puzzles: resync with upstream

This brings the code to upstream commit 3ece3d6 (I've made my own Rockbox-
specific changes on top of that).

Changes include using C99 `bool' throughout, and minor logic fixes for some
puzzles.

Change-Id: Ie823e73ae49a8ee1de411d6d406df2ba835af541

116 files changed, 8845 insertions, 8423 deletions

diff --git a/apps/plugins/puzzles/README.rockbox b/apps/plugins/puzzles/README.rockbox
index 15bc550331..c69c4da50d 100644
--- a/apps/plugins/puzzles/README.rockbox
+++ b/apps/plugins/puzzles/README.rockbox
@@ -54,3 +54,5 @@ halibut.
 
 April 2018: Finished up the rest of the games. All work now! Surely
 there's still bugs to fix, so stay tuned...
+
+December 2018: Resync to 3ece3d6. Happy holidays!
diff --git a/apps/plugins/puzzles/help/blackbox.c b/apps/plugins/puzzles/help/blackbox.c
index f67ee28e62..938810a19f 100644
--- a/apps/plugins/puzzles/help/blackbox.c
+++ b/apps/plugins/puzzles/help/blackbox.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -19,7 +19,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 5458 comp 3139 ratio 0.575119 level 11 saved 2319 */
+/* orig 5458 comp 3139 ratio 0.575119 level 10 saved 2319 */
 const char help_text[] = {
 0xf0, 0x37, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x39, 0x3a, 0x20, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x20,
@@ -28,15 +28,15 @@ const char help_text[] = {
 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x61, 0x72, 0x65, 0x00, 0x68,
 0x69, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x69, 0x6e, 0x00, 0x61,
 0x00, 0x72, 0x65, 0x63, 0x74, 0x61, 0x6e, 0x67, 0x75, 0x6c,
-0x61, 0x72, 0x1c, 0x00, 0xf0, 0x18, 0x6e, 0x61, 0x2e, 0x00,
+0x61, 0x72, 0x1c, 0x00, 0xf0, 0x15, 0x6e, 0x61, 0x2e, 0x00,
 0x59, 0x6f, 0x75, 0x00, 0x68, 0x61, 0x76, 0x65, 0x00, 0x74,
 0x6f, 0x00, 0x64, 0x65, 0x64, 0x75, 0x63, 0x65, 0x00, 0x74,
 0x68, 0x65, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
-0x6e, 0x73, 0x00, 0x6f, 0x66, 0x11, 0x00, 0x03, 0x51, 0x00,
+0x6e, 0x73, 0x4d, 0x00, 0x00, 0x11, 0x00, 0x02, 0x51, 0x00,
 0xf5, 0x01, 0x62, 0x79, 0x00, 0x66, 0x69, 0x72, 0x69, 0x6e,
 0x67, 0x00, 0x6c, 0x61, 0x73, 0x65, 0x72, 0x73, 0x28, 0x00,
-0x51, 0x65, 0x64, 0x00, 0x61, 0x74, 0x29, 0x00, 0x44, 0x65,
-0x64, 0x67, 0x65, 0x36, 0x00, 0x02, 0x65, 0x00, 0xb0, 0x00,
+0x51, 0x65, 0x64, 0x00, 0x61, 0x74, 0x29, 0x00, 0x45, 0x65,
+0x64, 0x67, 0x65, 0x36, 0x00, 0x01, 0x65, 0x00, 0xb0, 0x00,
 0x61, 0x6e, 0x64, 0x00, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76,
 0x3a, 0x00, 0x30, 0x68, 0x6f, 0x77, 0x1c, 0x00, 0x72, 0x69,
 0x72, 0x00, 0x62, 0x65, 0x61, 0x6d, 0xa5, 0x00, 0xe1, 0x64,
@@ -52,289 +52,289 @@ const char help_text[] = {
 0x68, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x38, 0x00, 0xf1,
 0x04, 0x65, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x29, 0x2c, 0x00,
 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x61, 0x66, 0x66,
-0x8c, 0x00, 0x32, 0x00, 0x62, 0x79, 0xf7, 0x00, 0x00, 0x3d,
-0x01, 0x25, 0x6f, 0x6e, 0x4b, 0x00, 0x60, 0x66, 0x6f, 0x6c,
-0x6c, 0x6f, 0x77, 0xcb, 0x00, 0xb0, 0x77, 0x61, 0x79, 0x73,
-0x3a, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x41, 0xcd, 0x00, 0x00,
-0x9b, 0x00, 0x20, 0x61, 0x74, 0x88, 0x00, 0x31, 0x73, 0x00,
-0x61, 0x3b, 0x00, 0xf0, 0x05, 0x00, 0x68, 0x65, 0x61, 0x64,
+0x8c, 0x00, 0x00, 0xee, 0x00, 0x02, 0xf7, 0x00, 0x55, 0x69,
+0x6e, 0x00, 0x6f, 0x6e, 0x4b, 0x00, 0x60, 0x66, 0x6f, 0x6c,
+0x6c, 0x6f, 0x77, 0xcb, 0x00, 0xb1, 0x77, 0x61, 0x79, 0x73,
+0x3a, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x41, 0xcd, 0x00, 0x50,
+0x00, 0x74, 0x68, 0x61, 0x74, 0x88, 0x00, 0x31, 0x73, 0x00,
+0x61, 0x3b, 0x00, 0xf1, 0x05, 0x00, 0x68, 0x65, 0x61, 0x64,
 0x2d, 0x6f, 0x6e, 0x00, 0x69, 0x73, 0x00, 0x61, 0x62, 0x73,
-0x6f, 0x72, 0x62, 0x65, 0x64, 0x0f, 0x01, 0x02, 0xde, 0x00,
+0x6f, 0x72, 0x62, 0x65, 0x64, 0x0f, 0x01, 0x01, 0xde, 0x00,
 0x93, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x00, 0x72, 0x65, 0x2d,
 0x83, 0x00, 0x50, 0x2e, 0x00, 0x54, 0x68, 0x69, 0x6e, 0x00,
-0x62, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x01, 0x02,
+0x63, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x01, 0x01,
 0x54, 0x00, 0x44, 0x6d, 0x65, 0x65, 0x74, 0x54, 0x00, 0x22,
 0x6f, 0x6e, 0x87, 0x00, 0x99, 0x69, 0x72, 0x73, 0x74, 0x00,
 0x72, 0x61, 0x6e, 0x6b, 0xe4, 0x00, 0x18, 0x2e, 0x90, 0x00,
-0x43, 0x77, 0x69, 0x74, 0x68, 0x37, 0x00, 0x00, 0xc5, 0x00,
-0x30, 0x69, 0x74, 0x73, 0x43, 0x01, 0xe1, 0x6e, 0x74, 0x2d,
-0x6c, 0x65, 0x66, 0x74, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72,
-0x65, 0x90, 0x00, 0x22, 0x6e, 0x6f, 0x25, 0x00, 0x10, 0x61,
+0x44, 0x77, 0x69, 0x74, 0x68, 0x37, 0x00, 0x30, 0x69, 0x6e,
+0x00, 0x99, 0x00, 0xe0, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x2d,
+0x6c, 0x65, 0x66, 0x74, 0x00, 0x73, 0x71, 0x75, 0x7d, 0x01,
+0x00, 0x90, 0x00, 0x22, 0x6e, 0x6f, 0x25, 0x00, 0x10, 0x61,
 0xb1, 0x00, 0x00, 0x50, 0x00, 0x76, 0x69, 0x74, 0x00, 0x67,
-0x65, 0x74, 0x73, 0x9a, 0x01, 0xe1, 0x00, 0x39, 0x30, 0x00,
-0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x73, 0x00, 0x74, 0x6f,
+0x65, 0x74, 0x73, 0x9a, 0x01, 0xb0, 0x00, 0x39, 0x30, 0x00,
+0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x73, 0x2c, 0x02, 0x00,
 0x70, 0x00, 0x10, 0x72, 0x94, 0x01, 0x0f, 0x70, 0x00, 0x13,
-0x00, 0x2b, 0x00, 0x0f, 0x71, 0x00, 0x13, 0x96, 0x73, 0x69,
-0x6d, 0x69, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x7b, 0x00, 0x04,
+0x01, 0x2b, 0x00, 0x0f, 0x71, 0x00, 0x12, 0x97, 0x73, 0x69,
+0x6d, 0x69, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x7b, 0x00, 0x03,
 0x70, 0x00, 0x00, 0xb5, 0x00, 0x1d, 0x2e, 0x6f, 0x01, 0x50,
 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x46, 0x01, 0x02, 0x45, 0x01,
-0x01, 0x24, 0x02, 0x01, 0x7a, 0x00, 0xc2, 0x65, 0x6e, 0x74,
+0x02, 0x24, 0x02, 0x00, 0x7a, 0x00, 0xc2, 0x65, 0x6e, 0x74,
 0x72, 0x79, 0x00, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x83,
 0x01, 0x30, 0x63, 0x6f, 0x6e, 0x14, 0x02, 0x12, 0x72, 0x53,
-0x00, 0x54, 0x62, 0x65, 0x00, 0x60, 0x72, 0x64, 0x00, 0x18,
-0x27, 0x59, 0x00, 0x02, 0x24, 0x02, 0x02, 0x5a, 0x00, 0x00,
-0x96, 0x00, 0x07, 0x8b, 0x00, 0x60, 0x62, 0x65, 0x66, 0x6f,
-0x72, 0x65, 0x5c, 0x00, 0x10, 0x65, 0x08, 0x03, 0x07, 0x5c,
-0x02, 0x23, 0x62, 0x79, 0xfa, 0x00, 0x03, 0xaf, 0x00, 0x08,
-0x6a, 0x01, 0x29, 0x6f, 0x72, 0x08, 0x01, 0x26, 0x6f, 0x66,
-0xa1, 0x00, 0x02, 0x8a, 0x02, 0x01, 0x21, 0x02, 0x3f, 0x6c,
-0x73, 0x6f, 0xa3, 0x00, 0x0e, 0x15, 0x42, 0x14, 0x02, 0x01,
-0x39, 0x03, 0x15, 0x72, 0x99, 0x00, 0x40, 0x61, 0x70, 0x70,
-0x65, 0xd7, 0x03, 0x00, 0x7b, 0x02, 0x42, 0x60, 0x52, 0x27,
-0x3b, 0x3e, 0x02, 0x05, 0x92, 0x02, 0x02, 0xca, 0x02, 0x02,
-0x90, 0x02, 0x37, 0x00, 0x6f, 0x6e, 0x2f, 0x00, 0xf3, 0x02,
+0x00, 0x54, 0x62, 0x65, 0x00, 0x60, 0x72, 0x64, 0x00, 0x1a,
+0x27, 0xc8, 0x00, 0x01, 0x24, 0x02, 0x02, 0x5a, 0x00, 0x37,
+0x67, 0x65, 0x74, 0x8b, 0x00, 0x60, 0x62, 0x65, 0x66, 0x6f,
+0x72, 0x65, 0x5c, 0x00, 0x11, 0x65, 0x08, 0x03, 0x06, 0x5c,
+0x02, 0x24, 0x62, 0x79, 0xfa, 0x00, 0x03, 0xaf, 0x00, 0x07,
+0x6a, 0x01, 0x29, 0x6f, 0x72, 0x08, 0x01, 0x27, 0x6f, 0x66,
+0xa1, 0x00, 0x02, 0x8a, 0x02, 0x00, 0x21, 0x02, 0x3f, 0x6c,
+0x73, 0x6f, 0xa3, 0x00, 0x0e, 0x16, 0x42, 0x14, 0x02, 0x00,
+0x4b, 0x01, 0x15, 0x72, 0x99, 0x00, 0x40, 0x61, 0x70, 0x70,
+0x65, 0xd7, 0x03, 0x00, 0x7b, 0x02, 0x48, 0x60, 0x52, 0x27,
+0x3b, 0x3e, 0x02, 0x00, 0x1a, 0x03, 0x02, 0xca, 0x02, 0x01,
+0x90, 0x02, 0x00, 0x42, 0x02, 0x06, 0x2f, 0x00, 0xf4, 0x02,
 0x60, 0x48, 0x27, 0x2e, 0x00, 0x4f, 0x74, 0x68, 0x65, 0x72,
-0x77, 0x69, 0x73, 0x65, 0x2c, 0x00, 0x61, 0x47, 0x04, 0x03,
-0x23, 0x00, 0x13, 0x73, 0xd9, 0x03, 0x03, 0xf9, 0x03, 0x02,
-0xaf, 0x00, 0x00, 0xc3, 0x01, 0x00, 0x15, 0x00, 0x06, 0x5e,
-0x01, 0x41, 0x77, 0x68, 0x65, 0x72, 0x3b, 0x04, 0x01, 0x78,
-0x00, 0x03, 0xd1, 0x02, 0x73, 0x73, 0x00, 0x28, 0x74, 0x68,
-0x69, 0x73, 0x51, 0x00, 0x00, 0xe4, 0x00, 0x50, 0x75, 0x6e,
-0x69, 0x71, 0x75, 0x6d, 0x04, 0x02, 0x99, 0x00, 0x81, 0x73,
-0x68, 0x6f, 0x74, 0x29, 0x2e, 0x00, 0x00, 0x87, 0x04, 0xf0,
+0x77, 0x69, 0x73, 0x65, 0x2c, 0x00, 0x61, 0x47, 0x04, 0x02,
+0x23, 0x00, 0x14, 0x73, 0xd9, 0x03, 0x03, 0xf9, 0x03, 0x02,
+0xaf, 0x00, 0x00, 0xc3, 0x01, 0x01, 0x93, 0x01, 0x04, 0x5e,
+0x01, 0x42, 0x77, 0x68, 0x65, 0x72, 0x3b, 0x04, 0x01, 0x41,
+0x01, 0x02, 0x8c, 0x01, 0x40, 0x73, 0x00, 0x28, 0x74, 0xd2,
+0x02, 0x03, 0x51, 0x00, 0x81, 0x69, 0x73, 0x00, 0x75, 0x6e,
+0x69, 0x71, 0x75, 0x6d, 0x04, 0x01, 0x99, 0x00, 0x50, 0x73,
+0x68, 0x6f, 0x74, 0x29, 0xd7, 0x00, 0x00, 0x87, 0x04, 0xf5,
 0x04, 0x63, 0x61, 0x6e, 0x00, 0x70, 0x6c, 0x61, 0x63, 0x65,
 0x00, 0x67, 0x75, 0x65, 0x73, 0x73, 0x65, 0x73, 0x00, 0x61,
-0x6b, 0x02, 0x09, 0x68, 0x00, 0x09, 0x8f, 0x04, 0x73, 0x2c,
+0x6b, 0x02, 0x05, 0x68, 0x00, 0x08, 0x8f, 0x04, 0x74, 0x2c,
 0x00, 0x62, 0x61, 0x73, 0x65, 0x64, 0x11, 0x03, 0x02, 0x4f,
-0x01, 0x01, 0x9a, 0x00, 0xb5, 0x65, 0x78, 0x69, 0x74, 0x00,
-0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0xc2, 0x04, 0x02, 0x10,
-0x01, 0x83, 0x3b, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x00, 0x79,
-0xf6, 0x04, 0x02, 0x70, 0x00, 0x84, 0x64, 0x00, 0x65, 0x6e,
+0x01, 0x00, 0x9a, 0x00, 0xb7, 0x65, 0x78, 0x69, 0x74, 0x00,
+0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0xc2, 0x04, 0x00, 0x10,
+0x01, 0x84, 0x3b, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x00, 0x79,
+0xf6, 0x04, 0x01, 0x70, 0x00, 0x84, 0x64, 0x00, 0x65, 0x6e,
 0x6f, 0x75, 0x67, 0x68, 0x36, 0x05, 0x55, 0x00, 0x62, 0x75,
-0x74, 0x74, 0x24, 0x01, 0x00, 0xa8, 0x01, 0x61, 0x61, 0x62,
-0x6c, 0x69, 0x6e, 0x67, 0x37, 0x00, 0x20, 0x74, 0x6f, 0x3a,
-0x00, 0x01, 0x43, 0x00, 0x15, 0x72, 0xa9, 0x00, 0x52, 0x63,
+0x74, 0x74, 0x24, 0x01, 0x00, 0xa8, 0x01, 0x30, 0x61, 0x62,
+0x6c, 0xfc, 0x00, 0x00, 0x37, 0x00, 0x22, 0x74, 0x6f, 0x3a,
+0x00, 0x45, 0x79, 0x6f, 0x75, 0x72, 0xa9, 0x00, 0x52, 0x63,
 0x68, 0x65, 0x63, 0x6b, 0xbe, 0x04, 0x10, 0x48, 0x08, 0x01,
 0x10, 0x69, 0x46, 0x00, 0x70, 0x64, 0x69, 0x61, 0x67, 0x72,
-0x61, 0x6d, 0xe5, 0x00, 0x13, 0x77, 0xf9, 0x04, 0x0a, 0x5c,
-0x05, 0x05, 0xa9, 0x05, 0x01, 0xfb, 0x00, 0xb8, 0x63, 0x72,
+0x61, 0x6d, 0xe5, 0x00, 0x17, 0x77, 0xf9, 0x04, 0x0a, 0x5c,
+0x05, 0x02, 0x73, 0x00, 0x00, 0xfb, 0x00, 0xb8, 0x63, 0x72,
 0x65, 0x61, 0x74, 0x65, 0x00, 0x65, 0x61, 0x63, 0x68, 0xb3,
 0x00, 0xb1, 0x00, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f,
 0x75, 0x72, 0x73, 0x4a, 0x00, 0x70, 0x6e, 0x00, 0x61, 0x62,
 0x6f, 0x76, 0x65, 0x77, 0x04, 0xf3, 0x09, 0x31, 0x52, 0x48,
 0x52, 0x2d, 0x2d, 0x2d, 0x2d, 0x00, 0x00, 0x7c, 0x2e, 0x2e,
 0x4f, 0x2e, 0x4f, 0x2e, 0x2e, 0x2e, 0x7c, 0x00, 0x00, 0x32,
-0x2e, 0x01, 0x00, 0x44, 0x33, 0x00, 0x00, 0x7c, 0x0c, 0x00,
+0x2e, 0x01, 0x00, 0x11, 0x33, 0x18, 0x00, 0x02, 0x01, 0x00,
 0x1a, 0x7c, 0x0c, 0x00, 0x1e, 0x33, 0x18, 0x00, 0x10, 0x4f,
 0x0c, 0x00, 0x1d, 0x48, 0x18, 0x00, 0x11, 0x4f, 0x0c, 0x00,
-0x50, 0x31, 0x32, 0x2d, 0x52, 0x52, 0x6a, 0x00, 0x00, 0x67,
-0x06, 0x03, 0x88, 0x00, 0x10, 0x2c, 0xb3, 0x03, 0x11, 0x69,
+0x51, 0x31, 0x32, 0x2d, 0x52, 0x52, 0x6a, 0x00, 0x33, 0x00,
+0x00, 0x41, 0x88, 0x00, 0x10, 0x2c, 0xb3, 0x03, 0x11, 0x69,
 0x03, 0x06, 0x40, 0x73, 0x69, 0x62, 0x6c, 0x18, 0x05, 0x33,
-0x72, 0x00, 0x61, 0x99, 0x03, 0x10, 0x6f, 0x6c, 0x06, 0xc4,
+0x72, 0x00, 0x61, 0x99, 0x03, 0x10, 0x6f, 0x6c, 0x06, 0xc5,
 0x65, 0x69, 0x76, 0x65, 0x00, 0x6d, 0x75, 0x6c, 0x74, 0x69,
 0x70, 0x6c, 0xab, 0x02, 0x01, 0xf9, 0x00, 0x03, 0x46, 0x03,
-0x05, 0xb5, 0x03, 0x00, 0x1e, 0x01, 0xf4, 0x00, 0x28, 0x73,
+0x04, 0xb5, 0x03, 0x00, 0x1e, 0x01, 0xf4, 0x00, 0x28, 0x73,
 0x65, 0x65, 0x00, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x33, 0x29,
 0x2e, 0x00, 0x53, 0x06, 0x04, 0x14, 0x2c, 0x53, 0x00, 0x58,
 0x6d, 0x61, 0x79, 0x00, 0x62, 0xf1, 0x02, 0x13, 0x28, 0x79,
 0x00, 0x41, 0x79, 0x00, 0x6d, 0x6f, 0x7b, 0x02, 0x21, 0x61,
-0x6e, 0xdd, 0x01, 0x13, 0x29, 0x5e, 0x00, 0x02, 0x82, 0x00,
-0x01, 0x73, 0x06, 0x10, 0x61, 0x02, 0x03, 0x00, 0x8c, 0x02,
-0x10, 0x65, 0xee, 0x02, 0x35, 0x00, 0x6f, 0x6e, 0x4f, 0x04,
-0x09, 0x24, 0x06, 0x71, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c,
+0x6e, 0xdd, 0x01, 0x16, 0x29, 0x5e, 0x00, 0x00, 0x82, 0x00,
+0x00, 0x5c, 0x00, 0x11, 0x61, 0x02, 0x03, 0x10, 0x28, 0x53,
+0x01, 0x34, 0x60, 0x48, 0x27, 0x30, 0x02, 0x02, 0x04, 0x05,
+0x07, 0x24, 0x06, 0x71, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c,
 0x65, 0x91, 0x02, 0x43, 0x4e, 0x6f, 0x74, 0x65, 0x67, 0x03,
-0x91, 0x6e, 0x79, 0x00, 0x6c, 0x61, 0x79, 0x6f, 0x75, 0x74,
-0xdf, 0x04, 0x07, 0x6e, 0x00, 0x12, 0x34, 0xbe, 0x01, 0x00,
-0x9b, 0x00, 0x01, 0x14, 0x02, 0x00, 0x3b, 0x03, 0x33, 0x6f,
+0x92, 0x6e, 0x79, 0x00, 0x6c, 0x61, 0x79, 0x6f, 0x75, 0x74,
+0xdf, 0x04, 0x06, 0x6e, 0x00, 0x13, 0x34, 0xbe, 0x01, 0x00,
+0x9b, 0x00, 0x01, 0x14, 0x02, 0x63, 0x61, 0x00, 0x6e, 0x6f,
 0x6e, 0x2d, 0xe4, 0x02, 0x40, 0x73, 0x6f, 0x6c, 0x75, 0xee,
-0x00, 0x38, 0x2e, 0x00, 0x54, 0x35, 0x06, 0x05, 0x17, 0x02,
-0x40, 0x69, 0x6c, 0x6c, 0x75, 0xd9, 0x06, 0x40, 0x74, 0x65,
-0x73, 0x00, 0x26, 0x03, 0x41, 0x3b, 0x00, 0x69, 0x66, 0x62,
+0x00, 0x00, 0xd6, 0x05, 0x08, 0x35, 0x06, 0x04, 0x17, 0x02,
+0x40, 0x69, 0x6c, 0x6c, 0x75, 0xd9, 0x06, 0x20, 0x74, 0x65,
+0xa6, 0x03, 0x61, 0x69, 0x73, 0x3b, 0x00, 0x69, 0x66, 0x62,
 0x02, 0x23, 0x6b, 0x6e, 0x29, 0x02, 0x50, 0x62, 0x6f, 0x61,
-0x72, 0x64, 0x12, 0x04, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x73,
-0x00, 0x35, 0x6f, 0x00, 0x04, 0x78, 0x01, 0x23, 0x69, 0x6d,
-0x01, 0x01, 0x03, 0xbc, 0x07, 0x77, 0x74, 0x65, 0x72, 0x6d,
+0x72, 0x64, 0x12, 0x04, 0x74, 0x74, 0x61, 0x69, 0x6e, 0x73,
+0x00, 0x35, 0xf6, 0x02, 0x02, 0x78, 0x01, 0x25, 0x69, 0x6d,
+0x7a, 0x01, 0x01, 0xbc, 0x07, 0x77, 0x74, 0x65, 0x72, 0x6d,
 0x69, 0x6e, 0x65, 0x8a, 0x03, 0x53, 0x66, 0x69, 0x66, 0x74,
 0x68, 0x8d, 0x05, 0x15, 0x73, 0x30, 0x01, 0x08, 0x81, 0x02,
 0x63, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x64, 0xb7, 0x05, 0x41,
 0x6e, 0x00, 0x78, 0x29, 0xce, 0x06, 0x03, 0x01, 0x00, 0x0f,
 0x3f, 0x02, 0x07, 0x11, 0x7c, 0x18, 0x02, 0x15, 0x4f, 0x18,
-0x00, 0x3b, 0x78, 0x78, 0x2e, 0x0c, 0x00, 0x0e, 0x24, 0x00,
+0x00, 0x3e, 0x78, 0x78, 0x2e, 0x0c, 0x00, 0x0b, 0x24, 0x00,
 0x0e, 0x48, 0x00, 0x08, 0x6a, 0x00, 0x61, 0x00, 0x00, 0x46,
 0x6f, 0x72, 0x00, 0x2d, 0x04, 0x70, 0x72, 0x65, 0x61, 0x73,
-0x6f, 0x6e, 0x2c, 0xc8, 0x00, 0x10, 0x6e, 0x10, 0x01, 0x0f,
-0x6f, 0x03, 0x07, 0x11, 0x2c, 0xe6, 0x00, 0x41, 0x67, 0x61,
-0x6d, 0x65, 0x50, 0x07, 0x02, 0x17, 0x00, 0x01, 0xb5, 0x01,
-0x01, 0x2f, 0x00, 0x05, 0x82, 0x01, 0x40, 0x00, 0x70, 0x72,
-0x6f, 0xda, 0x08, 0xf0, 0x02, 0x73, 0x20, 0x74, 0x68, 0x65,
+0x6f, 0x6e, 0x2c, 0xc8, 0x00, 0x16, 0x6e, 0xa9, 0x03, 0x0f,
+0x6f, 0x03, 0x01, 0x11, 0x2c, 0xe6, 0x00, 0x42, 0x67, 0x61,
+0x6d, 0x65, 0x50, 0x07, 0x01, 0x17, 0x00, 0x02, 0xb5, 0x01,
+0x01, 0x2f, 0x00, 0x04, 0x82, 0x01, 0x40, 0x00, 0x70, 0x72,
+0x6f, 0xda, 0x08, 0xf2, 0x02, 0x73, 0x20, 0x74, 0x68, 0x65,
 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75,
-0x6c, 0x74, 0x62, 0x04, 0x01, 0x44, 0x00, 0xe0, 0x63, 0x6f,
-0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x27, 0x73, 0x2c, 0x00,
-0x72, 0x61, 0x0c, 0x05, 0x02, 0xe2, 0x01, 0x0e, 0x4c, 0x00,
-0x01, 0x7a, 0x01, 0x70, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63,
-0x61, 0xea, 0x05, 0x0b, 0x3f, 0x00, 0x61, 0x2e, 0x00, 0x53,
-0x6f, 0x00, 0x69, 0x60, 0x02, 0x01, 0xa8, 0x03, 0x05, 0x55,
-0x02, 0x11, 0x2c, 0xcb, 0x00, 0x11, 0x63, 0x52, 0x06, 0x3c,
-0x70, 0x75, 0x74, 0xa0, 0x01, 0x03, 0x68, 0x02, 0x29, 0x6f,
-0x66, 0xee, 0x04, 0x0e, 0xa1, 0x01, 0x10, 0x2c, 0xe0, 0x04,
-0x00, 0x4b, 0x00, 0x03, 0x9d, 0x06, 0x20, 0x73, 0x74, 0xf9,
-0x00, 0x30, 0x77, 0x69, 0x6e, 0xb4, 0x02, 0x01, 0x0e, 0x0a,
-0x81, 0x00, 0x42, 0x6f, 0x78, 0x00, 0x77, 0x61, 0x73, 0x38,
-0x02, 0x45, 0x72, 0x69, 0x62, 0x75, 0x41, 0x07, 0x01, 0x01,
-0x07, 0x13, 0x6c, 0x84, 0x03, 0x00, 0xaf, 0x06, 0xd0, 0x4a,
-0x61, 0x6d, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65,
-0x79, 0x2e, 0x50, 0x04, 0x37, 0x39, 0x2e, 0x31, 0x53, 0x0a,
-0x01, 0x41, 0x00, 0x30, 0x6f, 0x6c, 0x73, 0x5c, 0x0a, 0x50,
-0x54, 0x6f, 0x00, 0x66, 0x69, 0xbb, 0x07, 0x01, 0xf9, 0x09,
-0x02, 0xbb, 0x09, 0x11, 0x2c, 0x42, 0x03, 0x61, 0x2d, 0x63,
-0x6c, 0x69, 0x63, 0x6b, 0x60, 0x0a, 0x05, 0xe0, 0x07, 0x54,
-0x72, 0x6f, 0x75, 0x6e, 0x64, 0x0e, 0x0a, 0x0a, 0x83, 0x09,
-0x02, 0x0e, 0x03, 0x02, 0x7f, 0x01, 0x02, 0xe5, 0x09, 0x00,
-0xd6, 0x03, 0xf0, 0x09, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61,
-0x79, 0x65, 0x64, 0x00, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69,
-0x61, 0x74, 0x65, 0x6c, 0x79, 0x2e, 0x00, 0x43, 0x5b, 0x00,
-0x30, 0x69, 0x6e, 0x67, 0x40, 0x07, 0x75, 0x68, 0x6f, 0x6c,
-0x64, 0x69, 0x6e, 0x67, 0xba, 0x03, 0x04, 0xa5, 0x05, 0x18,
-0x6f, 0x9c, 0x09, 0x23, 0x73, 0x65, 0x84, 0x00, 0x03, 0x5b,
-0x00, 0x50, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x73, 0x07, 0x02,
-0xa7, 0x01, 0xb1, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x00,
-0x67, 0x6f, 0x00, 0x28, 0xac, 0x04, 0x30, 0x70, 0x72, 0x65,
-0x5a, 0x05, 0x71, 0x73, 0x00, 0x67, 0x6f, 0x29, 0x00, 0x74,
-0x7d, 0x07, 0x31, 0x66, 0x69, 0x72, 0x62, 0x0a, 0x01, 0x44,
-0x06, 0x02, 0xed, 0x06, 0x00, 0xd9, 0x04, 0x01, 0x0a, 0x02,
-0x02, 0xfc, 0x00, 0x40, 0x2c, 0x00, 0x69, 0x66, 0x1b, 0x06,
-0x81, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x1e,
-0x01, 0x02, 0x9b, 0x02, 0x0c, 0xab, 0x06, 0x03, 0x11, 0x08,
-0x08, 0x29, 0x01, 0x01, 0xcb, 0x01, 0x2a, 0x69, 0x6e, 0x1e,
-0x0b, 0x00, 0x28, 0x00, 0x01, 0xbc, 0x01, 0x52, 0x63, 0x69,
-0x72, 0x63, 0x6c, 0xce, 0x02, 0x03, 0x7e, 0x06, 0x01, 0x02,
-0x02, 0x02, 0xf8, 0x00, 0x03, 0x18, 0x07, 0x22, 0x3b, 0x00,
-0x49, 0x00, 0x52, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x6a, 0x05,
-0x46, 0x6d, 0x6f, 0x76, 0x65, 0x21, 0x00, 0x21, 0x65, 0x64,
-0x76, 0x00, 0x00, 0x99, 0x00, 0x15, 0x4c, 0x49, 0x02, 0x08,
-0x73, 0x00, 0x04, 0x4c, 0x05, 0x20, 0x6c, 0x6f, 0x46, 0x03,
-0x02, 0x49, 0x00, 0xb3, 0x73, 0x74, 0x00, 0x6d, 0x6f, 0x64,
-0x69, 0x66, 0x69, 0x63, 0x61, 0x1f, 0x02, 0x02, 0xdf, 0x09,
-0x33, 0x2d, 0x00, 0x63, 0x85, 0x01, 0x50, 0x3b, 0x00, 0x77,
-0x68, 0x6f, 0xc8, 0x05, 0x30, 0x6f, 0x77, 0x73, 0xb5, 0x00,
-0x00, 0x4d, 0x02, 0x43, 0x75, 0x6d, 0x6e, 0x73, 0x4e, 0x00,
-0x06, 0xb9, 0x09, 0x04, 0x58, 0x00, 0x0e, 0x43, 0x00, 0x03,
-0x86, 0x00, 0x02, 0x48, 0x01, 0x02, 0xaa, 0x01, 0x03, 0x27,
-0x03, 0x61, 0x2f, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x66, 0x01,
-0x03, 0x58, 0x00, 0x48, 0x2c, 0x00, 0x6f, 0x72, 0xf9, 0x09,
-0x14, 0x2f, 0x3b, 0x09, 0x01, 0x25, 0x00, 0x00, 0x86, 0x00,
-0x01, 0x7a, 0x01, 0x02, 0xd7, 0x01, 0x71, 0x73, 0x6f, 0x72,
-0x00, 0x6b, 0x65, 0x79, 0x8c, 0x00, 0x00, 0x48, 0x09, 0x01,
-0x3a, 0x09, 0x22, 0x75, 0x73, 0xfa, 0x02, 0x39, 0x6d, 0x6f,
-0x76, 0x94, 0x02, 0xb4, 0x67, 0x72, 0x69, 0x64, 0x2e, 0x00,
-0x50, 0x72, 0x65, 0x73, 0x73, 0x59, 0x01, 0x41, 0x45, 0x6e,
-0x74, 0x65, 0x42, 0x00, 0x01, 0x7b, 0x01, 0x0a, 0xeb, 0x02,
-0x00, 0x2a, 0x02, 0x20, 0x64, 0x64, 0xdc, 0x05, 0x21, 0x65,
-0x77, 0x59, 0x01, 0x14, 0x2d, 0xe2, 0x01, 0x02, 0x6f, 0x01,
-0x02, 0x93, 0x03, 0x14, 0x70, 0x4f, 0x00, 0x43, 0x53, 0x70,
-0x61, 0x63, 0xc2, 0x01, 0x20, 0x6c, 0x6f, 0xa7, 0x01, 0x60,
-0x00, 0x63, 0x65, 0x6c, 0x6c, 0x2c, 0xb1, 0x00, 0x00, 0xd3,
-0x00, 0x02, 0xde, 0x00, 0x01, 0xaf, 0x03, 0x10, 0x57, 0xe1,
-0x04, 0x11, 0x61, 0x67, 0x08, 0x40, 0x72, 0x6f, 0x70, 0x72,
-0xf5, 0x02, 0x0c, 0xc2, 0x0d, 0x02, 0xfc, 0x04, 0x44, 0x62,
-0x65, 0x65, 0x6e, 0xdb, 0x01, 0x15, 0x2c, 0x9f, 0x08, 0x08,
-0x26, 0x02, 0x04, 0xa4, 0x09, 0x32, 0x74, 0x6f, 0x70, 0x71,
-0x0a, 0x41, 0x63, 0x6f, 0x72, 0x6e, 0x48, 0x00, 0x05, 0xf2,
-0x00, 0x15, 0x3b, 0x86, 0x01, 0x02, 0x41, 0x01, 0x13, 0x28,
-0xcd, 0x06, 0x63, 0x75, 0x73, 0x65, 0x00, 0x6f, 0x72, 0x45,
-0x01, 0x17, 0x29, 0x49, 0x05, 0x09, 0x73, 0x05, 0x00, 0xb0,
-0x00, 0x11, 0x49, 0x9f, 0x06, 0x03, 0x7e, 0x02, 0x01, 0x4c,
-0x07, 0x01, 0x28, 0x00, 0x15, 0x27, 0x2f, 0x09, 0x28, 0x6e,
-0x64, 0x34, 0x00, 0x02, 0xda, 0x0d, 0x21, 0x6e, 0x6f, 0x8d,
-0x00, 0x00, 0x7a, 0x0e, 0x0b, 0xaf, 0x05, 0x01, 0x46, 0x08,
-0x00, 0x31, 0x00, 0x01, 0x17, 0x00, 0xe2, 0x6d, 0x69, 0x6e,
-0x69, 0x6d, 0x75, 0x6d, 0x00, 0x69, 0x6e, 0x66, 0x6f, 0x72,
-0x6d, 0x5f, 0x01, 0x92, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73,
-0x61, 0x72, 0x79, 0xe1, 0x06, 0x32, 0x6d, 0x6f, 0x6e, 0x30,
-0x07, 0x02, 0xcc, 0x04, 0x20, 0x74, 0x6f, 0x3d, 0x00, 0x42,
-0x2c, 0x00, 0x73, 0x6f, 0x97, 0x00, 0x00, 0xaf, 0x05, 0x22,
-0x72, 0x79, 0xce, 0x02, 0x13, 0x2e, 0xad, 0x00, 0x11, 0x72,
-0x47, 0x01, 0x05, 0xf1, 0x06, 0x05, 0x93, 0x00, 0x02, 0x67,
-0x0b, 0x42, 0x73, 0x74, 0x65, 0x6e, 0xd5, 0x07, 0x05, 0x6e,
-0x09, 0x00, 0x36, 0x0a, 0x21, 0x68, 0x73, 0x51, 0x00, 0x71,
-0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x8f, 0x07, 0x00,
-0xa5, 0x02, 0x67, 0x75, 0x74, 0x2c, 0x00, 0x6f, 0x6e, 0x27,
-0x00, 0x04, 0xbe, 0x04, 0x02, 0xb6, 0x03, 0x02, 0x6c, 0x02,
-0x64, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x3b, 0x08, 0x20,
-0x69, 0x74, 0x7b, 0x06, 0x32, 0x76, 0x65, 0x73, 0xb2, 0x05,
-0x45, 0x72, 0x6f, 0x6e, 0x67, 0x9a, 0x00, 0x09, 0x86, 0x07,
-0x74, 0x74, 0x63, 0x68, 0x00, 0x61, 0x6c, 0x6c, 0x79, 0x04,
-0x58, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x90, 0x00, 0x21, 0x62,
-0x75, 0xef, 0x0b, 0x02, 0xef, 0x05, 0x02, 0x49, 0x00, 0x01,
-0x8d, 0x00, 0x01, 0x94, 0x02, 0x0e, 0x91, 0x00, 0x60, 0x72,
-0x65, 0x76, 0x65, 0x61, 0x6c, 0x24, 0x09, 0x52, 0x77, 0x72,
-0x69, 0x74, 0x74, 0xff, 0x0f, 0x43, 0x72, 0x65, 0x64, 0x29,
-0xd9, 0x0c, 0x2f, 0x69, 0x73, 0x05, 0x01, 0x01, 0x01, 0x97,
-0x00, 0x05, 0x25, 0x05, 0x0e, 0xf9, 0x01, 0x51, 0x64, 0x65,
-0x63, 0x69, 0x64, 0x6d, 0x08, 0x10, 0x67, 0xd9, 0x09, 0x21,
-0x75, 0x70, 0xf8, 0x06, 0x20, 0x6c, 0x65, 0xac, 0x05, 0x15,
-0x2c, 0x84, 0x01, 0x20, 0x73, 0x65, 0x62, 0x06, 0x41, 0x00,
-0x53, 0x6f, 0x6c, 0x55, 0x10, 0x03, 0x8c, 0x00, 0x02, 0x7d,
-0x04, 0x5b, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x93, 0x01, 0x41,
-0x2e, 0x00, 0x41, 0x74, 0xd1, 0x01, 0x02, 0x6d, 0x05, 0x14,
-0x2c, 0x2e, 0x02, 0x32, 0x6c, 0x79, 0x2d, 0x9d, 0x0b, 0x02,
-0x0a, 0x03, 0x0e, 0x2b, 0x06, 0x00, 0xbc, 0x07, 0x69, 0x66,
-0x69, 0x6c, 0x6c, 0x65, 0x64, 0x3d, 0x05, 0x00, 0x20, 0x09,
-0x1f, 0x6e, 0x44, 0x00, 0x03, 0x0f, 0x32, 0x00, 0x05, 0x02,
-0xfe, 0x00, 0x00, 0x73, 0x0d, 0x63, 0x63, 0x72, 0x6f, 0x73,
-0x73, 0x65, 0xd3, 0x03, 0x21, 0x6d, 0x69, 0xd2, 0x03, 0x0c,
-0x3c, 0x00, 0x00, 0x29, 0x00, 0x04, 0x3a, 0x00, 0x40, 0x2e,
-0x00, 0x49, 0x6e, 0x1e, 0x04, 0x01, 0xcb, 0x00, 0x37, 0x2c,
-0x00, 0x61, 0x1c, 0x00, 0x01, 0xb9, 0x05, 0x10, 0x73, 0xd6,
-0x07, 0x02, 0x48, 0x04, 0x03, 0xcb, 0x08, 0x14, 0x64, 0x58,
-0x02, 0x01, 0x65, 0x04, 0x1f, 0x64, 0x91, 0x01, 0x0a, 0x06,
-0xc2, 0x02, 0x04, 0x81, 0x0a, 0x85, 0x28, 0x6a, 0x75, 0x73,
-0x74, 0x00, 0x61, 0x73, 0x1d, 0x09, 0x02, 0x78, 0x04, 0x0f,
-0x8e, 0x03, 0x00, 0x12, 0x29, 0xc4, 0x00, 0x01, 0x48, 0x0e,
-0x3c, 0x65, 0x78, 0x74, 0x8e, 0x00, 0x06, 0x8e, 0x08, 0x01,
-0x63, 0x04, 0x02, 0x8d, 0x00, 0x01, 0xe8, 0x10, 0x41, 0x72,
-0x64, 0x65, 0x72, 0x70, 0x03, 0x02, 0x86, 0x02, 0x3d, 0x75,
-0x69, 0x73, 0x88, 0x00, 0x06, 0x88, 0x11, 0x04, 0xad, 0x01,
-0x31, 0x00, 0x6f, 0x6e, 0x09, 0x07, 0x33, 0x28, 0x41, 0x6c,
-0xeb, 0x01, 0x03, 0xe9, 0x0b, 0x72, 0x64, 0x65, 0x73, 0x63,
-0x72, 0x69, 0x62, 0x5c, 0x00, 0x13, 0x73, 0x7b, 0x08, 0x30,
-0x32, 0x2e, 0x31, 0xce, 0x02, 0x02, 0xa9, 0x05, 0x51, 0x61,
-0x76, 0x61, 0x69, 0x6c, 0x49, 0x07, 0x12, 0x29, 0x83, 0x08,
-0x17, 0x32, 0x83, 0x08, 0x50, 0x70, 0x61, 0x72, 0x61, 0x6d,
-0xda, 0x0a, 0x02, 0x85, 0x08, 0x01, 0xe1, 0x07, 0x05, 0x14,
-0x00, 0x01, 0xce, 0x03, 0x06, 0x40, 0x00, 0x06, 0x95, 0x00,
-0xe2, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
-0x2e, 0x27, 0x00, 0x6f, 0x70, 0x8c, 0x07, 0x12, 0x6e, 0x1a,
-0x00, 0xa1, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65,
-0x6e, 0x75, 0x82, 0x05, 0x81, 0x69, 0x64, 0x74, 0x68, 0x2c,
-0x00, 0x48, 0x65, 0x5b, 0x06, 0x50, 0x00, 0x00, 0x53, 0x69,
-0x7a, 0x4a, 0x08, 0x00, 0x30, 0x05, 0x00, 0xb1, 0x00, 0x04,
-0x4c, 0x08, 0x01, 0xb4, 0x08, 0x21, 0x72, 0x65, 0x6f, 0x00,
-0x32, 0x32, 0x00, 0x78, 0x37, 0x00, 0x23, 0x00, 0x78, 0x38,
-0x00, 0x05, 0x0b, 0x13, 0x20, 0x65, 0x72, 0x39, 0x00, 0x00,
-0x96, 0x0a, 0x20, 0x77, 0x6f, 0x0e, 0x00, 0x00, 0xf3, 0x05,
-0x00, 0x85, 0x01, 0x03, 0x10, 0x00, 0x08, 0xfb, 0x05, 0x71,
-0x4e, 0x6f, 0x2e, 0x20, 0x6f, 0x66, 0x20, 0x5a, 0x02, 0x00,
-0x0f, 0x00, 0x0b, 0xf6, 0x05, 0x23, 0x74, 0x6f, 0x09, 0x0f,
-0x25, 0x69, 0x6e, 0xc0, 0x05, 0x01, 0x1d, 0x12, 0x02, 0x2a,
-0x0e, 0x10, 0x62, 0x9d, 0x06, 0x00, 0x9b, 0x02, 0x14, 0x6c,
-0x31, 0x06, 0x11, 0x2c, 0xa6, 0x06, 0x00, 0x0d, 0x12, 0x20,
-0x67, 0x65, 0x4a, 0x0d, 0x00, 0x24, 0x01, 0x15, 0x74, 0x38,
-0x0a, 0xf2, 0x04, 0x00, 0x68, 0x79, 0x70, 0x68, 0x65, 0x6e,
-0x2c, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x60, 0x32, 0x2d,
-0x36, 0x27, 0x1f, 0x02, 0x06, 0x36, 0x0c, 0x02, 0x43, 0x02,
-0x1f, 0x6e, 0x88, 0x00, 0x05, 0x19, 0x6f, 0x88, 0x00, 0x00,
-0x49, 0x01, 0x02, 0xd7, 0x03, 0x02, 0x6e, 0x02, 0x02, 0x16,
-0x0b, 0x42, 0x6f, 0x6e, 0x6c, 0x79, 0x2b, 0x0f, 0x00, 0xee,
-0x01, 0x14, 0x66, 0xbb, 0x0b, 0x05, 0x95, 0x08, 0x0f, 0xeb,
-0x06, 0x0c, 0x33, 0x3b, 0x00, 0x61, 0x45, 0x09, 0x10, 0x75,
-0xdb, 0x00, 0x01, 0x40, 0x0f, 0x30, 0x66, 0x66, 0x65, 0x8c,
-0x04, 0x02, 0x2b, 0x00, 0x04, 0x0e, 0x08, 0x03, 0xfa, 0x13,
-0x28, 0x61, 0x6c, 0x94, 0x0b, 0x03, 0x1a, 0x05, 0x60, 0x61,
-0x63, 0x63, 0x65, 0x70, 0x74, 0x83, 0x00, 0x02, 0xa6, 0x09,
-0x26, 0x6c, 0x6c, 0xda, 0x05, 0x62, 0x69, 0x6e, 0x70, 0x75,
-0x74, 0x73, 0x8d, 0x14, 0xe0, 0x75, 0x74, 0x70, 0x75, 0x74,
-0x73, 0x00, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x00,
+0x6c, 0x74, 0x62, 0x04, 0xf0, 0x02, 0x68, 0x65, 0x00, 0x63,
+0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x27, 0x73, 0x2c,
+0x00, 0x72, 0x61, 0x0c, 0x05, 0x02, 0xe2, 0x01, 0x0e, 0x4c,
+0x00, 0x01, 0x7a, 0x01, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x69,
+0x63, 0x61, 0xea, 0x05, 0x06, 0x3f, 0x00, 0x62, 0x2e, 0x00,
+0x53, 0x6f, 0x00, 0x69, 0x60, 0x02, 0x01, 0xa8, 0x03, 0x04,
+0x55, 0x02, 0x11, 0x2c, 0xcb, 0x00, 0x11, 0x63, 0x52, 0x06,
+0x3c, 0x70, 0x75, 0x74, 0xa0, 0x01, 0x03, 0x68, 0x02, 0x29,
+0x6f, 0x66, 0xee, 0x04, 0x0e, 0xa1, 0x01, 0x11, 0x2c, 0xe0,
+0x04, 0x00, 0x4b, 0x00, 0x02, 0x9d, 0x06, 0x20, 0x73, 0x74,
+0xf9, 0x00, 0x31, 0x77, 0x69, 0x6e, 0x1c, 0x06, 0x00, 0x0e,
+0x0a, 0x81, 0x00, 0x42, 0x6f, 0x78, 0x00, 0x77, 0x61, 0x73,
+0x38, 0x02, 0x45, 0x72, 0x69, 0x62, 0x75, 0x41, 0x07, 0x01,
+0x01, 0x07, 0x13, 0x6c, 0x84, 0x03, 0x00, 0xaf, 0x06, 0xd0,
+0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x76,
+0x65, 0x79, 0x2e, 0x50, 0x04, 0x37, 0x39, 0x2e, 0x31, 0x53,
+0x0a, 0x01, 0x41, 0x00, 0x30, 0x6f, 0x6c, 0x73, 0x5c, 0x0a,
+0x20, 0x54, 0x6f, 0x00, 0x06, 0x00, 0xe2, 0x02, 0x01, 0xf9,
+0x09, 0x01, 0x93, 0x03, 0x11, 0x2c, 0x42, 0x03, 0x62, 0x2d,
+0x63, 0x6c, 0x69, 0x63, 0x6b, 0x60, 0x0a, 0x04, 0xe0, 0x07,
+0x55, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x0e, 0x0a, 0x0b, 0x9f,
+0x08, 0x00, 0x0e, 0x03, 0x04, 0x7f, 0x01, 0x01, 0xb7, 0x01,
+0xf0, 0x0c, 0x62, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70, 0x6c,
+0x61, 0x79, 0x65, 0x64, 0x00, 0x69, 0x6d, 0x6d, 0x65, 0x64,
+0x69, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x2e, 0x00, 0x43, 0x5b,
+0x00, 0x00, 0x34, 0x03, 0x74, 0x6f, 0x72, 0x00, 0x68, 0x6f,
+0x6c, 0x64, 0x71, 0x07, 0x01, 0xba, 0x03, 0x03, 0xa5, 0x05,
+0x18, 0x6f, 0x9c, 0x09, 0x23, 0x73, 0x65, 0x84, 0x00, 0x03,
+0x5b, 0x00, 0x51, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x73, 0x07,
+0x01, 0xa7, 0x01, 0xb1, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+0x00, 0x67, 0x6f, 0x00, 0x28, 0xac, 0x04, 0x30, 0x70, 0x72,
+0x65, 0x5a, 0x05, 0x71, 0x73, 0x00, 0x67, 0x6f, 0x29, 0x00,
+0x74, 0x7d, 0x07, 0x31, 0x66, 0x69, 0x72, 0x62, 0x0a, 0x03,
+0x44, 0x06, 0x01, 0xed, 0x06, 0x00, 0xd9, 0x04, 0x01, 0x0a,
+0x02, 0x01, 0xfc, 0x00, 0x10, 0x2c, 0xa8, 0x03, 0xb2, 0x61,
+0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e,
+0x1e, 0x01, 0x01, 0x9b, 0x02, 0x0d, 0xab, 0x06, 0x02, 0x11,
+0x08, 0x09, 0x29, 0x01, 0x00, 0xcb, 0x01, 0x2b, 0x69, 0x6e,
+0x1e, 0x0b, 0x31, 0x61, 0x00, 0x62, 0xbc, 0x01, 0x53, 0x63,
+0x69, 0x72, 0x63, 0x6c, 0xce, 0x02, 0x03, 0xa2, 0x07, 0x00,
+0x02, 0x02, 0x04, 0xf8, 0x00, 0x01, 0x65, 0x00, 0x22, 0x3b,
+0x00, 0x49, 0x00, 0x52, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x6a,
+0x05, 0x10, 0x6d, 0x69, 0x02, 0x05, 0x21, 0x00, 0x21, 0x65,
+0x64, 0x76, 0x00, 0x00, 0x99, 0x00, 0x15, 0x4c, 0x49, 0x02,
+0x09, 0x73, 0x00, 0x03, 0x4c, 0x05, 0x20, 0x6c, 0x6f, 0x46,
+0x03, 0x02, 0x49, 0x00, 0xb4, 0x73, 0x74, 0x00, 0x6d, 0x6f,
+0x64, 0x69, 0x66, 0x69, 0x63, 0x61, 0x1f, 0x02, 0x01, 0xac,
+0x08, 0x33, 0x2d, 0x00, 0x63, 0x85, 0x01, 0x50, 0x3b, 0x00,
+0x77, 0x68, 0x6f, 0xc8, 0x05, 0x31, 0x6f, 0x77, 0x73, 0xb5,
+0x00, 0x74, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x4e,
+0x00, 0x06, 0xb9, 0x09, 0x03, 0x58, 0x00, 0x0e, 0x43, 0x00,
+0x04, 0x86, 0x00, 0x02, 0x44, 0x02, 0x04, 0x2e, 0x02, 0x00,
+0x27, 0x03, 0x62, 0x2f, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x66,
+0x01, 0x02, 0x58, 0x00, 0x10, 0x2c, 0xf5, 0x01, 0x07, 0xf9,
+0x09, 0x15, 0x2f, 0x3b, 0x09, 0x01, 0x25, 0x00, 0x31, 0x72,
+0x6f, 0x77, 0x7a, 0x01, 0x02, 0xd7, 0x01, 0x72, 0x73, 0x6f,
+0x72, 0x00, 0x6b, 0x65, 0x79, 0x8c, 0x00, 0x01, 0x48, 0x09,
+0x52, 0x62, 0x65, 0x00, 0x75, 0x73, 0xfa, 0x02, 0x01, 0x1e,
+0x01, 0x07, 0x94, 0x02, 0xb4, 0x67, 0x72, 0x69, 0x64, 0x2e,
+0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x59, 0x01, 0x10, 0x45,
+0xcf, 0x09, 0x00, 0x42, 0x00, 0x02, 0x7b, 0x01, 0x09, 0xeb,
+0x02, 0x00, 0x2a, 0x02, 0x20, 0x64, 0x64, 0xdc, 0x05, 0x21,
+0x65, 0x77, 0x59, 0x01, 0x15, 0x2d, 0xe2, 0x01, 0x01, 0x6f,
+0x01, 0x02, 0x93, 0x03, 0x14, 0x70, 0x4f, 0x00, 0x43, 0x53,
+0x70, 0x61, 0x63, 0xc2, 0x01, 0x20, 0x6c, 0x6f, 0xa7, 0x01,
+0x30, 0x00, 0x63, 0x65, 0x03, 0x02, 0x31, 0x72, 0x6f, 0x77,
+0xd3, 0x00, 0x02, 0xde, 0x00, 0x00, 0xbc, 0x00, 0x10, 0x57,
+0xe1, 0x04, 0x11, 0x61, 0x67, 0x08, 0x40, 0x72, 0x6f, 0x70,
+0x72, 0xf5, 0x02, 0x0d, 0xc2, 0x0d, 0x01, 0xfc, 0x04, 0x44,
+0x62, 0x65, 0x65, 0x6e, 0xdb, 0x01, 0x16, 0x2c, 0x9f, 0x08,
+0x08, 0x26, 0x02, 0x03, 0xa4, 0x09, 0x32, 0x74, 0x6f, 0x70,
+0x71, 0x0a, 0x42, 0x63, 0x6f, 0x72, 0x6e, 0x48, 0x00, 0x04,
+0xf2, 0x00, 0x16, 0x3b, 0x86, 0x01, 0x01, 0x41, 0x01, 0x13,
+0x28, 0xcd, 0x06, 0x31, 0x75, 0x73, 0x65, 0x97, 0x00, 0x01,
+0x45, 0x01, 0x18, 0x29, 0x49, 0x05, 0x08, 0x73, 0x05, 0x00,
+0xb0, 0x00, 0x12, 0x49, 0x9f, 0x06, 0x02, 0x7e, 0x02, 0x01,
+0x4c, 0x07, 0x01, 0x28, 0x00, 0x15, 0x27, 0x2f, 0x09, 0x2a,
+0x6e, 0x64, 0xa7, 0x05, 0x00, 0xde, 0x01, 0x21, 0x6e, 0x6f,
+0x8d, 0x00, 0x00, 0x7a, 0x0e, 0x0c, 0xaf, 0x05, 0x00, 0x46,
+0x08, 0x02, 0x53, 0x09, 0xf2, 0x02, 0x68, 0x65, 0x00, 0x6d,
+0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x00, 0x69, 0x6e, 0x66,
+0x6f, 0x72, 0x6d, 0x5f, 0x01, 0x92, 0x6e, 0x65, 0x63, 0x65,
+0x73, 0x73, 0x61, 0x72, 0x79, 0xe1, 0x06, 0x32, 0x6d, 0x6f,
+0x6e, 0x30, 0x07, 0x02, 0xcc, 0x04, 0x20, 0x74, 0x6f, 0x3d,
+0x00, 0x31, 0x2c, 0x00, 0x73, 0x08, 0x00, 0x01, 0x43, 0x09,
+0x01, 0x00, 0x0a, 0x00, 0xce, 0x02, 0x13, 0x2e, 0xad, 0x00,
+0x12, 0x72, 0x5e, 0x05, 0x06, 0xf1, 0x06, 0x06, 0x93, 0x00,
+0x73, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0xd5, 0x07,
+0x05, 0x6e, 0x09, 0x51, 0x70, 0x61, 0x74, 0x68, 0x73, 0x51,
+0x00, 0x72, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x8f,
+0x07, 0x61, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x2c, 0x6a, 0x04,
+0x05, 0x27, 0x00, 0x05, 0xbe, 0x04, 0x02, 0xb6, 0x03, 0x01,
+0x6c, 0x02, 0x30, 0x69, 0x6e, 0x64, 0x42, 0x03, 0x03, 0x3b,
+0x08, 0x20, 0x69, 0x74, 0x7b, 0x06, 0x32, 0x76, 0x65, 0x73,
+0xb2, 0x05, 0x46, 0x72, 0x6f, 0x6e, 0x67, 0x9a, 0x00, 0x08,
+0x86, 0x07, 0x41, 0x74, 0x63, 0x68, 0x00, 0x3a, 0x0c, 0x02,
+0x79, 0x04, 0x20, 0x73, 0x74, 0xa7, 0x01, 0x07, 0x90, 0x00,
+0x22, 0x62, 0x75, 0xef, 0x0b, 0x03, 0xef, 0x05, 0x00, 0x49,
+0x00, 0x02, 0x8d, 0x00, 0x01, 0x94, 0x02, 0x0d, 0x91, 0x00,
+0x60, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x24, 0x09, 0x52,
+0x77, 0x72, 0x69, 0x74, 0x74, 0xff, 0x0f, 0x43, 0x72, 0x65,
+0x64, 0x29, 0xd9, 0x0c, 0x2f, 0x69, 0x73, 0x05, 0x01, 0x02,
+0x01, 0x97, 0x00, 0x05, 0x25, 0x05, 0x0d, 0xf9, 0x01, 0x51,
+0x64, 0x65, 0x63, 0x69, 0x64, 0x6d, 0x08, 0x10, 0x67, 0xd9,
+0x09, 0x21, 0x75, 0x70, 0xf8, 0x06, 0x20, 0x6c, 0x65, 0xac,
+0x05, 0x15, 0x2c, 0x84, 0x01, 0x20, 0x73, 0x65, 0x62, 0x06,
+0x42, 0x00, 0x53, 0x6f, 0x6c, 0x55, 0x10, 0x02, 0x8c, 0x00,
+0x02, 0x7d, 0x04, 0x5b, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x93,
+0x01, 0x42, 0x2e, 0x00, 0x41, 0x74, 0xd1, 0x01, 0x01, 0x6d,
+0x05, 0x14, 0x2c, 0x2e, 0x02, 0x33, 0x6c, 0x79, 0x2d, 0x9d,
+0x0b, 0x02, 0x0a, 0x03, 0x0e, 0x2b, 0x06, 0x60, 0x61, 0x73,
+0x00, 0x66, 0x69, 0x6c, 0xe7, 0x00, 0x08, 0x3d, 0x05, 0x00,
+0x20, 0x09, 0x1f, 0x6e, 0x44, 0x00, 0x04, 0x0f, 0x32, 0x00,
+0x04, 0x02, 0xfe, 0x00, 0x00, 0x73, 0x0d, 0x30, 0x63, 0x72,
+0x6f, 0xf5, 0x00, 0x02, 0xd3, 0x03, 0x22, 0x6d, 0x69, 0xd2,
+0x03, 0x0c, 0x3c, 0x00, 0x01, 0x29, 0x00, 0x02, 0x3a, 0x00,
+0x40, 0x2e, 0x00, 0x49, 0x6e, 0x1e, 0x04, 0x01, 0xcb, 0x00,
+0x00, 0x9b, 0x03, 0x06, 0x1c, 0x00, 0x01, 0xb9, 0x05, 0x13,
+0x73, 0x3e, 0x0a, 0x00, 0x48, 0x04, 0x02, 0xcb, 0x08, 0x15,
+0x64, 0x58, 0x02, 0x00, 0x65, 0x04, 0x1f, 0x64, 0x91, 0x01,
+0x10, 0x01, 0x2f, 0x01, 0x03, 0x81, 0x0a, 0x50, 0x28, 0x6a,
+0x75, 0x73, 0x74, 0x8b, 0x00, 0x05, 0x1d, 0x09, 0x01, 0x78,
+0x04, 0x0f, 0x8e, 0x03, 0x00, 0x12, 0x29, 0xc4, 0x00, 0x01,
+0x48, 0x0e, 0x3e, 0x65, 0x78, 0x74, 0x8e, 0x00, 0x05, 0x8e,
+0x08, 0x01, 0x63, 0x04, 0x02, 0x8d, 0x00, 0x00, 0xe8, 0x10,
+0x41, 0x72, 0x64, 0x65, 0x72, 0x70, 0x03, 0x02, 0x86, 0x02,
+0x3e, 0x75, 0x69, 0x73, 0x88, 0x00, 0x05, 0x88, 0x11, 0x04,
+0xad, 0x01, 0x00, 0x8c, 0x02, 0x00, 0x2a, 0x02, 0x35, 0x28,
+0x41, 0x6c, 0xeb, 0x01, 0x01, 0xdb, 0x02, 0x72, 0x64, 0x65,
+0x73, 0x63, 0x72, 0x69, 0x62, 0x5c, 0x00, 0x13, 0x73, 0x7b,
+0x08, 0x31, 0x32, 0x2e, 0x31, 0xce, 0x02, 0x01, 0xa9, 0x05,
+0x51, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x49, 0x07, 0x12, 0x29,
+0x83, 0x08, 0x17, 0x32, 0x83, 0x08, 0x50, 0x70, 0x61, 0x72,
+0x61, 0x6d, 0xda, 0x0a, 0x02, 0x85, 0x08, 0x01, 0xe1, 0x07,
+0x06, 0x14, 0x00, 0x02, 0x45, 0x00, 0x04, 0x40, 0x00, 0x06,
+0x95, 0x00, 0xe2, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
+0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x8c, 0x07, 0x12,
+0x6e, 0x1a, 0x00, 0xa1, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0x82, 0x05, 0x81, 0x69, 0x64, 0x74,
+0x68, 0x2c, 0x00, 0x48, 0x65, 0x5b, 0x06, 0x51, 0x00, 0x00,
+0x53, 0x69, 0x7a, 0x4a, 0x08, 0x00, 0x30, 0x05, 0x01, 0xb1,
+0x00, 0x02, 0x4c, 0x08, 0x01, 0xb4, 0x08, 0x21, 0x72, 0x65,
+0x6f, 0x00, 0x32, 0x32, 0x00, 0x78, 0x37, 0x00, 0x24, 0x00,
+0x78, 0x38, 0x00, 0x04, 0x0b, 0x13, 0x21, 0x65, 0x72, 0x39,
+0x00, 0x51, 0x2c, 0x00, 0x74, 0x77, 0x6f, 0x0e, 0x00, 0x32,
+0x72, 0x6f, 0x77, 0x29, 0x0f, 0x03, 0x10, 0x00, 0x06, 0xfb,
+0x05, 0x72, 0x4e, 0x6f, 0x2e, 0x20, 0x6f, 0x66, 0x20, 0x5a,
+0x02, 0x3b, 0x00, 0x00, 0x4e, 0xf6, 0x05, 0x23, 0x74, 0x6f,
+0x09, 0x0f, 0x27, 0x69, 0x6e, 0xb2, 0x06, 0x01, 0x1d, 0x12,
+0x00, 0x63, 0x03, 0x10, 0x62, 0x9d, 0x06, 0x00, 0x9b, 0x02,
+0x14, 0x6c, 0x31, 0x06, 0x11, 0x2c, 0xa6, 0x06, 0x00, 0x0d,
+0x12, 0x20, 0x67, 0x65, 0x4a, 0x0d, 0x00, 0x24, 0x01, 0x15,
+0x74, 0x38, 0x0a, 0xf3, 0x04, 0x00, 0x68, 0x79, 0x70, 0x68,
+0x65, 0x6e, 0x2c, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x60,
+0x32, 0x2d, 0x36, 0x27, 0x1f, 0x02, 0x05, 0x36, 0x0c, 0x02,
+0x43, 0x02, 0x1f, 0x6e, 0x88, 0x00, 0x05, 0x1a, 0x6f, 0x88,
+0x00, 0x01, 0x96, 0x10, 0x00, 0xd7, 0x03, 0x05, 0xfc, 0x05,
+0x72, 0x69, 0x73, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x2b, 0x0f,
+0x00, 0xee, 0x01, 0x16, 0x66, 0xbb, 0x0b, 0x04, 0x95, 0x08,
+0x0f, 0xeb, 0x06, 0x0b, 0x33, 0x3b, 0x00, 0x61, 0x45, 0x09,
+0x11, 0x75, 0x76, 0x03, 0x00, 0x40, 0x0f, 0x31, 0x66, 0x66,
+0x65, 0x8c, 0x04, 0x03, 0x2b, 0x00, 0x03, 0x0e, 0x08, 0x02,
+0xfa, 0x13, 0x29, 0x61, 0x6c, 0x94, 0x0b, 0x02, 0x1a, 0x05,
+0x60, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x83, 0x00, 0x02,
+0xa6, 0x09, 0x26, 0x6c, 0x6c, 0xda, 0x05, 0x62, 0x69, 0x6e,
+0x70, 0x75, 0x74, 0x73, 0x8d, 0x14, 0x21, 0x75, 0x74, 0x0c,
+0x00, 0x70, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 5458;
diff --git a/apps/plugins/puzzles/help/bridges.c b/apps/plugins/puzzles/help/bridges.c
index 97fc5c6ab0..ed901c1309 100644
--- a/apps/plugins/puzzles/help/bridges.c
+++ b/apps/plugins/puzzles/help/bridges.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -19,7 +19,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 5230 comp 3127 ratio 0.597897 level 11 saved 2103 */
+/* orig 5230 comp 3126 ratio 0.597706 level 10 saved 2104 */
 const char help_text[] = {
 0xf3, 0x4b, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x36, 0x3a, 0x20, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
@@ -34,7 +34,7 @@ const char help_text[] = {
 0x74, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x61, 0x00, 0x6e, 0x75,
 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x5e, 0x00, 0xb0, 0x72, 0x00,
 0x61, 0x69, 0x6d, 0x00, 0x69, 0x73, 0x00, 0x74, 0x6f, 0x22,
-0x00, 0x40, 0x6e, 0x65, 0x63, 0x74, 0x48, 0x00, 0x05, 0x67,
+0x00, 0x41, 0x6e, 0x65, 0x63, 0x74, 0x48, 0x00, 0x04, 0x67,
 0x00, 0xf2, 0x00, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65,
 0x72, 0x00, 0x77, 0x69, 0x74, 0x68, 0x00, 0x62, 0x9a, 0x00,
 0xf3, 0x0b, 0x2c, 0x00, 0x69, 0x6e, 0x00, 0x73, 0x75, 0x63,
@@ -45,295 +45,295 @@ const char help_text[] = {
 0x00, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, 0x0e, 0x00, 0x11,
 0x2e, 0x2c, 0x00, 0x33, 0x54, 0x68, 0x65, 0x8a, 0x00, 0x00,
 0xd8, 0x00, 0x13, 0x62, 0x3a, 0x00, 0x81, 0x74, 0x65, 0x72,
-0x6d, 0x69, 0x6e, 0x61, 0x74, 0xc5, 0x00, 0x53, 0x74, 0x00,
-0x61, 0x6e, 0x79, 0x8c, 0x00, 0x00, 0xa5, 0x00, 0x50, 0x65,
+0x6d, 0x69, 0x6e, 0x61, 0x74, 0xc5, 0x00, 0x54, 0x74, 0x00,
+0x61, 0x6e, 0x79, 0xc1, 0x00, 0x80, 0x69, 0x73, 0x00, 0x65,
 0x71, 0x75, 0x61, 0x6c, 0xab, 0x00, 0x16, 0x74, 0x3c, 0x00,
-0xa1, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x69,
-0x6e, 0x88, 0x00, 0x03, 0x2e, 0x00, 0x03, 0x63, 0x00, 0x25,
-0x77, 0x6f, 0x59, 0x00, 0x61, 0x6d, 0x61, 0x79, 0x00, 0x72,
-0x75, 0x28, 0x00, 0xf1, 0x01, 0x70, 0x61, 0x72, 0x61, 0x6c,
+0x70, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x93, 0x00,
+0x00, 0x88, 0x00, 0x03, 0x2e, 0x00, 0x03, 0x63, 0x00, 0x25,
+0x77, 0x6f, 0x59, 0x00, 0x31, 0x6d, 0x61, 0x79, 0x97, 0x00,
+0xf1, 0x04, 0x69, 0x6e, 0x00, 0x70, 0x61, 0x72, 0x61, 0x6c,
 0x6c, 0x65, 0x6c, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65,
 0x6e, 0x4f, 0x00, 0x84, 0x73, 0x61, 0x6d, 0x65, 0x00, 0x74,
 0x77, 0x6f, 0xfb, 0x00, 0xd0, 0x2c, 0x00, 0x62, 0x75, 0x74,
 0x00, 0x6e, 0x6f, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x5b, 0x00,
-0x10, 0x6e, 0x1e, 0x00, 0x01, 0x47, 0x00, 0x52, 0x64, 0x6f,
+0x11, 0x6e, 0x1e, 0x00, 0x00, 0x47, 0x00, 0x52, 0x64, 0x6f,
 0x00, 0x73, 0x6f, 0x62, 0x00, 0x14, 0x4e, 0x61, 0x00, 0x11,
-0x00, 0x84, 0x01, 0x60, 0x65, 0x73, 0x00, 0x61, 0x6e, 0x6f,
-0x31, 0x01, 0x03, 0x17, 0x00, 0x02, 0x26, 0x00, 0x38, 0x41,
-0x6c, 0x6c, 0x56, 0x01, 0x00, 0x9e, 0x01, 0x04, 0x6e, 0x01,
-0x25, 0x65, 0x64, 0x64, 0x01, 0x30, 0x2e, 0x00, 0x00, 0x15,
-0x01, 0x21, 0x72, 0x65, 0x20, 0x00, 0x31, 0x73, 0x6f, 0x6d,
+0x00, 0x84, 0x01, 0x61, 0x65, 0x73, 0x00, 0x61, 0x6e, 0x6f,
+0x31, 0x01, 0x02, 0x17, 0x00, 0x02, 0x26, 0x00, 0x39, 0x41,
+0x6c, 0x6c, 0x56, 0x01, 0x34, 0x61, 0x72, 0x65, 0x6e, 0x01,
+0x25, 0x65, 0x64, 0x64, 0x01, 0x00, 0x2c, 0x00, 0x51, 0x54,
+0x68, 0x65, 0x72, 0x65, 0x20, 0x00, 0x31, 0x73, 0x6f, 0x6d,
 0x25, 0x00, 0xf0, 0x00, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61,
 0x62, 0x6c, 0x65, 0x00, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x1b,
 0x01, 0x60, 0x76, 0x65, 0x00, 0x6d, 0x6f, 0x64, 0x88, 0x01,
 0x30, 0x77, 0x68, 0x69, 0xe2, 0x01, 0xc0, 0x6e, 0x76, 0x6f,
 0x6c, 0x76, 0x65, 0x00, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x39,
-0x01, 0x35, 0x74, 0x68, 0x65, 0xe5, 0x00, 0x13, 0x2d, 0xa0,
-0x00, 0x81, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x00, 0x74, 0x6f,
-0x59, 0x00, 0x20, 0x74, 0x68, 0x27, 0x00, 0x01, 0xa9, 0x00,
-0x02, 0xdb, 0x00, 0x31, 0x32, 0x2c, 0x00, 0x64, 0x01, 0x74,
+0x01, 0x01, 0x0a, 0x02, 0x03, 0xe5, 0x00, 0x13, 0x2d, 0xa0,
+0x00, 0x50, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x3c, 0x01, 0x00,
+0x59, 0x00, 0x20, 0x74, 0x68, 0x27, 0x00, 0x02, 0xa9, 0x00,
+0x01, 0xdb, 0x00, 0x31, 0x32, 0x2c, 0x00, 0x64, 0x01, 0x74,
 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x45, 0x00, 0xa0,
 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
-0x8b, 0x00, 0x70, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74,
-0x32, 0x00, 0x01, 0x1a, 0x01, 0xb9, 0x73, 0x65, 0x71, 0x75,
-0x65, 0x6e, 0x63, 0x65, 0x00, 0x6f, 0x66, 0x67, 0x01, 0xf4,
+0x8b, 0x00, 0x72, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74,
+0x68, 0x01, 0xb8, 0x6e, 0x6f, 0x00, 0x73, 0x65, 0x71, 0x75,
+0x65, 0x6e, 0x63, 0x65, 0xc0, 0x01, 0x00, 0x20, 0x01, 0xf4,
 0x05, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x6f,
 0x6f, 0x70, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x6f, 0x6e,
-0x65, 0xc6, 0x01, 0x75, 0x62, 0x61, 0x63, 0x6b, 0x00, 0x74,
-0x6f, 0x73, 0x01, 0x04, 0xb0, 0x01, 0x01, 0x0f, 0x02, 0x91,
+0x65, 0xc6, 0x01, 0x44, 0x62, 0x61, 0x63, 0x6b, 0xc2, 0x01,
+0x01, 0x73, 0x01, 0x04, 0xb0, 0x01, 0x00, 0x0f, 0x02, 0x91,
 0x72, 0x75, 0x6c, 0x65, 0x73, 0x00, 0x73, 0x74, 0x61, 0xd6,
-0x02, 0x31, 0x62, 0x6f, 0x76, 0x0b, 0x01, 0x01, 0x2c, 0x00,
+0x02, 0x32, 0x62, 0x6f, 0x76, 0x0b, 0x01, 0x00, 0x2c, 0x00,
 0x70, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4b, 0x00,
-0x10, 0x73, 0x29, 0x01, 0x90, 0x43, 0x72, 0x65, 0x64, 0x69,
-0x74, 0x00, 0x66, 0x6f, 0xc1, 0x00, 0xd1, 0x69, 0x73, 0x00,
-0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x67, 0x6f, 0x65,
-0xcc, 0x02, 0xe5, 0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x69, 0x00,
-0x5b, 0x31, 0x32, 0x5d, 0x2e, 0x00, 0x00, 0x98, 0x02, 0x30,
-0x77, 0x61, 0x73, 0xc9, 0x00, 0x04, 0x3a, 0x03, 0x02, 0x89,
-0x00, 0x10, 0x69, 0x14, 0x00, 0x40, 0x6c, 0x6c, 0x65, 0x63,
-0xea, 0x00, 0xf0, 0x00, 0x00, 0x62, 0x79, 0x00, 0x4a, 0x61,
-0x6d, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0xac,
-0x02, 0x01, 0x46, 0x00, 0xd1, 0x00, 0x68, 0x74, 0x74, 0x70,
-0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x5d, 0x00,
-0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65, 0x6e,
-0x2f, 0x7c, 0x00, 0xf1, 0x0c, 0x73, 0x2f, 0x68, 0x61, 0x73,
-0x68, 0x69, 0x77, 0x6f, 0x6b, 0x61, 0x6b, 0x65, 0x72, 0x6f,
-0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x28, 0x62, 0x65, 0x77,
-0x61, 0x72, 0x22, 0x01, 0xd5, 0x46, 0x6c, 0x61, 0x73, 0x68,
-0x29, 0x00, 0x00, 0x00, 0x32, 0x36, 0x2e, 0x31, 0xe5, 0x03,
-0x01, 0x8e, 0x00, 0x21, 0x6f, 0x6c, 0xee, 0x03, 0x20, 0x54,
-0x6f, 0xc0, 0x03, 0x43, 0x63, 0x65, 0x00, 0x61, 0x4f, 0x01,
-0x04, 0xa1, 0x02, 0x0a, 0x98, 0x02, 0x30, 0x63, 0x6c, 0x69,
-0x44, 0x01, 0x10, 0x68, 0x06, 0x02, 0xb7, 0x75, 0x73, 0x65,
-0x00, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x6f, 0x6e, 0x66, 0x01,
-0x01, 0xcc, 0x01, 0x51, 0x64, 0x72, 0x61, 0x67, 0x00, 0xf3,
-0x01, 0x41, 0x77, 0x61, 0x72, 0x64, 0x1f, 0x04, 0x00, 0xf2,
-0x01, 0x03, 0xf9, 0x03, 0x00, 0xc5, 0x02, 0x61, 0x6e, 0x6f,
-0x74, 0x00, 0x6e, 0x65, 0x07, 0x01, 0x02, 0x2e, 0x00, 0x12,
-0x61, 0xa8, 0x02, 0x02, 0xd5, 0x03, 0x16, 0x6f, 0x32, 0x00,
-0x03, 0x57, 0x00, 0xa5, 0x3b, 0x00, 0x79, 0x6f, 0x75, 0x00,
-0x6f, 0x6e, 0x6c, 0x79, 0x37, 0x00, 0x47, 0x6d, 0x6f, 0x76,
-0x65, 0x8b, 0x00, 0xa3, 0x66, 0x61, 0x72, 0x00, 0x65, 0x6e,
-0x6f, 0x75, 0x67, 0x68, 0x9a, 0x01, 0x10, 0x65, 0x53, 0x02,
-0x54, 0x65, 0x6e, 0x64, 0x65, 0x64, 0xd3, 0x00, 0x32, 0x64,
-0x69, 0x72, 0x6a, 0x01, 0x00, 0x3f, 0x00, 0xf1, 0x04, 0x62,
-0x65, 0x00, 0x75, 0x6e, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75,
-0x6f, 0x75, 0x73, 0x2e, 0x00, 0x28, 0x53, 0x6f, 0x64, 0x00,
-0x87, 0x63, 0x61, 0x6e, 0x00, 0x6b, 0x65, 0x65, 0x70, 0x5b,
-0x00, 0x31, 0x6e, 0x65, 0x61, 0x51, 0x00, 0x00, 0x1f, 0x02,
-0x10, 0x72, 0x1f, 0x04, 0x04, 0xec, 0x00, 0x03, 0xdd, 0x04,
-0x80, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x74, 0x6c, 0x8f,
-0x04, 0x35, 0x72, 0x6f, 0x77, 0x91, 0x02, 0x32, 0x6f, 0x75,
-0x74, 0x85, 0x02, 0x20, 0x69, 0x74, 0xfc, 0x03, 0x46, 0x6d,
-0x61, 0x6e, 0x79, 0x84, 0x00, 0x20, 0x73, 0x2e, 0x91, 0x01,
-0x52, 0x44, 0x6f, 0x69, 0x6e, 0x67, 0x09, 0x02, 0xa6, 0x61,
-0x67, 0x61, 0x69, 0x6e, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x85,
-0x01, 0x00, 0x17, 0x00, 0xf0, 0x04, 0x6c, 0x72, 0x65, 0x61,
-0x64, 0x79, 0x00, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74,
-0x00, 0x77, 0x69, 0x6c, 0x6c, 0x1d, 0x03, 0x04, 0xee, 0x03,
-0x05, 0x6e, 0x03, 0x05, 0xf7, 0x03, 0x44, 0x49, 0x66, 0x00,
-0x74, 0xcc, 0x03, 0x05, 0x3f, 0x00, 0x21, 0x61, 0x73, 0x80,
-0x00, 0x04, 0x9c, 0x00, 0x07, 0x80, 0x04, 0x09, 0x7b, 0x04,
-0x00, 0x28, 0x00, 0x10, 0x70, 0x08, 0x05, 0x20, 0x74, 0x74,
-0x38, 0x01, 0x11, 0x79, 0x20, 0x00, 0x40, 0x63, 0x75, 0x72,
-0x72, 0x7b, 0x00, 0x34, 0x67, 0x61, 0x6d, 0x29, 0x03, 0x51,
-0x28, 0x69, 0x2e, 0x65, 0x2e, 0x39, 0x00, 0x24, 0x62, 0x79,
-0x21, 0x03, 0x25, 0x29, 0x2c, 0x5b, 0x03, 0x01, 0xd4, 0x01,
-0x11, 0x67, 0x49, 0x05, 0x01, 0xed, 0x00, 0x02, 0xb6, 0x00,
-0x20, 0x72, 0x65, 0xb4, 0x01, 0x01, 0xeb, 0x01, 0x11, 0x6f,
-0xa4, 0x00, 0x10, 0x6d, 0xe3, 0x02, 0x21, 0x49, 0x66, 0x78,
-0x01, 0x30, 0x77, 0x61, 0x6e, 0x31, 0x02, 0x00, 0x25, 0x00,
-0x30, 0x69, 0x6e, 0x64, 0x13, 0x00, 0x51, 0x72, 0x73, 0x65,
-0x6c, 0x66, 0xf2, 0x03, 0x08, 0xa2, 0x00, 0x00, 0x6e, 0x00,
-0x60, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x0e, 0x05, 0x40,
-0x20, 0x6e, 0x6f, 0x74, 0xa7, 0x06, 0x0e, 0xb9, 0x02, 0x01,
-0x60, 0x00, 0x15, 0x2c, 0xd3, 0x01, 0x60, 0x72, 0x69, 0x67,
-0x68, 0x74, 0x2d, 0x97, 0x00, 0x09, 0x21, 0x00, 0x25, 0x00,
-0x69, 0x83, 0x05, 0x01, 0x7c, 0x02, 0x03, 0x90, 0x02, 0x83,
-0x77, 0x00, 0x61, 0x00, 0x60, 0x6e, 0x6f, 0x6e, 0xc2, 0x04,
-0x87, 0x27, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x72, 0xaf,
-0x00, 0x00, 0xc7, 0x04, 0x34, 0x6b, 0x00, 0x79, 0x25, 0x07,
-0x00, 0x93, 0x00, 0x42, 0x73, 0x68, 0x65, 0x64, 0xad, 0x06,
-0x23, 0x61, 0x6e, 0xae, 0x00, 0x02, 0x28, 0x01, 0x05, 0x27,
-0x00, 0x02, 0x64, 0x03, 0x11, 0x64, 0x02, 0x01, 0x35, 0x69,
-0x74, 0x73, 0x8d, 0x01, 0x01, 0x4c, 0x02, 0x13, 0x72, 0x74,
-0x05, 0x22, 0x64, 0x65, 0xe8, 0x04, 0x01, 0x0e, 0x07, 0x10,
-0x79, 0x18, 0x00, 0x03, 0xa5, 0x00, 0x02, 0xc4, 0x00, 0x02,
-0x44, 0x00, 0x25, 0x73, 0x29, 0xdb, 0x00, 0x01, 0x9c, 0x00,
-0x07, 0xe4, 0x05, 0x33, 0x00, 0x61, 0x73, 0x8f, 0x00, 0x02,
-0xc2, 0x01, 0x51, 0x6c, 0x65, 0x66, 0x74, 0x2d, 0xb9, 0x03,
-0x01, 0x79, 0x05, 0x40, 0x6e, 0x00, 0x69, 0x74, 0xf3, 0x04,
-0x22, 0x69, 0x73, 0x95, 0x01, 0x51, 0x68, 0x69, 0x67, 0x68,
-0x6c, 0x59, 0x00, 0x20, 0x69, 0x74, 0x89, 0x00, 0x04, 0x8a,
-0x03, 0x04, 0x9d, 0x00, 0x09, 0x2e, 0x06, 0x31, 0x00, 0x69,
-0x74, 0xae, 0x05, 0x02, 0xb2, 0x01, 0x20, 0x69, 0x6c, 0xc8,
-0x06, 0x00, 0x9a, 0x02, 0x62, 0x76, 0x65, 0x6e, 0x74, 0x65,
-0x64, 0xed, 0x02, 0x62, 0x61, 0x63, 0x63, 0x69, 0x64, 0x65,
-0x7d, 0x07, 0x00, 0x2d, 0x06, 0x22, 0x69, 0x66, 0x17, 0x08,
-0x22, 0x6e, 0x79, 0xf6, 0x01, 0x25, 0x6f, 0x73, 0x5c, 0x00,
-0x00, 0xd9, 0x00, 0x98, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65,
-0x2e, 0x00, 0x4c, 0xa7, 0x00, 0x01, 0x0d, 0x03, 0x01, 0x5a,
-0x04, 0x16, 0x61, 0xa1, 0x00, 0x23, 0x65, 0x64, 0xe2, 0x00,
-0x02, 0x7a, 0x00, 0x20, 0x75, 0x6e, 0xf9, 0x00, 0x04, 0xb6,
-0x00, 0x40, 0x72, 0x65, 0x73, 0x74, 0x2e, 0x07, 0x11, 0x79,
-0x59, 0x08, 0x50, 0x62, 0x69, 0x6c, 0x69, 0x74, 0xcd, 0x01,
-0x03, 0x81, 0x00, 0x00, 0xf4, 0x00, 0x00, 0xd4, 0x08, 0x03,
-0x32, 0x01, 0x84, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x75, 0x73,
-0x65, 0xde, 0x02, 0x85, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65,
-0x79, 0x73, 0x57, 0x04, 0x61, 0x61, 0x72, 0x6f, 0x75, 0x6e,
-0x64, 0x1f, 0x00, 0xf8, 0x01, 0x67, 0x72, 0x69, 0x64, 0x3a,
-0x00, 0x69, 0x66, 0x00, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62,
-0x6c, 0x35, 0x00, 0x03, 0x8d, 0x03, 0x52, 0x6c, 0x77, 0x61,
-0x79, 0x73, 0x39, 0x00, 0x80, 0x6f, 0x72, 0x74, 0x68, 0x6f,
-0x67, 0x6f, 0x6e, 0xfd, 0x00, 0x12, 0x2c, 0xc2, 0x04, 0x62,
-0x77, 0x69, 0x73, 0x65, 0x00, 0x69, 0xb9, 0x03, 0x01, 0x25,
-0x00, 0x07, 0x17, 0x05, 0x02, 0x5c, 0x04, 0x24, 0x65, 0x73,
-0x3c, 0x08, 0x04, 0xfb, 0x04, 0x50, 0x69, 0x6e, 0x64, 0x69,
-0x63, 0x8b, 0x06, 0x06, 0x30, 0x04, 0x60, 0x2e, 0x00, 0x48,
-0x6f, 0x6c, 0x64, 0x1c, 0x01, 0x12, 0x43, 0xb8, 0x05, 0x00,
-0xf7, 0x00, 0x01, 0x16, 0x04, 0x11, 0x73, 0x31, 0x01, 0x07,
-0xc8, 0x00, 0x02, 0x6b, 0x00, 0x35, 0x6c, 0x61, 0x79, 0x15,
-0x03, 0x04, 0xa3, 0x08, 0x07, 0x03, 0x05, 0x90, 0x28, 0x69,
-0x66, 0x00, 0x61, 0x76, 0x61, 0x69, 0x6c, 0xe1, 0x07, 0x71,
-0x29, 0x3b, 0x00, 0x53, 0x68, 0x69, 0x66, 0x4b, 0x01, 0x0f,
-0x4b, 0x00, 0x03, 0x04, 0x11, 0x03, 0x1c, 0x00, 0x12, 0x03,
-0x13, 0x50, 0x82, 0x00, 0x02, 0xa2, 0x02, 0x40, 0x65, 0x74,
-0x75, 0x72, 0x40, 0x05, 0x00, 0x8a, 0x07, 0x41, 0x6c, 0x6c,
-0x6f, 0x77, 0x83, 0x02, 0x0e, 0x52, 0x00, 0x01, 0x82, 0x01,
-0x0f, 0xa2, 0x00, 0x0c, 0x01, 0xb1, 0x01, 0x08, 0xe3, 0x02,
-0x2f, 0x61, 0x6e, 0xe2, 0x02, 0x04, 0x18, 0x70, 0x83, 0x00,
-0x20, 0x73, 0x70, 0xc7, 0x06, 0x66, 0x62, 0x61, 0x72, 0x00,
-0x6f, 0x72, 0x1d, 0x00, 0x0e, 0xa0, 0x00, 0x51, 0x74, 0x77,
-0x69, 0x63, 0x65, 0xa1, 0x07, 0x06, 0x24, 0x00, 0x04, 0xa1,
-0x0a, 0x01, 0xa9, 0x00, 0x06, 0x61, 0x03, 0x7e, 0x6a, 0x75,
-0x6d, 0x70, 0x00, 0x74, 0x6f, 0xb0, 0x01, 0x02, 0xef, 0x03,
-0x01, 0xb8, 0x00, 0x05, 0xda, 0x0a, 0xf0, 0x0c, 0x4c, 0x65,
-0x74, 0x74, 0x65, 0x72, 0x73, 0x00, 0x60, 0x61, 0x27, 0x2c,
-0x00, 0x2e, 0x2e, 0x2e, 0x2c, 0x00, 0x60, 0x66, 0x27, 0x00,
-0x63, 0x6f, 0x75, 0x6e, 0x74, 0xb8, 0x00, 0x23, 0x31, 0x30,
-0x16, 0x00, 0x21, 0x31, 0x35, 0x6d, 0x01, 0x31, 0x60, 0x30,
-0x27, 0x17, 0x00, 0x10, 0x36, 0x8b, 0x00, 0x51, 0x56, 0x69,
-0x6f, 0x6c, 0x61, 0x1d, 0x06, 0x03, 0x21, 0x05, 0x02, 0x5c,
-0x08, 0x03, 0x75, 0x05, 0x04, 0x71, 0x03, 0x02, 0x7b, 0x01,
-0x10, 0x64, 0x32, 0x01, 0x42, 0x72, 0x65, 0x64, 0x3a, 0xe7,
-0x09, 0x1a, 0x6e, 0x92, 0x00, 0x27, 0x6f, 0x6f, 0xef, 0x05,
-0x06, 0x3b, 0x00, 0x06, 0x4d, 0x03, 0x05, 0x40, 0x00, 0x1f,
-0x2e, 0x40, 0x00, 0x05, 0x3f, 0x66, 0x65, 0x77, 0x3f, 0x00,
-0x10, 0x31, 0x00, 0x69, 0x66, 0xdf, 0x06, 0x08, 0x98, 0x05,
-0x00, 0xaa, 0x01, 0xf3, 0x00, 0x65, 0x72, 0x72, 0x6f, 0x72,
-0x00, 0x28, 0x61, 0x73, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x73,
-0xb3, 0x07, 0x51, 0x65, 0x72, 0x65, 0x6c, 0x79, 0xfd, 0x07,
-0x56, 0x62, 0x65, 0x69, 0x6e, 0x67, 0xc6, 0x01, 0x41, 0x79,
-0x65, 0x74, 0x29, 0x66, 0x03, 0x20, 0x61, 0x64, 0xe4, 0x02,
-0x03, 0xca, 0x07, 0x06, 0x80, 0x00, 0x44, 0x6f, 0x75, 0x6c,
-0x64, 0x6d, 0x0a, 0x00, 0x4b, 0x05, 0x01, 0xd1, 0x01, 0x11,
-0x6f, 0xfa, 0x0a, 0x0b, 0xf8, 0x0a, 0x00, 0x84, 0x03, 0x05,
-0x6a, 0x06, 0x16, 0x00, 0xc4, 0x05, 0x03, 0xb1, 0x02, 0x10,
-0x2c, 0x1f, 0x00, 0x28, 0x69, 0x66, 0x30, 0x05, 0x20, 0x68,
-0x61, 0x0f, 0x07, 0x29, 0x65, 0x6e, 0xde, 0x00, 0x01, 0xae,
-0x09, 0x54, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x49, 0x0b, 0x66,
-0x00, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x09, 0x0d, 0x01, 0xb7,
-0x05, 0x08, 0x7d, 0x0a, 0x0f, 0x21, 0x01, 0x0c, 0x00, 0x06,
-0x03, 0x11, 0x6c, 0x0a, 0x01, 0x6a, 0x73, 0x75, 0x62, 0x73,
-0x65, 0x74, 0xe3, 0x01, 0x02, 0x78, 0x01, 0x20, 0x6e, 0x6f,
-0x85, 0x06, 0x07, 0x12, 0x0d, 0x02, 0x46, 0x09, 0x03, 0xbc,
-0x02, 0x10, 0x73, 0x34, 0x00, 0x08, 0xce, 0x0b, 0x90, 0x2e,
-0x00, 0x46, 0x6f, 0x72, 0x00, 0x65, 0x78, 0x61, 0xa9, 0x00,
-0x31, 0x2c, 0x00, 0x69, 0x9b, 0x06, 0x03, 0x42, 0x03, 0x23,
-0x6c, 0x79, 0x44, 0x00, 0x02, 0x3e, 0x07, 0x1b, 0x31, 0x51,
-0x0d, 0x05, 0x79, 0x03, 0x00, 0xc6, 0x00, 0x06, 0x6a, 0x06,
-0x21, 0x6e, 0x6f, 0x77, 0x06, 0x01, 0x6a, 0x09, 0x09, 0x76,
-0x07, 0x25, 0x6f, 0x6e, 0x0e, 0x05, 0x00, 0xe7, 0x07, 0x04,
-0xc8, 0x03, 0x02, 0x3a, 0x06, 0x41, 0x75, 0x70, 0x00, 0x72,
-0xe2, 0x01, 0x05, 0xb9, 0x04, 0x01, 0x14, 0x03, 0x03, 0xa9,
-0x0d, 0x02, 0x39, 0x01, 0x00, 0x4a, 0x03, 0x02, 0xf9, 0x01,
-0x04, 0x10, 0x0e, 0x01, 0x23, 0x01, 0x01, 0x18, 0x06, 0xa4,
-0x76, 0x61, 0x6c, 0x69, 0x64, 0x00, 0x73, 0x6f, 0x6c, 0x75,
-0xf9, 0x03, 0x46, 0x2d, 0x00, 0x49, 0x66, 0x37, 0x07, 0x30,
-0x73, 0x65, 0x6c, 0x82, 0x06, 0x02, 0x91, 0x05, 0x10, 0x28,
-0xd4, 0x01, 0x04, 0x73, 0x08, 0x33, 0x00, 0x6f, 0x70, 0xd1,
-0x09, 0x00, 0x97, 0x0e, 0x10, 0x61, 0x73, 0x04, 0x01, 0xfd,
-0x0b, 0x13, 0x73, 0x34, 0x07, 0x05, 0x55, 0x00, 0x14, 0x2c,
-0x88, 0x00, 0x07, 0x32, 0x0c, 0x02, 0xc4, 0x0c, 0x01, 0x34,
-0x0c, 0x13, 0x73, 0x35, 0x0c, 0x0e, 0xea, 0x02, 0x02, 0x22,
-0x03, 0x13, 0x28, 0x48, 0x0d, 0x03, 0xd0, 0x08, 0x00, 0xee,
-0x02, 0x52, 0x73, 0x63, 0x72, 0x69, 0x62, 0xc4, 0x00, 0x13,
-0x73, 0x54, 0x05, 0x33, 0x32, 0x2e, 0x31, 0x75, 0x09, 0x26,
-0x73, 0x6f, 0x5d, 0x05, 0x13, 0x2e, 0x7a, 0x0b, 0x15, 0x32,
-0x7a, 0x0b, 0x00, 0xb3, 0x09, 0x20, 0x6d, 0x65, 0x27, 0x04,
-0x12, 0x20, 0x79, 0x0d, 0x35, 0x73, 0x65, 0x00, 0x14, 0x00,
-0x01, 0xa4, 0x0d, 0x06, 0x3e, 0x00, 0x01, 0x55, 0x07, 0x01,
-0x7b, 0x00, 0xb3, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
-0x2e, 0x2e, 0x2e, 0x27, 0xf7, 0x00, 0x04, 0x96, 0x01, 0x40,
-0x60, 0x54, 0x79, 0x70, 0x93, 0x05, 0x30, 0x65, 0x6e, 0x75,
-0xad, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00,
-0x48, 0x65, 0x9d, 0x01, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a,
-0x07, 0x0c, 0x00, 0xbd, 0x01, 0x02, 0xaf, 0x00, 0x42, 0x71,
-0x75, 0x61, 0x72, 0xcc, 0x0c, 0xaa, 0x44, 0x69, 0x66, 0x66,
-0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x0d, 0x00, 0x40, 0x6c,
-0x65, 0x76, 0x65, 0xa6, 0x09, 0x02, 0x9e, 0x02, 0x01, 0x03,
-0x03, 0x10, 0x41, 0x5d, 0x01, 0x12, 0x20, 0x5d, 0x01, 0x12,
-0x00, 0x41, 0x08, 0x20, 0x69, 0x73, 0x1c, 0x10, 0x07, 0x03,
-0x0a, 0x01, 0x7d, 0x0a, 0x20, 0x63, 0x6c, 0x24, 0x05, 0x21,
-0x64, 0x2c, 0x3c, 0x00, 0x08, 0xb8, 0x04, 0x50, 0x67, 0x65,
-0x6e, 0x65, 0x72, 0xd6, 0x06, 0x0a, 0xc5, 0x0f, 0x0a, 0xed,
-0x08, 0x03, 0x4f, 0x07, 0x01, 0xb9, 0x01, 0x13, 0x62, 0x18,
-0x03, 0x00, 0x49, 0x0b, 0x31, 0x63, 0x72, 0x65, 0x9b, 0x0f,
-0x03, 0xa9, 0x01, 0x00, 0x87, 0x08, 0x06, 0x33, 0x02, 0x04,
-0xcb, 0x01, 0x24, 0x64, 0x6f, 0x25, 0x04, 0x0b, 0xd0, 0x01,
-0x05, 0x1e, 0x02, 0x02, 0xcf, 0x01, 0x64, 0x4d, 0x61, 0x78,
-0x2e, 0x20, 0x62, 0x8e, 0x01, 0x35, 0x65, 0x72, 0x20, 0x76,
-0x06, 0x02, 0x1d, 0x00, 0x4e, 0x69, 0x6d, 0x75, 0x6d, 0x22,
-0x10, 0x03, 0xaf, 0x02, 0x00, 0xab, 0x01, 0x10, 0x74, 0x28,
-0x01, 0x28, 0x61, 0x72, 0xae, 0x06, 0x15, 0x54, 0x2b, 0x0e,
-0x01, 0xee, 0x03, 0x11, 0x32, 0xc6, 0x0f, 0x04, 0x44, 0x06,
-0x02, 0x21, 0x0f, 0x13, 0x65, 0xcf, 0x03, 0x40, 0x31, 0x2c,
-0x00, 0x33, 0x88, 0x04, 0x53, 0x34, 0x2e, 0x00, 0x49, 0x6e,
-0x17, 0x01, 0x20, 0x6c, 0x2c, 0x72, 0x05, 0x21, 0x65, 0x72,
-0x6d, 0x10, 0x32, 0x61, 0x73, 0x69, 0x6e, 0x0a, 0x82, 0x25,
-0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x87, 0x03, 0x12,
-0x20, 0xba, 0x01, 0x00, 0x80, 0x01, 0x40, 0x47, 0x69, 0x76,
-0x65, 0xb5, 0x02, 0x10, 0x72, 0x28, 0x05, 0x00, 0xb3, 0x0b,
-0x10, 0x63, 0x73, 0x09, 0x28, 0x67, 0x65, 0xa0, 0x04, 0x25,
-0x74, 0x68, 0x74, 0x01, 0x04, 0xac, 0x08, 0x31, 0x74, 0x72,
-0x79, 0x39, 0x01, 0x11, 0x6c, 0xaf, 0x04, 0x34, 0x66, 0x6f,
-0x72, 0xbb, 0x0a, 0x03, 0x22, 0x07, 0x05, 0xf0, 0x01, 0x30,
-0x43, 0x65, 0x72, 0xa4, 0x03, 0x00, 0x29, 0x00, 0x32, 0x6f,
-0x75, 0x74, 0xc4, 0x01, 0x00, 0x1e, 0x04, 0x00, 0x57, 0x06,
-0x00, 0x67, 0x00, 0x11, 0x74, 0xbf, 0x07, 0x03, 0xa8, 0x05,
-0x04, 0x72, 0x00, 0x32, 0x3b, 0x00, 0x74, 0x17, 0x02, 0x00,
-0x02, 0x06, 0x30, 0x75, 0x70, 0x70, 0x94, 0x05, 0x22, 0x6f,
-0x75, 0x13, 0x11, 0xf0, 0x03, 0x45, 0x78, 0x70, 0x61, 0x6e,
-0x73, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x61, 0x63, 0x74, 0x6f,
-0x72, 0x20, 0x28, 0xdc, 0x00, 0x10, 0x29, 0x4b, 0x02, 0x03,
-0x58, 0x04, 0x08, 0xac, 0x00, 0x41, 0x6f, 0x72, 0x6b, 0x73,
-0xbe, 0x07, 0x02, 0x10, 0x0a, 0x01, 0x52, 0x06, 0x39, 0x78,
-0x69, 0x73, 0x7d, 0x0d, 0xf8, 0x05, 0x74, 0x00, 0x72, 0x61,
-0x6e, 0x64, 0x6f, 0x6d, 0x00, 0x28, 0x61, 0x66, 0x74, 0x65,
-0x72, 0x00, 0x66, 0x69, 0x72, 0x73, 0x28, 0x02, 0x20, 0x6e,
-0x00, 0x90, 0x06, 0x33, 0x69, 0x61, 0x6c, 0x32, 0x00, 0x01,
-0x7f, 0x10, 0x10, 0x77, 0x1a, 0x0d, 0x41, 0x29, 0x2e, 0x00,
-0x49, 0x72, 0x02, 0x40, 0x6e, 0x00, 0x64, 0x65, 0xae, 0x0a,
-0x11, 0x73, 0x6b, 0x0a, 0x08, 0x1e, 0x09, 0x05, 0x5e, 0x00,
-0x24, 0x29, 0x2c, 0x22, 0x05, 0x11, 0x6e, 0x97, 0x00, 0x02,
-0xd7, 0x0d, 0x30, 0x68, 0x6f, 0x77, 0x72, 0x0e, 0x00, 0xd0,
-0x01, 0x11, 0x63, 0x9c, 0x06, 0x20, 0x65, 0x78, 0x6c, 0x0e,
-0x03, 0x54, 0x01, 0x08, 0x85, 0x00, 0x08, 0xc6, 0x0e, 0x02,
-0x78, 0x0b, 0x06, 0xeb, 0x03, 0x32, 0x00, 0x64, 0x65, 0x75,
-0x12, 0x21, 0x65, 0x73, 0x52, 0x00, 0x50, 0x6c, 0x69, 0x6b,
-0x65, 0x6c, 0xad, 0x0a, 0x02, 0x17, 0x13, 0x04, 0x55, 0x00,
-0x21, 0x61, 0x73, 0x6c, 0x00, 0x21, 0x61, 0x73, 0x6f, 0x00,
-0x66, 0x61, 0x6e, 0x2c, 0x00, 0x72, 0x61, 0x40, 0x11, 0x40,
-0x63, 0x68, 0x6f, 0x6f, 0xbd, 0x08, 0x06, 0xdf, 0x00, 0x01,
-0x68, 0x06, 0x02, 0x40, 0x02, 0x64, 0x48, 0x69, 0x67, 0x68,
-0x00, 0x65, 0x7b, 0x01, 0x12, 0x00, 0x7b, 0x01, 0x52, 0x73,
-0x00, 0x75, 0x73, 0x75, 0x9f, 0x0b, 0x33, 0x65, 0x61, 0x6e,
-0x6e, 0x02, 0x07, 0xae, 0x03, 0x22, 0x74, 0x68, 0x8b, 0x02,
-0x05, 0xf3, 0x0a, 0x06, 0xe0, 0x01, 0x3e, 0x6c, 0x6f, 0x77,
-0x4f, 0x00, 0x02, 0xe1, 0x02, 0x20, 0x72, 0x65, 0xf8, 0x05,
-0x32, 0x6c, 0x6f, 0x74, 0xbd, 0x08, 0x00, 0x7c, 0x04, 0x61,
-0x6c, 0x79, 0x2d, 0x70, 0x61, 0x63, 0xac, 0x08, 0x80, 0x73,
-0x6c, 0x61, 0x6e, 0x64, 0x73, 0x2e, 0x00,
+0x10, 0x73, 0x29, 0x01, 0x60, 0x43, 0x72, 0x65, 0x64, 0x69,
+0x74, 0x6b, 0x00, 0xf1, 0x01, 0x00, 0x74, 0x68, 0x69, 0x73,
+0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x67, 0x6f,
+0x65, 0xcc, 0x02, 0xb0, 0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x69,
+0x00, 0x5b, 0x31, 0x32, 0x5d, 0x2e, 0x00, 0x04, 0x98, 0x02,
+0x31, 0x77, 0x61, 0x73, 0x09, 0x03, 0x04, 0x3a, 0x03, 0x01,
+0x89, 0x00, 0x10, 0x69, 0x14, 0x00, 0x40, 0x6c, 0x6c, 0x65,
+0x63, 0xea, 0x00, 0xf1, 0x00, 0x00, 0x62, 0x79, 0x00, 0x4a,
+0x61, 0x6d, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65,
+0xac, 0x02, 0x00, 0x46, 0x00, 0xd1, 0x00, 0x68, 0x74, 0x74,
+0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x5d,
+0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65,
+0x6e, 0x2f, 0x7c, 0x00, 0xf1, 0x0c, 0x73, 0x2f, 0x68, 0x61,
+0x73, 0x68, 0x69, 0x77, 0x6f, 0x6b, 0x61, 0x6b, 0x65, 0x72,
+0x6f, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x28, 0x62, 0x65,
+0x77, 0x61, 0x72, 0x22, 0x01, 0xd5, 0x46, 0x6c, 0x61, 0x73,
+0x68, 0x29, 0x00, 0x00, 0x00, 0x32, 0x36, 0x2e, 0x31, 0xe5,
+0x03, 0x01, 0x8e, 0x00, 0x21, 0x6f, 0x6c, 0xee, 0x03, 0x20,
+0x54, 0x6f, 0xc0, 0x03, 0x10, 0x63, 0xee, 0x03, 0x03, 0xb5,
+0x01, 0x05, 0xa1, 0x02, 0x08, 0x98, 0x02, 0x30, 0x63, 0x6c,
+0x69, 0x44, 0x01, 0x10, 0x68, 0x06, 0x02, 0xb8, 0x75, 0x73,
+0x65, 0x00, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x6f, 0x6e, 0x66,
+0x01, 0x00, 0x04, 0x00, 0x51, 0x64, 0x72, 0x61, 0x67, 0x00,
+0xf3, 0x01, 0x42, 0x77, 0x61, 0x72, 0x64, 0x1f, 0x04, 0x01,
+0xf2, 0x01, 0x01, 0xf9, 0x03, 0x00, 0xc5, 0x02, 0x62, 0x6e,
+0x6f, 0x74, 0x00, 0x6e, 0x65, 0x07, 0x01, 0x01, 0x2e, 0x00,
+0x13, 0x61, 0xa8, 0x02, 0x01, 0xd5, 0x03, 0x16, 0x6f, 0x32,
+0x00, 0x03, 0x57, 0x00, 0xa5, 0x3b, 0x00, 0x79, 0x6f, 0x75,
+0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x37, 0x00, 0x10, 0x6d, 0xa4,
+0x01, 0x06, 0x8b, 0x00, 0xa3, 0x66, 0x61, 0x72, 0x00, 0x65,
+0x6e, 0x6f, 0x75, 0x67, 0x68, 0x9a, 0x01, 0x10, 0x65, 0x53,
+0x02, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x64, 0xd3, 0x00, 0x33,
+0x64, 0x69, 0x72, 0x6a, 0x01, 0xf1, 0x07, 0x74, 0x6f, 0x00,
+0x62, 0x65, 0x00, 0x75, 0x6e, 0x61, 0x6d, 0x62, 0x69, 0x67,
+0x75, 0x6f, 0x75, 0x73, 0x2e, 0x00, 0x28, 0x53, 0x6f, 0x64,
+0x00, 0x87, 0x63, 0x61, 0x6e, 0x00, 0x6b, 0x65, 0x65, 0x70,
+0x5b, 0x00, 0x42, 0x6e, 0x65, 0x61, 0x72, 0x36, 0x02, 0x31,
+0x74, 0x61, 0x72, 0x1f, 0x04, 0x07, 0xec, 0x00, 0xb0, 0x63,
+0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x74, 0x6c,
+0x8f, 0x04, 0x35, 0x72, 0x6f, 0x77, 0x91, 0x02, 0x32, 0x6f,
+0x75, 0x74, 0x85, 0x02, 0x20, 0x69, 0x74, 0xfc, 0x03, 0x10,
+0x6d, 0x52, 0x04, 0x05, 0x84, 0x00, 0x20, 0x73, 0x2e, 0x91,
+0x01, 0x22, 0x44, 0x6f, 0xf0, 0x02, 0xd6, 0x69, 0x73, 0x00,
+0x61, 0x67, 0x61, 0x69, 0x6e, 0x00, 0x77, 0x68, 0x65, 0x6e,
+0x85, 0x01, 0x00, 0x17, 0x00, 0xf0, 0x04, 0x6c, 0x72, 0x65,
+0x61, 0x64, 0x79, 0x00, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e,
+0x74, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x1d, 0x03, 0x05, 0xee,
+0x03, 0x06, 0x53, 0x04, 0x03, 0xf7, 0x03, 0x45, 0x49, 0x66,
+0x00, 0x74, 0xcc, 0x03, 0x04, 0x3f, 0x00, 0x22, 0x61, 0x73,
+0x80, 0x00, 0x04, 0x9c, 0x00, 0x08, 0x80, 0x04, 0x07, 0xe3,
+0x01, 0x00, 0x28, 0x00, 0x10, 0x70, 0x08, 0x05, 0x20, 0x74,
+0x74, 0x38, 0x01, 0x11, 0x79, 0x20, 0x00, 0x40, 0x63, 0x75,
+0x72, 0x72, 0x7b, 0x00, 0x34, 0x67, 0x61, 0x6d, 0x29, 0x03,
+0x51, 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x39, 0x00, 0x24, 0x62,
+0x79, 0x21, 0x03, 0x26, 0x29, 0x2c, 0x5b, 0x03, 0x00, 0xd4,
+0x01, 0x11, 0x67, 0x49, 0x05, 0x02, 0x71, 0x01, 0x01, 0xb6,
+0x00, 0x21, 0x72, 0x65, 0xb4, 0x01, 0x00, 0xeb, 0x01, 0x11,
+0x6f, 0xa4, 0x00, 0x10, 0x6d, 0xe3, 0x02, 0x21, 0x49, 0x66,
+0x78, 0x01, 0x31, 0x77, 0x61, 0x6e, 0x24, 0x04, 0x60, 0x72,
+0x65, 0x6d, 0x69, 0x6e, 0x64, 0x13, 0x00, 0x52, 0x72, 0x73,
+0x65, 0x6c, 0x66, 0xf2, 0x03, 0x08, 0xa2, 0x00, 0x90, 0x64,
+0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x0e, 0x05,
+0x10, 0x20, 0x49, 0x02, 0x03, 0xa7, 0x06, 0x0c, 0xb9, 0x02,
+0x45, 0x68, 0x65, 0x6d, 0x2c, 0xd3, 0x01, 0x61, 0x72, 0x69,
+0x67, 0x68, 0x74, 0x2d, 0x6b, 0x02, 0x08, 0x21, 0x00, 0x27,
+0x00, 0x69, 0x83, 0x05, 0x03, 0x7c, 0x02, 0xb3, 0x64, 0x72,
+0x61, 0x77, 0x00, 0x61, 0x00, 0x60, 0x6e, 0x6f, 0x6e, 0xc2,
+0x04, 0x87, 0x27, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x72,
+0xaf, 0x00, 0x00, 0xc7, 0x04, 0x34, 0x6b, 0x00, 0x79, 0x25,
+0x07, 0x00, 0x93, 0x00, 0x42, 0x73, 0x68, 0x65, 0x64, 0xad,
+0x06, 0x24, 0x61, 0x6e, 0x22, 0x02, 0x02, 0x28, 0x01, 0x05,
+0x27, 0x00, 0x01, 0x64, 0x03, 0x11, 0x64, 0x02, 0x01, 0x35,
+0x69, 0x74, 0x73, 0x8d, 0x01, 0x01, 0x4c, 0x02, 0x13, 0x72,
+0x74, 0x05, 0x24, 0x64, 0x65, 0xe8, 0x04, 0x41, 0x74, 0x68,
+0x65, 0x79, 0x18, 0x00, 0x03, 0xa5, 0x00, 0x01, 0xc4, 0x00,
+0x02, 0x44, 0x00, 0x26, 0x73, 0x29, 0xdb, 0x00, 0x00, 0x9c,
+0x00, 0x07, 0xe4, 0x05, 0x00, 0xc3, 0x01, 0x05, 0x8f, 0x00,
+0x81, 0x62, 0x79, 0x00, 0x6c, 0x65, 0x66, 0x74, 0x2d, 0xb9,
+0x03, 0x01, 0x79, 0x05, 0x40, 0x6e, 0x00, 0x69, 0x74, 0xf3,
+0x04, 0x22, 0x69, 0x73, 0x95, 0x01, 0x51, 0x68, 0x69, 0x67,
+0x68, 0x6c, 0x59, 0x00, 0x22, 0x69, 0x74, 0x89, 0x00, 0x03,
+0x8a, 0x03, 0x04, 0x9d, 0x00, 0x08, 0x2e, 0x06, 0x32, 0x00,
+0x69, 0x74, 0xae, 0x05, 0x01, 0xb2, 0x01, 0x20, 0x69, 0x6c,
+0xc8, 0x06, 0x00, 0x9a, 0x02, 0x30, 0x76, 0x65, 0x6e, 0x21,
+0x00, 0x01, 0xed, 0x02, 0x31, 0x61, 0x63, 0x63, 0xc4, 0x00,
+0x01, 0x7d, 0x07, 0x52, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x17,
+0x08, 0x22, 0x6e, 0x79, 0xf6, 0x01, 0x26, 0x6f, 0x73, 0x5c,
+0x00, 0xc9, 0x69, 0x6e, 0x00, 0x66, 0x75, 0x74, 0x75, 0x72,
+0x65, 0x2e, 0x00, 0x4c, 0xa7, 0x00, 0x02, 0x0d, 0x03, 0x10,
+0x6f, 0x0b, 0x03, 0x05, 0xa1, 0x00, 0x24, 0x65, 0x64, 0xe2,
+0x00, 0x01, 0x7a, 0x00, 0x21, 0x75, 0x6e, 0xf9, 0x00, 0x03,
+0xb6, 0x00, 0x40, 0x72, 0x65, 0x73, 0x74, 0x2e, 0x07, 0x11,
+0x79, 0x59, 0x08, 0x51, 0x62, 0x69, 0x6c, 0x69, 0x74, 0xcd,
+0x01, 0x02, 0x81, 0x00, 0x01, 0xf4, 0x00, 0x02, 0xd4, 0x08,
+0x00, 0x32, 0x01, 0x50, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0xda,
+0x03, 0x03, 0xde, 0x02, 0x85, 0x73, 0x6f, 0x72, 0x00, 0x6b,
+0x65, 0x79, 0x73, 0x57, 0x04, 0x61, 0x61, 0x72, 0x6f, 0x75,
+0x6e, 0x64, 0x1f, 0x00, 0xf9, 0x01, 0x67, 0x72, 0x69, 0x64,
+0x3a, 0x00, 0x69, 0x66, 0x00, 0x70, 0x6f, 0x73, 0x73, 0x69,
+0x62, 0x6c, 0x35, 0x00, 0x02, 0x8d, 0x03, 0x52, 0x6c, 0x77,
+0x61, 0x79, 0x73, 0x39, 0x00, 0x80, 0x6f, 0x72, 0x74, 0x68,
+0x6f, 0x67, 0x6f, 0x6e, 0xfd, 0x00, 0x12, 0x2c, 0xc2, 0x04,
+0x63, 0x77, 0x69, 0x73, 0x65, 0x00, 0x69, 0xb9, 0x03, 0x02,
+0xb5, 0x04, 0x07, 0x17, 0x05, 0x00, 0x5c, 0x04, 0x24, 0x65,
+0x73, 0x3c, 0x08, 0x04, 0xfb, 0x04, 0x51, 0x69, 0x6e, 0x64,
+0x69, 0x63, 0x8b, 0x06, 0x05, 0x30, 0x04, 0x60, 0x2e, 0x00,
+0x48, 0x6f, 0x6c, 0x64, 0x1c, 0x01, 0x12, 0x43, 0xb8, 0x05,
+0x01, 0xf7, 0x00, 0x00, 0x16, 0x04, 0x11, 0x73, 0x31, 0x01,
+0x07, 0xc8, 0x00, 0x02, 0x6b, 0x00, 0x37, 0x6c, 0x61, 0x79,
+0x49, 0x04, 0x03, 0xa3, 0x08, 0x06, 0x03, 0x05, 0x90, 0x28,
+0x69, 0x66, 0x00, 0x61, 0x76, 0x61, 0x69, 0x6c, 0xe1, 0x07,
+0x73, 0x29, 0x3b, 0x00, 0x53, 0x68, 0x69, 0x66, 0x01, 0x02,
+0x0f, 0x4b, 0x00, 0x04, 0x01, 0x11, 0x03, 0x1c, 0x00, 0x12,
+0x03, 0x14, 0x50, 0x82, 0x00, 0x01, 0xa2, 0x02, 0x40, 0x65,
+0x74, 0x75, 0x72, 0x40, 0x05, 0x00, 0x8a, 0x07, 0x42, 0x6c,
+0x6c, 0x6f, 0x77, 0x83, 0x02, 0x0e, 0x52, 0x00, 0x01, 0x82,
+0x01, 0x0f, 0xa2, 0x00, 0x0b, 0x08, 0xb1, 0x01, 0x01, 0xea,
+0x01, 0x2f, 0x61, 0x6e, 0xe2, 0x02, 0x04, 0x18, 0x70, 0x83,
+0x00, 0x20, 0x73, 0x70, 0xc7, 0x06, 0x30, 0x62, 0x61, 0x72,
+0xf9, 0x09, 0x0c, 0x1d, 0x00, 0x07, 0xa0, 0x00, 0x51, 0x74,
+0x77, 0x69, 0x63, 0x65, 0xa1, 0x07, 0x07, 0x24, 0x00, 0x04,
+0xa1, 0x0a, 0x00, 0x22, 0x00, 0x06, 0x61, 0x03, 0x45, 0x6a,
+0x75, 0x6d, 0x70, 0xfb, 0x09, 0x0a, 0xb0, 0x01, 0x01, 0xef,
+0x03, 0x02, 0x95, 0x08, 0x03, 0xda, 0x0a, 0xf0, 0x0c, 0x4c,
+0x65, 0x74, 0x74, 0x65, 0x72, 0x73, 0x00, 0x60, 0x61, 0x27,
+0x2c, 0x00, 0x2e, 0x2e, 0x2e, 0x2c, 0x00, 0x60, 0x66, 0x27,
+0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0xb8, 0x00, 0x23, 0x31,
+0x30, 0x16, 0x00, 0x21, 0x31, 0x35, 0x6d, 0x01, 0x31, 0x60,
+0x30, 0x27, 0x17, 0x00, 0x10, 0x36, 0x8b, 0x00, 0x51, 0x56,
+0x69, 0x6f, 0x6c, 0x61, 0x1d, 0x06, 0x03, 0x21, 0x05, 0x04,
+0x5c, 0x08, 0x02, 0x75, 0x05, 0x04, 0x71, 0x03, 0x01, 0x7b,
+0x01, 0x10, 0x64, 0x32, 0x01, 0x42, 0x72, 0x65, 0x64, 0x3a,
+0xe7, 0x09, 0x1a, 0x6e, 0x92, 0x00, 0x2a, 0x6f, 0x6f, 0xef,
+0x05, 0x04, 0x3b, 0x00, 0x09, 0x4d, 0x03, 0x01, 0x40, 0x00,
+0x1f, 0x2e, 0x40, 0x00, 0x05, 0x3f, 0x66, 0x65, 0x77, 0x3f,
+0x00, 0x10, 0x00, 0x1a, 0x03, 0x00, 0xdf, 0x06, 0x09, 0x98,
+0x05, 0xf3, 0x03, 0x61, 0x6e, 0x00, 0x65, 0x72, 0x72, 0x6f,
+0x72, 0x00, 0x28, 0x61, 0x73, 0x00, 0x6f, 0x70, 0x70, 0x6f,
+0x73, 0xb3, 0x07, 0x20, 0x65, 0x72, 0x1f, 0x00, 0x00, 0xb4,
+0x05, 0x20, 0x62, 0x65, 0x70, 0x01, 0x05, 0xc6, 0x01, 0x41,
+0x79, 0x65, 0x74, 0x29, 0x66, 0x03, 0x21, 0x61, 0x64, 0xe4,
+0x02, 0x03, 0xca, 0x07, 0x05, 0x80, 0x00, 0x45, 0x6f, 0x75,
+0x6c, 0x64, 0x6d, 0x0a, 0x31, 0x68, 0x61, 0x76, 0xd1, 0x01,
+0x12, 0x6f, 0xfa, 0x0a, 0x0b, 0xf8, 0x0a, 0x00, 0xf8, 0x01,
+0x04, 0x6a, 0x06, 0x16, 0x00, 0xc4, 0x05, 0x03, 0xb1, 0x02,
+0x10, 0x2c, 0x1f, 0x00, 0x28, 0x69, 0x66, 0x30, 0x05, 0x20,
+0x68, 0x61, 0x0f, 0x07, 0x29, 0x65, 0x6e, 0xde, 0x00, 0x01,
+0xae, 0x09, 0x54, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x49, 0x0b,
+0x68, 0x00, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x09, 0x0d, 0x01,
+0x55, 0x0a, 0x07, 0x7d, 0x0a, 0x0f, 0x21, 0x01, 0x0c, 0x41,
+0x61, 0x00, 0x63, 0x6c, 0x0a, 0x01, 0x33, 0x73, 0x75, 0x62,
+0x53, 0x0d, 0x07, 0xe3, 0x01, 0x01, 0x78, 0x01, 0x24, 0x6e,
+0x6f, 0x85, 0x06, 0x04, 0x12, 0x0d, 0x02, 0x39, 0x0b, 0x02,
+0xbc, 0x02, 0x15, 0x73, 0x34, 0x00, 0x03, 0x82, 0x00, 0x90,
+0x2e, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x65, 0x78, 0x61, 0xa9,
+0x00, 0x32, 0x2c, 0x00, 0x69, 0x9b, 0x06, 0x02, 0x42, 0x03,
+0x26, 0x6c, 0x79, 0x56, 0x0d, 0x4c, 0x77, 0x6f, 0x00, 0x31,
+0x51, 0x0d, 0x05, 0x79, 0x03, 0x01, 0x77, 0x04, 0x04, 0x6a,
+0x06, 0x22, 0x6e, 0x6f, 0x85, 0x0d, 0x01, 0x6a, 0x09, 0x08,
+0x76, 0x07, 0x25, 0x6f, 0x6e, 0x0e, 0x05, 0x01, 0xe7, 0x07,
+0x04, 0x1a, 0x04, 0x01, 0x3a, 0x06, 0x43, 0x75, 0x70, 0x00,
+0x72, 0x20, 0x06, 0x03, 0xb9, 0x04, 0x02, 0x14, 0x03, 0x03,
+0xa9, 0x0d, 0x02, 0x39, 0x01, 0x32, 0x63, 0x61, 0x6e, 0xf9,
+0x01, 0x04, 0x10, 0x0e, 0x02, 0x23, 0x01, 0x00, 0xa6, 0x02,
+0xa4, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x00, 0x73, 0x6f, 0x6c,
+0x75, 0xf9, 0x03, 0x14, 0x2d, 0x68, 0x07, 0x01, 0x37, 0x07,
+0x33, 0x73, 0x65, 0x6c, 0x82, 0x06, 0x40, 0x68, 0x65, 0x00,
+0x28, 0xd4, 0x01, 0x04, 0x73, 0x08, 0x34, 0x00, 0x6f, 0x70,
+0xd1, 0x09, 0x40, 0x64, 0x69, 0x73, 0x61, 0x73, 0x04, 0x01,
+0xfd, 0x0b, 0x15, 0x73, 0xd9, 0x07, 0x03, 0x55, 0x00, 0x15,
+0x2c, 0x88, 0x00, 0x07, 0x32, 0x0c, 0x02, 0xc4, 0x0c, 0x00,
+0x34, 0x0c, 0x14, 0x73, 0x35, 0x0c, 0x0e, 0xea, 0x02, 0x01,
+0x22, 0x03, 0x14, 0x28, 0x48, 0x0d, 0x02, 0xd0, 0x08, 0x00,
+0xee, 0x02, 0x52, 0x73, 0x63, 0x72, 0x69, 0x62, 0xc4, 0x00,
+0x13, 0x73, 0x54, 0x05, 0x33, 0x32, 0x2e, 0x31, 0x75, 0x09,
+0x26, 0x73, 0x6f, 0x5d, 0x05, 0x13, 0x2e, 0x7a, 0x0b, 0x15,
+0x32, 0x7a, 0x0b, 0x00, 0xb3, 0x09, 0x20, 0x6d, 0x65, 0x27,
+0x04, 0x12, 0x20, 0x79, 0x0d, 0x36, 0x73, 0x65, 0x00, 0x14,
+0x00, 0x02, 0x43, 0x00, 0x04, 0x3e, 0x00, 0x02, 0x55, 0x07,
+0x00, 0x7b, 0x00, 0xb4, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f,
+0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0xf7, 0x00, 0x03, 0x96, 0x01,
+0x40, 0x60, 0x54, 0x79, 0x70, 0x93, 0x05, 0x30, 0x65, 0x6e,
+0x75, 0xad, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c,
+0x00, 0x48, 0x65, 0x9d, 0x01, 0x51, 0x00, 0x00, 0x53, 0x69,
+0x7a, 0x07, 0x0c, 0x00, 0xbd, 0x01, 0x01, 0xaf, 0x00, 0x42,
+0x71, 0x75, 0x61, 0x72, 0xcc, 0x0c, 0xaa, 0x44, 0x69, 0x66,
+0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x0d, 0x00, 0x41,
+0x6c, 0x65, 0x76, 0x65, 0xa6, 0x09, 0x02, 0x9e, 0x02, 0x00,
+0x2b, 0x00, 0x10, 0x41, 0x5d, 0x01, 0x12, 0x20, 0x5d, 0x01,
+0x12, 0x00, 0x41, 0x08, 0x21, 0x69, 0x73, 0x1c, 0x10, 0x06,
+0x03, 0x0a, 0x01, 0x7d, 0x0a, 0x20, 0x63, 0x6c, 0x24, 0x05,
+0x23, 0x64, 0x2c, 0x3c, 0x00, 0x06, 0x3e, 0x04, 0x51, 0x67,
+0x65, 0x6e, 0x65, 0x72, 0xd6, 0x06, 0x0e, 0xc5, 0x0f, 0x06,
+0x83, 0x02, 0x03, 0x4f, 0x07, 0x00, 0xb9, 0x01, 0x13, 0x62,
+0x18, 0x03, 0x00, 0x49, 0x0b, 0x33, 0x63, 0x72, 0x65, 0x9b,
+0x0f, 0x01, 0xa9, 0x01, 0x02, 0x87, 0x08, 0x04, 0xde, 0x01,
+0x04, 0xcb, 0x01, 0x25, 0x64, 0x6f, 0x25, 0x04, 0x0b, 0xd0,
+0x01, 0x04, 0x1e, 0x02, 0x02, 0xcf, 0x01, 0x64, 0x4d, 0x61,
+0x78, 0x2e, 0x20, 0x62, 0x8e, 0x01, 0x36, 0x65, 0x72, 0x20,
+0x18, 0x07, 0x01, 0x1d, 0x00, 0x4e, 0x69, 0x6d, 0x75, 0x6d,
+0x22, 0x10, 0x04, 0xaf, 0x02, 0x20, 0x70, 0x61, 0x4f, 0x10,
+0x48, 0x75, 0x6c, 0x61, 0x72, 0xae, 0x06, 0x17, 0x54, 0x2b,
+0x0e, 0x42, 0x69, 0x73, 0x00, 0x32, 0xc6, 0x0f, 0x04, 0x44,
+0x06, 0x01, 0x21, 0x0f, 0x13, 0x65, 0xcf, 0x03, 0x40, 0x31,
+0x2c, 0x00, 0x33, 0x88, 0x04, 0x53, 0x34, 0x2e, 0x00, 0x49,
+0x6e, 0x17, 0x01, 0x20, 0x6c, 0x2c, 0x72, 0x05, 0x21, 0x65,
+0x72, 0x6d, 0x10, 0x32, 0x61, 0x73, 0x69, 0x6e, 0x0a, 0x82,
+0x25, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x87, 0x03,
+0x13, 0x20, 0xba, 0x01, 0x70, 0x00, 0x00, 0x00, 0x47, 0x69,
+0x76, 0x65, 0xb5, 0x02, 0x11, 0x72, 0x28, 0x05, 0x40, 0x70,
+0x65, 0x72, 0x63, 0x73, 0x09, 0x28, 0x67, 0x65, 0xa0, 0x04,
+0x25, 0x74, 0x68, 0x74, 0x01, 0x04, 0xac, 0x08, 0x31, 0x74,
+0x72, 0x79, 0x39, 0x01, 0x11, 0x6c, 0xaf, 0x04, 0x34, 0x66,
+0x6f, 0x72, 0xbb, 0x0a, 0x05, 0xbc, 0x0f, 0x03, 0xf0, 0x01,
+0x30, 0x43, 0x65, 0x72, 0xa4, 0x03, 0x00, 0x29, 0x00, 0x33,
+0x6f, 0x75, 0x74, 0xc4, 0x01, 0x00, 0xc0, 0x03, 0x30, 0x6d,
+0x61, 0x6e, 0x67, 0x00, 0x12, 0x74, 0xbf, 0x07, 0x03, 0xa8,
+0x05, 0x03, 0x72, 0x00, 0x12, 0x3b, 0xca, 0x0c, 0x10, 0x69,
+0x1b, 0x05, 0x40, 0x00, 0x75, 0x70, 0x70, 0x94, 0x05, 0x22,
+0x6f, 0x75, 0x13, 0x11, 0xf0, 0x03, 0x45, 0x78, 0x70, 0x61,
+0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x61, 0x63, 0x74,
+0x6f, 0x72, 0x20, 0x28, 0xdc, 0x00, 0x12, 0x29, 0x00, 0x03,
+0x02, 0x9b, 0x02, 0x07, 0xac, 0x00, 0x41, 0x6f, 0x72, 0x6b,
+0x73, 0xbe, 0x07, 0x04, 0x10, 0x0a, 0x69, 0x6e, 0x00, 0x65,
+0x78, 0x69, 0x73, 0x7d, 0x0d, 0xf8, 0x05, 0x74, 0x00, 0x72,
+0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x00, 0x28, 0x61, 0x66, 0x74,
+0x65, 0x72, 0x00, 0x66, 0x69, 0x72, 0x73, 0x28, 0x02, 0x20,
+0x6e, 0x00, 0x90, 0x06, 0x34, 0x69, 0x61, 0x6c, 0x32, 0x00,
+0x00, 0x7f, 0x10, 0x10, 0x77, 0x1a, 0x0d, 0x41, 0x29, 0x2e,
+0x00, 0x49, 0x72, 0x02, 0x40, 0x6e, 0x00, 0x64, 0x65, 0xae,
+0x0a, 0x12, 0x73, 0x6b, 0x0a, 0x07, 0x1e, 0x09, 0x05, 0x5e,
+0x00, 0x24, 0x29, 0x2c, 0x22, 0x05, 0x13, 0x6e, 0x97, 0x00,
+0x00, 0x8e, 0x02, 0x31, 0x68, 0x6f, 0x77, 0x72, 0x0e, 0x41,
+0x69, 0x74, 0x00, 0x63, 0x9c, 0x06, 0x20, 0x65, 0x78, 0x6c,
+0x0e, 0x04, 0x54, 0x01, 0x07, 0x85, 0x00, 0x08, 0xc6, 0x0e,
+0x03, 0x78, 0x0b, 0x05, 0xeb, 0x03, 0x32, 0x00, 0x64, 0x65,
+0x75, 0x12, 0x21, 0x65, 0x73, 0x52, 0x00, 0x50, 0x6c, 0x69,
+0x6b, 0x65, 0x6c, 0xad, 0x0a, 0x03, 0x17, 0x13, 0x03, 0x55,
+0x00, 0x21, 0x61, 0x73, 0x6c, 0x00, 0x21, 0x61, 0x73, 0x6f,
+0x00, 0x66, 0x61, 0x6e, 0x2c, 0x00, 0x72, 0x61, 0x40, 0x11,
+0x41, 0x63, 0x68, 0x6f, 0x6f, 0xbd, 0x08, 0x05, 0xdf, 0x00,
+0x02, 0x68, 0x06, 0x01, 0x40, 0x02, 0x64, 0x48, 0x69, 0x67,
+0x68, 0x00, 0x65, 0x7b, 0x01, 0x12, 0x00, 0x7b, 0x01, 0x52,
+0x73, 0x00, 0x75, 0x73, 0x75, 0x9f, 0x0b, 0x33, 0x65, 0x61,
+0x6e, 0x6e, 0x02, 0x07, 0xae, 0x03, 0x23, 0x74, 0x68, 0x8b,
+0x02, 0x05, 0xf3, 0x0a, 0x05, 0xe0, 0x01, 0x00, 0x60, 0x05,
+0x0e, 0x4f, 0x00, 0x01, 0xe1, 0x02, 0x20, 0x72, 0x65, 0xf8,
+0x05, 0x32, 0x6c, 0x6f, 0x74, 0xbd, 0x08, 0x00, 0x7c, 0x04,
+0x73, 0x6c, 0x79, 0x2d, 0x70, 0x61, 0x63, 0x6b, 0xb9, 0x0b,
+0x50, 0x6e, 0x64, 0x73, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 5230;
diff --git a/apps/plugins/puzzles/help/cube.c b/apps/plugins/puzzles/help/cube.c
index 3d9137afe0..f8026a5946 100644
--- a/apps/plugins/puzzles/help/cube.c
+++ b/apps/plugins/puzzles/help/cube.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,148 +14,148 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2055 comp 1444 ratio 0.702676 level 11 saved 611 */
+/* orig 2055 comp 1444 ratio 0.702676 level 10 saved 611 */
 const char help_text[] = {
-0xf1, 0x37, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
+0xf2, 0x37, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x34, 0x3a, 0x20, 0x43, 0x75, 0x62, 0x65, 0x20, 0x00, 0x00,
 0x00, 0x54, 0x68, 0x69, 0x73, 0x00, 0x69, 0x73, 0x00, 0x61,
 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x6f, 0x6e, 0x65,
 0x00, 0x49, 0x00, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61,
 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x61, 0x77, 0x00, 0x61, 0x73,
 0x00, 0x61, 0x00, 0x77, 0x65, 0x62, 0x00, 0x67, 0x61, 0x6d,
-0x65, 0x2e, 0x34, 0x00, 0x01, 0x29, 0x00, 0x11, 0x77, 0x19,
+0x65, 0x2e, 0x34, 0x00, 0x00, 0x29, 0x00, 0x11, 0x77, 0x19,
 0x00, 0x41, 0x4a, 0x61, 0x76, 0x61, 0x1a, 0x00, 0xf0, 0x28,
 0x00, 0x5b, 0x32, 0x5d, 0x2c, 0x00, 0x62, 0x79, 0x00, 0x50,
 0x61, 0x75, 0x6c, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x2e,
 0x00, 0x59, 0x6f, 0x75, 0x00, 0x68, 0x61, 0x76, 0x65, 0x00,
 0x61, 0x00, 0x67, 0x72, 0x69, 0x64, 0x00, 0x6f, 0x66, 0x00,
 0x31, 0x36, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x73,
-0x2c, 0x00, 0x73, 0x69, 0x78, 0x13, 0x00, 0xf0, 0x03, 0x77,
+0x2c, 0x00, 0x73, 0x69, 0x78, 0x13, 0x00, 0xf1, 0x03, 0x77,
 0x68, 0x69, 0x63, 0x68, 0x00, 0x61, 0x72, 0x65, 0x00, 0x62,
-0x6c, 0x75, 0x65, 0x3b, 0x00, 0x6f, 0x6e, 0x61, 0x00, 0x03,
+0x6c, 0x75, 0x65, 0x3b, 0x00, 0x6f, 0x6e, 0x61, 0x00, 0x02,
 0x27, 0x00, 0x50, 0x00, 0x72, 0x65, 0x73, 0x74, 0x6a, 0x00,
 0x41, 0x63, 0x75, 0x62, 0x65, 0x52, 0x00, 0x60, 0x72, 0x00,
 0x6d, 0x6f, 0x76, 0x65, 0xb8, 0x00, 0xf1, 0x05, 0x74, 0x6f,
 0x00, 0x75, 0x73, 0x65, 0x00, 0x74, 0x68, 0x65, 0x00, 0x61,
 0x72, 0x72, 0x6f, 0x77, 0x00, 0x6b, 0x65, 0x79, 0x16, 0x00,
-0x40, 0x72, 0x6f, 0x6c, 0x6c, 0x17, 0x00, 0x00, 0x35, 0x00,
-0x00, 0x20, 0x00, 0xf1, 0x0c, 0x72, 0x6f, 0x75, 0x67, 0x68,
+0x41, 0x72, 0x6f, 0x6c, 0x6c, 0x17, 0x00, 0x00, 0x35, 0x00,
+0xf1, 0x0f, 0x00, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68,
 0x00, 0x39, 0x30, 0x00, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65,
 0x73, 0x00, 0x73, 0x6f, 0x00, 0x74, 0x68, 0x61, 0x74, 0x00,
 0x69, 0x74, 0x4d, 0x00, 0x01, 0x35, 0x00, 0xb3, 0x61, 0x6e,
 0x00, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x7c,
 0x00, 0x8b, 0x2e, 0x00, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75,
-0x50, 0x00, 0x21, 0x6f, 0x6e, 0x2f, 0x00, 0x00, 0xae, 0x00,
-0x04, 0xa6, 0x00, 0x10, 0x2c, 0x1e, 0x00, 0x07, 0x11, 0x00,
-0x01, 0x9f, 0x00, 0x94, 0x70, 0x69, 0x63, 0x6b, 0x65, 0x64,
-0x00, 0x75, 0x70, 0xd2, 0x00, 0x75, 0x66, 0x61, 0x63, 0x65,
-0x00, 0x6f, 0x66, 0x4a, 0x00, 0x36, 0x3b, 0x00, 0x69, 0x60,
-0x00, 0x02, 0x51, 0x00, 0x05, 0x25, 0x00, 0x0e, 0x6f, 0x00,
+0x50, 0x00, 0x21, 0x6f, 0x6e, 0x2f, 0x00, 0x01, 0xae, 0x00,
+0x03, 0x2a, 0x00, 0x11, 0x2c, 0x1e, 0x00, 0x07, 0x11, 0x00,
+0x00, 0x9f, 0x00, 0x94, 0x70, 0x69, 0x63, 0x6b, 0x65, 0x64,
+0x00, 0x75, 0x70, 0xd2, 0x00, 0x40, 0x66, 0x61, 0x63, 0x65,
+0xf1, 0x00, 0x04, 0x4a, 0x00, 0x37, 0x3b, 0x00, 0x69, 0x60,
+0x00, 0x03, 0x51, 0x00, 0x0c, 0x25, 0x00, 0x05, 0x6f, 0x00,
 0x4f, 0x6e, 0x6f, 0x6e, 0x2d, 0x73, 0x00, 0x02, 0x41, 0x6e,
-0x65, 0x73, 0x73, 0x70, 0x00, 0xfd, 0x15, 0x75, 0x74, 0x00,
+0x65, 0x73, 0x73, 0x70, 0x00, 0xfe, 0x15, 0x75, 0x74, 0x00,
 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x61, 0x67, 0x61, 0x69, 0x6e,
 0x2e, 0x00, 0x28, 0x49, 0x6e, 0x00, 0x67, 0x65, 0x6e, 0x65,
 0x72, 0x61, 0x6c, 0x2c, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x65,
-0x76, 0x65, 0x72, 0xd0, 0x00, 0x03, 0x49, 0x00, 0x31, 0x74,
+0x76, 0x65, 0x72, 0xd0, 0x00, 0x02, 0x49, 0x00, 0x31, 0x74,
 0x77, 0x6f, 0x7b, 0x00, 0x12, 0x73, 0x19, 0x01, 0xf2, 0x11,
 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x6f, 0x00,
 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x00, 0x73, 0x77,
 0x61, 0x70, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x73,
 0x2e, 0x29, 0x89, 0x01, 0x33, 0x6a, 0x6f, 0x62, 0x88, 0x01,
-0x70, 0x67, 0x65, 0x74, 0x00, 0x61, 0x6c, 0x6c, 0xd3, 0x01,
-0x08, 0x07, 0x01, 0x12, 0x73, 0xbe, 0x00, 0x00, 0x62, 0x00,
-0x00, 0x1b, 0x00, 0x02, 0x62, 0x00, 0x09, 0xde, 0x00, 0x22,
+0x71, 0x67, 0x65, 0x74, 0x00, 0x61, 0x6c, 0x6c, 0xd3, 0x01,
+0x07, 0xa5, 0x00, 0x13, 0x73, 0xbe, 0x00, 0x00, 0x62, 0x00,
+0x00, 0x1b, 0x00, 0x02, 0x62, 0x00, 0x08, 0xde, 0x00, 0x22,
 0x61, 0x74, 0x1d, 0x00, 0x00, 0x43, 0x02, 0x20, 0x74, 0x69,
 0x62, 0x02, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x79,
 0xe9, 0x01, 0x00, 0x9f, 0x02, 0x50, 0x64, 0x00, 0x74, 0x72,
 0x79, 0x48, 0x00, 0x20, 0x64, 0x6f, 0xb3, 0x01, 0x20, 0x69,
-0x6e, 0x96, 0x02, 0x21, 0x66, 0x65, 0x9d, 0x02, 0xf1, 0x02,
+0x6e, 0x96, 0x02, 0x21, 0x66, 0x65, 0x9d, 0x02, 0xf2, 0x02,
 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x2e, 0x00,
-0x00, 0x00, 0x55, 0x6e, 0x6c, 0x69, 0x6b, 0x11, 0x02, 0x05,
+0x00, 0x00, 0x55, 0x6e, 0x6c, 0x69, 0x6b, 0x11, 0x02, 0x04,
 0xc6, 0x02, 0x06, 0xa2, 0x02, 0xf2, 0x01, 0x2c, 0x00, 0x6d,
 0x79, 0x00, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00,
 0x68, 0x61, 0x73, 0xf1, 0x01, 0x50, 0x64, 0x69, 0x74, 0x69,
 0x6f, 0x28, 0x00, 0xd0, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
-0x65, 0x3a, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x7f, 0x00, 0xc0,
+0x65, 0x3a, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x7f, 0x00, 0xc1,
 0x27, 0x76, 0x65, 0x00, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72,
-0x65, 0x64, 0x53, 0x00, 0x02, 0xe7, 0x02, 0x43, 0x77, 0x69,
+0x65, 0x64, 0x53, 0x00, 0x01, 0xe7, 0x02, 0x43, 0x77, 0x69,
 0x74, 0x68, 0x8e, 0x02, 0x01, 0x47, 0x01, 0x30, 0x69, 0x6e,
-0x67, 0xe4, 0x00, 0x13, 0x61, 0xf1, 0x00, 0x01, 0xe8, 0x02,
+0x67, 0xe4, 0x00, 0x14, 0x61, 0xf8, 0x01, 0x00, 0xe8, 0x02,
 0x11, 0x2c, 0x65, 0x01, 0xa2, 0x63, 0x61, 0x6e, 0x00, 0x63,
-0x68, 0x61, 0x6e, 0x67, 0x65, 0xc0, 0x01, 0xa1, 0x74, 0x72,
-0x69, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x25, 0x00,
-0x00, 0xd7, 0x00, 0x03, 0xf9, 0x01, 0x50, 0x6e, 0x79, 0x00,
-0x6f, 0x66, 0x22, 0x00, 0xb0, 0x65, 0x74, 0x72, 0x61, 0x68,
+0x68, 0x61, 0x6e, 0x67, 0x65, 0xc0, 0x01, 0xa2, 0x74, 0x72,
+0x69, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x0d, 0x03,
+0x00, 0xd7, 0x00, 0x02, 0xf9, 0x01, 0x20, 0x6e, 0x79, 0x13,
+0x01, 0xe0, 0x61, 0x00, 0x74, 0x65, 0x74, 0x72, 0x61, 0x68,
 0x65, 0x64, 0x72, 0x6f, 0x6e, 0x2c, 0x9e, 0x00, 0x33, 0x6f,
 0x63, 0x74, 0x0f, 0x00, 0x30, 0x00, 0x6f, 0x72, 0x11, 0x00,
-0x43, 0x69, 0x63, 0x6f, 0x73, 0x12, 0x00, 0x30, 0x2e, 0x00,
-0x00, 0x73, 0x03, 0xf0, 0x10, 0x00, 0x68, 0x74, 0x74, 0x70,
+0x43, 0x69, 0x63, 0x6f, 0x73, 0x12, 0x00, 0x00, 0xef, 0x00,
+0xf0, 0x13, 0x5b, 0x32, 0x5d, 0x00, 0x68, 0x74, 0x74, 0x70,
 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x33, 0x2e, 0x73, 0x79,
 0x6d, 0x70, 0x61, 0x74, 0x69, 0x63, 0x6f, 0x2e, 0x63, 0x61,
 0x2f, 0x70, 0x61, 0x75, 0x6c, 0x73, 0x87, 0x03, 0x10, 0x2f,
 0xac, 0x00, 0x11, 0x2f, 0x3f, 0x03, 0x92, 0x68, 0x74, 0x6d,
 0x00, 0x00, 0x00, 0x34, 0x2e, 0x31, 0x03, 0x04, 0x00, 0xdb,
-0x01, 0x44, 0x72, 0x6f, 0x6c, 0x73, 0x0c, 0x04, 0x01, 0xe2,
-0x00, 0x01, 0xb8, 0x00, 0x92, 0x62, 0x65, 0x00, 0x70, 0x6c,
-0x61, 0x79, 0x65, 0x64, 0xf0, 0x00, 0x20, 0x65, 0x69, 0x20,
-0x04, 0x00, 0x05, 0x01, 0x00, 0x63, 0x03, 0x72, 0x62, 0x6f,
+0x01, 0x45, 0x72, 0x6f, 0x6c, 0x73, 0x0c, 0x04, 0x01, 0xe2,
+0x00, 0x00, 0xb8, 0x00, 0x92, 0x62, 0x65, 0x00, 0x70, 0x6c,
+0x61, 0x79, 0x65, 0x64, 0xf0, 0x00, 0x21, 0x65, 0x69, 0x20,
+0x04, 0x00, 0x05, 0x01, 0xa2, 0x6b, 0x65, 0x79, 0x62, 0x6f,
 0x61, 0x72, 0x64, 0x00, 0x6f, 0x10, 0x00, 0x41, 0x6d, 0x6f,
-0x75, 0x73, 0x7c, 0x01, 0xd0, 0x4c, 0x65, 0x66, 0x74, 0x2d,
-0x63, 0x6c, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0xd4, 0x00,
-0x42, 0x77, 0x68, 0x65, 0x72, 0xbe, 0x02, 0x10, 0x68, 0x37,
-0x01, 0x91, 0x6e, 0x64, 0x6f, 0x77, 0x00, 0x77, 0x69, 0x6c,
-0x6c, 0xd6, 0x01, 0x06, 0x01, 0x02, 0x42, 0x28, 0x6f, 0x72,
+0x75, 0x73, 0x7c, 0x01, 0xa0, 0x4c, 0x65, 0x66, 0x74, 0x2d,
+0x63, 0x6c, 0x69, 0x63, 0x6b, 0x13, 0x01, 0x72, 0x61, 0x6e,
+0x79, 0x77, 0x68, 0x65, 0x72, 0xbe, 0x02, 0x10, 0x68, 0x37,
+0x01, 0x92, 0x6e, 0x64, 0x6f, 0x77, 0x00, 0x77, 0x69, 0x6c,
+0x6c, 0xbf, 0x03, 0x05, 0x01, 0x02, 0x42, 0x28, 0x6f, 0x72,
 0x00, 0x7f, 0x04, 0xe6, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x29,
 0x00, 0x74, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x73, 0x5e, 0x00,
-0x90, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x2e,
-0xa7, 0x00, 0x0a, 0xec, 0x03, 0x10, 0x63, 0xc4, 0x01, 0x20,
-0x6c, 0x73, 0x08, 0x04, 0x00, 0xa5, 0x01, 0x1e, 0x6f, 0xaa,
-0x03, 0x38, 0x69, 0x74, 0x73, 0x9b, 0x01, 0x22, 0x00, 0x69,
+0x91, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x2e,
+0xa7, 0x00, 0x09, 0xec, 0x03, 0x10, 0x63, 0xc4, 0x01, 0x21,
+0x6c, 0x73, 0x08, 0x04, 0x1e, 0x64, 0xfa, 0x03, 0x68, 0x6f,
+0x6e, 0x00, 0x69, 0x74, 0x73, 0x9b, 0x01, 0x22, 0x00, 0x69,
 0x90, 0x00, 0x10, 0x66, 0x5f, 0x02, 0x41, 0x63, 0x61, 0x72,
 0x64, 0x24, 0x02, 0x50, 0x64, 0x69, 0x72, 0x65, 0x63, 0x08,
-0x02, 0x41, 0x73, 0x2e, 0x00, 0x4f, 0x21, 0x00, 0x0c, 0xae,
+0x02, 0x42, 0x73, 0x2e, 0x00, 0x4f, 0x21, 0x00, 0x0b, 0xae,
 0x01, 0x22, 0x73, 0x2c, 0x90, 0x00, 0x31, 0x61, 0x70, 0x70,
-0xf2, 0x01, 0x1a, 0x66, 0x72, 0x04, 0x06, 0x42, 0x00, 0x01,
-0x8a, 0x03, 0xf2, 0x0a, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x61,
+0xf2, 0x01, 0x1b, 0x66, 0x72, 0x04, 0x06, 0x42, 0x00, 0x00,
+0x11, 0x03, 0xf2, 0x0a, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x61,
 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65,
 0x2e, 0x00, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0xfd,
-0x00, 0x40, 0x6d, 0x65, 0x6e, 0x74, 0x27, 0x00, 0xb2, 0x64,
-0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x00,
+0x00, 0x10, 0x6d, 0x63, 0x04, 0xb0, 0x69, 0x73, 0x00, 0x64,
+0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x67, 0x01, 0x01,
 0x2d, 0x01, 0x10, 0x69, 0xc1, 0x03, 0xe0, 0x65, 0x73, 0x6e,
 0x27, 0x74, 0x00, 0x6d, 0x61, 0x6b, 0x65, 0x00, 0x73, 0x65,
-0x6e, 0x5d, 0x01, 0x13, 0x54, 0xb1, 0x00, 0x02, 0x6e, 0x00,
-0xbb, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x69,
-0x6e, 0x67, 0xfb, 0x04, 0x04, 0x6d, 0x01, 0x70, 0x6e, 0x75,
+0x6e, 0x5d, 0x01, 0x14, 0x54, 0xb1, 0x00, 0x01, 0x6e, 0x00,
+0x80, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x88,
+0x00, 0x0b, 0xfb, 0x04, 0x03, 0x6d, 0x01, 0x70, 0x6e, 0x75,
 0x6d, 0x65, 0x72, 0x69, 0x63, 0x14, 0x00, 0xc0, 0x70, 0x61,
 0x64, 0x00, 0x28, 0x60, 0x37, 0x27, 0x2c, 0x00, 0x60, 0x39,
-0x05, 0x00, 0x10, 0x31, 0x05, 0x00, 0x33, 0x33, 0x27, 0x29,
-0xe6, 0x01, 0x02, 0x38, 0x01, 0xa7, 0x66, 0x6f, 0x72, 0x00,
+0x05, 0x00, 0x10, 0x31, 0x05, 0x00, 0x34, 0x33, 0x27, 0x29,
+0xe6, 0x01, 0x01, 0x38, 0x01, 0xa7, 0x66, 0x6f, 0x72, 0x00,
 0x64, 0x69, 0x61, 0x67, 0x6f, 0x6e, 0xa1, 0x00, 0x00, 0x6e,
 0x01, 0x23, 0x28, 0x41, 0x4e, 0x01, 0x13, 0x61, 0xdc, 0x00,
 0x81, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x48,
-0x01, 0x12, 0x73, 0xf2, 0x00, 0x40, 0x00, 0x32, 0x2e, 0x31,
-0xbe, 0x05, 0x02, 0x89, 0x01, 0x60, 0x61, 0x76, 0x61, 0x69,
+0x01, 0x12, 0x73, 0xf2, 0x00, 0x41, 0x00, 0x32, 0x2e, 0x31,
+0xbe, 0x05, 0x01, 0x89, 0x01, 0x60, 0x61, 0x76, 0x61, 0x69,
 0x6c, 0x61, 0x90, 0x03, 0x11, 0x29, 0x6b, 0x02, 0x12, 0x32,
 0x6b, 0x02, 0x93, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x6d, 0x02, 0x46, 0x65, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x00, 0x3f, 0x00, 0x06, 0x3a, 0x00, 0x51, 0x00, 0x66,
-0x72, 0x6f, 0x6d, 0x77, 0x00, 0xe0, 0x60, 0x43, 0x75, 0x73,
+0x65, 0x72, 0x6d, 0x02, 0x10, 0x65, 0xd7, 0x01, 0x05, 0x14,
+0x00, 0x02, 0x3f, 0x00, 0x04, 0x3a, 0x00, 0x51, 0x00, 0x66,
+0x72, 0x6f, 0x6d, 0x77, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73,
 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70,
-0x6d, 0x00, 0x04, 0xe3, 0x00, 0xb0, 0x60, 0x54, 0x79, 0x70,
-0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xa9, 0x00, 0x00,
-0x0e, 0x00, 0x41, 0x20, 0x6f, 0x66, 0x20, 0x43, 0x02, 0x91,
+0x6d, 0x00, 0x03, 0xe3, 0x00, 0xb1, 0x60, 0x54, 0x79, 0x70,
+0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0x17, 0x02, 0x71,
+0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x43, 0x02, 0x92,
 0x00, 0x00, 0x00, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x44,
-0x02, 0x01, 0x57, 0x02, 0x06, 0x1c, 0x02, 0x10, 0x28, 0x77,
-0x03, 0x52, 0x68, 0x65, 0x6e, 0x63, 0x65, 0x1d, 0x00, 0x33,
-0x68, 0x61, 0x70, 0x6f, 0x05, 0x02, 0x21, 0x02, 0x29, 0x29,
-0x3a, 0x87, 0x03, 0x02, 0x22, 0x05, 0x07, 0x8a, 0x03, 0x4c,
-0x2c, 0x00, 0x6f, 0x72, 0x88, 0x03, 0xf0, 0x0c, 0x57, 0x69,
+0x02, 0x02, 0x14, 0x00, 0x04, 0x1c, 0x02, 0x10, 0x28, 0x77,
+0x03, 0x20, 0x68, 0x65, 0xe4, 0x03, 0x01, 0x1d, 0x00, 0x35,
+0x68, 0x61, 0x70, 0x6f, 0x05, 0x00, 0xe9, 0x01, 0x2a, 0x29,
+0x3a, 0x87, 0x03, 0x02, 0x22, 0x05, 0x06, 0x8a, 0x03, 0x10,
+0x2c, 0xf9, 0x02, 0x0b, 0x88, 0x03, 0xf0, 0x0c, 0x57, 0x69,
 0x64, 0x74, 0x68, 0x20, 0x2f, 0x20, 0x74, 0x6f, 0x70, 0x2c,
 0x00, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x2f, 0x20,
 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x70, 0x03, 0x1d, 0x4f, 0x1f,
 0x04, 0x50, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x58, 0x05, 0x11,
-0x6c, 0x06, 0x04, 0x14, 0x76, 0x1d, 0x02, 0x64, 0x64, 0x69,
-0x6d, 0x65, 0x6e, 0x73, 0x88, 0x02, 0x0e, 0x34, 0x04, 0x14,
+0x6c, 0x06, 0x04, 0x14, 0x76, 0x1d, 0x02, 0x65, 0x64, 0x69,
+0x6d, 0x65, 0x6e, 0x73, 0x88, 0x02, 0x0d, 0x34, 0x04, 0x14,
 0x2c, 0xdf, 0x01, 0x10, 0x62, 0xae, 0x07, 0x13, 0x66, 0x1f,
 0x00, 0x25, 0x6c, 0x65, 0xfa, 0x01, 0x31, 0x74, 0x6f, 0x70,
 0x52, 0x00, 0x03, 0x7c, 0x00, 0x40, 0x72, 0x6f, 0x77, 0x73,
diff --git a/apps/plugins/puzzles/help/dominosa.c b/apps/plugins/puzzles/help/dominosa.c
index b2994d79da..f1c61620ee 100644
--- a/apps/plugins/puzzles/help/dominosa.c
+++ b/apps/plugins/puzzles/help/dominosa.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2278 comp 1541 ratio 0.676471 level 11 saved 737 */
+/* orig 2278 comp 1541 ratio 0.676471 level 10 saved 737 */
 const char help_text[] = {
 0xf1, 0x1a, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x37, 0x3a, 0x20, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x6f,
@@ -37,16 +37,16 @@ const char help_text[] = {
 0x65, 0x3b, 0x00, 0x74, 0x68, 0x65, 0x6e, 0x05, 0x00, 0x03,
 0x4f, 0x00, 0xf6, 0x00, 0x00, 0x69, 0x6e, 0x00, 0x65, 0x61,
 0x63, 0x68, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x4f,
-0x00, 0xf0, 0x01, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e,
+0x00, 0xf1, 0x01, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e,
 0x00, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x61, 0x6e, 0x64, 0x34,
-0x00, 0x05, 0xc1, 0x00, 0x00, 0x0d, 0x00, 0xf0, 0x11, 0x6d,
+0x00, 0x05, 0xc1, 0x00, 0xf0, 0x11, 0x74, 0x68, 0x65, 0x6d,
 0x73, 0x65, 0x6c, 0x76, 0x65, 0x73, 0x00, 0x72, 0x65, 0x6d,
 0x6f, 0x76, 0x65, 0x64, 0x2e, 0x00, 0x59, 0x6f, 0x75, 0x72,
-0x00, 0x74, 0x61, 0x73, 0x6b, 0x00, 0x69, 0x73, 0x00, 0x74,
-0x6f, 0x75, 0x00, 0x81, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75,
+0x00, 0x74, 0x61, 0x73, 0x6b, 0x00, 0x69, 0x73, 0x9e, 0x00,
+0xb1, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75,
 0x63, 0x74, 0x3d, 0x00, 0xa3, 0x70, 0x61, 0x74, 0x74, 0x65,
-0x72, 0x6e, 0x00, 0x62, 0x79, 0xac, 0x00, 0x30, 0x69, 0x6e,
-0x67, 0x19, 0x00, 0x0b, 0x1e, 0x01, 0x01, 0x3c, 0x00, 0x52,
+0x72, 0x6e, 0x00, 0x62, 0x79, 0xac, 0x00, 0x31, 0x69, 0x6e,
+0x67, 0x19, 0x00, 0x0c, 0x1e, 0x01, 0x82, 0x74, 0x6f, 0x00,
 0x6d, 0x61, 0x74, 0x63, 0x68, 0x36, 0x00, 0x71, 0x72, 0x6f,
 0x76, 0x69, 0x64, 0x65, 0x64, 0x34, 0x00, 0x17, 0x79, 0x08,
 0x01, 0xf0, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x54, 0x68, 0x69,
@@ -71,59 +71,59 @@ const char help_text[] = {
 0x72, 0x65, 0x61, 0x64, 0x79, 0x00, 0x70, 0x72, 0x65, 0x73,
 0x65, 0x6e, 0x74, 0x2e, 0x00, 0x54, 0x72, 0x79, 0x36, 0x00,
 0x12, 0x6f, 0x52, 0x00, 0x06, 0x51, 0x00, 0x60, 0x77, 0x68,
-0x69, 0x63, 0x68, 0x00, 0x56, 0x00, 0xd6, 0x6c, 0x61, 0x70,
-0x73, 0x00, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67,
-0x56, 0x01, 0x43, 0x77, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x00,
-0x75, 0x00, 0x00, 0x68, 0x00, 0x44, 0x73, 0x00, 0x69, 0x74,
-0x33, 0x00, 0x01, 0xef, 0x00, 0x4e, 0x52, 0x69, 0x67, 0x68,
+0x69, 0x63, 0x68, 0x00, 0x56, 0x00, 0xa0, 0x6c, 0x61, 0x70,
+0x73, 0x00, 0x65, 0x78, 0x69, 0x73, 0x74, 0x2a, 0x00, 0x05,
+0x56, 0x01, 0x43, 0x77, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x01,
+0x59, 0x01, 0x40, 0x6f, 0x6e, 0x65, 0x73, 0x66, 0x00, 0x04,
+0x33, 0x00, 0x00, 0xef, 0x00, 0x4e, 0x52, 0x69, 0x67, 0x68,
 0xd6, 0x00, 0x0f, 0xd2, 0x00, 0x03, 0x40, 0x64, 0x72, 0x61,
-0x77, 0xd1, 0x00, 0x44, 0x6c, 0x69, 0x6e, 0x65, 0x2a, 0x00,
-0x02, 0xce, 0x00, 0x03, 0x8c, 0x00, 0xb2, 0x79, 0x6f, 0x75,
+0x77, 0xd1, 0x00, 0x46, 0x6c, 0x69, 0x6e, 0x65, 0x2a, 0x00,
+0x01, 0xce, 0x00, 0x02, 0x8c, 0x00, 0xb2, 0x79, 0x6f, 0x75,
 0x00, 0x63, 0x61, 0x6e, 0x00, 0x75, 0x73, 0x65, 0x0f, 0x02,
-0x40, 0x6d, 0x69, 0x6e, 0x64, 0x16, 0x00, 0x51, 0x72, 0x73,
-0x65, 0x6c, 0x66, 0x02, 0x03, 0x01, 0x24, 0x00, 0x42, 0x6b,
-0x6e, 0x6f, 0x77, 0x7b, 0x01, 0x00, 0x69, 0x00, 0x05, 0x60,
+0x40, 0x6d, 0x69, 0x6e, 0x64, 0x16, 0x00, 0x52, 0x72, 0x73,
+0x65, 0x6c, 0x66, 0x02, 0x03, 0x00, 0x24, 0x00, 0x43, 0x6b,
+0x6e, 0x6f, 0x77, 0x7b, 0x01, 0x00, 0x69, 0x00, 0x04, 0x60,
 0x00, 0x00, 0x8e, 0x02, 0x32, 0x6e, 0x6f, 0x74, 0x2a, 0x01,
-0x21, 0x65, 0x64, 0x37, 0x02, 0x64, 0x00, 0x73, 0x69, 0x6e,
-0x67, 0x6c, 0x88, 0x02, 0x1c, 0x2e, 0xb0, 0x00, 0x52, 0x61,
-0x67, 0x61, 0x69, 0x6e, 0xe4, 0x00, 0x02, 0xa4, 0x02, 0x01,
-0x9d, 0x00, 0x00, 0xd9, 0x00, 0x13, 0x59, 0x8c, 0x00, 0x72,
-0x61, 0x6c, 0x73, 0x6f, 0x00, 0x75, 0x73, 0x02, 0x01, 0xa1,
+0x21, 0x65, 0x64, 0x37, 0x02, 0x30, 0x00, 0x73, 0x69, 0xc6,
+0x02, 0x03, 0xd5, 0x00, 0x1c, 0x2e, 0xb0, 0x00, 0x55, 0x61,
+0x67, 0x61, 0x69, 0x6e, 0x49, 0x01, 0x00, 0xe5, 0x00, 0x00,
+0x9d, 0x00, 0x00, 0xd9, 0x00, 0x13, 0x59, 0x8c, 0x00, 0x42,
+0x61, 0x6c, 0x73, 0x6f, 0x91, 0x00, 0xd2, 0x68, 0x65, 0x00,
 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79,
-0x74, 0x02, 0x01, 0x1a, 0x01, 0x14, 0x61, 0x16, 0x00, 0x43,
-0x61, 0x72, 0x6f, 0x75, 0xf6, 0x02, 0xa7, 0x67, 0x72, 0x69,
-0x64, 0x2e, 0x00, 0x57, 0x68, 0x65, 0x6e, 0x37, 0x00, 0x00,
-0x9e, 0x01, 0x8f, 0x68, 0x61, 0x6c, 0x66, 0x00, 0x77, 0x61,
+0x74, 0x02, 0x00, 0x1a, 0x01, 0x14, 0x61, 0x16, 0x00, 0x43,
+0x61, 0x72, 0x6f, 0x75, 0xf6, 0x02, 0x74, 0x67, 0x72, 0x69,
+0x64, 0x2e, 0x00, 0x57, 0x39, 0x03, 0x03, 0x21, 0x00, 0xbf,
+0x69, 0x73, 0x00, 0x68, 0x61, 0x6c, 0x66, 0x00, 0x77, 0x61,
 0x79, 0x29, 0x01, 0x0a, 0x11, 0x2c, 0xbd, 0x01, 0x14, 0x73,
 0xed, 0x02, 0x60, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x75,
-0x00, 0x01, 0x92, 0x01, 0x02, 0xc7, 0x01, 0x0e, 0x18, 0x02,
-0x02, 0x11, 0x01, 0x06, 0x44, 0x00, 0x2a, 0x6f, 0x72, 0x47,
+0x00, 0x02, 0x92, 0x01, 0x0b, 0xc7, 0x01, 0x07, 0x18, 0x02,
+0x00, 0x11, 0x01, 0x05, 0x44, 0x00, 0x2a, 0x6f, 0x72, 0x47,
 0x00, 0x20, 0x73, 0x70, 0x37, 0x00, 0x32, 0x62, 0x61, 0x72,
-0x46, 0x00, 0x3e, 0x6c, 0x61, 0x79, 0x8b, 0x01, 0x01, 0x50,
-0x01, 0x03, 0xd9, 0x03, 0x81, 0x73, 0x2e, 0x00, 0x52, 0x65,
-0x70, 0x65, 0x61, 0x14, 0x02, 0xc9, 0x65, 0x69, 0x74, 0x68,
+0x46, 0x00, 0x3e, 0x6c, 0x61, 0x79, 0x8b, 0x01, 0x02, 0x50,
+0x01, 0x02, 0xd9, 0x03, 0x81, 0x73, 0x2e, 0x00, 0x52, 0x65,
+0x70, 0x65, 0x61, 0x14, 0x02, 0xca, 0x65, 0x69, 0x74, 0x68,
 0x65, 0x72, 0x00, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x30, 0x01,
-0x04, 0x86, 0x00, 0x25, 0x6f, 0x72, 0x3a, 0x01, 0x14, 0x50,
-0x76, 0x00, 0x13, 0x61, 0x8d, 0x00, 0x06, 0xbb, 0x00, 0x50,
+0x03, 0x86, 0x00, 0x25, 0x6f, 0x72, 0x3a, 0x01, 0x14, 0x50,
+0x76, 0x00, 0x14, 0x61, 0x32, 0x04, 0x05, 0xbb, 0x00, 0x50,
 0x68, 0x69, 0x67, 0x68, 0x6c, 0x82, 0x01, 0xe0, 0x00, 0x61,
 0x6c, 0x6c, 0x00, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65,
-0x6e, 0x63, 0xc4, 0x02, 0x01, 0xdf, 0x01, 0x04, 0x03, 0x01,
-0x15, 0x2e, 0x45, 0x00, 0x08, 0x16, 0x00, 0x02, 0xae, 0x01,
-0x02, 0x4a, 0x00, 0x50, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x81,
-0x00, 0x05, 0x54, 0x00, 0x00, 0xa8, 0x00, 0x71, 0x2e, 0x00,
-0x55, 0x70, 0x00, 0x74, 0x6f, 0xc6, 0x00, 0x67, 0x64, 0x69,
-0x66, 0x66, 0x65, 0x72, 0x57, 0x01, 0x01, 0xcf, 0x01, 0x17,
+0x6e, 0x63, 0xc4, 0x02, 0x03, 0xdf, 0x01, 0x02, 0x32, 0x00,
+0x16, 0x2e, 0x45, 0x00, 0x07, 0x16, 0x00, 0x03, 0xae, 0x01,
+0x01, 0x4a, 0x00, 0x51, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x81,
+0x00, 0x05, 0x54, 0x00, 0x70, 0x69, 0x6e, 0x67, 0x2e, 0x00,
+0x55, 0x70, 0x99, 0x01, 0x00, 0xc6, 0x00, 0x68, 0x64, 0x69,
+0x66, 0x66, 0x65, 0x72, 0x80, 0x02, 0x00, 0xcf, 0x01, 0x17,
 0x62, 0x31, 0x00, 0x00, 0x23, 0x04, 0x11, 0x74, 0x81, 0x03,
 0x30, 0x67, 0x69, 0x76, 0x00, 0x01, 0x21, 0x69, 0x6d, 0xc1,
-0x00, 0x40, 0x28, 0x41, 0x6c, 0x6c, 0x5b, 0x00, 0x03, 0xef,
+0x00, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x5b, 0x00, 0x02, 0xef,
 0x00, 0xb0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
 0x62, 0x65, 0x64, 0xfc, 0x04, 0x22, 0x73, 0x65, 0x05, 0x01,
-0x30, 0x32, 0x2e, 0x31, 0x72, 0x02, 0x02, 0x21, 0x02, 0xb2,
+0x31, 0x32, 0x2e, 0x31, 0x72, 0x02, 0x01, 0x21, 0x02, 0xb2,
 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
 0x29, 0x04, 0x04, 0x16, 0x32, 0x04, 0x04, 0xb1, 0x70, 0x61,
 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x81,
-0x04, 0x43, 0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x03, 0xb6,
-0x02, 0x05, 0x3f, 0x00, 0x05, 0x56, 0x04, 0xf1, 0x01, 0x65,
+0x04, 0x46, 0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02, 0x44,
+0x00, 0x04, 0x3f, 0x00, 0x04, 0x56, 0x04, 0xf1, 0x01, 0x65,
 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x72, 0x00, 0x22, 0x6f, 0x6e,
 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
@@ -131,15 +131,15 @@ const char help_text[] = {
 0x6d, 0x75, 0x6d, 0x20, 0xe6, 0x00, 0x45, 0x20, 0x6f, 0x6e,
 0x20, 0xc1, 0x03, 0x33, 0x00, 0x00, 0x43, 0x80, 0x04, 0x02,
 0x02, 0x02, 0x32, 0x69, 0x7a, 0x65, 0x69, 0x01, 0x13, 0x65,
-0x03, 0x05, 0x10, 0x2c, 0x24, 0x03, 0x03, 0xa4, 0x04, 0x4a,
-0x6c, 0x69, 0x6e, 0x67, 0x27, 0x00, 0x0e, 0x69, 0x05, 0x00,
-0x09, 0x03, 0x12, 0x64, 0x6e, 0x05, 0x86, 0x6b, 0x65, 0x00,
+0x03, 0x05, 0x10, 0x2c, 0x24, 0x03, 0x03, 0xa4, 0x04, 0x15,
+0x6c, 0x29, 0x02, 0x07, 0x27, 0x00, 0x0c, 0x69, 0x05, 0x42,
+0x75, 0x73, 0x65, 0x64, 0x6e, 0x05, 0x86, 0x6b, 0x65, 0x00,
 0x69, 0x74, 0x2e, 0x00, 0x44, 0x2d, 0x04, 0x25, 0x74, 0x68,
 0x6a, 0x01, 0x20, 0x67, 0x6f, 0x4d, 0x00, 0x11, 0x75, 0x8c,
-0x01, 0x11, 0x4e, 0xb1, 0x01, 0x01, 0x63, 0x01, 0x32, 0x00,
+0x01, 0x12, 0x4e, 0xb1, 0x01, 0x00, 0x63, 0x01, 0x32, 0x00,
 0x72, 0x69, 0xda, 0x03, 0xa0, 0x61, 0x6e, 0x00, 0x28, 0x4e,
 0x2b, 0x32, 0x29, 0x00, 0x78, 0x08, 0x00, 0x28, 0x31, 0x29,
-0x6f, 0x06, 0x61, 0x73, 0x6f, 0x2c, 0x00, 0x69, 0x6e, 0x70,
+0x6f, 0x06, 0x30, 0x73, 0x6f, 0x2c, 0x67, 0x01, 0x00, 0x70,
 0x05, 0x20, 0x69, 0x63, 0x95, 0x06, 0x12, 0x2c, 0x68, 0x02,
 0xb1, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x76, 0x61,
 0x6c, 0x75, 0x9f, 0x00, 0x11, 0x36, 0x53, 0x00, 0x10, 0x73,
@@ -147,29 +147,29 @@ const char help_text[] = {
 0x00, 0x00, 0x45, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x75,
 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x73, 0x6f, 0x6c, 0x75,
 0x3c, 0x01, 0x31, 0x00, 0x00, 0x4e, 0x59, 0x07, 0x44, 0x6c,
-0x79, 0x2c, 0x00, 0x9a, 0x01, 0x01, 0x99, 0x00, 0x02, 0xcb,
-0x00, 0x00, 0x34, 0x00, 0x01, 0x6b, 0x02, 0x06, 0x1d, 0x01,
-0x01, 0xec, 0x04, 0x04, 0x47, 0x05, 0x00, 0xba, 0x03, 0x10,
+0x79, 0x2c, 0x00, 0x9a, 0x01, 0x02, 0x99, 0x00, 0x01, 0xcb,
+0x00, 0x00, 0x34, 0x00, 0x02, 0x6b, 0x02, 0x06, 0x1d, 0x01,
+0x01, 0xec, 0x04, 0x03, 0x47, 0x05, 0x00, 0xba, 0x03, 0x10,
 0x76, 0x02, 0x05, 0x21, 0x6c, 0x79, 0x6f, 0x05, 0x04, 0x58,
-0x00, 0x30, 0x2e, 0x00, 0x50, 0x2c, 0x00, 0x04, 0x00, 0x01,
+0x00, 0x33, 0x2e, 0x00, 0x50, 0x2c, 0x00, 0x01, 0x00, 0x01,
 0x94, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75, 0x6f, 0x75, 0x73,
 0x26, 0x02, 0x05, 0x75, 0x02, 0x41, 0x6d, 0x6f, 0x72, 0x65,
 0x93, 0x02, 0x00, 0xd4, 0x00, 0x11, 0x74, 0x58, 0x06, 0x40,
 0x73, 0x6f, 0x6d, 0x65, 0x73, 0x02, 0x12, 0x73, 0x1d, 0x00,
-0x40, 0x73, 0x75, 0x62, 0x74, 0x92, 0x01, 0x51, 0x73, 0x6f,
-0x00, 0x69, 0x66, 0xe7, 0x04, 0x45, 0x6c, 0x69, 0x6b, 0x65,
-0x14, 0x05, 0x01, 0x04, 0x04, 0x50, 0x6f, 0x66, 0x66, 0x00,
-0x74, 0xc2, 0x06, 0xb0, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
+0x40, 0x73, 0x75, 0x62, 0x74, 0x92, 0x01, 0x20, 0x73, 0x6f,
+0xcd, 0x05, 0x00, 0xe7, 0x04, 0x45, 0x6c, 0x69, 0x6b, 0x65,
+0x14, 0x05, 0x01, 0x04, 0x04, 0x20, 0x6f, 0x66, 0x97, 0x01,
+0xe0, 0x69, 0x73, 0x00, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
 0x65, 0x2e, 0x00, 0x41, 0x6c, 0x30, 0x01, 0x41, 0x66, 0x69,
-0x6e, 0x64, 0x72, 0x03, 0x03, 0xb9, 0x02, 0x72, 0x70, 0x6f,
-0x73, 0x73, 0x69, 0x62, 0x6c, 0xa8, 0x00, 0x09, 0x88, 0x00,
+0x6e, 0x64, 0x72, 0x03, 0x03, 0xb9, 0x02, 0x76, 0x70, 0x6f,
+0x73, 0x73, 0x69, 0x62, 0x6c, 0xa8, 0x00, 0x05, 0x88, 0x00,
 0x00, 0xd2, 0x04, 0x30, 0x64, 0x64, 0x69, 0x14, 0x00, 0xf2,
 0x01, 0x61, 0x6c, 0x00, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65,
 0x6e, 0x67, 0x65, 0x00, 0x66, 0x6f, 0x72, 0x1c, 0x00, 0x10,
 0x76, 0x57, 0x08, 0x10, 0x64, 0x65, 0x04, 0x10, 0x79, 0x88,
-0x03, 0x75, 0x54, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x7a,
-0x00, 0x03, 0x8c, 0x02, 0x06, 0x1b, 0x05, 0x84, 0x73, 0x70,
-0x65, 0x65, 0x64, 0x00, 0x75, 0x70, 0x55, 0x07, 0xc0, 0x67,
+0x03, 0x40, 0x54, 0x75, 0x72, 0x6e, 0x5a, 0x00, 0x05, 0x7a,
+0x00, 0x03, 0x8c, 0x02, 0x05, 0x1b, 0x05, 0x50, 0x73, 0x70,
+0x65, 0x65, 0x64, 0xeb, 0x01, 0x03, 0x55, 0x07, 0xc0, 0x67,
 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
 0x00,
 };
diff --git a/apps/plugins/puzzles/help/fifteen.c b/apps/plugins/puzzles/help/fifteen.c
index 72856d1061..eb3f84ab26 100644
--- a/apps/plugins/puzzles/help/fifteen.c
+++ b/apps/plugins/puzzles/help/fifteen.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1245 comp 924 ratio 0.742169 level 11 saved 321 */
+/* orig 1245 comp 925 ratio 0.742972 level 5 saved 320 */
 const char help_text[] = {
 0xf1, 0x29, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x35, 0x3a, 0x20, 0x46, 0x69, 0x66, 0x74, 0x65, 0x65, 0x6e,
@@ -36,80 +36,80 @@ const char help_text[] = {
 0x70, 0x00, 0x30, 0x73, 0x69, 0x78, 0xa2, 0x00, 0x20, 0x74,
 0x68, 0x81, 0x00, 0x51, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x5b,
 0x00, 0x61, 0x72, 0x00, 0x6d, 0x6f, 0x76, 0x65, 0x95, 0x00,
-0xa1, 0x6f, 0x00, 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x00,
-0x61, 0x3c, 0x00, 0x80, 0x00, 0x6e, 0x65, 0x78, 0x74, 0x00,
-0x74, 0x6f, 0x3e, 0x00, 0x02, 0x31, 0x00, 0x61, 0x00, 0x73,
-0x70, 0x61, 0x63, 0x65, 0x53, 0x00, 0x01, 0xa5, 0x00, 0x72,
-0x65, 0x00, 0x69, 0x74, 0x00, 0x69, 0x6e, 0x23, 0x00, 0x02,
+0x70, 0x6f, 0x00, 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x69, 0x00,
+0x00, 0x3c, 0x00, 0x50, 0x00, 0x6e, 0x65, 0x78, 0x74, 0x16,
+0x00, 0x00, 0x3e, 0x00, 0x01, 0x31, 0x00, 0x62, 0x00, 0x73,
+0x70, 0x61, 0x63, 0x65, 0x53, 0x00, 0x00, 0xa5, 0x00, 0x73,
+0x65, 0x00, 0x69, 0x74, 0x00, 0x69, 0x6e, 0x23, 0x00, 0x01,
 0x1d, 0x00, 0x11, 0x2e, 0xff, 0x00, 0x33, 0x61, 0x69, 0x6d,
-0x52, 0x00, 0x61, 0x65, 0x6e, 0x64, 0x00, 0x75, 0x70, 0xd8,
-0x00, 0x00, 0x25, 0x00, 0x02, 0x95, 0x00, 0x12, 0x00, 0xa7,
-0x00, 0xd1, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x6f,
-0x72, 0x64, 0x65, 0x72, 0x2c, 0x23, 0x00, 0x06, 0x48, 0x00,
-0x32, 0x00, 0x69, 0x6e, 0x38, 0x01, 0xe0, 0x6f, 0x74, 0x74,
+0x52, 0x00, 0x62, 0x65, 0x6e, 0x64, 0x00, 0x75, 0x70, 0xd8,
+0x00, 0x00, 0x25, 0x00, 0x01, 0x95, 0x00, 0x12, 0x00, 0xa7,
+0x00, 0xd6, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x6f,
+0x72, 0x64, 0x65, 0x72, 0x2c, 0x23, 0x00, 0x01, 0x48, 0x00,
+0x00, 0x23, 0x00, 0x01, 0x38, 0x01, 0xe0, 0x6f, 0x74, 0x74,
 0x6f, 0x6d, 0x00, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x28,
-0x73, 0x6a, 0x00, 0x22, 0x61, 0x74, 0x4a, 0x00, 0xf0, 0x05,
+0x73, 0x6a, 0x00, 0x22, 0x61, 0x74, 0x4a, 0x00, 0xf5, 0x05,
 0x6f, 0x70, 0x00, 0x72, 0x6f, 0x77, 0x00, 0x72, 0x65, 0x61,
 0x64, 0x73, 0x00, 0x31, 0x2c, 0x32, 0x2c, 0x33, 0x2c, 0x34,
-0x9b, 0x00, 0x07, 0x38, 0x00, 0x08, 0x21, 0x00, 0x81, 0x33,
+0xee, 0x00, 0x04, 0x38, 0x00, 0x06, 0x21, 0x00, 0x81, 0x33,
 0x2c, 0x31, 0x34, 0x2c, 0x31, 0x35, 0x2c, 0x5f, 0x00, 0x85,
 0x29, 0x2e, 0x00, 0x00, 0x00, 0x35, 0x2e, 0x31, 0xb8, 0x01,
-0x00, 0x3e, 0x01, 0x41, 0x72, 0x6f, 0x6c, 0x73, 0xc1, 0x01,
-0x00, 0xa6, 0x01, 0xc3, 0x67, 0x61, 0x6d, 0x65, 0x00, 0x63,
-0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x1d, 0x00, 0x36, 0x6c,
-0x65, 0x64, 0xa6, 0x00, 0x81, 0x6d, 0x6f, 0x75, 0x73, 0x65,
-0x00, 0x6f, 0x72, 0x0d, 0x00, 0x80, 0x6b, 0x65, 0x79, 0x62,
-0x6f, 0x61, 0x72, 0x64, 0x56, 0x00, 0xca, 0x41, 0x00, 0x6c,
-0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x2f,
-0x00, 0x04, 0xd5, 0x00, 0x00, 0x96, 0x00, 0x00, 0x3a, 0x00,
-0x64, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0xb9, 0x01, 0x3c,
-0x69, 0x6e, 0x67, 0x6a, 0x01, 0x52, 0x00, 0x77, 0x69, 0x6c,
-0x6c, 0xa0, 0x01, 0x72, 0x61, 0x73, 0x00, 0x6d, 0x61, 0x6e,
-0x79, 0x40, 0x01, 0x00, 0x0e, 0x00, 0xc1, 0x6e, 0x65, 0x63,
-0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x00, 0x74, 0x6f, 0x23,
-0x00, 0x07, 0x3c, 0x01, 0x27, 0x74, 0x6f, 0x74, 0x00, 0x83,
-0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x9a, 0x02,
-0x50, 0x61, 0x72, 0x72, 0x6f, 0x77, 0xb1, 0x00, 0x15, 0x73,
-0x5e, 0x00, 0x05, 0xf1, 0x01, 0x70, 0x61, 0x64, 0x6a, 0x61,
-0x63, 0x65, 0x6e, 0xf5, 0x01, 0x0e, 0x8a, 0x01, 0xfe, 0x0c,
-0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00,
-0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x00,
-0x28, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x2d, 0x00, 0x77,
-0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x36, 0x00, 0x01,
-0x72, 0x01, 0x50, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31, 0x00,
-0x33, 0x60, 0x68, 0x27, 0x7f, 0x00, 0x20, 0x61, 0x6b, 0x7f,
-0x00, 0x91, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65,
-0x64, 0x90, 0x00, 0x1a, 0x2e, 0x29, 0x00, 0xb3, 0x65, 0x6e,
-0x6f, 0x75, 0x67, 0x68, 0x00, 0x74, 0x69, 0x6d, 0x65, 0xb5,
-0x00, 0x32, 0x73, 0x6f, 0x6c, 0xf1, 0x00, 0x01, 0xa7, 0x01,
-0x50, 0x2c, 0x00, 0x62, 0x75, 0x74, 0x8b, 0x02, 0xe0, 0x6d,
-0x61, 0x79, 0x00, 0x73, 0x63, 0x72, 0x61, 0x6d, 0x62, 0x6c,
-0x65, 0x00, 0x79, 0xdc, 0x02, 0x40, 0x70, 0x72, 0x6f, 0x67,
-0x4b, 0x00, 0x30, 0x00, 0x77, 0x68, 0xe1, 0x00, 0x20, 0x64,
-0x6f, 0x54, 0x00, 0x20, 0x73, 0x6f, 0x8c, 0x00, 0x41, 0x28,
-0x41, 0x6c, 0x6c, 0x43, 0x00, 0x11, 0x61, 0xa0, 0x00, 0xb0,
-0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65,
-0x64, 0xc5, 0x00, 0x13, 0x73, 0xec, 0x00, 0x31, 0x32, 0x2e,
-0x31, 0xc4, 0x03, 0xf1, 0x01, 0x61, 0x6c, 0x73, 0x6f, 0x00,
-0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
-0x29, 0x3f, 0x02, 0x15, 0x32, 0x3f, 0x02, 0xa5, 0x70, 0x61,
-0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x02, 0x04,
-0x61, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x70, 0x5b, 0x00, 0x06,
-0x39, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x76, 0x00,
-0xb3, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
-0x2e, 0x27, 0x27, 0x00, 0x32, 0x00, 0x6f, 0x6e, 0x1a, 0x00,
-0xa1, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e,
-0x75, 0x7b, 0x00, 0x51, 0x57, 0x69, 0x64, 0x74, 0x68, 0xd9,
-0x02, 0x20, 0x48, 0x65, 0x07, 0x03, 0x10, 0x2c, 0xcd, 0x00,
-0x21, 0x63, 0x68, 0x1c, 0x00, 0xf1, 0x07, 0x73, 0x65, 0x6c,
-0x66, 0x2d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74,
-0x6f, 0x72, 0x79, 0x2e, 0x00, 0x28, 0x4f, 0x6e, 0x63, 0xfd,
-0x00, 0xa1, 0x27, 0x76, 0x65, 0x00, 0x63, 0x68, 0x61, 0x6e,
-0x67, 0x65, 0x12, 0x03, 0xe9, 0x73, 0x65, 0x2c, 0x00, 0x69,
-0x74, 0x27, 0x73, 0x00, 0x6e, 0x6f, 0x74, 0x00, 0x61, 0x75,
-0x04, 0x00, 0x58, 0x02, 0xf0, 0x03, 0x6d, 0x6f, 0x72, 0x65,
-0x2c, 0x00, 0x6f, 0x66, 0x00, 0x63, 0x6f, 0x75, 0x72, 0x73,
-0x65, 0x21, 0x29, 0x00,
+0x00, 0x3e, 0x01, 0x42, 0x72, 0x6f, 0x6c, 0x73, 0xc1, 0x01,
+0xf3, 0x00, 0x69, 0x73, 0x00, 0x67, 0x61, 0x6d, 0x65, 0x00,
+0x63, 0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x1d, 0x00, 0x36,
+0x6c, 0x65, 0x64, 0xa6, 0x00, 0x81, 0x6d, 0x6f, 0x75, 0x73,
+0x65, 0x00, 0x6f, 0x72, 0x0d, 0x00, 0x80, 0x6b, 0x65, 0x79,
+0x62, 0x6f, 0x61, 0x72, 0x64, 0x56, 0x00, 0xcc, 0x41, 0x00,
+0x6c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b,
+0x2f, 0x00, 0x03, 0xd5, 0x00, 0x00, 0x96, 0x00, 0x94, 0x6f,
+0x72, 0x00, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0xb9, 0x01,
+0x01, 0xf2, 0x01, 0x0a, 0x6a, 0x01, 0x52, 0x00, 0x77, 0x69,
+0x6c, 0x6c, 0xa0, 0x01, 0x73, 0x61, 0x73, 0x00, 0x6d, 0x61,
+0x6e, 0x79, 0x40, 0x01, 0xc0, 0x61, 0x73, 0x00, 0x6e, 0x65,
+0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x66, 0x01, 0x01,
+0x23, 0x00, 0x06, 0x3c, 0x01, 0x27, 0x74, 0x6f, 0x74, 0x00,
+0x83, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x9a,
+0x02, 0x20, 0x61, 0x72, 0x7e, 0x00, 0x48, 0x6b, 0x65, 0x79,
+0x73, 0x5e, 0x00, 0x02, 0xf1, 0x01, 0x75, 0x61, 0x64, 0x6a,
+0x61, 0x63, 0x65, 0x6e, 0xf5, 0x01, 0x09, 0x8a, 0x01, 0xf4,
+0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+0x00, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64,
+0x00, 0x28, 0x6d, 0x6f, 0x76, 0xb8, 0x00, 0x09, 0x2d, 0x00,
+0x77, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x36, 0x00,
+0x01, 0x72, 0x01, 0x50, 0x50, 0x72, 0x65, 0x73, 0x73, 0x31,
+0x00, 0x33, 0x60, 0x68, 0x27, 0x7f, 0x00, 0x20, 0x61, 0x6b,
+0x7f, 0x00, 0x60, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x53,
+0x00, 0x00, 0x90, 0x00, 0x1a, 0x2e, 0x29, 0x00, 0xb3, 0x65,
+0x6e, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x74, 0x69, 0x6d, 0x65,
+0xb5, 0x00, 0x33, 0x73, 0x6f, 0x6c, 0xf1, 0x00, 0x00, 0xa7,
+0x01, 0x50, 0x2c, 0x00, 0x62, 0x75, 0x74, 0x8b, 0x02, 0xe0,
+0x6d, 0x61, 0x79, 0x00, 0x73, 0x63, 0x72, 0x61, 0x6d, 0x62,
+0x6c, 0x65, 0x00, 0x79, 0xdc, 0x02, 0x40, 0x70, 0x72, 0x6f,
+0x67, 0x4b, 0x00, 0x30, 0x00, 0x77, 0x68, 0xe1, 0x00, 0x20,
+0x64, 0x6f, 0x54, 0x00, 0x20, 0x73, 0x6f, 0x8c, 0x00, 0x41,
+0x28, 0x41, 0x6c, 0x6c, 0x43, 0x00, 0x11, 0x61, 0xa0, 0x00,
+0xb0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62,
+0x65, 0x64, 0xc5, 0x00, 0x13, 0x73, 0xec, 0x00, 0x31, 0x32,
+0x2e, 0x31, 0xc4, 0x03, 0xf1, 0x01, 0x61, 0x6c, 0x73, 0x6f,
+0x00, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65,
+0x2e, 0x29, 0x3f, 0x02, 0x15, 0x32, 0x3f, 0x02, 0xa5, 0x70,
+0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x02,
+0x04, 0x62, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x70, 0x5b, 0x00,
+0x05, 0x39, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x76,
+0x00, 0xb3, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e,
+0x2e, 0x2e, 0x27, 0x27, 0x00, 0x22, 0x00, 0x6f, 0x3c, 0x01,
+0xb1, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65,
+0x6e, 0x75, 0x7b, 0x00, 0x51, 0x57, 0x69, 0x64, 0x74, 0x68,
+0xd9, 0x02, 0x20, 0x48, 0x65, 0x07, 0x03, 0x10, 0x2c, 0xcd,
+0x00, 0x21, 0x63, 0x68, 0x1c, 0x00, 0xf1, 0x07, 0x73, 0x65,
+0x6c, 0x66, 0x2d, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61,
+0x74, 0x6f, 0x72, 0x79, 0x2e, 0x00, 0x28, 0x4f, 0x6e, 0x63,
+0xfd, 0x00, 0xa1, 0x27, 0x76, 0x65, 0x00, 0x63, 0x68, 0x61,
+0x6e, 0x67, 0x65, 0x12, 0x03, 0xe9, 0x73, 0x65, 0x2c, 0x00,
+0x69, 0x74, 0x27, 0x73, 0x00, 0x6e, 0x6f, 0x74, 0x00, 0x61,
+0x75, 0x04, 0x00, 0x58, 0x02, 0xf0, 0x03, 0x6d, 0x6f, 0x72,
+0x65, 0x2c, 0x00, 0x6f, 0x66, 0x00, 0x63, 0x6f, 0x75, 0x72,
+0x73, 0x65, 0x21, 0x29, 0x00,
 };
 
 const unsigned short help_text_len = 1245;
diff --git a/apps/plugins/puzzles/help/filling.c b/apps/plugins/puzzles/help/filling.c
index bf40041cff..15ba8cbe43 100644
--- a/apps/plugins/puzzles/help/filling.c
+++ b/apps/plugins/puzzles/help/filling.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -11,7 +11,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1804 comp 1242 ratio 0.68847 level 11 saved 562 */
+/* orig 1804 comp 1242 ratio 0.68847 level 10 saved 562 */
 const char help_text[] = {
 0xf0, 0x28, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x39, 0x3a, 0x20, 0x46, 0x69, 0x6c, 0x6c, 0x69, 0x6e,
@@ -26,37 +26,37 @@ const char help_text[] = {
 0x65, 0x00, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x5b, 0x00,
 0xf5, 0x02, 0x72, 0x00, 0x6a, 0x6f, 0x62, 0x00, 0x69, 0x73,
 0x00, 0x74, 0x6f, 0x00, 0x66, 0x69, 0x6c, 0x6c, 0x00, 0x40,
-0x00, 0x00, 0x0a, 0x00, 0x23, 0x74, 0x68, 0x2c, 0x00, 0x05,
-0x73, 0x00, 0x00, 0x16, 0x00, 0x20, 0x73, 0x75, 0x47, 0x00,
+0x00, 0x00, 0x0a, 0x00, 0x23, 0x74, 0x68, 0x2c, 0x00, 0x06,
+0x73, 0x00, 0x50, 0x69, 0x6e, 0x00, 0x73, 0x75, 0x47, 0x00,
 0xc2, 0x00, 0x77, 0x61, 0x79, 0x00, 0x74, 0x68, 0x61, 0x74,
 0x00, 0x65, 0x61, 0x7d, 0x00, 0xd7, 0x6e, 0x65, 0x63, 0x74,
 0x65, 0x64, 0x00, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0xa8,
 0x00, 0x44, 0x00, 0x61, 0x6c, 0x6c, 0x9d, 0x00, 0x31, 0x69,
 0x6e, 0x67, 0x56, 0x00, 0x42, 0x73, 0x61, 0x6d, 0x65, 0x69,
 0x00, 0x70, 0x00, 0x68, 0x61, 0x73, 0x00, 0x61, 0x6e, 0x98,
-0x00, 0xa1, 0x61, 0x00, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x00,
-0x74, 0x6f, 0x59, 0x00, 0x02, 0x20, 0x00, 0x7b, 0x2e, 0x00,
+0x00, 0x70, 0x61, 0x00, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x8c,
+0x00, 0x01, 0x59, 0x00, 0x01, 0x20, 0x00, 0x7b, 0x2e, 0x00,
 0x00, 0x00, 0x28, 0x60, 0x43, 0x5f, 0x00, 0x61, 0x27, 0x2c,
 0x00, 0x66, 0x6f, 0x72, 0x4b, 0x00, 0x80, 0x70, 0x75, 0x72,
 0x70, 0x6f, 0x73, 0x65, 0x73, 0x72, 0x00, 0xf0, 0x09, 0x74,
 0x68, 0x69, 0x73, 0x00, 0x67, 0x61, 0x6d, 0x65, 0x2c, 0x00,
 0x64, 0x6f, 0x65, 0x73, 0x00, 0x6e, 0x6f, 0x74, 0x00, 0x63,
-0x6f, 0x75, 0x6e, 0x4c, 0x00, 0xf5, 0x03, 0x61, 0x67, 0x6f,
+0x6f, 0x75, 0x6e, 0x4c, 0x00, 0xf0, 0x00, 0x61, 0x67, 0x6f,
 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x70, 0x61,
-0x72, 0x61, 0x74, 0x65, 0x64, 0xa1, 0x00, 0x00, 0x82, 0x00,
-0xf2, 0x14, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x2e,
+0x72, 0x61, 0x4c, 0x00, 0x05, 0xa1, 0x00, 0xf2, 0x17, 0x73,
+0x00, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x2e,
 0x29, 0x00, 0x00, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x65, 0x78,
 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x00, 0x69, 0x74, 0x00,
 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x96, 0x00, 0x23,
 0x6e, 0x6f, 0x38, 0x00, 0x45, 0x00, 0x63, 0x61, 0x6e, 0x75,
-0x01, 0x61, 0x61, 0x00, 0x7a, 0x65, 0x72, 0x6f, 0x75, 0x01,
-0x02, 0x27, 0x00, 0x35, 0x74, 0x77, 0x6f, 0x55, 0x00, 0x04,
-0x69, 0x00, 0x00, 0x32, 0x00, 0x01, 0x94, 0x00, 0x47, 0x62,
-0x6f, 0x74, 0x68, 0x3b, 0x00, 0x73, 0x6f, 0x6e, 0x65, 0x2e,
-0x00, 0x4e, 0x6f, 0xdc, 0x00, 0x09, 0x12, 0x01, 0x70, 0x67,
+0x01, 0x64, 0x61, 0x00, 0x7a, 0x65, 0x72, 0x6f, 0x75, 0x01,
+0x65, 0x61, 0x74, 0x00, 0x74, 0x77, 0x6f, 0x55, 0x00, 0x05,
+0x69, 0x00, 0x00, 0x32, 0x00, 0x00, 0x94, 0x00, 0x47, 0x62,
+0x6f, 0x74, 0x68, 0x3b, 0x00, 0x74, 0x6f, 0x6e, 0x65, 0x2e,
+0x00, 0x4e, 0x6f, 0x3b, 0x01, 0x08, 0x12, 0x01, 0x70, 0x67,
 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x54, 0x00, 0xc0, 0x6e,
 0x00, 0x39, 0x00, 0x28, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73,
-0x65, 0xfa, 0x00, 0x52, 0x6e, 0x00, 0x69, 0x74, 0x73, 0x26,
+0x65, 0xfa, 0x00, 0x20, 0x6e, 0x00, 0xa7, 0x01, 0x01, 0x26,
 0x00, 0x52, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x5a, 0x00, 0x00,
 0x29, 0x02, 0x53, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x60, 0x01,
 0x10, 0x29, 0x41, 0x01, 0x41, 0x43, 0x72, 0x65, 0x64, 0xc8,
@@ -64,11 +64,11 @@ const char help_text[] = {
 0x6c, 0x65, 0x00, 0x67, 0x6f, 0x65, 0xfa, 0x01, 0xb0, 0x4e,
 0x69, 0x6b, 0x6f, 0x6c, 0x69, 0x00, 0x5b, 0x31, 0x34, 0x5d,
 0x2e, 0x00, 0x03, 0x7e, 0x02, 0x41, 0x00, 0x77, 0x61, 0x73,
-0xa5, 0x00, 0x72, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64,
+0xa5, 0x00, 0x40, 0x72, 0x69, 0x62, 0x75, 0x2f, 0x01, 0x01,
 0x98, 0x01, 0x10, 0x69, 0x14, 0x00, 0x50, 0x6c, 0x6c, 0x65,
-0x63, 0x74, 0xab, 0x00, 0xf1, 0x04, 0x62, 0x79, 0x00, 0x4a,
+0x63, 0x74, 0xab, 0x00, 0xf0, 0x01, 0x62, 0x79, 0x00, 0x4a,
 0x6f, 0x6e, 0x61, 0x73, 0x00, 0x4b, 0x6f, 0x65, 0x6c, 0x6b,
-0x65, 0x72, 0x2e, 0x00, 0x00, 0x47, 0x00, 0xd1, 0x00, 0x68,
+0x65, 0x72, 0x3f, 0x00, 0x00, 0x47, 0x00, 0xd1, 0x00, 0x68,
 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
 0x6e, 0x5e, 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70,
 0x2f, 0x65, 0x6e, 0x2f, 0x7d, 0x00, 0x20, 0x73, 0x2f, 0x70,
@@ -79,20 +79,20 @@ const char help_text[] = {
 0x00, 0xe1, 0x2c, 0x00, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x79,
 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x05, 0x02, 0x20, 0x6d,
 0x6f, 0x15, 0x01, 0x00, 0x4d, 0x01, 0x29, 0x6e, 0x79, 0xb3,
-0x02, 0x04, 0x06, 0x03, 0x83, 0x6e, 0x00, 0x74, 0x79, 0x70,
-0x65, 0x00, 0x61, 0x75, 0x02, 0x12, 0x6f, 0xdd, 0x02, 0x84,
+0x02, 0x04, 0x06, 0x03, 0x50, 0x6e, 0x00, 0x74, 0x79, 0x70,
+0x1c, 0x01, 0x02, 0x75, 0x02, 0x12, 0x6f, 0xdd, 0x02, 0x85,
 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64, 0xff, 0x02,
-0x00, 0x67, 0x01, 0x04, 0xae, 0x01, 0xd6, 0x2e, 0x00, 0x42,
-0x79, 0x00, 0x64, 0x72, 0x61, 0x67, 0x67, 0x69, 0x6e, 0x67,
+0x01, 0xbb, 0x01, 0x02, 0x3a, 0x00, 0xa4, 0x2e, 0x00, 0x42,
+0x79, 0x00, 0x64, 0x72, 0x61, 0x67, 0x67, 0xb5, 0x02, 0x01,
 0x65, 0x00, 0x51, 0x2c, 0x00, 0x79, 0x6f, 0x75, 0xc9, 0x01,
-0x20, 0x73, 0x65, 0x06, 0x01, 0x93, 0x00, 0x6d, 0x75, 0x6c,
-0x74, 0x69, 0x70, 0x6c, 0x65, 0x37, 0x00, 0x06, 0x4b, 0x03,
-0x44, 0x77, 0x69, 0x74, 0x68, 0x8d, 0x01, 0x01, 0x6b, 0x00,
-0x91, 0x70, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x00, 0x49, 0x66,
-0x43, 0x00, 0x30, 0x6d, 0x61, 0x6b, 0x90, 0x00, 0x8c, 0x6d,
-0x69, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x2c, 0xcd, 0x00, 0x04,
-0x80, 0x03, 0x98, 0x69, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65,
-0x63, 0x74, 0xd1, 0x00, 0x01, 0x4a, 0x00, 0xf0, 0x01, 0x00,
+0x20, 0x73, 0x65, 0x06, 0x01, 0x95, 0x00, 0x6d, 0x75, 0x6c,
+0x74, 0x69, 0x70, 0x6c, 0x65, 0xe5, 0x01, 0x04, 0x4c, 0x00,
+0x46, 0x77, 0x69, 0x74, 0x68, 0x8d, 0x01, 0xc1, 0x6b, 0x65,
+0x79, 0x70, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x00, 0x49, 0x66,
+0x43, 0x00, 0x30, 0x6d, 0x61, 0x6b, 0x90, 0x00, 0x8e, 0x6d,
+0x69, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x2c, 0xcd, 0x00, 0x02,
+0xa3, 0x00, 0x60, 0x69, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x69,
+0x00, 0x07, 0xd1, 0x00, 0x01, 0x4a, 0x00, 0xf0, 0x01, 0x00,
 0x30, 0x2c, 0x00, 0x53, 0x70, 0x61, 0x63, 0x65, 0x2c, 0x00,
 0x42, 0x61, 0x63, 0x6b, 0x73, 0x0b, 0x00, 0x61, 0x00, 0x6f,
 0x72, 0x00, 0x45, 0x6e, 0x31, 0x02, 0x70, 0x6f, 0x00, 0x63,
@@ -100,41 +100,41 @@ const char help_text[] = {
 0x02, 0x43, 0x28, 0x6f, 0x72, 0x00, 0x3b, 0x02, 0xd1, 0x00,
 0x55, 0x6e, 0x64, 0x6f, 0x00, 0x66, 0x65, 0x61, 0x74, 0x75,
 0x72, 0x65, 0x22, 0x02, 0x13, 0x59, 0xd5, 0x00, 0x70, 0x61,
-0x6c, 0x73, 0x6f, 0x00, 0x6d, 0x6f, 0x70, 0x04, 0x32, 0x72,
-0x6f, 0x75, 0x3c, 0x01, 0x01, 0x79, 0x04, 0x01, 0xcf, 0x00,
-0x01, 0x0e, 0x00, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
-0xd1, 0x00, 0x20, 0x73, 0x3b, 0x56, 0x01, 0x35, 0x69, 0x6e,
-0x67, 0x58, 0x01, 0x44, 0x77, 0x69, 0x6c, 0x6c, 0x4a, 0x01,
-0x04, 0x12, 0x01, 0x07, 0xfc, 0x03, 0x07, 0x40, 0x00, 0x01,
-0x50, 0x00, 0x03, 0x52, 0x03, 0x55, 0x75, 0x6d, 0x62, 0x65,
-0x72, 0x4c, 0x00, 0x11, 0x30, 0x46, 0x00, 0x05, 0xbe, 0x00,
-0x19, 0x2e, 0x9c, 0x00, 0x0f, 0x76, 0x01, 0x05, 0x00, 0xdc,
-0x02, 0x03, 0x49, 0x00, 0x00, 0x44, 0x00, 0x21, 0x6f, 0x72,
-0x40, 0x00, 0x00, 0x0c, 0x00, 0x06, 0xb9, 0x00, 0x61, 0x72,
+0x6c, 0x73, 0x6f, 0x00, 0x6d, 0x6f, 0x70, 0x04, 0x33, 0x72,
+0x6f, 0x75, 0x42, 0x04, 0x01, 0x79, 0x04, 0x01, 0xcf, 0x00,
+0x00, 0x0e, 0x00, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
+0xd1, 0x00, 0x20, 0x73, 0x3b, 0x56, 0x01, 0x00, 0x1f, 0x01,
+0x04, 0x58, 0x01, 0x10, 0x77, 0xf9, 0x00, 0x03, 0x4a, 0x01,
+0x04, 0x12, 0x01, 0x0c, 0xfc, 0x03, 0x03, 0x40, 0x00, 0x03,
+0x50, 0x00, 0x00, 0x52, 0x03, 0x55, 0x75, 0x6d, 0x62, 0x65,
+0x72, 0x4c, 0x00, 0x12, 0x30, 0x46, 0x00, 0x04, 0xbe, 0x00,
+0x1a, 0x2e, 0x9c, 0x00, 0x0f, 0x76, 0x01, 0x05, 0x00, 0xdc,
+0x02, 0x02, 0x49, 0x00, 0x00, 0x44, 0x00, 0x22, 0x6f, 0x72,
+0x40, 0x00, 0x01, 0xc7, 0x02, 0x04, 0xb9, 0x00, 0x61, 0x72,
 0x65, 0x74, 0x75, 0x72, 0x6e, 0x41, 0x01, 0x51, 0x61, 0x72,
-0x72, 0x6f, 0x77, 0xc3, 0x00, 0x8b, 0x2c, 0x00, 0x62, 0x65,
+0x72, 0x6f, 0x77, 0xc3, 0x00, 0x8c, 0x2c, 0x00, 0x62, 0x65,
 0x66, 0x6f, 0x72, 0x65, 0xca, 0x00, 0x04, 0xc6, 0x01, 0x04,
-0x4a, 0x00, 0x02, 0x6c, 0x04, 0x88, 0x68, 0x69, 0x67, 0x68,
+0x4a, 0x00, 0x01, 0x42, 0x00, 0x88, 0x68, 0x69, 0x67, 0x68,
 0x6c, 0x69, 0x67, 0x68, 0x3d, 0x04, 0x10, 0x28, 0xae, 0x03,
-0x30, 0x62, 0x6f, 0x76, 0x48, 0x01, 0x42, 0x54, 0x68, 0x65,
-0x00, 0x88, 0x01, 0x70, 0x62, 0x61, 0x72, 0x00, 0x61, 0x64,
-0x64, 0xc9, 0x03, 0x00, 0xb4, 0x04, 0x00, 0x52, 0x01, 0x11,
-0x73, 0x0b, 0x02, 0x09, 0x29, 0x02, 0x01, 0x1e, 0x00, 0x42,
+0x30, 0x62, 0x6f, 0x76, 0x48, 0x01, 0x10, 0x54, 0xf5, 0x00,
+0x01, 0x88, 0x01, 0x70, 0x62, 0x61, 0x72, 0x00, 0x61, 0x64,
+0x64, 0xc9, 0x03, 0x00, 0xb4, 0x04, 0x00, 0x52, 0x01, 0x14,
+0x73, 0x0b, 0x02, 0x07, 0x29, 0x02, 0x00, 0x1e, 0x00, 0x42,
 0x66, 0x72, 0x6f, 0x6d, 0x2f, 0x01, 0x13, 0x65, 0x57, 0x03,
-0x15, 0x2e, 0xd1, 0x01, 0x02, 0xef, 0x01, 0x63, 0x65, 0x73,
-0x63, 0x61, 0x70, 0x65, 0x47, 0x00, 0x00, 0x4f, 0x05, 0x05,
-0x43, 0x00, 0x0e, 0x3c, 0x00, 0x01, 0x30, 0x05, 0x13, 0x41,
+0x17, 0x2e, 0xd1, 0x01, 0x00, 0x22, 0x00, 0x63, 0x65, 0x73,
+0x63, 0x61, 0x70, 0x65, 0x47, 0x00, 0x01, 0x4f, 0x05, 0x05,
+0xf6, 0x00, 0x0e, 0x3c, 0x00, 0x00, 0x30, 0x05, 0x13, 0x41,
 0x81, 0x01, 0x11, 0x61, 0x13, 0x00, 0xb1, 0x73, 0x00, 0x64,
 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0xc0, 0x05,
-0x03, 0xbc, 0x03, 0x30, 0x32, 0x2e, 0x31, 0x3e, 0x04, 0x02,
+0x03, 0xbc, 0x03, 0x31, 0x32, 0x2e, 0x31, 0x0e, 0x06, 0x01,
 0x57, 0x01, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
 0x6c, 0x65, 0x2e, 0x29, 0x8a, 0x03, 0x15, 0x32, 0x8a, 0x03,
 0x00, 0x2e, 0x05, 0x77, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73,
-0x20, 0x1d, 0x04, 0x11, 0x61, 0x13, 0x05, 0x01, 0xca, 0x02,
-0x20, 0x74, 0x6f, 0xe3, 0x01, 0x51, 0x66, 0x69, 0x67, 0x75,
-0x72, 0x5e, 0x02, 0x03, 0x88, 0x01, 0x00, 0x91, 0x05, 0x31,
-0x72, 0x6f, 0x77, 0x03, 0x01, 0x00, 0x34, 0x04, 0x30, 0x75,
-0x6d, 0x6e, 0xa5, 0x05, 0x05, 0x52, 0x02, 0x82, 0x2c, 0x00,
+0x20, 0x1d, 0x04, 0x12, 0x61, 0x13, 0x05, 0x00, 0xca, 0x02,
+0x20, 0x74, 0x6f, 0xe3, 0x01, 0x52, 0x66, 0x69, 0x67, 0x75,
+0x72, 0x5e, 0x02, 0x02, 0x88, 0x01, 0x00, 0x91, 0x05, 0x32,
+0x72, 0x6f, 0x77, 0x03, 0x01, 0x63, 0x63, 0x6f, 0x6c, 0x75,
+0x6d, 0x6e, 0xa5, 0x05, 0x02, 0x52, 0x02, 0x82, 0x2c, 0x00,
 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x9d, 0x01, 0xd0, 0x60,
 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75,
 0x2e, 0x00,
diff --git a/apps/plugins/puzzles/help/flip.c b/apps/plugins/puzzles/help/flip.c
index 06606d97b2..c451e8c672 100644
--- a/apps/plugins/puzzles/help/flip.c
+++ b/apps/plugins/puzzles/help/flip.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1522 comp 1092 ratio 0.717477 level 11 saved 430 */
+/* orig 1522 comp 1092 ratio 0.717477 level 10 saved 430 */
 const char help_text[] = {
 0xf2, 0x2f, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x34, 0x3a, 0x20, 0x46, 0x6c, 0x69, 0x70, 0x20, 0x00,
@@ -33,8 +33,8 @@ const char help_text[] = {
 0x61, 0x6e, 0x79, 0x30, 0x00, 0x01, 0x63, 0x00, 0xf3, 0x04,
 0x66, 0x6c, 0x69, 0x70, 0x00, 0x69, 0x74, 0x73, 0x00, 0x73,
 0x74, 0x61, 0x74, 0x65, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x5d,
-0x00, 0x21, 0x74, 0x6f, 0x7b, 0x00, 0x31, 0x00, 0x6f, 0x72,
-0x08, 0x00, 0x05, 0x76, 0x00, 0xf5, 0x0c, 0x2c, 0x00, 0x62,
+0x00, 0x21, 0x74, 0x6f, 0x7b, 0x00, 0x32, 0x00, 0x6f, 0x72,
+0x08, 0x00, 0x04, 0x76, 0x00, 0xf5, 0x0c, 0x2c, 0x00, 0x62,
 0x75, 0x74, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x00, 0x79, 0x6f,
 0x75, 0x00, 0x64, 0x6f, 0x00, 0x73, 0x6f, 0x2c, 0x00, 0x6f,
 0x74, 0x68, 0x65, 0x72, 0x89, 0x00, 0xf3, 0x01, 0x61, 0x72,
@@ -43,46 +43,46 @@ const char help_text[] = {
 0x00, 0x77, 0x65, 0x6c, 0x6c, 0x2e, 0x00, 0x00, 0x00, 0x45,
 0x61, 0x63, 0x68, 0x88, 0x00, 0xd0, 0x63, 0x6f, 0x6e, 0x74,
 0x61, 0x69, 0x6e, 0x73, 0x00, 0x61, 0x00, 0x73, 0x6d, 0xd4,
-0x00, 0xfa, 0x06, 0x64, 0x69, 0x61, 0x67, 0x72, 0x61, 0x6d,
+0x00, 0xfb, 0x06, 0x64, 0x69, 0x61, 0x67, 0x72, 0x61, 0x6d,
 0x00, 0x73, 0x68, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x00, 0x77,
 0x68, 0x69, 0x63, 0x68, 0x63, 0x00, 0x03, 0x59, 0x00, 0x05,
-0x88, 0x00, 0x04, 0xc9, 0x00, 0x00, 0x5c, 0x00, 0x42, 0x31,
+0x88, 0x00, 0x03, 0xc9, 0x00, 0x00, 0x5c, 0x00, 0x42, 0x31,
 0x34, 0x2e, 0x31, 0x6f, 0x01, 0x00, 0x5a, 0x00, 0x40, 0x72,
-0x6f, 0x6c, 0x73, 0x78, 0x01, 0x91, 0x54, 0x68, 0x69, 0x73,
-0x00, 0x67, 0x61, 0x6d, 0x65, 0x0e, 0x01, 0xf0, 0x02, 0x62,
+0x6f, 0x6c, 0x73, 0x78, 0x01, 0x60, 0x54, 0x68, 0x69, 0x73,
+0x00, 0x67, 0x18, 0x01, 0x00, 0x0e, 0x01, 0xf1, 0x02, 0x62,
 0x65, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x00, 0x77,
-0x69, 0x74, 0x68, 0x00, 0x65, 0x69, 0x5d, 0x00, 0x01, 0x3b,
+0x69, 0x74, 0x68, 0x00, 0x65, 0x69, 0x5d, 0x00, 0x00, 0x3b,
 0x01, 0xa2, 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64,
 0x00, 0x6f, 0x10, 0x00, 0x50, 0x6d, 0x6f, 0x75, 0x73, 0x65,
 0x57, 0x00, 0xf4, 0x00, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63,
 0x6c, 0x69, 0x63, 0x6b, 0x00, 0x69, 0x6e, 0x00, 0x61, 0xbe,
-0x00, 0x23, 0x74, 0x6f, 0x7c, 0x00, 0x01, 0xb4, 0x01, 0x01,
-0x4c, 0x01, 0xa5, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61,
-0x74, 0x65, 0x64, 0xdb, 0x01, 0x00, 0x4e, 0x00, 0x31, 0x75,
+0x00, 0x24, 0x74, 0x6f, 0x7c, 0x00, 0x01, 0x51, 0x01, 0x00,
+0x4c, 0x01, 0xa6, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61,
+0x74, 0x65, 0x64, 0xdb, 0x01, 0x61, 0x6f, 0x72, 0x00, 0x75,
 0x73, 0x65, 0x52, 0x00, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f,
-0x72, 0x69, 0x00, 0x00, 0xcc, 0x01, 0x05, 0x99, 0x01, 0x07,
-0x97, 0x01, 0x02, 0xc4, 0x01, 0x80, 0x70, 0x61, 0x63, 0x65,
+0x72, 0x69, 0x00, 0x01, 0xcc, 0x01, 0x04, 0x99, 0x01, 0x08,
+0x97, 0x01, 0x01, 0xc4, 0x01, 0x80, 0x70, 0x61, 0x63, 0x65,
 0x00, 0x62, 0x61, 0x72, 0x3c, 0x00, 0x41, 0x45, 0x6e, 0x74,
-0x65, 0x33, 0x00, 0x04, 0x70, 0x00, 0x00, 0x92, 0x00, 0x20,
-0x49, 0x66, 0xfb, 0x00, 0x05, 0x58, 0x00, 0xf4, 0x06, 0x60,
+0x65, 0x33, 0x00, 0x04, 0x70, 0x00, 0x00, 0x92, 0x00, 0x21,
+0x49, 0x66, 0xfb, 0x00, 0x04, 0x58, 0x00, 0xf4, 0x06, 0x60,
 0x53, 0x6f, 0x6c, 0x76, 0x65, 0x27, 0x00, 0x66, 0x75, 0x6e,
 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x6f, 0x6e, 0x00, 0x74,
-0xf6, 0x00, 0x10, 0x2c, 0xa1, 0x00, 0x92, 0x77, 0x69, 0x6c,
-0x6c, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x5b, 0x02, 0x28, 0x6f,
-0x66, 0x3f, 0x02, 0x00, 0xd6, 0x00, 0x44, 0x72, 0x65, 0x64,
+0xf6, 0x00, 0x10, 0x2c, 0xa1, 0x00, 0x60, 0x77, 0x69, 0x6c,
+0x6c, 0x00, 0x6d, 0xce, 0x01, 0x01, 0x5b, 0x02, 0x29, 0x6f,
+0x66, 0x3f, 0x02, 0x74, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x64,
 0x2e, 0x57, 0x00, 0x02, 0xeb, 0x00, 0x40, 0x6f, 0x6e, 0x63,
-0x65, 0x1a, 0x00, 0x44, 0x65, 0x76, 0x65, 0x72, 0x3a, 0x02,
-0x02, 0x34, 0x01, 0x10, 0x61, 0x2e, 0x00, 0x01, 0x4e, 0x00,
-0x10, 0x2c, 0x47, 0x00, 0x01, 0x66, 0x00, 0x00, 0xb3, 0x01,
-0x30, 0x75, 0x6c, 0x64, 0x5f, 0x01, 0x40, 0x73, 0x6f, 0x6c,
-0x76, 0x4e, 0x00, 0x13, 0x28, 0x4f, 0x00, 0x06, 0x3a, 0x01,
-0x08, 0x46, 0x00, 0x38, 0x6f, 0x75, 0x74, 0x49, 0x00, 0x07,
+0x65, 0x1a, 0x00, 0x45, 0x65, 0x76, 0x65, 0x72, 0x3a, 0x02,
+0x01, 0x34, 0x01, 0x10, 0x61, 0x2e, 0x00, 0x01, 0x4e, 0x00,
+0x11, 0x2c, 0x47, 0x00, 0x01, 0x5c, 0x01, 0x60, 0x73, 0x68,
+0x6f, 0x75, 0x6c, 0x64, 0x5f, 0x01, 0x10, 0x73, 0x8d, 0x00,
+0x49, 0x64, 0x2e, 0x00, 0x28, 0x4f, 0x00, 0x08, 0x3a, 0x01,
+0x00, 0x46, 0x00, 0x39, 0x6f, 0x75, 0x74, 0x49, 0x00, 0x06,
 0x0c, 0x00, 0x02, 0xad, 0x00, 0x60, 0x61, 0x70, 0x70, 0x65,
 0x61, 0x72, 0x37, 0x00, 0x11, 0x69, 0x93, 0x02, 0x70, 0x69,
-0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0xf1, 0x00, 0x20, 0x61,
-0x74, 0x58, 0x00, 0x02, 0x27, 0x00, 0x40, 0x6e, 0x65, 0x65,
+0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0xf1, 0x00, 0x21, 0x61,
+0x74, 0x58, 0x00, 0x01, 0x27, 0x00, 0x40, 0x6e, 0x65, 0x65,
 0x64, 0x1f, 0x00, 0x10, 0x72, 0xa7, 0x00, 0x13, 0x73, 0x1e,
-0x00, 0x50, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x09, 0x01, 0x02,
+0x00, 0x51, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x09, 0x01, 0x01,
 0x1a, 0x00, 0x00, 0x72, 0x02, 0x21, 0x74, 0x68, 0x99, 0x00,
 0x10, 0x75, 0x16, 0x00, 0x73, 0x2e, 0x29, 0x00, 0x00, 0x00,
 0x28, 0x41, 0x44, 0x03, 0x11, 0x61, 0x33, 0x01, 0xb0, 0x73,
@@ -92,39 +92,39 @@ const char help_text[] = {
 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
 0x29, 0x6d, 0x02, 0x12, 0x32, 0x6d, 0x02, 0x93, 0x70, 0x61,
 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x6f, 0x02, 0x46,
-0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x00, 0x40, 0x00, 0x05,
-0x3b, 0x00, 0x02, 0x69, 0x03, 0x02, 0xb5, 0x01, 0xd3, 0x43,
+0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02, 0x40, 0x00, 0x04,
+0x3b, 0x00, 0x02, 0x69, 0x03, 0x01, 0xb5, 0x01, 0xd6, 0x43,
 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00,
-0x6f, 0x70, 0xb7, 0x01, 0x02, 0x1a, 0x00, 0xa0, 0x54, 0x79,
+0x6f, 0x70, 0xb7, 0x01, 0xd0, 0x65, 0x00, 0x60, 0x54, 0x79,
 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xed, 0x01,
 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65,
-0x9e, 0x03, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0xc2, 0x01,
-0x02, 0x45, 0x04, 0x24, 0x69, 0x6e, 0xc6, 0x01, 0x10, 0x2e,
+0x9e, 0x03, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0xc2, 0x01,
+0x01, 0x45, 0x04, 0x24, 0x69, 0x6e, 0xc6, 0x01, 0x10, 0x2e,
 0x1b, 0x00, 0x94, 0x68, 0x61, 0x70, 0x65, 0x20, 0x74, 0x79,
 0x70, 0x65, 0xf8, 0x02, 0x03, 0x09, 0x03, 0x20, 0x00, 0x64,
 0x8c, 0x00, 0x52, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x0b, 0x01,
-0x35, 0x68, 0x61, 0x70, 0x07, 0x02, 0x63, 0x72, 0x65, 0x67,
-0x69, 0x6f, 0x6e, 0x6d, 0x03, 0x21, 0x69, 0x73, 0x66, 0x02,
+0x00, 0x29, 0x00, 0x04, 0x07, 0x02, 0x30, 0x72, 0x65, 0x67,
+0x7e, 0x00, 0x02, 0x6d, 0x03, 0x21, 0x69, 0x73, 0x66, 0x02,
 0x62, 0x70, 0x65, 0x64, 0x00, 0x62, 0x79, 0xbc, 0x01, 0x00,
 0x8a, 0x03, 0x21, 0x69, 0x6e, 0x41, 0x04, 0x44, 0x67, 0x69,
-0x76, 0x65, 0x72, 0x00, 0x10, 0x2e, 0xeb, 0x00, 0xf2, 0x14,
+0x76, 0x65, 0x72, 0x00, 0x10, 0x2e, 0xeb, 0x00, 0xfa, 0x14,
 0x00, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x73,
 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x00, 0x60, 0x43,
 0x72, 0x6f, 0x73, 0x73, 0x65, 0x73, 0x27, 0x2c, 0x00, 0x63,
-0x61, 0x75, 0x73, 0x65, 0x73, 0x42, 0x02, 0x0e, 0x36, 0x03,
+0x61, 0x75, 0x73, 0x65, 0x73, 0x42, 0x02, 0x06, 0x36, 0x03,
 0x45, 0x73, 0x65, 0x6c, 0x66, 0x3a, 0x03, 0x10, 0x66, 0xe7,
 0x04, 0x60, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0xe5, 0x01,
 0x10, 0x6e, 0xed, 0x00, 0x71, 0x62, 0x6f, 0x75, 0x72, 0x73,
 0x00, 0x28, 0x8f, 0x03, 0x31, 0x72, 0x65, 0x65, 0x98, 0x03,
 0xc0, 0x77, 0x6f, 0x00, 0x69, 0x66, 0x00, 0x69, 0x74, 0x27,
 0x73, 0x00, 0x61, 0x78, 0x03, 0x41, 0x00, 0x65, 0x64, 0x67,
-0x1a, 0x00, 0x71, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x29,
-0x95, 0x00, 0x02, 0x32, 0x04, 0x07, 0x93, 0x00, 0x65, 0x52,
-0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x92, 0x00, 0x00, 0x6d, 0x02,
-0x01, 0x12, 0x00, 0x01, 0x08, 0x01, 0x01, 0x94, 0x00, 0x20,
-0x62, 0x65, 0x8f, 0x03, 0x79, 0x73, 0x65, 0x6e, 0x00, 0x66,
-0x6f, 0x72, 0xb2, 0x00, 0x00, 0x9d, 0x05, 0x05, 0xe7, 0x02,
-0x00, 0x1f, 0x01, 0x93, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72,
+0x1a, 0x00, 0x72, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x29,
+0x95, 0x00, 0x03, 0x32, 0x04, 0x05, 0x93, 0x00, 0x66, 0x52,
+0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x92, 0x00, 0x31, 0x61, 0x00,
+0x72, 0x12, 0x00, 0x03, 0x08, 0x01, 0x20, 0x74, 0x6f, 0xb8,
+0x02, 0xa9, 0x63, 0x68, 0x6f, 0x73, 0x65, 0x6e, 0x00, 0x66,
+0x6f, 0x72, 0xb2, 0x00, 0x00, 0x9d, 0x05, 0x06, 0xe7, 0x02,
+0xc3, 0x69, 0x73, 0x00, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72,
 0x65, 0x6e, 0x74, 0x27, 0x00, 0x60, 0x74, 0x69, 0x6d, 0x65,
 0x2e, 0x00,
 };
diff --git a/apps/plugins/puzzles/help/flood.c b/apps/plugins/puzzles/help/flood.c
index 25a95cb394..1bee956902 100644
--- a/apps/plugins/puzzles/help/flood.c
+++ b/apps/plugins/puzzles/help/flood.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -16,7 +16,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2377 comp 1591 ratio 0.669331 level 11 saved 786 */
+/* orig 2377 comp 1592 ratio 0.669752 level 10 saved 785 */
 const char help_text[] = {
 0xf3, 0x45, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x39, 0x3a, 0x20, 0x46, 0x6c, 0x6f, 0x6f, 0x64, 0x20,
@@ -44,36 +44,36 @@ const char help_text[] = {
 0x74, 0x65, 0x64, 0x00, 0x70, 0x61, 0x74, 0x68, 0xdc, 0x00,
 0x23, 0x00, 0x61, 0x96, 0x00, 0x44, 0x73, 0x61, 0x6d, 0x65,
 0x86, 0x00, 0x10, 0x77, 0xab, 0x00, 0x30, 0x62, 0x65, 0x00,
-0xb3, 0x00, 0x51, 0x65, 0x64, 0x00, 0x69, 0x6e, 0x22, 0x00,
+0xb3, 0x00, 0x20, 0x65, 0x64, 0xa1, 0x00, 0x00, 0x22, 0x00,
 0x33, 0x6e, 0x65, 0x77, 0x21, 0x00, 0x51, 0x29, 0x2e, 0x00,
 0x41, 0x73, 0xdf, 0x00, 0xf2, 0x02, 0x64, 0x6f, 0x00, 0x74,
 0x68, 0x69, 0x73, 0x2c, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x00,
-0x61, 0x6e, 0x64, 0x09, 0x00, 0x20, 0x6f, 0x66, 0x32, 0x00,
-0x02, 0x48, 0x01, 0x77, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65,
+0x61, 0x6e, 0x64, 0x09, 0x00, 0x21, 0x6f, 0x66, 0x32, 0x00,
+0x01, 0x48, 0x01, 0x77, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65,
 0x73, 0x83, 0x00, 0x2f, 0x74, 0x6f, 0xb7, 0x00, 0x01, 0x12,
 0x2e, 0x89, 0x01, 0x80, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00,
 0x69, 0x73, 0x26, 0x00, 0x41, 0x6d, 0x61, 0x6b, 0x65, 0x2b,
-0x00, 0x42, 0x77, 0x68, 0x6f, 0x6c, 0x4f, 0x00, 0x0c, 0xac,
+0x00, 0x43, 0x77, 0x68, 0x6f, 0x6c, 0x4f, 0x00, 0x0b, 0xac,
 0x00, 0x11, 0x2c, 0x3f, 0x01, 0x51, 0x73, 0x00, 0x66, 0x65,
 0x77, 0x76, 0x01, 0x10, 0x73, 0x0d, 0x00, 0xb0, 0x70, 0x6f,
 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x2e, 0x00, 0x54, 0x86,
-0x00, 0x32, 0x61, 0x6d, 0x65, 0xd3, 0x00, 0xd3, 0x73, 0x65,
+0x00, 0x00, 0x2e, 0x00, 0x01, 0xd3, 0x00, 0xd3, 0x73, 0x65,
 0x74, 0x00, 0x61, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x00,
-0x6f, 0xd5, 0x00, 0x40, 0x75, 0x6d, 0x62, 0x65, 0x78, 0x01,
-0x02, 0x3e, 0x00, 0x70, 0x2c, 0x00, 0x62, 0x61, 0x73, 0x65,
+0x6f, 0xd5, 0x00, 0x41, 0x75, 0x6d, 0x62, 0x65, 0x78, 0x01,
+0x01, 0x3e, 0x00, 0x70, 0x2c, 0x00, 0x62, 0x61, 0x73, 0x65,
 0x64, 0x1e, 0x00, 0x40, 0x72, 0x75, 0x6e, 0x6e, 0x9e, 0x00,
 0xf1, 0x09, 0x69, 0x74, 0x73, 0x00, 0x6f, 0x77, 0x6e, 0x00,
 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x00, 0x73,
-0x6f, 0x6c, 0x76, 0x65, 0x72, 0x2e, 0x36, 0x02, 0x64, 0x77,
+0x6f, 0x6c, 0x76, 0x65, 0x72, 0x2e, 0x36, 0x02, 0x65, 0x77,
 0x69, 0x6e, 0x00, 0x69, 0x66, 0xea, 0x01, 0x0f, 0xb1, 0x00,
-0x11, 0x02, 0x4e, 0x01, 0x73, 0x61, 0x74, 0x00, 0x6d, 0x61,
+0x10, 0x02, 0x4e, 0x01, 0x73, 0x61, 0x74, 0x00, 0x6d, 0x61,
 0x6e, 0x79, 0xb3, 0x00, 0x20, 0x6f, 0x72, 0xc0, 0x00, 0x20,
 0x65, 0x72, 0x03, 0x01, 0x51, 0x49, 0x00, 0x73, 0x61, 0x77,
 0x55, 0x01, 0x02, 0xb9, 0x00, 0xd2, 0x28, 0x77, 0x69, 0x74,
 0x68, 0x00, 0x61, 0x00, 0x66, 0x69, 0x78, 0x65, 0x64, 0x52,
-0x00, 0x52, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0x11, 0x00, 0x06,
-0xc0, 0x00, 0x04, 0x85, 0x02, 0x10, 0x2c, 0x86, 0x01, 0x02,
-0x1d, 0x00, 0x01, 0x5e, 0x00, 0x02, 0xef, 0x00, 0x10, 0x29,
+0x00, 0x53, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0x11, 0x00, 0x06,
+0xc0, 0x00, 0x03, 0x85, 0x02, 0x11, 0x2c, 0x86, 0x01, 0x02,
+0x1d, 0x00, 0x00, 0x5e, 0x00, 0x02, 0xef, 0x00, 0x10, 0x29,
 0xba, 0x02, 0x71, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
 0x8f, 0x02, 0xf2, 0x0f, 0x69, 0x74, 0x2e, 0x61, 0x70, 0x70,
 0x73, 0x70, 0x6f, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x28,
@@ -82,86 +82,86 @@ const char help_text[] = {
 0x43, 0x33, 0x39, 0x2e, 0x31, 0x2a, 0x03, 0x80, 0x63, 0x6f,
 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, 0x33, 0x03, 0x81, 0x54,
 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x00, 0x1a, 0x00, 0x71,
-0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xeb, 0x00, 0x42,
-0x6d, 0x6f, 0x75, 0x73, 0xd4, 0x02, 0x05, 0xd8, 0x01, 0x18,
-0x54, 0xf5, 0x02, 0x60, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72,
-0xa5, 0x00, 0x02, 0xd8, 0x02, 0x5a, 0x74, 0x68, 0x69, 0x6e,
-0x67, 0x1d, 0x02, 0x24, 0x69, 0x74, 0x82, 0x02, 0x03, 0x3b,
-0x03, 0x03, 0x88, 0x02, 0x01, 0x0a, 0x01, 0x24, 0x74, 0x68,
-0x4a, 0x01, 0x03, 0x66, 0x02, 0x03, 0x67, 0x00, 0x00, 0x84,
-0x01, 0x02, 0x87, 0x00, 0x50, 0x65, 0x64, 0x2e, 0x00, 0x43,
-0x09, 0x00, 0x35, 0x69, 0x6e, 0x67, 0x86, 0x00, 0x0c, 0x87,
-0x01, 0x00, 0x27, 0x02, 0x1f, 0x74, 0x98, 0x00, 0x00, 0xd0,
+0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xeb, 0x00, 0x43,
+0x6d, 0x6f, 0x75, 0x73, 0xd4, 0x02, 0x04, 0xd8, 0x01, 0x18,
+0x54, 0xf5, 0x02, 0x61, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72,
+0xa5, 0x00, 0x01, 0xd8, 0x02, 0x20, 0x74, 0x68, 0x65, 0x01,
+0x09, 0x1d, 0x02, 0x26, 0x69, 0x74, 0x82, 0x02, 0x05, 0x3b,
+0x03, 0x31, 0x65, 0x64, 0x00, 0x0a, 0x01, 0x25, 0x74, 0x68,
+0x4a, 0x01, 0x03, 0x66, 0x02, 0x03, 0xf6, 0x02, 0x01, 0x84,
+0x01, 0x00, 0x87, 0x00, 0x50, 0x65, 0x64, 0x2e, 0x00, 0x43,
+0x09, 0x00, 0x00, 0x59, 0x00, 0x04, 0x86, 0x00, 0x0d, 0x87,
+0x01, 0x4f, 0x61, 0x73, 0x00, 0x74, 0x98, 0x00, 0x00, 0xd2,
 0x68, 0x61, 0x73, 0x00, 0x6e, 0x6f, 0x00, 0x65, 0x66, 0x66,
-0x65, 0x63, 0x74, 0x4c, 0x01, 0x01, 0xc1, 0x01, 0x30, 0x72,
+0x65, 0x63, 0x74, 0x4c, 0x01, 0x60, 0x74, 0x68, 0x65, 0x72,
 0x65, 0x66, 0xd7, 0x02, 0x30, 0x64, 0x6f, 0x65, 0x1e, 0x00,
-0x00, 0x2d, 0x00, 0x30, 0x75, 0x6e, 0x74, 0x43, 0x00, 0x10,
-0x61, 0x64, 0x01, 0x02, 0xbb, 0x02, 0x03, 0x03, 0x02, 0x82,
-0x61, 0x6c, 0x73, 0x6f, 0x00, 0x75, 0x73, 0x65, 0xa9, 0x00,
-0x90, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79,
-0xd0, 0x02, 0x02, 0x90, 0x01, 0x14, 0x61, 0x16, 0x00, 0xe3,
+0x00, 0x2d, 0x00, 0x30, 0x75, 0x6e, 0x74, 0x43, 0x00, 0x11,
+0x61, 0x64, 0x01, 0x03, 0xbb, 0x02, 0x01, 0x03, 0x02, 0x50,
+0x61, 0x6c, 0x73, 0x6f, 0x00, 0x03, 0x01, 0x01, 0xa9, 0x00,
+0x92, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79,
+0xd0, 0x02, 0x00, 0x90, 0x01, 0x14, 0x61, 0x16, 0x00, 0xe3,
 0x28, 0x6f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x62,
 0x6c, 0x61, 0x63, 0x6b, 0xa8, 0x00, 0x85, 0x29, 0x00, 0x61,
 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x40, 0x03, 0x40, 0x2e, 0x00,
 0x50, 0x72, 0x90, 0x01, 0x21, 0x6e, 0x67, 0x13, 0x00, 0x60,
 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x52, 0x00, 0x02, 0x24,
-0x01, 0x03, 0x56, 0x04, 0x0e, 0xc9, 0x00, 0x2f, 0x69, 0x6e,
-0x2b, 0x01, 0x07, 0x56, 0x75, 0x6e, 0x64, 0x65, 0x72, 0xa1,
-0x00, 0x01, 0x78, 0x02, 0x23, 0x28, 0x41, 0x49, 0x00, 0xf2,
+0x01, 0x0e, 0x56, 0x04, 0x03, 0xc9, 0x00, 0x2f, 0x69, 0x6e,
+0x2b, 0x01, 0x07, 0x57, 0x75, 0x6e, 0x64, 0x65, 0x72, 0xa1,
+0x00, 0x00, 0xc0, 0x00, 0x23, 0x28, 0x41, 0x49, 0x00, 0xf2,
 0x00, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x64,
 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x00, 0x04, 0x21, 0x73,
-0x65, 0x16, 0x00, 0x40, 0x00, 0x32, 0x2e, 0x31, 0x2a, 0x05,
-0x02, 0xe6, 0x00, 0x60, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
+0x65, 0x16, 0x00, 0x41, 0x00, 0x32, 0x2e, 0x31, 0x2a, 0x05,
+0x01, 0xe6, 0x00, 0x60, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
 0x68, 0x03, 0x12, 0x29, 0x29, 0x02, 0x13, 0x32, 0x29, 0x02,
 0x92, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
 0x2b, 0x02, 0x56, 0x68, 0x65, 0x73, 0x65, 0x00, 0x14, 0x00,
-0x00, 0x41, 0x00, 0x02, 0x3c, 0x00, 0x0a, 0xc7, 0x04, 0xe0,
+0x02, 0x41, 0x00, 0x04, 0x3c, 0x00, 0x06, 0xc7, 0x04, 0xe1,
 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e,
-0x27, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x04, 0xa5, 0x03, 0xb0,
+0x27, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x03, 0xa5, 0x03, 0xb0,
 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e,
 0x75, 0xab, 0x00, 0xf9, 0x04, 0x57, 0x69, 0x64, 0x74, 0x68,
 0x2c, 0x00, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00,
-0x00, 0x53, 0x69, 0x7a, 0x73, 0x04, 0x00, 0x14, 0x04, 0x04,
+0x00, 0x53, 0x69, 0x7a, 0x73, 0x04, 0x01, 0x14, 0x04, 0x03,
 0xe0, 0x04, 0x00, 0x30, 0x00, 0x12, 0x43, 0x1a, 0x03, 0x4c,
-0x00, 0x00, 0x00, 0x4e, 0x2e, 0x03, 0x31, 0x00, 0x75, 0x73,
-0x74, 0x02, 0x01, 0x48, 0x01, 0x07, 0x74, 0x01, 0x70, 0x4d,
-0x75, 0x73, 0x74, 0x00, 0x62, 0x65, 0x36, 0x03, 0x73, 0x6c,
-0x65, 0x61, 0x73, 0x74, 0x00, 0x33, 0x89, 0x03, 0x34, 0x74,
-0x77, 0x6f, 0x3c, 0x00, 0x02, 0x19, 0x02, 0x50, 0x00, 0x77,
+0x00, 0x00, 0x00, 0x4e, 0x2e, 0x03, 0x00, 0xaa, 0x01, 0x01,
+0x74, 0x02, 0x05, 0x48, 0x01, 0x02, 0x74, 0x01, 0x40, 0x4d,
+0x75, 0x73, 0x74, 0x80, 0x02, 0xa3, 0x61, 0x74, 0x00, 0x6c,
+0x65, 0x61, 0x73, 0x74, 0x00, 0x33, 0x89, 0x03, 0x35, 0x74,
+0x77, 0x6f, 0x3c, 0x00, 0x01, 0x19, 0x02, 0x50, 0x00, 0x77,
 0x6f, 0x75, 0x6c, 0x31, 0x04, 0x20, 0x6c, 0x79, 0x31, 0x00,
 0x93, 0x6f, 0x6e, 0x65, 0x00, 0x6c, 0x65, 0x67, 0x61, 0x6c,
-0xed, 0x01, 0x50, 0x74, 0x00, 0x61, 0x6e, 0x79, 0xeb, 0x04,
-0xc3, 0x67, 0x65, 0x2c, 0x00, 0x68, 0x65, 0x6e, 0x63, 0x65,
-0x00, 0x6e, 0x6f, 0xdf, 0x05, 0x05, 0xe3, 0x04, 0x20, 0x61,
+0xed, 0x01, 0x20, 0x74, 0x00, 0xe7, 0x03, 0xc0, 0x73, 0x74,
+0x61, 0x67, 0x65, 0x2c, 0x00, 0x68, 0x65, 0x6e, 0x63, 0x65,
+0x5f, 0x02, 0x03, 0xdf, 0x05, 0x04, 0xe3, 0x04, 0x20, 0x61,
 0x74, 0x87, 0x05, 0x12, 0x29, 0x6f, 0x02, 0x00, 0x1b, 0x04,
 0x60, 0x6f, 0x73, 0x74, 0x00, 0x31, 0x30, 0xbc, 0x00, 0x61,
-0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x27, 0x04, 0xa0, 0x20,
-0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0xd4,
-0x00, 0x02, 0x8c, 0x03, 0x02, 0xc5, 0x02, 0xa4, 0x64, 0x69,
+0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x27, 0x04, 0x70, 0x20,
+0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x25, 0x03, 0x00, 0xd4,
+0x00, 0x02, 0x8c, 0x03, 0x01, 0xb4, 0x00, 0xa4, 0x64, 0x69,
 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x07, 0x01,
 0x70, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x2c, 0x0b, 0x06,
-0x64, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x41, 0x02, 0x07,
-0x14, 0x04, 0x05, 0xaf, 0x06, 0x00, 0xda, 0x05, 0x02, 0x39,
-0x01, 0x02, 0xcf, 0x03, 0x01, 0x5a, 0x02, 0x00, 0x00, 0x05,
-0x2d, 0x00, 0x61, 0xf7, 0x04, 0x00, 0xb4, 0x00, 0x84, 0x67,
-0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x1b, 0x05, 0x00,
-0x1b, 0x00, 0x10, 0x75, 0xb0, 0x01, 0x05, 0x30, 0x03, 0x02,
-0xb7, 0x01, 0x40, 0x76, 0x61, 0x6c, 0x75, 0x0b, 0x04, 0x02,
+0x65, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x41, 0x02, 0x06,
+0x14, 0x04, 0x06, 0xaf, 0x06, 0x00, 0xda, 0x05, 0x02, 0x39,
+0x01, 0x01, 0xc0, 0x01, 0x02, 0x5a, 0x02, 0x5d, 0x72, 0x75,
+0x6e, 0x00, 0x61, 0xf7, 0x04, 0x00, 0xb4, 0x00, 0x85, 0x67,
+0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x1b, 0x05, 0x40,
+0x73, 0x6f, 0x6c, 0x75, 0xb0, 0x01, 0x05, 0x30, 0x03, 0x02,
+0xb7, 0x01, 0x41, 0x76, 0x61, 0x6c, 0x75, 0x0b, 0x04, 0x01,
 0xce, 0x04, 0x55, 0x66, 0x69, 0x65, 0x6c, 0x64, 0xd9, 0x03,
-0x36, 0x61, 0x64, 0x64, 0x0a, 0x06, 0x41, 0x6c, 0x65, 0x6e,
-0x67, 0x96, 0x06, 0x02, 0x80, 0x00, 0x25, 0x27, 0x73, 0x52,
+0x36, 0x61, 0x64, 0x64, 0x0a, 0x06, 0x42, 0x6c, 0x65, 0x6e,
+0x67, 0x96, 0x06, 0x01, 0x80, 0x00, 0x25, 0x27, 0x73, 0x52,
 0x00, 0x09, 0x6f, 0x00, 0x13, 0x74, 0xcd, 0x05, 0x29, 0x27,
-0x73, 0xc6, 0x00, 0x41, 0x53, 0x6f, 0x00, 0x61, 0x6c, 0x00,
-0x01, 0x05, 0x02, 0x92, 0x30, 0x00, 0x72, 0x65, 0x71, 0x75,
+0x73, 0xc6, 0x00, 0x43, 0x53, 0x6f, 0x00, 0x61, 0x6c, 0x00,
+0xc2, 0x6f, 0x66, 0x00, 0x30, 0x00, 0x72, 0x65, 0x71, 0x75,
 0x69, 0x72, 0x65, 0xa1, 0x06, 0x20, 0x74, 0x6f, 0x6e, 0x00,
 0x31, 0x6a, 0x75, 0x73, 0xaf, 0x03, 0x10, 0x65, 0x28, 0x01,
-0x21, 0x69, 0x65, 0xbc, 0x03, 0x05, 0x6c, 0x00, 0x93, 0x61,
-0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x65, 0x64, 0xe3, 0x00,
-0x03, 0x87, 0x01, 0x72, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65,
-0x72, 0x5a, 0x00, 0x01, 0xa8, 0x01, 0x10, 0x73, 0x9a, 0x04,
-0x00, 0x4b, 0x01, 0x12, 0x65, 0x32, 0x03, 0x41, 0x4e, 0x6f,
-0x74, 0x65, 0xcc, 0x05, 0x04, 0x4b, 0x00, 0x0b, 0x2d, 0x01,
-0x02, 0x49, 0x07, 0x01, 0x31, 0x04, 0x20, 0x6e, 0x65, 0x55,
+0x22, 0x69, 0x65, 0xbc, 0x03, 0x04, 0x6c, 0x00, 0x60, 0x61,
+0x75, 0x74, 0x6f, 0x6d, 0x61, 0x57, 0x01, 0x02, 0xe3, 0x00,
+0x03, 0x87, 0x01, 0x40, 0x00, 0x6c, 0x61, 0x72, 0x10, 0x05,
+0x02, 0x5a, 0x00, 0x00, 0xa8, 0x01, 0x10, 0x73, 0x9a, 0x04,
+0x00, 0x4b, 0x01, 0x12, 0x65, 0x32, 0x03, 0x42, 0x4e, 0x6f,
+0x74, 0x65, 0xcc, 0x05, 0x04, 0x4b, 0x00, 0x0c, 0x2d, 0x01,
+0x01, 0xee, 0x00, 0x00, 0x31, 0x04, 0x20, 0x6e, 0x65, 0x55,
 0x05, 0x93, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x66, 0x69,
 0x6e, 0x16, 0x06, 0x75, 0x68, 0x6f, 0x72, 0x74, 0x65, 0x73,
 0x74, 0xb0, 0x06, 0x07, 0x49, 0x01, 0xf0, 0x00, 0x74, 0x68,
@@ -170,14 +170,14 @@ const char help_text[] = {
 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, 0x00, 0x63, 0x6c, 0x6f,
 0x73, 0x65, 0x2e, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x61, 0x11,
 0x08, 0x60, 0x6c, 0x00, 0x63, 0x68, 0x61, 0x6c, 0x46, 0x01,
-0x20, 0x65, 0x2c, 0xe5, 0x06, 0x01, 0x71, 0x01, 0x01, 0xb9,
-0x00, 0x01, 0x64, 0x02, 0x17, 0x30, 0x97, 0x01, 0x52, 0x72,
-0x79, 0x00, 0x74, 0x6f, 0x9f, 0x00, 0x02, 0xe9, 0x08, 0x02,
-0xdf, 0x03, 0x81, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6c, 0x79,
-0x20, 0x87, 0x06, 0x02, 0x96, 0x06, 0x00, 0xda, 0x00, 0x00,
-0xbb, 0x01, 0x03, 0x68, 0x01, 0x00, 0x4e, 0x01, 0xc0, 0x27,
-0x72, 0x65, 0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x21, 0x29,
-0x00,
+0x21, 0x65, 0x2c, 0xe5, 0x06, 0x01, 0x71, 0x01, 0x02, 0xb9,
+0x00, 0x47, 0x74, 0x6f, 0x00, 0x30, 0x97, 0x01, 0x20, 0x72,
+0x79, 0x12, 0x00, 0x01, 0x9f, 0x00, 0x04, 0xe9, 0x08, 0x00,
+0x2d, 0x03, 0x81, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6c, 0x79,
+0x20, 0x87, 0x06, 0x03, 0x96, 0x06, 0x32, 0x74, 0x68, 0x61,
+0xc8, 0x01, 0x02, 0x31, 0x07, 0xf0, 0x00, 0x79, 0x6f, 0x75,
+0x27, 0x72, 0x65, 0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x21,
+0x29, 0x00,
 };
 
 const unsigned short help_text_len = 2377;
diff --git a/apps/plugins/puzzles/help/galaxies.c b/apps/plugins/puzzles/help/galaxies.c
index 68a59e6339..eed08b8ac4 100644
--- a/apps/plugins/puzzles/help/galaxies.c
+++ b/apps/plugins/puzzles/help/galaxies.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2754 comp 1877 ratio 0.681554 level 11 saved 877 */
+/* orig 2754 comp 1877 ratio 0.681554 level 10 saved 877 */
 const char help_text[] = {
 0xf0, 0x41, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x38, 0x3a, 0x20, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x69,
@@ -41,44 +41,44 @@ const char help_text[] = {
 0x00, 0xd0, 0x73, 0x00, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c,
 0x79, 0x00, 0x6f, 0x6e, 0x65, 0xaf, 0x00, 0x60, 0x00, 0x77,
 0x68, 0x69, 0x63, 0x68, 0x49, 0x00, 0x40, 0x6c, 0x6f, 0x63,
-0x61, 0x88, 0x00, 0xd0, 0x61, 0x74, 0x00, 0x69, 0x74, 0x73,
-0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x8e, 0x00, 0x03,
+0x61, 0x88, 0x00, 0xd1, 0x61, 0x74, 0x00, 0x69, 0x74, 0x73,
+0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x8e, 0x00, 0x02,
 0x4a, 0x00, 0xf0, 0x00, 0x79, 0x2e, 0x00, 0x00, 0x00, 0x54,
 0x6f, 0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x79, 0xe4,
 0x00, 0x40, 0x73, 0x6f, 0x6c, 0x75, 0x71, 0x00, 0x10, 0x2c,
-0x0f, 0x00, 0xf0, 0x02, 0x00, 0x64, 0x72, 0x61, 0x77, 0x00,
+0x0f, 0x00, 0xf1, 0x02, 0x00, 0x64, 0x72, 0x61, 0x77, 0x00,
 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x61, 0x6c, 0x6f, 0x6e,
-0x67, 0xef, 0x00, 0x02, 0x2e, 0x01, 0x41, 0x65, 0x64, 0x67,
+0x67, 0xef, 0x00, 0x01, 0x2e, 0x01, 0x41, 0x65, 0x64, 0x67,
 0x65, 0x0b, 0x01, 0x41, 0x6d, 0x61, 0x72, 0x6b, 0x17, 0x00,
-0x90, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x72, 0x69, 0x65,
-0xf0, 0x00, 0x00, 0x12, 0x00, 0x04, 0xff, 0x00, 0xc0, 0x2e,
+0x91, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x72, 0x69, 0x65,
+0xf0, 0x00, 0x02, 0x18, 0x01, 0x01, 0xff, 0x00, 0xc0, 0x2e,
 0x00, 0x54, 0x68, 0x65, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c,
-0x65, 0x96, 0x00, 0xc1, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
-0x74, 0x65, 0x00, 0x77, 0x68, 0x65, 0x41, 0x01, 0x01, 0x44,
+0x65, 0x96, 0x00, 0xc2, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
+0x74, 0x65, 0x00, 0x77, 0x68, 0x65, 0x41, 0x01, 0x00, 0x44,
 0x00, 0x23, 0x65, 0x64, 0x69, 0x00, 0x26, 0x6f, 0x6e, 0x66,
 0x00, 0xc0, 0x61, 0x72, 0x65, 0x00, 0x70, 0x72, 0x65, 0x63,
 0x69, 0x73, 0x65, 0x6c, 0x2d, 0x01, 0x32, 0x6f, 0x73, 0x65,
 0x33, 0x01, 0xc4, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74,
 0x65, 0x00, 0x74, 0x77, 0x6f, 0x5c, 0x01, 0x30, 0x00, 0x62,
-0x65, 0xa4, 0x00, 0x30, 0x69, 0x6e, 0x67, 0x98, 0x00, 0x94,
+0x65, 0xa4, 0x00, 0x10, 0x69, 0xa7, 0x00, 0xb6, 0x6f, 0x00,
 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x87,
-0x00, 0x01, 0xec, 0x00, 0x34, 0x68, 0x69, 0x73, 0x8a, 0x00,
+0x00, 0x64, 0x00, 0x00, 0x54, 0x68, 0x69, 0x73, 0x8a, 0x00,
 0x90, 0x77, 0x61, 0x73, 0x00, 0x69, 0x6e, 0x76, 0x65, 0x6e,
 0x22, 0x01, 0xf1, 0x06, 0x62, 0x79, 0x00, 0x4e, 0x69, 0x6b,
 0x6f, 0x6c, 0x69, 0x00, 0x5b, 0x31, 0x33, 0x5d, 0x2c, 0x00,
 0x75, 0x6e, 0x64, 0x65, 0x72, 0x88, 0x00, 0x80, 0x6e, 0x61,
-0x6d, 0x65, 0x00, 0x60, 0x54, 0x65, 0x6c, 0x01, 0x70, 0x00,
-0x53, 0x68, 0x6f, 0x77, 0x27, 0x3b, 0x4d, 0x01, 0x00, 0x18,
-0x00, 0x04, 0xce, 0x00, 0x30, 0x6d, 0x6f, 0x6e, 0x9e, 0x00,
-0x50, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x70, 0x01, 0x02, 0x07,
+0x6d, 0x65, 0x00, 0x60, 0x54, 0x65, 0x6c, 0x01, 0x71, 0x00,
+0x53, 0x68, 0x6f, 0x77, 0x27, 0x3b, 0x4d, 0x01, 0x01, 0x18,
+0x00, 0x02, 0xce, 0x00, 0x30, 0x6d, 0x6f, 0x6e, 0x9e, 0x00,
+0x51, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x70, 0x01, 0x01, 0x07,
 0x02, 0xf4, 0x04, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68,
 0x00, 0x61, 0x73, 0x00, 0x60, 0x53, 0x70, 0x69, 0x72, 0x61,
-0x6c, 0x00, 0x8b, 0x02, 0x45, 0x27, 0x2e, 0x00, 0x00, 0x0d,
-0x00, 0x00, 0x89, 0x00, 0x01, 0xcc, 0x01, 0x70, 0x72, 0x69,
-0x62, 0x75, 0x74, 0x65, 0x64, 0xbd, 0x00, 0x21, 0x74, 0x68,
-0x5a, 0x00, 0x40, 0x6c, 0x6c, 0x65, 0x63, 0x8d, 0x01, 0x00,
-0x9f, 0x00, 0xb0, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48,
-0x61, 0x72, 0x76, 0x65, 0xb7, 0x01, 0x01, 0xa8, 0x00, 0xd1,
+0x6c, 0x00, 0x8b, 0x02, 0x10, 0x27, 0x8c, 0x00, 0x04, 0x0d,
+0x00, 0x01, 0x89, 0x00, 0x00, 0xcc, 0x01, 0x40, 0x72, 0x69,
+0x62, 0x75, 0x3e, 0x00, 0x51, 0x74, 0x6f, 0x00, 0x74, 0x68,
+0x5a, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x63, 0x66, 0x02, 0xe1,
+0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48,
+0x61, 0x72, 0x76, 0x65, 0xb7, 0x01, 0x00, 0xa8, 0x00, 0xd1,
 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77,
 0x77, 0x2e, 0x6e, 0xbf, 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e,
 0x6a, 0x70, 0x2f, 0x65, 0x6e, 0x2f, 0xe6, 0x00, 0xf6, 0x10,
@@ -87,19 +87,19 @@ const char help_text[] = {
 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x32, 0x38, 0x2e,
 0x31, 0x1d, 0x03, 0x01, 0x81, 0x00, 0x21, 0x6f, 0x6c, 0x26,
 0x03, 0xa0, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69,
-0x63, 0x6b, 0x8d, 0x01, 0x30, 0x61, 0x6e, 0x79, 0x8d, 0x01,
-0x02, 0x9f, 0x01, 0x32, 0x00, 0x74, 0x6f, 0x15, 0x02, 0x21,
+0x63, 0x6b, 0x8d, 0x01, 0x32, 0x61, 0x6e, 0x79, 0x8d, 0x01,
+0x00, 0x9f, 0x01, 0x01, 0x5a, 0x01, 0x00, 0x15, 0x02, 0x21,
 0x61, 0x6e, 0x03, 0x02, 0x21, 0x00, 0x69, 0xeb, 0x01, 0x10,
 0x72, 0x0b, 0x01, 0x31, 0x6e, 0x27, 0x74, 0x83, 0x02, 0xb0,
 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x2c, 0x00, 0x6f,
-0x72, 0x2f, 0x00, 0x99, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
-0x00, 0x6f, 0x6e, 0x2d, 0x00, 0x61, 0x2e, 0x00, 0x57, 0x68,
-0x65, 0x6e, 0x65, 0x02, 0x50, 0x63, 0x72, 0x65, 0x61, 0x74,
+0x72, 0x2f, 0x00, 0x61, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
+0x1a, 0x00, 0x07, 0x2d, 0x00, 0x30, 0x2e, 0x00, 0x57, 0xfe,
+0x01, 0x00, 0x65, 0x02, 0x50, 0x63, 0x72, 0x65, 0x61, 0x74,
 0x93, 0x03, 0x54, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x08, 0x03,
-0x46, 0x28, 0x6f, 0x6e, 0x65, 0xca, 0x02, 0x7f, 0x63, 0x6c,
-0x6f, 0x73, 0x65, 0x64, 0x2c, 0xf4, 0x02, 0x06, 0x1a, 0x2c,
-0x38, 0x03, 0x06, 0x2b, 0x03, 0x61, 0x00, 0x61, 0x62, 0x6f,
-0x75, 0x74, 0x35, 0x02, 0x00, 0x28, 0x00, 0x0b, 0x3a, 0x03,
+0x10, 0x28, 0x31, 0x00, 0x05, 0xca, 0x02, 0x7f, 0x63, 0x6c,
+0x6f, 0x73, 0x65, 0x64, 0x2c, 0xf4, 0x02, 0x06, 0x1b, 0x2c,
+0x38, 0x03, 0x05, 0x2b, 0x03, 0x62, 0x00, 0x61, 0x62, 0x6f,
+0x75, 0x74, 0x35, 0x02, 0x01, 0x28, 0x00, 0x09, 0x3a, 0x03,
 0x50, 0x6e, 0x6f, 0x00, 0x65, 0x78, 0xb9, 0x01, 0x43, 0x65,
 0x6f, 0x75, 0x73, 0xd4, 0x02, 0x71, 0x62, 0x65, 0x74, 0x77,
 0x65, 0x65, 0x6e, 0x5a, 0x02, 0x21, 0x6f, 0x66, 0xec, 0x01,
@@ -107,99 +107,99 @@ const char help_text[] = {
 0x00, 0x69, 0x74, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x00, 0x62,
 0x65, 0x00, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68,
 0x65, 0x03, 0x80, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69,
-0x63, 0xac, 0x03, 0x69, 0x3b, 0x00, 0x73, 0x6f, 0x00, 0x79,
-0x35, 0x04, 0x02, 0x79, 0x04, 0x20, 0x74, 0x68, 0xd6, 0x00,
-0x22, 0x6f, 0x6c, 0xe1, 0x02, 0x09, 0x41, 0x00, 0x22, 0x69,
-0x6e, 0xa7, 0x00, 0x21, 0x77, 0x61, 0xe1, 0x01, 0x60, 0x44,
-0x75, 0x72, 0x69, 0x6e, 0x67, 0x91, 0x03, 0x42, 0x76, 0x69,
+0x63, 0xac, 0x03, 0x6a, 0x3b, 0x00, 0x73, 0x6f, 0x00, 0x79,
+0x35, 0x04, 0x01, 0x79, 0x04, 0x20, 0x74, 0x68, 0xd6, 0x00,
+0x23, 0x6f, 0x6c, 0xe1, 0x02, 0x08, 0x41, 0x00, 0x22, 0x69,
+0x6e, 0xa7, 0x00, 0x21, 0x77, 0x61, 0xe1, 0x01, 0x30, 0x44,
+0x75, 0x72, 0xcb, 0x02, 0x72, 0x73, 0x6f, 0x6c, 0x76, 0x69,
 0x6e, 0x67, 0x90, 0x03, 0x10, 0x6d, 0x2b, 0x00, 0x52, 0x00,
 0x6b, 0x6e, 0x6f, 0x77, 0x2b, 0x00, 0x12, 0x61, 0x8a, 0x04,
-0x15, 0x63, 0xc6, 0x04, 0x03, 0xa7, 0x00, 0x03, 0x0b, 0x03,
+0x16, 0x63, 0xc6, 0x04, 0x02, 0xa7, 0x00, 0x03, 0x0b, 0x03,
 0x01, 0x77, 0x00, 0xa2, 0x61, 0x00, 0x73, 0x70, 0x65, 0x63,
 0x69, 0x66, 0x69, 0x63, 0x01, 0x01, 0x70, 0x62, 0x75, 0x74,
-0x00, 0x6e, 0x6f, 0x74, 0xbf, 0x00, 0x21, 0x73, 0x75, 0x0f,
-0x04, 0x00, 0x89, 0x03, 0x11, 0x72, 0x9b, 0x00, 0x03, 0x03,
-0x01, 0x20, 0x67, 0x6f, 0x27, 0x01, 0x03, 0x7e, 0x01, 0x10,
-0x6f, 0xb3, 0x01, 0x04, 0xff, 0x00, 0x00, 0x92, 0x03, 0x03,
-0xe1, 0x04, 0x05, 0xab, 0x02, 0x01, 0x81, 0x01, 0xa7, 0x2e,
-0x00, 0x49, 0x6e, 0x00, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x15,
+0x00, 0x6e, 0x6f, 0x74, 0xbf, 0x00, 0x22, 0x73, 0x75, 0x0f,
+0x04, 0x11, 0x77, 0x95, 0x01, 0x00, 0x9b, 0x00, 0x02, 0x03,
+0x01, 0x21, 0x67, 0x6f, 0x27, 0x01, 0x02, 0x7e, 0x01, 0x10,
+0x6f, 0xb3, 0x01, 0x05, 0x64, 0x03, 0x00, 0x5d, 0x00, 0x06,
+0xe1, 0x04, 0x01, 0xab, 0x02, 0x01, 0x81, 0x01, 0x71, 0x2e,
+0x00, 0x49, 0x6e, 0x00, 0x6f, 0x72, 0x36, 0x03, 0x05, 0x15,
 0x04, 0x23, 0x69, 0x73, 0x07, 0x01, 0x30, 0x00, 0x64, 0x6f,
 0x1e, 0x02, 0x72, 0x66, 0x6f, 0x72, 0x67, 0x65, 0x74, 0x2c,
-0xf6, 0x01, 0x76, 0x61, 0x6e, 0x00, 0x72, 0x69, 0x67, 0x68,
-0x6a, 0x02, 0x04, 0x4b, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x65,
-0x02, 0x22, 0x67, 0x2c, 0x82, 0x00, 0x01, 0x6e, 0x01, 0x05,
+0xf6, 0x01, 0x40, 0x61, 0x6e, 0x00, 0x72, 0xcf, 0x00, 0x06,
+0x6a, 0x02, 0x03, 0x4b, 0x00, 0x01, 0x7c, 0x00, 0x53, 0x64,
+0x72, 0x61, 0x67, 0x2c, 0x82, 0x00, 0x01, 0x6e, 0x01, 0x04,
 0x26, 0x02, 0x72, 0x6e, 0x00, 0x61, 0x72, 0x72, 0x6f, 0x77,
 0x34, 0x04, 0x71, 0x72, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74,
-0xb4, 0x05, 0x16, 0x74, 0x8b, 0x00, 0x41, 0x44, 0x72, 0x6f,
-0x70, 0x21, 0x01, 0x00, 0x54, 0x01, 0x14, 0x61, 0x14, 0x01,
-0x22, 0x6f, 0x66, 0x92, 0x01, 0x60, 0x63, 0x68, 0x6f, 0x69,
-0x63, 0x65, 0x66, 0x00, 0x04, 0xcb, 0x01, 0x00, 0xa4, 0x02,
-0x30, 0x69, 0x6e, 0x64, 0x1f, 0x00, 0x03, 0x73, 0x00, 0x20,
+0xb4, 0x05, 0x16, 0x74, 0x8b, 0x00, 0x42, 0x44, 0x72, 0x6f,
+0x70, 0x21, 0x01, 0x44, 0x69, 0x6e, 0x00, 0x61, 0x14, 0x01,
+0x22, 0x6f, 0x66, 0x92, 0x01, 0x61, 0x63, 0x68, 0x6f, 0x69,
+0x63, 0x65, 0x66, 0x00, 0x04, 0xcb, 0x01, 0x61, 0x72, 0x65,
+0x6d, 0x69, 0x6e, 0x64, 0x98, 0x00, 0x02, 0x73, 0x00, 0x20,
 0x64, 0x6f, 0x33, 0x05, 0x91, 0x27, 0x73, 0x00, 0x61, 0x73,
-0x73, 0x6f, 0x63, 0x69, 0xd6, 0x03, 0x73, 0x77, 0x69, 0x74,
-0x68, 0x2e, 0x00, 0x59, 0xbc, 0x00, 0x4c, 0x61, 0x6c, 0x73,
-0x6f, 0xc1, 0x00, 0x40, 0x65, 0x78, 0x69, 0x73, 0x8d, 0x00,
-0x02, 0xa3, 0x00, 0x02, 0x2a, 0x06, 0x21, 0x69, 0x63, 0x1f,
-0x05, 0x41, 0x6d, 0x00, 0x75, 0x70, 0x73, 0x00, 0x00, 0x0d,
-0x03, 0x01, 0x11, 0x00, 0x01, 0x20, 0x03, 0x20, 0x64, 0x65,
-0x9f, 0x03, 0x11, 0x79, 0x11, 0x00, 0x00, 0xe6, 0x03, 0x82,
-0x64, 0x72, 0x6f, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x11, 0x00,
-0x34, 0x6f, 0x66, 0x66, 0x96, 0x01, 0x00, 0xbf, 0x00, 0x05,
-0x18, 0x05, 0xa1, 0x2e, 0x00, 0x28, 0x41, 0x6c, 0x73, 0x6f,
-0x2c, 0x00, 0x69, 0xd3, 0x00, 0x30, 0x27, 0x72, 0x65, 0xd2,
-0x01, 0x01, 0xcf, 0x01, 0x06, 0xc0, 0x00, 0x06, 0x2b, 0x01,
-0x27, 0x69, 0x73, 0x27, 0x01, 0x06, 0x7f, 0x01, 0x02, 0x9c,
-0x00, 0x28, 0x69, 0x74, 0x9a, 0x00, 0x00, 0x0f, 0x00, 0x20,
+0x73, 0x6f, 0x63, 0x69, 0xd6, 0x03, 0x41, 0x77, 0x69, 0x74,
+0x68, 0x0a, 0x06, 0x01, 0xbc, 0x00, 0x4c, 0x61, 0x6c, 0x73,
+0x6f, 0xc1, 0x00, 0x42, 0x65, 0x78, 0x69, 0x73, 0x8d, 0x00,
+0x00, 0xa3, 0x00, 0x02, 0x2a, 0x06, 0x21, 0x69, 0x63, 0x1f,
+0x05, 0x41, 0x6d, 0x00, 0x75, 0x70, 0x73, 0x00, 0x01, 0x0d,
+0x03, 0x00, 0x11, 0x00, 0x01, 0x20, 0x03, 0x20, 0x64, 0x65,
+0x9f, 0x03, 0x12, 0x79, 0x22, 0x00, 0x81, 0x62, 0x79, 0x00,
+0x64, 0x72, 0x6f, 0x70, 0x70, 0xc2, 0x04, 0x00, 0x11, 0x00,
+0x35, 0x6f, 0x66, 0x66, 0x96, 0x01, 0x04, 0x55, 0x05, 0x00,
+0xe6, 0x01, 0xa1, 0x2e, 0x00, 0x28, 0x41, 0x6c, 0x73, 0x6f,
+0x2c, 0x00, 0x69, 0xd3, 0x00, 0x31, 0x27, 0x72, 0x65, 0xd2,
+0x01, 0x01, 0xcf, 0x01, 0x06, 0xc0, 0x00, 0x05, 0x2b, 0x01,
+0x28, 0x69, 0x73, 0x27, 0x01, 0x06, 0x7f, 0x01, 0x01, 0x9c,
+0x00, 0x29, 0x69, 0x74, 0x9a, 0x00, 0x50, 0x69, 0x74, 0x00,
 0x61, 0x72, 0xca, 0x05, 0x02, 0xc7, 0x01, 0x11, 0x6b, 0x12,
 0x00, 0xa3, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x65, 0x72, 0x2e,
 0x00, 0x49, 0x30, 0x01, 0x60, 0x73, 0x77, 0x69, 0x76, 0x65,
 0x6c, 0x09, 0x02, 0x40, 0x73, 0x74, 0x61, 0x6e, 0x88, 0x03,
 0x24, 0x61, 0x73, 0x31, 0x06, 0x50, 0x67, 0x00, 0x69, 0x74,
-0x2c, 0x3e, 0x00, 0x41, 0x73, 0x74, 0x61, 0x79, 0x79, 0x00,
-0x07, 0x83, 0x06, 0x20, 0x70, 0x61, 0x93, 0x05, 0x01, 0xa6,
+0x2c, 0x3e, 0x00, 0x42, 0x73, 0x74, 0x61, 0x79, 0x79, 0x00,
+0x06, 0x83, 0x06, 0x21, 0x70, 0x61, 0x93, 0x05, 0x00, 0xa6,
 0x01, 0x3a, 0x29, 0x00, 0x00, 0x4d, 0x01, 0x22, 0x75, 0x73,
-0x84, 0x02, 0xa0, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00,
-0x6b, 0x65, 0x79, 0x42, 0x01, 0x01, 0x97, 0x00, 0x03, 0x94,
-0x00, 0x05, 0x01, 0x01, 0x06, 0x8f, 0x02, 0x13, 0x6e, 0x37,
-0x06, 0xa3, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x69,
-0x6e, 0x67, 0x7b, 0x06, 0x40, 0x74, 0x75, 0x72, 0x6e, 0x44,
-0x00, 0x02, 0x66, 0x06, 0x66, 0x6f, 0x76, 0x65, 0x72, 0x00,
-0x61, 0xc8, 0x04, 0x01, 0xc7, 0x00, 0x02, 0xca, 0x04, 0x22,
-0x6f, 0x72, 0xe0, 0x00, 0x32, 0x00, 0x69, 0x74, 0x03, 0x04,
-0x40, 0x2c, 0x00, 0x61, 0x73, 0x37, 0x04, 0x2f, 0x76, 0x65,
-0x55, 0x00, 0x13, 0x22, 0x64, 0x6f, 0x16, 0x01, 0x02, 0x50,
+0x84, 0x02, 0xa2, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00,
+0x6b, 0x65, 0x79, 0x61, 0x06, 0x00, 0x97, 0x00, 0x04, 0x94,
+0x00, 0x04, 0x19, 0x06, 0x05, 0x8f, 0x02, 0x13, 0x6e, 0x37,
+0x06, 0x83, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x69,
+0xa4, 0x06, 0x60, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x44,
+0x00, 0x02, 0x66, 0x06, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x00,
+0x61, 0xc8, 0x04, 0x01, 0xc7, 0x00, 0x01, 0xca, 0x04, 0x22,
+0x6f, 0x72, 0xe0, 0x00, 0x01, 0xa0, 0x00, 0x00, 0x6a, 0x01,
+0x10, 0x2c, 0xcd, 0x00, 0x5f, 0x61, 0x62, 0x6f, 0x76, 0x65,
+0x55, 0x00, 0x13, 0x23, 0x64, 0x6f, 0x16, 0x01, 0x01, 0x50,
 0x01, 0x25, 0x75, 0x70, 0x79, 0x01, 0x01, 0x06, 0x01, 0x22,
-0x62, 0x65, 0xd5, 0x01, 0x22, 0x65, 0x64, 0x4f, 0x06, 0x8b,
+0x62, 0x65, 0xd5, 0x01, 0x22, 0x65, 0x64, 0x4f, 0x06, 0x8c,
 0x65, 0x78, 0x74, 0x00, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x00,
-0x01, 0xa5, 0x01, 0x00, 0x6d, 0x00, 0x31, 0x65, 0x64, 0x3b,
-0x3a, 0x03, 0x06, 0x18, 0x01, 0x20, 0x62, 0x65, 0x1b, 0x01,
-0x14, 0x64, 0x0c, 0x01, 0x0c, 0x66, 0x02, 0x03, 0x1c, 0x01,
+0x00, 0xa5, 0x01, 0x00, 0x6d, 0x00, 0x33, 0x65, 0x64, 0x3b,
+0xff, 0x05, 0x04, 0x18, 0x01, 0x20, 0x62, 0x65, 0x1b, 0x01,
+0x15, 0x64, 0x0c, 0x01, 0x0c, 0x66, 0x02, 0x02, 0x1c, 0x01,
 0x12, 0x2c, 0x69, 0x05, 0x05, 0x3c, 0x02, 0x0e, 0x4d, 0x02,
-0x12, 0x6e, 0xac, 0x00, 0x00, 0xf1, 0x00, 0x21, 0x61, 0x6e,
-0xd6, 0x03, 0x02, 0x42, 0x00, 0x30, 0x2e, 0x00, 0x00, 0x50,
-0x02, 0x11, 0x6c, 0x92, 0x00, 0x11, 0x61, 0x71, 0x06, 0x10,
+0x13, 0x6e, 0xac, 0x00, 0x52, 0x6f, 0x72, 0x00, 0x61, 0x6e,
+0xd6, 0x03, 0x01, 0x42, 0x00, 0x00, 0x6d, 0x04, 0x41, 0x28,
+0x41, 0x6c, 0x6c, 0x92, 0x00, 0x11, 0x61, 0x71, 0x06, 0x10,
 0x73, 0x99, 0x02, 0x42, 0x63, 0x72, 0x69, 0x62, 0x97, 0x04,
-0x13, 0x73, 0x87, 0x06, 0x30, 0x32, 0x2e, 0x31, 0x01, 0x04,
-0x02, 0x97, 0x00, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
+0x13, 0x73, 0x87, 0x06, 0x31, 0x32, 0x2e, 0x31, 0x01, 0x04,
+0x01, 0x97, 0x00, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
 0x62, 0x6c, 0x65, 0x2e, 0x29, 0x4e, 0x06, 0x16, 0x32, 0x4e,
-0x06, 0x00, 0x9d, 0x07, 0x50, 0x6d, 0x65, 0x74, 0x65, 0x72,
-0x50, 0x06, 0x00, 0xff, 0x07, 0x35, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x01, 0x45, 0x04, 0x06, 0x3f, 0x00, 0x51, 0x00, 0x66,
-0x72, 0x6f, 0x6d, 0x7c, 0x00, 0xe0, 0x60, 0x43, 0x75, 0x73,
+0x06, 0x00, 0x9d, 0x07, 0x71, 0x6d, 0x65, 0x74, 0x65, 0x72,
+0x73, 0x20, 0x76, 0x07, 0x46, 0x65, 0x73, 0x65, 0x00, 0x14,
+0x00, 0x02, 0x44, 0x00, 0x04, 0x3f, 0x00, 0x51, 0x00, 0x66,
+0x72, 0x6f, 0x6d, 0x7c, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73,
 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70,
-0x72, 0x00, 0x04, 0x16, 0x04, 0xb0, 0x60, 0x54, 0x79, 0x70,
+0x72, 0x00, 0x03, 0x16, 0x04, 0xb0, 0x60, 0x54, 0x79, 0x70,
 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xae, 0x00, 0x91,
 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x0f,
-0x05, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x20, 0x03, 0x02,
+0x05, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x20, 0x03, 0x01,
 0xdf, 0x01, 0x15, 0x69, 0xac, 0x05, 0x01, 0x46, 0x05, 0x30,
 0x69, 0x66, 0x66, 0x20, 0x05, 0x63, 0x74, 0x79, 0x00, 0x00,
-0x00, 0x43, 0xe5, 0x06, 0x02, 0x2a, 0x04, 0x05, 0x1a, 0x00,
-0x05, 0x5b, 0x03, 0x40, 0x65, 0x6e, 0x65, 0x72, 0xeb, 0x03,
-0x03, 0x23, 0x08, 0x57, 0x2e, 0x00, 0x4d, 0x6f, 0x72, 0x29,
-0x00, 0x13, 0x00, 0x54, 0x07, 0xd3, 0x00, 0x72, 0x65, 0x71,
-0x75, 0x69, 0x72, 0x65, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0xcf,
+0x00, 0x43, 0xe5, 0x06, 0x02, 0x2a, 0x04, 0x06, 0x1a, 0x00,
+0x04, 0x5b, 0x03, 0x41, 0x65, 0x6e, 0x65, 0x72, 0xeb, 0x03,
+0x02, 0x3d, 0x07, 0x57, 0x2e, 0x00, 0x4d, 0x6f, 0x72, 0x29,
+0x00, 0x13, 0x00, 0x54, 0x07, 0xa0, 0x00, 0x72, 0x65, 0x71,
+0x75, 0x69, 0x72, 0x65, 0x00, 0x6d, 0x1f, 0x00, 0x02, 0xcf,
 0x08, 0x62, 0x78, 0x00, 0x64, 0x65, 0x64, 0x75, 0x3d, 0x01,
-0x01, 0x65, 0x06, 0x02, 0xb8, 0x00, 0x80, 0x55, 0x6e, 0x72,
+0x02, 0x65, 0x06, 0x01, 0xb8, 0x00, 0x80, 0x55, 0x6e, 0x72,
 0x65, 0x61, 0x73, 0x6f, 0x6e, 0xe9, 0x00, 0x18, 0x27, 0x73,
 0x00, 0x20, 0x6c, 0x65, 0x41, 0x03, 0x35, 0x6d, 0x61, 0x79,
 0x4d, 0x00, 0xe0, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61,
diff --git a/apps/plugins/puzzles/help/guess.c b/apps/plugins/puzzles/help/guess.c
index 63ada73bca..1fc4f0695f 100644
--- a/apps/plugins/puzzles/help/guess.c
+++ b/apps/plugins/puzzles/help/guess.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -16,7 +16,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3042 comp 1882 ratio 0.618672 level 11 saved 1160 */
+/* orig 3042 comp 1883 ratio 0.619001 level 10 saved 1159 */
 const char help_text[] = {
 0xf2, 0x2a, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x35, 0x3a, 0x20, 0x47, 0x75, 0x65, 0x73, 0x73, 0x20,
@@ -37,17 +37,17 @@ const char help_text[] = {
 0x95, 0x00, 0xa2, 0x65, 0x73, 0x2e, 0x00, 0x00, 0x00, 0x45,
 0x61, 0x63, 0x68, 0x10, 0x00, 0xc1, 0x00, 0x67, 0x65, 0x74,
 0x73, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x64, 0x3d, 0x00,
-0x00, 0x50, 0x00, 0x07, 0x35, 0x00, 0xa9, 0x63, 0x6f, 0x72,
-0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x2d, 0xb9, 0x00, 0x30,
-0x00, 0x69, 0x6e, 0x29, 0x00, 0x04, 0x1f, 0x00, 0xf2, 0x03,
+0x01, 0x50, 0x00, 0x06, 0x35, 0x00, 0xa9, 0x63, 0x6f, 0x72,
+0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x2d, 0xb9, 0x00, 0x33,
+0x00, 0x69, 0x6e, 0x79, 0x00, 0x01, 0x1f, 0x00, 0xf2, 0x03,
 0x00, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x00, 0x28, 0x69,
 0x6e, 0x00, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x29, 0xda, 0x00,
 0x4f, 0x61, 0x6c, 0x73, 0x6f, 0x51, 0x00, 0x06, 0x1f, 0x00,
 0x52, 0x00, 0x02, 0x58, 0x77, 0x72, 0x6f, 0x6e, 0x67, 0x50,
 0x00, 0x60, 0x77, 0x68, 0x69, 0x74, 0x65, 0x29, 0xb6, 0x00,
 0xc2, 0x54, 0x68, 0x69, 0x73, 0x00, 0x67, 0x61, 0x6d, 0x65,
-0x00, 0x69, 0x73, 0x5b, 0x00, 0xa2, 0x6b, 0x6e, 0x6f, 0x77,
-0x6e, 0x00, 0x28, 0x61, 0x6e, 0x64, 0xc3, 0x00, 0x40, 0x74,
+0x00, 0x69, 0x73, 0x5b, 0x00, 0x70, 0x6b, 0x6e, 0x6f, 0x77,
+0x6e, 0x00, 0x28, 0x6b, 0x00, 0x01, 0xc3, 0x00, 0x40, 0x74,
 0x65, 0x64, 0x2c, 0x14, 0x01, 0xf2, 0x0b, 0x48, 0x61, 0x73,
 0x62, 0x72, 0x6f, 0x2c, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x6c,
 0x79, 0x29, 0x00, 0x61, 0x73, 0x00, 0x61, 0x00, 0x62, 0x6f,
@@ -59,13 +59,13 @@ const char help_text[] = {
 0x65, 0x72, 0x2c, 0x00, 0x74, 0x91, 0x00, 0xf0, 0x06, 0x76,
 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x61, 0x6c, 0x6c,
 0x6f, 0x77, 0x73, 0x00, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d,
-0xee, 0x01, 0x86, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x6f,
-0x66, 0xfd, 0x00, 0x04, 0x63, 0x00, 0x40, 0x00, 0x28, 0x75,
-0x70, 0xf1, 0x01, 0x46, 0x31, 0x30, 0x29, 0x2c, 0x1e, 0x00,
-0x0e, 0x76, 0x00, 0x0f, 0xbd, 0x01, 0x03, 0x11, 0x47, 0xb8,
-0x01, 0xf1, 0x03, 0x77, 0x61, 0x73, 0x00, 0x63, 0x6f, 0x6e,
-0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x00, 0x74,
-0x6f, 0x8f, 0x00, 0x00, 0x63, 0x00, 0x61, 0x6c, 0x65, 0x63,
+0xee, 0x01, 0x50, 0x74, 0x69, 0x6e, 0x67, 0x73, 0xf3, 0x00,
+0x08, 0xfd, 0x00, 0x01, 0x63, 0x00, 0x40, 0x00, 0x28, 0x75,
+0x70, 0xf1, 0x01, 0x47, 0x31, 0x30, 0x29, 0x2c, 0x1e, 0x00,
+0x0e, 0x76, 0x00, 0x0f, 0xbd, 0x01, 0x02, 0x11, 0x47, 0xb8,
+0x01, 0xf0, 0x00, 0x77, 0x61, 0x73, 0x00, 0x63, 0x6f, 0x6e,
+0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x4f, 0x00,
+0x01, 0x8f, 0x00, 0x91, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
 0x74, 0x69, 0x6f, 0x1d, 0x02, 0xc0, 0x4a, 0x61, 0x6d, 0x65,
 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x3c, 0x00,
 0x43, 0x31, 0x35, 0x2e, 0x31, 0x9e, 0x02, 0x01, 0x3d, 0x00,
@@ -73,24 +73,24 @@ const char help_text[] = {
 0x6e, 0x00, 0x62, 0x65, 0x80, 0x01, 0x14, 0x79, 0x11, 0x02,
 0x61, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x9d, 0x01, 0x32,
 0x6b, 0x65, 0x79, 0x46, 0x01, 0x12, 0x6f, 0x10, 0x00, 0x50,
-0x6d, 0x6f, 0x75, 0x73, 0x65, 0x58, 0x00, 0x46, 0x57, 0x69,
-0x74, 0x68, 0x12, 0x00, 0x89, 0x2c, 0x00, 0x64, 0x72, 0x61,
+0x6d, 0x6f, 0x75, 0x73, 0x65, 0x58, 0x00, 0x14, 0x57, 0x3a,
+0x02, 0x01, 0x12, 0x00, 0x89, 0x2c, 0x00, 0x64, 0x72, 0x61,
 0x67, 0x00, 0x61, 0xe2, 0x01, 0x51, 0x00, 0x66, 0x72, 0x6f,
 0x6d, 0x24, 0x00, 0x62, 0x74, 0x72, 0x61, 0x79, 0x00, 0x6f,
 0xef, 0x01, 0x60, 0x6c, 0x65, 0x66, 0x74, 0x2d, 0x68, 0xec,
 0x00, 0x31, 0x73, 0x69, 0x64, 0x06, 0x03, 0x91, 0x69, 0x74,
-0x73, 0x00, 0x72, 0x65, 0x71, 0x75, 0x69, 0x38, 0x00, 0x30,
-0x6f, 0x73, 0x69, 0xcc, 0x00, 0x05, 0x70, 0x02, 0x62, 0x75,
+0x73, 0x00, 0x72, 0x65, 0x71, 0x75, 0x69, 0x38, 0x00, 0x31,
+0x6f, 0x73, 0x69, 0xcc, 0x00, 0x04, 0x70, 0x02, 0x62, 0x75,
 0x72, 0x72, 0x65, 0x6e, 0x74, 0x0f, 0x01, 0x12, 0x3b, 0x32,
 0x01, 0x32, 0x6d, 0x61, 0x79, 0x0e, 0x02, 0x21, 0x62, 0x65,
-0x78, 0x00, 0x31, 0x67, 0x65, 0x64, 0x6c, 0x00, 0x04, 0x2d,
-0x00, 0x01, 0x4a, 0x01, 0x44, 0x70, 0x61, 0x73, 0x74, 0x45,
+0x78, 0x00, 0x32, 0x67, 0x65, 0x64, 0x6c, 0x00, 0x04, 0x2d,
+0x00, 0x00, 0x5e, 0x00, 0x44, 0x70, 0x61, 0x73, 0x74, 0x45,
 0x01, 0x00, 0x66, 0x00, 0x42, 0x63, 0x6f, 0x70, 0x79, 0x4b,
 0x03, 0xc0, 0x65, 0x6c, 0x73, 0x65, 0x77, 0x68, 0x65, 0x72,
-0x65, 0x2e, 0x00, 0x54, 0x84, 0x03, 0x20, 0x6d, 0x6f, 0xaf,
-0x03, 0x00, 0x5b, 0x00, 0x03, 0xc7, 0x00, 0x10, 0x69, 0xb8,
-0x03, 0x10, 0x66, 0x98, 0x00, 0x04, 0x52, 0x00, 0x05, 0x97,
-0x00, 0x00, 0x4a, 0x00, 0x32, 0x73, 0x6f, 0x6d, 0x40, 0x00,
+0x65, 0x2e, 0x00, 0x54, 0x84, 0x03, 0x31, 0x6d, 0x6f, 0x76,
+0x81, 0x03, 0x23, 0x65, 0x67, 0xc7, 0x00, 0x10, 0x69, 0xb8,
+0x03, 0x11, 0x66, 0x98, 0x00, 0x04, 0x52, 0x00, 0x05, 0x97,
+0x00, 0x62, 0x74, 0x6f, 0x00, 0x73, 0x6f, 0x6d, 0x40, 0x00,
 0x80, 0x00, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10,
 0x01, 0xef, 0x52, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x63, 0x6c,
 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0xbe, 0x00, 0x02, 0x40,
@@ -99,114 +99,114 @@ const char help_text[] = {
 0x74, 0x68, 0x61, 0x74, 0x17, 0x04, 0x00, 0x1d, 0x00, 0x03,
 0x1c, 0x00, 0x60, 0x73, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0xe6,
 0x00, 0xd0, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69,
-0x63, 0x61, 0x6c, 0x6c, 0x79, 0x48, 0x00, 0x00, 0x00, 0x02,
-0x03, 0x69, 0x03, 0x25, 0x65, 0x78, 0x60, 0x00, 0x40, 0x66,
-0x74, 0x65, 0x72, 0x3c, 0x00, 0x00, 0x83, 0x00, 0x00, 0x95,
-0x00, 0xd2, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74,
-0x69, 0x76, 0x65, 0x6c, 0x79, 0xf7, 0x02, 0x09, 0xd6, 0x01,
-0x11, 0x2c, 0x0e, 0x00, 0x21, 0x75, 0x70, 0x31, 0x01, 0x40,
-0x64, 0x6f, 0x77, 0x6e, 0xb1, 0x00, 0x30, 0x73, 0x6f, 0x72,
+0x63, 0x61, 0x6c, 0x6c, 0x79, 0x48, 0x00, 0x04, 0x00, 0x02,
+0x55, 0x65, 0x00, 0x6e, 0x65, 0x78, 0x60, 0x00, 0x41, 0x66,
+0x74, 0x65, 0x72, 0x3c, 0x00, 0x30, 0x69, 0x6e, 0x67, 0x95,
+0x00, 0xd3, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74,
+0x69, 0x76, 0x65, 0x6c, 0x79, 0xf7, 0x02, 0x08, 0xd6, 0x01,
+0x11, 0x2c, 0x0e, 0x00, 0x21, 0x75, 0x70, 0x31, 0x01, 0x10,
+0x64, 0x5a, 0x03, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
 0x21, 0x00, 0x14, 0x73, 0x1a, 0x02, 0x22, 0x75, 0x73, 0x6d,
 0x00, 0x20, 0x73, 0x65, 0x67, 0x02, 0x02, 0x29, 0x01, 0x03,
-0xe8, 0x01, 0x14, 0x2c, 0xd2, 0x01, 0x02, 0x73, 0x01, 0x10,
-0x72, 0x04, 0x01, 0x01, 0x3c, 0x00, 0x0c, 0x30, 0x00, 0x05,
-0x40, 0x01, 0x01, 0xe6, 0x02, 0x01, 0x36, 0x00, 0x90, 0x73,
+0xe8, 0x01, 0x15, 0x2c, 0xd2, 0x01, 0x01, 0x42, 0x00, 0x10,
+0x72, 0x04, 0x01, 0x02, 0x3c, 0x00, 0x0c, 0x30, 0x00, 0x04,
+0x40, 0x01, 0x02, 0xe6, 0x02, 0x00, 0x36, 0x00, 0x90, 0x73,
 0x70, 0x61, 0x63, 0x65, 0x00, 0x62, 0x61, 0x72, 0x5b, 0x02,
-0x41, 0x45, 0x6e, 0x74, 0x65, 0x76, 0x00, 0x31, 0x00, 0x74,
-0x6f, 0x0b, 0x04, 0x03, 0x91, 0x01, 0x03, 0xff, 0x04, 0x03,
-0x4c, 0x00, 0x23, 0x65, 0x64, 0x78, 0x00, 0x04, 0x5f, 0x01,
-0x02, 0x14, 0x05, 0x05, 0x5d, 0x00, 0x50, 0x2e, 0x00, 0x60,
-0x44, 0x27, 0x4f, 0x00, 0x41, 0x42, 0x61, 0x63, 0x6b, 0x60,
-0x00, 0x03, 0xde, 0x01, 0x12, 0x73, 0x4e, 0x00, 0x02, 0x7d,
-0x00, 0x10, 0x53, 0x19, 0x00, 0x03, 0x8c, 0x01, 0x08, 0x6e,
+0x41, 0x45, 0x6e, 0x74, 0x65, 0x76, 0x00, 0x00, 0x39, 0x00,
+0x01, 0x0b, 0x04, 0x03, 0x38, 0x00, 0x02, 0xff, 0x04, 0x03,
+0x4c, 0x00, 0x23, 0x65, 0x64, 0x78, 0x00, 0x05, 0x5f, 0x01,
+0x02, 0x14, 0x05, 0x04, 0x5d, 0x00, 0x50, 0x2e, 0x00, 0x60,
+0x44, 0x27, 0x4f, 0x00, 0x42, 0x42, 0x61, 0x63, 0x6b, 0x60,
+0x00, 0x02, 0xde, 0x01, 0x14, 0x73, 0xdf, 0x01, 0x00, 0x7d,
+0x00, 0x11, 0x53, 0x19, 0x00, 0x03, 0x8c, 0x01, 0x07, 0x6e,
 0x01, 0x00, 0x31, 0x01, 0x50, 0x50, 0x72, 0x65, 0x73, 0x73,
 0xc0, 0x01, 0x21, 0x60, 0x68, 0x49, 0x00, 0x32, 0x60, 0x3f,
-0x27, 0x84, 0x01, 0x4e, 0x66, 0x69, 0x6c, 0x6c, 0xd2, 0x01,
-0x01, 0x52, 0x01, 0x00, 0xea, 0x05, 0x82, 0x75, 0x67, 0x67,
-0x65, 0x73, 0x74, 0x65, 0x64, 0x17, 0x00, 0x30, 0x2e, 0x00,
-0x55, 0x45, 0x00, 0x01, 0x9f, 0x03, 0x00, 0xba, 0x04, 0xd0,
-0x6e, 0x6f, 0x74, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d,
-0x65, 0x6e, 0x64, 0xac, 0x02, 0x50, 0x6f, 0x72, 0x00, 0x31,
-0x30, 0x60, 0x00, 0x41, 0x6d, 0x6f, 0x72, 0x65, 0x01, 0x02,
-0x00, 0xb1, 0x04, 0x20, 0x69, 0x74, 0x2d, 0x00, 0x41, 0x73,
-0x6c, 0x6f, 0x77, 0x61, 0x03, 0x21, 0x68, 0x65, 0xe5, 0x00,
-0x03, 0x6a, 0x00, 0x21, 0x69, 0x73, 0xf4, 0x05, 0x52, 0x6c,
-0x65, 0x74, 0x65, 0x2c, 0x13, 0x01, 0xf0, 0x00, 0x6d, 0x61,
-0x6c, 0x6c, 0x65, 0x72, 0x00, 0x66, 0x65, 0x65, 0x64, 0x62,
-0x61, 0x63, 0x6b, 0x47, 0x00, 0x06, 0x31, 0x02, 0x50, 0x68,
-0x69, 0x67, 0x68, 0x6c, 0x8f, 0x01, 0x44, 0x65, 0x64, 0x3b,
-0x00, 0x96, 0x02, 0x03, 0x83, 0x03, 0x41, 0x73, 0x65, 0x00,
-0x28, 0x7c, 0x00, 0x12, 0x76, 0xa5, 0x00, 0x01, 0x82, 0x00,
-0x03, 0xfa, 0x01, 0x03, 0x56, 0x02, 0x16, 0x6d, 0x2c, 0x02,
-0x51, 0x61, 0x72, 0x72, 0x6f, 0x77, 0xd5, 0x01, 0x02, 0x57,
-0x03, 0x03, 0x22, 0x01, 0x0f, 0xc4, 0x01, 0x08, 0x11, 0x29,
-0x86, 0x00, 0x01, 0x56, 0x01, 0x0e, 0x33, 0x01, 0x12, 0x2c,
-0x89, 0x03, 0x72, 0x61, 0x6e, 0x79, 0x00, 0x68, 0x65, 0x6c,
-0x0a, 0x06, 0x0d, 0xcb, 0x02, 0x03, 0x27, 0x07, 0x00, 0xbb,
-0x01, 0x01, 0x19, 0x00, 0x19, 0x60, 0x43, 0x00, 0x17, 0x27,
-0xb1, 0x01, 0x66, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x64,
-0x06, 0x06, 0xa9, 0x03, 0x11, 0x61, 0xb1, 0x01, 0x02, 0x5e,
-0x01, 0x02, 0xad, 0x00, 0x30, 0x6f, 0x6c, 0x75, 0x1a, 0x00,
-0x05, 0x24, 0x01, 0x33, 0x64, 0x69, 0x73, 0xf6, 0x04, 0x82,
-0x62, 0x65, 0x6c, 0x6f, 0x77, 0x3b, 0x00, 0x69, 0x4d, 0x00,
-0x77, 0x72, 0x75, 0x6e, 0x00, 0x6f, 0x75, 0x74, 0x85, 0x05,
-0x00, 0x30, 0x01, 0x04, 0xd0, 0x02, 0xbe, 0x60, 0x53, 0x6f,
-0x6c, 0x76, 0x65, 0x2e, 0x2e, 0x2e, 0x27, 0x29, 0x57, 0x00,
-0x05, 0x97, 0x04, 0x71, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c,
-0x65, 0x1b, 0x04, 0x23, 0x28, 0x41, 0x8b, 0x00, 0x11, 0x61,
-0xa6, 0x05, 0xb0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72,
-0x69, 0x62, 0x65, 0x64, 0xc8, 0x02, 0x13, 0x73, 0xbc, 0x05,
-0x72, 0x32, 0x2e, 0x31, 0x00, 0x61, 0x72, 0x65, 0x42, 0x00,
-0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65,
-0x2e, 0x29, 0xc4, 0x05, 0x13, 0x32, 0xc4, 0x05, 0x50, 0x70,
-0x61, 0x72, 0x61, 0x6d, 0x27, 0x08, 0x02, 0xc6, 0x05, 0x01,
-0xcd, 0x01, 0x06, 0x14, 0x00, 0x00, 0x41, 0x00, 0x06, 0x3c,
-0x00, 0x06, 0x80, 0x05, 0x21, 0x60, 0x43, 0xa4, 0x06, 0x00,
-0xb5, 0x00, 0x30, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x04, 0x8e,
-0x05, 0xc0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0x2e, 0x4f, 0x00, 0x82, 0x00, 0x64, 0x65,
-0x66, 0x61, 0x75, 0x6c, 0x74, 0x1c, 0x06, 0x60, 0x6d, 0x61,
-0x74, 0x63, 0x68, 0x65, 0x3f, 0x01, 0x09, 0x66, 0x00, 0x12,
-0x66, 0x0d, 0x06, 0x0f, 0x60, 0x07, 0x05, 0x00, 0xf4, 0x00,
-0x13, 0x43, 0xf8, 0x06, 0x3b, 0x00, 0x00, 0x4e, 0x0c, 0x07,
-0x0b, 0x8d, 0x01, 0x23, 0x69, 0x73, 0xc6, 0x03, 0x01, 0xae,
-0x00, 0x12, 0x3b, 0xb4, 0x00, 0x12, 0x32, 0x2c, 0x07, 0x51,
-0x00, 0x28, 0x6d, 0x6f, 0x72, 0xfc, 0x07, 0x71, 0x68, 0x61,
-0x72, 0x64, 0x65, 0x72, 0x29, 0xa3, 0x03, 0x80, 0x65, 0x67,
-0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x9c, 0x01, 0x01, 0x61,
-0x00, 0x0d, 0x4f, 0x07, 0x02, 0xb7, 0x01, 0x0d, 0x3e, 0x00,
-0x05, 0x4b, 0x07, 0x11, 0x65, 0x37, 0x00, 0x0c, 0x6a, 0x07,
-0x00, 0xfc, 0x01, 0x05, 0x9a, 0x09, 0x4b, 0x66, 0x69, 0x6e,
-0x64, 0xa9, 0x00, 0x8b, 0x6e, 0x00, 0x28, 0x66, 0x65, 0x77,
-0x65, 0x72, 0x52, 0x00, 0x10, 0x41, 0x06, 0x08, 0x74, 0x20,
-0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x73, 0x0f, 0x00, 0x21, 0x73,
-0x00, 0x10, 0x00, 0x03, 0x7c, 0x02, 0x01, 0x11, 0x02, 0x80,
-0x67, 0x69, 0x76, 0x65, 0x6e, 0x00, 0x61, 0x73, 0x48, 0x01,
-0x01, 0x5b, 0x02, 0x15, 0x61, 0xa6, 0x00, 0x31, 0x61, 0x6b,
-0x65, 0xfd, 0x03, 0x40, 0x65, 0x61, 0x73, 0x69, 0x65, 0x08,
-0x70, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x90, 0x00,
-0x01, 0xf0, 0x08, 0x02, 0x1d, 0x06, 0x10, 0x74, 0x26, 0x01,
-0x02, 0x65, 0x02, 0x10, 0x6e, 0x8d, 0x08, 0x20, 0x00, 0x62,
-0x8d, 0x09, 0x57, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x57, 0x00,
-0x09, 0xb4, 0x00, 0x43, 0x29, 0x2e, 0x00, 0x54, 0x83, 0x04,
-0x61, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0xd7, 0x06, 0x24,
-0x62, 0x79, 0xe5, 0x01, 0x10, 0x2e, 0x07, 0x01, 0x31, 0x6f,
-0x74, 0x65, 0x61, 0x00, 0x02, 0xae, 0x04, 0x72, 0x64, 0x6f,
-0x65, 0x73, 0x6e, 0x27, 0x74, 0xdc, 0x08, 0x08, 0xc6, 0x00,
-0x29, 0x69, 0x6e, 0x5b, 0x00, 0x06, 0x2d, 0x03, 0x11, 0x65,
-0x93, 0x06, 0x20, 0x77, 0x61, 0x89, 0x00, 0x01, 0x49, 0x00,
-0x20, 0x2c, 0x00, 0xbd, 0x00, 0x84, 0x6f, 0x6e, 0x65, 0x00,
-0x65, 0x78, 0x74, 0x72, 0x13, 0x08, 0x06, 0x2b, 0x01, 0x95,
-0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2f,
-0x01, 0x0b, 0x13, 0x02, 0x13, 0x28, 0x23, 0x06, 0x04, 0x99,
-0x01, 0x12, 0x29, 0xbf, 0x07, 0x10, 0x6e, 0xde, 0x0a, 0x04,
-0x45, 0x02, 0x00, 0x3a, 0x05, 0x01, 0xb8, 0x00, 0x00, 0xca,
-0x02, 0x33, 0x63, 0x65, 0x3b, 0x6c, 0x05, 0x83, 0x6e, 0x63,
-0x72, 0x65, 0x61, 0x73, 0x65, 0x73, 0x35, 0x06, 0x42, 0x61,
-0x72, 0x63, 0x68, 0xa5, 0x04, 0x01, 0x67, 0x01, 0x03, 0x94,
-0x05, 0x24, 0x6e, 0x67, 0xc1, 0x01, 0x02, 0xb5, 0x0a, 0x08,
-0x20, 0x01, 0x14, 0x6e, 0x1f, 0x01, 0x50, 0x75, 0x6c, 0x74,
-0x2e, 0x00,
+0x27, 0x84, 0x01, 0x10, 0x66, 0x05, 0x00, 0x0e, 0xd2, 0x01,
+0x01, 0x52, 0x01, 0x80, 0x61, 0x00, 0x73, 0x75, 0x67, 0x67,
+0x65, 0x73, 0xa0, 0x00, 0x01, 0x17, 0x00, 0x31, 0x2e, 0x00,
+0x55, 0x45, 0x00, 0x01, 0x9f, 0x03, 0xf0, 0x01, 0x69, 0x73,
+0x00, 0x6e, 0x6f, 0x74, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x6d,
+0x6d, 0x65, 0x6e, 0x64, 0xac, 0x02, 0x20, 0x6f, 0x72, 0x5f,
+0x04, 0x72, 0x6f, 0x72, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x01,
+0x02, 0x20, 0x61, 0x73, 0x77, 0x02, 0x71, 0x69, 0x73, 0x00,
+0x73, 0x6c, 0x6f, 0x77, 0x61, 0x03, 0x22, 0x68, 0x65, 0xe5,
+0x00, 0x02, 0x6a, 0x00, 0x21, 0x69, 0x73, 0xf4, 0x05, 0x52,
+0x6c, 0x65, 0x74, 0x65, 0x2c, 0x13, 0x01, 0xf2, 0x00, 0x6d,
+0x61, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x66, 0x65, 0x65, 0x64,
+0x62, 0x61, 0x63, 0x6b, 0x47, 0x00, 0x04, 0x31, 0x02, 0x50,
+0x68, 0x69, 0x67, 0x68, 0x6c, 0x8f, 0x01, 0x45, 0x65, 0x64,
+0x3b, 0x00, 0x96, 0x02, 0x02, 0x83, 0x03, 0x41, 0x73, 0x65,
+0x00, 0x28, 0x7c, 0x00, 0x12, 0x76, 0xa5, 0x00, 0x01, 0x82,
+0x00, 0x04, 0xfa, 0x01, 0x02, 0x56, 0x02, 0x16, 0x6d, 0x2c,
+0x02, 0x52, 0x61, 0x72, 0x72, 0x6f, 0x77, 0xd5, 0x01, 0x01,
+0x57, 0x03, 0x04, 0x22, 0x01, 0x0f, 0xc4, 0x01, 0x07, 0x12,
+0x29, 0x86, 0x00, 0x00, 0x56, 0x01, 0x0e, 0x33, 0x01, 0x12,
+0x2c, 0x89, 0x03, 0x73, 0x61, 0x6e, 0x79, 0x00, 0x68, 0x65,
+0x6c, 0x0a, 0x06, 0x0d, 0xcb, 0x02, 0x02, 0xaa, 0x01, 0x01,
+0x99, 0x03, 0x00, 0x19, 0x00, 0x19, 0x60, 0x43, 0x00, 0x17,
+0x27, 0xb1, 0x01, 0x66, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75,
+0x64, 0x06, 0x06, 0xa9, 0x03, 0x13, 0x61, 0xb1, 0x01, 0x03,
+0x5f, 0x03, 0x61, 0x65, 0x00, 0x73, 0x6f, 0x6c, 0x75, 0x1a,
+0x00, 0x04, 0x24, 0x01, 0x33, 0x64, 0x69, 0x73, 0xf6, 0x04,
+0x82, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x3b, 0x00, 0x69, 0x4d,
+0x00, 0x77, 0x72, 0x75, 0x6e, 0x00, 0x6f, 0x75, 0x74, 0x85,
+0x05, 0x01, 0x30, 0x01, 0x03, 0xd0, 0x02, 0xbe, 0x60, 0x53,
+0x6f, 0x6c, 0x76, 0x65, 0x2e, 0x2e, 0x2e, 0x27, 0x29, 0x57,
+0x00, 0x05, 0x97, 0x04, 0x71, 0x72, 0x65, 0x76, 0x65, 0x61,
+0x6c, 0x65, 0x1b, 0x04, 0x23, 0x28, 0x41, 0x8b, 0x00, 0x11,
+0x61, 0xa6, 0x05, 0xb0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63,
+0x72, 0x69, 0x62, 0x65, 0x64, 0xc8, 0x02, 0x13, 0x73, 0xbc,
+0x05, 0x72, 0x32, 0x2e, 0x31, 0x00, 0x61, 0x72, 0x65, 0x42,
+0x00, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c,
+0x65, 0x2e, 0x29, 0xc4, 0x05, 0x13, 0x32, 0xc4, 0x05, 0x50,
+0x70, 0x61, 0x72, 0x61, 0x6d, 0x27, 0x08, 0x03, 0xc6, 0x05,
+0x00, 0xcd, 0x01, 0x06, 0x14, 0x00, 0x02, 0x41, 0x00, 0x04,
+0x3c, 0x00, 0x06, 0x80, 0x05, 0x21, 0x60, 0x43, 0xa4, 0x06,
+0x00, 0xb5, 0x00, 0x31, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x03,
+0x8e, 0x05, 0xc0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0x2e, 0x4f, 0x00, 0x82, 0x00, 0x64,
+0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x1c, 0x06, 0x62, 0x6d,
+0x61, 0x74, 0x63, 0x68, 0x65, 0x3f, 0x01, 0x07, 0x66, 0x00,
+0x13, 0x66, 0x0d, 0x06, 0x0f, 0x60, 0x07, 0x04, 0x00, 0xf4,
+0x00, 0x13, 0x43, 0xf8, 0x06, 0x3d, 0x00, 0x00, 0x4e, 0x0c,
+0x07, 0x09, 0x36, 0x01, 0x24, 0x69, 0x73, 0xc6, 0x03, 0x00,
+0xae, 0x00, 0x12, 0x3b, 0xb4, 0x00, 0x12, 0x32, 0x2c, 0x07,
+0x21, 0x00, 0x28, 0x20, 0x03, 0xa1, 0x69, 0x73, 0x00, 0x68,
+0x61, 0x72, 0x64, 0x65, 0x72, 0x29, 0xa3, 0x03, 0x82, 0x65,
+0x67, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x18, 0x03, 0x08,
+0x61, 0x00, 0x05, 0x4f, 0x07, 0x02, 0x1b, 0x00, 0x0e, 0x3e,
+0x00, 0x03, 0x4b, 0x07, 0x1a, 0x65, 0x37, 0x00, 0x04, 0xe5,
+0x01, 0x00, 0xfc, 0x01, 0x04, 0x9a, 0x09, 0x4b, 0x66, 0x69,
+0x6e, 0x64, 0xa9, 0x00, 0x8b, 0x6e, 0x00, 0x28, 0x66, 0x65,
+0x77, 0x65, 0x72, 0x52, 0x00, 0x10, 0x41, 0x06, 0x08, 0x74,
+0x20, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x73, 0x0f, 0x00, 0x21,
+0x73, 0x00, 0x10, 0x00, 0x05, 0xdd, 0x02, 0x80, 0x62, 0x65,
+0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0xe6, 0x03, 0x31, 0x70,
+0x61, 0x72, 0x5b, 0x02, 0x15, 0x61, 0xa6, 0x00, 0x31, 0x61,
+0x6b, 0x65, 0xfd, 0x03, 0x40, 0x65, 0x61, 0x73, 0x69, 0x65,
+0x08, 0x71, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x90,
+0x00, 0x00, 0xf0, 0x08, 0x02, 0x1d, 0x06, 0x10, 0x74, 0x26,
+0x01, 0x02, 0x65, 0x02, 0x10, 0x6e, 0x8d, 0x08, 0x20, 0x00,
+0x62, 0x8d, 0x09, 0x20, 0x75, 0x6e, 0x76, 0x04, 0x07, 0x57,
+0x00, 0x08, 0xb4, 0x00, 0x10, 0x29, 0xd3, 0x01, 0x02, 0x83,
+0x04, 0x30, 0x74, 0x75, 0x72, 0x57, 0x0a, 0x00, 0xd7, 0x06,
+0x24, 0x62, 0x79, 0xe5, 0x01, 0x10, 0x2e, 0x07, 0x01, 0x34,
+0x6f, 0x74, 0x65, 0x61, 0x00, 0xa2, 0x69, 0x73, 0x00, 0x64,
+0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0xdc, 0x08, 0x08, 0xc6,
+0x00, 0x29, 0x69, 0x6e, 0x5b, 0x00, 0x06, 0x2d, 0x03, 0x11,
+0x65, 0x93, 0x06, 0x21, 0x77, 0x61, 0x89, 0x00, 0x00, 0x49,
+0x00, 0x20, 0x2c, 0x00, 0xbd, 0x00, 0x84, 0x6f, 0x6e, 0x65,
+0x00, 0x65, 0x78, 0x74, 0x72, 0x13, 0x08, 0x06, 0x2b, 0x01,
+0x97, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65,
+0x2f, 0x01, 0x09, 0x6a, 0x01, 0x14, 0x28, 0x23, 0x06, 0x03,
+0x99, 0x01, 0x12, 0x29, 0xbf, 0x07, 0x11, 0x6e, 0xde, 0x0a,
+0x04, 0x45, 0x02, 0x01, 0xdc, 0x01, 0x30, 0x74, 0x68, 0x61,
+0xca, 0x02, 0x33, 0x63, 0x65, 0x3b, 0x6c, 0x05, 0x51, 0x6e,
+0x63, 0x72, 0x65, 0x61, 0xf1, 0x07, 0x01, 0x35, 0x06, 0x43,
+0x61, 0x72, 0x63, 0x68, 0xa5, 0x04, 0x00, 0x67, 0x01, 0x03,
+0x94, 0x05, 0x25, 0x6e, 0x67, 0xc1, 0x01, 0x02, 0x68, 0x04,
+0x07, 0x20, 0x01, 0x14, 0x6e, 0x1f, 0x01, 0x50, 0x75, 0x6c,
+0x74, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3042;
diff --git a/apps/plugins/puzzles/help/inertia.c b/apps/plugins/puzzles/help/inertia.c
index b537fbf5d0..8d7902dc54 100644
--- a/apps/plugins/puzzles/help/inertia.c
+++ b/apps/plugins/puzzles/help/inertia.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2266 comp 1565 ratio 0.690644 level 11 saved 701 */
+/* orig 2266 comp 1565 ratio 0.690644 level 10 saved 701 */
 const char help_text[] = {
 0xf0, 0x1f, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x34, 0x3a, 0x20, 0x49, 0x6e, 0x65, 0x72, 0x74, 0x69,
@@ -30,10 +30,10 @@ const char help_text[] = {
 0x00, 0x74, 0x6f, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
 0x74, 0x00, 0x40, 0x00, 0xf2, 0x06, 0x74, 0x68, 0x65, 0x00,
 0x67, 0x65, 0x6d, 0x73, 0x00, 0x77, 0x69, 0x74, 0x68, 0x6f,
-0x75, 0x74, 0x00, 0x72, 0x75, 0x6e, 0x6e, 0x51, 0x00, 0xd3,
+0x75, 0x74, 0x00, 0x72, 0x75, 0x6e, 0x6e, 0x51, 0x00, 0xa0,
 0x74, 0x6f, 0x00, 0x61, 0x6e, 0x79, 0x00, 0x6d, 0x69, 0x6e,
-0x65, 0x73, 0x2e, 0x86, 0x00, 0x80, 0x63, 0x61, 0x6e, 0x00,
-0x6d, 0x6f, 0x76, 0x65, 0x38, 0x00, 0x02, 0x81, 0x00, 0x21,
+0x44, 0x00, 0x02, 0x86, 0x00, 0x81, 0x63, 0x61, 0x6e, 0x00,
+0x6d, 0x6f, 0x76, 0x65, 0x38, 0x00, 0x01, 0x81, 0x00, 0x21,
 0x69, 0x6e, 0x26, 0x00, 0xf2, 0x02, 0x6f, 0x72, 0x74, 0x68,
 0x6f, 0x67, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x6f, 0x72, 0x20,
 0x64, 0x69, 0x61, 0x0c, 0x00, 0xe7, 0x64, 0x69, 0x72, 0x65,
@@ -45,134 +45,134 @@ const char help_text[] = {
 0x00, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x8f, 0x00, 0xf4,
 0x00, 0x73, 0x74, 0x6f, 0x70, 0x73, 0x00, 0x69, 0x74, 0x2e,
 0x00, 0x41, 0x00, 0x77, 0x61, 0x6c, 0x5a, 0x00, 0x20, 0x6c,
-0x79, 0x81, 0x00, 0x81, 0x69, 0x74, 0x73, 0x00, 0x70, 0x61,
-0x74, 0x68, 0x44, 0x00, 0x01, 0x2b, 0x00, 0x00, 0x51, 0x00,
+0x79, 0x81, 0x00, 0x82, 0x69, 0x74, 0x73, 0x00, 0x70, 0x61,
+0x74, 0x68, 0x44, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x51, 0x00,
 0x70, 0x28, 0x62, 0x75, 0x74, 0x00, 0x69, 0x66, 0x0b, 0x00,
-0x14, 0x69, 0x6a, 0x00, 0x14, 0x00, 0x9a, 0x00, 0x25, 0x6c,
-0x79, 0x75, 0x00, 0x04, 0xd1, 0x00, 0x85, 0x72, 0x6f, 0x75,
+0x14, 0x69, 0x6a, 0x00, 0x14, 0x00, 0x9a, 0x00, 0x26, 0x6c,
+0x79, 0x75, 0x00, 0x03, 0xd1, 0x00, 0x85, 0x72, 0x6f, 0x75,
 0x67, 0x68, 0x00, 0x61, 0x00, 0xbd, 0x00, 0x80, 0x67, 0x61,
 0x70, 0x00, 0x62, 0x65, 0x74, 0x77, 0x6d, 0x01, 0x91, 0x74,
 0x77, 0x6f, 0x00, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x7e, 0x00,
-0x05, 0x2f, 0x01, 0x01, 0x6d, 0x00, 0xc1, 0x70, 0x69, 0x6e,
+0x06, 0x2f, 0x01, 0x00, 0x6d, 0x00, 0xc1, 0x70, 0x69, 0x6e,
 0x67, 0x29, 0x2e, 0x00, 0x41, 0x6c, 0x73, 0x6f, 0x2c, 0xb3,
-0x00, 0x31, 0x00, 0x6f, 0x66, 0xea, 0x00, 0x71, 0x73, 0x71,
+0x00, 0x00, 0x7f, 0x01, 0x00, 0xea, 0x00, 0x71, 0x73, 0x71,
 0x75, 0x61, 0x72, 0x65, 0x73, 0xbc, 0x01, 0x11, 0x60, 0xc2,
-0x00, 0x73, 0x27, 0x3b, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x08,
-0x01, 0x03, 0x7c, 0x00, 0x50, 0x73, 0x00, 0x6f, 0x6e, 0x00,
-0x6e, 0x01, 0x01, 0x4e, 0x00, 0x00, 0x98, 0x00, 0x06, 0xc9,
-0x00, 0x04, 0xb8, 0x00, 0x70, 0x6e, 0x6f, 0x00, 0x6d, 0x61,
+0x00, 0x76, 0x27, 0x3b, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x08,
+0x01, 0x00, 0x7c, 0x00, 0x50, 0x73, 0x00, 0x6f, 0x6e, 0x00,
+0x6e, 0x01, 0x01, 0x4e, 0x00, 0x06, 0x98, 0x00, 0x01, 0xc9,
+0x00, 0x03, 0xb8, 0x00, 0x70, 0x6e, 0x6f, 0x00, 0x6d, 0x61,
 0x74, 0x74, 0x80, 0x00, 0x36, 0x68, 0x61, 0x74, 0x58, 0x01,
 0x01, 0x2d, 0x00, 0x52, 0x61, 0x73, 0x00, 0x67, 0x6f, 0xb5,
 0x01, 0x30, 0x2e, 0x00, 0x47, 0xce, 0x01, 0x52, 0x64, 0x6f,
 0x00, 0x6e, 0x6f, 0x9e, 0x00, 0x05, 0x6c, 0x00, 0x10, 0x3b,
 0x2c, 0x00, 0x50, 0x70, 0x69, 0x63, 0x6b, 0x73, 0x13, 0x00,
-0xd0, 0x6d, 0x00, 0x75, 0x70, 0x00, 0x61, 0x6e, 0x64, 0x00,
-0x6b, 0x65, 0x65, 0x70, 0x82, 0x00, 0x02, 0x43, 0x00, 0x00,
+0xd1, 0x6d, 0x00, 0x75, 0x70, 0x00, 0x61, 0x6e, 0x64, 0x00,
+0x6b, 0x65, 0x65, 0x70, 0x82, 0x00, 0x01, 0x43, 0x00, 0x00,
 0xe9, 0x01, 0x19, 0x52, 0x03, 0x02, 0x01, 0x01, 0x02, 0x00,
 0x42, 0x01, 0xb0, 0x66, 0x61, 0x74, 0x61, 0x6c, 0x2e, 0x00,
 0x45, 0x76, 0x65, 0x6e, 0x57, 0x01, 0x31, 0x79, 0x6f, 0x75,
 0x4e, 0x00, 0x42, 0x65, 0x64, 0x00, 0x75, 0x65, 0x00, 0x40,
-0x6c, 0x61, 0x73, 0x74, 0x4d, 0x02, 0x32, 0x00, 0x69, 0x6e,
+0x6c, 0x61, 0x73, 0x74, 0x4d, 0x02, 0x00, 0x93, 0x01, 0x01,
 0xff, 0x00, 0x32, 0x61, 0x6d, 0x65, 0x5d, 0x01, 0x70, 0x77,
 0x68, 0x69, 0x63, 0x68, 0x00, 0x74, 0xfa, 0x00, 0x33, 0x68,
-0x69, 0x74, 0x54, 0x00, 0x12, 0x2c, 0x7d, 0x02, 0x34, 0x61,
-0x6d, 0x65, 0xfc, 0x01, 0x31, 0x75, 0x6e, 0x74, 0x57, 0x00,
+0x69, 0x74, 0x54, 0x00, 0x12, 0x2c, 0x7d, 0x02, 0x00, 0x25,
+0x00, 0x03, 0xfc, 0x01, 0x31, 0x75, 0x6e, 0x74, 0x57, 0x00,
 0xa1, 0x61, 0x73, 0x00, 0x64, 0x65, 0x61, 0x64, 0x00, 0x72,
 0x61, 0x72, 0x01, 0xe1, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x76,
 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x6f, 0x75, 0x8c, 0x02,
-0x41, 0x54, 0x68, 0x69, 0x73, 0x3b, 0x00, 0x01, 0xfd, 0x00,
-0x51, 0x6f, 0x72, 0x69, 0x67, 0x69, 0xd5, 0x01, 0xf0, 0x16,
+0x43, 0x54, 0x68, 0x69, 0x73, 0x3b, 0x00, 0x81, 0x61, 0x73,
+0x00, 0x6f, 0x72, 0x69, 0x67, 0x69, 0xd5, 0x01, 0xf0, 0x16,
 0x00, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
 0x65, 0x64, 0x00, 0x66, 0x6f, 0x72, 0x00, 0x57, 0x69, 0x6e,
 0x64, 0x6f, 0x77, 0x73, 0x00, 0x62, 0x79, 0x00, 0x42, 0x65,
 0x6e, 0x00, 0x4f, 0x6c, 0x6d, 0x73, 0x74, 0x5b, 0x00, 0x91,
 0x5b, 0x31, 0x31, 0x5d, 0x2c, 0x00, 0x77, 0x68, 0x6f, 0x41,
-0x00, 0x70, 0x6b, 0x69, 0x6e, 0x64, 0x00, 0x65, 0x6e, 0x01,
-0x02, 0x00, 0x89, 0x01, 0x80, 0x72, 0x65, 0x6c, 0x65, 0x61,
+0x00, 0x71, 0x6b, 0x69, 0x6e, 0x64, 0x00, 0x65, 0x6e, 0x01,
+0x02, 0xb0, 0x74, 0x6f, 0x00, 0x72, 0x65, 0x6c, 0x65, 0x61,
 0x73, 0x65, 0x00, 0x65, 0x00, 0xb0, 0x73, 0x6f, 0x75, 0x72,
-0x63, 0x65, 0x00, 0x63, 0x6f, 0x64, 0x65, 0x25, 0x01, 0xc0,
+0x63, 0x65, 0x00, 0x63, 0x6f, 0x64, 0x65, 0x25, 0x01, 0xa0,
 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x00, 0x73, 0x6f,
-0x00, 0x74, 0x89, 0x01, 0x20, 0x69, 0x74, 0xb8, 0x00, 0x9c,
+0x97, 0x00, 0x10, 0x74, 0x53, 0x01, 0xcc, 0x63, 0x6f, 0x75,
 0x6c, 0x64, 0x00, 0x62, 0x65, 0x00, 0x72, 0x65, 0x2d, 0x7f,
-0x00, 0x41, 0x74, 0x68, 0x69, 0x73, 0x70, 0x03, 0x04, 0x06,
+0x00, 0x10, 0x74, 0x43, 0x00, 0x03, 0x70, 0x03, 0x01, 0x06,
 0x03, 0x11, 0x00, 0x7a, 0x00, 0xf5, 0x09, 0x00, 0x68, 0x74,
 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x78, 0x6e, 0x31, 0x33, 0x2e,
 0x63, 0x6f, 0x6d, 0x2f, 0x00, 0x00, 0x00, 0x32, 0x34, 0x2e,
 0x31, 0xf5, 0x03, 0x00, 0x08, 0x03, 0x5f, 0x72, 0x6f, 0x6c,
-0x73, 0x20, 0x78, 0x03, 0x0c, 0x04, 0x6a, 0x02, 0x47, 0x65,
-0x69, 0x67, 0x68, 0x16, 0x02, 0x71, 0x73, 0x00, 0x75, 0x73,
-0x69, 0x6e, 0x67, 0x1b, 0x00, 0xe0, 0x6e, 0x75, 0x6d, 0x65,
+0x73, 0x20, 0x78, 0x03, 0x0e, 0x02, 0x6a, 0x02, 0x47, 0x65,
+0x69, 0x67, 0x68, 0x16, 0x02, 0x40, 0x73, 0x00, 0x75, 0x73,
+0xc2, 0x01, 0x00, 0x1b, 0x00, 0xe0, 0x6e, 0x75, 0x6d, 0x65,
 0x72, 0x69, 0x63, 0x00, 0x6b, 0x65, 0x79, 0x70, 0x61, 0x64,
-0xa7, 0x02, 0xc4, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
-0x76, 0x65, 0x6c, 0x79, 0x2c, 0xca, 0x01, 0x52, 0x63, 0x6c,
-0x69, 0x63, 0x6b, 0xc6, 0x01, 0xf1, 0x03, 0x65, 0x66, 0x74,
+0xa7, 0x02, 0x91, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
+0x76, 0x65, 0x05, 0x03, 0x02, 0xca, 0x01, 0x52, 0x63, 0x6c,
+0x69, 0x63, 0x6b, 0xc6, 0x01, 0xf2, 0x03, 0x65, 0x66, 0x74,
 0x00, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x62, 0x75, 0x74,
-0x74, 0x6f, 0x6e, 0x00, 0x6f, 0xcf, 0x01, 0x01, 0x5e, 0x04,
-0x15, 0x2c, 0x81, 0x00, 0x02, 0xb4, 0x01, 0x30, 0x62, 0x65,
-0x67, 0x89, 0x00, 0x02, 0x9c, 0x00, 0x23, 0x69, 0x6e, 0x4f,
-0x04, 0x38, 0x6e, 0x65, 0x72, 0xfc, 0x03, 0x30, 0x00, 0x6f,
-0x66, 0xf6, 0x02, 0x26, 0x72, 0x65, 0x6a, 0x00, 0x20, 0x65,
+0x74, 0x6f, 0x6e, 0x00, 0x6f, 0xcf, 0x01, 0x00, 0x5e, 0x04,
+0x16, 0x2c, 0x81, 0x00, 0x01, 0xb4, 0x01, 0x31, 0x62, 0x65,
+0x67, 0x7a, 0x04, 0x01, 0x9c, 0x00, 0x23, 0x69, 0x6e, 0x4f,
+0x04, 0x38, 0x6e, 0x65, 0x72, 0xfc, 0x03, 0x00, 0xa5, 0x00,
+0x56, 0x77, 0x68, 0x65, 0x72, 0x65, 0x6a, 0x00, 0x20, 0x65,
 0x64, 0x0b, 0x01, 0x12, 0x49, 0x7c, 0x00, 0x22, 0x75, 0x73,
-0xd8, 0x00, 0xe3, 0x60, 0x53, 0x6f, 0x6c, 0x76, 0x65, 0x27,
-0x00, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x79, 0x00, 0x03,
-0xe9, 0x01, 0x03, 0x2e, 0x02, 0x74, 0x70, 0x72, 0x6f, 0x67,
-0x72, 0x61, 0x6d, 0x31, 0x02, 0x71, 0x6d, 0x70, 0x75, 0x74,
-0x65, 0x00, 0x61, 0xfd, 0x03, 0x04, 0xc2, 0x03, 0x05, 0xac,
-0x00, 0x02, 0x76, 0x02, 0x04, 0x7e, 0x01, 0x15, 0x73, 0xef,
-0x04, 0x50, 0x72, 0x65, 0x6d, 0x61, 0x69, 0xe1, 0x02, 0x01,
-0xf9, 0x04, 0x01, 0x04, 0x03, 0x60, 0x72, 0x65, 0x74, 0x75,
-0x72, 0x6e, 0x1d, 0x05, 0x01, 0x22, 0x00, 0xc2, 0x63, 0x75,
+0xd8, 0x00, 0xb3, 0x60, 0x53, 0x6f, 0x6c, 0x76, 0x65, 0x27,
+0x00, 0x66, 0x75, 0x6e, 0x38, 0x00, 0x00, 0x51, 0x00, 0x03,
+0xe9, 0x01, 0x02, 0x7a, 0x00, 0x74, 0x70, 0x72, 0x6f, 0x67,
+0x72, 0x61, 0x6d, 0x31, 0x02, 0x40, 0x6d, 0x70, 0x75, 0x74,
+0x17, 0x05, 0x01, 0xfd, 0x03, 0x04, 0xc2, 0x03, 0x04, 0xac,
+0x00, 0x03, 0x76, 0x02, 0x03, 0x7e, 0x01, 0x15, 0x73, 0xef,
+0x04, 0x51, 0x72, 0x65, 0x6d, 0x61, 0x69, 0xe1, 0x02, 0x01,
+0xf9, 0x04, 0x00, 0x04, 0x03, 0x61, 0x72, 0x65, 0x74, 0x75,
+0x72, 0x6e, 0x1d, 0x05, 0x00, 0x22, 0x00, 0xc2, 0x63, 0x75,
 0x72, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x70, 0x6f, 0x73, 0x69,
 0xb7, 0x01, 0xc2, 0x41, 0x00, 0x68, 0x69, 0x6e, 0x74, 0x00,
-0x61, 0x72, 0x72, 0x6f, 0x77, 0x7d, 0x00, 0x98, 0x61, 0x70,
-0x70, 0x65, 0x61, 0x72, 0x00, 0x6f, 0x6e, 0x93, 0x01, 0x53,
-0x64, 0x69, 0x63, 0x61, 0x74, 0x79, 0x01, 0x08, 0xa4, 0x03,
-0x12, 0x6e, 0x8c, 0x00, 0x01, 0xee, 0x00, 0x20, 0x73, 0x68,
-0x30, 0x02, 0x03, 0xce, 0x01, 0x11, 0x6f, 0x42, 0x01, 0x04,
-0xea, 0x00, 0x02, 0xc6, 0x04, 0x13, 0x2e, 0x18, 0x01, 0x01,
-0x30, 0x03, 0x06, 0x5a, 0x01, 0x09, 0xf7, 0x03, 0x01, 0x0e,
-0x01, 0x08, 0x8f, 0x00, 0x50, 0x75, 0x70, 0x64, 0x61, 0x74,
-0x51, 0x00, 0x04, 0x86, 0x00, 0x12, 0x65, 0xfd, 0x01, 0x25,
-0x65, 0x78, 0x36, 0x00, 0x05, 0xca, 0x01, 0x02, 0x66, 0x00,
-0x05, 0x58, 0x02, 0xf1, 0x01, 0x61, 0x6c, 0x73, 0x6f, 0x00,
+0x61, 0x72, 0x72, 0x6f, 0x77, 0x7d, 0x00, 0x64, 0x61, 0x70,
+0x70, 0x65, 0x61, 0x72, 0x1c, 0x01, 0x03, 0x93, 0x01, 0x54,
+0x64, 0x69, 0x63, 0x61, 0x74, 0x79, 0x01, 0x07, 0xa4, 0x03,
+0x13, 0x6e, 0x8c, 0x00, 0x00, 0xee, 0x00, 0x21, 0x73, 0x68,
+0x30, 0x02, 0x02, 0xce, 0x01, 0x13, 0x6f, 0x42, 0x01, 0x04,
+0xea, 0x00, 0x00, 0xc9, 0x00, 0x14, 0x2e, 0x18, 0x01, 0x01,
+0x30, 0x03, 0x06, 0x5a, 0x01, 0x08, 0xf7, 0x03, 0x02, 0x0e,
+0x01, 0x07, 0x8f, 0x00, 0x51, 0x75, 0x70, 0x64, 0x61, 0x74,
+0x51, 0x00, 0x03, 0x86, 0x00, 0x12, 0x65, 0xfd, 0x01, 0x28,
+0x65, 0x78, 0x2d, 0x04, 0x03, 0xae, 0x00, 0x02, 0x66, 0x00,
+0x04, 0x58, 0x02, 0xf1, 0x01, 0x61, 0x6c, 0x73, 0x6f, 0x00,
 0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x61, 0x63,
-0x65, 0x8b, 0x04, 0x80, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74,
-0x69, 0x63, 0x55, 0x03, 0x04, 0x84, 0x00, 0x0a, 0xd6, 0x00,
-0x03, 0x7b, 0x02, 0x07, 0x19, 0x01, 0x04, 0xb9, 0x00, 0x04,
-0x30, 0x00, 0x01, 0x4c, 0x05, 0x68, 0x66, 0x66, 0x65, 0x72,
-0x65, 0x6e, 0x85, 0x00, 0x41, 0x66, 0x72, 0x6f, 0x6d, 0x3a,
-0x00, 0x30, 0x6f, 0x6e, 0x65, 0x0e, 0x01, 0x56, 0x77, 0x6e,
-0x00, 0x62, 0x79, 0xd0, 0x00, 0x12, 0x2c, 0x07, 0x00, 0x13,
-0x73, 0x61, 0x02, 0x04, 0x23, 0x00, 0x20, 0x6f, 0x6e, 0xde,
+0x65, 0x8b, 0x04, 0x81, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74,
+0x69, 0x63, 0x55, 0x03, 0x08, 0xde, 0x01, 0x09, 0xd6, 0x01,
+0x00, 0x11, 0x00, 0x06, 0x19, 0x01, 0x05, 0xb9, 0x00, 0x04,
+0x30, 0x00, 0x00, 0x4c, 0x05, 0x31, 0x66, 0x66, 0x65, 0x4c,
+0x01, 0x06, 0x38, 0x00, 0x41, 0x66, 0x72, 0x6f, 0x6d, 0x3a,
+0x00, 0x30, 0x6f, 0x6e, 0x65, 0x0e, 0x01, 0x20, 0x77, 0x6e,
+0x9e, 0x03, 0x05, 0xd0, 0x00, 0x12, 0x2c, 0x07, 0x00, 0x14,
+0x73, 0x61, 0x02, 0x03, 0x23, 0x00, 0x20, 0x6f, 0x6e, 0xde,
 0x03, 0x12, 0x66, 0xc0, 0x00, 0x41, 0x75, 0x7a, 0x7a, 0x6c,
 0x94, 0x04, 0x21, 0x73, 0x74, 0x29, 0x05, 0x70, 0x6f, 0x6c,
 0x76, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x02, 0x13, 0x41, 0xe6,
 0x01, 0x13, 0x61, 0x09, 0x03, 0x90, 0x64, 0x65, 0x73, 0x63,
 0x72, 0x69, 0x62, 0x65, 0x64, 0x91, 0x00, 0x13, 0x73, 0x83,
-0x00, 0x30, 0x32, 0x2e, 0x31, 0x95, 0x05, 0x02, 0xfb, 0x00,
+0x00, 0x32, 0x32, 0x2e, 0x31, 0x51, 0x07, 0x00, 0xfb, 0x00,
 0x52, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x3f, 0x00, 0xd5, 0x49,
 0x6e, 0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c,
-0x61, 0x72, 0x1c, 0x03, 0x20, 0x64, 0x6f, 0x16, 0x07, 0x08,
-0x0f, 0x05, 0x01, 0x35, 0x02, 0x62, 0x64, 0x69, 0x65, 0x2c,
-0x00, 0x79, 0x45, 0x01, 0x05, 0xc4, 0x02, 0x45, 0x55, 0x6e,
-0x64, 0x6f, 0xc1, 0x02, 0x03, 0x5c, 0x02, 0xc2, 0x73, 0x75,
-0x6d, 0x65, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67,
-0xfe, 0x00, 0x51, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x31, 0x00,
-0x01, 0x56, 0x05, 0x02, 0x07, 0x06, 0x38, 0x2e, 0x00, 0x54,
-0x10, 0x05, 0x01, 0x99, 0x05, 0x94, 0x00, 0x74, 0x72, 0x61,
-0x63, 0x6b, 0x00, 0x6f, 0x66, 0xcb, 0x03, 0x31, 0x62, 0x65,
+0x61, 0x72, 0x1c, 0x03, 0x20, 0x64, 0x6f, 0x16, 0x07, 0x09,
+0x0f, 0x05, 0x00, 0x35, 0x02, 0x63, 0x64, 0x69, 0x65, 0x2c,
+0x00, 0x79, 0x45, 0x01, 0x04, 0xc4, 0x02, 0x46, 0x55, 0x6e,
+0x64, 0x6f, 0xc1, 0x02, 0x02, 0x5c, 0x02, 0x90, 0x73, 0x75,
+0x6d, 0x65, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x1a, 0x02, 0x01,
+0xfe, 0x00, 0x52, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x31, 0x00,
+0x01, 0x56, 0x05, 0x01, 0x32, 0x01, 0x39, 0x2e, 0x00, 0x54,
+0x10, 0x05, 0x00, 0x99, 0x05, 0x64, 0x00, 0x74, 0x72, 0x61,
+0x63, 0x6b, 0x6b, 0x01, 0x61, 0x6e, 0x75, 0x6d, 0x62, 0x65,
 0x72, 0x0e, 0x00, 0x41, 0x69, 0x6d, 0x65, 0x73, 0x7d, 0x00,
-0x91, 0x68, 0x61, 0x76, 0x65, 0x00, 0x64, 0x6f, 0x6e, 0x65,
+0x60, 0x68, 0x61, 0x76, 0x65, 0x00, 0x64, 0x4b, 0x01, 0x00,
 0x41, 0x02, 0x12, 0x2e, 0x49, 0x04, 0x15, 0x32, 0x49, 0x04,
-0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
-0x4b, 0x04, 0x00, 0x61, 0x00, 0x35, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x01, 0x9a, 0x06, 0x06, 0x00, 0x01, 0x06, 0x9a, 0x01,
+0xb1, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+0x73, 0x20, 0x37, 0x05, 0x46, 0x65, 0x73, 0x65, 0x00, 0x14,
+0x00, 0x02, 0x05, 0x01, 0x04, 0x00, 0x01, 0x06, 0x9a, 0x01,
 0xe8, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x3b, 0x02, 0xb0, 0x60, 0x54,
 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0x6c,
 0x00, 0x82, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48,
-0x80, 0x04, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0xfe, 0x06,
-0x00, 0x80, 0x03, 0x02, 0x71, 0x01, 0x80, 0x71, 0x75, 0x61,
+0x80, 0x04, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0xfe, 0x06,
+0x01, 0x80, 0x03, 0x00, 0x71, 0x01, 0x80, 0x71, 0x75, 0x61,
 0x72, 0x65, 0x73, 0x2e, 0x00,
 };
 
diff --git a/apps/plugins/puzzles/help/keen.c b/apps/plugins/puzzles/help/keen.c
index 5628338343..8f0374dcdd 100644
--- a/apps/plugins/puzzles/help/keen.c
+++ b/apps/plugins/puzzles/help/keen.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,18 +15,18 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3952 comp 2375 ratio 0.600962 level 11 saved 1577 */
+/* orig 3952 comp 2376 ratio 0.601215 level 10 saved 1576 */
 const char help_text[] = {
 0xf4, 0x21, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x30, 0x3a, 0x20, 0x4b, 0x65, 0x65, 0x6e, 0x20, 0x00,
 0x00, 0x00, 0x59, 0x6f, 0x75, 0x00, 0x68, 0x61, 0x76, 0x65,
 0x00, 0x61, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x00,
 0x67, 0x72, 0x69, 0x64, 0x3b, 0x00, 0x65, 0x61, 0x63, 0x68,
-0x12, 0x00, 0xf2, 0x1d, 0x6d, 0x61, 0x79, 0x00, 0x63, 0x6f,
+0x12, 0x00, 0xf1, 0x1a, 0x6d, 0x61, 0x79, 0x00, 0x63, 0x6f,
 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x61, 0x00, 0x64, 0x69,
 0x67, 0x69, 0x74, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x31,
 0x00, 0x74, 0x6f, 0x00, 0x74, 0x68, 0x65, 0x00, 0x73, 0x69,
-0x7a, 0x65, 0x00, 0x6f, 0x66, 0x00, 0x74, 0x68, 0x40, 0x00,
+0x7a, 0x65, 0x00, 0x6f, 0x66, 0x0c, 0x00, 0x00, 0x40, 0x00,
 0x33, 0x2e, 0x00, 0x54, 0x0a, 0x00, 0xf0, 0x08, 0x00, 0x69,
 0x73, 0x00, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x64, 0x00,
 0x69, 0x6e, 0x74, 0x6f, 0x00, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
@@ -36,225 +36,225 @@ const char help_text[] = {
 0x74, 0x68, 0x00, 0x61, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x65,
 0x74, 0x69, 0x63, 0x00, 0x63, 0x6c, 0x75, 0x65, 0x73, 0x00,
 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x69, 0x6e,
-0x66, 0x00, 0x20, 0x6d, 0x2e, 0xba, 0x00, 0x80, 0x72, 0x00,
-0x61, 0x69, 0x6d, 0x00, 0x69, 0x73, 0x87, 0x00, 0xe5, 0x66,
-0x75, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x70, 0x75, 0x6c,
-0x61, 0x74, 0x65, 0x8a, 0x00, 0x01, 0x4e, 0x00, 0x02, 0xb4,
-0x00, 0xf0, 0x03, 0x73, 0x00, 0x73, 0x75, 0x63, 0x68, 0x00,
-0x74, 0x68, 0x61, 0x74, 0x3a, 0x00, 0x00, 0x00, 0x2d, 0x00,
-0x45, 0xe4, 0x00, 0x34, 0x72, 0x6f, 0x77, 0xdd, 0x00, 0xf0,
-0x05, 0x73, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x6e,
-0x65, 0x00, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e,
-0x63, 0xd7, 0x00, 0x00, 0x0d, 0x01, 0x03, 0x44, 0x00, 0x06,
-0x38, 0x00, 0x6f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x3b,
-0x00, 0x1c, 0x00, 0x17, 0x01, 0x04, 0x8d, 0x00, 0x21, 0x69,
-0x6e, 0x1d, 0x00, 0x02, 0x11, 0x01, 0xf1, 0x01, 0x00, 0x63,
-0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x62,
-0x69, 0x6e, 0x65, 0x64, 0xd2, 0x00, 0x31, 0x6f, 0x72, 0x6d,
-0xc8, 0x00, 0xd3, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x00,
-0x73, 0x74, 0x61, 0x74, 0x65, 0x64, 0x01, 0x01, 0x01, 0x16,
-0x01, 0x70, 0x2c, 0x00, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x10,
-0x00, 0x08, 0x31, 0x01, 0xf8, 0x00, 0x6f, 0x70, 0x65, 0x72,
-0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x67, 0x69, 0x76, 0x65,
-0x6e, 0x32, 0x00, 0x00, 0x99, 0x01, 0x52, 0x61, 0x74, 0x00,
-0x69, 0x73, 0x02, 0x01, 0x70, 0x41, 0x6e, 0x00, 0x61, 0x64,
-0x64, 0x69, 0x2c, 0x00, 0x01, 0x1f, 0x00, 0x61, 0x00, 0x6d,
-0x65, 0x61, 0x6e, 0x73, 0x23, 0x01, 0x02, 0xd8, 0x01, 0x21,
-0x75, 0x6d, 0xd7, 0x01, 0x05, 0xb6, 0x00, 0x03, 0x4c, 0x00,
-0x03, 0xb5, 0x00, 0x61, 0x6d, 0x75, 0x73, 0x74, 0x00, 0x62,
-0x6d, 0x01, 0x02, 0x6b, 0x00, 0x03, 0xab, 0x00, 0xf5, 0x05,
-0x2e, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x65, 0x78, 0x61, 0x6d,
-0x70, 0x6c, 0x65, 0x2c, 0x00, 0x60, 0x31, 0x35, 0x2b, 0x27,
-0x5b, 0x00, 0x11, 0x65, 0x34, 0x01, 0x30, 0x65, 0x6e, 0x74,
-0x05, 0x02, 0x06, 0x4d, 0x00, 0x00, 0x89, 0x00, 0x41, 0x73,
-0x00, 0x75, 0x70, 0xfa, 0x00, 0x72, 0x69, 0x66, 0x74, 0x65,
-0x65, 0x6e, 0x2e, 0xa4, 0x00, 0xb6, 0x00, 0x6d, 0x75, 0x6c,
-0x74, 0x69, 0x70, 0x6c, 0x69, 0x63, 0x61, 0xa9, 0x00, 0xfc,
-0x09, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x00, 0x60, 0x36, 0x30,
-0x2a, 0x27, 0x29, 0x2c, 0x00, 0x73, 0x69, 0x6d, 0x69, 0x6c,
-0x61, 0x72, 0x6c, 0x79, 0x2c, 0xc2, 0x00, 0x7f, 0x70, 0x72,
-0x6f, 0x64, 0x75, 0x63, 0x74, 0xc6, 0x00, 0x21, 0x04, 0x7f,
-0x00, 0x76, 0x73, 0x75, 0x62, 0x74, 0x72, 0x61, 0x63, 0x7c,
-0x00, 0xe8, 0x77, 0x69, 0x6c, 0x6c, 0x00, 0x61, 0x6c, 0x77,
-0x61, 0x79, 0x73, 0x00, 0x62, 0x65, 0x9a, 0x02, 0x13, 0x61,
-0x53, 0x00, 0x22, 0x6f, 0x66, 0x13, 0x03, 0x41, 0x74, 0x77,
-0x6f, 0x2c, 0xda, 0x02, 0x27, 0x69, 0x74, 0x99, 0x00, 0x00,
-0x27, 0x02, 0x0f, 0x91, 0x00, 0x08, 0x00, 0xd1, 0x02, 0x70,
-0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x2f, 0x00, 0x02,
-0x1a, 0x00, 0x87, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x62,
-0x79, 0xa6, 0x00, 0x6c, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-0x6c, 0x01, 0x3f, 0x32, 0x2d, 0x27, 0x6b, 0x00, 0x1b, 0x6b,
-0x32, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x6a, 0x00, 0x20, 0x2c,
-0x00, 0x55, 0x00, 0xb5, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c,
-0x65, 0x6e, 0x74, 0x6c, 0x79, 0x4e, 0x00, 0x03, 0xcd, 0x02,
-0x56, 0x6d, 0x69, 0x6e, 0x75, 0x73, 0x30, 0x00, 0x00, 0x1a,
-0x00, 0x01, 0x4d, 0x00, 0x00, 0x61, 0x02, 0x01, 0xf8, 0x00,
-0x04, 0x6f, 0x00, 0x50, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x27,
-0x01, 0x21, 0x65, 0x69, 0x29, 0x00, 0xf3, 0x02, 0x77, 0x61,
-0x79, 0x00, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2c, 0x00, 0x74,
-0x68, 0x6f, 0x75, 0x67, 0x68, 0x67, 0x01, 0x01, 0x26, 0x04,
-0x1c, 0x73, 0xe0, 0x01, 0x2b, 0x33, 0x2f, 0xdf, 0x01, 0x23,
-0x69, 0x73, 0x7a, 0x01, 0x0f, 0x6f, 0x01, 0x04, 0x00, 0x6e,
-0x01, 0x02, 0x00, 0x01, 0x0b, 0xb2, 0x00, 0x05, 0x86, 0x04,
-0x27, 0x62, 0x79, 0xb7, 0x00, 0x20, 0x69, 0x73, 0xe6, 0x00,
-0x20, 0x61, 0x6c, 0x76, 0x02, 0x0e, 0x5a, 0x01, 0x61, 0x00,
-0x00, 0x4e, 0x6f, 0x74, 0x65, 0x49, 0x00, 0x04, 0x6c, 0x00,
-0x08, 0x0d, 0x05, 0x02, 0x23, 0x03, 0x23, 0x61, 0x6d, 0x62,
-0x00, 0x07, 0x48, 0x01, 0x10, 0x6f, 0xfe, 0x03, 0x41, 0x28,
-0x70, 0x72, 0x6f, 0x73, 0x00, 0x01, 0x28, 0x00, 0x90, 0x69,
-0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x93, 0x00,
-0x20, 0x73, 0x00, 0x58, 0x05, 0x47, 0x6e, 0x6f, 0x74, 0x00,
-0x46, 0x00, 0x00, 0x8b, 0x04, 0x00, 0xbf, 0x00, 0x03, 0x5b,
-0x04, 0x10, 0x29, 0x4b, 0x01, 0x61, 0x69, 0x73, 0x00, 0x72,
-0x75, 0x6c, 0x5b, 0x01, 0x83, 0x70, 0x72, 0x65, 0x63, 0x69,
-0x73, 0x65, 0x6c, 0xbf, 0x00, 0x64, 0x70, 0x70, 0x6f, 0x73,
-0x69, 0x74, 0xdd, 0x01, 0x03, 0x26, 0x00, 0xf2, 0x0e, 0x6e,
-0x00, 0x53, 0x6f, 0x6c, 0x6f, 0x27, 0x73, 0x00, 0x60, 0x4b,
-0x69, 0x6c, 0x6c, 0x65, 0x72, 0x27, 0x00, 0x6d, 0x6f, 0x64,
-0x65, 0x00, 0x28, 0x73, 0x65, 0x65, 0x00, 0x63, 0xfe, 0x05,
-0x72, 0x00, 0x31, 0x31, 0x29, 0x2e, 0x00, 0x00, 0x5c, 0x00,
-0xd5, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x61, 0x70,
-0x70, 0x65, 0x61, 0x72, 0x1b, 0x02, 0xb2, 0x54, 0x69, 0x6d,
-0x65, 0x73, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x80, 0x04,
-0x00, 0x9d, 0x00, 0x80, 0x60, 0x4b, 0x65, 0x6e, 0x4b, 0x65,
-0x6e, 0x27, 0x3c, 0x00, 0x42, 0x33, 0x30, 0x2e, 0x31, 0x42,
-0x06, 0x00, 0x0a, 0x01, 0x40, 0x72, 0x6f, 0x6c, 0x73, 0x4b,
-0x06, 0x00, 0x11, 0x00, 0x00, 0xcd, 0x05, 0x80, 0x72, 0x65,
-0x73, 0x00, 0x6d, 0x75, 0x63, 0x68, 0x9b, 0x00, 0x00, 0x02,
-0x02, 0x03, 0x24, 0x00, 0x71, 0x00, 0x73, 0x79, 0x73, 0x74,
-0x65, 0x6d, 0x91, 0x05, 0x01, 0xa7, 0x00, 0x20, 0x00, 0x28,
-0xed, 0x00, 0x21, 0x55, 0x6e, 0x81, 0x01, 0x02, 0x94, 0x00,
-0x61, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x4a, 0x00, 0x01,
-0xf6, 0x01, 0x91, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x69,
-0x63, 0x6b, 0x88, 0x00, 0x51, 0x6d, 0x6f, 0x75, 0x73, 0x65,
-0xf8, 0x01, 0x84, 0x6e, 0x79, 0x00, 0x65, 0x6d, 0x70, 0x74,
-0x79, 0xa2, 0x06, 0x21, 0x61, 0x6e, 0x65, 0x01, 0x65, 0x6e,
-0x00, 0x74, 0x79, 0x70, 0x65, 0xa4, 0x06, 0x12, 0x6f, 0xcf,
-0x00, 0x82, 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64,
-0x5a, 0x04, 0x21, 0x6c, 0x6c, 0xd0, 0x01, 0x03, 0x3a, 0x00,
-0xc0, 0x2e, 0x00, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x00,
-0x6d, 0x61, 0x6b, 0x39, 0x00, 0x8f, 0x6d, 0x69, 0x73, 0x74,
-0x61, 0x6b, 0x65, 0x2c, 0x76, 0x00, 0x00, 0x02, 0xc6, 0x01,
-0x87, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x7a,
-0x00, 0x00, 0x9a, 0x01, 0x80, 0x73, 0x73, 0x00, 0x53, 0x70,
-0x61, 0x63, 0x65, 0x64, 0x00, 0x50, 0x63, 0x6c, 0x65, 0x61,
-0x72, 0xf2, 0x03, 0x20, 0x61, 0x67, 0x25, 0x02, 0x62, 0x28,
-0x6f, 0x72, 0x00, 0x75, 0x73, 0x5f, 0x04, 0xc0, 0x55, 0x6e,
-0x64, 0x6f, 0x00, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65,
-0xf2, 0x00, 0x04, 0x7e, 0x00, 0x61, 0x72, 0x69, 0x67, 0x68,
-0x74, 0x2d, 0x74, 0x00, 0x01, 0xe0, 0x00, 0x0f, 0xd8, 0x00,
-0x04, 0x03, 0x99, 0x04, 0x11, 0x2c, 0xc2, 0x00, 0x03, 0x0d,
-0x00, 0x01, 0x8e, 0x04, 0x01, 0x60, 0x03, 0x45, 0x6e, 0x74,
-0x65, 0x72, 0x20, 0x06, 0x05, 0x42, 0x00, 0xf1, 0x02, 0x73,
-0x00, 0x61, 0x00, 0x60, 0x70, 0x65, 0x6e, 0x63, 0x69, 0x6c,
-0x00, 0x6d, 0x61, 0x72, 0x6b, 0x27, 0x3a, 0x07, 0x00, 0x70,
-0x06, 0x02, 0xf8, 0x07, 0x07, 0x1b, 0x00, 0x10, 0x73, 0x73,
-0x06, 0x04, 0x6e, 0x05, 0x04, 0x77, 0x06, 0x18, 0x73, 0xa3,
-0x02, 0x05, 0x36, 0x01, 0x11, 0x53, 0x08, 0x00, 0x14, 0x73,
-0x0a, 0x03, 0x00, 0x85, 0x06, 0x10, 0x66, 0x72, 0x02, 0x44,
-0x64, 0x2d, 0x69, 0x6e, 0x39, 0x00, 0x00, 0x64, 0x00, 0x00,
-0xe3, 0x02, 0x44, 0x61, 0x6c, 0x73, 0x6f, 0x29, 0x00, 0x09,
-0x6f, 0x00, 0x32, 0x2e, 0x00, 0x00, 0x28, 0x08, 0x00, 0x5a,
-0x00, 0x10, 0x70, 0xd4, 0x03, 0x40, 0x6e, 0x6f, 0x00, 0x61,
-0x4c, 0x05, 0x01, 0x6c, 0x05, 0x29, 0x74, 0x6f, 0x2e, 0x00,
-0x40, 0x2c, 0x00, 0x73, 0x6f, 0xe8, 0x04, 0x10, 0x63, 0x8e,
-0x04, 0x40, 0x77, 0x68, 0x61, 0x74, 0x3a, 0x01, 0x04, 0x5a,
-0x01, 0x11, 0x6d, 0xbb, 0x00, 0x13, 0x69, 0x41, 0x06, 0x00,
-0x1a, 0x00, 0x32, 0x3a, 0x00, 0x79, 0xe7, 0x00, 0x05, 0x23,
-0x00, 0x00, 0x0c, 0x01, 0x40, 0x72, 0x65, 0x6d, 0x69, 0xd8,
-0x02, 0x14, 0x73, 0xd5, 0x03, 0xa4, 0x70, 0x61, 0x72, 0x74,
-0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x32, 0x01, 0x40, 0x6e,
-0x65, 0x65, 0x64, 0x52, 0x08, 0x00, 0x54, 0x01, 0x30, 0x72,
-0x65, 0x2d, 0x5a, 0x05, 0x00, 0x92, 0x07, 0x01, 0xd4, 0x03,
-0x01, 0x54, 0x00, 0x42, 0x6b, 0x6e, 0x6f, 0x77, 0xec, 0x03,
-0x4a, 0x61, 0x62, 0x6f, 0x75, 0x45, 0x00, 0x05, 0xa2, 0x01,
-0x2f, 0x6f, 0x72, 0x80, 0x00, 0x02, 0x36, 0x6c, 0x69, 0x73,
-0xf8, 0x06, 0x6a, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6a,
-0x01, 0x12, 0x61, 0x83, 0x04, 0x03, 0x8d, 0x00, 0x00, 0x48,
-0x00, 0x00, 0xee, 0x02, 0x20, 0x74, 0x68, 0x62, 0x01, 0x32,
-0x65, 0x6c, 0x73, 0x82, 0x00, 0x93, 0x66, 0x65, 0x65, 0x6c,
-0x00, 0x6c, 0x69, 0x6b, 0x65, 0x35, 0x03, 0x40, 0x65, 0x72,
-0x61, 0x73, 0x1f, 0x02, 0x00, 0x0d, 0x08, 0x19, 0x6c, 0xd3,
-0x01, 0x18, 0x2c, 0x5b, 0x02, 0x0c, 0x1b, 0x02, 0x21, 0x6e,
-0x64, 0x58, 0x02, 0x04, 0xde, 0x01, 0x04, 0x88, 0x00, 0x01,
-0xb8, 0x02, 0x01, 0x7d, 0x07, 0x39, 0x41, 0x6c, 0x6c, 0x83,
-0x01, 0x0a, 0x9c, 0x02, 0x22, 0x72, 0x65, 0x79, 0x00, 0x61,
-0x64, 0x00, 0x77, 0x68, 0x65, 0x6e, 0x99, 0x00, 0x33, 0x6c,
-0x65, 0x66, 0x6c, 0x00, 0x06, 0x5e, 0x00, 0x17, 0x61, 0x14,
-0x01, 0x0f, 0x2a, 0x00, 0x01, 0x07, 0x43, 0x03, 0x10, 0x73,
-0x43, 0x03, 0x36, 0x2e, 0x00, 0x52, 0xb3, 0x00, 0x35, 0x69,
-0x6e, 0x67, 0x20, 0x00, 0x00, 0xde, 0x00, 0x01, 0x23, 0x00,
-0x05, 0x82, 0x07, 0x13, 0x73, 0xfb, 0x00, 0x0d, 0x56, 0x02,
-0x11, 0x41, 0xcb, 0x02, 0x01, 0x66, 0x04, 0x12, 0x2c, 0x73,
-0x08, 0x50, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x0b, 0x04, 0x14,
-0x73, 0x6b, 0x09, 0x20, 0x75, 0x73, 0x2d, 0x03, 0x01, 0xc2,
-0x09, 0x31, 0x6a, 0x75, 0x6e, 0xdf, 0x07, 0x01, 0x9c, 0x04,
-0x06, 0x2c, 0x07, 0x00, 0x2f, 0x00, 0x01, 0x0a, 0x02, 0x35,
-0x73, 0x65, 0x74, 0xa4, 0x01, 0x2b, 0x6f, 0x72, 0x6e, 0x00,
-0x37, 0x55, 0x73, 0x65, 0x63, 0x00, 0x05, 0x34, 0x00, 0x21,
-0x6d, 0x6f, 0x55, 0x0b, 0x50, 0x68, 0x69, 0x67, 0x68, 0x6c,
-0xd0, 0x00, 0x21, 0x00, 0x61, 0xf6, 0x06, 0x05, 0x99, 0x0a,
-0x01, 0x18, 0x08, 0x0a, 0xb0, 0x04, 0x22, 0x74, 0x6f, 0xc5,
-0x03, 0x24, 0x00, 0x69, 0x18, 0x06, 0x06, 0x3f, 0x00, 0x25,
-0x65, 0x64, 0x7c, 0x03, 0x14, 0x50, 0x0c, 0x01, 0x50, 0x72,
-0x65, 0x74, 0x75, 0x72, 0x28, 0x03, 0x5a, 0x67, 0x67, 0x6c,
-0x65, 0x73, 0x30, 0x00, 0x02, 0x6d, 0x0b, 0x10, 0x61, 0x00,
-0x06, 0x01, 0xbd, 0x04, 0x54, 0x77, 0x68, 0x69, 0x63, 0x68,
-0x93, 0x02, 0x03, 0x67, 0x00, 0x20, 0x6f, 0x72, 0x10, 0x03,
-0x2d, 0x6f, 0x76, 0x40, 0x01, 0x06, 0x63, 0x00, 0x11, 0x4d,
-0x6b, 0x01, 0x01, 0xdc, 0x03, 0x01, 0xfd, 0x01, 0x01, 0x67,
-0x0b, 0x01, 0x10, 0x01, 0x2d, 0x6f, 0x66, 0x1b, 0x02, 0x43,
-0x65, 0x76, 0x65, 0x72, 0x93, 0x05, 0x03, 0x35, 0x07, 0x40,
-0x64, 0x6f, 0x65, 0x73, 0xe7, 0x06, 0x04, 0x63, 0x0c, 0x40,
-0x6d, 0x61, 0x69, 0x6e, 0xed, 0x00, 0x02, 0xe1, 0x00, 0x11,
-0x69, 0x63, 0x07, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0xbc, 0x00,
-0x02, 0x63, 0x09, 0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63,
-0x72, 0x69, 0x62, 0x9e, 0x01, 0x22, 0x73, 0x65, 0x9a, 0x01,
-0x30, 0x32, 0x2e, 0x31, 0x72, 0x02, 0x02, 0xf5, 0x01, 0xb2,
-0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
-0x29, 0x8e, 0x06, 0x12, 0x32, 0x8e, 0x06, 0xb2, 0x70, 0x61,
-0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x5b,
-0x04, 0x35, 0x73, 0x65, 0x00, 0x14, 0x00, 0x01, 0x74, 0x07,
-0x06, 0x3b, 0x00, 0x00, 0xc2, 0x0c, 0x02, 0x5f, 0x0b, 0xe0,
-0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e,
-0x27, 0x00, 0x6f, 0x70, 0x6e, 0x00, 0x04, 0x3a, 0x06, 0x50,
-0x60, 0x54, 0x79, 0x70, 0x65, 0x4f, 0x09, 0x20, 0x6e, 0x75,
-0xaa, 0x00, 0x51, 0x47, 0x72, 0x69, 0x64, 0x20, 0x69, 0x08,
-0xbf, 0x00, 0x00, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69,
-0x65, 0x73, 0x00, 0x0d, 0x04, 0xb0, 0x4c, 0x6f, 0x77, 0x65,
-0x72, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x97, 0x04, 0x68,
-0x33, 0x3b, 0x00, 0x75, 0x70, 0x70, 0x12, 0x00, 0x74, 0x39,
-0x00, 0x28, 0x62, 0x65, 0x63, 0x61, 0x1a, 0x06, 0x20, 0x75,
-0x73, 0xf8, 0x01, 0x00, 0x97, 0x01, 0x11, 0x66, 0xe1, 0x02,
-0x03, 0x36, 0x09, 0x42, 0x63, 0x6f, 0x6d, 0x65, 0x6c, 0x04,
-0x40, 0x64, 0x69, 0x66, 0x66, 0x64, 0x04, 0x12, 0x74, 0xa5,
-0x02, 0x12, 0x60, 0x5f, 0x09, 0x64, 0x27, 0x00, 0x62, 0x69,
-0x67, 0x67, 0x29, 0x0a, 0x21, 0x39, 0x21, 0x55, 0x06, 0x14,
-0x44, 0x2b, 0x00, 0x53, 0x79, 0x00, 0x00, 0x00, 0x43, 0xa2,
-0x07, 0x02, 0xd7, 0x02, 0x05, 0x1a, 0x00, 0x05, 0xae, 0x00,
-0x40, 0x65, 0x6e, 0x65, 0x72, 0x58, 0x0c, 0x03, 0x0c, 0x08,
-0xd1, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x55, 0x6e, 0x72, 0x65,
-0x61, 0x73, 0x6f, 0x6e, 0x28, 0x01, 0x80, 0x6c, 0x65, 0x76,
-0x65, 0x6c, 0x2c, 0x00, 0x73, 0x8a, 0x00, 0x71, 0x62, 0x61,
-0x63, 0x6b, 0x74, 0x72, 0x61, 0x98, 0x03, 0x05, 0x79, 0x06,
-0x10, 0x72, 0x28, 0x0a, 0x73, 0x72, 0x65, 0x64, 0x2c, 0x00,
-0x62, 0x75, 0x37, 0x0c, 0x31, 0x6f, 0x6c, 0x75, 0x48, 0x01,
-0x21, 0x73, 0x68, 0xc8, 0x00, 0x23, 0x73, 0x74, 0x2b, 0x00,
-0x42, 0x75, 0x6e, 0x69, 0x71, 0x85, 0x0c, 0x10, 0x65, 0x7b,
-0x02, 0x02, 0x3a, 0x06, 0x02, 0x62, 0x00, 0x13, 0x73, 0x48,
-0x00, 0x01, 0x64, 0x07, 0x31, 0x72, 0x65, 0x61, 0xcc, 0x04,
-0x00, 0x6b, 0x09, 0x00, 0xd8, 0x0a, 0x22, 0x78, 0x00, 0x91,
-0x00, 0x01, 0xed, 0x0c, 0x00, 0x00, 0x02, 0x30, 0x6f, 0x69,
-0x64, 0x54, 0x02, 0x02, 0x10, 0x00, 0x06, 0x97, 0x00, 0x00,
-0xfe, 0x00, 0x19, 0x4d, 0x2e, 0x0c, 0x10, 0x20, 0x98, 0x0d,
-0x02, 0x69, 0x07, 0x41, 0x74, 0x68, 0x69, 0x73, 0xf1, 0x09,
-0x01, 0xd8, 0x00, 0x00, 0x81, 0x03, 0x00, 0x95, 0x00, 0x44,
-0x6f, 0x78, 0x65, 0x73, 0xcb, 0x00, 0x0b, 0x6a, 0x0c, 0x02,
-0x1d, 0x00, 0x31, 0x2e, 0x00, 0x57, 0x16, 0x04, 0x04, 0x8c,
-0x09, 0x01, 0x51, 0x04, 0x04, 0x3a, 0x09, 0x21, 0x69, 0x73,
-0x0f, 0x06, 0x10, 0x6e, 0xdc, 0x05, 0xf0, 0x02, 0x60, 0x49,
-0x6e, 0x73, 0x68, 0x69, 0x00, 0x4e, 0x6f, 0x00, 0x48, 0x65,
-0x79, 0x61, 0x27, 0x2e, 0x00,
+0x66, 0x00, 0x20, 0x6d, 0x2e, 0xba, 0x00, 0x50, 0x72, 0x00,
+0x61, 0x69, 0x6d, 0x62, 0x00, 0xf5, 0x02, 0x74, 0x6f, 0x00,
+0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x70, 0x75,
+0x6c, 0x61, 0x74, 0x65, 0x8a, 0x00, 0x02, 0x4e, 0x00, 0x01,
+0xb4, 0x00, 0xf0, 0x03, 0x73, 0x00, 0x73, 0x75, 0x63, 0x68,
+0x00, 0x74, 0x68, 0x61, 0x74, 0x3a, 0x00, 0x00, 0x00, 0x2d,
+0x00, 0x45, 0xe4, 0x00, 0x34, 0x72, 0x6f, 0x77, 0xdd, 0x00,
+0xf1, 0x05, 0x73, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x00, 0x6f,
+0x6e, 0x65, 0x00, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65,
+0x6e, 0x63, 0xd7, 0x00, 0x01, 0x0d, 0x01, 0x02, 0xf8, 0x00,
+0x05, 0x38, 0x00, 0x6f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
+0x3b, 0x00, 0x1d, 0x00, 0x17, 0x01, 0x03, 0x8d, 0x00, 0x22,
+0x69, 0x6e, 0x1d, 0x00, 0x01, 0x11, 0x01, 0xf1, 0x01, 0x00,
+0x63, 0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x63, 0x6f, 0x6d,
+0x62, 0x69, 0x6e, 0x65, 0x64, 0xd2, 0x00, 0x31, 0x6f, 0x72,
+0x6d, 0xc8, 0x00, 0xd3, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+0x00, 0x73, 0x74, 0x61, 0x74, 0x65, 0x64, 0x01, 0x01, 0x01,
+0x16, 0x01, 0x40, 0x2c, 0x00, 0x75, 0x73, 0x42, 0x01, 0x00,
+0x10, 0x00, 0x07, 0x31, 0x01, 0xf8, 0x00, 0x6f, 0x70, 0x65,
+0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x67, 0x69, 0x76,
+0x65, 0x6e, 0x32, 0x00, 0x00, 0x99, 0x01, 0x52, 0x61, 0x74,
+0x00, 0x69, 0x73, 0x02, 0x01, 0x71, 0x41, 0x6e, 0x00, 0x61,
+0x64, 0x64, 0x69, 0x2c, 0x00, 0x00, 0x1f, 0x00, 0x61, 0x00,
+0x6d, 0x65, 0x61, 0x6e, 0x73, 0x23, 0x01, 0x02, 0xd8, 0x01,
+0x24, 0x75, 0x6d, 0xd7, 0x01, 0x06, 0xb6, 0x00, 0x00, 0x0e,
+0x00, 0x02, 0xb5, 0x00, 0x63, 0x6d, 0x75, 0x73, 0x74, 0x00,
+0x62, 0x6d, 0x01, 0x01, 0x6b, 0x00, 0x02, 0xab, 0x00, 0xf5,
+0x05, 0x2e, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x65, 0x78, 0x61,
+0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x00, 0x60, 0x31, 0x35, 0x2b,
+0x27, 0x5b, 0x00, 0x11, 0x65, 0x34, 0x01, 0x31, 0x65, 0x6e,
+0x74, 0x05, 0x02, 0x06, 0x4d, 0x00, 0x71, 0x61, 0x64, 0x64,
+0x73, 0x00, 0x75, 0x70, 0xfa, 0x00, 0x72, 0x69, 0x66, 0x74,
+0x65, 0x65, 0x6e, 0x2e, 0xa4, 0x00, 0xb6, 0x00, 0x6d, 0x75,
+0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x63, 0x61, 0xa9, 0x00,
+0xfc, 0x09, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x00, 0x60, 0x36,
+0x30, 0x2a, 0x27, 0x29, 0x2c, 0x00, 0x73, 0x69, 0x6d, 0x69,
+0x6c, 0x61, 0x72, 0x6c, 0x79, 0x2c, 0xc2, 0x00, 0x7f, 0x70,
+0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0xc6, 0x00, 0x23, 0x02,
+0x7f, 0x00, 0x76, 0x73, 0x75, 0x62, 0x74, 0x72, 0x61, 0x63,
+0x7c, 0x00, 0xb0, 0x77, 0x69, 0x6c, 0x6c, 0x00, 0x61, 0x6c,
+0x77, 0x61, 0x79, 0x73, 0x38, 0x00, 0x07, 0x9a, 0x02, 0x13,
+0x61, 0x53, 0x00, 0x22, 0x6f, 0x66, 0x13, 0x03, 0x41, 0x74,
+0x77, 0x6f, 0x2c, 0xda, 0x02, 0x28, 0x69, 0x74, 0x99, 0x00,
+0x01, 0x27, 0x02, 0x0f, 0x91, 0x00, 0x07, 0xa0, 0x69, 0x73,
+0x00, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x2f, 0x00,
+0x02, 0x1a, 0x00, 0x87, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00,
+0x62, 0x79, 0xa6, 0x00, 0x6c, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
+0x74, 0x6c, 0x01, 0x3f, 0x32, 0x2d, 0x27, 0x6b, 0x00, 0x1b,
+0x6b, 0x32, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x6a, 0x00, 0x20,
+0x2c, 0x00, 0x55, 0x00, 0xb6, 0x71, 0x75, 0x69, 0x76, 0x61,
+0x6c, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x4e, 0x00, 0x02, 0xcd,
+0x02, 0x57, 0x6d, 0x69, 0x6e, 0x75, 0x73, 0x9a, 0x00, 0x00,
+0x1a, 0x00, 0x00, 0x4d, 0x00, 0x02, 0xfa, 0x03, 0x34, 0x74,
+0x77, 0x6f, 0x6f, 0x00, 0x50, 0x63, 0x6f, 0x75, 0x6c, 0x64,
+0x27, 0x01, 0x21, 0x65, 0x69, 0x29, 0x00, 0xf4, 0x02, 0x77,
+0x61, 0x79, 0x00, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2c, 0x00,
+0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x67, 0x01, 0x00, 0x26,
+0x04, 0x1c, 0x73, 0xe0, 0x01, 0x2b, 0x33, 0x2f, 0xdf, 0x01,
+0x24, 0x69, 0x73, 0x7a, 0x01, 0x0f, 0x6f, 0x01, 0x03, 0x01,
+0x6e, 0x01, 0x0b, 0x00, 0x01, 0x02, 0xb2, 0x00, 0x04, 0x86,
+0x04, 0x27, 0x62, 0x79, 0xb7, 0x00, 0x20, 0x69, 0x73, 0xe6,
+0x00, 0x24, 0x61, 0x6c, 0xc9, 0x04, 0x0a, 0x5a, 0x01, 0x62,
+0x00, 0x00, 0x4e, 0x6f, 0x74, 0x65, 0x49, 0x00, 0x04, 0x6c,
+0x00, 0x08, 0x0d, 0x05, 0x01, 0x23, 0x03, 0x25, 0x61, 0x6d,
+0x14, 0x01, 0x05, 0x48, 0x01, 0x10, 0x6f, 0xfe, 0x03, 0x42,
+0x28, 0x70, 0x72, 0x6f, 0x73, 0x00, 0x00, 0x28, 0x00, 0x90,
+0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x93,
+0x00, 0x20, 0x73, 0x00, 0x58, 0x05, 0x48, 0x6e, 0x6f, 0x74,
+0x00, 0x46, 0x00, 0x00, 0x8b, 0x04, 0x00, 0xbf, 0x00, 0x02,
+0x5b, 0x04, 0x10, 0x29, 0x4b, 0x01, 0x61, 0x69, 0x73, 0x00,
+0x72, 0x75, 0x6c, 0x5b, 0x01, 0x83, 0x70, 0x72, 0x65, 0x63,
+0x69, 0x73, 0x65, 0x6c, 0xbf, 0x00, 0x65, 0x70, 0x70, 0x6f,
+0x73, 0x69, 0x74, 0xdd, 0x01, 0x02, 0x26, 0x00, 0xf2, 0x0e,
+0x6e, 0x00, 0x53, 0x6f, 0x6c, 0x6f, 0x27, 0x73, 0x00, 0x60,
+0x4b, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x27, 0x00, 0x6d, 0x6f,
+0x64, 0x65, 0x00, 0x28, 0x73, 0x65, 0x65, 0x00, 0x63, 0xfe,
+0x05, 0x40, 0x00, 0x31, 0x31, 0x29, 0xda, 0x00, 0x01, 0x5c,
+0x00, 0xd5, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x61,
+0x70, 0x70, 0x65, 0x61, 0x72, 0x1b, 0x02, 0xb2, 0x54, 0x69,
+0x6d, 0x65, 0x73, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x80,
+0x04, 0x00, 0x9d, 0x00, 0x80, 0x60, 0x4b, 0x65, 0x6e, 0x4b,
+0x65, 0x6e, 0x27, 0x3c, 0x00, 0x42, 0x33, 0x30, 0x2e, 0x31,
+0x42, 0x06, 0x00, 0x0a, 0x01, 0x40, 0x72, 0x6f, 0x6c, 0x73,
+0x4b, 0x06, 0x00, 0x11, 0x00, 0x00, 0xcd, 0x05, 0x50, 0x72,
+0x65, 0x73, 0x00, 0x6d, 0x6a, 0x05, 0x32, 0x6f, 0x66, 0x00,
+0x02, 0x02, 0x01, 0x24, 0x00, 0x72, 0x00, 0x73, 0x79, 0x73,
+0x74, 0x65, 0x6d, 0x91, 0x05, 0x00, 0xa7, 0x00, 0x20, 0x00,
+0x28, 0xed, 0x00, 0x21, 0x55, 0x6e, 0x81, 0x01, 0x02, 0x94,
+0x00, 0x61, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x4a, 0x00,
+0x01, 0xf6, 0x01, 0x91, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c,
+0x69, 0x63, 0x6b, 0x88, 0x00, 0x51, 0x6d, 0x6f, 0x75, 0x73,
+0x65, 0xf8, 0x01, 0x84, 0x6e, 0x79, 0x00, 0x65, 0x6d, 0x70,
+0x74, 0x79, 0xa2, 0x06, 0x21, 0x61, 0x6e, 0x65, 0x01, 0x65,
+0x6e, 0x00, 0x74, 0x79, 0x70, 0x65, 0xa4, 0x06, 0x12, 0x6f,
+0xcf, 0x00, 0x72, 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72,
+0x54, 0x05, 0x00, 0xbb, 0x03, 0x01, 0xd0, 0x01, 0x02, 0x3a,
+0x00, 0xc0, 0x2e, 0x00, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75,
+0x00, 0x6d, 0x61, 0x6b, 0x39, 0x00, 0x8f, 0x6d, 0x69, 0x73,
+0x74, 0x61, 0x6b, 0x65, 0x2c, 0x76, 0x00, 0x01, 0x01, 0xc6,
+0x01, 0x88, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74,
+0x7a, 0x00, 0xb0, 0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53,
+0x70, 0x61, 0x63, 0x65, 0x64, 0x00, 0x50, 0x63, 0x6c, 0x65,
+0x61, 0x72, 0xf2, 0x03, 0x20, 0x61, 0x67, 0x25, 0x02, 0x62,
+0x28, 0x6f, 0x72, 0x00, 0x75, 0x73, 0x5f, 0x04, 0xc1, 0x55,
+0x6e, 0x64, 0x6f, 0x00, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
+0x65, 0xf2, 0x00, 0x03, 0x7e, 0x00, 0x62, 0x72, 0x69, 0x67,
+0x68, 0x74, 0x2d, 0x74, 0x00, 0x01, 0xd8, 0x02, 0x0f, 0xd8,
+0x00, 0x04, 0x02, 0x99, 0x04, 0x12, 0x2c, 0xc2, 0x00, 0x03,
+0x17, 0x06, 0x01, 0x8e, 0x04, 0x00, 0x60, 0x03, 0x46, 0x6e,
+0x74, 0x65, 0x72, 0x20, 0x06, 0x04, 0x42, 0x00, 0xf1, 0x02,
+0x73, 0x00, 0x61, 0x00, 0x60, 0x70, 0x65, 0x6e, 0x63, 0x69,
+0x6c, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x27, 0x3a, 0x07, 0x01,
+0x70, 0x06, 0x01, 0xf8, 0x07, 0x07, 0x1b, 0x00, 0x10, 0x73,
+0x73, 0x06, 0x04, 0x6e, 0x05, 0x04, 0x77, 0x06, 0x19, 0x73,
+0xa3, 0x02, 0x04, 0x36, 0x01, 0x11, 0x53, 0x08, 0x00, 0x14,
+0x73, 0x0a, 0x03, 0x00, 0x85, 0x06, 0x10, 0x66, 0x72, 0x02,
+0x45, 0x64, 0x2d, 0x69, 0x6e, 0x39, 0x00, 0x30, 0x63, 0x61,
+0x6e, 0xe3, 0x02, 0x45, 0x61, 0x6c, 0x73, 0x6f, 0x33, 0x03,
+0x08, 0x6f, 0x00, 0x02, 0x87, 0x02, 0x30, 0x65, 0x00, 0x67,
+0x5a, 0x00, 0x10, 0x70, 0xd4, 0x03, 0x40, 0x6e, 0x6f, 0x00,
+0x61, 0x4c, 0x05, 0x01, 0x6c, 0x05, 0x29, 0x74, 0x6f, 0x2e,
+0x00, 0x40, 0x2c, 0x00, 0x73, 0x6f, 0xe8, 0x04, 0x10, 0x63,
+0x8e, 0x04, 0x10, 0x77, 0x01, 0x01, 0x00, 0x3a, 0x01, 0x03,
+0x5a, 0x01, 0x11, 0x6d, 0xbb, 0x00, 0x14, 0x69, 0x41, 0x06,
+0x63, 0x79, 0x6f, 0x75, 0x3a, 0x00, 0x79, 0xe7, 0x00, 0x05,
+0x23, 0x00, 0x70, 0x61, 0x73, 0x00, 0x72, 0x65, 0x6d, 0x69,
+0xd8, 0x02, 0x14, 0x73, 0xd5, 0x03, 0xa4, 0x70, 0x61, 0x72,
+0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x32, 0x01, 0x41,
+0x6e, 0x65, 0x65, 0x64, 0x52, 0x08, 0x60, 0x62, 0x65, 0x00,
+0x72, 0x65, 0x2d, 0x5a, 0x05, 0x01, 0x92, 0x07, 0x01, 0xd4,
+0x03, 0x00, 0x54, 0x00, 0x42, 0x6b, 0x6e, 0x6f, 0x77, 0xec,
+0x03, 0x4b, 0x61, 0x62, 0x6f, 0x75, 0x45, 0x00, 0x04, 0xa2,
+0x01, 0x2f, 0x6f, 0x72, 0x80, 0x00, 0x02, 0x36, 0x6c, 0x69,
+0x73, 0xf8, 0x06, 0x6a, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62,
+0x6a, 0x01, 0x13, 0x61, 0x83, 0x04, 0x02, 0x8d, 0x00, 0x01,
+0x48, 0x00, 0x50, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x62, 0x01,
+0x32, 0x65, 0x6c, 0x73, 0x82, 0x00, 0x93, 0x66, 0x65, 0x65,
+0x6c, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x35, 0x03, 0x41, 0x65,
+0x72, 0x61, 0x73, 0xc2, 0x09, 0x49, 0x69, 0x6e, 0x67, 0x6c,
+0xd3, 0x01, 0x1c, 0x2c, 0x5b, 0x02, 0x08, 0x1b, 0x02, 0x22,
+0x6e, 0x64, 0x58, 0x02, 0x05, 0xde, 0x01, 0x03, 0x52, 0x02,
+0x01, 0xb8, 0x02, 0x00, 0x5b, 0x00, 0x3a, 0x41, 0x6c, 0x6c,
+0x20, 0x02, 0x09, 0x9c, 0x02, 0x22, 0x72, 0x65, 0x79, 0x00,
+0x30, 0x64, 0x00, 0x77, 0xa3, 0x02, 0x00, 0x99, 0x00, 0x34,
+0x6c, 0x65, 0x66, 0x6c, 0x00, 0x05, 0x5e, 0x00, 0x18, 0x61,
+0x14, 0x01, 0x0f, 0x2a, 0x00, 0x05, 0x02, 0x43, 0x03, 0x10,
+0x73, 0x43, 0x03, 0x36, 0x2e, 0x00, 0x52, 0xb3, 0x00, 0x00,
+0xf7, 0x00, 0x05, 0x20, 0x00, 0x01, 0x2d, 0x0a, 0x01, 0x66,
+0x03, 0x03, 0x82, 0x07, 0x14, 0x73, 0xfb, 0x00, 0x0c, 0x56,
+0x02, 0x12, 0x41, 0xcb, 0x02, 0x00, 0x66, 0x04, 0x12, 0x2c,
+0x73, 0x08, 0x50, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x0b, 0x04,
+0x14, 0x73, 0x6b, 0x09, 0x22, 0x75, 0x73, 0x2d, 0x03, 0x62,
+0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0xdf, 0x07, 0x01, 0x9c,
+0x04, 0x05, 0x2c, 0x07, 0x02, 0x2f, 0x00, 0x65, 0x74, 0x6f,
+0x00, 0x73, 0x65, 0x74, 0xa4, 0x01, 0x2b, 0x6f, 0x72, 0x6e,
+0x00, 0x3d, 0x55, 0x73, 0x65, 0x63, 0x00, 0x51, 0x74, 0x6f,
+0x00, 0x6d, 0x6f, 0x55, 0x0b, 0x50, 0x68, 0x69, 0x67, 0x68,
+0x6c, 0xd0, 0x00, 0x21, 0x00, 0x61, 0xf6, 0x06, 0x05, 0x99,
+0x0a, 0x02, 0x18, 0x08, 0x09, 0xb0, 0x04, 0x22, 0x74, 0x6f,
+0xc5, 0x03, 0x25, 0x00, 0x69, 0x18, 0x06, 0x05, 0x3f, 0x00,
+0x25, 0x65, 0x64, 0x7c, 0x03, 0x14, 0x50, 0x0c, 0x01, 0x50,
+0x72, 0x65, 0x74, 0x75, 0x72, 0x28, 0x03, 0x5a, 0x67, 0x67,
+0x6c, 0x65, 0x73, 0x30, 0x00, 0x02, 0x6d, 0x0b, 0x12, 0x61,
+0x00, 0x06, 0x85, 0x69, 0x6e, 0x00, 0x77, 0x68, 0x69, 0x63,
+0x68, 0x93, 0x02, 0x02, 0x67, 0x00, 0x20, 0x6f, 0x72, 0x10,
+0x03, 0x2e, 0x6f, 0x76, 0x40, 0x01, 0x05, 0x63, 0x00, 0x12,
+0x4d, 0x6b, 0x01, 0x01, 0x37, 0x05, 0x01, 0xfd, 0x01, 0x00,
+0x67, 0x0b, 0x01, 0x10, 0x01, 0x2d, 0x6f, 0x66, 0x1b, 0x02,
+0x45, 0x65, 0x76, 0x65, 0x72, 0x93, 0x05, 0x01, 0x60, 0x03,
+0x41, 0x64, 0x6f, 0x65, 0x73, 0xe7, 0x06, 0x03, 0x63, 0x0c,
+0x10, 0x6d, 0x03, 0x04, 0x02, 0xed, 0x00, 0x41, 0x69, 0x6e,
+0x00, 0x69, 0x63, 0x07, 0x10, 0x28, 0x66, 0x02, 0x01, 0xc2,
+0x0a, 0x01, 0x84, 0x01, 0x92, 0x73, 0x00, 0x64, 0x65, 0x73,
+0x63, 0x72, 0x69, 0x62, 0x9e, 0x01, 0x22, 0x73, 0x65, 0x9a,
+0x01, 0x31, 0x32, 0x2e, 0x31, 0x72, 0x02, 0x01, 0xf5, 0x01,
+0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65,
+0x2e, 0x29, 0x8e, 0x06, 0x12, 0x32, 0x8e, 0x06, 0xb2, 0x70,
+0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20,
+0x5b, 0x04, 0x00, 0x1b, 0x02, 0x05, 0x14, 0x00, 0x02, 0x40,
+0x00, 0x04, 0x3b, 0x00, 0x02, 0xc2, 0x0c, 0x00, 0x78, 0x00,
+0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
+0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6e, 0x00, 0x03, 0x3a, 0x06,
+0x50, 0x60, 0x54, 0x79, 0x70, 0x65, 0x4f, 0x09, 0x20, 0x6e,
+0x75, 0xaa, 0x00, 0x51, 0x47, 0x72, 0x69, 0x64, 0x20, 0x69,
+0x08, 0xbf, 0x00, 0x00, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66,
+0x69, 0x65, 0x73, 0x00, 0x0d, 0x04, 0xb0, 0x4c, 0x6f, 0x77,
+0x65, 0x72, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x97, 0x04,
+0x68, 0x33, 0x3b, 0x00, 0x75, 0x70, 0x70, 0x12, 0x00, 0x74,
+0x39, 0x00, 0x28, 0x62, 0x65, 0x63, 0x61, 0x1a, 0x06, 0x20,
+0x75, 0x73, 0xf8, 0x01, 0x00, 0x97, 0x01, 0x11, 0x66, 0xe1,
+0x02, 0x03, 0x36, 0x09, 0x42, 0x63, 0x6f, 0x6d, 0x65, 0x6c,
+0x04, 0x40, 0x64, 0x69, 0x66, 0x66, 0x64, 0x04, 0x12, 0x74,
+0xa5, 0x02, 0x12, 0x60, 0x5f, 0x09, 0x64, 0x27, 0x00, 0x62,
+0x69, 0x67, 0x67, 0x29, 0x0a, 0x21, 0x39, 0x21, 0x55, 0x06,
+0x14, 0x44, 0x2b, 0x00, 0x53, 0x79, 0x00, 0x00, 0x00, 0x43,
+0xa2, 0x07, 0x03, 0xd7, 0x02, 0x05, 0x1a, 0x00, 0x04, 0xae,
+0x00, 0x41, 0x65, 0x6e, 0x65, 0x72, 0x58, 0x0c, 0x02, 0x0c,
+0x08, 0xd1, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x55, 0x6e, 0x72,
+0x65, 0x61, 0x73, 0x6f, 0x6e, 0x28, 0x01, 0x50, 0x6c, 0x65,
+0x76, 0x65, 0x6c, 0x7d, 0x05, 0x70, 0x6d, 0x65, 0x00, 0x62,
+0x61, 0x63, 0x6b, 0x0c, 0x0b, 0x01, 0x98, 0x03, 0x04, 0x79,
+0x06, 0x10, 0x72, 0x28, 0x0a, 0x73, 0x72, 0x65, 0x64, 0x2c,
+0x00, 0x62, 0x75, 0x37, 0x0c, 0x31, 0x6f, 0x6c, 0x75, 0x48,
+0x01, 0x21, 0x73, 0x68, 0xc8, 0x00, 0x23, 0x73, 0x74, 0x2b,
+0x00, 0x42, 0x75, 0x6e, 0x69, 0x71, 0x85, 0x0c, 0x10, 0x65,
+0x7b, 0x02, 0x03, 0x3a, 0x06, 0x01, 0x62, 0x00, 0x14, 0x73,
+0x48, 0x00, 0x00, 0x64, 0x07, 0x00, 0x7f, 0x00, 0x00, 0xcc,
+0x04, 0x00, 0x6b, 0x09, 0x00, 0xd8, 0x0a, 0x22, 0x78, 0x00,
+0x91, 0x00, 0x01, 0xed, 0x0c, 0x00, 0x00, 0x02, 0x30, 0x6f,
+0x69, 0x64, 0x54, 0x02, 0x03, 0x10, 0x00, 0x05, 0x97, 0x00,
+0x00, 0xfe, 0x00, 0x19, 0x4d, 0x2e, 0x0c, 0x11, 0x20, 0x98,
+0x0d, 0x01, 0x69, 0x07, 0x10, 0x74, 0xf2, 0x08, 0x00, 0xf1,
+0x09, 0x01, 0xd8, 0x00, 0x00, 0x81, 0x03, 0x00, 0x95, 0x00,
+0x45, 0x6f, 0x78, 0x65, 0x73, 0xcb, 0x00, 0x0b, 0x6a, 0x0c,
+0x01, 0x1d, 0x00, 0x32, 0x2e, 0x00, 0x57, 0x16, 0x04, 0x03,
+0x8c, 0x09, 0x02, 0x51, 0x04, 0x03, 0x3a, 0x09, 0x21, 0x69,
+0x73, 0x0f, 0x06, 0x10, 0x6e, 0xdc, 0x05, 0xf0, 0x02, 0x60,
+0x49, 0x6e, 0x73, 0x68, 0x69, 0x00, 0x4e, 0x6f, 0x00, 0x48,
+0x65, 0x79, 0x61, 0x27, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3952;
diff --git a/apps/plugins/puzzles/help/lightup.c b/apps/plugins/puzzles/help/lightup.c
index 127c78d885..303aa45beb 100644
--- a/apps/plugins/puzzles/help/lightup.c
+++ b/apps/plugins/puzzles/help/lightup.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -16,9 +16,9 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2327 comp 1556 ratio 0.668672 level 11 saved 771 */
+/* orig 2327 comp 1558 ratio 0.669532 level 10 saved 769 */
 const char help_text[] = {
-0xf0, 0x43, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
+0xf0, 0x40, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x31, 0x3a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x20,
 0x55, 0x70, 0x20, 0x00, 0x00, 0x00, 0x59, 0x6f, 0x75, 0x00,
 0x68, 0x61, 0x76, 0x65, 0x00, 0x61, 0x00, 0x67, 0x72, 0x69,
@@ -26,7 +26,7 @@ const char help_text[] = {
 0x65, 0x73, 0x2e, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x00, 0x61,
 0x72, 0x65, 0x00, 0x66, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x00,
 0x69, 0x6e, 0x00, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x3b, 0x00,
-0x73, 0x6f, 0x6d, 0x65, 0x2b, 0x00, 0x32, 0x74, 0x68, 0x65,
+0x73, 0x1a, 0x00, 0x62, 0x6f, 0x66, 0x00, 0x74, 0x68, 0x65,
 0x13, 0x00, 0x04, 0x35, 0x00, 0x01, 0x2f, 0x00, 0x90, 0x6e,
 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x2e, 0x5e, 0x00,
 0xe0, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00, 0x69, 0x73, 0x00,
@@ -34,19 +34,19 @@ const char help_text[] = {
 0x70, 0x27, 0x00, 0x61, 0x6c, 0x6c, 0x3e, 0x00, 0x55, 0x65,
 0x6d, 0x70, 0x74, 0x79, 0x3e, 0x00, 0xb2, 0x62, 0x79, 0x00,
 0x70, 0x6c, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x00, 0x2b, 0x00,
-0x88, 0x62, 0x75, 0x6c, 0x62, 0x73, 0x00, 0x69, 0x6e, 0x72,
+0x50, 0x62, 0x75, 0x6c, 0x62, 0x73, 0x79, 0x00, 0x07, 0x72,
 0x00, 0x97, 0x6d, 0x2e, 0x00, 0x00, 0x00, 0x45, 0x61, 0x63,
-0x68, 0x24, 0x00, 0xc0, 0x00, 0x69, 0x6c, 0x6c, 0x75, 0x6d,
-0x69, 0x6e, 0x61, 0x74, 0x65, 0x73, 0x24, 0x00, 0x03, 0x52,
-0x00, 0x30, 0x00, 0x69, 0x74, 0x7b, 0x00, 0x80, 0x6f, 0x6e,
-0x2c, 0x00, 0x70, 0x6c, 0x75, 0x73, 0x76, 0x00, 0x03, 0x1a,
-0x00, 0x01, 0x55, 0x00, 0x90, 0x6c, 0x69, 0x6e, 0x65, 0x00,
+0x68, 0x24, 0x00, 0xc1, 0x00, 0x69, 0x6c, 0x6c, 0x75, 0x6d,
+0x69, 0x6e, 0x61, 0x74, 0x65, 0x73, 0x58, 0x00, 0x02, 0x52,
+0x00, 0x30, 0x00, 0x69, 0x74, 0x7b, 0x00, 0x81, 0x6f, 0x6e,
+0x2c, 0x00, 0x70, 0x6c, 0x75, 0x73, 0x76, 0x00, 0x04, 0x6c,
+0x00, 0xc0, 0x69, 0x6e, 0x00, 0x6c, 0x69, 0x6e, 0x65, 0x00,
 0x77, 0x69, 0x74, 0x68, 0x28, 0x00, 0xf1, 0x07, 0x68, 0x6f,
 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79,
 0x00, 0x6f, 0x72, 0x00, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63,
 0x0e, 0x00, 0x89, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x00,
-0x61, 0xec, 0x00, 0x00, 0x59, 0x00, 0x81, 0x62, 0x6c, 0x6f,
-0x63, 0x6b, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x30, 0x77, 0x61,
+0x61, 0xec, 0x00, 0x00, 0x59, 0x00, 0x50, 0x62, 0x6c, 0x6f,
+0x63, 0x6b, 0xae, 0x00, 0x00, 0x73, 0x00, 0x30, 0x77, 0x61,
 0x79, 0x9a, 0x00, 0x61, 0x54, 0x6f, 0x00, 0x77, 0x69, 0x6e,
 0x12, 0x00, 0xf1, 0x07, 0x67, 0x61, 0x6d, 0x65, 0x2c, 0x00,
 0x79, 0x6f, 0x75, 0x00, 0x6d, 0x75, 0x73, 0x74, 0x00, 0x73,
@@ -57,18 +57,18 @@ const char help_text[] = {
 0x6f, 0x6e, 0x2d, 0x58, 0x01, 0x41, 0x6c, 0x69, 0x74, 0x2e,
 0x23, 0x00, 0x23, 0x4e, 0x6f, 0xfb, 0x00, 0x20, 0x69, 0x73,
 0x15, 0x00, 0x00, 0x37, 0x01, 0x72, 0x61, 0x6e, 0x6f, 0x74,
-0x68, 0x65, 0x72, 0x18, 0x00, 0x14, 0x2e, 0x49, 0x00, 0x05,
-0x8b, 0x01, 0x0a, 0xa6, 0x01, 0x02, 0xf2, 0x01, 0x60, 0x65,
+0x68, 0x65, 0x72, 0x18, 0x00, 0x16, 0x2e, 0x49, 0x00, 0x03,
+0x8b, 0x01, 0x0b, 0xa6, 0x01, 0x01, 0xf2, 0x01, 0x60, 0x65,
 0x78, 0x61, 0x63, 0x74, 0x6c, 0x8f, 0x00, 0x23, 0x61, 0x74,
-0x29, 0x00, 0x32, 0x00, 0x6f, 0x66, 0x42, 0x00, 0xd1, 0x73,
-0x00, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x00,
-0x74, 0x6f, 0x75, 0x01, 0x43, 0x00, 0x28, 0x69, 0x6e, 0xba,
-0x00, 0x26, 0x75, 0x72, 0x97, 0x00, 0xf3, 0x01, 0x62, 0x6f,
+0x29, 0x00, 0x00, 0x62, 0x01, 0x01, 0x42, 0x00, 0xa0, 0x73,
+0x00, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0xb8,
+0x01, 0x00, 0x75, 0x01, 0x23, 0x00, 0x28, 0xd5, 0x00, 0x10,
+0x66, 0xd4, 0x01, 0x05, 0x97, 0x00, 0xf3, 0x01, 0x62, 0x6f,
 0x76, 0x65, 0x2c, 0x00, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x2c,
 0x00, 0x61, 0x6e, 0x64, 0x2f, 0x00, 0x60, 0x00, 0x73, 0x69,
 0x64, 0x65, 0x29, 0x88, 0x00, 0x4f, 0x4e, 0x6f, 0x6e, 0x2d,
 0x86, 0x00, 0x04, 0x33, 0x6d, 0x61, 0x79, 0x7c, 0x02, 0x2f,
-0x6e, 0x79, 0x81, 0x00, 0x0a, 0x05, 0xf6, 0x01, 0xf1, 0x0b,
+0x6e, 0x79, 0x81, 0x00, 0x0f, 0x00, 0x4d, 0x00, 0xf1, 0x0b,
 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x00, 0x66, 0x6f, 0x72,
 0x00, 0x74, 0x68, 0x69, 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a,
 0x6c, 0x65, 0x00, 0x67, 0x6f, 0x65, 0x60, 0x02, 0xa0, 0x4e,
@@ -76,104 +76,104 @@ const char help_text[] = {
 0x00, 0x11, 0x4c, 0x23, 0x01, 0x60, 0x55, 0x70, 0x00, 0x77,
 0x61, 0x73, 0x66, 0x01, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75,
 0x74, 0x65, 0xa3, 0x00, 0x10, 0x69, 0x14, 0x00, 0x40, 0x6c,
-0x6c, 0x65, 0x63, 0x7b, 0x01, 0x00, 0x42, 0x01, 0xb0, 0x4a,
+0x6c, 0x65, 0x63, 0x7b, 0x01, 0x00, 0x42, 0x01, 0xb1, 0x4a,
 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65,
-0xc8, 0x01, 0x00, 0x46, 0x00, 0xd1, 0x00, 0x68, 0x74, 0x74,
-0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x5c,
-0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65,
-0x6e, 0x2f, 0x7b, 0x00, 0xf1, 0x04, 0x73, 0x2f, 0x61, 0x6b,
-0x61, 0x72, 0x69, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x28,
-0x62, 0x65, 0x77, 0x61, 0x72, 0xa7, 0x02, 0xd6, 0x46, 0x6c,
-0x61, 0x73, 0x68, 0x29, 0x00, 0x00, 0x00, 0x32, 0x31, 0x2e,
-0x31, 0x71, 0x03, 0x01, 0x86, 0x00, 0x40, 0x6f, 0x6c, 0x73,
-0x20, 0x9f, 0x00, 0x71, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c,
-0x69, 0x41, 0x02, 0x00, 0x8e, 0x02, 0x1c, 0x61, 0xf7, 0x01,
-0x00, 0x9c, 0x02, 0x00, 0x27, 0x03, 0x51, 0x6f, 0x67, 0x67,
-0x6c, 0x65, 0x56, 0x01, 0x71, 0x70, 0x72, 0x65, 0x73, 0x65,
-0x6e, 0x63, 0x63, 0x00, 0x14, 0x61, 0x04, 0x02, 0x11, 0x6e,
-0xc2, 0x01, 0x03, 0x33, 0x00, 0x6f, 0x2e, 0x00, 0x52, 0x69,
-0x67, 0x68, 0x59, 0x00, 0x0d, 0x03, 0x54, 0x00, 0x00, 0xd3,
-0x02, 0x40, 0x6d, 0x61, 0x72, 0x6b, 0x5c, 0x00, 0x01, 0x15,
-0x00, 0xd0, 0x00, 0x61, 0x69, 0x64, 0x00, 0x73, 0x6f, 0x6c,
-0x76, 0x69, 0x6e, 0x67, 0x3b, 0x15, 0x03, 0x92, 0x63, 0x61,
-0x6e, 0x00, 0x62, 0x65, 0x00, 0x75, 0x73, 0x37, 0x01, 0x41,
-0x68, 0x69, 0x67, 0x68, 0x76, 0x00, 0x04, 0xc4, 0x01, 0x00,
-0x7b, 0x00, 0x01, 0x26, 0x00, 0x51, 0x6e, 0x6f, 0x74, 0x00,
-0x62, 0xa3, 0x02, 0x10, 0x2c, 0x9f, 0x01, 0x00, 0x5d, 0x02,
-0x52, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x04, 0x01, 0xeb,
-0x01, 0x31, 0x6e, 0x6f, 0x74, 0xde, 0x03, 0x17, 0x65, 0xbb,
-0x00, 0x03, 0x81, 0x00, 0x23, 0x65, 0x64, 0x51, 0x00, 0x52,
-0x2c, 0x00, 0x6e, 0x6f, 0x72, 0x26, 0x00, 0x04, 0x9c, 0x00,
-0x21, 0x69, 0x6e, 0x30, 0x00, 0x04, 0x73, 0x00, 0x01, 0x63,
-0x03, 0x02, 0x5c, 0x03, 0x02, 0x20, 0x01, 0x07, 0x95, 0x00,
-0xd1, 0x6f, 0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x65,
-0x72, 0x72, 0x6f, 0x72, 0xe2, 0x03, 0x00, 0x86, 0x04, 0x02,
-0x09, 0x02, 0x05, 0x2a, 0x03, 0x07, 0x28, 0x03, 0x01, 0x57,
-0x03, 0x06, 0x40, 0x00, 0x01, 0xe3, 0x04, 0x01, 0x1b, 0x02,
-0x00, 0xcc, 0x03, 0x3a, 0x2c, 0x00, 0x61, 0xcf, 0x04, 0x05,
-0xf4, 0x00, 0x81, 0x77, 0x68, 0x69, 0x63, 0x68, 0x00, 0x64,
-0x6f, 0xd2, 0x00, 0x33, 0x28, 0x6f, 0x72, 0x00, 0x01, 0x10,
-0x29, 0xcd, 0x02, 0x02, 0xa8, 0x01, 0x10, 0x72, 0x4f, 0x00,
-0x0e, 0xd3, 0x02, 0x39, 0x6e, 0x65, 0x78, 0xcf, 0x02, 0x50,
-0x54, 0x68, 0x75, 0x73, 0x2c, 0x0e, 0x00, 0x02, 0x7c, 0x05,
-0x21, 0x69, 0x73, 0x7c, 0x01, 0x94, 0x65, 0x64, 0x00, 0x77,
-0x68, 0x65, 0x6e, 0x00, 0x61, 0x09, 0x04, 0x0e, 0xbb, 0x03,
-0x20, 0x79, 0x65, 0x3e, 0x04, 0x06, 0xba, 0x00, 0x10, 0x73,
-0x7b, 0x03, 0x02, 0xc6, 0x01, 0x02, 0xb3, 0x00, 0x10, 0x6f,
-0xfa, 0x00, 0x03, 0x77, 0x00, 0x00, 0x6a, 0x00, 0x23, 0x28,
-0x41, 0x70, 0x05, 0x21, 0x61, 0x63, 0x6b, 0x04, 0x82, 0x00,
-0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0xf3, 0x00, 0x13,
-0x73, 0x06, 0x03, 0x31, 0x32, 0x2e, 0x31, 0x3f, 0x00, 0xf3,
-0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x61, 0x76, 0x61, 0x69,
-0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0xc8, 0x02, 0x16, 0x32,
-0xc8, 0x02, 0xb2, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x73, 0x20, 0x8f, 0x01, 0x35, 0x73, 0x65, 0x00,
-0x14, 0x00, 0x01, 0x36, 0x01, 0x06, 0x3f, 0x00, 0x51, 0x00,
-0x66, 0x72, 0x6f, 0x6d, 0x7c, 0x00, 0xe1, 0x60, 0x43, 0x75,
-0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f,
-0x70, 0x72, 0x00, 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0xa0, 0x54,
-0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xae,
-0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48,
-0x65, 0x47, 0x01, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0xf3,
-0x02, 0x03, 0x26, 0x01, 0x16, 0x6e, 0xa2, 0x06, 0xa1, 0x00,
-0x00, 0x25, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x25,
-0x01, 0x14, 0x20, 0x25, 0x01, 0xb0, 0x00, 0x00, 0x52, 0x6f,
-0x75, 0x67, 0x68, 0x00, 0x70, 0x65, 0x72, 0x43, 0x04, 0x20,
-0x61, 0x67, 0x3f, 0x00, 0x0b, 0x7e, 0x04, 0x25, 0x69, 0x6e,
-0x7a, 0x01, 0x01, 0x8c, 0x01, 0x00, 0xf7, 0x01, 0x10, 0x69,
-0x12, 0x03, 0x70, 0x68, 0x69, 0x6e, 0x74, 0x00, 0x72, 0x61,
-0x4e, 0x01, 0x00, 0xdf, 0x02, 0xb1, 0x6e, 0x00, 0x61, 0x6e,
-0x00, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x26, 0x01, 0x46,
-0x2e, 0x00, 0x49, 0x66, 0xb4, 0x01, 0x90, 0x67, 0x65, 0x6e,
-0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x00, 0x21, 0x75,
-0x6e, 0xf1, 0x00, 0x24, 0x74, 0x6f, 0x17, 0x00, 0x33, 0x65,
-0x00, 0x61, 0xa4, 0x04, 0x04, 0x75, 0x04, 0x00, 0xc3, 0x03,
-0xe0, 0x63, 0x69, 0x73, 0x65, 0x00, 0x73, 0x70, 0x65, 0x63,
-0x69, 0x66, 0x69, 0x63, 0x61, 0x54, 0x00, 0x42, 0x2c, 0x00,
-0x69, 0x74, 0xcd, 0x02, 0x74, 0x69, 0x6e, 0x63, 0x72, 0x65,
-0x61, 0x73, 0xef, 0x03, 0x40, 0x6f, 0x70, 0x6f, 0x72, 0x21,
-0x00, 0x0e, 0xbf, 0x00, 0x53, 0x75, 0x6e, 0x74, 0x69, 0x6c,
-0xa3, 0x03, 0x10, 0x2e, 0x24, 0x01, 0xb0, 0x79, 0x6d, 0x6d,
-0x65, 0x74, 0x72, 0x79, 0x00, 0x00, 0x00, 0x41, 0x1d, 0x02,
-0x11, 0x73, 0x78, 0x06, 0x23, 0x74, 0x6f, 0x69, 0x00, 0x12,
-0x79, 0x98, 0x02, 0x41, 0x65, 0x71, 0x75, 0x69, 0xcb, 0x02,
-0x03, 0x2e, 0x00, 0x0d, 0xc5, 0x07, 0x0e, 0x1b, 0x01, 0x11,
-0x28, 0x1a, 0x01, 0x41, 0x64, 0x6f, 0x65, 0x73, 0xf0, 0x02,
-0x61, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x20, 0x00, 0x94,
-0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x47,
-0x00, 0x02, 0xec, 0x00, 0x02, 0x29, 0x00, 0x71, 0x69, 0x63,
-0x65, 0x61, 0x62, 0x6c, 0x79, 0x3d, 0x02, 0x16, 0x44, 0x29,
-0x00, 0x70, 0x00, 0x00, 0x60, 0x45, 0x61, 0x73, 0x79, 0xec,
-0x01, 0x22, 0x61, 0x6e, 0x3f, 0x04, 0x09, 0x3a, 0x00, 0x90,
-0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x62, 0x65, 0x0b,
-0x03, 0x32, 0x75, 0x62, 0x6c, 0xa0, 0x07, 0xb1, 0x6f, 0x75,
-0x74, 0x00, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0xd6,
-0x04, 0x00, 0xa0, 0x07, 0xf8, 0x00, 0x67, 0x75, 0x65, 0x73,
-0x73, 0x69, 0x6e, 0x67, 0x2c, 0x00, 0x60, 0x48, 0x61, 0x72,
-0x64, 0x52, 0x00, 0x01, 0x2e, 0x08, 0x02, 0x21, 0x00, 0x21,
-0x65, 0x73, 0x58, 0x01, 0x00, 0x4b, 0x01, 0x10, 0x62, 0x90,
-0x00, 0x00, 0x5a, 0x00, 0xb0, 0x6e, 0x65, 0x63, 0x65, 0x73,
-0x73, 0x61, 0x72, 0x79, 0x2e, 0x00,
+0xc8, 0x01, 0xf1, 0x01, 0x5b, 0x39, 0x5d, 0x00, 0x68, 0x74,
+0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e,
+0x5c, 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f,
+0x65, 0x6e, 0x2f, 0x7b, 0x00, 0xf1, 0x04, 0x73, 0x2f, 0x61,
+0x6b, 0x61, 0x72, 0x69, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x00,
+0x28, 0x62, 0x65, 0x77, 0x61, 0x72, 0xa7, 0x02, 0xd6, 0x46,
+0x6c, 0x61, 0x73, 0x68, 0x29, 0x00, 0x00, 0x00, 0x32, 0x31,
+0x2e, 0x31, 0x71, 0x03, 0x01, 0x86, 0x00, 0x40, 0x6f, 0x6c,
+0x73, 0x20, 0x9f, 0x00, 0x72, 0x65, 0x66, 0x74, 0x2d, 0x63,
+0x6c, 0x69, 0x41, 0x02, 0x4d, 0x69, 0x6e, 0x00, 0x61, 0xf7,
+0x01, 0x30, 0x00, 0x77, 0x69, 0x27, 0x03, 0x51, 0x6f, 0x67,
+0x67, 0x6c, 0x65, 0x56, 0x01, 0x71, 0x70, 0x72, 0x65, 0x73,
+0x65, 0x6e, 0x63, 0x63, 0x00, 0x14, 0x61, 0x04, 0x02, 0x12,
+0x6e, 0xc2, 0x01, 0x02, 0x33, 0x00, 0x30, 0x2e, 0x00, 0x52,
+0x16, 0x00, 0x0f, 0x59, 0x00, 0x0d, 0x02, 0x54, 0x00, 0x00,
+0xd3, 0x02, 0x40, 0x6d, 0x61, 0x72, 0x6b, 0x5c, 0x00, 0x01,
+0x15, 0x00, 0xd0, 0x00, 0x61, 0x69, 0x64, 0x00, 0x73, 0x6f,
+0x6c, 0x76, 0x69, 0x6e, 0x67, 0x3b, 0x15, 0x03, 0x92, 0x63,
+0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x75, 0x73, 0x37, 0x01,
+0x42, 0x68, 0x69, 0x67, 0x68, 0x76, 0x00, 0x04, 0xc4, 0x01,
+0x01, 0x7b, 0x00, 0x81, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+0x00, 0x62, 0xa3, 0x02, 0x11, 0x2c, 0x9f, 0x01, 0x83, 0x65,
+0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x04, 0x00,
+0xeb, 0x01, 0x00, 0x23, 0x00, 0x00, 0xde, 0x03, 0x18, 0x65,
+0xbb, 0x00, 0x02, 0x81, 0x00, 0x23, 0x65, 0x64, 0x51, 0x00,
+0x55, 0x2c, 0x00, 0x6e, 0x6f, 0x72, 0x26, 0x00, 0x01, 0x9c,
+0x00, 0x21, 0x69, 0x6e, 0x30, 0x00, 0x06, 0xe1, 0x00, 0x33,
+0x00, 0x00, 0x54, 0x5c, 0x03, 0x02, 0x20, 0x01, 0x06, 0x95,
+0x00, 0xd1, 0x6f, 0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00,
+0x65, 0x72, 0x72, 0x6f, 0x72, 0xe2, 0x03, 0x01, 0x86, 0x04,
+0x01, 0x7f, 0x01, 0x05, 0x2a, 0x03, 0x07, 0x28, 0x03, 0x02,
+0x57, 0x03, 0x05, 0x40, 0x00, 0x02, 0xe3, 0x04, 0x01, 0x1b,
+0x02, 0x6a, 0x77, 0x61, 0x79, 0x2c, 0x00, 0x61, 0xcf, 0x04,
+0x05, 0xf4, 0x00, 0x81, 0x77, 0x68, 0x69, 0x63, 0x68, 0x00,
+0x64, 0x6f, 0xd2, 0x00, 0x33, 0x28, 0x6f, 0x72, 0x00, 0x01,
+0x12, 0x29, 0xcd, 0x02, 0x00, 0xa8, 0x01, 0x11, 0x72, 0x8f,
+0x00, 0x0d, 0xd3, 0x02, 0x39, 0x6e, 0x65, 0x78, 0xcf, 0x02,
+0x52, 0x54, 0x68, 0x75, 0x73, 0x2c, 0x2a, 0x04, 0x00, 0x7c,
+0x05, 0x21, 0x69, 0x73, 0x7c, 0x01, 0x9e, 0x65, 0x64, 0x00,
+0x77, 0x68, 0x65, 0x6e, 0x00, 0x61, 0x09, 0x04, 0x04, 0xbb,
+0x03, 0x20, 0x79, 0x65, 0x3e, 0x04, 0x06, 0xba, 0x00, 0x12,
+0x73, 0x7b, 0x03, 0x01, 0xc6, 0x01, 0x01, 0xb3, 0x00, 0x10,
+0x6f, 0xfa, 0x00, 0x03, 0x77, 0x00, 0x00, 0x6a, 0x00, 0x23,
+0x28, 0x41, 0x70, 0x05, 0x21, 0x61, 0x63, 0x6b, 0x04, 0x82,
+0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0xf3, 0x00,
+0x13, 0x73, 0x06, 0x03, 0x31, 0x32, 0x2e, 0x31, 0x3f, 0x00,
+0xf3, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x61, 0x76, 0x61,
+0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0xc8, 0x02, 0x16,
+0x32, 0xc8, 0x02, 0xb2, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
+0x74, 0x65, 0x72, 0x73, 0x20, 0x8f, 0x01, 0x36, 0x73, 0x65,
+0x00, 0x14, 0x00, 0x02, 0x44, 0x00, 0x04, 0x3f, 0x00, 0x51,
+0x00, 0x66, 0x72, 0x6f, 0x6d, 0x7c, 0x00, 0xe1, 0x60, 0x43,
+0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00,
+0x6f, 0x70, 0x72, 0x00, 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0xa0,
+0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75,
+0xae, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00,
+0x48, 0x65, 0x47, 0x01, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a,
+0xf3, 0x02, 0x02, 0x26, 0x01, 0x16, 0x6e, 0xa2, 0x06, 0xa1,
+0x00, 0x00, 0x25, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20,
+0x25, 0x01, 0x14, 0x20, 0x25, 0x01, 0xb0, 0x00, 0x00, 0x52,
+0x6f, 0x75, 0x67, 0x68, 0x00, 0x70, 0x65, 0x72, 0x43, 0x04,
+0x21, 0x61, 0x67, 0x3f, 0x00, 0x0a, 0x49, 0x01, 0x25, 0x69,
+0x6e, 0x7a, 0x01, 0x02, 0x8c, 0x01, 0x40, 0x69, 0x73, 0x00,
+0x69, 0x12, 0x03, 0x71, 0x68, 0x69, 0x6e, 0x74, 0x00, 0x72,
+0x61, 0x27, 0x02, 0xe1, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x61,
+0x6e, 0x00, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x26, 0x01,
+0x46, 0x2e, 0x00, 0x49, 0x66, 0xb4, 0x01, 0x90, 0x67, 0x65,
+0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x3c, 0x00, 0x21,
+0x75, 0x6e, 0xf1, 0x00, 0x24, 0x74, 0x6f, 0x17, 0x00, 0x00,
+0xc5, 0x02, 0x03, 0xa4, 0x04, 0x04, 0x75, 0x04, 0xf0, 0x02,
+0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x65, 0x00, 0x73, 0x70,
+0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x54, 0x00, 0x10,
+0x2c, 0x6c, 0x03, 0x01, 0xcd, 0x02, 0x74, 0x69, 0x6e, 0x63,
+0x72, 0x65, 0x61, 0x73, 0xef, 0x03, 0x42, 0x6f, 0x70, 0x6f,
+0x72, 0x29, 0x01, 0x0c, 0xbf, 0x00, 0x53, 0x75, 0x6e, 0x74,
+0x69, 0x6c, 0xa3, 0x03, 0x10, 0x2e, 0x24, 0x01, 0xb0, 0x79,
+0x6d, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x00, 0x00, 0x00, 0x41,
+0x1d, 0x02, 0x11, 0x73, 0x78, 0x06, 0x23, 0x74, 0x6f, 0x69,
+0x00, 0x12, 0x79, 0x98, 0x02, 0x41, 0x65, 0x71, 0x75, 0x69,
+0xcb, 0x02, 0x04, 0x2e, 0x00, 0x0e, 0xc5, 0x07, 0x0c, 0x1b,
+0x01, 0x11, 0x28, 0x1a, 0x01, 0x10, 0x64, 0x63, 0x05, 0x00,
+0xf0, 0x02, 0x61, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x20,
+0x00, 0x95, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c,
+0x74, 0x47, 0x00, 0x03, 0x15, 0x05, 0x00, 0x29, 0x00, 0x71,
+0x69, 0x63, 0x65, 0x61, 0x62, 0x6c, 0x79, 0x3d, 0x02, 0x16,
+0x44, 0x29, 0x00, 0x70, 0x00, 0x00, 0x60, 0x45, 0x61, 0x73,
+0x79, 0xec, 0x01, 0x23, 0x61, 0x6e, 0x3f, 0x04, 0x08, 0x3a,
+0x00, 0x60, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4b, 0x04,
+0x62, 0x73, 0x6f, 0x6c, 0x75, 0x62, 0x6c, 0xa0, 0x07, 0xb2,
+0x6f, 0x75, 0x74, 0x00, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72,
+0x61, 0xd6, 0x04, 0xf9, 0x03, 0x6f, 0x72, 0x00, 0x67, 0x75,
+0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x2c, 0x00, 0x60, 0x48,
+0x61, 0x72, 0x64, 0x52, 0x00, 0x01, 0x2e, 0x08, 0x01, 0x21,
+0x00, 0x22, 0x65, 0x73, 0x58, 0x01, 0x40, 0x70, 0x72, 0x6f,
+0x62, 0x90, 0x00, 0x00, 0x5a, 0x00, 0xb0, 0x6e, 0x65, 0x63,
+0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2327;
diff --git a/apps/plugins/puzzles/help/loopy.c b/apps/plugins/puzzles/help/loopy.c
index 1c6e420fd3..eb4adedfc8 100644
--- a/apps/plugins/puzzles/help/loopy.c
+++ b/apps/plugins/puzzles/help/loopy.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -20,7 +20,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2260 comp 1602 ratio 0.70885 level 11 saved 658 */
+/* orig 2260 comp 1600 ratio 0.707965 level 10 saved 660 */
 const char help_text[] = {
 0xf1, 0x4e, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x33, 0x3a, 0x20, 0x4c, 0x6f, 0x6f, 0x70, 0x79, 0x20,
@@ -46,26 +46,26 @@ const char help_text[] = {
 0x6f, 0x6d, 0x8c, 0x00, 0x01, 0x28, 0x00, 0x21, 0x6f, 0x74,
 0xbb, 0x00, 0x61, 0x69, 0x6e, 0x00, 0x74, 0x68, 0x65, 0xdb,
 0x00, 0x50, 0x2e, 0x00, 0x00, 0x00, 0x53, 0x64, 0x00, 0x21,
-0x6f, 0x66, 0x14, 0x00, 0xd1, 0x73, 0x70, 0x61, 0x63, 0x65,
+0x6f, 0x66, 0x14, 0x00, 0xd2, 0x73, 0x70, 0x61, 0x63, 0x65,
 0x73, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x27, 0x00,
-0x02, 0x67, 0x00, 0x00, 0xb7, 0x00, 0xf4, 0x04, 0x74, 0x61,
+0x02, 0x67, 0x00, 0xf4, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x61,
 0x69, 0x6e, 0x00, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73,
 0x2e, 0x00, 0x54, 0x68, 0x65, 0x73, 0x65, 0x0f, 0x00, 0x06,
-0xfd, 0x00, 0xb7, 0x68, 0x6f, 0x77, 0x00, 0x6d, 0x61, 0x6e,
-0x79, 0x00, 0x6f, 0x66, 0x3e, 0x00, 0xb2, 0x61, 0x72, 0x6f,
+0xfd, 0x00, 0x84, 0x68, 0x6f, 0x77, 0x00, 0x6d, 0x61, 0x6e,
+0x79, 0x51, 0x00, 0x02, 0x3e, 0x00, 0xb2, 0x61, 0x72, 0x6f,
 0x75, 0x6e, 0x64, 0x00, 0x74, 0x68, 0x61, 0x74, 0x63, 0x00,
-0xa3, 0x00, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x70, 0x61, 0x72,
-0x74, 0x29, 0x00, 0x01, 0xae, 0x00, 0x33, 0x2e, 0x00, 0x54,
-0x0a, 0x00, 0x00, 0x3a, 0x01, 0x02, 0xd8, 0x00, 0x83, 0x6d,
+0xa5, 0x00, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x70, 0x61, 0x72,
+0x74, 0x29, 0x00, 0x31, 0x6f, 0x6f, 0x70, 0x56, 0x00, 0x02,
+0xb8, 0x00, 0x00, 0x3a, 0x01, 0x01, 0xd8, 0x00, 0x83, 0x6d,
 0x75, 0x73, 0x74, 0x00, 0x63, 0x6f, 0x72, 0x2e, 0x01, 0x70,
-0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x52, 0x01, 0x01,
-0x3a, 0x00, 0x01, 0x86, 0x00, 0x32, 0x63, 0x6c, 0x75, 0x0a,
+0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x52, 0x01, 0x03,
+0x3a, 0x00, 0x62, 0x73, 0x65, 0x00, 0x63, 0x6c, 0x75, 0x0a,
 0x01, 0x20, 0x62, 0x65, 0xa9, 0x00, 0x94, 0x73, 0x69, 0x64,
 0x65, 0x72, 0x65, 0x64, 0x00, 0x61, 0x38, 0x00, 0x90, 0x00,
 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0xef, 0x00,
-0x12, 0x49, 0xd7, 0x00, 0xd0, 0x64, 0x65, 0x66, 0x61, 0x75,
+0x12, 0x49, 0xd7, 0x00, 0xd2, 0x64, 0x65, 0x66, 0x61, 0x75,
 0x6c, 0x74, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x2c, 0x12, 0x00,
-0x01, 0xb2, 0x01, 0x02, 0xae, 0x01, 0x98, 0x72, 0x72, 0x61,
+0x00, 0xb2, 0x01, 0x01, 0xae, 0x01, 0x98, 0x72, 0x72, 0x61,
 0x6e, 0x67, 0x65, 0x64, 0x00, 0x69, 0x02, 0x02, 0x80, 0x73,
 0x71, 0x75, 0x61, 0x72, 0x65, 0x73, 0x3b, 0xe3, 0x00, 0x51,
 0x65, 0x76, 0x65, 0x72, 0x2c, 0xa4, 0x00, 0xf1, 0x19, 0x63,
@@ -91,10 +91,10 @@ const char help_text[] = {
 0x6e, 0x68, 0x01, 0x62, 0x65, 0x6e, 0x68, 0x61, 0x6e, 0x63,
 0x3c, 0x00, 0xf0, 0x05, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65,
 0x00, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x74,
-0x79, 0x70, 0x65, 0x73, 0x12, 0x01, 0x41, 0x6e, 0x6f, 0x6e,
-0x2d, 0x16, 0x01, 0x02, 0x4c, 0x02, 0x00, 0x54, 0x00, 0x73,
-0x4c, 0x61, 0x6d, 0x62, 0x72, 0x6f, 0x73, 0x08, 0x00, 0x41,
-0x75, 0x2e, 0x00, 0x00, 0xa6, 0x00, 0xd1, 0x00, 0x68, 0x74,
+0x79, 0x70, 0x65, 0x73, 0x12, 0x01, 0x42, 0x6e, 0x6f, 0x6e,
+0x2d, 0x16, 0x01, 0x02, 0x25, 0x01, 0xa3, 0x62, 0x79, 0x00,
+0x4c, 0x61, 0x6d, 0x62, 0x72, 0x6f, 0x73, 0x08, 0x00, 0x10,
+0x75, 0x9e, 0x00, 0x00, 0xa6, 0x00, 0xd1, 0x00, 0x68, 0x74,
 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e,
 0xbd, 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f,
 0x65, 0x6e, 0x2f, 0xe1, 0x00, 0x50, 0x73, 0x2f, 0x73, 0x6c,
@@ -107,82 +107,81 @@ const char help_text[] = {
 0x01, 0x00, 0x3c, 0x03, 0x60, 0x62, 0x75, 0x74, 0x74, 0x6f,
 0x6e, 0x94, 0x01, 0x18, 0x61, 0x33, 0x03, 0x01, 0x0e, 0x01,
 0xd4, 0x75, 0x72, 0x6e, 0x00, 0x69, 0x74, 0x00, 0x62, 0x6c,
-0x61, 0x63, 0x6b, 0x2c, 0xbe, 0x02, 0x31, 0x69, 0x6e, 0x67,
-0xa3, 0x02, 0x01, 0xd9, 0x01, 0x00, 0x27, 0x03, 0x10, 0x6b,
+0x61, 0x63, 0x6b, 0x2c, 0xbe, 0x02, 0x32, 0x69, 0x6e, 0x67,
+0xa3, 0x02, 0x00, 0xd9, 0x01, 0x00, 0x27, 0x03, 0x10, 0x6b,
 0x24, 0x00, 0x2e, 0x69, 0x73, 0xa8, 0x02, 0x03, 0x71, 0x00,
-0x53, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x50, 0x00, 0x05, 0x2d,
-0x03, 0x04, 0xa0, 0x03, 0x03, 0x1e, 0x00, 0x84, 0x28, 0x6d,
-0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x0c, 0x04, 0x70, 0x6e,
+0x20, 0x61, 0x67, 0x13, 0x03, 0x04, 0x50, 0x00, 0x04, 0xef,
+0x02, 0x04, 0x6d, 0x00, 0x02, 0x1e, 0x00, 0x50, 0x28, 0x6d,
+0x65, 0x61, 0x6e, 0x5a, 0x00, 0x03, 0x0c, 0x04, 0x70, 0x6e,
 0x27, 0x74, 0x00, 0x73, 0x75, 0x72, 0x26, 0x00, 0x21, 0x74,
-0x29, 0x90, 0x02, 0x14, 0x66, 0x1b, 0x00, 0x01, 0x18, 0x00,
-0x02, 0x82, 0x00, 0x11, 0x61, 0x74, 0x00, 0x20, 0x69, 0x63,
-0x48, 0x02, 0x02, 0x55, 0x00, 0x61, 0x73, 0x65, 0x67, 0x6d,
+0x29, 0x90, 0x02, 0x15, 0x66, 0x27, 0x04, 0x01, 0x18, 0x00,
+0x01, 0x82, 0x00, 0x11, 0x61, 0x74, 0x00, 0x21, 0x69, 0x63,
+0x48, 0x02, 0x01, 0x55, 0x00, 0x61, 0x73, 0x65, 0x67, 0x6d,
 0x65, 0x6e, 0x8f, 0x00, 0x3d, 0x6e, 0x6f, 0x74, 0x93, 0x00,
-0x06, 0x8e, 0x02, 0x15, 0x63, 0x0c, 0x01, 0x49, 0x72, 0x69,
-0x67, 0x68, 0x0d, 0x01, 0x01, 0xac, 0x00, 0x80, 0x72, 0x65,
+0x06, 0x8e, 0x02, 0x15, 0x63, 0x0c, 0x01, 0x4b, 0x72, 0x69,
+0x67, 0x68, 0x0d, 0x01, 0xb0, 0x74, 0x6f, 0x00, 0x72, 0x65,
 0x6d, 0x6f, 0x76, 0x65, 0x00, 0x69, 0x56, 0x03, 0xb0, 0x6d,
 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x2e, 0x00, 0x41,
-0xad, 0x00, 0x12, 0x2c, 0x3d, 0x00, 0x30, 0x69, 0x6e, 0x67,
-0x4f, 0x04, 0x30, 0x65, 0x63, 0x6f, 0xb4, 0x03, 0x8b, 0x69,
+0xad, 0x00, 0x12, 0x2c, 0x3d, 0x00, 0x00, 0xae, 0x00, 0x60,
+0x61, 0x00, 0x73, 0x65, 0x63, 0x6f, 0xb4, 0x03, 0x8b, 0x69,
 0x6d, 0x65, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0xe5, 0x00, 0x20,
 0x62, 0x61, 0x66, 0x00, 0x13, 0x6f, 0xed, 0x00, 0x00, 0xc9,
 0x00, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x20, 0x00, 0x11, 0x61,
 0x63, 0x02, 0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72,
-0x69, 0x62, 0x49, 0x03, 0x13, 0x73, 0x79, 0x02, 0x30, 0x32,
-0x2e, 0x31, 0xec, 0x00, 0x02, 0x35, 0x03, 0xa3, 0x61, 0x76,
+0x69, 0x62, 0x49, 0x03, 0x13, 0x73, 0x79, 0x02, 0x33, 0x32,
+0x2e, 0x31, 0x13, 0x05, 0xd3, 0x73, 0x6f, 0x00, 0x61, 0x76,
 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0xdd, 0x01,
-0x13, 0x32, 0xdd, 0x01, 0x90, 0x70, 0x61, 0x72, 0x61, 0x6d,
-0x65, 0x74, 0x65, 0x72, 0xdf, 0x01, 0x03, 0x6c, 0x04, 0x05,
-0x14, 0x00, 0x01, 0xa6, 0x03, 0x06, 0x3c, 0x00, 0x01, 0xe4,
-0x04, 0x01, 0x79, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74,
+0x13, 0x32, 0xdd, 0x01, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d,
+0x65, 0x74, 0x65, 0x72, 0xdf, 0x01, 0x02, 0x6c, 0x04, 0x06,
+0x14, 0x00, 0x02, 0x41, 0x00, 0x04, 0x3c, 0x00, 0x02, 0xe4,
+0x04, 0x00, 0x79, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74,
 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6f,
 0x00, 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0x91, 0x54, 0x79, 0x70,
-0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x94, 0x02, 0x90, 0x57,
+0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x94, 0x02, 0x91, 0x57,
 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x22, 0x01,
-0x00, 0x03, 0x05, 0x20, 0x69, 0x7a, 0x68, 0x02, 0x01, 0xc7,
+0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x68, 0x02, 0x00, 0xc7,
 0x02, 0x70, 0x2c, 0x00, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x41,
 0x04, 0x05, 0xf0, 0x04, 0x00, 0x1c, 0x00, 0x31, 0x72, 0x65,
 0x67, 0xd6, 0x00, 0x61, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73,
 0x32, 0x03, 0x93, 0x64, 0x6f, 0x77, 0x6e, 0x2e, 0x00, 0x46,
-0x6f, 0x72, 0x1d, 0x04, 0x04, 0xe5, 0x03, 0xa0, 0x69, 0x74,
-0x27, 0x73, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x2d, 0x04,
-0x02, 0x7c, 0x03, 0x01, 0x7f, 0x03, 0x61, 0x75, 0x6e, 0x74,
-0x65, 0x64, 0x3b, 0xe2, 0x03, 0x10, 0x6f, 0xed, 0x02, 0x02,
-0x4c, 0x03, 0x04, 0x7a, 0x00, 0x01, 0xc3, 0x01, 0x70, 0x6d,
-0x61, 0x79, 0x00, 0x68, 0x61, 0x76, 0xa7, 0x02, 0x03, 0x84,
-0x02, 0x41, 0x61, 0x00, 0x62, 0x69, 0xc0, 0x05, 0x21, 0x73,
-0x65, 0x60, 0x05, 0x02, 0xad, 0x04, 0x52, 0x69, 0x6d, 0x65,
-0x6e, 0x73, 0x91, 0x00, 0x24, 0x72, 0x65, 0xb3, 0x00, 0x01,
-0xd0, 0x05, 0x50, 0x47, 0x72, 0x69, 0x64, 0x20, 0x59, 0x00,
-0x40, 0x00, 0x00, 0x00, 0x41, 0x9d, 0x01, 0x01, 0x88, 0x06,
-0x01, 0x7c, 0x06, 0x54, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0xde,
-0x05, 0x01, 0xe4, 0x01, 0x04, 0x10, 0x04, 0x26, 0x6f, 0x66,
-0x8c, 0x00, 0x71, 0x74, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x2e,
-0x19, 0x06, 0x02, 0x8c, 0x00, 0x13, 0x61, 0xda, 0x01, 0x10,
-0x66, 0x1e, 0x06, 0x02, 0x29, 0x06, 0x21, 0x61, 0x6d, 0x55,
+0x6f, 0x72, 0x1d, 0x04, 0x04, 0xe5, 0x03, 0xa1, 0x69, 0x74,
+0x27, 0x73, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x10, 0x05,
+0x01, 0x7c, 0x03, 0x01, 0x7f, 0x03, 0x61, 0x75, 0x6e, 0x74,
+0x65, 0x64, 0x3b, 0xe2, 0x03, 0x10, 0x6f, 0xed, 0x02, 0x06,
+0x4c, 0x03, 0x01, 0x41, 0x03, 0x00, 0xc3, 0x01, 0x72, 0x6d,
+0x61, 0x79, 0x00, 0x68, 0x61, 0x76, 0xa7, 0x02, 0x01, 0x84,
+0x02, 0x41, 0x61, 0x00, 0x62, 0x69, 0xc0, 0x05, 0x22, 0x73,
+0x65, 0x60, 0x05, 0x01, 0xad, 0x04, 0x52, 0x69, 0x6d, 0x65,
+0x6e, 0x73, 0x91, 0x00, 0x25, 0x72, 0x65, 0xb3, 0x00, 0x00,
+0xdd, 0x00, 0x50, 0x47, 0x72, 0x69, 0x64, 0x20, 0x59, 0x00,
+0x40, 0x00, 0x00, 0x00, 0x41, 0x9d, 0x01, 0x02, 0x88, 0x06,
+0x00, 0x7c, 0x06, 0x20, 0x68, 0x6f, 0x40, 0x06, 0x04, 0xde,
+0x05, 0x00, 0xe4, 0x01, 0x04, 0x10, 0x04, 0x26, 0x6f, 0x66,
+0x8c, 0x00, 0x72, 0x74, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x2e,
+0x19, 0x06, 0x01, 0x8c, 0x00, 0x13, 0x61, 0xda, 0x01, 0x11,
+0x66, 0x1e, 0x06, 0x01, 0x29, 0x06, 0x21, 0x61, 0x6d, 0x55,
 0x02, 0x06, 0xb0, 0x00, 0x70, 0x6d, 0x75, 0x6c, 0x74, 0x69,
-0x70, 0x6c, 0x9b, 0x00, 0x76, 0x66, 0x66, 0x65, 0x72, 0x65,
-0x6e, 0x74, 0x52, 0x00, 0xc1, 0x76, 0x65, 0x72, 0x74, 0x65,
+0x70, 0x6c, 0x9b, 0x00, 0x40, 0x66, 0x66, 0x65, 0x72, 0xac,
+0x02, 0x05, 0x52, 0x00, 0xc1, 0x76, 0x65, 0x72, 0x74, 0x65,
 0x78, 0x00, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x3f, 0x00, 0x50,
 0x43, 0x61, 0x69, 0x72, 0x6f, 0x0d, 0x05, 0x51, 0x4b, 0x69,
 0x74, 0x65, 0x73, 0x85, 0x05, 0x22, 0x29, 0x3b, 0x14, 0x01,
-0x19, 0x73, 0x73, 0x00, 0x01, 0x3b, 0x00, 0x1f, 0x69, 0x76,
+0x1a, 0x73, 0x73, 0x00, 0x00, 0x3b, 0x00, 0x1f, 0x69, 0x76,
 0x00, 0x07, 0x0e, 0x6d, 0x00, 0x01, 0xa5, 0x00, 0x07, 0x6b,
 0x00, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x20, 0x48, 0x89,
-0x05, 0x11, 0x29, 0x65, 0x06, 0x03, 0xb1, 0x01, 0x17, 0x2c,
-0xaf, 0x05, 0x01, 0xd2, 0x01, 0x91, 0x68, 0x6f, 0x6e, 0x65,
-0x79, 0x63, 0x6f, 0x6d, 0x62, 0x91, 0x01, 0x02, 0x5c, 0x01,
+0x05, 0x12, 0x29, 0x65, 0x06, 0x02, 0xb1, 0x01, 0x18, 0x2c,
+0xaf, 0x05, 0x00, 0xd2, 0x01, 0x92, 0x68, 0x6f, 0x6e, 0x65,
+0x79, 0x63, 0x6f, 0x6d, 0x62, 0xcb, 0x01, 0x01, 0x5c, 0x01,
 0x20, 0x66, 0x75, 0x50, 0x05, 0x21, 0x72, 0x65, 0x26, 0x00,
-0x01, 0x2b, 0x05, 0x09, 0xa2, 0x00, 0x24, 0x69, 0x72, 0xa4,
-0x00, 0x01, 0x15, 0x02, 0x0b, 0x24, 0x01, 0x12, 0x3b, 0xfe,
+0x02, 0x2b, 0x05, 0x08, 0xa2, 0x00, 0x26, 0x69, 0x72, 0xa4,
+0x00, 0x00, 0x1c, 0x00, 0x0a, 0x24, 0x01, 0x12, 0x3b, 0xfe,
 0x01, 0x32, 0x6d, 0x61, 0x6b, 0x15, 0x00, 0x13, 0x6d, 0xa6,
 0x04, 0x11, 0x61, 0xd6, 0x06, 0x41, 0x6e, 0x66, 0x75, 0x73,
 0x76, 0x04, 0x02, 0x40, 0x06, 0x00, 0xbe, 0x01, 0x40, 0x44,
 0x69, 0x66, 0x66, 0xf8, 0x03, 0x20, 0x74, 0x79, 0xd8, 0x04,
-0x03, 0xe4, 0x04, 0x02, 0xf3, 0x01, 0x04, 0x1a, 0x00, 0x05,
-0x5d, 0x07, 0xf0, 0x03, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
-0x74, 0x65, 0x64, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65,
-0x2e, 0x00,
+0x03, 0xe4, 0x04, 0x03, 0xf3, 0x01, 0x05, 0x1a, 0x00, 0x03,
+0xf9, 0x03, 0x60, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0xe2,
+0x05, 0x80, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2260;
diff --git a/apps/plugins/puzzles/help/magnets.c b/apps/plugins/puzzles/help/magnets.c
index eed84c78b6..becfe20902 100644
--- a/apps/plugins/puzzles/help/magnets.c
+++ b/apps/plugins/puzzles/help/magnets.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -17,7 +17,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2502 comp 1650 ratio 0.659472 level 11 saved 852 */
+/* orig 2502 comp 1653 ratio 0.660671 level 10 saved 849 */
 const char help_text[] = {
 0xf2, 0x3e, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x33, 0x3a, 0x20, 0x4d, 0x61, 0x67, 0x6e, 0x65, 0x74,
@@ -32,56 +32,56 @@ const char help_text[] = {
 0x65, 0x73, 0x2d, 0x00, 0xf1, 0x05, 0x6f, 0x6e, 0x65, 0x00,
 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x00, 0x65,
 0x6e, 0x64, 0x00, 0x61, 0x6e, 0x64, 0x15, 0x00, 0x44, 0x6e,
-0x65, 0x67, 0x61, 0x15, 0x00, 0x11, 0x29, 0x16, 0x00, 0x54,
+0x65, 0x67, 0x61, 0x15, 0x00, 0x11, 0x29, 0x16, 0x00, 0x56,
 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x3f, 0x00, 0x0f, 0x52, 0x00,
-0x07, 0xf6, 0x0a, 0x74, 0x77, 0x6f, 0x00, 0x6e, 0x65, 0x75,
+0x05, 0xf6, 0x0a, 0x74, 0x77, 0x6f, 0x00, 0x6e, 0x65, 0x75,
 0x74, 0x72, 0x61, 0x6c, 0x00, 0x70, 0x6f, 0x6c, 0x65, 0x73,
 0x29, 0x2e, 0x00, 0x54, 0x68, 0x65, 0x73, 0x65, 0x28, 0x00,
 0xf0, 0x05, 0x61, 0x72, 0x65, 0x00, 0x69, 0x6e, 0x69, 0x74,
 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x6c, 0x79,
-0x00, 0x73, 0xc6, 0x00, 0xf1, 0x0a, 0x69, 0x6e, 0x00, 0x73,
+0x00, 0x73, 0xc6, 0x00, 0xf2, 0x0a, 0x69, 0x6e, 0x00, 0x73,
 0x69, 0x6c, 0x68, 0x6f, 0x75, 0x65, 0x74, 0x74, 0x65, 0x2e,
 0x00, 0x41, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x74, 0x68,
-0x65, 0xee, 0x00, 0x01, 0x37, 0x00, 0xf0, 0x00, 0x70, 0x6c,
+0x65, 0xee, 0x00, 0x00, 0x37, 0x00, 0xf0, 0x00, 0x70, 0x6c,
 0x61, 0x63, 0x65, 0x64, 0x00, 0x61, 0x00, 0x6e, 0x75, 0x6d,
-0x62, 0x65, 0x72, 0xe3, 0x00, 0xf0, 0x01, 0x63, 0x6c, 0x75,
+0x62, 0x65, 0x72, 0xe3, 0x00, 0xf1, 0x01, 0x63, 0x6c, 0x75,
 0x65, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74,
 0x69, 0x6e, 0x67, 0x31, 0x00, 0x06, 0x1f, 0x00, 0x05, 0xde,
-0x00, 0x00, 0xc4, 0x00, 0x05, 0xd6, 0x00, 0x02, 0x9a, 0x00,
+0x00, 0x00, 0xc4, 0x00, 0x05, 0xd6, 0x00, 0x01, 0x9a, 0x00,
 0xa0, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65,
 0x64, 0x7b, 0x00, 0x50, 0x63, 0x65, 0x72, 0x74, 0x61, 0x08,
 0x00, 0x61, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x30, 0x00,
 0xf0, 0x0b, 0x72, 0x6f, 0x77, 0x73, 0x2e, 0x00, 0x00, 0x00,
 0x59, 0x6f, 0x75, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00, 0x69,
 0x73, 0x00, 0x74, 0x6f, 0x00, 0x63, 0x6f, 0x72, 0x8c, 0x01,
-0x22, 0x6c, 0x79, 0x90, 0x00, 0x00, 0x72, 0x00, 0x04, 0x6a,
-0x01, 0x0f, 0x2b, 0x01, 0x01, 0x51, 0x73, 0x75, 0x63, 0x68,
-0x00, 0x2f, 0x01, 0x30, 0x61, 0x6c, 0x6c, 0x2d, 0x00, 0x00,
-0xb4, 0x00, 0x03, 0x08, 0x01, 0xa1, 0x73, 0x61, 0x74, 0x69,
-0x73, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x3f, 0x01, 0x01, 0x1e,
-0x00, 0xa0, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+0x22, 0x6c, 0x79, 0x90, 0x00, 0x01, 0x72, 0x00, 0x04, 0x6a,
+0x01, 0x0f, 0x2b, 0x01, 0x00, 0x51, 0x73, 0x75, 0x63, 0x68,
+0x00, 0x2f, 0x01, 0x31, 0x61, 0x6c, 0x6c, 0x2d, 0x00, 0x02,
+0xb4, 0x00, 0x00, 0xd1, 0x00, 0xa3, 0x73, 0x61, 0x74, 0x69,
+0x73, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x3f, 0x01, 0xd0, 0x68,
+0x65, 0x00, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
 0x61, 0x6c, 0xa2, 0x00, 0x72, 0x73, 0x74, 0x72, 0x61, 0x69,
-0x6e, 0x74, 0x41, 0x00, 0x21, 0x6e, 0x6f, 0x61, 0x01, 0x73,
-0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x75, 0x00, 0x23,
+0x6e, 0x74, 0x41, 0x00, 0x21, 0x6e, 0x6f, 0x61, 0x01, 0x40,
+0x73, 0x69, 0x6d, 0x69, 0x06, 0x02, 0x02, 0x75, 0x00, 0x23,
 0x69, 0x63, 0xd0, 0x00, 0xf1, 0x00, 0x6d, 0x61, 0x79, 0x00,
 0x62, 0x65, 0x00, 0x6f, 0x72, 0x74, 0x68, 0x6f, 0x67, 0x6f,
 0x6e, 0x5f, 0x01, 0xd2, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65,
 0x6e, 0x74, 0x00, 0x28, 0x73, 0x69, 0x6e, 0xac, 0x00, 0xb8,
 0x79, 0x00, 0x72, 0x65, 0x70, 0x65, 0x6c, 0x29, 0x2e, 0x00,
 0x4e, 0xa9, 0x01, 0x72, 0x00, 0x64, 0x6f, 0x00, 0x6e, 0x6f,
-0x74, 0x1d, 0x00, 0x11, 0x2c, 0xc9, 0x00, 0x65, 0x63, 0x61,
-0x6e, 0x00, 0x62, 0x65, 0x44, 0x00, 0x00, 0xfc, 0x00, 0x91,
+0x74, 0x1d, 0x00, 0x11, 0x2c, 0xc9, 0x00, 0x30, 0x63, 0x61,
+0x6e, 0x51, 0x00, 0x05, 0x44, 0x00, 0xc1, 0x74, 0x6f, 0x00,
 0x61, 0x6e, 0x79, 0x00, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x35,
 0x00, 0x00, 0x1d, 0x01, 0xf1, 0x0b, 0x43, 0x72, 0x65, 0x64,
 0x69, 0x74, 0x00, 0x66, 0x6f, 0x72, 0x00, 0x74, 0x68, 0x69,
 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x67,
 0x6f, 0x65, 0x2d, 0x01, 0xa0, 0x4a, 0x61, 0x6e, 0x6b, 0x6f,
 0x00, 0x5b, 0x31, 0x36, 0x5d, 0x2d, 0x00, 0x13, 0x4d, 0x27,
-0x01, 0x22, 0x77, 0x61, 0x7f, 0x01, 0xa1, 0x72, 0x69, 0x62,
-0x75, 0x74, 0x65, 0x64, 0x00, 0x74, 0x6f, 0x3d, 0x00, 0x00,
-0x7e, 0x01, 0x30, 0x6c, 0x65, 0x63, 0xfe, 0x00, 0xf1, 0x04,
+0x01, 0x22, 0x77, 0x61, 0x7f, 0x01, 0x70, 0x72, 0x69, 0x62,
+0x75, 0x74, 0x65, 0x64, 0x29, 0x00, 0x01, 0x3d, 0x00, 0x60,
+0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0xfe, 0x00, 0xf0, 0x01,
 0x00, 0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00,
-0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x2e, 0x00, 0x00, 0x46,
+0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x3e, 0x00, 0x00, 0x46,
 0x00, 0xd0, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
 0x77, 0x77, 0x77, 0x2e, 0x6a, 0x5c, 0x00, 0xc2, 0x2e, 0x61,
 0x74, 0x2f, 0x52, 0x61, 0x65, 0x74, 0x73, 0x65, 0x6c, 0x2f,
@@ -89,25 +89,25 @@ const char help_text[] = {
 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x00, 0x00, 0x00, 0x33, 0x33,
 0x2e, 0x31, 0x49, 0x03, 0x01, 0x74, 0x00, 0x21, 0x6f, 0x6c,
 0x52, 0x03, 0xa0, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c,
-0x69, 0x63, 0x6b, 0x37, 0x02, 0xf4, 0x00, 0x6f, 0x6e, 0x00,
+0x69, 0x63, 0x6b, 0x37, 0x02, 0xf5, 0x00, 0x6f, 0x6e, 0x00,
 0x61, 0x6e, 0x00, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x00, 0x73,
-0x71, 0x75, 0x6e, 0x02, 0x00, 0xa8, 0x01, 0x03, 0x68, 0x01,
-0x22, 0x00, 0x61, 0x86, 0x01, 0x03, 0x54, 0x02, 0x24, 0x6f,
-0x6e, 0xb3, 0x01, 0x02, 0x44, 0x03, 0x05, 0x59, 0x02, 0x30,
-0x00, 0x6f, 0x6e, 0x15, 0x00, 0x04, 0x46, 0x00, 0x11, 0x61,
-0xc5, 0x02, 0x02, 0x53, 0x03, 0x0c, 0x24, 0x00, 0x03, 0x4b,
-0x01, 0x77, 0x68, 0x61, 0x6c, 0x66, 0x00, 0x6f, 0x66, 0x49,
+0x71, 0x75, 0x6e, 0x02, 0x33, 0x73, 0x00, 0x61, 0x68, 0x01,
+0x23, 0x00, 0x61, 0x86, 0x01, 0x02, 0x54, 0x02, 0x26, 0x6f,
+0x6e, 0xb3, 0x01, 0x05, 0x66, 0x02, 0x00, 0x15, 0x01, 0x00,
+0x4b, 0x00, 0x00, 0x15, 0x00, 0x03, 0x46, 0x00, 0x13, 0x61,
+0xc5, 0x02, 0x09, 0x7d, 0x02, 0x04, 0x24, 0x00, 0x02, 0x4b,
+0x01, 0x40, 0x68, 0x61, 0x6c, 0x66, 0xad, 0x02, 0x06, 0x49,
 0x02, 0x39, 0x3b, 0x00, 0x6c, 0x9e, 0x00, 0x20, 0x61, 0x67,
 0x9c, 0x02, 0x83, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65,
 0x73, 0x74, 0x00, 0x62, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79,
 0xab, 0x01, 0x10, 0x61, 0x40, 0x01, 0x31, 0x72, 0x64, 0x00,
 0x32, 0x00, 0x87, 0x00, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
 0x73, 0x51, 0x00, 0x00, 0x3f, 0x01, 0x4f, 0x52, 0x69, 0x67,
-0x68, 0xf2, 0x00, 0x13, 0x09, 0xc3, 0x02, 0x10, 0x00, 0xa4,
-0x00, 0x21, 0x65, 0x2e, 0x3f, 0x00, 0x0c, 0x93, 0x00, 0x03,
-0x32, 0x00, 0x01, 0x96, 0x02, 0x41, 0x71, 0x75, 0x65, 0x73,
-0x17, 0x01, 0x52, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xe2, 0x00,
-0x04, 0xf7, 0x03, 0x90, 0x2c, 0x00, 0x73, 0x69, 0x67, 0x6e,
+0x68, 0xf2, 0x00, 0x14, 0x08, 0xc3, 0x02, 0x10, 0x00, 0xa4,
+0x00, 0x2c, 0x65, 0x2e, 0x3f, 0x00, 0x02, 0x93, 0x00, 0x03,
+0x32, 0x00, 0x00, 0x96, 0x02, 0x41, 0x71, 0x75, 0x65, 0x73,
+0x17, 0x01, 0x54, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0xe2, 0x00,
+0x02, 0x44, 0x00, 0x90, 0x2c, 0x00, 0x73, 0x69, 0x67, 0x6e,
 0x69, 0x66, 0x79, 0x3a, 0x00, 0x12, 0x60, 0xeb, 0x01, 0x20,
 0x61, 0x6e, 0x6f, 0x02, 0x22, 0x62, 0x65, 0x6d, 0x00, 0x84,
 0x27, 0x00, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x75, 0x02,
@@ -117,9 +117,9 @@ const char help_text[] = {
 0x73, 0x6f, 0x6c, 0x76, 0x69, 0x6e, 0x67, 0x29, 0x2c, 0xaa,
 0x03, 0x0e, 0x9c, 0x00, 0x02, 0xdb, 0x00, 0x37, 0x69, 0x65,
 0x73, 0x87, 0x00, 0x1d, 0x2e, 0xf7, 0x01, 0x11, 0x61, 0x8d,
-0x03, 0x51, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0xb8, 0x00, 0x80,
-0x00, 0x69, 0x74, 0x00, 0x61, 0x73, 0x00, 0x64, 0x05, 0x05,
-0x50, 0x28, 0x67, 0x72, 0x65, 0x79, 0x11, 0x00, 0xb4, 0x6f,
+0x03, 0x51, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0xb8, 0x00, 0x50,
+0x00, 0x69, 0x74, 0x00, 0x61, 0x0c, 0x03, 0x80, 0x6e, 0x65,
+0x00, 0x28, 0x67, 0x72, 0x65, 0x79, 0x11, 0x00, 0xb4, 0x6f,
 0x75, 0x74, 0x29, 0x2c, 0x00, 0x6f, 0x72, 0x00, 0x75, 0x6e,
 0x24, 0x00, 0x21, 0x69, 0x66, 0x06, 0x00, 0x91, 0x73, 0x00,
 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x3d, 0x00, 0x23,
@@ -129,61 +129,62 @@ const char help_text[] = {
 0x6d, 0x6f, 0x93, 0x04, 0x04, 0x16, 0x00, 0x1a, 0x61, 0xeb,
 0x04, 0x74, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0xcd,
 0x04, 0x60, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x00,
-0x02, 0xa7, 0x00, 0x53, 0x6c, 0x61, 0x79, 0x00, 0x61, 0xd1,
-0x00, 0x03, 0xf4, 0x05, 0x0a, 0x81, 0x02, 0x0d, 0xa9, 0x02,
-0x30, 0x3b, 0x00, 0x70, 0x51, 0x00, 0x0f, 0x49, 0x02, 0x0c,
-0x04, 0xaa, 0x02, 0x14, 0x6e, 0x3f, 0x02, 0x09, 0xc0, 0x01,
-0x12, 0x61, 0xe1, 0x05, 0x0a, 0x98, 0x02, 0x35, 0x2e, 0x00,
+0x02, 0xa7, 0x00, 0x54, 0x6c, 0x61, 0x79, 0x00, 0x61, 0x9c,
+0x01, 0x03, 0xf4, 0x05, 0x0a, 0x81, 0x02, 0x0c, 0xa9, 0x02,
+0x34, 0x3b, 0x00, 0x70, 0x51, 0x00, 0x0f, 0x49, 0x02, 0x08,
+0x04, 0xaa, 0x02, 0x19, 0x6e, 0x3f, 0x02, 0x04, 0xc0, 0x01,
+0x13, 0x61, 0xe1, 0x05, 0x09, 0x98, 0x02, 0x35, 0x2e, 0x00,
 0x55, 0xa7, 0x00, 0x20, 0x73, 0x70, 0x0c, 0x05, 0x30, 0x62,
 0x61, 0x72, 0xe7, 0x04, 0x32, 0x6f, 0x77, 0x73, 0x1b, 0x02,
-0x10, 0x6d, 0x38, 0x04, 0x2a, 0x6f, 0x66, 0x14, 0x05, 0x01,
-0x27, 0x05, 0x03, 0x01, 0x02, 0x42, 0x2d, 0x62, 0x65, 0x2d,
-0x1d, 0x00, 0x50, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x69, 0x00,
-0x00, 0x4c, 0x04, 0x03, 0xd2, 0x01, 0x16, 0x00, 0x6a, 0x00,
+0x10, 0x6d, 0x38, 0x04, 0x2c, 0x6f, 0x66, 0x14, 0x05, 0x03,
+0x5e, 0x04, 0x72, 0x6e, 0x6f, 0x74, 0x2d, 0x62, 0x65, 0x2d,
+0x1d, 0x00, 0x51, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x69, 0x00,
+0x00, 0x4c, 0x04, 0x02, 0xd2, 0x01, 0x16, 0x00, 0x6a, 0x00,
 0x43, 0x00, 0x00, 0x28, 0x41, 0x40, 0x05, 0x13, 0x61, 0x0a,
 0x02, 0x72, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0xc1,
-0x05, 0x13, 0x73, 0x38, 0x04, 0x30, 0x32, 0x2e, 0x31, 0x5b,
-0x05, 0x02, 0x7f, 0x01, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c,
+0x05, 0x13, 0x73, 0x38, 0x04, 0x31, 0x32, 0x2e, 0x31, 0x5b,
+0x05, 0x01, 0x7f, 0x01, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c,
 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29, 0x0b, 0x04, 0x15, 0x32,
-0x0b, 0x04, 0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x0d, 0x04, 0x03, 0xa4, 0x06, 0x05, 0x14, 0x00,
-0x01, 0x9e, 0x05, 0x06, 0x3e, 0x00, 0x51, 0x00, 0x66, 0x72,
-0x6f, 0x6d, 0x7b, 0x00, 0xe0, 0x60, 0x43, 0x75, 0x73, 0x74,
+0x0b, 0x04, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
+0x65, 0x72, 0x0d, 0x04, 0x02, 0xa4, 0x06, 0x06, 0x14, 0x00,
+0x02, 0x43, 0x00, 0x04, 0x3e, 0x00, 0x51, 0x00, 0x66, 0x72,
+0x6f, 0x6d, 0x7b, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74,
 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x71,
-0x00, 0x04, 0xe9, 0x02, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
+0x00, 0x03, 0xe9, 0x02, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xad, 0x00, 0x90, 0x57,
 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0xc8, 0x00,
-0x60, 0x00, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x93, 0x07, 0x02,
+0x61, 0x00, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x93, 0x07, 0x01,
 0xcc, 0x06, 0x23, 0x69, 0x6e, 0x72, 0x03, 0x11, 0x73, 0x1e,
-0x07, 0x13, 0x72, 0x81, 0x02, 0x21, 0x62, 0x65, 0x0b, 0x04,
-0x02, 0x3c, 0x00, 0x23, 0x00, 0x78, 0x3d, 0x00, 0x06, 0x36,
-0x01, 0x25, 0x69, 0x6e, 0x24, 0x02, 0x41, 0x3a, 0x00, 0x69,
-0x66, 0x33, 0x05, 0x03, 0xec, 0x06, 0x00, 0x8b, 0x02, 0x23,
-0x6f, 0x64, 0xc0, 0x01, 0x22, 0x6f, 0x6e, 0x7e, 0x04, 0x03,
-0x58, 0x00, 0x05, 0x64, 0x03, 0x01, 0x45, 0x01, 0x42, 0x47,
-0x72, 0x69, 0x64, 0xcc, 0x01, 0x00, 0x28, 0x02, 0x50, 0x6c,
-0x65, 0x61, 0x73, 0x74, 0x31, 0x00, 0x01, 0x3e, 0x00, 0x70,
-0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0xd2, 0x00, 0x20,
-0x65, 0x6e, 0x96, 0x05, 0x00, 0x3b, 0x00, 0x91, 0x65, 0x61,
-0x73, 0x69, 0x65, 0x72, 0x00, 0x74, 0x6f, 0x74, 0x03, 0x02,
+0x07, 0x13, 0x72, 0x81, 0x02, 0x22, 0x62, 0x65, 0x0b, 0x04,
+0x01, 0x3c, 0x00, 0x24, 0x00, 0x78, 0x3d, 0x00, 0x05, 0x36,
+0x01, 0x25, 0x69, 0x6e, 0x24, 0x02, 0x10, 0x3a, 0x82, 0x02,
+0x01, 0x48, 0x03, 0x03, 0xec, 0x06, 0x53, 0x69, 0x73, 0x00,
+0x6f, 0x64, 0xc0, 0x01, 0x25, 0x6f, 0x6e, 0x7e, 0x04, 0x04,
+0x58, 0x00, 0x01, 0x63, 0x01, 0x01, 0x45, 0x01, 0x53, 0x47,
+0x72, 0x69, 0x64, 0x73, 0x38, 0x02, 0x71, 0x74, 0x00, 0x6c,
+0x65, 0x61, 0x73, 0x74, 0x31, 0x00, 0x00, 0x3e, 0x00, 0x70,
+0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0xd2, 0x00, 0x21,
+0x65, 0x6e, 0x96, 0x05, 0x90, 0x62, 0x65, 0x00, 0x65, 0x61,
+0x73, 0x69, 0x65, 0x72, 0x0d, 0x00, 0x00, 0x74, 0x03, 0x02,
 0x4a, 0x01, 0xa0, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75,
-0x6c, 0x74, 0x79, 0x02, 0x06, 0x02, 0x55, 0x05, 0x03, 0x30,
-0x02, 0x05, 0x1a, 0x00, 0x04, 0xd2, 0x04, 0x92, 0x67, 0x65,
-0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x1b, 0x06, 0x00,
-0xdb, 0x07, 0xc0, 0x74, 0x00, 0x54, 0x72, 0x69, 0x63, 0x6b,
-0x79, 0x00, 0x6c, 0x65, 0x76, 0x6d, 0x06, 0x31, 0x79, 0x6f,
-0x75, 0x71, 0x01, 0x62, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
-0x10, 0x06, 0x89, 0x6d, 0x61, 0x6b, 0x65, 0x00, 0x6d, 0x6f,
-0x72, 0xfc, 0x03, 0x52, 0x61, 0x62, 0x6f, 0x75, 0x74, 0xb4,
-0x04, 0x04, 0x17, 0x01, 0x05, 0xab, 0x07, 0x11, 0x2f, 0xbb,
-0x07, 0x00, 0xc2, 0x07, 0x31, 0x75, 0x6e, 0x74, 0xb8, 0x07,
-0x62, 0x53, 0x74, 0x72, 0x69, 0x70, 0x20, 0x6e, 0x07, 0xe0,
-0x00, 0x00, 0x49, 0x66, 0x00, 0x74, 0x72, 0x75, 0x65, 0x2c,
-0x00, 0x73, 0x6f, 0x6d, 0x8b, 0x01, 0x08, 0x8b, 0x07, 0x0e,
-0x6c, 0x08, 0x02, 0x05, 0x03, 0x00, 0x6d, 0x08, 0x14, 0x74,
-0xc2, 0x00, 0x01, 0x18, 0x01, 0x40, 0x69, 0x6d, 0x65, 0x2c,
-0x9c, 0x00, 0x03, 0xf7, 0x02, 0x02, 0xd4, 0x00, 0x01, 0xa9,
-0x00, 0x04, 0xfc, 0x00, 0x50, 0x75, 0x6c, 0x74, 0x2e, 0x00,
+0x6c, 0x74, 0x79, 0x02, 0x06, 0x03, 0x55, 0x05, 0x02, 0x30,
+0x02, 0x06, 0x1a, 0x00, 0x03, 0xd2, 0x04, 0x60, 0x67, 0x65,
+0x6e, 0x65, 0x72, 0x61, 0xe6, 0x05, 0x02, 0x1b, 0x06, 0xf0,
+0x00, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x54, 0x72, 0x69, 0x63,
+0x6b, 0x79, 0x00, 0x6c, 0x65, 0x76, 0x6d, 0x06, 0x31, 0x79,
+0x6f, 0x75, 0x71, 0x01, 0x62, 0x72, 0x65, 0x71, 0x75, 0x69,
+0x72, 0x10, 0x06, 0x89, 0x6d, 0x61, 0x6b, 0x65, 0x00, 0x6d,
+0x6f, 0x72, 0xfc, 0x03, 0x53, 0x61, 0x62, 0x6f, 0x75, 0x74,
+0xb4, 0x04, 0x09, 0x4d, 0x02, 0x42, 0x72, 0x6f, 0x77, 0x2f,
+0xbb, 0x07, 0x61, 0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0xb8,
+0x07, 0x62, 0x53, 0x74, 0x72, 0x69, 0x70, 0x20, 0x6e, 0x07,
+0xe1, 0x00, 0x00, 0x49, 0x66, 0x00, 0x74, 0x72, 0x75, 0x65,
+0x2c, 0x00, 0x73, 0x6f, 0x6d, 0x8b, 0x01, 0x08, 0x8b, 0x07,
+0x0e, 0x6c, 0x08, 0x02, 0x05, 0x03, 0x10, 0x64, 0x25, 0x01,
+0x03, 0xc2, 0x00, 0x01, 0x18, 0x01, 0x40, 0x69, 0x6d, 0x65,
+0x2c, 0x9c, 0x00, 0x04, 0xf7, 0x02, 0x03, 0xef, 0x06, 0x02,
+0xa9, 0x00, 0xa0, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c,
+0x74, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2502;
diff --git a/apps/plugins/puzzles/help/map.c b/apps/plugins/puzzles/help/map.c
index 931ffeb05f..731b5f4745 100644
--- a/apps/plugins/puzzles/help/map.c
+++ b/apps/plugins/puzzles/help/map.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -18,7 +18,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3466 comp 2282 ratio 0.658396 level 11 saved 1184 */
+/* orig 3466 comp 2283 ratio 0.658684 level 10 saved 1183 */
 const char help_text[] = {
 0xf0, 0x2e, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x32, 0x3a, 0x20, 0x4d, 0x61, 0x70, 0x20, 0x00, 0x00,
@@ -31,7 +31,7 @@ const char help_text[] = {
 0x74, 0x61, 0x73, 0x6b, 0x00, 0x69, 0x73, 0x00, 0x74, 0x6f,
 0x00, 0x63, 0x6f, 0x6c, 0x12, 0x00, 0x43, 0x65, 0x61, 0x63,
 0x68, 0x25, 0x00, 0x90, 0x00, 0x77, 0x69, 0x74, 0x68, 0x00,
-0x6f, 0x6e, 0x65, 0x38, 0x00, 0x43, 0x66, 0x6f, 0x75, 0x72,
+0x6f, 0x6e, 0x65, 0x38, 0x00, 0x10, 0x66, 0x1d, 0x00, 0x02,
 0x24, 0x00, 0xf4, 0x0d, 0x73, 0x2c, 0x00, 0x69, 0x6e, 0x00,
 0x73, 0x75, 0x63, 0x68, 0x00, 0x61, 0x00, 0x77, 0x61, 0x79,
 0x00, 0x74, 0x68, 0x61, 0x74, 0x00, 0x6e, 0x6f, 0x00, 0x74,
@@ -44,211 +44,211 @@ const char help_text[] = {
 0x4c, 0x00, 0x73, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79,
 0x33, 0x00, 0xe0, 0x65, 0x64, 0x2c, 0x00, 0x73, 0x75, 0x66,
 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0xbb, 0x00, 0x32,
-0x6d, 0x61, 0x6b, 0x59, 0x00, 0x71, 0x72, 0x65, 0x6d, 0x61,
-0x69, 0x6e, 0x64, 0xea, 0x00, 0x02, 0x6a, 0x00, 0x40, 0x6f,
+0x6d, 0x61, 0x6b, 0x59, 0x00, 0x72, 0x72, 0x65, 0x6d, 0x61,
+0x69, 0x6e, 0x64, 0xea, 0x00, 0x01, 0x6a, 0x00, 0x40, 0x6f,
 0x6c, 0x75, 0x74, 0xcb, 0x00, 0xe5, 0x75, 0x6e, 0x69, 0x71,
 0x75, 0x65, 0x2e, 0x00, 0x00, 0x00, 0x4f, 0x6e, 0x6c, 0x79,
 0x5a, 0x00, 0x51, 0x77, 0x68, 0x69, 0x63, 0x68, 0xac, 0x00,
 0xa0, 0x65, 0x00, 0x61, 0x00, 0x6c, 0x65, 0x6e, 0x67, 0x74,
 0x68, 0x3c, 0x00, 0x30, 0x62, 0x6f, 0x72, 0x46, 0x00, 0x20,
 0x61, 0x72, 0x54, 0x00, 0x60, 0x71, 0x75, 0x69, 0x72, 0x65,
-0x64, 0x69, 0x00, 0xc4, 0x62, 0x65, 0x00, 0x64, 0x69, 0x66,
-0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x0d, 0x01, 0x5b, 0x2e,
-0x00, 0x54, 0x77, 0x6f, 0x51, 0x00, 0xc1, 0x6d, 0x65, 0x65,
-0x74, 0x00, 0x61, 0x74, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x41,
+0x64, 0x69, 0x00, 0x90, 0x62, 0x65, 0x00, 0x64, 0x69, 0x66,
+0x66, 0x65, 0x72, 0x79, 0x00, 0x03, 0x0d, 0x01, 0x5b, 0x2e,
+0x00, 0x54, 0x77, 0x6f, 0x51, 0x00, 0x90, 0x6d, 0x65, 0x65,
+0x74, 0x00, 0x61, 0x74, 0x00, 0x6f, 0x6c, 0x00, 0x00, 0x41,
 0x01, 0xb1, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x28, 0x69,
-0x2e, 0x65, 0x2e, 0x55, 0x00, 0xfd, 0x0c, 0x64, 0x69, 0x61,
+0x2e, 0x65, 0x2e, 0x55, 0x00, 0xff, 0x0c, 0x64, 0x69, 0x61,
 0x67, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x65,
 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x29, 0x00, 0x6d,
-0x61, 0x79, 0x00, 0x62, 0x23, 0x01, 0x00, 0xb5, 0x00, 0x71,
+0x61, 0x79, 0x00, 0x62, 0x23, 0x01, 0x00, 0x91, 0x00, 0x00,
 0x49, 0x00, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x40, 0x01, 0x90,
 0x69, 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0xb9,
 0x01, 0xf0, 0x08, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61,
 0x6c, 0x3b, 0x00, 0x49, 0x27, 0x76, 0x65, 0x00, 0x6e, 0x65,
-0x76, 0x65, 0x72, 0x00, 0x73, 0x65, 0x09, 0x02, 0xc0, 0x6e,
+0x76, 0x65, 0x72, 0x00, 0x73, 0x65, 0x09, 0x02, 0xc1, 0x6e,
 0x00, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-0x61, 0x04, 0x01, 0x00, 0xd8, 0x00, 0xf0, 0x06, 0x69, 0x74,
+0x61, 0x04, 0x01, 0xf0, 0x09, 0x6f, 0x66, 0x00, 0x69, 0x74,
 0x00, 0x61, 0x6e, 0x79, 0x77, 0x68, 0x65, 0x72, 0x65, 0x00,
 0x65, 0x6c, 0x73, 0x65, 0x2e, 0x00, 0x54, 0x68, 0x65, 0x2e,
-0x02, 0x41, 0x63, 0x65, 0x70, 0x74, 0x2b, 0x02, 0x01, 0xe9,
-0x01, 0x11, 0x2d, 0x7a, 0x00, 0x00, 0xc0, 0x01, 0x04, 0x6b,
+0x02, 0x42, 0x63, 0x65, 0x70, 0x74, 0x2b, 0x02, 0x00, 0xe9,
+0x01, 0x12, 0x2d, 0x7a, 0x00, 0x00, 0xc0, 0x01, 0x03, 0x6b,
 0x00, 0xf0, 0x20, 0x77, 0x61, 0x73, 0x00, 0x73, 0x75, 0x67,
 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x00, 0x62, 0x79, 0x00,
 0x4f, 0x77, 0x65, 0x6e, 0x00, 0x44, 0x75, 0x6e, 0x6e, 0x3b,
 0x00, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x00, 0x6d, 0x75,
 0x73, 0x74, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x67, 0x6f,
 0x2d, 0x01, 0x91, 0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x69, 0x00,
-0x61, 0x6e, 0x3b, 0x01, 0xf0, 0x07, 0x56, 0x65, 0x72, 0x69,
+0x61, 0x6e, 0x3b, 0x01, 0xf1, 0x07, 0x56, 0x65, 0x72, 0x69,
 0x74, 0x79, 0x00, 0x41, 0x6c, 0x6c, 0x61, 0x6e, 0x00, 0x66,
 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x73, 0x70, 0x69, 0x63, 0x00,
-0x01, 0xf0, 0x00, 0x52, 0x74, 0x72, 0x61, 0x69, 0x6e, 0xb6,
+0x00, 0xf0, 0x00, 0x52, 0x74, 0x72, 0x61, 0x69, 0x6e, 0xb6,
 0x01, 0x52, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x54, 0x02, 0x12,
-0x6c, 0x77, 0x01, 0x01, 0x0b, 0x02, 0x71, 0x61, 0x6c, 0x69,
-0x73, 0x69, 0x6e, 0x67, 0x79, 0x00, 0x14, 0x27, 0x8d, 0x00,
-0x00, 0xd8, 0x00, 0x01, 0x9c, 0x00, 0x82, 0x61, 0x00, 0x76,
-0x69, 0x61, 0x62, 0x6c, 0x65, 0xb0, 0x00, 0x01, 0xd8, 0x00,
-0x40, 0x61, 0x6e, 0x6b, 0x73, 0x90, 0x00, 0x01, 0x8d, 0x00,
-0xd1, 0x47, 0x61, 0x72, 0x65, 0x74, 0x68, 0x00, 0x54, 0x61,
-0x79, 0x6c, 0x6f, 0x72, 0x80, 0x00, 0xd7, 0x6d, 0x61, 0x6e,
-0x79, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64,
-0x4f, 0x00, 0x10, 0x73, 0x70, 0x01, 0x41, 0x32, 0x32, 0x2e,
-0x31, 0x60, 0x03, 0x80, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
-0x6c, 0x73, 0x69, 0x03, 0x15, 0x54, 0x25, 0x03, 0x13, 0x61,
-0xf0, 0x01, 0x71, 0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b,
-0xc2, 0x00, 0xf0, 0x00, 0x6c, 0x65, 0x66, 0x74, 0x00, 0x6d,
-0x6f, 0x75, 0x73, 0x65, 0x00, 0x62, 0x75, 0x74, 0x74, 0x70,
-0x01, 0x01, 0x85, 0x01, 0x22, 0x65, 0x78, 0x89, 0x03, 0x03,
-0x33, 0x00, 0x04, 0x9a, 0x02, 0x30, 0x64, 0x65, 0x73, 0x56,
-0x02, 0x03, 0x52, 0x00, 0x01, 0x26, 0x01, 0x41, 0x64, 0x72,
-0x61, 0x67, 0xf8, 0x00, 0x04, 0x15, 0x00, 0x41, 0x69, 0x6e,
-0x74, 0x6f, 0x2d, 0x00, 0x33, 0x6e, 0x65, 0x77, 0x3f, 0x00,
-0x00, 0x9d, 0x00, 0x31, 0x28, 0x54, 0x68, 0x2f, 0x03, 0xf3,
-0x07, 0x67, 0x72, 0x61, 0x6d, 0x00, 0x77, 0x69, 0x6c, 0x6c,
-0x00, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x00, 0x65, 0x6e,
-0x73, 0x75, 0x72, 0x40, 0x02, 0x47, 0x74, 0x61, 0x72, 0x74,
-0xc0, 0x01, 0x41, 0x68, 0x61, 0x73, 0x00, 0x51, 0x01, 0x30,
-0x61, 0x73, 0x74, 0x92, 0x02, 0x06, 0x8e, 0x00, 0x01, 0xf2,
-0x03, 0x03, 0x72, 0x00, 0x41, 0x2c, 0x00, 0x73, 0x6f, 0x82,
-0x00, 0x02, 0x67, 0x02, 0x24, 0x69, 0x73, 0x5a, 0x00, 0xa0,
-0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x21, 0x29,
-0x8d, 0x02, 0x82, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x00, 0x6e,
-0x65, 0x9e, 0x01, 0x47, 0x63, 0x6c, 0x65, 0x61, 0x13, 0x01,
-0x01, 0x1c, 0x00, 0x32, 0x63, 0x61, 0x6e, 0xcf, 0x00, 0x41,
-0x66, 0x72, 0x6f, 0x6d, 0x06, 0x01, 0x45, 0x6d, 0x70, 0x74,
-0x79, 0x23, 0x00, 0x22, 0x6f, 0x72, 0x19, 0x00, 0x24, 0x74,
-0x68, 0xb1, 0x01, 0x06, 0x26, 0x04, 0x11, 0x69, 0x20, 0x01,
-0x21, 0x72, 0x65, 0x28, 0x03, 0x29, 0x6e, 0x6f, 0x3a, 0x00,
-0x11, 0x73, 0x66, 0x01, 0x00, 0x04, 0x01, 0x51, 0x44, 0x72,
-0x61, 0x67, 0x67, 0x60, 0x04, 0x04, 0x2d, 0x01, 0x24, 0x75,
-0x73, 0x4c, 0x02, 0x4a, 0x72, 0x69, 0x67, 0x68, 0x8b, 0x01,
-0x02, 0x26, 0x01, 0x60, 0x73, 0x74, 0x69, 0x70, 0x70, 0x6c,
-0x20, 0x01, 0x05, 0xff, 0x00, 0x28, 0x69, 0x6e, 0x71, 0x01,
-0x12, 0x2c, 0xbf, 0x03, 0x05, 0xc2, 0x00, 0x00, 0x41, 0x00,
-0x01, 0x5c, 0x02, 0x40, 0x6e, 0x6f, 0x74, 0x65, 0xeb, 0x00,
-0x10, 0x79, 0xf1, 0x03, 0x31, 0x65, 0x6c, 0x66, 0x35, 0x00,
-0x00, 0x0e, 0x00, 0x00, 0x28, 0x01, 0x28, 0x6e, 0x6b, 0x52,
-0x00, 0x11, 0x6d, 0x7d, 0x00, 0x28, 0x62, 0x65, 0x58, 0x00,
-0x33, 0x2e, 0x00, 0x41, 0x1f, 0x00, 0x01, 0x57, 0x00, 0x00,
-0x54, 0x02, 0x34, 0x61, 0x69, 0x6e, 0x90, 0x00, 0x10, 0x73,
-0x86, 0x00, 0x74, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
-0xf4, 0x03, 0x01, 0xad, 0x01, 0x00, 0x96, 0x03, 0x43, 0x2e,
-0x00, 0x28, 0x54, 0x8b, 0x01, 0x41, 0x6f, 0x66, 0x74, 0x65,
-0x94, 0x00, 0x41, 0x66, 0x75, 0x6c, 0x00, 0xa3, 0x01, 0x00,
-0xd7, 0x01, 0x01, 0xa8, 0x04, 0x20, 0x64, 0x69, 0x0f, 0x05,
-0xd0, 0x75, 0x6c, 0x74, 0x79, 0x00, 0x6c, 0x65, 0x76, 0x65,
-0x6c, 0x73, 0x2e, 0x29, 0x19, 0x06, 0x02, 0xc7, 0x00, 0x02,
-0x04, 0x03, 0x22, 0x75, 0x73, 0xf9, 0x00, 0xb1, 0x63, 0x75,
-0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x5b,
-0x03, 0x20, 0x6f, 0x76, 0x6a, 0x01, 0x00, 0x7d, 0x01, 0x00,
-0x1f, 0x00, 0x00, 0x3d, 0x06, 0x10, 0x3a, 0x09, 0x00, 0x04,
-0x56, 0x01, 0x28, 0x6f, 0x66, 0x36, 0x00, 0x92, 0x69, 0x6e,
-0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0xba, 0x01, 0x33,
-0x6f, 0x73, 0x69, 0x59, 0x04, 0x07, 0x33, 0x00, 0x01, 0x17,
-0x01, 0x43, 0x77, 0x6f, 0x75, 0x6c, 0xd1, 0x02, 0x12, 0x28,
-0x54, 0x01, 0x20, 0x69, 0x73, 0x46, 0x01, 0xa1, 0x00, 0x6f,
-0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x69, 0x44, 0x02,
-0x65, 0x27, 0x72, 0x65, 0x00, 0x6f, 0x6e, 0x3c, 0x02, 0x25,
-0x27, 0x73, 0x07, 0x02, 0x70, 0x2c, 0x00, 0x73, 0x69, 0x6e,
-0x63, 0x65, 0xb1, 0x04, 0xa2, 0x64, 0x65, 0x70, 0x65, 0x6e,
-0x64, 0x73, 0x00, 0x6f, 0x6e, 0x39, 0x03, 0x40, 0x69, 0x72,
-0x65, 0x63, 0x77, 0x00, 0x01, 0x43, 0x02, 0x07, 0xb2, 0x01,
-0x90, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x61, 0x63, 0x68, 0x65,
-0xca, 0x00, 0x06, 0x51, 0x02, 0x76, 0x29, 0x2e, 0x00, 0x50,
-0x72, 0x65, 0x73, 0x1e, 0x02, 0x50, 0x65, 0x74, 0x75, 0x72,
-0x6e, 0x01, 0x01, 0x02, 0x25, 0x03, 0x32, 0x73, 0x00, 0x61,
-0xa9, 0x00, 0x29, 0x6f, 0x66, 0x0c, 0x02, 0x01, 0xfa, 0x01,
-0x48, 0x62, 0x6f, 0x76, 0x65, 0x16, 0x02, 0x03, 0x0f, 0x04,
-0x01, 0xa4, 0x06, 0x0c, 0x4f, 0x01, 0x3f, 0x3b, 0x00, 0x70,
-0x68, 0x00, 0x04, 0x20, 0x61, 0x67, 0xef, 0x01, 0x62, 0x66,
-0x69, 0x6e, 0x69, 0x73, 0x68, 0x3c, 0x01, 0x01, 0x72, 0x00,
-0x02, 0x7d, 0x05, 0x90, 0x73, 0x70, 0x61, 0x63, 0x65, 0x00,
-0x62, 0x61, 0x72, 0xac, 0x01, 0x00, 0x39, 0x02, 0x20, 0x75,
-0x73, 0x90, 0x04, 0x81, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72,
-0x6c, 0x79, 0x62, 0x03, 0x74, 0x72, 0x65, 0x61, 0x74, 0x65,
-0x00, 0x61, 0x32, 0x02, 0x15, 0x64, 0x0d, 0x04, 0x7f, 0x44,
-0x6f, 0x75, 0x62, 0x6c, 0x65, 0x2d, 0x79, 0x00, 0x05, 0x30,
-0x28, 0x77, 0x69, 0x50, 0x05, 0x10, 0x74, 0xe7, 0x01, 0x37,
-0x69, 0x6e, 0x67, 0xb2, 0x00, 0x11, 0x29, 0x13, 0x03, 0x02,
-0xbc, 0x03, 0x07, 0xbf, 0x02, 0x02, 0xf6, 0x00, 0x0f, 0xbb,
-0x03, 0x07, 0x64, 0x00, 0x64, 0x6f, 0x65, 0x73, 0x3a, 0x1e,
-0x04, 0x02, 0x8d, 0x02, 0x0e, 0x0e, 0x01, 0x43, 0x6d, 0x6f,
-0x64, 0x65, 0xe2, 0x01, 0x02, 0xf5, 0x07, 0x43, 0x66, 0x69,
-0x6c, 0x6c, 0x97, 0x01, 0x61, 0x65, 0x6e, 0x74, 0x69, 0x72,
-0x65, 0xa5, 0x08, 0x20, 0x69, 0x6e, 0x9f, 0x03, 0x06, 0x48,
-0x04, 0x20, 0x6f, 0x72, 0xda, 0x01, 0x02, 0x4d, 0x05, 0x65,
-0x61, 0x79, 0x6f, 0x75, 0x74, 0x2e, 0x6d, 0x04, 0x02, 0x5b,
-0x01, 0x43, 0x00, 0x4c, 0x00, 0x64, 0x96, 0x06, 0x41, 0x6c,
-0x61, 0x79, 0x2c, 0x2a, 0x00, 0x42, 0x67, 0x61, 0x6d, 0x65,
-0xcc, 0x00, 0x50, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x20, 0x02,
-0x10, 0x73, 0x1e, 0x00, 0x09, 0xf8, 0x08, 0x29, 0x69, 0x6e,
-0xd8, 0x08, 0x24, 0x6f, 0x66, 0xec, 0x02, 0x39, 0x2e, 0x00,
-0x54, 0xcb, 0x00, 0x04, 0xb6, 0x00, 0x21, 0x77, 0x61, 0x5a,
-0x08, 0x00, 0x4d, 0x00, 0x30, 0x63, 0x75, 0x73, 0x13, 0x01,
-0x40, 0x70, 0x61, 0x72, 0x74, 0x63, 0x03, 0x25, 0x61, 0x72,
-0x7e, 0x07, 0x71, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
-0xff, 0x00, 0x00, 0x39, 0x07, 0x70, 0x72, 0x69, 0x65, 0x6e,
-0x64, 0x00, 0x2d, 0xf3, 0x00, 0x01, 0x9a, 0x04, 0x00, 0x76,
-0x08, 0x60, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75, 0xf2, 0x02,
-0x10, 0x6e, 0xa9, 0x00, 0x29, 0x66, 0x6f, 0x62, 0x09, 0x00,
-0x79, 0x00, 0x10, 0x6d, 0x48, 0x09, 0x60, 0x65, 0x61, 0x73,
-0x69, 0x65, 0x72, 0x80, 0x02, 0x51, 0x6e, 0x00, 0x74, 0x72,
-0x79, 0xac, 0x01, 0x00, 0x55, 0x08, 0x42, 0x66, 0x65, 0x72,
-0x00, 0x04, 0x06, 0x81, 0x6d, 0x00, 0x61, 0x6c, 0x6c, 0x00,
-0x62, 0x79, 0x48, 0x00, 0x13, 0x73, 0x7e, 0x09, 0x61, 0x73,
-0x00, 0x60, 0x74, 0x68, 0x65, 0xd0, 0x05, 0x40, 0x64, 0x6f,
-0x77, 0x6e, 0x46, 0x06, 0x02, 0xfe, 0x04, 0x04, 0xe3, 0x00,
-0x52, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0xc3, 0x09, 0x12, 0x6e,
-0x68, 0x07, 0x23, 0x6f, 0x70, 0xdd, 0x08, 0x11, 0x27, 0x4b,
-0x06, 0x31, 0x41, 0x6c, 0x6c, 0x18, 0x00, 0x21, 0x61, 0x63,
-0xfc, 0x06, 0x00, 0x97, 0x06, 0x61, 0x63, 0x72, 0x69, 0x62,
-0x65, 0x64, 0xe3, 0x09, 0x03, 0x69, 0x03, 0x30, 0x32, 0x2e,
-0x31, 0x8e, 0x05, 0x02, 0x49, 0x04, 0x50, 0x61, 0x76, 0x61,
-0x69, 0x6c, 0x6b, 0x07, 0x22, 0x2e, 0x29, 0x29, 0x07, 0x11,
-0x32, 0x29, 0x07, 0x00, 0xc5, 0x08, 0x52, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x2b, 0x07, 0x56, 0x68, 0x65, 0x73, 0x65, 0x00,
-0x14, 0x00, 0x00, 0x3f, 0x00, 0x06, 0x3a, 0x00, 0x06, 0xfd,
-0x05, 0xe2, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e,
-0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x4d, 0x04, 0x12, 0x6e,
-0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0xa9, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0xde, 0x00, 0x51, 0x00, 0x00,
-0x53, 0x69, 0x7a, 0x97, 0x0a, 0x32, 0x67, 0x72, 0x69, 0xab,
-0x00, 0x51, 0x71, 0x75, 0x61, 0x72, 0x65, 0xbc, 0x07, 0x13,
-0x52, 0x2b, 0x06, 0x3b, 0x00, 0x00, 0x4e, 0xf6, 0x0a, 0x00,
-0x6a, 0x05, 0x02, 0x35, 0x02, 0x31, 0x65, 0x6e, 0x65, 0x74,
-0x09, 0x00, 0x04, 0x02, 0x01, 0x4f, 0x06, 0x05, 0x41, 0x05,
-0x00, 0x73, 0x02, 0x81, 0x6e, 0x00, 0x60, 0x45, 0x61, 0x73,
-0x79, 0x27, 0xc9, 0x02, 0x13, 0x2c, 0x8f, 0x06, 0x20, 0x73,
-0x68, 0xd4, 0x04, 0x04, 0x11, 0x07, 0x2f, 0x62, 0x65, 0x4f,
-0x07, 0x02, 0x43, 0x77, 0x68, 0x6f, 0x73, 0x09, 0x05, 0x05,
-0xd0, 0x03, 0x10, 0x64, 0x02, 0x01, 0x30, 0x6d, 0x69, 0x6e,
-0xe6, 0x02, 0x40, 0x72, 0x69, 0x76, 0x69, 0xf6, 0x09, 0x11,
-0x2e, 0x65, 0x00, 0x71, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c,
-0x27, 0xb7, 0x01, 0x52, 0x60, 0x48, 0x61, 0x72, 0x64, 0x72,
-0x00, 0x11, 0x73, 0x44, 0x07, 0x01, 0xd5, 0x02, 0x03, 0x34,
-0x0b, 0x02, 0xbf, 0x05, 0x20, 0x69, 0x6e, 0x09, 0x04, 0x00,
-0xe8, 0x03, 0x10, 0x6c, 0x0c, 0x0b, 0x00, 0xdd, 0x09, 0x71,
-0x78, 0x00, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0xab, 0x02, 0x5a,
-0x65, 0x64, 0x75, 0x63, 0x65, 0xbc, 0x05, 0x09, 0x47, 0x0b,
-0x50, 0x2e, 0x00, 0x48, 0x6f, 0x77, 0x20, 0x0a, 0x49, 0x2c,
-0x00, 0x69, 0x74, 0x38, 0x08, 0x25, 0x62, 0x65, 0xe1, 0x07,
-0x13, 0x00, 0x32, 0x04, 0x00, 0x79, 0x00, 0x03, 0x86, 0x02,
-0x50, 0x67, 0x75, 0x65, 0x73, 0x73, 0xb3, 0x07, 0xa3, 0x62,
-0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x2e, 0x25,
-0x01, 0x20, 0x55, 0x6e, 0x90, 0x00, 0x20, 0x6f, 0x6e, 0xd4,
-0x01, 0x05, 0x2d, 0x01, 0x0c, 0x9c, 0x08, 0x80, 0x66, 0x65,
-0x65, 0x6c, 0x00, 0x66, 0x72, 0x65, 0xc7, 0x00, 0x04, 0x79,
-0x01, 0x04, 0xf6, 0x07, 0x03, 0x30, 0x0b, 0x02, 0x1e, 0x02,
-0x11, 0x73, 0xce, 0x06, 0x00, 0x08, 0x00, 0x20, 0x69, 0x74,
-0x3c, 0x01, 0x04, 0x94, 0x00, 0x15, 0x79, 0xe0, 0x0b, 0x11,
-0x6d, 0x9b, 0x06, 0x01, 0x56, 0x0b, 0x01, 0xe2, 0x0c, 0x01,
-0x35, 0x0a, 0x11, 0x74, 0xc0, 0x0c, 0x12, 0x68, 0x11, 0x07,
-0x14, 0x79, 0xa7, 0x01, 0x25, 0x73, 0x74, 0x3e, 0x01, 0x12,
-0x61, 0xfd, 0x0b, 0x06, 0x0d, 0x0c, 0x51, 0x2e, 0x00, 0x53,
-0x6f, 0x6c, 0xde, 0x00, 0x07, 0xc1, 0x00, 0x05, 0x93, 0x00,
-0x00, 0x86, 0x0b, 0x04, 0xf5, 0x0b, 0x02, 0xfc, 0x00, 0x02,
-0xcd, 0x03, 0x16, 0x64, 0x00, 0x01, 0x50, 0x69, 0x6e, 0x67,
-0x2e, 0x00,
+0x6c, 0x77, 0x01, 0x01, 0x0b, 0x02, 0x40, 0x61, 0x6c, 0x69,
+0x73, 0x2e, 0x00, 0x00, 0x79, 0x00, 0x15, 0x27, 0x8d, 0x00,
+0x01, 0xa7, 0x02, 0xb3, 0x61, 0x73, 0x00, 0x61, 0x00, 0x76,
+0x69, 0x61, 0x62, 0x6c, 0x65, 0xb0, 0x00, 0x00, 0xd8, 0x00,
+0x42, 0x61, 0x6e, 0x6b, 0x73, 0x90, 0x00, 0xf1, 0x01, 0x74,
+0x6f, 0x00, 0x47, 0x61, 0x72, 0x65, 0x74, 0x68, 0x00, 0x54,
+0x61, 0x79, 0x6c, 0x6f, 0x72, 0x80, 0x00, 0xa0, 0x6d, 0x61,
+0x6e, 0x79, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x66, 0x00,
+0x06, 0x4f, 0x00, 0x10, 0x73, 0x70, 0x01, 0x41, 0x32, 0x32,
+0x2e, 0x31, 0x60, 0x03, 0x80, 0x63, 0x6f, 0x6e, 0x74, 0x72,
+0x6f, 0x6c, 0x73, 0x69, 0x03, 0x15, 0x54, 0x25, 0x03, 0x13,
+0x61, 0xf0, 0x01, 0x71, 0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63,
+0x6b, 0xc2, 0x00, 0xf0, 0x00, 0x6c, 0x65, 0x66, 0x74, 0x00,
+0x6d, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x62, 0x75, 0x74, 0x74,
+0x70, 0x01, 0x01, 0x85, 0x01, 0x23, 0x65, 0x78, 0x89, 0x03,
+0x03, 0x55, 0x03, 0x03, 0x9a, 0x02, 0x31, 0x64, 0x65, 0x73,
+0x56, 0x02, 0x04, 0x52, 0x00, 0x72, 0x6e, 0x64, 0x00, 0x64,
+0x72, 0x61, 0x67, 0xf8, 0x00, 0x03, 0x15, 0x00, 0x41, 0x69,
+0x6e, 0x74, 0x6f, 0x2d, 0x00, 0x33, 0x6e, 0x65, 0x77, 0x3f,
+0x00, 0x00, 0x9d, 0x00, 0x31, 0x28, 0x54, 0x68, 0x2f, 0x03,
+0xf3, 0x07, 0x67, 0x72, 0x61, 0x6d, 0x00, 0x77, 0x69, 0x6c,
+0x6c, 0x00, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x00, 0x65,
+0x6e, 0x73, 0x75, 0x72, 0x40, 0x02, 0x47, 0x74, 0x61, 0x72,
+0x74, 0xc0, 0x01, 0x10, 0x68, 0x24, 0x01, 0x00, 0x51, 0x01,
+0x31, 0x61, 0x73, 0x74, 0x92, 0x02, 0x06, 0x8e, 0x00, 0x01,
+0xf2, 0x03, 0x02, 0x72, 0x00, 0x42, 0x2c, 0x00, 0x73, 0x6f,
+0x82, 0x00, 0x01, 0x67, 0x02, 0x24, 0x69, 0x73, 0x5a, 0x00,
+0xa0, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x21,
+0x29, 0x8d, 0x02, 0x82, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x00,
+0x6e, 0x65, 0x9e, 0x01, 0x48, 0x63, 0x6c, 0x65, 0x61, 0x13,
+0x01, 0x00, 0x1c, 0x00, 0x32, 0x63, 0x61, 0x6e, 0xcf, 0x00,
+0x41, 0x66, 0x72, 0x6f, 0x6d, 0x06, 0x01, 0x45, 0x6d, 0x70,
+0x74, 0x79, 0x23, 0x00, 0x22, 0x6f, 0x72, 0x19, 0x00, 0x24,
+0x74, 0x68, 0xb1, 0x01, 0x06, 0x26, 0x04, 0x11, 0x69, 0x20,
+0x01, 0x21, 0x72, 0x65, 0x28, 0x03, 0x29, 0x6e, 0x6f, 0x3a,
+0x00, 0x11, 0x73, 0x66, 0x01, 0x00, 0x04, 0x01, 0x52, 0x44,
+0x72, 0x61, 0x67, 0x67, 0x60, 0x04, 0x03, 0x2d, 0x01, 0x24,
+0x75, 0x73, 0x4c, 0x02, 0x4b, 0x72, 0x69, 0x67, 0x68, 0x8b,
+0x01, 0x01, 0x26, 0x01, 0x64, 0x73, 0x74, 0x69, 0x70, 0x70,
+0x6c, 0x2a, 0x04, 0x01, 0xff, 0x00, 0x28, 0x69, 0x6e, 0x71,
+0x01, 0x13, 0x2c, 0xbf, 0x03, 0x04, 0xc2, 0x00, 0x00, 0x41,
+0x00, 0x01, 0x5c, 0x02, 0x40, 0x6e, 0x6f, 0x74, 0x65, 0xeb,
+0x00, 0x10, 0x79, 0xf1, 0x03, 0x32, 0x65, 0x6c, 0x66, 0x35,
+0x00, 0x00, 0x27, 0x00, 0x58, 0x74, 0x68, 0x69, 0x6e, 0x6b,
+0x52, 0x00, 0x11, 0x6d, 0x7d, 0x00, 0x28, 0x62, 0x65, 0x58,
+0x00, 0x34, 0x2e, 0x00, 0x41, 0x1f, 0x00, 0x00, 0x57, 0x00,
+0x00, 0x54, 0x02, 0x00, 0xee, 0x02, 0x03, 0x90, 0x00, 0x10,
+0x73, 0x86, 0x00, 0x74, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70,
+0x6c, 0xf4, 0x03, 0x01, 0xad, 0x01, 0x00, 0x96, 0x03, 0x10,
+0x2e, 0xee, 0x01, 0x02, 0x8b, 0x01, 0x41, 0x6f, 0x66, 0x74,
+0x65, 0x94, 0x00, 0x41, 0x66, 0x75, 0x6c, 0x00, 0xa3, 0x01,
+0x00, 0xd7, 0x01, 0x01, 0xa8, 0x04, 0x20, 0x64, 0x69, 0x0f,
+0x05, 0xd3, 0x75, 0x6c, 0x74, 0x79, 0x00, 0x6c, 0x65, 0x76,
+0x65, 0x6c, 0x73, 0x2e, 0x29, 0x19, 0x06, 0x00, 0x70, 0x00,
+0x01, 0x04, 0x03, 0x22, 0x75, 0x73, 0xf9, 0x00, 0xb1, 0x63,
+0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73,
+0x5b, 0x03, 0x20, 0x6f, 0x76, 0x6a, 0x01, 0x00, 0x7d, 0x01,
+0x01, 0x1f, 0x00, 0x42, 0x6d, 0x61, 0x70, 0x3a, 0x28, 0x00,
+0x02, 0x56, 0x01, 0x28, 0x6f, 0x66, 0x36, 0x00, 0x92, 0x69,
+0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0xba, 0x01,
+0x34, 0x6f, 0x73, 0x69, 0x59, 0x04, 0x07, 0x33, 0x00, 0x00,
+0x17, 0x01, 0x43, 0x77, 0x6f, 0x75, 0x6c, 0xd1, 0x02, 0x12,
+0x28, 0x54, 0x01, 0x20, 0x69, 0x73, 0x46, 0x01, 0xa1, 0x00,
+0x6f, 0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x69, 0x44,
+0x02, 0x31, 0x27, 0x72, 0x65, 0x26, 0x03, 0x03, 0x1e, 0x01,
+0x25, 0x27, 0x73, 0x07, 0x02, 0x70, 0x2c, 0x00, 0x73, 0x69,
+0x6e, 0x63, 0x65, 0xb1, 0x04, 0x70, 0x64, 0x65, 0x70, 0x65,
+0x6e, 0x64, 0x73, 0x29, 0x00, 0x01, 0x39, 0x03, 0x41, 0x69,
+0x72, 0x65, 0x63, 0x77, 0x00, 0x01, 0x43, 0x02, 0x06, 0xb2,
+0x01, 0x92, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x61, 0x63, 0x68,
+0x65, 0xca, 0x00, 0x04, 0x4a, 0x00, 0x76, 0x29, 0x2e, 0x00,
+0x50, 0x72, 0x65, 0x73, 0x1e, 0x02, 0x50, 0x65, 0x74, 0x75,
+0x72, 0x6e, 0x01, 0x01, 0x02, 0x25, 0x03, 0x00, 0xe0, 0x01,
+0x01, 0xa9, 0x00, 0x2a, 0x6f, 0x66, 0x0c, 0x02, 0x00, 0xfa,
+0x01, 0x49, 0x62, 0x6f, 0x76, 0x65, 0x16, 0x02, 0x02, 0x0f,
+0x04, 0x02, 0xa4, 0x06, 0x0b, 0x4f, 0x01, 0x3f, 0x3b, 0x00,
+0x70, 0x68, 0x00, 0x04, 0x20, 0x61, 0x67, 0xef, 0x01, 0x63,
+0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x3c, 0x01, 0x00, 0x72,
+0x00, 0x02, 0x7d, 0x05, 0x91, 0x73, 0x70, 0x61, 0x63, 0x65,
+0x00, 0x62, 0x61, 0x72, 0xac, 0x01, 0x20, 0x62, 0x65, 0xaa,
+0x01, 0xb1, 0x64, 0x00, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61,
+0x72, 0x6c, 0x79, 0x62, 0x03, 0x40, 0x72, 0x65, 0x61, 0x74,
+0xa1, 0x06, 0x03, 0x32, 0x02, 0x15, 0x64, 0x0d, 0x04, 0x7f,
+0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x2d, 0x79, 0x00, 0x05,
+0x30, 0x28, 0x77, 0x69, 0x50, 0x05, 0x10, 0x74, 0xe7, 0x01,
+0x04, 0x1f, 0x00, 0x02, 0xb2, 0x00, 0x12, 0x29, 0x13, 0x03,
+0x02, 0xbc, 0x03, 0x06, 0xbf, 0x02, 0x02, 0xf6, 0x00, 0x0f,
+0xbb, 0x03, 0x07, 0x65, 0x00, 0x64, 0x6f, 0x65, 0x73, 0x3a,
+0x1e, 0x04, 0x03, 0x8d, 0x02, 0x0c, 0x0e, 0x01, 0x43, 0x6d,
+0x6f, 0x64, 0x65, 0xe2, 0x01, 0x02, 0xf5, 0x07, 0x43, 0x66,
+0x69, 0x6c, 0x6c, 0x97, 0x01, 0x51, 0x65, 0x6e, 0x74, 0x69,
+0x72, 0x68, 0x02, 0x00, 0xf7, 0x02, 0x36, 0x62, 0x75, 0x74,
+0x48, 0x04, 0x20, 0x6f, 0x72, 0xda, 0x01, 0x02, 0x4d, 0x05,
+0x66, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x2e, 0x6d, 0x04, 0x01,
+0xe2, 0x00, 0x43, 0x00, 0x4c, 0x00, 0x64, 0x96, 0x06, 0x41,
+0x6c, 0x61, 0x79, 0x2c, 0x2a, 0x00, 0x10, 0x67, 0x29, 0x07,
+0x01, 0xcc, 0x00, 0x50, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x20,
+0x02, 0x10, 0x73, 0x1e, 0x00, 0x09, 0xf8, 0x08, 0x29, 0x69,
+0x6e, 0xd8, 0x08, 0x24, 0x6f, 0x66, 0xec, 0x02, 0x00, 0x83,
+0x01, 0x09, 0xcb, 0x00, 0x03, 0xb6, 0x00, 0x22, 0x77, 0x61,
+0x5a, 0x08, 0x60, 0x64, 0x69, 0x73, 0x63, 0x75, 0x73, 0x13,
+0x01, 0x10, 0x70, 0x50, 0x05, 0x55, 0x63, 0x75, 0x6c, 0x61,
+0x72, 0x7e, 0x07, 0x40, 0x6e, 0x73, 0x74, 0x61, 0xa4, 0x02,
+0x01, 0xff, 0x00, 0xa0, 0x61, 0x00, 0x66, 0x72, 0x69, 0x65,
+0x6e, 0x64, 0x00, 0x2d, 0xf3, 0x00, 0x01, 0x9a, 0x04, 0x00,
+0x76, 0x08, 0x60, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75, 0xf2,
+0x02, 0x10, 0x6e, 0xa9, 0x00, 0x2a, 0x66, 0x6f, 0x62, 0x09,
+0x40, 0x69, 0x73, 0x00, 0x6d, 0x48, 0x09, 0x60, 0x65, 0x61,
+0x73, 0x69, 0x65, 0x72, 0x80, 0x02, 0x51, 0x6e, 0x00, 0x74,
+0x72, 0x79, 0xac, 0x01, 0x00, 0x55, 0x08, 0x10, 0x66, 0x15,
+0x00, 0x01, 0x04, 0x06, 0x50, 0x6d, 0x00, 0x61, 0x6c, 0x6c,
+0x79, 0x07, 0x00, 0x48, 0x00, 0x13, 0x73, 0x7e, 0x09, 0x30,
+0x73, 0x00, 0x60, 0xc9, 0x00, 0x00, 0xd0, 0x05, 0x41, 0x64,
+0x6f, 0x77, 0x6e, 0x46, 0x06, 0x02, 0xfe, 0x04, 0x03, 0xe3,
+0x00, 0x20, 0x62, 0x72, 0x17, 0x00, 0x01, 0xc3, 0x09, 0x12,
+0x6e, 0x68, 0x07, 0x23, 0x6f, 0x70, 0xdd, 0x08, 0x11, 0x27,
+0x4b, 0x06, 0x31, 0x41, 0x6c, 0x6c, 0x18, 0x00, 0x21, 0x61,
+0x63, 0xfc, 0x06, 0x00, 0x97, 0x06, 0x61, 0x63, 0x72, 0x69,
+0x62, 0x65, 0x64, 0xe3, 0x09, 0x03, 0x69, 0x03, 0x31, 0x32,
+0x2e, 0x31, 0x8e, 0x05, 0x01, 0x49, 0x04, 0x50, 0x61, 0x76,
+0x61, 0x69, 0x6c, 0x6b, 0x07, 0x22, 0x2e, 0x29, 0x29, 0x07,
+0x11, 0x32, 0x29, 0x07, 0x00, 0xc5, 0x08, 0x52, 0x6d, 0x65,
+0x74, 0x65, 0x72, 0x2b, 0x07, 0x56, 0x68, 0x65, 0x73, 0x65,
+0x00, 0x14, 0x00, 0x02, 0x3f, 0x00, 0x04, 0x3a, 0x00, 0x06,
+0xfd, 0x05, 0xe2, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
+0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x4d, 0x04, 0x12,
+0x6e, 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0xa9, 0x00, 0x91, 0x57, 0x69, 0x64,
+0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0xde, 0x00, 0x51, 0x00,
+0x00, 0x53, 0x69, 0x7a, 0x97, 0x0a, 0x32, 0x67, 0x72, 0x69,
+0xab, 0x00, 0x51, 0x71, 0x75, 0x61, 0x72, 0x65, 0xbc, 0x07,
+0x13, 0x52, 0x2b, 0x06, 0x3c, 0x00, 0x00, 0x4e, 0xf6, 0x0a,
+0x22, 0x00, 0x69, 0x5d, 0x00, 0x41, 0x67, 0x65, 0x6e, 0x65,
+0x74, 0x09, 0x02, 0x04, 0x02, 0x36, 0x00, 0x00, 0x44, 0x41,
+0x05, 0xb1, 0x00, 0x00, 0x49, 0x6e, 0x00, 0x60, 0x45, 0x61,
+0x73, 0x79, 0x27, 0xc9, 0x02, 0x13, 0x2c, 0x8f, 0x06, 0x21,
+0x73, 0x68, 0xd4, 0x04, 0x03, 0x11, 0x07, 0x2f, 0x62, 0x65,
+0x4f, 0x07, 0x02, 0x45, 0x77, 0x68, 0x6f, 0x73, 0x09, 0x05,
+0x03, 0xd0, 0x03, 0x10, 0x64, 0x02, 0x01, 0x30, 0x6d, 0x69,
+0x6e, 0xe6, 0x02, 0x40, 0x72, 0x69, 0x76, 0x69, 0xf6, 0x09,
+0x11, 0x2e, 0x65, 0x00, 0x71, 0x4e, 0x6f, 0x72, 0x6d, 0x61,
+0x6c, 0x27, 0xb7, 0x01, 0x52, 0x60, 0x48, 0x61, 0x72, 0x64,
+0x72, 0x00, 0x12, 0x73, 0x44, 0x07, 0x01, 0xd5, 0x02, 0x02,
+0x34, 0x0b, 0x02, 0xbf, 0x05, 0x20, 0x69, 0x6e, 0x09, 0x04,
+0x00, 0xe8, 0x03, 0x10, 0x6c, 0x0c, 0x0b, 0x00, 0xdd, 0x09,
+0x71, 0x78, 0x00, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0xab, 0x02,
+0x5b, 0x65, 0x64, 0x75, 0x63, 0x65, 0xbc, 0x05, 0x08, 0x47,
+0x0b, 0x50, 0x2e, 0x00, 0x48, 0x6f, 0x77, 0x20, 0x0a, 0x10,
+0x2c, 0x56, 0x05, 0x08, 0x38, 0x08, 0x25, 0x62, 0x65, 0xe1,
+0x07, 0x14, 0x00, 0x32, 0x04, 0x03, 0xc5, 0x02, 0x70, 0x74,
+0x6f, 0x00, 0x67, 0x75, 0x65, 0x73, 0x69, 0x0a, 0xb3, 0x00,
+0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x2e,
+0x25, 0x01, 0x20, 0x55, 0x6e, 0x90, 0x00, 0x20, 0x6f, 0x6e,
+0xd4, 0x01, 0x07, 0x2d, 0x01, 0x0a, 0x9c, 0x08, 0x81, 0x66,
+0x65, 0x65, 0x6c, 0x00, 0x66, 0x72, 0x65, 0xc7, 0x00, 0x04,
+0x79, 0x01, 0x03, 0x44, 0x03, 0x04, 0x30, 0x0b, 0x01, 0x1e,
+0x02, 0x11, 0x73, 0xce, 0x06, 0x00, 0x08, 0x00, 0x21, 0x69,
+0x74, 0x3c, 0x01, 0x03, 0x94, 0x00, 0x15, 0x79, 0xe0, 0x0b,
+0x12, 0x6d, 0x9b, 0x06, 0x01, 0x56, 0x0b, 0x00, 0xe2, 0x0c,
+0x01, 0x35, 0x0a, 0x11, 0x74, 0xc0, 0x0c, 0x12, 0x68, 0x11,
+0x07, 0x14, 0x79, 0xa7, 0x01, 0x25, 0x73, 0x74, 0x3e, 0x01,
+0x13, 0x61, 0xfd, 0x0b, 0x05, 0x0d, 0x0c, 0x51, 0x2e, 0x00,
+0x53, 0x6f, 0x6c, 0xde, 0x00, 0x08, 0xc1, 0x00, 0x05, 0x93,
+0x00, 0x00, 0x86, 0x0b, 0x03, 0xf5, 0x0b, 0x02, 0xfc, 0x00,
+0x02, 0xcd, 0x03, 0x16, 0x64, 0x00, 0x01, 0x50, 0x69, 0x6e,
+0x67, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3466;
diff --git a/apps/plugins/puzzles/help/mines.c b/apps/plugins/puzzles/help/mines.c
index ad20406b3a..317d626292 100644
--- a/apps/plugins/puzzles/help/mines.c
+++ b/apps/plugins/puzzles/help/mines.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -20,7 +20,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3796 comp 2332 ratio 0.614331 level 11 saved 1464 */
+/* orig 3796 comp 2333 ratio 0.614594 level 10 saved 1463 */
 const char help_text[] = {
 0xf0, 0x2e, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x32, 0x3a, 0x20, 0x4d, 0x69, 0x6e, 0x65, 0x73, 0x20,
@@ -37,17 +37,17 @@ const char help_text[] = {
 0x73, 0x00, 0x74, 0x6f, 0x00, 0x75, 0x6e, 0x59, 0x00, 0x63,
 0x00, 0x65, 0x76, 0x65, 0x72, 0x79, 0x5d, 0x00, 0x03, 0x53,
 0x00, 0x85, 0x64, 0x6f, 0x65, 0x73, 0x00, 0x6e, 0x6f, 0x74,
-0x5c, 0x00, 0x11, 0x61, 0x5e, 0x00, 0x40, 0x2e, 0x00, 0x49,
-0x66, 0x5c, 0x00, 0x05, 0x3b, 0x00, 0x13, 0x61, 0x37, 0x00,
-0x04, 0x28, 0x00, 0x33, 0x69, 0x6e, 0x67, 0x2b, 0x00, 0x11,
-0x2c, 0x28, 0x00, 0x3f, 0x6c, 0x6f, 0x73, 0x35, 0x00, 0x00,
-0x0f, 0x6c, 0x00, 0x0b, 0x09, 0x41, 0x00, 0x00, 0x27, 0x00,
+0x5c, 0x00, 0x11, 0x61, 0x5e, 0x00, 0x41, 0x2e, 0x00, 0x49,
+0x66, 0x5c, 0x00, 0x04, 0x3b, 0x00, 0x14, 0x61, 0x37, 0x00,
+0x03, 0x28, 0x00, 0x33, 0x69, 0x6e, 0x67, 0x2b, 0x00, 0x11,
+0x2c, 0x28, 0x00, 0x3f, 0x6c, 0x6f, 0x73, 0x35, 0x00, 0x08,
+0x0f, 0x6c, 0x00, 0x0a, 0x02, 0x41, 0x00, 0x00, 0x27, 0x00,
 0xd2, 0x74, 0x6f, 0x6c, 0x64, 0x00, 0x68, 0x6f, 0x77, 0x00,
 0x6d, 0x61, 0x6e, 0x79, 0xe6, 0x00, 0x17, 0x00, 0x74, 0x00,
-0xf4, 0x10, 0x65, 0x64, 0x00, 0x77, 0x69, 0x74, 0x68, 0x69,
+0xf0, 0x0d, 0x65, 0x64, 0x00, 0x77, 0x69, 0x74, 0x68, 0x69,
 0x6e, 0x00, 0x74, 0x68, 0x65, 0x00, 0x65, 0x69, 0x67, 0x68,
 0x74, 0x00, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64,
-0x69, 0x6e, 0x67, 0x36, 0x01, 0xf0, 0x03, 0x2e, 0x00, 0x00,
+0x90, 0x00, 0x03, 0x36, 0x01, 0xf0, 0x03, 0x2e, 0x00, 0x00,
 0x00, 0x54, 0x68, 0x69, 0x73, 0x00, 0x67, 0x61, 0x6d, 0x65,
 0x00, 0x6e, 0x65, 0x65, 0x64, 0x76, 0x00, 0xf0, 0x1a, 0x00,
 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69,
@@ -60,8 +60,8 @@ const char help_text[] = {
 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x00, 0x70, 0x75, 0x7a,
 0x7a, 0x6c, 0x65, 0x67, 0x00, 0xc5, 0x69, 0x6e, 0x00, 0x65,
 0x78, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x81, 0x00,
-0xa0, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x6f,
-0x66, 0x58, 0x00, 0xf1, 0x14, 0x68, 0x61, 0x73, 0x00, 0x61,
+0x70, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0xc1, 0x01,
+0xf1, 0x17, 0x69, 0x74, 0x00, 0x68, 0x61, 0x73, 0x00, 0x61,
 0x6e, 0x00, 0x75, 0x6e, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x00,
 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x00,
 0x42, 0x79, 0x00, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
@@ -73,32 +73,32 @@ const char help_text[] = {
 0x40, 0x65, 0x6e, 0x73, 0x75, 0x42, 0x01, 0x22, 0x68, 0x61,
 0x14, 0x02, 0x10, 0x6e, 0xec, 0x01, 0x01, 0xfd, 0x00, 0x00,
 0x1e, 0x00, 0xb3, 0x67, 0x75, 0x65, 0x73, 0x73, 0x00, 0x77,
-0x68, 0x65, 0x72, 0x65, 0x75, 0x01, 0x40, 0x00, 0x69, 0x73,
-0x3a, 0x29, 0x00, 0x02, 0x6e, 0x00, 0xe0, 0x61, 0x6c, 0x77,
+0x68, 0x65, 0x72, 0x65, 0x75, 0x01, 0x41, 0x00, 0x69, 0x73,
+0x3a, 0x29, 0x00, 0x01, 0x6e, 0x00, 0xe0, 0x61, 0x6c, 0x77,
 0x61, 0x79, 0x73, 0x00, 0x62, 0x65, 0x00, 0x61, 0x62, 0x6c,
 0x65, 0x32, 0x00, 0x50, 0x64, 0x65, 0x64, 0x75, 0x63, 0x7e,
-0x00, 0x01, 0x83, 0x02, 0x75, 0x68, 0x6f, 0x77, 0x2e, 0x00,
-0x53, 0x6f, 0x31, 0x00, 0x02, 0x5f, 0x00, 0x10, 0x2c, 0x7c,
+0x00, 0x01, 0x83, 0x02, 0x76, 0x68, 0x6f, 0x77, 0x2e, 0x00,
+0x53, 0x6f, 0x31, 0x00, 0x01, 0x5f, 0x00, 0x10, 0x2c, 0x7c,
 0x00, 0xa0, 0x63, 0x61, 0x6e, 0x00, 0x68, 0x61, 0x70, 0x70,
 0x65, 0x6e, 0x98, 0x00, 0x54, 0x6f, 0x74, 0x68, 0x65, 0x72,
-0xf8, 0x00, 0x91, 0x73, 0x2c, 0x00, 0x67, 0x65, 0x74, 0x00,
-0x74, 0x6f, 0x48, 0x01, 0x93, 0x6c, 0x61, 0x73, 0x74, 0x00,
-0x66, 0x6f, 0x75, 0x72, 0xa8, 0x01, 0x00, 0x0d, 0x01, 0x51,
-0x64, 0x00, 0x64, 0x69, 0x73, 0x2c, 0x02, 0x02, 0xba, 0x00,
-0x10, 0x74, 0xa2, 0x00, 0x02, 0x0b, 0x02, 0x23, 0x77, 0x6f,
-0x01, 0x02, 0x42, 0x6c, 0x65, 0x66, 0x74, 0xeb, 0x02, 0x04,
+0xf8, 0x00, 0x60, 0x73, 0x2c, 0x00, 0x67, 0x65, 0x74, 0x4e,
+0x00, 0x00, 0x48, 0x01, 0x60, 0x6c, 0x61, 0x73, 0x74, 0x00,
+0x66, 0x99, 0x02, 0x03, 0xa8, 0x01, 0x82, 0x00, 0x61, 0x6e,
+0x64, 0x00, 0x64, 0x69, 0x73, 0x2c, 0x02, 0x01, 0xba, 0x00,
+0x12, 0x74, 0xa2, 0x00, 0x00, 0xc9, 0x00, 0x23, 0x77, 0x6f,
+0x01, 0x02, 0x45, 0x6c, 0x65, 0x66, 0x74, 0xeb, 0x02, 0x01,
 0x30, 0x03, 0x21, 0x6e, 0x6f, 0xf9, 0x00, 0x21, 0x6f, 0x66,
-0x90, 0x01, 0x00, 0xfa, 0x01, 0x40, 0x66, 0x6f, 0x72, 0x00,
-0x00, 0x01, 0x02, 0xe3, 0x00, 0x00, 0x47, 0x00, 0x41, 0x79,
-0x00, 0x61, 0x72, 0x89, 0x01, 0x43, 0x31, 0x32, 0x2e, 0x31,
-0x74, 0x03, 0x20, 0x63, 0x6f, 0x03, 0x02, 0x38, 0x6c, 0x73,
-0x20, 0x21, 0x02, 0x01, 0xef, 0x01, 0x33, 0x6c, 0x61, 0x79,
-0x5d, 0x02, 0x01, 0xab, 0x00, 0x40, 0x6d, 0x6f, 0x75, 0x73,
-0x3d, 0x00, 0x03, 0xd0, 0x02, 0x01, 0x83, 0x00, 0x70, 0x2d,
-0x63, 0x6c, 0x69, 0x63, 0x6b, 0x00, 0xb6, 0x02, 0x0b, 0xa7,
+0x90, 0x01, 0x00, 0xfa, 0x01, 0x41, 0x66, 0x6f, 0x72, 0x00,
+0x00, 0x01, 0x02, 0xe3, 0x00, 0x40, 0x74, 0x68, 0x65, 0x79,
+0x46, 0x00, 0x00, 0x89, 0x01, 0x43, 0x31, 0x32, 0x2e, 0x31,
+0x74, 0x03, 0x20, 0x63, 0x6f, 0x03, 0x02, 0x39, 0x6c, 0x73,
+0x20, 0x21, 0x02, 0x00, 0xef, 0x01, 0x33, 0x6c, 0x61, 0x79,
+0x5d, 0x02, 0x01, 0xab, 0x00, 0x41, 0x6d, 0x6f, 0x75, 0x73,
+0x3d, 0x00, 0x03, 0xd0, 0x02, 0x00, 0x83, 0x00, 0x71, 0x2d,
+0x63, 0x6c, 0x69, 0x63, 0x6b, 0x00, 0xb6, 0x02, 0x0a, 0xa7,
 0x03, 0x06, 0xb5, 0x01, 0x24, 0x62, 0x65, 0xfb, 0x02, 0x27,
-0x65, 0x64, 0x3f, 0x00, 0x4f, 0x72, 0x69, 0x67, 0x68, 0x40,
-0x00, 0x11, 0x00, 0x88, 0x00, 0x10, 0x63, 0xa1, 0x01, 0x43,
+0x65, 0x64, 0x3f, 0x00, 0x10, 0x72, 0xaa, 0x02, 0x0f, 0x40,
+0x00, 0x11, 0x40, 0x70, 0x6c, 0x61, 0x63, 0xa1, 0x01, 0x43,
 0x66, 0x6c, 0x61, 0x67, 0x34, 0x03, 0x95, 0x69, 0x6e, 0x64,
 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x21, 0x01, 0x04, 0x54,
 0x03, 0x10, 0x69, 0xb0, 0x01, 0x42, 0x6c, 0x69, 0x65, 0x76,
@@ -106,156 +106,156 @@ const char help_text[] = {
 0x00, 0x00, 0x1c, 0x01, 0x02, 0x68, 0x03, 0x35, 0x61, 0x72,
 0x6b, 0x71, 0x00, 0x03, 0xc3, 0x01, 0x25, 0x6f, 0x74, 0xa9,
 0x03, 0x32, 0x69, 0x74, 0x2c, 0x44, 0x01, 0x51, 0x61, 0x66,
-0x65, 0x74, 0x79, 0x40, 0x04, 0x00, 0xd9, 0x01, 0x09, 0xba,
-0x00, 0x50, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x6a, 0x00, 0x63,
+0x65, 0x74, 0x79, 0x40, 0x04, 0x01, 0xd9, 0x01, 0x08, 0xba,
+0x00, 0x30, 0x61, 0x67, 0x61, 0x7a, 0x03, 0x83, 0x6f, 0x00,
 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x55, 0x00, 0x02, 0xb4,
 0x00, 0x11, 0x64, 0x00, 0x03, 0x4f, 0x72, 0x72, 0x6f, 0x72,
-0x36, 0x01, 0x05, 0x02, 0xfa, 0x02, 0x0f, 0xf9, 0x00, 0x05,
+0x36, 0x01, 0x07, 0x00, 0xfa, 0x02, 0x0f, 0xf9, 0x00, 0x05,
 0x81, 0x60, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x61, 0xcb,
-0x03, 0x17, 0x27, 0xe6, 0x00, 0x12, 0x2e, 0xa9, 0x01, 0x97,
-0x6d, 0x65, 0x61, 0x6e, 0x73, 0x3a, 0x00, 0x69, 0x66, 0x1b,
-0x00, 0x01, 0x50, 0x03, 0x60, 0x65, 0x78, 0x61, 0x63, 0x74,
-0x6c, 0x05, 0x03, 0x01, 0x34, 0x04, 0x01, 0x3a, 0x01, 0x18,
-0x73, 0x15, 0x04, 0x00, 0x63, 0x00, 0x21, 0x61, 0x73, 0xc8,
-0x02, 0x51, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x42, 0x02, 0x03,
-0x41, 0x05, 0x00, 0x4d, 0x00, 0x50, 0x6e, 0x00, 0x61, 0x6c,
-0x6c, 0x09, 0x00, 0x0c, 0x7c, 0x05, 0x41, 0x00, 0x6e, 0x65,
-0x78, 0xbc, 0x02, 0x22, 0x69, 0x74, 0x8b, 0x01, 0x00, 0x51,
-0x02, 0x00, 0x35, 0x01, 0x01, 0x64, 0x00, 0x3e, 0x67, 0x65,
+0x03, 0x17, 0x27, 0xe6, 0x00, 0x12, 0x2e, 0xa9, 0x01, 0x98,
+0x6d, 0x65, 0x61, 0x6e, 0x73, 0x3a, 0x00, 0x69, 0x66, 0x01,
+0x01, 0x00, 0x50, 0x03, 0x61, 0x65, 0x78, 0x61, 0x63, 0x74,
+0x6c, 0x05, 0x03, 0x01, 0x34, 0x04, 0x00, 0x3a, 0x01, 0x19,
+0x73, 0x15, 0x04, 0x20, 0x69, 0x74, 0x1d, 0x00, 0x00, 0xc8,
+0x02, 0x52, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x42, 0x02, 0x03,
+0x41, 0x05, 0x81, 0x74, 0x68, 0x65, 0x6e, 0x00, 0x61, 0x6c,
+0x6c, 0x56, 0x00, 0x0b, 0x7c, 0x05, 0x41, 0x00, 0x6e, 0x65,
+0x78, 0xbc, 0x02, 0x23, 0x69, 0x74, 0x8b, 0x01, 0x00, 0x74,
+0x00, 0x00, 0x35, 0x01, 0x00, 0x64, 0x00, 0x3e, 0x67, 0x65,
 0x64, 0xf3, 0x01, 0x01, 0x23, 0x03, 0x41, 0x6f, 0x6e, 0x63,
-0x65, 0xff, 0x00, 0x00, 0xa9, 0x04, 0x10, 0x6b, 0x0a, 0x00,
-0x01, 0xa6, 0x02, 0x02, 0x03, 0x03, 0x42, 0x6f, 0x63, 0x61,
-0x74, 0x11, 0x04, 0x03, 0x77, 0x00, 0x03, 0x8b, 0x00, 0x03,
-0xfa, 0x00, 0x04, 0x31, 0x05, 0x03, 0x13, 0x05, 0x10, 0x63,
-0x34, 0x01, 0x40, 0x73, 0x65, 0x00, 0x74, 0x03, 0x01, 0x41,
+0x65, 0xff, 0x00, 0x00, 0xa9, 0x04, 0x11, 0x6b, 0x0a, 0x00,
+0x01, 0x9a, 0x05, 0x01, 0x03, 0x03, 0x43, 0x6f, 0x63, 0x61,
+0x74, 0x11, 0x04, 0x04, 0x77, 0x00, 0x04, 0xe6, 0x04, 0x00,
+0xb0, 0x00, 0x05, 0x31, 0x05, 0x02, 0x13, 0x05, 0x10, 0x63,
+0x34, 0x01, 0x20, 0x73, 0x65, 0x4a, 0x00, 0x61, 0x73, 0x00,
 0x66, 0x75, 0x6e, 0x63, 0x3c, 0x00, 0x00, 0x46, 0x04, 0x00,
 0xcd, 0x00, 0x41, 0x72, 0x74, 0x63, 0x75, 0xa1, 0x00, 0x41,
-0x61, 0x76, 0x6f, 0x69, 0xd8, 0x00, 0x30, 0x69, 0x6e, 0x67,
-0x10, 0x00, 0x02, 0x73, 0x01, 0x91, 0x6f, 0x6e, 0x00, 0x65,
-0x61, 0x63, 0x68, 0x00, 0x6f, 0x34, 0x01, 0x00, 0xb5, 0x01,
-0x02, 0xb6, 0x05, 0x05, 0xe0, 0x00, 0x30, 0x6f, 0x6e, 0x65,
-0xfa, 0x04, 0x20, 0x6f, 0x6e, 0xea, 0x02, 0x0f, 0xba, 0x05,
-0x0b, 0x01, 0x6b, 0x01, 0x14, 0x6e, 0x91, 0x03, 0x02, 0x80,
-0x05, 0x08, 0x65, 0x01, 0x02, 0x8c, 0x05, 0x02, 0x33, 0x00,
-0x04, 0x58, 0x01, 0x03, 0x4a, 0x05, 0x91, 0x6f, 0x62, 0x76,
+0x61, 0x76, 0x6f, 0x69, 0xd8, 0x00, 0x00, 0xef, 0x00, 0x32,
+0x74, 0x6f, 0x00, 0x73, 0x01, 0x92, 0x6f, 0x6e, 0x00, 0x65,
+0x61, 0x63, 0x68, 0x00, 0x6f, 0x34, 0x01, 0x33, 0x72, 0x65,
+0x6d, 0xb6, 0x05, 0x04, 0xe0, 0x00, 0x30, 0x6f, 0x6e, 0x65,
+0xfa, 0x04, 0x28, 0x6f, 0x6e, 0xea, 0x02, 0x0f, 0xba, 0x05,
+0x04, 0x00, 0x6b, 0x01, 0x14, 0x6e, 0x91, 0x03, 0x03, 0x80,
+0x05, 0x08, 0x65, 0x01, 0x03, 0x8c, 0x05, 0x04, 0xb6, 0x06,
+0x01, 0x58, 0x01, 0x02, 0x4a, 0x05, 0x91, 0x6f, 0x62, 0x76,
 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5c, 0x02, 0x08, 0x8d,
-0x06, 0x43, 0x74, 0x68, 0x6f, 0x73, 0xcc, 0x01, 0x03, 0x55,
+0x06, 0x44, 0x74, 0x68, 0x6f, 0x73, 0xcc, 0x01, 0x02, 0x55,
 0x00, 0x41, 0x75, 0x72, 0x6e, 0x2c, 0x15, 0x04, 0x10, 0x73,
-0x47, 0x01, 0x00, 0xee, 0x01, 0x33, 0x61, 0x6e, 0x79, 0xc1,
-0x00, 0x63, 0x6d, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x89, 0x00,
-0x08, 0x7c, 0x00, 0x02, 0x95, 0x00, 0x02, 0x28, 0x02, 0x04,
-0x93, 0x01, 0x00, 0x12, 0x07, 0x10, 0x65, 0xd1, 0x02, 0x02,
+0x47, 0x01, 0x00, 0xee, 0x01, 0x00, 0xd3, 0x01, 0x02, 0xc1,
+0x00, 0x64, 0x6d, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x89, 0x00,
+0x08, 0x7c, 0x00, 0x01, 0x95, 0x00, 0x03, 0x28, 0x02, 0x04,
+0x93, 0x01, 0x10, 0x64, 0xdd, 0x00, 0x00, 0xd1, 0x02, 0x01,
 0x5a, 0x06, 0xd0, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69,
 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x3b, 0x5d, 0x00, 0x00, 0xd3,
 0x04, 0x41, 0x74, 0x69, 0x6d, 0x65, 0x13, 0x05, 0x1f, 0x6e,
 0xf9, 0x00, 0x02, 0x10, 0x2c, 0x5e, 0x05, 0x30, 0x68, 0x6f,
 0x6c, 0x41, 0x06, 0x10, 0x77, 0xfb, 0x01, 0x12, 0x61, 0x5d,
 0x00, 0x10, 0x6f, 0xe9, 0x04, 0x23, 0x75, 0x70, 0x72, 0x03,
-0x52, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0xed, 0x03, 0x04, 0x34,
-0x03, 0x01, 0xa8, 0x00, 0x00, 0xb7, 0x01, 0x02, 0x55, 0x02,
-0x91, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79,
-0xa6, 0x05, 0x00, 0x39, 0x03, 0x03, 0xec, 0x01, 0x05, 0xfd,
+0x53, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0xed, 0x03, 0x04, 0x34,
+0x03, 0x01, 0xa8, 0x00, 0x02, 0xb7, 0x01, 0xc1, 0x65, 0x00,
+0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79,
+0xa6, 0x05, 0x02, 0x39, 0x03, 0x02, 0xec, 0x01, 0x04, 0xfd,
 0x01, 0xb0, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x00, 0x50,
 0x72, 0x65, 0x73, 0x6b, 0x06, 0x03, 0xae, 0x01, 0x00, 0x0d,
-0x01, 0x00, 0x37, 0x00, 0x0f, 0x31, 0x04, 0x00, 0x05, 0x72,
-0x02, 0x00, 0xd7, 0x02, 0x01, 0x31, 0x01, 0x0a, 0x60, 0x03,
-0x0b, 0xe8, 0x03, 0x08, 0x5b, 0x03, 0x00, 0x95, 0x01, 0x31,
-0x28, 0x73, 0x6f, 0x15, 0x03, 0x51, 0x63, 0x74, 0x73, 0x00,
-0x61, 0xe3, 0x06, 0x05, 0x63, 0x05, 0x78, 0x74, 0x6f, 0x6e,
+0x01, 0x00, 0x37, 0x00, 0x0f, 0x31, 0x04, 0x01, 0x04, 0xad,
+0x00, 0x00, 0xd7, 0x02, 0x02, 0x31, 0x01, 0x0e, 0x60, 0x03,
+0x06, 0xe8, 0x03, 0x08, 0x5b, 0x03, 0x00, 0x95, 0x01, 0x31,
+0x28, 0x73, 0x6f, 0x15, 0x03, 0x52, 0x63, 0x74, 0x73, 0x00,
+0x61, 0xe3, 0x06, 0x04, 0x63, 0x05, 0x78, 0x74, 0x6f, 0x6e,
 0x29, 0x2c, 0x00, 0x70, 0x8a, 0x00, 0x20, 0x73, 0x70, 0x93,
 0x04, 0x3f, 0x62, 0x61, 0x72, 0x89, 0x00, 0x02, 0x0e, 0xb6,
-0x04, 0xbb, 0x28, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72,
-0x6c, 0x79, 0x2c, 0x66, 0x00, 0x01, 0x4d, 0x04, 0x05, 0x67,
-0x00, 0x00, 0x32, 0x01, 0x13, 0x41, 0x03, 0x03, 0x21, 0x61,
-0x63, 0xd8, 0x06, 0x00, 0x58, 0x07, 0x42, 0x63, 0x72, 0x69,
-0x62, 0x4e, 0x04, 0x22, 0x73, 0x65, 0xef, 0x02, 0x30, 0x32,
-0x2e, 0x31, 0x7f, 0x01, 0x02, 0x57, 0x01, 0x81, 0x61, 0x76,
-0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0xb3, 0x02, 0xc5, 0x45,
-0x76, 0x65, 0x6e, 0x00, 0x55, 0x6e, 0x64, 0x6f, 0x00, 0x69,
-0x73, 0x1a, 0x00, 0x00, 0xb9, 0x01, 0x71, 0x6c, 0x74, 0x68,
-0x6f, 0x75, 0x67, 0x68, 0xd8, 0x01, 0x41, 0x6d, 0x69, 0x67,
-0x68, 0x71, 0x08, 0x31, 0x73, 0x69, 0x64, 0xe9, 0x04, 0x63,
+0x04, 0xbc, 0x28, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72,
+0x6c, 0x79, 0x2c, 0x66, 0x00, 0x01, 0x4d, 0x04, 0x04, 0x67,
+0x00, 0x00, 0x32, 0x01, 0x13, 0x41, 0x03, 0x03, 0x22, 0x61,
+0x63, 0xd8, 0x06, 0x72, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
+0x62, 0x4e, 0x04, 0x22, 0x73, 0x65, 0xef, 0x02, 0x31, 0x32,
+0x2e, 0x31, 0x7a, 0x03, 0x01, 0x57, 0x01, 0x50, 0x61, 0x76,
+0x61, 0x69, 0x6c, 0xa3, 0x06, 0x00, 0x3f, 0x00, 0x90, 0x45,
+0x76, 0x65, 0x6e, 0x00, 0x55, 0x6e, 0x64, 0x6f, 0x68, 0x02,
+0x05, 0x1a, 0x00, 0xa1, 0x2c, 0x00, 0x61, 0x6c, 0x74, 0x68,
+0x6f, 0x75, 0x67, 0x68, 0xd8, 0x01, 0x11, 0x6d, 0x75, 0x00,
+0x61, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0xe9, 0x04, 0x63,
 0x00, 0x63, 0x68, 0x65, 0x61, 0x74, 0x2b, 0x03, 0x20, 0x75,
-0x73, 0xe3, 0x06, 0x05, 0xb8, 0x08, 0x64, 0x73, 0x74, 0x65,
-0x70, 0x00, 0x6f, 0x98, 0x08, 0x01, 0xc8, 0x02, 0x00, 0xa7,
-0x07, 0x43, 0x67, 0x72, 0x61, 0x6d, 0xfe, 0x01, 0x95, 0x6e,
+0x73, 0xe3, 0x06, 0x05, 0xb8, 0x08, 0x66, 0x73, 0x74, 0x65,
+0x70, 0x00, 0x6f, 0x98, 0x08, 0x00, 0x9d, 0x00, 0x73, 0x70,
+0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0xfe, 0x01, 0x96, 0x6e,
 0x6c, 0x79, 0x00, 0x72, 0x65, 0x76, 0x65, 0x61, 0xbd, 0x03,
-0x01, 0xfb, 0x07, 0x41, 0x71, 0x75, 0x65, 0x73, 0xae, 0x00,
+0x00, 0xad, 0x00, 0x41, 0x71, 0x75, 0x65, 0x73, 0xae, 0x00,
 0x60, 0x28, 0x75, 0x6e, 0x6c, 0x69, 0x6b, 0x42, 0x06, 0x23,
-0x73, 0x74, 0x0d, 0x07, 0xb1, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+0x73, 0x74, 0x0d, 0x07, 0xb2, 0x69, 0x6d, 0x70, 0x6c, 0x65,
 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x14, 0x07, 0x02, 0x53,
-0x03, 0x03, 0x46, 0x00, 0x00, 0x07, 0x04, 0x04, 0xe2, 0x02,
+0x03, 0x03, 0x46, 0x00, 0x00, 0x07, 0x04, 0x03, 0xe2, 0x02,
 0x16, 0x29, 0x78, 0x05, 0x24, 0x74, 0x68, 0xdb, 0x00, 0x10,
 0x79, 0x31, 0x07, 0x53, 0x66, 0x61, 0x74, 0x61, 0x6c, 0x3d,
 0x02, 0x21, 0x6e, 0x64, 0x0f, 0x09, 0x41, 0x69, 0x6e, 0x75,
-0x65, 0xb8, 0x06, 0x01, 0xe4, 0x04, 0x03, 0x71, 0x05, 0x20,
-0x69, 0x6b, 0x31, 0x05, 0x0c, 0xb5, 0x00, 0x51, 0x74, 0x72,
-0x61, 0x63, 0x6b, 0xaf, 0x00, 0x60, 0x6e, 0x75, 0x6d, 0x62,
-0x65, 0x72, 0x70, 0x00, 0x01, 0xfe, 0x02, 0x02, 0x3d, 0x0a,
-0x81, 0x69, 0x65, 0x64, 0x00, 0x28, 0x61, 0x6e, 0x64, 0x70,
-0x00, 0x06, 0x1b, 0x06, 0x10, 0x72, 0x01, 0x08, 0x03, 0x51,
-0x08, 0x80, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x29,
-0x90, 0x0a, 0x05, 0x33, 0x03, 0x08, 0xdc, 0x07, 0x32, 0x65,
-0x6e, 0x64, 0xc6, 0x00, 0x02, 0x0e, 0x09, 0x05, 0xf6, 0x04,
-0x00, 0x2d, 0x00, 0x01, 0x05, 0x01, 0x20, 0x6f, 0x72, 0x55,
-0x00, 0x03, 0x71, 0x00, 0x12, 0x64, 0xf8, 0x05, 0x00, 0xa6,
-0x01, 0x40, 0x74, 0x00, 0x6d, 0x61, 0xa6, 0x06, 0x00, 0xea,
-0x03, 0x02, 0x41, 0x06, 0x01, 0xbf, 0x09, 0x14, 0x28, 0x3a,
-0x07, 0x10, 0x65, 0xb4, 0x03, 0x40, 0x00, 0x77, 0x61, 0x6e,
-0x6b, 0x00, 0x06, 0x49, 0x05, 0xb3, 0x66, 0x75, 0x6c, 0x6c,
-0x00, 0x6c, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x78, 0x00, 0x01,
-0x43, 0x0b, 0x03, 0x5c, 0x01, 0x0f, 0x79, 0x01, 0x02, 0x02,
-0x1d, 0x04, 0x00, 0x39, 0x05, 0x12, 0x77, 0x16, 0x04, 0x43,
-0x66, 0x74, 0x65, 0x72, 0x91, 0x00, 0x06, 0x70, 0x05, 0x03,
-0x0a, 0x09, 0x05, 0xc0, 0x03, 0x30, 0x53, 0x6f, 0x6c, 0x2f,
+0x65, 0xb8, 0x06, 0x01, 0xe4, 0x04, 0x03, 0x71, 0x05, 0x21,
+0x69, 0x6b, 0x31, 0x05, 0x0b, 0xb5, 0x00, 0x51, 0x74, 0x72,
+0x61, 0x63, 0x6b, 0xaf, 0x00, 0x61, 0x6e, 0x75, 0x6d, 0x62,
+0x65, 0x72, 0x70, 0x00, 0x01, 0xfe, 0x02, 0x01, 0x3d, 0x0a,
+0x50, 0x69, 0x65, 0x64, 0x00, 0x28, 0x57, 0x00, 0x01, 0x70,
+0x00, 0x05, 0x1b, 0x06, 0x12, 0x72, 0x01, 0x08, 0x01, 0x76,
+0x06, 0x80, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x29,
+0x90, 0x0a, 0x06, 0x33, 0x03, 0x07, 0xdc, 0x07, 0x34, 0x65,
+0x6e, 0x64, 0x69, 0x04, 0x01, 0x54, 0x07, 0x05, 0xf6, 0x04,
+0x31, 0x77, 0x68, 0x65, 0x05, 0x01, 0x21, 0x6f, 0x72, 0x55,
+0x00, 0x02, 0x71, 0x00, 0x12, 0x64, 0xf8, 0x05, 0x00, 0xa6,
+0x01, 0x41, 0x74, 0x00, 0x6d, 0x61, 0xa6, 0x06, 0x00, 0xea,
+0x03, 0x01, 0x41, 0x06, 0x01, 0xbf, 0x09, 0x14, 0x28, 0x3a,
+0x07, 0x10, 0x65, 0xb4, 0x03, 0x41, 0x00, 0x77, 0x61, 0x6e,
+0x6b, 0x00, 0x05, 0x49, 0x05, 0x80, 0x66, 0x75, 0x6c, 0x6c,
+0x00, 0x6c, 0x61, 0x79, 0x41, 0x00, 0x04, 0x78, 0x00, 0x34,
+0x72, 0x69, 0x64, 0x5c, 0x01, 0x0f, 0x79, 0x01, 0x02, 0x02,
+0xdb, 0x00, 0x10, 0x73, 0x5f, 0x0a, 0x01, 0x16, 0x04, 0x44,
+0x66, 0x74, 0x65, 0x72, 0x02, 0x01, 0x06, 0x70, 0x05, 0x03,
+0x0a, 0x09, 0x04, 0xc0, 0x03, 0x30, 0x53, 0x6f, 0x6c, 0x2f,
 0x06, 0x60, 0x65, 0x6e, 0x75, 0x00, 0x6f, 0x70, 0x47, 0x00,
 0x22, 0x2e, 0x29, 0x54, 0x08, 0x13, 0x32, 0x54, 0x08, 0x93,
 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x56,
 0x08, 0x13, 0x65, 0x28, 0x00, 0x07, 0x92, 0x02, 0x51, 0x00,
 0x66, 0x72, 0x6f, 0x6d, 0x4e, 0x00, 0xb3, 0x60, 0x43, 0x75,
 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x27, 0x00,
-0x32, 0x00, 0x6f, 0x6e, 0x1a, 0x00, 0x50, 0x54, 0x79, 0x70,
-0x65, 0x27, 0x69, 0x00, 0x01, 0x0a, 0x0b, 0xc2, 0x3a, 0x00,
-0x00, 0x00, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48,
-0x5c, 0x05, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x0b, 0x0c,
-0x02, 0x2c, 0x0c, 0x28, 0x69, 0x6e, 0xee, 0x0a, 0x11, 0x4d,
-0x98, 0x05, 0x34, 0x00, 0x00, 0x4e, 0xe0, 0x01, 0x05, 0xaa,
-0x05, 0x05, 0x1b, 0x01, 0x06, 0x5c, 0x02, 0x10, 0x65, 0xcb,
-0x01, 0x02, 0x54, 0x06, 0x02, 0x91, 0x0a, 0x72, 0x61, 0x62,
-0x73, 0x6f, 0x6c, 0x75, 0x74, 0xce, 0x02, 0x02, 0xec, 0x01,
-0x40, 0x2c, 0x00, 0x6f, 0x72, 0x48, 0x03, 0xa5, 0x65, 0x72,
-0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x21, 0x01,
-0xb5, 0x70, 0x75, 0x74, 0x00, 0x61, 0x00, 0x25, 0x00, 0x73,
-0x69, 0x67, 0xbe, 0x00, 0x11, 0x65, 0x83, 0x04, 0x04, 0xa5,
-0x0c, 0x35, 0x61, 0x73, 0x65, 0x0a, 0x02, 0x03, 0x5f, 0x0a,
-0x50, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x92, 0x05, 0x02, 0xe8,
-0x09, 0x01, 0xfc, 0x0a, 0x22, 0x6f, 0x72, 0x01, 0x01, 0x07,
-0xd4, 0x07, 0x09, 0xb3, 0x00, 0x03, 0xd6, 0x08, 0x04, 0xe0,
-0x05, 0x71, 0x00, 0x00, 0x42, 0x65, 0x77, 0x61, 0x72, 0x03,
-0x01, 0x42, 0x73, 0x65, 0x74, 0x74, 0xa1, 0x04, 0x06, 0xb5,
-0x00, 0x01, 0x22, 0x02, 0xb0, 0x6f, 0x00, 0x68, 0x69, 0x67,
-0x68, 0x2e, 0x00, 0x41, 0x74, 0x00, 0xeb, 0x0c, 0x01, 0x0e,
-0x00, 0x40, 0x00, 0x64, 0x65, 0x6e, 0x3a, 0x0b, 0x2a, 0x65,
-0x73, 0xd1, 0x03, 0x90, 0x6d, 0x61, 0x79, 0x00, 0x73, 0x70,
-0x65, 0x6e, 0x64, 0x97, 0x00, 0x01, 0x2e, 0x0b, 0x62, 0x73,
-0x65, 0x61, 0x72, 0x63, 0x68, 0x50, 0x0a, 0x01, 0x0a, 0x06,
-0x62, 0x6f, 0x6c, 0x76, 0x61, 0x62, 0x6c, 0x8e, 0x00, 0x01,
-0x72, 0x04, 0x01, 0x65, 0x0b, 0x10, 0x20, 0x2f, 0x01, 0x60,
-0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xa7, 0x01, 0x31, 0x68,
-0x65, 0x6e, 0x4e, 0x01, 0x03, 0xd2, 0x01, 0x00, 0x8d, 0x04,
-0x51, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x57, 0x03, 0x13, 0x73,
-0x07, 0x07, 0x15, 0x62, 0xe3, 0x0b, 0x21, 0x29, 0x2c, 0xaf,
-0x01, 0x02, 0x8f, 0x02, 0x08, 0xb7, 0x0b, 0x03, 0x4a, 0x01,
-0x32, 0x74, 0x69, 0x72, 0x71, 0x00, 0x01, 0x6e, 0x01, 0x12,
-0x62, 0xec, 0x02, 0x12, 0x79, 0x90, 0x0b, 0x00, 0x79, 0x05,
-0x30, 0x74, 0x61, 0x72, 0xfc, 0x00, 0x06, 0x55, 0x02, 0x62,
-0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x9a, 0x06, 0x01, 0xaf,
-0x05, 0x05, 0x88, 0x0d, 0x00, 0xca, 0x05, 0x33, 0x66, 0x65,
-0x72, 0x7d, 0x05, 0x51, 0x73, 0x6b, 0x69, 0x65, 0x72, 0x5a,
-0x00, 0x14, 0x73, 0x5e, 0x0c, 0x01, 0xfc, 0x0c, 0x0f, 0x2e,
-0x03, 0x03, 0x06, 0x12, 0x03, 0x41, 0x73, 0x77, 0x69, 0x74,
-0x48, 0x08, 0x15, 0x66, 0xe7, 0x00, 0x50, 0x69, 0x6f, 0x6e,
-0x2e, 0x00,
+0x00, 0x6e, 0x02, 0x01, 0x1a, 0x00, 0x52, 0x54, 0x79, 0x70,
+0x65, 0x27, 0x69, 0x00, 0xf2, 0x00, 0x61, 0x72, 0x65, 0x3a,
+0x00, 0x00, 0x00, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00,
+0x48, 0x5c, 0x05, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x0b,
+0x0c, 0x01, 0x2c, 0x0c, 0x28, 0x69, 0x6e, 0xee, 0x0a, 0x11,
+0x4d, 0x98, 0x05, 0x35, 0x00, 0x00, 0x4e, 0xe0, 0x01, 0x09,
+0xaa, 0x05, 0x00, 0x32, 0x00, 0x06, 0x5c, 0x02, 0x10, 0x65,
+0xcb, 0x01, 0x02, 0x54, 0x06, 0x02, 0x91, 0x0a, 0x73, 0x61,
+0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0xce, 0x02, 0x01, 0xec,
+0x01, 0x10, 0x2c, 0xb1, 0x01, 0xd5, 0x61, 0x6c, 0x74, 0x65,
+0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x21,
+0x01, 0xb5, 0x70, 0x75, 0x74, 0x00, 0x61, 0x00, 0x25, 0x00,
+0x73, 0x69, 0x67, 0xbe, 0x00, 0x12, 0x65, 0x83, 0x04, 0x03,
+0xa5, 0x0c, 0x36, 0x61, 0x73, 0x65, 0x0a, 0x02, 0x02, 0x5f,
+0x0a, 0x52, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x92, 0x05, 0x01,
+0x51, 0x02, 0x00, 0xfc, 0x0a, 0x24, 0x6f, 0x72, 0x0b, 0x07,
+0x06, 0xd4, 0x07, 0x09, 0xb3, 0x00, 0x03, 0x64, 0x05, 0x03,
+0xe0, 0x05, 0x71, 0x00, 0x00, 0x42, 0x65, 0x77, 0x61, 0x72,
+0x03, 0x01, 0x44, 0x73, 0x65, 0x74, 0x74, 0xa1, 0x04, 0x06,
+0xb5, 0x00, 0xe1, 0x00, 0x74, 0x6f, 0x6f, 0x00, 0x68, 0x69,
+0x67, 0x68, 0x2e, 0x00, 0x41, 0x74, 0x00, 0xeb, 0x0c, 0x00,
+0x0e, 0x00, 0x40, 0x00, 0x64, 0x65, 0x6e, 0x3a, 0x0b, 0x2a,
+0x65, 0x73, 0xd1, 0x03, 0x60, 0x6d, 0x61, 0x79, 0x00, 0x73,
+0x70, 0xbb, 0x00, 0x31, 0x66, 0x6f, 0x72, 0x2e, 0x0b, 0x64,
+0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x50, 0x0a, 0x61, 0x61,
+0x00, 0x73, 0x6f, 0x6c, 0x76, 0xc1, 0x01, 0x02, 0x41, 0x01,
+0x31, 0x00, 0x00, 0x45, 0x65, 0x0b, 0x10, 0x20, 0x2f, 0x01,
+0x60, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xa7, 0x01, 0x00,
+0x0f, 0x03, 0x01, 0x4e, 0x01, 0x03, 0xd2, 0x01, 0x50, 0x69,
+0x73, 0x00, 0x65, 0x6e, 0x37, 0x00, 0x00, 0x57, 0x03, 0x13,
+0x73, 0x07, 0x07, 0x15, 0x62, 0xe3, 0x0b, 0x23, 0x29, 0x2c,
+0xaf, 0x01, 0x01, 0x1a, 0x01, 0x08, 0xb7, 0x0b, 0x02, 0x4a,
+0x01, 0x33, 0x74, 0x69, 0x72, 0xff, 0x00, 0x00, 0x6e, 0x01,
+0x12, 0x62, 0xec, 0x02, 0x13, 0x79, 0x90, 0x0b, 0x61, 0x64,
+0x00, 0x73, 0x74, 0x61, 0x72, 0xfc, 0x00, 0x05, 0x55, 0x02,
+0x63, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x9a, 0x06, 0x01,
+0xaf, 0x05, 0x05, 0xd0, 0x04, 0x63, 0x70, 0x72, 0x65, 0x66,
+0x65, 0x72, 0x7d, 0x05, 0x51, 0x73, 0x6b, 0x69, 0x65, 0x72,
+0x5a, 0x00, 0x15, 0x73, 0x5e, 0x0c, 0x01, 0xfc, 0x0c, 0x0f,
+0xa7, 0x04, 0x04, 0x04, 0xf1, 0x01, 0x41, 0x73, 0x77, 0x69,
+0x74, 0x48, 0x08, 0x15, 0x66, 0xe7, 0x00, 0x50, 0x69, 0x6f,
+0x6e, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3796;
diff --git a/apps/plugins/puzzles/help/net.c b/apps/plugins/puzzles/help/net.c
index 504de3fca5..d83892c110 100644
--- a/apps/plugins/puzzles/help/net.c
+++ b/apps/plugins/puzzles/help/net.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -27,7 +27,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3439 comp 2361 ratio 0.686537 level 11 saved 1078 */
+/* orig 3439 comp 2361 ratio 0.686537 level 10 saved 1078 */
 const char help_text[] = {
 0xf4, 0x57, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x3a, 0x20, 0x4e, 0x65, 0x74, 0x20, 0x00, 0x00, 0x00,
@@ -45,7 +45,7 @@ const char help_text[] = {
 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x61,
 0x77, 0x62, 0x00, 0x21, 0x69, 0x6e, 0x81, 0x00, 0x40, 0x66,
 0x6f, 0x72, 0x6d, 0x76, 0x00, 0x30, 0x61, 0x00, 0x46, 0x4f,
-0x00, 0x01, 0x79, 0x00, 0x04, 0x76, 0x00, 0xf0, 0x18, 0x46,
+0x00, 0x02, 0x79, 0x00, 0x03, 0x76, 0x00, 0xf0, 0x18, 0x46,
 0x72, 0x65, 0x65, 0x4e, 0x65, 0x74, 0x00, 0x5b, 0x31, 0x5d,
 0x2c, 0x00, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00,
 0x62, 0x79, 0x00, 0x50, 0x61, 0x76, 0x69, 0x6c, 0x73, 0x00,
@@ -60,12 +60,12 @@ const char help_text[] = {
 0x74, 0x65, 0x72, 0x00, 0x70, 0x72, 0x65, 0x70, 0x61, 0x72,
 0x65, 0x73, 0x00, 0x61, 0x00, 0x6e, 0x65, 0x74, 0x77, 0x6f,
 0x72, 0x6b, 0x73, 0x00, 0x70, 0x63, 0x6f, 0x6e, 0x6e, 0x65,
-0x63, 0x74, 0xee, 0x00, 0x21, 0x75, 0x70, 0x43, 0x00, 0x70,
-0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x73, 0xbc, 0x00, 0x61,
-0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0xd3, 0x00, 0xb0, 0x61,
+0x63, 0x74, 0xee, 0x00, 0x21, 0x75, 0x70, 0x43, 0x00, 0x40,
+0x63, 0x65, 0x6e, 0x74, 0x27, 0x00, 0x61, 0x6f, 0x66, 0x00,
+0x73, 0x71, 0x75, 0x32, 0x00, 0xe0, 0x69, 0x6e, 0x00, 0x61,
 0x00, 0x67, 0x72, 0x69, 0x64, 0x2c, 0x00, 0x61, 0x6e, 0x64,
-0x26, 0x00, 0xa0, 0x6e, 0x00, 0x73, 0x68, 0x75, 0x66, 0x66,
-0x6c, 0x65, 0x73, 0x0e, 0x00, 0x08, 0x51, 0x00, 0x41, 0x72,
+0x26, 0x00, 0xa2, 0x6e, 0x00, 0x73, 0x68, 0x75, 0x66, 0x66,
+0x6c, 0x65, 0x73, 0x77, 0x00, 0x06, 0x51, 0x00, 0x41, 0x72,
 0x6f, 0x74, 0x61, 0x4f, 0x00, 0x00, 0xb2, 0x00, 0xf0, 0x0a,
 0x79, 0x00, 0x74, 0x69, 0x6c, 0x65, 0x00, 0x72, 0x61, 0x6e,
 0x64, 0x6f, 0x6d, 0x6c, 0x79, 0x2e, 0x00, 0x59, 0x6f, 0x75,
@@ -81,8 +81,8 @@ const char help_text[] = {
 0x03, 0x6e, 0x6f, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64,
 0x00, 0x6c, 0x6f, 0x6f, 0x70, 0x73, 0x2e, 0x00, 0x41, 0x02,
 0x01, 0x81, 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x00, 0x61,
-0xd3, 0x00, 0x21, 0x6c, 0x6c, 0xa7, 0x00, 0x70, 0x73, 0x00,
-0x77, 0x68, 0x69, 0x63, 0x68, 0x70, 0x01, 0x07, 0x4e, 0x00,
+0xd3, 0x00, 0x21, 0x6c, 0x6c, 0xa7, 0x00, 0x71, 0x73, 0x00,
+0x77, 0x68, 0x69, 0x63, 0x68, 0x70, 0x01, 0x06, 0x4e, 0x00,
 0x21, 0x74, 0x6f, 0xe2, 0x00, 0x34, 0x6f, 0x6e, 0x65, 0xda,
 0x01, 0x52, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x97, 0x01, 0xe0,
 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x65,
@@ -92,8 +92,8 @@ const char help_text[] = {
 0x66, 0x66, 0x2f, 0x6e, 0x65, 0x74, 0x2f, 0xfc, 0x01, 0xa1,
 0x2e, 0x68, 0x74, 0x6d, 0x00, 0x00, 0x00, 0x33, 0x2e, 0x31,
 0xbd, 0x02, 0x80, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
-0x73, 0xc6, 0x02, 0x15, 0x54, 0xa8, 0x02, 0x60, 0x63, 0x61,
-0x6e, 0x00, 0x62, 0x65, 0x0e, 0x01, 0x32, 0x79, 0x65, 0x64,
+0x73, 0xc6, 0x02, 0x15, 0x54, 0xa8, 0x02, 0x30, 0x63, 0x61,
+0x6e, 0xe7, 0x00, 0x62, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x64,
 0xcf, 0x00, 0x43, 0x65, 0x69, 0x74, 0x68, 0xec, 0x01, 0xb2,
 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x6f,
 0x72, 0x98, 0x00, 0x33, 0x6f, 0x75, 0x73, 0x35, 0x01, 0x04,
@@ -106,15 +106,15 @@ const char help_text[] = {
 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x77, 0x69, 0x73, 0x65, 0x3a,
 0x00, 0x6c, 0x65, 0x66, 0x74, 0x3c, 0x00, 0xb0, 0x62, 0x75,
 0x74, 0x74, 0x6f, 0x6e, 0x2c, 0x00, 0x60, 0x41, 0x27, 0x39,
-0x00, 0x0b, 0x38, 0x00, 0x07, 0x34, 0x00, 0x4d, 0x72, 0x69,
-0x67, 0x68, 0x35, 0x00, 0x1f, 0x44, 0x35, 0x00, 0x01, 0xf4,
+0x00, 0x0b, 0x38, 0x00, 0x07, 0x34, 0x00, 0x10, 0x72, 0x1c,
+0x01, 0x0c, 0x35, 0x00, 0x1f, 0x44, 0x35, 0x00, 0x01, 0xf4,
 0x03, 0x62, 0x79, 0x20, 0x31, 0x38, 0x30, 0x20, 0x64, 0x65,
 0x67, 0x72, 0x65, 0x65, 0x73, 0x3a, 0x00, 0x60, 0x46, 0x26,
 0x00, 0xb0, 0x4c, 0x6f, 0x63, 0x6b, 0x20, 0x28, 0x6f, 0x72,
-0x20, 0x75, 0x6e, 0x59, 0x00, 0x12, 0x29, 0xc6, 0x00, 0x03,
-0x86, 0x01, 0x0b, 0x5c, 0x00, 0xf3, 0x00, 0x73, 0x68, 0x69,
+0x20, 0x75, 0x6e, 0x59, 0x00, 0x14, 0x29, 0xc6, 0x00, 0x02,
+0x86, 0x01, 0x0a, 0x5c, 0x00, 0xf4, 0x00, 0x73, 0x68, 0x69,
 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x2c, 0x00,
-0x60, 0x53, 0x43, 0x00, 0x00, 0x76, 0x02, 0x01, 0x4c, 0x01,
+0x60, 0x53, 0x43, 0x00, 0x31, 0x59, 0x6f, 0x75, 0x4c, 0x01,
 0x00, 0x40, 0x00, 0x22, 0x00, 0x61, 0x94, 0x02, 0xa0, 0x6f,
 0x6e, 0x63, 0x65, 0x00, 0x79, 0x6f, 0x75, 0x27, 0x72, 0x64,
 0x02, 0x20, 0x72, 0x65, 0xf0, 0x02, 0x30, 0x69, 0x74, 0x73,
@@ -122,70 +122,70 @@ const char help_text[] = {
 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x80, 0x00, 0x01, 0xad, 0x02,
 0x50, 0x67, 0x61, 0x69, 0x6e, 0x2c, 0x76, 0x00, 0x00, 0x33,
 0x02, 0x10, 0x6c, 0xc1, 0x02, 0x21, 0x27, 0x73, 0x5e, 0x00,
-0x42, 0x65, 0x64, 0x00, 0x79, 0x34, 0x00, 0xb1, 0x27, 0x74,
-0x00, 0x61, 0x63, 0x63, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x20,
-0x04, 0x80, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x69, 0x74, 0x2e,
-0xe1, 0x01, 0x01, 0x1f, 0x04, 0x79, 0x6c, 0x6c, 0x6f, 0x77,
-0x69, 0x6e, 0x67, 0xac, 0x01, 0x70, 0x00, 0x6e, 0x6f, 0x74,
+0x42, 0x65, 0x64, 0x00, 0x79, 0x34, 0x00, 0x80, 0x27, 0x74,
+0x00, 0x61, 0x63, 0x63, 0x69, 0x64, 0x4d, 0x00, 0x00, 0x20,
+0x04, 0x81, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x69, 0x74, 0x2e,
+0xe1, 0x01, 0x00, 0x1f, 0x04, 0x40, 0x6c, 0x6c, 0x6f, 0x77,
+0x28, 0x03, 0x08, 0xac, 0x01, 0x70, 0x00, 0x6e, 0x6f, 0x74,
 0x00, 0x6e, 0x65, 0xf1, 0x02, 0x10, 0x61, 0x3d, 0x03, 0x11,
-0x6f, 0xbf, 0x03, 0x40, 0x6c, 0x65, 0x74, 0x65, 0xe2, 0x01,
-0x01, 0x15, 0x02, 0x02, 0x77, 0x00, 0x30, 0x6d, 0x61, 0x79,
+0x6f, 0xbf, 0x03, 0x41, 0x6c, 0x65, 0x74, 0x65, 0xe2, 0x01,
+0x00, 0x15, 0x02, 0x02, 0x77, 0x00, 0x30, 0x6d, 0x61, 0x79,
 0x1a, 0x02, 0x61, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0xe2,
 0x01, 0x00, 0xfa, 0x00, 0x10, 0x20, 0xa4, 0x03, 0x12, 0x3a,
 0x0c, 0x00, 0x2a, 0x00, 0x2b, 0xda, 0x01, 0x21, 0x4f, 0x6e,
 0xc2, 0x03, 0x00, 0xb0, 0x03, 0x84, 0x61, 0x74, 0x00, 0x77,
-0x72, 0x61, 0x70, 0x2c, 0xab, 0x00, 0x41, 0x00, 0x6d, 0x6f,
-0x76, 0x61, 0x00, 0x02, 0xd0, 0x04, 0x03, 0x2d, 0x05, 0x13,
-0x65, 0xf2, 0x03, 0x21, 0x73, 0x6f, 0x33, 0x00, 0x01, 0x36,
-0x01, 0x04, 0x3e, 0x00, 0x00, 0x97, 0x04, 0x00, 0x55, 0x05,
+0x72, 0x61, 0x70, 0x2c, 0xab, 0x00, 0x42, 0x00, 0x6d, 0x6f,
+0x76, 0x61, 0x00, 0x02, 0xd0, 0x04, 0x02, 0x2d, 0x05, 0x13,
+0x65, 0xf2, 0x03, 0x22, 0x73, 0x6f, 0x33, 0x00, 0x02, 0x23,
+0x03, 0x02, 0x3e, 0x00, 0x00, 0x97, 0x04, 0x00, 0x55, 0x05,
 0xd8, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x00, 0x73,
 0x69, 0x64, 0x65, 0x73, 0x37, 0x00, 0x04, 0xbb, 0x02, 0x90,
 0x73, 0x65, 0x65, 0x6e, 0x00, 0x74, 0x6f, 0x67, 0x65, 0xb6,
 0x02, 0x00, 0xfc, 0x00, 0x52, 0x4d, 0x6f, 0x76, 0x65, 0x20,
-0x63, 0x04, 0x69, 0x3a, 0x00, 0x43, 0x74, 0x72, 0x6c, 0xa8,
-0x00, 0x07, 0xac, 0x01, 0x62, 0x63, 0x68, 0x61, 0x6e, 0x67,
-0x65, 0x93, 0x03, 0x00, 0x7c, 0x00, 0x01, 0xb6, 0x05, 0x10,
-0x75, 0xc8, 0x03, 0x12, 0x61, 0x74, 0x04, 0x50, 0x73, 0x6f,
-0x75, 0x72, 0x63, 0xb7, 0x01, 0x05, 0x86, 0x03, 0x00, 0x77,
-0x04, 0xa0, 0x2e, 0x00, 0x28, 0x49, 0x74, 0x00, 0x64, 0x6f,
+0x63, 0x04, 0x6c, 0x3a, 0x00, 0x43, 0x74, 0x72, 0x6c, 0xa8,
+0x00, 0x04, 0x73, 0x01, 0x63, 0x63, 0x68, 0x61, 0x6e, 0x67,
+0x65, 0x93, 0x03, 0x11, 0x74, 0x65, 0x01, 0x30, 0x73, 0x00,
+0x75, 0xc8, 0x03, 0x12, 0x61, 0x74, 0x04, 0x51, 0x73, 0x6f,
+0x75, 0x72, 0x63, 0xb7, 0x01, 0x05, 0x86, 0x03, 0xd0, 0x69,
+0x6e, 0x67, 0x2e, 0x00, 0x28, 0x49, 0x74, 0x00, 0x64, 0x6f,
 0x65, 0x73, 0x82, 0x01, 0x70, 0x75, 0x6c, 0x74, 0x69, 0x6d,
-0x61, 0x74, 0x20, 0x04, 0x67, 0x6d, 0x61, 0x74, 0x74, 0x65,
-0x72, 0x50, 0x00, 0x03, 0xae, 0x05, 0x57, 0x73, 0x2c, 0x00,
-0x61, 0x73, 0xad, 0x04, 0x03, 0x5d, 0x04, 0x0a, 0x03, 0x04,
-0x02, 0x20, 0x00, 0x02, 0x7e, 0x05, 0x01, 0x26, 0x00, 0x02,
-0x13, 0x05, 0x74, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74,
-0x99, 0x04, 0x03, 0x13, 0x02, 0x15, 0x69, 0x9f, 0x01, 0x74,
-0x68, 0x65, 0x6c, 0x70, 0x66, 0x75, 0x6c, 0x39, 0x04, 0x01,
+0x61, 0x74, 0x20, 0x04, 0x30, 0x6d, 0x61, 0x74, 0x06, 0x05,
+0x07, 0x50, 0x00, 0x02, 0xae, 0x05, 0x20, 0x73, 0x2c, 0x51,
+0x00, 0x07, 0xad, 0x04, 0x04, 0x5d, 0x04, 0x09, 0x03, 0x04,
+0x02, 0x20, 0x00, 0x02, 0x7e, 0x05, 0x02, 0x8d, 0x00, 0x00,
+0x13, 0x05, 0x75, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74,
+0x99, 0x04, 0x02, 0x9c, 0x01, 0x15, 0x69, 0x9f, 0x01, 0x40,
+0x68, 0x65, 0x6c, 0x70, 0xb9, 0x04, 0x03, 0x39, 0x04, 0x01,
 0x71, 0x03, 0x50, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x33, 0x01,
-0x33, 0x74, 0x61, 0x67, 0x66, 0x05, 0x61, 0x6f, 0x6c, 0x76,
-0x69, 0x6e, 0x67, 0x23, 0x00, 0x61, 0x70, 0x75, 0x7a, 0x7a,
-0x6c, 0x65, 0x5e, 0x06, 0x51, 0x4a, 0x75, 0x6d, 0x62, 0x6c,
-0x1e, 0x03, 0x01, 0x10, 0x03, 0x11, 0x4a, 0xcd, 0x02, 0x04,
-0x1f, 0x04, 0x22, 0x6b, 0x65, 0x52, 0x02, 0x10, 0x73, 0xbe,
-0x04, 0x07, 0x9b, 0x01, 0x04, 0x45, 0x02, 0x04, 0x8d, 0x02,
+0x33, 0x74, 0x61, 0x67, 0x66, 0x05, 0x30, 0x6f, 0x6c, 0x76,
+0x09, 0x02, 0x00, 0x23, 0x00, 0x61, 0x70, 0x75, 0x7a, 0x7a,
+0x6c, 0x65, 0x5e, 0x06, 0x52, 0x4a, 0x75, 0x6d, 0x62, 0x6c,
+0x1e, 0x03, 0x00, 0x10, 0x03, 0x14, 0x4a, 0xcd, 0x02, 0x01,
+0x1f, 0x04, 0x22, 0x6b, 0x65, 0x52, 0x02, 0x17, 0x73, 0xbe,
+0x04, 0x01, 0x9b, 0x01, 0x04, 0x45, 0x02, 0x03, 0x8d, 0x02,
 0x23, 0x74, 0x6f, 0x7d, 0x05, 0x08, 0xd8, 0x02, 0x20, 0x73,
 0x2e, 0x2c, 0x07, 0x31, 0x41, 0x6c, 0x6c, 0x73, 0x00, 0x22,
 0x61, 0x63, 0x45, 0x06, 0x90, 0x64, 0x65, 0x73, 0x63, 0x72,
 0x69, 0x62, 0x65, 0x64, 0xaf, 0x00, 0x31, 0x73, 0x65, 0x63,
-0x6a, 0x05, 0x30, 0x32, 0x2e, 0x31, 0x53, 0x00, 0x02, 0x01,
+0x6a, 0x05, 0x31, 0x32, 0x2e, 0x31, 0x53, 0x00, 0x01, 0x01,
 0x03, 0x73, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0xa0,
 0x00, 0x31, 0x33, 0x2e, 0x32, 0xbb, 0x04, 0x93, 0x70, 0x61,
-0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0xbd, 0x04, 0x45,
-0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x01, 0xd6, 0x02, 0x06,
+0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0xbd, 0x04, 0x10,
+0x65, 0x5d, 0x04, 0x05, 0x14, 0x00, 0x02, 0x3e, 0x00, 0x04,
 0x39, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x76, 0x00,
 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6c, 0x00, 0x22, 0x6f, 0x6e,
 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0xa8, 0x00, 0x90, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0xe1, 0x01, 0x00, 0xe9, 0x02,
-0x20, 0x69, 0x7a, 0xf5, 0x01, 0x02, 0x66, 0x02, 0x22, 0x69,
+0x65, 0x6e, 0x75, 0xa8, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74,
+0x68, 0x2c, 0x00, 0x48, 0x65, 0x4b, 0x04, 0x51, 0x00, 0x00,
+0x53, 0x69, 0x7a, 0xf5, 0x01, 0x01, 0x66, 0x02, 0x22, 0x69,
 0x6e, 0xfc, 0x00, 0x01, 0x29, 0x00, 0x50, 0x61, 0x6c, 0x6c,
 0x73, 0x20, 0xd9, 0x02, 0x70, 0x20, 0x61, 0x72, 0x6f, 0x75,
 0x6e, 0x64, 0xa2, 0x07, 0x50, 0x66, 0x00, 0x63, 0x68, 0x65,
 0x0a, 0x01, 0x61, 0x2c, 0x00, 0x66, 0x6c, 0x6f, 0x77, 0x5a,
-0x02, 0x45, 0x70, 0x61, 0x73, 0x73, 0x89, 0x00, 0x02, 0xd7,
-0x04, 0x43, 0x65, 0x64, 0x67, 0x65, 0xea, 0x05, 0x01, 0xb4,
-0x04, 0x02, 0x12, 0x00, 0x01, 0xee, 0x06, 0x03, 0x2a, 0x00,
+0x02, 0x46, 0x70, 0x61, 0x73, 0x73, 0x89, 0x00, 0x01, 0xd7,
+0x04, 0x44, 0x65, 0x64, 0x67, 0x65, 0xea, 0x05, 0x02, 0xb4,
+0x04, 0x00, 0x12, 0x00, 0x02, 0xee, 0x06, 0x02, 0x2a, 0x00,
 0x20, 0x6f, 0x70, 0x20, 0x00, 0x62, 0x62, 0x6f, 0x74, 0x74,
 0x6f, 0x6d, 0x18, 0x00, 0x41, 0x76, 0x69, 0x63, 0x65, 0x5f,
 0x08, 0x10, 0x61, 0x7e, 0x00, 0xf0, 0x03, 0x42, 0x61, 0x72,
@@ -195,19 +195,19 @@ const char help_text[] = {
 0x77, 0x0b, 0x03, 0x31, 0x30, 0x2e, 0x30, 0x3d, 0x00, 0x34,
 0x31, 0x2e, 0x30, 0xf9, 0x03, 0x11, 0x6c, 0x6a, 0x08, 0x11,
 0x68, 0x22, 0x03, 0x00, 0xd2, 0x06, 0x51, 0x69, 0x6d, 0x6d,
-0x6f, 0x76, 0x2d, 0x01, 0x12, 0x62, 0x54, 0x00, 0x32, 0x00,
-0x69, 0x73, 0x11, 0x07, 0x15, 0x64, 0x47, 0x00, 0x34, 0x74,
-0x77, 0x6f, 0xf5, 0x01, 0x10, 0x6f, 0xd9, 0x07, 0x41, 0x76,
-0x65, 0x6e, 0x74, 0xe1, 0x00, 0x06, 0x22, 0x00, 0x61, 0x68,
+0x6f, 0x76, 0x2d, 0x01, 0x12, 0x62, 0x54, 0x00, 0x00, 0xf9,
+0x02, 0x01, 0x11, 0x07, 0x15, 0x64, 0x47, 0x00, 0x34, 0x74,
+0x77, 0x6f, 0xf5, 0x01, 0x10, 0x6f, 0xd9, 0x07, 0x42, 0x76,
+0x65, 0x6e, 0x74, 0xe1, 0x00, 0x05, 0x22, 0x00, 0x61, 0x68,
 0x65, 0x6d, 0x00, 0x28, 0x61, 0x1c, 0x03, 0x24, 0x65, 0x72,
 0x87, 0x00, 0x95, 0x67, 0x69, 0x76, 0x65, 0x73, 0x00, 0x6d,
-0x6f, 0x72, 0x5d, 0x00, 0x83, 0x73, 0x29, 0x2e, 0x00, 0x53,
-0x69, 0x6e, 0x63, 0x11, 0x00, 0x03, 0xb2, 0x01, 0x06, 0x85,
-0x00, 0x10, 0x2c, 0x4a, 0x00, 0x10, 0x79, 0x25, 0x02, 0x30,
-0x00, 0x61, 0x73, 0xb3, 0x00, 0x83, 0x73, 0x74, 0x72, 0x61,
-0x69, 0x6e, 0x74, 0x73, 0xaf, 0x01, 0x06, 0x95, 0x07, 0x80,
+0x6f, 0x72, 0x5d, 0x00, 0x86, 0x73, 0x29, 0x2e, 0x00, 0x53,
+0x69, 0x6e, 0x63, 0x11, 0x00, 0x01, 0xb2, 0x01, 0x05, 0x85,
+0x00, 0x10, 0x2c, 0x4a, 0x00, 0x10, 0x79, 0x25, 0x02, 0x00,
+0x27, 0x03, 0xb4, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61,
+0x69, 0x6e, 0x74, 0x73, 0xaf, 0x01, 0x05, 0x95, 0x07, 0x80,
 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x2c, 0x00, 0x68, 0x1d, 0x00,
-0x11, 0x29, 0xe7, 0x04, 0x04, 0x0c, 0x04, 0x51, 0x67, 0x65,
+0x14, 0x29, 0xe7, 0x04, 0x01, 0xa6, 0x01, 0x51, 0x67, 0x65,
 0x6e, 0x65, 0x72, 0x7a, 0x02, 0x00, 0xb1, 0x01, 0x00, 0xf9,
 0x08, 0x50, 0x68, 0x61, 0x73, 0x00, 0x62, 0xa7, 0x00, 0x30,
 0x63, 0x61, 0x72, 0xc2, 0x04, 0x20, 0x6c, 0x79, 0x05, 0x04,
@@ -215,54 +215,54 @@ const char help_text[] = {
 0x00, 0x60, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x52, 0x05,
 0x04, 0x6b, 0x04, 0x48, 0x72, 0x65, 0x73, 0x74, 0x77, 0x04,
 0x12, 0x2e, 0x1e, 0x03, 0x43, 0x6d, 0x65, 0x61, 0x6e, 0x10,
-0x03, 0x20, 0x69, 0x66, 0xe6, 0x04, 0x00, 0x13, 0x03, 0x50,
-0x65, 0x00, 0x64, 0x6f, 0x77, 0xb4, 0x00, 0x04, 0x90, 0x08,
-0x00, 0x9d, 0x04, 0x12, 0x64, 0x53, 0x04, 0x24, 0x74, 0x6f,
-0xa5, 0x00, 0x12, 0x65, 0x04, 0x09, 0x63, 0x75, 0x72, 0x72,
-0x65, 0x6e, 0x74, 0x8f, 0x03, 0x57, 0x00, 0x28, 0x73, 0x65,
-0x65, 0x13, 0x03, 0x32, 0x32, 0x29, 0x2c, 0x9f, 0x04, 0x01,
-0x2d, 0x00, 0x0f, 0xfb, 0x01, 0x01, 0x06, 0x01, 0x03, 0x07,
+0x03, 0x21, 0x69, 0x66, 0xe6, 0x04, 0x82, 0x6e, 0x6f, 0x74,
+0x65, 0x00, 0x64, 0x6f, 0x77, 0xb4, 0x00, 0x03, 0x13, 0x03,
+0x42, 0x73, 0x65, 0x65, 0x64, 0x53, 0x04, 0x24, 0x74, 0x6f,
+0xa5, 0x00, 0x12, 0x65, 0x04, 0x09, 0x30, 0x75, 0x72, 0x72,
+0x67, 0x00, 0x02, 0x8f, 0x03, 0x57, 0x00, 0x28, 0x73, 0x65,
+0x65, 0x13, 0x03, 0x34, 0x32, 0x29, 0x2c, 0x9f, 0x04, 0x00,
+0x2d, 0x00, 0x0f, 0xfb, 0x01, 0x01, 0x05, 0x01, 0x03, 0x07,
 0x32, 0x09, 0x40, 0x72, 0x65, 0x2d, 0x65, 0x02, 0x04, 0x02,
 0x37, 0x01, 0x29, 0x61, 0x6d, 0x88, 0x00, 0x02, 0x8d, 0x05,
 0x70, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x6f, 0x00,
-0x74, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x2d, 0x00,
-0x01, 0x31, 0x04, 0x10, 0x72, 0xe2, 0x04, 0x01, 0xe9, 0x00,
-0x02, 0xdd, 0x08, 0x03, 0x9a, 0x08, 0x24, 0x6c, 0x79, 0x8f,
-0x00, 0x23, 0x62, 0x65, 0x49, 0x04, 0x04, 0xf1, 0x01, 0x25,
-0x6f, 0x66, 0x44, 0x01, 0x75, 0x2e, 0x00, 0x53, 0x6f, 0x00,
-0x69, 0x66, 0xf4, 0x06, 0x60, 0x74, 0x75, 0x63, 0x6b, 0x00,
+0x76, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x2d, 0x00,
+0x41, 0x73, 0x74, 0x61, 0x72, 0x59, 0x09, 0x02, 0x97, 0x05,
+0x01, 0x0e, 0x08, 0x02, 0x9a, 0x08, 0x24, 0x6c, 0x79, 0x8f,
+0x00, 0x24, 0x62, 0x65, 0x49, 0x04, 0x03, 0xf1, 0x01, 0x25,
+0x6f, 0x66, 0x44, 0x01, 0x43, 0x2e, 0x00, 0x53, 0x6f, 0x0f,
+0x01, 0x01, 0xf4, 0x06, 0x60, 0x74, 0x75, 0x63, 0x6b, 0x00,
 0x6f, 0xc7, 0x04, 0x10, 0x70, 0x59, 0x00, 0x52, 0x63, 0x75,
 0x6c, 0x61, 0x72, 0xb0, 0x01, 0x20, 0x61, 0x6e, 0x45, 0x09,
-0x00, 0x6a, 0x05, 0x01, 0xce, 0x01, 0x03, 0x28, 0x06, 0x00,
-0x9a, 0x00, 0x02, 0x85, 0x00, 0x00, 0x2a, 0x0a, 0x23, 0x61,
-0x6e, 0x8b, 0x0a, 0x51, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x88,
-0x05, 0x00, 0xda, 0x01, 0x40, 0x2c, 0x00, 0x73, 0x65, 0x20,
-0x00, 0x04, 0xb7, 0x00, 0x08, 0x0b, 0x04, 0x01, 0x1d, 0x05,
-0x04, 0x92, 0x02, 0x05, 0xdd, 0x02, 0x07, 0x36, 0x01, 0x02,
-0x2c, 0x01, 0x01, 0x24, 0x01, 0x05, 0xef, 0x06, 0x01, 0x1d,
-0x01, 0x05, 0xae, 0x03, 0x05, 0x71, 0x0b, 0x01, 0x46, 0x02,
+0x00, 0x6a, 0x05, 0x01, 0xce, 0x01, 0x03, 0x28, 0x06, 0x02,
+0x9a, 0x00, 0x00, 0x85, 0x00, 0x00, 0x2a, 0x0a, 0x23, 0x61,
+0x6e, 0x8b, 0x0a, 0x52, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x88,
+0x05, 0x71, 0x4e, 0x65, 0x74, 0x2c, 0x00, 0x73, 0x65, 0x20,
+0x00, 0x05, 0xb7, 0x00, 0x07, 0x0b, 0x04, 0x00, 0x1d, 0x05,
+0x05, 0x92, 0x02, 0x04, 0xdd, 0x02, 0x07, 0x36, 0x01, 0x02,
+0x2c, 0x01, 0x06, 0x24, 0x01, 0x01, 0x04, 0x09, 0x01, 0xa5,
+0x01, 0x05, 0xae, 0x03, 0x04, 0x71, 0x0b, 0x01, 0x46, 0x02,
 0x11, 0x77, 0x9a, 0x0b, 0x00, 0x6b, 0x02, 0x20, 0x45, 0x6e,
 0xc3, 0x07, 0x85, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65,
 0x20, 0x93, 0x02, 0x60, 0x00, 0x00, 0x4e, 0x6f, 0x72, 0x6d,
-0x7f, 0x07, 0x10, 0x2c, 0x31, 0x00, 0x02, 0xdb, 0x05, 0x32,
-0x6d, 0x61, 0x6b, 0xf2, 0x07, 0x01, 0x21, 0x02, 0x06, 0x76,
-0x05, 0x00, 0xe8, 0x0a, 0x10, 0x74, 0x4d, 0x03, 0x20, 0x73,
+0x7f, 0x07, 0x13, 0x2c, 0x31, 0x00, 0x63, 0x6c, 0x6c, 0x00,
+0x6d, 0x61, 0x6b, 0xf2, 0x07, 0x05, 0x67, 0x02, 0x02, 0xe7,
+0x01, 0x10, 0x73, 0xba, 0x05, 0x50, 0x70, 0x72, 0x65, 0x73,
 0x65, 0xdf, 0x02, 0x33, 0x68, 0x61, 0x76, 0x5c, 0x01, 0x26,
-0x6f, 0x6e, 0xe6, 0x02, 0x32, 0x2e, 0x00, 0x50, 0x2c, 0x00,
-0x02, 0x80, 0x01, 0x94, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75,
-0x6f, 0x75, 0x73, 0x1e, 0x02, 0x13, 0x73, 0xf9, 0x06, 0x02,
+0x6f, 0x6e, 0xe6, 0x02, 0x33, 0x2e, 0x00, 0x50, 0x2c, 0x00,
+0x01, 0x80, 0x01, 0x94, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75,
+0x6f, 0x75, 0x73, 0x1e, 0x02, 0x14, 0x73, 0xf9, 0x06, 0x01,
 0x64, 0x03, 0x40, 0x64, 0x69, 0x66, 0x66, 0x59, 0x01, 0x11,
-0x74, 0xd9, 0x00, 0x21, 0x6d, 0x6f, 0x6b, 0x08, 0x40, 0x62,
-0x74, 0x6c, 0x65, 0x56, 0x07, 0x04, 0x9b, 0x02, 0x44, 0x6c,
-0x69, 0x6b, 0x65, 0x8a, 0x07, 0x02, 0x26, 0x08, 0x23, 0x6f,
-0x66, 0xad, 0x0c, 0x71, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
-0x65, 0x3e, 0x00, 0x70, 0x72, 0x69, 0x73, 0x6b, 0x00, 0x68,
-0x61, 0x2a, 0x06, 0x06, 0x77, 0x00, 0x04, 0xba, 0x00, 0x10,
+0x74, 0xd9, 0x00, 0x21, 0x6d, 0x6f, 0x6b, 0x08, 0x41, 0x62,
+0x74, 0x6c, 0x65, 0x56, 0x07, 0x03, 0x9b, 0x02, 0x45, 0x6c,
+0x69, 0x6b, 0x65, 0x8a, 0x07, 0x01, 0x26, 0x08, 0x23, 0x6f,
+0x66, 0xad, 0x0c, 0x40, 0x66, 0x65, 0x61, 0x74, 0xa9, 0x00,
+0x00, 0x3e, 0x00, 0x40, 0x72, 0x69, 0x73, 0x6b, 0x95, 0x00,
+0x00, 0xe1, 0x01, 0x06, 0x77, 0x00, 0x03, 0xba, 0x00, 0x10,
 0x2e, 0xcf, 0x05, 0x81, 0x73, 0x6f, 0x2c, 0x00, 0x66, 0x69,
-0x6e, 0x64, 0x22, 0x00, 0x03, 0xdd, 0x05, 0x72, 0x70, 0x6f,
-0x73, 0x73, 0x69, 0x62, 0x6c, 0xc1, 0x00, 0x09, 0xa1, 0x00,
-0x00, 0xd6, 0x08, 0x60, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f,
-0x4f, 0x01, 0x20, 0x63, 0x68, 0x9a, 0x0c, 0x21, 0x6e, 0x67,
+0x6e, 0x64, 0x22, 0x00, 0x03, 0xdd, 0x05, 0x76, 0x70, 0x6f,
+0x73, 0x73, 0x69, 0x62, 0x6c, 0xc1, 0x00, 0x05, 0xa1, 0x00,
+0x00, 0xd6, 0x08, 0x30, 0x64, 0x64, 0x69, 0x14, 0x00, 0x20,
+0x61, 0x6c, 0x40, 0x02, 0x51, 0x6c, 0x6c, 0x65, 0x6e, 0x67,
 0xb8, 0x0c, 0x02, 0x1c, 0x00, 0x30, 0x76, 0x61, 0x6e, 0x73,
 0x04, 0x90, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, 0x29,
 0x00,
diff --git a/apps/plugins/puzzles/help/netslide.c b/apps/plugins/puzzles/help/netslide.c
index be2a6d7aa6..dc6a0d65e1 100644
--- a/apps/plugins/puzzles/help/netslide.c
+++ b/apps/plugins/puzzles/help/netslide.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
diff --git a/apps/plugins/puzzles/help/palisade.c b/apps/plugins/puzzles/help/palisade.c
index 3b0e897828..3de6c2d06d 100644
--- a/apps/plugins/puzzles/help/palisade.c
+++ b/apps/plugins/puzzles/help/palisade.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
diff --git a/apps/plugins/puzzles/help/pattern.c b/apps/plugins/puzzles/help/pattern.c
index f977e03860..3c51afd66c 100644
--- a/apps/plugins/puzzles/help/pattern.c
+++ b/apps/plugins/puzzles/help/pattern.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
diff --git a/apps/plugins/puzzles/help/pearl.c b/apps/plugins/puzzles/help/pearl.c
index 162b8a44a4..1c7a7ee3ab 100644
--- a/apps/plugins/puzzles/help/pearl.c
+++ b/apps/plugins/puzzles/help/pearl.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2570 comp 1610 ratio 0.626459 level 11 saved 960 */
+/* orig 2570 comp 1610 ratio 0.626459 level 10 saved 960 */
 const char help_text[] = {
 0xf0, 0x21, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x36, 0x3a, 0x20, 0x50, 0x65, 0x61, 0x72, 0x6c, 0x20,
@@ -30,57 +30,57 @@ const char help_text[] = {
 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c,
 0x6c, 0x79, 0x00, 0x6f, 0x72, 0x00, 0x76, 0x65, 0x72, 0x74,
 0x69, 0x63, 0x0e, 0x00, 0x40, 0x61, 0x64, 0x6a, 0x61, 0x2a,
-0x00, 0x04, 0x5e, 0x00, 0x90, 0x2c, 0x00, 0x73, 0x6f, 0x00,
-0x74, 0x68, 0x61, 0x74, 0x44, 0x00, 0x03, 0x56, 0x00, 0xf2,
+0x00, 0x04, 0x5e, 0x00, 0x91, 0x2c, 0x00, 0x73, 0x6f, 0x00,
+0x74, 0x68, 0x61, 0x74, 0x44, 0x00, 0x02, 0x56, 0x00, 0xf2,
 0x0d, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x69,
 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65,
 0x64, 0x00, 0x6c, 0x6f, 0x6f, 0x70, 0x2e, 0x00, 0x49, 0x6c,
 0x00, 0x91, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x69, 0x6e,
-0x67, 0xad, 0x00, 0x00, 0x44, 0x00, 0x50, 0x6d, 0x65, 0x00,
-0x6f, 0x66, 0x1c, 0x00, 0x04, 0x59, 0x00, 0x05, 0x55, 0x00,
-0x01, 0x3a, 0x00, 0x51, 0x00, 0x70, 0x61, 0x73, 0x73, 0x15,
+0x67, 0xad, 0x00, 0x00, 0x44, 0x00, 0x20, 0x6d, 0x65, 0x79,
+0x00, 0x00, 0x1c, 0x00, 0x03, 0x59, 0x00, 0x07, 0x55, 0x00,
+0x81, 0x6f, 0x6f, 0x70, 0x00, 0x70, 0x61, 0x73, 0x73, 0x15,
 0x00, 0xc0, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x77, 0x69,
-0x6c, 0x6c, 0x00, 0x63, 0xa3, 0x00, 0xf1, 0x00, 0x69, 0x6e,
+0x6c, 0x6c, 0x00, 0x63, 0xa3, 0x00, 0xf2, 0x00, 0x69, 0x6e,
 0x00, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x73, 0x2c, 0x00,
-0x61, 0x6e, 0x64, 0x4b, 0x00, 0x02, 0x1f, 0x00, 0xb7, 0x62,
+0x61, 0x6e, 0x64, 0x4b, 0x00, 0x01, 0x1f, 0x00, 0xb7, 0x62,
 0x65, 0x00, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74,
-0xd2, 0x00, 0x08, 0xd0, 0x00, 0x02, 0xb0, 0x00, 0x42, 0x2e,
-0x00, 0x28, 0x41, 0x39, 0x00, 0x06, 0x7d, 0x00, 0x30, 0x63,
+0xd2, 0x00, 0x08, 0xd0, 0x00, 0x02, 0xb0, 0x00, 0x44, 0x2e,
+0x00, 0x28, 0x41, 0x39, 0x00, 0x04, 0x7d, 0x00, 0x30, 0x63,
 0x61, 0x6e, 0x40, 0x00, 0xf6, 0x03, 0x63, 0x6f, 0x6d, 0x70,
 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x65, 0x6d, 0x70,
 0x74, 0x79, 0x00, 0x2d, 0x92, 0x00, 0x72, 0x64, 0x6f, 0x65,
-0x73, 0x6e, 0x27, 0x74, 0x76, 0x01, 0x20, 0x74, 0x6f, 0xa2,
-0x00, 0x06, 0xa0, 0x00, 0x53, 0x65, 0x76, 0x65, 0x72, 0x79,
+0x73, 0x6e, 0x27, 0x74, 0x76, 0x01, 0x21, 0x74, 0x6f, 0xa2,
+0x00, 0x05, 0xa0, 0x00, 0x53, 0x65, 0x76, 0x65, 0x72, 0x79,
 0x4e, 0x00, 0x6e, 0x2e, 0x29, 0x00, 0x00, 0x00, 0x53, 0xe2,
 0x00, 0x05, 0xc0, 0x00, 0x51, 0x62, 0x6c, 0x61, 0x63, 0x6b,
-0xbd, 0x00, 0xe0, 0x77, 0x68, 0x69, 0x74, 0x65, 0x00, 0x63,
-0x69, 0x72, 0x63, 0x6c, 0x65, 0x73, 0x2c, 0x0f, 0x00, 0x50,
+0xbd, 0x00, 0xb0, 0x77, 0x68, 0x69, 0x74, 0x65, 0x00, 0x63,
+0x69, 0x72, 0x63, 0x6c, 0x5b, 0x01, 0x80, 0x77, 0x68, 0x69,
 0x63, 0x68, 0x00, 0x61, 0x72, 0x45, 0x01, 0x1d, 0x75, 0x13,
-0x01, 0xf2, 0x02, 0x6d, 0x75, 0x73, 0x74, 0x00, 0x73, 0x61,
+0x01, 0xf3, 0x02, 0x6d, 0x75, 0x73, 0x74, 0x00, 0x73, 0x61,
 0x74, 0x69, 0x73, 0x66, 0x79, 0x2e, 0x00, 0x00, 0x00, 0x41,
-0x49, 0x00, 0x03, 0x3f, 0x00, 0x52, 0x00, 0x69, 0x6e, 0x00,
-0x61, 0x6b, 0x00, 0x00, 0x0c, 0x00, 0x56, 0x64, 0x69, 0x63,
+0x49, 0x00, 0x02, 0x3f, 0x00, 0x53, 0x00, 0x69, 0x6e, 0x00,
+0x61, 0x6b, 0x00, 0x86, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x63,
 0x61, 0x74, 0x43, 0x00, 0x14, 0x61, 0xc1, 0x01, 0x00, 0x14,
-0x02, 0x13, 0x61, 0x42, 0x01, 0xdb, 0x2c, 0x00, 0x62, 0x75,
+0x02, 0x13, 0x61, 0x42, 0x01, 0xdc, 0x2c, 0x00, 0x62, 0x75,
 0x74, 0x00, 0x6e, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0xad,
-0x00, 0x05, 0xf9, 0x01, 0x00, 0xeb, 0x00, 0x55, 0x69, 0x74,
-0x00, 0x69, 0x6e, 0x89, 0x00, 0x01, 0x43, 0x00, 0x35, 0x6c,
-0x73, 0x6f, 0x48, 0x00, 0x01, 0x8d, 0x00, 0x09, 0xcc, 0x00,
-0x0e, 0x81, 0x00, 0x18, 0x65, 0x80, 0x00, 0x06, 0xa8, 0x01,
+0x00, 0x05, 0xf9, 0x01, 0x50, 0x74, 0x6f, 0x00, 0x69, 0x74,
+0x5e, 0x00, 0x05, 0x89, 0x00, 0x00, 0x43, 0x00, 0x35, 0x6c,
+0x73, 0x6f, 0x48, 0x00, 0x02, 0x8d, 0x00, 0x08, 0xcc, 0x00,
+0x0e, 0x81, 0x00, 0x19, 0x65, 0x80, 0x00, 0x05, 0xa8, 0x01,
 0x42, 0x65, 0x64, 0x67, 0x65, 0x87, 0x00, 0xcf, 0x61, 0x74,
 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x6e, 0x65,
-0x8c, 0x00, 0x1a, 0x09, 0x87, 0x00, 0xc0, 0x28, 0x49, 0x6e,
+0x8c, 0x00, 0x1c, 0x07, 0x87, 0x00, 0xc0, 0x28, 0x49, 0x6e,
 0x00, 0x62, 0x6f, 0x74, 0x68, 0x00, 0x63, 0x61, 0x73, 0x52,
 0x01, 0x22, 0x74, 0x68, 0x4c, 0x01, 0x50, 0x00, 0x6f, 0x6e,
 0x6c, 0x79, 0x81, 0x01, 0x01, 0x7a, 0x00, 0x21, 0x6e, 0x73,
 0x19, 0x00, 0x3e, 0x74, 0x77, 0x6f, 0x63, 0x00, 0x70, 0x69,
 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x5d, 0x00, 0x12, 0x2c,
-0xbd, 0x00, 0x3f, 0x69, 0x73, 0x2c, 0xa9, 0x02, 0x0f, 0xf5,
-0x03, 0x69, 0x6e, 0x74, 0x6f, 0x00, 0x61, 0x66, 0x74, 0x65,
-0x72, 0x00, 0x6c, 0x65, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x7c,
-0x00, 0x04, 0x17, 0x02, 0x2c, 0x00, 0x54, 0x45, 0x00, 0x22,
-0x61, 0x72, 0x99, 0x00, 0x0d, 0x7e, 0x00, 0x00, 0x26, 0x03,
-0x01, 0x1e, 0x00, 0x36, 0x6e, 0x6f, 0x74, 0xb6, 0x00, 0x21,
+0xbd, 0x00, 0x3f, 0x69, 0x73, 0x2c, 0xa9, 0x02, 0x0f, 0xf0,
+0x00, 0x69, 0x6e, 0x74, 0x6f, 0x00, 0x61, 0x66, 0x74, 0x65,
+0x72, 0x00, 0x6c, 0x65, 0x61, 0x76, 0xeb, 0x02, 0x05, 0x7c,
+0x00, 0x03, 0x17, 0x02, 0x2c, 0x00, 0x54, 0x45, 0x00, 0x23,
+0x61, 0x72, 0x99, 0x00, 0x0c, 0x7e, 0x00, 0x01, 0xd3, 0x03,
+0x00, 0x1e, 0x00, 0x36, 0x6e, 0x6f, 0x74, 0xb6, 0x00, 0x21,
 0x65, 0x64, 0x5b, 0x02, 0x60, 0x43, 0x72, 0x65, 0x64, 0x69,
 0x74, 0x76, 0x03, 0xf1, 0x01, 0x00, 0x74, 0x68, 0x69, 0x73,
 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x67, 0x6f,
@@ -92,8 +92,8 @@ const char help_text[] = {
 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x53, 0x00,
 0x90, 0x61, 0x73, 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63,
 0x56, 0x03, 0x21, 0x74, 0x68, 0xc6, 0x00, 0x10, 0x69, 0x16,
-0x03, 0xc2, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
-0x6e, 0x2e, 0x00, 0x00, 0x48, 0x00, 0xc1, 0x68, 0x74, 0x74,
+0x03, 0x90, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
+0x6e, 0x68, 0x01, 0x01, 0x48, 0x00, 0xc1, 0x68, 0x74, 0x74,
 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x75,
 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65,
 0x6e, 0x2f, 0x94, 0x00, 0x30, 0x73, 0x2f, 0x6d, 0x78, 0x00,
@@ -102,47 +102,47 @@ const char help_text[] = {
 0x68, 0xcb, 0x00, 0x43, 0x33, 0x36, 0x2e, 0x31, 0xd4, 0x04,
 0x00, 0x1d, 0x03, 0x50, 0x72, 0x6f, 0x6c, 0x73, 0x20, 0xe2,
 0x00, 0x46, 0x6c, 0x69, 0x63, 0x6b, 0x7f, 0x00, 0x40, 0x6c,
-0x65, 0x66, 0x74, 0x24, 0x02, 0x63, 0x74, 0x6f, 0x6e, 0x00,
-0x6f, 0x6e, 0xf2, 0x04, 0x01, 0x3b, 0x02, 0x04, 0xdf, 0x04,
-0x00, 0x53, 0x02, 0x30, 0x65, 0x67, 0x6d, 0x42, 0x01, 0x25,
-0x6f, 0x66, 0x9c, 0x01, 0x04, 0x9e, 0x03, 0x00, 0x6d, 0x01,
-0x04, 0x6b, 0x02, 0x20, 0x6f, 0x72, 0x34, 0x00, 0x68, 0x72,
+0x65, 0x66, 0x74, 0x24, 0x02, 0x64, 0x74, 0x6f, 0x6e, 0x00,
+0x6f, 0x6e, 0xf2, 0x04, 0x00, 0x3b, 0x02, 0x05, 0xdf, 0x04,
+0x50, 0x61, 0x00, 0x73, 0x65, 0x67, 0xa2, 0x00, 0x04, 0x3b,
+0x02, 0x01, 0x9c, 0x01, 0x04, 0x9e, 0x03, 0x01, 0x6d, 0x01,
+0x02, 0x6b, 0x02, 0x20, 0x6f, 0x72, 0x34, 0x00, 0x68, 0x72,
 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x36, 0x00, 0x00, 0xf0, 0x00,
 0x10, 0x69, 0xec, 0x01, 0x01, 0x50, 0x00, 0x01, 0xe4, 0x00,
-0x4f, 0x44, 0x72, 0x61, 0x67, 0x85, 0x00, 0x02, 0x04, 0x58,
-0x00, 0x01, 0x40, 0x00, 0x46, 0x72, 0x69, 0x65, 0x73, 0x7e,
-0x05, 0x06, 0x71, 0x05, 0x40, 0x6d, 0x6f, 0x72, 0x65, 0x79,
+0x4f, 0x44, 0x72, 0x61, 0x67, 0x85, 0x00, 0x03, 0x04, 0x58,
+0x00, 0x00, 0x40, 0x00, 0x47, 0x72, 0x69, 0x65, 0x73, 0x7e,
+0x05, 0x05, 0x92, 0x00, 0x40, 0x6d, 0x6f, 0x72, 0x65, 0x79,
 0x00, 0x00, 0xb3, 0x00, 0x1f, 0x65, 0x9e, 0x00, 0x02, 0x12,
 0x69, 0x1b, 0x00, 0xf0, 0x05, 0x67, 0x6f, 0x2e, 0x00, 0x41,
 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
 0x6c, 0x79, 0x2c, 0x00, 0x64, 0x7a, 0x00, 0xc1, 0x6f, 0x76,
 0x65, 0x72, 0x00, 0x61, 0x6e, 0x00, 0x65, 0x78, 0x69, 0x73,
 0x3b, 0x05, 0x3b, 0x70, 0x61, 0x72, 0xdf, 0x00, 0x41, 0x6f,
-0x00, 0x75, 0x6e, 0x6d, 0x00, 0x20, 0x69, 0x74, 0xda, 0x00,
-0x06, 0x11, 0x00, 0x05, 0x2c, 0x00, 0x20, 0x69, 0x74, 0x68,
-0x04, 0x00, 0x33, 0x00, 0x42, 0x6e, 0x00, 0x67, 0x6f, 0x24,
+0x00, 0x75, 0x6e, 0x6d, 0x00, 0x24, 0x69, 0x74, 0xda, 0x00,
+0x03, 0x11, 0x00, 0x04, 0x2c, 0x00, 0x21, 0x69, 0x74, 0x68,
+0x04, 0x72, 0x74, 0x68, 0x65, 0x6e, 0x00, 0x67, 0x6f, 0x24,
 0x04, 0x60, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x8e, 0x00,
-0x51, 0x64, 0x69, 0x72, 0x65, 0x63, 0xd3, 0x01, 0x0e, 0x75,
-0x01, 0x4f, 0x72, 0x69, 0x67, 0x68, 0x76, 0x01, 0x08, 0x71,
-0x6d, 0x61, 0x72, 0x6b, 0x00, 0x69, 0x74, 0x30, 0x00, 0x00,
-0x82, 0x03, 0x53, 0x72, 0x6f, 0x73, 0x73, 0x2c, 0xf7, 0x03,
-0x00, 0xae, 0x00, 0x02, 0x74, 0x01, 0x31, 0x79, 0x6f, 0x75,
+0x54, 0x64, 0x69, 0x72, 0x65, 0x63, 0xd3, 0x01, 0x0b, 0x75,
+0x01, 0x11, 0x72, 0xa0, 0x03, 0x0f, 0x76, 0x01, 0x06, 0x40,
+0x6d, 0x61, 0x72, 0x6b, 0x5e, 0x00, 0x01, 0x30, 0x00, 0x84,
+0x61, 0x00, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x2c, 0xf7, 0x03,
+0x02, 0xfe, 0x02, 0x61, 0x61, 0x74, 0x00, 0x79, 0x6f, 0x75,
 0xc7, 0x02, 0x4a, 0x73, 0x75, 0x72, 0x65, 0x4a, 0x05, 0x01,
 0xda, 0x02, 0x2e, 0x67, 0x6f, 0xa3, 0x01, 0x92, 0x2e, 0x00,
 0x28, 0x46, 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x85, 0x02, 0x64,
-0x2c, 0x00, 0x69, 0x66, 0x00, 0x79, 0xed, 0x06, 0x72, 0x64,
+0x2c, 0x00, 0x69, 0x66, 0x00, 0x79, 0xed, 0x06, 0x73, 0x64,
 0x65, 0x63, 0x69, 0x64, 0x65, 0x64, 0x29, 0x05, 0x0f, 0x26,
-0x04, 0x09, 0x11, 0x61, 0x8f, 0x04, 0x03, 0x80, 0x03, 0x21,
+0x04, 0x08, 0x14, 0x61, 0x8f, 0x04, 0x00, 0x80, 0x03, 0x21,
 0x68, 0x61, 0x97, 0x01, 0x2b, 0x62, 0x65, 0xfa, 0x04, 0x20,
 0x64, 0x6f, 0xd0, 0x05, 0x83, 0x79, 0x65, 0x74, 0x00, 0x6b,
-0x6e, 0x6f, 0x77, 0x55, 0x00, 0x30, 0x77, 0x61, 0x79, 0x56,
-0x00, 0x03, 0x29, 0x00, 0x71, 0x00, 0x74, 0x75, 0x72, 0x6e,
-0x73, 0x2c, 0x82, 0x00, 0x10, 0x6d, 0x12, 0x01, 0x01, 0xf9,
-0x00, 0x00, 0x21, 0x00, 0x00, 0xbc, 0x01, 0x01, 0x2d, 0x00,
-0x20, 0x69, 0x74, 0x3e, 0x06, 0x10, 0x27, 0xce, 0x00, 0x09,
-0x0e, 0x01, 0x00, 0xac, 0x03, 0x0c, 0xd9, 0x01, 0x32, 0x75,
-0x73, 0x65, 0x5d, 0x00, 0xa1, 0x75, 0x72, 0x73, 0x6f, 0x72,
-0x00, 0x6b, 0x65, 0x79, 0x73, 0x4d, 0x01, 0x28, 0x6f, 0x76,
+0x6e, 0x6f, 0x77, 0x55, 0x00, 0x32, 0x77, 0x61, 0x79, 0xba,
+0x03, 0x01, 0x29, 0x00, 0x71, 0x00, 0x74, 0x75, 0x72, 0x6e,
+0x73, 0x2c, 0x82, 0x00, 0x11, 0x6d, 0x12, 0x01, 0x01, 0xf9,
+0x00, 0x00, 0x21, 0x00, 0x00, 0xbc, 0x01, 0x00, 0x2d, 0x00,
+0x20, 0x69, 0x74, 0x3e, 0x06, 0x11, 0x27, 0xce, 0x00, 0x08,
+0x0e, 0x01, 0x01, 0xac, 0x03, 0x0b, 0xd9, 0x01, 0x32, 0x75,
+0x73, 0x65, 0x5d, 0x00, 0x91, 0x75, 0x72, 0x73, 0x6f, 0x72,
+0x00, 0x6b, 0x65, 0x79, 0x9a, 0x00, 0x01, 0x8d, 0x02, 0x06,
 0x18, 0x00, 0x33, 0x2e, 0x00, 0x55, 0x28, 0x00, 0x41, 0x45,
 0x6e, 0x74, 0x65, 0x27, 0x00, 0x02, 0xc0, 0x00, 0x31, 0x67,
 0x69, 0x6e, 0xcf, 0x01, 0x30, 0x65, 0x6e, 0x64, 0x15, 0x00,
@@ -151,29 +151,29 @@ const char help_text[] = {
 0x73, 0x3f, 0x00, 0x30, 0x53, 0x70, 0x61, 0x42, 0x01, 0x60,
 0x45, 0x73, 0x63, 0x61, 0x70, 0x65, 0x21, 0x02, 0x50, 0x42,
 0x61, 0x63, 0x6b, 0x73, 0x15, 0x00, 0x05, 0x7b, 0x00, 0x10,
-0x63, 0x65, 0x01, 0x10, 0x6c, 0x2e, 0x00, 0x01, 0x76, 0x02,
+0x63, 0x65, 0x01, 0x11, 0x6c, 0x2e, 0x00, 0x00, 0x48, 0x00,
 0xc2, 0x2e, 0x00, 0x4f, 0x72, 0x2c, 0x00, 0x68, 0x6f, 0x6c,
 0x64, 0x00, 0x43, 0x91, 0x03, 0x00, 0x17, 0x01, 0x12, 0x6c,
-0x1d, 0x00, 0x34, 0x67, 0x69, 0x6e, 0x11, 0x03, 0x0e, 0xc4,
-0x00, 0x55, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0xe9, 0x02, 0x40,
-0x73, 0x00, 0x61, 0x73, 0x35, 0x01, 0x01, 0xdb, 0x00, 0x04,
-0x77, 0x08, 0x06, 0xa2, 0x08, 0x60, 0x00, 0x00, 0x50, 0x72,
+0x1d, 0x00, 0x37, 0x67, 0x69, 0x6e, 0x11, 0x03, 0x0b, 0xc4,
+0x00, 0x55, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0xe9, 0x02, 0x42,
+0x73, 0x00, 0x61, 0x73, 0x35, 0x01, 0x00, 0xdb, 0x00, 0x04,
+0x77, 0x08, 0x05, 0xa2, 0x08, 0x60, 0x00, 0x00, 0x50, 0x72,
 0x65, 0x73, 0x31, 0x08, 0x04, 0x67, 0x00, 0xe1, 0x2d, 0x53,
 0x68, 0x69, 0x66, 0x74, 0x2d, 0x61, 0x72, 0x72, 0x6f, 0x77,
 0x6b, 0x65, 0x86, 0x08, 0x0b, 0x12, 0x00, 0x51, 0x73, 0x69,
 0x6d, 0x75, 0x6c, 0x53, 0x06, 0x12, 0x61, 0x8d, 0x03, 0x23,
 0x6f, 0x72, 0xa5, 0x02, 0x10, 0x63, 0xba, 0x02, 0x10, 0x2c,
-0x65, 0x08, 0x34, 0x70, 0x65, 0x63, 0x6b, 0x01, 0x11, 0x6f,
-0x25, 0x06, 0x01, 0x53, 0x02, 0x03, 0x31, 0x06, 0x06, 0xef,
-0x02, 0x02, 0x3a, 0x02, 0x01, 0x05, 0x01, 0x01, 0x35, 0x06,
+0x65, 0x08, 0x34, 0x70, 0x65, 0x63, 0x6b, 0x01, 0x12, 0x6f,
+0x25, 0x06, 0x01, 0xb0, 0x02, 0x03, 0x31, 0x06, 0x05, 0xef,
+0x02, 0x04, 0x3a, 0x02, 0x31, 0x6b, 0x65, 0x79, 0x35, 0x06,
 0x22, 0x41, 0x6c, 0x02, 0x01, 0x21, 0x61, 0x63, 0x41, 0x01,
 0xa0, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65,
-0x64, 0x3a, 0x00, 0x13, 0x73, 0x34, 0x00, 0x30, 0x32, 0x2e,
-0x31, 0xcc, 0x02, 0x03, 0xfb, 0x06, 0x93, 0x76, 0x61, 0x69,
+0x64, 0x3a, 0x00, 0x13, 0x73, 0x34, 0x00, 0x31, 0x32, 0x2e,
+0x31, 0xcc, 0x02, 0x02, 0xfb, 0x06, 0x93, 0x76, 0x61, 0x69,
 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0xc7, 0x04, 0x13, 0x32,
-0xc7, 0x04, 0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0xc9, 0x04, 0x00, 0xf2, 0x05, 0x36, 0x73, 0x65,
-0x00, 0x14, 0x00, 0x00, 0x41, 0x00, 0x06, 0x3c, 0x00, 0x51,
+0xc7, 0x04, 0xb1, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
+0x65, 0x72, 0x73, 0x20, 0x68, 0x05, 0x46, 0x65, 0x73, 0x65,
+0x00, 0x14, 0x00, 0x02, 0x41, 0x00, 0x04, 0x3c, 0x00, 0x51,
 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x79, 0x00, 0xa0, 0x60, 0x43,
 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0xc9, 0x01,
 0x02, 0xa3, 0x00, 0x12, 0x6e, 0x1a, 0x00, 0xc0, 0x54, 0x79,
diff --git a/apps/plugins/puzzles/help/pegs.c b/apps/plugins/puzzles/help/pegs.c
index 0877c3a5c2..d64cbe8d56 100644
--- a/apps/plugins/puzzles/help/pegs.c
+++ b/apps/plugins/puzzles/help/pegs.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
diff --git a/apps/plugins/puzzles/help/range.c b/apps/plugins/puzzles/help/range.c
index 64e4f59042..62c308778e 100644
--- a/apps/plugins/puzzles/help/range.c
+++ b/apps/plugins/puzzles/help/range.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2036 comp 1386 ratio 0.680747 level 11 saved 650 */
+/* orig 2036 comp 1387 ratio 0.681238 level 4 saved 649 */
 const char help_text[] = {
 0xf4, 0x26, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x35, 0x3a, 0x20, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20,
@@ -23,20 +23,20 @@ const char help_text[] = {
 0x66, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x73, 0x3b,
 0x00, 0x73, 0x6f, 0x6d, 0x65, 0x0e, 0x00, 0xf0, 0x02, 0x00,
 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x6e, 0x75,
-0x6d, 0x62, 0x65, 0x72, 0x73, 0x2e, 0x3a, 0x00, 0xf1, 0x03,
+0x6d, 0x62, 0x65, 0x72, 0x73, 0x2e, 0x3a, 0x00, 0xf0, 0x00,
 0x72, 0x00, 0x6a, 0x6f, 0x62, 0x00, 0x69, 0x73, 0x00, 0x74,
-0x6f, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x34, 0x00,
-0x00, 0x45, 0x00, 0x26, 0x74, 0x68, 0x3b, 0x00, 0xf3, 0x28,
+0x6f, 0x00, 0x63, 0x6f, 0x6c, 0x11, 0x00, 0x01, 0x34, 0x00,
+0x56, 0x6f, 0x66, 0x00, 0x74, 0x68, 0x3b, 0x00, 0xf3, 0x28,
 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2c, 0x00, 0x73, 0x75, 0x63,
 0x68, 0x00, 0x74, 0x68, 0x61, 0x74, 0x00, 0x73, 0x65, 0x76,
 0x65, 0x72, 0x61, 0x6c, 0x00, 0x63, 0x72, 0x69, 0x74, 0x65,
 0x72, 0x69, 0x61, 0x00, 0x61, 0x72, 0x65, 0x00, 0x73, 0x61,
 0x74, 0x69, 0x73, 0x66, 0x69, 0x65, 0x64, 0x3a, 0x00, 0x00,
 0x00, 0x2d, 0x00, 0x6e, 0x6f, 0x40, 0x00, 0x73, 0x00, 0x77,
-0x69, 0x74, 0x68, 0x00, 0x61, 0x79, 0x00, 0x33, 0x00, 0x69,
-0x73, 0x6b, 0x00, 0x22, 0x65, 0x64, 0x59, 0x00, 0x14, 0x2e,
-0x2f, 0x00, 0x32, 0x74, 0x77, 0x6f, 0x12, 0x00, 0x04, 0x79,
-0x00, 0x01, 0x57, 0x00, 0xf0, 0x00, 0x61, 0x64, 0x6a, 0x61,
+0x69, 0x74, 0x68, 0x00, 0x61, 0x79, 0x00, 0x00, 0x6e, 0x00,
+0x02, 0x6b, 0x00, 0x22, 0x65, 0x64, 0x59, 0x00, 0x14, 0x2e,
+0x2f, 0x00, 0x32, 0x74, 0x77, 0x6f, 0x12, 0x00, 0x05, 0x79,
+0x00, 0x00, 0x3e, 0x00, 0xf0, 0x00, 0x61, 0x64, 0x6a, 0x61,
 0x63, 0x65, 0x6e, 0x74, 0x00, 0x28, 0x68, 0x6f, 0x72, 0x69,
 0x7a, 0xc6, 0x00, 0xd0, 0x6c, 0x6c, 0x79, 0x00, 0x6f, 0x72,
 0x00, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, 0x0e, 0x00, 0x12,
@@ -47,114 +47,114 @@ const char help_text[] = {
 0x77, 0x65, 0x65, 0x6e, 0x18, 0x00, 0xca, 0x6d, 0x00, 0x75,
 0x73, 0x69, 0x6e, 0x67, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x37,
 0x00, 0x06, 0x56, 0x00, 0x4f, 0x65, 0x61, 0x63, 0x68, 0xcf,
-0x00, 0x02, 0x11, 0x2c, 0x11, 0x01, 0x04, 0xdc, 0x00, 0x71,
+0x00, 0x02, 0x12, 0x2c, 0x11, 0x01, 0x03, 0xdc, 0x00, 0x71,
 0x64, 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x73, 0x3d, 0x01, 0x54,
 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x19, 0x00, 0x2a, 0x6f, 0x66,
-0x5a, 0x00, 0x20, 0x00, 0x72, 0x52, 0x00, 0x91, 0x61, 0x62,
-0x6c, 0x65, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x45, 0x00, 0x04,
-0x60, 0x00, 0x20, 0x67, 0x6f, 0x8e, 0x00, 0xf1, 0x06, 0x69,
+0x5a, 0x00, 0x20, 0x00, 0x72, 0x52, 0x00, 0x93, 0x61, 0x62,
+0x6c, 0x65, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x56, 0x01, 0x02,
+0x60, 0x00, 0x20, 0x67, 0x6f, 0x8e, 0x00, 0xf1, 0x03, 0x69,
 0x6e, 0x00, 0x61, 0x00, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67,
-0x68, 0x74, 0x00, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x69, 0x6e,
-0xde, 0x00, 0x06, 0x07, 0x01, 0x08, 0x05, 0x01, 0xf0, 0x06,
+0x68, 0x74, 0x00, 0x6c, 0x69, 0x6e, 0x65, 0x13, 0x00, 0x36,
+0x6e, 0x79, 0x00, 0x07, 0x01, 0x08, 0x05, 0x01, 0xf0, 0x06,
 0x00, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
 0x00, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x00, 0x68, 0x69, 0x74,
 0x74, 0x49, 0x00, 0x51, 0x61, 0x00, 0x77, 0x61, 0x6c, 0x2b,
-0x00, 0x19, 0x61, 0x5e, 0x01, 0x10, 0x3b, 0xa6, 0x00, 0x08,
-0xd4, 0x00, 0x00, 0x10, 0x00, 0x07, 0xa5, 0x01, 0xb7, 0x69,
-0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x00, 0x69, 0x6e,
+0x00, 0x19, 0x61, 0x5e, 0x01, 0x17, 0x3b, 0xe3, 0x01, 0x02,
+0xd4, 0x00, 0x00, 0x10, 0x00, 0x06, 0xa5, 0x01, 0x80, 0x69,
+0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x77, 0x00, 0x06,
 0xd0, 0x00, 0x51, 0x28, 0x6f, 0x6e, 0x63, 0x65, 0x6f, 0x01,
-0xf3, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x73, 0x74,
-0x61, 0x6e, 0x63, 0x65, 0x2c, 0x00, 0x61, 0x4a, 0x00, 0x04,
-0x67, 0x02, 0x38, 0x69, 0x6e, 0x67, 0x50, 0x00, 0x82, 0x6f,
-0x6e, 0x65, 0x00, 0x6d, 0x75, 0x73, 0x74, 0xab, 0x02, 0x4c,
-0x66, 0x6f, 0x75, 0x72, 0xea, 0x01, 0xf1, 0x04, 0x73, 0x00,
+0xf4, 0x00, 0x46, 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x73, 0x74,
+0x61, 0x6e, 0x63, 0x65, 0x2c, 0x00, 0x61, 0x4a, 0x00, 0x03,
+0x67, 0x02, 0x00, 0x7a, 0x00, 0x07, 0x50, 0x00, 0x82, 0x6f,
+0x6e, 0x65, 0x00, 0x6d, 0x75, 0x73, 0x74, 0xab, 0x02, 0x10,
+0x66, 0x69, 0x02, 0x0b, 0xea, 0x01, 0xf1, 0x04, 0x73, 0x00,
 0x69, 0x74, 0x73, 0x00, 0x6e, 0x65, 0x69, 0x67, 0x68, 0x62,
 0x6f, 0x75, 0x72, 0x73, 0x00, 0x62, 0x79, 0x41, 0x00, 0x44,
 0x6c, 0x61, 0x73, 0x74, 0x68, 0x02, 0x70, 0x6f, 0x6e, 0x3b,
 0x00, 0x62, 0x75, 0x74, 0x18, 0x00, 0xe1, 0x6e, 0x00, 0x69,
 0x74, 0x27, 0x73, 0x00, 0x69, 0x6d, 0x70, 0x6f, 0x73, 0x73,
 0x69, 0x48, 0x01, 0x00, 0x90, 0x00, 0x10, 0x74, 0xca, 0x02,
-0x11, 0x62, 0x86, 0x00, 0x91, 0x6e, 0x65, 0x63, 0x74, 0x65,
-0x64, 0x00, 0x74, 0x6f, 0x35, 0x01, 0x79, 0x6f, 0x75, 0x74,
+0x11, 0x62, 0x86, 0x00, 0x60, 0x6e, 0x65, 0x63, 0x74, 0x65,
+0x64, 0x10, 0x00, 0x00, 0x35, 0x01, 0x79, 0x6f, 0x75, 0x74,
 0x73, 0x69, 0x64, 0x65, 0x86, 0x01, 0x10, 0x2c, 0x0e, 0x00,
 0x84, 0x63, 0x68, 0x00, 0x76, 0x69, 0x6f, 0x6c, 0x61, 0xb7,
-0x01, 0x50, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x37, 0x00, 0x0b,
-0x7a, 0x00, 0x49, 0x2e, 0x00, 0x53, 0x6f, 0xd4, 0x02, 0x24,
-0x6c, 0x6c, 0xec, 0x00, 0x0b, 0xe9, 0x00, 0x00, 0x1d, 0x01,
+0x01, 0x51, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x37, 0x00, 0x0a,
+0x7a, 0x00, 0x49, 0x2e, 0x00, 0x53, 0x6f, 0xd4, 0x02, 0x25,
+0x6c, 0x6c, 0x53, 0x03, 0x0a, 0xe9, 0x00, 0x00, 0x1d, 0x01,
 0x61, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x94, 0x00, 0xa0,
 0x74, 0x68, 0x69, 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c,
 0xdb, 0x01, 0x11, 0x65, 0x6c, 0x03, 0x60, 0x4e, 0x69, 0x6b,
 0x6f, 0x6c, 0x69, 0x80, 0x00, 0x12, 0x6f, 0x12, 0x01, 0xa0,
 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00,
-0xd0, 0x02, 0x20, 0x65, 0x64, 0xca, 0x00, 0xb2, 0x60, 0x4b,
+0xd0, 0x02, 0x00, 0x75, 0x01, 0xd2, 0x74, 0x00, 0x60, 0x4b,
 0x75, 0x72, 0x6f, 0x64, 0x6f, 0x6b, 0x6f, 0x27, 0x2c, 0x0c,
 0x00, 0x50, 0x6d, 0x61, 0x73, 0x75, 0x27, 0xc9, 0x01, 0x24,
 0x60, 0x57, 0xce, 0x02, 0x11, 0x42, 0x45, 0x01, 0xc0, 0x43,
 0x65, 0x6c, 0x6c, 0x73, 0x27, 0x2e, 0x00, 0x5b, 0x31, 0x38,
 0x5d, 0x7e, 0x00, 0x01, 0x1d, 0x04, 0x32, 0x00, 0x77, 0x61,
 0xf5, 0x03, 0x43, 0x72, 0x69, 0x62, 0x75, 0x0a, 0x01, 0x22,
-0x74, 0x68, 0x7e, 0x03, 0x12, 0x6c, 0x2a, 0x02, 0x00, 0x64,
-0x01, 0xd0, 0x4a, 0x6f, 0x6e, 0x61, 0x73, 0x00, 0x4b, 0x6f,
-0x65, 0x6c, 0x6b, 0x65, 0x72, 0x3d, 0x00, 0x00, 0x45, 0x00,
-0xd1, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77,
-0x77, 0x77, 0x2e, 0x6e, 0xac, 0x00, 0xa2, 0x2e, 0x63, 0x6f,
-0x2e, 0x6a, 0x70, 0x2f, 0x65, 0x6e, 0x2f, 0xcb, 0x00, 0x30,
-0x73, 0x2f, 0x77, 0x84, 0x00, 0x41, 0x5f, 0x69, 0x73, 0x5f,
-0xc9, 0x01, 0x20, 0x5f, 0x63, 0x84, 0x00, 0xc3, 0x2e, 0x68,
-0x74, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x33, 0x35, 0x2e, 0x31,
-0xa3, 0x04, 0x01, 0x82, 0x00, 0x40, 0x6f, 0x6c, 0x73, 0x20,
-0x16, 0x01, 0x46, 0x6c, 0x69, 0x63, 0x6b, 0x6c, 0x02, 0x40,
-0x6c, 0x65, 0x66, 0x74, 0xd0, 0x01, 0x30, 0x74, 0x6f, 0x6e,
-0x9d, 0x00, 0x55, 0x70, 0x61, 0x69, 0x6e, 0x74, 0x49, 0x02,
-0x04, 0x75, 0x04, 0x26, 0x6f, 0x72, 0x31, 0x00, 0x48, 0x72,
-0x69, 0x67, 0x68, 0x32, 0x00, 0x6b, 0x6d, 0x61, 0x72, 0x6b,
-0x00, 0x61, 0x98, 0x03, 0x21, 0x64, 0x6f, 0x05, 0x02, 0x82,
-0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5b, 0x03,
-0x32, 0x79, 0x6f, 0x75, 0xa4, 0x04, 0x30, 0x75, 0x72, 0x65,
-0x5c, 0x01, 0xd2, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x00,
-0x6e, 0x6f, 0x74, 0x00, 0x62, 0x65, 0x7a, 0x00, 0x06, 0x8f,
-0x04, 0x50, 0x52, 0x65, 0x70, 0x65, 0x61, 0x10, 0x00, 0x10,
-0x63, 0xb0, 0x00, 0x32, 0x69, 0x6e, 0x67, 0x5b, 0x00, 0x20,
-0x65, 0x69, 0x45, 0x04, 0x03, 0x7f, 0x00, 0x03, 0x01, 0x02,
-0x48, 0x79, 0x63, 0x6c, 0x65, 0x48, 0x03, 0x60, 0x74, 0x68,
-0x72, 0x6f, 0x75, 0x67, 0xae, 0x00, 0x01, 0x0c, 0x00, 0x35,
-0x65, 0x65, 0x00, 0xa0, 0x02, 0x21, 0x73, 0x74, 0x64, 0x02,
-0x30, 0x28, 0x66, 0x69, 0xe1, 0x01, 0x10, 0x2c, 0xa8, 0x00,
-0x00, 0x64, 0x00, 0x00, 0x5d, 0x04, 0x50, 0x6d, 0x70, 0x74,
-0x79, 0x29, 0x68, 0x03, 0x86, 0x6f, 0x70, 0x70, 0x6f, 0x73,
-0x69, 0x74, 0x65, 0xcd, 0x03, 0x23, 0x73, 0x2e, 0xe4, 0x05,
-0xb2, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00,
-0x75, 0x73, 0x72, 0x00, 0xb1, 0x63, 0x75, 0x72, 0x73, 0x6f,
-0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x0c, 0x01, 0x10, 0x6f,
-0x04, 0x06, 0x50, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x1f, 0x00,
-0x01, 0x0d, 0x06, 0x06, 0xc8, 0x04, 0x41, 0x50, 0x72, 0x65,
-0x73, 0xe5, 0x04, 0x94, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e,
-0x00, 0x64, 0x6f, 0xef, 0x02, 0x68, 0x61, 0x6d, 0x65, 0x00,
-0x61, 0x73, 0xeb, 0x00, 0x0e, 0x9e, 0x01, 0x01, 0x29, 0x03,
-0x44, 0x6c, 0x65, 0x00, 0x70, 0x46, 0x00, 0x5e, 0x53, 0x70,
-0x61, 0x63, 0x65, 0x45, 0x00, 0x19, 0x61, 0xa2, 0x01, 0x02,
-0x54, 0x00, 0x54, 0x2e, 0x00, 0x4d, 0x6f, 0x76, 0x59, 0x00,
-0x0c, 0xb9, 0x00, 0x03, 0x58, 0x00, 0x41, 0x68, 0x6f, 0x6c,
-0x64, 0x57, 0x00, 0x42, 0x68, 0x69, 0x66, 0x74, 0x5a, 0x01,
-0x22, 0x70, 0x6c, 0x62, 0x00, 0x21, 0x74, 0x73, 0xf7, 0x04,
-0x24, 0x6c, 0x6c, 0xcc, 0x00, 0x01, 0xd0, 0x01, 0x00, 0xcc,
-0x01, 0x01, 0xf2, 0x00, 0x14, 0x64, 0x72, 0x01, 0x00, 0x27,
-0x01, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x62, 0x00, 0x12, 0x61,
-0x3b, 0x01, 0x82, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
-0x62, 0xc4, 0x04, 0x13, 0x73, 0xf4, 0x02, 0x30, 0x32, 0x2e,
-0x31, 0x3f, 0x00, 0x02, 0x4d, 0x01, 0x50, 0x61, 0x76, 0x61,
-0x69, 0x6c, 0x87, 0x05, 0x22, 0x2e, 0x29, 0xb7, 0x02, 0x13,
-0x32, 0xb7, 0x02, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
-0x74, 0x65, 0x72, 0xb9, 0x02, 0x65, 0x54, 0x68, 0x65, 0x73,
-0x65, 0x00, 0x14, 0x00, 0x01, 0x99, 0x06, 0x02, 0x3c, 0x00,
-0x08, 0xc3, 0x05, 0xf1, 0x01, 0x65, 0x00, 0x60, 0x43, 0x75,
-0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f,
-0x70, 0x6f, 0x00, 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0xa0, 0x54,
-0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xab,
-0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48,
-0x65, 0x30, 0x01, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x76,
-0x07, 0x00, 0xb6, 0x01, 0x02, 0xad, 0x00, 0x80, 0x71, 0x75,
-0x61, 0x72, 0x65, 0x73, 0x2e, 0x00,
+0x74, 0x68, 0x7e, 0x03, 0x13, 0x6c, 0x2a, 0x02, 0xf0, 0x01,
+0x62, 0x79, 0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x73, 0x00, 0x4b,
+0x6f, 0x65, 0x6c, 0x6b, 0x65, 0x72, 0x3d, 0x00, 0x00, 0x45,
+0x00, 0xd1, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
+0x77, 0x77, 0x77, 0x2e, 0x6e, 0xac, 0x00, 0xa2, 0x2e, 0x63,
+0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65, 0x6e, 0x2f, 0xcb, 0x00,
+0x30, 0x73, 0x2f, 0x77, 0x84, 0x00, 0x41, 0x5f, 0x69, 0x73,
+0x5f, 0xc9, 0x01, 0x20, 0x5f, 0x63, 0x84, 0x00, 0xc3, 0x2e,
+0x68, 0x74, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x33, 0x35, 0x2e,
+0x31, 0xa3, 0x04, 0x01, 0x82, 0x00, 0x30, 0x6f, 0x6c, 0x73,
+0xac, 0x04, 0x56, 0x43, 0x6c, 0x69, 0x63, 0x6b, 0x6c, 0x02,
+0x40, 0x6c, 0x65, 0x66, 0x74, 0xd0, 0x01, 0x30, 0x74, 0x6f,
+0x6e, 0x9d, 0x00, 0x56, 0x70, 0x61, 0x69, 0x6e, 0x74, 0x49,
+0x02, 0x03, 0x75, 0x04, 0x26, 0x6f, 0x72, 0x31, 0x00, 0x11,
+0x72, 0x0c, 0x03, 0x06, 0x32, 0x00, 0x6b, 0x6d, 0x61, 0x72,
+0x6b, 0x00, 0x61, 0x98, 0x03, 0x21, 0x64, 0x6f, 0x05, 0x02,
+0x82, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5b,
+0x03, 0x32, 0x79, 0x6f, 0x75, 0xa4, 0x04, 0x10, 0x75, 0x38,
+0x01, 0xc0, 0x74, 0x00, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64,
+0x00, 0x6e, 0x6f, 0x74, 0x2e, 0x02, 0x01, 0x7a, 0x00, 0x06,
+0x8f, 0x04, 0x50, 0x52, 0x65, 0x70, 0x65, 0x61, 0x10, 0x00,
+0x10, 0x63, 0xb0, 0x00, 0x00, 0xca, 0x02, 0x01, 0x5b, 0x00,
+0x20, 0x65, 0x69, 0x45, 0x04, 0x04, 0x7f, 0x00, 0x02, 0x01,
+0x02, 0x48, 0x79, 0x63, 0x6c, 0x65, 0x48, 0x03, 0x62, 0x74,
+0x68, 0x72, 0x6f, 0x75, 0x67, 0xae, 0x00, 0x65, 0x74, 0x68,
+0x72, 0x65, 0x65, 0x00, 0xa0, 0x02, 0x21, 0x73, 0x74, 0x64,
+0x02, 0x30, 0x28, 0x66, 0x69, 0xe1, 0x01, 0x10, 0x2c, 0xa8,
+0x00, 0x00, 0x64, 0x00, 0x00, 0x5d, 0x04, 0x50, 0x6d, 0x70,
+0x74, 0x79, 0x29, 0x68, 0x03, 0x50, 0x6f, 0x70, 0x70, 0x6f,
+0x73, 0xa1, 0x02, 0x05, 0xcd, 0x03, 0x23, 0x73, 0x2e, 0xe4,
+0x05, 0xb2, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c, 0x73, 0x6f,
+0x00, 0x75, 0x73, 0x72, 0x00, 0xa1, 0x63, 0x75, 0x72, 0x73,
+0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x53, 0x02, 0x20, 0x6d,
+0x6f, 0x04, 0x06, 0x51, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x1f,
+0x00, 0x01, 0x0d, 0x06, 0x05, 0xc8, 0x04, 0x41, 0x50, 0x72,
+0x65, 0x73, 0xe5, 0x04, 0x94, 0x52, 0x65, 0x74, 0x75, 0x72,
+0x6e, 0x00, 0x64, 0x6f, 0xef, 0x02, 0x30, 0x61, 0x6d, 0x65,
+0x7d, 0x03, 0x0a, 0xeb, 0x00, 0x0b, 0x9e, 0x01, 0x01, 0x29,
+0x03, 0x44, 0x6c, 0x65, 0x00, 0x70, 0x46, 0x00, 0x5e, 0x53,
+0x70, 0x61, 0x63, 0x65, 0x45, 0x00, 0x1a, 0x61, 0xa2, 0x01,
+0x01, 0x54, 0x00, 0x59, 0x2e, 0x00, 0x4d, 0x6f, 0x76, 0x59,
+0x00, 0x08, 0xb9, 0x00, 0x02, 0x58, 0x00, 0x41, 0x68, 0x6f,
+0x6c, 0x64, 0x57, 0x00, 0x42, 0x68, 0x69, 0x66, 0x74, 0x5a,
+0x01, 0x22, 0x70, 0x6c, 0x62, 0x00, 0x21, 0x74, 0x73, 0xf7,
+0x04, 0x25, 0x6c, 0x6c, 0x2a, 0x04, 0x01, 0xd0, 0x01, 0x00,
+0x6c, 0x01, 0x00, 0xf2, 0x00, 0x14, 0x64, 0x72, 0x01, 0x00,
+0x27, 0x01, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x62, 0x00, 0x12,
+0x61, 0x3b, 0x01, 0x82, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72,
+0x69, 0x62, 0xc4, 0x04, 0x13, 0x73, 0xf4, 0x02, 0x32, 0x32,
+0x2e, 0x31, 0x58, 0x06, 0x00, 0x4d, 0x01, 0x50, 0x61, 0x76,
+0x61, 0x69, 0x6c, 0x87, 0x05, 0x22, 0x2e, 0x29, 0xb7, 0x02,
+0x13, 0x32, 0xb7, 0x02, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d,
+0x65, 0x74, 0x65, 0x72, 0xb9, 0x02, 0x66, 0x54, 0x68, 0x65,
+0x73, 0x65, 0x00, 0x14, 0x00, 0x02, 0x41, 0x00, 0x04, 0x3c,
+0x00, 0x04, 0xc3, 0x05, 0xf1, 0x01, 0x65, 0x00, 0x60, 0x43,
+0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00,
+0x6f, 0x70, 0x6f, 0x00, 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0xa0,
+0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75,
+0xab, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00,
+0x48, 0x65, 0x30, 0x01, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a,
+0x76, 0x07, 0x01, 0xb6, 0x01, 0x00, 0xad, 0x00, 0x80, 0x71,
+0x75, 0x61, 0x72, 0x65, 0x73, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2036;
diff --git a/apps/plugins/puzzles/help/rect.c b/apps/plugins/puzzles/help/rect.c
index 8ce9af4a73..768bd1a4ce 100644
--- a/apps/plugins/puzzles/help/rect.c
+++ b/apps/plugins/puzzles/help/rect.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -18,7 +18,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3535 comp 2340 ratio 0.661952 level 11 saved 1195 */
+/* orig 3535 comp 2341 ratio 0.662235 level 10 saved 1194 */
 const char help_text[] = {
 0xf0, 0x50, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x38, 0x3a, 0x20, 0x52, 0x65, 0x63, 0x74, 0x61, 0x6e, 0x67,
@@ -30,10 +30,10 @@ const char help_text[] = {
 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x69, 0x6e, 0x00, 0x73,
 0x6f, 0x6d, 0x65, 0x00, 0x28, 0x62, 0x75, 0x74, 0x00, 0x6e,
 0x6f, 0x74, 0x00, 0x61, 0x6c, 0x6c, 0x29, 0x37, 0x00, 0x34,
-0x74, 0x68, 0x65, 0x3b, 0x00, 0x10, 0x2e, 0x57, 0x00, 0xf0,
+0x74, 0x68, 0x65, 0x3b, 0x00, 0x10, 0x2e, 0x57, 0x00, 0xf1,
 0x07, 0x72, 0x00, 0x74, 0x61, 0x73, 0x6b, 0x00, 0x69, 0x73,
 0x00, 0x74, 0x6f, 0x00, 0x73, 0x75, 0x62, 0x64, 0x69, 0x76,
-0x69, 0x64, 0x65, 0x27, 0x00, 0x02, 0x6a, 0x00, 0x65, 0x69,
+0x69, 0x64, 0x65, 0x27, 0x00, 0x01, 0x6a, 0x00, 0x65, 0x69,
 0x6e, 0x74, 0x6f, 0x00, 0x72, 0x8d, 0x00, 0x00, 0x43, 0x00,
 0xb0, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x73,
 0x69, 0x7a, 0x80, 0x00, 0xf6, 0x04, 0x73, 0x75, 0x63, 0x68,
@@ -43,8 +43,8 @@ const char help_text[] = {
 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x65,
 0xae, 0x00, 0x23, 0x65, 0x64, 0x8a, 0x00, 0x91, 0x2c, 0x00,
 0x61, 0x6e, 0x64, 0x00, 0x28, 0x62, 0x29, 0x77, 0x00, 0x40,
-0x61, 0x72, 0x65, 0x61, 0x67, 0x00, 0x46, 0x65, 0x61, 0x63,
-0x68, 0x49, 0x00, 0x00, 0xa2, 0x00, 0x50, 0x65, 0x71, 0x75,
+0x61, 0x72, 0x65, 0x61, 0x67, 0x00, 0x47, 0x65, 0x61, 0x63,
+0x68, 0x49, 0x00, 0x80, 0x69, 0x73, 0x00, 0x65, 0x71, 0x75,
 0x61, 0x6c, 0xa8, 0x00, 0x24, 0x74, 0x68, 0x44, 0x00, 0x08,
 0xf1, 0x00, 0x3c, 0x69, 0x74, 0x73, 0x5a, 0x00, 0xf4, 0x0e,
 0x2e, 0x00, 0x00, 0x00, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74,
@@ -54,11 +54,11 @@ const char help_text[] = {
 0x65, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x6d,
 0x61, 0x67, 0x61, 0x7a, 0x69, 0x6e, 0x65, 0x00, 0x4e, 0x69,
 0x6b, 0x6f, 0x6c, 0x69, 0x00, 0x5b, 0x33, 0x5d, 0x3b, 0x00,
-0x49, 0x27, 0x7e, 0x01, 0xf1, 0x14, 0x6c, 0x73, 0x6f, 0x00,
+0x49, 0x27, 0x7e, 0x01, 0xf2, 0x14, 0x6c, 0x73, 0x6f, 0x00,
 0x73, 0x65, 0x65, 0x6e, 0x00, 0x61, 0x00, 0x50, 0x61, 0x6c,
 0x6d, 0x00, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x61, 0x74, 0x00,
-0x50, 0x44, 0x00, 0x00, 0x1e, 0x00, 0xfa, 0x00, 0x61, 0x63,
+0x50, 0x44, 0x00, 0xfa, 0x03, 0x50, 0x61, 0x6c, 0x61, 0x63,
 0x65, 0x00, 0x5b, 0x34, 0x5d, 0x2e, 0x00, 0x55, 0x6e, 0x6c,
 0x69, 0x6b, 0x65, 0x1a, 0x00, 0x2b, 0x27, 0x73, 0x3c, 0x00,
 0x91, 0x2c, 0x00, 0x6d, 0x79, 0x00, 0x76, 0x65, 0x72, 0x73,
@@ -68,7 +68,7 @@ const char help_text[] = {
 0x64, 0x6f, 0x6d, 0x99, 0x01, 0x01, 0x8a, 0x01, 0x31, 0x61,
 0x6e, 0x79, 0x86, 0x01, 0x50, 0x00, 0x79, 0x6f, 0x75, 0x00,
 0x65, 0x00, 0x60, 0x2e, 0x00, 0x54, 0x68, 0x65, 0x00, 0x27,
-0x01, 0x64, 0x69, 0x74, 0x79, 0x00, 0x6f, 0x66, 0xd3, 0x00,
+0x01, 0x30, 0x69, 0x74, 0x79, 0x22, 0x00, 0x03, 0xd3, 0x00,
 0x61, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0xe6, 0x01, 0x81,
 0x68, 0x65, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x16, 0x02,
 0xd0, 0x71, 0x75, 0x69, 0x74, 0x65, 0x00, 0x61, 0x73, 0x00,
@@ -77,183 +77,184 @@ const char help_text[] = {
 0x00, 0xc0, 0x73, 0x00, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x00,
 0x62, 0x65, 0x2c, 0x00, 0x4e, 0x02, 0x21, 0x6f, 0x6e, 0x36,
 0x01, 0x21, 0x70, 0x6c, 0x03, 0x02, 0x12, 0x64, 0x7d, 0x00,
-0x50, 0x67, 0x65, 0x74, 0x00, 0x61, 0x86, 0x01, 0xf6, 0x02,
+0x50, 0x67, 0x65, 0x74, 0x00, 0x61, 0x86, 0x01, 0xf7, 0x02,
 0x65, 0x78, 0x68, 0x61, 0x75, 0x73, 0x74, 0x69, 0x62, 0x6c,
-0x65, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x87, 0x00, 0x00,
-0x72, 0x01, 0x70, 0x61, 0x69, 0x6c, 0x6f, 0x72, 0x65, 0x64,
-0x7b, 0x01, 0x10, 0x79, 0x7d, 0x02, 0xc1, 0x6f, 0x77, 0x6e,
+0x65, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x87, 0x00, 0x70,
+0x73, 0x00, 0x74, 0x61, 0x69, 0x6c, 0x6f, 0x9f, 0x01, 0x40,
+0x74, 0x6f, 0x00, 0x79, 0x7d, 0x02, 0xc1, 0x6f, 0x77, 0x6e,
 0x00, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x08,
-0x01, 0x30, 0x2e, 0x00, 0x00, 0x71, 0x01, 0xd1, 0x00, 0x68,
-0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
-0x6e, 0x87, 0x01, 0xa3, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70,
-0x2f, 0x65, 0x6e, 0x2f, 0x4d, 0x00, 0xf0, 0x06, 0x2f, 0x73,
-0x68, 0x69, 0x6b, 0x61, 0x6b, 0x75, 0x2e, 0x68, 0x74, 0x6d,
-0x6c, 0x00, 0x28, 0x62, 0x65, 0x77, 0x61, 0x72, 0x65, 0x6d,
-0x00, 0x60, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x29, 0x48, 0x00,
-0x12, 0x34, 0x48, 0x00, 0x10, 0x73, 0x49, 0x00, 0xe0, 0x65,
-0x62, 0x2e, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x2e,
-0x6f, 0x72, 0x67, 0x10, 0x00, 0xf7, 0x01, 0x2f, 0x32, 0x30,
-0x30, 0x34, 0x31, 0x30, 0x32, 0x34, 0x30, 0x30, 0x31, 0x34,
-0x35, 0x39, 0x2f, 0x73, 0x00, 0x02, 0x63, 0x00, 0x63, 0x2e,
-0x67, 0x72, 0x2e, 0x6a, 0x70, 0x70, 0x00, 0x21, 0x2f, 0x73,
-0x6e, 0x00, 0xb1, 0x2f, 0x70, 0x61, 0x6c, 0x6d, 0x2f, 0x69,
-0x6e, 0x64, 0x65, 0x78, 0x79, 0x00, 0x98, 0x2e, 0x65, 0x6e,
-0x00, 0x00, 0x00, 0x38, 0x2e, 0x31, 0xb2, 0x03, 0x00, 0xf5,
-0x02, 0x31, 0x72, 0x6f, 0x6c, 0xbb, 0x03, 0x13, 0x54, 0x74,
-0x02, 0x01, 0xc2, 0x02, 0x61, 0x70, 0x6c, 0x61, 0x79, 0x65,
-0x64, 0xb3, 0x03, 0x01, 0x45, 0x01, 0xf0, 0x05, 0x6d, 0x6f,
-0x75, 0x73, 0x65, 0x00, 0x6f, 0x72, 0x00, 0x63, 0x75, 0x72,
-0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x02, 0x01,
-0xa1, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63,
-0x6b, 0xe4, 0x01, 0x41, 0x65, 0x64, 0x67, 0x65, 0xae, 0x02,
-0x21, 0x6f, 0x67, 0x0b, 0x03, 0x00, 0x85, 0x01, 0x00, 0x36,
-0x00, 0x40, 0x6f, 0x66, 0x66, 0x2c, 0x08, 0x00, 0x18, 0x6c,
-0x2f, 0x00, 0x90, 0x64, 0x00, 0x64, 0x72, 0x61, 0x67, 0x00,
-0x74, 0x6f, 0x08, 0x00, 0x10, 0x77, 0x96, 0x01, 0x67, 0x65,
-0x6e, 0x74, 0x69, 0x72, 0x65, 0x4c, 0x03, 0x10, 0x28, 0x34,
-0x00, 0x78, 0x69, 0x6e, 0x65, 0x29, 0x00, 0x6f, 0x6e, 0xeb,
-0x03, 0x01, 0x9d, 0x03, 0xc2, 0x67, 0x6f, 0x00, 0x28, 0x72,
-0x65, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x7e, 0x00, 0x71,
-0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x87, 0x00, 0x11,
-0x73, 0xbd, 0x00, 0x21, 0x69, 0x6e, 0xf2, 0x03, 0x06, 0x53,
-0x00, 0x73, 0x29, 0x2e, 0x00, 0x52, 0x69, 0x67, 0x68, 0x86,
-0x00, 0x35, 0x69, 0x6e, 0x67, 0x89, 0x00, 0x10, 0x67, 0x0d,
-0x00, 0x40, 0x77, 0x69, 0x6c, 0x6c, 0x83, 0x04, 0x20, 0x6f,
-0x77, 0xf7, 0x01, 0x00, 0x9c, 0x00, 0x40, 0x65, 0x72, 0x61,
-0x73, 0x67, 0x04, 0x02, 0x22, 0x04, 0x32, 0x65, 0x6e, 0x74,
-0xd1, 0x02, 0x06, 0x52, 0x00, 0x01, 0x68, 0x00, 0x90, 0x6f,
-0x75, 0x74, 0x00, 0x61, 0x66, 0x66, 0x65, 0x63, 0x80, 0x00,
-0x00, 0xe1, 0x03, 0x01, 0x84, 0x00, 0x01, 0x23, 0x01, 0xf2,
-0x01, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
-0x76, 0x65, 0x6c, 0x79, 0x2c, 0x00, 0x75, 0x4e, 0x00, 0x07,
-0x49, 0x01, 0x01, 0xe0, 0x03, 0x42, 0x6d, 0x6f, 0x76, 0x65,
-0xaf, 0x02, 0x31, 0x6f, 0x73, 0x69, 0xa4, 0x03, 0x30, 0x69,
-0x6e, 0x64, 0x6b, 0x02, 0x91, 0x6f, 0x72, 0x00, 0x61, 0x72,
-0x6f, 0x75, 0x6e, 0x64, 0x1e, 0x00, 0xc0, 0x62, 0x6f, 0x61,
-0x72, 0x64, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x6a,
-0x00, 0x20, 0x74, 0x68, 0x2f, 0x01, 0x40, 0x74, 0x75, 0x72,
-0x6e, 0x4a, 0x00, 0x00, 0x0f, 0x00, 0x12, 0x6e, 0xbf, 0x00,
-0x13, 0x73, 0xc0, 0x00, 0x0f, 0x70, 0x00, 0x04, 0x01, 0xf2,
-0x00, 0x09, 0xc6, 0x00, 0x00, 0xc2, 0x00, 0x41, 0x66, 0x72,
-0x6f, 0x6d, 0x30, 0x01, 0x05, 0x86, 0x00, 0x02, 0xf2, 0x04,
-0x1f, 0x70, 0x6f, 0x00, 0x04, 0x80, 0x61, 0x67, 0x61, 0x69,
-0x6e, 0x00, 0x63, 0x6f, 0x21, 0x04, 0x20, 0x74, 0x65, 0xb4,
-0x03, 0x07, 0xbd, 0x01, 0x35, 0x2e, 0x00, 0x55, 0x34, 0x00,
-0x20, 0x73, 0x70, 0x65, 0x04, 0xa0, 0x62, 0x61, 0x72, 0x00,
-0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x19, 0x06, 0x0b, 0x4d,
-0x00, 0x03, 0xb7, 0x00, 0x0f, 0x77, 0x01, 0x32, 0x10, 0x2c,
-0x22, 0x04, 0x57, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2b, 0x01,
-0xf1, 0x01, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x00, 0x63,
-0x61, 0x6e, 0x63, 0x65, 0x6c, 0x73, 0x00, 0x61, 0x03, 0x01,
-0x00, 0xa1, 0x01, 0x4a, 0x57, 0x68, 0x65, 0x6e, 0x0b, 0x01,
-0x13, 0x66, 0x79, 0x00, 0x10, 0x72, 0x14, 0x00, 0x02, 0xb9,
-0x04, 0x25, 0x69, 0x73, 0xe8, 0x00, 0x52, 0x64, 0x2c, 0x00,
-0x69, 0x74, 0x2a, 0x02, 0x90, 0x62, 0x65, 0x00, 0x73, 0x68,
-0x61, 0x64, 0x65, 0x64, 0x48, 0x00, 0x42, 0x28, 0x41, 0x6c,
-0x6c, 0x19, 0x06, 0x10, 0x63, 0x3b, 0x01, 0x10, 0x73, 0xcd,
-0x04, 0x61, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0xe6, 0x06,
-0x21, 0x65, 0x63, 0xd7, 0x01, 0x63, 0x32, 0x2e, 0x31, 0x00,
-0x61, 0x72, 0xa3, 0x05, 0xb1, 0x61, 0x76, 0x61, 0x69, 0x6c,
-0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29, 0x9d, 0x03, 0x18, 0x32,
-0x9d, 0x03, 0x93, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x9f, 0x03, 0x00, 0xfa, 0x05, 0x06, 0x14, 0x00,
-0x00, 0x45, 0x00, 0x06, 0x40, 0x00, 0x04, 0xbb, 0x01, 0xf0,
-0x01, 0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
-0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x73, 0x00, 0x04,
-0x3c, 0x03, 0xb1, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
-0x6d, 0x65, 0x6e, 0x75, 0xf7, 0x00, 0x80, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0x0f, 0x03, 0x60, 0x00, 0x00,
-0x00, 0x53, 0x69, 0x7a, 0xfb, 0x00, 0x00, 0x63, 0x03, 0x00,
-0xe2, 0x00, 0x16, 0x6e, 0x7e, 0x07, 0x70, 0x00, 0x00, 0x45,
-0x78, 0x70, 0x61, 0x6e, 0xf2, 0x05, 0x74, 0x20, 0x66, 0x61,
-0x63, 0x74, 0x6f, 0x72, 0x2f, 0x04, 0x10, 0x69, 0x48, 0x01,
-0x91, 0x6d, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x73, 0x6d,
-0xbb, 0x06, 0x00, 0x0c, 0x00, 0x14, 0x67, 0xf8, 0x01, 0x35,
-0x74, 0x79, 0x70, 0x54, 0x00, 0x15, 0x73, 0x20, 0x06, 0x42,
-0x64, 0x00, 0x62, 0x79, 0xec, 0x02, 0x90, 0x72, 0x6f, 0x67,
-0x72, 0x61, 0x6d, 0x2e, 0x00, 0x53, 0x03, 0x08, 0x60, 0x70,
-0x65, 0x6f, 0x70, 0x6c, 0x65, 0x6d, 0x02, 0x33, 0x66, 0x65,
-0x72, 0x41, 0x08, 0x04, 0x97, 0x07, 0x01, 0xa9, 0x03, 0x96,
-0x00, 0x66, 0x65, 0x77, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x66,
-0x02, 0x01, 0x1d, 0x07, 0x00, 0x0e, 0x04, 0x08, 0x29, 0x00,
-0x11, 0x6d, 0x6f, 0x06, 0x70, 0x6d, 0x61, 0x6c, 0x6c, 0x00,
-0x6f, 0x6e, 0xc1, 0x00, 0x11, 0x53, 0xc5, 0x05, 0x00, 0xfb,
-0x01, 0x10, 0x00, 0x44, 0x08, 0x19, 0x52, 0x3d, 0x00, 0x30,
-0x65, 0x73, 0x73, 0x78, 0x04, 0x09, 0xc2, 0x06, 0x22, 0x00,
-0x61, 0x40, 0x00, 0x21, 0x65, 0x72, 0x86, 0x00, 0x00, 0x14,
-0x03, 0x01, 0x44, 0x01, 0x05, 0xc5, 0x06, 0x04, 0x0c, 0x06,
-0x21, 0x65, 0x64, 0x22, 0x03, 0x01, 0x79, 0x03, 0x01, 0x4d,
-0x00, 0x20, 0x78, 0x70, 0x0f, 0x00, 0x20, 0x69, 0x74, 0xe3,
-0x00, 0x30, 0x61, 0x64, 0x64, 0x8f, 0x00, 0x10, 0x72, 0xd7,
-0x02, 0x20, 0x61, 0x6e, 0xcc, 0x00, 0x61, 0x6c, 0x75, 0x6d,
-0x6e, 0x73, 0x2e, 0x3e, 0x01, 0x00, 0xec, 0x06, 0x52, 0x66,
-0x61, 0x75, 0x6c, 0x74, 0x34, 0x00, 0x01, 0x4f, 0x07, 0x02,
-0x5d, 0x01, 0x00, 0x31, 0x01, 0xa1, 0x7a, 0x65, 0x72, 0x6f,
-0x00, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x90, 0x03, 0x07, 0xb3,
-0x00, 0x02, 0x79, 0x02, 0x46, 0x73, 0x69, 0x6d, 0x70, 0xb0,
-0x00, 0x07, 0x6f, 0x09, 0x09, 0xa6, 0x00, 0x00, 0xee, 0x00,
-0x00, 0x95, 0x01, 0x12, 0x2c, 0xe5, 0x04, 0x10, 0x6f, 0x4b,
-0x07, 0x10, 0x68, 0x93, 0x00, 0x30, 0x66, 0x75, 0x72, 0x60,
-0x07, 0x42, 0x2e, 0x00, 0x49, 0x66, 0xce, 0x00, 0x01, 0x16,
-0x07, 0x0f, 0x8a, 0x00, 0x02, 0x90, 0x28, 0x73, 0x61, 0x79,
-0x29, 0x00, 0x30, 0x2e, 0x35, 0xf6, 0x02, 0x07, 0x93, 0x00,
-0x02, 0xf7, 0x08, 0x42, 0x64, 0x69, 0x6d, 0x65, 0x32, 0x00,
-0x25, 0x6f, 0x66, 0xa1, 0x05, 0x04, 0x1c, 0x03, 0x03, 0x0e,
-0x01, 0x02, 0x46, 0x07, 0x42, 0x68, 0x61, 0x6c, 0x66, 0x31,
-0x04, 0x00, 0x9d, 0x03, 0x40, 0x62, 0x69, 0x67, 0x00, 0xbc,
-0x07, 0x12, 0x72, 0xc3, 0x00, 0x03, 0x52, 0x07, 0x60, 0x49,
-0x6e, 0x00, 0x6f, 0x74, 0x68, 0x2d, 0x09, 0x51, 0x6f, 0x72,
-0x64, 0x73, 0x2c, 0x51, 0x00, 0x30, 0x69, 0x6e, 0x69, 0x9d,
-0x01, 0x0a, 0x59, 0x00, 0x36, 0x32, 0x2f, 0x33, 0xe9, 0x00,
-0x28, 0x69, 0x6e, 0x8c, 0x00, 0x03, 0xb5, 0x04, 0x0f, 0x85,
-0x00, 0x02, 0x01, 0x22, 0x04, 0x21, 0x66, 0x75, 0x40, 0x01,
-0x17, 0x7a, 0x42, 0x04, 0x24, 0x64, 0x64, 0x43, 0x06, 0x27,
-0x6d, 0x6f, 0x80, 0x06, 0x02, 0xfc, 0x02, 0x30, 0x53, 0x65,
-0x74, 0x5e, 0x04, 0x0f, 0x20, 0x01, 0x04, 0x03, 0x9d, 0x05,
-0x00, 0x21, 0x01, 0x52, 0x00, 0x74, 0x65, 0x6e, 0x64, 0xcd,
-0x05, 0x21, 0x61, 0x6b, 0xbc, 0x04, 0x01, 0x4f, 0x07, 0x02,
-0x54, 0x00, 0x91, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75,
-0x6c, 0x74, 0x9d, 0x00, 0x02, 0xfe, 0x03, 0x60, 0x28, 0x69,
-0x6e, 0x00, 0x6d, 0x79, 0x56, 0x00, 0xa0, 0x65, 0x72, 0x69,
-0x65, 0x6e, 0x63, 0x65, 0x29, 0x00, 0x72, 0x1d, 0x08, 0x10,
-0x64, 0x56, 0x03, 0x30, 0x6c, 0x65, 0x73, 0x42, 0x04, 0x30,
-0x64, 0x75, 0x63, 0x3a, 0x06, 0x00, 0x35, 0x00, 0x01, 0x49,
-0x00, 0x00, 0xe8, 0x0a, 0x20, 0x75, 0x69, 0x13, 0x00, 0x01,
-0xa4, 0x07, 0x00, 0x99, 0x00, 0x58, 0x73, 0x74, 0x79, 0x6c,
-0x65, 0xcb, 0x01, 0x00, 0xa9, 0x01, 0xa0, 0x74, 0x6f, 0x6f,
-0x00, 0x68, 0x69, 0x67, 0x68, 0x2c, 0x00, 0xe4, 0x00, 0x35,
-0x67, 0x68, 0x2c, 0x90, 0x00, 0x03, 0x3c, 0x02, 0x00, 0x0e,
-0x03, 0x34, 0x6e, 0x6f, 0x74, 0x80, 0x01, 0x02, 0xa7, 0x00,
-0x01, 0xe9, 0x02, 0x02, 0x69, 0x03, 0x0b, 0x63, 0x03, 0x50,
-0x63, 0x6f, 0x76, 0x65, 0x72, 0x44, 0x00, 0x02, 0xa5, 0x07,
-0x01, 0xe9, 0x01, 0x02, 0xfc, 0x02, 0x06, 0x59, 0x00, 0x50,
-0x62, 0x65, 0x63, 0x6f, 0x6d, 0x2f, 0x00, 0x61, 0x72, 0x69,
-0x76, 0x69, 0x61, 0x6c, 0x39, 0x04, 0xf1, 0x02, 0x6e, 0x73,
-0x75, 0x72, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65,
-0x20, 0x73, 0x6f, 0x6c, 0x75, 0x92, 0x04, 0x60, 0x00, 0x00,
-0x4e, 0x6f, 0x72, 0x6d, 0x73, 0x03, 0x1c, 0x2c, 0xdb, 0x02,
-0x02, 0x3d, 0x01, 0x00, 0x36, 0x00, 0x01, 0x67, 0x02, 0x00,
-0x5e, 0x00, 0x05, 0x96, 0x09, 0x21, 0x69, 0x74, 0x8b, 0x06,
-0x00, 0x0e, 0x06, 0x02, 0x66, 0x0c, 0x23, 0x6f, 0x6e, 0xa9,
-0x0b, 0x04, 0x5a, 0x00, 0x13, 0x2e, 0xbe, 0x0a, 0x12, 0x73,
-0xbb, 0x08, 0x61, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75, 0x04,
-0x0c, 0x12, 0x65, 0x95, 0x05, 0x01, 0x05, 0x04, 0x1c, 0x62,
-0x95, 0x01, 0x05, 0x5f, 0x01, 0x00, 0x5a, 0x0c, 0xa5, 0x74,
-0x6c, 0x65, 0x2c, 0x00, 0x73, 0x6f, 0x00, 0x69, 0x66, 0xaf,
-0x0a, 0x05, 0x3f, 0x04, 0x00, 0xae, 0x06, 0x00, 0xce, 0x08,
-0x02, 0xa2, 0x0b, 0x62, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
-0x9d, 0x01, 0x70, 0x72, 0x69, 0x73, 0x6b, 0x00, 0x68, 0x61,
-0x8d, 0x08, 0x06, 0x77, 0x00, 0x04, 0xba, 0x00, 0xb2, 0x2e,
-0x00, 0x41, 0x6c, 0x73, 0x6f, 0x2c, 0x00, 0x66, 0x69, 0x6e,
-0x6b, 0x02, 0x24, 0x6c, 0x6c, 0xed, 0x07, 0x42, 0x73, 0x69,
-0x62, 0x6c, 0xc0, 0x00, 0x09, 0xa0, 0x00, 0x20, 0x61, 0x6e,
-0x97, 0x02, 0x01, 0x84, 0x07, 0x50, 0x61, 0x6c, 0x00, 0x63,
-0x68, 0x8d, 0x04, 0x30, 0x6e, 0x67, 0x65, 0xce, 0x03, 0x02,
-0x1c, 0x00, 0x10, 0x76, 0xc8, 0x06, 0x11, 0x64, 0x05, 0x02,
-0x00, 0xc9, 0x03, 0x30, 0x54, 0x75, 0x72, 0xfc, 0x04, 0x05,
-0x9c, 0x00, 0x03, 0xfc, 0x05, 0x00, 0x4f, 0x00, 0x03, 0x0e,
-0x0c, 0x73, 0x70, 0x65, 0x65, 0x64, 0x00, 0x75, 0x70, 0x93,
-0x00, 0x04, 0xf8, 0x01, 0x50, 0x69, 0x6f, 0x6e, 0x2e, 0x00,
+0x01, 0x00, 0xb2, 0x01, 0xf1, 0x01, 0x5b, 0x33, 0x5d, 0x00,
+0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
+0x2e, 0x6e, 0x87, 0x01, 0xa3, 0x2e, 0x63, 0x6f, 0x2e, 0x6a,
+0x70, 0x2f, 0x65, 0x6e, 0x2f, 0x4d, 0x00, 0xf0, 0x06, 0x2f,
+0x73, 0x68, 0x69, 0x6b, 0x61, 0x6b, 0x75, 0x2e, 0x68, 0x74,
+0x6d, 0x6c, 0x00, 0x28, 0x62, 0x65, 0x77, 0x61, 0x72, 0x65,
+0x6d, 0x00, 0x60, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x29, 0x48,
+0x00, 0x12, 0x34, 0x48, 0x00, 0x10, 0x73, 0x49, 0x00, 0xe0,
+0x65, 0x62, 0x2e, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65,
+0x2e, 0x6f, 0x72, 0x67, 0x10, 0x00, 0xf7, 0x01, 0x2f, 0x32,
+0x30, 0x30, 0x34, 0x31, 0x30, 0x32, 0x34, 0x30, 0x30, 0x31,
+0x34, 0x35, 0x39, 0x2f, 0x73, 0x00, 0x02, 0x63, 0x00, 0x30,
+0x2e, 0x67, 0x72, 0x73, 0x00, 0x02, 0x0d, 0x00, 0x21, 0x2f,
+0x73, 0x6e, 0x00, 0xb1, 0x2f, 0x70, 0x61, 0x6c, 0x6d, 0x2f,
+0x69, 0x6e, 0x64, 0x65, 0x78, 0x79, 0x00, 0x98, 0x2e, 0x65,
+0x6e, 0x00, 0x00, 0x00, 0x38, 0x2e, 0x31, 0xb2, 0x03, 0x00,
+0xf5, 0x02, 0x31, 0x72, 0x6f, 0x6c, 0xbb, 0x03, 0x15, 0x54,
+0x74, 0x02, 0x92, 0x69, 0x73, 0x00, 0x70, 0x6c, 0x61, 0x79,
+0x65, 0x64, 0xb3, 0x03, 0x00, 0x45, 0x01, 0xf0, 0x05, 0x6d,
+0x6f, 0x75, 0x73, 0x65, 0x00, 0x6f, 0x72, 0x00, 0x63, 0x75,
+0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x02,
+0x01, 0xa1, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69,
+0x63, 0x6b, 0xe4, 0x01, 0x41, 0x65, 0x64, 0x67, 0x65, 0xae,
+0x02, 0x21, 0x6f, 0x67, 0x0b, 0x03, 0x01, 0x85, 0x01, 0x70,
+0x6f, 0x72, 0x00, 0x6f, 0x66, 0x66, 0x2c, 0x08, 0x00, 0x18,
+0x6c, 0x2f, 0x00, 0x60, 0x64, 0x00, 0x64, 0x72, 0x61, 0x67,
+0x2f, 0x00, 0x40, 0x64, 0x72, 0x61, 0x77, 0x96, 0x01, 0x67,
+0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x4c, 0x03, 0x10, 0x28,
+0x34, 0x00, 0x44, 0x69, 0x6e, 0x65, 0x29, 0xcd, 0x01, 0x03,
+0xeb, 0x03, 0x01, 0x9d, 0x03, 0xc2, 0x67, 0x6f, 0x00, 0x28,
+0x72, 0x65, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x7e, 0x00,
+0x40, 0x78, 0x69, 0x73, 0x74, 0x0d, 0x00, 0x00, 0x87, 0x00,
+0x11, 0x73, 0xbd, 0x00, 0x22, 0x69, 0x6e, 0xf2, 0x03, 0x05,
+0x53, 0x00, 0x73, 0x29, 0x2e, 0x00, 0x52, 0x69, 0x67, 0x68,
+0x86, 0x00, 0x02, 0x3a, 0x00, 0x02, 0x89, 0x00, 0x10, 0x67,
+0x0d, 0x00, 0x40, 0x77, 0x69, 0x6c, 0x6c, 0x83, 0x04, 0x21,
+0x6f, 0x77, 0x2e, 0x02, 0x72, 0x74, 0x6f, 0x00, 0x65, 0x72,
+0x61, 0x73, 0x67, 0x04, 0x00, 0x2d, 0x01, 0x32, 0x65, 0x6e,
+0x74, 0xd1, 0x02, 0x07, 0xa5, 0x00, 0x00, 0x68, 0x00, 0x91,
+0x6f, 0x75, 0x74, 0x00, 0x61, 0x66, 0x66, 0x65, 0x63, 0x80,
+0x00, 0x00, 0xe1, 0x03, 0x01, 0x84, 0x00, 0x00, 0x23, 0x01,
+0xf4, 0x01, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74,
+0x69, 0x76, 0x65, 0x6c, 0x79, 0x2c, 0x00, 0x75, 0x4e, 0x00,
+0x06, 0x49, 0x01, 0x00, 0x67, 0x00, 0x42, 0x6d, 0x6f, 0x76,
+0x65, 0xaf, 0x02, 0x31, 0x6f, 0x73, 0x69, 0xa4, 0x03, 0x30,
+0x69, 0x6e, 0x64, 0x6b, 0x02, 0x91, 0x6f, 0x72, 0x00, 0x61,
+0x72, 0x6f, 0x75, 0x6e, 0x64, 0x1e, 0x00, 0xc0, 0x62, 0x6f,
+0x61, 0x72, 0x64, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73,
+0x6a, 0x00, 0x20, 0x74, 0x68, 0x2f, 0x01, 0x40, 0x74, 0x75,
+0x72, 0x6e, 0x4a, 0x00, 0x00, 0x0f, 0x00, 0x12, 0x6e, 0xbf,
+0x00, 0x14, 0x73, 0xc0, 0x00, 0x0f, 0x70, 0x00, 0x04, 0x01,
+0x7b, 0x01, 0x08, 0xc6, 0x00, 0x00, 0xc2, 0x00, 0x42, 0x66,
+0x72, 0x6f, 0x6d, 0x30, 0x01, 0x04, 0x86, 0x00, 0x02, 0xf2,
+0x04, 0x1f, 0x70, 0x6f, 0x00, 0x04, 0x80, 0x61, 0x67, 0x61,
+0x69, 0x6e, 0x00, 0x63, 0x6f, 0x21, 0x04, 0x21, 0x74, 0x65,
+0xb4, 0x03, 0x06, 0x52, 0x00, 0x35, 0x2e, 0x00, 0x55, 0x34,
+0x00, 0x20, 0x73, 0x70, 0x65, 0x04, 0xa1, 0x62, 0x61, 0x72,
+0x00, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x19, 0x06, 0x0c,
+0x4d, 0x00, 0x09, 0xb7, 0x00, 0x0f, 0x77, 0x01, 0x2a, 0x10,
+0x2c, 0x22, 0x04, 0x57, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2b,
+0x01, 0xf1, 0x01, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x00,
+0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x73, 0x00, 0x61, 0x03,
+0x01, 0x00, 0xa1, 0x01, 0x11, 0x57, 0x35, 0x01, 0x08, 0x0b,
+0x01, 0x13, 0x66, 0x79, 0x00, 0x10, 0x72, 0x14, 0x00, 0x02,
+0xb9, 0x04, 0x25, 0x69, 0x73, 0xe8, 0x00, 0x20, 0x64, 0x2c,
+0xd9, 0x02, 0x01, 0x2a, 0x02, 0x90, 0x62, 0x65, 0x00, 0x73,
+0x68, 0x61, 0x64, 0x65, 0x64, 0x48, 0x00, 0x42, 0x28, 0x41,
+0x6c, 0x6c, 0x19, 0x06, 0x10, 0x63, 0x3b, 0x01, 0x10, 0x73,
+0xcd, 0x04, 0x61, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0xe6,
+0x06, 0x21, 0x65, 0x63, 0xd7, 0x01, 0x30, 0x32, 0x2e, 0x31,
+0x3a, 0x06, 0x02, 0xa3, 0x05, 0xb1, 0x61, 0x76, 0x61, 0x69,
+0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29, 0x9d, 0x03, 0x18,
+0x32, 0x9d, 0x03, 0x93, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
+0x74, 0x65, 0x72, 0x9f, 0x03, 0x01, 0xfa, 0x05, 0x05, 0x14,
+0x00, 0x02, 0x45, 0x00, 0x04, 0x40, 0x00, 0x04, 0xbb, 0x01,
+0xf1, 0x01, 0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f,
+0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x73, 0x00,
+0x03, 0x3c, 0x03, 0xb1, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27,
+0x00, 0x6d, 0x65, 0x6e, 0x75, 0xf7, 0x00, 0x80, 0x69, 0x64,
+0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x0f, 0x03, 0x61, 0x00,
+0x00, 0x00, 0x53, 0x69, 0x7a, 0xfb, 0x00, 0x00, 0x63, 0x03,
+0x11, 0x2c, 0xb2, 0x00, 0x04, 0x7e, 0x07, 0x70, 0x00, 0x00,
+0x45, 0x78, 0x70, 0x61, 0x6e, 0xf2, 0x05, 0x40, 0x20, 0x66,
+0x61, 0x63, 0x93, 0x02, 0x03, 0x2f, 0x04, 0x10, 0x69, 0x48,
+0x01, 0x91, 0x6d, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x73,
+0x6d, 0xbb, 0x06, 0x00, 0x0c, 0x00, 0x14, 0x67, 0xf8, 0x01,
+0x35, 0x74, 0x79, 0x70, 0x54, 0x00, 0x15, 0x73, 0x20, 0x06,
+0x42, 0x64, 0x00, 0x62, 0x79, 0xec, 0x02, 0x90, 0x72, 0x6f,
+0x67, 0x72, 0x61, 0x6d, 0x2e, 0x00, 0x53, 0x03, 0x08, 0x60,
+0x70, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x6d, 0x02, 0x34, 0x66,
+0x65, 0x72, 0x41, 0x08, 0x03, 0x97, 0x07, 0x01, 0xa9, 0x03,
+0x97, 0x00, 0x66, 0x65, 0x77, 0x00, 0x6c, 0x61, 0x72, 0x67,
+0x66, 0x02, 0x01, 0xcd, 0x02, 0x00, 0x0e, 0x04, 0x07, 0x29,
+0x00, 0x11, 0x6d, 0x6f, 0x06, 0x40, 0x6d, 0x61, 0x6c, 0x6c,
+0x1a, 0x00, 0x10, 0x73, 0x5f, 0x00, 0x01, 0x57, 0x02, 0x40,
+0x63, 0x61, 0x6e, 0x00, 0x44, 0x08, 0x19, 0x52, 0x3d, 0x00,
+0x30, 0x65, 0x73, 0x73, 0x78, 0x04, 0x09, 0xc2, 0x06, 0x22,
+0x00, 0x61, 0x40, 0x00, 0x22, 0x65, 0x72, 0x86, 0x00, 0x32,
+0x74, 0x68, 0x61, 0x44, 0x01, 0x05, 0xc5, 0x06, 0x03, 0x0c,
+0x06, 0x22, 0x65, 0x64, 0x22, 0x03, 0x01, 0x79, 0x03, 0x00,
+0x4d, 0x00, 0x00, 0x29, 0x01, 0x10, 0x64, 0x20, 0x02, 0x60,
+0x62, 0x79, 0x00, 0x61, 0x64, 0x64, 0x8f, 0x00, 0x10, 0x72,
+0xd7, 0x02, 0x20, 0x61, 0x6e, 0xcc, 0x00, 0x41, 0x6c, 0x75,
+0x6d, 0x6e, 0x51, 0x01, 0x00, 0xfe, 0x06, 0x72, 0x64, 0x65,
+0x66, 0x61, 0x75, 0x6c, 0x74, 0x34, 0x00, 0x01, 0x4f, 0x07,
+0x03, 0x5d, 0x01, 0xd2, 0x6f, 0x66, 0x00, 0x7a, 0x65, 0x72,
+0x6f, 0x00, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x90, 0x03, 0x07,
+0xb3, 0x00, 0x01, 0x79, 0x02, 0x10, 0x73, 0x95, 0x07, 0x09,
+0xb0, 0x00, 0x04, 0x6f, 0x09, 0x09, 0xa6, 0x00, 0x00, 0xee,
+0x00, 0x42, 0x66, 0x6f, 0x72, 0x2c, 0xe5, 0x04, 0x10, 0x6f,
+0x4b, 0x07, 0x10, 0x68, 0x93, 0x00, 0x30, 0x66, 0x75, 0x72,
+0x60, 0x07, 0x42, 0x2e, 0x00, 0x49, 0x66, 0xce, 0x00, 0x02,
+0x16, 0x07, 0x0f, 0x8a, 0x00, 0x01, 0x91, 0x28, 0x73, 0x61,
+0x79, 0x29, 0x00, 0x30, 0x2e, 0x35, 0xf6, 0x02, 0x07, 0x93,
+0x00, 0x01, 0xf7, 0x08, 0x42, 0x64, 0x69, 0x6d, 0x65, 0x32,
+0x00, 0x26, 0x6f, 0x66, 0xa1, 0x05, 0x04, 0x1c, 0x03, 0x02,
+0x0e, 0x01, 0x02, 0x46, 0x07, 0x43, 0x68, 0x61, 0x6c, 0x66,
+0x31, 0x04, 0x70, 0x61, 0x73, 0x00, 0x62, 0x69, 0x67, 0x00,
+0xbc, 0x07, 0x14, 0x72, 0xc3, 0x00, 0x01, 0x52, 0x07, 0x60,
+0x49, 0x6e, 0x00, 0x6f, 0x74, 0x68, 0x2d, 0x09, 0x51, 0x6f,
+0x72, 0x64, 0x73, 0x2c, 0x51, 0x00, 0x30, 0x69, 0x6e, 0x69,
+0x9d, 0x01, 0x0a, 0x59, 0x00, 0x36, 0x32, 0x2f, 0x33, 0xe9,
+0x00, 0x2b, 0x69, 0x6e, 0x8c, 0x00, 0x02, 0xef, 0x00, 0x0f,
+0x85, 0x00, 0x01, 0x00, 0x22, 0x04, 0x21, 0x66, 0x75, 0x40,
+0x01, 0x17, 0x7a, 0x42, 0x04, 0x24, 0x64, 0x64, 0x43, 0x06,
+0x28, 0x6d, 0x6f, 0x80, 0x06, 0x01, 0xab, 0x01, 0x31, 0x53,
+0x65, 0x74, 0x5e, 0x04, 0x0f, 0x20, 0x01, 0x04, 0x03, 0x9d,
+0x05, 0x82, 0x30, 0x2e, 0x35, 0x00, 0x74, 0x65, 0x6e, 0x64,
+0xcd, 0x05, 0x23, 0x61, 0x6b, 0x9a, 0x0a, 0x00, 0x4f, 0x07,
+0x01, 0x54, 0x00, 0x92, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63,
+0x75, 0x6c, 0x74, 0x9d, 0x00, 0x01, 0xfe, 0x03, 0x50, 0x28,
+0x69, 0x6e, 0x00, 0x6d, 0xb7, 0x06, 0xb0, 0x70, 0x65, 0x72,
+0x69, 0x65, 0x6e, 0x63, 0x65, 0x29, 0x00, 0x72, 0x1d, 0x08,
+0x10, 0x64, 0x56, 0x03, 0x30, 0x6c, 0x65, 0x73, 0x42, 0x04,
+0x30, 0x64, 0x75, 0x63, 0x3a, 0x06, 0x01, 0x35, 0x00, 0x01,
+0x49, 0x00, 0x51, 0x69, 0x6e, 0x74, 0x75, 0x69, 0x13, 0x00,
+0x00, 0xa4, 0x07, 0x00, 0x99, 0x00, 0x59, 0x73, 0x74, 0x79,
+0x6c, 0x65, 0xcb, 0x01, 0xd0, 0x69, 0x74, 0x00, 0x74, 0x6f,
+0x6f, 0x00, 0x68, 0x69, 0x67, 0x68, 0x2c, 0x00, 0xe4, 0x00,
+0x02, 0x08, 0x00, 0x03, 0x90, 0x00, 0x03, 0x3c, 0x02, 0x30,
+0x63, 0x61, 0x6e, 0x5a, 0x09, 0x05, 0x43, 0x02, 0x01, 0x5e,
+0x00, 0x01, 0xe9, 0x02, 0x02, 0x69, 0x03, 0x0a, 0x63, 0x03,
+0x51, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x44, 0x00, 0x03, 0xa5,
+0x07, 0x02, 0x27, 0x04, 0x03, 0xfc, 0x02, 0x02, 0x59, 0x00,
+0x50, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x2f, 0x00, 0x61, 0x72,
+0x69, 0x76, 0x69, 0x61, 0x6c, 0x39, 0x04, 0xf1, 0x02, 0x6e,
+0x73, 0x75, 0x72, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75,
+0x65, 0x20, 0x73, 0x6f, 0x6c, 0x75, 0x92, 0x04, 0x60, 0x00,
+0x00, 0x4e, 0x6f, 0x72, 0x6d, 0x73, 0x03, 0x1d, 0x2c, 0xdb,
+0x02, 0x01, 0x3d, 0x01, 0x00, 0x36, 0x00, 0x02, 0x67, 0x02,
+0x01, 0x28, 0x04, 0x03, 0x96, 0x09, 0x21, 0x69, 0x74, 0x8b,
+0x06, 0x01, 0x0e, 0x06, 0x01, 0x66, 0x0c, 0x23, 0x6f, 0x6e,
+0xa9, 0x0b, 0x04, 0x5a, 0x00, 0x13, 0x2e, 0xbe, 0x0a, 0x12,
+0x73, 0xbb, 0x08, 0x61, 0x61, 0x6d, 0x62, 0x69, 0x67, 0x75,
+0x04, 0x0c, 0x13, 0x65, 0x95, 0x05, 0x00, 0x05, 0x04, 0x1c,
+0x62, 0x95, 0x01, 0x06, 0x5f, 0x01, 0xd5, 0x73, 0x75, 0x62,
+0x74, 0x6c, 0x65, 0x2c, 0x00, 0x73, 0x6f, 0x00, 0x69, 0x66,
+0xaf, 0x0a, 0x05, 0x3f, 0x04, 0x01, 0xae, 0x06, 0x32, 0x6f,
+0x66, 0x66, 0xa2, 0x0b, 0x62, 0x66, 0x65, 0x61, 0x74, 0x75,
+0x72, 0x9d, 0x01, 0x40, 0x72, 0x69, 0x73, 0x6b, 0x95, 0x00,
+0x01, 0x2b, 0x02, 0x05, 0x77, 0x00, 0x03, 0xba, 0x00, 0xb2,
+0x2e, 0x00, 0x41, 0x6c, 0x73, 0x6f, 0x2c, 0x00, 0x66, 0x69,
+0x6e, 0x6b, 0x02, 0x24, 0x6c, 0x6c, 0xed, 0x07, 0x12, 0x73,
+0x82, 0x0a, 0x03, 0xc0, 0x00, 0x05, 0xa0, 0x00, 0x21, 0x61,
+0x6e, 0x97, 0x02, 0x00, 0x14, 0x00, 0x20, 0x61, 0x6c, 0x55,
+0x05, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x63, 0x05,
+0x01, 0x1c, 0x00, 0x10, 0x76, 0xc8, 0x06, 0x12, 0x64, 0xa9,
+0x09, 0x61, 0x72, 0x2e, 0x00, 0x54, 0x75, 0x72, 0xfc, 0x04,
+0x05, 0x9c, 0x00, 0x03, 0xfc, 0x05, 0x01, 0xf4, 0x04, 0x01,
+0x0e, 0x0c, 0x74, 0x70, 0x65, 0x65, 0x64, 0x00, 0x75, 0x70,
+0x6a, 0x0b, 0x03, 0xf8, 0x01, 0x50, 0x69, 0x6f, 0x6e, 0x2e,
+0x00,
 };
 
 const unsigned short help_text_len = 3535;
diff --git a/apps/plugins/puzzles/help/samegame.c b/apps/plugins/puzzles/help/samegame.c
index 067dea0cec..2f8e8a3003 100644
--- a/apps/plugins/puzzles/help/samegame.c
+++ b/apps/plugins/puzzles/help/samegame.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -17,7 +17,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2470 comp 1632 ratio 0.660729 level 11 saved 838 */
+/* orig 2470 comp 1634 ratio 0.661538 level 10 saved 836 */
 const char help_text[] = {
 0xf0, 0x03, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x33, 0x3a, 0x20, 0x53, 0x61, 0x6d, 0x65, 0x20, 0x47,
@@ -32,16 +32,16 @@ const char help_text[] = {
 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x6f, 0x75, 0x73,
 0x00, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x00,
 0xdc, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x74, 0x68, 0x61, 0x6e,
-0x00, 0x6f, 0x6e, 0x65, 0x5e, 0x00, 0xc0, 0x3b, 0x00, 0x74,
+0x00, 0x6f, 0x6e, 0x65, 0x5e, 0x00, 0xc1, 0x3b, 0x00, 0x74,
 0x68, 0x65, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x0b,
-0x00, 0x03, 0x39, 0x00, 0x00, 0x6d, 0x00, 0x06, 0x5c, 0x00,
-0x10, 0x2c, 0x1a, 0x00, 0x02, 0x48, 0x00, 0x61, 0x70, 0x6f,
+0x00, 0x02, 0x39, 0x00, 0x02, 0x6d, 0x00, 0x04, 0x5c, 0x00,
+0x11, 0x2c, 0x1a, 0x00, 0x01, 0x48, 0x00, 0x61, 0x70, 0x6f,
 0x69, 0x6e, 0x74, 0x73, 0x1f, 0x00, 0x81, 0x67, 0x65, 0x74,
-0x00, 0x28, 0x61, 0x6e, 0x64, 0x1d, 0x00, 0x60, 0x66, 0x61,
-0x73, 0x74, 0x65, 0x72, 0x18, 0x00, 0x01, 0x9c, 0x00, 0x02,
-0x4c, 0x00, 0xca, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x29, 0x2e,
+0x00, 0x28, 0x61, 0x6e, 0x64, 0x1d, 0x00, 0x61, 0x66, 0x61,
+0x73, 0x74, 0x65, 0x72, 0x18, 0x00, 0x02, 0x9c, 0x00, 0x00,
+0x15, 0x00, 0xcb, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x29, 0x2e,
 0x00, 0x00, 0x00, 0x49, 0x66, 0x1b, 0x00, 0x01, 0xed, 0x00,
-0x01, 0x13, 0x00, 0x44, 0x77, 0x69, 0x6e, 0x2e, 0x1f, 0x00,
+0x00, 0x13, 0x00, 0x44, 0x77, 0x69, 0x6e, 0x2e, 0x1f, 0x00,
 0xf0, 0x01, 0x65, 0x6e, 0x64, 0x00, 0x75, 0x70, 0x00, 0x77,
 0x69, 0x74, 0x68, 0x00, 0x6e, 0x6f, 0x74, 0x68, 0xd4, 0x00,
 0xa4, 0x62, 0x75, 0x74, 0x00, 0x73, 0x69, 0x6e, 0x67, 0x6c,
@@ -52,8 +52,8 @@ const char help_text[] = {
 0x5c, 0x00, 0x40, 0x6c, 0x6f, 0x73, 0x65, 0x8a, 0x00, 0x50,
 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x59, 0x00, 0x14, 0x61, 0xeb,
 0x00, 0x63, 0x63, 0x61, 0x75, 0x73, 0x65, 0x73, 0xfd, 0x00,
-0x55, 0x73, 0x74, 0x00, 0x6f, 0x66, 0xa2, 0x00, 0x00, 0x6b,
-0x01, 0xf0, 0x03, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65,
+0x20, 0x73, 0x74, 0x33, 0x01, 0x05, 0xa2, 0x00, 0xf0, 0x06,
+0x74, 0x6f, 0x00, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65,
 0x00, 0x75, 0x70, 0x3a, 0x00, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
 0x73, 0x4d, 0x01, 0x11, 0x74, 0x79, 0x00, 0xf3, 0x13, 0x73,
 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x00, 0x77,
@@ -66,123 +66,123 @@ const char help_text[] = {
 0xa3, 0x00, 0x00, 0x21, 0x02, 0x20, 0x00, 0x47, 0x05, 0x00,
 0x31, 0x77, 0x61, 0x73, 0xd5, 0x01, 0x61, 0x72, 0x69, 0x62,
 0x75, 0x74, 0x65, 0x8f, 0x00, 0x40, 0x74, 0x68, 0x69, 0x73,
-0x47, 0x00, 0x70, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-0x04, 0x02, 0xc0, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48,
-0x61, 0x72, 0x76, 0x65, 0x79, 0x40, 0x00, 0x47, 0x31, 0x33,
-0x2e, 0x31, 0x66, 0x02, 0x01, 0x41, 0x00, 0x30, 0x6f, 0x6c,
-0x73, 0x6f, 0x02, 0x10, 0x54, 0x3e, 0x00, 0x10, 0x67, 0x5b,
-0x00, 0xd2, 0x63, 0x61, 0x6e, 0x00, 0x62, 0x65, 0x00, 0x70,
-0x6c, 0x61, 0x79, 0x65, 0x64, 0x73, 0x01, 0x43, 0x65, 0x69,
-0x74, 0x68, 0x06, 0x02, 0xb3, 0x6b, 0x65, 0x79, 0x62, 0x6f,
-0x61, 0x72, 0x64, 0x00, 0x6f, 0x72, 0xfc, 0x01, 0x36, 0x75,
-0x73, 0x65, 0xc9, 0x01, 0x01, 0x58, 0x01, 0x11, 0x2d, 0x6f,
-0x01, 0x80, 0x00, 0x61, 0x6e, 0x00, 0x75, 0x6e, 0x73, 0x65,
-0x90, 0x00, 0x23, 0x65, 0x64, 0x54, 0x01, 0x90, 0x2c, 0x00,
-0x69, 0x74, 0x00, 0x62, 0x65, 0x63, 0x6f, 0x99, 0x00, 0x05,
-0x1c, 0x00, 0x92, 0x28, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62,
-0x6c, 0x79, 0x08, 0x02, 0x31, 0x69, 0x6e, 0x67, 0x5c, 0x00,
-0xa3, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x73,
-0x65, 0xd4, 0x00, 0x1f, 0x29, 0x69, 0x00, 0x02, 0x01, 0x2c,
-0x00, 0x0f, 0x68, 0x00, 0x00, 0x01, 0x7b, 0x01, 0x00, 0xcb,
-0x00, 0x10, 0x72, 0xda, 0x01, 0x24, 0x65, 0x64, 0x94, 0x02,
-0x0e, 0xce, 0x01, 0x04, 0xcb, 0x01, 0xd7, 0x64, 0x00, 0x69,
-0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79,
-0x6d, 0x00, 0x01, 0x82, 0x01, 0x0f, 0x6e, 0x00, 0x14, 0x07,
-0xf4, 0x00, 0x10, 0x2e, 0x58, 0x01, 0x02, 0xc8, 0x00, 0x30,
-0x73, 0x6f, 0x72, 0x3b, 0x01, 0x40, 0x73, 0x00, 0x6d, 0x6f,
-0xd3, 0x03, 0x04, 0x13, 0x00, 0x65, 0x61, 0x72, 0x6f, 0x75,
-0x6e, 0x64, 0x88, 0x00, 0x74, 0x2e, 0x00, 0x50, 0x72, 0x65,
-0x73, 0x73, 0x00, 0x01, 0x50, 0x53, 0x70, 0x61, 0x63, 0x65,
-0x69, 0x01, 0x42, 0x45, 0x6e, 0x74, 0x65, 0x40, 0x00, 0x00,
-0xf2, 0x03, 0x46, 0x6c, 0x65, 0x00, 0x74, 0x56, 0x00, 0x5f,
-0x69, 0x73, 0x00, 0x69, 0x6e, 0x6c, 0x01, 0x02, 0x03, 0xa6,
-0x00, 0x73, 0x73, 0x00, 0x69, 0x74, 0x3b, 0x00, 0x70, 0x59,
-0x00, 0x0c, 0x55, 0x00, 0x53, 0x61, 0x67, 0x61, 0x69, 0x6e,
-0x22, 0x01, 0x10, 0x73, 0xc7, 0x00, 0x71, 0x61, 0x73, 0x00,
-0x61, 0x62, 0x6f, 0x76, 0xd4, 0x01, 0x42, 0x28, 0x41, 0x6c,
-0x6c, 0xb0, 0x03, 0x21, 0x63, 0x74, 0x36, 0x03, 0x90, 0x64,
-0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x74, 0x00,
-0x13, 0x73, 0x69, 0x02, 0x31, 0x32, 0x2e, 0x31, 0xb7, 0x02,
-0xa0, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x61, 0x76, 0x61, 0x69,
-0x6c, 0x6a, 0x03, 0x22, 0x2e, 0x29, 0x71, 0x02, 0x17, 0x32,
-0x71, 0x02, 0x93, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
-0x65, 0x72, 0x73, 0x02, 0x45, 0x65, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x01, 0xfc, 0x02, 0x06, 0x40, 0x00, 0x06, 0xff, 0x02,
-0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
-0x2e, 0x27, 0x00, 0x6f, 0x70, 0x73, 0x00, 0x22, 0x6f, 0x6e,
-0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0xaf, 0x00, 0x90, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0xae, 0x01, 0x00, 0x2f, 0x03,
-0x62, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x66, 0xe3, 0x01, 0x24,
-0x69, 0x6e, 0x27, 0x04, 0x00, 0x2b, 0x00, 0x72, 0x4e, 0x6f,
-0x2e, 0x20, 0x6f, 0x66, 0x20, 0xf4, 0x04, 0x10, 0x73, 0x11,
-0x00, 0x50, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x00, 0x51,
-0x64, 0x69, 0x66, 0x66, 0x65, 0x78, 0x02, 0x04, 0x1e, 0x00,
-0x21, 0x75, 0x73, 0x62, 0x03, 0x01, 0x98, 0x03, 0x05, 0xac,
-0x01, 0x15, 0x3b, 0xfb, 0x04, 0x04, 0x28, 0x00, 0x12, 0x2c,
-0xf0, 0x04, 0x41, 0x65, 0x77, 0x65, 0x72, 0x38, 0x05, 0x05,
-0x6d, 0x04, 0x06, 0xbc, 0x05, 0x03, 0xf6, 0x03, 0x25, 0x75,
-0x73, 0x3d, 0x00, 0x01, 0x6f, 0x00, 0x50, 0x69, 0x63, 0x75,
-0x6c, 0x74, 0x7d, 0x01, 0x21, 0x69, 0x73, 0x59, 0x04, 0xbb,
-0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c,
-0x79, 0x1a, 0x05, 0x01, 0x06, 0x04, 0x20, 0x63, 0x6f, 0x23,
-0x03, 0xb2, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x00,
-0x00, 0x00, 0x43, 0xc8, 0x03, 0x01, 0x55, 0x00, 0x00, 0xe9,
-0x01, 0xe2, 0x63, 0x69, 0x73, 0x65, 0x00, 0x6d, 0x65, 0x63,
-0x68, 0x61, 0x6e, 0x69, 0x73, 0x6d, 0xbf, 0x00, 0x52, 0x66,
-0x6f, 0x72, 0x00, 0x73, 0x39, 0x00, 0x61, 0x2e, 0x00, 0x57,
-0x69, 0x74, 0x68, 0x2d, 0x00, 0x40, 0x64, 0x65, 0x66, 0x61,
-0x7b, 0x00, 0x02, 0x4b, 0x00, 0xf8, 0x02, 0x2c, 0x00, 0x60,
-0x28, 0x6e, 0x2d, 0x32, 0x29, 0x5e, 0x32, 0x27, 0x2c, 0x00,
-0x6f, 0x6e, 0x6c, 0x79, 0xc1, 0x00, 0x46, 0x74, 0x68, 0x72,
-0x65, 0x6a, 0x05, 0x21, 0x6f, 0x72, 0xbe, 0x00, 0x01, 0xf5,
-0x02, 0x00, 0x58, 0x00, 0x00, 0xba, 0x01, 0x24, 0x6e, 0x79,
-0x05, 0x06, 0x00, 0x05, 0x05, 0x27, 0x6c, 0x6c, 0x68, 0x00,
-0xb1, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
-0x76, 0x65, 0x64, 0x00, 0x10, 0x31, 0x64, 0x00, 0x04, 0x76,
-0x00, 0x09, 0x66, 0x00, 0x24, 0x77, 0x6f, 0x64, 0x00, 0x04,
-0x57, 0x00, 0x02, 0x55, 0x00, 0x51, 0x00, 0x65, 0x61, 0x63,
-0x68, 0x36, 0x05, 0x03, 0x94, 0x06, 0x03, 0x36, 0x00, 0x04,
-0x27, 0x00, 0x31, 0x72, 0x65, 0x6c, 0x5f, 0x00, 0x27, 0x6c,
-0x79, 0x8f, 0x06, 0x01, 0xeb, 0x01, 0xf1, 0x02, 0x45, 0x6e,
-0x73, 0x75, 0x72, 0x65, 0x20, 0x73, 0x6f, 0x6c, 0x75, 0x62,
-0x69, 0x6c, 0x69, 0x74, 0x79, 0xd7, 0x03, 0x01, 0x2f, 0x05,
-0x03, 0x4f, 0x02, 0x01, 0x77, 0x01, 0x30, 0x69, 0x63, 0x6b,
-0x23, 0x04, 0x09, 0x16, 0x01, 0xd0, 0x74, 0x61, 0x74, 0x65,
-0x29, 0x2c, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x59,
-0x03, 0x00, 0x83, 0x01, 0x15, 0x73, 0xea, 0x03, 0x81, 0x67,
-0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x1e, 0x02, 0x03,
-0xad, 0x07, 0x71, 0x74, 0x00, 0x6c, 0x65, 0x61, 0x73, 0x74,
-0x52, 0x07, 0x00, 0x73, 0x00, 0x00, 0x60, 0x00, 0x07, 0x49,
-0x04, 0x60, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x69, 0x7d, 0x04,
-0x11, 0x66, 0x2f, 0x02, 0x01, 0x73, 0x05, 0x04, 0x61, 0x00,
-0x21, 0x6f, 0x72, 0x5b, 0x00, 0x00, 0xe2, 0x06, 0x76, 0x00,
-0x74, 0x72, 0x79, 0x00, 0x74, 0x6f, 0x63, 0x00, 0x11, 0x00,
-0xc0, 0x00, 0x22, 0x6c, 0x65, 0x83, 0x00, 0x14, 0x3b, 0x71,
-0x04, 0xd0, 0x2c, 0x00, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65,
-0x72, 0x2c, 0x00, 0x73, 0x74, 0x3c, 0x00, 0x11, 0x65, 0xee,
-0x00, 0x01, 0x89, 0x06, 0x05, 0x08, 0x07, 0x07, 0x97, 0x00,
-0x16, 0x32, 0xc2, 0x01, 0x11, 0x66, 0x53, 0x01, 0x04, 0x99,
-0x02, 0x26, 0x6f, 0x6e, 0x0e, 0x05, 0x02, 0x3b, 0x00, 0x00,
-0xff, 0x00, 0x83, 0x72, 0x74, 0x00, 0x28, 0x73, 0x69, 0x6e,
-0x63, 0x86, 0x08, 0x04, 0x0f, 0x06, 0x93, 0x78, 0x61, 0x63,
-0x74, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x11, 0x02, 0x00, 0x66,
-0x03, 0x00, 0x22, 0x00, 0x44, 0x69, 0x76, 0x65, 0x6e, 0x51,
-0x00, 0x20, 0x69, 0x73, 0x48, 0x01, 0x40, 0x69, 0x6e, 0x69,
-0x74, 0x94, 0x01, 0x23, 0x69, 0x6e, 0xc0, 0x00, 0x40, 0x29,
-0x2e, 0x00, 0x47, 0xc2, 0x00, 0x04, 0xf4, 0x00, 0x03, 0x63,
-0x06, 0x09, 0x8f, 0x01, 0x50, 0x64, 0x69, 0x73, 0x61, 0x62,
-0x8e, 0x05, 0x31, 0x6d, 0x61, 0x79, 0xe6, 0x06, 0x30, 0x61,
-0x69, 0x6e, 0xd6, 0x01, 0x02, 0x8f, 0x08, 0x01, 0xd2, 0x00,
-0x10, 0x61, 0xc1, 0x00, 0x07, 0xd7, 0x08, 0x03, 0x76, 0x00,
-0x10, 0x2c, 0xe7, 0x00, 0x11, 0x64, 0x40, 0x05, 0xf0, 0x00,
-0x6f, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x6e,
-0x69, 0x74, 0x69, 0x65, 0x73, 0x01, 0x03, 0x01, 0xb8, 0x08,
-0x22, 0x65, 0x72, 0x32, 0x02, 0x11, 0x73, 0xc1, 0x03, 0x10,
-0x79, 0xef, 0x06, 0x02, 0xba, 0x04, 0x80, 0x74, 0x61, 0x6b,
-0x65, 0x00, 0x6c, 0x65, 0x73, 0x0c, 0x02, 0x21, 0x6d, 0x65,
-0x7d, 0x01, 0x90, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65,
-0x2e, 0x00,
+0x47, 0x00, 0x40, 0x6c, 0x65, 0x63, 0x74, 0xbe, 0x00, 0xf0,
+0x00, 0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00,
+0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x40, 0x00, 0x47, 0x31,
+0x33, 0x2e, 0x31, 0x66, 0x02, 0x01, 0x41, 0x00, 0x30, 0x6f,
+0x6c, 0x73, 0x6f, 0x02, 0x10, 0x54, 0x3e, 0x00, 0x10, 0x67,
+0x5b, 0x00, 0xd2, 0x63, 0x61, 0x6e, 0x00, 0x62, 0x65, 0x00,
+0x70, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x73, 0x01, 0x43, 0x65,
+0x69, 0x74, 0x68, 0x06, 0x02, 0xb3, 0x6b, 0x65, 0x79, 0x62,
+0x6f, 0x61, 0x72, 0x64, 0x00, 0x6f, 0x72, 0xfc, 0x01, 0x37,
+0x75, 0x73, 0x65, 0xc9, 0x01, 0x00, 0x58, 0x01, 0x11, 0x2d,
+0x6f, 0x01, 0x80, 0x00, 0x61, 0x6e, 0x00, 0x75, 0x6e, 0x73,
+0x65, 0x90, 0x00, 0x23, 0x65, 0x64, 0x54, 0x01, 0x90, 0x2c,
+0x00, 0x69, 0x74, 0x00, 0x62, 0x65, 0x63, 0x6f, 0x99, 0x00,
+0x05, 0x1c, 0x00, 0x92, 0x28, 0x70, 0x6f, 0x73, 0x73, 0x69,
+0x62, 0x6c, 0x79, 0x08, 0x02, 0x00, 0x85, 0x01, 0x00, 0x5c,
+0x00, 0x73, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x28,
+0x00, 0x4f, 0x69, 0x6f, 0x6e, 0x29, 0x69, 0x00, 0x03, 0x00,
+0x2c, 0x00, 0x0f, 0x68, 0x00, 0x01, 0x01, 0x7b, 0x01, 0x10,
+0x62, 0xbd, 0x01, 0x56, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x94,
+0x02, 0x0d, 0xce, 0x01, 0x03, 0xcb, 0x01, 0xd8, 0x64, 0x00,
+0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c,
+0x79, 0x6d, 0x00, 0x01, 0x82, 0x01, 0x0f, 0x6e, 0x00, 0x14,
+0x06, 0xf4, 0x00, 0x11, 0x2e, 0x58, 0x01, 0x01, 0xc8, 0x00,
+0x30, 0x73, 0x6f, 0x72, 0x3b, 0x01, 0x41, 0x73, 0x00, 0x6d,
+0x6f, 0xd3, 0x03, 0x03, 0x13, 0x00, 0x65, 0x61, 0x72, 0x6f,
+0x75, 0x6e, 0x64, 0x88, 0x00, 0x74, 0x2e, 0x00, 0x50, 0x72,
+0x65, 0x73, 0x73, 0x00, 0x01, 0x50, 0x53, 0x70, 0x61, 0x63,
+0x65, 0x69, 0x01, 0x43, 0x45, 0x6e, 0x74, 0x65, 0x40, 0x00,
+0x40, 0x77, 0x68, 0x69, 0x6c, 0xb5, 0x03, 0x05, 0x56, 0x00,
+0x5f, 0x69, 0x73, 0x00, 0x69, 0x6e, 0x6c, 0x01, 0x02, 0x03,
+0xa6, 0x00, 0x74, 0x73, 0x00, 0x69, 0x74, 0x3b, 0x00, 0x70,
+0x59, 0x00, 0x0b, 0x55, 0x00, 0x53, 0x61, 0x67, 0x61, 0x69,
+0x6e, 0x22, 0x01, 0x10, 0x73, 0xc7, 0x00, 0x71, 0x61, 0x73,
+0x00, 0x61, 0x62, 0x6f, 0x76, 0xd4, 0x01, 0x42, 0x28, 0x41,
+0x6c, 0x6c, 0xb0, 0x03, 0x21, 0x63, 0x74, 0x36, 0x03, 0x70,
+0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x29, 0x01, 0x00,
+0x5f, 0x00, 0x02, 0x69, 0x02, 0x31, 0x32, 0x2e, 0x31, 0xb7,
+0x02, 0xa0, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x61, 0x76, 0x61,
+0x69, 0x6c, 0x6a, 0x03, 0x22, 0x2e, 0x29, 0x71, 0x02, 0x17,
+0x32, 0x71, 0x02, 0x93, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
+0x74, 0x65, 0x72, 0x73, 0x02, 0x46, 0x65, 0x73, 0x65, 0x00,
+0x14, 0x00, 0x02, 0x45, 0x00, 0x04, 0x40, 0x00, 0x06, 0xff,
+0x02, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e,
+0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x73, 0x00, 0x22, 0x6f,
+0x6e, 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0xaf, 0x00, 0x90, 0x57, 0x69, 0x64,
+0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0xae, 0x01, 0x00, 0x2f,
+0x03, 0x30, 0x69, 0x7a, 0x65, 0xe7, 0x01, 0x01, 0xe3, 0x01,
+0x24, 0x69, 0x6e, 0x27, 0x04, 0x00, 0x2b, 0x00, 0x72, 0x4e,
+0x6f, 0x2e, 0x20, 0x6f, 0x66, 0x20, 0xf4, 0x04, 0x10, 0x73,
+0x11, 0x00, 0x50, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x00,
+0x51, 0x64, 0x69, 0x66, 0x66, 0x65, 0x78, 0x02, 0x04, 0x1e,
+0x00, 0x22, 0x75, 0x73, 0x62, 0x03, 0x00, 0x98, 0x03, 0x05,
+0xac, 0x01, 0x16, 0x3b, 0xfb, 0x04, 0x03, 0x28, 0x00, 0x12,
+0x2c, 0xf0, 0x04, 0x42, 0x65, 0x77, 0x65, 0x72, 0x38, 0x05,
+0x08, 0x6c, 0x05, 0x02, 0x24, 0x00, 0x03, 0xf6, 0x03, 0x26,
+0x75, 0x73, 0x3d, 0x00, 0x00, 0x6f, 0x00, 0x50, 0x69, 0x63,
+0x75, 0x6c, 0x74, 0x7d, 0x01, 0x21, 0x69, 0x73, 0x59, 0x04,
+0xbb, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c,
+0x6c, 0x79, 0x1a, 0x05, 0x01, 0x06, 0x04, 0x20, 0x63, 0x6f,
+0x23, 0x03, 0xb3, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d,
+0x00, 0x00, 0x00, 0x43, 0xc8, 0x03, 0x01, 0x26, 0x00, 0xf2,
+0x02, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x65, 0x00, 0x6d,
+0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x73, 0x6d, 0xbf, 0x00,
+0x52, 0x66, 0x6f, 0x72, 0x00, 0x73, 0x39, 0x00, 0x30, 0x2e,
+0x00, 0x57, 0xd5, 0x03, 0x00, 0x2d, 0x00, 0x40, 0x64, 0x65,
+0x66, 0x61, 0x7b, 0x00, 0x02, 0x4b, 0x00, 0xf8, 0x02, 0x2c,
+0x00, 0x60, 0x28, 0x6e, 0x2d, 0x32, 0x29, 0x5e, 0x32, 0x27,
+0x2c, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0xc1, 0x00, 0x46, 0x74,
+0x68, 0x72, 0x65, 0x6a, 0x05, 0x22, 0x6f, 0x72, 0xbe, 0x00,
+0x01, 0xf5, 0x02, 0x20, 0x73, 0x63, 0x0b, 0x00, 0x34, 0x61,
+0x6e, 0x79, 0x05, 0x06, 0x00, 0x05, 0x05, 0x27, 0x6c, 0x6c,
+0x68, 0x00, 0xb1, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61,
+0x74, 0x69, 0x76, 0x65, 0x64, 0x00, 0x10, 0x31, 0x64, 0x00,
+0x05, 0x76, 0x00, 0x08, 0x66, 0x00, 0x25, 0x77, 0x6f, 0x64,
+0x00, 0x03, 0x57, 0x00, 0x02, 0x55, 0x00, 0x52, 0x00, 0x65,
+0x61, 0x63, 0x68, 0x36, 0x05, 0x03, 0x94, 0x06, 0x04, 0x36,
+0x00, 0x02, 0x27, 0x00, 0x31, 0x72, 0x65, 0x6c, 0x5f, 0x00,
+0x28, 0x6c, 0x79, 0x8f, 0x06, 0x00, 0x2f, 0x01, 0xf2, 0x02,
+0x45, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x73, 0x6f, 0x6c,
+0x75, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xd7, 0x03, 0x01,
+0x2f, 0x05, 0x03, 0x4f, 0x02, 0x00, 0x77, 0x01, 0x30, 0x69,
+0x63, 0x6b, 0x23, 0x04, 0x09, 0x16, 0x01, 0xd0, 0x74, 0x61,
+0x74, 0x65, 0x29, 0x2c, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x72,
+0x61, 0x59, 0x03, 0x00, 0x83, 0x01, 0x15, 0x73, 0xea, 0x03,
+0x82, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x1e,
+0x02, 0x02, 0xad, 0x07, 0x71, 0x74, 0x00, 0x6c, 0x65, 0x61,
+0x73, 0x74, 0x52, 0x07, 0x00, 0x73, 0x00, 0x00, 0x60, 0x00,
+0x07, 0x49, 0x04, 0x60, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x69,
+0x7d, 0x04, 0x12, 0x66, 0x2f, 0x02, 0x01, 0x73, 0x05, 0x03,
+0x61, 0x00, 0x22, 0x6f, 0x72, 0x5b, 0x00, 0x70, 0x6e, 0x6f,
+0x74, 0x00, 0x74, 0x72, 0x79, 0x55, 0x00, 0x05, 0x63, 0x00,
+0x01, 0x4d, 0x00, 0x00, 0x17, 0x03, 0x01, 0x83, 0x00, 0x14,
+0x3b, 0x71, 0x04, 0xd0, 0x2c, 0x00, 0x68, 0x6f, 0x77, 0x65,
+0x76, 0x65, 0x72, 0x2c, 0x00, 0x73, 0x74, 0x3c, 0x00, 0x11,
+0x65, 0xee, 0x00, 0x02, 0x89, 0x06, 0x06, 0x08, 0x07, 0x05,
+0x97, 0x00, 0x16, 0x32, 0xc2, 0x01, 0x11, 0x66, 0x53, 0x01,
+0x04, 0x99, 0x02, 0x26, 0x6f, 0x6e, 0x0e, 0x05, 0x02, 0x3b,
+0x00, 0x00, 0xff, 0x00, 0x85, 0x72, 0x74, 0x00, 0x28, 0x73,
+0x69, 0x6e, 0x63, 0x86, 0x08, 0x02, 0x0f, 0x06, 0x62, 0x78,
+0x61, 0x63, 0x74, 0x6c, 0x79, 0xe4, 0x00, 0x01, 0x4f, 0x00,
+0x00, 0x4e, 0x00, 0x74, 0x61, 0x00, 0x67, 0x69, 0x76, 0x65,
+0x6e, 0x51, 0x00, 0x20, 0x69, 0x73, 0x48, 0x01, 0x40, 0x69,
+0x6e, 0x69, 0x74, 0x94, 0x01, 0x23, 0x69, 0x6e, 0xc0, 0x00,
+0x41, 0x29, 0x2e, 0x00, 0x47, 0x45, 0x01, 0x06, 0x55, 0x01,
+0x01, 0x54, 0x00, 0x08, 0x8f, 0x01, 0x50, 0x64, 0x69, 0x73,
+0x61, 0x62, 0x8e, 0x05, 0x31, 0x6d, 0x61, 0x79, 0xe6, 0x06,
+0x00, 0xa3, 0x04, 0x01, 0xd6, 0x01, 0x02, 0x57, 0x03, 0x43,
+0x61, 0x72, 0x65, 0x61, 0x55, 0x03, 0x05, 0xd7, 0x08, 0x02,
+0x76, 0x00, 0x10, 0x2c, 0xe7, 0x00, 0x11, 0x64, 0x40, 0x05,
+0xf1, 0x00, 0x6f, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x72, 0x74,
+0x75, 0x6e, 0x69, 0x74, 0x69, 0x65, 0x73, 0x01, 0x03, 0x00,
+0xb8, 0x08, 0x22, 0x65, 0x72, 0x32, 0x02, 0x11, 0x73, 0xc1,
+0x03, 0x11, 0x79, 0xef, 0x06, 0x01, 0xba, 0x04, 0x80, 0x74,
+0x61, 0x6b, 0x65, 0x00, 0x6c, 0x65, 0x73, 0x0c, 0x02, 0x21,
+0x6d, 0x65, 0x7d, 0x01, 0x90, 0x65, 0x6e, 0x65, 0x72, 0x61,
+0x74, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2470;
diff --git a/apps/plugins/puzzles/help/signpost.c b/apps/plugins/puzzles/help/signpost.c
index fd496dab24..ceafcfd056 100644
--- a/apps/plugins/puzzles/help/signpost.c
+++ b/apps/plugins/puzzles/help/signpost.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3054 comp 1895 ratio 0.620498 level 11 saved 1159 */
+/* orig 3054 comp 1895 ratio 0.620498 level 10 saved 1159 */
 const char help_text[] = {
 0xf3, 0x29, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x34, 0x3a, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x70, 0x6f,
@@ -30,34 +30,34 @@ const char help_text[] = {
 0x6d, 0x65, 0x47, 0x00, 0x54, 0x00, 0x61, 0x6c, 0x73, 0x6f,
 0x29, 0x00, 0x90, 0x00, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
 0x73, 0x2e, 0x78, 0x00, 0xa1, 0x72, 0x00, 0x6a, 0x6f, 0x62,
-0x00, 0x69, 0x73, 0x00, 0x74, 0x20, 0x00, 0x30, 0x6e, 0x65,
-0x63, 0x5f, 0x00, 0x04, 0x39, 0x00, 0x01, 0x17, 0x00, 0x61,
+0x00, 0x69, 0x73, 0x00, 0x74, 0x20, 0x00, 0x32, 0x6e, 0x65,
+0x63, 0x5f, 0x00, 0x04, 0x39, 0x00, 0x91, 0x74, 0x6f, 0x00,
 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x61, 0x3e, 0x00, 0x90, 0x69,
 0x6e, 0x75, 0x6f, 0x75, 0x73, 0x00, 0x6c, 0x69, 0x7c, 0x00,
 0x14, 0x66, 0x49, 0x00, 0xe1, 0x00, 0x73, 0x74, 0x61, 0x72,
 0x74, 0x69, 0x6e, 0x67, 0x00, 0x61, 0x74, 0x00, 0x31, 0x7d,
 0x00, 0x91, 0x6c, 0x69, 0x6e, 0x6b, 0x65, 0x64, 0x00, 0x69,
-0x6e, 0x4d, 0x00, 0xc0, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
-0x69, 0x6f, 0x6e, 0x00, 0x6f, 0x66, 0x11, 0x00, 0x02, 0xa7,
+0x6e, 0x4d, 0x00, 0x90, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
+0x69, 0x6f, 0x6e, 0x35, 0x00, 0x00, 0x11, 0x00, 0x01, 0xa7,
 0x00, 0x66, 0x73, 0x00, 0x2d, 0x00, 0x73, 0x6f, 0x10, 0x00,
 0x77, 0x00, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x7f, 0x00,
-0x50, 0x00, 0x77, 0x69, 0x74, 0x68, 0x10, 0x00, 0x03, 0x6a,
+0x51, 0x00, 0x77, 0x69, 0x74, 0x68, 0x10, 0x00, 0x02, 0x6a,
 0x00, 0xd0, 0x00, 0x31, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x00,
-0x70, 0x6f, 0x69, 0x6e, 0x74, 0x9b, 0x00, 0x06, 0x2b, 0x00,
-0x04, 0xdd, 0x00, 0x38, 0x69, 0x6e, 0x67, 0x31, 0x00, 0x8f,
+0x70, 0x6f, 0x69, 0x6e, 0x74, 0x9b, 0x00, 0x07, 0x2b, 0x00,
+0x03, 0xdd, 0x00, 0x00, 0x86, 0x00, 0x07, 0x31, 0x00, 0x8f,
 0x32, 0x2c, 0x00, 0x77, 0x68, 0x69, 0x63, 0x68, 0x38, 0x00,
 0x1d, 0x97, 0x33, 0x2c, 0x00, 0x65, 0x74, 0x63, 0x2e, 0x00,
 0x45, 0x7e, 0x01, 0xf1, 0x0e, 0x63, 0x61, 0x6e, 0x00, 0x62,
 0x65, 0x00, 0x61, 0x6e, 0x79, 0x00, 0x64, 0x69, 0x73, 0x74,
 0x61, 0x6e, 0x63, 0x65, 0x00, 0x61, 0x77, 0x61, 0x79, 0x00,
-0x66, 0x72, 0x6f, 0x6d, 0x3d, 0x00, 0x80, 0x70, 0x72, 0x65,
-0x76, 0x69, 0x6f, 0x75, 0x73, 0x98, 0x01, 0x90, 0x2c, 0x00,
-0x61, 0x73, 0x00, 0x6c, 0x6f, 0x6e, 0x67, 0x08, 0x00, 0x51,
-0x69, 0x74, 0x00, 0x69, 0x73, 0x92, 0x01, 0x5f, 0x77, 0x68,
+0x66, 0x72, 0x6f, 0x6d, 0x3d, 0x00, 0x50, 0x70, 0x72, 0x65,
+0x76, 0x69, 0x21, 0x01, 0xc0, 0x6f, 0x6e, 0x65, 0x2c, 0x00,
+0x61, 0x73, 0x00, 0x6c, 0x6f, 0x6e, 0x67, 0x08, 0x00, 0x20,
+0x69, 0x74, 0x63, 0x01, 0x00, 0x92, 0x01, 0x5f, 0x77, 0x68,
 0x65, 0x72, 0x65, 0x18, 0x01, 0x0b, 0x60, 0x2e, 0x00, 0x00,
-0x00, 0x42, 0x79, 0x99, 0x00, 0x62, 0x76, 0x65, 0x6e, 0x74,
-0x69, 0x6f, 0x2c, 0x00, 0x50, 0x66, 0x69, 0x72, 0x73, 0x74,
-0x5c, 0x01, 0x01, 0xfa, 0x01, 0x05, 0x7b, 0x01, 0x00, 0x99,
+0x00, 0x42, 0x79, 0x99, 0x00, 0x31, 0x76, 0x65, 0x6e, 0x1e,
+0x00, 0x00, 0x1b, 0x00, 0x52, 0x66, 0x69, 0x72, 0x73, 0x74,
+0x5c, 0x01, 0x00, 0xfa, 0x01, 0x04, 0x7b, 0x01, 0x00, 0x99,
 0x00, 0x60, 0x73, 0x68, 0x6f, 0x77, 0x6e, 0x3b, 0x75, 0x00,
 0x61, 0x00, 0x6f, 0x72, 0x00, 0x6d, 0x6f, 0x61, 0x00, 0x55,
 0x74, 0x65, 0x72, 0x69, 0x6d, 0x27, 0x00, 0x32, 0x6d, 0x61,
@@ -74,19 +74,19 @@ const char help_text[] = {
 0x00, 0x04, 0xe7, 0x02, 0x41, 0x00, 0x77, 0x61, 0x73, 0x6c,
 0x01, 0x72, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x86,
 0x01, 0x10, 0x69, 0x14, 0x00, 0x23, 0x6c, 0x6c, 0x05, 0x01,
-0xf1, 0x03, 0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73,
-0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x2e, 0x00, 0x00,
+0xf0, 0x00, 0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73,
+0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x3f, 0x00, 0x00,
 0x6f, 0x00, 0x90, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
 0x2f, 0x6a, 0x81, 0x00, 0xc5, 0x2e, 0x61, 0x74, 0x2f, 0x52,
 0x61, 0x65, 0x74, 0x73, 0x65, 0x6c, 0x2f, 0x79, 0x00, 0xf6,
 0x02, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74,
 0x6d, 0x00, 0x00, 0x00, 0x33, 0x34, 0x2e, 0x31, 0x5e, 0x03,
 0x01, 0x73, 0x00, 0x30, 0x6f, 0x6c, 0x73, 0x67, 0x03, 0x75,
-0x54, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x94, 0x00, 0x54,
-0x2c, 0x00, 0x79, 0x6f, 0x75, 0xf6, 0x02, 0x07, 0xf2, 0x02,
-0x60, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x8f, 0x00, 0x82,
-0x64, 0x72, 0x61, 0x67, 0x67, 0x69, 0x6e, 0x67, 0xe3, 0x01,
-0x24, 0x6f, 0x6e, 0x36, 0x02, 0x00, 0xbe, 0x00, 0x30, 0x61,
+0x54, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x94, 0x00, 0x55,
+0x2c, 0x00, 0x79, 0x6f, 0x75, 0xf6, 0x02, 0x06, 0xf2, 0x02,
+0x60, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x8f, 0x00, 0x50,
+0x64, 0x72, 0x61, 0x67, 0x67, 0x1b, 0x02, 0x01, 0xe3, 0x01,
+0x25, 0x6f, 0x6e, 0x36, 0x02, 0x60, 0x74, 0x6f, 0x00, 0x61,
 0x6e, 0x6f, 0x27, 0x00, 0x92, 0x2c, 0x00, 0x69, 0x6e, 0x64,
 0x69, 0x63, 0x61, 0x74, 0x42, 0x02, 0x02, 0x59, 0x01, 0x11,
 0x79, 0x98, 0x01, 0x84, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65,
@@ -96,112 +96,112 @@ const char help_text[] = {
 0x74, 0x6f, 0x6e, 0x69, 0x00, 0x17, 0x61, 0x67, 0x00, 0xe0,
 0x69, 0x74, 0x73, 0x00, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73,
 0x73, 0x6f, 0x72, 0x2c, 0xe1, 0x01, 0x05, 0x38, 0x00, 0x4f,
-0x72, 0x69, 0x67, 0x68, 0x39, 0x00, 0x0a, 0x00, 0x91, 0x02,
-0x22, 0x64, 0x65, 0x3b, 0x00, 0x00, 0x4e, 0x01, 0x28, 0x49,
-0x66, 0xf2, 0x00, 0x06, 0xea, 0x00, 0x35, 0x74, 0x77, 0x6f,
-0xff, 0x00, 0x22, 0x69, 0x6e, 0x98, 0x01, 0x30, 0x77, 0x61,
-0x79, 0x6e, 0x02, 0x00, 0xf5, 0x00, 0x03, 0x9e, 0x02, 0x73,
-0x6d, 0x00, 0x68, 0x61, 0x73, 0x00, 0x61, 0x54, 0x02, 0x00,
-0x29, 0x00, 0x32, 0x69, 0x74, 0x2c, 0xb7, 0x02, 0x94, 0x70,
+0x72, 0x69, 0x67, 0x68, 0x39, 0x00, 0x0b, 0x52, 0x70, 0x72,
+0x65, 0x64, 0x65, 0x3b, 0x00, 0x00, 0x4e, 0x01, 0x29, 0x49,
+0x66, 0xf2, 0x00, 0x05, 0xea, 0x00, 0x35, 0x74, 0x77, 0x6f,
+0xff, 0x00, 0x22, 0x69, 0x6e, 0x98, 0x01, 0x00, 0xd9, 0x02,
+0x00, 0x6e, 0x02, 0x01, 0x56, 0x02, 0x01, 0x9e, 0x02, 0x74,
+0x6d, 0x00, 0x68, 0x61, 0x73, 0x00, 0x61, 0x23, 0x03, 0x62,
+0x69, 0x6e, 0x00, 0x69, 0x74, 0x2c, 0xb7, 0x02, 0x95, 0x70,
 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x41, 0x03,
-0x01, 0x70, 0x03, 0x03, 0x6d, 0x02, 0x04, 0xff, 0x00, 0x01,
-0x2f, 0x01, 0x03, 0x68, 0x00, 0x1b, 0x2e, 0x8c, 0x00, 0x01,
-0x83, 0x00, 0x42, 0x6e, 0x6f, 0x6e, 0x2d, 0x3f, 0x00, 0x24,
-0x65, 0x64, 0x90, 0x00, 0x11, 0x2c, 0x4f, 0x01, 0x01, 0x4f,
-0x00, 0x01, 0x7d, 0x03, 0x50, 0x73, 0x73, 0x69, 0x67, 0x6e,
+0x01, 0x70, 0x03, 0x03, 0x6d, 0x02, 0x03, 0xff, 0x00, 0x01,
+0x2f, 0x01, 0x03, 0x68, 0x00, 0x1d, 0x2e, 0x8c, 0x00, 0x72,
+0x77, 0x6f, 0x00, 0x6e, 0x6f, 0x6e, 0x2d, 0x3f, 0x00, 0x24,
+0x65, 0x64, 0x90, 0x00, 0x12, 0x2c, 0x4f, 0x01, 0x01, 0x4f,
+0x00, 0x00, 0x7d, 0x03, 0x50, 0x73, 0x73, 0x69, 0x67, 0x6e,
 0x3f, 0x02, 0x70, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72,
 0xd7, 0x02, 0xf9, 0x01, 0x67, 0x65, 0x62, 0x72, 0x61, 0x69,
 0x63, 0x00, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x3a, 0x00,
-0x32, 0x03, 0x8a, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f,
-0x6e, 0x49, 0x00, 0x02, 0x2c, 0x00, 0x71, 0x6c, 0x65, 0x64,
-0x00, 0x60, 0x61, 0x27, 0xe8, 0x00, 0x51, 0x60, 0x61, 0x2b,
-0x31, 0x27, 0x3a, 0x05, 0x00, 0x29, 0x00, 0x43, 0x6e, 0x00,
-0x60, 0x62, 0x18, 0x00, 0x14, 0x62, 0x18, 0x00, 0x00, 0xad,
-0x04, 0x51, 0x6f, 0x6e, 0x2e, 0x00, 0x43, 0xb3, 0x00, 0x00,
-0xf0, 0x01, 0x00, 0x6c, 0x03, 0x06, 0x2b, 0x05, 0x24, 0x6f,
+0x32, 0x03, 0x8b, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f,
+0x6e, 0x49, 0x00, 0x01, 0x2c, 0x00, 0x71, 0x6c, 0x65, 0x64,
+0x00, 0x60, 0x61, 0x27, 0xe8, 0x00, 0x52, 0x60, 0x61, 0x2b,
+0x31, 0x27, 0x3a, 0x05, 0x73, 0x74, 0x68, 0x65, 0x6e, 0x00,
+0x60, 0x62, 0x18, 0x00, 0x15, 0x62, 0x18, 0x00, 0x82, 0x73,
+0x6f, 0x00, 0x6f, 0x6e, 0x2e, 0x00, 0x43, 0xb3, 0x00, 0x00,
+0xf0, 0x01, 0x01, 0x6c, 0x03, 0x04, 0x3a, 0x01, 0x24, 0x6f,
 0x6e, 0x5b, 0x04, 0x41, 0x65, 0x6e, 0x64, 0x73, 0xc5, 0x05,
-0x30, 0x75, 0x63, 0x68, 0x3a, 0x05, 0x42, 0x68, 0x61, 0x69,
-0x6e, 0x7a, 0x00, 0x52, 0x63, 0x61, 0x75, 0x73, 0x65, 0x4d,
-0x01, 0x00, 0x3f, 0x03, 0x28, 0x74, 0x6f, 0x8c, 0x00, 0x06,
+0x30, 0x75, 0x63, 0x68, 0x3a, 0x05, 0x10, 0x68, 0x76, 0x05,
+0x01, 0x7a, 0x00, 0x52, 0x63, 0x61, 0x75, 0x73, 0x65, 0x4d,
+0x01, 0x00, 0x3f, 0x03, 0x29, 0x74, 0x6f, 0x8c, 0x00, 0x05,
 0xda, 0x01, 0x30, 0x73, 0x61, 0x6d, 0x17, 0x02, 0x31, 0x74,
-0x74, 0x65, 0xb8, 0x01, 0x40, 0x57, 0x68, 0x65, 0x6e, 0x2e,
-0x01, 0x01, 0x2a, 0x02, 0x91, 0x2d, 0x63, 0x6c, 0x69, 0x63,
-0x6b, 0x00, 0x6f, 0x72, 0x00, 0x02, 0x04, 0x0f, 0x00, 0x25,
-0x69, 0x6e, 0xfd, 0x01, 0x13, 0x2c, 0x55, 0x02, 0x33, 0x67,
-0x61, 0x6c, 0x12, 0x00, 0x09, 0xde, 0x05, 0x10, 0x69, 0xf9,
-0x01, 0x03, 0x08, 0x01, 0x03, 0x3c, 0x04, 0x10, 0x2e, 0x1d,
-0x03, 0x07, 0x87, 0x05, 0x08, 0x75, 0x06, 0x02, 0xdd, 0x05,
-0x00, 0xcf, 0x00, 0x71, 0x66, 0x00, 0x62, 0x6c, 0x61, 0x63,
-0x6b, 0x0c, 0x01, 0x02, 0x16, 0x04, 0x9a, 0x67, 0x72, 0x65,
-0x79, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0xcb, 0x01, 0x2e, 0x68,
-0x65, 0xc0, 0x02, 0x04, 0x85, 0x02, 0x58, 0x41, 0x6c, 0x73,
-0x6f, 0x2c, 0x60, 0x00, 0x03, 0xa0, 0x05, 0x78, 0x6e, 0x65,
-0x65, 0x64, 0x73, 0x00, 0x61, 0xb2, 0x02, 0x03, 0x6f, 0x02,
+0x74, 0x65, 0xb8, 0x01, 0x10, 0x57, 0x91, 0x00, 0x00, 0x2e,
+0x01, 0x00, 0x2a, 0x02, 0x60, 0x2d, 0x63, 0x6c, 0x69, 0x63,
+0x6b, 0x09, 0x02, 0x01, 0x00, 0x02, 0x03, 0x0f, 0x00, 0x25,
+0x69, 0x6e, 0xfd, 0x01, 0x13, 0x2c, 0x55, 0x02, 0x38, 0x67,
+0x61, 0x6c, 0xc7, 0x05, 0x04, 0x6a, 0x01, 0x11, 0x69, 0x02,
+0x05, 0x04, 0x08, 0x01, 0x01, 0x3c, 0x04, 0x10, 0x2e, 0x1d,
+0x03, 0x07, 0x87, 0x05, 0x09, 0x75, 0x06, 0x01, 0xdd, 0x05,
+0x00, 0xcf, 0x00, 0x72, 0x66, 0x00, 0x62, 0x6c, 0x61, 0x63,
+0x6b, 0x0c, 0x01, 0x01, 0x16, 0x04, 0x60, 0x67, 0x72, 0x65,
+0x79, 0x00, 0x6f, 0x08, 0x05, 0x09, 0xcb, 0x01, 0x2e, 0x68,
+0x65, 0xc0, 0x02, 0x04, 0x85, 0x02, 0x59, 0x41, 0x6c, 0x73,
+0x6f, 0x2c, 0x60, 0x00, 0x02, 0xa0, 0x05, 0x40, 0x6e, 0x65,
+0x65, 0x64, 0x5d, 0x02, 0x07, 0xb2, 0x02, 0x03, 0x6f, 0x02,
 0x20, 0x73, 0x6d, 0x2a, 0x01, 0x25, 0x64, 0x6f, 0x47, 0x03,
 0x62, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x36, 0x03, 0x64,
-0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0xe5, 0x05, 0x85, 0x76,
-0x61, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, 0x94, 0x00, 0x01,
+0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0xe5, 0x05, 0x86, 0x76,
+0x61, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, 0x94, 0x00, 0x00,
 0x88, 0x06, 0x0b, 0x16, 0x03, 0x60, 0x2e, 0x00, 0x53, 0x6f,
 0x00, 0x79, 0xfa, 0x06, 0x50, 0x61, 0x69, 0x6d, 0x00, 0x69,
 0x1c, 0x07, 0x39, 0x77, 0x61, 0x79, 0x23, 0x01, 0x19, 0x61,
-0x80, 0x06, 0x12, 0x61, 0xf8, 0x00, 0x03, 0x1e, 0x01, 0x2c,
-0x74, 0x6f, 0x1f, 0x00, 0x00, 0x9c, 0x00, 0x12, 0x2e, 0x5f,
-0x04, 0x51, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x23, 0x06, 0x01,
-0x7a, 0x00, 0x10, 0x73, 0x4d, 0x05, 0x00, 0xd5, 0x00, 0x00,
+0x80, 0x06, 0x12, 0x61, 0xf8, 0x00, 0x03, 0x1e, 0x01, 0x2d,
+0x74, 0x6f, 0x1f, 0x00, 0x42, 0x64, 0x6f, 0x74, 0x2e, 0x5f,
+0x04, 0x52, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x23, 0x06, 0x00,
+0x7a, 0x00, 0x11, 0x73, 0x4d, 0x05, 0x30, 0x61, 0x00, 0x70,
 0x1f, 0x07, 0x55, 0x63, 0x75, 0x6c, 0x61, 0x72, 0xca, 0x07,
-0xd2, 0x62, 0x6f, 0x74, 0x68, 0x00, 0x69, 0x6e, 0x63, 0x6f,
-0x6d, 0x69, 0x6e, 0x67, 0x69, 0x03, 0x92, 0x75, 0x74, 0x67,
+0xa1, 0x62, 0x6f, 0x74, 0x68, 0x00, 0x69, 0x6e, 0x63, 0x6f,
+0x6d, 0x38, 0x07, 0x00, 0x69, 0x03, 0x92, 0x75, 0x74, 0x67,
 0x6f, 0x69, 0x6e, 0x67, 0x29, 0x2c, 0xe7, 0x01, 0x10, 0x64,
-0x24, 0x04, 0x10, 0x69, 0x68, 0x07, 0x01, 0x7e, 0x03, 0x01,
+0x24, 0x04, 0x10, 0x69, 0x68, 0x07, 0x02, 0x1c, 0x06, 0x00,
 0x1a, 0x08, 0x18, 0x2e, 0x65, 0x00, 0x00, 0x86, 0x05, 0x22,
-0x6c, 0x65, 0x5e, 0x02, 0x11, 0x2c, 0x0d, 0x02, 0x02, 0x35,
-0x00, 0x00, 0x7f, 0x00, 0x01, 0x68, 0x00, 0x04, 0x69, 0x06,
-0x03, 0x24, 0x00, 0x0a, 0x4a, 0x00, 0x02, 0x77, 0x08, 0x00,
-0xd5, 0x06, 0x02, 0x19, 0x06, 0x03, 0x98, 0x02, 0x40, 0x00,
+0x6c, 0x65, 0x5e, 0x02, 0x13, 0x2c, 0x0d, 0x02, 0x01, 0x35,
+0x00, 0x00, 0x7f, 0x00, 0x03, 0x68, 0x00, 0x03, 0x33, 0x01,
+0x02, 0x82, 0x02, 0x0a, 0x4a, 0x00, 0x02, 0x77, 0x08, 0x00,
+0xd5, 0x06, 0x01, 0x19, 0x06, 0x03, 0x98, 0x02, 0x40, 0x00,
 0x63, 0x75, 0x72, 0x7c, 0x01, 0x22, 0x6b, 0x65, 0x13, 0x01,
-0x02, 0x6b, 0x00, 0x54, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3c,
-0x00, 0x05, 0x9c, 0x03, 0x04, 0xea, 0x07, 0x94, 0x65, 0x73,
+0x02, 0x6b, 0x00, 0x55, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3c,
+0x00, 0x06, 0x56, 0x08, 0x02, 0xea, 0x07, 0x94, 0x65, 0x73,
 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x45, 0x07, 0x80,
 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x6b, 0x70, 0x03,
-0x00, 0xbb, 0x02, 0x6b, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x61,
+0x00, 0xbb, 0x02, 0x30, 0x6f, 0x76, 0x65, 0x07, 0x01, 0x0a,
 0x51, 0x02, 0x12, 0x61, 0x9d, 0x01, 0x50, 0x6f, 0x70, 0x65,
 0x72, 0x61, 0xff, 0x05, 0x02, 0x58, 0x02, 0x1f, 0x70, 0x48,
-0x00, 0x04, 0x4b, 0x61, 0x67, 0x61, 0x69, 0x49, 0x00, 0x02,
-0xc4, 0x02, 0x51, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x36, 0x03,
-0x01, 0x50, 0x00, 0x40, 0x2c, 0x00, 0x69, 0x66, 0x5b, 0x03,
+0x00, 0x04, 0x4c, 0x61, 0x67, 0x61, 0x69, 0x49, 0x00, 0x01,
+0xc4, 0x02, 0x20, 0x66, 0x69, 0xf4, 0x01, 0x02, 0xf3, 0x02,
+0x70, 0x69, 0x6e, 0x6b, 0x2c, 0x00, 0x69, 0x66, 0x5b, 0x03,
 0x6b, 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x98, 0x00, 0x9f,
 0x73, 0x70, 0x61, 0x63, 0x65, 0x00, 0x62, 0x61, 0x72, 0x49,
-0x00, 0x00, 0x01, 0x0a, 0x03, 0x0d, 0xa8, 0x04, 0x11, 0x73,
-0x34, 0x08, 0x00, 0xec, 0x03, 0x02, 0x3d, 0x02, 0x01, 0xa5,
-0x00, 0x02, 0x60, 0x00, 0x00, 0x44, 0x02, 0x07, 0x1f, 0x09,
+0x00, 0x01, 0x00, 0x0a, 0x03, 0x0d, 0xa8, 0x04, 0x12, 0x73,
+0x34, 0x08, 0x01, 0x41, 0x00, 0x00, 0x3d, 0x02, 0x02, 0xa5,
+0x00, 0x01, 0x60, 0x00, 0x01, 0x60, 0x02, 0x06, 0x1f, 0x09,
 0x72, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0xfb, 0x08,
-0x06, 0xcc, 0x00, 0x0e, 0x7c, 0x00, 0x03, 0xcb, 0x00, 0x10,
+0x0e, 0xcc, 0x00, 0x07, 0x7c, 0x00, 0x02, 0xcb, 0x00, 0x10,
 0x63, 0x40, 0x08, 0x21, 0x6c, 0x73, 0x6d, 0x05, 0x00, 0x8d,
 0x01, 0x42, 0x28, 0x41, 0x6c, 0x6c, 0x4d, 0x05, 0x01, 0x0d,
 0x07, 0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
-0x62, 0x46, 0x09, 0x13, 0x73, 0x23, 0x07, 0x30, 0x32, 0x2e,
-0x31, 0x5b, 0x06, 0x03, 0xcc, 0x07, 0x41, 0x76, 0x61, 0x69,
+0x62, 0x46, 0x09, 0x13, 0x73, 0x23, 0x07, 0x32, 0x32, 0x2e,
+0x31, 0x5b, 0x06, 0x01, 0xcc, 0x07, 0x41, 0x76, 0x61, 0x69,
 0x6c, 0xe7, 0x00, 0x12, 0x29, 0xf8, 0x06, 0x16, 0x32, 0xf8,
 0x06, 0xb2, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
-0x72, 0x73, 0x20, 0xdd, 0x03, 0x33, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x03, 0x37, 0x08, 0x06, 0x3f, 0x00, 0x06, 0xc1, 0x08,
+0x72, 0x73, 0x20, 0xdd, 0x03, 0x36, 0x73, 0x65, 0x00, 0x14,
+0x00, 0x02, 0x44, 0x00, 0x04, 0x3f, 0x00, 0x06, 0xc1, 0x08,
 0xe2, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x9a, 0x08, 0x12, 0x6e, 0x1a,
 0x00, 0xa1, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65,
-0x6e, 0x75, 0x92, 0x04, 0x80, 0x69, 0x64, 0x74, 0x68, 0x2c,
-0x00, 0x48, 0x65, 0x76, 0x02, 0x01, 0xe7, 0x07, 0x10, 0x7a,
-0x27, 0x06, 0x02, 0x1f, 0x02, 0x23, 0x69, 0x6e, 0x3e, 0x01,
-0x01, 0xd9, 0x00, 0x61, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20,
+0x6e, 0x75, 0x92, 0x04, 0x81, 0x69, 0x64, 0x74, 0x68, 0x2c,
+0x00, 0x48, 0x65, 0x83, 0x06, 0x00, 0xe7, 0x07, 0x11, 0x7a,
+0x27, 0x06, 0x01, 0x1f, 0x02, 0x24, 0x69, 0x6e, 0x3e, 0x01,
+0x00, 0x2b, 0x00, 0x61, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20,
 0xf5, 0x01, 0x82, 0x2f, 0x65, 0x6e, 0x64, 0x20, 0x74, 0x6f,
-0x20, 0xb6, 0x03, 0x12, 0x73, 0x92, 0x06, 0x31, 0x74, 0x72,
-0x75, 0xb3, 0x04, 0x02, 0x19, 0x02, 0x02, 0xe3, 0x08, 0x27,
-0x65, 0x6e, 0x65, 0x02, 0x23, 0x72, 0x65, 0xa3, 0x03, 0x00,
-0xbe, 0x07, 0x12, 0x63, 0x10, 0x01, 0x94, 0x6f, 0x70, 0x70,
-0x6f, 0x73, 0x69, 0x74, 0x65, 0x00, 0x4b, 0x00, 0x15, 0x28,
-0x41, 0x00, 0x04, 0xdc, 0x08, 0x31, 0x74, 0x6f, 0x70, 0x49,
-0x03, 0x05, 0xd4, 0x05, 0x01, 0x56, 0x00, 0x27, 0x61, 0x74,
-0x44, 0x04, 0x02, 0x35, 0x03, 0x11, 0x29, 0x8d, 0x06, 0x5f,
-0x66, 0x61, 0x6c, 0x73, 0x65, 0x87, 0x00, 0x0b, 0x04, 0x80,
+0x20, 0xb6, 0x03, 0x12, 0x73, 0x92, 0x06, 0x33, 0x74, 0x72,
+0x75, 0xb3, 0x04, 0x01, 0x24, 0x00, 0x01, 0x3a, 0x01, 0x27,
+0x65, 0x6e, 0x65, 0x02, 0x24, 0x72, 0x65, 0xa3, 0x03, 0x42,
+0x70, 0x6c, 0x61, 0x63, 0x10, 0x01, 0x94, 0x6f, 0x70, 0x70,
+0x6f, 0x73, 0x69, 0x74, 0x65, 0x00, 0x4b, 0x00, 0x17, 0x28,
+0x41, 0x00, 0x02, 0x83, 0x04, 0x31, 0x74, 0x6f, 0x70, 0x49,
+0x03, 0x05, 0xd4, 0x05, 0x01, 0x56, 0x00, 0x28, 0x61, 0x74,
+0x44, 0x04, 0x01, 0x35, 0x03, 0x11, 0x29, 0x8d, 0x06, 0x5f,
+0x66, 0x61, 0x6c, 0x73, 0x65, 0x87, 0x00, 0x0c, 0x03, 0x80,
 0x00, 0xf4, 0x03, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x6c,
 0x79, 0x00, 0x28, 0x61, 0x6c, 0x74, 0x68, 0x6f, 0x75, 0x67,
 0x68, 0xa1, 0x00, 0x01, 0xd6, 0x03, 0x80, 0x73, 0x68, 0x6f,
diff --git a/apps/plugins/puzzles/help/singles.c b/apps/plugins/puzzles/help/singles.c
index 66978cd67d..dffc14b35b 100644
--- a/apps/plugins/puzzles/help/singles.c
+++ b/apps/plugins/puzzles/help/singles.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1392 comp 1054 ratio 0.757184 level 11 saved 338 */
+/* orig 1392 comp 1052 ratio 0.755747 level 10 saved 340 */
 const char help_text[] = {
 0xf3, 0x2d, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x32, 0x3a, 0x20, 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65,
@@ -27,27 +27,27 @@ const char help_text[] = {
 0x62, 0x65, 0x72, 0x73, 0x2e, 0x40, 0x00, 0xf0, 0x01, 0x72,
 0x00, 0x74, 0x61, 0x73, 0x6b, 0x00, 0x69, 0x73, 0x00, 0x74,
 0x6f, 0x00, 0x63, 0x6f, 0x6c, 0x12, 0x00, 0x40, 0x73, 0x6f,
-0x6d, 0x65, 0x36, 0x00, 0x25, 0x74, 0x68, 0x4a, 0x00, 0xf0,
+0x6d, 0x65, 0x36, 0x00, 0x25, 0x74, 0x68, 0x4a, 0x00, 0xf1,
 0x01, 0x00, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x00, 0x28, 0x72,
-0x65, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x1c, 0x00, 0x03,
+0x65, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x1c, 0x00, 0x02,
 0x48, 0x00, 0x61, 0x29, 0x00, 0x73, 0x6f, 0x00, 0x61, 0x40,
-0x00, 0x70, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x76,
-0x00, 0x04, 0x40, 0x00, 0x90, 0x66, 0x6f, 0x6c, 0x6c, 0x6f,
-0x77, 0x69, 0x6e, 0x67, 0x7e, 0x00, 0xf3, 0x00, 0x64, 0x69,
+0x00, 0x74, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x79, 0x76,
+0x00, 0x00, 0x24, 0x00, 0x60, 0x66, 0x6f, 0x6c, 0x6c, 0x6f,
+0x77, 0x32, 0x00, 0xf3, 0x03, 0x63, 0x6f, 0x6e, 0x64, 0x69,
 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x00, 0x00, 0x00, 0x2d,
 0x00, 0x4e, 0x6f, 0x41, 0x00, 0xf0, 0x15, 0x00, 0x6f, 0x63,
 0x63, 0x75, 0x72, 0x73, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x00,
 0x74, 0x68, 0x61, 0x6e, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x00,
 0x69, 0x6e, 0x00, 0x61, 0x6e, 0x79, 0x00, 0x72, 0x6f, 0x77,
-0x00, 0x6f, 0x72, 0x9b, 0x00, 0x43, 0x75, 0x6d, 0x6e, 0x2e,
-0x3a, 0x00, 0x02, 0x8f, 0x00, 0x03, 0x9d, 0x00, 0x00, 0xbd,
+0x00, 0x6f, 0x72, 0x9b, 0x00, 0x44, 0x75, 0x6d, 0x6e, 0x2e,
+0x3a, 0x00, 0x02, 0x8f, 0x00, 0x02, 0x9d, 0x00, 0x00, 0xbd,
 0x00, 0x50, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0xdf, 0x00, 0x30,
 0x6c, 0x6c, 0x79, 0x2f, 0x00, 0x61, 0x76, 0x65, 0x72, 0x74,
-0x69, 0x63, 0x0e, 0x00, 0xb1, 0x61, 0x64, 0x6a, 0x61, 0x63,
-0x65, 0x6e, 0x74, 0x00, 0x74, 0x6f, 0x51, 0x00, 0x59, 0x6f,
-0x74, 0x68, 0x65, 0x72, 0x41, 0x00, 0x02, 0x56, 0x00, 0xda,
+0x69, 0x63, 0x0e, 0x00, 0x80, 0x61, 0x64, 0x6a, 0x61, 0x63,
+0x65, 0x6e, 0x74, 0xa1, 0x00, 0x00, 0x51, 0x00, 0x59, 0x6f,
+0x74, 0x68, 0x65, 0x72, 0x41, 0x00, 0x02, 0x56, 0x00, 0xa0,
 0x54, 0x68, 0x65, 0x00, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e,
-0x69, 0x6e, 0x67, 0x48, 0x01, 0x51, 0x00, 0x6d, 0x75, 0x73,
+0xae, 0x00, 0x09, 0x48, 0x01, 0x51, 0x00, 0x6d, 0x75, 0x73,
 0x74, 0xd6, 0x00, 0x81, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x6f,
 0x6e, 0x65, 0x4c, 0x01, 0xf0, 0x10, 0x69, 0x67, 0x75, 0x6f,
 0x75, 0x73, 0x00, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x00,
@@ -63,8 +63,8 @@ const char help_text[] = {
 0x5d, 0x00, 0x77, 0x68, 0x6f, 0x00, 0x63, 0x85, 0x00, 0x90,
 0x69, 0x74, 0x00, 0x48, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x41,
 0x00, 0x03, 0x0f, 0x02, 0x41, 0x00, 0x77, 0x61, 0x73, 0x95,
-0x00, 0x40, 0x72, 0x69, 0x62, 0x75, 0x84, 0x00, 0x21, 0x74,
-0x6f, 0x51, 0x00, 0x00, 0x39, 0x01, 0x30, 0x6c, 0x65, 0x63,
+0x00, 0x40, 0x72, 0x69, 0x62, 0x75, 0x84, 0x00, 0x22, 0x74,
+0x6f, 0x51, 0x00, 0x60, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
 0x78, 0x01, 0x00, 0x97, 0x00, 0xc0, 0x4a, 0x61, 0x6d, 0x65,
 0x73, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x3e, 0x00,
 0x01, 0x59, 0x00, 0xc1, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
@@ -78,50 +78,50 @@ const char help_text[] = {
 0x6c, 0x69, 0x63, 0x6b, 0xfb, 0x00, 0x10, 0x6f, 0xd2, 0x01,
 0x64, 0x00, 0x65, 0x6d, 0x70, 0x74, 0x79, 0xbb, 0x01, 0x44,
 0x77, 0x69, 0x6c, 0x6c, 0x77, 0x02, 0x22, 0x69, 0x74, 0x96,
-0x01, 0x39, 0x3b, 0x00, 0x6c, 0x37, 0x00, 0x52, 0x61, 0x67,
-0x61, 0x69, 0x6e, 0x2a, 0x00, 0x77, 0x72, 0x65, 0x73, 0x74,
-0x6f, 0x72, 0x65, 0x7e, 0x02, 0x66, 0x2e, 0x00, 0x52, 0x69,
-0x67, 0x68, 0x2e, 0x00, 0x02, 0x28, 0x00, 0xf1, 0x05, 0x61,
+0x01, 0x39, 0x3b, 0x00, 0x6c, 0x37, 0x00, 0x20, 0x61, 0x67,
+0xb5, 0x02, 0x01, 0x2a, 0x00, 0x42, 0x72, 0x65, 0x73, 0x74,
+0x26, 0x02, 0x04, 0x7e, 0x02, 0x67, 0x2e, 0x00, 0x52, 0x69,
+0x67, 0x68, 0x2e, 0x00, 0x01, 0x28, 0x00, 0xf1, 0x05, 0x61,
 0x64, 0x64, 0x00, 0x61, 0x00, 0x63, 0x69, 0x72, 0x63, 0x6c,
 0x65, 0x00, 0x28, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x64,
 0x01, 0x72, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0xc2,
 0x02, 0x20, 0x61, 0x74, 0x25, 0x00, 0x30, 0x65, 0x6c, 0x6c,
-0x42, 0x02, 0xd3, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74,
-0x65, 0x6c, 0x79, 0x00, 0x6e, 0x6f, 0x8a, 0x00, 0x23, 0x29,
+0x42, 0x02, 0xa1, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74,
+0x65, 0x6c, 0x79, 0xb5, 0x01, 0x01, 0x8a, 0x00, 0x23, 0x29,
 0x2e, 0x65, 0x03, 0xb2, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c,
 0x73, 0x6f, 0x00, 0x75, 0x73, 0x7d, 0x00, 0x00, 0xb1, 0x02,
 0x61, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0xa7, 0x01, 0x20,
-0x6d, 0x6f, 0x85, 0x03, 0x50, 0x72, 0x6f, 0x75, 0x6e, 0x64,
-0x1f, 0x00, 0x01, 0x8e, 0x03, 0x74, 0x2e, 0x00, 0x50, 0x72,
+0x6d, 0x6f, 0x85, 0x03, 0x51, 0x72, 0x6f, 0x75, 0x6e, 0x64,
+0x1f, 0x00, 0x00, 0x8e, 0x03, 0x74, 0x2e, 0x00, 0x50, 0x72,
 0x65, 0x73, 0x73, 0x2d, 0x03, 0x60, 0x72, 0x65, 0x74, 0x75,
-0x72, 0x6e, 0x9c, 0x02, 0x51, 0x73, 0x70, 0x61, 0x63, 0x65,
-0x3b, 0x00, 0x02, 0xad, 0x00, 0x01, 0x18, 0x00, 0x13, 0x61,
-0x12, 0x01, 0x03, 0x99, 0x02, 0x29, 0x6f, 0x72, 0xc4, 0x00,
-0x00, 0xf9, 0x00, 0x10, 0x70, 0xc6, 0x01, 0xb6, 0x76, 0x65,
+0x72, 0x6e, 0x9c, 0x02, 0x52, 0x73, 0x70, 0x61, 0x63, 0x65,
+0x3b, 0x00, 0x01, 0xad, 0x00, 0x01, 0x18, 0x00, 0x14, 0x61,
+0x12, 0x01, 0x02, 0x99, 0x02, 0x2a, 0x6f, 0x72, 0xc4, 0x00,
+0x40, 0x72, 0x65, 0x73, 0x70, 0xc6, 0x01, 0xb8, 0x76, 0x65,
 0x6c, 0x79, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x00, 0x70, 0x5d,
-0x00, 0x01, 0x4d, 0x00, 0x0f, 0x27, 0x01, 0x0b, 0x00, 0x51,
-0x00, 0x01, 0xbc, 0x03, 0x01, 0x15, 0x00, 0x02, 0x56, 0x00,
-0x01, 0xf8, 0x02, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x13, 0x00,
+0x00, 0x3f, 0x6b, 0x65, 0x79, 0x27, 0x01, 0x0b, 0x00, 0x51,
+0x00, 0x01, 0xbc, 0x03, 0x03, 0xbf, 0x00, 0x01, 0x56, 0x00,
+0x00, 0xde, 0x00, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x13, 0x00,
 0x11, 0x61, 0x24, 0x02, 0x00, 0x08, 0x01, 0x70, 0x73, 0x63,
 0x72, 0x69, 0x62, 0x65, 0x64, 0x81, 0x03, 0x13, 0x73, 0x3a,
-0x02, 0x72, 0x32, 0x2e, 0x31, 0x00, 0x61, 0x72, 0x65, 0x04,
+0x02, 0x40, 0x32, 0x2e, 0x31, 0x00, 0x9d, 0x00, 0x01, 0x04,
 0x01, 0xa3, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c,
-0x65, 0x2e, 0xfc, 0x01, 0x15, 0x32, 0xfc, 0x01, 0x90, 0x70,
+0x65, 0x2e, 0xfc, 0x01, 0x15, 0x32, 0xfc, 0x01, 0x91, 0x70,
 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0xfe, 0x01,
-0x00, 0x52, 0x03, 0x36, 0x73, 0x65, 0x00, 0x14, 0x00, 0x00,
-0x43, 0x00, 0x06, 0x3e, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f,
+0x66, 0x54, 0x68, 0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02,
+0x43, 0x00, 0x04, 0x3e, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f,
 0x6d, 0x7b, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f,
 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x71, 0x00,
 0x22, 0x6f, 0x6e, 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65,
 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xad, 0x00, 0x90, 0x57,
 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0xf3, 0x01,
-0x01, 0xfc, 0x02, 0x10, 0x7a, 0x89, 0x02, 0x02, 0xfd, 0x04,
+0x01, 0xfc, 0x02, 0x11, 0x7a, 0x89, 0x02, 0x01, 0xfd, 0x04,
 0x24, 0x69, 0x6e, 0xaf, 0x03, 0x00, 0x2b, 0x00, 0xa0, 0x44,
 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x65,
-0x03, 0x03, 0x93, 0x02, 0x01, 0x54, 0x00, 0x15, 0x64, 0x1a,
-0x00, 0x04, 0xa4, 0x04, 0xf0, 0x03, 0x67, 0x65, 0x6e, 0x65,
-0x72, 0x61, 0x74, 0x65, 0x64, 0x00, 0x70, 0x75, 0x7a, 0x7a,
-0x6c, 0x65, 0x2e, 0x00,
+0x03, 0x03, 0x93, 0x02, 0x01, 0x54, 0x00, 0x16, 0x64, 0x1a,
+0x00, 0x03, 0xa4, 0x04, 0x60, 0x67, 0x65, 0x6e, 0x65, 0x72,
+0x61, 0x35, 0x03, 0x80, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65,
+0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 1392;
diff --git a/apps/plugins/puzzles/help/sixteen.c b/apps/plugins/puzzles/help/sixteen.c
index 8e3dfdba2a..eb8feed049 100644
--- a/apps/plugins/puzzles/help/sixteen.c
+++ b/apps/plugins/puzzles/help/sixteen.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2534 comp 1754 ratio 0.692186 level 11 saved 780 */
+/* orig 2534 comp 1755 ratio 0.692581 level 6 saved 779 */
 const char help_text[] = {
 0xf0, 0x3b, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x36, 0x3a, 0x20, 0x53, 0x69, 0x78, 0x74, 0x65, 0x65, 0x6e,
@@ -36,22 +36,22 @@ const char help_text[] = {
 0x65, 0x73, 0x00, 0x6f, 0x6e, 0x24, 0x00, 0xf4, 0x07, 0x00,
 0x67, 0x72, 0x69, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61,
 0x69, 0x6e, 0x00, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65,
-0x64, 0x25, 0x00, 0x60, 0x2e, 0x00, 0x59, 0x6f, 0x75, 0x72,
-0x5d, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x9d, 0x00, 0xfd, 0x16,
+0x64, 0x25, 0x00, 0x61, 0x2e, 0x00, 0x59, 0x6f, 0x75, 0x72,
+0x5d, 0x00, 0x00, 0x4b, 0x00, 0xf0, 0x16, 0x74, 0x6f, 0x00,
 0x73, 0x68, 0x69, 0x66, 0x74, 0x00, 0x61, 0x6e, 0x00, 0x65,
 0x6e, 0x74, 0x69, 0x72, 0x65, 0x00, 0x72, 0x6f, 0x77, 0x00,
 0x6c, 0x65, 0x66, 0x74, 0x00, 0x6f, 0x72, 0x00, 0x72, 0x69,
-0x67, 0x68, 0x74, 0x2c, 0x00, 0x6f, 0x72, 0x26, 0x00, 0x90,
+0x67, 0x68, 0x74, 0x2c, 0x0a, 0x00, 0x0c, 0x26, 0x00, 0x90,
 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x00, 0x75, 0x70, 0x1d,
 0x00, 0xb1, 0x64, 0x6f, 0x77, 0x6e, 0x3b, 0x00, 0x65, 0x76,
 0x65, 0x72, 0x79, 0xac, 0x00, 0xc1, 0x00, 0x79, 0x6f, 0x75,
 0x00, 0x64, 0x6f, 0x00, 0x74, 0x68, 0x61, 0x74, 0xb8, 0x00,
-0x00, 0x23, 0x01, 0x01, 0x16, 0x00, 0x03, 0x48, 0x00, 0x36,
+0x02, 0x23, 0x01, 0x00, 0x16, 0x00, 0x02, 0x48, 0x00, 0x36,
 0x6f, 0x66, 0x66, 0xab, 0x00, 0xd1, 0x72, 0x65, 0x2d, 0x61,
 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x00, 0x61, 0x74, 0x17,
 0x00, 0x02, 0x5f, 0x01, 0x52, 0x65, 0x6e, 0x64, 0x00, 0x6f,
-0x28, 0x00, 0x31, 0x73, 0x61, 0x6d, 0x99, 0x00, 0x42, 0x2c,
-0x00, 0x69, 0x6e, 0x11, 0x00, 0x32, 0x70, 0x61, 0x63, 0x51,
+0x28, 0x00, 0x31, 0x73, 0x61, 0x6d, 0x99, 0x00, 0x32, 0x2c,
+0x00, 0x69, 0xe4, 0x00, 0x42, 0x73, 0x70, 0x61, 0x63, 0x51,
 0x00, 0xf5, 0x0e, 0x6a, 0x75, 0x73, 0x74, 0x00, 0x76, 0x61,
 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x00, 0x54, 0x6f, 0x00,
 0x77, 0x69, 0x6e, 0x2c, 0x00, 0x61, 0x72, 0x72, 0x61, 0x6e,
@@ -83,115 +83,115 @@ const char help_text[] = {
 0x65, 0x65, 0x6e, 0x73, 0x61, 0x76, 0x65, 0x72, 0x00, 0x49,
 0x27, 0x64, 0x00, 0x73, 0x65, 0x65, 0x6e, 0x2c, 0xab, 0x02,
 0x12, 0x49, 0x59, 0x00, 0x61, 0x61, 0x00, 0x66, 0x65, 0x65,
-0x6c, 0xf9, 0x02, 0x12, 0x68, 0xb1, 0x01, 0x08, 0x34, 0x00,
-0x03, 0xdc, 0x00, 0x31, 0x61, 0x63, 0x74, 0x07, 0x03, 0x02,
+0x6c, 0xf9, 0x02, 0x13, 0x68, 0xb1, 0x01, 0x08, 0x34, 0x00,
+0x02, 0xdc, 0x00, 0x32, 0x61, 0x63, 0x74, 0x07, 0x03, 0x01,
 0x33, 0x00, 0x10, 0x62, 0xfe, 0x02, 0x14, 0x61, 0x08, 0x03,
-0x44, 0x2d, 0x74, 0x79, 0x70, 0x31, 0x03, 0x30, 0x00, 0x72,
-0x61, 0xba, 0x00, 0x00, 0x4b, 0x00, 0x12, 0x6e, 0x03, 0x01,
+0x11, 0x2d, 0xe3, 0x02, 0x02, 0x31, 0x03, 0x31, 0x00, 0x72,
+0x61, 0xba, 0x00, 0x42, 0x74, 0x68, 0x61, 0x6e, 0x03, 0x01,
 0x20, 0x73, 0x6c, 0x41, 0x00, 0x27, 0x6c, 0x79, 0x42, 0x01,
-0x81, 0x6b, 0x69, 0x6e, 0x64, 0x2e, 0x00, 0x53, 0x6f, 0x21,
-0x00, 0x03, 0x61, 0x00, 0x12, 0x62, 0xdd, 0x01, 0x02, 0x80,
-0x01, 0x30, 0x69, 0x6e, 0x67, 0x1a, 0x02, 0x22, 0x6d, 0x79,
-0x56, 0x00, 0x01, 0x9f, 0x02, 0xf2, 0x16, 0x6c, 0x65, 0x63,
+0x82, 0x6b, 0x69, 0x6e, 0x64, 0x2e, 0x00, 0x53, 0x6f, 0x21,
+0x00, 0x02, 0x61, 0x00, 0x12, 0x62, 0xdd, 0x01, 0x02, 0x80,
+0x01, 0x00, 0x8d, 0x00, 0x54, 0x69, 0x6e, 0x00, 0x6d, 0x79,
+0x56, 0x00, 0xf2, 0x19, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x77, 0x68, 0x69, 0x63, 0x68,
 0x00, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74,
 0x73, 0x00, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x76, 0x69,
-0x74, 0x79, 0x00, 0x6f, 0x34, 0x00, 0x38, 0x61, 0x72, 0x74,
-0x88, 0x00, 0x02, 0x54, 0x02, 0xb0, 0x65, 0x6e, 0x67, 0x69,
+0x74, 0x79, 0x00, 0x6f, 0x34, 0x00, 0x39, 0x61, 0x72, 0x74,
+0x88, 0x00, 0x01, 0x54, 0x02, 0xb0, 0x65, 0x6e, 0x67, 0x69,
 0x6e, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0xb5, 0x01, 0x35,
 0x36, 0x2e, 0x31, 0x04, 0x04, 0x00, 0x5d, 0x03, 0x40, 0x72,
-0x6f, 0x6c, 0x73, 0x0d, 0x04, 0xa2, 0x4c, 0x65, 0x66, 0x74,
-0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xf9, 0x01, 0x00, 0x24,
-0x03, 0x20, 0x61, 0x72, 0x45, 0x03, 0x40, 0x77, 0x69, 0x6c,
-0x6c, 0x69, 0x03, 0x02, 0xa9, 0x00, 0xa2, 0x61, 0x70, 0x70,
-0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x63, 0x03, 0x23,
-0x6f, 0x72, 0x44, 0x03, 0x04, 0xd3, 0x02, 0x32, 0x64, 0x69,
-0x72, 0xb2, 0x00, 0x00, 0xba, 0x01, 0x13, 0x69, 0xd0, 0x02,
-0x46, 0x52, 0x69, 0x67, 0x68, 0x5f, 0x00, 0x07, 0x53, 0x00,
+0x6f, 0x6c, 0x73, 0x0d, 0x04, 0xa3, 0x4c, 0x65, 0x66, 0x74,
+0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xf9, 0x01, 0x20, 0x61,
+0x6e, 0x7e, 0x02, 0x72, 0x6f, 0x77, 0x00, 0x77, 0x69, 0x6c,
+0x6c, 0x69, 0x03, 0x00, 0xa9, 0x00, 0xa2, 0x61, 0x70, 0x70,
+0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x63, 0x03, 0x24,
+0x6f, 0x72, 0x44, 0x03, 0x03, 0xd3, 0x02, 0x33, 0x64, 0x69,
+0x72, 0xb2, 0x00, 0x43, 0x69, 0x6e, 0x64, 0x69, 0xd0, 0x02,
+0x10, 0x52, 0xec, 0x00, 0x06, 0x5f, 0x00, 0x06, 0x53, 0x00,
 0x24, 0x69, 0x74, 0x38, 0x00, 0x77, 0x6f, 0x70, 0x70, 0x6f,
-0x73, 0x69, 0x74, 0x41, 0x00, 0x10, 0x2e, 0xa4, 0x04, 0x50,
+0x73, 0x69, 0x74, 0x41, 0x00, 0x00, 0xaf, 0x00, 0x60, 0x41,
 0x6c, 0x74, 0x65, 0x72, 0x6e, 0xe8, 0x00, 0x72, 0x65, 0x6c,
-0x79, 0x2c, 0x00, 0x75, 0x73, 0x86, 0x00, 0xa0, 0x63, 0x75,
+0x79, 0x2c, 0x00, 0x75, 0x73, 0x86, 0x00, 0xa1, 0x63, 0x75,
 0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0xfc, 0x03,
-0x06, 0x9e, 0x00, 0x00, 0x43, 0x00, 0x08, 0x7c, 0x00, 0x91,
+0x05, 0x9e, 0x00, 0x01, 0x43, 0x00, 0x07, 0x7c, 0x00, 0x91,
 0x6f, 0x72, 0x00, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x1e,
-0x00, 0x66, 0x65, 0x64, 0x67, 0x65, 0x00, 0x6f, 0xb3, 0x03,
-0x55, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x54, 0x00, 0x60, 0x72,
-0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x00, 0x07, 0x53, 0x00,
-0x01, 0xe5, 0x00, 0x1f, 0x2f, 0xe2, 0x00, 0x10, 0x10, 0x00,
-0x91, 0x04, 0x20, 0x00, 0x63, 0x36, 0x01, 0x21, 0x6c, 0x73,
-0x3f, 0x00, 0x07, 0xb6, 0x03, 0x03, 0x33, 0x00, 0x79, 0x6c,
+0x00, 0x31, 0x65, 0x64, 0x67, 0x93, 0x04, 0x04, 0xb3, 0x03,
+0x20, 0x2c, 0x00, 0x7c, 0x02, 0x04, 0x54, 0x00, 0x60, 0x72,
+0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x00, 0x09, 0x53, 0x00,
+0x4f, 0x72, 0x6f, 0x77, 0x2f, 0xe2, 0x00, 0x10, 0x10, 0x00,
+0x91, 0x04, 0x20, 0x00, 0x63, 0x36, 0x01, 0x27, 0x6c, 0x73,
+0x3f, 0x00, 0x02, 0xb6, 0x03, 0x02, 0x33, 0x00, 0x79, 0x6c,
 0x79, 0x2e, 0x00, 0x4d, 0x6f, 0x76, 0xc3, 0x00, 0x10, 0x6f,
 0xd0, 0x03, 0x11, 0x61, 0x27, 0x00, 0x10, 0x2c, 0x0f, 0x05,
 0x32, 0x64, 0x00, 0x43, 0x96, 0x01, 0x01, 0x9c, 0x00, 0x00,
-0xed, 0x01, 0x15, 0x73, 0x8b, 0x01, 0x08, 0x9c, 0x00, 0x06,
-0x8f, 0x04, 0x57, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x53, 0x00,
-0x01, 0x39, 0x00, 0x1b, 0x6d, 0x67, 0x00, 0x51, 0x61, 0x6c,
-0x6f, 0x6e, 0x67, 0xa5, 0x05, 0x05, 0x39, 0x00, 0x43, 0x2e,
-0x00, 0x4f, 0x72, 0x73, 0x00, 0x10, 0x53, 0xce, 0x04, 0x04,
-0x5a, 0x00, 0x01, 0xa9, 0x03, 0x07, 0x26, 0x00, 0x10, 0x50,
-0x84, 0x00, 0x00, 0xb6, 0x01, 0x50, 0x45, 0x6e, 0x74, 0x65,
-0x72, 0x10, 0x06, 0x60, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73,
-0x3b, 0x00, 0x00, 0x38, 0x06, 0x01, 0x37, 0x05, 0x05, 0xb6,
-0x00, 0x11, 0x28, 0xb3, 0x00, 0x03, 0x2c, 0x00, 0x50, 0x61,
-0x67, 0x61, 0x69, 0x6e, 0x58, 0x00, 0xc1, 0x72, 0x65, 0x6c,
-0x65, 0x61, 0x73, 0x65, 0x29, 0x2c, 0x00, 0x77, 0x68, 0x66,
-0x06, 0x04, 0x54, 0x00, 0x10, 0x53, 0x01, 0x05, 0x0f, 0x54,
-0x00, 0x04, 0x02, 0x65, 0x05, 0x00, 0x5b, 0x01, 0x42, 0x28,
-0x41, 0x6c, 0x6c, 0x7e, 0x02, 0x01, 0x78, 0x01, 0xb0, 0x73,
-0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64,
-0x94, 0x01, 0x13, 0x73, 0x8e, 0x01, 0x72, 0x32, 0x2e, 0x31,
+0xed, 0x01, 0x16, 0x73, 0x8b, 0x01, 0x0c, 0x9c, 0x00, 0x01,
+0x8f, 0x04, 0x20, 0x75, 0x6e, 0x03, 0x04, 0x07, 0x53, 0x00,
+0x00, 0x39, 0x00, 0x1b, 0x6d, 0x67, 0x00, 0x52, 0x61, 0x6c,
+0x6f, 0x6e, 0x67, 0xa5, 0x05, 0x04, 0x39, 0x00, 0x43, 0x2e,
+0x00, 0x4f, 0x72, 0x73, 0x00, 0x11, 0x53, 0xce, 0x04, 0x04,
+0x5a, 0x00, 0x01, 0xa9, 0x03, 0x06, 0x26, 0x00, 0x10, 0x50,
+0x84, 0x00, 0x00, 0xb6, 0x01, 0x20, 0x45, 0x6e, 0xf0, 0x05,
+0x91, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73,
+0x3b, 0x00, 0x00, 0x18, 0x00, 0x00, 0x37, 0x05, 0x05, 0xb6,
+0x00, 0x12, 0x28, 0xb3, 0x00, 0x02, 0x2c, 0x00, 0x20, 0x61,
+0x67, 0xbc, 0x05, 0xc0, 0x74, 0x6f, 0x00, 0x72, 0x65, 0x6c,
+0x65, 0x61, 0x73, 0x65, 0x29, 0x2c, 0xc7, 0x02, 0x00, 0x66,
+0x06, 0x04, 0x54, 0x00, 0x11, 0x53, 0x01, 0x05, 0x0f, 0x54,
+0x00, 0x04, 0x01, 0x65, 0x05, 0x00, 0x5b, 0x01, 0x42, 0x28,
+0x41, 0x6c, 0x6c, 0x7e, 0x02, 0x01, 0x78, 0x01, 0x90, 0x73,
+0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x08, 0x04,
+0x33, 0x6e, 0x00, 0x73, 0x8e, 0x01, 0x72, 0x32, 0x2e, 0x31,
 0x00, 0x61, 0x72, 0x65, 0x81, 0x01, 0xb1, 0x61, 0x76, 0x61,
 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29, 0xf6, 0x02,
 0x15, 0x32, 0xf6, 0x02, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d,
-0x65, 0x74, 0x65, 0x72, 0xf8, 0x02, 0x46, 0x54, 0x68, 0x65,
-0x00, 0x12, 0x00, 0x06, 0x37, 0x00, 0x51, 0x00, 0x66, 0x72,
-0x6f, 0x6d, 0x74, 0x00, 0xe0, 0x60, 0x43, 0x75, 0x73, 0x74,
+0x65, 0x74, 0x65, 0x72, 0xf8, 0x02, 0x10, 0x54, 0x36, 0x02,
+0x05, 0x12, 0x00, 0x06, 0x37, 0x00, 0x51, 0x00, 0x66, 0x72,
+0x6f, 0x6d, 0x74, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74,
 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6a,
-0x00, 0x04, 0x4b, 0x05, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
+0x00, 0x03, 0x4b, 0x05, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0x79, 0x00, 0xb1, 0x3a,
 0x00, 0x00, 0x00, 0x2d, 0x00, 0x57, 0x69, 0x64, 0x74, 0x68,
-0x84, 0x01, 0x21, 0x48, 0x65, 0x77, 0x06, 0x02, 0xba, 0x03,
-0x01, 0x9a, 0x00, 0x00, 0x10, 0x05, 0x70, 0x2d, 0x65, 0x78,
-0x70, 0x6c, 0x61, 0x6e, 0x9c, 0x02, 0x20, 0x79, 0x2e, 0x32,
-0x00, 0x06, 0x39, 0x02, 0x40, 0x73, 0x6b, 0x00, 0x66, 0xac,
-0x01, 0x20, 0x00, 0x6c, 0xc9, 0x04, 0x00, 0xed, 0x06, 0x51,
-0x68, 0x75, 0x66, 0x66, 0x6c, 0x91, 0x03, 0x41, 0x70, 0x65,
+0x84, 0x01, 0x22, 0x48, 0x65, 0x77, 0x06, 0x02, 0xba, 0x03,
+0x00, 0x9a, 0x00, 0x00, 0x10, 0x05, 0x70, 0x2d, 0x65, 0x78,
+0x70, 0x6c, 0x61, 0x6e, 0x9c, 0x02, 0x21, 0x79, 0x2e, 0x32,
+0x00, 0x05, 0x39, 0x02, 0x40, 0x73, 0x6b, 0x00, 0x66, 0xac,
+0x01, 0x20, 0x00, 0x6c, 0xc9, 0x04, 0x00, 0xed, 0x06, 0x41,
+0x68, 0x75, 0x66, 0x66, 0xa3, 0x04, 0x51, 0x6f, 0x70, 0x65,
 0x72, 0x61, 0x7c, 0x00, 0x20, 0x74, 0x6f, 0x34, 0x04, 0x98,
 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x2e,
 0x07, 0xe3, 0x2e, 0x00, 0x42, 0x79, 0x00, 0x64, 0x65, 0x66,
-0x61, 0x75, 0x6c, 0x74, 0x2c, 0x00, 0xf0, 0x00, 0x01, 0x6d,
-0x03, 0x03, 0x4a, 0x00, 0x14, 0x65, 0x2b, 0x00, 0x02, 0x38,
-0x01, 0x20, 0x75, 0x63, 0xb3, 0x07, 0x32, 0x77, 0x61, 0x79,
+0x61, 0x75, 0x6c, 0x74, 0x2c, 0x00, 0xf0, 0x00, 0x02, 0x6d,
+0x03, 0x02, 0x4a, 0x00, 0x16, 0x65, 0xae, 0x06, 0x00, 0x38,
+0x01, 0x10, 0x75, 0x97, 0x00, 0x42, 0x00, 0x77, 0x61, 0x79,
 0x02, 0x05, 0x34, 0x61, 0x6e, 0x79, 0x71, 0x06, 0x11, 0x6d,
 0xa0, 0x05, 0xf1, 0x00, 0x73, 0x00, 0x61, 0x62, 0x6f, 0x75,
 0x74, 0x00, 0x61, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x62, 0x17,
-0x01, 0x20, 0x61, 0x73, 0x28, 0x00, 0x02, 0xa8, 0x05, 0x15,
-0x2e, 0xbb, 0x00, 0x81, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69,
-0x64, 0x65, 0xda, 0x04, 0x00, 0xe5, 0x05, 0x62, 0x72, 0x65,
-0x71, 0x75, 0x65, 0x73, 0x8b, 0x05, 0x00, 0xee, 0x01, 0x43,
-0x63, 0x69, 0x73, 0x65, 0xc5, 0x07, 0x36, 0x00, 0x6f, 0x66,
-0xd9, 0x00, 0x01, 0x72, 0x02, 0x1a, 0x73, 0xd5, 0x00, 0x01,
-0x01, 0x07, 0x41, 0x79, 0x70, 0x69, 0x63, 0x79, 0x05, 0x10,
+0x01, 0x21, 0x61, 0x73, 0x28, 0x00, 0x01, 0xa8, 0x05, 0x15,
+0x2e, 0xbb, 0x00, 0x82, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69,
+0x64, 0x65, 0xda, 0x04, 0x93, 0x62, 0x79, 0x00, 0x72, 0x65,
+0x71, 0x75, 0x65, 0x73, 0x8b, 0x05, 0x73, 0x70, 0x72, 0x65,
+0x63, 0x69, 0x73, 0x65, 0xc5, 0x07, 0x00, 0x82, 0x03, 0x06,
+0xd9, 0x00, 0x00, 0x72, 0x02, 0x1c, 0x73, 0xd5, 0x00, 0x71,
+0x2e, 0x00, 0x54, 0x79, 0x70, 0x69, 0x63, 0x79, 0x05, 0x10,
 0x79, 0xe8, 0x07, 0x31, 0x61, 0x69, 0x6d, 0xe7, 0x07, 0x21,
-0x68, 0x65, 0x01, 0x01, 0x10, 0x64, 0xad, 0x01, 0x31, 0x6d,
-0x69, 0x6e, 0xd0, 0x00, 0x05, 0x5f, 0x00, 0x3f, 0x73, 0x65,
-0x74, 0x5c, 0x00, 0x00, 0x00, 0x8b, 0x01, 0x01, 0x37, 0x06,
-0x11, 0x72, 0xe4, 0x05, 0x70, 0x6d, 0x00, 0x65, 0x78, 0x61,
-0x63, 0x74, 0x4d, 0x04, 0x12, 0x73, 0xda, 0x07, 0x01, 0x7f,
+0x68, 0x65, 0x01, 0x01, 0x10, 0x64, 0xad, 0x01, 0x33, 0x6d,
+0x69, 0x6e, 0xf5, 0x03, 0x03, 0x5f, 0x00, 0x3f, 0x73, 0x65,
+0x74, 0x5c, 0x00, 0x01, 0x00, 0x8b, 0x01, 0x00, 0x37, 0x06,
+0x11, 0x72, 0xe4, 0x05, 0x50, 0x6d, 0x00, 0x65, 0x78, 0x61,
+0x8b, 0x03, 0x32, 0x2c, 0x00, 0x73, 0xda, 0x07, 0x01, 0x7f,
 0x07, 0x40, 0x61, 0x6e, 0x73, 0x77, 0x49, 0x07, 0x40, 0x73,
-0x61, 0x79, 0x29, 0x1a, 0x06, 0x40, 0x6f, 0x75, 0x72, 0x2d,
-0x3f, 0x00, 0x04, 0x39, 0x01, 0x01, 0x3b, 0x03, 0x0a, 0x19,
+0x61, 0x79, 0x29, 0x1a, 0x06, 0x41, 0x6f, 0x75, 0x72, 0x2d,
+0x0d, 0x03, 0x04, 0x39, 0x01, 0x03, 0xe0, 0x08, 0x07, 0x19,
 0x00, 0x32, 0x6f, 0x6c, 0x75, 0xa6, 0x04, 0x46, 0x4e, 0x6f,
-0x74, 0x65, 0x44, 0x06, 0x42, 0x6d, 0x6f, 0x72, 0x65, 0x7a,
-0x00, 0x00, 0x59, 0x00, 0x04, 0xd5, 0x01, 0x16, 0x2c, 0x1c,
-0x00, 0x40, 0x6c, 0x69, 0x6b, 0x65, 0xca, 0x06, 0x00, 0x61,
-0x01, 0x01, 0x37, 0x00, 0x05, 0x4b, 0x00, 0x72, 0x73, 0x00,
-0x73, 0x68, 0x6f, 0x72, 0x74, 0xbf, 0x05, 0x03, 0xca, 0x07,
-0xc2, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x6c, 0x65, 0x6e,
-0x67, 0x74, 0x68, 0xcb, 0x01, 0x01, 0xa6, 0x04, 0x34, 0x6f,
-0x75, 0x74, 0x35, 0x01, 0x90, 0x6f, 0x73, 0x73, 0x69, 0x62,
-0x6c, 0x65, 0x2e, 0x00,
+0x74, 0x65, 0x44, 0x06, 0x43, 0x6d, 0x6f, 0x72, 0x65, 0x7a,
+0x00, 0x01, 0x59, 0x00, 0x02, 0xd5, 0x01, 0x16, 0x2c, 0x1c,
+0x00, 0x40, 0x6c, 0x69, 0x6b, 0x65, 0xca, 0x06, 0x12, 0x74,
+0xd2, 0x00, 0x25, 0x61, 0x74, 0x4b, 0x00, 0x76, 0x73, 0x00,
+0x73, 0x68, 0x6f, 0x72, 0x74, 0x47, 0x06, 0xf2, 0x00, 0x65,
+0x00, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x6c, 0x65,
+0x6e, 0x67, 0x74, 0x68, 0xcb, 0x01, 0x01, 0xa6, 0x04, 0x00,
+0x97, 0x01, 0x03, 0x35, 0x01, 0x90, 0x6f, 0x73, 0x73, 0x69,
+0x62, 0x6c, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2534;
diff --git a/apps/plugins/puzzles/help/slant.c b/apps/plugins/puzzles/help/slant.c
index f905458aeb..873863757e 100644
--- a/apps/plugins/puzzles/help/slant.c
+++ b/apps/plugins/puzzles/help/slant.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2378 comp 1648 ratio 0.693019 level 11 saved 730 */
+/* orig 2378 comp 1650 ratio 0.69386 level 10 saved 728 */
 const char help_text[] = {
 0xf0, 0x21, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x30, 0x3a, 0x20, 0x53, 0x6c, 0x61, 0x6e, 0x74, 0x20,
@@ -27,9 +27,9 @@ const char help_text[] = {
 0x00, 0x61, 0x00, 0x64, 0x69, 0x61, 0x67, 0x6f, 0x6e, 0x61,
 0x6c, 0x00, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x74, 0x68, 0x72,
 0x6f, 0x75, 0x67, 0x68, 0x00, 0x65, 0x61, 0x63, 0x68, 0x3a,
-0x00, 0xf1, 0x07, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x00, 0x63,
+0x00, 0xf2, 0x07, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x00, 0x63,
 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x00, 0x77, 0x68, 0x69, 0x63,
-0x68, 0x00, 0x77, 0x61, 0x79, 0x22, 0x00, 0x02, 0x34, 0x00,
+0x68, 0x00, 0x77, 0x61, 0x79, 0x22, 0x00, 0x01, 0x34, 0x00,
 0x10, 0x73, 0x7d, 0x00, 0xfa, 0x24, 0x73, 0x00, 0x73, 0x6f,
 0x00, 0x74, 0x68, 0x61, 0x74, 0x00, 0x74, 0x68, 0x65, 0x00,
 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x00,
@@ -44,144 +44,144 @@ const char help_text[] = {
 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x68, 0x61, 0x73,
 0x00, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x65, 0x6c, 0x79,
 0x83, 0x00, 0x43, 0x6d, 0x61, 0x6e, 0x79, 0x55, 0x00, 0x40,
-0x6d, 0x65, 0x65, 0x74, 0x88, 0x00, 0xf1, 0x05, 0x61, 0x74,
+0x6d, 0x65, 0x65, 0x74, 0x88, 0x00, 0xf1, 0x02, 0x61, 0x74,
 0x00, 0x69, 0x74, 0x2e, 0x00, 0x28, 0x54, 0x68, 0x75, 0x73,
-0x2c, 0x00, 0x61, 0x00, 0x34, 0x00, 0x69, 0x73, 0xab, 0x00,
-0x90, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x00, 0x6f, 0x66,
-0x5a, 0x00, 0xfd, 0x0b, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x73,
+0x2c, 0x00, 0x61, 0x00, 0x34, 0x06, 0x01, 0x90, 0x68, 0x65,
+0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x29, 0x01, 0xfe,
+0x0e, 0x61, 0x00, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x73,
 0x68, 0x61, 0x70, 0x65, 0x2c, 0x00, 0x77, 0x68, 0x65, 0x72,
 0x65, 0x61, 0x73, 0x00, 0x61, 0x00, 0x7a, 0x65, 0x72, 0x6f,
-0x2f, 0x00, 0x02, 0x3b, 0x01, 0x42, 0x6d, 0x6f, 0x6e, 0x64,
+0x2f, 0x00, 0x01, 0x3b, 0x01, 0x42, 0x6d, 0x6f, 0x6e, 0x64,
 0x31, 0x00, 0xc0, 0x00, 0x2d, 0x00, 0x6f, 0x72, 0x00, 0x72,
 0x61, 0x74, 0x68, 0x65, 0x72, 0x61, 0x00, 0x7a, 0x70, 0x61,
 0x72, 0x74, 0x69, 0x61, 0x6c, 0x25, 0x00, 0x94, 0x2c, 0x00,
 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x56, 0x00, 0x33,
 0x63, 0x61, 0x6e, 0xf8, 0x00, 0x91, 0x61, 0x70, 0x70, 0x65,
-0x61, 0x72, 0x00, 0x69, 0x6e, 0x67, 0x00, 0x50, 0x6d, 0x69,
+0x61, 0x72, 0x00, 0x69, 0x6e, 0x67, 0x00, 0x51, 0x6d, 0x69,
 0x64, 0x64, 0x6c, 0x67, 0x00, 0x00, 0x0e, 0x00, 0x01, 0xcb,
-0x01, 0x04, 0x3a, 0x00, 0x02, 0xe2, 0x00, 0xe0, 0x77, 0x6f,
+0x01, 0x04, 0x3a, 0x00, 0x01, 0xe2, 0x00, 0xe0, 0x77, 0x6f,
 0x75, 0x6c, 0x64, 0x00, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69,
-0x61, 0x74, 0xf9, 0x00, 0x01, 0x1d, 0x00, 0x04, 0x39, 0x01,
+0x61, 0x74, 0xf9, 0x00, 0x04, 0x57, 0x00, 0x01, 0x39, 0x01,
 0xa0, 0x29, 0x00, 0x00, 0x00, 0x43, 0x72, 0x65, 0x64, 0x69,
 0x74, 0x50, 0x01, 0xf1, 0x01, 0x00, 0x74, 0x68, 0x69, 0x73,
 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00, 0x67, 0x6f,
-0x65, 0xff, 0x01, 0xd0, 0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x69,
-0x00, 0x5b, 0x38, 0x5d, 0x2e, 0x00, 0x00, 0x07, 0x00, 0xd1,
-0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77,
-0x77, 0x2e, 0x6e, 0x1d, 0x00, 0xa2, 0x2e, 0x63, 0x6f, 0x2e,
-0x6a, 0x70, 0x2f, 0x6a, 0x61, 0x2f, 0x3c, 0x00, 0xf0, 0x0e,
-0x73, 0x2f, 0x67, 0x6f, 0x6b, 0x69, 0x67, 0x65, 0x6e, 0x5f,
-0x6e, 0x61, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x28, 0x69, 0x6e,
-0x00, 0x4a, 0x61, 0x70, 0x61, 0x6e, 0x65, 0x73, 0x65, 0x73,
-0x00, 0x43, 0x32, 0x30, 0x2e, 0x31, 0x8c, 0x02, 0x80, 0x63,
-0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, 0x95, 0x02, 0xd0,
-0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63, 0x6b,
-0x69, 0x6e, 0x67, 0xe2, 0x00, 0x73, 0x61, 0x00, 0x62, 0x6c,
-0x61, 0x6e, 0x6b, 0x61, 0x02, 0xa0, 0x00, 0x77, 0x69, 0x6c,
-0x6c, 0x00, 0x70, 0x6c, 0x61, 0x63, 0xc0, 0x00, 0x10, 0x5c,
-0x21, 0x00, 0x52, 0x69, 0x74, 0x00, 0x28, 0x61, 0x5e, 0x02,
-0x40, 0x6c, 0x65, 0x61, 0x6e, 0x37, 0x00, 0x10, 0x74, 0x5f,
-0x02, 0x00, 0x0f, 0x00, 0xc1, 0x66, 0x74, 0x2c, 0x00, 0x69,
-0x2e, 0x65, 0x2e, 0x00, 0x72, 0x75, 0x6e, 0x1a, 0x00, 0x41,
-0x66, 0x72, 0x6f, 0x6d, 0x1c, 0x00, 0x31, 0x74, 0x6f, 0x70,
-0x20, 0x00, 0x03, 0x37, 0x01, 0x03, 0x5f, 0x00, 0x04, 0x3a,
-0x00, 0xff, 0x04, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x00,
-0x72, 0x69, 0x67, 0x68, 0x74, 0x29, 0x2e, 0x00, 0x52, 0x69,
-0x67, 0x68, 0x96, 0x00, 0x17, 0x14, 0x2f, 0x96, 0x00, 0x0a,
-0x8f, 0x00, 0x02, 0x4e, 0x00, 0x1b, 0x2c, 0x8b, 0x00, 0x22,
-0x6f, 0x70, 0x18, 0x00, 0x33, 0x00, 0x74, 0x6f, 0x76, 0x00,
-0x01, 0x97, 0x00, 0x20, 0x29, 0x2e, 0x96, 0x01, 0x63, 0x6f,
-0x6e, 0x74, 0x69, 0x6e, 0x75, 0x43, 0x00, 0x01, 0x7f, 0x00,
-0x30, 0x00, 0x65, 0x69, 0x35, 0x02, 0x72, 0x00, 0x62, 0x75,
-0x74, 0x74, 0x6f, 0x6e, 0x78, 0x00, 0xc0, 0x63, 0x79, 0x63,
-0x6c, 0x65, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x12,
-0x02, 0x01, 0x9a, 0x03, 0xa5, 0x65, 0x65, 0x00, 0x70, 0x6f,
-0x73, 0x73, 0x69, 0x62, 0x6c, 0xdc, 0x00, 0x00, 0x67, 0x01,
-0x62, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x00, 0xd9, 0x02, 0x85,
-0x69, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x00, 0x6c, 0x72, 0x01,
-0xbf, 0x00, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64,
-0x6c, 0x79, 0xe4, 0x00, 0x00, 0x23, 0x69, 0x74, 0x6f, 0x00,
-0x51, 0x68, 0x61, 0x6e, 0x67, 0x65, 0xbf, 0x00, 0x02, 0x21,
-0x00, 0x00, 0x9d, 0x00, 0x10, 0x5c, 0x05, 0x00, 0x50, 0x2f,
-0x00, 0x62, 0x61, 0x63, 0x0f, 0x00, 0x02, 0x18, 0x00, 0x01,
-0x0d, 0x04, 0x03, 0x66, 0x00, 0x01, 0xe5, 0x00, 0x0e, 0x67,
-0x00, 0x07, 0x7b, 0x01, 0x0f, 0x5d, 0x00, 0x08, 0x11, 0x2f,
-0x62, 0x00, 0x0a, 0x5d, 0x00, 0x00, 0x9f, 0x03, 0x00, 0x75,
-0x03, 0x50, 0x66, 0x6f, 0x72, 0x65, 0x2c, 0x62, 0x00, 0x00,
-0x1f, 0x03, 0x00, 0x83, 0x01, 0x12, 0x79, 0x06, 0x03, 0x00,
-0x73, 0x02, 0x82, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x6c,
-0x79, 0x0d, 0x04, 0x33, 0x6f, 0x6e, 0x65, 0x37, 0x01, 0x04,
-0x94, 0x00, 0x71, 0x6e, 0x65, 0x65, 0x64, 0x00, 0x74, 0x6f,
-0x02, 0x03, 0x13, 0x59, 0x42, 0x00, 0x82, 0x61, 0x6c, 0x73,
-0x6f, 0x00, 0x75, 0x73, 0x65, 0xc1, 0x03, 0x91, 0x75, 0x72,
-0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x07, 0x03, 0x20,
-0x6d, 0x6f, 0x2d, 0x05, 0x55, 0x72, 0x6f, 0x75, 0x6e, 0x64,
-0x6b, 0x03, 0xa2, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73,
-0x69, 0x6e, 0x67, 0xe4, 0x01, 0x50, 0x65, 0x74, 0x75, 0x72,
-0x6e, 0xde, 0x03, 0x51, 0x73, 0x70, 0x61, 0x63, 0x65, 0x3b,
-0x00, 0x0c, 0xb4, 0x02, 0x20, 0x6f, 0x72, 0x25, 0x02, 0xe1,
-0x2c, 0x00, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
-0x76, 0x65, 0x6c, 0x79, 0x2c, 0x01, 0x01, 0x29, 0x00, 0x00,
-0x47, 0x00, 0x11, 0x6e, 0xd4, 0x01, 0x01, 0x84, 0x00, 0x20,
-0x6d, 0x00, 0x57, 0x04, 0x5a, 0x62, 0x6f, 0x76, 0x65, 0x2e,
-0xa4, 0x00, 0x10, 0x70, 0x77, 0x00, 0x51, 0x00, 0x2f, 0x00,
-0x6f, 0x72, 0x7d, 0x01, 0x04, 0x60, 0x00, 0x03, 0x12, 0x00,
-0x0c, 0x5e, 0x00, 0xa1, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65,
-0x6e, 0x64, 0x65, 0x6e, 0xf2, 0x02, 0x40, 0x77, 0x68, 0x61,
-0x74, 0xa6, 0x04, 0x60, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64,
-0xee, 0x01, 0x07, 0xf0, 0x00, 0x03, 0x91, 0x01, 0x62, 0x2e,
-0x00, 0x42, 0x61, 0x63, 0x6b, 0xc7, 0x00, 0x20, 0x72, 0x65,
-0xfc, 0x00, 0x24, 0x73, 0x00, 0x2c, 0x05, 0x03, 0xbd, 0x02,
-0x0e, 0x33, 0x00, 0x42, 0x00, 0x00, 0x28, 0x41, 0xc4, 0x00,
-0x32, 0x00, 0x61, 0x63, 0xcb, 0x05, 0x90, 0x64, 0x65, 0x73,
-0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x66, 0x00, 0x21, 0x73,
-0x65, 0x16, 0x00, 0x40, 0x00, 0x32, 0x2e, 0x31, 0xe4, 0x05,
-0x02, 0xcb, 0x00, 0xa3, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
-0x62, 0x6c, 0x65, 0x2e, 0x19, 0x04, 0x13, 0x32, 0x19, 0x04,
-0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
-0x1b, 0x04, 0x00, 0x07, 0x06, 0x35, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x01, 0x25, 0x06, 0x05, 0x3c, 0x00, 0x07, 0x93, 0x00,
-0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
-0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x22, 0x6f, 0x6e,
-0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0xab, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0x81, 0x03, 0x50, 0x00, 0x00,
-0x53, 0x69, 0x7a, 0x47, 0x05, 0x02, 0x43, 0x05, 0x26, 0x69,
-0x6e, 0x0e, 0x07, 0xc0, 0x00, 0x00, 0x44, 0x69, 0x66, 0x66,
-0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x98, 0x03, 0x02, 0xb0,
-0x04, 0x02, 0xe5, 0x05, 0x15, 0x64, 0x1a, 0x00, 0x05, 0x82,
-0x05, 0x40, 0x65, 0x6e, 0x65, 0x72, 0xe0, 0x02, 0x03, 0x47,
-0x05, 0xf2, 0x00, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x48, 0x61,
-0x72, 0x64, 0x00, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0xae, 0x02,
-0x20, 0x61, 0x72, 0x56, 0x01, 0x61, 0x71, 0x75, 0x69, 0x72,
-0x65, 0x64, 0x62, 0x07, 0x63, 0x6f, 0x00, 0x64, 0x65, 0x64,
-0x75, 0x34, 0x01, 0x50, 0x62, 0x61, 0x73, 0x65, 0x64, 0xb6,
-0x00, 0x81, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67,
-0x98, 0x00, 0x41, 0x72, 0x65, 0x6c, 0x61, 0x20, 0x00, 0x43,
-0x68, 0x69, 0x70, 0x73, 0xf1, 0x03, 0x05, 0xa6, 0x00, 0x02,
-0x4f, 0x06, 0x00, 0xc0, 0x05, 0x01, 0x22, 0x02, 0x30, 0x77,
-0x61, 0x79, 0x23, 0x00, 0x01, 0xcf, 0x06, 0x10, 0x62, 0x4b,
-0x02, 0x03, 0x60, 0x00, 0x02, 0xd9, 0x02, 0x55, 0x65, 0x78,
-0x61, 0x63, 0x74, 0x11, 0x04, 0x00, 0x5c, 0x00, 0x24, 0x6f,
-0x6e, 0x89, 0x03, 0x00, 0xff, 0x06, 0xc0, 0x61, 0x00, 0x74,
-0x69, 0x6d, 0x65, 0x2e, 0x00, 0x28, 0x46, 0x6f, 0x72, 0x2d,
-0x00, 0x33, 0x6d, 0x70, 0x6c, 0x66, 0x03, 0x10, 0x6d, 0x2c,
-0x01, 0x01, 0x97, 0x00, 0x03, 0xc2, 0x07, 0x24, 0x77, 0x6f,
-0x82, 0x00, 0x02, 0xdd, 0x07, 0x04, 0x4c, 0x02, 0x30, 0x73,
-0x61, 0x6d, 0x1d, 0x01, 0x12, 0x72, 0xf1, 0x01, 0x55, 0x2c,
-0x00, 0x65, 0x76, 0x65, 0x79, 0x03, 0x82, 0x64, 0x6f, 0x6e,
-0x27, 0x74, 0x00, 0x79, 0x65, 0x49, 0x00, 0x01, 0x8e, 0x02,
-0x01, 0x4e, 0x00, 0x06, 0x30, 0x00, 0x31, 0x00, 0x69, 0x73,
-0x13, 0x03, 0x01, 0x8f, 0x06, 0x03, 0x75, 0x00, 0x20, 0x65,
-0x6e, 0xca, 0x00, 0x00, 0x41, 0x00, 0x07, 0xce, 0x00, 0x62,
-0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0xe7, 0x00, 0x60, 0x6f,
-0x75, 0x74, 0x00, 0x73, 0x74, 0x44, 0x03, 0x10, 0x6f, 0x0b,
-0x01, 0x05, 0xc0, 0x01, 0x30, 0x29, 0x00, 0x45, 0x7d, 0x00,
-0x1a, 0x61, 0x86, 0x01, 0x90, 0x67, 0x75, 0x65, 0x73, 0x73,
-0x77, 0x6f, 0x72, 0x6b, 0x68, 0x00, 0x01, 0x5d, 0x04, 0x32,
-0x74, 0x72, 0x61, 0xe1, 0x05, 0x20, 0x73, 0x68, 0x33, 0x07,
-0x03, 0x6d, 0x07, 0xe0, 0x62, 0x65, 0x00, 0x6e, 0x65, 0x63,
-0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x2e, 0x00,
+0x65, 0xff, 0x01, 0xa0, 0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x69,
+0x00, 0x5b, 0x38, 0x5d, 0x67, 0x01, 0xf1, 0x01, 0x5b, 0x38,
+0x5d, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77,
+0x77, 0x77, 0x2e, 0x6e, 0x1d, 0x00, 0xa2, 0x2e, 0x63, 0x6f,
+0x2e, 0x6a, 0x70, 0x2f, 0x6a, 0x61, 0x2f, 0x3c, 0x00, 0xf0,
+0x0e, 0x73, 0x2f, 0x67, 0x6f, 0x6b, 0x69, 0x67, 0x65, 0x6e,
+0x5f, 0x6e, 0x61, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x28, 0x69,
+0x6e, 0x00, 0x4a, 0x61, 0x70, 0x61, 0x6e, 0x65, 0x73, 0x65,
+0x73, 0x00, 0x43, 0x32, 0x30, 0x2e, 0x31, 0x8c, 0x02, 0x80,
+0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, 0x95, 0x02,
+0xa0, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69, 0x63,
+0x6b, 0x8a, 0x01, 0xa3, 0x69, 0x6e, 0x00, 0x61, 0x00, 0x62,
+0x6c, 0x61, 0x6e, 0x6b, 0x61, 0x02, 0xa0, 0x00, 0x77, 0x69,
+0x6c, 0x6c, 0x00, 0x70, 0x6c, 0x61, 0x63, 0xc0, 0x00, 0x10,
+0x5c, 0x21, 0x00, 0x52, 0x69, 0x74, 0x00, 0x28, 0x61, 0x5e,
+0x02, 0x40, 0x6c, 0x65, 0x61, 0x6e, 0x37, 0x00, 0x10, 0x74,
+0x5f, 0x02, 0x00, 0x0f, 0x00, 0xc1, 0x66, 0x74, 0x2c, 0x00,
+0x69, 0x2e, 0x65, 0x2e, 0x00, 0x72, 0x75, 0x6e, 0x1a, 0x00,
+0x41, 0x66, 0x72, 0x6f, 0x6d, 0x1c, 0x00, 0x31, 0x74, 0x6f,
+0x70, 0x20, 0x00, 0x04, 0x37, 0x01, 0x03, 0x5f, 0x00, 0x03,
+0x3a, 0x00, 0xf0, 0x01, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d,
+0x00, 0x72, 0x69, 0x67, 0x68, 0x74, 0x29, 0x2e, 0x00, 0x52,
+0x08, 0x00, 0x0f, 0x96, 0x00, 0x16, 0x14, 0x2f, 0x96, 0x00,
+0x0b, 0x8f, 0x00, 0x01, 0x4e, 0x00, 0x1b, 0x2c, 0x8b, 0x00,
+0x22, 0x6f, 0x70, 0x18, 0x00, 0x00, 0x25, 0x00, 0x03, 0x76,
+0x00, 0x00, 0x97, 0x00, 0x20, 0x29, 0x2e, 0x96, 0x01, 0x63,
+0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x43, 0x00, 0x01, 0x7f,
+0x00, 0x30, 0x00, 0x65, 0x69, 0x35, 0x02, 0x72, 0x00, 0x62,
+0x75, 0x74, 0x74, 0x6f, 0x6e, 0x78, 0x00, 0xd2, 0x63, 0x79,
+0x63, 0x6c, 0x65, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65,
+0x6e, 0xdd, 0x00, 0xc5, 0x68, 0x72, 0x65, 0x65, 0x00, 0x70,
+0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0xdc, 0x00, 0x00, 0x67,
+0x01, 0x62, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x00, 0xd9, 0x02,
+0x85, 0x69, 0x66, 0x00, 0x79, 0x6f, 0x75, 0x00, 0x6c, 0x72,
+0x01, 0xbe, 0x00, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65,
+0x64, 0x6c, 0x79, 0xe4, 0x00, 0x00, 0xd2, 0x00, 0x02, 0x6f,
+0x00, 0x52, 0x68, 0x61, 0x6e, 0x67, 0x65, 0xbf, 0x00, 0x02,
+0x21, 0x00, 0x40, 0x74, 0x6f, 0x00, 0x5c, 0x05, 0x00, 0x51,
+0x2f, 0x00, 0x62, 0x61, 0x63, 0x0f, 0x00, 0x01, 0x18, 0x00,
+0x02, 0x0d, 0x04, 0x03, 0x66, 0x00, 0x01, 0xe5, 0x00, 0x0e,
+0x67, 0x00, 0x07, 0x7b, 0x01, 0x0f, 0x5d, 0x00, 0x07, 0x12,
+0x2f, 0x62, 0x00, 0x09, 0x5d, 0x00, 0x01, 0x9f, 0x03, 0x50,
+0x65, 0x72, 0x65, 0x66, 0x6f, 0x76, 0x04, 0x00, 0x62, 0x00,
+0x00, 0x1f, 0x03, 0x42, 0x70, 0x6c, 0x61, 0x79, 0x06, 0x03,
+0x00, 0x73, 0x02, 0x50, 0x65, 0x6e, 0x74, 0x69, 0x72, 0xf0,
+0x02, 0x01, 0x0d, 0x04, 0x34, 0x6f, 0x6e, 0x65, 0x37, 0x01,
+0x03, 0x94, 0x00, 0x71, 0x6e, 0x65, 0x65, 0x64, 0x00, 0x74,
+0x6f, 0x02, 0x03, 0x13, 0x59, 0x42, 0x00, 0x52, 0x61, 0x6c,
+0x73, 0x6f, 0x00, 0x3b, 0x03, 0xc1, 0x65, 0x00, 0x63, 0x75,
+0x72, 0x73, 0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x07, 0x03,
+0x20, 0x6d, 0x6f, 0x2d, 0x05, 0x55, 0x72, 0x6f, 0x75, 0x6e,
+0x64, 0x6b, 0x03, 0x71, 0x2e, 0x00, 0x50, 0x72, 0x65, 0x73,
+0x73, 0xa4, 0x01, 0x00, 0xe4, 0x01, 0x50, 0x65, 0x74, 0x75,
+0x72, 0x6e, 0xde, 0x03, 0x20, 0x73, 0x70, 0x0e, 0x02, 0x01,
+0x3b, 0x00, 0x0b, 0xb4, 0x02, 0x20, 0x6f, 0x72, 0x25, 0x02,
+0xe2, 0x2c, 0x00, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74,
+0x69, 0x76, 0x65, 0x6c, 0x79, 0x2c, 0x01, 0x01, 0x29, 0x00,
+0x43, 0x74, 0x68, 0x65, 0x6e, 0xd4, 0x01, 0x50, 0x74, 0x68,
+0x65, 0x6d, 0x00, 0x57, 0x04, 0x5a, 0x62, 0x6f, 0x76, 0x65,
+0x2e, 0xa4, 0x00, 0x10, 0x70, 0x77, 0x00, 0x20, 0x00, 0x2f,
+0x4e, 0x00, 0x01, 0x7d, 0x01, 0x06, 0x7e, 0x02, 0x00, 0x12,
+0x00, 0x0c, 0x5e, 0x00, 0xa1, 0x69, 0x6e, 0x64, 0x65, 0x70,
+0x65, 0x6e, 0x64, 0x65, 0x6e, 0xf2, 0x02, 0x20, 0x77, 0x68,
+0xe4, 0x04, 0x81, 0x73, 0x00, 0x61, 0x6c, 0x72, 0x65, 0x61,
+0x64, 0xee, 0x01, 0x07, 0xf0, 0x00, 0x02, 0x91, 0x01, 0x62,
+0x2e, 0x00, 0x42, 0x61, 0x63, 0x6b, 0xc7, 0x00, 0x20, 0x72,
+0x65, 0xfc, 0x00, 0x24, 0x73, 0x00, 0x2c, 0x05, 0x06, 0x48,
+0x03, 0x0b, 0x33, 0x00, 0x42, 0x00, 0x00, 0x28, 0x41, 0xc4,
+0x00, 0x32, 0x00, 0x61, 0x63, 0xcb, 0x05, 0x90, 0x64, 0x65,
+0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x66, 0x00, 0x21,
+0x73, 0x65, 0x16, 0x00, 0x41, 0x00, 0x32, 0x2e, 0x31, 0xe4,
+0x05, 0x01, 0xcb, 0x00, 0xa3, 0x61, 0x76, 0x61, 0x69, 0x6c,
+0x61, 0x62, 0x6c, 0x65, 0x2e, 0x19, 0x04, 0x13, 0x32, 0x19,
+0x04, 0x91, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+0x72, 0x1b, 0x04, 0x66, 0x54, 0x68, 0x65, 0x73, 0x65, 0x00,
+0x14, 0x00, 0x02, 0x41, 0x00, 0x04, 0x3c, 0x00, 0x06, 0x93,
+0x00, 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e,
+0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x6f, 0x00, 0x22, 0x6f,
+0x6e, 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0xab, 0x00, 0x91, 0x57, 0x69, 0x64,
+0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x81, 0x03, 0x51, 0x00,
+0x00, 0x53, 0x69, 0x7a, 0x47, 0x05, 0x01, 0x43, 0x05, 0x26,
+0x69, 0x6e, 0x0e, 0x07, 0xc3, 0x00, 0x00, 0x44, 0x69, 0x66,
+0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x98, 0x03, 0x00,
+0xb0, 0x04, 0x01, 0x54, 0x00, 0x16, 0x64, 0x1a, 0x00, 0x04,
+0x82, 0x05, 0x40, 0x65, 0x6e, 0x65, 0x72, 0xe0, 0x02, 0x03,
+0x47, 0x05, 0xf2, 0x00, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x48,
+0x61, 0x72, 0x64, 0x00, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0xae,
+0x02, 0x20, 0x61, 0x72, 0x56, 0x01, 0x61, 0x71, 0x75, 0x69,
+0x72, 0x65, 0x64, 0x62, 0x07, 0x63, 0x6f, 0x00, 0x64, 0x65,
+0x64, 0x75, 0x34, 0x01, 0x50, 0x62, 0x61, 0x73, 0x65, 0x64,
+0xb6, 0x00, 0x81, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64,
+0x67, 0x98, 0x00, 0x41, 0x72, 0x65, 0x6c, 0x61, 0x20, 0x00,
+0x45, 0x68, 0x69, 0x70, 0x73, 0xf1, 0x03, 0x03, 0xa6, 0x00,
+0x03, 0x4f, 0x06, 0x00, 0xf3, 0x05, 0x00, 0x22, 0x02, 0x30,
+0x77, 0x61, 0x79, 0x23, 0x00, 0x01, 0xcf, 0x06, 0x10, 0x62,
+0x4b, 0x02, 0x03, 0x60, 0x00, 0x02, 0xd9, 0x02, 0x55, 0x65,
+0x78, 0x61, 0x63, 0x74, 0x11, 0x04, 0x00, 0x5c, 0x00, 0x25,
+0x6f, 0x6e, 0x89, 0x03, 0xf0, 0x00, 0x61, 0x74, 0x00, 0x61,
+0x00, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x00, 0x28, 0x46, 0x6f,
+0x72, 0x2d, 0x00, 0x33, 0x6d, 0x70, 0x6c, 0x66, 0x03, 0x11,
+0x6d, 0x2c, 0x01, 0x00, 0x97, 0x00, 0x03, 0xc2, 0x07, 0x25,
+0x77, 0x6f, 0x82, 0x00, 0x01, 0xdd, 0x07, 0x04, 0x4c, 0x02,
+0x30, 0x73, 0x61, 0x6d, 0x1d, 0x01, 0x12, 0x72, 0xf1, 0x01,
+0x55, 0x2c, 0x00, 0x65, 0x76, 0x65, 0x79, 0x03, 0x83, 0x64,
+0x6f, 0x6e, 0x27, 0x74, 0x00, 0x79, 0x65, 0x49, 0x00, 0x01,
+0x8e, 0x02, 0x01, 0x4e, 0x00, 0x05, 0x30, 0x00, 0x32, 0x00,
+0x69, 0x73, 0x13, 0x03, 0x01, 0x8f, 0x06, 0x02, 0x75, 0x00,
+0x21, 0x65, 0x6e, 0xca, 0x00, 0x00, 0x41, 0x00, 0x06, 0xce,
+0x00, 0x62, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0xe7, 0x00,
+0x60, 0x6f, 0x75, 0x74, 0x00, 0x73, 0x74, 0x44, 0x03, 0x11,
+0x6f, 0x0b, 0x01, 0x04, 0xc0, 0x01, 0x30, 0x29, 0x00, 0x45,
+0x7d, 0x00, 0x1a, 0x61, 0x86, 0x01, 0x91, 0x67, 0x75, 0x65,
+0x73, 0x73, 0x77, 0x6f, 0x72, 0x6b, 0x68, 0x00, 0x00, 0x5d,
+0x04, 0x32, 0x74, 0x72, 0x61, 0xe1, 0x05, 0x21, 0x73, 0x68,
+0x33, 0x07, 0x02, 0x6d, 0x07, 0xe0, 0x62, 0x65, 0x00, 0x6e,
+0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2378;
diff --git a/apps/plugins/puzzles/help/solo.c b/apps/plugins/puzzles/help/solo.c
index f2ba9c7848..a02bb94c04 100644
--- a/apps/plugins/puzzles/help/solo.c
+++ b/apps/plugins/puzzles/help/solo.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 6263 comp 3634 ratio 0.580233 level 11 saved 2629 */
+/* orig 6263 comp 3635 ratio 0.580393 level 10 saved 2628 */
 const char help_text[] = {
 0xf0, 0x53, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x31, 0x31, 0x3a, 0x20, 0x53, 0x6f, 0x6c, 0x6f, 0x20, 0x00,
@@ -30,9 +30,9 @@ const char help_text[] = {
 0x68, 0x61, 0x73, 0x00, 0x72, 0x6f, 0x77, 0x73, 0x2e, 0x00,
 0x45, 0x61, 0x63, 0x68, 0x5f, 0x00, 0xc1, 0x6d, 0x75, 0x73,
 0x74, 0x00, 0x62, 0x65, 0x00, 0x66, 0x69, 0x6c, 0x6c, 0x57,
-0x00, 0xf0, 0x08, 0x00, 0x77, 0x69, 0x74, 0x68, 0x00, 0x61,
+0x00, 0xf1, 0x08, 0x00, 0x77, 0x69, 0x74, 0x68, 0x00, 0x61,
 0x00, 0x64, 0x69, 0x67, 0x69, 0x74, 0x00, 0x66, 0x72, 0x6f,
-0x6d, 0x00, 0x31, 0x00, 0x74, 0x6f, 0x48, 0x00, 0x01, 0x60,
+0x6d, 0x00, 0x31, 0x00, 0x74, 0x6f, 0x48, 0x00, 0x00, 0x60,
 0x00, 0x35, 0x00, 0x6f, 0x66, 0x54, 0x00, 0x10, 0x2c, 0x30,
 0x00, 0x30, 0x73, 0x75, 0x63, 0x30, 0x00, 0xf0, 0x03, 0x77,
 0x61, 0x79, 0x00, 0x74, 0x68, 0x61, 0x74, 0x00, 0x00, 0x00,
@@ -40,110 +40,110 @@ const char help_text[] = {
 0x0d, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73,
 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x65, 0x00,
 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x4b,
-0x00, 0x41, 0x65, 0x61, 0x63, 0x68, 0x6c, 0x00, 0x08, 0x39,
+0x00, 0x10, 0x65, 0x8c, 0x00, 0x02, 0x6c, 0x00, 0x06, 0x39,
 0x00, 0x6f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x3c, 0x00,
 0x23, 0x01, 0xfa, 0x00, 0x0f, 0x3b, 0x00, 0x18, 0x11, 0x2e,
 0x3c, 0x00, 0x70, 0x28, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-0x46, 0x01, 0xf1, 0x02, 0x2c, 0x00, 0x62, 0x79, 0x00, 0x64,
+0x46, 0x01, 0xf2, 0x02, 0x2c, 0x00, 0x62, 0x79, 0x00, 0x64,
 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x6f, 0x66, 0x66,
-0x29, 0x2d, 0x00, 0x03, 0xf7, 0x00, 0x03, 0x37, 0x01, 0xf0,
+0x29, 0x2d, 0x00, 0x03, 0xf7, 0x00, 0x02, 0x37, 0x01, 0xf0,
 0x01, 0x27, 0x73, 0x00, 0x74, 0x77, 0x6f, 0x00, 0x6d, 0x61,
 0x69, 0x6e, 0x00, 0x64, 0x69, 0x61, 0x67, 0x3a, 0x00, 0x1f,
-0x73, 0x75, 0x00, 0x19, 0x03, 0xeb, 0x01, 0x01, 0xe1, 0x01,
+0x73, 0x75, 0x00, 0x1c, 0x00, 0xeb, 0x01, 0x01, 0xe1, 0x01,
 0x85, 0x69, 0x76, 0x65, 0x6e, 0x00, 0x73, 0x6f, 0x6d, 0x5b,
 0x01, 0x61, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xbe, 0x01,
-0xf0, 0x03, 0x63, 0x6c, 0x75, 0x65, 0x73, 0x3b, 0x00, 0x79,
-0x6f, 0x75, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00, 0x69, 0x73,
-0x8c, 0x01, 0x51, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2b, 0x00,
+0xf0, 0x00, 0x63, 0x6c, 0x75, 0x65, 0x73, 0x3b, 0x00, 0x79,
+0x6f, 0x75, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x02, 0x02, 0x81,
+0x74, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2b, 0x00,
 0x4c, 0x72, 0x65, 0x73, 0x74, 0x37, 0x00, 0x90, 0x63, 0x6f,
-0x72, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x66, 0x00, 0x50,
-0x55, 0x6e, 0x64, 0x65, 0x72, 0x1f, 0x00, 0x05, 0xd3, 0x00,
-0x90, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2c,
-0x16, 0x00, 0x09, 0x2d, 0x02, 0x24, 0x72, 0x65, 0x16, 0x02,
+0x72, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x66, 0x00, 0x51,
+0x55, 0x6e, 0x64, 0x65, 0x72, 0x1f, 0x00, 0x04, 0xd3, 0x00,
+0x92, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2c,
+0xd0, 0x00, 0x07, 0x2d, 0x02, 0x24, 0x72, 0x65, 0x16, 0x02,
 0x30, 0x6f, 0x72, 0x00, 0x43, 0x00, 0xa7, 0x61, 0x6e, 0x67,
-0x75, 0x6c, 0x61, 0x72, 0x2e, 0x00, 0x54, 0x40, 0x00, 0x52,
-0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x0c, 0x02, 0x00, 0x8f, 0x00,
-0xf2, 0x02, 0x33, 0x78, 0x33, 0x00, 0x28, 0x61, 0x00, 0x39,
+0x75, 0x6c, 0x61, 0x72, 0x2e, 0x00, 0x54, 0x40, 0x00, 0x53,
+0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x0c, 0x02, 0xf3, 0x05, 0x69,
+0x73, 0x00, 0x33, 0x78, 0x33, 0x00, 0x28, 0x61, 0x00, 0x39,
 0x78, 0x39, 0x00, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x1a,
-0x02, 0x0a, 0xa9, 0x02, 0x41, 0x6e, 0x69, 0x6e, 0x65, 0x2a,
+0x02, 0x09, 0xa9, 0x02, 0x41, 0x6e, 0x69, 0x6e, 0x65, 0x2a,
 0x00, 0x02, 0x6b, 0x00, 0x21, 0x29, 0x2e, 0xfe, 0x00, 0xf1,
 0x00, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00,
-0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x53, 0x00, 0x11, 0x73,
-0x80, 0x02, 0x08, 0x7e, 0x00, 0x13, 0x00, 0x9f, 0x00, 0xa5,
-0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x00, 0x6f, 0x66,
+0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x53, 0x00, 0x12, 0x73,
+0x80, 0x02, 0x07, 0x7e, 0x00, 0x13, 0x00, 0x9f, 0x00, 0x70,
+0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0xee, 0x00, 0x04,
 0xa6, 0x00, 0x43, 0x6e, 0x65, 0x73, 0x2c, 0x80, 0x02, 0x32,
-0x73, 0x00, 0x32, 0x89, 0x00, 0x31, 0x36, 0x78, 0x36, 0x82,
-0x00, 0x0a, 0x81, 0x00, 0x76, 0x73, 0x69, 0x78, 0x00, 0x33,
+0x73, 0x00, 0x32, 0x89, 0x00, 0x32, 0x36, 0x78, 0x36, 0xf0,
+0x02, 0x09, 0x81, 0x00, 0x76, 0x73, 0x69, 0x78, 0x00, 0x33,
 0x78, 0x32, 0x80, 0x00, 0xb0, 0x41, 0x6c, 0x74, 0x65, 0x72,
-0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0xf3, 0x01, 0x12, 0x79,
-0x8f, 0x00, 0x04, 0x8a, 0x00, 0xd0, 0x60, 0x6a, 0x69, 0x67,
+0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0xf3, 0x01, 0x13, 0x79,
+0x8f, 0x00, 0x03, 0x8a, 0x00, 0xd1, 0x60, 0x6a, 0x69, 0x67,
 0x73, 0x61, 0x77, 0x27, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0xe6,
-0x02, 0x02, 0x81, 0x03, 0x0f, 0x32, 0x01, 0x01, 0xe0, 0x61,
+0x02, 0x02, 0x81, 0x03, 0x0f, 0x32, 0x01, 0x00, 0xe0, 0x61,
 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x00, 0x73,
 0x68, 0x61, 0x70, 0xc0, 0x00, 0x21, 0x68, 0x69, 0xe7, 0x01,
 0xf1, 0x00, 0x66, 0x66, 0x65, 0x72, 0x00, 0x62, 0x65, 0x74,
-0x77, 0x65, 0x65, 0x6e, 0x00, 0x69, 0x6e, 0x8f, 0x00, 0x33,
-0x75, 0x61, 0x6c, 0x40, 0x01, 0x10, 0x73, 0x9d, 0x01, 0xf0,
+0x77, 0x65, 0x65, 0x6e, 0x00, 0x69, 0x6e, 0x8f, 0x00, 0x00,
+0x1f, 0x01, 0x02, 0x40, 0x01, 0x10, 0x73, 0x9d, 0x01, 0xf1,
 0x02, 0x41, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x61,
 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x70, 0x00,
-0x01, 0x56, 0x01, 0x20, 0x60, 0x6b, 0x90, 0x03, 0xb2, 0x72,
+0x00, 0x56, 0x01, 0x20, 0x60, 0x6b, 0x90, 0x03, 0xb3, 0x72,
 0x27, 0x2e, 0x00, 0x49, 0x6e, 0x00, 0x74, 0x68, 0x69, 0x73,
-0x8a, 0x00, 0x01, 0x10, 0x02, 0x02, 0x78, 0x00, 0x33, 0x6e,
-0x6f, 0x74, 0x3b, 0x02, 0x21, 0x69, 0x6e, 0x98, 0x00, 0x73,
-0x66, 0x6f, 0x72, 0x6d, 0x00, 0x6f, 0x66, 0xca, 0x03, 0x33,
+0x8a, 0x00, 0x01, 0x10, 0x02, 0x01, 0x78, 0x00, 0x33, 0x6e,
+0x6f, 0x74, 0x3b, 0x02, 0x21, 0x69, 0x6e, 0x98, 0x00, 0x40,
+0x66, 0x6f, 0x72, 0x6d, 0x1d, 0x01, 0x02, 0xca, 0x03, 0x33,
 0x2d, 0x69, 0x6e, 0x27, 0x01, 0x24, 0x73, 0x3b, 0x3b, 0x01,
-0x15, 0x2c, 0xb9, 0x03, 0x0d, 0x4a, 0x04, 0x91, 0x60, 0x63,
+0x16, 0x2c, 0x0d, 0x04, 0x0c, 0x4a, 0x04, 0x91, 0x60, 0x63,
 0x61, 0x67, 0x65, 0x73, 0x27, 0x00, 0x62, 0x7d, 0x03, 0x81,
 0x6f, 0x75, 0x72, 0x65, 0x64, 0x00, 0x6c, 0x69, 0x60, 0x01,
 0x30, 0x61, 0x6e, 0x64, 0x5c, 0x00, 0x02, 0xbe, 0x02, 0x00,
 0x27, 0x00, 0x02, 0x46, 0x00, 0x91, 0x61, 0x6d, 0x65, 0x00,
-0x74, 0x65, 0x6c, 0x6c, 0x73, 0x3c, 0x01, 0x43, 0x77, 0x68,
-0x61, 0x74, 0x1e, 0x01, 0x01, 0x85, 0x00, 0x30, 0x61, 0x6c,
-0x6c, 0x0f, 0x00, 0x02, 0xee, 0x02, 0x00, 0xbc, 0x01, 0x01,
-0x1c, 0x04, 0x02, 0x3f, 0x00, 0x90, 0x73, 0x68, 0x6f, 0x75,
+0x74, 0x65, 0x6c, 0x6c, 0x73, 0x3c, 0x01, 0x10, 0x77, 0xfa,
+0x03, 0x02, 0x1e, 0x01, 0x01, 0x85, 0x00, 0x32, 0x61, 0x6c,
+0x6c, 0x75, 0x02, 0x00, 0xee, 0x02, 0x00, 0xbc, 0x01, 0x02,
+0x1c, 0x04, 0x01, 0x3f, 0x00, 0x90, 0x73, 0x68, 0x6f, 0x75,
 0x6c, 0x64, 0x00, 0x62, 0x65, 0x86, 0x01, 0x63, 0x73, 0x6f,
 0x2c, 0x00, 0x6e, 0x6f, 0xc6, 0x03, 0xe0, 0x6d, 0x61, 0x79,
 0x00, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x00, 0x6d, 0x6f,
-0x72, 0x69, 0x00, 0x71, 0x61, 0x6e, 0x00, 0x6f, 0x6e, 0x63,
-0x65, 0x15, 0x02, 0x41, 0x69, 0x6e, 0x00, 0x61, 0x42, 0x00,
-0x31, 0x2c, 0x00, 0x65, 0xf8, 0x00, 0x01, 0xf7, 0x02, 0x02,
+0x72, 0x69, 0x00, 0x40, 0x61, 0x6e, 0x00, 0x6f, 0x3e, 0x03,
+0x00, 0x15, 0x02, 0x41, 0x69, 0x6e, 0x00, 0x61, 0x42, 0x00,
+0x31, 0x2c, 0x00, 0x65, 0xf8, 0x00, 0x02, 0xf7, 0x02, 0x01,
 0x54, 0x00, 0x62, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x65, 0xee,
 0x04, 0xa1, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x72, 0x69,
 0x65, 0x73, 0x75, 0x03, 0x30, 0x78, 0x69, 0x73, 0xf0, 0x02,
 0x71, 0x00, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x78, 0x01,
-0x20, 0x49, 0x66, 0xb5, 0x00, 0x04, 0xed, 0x01, 0x18, 0x61,
-0xd3, 0x02, 0x03, 0xbf, 0x01, 0x87, 0x72, 0x65, 0x71, 0x75,
-0x69, 0x72, 0x65, 0x73, 0x88, 0x00, 0x12, 0x39, 0xa5, 0x00,
-0x03, 0x38, 0x03, 0x42, 0x61, 0x64, 0x64, 0x69, 0x32, 0x04,
+0x21, 0x49, 0x66, 0xb5, 0x00, 0x03, 0xed, 0x01, 0x19, 0x61,
+0xd3, 0x02, 0x02, 0xbf, 0x01, 0x87, 0x72, 0x65, 0x71, 0x75,
+0x69, 0x72, 0x65, 0x73, 0x88, 0x00, 0x13, 0x39, 0xcd, 0x00,
+0x02, 0x46, 0x01, 0x42, 0x61, 0x64, 0x64, 0x69, 0x32, 0x04,
 0x04, 0xe4, 0x00, 0x40, 0x77, 0x69, 0x6c, 0x6c, 0x4a, 0x05,
-0x74, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x73, 0x96, 0x03,
+0x40, 0x6c, 0x65, 0x74, 0x74, 0x87, 0x03, 0x03, 0x96, 0x03,
 0xb0, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x2e,
 0x00, 0x46, 0x45, 0x01, 0x50, 0x78, 0x61, 0x6d, 0x70, 0x6c,
 0x53, 0x02, 0x09, 0x83, 0x00, 0x30, 0x33, 0x78, 0x34, 0x2d,
-0x00, 0x16, 0x6e, 0x34, 0x01, 0x04, 0x48, 0x02, 0x51, 0x67,
-0x6f, 0x00, 0x69, 0x6e, 0x00, 0x04, 0x01, 0xb9, 0x01, 0x04,
-0x66, 0x00, 0x02, 0x94, 0x05, 0xf1, 0x01, 0x39, 0x2c, 0x00,
+0x00, 0x18, 0x6e, 0x34, 0x01, 0x02, 0x89, 0x00, 0x20, 0x67,
+0x6f, 0x3d, 0x01, 0x01, 0x00, 0x04, 0x01, 0xb9, 0x01, 0x04,
+0x66, 0x00, 0x01, 0x94, 0x05, 0xf1, 0x01, 0x39, 0x2c, 0x00,
 0x70, 0x6c, 0x75, 0x73, 0x00, 0x60, 0x61, 0x27, 0x2c, 0x00,
 0x60, 0x62, 0x27, 0xac, 0x01, 0x30, 0x60, 0x63, 0x27, 0xb1,
-0x03, 0x20, 0x69, 0x73, 0xd1, 0x02, 0x20, 0x6e, 0x6f, 0xde,
-0x05, 0x03, 0x67, 0x00, 0x12, 0x65, 0xc9, 0x01, 0x02, 0x5b,
-0x02, 0x08, 0x88, 0x02, 0xb1, 0x49, 0x00, 0x66, 0x69, 0x72,
-0x73, 0x74, 0x00, 0x73, 0x61, 0x77, 0x6d, 0x02, 0x03, 0x1c,
-0x00, 0x00, 0x7a, 0x00, 0xf2, 0x0a, 0x4e, 0x69, 0x6b, 0x6f,
+0x03, 0x20, 0x69, 0x73, 0xd1, 0x02, 0x21, 0x6e, 0x6f, 0xde,
+0x05, 0x02, 0x67, 0x00, 0x12, 0x65, 0xc9, 0x01, 0x02, 0x5b,
+0x02, 0x08, 0x88, 0x02, 0xb2, 0x49, 0x00, 0x66, 0x69, 0x72,
+0x73, 0x74, 0x00, 0x73, 0x61, 0x77, 0x6d, 0x02, 0x03, 0x11,
+0x01, 0xf2, 0x0d, 0x69, 0x6e, 0x00, 0x4e, 0x69, 0x6b, 0x6f,
 0x6c, 0x69, 0x00, 0x5b, 0x35, 0x5d, 0x2c, 0x00, 0x61, 0x6c,
 0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x69, 0x74, 0x27,
 0x73, 0xba, 0x03, 0x10, 0x62, 0xdd, 0x02, 0x30, 0x70, 0x6f,
 0x70, 0xa9, 0x03, 0x40, 0x69, 0x73, 0x65, 0x64, 0x41, 0x02,
 0xf0, 0x00, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x00,
 0x6e, 0x65, 0x77, 0x73, 0x70, 0x61, 0x70, 0x0c, 0x01, 0x15,
-0x75, 0x86, 0x04, 0x10, 0x6e, 0x38, 0x02, 0xb0, 0x60, 0x53,
-0x75, 0x64, 0x6f, 0x6b, 0x75, 0x27, 0x00, 0x6f, 0x72, 0x0c,
-0x00, 0x20, 0x00, 0x44, 0x0d, 0x00, 0xf1, 0x01, 0x2e, 0x00,
+0x75, 0x86, 0x04, 0x10, 0x6e, 0x38, 0x02, 0x80, 0x60, 0x53,
+0x75, 0x64, 0x6f, 0x6b, 0x75, 0x27, 0x68, 0x04, 0x50, 0x60,
+0x53, 0x75, 0x00, 0x44, 0x0d, 0x00, 0xf1, 0x01, 0x2e, 0x00,
 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x00, 0x47, 0x61, 0x72,
 0x6e, 0x73, 0x00, 0x69, 0x50, 0x05, 0x40, 0x73, 0x69, 0x64,
-0x65, 0x8c, 0x02, 0x20, 0x74, 0x68, 0x8e, 0x00, 0x62, 0x76,
-0x65, 0x6e, 0x74, 0x6f, 0x72, 0x5a, 0x01, 0x02, 0x2c, 0x03,
-0x21, 0x72, 0x6e, 0xf8, 0x02, 0x03, 0x13, 0x00, 0x03, 0xb8,
+0x65, 0x8c, 0x02, 0x20, 0x74, 0x68, 0x8e, 0x00, 0x64, 0x76,
+0x65, 0x6e, 0x74, 0x6f, 0x72, 0x5a, 0x01, 0x00, 0x12, 0x03,
+0x25, 0x72, 0x6e, 0xf8, 0x02, 0x00, 0x13, 0x00, 0x02, 0xb8,
 0x00, 0x02, 0xb4, 0x02, 0x63, 0x69, 0x74, 0x00, 0x77, 0x61,
 0x73, 0xda, 0x00, 0x72, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73,
 0x68, 0xe2, 0x06, 0xd2, 0x44, 0x65, 0x6c, 0x6c, 0x20, 0x50,
@@ -153,233 +153,233 @@ const char help_text[] = {
 0x03, 0x65, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65,
 0x00, 0x74, 0x72, 0x65, 0x61, 0x74, 0x6d, 0x65, 0x6e, 0x6f,
 0x05, 0x7a, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x7b,
-0x00, 0x00, 0x74, 0x01, 0x01, 0x4f, 0x07, 0x00, 0x84, 0x02,
-0xf0, 0x05, 0x00, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6b, 0x69,
-0x70, 0x65, 0x64, 0x69, 0x61, 0x00, 0x5b, 0x36, 0x5d, 0x2e,
-0x00, 0x00, 0x4a, 0x01, 0xd1, 0x00, 0x68, 0x74, 0x74, 0x70,
-0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x60, 0x01,
-0xa3, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65, 0x6e,
-0x2f, 0x96, 0x01, 0x21, 0x2f, 0x73, 0x22, 0x01, 0xc1, 0x2e,
-0x68, 0x74, 0x6d, 0x6c, 0x00, 0x28, 0x62, 0x65, 0x77, 0x61,
-0x72, 0x1f, 0x06, 0x60, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x29,
-0x47, 0x00, 0x15, 0x36, 0x47, 0x00, 0x44, 0x65, 0x6e, 0x2e,
-0x77, 0x66, 0x00, 0x50, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x0e,
-0x00, 0x12, 0x2f, 0x63, 0x01, 0x72, 0x00, 0x00, 0x00, 0x31,
-0x31, 0x2e, 0x31, 0x60, 0x08, 0x00, 0xa0, 0x06, 0x40, 0x72,
-0x6f, 0x6c, 0x73, 0x69, 0x08, 0x11, 0x54, 0x46, 0x06, 0x20,
-0x79, 0x00, 0x19, 0x00, 0xe3, 0x2c, 0x00, 0x73, 0x69, 0x6d,
-0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5c,
-0x01, 0x21, 0x75, 0x73, 0x00, 0x02, 0x01, 0x5f, 0x08, 0x43,
-0x6d, 0x70, 0x74, 0x79, 0x4e, 0x04, 0x00, 0x5b, 0x01, 0x03,
-0xab, 0x02, 0x35, 0x79, 0x70, 0x65, 0x28, 0x08, 0x23, 0x6f,
-0x72, 0xf8, 0x02, 0x22, 0x00, 0x6f, 0xc5, 0x02, 0x50, 0x6b,
-0x65, 0x79, 0x62, 0x6f, 0xce, 0x01, 0x21, 0x74, 0x6f, 0x92,
-0x04, 0x01, 0x00, 0x04, 0x03, 0x44, 0x00, 0x14, 0x2e, 0x81,
-0x03, 0x30, 0x6d, 0x61, 0x6b, 0x43, 0x00, 0x8f, 0x6d, 0x69,
-0x73, 0x74, 0x61, 0x6b, 0x65, 0x2c, 0x80, 0x00, 0x00, 0x03,
-0xf9, 0x01, 0x03, 0xd3, 0x06, 0x08, 0x84, 0x00, 0x81, 0x70,
-0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x0a, 0x07, 0x70,
-0x6f, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0xf4, 0x01, 0x20,
-0x61, 0x67, 0x95, 0x07, 0x61, 0x28, 0x6f, 0x72, 0x00, 0x75,
-0x73, 0xab, 0x04, 0x00, 0x03, 0x07, 0xa7, 0x6f, 0x00, 0x66,
-0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0xff, 0x03, 0x61,
-0x72, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x74, 0x00, 0x01, 0xea,
-0x00, 0x0f, 0xe2, 0x00, 0x04, 0x03, 0x58, 0x07, 0x11, 0x2c,
-0xc2, 0x00, 0x03, 0x0d, 0x00, 0x05, 0x87, 0x03, 0x51, 0x65,
-0x6e, 0x74, 0x65, 0x72, 0x56, 0x02, 0x07, 0x1e, 0x08, 0x00,
-0x8e, 0x06, 0x41, 0x61, 0x00, 0x60, 0x70, 0x62, 0x02, 0x65,
-0x00, 0x6d, 0x61, 0x72, 0x6b, 0x27, 0xf1, 0x06, 0x02, 0xde,
-0x09, 0x07, 0x1b, 0x00, 0x11, 0x73, 0x94, 0x03, 0x75, 0x6d,
-0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0xc5, 0x07, 0x05, 0x51,
-0x00, 0x35, 0x61, 0x6d, 0x65, 0x36, 0x01, 0x11, 0x53, 0x08,
-0x00, 0x05, 0x68, 0x08, 0x36, 0x69, 0x6e, 0x67, 0xed, 0x05,
-0x03, 0x39, 0x00, 0x04, 0xf5, 0x03, 0x01, 0x9e, 0x03, 0x04,
-0x29, 0x00, 0x09, 0x6f, 0x00, 0x10, 0x2e, 0xfd, 0x01, 0x04,
-0xc1, 0x05, 0x40, 0x70, 0x61, 0x79, 0x73, 0x7f, 0x05, 0x70,
-0x61, 0x74, 0x74, 0x65, 0x6e, 0x74, 0x69, 0xbc, 0x01, 0x18,
-0x6f, 0x2e, 0x00, 0x00, 0x5f, 0x07, 0x10, 0x6f, 0xb5, 0x04,
-0x00, 0x4f, 0x08, 0x01, 0xe5, 0x05, 0x00, 0x3a, 0x01, 0x04,
-0x5a, 0x01, 0x10, 0x6d, 0xbb, 0x00, 0x00, 0xa9, 0x03, 0x50,
-0x75, 0x70, 0x00, 0x74, 0x6f, 0x1a, 0x00, 0x14, 0x3a, 0x49,
-0x07, 0x06, 0x23, 0x00, 0x00, 0x76, 0x0a, 0x30, 0x65, 0x6d,
-0x69, 0x01, 0x04, 0x10, 0x73, 0x43, 0x01, 0x01, 0x70, 0x05,
-0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x34, 0x04, 0x04, 0x32,
-0x01, 0x41, 0x6e, 0x65, 0x65, 0x64, 0xdb, 0x08, 0x10, 0x62,
-0xd4, 0x08, 0x10, 0x2d, 0x27, 0x05, 0x41, 0x69, 0x6e, 0x65,
-0x64, 0xfd, 0x05, 0x01, 0x54, 0x00, 0x42, 0x6b, 0x6e, 0x6f,
-0x77, 0x93, 0x03, 0x4a, 0x61, 0x62, 0x6f, 0x75, 0x45, 0x00,
-0x05, 0xa2, 0x01, 0x2f, 0x6f, 0x72, 0x80, 0x00, 0x02, 0x55,
-0x6c, 0x69, 0x73, 0x74, 0x73, 0xa8, 0x03, 0x5a, 0x6f, 0x73,
-0x73, 0x69, 0x62, 0x6a, 0x01, 0x11, 0x61, 0x4a, 0x07, 0x04,
-0x31, 0x07, 0x00, 0x48, 0x00, 0x00, 0xf8, 0x02, 0x20, 0x74,
-0x68, 0x62, 0x01, 0x32, 0x65, 0x6c, 0x73, 0x82, 0x00, 0xa2,
-0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x2e,
-0x3f, 0x03, 0x41, 0x65, 0x72, 0x61, 0x73, 0xa8, 0x0b, 0x49,
-0x69, 0x6e, 0x67, 0x6c, 0xd3, 0x01, 0x18, 0x2c, 0x5b, 0x02,
-0x0c, 0x1b, 0x02, 0x21, 0x6e, 0x64, 0x58, 0x02, 0x04, 0xde,
-0x01, 0x04, 0x88, 0x00, 0x02, 0xb8, 0x02, 0x01, 0x15, 0x08,
-0x29, 0x6c, 0x6c, 0x83, 0x01, 0x0a, 0x9c, 0x02, 0x22, 0x72,
-0x65, 0x79, 0x00, 0x61, 0x64, 0x00, 0x77, 0x68, 0x65, 0x6e,
-0x99, 0x00, 0x33, 0x6c, 0x65, 0x66, 0x6c, 0x00, 0x06, 0x5e,
-0x00, 0x17, 0x61, 0x14, 0x01, 0x0f, 0x2a, 0x00, 0x01, 0x07,
-0x43, 0x03, 0x10, 0x73, 0x43, 0x03, 0x36, 0x2e, 0x00, 0x52,
-0xb3, 0x00, 0x35, 0x69, 0x6e, 0x67, 0x20, 0x00, 0x00, 0xde,
-0x00, 0x02, 0x23, 0x00, 0x01, 0xf4, 0x02, 0x00, 0x58, 0x02,
-0x03, 0xfb, 0x00, 0x0c, 0x56, 0x02, 0x0b, 0x53, 0x09, 0x05,
-0x7f, 0x03, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x11,
-0x04, 0x01, 0xe1, 0x01, 0x31, 0x6d, 0x6f, 0x76, 0x18, 0x00,
-0x01, 0x38, 0x00, 0x30, 0x00, 0x61, 0x72, 0x29, 0x05, 0x05,
-0x98, 0x08, 0x33, 0x2e, 0x00, 0x50, 0x74, 0x00, 0x03, 0xde,
-0x0a, 0x40, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x00, 0x86, 0x00,
-0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x73, 0x3a, 0x00, 0x10,
-0x28, 0x9b, 0x0c, 0x00, 0xe8, 0x00, 0x52, 0x6f, 0x72, 0x6d,
-0x61, 0x6c, 0x14, 0x00, 0x00, 0x13, 0x0d, 0x08, 0x97, 0x00,
-0x24, 0x29, 0x2c, 0x12, 0x01, 0x35, 0x69, 0x6e, 0x67, 0x14,
-0x01, 0x00, 0x51, 0x01, 0x2f, 0x69, 0x73, 0xbb, 0x03, 0x02,
-0x04, 0x73, 0x04, 0x00, 0x86, 0x08, 0x80, 0x72, 0x6f, 0x70,
-0x72, 0x69, 0x61, 0x74, 0x65, 0xda, 0x0c, 0x13, 0x3b, 0x44,
-0x00, 0x02, 0x8c, 0x01, 0x20, 0x30, 0x00, 0x5e, 0x04, 0x04,
-0xa6, 0x00, 0x03, 0x1e, 0x01, 0x22, 0x62, 0x61, 0x16, 0x04,
-0x03, 0x8a, 0x04, 0x13, 0x61, 0x9b, 0x03, 0x05, 0xbd, 0x03,
-0x42, 0x00, 0x00, 0x28, 0x41, 0x15, 0x09, 0x00, 0x28, 0x0b,
-0x00, 0x8a, 0x08, 0x82, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72,
-0x69, 0x62, 0x84, 0x00, 0x31, 0x73, 0x65, 0x63, 0x81, 0x03,
-0x30, 0x32, 0x2e, 0x31, 0xe6, 0x01, 0x01, 0x69, 0x01, 0x06,
-0x19, 0x0a, 0x22, 0x2e, 0x29, 0xca, 0x05, 0x12, 0x32, 0xca,
-0x05, 0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
-0x72, 0xcc, 0x05, 0x01, 0xc4, 0x05, 0x00, 0x72, 0x09, 0x22,
-0x6f, 0x77, 0x8d, 0x09, 0x11, 0x74, 0xfa, 0x03, 0x40, 0x66,
-0x69, 0x67, 0x75, 0xbc, 0x08, 0x10, 0x77, 0x60, 0x0b, 0x00,
-0x31, 0x00, 0x10, 0x74, 0x5b, 0x08, 0x40, 0x6d, 0x65, 0x6e,
-0x73, 0x7d, 0x00, 0x09, 0xb7, 0x06, 0x02, 0x7d, 0x01, 0x04,
-0xbb, 0x05, 0xc6, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
-0x6d, 0x65, 0x6e, 0x75, 0x3a, 0x59, 0x0c, 0x00, 0x77, 0x07,
-0x03, 0x99, 0x0d, 0x02, 0x15, 0x0a, 0x0a, 0x1b, 0x00, 0x01,
-0x5b, 0x0e, 0x11, 0x2c, 0x4d, 0x0a, 0x06, 0x2c, 0x0b, 0x01,
-0x21, 0x0d, 0x0c, 0x71, 0x0a, 0x47, 0x2e, 0x00, 0x28, 0x54,
-0x4c, 0x0e, 0x13, 0x61, 0xb2, 0x0d, 0x25, 0x69, 0x73, 0xe5,
-0x07, 0x23, 0x72, 0x73, 0x0b, 0x0d, 0x5f, 0x69, 0x73, 0x3a,
-0x00, 0x66, 0x36, 0x09, 0x07, 0x14, 0x32, 0x90, 0x00, 0x01,
-0x8f, 0x00, 0x12, 0x33, 0x83, 0x00, 0x01, 0xa8, 0x0a, 0x03,
-0x8b, 0x0c, 0x02, 0x5b, 0x00, 0x01, 0x97, 0x01, 0x02, 0x78,
-0x05, 0x19, 0x33, 0x32, 0x00, 0x12, 0x32, 0x10, 0x0f, 0x16,
-0x29, 0x13, 0x06, 0x14, 0x74, 0x80, 0x06, 0xd1, 0x60, 0x58,
-0x27, 0x00, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x62, 0x6f, 0x78,
-0x2c, 0x61, 0x01, 0x03, 0xff, 0x02, 0x41, 0x70, 0x70, 0x6c,
-0x79, 0x22, 0x00, 0x04, 0x31, 0x0e, 0x61, 0x00, 0x65, 0x78,
-0x74, 0x72, 0x61, 0xac, 0x08, 0x84, 0x74, 0x72, 0x61, 0x69,
-0x6e, 0x74, 0x00, 0x74, 0x0c, 0x0b, 0x0e, 0x23, 0x0e, 0x08,
-0x3d, 0x0f, 0x09, 0xa3, 0x05, 0x02, 0x2e, 0x0e, 0x12, 0x66,
-0xc4, 0x0e, 0x04, 0x24, 0x0e, 0x11, 0x28, 0xc6, 0x09, 0x21,
-0x69, 0x73, 0x1d, 0x0e, 0x51, 0x74, 0x69, 0x6d, 0x65, 0x73,
-0x07, 0x05, 0x44, 0x6e, 0x00, 0x61, 0x73, 0x43, 0x09, 0x67,
-0x2d, 0x58, 0x27, 0x00, 0x69, 0x6e, 0x6b, 0x09, 0x2a, 0x2e,
-0x29, 0x32, 0x0c, 0x07, 0xdc, 0x02, 0x00, 0x98, 0x0e, 0x0f,
-0x98, 0x00, 0x03, 0x05, 0xbd, 0x0a, 0x00, 0xc4, 0x0c, 0x10,
-0x64, 0xb5, 0x02, 0x10, 0x6c, 0x0e, 0x04, 0x00, 0x52, 0x10,
-0x11, 0x6f, 0xcf, 0x00, 0x05, 0x83, 0x05, 0x02, 0xfb, 0x09,
-0x20, 0x65, 0x6e, 0x94, 0x02, 0x2f, 0x64, 0x2e, 0x39, 0x01,
-0x01, 0x11, 0x4a, 0x3a, 0x0d, 0x0f, 0x3e, 0x01, 0x03, 0x41,
-0x67, 0x65, 0x6e, 0x65, 0x88, 0x02, 0x72, 0x72, 0x61, 0x6e,
-0x64, 0x6f, 0x6d, 0x6c, 0x34, 0x0d, 0x09, 0xb3, 0x10, 0x1e,
-0x2e, 0xbf, 0x00, 0x08, 0x58, 0x0e, 0x01, 0x37, 0x02, 0x05,
-0xae, 0x00, 0x00, 0x36, 0x08, 0x12, 0x6e, 0x36, 0x06, 0x02,
-0xcd, 0x02, 0x5b, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x11, 0x0f,
-0x0d, 0xea, 0x03, 0x22, 0x60, 0x43, 0x04, 0x02, 0x03, 0x2f,
-0x0b, 0x30, 0x52, 0x6f, 0x77, 0xf9, 0x0c, 0x41, 0x6f, 0x78,
-0x65, 0x73, 0xe9, 0x0e, 0x00, 0x05, 0x04, 0x01, 0x15, 0x07,
-0x50, 0x72, 0x65, 0x61, 0x73, 0x6f, 0xfa, 0x0d, 0x34, 0x79,
-0x00, 0x79, 0x97, 0x11, 0x22, 0x74, 0x6f, 0x4e, 0x00, 0x06,
-0x4d, 0x04, 0x10, 0x67, 0x18, 0x0a, 0x22, 0x65, 0x72, 0x24,
-0x0c, 0x10, 0x31, 0x64, 0x00, 0x42, 0x62, 0x6f, 0x74, 0x68,
-0x50, 0x00, 0x22, 0x3b, 0x00, 0x0e, 0x01, 0x02, 0xd7, 0x0d,
-0x20, 0x68, 0x61, 0x57, 0x00, 0x07, 0x2a, 0x02, 0x03, 0x90,
-0x01, 0x05, 0xd9, 0x00, 0x05, 0xb9, 0x0a, 0x00, 0xc2, 0x06,
-0x02, 0xe4, 0x0c, 0x20, 0x62, 0x65, 0xd2, 0x04, 0x26, 0x72,
-0x69, 0x28, 0x06, 0x2a, 0x69, 0x66, 0x8e, 0x06, 0x3f, 0x00,
-0x69, 0x74, 0x88, 0x01, 0x02, 0x11, 0x4b, 0xe6, 0x0b, 0x0f,
-0x88, 0x01, 0x0a, 0x01, 0xbe, 0x06, 0x10, 0x65, 0x2f, 0x01,
-0x00, 0x03, 0x00, 0x01, 0x02, 0x0e, 0x04, 0x6a, 0x12, 0x2d,
-0x61, 0x72, 0xa5, 0x01, 0x01, 0x9c, 0x00, 0x41, 0x64, 0x72,
-0x61, 0x77, 0x72, 0x0e, 0x00, 0x99, 0x0d, 0x52, 0x75, 0x74,
-0x6c, 0x69, 0x6e, 0xc5, 0x03, 0x03, 0xf0, 0x0e, 0x33, 0x65,
-0x6e, 0x74, 0x40, 0x0e, 0x36, 0x2e, 0x00, 0x45, 0x36, 0x11,
-0x23, 0x73, 0x65, 0x7e, 0x0d, 0x06, 0x24, 0x11, 0x00, 0x7b,
-0x00, 0x20, 0x6d, 0x61, 0xa3, 0x00, 0x00, 0xd4, 0x0e, 0x03,
-0x77, 0x0d, 0x00, 0x1b, 0x0e, 0x26, 0x77, 0x73, 0x05, 0x0d,
-0x07, 0x4e, 0x0e, 0x09, 0xc8, 0x02, 0x12, 0x69, 0x23, 0x02,
-0x02, 0x55, 0x00, 0x00, 0x35, 0x07, 0x08, 0x4f, 0x10, 0x09,
-0xfd, 0x04, 0x21, 0x68, 0x65, 0x10, 0x07, 0x01, 0x35, 0x10,
-0x71, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x65, 0x00,
-0x04, 0x36, 0x0f, 0x05, 0x0b, 0x01, 0x16, 0x64, 0x10, 0x0d,
-0x45, 0x4d, 0x6f, 0x72, 0x65, 0x2e, 0x00, 0x01, 0xa4, 0x0a,
-0x17, 0x73, 0x2b, 0x05, 0x90, 0x73, 0x00, 0x6c, 0x6f, 0x6f,
-0x6b, 0x00, 0x70, 0x72, 0x47, 0x11, 0x00, 0xe2, 0x0f, 0x11,
-0x75, 0xb8, 0x0e, 0x01, 0x7a, 0x00, 0x00, 0x2d, 0x00, 0x03,
-0x77, 0x08, 0x70, 0x65, 0x61, 0x73, 0x69, 0x65, 0x72, 0x2c,
-0x1e, 0x08, 0x01, 0xab, 0x11, 0x06, 0x52, 0x00, 0x07, 0x01,
-0x02, 0x00, 0xae, 0x09, 0x01, 0xc1, 0x0c, 0x21, 0x63, 0x65,
-0xdc, 0x08, 0x02, 0xdf, 0x0f, 0x02, 0x4b, 0x02, 0x92, 0x6e,
-0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0xe0, 0x02,
-0x01, 0x8d, 0x07, 0x70, 0x65, 0x6e, 0x74, 0x2e, 0x00, 0x43,
-0x6f, 0x0c, 0x05, 0x63, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x61,
-0x54, 0x00, 0x24, 0x69, 0x63, 0x9d, 0x00, 0x01, 0xa6, 0x02,
-0x02, 0x0f, 0x10, 0x86, 0x72, 0x65, 0x65, 0x64, 0x6f, 0x6d,
-0x00, 0x74, 0x64, 0x04, 0x00, 0x0e, 0x0d, 0x24, 0x65, 0x77,
-0x44, 0x10, 0x14, 0x73, 0x0b, 0x09, 0x01, 0x9d, 0x06, 0x57,
-0x46, 0x69, 0x6e, 0x61, 0x6c, 0x0a, 0x11, 0x0a, 0x45, 0x01,
-0x01, 0xdf, 0x01, 0x00, 0x6d, 0x09, 0x10, 0x74, 0xf0, 0x0c,
-0x0f, 0x39, 0x01, 0x05, 0x16, 0x44, 0x25, 0x00, 0x52, 0x6c,
-0x65, 0x76, 0x65, 0x6c, 0xa9, 0x10, 0x41, 0x6a, 0x75, 0x64,
-0x67, 0x19, 0x0e, 0x02, 0x0e, 0x08, 0x01, 0xbe, 0x00, 0x26,
-0x78, 0x69, 0x49, 0x00, 0x82, 0x74, 0x65, 0x63, 0x68, 0x6e,
-0x69, 0x71, 0x75, 0xaf, 0x0f, 0x41, 0x64, 0x65, 0x64, 0x75,
-0x09, 0x07, 0x04, 0x83, 0x0f, 0x01, 0x42, 0x0c, 0x57, 0x73,
-0x6f, 0x6c, 0x76, 0x65, 0x85, 0x01, 0x11, 0x3a, 0xe6, 0x05,
-0x02, 0x66, 0x00, 0x06, 0xac, 0x0f, 0x12, 0x61, 0x68, 0x03,
-0x22, 0x6f, 0x66, 0xbb, 0x03, 0x00, 0x21, 0x0b, 0x03, 0x58,
-0x02, 0x11, 0x77, 0x7b, 0x03, 0x16, 0x74, 0x55, 0x01, 0x02,
-0xff, 0x01, 0x01, 0x56, 0x01, 0x10, 0x76, 0xad, 0x0e, 0x00,
-0x80, 0x05, 0x00, 0x7b, 0x04, 0x07, 0x56, 0x0a, 0x10, 0x2c,
-0x9f, 0x03, 0x1d, 0x64, 0xd3, 0x00, 0x83, 0x60, 0x54, 0x72,
-0x69, 0x76, 0x69, 0x61, 0x6c, 0x3e, 0x04, 0x70, 0x42, 0x61,
-0x73, 0x69, 0x63, 0x27, 0x00, 0xc7, 0x11, 0x04, 0x98, 0x04,
-0x06, 0xbd, 0x15, 0x04, 0x4d, 0x01, 0x01, 0x0c, 0x08, 0x04,
-0x5c, 0x15, 0x04, 0x33, 0x0a, 0x06, 0xfa, 0x09, 0x12, 0x74,
-0xe1, 0x02, 0x22, 0x69, 0x6d, 0x80, 0x03, 0x10, 0x65, 0xbe,
-0x00, 0x00, 0x16, 0x00, 0x20, 0x60, 0x49, 0x6b, 0x04, 0x30,
-0x6d, 0x65, 0x64, 0x87, 0x08, 0x13, 0x27, 0xee, 0x00, 0x20,
-0x61, 0x6e, 0x3b, 0x11, 0x40, 0x79, 0x6f, 0x6e, 0x64, 0x5e,
-0x00, 0x07, 0xdc, 0x06, 0x12, 0x74, 0x7f, 0x02, 0x02, 0xc2,
-0x00, 0x26, 0x61, 0x6c, 0x4a, 0x01, 0x11, 0x73, 0x33, 0x0b,
-0x01, 0x93, 0x06, 0x03, 0xef, 0x03, 0x04, 0x49, 0x03, 0x06,
-0xc6, 0x04, 0x13, 0x63, 0x93, 0x11, 0x12, 0x00, 0x3c, 0x0d,
-0x07, 0x2c, 0x00, 0x01, 0x22, 0x00, 0x04, 0xbc, 0x0b, 0x05,
-0x28, 0x00, 0x08, 0x95, 0x0a, 0x00, 0x4e, 0x13, 0x51, 0x74,
-0x00, 0x60, 0x55, 0x6e, 0x76, 0x01, 0x00, 0x1b, 0x06, 0x04,
-0xad, 0x00, 0x03, 0xa9, 0x11, 0x11, 0x74, 0xc7, 0x06, 0x02,
-0x82, 0x01, 0x20, 0x65, 0x6e, 0x42, 0x10, 0x38, 0x2c, 0x00,
-0x61, 0xc0, 0x00, 0x10, 0x65, 0xd9, 0x0f, 0x01, 0xc3, 0x16,
-0x09, 0xcb, 0x00, 0x00, 0x98, 0x0b, 0x35, 0x75, 0x65, 0x73,
-0x6f, 0x08, 0x00, 0x10, 0x05, 0x60, 0x61, 0x63, 0x6b, 0x74,
-0x72, 0x61, 0x30, 0x08, 0x10, 0x66, 0x29, 0x05, 0x00, 0x20,
-0x0a, 0x10, 0x73, 0x8a, 0x04, 0x03, 0x26, 0x03, 0x50, 0x77,
-0x72, 0x6f, 0x6e, 0x67, 0xd0, 0x02, 0x11, 0x47, 0x9f, 0x02,
-0x00, 0xf9, 0x11, 0x06, 0xc4, 0x01, 0x05, 0x25, 0x03, 0x00,
-0x8f, 0x00, 0x56, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x1c, 0x00,
-0x1a, 0x3a, 0x5c, 0x08, 0x00, 0x10, 0x02, 0x06, 0xe9, 0x0f,
-0x4e, 0x67, 0x68, 0x65, 0x72, 0x0b, 0x02, 0x03, 0x52, 0x05,
-0x2a, 0x6d, 0x61, 0xb6, 0x00, 0x01, 0x93, 0x17, 0x00, 0x52,
-0x0d, 0x00, 0x37, 0x0f, 0x01, 0xc8, 0x01, 0x15, 0x67, 0x8c,
-0x00, 0x06, 0x6c, 0x12, 0x30, 0x62, 0x65, 0x66, 0xf1, 0x03,
-0x00, 0x63, 0x17, 0x30, 0x69, 0x6e, 0x64, 0x80, 0x02, 0x00,
-0x21, 0x06, 0x23, 0x72, 0x64, 0x21, 0x01, 0x22, 0x00, 0x66,
-0xcc, 0x0c, 0x31, 0x2e, 0x00, 0x42, 0xa5, 0x02, 0x23, 0x70,
-0x61, 0x0a, 0x03, 0xc1, 0x77, 0x61, 0x69, 0x74, 0x2c, 0x00,
-0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x31, 0x01, 0x25, 0x69,
-0x66, 0x9e, 0x06, 0x0a, 0xfe, 0x04, 0x00, 0xb2, 0x05, 0x65,
-0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0xe0, 0x12, 0x50, 0x69,
-0x7a, 0x65, 0x2e, 0x00,
+0x00, 0x01, 0x45, 0x04, 0x00, 0x4f, 0x07, 0x00, 0x84, 0x02,
+0xf0, 0x02, 0x00, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6b, 0x69,
+0x70, 0x65, 0x64, 0x69, 0x61, 0x00, 0x5b, 0x36, 0x5d, 0x6c,
+0x01, 0xf1, 0x01, 0x5b, 0x35, 0x5d, 0x00, 0x68, 0x74, 0x74,
+0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x6e, 0x60,
+0x01, 0xa3, 0x2e, 0x63, 0x6f, 0x2e, 0x6a, 0x70, 0x2f, 0x65,
+0x6e, 0x2f, 0x96, 0x01, 0x21, 0x2f, 0x73, 0x22, 0x01, 0xc1,
+0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x28, 0x62, 0x65, 0x77,
+0x61, 0x72, 0x1f, 0x06, 0x60, 0x46, 0x6c, 0x61, 0x73, 0x68,
+0x29, 0x47, 0x00, 0x15, 0x36, 0x47, 0x00, 0x44, 0x65, 0x6e,
+0x2e, 0x77, 0x66, 0x00, 0x50, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+0x0e, 0x00, 0x12, 0x2f, 0x63, 0x01, 0x72, 0x00, 0x00, 0x00,
+0x31, 0x31, 0x2e, 0x31, 0x60, 0x08, 0x00, 0xa0, 0x06, 0x40,
+0x72, 0x6f, 0x6c, 0x73, 0x69, 0x08, 0x11, 0x54, 0x46, 0x06,
+0x20, 0x79, 0x00, 0x19, 0x00, 0xe3, 0x2c, 0x00, 0x73, 0x69,
+0x6d, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b,
+0x5c, 0x01, 0x21, 0x75, 0x73, 0x00, 0x02, 0x01, 0x5f, 0x08,
+0x44, 0x6d, 0x70, 0x74, 0x79, 0x75, 0x05, 0x00, 0x5b, 0x01,
+0x02, 0xab, 0x02, 0x35, 0x79, 0x70, 0x65, 0x28, 0x08, 0x23,
+0x6f, 0x72, 0xf8, 0x02, 0x22, 0x00, 0x6f, 0xc5, 0x02, 0x50,
+0x6b, 0x65, 0x79, 0x62, 0x6f, 0xce, 0x01, 0x21, 0x74, 0x6f,
+0x92, 0x04, 0x02, 0x00, 0x04, 0x02, 0x44, 0x00, 0x14, 0x2e,
+0x81, 0x03, 0x30, 0x6d, 0x61, 0x6b, 0x43, 0x00, 0x8f, 0x6d,
+0x69, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x2c, 0x80, 0x00, 0x01,
+0x02, 0xf9, 0x01, 0x03, 0xd3, 0x06, 0x08, 0x84, 0x00, 0x81,
+0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x0a, 0x07,
+0x40, 0x6f, 0x00, 0x63, 0x6c, 0x36, 0x04, 0x50, 0x69, 0x74,
+0x00, 0x61, 0x67, 0x95, 0x07, 0x62, 0x28, 0x6f, 0x72, 0x00,
+0x75, 0x73, 0xab, 0x04, 0xd7, 0x55, 0x6e, 0x64, 0x6f, 0x00,
+0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0xff, 0x03,
+0x62, 0x72, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x74, 0x00, 0x01,
+0x5c, 0x04, 0x0f, 0xe2, 0x00, 0x04, 0x02, 0x58, 0x07, 0x12,
+0x2c, 0xc2, 0x00, 0x02, 0x0d, 0x00, 0x05, 0x87, 0x03, 0x52,
+0x65, 0x6e, 0x74, 0x65, 0x72, 0x56, 0x02, 0x06, 0x1e, 0x08,
+0x00, 0x8e, 0x06, 0x41, 0x61, 0x00, 0x60, 0x70, 0x62, 0x02,
+0x66, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x27, 0xf1, 0x06, 0x01,
+0xde, 0x09, 0x07, 0x1b, 0x00, 0x11, 0x73, 0x94, 0x03, 0x76,
+0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0xc5, 0x07, 0x04,
+0x51, 0x00, 0x00, 0x2f, 0x03, 0x04, 0x36, 0x01, 0x12, 0x53,
+0xd0, 0x05, 0x04, 0x68, 0x08, 0x00, 0xd5, 0x04, 0x06, 0xed,
+0x05, 0x05, 0xfe, 0x07, 0x02, 0xf5, 0x03, 0x01, 0x9e, 0x03,
+0x03, 0x29, 0x00, 0x09, 0x6f, 0x00, 0x10, 0x2e, 0xfd, 0x01,
+0x04, 0xc1, 0x05, 0x40, 0x70, 0x61, 0x79, 0x73, 0x7f, 0x05,
+0x50, 0x61, 0x74, 0x74, 0x65, 0x6e, 0xcf, 0x04, 0x01, 0x5e,
+0x08, 0x07, 0x2e, 0x00, 0x40, 0x2c, 0x00, 0x73, 0x6f, 0xb5,
+0x04, 0x00, 0x4f, 0x08, 0x02, 0xe5, 0x05, 0x00, 0x3a, 0x01,
+0x03, 0x5a, 0x01, 0x11, 0x6d, 0xbb, 0x00, 0x50, 0x69, 0x73,
+0x00, 0x75, 0x70, 0x38, 0x00, 0x45, 0x79, 0x6f, 0x75, 0x3a,
+0x49, 0x07, 0x05, 0x23, 0x00, 0x00, 0x76, 0x0a, 0x30, 0x65,
+0x6d, 0x69, 0x01, 0x04, 0x12, 0x73, 0x43, 0x01, 0x81, 0x61,
+0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0xdd, 0x07, 0x03,
+0x32, 0x01, 0x41, 0x6e, 0x65, 0x65, 0x64, 0xdb, 0x08, 0x10,
+0x62, 0xd4, 0x08, 0x10, 0x2d, 0x27, 0x05, 0x42, 0x69, 0x6e,
+0x65, 0x64, 0xfd, 0x05, 0x00, 0x54, 0x00, 0x42, 0x6b, 0x6e,
+0x6f, 0x77, 0x93, 0x03, 0x4b, 0x61, 0x62, 0x6f, 0x75, 0x45,
+0x00, 0x04, 0xa2, 0x01, 0x2f, 0x6f, 0x72, 0x80, 0x00, 0x02,
+0x55, 0x6c, 0x69, 0x73, 0x74, 0x73, 0xa8, 0x03, 0x5a, 0x6f,
+0x73, 0x73, 0x69, 0x62, 0x6a, 0x01, 0x14, 0x61, 0x85, 0x09,
+0x01, 0x8d, 0x00, 0x01, 0x48, 0x00, 0x50, 0x61, 0x6e, 0x79,
+0x74, 0x68, 0x62, 0x01, 0x32, 0x65, 0x6c, 0x73, 0x82, 0x00,
+0xa2, 0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69, 0x6b, 0x65,
+0x2e, 0x3f, 0x03, 0x41, 0x65, 0x72, 0x61, 0x73, 0xa8, 0x0b,
+0x49, 0x69, 0x6e, 0x67, 0x6c, 0xd3, 0x01, 0x1c, 0x2c, 0x5b,
+0x02, 0x08, 0x1b, 0x02, 0x22, 0x6e, 0x64, 0x58, 0x02, 0x05,
+0xde, 0x01, 0x03, 0x52, 0x02, 0x01, 0xb8, 0x02, 0x01, 0x15,
+0x08, 0x2a, 0x6c, 0x6c, 0x20, 0x02, 0x09, 0x9c, 0x02, 0x22,
+0x72, 0x65, 0x79, 0x00, 0x30, 0x64, 0x00, 0x77, 0xa3, 0x02,
+0x00, 0x99, 0x00, 0x34, 0x6c, 0x65, 0x66, 0x6c, 0x00, 0x05,
+0x5e, 0x00, 0x18, 0x61, 0x14, 0x01, 0x0f, 0x2a, 0x00, 0x05,
+0x02, 0x43, 0x03, 0x10, 0x73, 0x43, 0x03, 0x36, 0x2e, 0x00,
+0x52, 0xb3, 0x00, 0x00, 0xf7, 0x00, 0x05, 0x20, 0x00, 0x00,
+0x0d, 0x00, 0x01, 0x23, 0x00, 0x02, 0xf4, 0x02, 0x01, 0x58,
+0x02, 0x02, 0xfb, 0x00, 0x0c, 0x56, 0x02, 0x0b, 0x53, 0x09,
+0x04, 0x7f, 0x03, 0x60, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
+0x11, 0x04, 0x01, 0xe1, 0x01, 0x32, 0x6d, 0x6f, 0x76, 0x18,
+0x00, 0x00, 0x38, 0x00, 0x31, 0x00, 0x61, 0x72, 0x29, 0x05,
+0x04, 0x98, 0x08, 0x34, 0x2e, 0x00, 0x50, 0x74, 0x00, 0x02,
+0xde, 0x0a, 0x40, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x00, 0x86,
+0x00, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x73, 0x3a, 0x00,
+0x11, 0x28, 0x9b, 0x0c, 0x82, 0x61, 0x00, 0x6e, 0x6f, 0x72,
+0x6d, 0x61, 0x6c, 0x14, 0x00, 0x00, 0x13, 0x0d, 0x08, 0x97,
+0x00, 0x24, 0x29, 0x2c, 0x12, 0x01, 0x01, 0xd3, 0x00, 0x04,
+0x6b, 0x01, 0x20, 0x69, 0x6e, 0xb5, 0x02, 0x0f, 0xbb, 0x03,
+0x03, 0x03, 0x0e, 0x00, 0x80, 0x61, 0x70, 0x70, 0x72, 0x6f,
+0x70, 0x72, 0x69, 0xfa, 0x05, 0x44, 0x77, 0x61, 0x79, 0x3b,
+0x44, 0x00, 0x01, 0x8c, 0x01, 0x21, 0x30, 0x00, 0x5e, 0x04,
+0x04, 0xa6, 0x00, 0x02, 0x1e, 0x01, 0x23, 0x62, 0x61, 0x16,
+0x04, 0x02, 0x8a, 0x04, 0x14, 0x61, 0x52, 0x0d, 0x04, 0xbd,
+0x03, 0x43, 0x00, 0x00, 0x28, 0x41, 0x15, 0x09, 0x30, 0x61,
+0x63, 0x74, 0x8a, 0x08, 0x82, 0x00, 0x64, 0x65, 0x73, 0x63,
+0x72, 0x69, 0x62, 0x84, 0x00, 0x31, 0x73, 0x65, 0x63, 0x81,
+0x03, 0x32, 0x32, 0x2e, 0x31, 0x58, 0x0a, 0x00, 0x69, 0x01,
+0x05, 0x19, 0x0a, 0x22, 0x2e, 0x29, 0xca, 0x05, 0x12, 0x32,
+0xca, 0x05, 0x60, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x67,
+0x08, 0x00, 0xcc, 0x05, 0x00, 0x13, 0x00, 0x00, 0x72, 0x09,
+0x22, 0x6f, 0x77, 0x8d, 0x09, 0x11, 0x74, 0xfa, 0x03, 0x40,
+0x66, 0x69, 0x67, 0x75, 0xbc, 0x08, 0x10, 0x77, 0x60, 0x0b,
+0x00, 0x31, 0x00, 0x10, 0x74, 0x5b, 0x08, 0x41, 0x6d, 0x65,
+0x6e, 0x73, 0x7d, 0x00, 0x0a, 0xb7, 0x06, 0x01, 0x5c, 0x08,
+0x03, 0xbb, 0x05, 0xc7, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27,
+0x00, 0x6d, 0x65, 0x6e, 0x75, 0x3a, 0x59, 0x0c, 0x00, 0x32,
+0x00, 0x02, 0x99, 0x0d, 0x03, 0x15, 0x0a, 0x0a, 0x1b, 0x00,
+0x00, 0x5b, 0x0e, 0x12, 0x2c, 0x4d, 0x0a, 0x06, 0x2c, 0x0b,
+0x01, 0x21, 0x0d, 0x0b, 0x71, 0x0a, 0x47, 0x2e, 0x00, 0x28,
+0x54, 0x4c, 0x0e, 0x13, 0x61, 0xb2, 0x0d, 0x25, 0x69, 0x73,
+0xe5, 0x07, 0x23, 0x72, 0x73, 0x0b, 0x0d, 0x5f, 0x69, 0x73,
+0x3a, 0x00, 0x66, 0x36, 0x09, 0x07, 0x14, 0x32, 0x90, 0x00,
+0x01, 0x8f, 0x00, 0x13, 0x33, 0x83, 0x00, 0x01, 0xa8, 0x0a,
+0x03, 0x8b, 0x0c, 0x02, 0x5b, 0x00, 0x01, 0x97, 0x01, 0x01,
+0x78, 0x05, 0x19, 0x33, 0x32, 0x00, 0x12, 0x32, 0x10, 0x0f,
+0x16, 0x29, 0x13, 0x06, 0x14, 0x74, 0x80, 0x06, 0xd2, 0x60,
+0x58, 0x27, 0x00, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x62, 0x6f,
+0x78, 0x2c, 0x61, 0x01, 0x02, 0xff, 0x02, 0x10, 0x70, 0x28,
+0x07, 0x00, 0x22, 0x00, 0x04, 0x31, 0x0e, 0x61, 0x00, 0x65,
+0x78, 0x74, 0x72, 0x61, 0xac, 0x08, 0x50, 0x74, 0x72, 0x61,
+0x69, 0x6e, 0x07, 0x0b, 0x03, 0x0c, 0x0b, 0x0e, 0x23, 0x0e,
+0x08, 0x3d, 0x0f, 0x0a, 0xa3, 0x05, 0x01, 0x2e, 0x0e, 0x13,
+0x66, 0xc4, 0x0e, 0x03, 0x24, 0x0e, 0x11, 0x28, 0xc6, 0x09,
+0x21, 0x69, 0x73, 0x1d, 0x0e, 0x51, 0x74, 0x69, 0x6d, 0x65,
+0x73, 0x07, 0x05, 0x10, 0x6e, 0xd4, 0x04, 0x03, 0x43, 0x09,
+0x30, 0x2d, 0x58, 0x27, 0x3d, 0x02, 0x06, 0x6b, 0x09, 0x2b,
+0x2e, 0x29, 0x32, 0x0c, 0x06, 0xdc, 0x02, 0x00, 0x98, 0x0e,
+0x0f, 0x98, 0x00, 0x05, 0x04, 0xd0, 0x06, 0x40, 0x73, 0x68,
+0x61, 0x64, 0xb5, 0x02, 0x10, 0x6c, 0x0e, 0x04, 0x00, 0x52,
+0x10, 0x12, 0x6f, 0xcf, 0x00, 0x05, 0x83, 0x05, 0x01, 0xfb,
+0x09, 0x20, 0x65, 0x6e, 0x94, 0x02, 0x2f, 0x64, 0x2e, 0x39,
+0x01, 0x01, 0x13, 0x4a, 0x3a, 0x0d, 0x0f, 0x3e, 0x01, 0x01,
+0x41, 0x67, 0x65, 0x6e, 0x65, 0x88, 0x02, 0x73, 0x72, 0x61,
+0x6e, 0x64, 0x6f, 0x6d, 0x6c, 0x34, 0x0d, 0x08, 0xb3, 0x10,
+0x1e, 0x2e, 0xbf, 0x00, 0x08, 0x58, 0x0e, 0x03, 0xa4, 0x0b,
+0x03, 0xae, 0x00, 0x00, 0x36, 0x08, 0x13, 0x6e, 0x36, 0x06,
+0x01, 0xcd, 0x02, 0x5d, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x11,
+0x0f, 0x0b, 0xea, 0x03, 0x22, 0x60, 0x43, 0x04, 0x02, 0x03,
+0x2f, 0x0b, 0x30, 0x52, 0x6f, 0x77, 0xf9, 0x0c, 0x41, 0x6f,
+0x78, 0x65, 0x73, 0xe9, 0x0e, 0x00, 0x05, 0x04, 0x01, 0x15,
+0x07, 0x50, 0x72, 0x65, 0x61, 0x73, 0x6f, 0xfa, 0x0d, 0x34,
+0x79, 0x00, 0x79, 0x97, 0x11, 0x22, 0x74, 0x6f, 0x4e, 0x00,
+0x06, 0x4d, 0x04, 0x10, 0x67, 0x18, 0x0a, 0x22, 0x65, 0x72,
+0x24, 0x0c, 0x10, 0x31, 0x64, 0x00, 0x42, 0x62, 0x6f, 0x74,
+0x68, 0x50, 0x00, 0x22, 0x3b, 0x00, 0x0e, 0x01, 0x02, 0xd7,
+0x0d, 0x21, 0x68, 0x61, 0x57, 0x00, 0x07, 0x2a, 0x02, 0x03,
+0x90, 0x01, 0x05, 0xd9, 0x00, 0x05, 0xb9, 0x0a, 0x00, 0xc2,
+0x06, 0x01, 0xe4, 0x0c, 0x20, 0x62, 0x65, 0xd2, 0x04, 0x26,
+0x72, 0x69, 0x28, 0x06, 0x2a, 0x69, 0x66, 0x8e, 0x06, 0x3f,
+0x00, 0x69, 0x74, 0x88, 0x01, 0x02, 0x12, 0x4b, 0x41, 0x0e,
+0x0f, 0x88, 0x01, 0x0b, 0x10, 0x61, 0x0e, 0x10, 0x00, 0x2f,
+0x01, 0x00, 0xdc, 0x03, 0x00, 0x02, 0x0e, 0x04, 0x6a, 0x12,
+0x2e, 0x61, 0x72, 0xa5, 0x01, 0x00, 0x9c, 0x00, 0x41, 0x64,
+0x72, 0x61, 0x77, 0x72, 0x0e, 0x00, 0x99, 0x0d, 0x20, 0x75,
+0x74, 0x23, 0x0e, 0x02, 0xc5, 0x03, 0x02, 0xf0, 0x0e, 0x00,
+0x1f, 0x0b, 0x02, 0x40, 0x0e, 0x03, 0x66, 0x12, 0x02, 0x8a,
+0x01, 0x24, 0x73, 0x65, 0x7e, 0x0d, 0x06, 0x24, 0x11, 0x51,
+0x61, 0x00, 0x73, 0x6d, 0x61, 0x89, 0x0c, 0x00, 0xd4, 0x0e,
+0x03, 0x77, 0x00, 0x20, 0x73, 0x68, 0xc4, 0x04, 0x05, 0x05,
+0x0d, 0x0c, 0x4e, 0x0e, 0x04, 0xc8, 0x02, 0x13, 0x69, 0x23,
+0x02, 0x02, 0x55, 0x00, 0x04, 0x4d, 0x11, 0x05, 0x4f, 0x10,
+0x07, 0xfd, 0x04, 0x22, 0x68, 0x65, 0x10, 0x07, 0x00, 0x35,
+0x10, 0x71, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x65,
+0x00, 0x05, 0x36, 0x0f, 0x04, 0x0b, 0x01, 0x16, 0x64, 0x10,
+0x0d, 0x10, 0x4d, 0x66, 0x08, 0x05, 0x2e, 0x00, 0x00, 0xa4,
+0x0a, 0x17, 0x73, 0x2b, 0x05, 0x60, 0x73, 0x00, 0x6c, 0x6f,
+0x6f, 0x6b, 0x1c, 0x07, 0x30, 0x74, 0x74, 0x69, 0xe2, 0x0f,
+0x13, 0x75, 0xb8, 0x0e, 0x00, 0x7a, 0x00, 0x01, 0xd1, 0x0a,
+0x01, 0x77, 0x08, 0x60, 0x65, 0x61, 0x73, 0x69, 0x65, 0x72,
+0x5a, 0x0b, 0x13, 0x6e, 0xab, 0x11, 0x05, 0x52, 0x00, 0x06,
+0x01, 0x02, 0x01, 0xae, 0x09, 0x00, 0xe2, 0x04, 0x22, 0x63,
+0x65, 0xdc, 0x08, 0x02, 0xdf, 0x0f, 0x01, 0x4b, 0x02, 0x60,
+0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x58, 0x10, 0x02, 0xe0,
+0x02, 0x00, 0x8d, 0x07, 0x70, 0x65, 0x6e, 0x74, 0x2e, 0x00,
+0x43, 0x6f, 0x0c, 0x05, 0x63, 0x74, 0x65, 0x6c, 0x79, 0x00,
+0x61, 0x54, 0x00, 0x25, 0x69, 0x63, 0x9d, 0x00, 0x02, 0xa6,
+0x02, 0x00, 0x0f, 0x10, 0x86, 0x72, 0x65, 0x65, 0x64, 0x6f,
+0x6d, 0x00, 0x74, 0x64, 0x04, 0x00, 0x0e, 0x0d, 0x24, 0x65,
+0x77, 0x44, 0x10, 0x15, 0x73, 0x0b, 0x09, 0x00, 0x41, 0x01,
+0x23, 0x46, 0x69, 0xfd, 0x12, 0x04, 0x41, 0x09, 0x0a, 0x45,
+0x01, 0x00, 0xdf, 0x01, 0x00, 0x6d, 0x09, 0x15, 0x74, 0xf0,
+0x0c, 0x0f, 0x39, 0x01, 0x00, 0x16, 0x44, 0x25, 0x00, 0x52,
+0x6c, 0x65, 0x76, 0x65, 0x6c, 0xa9, 0x10, 0x42, 0x6a, 0x75,
+0x64, 0x67, 0x19, 0x0e, 0x01, 0x0e, 0x08, 0x01, 0xbe, 0x00,
+0x26, 0x78, 0x69, 0x49, 0x00, 0x82, 0x74, 0x65, 0x63, 0x68,
+0x6e, 0x69, 0x71, 0x75, 0xaf, 0x0f, 0x42, 0x64, 0x65, 0x64,
+0x75, 0x09, 0x07, 0x03, 0x83, 0x0f, 0x01, 0x42, 0x0c, 0x57,
+0x73, 0x6f, 0x6c, 0x76, 0x65, 0x85, 0x01, 0x12, 0x3a, 0xe6,
+0x05, 0x01, 0x66, 0x00, 0x06, 0xac, 0x0f, 0x12, 0x61, 0x68,
+0x03, 0x23, 0x6f, 0x66, 0xbb, 0x03, 0x00, 0xa1, 0x07, 0x02,
+0x58, 0x02, 0x11, 0x77, 0x7b, 0x03, 0x17, 0x74, 0x55, 0x01,
+0x23, 0x69, 0x6e, 0x32, 0x04, 0x21, 0x65, 0x76, 0xad, 0x0e,
+0x31, 0x6f, 0x6e, 0x65, 0x7b, 0x04, 0x06, 0x56, 0x0a, 0x10,
+0x2c, 0x9f, 0x03, 0x1d, 0x64, 0xd3, 0x00, 0x83, 0x60, 0x54,
+0x72, 0x69, 0x76, 0x69, 0x61, 0x6c, 0x3e, 0x04, 0x70, 0x42,
+0x61, 0x73, 0x69, 0x63, 0x27, 0x00, 0xc7, 0x11, 0x06, 0x98,
+0x04, 0x05, 0xaf, 0x09, 0x04, 0x4d, 0x01, 0x01, 0x02, 0x0d,
+0x06, 0x5c, 0x15, 0x03, 0x33, 0x0a, 0x04, 0xfa, 0x09, 0x12,
+0x74, 0xe1, 0x02, 0x22, 0x69, 0x6d, 0x80, 0x03, 0x10, 0x65,
+0xbe, 0x00, 0x00, 0x16, 0x00, 0x20, 0x60, 0x49, 0x6b, 0x04,
+0x30, 0x6d, 0x65, 0x64, 0x87, 0x08, 0x13, 0x27, 0xee, 0x00,
+0x20, 0x61, 0x6e, 0x3b, 0x11, 0x42, 0x79, 0x6f, 0x6e, 0x64,
+0x79, 0x11, 0x05, 0xdc, 0x06, 0x13, 0x74, 0x7f, 0x02, 0x01,
+0xc2, 0x00, 0x26, 0x61, 0x6c, 0x4a, 0x01, 0x13, 0x73, 0x33,
+0x0b, 0x01, 0x85, 0x02, 0x02, 0xef, 0x03, 0x04, 0x49, 0x03,
+0x05, 0xc6, 0x04, 0x13, 0x63, 0x93, 0x11, 0x13, 0x00, 0x3c,
+0x0d, 0x07, 0x2c, 0x00, 0x04, 0x46, 0x05, 0x02, 0xc1, 0x11,
+0x07, 0x28, 0x00, 0x04, 0xe6, 0x00, 0x00, 0x4e, 0x13, 0x52,
+0x74, 0x00, 0x60, 0x55, 0x6e, 0x76, 0x01, 0x00, 0x1b, 0x06,
+0x03, 0xad, 0x00, 0x03, 0xa9, 0x11, 0x13, 0x74, 0xc7, 0x06,
+0x00, 0x82, 0x01, 0x20, 0x65, 0x6e, 0x42, 0x10, 0x02, 0xe9,
+0x04, 0x05, 0xc0, 0x00, 0x10, 0x65, 0xd9, 0x0f, 0x02, 0xc3,
+0x16, 0x09, 0xcb, 0x00, 0x86, 0x61, 0x00, 0x67, 0x75, 0x65,
+0x73, 0x73, 0x2c, 0x93, 0x0d, 0x70, 0x62, 0x61, 0x63, 0x6b,
+0x74, 0x72, 0x61, 0x30, 0x08, 0x10, 0x66, 0x29, 0x05, 0x00,
+0x20, 0x0a, 0x10, 0x73, 0x8a, 0x04, 0x03, 0x26, 0x03, 0x50,
+0x77, 0x72, 0x6f, 0x6e, 0x67, 0xd0, 0x02, 0x12, 0x47, 0x9f,
+0x02, 0x00, 0x03, 0x02, 0x05, 0xc4, 0x01, 0x05, 0x25, 0x03,
+0x00, 0x8f, 0x00, 0x56, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x1c,
+0x00, 0x1b, 0x3a, 0x5c, 0x08, 0x03, 0x90, 0x07, 0x02, 0xe9,
+0x0f, 0x10, 0x67, 0xa5, 0x13, 0x0d, 0x0b, 0x02, 0x03, 0x52,
+0x05, 0x2b, 0x6d, 0x61, 0xb6, 0x00, 0x01, 0x93, 0x17, 0x00,
+0x52, 0x0d, 0x31, 0x6d, 0x70, 0x74, 0xc8, 0x01, 0x16, 0x67,
+0x8c, 0x00, 0x05, 0x6c, 0x12, 0x30, 0x62, 0x65, 0x66, 0xf1,
+0x03, 0x00, 0x63, 0x17, 0x41, 0x69, 0x6e, 0x64, 0x73, 0x70,
+0x00, 0x10, 0x68, 0x30, 0x0f, 0x02, 0x21, 0x01, 0x22, 0x00,
+0x66, 0xcc, 0x0c, 0x31, 0x2e, 0x00, 0x42, 0xa5, 0x02, 0x23,
+0x70, 0x61, 0x0a, 0x03, 0xc1, 0x77, 0x61, 0x69, 0x74, 0x2c,
+0x00, 0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x31, 0x01, 0x26,
+0x69, 0x66, 0x9e, 0x06, 0x0a, 0xfe, 0x04, 0x95, 0x64, 0x00,
+0x61, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0xe0, 0x12, 0x50,
+0x69, 0x7a, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 6263;
diff --git a/apps/plugins/puzzles/help/tents.c b/apps/plugins/puzzles/help/tents.c
index 9ff68a3c24..e53f92b0f6 100644
--- a/apps/plugins/puzzles/help/tents.c
+++ b/apps/plugins/puzzles/help/tents.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -17,7 +17,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2140 comp 1385 ratio 0.647196 level 11 saved 755 */
+/* orig 2140 comp 1385 ratio 0.647196 level 10 saved 755 */
 const char help_text[] = {
 0xf0, 0x26, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x35, 0x3a, 0x20, 0x54, 0x65, 0x6e, 0x74, 0x73, 0x20,
@@ -30,17 +30,17 @@ const char help_text[] = {
 0x00, 0xf0, 0x04, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00, 0x69,
 0x73, 0x00, 0x74, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x63, 0x65,
 0x00, 0x74, 0x57, 0x00, 0x35, 0x00, 0x69, 0x6e, 0x3b, 0x00,
-0xd5, 0x74, 0x68, 0x65, 0x00, 0x72, 0x65, 0x6d, 0x61, 0x69,
-0x6e, 0x69, 0x6e, 0x67, 0x5a, 0x00, 0x01, 0x22, 0x00, 0xe1,
+0xd6, 0x74, 0x68, 0x65, 0x00, 0x72, 0x65, 0x6d, 0x61, 0x69,
+0x6e, 0x69, 0x6e, 0x67, 0x5a, 0x00, 0x00, 0x22, 0x00, 0xe1,
 0x75, 0x63, 0x68, 0x00, 0x61, 0x00, 0x77, 0x61, 0x79, 0x00,
-0x74, 0x68, 0x61, 0x74, 0x2a, 0x00, 0x90, 0x66, 0x6f, 0x6c,
-0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x6d, 0x00, 0xf1, 0x0b,
+0x74, 0x68, 0x61, 0x74, 0x2a, 0x00, 0x60, 0x66, 0x6f, 0x6c,
+0x6c, 0x6f, 0x77, 0x2a, 0x00, 0xf1, 0x0e, 0x63, 0x6f, 0x6e,
 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x72,
 0x65, 0x00, 0x6d, 0x65, 0x74, 0x3a, 0x00, 0x00, 0x00, 0x2d,
 0x00, 0x54, 0x68, 0x65, 0x72, 0x65, 0x13, 0x00, 0xf3, 0x00,
 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x61, 0x73,
-0x00, 0x6d, 0x61, 0x6e, 0x79, 0x7b, 0x00, 0x23, 0x61, 0x73,
-0xa0, 0x00, 0x04, 0x2e, 0x00, 0x04, 0x18, 0x00, 0x22, 0x6e,
+0x00, 0x6d, 0x61, 0x6e, 0x79, 0x7b, 0x00, 0x24, 0x61, 0x73,
+0xa0, 0x00, 0x03, 0x2e, 0x00, 0x04, 0x18, 0x00, 0x22, 0x6e,
 0x64, 0x19, 0x00, 0xff, 0x03, 0x00, 0x63, 0x61, 0x6e, 0x00,
 0x62, 0x65, 0x00, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64,
 0x00, 0x75, 0x70, 0x8d, 0x00, 0x01, 0x41, 0x65, 0x61, 0x63,
@@ -53,108 +53,108 @@ const char help_text[] = {
 0x67, 0x6f, 0x6e, 0x14, 0x00, 0x10, 0x29, 0x21, 0x01, 0x62,
 0x69, 0x74, 0x73, 0x00, 0x6f, 0x77, 0x3f, 0x01, 0xc2, 0x2e,
 0x00, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x00,
-0x61, 0x67, 0x00, 0x65, 0x6d, 0x61, 0x79, 0x00, 0x62, 0x65,
-0x62, 0x00, 0x00, 0x31, 0x00, 0x51, 0x6f, 0x74, 0x68, 0x65,
-0x72, 0x2f, 0x00, 0x01, 0xd7, 0x00, 0x74, 0x77, 0x65, 0x6c,
-0x6c, 0x00, 0x61, 0x73, 0x48, 0x00, 0x02, 0xe1, 0x00, 0x64,
+0x61, 0x67, 0x00, 0x30, 0x6d, 0x61, 0x79, 0x96, 0x00, 0x05,
+0x62, 0x00, 0x83, 0x74, 0x6f, 0x00, 0x6f, 0x74, 0x68, 0x65,
+0x72, 0xb5, 0x00, 0x70, 0x61, 0x73, 0x00, 0x77, 0x65, 0x6c,
+0x6c, 0x08, 0x00, 0x03, 0x48, 0x00, 0x02, 0xe1, 0x00, 0x64,
 0x4e, 0x6f, 0x00, 0x74, 0x77, 0x6f, 0xe4, 0x00, 0x17, 0x72,
-0x41, 0x00, 0x08, 0xa2, 0x00, 0x13, 0x2c, 0xa0, 0x00, 0x03,
-0xae, 0x00, 0x16, 0x20, 0x9a, 0x00, 0x06, 0x27, 0x01, 0x95,
-0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x6f, 0x66, 0xc4,
-0x01, 0x02, 0x05, 0x01, 0x40, 0x72, 0x6f, 0x77, 0x2c, 0x3e,
-0x01, 0x05, 0x11, 0x00, 0x73, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
+0x41, 0x00, 0x08, 0xa2, 0x00, 0x17, 0x2c, 0xa0, 0x00, 0x46,
+0x00, 0x6f, 0x72, 0x20, 0x9a, 0x00, 0x06, 0x27, 0x01, 0x61,
+0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xb3, 0x01, 0x04, 0xc4,
+0x01, 0x01, 0x05, 0x01, 0x41, 0x72, 0x6f, 0x77, 0x2c, 0x3e,
+0x01, 0x04, 0x11, 0x00, 0x73, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
 0x6e, 0x2c, 0x41, 0x01, 0x35, 0x73, 0x00, 0x74, 0x3d, 0x00,
 0xd1, 0x73, 0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x00, 0x72,
-0x6f, 0x75, 0x6e, 0x64, 0x18, 0x00, 0x53, 0x73, 0x69, 0x64,
-0x65, 0x73, 0x07, 0x02, 0x01, 0x5f, 0x02, 0x00, 0x70, 0x00,
+0x6f, 0x75, 0x6e, 0x64, 0x18, 0x00, 0x54, 0x73, 0x69, 0x64,
+0x65, 0x73, 0x07, 0x02, 0x00, 0x5f, 0x02, 0x00, 0x70, 0x00,
 0xb4, 0x54, 0x68, 0x69, 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a,
-0x6c, 0x65, 0x8d, 0x01, 0x10, 0x66, 0x32, 0x00, 0x01, 0x88,
-0x01, 0x00, 0x15, 0x01, 0x21, 0x61, 0x6c, 0x4e, 0x02, 0x00,
-0x3a, 0x00, 0x11, 0x6e, 0x3a, 0x00, 0x82, 0x49, 0x6e, 0x74,
+0x6c, 0x65, 0x8d, 0x01, 0x11, 0x66, 0x32, 0x00, 0x00, 0x88,
+0x01, 0x00, 0x15, 0x01, 0x22, 0x61, 0x6c, 0x4e, 0x02, 0x41,
+0x73, 0x00, 0x6f, 0x6e, 0x3a, 0x00, 0x82, 0x49, 0x6e, 0x74,
 0x65, 0x72, 0x6e, 0x65, 0x74, 0x89, 0x00, 0xa1, 0x77, 0x61,
 0x73, 0x00, 0x62, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x27, 0x01,
-0x80, 0x6d, 0x79, 0x00, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x2d,
-0x02, 0xf0, 0x28, 0x00, 0x62, 0x79, 0x00, 0x65, 0x2d, 0x6d,
+0x50, 0x6d, 0x79, 0x00, 0x61, 0x74, 0xb4, 0x00, 0xf0, 0x28,
+0x69, 0x6f, 0x6e, 0x00, 0x62, 0x79, 0x00, 0x65, 0x2d, 0x6d,
 0x61, 0x69, 0x6c, 0x2e, 0x00, 0x49, 0x00, 0x64, 0x6f, 0x6e,
 0x27, 0x74, 0x00, 0x6b, 0x6e, 0x6f, 0x77, 0x00, 0x77, 0x68,
 0x6f, 0x00, 0x49, 0x00, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64,
 0x00, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x00, 0x66, 0x6f,
-0x72, 0x00, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x71, 0x02,
-0x20, 0x69, 0x74, 0x9c, 0x00, 0x43, 0x32, 0x35, 0x2e, 0x31,
+0x72, 0x00, 0x69, 0x6e, 0x76, 0x3a, 0x00, 0x50, 0x6e, 0x67,
+0x00, 0x69, 0x74, 0x9c, 0x00, 0x43, 0x32, 0x35, 0x2e, 0x31,
 0x1c, 0x03, 0x00, 0xef, 0x02, 0x31, 0x72, 0x6f, 0x6c, 0x25,
 0x03, 0xa1, 0x4c, 0x65, 0x66, 0x74, 0x2d, 0x63, 0x6c, 0x69,
 0x63, 0x6b, 0x2b, 0x00, 0x93, 0x6e, 0x00, 0x61, 0x00, 0x62,
 0x6c, 0x61, 0x6e, 0x6b, 0xd1, 0x02, 0x43, 0x00, 0x77, 0x69,
 0x6c, 0xb4, 0x00, 0x04, 0xd0, 0x01, 0x21, 0x69, 0x6e, 0x52,
 0x00, 0x7f, 0x52, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x00, 0x3b,
-0x00, 0x0c, 0x00, 0x54, 0x01, 0x00, 0x4e, 0x03, 0x80, 0x69,
-0x74, 0x00, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x03, 0x40,
-0x64, 0x69, 0x63, 0x61, 0x99, 0x00, 0x02, 0x90, 0x02, 0x31,
+0x00, 0x0d, 0x30, 0x63, 0x6f, 0x6c, 0x4e, 0x03, 0x80, 0x69,
+0x74, 0x00, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x03, 0x41,
+0x64, 0x69, 0x63, 0x61, 0x99, 0x00, 0x01, 0x90, 0x02, 0x31,
 0x79, 0x6f, 0x75, 0xdf, 0x01, 0x60, 0x73, 0x75, 0x72, 0x65,
-0x00, 0x69, 0x96, 0x02, 0x33, 0x6e, 0x27, 0x74, 0x6c, 0x00,
-0x34, 0x2e, 0x00, 0x43, 0x5f, 0x00, 0x20, 0x65, 0x69, 0x34,
-0x02, 0x00, 0x82, 0x02, 0x31, 0x74, 0x6f, 0x6e, 0x6d, 0x00,
+0x00, 0x69, 0x96, 0x02, 0x00, 0xdb, 0x00, 0x02, 0x6c, 0x00,
+0x34, 0x2e, 0x00, 0x43, 0x5f, 0x00, 0x21, 0x65, 0x69, 0x34,
+0x02, 0x61, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x6d, 0x00,
 0xaa, 0x6e, 0x00, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x69, 0x65,
 0x64, 0x71, 0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0xf4, 0x00,
 0x21, 0x49, 0x66, 0x5f, 0x00, 0x92, 0x64, 0x72, 0x61, 0x67,
 0x00, 0x77, 0x69, 0x74, 0x68, 0xb4, 0x03, 0x00, 0xb9, 0x00,
 0x04, 0x49, 0x00, 0x70, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x00,
-0x61, 0x0c, 0x02, 0x35, 0x00, 0x6f, 0x72, 0x02, 0x02, 0x00,
+0x61, 0x0c, 0x02, 0x00, 0xed, 0x02, 0x04, 0x02, 0x02, 0x00,
 0xac, 0x01, 0x1a, 0x79, 0xce, 0x00, 0x23, 0x69, 0x6e, 0xf2,
-0x03, 0x41, 0x67, 0x69, 0x6f, 0x6e, 0x57, 0x00, 0x51, 0x63,
-0x6f, 0x76, 0x65, 0x72, 0x75, 0x00, 0x00, 0xe9, 0x01, 0x62,
-0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0xe6, 0x00, 0x02, 0xce,
-0x01, 0x13, 0x6e, 0xe9, 0x02, 0x04, 0x1c, 0x04, 0x05, 0x2b,
-0x00, 0xb0, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64,
-0x2e, 0x00, 0x28, 0x32, 0x02, 0x00, 0x89, 0x03, 0x60, 0x75,
-0x73, 0x65, 0x66, 0x75, 0x6c, 0xb9, 0x01, 0x02, 0xc1, 0x00,
-0x37, 0x69, 0x6e, 0x67, 0x61, 0x04, 0x11, 0x64, 0xbf, 0x02,
-0x04, 0xa7, 0x00, 0x53, 0x6e, 0x63, 0x65, 0x00, 0x79, 0xdc,
-0x04, 0x02, 0x9b, 0x01, 0x50, 0x64, 0x00, 0x61, 0x6c, 0x6c,
-0x3f, 0x03, 0x02, 0xe2, 0x02, 0x23, 0x2e, 0x29, 0xfe, 0x04,
+0x03, 0x10, 0x67, 0x8e, 0x01, 0x00, 0x57, 0x00, 0x52, 0x63,
+0x6f, 0x76, 0x65, 0x72, 0x75, 0x00, 0x94, 0x62, 0x65, 0x00,
+0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0xe6, 0x00, 0x00, 0xce,
+0x01, 0x14, 0x6e, 0xe9, 0x02, 0x03, 0x1c, 0x04, 0x05, 0x2b,
+0x00, 0xb1, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64,
+0x2e, 0x00, 0x28, 0x32, 0x02, 0x91, 0x69, 0x73, 0x00, 0x75,
+0x73, 0x65, 0x66, 0x75, 0x6c, 0xb9, 0x01, 0x01, 0xc1, 0x00,
+0x02, 0x1f, 0x01, 0x04, 0x61, 0x04, 0x12, 0x64, 0xbf, 0x02,
+0x03, 0xa7, 0x00, 0x54, 0x6e, 0x63, 0x65, 0x00, 0x79, 0xdc,
+0x04, 0x01, 0x9b, 0x01, 0x51, 0x64, 0x00, 0x61, 0x6c, 0x6c,
+0x3f, 0x03, 0x01, 0xe2, 0x02, 0x23, 0x2e, 0x29, 0xfe, 0x04,
 0x20, 0x63, 0x61, 0xe2, 0x00, 0x20, 0x73, 0x6f, 0x5f, 0x00,
 0x01, 0x4f, 0x00, 0xb1, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
 0x00, 0x6b, 0x65, 0x79, 0x73, 0x61, 0x02, 0x10, 0x6f, 0x1e,
-0x05, 0x01, 0xd5, 0x02, 0x07, 0xc8, 0x02, 0x56, 0x50, 0x72,
+0x05, 0x06, 0xd5, 0x02, 0x02, 0xc8, 0x02, 0x56, 0x50, 0x72,
 0x65, 0x73, 0x73, 0x81, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x32,
-0x00, 0x10, 0x00, 0xef, 0x00, 0x00, 0x77, 0x01, 0x5f, 0x65,
-0x6d, 0x70, 0x74, 0x79, 0x20, 0x02, 0x05, 0x03, 0xca, 0x02,
-0x18, 0x70, 0x44, 0x00, 0x20, 0x73, 0x70, 0x1f, 0x00, 0x3a,
-0x62, 0x61, 0x72, 0x43, 0x00, 0x0f, 0x28, 0x02, 0x09, 0x12,
-0x3b, 0xf1, 0x01, 0x01, 0xab, 0x00, 0x07, 0xd8, 0x01, 0x0e,
-0xf6, 0x01, 0x01, 0x71, 0x04, 0x20, 0x6c, 0x64, 0x6b, 0x00,
-0x59, 0x53, 0x68, 0x69, 0x66, 0x74, 0x7e, 0x00, 0x0c, 0xf4,
-0x00, 0x08, 0x6b, 0x00, 0x09, 0x84, 0x00, 0x12, 0x73, 0x76,
+0x00, 0x11, 0x00, 0xef, 0x00, 0x8f, 0x61, 0x6e, 0x00, 0x65,
+0x6d, 0x70, 0x74, 0x79, 0x20, 0x02, 0x06, 0x02, 0xfc, 0x00,
+0x18, 0x70, 0x44, 0x00, 0x20, 0x73, 0x70, 0x1f, 0x00, 0x3e,
+0x62, 0x61, 0x72, 0x43, 0x00, 0x0f, 0x28, 0x02, 0x05, 0x14,
+0x3b, 0xf1, 0x01, 0x00, 0x79, 0x00, 0x07, 0xd8, 0x01, 0x0e,
+0xf6, 0x01, 0x00, 0x71, 0x04, 0x20, 0x6c, 0x64, 0x6b, 0x00,
+0x5e, 0x53, 0x68, 0x69, 0x66, 0x74, 0x7e, 0x00, 0x08, 0xf4,
+0x00, 0x08, 0x6b, 0x00, 0x08, 0x84, 0x00, 0x12, 0x73, 0x76,
 0x00, 0x06, 0x4c, 0x00, 0x12, 0x43, 0x23, 0x03, 0x0f, 0x4e,
-0x00, 0x16, 0x02, 0x40, 0x00, 0x59, 0x00, 0x62, 0x6f, 0x74,
-0x68, 0x59, 0x00, 0x01, 0x9f, 0x05, 0x07, 0x01, 0x02, 0x12,
+0x00, 0x17, 0x01, 0x40, 0x00, 0x5b, 0x00, 0x62, 0x6f, 0x74,
+0x68, 0x59, 0x00, 0x00, 0x42, 0x00, 0x06, 0x01, 0x02, 0x12,
 0x74, 0x7c, 0x05, 0x01, 0xc5, 0x05, 0x41, 0x28, 0x41, 0x6c,
 0x6c, 0x54, 0x00, 0x22, 0x61, 0x63, 0x0f, 0x06, 0x83, 0x64,
 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x30, 0x04, 0x11,
-0x63, 0xf8, 0x03, 0x30, 0x32, 0x2e, 0x31, 0x20, 0x03, 0x02,
+0x63, 0xf8, 0x03, 0x32, 0x32, 0x2e, 0x31, 0xff, 0x04, 0x00,
 0xc8, 0x01, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
 0x6c, 0x65, 0x2e, 0x29, 0xd3, 0x03, 0x13, 0x32, 0xd3, 0x03,
-0x90, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
-0xd5, 0x03, 0x00, 0xf6, 0x04, 0x35, 0x73, 0x65, 0x00, 0x14,
-0x00, 0x01, 0x40, 0x05, 0x06, 0x3c, 0x00, 0x51, 0x00, 0x66,
-0x72, 0x6f, 0x6d, 0x79, 0x00, 0xe0, 0x60, 0x43, 0x75, 0x73,
+0xb1, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+0x73, 0x20, 0x88, 0x04, 0x46, 0x65, 0x73, 0x65, 0x00, 0x14,
+0x00, 0x02, 0x41, 0x00, 0x04, 0x3c, 0x00, 0x51, 0x00, 0x66,
+0x72, 0x6f, 0x6d, 0x79, 0x00, 0xe1, 0x60, 0x43, 0x75, 0x73,
 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70,
-0x6f, 0x00, 0x04, 0x98, 0x04, 0xb0, 0x60, 0x54, 0x79, 0x70,
+0x6f, 0x00, 0x03, 0x98, 0x04, 0xb0, 0x60, 0x54, 0x79, 0x70,
 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xab, 0x00, 0x91,
 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x3c,
-0x03, 0x50, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x04, 0x07, 0x02,
-0x58, 0x07, 0x22, 0x69, 0x6e, 0xe1, 0x00, 0x02, 0x9b, 0x06,
+0x03, 0x51, 0x00, 0x00, 0x53, 0x69, 0x7a, 0x04, 0x07, 0x01,
+0x58, 0x07, 0x24, 0x69, 0x6e, 0xe1, 0x00, 0x00, 0x2b, 0x00,
 0xc4, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74,
-0x79, 0x00, 0x00, 0x47, 0x01, 0x02, 0x4b, 0x05, 0x15, 0x64,
-0x1a, 0x00, 0x05, 0x38, 0x05, 0x83, 0x65, 0x6e, 0x65, 0x72,
+0x79, 0x00, 0x00, 0x47, 0x01, 0x02, 0x4b, 0x05, 0x16, 0x64,
+0x1a, 0x00, 0x04, 0x38, 0x05, 0x83, 0x65, 0x6e, 0x65, 0x72,
 0x61, 0x74, 0x65, 0x64, 0x35, 0x05, 0x57, 0x2e, 0x00, 0x4d,
 0x6f, 0x72, 0x29, 0x00, 0x03, 0x17, 0x00, 0x70, 0x73, 0x00,
 0x72, 0x65, 0x71, 0x75, 0x69, 0x2d, 0x07, 0x00, 0x1f, 0x00,
 0xc2, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x00, 0x64,
 0x65, 0x64, 0x75, 0x3a, 0x01, 0x02, 0x9a, 0x06, 0x21, 0x61,
-0x74, 0xab, 0x01, 0x20, 0x65, 0x6e, 0xa5, 0x06, 0x13, 0x6e,
-0xa4, 0x07, 0x06, 0xf8, 0x00, 0x09, 0x81, 0x00, 0x53, 0x6c,
-0x65, 0x76, 0x65, 0x6c, 0x58, 0x00, 0x01, 0xff, 0x01, 0x80,
+0x74, 0xab, 0x01, 0x20, 0x65, 0x6e, 0xa5, 0x06, 0x15, 0x6e,
+0xa4, 0x07, 0x06, 0xf8, 0x00, 0x07, 0x81, 0x00, 0x55, 0x6c,
+0x65, 0x76, 0x65, 0x6c, 0x58, 0x00, 0xb0, 0x73, 0x00, 0x67,
 0x75, 0x65, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x6b, 0x06, 0x04,
 0xe0, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63, 0x6b,
 0x69, 0x6e, 0x67, 0x2e, 0x00,
diff --git a/apps/plugins/puzzles/help/towers.c b/apps/plugins/puzzles/help/towers.c
index f56ac822ef..62c08e011b 100644
--- a/apps/plugins/puzzles/help/towers.c
+++ b/apps/plugins/puzzles/help/towers.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -14,7 +14,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3541 comp 2205 ratio 0.622705 level 5 saved 1336 */
+/* orig 3541 comp 2203 ratio 0.622141 level 10 saved 1338 */
 const char help_text[] = {
 0xf4, 0x26, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x31, 0x3a, 0x20, 0x54, 0x6f, 0x77, 0x65, 0x72, 0x73,
@@ -68,13 +68,13 @@ const char help_text[] = {
 0x01, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x00, 0x28, 0x6f, 0x74,
 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0xe9, 0x00, 0x90,
 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x6e, 0x6f, 0x74, 0x02,
-0x01, 0x10, 0x61, 0x5d, 0x01, 0x20, 0x74, 0x6f, 0x0a, 0x01,
+0x01, 0x30, 0x61, 0x62, 0x6c, 0x4f, 0x00, 0x00, 0x0a, 0x01,
 0x47, 0x00, 0x61, 0x6c, 0x6c, 0x5f, 0x00, 0x70, 0x73, 0x29,
 0x2c, 0x00, 0x77, 0x68, 0x65, 0x4b, 0x00, 0x0c, 0x9a, 0x00,
 0x1f, 0x31, 0x9a, 0x00, 0x02, 0x01, 0xe8, 0x00, 0x23, 0x73,
 0x74, 0x9d, 0x00, 0x10, 0x28, 0x13, 0x00, 0x25, 0x6f, 0x6e,
-0x35, 0x00, 0x22, 0x35, 0x29, 0xa8, 0x00, 0x10, 0x63, 0x84,
-0x02, 0x50, 0x66, 0x69, 0x72, 0x73, 0x74, 0x7c, 0x02, 0x51,
+0x35, 0x00, 0x22, 0x35, 0x29, 0xa8, 0x00, 0x30, 0x63, 0x6f,
+0x6d, 0xc5, 0x00, 0x30, 0x72, 0x73, 0x74, 0x7c, 0x02, 0x51,
 0x49, 0x6e, 0x00, 0x68, 0x61, 0xa5, 0x00, 0xf2, 0x03, 0x6f,
 0x72, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x00, 0x70,
 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x73, 0x2c, 0xaf, 0x02, 0x03,
@@ -97,146 +97,146 @@ const char help_text[] = {
 0x68, 0x6f, 0xfc, 0x00, 0xb1, 0x00, 0x69, 0x6e, 0x76, 0x65,
 0x6e, 0x74, 0x65, 0x64, 0x00, 0x69, 0x08, 0x01, 0x44, 0x33,
 0x31, 0x2e, 0x31, 0x4b, 0x04, 0x00, 0x03, 0x03, 0x31, 0x72,
-0x6f, 0x6c, 0x54, 0x04, 0x02, 0x13, 0x00, 0x50, 0x00, 0x73,
+0x6f, 0x6c, 0x54, 0x04, 0x12, 0x54, 0xfe, 0x00, 0x40, 0x73,
 0x68, 0x61, 0x72, 0xb2, 0x00, 0x00, 0x78, 0x03, 0x21, 0x6f,
 0x66, 0x1b, 0x04, 0x03, 0x26, 0x00, 0x72, 0x00, 0x73, 0x79,
 0x73, 0x74, 0x65, 0x6d, 0x33, 0x04, 0xd1, 0x53, 0x6f, 0x6c,
 0x6f, 0x2c, 0x00, 0x55, 0x6e, 0x65, 0x71, 0x75, 0x61, 0x6c,
-0xf4, 0x00, 0x41, 0x4b, 0x65, 0x65, 0x6e, 0xda, 0x00, 0x63,
-0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x50, 0x00, 0xe1, 0x2c,
+0xf4, 0x00, 0x51, 0x4b, 0x65, 0x65, 0x6e, 0x2e, 0x48, 0x00,
+0x53, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x50, 0x00, 0xe1, 0x2c,
 0x00, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c,
 0x69, 0x63, 0x6b, 0xe0, 0x00, 0x51, 0x6d, 0x6f, 0x75, 0x73,
-0x65, 0x91, 0x02, 0x74, 0x6e, 0x79, 0x00, 0x65, 0x6d, 0x70,
-0x74, 0xf1, 0x03, 0x22, 0x00, 0x61, 0x49, 0x01, 0x50, 0x6e,
+0x65, 0x91, 0x02, 0x84, 0x6e, 0x79, 0x00, 0x65, 0x6d, 0x70,
+0x74, 0x79, 0x03, 0x03, 0x12, 0x61, 0x49, 0x01, 0x50, 0x6e,
 0x00, 0x74, 0x79, 0x70, 0xdc, 0x04, 0x54, 0x64, 0x69, 0x67,
 0x69, 0x74, 0x17, 0x01, 0x80, 0x6b, 0x65, 0x79, 0x62, 0x6f,
 0x61, 0x72, 0x64, 0x43, 0x02, 0x10, 0x66, 0xa3, 0x01, 0x02,
 0x13, 0x03, 0x02, 0x3a, 0x00, 0x01, 0x94, 0x00, 0x05, 0x48,
 0x04, 0x03, 0x8c, 0x04, 0x43, 0x69, 0x76, 0x65, 0x6e, 0xba,
 0x02, 0x32, 0x2e, 0x00, 0x49, 0x7b, 0x03, 0x30, 0x6d, 0x61,
-0x6b, 0x5a, 0x00, 0x8f, 0x6d, 0x69, 0x73, 0x74, 0x61, 0x6b,
-0x65, 0x2c, 0x97, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x50, 0x69,
-0x6e, 0x63, 0x6f, 0x72, 0x86, 0x03, 0x08, 0x9b, 0x00, 0xa1,
-0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x61, 0x63,
-0xc8, 0x02, 0x21, 0x63, 0x6c, 0x06, 0x03, 0xc0, 0x74, 0x00,
-0x61, 0x67, 0x61, 0x69, 0x6e, 0x00, 0x28, 0x6f, 0x72, 0x00,
-0x42, 0x00, 0x00, 0x3f, 0x00, 0xd1, 0x55, 0x6e, 0x64, 0x6f,
-0x00, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0x7d,
-0x02, 0x02, 0x7e, 0x00, 0x10, 0x72, 0x8c, 0x00, 0x12, 0x2d,
-0x74, 0x00, 0x01, 0x92, 0x03, 0x0f, 0xf9, 0x00, 0x04, 0x02,
-0x4a, 0x04, 0x12, 0x2c, 0xe3, 0x00, 0x03, 0x57, 0x04, 0x04,
-0x97, 0x02, 0x00, 0xcc, 0x01, 0x10, 0x72, 0xce, 0x01, 0x18,
-0x6e, 0x3e, 0x04, 0x01, 0x3a, 0x03, 0x71, 0x60, 0x70, 0x65,
-0x6e, 0x63, 0x69, 0x6c, 0x08, 0x03, 0x43, 0x27, 0x2e, 0x00,
-0x59, 0xf3, 0x05, 0x01, 0x2a, 0x06, 0x07, 0x1b, 0x00, 0x11,
-0x73, 0xd1, 0x02, 0x74, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70,
-0x6c, 0xb7, 0x04, 0x15, 0x73, 0x51, 0x00, 0x24, 0x61, 0x6d,
-0x56, 0x00, 0x34, 0x2e, 0x00, 0x41, 0x60, 0x00, 0x03, 0x2d,
-0x05, 0x00, 0xea, 0x03, 0x04, 0x67, 0x01, 0x30, 0x63, 0x61,
-0x6e, 0xda, 0x03, 0x44, 0x61, 0x6c, 0x73, 0x6f, 0x1f, 0x00,
-0x09, 0x66, 0x00, 0x02, 0xe7, 0x02, 0x30, 0x65, 0x00, 0x67,
-0x51, 0x00, 0xd0, 0x70, 0x61, 0x79, 0x73, 0x00, 0x6e, 0x6f,
-0x00, 0x61, 0x74, 0x74, 0x65, 0x6e, 0xdc, 0x04, 0x00, 0x42,
-0x01, 0x08, 0x2e, 0x00, 0x00, 0x84, 0x03, 0x00, 0xaf, 0x04,
-0x60, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x77, 0xf8, 0x00, 0x00,
-0x31, 0x01, 0x03, 0x51, 0x01, 0x11, 0x6d, 0xb2, 0x00, 0x50,
-0x69, 0x73, 0x00, 0x75, 0x70, 0x38, 0x00, 0x45, 0x79, 0x6f,
-0x75, 0x3a, 0xd1, 0x06, 0x05, 0x23, 0x00, 0x95, 0x61, 0x73,
-0x00, 0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x7b, 0x05, 0x17,
-0x61, 0x33, 0x03, 0x04, 0xc9, 0x00, 0x42, 0x6e, 0x65, 0x65,
-0x64, 0x7c, 0x06, 0x50, 0x65, 0x00, 0x72, 0x65, 0x2d, 0x21,
-0x05, 0x42, 0x69, 0x6e, 0x65, 0x64, 0xe6, 0x05, 0x00, 0x54,
-0x00, 0x01, 0x3e, 0x03, 0x20, 0x6d, 0x6f, 0x54, 0x01, 0x3b,
-0x62, 0x6f, 0x75, 0x45, 0x00, 0x04, 0x99, 0x01, 0x2f, 0x6f,
-0x72, 0x80, 0x00, 0x02, 0x54, 0x6c, 0x69, 0x73, 0x74, 0x73,
-0x80, 0x02, 0x05, 0x51, 0x06, 0x07, 0x61, 0x01, 0x13, 0x61,
-0x96, 0x02, 0x04, 0xe2, 0x06, 0x20, 0x6f, 0x72, 0x06, 0x03,
-0x20, 0x74, 0x68, 0x58, 0x01, 0x23, 0x65, 0x6c, 0x36, 0x05,
-0x93, 0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69, 0x6b, 0x65,
-0x4f, 0x03, 0x41, 0x65, 0x72, 0x61, 0x73, 0xeb, 0x07, 0x49,
-0x69, 0x6e, 0x67, 0x6c, 0xca, 0x01, 0x1c, 0x2c, 0x52, 0x02,
-0x08, 0x12, 0x02, 0x00, 0x54, 0x02, 0x00, 0x4f, 0x02, 0x05,
-0xd5, 0x01, 0x03, 0x49, 0x02, 0x01, 0xaf, 0x02, 0x00, 0x5b,
-0x00, 0x3a, 0x41, 0x6c, 0x6c, 0x17, 0x02, 0x09, 0x93, 0x02,
-0x22, 0x72, 0x65, 0x79, 0x00, 0x10, 0x64, 0x9b, 0x05, 0x12,
-0x6e, 0xb8, 0x06, 0x24, 0x65, 0x66, 0x6c, 0x00, 0x05, 0x5e,
-0x00, 0x18, 0x61, 0x14, 0x01, 0x0f, 0x2a, 0x00, 0x05, 0x02,
-0x3a, 0x03, 0x10, 0x73, 0x3a, 0x03, 0x36, 0x2e, 0x00, 0x52,
-0xb3, 0x00, 0x01, 0x4f, 0x02, 0x04, 0x20, 0x00, 0x00, 0x0d,
-0x00, 0x01, 0x23, 0x00, 0x02, 0xeb, 0x02, 0x01, 0x58, 0x02,
-0x02, 0xfb, 0x00, 0x0c, 0x56, 0x02, 0x12, 0x41, 0xc2, 0x02,
-0x02, 0x84, 0x04, 0x01, 0x8a, 0x05, 0x50, 0x75, 0x72, 0x73,
-0x6f, 0x72, 0x23, 0x04, 0x14, 0x73, 0x70, 0x07, 0x22, 0x75,
-0x73, 0x24, 0x03, 0x61, 0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e,
-0x4f, 0x07, 0x02, 0x26, 0x04, 0x00, 0x30, 0x00, 0x02, 0x59,
-0x04, 0x01, 0x2f, 0x00, 0x01, 0x91, 0x06, 0x15, 0x74, 0xa4,
-0x01, 0x2b, 0x6f, 0x72, 0x6e, 0x00, 0x3d, 0x55, 0x73, 0x65,
-0x63, 0x00, 0x51, 0x74, 0x6f, 0x00, 0x6d, 0x6f, 0x7e, 0x09,
-0x51, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x2f, 0x08, 0x16, 0x61,
-0x08, 0x06, 0x03, 0x63, 0x07, 0x2a, 0x6e, 0x64, 0xc8, 0x04,
-0x22, 0x74, 0x6f, 0xbc, 0x03, 0x00, 0x33, 0x04, 0x03, 0xab,
-0x01, 0x05, 0x3f, 0x00, 0x25, 0x65, 0x64, 0x73, 0x03, 0x14,
-0x50, 0x0c, 0x01, 0x50, 0x72, 0x65, 0x74, 0x75, 0x72, 0x28,
-0x03, 0x5a, 0x67, 0x67, 0x6c, 0x65, 0x73, 0x30, 0x00, 0x02,
-0x3e, 0x08, 0x51, 0x61, 0x00, 0x6d, 0x6f, 0x64, 0xb4, 0x04,
-0x55, 0x77, 0x68, 0x69, 0x63, 0x68, 0x93, 0x02, 0x02, 0x67,
-0x00, 0x20, 0x6f, 0x72, 0x10, 0x03, 0x2e, 0x6f, 0x76, 0x40,
-0x01, 0x05, 0x63, 0x00, 0x12, 0x4d, 0x6b, 0x01, 0x01, 0x4f,
-0x05, 0x01, 0xfd, 0x01, 0x41, 0x66, 0x75, 0x6c, 0x6c, 0x10,
-0x01, 0x2d, 0x6f, 0x66, 0x1b, 0x02, 0x08, 0x9c, 0x09, 0x03,
-0xa9, 0x08, 0x31, 0x6f, 0x65, 0x73, 0xde, 0x07, 0x03, 0x8c,
-0x0a, 0x10, 0x6d, 0x03, 0x04, 0x02, 0xed, 0x00, 0x23, 0x69,
-0x6e, 0x6f, 0x06, 0x38, 0x4c, 0x65, 0x66, 0xed, 0x01, 0x02,
-0xde, 0x07, 0x01, 0xe1, 0x01, 0x00, 0x59, 0x00, 0x01, 0x3f,
-0x05, 0x10, 0x73, 0xb8, 0x06, 0x70, 0x65, 0x00, 0x28, 0x67,
-0x72, 0x65, 0x79, 0x11, 0x00, 0x41, 0x6f, 0x75, 0x74, 0x29,
-0x4f, 0x02, 0x24, 0x75, 0x6e, 0x24, 0x00, 0x21, 0x69, 0x66,
-0x06, 0x00, 0x93, 0x73, 0x00, 0x61, 0x6c, 0x72, 0x65, 0x61,
-0x64, 0x79, 0xeb, 0x07, 0x60, 0x2e, 0x00, 0x48, 0x6f, 0x6c,
-0x64, 0x59, 0x00, 0x13, 0x43, 0xa4, 0x06, 0x00, 0x17, 0x02,
-0x4a, 0x68, 0x69, 0x66, 0x74, 0x57, 0x02, 0x50, 0x61, 0x6e,
-0x00, 0x61, 0x72, 0x31, 0x0a, 0x31, 0x6b, 0x65, 0x79, 0x5a,
-0x03, 0x01, 0xa2, 0x08, 0x02, 0xda, 0x00, 0x00, 0x86, 0x06,
-0x01, 0x95, 0x00, 0x27, 0x69, 0x6e, 0x37, 0x06, 0x05, 0x84,
-0x09, 0x00, 0xc4, 0x00, 0x21, 0x28, 0x41, 0x6f, 0x06, 0x31,
-0x65, 0x00, 0x61, 0x13, 0x00, 0x15, 0x73, 0xf8, 0x09, 0x01,
-0x62, 0x02, 0x12, 0x73, 0x29, 0x00, 0x41, 0x00, 0x32, 0x2e,
-0x31, 0x36, 0x03, 0x01, 0xb9, 0x02, 0x50, 0x61, 0x76, 0x61,
-0x69, 0x6c, 0xf2, 0x08, 0x22, 0x2e, 0x29, 0x74, 0x07, 0x14,
-0x32, 0x74, 0x07, 0x73, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
-0x74, 0xca, 0x0b, 0x30, 0x54, 0x68, 0x65, 0xe1, 0x02, 0x05,
-0x14, 0x00, 0x02, 0x42, 0x00, 0x04, 0x3d, 0x00, 0x04, 0x15,
-0x0a, 0xf1, 0x01, 0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74,
-0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x70,
-0x00, 0x03, 0x18, 0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
-0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xac, 0x00, 0x51, 0x47,
-0x72, 0x69, 0x64, 0x20, 0xb0, 0x0b, 0x33, 0x00, 0x00, 0x53,
-0xc2, 0x08, 0x1f, 0x73, 0xc5, 0x0b, 0x04, 0x11, 0x4c, 0xc8,
-0x05, 0x32, 0x6c, 0x69, 0x6d, 0x5c, 0x01, 0x68, 0x33, 0x3b,
-0x00, 0x75, 0x70, 0x70, 0x12, 0x00, 0x74, 0x39, 0x00, 0x28,
-0x62, 0x65, 0x63, 0x61, 0xd7, 0x06, 0x20, 0x75, 0x73, 0xbe,
-0x02, 0x00, 0x5d, 0x02, 0x11, 0x66, 0xa7, 0x03, 0x01, 0xde,
-0x09, 0x21, 0x62, 0x65, 0x68, 0x09, 0x01, 0x32, 0x05, 0x40,
-0x64, 0x69, 0x66, 0x66, 0x2a, 0x05, 0x12, 0x74, 0x6b, 0x03,
-0x11, 0x60, 0x0c, 0x02, 0x60, 0x73, 0x27, 0x00, 0x62, 0x69,
-0x67, 0x6f, 0x09, 0x71, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x39,
-0x21, 0x12, 0x07, 0x14, 0x44, 0x2b, 0x00, 0x34, 0x79, 0x00,
-0x00, 0xbe, 0x01, 0x02, 0xa8, 0x00, 0x16, 0x64, 0x1a, 0x00,
-0x04, 0xae, 0x00, 0x50, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x25,
-0x03, 0x02, 0x32, 0x09, 0x70, 0x2e, 0x00, 0x41, 0x74, 0x00,
-0x55, 0x6e, 0x30, 0x0a, 0x21, 0x6f, 0x6e, 0x28, 0x01, 0x53,
-0x6c, 0x65, 0x76, 0x65, 0x6c, 0xc7, 0x09, 0x72, 0x62, 0x61,
-0x63, 0x6b, 0x74, 0x72, 0x61, 0x71, 0x02, 0x04, 0x36, 0x07,
-0x82, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2a,
-0x09, 0x01, 0x0f, 0x01, 0x31, 0x6f, 0x6c, 0x75, 0x48, 0x01,
-0x21, 0x73, 0x68, 0xc8, 0x00, 0x23, 0x73, 0x74, 0x2b, 0x00,
-0x71, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x2e, 0xbc, 0x06,
-0x33, 0x72, 0x65, 0x6d, 0xf6, 0x06, 0x01, 0x62, 0x00, 0x14,
-0x73, 0x48, 0x00, 0x07, 0xfa, 0x0a, 0x00, 0xdc, 0x08, 0x10,
-0x6f, 0x65, 0x0b, 0x22, 0x78, 0x00, 0x91, 0x00, 0x01, 0xaf,
-0x0b, 0x00, 0x02, 0x02, 0x30, 0x6f, 0x69, 0x64, 0x1a, 0x03,
-0x03, 0x10, 0x00, 0xb0, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72,
-0x61, 0x63, 0x6b, 0x2e, 0x00,
+0x6b, 0x5a, 0x00, 0x8e, 0x6d, 0x69, 0x73, 0x74, 0x61, 0x6b,
+0x65, 0x2c, 0x97, 0x00, 0x02, 0x6d, 0x00, 0x50, 0x69, 0x6e,
+0x63, 0x6f, 0x72, 0x86, 0x03, 0x08, 0x9b, 0x00, 0xa1, 0x70,
+0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x61, 0x63, 0xc8,
+0x02, 0x21, 0x63, 0x6c, 0x06, 0x03, 0xc0, 0x74, 0x00, 0x61,
+0x67, 0x61, 0x69, 0x6e, 0x00, 0x28, 0x6f, 0x72, 0x00, 0x42,
+0x00, 0x00, 0x3f, 0x00, 0xd1, 0x55, 0x6e, 0x64, 0x6f, 0x00,
+0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0x7d, 0x02,
+0x02, 0x7e, 0x00, 0x10, 0x72, 0x8c, 0x00, 0x12, 0x2d, 0x74,
+0x00, 0x01, 0x92, 0x03, 0x0f, 0xf9, 0x00, 0x04, 0x02, 0x4a,
+0x04, 0x12, 0x2c, 0xe3, 0x00, 0x03, 0x57, 0x04, 0x04, 0x97,
+0x02, 0x00, 0xcc, 0x01, 0x10, 0x72, 0xce, 0x01, 0x18, 0x6e,
+0x3e, 0x04, 0x01, 0x3a, 0x03, 0x71, 0x60, 0x70, 0x65, 0x6e,
+0x63, 0x69, 0x6c, 0x08, 0x03, 0x43, 0x27, 0x2e, 0x00, 0x59,
+0xf3, 0x05, 0x01, 0x2a, 0x06, 0x07, 0x1b, 0x00, 0x11, 0x73,
+0xd1, 0x02, 0x74, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
+0xb7, 0x04, 0x15, 0x73, 0x51, 0x00, 0x24, 0x61, 0x6d, 0x56,
+0x00, 0x34, 0x2e, 0x00, 0x41, 0x60, 0x00, 0x03, 0x2d, 0x05,
+0x00, 0xea, 0x03, 0x04, 0x67, 0x01, 0x30, 0x63, 0x61, 0x6e,
+0xda, 0x03, 0x44, 0x61, 0x6c, 0x73, 0x6f, 0x1f, 0x00, 0x09,
+0x66, 0x00, 0x02, 0xe7, 0x02, 0x30, 0x65, 0x00, 0x67, 0x51,
+0x00, 0xd0, 0x70, 0x61, 0x79, 0x73, 0x00, 0x6e, 0x6f, 0x00,
+0x61, 0x74, 0x74, 0x65, 0x6e, 0xdc, 0x04, 0x00, 0x42, 0x01,
+0x08, 0x2e, 0x00, 0x00, 0x84, 0x03, 0x00, 0xaf, 0x04, 0x60,
+0x63, 0x74, 0x6c, 0x79, 0x00, 0x77, 0xf8, 0x00, 0x00, 0x31,
+0x01, 0x03, 0x51, 0x01, 0x11, 0x6d, 0xb2, 0x00, 0x50, 0x69,
+0x73, 0x00, 0x75, 0x70, 0x38, 0x00, 0x45, 0x79, 0x6f, 0x75,
+0x3a, 0xd1, 0x06, 0x05, 0x23, 0x00, 0x95, 0x61, 0x73, 0x00,
+0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x7b, 0x05, 0x17, 0x61,
+0x33, 0x03, 0x04, 0xc9, 0x00, 0x42, 0x6e, 0x65, 0x65, 0x64,
+0x7c, 0x06, 0x50, 0x65, 0x00, 0x72, 0x65, 0x2d, 0x21, 0x05,
+0x42, 0x69, 0x6e, 0x65, 0x64, 0xe6, 0x05, 0x00, 0x54, 0x00,
+0x01, 0x3e, 0x03, 0x30, 0x6d, 0x6f, 0x72, 0xb1, 0x04, 0x2b,
+0x6f, 0x75, 0x45, 0x00, 0x04, 0x99, 0x01, 0x2f, 0x6f, 0x72,
+0x80, 0x00, 0x02, 0x54, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x80,
+0x02, 0x05, 0x51, 0x06, 0x07, 0x61, 0x01, 0x13, 0x61, 0x96,
+0x02, 0x04, 0xe2, 0x06, 0x20, 0x6f, 0x72, 0x06, 0x03, 0x20,
+0x74, 0x68, 0x58, 0x01, 0x23, 0x65, 0x6c, 0x36, 0x05, 0x93,
+0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x4f,
+0x03, 0x41, 0x65, 0x72, 0x61, 0x73, 0xeb, 0x07, 0x49, 0x69,
+0x6e, 0x67, 0x6c, 0xca, 0x01, 0x1c, 0x2c, 0x52, 0x02, 0x08,
+0x12, 0x02, 0x22, 0x6e, 0x64, 0x4f, 0x02, 0x05, 0xd5, 0x01,
+0x03, 0x49, 0x02, 0x01, 0xaf, 0x02, 0x00, 0x5b, 0x00, 0x3a,
+0x41, 0x6c, 0x6c, 0x17, 0x02, 0x09, 0x93, 0x02, 0x22, 0x72,
+0x65, 0x79, 0x00, 0x10, 0x64, 0x9b, 0x05, 0x12, 0x6e, 0xb8,
+0x06, 0x24, 0x65, 0x66, 0x6c, 0x00, 0x05, 0x5e, 0x00, 0x18,
+0x61, 0x14, 0x01, 0x0f, 0x2a, 0x00, 0x05, 0x02, 0x3a, 0x03,
+0x10, 0x73, 0x3a, 0x03, 0x36, 0x2e, 0x00, 0x52, 0xb3, 0x00,
+0x01, 0x4f, 0x02, 0x04, 0x20, 0x00, 0x00, 0x0d, 0x00, 0x01,
+0x23, 0x00, 0x02, 0xeb, 0x02, 0x01, 0x58, 0x02, 0x02, 0xfb,
+0x00, 0x0c, 0x56, 0x02, 0x12, 0x41, 0xc2, 0x02, 0x02, 0x84,
+0x04, 0x01, 0x8a, 0x05, 0x50, 0x75, 0x72, 0x73, 0x6f, 0x72,
+0x23, 0x04, 0x14, 0x73, 0x70, 0x07, 0x22, 0x75, 0x73, 0x24,
+0x03, 0x61, 0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0x4f, 0x07,
+0x02, 0x26, 0x04, 0x00, 0x30, 0x00, 0x02, 0x59, 0x04, 0x01,
+0x2f, 0x00, 0x01, 0x91, 0x06, 0x15, 0x74, 0xa4, 0x01, 0x2b,
+0x6f, 0x72, 0x6e, 0x00, 0x3d, 0x55, 0x73, 0x65, 0x63, 0x00,
+0x51, 0x74, 0x6f, 0x00, 0x6d, 0x6f, 0x7e, 0x09, 0x51, 0x68,
+0x69, 0x67, 0x68, 0x6c, 0x2f, 0x08, 0x16, 0x61, 0x08, 0x06,
+0x03, 0x63, 0x07, 0x2a, 0x6e, 0x64, 0xc8, 0x04, 0x22, 0x74,
+0x6f, 0xbc, 0x03, 0x00, 0x33, 0x04, 0x03, 0xab, 0x01, 0x05,
+0x3f, 0x00, 0x25, 0x65, 0x64, 0x73, 0x03, 0x14, 0x50, 0x0c,
+0x01, 0x50, 0x72, 0x65, 0x74, 0x75, 0x72, 0x28, 0x03, 0x5a,
+0x67, 0x67, 0x6c, 0x65, 0x73, 0x30, 0x00, 0x02, 0x3e, 0x08,
+0x51, 0x61, 0x00, 0x6d, 0x6f, 0x64, 0xb4, 0x04, 0x55, 0x77,
+0x68, 0x69, 0x63, 0x68, 0x93, 0x02, 0x02, 0x67, 0x00, 0x20,
+0x6f, 0x72, 0x10, 0x03, 0x2e, 0x6f, 0x76, 0x40, 0x01, 0x05,
+0x63, 0x00, 0x12, 0x4d, 0x6b, 0x01, 0x01, 0x4f, 0x05, 0x01,
+0xfd, 0x01, 0x41, 0x66, 0x75, 0x6c, 0x6c, 0x10, 0x01, 0x2d,
+0x6f, 0x66, 0x1b, 0x02, 0x08, 0x9c, 0x09, 0x03, 0xa9, 0x08,
+0x31, 0x6f, 0x65, 0x73, 0xde, 0x07, 0x03, 0x8c, 0x0a, 0x10,
+0x6d, 0x03, 0x04, 0x02, 0xed, 0x00, 0x23, 0x69, 0x6e, 0x6f,
+0x06, 0x38, 0x4c, 0x65, 0x66, 0xed, 0x01, 0x02, 0xde, 0x07,
+0x01, 0x76, 0x00, 0x00, 0x59, 0x00, 0x01, 0x3f, 0x05, 0x30,
+0x73, 0x00, 0x64, 0xbe, 0x07, 0x60, 0x28, 0x67, 0x72, 0x65,
+0x79, 0x00, 0xf1, 0x05, 0x31, 0x75, 0x74, 0x29, 0x4f, 0x02,
+0x24, 0x75, 0x6e, 0x24, 0x00, 0x10, 0x69, 0x8a, 0x06, 0x00,
+0x01, 0x04, 0x73, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79,
+0xeb, 0x07, 0x60, 0x2e, 0x00, 0x48, 0x6f, 0x6c, 0x64, 0x59,
+0x00, 0x13, 0x43, 0xa4, 0x06, 0x00, 0x17, 0x02, 0x4a, 0x68,
+0x69, 0x66, 0x74, 0x57, 0x02, 0x50, 0x61, 0x6e, 0x00, 0x61,
+0x72, 0x31, 0x0a, 0x31, 0x6b, 0x65, 0x79, 0x5a, 0x03, 0x01,
+0xa2, 0x08, 0x02, 0xda, 0x00, 0x00, 0x86, 0x06, 0x01, 0x95,
+0x00, 0x27, 0x69, 0x6e, 0x37, 0x06, 0x05, 0x84, 0x09, 0x00,
+0xc4, 0x00, 0x10, 0x28, 0x2a, 0x03, 0x00, 0x1c, 0x00, 0x11,
+0x61, 0x13, 0x00, 0x15, 0x73, 0xf8, 0x09, 0x11, 0x64, 0xa3,
+0x0a, 0x12, 0x65, 0x5e, 0x02, 0x31, 0x32, 0x2e, 0x31, 0x36,
+0x03, 0x01, 0xb9, 0x02, 0x50, 0x61, 0x76, 0x61, 0x69, 0x6c,
+0xf2, 0x08, 0x22, 0x2e, 0x29, 0x74, 0x07, 0x14, 0x32, 0x74,
+0x07, 0x73, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0xca,
+0x0b, 0x30, 0x54, 0x68, 0x65, 0xe1, 0x02, 0x05, 0x14, 0x00,
+0x02, 0x42, 0x00, 0x04, 0x3d, 0x00, 0x04, 0x15, 0x0a, 0xf1,
+0x01, 0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
+0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x70, 0x00, 0x03,
+0x18, 0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0xac, 0x00, 0x51, 0x47, 0x72, 0x69,
+0x64, 0x20, 0xb0, 0x0b, 0x33, 0x00, 0x00, 0x53, 0xc2, 0x08,
+0x1f, 0x73, 0xc5, 0x0b, 0x04, 0x11, 0x4c, 0xc8, 0x05, 0x32,
+0x6c, 0x69, 0x6d, 0x5c, 0x01, 0x68, 0x33, 0x3b, 0x00, 0x75,
+0x70, 0x70, 0x12, 0x00, 0x74, 0x39, 0x00, 0x28, 0x62, 0x65,
+0x63, 0x61, 0xd7, 0x06, 0x20, 0x75, 0x73, 0xbe, 0x02, 0x00,
+0x5d, 0x02, 0x11, 0x66, 0xa7, 0x03, 0x01, 0xde, 0x09, 0x21,
+0x62, 0x65, 0x68, 0x09, 0x01, 0x32, 0x05, 0x40, 0x64, 0x69,
+0x66, 0x66, 0x2a, 0x05, 0x12, 0x74, 0x6b, 0x03, 0x11, 0x60,
+0x0c, 0x02, 0x70, 0x73, 0x27, 0x00, 0x62, 0x69, 0x67, 0x67,
+0xb8, 0x0a, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x39, 0x21, 0x12,
+0x07, 0x14, 0x44, 0x2b, 0x00, 0x34, 0x79, 0x00, 0x00, 0xbe,
+0x01, 0x13, 0x73, 0x9d, 0x03, 0x05, 0x1a, 0x00, 0x04, 0xae,
+0x00, 0x50, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x25, 0x03, 0x02,
+0x32, 0x09, 0x70, 0x2e, 0x00, 0x41, 0x74, 0x00, 0x55, 0x6e,
+0x30, 0x0a, 0x21, 0x6f, 0x6e, 0x28, 0x01, 0x53, 0x6c, 0x65,
+0x76, 0x65, 0x6c, 0xc7, 0x09, 0x72, 0x62, 0x61, 0x63, 0x6b,
+0x74, 0x72, 0x61, 0x71, 0x02, 0x04, 0x36, 0x07, 0x82, 0x72,
+0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2a, 0x09, 0x01,
+0x0f, 0x01, 0x31, 0x6f, 0x6c, 0x75, 0x48, 0x01, 0x21, 0x73,
+0x68, 0xc8, 0x00, 0x23, 0x73, 0x74, 0x2b, 0x00, 0x71, 0x75,
+0x6e, 0x69, 0x71, 0x75, 0x65, 0x2e, 0xbc, 0x06, 0x33, 0x72,
+0x65, 0x6d, 0xf6, 0x06, 0x01, 0x62, 0x00, 0x14, 0x73, 0x48,
+0x00, 0x07, 0xfa, 0x0a, 0x00, 0xdc, 0x08, 0x10, 0x6f, 0x65,
+0x0b, 0x22, 0x78, 0x00, 0x91, 0x00, 0x01, 0xaf, 0x0b, 0x00,
+0x02, 0x02, 0x30, 0x6f, 0x69, 0x64, 0x1a, 0x03, 0x03, 0x10,
+0x00, 0xb0, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63,
+0x6b, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3541;
diff --git a/apps/plugins/puzzles/help/tracks.c b/apps/plugins/puzzles/help/tracks.c
index b46bd86f9e..d3bdc709be 100644
--- a/apps/plugins/puzzles/help/tracks.c
+++ b/apps/plugins/puzzles/help/tracks.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1862 comp 1274 ratio 0.684211 level 11 saved 588 */
+/* orig 1862 comp 1274 ratio 0.684211 level 10 saved 588 */
 const char help_text[] = {
 0xf0, 0x2c, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x34, 0x30, 0x3a, 0x20, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x73,
@@ -31,27 +31,27 @@ const char help_text[] = {
 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x00, 0x74, 0x68, 0x65,
 0x21, 0x00, 0x70, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x41,
 0x1d, 0x00, 0x91, 0x42, 0x00, 0x73, 0x6f, 0x00, 0x74, 0x68,
-0x61, 0x74, 0x1e, 0x00, 0xf1, 0x09, 0x72, 0x6f, 0x77, 0x73,
+0x61, 0x74, 0x1e, 0x00, 0xf1, 0x06, 0x72, 0x6f, 0x77, 0x73,
 0x00, 0x61, 0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
-0x6e, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
-0x1d, 0x00, 0xe3, 0x73, 0x61, 0x6d, 0x65, 0x00, 0x6e, 0x75,
-0x6d, 0x62, 0x65, 0x72, 0x00, 0x6f, 0x66, 0x4a, 0x00, 0xb1,
+0x6e, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x58, 0x00, 0xe0,
+0x68, 0x65, 0x00, 0x73, 0x61, 0x6d, 0x65, 0x00, 0x6e, 0x75,
+0x6d, 0x62, 0x65, 0x72, 0x87, 0x00, 0x02, 0x4a, 0x00, 0xb1,
 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x61,
 0x73, 0x93, 0x00, 0xa3, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61,
-0x74, 0x65, 0x64, 0x00, 0x36, 0x00, 0x82, 0x63, 0x6c, 0x75,
-0x65, 0x73, 0x00, 0x74, 0x6f, 0x7e, 0x00, 0x21, 0x6f, 0x70,
+0x74, 0x65, 0x64, 0x00, 0x36, 0x00, 0x50, 0x63, 0x6c, 0x75,
+0x65, 0x73, 0x6a, 0x00, 0x01, 0x7e, 0x00, 0x21, 0x6f, 0x70,
 0x5f, 0x00, 0x51, 0x72, 0x69, 0x67, 0x68, 0x74, 0x45, 0x00,
 0x21, 0x68, 0x65, 0xe9, 0x00, 0x91, 0x2e, 0x00, 0x00, 0x00,
-0x54, 0x68, 0x65, 0x72, 0x65, 0x45, 0x00, 0x90, 0x6f, 0x6e,
-0x6c, 0x79, 0x00, 0x73, 0x74, 0x72, 0x61, 0x27, 0x00, 0x01,
-0x31, 0x00, 0xf0, 0x08, 0x39, 0x30, 0x00, 0x64, 0x65, 0x67,
+0x54, 0x68, 0x65, 0x72, 0x65, 0x45, 0x00, 0x60, 0x6f, 0x6e,
+0x6c, 0x79, 0x00, 0x73, 0xd2, 0x00, 0x00, 0x27, 0x00, 0x00,
+0x31, 0x00, 0xf1, 0x08, 0x39, 0x30, 0x00, 0x64, 0x65, 0x67,
 0x72, 0x65, 0x65, 0x00, 0x63, 0x75, 0x72, 0x76, 0x65, 0x64,
-0x00, 0x72, 0x61, 0x69, 0x6c, 0x73, 0x2c, 0x1c, 0x00, 0x07,
-0xd7, 0x00, 0xf0, 0x05, 0x6d, 0x61, 0x79, 0x00, 0x6e, 0x6f,
+0x00, 0x72, 0x61, 0x69, 0x6c, 0x73, 0x2c, 0x1c, 0x00, 0x06,
+0xd7, 0x00, 0xf1, 0x05, 0x6d, 0x61, 0x79, 0x00, 0x6e, 0x6f,
 0x74, 0x00, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x69, 0x74,
-0x73, 0x65, 0x6c, 0x66, 0x5a, 0x00, 0x02, 0x65, 0x01, 0x32,
-0x00, 0x77, 0x61, 0xd1, 0x00, 0x72, 0x72, 0x69, 0x62, 0x75,
-0x74, 0x65, 0x64, 0x95, 0x00, 0x20, 0x69, 0x73, 0xed, 0x00,
+0x73, 0x65, 0x6c, 0x66, 0x5a, 0x00, 0x01, 0x16, 0x01, 0x32,
+0x00, 0x77, 0x61, 0xd1, 0x00, 0x40, 0x72, 0x69, 0x62, 0x75,
+0xa2, 0x00, 0x01, 0x95, 0x00, 0x20, 0x69, 0x73, 0xed, 0x00,
 0xf0, 0x08, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00,
 0x62, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x48,
 0x61, 0x72, 0x76, 0x65, 0x79, 0x3d, 0x00, 0x44, 0x34, 0x30,
@@ -62,34 +62,34 @@ const char help_text[] = {
 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00, 0x74, 0x77, 0x6f,
 0xbd, 0x01, 0x7a, 0x00, 0x61, 0x64, 0x64, 0x73, 0x00, 0x61,
 0x34, 0x01, 0x06, 0x29, 0x00, 0x28, 0x68, 0x65, 0x2d, 0x00,
-0x6f, 0x2e, 0x00, 0x52, 0x69, 0x67, 0x68, 0x5c, 0x00, 0x02,
-0x03, 0x48, 0x00, 0x03, 0xe1, 0x00, 0x11, 0x6f, 0x3b, 0x00,
-0x01, 0x19, 0x00, 0x14, 0x2c, 0x79, 0x01, 0x00, 0x30, 0x00,
+0x30, 0x2e, 0x00, 0x52, 0xf8, 0x00, 0x0f, 0x5c, 0x00, 0x02,
+0x03, 0x48, 0x00, 0x02, 0xe1, 0x00, 0x12, 0x6f, 0x3b, 0x00,
+0x00, 0x19, 0x00, 0x14, 0x2c, 0x79, 0x01, 0x00, 0x30, 0x00,
 0x23, 0x6e, 0x6f, 0x69, 0x00, 0xa1, 0x69, 0x73, 0x00, 0x70,
-0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0xfd, 0x01, 0x3c, 0x72,
-0x65, 0x2e, 0xb8, 0x00, 0x00, 0xa6, 0x01, 0x12, 0x61, 0x79,
-0x00, 0x06, 0x5d, 0x00, 0x54, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
-0x51, 0x00, 0xa2, 0x6f, 0x72, 0x00, 0x73, 0x68, 0x6f, 0x77,
-0x69, 0x6e, 0x67, 0x27, 0x02, 0x80, 0x79, 0x6f, 0x75, 0x00,
-0x6b, 0x6e, 0x6f, 0x77, 0x51, 0x00, 0x04, 0x39, 0x00, 0x44,
-0x6d, 0x75, 0x73, 0x74, 0x2b, 0x02, 0x04, 0xe6, 0x00, 0x30,
+0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0xfd, 0x01, 0x3d, 0x72,
+0x65, 0x2e, 0xb8, 0x00, 0x10, 0x69, 0x6b, 0x02, 0x02, 0x79,
+0x00, 0x05, 0x5d, 0x00, 0x54, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
+0x51, 0x00, 0x70, 0x6f, 0x72, 0x00, 0x73, 0x68, 0x6f, 0x77,
+0x2c, 0x00, 0x01, 0x27, 0x02, 0x82, 0x79, 0x6f, 0x75, 0x00,
+0x6b, 0x6e, 0x6f, 0x77, 0x13, 0x02, 0x02, 0x39, 0x00, 0x45,
+0x6d, 0x75, 0x73, 0x74, 0x2b, 0x02, 0x03, 0xe6, 0x00, 0x30,
 0x2c, 0x00, 0x65, 0xc8, 0x02, 0x21, 0x69, 0x66, 0x32, 0x00,
-0x51, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x38, 0x00, 0x02, 0xbf,
-0x02, 0x01, 0xb5, 0x00, 0x33, 0x73, 0x00, 0x69, 0xac, 0x01,
-0x65, 0x65, 0x73, 0x00, 0x79, 0x65, 0x74, 0xf9, 0x00, 0x0e,
-0x9d, 0x00, 0x0a, 0xfa, 0x00, 0x08, 0xed, 0x00, 0x15, 0x69,
-0x7a, 0x00, 0x4a, 0x73, 0x00, 0x6e, 0x6f, 0x62, 0x01, 0x05,
-0xef, 0x00, 0x32, 0x00, 0x6f, 0x72, 0x74, 0x02, 0x94, 0x2d,
-0x64, 0x72, 0x61, 0x67, 0x67, 0x69, 0x6e, 0x67, 0x7d, 0x01,
-0x06, 0xa2, 0x01, 0x50, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0xad,
-0x00, 0x00, 0x18, 0x02, 0x56, 0x6c, 0x61, 0x79, 0x00, 0x61,
+0x52, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x38, 0x00, 0x02, 0xbf,
+0x02, 0x00, 0xb5, 0x00, 0x00, 0xa3, 0x01, 0x02, 0xcb, 0x00,
+0x6d, 0x65, 0x73, 0x00, 0x79, 0x65, 0x74, 0xf9, 0x00, 0x0e,
+0x9d, 0x00, 0x04, 0xdb, 0x01, 0x06, 0xed, 0x00, 0x15, 0x69,
+0x7a, 0x00, 0x16, 0x73, 0xf9, 0x00, 0x03, 0x62, 0x01, 0x05,
+0xef, 0x00, 0x32, 0x00, 0x6f, 0x72, 0x74, 0x02, 0x60, 0x2d,
+0x64, 0x72, 0x61, 0x67, 0x67, 0x38, 0x00, 0x04, 0x7d, 0x01,
+0x05, 0xa2, 0x01, 0x20, 0x6c, 0x6c, 0xfd, 0x02, 0x00, 0xad,
+0x00, 0x86, 0x74, 0x6f, 0x00, 0x6c, 0x61, 0x79, 0x00, 0x61,
 0x83, 0x02, 0x31, 0x6c, 0x69, 0x6e, 0x7b, 0x03, 0x32, 0x69,
-0x73, 0x2d, 0x61, 0x00, 0x20, 0x6f, 0x72, 0x0c, 0x00, 0x32,
-0x6e, 0x6f, 0x74, 0x10, 0x00, 0x06, 0x2d, 0x01, 0xd1, 0x73,
+0x73, 0x2d, 0x61, 0x00, 0x20, 0x6f, 0x72, 0x0c, 0x00, 0x33,
+0x6e, 0x6f, 0x74, 0x10, 0x00, 0x05, 0x2d, 0x01, 0xd1, 0x73,
 0x2c, 0x00, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x00, 0x66,
-0x6f, 0x72, 0xa1, 0x03, 0x02, 0xc9, 0x00, 0x02, 0x5b, 0x03,
-0x23, 0x6f, 0x72, 0x5a, 0x03, 0x01, 0x12, 0x03, 0x54, 0x6d,
-0x61, 0x74, 0x63, 0x68, 0x25, 0x03, 0x01, 0x9c, 0x01, 0x41,
+0x6f, 0x72, 0xa1, 0x03, 0x03, 0xc9, 0x00, 0x01, 0x5b, 0x03,
+0x25, 0x6f, 0x72, 0x5a, 0x03, 0x85, 0x74, 0x6f, 0x00, 0x6d,
+0x61, 0x74, 0x63, 0x68, 0x25, 0x03, 0x00, 0xad, 0x00, 0x41,
 0x28, 0x41, 0x6c, 0x6c, 0x11, 0x00, 0x11, 0x61, 0x8f, 0x02,
 0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62,
 0x4f, 0x03, 0x13, 0x73, 0xa5, 0x02, 0x41, 0x32, 0x2e, 0x31,
@@ -97,17 +97,17 @@ const char help_text[] = {
 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29,
 0xad, 0x02, 0x14, 0x32, 0xad, 0x02, 0xb2, 0x70, 0x61, 0x72,
 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x5e, 0x03,
-0x35, 0x73, 0x65, 0x00, 0x14, 0x00, 0x01, 0xae, 0x03, 0x06,
-0x3d, 0x00, 0x01, 0x12, 0x04, 0x01, 0x7a, 0x00, 0xe0, 0x60,
+0x36, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02, 0x42, 0x00, 0x04,
+0x3d, 0x00, 0x02, 0x12, 0x04, 0x00, 0x7a, 0x00, 0xe1, 0x60,
 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e, 0x2e, 0x27,
-0x00, 0x6f, 0x70, 0x70, 0x00, 0x04, 0x68, 0x02, 0xb0, 0x60,
+0x00, 0x6f, 0x70, 0x70, 0x00, 0x03, 0x68, 0x02, 0xb0, 0x60,
 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75,
 0xac, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x00,
 0x48, 0x65, 0x22, 0x01, 0x68, 0x00, 0x00, 0x53, 0x69, 0x7a,
 0x65, 0xd3, 0x03, 0x00, 0x93, 0x02, 0x06, 0xd3, 0x02, 0xf3,
 0x01, 0x00, 0x00, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75,
 0x6c, 0x74, 0x79, 0x00, 0x00, 0x00, 0x43, 0x49, 0x03, 0x01,
-0x2e, 0x00, 0x15, 0x64, 0x1a, 0x00, 0x05, 0x40, 0x00, 0x41,
+0x2e, 0x00, 0x16, 0x64, 0x1a, 0x00, 0x04, 0x40, 0x00, 0x41,
 0x65, 0x6e, 0x65, 0x72, 0x46, 0x04, 0xf3, 0x0b, 0x70, 0x75,
 0x7a, 0x7a, 0x6c, 0x65, 0x3a, 0x00, 0x61, 0x74, 0x00, 0x54,
 0x72, 0x69, 0x63, 0x6b, 0x79, 0x00, 0x6c, 0x65, 0x76, 0x65,
@@ -117,33 +117,33 @@ const char help_text[] = {
 0x43, 0x01, 0x60, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x86,
 0x01, 0x36, 0x64, 0x69, 0x73, 0x0d, 0x00, 0x52, 0x6d, 0x6f,
 0x76, 0x65, 0x73, 0xd3, 0x02, 0x91, 0x77, 0x6f, 0x75, 0x6c,
-0x64, 0x00, 0x6c, 0x65, 0x61, 0x45, 0x00, 0x24, 0x69, 0x6d,
-0x34, 0x03, 0x02, 0x6d, 0x02, 0xa2, 0x69, 0x6e, 0x67, 0x73,
+0x64, 0x00, 0x6c, 0x65, 0x61, 0x45, 0x00, 0x25, 0x69, 0x6d,
+0x34, 0x03, 0x01, 0x6d, 0x02, 0xa2, 0x69, 0x6e, 0x67, 0x73,
 0x00, 0x6c, 0x61, 0x74, 0x65, 0x72, 0xc6, 0x00, 0x11, 0x73,
-0x2a, 0x02, 0x00, 0x0b, 0x04, 0xb1, 0x73, 0x65, 0x63, 0x75,
-0x74, 0x69, 0x76, 0x65, 0x20, 0x31, 0x20, 0xe6, 0x04, 0x08,
-0xd8, 0x00, 0x30, 0x77, 0x68, 0x65, 0x72, 0x03, 0x00, 0xce,
-0x00, 0x04, 0x7f, 0x04, 0x34, 0x67, 0x61, 0x6d, 0xda, 0x00,
-0x01, 0x57, 0x01, 0x71, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74,
-0x73, 0xfb, 0x03, 0x8f, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65,
-0x6e, 0x74, 0x27, 0x02, 0x01, 0x81, 0x68, 0x61, 0x76, 0x65,
-0x00, 0x61, 0x00, 0x31, 0x26, 0x02, 0x44, 0x2c, 0x00, 0x6f,
-0x72, 0x3a, 0x00, 0x04, 0xb3, 0x05, 0x06, 0x30, 0x00, 0x36,
-0x00, 0x6f, 0x66, 0x0f, 0x05, 0xbd, 0x27, 0x73, 0x00, 0x65,
+0x2a, 0x02, 0x00, 0x0b, 0x04, 0xb2, 0x73, 0x65, 0x63, 0x75,
+0x74, 0x69, 0x76, 0x65, 0x20, 0x31, 0x20, 0xe6, 0x04, 0x07,
+0xd8, 0x00, 0x30, 0x77, 0x68, 0x65, 0x72, 0x03, 0x01, 0xce,
+0x00, 0x03, 0x7f, 0x04, 0x35, 0x67, 0x61, 0x6d, 0xda, 0x00,
+0x00, 0x57, 0x01, 0x71, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74,
+0x73, 0xfb, 0x03, 0x50, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x14,
+0x04, 0x0f, 0x27, 0x02, 0x00, 0x81, 0x68, 0x61, 0x76, 0x65,
+0x00, 0x61, 0x00, 0x31, 0x26, 0x02, 0x10, 0x2c, 0x1d, 0x00,
+0x05, 0x3a, 0x00, 0x02, 0xb3, 0x05, 0x06, 0x30, 0x00, 0x04,
+0x40, 0x01, 0x01, 0x95, 0x02, 0xbd, 0x27, 0x73, 0x00, 0x65,
 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x47, 0x00, 0xc2,
 0x2e, 0x00, 0x42, 0x79, 0x00, 0x64, 0x65, 0x66, 0x61, 0x75,
-0x6c, 0x74, 0x05, 0x05, 0x20, 0x69, 0x73, 0x3b, 0x05, 0x03,
+0x6c, 0x74, 0x05, 0x05, 0x21, 0x69, 0x73, 0x3b, 0x05, 0x02,
 0x5b, 0x00, 0x60, 0x74, 0x65, 0x64, 0x2c, 0x00, 0x74, 0x5d,
 0x02, 0x86, 0x6f, 0x69, 0x64, 0x00, 0x6c, 0x6f, 0x6e, 0x67,
-0x0c, 0x03, 0x65, 0x62, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0xf9,
+0x0c, 0x03, 0x30, 0x62, 0x6f, 0x72, 0x40, 0x01, 0x05, 0xf9,
 0x05, 0x05, 0x0b, 0x06, 0x00, 0x8c, 0x05, 0x01, 0x82, 0x01,
-0x02, 0xc2, 0x01, 0x00, 0x46, 0x05, 0x02, 0x8c, 0x01, 0x71,
+0x01, 0xc2, 0x01, 0x01, 0x46, 0x05, 0x01, 0x8c, 0x01, 0x71,
 0x74, 0x77, 0x69, 0x64, 0x64, 0x6c, 0x79, 0x20, 0x00, 0x70,
 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0xba, 0x03, 0x32,
 0x2e, 0x00, 0x49, 0x1c, 0x04, 0x22, 0x77, 0x61, 0xa1, 0x00,
-0x00, 0x18, 0x00, 0x21, 0x6f, 0x72, 0x3f, 0x00, 0x03, 0xb7,
-0x04, 0xb1, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x00, 0x74,
-0x75, 0x72, 0x6e, 0xa5, 0x00, 0x04, 0x91, 0x02, 0x50, 0x6f,
+0x00, 0x18, 0x00, 0x22, 0x6f, 0x72, 0x3f, 0x00, 0x02, 0x83,
+0x01, 0xb2, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x00, 0x74,
+0x75, 0x72, 0x6e, 0xa5, 0x00, 0x03, 0x91, 0x02, 0x50, 0x6f,
 0x66, 0x66, 0x2e, 0x00,
 };
 
diff --git a/apps/plugins/puzzles/help/twiddle.c b/apps/plugins/puzzles/help/twiddle.c
index 6666746226..72495874b8 100644
--- a/apps/plugins/puzzles/help/twiddle.c
+++ b/apps/plugins/puzzles/help/twiddle.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -11,7 +11,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 2926 comp 1865 ratio 0.637389 level 11 saved 1061 */
+/* orig 2926 comp 1866 ratio 0.637731 level 10 saved 1060 */
 const char help_text[] = {
 0xf3, 0x07, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x37, 0x3a, 0x20, 0x54, 0x77, 0x69, 0x64, 0x64, 0x6c, 0x65,
@@ -22,107 +22,107 @@ const char help_text[] = {
 0x00, 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00,
 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x00, 0x74, 0x6f,
 0x00, 0x53, 0x69, 0x78, 0x74, 0x65, 0x65, 0x6e, 0x00, 0x28,
-0x73, 0x65, 0x65, 0x00, 0x63, 0x5f, 0x00, 0xf1, 0x14, 0x00,
+0x73, 0x65, 0x65, 0x00, 0x63, 0x5f, 0x00, 0xf0, 0x11, 0x00,
 0x36, 0x29, 0x3a, 0x00, 0x79, 0x6f, 0x75, 0x00, 0x61, 0x72,
 0x65, 0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x00, 0x61, 0x00,
 0x67, 0x72, 0x69, 0x64, 0x00, 0x6f, 0x66, 0x00, 0x73, 0x71,
-0x75, 0x61, 0x72, 0x65, 0x67, 0x00, 0xf0, 0x11, 0x73, 0x2c,
+0x75, 0x17, 0x00, 0x00, 0x67, 0x00, 0xf0, 0x11, 0x73, 0x2c,
 0x00, 0x65, 0x61, 0x63, 0x68, 0x00, 0x63, 0x6f, 0x6e, 0x74,
 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x61, 0x00, 0x6e,
 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x00, 0x61, 0x6e, 0x64,
-0x44, 0x00, 0x80, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x00, 0x69,
-0x73, 0x6c, 0x00, 0x03, 0x94, 0x00, 0x43, 0x00, 0x74, 0x68,
+0x44, 0x00, 0x50, 0x72, 0x00, 0x61, 0x69, 0x6d, 0x9a, 0x00,
+0x33, 0x74, 0x6f, 0x00, 0x94, 0x00, 0x43, 0x00, 0x74, 0x68,
 0x65, 0x27, 0x00, 0x40, 0x73, 0x00, 0x69, 0x6e, 0x19, 0x00,
 0x50, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x40, 0x00, 0xf4, 0x02,
 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x00, 0x00, 0x00, 0x49,
 0x6e, 0x00, 0x62, 0x61, 0x73, 0x69, 0x63, 0xdd, 0x00, 0x12,
 0x2c, 0x4d, 0x00, 0x43, 0x6d, 0x6f, 0x76, 0x65, 0x4e, 0x00,
 0x84, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x00, 0x61, 0x92,
-0x00, 0x50, 0x67, 0x72, 0x6f, 0x75, 0x70, 0xa2, 0x00, 0x42,
-0x66, 0x6f, 0x75, 0x72, 0xa0, 0x00, 0x60, 0x00, 0x61, 0x62,
+0x00, 0x50, 0x67, 0x72, 0x6f, 0x75, 0x70, 0xa2, 0x00, 0x10,
+0x66, 0x29, 0x00, 0x01, 0xa0, 0x00, 0x60, 0x00, 0x61, 0x62,
 0x6f, 0x75, 0x74, 0x70, 0x00, 0xf0, 0x0f, 0x69, 0x72, 0x00,
 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x00, 0x63, 0x65, 0x6e,
 0x74, 0x72, 0x65, 0x2e, 0x00, 0x28, 0x4f, 0x72, 0x69, 0x65,
-0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x00, 0xf0,
+0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x00, 0xf1,
 0x03, 0x6e, 0x6f, 0x74, 0x00, 0x73, 0x69, 0x67, 0x6e, 0x69,
-0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x00, 0x69, 0x6e, 0x38,
-0x00, 0x02, 0x85, 0x00, 0x05, 0x42, 0x01, 0x81, 0x61, 0x6c,
-0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x1e, 0x01, 0xf4, 0x1b,
+0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x00, 0x69, 0x6e, 0xa8,
+0x00, 0x02, 0x85, 0x00, 0x04, 0x42, 0x01, 0x81, 0x61, 0x6c,
+0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x1e, 0x01, 0xf5, 0x1b,
 0x63, 0x61, 0x6e, 0x00, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74,
 0x00, 0x69, 0x74, 0x2e, 0x29, 0x00, 0x4f, 0x6e, 0x00, 0x6d,
 0x6f, 0x72, 0x65, 0x00, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63,
 0x65, 0x64, 0x00, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
-0x73, 0x2c, 0x2f, 0x00, 0x06, 0xb4, 0x00, 0x6c, 0x6c, 0x61,
-0x72, 0x67, 0x65, 0x72, 0xbb, 0x00, 0x02, 0xb6, 0x00, 0x01,
+0x73, 0x2c, 0x2f, 0x00, 0x05, 0xb4, 0x00, 0x6d, 0x6c, 0x61,
+0x72, 0x67, 0x65, 0x72, 0xbb, 0x00, 0x01, 0xb6, 0x00, 0x01,
 0xff, 0x00, 0xd0, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x00,
-0x73, 0x61, 0x77, 0x00, 0x74, 0x68, 0xf1, 0x00, 0x63, 0x79,
-0x70, 0x65, 0x00, 0x6f, 0x66, 0x8a, 0x00, 0x04, 0x9e, 0x00,
+0x73, 0x61, 0x77, 0x00, 0x74, 0x68, 0xf1, 0x00, 0x30, 0x79,
+0x70, 0x65, 0x22, 0x00, 0x02, 0x8a, 0x00, 0x04, 0x9e, 0x00,
 0xf2, 0x13, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65,
 0x00, 0x67, 0x61, 0x6d, 0x65, 0x00, 0x60, 0x4d, 0x65, 0x74,
 0x72, 0x6f, 0x69, 0x64, 0x00, 0x50, 0x72, 0x69, 0x6d, 0x65,
 0x00, 0x32, 0x27, 0x2e, 0x00, 0x49, 0x28, 0x00, 0xd0, 0x4d,
 0x61, 0x69, 0x6e, 0x00, 0x47, 0x79, 0x72, 0x6f, 0x00, 0x43,
 0x68, 0x61, 0x79, 0x01, 0x02, 0x41, 0x00, 0x21, 0x61, 0x74,
-0x39, 0x00, 0x10, 0x2c, 0x24, 0x00, 0x12, 0x72, 0x40, 0x02,
-0x03, 0x61, 0x00, 0x01, 0xb2, 0x00, 0x50, 0x73, 0x6f, 0x6c,
+0x39, 0x00, 0x10, 0x2c, 0x24, 0x00, 0x13, 0x72, 0x40, 0x02,
+0x03, 0x61, 0x00, 0x00, 0xb2, 0x00, 0x50, 0x73, 0x6f, 0x6c,
 0x76, 0x65, 0x6b, 0x01, 0xf2, 0x05, 0x75, 0x6e, 0x6c, 0x6f,
 0x63, 0x6b, 0x00, 0x61, 0x00, 0x64, 0x6f, 0x6f, 0x72, 0x2c,
-0x00, 0x77, 0x68, 0x69, 0x63, 0x68, 0x2e, 0x00, 0xb0, 0x73,
+0x00, 0x77, 0x68, 0x69, 0x63, 0x68, 0x2e, 0x00, 0xb1, 0x73,
 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x63, 0x61, 0x73,
-0x9f, 0x00, 0x04, 0xae, 0x01, 0xd1, 0x2e, 0x00, 0x49, 0x00,
+0x9f, 0x00, 0x03, 0xae, 0x01, 0xd2, 0x2e, 0x00, 0x49, 0x00,
 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x64, 0xc1,
-0x00, 0x02, 0xa2, 0x00, 0x20, 0x61, 0x73, 0x4a, 0x02, 0x82,
+0x00, 0x01, 0xa2, 0x00, 0x20, 0x61, 0x73, 0x4a, 0x02, 0x82,
 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x73, 0x7c, 0x01,
-0x20, 0x6f, 0x66, 0x8a, 0x00, 0x04, 0xa6, 0x02, 0x00, 0xfd,
+0x22, 0x6f, 0x66, 0x8a, 0x00, 0x02, 0x79, 0x00, 0x00, 0xfd,
 0x00, 0x35, 0x37, 0x2e, 0x31, 0xdf, 0x02, 0x00, 0x5c, 0x02,
 0x41, 0x72, 0x6f, 0x6c, 0x73, 0xe8, 0x02, 0x66, 0x6f, 0x00,
 0x70, 0x6c, 0x61, 0x79, 0x13, 0x02, 0x51, 0x63, 0x6c, 0x69,
-0x63, 0x6b, 0xe1, 0x00, 0x44, 0x6d, 0x6f, 0x75, 0x73, 0x16,
-0x01, 0x03, 0xe3, 0x01, 0x02, 0x59, 0x00, 0x19, 0x65, 0x64,
-0x01, 0x01, 0xd7, 0x00, 0x45, 0x77, 0x69, 0x73, 0x68, 0x41,
-0x02, 0x00, 0xab, 0x00, 0x08, 0xea, 0x01, 0x32, 0x6d, 0x6f,
+0x63, 0x6b, 0xe1, 0x00, 0x45, 0x6d, 0x6f, 0x75, 0x73, 0x16,
+0x01, 0x02, 0xe3, 0x01, 0x02, 0x59, 0x00, 0x1a, 0x65, 0x64,
+0x01, 0x00, 0xd7, 0x00, 0x46, 0x77, 0x69, 0x73, 0x68, 0x41,
+0x02, 0x05, 0x24, 0x01, 0x02, 0xea, 0x01, 0x32, 0x6d, 0x6f,
 0x64, 0x6c, 0x02, 0x06, 0xac, 0x01, 0x33, 0x32, 0x78, 0x32,
 0x45, 0x00, 0x04, 0xfb, 0x00, 0x51, 0x6d, 0x65, 0x61, 0x6e,
-0x73, 0x25, 0x00, 0x21, 0x68, 0x61, 0x22, 0x01, 0x03, 0x8a,
-0x00, 0xf0, 0x04, 0x61, 0x74, 0x00, 0x61, 0x00, 0x63, 0x6f,
+0x73, 0x25, 0x00, 0x22, 0x68, 0x61, 0x22, 0x01, 0x02, 0x8a,
+0x00, 0xf1, 0x04, 0x61, 0x74, 0x00, 0x61, 0x00, 0x63, 0x6f,
 0x72, 0x6e, 0x65, 0x72, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74,
-0x00, 0x77, 0x59, 0x01, 0x08, 0x92, 0x02, 0x41, 0x6d, 0x65,
-0x65, 0x74, 0xe1, 0x01, 0x0b, 0x2d, 0x02, 0x01, 0x79, 0x00,
+0x00, 0x77, 0x59, 0x01, 0x07, 0x92, 0x02, 0x43, 0x6d, 0x65,
+0x65, 0x74, 0xe0, 0x02, 0x0a, 0x2d, 0x02, 0x00, 0x79, 0x00,
 0x02, 0x54, 0x00, 0x82, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x00,
 0x62, 0x65, 0x82, 0x00, 0x00, 0x16, 0x03, 0xa4, 0x33, 0x78,
 0x33, 0x00, 0x6f, 0x72, 0x00, 0x65, 0x76, 0x65, 0x36, 0x00,
 0x11, 0x74, 0xea, 0x03, 0x53, 0x6d, 0x65, 0x3b, 0x00, 0x69,
-0xe6, 0x00, 0x29, 0x69, 0x7a, 0xf2, 0x00, 0x02, 0xcf, 0x01,
-0x30, 0x6f, 0x64, 0x64, 0x12, 0x00, 0x12, 0x6e, 0xcf, 0x01,
-0x52, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0xab, 0x00, 0x08, 0x2b,
-0x01, 0x02, 0xce, 0x03, 0x0b, 0x3e, 0x00, 0x02, 0x2a, 0x01,
-0x38, 0x61, 0x6e, 0x74, 0x2a, 0x01, 0x30, 0x00, 0x00, 0x43,
+0xe6, 0x00, 0x2c, 0x69, 0x7a, 0xf2, 0x00, 0x60, 0x69, 0x73,
+0x00, 0x6f, 0x64, 0x64, 0x12, 0x00, 0x12, 0x6e, 0xcf, 0x01,
+0x53, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0xab, 0x00, 0x0a, 0x2b,
+0x01, 0x00, 0x9c, 0x00, 0x0b, 0x3e, 0x00, 0x01, 0x2a, 0x01,
+0x00, 0x09, 0x03, 0x07, 0x2a, 0x01, 0x30, 0x00, 0x00, 0x43,
 0x3d, 0x00, 0x00, 0x93, 0x00, 0x41, 0x77, 0x69, 0x74, 0x68,
 0x2f, 0x00, 0x43, 0x6c, 0x65, 0x66, 0x74, 0x7f, 0x01, 0x54,
-0x62, 0x75, 0x74, 0x74, 0x6f, 0xe5, 0x02, 0x44, 0x73, 0x00,
-0x74, 0x68, 0x76, 0x01, 0x50, 0x61, 0x6e, 0x74, 0x69, 0x63,
+0x62, 0x75, 0x74, 0x74, 0x6f, 0xe5, 0x02, 0x11, 0x73, 0x1e,
+0x00, 0x02, 0x76, 0x01, 0x50, 0x61, 0x6e, 0x74, 0x69, 0x63,
 0x43, 0x02, 0x5f, 0x77, 0x69, 0x73, 0x65, 0x2e, 0x45, 0x00,
-0x00, 0x10, 0x72, 0xf3, 0x00, 0x0c, 0x40, 0x00, 0x37, 0x69,
+0x00, 0x12, 0x72, 0xf3, 0x00, 0x0a, 0x40, 0x00, 0x37, 0x69,
 0x74, 0x00, 0x35, 0x00, 0x33, 0x00, 0x00, 0x59, 0x45, 0x03,
 0x42, 0x61, 0x6c, 0x73, 0x6f, 0x09, 0x04, 0x95, 0x61, 0x6e,
 0x00, 0x6f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0xb6, 0x00, 0x51,
-0x61, 0x72, 0x6f, 0x75, 0x6e, 0xf4, 0x00, 0x01, 0xb1, 0x04,
-0x06, 0x62, 0x00, 0xca, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
-0x00, 0x6b, 0x65, 0x79, 0x73, 0x3b, 0x25, 0x01, 0x06, 0x3f,
+0x61, 0x72, 0x6f, 0x75, 0x6e, 0xf4, 0x00, 0x02, 0xb1, 0x04,
+0x05, 0x62, 0x00, 0xcb, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72,
+0x00, 0x6b, 0x65, 0x79, 0x73, 0x3b, 0x25, 0x01, 0x05, 0x3f,
 0x01, 0x20, 0x61, 0x62, 0x55, 0x00, 0x10, 0x28, 0xf0, 0x01,
-0xe3, 0x62, 0x79, 0x00, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
-0x74, 0x2c, 0x00, 0x6f, 0x72, 0xaf, 0x03, 0xb2, 0x29, 0x2e,
-0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0xb6,
+0xb0, 0x62, 0x79, 0x00, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+0x74, 0x2c, 0x7a, 0x01, 0x02, 0xaf, 0x03, 0x80, 0x29, 0x2e,
+0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0xbb, 0x00, 0x01, 0xb6,
 0x00, 0x50, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x00, 0x00,
-0x24, 0x00, 0x40, 0x73, 0x70, 0x61, 0x63, 0x46, 0x02, 0x63,
-0x72, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0xc6, 0x00, 0x04, 0x7c,
-0x00, 0x43, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x0a, 0x0e,
+0x24, 0x00, 0x40, 0x73, 0x70, 0x61, 0x63, 0x46, 0x02, 0x64,
+0x72, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x3f, 0x02, 0x03, 0x7c,
+0x00, 0x10, 0x72, 0x88, 0x05, 0x04, 0xa4, 0x00, 0x08, 0x0e,
 0x01, 0x00, 0x3a, 0x00, 0x06, 0x0d, 0x00, 0x20, 0x72, 0x65,
 0x51, 0x03, 0x60, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0xf3,
 0x00, 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x43, 0x00, 0x20, 0x61,
 0x63, 0x2c, 0x03, 0xd0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63,
 0x72, 0x69, 0x62, 0x65, 0x64, 0x00, 0x69, 0x7d, 0x04, 0x11,
-0x63, 0x42, 0x03, 0x30, 0x32, 0x2e, 0x31, 0xab, 0x05, 0x02,
+0x63, 0x42, 0x03, 0x31, 0x32, 0x2e, 0x31, 0xab, 0x05, 0x01,
 0x19, 0x01, 0xb1, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
 0x6c, 0x65, 0x2e, 0x29, 0x4b, 0x03, 0x15, 0x32, 0x4b, 0x03,
 0xa8, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
@@ -131,75 +131,75 @@ const char help_text[] = {
 0x53, 0x66, 0x69, 0x67, 0x75, 0x72, 0x9e, 0x03, 0x12, 0x70,
 0x79, 0x00, 0x31, 0x76, 0x69, 0x61, 0x89, 0x00, 0x83, 0x60,
 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x27, 0x19, 0x00, 0x32,
-0x00, 0x6f, 0x6e, 0x17, 0x00, 0xf4, 0x00, 0x54, 0x79, 0x70,
+0x00, 0x6f, 0x6e, 0x17, 0x00, 0xf5, 0x00, 0x54, 0x79, 0x70,
 0x65, 0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0x3a, 0x00, 0x00,
-0x00, 0x2d, 0xad, 0x01, 0x05, 0x4e, 0x00, 0x02, 0x0a, 0x01,
-0x51, 0x77, 0x69, 0x64, 0x74, 0x68, 0x1b, 0x06, 0x20, 0x68,
-0x65, 0xf3, 0x01, 0x03, 0x74, 0x02, 0x02, 0xfc, 0x03, 0x02,
-0xb3, 0x01, 0x1f, 0x2e, 0x3f, 0x00, 0x03, 0x05, 0xa6, 0x01,
-0x07, 0x84, 0x06, 0x10, 0x62, 0x38, 0x01, 0x01, 0x3d, 0x04,
-0x04, 0x34, 0x02, 0x06, 0x19, 0x03, 0x0a, 0x47, 0x00, 0x52,
+0x00, 0x2d, 0xad, 0x01, 0x04, 0x4e, 0x00, 0x02, 0x0a, 0x01,
+0x51, 0x77, 0x69, 0x64, 0x74, 0x68, 0x1b, 0x06, 0x21, 0x68,
+0x65, 0xf3, 0x01, 0x03, 0x74, 0x02, 0x03, 0x75, 0x04, 0x00,
+0xb3, 0x01, 0x1f, 0x2e, 0x3f, 0x00, 0x08, 0x04, 0xe5, 0x02,
+0x03, 0x49, 0x01, 0x11, 0x62, 0x96, 0x04, 0x01, 0x3d, 0x04,
+0x04, 0x34, 0x02, 0x05, 0x19, 0x03, 0x0a, 0x47, 0x00, 0x52,
 0x61, 0x73, 0x6b, 0x00, 0x66, 0x42, 0x03, 0x25, 0x72, 0x79,
 0xfb, 0x01, 0x16, 0x6e, 0x28, 0x02, 0x20, 0x74, 0x6f, 0x71,
 0x03, 0x30, 0x64, 0x69, 0x73, 0x70, 0x03, 0x40, 0x75, 0x69,
-0x73, 0x68, 0x42, 0x01, 0x54, 0x00, 0x28, 0x74, 0x68, 0x65,
+0x73, 0x68, 0x42, 0x01, 0x20, 0x00, 0x28, 0x20, 0x00, 0x03,
 0x08, 0x02, 0x11, 0x29, 0x09, 0x02, 0x1b, 0x79, 0x51, 0x00,
-0x12, 0x61, 0x56, 0x03, 0x56, 0x69, 0x66, 0x69, 0x65, 0x64,
-0x9c, 0x05, 0x02, 0x27, 0x04, 0x03, 0x56, 0x05, 0x05, 0x7d,
+0x12, 0x61, 0x56, 0x03, 0x57, 0x69, 0x66, 0x69, 0x65, 0x64,
+0x9c, 0x05, 0x02, 0x27, 0x04, 0x02, 0x56, 0x05, 0x05, 0x7d,
 0x04, 0x10, 0x73, 0xbb, 0x00, 0x30, 0x69, 0x64, 0x65, 0xff,
-0x01, 0x24, 0x61, 0x6c, 0x02, 0x07, 0x04, 0x80, 0x04, 0x0e,
-0x49, 0x00, 0x09, 0x3f, 0x07, 0x48, 0x6a, 0x75, 0x73, 0x74,
-0x44, 0x07, 0x13, 0x61, 0x19, 0x02, 0x12, 0x31, 0x43, 0x07,
-0x00, 0x0c, 0x00, 0x03, 0x33, 0x06, 0x45, 0x72, 0x6f, 0x77,
-0x2c, 0x1f, 0x00, 0x16, 0x32, 0x1f, 0x00, 0x00, 0x2f, 0x02,
-0x30, 0x6f, 0x6e, 0x64, 0x20, 0x00, 0x02, 0x9e, 0x07, 0x5f,
-0x73, 0x6f, 0x00, 0x6f, 0x6e, 0x6f, 0x01, 0x04, 0x00, 0xb9,
-0x04, 0x00, 0xbf, 0x00, 0x01, 0x39, 0x00, 0x17, 0x6f, 0x2a,
+0x01, 0x24, 0x61, 0x6c, 0x02, 0x07, 0x05, 0x80, 0x04, 0x0e,
+0x49, 0x00, 0x08, 0x3f, 0x07, 0x48, 0x6a, 0x75, 0x73, 0x74,
+0x44, 0x07, 0x13, 0x61, 0x19, 0x02, 0x13, 0x31, 0x43, 0x07,
+0x00, 0x0c, 0x00, 0x02, 0x33, 0x06, 0x45, 0x72, 0x6f, 0x77,
+0x2c, 0x1f, 0x00, 0x17, 0x32, 0x1f, 0x00, 0x63, 0x73, 0x65,
+0x63, 0x6f, 0x6e, 0x64, 0x20, 0x00, 0x8f, 0x6e, 0x64, 0x00,
+0x73, 0x6f, 0x00, 0x6f, 0x6e, 0x6f, 0x01, 0x05, 0x30, 0x77,
+0x68, 0x65, 0xbf, 0x00, 0x01, 0x39, 0x00, 0x17, 0x6f, 0x2a,
 0x07, 0x24, 0x6f, 0x66, 0xc9, 0x04, 0x32, 0x61, 0x74, 0x74,
-0xbf, 0x00, 0x10, 0x66, 0xa9, 0x00, 0x06, 0x12, 0x01, 0x14,
-0x6e, 0x30, 0x00, 0x24, 0x62, 0x6c, 0xd9, 0x01, 0x02, 0x28,
-0x08, 0x01, 0x39, 0x00, 0x01, 0x1d, 0x03, 0x01, 0x37, 0x05,
-0x00, 0xa9, 0x01, 0xd0, 0x72, 0x69, 0x61, 0x6e, 0x67, 0x6c,
-0x65, 0x00, 0x64, 0x72, 0x61, 0x77, 0x6e, 0x39, 0x01, 0x43,
-0x69, 0x74, 0x2e, 0x00, 0xf4, 0x02, 0x03, 0x1e, 0x00, 0x01,
-0x6c, 0x00, 0x20, 0x75, 0x73, 0x11, 0x05, 0x01, 0x54, 0x05,
-0x01, 0x11, 0x05, 0x60, 0x75, 0x70, 0x77, 0x61, 0x72, 0x64,
-0x07, 0x08, 0x00, 0xd7, 0x07, 0x56, 0x70, 0x6c, 0x65, 0x74,
-0x65, 0x48, 0x02, 0x0f, 0xfc, 0x01, 0x03, 0x00, 0x75, 0x07,
-0x40, 0x69, 0x6d, 0x69, 0x74, 0x98, 0x07, 0x51, 0x68, 0x75,
-0x66, 0x66, 0x6c, 0x6f, 0x08, 0x22, 0x70, 0x65, 0xe8, 0x02,
-0x03, 0x01, 0x02, 0x92, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72,
-0x6d, 0x65, 0x64, 0xd8, 0x02, 0x04, 0x92, 0x02, 0x16, 0x42,
-0x0e, 0x04, 0x02, 0x38, 0x03, 0x03, 0xc8, 0x00, 0x03, 0x4a,
-0x00, 0x16, 0x65, 0x48, 0x02, 0x00, 0x9a, 0x04, 0x11, 0x75,
-0xfb, 0x01, 0x00, 0x8a, 0x02, 0x38, 0x6e, 0x79, 0x00, 0x88,
-0x09, 0x14, 0x69, 0x91, 0x08, 0x20, 0x61, 0x73, 0x77, 0x03,
-0x11, 0x62, 0x22, 0x01, 0x21, 0x61, 0x73, 0x28, 0x00, 0x10,
-0x6f, 0x6e, 0x01, 0x15, 0x2e, 0xb5, 0x00, 0x81, 0x6f, 0x76,
-0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x3c, 0x07, 0x00, 0x8e,
-0x04, 0x51, 0x72, 0x65, 0x71, 0x75, 0x65, 0x9e, 0x02, 0x00,
-0xa4, 0x07, 0x54, 0x72, 0x65, 0x63, 0x69, 0x73, 0x45, 0x09,
-0x36, 0x00, 0x6f, 0x66, 0xd3, 0x00, 0x01, 0x19, 0x05, 0x1c,
-0x73, 0xcf, 0x00, 0x70, 0x2e, 0x00, 0x54, 0x79, 0x70, 0x69,
-0x63, 0xfd, 0x09, 0x0a, 0x95, 0x09, 0x21, 0x68, 0x65, 0xfb,
-0x00, 0x10, 0x64, 0x17, 0x04, 0x31, 0x6d, 0x69, 0x6e, 0xca,
-0x00, 0x04, 0x5f, 0x00, 0x00, 0xc0, 0x08, 0x0e, 0x5c, 0x00,
-0x00, 0xaf, 0x00, 0x00, 0x7e, 0x04, 0x31, 0x76, 0x65, 0x72,
-0x5a, 0x09, 0xd1, 0x6d, 0x00, 0x65, 0x78, 0x61, 0x63, 0x74,
-0x6c, 0x79, 0x2c, 0x00, 0x73, 0x6f, 0xf8, 0x00, 0x02, 0x0f,
-0x02, 0xd1, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x00, 0x28, 0x73,
-0x61, 0x79, 0x29, 0x00, 0x61, 0x02, 0x07, 0x10, 0x2d, 0x3f,
-0x00, 0x04, 0x33, 0x01, 0x01, 0x9a, 0x05, 0x0a, 0x19, 0x00,
-0x50, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x92, 0x02, 0x21, 0x4e,
-0x6f, 0xcf, 0x01, 0x11, 0x61, 0x60, 0x00, 0x01, 0xf1, 0x06,
-0x02, 0x7a, 0x00, 0x08, 0x68, 0x02, 0x16, 0x2c, 0x1c, 0x00,
-0x80, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x00, 0x69, 0x61,
-0x01, 0x01, 0x37, 0x00, 0x05, 0x4b, 0x00, 0x71, 0x73, 0x00,
-0x73, 0x68, 0x6f, 0x72, 0x74, 0xc7, 0x02, 0x22, 0x61, 0x6e,
-0x55, 0x02, 0x00, 0xca, 0x05, 0x82, 0x74, 0x00, 0x6c, 0x65,
-0x6e, 0x67, 0x74, 0x68, 0xc5, 0x01, 0x01, 0xc5, 0x05, 0x01,
-0x28, 0x0a, 0x12, 0x6f, 0x65, 0x02, 0x80, 0x73, 0x73, 0x69,
-0x62, 0x6c, 0x65, 0x2e, 0x00,
+0xbf, 0x00, 0x12, 0x66, 0x2c, 0x08, 0x04, 0x12, 0x01, 0x14,
+0x6e, 0x30, 0x00, 0x24, 0x62, 0x6c, 0xd9, 0x01, 0x03, 0x28,
+0x08, 0x01, 0x66, 0x04, 0x01, 0x1d, 0x03, 0x01, 0x37, 0x05,
+0xf0, 0x01, 0x61, 0x00, 0x74, 0x72, 0x69, 0x61, 0x6e, 0x67,
+0x6c, 0x65, 0x00, 0x64, 0x72, 0x61, 0x77, 0x6e, 0x39, 0x01,
+0x44, 0x69, 0x74, 0x2e, 0x00, 0xf4, 0x02, 0x04, 0x1e, 0x00,
+0x51, 0x73, 0x00, 0x6d, 0x75, 0x73, 0x11, 0x05, 0x01, 0x54,
+0x05, 0x00, 0x7e, 0x03, 0x71, 0x75, 0x70, 0x77, 0x61, 0x72,
+0x64, 0x73, 0x7a, 0x05, 0x77, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
+0x74, 0x65, 0x48, 0x02, 0x0e, 0xfc, 0x01, 0x02, 0xab, 0x01,
+0x50, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x98, 0x07, 0x51, 0x68,
+0x75, 0x66, 0x66, 0x6c, 0x6f, 0x08, 0x23, 0x70, 0x65, 0xe8,
+0x02, 0x02, 0x01, 0x02, 0x94, 0x70, 0x65, 0x72, 0x66, 0x6f,
+0x72, 0x6d, 0x65, 0x64, 0xd8, 0x02, 0x02, 0x92, 0x02, 0x17,
+0x42, 0x0e, 0x04, 0x04, 0x38, 0x03, 0x01, 0xc8, 0x00, 0x02,
+0x4a, 0x00, 0x16, 0x65, 0x48, 0x02, 0x00, 0x9a, 0x04, 0x11,
+0x75, 0xfb, 0x01, 0x00, 0x8a, 0x02, 0x38, 0x6e, 0x79, 0x00,
+0x88, 0x09, 0x14, 0x69, 0x91, 0x08, 0x20, 0x61, 0x73, 0x77,
+0x03, 0x11, 0x62, 0x22, 0x01, 0x21, 0x61, 0x73, 0x28, 0x00,
+0x10, 0x6f, 0x6e, 0x01, 0x15, 0x2e, 0xb5, 0x00, 0x82, 0x6f,
+0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x3c, 0x07, 0x81,
+0x62, 0x79, 0x00, 0x72, 0x65, 0x71, 0x75, 0x65, 0x9e, 0x02,
+0x00, 0xa4, 0x07, 0x54, 0x72, 0x65, 0x63, 0x69, 0x73, 0x45,
+0x09, 0x01, 0x12, 0x03, 0x05, 0xd3, 0x00, 0x00, 0x19, 0x05,
+0x1c, 0x73, 0xcf, 0x00, 0x71, 0x2e, 0x00, 0x54, 0x79, 0x70,
+0x69, 0x63, 0xfd, 0x09, 0x09, 0x95, 0x09, 0x21, 0x68, 0x65,
+0xfb, 0x00, 0x10, 0x64, 0x17, 0x04, 0x33, 0x6d, 0x69, 0x6e,
+0x46, 0x01, 0x03, 0x5f, 0x00, 0x3e, 0x73, 0x65, 0x74, 0x5c,
+0x00, 0x00, 0xaf, 0x00, 0x00, 0x7e, 0x04, 0x31, 0x76, 0x65,
+0x72, 0x5a, 0x09, 0xa0, 0x6d, 0x00, 0x65, 0x78, 0x61, 0x63,
+0x74, 0x6c, 0x79, 0x2c, 0xfd, 0x00, 0x01, 0xf8, 0x00, 0x01,
+0x0f, 0x02, 0xd1, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x00, 0x28,
+0x73, 0x61, 0x79, 0x29, 0x00, 0x61, 0x02, 0x07, 0x11, 0x2d,
+0xb4, 0x05, 0x04, 0x33, 0x01, 0x01, 0x9a, 0x05, 0x09, 0x19,
+0x00, 0x50, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x92, 0x02, 0x21,
+0x4e, 0x6f, 0xcf, 0x01, 0x11, 0x61, 0x60, 0x00, 0x02, 0xf1,
+0x06, 0x02, 0x7a, 0x00, 0x07, 0x68, 0x02, 0x16, 0x2c, 0x1c,
+0x00, 0x81, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x00, 0x69,
+0x61, 0x01, 0x01, 0x37, 0x00, 0x04, 0x4b, 0x00, 0x71, 0x73,
+0x00, 0x73, 0x68, 0x6f, 0x72, 0x74, 0xc7, 0x02, 0x22, 0x61,
+0x6e, 0x55, 0x02, 0x00, 0xca, 0x05, 0x82, 0x74, 0x00, 0x6c,
+0x65, 0x6e, 0x67, 0x74, 0x68, 0xc5, 0x01, 0x01, 0xc5, 0x05,
+0x01, 0x28, 0x0a, 0x12, 0x6f, 0x65, 0x02, 0x80, 0x73, 0x73,
+0x69, 0x62, 0x6c, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 2926;
diff --git a/apps/plugins/puzzles/help/undead.c b/apps/plugins/puzzles/help/undead.c
index 48c26380ea..3af048a3b8 100644
--- a/apps/plugins/puzzles/help/undead.c
+++ b/apps/plugins/puzzles/help/undead.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3286 comp 2110 ratio 0.642118 level 11 saved 1176 */
+/* orig 3286 comp 2109 ratio 0.641814 level 10 saved 1177 */
 const char help_text[] = {
 0xf0, 0x2c, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x37, 0x3a, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x61, 0x64,
@@ -47,7 +47,7 @@ const char help_text[] = {
 0x10, 0x47, 0x6d, 0x00, 0x11, 0x73, 0x30, 0x00, 0xf0, 0x08,
 0x74, 0x68, 0x65, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69,
 0x74, 0x65, 0x00, 0x77, 0x61, 0x79, 0x00, 0x72, 0x6f, 0x75,
-0x6e, 0x64, 0x3a, 0x18, 0x00, 0x18, 0x79, 0x6b, 0x00, 0x07,
+0x6e, 0x64, 0x3a, 0x18, 0x00, 0x19, 0x79, 0x6b, 0x00, 0x06,
 0x40, 0x00, 0x0f, 0x6d, 0x00, 0x06, 0x95, 0x6c, 0x6f, 0x6f,
 0x6b, 0x65, 0x64, 0x00, 0x61, 0x74, 0x98, 0x00, 0x31, 0x2e,
 0x00, 0x5a, 0xc1, 0x00, 0x02, 0x6c, 0x00, 0x04, 0x2d, 0x00,
@@ -55,179 +55,179 @@ const char help_text[] = {
 0x61, 0x6e, 0x73, 0x2e, 0xa4, 0x01, 0x91, 0x61, 0x6c, 0x73,
 0x6f, 0x00, 0x74, 0x6f, 0x6c, 0x64, 0x96, 0x00, 0xc0, 0x74,
 0x6f, 0x74, 0x61, 0x6c, 0x00, 0x6e, 0x75, 0x6d, 0x62, 0x65,
-0x72, 0x34, 0x01, 0x40, 0x65, 0x61, 0x63, 0x68, 0x42, 0x01,
-0x00, 0x50, 0x01, 0x04, 0x3a, 0x01, 0x30, 0x00, 0x69, 0x6e,
-0x2c, 0x00, 0x01, 0xd6, 0x01, 0x30, 0x2e, 0x00, 0x41, 0x40,
-0x00, 0x10, 0x61, 0xc1, 0x00, 0x02, 0x42, 0x00, 0x33, 0x65,
+0x72, 0x34, 0x01, 0x41, 0x65, 0x61, 0x63, 0x68, 0x42, 0x01,
+0x00, 0x0d, 0x00, 0x03, 0x3a, 0x01, 0x00, 0x96, 0x00, 0x00,
+0x2c, 0x00, 0x00, 0xd6, 0x01, 0x30, 0x2e, 0x00, 0x41, 0x40,
+0x00, 0x11, 0x61, 0xc1, 0x00, 0x01, 0x16, 0x00, 0x33, 0x65,
 0x64, 0x67, 0x7d, 0x01, 0x12, 0x65, 0xf8, 0x01, 0x01, 0xbb,
 0x01, 0x63, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x59, 0x00,
-0x24, 0x73, 0x2c, 0xcc, 0x01, 0xd0, 0x6e, 0x64, 0x69, 0x63,
+0x24, 0x73, 0x2c, 0xcc, 0x01, 0xd1, 0x6e, 0x64, 0x69, 0x63,
 0x61, 0x74, 0x65, 0x00, 0x68, 0x6f, 0x77, 0x00, 0x6d, 0x9f,
-0x00, 0x03, 0x63, 0x00, 0x1a, 0x73, 0x06, 0x01, 0x51, 0x66,
+0x00, 0x02, 0x63, 0x00, 0x1a, 0x73, 0x06, 0x01, 0x51, 0x66,
 0x00, 0x79, 0x6f, 0x75, 0xea, 0x00, 0x57, 0x00, 0x69, 0x6e,
 0x74, 0x6f, 0x5c, 0x00, 0xa0, 0x6c, 0x6f, 0x6e, 0x67, 0x00,
 0x61, 0x00, 0x72, 0x6f, 0x77, 0xbb, 0x01, 0xf1, 0x0b, 0x63,
 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x00, 0x73, 0x74, 0x61, 0x72,
 0x74, 0x69, 0x6e, 0x67, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x00,
-0x74, 0x68, 0x61, 0x74, 0x00, 0x6c, 0x01, 0x9c, 0x69, 0x6f,
+0x74, 0x68, 0x61, 0x74, 0x00, 0x6c, 0x01, 0x9d, 0x69, 0x6f,
 0x6e, 0x2e, 0x00, 0x28, 0x54, 0x68, 0x65, 0x6a, 0x02, 0x01,
-0x2a, 0x01, 0x04, 0xb7, 0x01, 0xf1, 0x05, 0x69, 0x76, 0x65,
+0xa5, 0x00, 0x03, 0xb7, 0x01, 0xf1, 0x05, 0x69, 0x76, 0x65,
 0x00, 0x6f, 0x6e, 0x00, 0x62, 0x6f, 0x74, 0x68, 0x00, 0x73,
 0x69, 0x64, 0x65, 0x73, 0x2e, 0x00, 0x49, 0x81, 0x00, 0x17,
 0x72, 0xd9, 0x01, 0x22, 0x6c, 0x69, 0x63, 0x02, 0xd1, 0x73,
 0x69, 0x67, 0x68, 0x74, 0x00, 0x63, 0x72, 0x6f, 0x73, 0x73,
 0x65, 0x73, 0x98, 0x00, 0x45, 0x73, 0x61, 0x6d, 0x65, 0x2a,
-0x01, 0x21, 0x6d, 0x6f, 0xee, 0x01, 0x80, 0x61, 0x6e, 0x00,
-0x6f, 0x6e, 0x63, 0x65, 0x2c, 0x21, 0x00, 0x04, 0x5d, 0x01,
+0x01, 0x21, 0x6d, 0x6f, 0xee, 0x01, 0x81, 0x61, 0x6e, 0x00,
+0x6f, 0x6e, 0x63, 0x65, 0x2c, 0x21, 0x00, 0x03, 0x5d, 0x01,
 0xd3, 0x77, 0x69, 0x6c, 0x6c, 0x00, 0x63, 0x6f, 0x75, 0x6e,
 0x74, 0x00, 0x69, 0x74, 0x68, 0x01, 0x30, 0x69, 0x6d, 0x65,
 0x0d, 0x00, 0x24, 0x69, 0x73, 0xb6, 0x01, 0x11, 0x2c, 0xec,
-0x02, 0x41, 0x6a, 0x75, 0x73, 0x74, 0x41, 0x00, 0xf1, 0x00,
+0x02, 0x10, 0x6a, 0xe3, 0x02, 0x00, 0x41, 0x00, 0xf2, 0x01,
 0x2e, 0x29, 0x00, 0x00, 0x00, 0x54, 0x68, 0x69, 0x73, 0x00,
-0x70, 0x75, 0x7a, 0x7a, 0x6c, 0xdc, 0x02, 0x00, 0x41, 0x02,
-0x10, 0x73, 0x15, 0x02, 0x50, 0x65, 0x6e, 0x74, 0x65, 0x64,
-0xe7, 0x01, 0xd1, 0x44, 0x61, 0x76, 0x69, 0x64, 0x00, 0x4d,
-0x69, 0x6c, 0x6c, 0x61, 0x72, 0x2c, 0xf6, 0x02, 0x12, 0x72,
-0x79, 0x00, 0x00, 0x9a, 0x00, 0x41, 0x60, 0x48, 0x61, 0x75,
-0x29, 0x00, 0x12, 0x4d, 0x3f, 0x03, 0xf3, 0x03, 0x4d, 0x61,
-0x7a, 0x65, 0x27, 0x2e, 0x00, 0x53, 0x65, 0x65, 0x00, 0x5b,
-0x32, 0x30, 0x5d, 0x00, 0x66, 0x6f, 0xb6, 0x00, 0x61, 0x64,
-0x65, 0x74, 0x61, 0x69, 0x6c, 0x2b, 0x02, 0x02, 0xd9, 0x03,
-0x00, 0x68, 0x00, 0x01, 0xab, 0x03, 0x40, 0x72, 0x69, 0x62,
-0x75, 0x42, 0x00, 0x01, 0x89, 0x01, 0x20, 0x69, 0x73, 0x76,
-0x01, 0x01, 0x38, 0x01, 0x20, 0x6f, 0x6e, 0x7e, 0x00, 0xd0,
-0x53, 0x74, 0x65, 0x66, 0x66, 0x65, 0x6e, 0x00, 0x42, 0x61,
-0x75, 0x65, 0x72, 0x3e, 0x00, 0x01, 0x57, 0x00, 0xf4, 0x29,
-0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
-0x2e, 0x6a, 0x61, 0x6e, 0x6b, 0x6f, 0x2e, 0x61, 0x74, 0x2f,
-0x52, 0x61, 0x65, 0x74, 0x73, 0x65, 0x6c, 0x2f, 0x53, 0x70,
-0x75, 0x6b, 0x73, 0x63, 0x68, 0x6c, 0x6f, 0x73, 0x73, 0x2f,
-0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x00,
-0x00, 0x00, 0x33, 0x37, 0x2e, 0x31, 0x55, 0x04, 0x01, 0x78,
-0x00, 0x46, 0x6f, 0x6c, 0x73, 0x20, 0x8f, 0x00, 0xe3, 0x68,
-0x61, 0x73, 0x00, 0x61, 0x00, 0x73, 0x69, 0x6d, 0x69, 0x6c,
-0x61, 0x72, 0x00, 0x21, 0x00, 0x70, 0x00, 0x73, 0x79, 0x73,
-0x74, 0x65, 0x6d, 0x9c, 0x00, 0xf0, 0x08, 0x53, 0x6f, 0x6c,
-0x6f, 0x2c, 0x00, 0x55, 0x6e, 0x65, 0x71, 0x75, 0x61, 0x6c,
-0x00, 0x61, 0x6e, 0x64, 0x00, 0x4b, 0x65, 0x65, 0x6e, 0x2e,
-0x42, 0x01, 0x63, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x49,
-0x00, 0x71, 0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x23,
-0x01, 0x40, 0x6d, 0x6f, 0x75, 0x73, 0x62, 0x03, 0x01, 0x2b,
-0x03, 0x45, 0x65, 0x6d, 0x70, 0x74, 0x7d, 0x04, 0x12, 0x61,
-0xdf, 0x02, 0x12, 0x6e, 0x73, 0x01, 0x60, 0x61, 0x00, 0x6c,
-0x65, 0x74, 0x74, 0x23, 0x03, 0x02, 0x0b, 0x03, 0x83, 0x6b,
-0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64, 0xd2, 0x02, 0x00,
-0x7d, 0x02, 0x00, 0x18, 0x00, 0x0c, 0x3a, 0x03, 0x50, 0x3a,
-0x00, 0x60, 0x47, 0x27, 0x63, 0x01, 0x06, 0x7c, 0x04, 0x21,
-0x60, 0x56, 0x11, 0x00, 0x0b, 0x84, 0x04, 0x59, 0x60, 0x5a,
-0x27, 0x00, 0x66, 0x8c, 0x04, 0x12, 0x49, 0x04, 0x03, 0x41,
-0x6d, 0x61, 0x6b, 0x65, 0xfc, 0x04, 0x5d, 0x73, 0x74, 0x61,
-0x6b, 0x65, 0xbb, 0x00, 0x04, 0x9b, 0x03, 0x50, 0x69, 0x6e,
-0x63, 0x6f, 0x72, 0x0e, 0x04, 0x08, 0xbf, 0x00, 0xb0, 0x70,
-0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x61, 0x63, 0x65,
-0x20, 0x01, 0x50, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6f, 0x02,
-0x20, 0x61, 0x67, 0x7d, 0x05, 0x61, 0x28, 0x6f, 0x72, 0x00,
-0x75, 0x73, 0x9c, 0x04, 0x00, 0x19, 0x01, 0xd4, 0x6f, 0x00,
-0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0x2e, 0x00,
-0x00, 0x7e, 0x00, 0x10, 0x72, 0xee, 0x02, 0x11, 0x2d, 0x74,
-0x00, 0x01, 0x25, 0x01, 0x0f, 0x1d, 0x01, 0x0b, 0x02, 0xef,
-0x02, 0x01, 0x89, 0x00, 0x82, 0x73, 0x70, 0x6f, 0x6e, 0x64,
-0x69, 0x6e, 0x67, 0x09, 0x01, 0x03, 0xfe, 0x02, 0x01, 0xe0,
-0x03, 0x31, 0x68, 0x6f, 0x77, 0xe7, 0x04, 0xb3, 0x72, 0x65,
-0x64, 0x75, 0x63, 0x65, 0x64, 0x00, 0x73, 0x69, 0x7a, 0xc6,
-0x00, 0x14, 0x61, 0xbd, 0x00, 0x21, 0x2c, 0x00, 0xea, 0x01,
-0xe0, 0x60, 0x70, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x00, 0x6d,
-0x61, 0x72, 0x6b, 0x27, 0x2e, 0xc0, 0x04, 0x01, 0x25, 0x04,
-0x57, 0x68, 0x61, 0x76, 0x65, 0x00, 0x1b, 0x00, 0x12, 0x73,
-0xc3, 0x02, 0x65, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x8a,
-0x03, 0x00, 0x22, 0x03, 0x05, 0x9f, 0x03, 0x03, 0x58, 0x00,
-0x33, 0x2e, 0x00, 0x41, 0x0a, 0x00, 0x04, 0x82, 0x06, 0x11,
-0x69, 0x4d, 0x04, 0x85, 0x66, 0x75, 0x6c, 0x6c, 0x2d, 0x73,
-0x69, 0x7a, 0x3d, 0x00, 0x00, 0x68, 0x00, 0x31, 0x6e, 0x6f,
-0x74, 0x2b, 0x05, 0x04, 0x2b, 0x00, 0x09, 0x73, 0x00, 0x01,
-0x55, 0x02, 0x00, 0x94, 0x04, 0x00, 0x5d, 0x00, 0x30, 0x70,
-0x61, 0x79, 0xa3, 0x06, 0x20, 0x00, 0x61, 0xf2, 0x04, 0x01,
-0x16, 0x03, 0x28, 0x74, 0x6f, 0x2e, 0x00, 0x01, 0xff, 0x06,
-0x40, 0x00, 0x65, 0x78, 0x61, 0xac, 0x05, 0x50, 0x00, 0x77,
-0x68, 0x61, 0x74, 0x5c, 0x01, 0x04, 0x7c, 0x01, 0x10, 0x6d,
-0xbf, 0x00, 0x00, 0x02, 0x04, 0x50, 0x75, 0x70, 0x00, 0x74,
-0x6f, 0x1a, 0x00, 0x32, 0x3a, 0x00, 0x79, 0xeb, 0x00, 0x05,
-0x23, 0x00, 0x00, 0x10, 0x01, 0x40, 0x72, 0x65, 0x6d, 0x69,
-0xda, 0x03, 0x12, 0x73, 0x2a, 0x01, 0x30, 0x61, 0x00, 0x70,
-0xf4, 0x04, 0x54, 0x63, 0x75, 0x6c, 0x61, 0x72, 0xd5, 0x00,
-0x50, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x45, 0x00, 0x10, 0x62,
-0xdc, 0x04, 0x91, 0x2d, 0x65, 0x78, 0x61, 0x6d, 0x69, 0x6e,
-0x65, 0x64, 0x4a, 0x04, 0x01, 0x54, 0x00, 0x42, 0x6b, 0x6e,
-0x6f, 0x77, 0xed, 0x03, 0x4a, 0x61, 0x62, 0x6f, 0x75, 0x45,
-0x00, 0x04, 0xfc, 0x00, 0x00, 0x8f, 0x02, 0x0f, 0x81, 0x00,
-0x02, 0x53, 0x6c, 0x69, 0x73, 0x74, 0x73, 0xe9, 0x05, 0x00,
-0x5f, 0x05, 0x01, 0xb0, 0x04, 0x08, 0x23, 0x06, 0x12, 0x61,
-0xff, 0x07, 0x05, 0xc5, 0x01, 0x20, 0x6f, 0x72, 0x56, 0x03,
-0x20, 0x74, 0x68, 0x65, 0x01, 0x32, 0x65, 0x6c, 0x73, 0x83,
-0x00, 0x93, 0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69, 0x6b,
-0x65, 0x98, 0x03, 0x51, 0x65, 0x72, 0x61, 0x73, 0x65, 0xd7,
-0x03, 0x39, 0x6e, 0x67, 0x6c, 0xd8, 0x01, 0x18, 0x2c, 0x7e,
-0x02, 0x03, 0xce, 0x01, 0x07, 0x80, 0x02, 0x01, 0x7b, 0x02,
-0x05, 0xe2, 0x01, 0x03, 0x82, 0x02, 0x01, 0xdb, 0x02, 0x01,
-0xf3, 0x03, 0x39, 0x41, 0x6c, 0x6c, 0x84, 0x01, 0x0a, 0xbf,
-0x02, 0x22, 0x72, 0x65, 0x79, 0x00, 0x11, 0x64, 0x53, 0x07,
-0x02, 0x6d, 0x06, 0x23, 0x65, 0x66, 0x6c, 0x00, 0x06, 0x5e,
-0x00, 0x14, 0x61, 0xdf, 0x00, 0x05, 0xe1, 0x02, 0x2f, 0x6f,
-0x72, 0x32, 0x00, 0x01, 0x0c, 0x6e, 0x03, 0x31, 0x2e, 0x00,
-0x52, 0xbb, 0x00, 0x02, 0xae, 0x03, 0x36, 0x69, 0x6e, 0x67,
-0x21, 0x00, 0x00, 0x0d, 0x00, 0x10, 0x73, 0x24, 0x00, 0x01,
-0x12, 0x03, 0x00, 0x62, 0x02, 0x03, 0x04, 0x01, 0x0d, 0x60,
-0x02, 0x11, 0x41, 0xd9, 0x02, 0x01, 0xd6, 0x04, 0x03, 0x59,
-0x03, 0x50, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x7b, 0x04, 0x05,
-0x2e, 0x07, 0x21, 0x75, 0x73, 0x74, 0x08, 0x00, 0xa4, 0x02,
-0x31, 0x6a, 0x75, 0x6e, 0x93, 0x05, 0x02, 0x11, 0x09, 0x23,
-0x74, 0x68, 0x13, 0x01, 0x03, 0x30, 0x00, 0x11, 0x74, 0x02,
-0x05, 0x17, 0x63, 0x1f, 0x03, 0x2b, 0x6f, 0x72, 0x72, 0x00,
-0x36, 0x55, 0x73, 0x65, 0x67, 0x00, 0x06, 0x37, 0x00, 0x30,
-0x6d, 0x6f, 0x76, 0x09, 0x01, 0x50, 0x68, 0x69, 0x67, 0x68,
-0x6c, 0xd5, 0x00, 0x03, 0xfb, 0x07, 0x05, 0x93, 0x07, 0x1f,
-0x2c, 0x2f, 0x01, 0x07, 0x00, 0x3f, 0x00, 0x00, 0xa5, 0x06,
-0x00, 0x75, 0x04, 0x03, 0xc1, 0x01, 0x06, 0x48, 0x00, 0x25,
-0x65, 0x64, 0x96, 0x03, 0x14, 0x50, 0x19, 0x01, 0x50, 0x72,
-0x65, 0x74, 0x75, 0x72, 0x3f, 0x03, 0x5a, 0x67, 0x67, 0x6c,
-0x65, 0x73, 0x30, 0x00, 0x01, 0x09, 0x08, 0x01, 0x63, 0x00,
-0x10, 0x64, 0x30, 0x04, 0x02, 0x51, 0x08, 0x04, 0xa9, 0x02,
-0x03, 0x67, 0x00, 0x20, 0x6f, 0x72, 0x27, 0x03, 0x1b, 0x6f,
-0x20, 0x04, 0x06, 0xd0, 0x04, 0x00, 0x83, 0x01, 0x30, 0x66,
-0x65, 0x72, 0x0b, 0x01, 0x23, 0x69, 0x6e, 0xa5, 0x00, 0x05,
-0xd3, 0x02, 0x81, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65,
-0x74, 0x2b, 0x05, 0x26, 0x75, 0x74, 0xdb, 0x02, 0x50, 0x70,
-0x69, 0x63, 0x74, 0x75, 0xc6, 0x0a, 0x04, 0x6e, 0x00, 0x03,
-0xeb, 0x01, 0x63, 0x60, 0x41, 0x27, 0x00, 0x74, 0x6f, 0xae,
-0x00, 0x81, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e,
-0xe1, 0x04, 0x02, 0x0e, 0x06, 0x07, 0x6d, 0x01, 0x28, 0x61,
-0x73, 0x79, 0x01, 0x04, 0x24, 0x00, 0x04, 0x5b, 0x03, 0x03,
-0x8a, 0x00, 0x01, 0xa9, 0x00, 0x15, 0x4c, 0x55, 0x02, 0x02,
-0x9c, 0x04, 0x31, 0x63, 0x6c, 0x75, 0x2b, 0x02, 0x02, 0xcc,
-0x00, 0x01, 0xbe, 0x05, 0x30, 0x73, 0x00, 0x64, 0xf0, 0x0a,
-0x50, 0x28, 0x67, 0x72, 0x65, 0x79, 0x11, 0x00, 0x41, 0x6f,
-0x75, 0x74, 0x29, 0x9a, 0x02, 0x24, 0x75, 0x6e, 0x24, 0x00,
-0x23, 0x69, 0x66, 0x57, 0x08, 0x71, 0x61, 0x6c, 0x72, 0x65,
-0x61, 0x64, 0x79, 0x3d, 0x00, 0x20, 0x65, 0x64, 0x61, 0x00,
-0x42, 0x28, 0x41, 0x6c, 0x6c, 0xf0, 0x00, 0x01, 0x2f, 0x02,
-0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62,
-0x49, 0x02, 0x13, 0x73, 0xd8, 0x07, 0x36, 0x32, 0x2e, 0x31,
-0x2d, 0x0a, 0xb2, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
-0x6c, 0x65, 0x2e, 0x29, 0xa6, 0x07, 0x14, 0x32, 0xa6, 0x07,
-0x60, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0xbc, 0x00, 0x12,
-0x20, 0x12, 0x05, 0x34, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02,
-0x65, 0x09, 0x06, 0x3d, 0x00, 0x04, 0x9d, 0x09, 0xf0, 0x01,
-0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e,
-0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x70, 0x00, 0x04, 0x57,
-0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
-0x65, 0x6e, 0x75, 0xac, 0x00, 0x91, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0x01, 0x02, 0x50, 0x00, 0x00,
-0x53, 0x69, 0x7a, 0x5e, 0x07, 0x02, 0x0b, 0x0a, 0x14, 0x69,
-0x6a, 0x04, 0x01, 0x38, 0x01, 0x40, 0x44, 0x69, 0x66, 0x66,
-0xc9, 0x04, 0x62, 0x74, 0x79, 0x00, 0x00, 0x00, 0x43, 0x1c,
-0x08, 0x02, 0x42, 0x02, 0x15, 0x64, 0x1a, 0x00, 0x05, 0xa6,
-0x0a, 0xf0, 0x02, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65,
-0x64, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x2e, 0x00,
+0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x9a, 0x01, 0x30, 0x77,
+0x61, 0x73, 0x15, 0x02, 0x20, 0x65, 0x6e, 0x99, 0x00, 0xf1,
+0x01, 0x62, 0x79, 0x00, 0x44, 0x61, 0x76, 0x69, 0x64, 0x00,
+0x4d, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x2c, 0xf6, 0x02, 0x12,
+0x72, 0x79, 0x00, 0x00, 0x9a, 0x00, 0x41, 0x60, 0x48, 0x61,
+0x75, 0x29, 0x00, 0x12, 0x4d, 0x3f, 0x03, 0xf3, 0x03, 0x4d,
+0x61, 0x7a, 0x65, 0x27, 0x2e, 0x00, 0x53, 0x65, 0x65, 0x00,
+0x5b, 0x32, 0x30, 0x5d, 0x00, 0x66, 0x6f, 0xb6, 0x00, 0x61,
+0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x2b, 0x02, 0x02, 0xd9,
+0x03, 0x01, 0x68, 0x00, 0x00, 0xab, 0x03, 0x40, 0x72, 0x69,
+0x62, 0x75, 0x42, 0x00, 0x01, 0x89, 0x01, 0x20, 0x69, 0x73,
+0x76, 0x01, 0x01, 0x38, 0x01, 0x20, 0x6f, 0x6e, 0x7e, 0x00,
+0xd0, 0x53, 0x74, 0x65, 0x66, 0x66, 0x65, 0x6e, 0x00, 0x42,
+0x61, 0x75, 0x65, 0x72, 0x3e, 0x00, 0x01, 0x57, 0x00, 0xf4,
+0x29, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77,
+0x77, 0x2e, 0x6a, 0x61, 0x6e, 0x6b, 0x6f, 0x2e, 0x61, 0x74,
+0x2f, 0x52, 0x61, 0x65, 0x74, 0x73, 0x65, 0x6c, 0x2f, 0x53,
+0x70, 0x75, 0x6b, 0x73, 0x63, 0x68, 0x6c, 0x6f, 0x73, 0x73,
+0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d,
+0x00, 0x00, 0x00, 0x33, 0x37, 0x2e, 0x31, 0x55, 0x04, 0x01,
+0x78, 0x00, 0x46, 0x6f, 0x6c, 0x73, 0x20, 0x8f, 0x00, 0xe3,
+0x68, 0x61, 0x73, 0x00, 0x61, 0x00, 0x73, 0x69, 0x6d, 0x69,
+0x6c, 0x61, 0x72, 0x00, 0x21, 0x00, 0x70, 0x00, 0x73, 0x79,
+0x73, 0x74, 0x65, 0x6d, 0x9c, 0x00, 0xf0, 0x08, 0x53, 0x6f,
+0x6c, 0x6f, 0x2c, 0x00, 0x55, 0x6e, 0x65, 0x71, 0x75, 0x61,
+0x6c, 0x00, 0x61, 0x6e, 0x64, 0x00, 0x4b, 0x65, 0x65, 0x6e,
+0x2e, 0x42, 0x01, 0x63, 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79,
+0x49, 0x00, 0x71, 0x2c, 0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b,
+0x23, 0x01, 0x40, 0x6d, 0x6f, 0x75, 0x73, 0x62, 0x03, 0x01,
+0x2b, 0x03, 0x45, 0x65, 0x6d, 0x70, 0x74, 0x7d, 0x04, 0x12,
+0x61, 0xdf, 0x02, 0x12, 0x6e, 0x73, 0x01, 0x60, 0x61, 0x00,
+0x6c, 0x65, 0x74, 0x74, 0x23, 0x03, 0x02, 0x0b, 0x03, 0x84,
+0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64, 0xd2, 0x02,
+0x00, 0x7d, 0x02, 0x01, 0x4f, 0x03, 0x0a, 0x3a, 0x03, 0x51,
+0x3a, 0x00, 0x60, 0x47, 0x27, 0x63, 0x01, 0x05, 0x7c, 0x04,
+0x24, 0x60, 0x56, 0x11, 0x00, 0x08, 0x84, 0x04, 0x24, 0x60,
+0x5a, 0x16, 0x00, 0x04, 0x8c, 0x04, 0x12, 0x49, 0x04, 0x03,
+0x41, 0x6d, 0x61, 0x6b, 0x65, 0xfc, 0x04, 0x5e, 0x73, 0x74,
+0x61, 0x6b, 0x65, 0xbb, 0x00, 0x03, 0x9b, 0x03, 0x50, 0x69,
+0x6e, 0x63, 0x6f, 0x72, 0x0e, 0x04, 0x08, 0xbf, 0x00, 0xb0,
+0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53, 0x70, 0x61, 0x63,
+0x65, 0x20, 0x01, 0x50, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6f,
+0x02, 0x20, 0x61, 0x67, 0x7d, 0x05, 0x62, 0x28, 0x6f, 0x72,
+0x00, 0x75, 0x73, 0x9c, 0x04, 0xd0, 0x55, 0x6e, 0x64, 0x6f,
+0x00, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x29, 0x32,
+0x01, 0x03, 0x7e, 0x00, 0x10, 0x72, 0xee, 0x02, 0x12, 0x2d,
+0x74, 0x00, 0x00, 0x25, 0x01, 0x0f, 0x1d, 0x01, 0x0b, 0x02,
+0xef, 0x02, 0x01, 0x89, 0x00, 0x50, 0x73, 0x70, 0x6f, 0x6e,
+0x64, 0x15, 0x01, 0x04, 0x19, 0x03, 0x01, 0xfe, 0x02, 0x00,
+0xe0, 0x03, 0x31, 0x68, 0x6f, 0x77, 0xe7, 0x04, 0xb3, 0x72,
+0x65, 0x64, 0x75, 0x63, 0x65, 0x64, 0x00, 0x73, 0x69, 0x7a,
+0xc6, 0x00, 0x14, 0x61, 0xbd, 0x00, 0x21, 0x2c, 0x00, 0xea,
+0x01, 0xe1, 0x60, 0x70, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x00,
+0x6d, 0x61, 0x72, 0x6b, 0x27, 0x2e, 0xc0, 0x04, 0x00, 0x25,
+0x04, 0x57, 0x68, 0x61, 0x76, 0x65, 0x00, 0x1b, 0x00, 0x12,
+0x73, 0xc3, 0x02, 0x65, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
+0x8a, 0x03, 0x00, 0x22, 0x03, 0x06, 0x9f, 0x03, 0x02, 0x58,
+0x00, 0x34, 0x2e, 0x00, 0x41, 0xc1, 0x00, 0x03, 0x82, 0x06,
+0x11, 0x69, 0x4d, 0x04, 0x51, 0x66, 0x75, 0x6c, 0x6c, 0x2d,
+0x88, 0x00, 0x04, 0xae, 0x00, 0x31, 0x63, 0x61, 0x6e, 0x74,
+0x06, 0x00, 0xeb, 0x04, 0x04, 0xad, 0x06, 0x08, 0x73, 0x00,
+0x01, 0x55, 0x02, 0x00, 0x94, 0x04, 0x00, 0x5d, 0x00, 0x30,
+0x70, 0x61, 0x79, 0xa3, 0x06, 0x20, 0x00, 0x61, 0xf2, 0x04,
+0x01, 0x16, 0x03, 0x29, 0x74, 0x6f, 0x2e, 0x00, 0x00, 0xff,
+0x06, 0x40, 0x00, 0x65, 0x78, 0x61, 0xac, 0x05, 0x20, 0x00,
+0x77, 0xe8, 0x00, 0x00, 0x5c, 0x01, 0x03, 0x7c, 0x01, 0x11,
+0x6d, 0xbf, 0x00, 0x50, 0x69, 0x73, 0x00, 0x75, 0x70, 0x38,
+0x00, 0x63, 0x79, 0x6f, 0x75, 0x3a, 0x00, 0x79, 0xeb, 0x00,
+0x05, 0x23, 0x00, 0x70, 0x61, 0x73, 0x00, 0x72, 0x65, 0x6d,
+0x69, 0xda, 0x03, 0x12, 0x73, 0x2a, 0x01, 0x30, 0x61, 0x00,
+0x70, 0xf4, 0x04, 0x20, 0x63, 0x75, 0x0c, 0x03, 0x03, 0xd5,
+0x00, 0x50, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x45, 0x00, 0x10,
+0x62, 0xdc, 0x04, 0x91, 0x2d, 0x65, 0x78, 0x61, 0x6d, 0x69,
+0x6e, 0x65, 0x64, 0x4a, 0x04, 0x01, 0x54, 0x00, 0x42, 0x6b,
+0x6e, 0x6f, 0x77, 0xed, 0x03, 0x4b, 0x61, 0x62, 0x6f, 0x75,
+0x45, 0x00, 0x03, 0xfc, 0x00, 0x01, 0x8f, 0x02, 0x0f, 0x81,
+0x00, 0x01, 0x20, 0x6c, 0x69, 0xce, 0x06, 0x03, 0xe9, 0x05,
+0x32, 0x70, 0x6f, 0x73, 0x66, 0x06, 0x07, 0x23, 0x06, 0x13,
+0x61, 0xff, 0x07, 0x04, 0xc5, 0x01, 0x20, 0x6f, 0x72, 0x56,
+0x03, 0x20, 0x74, 0x68, 0x65, 0x01, 0x32, 0x65, 0x6c, 0x73,
+0x83, 0x00, 0x93, 0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c, 0x69,
+0x6b, 0x65, 0x98, 0x03, 0x51, 0x65, 0x72, 0x61, 0x73, 0x65,
+0xd7, 0x03, 0x39, 0x6e, 0x67, 0x6c, 0xd8, 0x01, 0x1c, 0x2c,
+0x7e, 0x02, 0x01, 0xce, 0x01, 0x07, 0x80, 0x02, 0x00, 0x7b,
+0x02, 0x05, 0xe2, 0x01, 0x03, 0x9f, 0x03, 0x01, 0xdb, 0x02,
+0x00, 0x5b, 0x00, 0x3a, 0x41, 0x6c, 0x6c, 0x25, 0x02, 0x09,
+0xbf, 0x02, 0x22, 0x72, 0x65, 0x79, 0x00, 0x12, 0x64, 0x53,
+0x07, 0x01, 0x6d, 0x06, 0x24, 0x65, 0x66, 0x6c, 0x00, 0x05,
+0x5e, 0x00, 0x15, 0x61, 0xdf, 0x00, 0x04, 0xe1, 0x02, 0x2f,
+0x6f, 0x72, 0x32, 0x00, 0x06, 0x07, 0x6e, 0x03, 0x31, 0x2e,
+0x00, 0x52, 0xbb, 0x00, 0x02, 0xae, 0x03, 0x01, 0x65, 0x02,
+0x04, 0x21, 0x00, 0x00, 0x0d, 0x00, 0x11, 0x73, 0x92, 0x03,
+0x01, 0x12, 0x03, 0x01, 0x62, 0x02, 0x02, 0x04, 0x01, 0x0c,
+0x60, 0x02, 0x12, 0x41, 0xd9, 0x02, 0x02, 0xd6, 0x04, 0x01,
+0x59, 0x03, 0x50, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x7b, 0x04,
+0x05, 0x2e, 0x07, 0x22, 0x75, 0x73, 0x74, 0x08, 0x62, 0x63,
+0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0x93, 0x05, 0x01, 0x11, 0x09,
+0x25, 0x74, 0x68, 0x13, 0x01, 0x01, 0x30, 0x00, 0x11, 0x74,
+0x02, 0x05, 0x17, 0x63, 0x1f, 0x03, 0x2b, 0x6f, 0x72, 0x72,
+0x00, 0x3d, 0x55, 0x73, 0x65, 0x67, 0x00, 0x60, 0x74, 0x6f,
+0x00, 0x6d, 0x6f, 0x76, 0x09, 0x01, 0x51, 0x68, 0x69, 0x67,
+0x68, 0x6c, 0xfc, 0x06, 0x07, 0xfb, 0x07, 0x00, 0x93, 0x07,
+0x1f, 0x2c, 0x2f, 0x01, 0x07, 0x00, 0x3f, 0x00, 0x00, 0xa5,
+0x06, 0x01, 0x75, 0x04, 0x03, 0xc1, 0x01, 0x05, 0x48, 0x00,
+0x25, 0x65, 0x64, 0x96, 0x03, 0x14, 0x50, 0x19, 0x01, 0x50,
+0x72, 0x65, 0x74, 0x75, 0x72, 0x3f, 0x03, 0x5a, 0x67, 0x67,
+0x6c, 0x65, 0x73, 0x30, 0x00, 0x02, 0x09, 0x08, 0x00, 0x63,
+0x00, 0x11, 0x64, 0x30, 0x04, 0x02, 0x51, 0x08, 0x04, 0xa9,
+0x02, 0x02, 0x67, 0x00, 0x20, 0x6f, 0x72, 0x27, 0x03, 0x1b,
+0x6f, 0x20, 0x04, 0x07, 0xd0, 0x04, 0x60, 0x70, 0x72, 0x65,
+0x66, 0x65, 0x72, 0x0b, 0x01, 0x23, 0x69, 0x6e, 0xa5, 0x00,
+0x05, 0xd3, 0x02, 0x81, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62,
+0x65, 0x74, 0x2b, 0x05, 0x26, 0x75, 0x74, 0xdb, 0x02, 0x51,
+0x70, 0x69, 0x63, 0x74, 0x75, 0xc6, 0x0a, 0x04, 0x6e, 0x00,
+0x02, 0xeb, 0x01, 0x31, 0x60, 0x41, 0x27, 0x13, 0x07, 0x01,
+0xae, 0x00, 0x50, 0x00, 0x62, 0x65, 0x74, 0x77, 0xbc, 0x08,
+0x00, 0xe1, 0x04, 0x04, 0x0e, 0x06, 0x05, 0x6d, 0x01, 0x29,
+0x61, 0x73, 0x79, 0x01, 0x07, 0x24, 0x00, 0x02, 0x5b, 0x03,
+0x02, 0x8a, 0x00, 0x00, 0xa9, 0x00, 0x15, 0x4c, 0x55, 0x02,
+0x02, 0x9c, 0x04, 0x33, 0x63, 0x6c, 0x75, 0x2b, 0x02, 0x00,
+0xcc, 0x00, 0x01, 0xbe, 0x05, 0x30, 0x73, 0x00, 0x64, 0xf0,
+0x0a, 0x50, 0x28, 0x67, 0x72, 0x65, 0x79, 0x11, 0x00, 0x41,
+0x6f, 0x75, 0x74, 0x29, 0x9a, 0x02, 0x24, 0x75, 0x6e, 0x24,
+0x00, 0x23, 0x69, 0x66, 0x57, 0x08, 0x71, 0x61, 0x6c, 0x72,
+0x65, 0x61, 0x64, 0x79, 0x3d, 0x00, 0x20, 0x65, 0x64, 0x61,
+0x00, 0x10, 0x28, 0x1a, 0x03, 0x01, 0xf0, 0x00, 0x01, 0x2f,
+0x02, 0x92, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
+0x62, 0x49, 0x02, 0x13, 0x73, 0xd8, 0x07, 0x36, 0x32, 0x2e,
+0x31, 0x2d, 0x0a, 0x82, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
+0x62, 0x6c, 0x8f, 0x08, 0x44, 0x33, 0x37, 0x2e, 0x32, 0xa6,
+0x07, 0x60, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0xbc, 0x00,
+0x12, 0x20, 0x12, 0x05, 0x00, 0xc8, 0x02, 0x05, 0x14, 0x00,
+0x02, 0x42, 0x00, 0x04, 0x3d, 0x00, 0x04, 0x9d, 0x09, 0xf1,
+0x01, 0x65, 0x00, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d,
+0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x70, 0x00, 0x03,
+0x57, 0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00,
+0x6d, 0x65, 0x6e, 0x75, 0xac, 0x00, 0x91, 0x57, 0x69, 0x64,
+0x74, 0x68, 0x2c, 0x00, 0x48, 0x65, 0x01, 0x02, 0x51, 0x00,
+0x00, 0x53, 0x69, 0x7a, 0x5e, 0x07, 0x01, 0x0b, 0x0a, 0x14,
+0x69, 0x6a, 0x04, 0x01, 0x38, 0x01, 0x40, 0x44, 0x69, 0x66,
+0x66, 0xc9, 0x04, 0x63, 0x74, 0x79, 0x00, 0x00, 0x00, 0x43,
+0x3d, 0x08, 0x01, 0x54, 0x00, 0x16, 0x64, 0x1a, 0x00, 0x04,
+0xa6, 0x0a, 0x50, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x82, 0x02,
+0x80, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3286;
diff --git a/apps/plugins/puzzles/help/unequal.c b/apps/plugins/puzzles/help/unequal.c
index 723b55967e..8c5d2fa9b8 100644
--- a/apps/plugins/puzzles/help/unequal.c
+++ b/apps/plugins/puzzles/help/unequal.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,19 +15,19 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 3934 comp 2353 ratio 0.598119 level 11 saved 1581 */
+/* orig 3934 comp 2352 ratio 0.597865 level 10 saved 1582 */
 const char help_text[] = {
 0xf4, 0x24, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x32, 0x37, 0x3a, 0x20, 0x55, 0x6e, 0x65, 0x71, 0x75, 0x61,
 0x6c, 0x20, 0x00, 0x00, 0x00, 0x59, 0x6f, 0x75, 0x00, 0x68,
 0x61, 0x76, 0x65, 0x00, 0x61, 0x00, 0x73, 0x71, 0x75, 0x61,
 0x72, 0x65, 0x00, 0x67, 0x72, 0x69, 0x64, 0x3b, 0x00, 0x65,
-0x61, 0x63, 0x68, 0x12, 0x00, 0xf2, 0x1d, 0x6d, 0x61, 0x79,
+0x61, 0x63, 0x68, 0x12, 0x00, 0xf1, 0x1a, 0x6d, 0x61, 0x79,
 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x61,
 0x00, 0x64, 0x69, 0x67, 0x69, 0x74, 0x00, 0x66, 0x72, 0x6f,
 0x6d, 0x00, 0x31, 0x00, 0x74, 0x6f, 0x00, 0x74, 0x68, 0x65,
-0x00, 0x73, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x66, 0x00, 0x74,
-0x68, 0x40, 0x00, 0xa3, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x00,
+0x00, 0x73, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x66, 0x0c, 0x00,
+0x00, 0x40, 0x00, 0xa3, 0x2c, 0x00, 0x61, 0x6e, 0x64, 0x00,
 0x73, 0x6f, 0x6d, 0x65, 0x44, 0x00, 0x12, 0x73, 0x65, 0x00,
 0x30, 0x63, 0x6c, 0x75, 0x2d, 0x00, 0xb0, 0x67, 0x6e, 0x73,
 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x33, 0x00,
@@ -38,62 +38,62 @@ const char help_text[] = {
 0x00, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x00, 0x73,
 0x75, 0x63, 0x68, 0x00, 0x74, 0x68, 0x61, 0x74, 0x3a, 0x00,
 0x00, 0x00, 0x2d, 0x00, 0x45, 0xb2, 0x00, 0x34, 0x72, 0x6f,
-0x77, 0xab, 0x00, 0xf0, 0x05, 0x73, 0x00, 0x6f, 0x6e, 0x6c,
+0x77, 0xab, 0x00, 0xf1, 0x05, 0x73, 0x00, 0x6f, 0x6e, 0x6c,
 0x79, 0x00, 0x6f, 0x6e, 0x65, 0x00, 0x6f, 0x63, 0x63, 0x75,
 0x72, 0x72, 0x65, 0x6e, 0x63, 0xa5, 0x00, 0x01, 0xdb, 0x00,
-0x02, 0xc6, 0x00, 0x06, 0x38, 0x00, 0x6f, 0x63, 0x6f, 0x6c,
-0x75, 0x6d, 0x6e, 0x3b, 0x00, 0x1d, 0x69, 0x41, 0x6c, 0x6c,
-0x00, 0x74, 0x68, 0xd7, 0x00, 0x00, 0x30, 0x01, 0xf1, 0x03,
+0x02, 0xc6, 0x00, 0x05, 0x38, 0x00, 0x6f, 0x63, 0x6f, 0x6c,
+0x75, 0x6d, 0x6e, 0x3b, 0x00, 0x1d, 0x31, 0x41, 0x6c, 0x6c,
+0x9c, 0x00, 0x07, 0xd7, 0x00, 0x00, 0x30, 0x01, 0xf1, 0x03,
 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x69, 0x65, 0x64, 0x2e,
 0x00, 0x00, 0x00, 0x54, 0x68, 0x65, 0x72, 0x65, 0x17, 0x00,
 0xf3, 0x0b, 0x74, 0x77, 0x6f, 0x00, 0x6d, 0x6f, 0x64, 0x65,
 0x73, 0x00, 0x66, 0x6f, 0x72, 0x00, 0x74, 0x68, 0x69, 0x73,
 0x00, 0x67, 0x61, 0x6d, 0x65, 0x2c, 0x00, 0x60, 0x90, 0x01,
 0x11, 0x27, 0x36, 0x01, 0xa0, 0x60, 0x41, 0x64, 0x6a, 0x61,
-0x63, 0x65, 0x6e, 0x74, 0x27, 0x3f, 0x00, 0x26, 0x49, 0x6e,
-0x1f, 0x00, 0x01, 0x3e, 0x00, 0x1c, 0x2c, 0x72, 0x00, 0x02,
-0xb4, 0x01, 0xf4, 0x11, 0x65, 0x61, 0x74, 0x65, 0x72, 0x2d,
+0x63, 0x65, 0x6e, 0x74, 0x27, 0x3f, 0x00, 0x27, 0x49, 0x6e,
+0x1f, 0x00, 0x00, 0x3e, 0x00, 0x1e, 0x2c, 0x72, 0x00, 0x00,
+0x1d, 0x01, 0xf1, 0x0e, 0x65, 0x61, 0x74, 0x65, 0x72, 0x2d,
 0x74, 0x68, 0x61, 0x6e, 0x00, 0x73, 0x79, 0x6d, 0x62, 0x6f,
 0x6c, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74,
-0x69, 0x6e, 0x67, 0x00, 0x6f, 0x6e, 0x89, 0x01, 0x50, 0x27,
+0x69, 0x6e, 0x67, 0xca, 0x00, 0x02, 0x89, 0x01, 0x50, 0x27,
 0x73, 0x00, 0x76, 0x61, 0x3d, 0x00, 0x24, 0x69, 0x73, 0x36,
-0x00, 0x11, 0x00, 0x36, 0x00, 0xf1, 0x04, 0x69, 0x74, 0x73,
+0x00, 0x11, 0x00, 0x36, 0x00, 0xf0, 0x01, 0x69, 0x74, 0x73,
 0x00, 0x6e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x75, 0x72,
-0x27, 0x73, 0x2e, 0x00, 0x49, 0x6e, 0xa4, 0x00, 0x01, 0x75,
+0x27, 0x73, 0x2e, 0x7a, 0x00, 0x01, 0xa4, 0x00, 0x00, 0x75,
 0x00, 0x81, 0x00, 0x6e, 0x6f, 0x74, 0x00, 0x61, 0x6c, 0x6c,
 0x78, 0x00, 0x11, 0x73, 0x11, 0x02, 0xf0, 0x18, 0x62, 0x65,
 0x00, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x2c, 0x00,
 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72,
 0x6c, 0x79, 0x00, 0x61, 0x74, 0x00, 0x68, 0x69, 0x67, 0x68,
-0x65, 0x72, 0x00, 0x64, 0x69, 0x66, 0x66, 0x17, 0x00, 0x92,
+0x65, 0x72, 0x00, 0x64, 0x69, 0x66, 0x66, 0x17, 0x00, 0x94,
 0x74, 0x79, 0x00, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x73, 0xd1,
-0x00, 0x06, 0xe2, 0x00, 0x0f, 0xd2, 0x00, 0x08, 0x3f, 0x62,
-0x61, 0x72, 0xc2, 0x00, 0x0f, 0x00, 0x0b, 0x02, 0x60, 0x65,
+0x00, 0x05, 0xe2, 0x00, 0x0f, 0xd2, 0x00, 0x07, 0x3f, 0x62,
+0x61, 0x72, 0xc2, 0x00, 0x10, 0x90, 0x6e, 0x75, 0x6d, 0x65,
 0x72, 0x69, 0x63, 0x61, 0x6c, 0x78, 0x00, 0x03, 0x55, 0x00,
-0x60, 0x00, 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x31, 0x00, 0x04,
+0x61, 0x00, 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x31, 0x00, 0x03,
 0x88, 0x00, 0x21, 0x6f, 0x72, 0x0e, 0x00, 0x6f, 0x6c, 0x6f,
-0x77, 0x65, 0x72, 0x29, 0xee, 0x00, 0x00, 0x0a, 0xec, 0x00,
-0x07, 0xe8, 0x00, 0x20, 0x61, 0x72, 0x0e, 0x00, 0x44, 0x77,
+0x77, 0x65, 0x72, 0x29, 0xee, 0x00, 0x00, 0x0b, 0xec, 0x00,
+0x06, 0xe8, 0x00, 0x20, 0x61, 0x72, 0x0e, 0x00, 0x44, 0x77,
 0x61, 0x79, 0x73, 0xec, 0x00, 0x54, 0x3a, 0x00, 0x61, 0x62,
-0x73, 0x0e, 0x02, 0x40, 0x61, 0x00, 0x62, 0x61, 0x3e, 0x01,
-0x81, 0x75, 0x73, 0x00, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x8d,
-0x02, 0x2f, 0x00, 0x61, 0xa8, 0x00, 0x00, 0xa0, 0x64, 0x65,
+0x73, 0x0e, 0x02, 0x10, 0x61, 0xa6, 0x00, 0xb1, 0x00, 0x74,
+0x68, 0x75, 0x73, 0x00, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x8d,
+0x02, 0x2f, 0x00, 0x61, 0xa8, 0x00, 0x00, 0xa1, 0x64, 0x65,
 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x79, 0x4a, 0x01,
-0x0f, 0xb7, 0x00, 0x03, 0x21, 0x74, 0x6f, 0x40, 0x00, 0x07,
-0x85, 0x01, 0x05, 0x30, 0x01, 0x8d, 0x54, 0x72, 0x69, 0x76,
-0x69, 0x61, 0x6c, 0x27, 0x52, 0x01, 0xa0, 0x00, 0x28, 0x61,
+0x0f, 0xb7, 0x00, 0x02, 0x22, 0x74, 0x6f, 0x40, 0x00, 0x09,
+0x85, 0x01, 0x02, 0x30, 0x01, 0x50, 0x54, 0x72, 0x69, 0x76,
+0x69, 0x01, 0x02, 0x0c, 0x52, 0x01, 0xa0, 0x00, 0x28, 0x61,
 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x8e, 0x01, 0x11,
 0x61, 0x49, 0x01, 0x81, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f,
-0x6d, 0x27, 0x5d, 0x02, 0xf5, 0x03, 0x00, 0x74, 0x79, 0x70,
+0x6d, 0x27, 0x5d, 0x02, 0xf1, 0x00, 0x00, 0x74, 0x79, 0x70,
 0x65, 0x00, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
-0x29, 0x2c, 0x00, 0x74, 0x8f, 0x02, 0x29, 0x6e, 0x6f, 0x37,
-0x02, 0x03, 0x7c, 0x01, 0x1c, 0x69, 0x70, 0x02, 0x11, 0x3b,
+0x29, 0x6b, 0x01, 0x03, 0x8f, 0x02, 0x2b, 0x6e, 0x6f, 0x37,
+0x02, 0x01, 0x7c, 0x01, 0x1c, 0x69, 0x70, 0x02, 0x11, 0x3b,
 0x55, 0x00, 0x63, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x9e,
 0x03, 0x42, 0x73, 0x6f, 0x6c, 0x76, 0x95, 0x03, 0x10, 0x4c,
-0x9d, 0x01, 0x03, 0xf0, 0x00, 0x01, 0x34, 0x03, 0x00, 0xb2,
+0x9d, 0x01, 0x04, 0x27, 0x04, 0x00, 0x34, 0x03, 0x00, 0xb2,
 0x00, 0x21, 0x41, 0x74, 0x1c, 0x00, 0x31, 0x74, 0x69, 0x6d,
-0x26, 0x01, 0x30, 0x77, 0x72, 0x69, 0xc2, 0x01, 0x01, 0x7b,
-0x00, 0x0a, 0x5c, 0x00, 0x03, 0x33, 0x04, 0x27, 0x69, 0x73,
+0x26, 0x01, 0x30, 0x77, 0x72, 0x69, 0xc2, 0x01, 0x02, 0xe6,
+0x01, 0x0a, 0x5c, 0x00, 0x02, 0x33, 0x04, 0x27, 0x69, 0x73,
 0x5f, 0x00, 0x60, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0xf2,
 0x01, 0x21, 0x69, 0x6e, 0x32, 0x00, 0xf1, 0x06, 0x47, 0x75,
 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x00, 0x77, 0x65, 0x65,
@@ -113,146 +113,146 @@ const char help_text[] = {
 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x3f, 0x00, 0xe1, 0x2c,
 0x00, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c,
 0x69, 0x63, 0x6b, 0xc4, 0x00, 0x60, 0x6d, 0x6f, 0x75, 0x73,
-0x65, 0x00, 0x58, 0x05, 0x83, 0x6e, 0x79, 0x00, 0x65, 0x6d,
-0x70, 0x74, 0x79, 0x4e, 0x01, 0x00, 0x0b, 0x04, 0x00, 0x22,
-0x00, 0x11, 0x6e, 0xc2, 0x01, 0x04, 0x77, 0x05, 0x00, 0xcb,
-0x02, 0x40, 0x6c, 0x65, 0x74, 0x74, 0xd5, 0x02, 0x02, 0x1f,
+0x65, 0x00, 0x58, 0x05, 0x84, 0x6e, 0x79, 0x00, 0x65, 0x6d,
+0x70, 0x74, 0x79, 0x4e, 0x01, 0x00, 0x0b, 0x04, 0x42, 0x74,
+0x68, 0x65, 0x6e, 0xc2, 0x01, 0x04, 0x77, 0x05, 0x70, 0x6f,
+0x72, 0x00, 0x6c, 0x65, 0x74, 0x74, 0xd5, 0x02, 0x02, 0x1f,
 0x01, 0x81, 0x6b, 0x65, 0x79, 0x62, 0x6f, 0x61, 0x72, 0x64,
-0x36, 0x05, 0x31, 0x69, 0x6c, 0x6c, 0x44, 0x02, 0x03, 0x44,
+0x36, 0x05, 0x32, 0x69, 0x6c, 0x6c, 0x44, 0x02, 0x02, 0x44,
 0x00, 0xc0, 0x2e, 0x00, 0x49, 0x66, 0x00, 0x79, 0x6f, 0x75,
-0x00, 0x6d, 0x61, 0x6b, 0x43, 0x00, 0x8c, 0x6d, 0x69, 0x73,
-0x74, 0x61, 0x6b, 0x65, 0x2c, 0x80, 0x00, 0x04, 0x6b, 0x01,
+0x00, 0x6d, 0x61, 0x6b, 0x43, 0x00, 0x8e, 0x6d, 0x69, 0x73,
+0x74, 0x61, 0x6b, 0x65, 0x2c, 0x80, 0x00, 0x02, 0x4c, 0x00,
 0x98, 0x69, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74,
 0x84, 0x00, 0xb0, 0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x53,
 0x70, 0x61, 0x63, 0x65, 0x64, 0x00, 0xb0, 0x63, 0x6c, 0x65,
 0x61, 0x72, 0x00, 0x69, 0x74, 0x00, 0x61, 0x67, 0x0f, 0x06,
-0x62, 0x28, 0x6f, 0x72, 0x00, 0x75, 0x73, 0x0d, 0x02, 0xd0,
+0x62, 0x28, 0x6f, 0x72, 0x00, 0x75, 0x73, 0x0d, 0x02, 0xd1,
 0x55, 0x6e, 0x64, 0x6f, 0x00, 0x66, 0x65, 0x61, 0x74, 0x75,
-0x72, 0x65, 0x29, 0xff, 0x00, 0x03, 0x7e, 0x00, 0x61, 0x72,
-0x69, 0x67, 0x68, 0x74, 0x2d, 0x74, 0x00, 0x01, 0xea, 0x00,
-0x0f, 0xe2, 0x00, 0x04, 0x03, 0xd8, 0x05, 0x11, 0x2c, 0xc2,
-0x00, 0x03, 0x0d, 0x00, 0x50, 0x00, 0x77, 0x69, 0x6c, 0x6c,
-0x6b, 0x04, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64,
-0xaa, 0x00, 0x05, 0x42, 0x00, 0xf1, 0x03, 0x73, 0x00, 0x61,
+0x72, 0x65, 0x29, 0xbb, 0x02, 0x02, 0x7e, 0x00, 0x62, 0x72,
+0x69, 0x67, 0x68, 0x74, 0x2d, 0x74, 0x00, 0x01, 0x42, 0x06,
+0x0f, 0xe2, 0x00, 0x04, 0x02, 0xd8, 0x05, 0x13, 0x2c, 0x06,
+0x03, 0x01, 0x0d, 0x00, 0x20, 0x00, 0x77, 0xd3, 0x00, 0xa4,
+0x62, 0x65, 0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64,
+0xaa, 0x00, 0x04, 0x42, 0x00, 0xf1, 0x03, 0x73, 0x00, 0x61,
 0x00, 0x60, 0x70, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x00, 0x6d,
 0x61, 0x72, 0x6b, 0x27, 0x2e, 0xd1, 0x06, 0x32, 0x63, 0x61,
-0x6e, 0x70, 0x06, 0x07, 0x1b, 0x00, 0x02, 0x76, 0x05, 0x84,
+0x6e, 0x70, 0x06, 0x07, 0x1b, 0x00, 0x02, 0x76, 0x05, 0x85,
 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x45, 0x06,
-0x05, 0x51, 0x00, 0x35, 0x61, 0x6d, 0x65, 0x36, 0x01, 0x12,
-0x53, 0xb3, 0x06, 0x04, 0x0e, 0x06, 0x31, 0x69, 0x6e, 0x67,
-0x5b, 0x01, 0x54, 0x65, 0x64, 0x2d, 0x69, 0x6e, 0x39, 0x00,
-0x00, 0x64, 0x00, 0x02, 0x15, 0x05, 0x24, 0x73, 0x6f, 0x29,
-0x00, 0x09, 0x6f, 0x00, 0x03, 0xfc, 0x05, 0x02, 0x86, 0x03,
-0x40, 0x70, 0x61, 0x79, 0x73, 0x71, 0x03, 0x51, 0x61, 0x74,
+0x04, 0x51, 0x00, 0x00, 0x4c, 0x02, 0x04, 0x36, 0x01, 0x13,
+0x53, 0xb3, 0x06, 0x03, 0x0e, 0x06, 0x00, 0x8d, 0x02, 0x00,
+0x5b, 0x01, 0x55, 0x65, 0x64, 0x2d, 0x69, 0x6e, 0x39, 0x00,
+0x32, 0x63, 0x61, 0x6e, 0x15, 0x05, 0x25, 0x73, 0x6f, 0x1d,
+0x07, 0x08, 0x6f, 0x00, 0x03, 0xfc, 0x05, 0x02, 0x86, 0x03,
+0x10, 0x70, 0x43, 0x04, 0x81, 0x6e, 0x6f, 0x00, 0x61, 0x74,
 0x74, 0x65, 0x6e, 0x7e, 0x02, 0x29, 0x74, 0x6f, 0x2e, 0x00,
 0xe0, 0x2c, 0x00, 0x73, 0x6f, 0x00, 0x65, 0x78, 0x61, 0x63,
-0x74, 0x6c, 0x79, 0x00, 0x77, 0x01, 0x01, 0x34, 0x79, 0x6f,
-0x75, 0x5a, 0x01, 0x10, 0x6d, 0xbb, 0x00, 0x00, 0x1d, 0x03,
-0x50, 0x75, 0x70, 0x00, 0x74, 0x6f, 0x1a, 0x00, 0x32, 0x3a,
-0x00, 0x79, 0xe7, 0x00, 0x05, 0x23, 0x00, 0x00, 0x0c, 0x01,
-0x40, 0x72, 0x65, 0x6d, 0x69, 0x1e, 0x03, 0x04, 0x89, 0x04,
-0x07, 0x98, 0x05, 0x04, 0x32, 0x01, 0x40, 0x6e, 0x65, 0x65,
-0x64, 0xc4, 0x03, 0x00, 0x54, 0x01, 0xd0, 0x72, 0x65, 0x2d,
-0x65, 0x78, 0x61, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x00, 0x6f,
-0xd3, 0x04, 0x00, 0x54, 0x00, 0x70, 0x6b, 0x6e, 0x6f, 0x77,
-0x00, 0x6d, 0x6f, 0x5d, 0x01, 0x3a, 0x62, 0x6f, 0x75, 0x45,
-0x00, 0x05, 0xa2, 0x01, 0x2f, 0x6f, 0x72, 0x80, 0x00, 0x02,
-0x54, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x07, 0x08, 0x6a, 0x70,
-0x6f, 0x73, 0x73, 0x69, 0x62, 0x6a, 0x01, 0x64, 0x61, 0x00,
-0x67, 0x69, 0x76, 0x65, 0x31, 0x04, 0x00, 0x48, 0x00, 0x00,
-0xf8, 0x02, 0x20, 0x74, 0x68, 0x62, 0x01, 0x32, 0x65, 0x6c,
-0x73, 0x82, 0x00, 0x93, 0x66, 0x65, 0x65, 0x6c, 0x00, 0x6c,
-0x69, 0x6b, 0x65, 0x42, 0x03, 0x41, 0x65, 0x72, 0x61, 0x73,
-0x9f, 0x08, 0x49, 0x69, 0x6e, 0x67, 0x6c, 0xd3, 0x01, 0x18,
-0x2c, 0x5b, 0x02, 0x0c, 0x1b, 0x02, 0x21, 0x6e, 0x64, 0x58,
-0x02, 0x04, 0xde, 0x01, 0x04, 0x88, 0x00, 0x02, 0xb8, 0x02,
-0x01, 0xa7, 0x04, 0x29, 0x6c, 0x6c, 0x83, 0x01, 0x0a, 0x9c,
-0x02, 0x22, 0x72, 0x65, 0x79, 0x00, 0x61, 0x64, 0x00, 0x77,
-0x68, 0x65, 0x6e, 0x99, 0x00, 0x33, 0x6c, 0x65, 0x66, 0x6c,
-0x00, 0x06, 0x5e, 0x00, 0x17, 0x61, 0x14, 0x01, 0x0f, 0x2a,
-0x00, 0x01, 0x07, 0x43, 0x03, 0x10, 0x73, 0x43, 0x03, 0x36,
-0x2e, 0x00, 0x52, 0xb3, 0x00, 0x35, 0x69, 0x6e, 0x67, 0x20,
-0x00, 0x00, 0xde, 0x00, 0x02, 0x23, 0x00, 0x01, 0xf4, 0x02,
-0x00, 0x58, 0x02, 0x03, 0xfb, 0x00, 0x0d, 0x56, 0x02, 0x11,
-0x41, 0xcb, 0x02, 0x01, 0x65, 0x04, 0x03, 0x3b, 0x07, 0x50,
-0x75, 0x72, 0x73, 0x6f, 0x72, 0x0b, 0x04, 0x01, 0x97, 0x02,
-0x00, 0xdc, 0x01, 0x20, 0x75, 0x73, 0x2d, 0x03, 0x01, 0xd1,
-0x08, 0x31, 0x6a, 0x75, 0x6e, 0xf1, 0x04, 0x01, 0x9b, 0x04,
-0x00, 0x30, 0x00, 0x02, 0x4b, 0x04, 0x00, 0x2f, 0x00, 0x02,
-0xce, 0x05, 0x25, 0x65, 0x74, 0xa4, 0x01, 0x29, 0x6f, 0x72,
-0x6e, 0x00, 0x05, 0x4e, 0x03, 0x01, 0x8f, 0x00, 0x05, 0xe9,
-0x03, 0x30, 0x60, 0x4d, 0x27, 0x3e, 0x00, 0x00, 0x3d, 0x00,
-0x51, 0x61, 0x75, 0x74, 0x6f, 0x2d, 0x78, 0x04, 0x54, 0x65,
-0x76, 0x65, 0x72, 0x79, 0xda, 0x06, 0xc0, 0x00, 0x68, 0x69,
-0x6e, 0x74, 0x2c, 0x00, 0x72, 0x65, 0x61, 0x64, 0x79, 0xad,
-0x00, 0x00, 0x9b, 0x02, 0x42, 0x6f, 0x76, 0x61, 0x6c, 0xa6,
-0x02, 0x60, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x33, 0x01,
-0x02, 0x4f, 0x00, 0x15, 0x48, 0x4f, 0x00, 0x26, 0x64, 0x6f,
-0xb0, 0x01, 0x23, 0x62, 0x75, 0x5e, 0x03, 0x22, 0x74, 0x6f,
-0x3f, 0x00, 0x02, 0x9a, 0x07, 0x71, 0x6f, 0x62, 0x76, 0x69,
-0x6f, 0x75, 0x73, 0x62, 0x00, 0x12, 0x73, 0xc8, 0x01, 0xc0,
-0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c,
-0x79, 0x2c, 0xa5, 0x00, 0x0d, 0x15, 0x01, 0x10, 0x74, 0x79,
-0x09, 0x02, 0xb3, 0x06, 0x01, 0xd9, 0x00, 0x75, 0x00, 0x61,
-0x72, 0x6f, 0x75, 0x6e, 0x64, 0x58, 0x0a, 0x34, 0x2e, 0x00,
-0x50, 0x83, 0x01, 0x20, 0x74, 0x68, 0x19, 0x03, 0x43, 0x74,
-0x75, 0x72, 0x6e, 0x94, 0x00, 0x56, 0x67, 0x67, 0x6c, 0x65,
-0x73, 0x3a, 0x00, 0x10, 0x28, 0xf9, 0x0a, 0x00, 0xf7, 0x01,
-0x42, 0x6f, 0x72, 0x6d, 0x61, 0x27, 0x01, 0x01, 0x08, 0x01,
-0x08, 0x38, 0x01, 0x24, 0x29, 0x2c, 0x21, 0x02, 0x35, 0x69,
-0x6e, 0x67, 0x23, 0x02, 0x00, 0x8f, 0x01, 0x2f, 0x69, 0x73,
-0xca, 0x04, 0x02, 0x04, 0x82, 0x05, 0x00, 0xfe, 0x06, 0x50,
-0x72, 0x6f, 0x70, 0x72, 0x69, 0xf5, 0x0a, 0x43, 0x77, 0x61,
-0x79, 0x3b, 0x44, 0x00, 0x02, 0x9b, 0x02, 0x20, 0x30, 0x00,
-0x6d, 0x05, 0x04, 0xa6, 0x00, 0x03, 0x2d, 0x02, 0x22, 0x62,
-0x61, 0x25, 0x05, 0x03, 0x99, 0x05, 0x13, 0x61, 0xaa, 0x04,
-0x05, 0xcc, 0x04, 0x58, 0x00, 0x00, 0x4c, 0x65, 0x66, 0x70,
-0x02, 0x00, 0xdb, 0x08, 0x01, 0x64, 0x02, 0x03, 0xbd, 0x00,
-0x20, 0x69, 0x74, 0x95, 0x01, 0x10, 0x64, 0x21, 0x09, 0x60,
-0x28, 0x67, 0x72, 0x65, 0x79, 0x00, 0x66, 0x06, 0x41, 0x75,
-0x74, 0x29, 0x2c, 0x6e, 0x00, 0x14, 0x6e, 0x24, 0x00, 0x10,
-0x69, 0xee, 0x06, 0x01, 0xa1, 0x07, 0x11, 0x6c, 0xd6, 0x01,
-0x01, 0x3d, 0x00, 0x00, 0xe2, 0x0a, 0x40, 0x48, 0x6f, 0x6c,
-0x64, 0x59, 0x00, 0x13, 0x43, 0x08, 0x07, 0x00, 0x9a, 0x02,
-0x4a, 0x68, 0x69, 0x66, 0x74, 0xda, 0x02, 0x00, 0x43, 0x02,
-0x40, 0x72, 0x72, 0x6f, 0x77, 0x55, 0x01, 0x01, 0xdd, 0x03,
-0x42, 0x77, 0x69, 0x73, 0x65, 0x65, 0x02, 0x00, 0x03, 0x04,
-0x01, 0x95, 0x00, 0x08, 0x0b, 0x09, 0x07, 0xc3, 0x01, 0x03,
-0x1c, 0x01, 0x03, 0x3b, 0x04, 0x31, 0x64, 0x69, 0x72, 0xc0,
-0x07, 0x01, 0xc3, 0x03, 0x14, 0x28, 0x81, 0x0b, 0x11, 0x61,
-0x13, 0x00, 0x00, 0x68, 0x09, 0x52, 0x73, 0x63, 0x72, 0x69,
-0x62, 0x5f, 0x01, 0x13, 0x73, 0xe9, 0x07, 0x30, 0x32, 0x2e,
-0x31, 0xd0, 0x03, 0x02, 0x4d, 0x02, 0x05, 0x30, 0x09, 0x22,
-0x2e, 0x29, 0xf1, 0x07, 0x15, 0x32, 0xf1, 0x07, 0xb2, 0x70,
-0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20,
-0xbc, 0x05, 0x35, 0x73, 0x65, 0x00, 0x14, 0x00, 0x01, 0x0d,
-0x0a, 0x06, 0x3e, 0x00, 0x01, 0x00, 0x0d, 0x08, 0x6f, 0x09,
-0x70, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x71, 0x00,
-0x04, 0x9b, 0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65, 0x27,
-0x00, 0x6d, 0x65, 0x6e, 0x75, 0xad, 0x00, 0x44, 0x4d, 0x6f,
-0x64, 0x65, 0x07, 0x00, 0x28, 0x6f, 0x66, 0x56, 0x09, 0x16,
-0x28, 0x16, 0x09, 0x27, 0x6f, 0x72, 0x1e, 0x0b, 0x00, 0xa2,
-0x00, 0x91, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x28, 0x73, 0x2a,
-0x73, 0x0d, 0x00, 0x02, 0x67, 0x0d, 0x03, 0xb4, 0x02, 0x36,
-0x00, 0x00, 0x44, 0x0f, 0x0a, 0x14, 0x00, 0x81, 0x01, 0x01,
-0xac, 0x02, 0x07, 0x29, 0x0a, 0x05, 0x97, 0x0d, 0x83, 0x65,
-0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x76, 0x00, 0x10,
-0x2e, 0xa8, 0x09, 0x03, 0x59, 0x0a, 0x02, 0x4d, 0x0a, 0x0f,
-0x1d, 0x0a, 0x0e, 0x0f, 0x0b, 0x0a, 0x1b, 0x01, 0x61, 0x00,
-0x20, 0x52, 0x65, 0xc5, 0x01, 0x34, 0x69, 0x76, 0x65, 0xb0,
-0x0a, 0x01, 0x59, 0x0d, 0x0f, 0xb5, 0x0a, 0x1b, 0x81, 0x00,
-0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0xc1, 0x02, 0x04,
-0x12, 0x08, 0x07, 0x47, 0x04, 0x21, 0x62, 0x75, 0x71, 0x0a,
-0x00, 0x8c, 0x00, 0x11, 0x75, 0x80, 0x01, 0x93, 0x73, 0x68,
-0x6f, 0x75, 0x6c, 0x64, 0x00, 0x73, 0x74, 0x2b, 0x00, 0xa2,
-0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x2e, 0x00, 0x54, 0x68,
-0x87, 0x00, 0x01, 0x1c, 0x0d, 0x04, 0x81, 0x0e, 0x03, 0x49,
-0x00, 0x01, 0xfe, 0x08, 0x31, 0x72, 0x65, 0x61, 0x66, 0x06,
-0x00, 0xef, 0x0e, 0x60, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x00,
-0x12, 0x00, 0x21, 0x6f, 0x6e, 0x73, 0x03, 0x00, 0x3c, 0x02,
-0x30, 0x6f, 0x69, 0x64, 0x59, 0x08, 0x31, 0x69, 0x6e, 0x67,
-0x44, 0x07, 0xa0, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63,
-0x6b, 0x2e, 0x00,
+0x74, 0x6c, 0x79, 0x00, 0x77, 0x01, 0x01, 0x00, 0x3a, 0x01,
+0x03, 0x5a, 0x01, 0x11, 0x6d, 0xbb, 0x00, 0x50, 0x69, 0x73,
+0x00, 0x75, 0x70, 0x38, 0x00, 0x63, 0x79, 0x6f, 0x75, 0x3a,
+0x00, 0x79, 0xe7, 0x00, 0x05, 0x23, 0x00, 0x70, 0x61, 0x73,
+0x00, 0x72, 0x65, 0x6d, 0x69, 0x1e, 0x03, 0x05, 0x89, 0x04,
+0x06, 0x98, 0x05, 0x04, 0x32, 0x01, 0x41, 0x6e, 0x65, 0x65,
+0x64, 0xc4, 0x03, 0xf0, 0x01, 0x62, 0x65, 0x00, 0x72, 0x65,
+0x2d, 0x65, 0x78, 0x61, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x00,
+0x6f, 0xd3, 0x04, 0x00, 0x54, 0x00, 0x70, 0x6b, 0x6e, 0x6f,
+0x77, 0x00, 0x6d, 0x6f, 0x5d, 0x01, 0x3b, 0x62, 0x6f, 0x75,
+0x45, 0x00, 0x04, 0xa2, 0x01, 0x2f, 0x6f, 0x72, 0x80, 0x00,
+0x02, 0x54, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x07, 0x08, 0x31,
+0x70, 0x6f, 0x73, 0x32, 0x05, 0x08, 0x6a, 0x01, 0x64, 0x61,
+0x00, 0x67, 0x69, 0x76, 0x65, 0x31, 0x04, 0x01, 0x48, 0x00,
+0x50, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x62, 0x01, 0x32, 0x65,
+0x6c, 0x73, 0x82, 0x00, 0x93, 0x66, 0x65, 0x65, 0x6c, 0x00,
+0x6c, 0x69, 0x6b, 0x65, 0x42, 0x03, 0x41, 0x65, 0x72, 0x61,
+0x73, 0x9f, 0x08, 0x49, 0x69, 0x6e, 0x67, 0x6c, 0xd3, 0x01,
+0x1c, 0x2c, 0x5b, 0x02, 0x08, 0x1b, 0x02, 0x22, 0x6e, 0x64,
+0x58, 0x02, 0x05, 0xde, 0x01, 0x03, 0x52, 0x02, 0x01, 0xb8,
+0x02, 0x01, 0xa7, 0x04, 0x2a, 0x6c, 0x6c, 0x20, 0x02, 0x09,
+0x9c, 0x02, 0x22, 0x72, 0x65, 0x79, 0x00, 0x30, 0x64, 0x00,
+0x77, 0xa3, 0x02, 0x00, 0x99, 0x00, 0x34, 0x6c, 0x65, 0x66,
+0x6c, 0x00, 0x05, 0x5e, 0x00, 0x18, 0x61, 0x14, 0x01, 0x0f,
+0x2a, 0x00, 0x05, 0x02, 0x43, 0x03, 0x10, 0x73, 0x43, 0x03,
+0x36, 0x2e, 0x00, 0x52, 0xb3, 0x00, 0x00, 0xf7, 0x00, 0x05,
+0x20, 0x00, 0x00, 0x0d, 0x00, 0x01, 0x23, 0x00, 0x02, 0xf4,
+0x02, 0x01, 0x58, 0x02, 0x02, 0xfb, 0x00, 0x0c, 0x56, 0x02,
+0x12, 0x41, 0xcb, 0x02, 0x00, 0x65, 0x04, 0x03, 0x3b, 0x07,
+0x50, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x0b, 0x04, 0x01, 0x97,
+0x02, 0x00, 0xdc, 0x01, 0x22, 0x75, 0x73, 0x2d, 0x03, 0x62,
+0x63, 0x6f, 0x6e, 0x6a, 0x75, 0x6e, 0xf1, 0x04, 0x01, 0x9b,
+0x04, 0x00, 0x30, 0x00, 0x02, 0x4b, 0x04, 0x01, 0x2f, 0x00,
+0x00, 0xce, 0x05, 0x25, 0x65, 0x74, 0xa4, 0x01, 0x2b, 0x6f,
+0x72, 0x6e, 0x00, 0x04, 0x4e, 0x03, 0x01, 0x8f, 0x00, 0x04,
+0xe9, 0x03, 0x30, 0x60, 0x4d, 0x27, 0x3e, 0x00, 0x00, 0x3d,
+0x00, 0x51, 0x61, 0x75, 0x74, 0x6f, 0x2d, 0x78, 0x04, 0x54,
+0x65, 0x76, 0x65, 0x72, 0x79, 0xda, 0x06, 0xc1, 0x00, 0x68,
+0x69, 0x6e, 0x74, 0x2c, 0x00, 0x72, 0x65, 0x61, 0x64, 0x79,
+0xad, 0x00, 0x72, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x61, 0x6c,
+0xa6, 0x02, 0x61, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x33,
+0x01, 0x01, 0x4f, 0x00, 0x15, 0x48, 0x4f, 0x00, 0x26, 0x64,
+0x6f, 0xb0, 0x01, 0x23, 0x62, 0x75, 0x5e, 0x03, 0x22, 0x74,
+0x6f, 0x3f, 0x00, 0x02, 0x9a, 0x07, 0x71, 0x6f, 0x62, 0x76,
+0x69, 0x6f, 0x75, 0x73, 0x62, 0x00, 0x12, 0x73, 0xc8, 0x01,
+0xc5, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
+0x6c, 0x79, 0x2c, 0xa5, 0x00, 0x08, 0x15, 0x01, 0x10, 0x74,
+0x79, 0x09, 0x03, 0xb3, 0x06, 0x00, 0xd9, 0x00, 0x75, 0x00,
+0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x58, 0x0a, 0x34, 0x2e,
+0x00, 0x50, 0x83, 0x01, 0x20, 0x74, 0x68, 0x19, 0x03, 0x43,
+0x74, 0x75, 0x72, 0x6e, 0x94, 0x00, 0x56, 0x67, 0x67, 0x6c,
+0x65, 0x73, 0x3a, 0x00, 0x11, 0x28, 0xf9, 0x0a, 0x72, 0x61,
+0x00, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x27, 0x01, 0x01, 0x08,
+0x01, 0x08, 0x38, 0x01, 0x24, 0x29, 0x2c, 0x21, 0x02, 0x01,
+0xe2, 0x01, 0x04, 0x7a, 0x02, 0x20, 0x69, 0x6e, 0xc4, 0x03,
+0x0f, 0xca, 0x04, 0x03, 0x03, 0x0e, 0x00, 0x80, 0x61, 0x70,
+0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0xf5, 0x0a, 0x44, 0x77,
+0x61, 0x79, 0x3b, 0x44, 0x00, 0x01, 0x9b, 0x02, 0x21, 0x30,
+0x00, 0x6d, 0x05, 0x04, 0xa6, 0x00, 0x02, 0x2d, 0x02, 0x23,
+0x62, 0x61, 0x25, 0x05, 0x02, 0x99, 0x05, 0x13, 0x61, 0xaa,
+0x04, 0x05, 0xcc, 0x04, 0x58, 0x00, 0x00, 0x4c, 0x65, 0x66,
+0x70, 0x02, 0x02, 0x69, 0x09, 0x01, 0x33, 0x00, 0x01, 0xbd,
+0x00, 0x20, 0x69, 0x74, 0x95, 0x01, 0x10, 0x64, 0x21, 0x09,
+0x60, 0x28, 0x67, 0x72, 0x65, 0x79, 0x00, 0x66, 0x06, 0x41,
+0x75, 0x74, 0x29, 0x2c, 0x6e, 0x00, 0x14, 0x6e, 0x24, 0x00,
+0x10, 0x69, 0xee, 0x06, 0x01, 0xa1, 0x07, 0x12, 0x6c, 0xd6,
+0x01, 0x00, 0x19, 0x00, 0x00, 0xe2, 0x0a, 0x40, 0x48, 0x6f,
+0x6c, 0x64, 0x59, 0x00, 0x13, 0x43, 0x08, 0x07, 0x00, 0x9a,
+0x02, 0x4a, 0x68, 0x69, 0x66, 0x74, 0xda, 0x02, 0x00, 0x43,
+0x02, 0x10, 0x72, 0x9d, 0x0b, 0x00, 0x55, 0x01, 0x00, 0xdd,
+0x03, 0x43, 0x77, 0x69, 0x73, 0x65, 0x78, 0x03, 0x00, 0xfb,
+0x06, 0x01, 0x95, 0x00, 0x0a, 0x0b, 0x09, 0x05, 0xc3, 0x01,
+0x03, 0x1c, 0x01, 0x02, 0x3b, 0x04, 0x32, 0x64, 0x69, 0x72,
+0xc0, 0x07, 0x00, 0xdb, 0x00, 0x14, 0x28, 0x81, 0x0b, 0x11,
+0x61, 0x13, 0x00, 0x00, 0x68, 0x09, 0x52, 0x73, 0x63, 0x72,
+0x69, 0x62, 0x5f, 0x01, 0x13, 0x73, 0xe9, 0x07, 0x33, 0x32,
+0x2e, 0x31, 0xca, 0x09, 0x35, 0x73, 0x6f, 0x00, 0x30, 0x09,
+0x22, 0x2e, 0x29, 0xf1, 0x07, 0x15, 0x32, 0xf1, 0x07, 0xb2,
+0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73,
+0x20, 0xbc, 0x05, 0x00, 0x7c, 0x03, 0x05, 0x14, 0x00, 0x02,
+0x43, 0x00, 0x05, 0x6e, 0x09, 0x01, 0x07, 0x02, 0x07, 0x6f,
+0x09, 0x71, 0x2e, 0x2e, 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x71,
+0x00, 0x03, 0x9b, 0x07, 0xb0, 0x60, 0x54, 0x79, 0x70, 0x65,
+0x27, 0x00, 0x6d, 0x65, 0x6e, 0x75, 0xad, 0x00, 0x10, 0x4d,
+0xf1, 0x08, 0x03, 0x07, 0x00, 0x28, 0x6f, 0x66, 0x56, 0x09,
+0x16, 0x28, 0x16, 0x09, 0x27, 0x6f, 0x72, 0x1e, 0x0b, 0x00,
+0xa2, 0x00, 0x94, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x28, 0x73,
+0x2a, 0x73, 0x0d, 0x00, 0x00, 0x3c, 0x00, 0x02, 0xb4, 0x02,
+0x36, 0x00, 0x00, 0x44, 0x0f, 0x0a, 0x14, 0x00, 0x81, 0x01,
+0x02, 0xac, 0x02, 0x07, 0x29, 0x0a, 0x04, 0x97, 0x0d, 0x50,
+0x65, 0x6e, 0x65, 0x72, 0x61, 0x0c, 0x09, 0x02, 0x76, 0x00,
+0x10, 0x2e, 0xa8, 0x09, 0x03, 0x59, 0x0a, 0x02, 0x4d, 0x0a,
+0x0f, 0x1d, 0x0a, 0x0e, 0x0f, 0x0b, 0x0a, 0x1d, 0x50, 0x41,
+0x74, 0x00, 0x52, 0x65, 0xc5, 0x01, 0x34, 0x69, 0x76, 0x65,
+0xb0, 0x0a, 0x01, 0x59, 0x0d, 0x0f, 0xb5, 0x0a, 0x1b, 0x82,
+0x00, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0xc1, 0x02,
+0x04, 0x12, 0x08, 0x06, 0x47, 0x04, 0x00, 0x29, 0x04, 0x01,
+0x11, 0x03, 0x31, 0x6f, 0x6c, 0x75, 0x80, 0x01, 0x93, 0x73,
+0x68, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x73, 0x74, 0x2b, 0x00,
+0x71, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x2e, 0x8f, 0x07,
+0x02, 0x89, 0x0c, 0x00, 0x1f, 0x02, 0x04, 0x81, 0x0e, 0x03,
+0x49, 0x00, 0x00, 0xfe, 0x08, 0x31, 0x72, 0x65, 0x61, 0x66,
+0x06, 0x00, 0xef, 0x0e, 0x60, 0x6d, 0x70, 0x6c, 0x65, 0x78,
+0x00, 0x12, 0x00, 0x21, 0x6f, 0x6e, 0x73, 0x03, 0x00, 0x3c,
+0x02, 0x30, 0x6f, 0x69, 0x64, 0x59, 0x08, 0x03, 0x10, 0x00,
+0xb0, 0x62, 0x61, 0x63, 0x6b, 0x74, 0x72, 0x61, 0x63, 0x6b,
+0x2e, 0x00,
 };
 
 const unsigned short help_text_len = 3934;
diff --git a/apps/plugins/puzzles/help/unruly.c b/apps/plugins/puzzles/help/unruly.c
index 19c1815991..55c4d5240f 100644
--- a/apps/plugins/puzzles/help/unruly.c
+++ b/apps/plugins/puzzles/help/unruly.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
@@ -15,7 +15,7 @@ struct style_text help_text_style[] = {
  LAST_STYLE_ITEM
 };
 
-/* orig 1688 comp 1225 ratio 0.725711 level 11 saved 463 */
+/* orig 1688 comp 1225 ratio 0.725711 level 10 saved 463 */
 const char help_text[] = {
 0xf0, 0x4d, 0x43, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20,
 0x33, 0x38, 0x3a, 0x20, 0x55, 0x6e, 0x72, 0x75, 0x6c, 0x79,
@@ -36,13 +36,13 @@ const char help_text[] = {
 0x6c, 0x00, 0x69, 0x6e, 0x2e, 0x00, 0x45, 0x61, 0x63, 0x68,
 0x00, 0x72, 0x6f, 0x77, 0x00, 0x61, 0x6e, 0x64, 0x75, 0x00,
 0x34, 0x75, 0x6d, 0x6e, 0x81, 0x00, 0x51, 0x6e, 0x74, 0x61,
-0x69, 0x6e, 0x47, 0x00, 0xe2, 0x73, 0x61, 0x6d, 0x65, 0x00,
-0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x6f, 0x66, 0x8e,
-0x00, 0x00, 0x31, 0x00, 0x02, 0x8f, 0x00, 0x05, 0xc4, 0x00,
-0x01, 0x13, 0x00, 0x21, 0x6e, 0x6f, 0x4f, 0x00, 0x25, 0x6f,
+0x69, 0x6e, 0x47, 0x00, 0xb0, 0x73, 0x61, 0x6d, 0x65, 0x00,
+0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xb4, 0x00, 0x02, 0x8e,
+0x00, 0x00, 0x31, 0x00, 0x01, 0x8f, 0x00, 0x06, 0xc4, 0x00,
+0x00, 0x13, 0x00, 0x21, 0x6e, 0x6f, 0x4f, 0x00, 0x25, 0x6f,
 0x72, 0x4e, 0x00, 0x27, 0x61, 0x79, 0x4d, 0x00, 0x30, 0x72,
 0x65, 0x65, 0x0e, 0x00, 0x76, 0x73, 0x65, 0x63, 0x75, 0x74,
-0x69, 0x76, 0xc5, 0x00, 0x25, 0x6f, 0x66, 0x6a, 0x00, 0x03,
+0x69, 0x76, 0xc5, 0x00, 0x26, 0x6f, 0x66, 0x6a, 0x00, 0x02,
 0xfc, 0x00, 0xf1, 0x2d, 0x2e, 0x00, 0x00, 0x00, 0x54, 0x68,
 0x69, 0x73, 0x00, 0x70, 0x75, 0x7a, 0x7a, 0x6c, 0x65, 0x00,
 0x74, 0x79, 0x70, 0x65, 0x00, 0x77, 0x61, 0x73, 0x00, 0x69,
@@ -54,9 +54,9 @@ const char help_text[] = {
 0x00, 0x56, 0x6f, 0x68, 0x75, 0x27, 0x2e, 0x00, 0x53, 0x65,
 0x65, 0x00, 0x5b, 0x32, 0x31, 0x5d, 0x0d, 0x01, 0xc0, 0x6d,
 0x6f, 0x72, 0x65, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c,
-0x73, 0x6f, 0x00, 0x02, 0xaf, 0x01, 0x00, 0x65, 0x00, 0x01,
-0xb2, 0x00, 0x70, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64,
-0x30, 0x01, 0x40, 0x74, 0x68, 0x69, 0x73, 0x98, 0x00, 0x70,
+0x73, 0x6f, 0x00, 0x02, 0xaf, 0x01, 0x01, 0x65, 0x00, 0x00,
+0xb2, 0x00, 0x40, 0x72, 0x69, 0x62, 0x75, 0x68, 0x00, 0x60,
+0x74, 0x6f, 0x00, 0x74, 0x68, 0x69, 0x14, 0x00, 0x80, 0x6c,
 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x7b, 0x00, 0xe0,
 0x4c, 0x65, 0x6e, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x53, 0x70,
 0x72, 0x6f, 0x6e, 0x67, 0x3f, 0x00, 0x01, 0x58, 0x00, 0xf0,
@@ -68,66 +68,66 @@ const char help_text[] = {
 0x00, 0x00, 0x00, 0x33, 0x38, 0x2e, 0x31, 0x2d, 0x02, 0x01,
 0x7a, 0x00, 0x40, 0x6f, 0x6c, 0x73, 0x20, 0x00, 0x01, 0x63,
 0x6f, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x99, 0x00, 0x71, 0x2c,
-0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xdd, 0x00, 0xa3, 0x6d,
-0x6f, 0x75, 0x73, 0x65, 0x00, 0x69, 0x6e, 0x00, 0x61, 0x43,
+0x00, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0xdd, 0x00, 0x70, 0x6d,
+0x6f, 0x75, 0x73, 0x65, 0x00, 0x69, 0x4b, 0x02, 0x02, 0x43,
 0x01, 0x00, 0xa6, 0x00, 0xa5, 0x63, 0x68, 0x61, 0x6e, 0x67,
 0x65, 0x00, 0x69, 0x74, 0x73, 0x44, 0x01, 0x51, 0x4c, 0x65,
 0x66, 0x74, 0x2d, 0x37, 0x00, 0xc4, 0x69, 0x6e, 0x67, 0x00,
 0x61, 0x6e, 0x00, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x34, 0x00,
 0x10, 0x77, 0x07, 0x02, 0x72, 0x74, 0x75, 0x72, 0x6e, 0x00,
-0x69, 0x74, 0xd7, 0x01, 0x02, 0xc5, 0x01, 0x46, 0x72, 0x69,
-0x67, 0x68, 0x37, 0x00, 0x09, 0x27, 0x00, 0x04, 0x83, 0x02,
-0x54, 0x4b, 0x65, 0x65, 0x70, 0x00, 0x22, 0x00, 0x06, 0xbc,
+0x69, 0x74, 0xd7, 0x01, 0x02, 0xc5, 0x01, 0x47, 0x72, 0x69,
+0x67, 0x68, 0x37, 0x00, 0x09, 0x27, 0x00, 0x03, 0x83, 0x02,
+0x55, 0x4b, 0x65, 0x65, 0x70, 0x00, 0x22, 0x00, 0x05, 0xbc,
 0x01, 0x61, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x8d, 0x00,
-0x40, 0x79, 0x63, 0x6c, 0x65, 0xf2, 0x01, 0x40, 0x6f, 0x75,
-0x67, 0x68, 0x21, 0x00, 0x03, 0xfe, 0x01, 0xf1, 0x00, 0x70,
+0x40, 0x79, 0x63, 0x6c, 0x65, 0xf2, 0x01, 0x41, 0x6f, 0x75,
+0x67, 0x68, 0x21, 0x00, 0x02, 0xfe, 0x01, 0xf1, 0x00, 0x70,
 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x73, 0x74,
 0x61, 0x74, 0x65, 0x73, 0x89, 0x01, 0x24, 0x74, 0x68, 0x0a,
 0x02, 0x42, 0x2e, 0x00, 0x49, 0x66, 0x06, 0x03, 0x52, 0x69,
 0x64, 0x64, 0x6c, 0x65, 0x84, 0x00, 0x09, 0xe8, 0x00, 0x22,
-0x69, 0x74, 0x90, 0x00, 0x11, 0x62, 0xdf, 0x02, 0x52, 0x65,
-0x74, 0x00, 0x74, 0x6f, 0xd5, 0x00, 0x13, 0x2e, 0x67, 0x03,
-0xc1, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00,
-0x75, 0x73, 0x65, 0x5a, 0x00, 0xb0, 0x63, 0x75, 0x72, 0x73,
-0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x2d, 0x00, 0xb0,
+0x69, 0x74, 0x90, 0x00, 0x11, 0x62, 0xdf, 0x02, 0x20, 0x65,
+0x74, 0x6c, 0x00, 0x01, 0xd5, 0x00, 0x13, 0x2e, 0x67, 0x03,
+0x90, 0x63, 0x61, 0x6e, 0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00,
+0x22, 0x01, 0x00, 0x5a, 0x00, 0xb0, 0x63, 0x75, 0x72, 0x73,
+0x6f, 0x72, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x2d, 0x00, 0xb1,
 0x6d, 0x6f, 0x76, 0x65, 0x00, 0x61, 0x72, 0x6f, 0x75, 0x6e,
-0x64, 0x1f, 0x00, 0x01, 0x8b, 0x03, 0x74, 0x2e, 0x00, 0x50,
-0x72, 0x65, 0x73, 0x73, 0xcb, 0x00, 0x20, 0x72, 0x65, 0xee,
-0x00, 0x00, 0xc5, 0x02, 0x51, 0x73, 0x70, 0x61, 0x63, 0x65,
+0x64, 0x1f, 0x00, 0x00, 0x8b, 0x03, 0x74, 0x2e, 0x00, 0x50,
+0x72, 0x65, 0x73, 0x73, 0xcb, 0x00, 0x21, 0x72, 0x65, 0xee,
+0x00, 0x82, 0x6f, 0x72, 0x00, 0x73, 0x70, 0x61, 0x63, 0x65,
 0x3b, 0x00, 0x06, 0x06, 0x01, 0x0c, 0x47, 0x01, 0x0a, 0x9f,
-0x03, 0x01, 0x97, 0x00, 0x30, 0x70, 0x65, 0x63, 0xdf, 0x02,
+0x03, 0x00, 0x97, 0x00, 0x30, 0x70, 0x65, 0x63, 0xdf, 0x02,
 0x52, 0x6c, 0x79, 0x00, 0x28, 0x61, 0x67, 0x00, 0x15, 0x6e,
 0x11, 0x01, 0x04, 0xe1, 0x02, 0x28, 0x73, 0x00, 0x5f, 0x03,
-0x65, 0x77, 0x61, 0x79, 0x00, 0x61, 0x73, 0xdc, 0x01, 0x04,
+0x30, 0x77, 0x61, 0x79, 0xbd, 0x03, 0x06, 0xdc, 0x01, 0x02,
 0x4a, 0x01, 0x22, 0x73, 0x29, 0x92, 0x01, 0x14, 0x70, 0x9f,
-0x00, 0x40, 0x42, 0x61, 0x63, 0x6b, 0x95, 0x00, 0x02, 0xbd,
-0x01, 0x02, 0x03, 0x01, 0x05, 0x1d, 0x01, 0x09, 0x0c, 0x01,
+0x00, 0x42, 0x42, 0x61, 0x63, 0x6b, 0x95, 0x00, 0x01, 0x90,
+0x00, 0x02, 0x03, 0x01, 0x08, 0x05, 0x02, 0x05, 0x0c, 0x01,
 0x41, 0x28, 0x41, 0x6c, 0x6c, 0x50, 0x00, 0x11, 0x61, 0xb4,
 0x02, 0xb0, 0x73, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
-0x62, 0x65, 0x64, 0x79, 0x00, 0x13, 0x73, 0xca, 0x02, 0x30,
-0x32, 0x2e, 0x31, 0x22, 0x04, 0x02, 0x32, 0x01, 0xb2, 0x61,
+0x62, 0x65, 0x64, 0x79, 0x00, 0x13, 0x73, 0xca, 0x02, 0x31,
+0x32, 0x2e, 0x31, 0x22, 0x04, 0x01, 0x32, 0x01, 0xb2, 0x61,
 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x29,
 0x96, 0x02, 0x14, 0x32, 0x96, 0x02, 0x92, 0x70, 0x61, 0x72,
-0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x98, 0x02, 0x55, 0x68,
-0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x01, 0x84, 0x04, 0x06,
+0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x98, 0x02, 0x56, 0x68,
+0x65, 0x73, 0x65, 0x00, 0x14, 0x00, 0x02, 0x42, 0x00, 0x04,
 0x3d, 0x00, 0x51, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x7a, 0x00,
 0xe1, 0x60, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x2e,
 0x2e, 0x27, 0x00, 0x6f, 0x70, 0x70, 0x00, 0x22, 0x6f, 0x6e,
 0x1a, 0x00, 0xa0, 0x54, 0x79, 0x70, 0x65, 0x27, 0x00, 0x6d,
 0x65, 0x6e, 0x75, 0xac, 0x00, 0x90, 0x57, 0x69, 0x64, 0x74,
-0x68, 0x2c, 0x00, 0x48, 0x65, 0x79, 0x02, 0xa2, 0x00, 0x00,
-0x00, 0x53, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x66, 0x27, 0x05,
+0x68, 0x2c, 0x00, 0x48, 0x65, 0x79, 0x02, 0x70, 0x00, 0x00,
+0x00, 0x53, 0x69, 0x7a, 0x65, 0x14, 0x04, 0x01, 0x27, 0x05,
 0x24, 0x69, 0x6e, 0x27, 0x04, 0x60, 0x2e, 0x00, 0x28, 0x4e,
 0x6f, 0x74, 0x45, 0x01, 0x22, 0x61, 0x74, 0xa9, 0x01, 0x26,
 0x75, 0x6c, 0x3d, 0x04, 0x30, 0x67, 0x61, 0x6d, 0x7d, 0x01,
 0x30, 0x71, 0x75, 0x69, 0x94, 0x01, 0x22, 0x6f, 0x74, 0x76,
 0x02, 0x10, 0x77, 0x5b, 0x00, 0x01, 0x44, 0x01, 0x12, 0x68,
-0x5e, 0x00, 0x20, 0x74, 0x6f, 0x3c, 0x02, 0x43, 0x65, 0x76,
-0x65, 0x6e, 0xd4, 0x04, 0x11, 0x73, 0xee, 0x00, 0xe2, 0x44,
+0x5e, 0x00, 0x20, 0x74, 0x6f, 0x3c, 0x02, 0x10, 0x65, 0x88,
+0x05, 0x02, 0xd4, 0x04, 0x11, 0x73, 0xee, 0x00, 0xe3, 0x44,
 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x00,
-0x00, 0x00, 0x43, 0x85, 0x03, 0x02, 0x90, 0x01, 0x15, 0x64,
-0x1a, 0x00, 0x05, 0x6a, 0x00, 0x83, 0x65, 0x6e, 0x65, 0x72,
-0x61, 0x74, 0x65, 0x64, 0x9d, 0x04, 0x02, 0x3d, 0x04, 0xe2,
+0x00, 0x00, 0x43, 0x85, 0x03, 0x01, 0x42, 0x00, 0x16, 0x64,
+0x1a, 0x00, 0x04, 0x6a, 0x00, 0x50, 0x65, 0x6e, 0x65, 0x72,
+0x61, 0x1c, 0x04, 0x02, 0x9d, 0x04, 0x02, 0x3d, 0x04, 0xe2,
 0x69, 0x71, 0x75, 0x65, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x20,
 0x61, 0x6e, 0x64, 0x20, 0xff, 0x04, 0x30, 0x73, 0x00, 0x00,
 0xd2, 0x02, 0x20, 0x65, 0x6e, 0x19, 0x01, 0x20, 0x64, 0x2c,
diff --git a/apps/plugins/puzzles/help/untangle.c b/apps/plugins/puzzles/help/untangle.c
index 193629778f..24f9d83986 100644
--- a/apps/plugins/puzzles/help/untangle.c
+++ b/apps/plugins/puzzles/help/untangle.c
@@ -1,4 +1,4 @@
-/* auto-generated on Apr 24 2018 by genhelp.sh */
+/* auto-generated on Dec 21 2018 by genhelp.sh */
 /* help text is compressed using LZ4; see compress.c for details */
 /* DO NOT EDIT! */
 
diff --git a/apps/plugins/puzzles/rockbox.c b/apps/plugins/puzzles/rockbox.c
index 231df5ab48..8a25038255 100644
--- a/apps/plugins/puzzles/rockbox.c
+++ b/apps/plugins/puzzles/rockbox.c
@@ -1661,7 +1661,7 @@ static int process_input(int tmo, bool do_pausemenu)
         int new_x = mouse_x, new_y = mouse_y;
 
         /* in src/misc.c */
-        move_cursor(state, &new_x, &new_y, LCD_WIDTH, LCD_HEIGHT, FALSE);
+        move_cursor(state, &new_x, &new_y, LCD_WIDTH, LCD_HEIGHT, false);
 
         int dx = new_x - mouse_x, dy = new_y - mouse_y;
 
@@ -1902,7 +1902,7 @@ static void zoom(void)
     zoom_clipl = 0;
     zoom_clipr = zoom_w;
 
-    midend_size(me, &zoom_w, &zoom_h, TRUE);
+    midend_size(me, &zoom_w, &zoom_h, true);
 
     /* Allocating the framebuffer will mostly likely grab the
      * audiobuffer, which will make impossible to load new fonts, and
@@ -2828,7 +2828,7 @@ static void fix_size(void)
     rb->lcd_setfont(cur_font = FONT_UI);
     rb->lcd_getstringsize("X", NULL, &h_x);
     h -= h_x;
-    midend_size(me, &w, &h, TRUE);
+    midend_size(me, &w, &h, true);
 }
 
 static void init_tlsf(void)
diff --git a/apps/plugins/puzzles/src/Buildscr b/apps/plugins/puzzles/src/Buildscr
index b2a4dd58db..21a3bdf30c 100644
--- a/apps/plugins/puzzles/src/Buildscr
+++ b/apps/plugins/puzzles/src/Buildscr
@@ -34,7 +34,7 @@ ifneq "$(NOICONS)" yes then
   in puzzles do make -j$(nproc)
 
   # Now build the screenshots and icons.
-  in puzzles/icons do xvfb-run -s "-screen 0 1024x768x24" make web winicons gtkicons -j$(nproc)
+  in puzzles/icons do make web winicons gtkicons -j$(nproc)
 
   # Destroy the local binaries and autoconf detritus, mostly to avoid
   # wasting network bandwidth by transferring them to the delegate
diff --git a/apps/plugins/puzzles/src/blackbox.c b/apps/plugins/puzzles/src/blackbox.c
index caaa9eb963..c52c50812d 100644
--- a/apps/plugins/puzzles/src/blackbox.c
+++ b/apps/plugins/puzzles/src/blackbox.c
@@ -59,13 +59,13 @@ static const game_params blackbox_presets[] = {
     { 10, 10, 4, 10 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     char str[80];
     game_params *ret;
 
     if (i < 0 || i >= lenof(blackbox_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = blackbox_presets[i];
@@ -79,7 +79,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -129,7 +129,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[256];
 
@@ -184,7 +184,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
         return "Width and height must both be at least two";
@@ -209,7 +209,7 @@ static const char *validate_params(const game_params *params, int full)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int nballs = params->minballs, i;
     char *grid, *ret;
@@ -242,7 +242,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     }
     sfree(grid);
 
-    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, FALSE);
+    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, false);
     ret = bin2hex(bmp, nballs*2 + 2);
     sfree(bmp);
 
@@ -263,7 +263,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
         return "Game description is wrong length";
 
     bmp = hex2bin(desc, nballs*2 + 2);
-    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, TRUE);
+    obfuscate_bitmap(bmp, (nballs*2 + 2) * 8, true);
     ret = "Game description is corrupted";
     /* check general grid size */
     if (bmp[0] != params->w || bmp[1] != params->h)
@@ -299,9 +299,10 @@ struct game_state {
     int w, h, minballs, maxballs, nballs, nlasers;
     unsigned int *grid; /* (w+2)x(h+2), to allow for laser firing range */
     unsigned int *exits; /* one per laser */
-    int done;           /* user has finished placing his own balls. */
+    bool done;          /* user has finished placing his own balls. */
     int laserno;        /* number of next laser to be fired. */
-    int nguesses, reveal, justwrong, nright, nwrong, nmissed;
+    int nguesses, nright, nwrong, nmissed;
+    bool reveal, justwrong;
 };
 
 #define GRID(s,x,y) ((s)->grid[(y)*((s)->w+2) + (x)])
@@ -326,18 +327,18 @@ static const char *dirstrs[] = {
 };
 #endif
 
-static int range2grid(const game_state *state, int rangeno, int *x, int *y,
-                      int *direction)
+static bool range2grid(const game_state *state, int rangeno, int *x, int *y,
+                       int *direction)
 {
     if (rangeno < 0)
-        return 0;
+        return false;
 
     if (rangeno < state->w) {
         /* top row; from (1,0) to (w,0) */
         *x = rangeno + 1;
         *y = 0;
         *direction = DIR_DOWN;
-        return 1;
+        return true;
     }
     rangeno -= state->w;
     if (rangeno < state->h) {
@@ -345,7 +346,7 @@ static int range2grid(const game_state *state, int rangeno, int *x, int *y,
         *x = state->w+1;
         *y = rangeno + 1;
         *direction = DIR_LEFT;
-        return 1;
+        return true;
     }
     rangeno -= state->h;
     if (rangeno < state->w) {
@@ -353,7 +354,7 @@ static int range2grid(const game_state *state, int rangeno, int *x, int *y,
         *x = (state->w - rangeno);
         *y = state->h+1;
         *direction = DIR_UP;
-        return 1;
+        return true;
     }
     rangeno -= state->w;
     if (rangeno < state->h) {
@@ -361,20 +362,20 @@ static int range2grid(const game_state *state, int rangeno, int *x, int *y,
         *x = 0;
         *y = (state->h - rangeno);
         *direction = DIR_RIGHT;
-        return 1;
+        return true;
     }
-    return 0;
+    return false;
 }
 
-static int grid2range(const game_state *state, int x, int y, int *rangeno)
+static bool grid2range(const game_state *state, int x, int y, int *rangeno)
 {
     int ret, x1 = state->w+1, y1 = state->h+1;
 
-    if (x > 0 && x < x1 && y > 0 && y < y1) return 0; /* in arena */
-    if (x < 0 || x > x1 || y < 0 || y > y1) return 0; /* outside grid */
+    if (x > 0 && x < x1 && y > 0 && y < y1) return false; /* in arena */
+    if (x < 0 || x > x1 || y < 0 || y > y1) return false; /* outside grid */
 
     if ((x == 0 || x == x1) && (y == 0 || y == y1))
-        return 0; /* one of 4 corners */
+        return false; /* one of 4 corners */
 
     if (y == 0) {               /* top line */
         ret = x - 1;
@@ -387,7 +388,7 @@ static int grid2range(const game_state *state, int x, int y, int *rangeno)
     }
     *rangeno = ret;
     debug(("grid2range: (%d,%d) rangeno = %d\n", x, y, ret));
-    return 1;
+    return true;
 }
 
 static game_state *new_game(midend *me, const game_params *params,
@@ -402,7 +403,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->nballs = ((dlen/2)-2)/2;
 
     bmp = hex2bin(desc, state->nballs*2 + 2);
-    obfuscate_bitmap(bmp, (state->nballs*2 + 2) * 8, TRUE);
+    obfuscate_bitmap(bmp, (state->nballs*2 + 2) * 8, true);
 
     state->w = bmp[0]; state->h = bmp[1];
     state->nlasers = 2 * (state->w + state->h);
@@ -418,8 +419,10 @@ static game_state *new_game(midend *me, const game_params *params,
     }
     sfree(bmp);
 
-    state->done = state->nguesses = state->reveal = state->justwrong =
-        state->nright = state->nwrong = state->nmissed = 0;
+    state->done = false;
+    state->justwrong = false;
+    state->reveal = false;
+    state->nguesses = state->nright = state->nwrong = state->nmissed = 0;
     state->laserno = 1;
 
     return state;
@@ -465,9 +468,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -477,8 +480,10 @@ static char *game_text_format(const game_state *state)
 
 struct game_ui {
     int flash_laserno;
-    int errors, newmove;
-    int cur_x, cur_y, cur_visible;
+    int errors;
+    bool newmove;
+    int cur_x, cur_y;
+    bool cur_visible;
     int flash_laser; /* 0 = never, 1 = always, 2 = if anim. */
 };
 
@@ -487,10 +492,10 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
     ui->flash_laserno = LASER_EMPTY;
     ui->errors = 0;
-    ui->newmove = FALSE;
+    ui->newmove = false;
 
     ui->cur_x = ui->cur_y = 1;
-    ui->cur_visible = 0;
+    ui->cur_visible = false;
 
     ui->flash_laser = 0;
 
@@ -526,7 +531,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      */
     if (newstate->justwrong && ui->newmove)
 	ui->errors++;
-    ui->newmove = FALSE;
+    ui->newmove = false;
 }
 
 #define OFFSET(gx,gy,o) do {                                    \
@@ -539,7 +544,7 @@ enum { LOOK_LEFT, LOOK_FORWARD, LOOK_RIGHT };
 
 /* Given a position and a direction, check whether we can see a ball in front
  * of us, or to our front-left or front-right. */
-static int isball(game_state *state, int gx, int gy, int direction, int lookwhere)
+static bool isball(game_state *state, int gx, int gy, int direction, int lookwhere)
 {
     debug(("isball, (%d, %d), dir %s, lookwhere %s\n", gx, gy, dirstrs[direction],
            lookwhere == LOOK_LEFT ? "LEFT" :
@@ -556,17 +561,18 @@ static int isball(game_state *state, int gx, int gy, int direction, int lookwher
 
     /* if we're off the grid (into the firing range) there's never a ball. */
     if (gx < 1 || gy < 1 || gx > state->w || gy > state->h)
-        return 0;
+        return false;
 
     if (GRID(state, gx,gy) & BALL_CORRECT)
-        return 1;
+        return true;
 
-    return 0;
+    return false;
 }
 
 static int fire_laser_internal(game_state *state, int x, int y, int direction)
 {
-    int unused, lno, tmp;
+    int unused, lno;
+    bool tmp;
 
     tmp = grid2range(state, x, y, &lno);
     assert(tmp);
@@ -629,7 +635,8 @@ static int fire_laser_internal(game_state *state, int x, int y, int direction)
 
 static int laser_exit(game_state *state, int entryno)
 {
-    int tmp, x, y, direction;
+    int x, y, direction;
+    bool tmp;
 
     tmp = range2grid(state, entryno, &x, &y, &direction);
     assert(tmp);
@@ -639,7 +646,8 @@ static int laser_exit(game_state *state, int entryno)
 
 static void fire_laser(game_state *state, int entryno)
 {
-    int tmp, exitno, x, y, direction;
+    int exitno, x, y, direction;
+    bool tmp;
 
     tmp = range2grid(state, entryno, &x, &y, &direction);
     assert(tmp);
@@ -664,10 +672,11 @@ static void fire_laser(game_state *state, int entryno)
  * have already guessed). This is required because any layout with >4 balls
  * might have multiple valid solutions. Returns non-zero for a 'correct'
  * (i.e. consistent) layout. */
-static int check_guesses(game_state *state, int cagey)
+static int check_guesses(game_state *state, bool cagey)
 {
     game_state *solution, *guesses;
     int i, x, y, n, unused, tmp;
+    bool tmpb;
     int ret = 0;
 
     if (cagey) {
@@ -720,7 +729,7 @@ static int check_guesses(game_state *state, int cagey)
 		    tmp = laser_exit(state, i);
 		    if (RANGECHECK(state, tmp))
 			state->exits[tmp] |= LASER_WRONG;
-		    state->justwrong = TRUE;
+		    state->justwrong = true;
 		    free_game(guesses);
 		    return 0;
 		}
@@ -756,7 +765,7 @@ static int check_guesses(game_state *state, int cagey)
 		    tmp = laser_exit(state, i);
 		    if (RANGECHECK(state, tmp))
 			state->exits[tmp] |= LASER_OMITTED;
-		    state->justwrong = TRUE;
+		    state->justwrong = true;
 		    free_game(guesses);
 		    return 0;
 		}
@@ -770,8 +779,8 @@ static int check_guesses(game_state *state, int cagey)
 
     /* clear out the lasers of solution */
     for (i = 0; i < solution->nlasers; i++) {
-        tmp = range2grid(solution, i, &x, &y, &unused);
-        assert(tmp);
+        tmpb = range2grid(solution, i, &x, &y, &unused);
+        assert(tmpb);
         GRID(solution, x, y) = 0;
         solution->exits[i] = LASER_EMPTY;
     }
@@ -801,8 +810,8 @@ static int check_guesses(game_state *state, int cagey)
     /* check each game_state's laser against the other; if any differ, return 0 */
     ret = 1;
     for (i = 0; i < solution->nlasers; i++) {
-        tmp = range2grid(solution, i, &x, &y, &unused);
-        assert(tmp);
+        tmpb = range2grid(solution, i, &x, &y, &unused);
+        assert(tmpb);
 
         if (solution->exits[i] != guesses->exits[i]) {
             /* If the original state didn't have this shot fired,
@@ -816,8 +825,8 @@ static int check_guesses(game_state *state, int cagey)
                 else {
                     /* add a new shot, incrementing state's laser count. */
                     int ex, ey, newno = state->laserno++;
-                    tmp = range2grid(state, state->exits[i], &ex, &ey, &unused);
-                    assert(tmp);
+                    tmpb = range2grid(state, state->exits[i], &ex, &ey, &unused);
+                    assert(tmpb);
                     GRID(state, x, y) = newno;
                     GRID(state, ex, ey) = newno;
                 }
@@ -859,7 +868,7 @@ done:
     }
     free_game(solution);
     free_game(guesses);
-    state->reveal = 1;
+    state->reveal = true;
     return ret;
 }
 
@@ -875,8 +884,8 @@ done:
 struct game_drawstate {
     int tilesize, crad, rrad, w, h; /* w and h to make macros work... */
     unsigned int *grid;          /* as the game_state grid */
-    int started, reveal;
-    int flash_laserno, isflash;
+    bool started, reveal, isflash;
+    int flash_laserno;
 };
 
 static char *interpret_move(const game_state *state, game_ui *ui,
@@ -891,7 +900,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (IS_CURSOR_MOVE(button)) {
         int cx = ui->cur_x, cy = ui->cur_y;
 
-        move_cursor(button, &cx, &cy, state->w+2, state->h+2, 0);
+        move_cursor(button, &cx, &cy, state->w+2, state->h+2, false);
         if ((cx == 0 && cy == 0 && !CAN_REVEAL(state)) ||
             (cx == 0 && cy == state->h+1) ||
             (cx == state->w+1 && cy == 0) ||
@@ -899,14 +908,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             return NULL; /* disallow moving cursor to corners. */
         ui->cur_x = cx;
         ui->cur_y = cy;
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
         return UI_UPDATE;
     }
 
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         gx = FROMDRAW(x);
         gy = FROMDRAW(y);
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         wouldflash = 1;
     } else if (button == LEFT_RELEASE) {
         ui->flash_laser = 0;
@@ -918,7 +927,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             ui->flash_laser = 0;
             wouldflash = 2;
         } else {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         /* Fix up 'button' for the below logic. */
@@ -976,7 +985,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
     case REVEAL:
         if (!CAN_REVEAL(state)) return nullret;
-        if (ui->cur_visible == 1) ui->cur_x = ui->cur_y = 1;
+        if (ui->cur_visible) ui->cur_x = ui->cur_y = 1;
         sprintf(buf, "R");
         break;
 
@@ -984,7 +993,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return nullret;
     }
     if (state->reveal) return nullret;
-    ui->newmove = TRUE;
+    ui->newmove = true;
     return dupstr(buf);
 }
 
@@ -995,14 +1004,14 @@ static game_state *execute_move(const game_state *from, const char *move)
 
     if (ret->justwrong) {
 	int i;
-	ret->justwrong = FALSE;
+	ret->justwrong = false;
 	for (i = 0; i < ret->nlasers; i++)
 	    if (ret->exits[i] != LASER_EMPTY)
 		ret->exits[i] &= ~(LASER_OMITTED | LASER_WRONG);
     }
 
     if (!strcmp(move, "S")) {
-        check_guesses(ret, FALSE);
+        check_guesses(ret, false);
         return ret;
     }
 
@@ -1036,7 +1045,7 @@ static game_state *execute_move(const game_state *from, const char *move)
         if (ret->nguesses < ret->minballs ||
             ret->nguesses > ret->maxballs)
             goto badmove;
-        check_guesses(ret, TRUE);
+        check_guesses(ret, true);
         break;
 
     case 'L':
@@ -1159,9 +1168,10 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->w = state->w; ds->h = state->h;
     ds->grid = snewn((state->w+2)*(state->h+2), unsigned int);
     memset(ds->grid, 0, (state->w+2)*(state->h+2)*sizeof(unsigned int));
-    ds->started = ds->reveal = 0;
+    ds->started = false;
+    ds->reveal = false;
     ds->flash_laserno = LASER_EMPTY;
-    ds->isflash = 0;
+    ds->isflash = false;
 
     return ds;
 }
@@ -1184,7 +1194,7 @@ static void draw_square_cursor(drawing *dr, game_drawstate *ds, int dx, int dy)
 
 static void draw_arena_tile(drawing *dr, const game_state *gs,
                             game_drawstate *ds, const game_ui *ui,
-                            int ax, int ay, int force, int isflash)
+                            int ax, int ay, bool force, bool isflash)
 {
     int gx = ax+1, gy = ay+1;
     int gs_tile = GRID(gs, gx, gy), ds_tile = GRID(ds, gx, gy);
@@ -1266,10 +1276,11 @@ static void draw_arena_tile(drawing *dr, const game_state *gs,
 
 static void draw_laser_tile(drawing *dr, const game_state *gs,
                             game_drawstate *ds, const game_ui *ui,
-                            int lno, int force)
+                            int lno, bool force)
 {
     int gx, gy, dx, dy, unused;
-    int wrong, omitted, reflect, hit, laserval, flash = 0, tmp;
+    int wrong, omitted, laserval;
+    bool tmp, reflect, hit, flash = false;
     unsigned int gs_tile, ds_tile, exitno;
 
     tmp = range2grid(gs, lno, &gx, &gy, &unused);
@@ -1293,7 +1304,7 @@ static void draw_laser_tile(drawing *dr, const game_state *gs,
         if (exitno == ds->flash_laserno)
             gs_tile |= LASER_FLASHED;
     }
-    if (gs_tile & LASER_FLASHED) flash = 1;
+    if (gs_tile & LASER_FLASHED) flash = true;
 
     gs_tile |= wrong | omitted;
 
@@ -1341,7 +1352,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int i, x, y, ts = TILE_SIZE, isflash = 0, force = 0;
+    int i, x, y, ts = TILE_SIZE;
+    bool isflash = false, force = false;
 
     if (flashtime > 0) {
         int frame = (int)(flashtime / FLASH_FRAME);
@@ -1374,11 +1386,11 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
         draw_update(dr, 0, 0,
                     TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3));
-        force = 1;
-        ds->started = 1;
+        force = true;
+        ds->started = true;
     }
 
-    if (isflash != ds->isflash) force = 1;
+    if (isflash != ds->isflash) force = true;
 
     /* draw the arena */
     for (x = 0; x < state->w; x++) {
@@ -1483,9 +1495,9 @@ static int game_status(const game_state *state)
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1508,15 +1520,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1533,9 +1545,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/bridges.c b/apps/plugins/puzzles/src/bridges.c
index 098fea2665..d12aa0bb6c 100644
--- a/apps/plugins/puzzles/src/bridges.c
+++ b/apps/plugins/puzzles/src/bridges.c
@@ -106,7 +106,8 @@ enum {
 struct game_params {
     int w, h, maxb;
     int islands, expansion;     /* %age of island squares, %age chance of expansion */
-    int allowloops, difficulty;
+    bool allowloops;
+    int difficulty;
 };
 
 /* general flags used by all structs */
@@ -155,7 +156,9 @@ struct island {
 };
 
 struct game_state {
-    int w, h, completed, solved, allowloops, maxb;
+    int w, h, maxb;
+    bool completed, solved;
+    bool allowloops;
     grid_type *grid;
     struct island *islands;
     int n_islands, n_islands_alloc;
@@ -180,7 +183,7 @@ struct game_state {
 
 #define GRIDCOUNT(s,x,y,f) ((GRID(s,x,y) & (f)) ? (INDEX(s,lines,x,y)) : 0)
 
-#define WITHIN2(x,min,max) (((x) < (min)) ? 0 : (((x) > (max)) ? 0 : 1))
+#define WITHIN2(x,min,max) ((x) >= (min) && (x) < (max))
 #define WITHIN(x,min,max) ((min) > (max) ? \
                            WITHIN2(x,max,min) : WITHIN2(x,min,max))
 
@@ -204,9 +207,9 @@ static void fixup_islands_for_realloc(game_state *state)
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -327,14 +330,14 @@ foundisland:
     }
 }
 
-static int island_hasbridge(struct island *is, int direction)
+static bool island_hasbridge(struct island *is, int direction)
 {
     int x = is->adj.points[direction].x;
     int y = is->adj.points[direction].y;
     grid_type gline = is->adj.points[direction].dx ? G_LINEH : G_LINEV;
 
-    if (GRID(is->state, x, y) & gline) return 1;
-    return 0;
+    if (GRID(is->state, x, y) & gline) return true;
+    return false;
 }
 
 static struct island *island_find_connection(struct island *is, int adjpt)
@@ -355,7 +358,7 @@ static struct island *island_find_connection(struct island *is, int adjpt)
 static struct island *island_add(game_state *state, int x, int y, int count)
 {
     struct island *is;
-    int realloced = 0;
+    bool realloced = false;
 
     assert(!(GRID(state,x,y) & G_ISLAND));
     GRID(state,x,y) |= G_ISLAND;
@@ -365,7 +368,7 @@ static struct island *island_add(game_state *state, int x, int y, int count)
         state->n_islands_alloc = state->n_islands * 2;
         state->islands =
             sresize(state->islands, state->n_islands_alloc, struct island);
-        realloced = 1;
+        realloced = true;
     }
     is = &state->islands[state->n_islands-1];
 
@@ -386,7 +389,7 @@ static struct island *island_add(game_state *state, int x, int y, int count)
 
 
 /* n = -1 means 'flip NOLINE flags [and set line to 0].' */
-static void island_join(struct island *i1, struct island *i2, int n, int is_max)
+static void island_join(struct island *i1, struct island *i2, int n, bool is_max)
 {
     game_state *state = i1->state;
     int s, e, x, y;
@@ -455,7 +458,7 @@ static int island_countbridges(struct island *is)
     return c;
 }
 
-static int island_adjspace(struct island *is, int marks, int missing,
+static int island_adjspace(struct island *is, bool marks, int missing,
                            int direction)
 {
     int x, y, poss, curr, dx;
@@ -481,7 +484,7 @@ static int island_adjspace(struct island *is, int marks, int missing,
 
 /* Counts the number of bridge spaces left around the island;
  * expects the possibles to be up-to-date. */
-static int island_countspaces(struct island *is, int marks)
+static int island_countspaces(struct island *is, bool marks)
 {
     int i, c = 0, missing;
 
@@ -494,6 +497,7 @@ static int island_countspaces(struct island *is, int marks)
     return c;
 }
 
+/* Returns a bridge count rather than a boolean */
 static int island_isadj(struct island *is, int direction)
 {
     int x, y;
@@ -565,7 +569,7 @@ static void island_togglemark(struct island *is)
     }
 }
 
-static int island_impossible(struct island *is, int strict)
+static bool island_impossible(struct island *is, bool strict)
 {
     int curr = island_countbridges(is), nspc = is->count - curr, nsurrspc;
     int i, poss;
@@ -573,13 +577,13 @@ static int island_impossible(struct island *is, int strict)
 
     if (nspc < 0) {
         debug(("island at (%d,%d) impossible because full.\n", is->x, is->y));
-        return 1;        /* too many bridges */
-    } else if ((curr + island_countspaces(is, 0)) < is->count) {
+        return true;        /* too many bridges */
+    } else if ((curr + island_countspaces(is, false)) < is->count) {
         debug(("island at (%d,%d) impossible because not enough spaces.\n", is->x, is->y));
-        return 1;        /* impossible to create enough bridges */
+        return true;        /* impossible to create enough bridges */
     } else if (strict && curr < is->count) {
         debug(("island at (%d,%d) impossible because locked.\n", is->x, is->y));
-        return 1;        /* not enough bridges and island is locked */
+        return true;        /* not enough bridges and island is locked */
     }
 
     /* Count spaces in surrounding islands. */
@@ -618,17 +622,17 @@ static int island_impossible(struct island *is, int strict)
     if (nsurrspc < nspc) {
         debug(("island at (%d,%d) impossible: surr. islands %d spc, need %d.\n",
                is->x, is->y, nsurrspc, nspc));
-        return 1;       /* not enough spaces around surrounding islands to fill this one. */
+        return true;       /* not enough spaces around surrounding islands to fill this one. */
     }
 
-    return 0;
+    return false;
 }
 
 /* --- Game parameter functions --- */
 
 #define DEFAULT_PRESET 0
 
-const struct game_params bridges_presets[] = {
+static const struct game_params bridges_presets[] = {
   { 7, 7, 2, 30, 10, 1, 0 },
   { 7, 7, 2, 30, 10, 1, 1 },
   { 7, 7, 2, 30, 10, 1, 2 },
@@ -648,13 +652,13 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(bridges_presets))
-        return FALSE;
+        return false;
 
     ret = default_params();
     *ret = bridges_presets[i];
@@ -665,7 +669,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
             ret->difficulty == 1 ? "medium" : "hard");
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -705,10 +709,10 @@ static void decode_params(game_params *params, char const *string)
         string++;
         EATNUM(params->maxb);
     }
-    params->allowloops = 1;
+    params->allowloops = true;
     if (*string == 'L') {
         string++;
-        params->allowloops = 0;
+        params->allowloops = false;
     }
     if (*string == 'd') {
         string++;
@@ -716,7 +720,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -795,7 +799,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->h < 3)
         return "Width and height must be at least 3";
@@ -922,14 +926,15 @@ static char *game_state_diff(const game_state *src, const game_state *dest)
 
 static void map_update_possibles(game_state *state)
 {
-    int x, y, s, e, bl, i, np, maxb, w = state->w, idx;
+    int x, y, s, e, i, np, maxb, w = state->w, idx;
+    bool bl;
     struct island *is_s = NULL, *is_f = NULL;
 
     /* Run down vertical stripes [un]setting possv... */
     for (x = 0; x < state->w; x++) {
         idx = x;
         s = e = -1;
-        bl = 0;
+        bl = false;
         maxb = state->params.maxb;     /* placate optimiser */
         /* Unset possible flags until we find an island. */
         for (y = 0; y < state->h; y++) {
@@ -955,12 +960,12 @@ static void map_update_possibles(game_state *state)
                     }
                 }
                 s = y+1;
-                bl = 0;
+                bl = false;
                 is_s = is_f;
                 maxb = is_s->count;
             } else {
                 e = y;
-                if (IDX(state,grid,idx) & (G_LINEH|G_NOLINEV)) bl = 1;
+                if (IDX(state,grid,idx) & (G_LINEH|G_NOLINEV)) bl = true;
             }
             idx += w;
         }
@@ -975,7 +980,7 @@ static void map_update_possibles(game_state *state)
     for (y = 0; y < state->h; y++) {
         idx = y*w;
         s = e = -1;
-        bl = 0;
+        bl = false;
         maxb = state->params.maxb;     /* placate optimiser */
         for (x = 0; x < state->w; x++) {
             is_s = IDX(state, gridi, idx);
@@ -1000,12 +1005,12 @@ static void map_update_possibles(game_state *state)
                     }
                 }
                 s = x+1;
-                bl = 0;
+                bl = false;
                 is_s = is_f;
                 maxb = is_s->count;
             } else {
                 e = x;
-                if (IDX(state,grid,idx) & (G_LINEV|G_NOLINEH)) bl = 1;
+                if (IDX(state,grid,idx) & (G_LINEV|G_NOLINEH)) bl = true;
             }
             idx += 1;
         }
@@ -1097,12 +1102,12 @@ static int bridges_neighbour(int vertex, void *vctx)
         return -1;
 }
 
-static int map_hasloops(game_state *state, int mark)
+static bool map_hasloops(game_state *state, bool mark)
 {
     int x, y;
     struct findloopstate *fls;
     struct bridges_neighbour_ctx ctx;
-    int ret;
+    bool ret;
 
     fls = findloop_new_state(state->w * state->h);
     ctx.state = state;
@@ -1172,11 +1177,12 @@ static void map_group(game_state *state)
     }
 }
 
-static int map_group_check(game_state *state, int canon, int warn,
-                           int *nislands_r)
+static bool map_group_check(game_state *state, int canon, bool warn,
+                            int *nislands_r)
 {
     int *dsf = state->solver->dsf, nislands = 0;
-    int x, y, i, allfull = 1;
+    int x, y, i;
+    bool allfull = true;
     struct island *is;
 
     for (i = 0; i < state->n_islands; i++) {
@@ -1186,7 +1192,7 @@ static int map_group_check(game_state *state, int canon, int warn,
         GRID(state, is->x, is->y) |= G_SWEEP;
         nislands++;
         if (island_countbridges(is) != is->count)
-            allfull = 0;
+            allfull = false;
     }
     if (warn && allfull && nislands != state->n_islands) {
         /* we're full and this island group isn't the whole set.
@@ -1204,10 +1210,11 @@ static int map_group_check(game_state *state, int canon, int warn,
     return allfull;
 }
 
-static int map_group_full(game_state *state, int *ngroups_r)
+static bool map_group_full(game_state *state, int *ngroups_r)
 {
     int *dsf = state->solver->dsf, ngroups = 0;
-    int i, anyfull = 0;
+    int i;
+    bool anyfull = false;
     struct island *is;
 
     /* NB this assumes map_group (or sth else) has cleared G_SWEEP. */
@@ -1218,31 +1225,31 @@ static int map_group_full(game_state *state, int *ngroups_r)
 
         ngroups++;
         if (map_group_check(state, dsf_canonify(dsf, DINDEX(is->x,is->y)),
-                            1, NULL))
-            anyfull = 1;
+                            true, NULL))
+            anyfull = true;
     }
 
     *ngroups_r = ngroups;
     return anyfull;
 }
 
-static int map_check(game_state *state)
+static bool map_check(game_state *state)
 {
     int ngroups;
 
     /* Check for loops, if necessary. */
     if (!state->allowloops) {
-        if (map_hasloops(state, 1))
-            return 0;
+        if (map_hasloops(state, true))
+            return false;
     }
 
     /* Place islands into island groups and check for early
      * satisfied-groups. */
     map_group(state); /* clears WARN and SWEEP */
     if (map_group_full(state, &ngroups)) {
-        if (ngroups == 1) return 1;
+        if (ngroups == 1) return true;
     }
-    return 0;
+    return false;
 }
 
 static void map_clear(game_state *state)
@@ -1257,7 +1264,7 @@ static void map_clear(game_state *state)
     }
 }
 
-static void solve_join(struct island *is, int direction, int n, int is_max)
+static void solve_join(struct island *is, int direction, int n, bool is_max)
 {
     struct island *is_orth;
     int d1, d2, *dsf = is->state->solver->dsf;
@@ -1290,7 +1297,7 @@ static int solve_fillone(struct island *is)
             if (island_hasbridge(is, i)) {
                 /* already attached; do nothing. */;
             } else {
-                solve_join(is, i, 1, 0);
+                solve_join(is, i, 1, false);
                 nadded++;
             }
         }
@@ -1311,25 +1318,25 @@ static int solve_fill(struct island *is)
 
     /* very like island_countspaces. */
     for (i = 0; i < is->adj.npoints; i++) {
-        nnew = island_adjspace(is, 1, missing, i);
+        nnew = island_adjspace(is, true, missing, i);
         if (nnew) {
             ncurr = GRIDCOUNT(is->state,
                               is->adj.points[i].x, is->adj.points[i].y,
                               is->adj.points[i].dx ? G_LINEH : G_LINEV);
 
-            solve_join(is, i, nnew + ncurr, 0);
+            solve_join(is, i, nnew + ncurr, false);
             nadded += nnew;
         }
     }
     return nadded;
 }
 
-static int solve_island_stage1(struct island *is, int *didsth_r)
+static bool solve_island_stage1(struct island *is, bool *didsth_r)
 {
     int bridges = island_countbridges(is);
-    int nspaces = island_countspaces(is, 1);
+    int nspaces = island_countspaces(is, true);
     int nadj = island_countadj(is);
-    int didsth = 0;
+    bool didsth = false;
 
     assert(didsth_r);
 
@@ -1341,64 +1348,68 @@ static int solve_island_stage1(struct island *is, int *didsth_r)
          * another island has become wrong, the puzzle must not have had
          * a solution. */
         debug(("...island at (%d,%d) is overpopulated!\n", is->x, is->y));
-        return 0;
+        return false;
     } else if (bridges == is->count) {
         /* This island is full. Make sure it's marked (and update
          * possibles if we did). */
         if (!(GRID(is->state, is->x, is->y) & G_MARK)) {
             debug(("...marking island (%d,%d) as full.\n", is->x, is->y));
             island_togglemark(is);
-            didsth = 1;
+            didsth = true;
         }
     } else if (GRID(is->state, is->x, is->y) & G_MARK) {
         debug(("...island (%d,%d) is marked but unfinished!\n",
                is->x, is->y));
-        return 0; /* island has been marked unfinished; no solution from here. */
+        return false; /* island has been marked unfinished; no solution from here. */
     } else {
         /* This is the interesting bit; we try and fill in more information
          * about this island. */
         if (is->count == bridges + nspaces) {
-            if (solve_fill(is) > 0) didsth = 1;
+            if (solve_fill(is) > 0) didsth = true;
         } else if (is->count > ((nadj-1) * is->state->maxb)) {
             /* must have at least one bridge in each possible direction. */
-            if (solve_fillone(is) > 0) didsth = 1;
+            if (solve_fillone(is) > 0) didsth = true;
         }
     }
     if (didsth) {
         map_update_possibles(is->state);
-        *didsth_r = 1;
+        *didsth_r = true;
     }
-    return 1;
+    return true;
 }
 
-/* returns non-zero if a new line here would cause a loop. */
-static int solve_island_checkloop(struct island *is, int direction)
+/* returns true if a new line here would cause a loop. */
+static bool solve_island_checkloop(struct island *is, int direction)
 {
     struct island *is_orth;
     int *dsf = is->state->solver->dsf, d1, d2;
     game_state *state = is->state;
 
-    if (is->state->allowloops) return 0; /* don't care anyway */
-    if (island_hasbridge(is, direction)) return 0; /* already has a bridge */
-    if (island_isadj(is, direction) == 0) return 0; /* no adj island */
+    if (is->state->allowloops)
+        return false; /* don't care anyway */
+    if (island_hasbridge(is, direction))
+        return false; /* already has a bridge */
+    if (island_isadj(is, direction) == 0)
+        return false; /* no adj island */
 
     is_orth = INDEX(is->state, gridi,
                     ISLAND_ORTHX(is,direction),
                     ISLAND_ORTHY(is,direction));
-    if (!is_orth) return 0;
+    if (!is_orth) return false;
 
     d1 = DINDEX(is->x, is->y);
     d2 = DINDEX(is_orth->x, is_orth->y);
     if (dsf_canonify(dsf, d1) == dsf_canonify(dsf, d2)) {
         /* two islands are connected already; don't join them. */
-        return 1;
+        return true;
     }
-    return 0;
+    return false;
 }
 
-static int solve_island_stage2(struct island *is, int *didsth_r)
+static bool solve_island_stage2(struct island *is, bool *didsth_r)
 {
-    int added = 0, removed = 0, navail = 0, nadj, i;
+    int navail = 0, nadj, i;
+    bool added = false, removed = false;
 
     assert(didsth_r);
 
@@ -1406,9 +1417,9 @@ static int solve_island_stage2(struct island *is, int *didsth_r)
         if (solve_island_checkloop(is, i)) {
             debug(("removing possible loop at (%d,%d) direction %d.\n",
                    is->x, is->y, i));
-            solve_join(is, i, -1, 0);
+            solve_join(is, i, -1, false);
             map_update_possibles(is->state);
-            removed = 1;
+            removed = true;
         } else {
             navail += island_isadj(is, i);
             /*debug(("stage2: navail for (%d,%d) direction (%d,%d) is %d.\n",
@@ -1431,19 +1442,19 @@ static int solve_island_stage2(struct island *is, int *didsth_r)
                 debug(("island at (%d,%d) direction (%d,%d) must have 1 bridge\n",
                        is->x, is->y,
                        is->adj.points[i].dx, is->adj.points[i].dy));
-                solve_join(is, i, 1, 0);
-                added = 1;
+                solve_join(is, i, 1, false);
+                added = true;
                 /*debug_state(is->state);
                 debug_possibles(is->state);*/
             }
         }
     }
     if (added) map_update_possibles(is->state);
-    if (added || removed) *didsth_r = 1;
-    return 1;
+    if (added || removed) *didsth_r = true;
+    return true;
 }
 
-static int solve_island_subgroup(struct island *is, int direction)
+static bool solve_island_subgroup(struct island *is, int direction)
 {
     struct island *is_join;
     int nislands, *dsf = is->state->solver->dsf;
@@ -1454,7 +1465,7 @@ static int solve_island_subgroup(struct island *is, int direction)
     /* if is isn't full, return 0. */
     if (island_countbridges(is) < is->count) {
         debug(("...orig island (%d,%d) not full.\n", is->x, is->y));
-        return 0;
+        return false;
     }
 
     if (direction >= 0) {
@@ -1467,27 +1478,27 @@ static int solve_island_subgroup(struct island *is, int direction)
         if (island_countbridges(is_join) < is_join->count) {
             debug(("...dest island (%d,%d) not full.\n",
                    is_join->x, is_join->y));
-            return 0;
+            return false;
         }
     }
 
     /* Check group membership for is->dsf; if it's full return 1. */
     if (map_group_check(state, dsf_canonify(dsf, DINDEX(is->x,is->y)),
-                        0, &nislands)) {
+                        false, &nislands)) {
         if (nislands < state->n_islands) {
             /* we have a full subgroup that isn't the whole set.
              * This isn't allowed. */
             debug(("island at (%d,%d) makes full subgroup, disallowing.\n",
                    is->x, is->y));
-            return 1;
+            return true;
         } else {
             debug(("...has finished puzzle.\n"));
         }
     }
-    return 0;
+    return false;
 }
 
-static int solve_island_impossible(game_state *state)
+static bool solve_island_impossible(game_state *state)
 {
     struct island *is;
     int i;
@@ -1495,31 +1506,32 @@ static int solve_island_impossible(game_state *state)
     /* If any islands are impossible, return 1. */
     for (i = 0; i < state->n_islands; i++) {
         is = &state->islands[i];
-        if (island_impossible(is, 0)) {
+        if (island_impossible(is, false)) {
             debug(("island at (%d,%d) has become impossible, disallowing.\n",
                    is->x, is->y));
-            return 1;
+            return true;
         }
     }
-    return 0;
+    return false;
 }
 
 /* Bear in mind that this function is really rather inefficient. */
-static int solve_island_stage3(struct island *is, int *didsth_r)
+static bool solve_island_stage3(struct island *is, bool *didsth_r)
 {
-    int i, n, x, y, missing, spc, curr, maxb, didsth = 0;
+    int i, n, x, y, missing, spc, curr, maxb;
+    bool didsth = false;
     int wh = is->state->w * is->state->h;
     struct solver_state *ss = is->state->solver;
 
     assert(didsth_r);
 
     missing = is->count - island_countbridges(is);
-    if (missing <= 0) return 1;
+    if (missing <= 0) return true;
 
     for (i = 0; i < is->adj.npoints; i++) {
         x = is->adj.points[i].x;
         y = is->adj.points[i].y;
-        spc = island_adjspace(is, 1, missing, i);
+        spc = island_adjspace(is, true, missing, i);
         if (spc == 0) continue;
 
         curr = GRIDCOUNT(is->state, x, y,
@@ -1534,7 +1546,7 @@ static int solve_island_stage3(struct island *is, int *didsth_r)
          * it is additive only, and can't be removed from. */
         memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));
         for (n = curr+1; n <= curr+spc; n++) {
-            solve_join(is, i, n, 0);
+            solve_join(is, i, n, false);
             map_update_possibles(is->state);
 
             if (solve_island_subgroup(is, i) ||
@@ -1547,19 +1559,19 @@ static int solve_island_stage3(struct island *is, int *didsth_r)
                 break;
             }
         }
-        solve_join(is, i, curr, 0); /* put back to before. */
+        solve_join(is, i, curr, false); /* put back to before. */
         memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));
 
         if (maxb != -1) {
             /*debug_state(is->state);*/
             if (maxb == 0) {
                 debug(("...adding NOLINE.\n"));
-                solve_join(is, i, -1, 0); /* we can't have any bridges here. */
+                solve_join(is, i, -1, false); /* we can't have any bridges here. */
             } else {
                 debug(("...setting maximum\n"));
-                solve_join(is, i, maxb, 1);
+                solve_join(is, i, maxb, true);
             }
-            didsth = 1;
+            didsth = true;
         }
         map_update_possibles(is->state);
     }
@@ -1603,11 +1615,11 @@ static int solve_island_stage3(struct island *is, int *didsth_r)
          * recording the idea that at least one of two edges must have
          * a bridge.
          */
-        int got = 0;
+        bool got = false;
         int before[4];
         int j;
 
-        spc = island_adjspace(is, 1, missing, i);
+        spc = island_adjspace(is, true, missing, i);
         if (spc == 0) continue;
 
         for (j = 0; j < is->adj.npoints; j++)
@@ -1620,33 +1632,33 @@ static int solve_island_stage3(struct island *is, int *didsth_r)
         memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));
 
         for (j = 0; j < is->adj.npoints; j++) {
-            spc = island_adjspace(is, 1, missing, j);
+            spc = island_adjspace(is, true, missing, j);
             if (spc == 0) continue;
             if (j == i) continue;
-            solve_join(is, j, before[j] + spc, 0);
+            solve_join(is, j, before[j] + spc, false);
         }
         map_update_possibles(is->state);
 
         if (solve_island_subgroup(is, -1))
-            got = 1;
+            got = true;
 
         for (j = 0; j < is->adj.npoints; j++)
-            solve_join(is, j, before[j], 0);
+            solve_join(is, j, before[j], false);
         memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));
 
         if (got) {
             debug(("island at (%d,%d) must connect in direction (%d,%d) to"
                    " avoid full subgroup.\n",
                    is->x, is->y, is->adj.points[i].dx, is->adj.points[i].dy));
-            solve_join(is, i, 1, 0);
-            didsth = 1;
+            solve_join(is, i, 1, false);
+            didsth = true;
         }
 
         map_update_possibles(is->state);
     }
 
     if (didsth) *didsth_r = didsth;
-    return 1;
+    return true;
 }
 
 #define CONTINUE_IF_FULL do {                           \
@@ -1658,10 +1670,10 @@ if (GRID(state, is->x, is->y) & G_MARK) {            \
 static int solve_sub(game_state *state, int difficulty, int depth)
 {
     struct island *is;
-    int i, didsth;
+    int i;
 
     while (1) {
-        didsth = 0;
+        bool didsth = false;
 
         /* First island iteration: things we can work out by looking at
          * properties of the island as a whole. */
@@ -1747,7 +1759,8 @@ static game_state *new_state(const game_params *params)
     ret->gridi = snewn(wh, struct island *);
     for (i = 0; i < wh; i++) ret->gridi[i] = NULL;
 
-    ret->solved = ret->completed = 0;
+    ret->solved = false;
+    ret->completed = false;
 
     ret->solver = snew(struct solver_state);
     ret->solver->dsf = snew_dsf(wh);
@@ -1820,7 +1833,7 @@ static void free_game(game_state *state)
 #define ORDER(a,b) do { if (a < b) { int tmp=a; int a=b; int b=tmp; } } while(0)
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *tobuild  = NULL;
     int i, j, wh = params->w * params->h, x, y, dx, dy;
@@ -1920,7 +1933,7 @@ foundmax:
 
         ni_curr++; ni_bad = 0;
 join:
-        island_join(is, is2, random_upto(rs, tobuild->maxb)+1, 0);
+        island_join(is, is2, random_upto(rs, tobuild->maxb)+1, false);
         debug_state(tobuild);
         continue;
 
@@ -2079,17 +2092,19 @@ struct game_ui {
     int dragx_src, dragy_src;   /* source; -1 means no drag */
     int dragx_dst, dragy_dst;   /* src's closest orth island. */
     grid_type todraw;
-    int dragging, drag_is_noline, nlines;
+    bool dragging, drag_is_noline;
+    int nlines;
 
-    int cur_x, cur_y, cur_visible;      /* cursor position */
-    int show_hints;
+    int cur_x, cur_y;           /* cursor position */
+    bool cur_visible;
+    bool show_hints;
 };
 
 static char *ui_cancel_drag(game_ui *ui)
 {
     ui->dragx_src = ui->dragy_src = -1;
     ui->dragx_dst = ui->dragy_dst = -1;
-    ui->dragging = 0;
+    ui->dragging = false;
     return UI_UPDATE;
 }
 
@@ -2099,8 +2114,8 @@ static game_ui *new_ui(const game_state *state)
     ui_cancel_drag(ui);
     ui->cur_x = state->islands[0].x;
     ui->cur_y = state->islands[0].y;
-    ui->cur_visible = 0;
-    ui->show_hints = 0;
+    ui->cur_visible = false;
+    ui->show_hints = false;
     return ui;
 }
 
@@ -2128,7 +2143,7 @@ struct game_drawstate {
     int w, h;
     unsigned long *grid, *newgrid;
     int *lv, *lh;
-    int started, dragging;
+    bool started, dragging;
 };
 
 /*
@@ -2312,12 +2327,12 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     int gx = FROMCOORD(x), gy = FROMCOORD(y);
     char buf[80], *ret;
     grid_type ggrid = INGRID(state,gx,gy) ? GRID(state,gx,gy) : 0;
-    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    bool shift = button & MOD_SHFT, control = button & MOD_CTRL;
     button &= ~MOD_MASK;
 
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         if (!INGRID(state, gx, gy)) return NULL;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         if (ggrid & G_ISLAND) {
             ui->dragx_src = gx;
             ui->dragy_src = gy;
@@ -2328,8 +2343,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         if (INGRID(state, ui->dragx_src, ui->dragy_src)
                 && (gx != ui->dragx_src || gy != ui->dragy_src)
                 && !(GRID(state,ui->dragx_src,ui->dragy_src) & G_MARK)) {
-            ui->dragging = 1;
-            ui->drag_is_noline = (button == RIGHT_DRAG) ? 1 : 0;
+            ui->dragging = true;
+            ui->drag_is_noline = (button == RIGHT_DRAG);
             return update_drag_dst(state, ui, ds, x, y);
         } else {
             /* cancel a drag when we go back to the starting point */
@@ -2358,17 +2373,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         free_game(solved);
         return ret;
     } else if (IS_CURSOR_MOVE(button)) {
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
         if (control || shift) {
             ui->dragx_src = ui->cur_x;
             ui->dragy_src = ui->cur_y;
-            ui->dragging = TRUE;
+            ui->dragging = true;
             ui->drag_is_noline = !control;
         }
         if (ui->dragging) {
             int nx = ui->cur_x, ny = ui->cur_y;
 
-            move_cursor(button, &nx, &ny, state->w, state->h, 0);
+            move_cursor(button, &nx, &ny, state->w, state->h, false);
             if (nx == ui->cur_x && ny == ui->cur_y)
                 return NULL;
             update_drag_dst(state, ui, ds,
@@ -2398,23 +2413,25 @@ static char *interpret_move(const game_state *state, game_ui *ui,
              * before closer islands slightly offset). Swap the order of
              * these two loops to change to breadth-first search. */
             for (orth = 0; ; orth++) {
-                int oingrid = 0;
+                bool oingrid = false;
                 for (dir = 1; ; dir++) {
-                    int dingrid = 0;
+                    bool dingrid = false;
 
                     if (orth > dir) continue; /* only search in cone outwards. */
 
                     nx = ui->cur_x + dir*dx + orth*dorthx*orthorder;
                     ny = ui->cur_y + dir*dy + orth*dorthy*orthorder;
                     if (INGRID(state, nx, ny)) {
-                        dingrid = oingrid = 1;
+                        dingrid = true;
+                        oingrid = true;
                         if (GRID(state, nx, ny) & G_ISLAND) goto found;
                     }
 
                     nx = ui->cur_x + dir*dx - orth*dorthx*orthorder;
                     ny = ui->cur_y + dir*dy - orth*dorthy*orthorder;
                     if (INGRID(state, nx, ny)) {
-                        dingrid = oingrid = 1;
+                        dingrid = true;
+                        oingrid = true;
                         if (GRID(state, nx, ny) & G_ISLAND) goto found;
                     }
 
@@ -2431,7 +2448,7 @@ found:
         }
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         if (ui->dragging || button == CURSOR_SELECT2) {
@@ -2444,11 +2461,11 @@ found:
         } else {
             grid_type v = GRID(state, ui->cur_x, ui->cur_y);
             if (v & G_ISLAND) {
-                ui->dragging = 1;
+                ui->dragging = true;
                 ui->dragx_src = ui->cur_x;
                 ui->dragy_src = ui->cur_y;
                 ui->dragx_dst = ui->dragy_dst = -1;
-                ui->drag_is_noline = (button == CURSOR_SELECT2) ? 1 : 0;
+                ui->drag_is_noline = (button == CURSOR_SELECT2);
                 return UI_UPDATE;
             }
         }
@@ -2466,7 +2483,7 @@ found:
             number = 10 + button - 'A';
 
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
 
@@ -2498,7 +2515,7 @@ found:
         } else
             return NULL;
     } else if (button == 'g' || button == 'G') {
-        ui->show_hints = 1 - ui->show_hints;
+        ui->show_hints = !ui->show_hints;
         return UI_UPDATE;
     }
 
@@ -2518,7 +2535,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move++;
         if (c == 'S') {
-            ret->solved = TRUE;
+            ret->solved = true;
             n = 0;
         } else if (c == 'L') {
             if (sscanf(move, "%d,%d,%d,%d,%d%n",
@@ -2530,7 +2547,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             is2 = INDEX(ret, gridi, x2, y2);
             if (!is1 || !is2) goto badmove;
             if (nl < 0 || nl > state->maxb) goto badmove;
-            island_join(is1, is2, nl, 0);
+            island_join(is1, is2, nl, false);
         } else if (c == 'N') {
             if (sscanf(move, "%d,%d,%d,%d%n",
                        &x1, &y1, &x2, &y2, &n) != 4)
@@ -2540,7 +2557,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             is1 = INDEX(ret, gridi, x1, y1);
             is2 = INDEX(ret, gridi, x2, y2);
             if (!is1 || !is2) goto badmove;
-            island_join(is1, is2, -1, 0);
+            island_join(is1, is2, -1, false);
         } else if (c == 'M') {
             if (sscanf(move, "%d,%d%n",
                        &x1, &y1, &n) != 2)
@@ -2562,7 +2579,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     map_update_possibles(ret);
     if (map_check(ret)) {
         debug(("Game completed.\n"));
-        ret->completed = 1;
+        ret->completed = true;
     }
     return ret;
 
@@ -2660,8 +2677,8 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->tilesize = 0;
     ds->w = state->w;
     ds->h = state->h;
-    ds->started = 0;
-    ds->dragging = 0;
+    ds->started = false;
+    ds->dragging = false;
     ds->grid = snewn(wh, unsigned long);
     for (i = 0; i < wh; i++)
         ds->grid[i] = ~0UL;
@@ -2688,8 +2705,8 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 
 #define OFFSET(thing) ((TILE_SIZE/2) - ((thing)/2))
 
-static int between_island(const game_state *state, int sx, int sy,
-                          int dx, int dy)
+static bool between_island(const game_state *state, int sx, int sy,
+                           int dx, int dy)
 {
     int x = sx - dx, y = sy - dy;
 
@@ -2697,14 +2714,14 @@ static int between_island(const game_state *state, int sx, int sy,
         if (GRID(state, x, y) & G_ISLAND) goto found;
         x -= dx; y -= dy;
     }
-    return 0;
+    return false;
 found:
     x = sx + dx, y = sy + dy;
     while (INGRID(state, x, y)) {
-        if (GRID(state, x, y) & G_ISLAND) return 1;
+        if (GRID(state, x, y) & G_ISLAND) return true;
         x += dx; y += dy;
     }
-    return 0;
+    return false;
 }
 
 static void lines_lvlh(const game_state *state, const game_ui *ui,
@@ -2945,12 +2962,13 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         float animtime, float flashtime)
 {
     int x, y, lv, lh;
-    grid_type v, flash = 0;
+    grid_type v;
+    bool flash = false;
     struct island *is, *is_drag_src = NULL, *is_drag_dst = NULL;
 
     if (flashtime) {
         int f = (int)(flashtime * 5 / FLASH_TIME);
-        if (f == 1 || f == 3) flash = TRUE;
+        if (f == 1 || f == 3) flash = true;
     }
 
     /* Clear screen, if required. */
@@ -2967,11 +2985,11 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         draw_update(dr, 0, 0,
                     TILE_SIZE * ds->w + 2 * BORDER,
                     TILE_SIZE * ds->h + 2 * BORDER);
-        ds->started = 1;
+        ds->started = true;
     }
 
     if (ui->dragx_src != -1 && ui->dragy_src != -1) {
-        ds->dragging = 1;
+        ds->dragging = true;
         is_drag_src = INDEX(state, gridi, ui->dragx_src, ui->dragy_src);
         assert(is_drag_src);
         if (ui->dragx_dst != -1 && ui->dragy_dst != -1) {
@@ -2979,7 +2997,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             assert(is_drag_dst);
         }
     } else
-        ds->dragging = 0;
+        ds->dragging = false;
 
     /*
      * Set up ds->newgrid with the current grid contents.
@@ -3031,7 +3049,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                     INDEX(ds,newgrid,x,y+1) |= idata << D_L_ISLAND_SHIFT_U;
             } else {
                 unsigned long hdata, vdata;
-                int selh = FALSE, selv = FALSE;
+                bool selh = false, selv = false;
 
                 /*
                  * A line (non-island) square. Compute the drawing
@@ -3044,9 +3062,9 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                     WITHIN(x,is_drag_src->x, is_drag_dst->x) &&
                     WITHIN(y,is_drag_src->y, is_drag_dst->y)) {
                     if (is_drag_src->x != is_drag_dst->x)
-                        selh = TRUE;
+                        selh = true;
                     else
-                        selv = TRUE;
+                        selv = true;
                 }
                 lines_lvlh(state, ui, x, y, v, &lv, &lh);
 
@@ -3145,9 +3163,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -3225,15 +3243,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3250,9 +3268,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/cube.c b/apps/plugins/puzzles/src/cube.c
index 749156564d..bda7623f97 100644
--- a/apps/plugins/puzzles/src/cube.c
+++ b/apps/plugins/puzzles/src/cube.c
@@ -178,7 +178,7 @@ struct grid_square {
     int npoints;
     float points[8];                   /* maximum */
     int directions[8];                 /* bit masks showing point pairs */
-    int flip;
+    bool flip;
     int tetra_class;
 };
 
@@ -220,7 +220,7 @@ struct game_state {
     int dpkey[2];                      /* key-point indices into polyhedron */
     int previous;
     float angle;
-    int completed;
+    int completed;                     /* stores move count at completion */
     int movecount;
 };
 
@@ -235,7 +235,7 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret = snew(game_params);
     const char *str;
@@ -267,12 +267,12 @@ static int game_fetch_preset(int i, char **name, game_params **params)
         break;
       default:
         sfree(ret);
-        return FALSE;
+        return false;
     }
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -304,7 +304,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -348,7 +348,7 @@ static void enum_grid_squares(const game_params *params, egc_callback callback,
                 sq.directions[DOWN_LEFT] = 0;   /* no diagonals in a square */
                 sq.directions[DOWN_RIGHT] = 0;   /* no diagonals in a square */
 
-                sq.flip = FALSE;
+                sq.flip = false;
 
                 /*
                  * This is supremely irrelevant, but just to avoid
@@ -406,7 +406,7 @@ static void enum_grid_squares(const game_params *params, egc_callback callback,
                 sq.directions[DOWN_LEFT] = sq.directions[LEFT];
                 sq.directions[DOWN_RIGHT] = sq.directions[RIGHT];
 
-                sq.flip = TRUE;
+                sq.flip = true;
 
                 if (firstix < 0)
                     firstix = ix & 3;
@@ -451,7 +451,7 @@ static void enum_grid_squares(const game_params *params, egc_callback callback,
                 sq.directions[UP_LEFT] = sq.directions[LEFT];
                 sq.directions[UP_RIGHT] = sq.directions[RIGHT];
 
-                sq.flip = FALSE;
+                sq.flip = false;
 
                 if (firstix < 0)
                     firstix = (ix - 1) & 3;
@@ -534,7 +534,7 @@ static void count_grid_square_callback(void *ctx, struct grid_square *sq)
     classes[thisclass]++;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int classes[5];
     int i;
@@ -543,8 +543,8 @@ static const char *validate_params(const game_params *params, int full)
 	return "Unrecognised solid type";
 
     if (solids[params->solid]->order == 4) {
-	if (params->d1 <= 0 || params->d2 <= 0)
-	    return "Both grid dimensions must be greater than zero";
+	if (params->d1 <= 1 || params->d2 <= 1)
+	    return "Both grid dimensions must be greater than one";
     } else {
 	if (params->d1 <= 0 && params->d2 <= 0)
 	    return "At least one grid dimension must be greater than zero";
@@ -595,11 +595,11 @@ static void classify_grid_square_callback(void *ctx, struct grid_square *sq)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     struct grid_data data;
     int i, j, k, m, area, facesperclass;
-    int *flags;
+    bool *flags;
     char *desc, *p;
 
     /*
@@ -634,16 +634,16 @@ static char *new_game_desc(const game_params *params, random_state *rs,
      * So now we know how many faces to allocate in each class. Get
      * on with it.
      */
-    flags = snewn(area, int);
+    flags = snewn(area, bool);
     for (i = 0; i < area; i++)
-	flags[i] = FALSE;
+	flags[i] = false;
 
     for (i = 0; i < data.nclasses; i++) {
 	for (j = 0; j < facesperclass; j++) {
             int n = random_upto(rs, data.nsquares[i]);
 
 	    assert(!flags[data.gridptrs[i][n]]);
-	    flags[data.gridptrs[i][n]] = TRUE;
+	    flags[data.gridptrs[i][n]] = true;
 
 	    /*
 	     * Move everything else up the array. I ought to use a
@@ -727,8 +727,8 @@ static int lowest_face(const struct solid *solid)
     return best;
 }
 
-static int align_poly(const struct solid *solid, struct grid_square *sq,
-                      int *pkey)
+static bool align_poly(const struct solid *solid, struct grid_square *sq,
+                       int *pkey)
 {
     float zmin;
     int i, j;
@@ -768,14 +768,14 @@ static int align_poly(const struct solid *solid, struct grid_square *sq,
         }
 
         if (matches != 1 || index < 0)
-            return FALSE;
+            return false;
         pkey[j] = index;
     }
 
-    return TRUE;
+    return true;
 }
 
-static void flip_poly(struct solid *solid, int flip)
+static void flip_poly(struct solid *solid, bool flip)
 {
     int i;
 
@@ -791,7 +791,7 @@ static void flip_poly(struct solid *solid, int flip)
     }
 }
 
-static struct solid *transform_poly(const struct solid *solid, int flip,
+static struct solid *transform_poly(const struct solid *solid, bool flip,
                                     int key0, int key1, float angle)
 {
     struct solid *ret = snew(struct solid);
@@ -918,7 +918,7 @@ static game_state *new_game(midend *me, const game_params *params,
 		    break;
 	    }
 	    if (v & j)
-		SET_SQUARE(state, i, TRUE);
+		SET_SQUARE(state, i, true);
 	    j >>= 1;
 	    if (j == 0)
 		j = 8;
@@ -938,7 +938,7 @@ static game_state *new_game(midend *me, const game_params *params,
      */
     {
         int pkey[4];
-        int ret;
+        bool ret;
 
         ret = align_poly(state->solid, &state->grid->squares[state->current], pkey);
         assert(ret);
@@ -1005,9 +1005,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1312,7 +1312,7 @@ static game_state *execute_move(const game_state *from, const char *move)
      */
     {
         int all_pkey[4];
-        int success;
+        bool success;
 
         if (from->solid->order == 4 && direction == UP)
             angle = -angle;            /* HACK */
@@ -1418,7 +1418,7 @@ static game_state *execute_move(const game_state *from, const char *move)
      */
     {
         int pkey[4];
-        int success;
+        bool success;
 
         success = align_poly(ret->solid, &ret->grid->squares[ret->current], pkey);
         assert(success);
@@ -1713,9 +1713,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1738,15 +1738,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    false, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1763,8 +1763,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/devel.but b/apps/plugins/puzzles/src/devel.but
index f30e8eecda..9f95ad7dd4 100644
--- a/apps/plugins/puzzles/src/devel.but
+++ b/apps/plugins/puzzles/src/devel.but
@@ -389,23 +389,23 @@ with the default values, and returns a pointer to it.
 
 \S{backend-fetch-preset} \cw{fetch_preset()}
 
-\c int (*fetch_preset)(int i, char **name, game_params **params);
+\c bool (*fetch_preset)(int i, char **name, game_params **params);
 
 This function is one of the two APIs a back end can provide to
 populate the \q{Type} menu, which provides a list of conveniently
 accessible preset parameters for most games.
 
 The function is called with \c{i} equal to the index of the preset
-required (numbering from zero). It returns \cw{FALSE} if that preset
+required (numbering from zero). It returns \cw{false} if that preset
 does not exist (if \c{i} is less than zero or greater than the
 largest preset index). Otherwise, it sets \c{*params} to point at a
 newly allocated \c{game_params} structure containing the preset
 information, sets \c{*name} to point at a newly allocated C string
 containing the preset title (to go on the \q{Type} menu), and
-returns \cw{TRUE}.
+returns \cw{true}.
 
 If the game does not wish to support any presets at all, this
-function is permitted to return \cw{FALSE} always.
+function is permitted to return \cw{false} always.
 
 If the game wants to return presets in the form of a hierarchical menu
 instead of a flat list (and, indeed, even if it doesn't), then it may
@@ -436,7 +436,7 @@ from the game, and before passing it on to the front end.
 
 \S{backend-encode-params} \cw{encode_params()}
 
-\c char *(*encode_params)(const game_params *params, int full);
+\c char *(*encode_params)(const game_params *params, bool full);
 
 The job of this function is to take a \c{game_params}, and encode it
 in a string form for use in game IDs. The return value must be a
@@ -460,10 +460,10 @@ letter denoting a parameter, followed optionally by a number giving
 the value of that parameter, with a few mandatory parts at the
 beginning such as numeric width and height separated by \cq{x}.)
 
-If the \c{full} parameter is \cw{TRUE}, this function should encode
+If the \c{full} parameter is \cw{true}, this function should encode
 absolutely everything in the \c{game_params}, such that a subsequent
 call to \cw{decode_params()} (\k{backend-decode-params}) will yield
-an identical structure. If \c{full} is \cw{FALSE}, however, you
+an identical structure. If \c{full} is \cw{false}, however, you
 should leave out anything which is not necessary to describe a
 \e{specific puzzle instance}, i.e. anything which only takes effect
 when a new puzzle is \e{generated}. For example, the Solo
@@ -529,13 +529,13 @@ provided as input. It returns a pointer to the new duplicate.
 
 \S{backend-can-configure} \c{can_configure}
 
-\c int can_configure;
+\c bool can_configure;
 
-This boolean data element is set to \cw{TRUE} if the back end
-supports custom parameter configuration via a dialog box. If it is
-\cw{TRUE}, then the functions \cw{configure()} and
-\cw{custom_params()} are expected to work. See \k{backend-configure}
-and \k{backend-custom-params} for more details.
+This data element is set to \cw{true} if the back end supports custom
+parameter configuration via a dialog box. If it is \cw{true}, then the
+functions \cw{configure()} and \cw{custom_params()} are expected to
+work. See \k{backend-configure} and \k{backend-custom-params} for more
+details.
 
 \S{backend-configure} \cw{configure()}
 
@@ -665,7 +665,7 @@ function is never called and need not do anything at all.
 \S{backend-validate-params} \cw{validate_params()}
 
 \c const char *(*validate_params)(const game_params *params,
-\c                                int full);
+\c                                bool full);
 
 This function takes a \c{game_params} structure as input, and checks
 that the parameters described in it fall within sensible limits. (At
@@ -710,7 +710,7 @@ a descriptive-format game ID.
 \S{backend-new-desc} \cw{new_desc()}
 
 \c char *(*new_desc)(const game_params *params, random_state *rs,
-\c                   char **aux, int interactive);
+\c                   char **aux, bool interactive);
 
 This function is where all the really hard work gets done. This is
 the function whose job is to randomly generate a new puzzle,
@@ -1046,11 +1046,11 @@ punishable by assertion failure in the mid-end.
 
 \S{backend-can-solve} \c{can_solve}
 
-\c int can_solve;
+\c bool can_solve;
 
-This boolean field is set to \cw{TRUE} if the game's \cw{solve()}
-function does something. If it's set to \cw{FALSE}, the game will
-not even offer the \q{Solve} menu option.
+This field is set to \cw{true} if the game's \cw{solve()} function
+does something. If it's set to \cw{false}, the game will not even
+offer the \q{Solve} menu option.
 
 \S{backend-solve} \cw{solve()}
 
@@ -1370,27 +1370,27 @@ printing puzzles out on paper.
 
 \S{backend-can-print} \c{can_print}
 
-\c int can_print;
+\c bool can_print;
 
-This flag is set to \cw{TRUE} if the puzzle is capable of printing
+This flag is set to \cw{true} if the puzzle is capable of printing
 itself on paper. (This makes sense for some puzzles, such as Solo,
 which can be filled in with a pencil. Other puzzles, such as
 Twiddle, inherently involve moving things around and so would not
 make sense to print.)
 
-If this flag is \cw{FALSE}, then the functions \cw{print_size()}
+If this flag is \cw{false}, then the functions \cw{print_size()}
 and \cw{print()} will never be called.
 
 \S{backend-can-print-in-colour} \c{can_print_in_colour}
 
-\c int can_print_in_colour;
+\c bool can_print_in_colour;
 
-This flag is set to \cw{TRUE} if the puzzle is capable of printing
+This flag is set to \cw{true} if the puzzle is capable of printing
 itself differently when colour is available. For example, Map can
 actually print coloured regions in different \e{colours} rather than
 resorting to cross-hatching.
 
-If the \c{can_print} flag is \cw{FALSE}, then this flag will be
+If the \c{can_print} flag is \cw{false}, then this flag will be
 ignored.
 
 \S{backend-print-size} \cw{print_size()}
@@ -1462,31 +1462,31 @@ called.
 
 \S{backend-can-format-as-text-ever} \c{can_format_as_text_ever}
 
-\c int can_format_as_text_ever;
+\c bool can_format_as_text_ever;
 
-This boolean field is \cw{TRUE} if the game supports formatting a
+This field is \cw{true} if the game supports formatting a
 game state as ASCII text (typically ASCII art) for copying to the
-clipboard and pasting into other applications. If it is \cw{FALSE},
+clipboard and pasting into other applications. If it is \cw{false},
 front ends will not offer the \q{Copy} command at all.
 
-If this field is \cw{TRUE}, the game does not necessarily have to
+If this field is \cw{true}, the game does not necessarily have to
 support text formatting for \e{all} games: e.g. a game which can be
 played on a square grid or a triangular one might only support copy
 and paste for the former, because triangular grids in ASCII art are
 just too difficult.
 
-If this field is \cw{FALSE}, the functions
+If this field is \cw{false}, the functions
 \cw{can_format_as_text_now()} (\k{backend-can-format-as-text-now})
 and \cw{text_format()} (\k{backend-text-format}) are never called.
 
 \S{backend-can-format-as-text-now} \c{can_format_as_text_now()}
 
-\c int (*can_format_as_text_now)(const game_params *params);
+\c bool (*can_format_as_text_now)(const game_params *params);
 
-This function is passed a \c{game_params} and returns a boolean,
-which is \cw{TRUE} if the game can support ASCII text output for
-this particular game type. If it returns \cw{FALSE}, front ends will
-grey out or otherwise disable the \q{Copy} command.
+This function is passed a \c{game_params}, and returns \cw{true} if
+the game can support ASCII text output for this particular game type.
+If it returns \cw{false}, front ends will grey out or otherwise
+disable the \q{Copy} command.
 
 Games may enable and disable the copy-and-paste function for
 different game \e{parameters}, but are currently constrained to
@@ -1530,28 +1530,28 @@ whether that should come with a newline or not.)
 
 \S{backend-wants-statusbar} \cw{wants_statusbar}
 
-\c int wants_statusbar;
+\c bool wants_statusbar;
 
-This boolean field is set to \cw{TRUE} if the puzzle has a use for a
-textual status line (to display score, completion status, currently
-active tiles, etc).
+This field is set to \cw{true} if the puzzle has a use for a textual
+status line (to display score, completion status, currently active
+tiles, etc).
 
 \S{backend-is-timed} \c{is_timed}
 
-\c int is_timed;
+\c bool is_timed;
 
-This boolean field is \cw{TRUE} if the puzzle is time-critical. If
+This field is \cw{true} if the puzzle is time-critical. If
 so, the mid-end will maintain a game timer while the user plays.
 
-If this field is \cw{FALSE}, then \cw{timing_state()} will never be
+If this field is \cw{false}, then \cw{timing_state()} will never be
 called and need not do anything.
 
 \S{backend-timing-state} \cw{timing_state()}
 
-\c int (*timing_state)(const game_state *state, game_ui *ui);
+\c bool (*timing_state)(const game_state *state, game_ui *ui);
 
 This function is passed the current \c{game_state} and the local
-\c{game_ui}; it returns \cw{TRUE} if the game timer should currently
+\c{game_ui}; it returns \cw{true} if the game timer should currently
 be running.
 
 A typical use for the \c{game_ui} in this function is to note when
@@ -2394,15 +2394,14 @@ capabilities.
 
 \S{print-line-dotted} \cw{print_line_dotted()}
 
-\c void print_line_dotted(drawing *dr, int dotted);
+\c void print_line_dotted(drawing *dr, bool dotted);
 
 This function is called to toggle the drawing of dotted lines during
 printing. It is not supported during drawing.
 
-The parameter \cq{dotted} is a boolean; \cw{TRUE} means that future
-lines drawn by \cw{draw_line()}, \cw{draw_circle} and
-\cw{draw_polygon()} will be dotted, and \cw{FALSE} means that they
-will be solid.
+Setting \cq{dotted} to \cw{true} means that future lines drawn by
+\cw{draw_line()}, \cw{draw_circle} and \cw{draw_polygon()} will be
+dotted. Setting it to \cw{false} means that they will be solid.
 
 Some front ends may impose restrictions on the width of dotted
 lines. Asking for a dotted line via this front end will override any
@@ -2854,7 +2853,7 @@ when finished with by passing it to the game's own
 
 \H{midend-size} \cw{midend_size()}
 
-\c void midend_size(midend *me, int *x, int *y, int user_size);
+\c void midend_size(midend *me, int *x, int *y, bool user_size);
 
 Tells the mid-end to figure out its window size.
 
@@ -2872,7 +2871,7 @@ status bar is also not included in this size.)
 Use \c{user_size} to indicate whether \c{*x} and \c{*y} are a
 requested size, or just a maximum size.
 
-If \c{user_size} is set to \cw{TRUE}, the mid-end will treat the
+If \c{user_size} is set to \cw{true}, the mid-end will treat the
 input size as a request, and will pick a tile size which
 approximates it \e{as closely as possible}, going over the game's
 preferred tile size if necessary to achieve this. The mid-end will
@@ -2995,7 +2994,7 @@ call to this function. Some back ends require that \cw{midend_size()}
 
 \H{midend-process-key} \cw{midend_process_key()}
 
-\c int midend_process_key(midend *me, int x, int y, int button);
+\c bool midend_process_key(midend *me, int x, int y, int button);
 
 The front end calls this function to report a mouse or keyboard
 event. The parameters \c{x}, \c{y} and \c{button} are almost
@@ -3028,10 +3027,10 @@ Calling this function is very likely to result in calls back to the
 front end's drawing API and/or \cw{activate_timer()}
 (\k{frontend-activate-timer}).
 
-The return value from \cw{midend_process_key()} is non-zero, unless
-the effect of the keypress was to request termination of the
-program. A front end should shut down the puzzle in response to a
-zero return.
+The return value from \cw{midend_process_key()} is \cw{true} unless
+the effect of the keypress was to request termination of the program.
+A front end should shut down the puzzle in response to a \cw{false}
+return.
 
 \H{midend-request-keys} \cw{midend_request_keys()}
 
@@ -3147,9 +3146,9 @@ of the corresponding \cw{struct preset_menu_entry} returned by
 
 \H{midend-wants-statusbar} \cw{midend_wants_statusbar()}
 
-\c int midend_wants_statusbar(midend *me);
+\c bool midend_wants_statusbar(midend *me);
 
-This function returns \cw{TRUE} if the puzzle has a use for a
+This function returns \cw{true} if the puzzle has a use for a
 textual status line (to display score, completion status, currently
 active tiles, time, or anything else).
 
@@ -3267,12 +3266,12 @@ The returned string, if it is non-\cw{NULL}, is dynamically allocated.
 
 \H{midend-can-format-as-text-now} \cw{midend_can_format_as_text_now()}
 
-\c int midend_can_format_as_text_now(midend *me);
+\c bool midend_can_format_as_text_now(midend *me);
 
-Returns \cw{TRUE} if the game code is capable of formatting puzzles
+Returns \cw{true} if the game code is capable of formatting puzzles
 of the currently selected game type as ASCII.
 
-If this returns \cw{FALSE}, then \cw{midend_text_format()}
+If this returns \cw{false}, then \cw{midend_text_format()}
 (\k{midend-text-format}) will return \cw{NULL}.
 
 \H{midend-text-format} \cw{midend_text_format()}
@@ -3324,18 +3323,18 @@ status code.)
 
 \H{midend-can-undo} \cw{midend_can_undo()}
 
-\c int midend_can_undo(midend *me);
+\c bool midend_can_undo(midend *me);
 
-Returns \cw{TRUE} if the midend is currently in a state where the undo
+Returns \cw{true} if the midend is currently in a state where the undo
 operation is meaningful (i.e. at least one position exists on the undo
 chain before the present one). Front ends may wish to use this to
 visually activate and deactivate an undo button.
 
 \H{midend-can-redo} \cw{midend_can_redo()}
 
-\c int midend_can_redo(midend *me);
+\c bool midend_can_redo(midend *me);
 
-Returns \cw{TRUE} if the midend is currently in a state where the redo
+Returns \cw{true} if the midend is currently in a state where the redo
 operation is meaningful (i.e. at least one position exists on the redo
 chain after the present one). Front ends may wish to use this to
 visually activate and deactivate a redo button.
@@ -3367,7 +3366,7 @@ output string.
 \H{midend-deserialise} \cw{midend_deserialise()}
 
 \c const char *midend_deserialise(midend *me,
-\c     int (*read)(void *ctx, void *buf, int len), void *rctx);
+\c     bool (*read)(void *ctx, void *buf, int len), void *rctx);
 
 This function is the counterpart to \cw{midend_serialise()}. It
 calls the supplied \cw{read} function repeatedly to read a quantity
@@ -3376,8 +3375,8 @@ as output by \cw{midend_serialise()}.
 
 The \cw{read} function is called with the first parameter (\c{ctx})
 equal to \c{rctx}, and should attempt to read \c{len} bytes of data
-into the buffer pointed to by \c{buf}. It should return \cw{FALSE}
-on failure or \cw{TRUE} on success. It should not report success
+into the buffer pointed to by \c{buf}. It should return \cw{false}
+on failure or \cw{true} on success. It should not report success
 unless it has filled the entire buffer; on platforms which might be
 reading from a pipe or other blocking data source, \c{read} is
 responsible for looping until the whole buffer has been filled.
@@ -3405,7 +3404,7 @@ place.
 \H{identify-game} \cw{identify_game()}
 
 \c const char *identify_game(char **name,
-\c     int (*read)(void *ctx, void *buf, int len), void *rctx);
+\c     bool (*read)(void *ctx, void *buf, int len), void *rctx);
 
 This function examines a serialised midend stream, of the same kind
 used by \cw{midend_serialise()} and \cw{midend_deserialise()}, and
@@ -4045,13 +4044,13 @@ Returns the number of elements currently in the tree.
 
 \S{utils-splitpos234} \cw{splitpos234()}
 
-\c tree234 *splitpos234(tree234 *t, int index, int before);
+\c tree234 *splitpos234(tree234 *t, int index, bool before);
 
 Splits the input tree into two pieces at a given position, and
 creates a new tree containing all the elements on one side of that
 position.
 
-If \c{before} is \cw{TRUE}, then all the items at or after position
+If \c{before} is \cw{true}, then all the items at or after position
 \c{index} are left in the input tree, and the items before that
 point are returned in the new tree. Otherwise, the reverse happens:
 all the items at or after \c{index} are moved into the new tree, and
diff --git a/apps/plugins/puzzles/src/divvy.c b/apps/plugins/puzzles/src/divvy.c
index 517e3ddbb0..ea018010cf 100644
--- a/apps/plugins/puzzles/src/divvy.c
+++ b/apps/plugins/puzzles/src/divvy.c
@@ -212,7 +212,7 @@
  * (This only works _because_ we've ensured the omino is simply
  * connected.)
  */
-static int addremcommon(int w, int h, int x, int y, int *own, int val)
+static bool addremcommon(int w, int h, int x, int y, int *own, int val)
 {
     int neighbours[8];
     int dir, count;
@@ -233,14 +233,14 @@ static int addremcommon(int w, int h, int x, int y, int *own, int val)
      */
     if (neighbours[0] != val && neighbours[2] != val &&
 	neighbours[4] != val && neighbours[6] != val)
-	return FALSE;
+	return false;
 
     count = 0;
 
     for (dir = 0; dir < 8; dir++) {
 	int next = (dir + 1) & 7;
-	int gotthis = (neighbours[dir] == val);
-	int gotnext = (neighbours[next] == val);
+        bool gotthis = (neighbours[dir] == val);
+	bool gotnext = (neighbours[next] == val);
 
 	if (gotthis != gotnext)
 	    count++;
@@ -262,7 +262,8 @@ static int addremcommon(int w, int h, int x, int y, int *own, int val)
  */
 static int *divvy_internal(int w, int h, int k, random_state *rs)
 {
-    int *order, *queue, *tmp, *own, *sizes, *addable, *removable, *retdsf;
+    int *order, *queue, *tmp, *own, *sizes, *addable, *retdsf;
+    bool *removable;
     int wh = w*h;
     int i, j, n, x, y, qhead, qtail;
 
@@ -275,7 +276,7 @@ static int *divvy_internal(int w, int h, int k, random_state *rs)
     sizes = snewn(n, int);
     queue = snewn(n, int);
     addable = snewn(wh*4, int);
-    removable = snewn(wh, int);
+    removable = snewn(wh, bool);
 
     /*
      * Permute the grid squares into a random order, which will be
@@ -341,9 +342,9 @@ static int *divvy_internal(int w, int h, int k, random_state *rs)
 		int dir;
 
 		if (curr < 0) {
-		    removable[yx] = FALSE; /* can't remove if not owned! */
+		    removable[yx] = false; /* can't remove if not owned! */
 		} else if (sizes[curr] == 1) {
-		    removable[yx] = TRUE; /* can always remove a singleton */
+		    removable[yx] = true; /* can always remove a singleton */
 		} else {
 		    /*
 		     * See if this square can be removed from its
diff --git a/apps/plugins/puzzles/src/dominosa.c b/apps/plugins/puzzles/src/dominosa.c
index 73b744d2be..5f035e9250 100644
--- a/apps/plugins/puzzles/src/dominosa.c
+++ b/apps/plugins/puzzles/src/dominosa.c
@@ -13,13 +13,17 @@
  *     * rule out a domino placement if it would divide an unfilled
  *       region such that at least one resulting region had an odd
  *       area
- *        + use b.f.s. to determine the area of an unfilled region
- *        + a square is unfilled iff it has at least two possible
- *          placements, and two adjacent unfilled squares are part
- *          of the same region iff the domino placement joining
- *          them is possible
+ *        + Tarjan's bridge-finding algorithm would be a way to find
+ *          domino placements that split a connected region in two:
+ *          form the graph whose vertices are unpaired squares and
+ *          whose edges are potential (not placed but also not ruled
+ *          out) dominoes covering two of them, and any bridge in that
+ *          graph is a candidate.
+ *        + Then, finding any old spanning forest of the unfilled
+ *          squares should be sufficient to determine the area parity
+ *          of the region that any such placement would cut off.
  *
- *     * perhaps set analysis
+ *     * set analysis
  *        + look at all unclaimed squares containing a given number
  *        + for each one, find the set of possible numbers that it
  *          can connect to (i.e. each neighbouring tile such that
@@ -37,6 +41,29 @@
  *             things out after finding the subset, we must be
  *             careful that we don't rule out precisely the domino
  *             placement that was _included_ in our set!
+ *
+ *     * playing off the two ends of one potential domino, by
+ *       considering the alternatives to that domino that each end
+ *       might otherwise be part of.
+ *        + if not playing this domino would require each end to be
+ *          part of an identical domino, play it. (e.g. the middle of
+ *          5-4-4-5)
+ *        + if not playing this domino would guarantee that the two
+ *          ends between them used up all of some other square's
+ *          choices, play it. (e.g. the middle of 2-3-3-1 if another 3
+ *          cell can only link to a 2 or a 1)
+ *
+ *     * identify 'forcing chains', in the sense of any path of cells
+ *       each of which has only two possible dominoes to be part of,
+ *       and each of those rules out one of the choices for the next
+ *       cell. Such a chain has the property that either all the odd
+ *       dominoes are placed, or all the even ones are placed; so if
+ *       either set of those introduces a conflict (e.g. a dupe within
+ *       the chain, or using up all of some other square's choices),
+ *       then the whole set can be ruled out, and the other set played
+ *       immediately.
+ *        + this is of course a generalisation of the previous idea,
+ *          which is simply a forcing chain of length 3.
  */
 
 #include <stdio.h>
@@ -71,7 +98,7 @@ enum {
 
 struct game_params {
     int n;
-    int unique;
+    bool unique;
 };
 
 struct game_numbers {
@@ -90,7 +117,7 @@ struct game_state {
     struct game_numbers *numbers;
     int *grid;
     unsigned short *edges;             /* h x w */
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -98,12 +125,12 @@ static game_params *default_params(void)
     game_params *ret = snew(game_params);
 
     ret->n = 6;
-    ret->unique = TRUE;
+    ret->unique = true;
 
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int n;
@@ -117,7 +144,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
       case 4: n = 7; break;
       case 5: n = 8; break;
       case 6: n = 9; break;
-      default: return FALSE;
+      default: return false;
     }
 
     sprintf(buf, "Up to double-%d", n);
@@ -125,9 +152,9 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *params = ret = snew(game_params);
     ret->n = n;
-    ret->unique = TRUE;
+    ret->unique = true;
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -147,10 +174,10 @@ static void decode_params(game_params *params, char const *string)
     params->n = atoi(string);
     while (*string && isdigit((unsigned char)*string)) string++;
     if (*string == 'a')
-        params->unique = FALSE;
+        params->unique = false;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
     sprintf(buf, "%d", params->n);
@@ -191,7 +218,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 1)
         return "Maximum face number must be at least one";
@@ -325,7 +352,7 @@ static int solver(int w, int h, int n, int *grid, int *output)
 #endif
 
     while (1) {
-        int done_something = FALSE;
+        bool done_something = false;
 
         /*
          * For each domino, look at its possible placements, and
@@ -375,7 +402,7 @@ static int solver(int w, int h, int n, int *grid, int *output)
                 if (placements[j] != -2) {
                     int p1, p2, di;
 
-                    done_something = TRUE;
+                    done_something = true;
 
                     /*
                      * Rule out this placement. First find what
@@ -464,7 +491,7 @@ static int solver(int w, int h, int n, int *grid, int *output)
                 for (k = heads[adi]; k >= 0; k = placements[k])
                     nn++;
                 if (nn > n) {
-                    done_something = TRUE;
+                    done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
                     printf("considering square %d,%d: reducing placements "
                            "of domino %d\n", x, y, adi);
@@ -544,7 +571,7 @@ static int solver(int w, int h, int n, int *grid, int *output)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int n = params->n, w = n+2, h = n+1, wh = w*h;
     int *grid, *grid2, *list;
@@ -834,7 +861,8 @@ static game_state *new_game(midend *me, const game_params *params,
         state->numbers->numbers[i] = j;
     }
 
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     return state;
 }
@@ -940,7 +968,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return params->n < 1000;
 }
@@ -1013,14 +1041,15 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int cur_x, cur_y, cur_visible, highlight_1, highlight_2;
+    int cur_x, cur_y, highlight_1, highlight_2;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
     ui->cur_x = ui->cur_y = 0;
-    ui->cur_visible = 0;
+    ui->cur_visible = false;
     ui->highlight_1 = ui->highlight_2 = -1;
     return ui;
 }
@@ -1043,7 +1072,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
     if (!oldstate->completed && newstate->completed)
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 }
 
 #define PREFERRED_TILESIZE 32
@@ -1058,7 +1087,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 #define FROMCOORD(x) ( ((x) - BORDER + TILESIZE) / TILESIZE - 1 )
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h, tilesize;
     unsigned long *visible;
 };
@@ -1107,13 +1136,13 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             (state->grid[d1] != d1 || state->grid[d2] != d2))
             return NULL;
 
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         sprintf(buf, "%c%d,%d", (int)(button == RIGHT_BUTTON ? 'E' : 'D'), d1, d2);
         return dupstr(buf);
     } else if (IS_CURSOR_MOVE(button)) {
-	ui->cur_visible = 1;
+	ui->cur_visible = true;
 
-        move_cursor(button, &ui->cur_x, &ui->cur_y, 2*w-1, 2*h-1, 0);
+        move_cursor(button, &ui->cur_x, &ui->cur_y, 2*w-1, 2*h-1, false);
 
 	return UI_UPDATE;
     } else if (IS_CURSOR_SELECT(button)) {
@@ -1164,7 +1193,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         if (move[0] == 'S') {
             int i;
 
-            ret->cheated = TRUE;
+            ret->cheated = true;
 
             /*
              * Clear the existing edges and domino placements. We
@@ -1278,7 +1307,7 @@ static game_state *execute_move(const game_state *state, const char *move)
      */
     if (!ret->completed) {
         int i, ok = 0;
-        unsigned char *used = snewn(TRI(n+1), unsigned char);
+        bool *used = snewn(TRI(n+1), bool);
 
         memset(used, 0, TRI(n+1));
         for (i = 0; i < wh; i++)
@@ -1292,14 +1321,14 @@ static game_state *execute_move(const game_state *state, const char *move)
                 assert(di >= 0 && di < TRI(n+1));
 
                 if (!used[di]) {
-                    used[di] = 1;
+                    used[di] = true;
                     ok++;
                 }
             }
 
         sfree(used);
         if (ok == DCOUNT(n))
-            ret->completed = TRUE;
+            ret->completed = true;
     }
 
     return ret;
@@ -1371,7 +1400,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->visible = snewn(ds->w * ds->h, unsigned long);
@@ -1542,7 +1571,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         game_compute_size(&state->params, TILESIZE, &pw, &ph);
 	draw_rect(dr, 0, 0, pw, ph, COL_BACKGROUND);
 	draw_update(dr, 0, 0, pw, ph);
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     /*
@@ -1645,9 +1674,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1710,15 +1739,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1735,9 +1764,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/drawing.c b/apps/plugins/puzzles/src/drawing.c
index caf0b4b43a..a8eb8cfd5f 100644
--- a/apps/plugins/puzzles/src/drawing.c
+++ b/apps/plugins/puzzles/src/drawing.c
@@ -264,7 +264,7 @@ void print_end_doc(drawing *dr)
     dr->api->end_doc(dr->handle);
 }
 
-void print_get_colour(drawing *dr, int colour, int printing_in_colour,
+void print_get_colour(drawing *dr, int colour, bool printing_in_colour,
 		      int *hatch, float *r, float *g, float *b)
 {
     assert(colour >= 0 && colour < dr->ncolours);
@@ -347,7 +347,7 @@ void print_line_width(drawing *dr, int width)
     dr->api->line_width(dr->handle, (float)sqrt(dr->scale) * width);
 }
 
-void print_line_dotted(drawing *dr, int dotted)
+void print_line_dotted(drawing *dr, bool dotted)
 {
     dr->api->line_dotted(dr->handle, dotted);
 }
diff --git a/apps/plugins/puzzles/src/dsf.c b/apps/plugins/puzzles/src/dsf.c
index aa22392661..832bb3005a 100644
--- a/apps/plugins/puzzles/src/dsf.c
+++ b/apps/plugins/puzzles/src/dsf.c
@@ -15,7 +15,8 @@
     int *equal_elements = snewn(size, int);
     int *inverse_elements = snewn(size, int);
     int printed_count = 0, equal_count, inverse_count;
-    int i, n, inverse;
+    int i, n;
+    bool inverse;
 
     memset(printed_elements, -1, sizeof(int) * size);
 
@@ -92,17 +93,17 @@ int dsf_canonify(int *dsf, int index)
 
 void dsf_merge(int *dsf, int v1, int v2)
 {
-    edsf_merge(dsf, v1, v2, FALSE);
+    edsf_merge(dsf, v1, v2, false);
 }
 
 int dsf_size(int *dsf, int index) {
     return dsf[dsf_canonify(dsf, index)] >> 2;
 }
 
-int edsf_canonify(int *dsf, int index, int *inverse_return)
+int edsf_canonify(int *dsf, int index, bool *inverse_return)
 {
     int start_index = index, canonical_index;
-    int inverse = 0;
+    bool inverse = false;
 
 /*    fprintf(stderr, "dsf = %p\n", dsf); */
 /*    fprintf(stderr, "Canonify %2d\n", index); */
@@ -128,22 +129,22 @@ int edsf_canonify(int *dsf, int index, int *inverse_return)
     index = start_index;
     while (index != canonical_index) {
 	int nextindex = dsf[index] >> 2;
-        int nextinverse = inverse ^ (dsf[index] & 1);
+        bool nextinverse = inverse ^ (dsf[index] & 1);
 	dsf[index] = (canonical_index << 2) | inverse;
         inverse = nextinverse;
 	index = nextindex;
     }
 
-    assert(inverse == 0);
+    assert(!inverse);
 
 /*    fprintf(stderr, "Return %2d\n", index); */
     
     return index;
 }
 
-void edsf_merge(int *dsf, int v1, int v2, int inverse)
+void edsf_merge(int *dsf, int v1, int v2, bool inverse)
 {
-    int i1, i2;
+    bool i1, i2;
 
 /*    fprintf(stderr, "dsf = %p\n", dsf); */
 /*    fprintf(stderr, "Merge [%2d,%2d], %d\n", v1, v2, inverse); */
@@ -160,7 +161,6 @@ void edsf_merge(int *dsf, int v1, int v2, int inverse)
     if (v1 == v2)
         assert(!inverse);
     else {
-	assert(inverse == 0 || inverse == 1);
 	/*
 	 * We always make the smaller of v1 and v2 the new canonical
 	 * element. This ensures that the canonical element of any
@@ -181,7 +181,7 @@ void edsf_merge(int *dsf, int v1, int v2, int inverse)
 	    v2 = v3;
 	}
 	dsf[v1] += (dsf[v2] >> 2) << 2;
-	dsf[v2] = (v1 << 2) | !!inverse;
+	dsf[v2] = (v1 << 2) | inverse;
     }
     
     v2 = edsf_canonify(dsf, v2, &i2);
diff --git a/apps/plugins/puzzles/src/emcc.c b/apps/plugins/puzzles/src/emcc.c
index 563fbe2799..9a6c742482 100644
--- a/apps/plugins/puzzles/src/emcc.c
+++ b/apps/plugins/puzzles/src/emcc.c
@@ -67,7 +67,7 @@ extern int js_get_selected_preset(void);
 extern void js_select_preset(int n);
 extern void js_get_date_64(unsigned *p);
 extern void js_update_permalinks(const char *desc, const char *seed);
-extern void js_enable_undo_redo(int undo, int redo);
+extern void js_enable_undo_redo(bool undo, bool redo);
 extern void js_activate_timer();
 extern void js_deactivate_timer();
 extern void js_canvas_start_draw(void);
@@ -101,7 +101,7 @@ extern void js_dialog_init(const char *title);
 extern void js_dialog_string(int i, const char *title, const char *initvalue);
 extern void js_dialog_choices(int i, const char *title, const char *choicelist,
                               int initvalue);
-extern void js_dialog_boolean(int i, const char *title, int initvalue);
+extern void js_dialog_boolean(int i, const char *title, bool initvalue);
 extern void js_dialog_launch(void);
 extern void js_dialog_cleanup(void);
 extern void js_focus_canvas(void);
@@ -171,17 +171,17 @@ midend *me;
 /* ----------------------------------------------------------------------
  * Timing functions.
  */
-int timer_active = FALSE;
+bool timer_active = false;
 void deactivate_timer(frontend *fe)
 {
     js_deactivate_timer();
-    timer_active = FALSE;
+    timer_active = false;
 }
 void activate_timer(frontend *fe)
 {
     if (!timer_active) {
         js_activate_timer();
-        timer_active = TRUE;
+        timer_active = true;
     }
 }
 void timer_callback(double tplus)
@@ -201,7 +201,7 @@ static void resize(void)
 {
     int w, h;
     w = h = INT_MAX;
-    midend_size(me, &w, &h, FALSE);
+    midend_size(me, &w, &h, false);
     js_canvas_set_size(w, h);
     canvas_w = w;
     canvas_h = h;
@@ -210,7 +210,7 @@ static void resize(void)
 /* Called from JS when the user uses the resize handle */
 void resize_puzzle(int w, int h)
 {
-    midend_size(me, &w, &h, TRUE);
+    midend_size(me, &w, &h, true);
     if (canvas_w != w || canvas_h != h) { 
         js_canvas_set_size(w, h);
         canvas_w = w;
@@ -277,7 +277,7 @@ void mousemove(int x, int y, int buttons)
  * Keyboard handler called from JS.
  */
 void key(int keycode, int charcode, const char *key, const char *chr,
-         int shift, int ctrl)
+         bool shift, bool ctrl)
 {
     int keyevent = -1;
 
@@ -554,7 +554,7 @@ const struct drawing_api js_drawing = {
  */
 static game_params **presets;
 static int npresets;
-int have_presets_dropdown;
+bool have_presets_dropdown;
 
 void populate_js_preset_menu(int menuid, struct preset_menu *menu)
 {
@@ -647,11 +647,11 @@ void dlg_return_ival(int index, int val)
 }
 
 /*
- * Called when the user clicks OK or Cancel. use_results will be TRUE
- * or FALSE respectively, in those cases. We terminate the dialog box,
+ * Called when the user clicks OK or Cancel. use_results will be true
+ * or false respectively, in those cases. We terminate the dialog box,
  * unless the user selected an invalid combination of parameters.
  */
-static void cfg_end(int use_results)
+static void cfg_end(bool use_results)
 {
     if (use_results) {
         /*
@@ -738,11 +738,11 @@ void command(int n)
         }
         break;
       case 3:                          /* OK clicked in a config box */
-        cfg_end(TRUE);
+        cfg_end(true);
         update_undo_redo();
         break;
       case 4:                          /* Cancel clicked in a config box */
-        cfg_end(FALSE);
+        cfg_end(false);
         update_undo_redo();
         break;
       case 5:                          /* New Game */
@@ -806,11 +806,15 @@ char *get_save_file(void)
     midend_serialise(me, savefile_write, &ctx);
     size = ctx.pos;
 
-    /* Second pass, to actually write out the data */
-    ctx.buffer = snewn(size, char);
+    /* Second pass, to actually write out the data. We have to put a
+     * terminating \0 on the end (which we expect never to show up in
+     * the actual serialisation format - it's text, not binary) so
+     * that the Javascript side can easily find out the length. */
+    ctx.buffer = snewn(size+1, char);
     ctx.pos = 0;
     midend_serialise(me, savefile_write, &ctx);
     assert(ctx.pos == size);
+    ctx.buffer[ctx.pos] = '\0';
 
     return ctx.buffer;
 }
@@ -825,15 +829,15 @@ struct savefile_read_ctx {
     int len_remaining;
 };
 
-static int savefile_read(void *vctx, void *buf, int len)
+static bool savefile_read(void *vctx, void *buf, int len)
 {
     struct savefile_read_ctx *ctx = (struct savefile_read_ctx *)vctx;
     if (ctx->len_remaining < len)
-        return FALSE;
+        return false;
     memcpy(buf, ctx->buffer, len);
     ctx->len_remaining -= len;
     ctx->buffer += len;
-    return TRUE;
+    return true;
 }
 
 void load_game(const char *buffer, int len)
@@ -912,7 +916,7 @@ int main(int argc, char **argv)
         if (thegame.can_configure)
             js_add_preset(0, "Custom", -1);
 
-        have_presets_dropdown = TRUE;
+        have_presets_dropdown = true;
 
         /*
          * Now ensure the appropriate element of the presets menu
diff --git a/apps/plugins/puzzles/src/fifteen.c b/apps/plugins/puzzles/src/fifteen.c
index 35bcb32a36..ba991e711a 100644
--- a/apps/plugins/puzzles/src/fifteen.c
+++ b/apps/plugins/puzzles/src/fifteen.c
@@ -46,8 +46,8 @@ struct game_state {
     int w, h, n;
     int *tiles;
     int gap_pos;
-    int completed;
-    int used_solve;		       /* used to suppress completion flash */
+    int completed;             /* move count at time of completion */
+    bool used_solve;           /* used to suppress completion flash */
     int movecount;
 };
 
@@ -60,14 +60,14 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     if (i == 0) {
 	*params = default_params();
 	*name = dupstr("4x4");
-	return TRUE;
+	return true;
     }
-    return FALSE;
+    return false;
 }
 
 static void free_params(game_params *params)
@@ -92,7 +92,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -134,7 +134,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must both be at least two";
@@ -157,27 +157,28 @@ static int perm_parity(int *perm, int n)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int gap, n, i, x;
     int x1, x2, p1, p2, parity;
-    int *tiles, *used;
+    int *tiles;
+    bool *used;
     char *ret;
     int retlen;
 
     n = params->w * params->h;
 
     tiles = snewn(n, int);
-    used = snewn(n, int);
+    used = snewn(n, bool);
 
     for (i = 0; i < n; i++) {
         tiles[i] = -1;
-        used[i] = FALSE;
+        used[i] = false;
     }
 
     gap = random_upto(rs, n);
     tiles[gap] = 0;
-    used[0] = TRUE;
+    used[0] = true;
 
     /*
      * Place everything else except the last two tiles.
@@ -191,7 +192,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
                 break;
 
         assert(j < n && !used[j]);
-        used[j] = TRUE;
+        used[j] = true;
 
         while (tiles[x] >= 0)
             x++;
@@ -275,15 +276,15 @@ static const char *validate_desc(const game_params *params, const char *desc)
     const char *p;
     const char *err;
     int i, area;
-    int *used;
+    bool *used;
 
     area = params->w * params->h;
     p = desc;
     err = NULL;
 
-    used = snewn(area, int);
+    used = snewn(area, bool);
     for (i = 0; i < area; i++)
-	used[i] = FALSE;
+	used[i] = false;
 
     for (i = 0; i < area; i++) {
 	const char *q = p;
@@ -312,7 +313,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
 	    err = "Number used twice";
 	    goto leave;
 	}
-	used[n] = TRUE;
+	used[n] = true;
 
 	if (*p) p++;		       /* eat comma */
     }
@@ -350,7 +351,7 @@ static game_state *new_game(midend *me, const game_params *params,
     assert(state->tiles[state->gap_pos] == 0);
 
     state->completed = state->movecount = 0;
-    state->used_solve = FALSE;
+    state->used_solve = false;
 
     return state;
 }
@@ -384,9 +385,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -455,7 +456,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h, bgcolour;
     int *tiles;
     int tilesize;
@@ -521,7 +522,7 @@ static void next_move(int nx, int ny, int ox, int oy, int gx, int gy,
 {
     const int to_tile_x = (gx < nx ? +1 : -1);
     const int to_goal_x = (gx < tx ? +1 : -1);
-    const int gap_x_on_goal_side = ((nx-tx) * (nx-gx) > 0);
+    const bool gap_x_on_goal_side = ((nx-tx) * (nx-gx) > 0);
 
     assert (nx != tx || ny != ty); /* not already in place */
     assert (nx != gx || ny != gy); /* not placing the gap */
@@ -608,7 +609,7 @@ static void next_move(int nx, int ny, int ox, int oy, int gx, int gy,
         *dx = to_tile_x;
 }
 
-static int compute_hint(const game_state *state, int *out_x, int *out_y)
+static bool compute_hint(const game_state *state, int *out_x, int *out_y)
 {
     /* The overall solving process is this:
      * 1. Find the next piece to be put in its place
@@ -657,7 +658,7 @@ static int compute_hint(const game_state *state, int *out_x, int *out_y)
     }
 
     if (next_piece == n)
-        return FALSE;
+        return false;
 
     /* 2, 3. Move the next piece towards its place */
 
@@ -680,7 +681,7 @@ static int compute_hint(const game_state *state, int *out_x, int *out_y)
 
     *out_x = gx + dx;
     *out_y = gy + dy;
-    return TRUE;
+    return true;
 }
 
 static char *interpret_move(const game_state *state, game_ui *ui,
@@ -707,7 +708,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         button = flip_cursor(button); /* the default */
         if (invert_cursor)
             button = flip_cursor(button); /* undoes the first flip */
-	move_cursor(button, &nx, &ny, state->w, state->h, FALSE);
+	move_cursor(button, &nx, &ny, state->w, state->h, false);
     } else if ((button == 'h' || button == 'H') && !state->completed) {
         if (!compute_hint(state, &nx, &ny))
             return NULL; /* shouldn't happen, since ^^we^^checked^^ */
@@ -746,7 +747,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	for (i = 0; i < ret->n; i++)
 	    ret->tiles[i] = (i+1) % ret->n;
 	ret->gap_pos = ret->n-1;
-	ret->used_solve = TRUE;
+	ret->used_solve = true;
 	ret->completed = ret->movecount = 1;
 
 	return ret;
@@ -835,7 +836,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->bgcolour = COL_BACKGROUND;
@@ -929,7 +930,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
         draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     /*
@@ -1065,9 +1066,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1090,15 +1091,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1115,9 +1116,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
@@ -1129,18 +1130,19 @@ int main(int argc, char **argv)
     game_state *state;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
+    bool grade = false;
     char *progname = argv[0];
 
     char buf[80];
-    int limit, x, y, solvable;
+    int limit, x, y;
+    bool solvable;
 
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            /* solver_show_working = TRUE; */
+            /* solver_show_working = true; */
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", progname, p);
             return 1;
diff --git a/apps/plugins/puzzles/src/filling.c b/apps/plugins/puzzles/src/filling.c
index e866a256ce..f67d9fadba 100644
--- a/apps/plugins/puzzles/src/filling.c
+++ b/apps/plugins/puzzles/src/filling.c
@@ -66,7 +66,7 @@
 
 #include "puzzles.h"
 
-static unsigned char verbose;
+static bool verbose;
 
 static void printv(const char *fmt, ...) {
 #if !defined(PALM) && !defined(ROCKBOX)
@@ -96,7 +96,7 @@ struct shared_state {
 struct game_state {
     int *board;
     struct shared_state *shared;
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static const struct game_params filling_defaults[3] = {
@@ -112,17 +112,17 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     char buf[64];
 
-    if (i < 0 || i >= lenof(filling_defaults)) return FALSE;
+    if (i < 0 || i >= lenof(filling_defaults)) return false;
     *params = snew(game_params);
     **params = filling_defaults[i]; /* struct copy */
     sprintf(buf, "%dx%d", filling_defaults[i].w, filling_defaults[i].h);
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -144,7 +144,7 @@ static void decode_params(game_params *ret, char const *string)
     if (*string == 'x') ret->h = atoi(++string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[64];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -184,7 +184,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1) return "Width must be at least one";
     if (params->h < 1) return "Height must be at least one";
@@ -268,9 +268,9 @@ static char *board_to_string(int *board, int w, int h) {
     return repr;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -312,7 +312,7 @@ static void free_game(game_state *);
 
 #define SENTINEL sz
 
-static int mark_region(int *board, int w, int h, int i, int n, int m) {
+static bool mark_region(int *board, int w, int h, int i, int n, int m) {
     int j;
 
     board[i] = -1;
@@ -320,11 +320,11 @@ static int mark_region(int *board, int w, int h, int i, int n, int m) {
     for (j = 0; j < 4; ++j) {
         const int x = (i % w) + dx[j], y = (i / w) + dy[j], ii = w*y + x;
         if (x < 0 || x >= w || y < 0 || y >= h) continue;
-        if (board[ii] == m) return FALSE;
+        if (board[ii] == m) return false;
         if (board[ii] != n) continue;
-        if (!mark_region(board, w, h, ii, n, m)) return FALSE;
+        if (!mark_region(board, w, h, ii, n, m)) return false;
     }
-    return TRUE;
+    return true;
 }
 
 static int region_size(int *board, int w, int h, int i) {
@@ -345,15 +345,18 @@ static void merge_ones(int *board, int w, int h)
 {
     const int sz = w * h;
     const int maxsize = min(max(max(w, h), 3), 9);
-    int i, j, k, change;
+    int i, j, k;
+    bool change;
     do {
-        change = FALSE;
+        change = false;
         for (i = 0; i < sz; ++i) {
             if (board[i] != 1) continue;
 
             for (j = 0; j < 4; ++j, board[i] = 1) {
                 const int x = (i % w) + dx[j], y = (i / w) + dy[j];
-                int oldsize, newsize, ok, ii = w*y + x;
+                int oldsize, newsize, ii = w*y + x;
+		bool ok;
+
                 if (x < 0 || x >= w || y < 0 || y >= h) continue;
                 if (board[ii] == maxsize) continue;
 
@@ -371,7 +374,7 @@ static void merge_ones(int *board, int w, int h)
 
                 if (ok) break;
             }
-            if (j < 4) change = TRUE;
+            if (j < 4) change = true;
         }
     } while (change);
 }
@@ -387,7 +390,8 @@ static void make_board(int *board, int w, int h, random_state *rs) {
     /* Note that if 1 in {w, h} then it's impossible to have a region
      * of size > w*h, so the special case only affects w=h=2. */
 
-    int i, change, *dsf;
+    int i, *dsf;
+    bool change;
 
     assert(w >= 1);
     assert(h >= 1);
@@ -403,11 +407,12 @@ retry:
     shuffle(board, sz, sizeof (int), rs);
 
     do {
-        change = FALSE; /* as long as the board potentially has errors */
+        change = false; /* as long as the board potentially has errors */
         for (i = 0; i < sz; ++i) {
             const int square = dsf_canonify(dsf, board[i]);
             const int size = dsf_size(dsf, square);
-            int merge = SENTINEL, min = maxsize - size + 1, error = FALSE;
+            int merge = SENTINEL, min = maxsize - size + 1;
+	    bool error = false;
             int neighbour, neighbour_size, j;
 
             for (j = 0; j < 4; ++j) {
@@ -419,7 +424,7 @@ retry:
                 if (square == neighbour) continue;
 
                 neighbour_size = dsf_size(dsf, neighbour);
-                if (size == neighbour_size) error = TRUE;
+                if (size == neighbour_size) error = true;
 
                 /* find the smallest neighbour to merge with, which
                  * wouldn't make the region too large.  (This is
@@ -441,7 +446,7 @@ retry:
 
             /* merge with the smallest neighbouring workable region. */
             dsf_merge(dsf, square, merge);
-            change = TRUE;
+            change = true;
         }
     } while (change);
 
@@ -520,7 +525,7 @@ static void flood_count(int *board, int w, int h, int i, int n, int *c) {
     }
 }
 
-static int check_capacity(int *board, int w, int h, int i) {
+static bool check_capacity(int *board, int w, int h, int i) {
     int n = board[i];
     flood_count(board, w, h, i, board[i], &n);
     clear_count(board, w * h);
@@ -625,16 +630,16 @@ static void init_solver_state(struct solver_state *s, int w, int h) {
         else filled_square(s, w, h, i);
 }
 
-static int learn_expand_or_one(struct solver_state *s, int w, int h) {
+static bool learn_expand_or_one(struct solver_state *s, int w, int h) {
     const int sz = w * h;
     int i;
-    int learn = FALSE;
+    bool learn = false;
 
     assert(s);
 
     for (i = 0; i < sz; ++i) {
 	int j;
-	int one = TRUE;
+	bool one = true;
 
 	if (s->board[i] != EMPTY) continue;
 
@@ -644,14 +649,14 @@ static int learn_expand_or_one(struct solver_state *s, int w, int h) {
 	    const int idx = w*y + x;
 	    if (x < 0 || x >= w || y < 0 || y >= h) continue;
 	    if (s->board[idx] == EMPTY) {
-		one = FALSE;
+		one = false;
 		continue;
 	    }
 	    if (one &&
 		(s->board[idx] == 1 ||
 		 (s->board[idx] >= expandsize(s->board, s->dsf, w, h,
 					      i, s->board[idx]))))
-		one = FALSE;
+		one = false;
 	    if (dsf_size(s->dsf, idx) == s->board[idx]) continue;
 	    assert(s->board[i] == EMPTY);
 	    s->board[i] = -SENTINEL;
@@ -659,7 +664,7 @@ static int learn_expand_or_one(struct solver_state *s, int w, int h) {
 	    assert(s->board[i] == EMPTY);
 	    printv("learn: expanding in one\n");
 	    expand(s, w, h, i, idx);
-	    learn = TRUE;
+	    learn = true;
 	    break;
 	}
 
@@ -669,16 +674,16 @@ static int learn_expand_or_one(struct solver_state *s, int w, int h) {
 	    s->board[i] = 1;
 	    assert(s->nempty);
 	    --s->nempty;
-	    learn = TRUE;
+	    learn = true;
 	}
     }
     return learn;
 }
 
-static int learn_blocked_expansion(struct solver_state *s, int w, int h) {
+static bool learn_blocked_expansion(struct solver_state *s, int w, int h) {
     const int sz = w * h;
     int i;
-    int learn = FALSE;
+    bool learn = false;
 
     assert(s);
     /* for every connected component */
@@ -758,7 +763,7 @@ static int learn_blocked_expansion(struct solver_state *s, int w, int h) {
 	if (exp == SENTINEL) continue;
 	printv("learning to expand\n");
 	expand(s, w, h, exp, i);
-	learn = TRUE;
+	learn = true;
 
         next_i:
         ;
@@ -767,10 +772,10 @@ static int learn_blocked_expansion(struct solver_state *s, int w, int h) {
     return learn;
 }
 
-static int learn_critical_square(struct solver_state *s, int w, int h) {
+static bool learn_critical_square(struct solver_state *s, int w, int h) {
     const int sz = w * h;
     int i;
-    int learn = FALSE;
+    bool learn = false;
     assert(s);
 
     /* for each connected component */
@@ -804,7 +809,7 @@ static int learn_critical_square(struct solver_state *s, int w, int h) {
 	    --s->nempty;
 	    s->board[j] = s->board[i];
 	    filled_square(s, w, h, j);
-	    learn = TRUE;
+	    learn = true;
 	}
     }
     return learn;
@@ -824,14 +829,14 @@ static void print_bitmap(int *bitmap, int w, int h) {
 }
 #endif
 
-static int learn_bitmap_deductions(struct solver_state *s, int w, int h)
+static bool learn_bitmap_deductions(struct solver_state *s, int w, int h)
 {
     const int sz = w * h;
     int *bm = s->bm;
     int *dsf = s->bmdsf;
     int *minsize = s->bmminsize;
     int x, y, i, j, n;
-    int learn = FALSE;
+    bool learn = false;
 
     /*
      * This function does deductions based on building up a bitmap
@@ -1058,7 +1063,7 @@ static int learn_bitmap_deductions(struct solver_state *s, int w, int h)
 		filled_square(s, w, h, i);
 		assert(s->nempty);
 		--s->nempty;
-		learn = TRUE;
+		learn = true;
 	    }
 	}
     }
@@ -1066,7 +1071,7 @@ static int learn_bitmap_deductions(struct solver_state *s, int w, int h)
     return learn;
 }
 
-static int solver(const int *orig, int w, int h, char **solution) {
+static bool solver(const int *orig, int w, int h, char **solution) {
     const int sz = w * h;
 
     struct solver_state ss;
@@ -1238,7 +1243,7 @@ static int encode_run(char *buffer, int run)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     const int w = params->w, h = params->h, sz = w * h;
     int *board = snewn(sz, int), i, j, run;
@@ -1312,7 +1317,8 @@ static game_state *new_game(midend *me, const game_params *params,
     int sz = params->w * params->h;
     int i;
 
-    state->cheated = state->completed = FALSE;
+    state->cheated = false;
+    state->completed = false;
     state->shared = snew(struct shared_state);
     state->shared->refcnt = 1;
     state->shared->params = *params; /* struct copy */
@@ -1374,8 +1380,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
  *****************************************************************************/
 
 struct game_ui {
-    int *sel; /* w*h highlighted squares, or NULL */
-    int cur_x, cur_y, cur_visible, keydragging;
+    bool *sel; /* w*h highlighted squares, or NULL */
+    int cur_x, cur_y;
+    bool cur_visible, keydragging;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1383,7 +1390,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->sel = NULL;
-    ui->cur_x = ui->cur_y = ui->cur_visible = ui->keydragging = 0;
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
+    ui->keydragging = false;
 
     return ui;
 }
@@ -1412,7 +1421,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
         sfree(ui->sel);
         ui->sel = NULL;
     }
-    ui->keydragging = FALSE;
+    ui->keydragging = false;
 }
 
 #define PREFERRED_TILE_SIZE 32
@@ -1423,7 +1432,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     struct game_params params;
     int tilesize;
-    int started;
+    bool started;
     int *v, *flags;
     int *dsf_scratch, *border_scratch;
 };
@@ -1456,25 +1465,25 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
         if (tx >= 0 && tx < w && ty >= 0 && ty < h) {
             if (!ui->sel) {
-                ui->sel = snewn(w*h, int);
-                memset(ui->sel, 0, w*h*sizeof(int));
+                ui->sel = snewn(w*h, bool);
+                memset(ui->sel, 0, w*h*sizeof(bool));
             }
             if (!state->shared->clues[w*ty+tx])
-                ui->sel[w*ty+tx] = 1;
+                ui->sel[w*ty+tx] = true;
         }
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         return UI_UPDATE;
     }
 
     if (IS_CURSOR_MOVE(button)) {
-        ui->cur_visible = 1;
-        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, 0);
+        ui->cur_visible = true;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, false);
 	if (ui->keydragging) goto select_square;
         return UI_UPDATE;
     }
     if (button == CURSOR_SELECT) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
 	ui->keydragging = !ui->keydragging;
@@ -1482,23 +1491,23 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
       select_square:
         if (!ui->sel) {
-            ui->sel = snewn(w*h, int);
-            memset(ui->sel, 0, w*h*sizeof(int));
+            ui->sel = snewn(w*h, bool);
+            memset(ui->sel, 0, w*h*sizeof(bool));
         }
 	if (!state->shared->clues[w*ui->cur_y + ui->cur_x])
-	    ui->sel[w*ui->cur_y + ui->cur_x] = 1;
+	    ui->sel[w*ui->cur_y + ui->cur_x] = true;
 	return UI_UPDATE;
     }
     if (button == CURSOR_SELECT2) {
 	if (!ui->cur_visible) {
-	    ui->cur_visible = 1;
+	    ui->cur_visible = true;
 	    return UI_UPDATE;
 	}
         if (!ui->sel) {
-            ui->sel = snewn(w*h, int);
-            memset(ui->sel, 0, w*h*sizeof(int));
+            ui->sel = snewn(w*h, bool);
+            memset(ui->sel, 0, w*h*sizeof(bool));
         }
-	ui->keydragging = FALSE;
+	ui->keydragging = false;
 	if (!state->shared->clues[w*ui->cur_y + ui->cur_x])
 	    ui->sel[w*ui->cur_y + ui->cur_x] ^= 1;
 	for (i = 0; i < w*h && !ui->sel[i]; i++);
@@ -1512,14 +1521,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (button == '\b' || button == 27) {
 	sfree(ui->sel);
 	ui->sel = NULL;
-	ui->keydragging = FALSE;
+	ui->keydragging = false;
 	return UI_UPDATE;
     }
 
     if (button < '0' || button > '9') return NULL;
     button -= '0';
     if (button > (w == 2 && h == 2 ? 3 : max(w, h))) return NULL;
-    ui->keydragging = FALSE;
+    ui->keydragging = false;
 
     for (i = 0; i < w*h; i++) {
         char buf[32];
@@ -1560,7 +1569,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         int i = 0;
         new_state = dup_game(state);
         for (++move; i < sz; ++i) new_state->board[i] = move[i] - '0';
-        new_state->cheated = TRUE;
+        new_state->cheated = true;
     } else {
         int value;
         char *endptr, *delim = strchr(move, '_');
@@ -1592,7 +1601,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         for (i = 0; i < sz && new_state->board[i] == dsf_size(dsf, i); ++i);
         sfree(dsf);
         if (i == sz)
-            new_state->completed = TRUE;
+            new_state->completed = true;
     }
 
     return new_state;
@@ -1673,7 +1682,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->tilesize = PREFERRED_TILE_SIZE;
-    ds->started = 0;
+    ds->started = false;
     ds->params = state->shared->params;
     ds->v = snewn(ds->params.w * ds->params.h, int);
     ds->flags = snewn(ds->params.w * ds->params.h, int);
@@ -1836,8 +1845,9 @@ static void draw_square(drawing *dr, game_drawstate *ds, int x, int y,
 		TILE_SIZE);
 }
 
-static void draw_grid(drawing *dr, game_drawstate *ds, const game_state *state,
-                      const game_ui *ui, int flashy, int borders, int shading)
+static void draw_grid(
+    drawing *dr, game_drawstate *ds, const game_state *state,
+    const game_ui *ui, bool flashy, bool borders, bool shading)
 {
     const int w = state->shared->params.w;
     const int h = state->shared->params.h;
@@ -1862,7 +1872,7 @@ static void draw_grid(drawing *dr, game_drawstate *ds, const game_state *state,
             int v1, s1, v2, s2;
 
             for (dx = 0; dx <= 1; dx++) {
-                int border = FALSE;
+                bool border = false;
 
                 dy = 1 - dx;
 
@@ -1885,16 +1895,16 @@ static void draw_grid(drawing *dr, game_drawstate *ds, const game_state *state,
                      * contain actual numbers...
                      */
                     if (v1 && v2)
-                        border = TRUE;
+                        border = true;
 
                     /*
                      * ... or if at least one of them is a
                      * completed or overfull omino.
                      */
                     if (v1 && s1 >= v1)
-                        border = TRUE;
+                        border = true;
                     if (v2 && s2 >= v2)
-                        border = TRUE;
+                        border = true;
                 }
 
                 if (border)
@@ -2001,7 +2011,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     const int w = state->shared->params.w;
     const int h = state->shared->params.h;
 
-    const int flashy =
+    const bool flashy =
         flashtime > 0 &&
         (flashtime <= FLASH_TIME/3 || flashtime >= FLASH_TIME*2/3);
 
@@ -2025,10 +2035,10 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
         draw_update(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER);
 
-        ds->started = TRUE;
+        ds->started = true;
     }
 
-    draw_grid(dr, ds, state, ui, flashy, TRUE, TRUE);
+    draw_grid(dr, ds, state, ui, flashy, true, true);
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -2055,9 +2065,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2076,7 +2086,8 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
 {
     const int w = state->shared->params.w;
     const int h = state->shared->params.h;
-    int c, i, borders;
+    int c, i;
+    bool borders;
 
     /* Ick: fake up `ds->tilesize' for macro expansion purposes */
     game_drawstate *ds = game_new_drawstate(dr, state);
@@ -2101,16 +2112,16 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
      * We'll draw borders between the ominoes iff the grid is not
      * pristine. So scan it to see if it is.
      */
-    borders = FALSE;
+    borders = false;
     for (i = 0; i < w*h; i++)
         if (state->board[i] && !state->shared->clues[i])
-            borders = TRUE;
+            borders = true;
 
     /*
      * Draw grid.
      */
     print_line_width(dr, TILE_SIZE / 64);
-    draw_grid(dr, ds, state, NULL, FALSE, borders, FALSE);
+    draw_grid(dr, ds, state, NULL, false, borders, false);
 
     /*
      * Clean up.
@@ -2130,15 +2141,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2155,9 +2166,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,				   /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,				   /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_NUMPAD,		       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/findloop.c b/apps/plugins/puzzles/src/findloop.c
index e6b2654cad..ffda12d716 100644
--- a/apps/plugins/puzzles/src/findloop.c
+++ b/apps/plugins/puzzles/src/findloop.c
@@ -14,7 +14,8 @@
 #include "puzzles.h"
 
 struct findloopstate {
-    int parent, child, sibling, visited;
+    int parent, child, sibling;
+    bool visited;
     int index, minindex, maxindex;
     int minreachable, maxreachable;
     int bridge;
@@ -37,7 +38,7 @@ void findloop_free_state(struct findloopstate *state)
     sfree(state);
 }
 
-int findloop_is_loop_edge(struct findloopstate *pv, int u, int v)
+bool findloop_is_loop_edge(struct findloopstate *pv, int u, int v)
 {
     /*
      * Since the algorithm is intended for finding bridges, and a
@@ -56,8 +57,8 @@ int findloop_is_loop_edge(struct findloopstate *pv, int u, int v)
     return !(pv[u].bridge == v || pv[v].bridge == u);
 }
 
-int findloop_run(struct findloopstate *pv, int nvertices,
-                 neighbour_fn_t neighbour, void *ctx)
+bool findloop_run(struct findloopstate *pv, int nvertices,
+                  neighbour_fn_t neighbour, void *ctx)
 {
     int u, v, w, root, index;
     int nbridges, nedges;
@@ -80,7 +81,7 @@ int findloop_run(struct findloopstate *pv, int nvertices,
         pv[v].parent = root;
         pv[v].child = -2;
         pv[v].sibling = -1;
-        pv[v].visited = FALSE;
+        pv[v].visited = false;
     }
     pv[root].child = -1;
     nedges = 0;
@@ -98,7 +99,7 @@ int findloop_run(struct findloopstate *pv, int nvertices,
             u = v;
             while (1) {
                 if (!pv[u].visited) {
-                    pv[u].visited = TRUE;
+                    pv[u].visited = true;
 
                     /*
                      * Enumerate the neighbours of u, and any that are
@@ -169,12 +170,12 @@ int findloop_run(struct findloopstate *pv, int nvertices,
     debug(("--- begin indexing pass\n"));
     index = 0;
     for (v = 0; v < nvertices; v++)
-        pv[v].visited = FALSE;
-    pv[root].visited = TRUE;
+        pv[v].visited = false;
+    pv[root].visited = true;
     u = pv[root].child;
     while (1) {
         if (!pv[u].visited) {
-            pv[u].visited = TRUE;
+            pv[u].visited = true;
 
             /*
              * Index this node.
@@ -239,12 +240,12 @@ int findloop_run(struct findloopstate *pv, int nvertices,
     debug(("--- begin min-max pass\n"));
     nbridges = 0;
     for (v = 0; v < nvertices; v++)
-        pv[v].visited = FALSE;
+        pv[v].visited = false;
     u = pv[root].child;
-    pv[root].visited = TRUE;
+    pv[root].visited = true;
     while (1) {
         if (!pv[u].visited) {
-            pv[u].visited = TRUE;
+            pv[u].visited = true;
 
             /*
              * Look for vertices reachable directly from u, including
diff --git a/apps/plugins/puzzles/src/flip.c b/apps/plugins/puzzles/src/flip.c
index 481c4b5ec3..29c888edf2 100644
--- a/apps/plugins/puzzles/src/flip.c
+++ b/apps/plugins/puzzles/src/flip.c
@@ -58,7 +58,8 @@ struct matrix {
 
 struct game_state {
     int w, h;
-    int moves, completed, cheated, hints_active;
+    int moves;
+    bool completed, cheated, hints_active;
     unsigned char *grid;               /* array of w*h */
     struct matrix *matrix;
 };
@@ -82,13 +83,13 @@ static const struct game_params flip_presets[] = {
     {5, 5, RANDOM},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(flip_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = flip_presets[i];
@@ -98,7 +99,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -131,7 +132,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -178,7 +179,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
         return "Width and height must both be greater than zero";
@@ -344,7 +345,7 @@ static void addneighbours(tree234 *t, int w, int h, int cx, int cy,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w * h;
     int i, j;
@@ -619,9 +620,9 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->w = w;
     state->h = h;
-    state->completed = FALSE;
-    state->cheated = FALSE;
-    state->hints_active = FALSE;
+    state->completed = false;
+    state->cheated = false;
+    state->hints_active = false;
     state->moves = 0;
     state->matrix = snew(struct matrix);
     state->matrix->refcount = 1;
@@ -850,9 +851,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 #define RIGHT 1
@@ -896,13 +897,15 @@ static char *game_text_format(const game_state *state)
 #undef DOWN
 
 struct game_ui {
-    int cx, cy, cdraw;
+    int cx, cy;
+    bool cdraw;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
-    ui->cx = ui->cy = ui->cdraw = 0;
+    ui->cx = ui->cy = 0;
+    ui->cdraw = false;
     return ui;
 }
 
@@ -926,7 +929,8 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int w, h, started;
+    int w, h;
+    bool started;
     unsigned char *tiles;
     int tilesize;
 };
@@ -942,10 +946,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         int tx, ty;
         if (button == LEFT_BUTTON) {
             tx = FROMCOORD(x), ty = FROMCOORD(y);
-            ui->cdraw = 0;
+            ui->cdraw = false;
         } else {
             tx = ui->cx; ty = ui->cy;
-            ui->cdraw = 1;
+            ui->cdraw = true;
         }
         nullret = UI_UPDATE;
 
@@ -955,10 +959,11 @@ static char *interpret_move(const game_state *state, game_ui *ui,
              * will have at least one square do nothing whatsoever.
              * If so, we avoid encoding a move at all.
              */
-            int i = ty*w+tx, j, makemove = FALSE;
+            int i = ty*w+tx, j;
+            bool makemove = false;
             for (j = 0; j < wh; j++) {
                 if (state->matrix->matrix[i*wh+j])
-                    makemove = TRUE;
+                    makemove = true;
             }
             if (makemove) {
                 sprintf(buf, "M%d,%d", tx, ty);
@@ -980,7 +985,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         ui->cx += dx; ui->cy += dy;
         ui->cx = min(max(ui->cx, 0), state->w - 1);
         ui->cy = min(max(ui->cy, 0), state->h - 1);
-        ui->cdraw = 1;
+        ui->cdraw = true;
         nullret = UI_UPDATE;
     }
 
@@ -997,8 +1002,8 @@ static game_state *execute_move(const game_state *from, const char *move)
 	int i;
 
 	ret = dup_game(from);
-	ret->hints_active = TRUE;
-	ret->cheated = TRUE;
+	ret->hints_active = true;
+	ret->cheated = true;
 	for (i = 0; i < wh; i++) {
 	    ret->grid[i] &= ~2;
 	    if (move[i+1] != '0')
@@ -1008,7 +1013,8 @@ static game_state *execute_move(const game_state *from, const char *move)
     } else if (move[0] == 'M' &&
 	       sscanf(move+1, "%d,%d", &x, &y) == 2 &&
 	x >= 0 && x < w && y >= 0 && y < h) {
-	int i, j, done;
+	int i, j;
+        bool done;
 
 	ret = dup_game(from);
 
@@ -1017,16 +1023,16 @@ static game_state *execute_move(const game_state *from, const char *move)
 
 	i = y * w + x;
 
-	done = TRUE;
+	done = true;
 	for (j = 0; j < wh; j++) {
 	    ret->grid[j] ^= ret->matrix->matrix[i*wh+j];
 	    if (ret->grid[j] & 1)
-		done = FALSE;
+		done = false;
 	}
 	ret->grid[i] ^= 2;	       /* toggle hint */
 	if (done) {
-	    ret->completed = TRUE;
-	    ret->hints_active = FALSE;
+	    ret->completed = true;
+	    ret->hints_active = false;
 	}
 
 	return ret;
@@ -1094,7 +1100,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->tiles = snewn(ds->w*ds->h, unsigned char);
@@ -1112,7 +1118,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void draw_tile(drawing *dr, game_drawstate *ds, const game_state *state,
-                      int x, int y, int tile, int anim, float animtime)
+                      int x, int y, int tile, bool anim, float animtime)
 {
     int w = ds->w, h = ds->h, wh = w * h;
     int bx = x * TILE_SIZE + BORDER, by = y * TILE_SIZE + BORDER;
@@ -1214,7 +1220,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         draw_update(dr, 0, 0, TILE_SIZE * w + 2 * BORDER,
                     TILE_SIZE * h + 2 * BORDER);
 
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     if (flashtime)
@@ -1289,9 +1295,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1314,15 +1320,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1339,8 +1345,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/flood.c b/apps/plugins/puzzles/src/flood.c
index 840ff64a17..67c3225be4 100644
--- a/apps/plugins/puzzles/src/flood.c
+++ b/apps/plugins/puzzles/src/flood.c
@@ -63,9 +63,9 @@ typedef struct soln {
 struct game_state {
     int w, h, colours;
     int moves, movelimit;
-    int complete;
+    bool complete;
     char *grid;
-    int cheated;
+    bool cheated;
     int solnpos;
     soln *soln;
 };
@@ -101,18 +101,18 @@ static const struct {
     {{12, 12, 4, 0}, "12x12, 4 colours"},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
 
     if (i < 0 || i >= lenof(flood_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = flood_presets[i].preset;
     *name = dupstr(flood_presets[i].name);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -150,7 +150,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -205,7 +205,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w * params->h < 2)
         return "Grid must contain at least two squares";
@@ -443,16 +443,16 @@ static void fill(int w, int h, char *grid, int x0, int y0, char newcolour,
 /*
  * Detect a completed grid.
  */
-static int completed(int w, int h, char *grid)
+static bool completed(int w, int h, char *grid)
 {
     int wh = w*h;
     int i;
 
     for (i = 1; i < wh; i++)
         if (grid[i] != grid[0])
-            return FALSE;
+            return false;
 
-    return TRUE;
+    return true;
 }
 
 /*
@@ -542,7 +542,7 @@ static char choosemove(int w, int h, char *grid, int x0, int y0,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h;
     int i, moves;
@@ -644,8 +644,8 @@ static game_state *new_game(midend *me, const game_params *params,
     desc++;
 
     state->movelimit = atoi(desc);
-    state->complete = FALSE;
-    state->cheated = FALSE;
+    state->complete = false;
+    state->cheated = false;
     state->solnpos = 0;
     state->soln = NULL;
 
@@ -731,9 +731,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -762,7 +762,7 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int cursor_visible;
+    bool cursor_visible;
     int cx, cy;
     enum { VICTORY, DEFEAT } flash_type;
 };
@@ -770,7 +770,7 @@ struct game_ui {
 static game_ui *new_ui(const game_state *state)
 {
     struct game_ui *ui = snew(struct game_ui);
-    ui->cursor_visible = FALSE;
+    ui->cursor_visible = false;
     ui->cx = FILLX;
     ui->cy = FILLY;
     return ui;
@@ -796,7 +796,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int tilesize;
     int *grid;
 };
@@ -822,22 +822,22 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (button == LEFT_BUTTON) {
 	tx = FROMCOORD(x);
         ty = FROMCOORD(y);
-        ui->cursor_visible = FALSE;
+        ui->cursor_visible = false;
     } else if (button == CURSOR_LEFT && ui->cx > 0) {
         ui->cx--;
-        ui->cursor_visible = TRUE;
+        ui->cursor_visible = true;
         return UI_UPDATE;
     } else if (button == CURSOR_RIGHT && ui->cx+1 < w) {
         ui->cx++;
-        ui->cursor_visible = TRUE;
+        ui->cursor_visible = true;
         return UI_UPDATE;
     } else if (button == CURSOR_UP && ui->cy > 0) {
         ui->cy--;
-        ui->cursor_visible = TRUE;
+        ui->cursor_visible = true;
         return UI_UPDATE;
     } else if (button == CURSOR_DOWN && ui->cy+1 < h) {
         ui->cy++;
-        ui->cursor_visible = TRUE;
+        ui->cursor_visible = true;
         return UI_UPDATE;
     } else if (button == CURSOR_SELECT) {
         tx = ui->cx;
@@ -930,7 +930,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         }
 
 	ret = dup_game(state);
-	ret->cheated = TRUE;
+	ret->cheated = true;
 	if (ret->soln && --ret->soln->refcount == 0) {
 	    sfree(ret->soln->moves);
 	    sfree(ret->soln);
@@ -1035,7 +1035,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int w = state->w, h = state->h, wh = w*h;
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->tilesize = 0;
     ds->grid = snewn(wh, int);
     for (i = 0; i < wh; i++)
@@ -1160,7 +1160,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                   TILESIZE * w + 2 * SEP_WIDTH, TILESIZE * h + 2 * SEP_WIDTH,
                   COL_SEPARATOR);
 
-	ds->started = 1;
+	ds->started = true;
     }
 
     if (flashtime > 0) {
@@ -1312,9 +1312,9 @@ static float game_flash_length(const game_state *oldstate,
     return 0.0F;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1337,15 +1337,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1362,8 +1362,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/galaxies.c b/apps/plugins/puzzles/src/galaxies.c
index 11efd34d44..0cc3198ae0 100644
--- a/apps/plugins/puzzles/src/galaxies.c
+++ b/apps/plugins/puzzles/src/galaxies.c
@@ -49,7 +49,7 @@
 #ifdef DEBUGGING
 #define solvep debug
 #else
-int solver_show_working;
+static bool solver_show_working;
 #define solvep(x) do { if (solver_show_working) { printf x; } } while(0)
 #endif
 
@@ -139,7 +139,7 @@ struct game_state {
     int w, h;           /* size from params */
     int sx, sy;         /* allocated size, (2x-1)*(2y-1) */
     space *grid;
-    int completed, used_solve;
+    bool completed, used_solve;
     int ndots;
     space **dots;
 
@@ -148,7 +148,7 @@ struct game_state {
                            or -1 if stale. */
 };
 
-static int check_complete(const game_state *state, int *dsf, int *colours);
+static bool check_complete(const game_state *state, int *dsf, int *colours);
 static int solver_state(game_state *state, int maxdiff);
 static int solver_obvious(game_state *state);
 static int solver_obvious_dot(game_state *state, space *dot);
@@ -171,13 +171,13 @@ static const game_params galaxies_presets[] = {
     { 15, 15, DIFF_NORMAL },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(galaxies_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = galaxies_presets[i]; /* structure copy */
@@ -187,7 +187,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     if (name) *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static game_params *default_params(void)
@@ -229,7 +229,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%d", params->w, params->h);
@@ -277,7 +277,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->h < 3)
         return "Width and height must both be at least 3";
@@ -384,9 +384,9 @@ static space *sp2dot(const game_state *state, int x, int y)
 
 #define IS_VERTICAL_EDGE(x) ((x % 2) == 0)
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -464,7 +464,8 @@ typedef int (*space_cb)(game_state *state, space *sp, void *ctx);
 static int foreach_sub(game_state *state, space_cb cb, unsigned int f,
                        void *ctx, int startx, int starty)
 {
-    int x, y, progress = 0, impossible = 0, ret;
+    int x, y, ret;
+    bool progress = false, impossible = false;
     space *sp;
 
     for (y = starty; y < state->sy; y += 2) {
@@ -473,14 +474,14 @@ static int foreach_sub(game_state *state, space_cb cb, unsigned int f,
             ret = cb(state, sp, ctx);
             if (ret == -1) {
                 if (f & IMPOSSIBLE_QUITS) return -1;
-                impossible = -1;
+                impossible = true;
             } else if (ret == 1) {
-                progress = 1;
+                progress = true;
             }
             sp += 2;
         }
     }
-    return impossible ? -1 : progress;
+    return impossible ? -1 : progress ? 1 : 0;
 }
 
 static int foreach_tile(game_state *state, space_cb cb, unsigned int f,
@@ -577,15 +578,15 @@ static space *tile_opposite(const game_state *state, const space *sp)
     return space_opposite_dot(state, sp, dot);
 }
 
-static int dotfortile(game_state *state, space *tile, space *dot)
+static bool dotfortile(game_state *state, space *tile, space *dot)
 {
     space *tile_opp = space_opposite_dot(state, tile, dot);
 
-    if (!tile_opp) return 0; /* opposite would be off grid */
+    if (!tile_opp) return false; /* opposite would be off grid */
     if (tile_opp->flags & F_TILE_ASSOC &&
             (tile_opp->dotx != dot->x || tile_opp->doty != dot->y))
-            return 0; /* opposite already associated with diff. dot */
-    return 1;
+            return false; /* opposite already associated with diff. dot */
+    return true;
 }
 
 static void adjacencies(game_state *state, space *sp, space **a1s, space **a2s)
@@ -614,33 +615,34 @@ static void adjacencies(game_state *state, space *sp, space **a1s, space **a2s)
     }
 }
 
-static int outline_tile_fordot(game_state *state, space *tile, int mark)
+static bool outline_tile_fordot(game_state *state, space *tile, bool mark)
 {
     space *tadj[4], *eadj[4];
-    int i, didsth = 0, edge, same;
+    int i;
+    bool didsth = false, edge, same;
 
     assert(tile->type == s_tile);
     adjacencies(state, tile, eadj, tadj);
     for (i = 0; i < 4; i++) {
         if (!eadj[i]) continue;
 
-        edge = (eadj[i]->flags & F_EDGE_SET) ? 1 : 0;
+        edge = eadj[i]->flags & F_EDGE_SET;
         if (tadj[i]) {
             if (!(tile->flags & F_TILE_ASSOC))
-                same = (tadj[i]->flags & F_TILE_ASSOC) ? 0 : 1;
+                same = !(tadj[i]->flags & F_TILE_ASSOC);
             else
                 same = ((tadj[i]->flags & F_TILE_ASSOC) &&
                     tile->dotx == tadj[i]->dotx &&
-                    tile->doty == tadj[i]->doty) ? 1 : 0;
+                    tile->doty == tadj[i]->doty);
         } else
-            same = 0;
+            same = false;
 
         if (!edge && !same) {
             if (mark) eadj[i]->flags |= F_EDGE_SET;
-            didsth = 1;
+            didsth = true;
         } else if (edge && same) {
             if (mark) eadj[i]->flags &= ~F_EDGE_SET;
-            didsth = 1;
+            didsth = true;
         }
     }
     return didsth;
@@ -664,7 +666,7 @@ static void tiles_from_edge(game_state *state, space *sp, space **ts)
 /* Returns a move string for use by 'solve', including the initial
  * 'S' if issolve is true. */
 static char *diff_game(const game_state *src, const game_state *dest,
-                       int issolve)
+                       bool issolve)
 {
     int movelen = 0, movesize = 256, x, y, len;
     char *move = snewn(movesize, char), buf[80];
@@ -725,9 +727,9 @@ static char *diff_game(const game_state *src, const game_state *dest,
     return move;
 }
 
-/* Returns 1 if a dot here would not be too close to any other dots
+/* Returns true if a dot here would not be too close to any other dots
  * (and would avoid other game furniture). */
-static int dot_is_possible(game_state *state, space *sp, int allow_assoc)
+static bool dot_is_possible(game_state *state, space *sp, bool allow_assoc)
 {
     int bx = 0, by = 0, dx, dy;
     space *adj;
@@ -766,28 +768,28 @@ static int dot_is_possible(game_state *state, space *sp, int allow_assoc)
 		    if (col < 0)
 			col = c;
 		    if (c != col)
-			return 0;          /* colour mismatch */
+			return false;          /* colour mismatch */
 		}
 	    }
 #endif
 
 	    if (!allow_assoc && (adj->flags & F_TILE_ASSOC))
-		return 0;
+		return false;
 
             if (dx != 0 || dy != 0) {
                 /* Other than our own square, no dots nearby. */
                 if (adj->flags & (F_DOT))
-                    return 0;
+                    return false;
             }
 
             /* We don't want edges within our rectangle
              * (but don't care about edges on the edge) */
             if (abs(dx) < bx && abs(dy) < by &&
                 adj->flags & F_EDGE_SET)
-                return 0;
+                return false;
         }
     }
-    return 1;
+    return true;
 }
 
 /* ----------------------------------------------------------
@@ -805,7 +807,8 @@ static game_state *blank_game(int w, int h)
     state->sx = (w*2)+1;
     state->sy = (h*2)+1;
     state->grid = snewn(state->sx * state->sy, space);
-    state->completed = state->used_solve = 0;
+    state->completed = false;
+    state->used_solve = false;
 
     for (x = 0; x < state->sx; x++) {
         for (y = 0; y < state->sy; y++) {
@@ -851,7 +854,7 @@ static void game_update_dots(game_state *state)
     }
 }
 
-static void clear_game(game_state *state, int cleardots)
+static void clear_game(game_state *state, bool cleardots)
 {
     int x, y;
 
@@ -1004,8 +1007,8 @@ static int movedot_cb(game_state *state, space *tile, void *vctx)
  * extra spaces (by checking for empty spaces on the far side), and then
  * see if we can move the dot to shift the CoG to include the new spaces.
  */
-static int dot_expand_or_move(game_state *state, space *dot,
-                              space **toadd, int nadd)
+static bool dot_expand_or_move(game_state *state, space *dot,
+                               space **toadd, int nadd)
 {
     space *tileopp;
     int i, ret, nnew, cx, cy;
@@ -1027,7 +1030,7 @@ static int dot_expand_or_move(game_state *state, space *dot,
 	for (i = 0; i < nadd; i++) {
 	    if (!(picture[(toadd[i]->y/2) * state->w + (toadd[i]->x/2)]) ^
 		!(dot->flags & F_DOT_BLACK))
-		return 0;
+		return false;
 	}
     }
 #endif
@@ -1061,7 +1064,7 @@ static int dot_expand_or_move(game_state *state, space *dot,
                dot->x, dot->y));
         dbg_state(state);
     }
-    return 1;
+    return true;
 
 noexpand:
     /* Otherwise, try to move dot so as to encompass given spaces: */
@@ -1077,7 +1080,7 @@ noexpand:
     if ((cx % nnew) != 0 || (cy % nnew) != 0) {
         debug(("Unable to move dot %d,%d, CoG not whole number.\n",
                dot->x, dot->y));
-        return 0;
+        return false;
     }
     cx /= nnew; cy /= nnew;
 
@@ -1090,7 +1093,7 @@ noexpand:
     if (ret == -1) {
         debug(("Unable to move dot %d,%d, new dot not symmetrical.\n",
                dot->x, dot->y));
-        return 0;
+        return false;
     }
     /* Also check whether all spaces we're adding would have a good
      * opposite wrt the new dot. */
@@ -1103,13 +1106,13 @@ noexpand:
         if (!tileopp) {
             debug(("Unable to move dot %d,%d, new dot not symmetrical.\n",
                dot->x, dot->y));
-            return 0;
+            return false;
         }
 #ifdef STANDALONE_PICTURE_GENERATOR
 	if (picture) {
 	    if (!(picture[(tileopp->y/2) * state->w + (tileopp->x/2)]) ^
 		!(dot->flags & F_DOT_BLACK))
-		return 0;
+		return false;
 	}
 #endif
     }
@@ -1142,7 +1145,7 @@ noexpand:
     assert(ret == 1);
     dbg_state(state);
 
-    return 1;
+    return true;
 }
 
 /* Hard-code to a max. of 2x2 squares, for speed (less malloc) */
@@ -1151,13 +1154,13 @@ noexpand:
 
 #define MAX_TILE_PERC 20
 
-static int generate_try_block(game_state *state, random_state *rs,
-                              int x1, int y1, int x2, int y2)
+static bool generate_try_block(game_state *state, random_state *rs,
+                               int x1, int y1, int x2, int y2)
 {
     int x, y, nadd = 0, nout = 0, i, maxsz;
     space *sp, *toadd[MAX_TOADD], *outside[MAX_OUTSIDE], *dot;
 
-    if (!INGRID(state, x1, y1) || !INGRID(state, x2, y2)) return 0;
+    if (!INGRID(state, x1, y1) || !INGRID(state, x2, y2)) return false;
 
     /* We limit the maximum size of tiles to be ~2*sqrt(area); so,
      * a 5x5 grid shouldn't have anything >10 tiles, a 20x20 grid
@@ -1172,7 +1175,7 @@ static int generate_try_block(game_state *state, random_state *rs,
             assert(nadd < MAX_TOADD);
             sp = &SPACE(state, x, y);
             assert(sp->type == s_tile);
-            if (sp->flags & F_TILE_ASSOC) return 0;
+            if (sp->flags & F_TILE_ASSOC) return false;
             toadd[nadd++] = sp;
         }
     }
@@ -1202,9 +1205,9 @@ static int generate_try_block(game_state *state, random_state *rs,
                    dot->x, dot->y, dot->nassoc));
             continue;
         }
-        if (dot_expand_or_move(state, dot, toadd, nadd)) return 1;
+        if (dot_expand_or_move(state, dot, toadd, nadd)) return true;
     }
-    return 0;
+    return false;
 }
 
 #ifdef STANDALONE_SOLVER
@@ -1258,7 +1261,7 @@ static void generate_pass(game_state *state, random_state *rs, int *scratch,
 
         /* If we've got here we might want to put a dot down. Check
          * if we can, and add one if so. */
-        if (dot_is_possible(state, sp, 0)) {
+        if (dot_is_possible(state, sp, false)) {
             add_dot(sp);
 #ifdef STANDALONE_PICTURE_GENERATOR
 	    if (picture) {
@@ -1277,19 +1280,20 @@ static void generate_pass(game_state *state, random_state *rs, int *scratch,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h), *copy;
     char *desc;
     int *scratch, sz = state->sx*state->sy, i;
-    int diff, ntries = 0, cc;
+    int diff, ntries = 0;
+    bool cc;
 
     /* Random list of squares to try and process, one-by-one. */
     scratch = snewn(sz, int);
     for (i = 0; i < sz; i++) scratch[i] = i;
 
 generate:
-    clear_game(state, 1);
+    clear_game(state, true);
     ntries++;
 
     /* generate_pass(state, rs, scratch, 10, GP_DOTS); */
@@ -1310,12 +1314,12 @@ generate:
 
     for (i = 0; i < state->sx*state->sy; i++)
         if (state->grid[i].type == s_tile)
-            outline_tile_fordot(state, &state->grid[i], TRUE);
+            outline_tile_fordot(state, &state->grid[i], true);
     cc = check_complete(state, NULL, NULL);
     assert(cc);
 
     copy = dup_game(state);
-    clear_game(copy, 0);
+    clear_game(copy, false);
     dbg_state(copy);
     diff = solver_state(copy, params->diff);
     free_game(copy);
@@ -1363,7 +1367,7 @@ generate:
 	for (i = 0; i < nposns; i++) {
 	    int x, y, x0, y0, x1, y1, cx, cy, cn, cx0, cy0, cx1, cy1, tx, ty;
 	    space *s0, *s1, *ts, *d0, *d1, *dn;
-	    int ok;
+	    bool ok;
 
 	    /* Coordinates of edge space */
 	    x = posns[i] % state->sx;
@@ -1412,14 +1416,14 @@ generate:
 	    cy0 = ((cy+1) & ~1) - 1;
 	    cx1 = 2*cx-cx0;	       /* and reflect about cx to get cx1 */
 	    cy1 = 2*cy-cy0;
-	    ok = TRUE;
+	    ok = true;
 	    for (ty = cy0; ty <= cy1; ty += 2)
 		for (tx = cx0; tx <= cx1; tx += 2) {
 		    ts = &SPACE(state, tx, ty);
 		    assert(ts->type == s_tile);
 		    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
 			(ts->dotx != d1->x || ts->doty != d1->y))
-			ok = FALSE;
+			ok = false;
 		}
 	    if (!ok)
 		continue;
@@ -1441,13 +1445,13 @@ generate:
 		    tx1 = 2*cx-tx;
 		    ty1 = 2*cy-ty;
 		    if (!INGRID(state, tx1, ty1)) {
-			ok = FALSE;
+			ok = false;
 			break;
 		    }
 		    ts = &SPACE(state, cx+cx-tx, cy+cy-ty);
 		    if ((ts->dotx != d0->x || ts->doty != d0->y) &&
 			(ts->dotx != d1->x || ts->doty != d1->y)) {
-			ok = FALSE;
+			ok = false;
 			break;
 		    }
 		}
@@ -1482,7 +1486,7 @@ generate:
 	    }
 
 	    copy = dup_game(state);
-	    clear_game(copy, 0);
+	    clear_game(copy, false);
 	    dbg_state(copy);
 	    newdiff = solver_state(copy, params->diff);
 	    free_game(copy);
@@ -1511,7 +1515,7 @@ generate:
     return desc;
 }
 
-static int dots_too_close(game_state *state)
+static bool dots_too_close(game_state *state)
 {
     /* Quick-and-dirty check, using half the solver:
      * solver_obvious will only fail if the dots are
@@ -1520,7 +1524,7 @@ static int dots_too_close(game_state *state)
     game_state *tmp = dup_game(state);
     int ret = solver_obvious(tmp);
     free_game(tmp);
-    return (ret == -1) ? 1 : 0;
+    return ret == -1;
 }
 
 static game_state *load_game(const game_params *params, const char *desc,
@@ -1601,7 +1605,7 @@ static game_state *new_game(midend *me, const game_params *params,
  * Solver and all its little wizards.
  */
 
-int solver_recurse_depth;
+static int solver_recurse_depth;
 
 typedef struct solver_ctx {
     game_state *state;
@@ -1919,13 +1923,13 @@ static int solver_spaces_oneposs_cb(game_state *state, space *tile, void *ctx)
  *
  */
 
-/* Returns 1 if this tile is either already associated with this dot,
+/* Returns true if this tile is either already associated with this dot,
  * or blank. */
-static int solver_expand_checkdot(space *tile, space *dot)
+static bool solver_expand_checkdot(space *tile, space *dot)
 {
-    if (!(tile->flags & F_TILE_ASSOC)) return 1;
-    if (tile->dotx == dot->x && tile->doty == dot->y) return 1;
-    return 0;
+    if (!(tile->flags & F_TILE_ASSOC)) return true;
+    if (tile->dotx == dot->x && tile->doty == dot->y) return true;
+    return false;
 }
 
 static void solver_expand_fromdot(game_state *state, space *dot, solver_ctx *sctx)
@@ -2287,7 +2291,7 @@ solved:
      */
     for (i = 0; i < tosolve->sx*tosolve->sy; i++)
         tosolve->grid[i].flags &= ~F_TILE_ASSOC;
-    ret = diff_game(currstate, tosolve, 1);
+    ret = diff_game(currstate, tosolve, true);
     free_game(tosolve);
     return ret;
 }
@@ -2298,19 +2302,20 @@ solved:
  */
 
 struct game_ui {
-    int dragging;
+    bool dragging;
     int dx, dy;         /* pixel coords of drag pos. */
     int dotx, doty;     /* grid coords of dot we're dragging from. */
     int srcx, srcy;     /* grid coords of drag start */
-    int cur_x, cur_y, cur_visible;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
-    ui->dragging = FALSE;
+    ui->dragging = false;
     ui->cur_x = ui->cur_y = 1;
-    ui->cur_visible = 0;
+    ui->cur_visible = false;
     return ui;
 }
 
@@ -2351,7 +2356,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 #define CURSOR_SIZE DOT_SIZE
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h;
     int tilesize;
     unsigned long *grid;
@@ -2359,11 +2364,13 @@ struct game_drawstate {
     blitter *bl;
     blitter *blmirror;
 
-    int dragging, dragx, dragy;
+    bool dragging;
+    int dragx, dragy;
 
     int *colour_scratch;
 
-    int cx, cy, cur_visible;
+    int cx, cy;
+    bool cur_visible;
     blitter *cur_bl;
 };
 
@@ -2474,13 +2481,13 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         char *ret;
         game_state *tmp = dup_game(state);
         solver_obvious(tmp);
-        ret = diff_game(state, tmp, 0);
+        ret = diff_game(state, tmp, false);
         free_game(tmp);
         return ret;
     }
 
     if (button == LEFT_BUTTON) {
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         coord_round_to_edge(FROMCOORD((float)x), FROMCOORD((float)y),
                             &px, &py);
 
@@ -2495,7 +2502,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     } else if (button == RIGHT_BUTTON) {
         int px1, py1;
 
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 
         px = (int)(2*FROMCOORD((float)x) + 0.5);
         py = (int)(2*FROMCOORD((float)y) + 0.5);
@@ -2545,7 +2552,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
          * Now, if we've managed to find a dot, begin a drag.
          */
         if (dot) {
-            ui->dragging = TRUE;
+            ui->dragging = true;
             ui->dx = x;
             ui->dy = y;
             ui->dotx = dot->x;
@@ -2558,7 +2565,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         ui->dy = y;
         return UI_UPDATE;
     } else if (button == RIGHT_RELEASE && ui->dragging) {
-        ui->dragging = FALSE;
+        ui->dragging = false;
 
         /*
          * Drags are always targeted at a single square.
@@ -2600,10 +2607,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	else
 	    return UI_UPDATE;
     } else if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->sx-1, state->sy-1, 0);
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->sx-1, state->sy-1, false);
         if (ui->cur_x < 1) ui->cur_x = 1;
         if (ui->cur_y < 1) ui->cur_y = 1;
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
         if (ui->dragging) {
             ui->dx = SCOORD(ui->cur_x);
             ui->dy = SCOORD(ui->cur_y);
@@ -2611,12 +2618,12 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return UI_UPDATE;
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         sp = &SPACE(state, ui->cur_x, ui->cur_y);
         if (ui->dragging) {
-            ui->dragging = FALSE;
+            ui->dragging = false;
 
             if ((ui->srcx != ui->dotx || ui->srcy != ui->doty) &&
                 SPACE(state, ui->srcx, ui->srcy).flags & F_TILE_ASSOC) {
@@ -2629,7 +2636,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             }
             return dupstr(buf);
         } else if (sp->flags & F_DOT) {
-            ui->dragging = TRUE;
+            ui->dragging = true;
             ui->dx = SCOORD(ui->cur_x);
             ui->dy = SCOORD(ui->cur_y);
             ui->dotx = ui->srcx = ui->cur_x;
@@ -2637,7 +2644,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             return UI_UPDATE;
         } else if (sp->flags & F_TILE_ASSOC) {
             assert(sp->type == s_tile);
-            ui->dragging = TRUE;
+            ui->dragging = true;
             ui->dx = SCOORD(ui->cur_x);
             ui->dy = SCOORD(ui->cur_y);
             ui->dotx = sp->dotx;
@@ -2655,24 +2662,26 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 }
 #endif
 
-static int check_complete(const game_state *state, int *dsf, int *colours)
+static bool check_complete(const game_state *state, int *dsf, int *colours)
 {
     int w = state->w, h = state->h;
-    int x, y, i, ret;
+    int x, y, i;
+    bool ret;
 
-    int free_dsf;
+    bool free_dsf;
     struct sqdata {
         int minx, miny, maxx, maxy;
         int cx, cy;
-        int valid, colour;
+        bool valid;
+        int colour;
     } *sqdata;
 
     if (!dsf) {
 	dsf = snew_dsf(w*h);
-	free_dsf = TRUE;
+	free_dsf = true;
     } else {
 	dsf_init(dsf, w*h);
-	free_dsf = FALSE;
+	free_dsf = false;
     }
 
     /*
@@ -2711,7 +2720,7 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
         sqdata[i].minx = w+1;
         sqdata[i].miny = h+1;
         sqdata[i].maxx = sqdata[i].maxy = -1;
-        sqdata[i].valid = FALSE;
+        sqdata[i].valid = false;
     }
     for (y = 0; y < h; y++)
         for (x = 0; x < w; x++) {
@@ -2724,7 +2733,7 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
                 sqdata[i].miny = y;
             if (sqdata[i].maxy < y)
                 sqdata[i].maxy = y;
-            sqdata[i].valid = TRUE;
+            sqdata[i].valid = true;
         }
 
     /*
@@ -2738,12 +2747,12 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
             cx = sqdata[i].cx = sqdata[i].minx + sqdata[i].maxx + 1;
             cy = sqdata[i].cy = sqdata[i].miny + sqdata[i].maxy + 1;
             if (!(SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT))
-                sqdata[i].valid = FALSE;   /* no dot at centre of symmetry */
+                sqdata[i].valid = false;   /* no dot at centre of symmetry */
             if (dsf_canonify(dsf, (cy-1)/2*w+(cx-1)/2) != i ||
                 dsf_canonify(dsf, (cy)/2*w+(cx-1)/2) != i ||
                 dsf_canonify(dsf, (cy-1)/2*w+(cx)/2) != i ||
                 dsf_canonify(dsf, (cy)/2*w+(cx)/2) != i)
-                sqdata[i].valid = FALSE;   /* dot at cx,cy isn't ours */
+                sqdata[i].valid = false;   /* dot at cx,cy isn't ours */
             if (SPACE(state, sqdata[i].cx, sqdata[i].cy).flags & F_DOT_BLACK)
                 sqdata[i].colour = 2;
             else
@@ -2773,7 +2782,7 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
                     for (cx = (x-1) >> 1; cx <= x >> 1; cx++) {
                         i = dsf_canonify(dsf, cy*w+cx);
                         if (x != sqdata[i].cx || y != sqdata[i].cy)
-                            sqdata[i].valid = FALSE;
+                            sqdata[i].valid = false;
                     }
             }
 
@@ -2787,7 +2796,7 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
                 assert((cx1==cx2) ^ (cy1==cy2));
                 i = dsf_canonify(dsf, cy1*w+cx1);
                 if (i == dsf_canonify(dsf, cy2*w+cx2))
-                    sqdata[i].valid = FALSE;
+                    sqdata[i].valid = false;
             }
         }
 
@@ -2806,7 +2815,7 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
             x2 = sqdata[i].cx - 1 - x;
             y2 = sqdata[i].cy - 1 - y;
             if (i != dsf_canonify(dsf, y2*w+x2))
-                sqdata[i].valid = FALSE;
+                sqdata[i].valid = false;
         }
 
     /*
@@ -2816,10 +2825,10 @@ static int check_complete(const game_state *state, int *dsf, int *colours)
      * true/false value depending on whether _every_ square in the
      * grid is part of a valid component.
      */
-    ret = TRUE;
+    ret = true;
     for (i = 0; i < w*h; i++) {
         int ci = dsf_canonify(dsf, i);
-        int thisok = sqdata[ci].valid;
+        bool thisok = sqdata[ci].valid;
         if (colours)
             colours[i] = thisok ? sqdata[ci].colour : 0;
         ret = ret && thisok;
@@ -2837,7 +2846,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     int x, y, ax, ay, n, dx, dy;
     game_state *ret = dup_game(state);
     space *sp, *dot;
-    int currently_solving = FALSE;
+    bool currently_solving = false;
 
     debug(("%s\n", move));
 
@@ -2924,12 +2933,12 @@ static game_state *execute_move(const game_state *state, const char *move)
 #ifdef EDITOR
         } else if (c == 'C') {
             move++;
-            clear_game(ret, 1);
+            clear_game(ret, true);
 #endif
         } else if (c == 'S') {
             move++;
-	    ret->used_solve = 1;
-            currently_solving = TRUE;
+	    ret->used_solve = true;
+            currently_solving = true;
         } else
             goto badmove;
 
@@ -2939,7 +2948,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             goto badmove;
     }
     if (check_complete(ret, NULL, NULL))
-        ret->completed = 1;
+        ret->completed = true;
     return ret;
 
 badmove:
@@ -3051,7 +3060,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = 0;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
 
@@ -3063,14 +3072,14 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 
     ds->bl = NULL;
     ds->blmirror = NULL;
-    ds->dragging = FALSE;
+    ds->dragging = false;
     ds->dragx = ds->dragy = 0;
 
     ds->colour_scratch = snewn(ds->w * ds->h, int);
 
     ds->cur_bl = NULL;
     ds->cx = ds->cy = 0;
-    ds->cur_visible = 0;
+    ds->cur_visible = false;
 
     return ds;
 }
@@ -3221,7 +3230,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         float animtime, float flashtime)
 {
     int w = ds->w, h = ds->h;
-    int x, y, flashing = FALSE;
+    int x, y;
+    bool flashing = false;
     int oppx, oppy;
 
     if (flashtime > 0) {
@@ -3240,13 +3250,13 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         draw_update(dr, ds->dragx, ds->dragy, TILE_SIZE, TILE_SIZE);
         blitter_load(dr, ds->blmirror, oppx, oppy);
         draw_update(dr, oppx, oppy, TILE_SIZE, TILE_SIZE);
-        ds->dragging = FALSE;
+        ds->dragging = false;
     }
     if (ds->cur_visible) {
         assert(ds->cur_bl);
         blitter_load(dr, ds->cur_bl, ds->cx, ds->cy);
         draw_update(dr, ds->cx, ds->cy, CURSOR_SIZE*2+1, CURSOR_SIZE*2+1);
-        ds->cur_visible = FALSE;
+        ds->cur_visible = false;
     }
 
     if (!ds->started) {
@@ -3255,7 +3265,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                   w*TILE_SIZE + EDGE_THICKNESS*2 - 1,
                   h*TILE_SIZE + EDGE_THICKNESS*2 - 1, COL_EDGE);
         draw_update(dr, 0, 0, DRAW_WIDTH, DRAW_HEIGHT);
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     check_complete(state, NULL, ds->colour_scratch);
@@ -3377,7 +3387,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      */
     if (ui->cur_visible) {
         space *sp = &SPACE(state, ui->cur_x, ui->cur_y);
-        ds->cur_visible = TRUE;
+        ds->cur_visible = true;
         ds->cx = SCOORD(ui->cur_x) - CURSOR_SIZE;
         ds->cy = SCOORD(ui->cur_y) - CURSOR_SIZE;
         blitter_save(dr, ds->cur_bl, ds->cx, ds->cy);
@@ -3398,7 +3408,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     }
 
     if (ui->dragging) {
-        ds->dragging = TRUE;
+        ds->dragging = true;
         ds->dragx = ui->dx - TILE_SIZE/2;
         ds->dragy = ui->dy - TILE_SIZE/2;
         calculate_opposite_point(ui, ds, ui->dx, ui->dy, &oppx, &oppy);
@@ -3442,9 +3452,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 #ifndef EDITOR
@@ -3635,7 +3645,7 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
@@ -3643,11 +3653,11 @@ const struct game thegame = {
     dup_game,
     free_game,
 #ifdef EDITOR
-    FALSE, NULL,
+    false, NULL,
 #else
-    TRUE, solve_game,
+    true, solve_game,
 #endif
-    TRUE, game_can_format_as_text_now, game_text_format,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3665,13 +3675,13 @@ const struct game thegame = {
     game_flash_length,
     game_status,
 #ifdef EDITOR
-    FALSE, FALSE, NULL, NULL,
-    TRUE,                              /* wants_statusbar */
+    false, false, NULL, NULL,
+    true,                              /* wants_statusbar */
 #else
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
 #endif
-    FALSE, game_timing_state,
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -3696,7 +3706,7 @@ static void dump_state(game_state *state)
     sfree(temp);
 }
 
-static int gen(game_params *p, random_state *rs, int debug)
+static int gen(game_params *p, random_state *rs, bool debug)
 {
     char *desc;
     int diff;
@@ -3708,7 +3718,7 @@ static int gen(game_params *p, random_state *rs, int debug)
     printf("Generating a %dx%d %s puzzle.\n",
            p->w, p->h, galaxies_diffnames[p->diff]);
 
-    desc = new_game_desc(p, rs, NULL, 0);
+    desc = new_game_desc(p, rs, NULL, false);
     state = new_game(NULL, p, desc);
     dump_state(state);
 
@@ -3731,7 +3741,7 @@ static void soak(game_params *p, random_state *rs)
     int diff, n = 0, i, diffs[DIFF_MAX], ndots = 0, nspaces = 0;
 
 #ifndef DEBUGGING
-    solver_show_working = 0;
+    solver_show_working = false;
 #endif
     tt_start = tt_now = time(NULL);
     for (i = 0; i < DIFF_MAX; i++) diffs[i] = 0;
@@ -3745,7 +3755,7 @@ static void soak(game_params *p, random_state *rs)
     printf("]\n");
 
     while (1) {
-        desc = new_game_desc(p, rs, NULL, 0);
+        desc = new_game_desc(p, rs, NULL, false);
         st = new_game(NULL, p, desc);
         diff = solver_state(st, p->diff);
         nspaces += st->w*st->h;
@@ -3776,7 +3786,8 @@ int main(int argc, char **argv)
     char *id = NULL, *desc;
     const char *err;
     game_state *s;
-    int diff, do_soak = 0, verbose = 0;
+    int diff;
+    bool do_soak = false, verbose = false;
     random_state *rs;
     time_t seed = time(NULL);
 
@@ -3784,13 +3795,13 @@ int main(int argc, char **argv)
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            verbose = 1;
+            verbose = true;
         } else if (!strcmp(p, "--seed")) {
             if (argc == 0) usage_exit("--seed needs an argument");
             seed = (time_t)atoi(*++argv);
             argc--;
         } else if (!strcmp(p, "--soak")) {
-            do_soak = 1;
+            do_soak = true;
         } else if (*p == '-') {
             usage_exit("unrecognised option");
         } else {
@@ -3815,7 +3826,7 @@ int main(int argc, char **argv)
             p->w = random_upto(rs, 15) + 3;
             p->h = random_upto(rs, 15) + 3;
             p->diff = random_upto(rs, DIFF_UNREASONABLE);
-            diff = gen(p, rs, 0);
+            diff = gen(p, rs, false);
         }
         return 0;
     }
@@ -3826,7 +3837,7 @@ int main(int argc, char **argv)
         gen(p, rs, verbose);
     } else {
 #ifndef DEBUGGING
-        solver_show_working = 1;
+        solver_show_working = true;
 #endif
         *desc++ = '\0';
         decode_params(p, id);
@@ -3977,8 +3988,8 @@ int main(int argc, char **argv)
 
     rs = random_new((void*)&seed, sizeof(time_t));
 
-    desc = new_game_desc(par, rs, NULL, FALSE);
-    params = encode_params(par, FALSE);
+    desc = new_game_desc(par, rs, NULL, false);
+    params = encode_params(par, false);
     printf("%s:%s\n", params, desc);
 
     sfree(desc);
diff --git a/apps/plugins/puzzles/src/grid.c b/apps/plugins/puzzles/src/grid.c
index b5e6bb0937..89bde187be 100644
--- a/apps/plugins/puzzles/src/grid.c
+++ b/apps/plugins/puzzles/src/grid.c
@@ -386,11 +386,11 @@ static void grid_trim_vigorously(grid *g)
      */
     dots = snewn(g->num_dots, int);
     for (i = 0; i < g->num_dots; i++) {
-        dots[i] = TRUE;
+        dots[i] = 1;
         for (j = 0; j < g->num_dots; j++) {
             if ((dotpairs[i*g->num_dots+j] >= 0) ^
                 (dotpairs[j*g->num_dots+i] >= 0))
-                dots[i] = FALSE;    /* non-duplicated edge: coastal dot */
+                dots[i] = 0;    /* non-duplicated edge: coastal dot */
         }
     }
 
@@ -435,14 +435,14 @@ static void grid_trim_vigorously(grid *g)
         dots[i] = 0;
     for (i = 0; i < g->num_faces; i++) {
         grid_face *f = g->faces + i;
-        int keep = FALSE;
+        bool keep = false;
         for (k = 0; k < f->order; k++)
             if (dsf_canonify(dsf, f->dots[k] - g->dots) == j)
-                keep = TRUE;
+                keep = true;
         if (keep) {
-            faces[i] = TRUE;
+            faces[i] = 1;
             for (k = 0; k < f->order; k++)
-                dots[f->dots[k]-g->dots] = TRUE;
+                dots[f->dots[k]-g->dots] = 1;
         }
     }
 
@@ -700,7 +700,7 @@ static void grid_make_consistent(grid *g)
          * that face (see diagram). */
  
         /* clockwise search */
-        while (TRUE) {
+        while (true) {
             grid_face *f = d->faces[current_face1];
             grid_edge *e;
             int j;
@@ -737,7 +737,7 @@ static void grid_make_consistent(grid *g)
             continue; /* this dot is complete, move on to next dot */
         
         /* anticlockwise search */
-        while (TRUE) {
+        while (true) {
             grid_face *f = d->faces[current_face2];
             grid_edge *e;
             int j;
@@ -813,7 +813,7 @@ static void grid_face_add_new(grid *g, int face_size)
     for (i = 0; i < face_size; i++)
         new_face->dots[i] = NULL;
     new_face->edges = NULL;
-    new_face->has_incentre = FALSE;
+    new_face->has_incentre = false;
     g->num_faces++;
 }
 /* Assumes dot list has enough space */
@@ -862,13 +862,13 @@ static void grid_face_set_dot(grid *g, grid_dot *d, int position)
 /*
  * Helper routines for grid_find_incentre.
  */
-static int solve_2x2_matrix(double mx[4], double vin[2], double vout[2])
+static bool solve_2x2_matrix(double mx[4], double vin[2], double vout[2])
 {
     double inv[4];
     double det;
     det = (mx[0]*mx[3] - mx[1]*mx[2]);
     if (det == 0)
-        return FALSE;
+        return false;
 
     inv[0] = mx[3] / det;
     inv[1] = -mx[1] / det;
@@ -878,9 +878,9 @@ static int solve_2x2_matrix(double mx[4], double vin[2], double vout[2])
     vout[0] = inv[0]*vin[0] + inv[1]*vin[1];
     vout[1] = inv[2]*vin[0] + inv[3]*vin[1];
 
-    return TRUE;
+    return true;
 }
-static int solve_3x3_matrix(double mx[9], double vin[3], double vout[3])
+static bool solve_3x3_matrix(double mx[9], double vin[3], double vout[3])
 {
     double inv[9];
     double det;
@@ -888,7 +888,7 @@ static int solve_3x3_matrix(double mx[9], double vin[3], double vout[3])
     det = (mx[0]*mx[4]*mx[8] + mx[1]*mx[5]*mx[6] + mx[2]*mx[3]*mx[7] -
            mx[0]*mx[5]*mx[7] - mx[1]*mx[3]*mx[8] - mx[2]*mx[4]*mx[6]);
     if (det == 0)
-        return FALSE;
+        return false;
 
     inv[0] = (mx[4]*mx[8] - mx[5]*mx[7]) / det;
     inv[1] = (mx[2]*mx[7] - mx[1]*mx[8]) / det;
@@ -904,7 +904,7 @@ static int solve_3x3_matrix(double mx[9], double vin[3], double vout[3])
     vout[1] = inv[3]*vin[0] + inv[4]*vin[1] + inv[5]*vin[2];
     vout[2] = inv[6]*vin[0] + inv[7]*vin[1] + inv[8]*vin[2];
 
-    return TRUE;
+    return true;
 }
 
 void grid_find_incentre(grid_face *f)
@@ -1239,7 +1239,8 @@ void grid_find_incentre(grid_face *f)
                      * _positive_ epsilon in both the x- and
                      * y-direction.)
                      */
-                    int e, in = 0;
+                    int e;
+                    bool in = false;
                     for (e = 0; e < f->order; e++) {
                         int xs = f->edges[e]->dot1->x;
                         int xe = f->edges[e]->dot2->x;
@@ -1265,7 +1266,7 @@ void grid_find_incentre(grid_face *f)
                                 denom = -denom;
                             }
                             if ((x - xs) * denom >= (y - ys) * num)
-                                in ^= 1;
+                                in = !in;
                         }
                     }
 
@@ -1364,7 +1365,7 @@ void grid_find_incentre(grid_face *f)
 
     assert(bestdist > 0);
 
-    f->has_incentre = TRUE;
+    f->has_incentre = true;
     f->ix = xbest + 0.5;               /* round to nearest */
     f->iy = ybest + 0.5;
 }
@@ -1611,11 +1612,11 @@ static grid *grid_new_triangular(int width, int height, const char *desc)
                 f1->edges = NULL;
                 f1->order = 3;
                 f1->dots = snewn(f1->order, grid_dot*);
-                f1->has_incentre = FALSE;
+                f1->has_incentre = false;
                 f2->edges = NULL;
                 f2->order = 3;
                 f2->dots = snewn(f2->order, grid_dot*);
-                f2->has_incentre = FALSE;
+                f2->has_incentre = false;
 
                 /* face descriptions depend on whether the row-number is
                  * odd or even */
diff --git a/apps/plugins/puzzles/src/grid.h b/apps/plugins/puzzles/src/grid.h
index 26d0b16633..7ca3ff1d5f 100644
--- a/apps/plugins/puzzles/src/grid.h
+++ b/apps/plugins/puzzles/src/grid.h
@@ -50,7 +50,7 @@ struct grid_face {
    * grid_find_incentre() on a face, and it will fill in ix,iy below
    * and set has_incentre to indicate that it's done so.
    */
-  int has_incentre;
+  bool has_incentre;
   int ix, iy;      /* incentre (centre of largest inscribed circle) */
 };
 struct grid_edge {
diff --git a/apps/plugins/puzzles/src/gtk.c b/apps/plugins/puzzles/src/gtk.c
index c3115b5816..d41f8677b9 100644
--- a/apps/plugins/puzzles/src/gtk.c
+++ b/apps/plugins/puzzles/src/gtk.c
@@ -139,6 +139,8 @@ struct font {
  * particularly good reason not to.
  */
 struct frontend {
+    bool headless; /* true if we're running without GTK, for --screenshot */
+
     GtkWidget *window;
     GtkAccelGroup *dummy_accelgroup;
     GtkWidget *area;
@@ -167,12 +169,14 @@ struct frontend {
 #endif
     int ncolours;
     int bbox_l, bbox_r, bbox_u, bbox_d;
-    int timer_active, timer_id;
+    bool timer_active;
+    int timer_id;
     struct timeval last_time;
     struct font *fonts;
     int nfonts, fontsize;
     config_item *cfg;
-    int cfg_which, cfgret;
+    int cfg_which;
+    bool cfgret;
     GtkWidget *cfgbox;
     void *paste_data;
     int paste_data_len;
@@ -182,12 +186,12 @@ struct frontend {
     char *filesel_name;
 #endif
     GSList *preset_radio;
-    int preset_threaded;
+    bool preset_threaded;
     GtkWidget *preset_custom;
     GtkWidget *copy_menu_item;
 #if !GTK_CHECK_VERSION(3,0,0)
-    int drawing_area_shrink_pending;
-    int menubar_is_local;
+    bool drawing_area_shrink_pending;
+    bool menubar_is_local;
 #endif
 #if GTK_CHECK_VERSION(3,0,0)
     /*
@@ -219,7 +223,7 @@ struct frontend {
      * happen, the window's size_allocate handler does a fallback
      * puzzle resize when it sees this flag still set to true.
      */
-    int awaiting_resize_ack;
+    bool awaiting_resize_ack;
 #endif
 };
 
@@ -268,6 +272,9 @@ void gtk_status_bar(void *handle, const char *text)
 {
     frontend *fe = (frontend *)handle;
 
+    if (fe->headless)
+        return;
+
     assert(fe->statusbar);
 
     gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
@@ -295,7 +302,7 @@ static void teardown_drawing(frontend *fe)
     fe->cr = NULL;
 
 #ifndef USE_CAIRO_WITHOUT_PIXMAP
-    {
+    if (!fe->headless) {
         cairo_t *cr = gdk_cairo_create(fe->pixmap);
         cairo_set_source_surface(cr, fe->image, 0, 0);
         cairo_rectangle(cr,
@@ -359,7 +366,7 @@ static void set_window_background(frontend *fe, int colour)
     fe->background.red = fe->colours[3*colour + 0] * 65535;
     fe->background.green = fe->colours[3*colour + 1] * 65535;
     fe->background.blue = fe->colours[3*colour + 2] * 65535;
-    if (!gdk_colormap_alloc_color(colmap, &fe->background, FALSE, FALSE)) {
+    if (!gdk_colormap_alloc_color(colmap, &fe->background, false, false)) {
 	g_error("couldn't allocate background (#%02x%02x%02x)\n",
 		fe->background.red >> 8, fe->background.green >> 8,
 		fe->background.blue >> 8);
@@ -494,7 +501,7 @@ static void clear_backing_store(frontend *fe)
 }
 
 static void wipe_and_maybe_destroy_cairo(frontend *fe, cairo_t *cr,
-                                         int destroy)
+                                         bool destroy)
 {
     cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]);
     cairo_paint(cr);
@@ -505,18 +512,23 @@ static void wipe_and_maybe_destroy_cairo(frontend *fe, cairo_t *cr,
 static void setup_backing_store(frontend *fe)
 {
 #ifndef USE_CAIRO_WITHOUT_PIXMAP
+    if (fe->headless) {
+        fprintf(stderr, "headless mode does not work with GDK pixmaps\n");
+        exit(1);
+    }
+
     fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area),
                                 fe->pw, fe->ph, -1);
 #endif
     fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
 					   fe->pw, fe->ph);
 
-    wipe_and_maybe_destroy_cairo(fe, cairo_create(fe->image), TRUE);
+    wipe_and_maybe_destroy_cairo(fe, cairo_create(fe->image), true);
 #ifndef USE_CAIRO_WITHOUT_PIXMAP
-    wipe_and_maybe_destroy_cairo(fe, gdk_cairo_create(fe->pixmap), TRUE);
+    wipe_and_maybe_destroy_cairo(fe, gdk_cairo_create(fe->pixmap), true);
 #endif
 #if GTK_CHECK_VERSION(3,22,0)
-    {
+    if (!fe->headless) {
         GdkWindow *gdkwin;
         cairo_region_t *region;
         GdkDrawingContext *drawctx;
@@ -526,19 +538,19 @@ static void setup_backing_store(frontend *fe)
         region = gdk_window_get_clip_region(gdkwin);
         drawctx = gdk_window_begin_draw_frame(gdkwin, region);
         cr = gdk_drawing_context_get_cairo_context(drawctx);
-        wipe_and_maybe_destroy_cairo(fe, cr, FALSE);
+        wipe_and_maybe_destroy_cairo(fe, cr, false);
         gdk_window_end_draw_frame(gdkwin, drawctx);
         cairo_region_destroy(region);
     }
 #else
     wipe_and_maybe_destroy_cairo(
-        fe, gdk_cairo_create(gtk_widget_get_window(fe->area)), TRUE);
+        fe, gdk_cairo_create(gtk_widget_get_window(fe->area)), true);
 #endif
 }
 
-static int backing_store_ok(frontend *fe)
+static bool backing_store_ok(frontend *fe)
 {
-    return (!!fe->image);
+    return fe->image != NULL;
 }
 
 static void teardown_backing_store(frontend *fe)
@@ -586,7 +598,7 @@ static void snaffle_colours(frontend *fe)
     }
     success = snewn(ncolours, gboolean);
     gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
-			      FALSE, FALSE, success);
+			      false, false, success);
     for (i = 0; i < ncolours; i++) {
 	if (!success[i]) {
 	    g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
@@ -698,7 +710,7 @@ static void do_draw_poly(frontend *fe, int *coords, int npoints,
 
     if (fillcolour >= 0) {
 	set_colour(fe, fillcolour);
-	gdk_draw_polygon(fe->pixmap, fe->gc, TRUE, points, npoints);
+	gdk_draw_polygon(fe->pixmap, fe->gc, true, points, npoints);
     }
     assert(outlinecolour >= 0);
     set_colour(fe, outlinecolour);
@@ -722,14 +734,14 @@ static void do_draw_circle(frontend *fe, int cx, int cy, int radius,
 {
     if (fillcolour >= 0) {
 	set_colour(fe, fillcolour);
-	gdk_draw_arc(fe->pixmap, fe->gc, TRUE,
+	gdk_draw_arc(fe->pixmap, fe->gc, true,
 		     cx - radius, cy - radius,
 		     2 * radius, 2 * radius, 0, 360 * 64);
     }
 
     assert(outlinecolour >= 0);
     set_colour(fe, outlinecolour);
-    gdk_draw_arc(fe->pixmap, fe->gc, FALSE,
+    gdk_draw_arc(fe->pixmap, fe->gc, false,
 		 cx - radius, cy - radius,
 		 2 * radius, 2 * radius, 0, 360 * 64);
 }
@@ -778,6 +790,11 @@ static void setup_backing_store(frontend *fe)
 {
     GdkGC *gc;
 
+    if (fe->headless) {
+        fprintf(stderr, "headless mode does not work with GDK drawing\n");
+        exit(1);
+    }
+
     fe->pixmap = gdk_pixmap_new(fe->area->window, fe->pw, fe->ph, -1);
 
     gc = gdk_gc_new(fe->area->window);
@@ -812,24 +829,24 @@ static void repaint_rectangle(frontend *fe, GtkWidget *widget,
 #endif
     if (x < fe->ox) {
 	gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
-			   TRUE, x, y, fe->ox - x, h);
+			   true, x, y, fe->ox - x, h);
 	w -= (fe->ox - x);
 	x = fe->ox;
     }
     if (y < fe->oy) {
 	gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
-			   TRUE, x, y, w, fe->oy - y);
+			   true, x, y, w, fe->oy - y);
 	h -= (fe->oy - y);
 	y = fe->oy;
     }
     if (w > fe->pw) {
 	gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
-			   TRUE, x + fe->pw, y, w - fe->pw, h);
+			   true, x + fe->pw, y, w - fe->pw, h);
 	w = fe->pw;
     }
     if (h > fe->ph) {
 	gdk_draw_rectangle(gtk_widget_get_window(widget), gc,
-			   TRUE, x, y + fe->ph, w, h - fe->ph);
+			   true, x, y + fe->ph, w, h - fe->ph);
 	h = fe->ph;
     }
     gdk_draw_pixmap(gtk_widget_get_window(widget), gc, fe->pixmap,
@@ -1116,7 +1133,7 @@ void gtk_end_draw(void *handle)
 
     teardown_drawing(fe);
 
-    if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
+    if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d && !fe->headless) {
 #ifdef USE_CAIRO_WITHOUT_PIXMAP
         gtk_widget_queue_draw_area(fe->area,
                                    fe->bbox_l - 1 + fe->ox,
@@ -1190,11 +1207,11 @@ static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
     int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0;
 
     if (!backing_store_ok(fe))
-        return TRUE;
+        return true;
 
     /* Handle mnemonics. */
     if (gtk_window_activate_key(GTK_WINDOW(fe->window), event))
-        return TRUE;
+        return true;
 
     if (event->keyval == GDK_KEY_Up)
         keyval = shift | ctrl | CURSOR_UP;
@@ -1249,7 +1266,7 @@ static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
         !midend_process_key(fe->me, 0, 0, keyval))
 	gtk_widget_destroy(fe->window);
 
-    return TRUE;
+    return true;
 }
 
 static gint button_event(GtkWidget *widget, GdkEventButton *event,
@@ -1259,10 +1276,10 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event,
     int button;
 
     if (!backing_store_ok(fe))
-        return TRUE;
+        return true;
 
     if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
-        return TRUE;
+        return true;
 
     if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
 	button = MIDDLE_BUTTON;
@@ -1275,7 +1292,7 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event,
     else if (event->button == 9 && event->type == GDK_BUTTON_PRESS)
         button = 'r';
     else
-	return FALSE;		       /* don't even know what button! */
+	return false;		       /* don't even know what button! */
 
     if (event->type == GDK_BUTTON_RELEASE && button >= LEFT_BUTTON)
         button += LEFT_RELEASE - LEFT_BUTTON;
@@ -1284,7 +1301,7 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event,
                             event->y - fe->oy, button))
 	gtk_widget_destroy(fe->window);
 
-    return TRUE;
+    return true;
 }
 
 static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
@@ -1294,7 +1311,7 @@ static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
     int button;
 
     if (!backing_store_ok(fe))
-        return TRUE;
+        return true;
 
     if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK))
 	button = MIDDLE_DRAG;
@@ -1303,7 +1320,7 @@ static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
     else if (event->state & GDK_BUTTON3_MASK)
 	button = RIGHT_DRAG;
     else
-	return FALSE;		       /* don't even know what button! */
+	return false;		       /* don't even know what button! */
 
     if (!midend_process_key(fe->me, event->x - fe->ox,
                             event->y - fe->oy, button))
@@ -1314,7 +1331,7 @@ static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
     gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, NULL);
 #endif
 
-    return TRUE;
+    return true;
 }
 
 #if GTK_CHECK_VERSION(3,0,0)
@@ -1329,7 +1346,7 @@ static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data)
                     dirtyrect.width, dirtyrect.height);
     cairo_fill(cr);
 
-    return TRUE;
+    return true;
 }
 #else
 static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
@@ -1351,7 +1368,7 @@ static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
 			  event->area.width, event->area.height);
 #endif
     }
-    return TRUE;
+    return true;
 }
 #endif
 
@@ -1367,7 +1384,7 @@ static gint map_window(GtkWidget *widget, GdkEvent *event,
      */
     gtk_widget_queue_draw(fe->window);
 
-    return TRUE;
+    return true;
 }
 
 static void resize_puzzle_to_area(frontend *fe, int x, int y)
@@ -1376,7 +1393,7 @@ static void resize_puzzle_to_area(frontend *fe, int x, int y)
 
     fe->w = x;
     fe->h = y;
-    midend_size(fe->me, &x, &y, TRUE);
+    midend_size(fe->me, &x, &y, true);
     fe->pw = x;
     fe->ph = y;
     fe->ox = (fe->w - fe->pw) / 2;
@@ -1398,9 +1415,9 @@ static gint configure_area(GtkWidget *widget,
     frontend *fe = (frontend *)data;
     resize_puzzle_to_area(fe, event->width, event->height);
 #if GTK_CHECK_VERSION(3,0,0)
-    fe->awaiting_resize_ack = FALSE;
+    fe->awaiting_resize_ack = false;
 #endif
-    return TRUE;
+    return true;
 }
 
 #if GTK_CHECK_VERSION(3,0,0)
@@ -1412,7 +1429,7 @@ static void window_size_alloc(GtkWidget *widget, GtkAllocation *allocation,
         GtkAllocation a;
         gtk_widget_get_allocation(fe->area, &a);
         resize_puzzle_to_area(fe, a.width, a.height);
-        fe->awaiting_resize_ack = FALSE;
+        fe->awaiting_resize_ack = false;
     }
 }
 #endif
@@ -1440,7 +1457,7 @@ void deactivate_timer(frontend *fe)
 	return;			       /* can happen due to --generate */
     if (fe->timer_active)
         g_source_remove(fe->timer_id);
-    fe->timer_active = FALSE;
+    fe->timer_active = false;
 }
 
 void activate_timer(frontend *fe)
@@ -1451,7 +1468,7 @@ void activate_timer(frontend *fe)
         fe->timer_id = g_timeout_add(20, timer_func, fe);
 	gettimeofday(&fe->last_time, NULL);
     }
-    fe->timer_active = TRUE;
+    fe->timer_active = true;
 }
 
 static void window_destroy(GtkWidget *widget, gpointer data)
@@ -1459,7 +1476,7 @@ static void window_destroy(GtkWidget *widget, gpointer data)
     gtk_main_quit();
 }
 
-static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
+static gint win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
 {
     GObject *cancelbutton = G_OBJECT(data);
 
@@ -1468,10 +1485,10 @@ static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
      */
     if (event->keyval == GDK_KEY_Escape) {
 	g_signal_emit_by_name(cancelbutton, "clicked");
-	return TRUE;
+	return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 enum { MB_OK, MB_YESNO };
@@ -1494,8 +1511,8 @@ static void align_label(GtkLabel *label, double x, double y)
 }
 
 #if GTK_CHECK_VERSION(3,0,0)
-int message_box(GtkWidget *parent, const char *title, const char *msg,
-                int centre, int type)
+bool message_box(GtkWidget *parent, const char *title, const char *msg,
+                 bool centre, int type)
 {
     GtkWidget *window;
     gint ret;
@@ -1509,7 +1526,7 @@ int message_box(GtkWidget *parent, const char *title, const char *msg,
     gtk_window_set_title(GTK_WINDOW(window), title);
     ret = gtk_dialog_run(GTK_DIALOG(window));
     gtk_widget_destroy(window);
-    return (type == MB_OK ? TRUE : (ret == GTK_RESPONSE_YES));
+    return (type == MB_OK ? true : (ret == GTK_RESPONSE_YES));
 }
 #else /* GTK_CHECK_VERSION(3,0,0) */
 static void msgbox_button_clicked(GtkButton *button, gpointer data)
@@ -1524,8 +1541,8 @@ static void msgbox_button_clicked(GtkButton *button, gpointer data)
     gtk_widget_destroy(GTK_WIDGET(data));
 }
 
-int message_box(GtkWidget *parent, const char *title, const char *msg,
-                int centre, int type)
+bool message_box(GtkWidget *parent, const char *title, const char *msg,
+                 bool centre, int type)
 {
     GtkWidget *window, *hbox, *text, *button;
     char *titles;
@@ -1534,15 +1551,15 @@ int message_box(GtkWidget *parent, const char *title, const char *msg,
     window = gtk_dialog_new();
     text = gtk_label_new(msg);
     align_label(GTK_LABEL(text), 0.0, 0.0);
-    hbox = gtk_hbox_new(FALSE, 0);
-    gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
+    hbox = gtk_hbox_new(false, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), text, false, false, 20);
     gtk_box_pack_start
         (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))),
-         hbox, FALSE, FALSE, 20);
+         hbox, false, false, 20);
     gtk_widget_show(text);
     gtk_widget_show(hbox);
     gtk_window_set_title(GTK_WINDOW(window), title);
-    gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
+    gtk_label_set_line_wrap(GTK_LABEL(text), true);
 
     if (type == MB_OK) {
 	titles = LABEL_OK "\0";
@@ -1559,10 +1576,10 @@ int message_box(GtkWidget *parent, const char *title, const char *msg,
 	button = gtk_button_new_with_our_label(titles);
 	gtk_box_pack_end
             (GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(window))),
-             button, FALSE, FALSE, 0);
+             button, false, false, 0);
 	gtk_widget_show(button);
 	if (i == def) {
-	    gtk_widget_set_can_default(button, TRUE);
+	    gtk_widget_set_can_default(button, true);
 	    gtk_window_set_default(GTK_WINDOW(window), button);
 	}
 	if (i == cancel) {
@@ -1579,19 +1596,19 @@ int message_box(GtkWidget *parent, const char *title, const char *msg,
     g_object_set_data(G_OBJECT(window), "user-data", &i);
     g_signal_connect(G_OBJECT(window), "destroy",
                      G_CALLBACK(window_destroy), NULL);
-    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
+    gtk_window_set_modal(GTK_WINDOW(window), true);
     gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
     /* set_transient_window_pos(parent, window); */
     gtk_widget_show(window);
     i = -1;
     gtk_main();
-    return (type == MB_YESNO ? i == 1 : TRUE);
+    return (type == MB_YESNO ? i == 1 : true);
 }
 #endif /* GTK_CHECK_VERSION(3,0,0) */
 
 void error_box(GtkWidget *parent, const char *msg)
 {
-    message_box(parent, "Error", msg, FALSE, MB_OK);
+    message_box(parent, "Error", msg, false, MB_OK);
 }
 
 static void config_ok_button_clicked(GtkButton *button, gpointer data)
@@ -1604,7 +1621,7 @@ static void config_ok_button_clicked(GtkButton *button, gpointer data)
     if (err)
 	error_box(fe->cfgbox, err);
     else {
-	fe->cfgret = TRUE;
+	fe->cfgret = true;
 	gtk_widget_destroy(fe->cfgbox);
 	changed_preset(fe);
     }
@@ -1617,7 +1634,7 @@ static void config_cancel_button_clicked(GtkButton *button, gpointer data)
     gtk_widget_destroy(fe->cfgbox);
 }
 
-static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
+static gint editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
 {
     /*
      * GtkEntry has a nasty habit of eating the Return key, which
@@ -1636,7 +1653,7 @@ static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
                               "key_press_event", event, &return_val);
 	return return_val;
     }
-    return FALSE;
+    return false;
 }
 
 static void editbox_changed(GtkEditable *ed, gpointer data)
@@ -1664,7 +1681,7 @@ static void droplist_sel(GtkComboBox *combo, gpointer data)
     i->u.choices.selected = gtk_combo_box_get_active(combo);
 }
 
-static int get_config(frontend *fe, int which)
+static bool get_config(frontend *fe, int which)
 {
     GtkWidget *w, *table, *cancel;
     GtkBox *content_box, *button_box;
@@ -1674,22 +1691,22 @@ static int get_config(frontend *fe, int which)
 
     fe->cfg = midend_get_config(fe->me, which, &title);
     fe->cfg_which = which;
-    fe->cfgret = FALSE;
+    fe->cfgret = false;
 
 #if GTK_CHECK_VERSION(3,0,0)
     /* GtkDialog isn't quite flexible enough */
     fe->cfgbox = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-    content_box = GTK_BOX(gtk_vbox_new(FALSE, 8));
+    content_box = GTK_BOX(gtk_vbox_new(false, 8));
     g_object_set(G_OBJECT(content_box), "margin", 8, (const char *)NULL);
     gtk_widget_show(GTK_WIDGET(content_box));
     gtk_container_add(GTK_CONTAINER(fe->cfgbox), GTK_WIDGET(content_box));
-    button_box = GTK_BOX(gtk_hbox_new(FALSE, 8));
+    button_box = GTK_BOX(gtk_hbox_new(false, 8));
     gtk_widget_show(GTK_WIDGET(button_box));
-    gtk_box_pack_end(content_box, GTK_WIDGET(button_box), FALSE, FALSE, 0);
+    gtk_box_pack_end(content_box, GTK_WIDGET(button_box), false, false, 0);
     {
         GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
         gtk_widget_show(sep);
-        gtk_box_pack_end(content_box, sep, FALSE, FALSE, 0);
+        gtk_box_pack_end(content_box, sep, false, false, 0);
     }
 #else
     fe->cfgbox = gtk_dialog_new();
@@ -1700,16 +1717,16 @@ static int get_config(frontend *fe, int which)
     sfree(title);
 
     w = gtk_button_new_with_our_label(LABEL_CANCEL);
-    gtk_box_pack_end(button_box, w, FALSE, FALSE, 0);
+    gtk_box_pack_end(button_box, w, false, false, 0);
     gtk_widget_show(w);
     g_signal_connect(G_OBJECT(w), "clicked",
                      G_CALLBACK(config_cancel_button_clicked), fe);
     cancel = w;
 
     w = gtk_button_new_with_our_label(LABEL_OK);
-    gtk_box_pack_end(button_box, w, FALSE, FALSE, 0);
+    gtk_box_pack_end(button_box, w, false, false, 0);
     gtk_widget_show(w);
-    gtk_widget_set_can_default(w, TRUE);
+    gtk_widget_set_can_default(w, true);
     gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
     g_signal_connect(G_OBJECT(w), "clicked",
                      G_CALLBACK(config_ok_button_clicked), fe);
@@ -1717,10 +1734,10 @@ static int get_config(frontend *fe, int which)
 #if GTK_CHECK_VERSION(3,0,0)
     table = gtk_grid_new();
 #else
-    table = gtk_table_new(1, 2, FALSE);
+    table = gtk_table_new(1, 2, false);
 #endif
     y = 0;
-    gtk_box_pack_start(content_box, table, FALSE, FALSE, 0);
+    gtk_box_pack_start(content_box, table, false, false, 0);
     gtk_widget_show(table);
 
     for (i = fe->cfg; i->type != C_END; i++) {
@@ -1749,7 +1766,7 @@ static int get_config(frontend *fe, int which)
 	    w = gtk_entry_new();
 #if GTK_CHECK_VERSION(3,0,0)
             gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1);
-            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+            g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL);
 #else
 	    gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
 			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
@@ -1774,7 +1791,7 @@ static int get_config(frontend *fe, int which)
                              G_CALLBACK(button_toggled), i);
 #if GTK_CHECK_VERSION(3,0,0)
             gtk_grid_attach(GTK_GRID(table), w, 0, y, 2, 1);
-            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+            g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL);
 #else
 	    gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
 			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
@@ -1839,7 +1856,7 @@ static int get_config(frontend *fe, int which)
                                          i->u.choices.selected);
 
 		cr = gtk_cell_renderer_text_new();
-		gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, TRUE);
+		gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, true);
 		gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), cr,
 					       "text", 0, NULL);
 
@@ -1849,7 +1866,7 @@ static int get_config(frontend *fe, int which)
 
 #if GTK_CHECK_VERSION(3,0,0)
             gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1);
-            g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
+            g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL);
 #else
 	    gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
 			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
@@ -1867,7 +1884,7 @@ static int get_config(frontend *fe, int which)
                      G_CALLBACK(window_destroy), NULL);
     g_signal_connect(G_OBJECT(fe->cfgbox), "key_press_event",
                      G_CALLBACK(win_key_press), cancel);
-    gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
+    gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), true);
     gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
 				 GTK_WINDOW(fe->window));
     /* set_transient_window_pos(fe->window, fe->cfgbox); */
@@ -1906,7 +1923,7 @@ static void get_size(frontend *fe, int *px, int *py)
      */
     x = INT_MAX;
     y = INT_MAX;
-    midend_size(fe->me, &x, &y, FALSE);
+    midend_size(fe->me, &x, &y, false);
     *px = x;
     *py = y;
 }
@@ -1924,11 +1941,11 @@ static void changed_preset(frontend *fe)
 {
     int n = midend_which_preset(fe->me);
 
-    fe->preset_threaded = TRUE;
+    fe->preset_threaded = true;
     if (n < 0 && fe->preset_custom) {
 	gtk_check_menu_item_set_active(
 	    GTK_CHECK_MENU_ITEM(fe->preset_custom),
-	    TRUE);
+	    true);
     } else {
 	GSList *gs = fe->preset_radio;
         GSList *found = NULL;
@@ -1939,27 +1956,27 @@ static void changed_preset(frontend *fe)
                     G_OBJECT(gs->data), "user-data");
             if (!entry || entry->id != n)
                 gtk_check_menu_item_set_active(
-                    GTK_CHECK_MENU_ITEM(gs->data), FALSE);
+                    GTK_CHECK_MENU_ITEM(gs->data), false);
             else
                 found = gs;
         }
         if (found)
             gtk_check_menu_item_set_active(
-                GTK_CHECK_MENU_ITEM(found->data), TRUE);
+                GTK_CHECK_MENU_ITEM(found->data), true);
     }
-    fe->preset_threaded = FALSE;
+    fe->preset_threaded = false;
 
     /*
      * Update the greying on the Copy menu option.
      */
     if (fe->copy_menu_item) {
-	int enabled = midend_can_format_as_text_now(fe->me);
+        bool enabled = midend_can_format_as_text_now(fe->me);
 	gtk_widget_set_sensitive(fe->copy_menu_item, enabled);
     }
 }
 
 #if !GTK_CHECK_VERSION(3,0,0)
-static gboolean not_size_allocated_yet(GtkWidget *w)
+static bool not_size_allocated_yet(GtkWidget *w)
 {
     /*
      * This function tests whether a widget has not yet taken up space
@@ -1969,18 +1986,18 @@ static gboolean not_size_allocated_yet(GtkWidget *w)
      * space it ever will.)
      */
     if (!w)
-        return FALSE;        /* nonexistent widgets aren't a problem */
+        return false;        /* nonexistent widgets aren't a problem */
 
 #if GTK_CHECK_VERSION(2,18,0)  /* skip if no gtk_widget_get_allocation */
     {
         GtkAllocation a;
         gtk_widget_get_allocation(w, &a);
         if (a.height == 0 || a.width == 0)
-            return TRUE;       /* widget exists but has no size yet */
+            return true;       /* widget exists but has no size yet */
     }
 #endif
 
-    return FALSE;
+    return false;
 }
 
 static void try_shrink_drawing_area(frontend *fe)
@@ -2004,7 +2021,7 @@ static void try_shrink_drawing_area(frontend *fe)
          * shrinking to less than the size we intended.
          */
         gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1);
-        fe->drawing_area_shrink_pending = FALSE;
+        fe->drawing_area_shrink_pending = false;
     }
 }
 #endif /* !GTK_CHECK_VERSION(3,0,0) */
@@ -2022,7 +2039,7 @@ static gint configure_window(GtkWidget *widget,
     frontend *fe = (frontend *)data;
     try_shrink_drawing_area(fe);
 #endif
-    return FALSE;
+    return false;
 }
 
 #if GTK_CHECK_VERSION(3,0,0)
@@ -2051,16 +2068,16 @@ static void resize_fe(frontend *fe)
 
 #if GTK_CHECK_VERSION(3,0,0)
     gtk_window_resize(GTK_WINDOW(fe->window), x, y + window_extra_height(fe));
-    fe->awaiting_resize_ack = TRUE;
+    fe->awaiting_resize_ack = true;
 #else
-    fe->drawing_area_shrink_pending = FALSE;
+    fe->drawing_area_shrink_pending = false;
     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
     {
         GtkRequisition req;
         gtk_widget_size_request(GTK_WIDGET(fe->window), &req);
         gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height);
     }
-    fe->drawing_area_shrink_pending = TRUE;
+    fe->drawing_area_shrink_pending = true;
     try_shrink_drawing_area(fe);
 #endif
 }
@@ -2084,14 +2101,14 @@ static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
 }
 
 GdkAtom compound_text_atom, utf8_string_atom;
-int paste_initialised = FALSE;
+bool paste_initialised = false;
 
 static void set_selection(frontend *fe, GdkAtom selection)
 {
     if (!paste_initialised) {
-	compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);
-	utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
-	paste_initialised = TRUE;
+	compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", false);
+	utf8_string_atom = gdk_atom_intern("UTF8_STRING", false);
+	paste_initialised = true;
     }
 
     /*
@@ -2139,7 +2156,7 @@ gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
 	sfree(fe->paste_data);
     fe->paste_data = NULL;
     fe->paste_data_len = 0;
-    return TRUE;
+    return true;
 }
 
 static void menu_copy_event(GtkMenuItem *menuitem, gpointer data)
@@ -2177,7 +2194,7 @@ static char *file_selector(frontend *fe, const char *title, int save)
 
     fe->filesel_name = NULL;
 
-    gtk_window_set_modal(GTK_WINDOW(filesel), TRUE);
+    gtk_window_set_modal(GTK_WINDOW(filesel), true);
     g_object_set_data
         (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data",
          (gpointer)filesel);
@@ -2201,7 +2218,7 @@ static char *file_selector(frontend *fe, const char *title, int save)
 
 #else
 
-static char *file_selector(frontend *fe, const char *title, int save)
+static char *file_selector(frontend *fe, const char *title, bool save)
 {
     char *filesel_name = NULL;
 
@@ -2240,7 +2257,7 @@ static void savefile_write(void *wctx, const void *buf, int len)
 	ctx->error = errno;
 }
 
-static int savefile_read(void *wctx, void *buf, int len)
+static bool savefile_read(void *wctx, void *buf, int len)
 {
     FILE *fp = (FILE *)wctx;
     int ret;
@@ -2254,7 +2271,7 @@ static void menu_save_event(GtkMenuItem *menuitem, gpointer data)
     frontend *fe = (frontend *)data;
     char *name;
 
-    name = file_selector(fe, "Enter name of game file to save", TRUE);
+    name = file_selector(fe, "Enter name of game file to save", true);
 
     if (name) {
         FILE *fp;
@@ -2267,7 +2284,7 @@ static void menu_save_event(GtkMenuItem *menuitem, gpointer data)
 	    sprintf(buf, "Are you sure you want to overwrite the"
 		    " file \"%.*s\"?",
 		    FILENAME_MAX, name);
-	    if (!message_box(fe->window, "Question", buf, TRUE, MB_YESNO))
+	    if (!message_box(fe->window, "Question", buf, true, MB_YESNO))
                 goto free_and_return;
 	}
 
@@ -2287,7 +2304,7 @@ static void menu_save_event(GtkMenuItem *menuitem, gpointer data)
 	    if (ctx.error) {
 		char boxmsg[512];
 		sprintf(boxmsg, "Error writing save file: %.400s",
-			strerror(errno));
+			strerror(ctx.error));
 		error_box(fe->window, boxmsg);
 		goto free_and_return;
 	    }
@@ -2303,7 +2320,7 @@ static void menu_load_event(GtkMenuItem *menuitem, gpointer data)
     char *name;
     const char *err;
 
-    name = file_selector(fe, "Enter name of saved game file to load", FALSE);
+    name = file_selector(fe, "Enter name of saved game file to load", false);
 
     if (name) {
         FILE *fp = fopen(name, "r");
@@ -2393,7 +2410,7 @@ static void menu_about_event(GtkMenuItem *menuitem, gpointer data)
 	    "from Simon Tatham's Portable Puzzle Collection\n\n"
 	    "%.500s", thegame.name, ver);
 
-    message_box(fe->window, titlebuf, textbuf, TRUE, MB_OK);
+    message_box(fe->window, titlebuf, textbuf, true, MB_OK);
 #endif
 }
 
@@ -2468,7 +2485,8 @@ static void populate_gtk_preset_menu(frontend *fe, struct preset_menu *menu,
 
 enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */
 
-static frontend *new_window(char *arg, int argtype, char **error)
+static frontend *new_window(
+    char *arg, int argtype, char **error, bool headless)
 {
     frontend *fe;
     GtkBox *vbox, *hbox;
@@ -2481,11 +2499,18 @@ static frontend *new_window(char *arg, int argtype, char **error)
     struct preset_menu *preset_menu;
 
     fe = snew(frontend);
-#if GTK_CHECK_VERSION(3,20,0)
-    fe->css_provider = NULL;
+    memset(fe, 0, sizeof(frontend));
+
+#if !GTK_CHECK_VERSION(3,0,0)
+    if (headless) {
+        fprintf(stderr, "headless mode not supported below GTK 3\n");
+        exit(1);
+    }
+#else
+    fe->headless = headless;
 #endif
 
-    fe->timer_active = FALSE;
+    fe->timer_active = false;
     fe->timer_id = -1;
 
     fe->me = midend_new(fe, &thegame, &gtk_drawing, fe);
@@ -2550,6 +2575,13 @@ static frontend *new_window(char *arg, int argtype, char **error)
 	midend_new_game(fe->me);
     }
 
+    if (headless) {
+        snaffle_colours(fe);
+        get_size(fe, &fe->pw, &fe->ph);
+        setup_backing_store(fe);
+        return fe;
+    }
+
 #if !GTK_CHECK_VERSION(3,0,0)
     {
         /*
@@ -2568,7 +2600,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
         GtkSettings *settings = gtk_settings_get_default();
         if (!g_object_class_find_property(G_OBJECT_GET_CLASS(settings),
                                           prop)) {
-            fe->menubar_is_local = TRUE;
+            fe->menubar_is_local = true;
         } else {
             int unity_mode;
             g_object_get(gtk_settings_get_default(),
@@ -2580,13 +2612,13 @@ static frontend *new_window(char *arg, int argtype, char **error)
 #endif
 
 #if GTK_CHECK_VERSION(3,0,0)
-    fe->awaiting_resize_ack = FALSE;
+    fe->awaiting_resize_ack = false;
 #endif
 
     fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
 
-    vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
+    vbox = GTK_BOX(gtk_vbox_new(false, 0));
     gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
     gtk_widget_show(GTK_WIDGET(vbox));
 
@@ -2596,12 +2628,12 @@ static frontend *new_window(char *arg, int argtype, char **error)
      * gtk_window_add_accel_group; see menu_key_event
      */
 
-    hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
-    gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0);
+    hbox = GTK_BOX(gtk_hbox_new(false, 0));
+    gtk_box_pack_start(vbox, GTK_WIDGET(hbox), false, false, 0);
     gtk_widget_show(GTK_WIDGET(hbox));
 
     fe->menubar = gtk_menu_bar_new();
-    gtk_box_pack_start(hbox, fe->menubar, TRUE, TRUE, 0);
+    gtk_box_pack_start(hbox, fe->menubar, true, true, 0);
     gtk_widget_show(fe->menubar);
 
     menuitem = gtk_menu_item_new_with_mnemonic("_Game");
@@ -2637,7 +2669,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
 
     fe->preset_radio = NULL;
     fe->preset_custom = NULL;
-    fe->preset_threaded = FALSE;
+    fe->preset_threaded = false;
 
     preset_menu = midend_get_presets(fe->me, NULL);
     if (preset_menu->n_entries > 0 || thegame.can_configure) {
@@ -2725,7 +2757,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
                       GINT_TO_POINTER(UI_REDO));
     g_signal_connect(G_OBJECT(menuitem), "clicked",
                      G_CALLBACK(menu_key_event), fe);
-    gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0);
+    gtk_box_pack_end(hbox, menuitem, false, false, 0);
     gtk_widget_show(menuitem);
 
     menuitem=gtk_button_new_with_mnemonic("_Undo");
@@ -2733,12 +2765,12 @@ static frontend *new_window(char *arg, int argtype, char **error)
                       GINT_TO_POINTER(UI_UNDO));
     g_signal_connect(G_OBJECT(menuitem), "clicked",
                      G_CALLBACK(menu_key_event), fe);
-    gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0);
+    gtk_box_pack_end(hbox, menuitem, false, false, 0);
     gtk_widget_show(menuitem);
 
     if (thegame.flags & REQUIRE_NUMPAD) {
-	hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
-	gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0);
+	hbox = GTK_BOX(gtk_hbox_new(false, 0));
+	gtk_box_pack_start(vbox, GTK_WIDGET(hbox), false, false, 0);
 	gtk_widget_show(GTK_WIDGET(hbox));
 
 	*((int*)errbuf)=0;
@@ -2749,7 +2781,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
                               GINT_TO_POINTER((int)(errbuf[0])));
 	    g_signal_connect(G_OBJECT(menuitem), "clicked",
                              G_CALLBACK(menu_key_event), fe);
-	    gtk_box_pack_start(hbox, menuitem, TRUE, TRUE, 0);
+	    gtk_box_pack_start(hbox, menuitem, true, true, 0);
 	    gtk_widget_show(menuitem);
 	}
     }
@@ -2768,7 +2800,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
 	fe->statusbar = gtk_statusbar_new();
 	gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
 	gtk_widget_show(viewport);
-	gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
+	gtk_box_pack_end(vbox, viewport, false, false, 0);
 	gtk_widget_show(fe->statusbar);
 	fe->statusctx = gtk_statusbar_get_context_id
 	    (GTK_STATUSBAR(fe->statusbar), "game");
@@ -2785,7 +2817,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
 
     fe->area = gtk_drawing_area_new();
 #if GTK_CHECK_VERSION(2,0,0) && !GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_set_double_buffered(fe->area, FALSE);
+    gtk_widget_set_double_buffered(fe->area, false);
 #endif
     {
         GdkGeometry geom;
@@ -2807,11 +2839,11 @@ static frontend *new_window(char *arg, int argtype, char **error)
     gtk_window_set_default_size(GTK_WINDOW(fe->window),
                                 x, y + window_extra_height(fe));
 #else
-    fe->drawing_area_shrink_pending = FALSE;
+    fe->drawing_area_shrink_pending = false;
     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
 #endif
 
-    gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0);
+    gtk_box_pack_end(vbox, fe->area, true, true, 0);
 
     clear_backing_store(fe);
     fe->fonts = NULL;
@@ -2877,7 +2909,7 @@ static frontend *new_window(char *arg, int argtype, char **error)
     gtk_widget_show(fe->window);
 
 #if !GTK_CHECK_VERSION(3,0,0)
-    fe->drawing_area_shrink_pending = TRUE;
+    fe->drawing_area_shrink_pending = true;
     try_shrink_drawing_area(fe);
 #endif
 
@@ -2893,7 +2925,7 @@ static void list_presets_from_menu(struct preset_menu *menu)
     for (i = 0; i < menu->n_entries; i++) {
         if (menu->entries[i].params) {
             char *paramstr = thegame.encode_params(
-                menu->entries[i].params, TRUE);
+                menu->entries[i].params, true);
             printf("%s %s\n", paramstr, menu->entries[i].title);
             sfree(paramstr);
         } else {
@@ -2906,16 +2938,17 @@ int main(int argc, char **argv)
 {
     char *pname = argv[0];
     char *error;
-    int ngenerate = 0, print = FALSE, px = 1, py = 1;
-    int time_generation = FALSE, test_solve = FALSE, list_presets = FALSE;
-    int soln = FALSE, colour = FALSE;
+    int ngenerate = 0, px = 1, py = 1;
+    bool print = false;
+    bool time_generation = false, test_solve = false, list_presets = false;
+    bool soln = false, colour = false;
     float scale = 1.0F;
     float redo_proportion = 0.0F;
     const char *savefile = NULL, *savesuffix = NULL;
     char *arg = NULL;
     int argtype = ARG_EITHER;
     char *screenshot_file = NULL;
-    int doing_opts = TRUE;
+    bool doing_opts = true;
     int ac = argc;
     char **av = argv;
     char errbuf[500];
@@ -2961,11 +2994,11 @@ int main(int argc, char **argv)
 	    } else
 		ngenerate = 1;
 	} else if (doing_opts && !strcmp(p, "--time-generation")) {
-            time_generation = TRUE;
+            time_generation = true;
 	} else if (doing_opts && !strcmp(p, "--test-solve")) {
-            test_solve = TRUE;
+            test_solve = true;
 	} else if (doing_opts && !strcmp(p, "--list-presets")) {
-            list_presets = TRUE;
+            list_presets = true;
 	} else if (doing_opts && !strcmp(p, "--save")) {
 	    if (--ac > 0) {
 		savefile = *++av;
@@ -2989,7 +3022,7 @@ int main(int argc, char **argv)
 			pname);
 		return 1;
 	    }
-	    print = TRUE;
+	    print = true;
 	    if (--ac > 0) {
 		char *dim = *++av;
 		if (sscanf(dim, "%dx%d", &px, &py) != 2) {
@@ -3059,20 +3092,20 @@ int main(int argc, char **argv)
 				  !strcmp(p, "--solution") ||
 				  !strcmp(p, "--solns") ||
 				  !strcmp(p, "--soln"))) {
-	    soln = TRUE;
+	    soln = true;
 	} else if (doing_opts && !strcmp(p, "--colour")) {
 	    if (!thegame.can_print_in_colour) {
 		fprintf(stderr, "%s: this game does not support colour"
 			" printing\n", pname);
 		return 1;
 	    }
-	    colour = TRUE;
+	    colour = true;
 	} else if (doing_opts && !strcmp(p, "--load")) {
 	    argtype = ARG_SAVE;
 	} else if (doing_opts && !strcmp(p, "--game")) {
 	    argtype = ARG_ID;
 	} else if (doing_opts && !strcmp(p, "--")) {
-	    doing_opts = FALSE;
+	    doing_opts = false;
 	} else if (!doing_opts || p[0] != '-') {
 	    if (arg) {
 		fprintf(stderr, "%s: more than one argument supplied\n",
@@ -3316,10 +3349,12 @@ int main(int argc, char **argv)
         return 0;
     } else {
 	frontend *fe;
+        bool headless = screenshot_file != NULL;
 
-	gtk_init(&argc, &argv);
+        if (!headless)
+            gtk_init(&argc, &argv);
 
-	fe = new_window(arg, argtype, &error);
+	fe = new_window(arg, argtype, &error, headless);
 
 	if (!fe) {
 	    fprintf(stderr, "%s: %s\n", pname, error);
diff --git a/apps/plugins/puzzles/src/guess.c b/apps/plugins/puzzles/src/guess.c
index 98019d272b..e5ebd5509b 100644
--- a/apps/plugins/puzzles/src/guess.c
+++ b/apps/plugins/puzzles/src/guess.c
@@ -24,7 +24,7 @@ enum {
 
 struct game_params {
     int ncolours, npegs, nguesses;
-    int allow_blank, allow_multiple;
+    bool allow_blank, allow_multiple;
 };
 
 #define FEEDBACK_CORRECTPLACE  1
@@ -39,7 +39,7 @@ typedef struct pegrow {
 struct game_state {
     game_params params;
     pegrow *guesses;  /* length params->nguesses */
-    int *holds;
+    bool *holds;
     pegrow solution;
     int next_go; /* from 0 to nguesses-1;
                     if next_go == nguesses then they've lost. */
@@ -55,8 +55,8 @@ static game_params *default_params(void)
     ret->npegs = 4;
     ret->nguesses = 10;
 
-    ret->allow_blank = 0;
-    ret->allow_multiple = 1;
+    ret->allow_blank = false;
+    ret->allow_multiple = true;
 
     return ret;
 }
@@ -77,15 +77,15 @@ static const struct {
     const char *name;
     game_params params;
 } guess_presets[] = {
-    {"Standard", {6, 4, 10, FALSE, TRUE}},
-    {"Super", {8, 5, 12, FALSE, TRUE}},
+    {"Standard", {6, 4, 10, false, true}},
+    {"Super", {8, 5, 12, false, true}},
 };
 
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     if (i < 0 || i >= lenof(guess_presets))
-        return FALSE;
+        return false;
 
     *name = dupstr(guess_presets[i].name);
     /*
@@ -96,7 +96,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
         *params = dup_params(&tmp);
     }
 
-    return TRUE;
+    return true;
 }
 
 static void decode_params(game_params *params, char const *string)
@@ -124,19 +124,19 @@ static void decode_params(game_params *params, char const *string)
 	    break;
 
         case 'b':
-            params->allow_blank = 1;
+            params->allow_blank = true;
             break;
 
         case 'B':
-            params->allow_blank = 0;
+            params->allow_blank = false;
             break;
 
         case 'm':
-            params->allow_multiple = 1;
+            params->allow_multiple = true;
             break;
 
         case 'M':
-            params->allow_multiple = 0;
+            params->allow_multiple = false;
             break;
 
 	default:
@@ -145,7 +145,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -206,7 +206,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->ncolours < 2 || params->npegs < 2)
 	return "Trivial solutions are uninteresting";
@@ -258,7 +258,7 @@ static void free_pegrow(pegrow pegs)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     unsigned char *bmp = snewn(params->npegs, unsigned char);
     char *ret;
@@ -272,7 +272,7 @@ newcol:
         colcount->pegs[c]++;
         bmp[i] = (unsigned char)(c+1);
     }
-    obfuscate_bitmap(bmp, params->npegs*8, FALSE);
+    obfuscate_bitmap(bmp, params->npegs*8, false);
 
     ret = bin2hex(bmp, params->npegs);
     sfree(bmp);
@@ -291,7 +291,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
     if (strlen(desc) != params->npegs * 2)
         return "Game description is wrong length";
     bmp = hex2bin(desc, params->npegs);
-    obfuscate_bitmap(bmp, params->npegs*8, TRUE);
+    obfuscate_bitmap(bmp, params->npegs*8, true);
     for (i = 0; i < params->npegs; i++) {
         if (bmp[i] < 1 || bmp[i] > params->ncolours) {
             sfree(bmp);
@@ -314,16 +314,16 @@ static game_state *new_game(midend *me, const game_params *params,
     state->guesses = snewn(params->nguesses, pegrow);
     for (i = 0; i < params->nguesses; i++)
 	state->guesses[i] = new_pegrow(params->npegs);
-    state->holds = snewn(params->npegs, int);
+    state->holds = snewn(params->npegs, bool);
     state->solution = new_pegrow(params->npegs);
 
     bmp = hex2bin(desc, params->npegs);
-    obfuscate_bitmap(bmp, params->npegs*8, TRUE);
+    obfuscate_bitmap(bmp, params->npegs*8, true);
     for (i = 0; i < params->npegs; i++)
 	state->solution->pegs[i] = (int)bmp[i];
     sfree(bmp);
 
-    memset(state->holds, 0, sizeof(int) * params->npegs);
+    memset(state->holds, 0, sizeof(bool) * params->npegs);
     state->next_go = state->solved = 0;
 
     return state;
@@ -339,8 +339,8 @@ static game_state *dup_game(const game_state *state)
     ret->guesses = snewn(state->params.nguesses, pegrow);
     for (i = 0; i < state->params.nguesses; i++)
 	ret->guesses[i] = dup_pegrow(state->guesses[i]);
-    ret->holds = snewn(state->params.npegs, int);
-    memcpy(ret->holds, state->holds, sizeof(int) * state->params.npegs);
+    ret->holds = snewn(state->params.npegs, bool);
+    memcpy(ret->holds, state->holds, sizeof(bool) * state->params.npegs);
     ret->solution = dup_pegrow(state->solution);
 
     return ret;
@@ -365,9 +365,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -375,9 +375,10 @@ static char *game_text_format(const game_state *state)
     return NULL;
 }
 
-static int is_markable(const game_params *params, pegrow pegs)
+static bool is_markable(const game_params *params, pegrow pegs)
 {
-    int i, nset = 0, nrequired, ret = 0;
+    int i, nset = 0, nrequired;
+    bool ret = false;
     pegrow colcount = new_pegrow(params->ncolours);
 
     nrequired = params->allow_blank ? 1 : params->npegs;
@@ -396,7 +397,7 @@ static int is_markable(const game_params *params, pegrow pegs)
             if (colcount->pegs[i] > 1) goto done;
         }
     }
-    ret = 1;
+    ret = true;
 done:
     free_pegrow(colcount);
     return ret;
@@ -405,15 +406,15 @@ done:
 struct game_ui {
     game_params params;
     pegrow curr_pegs; /* half-finished current move */
-    int *holds;
+    bool *holds;
     int colour_cur;   /* position of up-down colour picker cursor */
     int peg_cur;      /* position of left-right peg picker cursor */
-    int display_cur, markable;
+    bool display_cur, markable;
 
     int drag_col, drag_x, drag_y; /* x and y are *center* of peg! */
     int drag_opeg; /* peg index, if dragged from a peg (from current guess), otherwise -1 */
 
-    int show_labels;                   /* label the colours with letters */
+    bool show_labels;                   /* label the colours with letters */
     pegrow hint;
 };
 
@@ -423,8 +424,8 @@ static game_ui *new_ui(const game_state *state)
     memset(ui, 0, sizeof(game_ui));
     ui->params = state->params;        /* structure copy */
     ui->curr_pegs = new_pegrow(state->params.npegs);
-    ui->holds = snewn(state->params.npegs, int);
-    memset(ui->holds, 0, sizeof(int)*state->params.npegs);
+    ui->holds = snewn(state->params.npegs, bool);
+    memset(ui->holds, 0, sizeof(bool)*state->params.npegs);
     ui->drag_opeg = -1;
     return ui;
 }
@@ -470,10 +471,10 @@ static void decode_ui(game_ui *ui, const char *encoding)
         while (*p && isdigit((unsigned char)*p)) p++;
         if (*p == '_') {
             /* NB: old versions didn't store holds */
-            ui->holds[i] = 1;
+            ui->holds[i] = true;
             p++;
         } else
-            ui->holds[i] = 0;
+            ui->holds[i] = false;
         if (*p == ',') p++;
     }
     ui->markable = is_markable(&ui->params, ui->curr_pegs);
@@ -494,7 +495,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      * for undo. */
     for (i = 0; i < newstate->solution->npegs; i++) {
         if (newstate->solved)
-            ui->holds[i] = 0;
+            ui->holds[i] = false;
         else
             ui->holds[i] = newstate->holds[i];
 	if (newstate->solved || (newstate->next_go == 0) || !ui->holds[i]) {
@@ -559,7 +560,9 @@ struct game_drawstate {
     int guessx, guessy; /* origin of guesses */
     int solnx, solny;   /* origin of solution */
     int hintw;          /* no. of hint tiles we're wide per row */
-    int w, h, started, solved;
+    int w, h;
+    bool started;
+    int solved;
 
     int next_go;
 
@@ -729,9 +732,9 @@ increase_mincolour:
         for (i = 0; i < state->params.npegs; ++i)
             ui->curr_pegs->pegs[i] = ui->hint->pegs[i];
 
-        ui->markable = TRUE;
+        ui->markable = true;
         ui->peg_cur = state->params.npegs;
-        ui->display_cur = 1;
+        ui->display_cur = true;
         return;
 
     increment_pegrow:
@@ -747,9 +750,9 @@ increase_mincolour:
      * should it ever happen, update the ui in some trivial way.  This gives
      * the user a sense of broken(ish)ness and futility. */
     if (!ui->display_cur) {
-        ui->display_cur = 1;
+        ui->display_cur = true;
     } else if (state->params.npegs == 1) {
-        ui->display_cur = 0;
+        ui->display_cur = false;
     } else {
         ui->peg_cur = (ui->peg_cur + 1) % state->params.npegs;
     }
@@ -763,7 +766,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
     int over_guess = -1;        /* zero-indexed */
     int over_past_guess_y = -1; /* zero-indexed */
     int over_past_guess_x = -1; /* zero-indexed */
-    int over_hint = 0;          /* zero or one */
+    bool over_hint = false;
     char *ret = NULL;
 
     int guess_ox = GUESS_X(from->next_go, 0);
@@ -789,7 +792,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
             over_guess = (x - guess_ox) / PEGOFF;
             assert(over_guess >= 0 && over_guess < ds->solution->npegs);
         } else {
-            over_hint = 1;
+            over_hint = true;
         }
     } else if (x >= guess_ox && x < (guess_ox + GUESS_W) &&
                y >= GUESS_OY && y < guess_oy) {
@@ -852,14 +855,14 @@ static char *interpret_move(const game_state *from, game_ui *ui,
         }
         ui->drag_col = 0;
         ui->drag_opeg = -1;
-        ui->display_cur = 0;
+        ui->display_cur = false;
         debug(("Stop dragging."));
         ret = UI_UPDATE;
     } else if (button == RIGHT_BUTTON) {
         if (over_guess > -1) {
             /* we use ths feedback in the game_ui to signify
              * 'carry this peg to the next guess as well'. */
-            ui->holds[over_guess] = 1 - ui->holds[over_guess];
+            ui->holds[over_guess] ^= 1;
             ret = UI_UPDATE;
         }
     } else if (button == LEFT_RELEASE && over_hint && ui->markable) {
@@ -870,7 +873,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
 
     /* keyboard input */
     if (button == CURSOR_UP || button == CURSOR_DOWN) {
-        ui->display_cur = 1;
+        ui->display_cur = true;
         if (button == CURSOR_DOWN && (ui->colour_cur+1) < from->params.ncolours)
             ui->colour_cur++;
         if (button == CURSOR_UP && ui->colour_cur > 0)
@@ -883,14 +886,14 @@ static char *interpret_move(const game_state *from, game_ui *ui,
         int maxcur = from->params.npegs;
         if (ui->markable) maxcur++;
 
-        ui->display_cur = 1;
+        ui->display_cur = true;
         if (button == CURSOR_RIGHT && (ui->peg_cur+1) < maxcur)
             ui->peg_cur++;
         if (button == CURSOR_LEFT && ui->peg_cur > 0)
             ui->peg_cur--;
         ret = UI_UPDATE;
     } else if (IS_CURSOR_SELECT(button)) {
-        ui->display_cur = 1;
+        ui->display_cur = true;
         if (ui->peg_cur == from->params.npegs) {
             ret = encode_move(from, ui);
         } else {
@@ -898,14 +901,14 @@ static char *interpret_move(const game_state *from, game_ui *ui,
             ret = UI_UPDATE;
         }
     } else if (button == 'D' || button == 'd' || button == '\b') {
-        ui->display_cur = 1;
+        ui->display_cur = true;
         set_peg(&from->params, ui, ui->peg_cur, 0);
         ret = UI_UPDATE;
     } else if (button == CURSOR_SELECT2) {
         if (ui->peg_cur == from->params.npegs)
             return NULL;
-        ui->display_cur = 1;
-        ui->holds[ui->peg_cur] = 1 - ui->holds[ui->peg_cur];
+        ui->display_cur = true;
+        ui->holds[ui->peg_cur] ^= 1;
         ret = UI_UPDATE;
     }
     return ret;
@@ -936,10 +939,10 @@ static game_state *execute_move(const game_state *from, const char *move)
 	    ret->guesses[from->next_go]->pegs[i] = atoi(p);
 	    while (*p && isdigit((unsigned char)*p)) p++;
             if (*p == '_') {
-                ret->holds[i] = 1;
+                ret->holds[i] = true;
                 p++;
             } else
-                ret->holds[i] = 0;
+                ret->holds[i] = false;
 	    if (*p == ',') p++;
 	}
 
@@ -1172,7 +1175,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void draw_peg(drawing *dr, game_drawstate *ds, int cx, int cy,
-		     int moving, int labelled, int col)
+		     bool moving, bool labelled, int col)
 {
     /*
      * Some platforms antialias circles, which means we shouldn't
@@ -1210,8 +1213,8 @@ static void draw_cursor(drawing *dr, game_drawstate *ds, int x, int y)
 }
 
 static void guess_redraw(drawing *dr, game_drawstate *ds, int guess,
-                         pegrow src, int *holds, int cur_col, int force,
-                         int labelled)
+                         pegrow src, bool *holds, int cur_col, bool force,
+                         bool labelled)
 {
     pegrow dest;
     int rowx, rowy, i, scol;
@@ -1236,7 +1239,7 @@ static void guess_redraw(drawing *dr, game_drawstate *ds, int guess,
         if (labelled)
             scol |= 0x4000;
         if ((dest->pegs[i] != scol) || force) {
-	    draw_peg(dr, ds, rowx + PEGOFF * i, rowy, FALSE, labelled,
+	    draw_peg(dr, ds, rowx + PEGOFF * i, rowy, false, labelled,
                      scol &~ 0x7000);
             /*
              * Hold marker.
@@ -1253,11 +1256,11 @@ static void guess_redraw(drawing *dr, game_drawstate *ds, int guess,
 }
 
 static void hint_redraw(drawing *dr, game_drawstate *ds, int guess,
-                        pegrow src, int force, int cursor, int markable)
+                        pegrow src, bool force, bool cursor, bool markable)
 {
     pegrow dest = ds->guesses[guess];
     int rowx, rowy, i, scol, col, hintlen;
-    int need_redraw;
+    bool need_redraw;
     int emptycol = (markable ? COL_FLASH : COL_EMPTY);
 
     if (src) assert(src->npegs == dest->npegs);
@@ -1268,7 +1271,7 @@ static void hint_redraw(drawing *dr, game_drawstate *ds, int guess,
      * Because of the possible presence of the cursor around this
      * entire section, we redraw all or none of it but never part.
      */
-    need_redraw = FALSE;
+    need_redraw = false;
 
     for (i = 0; i < dest->npegs; i++) {
         scol = src ? src->feedback[i] : 0;
@@ -1277,7 +1280,7 @@ static void hint_redraw(drawing *dr, game_drawstate *ds, int guess,
         if (i == 0 && markable)
             scol |= 0x2000;
         if ((scol != dest->feedback[i]) || force) {
-            need_redraw = TRUE;
+            need_redraw = true;
         }
         dest->feedback[i] = scol;
     }
@@ -1340,7 +1343,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int i, new_move;
+    int i;
+    bool new_move;
 
     new_move = (state->next_go != ds->next_go) || !ds->started;
 
@@ -1364,7 +1368,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         if (ui->show_labels)
             val |= 0x2000;
         if (ds->colours->pegs[i] != val) {
-	    draw_peg(dr, ds, COL_X(i), COL_Y(i), FALSE, ui->show_labels, i+1);
+	    draw_peg(dr, ds, COL_X(i), COL_Y(i), false, ui->show_labels, i+1);
             if (val & 0x1000)
                 draw_cursor(dr, ds, COL_X(i), COL_Y(i));
             ds->colours->pegs[i] = val;
@@ -1377,23 +1381,23 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     for (i = state->params.nguesses - 1; i >= 0; i--) {
         if (i < state->next_go || state->solved) {
             /* this info is stored in the game_state already */
-            guess_redraw(dr, ds, i, state->guesses[i], NULL, -1, 0,
+            guess_redraw(dr, ds, i, state->guesses[i], NULL, -1, false,
                          ui->show_labels);
             hint_redraw(dr, ds, i, state->guesses[i],
-                        i == (state->next_go-1) ? 1 : 0, FALSE, FALSE);
+                        i == (state->next_go-1), false, false);
         } else if (i > state->next_go) {
             /* we've not got here yet; it's blank. */
-            guess_redraw(dr, ds, i, NULL, NULL, -1, 0, ui->show_labels);
-            hint_redraw(dr, ds, i, NULL, 0, FALSE, FALSE);
+            guess_redraw(dr, ds, i, NULL, NULL, -1, false, ui->show_labels);
+            hint_redraw(dr, ds, i, NULL, false, false, false);
         }
     }
     if (!state->solved) {
 	/* this is the one we're on; the (incomplete) guess is stored in
 	 * the game_ui. */
 	guess_redraw(dr, ds, state->next_go, ui->curr_pegs,
-		     ui->holds, ui->display_cur ? ui->peg_cur : -1, 0,
+		     ui->holds, ui->display_cur ? ui->peg_cur : -1, false,
 		     ui->show_labels);
-	hint_redraw(dr, ds, state->next_go, NULL, 1,
+	hint_redraw(dr, ds, state->next_go, NULL, true,
 		    ui->display_cur && ui->peg_cur == state->params.npegs,
 		    ui->markable);
     }
@@ -1425,11 +1429,11 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         ds->blit_ox = ox - 1; ds->blit_oy = oy - 1;
         debug(("Saving to blitter at (%d,%d)", ds->blit_ox, ds->blit_oy));
         blitter_save(dr, ds->blit_peg, ds->blit_ox, ds->blit_oy);
-        draw_peg(dr, ds, ox, oy, TRUE, ui->show_labels, ui->drag_col);
+        draw_peg(dr, ds, ox, oy, true, ui->show_labels, ui->drag_col);
     }
     ds->drag_col = ui->drag_col;
 
-    ds->started = 1;
+    ds->started = true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -1455,9 +1459,9 @@ static int game_status(const game_state *state)
     return state->solved;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1480,15 +1484,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1505,9 +1509,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/html/rect.html b/apps/plugins/puzzles/src/html/rect.html
index d23d827663..4cd22db70c 100644
--- a/apps/plugins/puzzles/src/html/rect.html
+++ b/apps/plugins/puzzles/src/html/rect.html
@@ -1,4 +1,4 @@
-docname=rectangles:Rectangles
+docname=rect:Rectangles
 <p>
 Draw lines along the grid edges to divide the grid into rectangles,
 so that each rectangle contains exactly one numbered square and its
diff --git a/apps/plugins/puzzles/src/inertia.c b/apps/plugins/puzzles/src/inertia.c
index 8206d00e79..838f8dee96 100644
--- a/apps/plugins/puzzles/src/inertia.c
+++ b/apps/plugins/puzzles/src/inertia.c
@@ -77,8 +77,8 @@ struct game_state {
     int gems;
     char *grid;
     int distance_moved;
-    int dead;
-    int cheated;
+    bool dead;
+    bool cheated;
     int solnpos;
     soln *soln;
 };
@@ -120,14 +120,14 @@ static const struct game_params inertia_presets[] = {
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+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(inertia_presets))
-	return FALSE;
+	return false;
 
     p = inertia_presets[i];
     ret = dup_params(&p);
@@ -136,7 +136,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *params = ret;
     *name = retname;
-    return TRUE;
+    return true;
 }
 
 static void decode_params(game_params *params, char const *string)
@@ -149,7 +149,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -191,7 +191,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Avoid completely degenerate cases which only have one
@@ -220,7 +220,7 @@ static const char *validate_params(const game_params *params, int full)
  */
 
 struct solver_scratch {
-    unsigned char *reachable_from, *reachable_to;
+    bool *reachable_from, *reachable_to;
     int *positions;
 };
 
@@ -228,8 +228,8 @@ static struct solver_scratch *new_scratch(int w, int h)
 {
     struct solver_scratch *sc = snew(struct solver_scratch);
 
-    sc->reachable_from = snewn(w * h * DIRECTIONS, unsigned char);
-    sc->reachable_to = snewn(w * h * DIRECTIONS, unsigned char);
+    sc->reachable_from = snewn(w * h * DIRECTIONS, bool);
+    sc->reachable_to = snewn(w * h * DIRECTIONS, bool);
     sc->positions = snewn(w * h * DIRECTIONS, int);
 
     return sc;
@@ -243,11 +243,11 @@ static void free_scratch(struct solver_scratch *sc)
     sfree(sc);
 }
 
-static int can_go(int w, int h, char *grid,
-		  int x1, int y1, int dir1, int x2, int y2, int dir2)
+static bool can_go(int w, int h, char *grid,
+                   int x1, int y1, int dir1, int x2, int y2, int dir2)
 {
     /*
-     * Returns TRUE if we can transition directly from (x1,y1)
+     * Returns true if we can transition directly from (x1,y1)
      * going in direction dir1, to (x2,y2) going in direction dir2.
      */
 
@@ -257,7 +257,7 @@ static int can_go(int w, int h, char *grid,
      */
     if (AT(w, h, grid, x1, y1) == WALL ||
 	AT(w, h, grid, x1, y1) == MINE)
-	return FALSE;
+	return false;
 
     /*
      * If a move is capable of stopping at x1,y1,dir1, and x2,y2 is
@@ -271,7 +271,7 @@ static int can_go(int w, int h, char *grid,
 	(AT(w, h, grid, x1, y1) == STOP ||
 	 AT(w, h, grid, x1, y1) == START ||
 	 AT(w, h, grid, x1+DX(dir1), y1+DY(dir1)) == WALL))
-	return TRUE;
+	return true;
 
     /*
      * If a move is capable of continuing here, then x1,y1,dir1 can
@@ -282,12 +282,12 @@ static int can_go(int w, int h, char *grid,
 	 AT(w, h, grid, x2, y2) == GEM ||
 	 AT(w, h, grid, x2, y2) == STOP ||
 	 AT(w, h, grid, x2, y2) == START))
-	return TRUE;
+	return true;
 
     /*
      * That's it.
      */
-    return FALSE;
+    return false;
 }
 
 static int find_gem_candidates(int w, int h, char *grid,
@@ -317,8 +317,8 @@ static int find_gem_candidates(int w, int h, char *grid,
      * flags set.
      */
 
-    memset(sc->reachable_from, 0, wh * DIRECTIONS);
-    memset(sc->reachable_to, 0, wh * DIRECTIONS);
+    memset(sc->reachable_from, 0, wh * DIRECTIONS * sizeof(bool));
+    memset(sc->reachable_to, 0, wh * DIRECTIONS * sizeof(bool));
 
     /*
      * Find the starting square.
@@ -334,8 +334,7 @@ static int find_gem_candidates(int w, int h, char *grid,
     assert(sy < h);
 
     for (pass = 0; pass < 2; pass++) {
-	unsigned char *reachable = (pass == 0 ? sc->reachable_from :
-				    sc->reachable_to);
+	bool *reachable = (pass == 0 ? sc->reachable_from : sc->reachable_to);
 	int sign = (pass == 0 ? +1 : -1);
 	int dir;
 
@@ -351,7 +350,7 @@ static int find_gem_candidates(int w, int h, char *grid,
 	for (dir = 0; dir < DIRECTIONS; dir++) {
 	    int index = (sy*w+sx)*DIRECTIONS+dir;
 	    sc->positions[tail++] = index;
-	    reachable[index] = TRUE;
+	    reachable[index] = true;
 #ifdef SOLVER_DIAGNOSTICS
 	    printf("starting point %d,%d,%d\n", sx, sy, dir);
 #endif
@@ -392,7 +391,7 @@ static int find_gem_candidates(int w, int h, char *grid,
 		if (x2 >= 0 && x2 < w &&
 		    y2 >= 0 && y2 < h &&
 		    !reachable[i2]) {
-		    int ok;
+		    bool ok;
 #ifdef SOLVER_DIAGNOSTICS
 		    printf("  trying point %d,%d,%d", x2, y2, d2);
 #endif
@@ -405,7 +404,7 @@ static int find_gem_candidates(int w, int h, char *grid,
 #endif
 		    if (ok) {
 			sc->positions[tail++] = i2;
-			reachable[i2] = TRUE;
+			reachable[i2] = true;
 		    }
 		}
 	    }
@@ -580,7 +579,7 @@ static char *gengrid(int w, int h, random_state *rs)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     return gengrid(params->w, params->h, rs);
 }
@@ -642,9 +641,9 @@ static game_state *new_game(midend *me, const game_params *params,
     assert(state->px >= 0 && state->py >= 0);
 
     state->distance_moved = 0;
-    state->dead = FALSE;
+    state->dead = false;
 
-    state->cheated = FALSE;
+    state->cheated = false;
     state->solnpos = 0;
     state->soln = NULL;
 
@@ -662,7 +661,7 @@ static game_state *dup_game(const game_state *state)
     ret->gems = state->gems;
     ret->grid = snewn(wh, char);
     ret->distance_moved = state->distance_moved;
-    ret->dead = FALSE;
+    ret->dead = false;
     memcpy(ret->grid, state->grid, wh);
     ret->cheated = state->cheated;
     ret->soln = state->soln;
@@ -892,10 +891,10 @@ static char *solve_game(const game_state *state, const game_state *currstate,
      */
     unvisited = snewn(wh, int);
     for (i = 0; i < wh; i++)
-	unvisited[i] = FALSE;
+	unvisited[i] = false;
     for (i = 0; i < wh; i++)
 	if (currstate->grid[i] == GEM)
-	    unvisited[i] = TRUE;
+	    unvisited[i] = true;
 
     /*
      * Allocate space for doing bfses inside the main loop.
@@ -1175,7 +1174,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 	for (i = n1; i <= n2; i++) {
 	    int pos = nodes[circuit[i]] / DP1;
 	    assert(pos >= 0 && pos < wh);
-	    unvisited[pos] = FALSE;
+	    unvisited[pos] = false;
 	}
     }
 
@@ -1443,9 +1442,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return soln;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1491,8 +1490,8 @@ struct game_ui {
     float anim_length;
     int flashtype;
     int deaths;
-    int just_made_move;
-    int just_died;
+    bool just_made_move;
+    bool just_died;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1501,8 +1500,8 @@ static game_ui *new_ui(const game_state *state)
     ui->anim_length = 0.0F;
     ui->flashtype = 0;
     ui->deaths = 0;
-    ui->just_made_move = FALSE;
-    ui->just_died = FALSE;
+    ui->just_made_move = false;
+    ui->just_died = false;
     return ui;
 }
 
@@ -1539,20 +1538,21 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
     if (!oldstate->dead && newstate->dead && ui->just_made_move &&
 	oldstate->gems) {
 	ui->deaths++;
-	ui->just_died = TRUE;
+	ui->just_died = true;
     } else {
-	ui->just_died = FALSE;
+	ui->just_died = false;
     }
-    ui->just_made_move = FALSE;
+    ui->just_made_move = false;
 }
 
 struct game_drawstate {
     game_params p;
     int tilesize;
-    int started;
+    bool started;
     unsigned short *grid;
     blitter *player_background;
-    int player_bg_saved, pbgx, pbgy;
+    bool player_bg_saved;
+    int pbgx, pbgy;
 };
 
 #define PREFERRED_TILESIZE 32
@@ -1637,7 +1637,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
      * Otherwise, we can make the move. All we need to specify is
      * the direction.
      */
-    ui->just_made_move = TRUE;
+    ui->just_made_move = true;
     sprintf(buf, "%d", dir);
     return dupstr(buf);
 }
@@ -1662,7 +1662,7 @@ static void install_new_solution(game_state *ret, const char *move)
     ret->soln = sol;
     sol->refcount = 1;
 
-    ret->cheated = TRUE;
+    ret->cheated = true;
     ret->solnpos = 0;
 }
 
@@ -1716,7 +1716,7 @@ static game_state *execute_move(const game_state *state, const char *move)
 	}
 
 	if (AT(w, h, ret->grid, ret->px, ret->py) == MINE) {
-	    ret->dead = TRUE;
+	    ret->dead = true;
 	    break;
 	}
 
@@ -1823,11 +1823,11 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     /* We can't allocate the blitter rectangle for the player background
      * until we know what size to make it. */
     ds->player_background = NULL;
-    ds->player_bg_saved = FALSE;
+    ds->player_bg_saved = false;
     ds->pbgx = ds->pbgy = -1;
 
     ds->p = state->p;		       /* structure copy */
-    ds->started = FALSE;
+    ds->started = false;
     ds->grid = snewn(wh, unsigned short);
     for (i = 0; i < wh; i++)
 	ds->grid[i] = UNDRAWN;
@@ -1844,7 +1844,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void draw_player(drawing *dr, game_drawstate *ds, int x, int y,
-			int dead, int hintdir)
+			bool dead, int hintdir)
 {
     if (dead) {
 	int coords[DIRECTIONS*4];
@@ -2006,7 +2006,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	assert(ds->player_background);
         blitter_load(dr, ds->player_background, ds->pbgx, ds->pbgy);
         draw_update(dr, ds->pbgx, ds->pbgy, TILESIZE, TILESIZE);
-	ds->player_bg_saved = FALSE;
+	ds->player_bg_saved = false;
     }
 
     /*
@@ -2032,7 +2032,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	    draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h),
 		      COL_LOWLIGHT);
 
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     /*
@@ -2158,7 +2158,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 		(state->dead && !oldstate),
 		(!oldstate && state->soln ?
 		 state->soln->list[state->solnpos] : -1));
-    ds->player_bg_saved = TRUE;
+    ds->player_bg_saved = true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -2196,9 +2196,9 @@ static int game_status(const game_state *state)
     return state->gems == 0 ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2221,15 +2221,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2246,8 +2246,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/keen.c b/apps/plugins/puzzles/src/keen.c
index 423ec8c446..baa1d81802 100644
--- a/apps/plugins/puzzles/src/keen.c
+++ b/apps/plugins/puzzles/src/keen.c
@@ -62,7 +62,8 @@ enum {
 };
 
 struct game_params {
-    int w, diff, multiplication_only;
+    int w, diff;
+    bool multiplication_only;
 };
 
 struct clues {
@@ -77,7 +78,7 @@ struct game_state {
     struct clues *clues;
     digit *grid;
     int *pencil;		       /* bitmaps using bits 1<<1..1<<n */
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -86,31 +87,31 @@ static game_params *default_params(void)
 
     ret->w = 6;
     ret->diff = DIFF_NORMAL;
-    ret->multiplication_only = FALSE;
+    ret->multiplication_only = false;
 
     return ret;
 }
 
 static const struct game_params keen_presets[] = {
-    {  4, DIFF_EASY,         FALSE },
-    {  5, DIFF_EASY,         FALSE },
-    {  5, DIFF_EASY,         TRUE  },
-    {  6, DIFF_EASY,         FALSE },
-    {  6, DIFF_NORMAL,       FALSE },
-    {  6, DIFF_NORMAL,       TRUE  },
-    {  6, DIFF_HARD,         FALSE },
-    {  6, DIFF_EXTREME,      FALSE },
-    {  6, DIFF_UNREASONABLE, FALSE },
-    {  9, DIFF_NORMAL,       FALSE },
+    {  4, DIFF_EASY,         false },
+    {  5, DIFF_EASY,         false },
+    {  5, DIFF_EASY,         true  },
+    {  6, DIFF_EASY,         false },
+    {  6, DIFF_NORMAL,       false },
+    {  6, DIFF_NORMAL,       true  },
+    {  6, DIFF_HARD,         false },
+    {  6, DIFF_EXTREME,      false },
+    {  6, DIFF_UNREASONABLE, false },
+    {  9, DIFF_NORMAL,       false },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(keen_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = keen_presets[i]; /* structure copy */
@@ -120,7 +121,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -157,11 +158,11 @@ static void decode_params(game_params *params, char const *string)
 
     if (*p == 'm') {
 	p++;
-	params->multiplication_only = TRUE;
+	params->multiplication_only = true;
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -211,7 +212,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->w > 9)
         return "Grid size must be between 3 and 9";
@@ -673,10 +674,11 @@ static char *encode_block_structure(char *p, int w, int *dsf)
      * means 26, zb 27 etc).
      */
     for (i = 0; i <= 2*w*(w-1); i++) {
-	int x, y, p0, p1, edge;
+	int x, y, p0, p1;
+        bool edge;
 
 	if (i == 2*w*(w-1)) {
-	    edge = TRUE;       /* terminating virtual edge */
+	    edge = true;       /* terminating virtual edge */
 	} else {
 	    if (i < w*(w-1)) {
 		y = i/(w-1);
@@ -736,7 +738,8 @@ static const char *parse_block_structure(const char **p, int w, int *dsf)
     dsf_init(dsf, a);
 
     while (**p && (repn > 0 || **p != ',')) {
-	int c, adv;
+	int c;
+        bool adv;
 
 	if (repn > 0) {
 	    repn--;
@@ -797,7 +800,7 @@ static const char *parse_block_structure(const char **p, int w, int *dsf)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln;
@@ -864,7 +867,7 @@ done
 	    revorder[order[i]] = i;
 
 	for (i = 0; i < a; i++)
-	    singletons[i] = TRUE;
+	    singletons[i] = true;
 
 	dsf_init(dsf, a);
 
@@ -897,7 +900,7 @@ done
 		 * shapes.
 		 */
 		if (best >= 0 && random_upto(rs, 4)) {
-		    singletons[i] = singletons[best] = FALSE;
+		    singletons[i] = singletons[best] = false;
 		    dsf_merge(dsf, i, best);
 		}
 	    }
@@ -925,7 +928,7 @@ done
 		    best = i+w;
 
 		if (best >= 0) {
-		    singletons[i] = singletons[best] = FALSE;
+		    singletons[i] = singletons[best] = false;
 		    dsf_merge(dsf, i, best);
 		}
 	    }
@@ -1040,7 +1043,7 @@ done
 	for (i = 0; i < a; i++)
 	    clues[i] = 0;
 	while (1) {
-	    int done_something = FALSE;
+	    bool done_something = false;
 
 	    for (k = 0; k < 4; k++) {
 		long clue;
@@ -1073,7 +1076,7 @@ done
 		    }
 		}
 		if (i < a)
-		    done_something = TRUE;
+		    done_something = true;
 	    }
 
 	    if (!done_something)
@@ -1327,7 +1330,8 @@ static game_state *new_game(midend *me, const game_params *params,
 	state->pencil[i] = 0;
     }
 
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     return state;
 }
@@ -1400,9 +1404,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1413,28 +1417,28 @@ static char *game_text_format(const game_state *state)
 struct game_ui {
     /*
      * These are the coordinates of the currently highlighted
-     * square on the grid, if hshow = 1.
+     * square on the grid, if hshow is true.
      */
     int hx, hy;
     /*
      * This indicates whether the current highlight is a
      * pencil-mark one or a real one.
      */
-    int hpencil;
+    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.
+     * fixed position. When true, pressing a valid number or letter
+     * key or Space will enter that number or letter in the grid.
      */
-    int hshow;
+    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.
      */
-    int hcursor;
+    bool hcursor;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1442,7 +1446,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
 
     return ui;
 }
@@ -1473,7 +1479,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      */
     if (ui->hshow && ui->hpencil && !ui->hcursor &&
         newstate->grid[ui->hy * w + ui->hx] != 0) {
-        ui->hshow = 0;
+        ui->hshow = false;
     }
 }
 
@@ -1495,26 +1501,27 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
 struct game_drawstate {
     int tilesize;
-    int started;
+    bool started;
     long *tiles;
     long *errors;
     char *minus_sign, *times_sign, *divide_sign;
 };
 
-static int check_errors(const game_state *state, long *errors)
+static bool check_errors(const game_state *state, long *errors)
 {
     int w = state->par.w, a = w*w;
-    int i, j, x, y, errs = FALSE;
+    int i, j, x, y;
+    bool errs = false;
     long *cluevals;
-    int *full;
+    bool *full;
 
     cluevals = snewn(a, long);
-    full = snewn(a, int);
+    full = snewn(a, bool);
 
     if (errors)
 	for (i = 0; i < a; i++) {
 	    errors[i] = 0;
-	    full[i] = TRUE;
+	    full[i] = true;
 	}
 
     for (i = 0; i < a; i++) {
@@ -1550,14 +1557,14 @@ static int check_errors(const game_state *state, long *errors)
 	}
 
 	if (!state->grid[i])
-	    full[j] = FALSE;
+	    full[j] = false;
     }
 
     for (i = 0; i < a; i++) {
 	j = dsf_canonify(state->clues->dsf, i);
 	if (j == i) {
 	    if ((state->clues->clues[j] & ~CMASK) != cluevals[i]) {
-		errs = TRUE;
+		errs = true;
 		if (errors && full[j])
 		    errors[j] |= DF_ERR_CLUE;
 	    }
@@ -1576,7 +1583,7 @@ static int check_errors(const game_state *state, long *errors)
 	}
 
 	if (mask != (1 << (w+1)) - (1 << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1;
 	    if (errors) {
 		for (x = 0; x < w; x++)
@@ -1595,7 +1602,7 @@ static int check_errors(const game_state *state, long *errors)
 	}
 
 	if (mask != (1 << (w+1)) - (1 << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1;
 	    if (errors) {
 		for (y = 0; y < w; y++)
@@ -1624,15 +1631,15 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
         if (button == LEFT_BUTTON) {
 	    if (tx == ui->hx && ty == ui->hy &&
-		ui->hshow && ui->hpencil == 0) {
-                ui->hshow = 0;
+		ui->hshow && !ui->hpencil) {
+                ui->hshow = false;
             } else {
                 ui->hx = tx;
                 ui->hy = ty;
-                ui->hshow = 1;
-                ui->hpencil = 0;
+                ui->hshow = true;
+                ui->hpencil = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
         if (button == RIGHT_BUTTON) {
@@ -1642,29 +1649,30 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             if (state->grid[ty*w+tx] == 0) {
                 if (tx == ui->hx && ty == ui->hy &&
                     ui->hshow && ui->hpencil) {
-                    ui->hshow = 0;
+                    ui->hshow = false;
                 } else {
-                    ui->hpencil = 1;
+                    ui->hpencil = true;
                     ui->hx = tx;
                     ui->hy = ty;
-                    ui->hshow = 1;
+                    ui->hshow = true;
                 }
             } else {
-                ui->hshow = 0;
+                ui->hshow = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
     }
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
-        ui->hshow = ui->hcursor = 1;
+        move_cursor(button, &ui->hx, &ui->hy, w, w, false);
+        ui->hshow = true;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
     if (ui->hshow &&
         (button == CURSOR_SELECT)) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil ^= 1;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
@@ -1685,7 +1693,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	sprintf(buf, "%c%d,%d,%d",
 		(char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
 
-        if (!ui->hcursor) ui->hshow = 0;
+        if (!ui->hcursor) ui->hshow = false;
 
 	return dupstr(buf);
     }
@@ -1704,7 +1712,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 
     if (move[0] == 'S') {
 	ret = dup_game(from);
-	ret->completed = ret->cheated = TRUE;
+	ret->completed = ret->cheated = true;
 
 	for (i = 0; i < a; i++) {
 	    if (move[i+1] < '1' || move[i+1] > '0'+w) {
@@ -1733,7 +1741,7 @@ static game_state *execute_move(const game_state *from, const char *move)
             ret->pencil[y*w+x] = 0;
 
             if (!ret->completed && !check_errors(ret, NULL))
-                ret->completed = TRUE;
+                ret->completed = true;
         }
 	return ret;
     } else if (move[0] == 'M') {
@@ -1816,7 +1824,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->tilesize = 0;
-    ds->started = FALSE;
+    ds->started = false;
     ds->tiles = snewn(a, long);
     for (i = 0; i < a; i++)
 	ds->tiles[i] = -1;
@@ -1839,7 +1847,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void draw_tile(drawing *dr, game_drawstate *ds, struct clues *clues,
-		      int x, int y, long tile, int only_one_op)
+		      int x, int y, long tile, bool only_one_op)
 {
     int w = clues->w /* , a = w*w */;
     int tx, ty, tw, th;
@@ -2056,7 +2064,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
 	draw_update(dr, 0, 0, SIZE(w), SIZE(w));
 
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     check_errors(state, ds->errors);
@@ -2109,11 +2117,11 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
-	return FALSE;
-    return TRUE;
+	return false;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2362,15 +2370,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2387,9 +2395,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
 };
 
@@ -2403,15 +2411,16 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
-    int ret, diff, really_show_working = FALSE;
+    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;
+            really_show_working = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
@@ -2447,7 +2456,7 @@ int main(int argc, char **argv)
      * the puzzle internally before doing anything else.
      */
     ret = -1;			       /* placate optimiser */
-    solver_show_working = FALSE;
+    solver_show_working = 0;
     for (diff = 0; diff < DIFFCOUNT; diff++) {
 	memset(s->grid, 0, p->w * p->w);
 	ret = solver(p->w, s->clues->dsf, s->clues->clues,
@@ -2468,7 +2477,7 @@ int main(int argc, char **argv)
 	    else
 		printf("Difficulty rating: %s\n", keen_diffnames[ret]);
 	} else {
-	    solver_show_working = really_show_working;
+	    solver_show_working = really_show_working ? 1 : 0;
 	    memset(s->grid, 0, p->w * p->w);
 	    ret = solver(p->w, s->clues->dsf, s->clues->clues,
 			 s->grid, diff);
diff --git a/apps/plugins/puzzles/src/latin.c b/apps/plugins/puzzles/src/latin.c
index 6e805455bf..9d06ccd938 100644
--- a/apps/plugins/puzzles/src/latin.c
+++ b/apps/plugins/puzzles/src/latin.c
@@ -43,21 +43,21 @@ void latin_solver_place(struct latin_solver *solver, int x, int y, int n)
      */
     for (i = 1; i <= o; i++)
 	if (i != n)
-            cube(x,y,i) = FALSE;
+            cube(x,y,i) = false;
 
     /*
      * Rule out this number in all other positions in the row.
      */
     for (i = 0; i < o; i++)
 	if (i != y)
-            cube(x,i,n) = FALSE;
+            cube(x,i,n) = false;
 
     /*
      * Rule out this number in all other positions in the column.
      */
     for (i = 0; i < o; i++)
 	if (i != x)
-            cube(i,y,n) = FALSE;
+            cube(i,y,n) = false;
 
     /*
      * Enter the number in the result grid.
@@ -68,7 +68,7 @@ void latin_solver_place(struct latin_solver *solver, int x, int y, int n)
      * Cross out this number from the list of numbers left to place
      * in its row, its column and its block.
      */
-    solver->row[y*o+n-1] = solver->col[x*o+n-1] = TRUE;
+    solver->row[y*o+n-1] = solver->col[x*o+n-1] = true;
 }
 
 int latin_solver_elim(struct latin_solver *solver, int start, int step
@@ -170,8 +170,8 @@ int latin_solver_set(struct latin_solver *solver,
      * any row with a solitary 1 - and discarding that row and the
      * column containing the 1.
      */
-    memset(rowidx, TRUE, o);
-    memset(colidx, TRUE, o);
+    memset(rowidx, true, o);
+    memset(colidx, true, o);
     for (i = 0; i < o; i++) {
         int count = 0, first = -1;
         for (j = 0; j < o; j++)
@@ -180,7 +180,7 @@ int latin_solver_set(struct latin_solver *solver,
 
 	if (count == 0) return -1;
         if (count == 1)
-            rowidx[i] = colidx[first] = FALSE;
+            rowidx[i] = colidx[first] = false;
     }
 
     /*
@@ -226,10 +226,10 @@ int latin_solver_set(struct latin_solver *solver,
              */
             int rows = 0;
             for (i = 0; i < n; i++) {
-                int ok = TRUE;
+                bool ok = true;
                 for (j = 0; j < n; j++)
                     if (set[j] && grid[i*o+j]) {
-                        ok = FALSE;
+                        ok = false;
                         break;
                     }
                 if (ok)
@@ -261,7 +261,7 @@ int latin_solver_set(struct latin_solver *solver,
 	    }
 
             if (rows >= n - count) {
-                int progress = FALSE;
+                bool progress = false;
 
                 /*
                  * We've got one! Now, for each row which _doesn't_
@@ -275,10 +275,10 @@ int latin_solver_set(struct latin_solver *solver,
                  * positions in the cube to meddle with.
                  */
                 for (i = 0; i < n; i++) {
-                    int ok = TRUE;
+                    bool ok = true;
                     for (j = 0; j < n; j++)
                         if (set[j] && grid[i*o+j]) {
-                            ok = FALSE;
+                            ok = false;
                             break;
                         }
                     if (!ok) {
@@ -310,8 +310,8 @@ int latin_solver_set(struct latin_solver *solver,
                                            names[pn-1], px+1, py+1);
                                 }
 #endif
-                                progress = TRUE;
-                                solver->cube[fpos] = FALSE;
+                                progress = true;
+                                solver->cube[fpos] = false;
                             }
                     }
                 }
@@ -522,7 +522,7 @@ int latin_solver_forcing(struct latin_solver *solver,
 					   xt+1, yt+1);
                                 }
 #endif
-                                cube(xt, yt, orign) = FALSE;
+                                cube(xt, yt, orign) = false;
                                 return 1;
                             }
                         }
@@ -570,12 +570,12 @@ void latin_solver_alloc(struct latin_solver *solver, digit *grid, int o)
     solver->o = o;
     solver->cube = snewn(o*o*o, unsigned char);
     solver->grid = grid;		/* write straight back to the input */
-    memset(solver->cube, TRUE, o*o*o);
+    memset(solver->cube, 1, o*o*o);
 
     solver->row = snewn(o*o, unsigned char);
     solver->col = snewn(o*o, unsigned char);
-    memset(solver->row, FALSE, o*o);
-    memset(solver->col, FALSE, o*o);
+    memset(solver->row, 0, o*o);
+    memset(solver->col, 0, o*o);
 
     for (x = 0; x < o; x++)
 	for (y = 0; y < o; y++)
@@ -650,7 +650,7 @@ int latin_solver_diff_simple(struct latin_solver *solver)
 
 int latin_solver_diff_set(struct latin_solver *solver,
                           struct latin_solver_scratch *scratch,
-                          int extreme)
+                          bool extreme)
 {
     int x, y, n, ret, o = solver->o;
 #ifdef STANDALONE_SOLVER
@@ -908,9 +908,9 @@ static int latin_solver_top(struct latin_solver *solver, int maxdiff,
 	    if (ret == 0 && i == diff_simple)
 		ret = latin_solver_diff_simple(solver);
 	    if (ret == 0 && i == diff_set_0)
-		ret = latin_solver_diff_set(solver, scratch, 0);
+		ret = latin_solver_diff_set(solver, scratch, false);
 	    if (ret == 0 && i == diff_set_1)
-		ret = latin_solver_diff_set(solver, scratch, 1);
+		ret = latin_solver_diff_set(solver, scratch, true);
 	    if (ret == 0 && i == diff_forcing)
 		ret = latin_solver_forcing(solver, scratch);
 
@@ -1244,12 +1244,12 @@ static int latin_check_cmp(void *v1, void *v2)
 
 #define ELT(sq,x,y) (sq[((y)*order)+(x)])
 
-/* returns non-zero if sq is not a latin square. */
-int latin_check(digit *sq, int order)
+/* returns true if sq is not a latin square. */
+bool latin_check(digit *sq, int order)
 {
     tree234 *dict = newtree234(latin_check_cmp);
     int c, r;
-    int ret = 0;
+    bool ret = false;
     lcparams *lcp, lc, *aret;
 
     /* Use a tree234 as a simple hash table, go through the square
@@ -1272,10 +1272,10 @@ int latin_check(digit *sq, int order)
 
     /* There should be precisely 'order' letters in the alphabet,
      * each occurring 'order' times (making the OxO tree) */
-    if (count234(dict) != order) ret = 1;
+    if (count234(dict) != order) ret = true;
     else {
 	for (c = 0; (lcp = index234(dict, c)) != NULL; c++) {
-	    if (lcp->count != order) ret = 1;
+	    if (lcp->count != order) ret = true;
 	}
     }
     for (c = 0; (lcp = index234(dict, c)) != NULL; c++)
diff --git a/apps/plugins/puzzles/src/latin.h b/apps/plugins/puzzles/src/latin.h
index e13050e9a8..ff6f07c922 100644
--- a/apps/plugins/puzzles/src/latin.h
+++ b/apps/plugins/puzzles/src/latin.h
@@ -14,11 +14,11 @@ extern int solver_show_working, solver_recurse_depth;
 struct latin_solver {
   int o;                /* order of latin square */
   unsigned char *cube;  /* o^3, indexed by x, y, and digit:
-                           TRUE in that position indicates a possibility */
+                           true in that position indicates a possibility */
   digit *grid;          /* o^2, indexed by x and y: for final deductions */
 
-  unsigned char *row;   /* o^2: row[y*cr+n-1] TRUE if n is in row y */
-  unsigned char *col;   /* o^2: col[x*cr+n-1] TRUE if n is in col x */
+  unsigned char *row;   /* o^2: row[y*cr+n-1] true if n is in row y */
+  unsigned char *col;   /* o^2: col[x*cr+n-1] true if n is in col x */
 
 #ifdef STANDALONE_SOLVER
   char **names;         /* o: names[n-1] gives name of 'digit' n */
@@ -78,11 +78,11 @@ void latin_solver_free_scratch(struct latin_solver_scratch *scratch);
 /* Looped positional elimination */
 int latin_solver_diff_simple(struct latin_solver *solver);
 
-/* Looped set elimination; *extreme is set if it used
- * the more difficult single-number elimination. */
+/* Looped set elimination; extreme permits use of the more difficult
+ * single-number elimination. */
 int latin_solver_diff_set(struct latin_solver *solver,
                           struct latin_solver_scratch *scratch,
-                          int extreme);
+                          bool extreme);
 
 typedef int (*usersolver_t)(struct latin_solver *solver, void *ctx);
 typedef void *(*ctxnew_t)(void *ctx);
@@ -115,7 +115,7 @@ digit *latin_generate(int o, random_state *rs);
 /* The order of the latin rectangle is max(w,h). */
 digit *latin_generate_rect(int w, int h, random_state *rs);
 
-int latin_check(digit *sq, int order); /* !0 => not a latin square */
+bool latin_check(digit *sq, int order); /* true => not a latin square */
 
 void latin_debug(digit *sq, int order);
 
diff --git a/apps/plugins/puzzles/src/lightup.c b/apps/plugins/puzzles/src/lightup.c
index acee853366..90811d5475 100644
--- a/apps/plugins/puzzles/src/lightup.c
+++ b/apps/plugins/puzzles/src/lightup.c
@@ -117,7 +117,7 @@ struct game_state {
                            of surrounding lights. For non-black squares,
                            the number of times it's lit. size h*w*/
     unsigned int *flags;        /* size h*w */
-    int completed, used_solve;
+    bool completed, used_solve;
 };
 
 #define GRID(gs,grid,x,y) (gs->grid[(y)*((gs)->w) + (x)])
@@ -129,7 +129,7 @@ struct game_state {
 typedef struct {
     int ox,oy;
     int minx, maxx, miny, maxy;
-    int include_origin;
+    bool include_origin;
 } ll_data;
 
 /* Macro that executes 'block' once per light in lld, including
@@ -179,7 +179,7 @@ static void get_surrounds(const game_state *state, int ox, int oy,
 
 #define DEFAULT_PRESET 0
 
-const struct game_params lightup_presets[] = {
+static const struct game_params lightup_presets[] = {
     { 7, 7, 20, SYMM_ROT4, 0 },
     { 7, 7, 20, SYMM_ROT4, 1 },
     { 7, 7, 20, SYMM_ROT4, 2 },
@@ -204,13 +204,13 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(lightup_presets))
-        return FALSE;
+        return false;
 
     ret = default_params();
     *ret = lightup_presets[i];
@@ -222,7 +222,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
             ret->difficulty == 1 ? "tricky" : "easy");
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -274,7 +274,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -342,7 +342,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
         return "Width and height must be at least 2";
@@ -374,7 +374,8 @@ static game_state *new_state(const game_params *params)
     memset(ret->lights, 0, ret->w * ret->h * sizeof(int));
     ret->flags = snewn(ret->w * ret->h, unsigned int);
     memset(ret->flags, 0, ret->w * ret->h * sizeof(unsigned int));
-    ret->completed = ret->used_solve = 0;
+    ret->completed = false;
+    ret->used_solve = false;
     return ret;
 }
 
@@ -445,8 +446,8 @@ static void debug_state(game_state *state)
 /* These are split up because occasionally functions are only
  * interested in one particular aspect. */
 
-/* Returns non-zero if all grid spaces are lit. */
-static int grid_lit(game_state *state)
+/* Returns true if all grid spaces are lit. */
+static bool grid_lit(game_state *state)
 {
     int x, y;
 
@@ -454,14 +455,14 @@ static int grid_lit(game_state *state)
         for (y = 0; y < state->h; y++) {
             if (GRID(state,flags,x,y) & F_BLACK) continue;
             if (GRID(state,lights,x,y) == 0)
-                return 0;
+                return false;
         }
     }
-    return 1;
+    return true;
 }
 
 /* Returns non-zero if any lights are lit by other lights. */
-static int grid_overlap(game_state *state)
+static bool grid_overlap(game_state *state)
 {
     int x, y;
 
@@ -469,13 +470,13 @@ static int grid_overlap(game_state *state)
         for (y = 0; y < state->h; y++) {
             if (!(GRID(state, flags, x, y) & F_LIGHT)) continue;
             if (GRID(state, lights, x, y) > 1)
-                return 1;
+                return true;
         }
     }
-    return 0;
+    return false;
 }
 
-static int number_wrong(const game_state *state, int x, int y)
+static bool number_wrong(const game_state *state, int x, int y)
 {
     surrounds s;
     int i, n, empty, lights = GRID(state, lights, x, y);
@@ -511,7 +512,7 @@ static int number_wrong(const game_state *state, int x, int y)
     return (n > lights || (n + empty < lights));
 }
 
-static int number_correct(game_state *state, int x, int y)
+static bool number_correct(game_state *state, int x, int y)
 {
     surrounds s;
     int n = 0, i, lights = GRID(state, lights, x, y);
@@ -522,34 +523,34 @@ static int number_correct(game_state *state, int x, int y)
         if (GRID(state,flags,s.points[i].x,s.points[i].y) & F_LIGHT)
             n++;
     }
-    return (n == lights) ? 1 : 0;
+    return n == lights;
 }
 
-/* Returns non-zero if any numbers add up incorrectly. */
-static int grid_addsup(game_state *state)
+/* Returns true if any numbers add up incorrectly. */
+static bool grid_addsup(game_state *state)
 {
     int x, y;
 
     for (x = 0; x < state->w; x++) {
         for (y = 0; y < state->h; y++) {
             if (!(GRID(state, flags, x, y) & F_NUMBERED)) continue;
-            if (!number_correct(state, x, y)) return 0;
+            if (!number_correct(state, x, y)) return false;
         }
     }
-    return 1;
+    return true;
 }
 
-static int grid_correct(game_state *state)
+static bool grid_correct(game_state *state)
 {
     if (grid_lit(state) &&
         !grid_overlap(state) &&
-        grid_addsup(state)) return 1;
-    return 0;
+        grid_addsup(state)) return true;
+    return false;
 }
 
 /* --- Board initial setup (blacks, lights, numbers) --- */
 
-static void clean_board(game_state *state, int leave_blacks)
+static void clean_board(game_state *state, bool leave_blacks)
 {
     int x,y;
     for (x = 0; x < state->w; x++) {
@@ -567,18 +568,19 @@ static void clean_board(game_state *state, int leave_blacks)
 static void set_blacks(game_state *state, const game_params *params,
                        random_state *rs)
 {
-    int x, y, degree = 0, rotate = 0, nblack;
+    int x, y, degree = 0, nblack;
+    bool rotate = false;
     int rh, rw, i;
     int wodd = (state->w % 2) ? 1 : 0;
     int hodd = (state->h % 2) ? 1 : 0;
     int xs[4], ys[4];
 
     switch (params->symm) {
-    case SYMM_NONE: degree = 1; rotate = 0; break;
-    case SYMM_ROT2: degree = 2; rotate = 1; break;
-    case SYMM_REF2: degree = 2; rotate = 0; break;
-    case SYMM_ROT4: degree = 4; rotate = 1; break;
-    case SYMM_REF4: degree = 4; rotate = 0; break;
+    case SYMM_NONE: degree = 1; rotate = false; break;
+    case SYMM_ROT2: degree = 2; rotate = true; break;
+    case SYMM_REF2: degree = 2; rotate = false; break;
+    case SYMM_ROT4: degree = 4; rotate = true; break;
+    case SYMM_REF4: degree = 4; rotate = false; break;
     default: assert(!"Unknown symmetry type");
     }
     if (params->symm == SYMM_ROT4 && (state->h != state->w))
@@ -599,7 +601,7 @@ static void set_blacks(game_state *state, const game_params *params,
     }
 
     /* clear, then randomise, required region. */
-    clean_board(state, 0);
+    clean_board(state, false);
     nblack = (rw * rh * params->blackpc) / 100;
     for (i = 0; i < nblack; i++) {
         do {
@@ -647,9 +649,9 @@ static void set_blacks(game_state *state, const game_params *params,
 }
 
 /* Fills in (does not allocate) a ll_data with all the tiles that would
- * be illuminated by a light at point (ox,oy). If origin=1 then the
+ * be illuminated by a light at point (ox,oy). If origin is true then the
  * origin is included in this list. */
-static void list_lights(game_state *state, int ox, int oy, int origin,
+static void list_lights(game_state *state, int ox, int oy, bool origin,
                         ll_data *lld)
 {
     int x,y;
@@ -681,7 +683,7 @@ static void list_lights(game_state *state, int ox, int oy, int origin,
 
 /* Makes sure a light is the given state, editing the lights table to suit the
  * new state if necessary. */
-static void set_light(game_state *state, int ox, int oy, int on)
+static void set_light(game_state *state, int ox, int oy, bool on)
 {
     ll_data lld;
     int diff = 0;
@@ -699,7 +701,7 @@ static void set_light(game_state *state, int ox, int oy, int on)
     }
 
     if (diff != 0) {
-        list_lights(state,ox,oy,1,&lld);
+        list_lights(state,ox,oy,true,&lld);
         FOREACHLIT(&lld, GRID(state,lights,lx,ly) += diff; );
     }
 }
@@ -709,7 +711,7 @@ static int check_dark(game_state *state, int x, int y)
 {
     ll_data lld;
 
-    list_lights(state, x, y, 1, &lld);
+    list_lights(state, x, y, true, &lld);
     FOREACHLIT(&lld, if (GRID(state,lights,lx,ly) == 1) { return 1; } );
     return 0;
 }
@@ -731,7 +733,7 @@ static void place_lights(game_state *state, random_state *rs)
         for (y = 0; y < state->h; y++) {
             GRID(state, flags, x, y) &= ~F_MARK; /* we use this later. */
             if (GRID(state, flags, x, y) & F_BLACK) continue;
-            set_light(state, x, y, 1);
+            set_light(state, x, y, true);
         }
     }
 
@@ -740,7 +742,7 @@ static void place_lights(game_state *state, random_state *rs)
         x = numindices[i] % state->w;
         if (!(GRID(state, flags, x, y) & F_LIGHT)) continue;
         if (GRID(state, flags, x, y) & F_MARK) continue;
-        list_lights(state, x, y, 0, &lld);
+        list_lights(state, x, y, false, &lld);
 
         /* If we're not lighting any lights ourself, don't remove anything. */
         n = 0;
@@ -753,7 +755,7 @@ static void place_lights(game_state *state, random_state *rs)
         FOREACHLIT(&lld, if (GRID(state,flags,lx,ly) & F_LIGHT) { n += check_dark(state,lx,ly); } );
         if (n == 0) {
             /* No, it wouldn't, so we can remove them all. */
-            FOREACHLIT(&lld, set_light(state,lx,ly, 0); );
+            FOREACHLIT(&lld, set_light(state,lx,ly, false); );
             GRID(state,flags,x,y) |= F_MARK;
         }
 
@@ -802,57 +804,58 @@ static void tsl_callback(game_state *state,
     *x = lx; *y = ly; (*n)++;
 }
 
-static int try_solve_light(game_state *state, int ox, int oy,
-                           unsigned int flags, int lights)
+static bool try_solve_light(game_state *state, int ox, int oy,
+                            unsigned int flags, int lights)
 {
     ll_data lld;
     int sx = 0, sy = 0, n = 0;
 
-    if (lights > 0) return 0;
-    if (flags & F_BLACK) return 0;
+    if (lights > 0) return false;
+    if (flags & F_BLACK) return false;
 
     /* We have an unlit square; count how many ways there are left to
      * place a light that lights us (including this square); if only
      * one, we must put a light there. Squares that could light us
      * are, of course, the same as the squares we would light... */
-    list_lights(state, ox, oy, 1, &lld);
+    list_lights(state, ox, oy, true, &lld);
     FOREACHLIT(&lld, { tsl_callback(state, lx, ly, &sx, &sy, &n); });
     if (n == 1) {
-        set_light(state, sx, sy, 1);
+        set_light(state, sx, sy, true);
 #ifdef SOLVER_DIAGNOSTICS
         debug(("(%d,%d) can only be lit from (%d,%d); setting to LIGHT\n",
                 ox,oy,sx,sy));
         if (verbose) debug_state(state);
 #endif
-        return 1;
+        return true;
     }
 
-    return 0;
+    return false;
 }
 
-static int could_place_light(unsigned int flags, int lights)
+static bool could_place_light(unsigned int flags, int lights)
 {
-    if (flags & (F_BLACK | F_IMPOSSIBLE)) return 0;
-    return (lights > 0) ? 0 : 1;
+    if (flags & (F_BLACK | F_IMPOSSIBLE)) return false;
+    return !(lights > 0);
 }
 
-static int could_place_light_xy(game_state *state, int x, int y)
+static bool could_place_light_xy(game_state *state, int x, int y)
 {
     int lights = GRID(state,lights,x,y);
     unsigned int flags = GRID(state,flags,x,y);
-    return (could_place_light(flags, lights)) ? 1 : 0;
+    return could_place_light(flags, lights);
 }
 
 /* For a given number square, determine whether we have enough info
  * to unambiguously place its lights. */
-static int try_solve_number(game_state *state, int nx, int ny,
-                            unsigned int nflags, int nlights)
+static bool try_solve_number(game_state *state, int nx, int ny,
+                             unsigned int nflags, int nlights)
 {
     surrounds s;
-    int x, y, nl, ns, i, ret = 0, lights;
+    int x, y, nl, ns, i, lights;
+    bool ret = false;
     unsigned int flags;
 
-    if (!(nflags & F_NUMBERED)) return 0;
+    if (!(nflags & F_NUMBERED)) return false;
     nl = nlights;
     get_surrounds(state,nx,ny,&s);
     ns = s.npoints;
@@ -873,7 +876,7 @@ static int try_solve_number(game_state *state, int nx, int ny,
             s.points[i].f |= F_MARK;
         }
     }
-    if (ns == 0) return 0; /* nowhere to put anything. */
+    if (ns == 0) return false; /* nowhere to put anything. */
     if (nl == 0) {
         /* we have placed all lights we need to around here; all remaining
          * surrounds are therefore IMPOSSIBLE. */
@@ -881,7 +884,7 @@ static int try_solve_number(game_state *state, int nx, int ny,
         for (i = 0; i < s.npoints; i++) {
             if (!(s.points[i].f & F_MARK)) {
                 GRID(state,flags,s.points[i].x,s.points[i].y) |= F_IMPOSSIBLE;
-                ret = 1;
+                ret = true;
             }
         }
 #ifdef SOLVER_DIAGNOSTICS
@@ -894,8 +897,8 @@ static int try_solve_number(game_state *state, int nx, int ny,
         GRID(state,flags,nx,ny) |= F_NUMBERUSED;
         for (i = 0; i < s.npoints; i++) {
             if (!(s.points[i].f & F_MARK)) {
-                set_light(state, s.points[i].x,s.points[i].y, 1);
-                ret = 1;
+                set_light(state, s.points[i].x,s.points[i].y, true);
+                ret = true;
             }
         }
 #ifdef SOLVER_DIAGNOSTICS
@@ -992,7 +995,7 @@ static void trl_callback_search(game_state *state, int dx, int dy,
 static void trl_callback_discount(game_state *state, int dx, int dy,
                        struct setscratch *scratch, int n, void *ctx)
 {
-    int *didsth = (int *)ctx;
+    bool *didsth = (bool *)ctx;
     int i;
 
     if (GRID(state,flags,dx,dy) & F_IMPOSSIBLE) {
@@ -1025,7 +1028,7 @@ static void trl_callback_discount(game_state *state, int dx, int dy,
     if (verbose) debug_state(state);
 #endif
 
-    *didsth = 1;
+    *didsth = true;
 }
 
 static void trl_callback_incn(game_state *state, int dx, int dy,
@@ -1050,7 +1053,7 @@ static void try_rule_out(game_state *state, int x, int y,
     /* Find all squares that would rule out a light at (x,y) and call trl_cb
      * with them: anything that would light (x,y)... */
 
-    list_lights(state, x, y, 0, &lld);
+    list_lights(state, x, y, false, &lld);
     FOREACHLIT(&lld, { if (could_place_light_xy(state, lx, ly)) { cb(state, lx, ly, scratch, n, ctx); } });
 
     /* ... as well as any empty space (that isn't x,y) next to any clue square
@@ -1095,15 +1098,16 @@ static void debug_scratch(const char *msg, struct setscratch *scratch, int n)
 }
 #endif
 
-static int discount_set(game_state *state,
-                        struct setscratch *scratch, int n)
+static bool discount_set(game_state *state,
+                         struct setscratch *scratch, int n)
 {
-    int i, besti, bestn, didsth = 0;
+    int i, besti, bestn;
+    bool didsth = false;
 
 #ifdef SOLVER_DIAGNOSTICS
     if (verbose > 1) debug_scratch("discount_set", scratch, n);
 #endif
-    if (n == 0) return 0;
+    if (n == 0) return false;
 
     for (i = 0; i < n; i++) {
         try_rule_out(state, scratch[i].x, scratch[i].y, scratch, n,
@@ -1149,11 +1153,12 @@ static void unlit_cb(game_state *state, int lx, int ly,
 }
 
 /* Construct a MAKESLIGHT set from an unlit square. */
-static int discount_unlit(game_state *state, int x, int y,
-                          struct setscratch *scratch)
+static bool discount_unlit(game_state *state, int x, int y,
+                           struct setscratch *scratch)
 {
     ll_data lld;
-    int n, didsth;
+    int n;
+    bool didsth;
 
 #ifdef SOLVER_DIAGNOSTICS
     if (verbose) debug(("Trying to discount for unlit square at (%d,%d).\n", x, y));
@@ -1162,7 +1167,7 @@ static int discount_unlit(game_state *state, int x, int y,
 
     discount_clear(state, scratch, &n);
 
-    list_lights(state, x, y, 1, &lld);
+    list_lights(state, x, y, true, &lld);
     FOREACHLIT(&lld, { unlit_cb(state, lx, ly, scratch, &n); });
     didsth = discount_set(state, scratch, n);
 #ifdef SOLVER_DIAGNOSTICS
@@ -1177,15 +1182,16 @@ static int discount_unlit(game_state *state, int x, int y,
  *  subset of size N-M+1 of those N spaces forms such a set.
  */
 
-static int discount_clue(game_state *state, int x, int y,
+static bool discount_clue(game_state *state, int x, int y,
                           struct setscratch *scratch)
 {
-    int slen, m = GRID(state, lights, x, y), n, i, didsth = 0, lights;
+    int slen, m = GRID(state, lights, x, y), n, i, lights;
+    bool didsth = false;
     unsigned int flags;
     surrounds s, sempty;
     combi_ctx *combi;
 
-    if (m == 0) return 0;
+    if (m == 0) return false;
 
 #ifdef SOLVER_DIAGNOSTICS
     if (verbose) debug(("Trying to discount for sets at clue (%d,%d).\n", x, y));
@@ -1213,9 +1219,9 @@ static int discount_clue(game_state *state, int x, int y,
         }
     }
     n = sempty.npoints; /* sempty is now a surrounds of only blank squares. */
-    if (n == 0) return 0; /* clue is full already. */
+    if (n == 0) return false; /* clue is full already. */
 
-    if (m < 0 || m > n) return 0; /* become impossible. */
+    if (m < 0 || m > n) return false; /* become impossible. */
 
     combi = new_combi(n - m + 1, n);
     while (next_combi(combi)) {
@@ -1225,7 +1231,7 @@ static int discount_clue(game_state *state, int x, int y,
             scratch[slen].y = sempty.points[combi->a[i]].y;
             slen++;
         }
-        if (discount_set(state, scratch, slen)) didsth = 1;
+        if (discount_set(state, scratch, slen)) didsth = true;
     }
     free_combi(combi);
 #ifdef SOLVER_DIAGNOSTICS
@@ -1254,7 +1260,8 @@ static int solve_sub(game_state *state,
                      int *maxdepth)
 {
     unsigned int flags;
-    int x, y, didstuff, ncanplace, lights;
+    int x, y, ncanplace, lights;
+    bool didstuff;
     int bestx, besty, n, bestn, copy_soluble, self_soluble, ret, maxrecurse = 0;
     game_state *scopy;
     ll_data lld;
@@ -1278,7 +1285,7 @@ static int solve_sub(game_state *state,
         if (grid_correct(state)) { ret = 1; goto done; }
 
         ncanplace = 0;
-        didstuff = 0;
+        didstuff = false;
         /* These 2 loops, and the functions they call, are the critical loops
          * for timing; any optimisations should look here first. */
         for (x = 0; x < state->w; x++) {
@@ -1287,8 +1294,10 @@ static int solve_sub(game_state *state,
                 lights = GRID(state,lights,x,y);
                 ncanplace += could_place_light(flags, lights);
 
-                if (try_solve_light(state, x, y, flags, lights)) didstuff = 1;
-                if (try_solve_number(state, x, y, flags, lights)) didstuff = 1;
+                if (try_solve_light(state, x, y, flags, lights))
+                    didstuff = true;
+                if (try_solve_number(state, x, y, flags, lights))
+                    didstuff = true;
             }
         }
         if (didstuff) continue;
@@ -1307,12 +1316,12 @@ static int solve_sub(game_state *state,
 
                     if (!(flags & F_BLACK) && lights == 0) {
                         if (discount_unlit(state, x, y, sscratch)) {
-                            didstuff = 1;
+                            didstuff = true;
                             goto reduction_success;
                         }
                     } else if (flags & F_NUMBERED) {
                         if (discount_clue(state, x, y, sscratch)) {
-                            didstuff = 1;
+                            didstuff = true;
                             goto reduction_success;
                         }
                     }
@@ -1342,7 +1351,7 @@ reduction_success:
                 if (!could_place_light(flags, lights)) continue;
 
                 n = 0;
-                list_lights(state, x, y, 1, &lld);
+                list_lights(state, x, y, true, &lld);
                 FOREACHLIT(&lld, { if (GRID(state,lights,lx,ly) == 0) n++; });
                 if (n > bestn) {
                     bestn = n; bestx = x; besty = y;
@@ -1373,7 +1382,7 @@ reduction_success:
 #ifdef SOLVER_DIAGNOSTICS
         debug(("Recursing #2: trying (%d,%d) as LIGHT\n", bestx, besty));
 #endif
-        set_light(scopy, bestx, besty, 1);
+        set_light(scopy, bestx, besty, true);
         copy_soluble = solve_sub(scopy, solve_flags, depth+1, maxdepth);
 
         /* If we wanted a unique solution but we hit our recursion limit
@@ -1453,14 +1462,14 @@ static void unplace_lights(game_state *state)
     for (x = 0; x < state->w; x++) {
         for (y = 0; y < state->h; y++) {
             if (GRID(state,flags,x,y) & F_LIGHT)
-                set_light(state,x,y,0);
+                set_light(state,x,y,false);
             GRID(state,flags,x,y) &= ~F_IMPOSSIBLE;
             GRID(state,flags,x,y) &= ~F_NUMBERUSED;
         }
     }
 }
 
-static int puzzle_is_good(game_state *state, int difficulty)
+static bool puzzle_is_good(game_state *state, int difficulty)
 {
     int nsol, mdepth = 0;
     unsigned int sflags = flags_from_difficulty(difficulty);
@@ -1477,13 +1486,13 @@ static int puzzle_is_good(game_state *state, int difficulty)
     /* if we wanted an easy puzzle, make sure we didn't need recursion. */
     if (!(sflags & F_SOLVE_ALLOWRECURSE) && mdepth > 0) {
         debug(("Ignoring recursive puzzle.\n"));
-        return 0;
+        return false;
     }
 
     debug(("%d solutions found.\n", nsol));
-    if (nsol <= 0) return 0;
-    if (nsol > 1) return 0;
-    return 1;
+    if (nsol <= 0) return false;
+    if (nsol > 1) return false;
+    return true;
 }
 
 /* --- New game creation and user input code. --- */
@@ -1514,7 +1523,7 @@ static int puzzle_is_good(game_state *state, int difficulty)
 #define MAX_GRIDGEN_TRIES 20
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1750,9 +1759,9 @@ done:
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 /* 'borrowed' from slant.c, mainly. I could have printed it one
@@ -1811,13 +1820,15 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int cur_x, cur_y, cur_visible;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
-    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
     return ui;
 }
 
@@ -1841,7 +1852,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
     if (newstate->completed)
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 }
 
 #define DF_BLACK        1       /* black square */
@@ -1858,7 +1869,7 @@ struct game_drawstate {
     int tilesize, crad;
     int w, h;
     unsigned int *flags;         /* width * height */
-    int started;
+    bool started;
 };
 
 
@@ -1882,7 +1893,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         if (ui->cur_visible)
             nullret = empty;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         cx = FROMCOORD(x);
         cy = FROMCOORD(y);
         action = (button == LEFT_BUTTON) ? FLIP_LIGHT : FLIP_IMPOSSIBLE;
@@ -1897,10 +1908,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             action = (button == 'i' || button == 'I' || button == CURSOR_SELECT2) ?
                 FLIP_IMPOSSIBLE : FLIP_LIGHT;
         }
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
     } else if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
-        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, false);
+        ui->cur_visible = true;
         nullret = empty;
     } else
         return NULL;
@@ -1951,7 +1962,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move;
         if (c == 'S') {
-            ret->used_solve = TRUE;
+            ret->used_solve = true;
             move++;
         } else if (c == 'L' || c == 'I') {
             move++;
@@ -1965,9 +1976,9 @@ static game_state *execute_move(const game_state *state, const char *move)
             /* LIGHT and IMPOSSIBLE are mutually exclusive. */
             if (c == 'L') {
                 GRID(ret, flags, x, y) &= ~F_IMPOSSIBLE;
-                set_light(ret, x, y, (flags & F_LIGHT) ? 0 : 1);
+                set_light(ret, x, y, !(flags & F_LIGHT));
             } else {
-                set_light(ret, x, y, 0);
+                set_light(ret, x, y, false);
                 GRID(ret, flags, x, y) ^= F_IMPOSSIBLE;
             }
             move += n;
@@ -1977,7 +1988,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             move++;
         else if (*move) goto badmove;
     }
-    if (grid_correct(ret)) ret->completed = 1;
+    if (grid_correct(ret)) ret->completed = true;
     return ret;
 
 badmove:
@@ -2047,7 +2058,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     for (i = 0; i < ds->w*ds->h; i++)
         ds->flags[i] = -1;
 
-    ds->started = 0;
+    ds->started = false;
 
     return ds;
 }
@@ -2066,7 +2077,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 #define HINT_NUMBERS
 
 static unsigned int tile_flags(game_drawstate *ds, const game_state *state,
-                               const game_ui *ui, int x, int y, int flashing)
+                               const game_ui *ui, int x, int y, bool flashing)
 {
     unsigned int flags = GRID(state, flags, x, y);
     int lights = GRID(state, lights, x, y);
@@ -2159,7 +2170,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int flashing = FALSE;
+    bool flashing = false;
     int x,y;
 
     if (flashtime) flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
@@ -2177,7 +2188,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         draw_update(dr, 0, 0,
                     TILE_SIZE * ds->w + 2 * BORDER,
                     TILE_SIZE * ds->h + 2 * BORDER);
-        ds->started = 1;
+        ds->started = true;
     }
 
     for (x = 0; x < ds->w; x++) {
@@ -2211,9 +2222,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2260,7 +2271,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
      */
     for (y = 0; y < h; y++)
 	for (x = 0; x < w; x++) {
-            unsigned int ds_flags = tile_flags(ds, state, NULL, x, y, FALSE);
+            unsigned int ds_flags = tile_flags(ds, state, NULL, x, y, false);
 	    int dx = COORD(x), dy = COORD(y);
 	    if (ds_flags & DF_BLACK) {
 		draw_rect(dr, dx, dy, TILE_SIZE, TILE_SIZE, ink);
@@ -2290,15 +2301,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2315,9 +2326,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/loopgen.c b/apps/plugins/puzzles/src/loopgen.c
index 0b6990455f..e738d4a26d 100644
--- a/apps/plugins/puzzles/src/loopgen.c
+++ b/apps/plugins/puzzles/src/loopgen.c
@@ -75,16 +75,16 @@ static int black_sort_cmpfn(void *v1, void *v2)
 /* 'board' is an array of enum face_colour, indicating which faces are
  * currently black/white/grey.  'colour' is FACE_WHITE or FACE_BLACK.
  * Returns whether it's legal to colour the given face with this colour. */
-static int can_colour_face(grid *g, char* board, int face_index,
-                           enum face_colour colour)
+static bool can_colour_face(grid *g, char* board, int face_index,
+                            enum face_colour colour)
 {
     int i, j;
     grid_face *test_face = g->faces + face_index;
     grid_face *starting_face, *current_face;
     grid_dot *starting_dot;
     int transitions;
-    int current_state, s; /* booleans: equal or not-equal to 'colour' */
-    int found_same_coloured_neighbour = FALSE;
+    bool current_state, s; /* equal or not-equal to 'colour' */
+    bool found_same_coloured_neighbour = false;
     assert(board[face_index] != colour);
 
     /* Can only consider a face for colouring if it's adjacent to a face
@@ -93,12 +93,12 @@ static int can_colour_face(grid *g, char* board, int face_index,
         grid_edge *e = test_face->edges[i];
         grid_face *f = (e->face1 == test_face) ? e->face2 : e->face1;
         if (FACE_COLOUR(f) == colour) {
-            found_same_coloured_neighbour = TRUE;
+            found_same_coloured_neighbour = true;
             break;
         }
     }
     if (!found_same_coloured_neighbour)
-        return FALSE;
+        return false;
 
     /* Need to avoid creating a loop of faces of this colour around some
      * differently-coloured faces.
@@ -158,11 +158,11 @@ static int can_colour_face(grid *g, char* board, int face_index,
     current_state = (FACE_COLOUR(current_face) == colour);
     starting_dot = NULL;
     starting_face = NULL;
-    while (TRUE) {
+    while (true) {
         /* Advance to next face.
          * Need to loop here because it might take several goes to
          * find it. */
-        while (TRUE) {
+        while (true) {
             j++;
             if (j == test_face->dots[i]->order)
                 j = 0;
@@ -206,7 +206,7 @@ static int can_colour_face(grid *g, char* board, int face_index,
         }
     }
 
-    return (transitions == 2) ? TRUE : FALSE;
+    return (transitions == 2) ? true : false;
 }
 
 /* Count the number of neighbours of 'face', having colour 'colour' */
@@ -306,7 +306,7 @@ void generate_loop(grid *g, char *board, random_state *rs,
     tree234 *lightable_faces_sorted;
     tree234 *darkable_faces_sorted;
     int *face_list;
-    int do_random_pass;
+    bool do_random_pass;
 
     /* Make a board */
     memset(board, FACE_GREY, num_faces);
@@ -361,7 +361,7 @@ void generate_loop(grid *g, char *board, random_state *rs,
     }
 
     /* Colour faces one at a time until no more faces are colourable. */
-    while (TRUE)
+    while (true)
     {
         enum face_colour colour;
         tree234 *faces_to_pick;
@@ -501,12 +501,12 @@ void generate_loop(grid *g, char *board, random_state *rs,
      * make some illicit deductions.  To combat this (and make the path more
      * interesting), we do one final pass making random flips. */
 
-    /* Set to TRUE for final pass */
-    do_random_pass = FALSE;
+    /* Set to true for final pass */
+    do_random_pass = false;
 
-    while (TRUE) {
+    while (true) {
         /* Remember whether a flip occurred during this pass */
-        int flipped = FALSE;
+        bool flipped = false;
 
         for (i = 0; i < num_faces; ++i) {
             int j = face_list[i];
@@ -522,14 +522,14 @@ void generate_loop(grid *g, char *board, random_state *rs,
                     /* normal pass - flip when neighbour count is 1 */
                     if (face_num_neighbours(g, board, face, opp) == 1) {
                         board[j] = opp;
-                        flipped = TRUE;
+                        flipped = true;
                     }
                 }
             }
         }
 
         if (do_random_pass) break;
-        if (!flipped) do_random_pass = TRUE;
+        if (!flipped) do_random_pass = true;
     }
 
     sfree(face_list);
diff --git a/apps/plugins/puzzles/src/loopy.c b/apps/plugins/puzzles/src/loopy.c
index f5f8917052..f2875a2e93 100644
--- a/apps/plugins/puzzles/src/loopy.c
+++ b/apps/plugins/puzzles/src/loopy.c
@@ -117,11 +117,11 @@ struct game_state {
      * YES, NO or UNKNOWN */
     char *lines;
 
-    unsigned char *line_errors;
-    int exactly_one_loop;
+    bool *line_errors;
+    bool exactly_one_loop;
 
-    int solved;
-    int cheated;
+    bool solved;
+    bool cheated;
 
     /* Used in game_text_format(), so that it knows what type of
      * grid it's trying to render as ASCII text. */
@@ -152,7 +152,7 @@ typedef struct solver_state {
     char *dot_no_count;
     char *face_yes_count;
     char *face_no_count;
-    char *dot_solved, *face_solved;
+    bool *dot_solved, *face_solved;
     int *dotdsf;
 
     /* Information for Normal level deductions:
@@ -223,13 +223,13 @@ enum line_drawstate { DS_LINE_YES, DS_LINE_UNKNOWN,
 
 
 struct game_drawstate {
-    int started;
+    bool started;
     int tilesize;
-    int flashing;
+    bool flashing;
     int *textx, *texty;
     char *lines;
-    char *clue_error;
-    char *clue_satisfied;
+    bool *clue_error;
+    bool *clue_satisfied;
 };
 
 static const char *validate_desc(const game_params *params, const char *desc);
@@ -319,11 +319,11 @@ static grid *loopy_generate_grid(const game_params *params,
 
 #define BIT_SET(field, bit) ((field) & (1<<(bit)))
 
-#define SET_BIT(field, bit)  (BIT_SET(field, bit) ? FALSE : \
-                              ((field) |= (1<<(bit)), TRUE))
+#define SET_BIT(field, bit)  (BIT_SET(field, bit) ? false : \
+                              ((field) |= (1<<(bit)), true))
 
 #define CLEAR_BIT(field, bit) (BIT_SET(field, bit) ? \
-                               ((field) &= ~(1<<(bit)), TRUE) : FALSE)
+                               ((field) &= ~(1<<(bit)), true) : false)
 
 #define CLUE2CHAR(c) \
     ((c < 0) ? ' ' : c < 10 ? c + '0' : c - 10 + 'A')
@@ -348,8 +348,9 @@ static game_state *dup_game(const game_state *state)
     ret->lines = snewn(state->game_grid->num_edges, char);
     memcpy(ret->lines, state->lines, state->game_grid->num_edges);
 
-    ret->line_errors = snewn(state->game_grid->num_edges, unsigned char);
-    memcpy(ret->line_errors, state->line_errors, state->game_grid->num_edges);
+    ret->line_errors = snewn(state->game_grid->num_edges, bool);
+    memcpy(ret->line_errors, state->line_errors,
+           state->game_grid->num_edges * sizeof(bool));
     ret->exactly_one_loop = state->exactly_one_loop;
 
     ret->grid_type = state->grid_type;
@@ -386,10 +387,10 @@ static solver_state *new_solver_state(const game_state *state, int diff) {
         ret->looplen[i] = 1;
     }
 
-    ret->dot_solved = snewn(num_dots, char);
-    ret->face_solved = snewn(num_faces, char);
-    memset(ret->dot_solved, FALSE, num_dots);
-    memset(ret->face_solved, FALSE, num_faces);
+    ret->dot_solved = snewn(num_dots, bool);
+    ret->face_solved = snewn(num_faces, bool);
+    memset(ret->dot_solved, 0, num_dots * sizeof(bool));
+    memset(ret->face_solved, 0, num_faces * sizeof(bool));
 
     ret->dot_yes_count = snewn(num_dots, char);
     memset(ret->dot_yes_count, 0, num_dots);
@@ -455,10 +456,10 @@ static solver_state *dup_solver_state(const solver_state *sstate) {
     memcpy(ret->looplen, sstate->looplen,
            num_dots * sizeof(int));
 
-    ret->dot_solved = snewn(num_dots, char);
-    ret->face_solved = snewn(num_faces, char);
-    memcpy(ret->dot_solved, sstate->dot_solved, num_dots);
-    memcpy(ret->face_solved, sstate->face_solved, num_faces);
+    ret->dot_solved = snewn(num_dots, bool);
+    ret->face_solved = snewn(num_faces, bool);
+    memcpy(ret->dot_solved, sstate->dot_solved, num_dots * sizeof(bool));
+    memcpy(ret->face_solved, sstate->face_solved, num_faces * sizeof(bool));
 
     ret->dot_yes_count = snewn(num_dots, char);
     memcpy(ret->dot_yes_count, sstate->dot_yes_count, num_dots);
@@ -624,7 +625,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%dt%d", params->w, params->h, params->type);
@@ -678,7 +679,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->type < 0 || params->type >= NUM_GRID_TYPES)
         return "Illegal grid type";
@@ -946,17 +947,17 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->tilesize = 0;
-    ds->started = 0;
+    ds->started = false;
     ds->lines = snewn(num_edges, char);
-    ds->clue_error = snewn(num_faces, char);
-    ds->clue_satisfied = snewn(num_faces, char);
+    ds->clue_error = snewn(num_faces, bool);
+    ds->clue_satisfied = snewn(num_faces, bool);
     ds->textx = snewn(num_faces, int);
     ds->texty = snewn(num_faces, int);
-    ds->flashing = 0;
+    ds->flashing = false;
 
     memset(ds->lines, LINE_UNKNOWN, num_edges);
-    memset(ds->clue_error, 0, num_faces);
-    memset(ds->clue_satisfied, 0, num_faces);
+    memset(ds->clue_error, 0, num_faces * sizeof(bool));
+    memset(ds->clue_satisfied, 0, num_faces * sizeof(bool));
     for (i = 0; i < num_faces; i++)
         ds->textx[i] = ds->texty[i] = -1;
 
@@ -973,9 +974,9 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
     sfree(ds);
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -984,11 +985,11 @@ static float game_anim_length(const game_state *oldstate,
     return 0.0F;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     if (params->type != 0)
-        return FALSE;
-    return TRUE;
+        return false;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1106,13 +1107,13 @@ static void check_caches(const solver_state* sstate)
 
 /* Sets the line (with index i) to the new state 'line_new', and updates
  * the cached counts of any affected faces and dots.
- * Returns TRUE if this actually changed the line's state. */
-static int solver_set_line(solver_state *sstate, int i,
-                           enum line_state line_new
+ * Returns true if this actually changed the line's state. */
+static bool solver_set_line(solver_state *sstate, int i,
+                            enum line_state line_new
 #ifdef SHOW_WORKING
-			   , const char *reason
+                            , const char *reason
 #endif
-			   )
+                            )
 {
     game_state *state = sstate->state;
     grid *g;
@@ -1123,7 +1124,7 @@ static int solver_set_line(solver_state *sstate, int i,
     check_caches(sstate);
 
     if (state->lines[i] == line_new) {
-        return FALSE; /* nothing changed */
+        return false; /* nothing changed */
     }
     state->lines[i] = line_new;
 
@@ -1158,7 +1159,7 @@ static int solver_set_line(solver_state *sstate, int i,
     }
 
     check_caches(sstate);
-    return TRUE;
+    return true;
 }
 
 #ifdef SHOW_WORKING
@@ -1170,10 +1171,10 @@ static int solver_set_line(solver_state *sstate, int i,
  * Merge two dots due to the existence of an edge between them.
  * Updates the dsf tracking equivalence classes, and keeps track of
  * the length of path each dot is currently a part of.
- * Returns TRUE if the dots were already linked, ie if they are part of a
+ * Returns true if the dots were already linked, ie if they are part of a
  * closed loop, and false otherwise.
  */
-static int merge_dots(solver_state *sstate, int edge_index)
+static bool merge_dots(solver_state *sstate, int edge_index)
 {
     int i, j, len;
     grid *g = sstate->state->game_grid;
@@ -1186,26 +1187,26 @@ static int merge_dots(solver_state *sstate, int edge_index)
     j = dsf_canonify(sstate->dotdsf, j);
 
     if (i == j) {
-        return TRUE;
+        return true;
     } else {
         len = sstate->looplen[i] + sstate->looplen[j];
         dsf_merge(sstate->dotdsf, i, j);
         i = dsf_canonify(sstate->dotdsf, i);
         sstate->looplen[i] = len;
-        return FALSE;
+        return false;
     }
 }
 
 /* Merge two lines because the solver has deduced that they must be either
- * identical or opposite.   Returns TRUE if this is new information, otherwise
- * FALSE. */
-static int merge_lines(solver_state *sstate, int i, int j, int inverse
+ * identical or opposite.   Returns true if this is new information, otherwise
+ * false. */
+static bool merge_lines(solver_state *sstate, int i, int j, bool inverse
 #ifdef SHOW_WORKING
-                       , const char *reason
+                        , const char *reason
 #endif
-		       )
+                        )
 {
-    int inv_tmp;
+    bool inv_tmp;
 
     assert(i < sstate->state->game_grid->num_edges);
     assert(j < sstate->state->game_grid->num_edges);
@@ -1268,17 +1269,17 @@ static int face_order(const game_state* state, int face, char line_type)
 
 /* Set all lines bordering a dot of type old_type to type new_type
  * Return value tells caller whether this function actually did anything */
-static int dot_setall(solver_state *sstate, int dot,
-		      char old_type, char new_type)
+static bool dot_setall(solver_state *sstate, int dot,
+                       char old_type, char new_type)
 {
-    int retval = FALSE, r;
+    bool retval = false, r;
     game_state *state = sstate->state;
     grid *g;
     grid_dot *d;
     int i;
 
     if (old_type == new_type)
-        return FALSE;
+        return false;
 
     g = state->game_grid;
     d = g->dots + dot;
@@ -1287,25 +1288,25 @@ static int dot_setall(solver_state *sstate, int dot,
         int line_index = d->edges[i] - g->edges;
         if (state->lines[line_index] == old_type) {
             r = solver_set_line(sstate, line_index, new_type);
-            assert(r == TRUE);
-            retval = TRUE;
+            assert(r);
+            retval = true;
         }
     }
     return retval;
 }
 
 /* Set all lines bordering a face of type old_type to type new_type */
-static int face_setall(solver_state *sstate, int face,
-                       char old_type, char new_type)
+static bool face_setall(solver_state *sstate, int face,
+                        char old_type, char new_type)
 {
-    int retval = FALSE, r;
+    bool retval = false, r;
     game_state *state = sstate->state;
     grid *g;
     grid_face *f;
     int i;
 
     if (old_type == new_type)
-        return FALSE;
+        return false;
 
     g = state->game_grid;
     f = g->faces + face;
@@ -1314,8 +1315,8 @@ static int face_setall(solver_state *sstate, int face,
         int line_index = f->edges[i] - g->edges;
         if (state->lines[line_index] == old_type) {
             r = solver_set_line(sstate, line_index, new_type);
-            assert(r == TRUE);
-            retval = TRUE;
+            assert(r);
+            retval = true;
         }
     }
     return retval;
@@ -1356,9 +1357,9 @@ static void add_full_clues(game_state *state, random_state *rs)
 }
 
 
-static int game_has_unique_soln(const game_state *state, int diff)
+static bool game_has_unique_soln(const game_state *state, int diff)
 {
-    int ret;
+    bool ret;
     solver_state *sstate_new;
     solver_state *sstate = new_solver_state((game_state *)state, diff);
 
@@ -1412,7 +1413,7 @@ static game_state *remove_clues(game_state *state, random_state *rs,
 
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     /* solution and description both use run-length encoding in obvious ways */
     char *retval, *game_desc, *grid_desc;
@@ -1425,17 +1426,18 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
     state->clues = snewn(g->num_faces, signed char);
     state->lines = snewn(g->num_edges, char);
-    state->line_errors = snewn(g->num_edges, unsigned char);
-    state->exactly_one_loop = FALSE;
+    state->line_errors = snewn(g->num_edges, bool);
+    state->exactly_one_loop = false;
 
     state->grid_type = params->type;
 
     newboard_please:
 
     memset(state->lines, LINE_UNKNOWN, g->num_edges);
-    memset(state->line_errors, 0, g->num_edges);
+    memset(state->line_errors, 0, g->num_edges * sizeof(bool));
 
-    state->solved = state->cheated = FALSE;
+    state->solved = false;
+    state->cheated = false;
 
     /* Get a new random solvable board with all its clues filled in.  Yes, this
      * can loop for ever if the params are suitably unfavourable, but
@@ -1497,10 +1499,10 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->clues = snewn(num_faces, signed char);
     state->lines = snewn(num_edges, char);
-    state->line_errors = snewn(num_edges, unsigned char);
-    state->exactly_one_loop = FALSE;
+    state->line_errors = snewn(num_edges, bool);
+    state->exactly_one_loop = false;
 
-    state->solved = state->cheated = FALSE;
+    state->solved = state->cheated = false;
 
     state->grid_type = params->type;
 
@@ -1528,21 +1530,22 @@ static game_state *new_game(midend *me, const game_params *params,
     }
 
     memset(state->lines, LINE_UNKNOWN, num_edges);
-    memset(state->line_errors, 0, num_edges);
+    memset(state->line_errors, 0, num_edges * sizeof(bool));
     return state;
 }
 
 /* Calculates the line_errors data, and checks if the current state is a
  * solution */
-static int check_completion(game_state *state)
+static bool check_completion(game_state *state)
 {
     grid *g = state->game_grid;
-    int i, ret;
+    int i;
+    bool ret;
     int *dsf, *component_state;
     int nsilly, nloop, npath, largest_comp, largest_size, total_pathsize;
     enum { COMP_NONE, COMP_LOOP, COMP_PATH, COMP_SILLY, COMP_EMPTY };
 
-    memset(state->line_errors, 0, g->num_edges);
+    memset(state->line_errors, 0, g->num_edges * sizeof(bool));
 
     /*
      * Find loops in the grid, and determine whether the puzzle is
@@ -1659,7 +1662,7 @@ static int check_completion(game_state *state)
             for (j = 0; j < d->order; j++) {
                 int e = d->edges[j] - g->edges;
                 if (state->lines[e] == LINE_YES)
-                    state->line_errors[e] = TRUE;
+                    state->line_errors[e] = true;
             }
             /* And mark this component as not worthy of further
              * consideration. */
@@ -1727,7 +1730,7 @@ static int check_completion(game_state *state)
                      -1 != largest_comp) ||
                     (component_state[comp] == COMP_LOOP &&
                      comp != largest_comp))
-                    state->line_errors[i] = TRUE;
+                    state->line_errors[i] = true;
             }
         }
     }
@@ -1737,12 +1740,12 @@ static int check_completion(game_state *state)
          * If there is exactly one component and it is a loop, then
          * the puzzle is potentially complete, so check the clues.
          */
-        ret = TRUE;
+        ret = true;
 
         for (i = 0; i < g->num_faces; i++) {
             int c = state->clues[i];
             if (c >= 0 && face_order(state, i, LINE_YES) != c) {
-                ret = FALSE;
+                ret = false;
                 break;
             }
         }
@@ -1753,10 +1756,10 @@ static int check_completion(game_state *state)
          * nothing else, which will be used to vary the semantics of
          * clue highlighting at display time.
          */
-        state->exactly_one_loop = TRUE;
+        state->exactly_one_loop = true;
     } else {
-        ret = FALSE;
-        state->exactly_one_loop = FALSE;
+        ret = false;
+        state->exactly_one_loop = false;
     }
 
     sfree(component_state);
@@ -1795,7 +1798,7 @@ static int check_completion(game_state *state)
  * A dline can be uniquely identified by an edge/dot combination, given that
  * a dline-pair always goes clockwise around its common dot.  The edge/dot
  * combination can be represented by an edge/bool combination - if bool is
- * TRUE, use edge->dot1 else use edge->dot2.  So the total number of dlines is
+ * true, use edge->dot1 else use edge->dot2.  So the total number of dlines is
  * exactly twice the number of edges in the grid - although the dlines
  * spanning the infinite face are not all that useful to the solver.
  * Note that, by convention, a dline goes clockwise around its common dot,
@@ -1850,19 +1853,19 @@ static int dline_index_from_face(grid *g, grid_face *f, int i)
 #endif
     return ret;
 }
-static int is_atleastone(const char *dline_array, int index)
+static bool is_atleastone(const char *dline_array, int index)
 {
     return BIT_SET(dline_array[index], 0);
 }
-static int set_atleastone(char *dline_array, int index)
+static bool set_atleastone(char *dline_array, int index)
 {
     return SET_BIT(dline_array[index], 0);
 }
-static int is_atmostone(const char *dline_array, int index)
+static bool is_atmostone(const char *dline_array, int index)
 {
     return BIT_SET(dline_array[index], 1);
 }
-static int set_atmostone(char *dline_array, int index)
+static bool set_atmostone(char *dline_array, int index)
 {
     return SET_BIT(dline_array[index], 1);
 }
@@ -1886,8 +1889,8 @@ static void array_setall(char *array, char from, char to, int len)
  * will find the opposite UNKNOWNS (if they are adjacent to one another)
  * and set their corresponding dline to atleastone.  (Setting atmostone
  * already happens in earlier dline deductions) */
-static int dline_set_opp_atleastone(solver_state *sstate,
-                                    grid_dot *d, int edge)
+static bool dline_set_opp_atleastone(solver_state *sstate,
+                                     grid_dot *d, int edge)
 {
     game_state *state = sstate->state;
     grid *g = state->game_grid;
@@ -1912,26 +1915,27 @@ static int dline_set_opp_atleastone(solver_state *sstate,
         opp_dline_index = dline_index_from_dot(g, d, opp);
         return set_atleastone(sstate->dlines, opp_dline_index);
     }
-    return FALSE;
+    return false;
 }
 
 
 /* Set pairs of lines around this face which are known to be identical, to
  * the given line_state */
-static int face_setall_identical(solver_state *sstate, int face_index,
-                                 enum line_state line_new)
+static bool face_setall_identical(solver_state *sstate, int face_index,
+                                  enum line_state line_new)
 {
     /* can[dir] contains the canonical line associated with the line in
      * direction dir from the square in question.  Similarly inv[dir] is
      * whether or not the line in question is inverse to its canonical
      * element. */
-    int retval = FALSE;
+    bool retval = false;
     game_state *state = sstate->state;
     grid *g = state->game_grid;
     grid_face *f = g->faces + face_index;
     int N = f->order;
     int i, j;
-    int can1, can2, inv1, inv2;
+    int can1, can2;
+    bool inv1, inv2;
 
     for (i = 0; i < N; i++) {
         int line1_index = f->edges[i] - g->edges;
@@ -1996,7 +2000,7 @@ static int parity_deductions(solver_state *sstate,
     } else if (unknown_count == 3) {
         int e[3];
         int can[3]; /* canonical edges */
-        int inv[3]; /* whether can[x] is inverse to e[x] */
+        bool inv[3]; /* whether can[x] is inverse to e[x] */
         find_unknowns(state, edge_list, 3, e);
         can[0] = edsf_canonify(linedsf, e[0], inv);
         can[1] = edsf_canonify(linedsf, e[1], inv+1);
@@ -2019,7 +2023,7 @@ static int parity_deductions(solver_state *sstate,
     } else if (unknown_count == 4) {
         int e[4];
         int can[4]; /* canonical edges */
-        int inv[4]; /* whether can[x] is inverse to e[x] */
+        bool inv[4]; /* whether can[x] is inverse to e[x] */
         find_unknowns(state, edge_list, 4, e);
         can[0] = edsf_canonify(linedsf, e[0], inv);
         can[1] = edsf_canonify(linedsf, e[1], inv+1);
@@ -2102,7 +2106,7 @@ static int trivial_deductions(solver_state *sstate)
         current_no  = sstate->face_no_count[i];
 
         if (current_yes + current_no == f->order)  {
-            sstate->face_solved[i] = TRUE;
+            sstate->face_solved[i] = true;
             continue;
         }
 
@@ -2123,7 +2127,7 @@ static int trivial_deductions(solver_state *sstate)
         if (state->clues[i] == current_yes) {
             if (face_setall(sstate, i, LINE_UNKNOWN, LINE_NO))
                 diff = min(diff, DIFF_EASY);
-            sstate->face_solved[i] = TRUE;
+            sstate->face_solved[i] = true;
             continue;
         }
 
@@ -2134,7 +2138,7 @@ static int trivial_deductions(solver_state *sstate)
         if (f->order - state->clues[i] == current_no) {
             if (face_setall(sstate, i, LINE_UNKNOWN, LINE_YES))
                 diff = min(diff, DIFF_EASY);
-            sstate->face_solved[i] = TRUE;
+            sstate->face_solved[i] = true;
             continue;
         }
 
@@ -2182,7 +2186,7 @@ static int trivial_deductions(solver_state *sstate)
             for (j = 0; j < f->order; j++) {
                 e = f->edges[j] - g->edges;
                 if (state->lines[e] == LINE_UNKNOWN && e != e1 && e != e2) {
-                    int r = solver_set_line(sstate, e, LINE_YES);
+                    bool r = solver_set_line(sstate, e, LINE_YES);
                     assert(r);
                     diff = min(diff, DIFF_EASY);
                 }
@@ -2206,11 +2210,11 @@ static int trivial_deductions(solver_state *sstate)
 
         if (yes == 0) {
             if (unknown == 0) {
-                sstate->dot_solved[i] = TRUE;
+                sstate->dot_solved[i] = true;
             } else if (unknown == 1) {
                 dot_setall(sstate, i, LINE_UNKNOWN, LINE_NO);
                 diff = min(diff, DIFF_EASY);
-                sstate->dot_solved[i] = TRUE;
+                sstate->dot_solved[i] = true;
             }
         } else if (yes == 1) {
             if (unknown == 0) {
@@ -2225,7 +2229,7 @@ static int trivial_deductions(solver_state *sstate)
                 dot_setall(sstate, i, LINE_UNKNOWN, LINE_NO);
                 diff = min(diff, DIFF_EASY);
             }
-            sstate->dot_solved[i] = TRUE;
+            sstate->dot_solved[i] = true;
         } else {
             sstate->solver_status = SOLVER_MISTAKE;
             return DIFF_EASY;
@@ -2627,7 +2631,8 @@ static int linedsf_deductions(solver_state *sstate)
             int dline_index = dline_index_from_dot(g, d, j);
             int line1_index;
             int line2_index;
-            int can1, can2, inv1, inv2;
+            int can1, can2;
+            bool inv1, inv2;
             int j2;
             line1_index = d->edges[j] - g->edges;
             if (state->lines[line1_index] != LINE_UNKNOWN)
@@ -2651,7 +2656,7 @@ static int linedsf_deductions(solver_state *sstate)
             /* Infer linedsf from dline flags */
             if (is_atmostone(dlines, dline_index)
 		&& is_atleastone(dlines, dline_index)) {
-                if (merge_lines(sstate, line1_index, line2_index, 1))
+                if (merge_lines(sstate, line1_index, line2_index, true))
                     diff = min(diff, DIFF_HARD);
             }
         }
@@ -2671,7 +2676,8 @@ static int linedsf_deductions(solver_state *sstate)
     /* If the state of a line is known, deduce the state of its canonical line
      * too, and vice versa. */
     for (i = 0; i < g->num_edges; i++) {
-        int can, inv;
+        int can;
+        bool inv;
         enum line_state s;
         can = edsf_canonify(sstate->linedsf, i, &inv);
         if (can == i)
@@ -2698,9 +2704,9 @@ static int loop_deductions(solver_state *sstate)
     game_state *state = sstate->state;
     grid *g = state->game_grid;
     int shortest_chainlen = g->num_dots;
-    int loop_found = FALSE;
+    bool loop_found = false;
     int dots_connected;
-    int progress = FALSE;
+    bool progress = false;
     int i;
 
     /*
@@ -2745,7 +2751,7 @@ static int loop_deductions(solver_state *sstate)
         sstate->solver_status = SOLVER_SOLVED;
         /* This discovery clearly counts as progress, even if we haven't
          * just added any lines or anything */
-        progress = TRUE;
+        progress = true;
         goto finished_loop_deductionsing;
     }
 
@@ -2833,7 +2839,7 @@ static int loop_deductions(solver_state *sstate)
          * make.
          */
         progress = solver_set_line(sstate, i, val);
-        assert(progress == TRUE);
+        assert(progress);
         if (val == LINE_YES) {
             sstate->solver_status = SOLVER_AMBIGUOUS;
             goto finished_loop_deductionsing;
@@ -3096,7 +3102,7 @@ static game_state *execute_move(const game_state *state, const char *move)
 
     if (move[0] == 'S') {
         move++;
-        newstate->cheated = TRUE;
+        newstate->cheated = true;
     }
 
     while (*move) {
@@ -3123,7 +3129,7 @@ static game_state *execute_move(const game_state *state, const char *move)
      * Check for completion.
      */
     if (check_completion(newstate))
-        newstate->solved = TRUE;
+        newstate->solved = true;
 
     return newstate;
 
@@ -3304,8 +3310,8 @@ static void game_redraw_dot(drawing *dr, game_drawstate *ds,
     draw_circle(dr, x, y, 2, COL_FOREGROUND, COL_FOREGROUND);
 }
 
-static int boxes_intersect(int x0, int y0, int w0, int h0,
-                           int x1, int y1, int w1, int h1)
+static bool boxes_intersect(int x0, int y0, int w0, int h0,
+                            int x1, int y1, int w1, int h1)
 {
     /*
      * Two intervals intersect iff neither is wholly on one side of
@@ -3360,8 +3366,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     grid *g = state->game_grid;
     int border = BORDER(ds->tilesize);
     int i;
-    int flash_changed;
-    int redraw_everything = FALSE;
+    bool flash_changed;
+    bool redraw_everything = false;
 
     int edges[REDRAW_OBJECTS_LIMIT], nedges = 0;
     int faces[REDRAW_OBJECTS_LIMIT], nfaces = 0;
@@ -3392,7 +3398,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      */
 
     if (!ds->started) {
-	redraw_everything = TRUE;
+	redraw_everything = true;
         /*
          * But we must still go through the upcoming loops, so that we
          * set up stuff in ds correctly for the initial redraw.
@@ -3404,8 +3410,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         grid_face *f = g->faces + i;
         int sides = f->order;
         int yes_order, no_order;
-        int clue_mistake;
-        int clue_satisfied;
+        bool clue_mistake;
+        bool clue_satisfied;
         int n = state->clues[i];
         if (n < 0)
             continue;
@@ -3456,7 +3462,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             ds->clue_error[i] = clue_mistake;
             ds->clue_satisfied[i] = clue_satisfied;
             if (nfaces == REDRAW_OBJECTS_LIMIT)
-                redraw_everything = TRUE;
+                redraw_everything = true;
             else
                 faces[nfaces++] = i;
         }
@@ -3467,10 +3473,10 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         (flashtime <= FLASH_TIME/3 ||
          flashtime >= FLASH_TIME*2/3)) {
         flash_changed = !ds->flashing;
-        ds->flashing = TRUE;
+        ds->flashing = true;
     } else {
         flash_changed = ds->flashing;
-        ds->flashing = FALSE;
+        ds->flashing = false;
     }
 
     /* Now, trundle through the edges. */
@@ -3481,7 +3487,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             (flash_changed && state->lines[i] == LINE_YES)) {
             ds->lines[i] = new_ds;
             if (nedges == REDRAW_OBJECTS_LIMIT)
-                redraw_everything = TRUE;
+                redraw_everything = true;
             else
                 edges[nedges++] = i;
         }
@@ -3517,7 +3523,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	}
     }
 
-    ds->started = TRUE;
+    ds->started = true;
 }
 
 static float game_flash_length(const game_state *oldstate,
@@ -3645,7 +3651,7 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
@@ -3653,7 +3659,7 @@ const struct game thegame = {
     dup_game,
     free_game,
     1, solve_game,
-    TRUE, game_can_format_as_text_now, game_text_format,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3670,9 +3676,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE /* wants_statusbar */,
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false /* wants_statusbar */,
+    false, game_timing_state,
     0,                                       /* mouse_priorities */
 };
 
@@ -3694,21 +3700,21 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
+    bool grade = false;
     int ret, diff;
 #if 0 /* verbose solver not supported here (yet) */
-    int really_verbose = FALSE;
+    bool really_verbose = false;
 #endif
 
     while (--argc > 0) {
         char *p = *++argv;
 #if 0 /* verbose solver not supported here (yet) */
         if (!strcmp(p, "-v")) {
-            really_verbose = TRUE;
+            really_verbose = true;
         } else
 #endif
 	if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
diff --git a/apps/plugins/puzzles/src/magnets.c b/apps/plugins/puzzles/src/magnets.c
index c9f97b63dd..1a5f37f1fd 100644
--- a/apps/plugins/puzzles/src/magnets.c
+++ b/apps/plugins/puzzles/src/magnets.c
@@ -41,7 +41,7 @@
 #include "puzzles.h"
 
 #ifdef STANDALONE_SOLVER
-int verbose = 0;
+bool verbose = 0;
 #endif
 
 enum {
@@ -88,7 +88,8 @@ static char const magnets_diffchars[] = DIFFLIST(ENCODE);
 /* Game parameter functions. */
 
 struct game_params {
-    int w, h, diff, stripclues;
+    int w, h, diff;
+    bool stripclues;
 };
 
 #define DEFAULT_PRESET 2
@@ -113,12 +114,12 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[64];
 
-    if (i < 0 || i >= lenof(magnets_presets)) return FALSE;
+    if (i < 0 || i >= lenof(magnets_presets)) return false;
 
     ret = default_params();
     *ret = magnets_presets[i]; /* struct copy */
@@ -130,7 +131,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
             magnets_presets[i].stripclues ? ", strip clues" : "");
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -165,14 +166,14 @@ static void decode_params(game_params *ret, char const *string)
 	if (*string) string++;
     }
 
-    ret->stripclues = 0;
+    ret->stripclues = false;
     if (*string == 'S') {
         string++;
-        ret->stripclues = 1;
+        ret->stripclues = true;
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -227,7 +228,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2) return "Width must be at least one";
     if (params->h < 2) return "Height must be at least one";
@@ -267,8 +268,8 @@ struct game_state {
     int w, h, wh;
     int *grid;                  /* size w*h, for cell state (pos/neg) */
     unsigned int *flags;        /* size w*h */
-    int solved, completed, numbered;
-    unsigned char *counts_done;
+    bool solved, completed, numbered;
+    bool *counts_done;
 
     struct game_common *common; /* domino layout never changes. */
 };
@@ -277,11 +278,13 @@ static void clear_state(game_state *ret)
 {
     int i;
 
-    ret->solved = ret->completed = ret->numbered = 0;
+    ret->solved = false;
+    ret->completed = false;
+    ret->numbered = false;
 
     memset(ret->common->rowcount, 0, ret->h*3*sizeof(int));
     memset(ret->common->colcount, 0, ret->w*3*sizeof(int));
-    memset(ret->counts_done, 0, (ret->h + ret->w) * 2 * sizeof(unsigned char));
+    memset(ret->counts_done, 0, (ret->h + ret->w) * 2 * sizeof(bool));
 
     for (i = 0; i < ret->wh; i++) {
         ret->grid[i] = EMPTY;
@@ -301,7 +304,7 @@ static game_state *new_state(int w, int h)
 
     ret->grid = snewn(ret->wh, int);
     ret->flags = snewn(ret->wh, unsigned int);
-    ret->counts_done = snewn((ret->h + ret->w) * 2, unsigned char);
+    ret->counts_done = snewn((ret->h + ret->w) * 2, bool);
 
     ret->common = snew(struct game_common);
     ret->common->refcount = 1;
@@ -333,9 +336,9 @@ static game_state *dup_game(const game_state *src)
     dest->grid = snewn(dest->wh, int);
     memcpy(dest->grid, src->grid, dest->wh*sizeof(int));
 
-    dest->counts_done = snewn((dest->h + dest->w) * 2, unsigned char);
+    dest->counts_done = snewn((dest->h + dest->w) * 2, bool);
     memcpy(dest->counts_done, src->counts_done,
-           (dest->h + dest->w) * 2 * sizeof(unsigned char));
+           (dest->h + dest->w) * 2 * sizeof(bool));
 
     dest->flags = snewn(dest->wh, unsigned int);
     memcpy(dest->flags, src->flags, dest->wh*sizeof(unsigned int));
@@ -518,7 +521,7 @@ nextchar:
         }
     }
     /* Success. */
-    state->numbered = 1;
+    state->numbered = true;
     goto done;
 
 badchar:
@@ -599,9 +602,9 @@ static void game_text_hborder(const game_state *state, char **p_r)
     *p_r = p;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -728,21 +731,22 @@ static int count_rowcol(const game_state *state, int num, int roworcol,
 }
 
 static void check_rowcol(game_state *state, int num, int roworcol, int which,
-                        int *wrong, int *incomplete)
+                         bool *wrong, bool *incomplete)
 {
     int count, target = mkrowcol(state, num, roworcol).targets[which];
 
     if (target == -1) return; /* no number to check against. */
 
     count = count_rowcol(state, num, roworcol, which);
-    if (count < target) *incomplete = 1;
-    if (count > target) *wrong = 1;
+    if (count < target) *incomplete = true;
+    if (count > target) *wrong = true;
 }
 
 static int check_completion(game_state *state)
 {
     int i, j, x, y, idx, w = state->w, h = state->h;
-    int which = POSITIVE, wrong = 0, incomplete = 0;
+    int which = POSITIVE;
+    bool wrong = false, incomplete = false;
 
     /* Check row and column counts for magnets. */
     for (which = POSITIVE, j = 0; j < 2; which = OPPOSITE(which), j++) {
@@ -762,14 +766,14 @@ static int check_completion(game_state *state)
                 continue; /* no domino here */
 
             if (!(state->flags[idx] & GS_SET))
-                incomplete = 1;
+                incomplete = true;
 
             which = state->grid[idx];
             if (which != NEUTRAL) {
 #define CHECK(xx,yy) do { \
     if (INGRID(state,xx,yy) && \
         (state->grid[(yy)*w+(xx)] == which)) { \
-        wrong = 1; \
+        wrong = true; \
         state->flags[(yy)*w+(xx)] |= GS_ERROR; \
         state->flags[y*w+x] |= GS_ERROR; \
     } \
@@ -1100,7 +1104,8 @@ static int solve_neither(game_state *state)
 
 static int solve_advancedfull(game_state *state, rowcol rc, int *counts)
 {
-    int i, j, nfound = 0, clearpos = 0, clearneg = 0, ret = 0;
+    int i, j, nfound = 0, ret = 0;
+    bool clearpos = false, clearneg = false;
 
     /* For this row/col, look for a domino entirely within the row where
      * both ends can only be + or - (but isn't held).
@@ -1146,11 +1151,11 @@ static int solve_advancedfull(game_state *state, rowcol rc, int *counts)
 
     if (rc.targets[POSITIVE] >= 0 && counts[POSITIVE] == rc.targets[POSITIVE]) {
         debug(("%s %d has now filled POSITIVE:", rc.name, rc.num));
-        clearpos = 1;
+        clearpos = true;
     }
     if (rc.targets[NEGATIVE] >= 0 && counts[NEGATIVE] == rc.targets[NEGATIVE]) {
         debug(("%s %d has now filled NEGATIVE:", rc.name, rc.num));
-        clearneg = 1;
+        clearneg = true;
     }
 
     if (!clearpos && !clearneg) return 0;
@@ -1202,7 +1207,8 @@ static int solve_nonneutral(game_state *state, rowcol rc, int *counts)
 static int solve_oddlength(game_state *state, rowcol rc, int *counts)
 {
     int i, j, ret = 0, extra, tpos, tneg;
-    int start = -1, length = 0, inempty = 0, startodd = -1;
+    int start = -1, length = 0, startodd = -1;
+    bool inempty = false;
 
     /* need zero neutral cells still to find... */
     if (rc.targets[NEUTRAL] != counts[NEUTRAL])
@@ -1225,7 +1231,7 @@ static int solve_oddlength(game_state *state, rowcol rc, int *counts)
                     if (startodd != -1) goto twoodd;
                     startodd = start;
                 }
-                inempty = 0;
+                inempty = false;
             }
         } else {
             if (inempty)
@@ -1233,7 +1239,7 @@ static int solve_oddlength(game_state *state, rowcol rc, int *counts)
             else {
                 start = i;
                 length = 1;
-                inempty = 1;
+                inempty = true;
             }
         }
     }
@@ -1259,7 +1265,8 @@ twoodd:
  * or to the #remaining negative, no empty cells can be neutral. */
 static int solve_countdominoes_neutral(game_state *state, rowcol rc, int *counts)
 {
-    int i, j, ndom = 0, nonn = 0, ret = 0;
+    int i, j, ndom = 0, ret = 0;
+    bool nonn = false;
 
     if ((rc.targets[POSITIVE] == -1) && (rc.targets[NEGATIVE] == -1))
         return 0; /* need at least one target to compare. */
@@ -1278,10 +1285,10 @@ static int solve_countdominoes_neutral(game_state *state, rowcol rc, int *counts
 
     if ((rc.targets[POSITIVE] != -1) &&
         (rc.targets[POSITIVE]-counts[POSITIVE] == ndom))
-        nonn = 1;
+        nonn = true;
     if ((rc.targets[NEGATIVE] != -1) &&
         (rc.targets[NEGATIVE]-counts[NEGATIVE] == ndom))
-        nonn = 1;
+        nonn = true;
 
     if (!nonn) return 0;
 
@@ -1400,7 +1407,7 @@ static int solve_state(game_state *state, int diff)
 
 
 static char *game_state_diff(const game_state *src, const game_state *dst,
-                             int issolve)
+                             bool issolve)
 {
     char *ret = NULL, buf[80], c;
     int retlen = 0, x, y, i, k;
@@ -1473,7 +1480,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 
 solved:
-    move = game_state_diff(currstate, solved, 1);
+    move = game_state_diff(currstate, solved, true);
     free_game(solved);
     return move;
 }
@@ -1598,7 +1605,7 @@ static void gen_game(game_state *new, random_state *rs)
             new->common->rowcount[y*3+val]++;
         }
     }
-    new->numbered = 1;
+    new->numbered = true;
 
     sfree(scratch);
 }
@@ -1684,7 +1691,7 @@ static int check_difficulty(const game_params *params, game_state *new,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux_r, int interactive)
+			   char **aux_r, bool interactive)
 {
     game_state *new = new_state(params->w, params->h);
     char *desc, *aux = snewn(new->wh+1, char);
@@ -1705,14 +1712,15 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 }
 
 struct game_ui {
-    int cur_x, cur_y, cur_visible;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
     ui->cur_x = ui->cur_y = 0;
-    ui->cur_visible = 0;
+    ui->cur_visible = false;
     return ui;
 }
 
@@ -1734,11 +1742,12 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
     if (!oldstate->completed && newstate->completed)
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 }
 
 struct game_drawstate {
-    int tilesize, started, solved;
+    int tilesize;
+    bool started, solved;
     int w, h;
     unsigned long *what;                /* size w*h */
     unsigned long *colwhat, *rowwhat;   /* size 3*w, 3*h */
@@ -1761,15 +1770,15 @@ struct game_drawstate {
 #define COORD(x) ( (x+1) * TILE_SIZE + BORDER )
 #define FROMCOORD(x) ( (x - BORDER) / TILE_SIZE - 1 )
 
-static int is_clue(const game_state *state, int x, int y)
+static bool is_clue(const game_state *state, int x, int y)
 {
     int h = state->h, w = state->w;
 
     if (((x == -1 || x == w) && y >= 0 && y < h) ||
         ((y == -1 || y == h) && x >= 0 && x < w))
-        return TRUE;
+        return true;
 
-    return FALSE;
+    return false;
 }
 
 static int clue_index(const game_state *state, int x, int y)
@@ -1797,12 +1806,12 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     enum { CYCLE_MAGNET, CYCLE_NEUTRAL } action;
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
-        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, false);
+        ui->cur_visible = true;
         return UI_UPDATE;
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         action = (button == CURSOR_SELECT) ? CYCLE_MAGNET : CYCLE_NEUTRAL;
@@ -1811,7 +1820,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     } else if (INGRID(state, gx, gy) &&
                (button == LEFT_BUTTON || button == RIGHT_BUTTON)) {
         if (ui->cur_visible) {
-            ui->cur_visible = 0;
+            ui->cur_visible = false;
             nullret = UI_UPDATE;
         }
         action = (button == LEFT_BUTTON) ? CYCLE_MAGNET : CYCLE_NEUTRAL;
@@ -1865,7 +1874,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move++;
         if (c == 'S') {
-            ret->solved = TRUE;
+            ret->solved = true;
             n = 0;
         } else if (c == '+' || c == '-' ||
                    c == '.' || c == ' ' || c == '?') {
@@ -1905,7 +1914,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         else if (*move) goto badmove;
     }
     if (check_completion(ret) == 1)
-        ret->completed = 1;
+        ret->completed = true;
 
     return ret;
 
@@ -1973,7 +1982,9 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 {
     struct game_drawstate *ds = snew(struct game_drawstate);
 
-    ds->tilesize = ds->started = ds->solved = 0;
+    ds->tilesize = 0;
+    ds->started = false;
+    ds->solved = false;
     ds->w = state->w;
     ds->h = state->h;
 
@@ -2188,7 +2199,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int x, y, w = state->w, h = state->h, which, i, j, flash;
+    int x, y, w = state->w, h = state->h, which, i, j;
+    bool flash;
 
     flash = (int)(flashtime * 5 / FLASH_TIME) % 2;
 
@@ -2261,7 +2273,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         }
     }
 
-    ds->started = 1;
+    ds->started = true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -2284,9 +2296,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2396,15 +2408,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2421,9 +2433,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -2433,7 +2445,7 @@ const struct game thegame = {
 #include <stdarg.h>
 
 const char *quis = NULL;
-int csv = 0;
+bool csv = false;
 
 void usage(FILE *out) {
     fprintf(out, "usage: %s [-v] [--print] <params>|<game id>\n", quis);
@@ -2535,7 +2547,8 @@ static void start_soak(game_params *p, random_state *rs)
 
 int main(int argc, const char *argv[])
 {
-    int print = 0, soak = 0, solved = 0, ret;
+    bool print = false, soak = false, solved = false;
+    int ret;
     char *id = NULL, *desc, *desc_gen = NULL, *aux = NULL;
     const char *err;
     game_state *s = NULL;
@@ -2549,16 +2562,16 @@ int main(int argc, const char *argv[])
     while (--argc > 0) {
         char *p = (char*)(*++argv);
         if (!strcmp(p, "-v") || !strcmp(p, "--verbose")) {
-            verbose = 1;
+            verbose = true;
         } else if (!strcmp(p, "--csv")) {
-            csv = 1;
+            csv = true;
         } else if (!strcmp(p, "-e") || !strcmp(p, "--seed")) {
             seed = atoi(*++argv);
             argc--;
         } else if (!strcmp(p, "-p") || !strcmp(p, "--print")) {
-            print = 1;
+            print = true;
         } else if (!strcmp(p, "-s") || !strcmp(p, "--soak")) {
-            soak = 1;
+            soak = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             usage(stderr);
@@ -2579,7 +2592,7 @@ int main(int argc, const char *argv[])
 
     p = default_params();
     decode_params(p, id);
-    err = validate_params(p, 1);
+    err = validate_params(p, true);
     if (err) {
         fprintf(stderr, "%s: %s", argv[0], err);
         goto done;
@@ -2595,7 +2608,7 @@ int main(int argc, const char *argv[])
     }
 
     if (!desc)
-        desc = desc_gen = new_game_desc(p, rs, &aux, 0);
+        desc = desc_gen = new_game_desc(p, rs, &aux, false);
 
     err = validate_desc(p, desc);
     if (err) {
@@ -2609,17 +2622,17 @@ int main(int argc, const char *argv[])
         if (verbose || print) {
             doprint(s);
             solve_from_aux(s, aux);
-            solved = 1;
+            solved = true;
         }
     } else {
         doprint(s);
-        verbose = 1;
+        verbose = true;
         ret = solve_state(s, DIFFCOUNT);
         if (ret < 0) printf("Puzzle is impossible.\n");
         else if (ret == 0) printf("Puzzle is ambiguous.\n");
         else printf("Puzzle was solved.\n");
-        verbose = 0;
-        solved = 1;
+        verbose = false;
+        solved = true;
     }
     if (solved) doprint(s);
 
diff --git a/apps/plugins/puzzles/src/map.c b/apps/plugins/puzzles/src/map.c
index 203751016c..4e65aa91a6 100644
--- a/apps/plugins/puzzles/src/map.c
+++ b/apps/plugins/puzzles/src/map.c
@@ -25,9 +25,9 @@
  */
 #if defined STANDALONE_SOLVER
 #define SOLVER_DIAGNOSTICS
-int verbose = FALSE;
+bool verbose = false;
 #elif defined SOLVER_DIAGNOSTICS
-#define verbose TRUE
+#define verbose true
 #endif
 
 /*
@@ -84,7 +84,7 @@ struct map {
     int *graph;
     int n;
     int ngraph;
-    int *immutable;
+    bool *immutable;
     int *edgex, *edgey;		       /* position of a point on each edge */
     int *regionx, *regiony;            /* position of a point in each region */
 };
@@ -93,7 +93,7 @@ struct game_state {
     game_params p;
     struct map *map;
     int *colouring, *pencil;
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -131,13 +131,13 @@ static const struct game_params map_presets[] = {
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(map_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = map_presets[i];
@@ -147,7 +147,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -192,7 +192,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
 
@@ -248,7 +248,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must be at least two";
@@ -680,8 +680,8 @@ static int graph_vertex_start(int *graph, int n, int ngraph, int i)
  * the sake of the Palm port and its limited stack.
  */
 
-static int fourcolour_recurse(int *graph, int n, int ngraph,
-			      int *colouring, int *scratch, random_state *rs)
+static bool fourcolour_recurse(int *graph, int n, int ngraph,
+                               int *colouring, int *scratch, random_state *rs)
 {
     int nfree, nvert, start, i, j, k, c, ci;
     int cs[FOUR];
@@ -706,7 +706,7 @@ static int fourcolour_recurse(int *graph, int n, int ngraph,
      * If there aren't any uncoloured vertices at all, we're done.
      */
     if (nvert == 0)
-	return TRUE;		       /* we've got a colouring! */
+	return true;		       /* we've got a colouring! */
 
     /*
      * Pick a random vertex in that set.
@@ -752,7 +752,7 @@ static int fourcolour_recurse(int *graph, int n, int ngraph,
 	 * Recurse.
 	 */
 	if (fourcolour_recurse(graph, n, ngraph, colouring, scratch, rs))
-	    return TRUE;	       /* got one! */
+	    return true;	       /* got one! */
 
 	/*
 	 * If that didn't work, clean up and try again with a
@@ -775,7 +775,7 @@ static int fourcolour_recurse(int *graph, int n, int ngraph,
      * violation if we get all the way back up to the top level and
      * still fail.)
      */
-    return FALSE;
+    return false;
 }
 
 static void fourcolour(int *graph, int n, int ngraph, int *colouring,
@@ -783,6 +783,7 @@ static void fourcolour(int *graph, int n, int ngraph, int *colouring,
 {
     int *scratch;
     int i;
+    bool retd;
 
     /*
      * For each vertex and each colour, we store the number of
@@ -799,8 +800,8 @@ static void fourcolour(int *graph, int n, int ngraph, int *colouring,
     for (i = 0; i < n; i++)
 	colouring[i] = -1;
 
-    i = fourcolour_recurse(graph, n, ngraph, colouring, scratch, rs);
-    assert(i);			       /* by the Four Colour Theorem :-) */
+    retd = fourcolour_recurse(graph, n, ngraph, colouring, scratch, rs);
+    assert(retd);                 /* by the Four Colour Theorem :-) */
 
     sfree(scratch);
 }
@@ -870,12 +871,12 @@ static int bitcount(int word)
 static const char colnames[FOUR] = { 'R', 'Y', 'G', 'B' };
 #endif
 
-static int place_colour(struct solver_scratch *sc,
-			int *colouring, int index, int colour
+static bool place_colour(struct solver_scratch *sc,
+                         int *colouring, int index, int colour
 #ifdef SOLVER_DIAGNOSTICS
-                        , const char *verb
+                         , const char *verb
 #endif
-                        )
+                         )
 {
     int *graph = sc->graph, n = sc->n, ngraph = sc->ngraph;
     int j, k;
@@ -886,7 +887,7 @@ static int place_colour(struct solver_scratch *sc,
             printf("%*scannot place %c in region %d\n", 2*sc->depth, "",
                    colnames[colour], index);
 #endif
-	return FALSE;		       /* can't do it */
+	return false;		       /* can't do it */
     }
 
     sc->possible[index] = 1 << colour;
@@ -912,7 +913,7 @@ static int place_colour(struct solver_scratch *sc,
 	sc->possible[k] &= ~(1 << colour);
     }
 
-    return TRUE;
+    return true;
 }
 
 #ifdef SOLVER_DIAGNOSTICS
@@ -974,7 +975,7 @@ static int map_solver(struct solver_scratch *sc,
      * Now repeatedly loop until we find nothing further to do.
      */
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 
         if (difficulty < DIFF_EASY)
             break;                     /* can't do anything at all! */
@@ -996,7 +997,8 @@ static int map_solver(struct solver_scratch *sc,
             }
 
 	    if ((p & (p-1)) == 0) {    /* p is a power of two */
-		int c, ret;
+		int c;
+                bool ret;
 		for (c = 0; c < FOUR; c++)
 		    if (p == (1 << c))
 			break;
@@ -1015,7 +1017,7 @@ static int map_solver(struct solver_scratch *sc,
                  * friendly error code.
                  */
                 assert(ret);
-		done_something = TRUE;
+		done_something = true;
 	    }
 	}
 
@@ -1040,7 +1042,7 @@ static int map_solver(struct solver_scratch *sc,
             int j1 = graph[i] / n, j2 = graph[i] % n;
             int j, k, v, v2;
 #ifdef SOLVER_DIAGNOSTICS
-            int started = FALSE;
+            bool started = false;
 #endif
 
             if (j1 > j2)
@@ -1084,13 +1086,13 @@ static int map_solver(struct solver_scratch *sc,
                             printf("%*sadjacent regions %d,%d share colours"
                                    " %s\n", 2*sc->depth, "", j1, j2,
                                    colourset(buf, v));
-                        started = TRUE;
+                        started = true;
                         printf("%*s  ruling out %s in region %d\n",2*sc->depth,
                                "", colourset(buf, sc->possible[k] & v), k);
                     }
 #endif
                     sc->possible[k] &= ~v;
-                    done_something = TRUE;
+                    done_something = true;
                 }
             }
         }
@@ -1231,7 +1233,7 @@ static int map_solver(struct solver_scratch *sc,
                                 }
 #endif
                                 sc->possible[k] &= ~origc;
-                                done_something = TRUE;
+                                done_something = true;
                             }
                         }
                     }
@@ -1279,7 +1281,7 @@ static int map_solver(struct solver_scratch *sc,
         struct solver_scratch *rsc;
         int *subcolouring, *origcolouring;
         int ret, subret;
-        int we_already_got_one;
+        bool we_already_got_one;
 
         best = -1;
         bestc = FIVE;
@@ -1315,7 +1317,7 @@ static int map_solver(struct solver_scratch *sc,
         origcolouring = snewn(n, int);
         memcpy(origcolouring, colouring, n * sizeof(int));
         subcolouring = snewn(n, int);
-        we_already_got_one = FALSE;
+        we_already_got_one = false;
         ret = 0;
 
         for (i = 0; i < FOUR; i++) {
@@ -1359,7 +1361,7 @@ static int map_solver(struct solver_scratch *sc,
              */
             if (subret == 1) {
                 memcpy(colouring, subcolouring, n * sizeof(int));
-                we_already_got_one = TRUE;
+                we_already_got_one = true;
                 ret = 1;
             }
 
@@ -1390,7 +1392,7 @@ static int map_solver(struct solver_scratch *sc,
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     struct solver_scratch *sc = NULL;
     int *map, *graph, ngraph, *colouring, *colouring2, *regions;
@@ -1601,7 +1603,8 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     ret = NULL;
 
     {
-	int run, pv;
+	int run;
+        bool pv;
 
 	/*
 	 * Start with a notional non-edge, so that there'll be an
@@ -1609,10 +1612,11 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 	 * an edge.
 	 */
 	run = 1;
-	pv = 0;
+	pv = false;
 
 	for (i = 0; i < w*(h-1) + (w-1)*h; i++) {
-	    int x, y, dx, dy, v;
+	    int x, y, dx, dy;
+            bool v;
 
 	    if (i < w*(h-1)) {
 		/* Horizontal edge. */
@@ -1704,13 +1708,14 @@ static const char *parse_edge_list(const game_params *params,
                                    const char **desc, int *map)
 {
     int w = params->w, h = params->h, wh = w*h, n = params->n;
-    int i, k, pos, state;
+    int i, k, pos;
+    bool state;
     const char *p = *desc;
 
     dsf_init(map+wh, wh);
 
     pos = -1;
-    state = 0;
+    state = false;
 
     /*
      * Parse the game description to get the list of edges, and
@@ -1828,16 +1833,17 @@ static game_state *new_game(midend *me, const game_params *params,
     for (i = 0; i < n; i++)
 	state->pencil[i] = 0;
 
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     state->map = snew(struct map);
     state->map->refcount = 1;
     state->map->map = snewn(wh*4, int);
     state->map->graph = snewn(n*n, int);
     state->map->n = n;
-    state->map->immutable = snewn(n, int);
+    state->map->immutable = snewn(n, bool);
     for (i = 0; i < n; i++)
-	state->map->immutable[i] = FALSE;
+	state->map->immutable[i] = false;
 
     p = desc;
 
@@ -1863,7 +1869,7 @@ static game_state *new_game(midend *me, const game_params *params,
     while (*p) {
 	if (*p >= '0' && *p < '0'+FOUR) {
 	    state->colouring[pos] = *p - '0';
-	    state->map->immutable[pos] = TRUE;
+	    state->map->immutable[pos] = true;
 	    pos++;
 	} else {
 	    assert(*p >= 'a' && *p <= 'z');
@@ -1882,14 +1888,14 @@ static game_state *new_game(midend *me, const game_params *params,
     {
         random_state *rs = random_new(desc, strlen(desc));
         int *squares = snewn(wh, int);
-        int done_something;
+        bool done_something;
 
         for (i = 0; i < wh; i++)
             squares[i] = i;
         shuffle(squares, wh, sizeof(*squares), rs);
 
         do {
-            done_something = FALSE;
+            done_something = false;
             for (i = 0; i < wh; i++) {
                 int y = squares[i] / w, x = squares[i] % w;
                 int c = state->map->map[y*w+x];
@@ -1920,7 +1926,7 @@ static game_state *new_game(midend *me, const game_params *params,
                         state->map->map[BE * wh + y*w+x] = bc;
                         state->map->map[LE * wh + y*w+x] = lc;
                         state->map->map[RE * wh + y*w+x] = rc;
-                        done_something = TRUE;
+                        done_something = true;
                     }
                 }
             }
@@ -2246,9 +2252,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr(aux);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -2268,9 +2274,10 @@ struct game_ui {
     int drag_colour;
     int drag_pencil;
     int dragx, dragy;
-    int show_numbers;
+    bool show_numbers;
 
-    int cur_x, cur_y, cur_visible, cur_moved, cur_lastmove;
+    int cur_x, cur_y, cur_lastmove;
+    bool cur_visible, cur_moved;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -2279,8 +2286,10 @@ static game_ui *new_ui(const game_state *state)
     ui->dragx = ui->dragy = -1;
     ui->drag_colour = -2;
     ui->drag_pencil = 0;
-    ui->show_numbers = FALSE;
-    ui->cur_x = ui->cur_y = ui->cur_visible = ui->cur_moved = 0;
+    ui->show_numbers = false;
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
+    ui->cur_moved = false;
     ui->cur_lastmove = 0;
     return ui;
 }
@@ -2307,8 +2316,9 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     int tilesize;
     unsigned long *drawn, *todraw;
-    int started;
-    int dragx, dragy, drag_visible;
+    bool started;
+    int dragx, dragy;
+    bool drag_visible;
     blitter *bl;
 };
 
@@ -2383,7 +2393,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                             int x, int y, int button)
 {
     char *bufp, buf[256];
-    int alt_button, drop_region;
+    bool alt_button;
+    int drop_region;
 
     /*
      * Enable or disable numeric labels on regions.
@@ -2394,15 +2405,16 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     }
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->p.w, state->p.h, 0);
-        ui->cur_visible = 1;
-        ui->cur_moved = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->p.w, state->p.h,
+                    false);
+        ui->cur_visible = true;
+        ui->cur_moved = true;
         ui->cur_lastmove = button;
         return UI_UPDATE;
     }
     if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         if (ui->drag_colour == -2) { /* not currently cursor-dragging, start. */
@@ -2414,10 +2426,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 ui->drag_colour = -1;
                 ui->drag_pencil = 0;
             }
-            ui->cur_moved = 0;
+            ui->cur_moved = false;
             return UI_UPDATE;
         } else { /* currently cursor-dragging; drop the colour in the new region. */
-            alt_button = (button == CURSOR_SELECT2) ? 1 : 0;
+            alt_button = (button == CURSOR_SELECT2);
             /* Double-select removes current colour. */
             if (!ui->cur_moved) ui->drag_colour = -1;
             drop_region = region_from_ui_cursor(state, ui);
@@ -2439,7 +2451,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	}
         ui->dragx = x;
         ui->dragy = y;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
         return UI_UPDATE;
     }
 
@@ -2452,7 +2464,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
     if ((button == LEFT_RELEASE || button == RIGHT_RELEASE) &&
         ui->drag_colour > -2) {
-        alt_button = (button == RIGHT_RELEASE) ? 1 : 0;
+        alt_button = (button == RIGHT_RELEASE);
         drop_region = region_from_coords(state, ds, x, y);
         goto drag_dropped;
     }
@@ -2518,11 +2530,11 @@ static game_state *execute_move(const game_state *state, const char *move)
     int c, k, adv, i;
 
     while (*move) {
-        int pencil = FALSE;
+        bool pencil = false;
 
 	c = *move;
         if (c == 'p') {
-            pencil = TRUE;
+            pencil = true;
             c = *++move;
         }
 	if ((c == 'C' || (c >= '0' && c < '0'+FOUR)) &&
@@ -2544,7 +2556,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             }
 	} else if (*move == 'S') {
 	    move++;
-	    ret->cheated = TRUE;
+	    ret->cheated = true;
 	} else {
 	    free_game(ret);
 	    return NULL;
@@ -2562,11 +2574,11 @@ static game_state *execute_move(const game_state *state, const char *move)
      * Check for completion.
      */
     if (!ret->completed) {
-	int ok = TRUE;
+	bool ok = true;
 
 	for (i = 0; i < n; i++)
 	    if (ret->colouring[i] < 0) {
-		ok = FALSE;
+		ok = false;
 		break;
 	    }
 
@@ -2575,14 +2587,14 @@ static game_state *execute_move(const game_state *state, const char *move)
 		int j = ret->map->graph[i] / n;
 		int k = ret->map->graph[i] % n;
 		if (ret->colouring[j] == ret->colouring[k]) {
-		    ok = FALSE;
+		    ok = false;
 		    break;
 		}
 	    }
 	}
 
 	if (ok)
-	    ret->completed = TRUE;
+	    ret->completed = true;
     }
 
     return ret;
@@ -2612,7 +2624,7 @@ static void game_set_size(drawing *dr, game_drawstate *ds,
     ds->bl = blitter_new(dr, TILESIZE+3, TILESIZE+3);
 }
 
-const float map_colours[FOUR][3] = {
+static const float map_colours[FOUR][3] = {
 #ifdef VIVID_COLOURS
     /* Use more vivid colours (e.g. on the Pocket PC) */
     {0.75F, 0.25F, 0.25F},
@@ -2626,7 +2638,7 @@ const float map_colours[FOUR][3] = {
     {0.55F, 0.45F, 0.35F},
 #endif
 };
-const int map_hatching[FOUR] = {
+static const int map_hatching[FOUR] = {
     HATCH_VERT, HATCH_SLASH, HATCH_HORIZ, HATCH_BACKSLASH
 };
 
@@ -2667,9 +2679,9 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     for (i = 0; i < state->p.w * state->p.h; i++)
 	ds->drawn[i] = 0xFFFFL;
     ds->todraw = snewn(state->p.w * state->p.h, unsigned long);
-    ds->started = FALSE;
+    ds->started = false;
     ds->bl = NULL;
-    ds->drag_visible = FALSE;
+    ds->drag_visible = false;
     ds->dragx = ds->dragy = -1;
 
     return ds;
@@ -2857,7 +2869,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     if (ds->drag_visible) {
         blitter_load(dr, ds->bl, ds->dragx, ds->dragy);
         draw_update(dr, ds->dragx, ds->dragy, TILESIZE + 3, TILESIZE + 3);
-        ds->drag_visible = FALSE;
+        ds->drag_visible = false;
     }
 
     /*
@@ -2875,7 +2887,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 		  COL_GRID);
 
 	draw_update(dr, 0, 0, ww, wh);
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     if (flashtime) {
@@ -2987,7 +2999,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      * Draw the dragged colour blob if any.
      */
     if ((ui->drag_colour > -2) || ui->cur_visible) {
-        int bg, iscur = 0, cursor_x, cursor_y;
+        int bg, cursor_x, cursor_y;
+        bool iscur = false;
         if (ui->drag_colour >= 0)
             bg = COL_0 + ui->drag_colour;
         else if (ui->drag_colour == -1) {
@@ -2997,7 +3010,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             int c = (r < 0) ? -1 : state->colouring[r];
             /*bg = COL_GRID;*/
             bg = (c < 0) ? COL_BACKGROUND : COL_0 + c;
-            iscur = 1;
+            iscur = true;
         }
 
         if (ui->cur_visible) {
@@ -3020,7 +3033,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 			    cursor_y + (i*2-3) * TILESIZE/10,
 			    TILESIZE/8, COL_0 + i, COL_0 + i);
         draw_update(dr, ds->dragx, ds->dragy, TILESIZE + 3, TILESIZE + 3);
-        ds->drag_visible = TRUE;
+        ds->drag_visible = true;
     }
 }
 
@@ -3053,9 +3066,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -3223,15 +3236,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3248,9 +3261,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, TRUE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, true, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
@@ -3262,17 +3275,18 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
-    int ret, diff, really_verbose = FALSE;
+    bool grade = false;
+    int ret, diff;
+    bool really_verbose = false;
     struct solver_scratch *sc;
     int i;
 
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            really_verbose = TRUE;
+            really_verbose = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
diff --git a/apps/plugins/puzzles/src/matching.c b/apps/plugins/puzzles/src/matching.c
index 89f67ee83e..9078f6c36a 100644
--- a/apps/plugins/puzzles/src/matching.c
+++ b/apps/plugins/puzzles/src/matching.c
@@ -135,7 +135,7 @@ int matching_with_scratch(void *scratchv,
 
         layer = 0;
         while (1) {
-            int found_free_R_vertex = FALSE;
+            bool found_free_R_vertex = false;
 
             Rqs = 0;
             for (i = 0; i < Lqs; i++) {
@@ -148,7 +148,7 @@ int matching_with_scratch(void *scratchv,
                         s->Rlayer[R] = layer+1;
                         s->Rqueue[Rqs++] = R;
                         if (s->RtoL[R] == -1)
-                            found_free_R_vertex = TRUE;
+                            found_free_R_vertex = true;
                     }
                 }
             }
@@ -685,7 +685,7 @@ int main(int argc, char **argv)
 {
     static const char stdin_identifier[] = "<standard input>";
     const char *infile = NULL;
-    int doing_opts = TRUE;
+    bool doing_opts = true;
     enum { USER_INPUT, AUTOTEST } mode = USER_INPUT;
 
     while (--argc > 0) {
@@ -693,7 +693,7 @@ int main(int argc, char **argv)
 
         if (doing_opts && arg[0] == '-' && arg[1]) {
             if (!strcmp(arg, "--")) {
-                doing_opts = FALSE;
+                doing_opts = false;
             } else if (!strcmp(arg, "--random")) {
                 char buf[64];
                 int len = sprintf(buf, "%lu", (unsigned long)time(NULL));
diff --git a/apps/plugins/puzzles/src/midend.c b/apps/plugins/puzzles/src/midend.c
index a42e51639e..036c8569c7 100644
--- a/apps/plugins/puzzles/src/midend.c
+++ b/apps/plugins/puzzles/src/midend.c
@@ -69,7 +69,7 @@ struct midend {
     struct midend_state_entry *states;
 
     struct midend_serialise_buf newgame_undo, newgame_redo;
-    int newgame_can_store_undo;
+    bool newgame_can_store_undo;
 
     game_params *params, *curparams;
     game_drawstate *drawstate;
@@ -80,7 +80,7 @@ struct midend {
     float flash_time, flash_pos;
     int dir;
 
-    int timing;
+    bool timing;
     float elapsed;
     char *laststatus;
 
@@ -122,7 +122,7 @@ struct deserialise_data {
  * Forward reference.
  */
 static const char *midend_deserialise_internal(
-    midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx,
+    midend *me, bool (*read)(void *ctx, void *buf, int len), void *rctx,
     const char *(*check)(void *ctx, midend *, const struct deserialise_data *),
     void *cctx);
 
@@ -167,7 +167,7 @@ midend *midend_new(frontend *fe, const game *ourgame,
     me->newgame_undo.size = me->newgame_undo.len = 0;
     me->newgame_redo.buf = NULL;
     me->newgame_redo.size = me->newgame_redo.len = 0;
-    me->newgame_can_store_undo = FALSE;
+    me->newgame_can_store_undo = false;
     me->params = ourgame->default_params();
     me->game_id_change_notify_function = NULL;
     me->game_id_change_notify_ctx = NULL;
@@ -202,7 +202,7 @@ midend *midend_new(frontend *fe, const game *ourgame,
     me->ui = NULL;
     me->pressed_mouse_button = 0;
     me->laststatus = NULL;
-    me->timing = FALSE;
+    me->timing = false;
     me->elapsed = 0.0F;
     me->tilesize = me->winwidth = me->winheight = 0;
     if (drapi)
@@ -297,7 +297,7 @@ static void midend_size_new_drawstate(midend *me)
     }
 }
 
-void midend_size(midend *me, int *x, int *y, int user_size)
+void midend_size(midend *me, int *x, int *y, bool user_size)
 {
     int min, max;
     int rx, ry;
@@ -315,7 +315,7 @@ void midend_size(midend *me, int *x, int *y, int user_size)
 
     /*
      * Find the tile size that best fits within the given space. If
-     * `user_size' is TRUE, we must actually find the _largest_ such
+     * `user_size' is true, we must actually find the _largest_ such
      * tile size, in order to get as close to the user's explicit
      * request as possible; otherwise, we bound above at the game's
      * preferred tile size, so that the game gets what it wants
@@ -542,15 +542,15 @@ void midend_new_game(midend *me)
     if (me->game_id_change_notify_function)
         me->game_id_change_notify_function(me->game_id_change_notify_ctx);
 
-    me->newgame_can_store_undo = TRUE;
+    me->newgame_can_store_undo = true;
 }
 
-int midend_can_undo(midend *me)
+bool midend_can_undo(midend *me)
 {
     return (me->statepos > 1 || me->newgame_undo.len);
 }
 
-int midend_can_redo(midend *me)
+bool midend_can_redo(midend *me)
 {
     return (me->statepos < me->nstates || me->newgame_redo.len);
 }
@@ -560,18 +560,20 @@ struct newgame_undo_deserialise_read_ctx {
     int len, pos;
 };
 
-static int newgame_undo_deserialise_read(void *ctx, void *buf, int len)
+static bool newgame_undo_deserialise_read(void *ctx, void *buf, int len)
 {
     struct newgame_undo_deserialise_read_ctx *const rctx = ctx;
 
-    int use = min(len, rctx->len - rctx->pos);
-    memcpy(buf, rctx->ser->buf + rctx->pos, use);
-    rctx->pos += use;
-    return use;
+    if (len > rctx->len - rctx->pos)
+        return false;
+
+    memcpy(buf, rctx->ser->buf + rctx->pos, len);
+    rctx->pos += len;
+    return true;
 }
 
 struct newgame_undo_deserialise_check_ctx {
-    int refused;
+    bool refused;
 };
 
 static const char *newgame_undo_deserialise_check(
@@ -604,19 +606,19 @@ static const char *newgame_undo_deserialise_check(
      * We check both params and cparams, to be as safe as possible.
      */
 
-    old = me->ourgame->encode_params(me->params, TRUE);
-    new = me->ourgame->encode_params(data->params, TRUE);
+    old = me->ourgame->encode_params(me->params, true);
+    new = me->ourgame->encode_params(data->params, true);
     if (strcmp(old, new)) {
         /* Set a flag to distinguish this deserialise failure
          * from one due to faulty decoding */
-        ctx->refused = TRUE;
+        ctx->refused = true;
         return "Undoing this new-game operation would change params";
     }
 
-    old = me->ourgame->encode_params(me->curparams, TRUE);
-    new = me->ourgame->encode_params(data->cparams, TRUE);
+    old = me->ourgame->encode_params(me->curparams, true);
+    new = me->ourgame->encode_params(data->cparams, true);
     if (strcmp(old, new)) {
-        ctx->refused = TRUE;
+        ctx->refused = true;
         return "Undoing this new-game operation would change params";
     }
 
@@ -626,7 +628,7 @@ static const char *newgame_undo_deserialise_check(
     return NULL;
 }
 
-static int midend_undo(midend *me)
+static bool midend_undo(midend *me)
 {
     const char *deserialise_error;
 
@@ -637,7 +639,7 @@ static int midend_undo(midend *me)
                                        me->states[me->statepos-2].state);
 	me->statepos--;
         me->dir = -1;
-        return 1;
+        return true;
     } else if (me->newgame_undo.len) {
 	struct newgame_undo_deserialise_read_ctx rctx;
 	struct newgame_undo_deserialise_check_ctx cctx;
@@ -655,7 +657,7 @@ static int midend_undo(midend *me)
 	rctx.ser = &me->newgame_undo;
 	rctx.len = me->newgame_undo.len; /* copy for reentrancy safety */
 	rctx.pos = 0;
-        cctx.refused = FALSE;
+        cctx.refused = false;
         deserialise_error = midend_deserialise_internal(
             me, newgame_undo_deserialise_read, &rctx,
             newgame_undo_deserialise_check, &cctx);
@@ -667,7 +669,7 @@ static int midend_undo(midend *me)
              * function, which we ignore.)
              */
             sfree(serbuf.buf);
-            return 0;
+            return false;
         } else {
             /*
              * There should never be any _other_ deserialisation
@@ -693,13 +695,13 @@ static int midend_undo(midend *me)
             newgame_serialise_write(&me->newgame_redo, serbuf.buf, serbuf.len);
 
             sfree(serbuf.buf);
-            return 1;
+            return true;
         }
     } else
-        return 0;
+        return false;
 }
 
-static int midend_redo(midend *me)
+static bool midend_redo(midend *me)
 {
     const char *deserialise_error;
 
@@ -710,7 +712,7 @@ static int midend_redo(midend *me)
                                        me->states[me->statepos].state);
 	me->statepos++;
         me->dir = +1;
-        return 1;
+        return true;
     } else if (me->newgame_redo.len) {
 	struct newgame_undo_deserialise_read_ctx rctx;
 	struct newgame_undo_deserialise_check_ctx cctx;
@@ -728,7 +730,7 @@ static int midend_redo(midend *me)
 	rctx.ser = &me->newgame_redo;
 	rctx.len = me->newgame_redo.len; /* copy for reentrancy safety */
 	rctx.pos = 0;
-        cctx.refused = FALSE;
+        cctx.refused = false;
         deserialise_error = midend_deserialise_internal(
             me, newgame_undo_deserialise_read, &rctx,
             newgame_undo_deserialise_check, &cctx);
@@ -740,7 +742,7 @@ static int midend_redo(midend *me)
              * function, which we ignore.)
              */
             sfree(serbuf.buf);
-            return 0;
+            return false;
         } else {
             /*
              * There should never be any _other_ deserialisation
@@ -766,10 +768,10 @@ static int midend_redo(midend *me)
             newgame_serialise_write(&me->newgame_undo, serbuf.buf, serbuf.len);
 
             sfree(serbuf.buf);
-            return 1;
+            return true;
         }
     } else
-        return 0;
+        return false;
 }
 
 static void midend_finish_move(midend *me)
@@ -850,11 +852,12 @@ void midend_restart_game(midend *me)
     midend_set_timer(me);
 }
 
-static int midend_really_process_key(midend *me, int x, int y, int button)
+static bool midend_really_process_key(midend *me, int x, int y, int button)
 {
     game_state *oldstate =
         me->ourgame->dup_game(me->states[me->statepos - 1].state);
-    int type = MOVE, gottype = FALSE, ret = 1;
+    int type = MOVE;
+    bool gottype = false, ret = true;
     float anim_time;
     game_state *s;
     char *movestr = NULL;
@@ -876,7 +879,7 @@ static int midend_really_process_key(midend *me, int x, int y, int button)
                    button == UI_UNDO) {
 	    midend_stop_anim(me);
 	    type = me->states[me->statepos-1].movetype;
-	    gottype = TRUE;
+	    gottype = true;
 	    if (!midend_undo(me))
 		goto done;
 	} else if (button == 'r' || button == 'R' ||
@@ -891,7 +894,7 @@ static int midend_really_process_key(midend *me, int x, int y, int button)
 		goto done;
 	} else if (button == 'q' || button == 'Q' || button == '\x11' ||
                    button == UI_QUIT) {
-	    ret = 0;
+	    ret = false;
 	    goto done;
 	} else
 	    goto done;
@@ -965,9 +968,9 @@ static int midend_really_process_key(midend *me, int x, int y, int button)
     return ret;
 }
 
-int midend_process_key(midend *me, int x, int y, int button)
+bool midend_process_key(midend *me, int x, int y, int button)
 {
-    int ret = 1;
+    bool ret = true;
 
     /*
      * Harmonise mouse drag and release messages.
@@ -1159,7 +1162,7 @@ void midend_freeze_timer(midend *me, float tprop)
 
 void midend_timer(midend *me, float tplus)
 {
-    int need_redraw = (me->anim_time > 0 || me->flash_time > 0);
+    bool need_redraw = (me->anim_time > 0 || me->flash_time > 0);
 
     me->anim_pos += tplus;
     if (me->anim_pos >= me->anim_time ||
@@ -1281,7 +1284,7 @@ game_params *preset_menu_lookup_by_id(struct preset_menu *menu, int id)
 }
 
 static char *preset_menu_add_from_user_env(
-    midend *me, struct preset_menu *menu, char *p, int top_level)
+    midend *me, struct preset_menu *menu, char *p, bool top_level)
 {
     while (*p) {
         char *name, *val;
@@ -1302,7 +1305,7 @@ static char *preset_menu_add_from_user_env(
             if (*name) {
                 struct preset_menu *submenu =
                     preset_menu_add_submenu(menu, dupstr(name));
-                p = preset_menu_add_from_user_env(me, submenu, p, FALSE);
+                p = preset_menu_add_from_user_env(me, submenu, p, false);
             } else {
                 /*
                  * If we get a 'close submenu' indication at the top
@@ -1318,7 +1321,7 @@ static char *preset_menu_add_from_user_env(
         preset = me->ourgame->default_params();
         me->ourgame->decode_params(preset, val);
 
-        if (me->ourgame->validate_params(preset, TRUE)) {
+        if (me->ourgame->validate_params(preset, true)) {
             /* Drop this one from the list. */
             me->ourgame->free_params(preset);
             continue;
@@ -1349,7 +1352,7 @@ static void preset_menu_encode_params(midend *me, struct preset_menu *menu)
     for (i = 0; i < menu->n_entries; i++) {
         if (menu->entries[i].params) {
             me->encoded_presets[menu->entries[i].id] =
-                me->ourgame->encode_params(menu->entries[i].params, TRUE);
+                me->ourgame->encode_params(menu->entries[i].params, true);
         } else {
             preset_menu_encode_params(me, menu->entries[i].submenu);
         }
@@ -1404,7 +1407,7 @@ struct preset_menu *midend_get_presets(midend *me, int *id_limit)
 
         if ((e = getenv(buf)) != NULL) {
             e = dupstr(e);
-            preset_menu_add_from_user_env(me, me->preset_menu, e, TRUE);
+            preset_menu_add_from_user_env(me, me->preset_menu, e, true);
             sfree(e);
         }
     }
@@ -1428,7 +1431,7 @@ struct preset_menu *midend_get_presets(midend *me, int *id_limit)
 
 int midend_which_preset(midend *me)
 {
-    char *encoding = me->ourgame->encode_params(me->params, TRUE);
+    char *encoding = me->ourgame->encode_params(me->params, true);
     int i, ret;
 
     ret = -1;
@@ -1443,7 +1446,7 @@ int midend_which_preset(midend *me)
     return ret;
 }
 
-int midend_wants_statusbar(midend *me)
+bool midend_wants_statusbar(midend *me)
 {
     return me->ourgame->wants_statusbar;
 }
@@ -1535,7 +1538,7 @@ static const char *midend_game_id_int(midend *me, const char *id, int defmode)
     char *par = NULL;
     const char *desc, *seed;
     game_params *newcurparams, *newparams, *oldparams1, *oldparams2;
-    int free_params;
+    bool free_params;
 
     seed = strchr(id, '#');
     desc = strchr(id, ':');
@@ -1650,18 +1653,18 @@ static const char *midend_game_id_int(midend *me, const char *id, int defmode)
 
             newparams = me->ourgame->dup_params(me->params);
 
-            tmpstr = me->ourgame->encode_params(newcurparams, FALSE);
+            tmpstr = me->ourgame->encode_params(newcurparams, false);
             me->ourgame->decode_params(newparams, tmpstr);
 
             sfree(tmpstr);
         } else {
             newparams = me->ourgame->dup_params(newcurparams);
         }
-        free_params = TRUE;
+        free_params = true;
     } else {
         newcurparams = me->curparams;
         newparams = me->params;
-        free_params = FALSE;
+        free_params = false;
     }
 
     if (desc) {
@@ -1708,7 +1711,7 @@ static const char *midend_game_id_int(midend *me, const char *id, int defmode)
 
     sfree(par);
 
-    me->newgame_can_store_undo = FALSE;
+    me->newgame_can_store_undo = false;
 
     return NULL;
 }
@@ -1722,7 +1725,7 @@ char *midend_get_game_id(midend *me)
 {
     char *parstr, *ret;
 
-    parstr = me->ourgame->encode_params(me->curparams, FALSE);
+    parstr = me->ourgame->encode_params(me->curparams, false);
     assert(parstr);
     assert(me->desc);
     ret = snewn(strlen(parstr) + strlen(me->desc) + 2, char);
@@ -1738,7 +1741,7 @@ char *midend_get_random_seed(midend *me)
     if (!me->seedstr)
         return NULL;
 
-    parstr = me->ourgame->encode_params(me->curparams, TRUE);
+    parstr = me->ourgame->encode_params(me->curparams, true);
     assert(parstr);
     ret = snewn(strlen(parstr) + strlen(me->seedstr) + 2, char);
     sprintf(ret, "%s#%s", parstr, me->seedstr);
@@ -1754,7 +1757,7 @@ const char *midend_set_config(midend *me, int which, config_item *cfg)
     switch (which) {
       case CFG_SETTINGS:
 	params = me->ourgame->custom_params(cfg);
-	error = me->ourgame->validate_params(params, TRUE);
+	error = me->ourgame->validate_params(params, true);
 
 	if (error) {
 	    me->ourgame->free_params(params);
@@ -1777,12 +1780,12 @@ const char *midend_set_config(midend *me, int which, config_item *cfg)
     return NULL;
 }
 
-int midend_can_format_as_text_now(midend *me)
+bool midend_can_format_as_text_now(midend *me)
 {
     if (me->ourgame->can_format_as_text_ever)
 	return me->ourgame->can_format_as_text_now(me->params);
     else
-	return FALSE;
+	return false;
 }
 
 char *midend_text_format(midend *me)
@@ -1947,7 +1950,7 @@ void midend_serialise(midend *me,
      * The current long-term parameters structure, in full.
      */
     if (me->params) {
-        char *s = me->ourgame->encode_params(me->params, TRUE);
+        char *s = me->ourgame->encode_params(me->params, true);
         wr("PARAMS", s);
         sfree(s);
     }
@@ -1956,7 +1959,7 @@ void midend_serialise(midend *me,
      * The current short-term parameters structure, in full.
      */
     if (me->curparams) {
-        char *s = me->ourgame->encode_params(me->curparams, TRUE);
+        char *s = me->ourgame->encode_params(me->curparams, true);
         wr("CPARAMS", s);
         sfree(s);
     }
@@ -1985,7 +1988,7 @@ void midend_serialise(midend *me,
         len = strlen(me->aux_info);
         s1 = snewn(len, unsigned char);
         memcpy(s1, me->aux_info, len);
-        obfuscate_bitmap(s1, len*8, FALSE);
+        obfuscate_bitmap(s1, len*8, false);
         s2 = bin2hex(s1, len);
 
         wr("AUXINFO", s2);
@@ -2058,13 +2061,13 @@ void midend_serialise(midend *me,
  * success, or an error message.
  */
 static const char *midend_deserialise_internal(
-    midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx,
+    midend *me, bool (*read)(void *ctx, void *buf, int len), void *rctx,
     const char *(*check)(void *ctx, midend *, const struct deserialise_data *),
     void *cctx)
 {
     struct deserialise_data data;
     int gotstates = 0;
-    int started = FALSE;
+    bool started = false;
     int i;
 
     char *val = NULL;
@@ -2144,7 +2147,7 @@ static const char *midend_deserialise_internal(
             }
             /* Now most errors are this one, unless otherwise specified */
             ret = "Saved data ended unexpectedly";
-            started = TRUE;
+            started = true;
         } else {
             if (!strcmp(key, "VERSION")) {
                 if (strcmp(val, SERIALISE_VERSION)) {
@@ -2181,7 +2184,7 @@ static const char *midend_deserialise_internal(
                 unsigned char *tmp;
                 int len = strlen(val) / 2;   /* length in bytes */
                 tmp = hex2bin(val, len);
-                obfuscate_bitmap(tmp, len*8, TRUE);
+                obfuscate_bitmap(tmp, len*8, true);
 
                 sfree(data.auxinfo);
                 data.auxinfo = snewn(len + 1, char);
@@ -2236,17 +2239,17 @@ static const char *midend_deserialise_internal(
 
     data.params = me->ourgame->default_params();
     me->ourgame->decode_params(data.params, data.parstr);
-    if (me->ourgame->validate_params(data.params, TRUE)) {
+    if (me->ourgame->validate_params(data.params, true)) {
         ret = "Long-term parameters in save file are invalid";
         goto cleanup;
     }
     data.cparams = me->ourgame->default_params();
     me->ourgame->decode_params(data.cparams, data.cparstr);
-    if (me->ourgame->validate_params(data.cparams, FALSE)) {
+    if (me->ourgame->validate_params(data.cparams, false)) {
         ret = "Short-term parameters in save file are invalid";
         goto cleanup;
     }
-    if (data.seed && me->ourgame->validate_params(data.cparams, TRUE)) {
+    if (data.seed && me->ourgame->validate_params(data.cparams, true)) {
         /*
          * The seed's no use with this version, but we can perfectly
          * well use the rest of the data.
@@ -2426,7 +2429,7 @@ static const char *midend_deserialise_internal(
 }
 
 const char *midend_deserialise(
-    midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx)
+    midend *me, bool (*read)(void *ctx, void *buf, int len), void *rctx)
 {
     return midend_deserialise_internal(me, read, rctx, NULL, NULL);
 }
@@ -2439,11 +2442,11 @@ const char *midend_deserialise(
  * failure.
  */
 const char *identify_game(char **name,
-                          int (*read)(void *ctx, void *buf, int len),
+                          bool (*read)(void *ctx, void *buf, int len),
                           void *rctx)
 {
     int nstates = 0, statepos = -1, gotstates = 0;
-    int started = FALSE;
+    bool started = false;
 
     char *val = NULL;
     /* Initially all errors give the same report */
@@ -2513,7 +2516,7 @@ const char *identify_game(char **name,
             }
             /* Now most errors are this one, unless otherwise specified */
             ret = "Saved data ended unexpectedly";
-            started = TRUE;
+            started = true;
         } else {
             if (!strcmp(key, "VERSION")) {
                 if (strcmp(val, SERIALISE_VERSION)) {
@@ -2537,7 +2540,7 @@ const char *identify_game(char **name,
     return ret;
 }
 
-const char *midend_print_puzzle(midend *me, document *doc, int with_soln)
+const char *midend_print_puzzle(midend *me, document *doc, bool with_soln)
 {
     game_state *soln = NULL;
 
diff --git a/apps/plugins/puzzles/src/mines.c b/apps/plugins/puzzles/src/mines.c
index 0a66a25d8a..c9d9852573 100644
--- a/apps/plugins/puzzles/src/mines.c
+++ b/apps/plugins/puzzles/src/mines.c
@@ -43,7 +43,7 @@ enum {
 
 struct game_params {
     int w, h, n;
-    int unique;
+    bool unique;
 };
 
 struct mine_layout {
@@ -52,19 +52,20 @@ struct mine_layout {
      * given instance of the puzzle, so we reference-count it.
      */
     int refcount;
-    char *mines;
+    bool *mines;
     /*
      * If we haven't yet actually generated the mine layout, here's
      * all the data we will need to do so.
      */
-    int n, unique;
+    int n;
+    bool unique;
     random_state *rs;
     midend *me;		       /* to give back the new game desc */
 };
 
 struct game_state {
-    int w, h, n, dead, won;
-    int used_solve;
+    int w, h, n;
+    bool dead, won, used_solve;
     struct mine_layout *layout;	       /* real mine positions */
     signed char *grid;			       /* player knowledge */
     /*
@@ -97,29 +98,29 @@ static game_params *default_params(void)
 
     ret->w = ret->h = 9;
     ret->n = 10;
-    ret->unique = TRUE;
+    ret->unique = true;
 
     return ret;
 }
 
 static const struct game_params mines_presets[] = {
-  {9, 9, 10, TRUE},
-  {9, 9, 35, TRUE},
-  {16, 16, 40, TRUE},
-  {16, 16, 99, TRUE},
+  {9, 9, 10, true},
+  {9, 9, 35, true},
+  {16, 16, 40, true},
+  {16, 16, 99, true},
 #ifndef SMALL_SCREEN
-  {30, 16, 99, TRUE},
-  {30, 16, 170, TRUE},
+  {30, 16, 99, true},
+  {30, 16, 170, true},
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(mines_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = mines_presets[i];
@@ -128,7 +129,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -167,13 +168,13 @@ static void decode_params(game_params *params, char const *string)
     while (*p) {
 	if (*p == 'a') {
             p++;
-	    params->unique = FALSE;
+	    params->unique = false;
 	} else
 	    p++;		       /* skip any other gunk */
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -239,7 +240,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Lower limit on grid size: each dimension must be at least 3.
@@ -298,7 +299,7 @@ static int bitcount16(int inword)
  */
 struct set {
     short x, y, mask, mines;
-    int todo;
+    bool todo;
     struct set *prev, *next;
 };
 
@@ -342,7 +343,7 @@ static struct setstore *ss_new(void)
  * with the second. Return the new mask part of the first set.
  */
 static int setmunge(int x1, int y1, int mask1, int x2, int y2, int mask2,
-		    int diff)
+		    bool diff)
 {
     /*
      * Adjust the second set so that it has the same x,y
@@ -403,7 +404,7 @@ static void ss_add_todo(struct setstore *ss, struct set *s)
 	ss->todo_head = s;
     ss->todo_tail = s;
     s->next = NULL;
-    s->todo = TRUE;
+    s->todo = true;
 }
 
 static void ss_add(struct setstore *ss, int x, int y, int mask, int mines)
@@ -429,7 +430,7 @@ static void ss_add(struct setstore *ss, int x, int y, int mask, int mines)
     s->y = y;
     s->mask = mask;
     s->mines = mines;
-    s->todo = FALSE;
+    s->todo = false;
     if (add234(ss->sets, s) != s) {
 	/*
 	 * This set already existed! Free it and return.
@@ -465,7 +466,7 @@ static void ss_remove(struct setstore *ss, struct set *s)
     else if (s == ss->todo_tail)
 	ss->todo_tail = prev;
 
-    s->todo = FALSE;
+    s->todo = false;
 
     /*
      * Remove s from the tree.
@@ -509,7 +510,7 @@ static struct set **ss_overlap(struct setstore *ss, int x, int y, int mask)
 		     * really overlap, and add it to the list if
 		     * so.
 		     */
-		    if (setmunge(x, y, mask, s->x, s->y, s->mask, FALSE)) {
+		    if (setmunge(x, y, mask, s->x, s->y, s->mask, false)) {
 			/*
 			 * There's an overlap.
 			 */
@@ -544,7 +545,7 @@ static struct set *ss_todo(struct setstore *ss)
 	else
 	    ss->todo_tail = NULL;
 	ret->next = ret->prev = NULL;
-	ret->todo = FALSE;
+	ret->todo = false;
 	return ret;
     } else {
 	return NULL;
@@ -571,7 +572,7 @@ typedef int (*open_cb)(void *, int, int);
 static void known_squares(int w, int h, struct squaretodo *std,
                           signed char *grid,
 			  open_cb open, void *openctx,
-			  int x, int y, int mask, int mine)
+			  int x, int y, int mask, bool mine)
 {
     int xx, yy, bit;
 
@@ -673,7 +674,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
      * Main deductive loop.
      */
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 	struct set *s;
 
 	/*
@@ -742,7 +743,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		     * Compute the mask for this set minus the
 		     * newly known square.
 		     */
-		    newmask = setmunge(s->x, s->y, s->mask, x, y, 1, TRUE);
+		    newmask = setmunge(s->x, s->y, s->mask, x, y, 1, true);
 
 		    /*
 		     * Compute the new mine count.
@@ -770,7 +771,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 	     * Marking a fresh square as known certainly counts as
 	     * doing something.
 	     */
-	    done_something = TRUE;
+	    done_something = true;
 	}
 
 	/*
@@ -827,9 +828,9 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		 * s2-s.
 		 */
 		swing = setmunge(s->x, s->y, s->mask, s2->x, s2->y, s2->mask,
-				 TRUE);
+				 true);
 		s2wing = setmunge(s2->x, s2->y, s2->mask, s->x, s->y, s->mask,
-				 TRUE);
+				 true);
 		swc = bitcount16(swing);
 		s2wc = bitcount16(s2wing);
 
@@ -876,7 +877,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 	     * _something_, even if it's only reducing the size of
 	     * our to-do list.
 	     */
-	    done_something = TRUE;
+	    done_something = true;
 	} else if (n >= 0) {
 	    /*
 	     * We have nothing left on our todo list, which means
@@ -893,7 +894,8 @@ static int minesolve(int w, int h, int n, signed char *grid,
 	     */
 
 	    int minesleft, squaresleft;
-	    int nsets, setused[10], cursor;
+	    int nsets, cursor;
+            bool setused[10];
 
 	    /*
 	     * Start by scanning the current grid state to work out
@@ -974,10 +976,9 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		 * I'm going to use a virtual recursion within this
 		 * function. The way this works is:
 		 * 
-		 *  - we have an array `setused', such that
-		 *    setused[n] is 0 or 1 depending on whether set
-		 *    n is currently in the union we are
-		 *    considering.
+		 *  - we have an array `setused', such that setused[n]
+		 *    is true if set n is currently in the union we
+		 *    are considering.
 		 * 
 		 *  - we have a value `cursor' which indicates how
 		 *    much of `setused' we have so far filled in.
@@ -985,11 +986,10 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		 * 
 		 * We begin by setting `cursor' to zero. Then:
 		 * 
-		 *  - if cursor can advance, we advance it by one.
-		 *    We set the value in `setused' that it went
-		 *    past to 1 if that set is disjoint from
-		 *    anything else currently in `setused', or to 0
-		 *    otherwise.
+		 *  - if cursor can advance, we advance it by one. We
+		 *    set the value in `setused' that it went past to
+		 *    true if that set is disjoint from anything else
+		 *    currently in `setused', or to false otherwise.
 		 * 
 		 *  - If cursor cannot advance because it has
 		 *    reached the end of the setused list, then we
@@ -998,10 +998,10 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		 *    properties. If so, mark all the squares not
 		 *    in the union as known and terminate.
 		 * 
-		 *  - If cursor has reached the end of setused and
-		 *    the algorithm _hasn't_ terminated, back
-		 *    cursor up to the nearest 1, turn it into a 0
-		 *    and advance cursor just past it.
+		 *  - If cursor has reached the end of setused and the
+		 *    algorithm _hasn't_ terminated, back cursor up to
+		 *    the nearest true entry, reset it to false, and
+		 *    advance cursor just past it.
 		 * 
 		 *  - If we attempt to back up to the nearest 1 and
 		 *    there isn't one at all, then we have gone
@@ -1017,7 +1017,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 		while (1) {
 
 		    if (cursor < nsets) {
-			int ok = TRUE;
+			bool ok = true;
 
 			/* See if any existing set overlaps this one. */
 			for (i = 0; i < cursor; i++)
@@ -1026,8 +1026,8 @@ static int minesolve(int w, int h, int n, signed char *grid,
 					 sets[cursor]->y,
 					 sets[cursor]->mask,
 					 sets[i]->x, sets[i]->y, sets[i]->mask,
-					 FALSE)) {
-				ok = FALSE;
+					 false)) {
+				ok = false;
 				break;
 			    }
 
@@ -1067,15 +1067,15 @@ static int minesolve(int w, int h, int n, signed char *grid,
 			     */
 			    for (i = 0; i < w*h; i++)
 				if (grid[i] == -2) {
-				    int outside = TRUE;
+                                    bool outside = true;
 				    y = i / w;
 				    x = i % w;
 				    for (j = 0; j < nsets; j++)
 					if (setused[j] &&
 					    setmunge(sets[j]->x, sets[j]->y,
 						     sets[j]->mask, x, y, 1,
-						     FALSE)) {
-					    outside = FALSE;
+						     false)) {
+					    outside = false;
 					    break;
 					}
 				    if (outside)
@@ -1084,7 +1084,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 						      x, y, 1, minesleft != 0);
 				}
 
-			    done_something = TRUE;
+			    done_something = true;
 			    break;     /* return to main deductive loop */
 			}
 
@@ -1106,7 +1106,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
 			    minesleft += sets[cursor]->mines;
 			    squaresleft += bitcount16(sets[cursor]->mask);
 
-			    setused[cursor++] = 0;
+			    setused[cursor++] = false;
 			} else {
 			    /*
 			     * We've backtracked all the way to the
@@ -1301,10 +1301,10 @@ static int minesolve(int w, int h, int n, signed char *grid,
  */
 
 struct minectx {
-    char *grid;
+    bool *grid;
     int w, h;
     int sx, sy;
-    int allow_big_perturbs;
+    bool allow_big_perturbs;
     random_state *rs;
 };
 
@@ -1722,15 +1722,15 @@ static struct perturbations *mineperturb(void *vctx, signed char *grid,
     return ret;
 }
 
-static char *minegen(int w, int h, int n, int x, int y, int unique,
+static bool *minegen(int w, int h, int n, int x, int y, bool unique,
 		     random_state *rs)
 {
-    char *ret = snewn(w*h, char);
-    int success;
+    bool *ret = snewn(w*h, bool);
+    bool success;
     int ntries = 0;
 
     do {
-	success = FALSE;
+	success = false;
 	ntries++;
 
 	memset(ret, 0, w*h);
@@ -1758,7 +1758,7 @@ static char *minegen(int w, int h, int n, int x, int y, int unique,
 	    nn = n;
 	    while (nn-- > 0) {
 		i = random_upto(rs, k);
-		ret[tmp[i]] = 1;
+		ret[tmp[i]] = true;
 		tmp[i] = tmp[--k];
 	    }
 
@@ -1816,17 +1816,17 @@ static char *minegen(int w, int h, int n, int x, int y, int unique,
 		solveret =
 		    minesolve(w, h, n, solvegrid, mineopen, mineperturb, ctx, rs);
 		if (solveret < 0 || (prevret >= 0 && solveret >= prevret)) {
-		    success = FALSE;
+		    success = false;
 		    break;
 		} else if (solveret == 0) {
-		    success = TRUE;
+		    success = true;
 		    break;
 		}
 	    }
 
 	    sfree(solvegrid);
 	} else {
-	    success = TRUE;
+	    success = true;
 	}
 
     } while (!success);
@@ -1834,8 +1834,8 @@ static char *minegen(int w, int h, int n, int x, int y, int unique,
     return ret;
 }
 
-static char *describe_layout(char *grid, int area, int x, int y,
-                             int obfuscate)
+static char *describe_layout(bool *grid, int area, int x, int y,
+                             bool obfuscate)
 {
     char *ret, *p;
     unsigned char *bmp;
@@ -1851,7 +1851,7 @@ static char *describe_layout(char *grid, int area, int x, int y,
             bmp[i / 8] |= 0x80 >> (i % 8);
     }
     if (obfuscate)
-        obfuscate_bitmap(bmp, area, FALSE);
+        obfuscate_bitmap(bmp, area, false);
 
     /*
      * Now encode the resulting bitmap in hex. We can work to
@@ -1875,13 +1875,13 @@ static char *describe_layout(char *grid, int area, int x, int y,
     return ret;
 }
 
-static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
+static bool *new_mine_layout(int w, int h, int n, int x, int y, bool unique,
 			     random_state *rs, char **game_desc)
 {
-    char *grid;
+    bool *grid;
 
 #ifdef TEST_OBFUSCATION
-    static int tested_obfuscation = FALSE;
+    static int tested_obfuscation = false;
     if (!tested_obfuscation) {
 	/*
 	 * A few simple test vectors for the obfuscator.
@@ -1897,10 +1897,10 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 	 */
 	{
 	    unsigned char bmp1[] = "\x12\x34\x56\x70";
-	    obfuscate_bitmap(bmp1, 28, FALSE);
+	    obfuscate_bitmap(bmp1, 28, false);
 	    printf("test 1 encode: %s\n",
 		   memcmp(bmp1, "\x07\xfa\x65\x00", 4) ? "failed" : "passed");
-	    obfuscate_bitmap(bmp1, 28, TRUE);
+	    obfuscate_bitmap(bmp1, 28, true);
 	    printf("test 1 decode: %s\n",
 		   memcmp(bmp1, "\x12\x34\x56\x70", 4) ? "failed" : "passed");
 	}
@@ -1914,7 +1914,7 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 	    unsigned char bmp2a[50];
 	    memset(bmp2, 0, 50);
 	    memset(bmp2a, 0, 50);
-	    obfuscate_bitmap(bmp2, 50 * 8, FALSE);
+	    obfuscate_bitmap(bmp2, 50 * 8, false);
 	    /*
 	     * SHA of twenty-five zero bytes plus "0" is
 	     * b202c07b990c01f6ff2d544707f60e506019b671. SHA of
@@ -1936,7 +1936,7 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 			  "\xb5\xa2\x10\xb0\xaf\x91\x3d\xb8\x5d\x37\xca\x27"
 			  "\xf5\x2a\x9f\x78\xbb\xa3\xa8\x00\x30\xdb\x3d\x01"
 			  "\xd8\xdf\x78", 50) ? "failed" : "passed");
-	    obfuscate_bitmap(bmp2, 50 * 8, TRUE);
+	    obfuscate_bitmap(bmp2, 50 * 8, true);
 	    printf("test 2 decode: %s\n",
 		   memcmp(bmp2, bmp2a, 50) ? "failed" : "passed");
 	}
@@ -1946,13 +1946,13 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
     grid = minegen(w, h, n, x, y, unique, rs);
 
     if (game_desc)
-        *game_desc = describe_layout(grid, w * h, x, y, TRUE);
+        *game_desc = describe_layout(grid, w * h, x, y, true);
 
     return grid;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     /*
      * We generate the coordinates of an initial click even if they
@@ -1972,7 +1972,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 	/*
 	 * For batch-generated grids, pre-open one square.
 	 */
-	char *grid;
+	bool *grid;
 	char *desc;
 
 	grid = new_mine_layout(params->w, params->h, params->n,
@@ -2081,7 +2081,7 @@ static int open_square(game_state *state, int x, int y)
 	 * mine that killed them, but not the rest (in case they
 	 * want to Undo and carry on playing).
 	 */
-	state->dead = TRUE;
+	state->dead = true;
 	state->grid[y*w+x] = 65;
 	return -1;
     }
@@ -2101,7 +2101,7 @@ static int open_square(game_state *state, int x, int y)
      * using repeated N^2 scans of the grid.
      */
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 
 	for (yy = 0; yy < h; yy++)
 	    for (xx = 0; xx < w; xx++)
@@ -2130,7 +2130,7 @@ static int open_square(game_state *state, int x, int y)
 				    state->grid[(yy+dy)*w+(xx+dx)] = -10;
 		    }
 
-		    done_something = TRUE;
+		    done_something = true;
 		}
 
 	if (!done_something)
@@ -2157,7 +2157,7 @@ static int open_square(game_state *state, int x, int y)
 		if (state->grid[yy*w+xx] < 0)
 		    state->grid[yy*w+xx] = -1;
 	}
-	state->won = TRUE;
+	state->won = true;
     }
 
     return 0;
@@ -2167,14 +2167,15 @@ static game_state *new_game(midend *me, const game_params *params,
                             const char *desc)
 {
     game_state *state = snew(game_state);
-    int i, wh, x, y, masked;
+    int i, wh, x, y;
+    bool masked;
     unsigned char *bmp;
 
     state->w = params->w;
     state->h = params->h;
     state->n = params->n;
-    state->dead = state->won = FALSE;
-    state->used_solve = FALSE;
+    state->dead = state->won = false;
+    state->used_solve = false;
 
     wh = state->w * state->h;
 
@@ -2192,9 +2193,9 @@ static game_state *new_game(midend *me, const game_params *params,
 	    desc++;		       /* skip over mine count */
 	if (*desc) desc++;	       /* eat comma */
 	if (*desc == 'a')
-	    state->layout->unique = FALSE;
+	    state->layout->unique = false;
 	else
-	    state->layout->unique = TRUE;
+	    state->layout->unique = true;
 	desc++;
 	if (*desc) desc++;	       /* eat comma */
 
@@ -2205,7 +2206,7 @@ static game_state *new_game(midend *me, const game_params *params,
     } else {
 	state->layout->rs = NULL;
 	state->layout->me = NULL;
-	state->layout->mines = snewn(wh, char);
+	state->layout->mines = snewn(wh, bool);
 
 	if (*desc && isdigit((unsigned char)*desc)) {
 	    x = atoi(desc);
@@ -2221,7 +2222,7 @@ static game_state *new_game(midend *me, const game_params *params,
 	}
 
 	if (*desc == 'm') {
-	    masked = TRUE;
+	    masked = true;
 	    desc++;
 	} else {
 	    if (*desc == 'u')
@@ -2230,7 +2231,7 @@ static game_state *new_game(midend *me, const game_params *params,
 	     * We permit game IDs to be entered by hand without the
 	     * masking transformation.
 	     */
-	    masked = FALSE;
+	    masked = false;
 	}
 
 	bmp = snewn((wh + 7) / 8, unsigned char);
@@ -2253,12 +2254,12 @@ static game_state *new_game(midend *me, const game_params *params,
 	}
 
 	if (masked)
-	    obfuscate_bitmap(bmp, wh, TRUE);
+	    obfuscate_bitmap(bmp, wh, true);
 
-	memset(state->layout->mines, 0, wh);
+	memset(state->layout->mines, 0, wh * sizeof(bool));
 	for (i = 0; i < wh; i++) {
 	    if (bmp[i / 8] & (0x80 >> (i % 8)))
-		state->layout->mines[i] = 1;
+		state->layout->mines[i] = true;
 	}
 
 	if (x >= 0 && y >= 0)
@@ -2310,9 +2311,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -2346,9 +2347,11 @@ static char *game_text_format(const game_state *state)
 struct game_ui {
     int hx, hy, hradius;	       /* for mouse-down highlights */
     int validradius;
-    int flash_is_death;
-    int deaths, completed;
-    int cur_x, cur_y, cur_visible;
+    bool flash_is_death;
+    int deaths;
+    bool completed;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -2357,9 +2360,10 @@ static game_ui *new_ui(const game_state *state)
     ui->hx = ui->hy = -1;
     ui->hradius = ui->validradius = 0;
     ui->deaths = 0;
-    ui->completed = FALSE;
-    ui->flash_is_death = FALSE;	       /* *shrug* */
-    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    ui->completed = false;
+    ui->flash_is_death = false;	       /* *shrug* */
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
     return ui;
 }
 
@@ -2386,18 +2390,19 @@ static void decode_ui(game_ui *ui, const char *encoding)
     int p= 0;
     sscanf(encoding, "D%d%n", &ui->deaths, &p);
     if (encoding[p] == 'C')
-	ui->completed = TRUE;
+	ui->completed = true;
 }
 
 static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
     if (newstate->won)
-	ui->completed = TRUE;
+	ui->completed = true;
 }
 
 struct game_drawstate {
-    int w, h, started, tilesize, bg;
+    int w, h, tilesize, bg;
+    bool started;
     signed char *grid;
     /*
      * Items in this `grid' array have all the same values as in
@@ -2426,15 +2431,15 @@ static char *interpret_move(const game_state *from, game_ui *ui,
     cy = FROMCOORD(y);
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, 0);
-        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, false);
+        ui->cur_visible = true;
         return UI_UPDATE;
     }
     if (IS_CURSOR_SELECT(button)) {
         int v = from->grid[ui->cur_y * from->w + ui->cur_x];
 
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         if (button == CURSOR_SELECT2) {
@@ -2474,7 +2479,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
 	    ui->validradius = ui->hradius;
 	else if (button == MIDDLE_BUTTON)
 	    ui->validradius = 1;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 	return UI_UPDATE;
     }
 
@@ -2645,7 +2650,7 @@ static game_state *execute_move(const game_state *from, const char *move)
                     }
                 }
         }
-        ret->used_solve = TRUE;
+        ret->used_solve = true;
 
 	return ret;
     } else {
@@ -2799,7 +2804,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 
     ds->w = state->w;
     ds->h = state->h;
-    ds->started = FALSE;
+    ds->started = false;
     ds->tilesize = 0;                  /* not decided yet */
     ds->grid = snewn(ds->w * ds->h, signed char);
     ds->bg = -1;
@@ -2958,7 +2963,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 {
     int x, y;
     int mines, markers, closed, bg;
-    int cx = -1, cy = -1, cmoved;
+    int cx = -1, cy = -1;
+    bool cmoved;
 
     if (flashtime) {
 	int frame = (int)(flashtime / FLASH_FRAME);
@@ -2998,7 +3004,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         coords[0] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
         draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     if (ui->cur_visible) cx = ui->cur_x;
@@ -3012,7 +3018,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     mines = markers = closed = 0;
     for (y = 0; y < ds->h; y++)
 	for (x = 0; x < ds->w; x++) {
-	    int v = state->grid[y*ds->w+x], cc = 0;
+	    int v = state->grid[y*ds->w+x];
+            bool cc = false;
 
             if (v < 0)
                 closed++;
@@ -3047,7 +3054,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
             if (cmoved && /* if cursor has moved, force redraw of curr and prev pos */
                 ((x == cx && y == cy) || (x == ds->cur_x && y == ds->cur_y)))
-              cc = 1;
+              cc = true;
 
 	    if (ds->grid[y*ds->w+x] != v || bg != ds->bg || cc) {
 		draw_tile(dr, ds, COORD(x), COORD(y), v,
@@ -3132,11 +3139,11 @@ static float game_flash_length(const game_state *oldstate,
 
     if (dir > 0 && !oldstate->dead && !oldstate->won) {
 	if (newstate->dead) {
-	    ui->flash_is_death = TRUE;
+	    ui->flash_is_death = true;
 	    return 3 * FLASH_FRAME;
 	}
 	if (newstate->won) {
-	    ui->flash_is_death = FALSE;
+	    ui->flash_is_death = false;
 	    return 2 * FLASH_FRAME;
 	}
     }
@@ -3153,11 +3160,11 @@ static int game_status(const game_state *state)
     return state->won ? (state->used_solve ? -1 : +1) : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->dead || state->won || ui->completed || !state->layout->mines)
-	return FALSE;
-    return TRUE;
+	return false;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -3180,15 +3187,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3205,9 +3212,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    TRUE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    true, game_timing_state,
     BUTTON_BEATS(LEFT_BUTTON, RIGHT_BUTTON) | REQUIRE_RBUTTON,
 };
 
diff --git a/apps/plugins/puzzles/src/misc.c b/apps/plugins/puzzles/src/misc.c
index 1d6ec4c547..ed31acbbe4 100644
--- a/apps/plugins/puzzles/src/misc.c
+++ b/apps/plugins/puzzles/src/misc.c
@@ -46,7 +46,7 @@ void free_keys(key_label *keys, int nkeys)
  * keyless, reversible, but visually completely obfuscatory masking
  * function to the mine bitmap.
  */
-void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
+void obfuscate_bitmap(unsigned char *bmp, int bits, bool decode)
 {
     int bytes, firsthalf, secondhalf;
     struct step {
@@ -288,7 +288,7 @@ void draw_rect_corners(drawing *dr, int cx, int cy, int r, int col)
     draw_line(dr, cx + r, cy + r, cx + r/2, cy + r, col);
 }
 
-void move_cursor(int button, int *x, int *y, int maxw, int maxh, int wrap)
+void move_cursor(int button, int *x, int *y, int maxw, int maxh, bool wrap)
 {
     int dx = 0, dy = 0;
     switch (button) {
diff --git a/apps/plugins/puzzles/src/mkfiles.pl b/apps/plugins/puzzles/src/mkfiles.pl
index 142f7ca252..d92bcca11d 100755
--- a/apps/plugins/puzzles/src/mkfiles.pl
+++ b/apps/plugins/puzzles/src/mkfiles.pl
@@ -1707,7 +1707,8 @@ if (defined $makefiles{'nestedvm'}) {
 if (defined $makefiles{'osx'}) {
     $mftyp = 'osx';
     $dirpfx = &dirpfx($makefiles{'osx'}, "/");
-    @osxarchs = ('i386', 'x86_64');
+    @osxarchs = ('x86_64');
+    my $osxminver = "10.6";
 
     ##-- Mac OS X makefile
     open OUT, ">$makefiles{'osx'}"; select OUT;
@@ -1756,7 +1757,7 @@ if (defined $makefiles{'osx'}) {
       foreach $arch (@osxarchs) {
 	$objstr = &objects($p, "X.${arch}.o", undef, undef);
 	print &splitline("${prog}.${arch}.bin: " . $objstr), "\n";
-	print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=10.4 \$(LDFLAGS) -o \$@ " .
+	print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=${osxminver} \$(LDFLAGS) -o \$@ " .
                        $objstr . " $libstr", 69), "\n\n";
 	$archbins .= " ${prog}.${arch}.bin";
       }
@@ -1771,7 +1772,7 @@ if (defined $makefiles{'osx'}) {
       foreach $arch (@osxarchs) {
 	$objstr = &objects($p, "X.${arch}.o", undef, undef);
 	print &splitline("${prog}.${arch}: " . $objstr), "\n";
-	print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=10.4 \$(ULDFLAGS) -o \$@ " .
+	print &splitline("\t\$(CC) -arch ${arch} -mmacosx-version-min=${osxminver} \$(ULDFLAGS) -o \$@ " .
                        $objstr . " $libstr", 69), "\n\n";
 	$archbins .= " ${prog}.${arch}";
       }
@@ -1784,10 +1785,10 @@ if (defined $makefiles{'osx'}) {
             "\n";
         $deflist = join "", map { " -D$_" } @{$d->{defs}};
         if ($d->{deps}->[0] =~ /\.m$/) {
-	  print "\t\$(CC) -arch $arch -mmacosx-version-min=10.4 -x objective-c \$(COMPAT) \$(FWHACK) \$(CFLAGS)".
+	  print "\t\$(CC) -arch $arch -mmacosx-version-min=${osxminver} -x objective-c \$(COMPAT) \$(FWHACK) \$(CFLAGS)".
 	      " \$(XFLAGS)$deflist -c \$< -o \$\@\n";
         } else {
-	  print "\t\$(CC) -arch $arch -mmacosx-version-min=10.4 \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
+	  print "\t\$(CC) -arch $arch -mmacosx-version-min=${osxminver} \$(COMPAT) \$(FWHACK) \$(CFLAGS) \$(XFLAGS)$deflist" .
 	      " -c \$< -o \$\@\n";
         }
       }
diff --git a/apps/plugins/puzzles/src/nestedvm.c b/apps/plugins/puzzles/src/nestedvm.c
index 0ad0f3fab4..947abe0fae 100644
--- a/apps/plugins/puzzles/src/nestedvm.c
+++ b/apps/plugins/puzzles/src/nestedvm.c
@@ -31,10 +31,11 @@ void fatal(const char *fmt, ...)
 struct frontend {
     // TODO kill unneeded members!
     midend *me;
-    int timer_active;
+    bool timer_active;
     struct timeval last_time;
     config_item *cfg;
-    int cfg_which, cfgret;
+    int cfg_which;
+    bool cfgret;
     int ox, oy, w, h;
 };
 
@@ -216,7 +217,7 @@ int jcallback_resize(int width, int height)
     int x, y;
     x = width;
     y = height;
-    midend_size(fe->me, &x, &y, TRUE);
+    midend_size(fe->me, &x, &y, true);
     fe->ox = (width - x) / 2;
     fe->oy = (height - y) / 2;
     fe->w = x;
@@ -244,7 +245,7 @@ void deactivate_timer(frontend *fe)
 {
     if (fe->timer_active)
 	_call_java(4, 13, 0, 0);
-    fe->timer_active = FALSE;
+    fe->timer_active = false;
 }
 
 void activate_timer(frontend *fe)
@@ -253,7 +254,7 @@ void activate_timer(frontend *fe)
 	_call_java(4, 12, 0, 0);
 	gettimeofday(&fe->last_time, NULL);
     }
-    fe->timer_active = TRUE;
+    fe->timer_active = true;
 }
 
 void jcallback_config_ok()
@@ -266,7 +267,7 @@ void jcallback_config_ok()
     if (err)
 	_call_java(2, (int) "Error", (int)err, 1);
     else {
-	fe->cfgret = TRUE;
+	fe->cfgret = true;
     }
 }
 
@@ -282,7 +283,7 @@ void jcallback_config_set_string(int item_ptr, int char_ptr) {
 void jcallback_config_set_boolean(int item_ptr, int selected) {
     config_item *i = (config_item *)item_ptr;
     assert(i->type == C_BOOLEAN);
-    i->u.boolean.bval = selected != 0 ? TRUE : FALSE;
+    i->u.boolean.bval = selected != 0 ? true : false;
 }
 
 void jcallback_config_set_choice(int item_ptr, int selected) {
@@ -291,13 +292,13 @@ void jcallback_config_set_choice(int item_ptr, int selected) {
     i->u.choices.selected = selected;
 }
 
-static int get_config(frontend *fe, int which)
+static bool get_config(frontend *fe, int which)
 {
     char *title;
     config_item *i;
     fe->cfg = midend_get_config(fe->me, which, &title);
     fe->cfg_which = which;
-    fe->cfgret = FALSE;
+    fe->cfgret = false;
     _call_java(10, (int)title, 0, 0);
     for (i = fe->cfg; i->type != C_END; i++) {
 	_call_java(5, (int)i, i->type, (int)i->name);
@@ -357,7 +358,7 @@ static void resize_fe(frontend *fe)
 
     x = INT_MAX;
     y = INT_MAX;
-    midend_size(fe->me, &x, &y, FALSE);
+    midend_size(fe->me, &x, &y, false);
     _call_java(3, x, y, 0);
 }
 
@@ -443,7 +444,7 @@ int main(int argc, char **argv)
     float* colours;
 
     _fe = snew(frontend);
-    _fe->timer_active = FALSE;
+    _fe->timer_active = false;
     _fe->me = midend_new(_fe, &thegame, &nestedvm_drawing, _fe);
     if (argc > 1)
 	midend_game_id(_fe->me, argv[1]);   /* ignore failure */
diff --git a/apps/plugins/puzzles/src/net.c b/apps/plugins/puzzles/src/net.c
index 224263382f..36f8aca483 100644
--- a/apps/plugins/puzzles/src/net.c
+++ b/apps/plugins/puzzles/src/net.c
@@ -34,11 +34,11 @@
 #define D 0x08
 #define LOCKED 0x10
 #define ACTIVE 0x20
-#define RLOOP (R << 6)
-#define ULOOP (U << 6)
-#define LLOOP (L << 6)
-#define DLOOP (D << 6)
-#define LOOP(dir) ((dir) << 6)
+#define RERR (R << 6)
+#define UERR (U << 6)
+#define LERR (L << 6)
+#define DERR (D << 6)
+#define ERR(dir) ((dir) << 6)
 
 /* Rotations: Anticlockwise, Clockwise, Flip, general rotate */
 #define A(x) ( (((x) & 0x07) << 1) | (((x) & 0x08) >> 3) )
@@ -76,15 +76,15 @@ enum {
     COL_ENDPOINT,
     COL_POWERED,
     COL_BARRIER,
-    COL_LOOP,
+    COL_ERR,
     NCOLOURS
 };
 
 struct game_params {
     int width;
     int height;
-    int wrapping;
-    int unique;
+    bool wrapping;
+    bool unique;
     float barrier_probability;
 };
 
@@ -94,9 +94,10 @@ typedef struct game_immutable_state {
 } game_immutable_state;
 
 struct game_state {
-    int width, height, wrapping, completed;
+    int width, height;
+    bool wrapping, completed;
     int last_rotate_x, last_rotate_y, last_rotate_dir;
-    int used_solve;
+    bool used_solve;
     unsigned char *tiles;
     struct game_immutable_state *imm;
 };
@@ -154,37 +155,37 @@ static game_params *default_params(void)
 
     ret->width = 5;
     ret->height = 5;
-    ret->wrapping = FALSE;
-    ret->unique = TRUE;
+    ret->wrapping = false;
+    ret->unique = true;
     ret->barrier_probability = 0.0;
 
     return ret;
 }
 
 static const struct game_params net_presets[] = {
-    {5, 5, FALSE, TRUE, 0.0},
-    {7, 7, FALSE, TRUE, 0.0},
-    {9, 9, FALSE, TRUE, 0.0},
-    {11, 11, FALSE, TRUE, 0.0},
+    {5, 5, false, true, 0.0},
+    {7, 7, false, true, 0.0},
+    {9, 9, false, true, 0.0},
+    {11, 11, false, true, 0.0},
 #ifndef SMALL_SCREEN
-    {13, 11, FALSE, TRUE, 0.0},
+    {13, 11, false, true, 0.0},
 #endif
-    {5, 5, TRUE, TRUE, 0.0},
-    {7, 7, TRUE, TRUE, 0.0},
-    {9, 9, TRUE, TRUE, 0.0},
-    {11, 11, TRUE, TRUE, 0.0},
+    {5, 5, true, true, 0.0},
+    {7, 7, true, true, 0.0},
+    {9, 9, true, true, 0.0},
+    {11, 11, true, true, 0.0},
 #ifndef SMALL_SCREEN
-    {13, 11, TRUE, TRUE, 0.0},
+    {13, 11, true, true, 0.0},
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(net_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = net_presets[i];
@@ -194,7 +195,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -226,20 +227,20 @@ static void decode_params(game_params *ret, char const *string)
     while (*p) {
         if (*p == 'w') {
             p++;
-	    ret->wrapping = TRUE;
+	    ret->wrapping = true;
 	} else if (*p == 'b') {
 	    p++;
             ret->barrier_probability = (float)atof(p);
 	    while (*p && (*p == '.' || isdigit((unsigned char)*p))) p++;
 	} else if (*p == 'a') {
             p++;
-	    ret->unique = FALSE;
+	    ret->unique = false;
 	} else
 	    p++;		       /* skip any other gunk */
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -309,7 +310,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->width <= 0 || params->height <= 0)
 	return "Width and height must both be greater than zero";
@@ -399,7 +400,7 @@ static const char *validate_params(const game_params *params, int full)
  */
 
 struct todo {
-    unsigned char *marked;
+    bool *marked;
     int *buffer;
     int buflen;
     int head, tail;
@@ -408,7 +409,7 @@ struct todo {
 static struct todo *todo_new(int maxsize)
 {
     struct todo *todo = snew(struct todo);
-    todo->marked = snewn(maxsize, unsigned char);
+    todo->marked = snewn(maxsize, bool);
     memset(todo->marked, 0, maxsize);
     todo->buflen = maxsize + 1;
     todo->buffer = snewn(todo->buflen, int);
@@ -427,7 +428,7 @@ static void todo_add(struct todo *todo, int index)
 {
     if (todo->marked[index])
 	return;			       /* already on the list */
-    todo->marked[index] = TRUE;
+    todo->marked[index] = true;
     todo->buffer[todo->tail++] = index;
     if (todo->tail == todo->buflen)
 	todo->tail = 0;
@@ -441,7 +442,7 @@ static int todo_get(struct todo *todo) {
     ret = todo->buffer[todo->head++];
     if (todo->head == todo->buflen)
 	todo->head = 0;
-    todo->marked[ret] = FALSE;
+    todo->marked[ret] = false;
 
     return ret;
 }
@@ -452,7 +453,7 @@ static int todo_get(struct todo *todo) {
  * fully.
  */
 static int net_solver(int w, int h, unsigned char *tiles,
-		      unsigned char *barriers, int wrapping)
+		      unsigned char *barriers, bool wrapping)
 {
     unsigned char *tilestate;
     unsigned char *edgestate;
@@ -461,7 +462,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
     struct todo *todo;
     int i, j, x, y;
     int area;
-    int done_something;
+    bool done_something;
 
     /*
      * Set up the solver's data structures.
@@ -594,7 +595,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
     /*
      * Main deductive loop.
      */
-    done_something = TRUE;	       /* prevent instant termination! */
+    done_something = true;	       /* prevent instant termination! */
     while (1) {
 	int index;
 
@@ -608,8 +609,8 @@ static int net_solver(int w, int h, unsigned char *tiles,
 	     * have no choice but to scan the whole grid for
 	     * longer-range things we've missed. Hence, I now add
 	     * every square on the grid back on to the to-do list.
-	     * I also set `done_something' to FALSE at this point;
-	     * if we later come back here and find it still FALSE,
+	     * I also set `done_something' to false at this point;
+	     * if we later come back here and find it still false,
 	     * we will know we've scanned the entire grid without
 	     * finding anything new to do, and we can terminate.
 	     */
@@ -617,7 +618,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 		break;
 	    for (i = 0; i < w*h; i++)
 		todo_add(todo, i);
-	    done_something = FALSE;
+	    done_something = false;
 
 	    index = todo_get(todo);
 	}
@@ -631,12 +632,12 @@ static int net_solver(int w, int h, unsigned char *tiles,
 	    deadendmax[1] = deadendmax[2] = deadendmax[4] = deadendmax[8] = 0;
 
 	    for (i = j = 0; i < 4 && tilestate[(y*w+x) * 4 + i] != 255; i++) {
-		int valid;
+		bool valid;
 		int nnondeadends, nondeadends[4], deadendtotal;
 		int nequiv, equiv[5];
 		int val = tilestate[(y*w+x) * 4 + i];
 
-		valid = TRUE;
+		valid = true;
 		nnondeadends = deadendtotal = 0;
 		equiv[0] = ourclass;
 		nequiv = 1;
@@ -647,7 +648,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 		     */
 		    if ((edgestate[(y*w+x) * 5 + d] == 1 && !(val & d)) ||
 			(edgestate[(y*w+x) * 5 + d] == 2 && (val & d)))
-			valid = FALSE;
+			valid = false;
 
 		    if (val & d) {
 			/*
@@ -675,7 +676,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 			    if (k == nequiv)
 				equiv[nequiv++] = c;
 			    else
-				valid = FALSE;
+				valid = false;
 			}
 		    }
 		}
@@ -692,7 +693,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 		     * with a total area of 6, not 5.)
 		     */
 		    if (deadendtotal > 0 && deadendtotal+1 < area)
-			valid = FALSE;
+			valid = false;
 		} else if (nnondeadends == 1) {
 		    /*
 		     * If this orientation links together one or
@@ -732,7 +733,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
             }
 
 	    if (j < i) {
-		done_something = TRUE;
+		done_something = true;
 
 		/*
 		 * We have ruled out at least one tile orientation.
@@ -767,7 +768,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 			    edgestate[(y*w+x) * 5 + d] = 1;
 			    edgestate[(y2*w+x2) * 5 + d2] = 1;
 			    dsf_merge(equivalence, y*w+x, y2*w+x2);
-			    done_something = TRUE;
+			    done_something = true;
 			    todo_add(todo, y2*w+x2);
 			} else if (!(o & d)) {
 			    /* This edge is closed in all orientations. */
@@ -776,7 +777,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 #endif
 			    edgestate[(y*w+x) * 5 + d] = 2;
 			    edgestate[(y2*w+x2) * 5 + d2] = 2;
-			    done_something = TRUE;
+			    done_something = true;
 			    todo_add(todo, y2*w+x2);
 			}
 		    }
@@ -798,7 +799,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
 			   x2, y2, d2, deadendmax[d]);
 #endif
 		    deadends[(y2*w+x2) * 5 + d2] = deadendmax[d];
-		    done_something = TRUE;
+		    done_something = true;
 		    todo_add(todo, y2*w+x2);
 		}
 	    }
@@ -840,7 +841,7 @@ static int net_solver(int w, int h, unsigned char *tiles,
  * Function to randomly perturb an ambiguous section in a grid, to
  * attempt to ensure unique solvability.
  */
-static void perturb(int w, int h, unsigned char *tiles, int wrapping,
+static void perturb(int w, int h, unsigned char *tiles, bool wrapping,
 		    random_state *rs, int startx, int starty, int startd)
 {
     struct xyd *perimeter, *perim2, *loop[2], looppos[2];
@@ -1128,12 +1129,12 @@ static void perturb(int w, int h, unsigned char *tiles, int wrapping,
     sfree(perimeter);
 }
 
-static int *compute_loops_inner(int w, int h, int wrapping,
+static int *compute_loops_inner(int w, int h, bool wrapping,
                                 const unsigned char *tiles,
                                 const unsigned char *barriers);
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     tree234 *possibilities, *barriertree;
     int w, h, x, y, cx, cy, nbarriers;
@@ -1643,7 +1644,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->imm = snew(game_immutable_state);
     state->imm->refcount = 1;
     state->last_rotate_dir = state->last_rotate_x = state->last_rotate_y = 0;
-    state->completed = state->used_solve = FALSE;
+    state->completed = state->used_solve = false;
     state->tiles = snewn(state->width * state->height, unsigned char);
     memset(state->tiles, 0, state->width * state->height);
     state->imm->barriers = snewn(state->width * state->height, unsigned char);
@@ -1699,15 +1700,15 @@ static game_state *new_game(midend *me, const game_params *params,
          * description of a non-wrapping game. This is so that we
          * can change some aspects of the UI behaviour.
          */
-        state->wrapping = FALSE;
+        state->wrapping = false;
         for (x = 0; x < state->width; x++)
             if (!(barrier(state, x, 0) & U) ||
                 !(barrier(state, x, state->height-1) & D))
-                state->wrapping = TRUE;
+                state->wrapping = true;
         for (y = 0; y < state->height; y++)
             if (!(barrier(state, 0, y) & L) ||
                 !(barrier(state, state->width-1, y) & R))
-                state->wrapping = TRUE;
+                state->wrapping = true;
     }
 
     return state;
@@ -1847,9 +1848,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1953,7 +1954,7 @@ static int net_neighbour(int vertex, void *vctx)
         return -1;
 }
 
-static int *compute_loops_inner(int w, int h, int wrapping,
+static int *compute_loops_inner(int w, int h, bool wrapping,
                                 const unsigned char *tiles,
                                 const unsigned char *barriers)
 {
@@ -1982,7 +1983,7 @@ static int *compute_loops_inner(int w, int h, int wrapping,
                     OFFSETWH(x1, y1, x, y, dir, w, h);
                     if ((tiles[y1*w+x1] & F(dir)) &&
                         findloop_is_loop_edge(fls, y*w+x, y1*w+x1))
-                        flags |= LOOP(dir);
+                        flags |= ERR(dir);
                 }
             }
             loops[y*w+x] = flags;
@@ -2003,10 +2004,11 @@ struct game_ui {
     int org_x, org_y; /* origin */
     int cx, cy;       /* source tile (game coordinates) */
     int cur_x, cur_y;
-    int cur_visible;
+    bool cur_visible;
     random_state *rs; /* used for jumbling */
 #ifdef USE_DRAGGING
-    int dragtilex, dragtiley, dragstartx, dragstarty, dragged;
+    int dragtilex, dragtiley, dragstartx, dragstarty;
+    bool dragged;
 #endif
 };
 
@@ -2018,7 +2020,7 @@ static game_ui *new_ui(const game_state *state)
     ui->org_x = ui->org_y = 0;
     ui->cur_x = ui->cx = state->width / 2;
     ui->cur_y = ui->cy = state->height / 2;
-    ui->cur_visible = FALSE;
+    ui->cur_visible = false;
     get_random_seed(&seed, &seedsize);
     ui->rs = random_new(seed, seedsize);
     sfree(seed);
@@ -2055,7 +2057,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int width, height;
     int tilesize;
     unsigned long *visible, *to_draw;
@@ -2070,7 +2072,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     char *nullret;
     int tx = -1, ty = -1, dir = 0;
-    int shift = button & MOD_SHFT, ctrl = button & MOD_CTRL;
+    bool shift = button & MOD_SHFT, ctrl = button & MOD_CTRL;
     enum {
         NONE, ROTATE_LEFT, ROTATE_180, ROTATE_RIGHT, TOGGLE_LOCK, JUMBLE,
         MOVE_ORIGIN, MOVE_SOURCE, MOVE_ORIGIN_AND_SOURCE, MOVE_CURSOR
@@ -2091,7 +2093,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	button == RIGHT_BUTTON) {
 
 	if (ui->cur_visible) {
-	    ui->cur_visible = FALSE;
+	    ui->cur_visible = false;
 	    nullret = UI_UPDATE;
 	}
 
@@ -2136,7 +2138,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             ui->dragtiley = ty;
             ui->dragstartx = x % TILE_SIZE;
             ui->dragstarty = y % TILE_SIZE;
-            ui->dragged = FALSE;
+            ui->dragged = false;
             return nullret;            /* no actual action */
         } else if (button == LEFT_DRAG
 #ifndef STYLUS_BASED
@@ -2179,17 +2181,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 action = ROTATE_180;
                 ui->dragstartx = xF;
                 ui->dragstarty = yF;
-                ui->dragged = TRUE;
+                ui->dragged = true;
             } else if (dA == dmin) {
                 action = ROTATE_LEFT;
                 ui->dragstartx = xA;
                 ui->dragstarty = yA;
-                ui->dragged = TRUE;
+                ui->dragged = true;
             } else /* dC == dmin */ {
                 action = ROTATE_RIGHT;
                 ui->dragstartx = xC;
                 ui->dragstarty = yC;
-                ui->dragged = TRUE;
+                ui->dragged = true;
             }
         } else if (button == LEFT_RELEASE
 #ifndef STYLUS_BASED
@@ -2245,7 +2247,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	    action = ROTATE_RIGHT;
         else if (button == 'f' || button == 'F')
             action = ROTATE_180;
-        ui->cur_visible = TRUE;
+        ui->cur_visible = true;
     } else if (button == 'j' || button == 'J') {
 	/* XXX should we have some mouse control for this? */
 	action = JUMBLE;
@@ -2330,7 +2332,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
         if (action == MOVE_CURSOR) {
             OFFSET(ui->cur_x, ui->cur_y, ui->cur_x, ui->cur_y, dir, state);
-            ui->cur_visible = TRUE;
+            ui->cur_visible = true;
         }
         return UI_UPDATE;
     } else {
@@ -2341,20 +2343,21 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 static game_state *execute_move(const game_state *from, const char *move)
 {
     game_state *ret;
-    int tx = -1, ty = -1, n, noanim, orig;
+    int tx = -1, ty = -1, n, orig;
+    bool noanim;
 
     ret = dup_game(from);
 
     if (move[0] == 'J' || move[0] == 'S') {
 	if (move[0] == 'S')
-	    ret->used_solve = TRUE;
+	    ret->used_solve = true;
 
 	move++;
 	if (*move == ';')
 	    move++;
-	noanim = TRUE;
+	noanim = true;
     } else
-	noanim = FALSE;
+	noanim = false;
 
     ret->last_rotate_dir = 0;	       /* suppress animation */
     ret->last_rotate_x = ret->last_rotate_y = 0;
@@ -2406,7 +2409,7 @@ static game_state *execute_move(const game_state *from, const char *move)
     {
 	unsigned char *active;
 	int pos;
-	int complete = TRUE;
+        bool complete = true;
 
 	for (pos = 0; pos < ret->width * ret->height; pos++)
             if (ret->tiles[pos] & 0xF)
@@ -2417,7 +2420,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 
             for (pos = 0; pos < ret->width * ret->height; pos++)
                 if ((ret->tiles[pos] & 0xF) && !active[pos]) {
-		    complete = FALSE;
+		    complete = false;
                     break;
                 }
 
@@ -2425,7 +2428,7 @@ static game_state *execute_move(const game_state *from, const char *move)
         }
 
 	if (complete)
-	    ret->completed = TRUE;
+	    ret->completed = true;
     }
 
     return ret;
@@ -2441,7 +2444,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     game_drawstate *ds = snew(game_drawstate);
     int i, ncells;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->width = state->width;
     ds->height = state->height;
     ncells = (state->width+2) * (state->height+2);
@@ -2516,11 +2519,11 @@ static float *game_colours(frontend *fe, int *ncolours)
     ret[COL_BARRIER * 3 + 2] = 0.0F;
 
     /*
-     * Highlighted loops are red as well.
+     * Highlighted errors are red as well.
      */
-    ret[COL_LOOP * 3 + 0] = 1.0F;
-    ret[COL_LOOP * 3 + 1] = 0.0F;
-    ret[COL_LOOP * 3 + 2] = 0.0F;
+    ret[COL_ERR * 3 + 0] = 1.0F;
+    ret[COL_ERR * 3 + 1] = 0.0F;
+    ret[COL_ERR * 3 + 2] = 0.0F;
 
     /*
      * Unpowered endpoints are blue.
@@ -2559,7 +2562,7 @@ static void rotated_coords(float *ox, float *oy, const float matrix[4],
 #define TILE_KEYBOARD_CURSOR      (1<<8) /* 1 bit if cursor is here */
 #define TILE_WIRE_SHIFT               9  /* 8 bits: RR UU LL DD
                                           * Each pair: 0=no wire, 1=unpowered,
-                                          * 2=powered, 3=loop err highlight */
+                                          * 2=powered, 3=error highlight */
 #define TILE_ENDPOINT_SHIFT          17  /* 2 bits: 0=no endpoint, 1=unpowered,
                                           * 2=powered, 3=power-source square */
 #define TILE_WIRE_ON_EDGE_SHIFT      19  /* 8 bits: RR UU LL DD,
@@ -2574,7 +2577,7 @@ static void draw_wires(drawing *dr, int cx, int cy, int radius,
     float fpoints[12*2];
     int points[12*2];
     int npoints, d, dsh, i;
-    int any_wire_this_colour = FALSE;
+    bool any_wire_this_colour = false;
     float xf, yf;
 
     npoints = 0;
@@ -2593,7 +2596,7 @@ static void draw_wires(drawing *dr, int cx, int cy, int radius,
             fpoints[2*npoints+1] = radius * Y(d) + halfwidth * Y(A(d));
             npoints++;
 
-            any_wire_this_colour = TRUE;
+            any_wire_this_colour = true;
         }
     }
 
@@ -2708,7 +2711,7 @@ static void draw_tile(drawing *dr, game_drawstate *ds, int x, int y,
         for (pass = 0; pass < 2; pass++) {
             int x, y, w, h;
             int col = (pass == 0 || edgetype == 1 ? COL_WIRE :
-                       edgetype == 2 ? COL_POWERED : COL_LOOP);
+                       edgetype == 2 ? COL_POWERED : COL_ERR);
             int halfwidth = pass == 0 ? 2*LINE_THICK-1 : LINE_THICK-1;
 
             if (X(d) < 0) {
@@ -2760,7 +2763,7 @@ static void draw_tile(drawing *dr, game_drawstate *ds, int x, int y,
     draw_wires(dr, cx, cy, radius, tile,
                0x4, COL_POWERED, LINE_THICK-1, matrix);
     draw_wires(dr, cx, cy, radius, tile,
-               0x8, COL_LOOP, LINE_THICK-1, matrix);
+               0x8, COL_ERR, LINE_THICK-1, matrix);
 
     /*
      * Draw the central box.
@@ -2845,7 +2848,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         int w, h;
         game_params params;
 
-        ds->started = TRUE;
+        ds->started = true;
 
         params.width = ds->width;
         params.height = ds->height;
@@ -2918,7 +2921,25 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                 }
 
                 if (t & d) {
-                    int edgeval = (t & LOOP(d) ? 3 : t & ACTIVE ? 2 : 1);
+                    int edgeval;
+
+                    /* Highlight as an error any edge in a locked tile that
+                     * is adjacent to a lack-of-edge in another locked tile,
+                     * or to a barrier */
+                    if (t & LOCKED) {
+                        if (barrier(state, gx, gy) & d) {
+                            t |= ERR(d);
+                        } else {
+                            int ox, oy, t2;
+                            OFFSET(ox, oy, gx, gy, d, state);
+                            t2 = tile(state, ox, oy);
+                            if ((t2 & LOCKED) && !(t2 & F(d))) {
+                                t |= ERR(d);
+                            }
+                        }
+                    }
+
+                    edgeval = (t & ERR(d) ? 3 : t & ACTIVE ? 2 : 1);
                     todraw(ds, dx, dy) |= edgeval << (TILE_WIRE_SHIFT + dsh*2);
                     if (!(gx == tx && gy == ty)) {
                         todraw(ds, dx + X(d), dy + Y(d)) |=
@@ -2990,17 +3011,17 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     {
 	char statusbuf[256], *p;
 	int i, n, n2, a;
-        int complete = FALSE;
+        bool complete = false;
 
         p = statusbuf;
         *p = '\0';     /* ensure even an empty status string is terminated */
 
         if (state->used_solve) {
             p += sprintf(p, "Auto-solved. ");
-            complete = TRUE;
+            complete = true;
         } else if (state->completed) {
             p += sprintf(p, "COMPLETED! ");
-            complete = TRUE;
+            complete = true;
         }
 
         /*
@@ -3074,9 +3095,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -3092,7 +3113,7 @@ static void game_print_size(const game_params *params, float *x, float *y)
 }
 
 static void draw_diagram(drawing *dr, game_drawstate *ds, int x, int y,
-			 int topleft, int v, int drawlines, int ink)
+			 bool topleft, int v, bool drawlines, int ink)
 {
     int tx, ty, cx, cy, r, br, k, thick;
 
@@ -3205,12 +3226,12 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
 	    /*
 	     * Draw the top left corner diagram.
 	     */
-	    draw_diagram(dr, ds, x, y, TRUE, vx, TRUE, ink);
+	    draw_diagram(dr, ds, x, y, true, vx, true, ink);
 
 	    /*
 	     * Draw the real solution diagram, if we're doing so.
 	     */
-	    draw_diagram(dr, ds, x, y, FALSE, v, locked, ink);
+	    draw_diagram(dr, ds, x, y, false, v, locked, ink);
 	}
 }
 
@@ -3226,15 +3247,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -3251,8 +3272,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/netslide.c b/apps/plugins/puzzles/src/netslide.c
index af4ef7d81f..727ff0a910 100644
--- a/apps/plugins/puzzles/src/netslide.c
+++ b/apps/plugins/puzzles/src/netslide.c
@@ -77,14 +77,14 @@ enum {
 struct game_params {
     int width;
     int height;
-    int wrapping;
+    bool wrapping;
     float barrier_probability;
     int movetarget;
 };
 
 struct game_state {
-    int width, height, cx, cy, wrapping, completed;
-    int used_solve;
+    int width, height, cx, cy, completed;
+    bool wrapping, used_solve;
     int move_count, movetarget;
 
     /* position (row or col number, starting at 0) of last move. */
@@ -150,7 +150,7 @@ static game_params *default_params(void)
 
     ret->width = 3;
     ret->height = 3;
-    ret->wrapping = FALSE;
+    ret->wrapping = false;
     ret->barrier_probability = 1.0;
     ret->movetarget = 0;
 
@@ -159,24 +159,24 @@ static game_params *default_params(void)
 
 static const struct { int x, y, wrap, bprob; const char* desc; }
 netslide_presets[] = {
-    {3, 3, FALSE, 1, " easy"},
-    {3, 3, FALSE, 0, " medium"},
-    {3, 3, TRUE,  0, " hard"},
-    {4, 4, FALSE, 1, " easy"},
-    {4, 4, FALSE, 0, " medium"},
-    {4, 4, TRUE,  0, " hard"},
-    {5, 5, FALSE, 1, " easy"},
-    {5, 5, FALSE, 0, " medium"},
-    {5, 5, TRUE,  0, " hard"},
+    {3, 3, false, 1, " easy"},
+    {3, 3, false, 0, " medium"},
+    {3, 3, true,  0, " hard"},
+    {4, 4, false, 1, " easy"},
+    {4, 4, false, 0, " medium"},
+    {4, 4, true,  0, " hard"},
+    {5, 5, false, 1, " easy"},
+    {5, 5, false, 0, " medium"},
+    {5, 5, true,  0, " hard"},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(netslide_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     ret->width = netslide_presets[i].x;
@@ -189,7 +189,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -208,7 +208,7 @@ static void decode_params(game_params *ret, char const *string)
 {
     char const *p = string;
 
-    ret->wrapping = FALSE;
+    ret->wrapping = false;
     ret->barrier_probability = 0.0;
     ret->movetarget = 0;
 
@@ -218,7 +218,8 @@ static void decode_params(game_params *ret, char const *string)
         p++;
         ret->height = atoi(p);
         while (*p && isdigit((unsigned char)*p)) p++;
-        if ( (ret->wrapping = (*p == 'w')) != 0 )
+        ret->wrapping = (*p == 'w');
+        if (ret->wrapping)
             p++;
         if (*p == 'b') {
             ret->barrier_probability = (float)atof(++p);
@@ -232,7 +233,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -305,7 +306,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->width <= 1 || params->height <= 1)
 	return "Width and height must both be greater than one";
@@ -323,7 +324,7 @@ static const char *validate_params(const game_params *params, int full)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     tree234 *possibilities, *barriertree;
     int w, h, x, y, cx, cy, nbarriers;
@@ -744,7 +745,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->wrapping = params->wrapping;
     state->movetarget = params->movetarget;
     state->completed = 0;
-    state->used_solve = FALSE;
+    state->used_solve = false;
     state->move_count = 0;
     state->last_move_row = -1;
     state->last_move_col = -1;
@@ -811,25 +812,25 @@ static game_state *new_game(midend *me, const game_params *params,
             for (dir = 1; dir < 0x10; dir <<= 1) {
                 int dir2 = A(dir);
                 int x1, y1, x2, y2, x3, y3;
-                int corner = FALSE;
+                bool corner = false;
 
                 if (!(barrier(state, x, y) & dir))
                     continue;
 
                 if (barrier(state, x, y) & dir2)
-                    corner = TRUE;
+                    corner = true;
 
                 x1 = x + X(dir), y1 = y + Y(dir);
                 if (x1 >= 0 && x1 < state->width &&
                     y1 >= 0 && y1 < state->height &&
                     (barrier(state, x1, y1) & dir2))
-                    corner = TRUE;
+                    corner = true;
 
                 x2 = x + X(dir2), y2 = y + Y(dir2);
                 if (x2 >= 0 && x2 < state->width &&
                     y2 >= 0 && y2 < state->height &&
                     (barrier(state, x2, y2) & dir))
-                    corner = TRUE;
+                    corner = true;
 
                 if (corner) {
                     barrier(state, x, y) |= (dir << 4);
@@ -894,9 +895,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr(aux);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -972,7 +973,7 @@ static unsigned char *compute_active(const game_state *state,
 
 struct game_ui {
     int cur_x, cur_y;
-    int cur_visible;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -980,7 +981,7 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
     ui->cur_x = 0;
     ui->cur_y = -1;
-    ui->cur_visible = FALSE;
+    ui->cur_visible = false;
 
     return ui;
 }
@@ -1047,7 +1048,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int width, height;
     int tilesize;
     unsigned char *visible;
@@ -1076,21 +1077,21 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             } while (ui->cur_x == state->cx || ui->cur_y == state->cy);
         }
 
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
         return UI_UPDATE;
     }
 
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
         cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
     } else if (IS_CURSOR_SELECT(button)) {
         if (ui->cur_visible) {
             cx = ui->cur_x;
             cy = ui->cur_y;
         } else {
             /* 'click' when cursor is invisible just makes cursor visible. */
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
     } else
@@ -1130,7 +1131,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 static game_state *execute_move(const game_state *from, const char *move)
 {
     game_state *ret;
-    int c, d, col;
+    int c, d;
+    bool col;
 
     if ((move[0] == 'C' || move[0] == 'R') &&
 	sscanf(move+1, "%d,%d", &c, &d) == 2 &&
@@ -1140,7 +1142,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	       strlen(move) == from->width * from->height + 1) {
 	int i;
 	ret = dup_game(from);
-	ret->used_solve = TRUE;
+	ret->used_solve = true;
 	ret->completed = ret->move_count = 1;
 
 	for (i = 0; i < from->width * from->height; i++) {
@@ -1179,12 +1181,12 @@ static game_state *execute_move(const game_state *from, const char *move)
     if (!ret->completed) {
 	unsigned char *active = compute_active(ret, -1, -1);
 	int x1, y1;
-	int complete = TRUE;
+        bool complete = true;
 
 	for (x1 = 0; x1 < ret->width; x1++)
 	    for (y1 = 0; y1 < ret->height; y1++)
 		if (!index(ret, active, x1, y1)) {
-		    complete = FALSE;
+		    complete = false;
 		    goto break_label;  /* break out of two loops at once */
 		}
 	break_label:
@@ -1206,7 +1208,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 {
     game_drawstate *ds = snew(game_drawstate);
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->width = state->width;
     ds->height = state->height;
     ds->visible = snewn(state->width * state->height, unsigned char);
@@ -1535,7 +1537,7 @@ static void draw_tile_barriers(drawing *dr, game_drawstate *ds,
 }
 
 static void draw_arrow(drawing *dr, game_drawstate *ds,
-                       int x, int y, int xdx, int xdy, int cur)
+                       int x, int y, int xdx, int xdy, bool cur)
 {
     int coords[14];
     int ydy = -xdx, ydx = xdy;
@@ -1559,7 +1561,7 @@ static void draw_arrow(drawing *dr, game_drawstate *ds,
 }
 
 static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
-                                  int cur_x, int cur_y, int cur)
+                                  int cur_x, int cur_y, bool cur)
 {
     if (cur_x == -1 && cur_y == -1)
         return; /* 'no cursur here */
@@ -1598,7 +1600,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     if (!ds->started) {
         int phase;
 
-        ds->started = TRUE;
+        ds->started = true;
 
         draw_rect(dr, 0, 0, 
                   BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->width + TILE_BORDER,
@@ -1646,13 +1648,13 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
          */
         for (x = 0; x < ds->width; x++) {
             if (x == state->cx) continue;
-            draw_arrow(dr, ds, x, 0, +1, 0, 0);
-            draw_arrow(dr, ds, x+1, ds->height, -1, 0, 0);
+            draw_arrow(dr, ds, x, 0, +1, 0, false);
+            draw_arrow(dr, ds, x+1, ds->height, -1, 0, false);
         }
         for (y = 0; y < ds->height; y++) {
             if (y == state->cy) continue;
-            draw_arrow(dr, ds, ds->width, y, 0, +1, 0);
-            draw_arrow(dr, ds, 0, y+1, 0, -1, 0);
+            draw_arrow(dr, ds, ds->width, y, 0, +1, false);
+            draw_arrow(dr, ds, 0, y+1, 0, -1, false);
         }
     }
     if (ui->cur_visible) {
@@ -1662,8 +1664,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         /* Cursor has changed; redraw two (prev and curr) arrows. */
         assert(cur_x != state->cx && cur_y != state->cy);
 
-        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1);
-        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0);
+        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, true);
+        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, false);
         ds->cur_x = cur_x; ds->cur_y = cur_y;
     }
 
@@ -1833,9 +1835,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return FALSE;
+    return false;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1858,15 +1860,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1883,9 +1885,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/nullfe.c b/apps/plugins/puzzles/src/nullfe.c
index 14b6e096c0..7cba4e0c23 100644
--- a/apps/plugins/puzzles/src/nullfe.c
+++ b/apps/plugins/puzzles/src/nullfe.c
@@ -40,7 +40,7 @@ int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
 int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
 { return 0; }
 void print_line_width(drawing *dr, int width) {}
-void print_line_dotted(drawing *dr, int dotted) {}
+void print_line_dotted(drawing *dr, bool dotted) {}
 void midend_supersede_game_desc(midend *me, const char *desc,
                                 const char *privdesc) {}
 void status_bar(drawing *dr, const char *text) {}
diff --git a/apps/plugins/puzzles/src/nullgame.c b/apps/plugins/puzzles/src/nullgame.c
index 13c464c60d..2fa4da6ffd 100644
--- a/apps/plugins/puzzles/src/nullgame.c
+++ b/apps/plugins/puzzles/src/nullgame.c
@@ -42,9 +42,9 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
-    return FALSE;
+    return false;
 }
 
 static void free_params(game_params *params)
@@ -63,7 +63,7 @@ static void decode_params(game_params *params, char const *string)
 {
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     return dupstr("FIXME");
 }
@@ -78,13 +78,13 @@ static game_params *custom_params(const config_item *cfg)
     return NULL;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     return NULL;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     return dupstr("FIXME");
 }
@@ -124,9 +124,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -247,9 +247,9 @@ static int game_status(const game_state *state)
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -272,15 +272,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    FALSE, game_configure, custom_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,
+    false, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -297,8 +297,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/obfusc.c b/apps/plugins/puzzles/src/obfusc.c
index dc0656c20e..c62189c3ad 100644
--- a/apps/plugins/puzzles/src/obfusc.c
+++ b/apps/plugins/puzzles/src/obfusc.c
@@ -36,8 +36,8 @@ int main(int argc, char **argv)
     char *inhex = NULL;
     unsigned char *data;
     int datalen;
-    int decode = -1;
-    int doing_opts = TRUE;
+    enum { UNKNOWN, DECODE, ENCODE } mode = UNKNOWN;
+    bool doing_opts = true;
 
     while (--argc > 0) {
 	char *p = *++argv;
@@ -51,10 +51,10 @@ int main(int argc, char **argv)
 	    while (*p) {
 		switch (*p) {
 		  case 'e':
-		    decode = 0;
+		    mode = ENCODE;
 		    break;
 		  case 'd':
-		    decode = 1;
+		    mode = DECODE;
 		    break;
 		  case 'b':
 		    outputmode = BINARY;
@@ -79,13 +79,13 @@ int main(int argc, char **argv)
 	}
     }
 
-    if (decode < 0) {
+    if (mode == UNKNOWN) {
 	fprintf(stderr, "usage: obfusc < -e | -d > [ -b | -h ] [hex data]\n");
 	return 0;
     }
 
     if (outputmode == DEFAULT)
-	outputmode = (decode ? BINARY : HEX);
+	outputmode = (mode == DECODE ? BINARY : HEX);
 
     if (inhex) {
 	datalen = strlen(inhex) / 2;
@@ -111,7 +111,7 @@ int main(int argc, char **argv)
 	}
     }
 
-    obfuscate_bitmap(data, datalen * 8, decode);
+    obfuscate_bitmap(data, datalen * 8, mode == DECODE);
 
     if (outputmode == BINARY) {
 	int ret = fwrite(data, 1, datalen, stdout);
diff --git a/apps/plugins/puzzles/src/osx.m b/apps/plugins/puzzles/src/osx.m
index daa4af1f09..0793817776 100644
--- a/apps/plugins/puzzles/src/osx.m
+++ b/apps/plugins/puzzles/src/osx.m
@@ -158,7 +158,7 @@ static void savefile_write(void *wctx, const void *buf, int len)
     fwrite(buf, 1, len, fp);
 }
 
-static int savefile_read(void *wctx, void *buf, int len)
+static bool savefile_read(void *wctx, void *buf, int len)
 {
     FILE *fp = (FILE *)wctx;
     int ret;
@@ -392,7 +392,7 @@ struct frontend {
     MyImageView *view;
     NSColor **colours;
     int ncolours;
-    int clipped;
+    bool clipped;
     int w, h;
 };
 
@@ -522,7 +522,7 @@ struct frontend {
     frame.origin.x = 0;
 
     w = h = INT_MAX;
-    midend_size(me, &w, &h, FALSE);
+    midend_size(me, &w, &h, false);
     frame.size.width = w;
     frame.size.height = h;
     fe.w = w;
@@ -557,7 +557,7 @@ struct frontend {
      */
     midend_new_game(me);
     w = h = INT_MAX;
-    midend_size(me, &w, &h, FALSE);
+    midend_size(me, &w, &h, false);
     rect.size.width = w;
     rect.size.height = h;
     fe.w = w;
@@ -654,23 +654,23 @@ struct frontend {
 	 * function key codes.
 	 */
 	if (c >= 0x80) {
-	    int mods = FALSE;
+	    bool mods = false;
 	    switch (c) {
 	      case NSUpArrowFunctionKey:
 		c = CURSOR_UP;
-		mods = TRUE;
+		mods = true;
 		break;
 	      case NSDownArrowFunctionKey:
 		c = CURSOR_DOWN;
-		mods = TRUE;
+		mods = true;
 		break;
 	      case NSLeftArrowFunctionKey:
 		c = CURSOR_LEFT;
-		mods = TRUE;
+		mods = true;
 		break;
 	      case NSRightArrowFunctionKey:
 		c = CURSOR_RIGHT;
-		mods = TRUE;
+		mods = true;
 		break;
 	      default:
 		continue;
@@ -750,7 +750,7 @@ struct frontend {
     NSSavePanel *sp = [NSSavePanel savePanel];
 
     if ([sp runModal] == NSFileHandlingPanelOKButton) {
-       const char *name = [[sp filename] UTF8String];
+       const char *name = [[sp URL] fileSystemRepresentation];
 
         FILE *fp = fopen(name, "w");
 
@@ -770,25 +770,9 @@ struct frontend {
 
     [op setAllowsMultipleSelection:NO];
 
-    if ([op runModalForTypes:nil] == NSOKButton) {
-        /*
-         * This used to be
-         *
-         *    [[[op filenames] objectAtIndex:0] cString]
-         *
-         * but the plain cString method became deprecated and Xcode 7
-         * started complaining about it. Since OS X 10.9 we can
-         * apparently use the more modern API
-         *
-         *    [[[op URLs] objectAtIndex:0] fileSystemRepresentation]
-         *
-         * but the alternative below still compiles with Xcode 7 and
-         * is a bit more backwards compatible, so I'll try it for the
-         * moment.
-         */
-	const char *name = [[[op filenames] objectAtIndex:0]
-                               cStringUsingEncoding:
-                                   [NSString defaultCStringEncoding]];
+    if ([op runModal] == NSOKButton) {
+	const char *name = [[[op URLs] objectAtIndex:0]
+                               fileSystemRepresentation];
 	const char *err;
 
         FILE *fp = fopen(name, "r");
@@ -973,7 +957,7 @@ struct frontend {
     int w, h;
 
     w = h = INT_MAX;
-    midend_size(me, &w, &h, FALSE);
+    midend_size(me, &w, &h, false);
     size.width = w;
     size.height = h;
     fe.w = w;
@@ -1291,7 +1275,7 @@ struct frontend {
     [self startConfigureSheet:CFG_SETTINGS];
 }
 
-- (void)sheetEndWithStatus:(BOOL)update
+- (void)sheetEndWithStatus:(bool)update
 {
     assert(sheet != NULL);
     [app endSheet:sheet];
@@ -1341,11 +1325,11 @@ struct frontend {
 }
 - (void)sheetOKButton:(id)sender
 {
-    [self sheetEndWithStatus:YES];
+    [self sheetEndWithStatus:true];
 }
 - (void)sheetCancelButton:(id)sender
 {
-    [self sheetEndWithStatus:NO];
+    [self sheetEndWithStatus:false];
 }
 
 - (void)setStatusLine:(const char *)text
@@ -1593,20 +1577,20 @@ static void osx_clip(void *handle, int x, int y, int w, int h)
     if (!fe->clipped)
 	[[NSGraphicsContext currentContext] saveGraphicsState];
     [NSBezierPath clipRect:r];
-    fe->clipped = TRUE;
+    fe->clipped = true;
 }
 static void osx_unclip(void *handle)
 {
     frontend *fe = (frontend *)handle;
     if (fe->clipped)
 	[[NSGraphicsContext currentContext] restoreGraphicsState];
-    fe->clipped = FALSE;
+    fe->clipped = false;
 }
 static void osx_start_draw(void *handle)
 {
     frontend *fe = (frontend *)handle;
     [fe->image lockFocus];
-    fe->clipped = FALSE;
+    fe->clipped = false;
 }
 static void osx_end_draw(void *handle)
 {
diff --git a/apps/plugins/puzzles/src/palisade.c b/apps/plugins/puzzles/src/palisade.c
index 0be8ac57f6..759fcaa75d 100644
--- a/apps/plugins/puzzles/src/palisade.c
+++ b/apps/plugins/puzzles/src/palisade.c
@@ -59,8 +59,7 @@ struct game_state {
     shared_state *shared;
     borderflag *borders; /* length w*h */
 
-    unsigned int completed: 1;
-    unsigned int cheated: 1;
+    bool completed, cheated;
 };
 
 #define DEFAULT_PRESET 0
@@ -75,15 +74,15 @@ static game_params *default_params(void)
     return clone(&presets[DEFAULT_PRESET]);
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
-    if (i < 0 || i >= lenof(presets)) return FALSE;
+    if (i < 0 || i >= lenof(presets)) return false;
 
     *params = clone(&presets[i]);
     *name = string(60, "%d x %d, regions of size %d",
                    presets[i].w, presets[i].h, presets[i].k);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -107,7 +106,7 @@ static void decode_params(game_params *params, char const *string)
     if (*string == 'n') params->k = atoi(++string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     return string(40, "%dx%dn%d", params->w, params->h, params->k);
 }
@@ -155,7 +154,7 @@ static game_params *custom_params(const config_item *cfg)
  * +---+   the dominos is horizontal or vertical.            +---+---+
  */
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int w = params->w, h = params->h, k = params->k, wh = w * h;
 
@@ -268,7 +267,7 @@ static void connect(solver_ctx *ctx, int i, int j)
     dsf_merge(ctx->dsf, i, j);
 }
 
-static int connected(solver_ctx *ctx, int i, int j, int dir)
+static bool connected(solver_ctx *ctx, int i, int j, int dir)
 {
     if (j == COMPUTE_J) j = i + dx[dir] + ctx->params->w*dy[dir];
     return dsf_canonify(ctx->dsf, i) == dsf_canonify(ctx->dsf, j);
@@ -281,13 +280,13 @@ static void disconnect(solver_ctx *ctx, int i, int j, int dir)
     ctx->borders[j] |= BORDER(FLIP(dir));
 }
 
-static int disconnected(solver_ctx *ctx, int i, int j, int dir)
+static bool disconnected(solver_ctx *ctx, int i, int j, int dir)
 {
     assert (j == COMPUTE_J || j == i + dx[dir] + ctx->params->w*dy[dir]);
     return ctx->borders[i] & BORDER(dir);
 }
 
-static int maybe(solver_ctx *ctx, int i, int j, int dir)
+static bool maybe(solver_ctx *ctx, int i, int j, int dir)
 {
     assert (j == COMPUTE_J || j == i + dx[dir] + ctx->params->w*dy[dir]);
     return !disconnected(ctx, i, j, dir) && !connected(ctx, i, j, dir);
@@ -315,16 +314,16 @@ static void solver_connected_clues_versus_region_size(solver_ctx *ctx)
                  ctx->params->k != 2))
             {
                 disconnect(ctx, i, j, dir);
-                /* changed = TRUE, but this is a one-shot... */
+                /* changed = true, but this is a one-shot... */
             }
         }
     }
 }
 
-static int solver_number_exhausted(solver_ctx *ctx)
+static bool solver_number_exhausted(solver_ctx *ctx)
 {
     int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir, off;
-    int changed = FALSE;
+    bool changed = false;
 
     for (i = 0; i < wh; ++i) {
         if (ctx->clues[i] == EMPTY) continue;
@@ -334,7 +333,7 @@ static int solver_number_exhausted(solver_ctx *ctx)
                 int j = i + dx[dir] + w*dy[dir];
                 if (!maybe(ctx, i, j, dir)) continue;
                 connect(ctx, i, j);
-                changed = TRUE;
+                changed = true;
             }
             continue;
         }
@@ -350,17 +349,17 @@ static int solver_number_exhausted(solver_ctx *ctx)
                 int j = i + dx[dir] + w*dy[dir];
                 if (!maybe(ctx, i, j, dir)) continue;
                 disconnect(ctx, i, j, dir);
-                changed = TRUE;
+                changed = true;
             }
     }
 
     return changed;
 }
 
-static int solver_not_too_big(solver_ctx *ctx)
+static bool solver_not_too_big(solver_ctx *ctx)
 {
     int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir;
-    int changed = FALSE;
+    bool changed = false;
 
     for (i = 0; i < wh; ++i) {
         int size = dsf_size(ctx->dsf, i);
@@ -369,17 +368,18 @@ static int solver_not_too_big(solver_ctx *ctx)
             if (!maybe(ctx, i, j, dir)) continue;
             if (size + dsf_size(ctx->dsf, j) <= ctx->params->k) continue;
             disconnect(ctx, i, j, dir);
-            changed = TRUE;
+            changed = true;
         }
     }
 
     return changed;
 }
 
-static int solver_not_too_small(solver_ctx *ctx)
+static bool solver_not_too_small(solver_ctx *ctx)
 {
     int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dir;
-    int *outs, k = ctx->params->k, ci, changed = FALSE;
+    int *outs, k = ctx->params->k, ci;
+    bool changed = false;
 
     snewa(outs, wh);
     setmem(outs, -1, wh);
@@ -400,17 +400,17 @@ static int solver_not_too_small(solver_ctx *ctx)
         if (i != dsf_canonify(ctx->dsf, i)) continue;
         if (j < 0) continue;
         connect(ctx, i, j); /* only one place for i to grow */
-        changed = TRUE;
+        changed = true;
     }
 
     sfree(outs);
     return changed;
 }
 
-static int solver_no_dangling_edges(solver_ctx *ctx)
+static bool solver_no_dangling_edges(solver_ctx *ctx)
 {
     int w = ctx->params->w, h = ctx->params->h, r, c;
-    int changed = FALSE;
+    bool changed = false;
 
     /* for each vertex */
     for (r = 1; r < h; ++r)
@@ -435,7 +435,7 @@ static int solver_no_dangling_edges(solver_ctx *ctx)
             if (4 - noline == 1) {
                 assert (e != -1);
                 disconnect(ctx, e, COMPUTE_J, de);
-                changed = TRUE;
+                changed = true;
                 continue;
             }
 
@@ -447,21 +447,21 @@ static int solver_no_dangling_edges(solver_ctx *ctx)
             if (ctx->borders[e] & BORDER(de)) {
                 if (!(ctx->borders[f] & BORDER(df))) {
                     disconnect(ctx, f, COMPUTE_J, df);
-                    changed = TRUE;
+                    changed = true;
                 }
             } else if (ctx->borders[f] & BORDER(df)) {
                 disconnect(ctx, e, COMPUTE_J, de);
-                changed = TRUE;
+                changed = true;
             }
         }
 
     return changed;
 }
 
-static int solver_equivalent_edges(solver_ctx *ctx)
+static bool solver_equivalent_edges(solver_ctx *ctx)
 {
     int w = ctx->params->w, h = ctx->params->h, wh = w*h, i, dirj;
-    int changed = FALSE;
+    bool changed = false;
 
     /* if a square is adjacent to two connected squares, the two
      * borders (i,j) and (i,k) are either both on or both off. */
@@ -489,11 +489,11 @@ static int solver_equivalent_edges(solver_ctx *ctx)
                 if (n_on + 2 > ctx->clues[i]) {
                     connect(ctx, i, j);
                     connect(ctx, i, k);
-                    changed = TRUE;
+                    changed = true;
                 } else if (n_off + 2 > 4 - ctx->clues[i]) {
                     disconnect(ctx, i, j, dirj);
                     disconnect(ctx, i, k, dirk);
-                    changed = TRUE;
+                    changed = true;
                 }
             }
         }
@@ -505,7 +505,7 @@ static int solver_equivalent_edges(solver_ctx *ctx)
 #define UNVISITED 6
 
 /* build connected components in `dsf', along the lines of `borders'. */
-static void dfs_dsf(int i, int w, borderflag *border, int *dsf, int black)
+static void dfs_dsf(int i, int w, borderflag *border, int *dsf, bool black)
 {
     int dir;
     for (dir = 0; dir < 4; ++dir) {
@@ -518,8 +518,8 @@ static void dfs_dsf(int i, int w, borderflag *border, int *dsf, int black)
     }
 }
 
-static int is_solved(const game_params *params, clue *clues,
-                     borderflag *border)
+static bool is_solved(const game_params *params, clue *clues,
+                      borderflag *border)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
     int i, x, y;
@@ -536,7 +536,7 @@ static int is_solved(const game_params *params, clue *clues,
      *  - the borders also satisfy the clue set
      */
     for (i = 0; i < wh; ++i) {
-        if (dsf[i] == UNVISITED) dfs_dsf(i, params->w, border, dsf, TRUE);
+        if (dsf[i] == UNVISITED) dfs_dsf(i, params->w, border, dsf, true);
         if (dsf_size(dsf, i) != k) goto error;
         if (clues[i] == EMPTY) continue;
         if (clues[i] != bitcount[border[i] & BORDER_MASK]) goto error;
@@ -563,16 +563,17 @@ static int is_solved(const game_params *params, clue *clues,
     }
 
     sfree(dsf);
-    return TRUE;
+    return true;
 
 error:
     sfree(dsf);
-    return FALSE;
+    return false;
 }
 
-static int solver(const game_params *params, clue *clues, borderflag *borders)
+static bool solver(const game_params *params, clue *clues, borderflag *borders)
 {
-    int w = params->w, h = params->h, wh = w*h, changed;
+    int w = params->w, h = params->h, wh = w*h;
+    bool changed;
     solver_ctx ctx;
 
     ctx.params = params;
@@ -582,7 +583,7 @@ static int solver(const game_params *params, clue *clues, borderflag *borders)
 
     solver_connected_clues_versus_region_size(&ctx); /* idempotent */
     do {
-        changed  = FALSE;
+        changed  = false;
         changed |= solver_number_exhausted(&ctx);
         changed |= solver_not_too_big(&ctx);
         changed |= solver_not_too_small(&ctx);
@@ -617,7 +618,7 @@ static void init_borders(int w, int h, borderflag *borders)
 #define xshuffle(ptr, len, rs) shuffle((ptr), (len), sizeof (ptr)[0], (rs))
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
 
@@ -750,7 +751,7 @@ static game_state *new_game(midend *me, const game_params *params,
     init_borders(w, h, state->borders);
 
     state->completed = (params->k == wh);
-    state->cheated = FALSE;
+    state->cheated = false;
 
     return state;
 }
@@ -819,9 +820,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -865,16 +866,15 @@ static char *game_text_format(const game_state *state)
 
 struct game_ui {
     int x, y;
-    unsigned int show:       1;
-    unsigned int fake_ctrl:  1;
-    unsigned int fake_shift: 1;
+    bool show;
+    bool fake_ctrl, fake_shift;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
     ui->x = ui->y = 0;
-    ui->show = ui->fake_ctrl = ui->fake_shift = FALSE;
+    ui->show = ui->fake_ctrl = ui->fake_shift = false;
     return ui;
 }
 
@@ -918,10 +918,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                             const game_drawstate *ds, int x, int y, int button)
 {
     int w = state->shared->params.w, h = state->shared->params.h;
-    int control = (button & MOD_CTRL) | ui->fake_ctrl, shift = (button & MOD_SHFT) | ui->fake_shift;
+    bool control = (button & MOD_CTRL) | ui->fake_ctrl, shift = (button & MOD_SHFT) | ui->fake_shift;
 
     /* reset */
-    ui->fake_ctrl = ui->fake_shift = FALSE;
+    ui->fake_ctrl = ui->fake_shift = false;
 
     button &= ~MOD_MASK;
 
@@ -950,7 +950,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         if (OUT_OF_BOUNDS(hx, hy, w, h)) return NULL;
 
-        ui->show = FALSE;
+        ui->show = false;
 
         i = gy * w + gx;
         switch ((button == RIGHT_BUTTON) |
@@ -974,13 +974,13 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     }
 
     if (IS_CURSOR_MOVE(button)) {
-        ui->show = TRUE;
+        ui->show = true;
         if (control || shift) {
             borderflag flag = 0, newflag;
             int dir, i =  ui->y * w + ui->x;
             x = ui->x;
             y = ui->y;
-            move_cursor(button, &x, &y, w, h, FALSE);
+            move_cursor(button, &x, &y, w, h, false);
             if (OUT_OF_BOUNDS(x, y, w, h)) return NULL;
 
             for (dir = 0; dir < 4; ++dir)
@@ -1000,7 +1000,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             return string(80, "F%d,%d,%dF%d,%d,%d",
                           ui->x, ui->y, flag, x, y, newflag);
         } else {
-            move_cursor(button, &ui->x, &ui->y, w, h, FALSE);
+            move_cursor(button, &ui->x, &ui->y, w, h, false);
             return UI_UPDATE;
         }
     }
@@ -1008,7 +1008,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         /* CURSOR_SELECT or CURSOR_SELECT2 tells us to toggle whether
          * the button press should be interpreted as having CTRL or
          * shift pressed along with it, respectively. */
-        ui->show = TRUE;
+        ui->show = true;
         if(button == CURSOR_SELECT2)
             ui->fake_shift = !ui->fake_shift;
         else
@@ -1031,7 +1031,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             ret->borders[i] =
                 (move[i] & BORDER_MASK) | DISABLED(~move[i] & BORDER_MASK);
         if (i < wh || move[i]) return NULL; /* leaks `ret', then we die */
-        ret->cheated = ret->completed = TRUE;
+        ret->cheated = ret->completed = true;
         return ret;
     }
 
@@ -1205,9 +1205,9 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
     for (i = 0; i < wh; ++i) {
         if (black_border_dsf[i] == UNVISITED)
-            dfs_dsf(i, w, state->borders, black_border_dsf, TRUE);
+            dfs_dsf(i, w, state->borders, black_border_dsf, true);
         if (yellow_border_dsf[i] == UNVISITED)
-            dfs_dsf(i, w, state->borders, yellow_border_dsf, FALSE);
+            dfs_dsf(i, w, state->borders, yellow_border_dsf, false);
     }
 
     for (r = 0; r < h; ++r)
@@ -1293,10 +1293,10 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     assert (!"this shouldn't get called");
-    return 0;                          /* placate optimiser */
+    return false;                      /* placate optimiser */
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1310,7 +1310,7 @@ static void game_print_size(const game_params *params, float *x, float *y)
 }
 
 static void print_line(drawing *dr, int x1, int y1, int x2, int y2,
-                       int colour, int full)
+                       int colour, bool full)
 {
     if (!full) {
         int i, subdivisions = 8;
@@ -1377,15 +1377,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1402,8 +1402,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    TRUE,                                     /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    true,                                     /* wants_statusbar */
+    false, game_timing_state,
     0,                                         /* flags */
 };
diff --git a/apps/plugins/puzzles/src/pattern.c b/apps/plugins/puzzles/src/pattern.c
index f715df490e..42f3fc55ce 100644
--- a/apps/plugins/puzzles/src/pattern.c
+++ b/apps/plugins/puzzles/src/pattern.c
@@ -50,14 +50,14 @@ typedef struct game_state_common {
     int w, h;
     int rowsize;
     int *rowdata, *rowlen;
-    unsigned char *immutable;
+    bool *immutable;
     int refcount;
 } game_state_common;
 
 struct game_state {
     game_state_common *common;
     unsigned char *grid;
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 #define FLASH_TIME 0.13F
@@ -81,13 +81,13 @@ static const struct game_params pattern_presets[] = {
 #endif
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(pattern_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = pattern_presets[i];
@@ -96,7 +96,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -126,7 +126,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[400];
     int len;
@@ -171,7 +171,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
 	return "Width and height must both be greater than zero";
@@ -359,10 +359,10 @@ static int compute_rowdata(int *ret, unsigned char *start, int len, int step)
 #define STILL_UNKNOWN 3
 
 #ifdef STANDALONE_SOLVER
-int verbose = FALSE;
+bool verbose = false;
 #endif
 
-static int do_recurse(unsigned char *known, unsigned char *deduced,
+static bool do_recurse(unsigned char *known, unsigned char *deduced,
                        unsigned char *row,
 		       unsigned char *minpos_done, unsigned char *maxpos_done,
 		       unsigned char *minpos_ok, unsigned char *maxpos_ok,
@@ -416,28 +416,29 @@ static int do_recurse(unsigned char *known, unsigned char *deduced,
 	return lowest >= minpos_ok[ndone] && lowest <= maxpos_ok[ndone];
     } else {
 	for (i=lowest; i<len; i++) {
-	    if (known[i] == BLOCK) return FALSE;
+	    if (known[i] == BLOCK) return false;
 	    row[i] = DOT;
 	    }
 	for (i=0; i<len; i++)
 	    deduced[i] |= row[i];
-	return TRUE;
+	return true;
     }
 }
 
 
-static int do_row(unsigned char *known, unsigned char *deduced,
-                  unsigned char *row,
-                  unsigned char *minpos_done, unsigned char *maxpos_done,
-		  unsigned char *minpos_ok, unsigned char *maxpos_ok,
-                  unsigned char *start, int len, int step, int *data,
-		  unsigned int *changed
+static bool do_row(unsigned char *known, unsigned char *deduced,
+                   unsigned char *row,
+                   unsigned char *minpos_done, unsigned char *maxpos_done,
+                   unsigned char *minpos_ok, unsigned char *maxpos_ok,
+                   unsigned char *start, int len, int step, int *data,
+                   unsigned int *changed
 #ifdef STANDALONE_SOLVER
-		  , const char *rowcol, int index, int cluewid
+                   , const char *rowcol, int index, int cluewid
 #endif
-		  )
+                   )
 {
-    int rowlen, i, freespace, done_any;
+    int rowlen, i, freespace;
+    bool done_any;
 
     freespace = len+1;
     for (rowlen = 0; data[rowlen]; rowlen++) {
@@ -462,12 +463,12 @@ static int do_row(unsigned char *known, unsigned char *deduced,
                    maxpos_ok, data, len, freespace, 0, 0);
     }
 
-    done_any = FALSE;
+    done_any = false;
     for (i=0; i<len; i++)
 	if (deduced[i] && deduced[i] != STILL_UNKNOWN && !known[i]) {
 	    start[i*step] = deduced[i];
 	    if (changed) changed[i]++;
-	    done_any = TRUE;
+	    done_any = true;
 	}
 #ifdef STANDALONE_SOLVER
     if (verbose && done_any) {
@@ -493,19 +494,20 @@ static int do_row(unsigned char *known, unsigned char *deduced,
     return done_any;
 }
 
-static int solve_puzzle(const game_state *state, unsigned char *grid,
-                        int w, int h,
-			unsigned char *matrix, unsigned char *workspace,
-			unsigned int *changed_h, unsigned int *changed_w,
-			int *rowdata
+static bool solve_puzzle(const game_state *state, unsigned char *grid,
+                         int w, int h,
+                         unsigned char *matrix, unsigned char *workspace,
+                         unsigned int *changed_h, unsigned int *changed_w,
+                         int *rowdata
 #ifdef STANDALONE_SOLVER
-			, int cluewid
+                         , int cluewid
 #else
-			, int dummy
+                         , int dummy
 #endif
-			)
+                         )
 {
-    int i, j, ok, max;
+    int i, j, max;
+    bool ok;
     int max_h, max_w;
 
     assert((state!=NULL && state->common->rowdata!=NULL) ^ (grid!=NULL));
@@ -637,11 +639,11 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
 	}
     } while (max_h>0 || max_w>0);
 
-    ok = TRUE;
+    ok = true;
     for (i=0; i<h; i++) {
 	for (j=0; j<w; j++) {
 	    if (matrix[i*w+j] == UNKNOWN)
-		ok = FALSE;
+		ok = false;
 	}
     }
 
@@ -651,7 +653,8 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
 #ifndef STANDALONE_PICTURE_GENERATOR
 static unsigned char *generate_soluble(random_state *rs, int w, int h)
 {
-    int i, j, ok, ntries, max;
+    int i, j, ntries, max;
+    bool ok;
     unsigned char *grid, *matrix, *workspace;
     unsigned int *changed_h, *changed_w;
     int *rowdata;
@@ -679,14 +682,14 @@ static unsigned char *generate_soluble(random_state *rs, int w, int h)
          * made for rows/columns that are under 3 squares,
          * otherwise nothing will ever be successfully generated.
          */
-        ok = TRUE;
+        ok = true;
         if (w > 2) {
             for (i = 0; i < h; i++) {
                 int colours = 0;
                 for (j = 0; j < w; j++)
                     colours |= (grid[i*w+j] == GRID_FULL ? 2 : 1);
                 if (colours != 3)
-                    ok = FALSE;
+                    ok = false;
             }
         }
         if (h > 2) {
@@ -695,7 +698,7 @@ static unsigned char *generate_soluble(random_state *rs, int w, int h)
                 for (i = 0; i < h; i++)
                     colours |= (grid[i*w+j] == GRID_FULL ? 2 : 1);
                 if (colours != 3)
-                    ok = FALSE;
+                    ok = false;
             }
         }
         if (!ok)
@@ -719,7 +722,7 @@ unsigned char *picture;
 #endif
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     unsigned char *grid;
     int i, j, max, rowlen, *rowdata;
@@ -746,8 +749,9 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     state->grid = grid;
     state->common = snew(game_state_common);
     state->common->rowdata = NULL;
-    state->common->immutable = snewn(params->w * params->h, unsigned char);
-    memset(state->common->immutable, 1, params->w * params->h);
+    state->common->immutable = snewn(params->w * params->h, bool);
+    for (i = 0; i < params->w * params->h; i++)
+        state->common->immutable[i] = true;
 
     index = snewn(params->w * params->h, int);
     for (i = 0; i < params->w * params->h; i++)
@@ -761,11 +765,11 @@ static char *new_game_desc(const game_params *params, random_state *rs,
         unsigned int *changed_w = snewn(max+1, unsigned int);
         int *rowdata = snewn(max+1, int);
         for (i = 0; i < params->w * params->h; i++) {
-            state->common->immutable[index[i]] = 0;
+            state->common->immutable[index[i]] = false;
             if (!solve_puzzle(state, grid, params->w, params->h,
                               matrix, workspace, changed_h, changed_w,
                               rowdata, 0))
-                state->common->immutable[index[i]] = 1;
+                state->common->immutable[index[i]] = true;
         }
         sfree(workspace);
         sfree(changed_h);
@@ -974,14 +978,15 @@ static game_state *new_game(midend *me, const game_params *params,
     memset(state->grid, GRID_UNKNOWN, state->common->w * state->common->h);
 
     state->common->immutable = snewn(state->common->w * state->common->h,
-                                     unsigned char);
-    memset(state->common->immutable, 0, state->common->w * state->common->h);
+                                     bool);
+    memset(state->common->immutable, 0,
+           state->common->w * state->common->h * sizeof(bool));
 
     state->common->rowsize = max(state->common->w, state->common->h);
     state->common->rowdata = snewn(state->common->rowsize * (state->common->w + state->common->h), int);
     state->common->rowlen = snewn(state->common->w + state->common->h, int);
 
-    state->completed = state->cheated = FALSE;
+    state->completed = state->cheated = false;
 
     for (i = 0; i < params->w + params->h; i++) {
         state->common->rowlen[i] = 0;
@@ -1005,11 +1010,12 @@ static game_state *new_game(midend *me, const game_params *params,
         i = 0;
         while (i < params->w * params->h) {
             int c = (unsigned char)*desc++;
-            int full = isupper(c), len = tolower(c) - 'a';
+            bool full = isupper(c);
+            int len = tolower(c) - 'a';
             i += len;
             if (len < 25 && i < params->w*params->h) {
                 state->grid[i] = full ? GRID_FULL : GRID_EMPTY;
-                state->common->immutable[i] = TRUE;
+                state->common->immutable[i] = true;
                 i++;
             }
         }
@@ -1053,7 +1059,8 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     int w = state->common->w, h = state->common->h;
     int i;
     char *ret;
-    int max, ok;
+    int max;
+    bool ok;
     unsigned char *workspace;
     unsigned int *changed_h, *changed_w;
     int *rowdata;
@@ -1098,9 +1105,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1120,11 +1127,12 @@ static char *game_text_format(const game_state *state)
 	    }
     }
     for (i = 0; i < h; ++i) {
-	int rowlen = 0, predecessors = FALSE;
+	int rowlen = 0;
+        bool predecessors = false;
 	for (j = 0; j < state->common->rowlen[i+w]; ++j) {
 	    int copy = state->common->rowdata[(i+w)*state->common->rowsize + j];
 	    rowlen += predecessors;
-	    predecessors = TRUE;
+	    predecessors = true;
 	    do ++rowlen; while (copy /= 10);
 	}
 	left_gap = max(left_gap, rowlen);
@@ -1172,7 +1180,7 @@ static char *game_text_format(const game_state *state)
 	    int cell = topleft + i*cw + j*ch*lw;
 	    int center = cell + cw/2 + (ch/2)*lw;
 	    int dx, dy;
-	    board[cell] = 0 ? center : '+';
+	    board[cell] = false ? center : '+';
 	    for (dx = 1; dx < cw; ++dx) board[cell + dx] = '-';
 	    for (dy = 1; dy < ch; ++dy) board[cell + dy*lw] = '|';
 	    if (state->grid[i*w+j] == GRID_UNKNOWN) continue;
@@ -1191,13 +1199,14 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int dragging;
+    bool dragging;
     int drag_start_x;
     int drag_start_y;
     int drag_end_x;
     int drag_end_y;
     int drag, release, state;
-    int cur_x, cur_y, cur_visible;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1205,8 +1214,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ret;
 
     ret = snew(game_ui);
-    ret->dragging = FALSE;
-    ret->cur_x = ret->cur_y = ret->cur_visible = 0;
+    ret->dragging = false;
+    ret->cur_x = ret->cur_y = 0;
+    ret->cur_visible = false;
 
     return ret;
 }
@@ -1231,7 +1241,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h;
     int tilesize;
     unsigned char *visible, *numcolours;
@@ -1242,7 +1252,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                             const game_drawstate *ds,
                             int x, int y, int button)
 {
-    int control = button & MOD_CTRL, shift = button & MOD_SHFT;
+    bool control = button & MOD_CTRL, shift = button & MOD_SHFT;
     button &= ~MOD_MASK;
 
     x = FROMCOORD(state->common->w, x);
@@ -1255,7 +1265,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         int currstate = state->grid[y * state->common->w + x];
 #endif
 
-        ui->dragging = TRUE;
+        ui->dragging = true;
 
         if (button == LEFT_BUTTON) {
             ui->drag = LEFT_DRAG;
@@ -1281,7 +1291,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         ui->drag_start_x = ui->drag_end_x = x;
         ui->drag_start_y = ui->drag_end_y = y;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
 
         return UI_UPDATE;
     }
@@ -1317,7 +1327,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
     if (ui->dragging && button == ui->release) {
         int x1, x2, y1, y2, xx, yy;
-        int move_needed = FALSE;
+        bool move_needed = false;
 
         x1 = min(ui->drag_start_x, ui->drag_end_x);
         x2 = max(ui->drag_start_x, ui->drag_end_x);
@@ -1328,9 +1338,9 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             for (xx = x1; xx <= x2; xx++)
                 if (!state->common->immutable[yy * state->common->w + xx] &&
                     state->grid[yy * state->common->w + xx] != ui->state)
-                    move_needed = TRUE;
+                    move_needed = true;
 
-        ui->dragging = FALSE;
+        ui->dragging = false;
 
         if (move_needed) {
 	    char buf[80];
@@ -1346,8 +1356,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (IS_CURSOR_MOVE(button)) {
 	int x = ui->cur_x, y = ui->cur_y, newstate;
 	char buf[80];
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->common->w, state->common->h, 0);
-        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->common->w, state->common->h, false);
+        ui->cur_visible = true;
 	if (!control && !shift) return UI_UPDATE;
 
 	newstate = control ? shift ? GRID_UNKNOWN : GRID_FULL : GRID_EMPTY;
@@ -1367,7 +1377,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         char buf[80];
 
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
 
@@ -1403,7 +1413,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	for (i = 0; i < ret->common->w * ret->common->h; i++)
 	    ret->grid[i] = (move[i+1] == '1' ? GRID_FULL : GRID_EMPTY);
 
-	ret->completed = ret->cheated = TRUE;
+	ret->completed = ret->cheated = true;
 
 	return ret;
     } else if ((move[0] == 'F' || move[0] == 'E' || move[0] == 'U') &&
@@ -1430,7 +1440,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	    int *rowdata = snewn(ret->common->rowsize, int);
 	    int i, len;
 
-	    ret->completed = TRUE;
+	    ret->completed = true;
 
 	    for (i=0; i<ret->common->w; i++) {
 		len = compute_rowdata(rowdata, ret->grid+i,
@@ -1438,7 +1448,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 		if (len != ret->common->rowlen[i] ||
 		    memcmp(ret->common->rowdata+i*ret->common->rowsize,
                            rowdata, len * sizeof(int))) {
-		    ret->completed = FALSE;
+		    ret->completed = false;
 		    break;
 		}
 	    }
@@ -1449,7 +1459,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 		    memcmp(ret->common->rowdata +
                            (i+ret->common->w)*ret->common->rowsize,
                            rowdata, len * sizeof(int))) {
-		    ret->completed = FALSE;
+		    ret->completed = false;
 		    break;
 		}
 	    }
@@ -1537,7 +1547,7 @@ struct errcheck_state {
     int ncontig;
 };
 
-static int errcheck_found_run(struct errcheck_state *es, int r)
+static bool errcheck_found_run(struct errcheck_state *es, int r)
 {
 /* Macro to handle the pretence that rowdata has a 0 at each end */
 #define ROWDATA(k) ((k)<0 || (k)>=es->rowlen ? 0 : es->rowdata[(k)])
@@ -1558,17 +1568,17 @@ static int errcheck_found_run(struct errcheck_state *es, int r)
 
         es->rowpos = newpos+1;
         es->ncontig++;
-        return TRUE;
+        return true;
 
       notfound:;
     }
 
-    return FALSE;
+    return false;
 
 #undef ROWDATA
 }
 
-static int check_errors(const game_state *state, int i)
+static bool check_errors(const game_state *state, int i)
 {
     int start, step, end, j;
     int val, runlen;
@@ -1606,7 +1616,7 @@ static int check_errors(const game_state *state, int i)
         } else if (val == GRID_EMPTY) {
             if (runlen > 0) {
                 if (!errcheck_found_run(es, runlen))
-                    return TRUE;       /* error! */
+                    return true;       /* error! */
             }
             runlen = 0;
         }
@@ -1616,9 +1626,9 @@ static int check_errors(const game_state *state, int i)
      * zero run, which will be marked as contiguous with the previous
      * run if and only if there hasn't been a GRID_UNKNOWN before. */
     if (!errcheck_found_run(es, 0))
-        return TRUE;                   /* error at the last minute! */
+        return true;                   /* error at the last minute! */
 
-    return FALSE;                      /* no error */
+    return false;                      /* no error */
 }
 
 /* ----------------------------------------------------------------------
@@ -1671,7 +1681,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 {
     struct game_drawstate *ds = snew(struct game_drawstate);
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->common->w;
     ds->h = state->common->h;
     ds->visible = snewn(ds->w * ds->h, unsigned char);
@@ -1691,7 +1701,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void grid_square(drawing *dr, game_drawstate *ds,
-                        int y, int x, int state, int cur)
+                        int y, int x, int state, bool cur)
 {
     int xl, xr, yt, yb, dx, dy, dw, dh;
 
@@ -1723,8 +1733,9 @@ static void grid_square(drawing *dr, game_drawstate *ds,
 /*
  * Draw the numbers for a single row or column.
  */
-static void draw_numbers(drawing *dr, game_drawstate *ds,
-                         const game_state *state, int i, int erase, int colour)
+static void draw_numbers(
+    drawing *dr, game_drawstate *ds, const game_state *state,
+    int i, bool erase, int colour)
 {
     int rowlen = state->common->rowlen[i];
     int *rowdata = state->common->rowdata + state->common->rowsize * i;
@@ -1790,7 +1801,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 {
     int i, j;
     int x1, x2, y1, y2;
-    int cx, cy, cmoved;
+    int cx, cy;
+    bool cmoved;
 
     if (!ds->started) {
         /*
@@ -1808,7 +1820,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                   ds->w * TILE_SIZE + 3, ds->h * TILE_SIZE + 3,
                   COL_GRID);
 
-        ds->started = TRUE;
+        ds->started = true;
 
 	draw_update(dr, 0, 0, SIZE(ds->w), SIZE(ds->h));
     }
@@ -1835,7 +1847,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      */
     for (i = 0; i < ds->h; i++) {
         for (j = 0; j < ds->w; j++) {
-            int val, cc = 0;
+            int val;
+            bool cc = false;
 
             /*
              * Work out what state this square should be drawn in,
@@ -1850,8 +1863,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             if (cmoved) {
                 /* the cursor has moved; if we were the old or
                  * the new cursor position we need to redraw. */
-                if (j == cx && i == cy) cc = 1;
-                if (j == ds->cur_x && i == ds->cur_y) cc = 1;
+                if (j == cx && i == cy) cc = true;
+                if (j == ds->cur_x && i == ds->cur_y) cc = true;
             }
 
             /*
@@ -1879,7 +1892,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     for (i = 0; i < state->common->w + state->common->h; i++) {
         int colour = check_errors(state, i) ? COL_ERROR : COL_TEXT;
         if (ds->numcolours[i] != colour) {
-            draw_numbers(dr, ds, state, i, TRUE, colour);
+            draw_numbers(dr, ds, state, i, true, colour);
             ds->numcolours[i] = colour;
         }
     }
@@ -1905,9 +1918,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1957,7 +1970,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
      * Clues.
      */
     for (i = 0; i < state->common->w + state->common->h; i++)
-        draw_numbers(dr, ds, state, i, FALSE, ink);
+        draw_numbers(dr, ds, state, i, false, ink);
 
     /*
      * Solution.
@@ -1987,15 +2000,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2012,9 +2025,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -2031,7 +2044,7 @@ int main(int argc, char **argv)
         char *p = *++argv;
 	if (*p == '-') {
 	    if (!strcmp(p, "-v")) {
-		verbose = TRUE;
+		verbose = true;
 	    } else {
 		fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
 		return 1;
@@ -2251,8 +2264,8 @@ int main(int argc, char **argv)
 
     rs = random_new((void*)&seed, sizeof(time_t));
 
-    desc = new_game_desc(par, rs, NULL, FALSE);
-    params = encode_params(par, FALSE);
+    desc = new_game_desc(par, rs, NULL, false);
+    params = encode_params(par, false);
     printf("%s:%s\n", params, desc);
 
     sfree(desc);
diff --git a/apps/plugins/puzzles/src/pearl.c b/apps/plugins/puzzles/src/pearl.c
index 07949b5a99..ccbba51897 100644
--- a/apps/plugins/puzzles/src/pearl.c
+++ b/apps/plugins/puzzles/src/pearl.c
@@ -113,7 +113,7 @@ static char const pearl_diffchars[] = DIFFLIST(ENCODE);
 struct game_params {
     int w, h;
     int difficulty;
-    int nosolve;        /* XXX remove me! */
+    bool nosolve;        /* XXX remove me! */
 };
 
 struct shared_state {
@@ -129,7 +129,7 @@ struct game_state {
     char *lines;        /* size w*h: lines placed */
     char *errors;       /* size w*h: errors detected */
     char *marks;        /* size w*h: 'no line here' marks placed. */
-    int completed, used_solve;
+    bool completed, used_solve;
 };
 
 #define DEFAULT_PRESET 3
@@ -150,17 +150,17 @@ static game_params *default_params(void)
     game_params *ret = snew(game_params);
 
     *ret = pearl_presets[DEFAULT_PRESET];
-    ret->nosolve = FALSE;
+    ret->nosolve = false;
 
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[64];
 
-    if (i < 0 || i >= lenof(pearl_presets)) return FALSE;
+    if (i < 0 || i >= lenof(pearl_presets)) return false;
 
     ret = default_params();
     *ret = pearl_presets[i]; /* struct copy */
@@ -171,7 +171,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
             pearl_diffnames[pearl_presets[i].difficulty]);
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -206,14 +206,14 @@ static void decode_params(game_params *ret, char const *string)
 	if (*string) string++;
     }
 
-    ret->nosolve = FALSE;
+    ret->nosolve = false;
     if (*string == 'n') {
-        ret->nosolve = TRUE;
+        ret->nosolve = true;
         string++;
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -268,7 +268,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 5) return "Width must be at least five";
     if (params->h < 5) return "Height must be at least five";
@@ -282,8 +282,8 @@ static const char *validate_params(const game_params *params, int full)
  * Solver.
  */
 
-int pearl_solve(int w, int h, char *clues, char *result,
-                int difficulty, int partial)
+static int pearl_solve(int w, int h, char *clues, char *result,
+                       int difficulty, bool partial)
 {
     int W = 2*w+1, H = 2*h+1;
     short *workspace;
@@ -347,7 +347,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
      * Now repeatedly try to find something we can do.
      */
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 
 #ifdef SOLVER_DIAGNOSTICS
 	for (y = 0; y < H; y++) {
@@ -383,7 +383,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 				       ex/2, ey/2, (ex+1)/2, (ey+1)/2,
 				       b, x, y);
 #endif
-				done_something = TRUE;
+				done_something = true;
 				break;
 			    }
 			}
@@ -437,7 +437,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 
 		    if (!(edgeor & d) && workspace[ey*W+ex] == 3) {
 			workspace[ey*W+ex] = 2;
-			done_something = TRUE;
+			done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 			printf("possible states of square (%d,%d) force edge"
 			       " (%d,%d)-(%d,%d) to be disconnected\n",
@@ -445,7 +445,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 #endif
 		    } else if ((edgeand & d) && workspace[ey*W+ex] == 3) {
 			workspace[ey*W+ex] = 1;
-			done_something = TRUE;
+			done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 			printf("possible states of square (%d,%d) force edge"
 			       " (%d,%d)-(%d,%d) to be connected\n",
@@ -483,7 +483,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 			     */
 			    if (workspace[fy*W+fx] != (1<<type)) {
 				workspace[fy*W+fx] = (1<<type);
-				done_something = TRUE;
+				done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 				printf("corner clue at (%d,%d) forces square "
 				       "(%d,%d) into state %d\n", x, y,
@@ -501,7 +501,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 			     */
 			    if (!(workspace[fy*W+fx] & (1<<type))) {
 				workspace[ey*W+ex] = 2;
-				done_something = TRUE;
+				done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 				printf("corner clue at (%d,%d), plus square "
 				       "(%d,%d) not being state %d, "
@@ -535,7 +535,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 			    !(workspace[gy*W+gx] & ((1<<(  d |A(d))) |
 						    (1<<(  d |C(d)))))) {
 			    workspace[(2*y+1)*W+(2*x+1)] &= ~(1<<type);
-			    done_something = TRUE;
+			    done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 			    printf("straight clue at (%d,%d) cannot corner at "
 				   "(%d,%d) or (%d,%d) so is not state %d\n",
@@ -561,7 +561,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 			if (!(workspace[fy*W+fx] &~ (bLR|bUD)) &&
 			    (workspace[gy*W+gx] &~ (bLU|bLD|bRU|bRD))) {
 			    workspace[gy*W+gx] &= (bLU|bLD|bRU|bRD);
-			    done_something = TRUE;
+			    done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 			    printf("straight clue at (%d,%d) connecting to "
 				   "straight at (%d,%d) makes (%d,%d) a "
@@ -743,7 +743,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 				     * Yes! Mark this edge disconnected.
 				     */
 				    workspace[y*W+x] = 2;
-				    done_something = TRUE;
+				    done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 				    printf("edge (%d,%d)-(%d,%d) would create"
 					   " a shortcut loop, hence must be"
@@ -804,7 +804,7 @@ int pearl_solve(int w, int h, char *clues, char *result,
 					 * state invalid.
 					 */
 					workspace[y*W+x] &= ~(1<<b);
-					done_something = TRUE;
+					done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
 					printf("square (%d,%d) would create a "
 					       "shortcut loop in state %d, "
@@ -900,7 +900,7 @@ struct pearl_loopgen_bias_ctx {
     struct pearl_loopgen_bias_ctx_boundary {
         int colour;                    /* FACE_WHITE or FACE_BLACK */
 
-        char *edges;                   /* is each edge part of the loop? */
+        bool *edges;                   /* is each edge part of the loop? */
         tdq *edges_todo;
 
         char *vertextypes;             /* bits 0-3 == outgoing edge bitmap;
@@ -921,7 +921,7 @@ struct pearl_loopgen_bias_ctx {
 
     grid *g;
 };
-int pearl_loopgen_bias(void *vctx, char *board, int face)
+static int pearl_loopgen_bias(void *vctx, char *board, int face)
 {
     struct pearl_loopgen_bias_ctx *ctx = (struct pearl_loopgen_bias_ctx *)vctx;
     grid *g = ctx->g;
@@ -962,8 +962,8 @@ int pearl_loopgen_bias(void *vctx, char *board, int face)
             grid_edge *e = &g->edges[j];
             int fc1 = e->face1 ? board[e->face1 - g->faces] : FACE_BLACK;
             int fc2 = e->face2 ? board[e->face2 - g->faces] : FACE_BLACK;
-            int oldedge = b->edges[j];
-            int newedge = (fc1==c) ^ (fc2==c);
+            bool oldedge = b->edges[j];
+            bool newedge = (fc1==c) ^ (fc2==c);
             if (oldedge != newedge) {
                 b->edges[j] = newedge;
                 tdq_add(b->vertextypes_todo, e->dot1 - g->dots);
@@ -1048,7 +1048,7 @@ int pearl_loopgen_bias(void *vctx, char *board, int face)
     return ctx->score;
 }
 
-void pearl_loopgen(int w, int h, char *lines, random_state *rs)
+static void pearl_loopgen(int w, int h, char *lines, random_state *rs)
 {
     grid *g = grid_new(GRID_SQUARE, w-1, h-1, NULL);
     char *board = snewn(g->num_faces, char);
@@ -1070,8 +1070,8 @@ void pearl_loopgen(int w, int h, char *lines, random_state *rs)
     biasctx.score = 0;
     memset(biasctx.faces, FACE_GREY, g->num_faces);
     for (i = 0; i < 2; i++) {
-        biasctx.boundaries[i].edges = snewn(g->num_edges, char);
-        memset(biasctx.boundaries[i].edges, 0, g->num_edges);
+        biasctx.boundaries[i].edges = snewn(g->num_edges, bool);
+        memset(biasctx.boundaries[i].edges, 0, g->num_edges * sizeof(bool));
         biasctx.boundaries[i].edges_todo = tdq_new(g->num_edges);
         tdq_fill(biasctx.boundaries[i].edges_todo);
         biasctx.boundaries[i].vertextypes = snewn(g->num_dots, char);
@@ -1247,7 +1247,7 @@ static int new_clues(const game_params *params, random_state *rs,
             /*
              * See if we can solve the puzzle just like this.
              */
-            ret = pearl_solve(w, h, clues, grid, diff, FALSE);
+            ret = pearl_solve(w, h, clues, grid, diff, false);
             assert(ret > 0);	       /* shouldn't be inconsistent! */
             if (ret != 1)
                 continue;		       /* go round and try again */
@@ -1256,7 +1256,7 @@ static int new_clues(const game_params *params, random_state *rs,
              * Check this puzzle isn't too easy.
              */
             if (diff > DIFF_EASY) {
-                ret = pearl_solve(w, h, clues, grid, diff-1, FALSE);
+                ret = pearl_solve(w, h, clues, grid, diff-1, false);
                 assert(ret > 0);
                 if (ret == 1)
                     continue; /* too easy: try again */
@@ -1323,7 +1323,7 @@ static int new_clues(const game_params *params, random_state *rs,
                 clue = clues[y*w+x];
                 clues[y*w+x] = 0;	       /* try removing this clue */
 
-                ret = pearl_solve(w, h, clues, grid, diff, FALSE);
+                ret = pearl_solve(w, h, clues, grid, diff, false);
                 assert(ret > 0);
                 if (ret != 1)
                     clues[y*w+x] = clue;   /* oops, put it back again */
@@ -1351,7 +1351,7 @@ static int new_clues(const game_params *params, random_state *rs,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     char *grid, *clues;
     char *desc;
@@ -1416,7 +1416,8 @@ static game_state *new_game(midend *me, const game_params *params,
     game_state *state = snew(game_state);
     int i, j, sz = params->w*params->h;
 
-    state->completed = state->used_solve = FALSE;
+    state->completed = false;
+    state->used_solve = false;
     state->shared = snew(struct shared_state);
 
     state->shared->w = params->w;
@@ -1508,10 +1509,10 @@ static void dsf_update_completion(game_state *state, int ax, int ay, char dir,
     dsf_merge(dsf, ac, bc);
 }
 
-static void check_completion(game_state *state, int mark)
+static void check_completion(game_state *state, bool mark)
 {
     int w = state->shared->w, h = state->shared->h, x, y, i, d;
-    int had_error = FALSE;
+    bool had_error = false;
     int *dsf, *component_state;
     int nsilly, nloop, npath, largest_comp, largest_size, total_pathsize;
     enum { COMP_NONE, COMP_LOOP, COMP_PATH, COMP_SILLY, COMP_EMPTY };
@@ -1522,7 +1523,7 @@ static void check_completion(game_state *state, int mark)
         }
     }
 
-#define ERROR(x,y,e) do { had_error = TRUE; if (mark) state->errors[(y)*w+(x)] |= (e); } while(0)
+#define ERROR(x,y,e) do { had_error = true; if (mark) state->errors[(y)*w+(x)] |= (e); } while(0)
 
     /*
      * Analyse the solution into loops, paths and stranger things.
@@ -1690,7 +1691,7 @@ static void check_completion(game_state *state, int mark)
          * But if not, then we're done!
          */
         if (!had_error)
-            state->completed = TRUE;
+            state->completed = true;
     }
 }
 
@@ -1745,11 +1746,11 @@ static char *solve_game(const game_state *state, const game_state *currstate,
          * solution from there go back to original state. */
         ret = pearl_solve(currstate->shared->w, currstate->shared->h,
                           currstate->shared->clues, solved->lines,
-                          DIFFCOUNT, FALSE);
+                          DIFFCOUNT, false);
         if (ret < 1)
             ret = pearl_solve(state->shared->w, state->shared->h,
                               state->shared->clues, solved->lines,
-                              DIFFCOUNT, FALSE);
+                              DIFFCOUNT, false);
 
     }
 
@@ -1765,9 +1766,9 @@ done:
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1808,7 +1809,7 @@ struct game_ui {
     int clickx, clicky;    /* pixel position of initial click */
 
     int curx, cury;        /* grid position of keyboard cursor */
-    int cursor_active;     /* TRUE iff cursor is shown */
+    bool cursor_active;    /* true iff cursor is shown */
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1818,7 +1819,7 @@ static game_ui *new_ui(const game_state *state)
 
     ui->ndragcoords = -1;
     ui->dragcoords = snewn(sz, int);
-    ui->cursor_active = FALSE;
+    ui->cursor_active = false;
     ui->curx = ui->cury = 0;
 
     return ui;
@@ -1882,7 +1883,7 @@ static int get_gui_style(void)
 
 struct game_drawstate {
     int halfsz;
-    int started;
+    bool started;
 
     int w, h, sz;
     unsigned int *lflags;       /* size w*h */
@@ -1963,7 +1964,7 @@ static void update_ui_drag(const game_state *state, game_ui *ui,
  *
  * Call it in a loop, like this:
  *
- *     int clearing = TRUE;
+ *     bool clearing = true;
  *     for (i = 0; i < ui->ndragcoords - 1; i++) {
  *         int sx, sy, dx, dy, dir, oldstate, newstate;
  *         interpret_ui_drag(state, ui, &clearing, i, &sx, &sy, &dx, &dy,
@@ -1976,7 +1977,7 @@ static void update_ui_drag(const game_state *state, game_ui *ui,
  *     }
  */
 static void interpret_ui_drag(const game_state *state, const game_ui *ui,
-                              int *clearing, int i, int *sx, int *sy,
+                              bool *clearing, int i, int *sx, int *sy,
                               int *dx, int *dy, int *dir,
                               int *oldstate, int *newstate)
 {
@@ -2003,12 +2004,12 @@ static void interpret_ui_drag(const game_state *state, const game_ui *ui,
          * the drag are set rather than cleared.
          */
         *newstate = *dir;
-        *clearing = FALSE;
+        *clearing = false;
     }
 }
 
 static char *mark_in_direction(const game_state *state, int x, int y, int dir,
-			       int primary, char *buf)
+			       bool primary, char *buf)
 {
     int w = state->shared->w /*, h = state->shared->h, sz = state->shared->sz */;
     int x2 = x + DX(dir);
@@ -2037,14 +2038,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     int w = state->shared->w, h = state->shared->h /*, sz = state->shared->sz */;
     int gx = FROMCOORD(x), gy = FROMCOORD(y), i;
-    int release = FALSE;
+    bool release = false;
     char tmpbuf[80];
 
-    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    bool shift = button & MOD_SHFT, control = button & MOD_CTRL;
     button &= ~MOD_MASK;
 
     if (IS_MOUSE_DOWN(button)) {
-	ui->cursor_active = FALSE;
+	ui->cursor_active = false;
 
         if (!INGRID(state, gx, gy)) {
             ui->ndragcoords = -1;
@@ -2063,22 +2064,22 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return UI_UPDATE;
     }
 
-    if (IS_MOUSE_RELEASE(button)) release = TRUE;
+    if (IS_MOUSE_RELEASE(button)) release = true;
 
     if (IS_CURSOR_MOVE(button)) {
 	if (!ui->cursor_active) {
-	    ui->cursor_active = TRUE;
-	} else if (control | shift) {
+	    ui->cursor_active = true;
+	} else if (control || shift) {
 	    char *move;
 	    if (ui->ndragcoords > 0) return NULL;
 	    ui->ndragcoords = -1;
 	    move = mark_in_direction(state, ui->curx, ui->cury,
 				     KEY_DIRECTION(button), control, tmpbuf);
 	    if (control && !shift && *move)
-		move_cursor(button, &ui->curx, &ui->cury, w, h, FALSE);
+		move_cursor(button, &ui->curx, &ui->cury, w, h, false);
 	    return move;
 	} else {
-	    move_cursor(button, &ui->curx, &ui->cury, w, h, FALSE);
+	    move_cursor(button, &ui->curx, &ui->cury, w, h, false);
 	    if (ui->ndragcoords >= 0)
 		update_ui_drag(state, ui, ui->curx, ui->cury);
 	}
@@ -2087,7 +2088,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
     if (IS_CURSOR_SELECT(button)) {
 	if (!ui->cursor_active) {
-	    ui->cursor_active = TRUE;
+	    ui->cursor_active = true;
 	    return UI_UPDATE;
 	} else if (button == CURSOR_SELECT) {
 	    if (ui->ndragcoords == -1) {
@@ -2096,7 +2097,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 		ui->clickx = CENTERED_COORD(ui->curx);
 		ui->clicky = CENTERED_COORD(ui->cury);
 		return UI_UPDATE;
-	    } else release = TRUE;
+	    } else release = true;
 	} else if (button == CURSOR_SELECT2 && ui->ndragcoords >= 0) {
 	    ui->ndragcoords = -1;
 	    return UI_UPDATE;
@@ -2114,7 +2115,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             int buflen = 0, bufsize = 256, tmplen;
             char *buf = NULL;
             const char *sep = "";
-            int clearing = TRUE;
+            bool clearing = true;
 
             for (i = 0; i < ui->ndragcoords - 1; i++) {
                 int sx, sy, dx, dy, dir, oldstate, newstate;
@@ -2197,7 +2198,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move;
         if (c == 'S') {
-            ret->used_solve = TRUE;
+            ret->used_solve = true;
             move++;
         } else if (c == 'L' || c == 'N' || c == 'R' || c == 'F' || c == 'M') {
             /* 'line' or 'noline' or 'replace' or 'flip' or 'mark' */
@@ -2232,7 +2233,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             move += n;
         } else if (strcmp(move, "H") == 0) {
             pearl_solve(ret->shared->w, ret->shared->h,
-                        ret->shared->clues, ret->lines, DIFFCOUNT, TRUE);
+                        ret->shared->clues, ret->lines, DIFFCOUNT, true);
             for (n = 0; n < w*h; n++)
                 ret->marks[n] &= ~ret->lines[n]; /* erase marks too */
             move++;
@@ -2245,7 +2246,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             goto badmove;
     }
 
-    check_completion(ret, TRUE);
+    check_completion(ret, true);
 
     return ret;
 
@@ -2317,7 +2318,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->halfsz = 0;
-    ds->started = FALSE;
+    ds->started = false;
 
     ds->w = state->shared->w;
     ds->h = state->shared->h;
@@ -2453,7 +2454,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         float animtime, float flashtime)
 {
     int w = state->shared->w, h = state->shared->h, sz = state->shared->sz;
-    int x, y, force = 0, flashing = 0;
+    int x, y, flashing = 0;
+    bool force = false;
 
     if (!ds->started) {
         /*
@@ -2477,8 +2479,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
         draw_update(dr, 0, 0, w*TILE_SIZE + 2*BORDER, h*TILE_SIZE + 2*BORDER);
 
-        ds->started = TRUE;
-        force = 1;
+        ds->started = true;
+        force = true;
     }
 
     if (flashtime > 0 &&
@@ -2488,7 +2490,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
     memset(ds->draglines, 0, sz);
     if (ui->ndragcoords > 0) {
-        int i, clearing = TRUE;
+        int i;
+        bool clearing = true;
         for (i = 0; i < ui->ndragcoords - 1; i++) {
             int sx, sy, dx, dy, dir, oldstate, newstate;
             interpret_ui_drag(state, ui, &clearing, i, &sx, &sy, &dx, &dy,
@@ -2544,9 +2547,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2608,15 +2611,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2633,9 +2636,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
@@ -2669,7 +2672,7 @@ static void start_soak(game_params *p, random_state *rs, int nsecs)
     if (nsecs > 0) printf(" for %d seconds", nsecs);
     printf(".\n");
 
-    p->nosolve = TRUE;
+    p->nosolve = true;
 
     grid = snewn(p->w*p->h, char);
     clues = snewn(p->w*p->h, char);
@@ -2677,7 +2680,7 @@ static void start_soak(game_params *p, random_state *rs, int nsecs)
     while (1) {
         n += new_clues(p, rs, clues, grid); /* should be 1, with nosolve */
 
-        ret = pearl_solve(p->w, p->h, clues, grid, DIFF_TRICKY, FALSE);
+        ret = pearl_solve(p->w, p->h, clues, grid, DIFF_TRICKY, false);
         if (ret <= 0) nimpossible++;
         if (ret == 1) nsolved++;
 
@@ -2739,7 +2742,7 @@ int main(int argc, const char *argv[])
         }
 
         decode_params(p, id);
-        err = validate_params(p, 1);
+        err = validate_params(p, true);
         if (err) {
             fprintf(stderr, "%s: %s", argv[0], err);
             goto done;
diff --git a/apps/plugins/puzzles/src/pegs.c b/apps/plugins/puzzles/src/pegs.c
index 823d5c2866..32673d56e7 100644
--- a/apps/plugins/puzzles/src/pegs.c
+++ b/apps/plugins/puzzles/src/pegs.c
@@ -55,7 +55,7 @@ struct game_params {
 
 struct game_state {
     int w, h;
-    int completed;
+    bool completed;
     unsigned char *grid;
 };
 
@@ -77,13 +77,13 @@ static const struct game_params pegs_presets[] = {
     {9, 9, TYPE_RANDOM},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(pegs_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = pegs_presets[i];
@@ -94,7 +94,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -129,7 +129,7 @@ static void decode_params(game_params *params, char const *string)
 	    params->type = i;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
 
@@ -178,7 +178,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (full && (params->w <= 3 || params->h <= 3))
 	return "Width and height must both be greater than three";
@@ -500,7 +500,7 @@ static void pegs_generate(unsigned char *grid, int w, int h, random_state *rs)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h;
     unsigned char *grid;
@@ -677,7 +677,7 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->w = w;
     state->h = h;
-    state->completed = 0;
+    state->completed = false;
     state->grid = snewn(w*h, unsigned char);
     for (i = 0; i < w*h; i++)
 	state->grid[i] = (desc[i] == 'P' ? GRID_PEG :
@@ -712,9 +712,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -737,10 +737,11 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int dragging;		       /* boolean: is a drag in progress? */
+    bool dragging;                     /* is a drag in progress? */
     int sx, sy;			       /* grid coords of drag start cell */
     int dx, dy;			       /* pixel coords of current drag posn */
-    int cur_x, cur_y, cur_visible, cur_jumping;
+    int cur_x, cur_y;
+    bool cur_visible, cur_jumping;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -749,8 +750,9 @@ static game_ui *new_ui(const game_state *state)
     int x, y, v;
 
     ui->sx = ui->sy = ui->dx = ui->dy = 0;
-    ui->dragging = FALSE;
-    ui->cur_visible = ui->cur_jumping = 0;
+    ui->dragging = false;
+    ui->cur_visible = false;
+    ui->cur_jumping = false;
 
     /* make sure we start the cursor somewhere on the grid. */
     for (x = 0; x < state->w; x++) {
@@ -789,7 +791,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      * Cancel a drag, in case the source square has become
      * unoccupied.
      */
-    ui->dragging = FALSE;
+    ui->dragging = false;
 }
 
 #define PREFERRED_TILE_SIZE 33
@@ -804,10 +806,11 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     int tilesize;
     blitter *drag_background;
-    int dragging, dragx, dragy;
+    bool dragging;
+    int dragx, dragy;
     int w, h;
     unsigned char *grid;
-    int started;
+    bool started;
     int bgcolour;
 };
 
@@ -838,12 +841,13 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	ty = FROMCOORD(y);
 	if (tx >= 0 && tx < w && ty >= 0 && ty < h &&
 	    state->grid[ty*w+tx] == GRID_PEG) {
-	    ui->dragging = TRUE;
+	    ui->dragging = true;
 	    ui->sx = tx;
 	    ui->sy = ty;
 	    ui->dx = x;
 	    ui->dy = y;
-            ui->cur_visible = ui->cur_jumping = 0;
+            ui->cur_visible = false;
+            ui->cur_jumping = false;
 	    return UI_UPDATE;
 	}
     } else if (button == LEFT_DRAG && ui->dragging) {
@@ -860,7 +864,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	 * Button released. Identify the target square of the drag,
 	 * see if it represents a valid move, and if so make it.
 	 */
-	ui->dragging = FALSE;	       /* cancel the drag no matter what */
+	ui->dragging = false;	       /* cancel the drag no matter what */
 	tx = FROMCOORD(x);
 	ty = FROMCOORD(y);
 	if (tx < 0 || tx >= w || ty < 0 || ty >= h)
@@ -888,8 +892,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             /* Not jumping; move cursor as usual, making sure we don't
              * leave the gameboard (which may be an irregular shape) */
             int cx = ui->cur_x, cy = ui->cur_y;
-            move_cursor(button, &cx, &cy, w, h, 0);
-            ui->cur_visible = 1;
+            move_cursor(button, &cx, &cy, w, h, false);
+            ui->cur_visible = true;
             if (state->grid[cy*w+cx] == GRID_HOLE ||
                 state->grid[cy*w+cx] == GRID_PEG) {
                 ui->cur_x = cx;
@@ -908,7 +912,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             mx = ui->cur_x+dx; my = ui->cur_y+dy;
             jx = mx+dx; jy = my+dy;
 
-            ui->cur_jumping = 0; /* reset, whatever. */
+            ui->cur_jumping = false; /* reset, whatever. */
             if (jx >= 0 && jy >= 0 && jx < w && jy < h &&
                 state->grid[my*w+mx] == GRID_PEG &&
                 state->grid[jy*w+jx] == GRID_HOLE) {
@@ -922,16 +926,16 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         if (ui->cur_jumping) {
-            ui->cur_jumping = 0;
+            ui->cur_jumping = false;
             return UI_UPDATE;
         }
         if (state->grid[ui->cur_y*w+ui->cur_x] == GRID_PEG) {
             /* cursor is on peg: next arrow-move wil jump. */
-            ui->cur_jumping = 1;
+            ui->cur_jumping = true;
             return UI_UPDATE;
         }
         return NULL;
@@ -983,7 +987,7 @@ static game_state *execute_move(const game_state *state, const char *move)
                 if (ret->grid[i] == GRID_PEG)
                     count++;
             if (count == 1)
-                ret->completed = 1;
+                ret->completed = true;
         }
 
 	return ret;
@@ -1045,14 +1049,14 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     /* We can't allocate the blitter rectangle for the drag background
      * until we know what size to make it. */
     ds->drag_background = NULL;
-    ds->dragging = FALSE;
+    ds->dragging = false;
 
     ds->w = w;
     ds->h = h;
     ds->grid = snewn(w*h, unsigned char);
     memset(ds->grid, 255, w*h);
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->bgcolour = -1;
 
     return ds;
@@ -1069,16 +1073,17 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 static void draw_tile(drawing *dr, game_drawstate *ds,
 		      int x, int y, int v, int bgcolour)
 {
-    int cursor = 0, jumping = 0, bg;
+    bool cursor = false, jumping = false;
+    int bg;
 
     if (bgcolour >= 0) {
 	draw_rect(dr, x, y, TILESIZE, TILESIZE, bgcolour);
     }
     if (v >= GRID_JUMPING) {
-        jumping = 1; v -= GRID_JUMPING;
+        jumping = true; v -= GRID_JUMPING;
     }
     if (v >= GRID_CURSOR) {
-        cursor = 1; v -= GRID_CURSOR;
+        cursor = true; v -= GRID_CURSOR;
     }
 
     if (v == GRID_HOLE) {
@@ -1120,7 +1125,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	assert(ds->drag_background);
         blitter_load(dr, ds->drag_background, ds->dragx, ds->dragy);
         draw_update(dr, ds->dragx, ds->dragy, TILESIZE, TILESIZE);
-	ds->dragging = FALSE;
+	ds->dragging = false;
     }
 
     if (!ds->started) {
@@ -1206,7 +1211,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 			      TILESIZE, COL_BACKGROUND);
 		}
 
-	ds->started = TRUE;
+	ds->started = true;
 
 	draw_update(dr, 0, 0,
 		    TILESIZE * state->w + 2 * BORDER,
@@ -1244,7 +1249,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      * Draw the dragging sprite if any.
      */
     if (ui->dragging) {
-	ds->dragging = TRUE;
+	ds->dragging = true;
 	ds->dragx = ui->dx - TILESIZE/2;
 	ds->dragy = ui->dy - TILESIZE/2;
 	blitter_save(dr, ds->drag_background, ds->dragx, ds->dragy);
@@ -1278,9 +1283,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1303,15 +1308,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    FALSE, solve_game,
-    TRUE, game_can_format_as_text_now, game_text_format,
+    false, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1328,9 +1333,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/printing.c b/apps/plugins/puzzles/src/printing.c
index e921a4d545..98fdd841d3 100644
--- a/apps/plugins/puzzles/src/printing.c
+++ b/apps/plugins/puzzles/src/printing.c
@@ -17,7 +17,7 @@ struct document {
     int npuzzles;
     struct puzzle *puzzles;
     int puzzlesize;
-    int got_solns;
+    bool got_solns;
     float *colwid, *rowht;
     float userscale;
 };
@@ -35,7 +35,7 @@ document *document_new(int pw, int ph, float userscale)
     doc->ph = ph;
     doc->puzzles = NULL;
     doc->puzzlesize = doc->npuzzles = 0;
-    doc->got_solns = FALSE;
+    doc->got_solns = false;
 
     doc->colwid = snewn(pw, float);
     doc->rowht = snewn(ph, float);
@@ -85,7 +85,7 @@ void document_add_puzzle(document *doc, const game *game, game_params *par,
     doc->puzzles[doc->npuzzles].st2 = st2;
     doc->npuzzles++;
     if (st2)
-	doc->got_solns = TRUE;
+	doc->got_solns = true;
 }
 
 static void get_puzzle_size(document *doc, struct puzzle *pz,
diff --git a/apps/plugins/puzzles/src/ps.c b/apps/plugins/puzzles/src/ps.c
index ac021aa80a..94a708648a 100644
--- a/apps/plugins/puzzles/src/ps.c
+++ b/apps/plugins/puzzles/src/ps.c
@@ -13,9 +13,9 @@
 
 struct psdata {
     FILE *fp;
-    int colour;
+    bool colour;
     int ytop;
-    int clipped;
+    bool clipped;
     float hatchthick, hatchspace;
     int gamewidth, gameheight;
     drawing *drawing;
@@ -204,7 +204,7 @@ static void ps_unclip(void *handle)
 
     assert(ps->clipped);
     ps_printf(ps, "grestore\n");
-    ps->clipped = FALSE;
+    ps->clipped = false;
 }
  
 static void ps_clip(void *handle, int x, int y, int w, int h)
@@ -222,7 +222,7 @@ static void ps_clip(void *handle, int x, int y, int w, int h)
     ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
 	      " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
     ps_printf(ps, "clip\n");
-    ps->clipped = TRUE;
+    ps->clipped = true;
 }
 
 static void ps_line_width(void *handle, float width)
@@ -232,7 +232,7 @@ static void ps_line_width(void *handle, float width)
     ps_printf(ps, "%g setlinewidth\n", width);
 }
 
-static void ps_line_dotted(void *handle, int dotted)
+static void ps_line_dotted(void *handle, bool dotted)
 {
     psdata *ps = (psdata *)handle;
 
@@ -353,7 +353,7 @@ static void ps_begin_puzzle(void *handle, float xm, float xc,
 	    "%g dup scale\n"
 	    "0 -%d translate\n", xm, xc, ym, yc, wmm/pw, ph);
     ps->ytop = ph;
-    ps->clipped = FALSE;
+    ps->clipped = false;
     ps->gamewidth = pw;
     ps->gameheight = ph;
     ps->hatchthick = 0.2 * pw / wmm;
@@ -408,14 +408,14 @@ static const struct drawing_api ps_drawing = {
     ps_text_fallback,
 };
 
-psdata *ps_init(FILE *outfile, int colour)
+psdata *ps_init(FILE *outfile, bool colour)
 {
     psdata *ps = snew(psdata);
 
     ps->fp = outfile;
     ps->colour = colour;
     ps->ytop = 0;
-    ps->clipped = FALSE;
+    ps->clipped = false;
     ps->hatchthick = ps->hatchspace = ps->gamewidth = ps->gameheight = 0;
     ps->drawing = drawing_new(&ps_drawing, NULL, ps);
 
diff --git a/apps/plugins/puzzles/src/puzzles.h b/apps/plugins/puzzles/src/puzzles.h
index 8759139404..48d3d83b6e 100644
--- a/apps/plugins/puzzles/src/puzzles.h
+++ b/apps/plugins/puzzles/src/puzzles.h
@@ -8,13 +8,7 @@
 #include <stdio.h>  /* for FILE */
 #include <stdlib.h> /* for size_t */
 #include <limits.h> /* for UINT_MAX */
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
+#include <stdbool.h>
 
 #define PI 3.141592653589793238462643383279502884197169399
 
@@ -163,8 +157,7 @@ struct config_item {
             int selected;
         } choices;
         struct {
-            /* just TRUE or FALSE */
-            int bval;
+            bool bval;
         } boolean;
     } u;
 };
@@ -292,7 +285,7 @@ void print_begin_puzzle(drawing *dr, float xm, float xc,
 void print_end_puzzle(drawing *dr);
 void print_end_page(drawing *dr, int number);
 void print_end_doc(drawing *dr);
-void print_get_colour(drawing *dr, int colour, int printing_in_colour,
+void print_get_colour(drawing *dr, int colour, bool printing_in_colour,
 		      int *hatch, float *r, float *g, float *b);
 int print_mono_colour(drawing *dr, int grey); /* 0==black, 1==white */
 int print_grey_colour(drawing *dr, float grey);
@@ -302,7 +295,7 @@ int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey);
 int print_rgb_hatched_colour(drawing *dr, float r, float g, float b,
 			     int hatch);
 void print_line_width(drawing *dr, int width);
-void print_line_dotted(drawing *dr, int dotted);
+void print_line_dotted(drawing *dr, bool dotted);
 
 /*
  * midend.c
@@ -313,12 +306,12 @@ void midend_free(midend *me);
 const game *midend_which_game(midend *me);
 void midend_set_params(midend *me, game_params *params);
 game_params *midend_get_params(midend *me);
-void midend_size(midend *me, int *x, int *y, int user_size);
+void midend_size(midend *me, int *x, int *y, bool user_size);
 void midend_reset_tilesize(midend *me);
 void midend_new_game(midend *me);
 void midend_restart_game(midend *me);
 void midend_stop_anim(midend *me);
-int midend_process_key(midend *me, int x, int y, int button);
+bool midend_process_key(midend *me, int x, int y, int button);
 key_label *midend_request_keys(midend *me, int *nkeys);
 void midend_force_redraw(midend *me);
 void midend_redraw(midend *me);
@@ -327,19 +320,19 @@ void midend_freeze_timer(midend *me, float tprop);
 void midend_timer(midend *me, float tplus);
 struct preset_menu *midend_get_presets(midend *me, int *id_limit);
 int midend_which_preset(midend *me);
-int midend_wants_statusbar(midend *me);
+bool midend_wants_statusbar(midend *me);
 enum { CFG_SETTINGS, CFG_SEED, CFG_DESC, CFG_FRONTEND_SPECIFIC };
 config_item *midend_get_config(midend *me, int which, char **wintitle);
 const char *midend_set_config(midend *me, int which, config_item *cfg);
 const char *midend_game_id(midend *me, const char *id);
 char *midend_get_game_id(midend *me);
 char *midend_get_random_seed(midend *me);
-int midend_can_format_as_text_now(midend *me);
+bool midend_can_format_as_text_now(midend *me);
 char *midend_text_format(midend *me);
 const char *midend_solve(midend *me);
 int midend_status(midend *me);
-int midend_can_undo(midend *me);
-int midend_can_redo(midend *me);
+bool midend_can_undo(midend *me);
+bool midend_can_redo(midend *me);
 void midend_supersede_game_desc(midend *me, const char *desc,
                                 const char *privdesc);
 char *midend_rewrite_statusbar(midend *me, const char *text);
@@ -347,14 +340,14 @@ void midend_serialise(midend *me,
                       void (*write)(void *ctx, const void *buf, int len),
                       void *wctx);
 const char *midend_deserialise(midend *me,
-                               int (*read)(void *ctx, void *buf, int len),
+                               bool (*read)(void *ctx, void *buf, int len),
                                void *rctx);
 const char *identify_game(char **name,
-                          int (*read)(void *ctx, void *buf, int len),
+                          bool (*read)(void *ctx, void *buf, int len),
                           void *rctx);
 void midend_request_id_changes(midend *me, void (*notify)(void *), void *ctx);
 /* Printing functions supplied by the mid-end */
-const char *midend_print_puzzle(midend *me, document *doc, int with_soln);
+const char *midend_print_puzzle(midend *me, document *doc, bool with_soln);
 int midend_tilesize(midend *me);
 
 /*
@@ -376,7 +369,7 @@ char *dupstr(const char *s);
  */
 void free_cfg(config_item *cfg);
 void free_keys(key_label *keys, int nkeys);
-void obfuscate_bitmap(unsigned char *bmp, int bits, int decode);
+void obfuscate_bitmap(unsigned char *bmp, int bits, bool decode);
 char *fgetline(FILE *fp);
 
 /* allocates output each time. len is always in bytes of binary data.
@@ -403,7 +396,7 @@ void draw_rect_outline(drawing *dr, int x, int y, int w, int h,
 /* Draw a set of rectangle corners (e.g. for a cursor display). */
 void draw_rect_corners(drawing *dr, int cx, int cy, int r, int col);
 
-void move_cursor(int button, int *x, int *y, int maxw, int maxh, int wrap);
+void move_cursor(int button, int *x, int *y, int maxw, int maxh, bool wrap);
 
 /* Used in netslide.c and sixteen.c for cursor movement around edge. */
 int c2pos(int w, int h, int cx, int cy);
@@ -439,16 +432,16 @@ void print_dsf(int *dsf, int size);
 /* Return the canonical element of the equivalence class containing element
  * val.  If 'inverse' is non-NULL, this function will put into it a flag
  * indicating whether the canonical element is inverse to val. */
-int edsf_canonify(int *dsf, int val, int *inverse);
+int edsf_canonify(int *dsf, int val, bool *inverse);
 int dsf_canonify(int *dsf, int val);
 int dsf_size(int *dsf, int val);
 
 /* Allow the caller to specify that two elements should be in the same
- * equivalence class.  If 'inverse' is TRUE, the elements are actually opposite
+ * equivalence class.  If 'inverse' is true, the elements are actually opposite
  * to one another in some sense.  This function will fail an assertion if the
  * caller gives it self-contradictory data, ie if two elements are claimed to
  * be both opposite and non-opposite. */
-void edsf_merge(int *dsf, int v1, int v2, int inverse);
+void edsf_merge(int *dsf, int v1, int v2, bool inverse);
 void dsf_merge(int *dsf, int v1, int v2);
 void dsf_init(int *dsf, int len);
 
@@ -542,7 +535,7 @@ void document_print(document *doc, drawing *dr);
 /*
  * ps.c
  */
-psdata *ps_init(FILE *outfile, int colour);
+psdata *ps_init(FILE *outfile, bool colour);
 void ps_free(psdata *ps);
 drawing *ps_drawing_api(psdata *ps);
 
@@ -584,22 +577,22 @@ void findloop_free_state(struct findloopstate *);
 typedef int (*neighbour_fn_t)(int vertex, void *ctx);
 /*
  * Actual function to find loops. 'ctx' will be passed unchanged to
- * the 'neighbour' function to query graph edges. Returns FALSE if no
- * loop was found, or TRUE if one was.
+ * the 'neighbour' function to query graph edges. Returns false if no
+ * loop was found, or true if one was.
  */
-int findloop_run(struct findloopstate *state, int nvertices,
-                 neighbour_fn_t neighbour, void *ctx);
+bool findloop_run(struct findloopstate *state, int nvertices,
+                  neighbour_fn_t neighbour, void *ctx);
 /*
  * Query whether an edge is part of a loop, in the output of
  * find_loops.
  *
  * Due to the internal storage format, if you pass u,v which are not
- * connected at all, the output will be TRUE. (The algorithm actually
+ * connected at all, the output will be true. (The algorithm actually
  * stores an exhaustive list of *non*-loop edges, because there are
  * fewer of those, so really it's querying whether the edge is on that
  * list.)
  */
-int findloop_is_loop_edge(struct findloopstate *state, int u, int v);
+bool findloop_is_loop_edge(struct findloopstate *state, int u, int v);
 
 /*
  * Data structure containing the function calls and data specific
@@ -612,28 +605,28 @@ struct game {
     const char *name;
     const char *winhelp_topic, *htmlhelp_topic;
     game_params *(*default_params)(void);
-    int (*fetch_preset)(int i, char **name, game_params **params);
+    bool (*fetch_preset)(int i, char **name, game_params **params);
     struct preset_menu *(*preset_menu)(void);
     void (*decode_params)(game_params *, char const *string);
-    char *(*encode_params)(const game_params *, int full);
+    char *(*encode_params)(const game_params *, bool full);
     void (*free_params)(game_params *params);
     game_params *(*dup_params)(const game_params *params);
-    int can_configure;
+    bool can_configure;
     config_item *(*configure)(const game_params *params);
     game_params *(*custom_params)(const config_item *cfg);
-    const char *(*validate_params)(const game_params *params, int full);
+    const char *(*validate_params)(const game_params *params, bool full);
     char *(*new_desc)(const game_params *params, random_state *rs,
-		      char **aux, int interactive);
+		      char **aux, bool interactive);
     const char *(*validate_desc)(const game_params *params, const char *desc);
     game_state *(*new_game)(midend *me, const game_params *params,
                             const char *desc);
     game_state *(*dup_game)(const game_state *state);
     void (*free_game)(game_state *state);
-    int can_solve;
+    bool can_solve;
     char *(*solve)(const game_state *orig, const game_state *curr,
                    const char *aux, const char **error);
-    int can_format_as_text_ever;
-    int (*can_format_as_text_now)(const game_params *params);
+    bool can_format_as_text_ever;
+    bool (*can_format_as_text_now)(const game_params *params);
     char *(*text_format)(const game_state *state);
     game_ui *(*new_ui)(const game_state *state);
     void (*free_ui)(game_ui *ui);
@@ -661,12 +654,12 @@ struct game {
     float (*flash_length)(const game_state *oldstate,
                           const game_state *newstate, int dir, game_ui *ui);
     int (*status)(const game_state *state);
-    int can_print, can_print_in_colour;
+    bool can_print, can_print_in_colour;
     void (*print_size)(const game_params *params, float *x, float *y);
     void (*print)(drawing *dr, const game_state *state, int tilesize);
-    int wants_statusbar;
-    int is_timed;
-    int (*timing_state)(const game_state *state, game_ui *ui);
+    bool wants_statusbar;
+    bool is_timed;
+    bool (*timing_state)(const game_state *state, game_ui *ui);
     int flags;
 };
 
@@ -703,7 +696,7 @@ struct drawing_api {
     void (*end_page)(void *handle, int number);
     void (*end_doc)(void *handle);
     void (*line_width)(void *handle, float width);
-    void (*line_dotted)(void *handle, int dotted);
+    void (*line_dotted)(void *handle, bool dotted);
     char *(*text_fallback)(void *handle, const char *const *strings,
 			   int nstrings);
     void (*draw_thick_line)(void *handle, float thickness,
diff --git a/apps/plugins/puzzles/src/range.c b/apps/plugins/puzzles/src/range.c
index 03bdf6d5fd..64bd17da56 100644
--- a/apps/plugins/puzzles/src/range.c
+++ b/apps/plugins/puzzles/src/range.c
@@ -94,8 +94,7 @@ struct game_params {
 
 struct game_state {
     struct game_params params;
-    unsigned int has_cheated: 1;
-    unsigned int was_solved: 1;
+    bool has_cheated, was_solved;
     puzzle_size *grid;
 };
 
@@ -123,11 +122,11 @@ static game_params *dup_params(const game_params *params)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
 
-    if (i < 0 || i >= lenof(range_presets)) return FALSE;
+    if (i < 0 || i >= lenof(range_presets)) return false;
 
     ret = default_params();
     *ret = range_presets[i]; /* struct copy */
@@ -135,7 +134,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = nfmtstr(40, "%d x %d", range_presets[i].w, range_presets[i].h);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -155,7 +154,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
     sprintf(str, "%dx%d", params->w, params->h);
@@ -388,7 +387,7 @@ static int runlength(puzzle_size r, puzzle_size c,
 {
     int const w = state->params.w, h = state->params.h;
     int sz = 0;
-    while (TRUE) {
+    while (true) {
         int cell = idx(r, c, w);
         if (out_of_bounds(r, c, w, h)) break;
         if (state->grid[cell] > 0) {
@@ -687,7 +686,7 @@ static int newdesc_strip_clues(game_state *state, int *shuffle_1toN);
 static char *newdesc_encode_game_description(int n, puzzle_size *grid);
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int const w = params->w, h = params->h, n = w * h;
 
@@ -702,11 +701,11 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     state.params = *params;
     state.grid = grid;
 
-    interactive = 0; /* I don't need it, I shouldn't use it*/
+    interactive = false; /* I don't need it, I shouldn't use it*/
 
     for (i = 0; i < n; ++i) shuffle_1toN[i] = i;
 
-    while (TRUE) {
+    while (true) {
         shuffle(shuffle_1toN, n, sizeof (int), rs);
         newdesc_choose_black_squares(&state, shuffle_1toN);
 
@@ -907,7 +906,7 @@ static int dfs_count_white(game_state *state, int cell)
     return k;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     int const w = params->w, h = params->h;
     if (w < 1) return "Error: width is less than 1";
@@ -1139,8 +1138,8 @@ static game_state *new_game(midend *me, const game_params *params,
         }
     }
     assert(i == n);
-    state->has_cheated = FALSE;
-    state->was_solved = FALSE;
+    state->has_cheated = false;
+    state->was_solved = false;
 
     return state;
 }
@@ -1149,9 +1148,9 @@ static game_state *new_game(midend *me, const game_params *params,
  * User interface: ascii
  */
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1221,14 +1220,14 @@ static char *game_text_format(const game_state *state)
 
 struct game_ui {
     puzzle_size r, c; /* cursor position */
-    unsigned int cursor_show: 1;
+    bool cursor_show;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     struct game_ui *ui = snew(game_ui);
     ui->r = ui->c = 0;
-    ui->cursor_show = FALSE;
+    ui->cursor_show = false;
     return ui;
 }
 
@@ -1248,15 +1247,13 @@ static void decode_ui(game_ui *ui, const char *encoding)
 
 typedef struct drawcell {
     puzzle_size value;
-    unsigned int error: 1;
-    unsigned int cursor: 1;
-    unsigned int flash: 1;
+    bool error, cursor, flash;
 } drawcell;
 
 struct game_drawstate {
     int tilesize;
     drawcell *grid;
-    unsigned int started: 1;
+    bool started;
 };
 
 #define TILESIZE (ds->tilesize)
@@ -1271,8 +1268,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     enum {none, forwards, backwards, hint};
     int const w = state->params.w, h = state->params.h;
     int r = ui->r, c = ui->c, action = none, cell;
-    int shift = button & MOD_SHFT;
-    button &= ~shift;
+    bool shift = button & MOD_SHFT;
+    button &= ~MOD_SHFT;
 
     if (IS_CURSOR_SELECT(button) && !ui->cursor_show) return NULL;
 
@@ -1282,7 +1279,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         if (out_of_bounds(r, c, w, h)) return NULL;
         ui->r = r;
         ui->c = c;
-        ui->cursor_show = FALSE;
+        ui->cursor_show = false;
     }
 
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
@@ -1331,7 +1328,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             for (i = 0; i < 4 && cursors[i] != button; ++i);
             assert (i < 4);
             if (shift) {
-                int pre_r = r, pre_c = c, do_pre, do_post;
+                int pre_r = r, pre_c = c;
+                bool do_pre, do_post;
                 cell = state->grid[idx(r, c, state->params.w)];
                 do_pre = (cell == EMPTY);
 
@@ -1363,7 +1361,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 ui->r += dr[i];
                 ui->c += dc[i];
             }
-        } else ui->cursor_show = TRUE;
+        } else ui->cursor_show = true;
         return UI_UPDATE;
     }
 
@@ -1407,7 +1405,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     return NULL;
 }
 
-static int find_errors(const game_state *state, int *report)
+static bool find_errors(const game_state *state, bool *report)
 {
     int const w = state->params.w, h = state->params.h, n = w * h;
     int *dsf;
@@ -1430,7 +1428,7 @@ static int find_errors(const game_state *state, int *report)
 			if (out_of_bounds(rr, cc, w, h)) continue;
 			if (state->grid[idx(rr, cc, w)] != BLACK) continue;
 			if (!report) goto found_error;
-			report[i] = TRUE;
+			report[i] = true;
 			break;
 		    }
 		}
@@ -1445,14 +1443,14 @@ static int find_errors(const game_state *state, int *report)
 		    }
 		    if (!report) {
 			if (runs != state->grid[i]) goto found_error;
-		    } else if (runs < state->grid[i]) report[i] = TRUE;
+		    } else if (runs < state->grid[i]) report[i] = true;
 		    else {
 			for (runs = 1, j = 0; j < 4; ++j) {
 			    int const rr = r + dr[j], cc = c + dc[j];
 			    runs += runlength(rr, cc, dr[j], dc[j], state,
 					      ~(MASK(BLACK) | MASK(EMPTY)));
 			}
-			if (runs > state->grid[i]) report[i] = TRUE;
+			if (runs > state->grid[i]) report[i] = true;
 		    }
 		}
 
@@ -1503,16 +1501,16 @@ static int find_errors(const game_state *state, int *report)
 
         for (i = 0; i < n; ++i)
             if (state->grid[i] != BLACK && dsf_canonify(dsf, i) != canonical)
-                report[i] = TRUE;
+                report[i] = true;
     }
     sfree(dsf);
 
     free_game(dup);
-    return FALSE; /* if report != NULL, this is ignored */
+    return false; /* if report != NULL, this is ignored */
 
 found_error:
     free_game(dup);
-    return TRUE;
+    return true;
 }
 
 static game_state *execute_move(const game_state *state, const char *move)
@@ -1527,7 +1525,7 @@ static game_state *execute_move(const game_state *state, const char *move)
 
     if (*move == 'S') {
         ++move;
-        ret->has_cheated = ret->was_solved = TRUE;
+        ret->has_cheated = ret->was_solved = true;
     }
 
     for (; *move; move += nchars) {
@@ -1543,7 +1541,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         ret->grid[idx(r, c, ret->params.w)] = value;
     }
 
-    if (ret->was_solved == FALSE)
+    if (!ret->was_solved)
         ret->was_solved = !find_errors(ret, NULL);
 
     return ret;
@@ -1626,7 +1624,8 @@ static float *game_colours(frontend *fe, int *ncolours)
     return ret;
 }
 
-static drawcell makecell(puzzle_size value, int error, int cursor, int flash)
+static drawcell makecell(puzzle_size value,
+                         bool error, bool cursor, bool flash)
 {
     drawcell ret;
     setmember(ret, value);
@@ -1643,11 +1642,11 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->tilesize = 0;
-    ds->started = FALSE;
+    ds->started = false;
 
     ds->grid = snewn(n, drawcell);
     for (i = 0; i < n; ++i)
-        ds->grid[i] = makecell(w + h, FALSE, FALSE, FALSE);
+        ds->grid[i] = makecell(w + h, false, false, false);
 
     return ds;
 }
@@ -1660,7 +1659,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 
 #define cmpmember(a, b, field) ((a) . field == (b) . field)
 
-static int cell_eq(drawcell a, drawcell b)
+static bool cell_eq(drawcell a, drawcell b)
 {
     return
         cmpmember(a, b, value) &&
@@ -1683,23 +1682,23 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
     int r, c, i;
 
-    int *errors = snewn(n, int);
-    memset(errors, FALSE, n * sizeof (int));
+    bool *errors = snewn(n, bool);
+    memset(errors, 0, n * sizeof (bool));
     find_errors(state, errors);
 
     assert (oldstate == NULL); /* only happens if animating moves */
 
     if (!ds->started) {
-        ds->started = TRUE;
+        ds->started = true;
         draw_rect(dr, 0, 0, wpx, hpx, COL_BACKGROUND);
         draw_update(dr, 0, 0, wpx, hpx);
     }
 
     for (i = r = 0; r < h; ++r) {
         for (c = 0; c < w; ++c, ++i) {
-            drawcell cell = makecell(state->grid[i], errors[i], FALSE, flash);
+            drawcell cell = makecell(state->grid[i], errors[i], false, flash);
             if (r == ui->r && c == ui->c && ui->cursor_show)
-                cell.cursor = TRUE;
+                cell.cursor = true;
             if (!cell_eq(cell, ds->grid[i])) {
                 draw_cell(dr, ds, r, c, cell);
                 ds->grid[i] = cell;
@@ -1745,10 +1744,10 @@ static void draw_cell(drawing *draw, game_drawstate *ds, int r, int c,
     draw_update(draw, x, y, ts + 1, ts + 1);
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     puts("warning: game_timing_state was called (this shouldn't happen)");
-    return FALSE; /* the (non-existing) timer should not be running */
+    return false; /* the (non-existing) timer should not be running */
 }
 
 /* ----------------------------------------------------------------------
@@ -1780,7 +1779,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
     for (i = r = 0; r < h; ++r)
         for (c = 0; c < w; ++c, ++i)
             draw_cell(dr, ds, r, c,
-                      makecell(state->grid[i], FALSE, FALSE, FALSE));
+                      makecell(state->grid[i], false, false, false));
 
     print_line_width(dr, 3 * tilesize / 40);
     draw_rect_outline(dr, BORDER, BORDER, w*TILESIZE, h*TILESIZE, COL_GRID);
@@ -1800,15 +1799,15 @@ struct game const thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1825,8 +1824,8 @@ struct game const thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE, /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false, /* wants_statusbar */
+    false, game_timing_state,
     0, /* flags */
 };
diff --git a/apps/plugins/puzzles/src/rect.c b/apps/plugins/puzzles/src/rect.c
index 3d84f046b5..2cb01bfa5d 100644
--- a/apps/plugins/puzzles/src/rect.c
+++ b/apps/plugins/puzzles/src/rect.c
@@ -44,7 +44,7 @@ enum {
 struct game_params {
     int w, h;
     float expandfactor;
-    int unique;
+    bool unique;
 };
 
 #define INDEX(state, x, y)    (((y) * (state)->w) + (x))
@@ -80,7 +80,7 @@ struct game_state {
     int *grid;			       /* contains the numbers */
     unsigned char *vedge;	       /* (w+1) x h */
     unsigned char *hedge;	       /* w x (h+1) */
-    int completed, cheated;
+    bool completed, cheated;
     unsigned char *correct;
 };
 
@@ -90,12 +90,12 @@ static game_params *default_params(void)
 
     ret->w = ret->h = 7;
     ret->expandfactor = 0.0F;
-    ret->unique = TRUE;
+    ret->unique = true;
 
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int w, h;
@@ -111,7 +111,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
       case 5: w = 17, h = 17; break;
       case 6: w = 19, h = 19; break;
 #endif
-      default: return FALSE;
+      default: return false;
     }
 
     sprintf(buf, "%dx%d", w, h);
@@ -120,8 +120,8 @@ static int game_fetch_preset(int i, char **name, game_params **params)
     ret->w = w;
     ret->h = h;
     ret->expandfactor = 0.0F;
-    ret->unique = TRUE;
-    return TRUE;
+    ret->unique = true;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -153,11 +153,11 @@ static void decode_params(game_params *ret, char const *string)
     }
     if (*string == 'a') {
 	string++;
-	ret->unique = FALSE;
+	ret->unique = false;
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -217,7 +217,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w <= 0 || params->h <= 0)
 	return "Width and height must both be greater than zero";
@@ -496,7 +496,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
      * Now run the actual deduction loop.
      */
     while (1) {
-        int done_something = FALSE;
+        bool done_something = false;
 
 #ifdef SOLVER_DIAGNOSTICS
         printf("starting deduction loop\n");
@@ -609,7 +609,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
 
             for (j = 0; j < rectpositions[i].n; j++) {
                 int xx, yy, k;
-                int del = FALSE;
+                bool del = false;
 
                 for (k = 0; k < nrects; k++)
                     workspace[k] = 0;
@@ -635,7 +635,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
                                    rectpositions[i].rects[j].h,
                                    x, y);
 #endif
-                            del = TRUE;
+                            del = true;
                         }
 
                         if (rectbyplace[y * w + x] != -1) {
@@ -668,7 +668,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
                                    rectpositions[i].rects[j].h,
                                    k);
 #endif
-                            del = TRUE;
+                            del = true;
                             break;
                         }
 
@@ -689,7 +689,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
                                rectpositions[i].rects[j].w,
                                rectpositions[i].rects[j].h);
 #endif
-                        del = TRUE;
+                        del = true;
                     }
                 }
 
@@ -698,7 +698,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
 
                     j--;               /* don't skip over next placement */
 
-                    done_something = TRUE;
+                    done_something = true;
                 }
             }
         }
@@ -742,7 +742,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
                         remove_rect_placement(w, h, rectpositions, overlaps,
                                               index, j);
                         j--;           /* don't skip over next placement */
-                        done_something = TRUE;
+                        done_something = true;
                     }
                 }
             }
@@ -850,7 +850,7 @@ static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
                         remove_number_placement(w, h, &numbers[k],
                                                 m, rectbyplace);
                         m--;           /* don't skip the next one */
-                        done_something = TRUE;
+                        done_something = true;
                     }
                 }
             }
@@ -1144,7 +1144,7 @@ static void display_grid(game_params *params, int *grid, int *numbers, int all)
 #endif
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1270,7 +1270,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
                     int dirs[4], ndirs;
 
 #ifdef GENERATION_DIAGNOSTICS
-                    display_grid(params2, grid, NULL, FALSE);
+                    display_grid(params2, grid, NULL, false);
                     printf("singleton at %d,%d\n", x, y);
 #endif
 
@@ -1448,7 +1448,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
 
 #ifdef GENERATION_DIAGNOSTICS
             printf("before expansion:\n");
-            display_grid(params2, grid, NULL, TRUE);
+            display_grid(params2, grid, NULL, true);
 #endif
 
             /*
@@ -1576,7 +1576,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
 
 #ifdef GENERATION_DIAGNOSTICS
             printf("after expansion:\n");
-            display_grid(params3, grid2, NULL, TRUE);
+            display_grid(params3, grid2, NULL, true);
 #endif
             /*
              * Transpose.
@@ -1607,7 +1607,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
 
 #ifdef GENERATION_DIAGNOSTICS
             printf("after transposition:\n");
-            display_grid(params2, grid, NULL, TRUE);
+            display_grid(params2, grid, NULL, true);
 #endif
         }
 
@@ -1734,7 +1734,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
     }
 
 #ifdef GENERATION_DIAGNOSTICS
-    display_grid(params, grid, numbers, FALSE);
+    display_grid(params, grid, numbers, false);
 #endif
 
     desc = snewn(11 * params->w * params->h, char);
@@ -1817,7 +1817,8 @@ static unsigned char *get_correct(game_state *state)
 	    if (index(state,ret,x,y) == 0xFF) {
 		int rw, rh;
 		int xx, yy;
-		int num, area, valid;
+		int num, area;
+                bool valid;
 
 		/*
 		 * Find a rectangle starting at this point.
@@ -1834,14 +1835,14 @@ static unsigned char *get_correct(game_state *state)
 		 * should be if it's there at all. Find out if we
 		 * really have a valid rectangle.
 		 */
-		valid = TRUE;
+		valid = true;
 		/* Check the horizontal edges. */
 		for (xx = x; xx < x+rw; xx++) {
 		    for (yy = y; yy <= y+rh; yy++) {
 			int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
 			int ec = (yy == y || yy == y+rh);
 			if (e != ec)
-			    valid = FALSE;
+			    valid = false;
 		    }
 		}
 		/* Check the vertical edges. */
@@ -1850,7 +1851,7 @@ static unsigned char *get_correct(game_state *state)
 			int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
 			int ec = (xx == x || xx == x+rw);
 			if (e != ec)
-			    valid = FALSE;
+			    valid = false;
 		    }
 		}
 
@@ -1875,13 +1876,13 @@ static unsigned char *get_correct(game_state *state)
 			area++;
 			if (grid(state,xx,yy)) {
 			    if (num > 0)
-				valid = FALSE;   /* two numbers */
+				valid = false;   /* two numbers */
 			    num = grid(state,xx,yy);
 			}
 		    }
 		}
 		if (num != area)
-		    valid = FALSE;
+		    valid = false;
 
 		/*
 		 * Now fill in the whole rectangle based on the
@@ -1911,7 +1912,8 @@ static game_state *new_game(midend *me, const game_params *params,
     state->grid = snewn(area, int);
     state->vedge = snewn(area, unsigned char);
     state->hedge = snewn(area, unsigned char);
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     i = 0;
     while (*desc) {
@@ -2045,9 +2047,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -2164,12 +2166,12 @@ struct game_ui {
      * the pointer _returns_ to its starting point the action is
      * treated as a small drag rather than a click.
      */
-    int dragged;
+    bool dragged;
     /* This flag is set if we're doing an erase operation (i.e.
      * removing edges in the centre of the rectangle without altering
      * the outlines).
      */
-    int erasing;
+    bool erasing;
     /*
      * These are the co-ordinates of the top-left and bottom-right squares
      * in the drag box, respectively, or -1 otherwise.
@@ -2182,7 +2184,8 @@ struct game_ui {
      * These are the coordinates of a cursor, whether it's visible, and
      * whether it was used to start a drag.
      */
-    int cur_x, cur_y, cur_visible, cur_dragging;
+    int cur_x, cur_y;
+    bool cur_visible, cur_dragging;
 };
 
 static void reset_ui(game_ui *ui)
@@ -2195,15 +2198,17 @@ static void reset_ui(game_ui *ui)
     ui->y1 = -1;
     ui->x2 = -1;
     ui->y2 = -1;
-    ui->dragged = FALSE;
+    ui->dragged = false;
 }
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
     reset_ui(ui);
-    ui->erasing = FALSE;
-    ui->cur_x = ui->cur_y = ui->cur_visible = ui->cur_dragging = 0;
+    ui->erasing = false;
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
+    ui->cur_dragging = false;
     return ui;
 }
 
@@ -2306,15 +2311,15 @@ static void coord_round(float x, float y, int *xr, int *yr)
 }
 
 /*
- * Returns TRUE if it has made any change to the grid.
+ * Returns true if it has made any change to the grid.
  */
-static int grid_draw_rect(const game_state *state,
+static bool grid_draw_rect(const game_state *state,
 			  unsigned char *hedge, unsigned char *vedge,
-			  int c, int really, int outline,
+			  int c, bool really, bool outline,
 			  int x1, int y1, int x2, int y2)
 {
     int x, y;
-    int changed = FALSE;
+    bool changed = false;
 
     /*
      * Draw horizontal edges of rectangles.
@@ -2353,9 +2358,9 @@ static int grid_draw_rect(const game_state *state,
     return changed;
 }
 
-static int ui_draw_rect(const game_state *state, const game_ui *ui,
+static bool ui_draw_rect(const game_state *state, const game_ui *ui,
 			unsigned char *hedge, unsigned char *vedge, int c,
-			int really, int outline)
+			bool really, bool outline)
 {
     return grid_draw_rect(state, hedge, vedge, c, really, outline,
 			  ui->x1, ui->y1, ui->x2, ui->y2);
@@ -2367,7 +2372,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h, tilesize;
     unsigned long *visible;
 };
@@ -2377,7 +2382,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
                             int x, int y, int button)
 {
     int xc, yc;
-    int startdrag = FALSE, enddrag = FALSE, active = FALSE, erasing = FALSE;
+    bool startdrag = false, enddrag = false, active = false, erasing = false;
     char buf[80], *ret;
 
     button &= ~MOD_MASK;
@@ -2387,23 +2392,23 @@ static char *interpret_move(const game_state *from, game_ui *ui,
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         if (ui->drag_start_x >= 0 && ui->cur_dragging)
             reset_ui(ui); /* cancel keyboard dragging */
-        startdrag = TRUE;
-        ui->cur_visible = ui->cur_dragging = FALSE;
-        active = TRUE;
+        startdrag = true;
+        ui->cur_visible = ui->cur_dragging = false;
+        active = true;
         erasing = (button == RIGHT_BUTTON);
     } else if (button == LEFT_RELEASE || button == RIGHT_RELEASE) {
         /* We assert we should have had a LEFT_BUTTON first. */
         if (ui->cur_visible) {
-            ui->cur_visible = FALSE;
-            active = TRUE;
+            ui->cur_visible = false;
+            active = true;
         }
         assert(!ui->cur_dragging);
-        enddrag = TRUE;
+        enddrag = true;
         erasing = (button == RIGHT_RELEASE);
     } else if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, 0);
-        ui->cur_visible = TRUE;
-        active = TRUE;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, from->w, from->h, false);
+        ui->cur_visible = true;
+        active = true;
         if (!ui->cur_dragging) return UI_UPDATE;
         coord_round((float)ui->cur_x + 0.5F, (float)ui->cur_y + 0.5F, &xc, &yc);
     } else if (IS_CURSOR_SELECT(button)) {
@@ -2416,27 +2421,27 @@ static char *interpret_move(const game_state *from, game_ui *ui,
         }
         if (!ui->cur_visible) {
             assert(!ui->cur_dragging);
-            ui->cur_visible = TRUE;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         coord_round((float)ui->cur_x + 0.5F, (float)ui->cur_y + 0.5F, &xc, &yc);
         erasing = (button == CURSOR_SELECT2);
         if (ui->cur_dragging) {
-            ui->cur_dragging = FALSE;
-            enddrag = TRUE;
-            active = TRUE;
+            ui->cur_dragging = false;
+            enddrag = true;
+            active = true;
         } else {
-            ui->cur_dragging = TRUE;
-            startdrag = TRUE;
-            active = TRUE;
+            ui->cur_dragging = true;
+            startdrag = true;
+            active = true;
         }
     } else if (button == '\b' || button == 27) {
         if (!ui->cur_dragging) {
-            ui->cur_visible = FALSE;
+            ui->cur_visible = false;
         } else {
             assert(ui->cur_visible);
             reset_ui(ui); /* cancel keyboard dragging */
-            ui->cur_dragging = FALSE;
+            ui->cur_dragging = false;
         }
         return UI_UPDATE;
     } else if (button != LEFT_DRAG && button != RIGHT_DRAG) {
@@ -2451,9 +2456,9 @@ static char *interpret_move(const game_state *from, game_ui *ui,
         ui->drag_start_y = yc;
         ui->drag_end_x = -1;
         ui->drag_end_y = -1;
-        ui->dragged = FALSE;
+        ui->dragged = false;
         ui->erasing = erasing;
-        active = TRUE;
+        active = true;
     }
 
     if (ui->drag_start_x >= 0 &&
@@ -2461,10 +2466,10 @@ static char *interpret_move(const game_state *from, game_ui *ui,
 	int t;
 
 	if (ui->drag_end_x != -1 && ui->drag_end_y != -1)
-	    ui->dragged = TRUE;
+	    ui->dragged = true;
         ui->drag_end_x = xc;
         ui->drag_end_y = yc;
-        active = TRUE;
+        active = true;
 
 	if (xc >= 0 && xc <= 2*from->w &&
 	    yc >= 0 && yc <= 2*from->h) {
@@ -2497,7 +2502,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
 
 	    if (ui->dragged) {
 		if (ui_draw_rect(from, ui, from->hedge,
-				 from->vedge, 1, FALSE, !ui->erasing)) {
+				 from->vedge, 1, false, !ui->erasing)) {
 		    sprintf(buf, "%c%d,%d,%d,%d",
 			    (int)(ui->erasing ? 'E' : 'R'),
 			    ui->x1, ui->y1, ui->x2 - ui->x1, ui->y2 - ui->y1);
@@ -2516,7 +2521,7 @@ static char *interpret_move(const game_state *from, game_ui *ui,
 	}
 
         reset_ui(ui);
-	active = TRUE;
+	active = true;
     }
 
     if (ret)
@@ -2537,7 +2542,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	int x, y;
 
 	ret = dup_game(from);
-	ret->cheated = TRUE;
+	ret->cheated = true;
 
 	for (y = 0; y < ret->h; y++)
 	    for (x = 1; x < ret->w; x++) {
@@ -2573,7 +2578,7 @@ static game_state *execute_move(const game_state *from, const char *move)
     ret = dup_game(from);
 
     if (mode == 'R' || mode == 'E') {
-	grid_draw_rect(ret, ret->hedge, ret->vedge, 1, TRUE,
+	grid_draw_rect(ret, ret->hedge, ret->vedge, 1, true,
                        mode == 'R', x1, y1, x2, y2);
     } else if (mode == 'H') {
 	hedge(ret,x1,y1) = !hedge(ret,x1,y1);
@@ -2589,16 +2594,17 @@ static game_state *execute_move(const game_state *from, const char *move)
      * if the game has been completed.
      */
     if (!ret->completed) {
-	int x, y, ok;
+	int x, y;
+        bool ok;
 
-	ok = TRUE;
+	ok = true;
 	for (x = 0; x < ret->w; x++)
 	    for (y = 0; y < ret->h; y++)
 		if (!index(ret, ret->correct, x, y))
-		    ok = FALSE;
+		    ok = false;
 
 	if (ok)
-	    ret->completed = TRUE;
+	    ret->completed = true;
     }
 
     return ret;
@@ -2674,7 +2680,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->visible = snewn(ds->w * ds->h, unsigned long);
@@ -2761,7 +2767,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         vedge = snewn(state->w*state->h, unsigned char);
         memcpy(hedge, state->hedge, state->w*state->h);
         memcpy(vedge, state->vedge, state->w*state->h);
-        ui_draw_rect(state, ui, hedge, vedge, ui->erasing ? 3 : 2, TRUE, TRUE);
+        ui_draw_rect(state, ui, hedge, vedge, ui->erasing ? 3 : 2, true, true);
     } else {
         hedge = state->hedge;
         vedge = state->vedge;
@@ -2795,7 +2801,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 		  state->h * TILE_SIZE + 2*BORDER + 1, COL_BACKGROUND);
 	draw_rect(dr, COORD(0)-1, COORD(0)-1,
 		  ds->w*TILE_SIZE+3, ds->h*TILE_SIZE+3, COL_LINE);
-	ds->started = TRUE;
+	ds->started = true;
 	draw_update(dr, 0, 0,
 		    state->w * TILE_SIZE + 2*BORDER + 1,
 		    state->h * TILE_SIZE + 2*BORDER + 1);
@@ -2882,9 +2888,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2964,15 +2970,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2989,9 +2995,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/samegame.c b/apps/plugins/puzzles/src/samegame.c
index 4dfc302000..272c7b457d 100644
--- a/apps/plugins/puzzles/src/samegame.c
+++ b/apps/plugins/puzzles/src/samegame.c
@@ -97,7 +97,7 @@ enum {
 /* scoresub is 1 or 2 (for (n-1)^2 or (n-2)^2) */
 struct game_params {
     int w, h, ncols, scoresub;
-    int soluble;		       /* choose generation algorithm */
+    bool soluble;                    /* choose generation algorithm */
 };
 
 /* These flags must be unique across all uses; in the game_state,
@@ -132,7 +132,7 @@ struct game_state {
     int n;
     int *tiles; /* colour only */
     int score;
-    int complete, impossible;
+    bool complete, impossible;
 };
 
 static game_params *default_params(void)
@@ -142,29 +142,29 @@ static game_params *default_params(void)
     ret->h = 5;
     ret->ncols = 3;
     ret->scoresub = 2;
-    ret->soluble = TRUE;
+    ret->soluble = true;
     return ret;
 }
 
 static const struct game_params samegame_presets[] = {
-    { 5, 5, 3, 2, TRUE },
-    { 10, 5, 3, 2, TRUE },
+    { 5, 5, 3, 2, true },
+    { 10, 5, 3, 2, true },
 #ifdef SLOW_SYSTEM
-    { 10, 10, 3, 2, TRUE },
+    { 10, 10, 3, 2, true },
 #else
-    { 15, 10, 3, 2, TRUE },
+    { 15, 10, 3, 2, true },
 #endif
-    { 15, 10, 4, 2, TRUE },
-    { 20, 15, 4, 2, TRUE }
+    { 15, 10, 4, 2, true },
+    { 20, 15, 4, 2, true }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(samegame_presets))
-	return FALSE;
+	return false;
 
     ret = snew(game_params);
     *ret = samegame_presets[i];
@@ -173,7 +173,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -217,11 +217,11 @@ static void decode_params(game_params *params, char const *string)
     }
     if (*p == 'r') {
 	p++;
-	params->soluble = FALSE;
+	params->soluble = false;
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -281,7 +281,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1 || params->h < 1)
 	return "Width and height must both be positive";
@@ -317,7 +317,8 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
     int wh = w*h, tc = nc+1;
     int i, j, k, c, x, y, pos, n;
     int *list, *grid2;
-    int ok, failures = 0;
+    bool ok;
+    int failures = 0;
 
     /*
      * We'll use `list' to track the possible places to put our
@@ -662,7 +663,7 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
                  */
                 {
                     int x1, x2, y1, y2;
-                    int ok = TRUE;
+                    bool ok = true;
                     int fillstart = -1, ntc = 0;
 
 #ifdef GENERATION_DIAGNOSTICS
@@ -691,7 +692,7 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
 #endif
 
                     for (x1 = x2 = 0; x2 < w; x2++) {
-                        int usedcol = FALSE;
+                        bool usedcol = false;
 
                         for (y1 = y2 = h-1; y2 >= 0; y2--) {
                             if (grid2[y2*w+x2] == tc) {
@@ -706,19 +707,19 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
                                     printf("adjacency failure at %d,%d\n",
                                            x2, y2);
 #endif
-                                    ok = FALSE;
+                                    ok = false;
                                 }
                                 continue;
                             }
                             if (grid2[y2*w+x2] == 0)
                                 break;
-                            usedcol = TRUE;
+                            usedcol = true;
                             if (grid2[y2*w+x2] != grid[y1*w+x1]) {
 #ifdef GENERATION_DIAGNOSTICS
                                 printf("matching failure at %d,%d vs %d,%d\n",
                                        x2, y2, x1, y1);
 #endif
-                                ok = FALSE;
+                                ok = false;
                             }
                             y1--;
                         }
@@ -735,7 +736,7 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
                                     printf("junk at column top (%d,%d)\n",
                                            x1, y1);
 #endif
-                                    ok = FALSE;
+                                    ok = false;
                                 }
                                 y1--;
                             }
@@ -830,10 +831,10 @@ static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
                 break;
         }
 
-        ok = TRUE;
+        ok = true;
         for (i = 0; i < wh; i++)
             if (grid[i] == 0) {
-                ok = FALSE;
+                ok = false;
                 failures++;
 #if defined GENERATION_DIAGNOSTICS || defined SHOW_INCOMPLETE
                 {
@@ -912,7 +913,7 @@ static void gen_grid_random(int w, int h, int nc, int *grid, random_state *rs)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     char *ret;
     int n, i, retlen, *tiles;
@@ -987,7 +988,8 @@ static game_state *new_game(midend *me, const game_params *params,
             p++;
         if (*p) p++;                   /* eat comma */
     }
-    state->complete = state->impossible = 0;
+    state->complete = false;
+    state->impossible = false;
     state->score = 0;
 
     return state;
@@ -1017,9 +1019,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1049,7 +1051,8 @@ struct game_ui {
     struct game_params params;
     int *tiles; /* selected-ness only */
     int nselected;
-    int xsel, ysel, displaysel;
+    int xsel, ysel;
+    bool displaysel;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1061,7 +1064,8 @@ static game_ui *new_ui(const game_state *state)
     memset(ui->tiles, 0, state->n*sizeof(int));
     ui->nselected = 0;
 
-    ui->xsel = ui->ysel = ui->displaysel = 0;
+    ui->xsel = ui->ysel = 0;
+    ui->displaysel = false;
 
     return ui;
 }
@@ -1102,7 +1106,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      * control cursor.
      */
     if (newstate->complete || newstate->impossible)
-	ui->displaysel = 0;
+	ui->displaysel = false;
 }
 
 static char *sel_movedesc(game_ui *ui, const game_state *state)
@@ -1192,13 +1196,13 @@ static void sel_expand(game_ui *ui, const game_state *state, int tx, int ty)
     }
 }
 
-static int sg_emptycol(game_state *ret, int x)
+static bool sg_emptycol(game_state *ret, int x)
 {
     int y;
     for (y = 0; y < ret->params.h; y++) {
-	if (COL(ret,x,y)) return 0;
+	if (COL(ret,x,y)) return false;
     }
-    return 1;
+    return true;
 }
 
 
@@ -1236,20 +1240,21 @@ static void sg_snuggle(game_state *ret)
 
 static void sg_check(game_state *ret)
 {
-    int x,y, complete = 1, impossible = 1;
+    int x,y;
+    bool complete = true, impossible = true;
 
     for (x = 0; x < ret->params.w; x++) {
 	for (y = 0; y < ret->params.h; y++) {
 	    if (COL(ret,x,y) == 0)
 		continue;
-	    complete = 0;
+	    complete = false;
 	    if (x+1 < ret->params.w) {
 		if (COL(ret,x,y) == COL(ret,x+1,y))
-		    impossible = 0;
+		    impossible = false;
 	    }
 	    if (y+1 < ret->params.h) {
 		if (COL(ret,x,y) == COL(ret,x,y+1))
-		    impossible = 0;
+		    impossible = false;
 	    }
 	}
     }
@@ -1258,7 +1263,8 @@ static void sg_check(game_state *ret)
 }
 
 struct game_drawstate {
-    int started, bgcolour;
+    bool started;
+    int bgcolour;
     int tileinner, tilegap;
     int *tiles; /* contains colour and SELECTED. */
 };
@@ -1270,20 +1276,20 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     int tx, ty;
     char *ret = UI_UPDATE;
 
-    ui->displaysel = 0;
+    ui->displaysel = false;
 
     if (button == RIGHT_BUTTON || button == LEFT_BUTTON) {
 	tx = FROMCOORD(x); ty= FROMCOORD(y);
     } else if (IS_CURSOR_MOVE(button)) {
 	int dx = 0, dy = 0;
-	ui->displaysel = 1;
+	ui->displaysel = true;
 	dx = (button == CURSOR_LEFT) ? -1 : ((button == CURSOR_RIGHT) ? +1 : 0);
 	dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP)    ? -1 : 0);
 	ui->xsel = (ui->xsel + state->params.w + dx) % state->params.w;
 	ui->ysel = (ui->ysel + state->params.h + dy) % state->params.h;
 	return ret;
     } else if (IS_CURSOR_SELECT(button)) {
-	ui->displaysel = 1;
+	ui->displaysel = true;
 	tx = ui->xsel;
 	ty = ui->ysel;
     } else
@@ -1429,7 +1435,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = 0;
+    ds->started = false;
     ds->tileinner = ds->tilegap = 0;   /* not decided yet */
     ds->tiles = snewn(state->n, int);
     ds->bgcolour = -1;
@@ -1452,7 +1458,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
  */
 
 static void tile_redraw(drawing *dr, game_drawstate *ds,
-			int x, int y, int dright, int dbelow,
+			int x, int y, bool dright, bool dbelow,
                         int tile, int bgcolour)
 {
     int outer = bgcolour, inner = outer, col = tile & TILE_COLMASK;
@@ -1532,7 +1538,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
 	draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
-	ds->started = 1;
+	ds->started = true;
     }
 
     if (flashtime > 0.0) {
@@ -1545,8 +1551,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	for (y = 0; y < state->params.h; y++) {
 	    int i = (state->params.w * y) + x;
 	    int col = COL(state,x,y), tile = col;
-	    int dright = (x+1 < state->params.w);
-	    int dbelow = (y+1 < state->params.h);
+	    bool dright = (x+1 < state->params.w);
+	    bool dbelow = (y+1 < state->params.h);
 
 	    tile |= ISSEL(ui,x,y);
 	    if (state->impossible)
@@ -1618,9 +1624,9 @@ static int game_status(const game_state *state)
     return state->complete ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1643,15 +1649,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    FALSE, solve_game,
-    TRUE, game_can_format_as_text_now, game_text_format,
+    false, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1668,8 +1674,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/signpost.c b/apps/plugins/puzzles/src/signpost.c
index 04a315206f..abf4c6a79c 100644
--- a/apps/plugins/puzzles/src/signpost.c
+++ b/apps/plugins/puzzles/src/signpost.c
@@ -39,7 +39,7 @@ enum {
 
 struct game_params {
     int w, h;
-    int force_corner_start;
+    bool force_corner_start;
 };
 
 enum { DIR_N = 0, DIR_NE, DIR_E, DIR_SE, DIR_S, DIR_SW, DIR_W, DIR_NW, DIR_MAX };
@@ -52,7 +52,7 @@ static const int dys[DIR_MAX] = { -1, -1, 0, 1, 1,  1,  0, -1 };
 
 struct game_state {
     int w, h, n;
-    int completed, used_solve, impossible;
+    bool completed, used_solve, impossible;
     int *dirs;                  /* direction enums, size n */
     int *nums;                  /* numbers, size n */
     unsigned int *flags;        /* flags, size n */
@@ -92,35 +92,36 @@ static int whichdiri(game_state *state, int fromi, int toi)
     return whichdir(fromi%w, fromi/w, toi%w, toi/w);
 }
 
-static int ispointing(const game_state *state, int fromx, int fromy,
-                      int tox, int toy)
+static bool ispointing(const game_state *state, int fromx, int fromy,
+                       int tox, int toy)
 {
     int w = state->w, dir = state->dirs[fromy*w+fromx];
 
     /* (by convention) squares do not point to themselves. */
-    if (fromx == tox && fromy == toy) return 0;
+    if (fromx == tox && fromy == toy) return false;
 
     /* the final number points to nothing. */
-    if (state->nums[fromy*w + fromx] == state->n) return 0;
+    if (state->nums[fromy*w + fromx] == state->n) return false;
 
     while (1) {
-        if (!INGRID(state, fromx, fromy)) return 0;
-        if (fromx == tox && fromy == toy) return 1;
+        if (!INGRID(state, fromx, fromy)) return false;
+        if (fromx == tox && fromy == toy) return true;
         fromx += dxs[dir]; fromy += dys[dir];
     }
-    return 0; /* not reached */
+    return false; /* not reached */
 }
 
-static int ispointingi(game_state *state, int fromi, int toi)
+static bool ispointingi(game_state *state, int fromi, int toi)
 {
     int w = state->w;
     return ispointing(state, fromi%w, fromi/w, toi%w, toi/w);
 }
 
 /* Taking the number 'num', work out the gap between it and the next
- * available number up or down (depending on d). Return 1 if the region
- * at (x,y) will fit in that gap, or 0 otherwise. */
-static int move_couldfit(const game_state *state, int num, int d, int x, int y)
+ * available number up or down (depending on d). Return true if the
+ * region at (x,y) will fit in that gap. */
+static bool move_couldfit(
+    const game_state *state, int num, int d, int x, int y)
 {
     int n, gap, i = y*state->w+x, sz;
 
@@ -136,54 +137,54 @@ static int move_couldfit(const game_state *state, int num, int d, int x, int y)
         /* no gap, so the only allowable move is that that directly
          * links the two numbers. */
         n = state->nums[i];
-        return (n == num+d) ? 0 : 1;
+        return n != num+d;
     }
     if (state->prev[i] == -1 && state->next[i] == -1)
-        return 1; /* single unconnected square, always OK */
+        return true; /* single unconnected square, always OK */
 
     sz = dsf_size(state->dsf, i);
-    return (sz > gap) ? 0 : 1;
+    return sz <= gap;
 }
 
-static int isvalidmove(const game_state *state, int clever,
-                       int fromx, int fromy, int tox, int toy)
+static bool isvalidmove(const game_state *state, bool clever,
+                        int fromx, int fromy, int tox, int toy)
 {
     int w = state->w, from = fromy*w+fromx, to = toy*w+tox;
     int nfrom, nto;
 
     if (!INGRID(state, fromx, fromy) || !INGRID(state, tox, toy))
-        return 0;
+        return false;
 
     /* can only move where we point */
     if (!ispointing(state, fromx, fromy, tox, toy))
-        return 0;
+        return false;
 
     nfrom = state->nums[from]; nto = state->nums[to];
 
     /* can't move _from_ the preset final number, or _to_ the preset 1. */
     if (((nfrom == state->n) && (state->flags[from] & FLAG_IMMUTABLE)) ||
         ((nto   == 1)        && (state->flags[to]   & FLAG_IMMUTABLE)))
-        return 0;
+        return false;
 
     /* can't create a new connection between cells in the same region
      * as that would create a loop. */
     if (dsf_canonify(state->dsf, from) == dsf_canonify(state->dsf, to))
-        return 0;
+        return false;
 
     /* if both cells are actual numbers, can't drag if we're not
      * one digit apart. */
     if (ISREALNUM(state, nfrom) && ISREALNUM(state, nto)) {
         if (nfrom != nto-1)
-            return 0;
+            return false;
     } else if (clever && ISREALNUM(state, nfrom)) {
         if (!move_couldfit(state, nfrom, +1, tox, toy))
-            return 0;
+            return false;
     } else if (clever && ISREALNUM(state, nto)) {
         if (!move_couldfit(state, nto, -1, fromx, fromy))
-            return 0;
+            return false;
     }
 
-    return 1;
+    return true;
 }
 
 static void makelink(game_state *state, int from, int to)
@@ -197,10 +198,10 @@ static void makelink(game_state *state, int from, int to)
     state->prev[to] = from;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    if (params->w * params->h >= 100) return 0;
-    return 1;
+    if (params->w * params->h >= 100) return false;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -279,9 +280,10 @@ static void strip_nums(game_state *state) {
     dsf_init(state->dsf, state->n);
 }
 
-static int check_nums(game_state *orig, game_state *copy, int only_immutable)
+static bool check_nums(game_state *orig, game_state *copy, bool only_immutable)
 {
-    int i, ret = 1;
+    int i;
+    bool ret = true;
     assert(copy->n == orig->n);
     for (i = 0; i < copy->n; i++) {
         if (only_immutable && !(copy->flags[i] & FLAG_IMMUTABLE)) continue;
@@ -290,7 +292,7 @@ static int check_nums(game_state *orig, game_state *copy, int only_immutable)
         if (copy->nums[i] != orig->nums[i]) {
             debug(("check_nums: (%d,%d) copy=%d, orig=%d.",
                    i%orig->w, i/orig->w, copy->nums[i], orig->nums[i]));
-            ret = 0;
+            ret = false;
         }
     }
     return ret;
@@ -302,7 +304,7 @@ static game_params *default_params(void)
 {
     game_params *ret = snew(game_params);
     ret->w = ret->h = 4;
-    ret->force_corner_start = 1;
+    ret->force_corner_start = true;
 
     return ret;
 }
@@ -316,13 +318,13 @@ static const struct game_params signpost_presets[] = {
   { 7, 7, 1 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(signpost_presets))
-        return FALSE;
+        return false;
 
     ret = default_params();
     *ret = signpost_presets[i];
@@ -332,7 +334,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
             ret->force_corner_start ? "" : ", free ends");
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -356,15 +358,15 @@ static void decode_params(game_params *ret, char const *string)
         ret->h = atoi(string);
         while (*string && isdigit((unsigned char)*string)) string++;
     }
-    ret->force_corner_start = 0;
+    ret->force_corner_start = false;
     if (*string == 'c') {
         string++;
-        ret->force_corner_start = 1;
+        ret->force_corner_start = true;
     }
 
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -415,7 +417,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 1) return "Width must be at least one";
     if (params->h < 1) return "Height must be at least one";
@@ -549,7 +551,7 @@ done:
     }
 }
 
-static char *generate_desc(game_state *state, int issolve)
+static char *generate_desc(game_state *state, bool issolve)
 {
     char *ret, buf[80];
     int retlen, i, k;
@@ -602,10 +604,11 @@ static int cell_adj(game_state *state, int i, int *ai, int *ad)
     return n;
 }
 
-static int new_game_fill(game_state *state, random_state *rs,
-                         int headi, int taili)
+static bool new_game_fill(game_state *state, random_state *rs,
+                          int headi, int taili)
 {
-    int nfilled, an, ret = 0, j;
+    int nfilled, an, j;
+    bool ret = false;
     int *aidx, *adir;
 
     aidx = snewn(state->n, int);
@@ -658,7 +661,7 @@ static int new_game_fill(game_state *state, random_state *rs,
 
     /* it could happen that our last two weren't in line; if that's the
      * case, we have to start again. */
-    if (state->dirs[headi] != -1) ret = 1;
+    if (state->dirs[headi] != -1) ret = true;
 
 done:
     sfree(aidx);
@@ -713,11 +716,12 @@ static void debug_desc(const char *what, game_state *state)
 
 /* Expects a fully-numbered game_state on input, and makes sure
  * FLAG_IMMUTABLE is only set on those numbers we need to solve
- * (as for a real new-game); returns 1 if it managed
- * this (such that it could solve it), or 0 if not. */
-static int new_game_strip(game_state *state, random_state *rs)
+ * (as for a real new-game); returns true if it managed
+ * this (such that it could solve it), or false if not. */
+static bool new_game_strip(game_state *state, random_state *rs)
 {
-    int *scratch, i, j, ret = 1;
+    int *scratch, i, j;
+    bool ret = true;
     game_state *copy = dup_game(state);
 
     debug(("new_game_strip."));
@@ -728,7 +732,7 @@ static int new_game_strip(game_state *state, random_state *rs)
     if (solve_state(copy) > 0) {
         debug(("new_game_strip: soluble immediately after strip."));
         free_game(copy);
-        return 1;
+        return true;
     }
 
     scratch = snewn(state->n, int);
@@ -755,9 +759,9 @@ static int new_game_strip(game_state *state, random_state *rs)
         debug_state("Copy of state: ", copy);
         strip_nums(copy);
         if (solve_state(copy) > 0) goto solved;
-        assert(check_nums(state, copy, 1));
+        assert(check_nums(state, copy, true));
     }
-    ret = 0;
+    ret = false;
     goto done;
 
 solved:
@@ -776,7 +780,7 @@ solved:
             dup_game_to(copy, state);
             strip_nums(copy);
             if (solve_state(copy) > 0) {
-                assert(check_nums(state, copy, 0));
+                assert(check_nums(state, copy, false));
                 debug(("new_game_strip: OK, removing number"));
             } else {
                 assert(state->nums[j] <= state->n);
@@ -795,7 +799,7 @@ done:
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h);
     char *ret;
@@ -839,7 +843,7 @@ generate:
         assert(solve_state(tosolve) > 0);
         free_game(tosolve);
     }
-    ret = generate_desc(state, 0);
+    ret = generate_desc(state, false);
     free_game(state);
     return ret;
 }
@@ -909,7 +913,7 @@ static void head_number(game_state *state, int i, struct head_meta *head)
                 head->why = "contains cell with immutable number";
             } else if (head->start != ss) {
                 debug(("head_number: chain with non-sequential numbers!"));
-                state->impossible = 1;
+                state->impossible = true;
             }
         }
         off++;
@@ -1015,7 +1019,7 @@ static void connect_numbers(game_state *state)
             dni = dsf_canonify(state->dsf, state->next[i]);
             if (di == dni) {
                 debug(("connect_numbers: chain forms a loop."));
-                state->impossible = 1;
+                state->impossible = true;
             }
             dsf_merge(state->dsf, di, dni);
         }
@@ -1142,9 +1146,10 @@ static void update_numbers(game_state *state)
     sfree(heads);
 }
 
-static int check_completion(game_state *state, int mark_errors)
+static bool check_completion(game_state *state, bool mark_errors)
 {
-    int n, j, k, error = 0, complete;
+    int n, j, k;
+    bool error = false, complete;
 
     /* NB This only marks errors that are possible to perpetrate with
      * the current UI in interpret_move. Things like forming loops in
@@ -1165,7 +1170,7 @@ static int check_completion(game_state *state, int mark_errors)
                         state->flags[j] |= FLAG_ERROR;
                         state->flags[k] |= FLAG_ERROR;
                     }
-                    error = 1;
+                    error = true;
                 }
             }
         }
@@ -1173,16 +1178,16 @@ static int check_completion(game_state *state, int mark_errors)
 
     /* Search and mark numbers n not pointing to n+1; if any numbers
      * are missing we know we've not completed. */
-    complete = 1;
+    complete = true;
     for (n = 1; n < state->n; n++) {
         if (state->numsi[n] == -1 || state->numsi[n+1] == -1)
-            complete = 0;
+            complete = false;
         else if (!ispointingi(state, state->numsi[n], state->numsi[n+1])) {
             if (mark_errors) {
                 state->flags[state->numsi[n]] |= FLAG_ERROR;
                 state->flags[state->numsi[n+1]] |= FLAG_ERROR;
             }
-            error = 1;
+            error = true;
         } else {
             /* make sure the link is explicitly made here; for instance, this
              * is nice if the user drags from 2 out (making 3) and a 4 is also
@@ -1197,13 +1202,13 @@ static int check_completion(game_state *state, int mark_errors)
         if ((state->nums[n] < 0) ||
             (state->nums[n] == 0 &&
              (state->next[n] != -1 || state->prev[n] != -1))) {
-            error = 1;
+            error = true;
             if (mark_errors)
                 state->flags[n] |= FLAG_ERROR;
         }
     }
 
-    if (error) return 0;
+    if (error) return false;
     return complete;
 }
 static game_state *new_game(midend *me, const game_params *params,
@@ -1215,7 +1220,7 @@ static game_state *new_game(midend *me, const game_params *params,
     if (!state) assert(!"new_game failed to unpick");
 
     update_numbers(state);
-    check_completion(state, 1); /* update any auto-links */
+    check_completion(state, true); /* update any auto-links */
 
     return state;
 }
@@ -1247,7 +1252,7 @@ static int solve_single(game_state *state, game_state *copy, int *from)
         while (1) {
             x += dxs[d]; y += dys[d];
             if (!INGRID(state, x, y)) break;
-            if (!isvalidmove(state, 1, sx, sy, x, y)) continue;
+            if (!isvalidmove(state, true, sx, sy, x, y)) continue;
 
             /* can't link to somewhere with a back-link we would have to
              * break (the solver just doesn't work like this). */
@@ -1276,7 +1281,7 @@ static int solve_single(game_state *state, game_state *copy, int *from)
             ;
         } else if (poss == -1) {
             debug(("Solver: nowhere possible for (%d,%d) to link to.", sx, sy));
-            copy->impossible = 1;
+            copy->impossible = true;
             return -1;
         } else {
             debug(("Solver: linking (%d,%d) to only possible next (%d,%d).",
@@ -1293,7 +1298,7 @@ static int solve_single(game_state *state, game_state *copy, int *from)
         x = i%w; y = i/w;
         if (from[i] == -1) {
             debug(("Solver: nowhere possible to link to (%d,%d)", x, y));
-            copy->impossible = 1;
+            copy->impossible = true;
             return -1;
         } else if (from[i] == -2) {
             /*debug(("Solver: (%d,%d) has multiple possible prev squares.", x, y));*/
@@ -1330,7 +1335,7 @@ static int solve_state(game_state *state)
     sfree(scratch);
 
     update_numbers(state);
-    ret = state->impossible ? -1 : check_completion(state, 0);
+    ret = state->impossible ? -1 : check_completion(state, false);
     debug(("Solver finished: %s",
            ret < 0 ? "impossible" : ret > 0 ? "solved" : "not solved"));
     debug_state("After solver: ", state);
@@ -1347,7 +1352,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     tosolve = dup_game(currstate);
     result = solve_state(tosolve);
     if (result > 0)
-        ret = generate_desc(tosolve, 1);
+        ret = generate_desc(tosolve, true);
     free_game(tosolve);
     if (ret) return ret;
 
@@ -1358,7 +1363,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     else if (result == 0)
         *error = "Unable to solve puzzle.";
     else
-        ret = generate_desc(tosolve, 1);
+        ret = generate_desc(tosolve, true);
 
     free_game(tosolve);
 
@@ -1369,9 +1374,10 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 
 
 struct game_ui {
-    int cx, cy, cshow;
+    int cx, cy;
+    bool cshow;
 
-    int dragging, drag_is_from;
+    bool dragging, drag_is_from;
     int sx, sy;         /* grid coords of start cell */
     int dx, dy;         /* pixel coords of drag posn */
 };
@@ -1383,9 +1389,10 @@ static game_ui *new_ui(const game_state *state)
     /* NB: if this is ever changed to as to require more than a structure
      * copy to clone, there's code that needs fixing in game_redraw too. */
 
-    ui->cx = ui->cy = ui->cshow = 0;
+    ui->cx = ui->cy = 0;
+    ui->cshow = false;
 
-    ui->dragging = 0;
+    ui->dragging = false;
     ui->sx = ui->sy = ui->dx = ui->dy = 0;
 
     return ui;
@@ -1408,18 +1415,22 @@ static void decode_ui(game_ui *ui, const char *encoding)
 static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
-    if (!oldstate->completed && newstate->completed)
-        ui->cshow = ui->dragging = 0;
+    if (!oldstate->completed && newstate->completed) {
+        ui->cshow = false;
+        ui->dragging = false;
+    }
 }
 
 struct game_drawstate {
-    int tilesize, started, solved;
+    int tilesize;
+    bool started, solved;
     int w, h, n;
     int *nums, *dirp;
     unsigned int *f;
     double angle_offset;
 
-    int dragging, dx, dy;
+    bool dragging;
+    int dx, dy;
     blitter *dragb;
 };
 
@@ -1431,8 +1442,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     char buf[80];
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, 0);
-        ui->cshow = 1;
+        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, false);
+        ui->cshow = true;
         if (ui->dragging) {
             ui->dx = COORD(ui->cx) + TILE_SIZE/2;
             ui->dy = COORD(ui->cy) + TILE_SIZE/2;
@@ -1440,33 +1451,34 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return UI_UPDATE;
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cshow)
-            ui->cshow = 1;
+            ui->cshow = true;
         else if (ui->dragging) {
-            ui->dragging = FALSE;
+            ui->dragging = false;
             if (ui->sx == ui->cx && ui->sy == ui->cy) return UI_UPDATE;
             if (ui->drag_is_from) {
-                if (!isvalidmove(state, 0, ui->sx, ui->sy, ui->cx, ui->cy))
+                if (!isvalidmove(state, false, ui->sx, ui->sy, ui->cx, ui->cy))
                     return UI_UPDATE;
                 sprintf(buf, "L%d,%d-%d,%d", ui->sx, ui->sy, ui->cx, ui->cy);
             } else {
-                if (!isvalidmove(state, 0, ui->cx, ui->cy, ui->sx, ui->sy))
+                if (!isvalidmove(state, false, ui->cx, ui->cy, ui->sx, ui->sy))
                     return UI_UPDATE;
                 sprintf(buf, "L%d,%d-%d,%d", ui->cx, ui->cy, ui->sx, ui->sy);
             }
             return dupstr(buf);
         } else {
-            ui->dragging = TRUE;
+            ui->dragging = true;
             ui->sx = ui->cx;
             ui->sy = ui->cy;
             ui->dx = COORD(ui->cx) + TILE_SIZE/2;
             ui->dy = COORD(ui->cy) + TILE_SIZE/2;
-            ui->drag_is_from = (button == CURSOR_SELECT) ? 1 : 0;
+            ui->drag_is_from = (button == CURSOR_SELECT);
         }
         return UI_UPDATE;
     }
     if (IS_MOUSE_DOWN(button)) {
         if (ui->cshow) {
-            ui->cshow = ui->dragging = 0;
+            ui->cshow = false;
+            ui->dragging = false;
         }
         assert(!ui->dragging);
         if (!INGRID(state, x, y)) return NULL;
@@ -1483,20 +1495,20 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 return NULL;
         }
 
-        ui->dragging = TRUE;
-        ui->drag_is_from = (button == LEFT_BUTTON) ? 1 : 0;
+        ui->dragging = true;
+        ui->drag_is_from = (button == LEFT_BUTTON);
         ui->sx = x;
         ui->sy = y;
         ui->dx = mx;
         ui->dy = my;
-        ui->cshow = 0;
+        ui->cshow = false;
         return UI_UPDATE;
     } else if (IS_MOUSE_DRAG(button) && ui->dragging) {
         ui->dx = mx;
         ui->dy = my;
         return UI_UPDATE;
     } else if (IS_MOUSE_RELEASE(button) && ui->dragging) {
-        ui->dragging = FALSE;
+        ui->dragging = false;
         if (ui->sx == x && ui->sy == y) return UI_UPDATE; /* single click */
 
         if (!INGRID(state, x, y)) {
@@ -1509,11 +1521,11 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
 
         if (ui->drag_is_from) {
-            if (!isvalidmove(state, 0, ui->sx, ui->sy, x, y))
+            if (!isvalidmove(state, false, ui->sx, ui->sy, x, y))
                 return UI_UPDATE;
             sprintf(buf, "L%d,%d-%d,%d", ui->sx, ui->sy, x, y);
         } else {
-            if (!isvalidmove(state, 0, x, y, ui->sx, ui->sy))
+            if (!isvalidmove(state, false, x, y, ui->sx, ui->sy))
                 return UI_UPDATE;
             sprintf(buf, "L%d,%d-%d,%d", x, y, ui->sx, ui->sy);
         }
@@ -1576,9 +1588,9 @@ static game_state *execute_move(const game_state *state, const char *move)
 	    ret->next[i] = tmp->next[i];
 	}
 	free_game(tmp);
-        ret->used_solve = 1;
+        ret->used_solve = true;
     } else if (sscanf(move, "L%d,%d-%d,%d", &sx, &sy, &ex, &ey) == 4) {
-        if (!isvalidmove(state, 0, sx, sy, ex, ey)) return NULL;
+        if (!isvalidmove(state, false, sx, sy, ex, ey)) return NULL;
 
         ret = dup_game(state);
 
@@ -1618,7 +1630,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     }
     if (ret) {
         update_numbers(ret);
-        if (check_completion(ret, 1)) ret->completed = 1;
+        if (check_completion(ret, true)) ret->completed = true;
     }
 
     return ret;
@@ -1724,7 +1736,9 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->tilesize = ds->started = ds->solved = 0;
+    ds->tilesize = 0;
+    ds->started = false;
+    ds->solved = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->n = state->n;
@@ -1740,7 +1754,8 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 
     ds->angle_offset = 0.0F;
 
-    ds->dragging = ds->dx = ds->dy = 0;
+    ds->dragging = false;
+    ds->dx = ds->dy = 0;
     ds->dragb = NULL;
 
     return ds;
@@ -1847,10 +1862,11 @@ static void tile_redraw(drawing *dr, game_drawstate *ds, int tx, int ty,
     int cb = TILE_SIZE / 16, textsz;
     char buf[20];
     int arrowcol, sarrowcol, setcol, textcol;
-    int acx, acy, asz, empty = 0;
+    int acx, acy, asz;
+    bool empty = false;
 
     if (num == 0 && !(f & F_ARROW_POINT) && !(f & F_ARROW_INPOINT)) {
-        empty = 1;
+        empty = true;
         /*
          * We don't display text in empty cells: typically these are
          * signified by num=0. However, in some cases a cell could
@@ -1978,7 +1994,7 @@ static void tile_redraw(drawing *dr, game_drawstate *ds, int tx, int ty,
 
 static void draw_drag_indicator(drawing *dr, game_drawstate *ds,
                                 const game_state *state, const game_ui *ui,
-                                int validdrag)
+                                bool validdrag)
 {
     int dir, w = ds->w, acol = COL_ARROW;
     int fx = FROMCOORD(ui->dx), fy = FROMCOORD(ui->dy);
@@ -2027,7 +2043,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int x, y, i, w = ds->w, dirp, force = 0;
+    int x, y, i, w = ds->w, dirp;
+    bool force = false;
     unsigned int f;
     double angle_offset = 0.0;
     game_state *postdrop = NULL;
@@ -2036,14 +2053,14 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         angle_offset = 2.0 * PI * (flashtime / FLASH_SPIN);
     if (angle_offset != ds->angle_offset) {
         ds->angle_offset = angle_offset;
-        force = 1;
+        force = true;
     }
 
     if (ds->dragging) {
         assert(ds->dragb);
         blitter_load(dr, ds->dragb, ds->dx, ds->dy);
         draw_update(dr, ds->dx, ds->dy, BLITTER_SIZE, BLITTER_SIZE);
-        ds->dragging = FALSE;
+        ds->dragging = false;
     }
 
     /* If an in-progress drag would make a valid move if finished, we
@@ -2144,15 +2161,15 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         }
     }
     if (ui->dragging) {
-        ds->dragging = TRUE;
+        ds->dragging = true;
         ds->dx = ui->dx - BLITTER_SIZE/2;
         ds->dy = ui->dy - BLITTER_SIZE/2;
         blitter_save(dr, ds->dragb, ds->dx, ds->dy);
 
-        draw_drag_indicator(dr, ds, state, ui, postdrop ? 1 : 0);
+        draw_drag_indicator(dr, ds, state, ui, postdrop != NULL);
     }
     if (postdrop) free_game(postdrop);
-    if (!ds->started) ds->started = TRUE;
+    if (!ds->started) ds->started = true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -2176,9 +2193,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2234,15 +2251,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2259,9 +2276,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -2378,7 +2395,8 @@ int main(int argc, const char *argv[])
 {
     char *id = NULL, *desc, *aux = NULL;
     const char *err;
-    int soak = 0, verbose = 0, stdin_desc = 0, n = 1, i;
+    bool soak = false, verbose = false, stdin_desc = false;
+    int n = 1, i;
     char *seedstr = NULL, newseed[16];
 
     setvbuf(stdout, NULL, _IONBF, 0);
@@ -2387,9 +2405,9 @@ int main(int argc, const char *argv[])
     while (--argc > 0) {
         char *p = (char*)(*++argv);
         if (!strcmp(p, "-v") || !strcmp(p, "--verbose"))
-            verbose = 1;
+            verbose = true;
         else if (!strcmp(p, "--stdin"))
-            stdin_desc = 1;
+            stdin_desc = true;
         else if (!strcmp(p, "-e") || !strcmp(p, "--seed")) {
             seedstr = dupstr(*++argv);
             argc--;
@@ -2397,7 +2415,7 @@ int main(int argc, const char *argv[])
             n = atoi(*++argv);
             argc--;
         } else if (!strcmp(p, "-s") || !strcmp(p, "--soak")) {
-            soak = 1;
+            soak = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             usage(stderr);
diff --git a/apps/plugins/puzzles/src/singles.c b/apps/plugins/puzzles/src/singles.c
index 35c5fcee59..3dde8c2b87 100644
--- a/apps/plugins/puzzles/src/singles.c
+++ b/apps/plugins/puzzles/src/singles.c
@@ -64,7 +64,7 @@
 #include "latin.h"
 
 #ifdef STANDALONE_SOLVER
-int verbose = 0;
+bool verbose = false;
 #endif
 
 #define PREFERRED_TILE_SIZE 32
@@ -99,7 +99,7 @@ struct game_params {
 
 struct game_state {
     int w, h, n, o;             /* n = w*h; o = max(w, h) */
-    int completed, used_solve, impossible;
+    bool completed, used_solve, impossible;
     int *nums;                  /* size w*h */
     unsigned int *flags;        /* size w*h */
 };
@@ -147,13 +147,13 @@ static const struct game_params singles_presets[] = {
   { 12, 12, DIFF_TRICKY }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(singles_presets))
-        return FALSE;
+        return false;
 
     ret = default_params();
     *ret = singles_presets[i];
@@ -162,7 +162,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
     sprintf(buf, "%dx%d %s", ret->w, ret->h, singles_diffnames[ret->diff]);
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -200,7 +200,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -251,7 +251,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and neight must be at least two";
@@ -277,7 +277,9 @@ static game_state *blank_game(int w, int h)
     state->n = w*h;
     state->o = max(w,h);
 
-    state->completed = state->used_solve = state->impossible = 0;
+    state->completed = false;
+    state->used_solve = false;
+    state->impossible = false;
 
     state->nums  = snewn(state->n, int);
     state->flags = snewn(state->n, unsigned int);
@@ -359,7 +361,7 @@ done:
     }
 }
 
-static char *generate_desc(game_state *state, int issolve)
+static char *generate_desc(game_state *state, bool issolve)
 {
     char *ret = snewn(state->n+1+(issolve?1:0), char);
     int i, p=0;
@@ -374,9 +376,9 @@ static char *generate_desc(game_state *state, int issolve)
 
 /* --- Useful game functions (completion, etc.) --- */
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -490,7 +492,7 @@ static int check_rowcol(game_state *state, int starti, int di, int sz, unsigned
     return nerr;
 }
 
-static int check_complete(game_state *state, unsigned flags)
+static bool check_complete(game_state *state, unsigned flags)
 {
     int *dsf = snewn(state->n, int);
     int x, y, i, error = 0, nwhite, w = state->w, h = state->h;
@@ -557,11 +559,11 @@ static int check_complete(game_state *state, unsigned flags)
     }
 
     sfree(dsf);
-    return (error > 0) ? 0 : 1;
+    return !(error > 0);
 }
 
 static char *game_state_diff(const game_state *src, const game_state *dst,
-                             int issolve)
+                             bool issolve)
 {
     char *ret = NULL, buf[80], c;
     int retlen = 0, x, y, i, k;
@@ -651,7 +653,7 @@ static void solver_op_circle(game_state *state, struct solver_state *ss,
     if (!INGRID(state, x, y)) return;
     if (state->flags[i] & F_BLACK) {
         debug(("... solver wants to add auto-circle on black (%d,%d)\n", x, y));
-        state->impossible = 1;
+        state->impossible = true;
         return;
     }
     /* Only add circle op if it's not already circled. */
@@ -669,7 +671,7 @@ static void solver_op_blacken(game_state *state, struct solver_state *ss,
     if (state->nums[i] != num) return;
     if (state->flags[i] & F_CIRCLE) {
         debug(("... solver wants to add auto-black on circled(%d,%d)\n", x, y));
-        state->impossible = 1;
+        state->impossible = true;
         return;
     }
     /* Only add black op if it's not already black. */
@@ -693,7 +695,7 @@ static int solver_ops_do(game_state *state, struct solver_state *ss)
         if (op.op == BLACK) {
             if (state->flags[i] & F_CIRCLE) {
                 debug(("Solver wants to blacken circled square (%d,%d)!\n", op.x, op.y));
-                state->impossible = 1;
+                state->impossible = true;
                 return n_ops;
             }
             if (!(state->flags[i] & F_BLACK)) {
@@ -713,7 +715,7 @@ static int solver_ops_do(game_state *state, struct solver_state *ss)
         } else {
             if (state->flags[i] & F_BLACK) {
                 debug(("Solver wants to circle blackened square (%d,%d)!\n", op.x, op.y));
-                state->impossible = 1;
+                state->impossible = true;
                 return n_ops;
             }
             if (!(state->flags[i] & F_CIRCLE)) {
@@ -845,7 +847,7 @@ static int solve_allblackbutone(game_state *state, struct solver_state *ss)
                               "CC/CE/QM: white cell with single non-black around it");
             else {
                 debug(("White cell with no escape at (%d,%d)\n", x, y));
-                state->impossible = 1;
+                state->impossible = true;
                 return 0;
             }
 skip: ;
@@ -994,7 +996,8 @@ static int solve_offsetpair(game_state *state, struct solver_state *ss)
     return ss->n_ops - n_ops;
 }
 
-static int solve_hassinglewhiteregion(game_state *state, struct solver_state *ss)
+static bool solve_hassinglewhiteregion(
+    game_state *state, struct solver_state *ss)
 {
     int i, j, nwhite = 0, lwhite = -1, szwhite, start, end, next, a, d, x, y;
 
@@ -1007,8 +1010,8 @@ static int solve_hassinglewhiteregion(game_state *state, struct solver_state *ss
     }
     if (lwhite == -1) {
         debug(("solve_hassinglewhite: no white squares found!\n"));
-        state->impossible = 1;
-        return 0;
+        state->impossible = true;
+        return false;
     }
     /* We don't use connect_dsf here; it's too slow, and there's a quicker
      * algorithm if all we want is the size of one region. */
@@ -1034,13 +1037,14 @@ static int solve_hassinglewhiteregion(game_state *state, struct solver_state *ss
         start = end; end = next;
     }
     szwhite = next;
-    return (szwhite == nwhite) ? 1 : 0;
+    return (szwhite == nwhite);
 }
 
 static void solve_removesplits_check(game_state *state, struct solver_state *ss,
                                      int x, int y)
 {
-    int i = y*state->w + x, issingle;
+    int i = y*state->w + x;
+    bool issingle;
 
     if (!INGRID(state, x, y)) return;
     if ((state->flags[i] & F_CIRCLE) || (state->flags[i] & F_BLACK))
@@ -1066,7 +1070,7 @@ static int solve_removesplits(game_state *state, struct solver_state *ss)
 
     if (!solve_hassinglewhiteregion(state, ss)) {
         debug(("solve_removesplits: white region is not contiguous at start!\n"));
-        state->impossible = 1;
+        state->impossible = true;
         return 0;
     }
 
@@ -1144,7 +1148,7 @@ static int solve_sneaky(game_state *state, struct solver_state *ss)
     return nunique;
 }
 
-static int solve_specific(game_state *state, int diff, int sneaky)
+static int solve_specific(game_state *state, int diff, bool sneaky)
 {
     struct solver_state *ss = solver_state_new(state);
 
@@ -1186,18 +1190,18 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     game_state *solved = dup_game(currstate);
     char *move = NULL;
 
-    if (solve_specific(solved, DIFF_ANY, 0) > 0) goto solved;
+    if (solve_specific(solved, DIFF_ANY, false) > 0) goto solved;
     free_game(solved);
 
     solved = dup_game(state);
-    if (solve_specific(solved, DIFF_ANY, 0) > 0) goto solved;
+    if (solve_specific(solved, DIFF_ANY, false) > 0) goto solved;
     free_game(solved);
 
     *error = "Unable to solve puzzle.";
     return NULL;
 
 solved:
-    move = game_state_diff(currstate, solved, 1);
+    move = game_state_diff(currstate, solved, true);
     free_game(solved);
     return move;
 }
@@ -1216,14 +1220,15 @@ solved:
       the solver gets a headstart working out where they are.
  */
 
-static int new_game_is_good(const game_params *params,
-                            game_state *state, game_state *tosolve)
+static bool new_game_is_good(const game_params *params,
+                             game_state *state, game_state *tosolve)
 {
     int sret, sret_easy = 0;
 
     memcpy(tosolve->nums, state->nums, state->n * sizeof(int));
     memset(tosolve->flags, 0, state->n * sizeof(unsigned int));
-    tosolve->completed = tosolve->impossible = 0;
+    tosolve->completed = false;
+    tosolve->impossible = false;
 
     /*
      * We try and solve it twice, once at our requested difficulty level
@@ -1241,22 +1246,23 @@ static int new_game_is_good(const game_params *params,
      */
 
     assert(params->diff < DIFF_MAX);
-    sret = solve_specific(tosolve, params->diff, 0);
+    sret = solve_specific(tosolve, params->diff, false);
     if (params->diff > DIFF_EASY) {
         memset(tosolve->flags, 0, state->n * sizeof(unsigned int));
-        tosolve->completed = tosolve->impossible = 0;
+        tosolve->completed = false;
+        tosolve->impossible = false;
 
-        /* this is the only time the 'sneaky' flag is set to 1. */
-        sret_easy = solve_specific(tosolve, params->diff-1, 1);
+        /* this is the only time the 'sneaky' flag is set. */
+        sret_easy = solve_specific(tosolve, params->diff-1, true);
     }
 
     if (sret <= 0 || sret_easy > 0) {
         debug(("Generated puzzle %s at chosen difficulty %s\n",
                sret <= 0 ? "insoluble" : "too easy",
                singles_diffnames[params->diff]));
-        return 0;
+        return false;
     }
-    return 1;
+    return true;
 }
 
 #define MAXTRIES 20
@@ -1299,7 +1305,7 @@ found:
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_state *state = blank_game(params->w, params->h);
     game_state *tosolve = blank_game(params->w, params->h);
@@ -1398,7 +1404,7 @@ randomise:
         goto randomise;
     }
 
-    ret = generate_desc(state, 0);
+    ret = generate_desc(state, false);
 
     free_game(tosolve);
     free_game(state);
@@ -1431,16 +1437,17 @@ static game_state *new_game(midend *me, const game_params *params,
 /* --- Game UI and move routines --- */
 
 struct game_ui {
-    int cx, cy, cshow;
-    int show_black_nums;
+    int cx, cy;
+    bool cshow, show_black_nums;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
 
-    ui->cx = ui->cy = ui->cshow = 0;
-    ui->show_black_nums = 0;
+    ui->cx = ui->cy = 0;
+    ui->cshow = false;
+    ui->show_black_nums = false;
 
     return ui;
 }
@@ -1463,7 +1470,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
     if (!oldstate->completed && newstate->completed)
-        ui->cshow = 0;
+        ui->cshow = false;
 }
 
 #define DS_BLACK        0x1
@@ -1475,7 +1482,8 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 #define DS_IMPOSSIBLE   0x40
 
 struct game_drawstate {
-    int tilesize, started, solved;
+    int tilesize;
+    bool started, solved;
     int w, h, n;
 
     unsigned int *flags;
@@ -1490,14 +1498,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     enum { NONE, TOGGLE_BLACK, TOGGLE_CIRCLE, UI } action = NONE;
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, 1);
-        ui->cshow = 1;
+        move_cursor(button, &ui->cx, &ui->cy, state->w, state->h, true);
+        ui->cshow = true;
         action = UI;
     } else if (IS_CURSOR_SELECT(button)) {
         x = ui->cx; y = ui->cy;
         if (!ui->cshow) {
             action = UI;
-            ui->cshow = 1;
+            ui->cshow = true;
         }
         if (button == CURSOR_SELECT) {
             action = TOGGLE_BLACK;
@@ -1506,11 +1514,11 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
     } else if (IS_MOUSE_DOWN(button)) {
         if (ui->cshow) {
-            ui->cshow = 0;
+            ui->cshow = false;
             action = UI;
         }
         if (!INGRID(state, x, y)) {
-            ui->show_black_nums = 1 - ui->show_black_nums;
+            ui->show_black_nums = !ui->show_black_nums;
             action = UI; /* this wants to be a per-game option. */
         } else if (button == LEFT_BUTTON) {
             action = TOGGLE_BLACK;
@@ -1557,7 +1565,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             move += n;
         } else if (c == 'S') {
             move++;
-            ret->used_solve = 1;
+            ret->used_solve = true;
         } else
             goto badmove;
 
@@ -1566,7 +1574,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         else if (*move)
             goto badmove;
     }
-    if (check_complete(ret, CC_MARK_ERRORS)) ret->completed = 1;
+    if (check_complete(ret, CC_MARK_ERRORS)) ret->completed = true;
     return ret;
 
 badmove:
@@ -1623,7 +1631,9 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 {
     struct game_drawstate *ds = snew(struct game_drawstate);
 
-    ds->tilesize = ds->started = ds->solved = 0;
+    ds->tilesize = 0;
+    ds->started = false;
+    ds->solved = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->n = state->n;
@@ -1644,17 +1654,18 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 static void tile_redraw(drawing *dr, game_drawstate *ds, int x, int y,
                         int num, unsigned int f)
 {
-    int tcol, bg, dnum, cx, cy, tsz;
+    int tcol, bg, cx, cy, tsz;
+    bool dnum;
     char buf[32];
 
     if (f & DS_BLACK) {
         bg = (f & DS_ERROR) ? COL_ERROR : COL_BLACK;
         tcol = COL_BLACKNUM;
-        dnum = (f & DS_BLACK_NUM) ? 1 : 0;
+        dnum = (f & DS_BLACK_NUM);
     } else {
         bg = (f & DS_FLASH) ? COL_LOWLIGHT : COL_BACKGROUND;
         tcol = (f & DS_ERROR) ? COL_ERROR : COL_BLACK;
-        dnum = 1;
+        dnum = true;
     }
 
     cx = x + TILE_SIZE/2; cy = y + TILE_SIZE/2;
@@ -1729,7 +1740,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
             }
         }
     }
-    ds->started = 1;
+    ds->started = true;
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -1752,9 +1763,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1815,15 +1826,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1840,9 +1851,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -1867,14 +1878,15 @@ static void start_soak(game_params *p, random_state *rs)
 
     while (1) {
         n++;
-        desc = new_game_desc(p, rs, &aux, 0);
+        desc = new_game_desc(p, rs, &aux, false);
         s = new_game(NULL, p, desc);
         nsneaky += solve_sneaky(s, NULL);
 
         for (diff = 0; diff < DIFF_MAX; diff++) {
             memset(s->flags, 0, s->n * sizeof(unsigned int));
-            s->completed = s->impossible = 0;
-            sret = solve_specific(s, diff, 0);
+            s->completed = false;
+            s->impossible = false;
+            sret = solve_specific(s, diff, false);
             if (sret > 0) {
                 ndiff[diff]++;
                 break;
@@ -1911,7 +1923,8 @@ int main(int argc, char **argv)
     const char *err;
     game_state *s = NULL;
     game_params *p = NULL;
-    int soln, soak = 0, ret = 1;
+    int soln, ret = 1;
+    bool soak = false;
     time_t seed = time(NULL);
     random_state *rs = NULL;
 
@@ -1920,9 +1933,9 @@ int main(int argc, char **argv)
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            verbose = 1;
+            verbose = true;
         } else if (!strcmp(p, "--soak")) {
-            soak = 1;
+            soak = true;
         } else if (!strcmp(p, "--seed")) {
             if (argc == 0) {
                 fprintf(stderr, "%s: --seed needs an argument", argv[0]);
@@ -1949,7 +1962,7 @@ int main(int argc, char **argv)
 
     p = default_params();
     decode_params(p, id);
-    err = validate_params(p, 1);
+    err = validate_params(p, true);
     if (err) {
         fprintf(stderr, "%s: %s", argv[0], err);
         goto done;
@@ -1962,7 +1975,7 @@ int main(int argc, char **argv)
         }
         start_soak(p, rs);
     } else {
-        if (!desc) desc = desc_gen = new_game_desc(p, rs, &aux, 0);
+        if (!desc) desc = desc_gen = new_game_desc(p, rs, &aux, false);
 
         err = validate_desc(p, desc);
         if (err) {
@@ -1978,7 +1991,7 @@ int main(int argc, char **argv)
             sfree(tgame);
         }
 
-        soln = solve_specific(s, DIFF_ANY, 0);
+        soln = solve_specific(s, DIFF_ANY, false);
         tgame = game_text_format(s);
         fputs(tgame, stdout);
         sfree(tgame);
diff --git a/apps/plugins/puzzles/src/sixteen.c b/apps/plugins/puzzles/src/sixteen.c
index 6bba4c83b6..e47147a8a5 100644
--- a/apps/plugins/puzzles/src/sixteen.c
+++ b/apps/plugins/puzzles/src/sixteen.c
@@ -47,7 +47,7 @@ struct game_state {
     int w, h, n;
     int *tiles;
     int completed;
-    int used_solve;		       /* used to suppress completion flash */
+    bool used_solve;           /* used to suppress completion flash */
     int movecount, movetarget;
     int last_movement_sense;
 };
@@ -62,7 +62,7 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int w, h;
@@ -74,7 +74,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
       case 2: w = 4, h = 4; break;
       case 3: w = 5, h = 4; break;
       case 4: w = 5, h = 5; break;
-      default: return FALSE;
+      default: return false;
     }
 
     sprintf(buf, "%dx%d", w, h);
@@ -83,7 +83,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
     ret->w = w;
     ret->h = h;
     ret->movetarget = 0;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -117,7 +117,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -169,7 +169,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 2 || params->h < 2)
 	return "Width and height must both be at least two";
@@ -193,11 +193,12 @@ static int perm_parity(int *perm, int n)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int stop, n, i, x;
     int x1, x2, p1, p2;
-    int *tiles, *used;
+    int *tiles;
+    bool *used;
     char *ret;
     int retlen;
 
@@ -297,11 +298,11 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
     } else {
 
-	used = snewn(n, int);
+	used = snewn(n, bool);
 
 	for (i = 0; i < n; i++) {
 	    tiles[i] = -1;
-	    used[i] = FALSE;
+	    used[i] = false;
 	}
 
 	/*
@@ -325,7 +326,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 		    break;
 
 	    assert(j < n && !used[j]);
-	    used[j] = TRUE;
+	    used[j] = true;
 
 	    while (tiles[x] >= 0)
 		x++;
@@ -401,15 +402,15 @@ static const char *validate_desc(const game_params *params, const char *desc)
 {
     const char *p, *err;
     int i, area;
-    int *used;
+    bool *used;
 
     area = params->w * params->h;
     p = desc;
     err = NULL;
 
-    used = snewn(area, int);
+    used = snewn(area, bool);
     for (i = 0; i < area; i++)
-	used[i] = FALSE;
+	used[i] = false;
 
     for (i = 0; i < area; i++) {
 	const char *q = p;
@@ -438,7 +439,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
 	    err = "Number used twice";
 	    goto leave;
 	}
-	used[n-1] = TRUE;
+	used[n-1] = true;
 
 	if (*p) p++;		       /* eat comma */
     }
@@ -473,7 +474,7 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->completed = state->movecount = 0;
     state->movetarget = params->movetarget;
-    state->used_solve = FALSE;
+    state->used_solve = false;
     state->last_movement_sense = 0;
 
     return state;
@@ -509,9 +510,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -557,7 +558,7 @@ enum cursor_mode { unlocked, lock_tile, lock_position };
 
 struct game_ui {
     int cur_x, cur_y;
-    int cur_visible;
+    bool cur_visible;
     enum cursor_mode cur_mode;
 };
 
@@ -566,7 +567,7 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
     ui->cur_x = 0;
     ui->cur_y = 0;
-    ui->cur_visible = FALSE;
+    ui->cur_visible = false;
     ui->cur_mode = unlocked;
 
     return ui;
@@ -592,7 +593,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h, bgcolour;
     int *tiles;
     int tilesize;
@@ -605,14 +606,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     int cx = -1, cy = -1, dx, dy;
     char buf[80];
-    int shift = button & MOD_SHFT, control = button & MOD_CTRL,
-        pad = button & MOD_NUM_KEYPAD;
+    bool shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    int pad = button & MOD_NUM_KEYPAD;
 
     button &= ~MOD_MASK;
 
     if (IS_CURSOR_MOVE(button) || pad) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
 
@@ -621,9 +622,9 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             if (x < 0 || x >= state->w || y < 0 || y >= state->h)
                 return NULL;
             move_cursor(button | pad, &x, &y,
-                        state->w, state->h, FALSE);
+                        state->w, state->h, false);
             move_cursor(button | pad, &xwrap, &ywrap,
-                        state->w, state->h, TRUE);
+                        state->w, state->h, true);
 
             if (x != xwrap) {
                 sprintf(buf, "R%d,%c1", y, x ? '+' : '-');
@@ -644,7 +645,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             int x = ui->cur_x + 1, y = ui->cur_y + 1;
 
             move_cursor(button | pad, &x, &y,
-                        state->w + 2, state->h + 2, FALSE);
+                        state->w + 2, state->h + 2, false);
 
             if (x == 0 && y == 0) {
                 int t = ui->cur_x;
@@ -667,7 +668,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 ui->cur_y = y - 1;
             }
 
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
     }
@@ -675,7 +676,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
         cx = FROMCOORD(x);
         cy = FROMCOORD(y);
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
     } else if (IS_CURSOR_SELECT(button)) {
         if (ui->cur_visible) {
             if (ui->cur_x == -1 || ui->cur_x == state->w ||
@@ -689,7 +690,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 return UI_UPDATE;
             }
         } else {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
     } else {
@@ -740,7 +741,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	 */
 	for (i = 0; i < ret->n; i++)
 	    ret->tiles[i] = i+1;
-	ret->used_solve = TRUE;
+	ret->used_solve = true;
 	ret->completed = ret->movecount = 1;
 
 	return ret;
@@ -778,7 +779,7 @@ static game_state *execute_move(const game_state *from, const char *move)
         ret->completed = ret->movecount;
         for (n = 0; n < ret->n; n++)
             if (ret->tiles[n] != n+1)
-                ret->completed = FALSE;
+                ret->completed = 0;
     }
 
     return ret;
@@ -824,7 +825,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->bgcolour = COL_BACKGROUND;
@@ -879,7 +880,7 @@ static void draw_tile(drawing *dr, game_drawstate *ds,
 }
 
 static void draw_arrow(drawing *dr, game_drawstate *ds,
-                       int x, int y, int xdx, int xdy, int cur)
+                       int x, int y, int xdx, int xdy, bool cur)
 {
     int coords[14];
     int ydy = -xdx, ydx = xdy;
@@ -900,7 +901,7 @@ static void draw_arrow(drawing *dr, game_drawstate *ds,
 }
 
 static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
-                                  int cur_x, int cur_y, int cur)
+                                  int cur_x, int cur_y, bool cur)
 {
     if (cur_x == -1 && cur_y == -1)
         return; /* 'no cursur here */
@@ -966,15 +967,15 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
          * Arrows for making moves.
          */
         for (i = 0; i < state->w; i++) {
-            draw_arrow(dr, ds, COORD(i), COORD(0), +1, 0, 0);
-            draw_arrow(dr, ds, COORD(i+1), COORD(state->h), -1, 0, 0);
+            draw_arrow(dr, ds, COORD(i), COORD(0), +1, 0, false);
+            draw_arrow(dr, ds, COORD(i+1), COORD(state->h), -1, 0, false);
         }
         for (i = 0; i < state->h; i++) {
-            draw_arrow(dr, ds, COORD(state->w), COORD(i), 0, +1, 0);
-            draw_arrow(dr, ds, COORD(0), COORD(i+1), 0, -1, 0);
+            draw_arrow(dr, ds, COORD(state->w), COORD(i), 0, +1, false);
+            draw_arrow(dr, ds, COORD(0), COORD(i+1), 0, -1, false);
         }
 
-        ds->started = TRUE;
+        ds->started = true;
     }
     /*
      * Cursor (highlighted arrow around edge)
@@ -985,8 +986,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
     if (cur_x != ds->cur_x || cur_y != ds->cur_y) {
         /* Cursor has changed; redraw two (prev and curr) arrows. */
-        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1);
-        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0);
+        draw_arrow_for_cursor(dr, ds, cur_x, cur_y, true);
+        draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, false);
     }
 
     /*
@@ -1151,9 +1152,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1176,15 +1177,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1201,9 +1202,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/slant.c b/apps/plugins/puzzles/src/slant.c
index 5eeb66841c..70b2585b81 100644
--- a/apps/plugins/puzzles/src/slant.c
+++ b/apps/plugins/puzzles/src/slant.c
@@ -51,9 +51,9 @@ enum {
  */
 #if defined STANDALONE_SOLVER
 #define SOLVER_DIAGNOSTICS
-int verbose = FALSE;
+bool verbose = false;
 #elif defined SOLVER_DIAGNOSTICS
-#define verbose TRUE
+#define verbose true
 #endif
 
 /*
@@ -91,8 +91,8 @@ struct game_state {
     game_clues *clues;
     signed char *soln;
     unsigned char *errors;
-    int completed;
-    int used_solve;		       /* used to suppress completion flash */
+    bool completed;
+    bool used_solve;           /* used to suppress completion flash */
 };
 
 static game_params *default_params(void)
@@ -114,13 +114,13 @@ static const struct game_params slant_presets[] = {
     {12, 10, DIFF_HARD},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(slant_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = slant_presets[i];
@@ -129,7 +129,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -163,7 +163,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -213,7 +213,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * (At least at the time of writing this comment) The grid
@@ -253,7 +253,7 @@ struct solver_scratch {
      * Tracks whether each connected set of points includes a
      * border point.
      */
-    unsigned char *border;
+    bool *border;
 
     /*
      * Another disjoint set forest. This one tracks _squares_ which
@@ -308,7 +308,7 @@ static struct solver_scratch *new_scratch(int w, int h)
     struct solver_scratch *ret = snew(struct solver_scratch);
     ret->connected = snewn(W*H, int);
     ret->exits = snewn(W*H, int);
-    ret->border = snewn(W*H, unsigned char);
+    ret->border = snewn(W*H, bool);
     ret->equiv = snewn(w*h, int);
     ret->slashval = snewn(w*h, signed char);
     ret->vbitmap = snewn(w*h, unsigned char);
@@ -333,7 +333,8 @@ static void free_scratch(struct solver_scratch *sc)
 static void merge_vertices(int *connected,
 			   struct solver_scratch *sc, int i, int j)
 {
-    int exits = -1, border = FALSE;    /* initialise to placate optimiser */
+    int exits = -1;
+    bool border = false;    /* initialise to placate optimiser */
 
     if (sc) {
 	i = dsf_canonify(connected, i);
@@ -412,15 +413,15 @@ static void fill_square(int w, int h, int x, int y, int v,
     }
 }
 
-static int vbitmap_clear(int w, int h, struct solver_scratch *sc,
-                         int x, int y, int vbits, const char *reason, ...)
+static bool vbitmap_clear(int w, int h, struct solver_scratch *sc,
+                          int x, int y, int vbits, const char *reason, ...)
 {
-    int done_something = FALSE;
+    bool done_something = false;
     int vbit;
 
     for (vbit = 1; vbit <= 8; vbit <<= 1)
         if (vbits & sc->vbitmap[y*w+x] & vbit) {
-            done_something = TRUE;
+            done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
             if (verbose) {
                 va_list ap;
@@ -452,7 +453,7 @@ static int slant_solve(int w, int h, const signed char *clues,
 {
     int W = w+1, H = h+1;
     int x, y, i, j;
-    int done_something;
+    bool done_something;
 
     /*
      * Clear the output.
@@ -500,9 +501,9 @@ static int slant_solve(int w, int h, const signed char *clues,
     for (y = 0; y < H; y++)
 	for (x = 0; x < W; x++) {
 	    if (y == 0 || y == H-1 || x == 0 || x == W-1)
-		sc->border[y*W+x] = TRUE;
+		sc->border[y*W+x] = true;
 	    else
-		sc->border[y*W+x] = FALSE;
+		sc->border[y*W+x] = false;
 
 	    if (clues[y*W+x] < 0)
 		sc->exits[y*W+x] = 4;
@@ -514,7 +515,7 @@ static int slant_solve(int w, int h, const signed char *clues,
      * Repeatedly try to deduce something until we can't.
      */
     do {
-	done_something = FALSE;
+	done_something = false;
 
 	/*
 	 * Any clue point with the number of remaining lines equal
@@ -645,7 +646,7 @@ static int slant_solve(int w, int h, const signed char *clues,
 					sc->connected, sc);
 		    }
 
-		    done_something = TRUE;
+		    done_something = true;
 		} else if (nu == 2 && nl == 1 && difficulty > DIFF_EASY) {
 		    /*
 		     * If we have precisely two undecided squares
@@ -731,8 +732,8 @@ static int slant_solve(int w, int h, const signed char *clues,
 	 */
 	for (y = 0; y < h; y++)
 	    for (x = 0; x < w; x++) {
-		int fs, bs, v;
-		int c1, c2;
+		bool fs, bs;
+                int v, c1, c2;
 #ifdef SOLVER_DIAGNOSTICS
 		const char *reason = "<internal error>";
 #endif
@@ -740,8 +741,8 @@ static int slant_solve(int w, int h, const signed char *clues,
 		if (soln[y*w+x])
 		    continue;	       /* got this one already */
 
-		fs = FALSE;
-		bs = FALSE;
+		fs = false;
+		bs = false;
 
 		if (difficulty > DIFF_EASY)
 		    v = sc->slashval[dsf_canonify(sc->equiv, y*w+x)];
@@ -756,7 +757,7 @@ static int slant_solve(int w, int h, const signed char *clues,
 		c1 = dsf_canonify(sc->connected, y*W+x);
 		c2 = dsf_canonify(sc->connected, (y+1)*W+(x+1));
 		if (c1 == c2) {
-		    fs = TRUE;
+		    fs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "simple loop avoidance";
 #endif
@@ -764,13 +765,13 @@ static int slant_solve(int w, int h, const signed char *clues,
 		if (difficulty > DIFF_EASY &&
 		    !sc->border[c1] && !sc->border[c2] &&
 		    sc->exits[c1] <= 1 && sc->exits[c2] <= 1) {
-		    fs = TRUE;
+		    fs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "dead end avoidance";
 #endif
 		}
 		if (v == +1) {
-		    fs = TRUE;
+		    fs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "equivalence to an already filled square";
 #endif
@@ -783,7 +784,7 @@ static int slant_solve(int w, int h, const signed char *clues,
 		c1 = dsf_canonify(sc->connected, y*W+(x+1));
 		c2 = dsf_canonify(sc->connected, (y+1)*W+x);
 		if (c1 == c2) {
-		    bs = TRUE;
+		    bs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "simple loop avoidance";
 #endif
@@ -791,13 +792,13 @@ static int slant_solve(int w, int h, const signed char *clues,
 		if (difficulty > DIFF_EASY &&
 		    !sc->border[c1] && !sc->border[c2] &&
 		    sc->exits[c1] <= 1 && sc->exits[c2] <= 1) {
-		    bs = TRUE;
+		    bs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "dead end avoidance";
 #endif
 		}
 		if (v == -1) {
-		    bs = TRUE;
+		    bs = true;
 #ifdef SOLVER_DIAGNOSTICS
 		    reason = "equivalence to an already filled square";
 #endif
@@ -820,14 +821,14 @@ static int slant_solve(int w, int h, const signed char *clues,
 			printf("employing %s\n", reason);
 #endif
 		    fill_square(w, h, x, y, +1, soln, sc->connected, sc);
-		    done_something = TRUE;
+		    done_something = true;
 		} else if (bs) {
 #ifdef SOLVER_DIAGNOSTICS
 		    if (verbose)
 			printf("employing %s\n", reason);
 #endif
 		    fill_square(w, h, x, y, -1, soln, sc->connected, sc);
-		    done_something = TRUE;
+		    done_something = true;
 		}
 	    }
 
@@ -877,7 +878,7 @@ static int slant_solve(int w, int h, const signed char *clues,
                     if (dsf_canonify(sc->equiv, n1) !=
                         dsf_canonify(sc->equiv, n2)) {
                         dsf_merge(sc->equiv, n1, n2);
-                        done_something = TRUE;
+                        done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
                         if (verbose)
                             printf("(%d,%d) and (%d,%d) must be equivalent"
@@ -891,7 +892,7 @@ static int slant_solve(int w, int h, const signed char *clues,
                     if (dsf_canonify(sc->equiv, n1) !=
                         dsf_canonify(sc->equiv, n2)) {
                         dsf_merge(sc->equiv, n1, n2);
-                        done_something = TRUE;
+                        done_something = true;
 #ifdef SOLVER_DIAGNOSTICS
                         if (verbose)
                             printf("(%d,%d) and (%d,%d) must be equivalent"
@@ -1016,7 +1017,8 @@ static void slant_generate(int w, int h, signed char *soln, random_state *rs)
      * Fill in each one in turn.
      */
     for (i = 0; i < w*h; i++) {
-	int fs, bs, v;
+	bool fs, bs;
+        int v;
 
 	y = indices[i] / w;
 	x = indices[i] % w;
@@ -1060,7 +1062,7 @@ static void slant_generate(int w, int h, signed char *soln, random_state *rs)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, W = w+1, H = h+1;
     signed char *soln, *tmpsoln, *clues;
@@ -1119,7 +1121,8 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 	shuffle(clueindices, W*H, sizeof(*clueindices), rs);
 	for (j = 0; j < 2; j++) {
 	    for (i = 0; i < W*H; i++) {
-		int pass, yb, xb;
+		int pass;
+                bool yb, xb;
 
 		y = clueindices[i] / W;
 		x = clueindices[i] % W;
@@ -1248,7 +1251,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->p = *params;
     state->soln = snewn(w*h, signed char);
     memset(state->soln, 0, w*h);
-    state->completed = state->used_solve = FALSE;
+    state->completed = state->used_solve = false;
     state->errors = snewn(W*H, unsigned char);
     memset(state->errors, 0, W*H);
 
@@ -1319,7 +1322,7 @@ static void free_game(game_state *state)
  * squares that contributed to it.
  */
 static int vertex_degree(int w, int h, signed char *soln, int x, int y,
-                         int anti, int *sx, int *sy)
+                         bool anti, int *sx, int *sy)
 {
     int ret = 0;
 
@@ -1376,10 +1379,11 @@ static int slant_neighbour(int vertex, void *vctx)
         return -1;
 }
 
-static int check_completion(game_state *state)
+static bool check_completion(game_state *state)
 {
     int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
-    int x, y, err = FALSE;
+    int x, y;
+    bool err = false;
 
     memset(state->errors, 0, W*H);
 
@@ -1392,7 +1396,7 @@ static int check_completion(game_state *state)
         ctx.state = state;
 
         if (findloop_run(fls, W*H, slant_neighbour, &ctx))
-            err = TRUE;
+            err = true;
         for (y = 0; y < h; y++) {
             for (x = 0; x < w; x++) {
                 int u, v;
@@ -1430,11 +1434,11 @@ static int check_completion(game_state *state)
              * grounds for marking the vertex as erroneous.
              */
             if (vertex_degree(w, h, state->soln, x, y,
-                              FALSE, NULL, NULL) > c ||
+                              false, NULL, NULL) > c ||
                 vertex_degree(w, h, state->soln, x, y,
-                              TRUE, NULL, NULL) > 4-c) {
+                              true, NULL, NULL) > 4-c) {
                 state->errors[y*W+x] |= ERR_VERTEX;
-                err = TRUE;
+                err = true;
             }
         }
 
@@ -1445,14 +1449,14 @@ static int check_completion(game_state *state)
      */
 
     if (err)
-        return FALSE;
+        return false;
 
     for (y = 0; y < h; y++)
 	for (x = 0; x < w; x++)
 	    if (state->soln[y*w+x] == 0)
-		return FALSE;
+		return false;
 
-    return TRUE;
+    return true;
 }
 
 static char *solve_game(const game_state *state, const game_state *currstate,
@@ -1461,7 +1465,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     int w = state->p.w, h = state->p.h;
     signed char *soln;
     int bs, ret;
-    int free_soln = FALSE;
+    bool free_soln = false;
     char *move, buf[80];
     int movelen, movesize;
     int x, y;
@@ -1473,7 +1477,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 	 */
 	soln = (signed char *)aux;
 	bs = (signed char)'\\';
-	free_soln = FALSE;
+	free_soln = false;
     } else {
 	struct solver_scratch *sc = new_scratch(w, h);
 	soln = snewn(w*h, signed char);
@@ -1488,7 +1492,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 		*error = "Unable to find a unique solution for this puzzle";
             return NULL;
 	}
-	free_soln = TRUE;
+	free_soln = true;
     }
 
     /*
@@ -1520,9 +1524,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1568,13 +1572,15 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int cur_x, cur_y, cur_visible;
+    int cur_x, cur_y;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
-    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
+    ui->cur_x = ui->cur_y = 0;
+    ui->cur_visible = false;
     return ui;
 }
 
@@ -1632,7 +1638,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
 struct game_drawstate {
     int tilesize;
-    int started;
+    bool started;
     long *grid;
     long *todraw;
 };
@@ -1675,10 +1681,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         y = FROMCOORD(y);
         if (x < 0 || y < 0 || x >= w || y >= h)
             return NULL;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
         x = ui->cur_x;
@@ -1686,8 +1692,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         action = (button == CURSOR_SELECT2) ? ANTICLOCKWISE : CLOCKWISE;
     } else if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, 0);
-        ui->cur_visible = 1;
+        move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, false);
+        ui->cur_visible = true;
         return UI_UPDATE;
     } else if (button == '\\' || button == '\b' || button == '/') {
 	int x = ui->cur_x, y = ui->cur_y;
@@ -1730,7 +1736,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move;
 	if (c == 'S') {
-	    ret->used_solve = TRUE;
+	    ret->used_solve = true;
 	    move++;
 	} else if (c == '\\' || c == '/' || c == 'C') {
             move++;
@@ -1826,7 +1832,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
 
     ds->tilesize = 0;
-    ds->started = FALSE;
+    ds->started = false;
     ds->grid = snewn((w+2)*(h+2), long);
     ds->todraw = snewn((w+2)*(h+2), long);
     for (i = 0; i < (w+2)*(h+2); i++)
@@ -1843,7 +1849,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 }
 
 static void draw_clue(drawing *dr, game_drawstate *ds,
-		      int x, int y, long v, long err, int bg, int colour)
+		      int x, int y, long v, bool err, int bg, int colour)
 {
     char p[2];
     int ccol = colour >= 0 ? colour : ((x ^ y) & 1) ? COL_SLANT1 : COL_SLANT2;
@@ -1959,19 +1965,19 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 {
     int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
     int x, y;
-    int flashing;
+    bool flashing;
 
     if (flashtime > 0)
 	flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
     else
-	flashing = FALSE;
+	flashing = false;
 
     if (!ds->started) {
 	int ww, wh;
 	game_compute_size(&state->p, TILESIZE, &ww, &wh);
 	draw_rect(dr, 0, 0, ww, wh, COL_BACKGROUND);
 	draw_update(dr, 0, 0, ww, wh);
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     /*
@@ -1989,7 +1995,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
     for (y = 0; y < h; y++) {
 	for (x = 0; x < w; x++) {
-            int err = state->errors[y*W+x] & ERR_SQUARE;
+            bool err = state->errors[y*W+x] & ERR_SQUARE;
 
 	    if (state->soln[y*w+x] < 0) {
 		ds->todraw[(y+1)*(w+2)+(x+1)] |= BACKSLASH;
@@ -2063,9 +2069,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2136,7 +2142,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
     for (y = 0; y <= h; y++)
 	for (x = 0; x <= w; x++)
 	    draw_clue(dr, ds, x, y, state->clues->clues[y*W+x],
-		      FALSE, paper, ink);
+		      false, paper, ink);
 }
 
 #ifdef COMBINED
@@ -2151,15 +2157,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2176,9 +2182,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
@@ -2192,16 +2198,17 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
-    int ret, diff, really_verbose = FALSE;
+    bool grade = false;
+    int ret, diff;
+    bool really_verbose = false;
     struct solver_scratch *sc;
 
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            really_verbose = TRUE;
+            really_verbose = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
diff --git a/apps/plugins/puzzles/src/solo.c b/apps/plugins/puzzles/src/solo.c
index 69fd85b90b..cfe38c5bd9 100644
--- a/apps/plugins/puzzles/src/solo.c
+++ b/apps/plugins/puzzles/src/solo.c
@@ -146,9 +146,9 @@ enum {
 #define MAX_2SUMS 5
 #define MAX_3SUMS 8
 #define MAX_4SUMS 12
-unsigned long sum_bits2[18][MAX_2SUMS];
-unsigned long sum_bits3[25][MAX_3SUMS];
-unsigned long sum_bits4[31][MAX_4SUMS];
+static unsigned long sum_bits2[18][MAX_2SUMS];
+static unsigned long sum_bits3[25][MAX_3SUMS];
+static unsigned long sum_bits4[31][MAX_4SUMS];
 
 static int find_sum_bits(unsigned long *array, int idx, int value_left,
 			 int addends_left, int min_addend,
@@ -210,8 +210,8 @@ struct game_params {
      * compositeness - a 7x7 jigsaw sudoku makes perfect sense).
      */
     int c, r, symm, diff, kdiff;
-    int xtype;			       /* require all digits in X-diagonals */
-    int killer;
+    bool xtype;                /* require all digits in X-diagonals */
+    bool killer;
 };
 
 struct block_structure {
@@ -263,11 +263,11 @@ struct game_state {
     int cr;
     struct block_structure *blocks;
     struct block_structure *kblocks;   /* Blocks for killer puzzles.  */
-    int xtype, killer;
+    bool xtype, killer;
     digit *grid, *kgrid;
-    unsigned char *pencil;             /* c*r*c*r elements */
-    unsigned char *immutable;	       /* marks which digits are clues */
-    int completed, cheated;
+    bool *pencil;                      /* c*r*c*r elements */
+    bool *immutable;                   /* marks which digits are clues */
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -275,8 +275,8 @@ static game_params *default_params(void)
     game_params *ret = snew(game_params);
 
     ret->c = ret->r = 3;
-    ret->xtype = FALSE;
-    ret->killer = FALSE;
+    ret->xtype = false;
+    ret->killer = false;
     ret->symm = SYMM_ROT2;	       /* a plausible default */
     ret->diff = DIFF_BLOCK;	       /* so is this */
     ret->kdiff = DIFF_KINTERSECT;      /* so is this */
@@ -296,53 +296,53 @@ static game_params *dup_params(const game_params *params)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     static struct {
         const char *title;
         game_params params;
     } const presets[] = {
-        { "2x2 Trivial", { 2, 2, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, FALSE, FALSE } },
-        { "2x3 Basic", { 2, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Trivial", { 3, 3, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Basic", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Basic X", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, TRUE } },
-        { "3x3 Intermediate", { 3, 3, SYMM_ROT2, DIFF_INTERSECT, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Advanced", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Advanced X", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, TRUE } },
-        { "3x3 Extreme", { 3, 3, SYMM_ROT2, DIFF_EXTREME, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Unreasonable", { 3, 3, SYMM_ROT2, DIFF_RECURSIVE, DIFF_KMINMAX, FALSE, FALSE } },
-        { "3x3 Killer", { 3, 3, SYMM_NONE, DIFF_BLOCK, DIFF_KINTERSECT, FALSE, TRUE } },
-        { "9 Jigsaw Basic", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
-        { "9 Jigsaw Basic X", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, TRUE } },
-        { "9 Jigsaw Advanced", { 9, 1, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, FALSE, FALSE } },
+        { "2x2 Trivial", { 2, 2, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, false, false } },
+        { "2x3 Basic", { 2, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, false, false } },
+        { "3x3 Trivial", { 3, 3, SYMM_ROT2, DIFF_BLOCK, DIFF_KMINMAX, false, false } },
+        { "3x3 Basic", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, false, false } },
+        { "3x3 Basic X", { 3, 3, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, true } },
+        { "3x3 Intermediate", { 3, 3, SYMM_ROT2, DIFF_INTERSECT, DIFF_KMINMAX, false, false } },
+        { "3x3 Advanced", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, false, false } },
+        { "3x3 Advanced X", { 3, 3, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, true } },
+        { "3x3 Extreme", { 3, 3, SYMM_ROT2, DIFF_EXTREME, DIFF_KMINMAX, false, false } },
+        { "3x3 Unreasonable", { 3, 3, SYMM_ROT2, DIFF_RECURSIVE, DIFF_KMINMAX, false, false } },
+        { "3x3 Killer", { 3, 3, SYMM_NONE, DIFF_BLOCK, DIFF_KINTERSECT, false, true } },
+        { "9 Jigsaw Basic", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, false, false } },
+        { "9 Jigsaw Basic X", { 9, 1, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, true } },
+        { "9 Jigsaw Advanced", { 9, 1, SYMM_ROT2, DIFF_SET, DIFF_KMINMAX, false, false } },
 #ifndef SLOW_SYSTEM
-        { "3x4 Basic", { 3, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
-        { "4x4 Basic", { 4, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, FALSE, FALSE } },
+        { "3x4 Basic", { 3, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, false, false } },
+        { "4x4 Basic", { 4, 4, SYMM_ROT2, DIFF_SIMPLE, DIFF_KMINMAX, false, false } },
 #endif
     };
 
     if (i < 0 || i >= lenof(presets))
-        return FALSE;
+        return false;
 
     *name = dupstr(presets[i].title);
     *params = dup_params(&presets[i].params);
 
-    return TRUE;
+    return true;
 }
 
 static void decode_params(game_params *ret, char const *string)
 {
-    int seen_r = FALSE;
+    bool seen_r = false;
 
     ret->c = ret->r = atoi(string);
-    ret->xtype = FALSE;
-    ret->killer = FALSE;
+    ret->xtype = false;
+    ret->killer = false;
     while (*string && isdigit((unsigned char)*string)) string++;
     if (*string == 'x') {
         string++;
         ret->r = atoi(string);
-	seen_r = TRUE;
+	seen_r = true;
 	while (*string && isdigit((unsigned char)*string)) string++;
     }
     while (*string) {
@@ -353,18 +353,19 @@ static void decode_params(game_params *ret, char const *string)
 	    ret->r = 1;
 	} else if (*string == 'x') {
 	    string++;
-	    ret->xtype = TRUE;
+	    ret->xtype = true;
 	} else if (*string == 'k') {
 	    string++;
-	    ret->killer = TRUE;
+	    ret->killer = true;
 	} else if (*string == 'r' || *string == 'm' || *string == 'a') {
-            int sn, sc, sd;
+            int sn, sc;
+            bool sd;
             sc = *string++;
             if (sc == 'm' && *string == 'd') {
-                sd = TRUE;
+                sd = true;
                 string++;
             } else {
-                sd = FALSE;
+                sd = false;
             }
             sn = atoi(string);
             while (*string && isdigit((unsigned char)*string)) string++;
@@ -399,7 +400,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char str[80];
 
@@ -501,7 +502,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->c < 2)
 	return "Both dimensions must be at least 2";
@@ -708,13 +709,13 @@ struct solver_usage {
     struct block_structure *blocks, *kblocks, *extra_cages;
     /*
      * We set up a cubic array, indexed by x, y and digit; each
-     * element of this array is TRUE or FALSE according to whether
+     * element of this array is true or false according to whether
      * or not that digit _could_ in principle go in that position.
      *
      * The way to index this array is cube[(y*cr+x)*cr+n-1]; there
      * are macros below to help with this.
      */
-    unsigned char *cube;
+    bool *cube;
     /*
      * This is the grid in which we write down our final
      * deductions. y-coordinates in here are _not_ transformed.
@@ -730,14 +731,14 @@ struct solver_usage {
      * have yet to work out, to prevent doing the same deduction
      * many times.
      */
-    /* row[y*cr+n-1] TRUE if digit n has been placed in row y */
-    unsigned char *row;
-    /* col[x*cr+n-1] TRUE if digit n has been placed in row x */
-    unsigned char *col;
-    /* blk[i*cr+n-1] TRUE if digit n has been placed in block i */
-    unsigned char *blk;
-    /* diag[i*cr+n-1] TRUE if digit n has been placed in diagonal i */
-    unsigned char *diag;	       /* diag 0 is \, 1 is / */
+    /* row[y*cr+n-1] true if digit n has been placed in row y */
+    bool *row;
+    /* col[x*cr+n-1] true if digit n has been placed in row x */
+    bool *col;
+    /* blk[i*cr+n-1] true if digit n has been placed in block i */
+    bool *blk;
+    /* diag[i*cr+n-1] true if digit n has been placed in diagonal i */
+    bool *diag;                        /* diag 0 is \, 1 is / */
 
     int *regions;
     int nr_regions;
@@ -771,21 +772,21 @@ static void solver_place(struct solver_usage *usage, int x, int y, int n)
      */
     for (i = 1; i <= cr; i++)
 	if (i != n)
-	    cube(x,y,i) = FALSE;
+	    cube(x,y,i) = false;
 
     /*
      * Rule out this number in all other positions in the row.
      */
     for (i = 0; i < cr; i++)
 	if (i != y)
-	    cube(x,i,n) = FALSE;
+	    cube(x,i,n) = false;
 
     /*
      * Rule out this number in all other positions in the column.
      */
     for (i = 0; i < cr; i++)
 	if (i != x)
-	    cube(i,y,n) = FALSE;
+	    cube(i,y,n) = false;
 
     /*
      * Rule out this number in all other positions in the block.
@@ -794,7 +795,7 @@ static void solver_place(struct solver_usage *usage, int x, int y, int n)
     for (i = 0; i < cr; i++) {
 	int bp = usage->blocks->blocks[bi][i];
 	if (bp != sqindex)
-	    cube2(bp,n) = FALSE;
+	    cube2(bp,n) = false;
     }
 
     /*
@@ -807,20 +808,20 @@ static void solver_place(struct solver_usage *usage, int x, int y, int n)
      * in its row, its column and its block.
      */
     usage->row[y*cr+n-1] = usage->col[x*cr+n-1] =
-	usage->blk[bi*cr+n-1] = TRUE;
+	usage->blk[bi*cr+n-1] = true;
 
     if (usage->diag) {
 	if (ondiag0(sqindex)) {
 	    for (i = 0; i < cr; i++)
 		if (diag0(i) != sqindex)
-		    cube2(diag0(i),n) = FALSE;
-	    usage->diag[n-1] = TRUE;
+		    cube2(diag0(i),n) = false;
+	    usage->diag[n-1] = true;
 	}
 	if (ondiag1(sqindex)) {
 	    for (i = 0; i < cr; i++)
 		if (diag1(i) != sqindex)
-		    cube2(diag1(i),n) = FALSE;
-	    usage->diag[cr+n-1] = TRUE;
+		    cube2(diag1(i),n) = false;
+	    usage->diag[cr+n-1] = true;
 	}
     }
 }
@@ -968,7 +969,7 @@ static int solver_intersect(struct solver_usage *usage,
             }
 #endif
             ret = +1;		       /* we did something */
-            usage->cube[p] = 0;
+            usage->cube[p] = false;
         }
     }
 
@@ -1005,8 +1006,8 @@ static int solver_set(struct solver_usage *usage,
      * any row with a solitary 1 - and discarding that row and the
      * column containing the 1.
      */
-    memset(rowidx, TRUE, cr);
-    memset(colidx, TRUE, cr);
+    memset(rowidx, 1, cr);
+    memset(colidx, 1, cr);
     for (i = 0; i < cr; i++) {
         int count = 0, first = -1;
         for (j = 0; j < cr; j++)
@@ -1033,7 +1034,7 @@ static int solver_set(struct solver_usage *usage,
             return -1;
         }
         if (count == 1)
-            rowidx[i] = colidx[first] = FALSE;
+            rowidx[i] = colidx[first] = 0;
     }
 
     /*
@@ -1079,10 +1080,10 @@ static int solver_set(struct solver_usage *usage,
              */
             int rows = 0;
             for (i = 0; i < n; i++) {
-                int ok = TRUE;
+                bool ok = true;
                 for (j = 0; j < n; j++)
                     if (set[j] && grid[i*cr+j]) {
-                        ok = FALSE;
+                        ok = false;
                         break;
                     }
                 if (ok)
@@ -1114,7 +1115,7 @@ static int solver_set(struct solver_usage *usage,
 	    }
 
             if (rows >= n - count) {
-                int progress = FALSE;
+                bool progress = false;
 
                 /*
                  * We've got one! Now, for each row which _doesn't_
@@ -1128,10 +1129,10 @@ static int solver_set(struct solver_usage *usage,
                  * positions in the cube to meddle with.
                  */
                 for (i = 0; i < n; i++) {
-                    int ok = TRUE;
+                    bool ok = true;
                     for (j = 0; j < n; j++)
                         if (set[j] && grid[i*cr+j]) {
-                            ok = FALSE;
+                            ok = false;
                             break;
                         }
                     if (!ok) {
@@ -1162,8 +1163,8 @@ static int solver_set(struct solver_usage *usage,
                                            pn, 1+px, 1+py);
                                 }
 #endif
-                                progress = TRUE;
-                                usage->cube[fpos] = FALSE;
+                                progress = true;
+                                usage->cube[fpos] = false;
                             }
                     }
                 }
@@ -1386,7 +1387,7 @@ static int solver_forcing(struct solver_usage *usage,
                                            orign, 1+xt, 1+yt);
                                 }
 #endif
-                                cube(xt, yt, orign) = FALSE;
+                                cube(xt, yt, orign) = false;
                                 return 1;
                             }
                         }
@@ -1437,7 +1438,7 @@ static int solver_killer_minmax(struct solver_usage *usage,
 			}
 		}
 		if (maxval + n < clues[b]) {
-		    cube2(x, n) = FALSE;
+		    cube2(x, n) = false;
 		    ret = 1;
 #ifdef STANDALONE_SOLVER
 		    if (solver_show_working)
@@ -1447,7 +1448,7 @@ static int solver_killer_minmax(struct solver_usage *usage,
 #endif
 		}
 		if (minval + n > clues[b]) {
-		    cube2(x, n) = FALSE;
+		    cube2(x, n) = false;
 		    ret = 1;
 #ifdef STANDALONE_SOLVER
 		    if (solver_show_working)
@@ -1463,7 +1464,7 @@ static int solver_killer_minmax(struct solver_usage *usage,
 
 static int solver_killer_sums(struct solver_usage *usage, int b,
 			      struct block_structure *cages, int clue,
-			      int cage_is_region
+			      bool cage_is_region
 #ifdef STANDALONE_SOLVER
 			      , const char *cage_type
 #endif
@@ -1580,7 +1581,7 @@ static int solver_killer_sums(struct solver_usage *usage, int b,
 	    if (!cube2(x, n))
 		continue;
 	    if ((possible_addends & (1 << n)) == 0) {
-		cube2(x, n) = FALSE;
+		cube2(x, n) = false;
 		ret = 1;
 #ifdef STANDALONE_SOLVER
 		if (solver_show_working) {
@@ -1700,7 +1701,7 @@ struct difficulty {
 };
 
 static void solver(int cr, struct block_structure *blocks,
-		  struct block_structure *kblocks, int xtype,
+		  struct block_structure *kblocks, bool xtype,
 		  digit *grid, digit *kgrid, struct difficulty *dlev)
 {
     struct solver_usage *usage;
@@ -1725,7 +1726,7 @@ static void solver(int cr, struct block_structure *blocks,
 	usage->kblocks = usage->extra_cages = NULL;
 	usage->extra_clues = NULL;
     }
-    usage->cube = snewn(cr*cr*cr, unsigned char);
+    usage->cube = snewn(cr*cr*cr, bool);
     usage->grid = grid;		       /* write straight back to the input */
     if (kgrid) {
 	int nclues;
@@ -1748,18 +1749,19 @@ static void solver(int cr, struct block_structure *blocks,
 	usage->kclues = NULL;
     }
 
-    memset(usage->cube, TRUE, cr*cr*cr);
+    for (i = 0; i < cr*cr*cr; i++)
+        usage->cube[i] = true;
 
-    usage->row = snewn(cr * cr, unsigned char);
-    usage->col = snewn(cr * cr, unsigned char);
-    usage->blk = snewn(cr * cr, unsigned char);
-    memset(usage->row, FALSE, cr * cr);
-    memset(usage->col, FALSE, cr * cr);
-    memset(usage->blk, FALSE, cr * cr);
+    usage->row = snewn(cr * cr, bool);
+    usage->col = snewn(cr * cr, bool);
+    usage->blk = snewn(cr * cr, bool);
+    memset(usage->row, 0, cr * cr * sizeof(bool));
+    memset(usage->col, 0, cr * cr * sizeof(bool));
+    memset(usage->blk, 0, cr * cr * sizeof(bool));
 
     if (xtype) {
-	usage->diag = snewn(cr * 2, unsigned char);
-	memset(usage->diag, FALSE, cr * 2);
+	usage->diag = snewn(cr * 2, bool);
+	memset(usage->diag, 0, cr * 2 * sizeof(bool));
     } else
 	usage->diag = NULL; 
 
@@ -1840,7 +1842,7 @@ static void solver(int cr, struct block_structure *blocks,
 		}
 
 	if (usage->kclues != NULL) {
-	    int changed = FALSE;
+	    bool changed = false;
 
 	    /*
 	     * First, bring the kblocks into a more useful form: remove
@@ -1866,7 +1868,7 @@ static void solver(int cr, struct block_structure *blocks,
 		     * about the other squares in the cage.
 		     */
 		    for (n = 0; n < usage->kblocks->nr_squares[b]; n++) {
-			cube2(usage->kblocks->blocks[b][n], t) = FALSE;
+			cube2(usage->kblocks->blocks[b][n], t) = false;
 		    }
 		}
 
@@ -1897,7 +1899,7 @@ static void solver(int cr, struct block_structure *blocks,
 			       v, 1 + x%cr, 1 + x/cr);
 		    }
 #endif
-		    changed = TRUE;
+		    changed = true;
 		}
 	    }
 
@@ -1907,7 +1909,7 @@ static void solver(int cr, struct block_structure *blocks,
 	    }
 	}
 	if (dlev->maxkdiff >= DIFF_KINTERSECT && usage->kclues != NULL) {
-	    int changed = FALSE;
+	    bool changed = false;
 	    /*
 	     * Now, create the extra_cages information.  Every full region
 	     * (row, column, or block) has the same sum total (45 for 3x3
@@ -1952,7 +1954,7 @@ static void solver(int cr, struct block_structure *blocks,
 			    goto got_result;
 			}
 			solver_place(usage, x, y, sum);
-			changed = TRUE;
+			changed = true;
 #ifdef STANDALONE_SOLVER
 			if (solver_show_working) {
 			    printf("%*s  placing %d at (%d,%d)\n",
@@ -1996,7 +1998,7 @@ static void solver(int cr, struct block_structure *blocks,
 	 * implement it for a higher difficulty level.
 	 */
 	if (dlev->maxkdiff >= DIFF_KMINMAX && usage->kclues != NULL) {
-	    int changed = FALSE;
+	    bool changed = false;
 	    for (b = 0; b < usage->kblocks->nr_blocks; b++) {
 		int ret = solver_killer_minmax(usage, usage->kblocks,
 					       usage->kclues, b
@@ -2008,7 +2010,7 @@ static void solver(int cr, struct block_structure *blocks,
 		    diff = DIFF_IMPOSSIBLE;
 		    goto got_result;
 		} else if (ret > 0)
-		    changed = TRUE;
+		    changed = true;
 	    }
 	    for (b = 0; b < usage->extra_cages->nr_blocks; b++) {
 		int ret = solver_killer_minmax(usage, usage->extra_cages,
@@ -2021,7 +2023,7 @@ static void solver(int cr, struct block_structure *blocks,
 		    diff = DIFF_IMPOSSIBLE;
 		    goto got_result;
 		} else if (ret > 0)
-		    changed = TRUE;
+		    changed = true;
 	    }
 	    if (changed) {
 		kdiff = max(kdiff, DIFF_KMINMAX);
@@ -2035,17 +2037,17 @@ static void solver(int cr, struct block_structure *blocks,
 	 * This can only be used if a cage lies entirely within a region.
 	 */
 	if (dlev->maxkdiff >= DIFF_KSUMS && usage->kclues != NULL) {
-	    int changed = FALSE;
+	    bool changed = false;
 
 	    for (b = 0; b < usage->kblocks->nr_blocks; b++) {
 		int ret = solver_killer_sums(usage, b, usage->kblocks,
-					     usage->kclues[b], TRUE
+					     usage->kclues[b], true
 #ifdef STANDALONE_SOLVER
 					     , "regular clues"
 #endif
 					     );
 		if (ret > 0) {
-		    changed = TRUE;
+		    changed = true;
 		    kdiff = max(kdiff, DIFF_KSUMS);
 		} else if (ret < 0) {
 		    diff = DIFF_IMPOSSIBLE;
@@ -2055,13 +2057,13 @@ static void solver(int cr, struct block_structure *blocks,
 
 	    for (b = 0; b < usage->extra_cages->nr_blocks; b++) {
 		int ret = solver_killer_sums(usage, b, usage->extra_cages,
-					     usage->extra_clues[b], FALSE
+					     usage->extra_clues[b], false
 #ifdef STANDALONE_SOLVER
 					     , "deduced clues"
 #endif
 					     );
 		if (ret > 0) {
-		    changed = TRUE;
+		    changed = true;
 		    kdiff = max(kdiff, DIFF_KSUMS);
 		} else if (ret < 0) {
 		    diff = DIFF_IMPOSSIBLE;
@@ -2754,10 +2756,11 @@ static void gridgen_remove(struct gridgen_usage *usage, int x, int y, digit n)
  * Return values: 1 means solution found, 0 means no solution
  * found on this branch.
  */
-static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
+static bool gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
 {
     int cr = usage->cr;
-    int i, j, n, sx, sy, bestm, bestr, ret;
+    int i, j, n, sx, sy, bestm, bestr;
+    bool ret;
     int *digits;
     unsigned int used;
 
@@ -2766,13 +2769,13 @@ static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
      * in the grid, we have a solution.
      */
     if (usage->nspaces == 0)
-	return TRUE;
+	return true;
 
     /*
      * Next, abandon generation if we went over our steps limit.
      */
     if (*steps <= 0)
-	return FALSE;
+	return false;
     (*steps)--;
 
     /*
@@ -2850,7 +2853,7 @@ static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
 	shuffle(digits, j, sizeof(*digits), usage->rs);
 
     /* And finally, go through the digit list and actually recurse. */
-    ret = FALSE;
+    ret = false;
     for (i = 0; i < j; i++) {
 	n = digits[i];
 
@@ -2860,7 +2863,7 @@ static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
 
 	/* Call the solver recursively. Stop when we find a solution. */
 	if (gridgen_real(usage, grid, steps)) {
-            ret = TRUE;
+            ret = true;
 	    break;
 	}
 
@@ -2877,12 +2880,13 @@ static int gridgen_real(struct gridgen_usage *usage, digit *grid, int *steps)
  * Entry point to generator. You give it parameters and a starting
  * grid, which is simply an array of cr*cr digits.
  */
-static int gridgen(int cr, struct block_structure *blocks,
-		   struct block_structure *kblocks, int xtype,
-		   digit *grid, random_state *rs, int maxsteps)
+static bool gridgen(int cr, struct block_structure *blocks,
+                    struct block_structure *kblocks, bool xtype,
+                    digit *grid, random_state *rs, int maxsteps)
 {
     struct gridgen_usage *usage;
-    int x, y, ret;
+    int x, y;
+    bool ret;
 
     /*
      * Clear the grid to start with.
@@ -2905,7 +2909,7 @@ static int gridgen(int cr, struct block_structure *blocks,
     if (kblocks != NULL) {
 	usage->kblocks = kblocks;
 	usage->cge = snewn(usage->kblocks->nr_blocks, unsigned int);
-	memset(usage->cge, FALSE, kblocks->nr_blocks * sizeof *usage->cge);
+	memset(usage->cge, 0, kblocks->nr_blocks * sizeof *usage->cge);
     } else {
 	usage->cge = NULL;
     }
@@ -3011,27 +3015,27 @@ static int check_killer_cage_sum(struct block_structure *kblocks,
 /*
  * Check whether a grid contains a valid complete puzzle.
  */
-static int check_valid(int cr, struct block_structure *blocks,
-		       struct block_structure *kblocks,
-                       digit *kgrid, int xtype, digit *grid)
+static bool check_valid(int cr, struct block_structure *blocks,
+                        struct block_structure *kblocks,
+                        digit *kgrid, bool xtype, digit *grid)
 {
-    unsigned char *used;
+    bool *used;
     int x, y, i, j, n;
 
-    used = snewn(cr, unsigned char);
+    used = snewn(cr, bool);
 
     /*
      * Check that each row contains precisely one of everything.
      */
     for (y = 0; y < cr; y++) {
-	memset(used, FALSE, cr);
+	memset(used, 0, cr * sizeof(bool));
 	for (x = 0; x < cr; x++)
 	    if (grid[y*cr+x] > 0 && grid[y*cr+x] <= cr)
-		used[grid[y*cr+x]-1] = TRUE;
+		used[grid[y*cr+x]-1] = true;
 	for (n = 0; n < cr; n++)
 	    if (!used[n]) {
 		sfree(used);
-		return FALSE;
+		return false;
 	    }
     }
 
@@ -3039,14 +3043,14 @@ static int check_valid(int cr, struct block_structure *blocks,
      * Check that each column contains precisely one of everything.
      */
     for (x = 0; x < cr; x++) {
-	memset(used, FALSE, cr);
+	memset(used, 0, cr * sizeof(bool));
 	for (y = 0; y < cr; y++)
 	    if (grid[y*cr+x] > 0 && grid[y*cr+x] <= cr)
-		used[grid[y*cr+x]-1] = TRUE;
+		used[grid[y*cr+x]-1] = true;
 	for (n = 0; n < cr; n++)
 	    if (!used[n]) {
 		sfree(used);
-		return FALSE;
+		return false;
 	    }
     }
 
@@ -3054,15 +3058,15 @@ static int check_valid(int cr, struct block_structure *blocks,
      * Check that each block contains precisely one of everything.
      */
     for (i = 0; i < cr; i++) {
-	memset(used, FALSE, cr);
+	memset(used, 0, cr * sizeof(bool));
 	for (j = 0; j < cr; j++)
 	    if (grid[blocks->blocks[i][j]] > 0 &&
 		grid[blocks->blocks[i][j]] <= cr)
-		used[grid[blocks->blocks[i][j]]-1] = TRUE;
+		used[grid[blocks->blocks[i][j]]-1] = true;
 	for (n = 0; n < cr; n++)
 	    if (!used[n]) {
 		sfree(used);
-		return FALSE;
+		return false;
 	    }
     }
 
@@ -3074,20 +3078,20 @@ static int check_valid(int cr, struct block_structure *blocks,
      */
     if (kblocks) {
 	for (i = 0; i < kblocks->nr_blocks; i++) {
-	    memset(used, FALSE, cr);
+            memset(used, 0, cr * sizeof(bool));
 	    for (j = 0; j < kblocks->nr_squares[i]; j++)
 		if (grid[kblocks->blocks[i][j]] > 0 &&
 		    grid[kblocks->blocks[i][j]] <= cr) {
 		    if (used[grid[kblocks->blocks[i][j]]-1]) {
 			sfree(used);
-			return FALSE;
+			return false;
 		    }
-		    used[grid[kblocks->blocks[i][j]]-1] = TRUE;
+		    used[grid[kblocks->blocks[i][j]]-1] = true;
 		}
 
             if (kgrid && check_killer_cage_sum(kblocks, kgrid, grid, i) != 1) {
                 sfree(used);
-                return FALSE;
+                return false;
             }
 	}
     }
@@ -3096,29 +3100,29 @@ static int check_valid(int cr, struct block_structure *blocks,
      * Check that each diagonal contains precisely one of everything.
      */
     if (xtype) {
-	memset(used, FALSE, cr);
+        memset(used, 0, cr * sizeof(bool));
 	for (i = 0; i < cr; i++)
 	    if (grid[diag0(i)] > 0 && grid[diag0(i)] <= cr)
-		used[grid[diag0(i)]-1] = TRUE;
+		used[grid[diag0(i)]-1] = true;
 	for (n = 0; n < cr; n++)
 	    if (!used[n]) {
 		sfree(used);
-		return FALSE;
+		return false;
 	    }
 
-	memset(used, FALSE, cr);
+        memset(used, 0, cr * sizeof(bool));
 	for (i = 0; i < cr; i++)
 	    if (grid[diag1(i)] > 0 && grid[diag1(i)] <= cr)
-		used[grid[diag1(i)]-1] = TRUE;
+		used[grid[diag1(i)]-1] = true;
 	for (n = 0; n < cr; n++)
 	    if (!used[n]) {
 		sfree(used);
-		return FALSE;
+		return false;
 	    }
     }
 
     sfree(used);
-    return TRUE;
+    return true;
 }
 
 static int symmetries(const game_params *params, int x, int y,
@@ -3273,10 +3277,11 @@ static char *encode_block_structure_desc(char *p, struct block_structure *blocks
      * etc).
      */
     for (i = 0; i <= 2*cr*(cr-1); i++) {
-	int x, y, p0, p1, edge;
+	int x, y, p0, p1;
+        bool edge;
 
 	if (i == 2*cr*(cr-1)) {
-	    edge = TRUE;       /* terminating virtual edge */
+	    edge = true;       /* terminating virtual edge */
 	} else {
 	    if (i < cr*(cr-1)) {
 		y = i/(cr-1);
@@ -3430,7 +3435,7 @@ static void merge_blocks(struct block_structure *b, int n1, int n2)
     b->nr_blocks = n1;
 }
 
-static int merge_some_cages(struct block_structure *b, int cr, int area,
+static bool merge_some_cages(struct block_structure *b, int cr, int area,
 			     digit *grid, random_state *rs)
 {
     /*
@@ -3510,11 +3515,11 @@ static int merge_some_cages(struct block_structure *b, int cr, int area,
 	 */
 	merge_blocks(b, n1, n2);
 	sfree(pairs);
-	return TRUE;
+	return true;
     }
 
     sfree(pairs);
-    return FALSE;
+    return false;
 }
 
 static void compute_kclues(struct block_structure *cages, digit *kclues,
@@ -3536,7 +3541,7 @@ static void compute_kclues(struct block_structure *cages, digit *kclues,
 }
 
 static struct block_structure *gen_killer_cages(int cr, random_state *rs,
-						int remove_singletons)
+						bool remove_singletons)
 {
     int nr;
     int x, y, area = cr * cr;
@@ -3629,7 +3634,7 @@ static key_label *game_request_keys(const game_params *params, int *nkeys)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int c = params->c, r = params->r, cr = c*r;
     int area = cr*cr;
@@ -3908,7 +3913,8 @@ static const char *spec_to_dsf(const char **pdesc, int **pdsf,
     *pdsf = dsf = snew_dsf(area);
 
     while (*desc && *desc != ',') {
-	int c, adv;
+	int c;
+        bool adv;
 
 	if (*desc == '_')
 	    c = 0;
@@ -4132,10 +4138,10 @@ static game_state *new_game(midend *me, const game_params *params,
     state->killer = params->killer;
 
     state->grid = snewn(area, digit);
-    state->pencil = snewn(area * cr, unsigned char);
-    memset(state->pencil, 0, area * cr);
-    state->immutable = snewn(area, unsigned char);
-    memset(state->immutable, FALSE, area);
+    state->pencil = snewn(area * cr, bool);
+    memset(state->pencil, 0, area * cr * sizeof(bool));
+    state->immutable = snewn(area, bool);
+    memset(state->immutable, 0, area * sizeof(bool));
 
     state->blocks = alloc_block_structure (c, r, area, cr, cr);
 
@@ -4146,12 +4152,12 @@ static game_state *new_game(midend *me, const game_params *params,
 	state->kblocks = NULL;
 	state->kgrid = NULL;
     }
-    state->completed = state->cheated = FALSE;
+    state->completed = state->cheated = false;
 
     desc = spec_to_grid(desc, state->grid, area);
     for (i = 0; i < area; i++)
 	if (state->grid[i] != 0)
-	    state->immutable[i] = TRUE;
+	    state->immutable[i] = true;
 
     if (r == 1) {
 	const char *err;
@@ -4246,11 +4252,11 @@ static game_state *dup_game(const game_state *state)
     } else
 	ret->kgrid = NULL;
 
-    ret->pencil = snewn(area * cr, unsigned char);
-    memcpy(ret->pencil, state->pencil, area * cr);
+    ret->pencil = snewn(area * cr, bool);
+    memcpy(ret->pencil, state->pencil, area * cr * sizeof(bool));
 
-    ret->immutable = snewn(area, unsigned char);
-    memcpy(ret->immutable, state->immutable, area);
+    ret->immutable = snewn(area, bool);
+    memcpy(ret->immutable, state->immutable, area * sizeof(bool));
 
     ret->completed = state->completed;
     ret->cheated = state->cheated;
@@ -4313,7 +4319,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 }
 
 static char *grid_text_format(int cr, struct block_structure *blocks,
-			      int xtype, digit *grid)
+			      bool xtype, digit *grid)
 {
     int vmod, hmod;
     int x, y;
@@ -4499,7 +4505,7 @@ static char *grid_text_format(int cr, struct block_structure *blocks,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     /*
      * Formatting Killer puzzles as text is currently unsupported. I
@@ -4508,8 +4514,8 @@ static int game_can_format_as_text_now(const game_params *params)
      * it unusable.
      */
     if (params->killer)
-        return FALSE;
-    return TRUE;
+        return false;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -4529,21 +4535,21 @@ struct game_ui {
      * This indicates whether the current highlight is a
      * pencil-mark one or a real one.
      */
-    int hpencil;
+    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
+     * fixed position. When hshow is true, pressing a valid number
      * or letter key or Space will enter that number or letter in the grid.
      */
-    int hshow;
+    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.
      */
-    int hcursor;
+    bool hcursor;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -4551,7 +4557,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
 
     return ui;
 }
@@ -4582,13 +4590,13 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      */
     if (ui->hshow && ui->hpencil && !ui->hcursor &&
         newstate->grid[ui->hy * cr + ui->hx] != 0) {
-        ui->hshow = 0;
+        ui->hshow = false;
     }
 }
 
 struct game_drawstate {
-    int started;
-    int cr, xtype;
+    bool started, xtype;
+    int cr;
     int tilesize;
     digit *grid;
     unsigned char *pencil;
@@ -4613,17 +4621,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (tx >= 0 && tx < cr && ty >= 0 && ty < cr) {
         if (button == LEFT_BUTTON) {
             if (state->immutable[ty*cr+tx]) {
-                ui->hshow = 0;
+                ui->hshow = false;
             } else if (tx == ui->hx && ty == ui->hy &&
-                       ui->hshow && ui->hpencil == 0) {
-                ui->hshow = 0;
+                       ui->hshow && !ui->hpencil) {
+                ui->hshow = false;
             } else {
                 ui->hx = tx;
                 ui->hy = ty;
-                ui->hshow = 1;
-                ui->hpencil = 0;
+                ui->hshow = true;
+                ui->hpencil = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
         if (button == RIGHT_BUTTON) {
@@ -4633,29 +4641,30 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             if (state->grid[ty*cr+tx] == 0) {
                 if (tx == ui->hx && ty == ui->hy &&
                     ui->hshow && ui->hpencil) {
-                    ui->hshow = 0;
+                    ui->hshow = false;
                 } else {
-                    ui->hpencil = 1;
+                    ui->hpencil = true;
                     ui->hx = tx;
                     ui->hy = ty;
-                    ui->hshow = 1;
+                    ui->hshow = true;
                 }
             } else {
-                ui->hshow = 0;
+                ui->hshow = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
     }
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->hx, &ui->hy, cr, cr, 0);
-        ui->hshow = ui->hcursor = 1;
+        move_cursor(button, &ui->hx, &ui->hy, cr, cr, false);
+        ui->hshow = true;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
     if (ui->hshow &&
         (button == CURSOR_SELECT)) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
@@ -4689,7 +4698,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	sprintf(buf, "%c%d,%d,%d",
 		(char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
 
-        if (!ui->hcursor) ui->hshow = 0;
+        if (!ui->hcursor) ui->hshow = false;
 
 	return dupstr(buf);
     }
@@ -4710,7 +4719,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	const char *p;
 
 	ret = dup_game(from);
-	ret->completed = ret->cheated = TRUE;
+	ret->completed = ret->cheated = true;
 
 	p = move+1;
 	for (n = 0; n < cr*cr; n++) {
@@ -4745,7 +4754,7 @@ static game_state *execute_move(const game_state *from, const char *move)
             if (!ret->completed && check_valid(
                     cr, ret->blocks, ret->kblocks, ret->kgrid,
                     ret->xtype, ret->grid)) {
-                ret->completed = TRUE;
+                ret->completed = true;
             }
         }
 	return ret;
@@ -4759,7 +4768,9 @@ static game_state *execute_move(const game_state *from, const char *move)
         for (y = 0; y < cr; y++) {
             for (x = 0; x < cr; x++) {
                 if (!ret->grid[y*cr+x]) {
-                    memset(ret->pencil + (y*cr+x)*cr, 1, cr);
+                    int i;
+                    for (i = 0; i < cr; i++)
+                        ret->pencil[(y*cr+x)*cr + i] = true;
                 }
             }
         }
@@ -4839,7 +4850,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int cr = state->cr;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->cr = cr;
     ds->xtype = state->xtype;
     ds->grid = snewn(cr*cr, digit);
@@ -4938,7 +4949,8 @@ static void draw_number(drawing *dr, game_drawstate *ds,
 	int t = GRIDEXTRA * 3;
 	int kcx, kcy, kcw, kch;
 	int kl, kt, kr, kb;
-	int has_left = 0, has_right = 0, has_top = 0, has_bottom = 0;
+	bool has_left = false, has_right = false;
+        bool has_top = false, has_bottom = false;
 
 	/*
 	 * In non-jigsaw mode, the Killer cages are placed at a
@@ -4971,13 +4983,13 @@ static void draw_number(drawing *dr, game_drawstate *ds,
 	 * different areas.
 	 */
 	if (x == 0 || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[y*cr+x-1])
-	    has_left = 1, kl += t;
+	    has_left = true, kl += t;
 	if (x+1 >= cr || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[y*cr+x+1])
-	    has_right = 1, kr -= t;
+	    has_right = true, kr -= t;
 	if (y == 0 || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y-1)*cr+x])
-	    has_top = 1, kt += t;
+	    has_top = true, kt += t;
 	if (y+1 >= cr || state->kblocks->whichblock[y*cr+x] != state->kblocks->whichblock[(y+1)*cr+x])
-	    has_bottom = 1, kb -= t;
+	    has_bottom = true, kb -= t;
 	if (has_top)
 	    draw_line(dr, kl, kt, kr, kt, col_killer);
 	if (has_bottom)
@@ -5266,7 +5278,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      */
     if (!ds->started) {
 	draw_update(dr, 0, 0, SIZE(cr), SIZE(cr));
-	ds->started = TRUE;
+	ds->started = true;
     }
 }
 
@@ -5290,11 +5302,11 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
-	return FALSE;
-    return TRUE;
+	return false;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -5538,10 +5550,10 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
      */
     if (state->kblocks) {
 	print_line_width(dr, TILE_SIZE / 40);
-	print_line_dotted(dr, TRUE);
+	print_line_dotted(dr, true);
 	outline_block_structure(dr, ds, state, state->kblocks, ink,
 				5 * TILE_SIZE / 40);
-	print_line_dotted(dr, FALSE);
+	print_line_dotted(dr, false);
 	for (y = 0; y < cr; y++)
 	    for (x = 0; x < cr; x++)
 		if (state->kgrid[y*cr+x]) {
@@ -5586,15 +5598,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -5611,9 +5623,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
 };
 
@@ -5625,15 +5637,15 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
+    bool grade = false;
     struct difficulty dlev;
 
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            solver_show_working = TRUE;
+            solver_show_working = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
diff --git a/apps/plugins/puzzles/src/tdq.c b/apps/plugins/puzzles/src/tdq.c
index d66f9f4a83..cf2535c744 100644
--- a/apps/plugins/puzzles/src/tdq.c
+++ b/apps/plugins/puzzles/src/tdq.c
@@ -30,7 +30,7 @@ struct tdq {
     int n;
     int *queue;
     int ip, op;                        /* in pointer, out pointer */
-    char *flags;
+    bool *flags;
 };
 
 tdq *tdq_new(int n)
@@ -38,10 +38,10 @@ tdq *tdq_new(int n)
     int i;
     tdq *tdq = snew(struct tdq);
     tdq->queue = snewn(n, int);
-    tdq->flags = snewn(n, char);
+    tdq->flags = snewn(n, bool);
     for (i = 0; i < n; i++) {
         tdq->queue[i] = 0;
-        tdq->flags[i] = 0;
+        tdq->flags[i] = false;
     }
     tdq->n = n;
     tdq->ip = tdq->op = 0;
@@ -60,7 +60,7 @@ void tdq_add(tdq *tdq, int k)
     assert((unsigned)k < (unsigned)tdq->n);
     if (!tdq->flags[k]) {
         tdq->queue[tdq->ip] = k;
-        tdq->flags[k] = 1;
+        tdq->flags[k] = true;
         if (++tdq->ip == tdq->n)
             tdq->ip = 0;
     }
@@ -73,7 +73,7 @@ int tdq_remove(tdq *tdq)
     if (!tdq->flags[ret])
         return -1;
 
-    tdq->flags[ret] = 0;
+    tdq->flags[ret] = false;
     if (++tdq->op == tdq->n)
         tdq->op = 0;
 
diff --git a/apps/plugins/puzzles/src/tents.c b/apps/plugins/puzzles/src/tents.c
index 2f0977efbe..1e601f5836 100644
--- a/apps/plugins/puzzles/src/tents.c
+++ b/apps/plugins/puzzles/src/tents.c
@@ -229,9 +229,9 @@
  */
 #if defined STANDALONE_SOLVER
 #define SOLVER_DIAGNOSTICS
-int verbose = FALSE;
+bool verbose = false;
 #elif defined SOLVER_DIAGNOSTICS
-#define verbose TRUE
+#define verbose true
 #endif
 
 /*
@@ -279,7 +279,7 @@ struct game_state {
     game_params p;
     char *grid;
     struct numbers *numbers;
-    int completed, used_solve;
+    bool completed, used_solve;
 };
 
 static game_params *default_params(void)
@@ -301,13 +301,13 @@ static const struct game_params tents_presets[] = {
     {15, 15, DIFF_TRICKY},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(tents_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = tents_presets[i];
@@ -316,7 +316,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -350,7 +350,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[120];
 
@@ -400,7 +400,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Generating anything under 4x4 runs into trouble of one kind
@@ -471,7 +471,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
      * Main solver loop.
      */
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 
 	/*
 	 * Any tent which has only one unattached tree adjacent to
@@ -512,7 +512,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 
 			sc->links[y*w+x] = linkd;
 			sc->links[y2*w+x2] = F(linkd);
-			done_something = TRUE;
+			done_something = true;
 		    }
 		}
 
@@ -528,14 +528,14 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 	for (y = 0; y < h; y++)
 	    for (x = 0; x < w; x++)
 		if (soln[y*w+x] == BLANK) {
-		    int can_be_tent = FALSE;
+		    bool can_be_tent = false;
 
 		    for (d = 1; d < MAXDIR; d++) {
 			int x2 = x + dx(d), y2 = y + dy(d);
 			if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
 			    soln[y2*w+x2] == TREE &&
 			    !sc->links[y2*w+x2])
-			    can_be_tent = TRUE;
+			    can_be_tent = true;
 		    }
 
 		    if (!can_be_tent) {
@@ -545,7 +545,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 				   " unmatched tree)\n", x, y);
 #endif
 			soln[y*w+x] = NONTENT;
-			done_something = TRUE;
+			done_something = true;
 		    }
 		}
 
@@ -559,7 +559,8 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 	for (y = 0; y < h; y++)
 	    for (x = 0; x < w; x++)
 		if (soln[y*w+x] == BLANK) {
-		    int dx, dy, imposs = FALSE;
+		    int dx, dy;
+                    bool imposs = false;
 
 		    for (dy = -1; dy <= +1; dy++)
 			for (dx = -1; dx <= +1; dx++)
@@ -567,7 +568,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 				int x2 = x + dx, y2 = y + dy;
 				if (x2 >= 0 && x2 < w && y2 >= 0 && y2 < h &&
 				    soln[y2*w+x2] == TENT)
-				    imposs = TRUE;
+				    imposs = true;
 			    }
 
 		    if (imposs) {
@@ -577,7 +578,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 				   x, y);
 #endif
 			soln[y*w+x] = NONTENT;
-			done_something = TRUE;
+			done_something = true;
 		    }
 		}
 
@@ -625,7 +626,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 			soln[y2*w+x2] = TENT;
 			sc->links[y*w+x] = linkd;
 			sc->links[y2*w+x2] = F(linkd);
-			done_something = TRUE;
+			done_something = true;
 		    } else if (nd == 2 && (!dx(linkd) != !dx(linkd2)) &&
 			       diff >= DIFF_TRICKY) {
 			/*
@@ -648,7 +649,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 				       x, y, x2, y2);
 #endif
 			    soln[y2*w+x2] = NONTENT;
-			    done_something = TRUE;
+			    done_something = true;
 			}
 		    }
 		}
@@ -751,7 +752,8 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 	     * And iterate over all possibilities.
 	     */
 	    while (1) {
-		int p, valid;
+		int p;
+                bool valid;
 
 		/*
 		 * See if this possibility is valid. The only way
@@ -761,12 +763,12 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 		 * placed, will have been dealt with already by
 		 * other parts of the solver.)
 		 */
-		valid = TRUE;
+		valid = true;
 		for (j = 0; j+1 < n; j++)
 		    if (sc->place[j] == TENT &&
 			sc->place[j+1] == TENT &&
 			sc->locs[j+1] == sc->locs[j]+1) {
-			valid = FALSE;
+			valid = false;
 			break;
 		    }
 
@@ -868,7 +870,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 				   pos % w, pos / w);
 #endif
 			soln[pos] = mthis[j];
-			done_something = TRUE;
+			done_something = true;
 		    }
 		}
 	    }
@@ -897,7 +899,7 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
 }
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -993,7 +995,8 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
          * is too few to fit the remaining tents into. */
 	for (i = 0; j > 0 && i+j <= w*h; i++) {
             int which, x, y, d, tmp;
-	    int dy, dx, ok = TRUE;
+	    int dy, dx;
+            bool ok = true;
 
             which = i + random_upto(rs, j);
             tmp = order[which];
@@ -1008,7 +1011,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
 		    if (x+dx >= 0 && x+dx < w &&
 			y+dy >= 0 && y+dy < h &&
 			grid[(y+dy)*w+(x+dx)] == TENT)
-			ok = FALSE;
+			ok = false;
 
 	    if (ok) {
 		grid[order[i]] = TENT;
@@ -1141,7 +1144,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
     p = ret;
     j = 0;
     for (i = 0; i <= w*h; i++) {
-	int c = (i < w*h ? grid[i] == TREE : 1);
+	bool c = (i < w*h ? grid[i] == TREE : true);
 	if (c) {
 	    *p++ = (j == 0 ? '_' : j-1 + 'a');
 	    j = 0;
@@ -1236,7 +1239,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->numbers = snew(struct numbers);
     state->numbers->refcount = 1;
     state->numbers->numbers = snewn(w+h, int);
-    state->completed = state->used_solve = FALSE;
+    state->completed = state->used_solve = false;
 
     i = 0;
     memset(state->grid, BLANK, w*h);
@@ -1360,7 +1363,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     }
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
     return params->w <= 1998 && params->h <= 1998; /* 999 tents */
 }
@@ -1419,9 +1422,10 @@ struct game_ui {
     int dsx, dsy;                      /* coords of drag start */
     int dex, dey;                      /* coords of drag end */
     int drag_button;                   /* -1 for none, or a button code */
-    int drag_ok;                       /* dragged off the window, to cancel */
+    bool drag_ok;                      /* dragged off the window, to cancel */
 
-    int cx, cy, cdisp;                 /* cursor position, and ?display. */
+    int cx, cy;                        /* cursor position. */
+    bool cdisp;                        /* is cursor displayed? */
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1430,8 +1434,9 @@ static game_ui *new_ui(const game_state *state)
     ui->dsx = ui->dsy = -1;
     ui->dex = ui->dey = -1;
     ui->drag_button = -1;
-    ui->drag_ok = FALSE;
-    ui->cx = ui->cy = ui->cdisp = 0;
+    ui->drag_ok = false;
+    ui->cx = ui->cy = 0;
+    ui->cdisp = false;
     return ui;
 }
 
@@ -1456,7 +1461,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
 struct game_drawstate {
     int tilesize;
-    int started;
+    bool started;
     game_params p;
     int *drawn, *numbersdrawn;
     int cx, cy;         /* last-drawn cursor pos, or (-1,-1) if absent. */
@@ -1539,7 +1544,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     int w = state->p.w, h = state->p.h;
     char tmpbuf[80];
-    int shift = button & MOD_SHFT, control = button & MOD_CTRL;
+    bool shift = button & MOD_SHFT, control = button & MOD_CTRL;
 
     button &= ~MOD_MASK;
 
@@ -1552,8 +1557,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         ui->drag_button = button;
         ui->dsx = ui->dex = x;
         ui->dsy = ui->dey = y;
-        ui->drag_ok = TRUE;
-        ui->cdisp = 0;
+        ui->drag_ok = true;
+        ui->cdisp = false;
         return UI_UPDATE;
     }
 
@@ -1567,7 +1572,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         x = FROMCOORD(x);
         y = FROMCOORD(y);
         if (x < 0 || y < 0 || x >= w || y >= h) {
-            ui->drag_ok = FALSE;
+            ui->drag_ok = false;
         } else {
             /*
              * Drags are limited to one row or column. Hence, we
@@ -1582,7 +1587,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             ui->dex = x;
             ui->dey = y;
 
-            ui->drag_ok = TRUE;
+            ui->drag_ok = true;
         }
 
         if (IS_MOUSE_DRAG(button))
@@ -1639,11 +1644,11 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     }
 
     if (IS_CURSOR_MOVE(button)) {
-        ui->cdisp = 1;
+        ui->cdisp = true;
         if (shift || control) {
             int len = 0, i, indices[2];
             indices[0] = ui->cx + w * ui->cy;
-            move_cursor(button, &ui->cx, &ui->cy, w, h, 0);
+            move_cursor(button, &ui->cx, &ui->cy, w, h, false);
             indices[1] = ui->cx + w * ui->cy;
 
             /* NONTENTify all unique traversed eligible squares */
@@ -1658,7 +1663,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             tmpbuf[len] = '\0';
             if (len) return dupstr(tmpbuf);
         } else
-            move_cursor(button, &ui->cx, &ui->cy, w, h, 0);
+            move_cursor(button, &ui->cx, &ui->cy, w, h, false);
         return UI_UPDATE;
     }
     if (ui->cdisp) {
@@ -1685,7 +1690,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             return dupstr(tmpbuf);
         }
     } else if (IS_CURSOR_SELECT(button)) {
-        ui->cdisp = 1;
+        ui->cdisp = true;
         return UI_UPDATE;
     }
 
@@ -1703,7 +1708,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         c = *move;
 	if (c == 'S') {
             int i;
-	    ret->used_solve = TRUE;
+	    ret->used_solve = true;
             /*
              * Set all non-tree squares to NONTENT. The rest of the
              * solve move will fill the tents in over the top.
@@ -1858,7 +1863,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         /*
          * We haven't managed to fault the grid on any count. Score!
          */
-        ret->completed = TRUE;
+        ret->completed = true;
     }
     completion_check_done:
 
@@ -1935,7 +1940,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->tilesize = 0;
-    ds->started = FALSE;
+    ds->started = false;
     ds->p = state->p;                  /* structure copy */
     ds->drawn = snewn(w*h, int);
     for (i = 0; i < w*h; i++)
@@ -2302,7 +2307,7 @@ static void draw_err_adj(drawing *dr, game_drawstate *ds, int x, int y)
 }
 
 static void draw_tile(drawing *dr, game_drawstate *ds,
-                      int x, int y, int v, int cur, int printing)
+                      int x, int y, int v, bool cur, bool printing)
 {
     int err;
     int tx = COORD(x), ty = COORD(y);
@@ -2390,18 +2395,19 @@ static void draw_tile(drawing *dr, game_drawstate *ds,
 static void int_redraw(drawing *dr, game_drawstate *ds,
                        const game_state *oldstate, const game_state *state,
                        int dir, const game_ui *ui,
-		       float animtime, float flashtime, int printing)
+		       float animtime, float flashtime, bool printing)
 {
     int w = state->p.w, h = state->p.h;
-    int x, y, flashing;
+    int x, y;
+    bool flashing;
     int cx = -1, cy = -1;
-    int cmoved = 0;
+    bool cmoved = false;
     char *tmpgrid;
     int *errors;
 
     if (ui) {
       if (ui->cdisp) { cx = ui->cx; cy = ui->cy; }
-      if (cx != ds->cx || cy != ds->cy) cmoved = 1;
+      if (cx != ds->cx || cy != ds->cy) cmoved = true;
     }
 
     if (printing || !ds->started) {
@@ -2410,7 +2416,7 @@ static void int_redraw(drawing *dr, game_drawstate *ds,
 	    game_compute_size(&state->p, TILESIZE, &ww, &wh);
 	    draw_rect(dr, 0, 0, ww, wh, COL_BACKGROUND);
 	    draw_update(dr, 0, 0, ww, wh);
-	    ds->started = TRUE;
+	    ds->started = true;
 	}
 
 	if (printing)
@@ -2428,7 +2434,7 @@ static void int_redraw(drawing *dr, game_drawstate *ds,
     if (flashtime > 0)
 	flashing = (int)(flashtime * 3 / FLASH_TIME) != 1;
     else
-	flashing = FALSE;
+	flashing = false;
 
     /*
      * Find errors. For this we use _part_ of the information from a
@@ -2454,7 +2460,7 @@ static void int_redraw(drawing *dr, game_drawstate *ds,
     for (y = 0; y < h; y++) {
         for (x = 0; x < w; x++) {
             int v = state->grid[y*w+x];
-            int credraw = 0;
+            bool credraw = false;
 
             /*
              * We deliberately do not take drag_ok into account
@@ -2470,7 +2476,7 @@ static void int_redraw(drawing *dr, game_drawstate *ds,
 
             if (cmoved) {
               if ((x == cx && y == cy) ||
-                  (x == ds->cx && y == ds->cy)) credraw = 1;
+                  (x == ds->cx && y == ds->cy)) credraw = true;
             }
 
 	    v |= errors[y*w+x];
@@ -2529,7 +2535,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int_redraw(dr, ds, oldstate, state, dir, ui, animtime, flashtime, FALSE);
+    int_redraw(dr, ds, oldstate, state, dir, ui, animtime, flashtime, false);
 }
 
 static float game_anim_length(const game_state *oldstate,
@@ -2553,9 +2559,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2585,7 +2591,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
     c = print_mono_colour(dr, 0); assert(c == COL_TREELEAF);
     c = print_mono_colour(dr, 0); assert(c == COL_TENT);
 
-    int_redraw(dr, ds, NULL, state, +1, NULL, 0.0F, 0.0F, TRUE);
+    int_redraw(dr, ds, NULL, state, +1, NULL, 0.0F, 0.0F, true);
 }
 
 #ifdef COMBINED
@@ -2600,15 +2606,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2625,9 +2631,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON,		       /* flags */
 };
 
@@ -2641,16 +2647,17 @@ int main(int argc, char **argv)
     game_state *s, *s2;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
-    int ret, diff, really_verbose = FALSE;
+    bool grade = false;
+    int ret, diff;
+    bool really_verbose = false;
     struct solver_scratch *sc;
 
     while (--argc > 0) {
         char *p = *++argv;
         if (!strcmp(p, "-v")) {
-            really_verbose = TRUE;
+            really_verbose = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
diff --git a/apps/plugins/puzzles/src/towers.c b/apps/plugins/puzzles/src/towers.c
index 62d4de7b8b..a72cae680d 100644
--- a/apps/plugins/puzzles/src/towers.c
+++ b/apps/plugins/puzzles/src/towers.c
@@ -114,10 +114,10 @@ static const char *const cluepos[] = {
 struct game_state {
     game_params par;
     struct clues *clues;
-    unsigned char *clues_done;
+    bool *clues_done;
     digit *grid;
     int *pencil;		       /* bitmaps using bits 1<<1..1<<n */
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -140,13 +140,13 @@ static const struct game_params towers_presets[] = {
     {  6, DIFF_UNREASONABLE },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(towers_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = towers_presets[i]; /* structure copy */
@@ -155,7 +155,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -191,7 +191,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -235,7 +235,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w < 3 || params->w > 9)
         return "Grid size must be between 3 and 9";
@@ -250,7 +250,7 @@ static const char *validate_params(const game_params *params, int full)
 
 struct solver_ctx {
     int w, diff;
-    int started;
+    bool started;
     int *clues;
     long *iscratch;
     int *dscratch;
@@ -268,7 +268,7 @@ static int solver_easy(struct latin_solver *solver, void *vctx)
 #endif
 
     if (!ctx->started) {
-	ctx->started = TRUE;
+	ctx->started = true;
 	/*
 	 * One-off loop to help get started: when a pair of facing
 	 * clues sum to w+1, it must mean that the row consists of
@@ -582,7 +582,7 @@ static int solver(int w, int *clues, digit *soln, int maxdiff)
     ctx.w = w;
     ctx.diff = maxdiff;
     ctx.clues = clues;
-    ctx.started = FALSE;
+    ctx.started = false;
     ctx.iscratch = snewn(w, long);
     ctx.dscratch = snewn(w+1, int);
 
@@ -602,7 +602,7 @@ static int solver(int w, int *clues, digit *soln, int maxdiff)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln, *soln2;
@@ -898,7 +898,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->clues->clues = snewn(4*w, int);
     state->clues->immutable = snewn(a, digit);
     state->grid = snewn(a, digit);
-    state->clues_done = snewn(4*w, unsigned char);
+    state->clues_done = snewn(4*w, bool);
     state->pencil = snewn(a, int);
 
     for (i = 0; i < a; i++) {
@@ -907,7 +907,7 @@ static game_state *new_game(midend *me, const game_params *params,
     }
 
     memset(state->clues->immutable, 0, a);
-    memset(state->clues_done, 0, 4*w*sizeof(unsigned char));
+    memset(state->clues_done, 0, 4*w*sizeof(bool));
 
     for (i = 0; i < 4*w; i++) {
 	if (i > 0) {
@@ -944,7 +944,8 @@ static game_state *new_game(midend *me, const game_params *params,
     }
     assert(!*p);
 
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     return state;
 }
@@ -961,10 +962,10 @@ static game_state *dup_game(const game_state *state)
 
     ret->grid = snewn(a, digit);
     ret->pencil = snewn(a, int);
-    ret->clues_done = snewn(4*w, unsigned char);
+    ret->clues_done = snewn(4*w, bool);
     memcpy(ret->grid, state->grid, a*sizeof(digit));
     memcpy(ret->pencil, state->pencil, a*sizeof(int));
-    memcpy(ret->clues_done, state->clues_done, 4*w*sizeof(unsigned char));
+    memcpy(ret->clues_done, state->clues_done, 4*w*sizeof(bool));
 
     ret->completed = state->completed;
     ret->cheated = state->cheated;
@@ -1019,9 +1020,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1106,7 +1107,7 @@ struct game_ui {
      * This indicates whether the current highlight is a
      * pencil-mark one or a real one.
      */
-    int hpencil;
+    bool hpencil;
     /*
      * This indicates whether or not we're showing the highlight
      * (used to be hx = hy = -1); important so that when we're
@@ -1114,13 +1115,13 @@ struct game_ui {
      * fixed position. When hshow = 1, pressing a valid number
      * or letter key or Space will enter that number or letter in the grid.
      */
-    int hshow;
+    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.
      */
-    int hcursor;
+    bool hcursor;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1128,7 +1129,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
 
     return ui;
 }
@@ -1159,7 +1162,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      */
     if (ui->hshow && ui->hpencil && !ui->hcursor &&
         newstate->grid[ui->hy * w + ui->hx] != 0) {
-        ui->hshow = 0;
+        ui->hshow = false;
     }
 }
 
@@ -1186,27 +1189,28 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
 struct game_drawstate {
     int tilesize;
-    int three_d;		/* default 3D graphics are user-disableable */
-    int started;
+    bool three_d;       /* default 3D graphics are user-disableable */
+    bool started;
     long *tiles;		       /* (w+2)*(w+2) temp space */
     long *drawn;		       /* (w+2)*(w+2)*4: current drawn data */
-    int *errtmp;
+    bool *errtmp;
 };
 
-static int check_errors(const game_state *state, int *errors)
+static bool check_errors(const game_state *state, bool *errors)
 {
     int w = state->par.w /*, a = w*w */;
     int W = w+2, A = W*W;	       /* the errors array is (w+2) square */
     int *clues = state->clues->clues;
     digit *grid = state->grid;
-    int i, x, y, errs = FALSE;
+    int i, x, y;
+    bool errs = false;
     int tmp[32];
 
     assert(w < lenof(tmp));
 
     if (errors)
 	for (i = 0; i < A; i++)
-	    errors[i] = 0;
+	    errors[i] = false;
 
     for (y = 0; y < w; y++) {
 	unsigned long mask = 0, errmask = 0;
@@ -1217,12 +1221,12 @@ static int check_errors(const game_state *state, int *errors)
 	}
 
 	if (mask != (1L << (w+1)) - (1L << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1UL;
 	    if (errors) {
 		for (x = 0; x < w; x++)
 		    if (errmask & (1UL << grid[y*w+x]))
-			errors[(y+1)*W+(x+1)] = TRUE;
+			errors[(y+1)*W+(x+1)] = true;
 	    }
 	}
     }
@@ -1236,12 +1240,12 @@ static int check_errors(const game_state *state, int *errors)
 	}
 
 	if (mask != (1 << (w+1)) - (1 << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1UL;
 	    if (errors) {
 		for (y = 0; y < w; y++)
 		    if (errmask & (1UL << grid[y*w+x]))
-			errors[(y+1)*W+(x+1)] = TRUE;
+			errors[(y+1)*W+(x+1)] = true;
 	    }
 	}
     }
@@ -1269,9 +1273,9 @@ static int check_errors(const game_state *state, int *errors)
 	    if (errors) {
 		int x, y;
 		CLUEPOS(x, y, i, w);
-		errors[(y+1)*W+(x+1)] = TRUE;
+		errors[(y+1)*W+(x+1)] = true;
 	    }
-	    errs = TRUE;
+	    errs = true;
 	}
     }
 
@@ -1290,7 +1294,7 @@ static int clue_index(const game_state *state, int x, int y)
     return -1;
 }
 
-static int is_clue(const game_state *state, int x, int y)
+static bool is_clue(const game_state *state, int x, int y)
 {
     int w = state->par.w;
 
@@ -1298,10 +1302,10 @@ static int is_clue(const game_state *state, int x, int y)
         ((y == -1 || y == w) && x >= 0 && x < w))
     {
         if (state->clues->clues[clue_index(state, x, y)] & DF_DIGIT_MASK)
-            return TRUE;
+            return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 static char *interpret_move(const game_state *state, game_ui *ui,
@@ -1309,7 +1313,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                             int x, int y, int button)
 {
     int w = state->par.w;
-    int shift_or_control = button & (MOD_SHFT | MOD_CTRL);
+    bool shift_or_control = button & (MOD_SHFT | MOD_CTRL);
     int tx, ty;
     char buf[80];
 
@@ -1356,15 +1360,15 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (tx >= 0 && tx < w && ty >= 0 && ty < w) {
         if (button == LEFT_BUTTON) {
 	    if (tx == ui->hx && ty == ui->hy &&
-		ui->hshow && ui->hpencil == 0) {
-                ui->hshow = 0;
+		ui->hshow && !ui->hpencil) {
+                ui->hshow = false;
             } else {
                 ui->hx = tx;
                 ui->hy = ty;
 		ui->hshow = !state->clues->immutable[ty*w+tx];
-                ui->hpencil = 0;
+                ui->hpencil = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
         if (button == RIGHT_BUTTON) {
@@ -1374,17 +1378,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             if (state->grid[ty*w+tx] == 0) {
                 if (tx == ui->hx && ty == ui->hy &&
                     ui->hshow && ui->hpencil) {
-                    ui->hshow = 0;
+                    ui->hshow = false;
                 } else {
-                    ui->hpencil = 1;
+                    ui->hpencil = true;
                     ui->hx = tx;
                     ui->hy = ty;
-                    ui->hshow = 1;
+                    ui->hshow = true;
                 }
             } else {
-                ui->hshow = 0;
+                ui->hshow = false;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
     } else if (button == LEFT_BUTTON) {
@@ -1408,14 +1412,15 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             }
             return NULL;
         }
-        move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
-        ui->hshow = ui->hcursor = 1;
+        move_cursor(button, &ui->hx, &ui->hy, w, w, false);
+        ui->hshow = true;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
     if (ui->hshow &&
         (button == CURSOR_SELECT)) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
@@ -1442,7 +1447,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	sprintf(buf, "%c%d,%d,%d",
 		(char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
 
-        if (!ui->hcursor) ui->hshow = 0;
+        if (!ui->hcursor) ui->hshow = false;
 
 	return dupstr(buf);
     }
@@ -1460,7 +1465,7 @@ static game_state *execute_move(const game_state *from, const char *move)
     int x, y, i, n;
 
     if (move[0] == 'S') {
-	ret->completed = ret->cheated = TRUE;
+	ret->completed = ret->cheated = true;
 
 	for (i = 0; i < a; i++) {
             if (move[i+1] < '1' || move[i+1] > '0'+w)
@@ -1486,7 +1491,7 @@ static game_state *execute_move(const game_state *from, const char *move)
             ret->pencil[y*w+x] = 0;
 
             if (!ret->completed && !check_errors(ret, NULL))
-                ret->completed = TRUE;
+                ret->completed = true;
         }
 	return ret;
     } else if (move[0] == 'M') {
@@ -1578,12 +1583,12 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 
     ds->tilesize = 0;
     ds->three_d = !getenv("TOWERS_2D");
-    ds->started = FALSE;
+    ds->started = false;
     ds->tiles = snewn((w+2)*(w+2), long);
     ds->drawn = snewn((w+2)*(w+2)*4, long);
     for (i = 0; i < (w+2)*(w+2)*4; i++)
 	ds->drawn[i] = -1;
-    ds->errtmp = snewn((w+2)*(w+2), int);
+    ds->errtmp = snewn((w+2)*(w+2), bool);
 
     return ds;
 }
@@ -1795,7 +1800,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
 	draw_update(dr, 0, 0, SIZE(w), SIZE(w));
 
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     check_errors(state, ds->errtmp);
@@ -1903,11 +1908,11 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
-	return FALSE;
-    return TRUE;
+	return false;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1999,15 +2004,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2024,9 +2029,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
 };
 
@@ -2040,15 +2045,16 @@ int main(int argc, char **argv)
     game_state *s;
     char *id = NULL, *desc;
     const char *err;
-    int grade = FALSE;
-    int ret, diff, really_show_working = FALSE;
+    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;
+            really_show_working = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
@@ -2084,7 +2090,7 @@ int main(int argc, char **argv)
      * the puzzle internally before doing anything else.
      */
     ret = -1;			       /* placate optimiser */
-    solver_show_working = FALSE;
+    solver_show_working = 0;
     for (diff = 0; diff < DIFFCOUNT; diff++) {
 	memcpy(s->grid, s->clues->immutable, p->w * p->w);
 	ret = solver(p->w, s->clues->clues, s->grid, diff);
diff --git a/apps/plugins/puzzles/src/tracks.c b/apps/plugins/puzzles/src/tracks.c
index 5122f899f7..8f29faa0fd 100644
--- a/apps/plugins/puzzles/src/tracks.c
+++ b/apps/plugins/puzzles/src/tracks.c
@@ -43,7 +43,8 @@ static char const tracks_diffchars[] = DIFFLIST(ENCODE);
 #define DIFFCONFIG DIFFLIST(CONFIG)
 
 struct game_params {
-    int w, h, diff, single_ones;
+    int w, h, diff;
+    bool single_ones;
 };
 
 static game_params *default_params(void)
@@ -52,7 +53,7 @@ static game_params *default_params(void)
 
     ret->w = ret->h = 8;
     ret->diff = DIFF_TRICKY;
-    ret->single_ones = TRUE;
+    ret->single_ones = true;
 
     return ret;
 }
@@ -70,13 +71,13 @@ static const struct game_params tracks_presets[] = {
     {15, 15, DIFF_TRICKY, 1},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
 
     if (i < 0 || i >= lenof(tracks_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = tracks_presets[i];
@@ -85,7 +86,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -118,15 +119,15 @@ static void decode_params(game_params *params, char const *string)
                 params->diff = i;
         if (*string) string++;
     }
-    params->single_ones = TRUE;
+    params->single_ones = true;
     if (*string == 'o') {
-        params->single_ones = FALSE;
+        params->single_ones = false;
         string++;
     }
 
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[120];
 
@@ -182,7 +183,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     /*
      * Generating anything under 4x4 runs into trouble of one kind
@@ -227,7 +228,7 @@ static const char *validate_params(const game_params *params, int full)
 #define BLANK 0
 #define UNKNOWN 15
 
-int nbits[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
+static const int nbits[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
 
 /* square grid flags */
 #define S_TRACK 1     /* a track passes through this square (--> 2 edges) */
@@ -258,39 +259,43 @@ struct game_state {
     unsigned int *sflags;       /* size w*h */
     struct numbers *numbers;
     int *num_errors;            /* size w+h */
-    int completed, used_solve, impossible;
+    bool completed, used_solve, impossible;
 };
 
 /* Return the four directions in which a particular edge flag is set, around a square. */
-int S_E_DIRS(const game_state *state, int sx, int sy, unsigned int eflag) {
+static int S_E_DIRS(const game_state *state, int sx, int sy,
+                    unsigned int eflag) {
     return (state->sflags[sy*state->p.w+sx] >>
             ((eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT)) & ALLDIR;
 }
 
 /* Count the number of a particular edge flag around a grid square. */
-int S_E_COUNT(const game_state *state, int sx, int sy, unsigned int eflag) {
+static int S_E_COUNT(const game_state *state, int sx, int sy,
+                     unsigned int eflag) {
     return nbits[S_E_DIRS(state, sx, sy, eflag)];
 }
 
 /* Return the two flags (E_TRACK and/or E_NOTRACK) set on a specific
  * edge of a square. */
-unsigned S_E_FLAGS(const game_state *state, int sx, int sy, int d) {
+static unsigned S_E_FLAGS(const game_state *state, int sx, int sy, int d) {
     unsigned f = state->sflags[sy*state->p.w+sx];
     int t = (f & (d << S_TRACK_SHIFT)), nt = (f & (d << S_NOTRACK_SHIFT));
     return (t ? E_TRACK : 0) | (nt ? E_NOTRACK : 0);
 }
 
-int S_E_ADJ(const game_state *state, int sx, int sy, int d, int *ax, int *ay, unsigned int *ad) {
-    if (d == L && sx > 0)            { *ax = sx-1; *ay = sy;   *ad = R; return 1; }
-    if (d == R && sx < state->p.w-1) { *ax = sx+1; *ay = sy;   *ad = L; return 1; }
-    if (d == U && sy > 0)            { *ax = sx;   *ay = sy-1; *ad = D; return 1; }
-    if (d == D && sy < state->p.h-1) { *ax = sx;   *ay = sy+1; *ad = U; return 1; }
+static bool S_E_ADJ(const game_state *state, int sx, int sy, int d, int *ax,
+                    int *ay, unsigned int *ad) {
+    if (d == L && sx > 0)            { *ax = sx-1; *ay = sy;   *ad = R; return true; }
+    if (d == R && sx < state->p.w-1) { *ax = sx+1; *ay = sy;   *ad = L; return true; }
+    if (d == U && sy > 0)            { *ax = sx;   *ay = sy-1; *ad = D; return true; }
+    if (d == D && sy < state->p.h-1) { *ax = sx;   *ay = sy+1; *ad = U; return true; }
 
-    return 0;
+    return false;
 }
 
 /* Sets flag (E_TRACK or E_NOTRACK) on a given edge of a square. */
-void S_E_SET(game_state *state, int sx, int sy, int d, unsigned int eflag) {
+static void S_E_SET(game_state *state, int sx, int sy, int d,
+                    unsigned int eflag) {
     unsigned shift = (eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT, ad;
     int ax, ay;
 
@@ -302,7 +307,8 @@ void S_E_SET(game_state *state, int sx, int sy, int d, unsigned int eflag) {
 }
 
 /* Clears flag (E_TRACK or E_NOTRACK) on a given edge of a square. */
-void S_E_CLEAR(game_state *state, int sx, int sy, int d, unsigned int eflag) {
+static void S_E_CLEAR(game_state *state, int sx, int sy, int d,
+                      unsigned int eflag) {
     unsigned shift = (eflag == E_TRACK) ? S_TRACK_SHIFT : S_NOTRACK_SHIFT, ad;
     int ax, ay;
 
@@ -324,7 +330,7 @@ static void clear_game(game_state *state)
 
     memset(state->num_errors, 0, (w+h) * sizeof(int));
 
-    state->completed = state->used_solve = state->impossible = FALSE;
+    state->completed = state->used_solve = state->impossible = false;
 }
 
 static game_state *blank_game(const game_params *params)
@@ -388,7 +394,7 @@ static void free_game(game_state *state)
 }
 
 #define NDIRS 4
-const unsigned int dirs_const[] = { U, D, L, R };
+static const unsigned int dirs_const[] = { U, D, L, R };
 
 static unsigned int find_direction(game_state *state, random_state *rs,
                                    int x, int y)
@@ -416,7 +422,7 @@ static unsigned int find_direction(game_state *state, random_state *rs,
     return 0; /* no possible directions left. */
 }
 
-static int check_completion(game_state *state, int mark);
+static bool check_completion(game_state *state, bool mark);
 
 static void lay_path(game_state *state, random_state *rs)
 {
@@ -544,7 +550,7 @@ static int solve_progress(const game_state *state) {
     return progress;
 }
 
-static int check_phantom_moves(const game_state *state) {
+static bool check_phantom_moves(const game_state *state) {
     int x, y, i;
 
     /* Check that this state won't show 'phantom moves' at the start of the
@@ -557,10 +563,10 @@ static int check_phantom_moves(const game_state *state) {
             if (state->sflags[i] & S_CLUE)
                 continue;
             if (S_E_COUNT(state, x, y, E_TRACK) > 1)
-                return 1; /* found one! */
+                return true; /* found one! */
         }
     }
-    return 0;
+    return false;
 }
 
 static int add_clues(game_state *state, random_state *rs, int diff)
@@ -685,7 +691,7 @@ done:
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
     int i, j, w = params->w, h = params->h, x, y, ret;
     game_state *state;
@@ -734,7 +740,7 @@ newpath:
     }
 
     if (params->single_ones) {
-        int last_was_one = 1, is_one; /* (disallow 1 clue at entry point) */
+        bool last_was_one = true, is_one; /* disallow 1 clue at entry point */
         for (i = 0; i < w+h; i++) {
             is_one = (state->numbers->numbers[i] == 1);
             if (is_one && last_was_one)
@@ -887,7 +893,7 @@ static int solve_set_sflag(game_state *state, int x, int y,
            x, y, (f == S_TRACK ? "TRACK" : "NOTRACK"), why));
     if (state->sflags[i] & (f == S_TRACK ? S_NOTRACK : S_TRACK)) {
         debug(("solve: opposite flag already set there, marking IMPOSSIBLE"));
-        state->impossible = TRUE;
+        state->impossible = true;
     }
     state->sflags[i] |= f;
     return 1;
@@ -905,7 +911,7 @@ static int solve_set_eflag(game_state *state, int x, int y, int d,
            (f == S_TRACK ? "TRACK" : "NOTRACK"), why));
     if (sf & (f == E_TRACK ? E_NOTRACK : E_TRACK)) {
         debug(("solve: opposite flag already set there, marking IMPOSSIBLE"));
-        state->impossible = TRUE;
+        state->impossible = true;
     }
     S_E_SET(state, x, y, d, f);
     return 1;
@@ -1116,7 +1122,7 @@ static int solve_check_loose_sub(game_state *state, int si, int id, int n,
     if (nloose > (target - e2count)) {
         debug(("check %s from (%d,%d): more loose (%d) than empty (%d), IMPOSSIBLE",
                what, si%w, si/w, nloose, target-e2count));
-        state->impossible = TRUE;
+        state->impossible = true;
     }
     if (nloose > 0 && nloose == (target - e2count)) {
         debug(("check %s from (%d,%d): nloose = empty (%d), forcing loners out.",
@@ -1173,7 +1179,8 @@ static int solve_check_loose_ends(game_state *state)
 static int solve_check_loop_sub(game_state *state, int x, int y, int dir,
                                 int *dsf, int startc, int endc)
 {
-    int w = state->p.w, h = state->p.h, i = y*w+x, j, k, satisfied = 1;
+    int w = state->p.w, h = state->p.h, i = y*w+x, j, k;
+    bool satisfied = true;
 
     j = (y+DY(dir))*w + (x+DX(dir));
 
@@ -1203,12 +1210,12 @@ static int solve_check_loop_sub(game_state *state, int x, int y, int dir,
             for (k = 0; k < w; k++) {
                 int target = state->numbers->numbers[k];
                 int ntracks = solve_count_col(state, k, S_TRACK);
-                if (ntracks < target) satisfied = 0;
+                if (ntracks < target) satisfied = false;
             }
             for (k = 0; k < h; k++) {
                 int target = state->numbers->numbers[w+k];
                 int ntracks = solve_count_row(state, k, S_TRACK);
-                if (ntracks < target) satisfied = 0;
+                if (ntracks < target) satisfied = false;
             }
             if (!satisfied) {
                 return solve_set_eflag(state, x, y, dir, E_NOTRACK,
@@ -1282,10 +1289,11 @@ static void solve_discount_edge(game_state *state, int x, int y, int d)
 
 static int tracks_solve(game_state *state, int diff)
 {
-    int didsth, x, y, w = state->p.w, h = state->p.h;
+    int x, y, w = state->p.w, h = state->p.h;
+    bool didsth;
 
     debug(("solve..."));
-    state->impossible = FALSE;
+    state->impossible = false;
 
     /* Set all the outer border edges as no-track. */
     for (x = 0; x < w; x++) {
@@ -1298,24 +1306,24 @@ static int tracks_solve(game_state *state, int diff)
     }
 
     while (1) {
-        didsth = 0;
+        didsth = false;
 
-        didsth += solve_update_flags(state);
-        didsth += solve_count_clues(state);
-        didsth += solve_check_loop(state);
+        didsth |= solve_update_flags(state);
+        didsth |= solve_count_clues(state);
+        didsth |= solve_check_loop(state);
 
         if (diff >= DIFF_TRICKY) {
-            didsth += solve_check_single(state);
-            didsth += solve_check_loose_ends(state);
+            didsth |= solve_check_single(state);
+            didsth |= solve_check_loose_ends(state);
         }
 
         if (!didsth || state->impossible) break;
     }
 
-    return state->impossible ? -1 : check_completion(state, FALSE) ? 1 : 0;
+    return state->impossible ? -1 : check_completion(state, false) ? 1 : 0;
 }
 
-static char *move_string_diff(const game_state *before, const game_state *after, int issolve)
+static char *move_string_diff(const game_state *before, const game_state *after, bool issolve)
 {
     int w = after->p.w, h = after->p.h, i, j;
     char *move = snewn(w*h*40, char), *p = move;
@@ -1382,16 +1390,16 @@ static char *solve_game(const game_state *state, const game_state *currstate,
         *error = "Unable to find solution";
         move = NULL;
     } else {
-        move = move_string_diff(currstate, solved, TRUE);
+        move = move_string_diff(currstate, solved, true);
     }
 
     free_game(solved);
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1532,9 +1540,10 @@ static int tracks_neighbour(int vertex, void *vctx)
         return -1;
 }
 
-static int check_completion(game_state *state, int mark)
+static bool check_completion(game_state *state, bool mark)
 {
-    int w = state->p.w, h = state->p.h, x, y, i, target, ret = TRUE;
+    int w = state->p.w, h = state->p.h, x, y, i, target;
+    bool ret = true;
     int ntrack, nnotrack, ntrackcomplete;
     int *dsf, pathclass;
     struct findloopstate *fls;
@@ -1548,7 +1557,7 @@ static int check_completion(game_state *state, int mark)
             state->sflags[i] &= ~S_ERROR;
             if (S_E_COUNT(state, i%w, i/w, E_TRACK) > 0) {
                 if (S_E_COUNT(state, i%w, i/w, E_TRACK) > 2) {
-                    ret = FALSE;
+                    ret = false;
                     state->sflags[i] |= S_ERROR;
                 }
             }
@@ -1577,11 +1586,11 @@ static int check_completion(game_state *state, int mark)
                 debug(("col %d error: target %d, track %d, notrack %d",
                        x, target, ntrack, nnotrack));
                 state->num_errors[x] = 1;
-                ret = FALSE;
+                ret = false;
             }
         }
         if (ntrackcomplete != target)
-            ret = FALSE;
+            ret = false;
     }
     for (y = 0; y < h; y++) {
         target = state->numbers->numbers[w+y];
@@ -1600,11 +1609,11 @@ static int check_completion(game_state *state, int mark)
                 debug(("row %d error: target %d, track %d, notrack %d",
                        y, target, ntrack, nnotrack));
                 state->num_errors[w+y] = 1;
-                ret = FALSE;
+                ret = false;
             }
         }
         if (ntrackcomplete != target)
-            ret = FALSE;
+            ret = false;
     }
 
     dsf = snewn(w*h, int);
@@ -1621,7 +1630,7 @@ static int check_completion(game_state *state, int mark)
     ctx.state = state;
     if (findloop_run(fls, w*h, tracks_neighbour, &ctx)) {
         debug(("loop detected, not complete"));
-        ret = FALSE; /* no loop allowed */
+        ret = false; /* no loop allowed */
         if (mark) {
             for (x = 0; x < w; x++) {
                 for (y = 0; y < h; y++) {
@@ -1647,7 +1656,7 @@ static int check_completion(game_state *state, int mark)
                 if ((dsf_canonify(dsf, i) != pathclass) &&
                     ((state->sflags[i] & S_TRACK) ||
                      (S_E_COUNT(state, i%w, i/w, E_TRACK) > 0))) {
-                    ret = FALSE;
+                    ret = false;
                     state->sflags[i] |= S_ERROR;
                 }
             }
@@ -1656,7 +1665,7 @@ static int check_completion(game_state *state, int mark)
              * can't be in a winning state. So even if we're not
              * highlighting any _errors_, we certainly shouldn't
              * return true. */
-            ret = FALSE;
+            ret = false;
         }
     }
 
@@ -1669,21 +1678,23 @@ static int check_completion(game_state *state, int mark)
 /* Code borrowed from Pearl. */
 
 struct game_ui {
-    int dragging, clearing, notrack;
+    bool dragging, clearing, notrack;
     int drag_sx, drag_sy, drag_ex, drag_ey; /* drag start and end grid coords */
     int clickx, clicky;    /* pixel position of initial click */
 
     int curx, cury;        /* grid position of keyboard cursor; uses half-size grid */
-    int cursor_active;     /* TRUE iff cursor is shown */
+    bool cursor_active;     /* true iff cursor is shown */
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
 
-    ui->clearing = ui->notrack = ui->dragging = 0;
+    ui->clearing = false;
+    ui->notrack = false;
+    ui->dragging = false;
     ui->drag_sx = ui->drag_sy = ui->drag_ex = ui->drag_ey = -1;
-    ui->cursor_active = FALSE;
+    ui->cursor_active = false;
     ui->curx = ui->cury = 1;
 
     return ui;
@@ -1738,7 +1749,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
 struct game_drawstate {
     int sz6, grid_line_all, grid_line_tl, grid_line_br;
-    int started;
+    bool started;
 
     int w, h, sz;
     unsigned int *flags, *flags_drag;
@@ -1753,20 +1764,20 @@ static void update_ui_drag(const game_state *state, game_ui *ui, int gx, int gy)
     if (dy == 0) {
         ui->drag_ex = gx < 0 ? 0 : gx >= w ? w-1 : gx;
         ui->drag_ey = ui->drag_sy;
-        ui->dragging = TRUE;
+        ui->dragging = true;
     } else if (dx == 0) {
         ui->drag_ex = ui->drag_sx;
         ui->drag_ey = gy < 0 ? 0 : gy >= h ? h-1 : gy;
-        ui->dragging = TRUE;
+        ui->dragging = true;
     } else {
         ui->drag_ex = ui->drag_sx;
         ui->drag_ey = ui->drag_sy;
-        ui->dragging = FALSE;
+        ui->dragging = false;
     }
 }
 
-static int ui_can_flip_edge(const game_state *state, int x, int y, int dir,
-                            int notrack)
+static bool ui_can_flip_edge(const game_state *state, int x, int y, int dir,
+                             bool notrack)
 {
     int w = state->p.w /*, h = state->shared->h, sz = state->shared->sz */;
     int x2 = x + DX(dir);
@@ -1774,12 +1785,12 @@ static int ui_can_flip_edge(const game_state *state, int x, int y, int dir,
     unsigned int sf1, sf2, ef;
 
     if (!INGRID(state, x, y) || !INGRID(state, x2, y2))
-        return FALSE;
+        return false;
 
     sf1 = state->sflags[y*w + x];
     sf2 = state->sflags[y2*w + x2];
     if ( !notrack && ((sf1 & S_CLUE) || (sf2 & S_CLUE)) )
-        return FALSE;
+        return false;
 
     ef = S_E_FLAGS(state, x, y, dir);
     if (notrack) {
@@ -1788,48 +1799,48 @@ static int ui_can_flip_edge(const game_state *state, int x, int y, int dir,
          could be set to TRACK, because we don't know which edges the general
          square setting refers to. */
       if (!(ef & E_NOTRACK) && (ef & E_TRACK))
-          return FALSE;
+          return false;
     } else {
       if (!(ef & E_TRACK)) {
           /* if we're going to _set_ TRACK, make sure neither adjacent square nor
              the edge itself is already set to NOTRACK. */
           if ((sf1 & S_NOTRACK) || (sf2 & S_NOTRACK) || (ef & E_NOTRACK))
-              return FALSE;
+              return false;
           /* if we're going to _set_ TRACK, make sure neither adjacent square has
              2 track flags already.  */
           if ((S_E_COUNT(state, x, y, E_TRACK) >= 2) ||
               (S_E_COUNT(state, x2, y2, E_TRACK) >= 2))
-              return FALSE;
+              return false;
           }
     }
-    return TRUE;
+    return true;
 }
 
-static int ui_can_flip_square(const game_state *state, int x, int y, int notrack)
+static bool ui_can_flip_square(const game_state *state, int x, int y, bool notrack)
 {
     int w = state->p.w, trackc;
     unsigned sf;
 
-    if (!INGRID(state, x, y)) return FALSE;
+    if (!INGRID(state, x, y)) return false;
     sf = state->sflags[y*w+x];
     trackc = S_E_COUNT(state, x, y, E_TRACK);
 
-    if (sf & S_CLUE) return FALSE;
+    if (sf & S_CLUE) return false;
 
     if (notrack) {
         /* If we're setting S_NOTRACK, we cannot have either S_TRACK or any E_TRACK. */
         if (!(sf & S_NOTRACK) && ((sf & S_TRACK) || (trackc > 0)))
-            return FALSE;
+            return false;
     } else {
         /* If we're setting S_TRACK, we cannot have any S_NOTRACK (we could have
           E_NOTRACK, though, because one or two wouldn't rule out a track) */
         if (!(sf & S_TRACK) && (sf & S_NOTRACK))
-            return FALSE;
+            return false;
     }
-    return TRUE;
+    return true;
 }
 
-static char *edge_flip_str(const game_state *state, int x, int y, int dir, int notrack, char *buf) {
+static char *edge_flip_str(const game_state *state, int x, int y, int dir, bool notrack, char *buf) {
     unsigned ef = S_E_FLAGS(state, x, y, dir);
     char c;
 
@@ -1842,7 +1853,7 @@ static char *edge_flip_str(const game_state *state, int x, int y, int dir, int n
     return dupstr(buf);
 }
 
-static char *square_flip_str(const game_state *state, int x, int y, int notrack, char *buf) {
+static char *square_flip_str(const game_state *state, int x, int y, bool notrack, char *buf) {
     unsigned f = state->sflags[y*state->p.w+x];
     char c;
 
@@ -1897,8 +1908,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     /* --- mouse operations --- */
 
     if (IS_MOUSE_DOWN(button)) {
-        ui->cursor_active = FALSE;
-        ui->dragging = FALSE;
+        ui->cursor_active = false;
+        ui->dragging = false;
 
         if (!INGRID(state, gx, gy)) {
             /* can't drag from off grid */
@@ -1906,10 +1917,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
 
         if (button == RIGHT_BUTTON) {
-            ui->notrack = TRUE;
+            ui->notrack = true;
             ui->clearing = state->sflags[gy*w+gx] & S_NOTRACK;
         } else {
-            ui->notrack = FALSE;
+            ui->notrack = false;
             ui->clearing = state->sflags[gy*w+gx] & S_TRACK;
         }
 
@@ -1922,19 +1933,19 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     }
 
     if (IS_MOUSE_DRAG(button)) {
-        ui->cursor_active = FALSE;
+        ui->cursor_active = false;
         update_ui_drag(state, ui, gx, gy);
         return UI_UPDATE;
     }
 
     if (IS_MOUSE_RELEASE(button)) {
-        ui->cursor_active = FALSE;
+        ui->cursor_active = false;
         if (ui->dragging &&
             (ui->drag_sx != ui->drag_ex || ui->drag_sy != ui->drag_ey)) {
             game_state *dragged = copy_and_apply_drag(state, ui);
-            char *ret = move_string_diff(state, dragged, FALSE);
+            char *ret = move_string_diff(state, dragged, false);
 
-            ui->dragging = 0;
+            ui->dragging = false;
             free_game(dragged);
 
             return ret;
@@ -1944,7 +1955,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             /* We might still have been dragging (and just done a one-
              * square drag): cancel drag, so undo doesn't make it like
              * a drag-in-progress. */
-            ui->dragging = 0;
+            ui->dragging = false;
 
             /* Click (or tiny drag). Work out which edge we were
              * closest to. */
@@ -1992,7 +2003,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         int dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP)    ? -1 : 0);
 
         if (!ui->cursor_active) {
-            ui->cursor_active = TRUE;
+            ui->cursor_active = true;
             return UI_UPDATE;
         }
 
@@ -2009,7 +2020,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
     if (IS_CURSOR_SELECT(button)) {
         if (!ui->cursor_active) {
-            ui->cursor_active = TRUE;
+            ui->cursor_active = true;
             return UI_UPDATE;
         }
         /* click on square corner does nothing (shouldn't get here) */
@@ -2052,7 +2063,7 @@ static game_state *execute_move(const game_state *state, const char *move)
     while (*move) {
         c = *move;
         if (c == 'S') {
-            ret->used_solve = TRUE;
+            ret->used_solve = true;
             move++;
         } else if (c == 'T' || c == 't' || c == 'N' || c == 'n') {
             /* set track, clear track; set notrack, clear notrack */
@@ -2094,7 +2105,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             goto badmove;
     }
 
-    check_completion(ret, TRUE);
+    check_completion(ret, true);
 
     return ret;
 
@@ -2186,7 +2197,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     int i;
 
     ds->sz6 = 0;
-    ds->started = FALSE;
+    ds->started = false;
 
     ds->w = state->p.w;
     ds->h = state->p.h;
@@ -2427,9 +2438,9 @@ static void draw_clue(drawing *dr, game_drawstate *ds, int w, int clue, int i, i
         cy = CENTERED_COORD(i-w);
     }
 
-    draw_rect(dr, cx - tsz + GRID_LINE_TL, cy - tsz + GRID_LINE_TL,
-              TILE_SIZE - GRID_LINE_ALL, TILE_SIZE - GRID_LINE_ALL,
-              bg);
+    if (bg >= 0)
+        draw_rect(dr, cx - tsz + GRID_LINE_TL, cy - tsz + GRID_LINE_TL,
+                  TILE_SIZE - GRID_LINE_ALL, TILE_SIZE - GRID_LINE_ALL, bg);
     sprintf(buf, "%d", clue);
     draw_text(dr, cx, cy, FONT_VARIABLE, tsz, ALIGN_VCENTRE|ALIGN_HCENTRE,
               col, buf);
@@ -2486,7 +2497,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds, const game_state *oldst
                         const game_state *state, int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int i, x, y, force = 0, flashing = 0, w = ds->w, h = ds->h;
+    int i, x, y, flashing = 0, w = ds->w, h = ds->h;
+    bool force = false;
     game_state *drag_state = NULL;
 
     if (!ds->started) {
@@ -2507,8 +2519,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds, const game_state *oldst
 
         draw_update(dr, 0, 0, (w+2)*TILE_SIZE + 2*BORDER, (h+2)*TILE_SIZE + 2*BORDER);
 
-        ds->started = TRUE;
-        force = 1;
+        ds->started = true;
+        force = true;
     }
 
     for (i = 0; i < w+h; i++) {
@@ -2567,9 +2579,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2606,8 +2618,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
 
     /* clue numbers, and loop ends */
     for (i = 0; i < w+h; i++)
-        draw_clue(dr, ds, w, state->numbers->numbers[i], i,
-		  black, COL_BACKGROUND);
+        draw_clue(dr, ds, w, state->numbers->numbers[i], i, black, -1);
     draw_loop_ends(dr, ds, state, black);
 
     /* clue tracks / solution */
@@ -2633,15 +2644,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2658,9 +2669,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/tree234.c b/apps/plugins/puzzles/src/tree234.c
index 4b3151ee2f..ad8eb047cd 100644
--- a/apps/plugins/puzzles/src/tree234.c
+++ b/apps/plugins/puzzles/src/tree234.c
@@ -1337,7 +1337,7 @@ static node234 *split234_internal(tree234 *t, int index) {
 		 * over to it until it is greater than minimum
 		 * size.
 		 */
-		int undersized = (!sub->elems[0]);
+		bool undersized = (!sub->elems[0]);
 		LOG(("  child %d is %ssize\n", ki,
 		     undersized ? "under" : "minimum-"));
 		LOG(("  neighbour is %s\n",
@@ -1376,7 +1376,7 @@ static node234 *split234_internal(tree234 *t, int index) {
     t->root = halves[1];
     return halves[0];
 }
-tree234 *splitpos234(tree234 *t, int index, int before) {
+tree234 *splitpos234(tree234 *t, int index, bool before) {
     tree234 *ret;
     node234 *n;
     int count;
@@ -1400,16 +1400,16 @@ tree234 *splitpos234(tree234 *t, int index, int before) {
     return ret;
 }
 tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel) {
-    int before;
+    bool before;
     int index;
 
     assert(rel != REL234_EQ);
 
     if (rel == REL234_GT || rel == REL234_GE) {
-	before = 1;
+	before = true;
 	rel = (rel == REL234_GT ? REL234_LE : REL234_LT);
     } else {
-	before = 0;
+	before = false;
     }
     if (!findrelpos234(t, e, cmp, rel, &index))
 	index = 0;
@@ -2012,7 +2012,7 @@ void splittest(tree234 *tree, void **array, int arraylen) {
     tree234 *tree3, *tree4;
     for (i = 0; i <= arraylen; i++) {
 	tree3 = copytree234(tree, NULL, NULL);
-	tree4 = splitpos234(tree3, i, 0);
+	tree4 = splitpos234(tree3, i, false);
 	verifytree(tree3, array, i);
 	verifytree(tree4, array+i, arraylen-i);
 	join234(tree3, tree4);
diff --git a/apps/plugins/puzzles/src/tree234.h b/apps/plugins/puzzles/src/tree234.h
index f75c8f7fb3..ccd943d69d 100644
--- a/apps/plugins/puzzles/src/tree234.h
+++ b/apps/plugins/puzzles/src/tree234.h
@@ -28,6 +28,8 @@
 #ifndef TREE234_H
 #define TREE234_H
 
+#include <stdbool.h>
+
 /*
  * This typedef is opaque outside tree234.c itself.
  */
@@ -162,9 +164,9 @@ int count234(tree234 *t);
 /*
  * Split a tree234 into two valid tree234s.
  * 
- * splitpos234 splits at a given index. If `before' is TRUE, the
+ * splitpos234 splits at a given index. If `before' is true, the
  * items at and after that index are left in t and the ones before
- * are returned; if `before' is FALSE, the items before that index
+ * are returned; if `before' is false, the items before that index
  * are left in t and the rest are returned.
  * 
  * split234 splits at a given key. You can pass any of the
@@ -172,7 +174,7 @@ int count234(tree234 *t);
  * in the tree that satisfy the relation are returned; the
  * remainder are left.
  */
-tree234 *splitpos234(tree234 *t, int index, int before);
+tree234 *splitpos234(tree234 *t, int index, bool before);
 tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel);
 
 /*
diff --git a/apps/plugins/puzzles/src/twiddle.c b/apps/plugins/puzzles/src/twiddle.c
index 600f445145..1d91559e37 100644
--- a/apps/plugins/puzzles/src/twiddle.c
+++ b/apps/plugins/puzzles/src/twiddle.c
@@ -37,17 +37,17 @@ enum {
 
 struct game_params {
     int w, h, n;
-    int rowsonly;
-    int orientable;
+    bool rowsonly;
+    bool orientable;
     int movetarget;
 };
 
 struct game_state {
     int w, h, n;
-    int orientable;
+    bool orientable;
     int *grid;
     int completed;
-    int used_solve;		       /* used to suppress completion flash */
+    bool used_solve;		       /* used to suppress completion flash */
     int movecount, movetarget;
     int lastx, lasty, lastr;	       /* coordinates of last rotation */
 };
@@ -58,7 +58,7 @@ static game_params *default_params(void)
 
     ret->w = ret->h = 3;
     ret->n = 2;
-    ret->rowsonly = ret->orientable = FALSE;
+    ret->rowsonly = ret->orientable = false;
     ret->movetarget = 0;
 
     return ret;
@@ -77,36 +77,37 @@ static game_params *dup_params(const game_params *params)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     static struct {
         const char *title;
         game_params params;
     } const presets[] = {
-        { "3x3 rows only", { 3, 3, 2, TRUE, FALSE } },
-        { "3x3 normal", { 3, 3, 2, FALSE, FALSE } },
-        { "3x3 orientable", { 3, 3, 2, FALSE, TRUE } },
-        { "4x4 normal", { 4, 4, 2, FALSE } },
-        { "4x4 orientable", { 4, 4, 2, FALSE, TRUE } },
-        { "4x4, rotating 3x3 blocks", { 4, 4, 3, FALSE } },
-        { "5x5, rotating 3x3 blocks", { 5, 5, 3, FALSE } },
-        { "6x6, rotating 4x4 blocks", { 6, 6, 4, FALSE } },
+        { "3x3 rows only", { 3, 3, 2, true, false } },
+        { "3x3 normal", { 3, 3, 2, false, false } },
+        { "3x3 orientable", { 3, 3, 2, false, true } },
+        { "4x4 normal", { 4, 4, 2, false } },
+        { "4x4 orientable", { 4, 4, 2, false, true } },
+        { "4x4, rotating 3x3 blocks", { 4, 4, 3, false } },
+        { "5x5, rotating 3x3 blocks", { 5, 5, 3, false } },
+        { "6x6, rotating 4x4 blocks", { 6, 6, 4, false } },
     };
 
     if (i < 0 || i >= lenof(presets))
-        return FALSE;
+        return false;
 
     *name = dupstr(presets[i].title);
     *params = dup_params(&presets[i].params);
 
-    return TRUE;
+    return true;
 }
 
 static void decode_params(game_params *ret, char const *string)
 {
     ret->w = ret->h = atoi(string);
     ret->n = 2;
-    ret->rowsonly = ret->orientable = FALSE;
+    ret->rowsonly = false;
+    ret->orientable = false;
     ret->movetarget = 0;
     while (*string && isdigit((unsigned char)*string)) string++;
     if (*string == 'x') {
@@ -121,9 +122,9 @@ static void decode_params(game_params *ret, char const *string)
     }
     while (*string) {
 	if (*string == 'r') {
-	    ret->rowsonly = TRUE;
+	    ret->rowsonly = true;
 	} else if (*string == 'o') {
-	    ret->orientable = TRUE;
+	    ret->orientable = true;
 	} else if (*string == 'm') {
             string++;
 	    ret->movetarget = atoi(string);
@@ -133,7 +134,7 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%dn%d%s%s", params->w, params->h, params->n,
@@ -201,7 +202,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 2)
 	return "Rotating block size must be at least two";
@@ -222,7 +223,7 @@ static const char *validate_params(const game_params *params, int full)
  * the centre is good for a user interface, but too inconvenient to
  * use internally.)
  */
-static void do_rotate(int *grid, int w, int h, int n, int orientable,
+static void do_rotate(int *grid, int w, int h, int n, bool orientable,
 		      int x, int y, int dir)
 {
     int i, j;
@@ -285,23 +286,23 @@ static void do_rotate(int *grid, int w, int h, int n, int orientable,
     }
 }
 
-static int grid_complete(int *grid, int wh, int orientable)
+static bool grid_complete(int *grid, int wh, bool orientable)
 {
-    int ok = TRUE;
+    bool ok = true;
     int i;
     for (i = 1; i < wh; i++)
 	if (grid[i] < grid[i-1])
-	    ok = FALSE;
+	    ok = false;
     if (orientable) {
 	for (i = 0; i < wh; i++)
 	    if (grid[i] & 3)
-		ok = FALSE;
+		ok = false;
     }
     return ok;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int *grid;
     int w = params->w, h = params->h, n = params->n, wh = w*h;
@@ -466,7 +467,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->n = n;
     state->orientable = params->orientable;
     state->completed = 0;
-    state->used_solve = FALSE;
+    state->used_solve = false;
     state->movecount = 0;
     state->movetarget = params->movetarget;
     state->lastx = state->lasty = state->lastr = -1;
@@ -540,15 +541,16 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return dupstr("S");
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
 {
     char *ret, *p, buf[80];
-    int i, x, y, col, o, maxlen;
+    int i, x, y, col, maxlen;
+    bool o = state->orientable;
 
     /*
      * First work out how many characters we need to display each
@@ -560,7 +562,6 @@ static char *game_text_format(const game_state *state)
 	x = sprintf(buf, "%d", state->grid[i] / 4);
 	if (col < x) col = x;
     }
-    o = (state->orientable ? 1 : 0);
 
     /*
      * Now we know the exact total size of the grid we're going to
@@ -594,7 +595,7 @@ static char *game_text_format(const game_state *state)
 
 struct game_ui {
     int cur_x, cur_y;
-    int cur_visible;
+    bool cur_visible;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -603,7 +604,7 @@ static game_ui *new_ui(const game_state *state)
 
     ui->cur_x = 0;
     ui->cur_y = 0;
-    ui->cur_visible = FALSE;
+    ui->cur_visible = false;
 
     return ui;
 }
@@ -628,7 +629,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 }
 
 struct game_drawstate {
-    int started;
+    bool started;
     int w, h, bgcolour;
     int *grid;
     int tilesize;
@@ -654,7 +655,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             ui->cur_y--;
         if (button == CURSOR_DOWN && (ui->cur_y+n) < (h))
             ui->cur_y++;
-        ui->cur_visible = 1;
+        ui->cur_visible = true;
         return UI_UPDATE;
     }
 
@@ -671,14 +672,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	dir = (button == LEFT_BUTTON ? 1 : -1);
 	if (x < 0 || x > w-n || y < 0 || y > h-n)
 	    return NULL;
-        ui->cur_visible = 0;
+        ui->cur_visible = false;
     } else if (IS_CURSOR_SELECT(button)) {
         if (ui->cur_visible) {
             x = ui->cur_x;
             y = ui->cur_y;
             dir = (button == CURSOR_SELECT2) ? -1 : +1;
         } else {
-            ui->cur_visible = 1;
+            ui->cur_visible = true;
             return UI_UPDATE;
         }
     } else if (button == 'a' || button == 'A' || button==MOD_NUM_KEYPAD+'7') {
@@ -747,7 +748,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 	qsort(ret->grid, ret->w*ret->h, sizeof(int), compare_int);
 	for (i = 0; i < ret->w*ret->h; i++)
 	    ret->grid[i] &= ~3;
-	ret->used_solve = TRUE;
+	ret->used_solve = true;
 	ret->completed = ret->movecount = 1;
 
 	return ret;
@@ -823,7 +824,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
 
-    ds->started = FALSE;
+    ds->started = false;
     ds->w = state->w;
     ds->h = state->h;
     ds->bgcolour = COL_BACKGROUND;
@@ -1093,12 +1094,13 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     int i, bgcolour;
     struct rotation srot, *rot;
     int lastx = -1, lasty = -1, lastr = -1;
-    int cx, cy, cmoved = 0, n = state->n;
+    int cx, cy, n = state->n;
+    bool cmoved = false;
 
     cx = ui->cur_visible ? ui->cur_x : -state->n;
     cy = ui->cur_visible ? ui->cur_y : -state->n;
     if (cx != ds->cur_x || cy != ds->cur_y)
-        cmoved = 1;
+        cmoved = true;
 
     if (flashtime > 0) {
         int frame = (int)(flashtime / FLASH_FRAME);
@@ -1135,7 +1137,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
         draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     /*
@@ -1183,7 +1185,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      * Now draw each tile.
      */
     for (i = 0; i < state->w * state->h; i++) {
-	int t, cc = 0;
+	int t;
+        bool cc = false;
 	int tx = i % state->w, ty = i / state->w;
 
 	/*
@@ -1203,10 +1206,10 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         if (cmoved) {
             /* cursor has moved (or changed visibility)... */
             if (tx == cx || tx == cx+n-1 || ty == cy || ty == cy+n-1)
-                cc = 1; /* ...we're on new cursor, redraw */
+                cc = true; /* ...we're on new cursor, redraw */
             if (tx == ds->cur_x || tx == ds->cur_x+n-1 ||
                 ty == ds->cur_y || ty == ds->cur_y+n-1)
-                cc = 1; /* ...we were on old cursor, redraw */
+                cc = true; /* ...we were on old cursor, redraw */
         }
 
 	if (ds->bgcolour != bgcolour ||   /* always redraw when flashing */
@@ -1255,9 +1258,9 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     }
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1280,15 +1283,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1305,9 +1308,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
diff --git a/apps/plugins/puzzles/src/undead.c b/apps/plugins/puzzles/src/undead.c
index 03b014f5a1..781c15d791 100644
--- a/apps/plugins/puzzles/src/undead.c
+++ b/apps/plugins/puzzles/src/undead.c
@@ -92,11 +92,11 @@ static game_params *default_params(void) {
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params) {
+static bool game_fetch_preset(int i, char **name, game_params **params) {
     game_params *ret;
     char buf[64];
 
-    if (i < 0 || i >= lenof(undead_presets)) return FALSE;
+    if (i < 0 || i >= lenof(undead_presets)) return false;
 
     ret = default_params();
     *ret = undead_presets[i]; /* struct copy */
@@ -107,7 +107,7 @@ static int game_fetch_preset(int i, char **name, game_params **params) {
             undead_diffnames[undead_presets[i].diff]);
     *name = dupstr(buf);
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params) {
@@ -144,7 +144,7 @@ static void decode_params(game_params *params, char const *string) {
     return;
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%d", params->w, params->h);
@@ -191,7 +191,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if ((params->w * params->h ) > 54)  return "Grid is too big";
     if (params->w < 3)                  return "Width must be at least 3";
@@ -224,20 +224,19 @@ struct game_common {
     struct path *paths;
     int *grid;
     int *xinfo;
-    int *fixed;
-    int solved;
+    bool *fixed;
 };
 
 struct game_state {
     struct game_common *common;
     int *guess;
     unsigned char *pencils;
-    unsigned char *cell_errors;
-    unsigned char *hint_errors;
-    unsigned char *hints_done;
-    unsigned char count_errors[3];
-    int solved;
-    int cheated;
+    bool *cell_errors;
+    bool *hint_errors;
+    bool *hints_done;
+    bool count_errors[3];
+    bool solved;
+    bool cheated;
 };
 
 static game_state *new_state(const game_params *params) {
@@ -260,7 +259,6 @@ static game_state *new_state(const game_params *params) {
     state->common->grid = snewn(state->common->wh, int);
     state->common->xinfo = snewn(state->common->wh, int);
     state->common->fixed = NULL;
-    state->common->solved = FALSE;
 
     state->common->num_paths =
         state->common->params.w + state->common->params.h;
@@ -281,20 +279,20 @@ static game_state *new_state(const game_params *params) {
     state->guess = NULL;
     state->pencils = NULL;
 
-    state->cell_errors = snewn(state->common->wh, unsigned char);
+    state->cell_errors = snewn(state->common->wh, bool);
     for (i=0;i<state->common->wh;i++)
-        state->cell_errors[i] = FALSE;
-    state->hint_errors = snewn(2*state->common->num_paths, unsigned char);
+        state->cell_errors[i] = false;
+    state->hint_errors = snewn(2*state->common->num_paths, bool);
     for (i=0;i<2*state->common->num_paths;i++)
-        state->hint_errors[i] = FALSE;
-    state->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+        state->hint_errors[i] = false;
+    state->hints_done = snewn(2 * state->common->num_paths, bool);
     memset(state->hints_done, 0,
-           2 * state->common->num_paths * sizeof(unsigned char));
+           2 * state->common->num_paths * sizeof(bool));
     for (i=0;i<3;i++)
-        state->count_errors[i] = FALSE;
+        state->count_errors[i] = false;
 
-    state->solved = FALSE;
-    state->cheated = FALSE;
+    state->solved = false;
+    state->cheated = false;
     
     return state;
 }
@@ -320,23 +318,23 @@ static game_state *dup_game(const game_state *state)
     else ret->pencils = NULL;
 
     if (state->cell_errors != NULL) {
-        ret->cell_errors = snewn(ret->common->wh,unsigned char);
+        ret->cell_errors = snewn(ret->common->wh,bool);
         memcpy(ret->cell_errors, state->cell_errors,
-               ret->common->wh*sizeof(unsigned char));
+               ret->common->wh*sizeof(bool));
     }
     else ret->cell_errors = NULL;
 
     if (state->hint_errors != NULL) {
-        ret->hint_errors = snewn(2*ret->common->num_paths,unsigned char);
+        ret->hint_errors = snewn(2*ret->common->num_paths,bool);
         memcpy(ret->hint_errors, state->hint_errors,
-               2*ret->common->num_paths*sizeof(unsigned char));
+               2*ret->common->num_paths*sizeof(bool));
     }
     else ret->hint_errors = NULL;
 
     if (state->hints_done != NULL) {
-        ret->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+        ret->hints_done = snewn(2 * state->common->num_paths, bool);
         memcpy(ret->hints_done, state->hints_done,
-               2 * state->common->num_paths * sizeof(unsigned char));
+               2 * state->common->num_paths * sizeof(bool));
     }
     else ret->hints_done = NULL;
 
@@ -399,7 +397,7 @@ enum {
     DIRECTION_DOWN
 };
 
-int range2grid(int rangeno, int width, int height, int *x, int *y) {
+static int range2grid(int rangeno, int width, int height, int *x, int *y) {
 
     if (rangeno < 0) {
         *x = 0; *y = 0; return DIRECTION_NONE;
@@ -423,7 +421,7 @@ int range2grid(int rangeno, int width, int height, int *x, int *y) {
     return DIRECTION_NONE;
 }
 
-int grid2range(int x, int y, int w, int h) {
+static int grid2range(int x, int y, int w, int h) {
     if (x>0 && x<w+1 && y>0 && y<h+1)           return -1;
     if (x<0 || x>w+1 || y<0 || y>h+1)           return -1;
     if ((x == 0 || x==w+1) && (y==0 || y==h+1)) return -1;
@@ -433,20 +431,20 @@ int grid2range(int x, int y, int w, int h) {
     return 2*(w+h) - y;
 }
 
-void make_paths(game_state *state) {
+static void make_paths(game_state *state) {
     int i;
     int count = 0;
 
     for (i=0;i<2*(state->common->params.w + state->common->params.h);i++) {
         int x,y,dir;
         int j,k,num_monsters;
-        int found;
+        bool found;
         int c,p; 
-        found = FALSE;
+        found = false;
         /* Check whether inverse path is already in list */
         for (j=0;j<count;j++) {
             if (i == state->common->paths[j].grid_end) {
-                found = TRUE;
+                found = true;
                 break;
             }
         }
@@ -458,7 +456,7 @@ void make_paths(game_state *state) {
                          state->common->params.h,&x,&y);     
         state->common->paths[count].sightings_start =
             state->common->grid[x+y*(state->common->params.w +2)];
-        while (TRUE) {
+        while (true) {
             int c,r;
 
             if      (dir == DIRECTION_DOWN)     y++;
@@ -515,9 +513,9 @@ void make_paths(game_state *state) {
             int m;
             m = state->common->paths[count].p[p];
             if (m == -1) continue;
-            found = FALSE;
+            found = false;
             for (j=0; j<c; j++)
-                if (state->common->paths[count].mapping[j] == m) found = TRUE;
+                if (state->common->paths[count].mapping[j] == m) found = true;
             if (!found) state->common->paths[count].mapping[c++] = m;
         }
         count++;
@@ -531,23 +529,23 @@ struct guess {
     int *possible;
 };
 
-int next_list(struct guess *g, int pos) {
+static bool next_list(struct guess *g, int pos) {
 
     if (pos == 0) {
         if ((g->guess[pos] == 1 && g->possible[pos] == 1) || 
             (g->guess[pos] == 2 && (g->possible[pos] == 3 ||
                                     g->possible[pos] == 2)) ||
             g->guess[pos] == 4)
-            return FALSE;
+            return false;
         if (g->guess[pos] == 1 && (g->possible[pos] == 3 ||
                                    g->possible[pos] == 7)) {
-            g->guess[pos] = 2; return TRUE;
+            g->guess[pos] = 2; return true;
         }
         if (g->guess[pos] == 1 && g->possible[pos] == 5) {
-            g->guess[pos] = 4; return TRUE;
+            g->guess[pos] = 4; return true;
         }
         if (g->guess[pos] == 2 && (g->possible[pos] == 6 || g->possible[pos] == 7)) {
-            g->guess[pos] = 4; return TRUE;
+            g->guess[pos] = 4; return true;
         }
     }
 
@@ -556,10 +554,10 @@ int next_list(struct guess *g, int pos) {
             return next_list(g,pos-1);
         }
         if (g->possible[pos] == 3 || g->possible[pos] == 7) {
-            g->guess[pos] = 2; return TRUE;
+            g->guess[pos] = 2; return true;
         }
         if (g->possible[pos] == 5) {
-            g->guess[pos] = 4; return TRUE;
+            g->guess[pos] = 4; return true;
         }
     }
 
@@ -571,7 +569,7 @@ int next_list(struct guess *g, int pos) {
             g->guess[pos] = 1; return next_list(g,pos-1);
         }
         if (g->possible[pos] == 6 || g->possible[pos] == 7) {
-            g->guess[pos] = 4; return TRUE;
+            g->guess[pos] = 4; return true;
         }
     }
 
@@ -586,10 +584,10 @@ int next_list(struct guess *g, int pos) {
             return next_list(g,pos-1);
         }
     }
-    return FALSE;
+    return false;
 }
 
-void get_unique(game_state *state, int counter, random_state *rs) {
+static void get_unique(game_state *state, int counter, random_state *rs) {
 
     int p,i,c,pathlimit,count_uniques;
     struct guess path_guess;
@@ -638,19 +636,20 @@ void get_unique(game_state *state, int counter, random_state *rs) {
         view_count[i] = 0;
     
     do {
-        int mirror, start_view, end_view;
+        bool mirror;
+        int start_view, end_view;
         
-        mirror = FALSE;
+        mirror = false;
         start_view = 0;
         for (p=0;p<state->common->paths[counter].length;p++) {
-            if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
+            if (state->common->paths[counter].p[p] == -1) mirror = true;
             else {
                 for (i=0;i<path_guess.length;i++) {
                     if (state->common->paths[counter].p[p] ==
                         state->common->paths[counter].mapping[i]) {
-                        if (path_guess.guess[i] == 1 && mirror == TRUE)
+                        if (path_guess.guess[i] == 1 && mirror)
                             start_view++;
-                        if (path_guess.guess[i] == 2 && mirror == FALSE)
+                        if (path_guess.guess[i] == 2 && !mirror)
                             start_view++;
                         if (path_guess.guess[i] == 4)
                             start_view++;
@@ -659,17 +658,17 @@ void get_unique(game_state *state, int counter, random_state *rs) {
                 }
             }
         }
-        mirror = FALSE;
+        mirror = false;
         end_view = 0;
         for (p=state->common->paths[counter].length-1;p>=0;p--) {
-            if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
+            if (state->common->paths[counter].p[p] == -1) mirror = true;
             else {
                 for (i=0;i<path_guess.length;i++) {
                     if (state->common->paths[counter].p[p] ==
                         state->common->paths[counter].mapping[i]) {
-                        if (path_guess.guess[i] == 1 && mirror == TRUE)
+                        if (path_guess.guess[i] == 1 && mirror)
                             end_view++;
-                        if (path_guess.guess[i] == 2 && mirror == FALSE)
+                        if (path_guess.guess[i] == 2 && !mirror)
                             end_view++;
                         if (path_guess.guess[i] == 4)
                             end_view++;
@@ -766,8 +765,8 @@ void get_unique(game_state *state, int counter, random_state *rs) {
     return;
 }
 
-int count_monsters(game_state *state,
-                   int *cGhost, int *cVampire, int *cZombie) {
+static int count_monsters(game_state *state,
+                          int *cGhost, int *cVampire, int *cZombie) {
     int cNone;
     int i;
 
@@ -783,8 +782,8 @@ int count_monsters(game_state *state,
     return cNone;
 }
 
-int check_numbers(game_state *state, int *guess) {
-    int valid;
+static bool check_numbers(game_state *state, int *guess) {
+    bool valid;
     int i;
     int count_ghosts, count_vampires, count_zombies;
 
@@ -795,49 +794,49 @@ int check_numbers(game_state *state, int *guess) {
         if (guess[i] == 4) count_zombies++;
     }
 
-    valid = TRUE;
+    valid = true;
 
-    if (count_ghosts   > state->common->num_ghosts)   valid = FALSE; 
-    if (count_vampires > state->common->num_vampires) valid = FALSE; 
-    if (count_zombies > state->common->num_zombies)   valid = FALSE; 
+    if (count_ghosts   > state->common->num_ghosts)   valid = false; 
+    if (count_vampires > state->common->num_vampires) valid = false; 
+    if (count_zombies > state->common->num_zombies)   valid = false; 
 
     return valid;
 }
 
-int check_solution(int *g, struct path path) {
+static bool check_solution(int *g, struct path path) {
     int i;
-    int mirror;
+    bool mirror;
     int count;
 
     count = 0;
-    mirror = FALSE;
+    mirror = false;
     for (i=0;i<path.length;i++) {
-        if (path.p[i] == -1) mirror = TRUE;
+        if (path.p[i] == -1) mirror = true;
         else {
             if (g[path.p[i]] == 1 && mirror) count++;
             else if (g[path.p[i]] == 2 && !mirror) count++;
             else if (g[path.p[i]] == 4) count++;
         }
     }
-    if (count != path.sightings_start) return FALSE;    
+    if (count != path.sightings_start) return false;    
 
     count = 0;
-    mirror = FALSE;
+    mirror = false;
     for (i=path.length-1;i>=0;i--) {
-        if (path.p[i] == -1) mirror = TRUE;
+        if (path.p[i] == -1) mirror = true;
         else {
             if (g[path.p[i]] == 1 && mirror) count++;
             else if (g[path.p[i]] == 2 && !mirror) count++;
             else if (g[path.p[i]] == 4) count++;
         }
     }
-    if (count != path.sightings_end) return FALSE;  
+    if (count != path.sightings_end) return false;  
 
-    return TRUE;
+    return true;
 }
 
-int solve_iterative(game_state *state, struct path *paths) {
-    int solved;
+static bool solve_iterative(game_state *state, struct path *paths) {
+    bool solved;
     int p,i,j,count;
 
     int *guess;
@@ -845,7 +844,7 @@ int solve_iterative(game_state *state, struct path *paths) {
 
     struct guess loop;
 
-    solved = TRUE;
+    solved = true;
     loop.length = state->common->num_total;
     guess = snewn(state->common->num_total,int);
     possible = snewn(state->common->num_total,int);
@@ -875,7 +874,7 @@ int solve_iterative(game_state *state, struct path *paths) {
                 possible[paths[p].mapping[i]] = 0;
             }
 
-            while(TRUE) {
+            while(true) {
                 for (i=0;i<state->common->num_total;i++) {
                     guess[i] = state->guess[i];
                 }
@@ -899,7 +898,7 @@ int solve_iterative(game_state *state, struct path *paths) {
     for (i=0;i<state->common->num_total;i++) {
         if (state->guess[i] == 3 || state->guess[i] == 5 ||
             state->guess[i] == 6 || state->guess[i] == 7) {
-            solved = FALSE; break;
+            solved = false; break;
         }
     }
 
@@ -909,8 +908,8 @@ int solve_iterative(game_state *state, struct path *paths) {
     return solved;
 }
 
-int solve_bruteforce(game_state *state, struct path *paths) {
-    int solved, correct;
+static bool solve_bruteforce(game_state *state, struct path *paths) {
+    bool solved, correct;
     int number_solutions;
     int p,i;
 
@@ -932,23 +931,23 @@ int solve_bruteforce(game_state *state, struct path *paths) {
         }
     }
 
-    solved = FALSE;
+    solved = false;
     number_solutions = 0;
 
-    while (TRUE) {
+    while (true) {
 
-        correct = TRUE;
-        if (!check_numbers(state,loop.guess)) correct = FALSE;
+        correct = true;
+        if (!check_numbers(state,loop.guess)) correct = false;
         else 
             for (p=0;p<state->common->num_paths;p++)
                 if (!check_solution(loop.guess,paths[p])) {
-                    correct = FALSE; break;
+                    correct = false; break;
                 }
         if (correct) {
             number_solutions++;
-            solved = TRUE;
+            solved = true;
             if(number_solutions > 1) {
-                solved = FALSE;
+                solved = false;
                 break; 
             }
             for (i=0;i<state->common->num_total;i++)
@@ -965,14 +964,14 @@ int solve_bruteforce(game_state *state, struct path *paths) {
     return solved;
 }
 
-int path_cmp(const void *a, const void *b) {
+static int path_cmp(const void *a, const void *b) {
     const struct path *pa = (const struct path *)a;
     const struct path *pb = (const struct path *)b;
     return pa->num_monsters - pb->num_monsters;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive) {
+                           char **aux, bool interactive) {
     int i,count,c,w,h,r,p,g;
     game_state *new;
 
@@ -980,12 +979,12 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     int filling;
     int max_length;
     int count_ghosts, count_vampires, count_zombies;
-    int abort;
+    bool abort;
     float ratio;
     
     /* Variables for solver algorithm */
-    int solved_iterative, solved_bruteforce, contains_inconsistency,
-        count_ambiguous;
+    bool solved_iterative, solved_bruteforce, contains_inconsistency;
+    int count_ambiguous;
     int iterative_depth;
     int *old_guess;
 
@@ -995,9 +994,9 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     char *desc; 
 
     i = 0;
-    while (TRUE) {
+    while (true) {
         new = new_state(params);
-        abort = FALSE;
+        abort = false;
 
         /* Fill grid with random mirrors and (later to be populated)
          * empty monster cells */
@@ -1062,9 +1061,9 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
         /* Initialize fixed flag from common. Not needed for the
          * puzzle generator; initialize it for having clean code */
-        new->common->fixed = snewn(new->common->num_total,int);
+        new->common->fixed = snewn(new->common->num_total, bool);
         for (g=0;g<new->common->num_total;g++)
-            new->common->fixed[g] = FALSE;
+            new->common->fixed[g] = false;
 
         /* paths generation */
         make_paths(new);
@@ -1080,7 +1079,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
         for (p=0;p<new->common->num_paths;p++) {
             if (new->common->paths[p].num_monsters > max_length) {
-                abort = TRUE;
+                abort = true;
             }
         }
         if (abort) {
@@ -1158,28 +1157,29 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
         /* Prepare path information needed by the solver (containing all hints) */  
         for (p=0;p<new->common->num_paths;p++) {
-            int mirror,x,y;
+            bool mirror;
+            int x,y;
 
             new->common->paths[p].sightings_start = 0;
             new->common->paths[p].sightings_end = 0;
             
-            mirror = FALSE;
+            mirror = false;
             for (g=0;g<new->common->paths[p].length;g++) {
 
-                if (new->common->paths[p].p[g] == -1) mirror = TRUE;
+                if (new->common->paths[p].p[g] == -1) mirror = true;
                 else {
-                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror == TRUE)  (new->common->paths[p].sightings_start)++;
-                    else if (new->guess[new->common->paths[p].p[g]] == 2 && mirror == FALSE) (new->common->paths[p].sightings_start)++;
+                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror)  (new->common->paths[p].sightings_start)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 2 && !mirror) (new->common->paths[p].sightings_start)++;
                     else if (new->guess[new->common->paths[p].p[g]] == 4)                    (new->common->paths[p].sightings_start)++;
                 }
             }
 
-            mirror = FALSE;
+            mirror = false;
             for (g=new->common->paths[p].length-1;g>=0;g--) {
-                if (new->common->paths[p].p[g] == -1) mirror = TRUE;
+                if (new->common->paths[p].p[g] == -1) mirror = true;
                 else {
-                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror == TRUE)  (new->common->paths[p].sightings_end)++;
-                    else if (new->guess[new->common->paths[p].p[g]] == 2 && mirror == FALSE) (new->common->paths[p].sightings_end)++;
+                    if      (new->guess[new->common->paths[p].p[g]] == 1 && mirror)  (new->common->paths[p].sightings_end)++;
+                    else if (new->guess[new->common->paths[p].p[g]] == 2 && !mirror) (new->common->paths[p].sightings_end)++;
                     else if (new->guess[new->common->paths[p].p[g]] == 4)                    (new->common->paths[p].sightings_end)++;
                 }
             }
@@ -1201,25 +1201,24 @@ static char *new_game_desc(const game_params *params, random_state *rs,
             old_guess[p] = 7;
         }
         iterative_depth = 0;
-        solved_iterative = FALSE;
-        contains_inconsistency = FALSE;
+        solved_iterative = false;
+        contains_inconsistency = false;
         count_ambiguous = 0;
 
-        while (TRUE) {
-            int no_change;          
-            no_change = TRUE;
+        while (true) {
+            bool no_change = true;
             solved_iterative = solve_iterative(new,new->common->paths);
             iterative_depth++;      
             for (p=0;p<new->common->num_total;p++) {
-                if (new->guess[p] != old_guess[p]) no_change = FALSE;
+                if (new->guess[p] != old_guess[p]) no_change = false;
                 old_guess[p] = new->guess[p];
-                if (new->guess[p] == 0) contains_inconsistency = TRUE;
+                if (new->guess[p] == 0) contains_inconsistency = true;
             }
             if (solved_iterative || no_change) break;
         } 
 
         /* If necessary, try to solve the puzzle with the brute-force solver */
-        solved_bruteforce = FALSE;  
+        solved_bruteforce = false;  
         if (new->common->params.diff != DIFF_EASY &&
             !solved_iterative && !contains_inconsistency) {
             for (p=0;p<new->common->num_total;p++)
@@ -1308,7 +1307,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     return desc;
 }
 
-void num2grid(int num, int width, int height, int *x, int *y) {
+static void num2grid(int num, int width, int height, int *x, int *y) {
     *x = 1+(num%width);
     *y = 1+(num/width);
     return;
@@ -1357,18 +1356,18 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->guess = snewn(state->common->num_total,int);
     state->pencils = snewn(state->common->num_total,unsigned char);
-    state->common->fixed = snewn(state->common->num_total,int);
+    state->common->fixed = snewn(state->common->num_total, bool);
     for (i=0;i<state->common->num_total;i++) {
         state->guess[i] = 7;
         state->pencils[i] = 0;
-        state->common->fixed[i] = FALSE;
+        state->common->fixed[i] = false;
     }
     for (i=0;i<state->common->wh;i++)
-        state->cell_errors[i] = FALSE;
+        state->cell_errors[i] = false;
     for (i=0;i<2*state->common->num_paths;i++)
-        state->hint_errors[i] = FALSE;
+        state->hint_errors[i] = false;
     for (i=0;i<3;i++)
-        state->count_errors[i] = FALSE;
+        state->count_errors[i] = false;
 
     count = 0;
     n = 0;
@@ -1393,7 +1392,7 @@ static game_state *new_game(midend *me, const game_params *params,
             state->common->grid[x+y*(state->common->params.w +2)] = CELL_GHOST;
             state->common->xinfo[x+y*(state->common->params.w+2)] = count;
             state->guess[count] = 1;
-            state->common->fixed[count++] = TRUE;
+            state->common->fixed[count++] = true;
             n++;
         }
         else if (*desc == 'V') {
@@ -1401,7 +1400,7 @@ static game_state *new_game(midend *me, const game_params *params,
             state->common->grid[x+y*(state->common->params.w +2)] = CELL_VAMPIRE;
             state->common->xinfo[x+y*(state->common->params.w+2)] = count;
             state->guess[count] = 2;
-            state->common->fixed[count++] = TRUE;
+            state->common->fixed[count++] = true;
             n++;
         }
         else if (*desc == 'Z') {
@@ -1409,7 +1408,7 @@ static game_state *new_game(midend *me, const game_params *params,
             state->common->grid[x+y*(state->common->params.w +2)] = CELL_ZOMBIE;
             state->common->xinfo[x+y*(state->common->params.w+2)] = count;
             state->guess[count] = 4;
-            state->common->fixed[count++] = TRUE;
+            state->common->fixed[count++] = true;
             n++;
         }
         else {
@@ -1419,7 +1418,7 @@ static game_state *new_game(midend *me, const game_params *params,
                 state->common->grid[x+y*(state->common->params.w +2)] = CELL_EMPTY;
                 state->common->xinfo[x+y*(state->common->params.w+2)] = count;
                 state->guess[count] = 7;
-                state->common->fixed[count++] = FALSE;
+                state->common->fixed[count++] = false;
                 n++;
             }
         }
@@ -1514,8 +1513,8 @@ static char *solve_game(const game_state *state_start, const game_state *currsta
     int p;
     int *old_guess;
     int iterative_depth;
-    int solved_iterative, solved_bruteforce, contains_inconsistency,
-        count_ambiguous;
+    bool solved_iterative, solved_bruteforce, contains_inconsistency;
+    int count_ambiguous;
 
     int i;
     char *move, *c;
@@ -1532,21 +1531,20 @@ static char *solve_game(const game_state *state_start, const game_state *currsta
         }
     }
     iterative_depth = 0;
-    solved_iterative = FALSE;
-    contains_inconsistency = FALSE;
+    solved_iterative = false;
+    contains_inconsistency = false;
     count_ambiguous = 0;
     
     /* Try to solve the puzzle with the iterative solver */
-    while (TRUE) {
-        int no_change;
-        no_change = TRUE;
+    while (true) {
+        bool no_change = true;
         solved_iterative =
             solve_iterative(solve_state,solve_state->common->paths);
         iterative_depth++;
         for (p=0;p<solve_state->common->num_total;p++) {
-            if (solve_state->guess[p] != old_guess[p]) no_change = FALSE;
+            if (solve_state->guess[p] != old_guess[p]) no_change = false;
             old_guess[p] = solve_state->guess[p];
-            if (solve_state->guess[p] == 0) contains_inconsistency = TRUE;
+            if (solve_state->guess[p] == 0) contains_inconsistency = true;
         }
         if (solved_iterative || no_change || contains_inconsistency) break;
     }
@@ -1559,7 +1557,7 @@ static char *solve_game(const game_state *state_start, const game_state *currsta
     }
 
     /* If necessary, try to solve the puzzle with the brute-force solver */
-    solved_bruteforce = FALSE;  
+    solved_bruteforce = false;  
     if (!solved_iterative) {
         for (p=0;p<solve_state->common->num_total;p++)
             if (solve_state->guess[p] != 1 && solve_state->guess[p] != 2 &&
@@ -1593,9 +1591,9 @@ static char *solve_game(const game_state *state_start, const game_state *currsta
     return move;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1640,16 +1638,18 @@ static char *game_text_format(const game_state *state)
 
 struct game_ui {
     int hx, hy;                         /* as for solo.c, highlight pos */
-    int hshow, hpencil, hcursor;        /* show state, type, and ?cursor. */
-    int ascii;
+    bool hshow, hpencil, hcursor;       /* show state, type, and ?cursor. */
+    bool ascii;
 };
 
 static game_ui *new_ui(const game_state *state)
 {
     game_ui *ui = snew(game_ui);
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
-    ui->ascii = FALSE;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
+    ui->ascii = false;
     return ui;
 }
 
@@ -1677,36 +1677,38 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
     if (ui->hshow && ui->hpencil && !ui->hcursor) {
         int g = newstate->guess[newstate->common->xinfo[ui->hx + ui->hy*(newstate->common->params.w+2)]];
         if (g == 1 || g == 2 || g == 4)
-            ui->hshow = 0;
+            ui->hshow = false;
     }
 }
 
 struct game_drawstate {
-    int tilesize, started, solved;
+    int tilesize;
+    bool started, solved;
     int w, h;
         
     int *monsters;
     unsigned char *pencils;
 
-    unsigned char count_errors[3];
-    unsigned char *cell_errors;
-    unsigned char *hint_errors;
-    unsigned char *hints_done;
+    bool count_errors[3];
+    bool *cell_errors;
+    bool *hint_errors;
+    bool *hints_done;
 
-    int hx, hy, hshow, hpencil; /* as for game_ui. */
-    int hflash;
-    int ascii;
+    int hx, hy;
+    bool hshow, hpencil; /* as for game_ui. */
+    bool hflash;
+    bool ascii;
 };
 
-static int is_clue(const game_state *state, int x, int y)
+static bool is_clue(const game_state *state, int x, int y)
 {
     int h = state->common->params.h, w = state->common->params.w;
 
     if (((x == 0 || x == w + 1) && y > 0 && y <= h) ||
         ((y == 0 || y == h + 1) && x > 0 && x <= w))
-        return TRUE;
+        return true;
 
-    return FALSE;
+    return false;
 }
 
 static int clue_index(const game_state *state, int x, int y)
@@ -1748,27 +1750,27 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return dupstr("M");
     }
     
-    if (ui->hshow == 1 && ui->hpencil == 0) {
+    if (ui->hshow && !ui->hpencil) {
         xi = state->common->xinfo[ui->hx + ui->hy*(state->common->params.w+2)];
         if (xi >= 0 && !state->common->fixed[xi]) {
             if (button == 'g' || button == 'G' || button == '1') {
-                if (!ui->hcursor) ui->hshow = 0;
+                if (!ui->hcursor) ui->hshow = false;
                 sprintf(buf,"G%d",xi);
                 return dupstr(buf);
             }
             if (button == 'v' || button == 'V' || button == '2') {
-                if (!ui->hcursor) ui->hshow = 0;
+                if (!ui->hcursor) ui->hshow = false;
                 sprintf(buf,"V%d",xi);
                 return dupstr(buf);
             }
             if (button == 'z' || button == 'Z' || button == '3') {
-                if (!ui->hcursor) ui->hshow = 0;
+                if (!ui->hcursor) ui->hshow = false;
                 sprintf(buf,"Z%d",xi);
                 return dupstr(buf);
             }
             if (button == 'e' || button == 'E' || button == CURSOR_SELECT2 ||
                 button == '0' || button == '\b' ) {
-                if (!ui->hcursor) ui->hshow = 0;
+                if (!ui->hcursor) ui->hshow = false;
                 sprintf(buf,"E%d",xi);
                 return dupstr(buf);
             }
@@ -1786,37 +1788,50 @@ static char *interpret_move(const game_state *state, game_ui *ui,
               case CURSOR_RIGHT:  ui->hx += (ui->hx < ds->w) ? 1 : 0; break;
               case CURSOR_LEFT:   ui->hx -= (ui->hx > 1)     ? 1 : 0; break;
             }
-        ui->hshow = ui->hcursor = 1;
+        ui->hshow = true;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
     if (ui->hshow && button == CURSOR_SELECT) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
-    if (ui->hshow == 1 && ui->hpencil == 1) {
+    if (ui->hshow && ui->hpencil) {
         xi = state->common->xinfo[ui->hx + ui->hy*(state->common->params.w+2)];
         if (xi >= 0 && !state->common->fixed[xi]) {
             if (button == 'g' || button == 'G' || button == '1') {
                 sprintf(buf,"g%d",xi);
-                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                if (!ui->hcursor) {
+                    ui->hpencil = false;
+                    ui->hshow = false;
+                }
                 return dupstr(buf);
             }
             if (button == 'v' || button == 'V' || button == '2') {
                 sprintf(buf,"v%d",xi);
-                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                if (!ui->hcursor) {
+                    ui->hpencil = false;
+                    ui->hshow = false;
+                }
                 return dupstr(buf);
             }
             if (button == 'z' || button == 'Z' || button == '3') {
                 sprintf(buf,"z%d",xi);
-                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                if (!ui->hcursor) {
+                    ui->hpencil = false;
+                    ui->hshow = false;
+                }
                 return dupstr(buf);
             }
             if (button == 'e' || button == 'E' || button == CURSOR_SELECT2 ||
                 button == '0' || button == '\b') {
                 sprintf(buf,"E%d",xi);
-                if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
+                if (!ui->hcursor) {
+                    ui->hpencil = false;
+                    ui->hshow = false;
+                }
                 return dupstr(buf);
             }
         }       
@@ -1826,52 +1841,68 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         xi = state->common->xinfo[gx+gy*(state->common->params.w+2)];
         if (xi >= 0 && !state->common->fixed[xi]) {
             g = state->guess[xi];
-            if (ui->hshow == 0) {
+            if (!ui->hshow) {
                 if (button == LEFT_BUTTON) {
-                    ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                    ui->hshow = true;
+                    ui->hpencil = false;
+                    ui->hcursor = false;
                     ui->hx = gx; ui->hy = gy;
                     return UI_UPDATE;
                 }
                 else if (button == RIGHT_BUTTON && g == 7) {
-                    ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                    ui->hshow = true;
+                    ui->hpencil = true;
+                    ui->hcursor = false;
                     ui->hx = gx; ui->hy = gy;
                     return UI_UPDATE;
                 }
             }
-            else if (ui->hshow == 1) {
+            else if (ui->hshow) {
                 if (button == LEFT_BUTTON) {
-                    if (ui->hpencil == 0) {
+                    if (!ui->hpencil) {
                         if (gx == ui->hx && gy == ui->hy) {
-                            ui->hshow = 0; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hshow = false;
+                            ui->hpencil = false;
+                            ui->hcursor = false;
                             ui->hx = 0; ui->hy = 0;
                             return UI_UPDATE;
                         }
                         else {
-                            ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hshow = true;
+                            ui->hpencil = false;
+                            ui->hcursor = false;
                             ui->hx = gx; ui->hy = gy;
                             return UI_UPDATE;
                         }
                     }
                     else {
-                        ui->hshow = 1; ui->hpencil = 0; ui->hcursor = 0;
+                        ui->hshow = true;
+                        ui->hpencil = false;
+                        ui->hcursor = false;
                         ui->hx = gx; ui->hy = gy;
                         return UI_UPDATE;
                     }
                 }
                 else if (button == RIGHT_BUTTON) {
-                    if (ui->hpencil == 0 && g == 7) {
-                        ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                    if (!ui->hpencil && g == 7) {
+                        ui->hshow = true;
+                        ui->hpencil = true;
+                        ui->hcursor = false;
                         ui->hx = gx; ui->hy = gy;
                         return UI_UPDATE;
                     }
                     else {
                         if (gx == ui->hx && gy == ui->hy) {
-                            ui->hshow = 0; ui->hpencil = 0; ui->hcursor = 0;
+                            ui->hshow = false;
+                            ui->hpencil = false;
+                            ui->hcursor = false;
                             ui->hx = 0; ui->hy = 0;
                             return UI_UPDATE;
                         }
                         else if (g == 7) {
-                            ui->hshow = 1; ui->hpencil = 1; ui->hcursor = 0;
+                            ui->hshow = true;
+                            ui->hpencil = true;
+                            ui->hcursor = false;
                             ui->hx = gx; ui->hy = gy;
                             return UI_UPDATE;
                         }
@@ -1889,8 +1920,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     return NULL;
 }
 
-int check_numbers_draw(game_state *state, int *guess) {
-    int valid, filled;
+static bool check_numbers_draw(game_state *state, int *guess) {
+    bool valid, filled;
     int i,x,y,xy;
     int count_ghosts, count_vampires, count_zombies;
 
@@ -1901,64 +1932,64 @@ int check_numbers_draw(game_state *state, int *guess) {
         if (guess[i] == 4) count_zombies++;
     }
 
-    valid = TRUE;
+    valid = true;
     filled = (count_ghosts + count_vampires + count_zombies >=
               state->common->num_total);
 
     if (count_ghosts > state->common->num_ghosts ||
         (filled && count_ghosts != state->common->num_ghosts) ) {
-        valid = FALSE; 
-        state->count_errors[0] = TRUE; 
+        valid = false; 
+        state->count_errors[0] = true; 
         for (x=1;x<state->common->params.w+1;x++)
             for (y=1;y<state->common->params.h+1;y++) {
                 xy = x+y*(state->common->params.w+2);
                 if (state->common->xinfo[xy] >= 0 &&
                     guess[state->common->xinfo[xy]] == 1)
-                    state->cell_errors[xy] = TRUE;
+                    state->cell_errors[xy] = true;
             }
     }
     if (count_vampires > state->common->num_vampires ||
         (filled && count_vampires != state->common->num_vampires) ) {
-        valid = FALSE; 
-        state->count_errors[1] = TRUE; 
+        valid = false; 
+        state->count_errors[1] = true; 
         for (x=1;x<state->common->params.w+1;x++)
             for (y=1;y<state->common->params.h+1;y++) {
                 xy = x+y*(state->common->params.w+2);
                 if (state->common->xinfo[xy] >= 0 &&
                     guess[state->common->xinfo[xy]] == 2)
-                    state->cell_errors[xy] = TRUE;
+                    state->cell_errors[xy] = true;
             }
     }
     if (count_zombies > state->common->num_zombies ||
         (filled && count_zombies != state->common->num_zombies) )  {
-        valid = FALSE; 
-        state->count_errors[2] = TRUE; 
+        valid = false; 
+        state->count_errors[2] = true; 
         for (x=1;x<state->common->params.w+1;x++)
             for (y=1;y<state->common->params.h+1;y++) {
                 xy = x+y*(state->common->params.w+2);
                 if (state->common->xinfo[xy] >= 0 &&
                     guess[state->common->xinfo[xy]] == 4)
-                    state->cell_errors[xy] = TRUE;
+                    state->cell_errors[xy] = true;
             }
     }
 
     return valid;
 }
 
-int check_path_solution(game_state *state, int p) {
+static bool check_path_solution(game_state *state, int p) {
     int i;
-    int mirror;
+    bool mirror;
     int count;
-    int correct;
+    bool correct;
     int unfilled;
 
     count = 0;
-    mirror = FALSE;
-    correct = TRUE;
+    mirror = false;
+    correct = true;
 
     unfilled = 0;
     for (i=0;i<state->common->paths[p].length;i++) {
-        if (state->common->paths[p].p[i] == -1) mirror = TRUE;
+        if (state->common->paths[p].p[i] == -1) mirror = true;
         else {
             if (state->guess[state->common->paths[p].p[i]] == 1 && mirror)
                 count++;
@@ -1974,15 +2005,15 @@ int check_path_solution(game_state *state, int p) {
     if (count            > state->common->paths[p].sightings_start ||
         count + unfilled < state->common->paths[p].sightings_start)
     {
-        correct = FALSE;
-        state->hint_errors[state->common->paths[p].grid_start] = TRUE;
+        correct = false;
+        state->hint_errors[state->common->paths[p].grid_start] = true;
     }
 
     count = 0;
-    mirror = FALSE;
+    mirror = false;
     unfilled = 0;
     for (i=state->common->paths[p].length-1;i>=0;i--) {
-        if (state->common->paths[p].p[i] == -1) mirror = TRUE;
+        if (state->common->paths[p].p[i] == -1) mirror = true;
         else {
             if (state->guess[state->common->paths[p].p[i]] == 1 && mirror)
                 count++;
@@ -1998,13 +2029,13 @@ int check_path_solution(game_state *state, int p) {
     if (count            > state->common->paths[p].sightings_end ||
         count + unfilled < state->common->paths[p].sightings_end)
     {
-        correct = FALSE;
-        state->hint_errors[state->common->paths[p].grid_end] = TRUE;
+        correct = false;
+        state->hint_errors[state->common->paths[p].grid_end] = true;
     }
 
     if (!correct) {
         for (i=0;i<state->common->paths[p].length;i++) 
-            state->cell_errors[state->common->paths[p].xy[i]] = TRUE;
+            state->cell_errors[state->common->paths[p].xy[i]] = true;
     }
 
     return correct;
@@ -2014,17 +2045,17 @@ static game_state *execute_move(const game_state *state, const char *move)
 {
     int x,y,n,p,i;
     char c;
-    int correct; 
-    int solver; 
+    bool correct; 
+    bool solver; 
 
     game_state *ret = dup_game(state);
-    solver = FALSE;
+    solver = false;
 
     while (*move) {
         c = *move;
         if (c == 'S') {
             move++;
-            solver = TRUE;
+            solver = true;
         }
         if (c == 'G' || c == 'V' || c == 'Z' || c == 'E' ||
             c == 'g' || c == 'v' || c == 'z') {
@@ -2059,23 +2090,23 @@ static game_state *execute_move(const game_state *state, const char *move)
         if (*move == ';') move++;
     }
 
-    correct = TRUE;
+    correct = true;
 
-    for (i=0;i<ret->common->wh;i++) ret->cell_errors[i] = FALSE;
-    for (i=0;i<2*ret->common->num_paths;i++) ret->hint_errors[i] = FALSE;
-    for (i=0;i<3;i++) ret->count_errors[i] = FALSE;
+    for (i=0;i<ret->common->wh;i++) ret->cell_errors[i] = false;
+    for (i=0;i<2*ret->common->num_paths;i++) ret->hint_errors[i] = false;
+    for (i=0;i<3;i++) ret->count_errors[i] = false;
 
-    if (!check_numbers_draw(ret,ret->guess)) correct = FALSE;
+    if (!check_numbers_draw(ret,ret->guess)) correct = false;
 
     for (p=0;p<state->common->num_paths;p++)
-        if (!check_path_solution(ret,p)) correct = FALSE;
+        if (!check_path_solution(ret,p)) correct = false;
 
     for (i=0;i<state->common->num_total;i++)
         if (!(ret->guess[i] == 1 || ret->guess[i] == 2 ||
-              ret->guess[i] == 4)) correct = FALSE;
+              ret->guess[i] == 4)) correct = false;
 
-    if (correct && !solver) ret->solved = TRUE;
-    if (solver) ret->cheated = TRUE;
+    if (correct && !solver) ret->solved = true;
+    if (solver) ret->cheated = true;
 
     return ret;
 }
@@ -2159,14 +2190,14 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     struct game_drawstate *ds = snew(struct game_drawstate);
 
     ds->tilesize = 0;
-    ds->started = ds->solved = FALSE;
+    ds->started = ds->solved = false;
     ds->w = state->common->params.w;
     ds->h = state->common->params.h;
-    ds->ascii = FALSE;
+    ds->ascii = false;
     
-    ds->count_errors[0] = FALSE;
-    ds->count_errors[1] = FALSE;
-    ds->count_errors[2] = FALSE;
+    ds->count_errors[0] = false;
+    ds->count_errors[1] = false;
+    ds->count_errors[2] = false;
 
     ds->monsters = snewn(state->common->num_total,int);
     for (i=0;i<(state->common->num_total);i++)
@@ -2175,17 +2206,19 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     for (i=0;i<state->common->num_total;i++)
         ds->pencils[i] = 0;
 
-    ds->cell_errors = snewn(state->common->wh,unsigned char);
+    ds->cell_errors = snewn(state->common->wh,bool);
     for (i=0;i<state->common->wh;i++)
-        ds->cell_errors[i] = FALSE;
-    ds->hint_errors = snewn(2*state->common->num_paths,unsigned char);
+        ds->cell_errors[i] = false;
+    ds->hint_errors = snewn(2*state->common->num_paths,bool);
     for (i=0;i<2*state->common->num_paths;i++)
-        ds->hint_errors[i] = FALSE;
-    ds->hints_done = snewn(2 * state->common->num_paths, unsigned char);
+        ds->hint_errors[i] = false;
+    ds->hints_done = snewn(2 * state->common->num_paths, bool);
     memset(ds->hints_done, 0,
-           2 * state->common->num_paths * sizeof(unsigned char));
+           2 * state->common->num_paths * sizeof(bool));
 
-    ds->hshow = ds->hpencil = ds->hflash = 0;
+    ds->hshow = false;
+    ds->hpencil = false;
+    ds->hflash = false;
     ds->hx = ds->hy = 0;
     return ds;
 }
@@ -2204,7 +2237,7 @@ static void draw_cell_background(drawing *dr, game_drawstate *ds,
                                  const game_state *state, const game_ui *ui,
                                  int x, int y) {
 
-    int hon;
+    bool hon;
     int dx,dy;
     dx = BORDER+(x* ds->tilesize)+(TILESIZE/2);
     dy = BORDER+(y* ds->tilesize)+(TILESIZE/2)+TILESIZE;
@@ -2238,7 +2271,7 @@ static void draw_circle_or_point(drawing *dr, int cx, int cy, int radius,
 }
 
 static void draw_monster(drawing *dr, game_drawstate *ds, int x, int y,
-                         int tilesize, int hflash, int monster)
+                         int tilesize, bool hflash, int monster)
 {
     int black = (hflash ? COL_FLASH : COL_TEXT);
     
@@ -2367,7 +2400,7 @@ static void draw_monster(drawing *dr, game_drawstate *ds, int x, int y,
 }
 
 static void draw_monster_count(drawing *dr, game_drawstate *ds,
-                               const game_state *state, int c, int hflash) {
+                               const game_state *state, int c, bool hflash) {
     int dx,dy;
     char buf[8];
     char bufm[8];
@@ -2412,7 +2445,7 @@ static void draw_monster_count(drawing *dr, game_drawstate *ds,
 
 static void draw_path_hint(drawing *dr, game_drawstate *ds,
                            const struct game_params *params,
-                           int hint_index, int hflash, int hint) {
+                           int hint_index, bool hflash, int hint) {
     int x, y, color, dx, dy, text_dx, text_dy, text_size;
     char buf[4];
 
@@ -2448,7 +2481,7 @@ static void draw_path_hint(drawing *dr, game_drawstate *ds,
 
 static void draw_mirror(drawing *dr, game_drawstate *ds,
                         const game_state *state, int x, int y,
-                        int hflash, int mirror) {
+                        bool hflash, int mirror) {
     int dx,dy,mx1,my1,mx2,my2;
     dx = BORDER+(x* ds->tilesize)+(TILESIZE/2);
     dy = BORDER+(y* ds->tilesize)+(TILESIZE/2)+TILESIZE;
@@ -2474,7 +2507,7 @@ static void draw_mirror(drawing *dr, game_drawstate *ds,
 
 static void draw_big_monster(drawing *dr, game_drawstate *ds,
                              const game_state *state, int x, int y,
-                             int hflash, int monster)
+                             bool hflash, int monster)
 {
     int dx,dy;
     char buf[10];
@@ -2518,7 +2551,7 @@ static void draw_pencils(drawing *dr, game_drawstate *ds,
                 if (!ds->ascii) {
                     draw_monster(dr, ds,
                                  dx + TILESIZE/2 * px, dy + TILESIZE/2 * py,
-                                 TILESIZE/2, 0, monsters[py*2+px]);
+                                 TILESIZE/2, false, monsters[py*2+px]);
                 }
                 else {
                     switch (monsters[py*2+px]) {
@@ -2539,21 +2572,21 @@ static void draw_pencils(drawing *dr, game_drawstate *ds,
 
 #define FLASH_TIME 0.7F
 
-static int is_hint_stale(const game_drawstate *ds, int hflash,
-                         const game_state *state, int index)
+static bool is_hint_stale(const game_drawstate *ds, bool hflash,
+                          const game_state *state, int index)
 {
-    int ret = FALSE;
-    if (!ds->started) ret = TRUE;
-    if (ds->hflash != hflash) ret = TRUE;
+    bool ret = false;
+    if (!ds->started) ret = true;
+    if (ds->hflash != hflash) ret = true;
 
     if (ds->hint_errors[index] != state->hint_errors[index]) {
         ds->hint_errors[index] = state->hint_errors[index];
-        ret = TRUE;
+        ret = true;
     }
 
     if (ds->hints_done[index] != state->hints_done[index]) {
         ds->hints_done[index] = state->hints_done[index];
-        ret = TRUE;
+        ret = true;
     }
 
     return ret;
@@ -2565,7 +2598,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         float animtime, float flashtime)
 {
     int i,j,x,y,xy;
-    int stale, xi, c, hflash, hchanged, changed_ascii;
+    int xi, c;
+    bool stale, hflash, hchanged, changed_ascii;
 
     hflash = (int)(flashtime * 5 / FLASH_TIME) % 2;
 
@@ -2584,26 +2618,26 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                     2*BORDER+(ds->h+3)*TILESIZE);
     }
 
-    hchanged = FALSE;
+    hchanged = false;
     if (ds->hx != ui->hx || ds->hy != ui->hy ||
         ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
-        hchanged = TRUE;
+        hchanged = true;
 
     if (ds->ascii != ui->ascii) {
         ds->ascii = ui->ascii;
-        changed_ascii = TRUE;
+        changed_ascii = true;
     } else
-        changed_ascii = FALSE;
+        changed_ascii = false;
 
     /* Draw monster count hints */
 
     for (i=0;i<3;i++) {
-        stale = FALSE;
-        if (!ds->started) stale = TRUE;
-        if (ds->hflash != hflash) stale = TRUE;
-        if (changed_ascii) stale = TRUE;
+        stale = false;
+        if (!ds->started) stale = true;
+        if (ds->hflash != hflash) stale = true;
+        if (changed_ascii) stale = true;
         if (ds->count_errors[i] != state->count_errors[i]) {
-            stale = TRUE;
+            stale = true;
             ds->count_errors[i] = state->count_errors[i];
         }
         
@@ -2630,33 +2664,33 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     /* Draw puzzle grid contents */
     for (x = 1; x < ds->w+1; x++)
         for (y = 1; y < ds->h+1; y++) {
-            stale = FALSE;
+            stale = false;
             xy = x+y*(state->common->params.w+2);
             xi = state->common->xinfo[xy];
             c = state->common->grid[xy];
     
-            if (!ds->started) stale = TRUE;
-            if (ds->hflash != hflash) stale = TRUE;
-            if (changed_ascii) stale = TRUE;
+            if (!ds->started) stale = true;
+            if (ds->hflash != hflash) stale = true;
+            if (changed_ascii) stale = true;
         
             if (hchanged) {
                 if ((x == ui->hx && y == ui->hy) ||
                     (x == ds->hx && y == ds->hy))
-                    stale = TRUE;
+                    stale = true;
             }
 
             if (xi >= 0 && (state->guess[xi] != ds->monsters[xi]) ) {
-                stale = TRUE;
+                stale = true;
                 ds->monsters[xi] = state->guess[xi];
             }
         
             if (xi >= 0 && (state->pencils[xi] != ds->pencils[xi]) ) {
-                stale = TRUE;
+                stale = true;
                 ds->pencils[xi] = state->pencils[xi];
             }
 
             if (state->cell_errors[xy] != ds->cell_errors[xy]) {
-                stale = TRUE;
+                stale = true;
                 ds->cell_errors[xy] = state->cell_errors[xy];
             }
                 
@@ -2676,7 +2710,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     ds->hshow = ui->hshow;
     ds->hpencil = ui->hpencil;
     ds->hflash = hflash;
-    ds->started = TRUE;
+    ds->started = true;
     return;
 }
 
@@ -2698,9 +2732,9 @@ static int game_status(const game_state *state)
     return state->solved;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2723,15 +2757,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2748,8 +2782,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,                 /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,                 /* wants_statusbar */
+    false, game_timing_state,
     0,                     /* flags */
 };
diff --git a/apps/plugins/puzzles/src/unequal.c b/apps/plugins/puzzles/src/unequal.c
index addcffaf68..951e9ac80f 100644
--- a/apps/plugins/puzzles/src/unequal.c
+++ b/apps/plugins/puzzles/src/unequal.c
@@ -55,11 +55,15 @@ enum {
     NCOLOURS
 };
 
+typedef enum {
+    MODE_UNEQUAL,      /* Puzzle indicators are 'greater-than'. */
+    MODE_ADJACENT      /* Puzzle indicators are 'adjacent number'. */
+} Mode;
+
 struct game_params {
     int order;          /* Size of latin square */
     int diff;           /* Difficulty */
-    int adjacent;       /* Puzzle indicators are 'adjacent number'
-                            not 'greater-than'. */
+    Mode mode;
 };
 
 #define F_IMMUTABLE     1       /* passed in as game description */
@@ -82,7 +86,9 @@ struct game_params {
 #define F_ERROR_MASK (F_ERROR|F_ERROR_UP|F_ERROR_RIGHT|F_ERROR_DOWN|F_ERROR_LEFT)
 
 struct game_state {
-    int order, completed, cheated, adjacent;
+    int order;
+    bool completed, cheated;
+    Mode mode;
     digit *nums;                 /* actual numbers (size order^2) */
     unsigned char *hints;        /* remaining possiblities (size order^3) */
     unsigned int *flags;         /* flags (size order^2) */
@@ -126,25 +132,25 @@ static const struct game_params unequal_presets[] = {
     {  7, DIFF_EXTREME, 0 }
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(unequal_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = unequal_presets[i]; /* structure copy */
 
     sprintf(buf, "%s: %dx%d %s",
-            ret->adjacent ? "Adjacent" : "Unequal",
+            ret->mode == MODE_ADJACENT ? "Adjacent" : "Unequal",
             ret->order, ret->order,
             unequal_diffnames[ret->diff]);
 
     *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static game_params *default_params(void)
@@ -178,9 +184,9 @@ static void decode_params(game_params *ret, char const *string)
 
     if (*p == 'a') {
         p++;
-        ret->adjacent = 1;
+        ret->mode = MODE_ADJACENT;
     } else
-        ret->adjacent = 0;
+        ret->mode = MODE_UNEQUAL;
 
     if (*p == 'd') {
         int i;
@@ -196,12 +202,12 @@ static void decode_params(game_params *ret, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
     sprintf(ret, "%d", params->order);
-    if (params->adjacent)
+    if (params->mode == MODE_ADJACENT)
         sprintf(ret + strlen(ret), "a");
     if (full)
         sprintf(ret + strlen(ret), "d%c", unequal_diffchars[params->diff]);
@@ -219,7 +225,7 @@ static config_item *game_configure(const game_params *params)
     ret[0].name = "Mode";
     ret[0].type = C_CHOICES;
     ret[0].u.choices.choicenames = ":Unequal:Adjacent";
-    ret[0].u.choices.selected = params->adjacent;
+    ret[0].u.choices.selected = params->mode;
 
     ret[1].name = "Size (s*s)";
     ret[1].type = C_STRING;
@@ -241,20 +247,20 @@ static game_params *custom_params(const config_item *cfg)
 {
     game_params *ret = snew(game_params);
 
-    ret->adjacent = cfg[0].u.choices.selected;
+    ret->mode = cfg[0].u.choices.selected;
     ret->order = atoi(cfg[1].u.string.sval);
     ret->diff = cfg[2].u.choices.selected;
 
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->order < 3 || params->order > 32)
         return "Order must be between 3 and 32";
     if (params->diff >= DIFFCOUNT)
         return "Unknown difficulty rating";
-    if (params->order < 5 && params->adjacent &&
+    if (params->order < 5 && params->mode == MODE_ADJACENT &&
         params->diff >= DIFF_SET)
         return "Order must be at least 5 for Adjacent puzzles of this difficulty.";
     return NULL;
@@ -271,14 +277,15 @@ static const struct { unsigned int f, fo, fe; int dx, dy; char c, ac; } adjthan[
     { F_ADJ_LEFT,  F_ADJ_RIGHT, F_ERROR_LEFT,  -1,  0, '<', '|' }
 };
 
-static game_state *blank_game(int order, int adjacent)
+static game_state *blank_game(int order, Mode mode)
 {
     game_state *state = snew(game_state);
     int o2 = order*order, o3 = o2*order;
 
     state->order = order;
-    state->adjacent = adjacent;
-    state->completed = state->cheated = 0;
+    state->mode = mode;
+    state->completed = false;
+    state->cheated = false;
 
     state->nums = snewn(o2, digit);
     state->hints = snewn(o3, unsigned char);
@@ -293,7 +300,7 @@ static game_state *blank_game(int order, int adjacent)
 
 static game_state *dup_game(const game_state *state)
 {
-    game_state *ret = blank_game(state->order, state->adjacent);
+    game_state *ret = blank_game(state->order, state->mode);
     int o2 = state->order*state->order, o3 = o2*state->order;
 
     memcpy(ret->nums, state->nums, o2 * sizeof(digit));
@@ -313,12 +320,13 @@ static void free_game(game_state *state)
 
 #define CHECKG(x,y) grid[(y)*o+(x)]
 
-/* Returns 0 if it finds an error, 1 otherwise. */
-static int check_num_adj(digit *grid, game_state *state,
-                        int x, int y, int me)
+/* Returns false if it finds an error, true if ok. */
+static bool check_num_adj(digit *grid, game_state *state,
+                          int x, int y, bool me)
 {
     unsigned int f = GRID(state, flags, x, y);
-    int ret = 1, i, o = state->order;
+    bool ret = true;
+    int i, o = state->order;
 
     for (i = 0; i < 4; i++) {
         int dx = adjthan[i].dx, dy = adjthan[i].dy, n, dn;
@@ -332,20 +340,20 @@ static int check_num_adj(digit *grid, game_state *state,
         assert (n != 0);
         if (dn == 0) continue;
 
-        if (state->adjacent) {
+        if (state->mode == MODE_ADJACENT) {
             int gd = abs(n-dn);
 
             if ((f & adjthan[i].f) && (gd != 1)) {
                 debug(("check_adj error (%d,%d):%d should be | (%d,%d):%d",
                        x, y, n, x+dx, y+dy, dn));
                 if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
-                ret = 0;
+                ret = false;
             }
             if (!(f & adjthan[i].f) && (gd == 1)) {
                 debug(("check_adj error (%d,%d):%d should not be | (%d,%d):%d",
                        x, y, n, x+dx, y+dy, dn));
                 if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
-                ret = 0;
+                ret = false;
             }
 
         } else {
@@ -353,32 +361,33 @@ static int check_num_adj(digit *grid, game_state *state,
                 debug(("check_adj error (%d,%d):%d not > (%d,%d):%d",
                        x, y, n, x+dx, y+dy, dn));
                 if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
-                ret = 0;
+                ret = false;
             }
         }
     }
     return ret;
 }
 
-/* Returns 0 if it finds an error, 1 otherwise. */
-static int check_num_error(digit *grid, game_state *state,
-                           int x, int y, int mark_errors)
+/* Returns false if it finds an error, true if ok. */
+static bool check_num_error(digit *grid, game_state *state,
+                            int x, int y, bool mark_errors)
 {
     int o = state->order;
-    int xx, yy, val = CHECKG(x,y), ret = 1;
+    int xx, yy, val = CHECKG(x,y);
+    bool ret = true;
 
     assert(val != 0);
 
     /* check for dups in same column. */
     for (yy = 0; yy < state->order; yy++) {
         if (yy == y) continue;
-        if (CHECKG(x,yy) == val) ret = 0;
+        if (CHECKG(x,yy) == val) ret = false;
     }
 
     /* check for dups in same row. */
     for (xx = 0; xx < state->order; xx++) {
         if (xx == x) continue;
-        if (CHECKG(xx,y) == val) ret = 0;
+        if (CHECKG(xx,y) == val) ret = false;
     }
 
     if (!ret) {
@@ -392,7 +401,7 @@ static int check_num_error(digit *grid, game_state *state,
  *               0 for 'incomplete'
  *               1 for 'complete and correct'
  */
-static int check_complete(digit *grid, game_state *state, int mark_errors)
+static int check_complete(digit *grid, game_state *state, bool mark_errors)
 {
     int x, y, ret = 1, o = state->order;
 
@@ -449,9 +458,9 @@ static int c2n(int c, int order) {
     return -1;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -469,7 +478,7 @@ static char *game_text_format(const game_state *state)
             *p++ = n > 0 ? n2c(n, state->order) : '.';
 
             if (x < (state->order-1)) {
-                if (state->adjacent) {
+                if (state->mode == MODE_ADJACENT) {
                     *p++ = (GRID(state, flags, x, y) & F_ADJ_RIGHT) ? '|' : ' ';
                 } else {
                     if (GRID(state, flags, x, y) & F_ADJ_RIGHT)
@@ -485,7 +494,7 @@ static char *game_text_format(const game_state *state)
 
         if (y < (state->order-1)) {
             for (x = 0; x < state->order; x++) {
-                if (state->adjacent) {
+                if (state->mode == MODE_ADJACENT) {
                     *p++ = (GRID(state, flags, x, y) & F_ADJ_DOWN) ? '-' : ' ';
                 } else {
                     if (GRID(state, flags, x, y) & F_ADJ_DOWN)
@@ -561,7 +570,8 @@ static struct solver_ctx *new_ctx(game_state *state)
     ctx->links = NULL;
     ctx->state = state;
 
-    if (state->adjacent) return ctx; /* adjacent mode doesn't use links. */
+    if (state->mode == MODE_ADJACENT)
+        return ctx; /* adjacent mode doesn't use links. */
 
     for (x = 0; x < o; x++) {
         for (y = 0; y < o; y++) {
@@ -642,7 +652,7 @@ static int solver_links(struct latin_solver *solver, void *vctx)
                                j+1, link->gx+1, link->gy+1);
                     }
 #endif
-                    cube(link->gx, link->gy, j+1) = FALSE;
+                    cube(link->gx, link->gy, j+1) = false;
                     nchanged++;
                 }
             }
@@ -660,7 +670,7 @@ static int solver_links(struct latin_solver *solver, void *vctx)
                                j+1, link->lx+1, link->ly+1);
                     }
 #endif
-                    cube(link->lx, link->ly, j+1) = FALSE;
+                    cube(link->lx, link->ly, j+1) = false;
                     nchanged++;
                 }
             }
@@ -684,7 +694,8 @@ static int solver_adjacent(struct latin_solver *solver, void *vctx)
              * adjacent possibles reflect the adjacent/non-adjacent clue. */
 
             for (i = 0; i < 4; i++) {
-                int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
+                bool isadjacent =
+                    (GRID(ctx->state, flags, x, y) & adjthan[i].f);
 
                 nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
                 if (nx < 0 || ny < 0 || nx >= o || ny >= o)
@@ -697,7 +708,7 @@ static int solver_adjacent(struct latin_solver *solver, void *vctx)
                     if (isadjacent && (gd == 1)) continue;
                     if (!isadjacent && (gd != 1)) continue;
 
-                    if (cube(nx, ny, n+1) == FALSE)
+                    if (!cube(nx, ny, n+1))
                         continue; /* already discounted this possibility. */
 
 #ifdef STANDALONE_SOLVER
@@ -709,7 +720,7 @@ static int solver_adjacent(struct latin_solver *solver, void *vctx)
                                solver_recurse_depth*4, "", n+1, nx+1, ny+1);
                     }
 #endif
-                    cube(nx, ny, n+1) = FALSE;
+                    cube(nx, ny, n+1) = false;
                     nchanged++;
                 }
             }
@@ -731,7 +742,8 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
     for (x = 0; x < o; x++) {
         for (y = 0; y < o; y++) {
             for (i = 0; i < 4; i++) {
-                int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
+                bool isadjacent =
+                    (GRID(ctx->state, flags, x, y) & adjthan[i].f);
 
                 nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
                 if (nx < 0 || ny < 0 || nx >= o || ny >= o)
@@ -745,7 +757,7 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
                 memset(scratch, 0, o*sizeof(int));
 
                 for (n = 0; n < o; n++) {
-                    if (cube(x, y, n+1) == FALSE) continue;
+                    if (!cube(x, y, n+1)) continue;
 
                     for (nn = 0; nn < o; nn++) {
                         if (n == nn) continue;
@@ -762,7 +774,7 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
                  * currently set but are not indicated in scratch. */
                 for (n = 0; n < o; n++) {
                     if (scratch[n] == 1) continue;
-                    if (cube(nx, ny, n+1) == FALSE) continue;
+                    if (!cube(nx, ny, n+1)) continue;
 
 #ifdef STANDALONE_SOLVER
                     if (solver_show_working) {
@@ -773,7 +785,7 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
                                solver_recurse_depth*4, "", n+1, nx+1, ny+1);
                     }
 #endif
-                    cube(nx, ny, n+1) = FALSE;
+                    cube(nx, ny, n+1) = false;
                     nchanged++;
                 }
             }
@@ -786,7 +798,7 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
 static int solver_easy(struct latin_solver *solver, void *vctx)
 {
     struct solver_ctx *ctx = (struct solver_ctx *)vctx;
-    if (ctx->state->adjacent)
+    if (ctx->state->mode == MODE_ADJACENT)
 	return solver_adjacent(solver, vctx);
     else
 	return solver_links(solver, vctx);
@@ -795,7 +807,7 @@ static int solver_easy(struct latin_solver *solver, void *vctx)
 static int solver_set(struct latin_solver *solver, void *vctx)
 {
     struct solver_ctx *ctx = (struct solver_ctx *)vctx;
-    if (ctx->state->adjacent)
+    if (ctx->state->mode == MODE_ADJACENT)
 	return solver_adjacent_set(solver, vctx);
     else
 	return 0;
@@ -866,8 +878,8 @@ static char *latin_desc(digit *sq, size_t order)
     return soln;
 }
 
-/* returns non-zero if it placed (or could have placed) clue. */
-static int gg_place_clue(game_state *state, int ccode, digit *latin, int checkonly)
+/* returns true if it placed (or could have placed) clue. */
+static bool gg_place_clue(game_state *state, int ccode, digit *latin, bool checkonly)
 {
     int loc = ccode / 5, which = ccode % 5;
     int x = loc % state->order, y = loc / state->order;
@@ -883,7 +895,7 @@ static int gg_place_clue(game_state *state, int ccode, digit *latin, int checkon
             }
 #endif
             assert(state->nums[loc] == latin[loc]);
-            return 0;
+            return false;
         }
         if (!checkonly) {
             state->nums[loc] = latin[loc];
@@ -891,31 +903,31 @@ static int gg_place_clue(game_state *state, int ccode, digit *latin, int checkon
     } else {                    /* add flag */
         int lx, ly, lloc;
 
-        if (state->adjacent)
-            return 0; /* never add flag clues in adjacent mode (they're always
-                         all present) */
+        if (state->mode == MODE_ADJACENT)
+            return false; /* never add flag clues in adjacent mode
+                             (they're always all present) */
 
         if (state->flags[loc] & adjthan[which].f)
-            return 0; /* already has flag. */
+            return false; /* already has flag. */
 
         lx = x + adjthan[which].dx;
         ly = y + adjthan[which].dy;
         if (lx < 0 || ly < 0 || lx >= state->order || ly >= state->order)
-            return 0; /* flag compares to off grid */
+            return false; /* flag compares to off grid */
 
         lloc = loc + adjthan[which].dx + adjthan[which].dy*state->order;
         if (latin[loc] <= latin[lloc])
-            return 0; /* flag would be incorrect */
+            return false; /* flag would be incorrect */
 
         if (!checkonly) {
             state->flags[loc] |= adjthan[which].f;
         }
     }
-    return 1;
+    return true;
 }
 
-/* returns non-zero if it removed (or could have removed) the clue. */
-static int gg_remove_clue(game_state *state, int ccode, int checkonly)
+/* returns true if it removed (or could have removed) the clue. */
+static bool gg_remove_clue(game_state *state, int ccode, bool checkonly)
 {
     int loc = ccode / 5, which = ccode % 5;
 #ifdef STANDALONE_SOLVER
@@ -925,7 +937,7 @@ static int gg_remove_clue(game_state *state, int ccode, int checkonly)
     assert(loc < state->order*state->order);
 
     if (which == 4) {           /* remove number. */
-        if (state->nums[loc] == 0) return 0;
+        if (state->nums[loc] == 0) return false;
         if (!checkonly) {
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
@@ -935,10 +947,10 @@ static int gg_remove_clue(game_state *state, int ccode, int checkonly)
             state->nums[loc] = 0;
         }
     } else {                    /* remove flag */
-        if (state->adjacent)
-            return 0; /* never remove clues in adjacent mode. */
+        if (state->mode == MODE_ADJACENT)
+            return false; /* never remove clues in adjacent mode. */
 
-        if (!(state->flags[loc] & adjthan[which].f)) return 0;
+        if (!(state->flags[loc] & adjthan[which].f)) return false;
         if (!checkonly) {
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
@@ -948,7 +960,7 @@ static int gg_remove_clue(game_state *state, int ccode, int checkonly)
             state->flags[loc] &= ~adjthan[which].f;
         }
     }
-    return 1;
+    return true;
 }
 
 static int gg_best_clue(game_state *state, int *scratch, digit *latin)
@@ -965,7 +977,7 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin)
 #endif
 
     for (i = ls; i-- > 0 ;) {
-        if (!gg_place_clue(state, scratch[i], latin, 1)) continue;
+        if (!gg_place_clue(state, scratch[i], latin, true)) continue;
 
         loc = scratch[i] / 5;
         for (j = nposs = 0; j < state->order; j++) {
@@ -997,7 +1009,7 @@ int maxtries;
 #else
 #define MAXTRIES 50
 #endif
-int gg_solved;
+static int gg_solved;
 
 static int game_assemble(game_state *new, int *scratch, digit *latin,
                          int difficulty)
@@ -1026,8 +1038,8 @@ static int game_assemble(game_state *new, int *scratch, digit *latin,
         if (solver_state(copy, difficulty) == 1) break;
 
         best = gg_best_clue(copy, scratch, latin);
-        gg_place_clue(new, scratch[best], latin, 0);
-        gg_place_clue(copy, scratch[best], latin, 0);
+        gg_place_clue(new, scratch[best], latin, false);
+        gg_place_clue(copy, scratch[best], latin, false);
     }
     free_game(copy);
 #ifdef STANDALONE_SOLVER
@@ -1044,20 +1056,20 @@ static void game_strip(game_state *new, int *scratch, digit *latin,
                        int difficulty)
 {
     int o = new->order, o2 = o*o, lscratch = o2*5, i;
-    game_state *copy = blank_game(new->order, new->adjacent);
+    game_state *copy = blank_game(new->order, new->mode);
 
     /* For each symbol (if it exists in new), try and remove it and
      * solve again; if we couldn't solve without it put it back. */
     for (i = 0; i < lscratch; i++) {
-        if (!gg_remove_clue(new, scratch[i], 0)) continue;
+        if (!gg_remove_clue(new, scratch[i], false)) continue;
 
         memcpy(copy->nums,  new->nums,  o2 * sizeof(digit));
         memcpy(copy->flags, new->flags, o2 * sizeof(unsigned int));
         gg_solved++;
         if (solver_state(copy, difficulty) != 1) {
             /* put clue back, we can't solve without it. */
-            int ret = gg_place_clue(new, scratch[i], latin, 0);
-            assert(ret == 1);
+            bool ret = gg_place_clue(new, scratch[i], latin, false);
+            assert(ret);
         } else {
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
@@ -1099,7 +1111,7 @@ static void add_adjacent_flags(game_state *state, digit *latin)
 }
 
 static char *new_game_desc(const game_params *params_in, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     game_params params_copy = *params_in; /* structure copy */
     game_params *params = &params_copy;
@@ -1108,7 +1120,7 @@ static char *new_game_desc(const game_params *params_in, random_state *rs,
     int o2 = params->order * params->order, ntries = 1;
     int *scratch, lscratch = o2*5;
     char *ret, buf[80];
-    game_state *state = blank_game(params->order, params->adjacent);
+    game_state *state = blank_game(params->order, params->mode);
 
     /* Generate a list of 'things to strip' (randomised later) */
     scratch = snewn(lscratch, int);
@@ -1131,7 +1143,7 @@ generate:
     memset(state->nums, 0, o2 * sizeof(digit));
     memset(state->flags, 0, o2 * sizeof(unsigned int));
 
-    if (state->adjacent) {
+    if (state->mode == MODE_ADJACENT) {
         /* All adjacency flags are always present. */
         add_adjacent_flags(state, sq);
     }
@@ -1197,7 +1209,7 @@ generate:
 static game_state *load_game(const game_params *params, const char *desc,
                              const char **why_r)
 {
-    game_state *state = blank_game(params->order, params->adjacent);
+    game_state *state = blank_game(params->order, params->mode);
     const char *p = desc;
     int i = 0, n, o = params->order, x, y;
     const char *why = NULL;
@@ -1254,7 +1266,7 @@ static game_state *load_game(const game_params *params, const char *desc,
                     if (nx < 0 || ny < 0 || nx >= o || ny >= o) {
                         why = "Flags go off grid"; goto fail;
                     }
-                    if (params->adjacent) {
+                    if (params->mode == MODE_ADJACENT) {
                         /* if one cell is adjacent to another, the other must
                          * also be adjacent to the first. */
                         if (!(GRID(state, flags, nx, ny) & adjthan[n].fo)) {
@@ -1348,7 +1360,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
 
 struct game_ui {
     int hx, hy;                         /* as for solo.c, highlight pos */
-    int hshow, hpencil, hcursor;        /* show state, type, and ?cursor. */
+    bool hshow, hpencil, hcursor;       /* show state, type, and ?cursor. */
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1356,7 +1368,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
 
     return ui;
 }
@@ -1383,18 +1397,21 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      * pencil mode. */
     if (ui->hshow && ui->hpencil && !ui->hcursor &&
         GRID(newstate, nums, ui->hx, ui->hy) != 0) {
-        ui->hshow = 0;
+        ui->hshow = false;
     }
 }
 
 struct game_drawstate {
-    int tilesize, order, started, adjacent;
+    int tilesize, order;
+    bool started;
+    Mode mode;
     digit *nums;                /* copy of nums, o^2 */
     unsigned char *hints;       /* copy of hints, o^3 */
     unsigned int *flags;        /* o^2 */
 
-    int hx, hy, hshow, hpencil; /* as for game_ui. */
-    int hflash;
+    int hx, hy;
+    bool hshow, hpencil;        /* as for game_ui. */
+    bool hflash;
 };
 
 static char *interpret_move(const game_state *state, game_ui *ui,
@@ -1403,7 +1420,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     int x = FROMCOORD(ox), y = FROMCOORD(oy), n;
     char buf[80];
-    int shift_or_control = button & (MOD_SHFT | MOD_CTRL);
+    bool shift_or_control = button & (MOD_SHFT | MOD_CTRL);
 
     button &= ~MOD_MASK;
 
@@ -1432,38 +1449,40 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         if (button == LEFT_BUTTON) {
             /* normal highlighting for non-immutable squares */
             if (GRID(state, flags, x, y) & F_IMMUTABLE)
-                ui->hshow = 0;
+                ui->hshow = false;
             else if (x == ui->hx && y == ui->hy &&
-                     ui->hshow && ui->hpencil == 0)
-                ui->hshow = 0;
+                     ui->hshow && !ui->hpencil)
+                ui->hshow = false;
             else {
-                ui->hx = x; ui->hy = y; ui->hpencil = 0;
-                ui->hshow = 1;
+                ui->hx = x; ui->hy = y; ui->hpencil = false;
+                ui->hshow = true;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
         if (button == RIGHT_BUTTON) {
             /* pencil highlighting for non-filled squares */
             if (GRID(state, nums, x, y) != 0)
-                ui->hshow = 0;
+                ui->hshow = false;
             else if (x == ui->hx && y == ui->hy &&
                      ui->hshow && ui->hpencil)
-                ui->hshow = 0;
+                ui->hshow = false;
             else {
-                ui->hx = x; ui->hy = y; ui->hpencil = 1;
-                ui->hshow = 1;
+                ui->hx = x; ui->hy = y; ui->hpencil = true;
+                ui->hshow = true;
             }
-            ui->hcursor = 0;
+            ui->hcursor = false;
             return UI_UPDATE;
         }
     }
 
     if (IS_CURSOR_MOVE(button)) {
 	if (shift_or_control) {
-	    int nx = ui->hx, ny = ui->hy, i, self;
-	    move_cursor(button, &nx, &ny, ds->order, ds->order, FALSE);
-	    ui->hshow = ui->hcursor = 1;
+	    int nx = ui->hx, ny = ui->hy, i;
+            bool self;
+	    move_cursor(button, &nx, &ny, ds->order, ds->order, false);
+	    ui->hshow = true;
+            ui->hcursor = true;
 
 	    for (i = 0; i < 4 && (nx != ui->hx + adjthan[i].dx ||
 				  ny != ui->hy + adjthan[i].dy); ++i);
@@ -1476,7 +1495,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 		  GRID(state, flags, nx,     ny    ) & adjthan[i].fo))
 		return UI_UPDATE; /* no clue to toggle */
 
-	    if (state->adjacent)
+	    if (state->mode == MODE_ADJACENT)
 		self = (adjthan[i].dx >= 0 && adjthan[i].dy >= 0);
 	    else
 		self = (GRID(state, flags, ui->hx, ui->hy) & adjthan[i].f);
@@ -1490,14 +1509,15 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
 	    return dupstr(buf);
 	} else {
-	    move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, FALSE);
-	    ui->hshow = ui->hcursor = 1;
+	    move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, false);
+	    ui->hshow = true;
+            ui->hcursor = true;
 	    return UI_UPDATE;
 	}
     }
     if (ui->hshow && IS_CURSOR_SELECT(button)) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
@@ -1519,7 +1539,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         sprintf(buf, "%c%d,%d,%d",
                 (char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
 
-        if (!ui->hcursor) ui->hshow = 0;
+        if (!ui->hcursor) ui->hshow = false;
 
         return dupstr(buf);
     }
@@ -1552,15 +1572,15 @@ static game_state *execute_move(const game_state *state, const char *move)
                 HINT(ret, x, y, i) = 0;
 
             /* real change to grid; check for completion */
-            if (!ret->completed && check_complete(ret->nums, ret, 1) > 0)
-                ret->completed = TRUE;
+            if (!ret->completed && check_complete(ret->nums, ret, true) > 0)
+                ret->completed = true;
         }
         return ret;
     } else if (move[0] == 'S') {
         const char *p;
 
         ret = dup_game(state);
-        ret->completed = ret->cheated = TRUE;
+        ret->completed = ret->cheated = true;
 
         p = move+1;
         for (i = 0; i < state->order*state->order; i++) {
@@ -1571,7 +1591,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             p++;
         }
         if (*p) goto badmove;
-        rc = check_complete(ret->nums, ret, 1);
+        rc = check_complete(ret->nums, ret, true);
 	assert(rc > 0);
         return ret;
     } else if (move[0] == 'M') {
@@ -1586,7 +1606,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         return ret;
     } else if (move[0] == 'H') {
         ret = solver_hint(state, NULL, DIFF_EASY, DIFF_EASY);
-        check_complete(ret->nums, ret, 1);
+        check_complete(ret->nums, ret, true);
         return ret;
     } else if (move[0] == 'F' && sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
 	       x >= 0 && x < state->order && y >= 0 && y < state->order) {
@@ -1659,7 +1679,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
 
     ds->tilesize = 0;
     ds->order = state->order;
-    ds->adjacent = state->adjacent;
+    ds->mode = state->mode;
 
     ds->nums = snewn(o2, digit);
     ds->hints = snewn(o3, unsigned char);
@@ -1669,7 +1689,10 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     memset(ds->flags, 0, o2*sizeof(unsigned int));
 
     ds->hx = ds->hy = 0;
-    ds->started = ds->hshow = ds->hpencil = ds->hflash = 0;
+    ds->started = false;
+    ds->hshow = false;
+    ds->hpencil = false;
+    ds->hflash = false;
 
     return ds;
 }
@@ -1771,9 +1794,10 @@ static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy,
 
 static void draw_furniture(drawing *dr, game_drawstate *ds,
                            const game_state *state, const game_ui *ui,
-                           int x, int y, int hflash)
+                           int x, int y, bool hflash)
 {
-    int ox = COORD(x), oy = COORD(y), bg, hon;
+    int ox = COORD(x), oy = COORD(y), bg;
+    bool hon;
     unsigned int f = GRID(state, flags, x, y);
 
     bg = hflash ? COL_HIGHLIGHT : COL_BACKGROUND;
@@ -1802,7 +1826,7 @@ static void draw_furniture(drawing *dr, game_drawstate *ds,
     draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
 
     /* Draw the adjacent clue signs. */
-    if (ds->adjacent)
+    if (ds->mode == MODE_ADJACENT)
         draw_adjs(dr, ds, ox, oy, f, COL_BACKGROUND, COL_GRID);
     else
         draw_gts(dr, ds, ox, oy, f, COL_BACKGROUND, COL_TEXT);
@@ -1866,13 +1890,14 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                         int dir, const game_ui *ui,
                         float animtime, float flashtime)
 {
-    int x, y, i, hchanged = 0, stale, hflash = 0;
+    int x, y, i;
+    bool hchanged = false, stale, hflash = false;
 
     debug(("highlight old (%d,%d), new (%d,%d)", ds->hx, ds->hy, ui->hx, ui->hy));
 
     if (flashtime > 0 &&
         (flashtime <= FLASH_TIME/3 || flashtime >= FLASH_TIME*2/3))
-         hflash = 1;
+         hflash = true;
 
     if (!ds->started) {
         draw_rect(dr, 0, 0, DRAW_SIZE, DRAW_SIZE, COL_BACKGROUND);
@@ -1880,30 +1905,30 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     }
     if (ds->hx != ui->hx || ds->hy != ui->hy ||
         ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
-        hchanged = 1;
+        hchanged = true;
 
     for (x = 0; x < ds->order; x++) {
         for (y = 0; y < ds->order; y++) {
             if (!ds->started)
-                stale = 1;
+                stale = true;
             else if (hflash != ds->hflash)
-                stale = 1;
+                stale = true;
             else
-                stale = 0;
+                stale = false;
 
             if (hchanged) {
                 if ((x == ui->hx && y == ui->hy) ||
                     (x == ds->hx && y == ds->hy))
-                    stale = 1;
+                    stale = true;
             }
 
             if (GRID(state, nums, x, y) != GRID(ds, nums, x, y)) {
                 GRID(ds, nums, x, y) = GRID(state, nums, x, y);
-                stale = 1;
+                stale = true;
             }
             if (GRID(state, flags, x, y) != GRID(ds, flags, x, y)) {
                 GRID(ds, flags, x, y) = GRID(state, flags, x, y);
-                stale = 1;
+                stale = true;
             }
             if (GRID(ds, nums, x, y) == 0) {
                 /* We're not a number square (therefore we might
@@ -1911,7 +1936,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                 for (i = 0; i < ds->order; i++) {
                     if (HINT(state, x, y, i) != HINT(ds, x, y, i)) {
                         HINT(ds, x, y, i) = HINT(state, x, y, i);
-                        stale = 1;
+                        stale = true;
                     }
                 }
             }
@@ -1928,7 +1953,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     ds->hshow = ui->hshow;
     ds->hpencil = ui->hpencil;
 
-    ds->started = 1;
+    ds->started = true;
     ds->hflash = hflash;
 }
 
@@ -1952,9 +1977,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1993,7 +2018,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
                       FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
                       ink, str);
 
-            if (state->adjacent)
+            if (state->mode == MODE_ADJACENT)
                 draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
             else
                 draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
@@ -2017,15 +2042,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2042,9 +2067,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
 };
 
@@ -2145,7 +2170,7 @@ static int solve(game_params *p, char *desc, int debug)
 
 static void check(game_params *p)
 {
-    const char *msg = validate_params(p, 1);
+    const char *msg = validate_params(p, true);
     if (msg) {
         fprintf(stderr, "%s: %s", quis, msg);
         exit(1);
@@ -2160,7 +2185,7 @@ static int gen(game_params *p, random_state *rs, int debug)
     check(p);
 
     solver_show_working = debug;
-    desc = new_game_desc(p, rs, &aux, 0);
+    desc = new_game_desc(p, rs, &aux, false);
     diff = solve(p, desc, debug);
     sfree(aux);
     sfree(desc);
@@ -2183,12 +2208,12 @@ static void soak(game_params *p, random_state *rs)
     tt_start = tt_now = time(NULL);
 
     printf("Soak-generating an %s %dx%d grid, difficulty %s.\n",
-           p->adjacent ? "adjacent" : "unequal",
+           p->mode == MODE_ADJACENT ? "adjacent" : "unequal",
            p->order, p->order, unequal_diffnames[p->diff]);
 
     while (1) {
         p->diff = realdiff;
-        desc = new_game_desc(p, rs, &aux, 0);
+        desc = new_game_desc(p, rs, &aux, false);
         st = new_game(NULL, p, desc);
         solver_state(st, DIFF_RECURSIVE);
         free_game(st);
diff --git a/apps/plugins/puzzles/src/unfinished/group.c b/apps/plugins/puzzles/src/unfinished/group.c
index 72293dd4ea..ef7ffba349 100644
--- a/apps/plugins/puzzles/src/unfinished/group.c
+++ b/apps/plugins/puzzles/src/unfinished/group.c
@@ -78,15 +78,21 @@ enum {
 #define TOCHAR(c,id) (E_FROM_FRONT(c,id) + ('a'-1))
 
 struct game_params {
-    int w, diff, id;
+    int w, diff;
+    bool id;
 };
 
+typedef struct group_common {
+    int refcount;
+    bool *immutable;
+} group_common;
+
 struct game_state {
     game_params par;
     digit *grid;
-    unsigned char *immutable;
     int *pencil;		       /* bitmaps using bits 1<<1..1<<n */
-    int completed, cheated;
+    group_common *common;
+    bool completed, cheated;
     digit *sequence;                   /* sequence of group elements shown */
 
     /*
@@ -112,28 +118,28 @@ static game_params *default_params(void)
 
     ret->w = 6;
     ret->diff = DIFF_NORMAL;
-    ret->id = TRUE;
+    ret->id = true;
 
     return ret;
 }
 
 const static struct game_params group_presets[] = {
-    {  6, DIFF_NORMAL, TRUE },
-    {  6, DIFF_NORMAL, FALSE },
-    {  8, DIFF_NORMAL, TRUE },
-    {  8, DIFF_NORMAL, FALSE },
-    {  8, DIFF_HARD, TRUE },
-    {  8, DIFF_HARD, FALSE },
-    { 12, DIFF_NORMAL, TRUE },
+    {  6, DIFF_NORMAL, true },
+    {  6, DIFF_NORMAL, false },
+    {  8, DIFF_NORMAL, true },
+    {  8, DIFF_NORMAL, false },
+    {  8, DIFF_HARD, true },
+    {  8, DIFF_HARD, false },
+    { 12, DIFF_NORMAL, true },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+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;
+        return false;
 
     ret = snew(game_params);
     *ret = group_presets[i]; /* structure copy */
@@ -143,7 +149,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -165,7 +171,7 @@ static void decode_params(game_params *params, char const *string)
     params->w = atoi(p);
     while (*p && isdigit((unsigned char)*p)) p++;
     params->diff = DIFF_NORMAL;
-    params->id = TRUE;
+    params->id = true;
 
     while (*p) {
 	if (*p == 'd') {
@@ -180,7 +186,7 @@ static void decode_params(game_params *params, char const *string)
 		p++;
 	    }
 	} else if (*p == 'i') {
-	    params->id = FALSE;
+	    params->id = false;
 	    p++;
 	} else {
 	    /* unrecognised character */
@@ -189,7 +195,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char ret[80];
 
@@ -240,7 +246,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+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";
@@ -593,7 +599,7 @@ static const struct groups groups[] = {
 /* ----- data generated by group.gap ends ----- */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, a = w*w;
     digit *grid, *soln, *soln2;
@@ -849,11 +855,13 @@ static game_state *new_game(midend *me, const game_params *params,
 
     state->par = *params;	       /* structure copy */
     state->grid = snewn(a, digit);
-    state->immutable = snewn(a, unsigned char);
+    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->immutable[i] = 0;
+	state->common->immutable[i] = false;
 	state->pencil[i] = 0;
     }
     state->sequence = snewn(w, digit);
@@ -866,9 +874,10 @@ static game_state *new_game(midend *me, const game_params *params,
     desc = spec_to_grid(desc, state->grid, a);
     for (i = 0; i < a; i++)
 	if (state->grid[i] != 0)
-	    state->immutable[i] = TRUE;
+	    state->common->immutable[i] = true;
 
-    state->completed = state->cheated = FALSE;
+    state->completed = false;
+    state->cheated = false;
 
     return state;
 }
@@ -881,12 +890,12 @@ static game_state *dup_game(const game_state *state)
     ret->par = state->par;	       /* structure copy */
 
     ret->grid = snewn(a, digit);
-    ret->immutable = snewn(a, unsigned char);
+    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->immutable, state->immutable, a*sizeof(unsigned char));
     memcpy(ret->pencil, state->pencil, a*sizeof(int));
     memcpy(ret->sequence, state->sequence, w*sizeof(digit));
     memcpy(ret->dividers, state->dividers, w*sizeof(int));
@@ -900,7 +909,10 @@ static game_state *dup_game(const game_state *state)
 static void free_game(game_state *state)
 {
     sfree(state->grid);
-    sfree(state->immutable);
+    if (--state->common->refcount == 0) {
+        sfree(state->common->immutable);
+        sfree(state->common);
+    }
     sfree(state->pencil);
     sfree(state->sequence);
     sfree(state);
@@ -940,9 +952,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return out;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1001,7 +1013,7 @@ struct game_ui {
      * This indicates whether the current highlight is a
      * pencil-mark one or a real one.
      */
-    int hpencil;
+    bool hpencil;
     /*
      * This indicates whether or not we're showing the highlight
      * (used to be hx = hy = -1); important so that when we're
@@ -1009,13 +1021,13 @@ struct game_ui {
      * fixed position. When hshow = 1, pressing a valid number
      * or letter key or Space will enter that number or letter in the grid.
      */
-    int hshow;
+    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.
      */
-    int hcursor;
+    bool hcursor;
     /*
      * This indicates whether we're dragging a table header to
      * reposition an entire row or column.
@@ -1031,7 +1043,9 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
 
     ui->hx = ui->hy = 0;
-    ui->hpencil = ui->hshow = ui->hcursor = 0;
+    ui->hpencil = false;
+    ui->hshow = false;
+    ui->hcursor = false;
     ui->drag = 0;
 
     return ui;
@@ -1063,7 +1077,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
      */
     if (ui->hshow && ui->hpencil && !ui->hcursor &&
         newstate->grid[ui->hy * w + ui->hx] != 0) {
-        ui->hshow = 0;
+        ui->hshow = false;
     }
     if (ui->hshow && ui->odn > 1) {
         /*
@@ -1075,12 +1089,12 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
         for (i = 0; i < ui->odn; i++) {
             if (oldstate->sequence[ui->ohx + i*ui->odx] !=
                 newstate->sequence[ui->ohx + i*ui->odx]) {
-                ui->hshow = 0;
+                ui->hshow = false;
                 break;
             }
             if (oldstate->sequence[ui->ohy + i*ui->ody] !=
                 newstate->sequence[ui->ohy + i*ui->ody]) {
-                ui->hshow = 0;
+                ui->hshow = false;
                 break;
             }
         }
@@ -1132,17 +1146,18 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     game_params par;
     int w, tilesize;
-    int started;
+    bool started;
     long *tiles, *legend, *pencil, *errors;
     long *errtmp;
     digit *sequence;
 };
 
-static int check_errors(const game_state *state, long *errors)
+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, errs = FALSE;
+    int i, j, k, x, y;
+    bool errs = false;
 
     /*
      * To verify that we have a valid group table, it suffices to
@@ -1185,7 +1200,7 @@ static int check_errors(const game_state *state, long *errors)
 	}
 
 	if (mask != (1 << (w+1)) - (1 << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1UL;
 	    if (errors) {
 		for (x = 0; x < w; x++)
@@ -1204,7 +1219,7 @@ static int check_errors(const game_state *state, long *errors)
 	}
 
 	if (mask != (1 << (w+1)) - (1 << 1)) {
-	    errs = TRUE;
+	    errs = true;
 	    errmask &= ~1UL;
 	    if (errors) {
 		for (y = 0; y < w; y++)
@@ -1240,7 +1255,7 @@ static int check_errors(const game_state *state, long *errors)
 			    errors[right] |= err << EF_RIGHT_SHIFT;
 			}
 		    }
-		    errs = TRUE;
+		    errs = true;
 		}
 
     return errs;
@@ -1304,8 +1319,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             ty = state->sequence[ty];
             if (button == LEFT_BUTTON) {
                 if (tx == ui->hx && ty == ui->hy &&
-                    ui->hshow && ui->hpencil == 0) {
-                    ui->hshow = 0;
+                    ui->hshow && !ui->hpencil) {
+                    ui->hshow = false;
                 } else {
                     ui->hx = tx;
                     ui->hy = ty;
@@ -1313,10 +1328,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                     ui->ohy = oty;
                     ui->odx = ui->ody = 0;
                     ui->odn = 1;
-                    ui->hshow = !state->immutable[ty*w+tx];
-                    ui->hpencil = 0;
+                    ui->hshow = !state->common->immutable[ty*w+tx];
+                    ui->hpencil = false;
                 }
-                ui->hcursor = 0;
+                ui->hcursor = false;
                 return UI_UPDATE;
             }
             if (button == RIGHT_BUTTON) {
@@ -1326,21 +1341,21 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 if (state->grid[ty*w+tx] == 0) {
                     if (tx == ui->hx && ty == ui->hy &&
                         ui->hshow && ui->hpencil) {
-                        ui->hshow = 0;
+                        ui->hshow = false;
                     } else {
-                        ui->hpencil = 1;
+                        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 = 1;
+                        ui->hshow = true;
                     }
                 } else {
-                    ui->hshow = 0;
+                    ui->hshow = false;
                 }
-                ui->hcursor = 0;
+                ui->hcursor = false;
                 return UI_UPDATE;
             }
         } else if (tx >= 0 && tx < w && ty == -1) {
@@ -1373,16 +1388,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     if (IS_CURSOR_MOVE(button)) {
         int cx = find_in_sequence(state->sequence, w, ui->hx);
         int cy = find_in_sequence(state->sequence, w, ui->hy);
-        move_cursor(button, &cx, &cy, w, w, 0);
+        move_cursor(button, &cx, &cy, w, w, false);
         ui->hx = state->sequence[cx];
         ui->hy = state->sequence[cy];
-        ui->hshow = ui->hcursor = 1;
+        ui->hshow = true;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
     if (ui->hshow &&
         (button == CURSOR_SELECT)) {
-        ui->hpencil = 1 - ui->hpencil;
-        ui->hcursor = 1;
+        ui->hpencil = !ui->hpencil;
+        ui->hcursor = true;
         return UI_UPDATE;
     }
 
@@ -1417,7 +1433,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
              */
             if (!ui->hpencil && state->grid[index] == n)
                 /* OK even if it is immutable */;
-            else if (state->immutable[index])
+            else if (state->common->immutable[index])
                 return NULL;
         }
 
@@ -1433,7 +1449,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         }
         movebuf = sresize(movebuf, buflen+1, char);
 
-        if (!ui->hcursor) ui->hshow = 0;
+        if (!ui->hcursor) ui->hshow = false;
 
 	return movebuf;
     }
@@ -1452,7 +1468,7 @@ static game_state *execute_move(const game_state *from, const char *move)
 
     if (move[0] == 'S') {
 	ret = dup_game(from);
-	ret->completed = ret->cheated = TRUE;
+	ret->completed = ret->cheated = true;
 
 	for (i = 0; i < a; i++) {
 	    if (!ISCHAR(move[i+1]) || FROMCHAR(move[i+1], from->par.id) > w) {
@@ -1473,7 +1489,7 @@ static game_state *execute_move(const game_state *from, const char *move)
                sscanf(move+1, "%d,%d,%d%n", &x, &y, &n, &pos) == 3 &&
                n >= 0 && n <= w) {
         const char *mp = move + 1 + pos;
-        int pencil = (move[0] == 'P');
+        bool pencil = (move[0] == 'P');
         ret = dup_game(from);
 
         while (1) {
@@ -1481,7 +1497,8 @@ static game_state *execute_move(const game_state *from, const char *move)
                 free_game(ret);
                 return NULL;
             }
-            if (from->immutable[y*w+x] && !(!pencil && from->grid[y*w+x] == n))
+            if (from->common->immutable[y*w+x] &&
+                !(!pencil && from->grid[y*w+x] == n))
                 return NULL;
 
             if (move[0] == 'P' && n > 0) {
@@ -1502,7 +1519,7 @@ static game_state *execute_move(const game_state *from, const char *move)
         }
 
         if (!ret->completed && !check_errors(ret, NULL))
-            ret->completed = TRUE;
+            ret->completed = true;
 
 	return ret;
     } else if (move[0] == 'M') {
@@ -1621,7 +1638,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->w = w;
     ds->par = state->par;	       /* structure copy */
     ds->tilesize = 0;
-    ds->started = FALSE;
+    ds->started = false;
     ds->tiles = snewn(a, long);
     ds->legend = snewn(w, long);
     ds->pencil = snewn(a, long);
@@ -1845,7 +1862,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
 	draw_update(dr, 0, 0, SIZE(w), SIZE(w));
 
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     check_errors(state, ds->errtmp);
@@ -1894,7 +1911,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	    else
 		pencil = (long)state->pencil[sy*w+sx];
 
-	    if (state->immutable[sy*w+sx])
+	    if (state->common->immutable[sy*w+sx])
 		tile |= DF_IMMUTABLE;
 
             if ((ui->drag == 5 && ui->dragnum == sy) ||
@@ -1902,7 +1919,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                 tile |= DF_HIGHLIGHT;
             } else if (ui->hshow) {
                 int i = abs(x - ui->ohx);
-                int highlight = 0;
+                bool highlight = false;
                 if (ui->odn > 1) {
                     /*
                      * When a diagonal multifill selection is shown,
@@ -1913,7 +1930,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                     if (i >= 0 && i < ui->odn &&
                         x == ui->ohx + i*ui->odx &&
                         y == ui->ohy + i*ui->ody)
-                        highlight = 1;
+                        highlight = true;
                 } else {
                     /*
                      * For a single square, we move its highlight
@@ -1973,11 +1990,11 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
     if (state->completed)
-	return FALSE;
-    return TRUE;
+	return false;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2068,15 +2085,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2093,9 +2110,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     REQUIRE_RBUTTON | REQUIRE_NUMPAD,  /* flags */
 };
 
@@ -2110,15 +2127,16 @@ int main(int argc, char **argv)
     char *id = NULL, *desc;
     const char *err;
     digit *grid;
-    int grade = FALSE;
-    int ret, diff, really_show_working = FALSE;
+    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;
+            really_show_working = true;
         } else if (!strcmp(p, "-g")) {
-            grade = TRUE;
+            grade = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
@@ -2156,7 +2174,7 @@ int main(int argc, char **argv)
      * the puzzle internally before doing anything else.
      */
     ret = -1;			       /* placate optimiser */
-    solver_show_working = FALSE;
+    solver_show_working = 0;
     for (diff = 0; diff < DIFFCOUNT; diff++) {
 	memcpy(grid, s->grid, p->w * p->w);
 	ret = solver(&s->par, grid, diff);
diff --git a/apps/plugins/puzzles/src/unfinished/numgame.c b/apps/plugins/puzzles/src/unfinished/numgame.c
index aed5c17347..d444b2257b 100644
--- a/apps/plugins/puzzles/src/unfinished/numgame.c
+++ b/apps/plugins/puzzles/src/unfinished/numgame.c
@@ -182,8 +182,8 @@ struct operation {
     int commutes;
 
     /*
-     * Function which implements the operator. Returns TRUE on
-     * success, FALSE on failure. Takes two rationals and writes
+     * 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);
@@ -196,21 +196,21 @@ struct rules {
 
 #define MUL(r, a, b) do { \
     (r) = (a) * (b); \
-    if ((b) && (a) && (r) / (b) != (a)) return FALSE; \
+    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; \
+    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; \
+    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); \
@@ -238,7 +238,7 @@ static int perform_add(int *a, int *b, int *output)
     ADD(tn, at, bt);
     MUL(bn, a[1], b[1]);
     OUT(output, tn, bn);
-    return TRUE;
+    return true;
 }
 
 static int perform_sub(int *a, int *b, int *output)
@@ -252,7 +252,7 @@ static int perform_sub(int *a, int *b, int *output)
     ADD(tn, at, -bt);
     MUL(bn, a[1], b[1]);
     OUT(output, tn, bn);
-    return TRUE;
+    return true;
 }
 
 static int perform_mul(int *a, int *b, int *output)
@@ -264,7 +264,7 @@ static int perform_mul(int *a, int *b, int *output)
     MUL(tn, a[0], b[0]);
     MUL(bn, a[1], b[1]);
     OUT(output, tn, bn);
-    return TRUE;
+    return true;
 }
 
 static int perform_div(int *a, int *b, int *output)
@@ -275,7 +275,7 @@ static int perform_div(int *a, int *b, int *output)
      * Division by zero is outlawed.
      */
     if (b[0] == 0)
-	return FALSE;
+	return false;
 
     /*
      * a0/a1 / b0/b1 = (a0*b1) / (a1*b0)
@@ -283,7 +283,7 @@ static int perform_div(int *a, int *b, int *output)
     MUL(tn, a[0], b[1]);
     MUL(bn, a[1], b[0]);
     OUT(output, tn, bn);
-    return TRUE;
+    return true;
 }
 
 static int perform_exact_div(int *a, int *b, int *output)
@@ -294,7 +294,7 @@ static int perform_exact_div(int *a, int *b, int *output)
      * Division by zero is outlawed.
      */
     if (b[0] == 0)
-	return FALSE;
+	return false;
 
     /*
      * a0/a1 / b0/b1 = (a0*b1) / (a1*b0)
@@ -324,9 +324,9 @@ static int max_p10(int n, int *p10_r)
     while (p10 <= (INT_MAX/10) && p10 <= n)
 	p10 *= 10;
     if (p10 > INT_MAX/10)
-	return FALSE;		       /* integer overflow */
+	return false;		       /* integer overflow */
     *p10_r = p10;
-    return TRUE;
+    return true;
 }
 
 static int perform_concat(int *a, int *b, int *output)
@@ -338,7 +338,7 @@ static int perform_concat(int *a, int *b, int *output)
      * integer.
      */
     if (a[1] != 1 || b[1] != 1 || a[0] < 0 || b[0] < 0)
-	return FALSE;
+	return false;
 
     /*
      * For concatenation, we can safely assume leading zeroes
@@ -357,14 +357,14 @@ static int perform_concat(int *a, int *b, int *output)
      * _end_ of the 1 first.
      */
     if (a[0] == 0)
-	return FALSE;
+	return false;
 
-    if (!max_p10(b[0], &p10)) 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;
+    return true;
 }
 
 #define IPOW(ret, x, y) do { \
@@ -400,7 +400,7 @@ static int perform_exp(int *a, int *b, int *output)
 	IPOW(xn, an, b[1]);
 	IPOW(xd, ad, b[1]);
 	if (xn != a[0] || xd != a[1])
-	    return FALSE;
+	    return false;
     } else {
 	an = a[0];
 	ad = a[1];
@@ -413,10 +413,10 @@ static int perform_exp(int *a, int *b, int *output)
 	IPOW(xn, ad, -b[0]);
     }
     if (xd == 0)
-	return FALSE;
+	return false;
 
     OUT(output, xn, xd);
-    return TRUE;
+    return true;
 }
 
 static int perform_factorial(int *a, int *b, int *output)
@@ -427,14 +427,14 @@ static int perform_factorial(int *a, int *b, int *output)
      * Factorials of non-negative integers are permitted.
      */
     if (a[1] != 1 || a[0] < 0)
-	return FALSE;
+	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;
+	return false;
 
     ret = 1;
     for (i = 1; i <= a[0]; i++) {
@@ -443,7 +443,7 @@ static int perform_factorial(int *a, int *b, int *output)
     }
 
     OUT(output, ret, 1);
-    return TRUE;
+    return true;
 }
 
 static int perform_decimal(int *a, int *b, int *output)
@@ -458,12 +458,12 @@ static int perform_decimal(int *a, int *b, int *output)
      * x --> x / (smallest power of 10 > than x)
      *
      */
-    if (a[1] != 1) return FALSE;
+    if (a[1] != 1) return false;
 
-    if (!max_p10(a[0], &p10)) return FALSE;
+    if (!max_p10(a[0], &p10)) return false;
 
     OUT(output, a[0], p10);
-    return TRUE;
+    return true;
 }
 
 static int perform_recur(int *a, int *b, int *output)
@@ -478,20 +478,20 @@ static int perform_recur(int *a, int *b, int *output)
      * 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 */
+    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;
+    return false;
 found:
     tn = a[0] * (p10 / a[1]);
     bn = p10 - 1;
 
     OUT(output, tn, bn);
-    return TRUE;
+    return true;
 }
 
 static int perform_root(int *a, int *b, int *output)
@@ -504,7 +504,7 @@ static int perform_root(int *a, int *b, int *output)
 
     if (a[0] == 0) {
         OUT(output, 1, 1);
-        return TRUE;
+        return true;
     }
 
     OUT(ainv, a[1], a[0]);
@@ -514,11 +514,11 @@ static int perform_root(int *a, int *b, int *output)
 
 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;
+    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;
+    return true;
 }
 
 static int perform_gamma(int *a, int *b, int *output)
@@ -531,7 +531,7 @@ static int perform_gamma(int *a, int *b, int *output)
      * special case not caught by perform_fact: gamma(1) is 1 so
      * don't bother.
      */
-    if (a[0] == 1 && a[1] == 1) return FALSE;
+    if (a[0] == 1 && a[1] == 1) return false;
 
     OUT(asub1, a[0]-a[1], a[1]);
     return perform_factorial(asub1, b, output);
@@ -544,53 +544,53 @@ static int perform_sqrt(int *a, int *b, int *output)
     /*
      * sqrt(0) == 0, sqrt(1) == 1: don't perform unary noops.
      */
-    if (a[0] == 0 || (a[0] == 1 && a[1] == 1)) return FALSE;
+    if (a[0] == 0 || (a[0] == 1 && a[1] == 1)) return false;
 
     return perform_exp(a, half, output);
 }
 
 const static struct operation op_add = {
-    TRUE, "+", "+", 0, 10, 0, TRUE, perform_add
+    true, "+", "+", 0, 10, 0, true, perform_add
 };
 const static struct operation op_sub = {
-    TRUE, "-", "-", 0, 10, 2, FALSE, perform_sub
+    true, "-", "-", 0, 10, 2, false, perform_sub
 };
 const static struct operation op_mul = {
-    TRUE, "*", "*", 0, 20, 0, TRUE, perform_mul
+    true, "*", "*", 0, 20, 0, true, perform_mul
 };
 const static struct operation op_div = {
-    TRUE, "/", "/", 0, 20, 2, FALSE, perform_div
+    true, "/", "/", 0, 20, 2, false, perform_div
 };
 const static struct operation op_xdiv = {
-    TRUE, "/", "/", 0, 20, 2, FALSE, perform_exact_div
+    true, "/", "/", 0, 20, 2, false, perform_exact_div
 };
 const static struct operation op_concat = {
-    FALSE, "", "concat", OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT,
-	1000, 0, FALSE, perform_concat
+    false, "", "concat", OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT,
+	1000, 0, false, perform_concat
 };
 const static struct operation op_exp = {
-    TRUE, "^", "^", 0, 30, 1, FALSE, perform_exp
+    true, "^", "^", 0, 30, 1, false, perform_exp
 };
 const static struct operation op_factorial = {
-    TRUE, "!", "!", OPFLAG_UNARY, 40, 0, FALSE, perform_factorial
+    true, "!", "!", OPFLAG_UNARY, 40, 0, false, perform_factorial
 };
 const static struct operation op_decimal = {
-    TRUE, ".", ".", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT, 50, 0, FALSE, perform_decimal
+    true, ".", ".", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_NEEDS_CONCAT | OPFLAG_KEEPS_CONCAT, 50, 0, false, perform_decimal
 };
 const static struct operation op_recur = {
-    TRUE, "...", "recur", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 2, FALSE, perform_recur
+    true, "...", "recur", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 2, false, perform_recur
 };
 const static struct operation op_root = {
-    TRUE, "v~", "root", 0, 30, 1, FALSE, perform_root
+    true, "v~", "root", 0, 30, 1, false, perform_root
 };
 const static struct operation op_perc = {
-    TRUE, "%", "%", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 1, FALSE, perform_perc
+    true, "%", "%", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 1, false, perform_perc
 };
 const static struct operation op_gamma = {
-    TRUE, "gamma", "gamma", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_FN, 1, 3, FALSE, perform_gamma
+    true, "gamma", "gamma", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_FN, 1, 3, false, perform_gamma
 };
 const static struct operation op_sqrt = {
-    TRUE, "v~", "sqrt", OPFLAG_UNARY | OPFLAG_UNARYPREFIX, 30, 1, FALSE, perform_sqrt
+    true, "v~", "sqrt", OPFLAG_UNARY | OPFLAG_UNARYPREFIX, 30, 1, false, perform_sqrt
 };
 
 /*
@@ -601,7 +601,7 @@ const static struct operation *const ops_countdown[] = {
     &op_add, &op_mul, &op_sub, &op_xdiv, NULL
 };
 const static struct rules rules_countdown = {
-    ops_countdown, FALSE
+    ops_countdown, false
 };
 
 /*
@@ -613,7 +613,7 @@ const static struct operation *const ops_3388[] = {
     &op_add, &op_mul, &op_sub, &op_div, NULL
 };
 const static struct rules rules_3388 = {
-    ops_3388, TRUE
+    ops_3388, true
 };
 
 /*
@@ -624,7 +624,7 @@ const static struct operation *const ops_four4s[] = {
     &op_add, &op_mul, &op_sub, &op_div, &op_concat, NULL
 };
 const static struct rules rules_four4s = {
-    ops_four4s, TRUE
+    ops_four4s, true
 };
 
 /*
@@ -636,7 +636,7 @@ const static struct operation *const ops_anythinggoes[] = {
     &op_decimal, &op_recur, &op_root, &op_perc, &op_gamma, &op_sqrt, NULL
 };
 const static struct rules rules_anythinggoes = {
-    ops_anythinggoes, TRUE
+    ops_anythinggoes, true
 };
 
 #define ratcmp(a,op,b) ( (long long)(a)[0] * (b)[1] op \
@@ -805,7 +805,7 @@ static int addoutput(struct sets *s, struct set *ss, int index, int *n)
      * Target numbers are always integers.
      */
     if (ss->numbers[2*index+1] != 1)
-	return FALSE;
+	return false;
 
     ensure(s->outputlists, s->outputlistsize, s->noutputs/OUTPUTLISTLEN+1,
 	   struct output *);
@@ -826,7 +826,7 @@ static int addoutput(struct sets *s, struct set *ss, int index, int *n)
 	s->noutputs++;
     }
     *n = o->number;
-    return TRUE;
+    return true;
 }
 
 static struct sets *do_search(int ninputs, int *inputs,
@@ -1095,16 +1095,16 @@ void print(int pathindex, struct sets *s, struct output *o)
  */
 int main(int argc, char **argv)
 {
-    int doing_opts = TRUE;
+    int doing_opts = true;
     const struct rules *rules = NULL;
     char *pname = argv[0];
-    int got_target = FALSE, target = 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;
+    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;
@@ -1118,12 +1118,12 @@ int main(int argc, char **argv)
 	    p++;
 
 	    if (!strcmp(p, "-")) {
-		doing_opts = FALSE;
+		doing_opts = false;
 		continue;
 	    } else if (*p == '-') {
 		p++;
 		if (!strcmp(p, "debug-bfs")) {
-		    debug_bfs = TRUE;
+		    debug_bfs = true;
 		} else {
 		    fprintf(stderr, "%s: option '--%s' not recognised\n",
 			    pname, p);
@@ -1142,13 +1142,13 @@ int main(int argc, char **argv)
 		rules = &rules_anythinggoes;
 		break;
 	      case 'v':
-		verbose = TRUE;
+		verbose = true;
 		break;
 	      case 'p':
-		pathcounts = TRUE;
+		pathcounts = true;
 		break;
 	      case 'm':
-		multiple = TRUE;
+		multiple = true;
 		break;
 	      case 't':
               case 'r':
@@ -1166,13 +1166,13 @@ int main(int argc, char **argv)
 		    }
 		    switch (c) {
 		      case 't':
-			got_target = TRUE;
+			got_target = true;
 			target = atoi(v);
 			break;
                       case 'r':
                         {
                              char *sep = strchr(v, '-');
-                             got_range = TRUE;
+                             got_range = true;
                              if (sep) {
                                  rangemin = atoi(v);
                                  rangemax = atoi(sep+1);
diff --git a/apps/plugins/puzzles/src/unfinished/path.c b/apps/plugins/puzzles/src/unfinished/path.c
index d4ec5d87cc..829fbc6c75 100644
--- a/apps/plugins/puzzles/src/unfinished/path.c
+++ b/apps/plugins/puzzles/src/unfinished/path.c
@@ -201,17 +201,17 @@ static int is_endpoint(struct genctx *ctx, int x, int y)
 
     c = ctx->grid[y*w+x];
     if (c < 0)
-	return FALSE;		       /* empty square is not an endpoint! */
+	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;
+	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.
+ * 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)
 {
@@ -233,7 +233,7 @@ static int extend_path(struct genctx *ctx, int path, int end, int direction)
     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 */
+	return false;		       /* could not extend in this direction */
 
     /*
      * We don't extend paths _directly_ into endpoints of other
@@ -242,13 +242,13 @@ static int extend_path(struct genctx *ctx, int path, int end, int direction)
      * path's endpoint.
      */
     if (is_endpoint(ctx, xe, ye))
-	return FALSE;
+	return false;
 
     /*
      * We can't extend a path back the way it came.
      */
     if (ctx->grid[ye*w+xe] == path)
-	return FALSE;
+	return false;
 
     /*
      * Paths may not double back on themselves. Check if the new
@@ -262,7 +262,7 @@ static int extend_path(struct genctx *ctx, int path, int end, int direction)
 
 	if (xf >= 0 && xf < w && yf >= 0 && yf < h &&
 	    (xf != x || yf != y) && ctx->grid[yf*w+xf] == path)
-	    return FALSE;
+	    return false;
     }
 
     /*
@@ -331,7 +331,7 @@ static int extend_path(struct genctx *ctx, int path, int end, int direction)
 		    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 */
+    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);
@@ -375,7 +375,7 @@ if (ctx->sparegrid3[ctx->pathends[i*2]] != i ||
 	    }
 
 	    if (first < 0 || last < 0)
-		return FALSE;	       /* path is completely wiped out! */
+		return false;	       /* path is completely wiped out! */
 
 	    /*
 	     * Now we've covered sparegrid3 in possible squares for
@@ -393,7 +393,7 @@ if (ctx->sparegrid3[ctx->pathends[i*2]] != i ||
 		 * any more. This means the entire push operation
 		 * has failed.
 		 */
-		return FALSE;
+		return false;
 	    }
 
 	    /*
@@ -407,7 +407,7 @@ if (ctx->sparegrid3[ctx->pathends[i*2]] != i ||
 
 		if (ctx->sparegrid[jp] >= 0) {
 		    if (ctx->pathspare[ctx->sparegrid[jp]] == 2)
-			return FALSE;  /* somehow we've hit a fixed path */
+			return false;  /* somehow we've hit a fixed path */
 		    ctx->pathspare[ctx->sparegrid[jp]] = 1;   /* broken */
 		}
 		ctx->sparegrid[jp] = i;
@@ -443,7 +443,7 @@ if (ctx->sparegrid3[ctx->pathends[i*2]] != i ||
      */
     memcpy(ctx->grid, ctx->sparegrid, w*h*sizeof(int));
     memcpy(ctx->pathends, ctx->sparepathends, ctx->npaths*2*sizeof(int));
-    return TRUE;
+    return true;
 }
 
 /*
@@ -556,10 +556,10 @@ static int add_path(struct genctx *ctx, random_state *rs)
 	    ctx->grid[j] = c;
 	}
 
-	return TRUE;
+	return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 /*
diff --git a/apps/plugins/puzzles/src/unfinished/separate.c b/apps/plugins/puzzles/src/unfinished/separate.c
index fc64d7fe37..88dc8ed060 100644
--- a/apps/plugins/puzzles/src/unfinished/separate.c
+++ b/apps/plugins/puzzles/src/unfinished/separate.c
@@ -120,9 +120,9 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
-    return FALSE;
+    return false;
 }
 
 static void free_params(game_params *params)
@@ -153,7 +153,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[256];
     sprintf(buf, "%dx%dn%d", params->w, params->h, params->k);
@@ -170,7 +170,7 @@ static game_params *custom_params(const config_item *cfg)
     return NULL;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     return NULL;
 }
@@ -207,7 +207,7 @@ struct solver_scratch {
      * tracks whether or not the connected components containing
      * yx1 and yx2 are known to be distinct.
      */
-    unsigned char *disconnect;
+    bool *disconnect;
 
     /*
      * Temporary space used only inside particular solver loops.
@@ -227,7 +227,7 @@ struct solver_scratch *solver_scratch_new(int w, int h, int k)
     sc->dsf = snew_dsf(wh);
     sc->size = snewn(wh, int);
     sc->contents = snewn(wh * k, int);
-    sc->disconnect = snewn(wh*wh, unsigned char);
+    sc->disconnect = snewn(wh*wh, bool);
     sc->tmp = snewn(wh, int);
 
     return sc;
@@ -312,7 +312,8 @@ void solver_disconnect(struct solver_scratch *sc, int yx1, int yx2)
      * Mark the components as disconnected from each other in the
      * disconnect matrix.
      */
-    sc->disconnect[yx1*wh+yx2] = sc->disconnect[yx2*wh+yx1] = 1;
+    sc->disconnect[yx1*wh+yx2] = true;
+    sc->disconnect[yx2*wh+yx1] = true;
 }
 
 void solver_init(struct solver_scratch *sc)
@@ -328,16 +329,16 @@ void solver_init(struct solver_scratch *sc)
      */
     dsf_init(sc->dsf, wh);
     for (i = 0; i < wh; i++) sc->size[i] = 1;
-    memset(sc->disconnect, 0, wh*wh);
+    memset(sc->disconnect, 0, wh*wh * sizeof(bool));
 }
 
 int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
-		   unsigned char *gen_lock)
+		   bool *gen_lock)
 {
     int w = sc->w, h = sc->h, k = sc->k;
     int wh = w*h;
     int i, x, y;
-    int done_something_overall = FALSE;
+    bool done_something_overall = false;
 
     /*
      * Set up the contents array from the grid.
@@ -348,7 +349,7 @@ int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
 	sc->contents[dsf_canonify(sc->dsf, i)*k+grid[i]] = i;
 
     while (1) {
-	int done_something = FALSE;
+	bool done_something = false;
 
 	/*
 	 * Go over the grid looking for reasons to add to the
@@ -393,7 +394,7 @@ int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
 		    printf("Disconnecting %d and %d (%c)\n", yx, yx2, 'A'+i);
 #endif
 		    solver_disconnect(sc, yx, yx2);
-		    done_something = done_something_overall = TRUE;
+		    done_something = done_something_overall = true;
 
 		    /*
 		     * We have just made a deduction which hinges
@@ -406,8 +407,8 @@ int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
 		     * based deductions.
 		     */
 		    if (gen_lock) {
-			gen_lock[sc->contents[yx*k+i]] = 1;
-			gen_lock[sc->contents[yx2*k+i]] = 1;
+			gen_lock[sc->contents[yx*k+i]] = true;
+			gen_lock[sc->contents[yx2*k+i]] = true;
 		    }
 		}
 	    }
@@ -467,7 +468,7 @@ int solver_attempt(struct solver_scratch *sc, const unsigned char *grid,
 		printf("Connecting %d and %d\n", i, sc->tmp[i]);
 #endif
 		solver_connect(sc, i, sc->tmp[i]);
-		done_something = done_something_overall = TRUE;
+		done_something = done_something_overall = true;
 		break;
 	    }
 	}
@@ -500,14 +501,14 @@ unsigned char *generate(int w, int h, int k, random_state *rs)
     unsigned char *shuffled;
     int i, j, m, retries;
     int *permutation;
-    unsigned char *gen_lock;
+    bool *gen_lock;
     extern int *divvy_rectangle(int w, int h, int k, random_state *rs);
 
     sc = solver_scratch_new(w, h, k);
     grid = snewn(wh, unsigned char);
     shuffled = snewn(k, unsigned char);
     permutation = snewn(wh, int);
-    gen_lock = snewn(wh, unsigned char);
+    gen_lock = snewn(wh, bool);
 
     do {
 	int *dsf = divvy_rectangle(w, h, k, rs);
@@ -547,7 +548,7 @@ unsigned char *generate(int w, int h, int k, random_state *rs)
 	 * on for deductions. This is gradually updated by
 	 * solver_attempt().
 	 */
-	memset(gen_lock, 0, wh);
+	memset(gen_lock, 0, wh * sizeof(bool));
 
 	/*
 	 * Now repeatedly fill the grid with letters, and attempt
@@ -627,7 +628,7 @@ unsigned char *generate(int w, int h, int k, random_state *rs)
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
     unsigned char *grid;
@@ -681,9 +682,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -803,9 +804,9 @@ static int game_status(const game_state *state)
     return 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -828,15 +829,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    FALSE, game_configure, custom_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,
+    false, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -853,8 +854,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    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
index 504c4e95e5..5ad1237d58 100644
--- a/apps/plugins/puzzles/src/unfinished/slide.c
+++ b/apps/plugins/puzzles/src/unfinished/slide.c
@@ -128,7 +128,7 @@ struct game_params {
 
 struct game_immutable_state {
     int refcount;
-    unsigned char *forcefield;
+    bool *forcefield;
 };
 
 struct game_solution {
@@ -145,7 +145,7 @@ struct game_state {
     int lastmoved, lastmoved_pos;      /* for move counting */
     int movecount;
     int completed;
-    int cheated;
+    bool cheated;
     struct game_immutable_state *imm;
     struct game_solution *soln;
     int soln_index;
@@ -168,13 +168,13 @@ static const struct game_params slide_presets[] = {
     {8, 6, -1},
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+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;
+        return false;
 
     ret = snew(game_params);
     *ret = slide_presets[i];
@@ -187,7 +187,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(str);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -221,7 +221,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -273,7 +273,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->w > MAXWID)
 	return "Width must be at most " STR(MAXWID);
@@ -287,7 +287,7 @@ static const char *validate_params(const game_params *params, int full)
 }
 
 static char *board_text_format(int w, int h, unsigned char *data,
-			       unsigned char *forcefield)
+			       bool *forcefield)
 {
     int wh = w*h;
     int *dsf = snew_dsf(wh);
@@ -406,13 +406,14 @@ static struct board *newboard(int w, int h, unsigned char *data)
  * which is a pointer to a dynamically allocated array.
  */
 static int solve_board(int w, int h, unsigned char *board,
-		       unsigned char *forcefield, int tx, int ty,
+		       bool *forcefield, int tx, int ty,
 		       int movelimit, int **moveout)
 {
     int wh = w*h;
     struct board *b, *b2, *b3;
-    int *next, *anchors, *which;
-    int *movereached, *movequeue, mqhead, mqtail;
+    int *next, *which;
+    bool *anchors, *movereached;
+    int *movequeue, mqhead, mqtail;
     tree234 *sorted, *queue;
     int i, j, dir;
     int qlen, lastdist;
@@ -453,9 +454,9 @@ static int solve_board(int w, int h, unsigned char *board,
     qlen = 1;
 
     next = snewn(wh, int);
-    anchors = snewn(wh, int);
+    anchors = snewn(wh, bool);
     which = snewn(wh, int);
-    movereached = snewn(wh, int);
+    movereached = snewn(wh, bool);
     movequeue = snewn(wh, int);
     lastdist = -1;
 
@@ -481,10 +482,10 @@ static int solve_board(int w, int h, unsigned char *board,
 	 */
 	for (i = 0; i < wh; i++) {
 	    next[i] = -1;
-	    anchors[i] = FALSE;
+	    anchors[i] = false;
 	    which[i] = -1;
 	    if (ISANCHOR(b->data[i])) {
-		anchors[i] = TRUE;
+		anchors[i] = true;
 		which[i] = i;
 	    } else if (ISDIST(b->data[i])) {
 		j = i - b->data[i];
@@ -503,7 +504,7 @@ static int solve_board(int w, int h, unsigned char *board,
 
 	    mqhead = mqtail = 0;
 	    for (j = 0; j < wh; j++)
-		movereached[j] = FALSE;
+		movereached[j] = false;
 	    movequeue[mqtail++] = i;
 	    while (mqhead < mqtail) {
 		int pos = movequeue[mqhead++];
@@ -542,7 +543,7 @@ static int solve_board(int w, int h, unsigned char *board,
 		     */
 		    if (movereached[newpos])
 			continue;
-		    movereached[newpos] = TRUE;
+		    movereached[newpos] = true;
 		    movequeue[mqtail++] = newpos;
 
 		    /*
@@ -637,11 +638,12 @@ static int solve_board(int w, int h, unsigned char *board,
 
 static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
 			   random_state *rs, unsigned char **rboard,
-			   unsigned char **rforcefield, int movelimit)
+			   bool **rforcefield, int movelimit)
 {
     int wh = w*h;
-    unsigned char *board, *board2, *forcefield;
-    unsigned char *tried_merge;
+    unsigned char *board, *board2;
+    bool *forcefield;
+    bool *tried_merge;
     int *dsf;
     int *list, nlist, pos;
     int tx, ty;
@@ -653,17 +655,17 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
      * border of walls.
      */
     board = snewn(wh, unsigned char);
-    forcefield = snewn(wh, unsigned char);
+    forcefield = snewn(wh, bool);
     board2 = snewn(wh, unsigned char);
     memset(board, ANCHOR, wh);
-    memset(forcefield, FALSE, 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, unsigned char);
-    memset(tried_merge, 0, wh*wh);
+    tried_merge = snewn(wh * wh, bool);
+    memset(tried_merge, 0, wh*wh * sizeof(bool));
     dsf = snew_dsf(wh);
 
     /*
@@ -680,7 +682,8 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
      */
     tx = w-2;
     ty = h-3;
-    forcefield[ty*w+tx+1] = forcefield[(ty+1)*w+tx+1] = TRUE;
+    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;
 
     /*
@@ -799,7 +802,8 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
 	     * Didn't work. Revert the merge.
 	     */
 	    memcpy(board, board2, wh);
-	    tried_merge[c1 * wh + c2] = tried_merge[c2 * wh + c1] = TRUE;
+	    tried_merge[c1 * wh + c2] = true;
+            tried_merge[c2 * wh + c1] = true;
 	} else {
 	    int c;
 
@@ -808,10 +812,10 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
 	    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[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+c] = (tried_merge[i*wh+c1] ||
 				       tried_merge[i*wh+c2]);
 	}
     }
@@ -833,11 +837,12 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
  */
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h, wh = w*h;
     int tx, ty, minmoves;
-    unsigned char *board, *forcefield;
+    unsigned char *board;
+    bool *forcefield;
     char *ret, *p;
     int i;
 
@@ -863,7 +868,8 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 	    i++;
 	} else {
 	    int count = 1;
-	    int b = board[i], f = forcefield[i];
+	    int b = board[i];
+            bool f = forcefield[i];
 	    int c = (b == ANCHOR ? 'a' :
 		     b == MAINANCHOR ? 'm' :
 		     b == EMPTY ? 'e' :
@@ -889,12 +895,13 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 static const char *validate_desc(const game_params *params, const char *desc)
 {
     int w = params->w, h = params->h, wh = w*h;
-    int *active, *link;
+    bool *active;
+    int *link;
     int mains = 0;
     int i, tx, ty, minmoves;
     char *ret;
 
-    active = snewn(wh, int);
+    active = snewn(wh, bool);
     link = snewn(wh, int);
     i = 0;
 
@@ -904,7 +911,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
 	    goto done;
 	}
 	link[i] = -1;
-	active[i] = FALSE;
+	active[i] = false;
 	if (*desc == 'f' || *desc == 'F') {
 	    desc++;
 	    if (!*desc) {
@@ -937,8 +944,8 @@ static const char *validate_desc(const game_params *params, const char *desc)
 
 	    link[i] = i - dist;
 
-	    active[i] = TRUE;
-	    active[link[i]] = FALSE;
+	    active[i] = true;
+	    active[link[i]] = false;
 	    i++;
 	} else {
 	    int c = *desc++;
@@ -1011,17 +1018,17 @@ static game_state *new_game(midend *me, const game_params *params,
     state->movecount = 0;
     state->imm = snew(struct game_immutable_state);
     state->imm->refcount = 1;
-    state->imm->forcefield = snewn(wh, unsigned char);
+    state->imm->forcefield = snewn(wh, bool);
 
     i = 0;
 
     while (*desc && *desc != ',') {
-	int f = FALSE;
+	bool f = false;
 
 	assert(i < wh);
 
 	if (*desc == 'f') {
-	    f = TRUE;
+	    f = true;
 	    desc++;
 	    assert(*desc);
 	}
@@ -1072,7 +1079,7 @@ static game_state *new_game(midend *me, const game_params *params,
     else
 	state->completed = -1;
 
-    state->cheated = FALSE;
+    state->cheated = false;
     state->soln = NULL;
     state->soln_index = -1;
 
@@ -1164,9 +1171,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1176,11 +1183,11 @@ static char *game_text_format(const game_state *state)
 }
 
 struct game_ui {
-    int dragging;
+    bool dragging;
     int drag_anchor;
     int drag_offset_x, drag_offset_y;
     int drag_currpos;
-    unsigned char *reachable;
+    bool *reachable;
     int *bfs_queue;		       /* used as scratch in interpret_move */
 };
 
@@ -1189,11 +1196,11 @@ 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->dragging = false;
     ui->drag_anchor = ui->drag_currpos = -1;
     ui->drag_offset_x = ui->drag_offset_y = -1;
-    ui->reachable = snewn(wh, unsigned char);
-    memset(ui->reachable, 0, wh);
+    ui->reachable = snewn(wh, bool);
+    memset(ui->reachable, 0, wh * sizeof(bool));
     ui->bfs_queue = snewn(wh, int);
 
     return ui;
@@ -1235,7 +1242,7 @@ struct game_drawstate {
     int tilesize;
     int w, h;
     unsigned long *grid;	       /* what's currently displayed */
-    int started;
+    bool started;
 };
 
 static char *interpret_move(const game_state *state, game_ui *ui,
@@ -1263,7 +1270,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	    i -= state->board[i];
 	assert(i >= 0 && i < wh);
 
-	ui->dragging = TRUE;
+	ui->dragging = true;
 	ui->drag_anchor = i;
 	ui->drag_offset_x = tx - (i % w);
 	ui->drag_offset_y = ty - (i / w);
@@ -1274,9 +1281,9 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	 * the anchor, to find all the places to which this block
 	 * can be dragged.
 	 */
-	memset(ui->reachable, FALSE, wh);
+	memset(ui->reachable, 0, wh * sizeof(bool));
 	qhead = qtail = 0;
-	ui->reachable[i] = TRUE;
+	ui->reachable[i] = true;
 	ui->bfs_queue[qtail++] = i;
 	for (j = i; j < wh; j++)
 	    if (state->board[j] == DIST(j - i))
@@ -1334,7 +1341,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 		     * disqualifying this position, mark it as
 		     * reachable for this drag.
 		     */
-		    ui->reachable[newpos] = TRUE;
+		    ui->reachable[newpos] = true;
 		    ui->bfs_queue[qtail++] = newpos;
 		}
 	    }
@@ -1390,10 +1397,10 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	} else
 	    str = "";		       /* null move; just update the UI */
 	
-	ui->dragging = FALSE;
+	ui->dragging = false;
 	ui->drag_anchor = ui->drag_currpos = -1;
 	ui->drag_offset_x = ui->drag_offset_y = -1;
-	memset(ui->reachable, 0, wh);
+	memset(ui->reachable, 0, wh * sizeof(bool));
 
 	return str;
     } else if (button == ' ' && state->soln) {
@@ -1415,14 +1422,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     return NULL;
 }
 
-static int move_piece(int w, int h, const unsigned char *src,
-		      unsigned char *dst, unsigned char *ff, int from, int to)
+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;
+	return false;
 
     /*
      * Scan to the far end of the piece's linked list.
@@ -1444,15 +1451,15 @@ static int move_piece(int w, int h, const unsigned char *src,
     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;
+	    return false;
 	if (dst[jn] == EMPTY && (!ff[jn] || src[from] == MAINANCHOR)) {
 	    dst[jn] = src[j];
 	} else {
-	    return FALSE;
+	    return false;
 	}
     }
 
-    return TRUE;
+    return true;
 }
 
 static game_state *execute_move(const game_state *state, const char *move)
@@ -1478,7 +1485,7 @@ static game_state *execute_move(const game_state *state, const char *move)
 	    ret->soln->moves = NULL;
 	    ret->soln->refcount = 1;
 	    ret->soln_index = 0;
-	    ret->cheated = TRUE;
+	    ret->cheated = true;
 
 	    movesize = 0;
 	    move++;
@@ -1673,7 +1680,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->tilesize = 0;
     ds->w = w;
     ds->h = h;
-    ds->started = FALSE;
+    ds->started = false;
     ds->grid = snewn(wh, unsigned long);
     for (i = 0; i < wh; i++)
 	ds->grid[i] = ~(unsigned long)0;
@@ -2130,7 +2137,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	 * background-colour rectangle covering the whole window.
 	 */
 	draw_rect(dr, 0, 0, 10*ds->tilesize, 10*ds->tilesize, COL_BACKGROUND);
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     /*
@@ -2141,9 +2148,9 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     board = snewn(wh, unsigned char);
     memcpy(board, state->board, wh);
     if (ui->dragging) {
-	int mpret = move_piece(w, h, state->board, board,
-			       state->imm->forcefield,
-			       ui->drag_anchor, ui->drag_currpos);
+	bool mpret = move_piece(w, h, state->board, board,
+                                state->imm->forcefield,
+                                ui->drag_anchor, ui->drag_currpos);
 	assert(mpret);
     }
 
@@ -2295,9 +2302,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -2320,15 +2327,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -2345,9 +2352,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    TRUE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    true,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
 
@@ -2359,8 +2366,9 @@ int main(int argc, char **argv)
 {
     game_params *p;
     game_state *s;
-    char *id = NULL, *desc, *err;
-    int count = FALSE;
+    char *id = NULL, *desc;
+    const char *err;
+    bool count = false;
     int ret;
     int *moves;
 
@@ -2368,11 +2376,11 @@ int main(int argc, char **argv)
         char *p = *++argv;
         /*
         if (!strcmp(p, "-v")) {
-            verbose = TRUE;
+            verbose = true;
         } else
         */
         if (!strcmp(p, "-c")) {
-            count = TRUE;
+            count = true;
         } else if (*p == '-') {
             fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
@@ -2413,7 +2421,7 @@ int main(int argc, char **argv)
 	    return 0;
 	}
 	while (1) {
-	    int moveret;
+	    bool moveret;
 	    char *text = board_text_format(s->w, s->h, s->board,
 					   s->imm->forcefield);
 	    game_state *s2;
diff --git a/apps/plugins/puzzles/src/unfinished/sokoban.c b/apps/plugins/puzzles/src/unfinished/sokoban.c
index a06ba7a662..7d42a12c5d 100644
--- a/apps/plugins/puzzles/src/unfinished/sokoban.c
+++ b/apps/plugins/puzzles/src/unfinished/sokoban.c
@@ -131,7 +131,7 @@ struct game_state {
     game_params p;
     unsigned char *grid;
     int px, py;
-    int completed;
+    bool completed;
 };
 
 static game_params *default_params(void)
@@ -162,14 +162,14 @@ static const struct game_params sokoban_presets[] = {
     { 20, 16 },
 };
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+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;
+	return false;
 
     p = sokoban_presets[i];
     ret = dup_params(&p);
@@ -178,7 +178,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *params = ret;
     *name = retname;
-    return TRUE;
+    return true;
 }
 
 static void decode_params(game_params *params, char const *string)
@@ -191,7 +191,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char data[256];
 
@@ -233,7 +233,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+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";
@@ -300,7 +300,7 @@ static const char *validate_params(const game_params *params, int full)
  */
 
 static void sokoban_generate(int w, int h, unsigned char *grid, int moves,
-			     int nethack, random_state *rs)
+			     bool nethack, random_state *rs)
 {
     struct pull {
 	int ox, oy, nx, ny, score;
@@ -728,7 +728,7 @@ static void sokoban_generate(int w, int h, unsigned char *grid, int moves,
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int w = params->w, h = params->h;
     char *desc;
@@ -741,7 +741,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
      * many moves to try?
      */
     grid = snewn(w*h, unsigned char);
-    sokoban_generate(w, h, grid, w*h, FALSE, rs);
+    sokoban_generate(w, h, grid, w*h, false, rs);
 
     desclen = descpos = descsize = 0;
     desc = NULL;
@@ -849,7 +849,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->p = *params;                /* structure copy */
     state->grid = snewn(w*h, unsigned char);
     state->px = state->py = -1;
-    state->completed = FALSE;
+    state->completed = false;
 
     i = 0;
 
@@ -904,9 +904,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return NULL;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -940,7 +940,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     game_params p;
     int tilesize;
-    int started;
+    bool started;
     unsigned short *grid;
 };
 
@@ -957,7 +957,7 @@ struct game_drawstate {
  * subfunction. move_type() returns -1 for an illegal move, 0 for a
  * movement, and 1 for a push.
  */
-int move_type(game_state *state, int dx, int dy)
+int 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;
@@ -1099,7 +1099,8 @@ static game_state *execute_move(const game_state *state, const char *move)
 {
     int w = state->p.w, h = state->p.h;
     int px = state->px, py = state->py;
-    int dx, dy, nx, ny, nbx, nby, type, m, i, freebarrels, freetargets;
+    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])
@@ -1158,20 +1159,20 @@ static game_state *execute_move(const game_state *state, const char *move)
      * no free target squares, and no deep pits at all.
      */
     if (!ret->completed) {
-        freebarrels = FALSE;
-        freetargets = FALSE;
+        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;
+                freebarrels = true;
             if (v == DEEP_PIT || v == PIT ||
                 (!IS_BARREL(v) && IS_ON_TARGET(v)))
-                freetargets = TRUE;
+                freetargets = true;
         }
 
         if (!freebarrels || !freetargets)
-            ret->completed = TRUE;
+            ret->completed = true;
     }
 
     return ret;
@@ -1261,7 +1262,7 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->grid = snewn(w*h, unsigned short);
     for (i = 0; i < w*h; i++)
         ds->grid[i] = INVALID;
-    ds->started = FALSE;
+    ds->started = false;
 
     return ds;
 }
@@ -1371,7 +1372,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	    draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h),
 		      COL_LOWLIGHT);
 
-	ds->started = TRUE;
+	ds->started = true;
     }
 
     /*
@@ -1419,9 +1420,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1444,15 +1445,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    false, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1469,8 +1470,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     0,				       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/unruly.c b/apps/plugins/puzzles/src/unruly.c
index 6506029d7e..e69c31b6b9 100644
--- a/apps/plugins/puzzles/src/unruly.c
+++ b/apps/plugins/puzzles/src/unruly.c
@@ -52,7 +52,7 @@
 #include "puzzles.h"
 
 #ifdef STANDALONE_SOLVER
-int solver_verbose = FALSE;
+bool solver_verbose = false;
 #endif
 
 enum {
@@ -77,7 +77,7 @@ enum {
 
 struct game_params {
     int w2, h2;        /* full grid width and height respectively */
-    int unique;        /* should row and column patterns be unique? */
+    bool unique;       /* should row and column patterns be unique? */
     int diff;
 };
 #define DIFFLIST(A)                             \
@@ -95,12 +95,12 @@ static char const unruly_diffchars[] = DIFFLIST(ENCODE);
 #define DIFFCONFIG DIFFLIST(CONFIG)
 
 static const struct game_params unruly_presets[] = {
-    { 8,  8, FALSE, DIFF_EASY},
-    { 8,  8, FALSE, DIFF_NORMAL},
-    {10, 10, FALSE, DIFF_EASY},
-    {10, 10, FALSE, DIFF_NORMAL},
-    {14, 14, FALSE, DIFF_EASY},
-    {14, 14, FALSE, DIFF_NORMAL}
+    { 8,  8, false, DIFF_EASY},
+    { 8,  8, false, DIFF_NORMAL},
+    {10, 10, false, DIFF_EASY},
+    {10, 10, false, DIFF_NORMAL},
+    {14, 14, false, DIFF_EASY},
+    {14, 14, false, DIFF_NORMAL}
 };
 
 #define DEFAULT_PRESET 0
@@ -133,13 +133,18 @@ enum {
 #define FF_FLASH2         0x0800
 #define FF_IMMUTABLE      0x1000
 
+typedef struct unruly_common {
+    int refcount;
+    bool *immutable;
+} unruly_common;
+
 struct game_state {
     int w2, h2;
-    int unique;
+    bool unique;
     char *grid;
-    unsigned char *immutable;
+    unruly_common *common;
 
-    int completed, cheated;
+    bool completed, cheated;
 };
 
 static game_params *default_params(void)
@@ -151,13 +156,13 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char buf[80];
 
     if (i < 0 || i >= lenof(unruly_presets))
-        return FALSE;
+        return false;
 
     ret = snew(game_params);
     *ret = unruly_presets[i];     /* structure copy */
@@ -166,7 +171,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
 
     *name = dupstr(buf);
     *params = ret;
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -185,7 +190,7 @@ static void decode_params(game_params *params, char const *string)
 {
     char const *p = string;
 
-    params->unique = FALSE;
+    params->unique = false;
 
     params->w2 = atoi(p);
     while (*p && isdigit((unsigned char)*p)) p++;
@@ -199,7 +204,7 @@ static void decode_params(game_params *params, char const *string)
 
     if (*p == 'u') {
         p++;
-        params->unique = TRUE;
+        params->unique = true;
     }
 
     if (*p == 'd') {
@@ -216,7 +221,7 @@ static void decode_params(game_params *params, char const *string)
     }
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -273,7 +278,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if ((params->w2 & 1) || (params->h2 & 1))
         return "Width and height must both be even";
@@ -344,7 +349,7 @@ static const char *validate_desc(const game_params *params, const char *desc)
     return NULL;
 }
 
-static game_state *blank_state(int w2, int h2, int unique)
+static game_state *blank_state(int w2, int h2, bool unique)
 {
     game_state *state = snew(game_state);
     int s = w2 * h2;
@@ -353,12 +358,14 @@ static game_state *blank_state(int w2, int h2, int unique)
     state->h2 = h2;
     state->unique = unique;
     state->grid = snewn(s, char);
-    state->immutable = snewn(s, unsigned char);
+    state->common = snew(unruly_common);
+    state->common->refcount = 1;
+    state->common->immutable = snewn(s, bool);
 
     memset(state->grid, EMPTY, s);
-    memset(state->immutable, FALSE, s);
+    memset(state->common->immutable, 0, s*sizeof(bool));
 
-    state->completed = state->cheated = FALSE;
+    state->completed = state->cheated = false;
 
     return state;
 }
@@ -379,14 +386,14 @@ static game_state *new_game(midend *me, const game_params *params,
             pos += (*p - 'a');
             if (pos < s) {
                 state->grid[pos] = N_ZERO;
-                state->immutable[pos] = TRUE;
+                state->common->immutable[pos] = true;
             }
             pos++;
         } else if (*p >= 'A' && *p < 'Z') {
             pos += (*p - 'A');
             if (pos < s) {
                 state->grid[pos] = N_ONE;
-                state->immutable[pos] = TRUE;
+                state->common->immutable[pos] = true;
             }
             pos++;
         } else if (*p == 'Z' || *p == 'z') {
@@ -409,7 +416,8 @@ static game_state *dup_game(const game_state *state)
     game_state *ret = blank_state(w2, h2, state->unique);
 
     memcpy(ret->grid, state->grid, s);
-    memcpy(ret->immutable, state->immutable, s);
+    ret->common = state->common;
+    ret->common->refcount++;
 
     ret->completed = state->completed;
     ret->cheated = state->cheated;
@@ -420,14 +428,17 @@ static game_state *dup_game(const game_state *state)
 static void free_game(game_state *state)
 {
     sfree(state->grid);
-    sfree(state->immutable);
+    if (--state->common->refcount == 0) {
+        sfree(state->common->immutable);
+        sfree(state->common);
+    }
 
     sfree(state);
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -517,7 +528,7 @@ static void unruly_free_scratch(struct unruly_scratch *scratch)
 }
 
 static int unruly_solver_check_threes(game_state *state, int *rowcount,
-                                      int *colcount, int horizontal,
+                                      int *colcount, bool horizontal,
                                       char check, char block)
 {
     int w2 = state->w2, h2 = state->h2;
@@ -594,23 +605,23 @@ static int unruly_solver_check_all_threes(game_state *state,
 
     ret +=
         unruly_solver_check_threes(state, scratch->zeros_rows,
-                                   scratch->zeros_cols, TRUE, N_ONE, N_ZERO);
+                                   scratch->zeros_cols, true, N_ONE, N_ZERO);
     ret +=
         unruly_solver_check_threes(state, scratch->ones_rows,
-                                   scratch->ones_cols, TRUE, N_ZERO, N_ONE);
+                                   scratch->ones_cols, true, N_ZERO, N_ONE);
     ret +=
         unruly_solver_check_threes(state, scratch->zeros_rows,
-                                   scratch->zeros_cols, FALSE, N_ONE,
+                                   scratch->zeros_cols, false, N_ONE,
                                    N_ZERO);
     ret +=
         unruly_solver_check_threes(state, scratch->ones_rows,
-                                   scratch->ones_cols, FALSE, N_ZERO, N_ONE);
+                                   scratch->ones_cols, false, N_ZERO, N_ONE);
 
     return ret;
 }
 
 static int unruly_solver_check_uniques(game_state *state, int *rowcount,
-                                       int horizontal, char check, char block,
+                                       bool horizontal, char check, char block,
                                        struct unruly_scratch *scratch)
 {
     int w2 = state->w2, h2 = state->h2;
@@ -680,18 +691,18 @@ static int unruly_solver_check_all_uniques(game_state *state,
     int ret = 0;
 
     ret += unruly_solver_check_uniques(state, scratch->ones_rows,
-                                       TRUE, N_ONE, N_ZERO, scratch);
+                                       true, N_ONE, N_ZERO, scratch);
     ret += unruly_solver_check_uniques(state, scratch->zeros_rows,
-                                       TRUE, N_ZERO, N_ONE, scratch);
+                                       true, N_ZERO, N_ONE, scratch);
     ret += unruly_solver_check_uniques(state, scratch->ones_cols,
-                                       FALSE, N_ONE, N_ZERO, scratch);
+                                       false, N_ONE, N_ZERO, scratch);
     ret += unruly_solver_check_uniques(state, scratch->zeros_cols,
-                                       FALSE, N_ZERO, N_ONE, scratch);
+                                       false, N_ZERO, N_ONE, scratch);
 
     return ret;
 }
 
-static int unruly_solver_fill_row(game_state *state, int i, int horizontal,
+static int unruly_solver_fill_row(game_state *state, int i, bool horizontal,
                                   int *rowcount, int *colcount, char fill)
 {
     int ret = 0;
@@ -733,7 +744,7 @@ static int unruly_solver_fill_row(game_state *state, int i, int horizontal,
 }
 
 static int unruly_solver_check_complete_nums(game_state *state,
-                                             int *complete, int horizontal,
+                                             int *complete, bool horizontal,
                                              int *rowcount, int *colcount,
                                              char fill)
 {
@@ -768,19 +779,19 @@ static int unruly_solver_check_all_complete_nums(game_state *state,
     int ret = 0;
 
     ret +=
-        unruly_solver_check_complete_nums(state, scratch->ones_rows, TRUE,
+        unruly_solver_check_complete_nums(state, scratch->ones_rows, true,
                                           scratch->zeros_rows,
                                           scratch->zeros_cols, N_ZERO);
     ret +=
-        unruly_solver_check_complete_nums(state, scratch->ones_cols, FALSE,
+        unruly_solver_check_complete_nums(state, scratch->ones_cols, false,
                                           scratch->zeros_rows,
                                           scratch->zeros_cols, N_ZERO);
     ret +=
-        unruly_solver_check_complete_nums(state, scratch->zeros_rows, TRUE,
+        unruly_solver_check_complete_nums(state, scratch->zeros_rows, true,
                                           scratch->ones_rows,
                                           scratch->ones_cols, N_ONE);
     ret +=
-        unruly_solver_check_complete_nums(state, scratch->zeros_cols, FALSE,
+        unruly_solver_check_complete_nums(state, scratch->zeros_cols, false,
                                           scratch->ones_rows,
                                           scratch->ones_cols, N_ONE);
 
@@ -788,7 +799,7 @@ static int unruly_solver_check_all_complete_nums(game_state *state,
 }
 
 static int unruly_solver_check_near_complete(game_state *state,
-                                             int *complete, int horizontal,
+                                             int *complete, bool horizontal,
                                              int *rowcount, int *colcount,
                                              char fill)
 {
@@ -928,26 +939,26 @@ static int unruly_solver_check_all_near_complete(game_state *state,
     int ret = 0;
 
     ret +=
-        unruly_solver_check_near_complete(state, scratch->ones_rows, TRUE,
+        unruly_solver_check_near_complete(state, scratch->ones_rows, true,
                                         scratch->zeros_rows,
                                         scratch->zeros_cols, N_ZERO);
     ret +=
-        unruly_solver_check_near_complete(state, scratch->ones_cols, FALSE,
+        unruly_solver_check_near_complete(state, scratch->ones_cols, false,
                                         scratch->zeros_rows,
                                         scratch->zeros_cols, N_ZERO);
     ret +=
-        unruly_solver_check_near_complete(state, scratch->zeros_rows, TRUE,
+        unruly_solver_check_near_complete(state, scratch->zeros_rows, true,
                                         scratch->ones_rows,
                                         scratch->ones_cols, N_ONE);
     ret +=
-        unruly_solver_check_near_complete(state, scratch->zeros_cols, FALSE,
+        unruly_solver_check_near_complete(state, scratch->zeros_cols, false,
                                         scratch->ones_rows,
                                         scratch->ones_cols, N_ONE);
 
     return ret;
 }
 
-static int unruly_validate_rows(const game_state *state, int horizontal,
+static int unruly_validate_rows(const game_state *state, bool horizontal,
                                 char check, int *errors)
 {
     int w2 = state->w2, h2 = state->h2;
@@ -987,7 +998,7 @@ static int unruly_validate_rows(const game_state *state, int horizontal,
     return ret;
 }
 
-static int unruly_validate_unique(const game_state *state, int horizontal,
+static int unruly_validate_unique(const game_state *state, bool horizontal,
                                   int *errors)
 {
     int w2 = state->w2, h2 = state->h2;
@@ -1011,11 +1022,11 @@ static int unruly_validate_unique(const game_state *state, int horizontal,
         if (nfull != nc)
             continue;
         for (r2 = r+1; r2 < nr; r2++) {
-            int match = TRUE;
+            bool match = true;
             for (c = 0; c < nc; c++)
                 if (state->grid[r*rmult + c*cmult] !=
                     state->grid[r2*rmult + c*cmult])
-                    match = FALSE;
+                    match = false;
             if (match) {
                 if (errors) {
                     for (c = 0; c < nc; c++) {
@@ -1035,14 +1046,14 @@ static int unruly_validate_all_rows(const game_state *state, int *errors)
 {
     int errcount = 0;
 
-    errcount += unruly_validate_rows(state, TRUE, N_ONE, errors);
-    errcount += unruly_validate_rows(state, FALSE, N_ONE, errors);
-    errcount += unruly_validate_rows(state, TRUE, N_ZERO, errors);
-    errcount += unruly_validate_rows(state, FALSE, N_ZERO, errors);
+    errcount += unruly_validate_rows(state, true, N_ONE, errors);
+    errcount += unruly_validate_rows(state, false, N_ONE, errors);
+    errcount += unruly_validate_rows(state, true, N_ZERO, errors);
+    errcount += unruly_validate_rows(state, false, N_ZERO, errors);
 
     if (state->unique) {
-        errcount += unruly_validate_unique(state, TRUE, errors);
-        errcount += unruly_validate_unique(state, FALSE, errors);
+        errcount += unruly_validate_unique(state, true, errors);
+        errcount += unruly_validate_unique(state, false, errors);
     }
 
     if (errcount)
@@ -1051,63 +1062,63 @@ static int unruly_validate_all_rows(const game_state *state, int *errors)
 }
 
 static int unruly_validate_counts(const game_state *state,
-                                  struct unruly_scratch *scratch, int *errors)
+                                  struct unruly_scratch *scratch, bool *errors)
 {
     int w2 = state->w2, h2 = state->h2;
     int w = w2/2, h = h2/2;
-    char below = FALSE;
-    char above = FALSE;
+    bool below = false;
+    bool above = false;
     int i;
 
     /* See if all rows/columns are satisfied. If one is exceeded,
      * mark it as an error (if required)
      */
 
-    char hasscratch = TRUE;
+    bool hasscratch = true;
     if (!scratch) {
         scratch = unruly_new_scratch(state);
-        hasscratch = FALSE;
+        hasscratch = false;
     }
 
     for (i = 0; i < w2; i++) {
         if (scratch->ones_cols[i] < h)
-            below = TRUE;
+            below = true;
         if (scratch->zeros_cols[i] < h)
-            below = TRUE;
+            below = true;
 
         if (scratch->ones_cols[i] > h) {
-            above = TRUE;
+            above = true;
             if (errors)
-                errors[2*h2 + i] = TRUE;
+                errors[2*h2 + i] = true;
         } else if (errors)
-            errors[2*h2 + i] = FALSE;
+            errors[2*h2 + i] = false;
 
         if (scratch->zeros_cols[i] > h) {
-            above = TRUE;
+            above = true;
             if (errors)
-                errors[2*h2 + w2 + i] = TRUE;
+                errors[2*h2 + w2 + i] = true;
         } else if (errors)
-            errors[2*h2 + w2 + i] = FALSE;
+            errors[2*h2 + w2 + i] = false;
     }
     for (i = 0; i < h2; i++) {
         if (scratch->ones_rows[i] < w)
-            below = TRUE;
+            below = true;
         if (scratch->zeros_rows[i] < w)
-            below = TRUE;
+            below = true;
 
         if (scratch->ones_rows[i] > w) {
-            above = TRUE;
+            above = true;
             if (errors)
-                errors[i] = TRUE;
+                errors[i] = true;
         } else if (errors)
-            errors[i] = FALSE;
+            errors[i] = false;
 
         if (scratch->zeros_rows[i] > w) {
-            above = TRUE;
+            above = true;
             if (errors)
-                errors[h2 + i] = TRUE;
+                errors[h2 + i] = true;
         } else if (errors)
-            errors[h2 + i] = FALSE;
+            errors[h2 + i] = false;
     }
 
     if (!hasscratch)
@@ -1121,7 +1132,7 @@ static int unruly_solve_game(game_state *state,
 {
     int done, maxdiff = -1;
 
-    while (TRUE) {
+    while (true) {
         done = 0;
 
         /* Check for impending 3's */
@@ -1215,8 +1226,8 @@ static char *solve_game(const game_state *state, const game_state *currstate,
  * Generator *
  * ********* */
 
-static int unruly_fill_game(game_state *state, struct unruly_scratch *scratch,
-                            random_state *rs)
+static bool unruly_fill_game(game_state *state, struct unruly_scratch *scratch,
+                             random_state *rs)
 {
 
     int w2 = state->w2, h2 = state->h2;
@@ -1263,17 +1274,17 @@ static int unruly_fill_game(game_state *state, struct unruly_scratch *scratch,
 
     if (unruly_validate_all_rows(state, NULL) != 0
         || unruly_validate_counts(state, scratch, NULL) != 0)
-        return FALSE;
+        return false;
 
-    return TRUE;
+    return true;
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, int interactive)
+                           char **aux, bool interactive)
 {
 #ifdef STANDALONE_SOLVER
     char *debug;
-    int temp_verbose = FALSE;
+    bool temp_verbose = false;
 #endif
 
     int w2 = params->w2, h2 = params->h2;
@@ -1289,7 +1300,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
     while (1) {
 
-        while (TRUE) {
+        while (true) {
             attempts++;
             state = blank_state(w2, h2, params->unique);
             scratch = unruly_new_scratch(state);
@@ -1307,7 +1318,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
             sfree(debug);
 
             temp_verbose = solver_verbose;
-            solver_verbose = FALSE;
+            solver_verbose = false;
         }
 #endif
 
@@ -1348,7 +1359,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
 #ifdef STANDALONE_SOLVER
         if (temp_verbose) {
-            solver_verbose = TRUE;
+            solver_verbose = true;
 
             printf("Final puzzle:\n");
             debug = game_text_format(state);
@@ -1361,7 +1372,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
          * See if the game has accidentally come out too easy.
          */
         if (params->diff > 0) {
-            int ok;
+            bool ok;
             game_state *solver;
 
             solver = dup_game(state);
@@ -1369,7 +1380,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
             unruly_solve_game(solver, scratch, params->diff - 1);
 
-            ok = unruly_validate_counts(solver, scratch, NULL);
+            ok = unruly_validate_counts(solver, scratch, NULL) > 0;
 
             free_game(solver);
             unruly_free_scratch(scratch);
@@ -1420,7 +1431,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
 struct game_ui {
     int cx, cy;
-    char cursor;
+    bool cursor;
 };
 
 static game_ui *new_ui(const game_state *state)
@@ -1428,7 +1439,7 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ret = snew(game_ui);
 
     ret->cx = ret->cy = 0;
-    ret->cursor = FALSE;
+    ret->cursor = false;
 
     return ret;
 }
@@ -1455,10 +1466,10 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 struct game_drawstate {
     int tilesize;
     int w2, h2;
-    int started;
+    bool started;
 
     int *gridfs;
-    int *rowfs;
+    bool *rowfs;
 
     int *grid;
 };
@@ -1474,10 +1485,10 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     ds->tilesize = 0;
     ds->w2 = w2;
     ds->h2 = h2;
-    ds->started = FALSE;
+    ds->started = false;
 
     ds->gridfs = snewn(s, int);
-    ds->rowfs = snewn(2 * (w2 + h2), int);
+    ds->rowfs = snewn(2 * (w2 + h2), bool);
 
     ds->grid = snewn(s, int);
     for (i = 0; i < s; i++)
@@ -1518,15 +1529,15 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             && oy >= (ds->tilesize / 2) && gy < h2) {
             hx = gx;
             hy = gy;
-            ui->cursor = FALSE;
+            ui->cursor = false;
         } else
             return NULL;
     }
 
     /* Keyboard move */
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cx, &ui->cy, w2, h2, 0);
-        ui->cursor = TRUE;
+        move_cursor(button, &ui->cx, &ui->cy, w2, h2, false);
+        ui->cursor = true;
         return UI_UPDATE;
     }
 
@@ -1539,7 +1550,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         char buf[80];
         char c, i;
 
-        if (state->immutable[hy * w2 + hx])
+        if (state->common->immutable[hy * w2 + hx])
             return NULL;
 
         c = '-';
@@ -1595,7 +1606,7 @@ static game_state *execute_move(const game_state *state, const char *move)
             p++;
         }
 
-        ret->completed = ret->cheated = TRUE;
+        ret->completed = ret->cheated = true;
         return ret;
     } else if (move[0] == 'P'
                && sscanf(move + 1, "%c,%d,%d", &c, &x, &y) == 3 && x >= 0
@@ -1604,7 +1615,7 @@ static game_state *execute_move(const game_state *state, const char *move)
         ret = dup_game(state);
         i = y * w2 + x;
 
-        if (state->immutable[i]) {
+        if (state->common->immutable[i]) {
             free_game(ret);
             return NULL;
         }
@@ -1613,7 +1624,7 @@ static game_state *execute_move(const game_state *state, const char *move)
 
         if (!ret->completed && unruly_validate_counts(ret, NULL, NULL) == 0
             && (unruly_validate_all_rows(ret, NULL) == 0))
-            ret->completed = TRUE;
+            ret->completed = true;
 
         return ret;
     }
@@ -1786,7 +1797,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
                   TILE_SIZE*h2 + 2*(TILE_SIZE/10) - 1, COL_GRID);
 
         draw_update(dr, 0, 0, TILE_SIZE * (w2+1), TILE_SIZE * (h2+1));
-        ds->started = TRUE;
+        ds->started = true;
     }
 
     flash = 0;
@@ -1797,7 +1808,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
         ds->gridfs[i] = 0;
     unruly_validate_all_rows(state, ds->gridfs);
     for (i = 0; i < 2 * (h2 + w2); i++)
-        ds->rowfs[i] = 0;
+        ds->rowfs[i] = false;
     unruly_validate_counts(state, NULL, ds->rowfs);
 
     for (y = 0; y < h2; y++) {
@@ -1820,7 +1831,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 
             tile |= flash;
 
-            if (state->immutable[i])
+            if (state->common->immutable[i])
                 tile |= FF_IMMUTABLE;
 
             if (ui->cursor && ui->cx == x && ui->cy == y)
@@ -1854,9 +1865,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1913,15 +1924,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_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,
+    true, solve_game,
+    true, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1938,9 +1949,9 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    TRUE, FALSE, game_print_size, game_print,
-    FALSE,                      /* wants_statusbar */
-    FALSE, game_timing_state,
+    true, false, game_print_size, game_print,
+    false,                      /* wants_statusbar */
+    false, game_timing_state,
     0,                          /* flags */
 };
 
@@ -1986,7 +1997,7 @@ int main(int argc, char *argv[])
             seed = (time_t) atoi(*++argv);
             argc--;
         } else if (!strcmp(p, "-v"))
-            solver_verbose = TRUE;
+            solver_verbose = true;
         else if (*p == '-')
             usage_exit("unrecognised option");
         else
@@ -2000,7 +2011,7 @@ int main(int argc, char *argv[])
 
         params = default_params();
         decode_params(params, id);
-        err = validate_params(params, TRUE);
+        err = validate_params(params, true);
         if (err) {
             fprintf(stderr, "Parameters are invalid\n");
             fprintf(stderr, "%s: %s", argv[0], err);
@@ -2014,8 +2025,8 @@ int main(int argc, char *argv[])
         if (!params)
             params = default_params();
         printf("Generating puzzle with parameters %s\n",
-               encode_params(params, TRUE));
-        desc_gen = new_game_desc(params, rs, &aux, FALSE);
+               encode_params(params, true));
+        desc_gen = new_game_desc(params, rs, &aux, false);
 
         if (!solver_verbose) {
             char *fmt = game_text_format(new_game(NULL, params, desc_gen));
diff --git a/apps/plugins/puzzles/src/untangle.c b/apps/plugins/puzzles/src/untangle.c
index 0bcd04d658..eff93382cd 100644
--- a/apps/plugins/puzzles/src/untangle.c
+++ b/apps/plugins/puzzles/src/untangle.c
@@ -97,7 +97,7 @@ struct game_state {
     int *crosses;		       /* mark edges which are crossed */
 #endif
     struct graph *graph;
-    int completed, cheated, just_solved;
+    bool completed, cheated, just_solved;
 };
 
 static int edgecmpC(const void *av, const void *bv)
@@ -127,7 +127,7 @@ static game_params *default_params(void)
     return ret;
 }
 
-static int game_fetch_preset(int i, char **name, game_params **params)
+static bool game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     int n;
@@ -139,7 +139,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
       case 2: n = 15; break;
       case 3: n = 20; break;
       case 4: n = 25; break;
-      default: return FALSE;
+      default: return false;
     }
 
     sprintf(buf, "%d points", n);
@@ -148,7 +148,7 @@ static int game_fetch_preset(int i, char **name, game_params **params)
     *params = ret = snew(game_params);
     ret->n = n;
 
-    return TRUE;
+    return true;
 }
 
 static void free_params(game_params *params)
@@ -168,7 +168,7 @@ static void decode_params(game_params *params, char const *string)
     params->n = atoi(string);
 }
 
-static char *encode_params(const game_params *params, int full)
+static char *encode_params(const game_params *params, bool full)
 {
     char buf[80];
 
@@ -204,7 +204,7 @@ static game_params *custom_params(const config_item *cfg)
     return ret;
 }
 
-static const char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, bool full)
 {
     if (params->n < 4)
         return "Number of points must be at least four";
@@ -300,7 +300,7 @@ static int64 dotprod64(long a, long b, long p, long q)
  * between b1 and b2, intersect. We count it as an intersection if
  * any of the endpoints lies _on_ the other line.
  */
-static int cross(point a1, point a2, point b1, point b2)
+static bool cross(point a1, point a2, point b1, point b2)
 {
     long b1x, b1y, b2x, b2y, px, py;
     int64 d1, d2, d3;
@@ -333,7 +333,7 @@ static int cross(point a1, point a2, point b1, point b2)
     /* If they have the same non-zero sign, the lines do not cross. */
     if ((sign64(d1) > 0 && sign64(d2) > 0) ||
 	(sign64(d1) < 0 && sign64(d2) < 0))
-	return FALSE;
+	return false;
 
     /*
      * If the dot products are both exactly zero, then the two line
@@ -350,13 +350,13 @@ static int cross(point a1, point a2, point b1, point b2)
 	d2 = dotprod64(b2x, px, b2y, py);
 	/* If they're both strictly negative, the lines do not cross. */
 	if (sign64(d1) < 0 && sign64(d2) < 0)
-	    return FALSE;
+	    return false;
 	/* Otherwise, take the dot product of a2-a1 with itself. If
 	 * the other two dot products both exceed this, the lines do
 	 * not cross. */
 	d3 = dotprod64(px, px, py, py);
 	if (greater64(d1, d3) && greater64(d2, d3))
-	    return FALSE;
+	    return false;
     }
 
     /*
@@ -375,12 +375,12 @@ static int cross(point a1, point a2, point b1, point b2)
     d2 = dotprod64(b2x, px, b2y, py);
     if ((sign64(d1) > 0 && sign64(d2) > 0) ||
 	(sign64(d1) < 0 && sign64(d2) < 0))
-	return FALSE;
+	return false;
 
     /*
      * The lines must cross.
      */
-    return TRUE;
+    return true;
 }
 
 static unsigned long squarert(unsigned long n) {
@@ -422,7 +422,7 @@ static void addedge(tree234 *edges, int a, int b)
     add234(edges, e);
 }
 
-static int isedge(tree234 *edges, int a, int b)
+static bool isedge(tree234 *edges, int a, int b)
 {
     edge e;
 
@@ -491,7 +491,7 @@ static void make_circle(point *pts, int n, int w)
 }
 
 static char *new_game_desc(const game_params *params, random_state *rs,
-			   char **aux, int interactive)
+			   char **aux, bool interactive)
 {
     int n = params->n, i;
     long w, h, j, k, m;
@@ -542,7 +542,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     edges = newtree234(edgecmp);
     vlist = snewn(n, vertex);
     while (1) {
-	int added = FALSE;
+        bool added = false;
 
 	for (i = 0; i < n; i++) {
 	    v = index234(vertices, i);
@@ -604,7 +604,7 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 		 * the two vertices involved, and break.
 		 */
 		addedge(edges, j, ki);
-		added = TRUE;
+		added = true;
 		del234(vertices, vs+j);
 		vs[j].param++;
 		add234(vertices, vs+j);
@@ -761,13 +761,13 @@ static const char *validate_desc(const game_params *params, const char *desc)
 
 static void mark_crossings(game_state *state)
 {
-    int ok = TRUE;
+    bool ok = true;
     int i, j;
     edge *e, *e2;
 
 #ifdef SHOW_CROSSINGS
     for (i = 0; (e = index234(state->graph->edges, i)) != NULL; i++)
-	state->crosses[i] = FALSE;
+	state->crosses[i] = false;
 #endif
 
     /*
@@ -781,9 +781,9 @@ static void mark_crossings(game_state *state)
 		continue;
 	    if (cross(state->pts[e2->a], state->pts[e2->b],
 		      state->pts[e->a], state->pts[e->b])) {
-		ok = FALSE;
+		ok = false;
 #ifdef SHOW_CROSSINGS
-		state->crosses[i] = state->crosses[j] = TRUE;
+		state->crosses[i] = state->crosses[j] = true;
 #else
 		goto done;	       /* multi-level break - sorry */
 #endif
@@ -799,7 +799,7 @@ static void mark_crossings(game_state *state)
     done:
 #endif
     if (ok)
-	state->completed = TRUE;
+	state->completed = true;
 }
 
 static game_state *new_game(midend *me, const game_params *params,
@@ -816,7 +816,7 @@ static game_state *new_game(midend *me, const game_params *params,
     state->graph = snew(struct graph);
     state->graph->refcount = 1;
     state->graph->edges = newtree234(edgecmp);
-    state->completed = state->cheated = state->just_solved = FALSE;
+    state->completed = state->cheated = state->just_solved = false;
 
     while (*desc) {
 	a = atoi(desc);
@@ -1025,9 +1025,9 @@ static char *solve_game(const game_state *state, const game_state *currstate,
     return ret;
 }
 
-static int game_can_format_as_text_now(const game_params *params)
+static bool game_can_format_as_text_now(const game_params *params)
 {
-    return TRUE;
+    return true;
 }
 
 static char *game_text_format(const game_state *state)
@@ -1043,8 +1043,8 @@ struct game_ui {
                                         * again -1 if none */
 
     point newpoint;		       /* where it's been dragged to so far */
-    int just_dragged;		       /* reset in game_changed_state */
-    int just_moved;		       /* _set_ in game_changed_state */
+    bool just_dragged;                 /* reset in game_changed_state */
+    bool just_moved;                   /* _set_ in game_changed_state */
     float anim_length;
 };
 
@@ -1053,7 +1053,7 @@ static game_ui *new_ui(const game_state *state)
     game_ui *ui = snew(game_ui);
     ui->dragpoint = -1;
     ui->cursorpoint = -1;
-    ui->just_moved = ui->just_dragged = FALSE;
+    ui->just_moved = ui->just_dragged = false;
     return ui;
 }
 
@@ -1076,7 +1076,7 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
 {
     ui->dragpoint = -1;
     ui->just_moved = ui->just_dragged;
-    ui->just_dragged = FALSE;
+    ui->just_dragged = false;
 }
 
 struct game_drawstate {
@@ -1153,7 +1153,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 	 */
 	sprintf(buf, "P%d:%ld,%ld/%ld", p,
 		ui->newpoint.x, ui->newpoint.y, ui->newpoint.d);
-	ui->just_dragged = TRUE;
+	ui->just_dragged = true;
 	return dupstr(buf);
     }
     else if(IS_CURSOR_MOVE(button))
@@ -1202,13 +1202,13 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 if(angle < 0)
                     angle += 2*PI;
 
-                right_direction = FALSE;
+                right_direction = false;
 
                 if((button == CURSOR_UP && (1*PI/4 <= angle && angle <= 3*PI/4))   ||
                    (button == CURSOR_LEFT && (3*PI/4 <= angle && angle <= 5*PI/4)) ||
                    (button == CURSOR_DOWN && (5*PI/4 <= angle && angle <= 7*PI/4)) ||
                    (button == CURSOR_RIGHT && (angle >= 7*PI/4 || angle <= 1*PI/4)))
-                    right_direction = TRUE;
+                    right_direction = true;
 
                 if ((best == -1 || bestd > d) && right_direction) {
                     best = i;
@@ -1281,7 +1281,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
              */
             sprintf(buf, "P%d:%ld,%ld/%ld", p,
                     ui->newpoint.x, ui->newpoint.y, ui->newpoint.d);
-            ui->just_dragged = TRUE;
+            ui->just_dragged = true;
             return dupstr(buf);
         }
         else if(ui->cursorpoint < 0)
@@ -1301,13 +1301,13 @@ static game_state *execute_move(const game_state *state, const char *move)
     long x, y, d;
     game_state *ret = dup_game(state);
 
-    ret->just_solved = FALSE;
+    ret->just_solved = false;
 
     while (*move) {
 	if (*move == 'S') {
 	    move++;
 	    if (*move == ';') move++;
-	    ret->cheated = ret->just_solved = TRUE;
+	    ret->cheated = ret->just_solved = true;
 	}
 	if (*move == 'P' &&
 	    sscanf(move+1, "%d:%ld,%ld/%ld%n", &p, &x, &y, &d, &k) == 4 &&
@@ -1444,7 +1444,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     int w, h;
     edge *e;
     int i, j;
-    int bg, points_moved;
+    int bg;
+    bool points_moved;
 
     /*
      * There's no terribly sensible way to do partial redraws of
@@ -1469,7 +1470,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      * Also in this loop we work out the coordinates of all the
      * points for this redraw.
      */
-    points_moved = FALSE;
+    points_moved = false;
     for (i = 0; i < state->params.n; i++) {
         point p = state->pts[i];
         long x, y;
@@ -1484,7 +1485,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
 	y = p.y * ds->tilesize / p.d;
 
         if (ds->x[i] != x || ds->y[i] != y)
-            points_moved = TRUE;
+            points_moved = true;
 
         ds->x[i] = x;
         ds->y[i] = y;
@@ -1585,9 +1586,9 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(const game_state *state, game_ui *ui)
+static bool game_timing_state(const game_state *state, game_ui *ui)
 {
-    return TRUE;
+    return true;
 }
 
 static void game_print_size(const game_params *params, float *x, float *y)
@@ -1610,15 +1611,15 @@ const struct game thegame = {
     encode_params,
     free_params,
     dup_params,
-    TRUE, game_configure, custom_params,
+    true, game_configure, custom_params,
     validate_params,
     new_game_desc,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    TRUE, solve_game,
-    FALSE, game_can_format_as_text_now, game_text_format,
+    true, solve_game,
+    false, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
     encode_ui,
@@ -1635,8 +1636,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_status,
-    FALSE, FALSE, game_print_size, game_print,
-    FALSE,			       /* wants_statusbar */
-    FALSE, game_timing_state,
+    false, false, game_print_size, game_print,
+    false,			       /* wants_statusbar */
+    false, game_timing_state,
     SOLVE_ANIMATES,		       /* flags */
 };
diff --git a/apps/plugins/puzzles/src/windows.c b/apps/plugins/puzzles/src/windows.c
index 8e5b40650d..38559c5454 100644
--- a/apps/plugins/puzzles/src/windows.c
+++ b/apps/plugins/puzzles/src/windows.c
@@ -61,7 +61,7 @@ static HINSTANCE hh_dll;
 #endif /* NO_HTMLHELP */
 enum { NONE, HLP, CHM } help_type;
 char *help_path;
-int help_has_contents;
+bool help_has_contents;
 
 #ifndef FILENAME_MAX
 #define	FILENAME_MAX	(260)
@@ -114,7 +114,7 @@ LPCSTR getenv(LPCSTR buf)
 
 BOOL GetKeyboardState(PBYTE pb)
 {
-  return FALSE;
+  return false;
 }
 
 static TCHAR wClassName[256], wGameName[256];
@@ -229,15 +229,17 @@ struct frontend {
     HFONT cfgfont;
     HBRUSH oldbr;
     HPEN oldpen;
-    int help_running;
+    bool help_running;
     enum { DRAWING, PRINTING, NOTHING } drawstatus;
     DOCINFO di;
-    int printcount, printw, printh, printsolns, printcurr, printcolour;
+    int printcount, printw, printh;
+    bool printsolns, printcurr, printcolour;
     float printscale;
     int printoffsetx, printoffsety;
     float printpixelscale;
     int fontstart;
-    int linewidth, linedotted;
+    int linewidth;
+    bool linedotted;
     drawing *dr;
     int xmin, ymin;
     float puzz_scale;
@@ -495,7 +497,7 @@ static void win_reset_brush(frontend *fe)
 	DeleteObject(br);
 }
 
-static void win_set_pen(frontend *fe, int colour, int thin)
+static void win_set_pen(frontend *fe, int colour, bool thin)
 {
     HPEN pen;
     assert(fe->drawstatus != NOTHING);
@@ -656,7 +658,7 @@ static void win_draw_rect(void *handle, int x, int y, int w, int h, int colour)
 	SetPixel(fe->hdc, x, y, fe->colours[colour]);
     } else {
 	win_set_brush(fe, colour);
-	win_set_pen(fe, colour, TRUE);
+	win_set_pen(fe, colour, true);
 	p = win_transform_point(fe, x, y);
 	q = win_transform_point(fe, x+w, y+h);
 	Rectangle(fe->hdc, p.x, p.y, q.x, q.y);
@@ -673,7 +675,7 @@ static void win_draw_line(void *handle, int x1, int y1, int x2, int y2, int colo
     if (fe->drawstatus == NOTHING)
 	return;
 
-    win_set_pen(fe, colour, FALSE);
+    win_set_pen(fe, colour, false);
     pp[0] = win_transform_point(fe, x1, y1);
     pp[1] = win_transform_point(fe, x2, y2);
     Polyline(fe->hdc, pp, 2);
@@ -698,7 +700,7 @@ static void win_draw_circle(void *handle, int cx, int cy, int radius,
     else
 	fe->oldbr = SelectObject(fe->hdc, GetStockObject(NULL_BRUSH));
 
-    win_set_pen(fe, outlinecolour, FALSE);
+    win_set_pen(fe, outlinecolour, false);
     p = win_transform_point(fe, cx - radius, cy - radius);
     q = win_transform_point(fe, cx + radius, cy + radius);
     Ellipse(fe->hdc, p.x, p.y, q.x+1, q.y+1);
@@ -727,12 +729,12 @@ static void win_draw_polygon(void *handle, int *coords, int npoints,
 
     if (fillcolour >= 0) {
 	win_set_brush(fe, fillcolour);
-	win_set_pen(fe, outlinecolour, FALSE);
+	win_set_pen(fe, outlinecolour, false);
 	Polygon(fe->hdc, pts, npoints);
 	win_reset_brush(fe);
 	win_reset_pen(fe);
     } else {
-	win_set_pen(fe, outlinecolour, FALSE);
+	win_set_pen(fe, outlinecolour, false);
 	Polyline(fe->hdc, pts, npoints+1);
 	win_reset_pen(fe);
     }
@@ -772,7 +774,7 @@ static void win_draw_update(void *handle, int x, int y, int w, int h)
     r.bottom = y + h;
 
     OffsetRect(&r, fe->bitmapPosition.left, fe->bitmapPosition.top);
-    InvalidateRect(fe->hwnd, &r, FALSE);
+    InvalidateRect(fe->hwnd, &r, false);
 }
 
 static void win_end_draw(void *handle)
@@ -799,7 +801,7 @@ static void win_line_width(void *handle, float width)
     fe->linewidth = (int)(width * fe->printpixelscale);
 }
 
-static void win_line_dotted(void *handle, int dotted)
+static void win_line_dotted(void *handle, bool dotted)
 {
     frontend *fe = (frontend *)handle;
 
@@ -900,7 +902,7 @@ static void win_begin_puzzle(void *handle, float xm, float xc,
     fe->printpixelscale = scale;
 
     fe->linewidth = 1;
-    fe->linedotted = FALSE;
+    fe->linedotted = false;
 }
 
 static void win_end_puzzle(void *handle)
@@ -1222,9 +1224,9 @@ static void init_help(void)
 	strcpy(r, HELP_CNT_NAME);
 	if ( (fp = fopen(b, "r")) != NULL) {
 	    fclose(fp);
-	    help_has_contents = TRUE;
+	    help_has_contents = true;
 	} else
-	    help_has_contents = FALSE;
+	    help_has_contents = false;
 
 	return;
     }
@@ -1256,7 +1258,7 @@ static void start_help(frontend *fe, const char *topic)
 	    cmd = HELP_CONTENTS;
 	}
 	WinHelp(fe->hwnd, help_path, cmd, (DWORD)str);
-	fe->help_running = TRUE;
+	fe->help_running = true;
 	break;
       case CHM:
 #ifndef NO_HTMLHELP
@@ -1269,7 +1271,7 @@ static void start_help(frontend *fe, const char *topic)
 	    str = dupstr(help_path);
 	}
 	htmlhelp(fe->hwnd, str, HH_DISPLAY_TOPIC, 0);
-	fe->help_running = TRUE;
+	fe->help_running = true;
 	break;
 #endif /* NO_HTMLHELP */
       case NONE:
@@ -1300,7 +1302,7 @@ static void stop_help(frontend *fe)
 	    assert(!"This shouldn't happen");
 	    break;
 	}
-	fe->help_running = FALSE;
+	fe->help_running = false;
     }
 }
 
@@ -1361,12 +1363,12 @@ static void get_menu_size(HWND wh, RECT *r)
  * furniture (wx,wy).
  */
 
-static int check_window_resize(frontend *fe, int cx, int cy,
-                               int *px, int *py,
-                               int *wx, int *wy)
+static bool check_window_resize(frontend *fe, int cx, int cy,
+                                int *px, int *py, int *wx, int *wy)
 {
     RECT r;
-    int x, y, sy = get_statusbar_height(fe), changed = 0;
+    int x, y, sy = get_statusbar_height(fe);
+    bool changed = false;
 
     /* disallow making window thinner than menu bar */
     x = max(cx, fe->xmin);
@@ -1376,7 +1378,7 @@ static int check_window_resize(frontend *fe, int cx, int cy,
      * See if we actually got the window size we wanted, and adjust
      * the puzzle size if not.
      */
-    midend_size(fe->me, &x, &y, TRUE);
+    midend_size(fe->me, &x, &y, true);
     if (x != cx || y != cy) {
         /*
          * Resize the window, now we know what size we _really_
@@ -1385,10 +1387,10 @@ static int check_window_resize(frontend *fe, int cx, int cy,
         r.left = r.top = 0;
         r.right = x;
         r.bottom = y + sy;
-        AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+        AdjustWindowRectEx(&r, WINFLAGS, true, 0);
         *wx = r.right - r.left;
         *wy = r.bottom - r.top;
-        changed = 1;
+        changed = true;
     }
 
     *px = x;
@@ -1430,14 +1432,14 @@ static void get_max_puzzle_size(frontend *fe, int *x, int *y)
 {
     RECT r, sr;
 
-    if (SystemParametersInfo(SPI_GETWORKAREA, 0, &sr, FALSE)) {
+    if (SystemParametersInfo(SPI_GETWORKAREA, 0, &sr, false)) {
 	*x = sr.right - sr.left;
 	*y = sr.bottom - sr.top;
 	r.left = 100;
 	r.right = 200;
 	r.top = 100;
 	r.bottom = 200;
-	AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+	AdjustWindowRectEx(&r, WINFLAGS, true, 0);
 	*x -= r.right - r.left - 100;
 	*y -= r.bottom - r.top - 100;
     } else {
@@ -1485,7 +1487,7 @@ static frontend *frontend_new(HINSTANCE inst)
     fe->timer = 0;
     fe->hwnd = NULL;
 
-    fe->help_running = FALSE;
+    fe->help_running = false;
 
     fe->drawstatus = NOTHING;
     fe->dr = NULL;
@@ -1523,7 +1525,7 @@ static frontend *frontend_new(HINSTANCE inst)
 	GetWindowRect(fe->hwnd, &rc);
 	GetWindowRect(mbi.hwndMB, &rcBar);
 	rc.bottom -= rcBar.bottom - rcBar.top;
-	MoveWindow(fe->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, FALSE);
+	MoveWindow(fe->hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, false);
 
         fe->numpad = NULL;
     }
@@ -1557,7 +1559,7 @@ static void savefile_write(void *wctx, const void *buf, int len)
     fwrite(buf, 1, len, fp);
 }
 
-static int savefile_read(void *wctx, void *buf, int len)
+static bool savefile_read(void *wctx, void *buf, int len)
 {
     FILE *fp = (FILE *)wctx;
     int ret;
@@ -1576,8 +1578,8 @@ static int savefile_read(void *wctx, void *buf, int len)
  * permissible.
  */
 static midend *midend_for_new_game(frontend *fe, const game *cgame,
-                                   char *arg, int maybe_game_id,
-                                   int maybe_save_file, char **error)
+                                   char *arg, bool maybe_game_id,
+                                   bool maybe_save_file, char **error)
 {
     midend *me = NULL;
 
@@ -1717,7 +1719,11 @@ static int fe_set_midend(frontend *fe, midend *me)
     int x, y;
     RECT r;
 
-    if (fe->me) midend_free(fe->me);
+    if (fe->me) {
+        midend_free(fe->me);
+        fe->preset_menu = NULL;
+        sfree(fe->preset_menuitems);
+    }
     fe->me = me;
     fe->game = midend_which_game(fe->me);
 
@@ -1757,12 +1763,12 @@ static int fe_set_midend(frontend *fe, midend *me)
         fe->statusbar = NULL;
 
     get_max_puzzle_size(fe, &x, &y);
-    midend_size(fe->me, &x, &y, FALSE);
+    midend_size(fe->me, &x, &y, false);
 
     r.left = r.top = 0;
     r.right = x;
     r.bottom = y;
-    AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+    AdjustWindowRectEx(&r, WINFLAGS, true, 0);
 
 #ifdef _WIN32_WCE
     if (fe->numpad)
@@ -1781,7 +1787,7 @@ static int fe_set_midend(frontend *fe, midend *me)
                    rcClient.bottom - (rcTB.bottom - rcTB.top) - 1,
                    rcClient.right,
                    rcTB.bottom - rcTB.top,
-                   FALSE);
+                   false);
         SendMessage(fe->numpad, TB_SETINDENT, (rcClient.right - (10 * 21)) / 2, 0);
     }
     else {
@@ -1803,7 +1809,7 @@ static int fe_set_midend(frontend *fe, midend *me)
 				       fe->hwnd, NULL, fe->inst, NULL);
 #ifdef _WIN32_WCE
 	/* Flat status bar looks better on the Pocket PC */
-	SendMessage(fe->statusbar, SB_SIMPLE, (WPARAM) TRUE, 0);
+	SendMessage(fe->statusbar, SB_SIMPLE, (WPARAM) true, 0);
 	SendMessage(fe->statusbar, SB_SETTEXT,
 				(WPARAM) 255 | SBT_NOBORDERS,
 				(LPARAM) L"");
@@ -1845,12 +1851,14 @@ static int fe_set_midend(frontend *fe, midend *me)
 	AppendMenu(menu, MF_ENABLED, IDM_SEED, TEXT("Rando&m Seed..."));
 #endif
 
-        if (!fe->preset_menu) {
+        assert(!fe->preset_menu);
+
+        fe->preset_menu = midend_get_presets(
+            fe->me, &fe->n_preset_menuitems);
+        fe->preset_menuitems = snewn(fe->n_preset_menuitems,
+                                     struct preset_menuitemref);
+        {
             int i;
-            fe->preset_menu = midend_get_presets(
-                fe->me, &fe->n_preset_menuitems);
-            fe->preset_menuitems = snewn(fe->n_preset_menuitems,
-                                         struct preset_menuitemref);
             for (i = 0; i < fe->n_preset_menuitems; i++)
                 fe->preset_menuitems[i].which_menu = NULL;
         }
@@ -2013,7 +2021,7 @@ static int CALLBACK AboutDlgProc(HWND hwnd, UINT msg,
 	    SetDlgItemTextA(hwnd, IDC_ABOUT_VERSION, ver);
 	}
 #endif
-	return TRUE;
+	return 1;
 
       case WM_COMMAND:
 	if (LOWORD(wParam) == IDOK)
@@ -2078,18 +2086,18 @@ static config_item *frontend_get_config(frontend *fe, int which,
 
 	ret[i].name = "Include currently shown puzzle";
 	ret[i].type = C_BOOLEAN;
-	ret[i].u.boolean.bval = TRUE;
+	ret[i].u.boolean.bval = true;
 	i++;
 
 	ret[i].name = "Print solutions";
 	ret[i].type = C_BOOLEAN;
-	ret[i].u.boolean.bval = FALSE;
+	ret[i].u.boolean.bval = false;
 	i++;
 
 	if (fe->game->can_print_in_colour) {
 	    ret[i].name = "Print in colour";
 	    ret[i].type = C_BOOLEAN;
-	    ret[i].u.boolean.bval = FALSE;
+	    ret[i].u.boolean.bval = false;
 	    i++;
 	}
 
@@ -2270,7 +2278,7 @@ static int CALLBACK ConfigDlgProc(HWND hwnd, UINT msg,
 	    create_config_controls(fe);
 	}
 #endif
-	return TRUE;
+	return 1;
 
       case WM_COMMAND:
 	/*
@@ -2352,7 +2360,7 @@ HWND mkctrl(frontend *fe, int x1, int x2, int y1, int y2,
     ret = CreateWindowEx(exstyle, wclass, wtext,
 			 wstyle | WS_CHILD | WS_VISIBLE, x1, y1, x2-x1, y2-y1,
 			 fe->cfgbox, (HMENU) wid, fe->inst, NULL);
-    SendMessage(ret, WM_SETFONT, (WPARAM)fe->cfgfont, MAKELPARAM(TRUE, 0));
+    SendMessage(ret, WM_SETFONT, (WPARAM)fe->cfgfont, MAKELPARAM(true, 0));
     return ret;
 }
 #endif
@@ -2398,11 +2406,11 @@ static void about(frontend *fe)
     hdc = GetDC(fe->hwnd);
     SetMapMode(hdc, MM_TEXT);
 
-    fe->dlg_done = FALSE;
+    fe->dlg_done = 0;
 
     fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
 			     0, 0, 0, 0,
-			     FALSE, FALSE, FALSE, DEFAULT_CHARSET,
+			     false, false, false, DEFAULT_CHARSET,
 			     OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
 			     DEFAULT_QUALITY,
 			     FF_SWISS,
@@ -2453,7 +2461,7 @@ static void about(frontend *fe)
 				DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
 				WS_CAPTION | WS_SYSMENU*/) &~
 			   (WS_MAXIMIZEBOX | WS_OVERLAPPED),
-			   FALSE, 0);
+			   false, 0);
 
 	/*
 	 * Centre the dialog on its parent window.
@@ -2474,7 +2482,7 @@ static void about(frontend *fe)
 				    fe->hwnd, NULL, fe->inst, NULL);
     }
 
-    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, FALSE);
+    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, false);
 
     SetWindowLongPtr(fe->cfgbox, GWLP_USERDATA, (LONG_PTR)fe);
     SetWindowLongPtr(fe->cfgbox, DWLP_DLGPROC, (LONG_PTR)AboutDlgProc);
@@ -2498,7 +2506,7 @@ static void about(frontend *fe)
 
     SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
 
-    EnableWindow(fe->hwnd, FALSE);
+    EnableWindow(fe->hwnd, false);
     ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
     while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
 	if (!IsDialogMessage(fe->cfgbox, &msg))
@@ -2506,14 +2514,14 @@ static void about(frontend *fe)
 	if (fe->dlg_done)
 	    break;
     }
-    EnableWindow(fe->hwnd, TRUE);
+    EnableWindow(fe->hwnd, true);
     SetForegroundWindow(fe->hwnd);
     DestroyWindow(fe->cfgbox);
     DeleteObject(fe->cfgfont);
 #endif
 }
 
-static int get_config(frontend *fe, int which)
+static bool get_config(frontend *fe, int which)
 {
 #ifdef _WIN32_WCE
     fe->cfg_which = which;
@@ -2552,11 +2560,11 @@ static int get_config(frontend *fe, int which)
     hdc = GetDC(fe->hwnd);
     SetMapMode(hdc, MM_TEXT);
 
-    fe->dlg_done = FALSE;
+    fe->dlg_done = 0;
 
     fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
 			     0, 0, 0, 0,
-			     FALSE, FALSE, FALSE, DEFAULT_CHARSET,
+			     false, false, false, DEFAULT_CHARSET,
 			     OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
 			     DEFAULT_QUALITY,
 			     FF_SWISS,
@@ -2633,7 +2641,7 @@ static int get_config(frontend *fe, int which)
 				DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
 				WS_CAPTION | WS_SYSMENU*/) &~
 			   (WS_MAXIMIZEBOX | WS_OVERLAPPED),
-			   FALSE, 0);
+			   false, 0);
 
 	/*
 	 * Centre the dialog on its parent window.
@@ -2655,7 +2663,7 @@ static int get_config(frontend *fe, int which)
 	sfree(title);
     }
 
-    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, FALSE);
+    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, false);
 
     SetWindowLongPtr(fe->cfgbox, GWLP_USERDATA, (LONG_PTR)fe);
     SetWindowLongPtr(fe->cfgbox, DWLP_DLGPROC, (LONG_PTR)ConfigDlgProc);
@@ -2691,7 +2699,7 @@ static int get_config(frontend *fe, int which)
 	    mkctrl(fe, col1l, col2r, y, y+height, "BUTTON",
 		   BS_NOTIFY | BS_AUTOCHECKBOX | WS_TABSTOP,
 		   0, i->name, (j->ctlid = id++));
-	    CheckDlgButton(fe->cfgbox, j->ctlid, (i->u.boolean.bval != 0));
+	    CheckDlgButton(fe->cfgbox, j->ctlid, i->u.boolean.bval);
 	    y += height;
 	    break;
 
@@ -2745,7 +2753,7 @@ static int get_config(frontend *fe, int which)
 
     SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
 
-    EnableWindow(fe->hwnd, FALSE);
+    EnableWindow(fe->hwnd, false);
     ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
     while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
 	if (!IsDialogMessage(fe->cfgbox, &msg))
@@ -2753,7 +2761,7 @@ static int get_config(frontend *fe, int which)
 	if (fe->dlg_done)
 	    break;
     }
-    EnableWindow(fe->hwnd, TRUE);
+    EnableWindow(fe->hwnd, true);
     SetForegroundWindow(fe->hwnd);
     DestroyWindow(fe->cfgbox);
     DeleteObject(fe->cfgfont);
@@ -2822,19 +2830,19 @@ static void new_game_size(frontend *fe, float scale)
     int x, y;
 
     get_max_puzzle_size(fe, &x, &y);
-    midend_size(fe->me, &x, &y, FALSE);
+    midend_size(fe->me, &x, &y, false);
 
     if (scale != 1.0) {
       x = (int)((float)x * fe->puzz_scale);
       y = (int)((float)y * fe->puzz_scale);
-      midend_size(fe->me, &x, &y, TRUE);
+      midend_size(fe->me, &x, &y, true);
     }
     fe->ymin = (fe->xmin * y) / x;
 
     r.left = r.top = 0;
     r.right = x;
     r.bottom = y;
-    AdjustWindowRectEx(&r, WINFLAGS, TRUE, 0);
+    AdjustWindowRectEx(&r, WINFLAGS, true, 0);
 
     if (fe->statusbar != NULL) {
 	GetWindowRect(fe->statusbar, &sr);
@@ -2859,7 +2867,7 @@ static void new_game_size(frontend *fe, float scale)
     new_bitmap(fe, x, y);
 
 #ifdef _WIN32_WCE
-    InvalidateRect(fe->hwnd, NULL, TRUE);
+    InvalidateRect(fe->hwnd, NULL, true);
 #endif
     midend_redraw(fe->me);
 }
@@ -2871,7 +2879,7 @@ static void new_game_size(frontend *fe, float scale)
  * new window size.
  */
 
-static void adjust_game_size(frontend *fe, RECT *proposed, int isedge,
+static void adjust_game_size(frontend *fe, RECT *proposed, bool isedge,
                              int *wx_r, int *wy_r)
 {
     RECT cr, wr;
@@ -2881,7 +2889,7 @@ static void adjust_game_size(frontend *fe, RECT *proposed, int isedge,
      * difference in size we're asking for. */
     GetClientRect(fe->hwnd, &cr);
     wr = cr;
-    AdjustWindowRectEx(&wr, WINFLAGS, TRUE, 0);
+    AdjustWindowRectEx(&wr, WINFLAGS, true, 0);
 
     xdiff = (proposed->right - proposed->left) - (wr.right - wr.left);
     ydiff = (proposed->bottom - proposed->top) - (wr.bottom - wr.top);
@@ -2958,17 +2966,17 @@ static void new_game_type(frontend *fe)
     update_copy_menu_greying(fe);
 }
 
-static int is_alt_pressed(void)
+static bool is_alt_pressed(void)
 {
     BYTE keystate[256];
     int r = GetKeyboardState(keystate);
     if (!r)
-	return FALSE;
+	return false;
     if (keystate[VK_MENU] & 0x80)
-	return TRUE;
+	return true;
     if (keystate[VK_RMENU] & 0x80)
-	return TRUE;
-    return FALSE;
+	return true;
+    return false;
 }
 
 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
@@ -3139,7 +3147,7 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                                     "supported by this program";
                             } else {
                                 me = midend_for_new_game(fe, gamelist[i], NULL,
-                                                         FALSE, FALSE, &err_w);
+                                                         false, false, &err_w);
                                 err = err_w;
                                 rewind(fp); /* for the actual load */
                             }
@@ -3181,7 +3189,7 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                 int p = wParam - IDM_GAMES;
                 char *error = NULL;
                 fe_set_midend(fe, midend_for_new_game(fe, gamelist[p], NULL,
-                                                      FALSE, FALSE, &error));
+                                                      false, false, &error));
                 sfree(error);
             } else
 #endif
@@ -3432,12 +3440,13 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
       case WM_SIZING:
         {
             RECT *sr = (RECT *)lParam;
-            int wx, wy, isedge = 0;
+            int wx, wy;
+            bool isedge = false;
 
             if (wParam == WMSZ_TOP ||
                 wParam == WMSZ_RIGHT ||
                 wParam == WMSZ_BOTTOM ||
-                wParam == WMSZ_LEFT) isedge = 1;
+                wParam == WMSZ_LEFT) isedge = true;
             adjust_game_size(fe, sr, isedge, &wx, &wy);
 
             /* Given the window size the puzzles constrain
@@ -3456,7 +3465,7 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
             } else {
                 sr->right = sr->left + wx;
             }
-            return TRUE;
+            return true;
         }
         break;
 #endif
@@ -3475,10 +3484,10 @@ static int FindPreviousInstance()
     if (hOtherWnd)
     {
         SetForegroundWindow (hOtherWnd);
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 #endif
 
@@ -3632,7 +3641,7 @@ void split_into_argv(char *cmdline, int *argc, char ***argv,
     p = cmdline; q = outputline; outputargc = 0;
 
     while (*p) {
-	int quote;
+	bool quote;
 
 	/* Skip whitespace searching for start of argument. */
 	while (*p && isspace(*p)) p++;
@@ -3642,7 +3651,7 @@ void split_into_argv(char *cmdline, int *argc, char ***argv,
 	outputargv[outputargc] = q;
 	outputargstart[outputargc] = p;
 	outputargc++;
-	quote = 0;
+	quote = false;
 
 	/* Copy data into the argument until it's finished. */
 	while (*p) {
@@ -3676,7 +3685,7 @@ void split_into_argv(char *cmdline, int *argc, char ***argv,
 
 		    if (quotes > 0) {
 			/* Outside a quote segment, a quote starts one. */
-			if (!quote) quotes--, quote = 1;
+			if (!quote) quotes--, quote = true;
 
 			/* Now we produce (n+1)/3 literal quotes... */
 			for (i = 3; i <= quotes+1; i += 3) *q++ = '"';
@@ -3785,7 +3794,7 @@ int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
 
     fe = frontend_new(inst);
     me = midend_for_new_game(fe, gg, argc > 0 ? argv[0] : NULL,
-                             TRUE, TRUE, &error);
+                             true, true, &error);
     if (!me) {
 	char buf[128];
 #ifdef COMBINED