commit c85716f60e475b88ee3a2752bd4eef6ae616130d
Author: reddsik <redspl@redspl.ct8.pl>
Date:   Sun Mar 26 13:00:19 2017 +0200

    Initial commit!

diff --git a/Amilogo.bm b/Amilogo.bm
new file mode 100644
index 0000000..348f818
--- /dev/null
+++ b/Amilogo.bm
@@ -0,0 +1,478 @@
+#define amiwmlogo_width 237
+#define amiwmlogo_height 237
+static char amiwmlogo_bits[] = {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x10,0x11,0x91,0x24,0xe1,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,
+ 0x92,0x24,0x49,0x95,0x00,0x00,0x00,0x00,0x00,0x20,0xa5,0xa4,0x24,0x49,0xe2,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x01,0x00,0x20,0x01,0x00,0x80,
+ 0x00,0x40,0x00,0x20,0x02,0x00,0x00,0x00,0x00,0x10,0x12,0x4a,0x92,0x24,0xe1,
+ 0x00,0x00,0x00,0x00,0x00,0x10,0x92,0x24,0x21,0x40,0x05,0xf8,0x00,0x00,0x20,
+ 0x48,0x0a,0x55,0x80,0x00,0x00,0x00,0x00,0x00,0xa5,0x48,0x21,0x49,0x92,0xe4,
+ 0x00,0x00,0x00,0x20,0x22,0x41,0x00,0x00,0x00,0x08,0x10,0xf8,0x00,0x00,0x00,
+ 0x02,0x20,0x00,0x20,0x14,0x00,0x00,0x00,0x40,0x12,0xa5,0x94,0x24,0xa9,0xf2,
+ 0x00,0x20,0x44,0x02,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0xfd,0x00,0x00,0x90,
+ 0x50,0x85,0x24,0x80,0x42,0x00,0x00,0x00,0x20,0xa4,0x10,0x4a,0xaa,0x24,0xe9,
+ 0x00,0x01,0x00,0x00,0x00,0x00,0x20,0x92,0x24,0x40,0x48,0xfc,0x00,0x00,0x04,
+ 0x04,0x20,0x08,0x00,0x10,0x02,0x00,0x00,0x4a,0x49,0x4a,0x21,0x91,0x92,0xe4,
+ 0x08,0x00,0x00,0x00,0x88,0x88,0x04,0x00,0x80,0x08,0x01,0xfc,0x00,0x00,0x50,
+ 0x11,0x89,0x12,0x00,0x48,0x09,0x00,0x80,0x24,0x12,0xa5,0x94,0x4a,0x4a,0xe0,
+ 0x00,0x80,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x02,0x28,0x79,0x00,0x00,0x00,
+ 0x00,0x20,0x00,0x00,0x20,0x20,0x00,0x50,0x92,0xa4,0x10,0x52,0x24,0x29,0xe0,
+ 0x00,0x04,0x10,0x01,0x00,0x00,0x90,0x24,0x09,0x20,0x02,0x04,0x00,0x00,0x4a,
+ 0x02,0x08,0x09,0x00,0x80,0x8a,0x00,0x00,0x49,0x01,0xca,0x8a,0xaa,0x0a,0xe0,
+ 0x20,0x00,0x00,0x00,0x88,0x24,0x01,0x00,0x40,0x00,0x50,0x00,0x00,0x80,0x00,
+ 0x00,0x40,0x04,0x00,0x40,0x50,0x0a,0xaa,0x24,0x00,0x28,0x51,0x22,0x09,0xe0,
+ 0x00,0x00,0x02,0x08,0x01,0x00,0x04,0x10,0x00,0x94,0x04,0x01,0x00,0x00,0xa4,
+ 0x00,0x00,0x01,0x00,0x00,0x05,0x41,0x11,0x12,0x00,0x80,0x4a,0x95,0x02,0xe0,
+ 0x02,0x21,0x40,0x20,0x00,0x00,0x40,0x02,0x25,0x01,0xa0,0x08,0x00,0x80,0x08,
+ 0x00,0x00,0x00,0x00,0x00,0x52,0x2a,0xa4,0x04,0x00,0x00,0x2a,0x52,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x48,0x22,0x08,0x40,0x00,0x40,0x44,0x22,0x00,0x20,0x10,
+ 0x00,0x00,0x00,0x00,0x00,0x08,0x91,0x12,0x01,0x00,0x00,0xa0,0x29,0x00,0xe0,
+ 0x08,0x04,0xfc,0x7b,0x00,0xbc,0xc0,0x0b,0xe0,0x0b,0x11,0xbd,0x00,0xb8,0x02,
+ 0x08,0xc0,0x00,0x70,0x00,0x57,0xca,0x4f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x20,0x40,0xff,0x7f,0xe2,0x3f,0xf8,0x2f,0xfa,0x0f,0xe0,0x3f,0xe2,0x3f,0x00,
+ 0x0f,0xe0,0xc1,0x7f,0xe0,0x3f,0xf1,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xc0,0x0f,0x3e,0xf0,0x7f,0xfc,0x8f,0xfc,0x2f,0xf9,0x3f,0xf0,0xbf,0x82,
+ 0x0f,0xe0,0xc3,0x7f,0xf8,0x9f,0xfc,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xf0,0x03,0xbe,0x40,0x3f,0x9e,0x1f,0x9f,0x0f,0x00,0x1f,0x09,0x3f,0x80,
+ 0x0f,0xe0,0x03,0x3e,0x1c,0x5f,0x1e,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x80,0xf8,0x11,0x3e,0x04,0x1f,0x07,0x8f,0x83,0x5f,0x52,0x5f,0x40,0x1f,0x80,
+ 0x0f,0xe0,0x03,0x3e,0x06,0x1e,0x07,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x04,0x7a,0x00,0x3e,0x00,0x9f,0x03,0x9f,0x01,0x0f,0x00,0x9f,0x00,0x1f,0x80,
+ 0x07,0xe0,0x01,0x3c,0x03,0x1e,0x03,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x10,0x7c,0x00,0x9f,0x10,0xdf,0x41,0xef,0xa8,0x2f,0xa5,0x1f,0x00,0x1f,0xc0,
+ 0x07,0xe0,0x03,0xbe,0x01,0x9e,0x01,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x3f,0x24,0x1f,0x02,0xef,0x90,0xef,0x82,0x0f,0x80,0x4f,0x01,0x0f,0xc0,
+ 0x07,0xe0,0x01,0x9e,0x01,0xde,0x00,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x9f,0x00,0x1f,0x88,0x6f,0x82,0x37,0x90,0xaf,0x94,0x3f,0x80,0x0f,0xc0,
+ 0x07,0xe0,0x01,0xde,0x00,0x6f,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x82,0x1f,0x80,0x1f,0x80,0x3f,0x88,0x3f,0xc2,0x0f,0xc0,0xbf,0x80,0x0f,0xe0,
+ 0x7f,0xe0,0x06,0x7f,0x00,0x6f,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x90,0x0f,0x88,0x0f,0xa1,0x3f,0xa0,0x5f,0xc8,0x87,0x92,0xff,0x80,0x0f,0xf0,
+ 0x1f,0xfa,0x05,0x2f,0x00,0x3f,0x80,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xc0,0x2f,0xc1,0x4f,0x84,0x1f,0xc2,0x1f,0xc1,0x27,0xc0,0xc7,0x85,0x3f,0xf8,
+ 0xe3,0xff,0x14,0x3f,0x00,0x1f,0x80,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xc0,0x07,0xc0,0x0f,0xc0,0x9f,0xc0,0x0f,0xe8,0x17,0xd5,0xff,0xdf,0x3f,0xf8,
+ 0x5b,0x77,0xfd,0x1f,0x80,0x1f,0x80,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe4,0x07,0xe4,0x2f,0xc8,0x0f,0xc8,0x8f,0xe2,0x83,0xe0,0x3b,0xfe,0xb7,0xf8,
+ 0x03,0x78,0xcc,0x1f,0x80,0x0f,0xc0,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x97,0xe0,0x07,0xc1,0x4f,0xe2,0x27,0xe8,0x27,0xe4,0xdf,0xf5,0xef,0xff,
+ 0xa3,0x7a,0xbb,0xff,0x80,0x0f,0xc0,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x03,0xf2,0x07,0xd0,0x07,0xe0,0x07,0xf1,0xa9,0xff,0xff,0xe7,0xcf,0xff,
+ 0x41,0xf8,0xd1,0x0f,0xc6,0x07,0xc0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe4,0x23,0xf0,0x57,0xe2,0x27,0xe5,0x23,0xf2,0xff,0xff,0xf7,0xe1,0x9f,0xfe,
+ 0x81,0x1e,0xf2,0xbf,0xdd,0x07,0xe0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x83,0xd8,0x07,0xe0,0x03,0xe0,0x8b,0xf0,0xb7,0xe0,0xfb,0xe3,0x37,0xfe,
+ 0x01,0x0d,0xe1,0xff,0xff,0x07,0xe0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x03,0xec,0x93,0xe4,0x93,0xf2,0x23,0xfd,0x49,0xf2,0x41,0xef,0xeb,0xfe,
+ 0x81,0x8e,0xe2,0x37,0xff,0x0f,0xe0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe9,0x23,0xee,0xc3,0xf0,0x0b,0xf0,0x09,0xfc,0x3a,0xf1,0x69,0xed,0x43,0xfe,
+ 0x01,0x87,0xc0,0x17,0xe0,0x3f,0xe0,0x61,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x09,0xe7,0x63,0xf2,0xa1,0xf4,0xa1,0xfe,0xb9,0xf4,0x39,0xfa,0x87,0xf3,
+ 0x03,0x03,0xe0,0x33,0xe0,0x7b,0xf0,0x21,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe2,0x23,0xf3,0xf3,0xf0,0x05,0xf0,0x0a,0xfd,0x18,0xfa,0x3b,0xf4,0x81,0xf5,
+ 0x87,0x03,0xe1,0x23,0xe0,0xe1,0xf0,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe8,0xc3,0xf3,0x39,0xf0,0x91,0xfa,0x81,0x7c,0x4c,0xf9,0x18,0xf0,0xcb,0xf5,
+ 0xc7,0x04,0xe0,0x33,0xf0,0x41,0xf0,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0xe7,0xf0,0x39,0xfa,0x02,0xf8,0x54,0x7e,0x2f,0xfa,0x1e,0xf0,0xf3,0xf0,
+ 0x7f,0x00,0xe2,0x27,0xf0,0x41,0xf8,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xe0,0x7f,0xf2,0x8f,0xf8,0x50,0xfa,0x00,0xff,0x87,0xf8,0xef,0xef,0x7f,0xf0,
+ 0x3f,0x00,0xf0,0x67,0xf0,0x60,0xf0,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xc9,0x3f,0xf0,0x0f,0xf8,0x85,0xf8,0xaa,0xfe,0x43,0xff,0xff,0xfe,0x1f,0xe0,
+ 0x3f,0x00,0xf0,0x4f,0xf0,0xe0,0xf0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x20,0x4f,0xc2,0x23,0x59,0x10,0x3c,0x20,0xfc,0xe0,0xff,0x01,0xc1,0x97,0xc2,
+ 0x77,0x00,0x70,0xd6,0x20,0xc0,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x02,0x00,0x10,0x40,0x00,0x44,0x81,0x4a,0x47,0xf2,0x57,0x95,0xb6,0x2e,0x08,
+ 0xc0,0x00,0x00,0xcc,0x0b,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x90,0x10,0x85,0x08,0x55,0x11,0x24,0x10,0x9e,0xe8,0xad,0xff,0xff,0xff,0x0a,
+ 0xd2,0x20,0x00,0xb8,0x2f,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x42,0x20,0x22,0x00,0x44,0x09,0x45,0x27,0xc2,0xfe,0xff,0xff,0xdf,0x10,
+ 0x80,0x01,0x28,0xd8,0x7a,0xc0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x4a,0x08,0x89,0x88,0x4a,0x11,0xa0,0x24,0x97,0xf0,0xff,0xff,0xff,0xbf,0x41,
+ 0x40,0xa3,0x90,0xb0,0x72,0xc0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x21,0x00,0x20,0x10,0x84,0x0a,0x92,0x26,0xb5,0xff,0xff,0xf7,0xff,0x03,
+ 0x05,0x46,0x40,0xe0,0x7b,0x80,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x24,0x04,0xaa,0x0a,0x42,0x51,0xa0,0x08,0x43,0xd2,0xfe,0xff,0xdd,0xfe,0x05,
+ 0x50,0x85,0x72,0xb2,0x76,0xc0,0x01,0x00,0x00,0x80,0xbd,0x00,0x00,0x00,0xe0,
+ 0x80,0xa0,0x00,0x40,0x11,0x04,0x15,0x52,0x17,0xb9,0x7e,0xbf,0xf6,0xfd,0x8f,
+ 0x02,0x0a,0xc5,0x60,0x7f,0x80,0x03,0x00,0x00,0x60,0x61,0x00,0x00,0x00,0xe0,
+ 0x12,0x08,0x24,0x29,0x44,0xa2,0x40,0x81,0x43,0xd2,0xff,0x55,0x95,0xd6,0x17,
+ 0x10,0x18,0x73,0xc1,0x7d,0x80,0x01,0x00,0x00,0x10,0x60,0x00,0x00,0x00,0xe0,
+ 0x84,0x22,0x41,0x84,0x12,0x11,0x2a,0x54,0x17,0xa9,0xf7,0x57,0x49,0x51,0x6f,
+ 0x20,0x1a,0xec,0x8d,0xef,0xc0,0x03,0x00,0x00,0x04,0xc1,0x01,0x00,0x00,0xe0,
+ 0x20,0x44,0x14,0x21,0xa0,0x48,0x41,0x89,0x4b,0xd9,0xff,0x5f,0x20,0x84,0xbe,
+ 0x80,0x30,0xb4,0x15,0x7d,0x80,0x01,0x00,0x00,0x41,0x84,0x01,0x00,0x00,0xe0,
+ 0x89,0x10,0x41,0x94,0x0a,0x25,0x94,0xa4,0x83,0xd8,0xff,0x3f,0x01,0x00,0xbd,
+ 0x41,0x70,0x58,0x33,0x6f,0x80,0x03,0x00,0x40,0x10,0x00,0x02,0x00,0x00,0xe0,
+ 0x02,0x42,0x14,0x49,0x52,0x90,0x22,0x92,0x4b,0xc8,0xde,0x7f,0x00,0x40,0xf6,
+ 0x02,0xe2,0xe8,0x57,0xea,0x80,0x01,0x00,0x20,0x8e,0x00,0x02,0x00,0x00,0xf8,
+ 0xa8,0x08,0x81,0x24,0x89,0x4a,0x94,0xa4,0x93,0xec,0xeb,0xff,0x00,0x00,0xdd,
+ 0x4f,0xd4,0xe0,0x26,0x2e,0x80,0x03,0x00,0x90,0x47,0x05,0x04,0x80,0x00,0xfe,
+ 0x01,0x42,0x28,0x92,0x24,0x91,0x4a,0xc9,0x41,0xa4,0xf5,0xff,0x87,0xb4,0xd6,
+ 0x0b,0xc8,0x43,0xaf,0x7c,0x80,0x01,0x00,0xc8,0xe0,0x03,0x00,0xfe,0x83,0xe6,
+ 0x94,0x10,0x85,0x48,0x92,0x24,0x21,0xa4,0x93,0xec,0xf9,0xff,0x2b,0x4a,0x5d,
+ 0x1f,0x91,0x87,0x4b,0xfa,0x80,0x03,0x00,0x7e,0xaa,0x4f,0x10,0x0f,0x56,0xfb,
+ 0x20,0x4a,0x20,0x25,0x55,0x92,0x94,0xca,0x4b,0xe4,0xd4,0xfe,0x9f,0xaa,0x5c,
+ 0x3f,0x24,0x8f,0xae,0x70,0x80,0x03,0x00,0x0f,0xdf,0x2c,0xd0,0x03,0xfa,0xfd,
+ 0x89,0x20,0x95,0x50,0x91,0x4a,0x4a,0xd1,0xad,0xf6,0xba,0xff,0xbf,0x52,0x7b,
+ 0x6f,0xa0,0x0e,0x56,0x68,0x80,0x01,0x80,0xc3,0x0b,0x70,0x61,0xc1,0x6f,0xef,
+ 0x22,0x0a,0x22,0x25,0x4a,0x24,0x25,0xca,0x49,0x6c,0xc9,0xfe,0xff,0xa5,0xbc,
+ 0xff,0x80,0x1e,0xbd,0x40,0x80,0x03,0xc0,0xf4,0x02,0xc0,0x86,0xbf,0xba,0xfd,
+ 0x08,0xa1,0x88,0x48,0xa5,0xaa,0x50,0xd1,0xa2,0xd4,0xac,0xff,0xe3,0x8b,0x7a,
+ 0xef,0x47,0x3b,0xb4,0x44,0x80,0x03,0xe0,0x7a,0x00,0x80,0x07,0xbe,0x5e,0xf7,
+ 0xa2,0x14,0x25,0x95,0x28,0x91,0x8a,0xe4,0x1d,0x6e,0x54,0xff,0x49,0x77,0xbd,
+ 0xd7,0x05,0x7d,0xb8,0x80,0x00,0x03,0x38,0x0f,0x00,0x00,0x2f,0xdb,0xf7,0xe3,
+ 0x08,0x48,0x52,0x42,0x92,0x4a,0x2a,0xd5,0x4f,0x6a,0xc5,0xff,0x03,0xfd,0xfa,
+ 0x53,0x4b,0x6b,0x60,0x92,0x80,0x03,0xd8,0x03,0x00,0x80,0x9b,0xf4,0x7d,0xe0,
+ 0xa2,0x52,0x09,0xa9,0x4a,0x24,0x51,0xe2,0x5b,0xea,0x94,0xfe,0x07,0xfc,0xff,
+ 0x2b,0x1e,0xec,0x61,0x09,0x81,0x03,0xee,0x00,0x00,0xc0,0x7e,0xea,0x0f,0xe0,
+ 0x10,0x89,0x64,0x4a,0xa4,0xaa,0x24,0xd5,0xad,0x66,0x42,0xff,0x05,0xdc,0xfd,
+ 0xeb,0x17,0xad,0x41,0x29,0x02,0x17,0x3f,0x00,0x00,0x60,0xed,0xa0,0x01,0xf8,
+ 0x4a,0x52,0x12,0x91,0x52,0x22,0x95,0xd0,0x5f,0xea,0x04,0xff,0x03,0x9c,0xfe,
+ 0x7f,0x30,0xb0,0xc6,0x11,0x84,0xff,0x0f,0x00,0x00,0x90,0xff,0x43,0xf0,0xff,
+ 0x81,0x88,0xaa,0x4a,0x29,0x95,0xa2,0xea,0x3b,0x6b,0x02,0xf6,0x03,0xf8,0x7b,
+ 0xff,0x60,0x88,0x86,0x46,0x08,0xd7,0x01,0x00,0x00,0x8c,0xfa,0x0b,0xec,0xfe,
+ 0x54,0x52,0x44,0x24,0x8a,0x48,0x28,0xe5,0x5e,0x74,0x8a,0xfc,0x07,0xf0,0xff,
+ 0x7e,0x80,0x40,0x0a,0xa3,0x98,0xe7,0x01,0x00,0x00,0xc4,0x2e,0x80,0x82,0xf7,
+ 0x09,0x89,0xaa,0x92,0xa4,0x52,0x95,0xd2,0x2f,0x6a,0x01,0xeb,0x0f,0xe0,0xff,
+ 0xbb,0x85,0x01,0x1a,0x0c,0xb1,0x76,0x01,0x00,0x00,0x62,0x0f,0x20,0x00,0xf6,
+ 0xa2,0x54,0x11,0xa9,0x52,0x8a,0x4a,0x68,0x1f,0x76,0x85,0xb6,0x1f,0x50,0xad,
+ 0xc2,0x12,0x93,0x18,0x0a,0xa3,0xb7,0x1f,0x00,0x00,0xa3,0x03,0x00,0x00,0xe8,
+ 0x14,0x22,0xaa,0x14,0x29,0x51,0xa4,0xf6,0x0e,0x74,0x04,0x6e,0x6b,0xd2,0x00,
+ 0xe8,0x4a,0x07,0x30,0x88,0xc6,0xde,0x7f,0x01,0x80,0xe9,0x00,0x00,0x00,0xf8,
+ 0xa1,0x54,0x49,0xa2,0x84,0x4a,0x29,0xe9,0x1f,0x6b,0x83,0xfe,0xfe,0x3b,0x00,
+ 0xc0,0xa7,0x07,0x70,0x00,0xce,0xff,0xef,0xff,0x2b,0x38,0x00,0x00,0x00,0xe0,
+ 0x14,0x49,0x25,0x15,0x55,0x29,0xa5,0xe4,0x2b,0x36,0x0a,0xfe,0xdf,0x3f,0x00,
+ 0x00,0xaf,0x1e,0xe0,0x28,0x1c,0xfe,0xfd,0x0a,0x00,0x1c,0x00,0x00,0x00,0xe0,
+ 0xc9,0xa4,0xaa,0xa2,0x52,0x94,0x52,0xf5,0x1f,0x76,0x85,0xfa,0xff,0x17,0x00,
+ 0x00,0xbe,0x1a,0xe0,0x01,0x38,0xbc,0xfa,0xaf,0x26,0x07,0x00,0x00,0x00,0xe0,
+ 0x24,0x52,0x94,0x54,0x24,0x65,0x49,0x6a,0x37,0x36,0x06,0xfa,0xff,0x2a,0x10,
+ 0x80,0xfc,0x3a,0xc0,0x03,0x60,0x3c,0x5c,0xff,0x15,0x03,0x00,0x00,0x00,0xe0,
+ 0x92,0x8a,0x52,0x8a,0x92,0xf2,0xaa,0xf2,0x1f,0x76,0xab,0xd5,0xff,0x16,0x44,
+ 0x00,0xe8,0x7d,0xa0,0x87,0xe0,0x1a,0xa0,0x08,0xe0,0x00,0x00,0x00,0x00,0xe0,
+ 0x49,0xa9,0x4a,0x51,0xa9,0xbc,0x49,0x6a,0x0f,0x37,0x07,0xed,0x7f,0x2b,0x21,
+ 0x00,0xd1,0xff,0x80,0x07,0xc0,0x3d,0x00,0x15,0x30,0x00,0x00,0x00,0x00,0xe0,
+ 0x24,0x54,0x29,0x4d,0x4a,0x3d,0x2b,0x75,0x37,0x76,0xab,0x54,0xad,0x54,0xfc,
+ 0x02,0x64,0xed,0x01,0x0f,0xa0,0x2b,0x00,0x60,0x19,0x00,0x00,0x00,0x00,0xe0,
+ 0x80,0x22,0xa5,0x24,0xa5,0x66,0xa5,0xf2,0x2f,0x76,0x4b,0xd5,0xb7,0xaa,0xff,
+ 0x07,0xa0,0xeb,0x83,0x1e,0x60,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xaa,0xaa,0x52,0x29,0xe7,0x56,0xf5,0x5e,0x37,0x2f,0xb5,0x94,0xda,0xc1,
+ 0x1f,0x48,0x95,0x07,0x3c,0x00,0x7f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x40,0x58,0x95,0xaa,0xd4,0xd3,0x2b,0xf5,0x5b,0x72,0x4f,0x55,0xab,0xfe,0x00,
+ 0x1c,0x20,0x55,0x0f,0x6c,0x80,0x1b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xb5,0xa7,0x54,0x55,0xa5,0x8b,0xa7,0xf4,0x29,0x3f,0x2f,0xb5,0x54,0xff,0x40,
+ 0x70,0xa0,0xaa,0x0e,0xdc,0x00,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x96,0x58,0xa5,0x2a,0xd5,0x8f,0x5f,0x75,0x34,0x73,0xbd,0xaa,0xd2,0xff,0x41,
+ 0xa0,0xa8,0x56,0x3d,0xb8,0x40,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xa9,0x4a,0x95,0xa4,0xea,0xf7,0x4a,0xf5,0xaa,0x76,0x57,0xab,0xfa,0xbf,0x7f,
+ 0xc1,0x51,0x55,0x3b,0x98,0xa1,0x1c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xa4,0xaa,0x6a,0x95,0xd2,0x7b,0x5e,0x75,0x24,0x33,0xbf,0xa9,0xfe,0x45,0x04,
+ 0xc6,0x53,0x55,0x7b,0x31,0x83,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x55,0x55,0x55,0x55,0xea,0x7e,0x5d,0xf5,0x12,0x77,0x5f,0x55,0xfd,0x7a,0x29,
+ 0x3c,0xaa,0xaa,0x74,0x32,0x86,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x92,0xaa,0xaa,0x55,0xe9,0xff,0x79,0xf5,0x54,0x73,0xbd,0x4a,0x75,0x95,0xaa,
+ 0x1a,0x56,0x49,0xf1,0x64,0x8c,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x55,0x4a,0x55,0x55,0xd5,0x7f,0xfe,0xda,0x92,0x77,0x6e,0xaa,0x9a,0xaa,0xaa,
+ 0xaa,0x3c,0x2d,0xe8,0xe3,0xc8,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x56,0x55,0x95,0xaa,0xea,0xff,0xfd,0x7a,0x48,0x6b,0xfb,0xaa,0x6a,0x55,0x55,
+ 0x55,0xda,0x5a,0xd2,0xc7,0x18,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0xf0,0xae,0x0a,0x55,0xb5,0x7f,0xf3,0xfd,0x2a,0x6f,0xfe,0x55,0x95,0xaa,0x4a,
+ 0xaa,0x7a,0xaa,0xd6,0xa7,0x31,0x3a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x40,0xa1,0x0a,0x2a,0xa9,0xfd,0xef,0x6f,0x48,0xa7,0xea,0xab,0x54,0xa5,0xf4,
+ 0x4b,0xd5,0x4a,0xa2,0x9f,0x61,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x80,0x82,0x0a,0xb5,0xaa,0xfe,0xca,0xff,0x25,0xbf,0xf6,0x97,0xaa,0x54,0xff,
+ 0x5f,0x55,0x25,0xd0,0x5f,0x83,0x1d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x80,0x42,0x15,0x4a,0x55,0xff,0x9f,0x7f,0x4a,0xef,0xd4,0x7d,0xa5,0xca,0xff,
+ 0x55,0xa9,0x12,0x50,0x3f,0xc7,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x40,0x45,0x15,0xaa,0xaa,0xfe,0x57,0xff,0x24,0xb7,0xde,0xff,0x5b,0xf5,0x7e,
+ 0xab,0xaa,0x0a,0xa8,0xff,0x86,0x7e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x80,0x82,0x2a,0x55,0x49,0xfd,0x7f,0xfe,0x89,0xee,0xa9,0xf7,0x7f,0x55,0xeb,
+ 0x57,0x92,0x40,0xd2,0x6e,0x0d,0x7f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x85,0x2a,0x56,0x55,0xfd,0xff,0x7d,0x52,0xaf,0xd9,0xda,0xb6,0xab,0xd5,
+ 0x5a,0x49,0x62,0x48,0xff,0x1a,0x7d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x8a,0x2a,0xaa,0xaa,0xee,0xbf,0xf2,0xa1,0xee,0x55,0xb7,0x6a,0x75,0x6d,
+ 0xad,0xa8,0x86,0xd6,0xef,0x1b,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x8a,0x2a,0xab,0xaa,0xfe,0xfd,0xef,0x88,0xee,0xa9,0x5a,0x95,0x96,0xb5,
+ 0x55,0xab,0x2a,0x55,0xef,0x37,0xbd,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x16,0xd5,0xaa,0xaa,0xe6,0xfb,0xf5,0x52,0xee,0x43,0xa9,0x54,0x54,0x4a,
+ 0xb6,0xed,0xaa,0xa8,0xef,0x3e,0xfd,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x14,0x55,0xad,0xaa,0xe6,0xf6,0xdf,0xa8,0xce,0x1f,0x50,0x52,0xab,0xaa,
+ 0xaa,0x2a,0x55,0x85,0xaf,0xec,0xfe,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x28,0xaa,0x55,0x55,0xe7,0xde,0xff,0x45,0xfe,0x3d,0x00,0x88,0x54,0x55,
+ 0x95,0xa4,0x55,0xf8,0xc5,0x78,0xbe,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x28,0xd5,0xb6,0xaa,0x73,0x7f,0xff,0x29,0xdd,0xe7,0x15,0x00,0xaa,0x92,
+ 0x44,0x90,0xa4,0xff,0x6e,0xe8,0xfe,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x58,0x6d,0xd5,0x56,0xa3,0xfd,0xfd,0x95,0x9c,0x1e,0xbf,0xab,0x40,0x20,
+ 0x91,0x4a,0xfd,0xef,0x87,0xe0,0xff,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xa0,0xaa,0xab,0x6a,0xf3,0xfe,0xff,0x49,0x7e,0xf2,0xff,0x5f,0x5f,0xaf,
+ 0xfe,0xff,0x17,0xf8,0x57,0x32,0x77,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xd0,0x56,0xad,0xaa,0xb3,0xbf,0xff,0xa5,0x7a,0x14,0xed,0xfd,0xeb,0xf7,
+ 0x95,0x68,0xe9,0xff,0xc7,0x64,0xb7,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x60,0xdb,0x55,0x5f,0xf3,0x1f,0xff,0x2b,0xfd,0xbb,0xa2,0xee,0xfe,0xd5,
+ 0x43,0xf6,0xaf,0x92,0x6a,0x80,0xf6,0x1b,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x80,0x6a,0xb5,0xf7,0xb9,0x0f,0xbe,0x93,0xf4,0x7f,0x2d,0x20,0x83,0xee,
+ 0xfe,0x15,0x00,0x48,0x6a,0x00,0xe7,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x60,0xab,0xd6,0xd0,0xf3,0x07,0xfe,0x49,0x65,0xff,0x5f,0xbd,0x10,0x00,
+ 0x00,0x48,0xa2,0x92,0x32,0x00,0xc6,0x37,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x80,0xb6,0xea,0x00,0xf9,0x0b,0xfe,0x25,0xb1,0xe0,0xff,0xff,0xff,0x07,
+ 0x92,0x02,0x08,0x24,0x3d,0x00,0x42,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x80,0xae,0x35,0x80,0xf8,0x0b,0xb7,0x91,0x72,0x05,0x40,0xff,0xff,0xff,
+ 0xff,0xff,0xaa,0xdb,0x1f,0x30,0x02,0x7f,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xab,0xb6,0x80,0xe8,0x07,0xde,0xab,0xa8,0x94,0x02,0x00,0xea,0xd4,
+ 0xde,0xff,0xff,0xff,0x12,0x00,0x02,0x7d,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xbd,0xba,0x80,0xbc,0x4b,0xb5,0x0e,0x72,0x6e,0x12,0x00,0x00,0xf5,
+ 0xb7,0x6f,0x00,0x00,0x00,0x00,0x03,0x5c,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xcb,0x2a,0x81,0xec,0x07,0x7b,0x7f,0x61,0xef,0x4b,0x1c,0x00,0x00,
+ 0xfd,0x5f,0x00,0x00,0x12,0x00,0x01,0xf9,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x7d,0x75,0x40,0xb4,0x82,0xad,0xfd,0xb0,0xef,0x77,0x0c,0x00,0x00,
+ 0x78,0x2b,0x40,0x00,0x10,0x00,0x03,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x95,0x6d,0x43,0xec,0x85,0xd9,0xf6,0xff,0xbf,0xbf,0x2f,0x00,0x00,
+ 0xed,0x76,0x10,0x05,0x14,0x00,0x03,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xc0,0x76,0xf5,0x4a,0xd4,0xd3,0x7d,0xdb,0xff,0x68,0xdf,0x1f,0x00,0x00,
+ 0xc0,0x25,0x00,0x00,0x0a,0x80,0x03,0xf0,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x40,0xab,0xfd,0x65,0xe6,0xc1,0xac,0xf6,0xff,0x23,0x75,0xaf,0x00,0x00,
+ 0xd0,0x1a,0x00,0x00,0x14,0xa0,0x03,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0xc0,0x7a,0xaf,0x25,0xd5,0xc2,0xde,0xfb,0xfb,0x7f,0x08,0x18,0x00,0x00,
+ 0x08,0x01,0x00,0x00,0x0c,0xdd,0x03,0xc0,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xed,0xa3,0x6b,0x72,0x69,0x6d,0xfd,0xaf,0xff,0x17,0x42,0x02,0x00,
+ 0x00,0x11,0x00,0x00,0x8e,0xff,0x07,0xc0,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x80,0x7b,0xdd,0x36,0xeb,0x61,0xb7,0xfe,0xaf,0xfe,0xff,0x2d,0x09,0x00,
+ 0x00,0x44,0x00,0xd0,0xff,0xbf,0x03,0x40,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x3e,0x4f,0x2b,0x77,0xf1,0xde,0xdf,0x7d,0xff,0xfa,0xff,0xff,0x7f,
+ 0x05,0x30,0xa5,0x6b,0xfb,0xff,0x03,0x80,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x1d,0x23,0x3c,0xff,0x30,0xb7,0xa6,0xf7,0xf5,0xdf,0xde,0x4a,0x80,
+ 0x50,0xd2,0xba,0xbc,0xff,0x4b,0x03,0xc0,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xce,0x05,0x38,0xb7,0xf0,0xdb,0x47,0x5e,0x6f,0xff,0x7f,0x92,0x2a,
+ 0x0a,0x49,0xd5,0xd6,0xfd,0xa6,0x03,0x80,0x03,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xae,0x01,0xb0,0xff,0x98,0xb7,0x23,0xf0,0xbd,0xd4,0xff,0xff,0xff,
+ 0xfb,0xb5,0xb7,0x7f,0x3c,0x52,0x03,0x80,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xd6,0x01,0x10,0x5f,0xf8,0xfa,0x07,0x80,0x6b,0x42,0xfe,0xff,0xff,
+ 0xaf,0xfe,0xff,0x0b,0x5c,0xa3,0x03,0x80,0x03,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x6c,0x00,0x30,0xbf,0xd8,0xef,0x09,0x00,0xfe,0x09,0xff,0xff,0xff,
+ 0xff,0xff,0xff,0x02,0x86,0x12,0x03,0x80,0x03,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x64,0x00,0xb0,0x6f,0xec,0xfa,0x34,0x00,0xe8,0x07,0xe0,0xff,0xae,
+ 0xfa,0xff,0x2e,0x01,0x17,0xc9,0x03,0x00,0x03,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x64,0x00,0x10,0x7f,0x7c,0xef,0xd0,0x01,0x80,0x0e,0x00,0xff,0xff,
+ 0x00,0x0e,0xbf,0x80,0x83,0x92,0x01,0x00,0x03,0xc0,0x01,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x34,0x00,0xb0,0x2f,0xf6,0x7a,0x2e,0x07,0x00,0x3d,0x00,0x7c,0xb5,
+ 0x07,0x17,0x05,0xe0,0x81,0xc2,0x01,0x00,0x1f,0x00,0x07,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x98,0x00,0x38,0x3f,0xbe,0x6f,0x5f,0x1d,0x00,0xf0,0x00,0xf0,0xcb,
+ 0xbd,0xc1,0x02,0xe0,0x90,0x52,0x01,0x80,0x7f,0x00,0x38,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x14,0x00,0x34,0x2f,0xfe,0x7a,0xbe,0xf4,0x00,0xc0,0x07,0x80,0x5f,
+ 0xd6,0x43,0x00,0x38,0x00,0xc1,0x01,0xf4,0xef,0x00,0xe0,0x01,0x00,0x00,0xe0,
+ 0x00,0x00,0x5a,0x00,0x9b,0x27,0x5f,0x7f,0xf7,0x8a,0x02,0x00,0x1e,0x00,0xfa,
+ 0xa9,0x23,0x00,0x34,0x48,0xb1,0x00,0xff,0x0f,0x03,0x20,0x0e,0x00,0x00,0xe0,
+ 0x00,0x00,0x08,0x48,0xbe,0x9a,0xee,0xf5,0xce,0xa9,0x0e,0x00,0x78,0x00,0x70,
+ 0x2f,0x1b,0x00,0x1a,0x40,0xa9,0x02,0xbd,0x0f,0x04,0x20,0x70,0x00,0x00,0xe0,
+ 0x00,0x00,0x2a,0xfa,0xbf,0x0f,0x73,0xfb,0xd6,0x4c,0x32,0x00,0xe0,0x01,0x80,
+ 0x55,0x0b,0x00,0x0c,0x88,0x60,0x80,0x8f,0x6f,0x08,0x20,0x80,0x03,0x00,0xe0,
+ 0x00,0x00,0x14,0x20,0xbf,0x2b,0xbb,0xef,0xde,0x77,0xd9,0x01,0x00,0x07,0x00,
+ 0x5a,0x07,0x80,0x06,0xa0,0xb4,0x80,0x03,0x1e,0x10,0x20,0x80,0x1f,0x00,0xe0,
+ 0x00,0x00,0x52,0x00,0xd8,0xaf,0xe1,0xfa,0x70,0xbf,0xaa,0x07,0x00,0x7c,0x00,
+ 0x00,0x01,0x20,0x03,0x80,0x90,0x80,0x09,0x00,0x60,0x20,0xf0,0x7f,0x00,0xe0,
+ 0x00,0x00,0x4a,0x00,0xf0,0xd7,0xa1,0xef,0xd4,0xf7,0xa5,0x1e,0x00,0xe0,0x05,
+ 0x00,0x00,0x80,0x02,0xc0,0x34,0x81,0x05,0x00,0x60,0x20,0xfe,0x7f,0x00,0xe0,
+ 0x00,0x00,0xaa,0x00,0xe0,0xcb,0x40,0xfb,0x93,0xff,0x17,0xf1,0x00,0x80,0x3f,
+ 0x00,0x00,0x80,0x01,0x50,0x4a,0x00,0x57,0x00,0x30,0xe0,0xff,0x1f,0x00,0xe0,
+ 0x00,0x00,0xd8,0x02,0xe0,0xc7,0x80,0xfe,0xcb,0xec,0xbb,0xc4,0x03,0x00,0x14,
+ 0x00,0x00,0xc8,0x00,0x40,0x5a,0x01,0xfd,0x01,0x1e,0xf8,0xff,0x03,0x00,0xe0,
+ 0x00,0x00,0x3a,0x03,0xe0,0x4b,0x00,0xec,0x5f,0xdc,0xce,0xc1,0x1f,0x00,0xd0,
+ 0x00,0x00,0x20,0x00,0x20,0x6a,0x00,0xfe,0x04,0x3d,0xff,0x7f,0x00,0x00,0xe0,
+ 0x00,0x00,0xf2,0x15,0xf0,0xa3,0x00,0xfc,0x3f,0xa5,0xff,0x84,0x77,0x00,0x00,
+ 0x0d,0x00,0x00,0x00,0x40,0x24,0x80,0xff,0x92,0xee,0xff,0x0f,0x00,0x00,0xe0,
+ 0x00,0x00,0xd4,0x57,0xf4,0x47,0x00,0xfc,0xfd,0xca,0xfb,0xde,0xdd,0x03,0x00,
+ 0x60,0x00,0x0c,0x00,0x10,0x35,0xc0,0xd7,0xff,0xef,0xff,0x01,0x00,0x00,0xe0,
+ 0x00,0x00,0x94,0x5f,0xba,0x51,0x00,0xec,0xff,0xaf,0xfe,0xce,0x61,0x3d,0x00,
+ 0x00,0x03,0x0e,0x00,0x20,0x15,0xe0,0x00,0xff,0xe9,0x3f,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xb0,0x5e,0xfd,0x43,0x00,0xff,0xfb,0xbf,0xde,0xfa,0xc0,0xc3,0x00,
+ 0x00,0x28,0x06,0x00,0xa0,0x1a,0x30,0x02,0xf0,0xea,0x07,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x24,0x7d,0xfb,0x2b,0xe0,0xef,0xe9,0xfb,0xf2,0xd6,0x03,0x0a,0x06,
+ 0x00,0x80,0x03,0x00,0x90,0x0c,0x8c,0x01,0x00,0xe4,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x94,0x72,0xbc,0x31,0xf8,0xfd,0xe3,0x7f,0x95,0xfe,0x8f,0x40,0x38,
+ 0x00,0x00,0x03,0x00,0x90,0x0c,0x26,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0xbc,0xea,0xfe,0x12,0xfc,0xdb,0x13,0xdf,0xdf,0xb6,0x7f,0x00,0xc7,
+ 0x01,0x80,0x03,0x00,0x50,0x05,0x07,0x40,0x00,0x28,0x01,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0xe0,0x81,0xff,0x09,0x6f,0xff,0xcb,0x7a,0x37,0xbd,0xeb,0x05,0x14,
+ 0x0e,0xc0,0x06,0x00,0x48,0x06,0x16,0x48,0x00,0x20,0x01,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x17,0xff,0x89,0xff,0xed,0x25,0xf5,0xfb,0xca,0x4e,0x87,0x42,
+ 0x74,0x40,0x02,0x00,0x08,0x03,0x0e,0x64,0x00,0x00,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0xfc,0xf7,0xc4,0xaf,0xff,0x57,0xaa,0x77,0x57,0x3f,0x5d,0x08,
+ 0x04,0x20,0x06,0x00,0xa4,0x01,0x26,0x28,0x00,0xe8,0xff,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0xc0,0xfd,0xe4,0xfb,0xd6,0x27,0x51,0xfe,0xab,0xf9,0xe1,0xa5,
+ 0x04,0x02,0x04,0x00,0x40,0x03,0x16,0xb8,0x06,0xc0,0xaa,0xaa,0x7a,0x00,0xe0,
+ 0x00,0x00,0x00,0xc0,0xbf,0xe0,0xde,0xff,0x4f,0x95,0xfa,0xdf,0xfc,0x87,0x17,
+ 0x36,0x10,0x92,0x01,0xc2,0x01,0x5e,0xb8,0x01,0x00,0x00,0x00,0x7c,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0x1e,0xe0,0xf7,0xf6,0x3f,0x4a,0xed,0x7b,0xf9,0x7f,0xfc,
+ 0xf6,0x18,0x12,0x01,0x62,0x04,0x0d,0xf8,0x0e,0x00,0x04,0xc0,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0x3f,0xb1,0xbd,0xdf,0xff,0x29,0xda,0xef,0x62,0xfd,0x43,
+ 0x27,0x0b,0xc6,0x00,0x70,0x02,0x57,0x78,0x03,0x00,0x00,0xf8,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0xbe,0xea,0xef,0xfb,0xff,0xa3,0xaa,0xbf,0x9f,0xe8,0x9f,
+ 0x37,0x1a,0xc6,0x00,0x39,0x06,0x17,0xf8,0x01,0x00,0x84,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0x6f,0x79,0xfb,0x6e,0xff,0x0f,0xf5,0xfe,0x5d,0x91,0xfe,
+ 0x72,0x0b,0x4e,0x00,0x30,0x8c,0x0d,0xbc,0x00,0x00,0xf0,0xff,0x1f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x57,0xf0,0xbf,0xff,0xff,0x2f,0xfc,0xff,0xf7,0x48,0xfd,
+ 0xef,0x0e,0x22,0x00,0x1c,0xcc,0x06,0xdc,0x01,0x00,0xfe,0xff,0x03,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x37,0xb8,0xed,0x76,0xff,0xff,0xd4,0xfb,0xbf,0x25,0xfa,
+ 0x67,0x0a,0x6e,0x00,0x1c,0x5a,0x82,0xfe,0x01,0xe0,0xff,0x7f,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0x13,0xf8,0xff,0xff,0xff,0x7f,0xf9,0xbe,0xfd,0x57,0xdd,
+ 0x50,0x0d,0x34,0x00,0x0e,0x7c,0x08,0x7f,0x00,0xe0,0xff,0x07,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x33,0xb8,0x6d,0xff,0x51,0xff,0x47,0x6f,0xf4,0xaf,0xf8,
+ 0x8f,0x08,0x5a,0x00,0x2f,0x30,0x82,0xef,0x00,0xc0,0x7f,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x19,0xf0,0xff,0x7f,0x44,0xfd,0xaf,0xfd,0xeb,0x7e,0xa7,
+ 0x21,0x0d,0x6a,0x80,0x1b,0x70,0x48,0x97,0x01,0x00,0x7c,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x80,0x09,0x78,0xfb,0x1f,0x55,0xee,0xff,0xf6,0x50,0xf8,0x5b,
+ 0xac,0x08,0x06,0x80,0x39,0xe8,0xa4,0x1f,0x01,0x00,0xe3,0x03,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x0d,0xf8,0xff,0x43,0x29,0xf1,0xff,0xa3,0xd6,0xd3,0x5f,
+ 0x93,0x0c,0x12,0xc0,0x5a,0xe0,0xd4,0x03,0x02,0x00,0x07,0x1e,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x05,0xb8,0x7f,0x90,0x94,0xca,0xbf,0xdf,0x51,0xbf,0xfe,
+ 0x4d,0x08,0x0c,0xe0,0x34,0xc0,0xaa,0x01,0x00,0x00,0x03,0xf0,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x0f,0xf8,0x0f,0x00,0x42,0xa4,0xfb,0xba,0xaa,0x3f,0xfa,
+ 0x3f,0x0d,0x02,0x30,0x52,0x80,0xd3,0x09,0x00,0x80,0x02,0x80,0x0f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x2e,0xf2,0x1f,0x40,0x00,0x20,0xff,0xff,0xc5,0xfe,0xc4,
+ 0xff,0x09,0x24,0x50,0x75,0x80,0xff,0x02,0x00,0x08,0x01,0x00,0x78,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0xb8,0xd0,0x3b,0x00,0x09,0x49,0xbc,0xf7,0x97,0xfa,0x23,
+ 0xfe,0x0f,0x02,0xb8,0x50,0x80,0xfe,0x04,0x00,0xe8,0xfe,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xf8,0x3f,0x00,0x40,0x80,0xf2,0xff,0x9f,0xea,0x17,
+ 0xed,0x1e,0x00,0x0c,0x71,0x00,0xfe,0x00,0x00,0xed,0xff,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xf0,0x75,0x00,0x00,0x29,0xc9,0xff,0xfb,0xe4,0x5f,
+ 0xa9,0x1f,0x02,0xec,0x54,0x00,0xe5,0x0b,0x00,0xec,0xff,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xf0,0x7b,0x80,0x24,0xf4,0x24,0xc1,0xef,0xd3,0xff,
+ 0x2c,0x08,0x00,0x37,0x60,0x00,0xcc,0x45,0x80,0xef,0xff,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xf8,0xe8,0x00,0x00,0x01,0x93,0x54,0xbf,0x5f,0xed,
+ 0x5b,0x01,0x02,0x2f,0x74,0x00,0x98,0x17,0x54,0xe7,0xff,0xff,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xb0,0xe6,0x01,0x00,0x80,0x4c,0xaa,0xfa,0xbe,0xfa,
+ 0x49,0x08,0x80,0x1f,0x41,0x00,0x90,0x8b,0x52,0x23,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x78,0xda,0x01,0x40,0x00,0x22,0x55,0xff,0xef,0xe4,
+ 0x9b,0x08,0xc2,0x9f,0x28,0x00,0x20,0x23,0xad,0x21,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x98,0xaa,0x03,0x04,0x09,0x90,0xe9,0xff,0xbf,0xeb,
+ 0x57,0x00,0xe0,0x5e,0x64,0x00,0x24,0x4e,0xf5,0x21,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x5c,0xed,0x05,0x00,0x40,0x64,0x74,0xfb,0xff,0xef,
+ 0x1f,0x08,0xf2,0x2f,0x29,0x00,0x20,0xa8,0xfd,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x84,0xde,0x07,0x08,0x02,0xb5,0x07,0xff,0x5f,0xbd,
+ 0x56,0x08,0xf3,0x5f,0x44,0x00,0x40,0xf8,0x1f,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x56,0xfe,0x0b,0x40,0x48,0xda,0x80,0xff,0xff,0xfa,
+ 0xb7,0x80,0xfd,0x7d,0x23,0x00,0x40,0x60,0x02,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x2c,0xfd,0x35,0x00,0xa0,0x1f,0x00,0xff,0xea,0xd7,
+ 0x7f,0xc8,0xfd,0xbf,0x3a,0x00,0x90,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x88,0xee,0x92,0x00,0xd1,0x01,0x80,0x3b,0x5e,0xbf,
+ 0xfa,0xd1,0xde,0xef,0x0e,0x00,0x80,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xac,0xf6,0x6d,0x4a,0x7c,0x00,0xd0,0x0e,0xf4,0xfa,
+ 0x95,0xff,0xf7,0xff,0x07,0x00,0x00,0x01,0x00,0xe0,0xaa,0xaa,0x36,0xc0,0xe1,
+ 0x00,0x00,0x00,0x00,0x00,0x28,0xdf,0xea,0xa5,0x3f,0x00,0x40,0x07,0xa0,0xd7,
+ 0x6f,0xfa,0x7f,0xff,0x01,0x00,0x00,0x01,0x00,0xe0,0xff,0xff,0x7f,0x78,0xe1,
+ 0x00,0x00,0x00,0x00,0x00,0x90,0xfe,0x29,0x9b,0x07,0x00,0x48,0x01,0x80,0x6a,
+ 0xdd,0xeb,0xab,0x09,0x00,0x00,0x00,0x01,0x00,0xe0,0xff,0xff,0x7f,0xd8,0xe1,
+ 0x00,0x00,0x00,0x00,0x00,0x58,0xf7,0x42,0xa4,0x12,0x00,0xa2,0x00,0x00,0xbe,
+ 0xff,0xfd,0x55,0x00,0x00,0x00,0x00,0x02,0x00,0xe0,0xff,0xff,0x7f,0x68,0xe3,
+ 0x00,0x00,0x00,0x00,0x00,0x90,0xbb,0x00,0x00,0x0b,0x00,0x58,0x00,0x00,0xac,
+ 0xfa,0x67,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0xff,0xff,0x7f,0xf8,0xe2,
+ 0x00,0x00,0x00,0x00,0x00,0xa0,0x5a,0x00,0x80,0x01,0x80,0x14,0x00,0x00,0x54,
+ 0xed,0xbf,0x05,0x00,0x00,0x00,0x00,0x04,0x00,0x20,0x00,0x00,0x40,0xa0,0xe3,
+ 0x00,0x00,0x00,0x00,0x00,0x50,0x56,0x00,0xc0,0x04,0x00,0x07,0x00,0x00,0xe8,
+ 0xf6,0x67,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x40,0xf0,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x20,0x0f,0x01,0x60,0x00,0xc0,0x01,0x00,0x00,0x28,
+ 0xab,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xa0,0x8a,0x0d,0xb0,0x00,0xe0,0x00,0x00,0x00,0xd0,
+ 0xda,0x2f,0x08,0x00,0x00,0x00,0x00,0x08,0x00,0x20,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x40,0x15,0x00,0x30,0x00,0x38,0x00,0x00,0x00,0xa8,
+ 0x6a,0x1f,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xc0,0x42,0x00,0x58,0x00,0x0c,0x00,0x00,0x00,0x50,
+ 0xad,0x4f,0x01,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0xc0,0x0f,0x00,0x18,0x00,0x07,0x00,0x00,0x00,0x50,
+ 0x55,0x1f,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x7f,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x80,0x2b,0x00,0x0c,0x80,0x01,0x00,0x00,0x00,0xa0,
+ 0x6a,0x5f,0x00,0x00,0x00,0x40,0x00,0x30,0x00,0x00,0xfc,0xff,0x01,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0xbe,0x00,0x24,0x60,0x00,0x00,0x00,0x00,0xa0,
+ 0xaa,0x3e,0x08,0x10,0x00,0x00,0x00,0x20,0x00,0x00,0xfe,0xff,0x07,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0xac,0x00,0x0e,0x18,0x00,0x00,0x00,0x00,0x50,
+ 0x55,0x5f,0x00,0x02,0x80,0x10,0x01,0x68,0x00,0x00,0xff,0xff,0x0f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0xb8,0x00,0x02,0x0f,0x00,0x00,0x00,0x00,0x60,
+ 0x55,0x3d,0x01,0x00,0x00,0x22,0x04,0x45,0x00,0x80,0xff,0xff,0x1f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x00,0xeb,0x01,0x00,0x00,0x00,0x00,0x80,
+ 0xaa,0x36,0x80,0x00,0x00,0x04,0x00,0x41,0x00,0xc0,0x0b,0x00,0x1e,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x83,0x78,0x00,0x00,0x00,0x00,0x00,0x40,
+ 0x55,0x5f,0x10,0x40,0x00,0x00,0xc0,0x80,0x00,0xe0,0x00,0x00,0x30,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x0f,0x00,0x00,0x00,0x00,0x00,0x80,
+ 0x54,0x3d,0x41,0x08,0x00,0x00,0x30,0x80,0x00,0x20,0x00,0x00,0x60,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x50,0x01,0x00,0x00,0x00,0x00,0x00,0xc0,
+ 0x4a,0x7d,0x08,0x02,0x00,0x06,0x18,0x80,0x00,0x30,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x29,0xed,0x20,0x04,0x00,0x20,0x06,0x80,0x00,0x10,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0xa5,0x7a,0x0a,0x08,0x01,0xb2,0x03,0x80,0x01,0x10,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x52,0xed,0x41,0x20,0x02,0xfb,0x01,0x40,0x01,0x10,0x00,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x2a,0xda,0x16,0x42,0x84,0xde,0x00,0x00,0x01,0x10,0x20,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x89,0xea,0xfb,0x8a,0xf0,0x6f,0x01,0x00,0x00,0x30,0x20,0x00,0x40,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x54,0xda,0xfd,0x5f,0x7f,0xfb,0x01,0x20,0x01,0x20,0x20,0x00,0x60,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x48,0xb5,0xff,0xff,0xdf,0x5d,0x00,0x40,0x02,0xe0,0x22,0x00,0x60,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x24,0x54,0x55,0xfb,0xfb,0x6f,0x00,0x10,0x01,0xe0,0x3f,0x00,0x38,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x90,0xb2,0x6b,0x5d,0xff,0x3b,0x00,0x50,0x03,0xc0,0x3f,0x00,0x3e,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0xa0,0xf4,0x97,0xe4,0xaf,0x05,0x00,0xb0,0x02,0x80,0x3f,0x80,0x1f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x40,0xa9,0xa7,0x52,0x9d,0x2b,0x00,0x40,0x00,0x00,0x3f,0x00,0x1b,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x80,0xe4,0x99,0x5a,0xd5,0x1c,0x00,0x00,0x01,0x00,0x3c,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x6a,0x4f,0xa5,0xca,0x2a,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0xd1,0x33,0x92,0x4a,0x14,0x00,0x02,0x02,0x60,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x64,0x57,0x49,0x65,0x13,0x00,0x80,0x00,0x80,0x03,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0xd0,0xae,0xaa,0x44,0x01,0x00,0x40,0x00,0x00,0x1e,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,
+ 0x00,0xc8,0x4b,0x49,0x8a,0x0c,0x00,0x20,0x00,0x00,0xf0,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0xa0,0x5e,0xa5,0x22,0x0f,0x00,0x80,0x00,0x00,0xa0,0x07,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x80,0x95,0x52,0x04,0x03,0x00,0x10,0x00,0x00,0x20,0x3c,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x40,0x67,0x8a,0x02,0x00,0x00,0x28,0x00,0x00,0x20,0xe0,0x01,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x80,0x2e,0x55,0x24,0x00,0x00,0x0a,0x00,0x00,0x20,0x00,0x0f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0xda,0x90,0x02,0x02,0x80,0x09,0x00,0x00,0x10,0xe0,0x3f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x7c,0x45,0x54,0x11,0xe0,0x04,0x00,0x00,0x20,0xfc,0x7f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0xe8,0x21,0x89,0x04,0x38,0x01,0x00,0x00,0xa0,0xff,0x3f,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0xa0,0x57,0x52,0x90,0x87,0x00,0x00,0x00,0xf0,0xff,0x07,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0xfe,0x5e,0xd5,0x52,0x00,0x00,0x00,0xfe,0xff,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x40,0xff,0x07,0x08,0x00,0x00,0xc0,0xff,0x1f,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0xb8,0x02,0x00,0x00,0xe0,0xff,0x03,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x7f,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x0f,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x01,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0
+ };
diff --git a/Amilogo.pm b/Amilogo.pm
new file mode 100644
index 0000000..2ded4dc
--- /dev/null
+++ b/Amilogo.pm
@@ -0,0 +1,443 @@
+/* XPM */
+static char *noname[] = {
+/* width height ncolors chars_per_pixel */
+"237 237 199 2",
+/* colors */
+"`` c #46243B",
+"`a c #E4CECC",
+"`b c #A6966E",
+"`c c #696867",
+"`d c #BAB8C7",
+"`e c #575348",
+"`f c #4B442F",
+"`g c #CB6961",
+"`h c #C4B2A9",
+"`i c #898465",
+"`j c #866C4B",
+"`k c #381019",
+"`l c #B1823D",
+"`m c #82242D",
+"`n c #764B6D",
+"`o c #D7C697",
+"`p c #866141",
+"`q c #775A11",
+"`r c #7B7B4D",
+"`s c #9C739C",
+"`t c #C84C40",
+"`u c #776A53",
+"`v c #A78D6B",
+"`w c #855D82",
+"`x c #D9B9A6",
+"`y c #973B2A",
+"`z c #583B24",
+"a` c #FBE7E5",
+"aa c #270D15",
+"ab c #C4AC84",
+"ac c #B5B4B4",
+"ad c #B798B6",
+"ae c #F3F4EA",
+"af c #897B4D",
+"ag c #B6B583",
+"ah c #A84237",
+"ai c #584C34",
+"aj c #E4D099",
+"ak c #DEC372",
+"al c #664B4F",
+"am c #A884A7",
+"an c #672739",
+"ao c #ABABA3",
+"ap c #868482",
+"aq c #A47CA3",
+"ar c #994749",
+"as c #E5DEC8",
+"at c #3D1E16",
+"au c #655551",
+"av c #886524",
+"aw c #57304A",
+"ax c #5B5B47",
+"ay c #9B9B93",
+"az c #BB483C",
+"b` c #767472",
+"ba c #8A6472",
+"bb c #561A1E",
+"bc c #686357",
+"bd c #722F1F",
+"be c #78673F",
+"bf c #968A98",
+"bg c #ECEDDF",
+"bh c #A89C99",
+"bi c #E6E4E3",
+"bj c #853521",
+"bk c #BBBC87",
+"bl c #BB8859",
+"bm c #E3E4CC",
+"bn c #DCDCD9",
+"bo c #B49E94",
+"bp c #CDB367",
+"bq c #7C7B74",
+"br c #ECB4AA",
+"bs c #E8EAD4",
+"bt c #96949E",
+"bu c #453C3E",
+"bv c #663C23",
+"bw c #685867",
+"bx c #936A59",
+"by c #977D3F",
+"bz c #674866",
+"c` c #887C79",
+"ca c #C5C4C2",
+"cb c #474443",
+"cc c #AB313C",
+"cd c #D9CBCF",
+"ce c #D38A7A",
+"cf c #CCCCCC",
+"cg c #88492D",
+"ch c #683A53",
+"ci c #4C4C4B",
+"cj c #FCFDFB",
+"ck c #C4C499",
+"cl c #373329",
+"cm c #BCBCBC",
+"cn c #956F2C",
+"co c #554B4D",
+"cp c #3C3C3B",
+"cq c #372A1F",
+"cr c #988C67",
+"cs c #B79675",
+"ct c #050305",
+"cu c #D4BEC3",
+"cv c #8C8B65",
+"cw c #B9ABAF",
+"cx c #F9C8C3",
+"cy c #79734F",
+"cz c #847571",
+"d` c #ACACAC",
+"da c #B6A6A2",
+"db c #2C2C2B",
+"dc c #B25859",
+"dd c #959492",
+"de c #655C59",
+"df c #A9A86A",
+"dg c #AC8CAC",
+"dh c #9C9C9C",
+"di c #1C1C1B",
+"dj c #A7843D",
+"dk c #A49490",
+"dl c #E4CC86",
+"dm c #B6A370",
+"dn c #573B55",
+"do c #151414",
+"dp c #473A24",
+"dq c #C5AEA3",
+"dr c #64561C",
+"ds c #F4E2DB",
+"dt c #DCDCC0",
+"du c #D9A599",
+"dv c #362B31",
+"dw c #A9A484",
+"dx c #CBCBA2",
+"dy c #976C97",
+"dz c #685837",
+"e` c #D5D4B9",
+"ea c #877A87",
+"eb c #EEBBB4",
+"ec c #8A668A",
+"ed c #E5D2CC",
+"ee c #7C7C7C",
+"ef c #D9CF9F",
+"eg c #572F19",
+"eh c #C7BDA1",
+"ei c #952B35",
+"ej c #755A4A",
+"ek c #48151E",
+"el c #D5D4D3",
+"em c #957D66",
+"en c #160D11",
+"eo c #ABAB82",
+"ep c #765A37",
+"eq c #575454",
+"er c #B8B49C",
+"es c #C4A43E",
+"et c #90782C",
+"eu c #8F854C",
+"ev c #D2BB70",
+"ew c #D6C6C0",
+"ex c #5C5C5C",
+"ey c #87744E",
+"ez c #B6A886",
+"f` c #BCBB99",
+"fa c #96756A",
+"fb c #C6B5BA",
+"fc c #492E46",
+"fd c #6A6B4F",
+"fe c #A49F6A",
+"ff c #373434",
+"fg c #8A5268",
+"fh c #261C20",
+"fi c #E8D9A6",
+"fj c #A5A4A3",
+"fk c #795778",
+"fl c #262423",
+"fm c #FC0305",
+"fn c #492E21",
+"fo c #AFB071",
+"fp c #361B2C",
+"fq c #A69AA7",
+"fr c #664A30",
+"fs c #8C8C8A",
+"ft c #C9BCBC",
+"fu c #76434D",
+"fv c #D55B4E",
+"fw c #999565",
+"fx c #9F8140",
+"fy c #562234",
+"fz c #F4DEDC",
+"g` c #FC1818",
+"ga c #56452D",
+"gb c #C4ABC4",
+"gc c #E8D9DA",
+"gd c #DB9988",
+"ge c #A58D8B",
+"gf c #988567",
+"gg c #766B6A",
+"gh c #CCCBBB",
+"gi c #998C89",
+/* pixels */
+"bnbnbnbnelbnelelbnbnelelelelelelbnelelelelelelelelelelelelelelelelelcfelelelcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcacfcfcacacfcfcacacfcacacacacacacmacd`cmcacacabicjcjaecjcjcjcjcjaecacmcmcmcmcmelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecfacaccmacaccmacacacacacacacacacacacacacacacacacd`acd`acd`d`acd`acd`cfaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnd`dhfjfjdhdhdhdhdhdhfjdhdhdhdhdhdhdhdhdhdhdhdhdddhdhdhdhdhbtaydhaybtaybtddelcjcj",
+"bnelbnelbnelbnelelbnelelelelbnelelbnelelelelelelelelelcfelcfelcfelcfelelcfcfelcfcfcfcfcfelcfcfcfcfcfcfcfcfcacfcfcfcacfcacfcacfcacfcacacacacacacacacacacaacacd`aocmcacacfaecjaecjcjcjcjcjbicmcacmcmcacfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecfaccmacacacacacacacacacacacacacd`acd`acacd`acacacd`acd`d`acd`d`acd`d`d``dbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgcafjfjfjdhdhfjdhdhfjfjdhdhdhdhdhdhdhdhdhdhdhdddhdddhbtddddbtayddbtaybtaydddhddd`aecj",
+"bnelbnelbnelbnbnbnelelbnelelelelelelelelelelelelelcfelelcfelelelcfcfelcfcfcfcfelcfelcfcfcfcfcfcfcfcacacfcacfcacfcacfcfcacfcacacfcacfcacfcacfcacacacacacacaacacd`d`cmcacacacfbnbgaecjcjbg`dcmcmcmcmcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcfacacaccmacaccmaccmacaccmacacacacacd`acacacd`acd`d`acd`cmd`aod`d`d`d`d`d`d`d`cabicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbncmfjbtdhdhdhfjdhdhdhdhdhdhdhdhdhdhdhdhdhdhdhdddhdhbtaybtayayayaybtddaybtddbtddaybtdhbncj",
+"bnbnelbnelelbnelelelelelelelbnelelelelelelelelcfcfelelcfelcfcfelcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcacfcacfcacfcacfcacacfcacacacacacfcacacacacacacacacacmcm`dd`accmcacmcmcmcfcfcdaeeedoctflbtcaaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnacacacaccmacacacacacacacacacd`d`acd`acacd`d`acd`d`acd`acbielcmd`d`d`d`d`d`fjd`fjd`cfaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaebicfacdhdhdhdhfjdhfjdhdhdhfjdhdhdhdhdhdhdhbtaybtaydhdhbtaybtayddaybtbtaybtaybtddddddddbtaybtd`ca",
+"elbnelelelelbnelelelelelelelcfelcfelelcfelelcfelelcfcfelcfcfelcfcfelelcfcfcfcfcfcfcfcfcfcfcfcfcacacfcfcacfcfcacacfcfcacacfcacacfcacacacacacacacacmcaca`dcacmcmacacfjaccmcacmca`d`daoeectctctctenaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbiacaccmacacacacacacacacacd`acd`acd`acacd`d`d`acd`acacd`aoelcjcjaebncmfjaod`d`d`fjd`aofjaccfaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeelacfjdhdhdhdhdhfjdhdhdhdhdhdhdhdhdhayaybtdhdhaydhaybtayddaybtaybtaybtddaybtddddddayddddddddaybtdddd",
+"bnelelelbnelelelelelelelelcfelelelelcfelcfcfelcfcfcfcfelcfcfcfelcfcfcfcfcfcfcfcfcacfcfcacfcacfcfcacacfcacfcacacfcacacacacacacacacacacacacmcaca`dcacacmcacacacmcmcmacfj`dcmcmcmcmcmacdictctctctctcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgcmacacacacacacacacacacacacacd`acacacd`acd`d`acd`d`d`d`aocmaecjcjcjcjaebn`daofjfjd`d`fjd`fjfjaccabicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcfcaacdhdhdhdhdhfjdhfjdhdhdhdhdhdhdhdhdhaydhaydhayaybtayaybtayddbtayddbtayddddddddbtayddbtddddbtaybtayaybt",
+"elelelelelelelelelelelcfelelcfelelcfelcfelcfcfcfelcfelcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcacfcacfcacfcfcacacacfcacacacacacfcacacaca`dcacmcacacmcacmcacmcacmcacmcaacaccmaod``dcmcmcmcmcmctctctctctctcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcaacacacacacacacacd`acd`d`d`acd`acaod`d`d`acd`d`d`d`d`aod`bicjcjcjcjcjcjcjaebicafjfjd`fjd`fjfjfjdhd`caaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecadhdhdhdhfjdhdhdhdhdhdhdhdhdhdhdhdhayaydhbtaydhbtbtayaybtaybtbtaybtaybtaybtddbtddddddddbtfsddfsddbtddaybtay",
+"elelelelelelelelcfelcfelcfelelcfelcfcfelcfcfcfelcfcfcfcfcfcfcfcfcfcfcfcfcfcacfcacfcacfcacfcacfcacfcacacfcacacacfcacacaca`dcacmcacacacacmcacacmcacmcmcacm`dcacmcmac`dacaoaocmcmcmcmcmdbctctctctdicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnacacacacacacd`acd`acd`d`d`cacaacd`acd`acd`d`d`d`d`d`d`d`cmaecjcjcjcjcjcjcjcjcjbicaacfjd`fjd`fjfjfjfjfjd`cacfbgcjcjcjcjcjcjcjcjcjcjcjcjcfcmd`dhdhdhdhdhdhdhfjdhdhdhdhdhdhdhdhayaybtaybtaybtbtayaybtbtaybtddayddddddddddddddddddddddfsddbtfsbtfjacaccmacac",
+"elelelelelelcfelcfelcfelcfcfcfelcfcfelcfcfcfcfcfelcfcfcfcfcfcfcfcfcfcacfcfcfcfcacfcacacfcacfcacfcacacacacacacacacacacacmcacacmcacacacmcacmcmcacmcacmcmcacmcmcmcmcmcmacfjfjaccmcm`dacdddoctctdicfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcad`acacacacacacd`acd`accfbnaecjbncmaod`aod`d`d`d`aod`d`acbicjcjcjcjcjcjcjcjcjcjcjcjbid`dhfjfjfjfjfjfjfjdhfjdhd`cfcjcjcjcjcjcjcjcjcjbiacdhdhfqfjdhdhdhdhdhdhdhdhdhbtaybtddbtbtddbtaybtaydhaybtddbtayddaybtddbtddbtddddddfsbtddddddfsbtddfsfsdhaecjcjcjcjcj",
+"elelcfelcfcfelelcfelcfelcfelcfcfelcfcfcfcfcfcfcfcfcfcfcfcfcfcfcacfcacfcacfcacfcfcacfcacacfcacacacacfcacfcacacacacacacmcacacmcacmcacmcmcacacmcacm`dcacmcmcmcacmcmcmacacd`fjfjaccmaccmcmcmaccacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjelacacacacacacd`acd`d`cmaecjcjcjcjcjbicmd`d`d`d`aod`d`d`fjcacjcjcjcjcjcjcjcjcjcjcjcjcjcjel`dfjfjd`fjfjfjfjfjfjfjfjfj`dcacfbicjcjcjbgcmfjdhdhfjdhdhdhdhdhfjdhdhdhaybtaoacacacacacacd`fjddbtbtaybtayddbtddbtddddddddddddbtddddddddfsddddfsfsfjd`elcjcjcjcjcjcj",
+"elcfelcfelelcfelcfelcfcfelcfelcfcfcfelcfcfcfcfcfcfcfcfcfcfcfcacfcacfcacfcacacacacacacacacacacacfcacacacacacacmcacacacacmcmcacacmcacmcacmcmcacmcmcmcmcmcmcmcmcmcmcmacac`dd`btfjaccmcmaccmbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgcad`acd`acd`d`d`d`acd`cabicjcjcjcjcjcjcjcjbnacfjfjd`d`d`dhfjbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjeld`btfjfjfjfjfjdhdhfjdhfjdhdhd`accfftd`dhdhdhfjdhdhfjdhdhdhdhdhdhbtaycfaecjcjcjcjcjcjcjbnacddfsfsddddbtddddddddbtddddddddfsbtfsddfsddfsddfsapaecjcjcjcjcjcjcjcj",
+"elcfelcfcfelcfcfelcfcfelcfcfcfcfcfcfcfcfelcfcfcfcfcfcacfcacfcacfcfcacfcacfcacfcfcfcacacacacacacacacacmcacmcacacacmcacmcacmcacmcacmcacmcacmcmcmcmcmcmcmcmcmcmcmcmcmacacaccmfjdhd`cmaccmaccaelbicjcjcjcjcjcjcjcjcjcjcjcjcjaeacd`acacd`acd`acd`d`fjcaaecjcjcjcjcjcjcjcjcjcjbicfcmfjfjfjacelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbicmfjfjfjfjdhfjfjdhfjdhdhdhdhaydhdhdhdhdhdhdhdhdhdhdhdhdhaybtayacelcjcjcjcjcjcjcjcjcjcjaecaaccmfjfsddddbtddddddddddddfsddddddfsddddapfsfj`daecjcjcjcjcjcjcjcj",
+"cfelcfcfelcfelcfcfcfcfcfcfcfcfcfcfcfcfcacfcfcfcfcfcacfcfcacacfcacfcfcacfcacacacacacacacacacacacacmcacacacmcacmcacmcacmcacmcmcmcmcmcmcmcm`dcmcmcmcmcmcmcmcmaccmcmaccmacaccmaobtdhd`cmacacacaccacjcjcjcjcjcjcjcjcjcjcjcjcjbgfjacd`d`d`acd`d`d`d`cfaecjcjcjcjcjcjcjcjcjcjcjcjcjaeelelbnbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjelbtfjdhdhfjfjdhdhdhfjdhdhdhdhdhdhdhdhdhdhdhaydhbtaybtdhcabnaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgcfdhfsddddddfsddfsddddfsfsddddfsfs`delbgcjcjcjcjcjcjcjcjcjcj",
+"elcfelcfcfcfelcfcfcfcfelcfcfcfcfcfcfcfcfcacfcfcfcacfcacacacfcacacacacacacacacacacacacacacacacmcacacacmcmcacacacmcm`dcacmcacmcacmcmcmcmcacmcmcmcmcm`dcmcmaccmaccmaccmcmd`acd`fjfsdhacaccmacacaccacfbgcjcjcjcjcjcjcjcjcjcjbid`d`acd`acacd`d``dbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcffjdhfjdhdhfjdhfjdhdhdhdhfjdhdhdhdhdhaydhdhaybtaocfbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbicafjfsfsddfsfsfsfsfsfsfsfsdhcacjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfelcfelcfcfcfelcfcfcfcfcfcfcfcfcacfbtb`cidbffcbb``dfs`c`cexeecfcacacacacacacaca`dbt`cexffdoapcacacmcacacmd``ccpffcifscmcmca`dcmcmcmcm`dcmeeeqdbdbexfj`dcmacaccmaccmacacacacd`dheeb`excbdbdiacd`d``dcmbicjcjcjcjbicmapeqdbctd`d`acd`d`d`cmbgcjcjcacmaceeelcjcjcjcjcjcjcjcjeleecpfjcjcjcjcjcjcjcjcjaeftddeecbfld`cjcjcjcjcjcjbifscicbexbtbtdhdhfjdhdhdhdhdhdh`ccbflflciapbtbtaydhbiaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbicfcfcacfcfcfcfcfcfcaelaecjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfd`cienctctctctctctctdoctctctcteqcacacacacad`eqdbenctctctctctctacca`dcacadhdbctctctctctctexcmcm`dcacmcmcmexdoctctctctctctfsaccmcmaccmacacac`ccpdictctctctctctcbacacacacd`cmbtexcpctctctctctctfld`d`d`d`d`cmbncjcjcmctctctctcacjcjcjcjcjcjcjfsctctctctbicjcjcjbib`cpenctctctctctctaecjcjcjcjelcpctctctctctctexdhdhdhdhdhfjdhcictctctctctctctb`d``dcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfelcfcfcfcfcfcfcfcfcfcacmcictctctctcifscaca`deectctctctctbtcacacacacaexctctctctctctctctdbcacmcmcaexctctctctctctctctctcmcmcmcm`ddhdictctctctctctctctdocmacaccmacacacacdictctctctctctctcteeacacacaod`d`cbctctctctctctctctcid`acd`acelaecjcjcjeectctctctcjcjcjcjcjcjcjcjacctctctctfscjcjcjeectctctctctctctctcpcjcjcjcjapctctctctctctctctctfjaydhbtayeedictctctctctctctctdiaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcfcfcfcfcfcfcfcfcfcafsenctctctcpcmcfcacacfcacf`cctctctctcacmcacmcacmcacadhfscpctctctct`ccmcmaccbctflapaccmcbctctctctfscmcmcmb`doctciddacfjdictctctctdhacacacacacacacacacd`ddctctctctctfjacacd`accmd`d`d`aofjdbctctctctb`d`aoacelcjcjcjcjcjcpctctctcpcjcjcjcjcjcjcjcjcfctctctcteqcjcjcjcjcjcfcmcictctctctddcjcjaeexctdbd`bgcjexctctctctfjfjbtdh`cctctciddcmcmdbctctctctbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcfcfcfcfcfcfcfcacfeectctctct`ccfcacfcacacacacacpctctctdbcacacacacacacacacacaexctctctctfjcaacflctexcm`dcmcmacctctctctfscmcmb`ctdidhcmaccmcmeectctctctfsacacacacacacacacacd`acdictctctdiacd`d`acbnbgelcmd`fjd`cpctctctctayaccfbicjcjcjcjcjcjctctctcteecjcjcjcjcjcjcjcjcjctctctctcpcjcjcjcjcjcjcjapctctctctbncjaedvcteecjcjcjcjaectctctctcmbicfeectdbelcjcjcjcjacctctctctcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcfcacfcfcacfcfcaeectctctcteecfcacacacfcacacaacctctctctb`cmcacmcmcacmcmcm`dcacbctctctdicm`dcpctb`cmcmcmcmcmcmctctctctfjcmfsctfld`accmacacacapctctctctfsacacacacacacacd`d`acfjctctctctciacacd`acbgcjcjaecfcaacdictctctdocabicjcjcjcjcjcjcjcmctctctctaccjcjcjcjcjcjcjcjcjctctctctb`cjcjcjcjcjcjcjexctctctdicjcjcictfjcjcjcjcjcjcjctctctctbicjcmctdbaecjcjcjcjcjcmctctctctelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcfcfcacfcacfcaeectctctcteqcacacacacacacacacaeectctctctaycacmcacacmcacmcacmcadictctctcicmeqctb`cmcmcmcmcmcmfjctctctctcmddctfld`cmacacaccmacexctctctctacacacacacacacacacd`aceectctctctb`fjd`d`d`bicjcjcjcjcjcfctctctctexcjcjcjcjcjcjcjcjcjb`ctctctctbgcjcjcjcjcjcjcjcjcjctctctctdhcjcjcjcjcjcjcjflctctctb`cjb`ctdhcjcjcjcjcjcjbictctctencjcfdodbaecjcjcjcjcjcjapctctctctcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcacacfcacfcafjenctctctflcacacacfcacacacacmcacpctctctct`dcacmcacmcacmcacmcafjctctctctddeectexcmcmcmcmcmcmacb`ctctctcpcmdidofjacacacacacacacdictctctdbacd`acacacd`acd`acd`d`cictctctctfsayd`d`d`aecjcjcjcjcjd`ctctctctfjcjcjcjcjcjcjcjcjcjdbctctctdicjcjcjcjcjcjcjcjcjcjctctctctbicjcjcjcjcjcjbnctctctctcmd`cteecjcjcjcjcjcjcjdhctctctcicjdbenbicjcjcjcjcjcjcjdbctctctcpcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacfcfcacacfcaflctctctctdhcacacacacacacacmcaacctctctctcpcacmcacmca`dcmcmcmcmb`ctctctctacctffcm`dcmcmcmcmaccmcbctctctb`cictapacacacacd`acacdhctctctctexacacacd`acacd`d`acd`d`doctctctdbapfsdhd`d`aecjcjcjcjcjeectctctctbncjcjcjcjcjcjcjcjbictctctctexcjcjaeaecjcjcjcjcjcjctctctdbbibncjcjcjcjcjfjctctctenaeencpcjcjcjcjcjcjcjcjbcctctctdhb`ctcmcjcjcjcjcjcjcjbictctctctfscjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cfcfcacacacaca`cctctctctexcacacacacmcacmcacaca`cctctctctb`cacmcacmcacmcmcm`dcacbctctctcbcpdod`cmaccmaccmacaccmdoctctctb`ctciacacacacacacacac`cctctctctddacd`acd`acd`acacd`d`ayctctctctflcbexbtd`d`bgcjcjcjcjcjcpctctctdocjcjcjcjcjcjcjbgdhcbctctctctffci`c`capaccjcjcjcjcfctctct`cci`caecjcjcjcjexctctctexcidoaecjcjcjcjcjcjcjcjdictctctdhctb`cjcjcjcjcjcjcjcjdhctctctctelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacacfcad`enctctctctcmcacacacmcacacacmcacmdictctctctfjcmcmcmcmcmcmcmcmcmcmdictctctcbctb`cmcmcmaccmacacacfjctctctdididid`cmacacacacacacaccpctctctdod`acd`acd`d`acd`acd`d``cctctctctffdbflcifsd`caaecjcjcjcjctctctctciaebgbgcjcjcjcjfjflenctctctctcldbcbeefjacdhdhapexexctctctff`ccicfcjcjcjcjflctctctexctdhcjcjcjcjcjcjcjcjbictctctdbdbdiaecjcjcjcjcjcjcjcjeqctctctdicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacfcacacbctctctctexcacacmcacacmcmcacmcaeectctctctdicmcmcacmcmcmcmcmcmcmfjctctctctctdbcmacacaccmacaccmac`cctctctencteeacd`acacacacacacfjctctctctciacd`acd`d`d`d`d`acd`d`cpctctctctaocr`fdidbexfsapacaecjcmctctctctexb`exbtcjcjcjaeeqcpctctctctctfwdwcvaxdbdienendodidictctdiacelciexfjd`acdhctctctctctcpcjcjcjcjcjcjcjcjcjfsctctctdoctaccjcjcjcjcjcjcjcjbgctctctctb`cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacaca`dctctctctctaocacmcacacmcacmcmcacmdoctctctctcbcmcmcmcmcmcmcmcmcmcmb`ctctctctctapcmacaccmaccmacacaccpctctctctdbacacd`acd`acacd`aceectctctctfsd`d`d`d`d`d`d`d`fjd`d`ctctctctdbbcbv`fdz`fdbffdifleed`eqctctctctdidib`bicjcjcjbncpcbctctctctdiafeyfwbkdwbqbccpexddctctctaodqboggdbcbcpdbenctctctctctcmcjcjcjcjcjcjcjcjcjeqctctctctcpcjcjcjcjcjcjcjcjcjacctctctctcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacaca`cctctctctcpcmcacacmca`dcacmca`deectctctctcteecmcmcmcmcmcmcmcmcmaccbctctctctcpcmacaccmacacacacaccmctctctctctapacd`acd`acd`acd`accpctctctctaoaod`d`d`d`d`d`d`d`d`fsctctctctdedzdpfwfefx`ucibudbendictctctctctb`bucbaofjfjcffscidictctctctbcdxfeeufwfobkbk`bezc`ctct`eghcseuczcpgiddcvdbctctctctdbbtcaaecjcjcjcjcjcjcjenctctctctcacjcjcjcjcjcjcjcjcjexctctctdocjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacmcaflctctctctb`ca`dcmcmcmcmcmcmcmcmdictctctctctaccmcmcmcmcm`dcm`dcmcmdoctctctctfsacacacacacacacacacapctctctctdbacacacd`d`d`d`d`d`fjctctctctcpd`d`d`d`acd`acacacd`d`eqctctctcteqcqdoexcyfdaxbe`rgf`eflctctctctfheuafclclcbfldvflcbctctctctctddcjbmfocrfefodfdfdfcpctct`peycrafcrci`e`b`bdictctctctexeeb`exfscfcjcjcjcjcactctctctcpcjcjcjcjcjcjcjcjcjcjdoctctctexcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacacmcactctctctctaccmcacmcacmcmcmcacmexctdbctctctdicmcm`dcmaccmcmcmcmacddctctctctdiaccmacacacacacacacacexctctctct`cacd`acacacd`d`d`d`eectctctctb`fjbtapfsapee`cexcpcpcpenctctctctcicbcbfldocifdfdcvdfdwfdctctctctfleudffw`edvgaaicpctctctctctctdxaecjbgf``bdffodffwctctaiepdzeueuezayciafejctctctctctcfcjbiacfseeb`fjbiaeeectctctctdhcjcjcjcjcjcjcjcjcjcmctctctctaccjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacmcacmctctctctdbcacacmcmcmcmcmcmcmdhctcidictctctcicmcmacaccmacaccmaccm`cctctctct`cacacacacacacacacacacdbctctctctacacd`d`d`acd`fjd`d`cpctctctctcicicicicpfldididbffcpcpctctctctflbccicpfldodi`efwbkdfdffdctctctctdp`fbeagagcydpaiaictenctctctdidtbmaecjbmercrfefeclctdbfofwafezfeehdxexcbdpctctctctendbex`cb`eeb`eqdbcp`cflctctctencjcjcjcjcjcjcjcjcjcjb`ctctctctcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacacmcacmctctctctexcmcmcmcmcmcacmcmcmfldifsctctctctfscmaccmacaccmaccmcmacffctctctctaoacacacacacacacacacfjctctctctcbd`acd`acd`acfjdhfjfjdoctctctendbdbcbeqci`ceeddeebtfjeectctctctb`dd`ccidbdbdbdibcf`efdfdpctctctctbedzdzeuagfo`iclenctflctctcteqaedtbmaeaegh`bfw`rctcterbgbkcr`bcsewdtdddbdictctctctcpendiflfldbdididiflcpctctctctcbbicjcjcjcjcjcjcjcjcjdictctctcicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ca`dca`dcactctctctb`cacmcmcmcmcmcm`deqctfs`cctctctctaccmcmcmfscmacaccmacacctctctctdbacacd`acacacd`d`acacb`ctctctctbqd`acd`d`d`fjfjddeecictctctctcidhbhfjfsayaybtfsaycfbg`cctctctctcfcacmaob`bq`c`edbciaodxdoctctctdifwfwcyfr`ufweoaictclatctctctcpbidtcaehcacaddcrflctfde`bickfwfw`v`hdtckbcctctctctclbqdbapayb`eqciexcpffdbctctctctdoeqcmbgcjcjcjcjcjcjelctctctctdhcjcjcjelbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcacmcmcmctctctctfscmcacmcmcmcmcmb`cteqcmdictctctdbcmacacfjdociacacacacddctctctct`cacacacacacd`acacd`d`cictctctctd`d`d`fjfjfjd`dhfseqdoctctctctc`apb`ggfldibtfsgifjaccmdoctctctflfbbtapfjencidhfs`ccp`fddctctctct`fdfdfbkfwafbhcvctcldzdoctctctflcfcjbsbmbicjas`ectcpdxcme`bkfwezdaezghghfsctctctctcvddffaccjaebgelcabtb`ffctctctctffflfl`ccmcjcjcjcjcjeectctctctaecjcjcjcpffcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcmcmcmcactctctctfs`dcmcmcmcmcmbtctdicmd`ctctctct`caccmaccpctdhacacacac`cctctctctayacd`acacd`d`acd`d`acdictctctcpaod`aod`d`d`d`ddeecbctctctctfldkcwfbggctggdadkddbhcwgictctctctcpdaaobcdbctcwcdacapb`cbclctctctctfddfbkdxdxdffeflctfeeuctctctctfl`ebgcjbsdtbgaoctdiehdtdtbmdtfockbibibmdxexctctctctcmckcbeeaea`a`aeaeaecjdbctctctcifj`cdbencpdhbgcjcjcjffctctctcpcjcjcjddctdhcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcacmcmcmctctctctfscmac`dcmcmbtctfld`acb`ctctctctddacaceectciacacacacacffctctctdiacacd`d`acacacd`acd`btctctctct`cd`d`d`d`d`acdhddeecpctctctctggfbftdaenfhcwcwdkdkgedkdectctctctffgida`cct`eewcdewdaddfsdbctctctct`rfodxdtdtbkdbctcvfefectctctctdpdbapcjcjbmaoenenfw`hdtdtdte`dxagbmcjbie`dbctctctdoerbmfdeqedaea`a`a`a`cdctctctctdhcjaeaceqcbapbicjcjbnctctctctddcjcjbnenffcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcmcmcmcmctctctctcicmcmaccmeedoctdhcmacexctctctctacacddctfld`acacacacd`ctctctctciacacd`acd`acd`d`d`d``cctctctctfjd`aod`fjd`fjdhddeeffctctctctap`x`hflctddfbdadkdkdkdkcbctctctctc`bhgiendocwft`xewcuft`hcictctctctcvdffoe`dxclctfddfdfdfctctctctfn`fcqd`cjfjdoctghckerewdtdtdtbmbkbkaeedehenctctctfl`vbsfscpcaaea`a`a`a`bfctctctctgccjcjcjfjcpelcjcjcjfjctctctctcmcjaedbctcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cacmcmcmcmctctctctenfscmfjcbctdiddacacacdbctctctctd`apdoctddacacacacacddctctctctapd`d`d`acd`d`acd`acd`cpctctctdbaod`fjfjd`fjdhbtdd`cflctctctctc`bhfhctb``xcwbodkbhbobhflctctctctdagienendkftcuftcacdgcgcb`ctctctctflfeckbqdoctfdckdtdxfoflctctctctgadpclcictdoaobsbmehftdtdtbsaedtage`gcdkctctctctfneydxcacpfqcja`a`a`a`eqctctctcpa`a`aeaeeedbcfcjcjcjeectctctctd`bidbctfjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcmcmcmcmctctctctctctctctctdbd`cmacaccmffctctctctctctctddacacacacd`d`exctctctctacacd`d`d`d`d`d`d`d`d`doctctctexd`d`d`d`fjfjdhddfsexflctctctctctctctggftfbdadadadabhdkffctctctctctctctcidebcdeexde`c`cggb`ctctctctctctctcten`rckdtbgaebkaxctctctctctctctctflbnbmdtbge`dxbibmdtaecjbkbkbs`uctctctctcidzeze`ex`cbia`a`a`a`enctctctc`a`a`a`fzexdod`cjcjcjddctctctctctctctdhcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcmcmaccmdhctctctctctctdob`accmacacacacb`ctctctctctdbddacacd`acacacd`cpctctctcpd`acd`d`d`acd`acd`d`fsctctctctfsfjd`d`d`d`fjdhdhfsexdbctctctctctdoggfbft`hbhgeeabccoffflctctctctctenffcbcpcpcieqcbdbffcpcpdictctctctctctcbe`agagdxdtbsdxbkdictctctctctctdi`cbgcjbmbmbmdtbgaedtbmcjdtfoe`cpctctctflcbgaemf`eeffcacja`a`ftctctctctfta`a`a`ds`cdoapcjcjcjbnenctctctctdid`cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmcmcmcmcmacd``ccpdbcieeacacacacacacacacaceeffdbcifsacacacd`acd`d`d`accpeq`capfjd`d`acd`d`d`d`d`d`d`b`cicieefsfjd`fjd`fjfjfjfjdhddexdbexcpflffeqgicw`xfbdk`edvdododoflffcpdidocp`cd`cmfjaccacfcmayddd`cmd`fjb`dbdidoflax`ccae`fodfagbkckdxfofdcldbdpaxafep`fapaeaebmdtdtdtaeasdtbgaeckbkcide`iaydwcibubcezfscpeafzfzdsbh`cb`cwfta`a`a`a`a`apdieqaecjcjcjcfexcpexdhaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmaccmcmacaccmacacacacacacacacacacacacacacacd`acacacacd`d`acd`acd`acd`acd`acd`d`d`d`d`d`d`d`d`d`d`d`fjaoaoaofjd`fjd`d`fjdhfjfjfjapciflc`bhddgedkbocwfbdaggfhdidiffcbex`capfsfsapeeeeeeb`ddfsddee`cb``cddee`c`cb`b``ccbaxb`axaodxdffefedfcke`agagdxbkfodxcrepbubtcjaee`dte`e`bsdtdtcjbmagabftdxe`dxdddvcogffecidbeq`capcwgcdsa`a`a`a`a`a`a`bffldbbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"accmaccmacacacaccmacacaccmacacacacacacd`acacacd`d`acacd`d`acd`d`acd`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`fjd`fjd`fjfjfjdhdhfjfjfjfjeecpfffsddgedkbhbo`hcwdagibccpcibc`ceqeqb`b`exeqffdbdbfffffldbflfldidbcpcpdbdbffcpcpcpflcpcicib`eofofefwfodtbme`ckfockckagemdzcbaccjbmdte`foe`bidtbsaedxfo`hewe`dxe`bqclcygibcfldoendibcapgicua`a`a`a`a`a`cwdvdid`cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"accmcmacacacacacacacacacacacacacacacacacacd`d`acacd`d`d`acd`d`d`d`d`d`d`d`d`d`aoaod`d`d`d`d`d`fjd`fjfjd`fjfjfjfjd`dhfsdhfjfjfjfjb`flcbgigigebhbhbocwdacwddb`ciciexb`cbcbcbfldodoctdodidididididididiflflfldidididbffdbfldoeq`rcpaydtbkagfobkbmaedxage`e`ckaggffreqcfcjbmdxfobkbnbnbmdtckdfag`hdxe`dtck`eciemfdex`cb`ex`ccbffc`a`a`a`a`a`a`cacpenb`cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmacacaccmacacacacacacacacd`acd`acacacd`d`d`d`d`d`d`acd`acd`acd`d`d`d`d`d`aod`d`d`d`fjd`fjd`d`d`fjd`fjfjfjfjfjfjfjbtdhfjfjfjfjdh`cdieqdhdddkbobobhdabocwcocbcbfldiflfldbdbdbdbdbdididididodoenctdoenctctctenctctctdodoenctdo`cb`fdckdte`f`foage`dxckbmdte`e`f`emaiexelcje`ckdfehelgcdxdffwfeabehe`dtdtddcibe`uexb`dhdhfsffdbeqcda`a`a`a`a`gceqdocibicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acaccmacacacacacacacd`acd`acacd`acd`d`acd`acd`acd`d`acd`d`d`d`d`d`d`d`d`aod`d`fjd`fjd`fjd`fjd`fjfjd`fjfjd`fjfjd`dhdhfjfjfjfjfjfjexdo`caccwbofqdabhdkbocwcpciexcpcpffdoflflflfldidodododidodifldbffcbdncocobudvdbfffffldifldodicp`eexd`bsdtckbkfofodxdxdxckbkckezeyalfsaebgdxdwcs`xgce`agfeaf`vehew`oe`f`gg`fb``eexapap`cdbdbciftdsbia`a`a`a``cdiffcacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbncabiaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acacacacacacacd`acacd`acacd`acd`acd`acd`d`d`d`d`d`acd`d`d`d`d`d`d`d`d`fjd`fjd`fjfjd`fjfjfjd`fjfjfjfjfjd`fjfjfjfjdhfjfjfjfjfjfjdhcbdofscacwdabhbodkgecwfjcbeeeeexb`cidoendododiffcpbudndnbufcfcdnbzbzdndnbzbzdn``dnfkfcfcfcfcdidoexeebqcmbgbmdxfodffofodfagdffockfeeyauaocjdtezgfblduehdxfecgcgboewdu`xe`ddcl`u`uexexex`cdbflcicmgcfza`dsa`a`b`didbfjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecafsb``c`c`cexdbcbeeeefjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acacacacacd`acacacd`acacd`acd`d`acd`d`d`d`d`acd`d`d`d`d`d`fjd`d`d`fjd`d`fjd`fjd`d`fjfjd`fjfjfjfjd`fjfjfjfjfjfjfjfjdhfjfjfjdhfjddcpdigi`dbobhbobhdddkcwapciap`ceqapcpendodifheqbzfc``fcfcdndnbzbzfkbzdnbzfk`ndnfcbz`ndnfcfp````fcdvdeb`bqghbsbsckdffobkbkckckfodxdx`b`pbccfcjdx`varfvceacescgbdbxeh`xdu`adxaxbu`iexcpfleqcpdiffcwdsfza`a`a`a`apdiflb`cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcmcicpeqee`dbnbneedib`biaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acacd`acd`acd`acd`acd`d`acd`acacd`d`acd`d`d`d`d`d`d`d`fjd`fjfjd`d`fjd`fjd`fjd`fjfjfjd`fjfjfjfjd`fjfjfjfjfjfjdhfjfjfjfjfjdhfjfjeeflflfsfjdkbhaddkgedkao`ceqfsexeqexdodbdnfc``flfhfhfc`nfk`w`w`wdydydyecdy`sdyecec`wecec`nbzdnfcfc``dobzb`apdwdtbsckckdtdtbkagckdte`f`eyfreeaecjehbxahfvezdc`ybdcgcsewdugd`adwcp`eauexdicbcbdiflfjbidsdsa`a`aebtfldbb`aecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnfjapd`bnbgbibmbgcjbg`cdiapaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"d`acd`acacd`acd`acd`acd`acd`d`d`d`d`d`d`d`d`d`d`fjfjaod`fjd`fjfjfjfjfjfjfjfjfjfjfjd`fjfjd`fjfjfjfjfjfjfjfjdhfjfjdhfjdhfjdhfjdh`cdoffapdkdkdadadkgibhcweqb`ap`ccbdbflbzfcfcbzdnfhctdibwdy`sdy`saqamdgdgdgdgdgaqaqaqamamaq`sdy`w`nfcfpeneqfs`cfsdtbsdxcke`ckdfckdtckbkfwepaibfcjbgf`bxarfvazahbjbdafab`g`tcee`cvclai`eflcbexdbflaobia`dsa`a`a`dhflcpbtcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnfqeed`bgbidxerdfdwezerbgbiexdbeeelcjcjcjcjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acacd`acd`acacd`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`aofjaofjfjfjfjdhaofjfjfjfjfjfjfjfjfjfjdhfjfjfjfjfjfjdhfjdhdhfjdhdhfjdhfjdhdhbtexdodbfsdkdacwdagidkfjcwcieeapexfldoffdvfhdvdvdvfpenctendnecaqamadadgbgbgbgbadadadcwgbgb`dgbadaqdyfkdnfpflexb``cfsdtbsdxckbkdfdfagagfoageugacqd`cjbgez`paz`tahahbjbv`v`g`tfvdughgg`fdecpcpexcpffdhfzbia`a`dsa`d`dbcpapaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjacfsd`aebgehezeoabagf`agagcdcjeleqeqfscacjcjcjcjcjcjbnbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"acd`d`acd`d`d`acd`d`d`d`d`d`d`d`d`d`d`d`fjd`fjaofjfjfjdhdhfjfjdhdhdhfjfjfjfjfjdhfjfjdhfjdhfjfjdhdhdhfjfjdhdhdhfjfjdhdhdhdhdhdhexencifqdadadqdkdkdk`daoexfseecbffcpfpenenfpfhenctctdodoendbfkgbcucacdcdcdcacucucacdgcbibielcfgbdgea`nfcfcfpeqbqexcvbmbsefbkfodffockefe`eh`qekcobicjasfwepahaz`y`ybd`pdm`t`t`geffjexdzaiexapciffbtbifzdsa`a`a`acffcpapaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbnfsapbnbgergffwagdxckghefewf`f`bgcj`deqdhaccfcjcjcjcjcjbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaefs",
+"d`acd`d`acd`acd`d`d`d`d`d`d`d`d`fjd`d`d`d`fjd`fjfjdhdhayayayayfjaydhaydhdhdhdhfjfjdhfjdhfjdhfjfjfjdhdhdhdhfjdhdhdhdhfjdhdhdhbtcienciacftdqdadkdkfjelgi`cdhb`cpeqcidi``dnbzbwdnfpfpenaadoctdib`cfelgcelgccdcdcdgcaebga`bigccdgbadaqecdndnaw``co`c`caye`bmdtckbkbkbkabewck`vbv`kcyaecjasgfcgah`y`ybjbdcrcs`tfvgddxb`cb`z`cdheqcbayfzfza`dsa`biftcpcpeebgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjac`cfjbndhdedzfddke`ghezerghdxdxdtbibgaed`eecfbncfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjac`cfl",
+"acd`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`d`fjd`fjaofjfjfjfjayfjayayayayayayayaydhaydhdhdhdhdhdhdhdhdhdhdhbtdhdhdhfjdhdhdhdhdhdhfjapcpdo`ccaftdabhdkdkcwbib`apbt`ccpexcbbwfk`nfkfg``fp`kenenendoendobufqcdgccdcdcucdgccdcdcucucugbgbdg`s`wbzbz`wdn``ffci`e`rbkbmdtbkdxbkdmcefoaggfbdaagiaea`ewafbj`ybdbjbdejab`g`t`g`oacbcdvcpeeexexfjgcfzdsa`a`fz`dcbdbb`bicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaefs`cacacbcaiaieyezew`h`beyemezere`ase`ghascjfjb`bnbgelcjcjcjcjbicacmacfs`cbfbgcjcjcjcjcjcjcab`ffffc`",
+"d`d`d`d`d`d`acd`d`d`d`d`d`fjd`fjd`d`d`fjfjfjfjfjfjayfjayayayayayayayayayayayayayaydhaydhdhdhdhdhdhaydhdddhdhdhdhdhdhdhdhdhdheedbdob`cmcwdabhgegidqelexfsfs`ccpcieqeady`wbz``fpfpfpfpaafpctctctctfl`c`dcdcucugbgbgbaddgamaqaqaq`s`secdncodyecbzfpfhcpcpcybkbmbmbkckagcsdjfedfavekatcsbrcxeweycg`ybdbjbjczdufvfvgde`fscbflciex`cdhbidsa`dsdsbicmcpffb`bncjcjcjcjcjcjcjcjcjcjcjcjcjcjbgapb`aob``eepafezelgc`bauaiegat`zgfewe`ewdxdtcjcjdhapbiaeaecjeleecbffdbcbexb`cpciacaecjbgd`bfb`cbcigfgf",
+"acd`d`d`d`d`d`d`d`fjd`d`d`d`fjd`fjd`fjd`fjfjfjfjfjayayayayddayayddayddddayayayayaydhayayayayddayddddayddaydhbtdhdhbtdhdhbtdheefldieecwdabhbhgigecwcmeqapfs`cdbcb`caddyfgbz``fpdv```````k`kctctctctdocpbfcfcuaddgam`sdydy`sdydy`s`sdydnfc`w`secdnfpfhflcpfdckbgbmckckag`vdjfo`bcgekfnbabra`ca`jar`y`y`yfrfecsazfv`xerbqcpdbcbexdhfzdsdsa`a`bicfcbdb`celcjcjcjcjcjcjcjcjcjcjcjcjcjbnb``cb`de`ugfdwayb`gidkgfbcejcqdofhaiboew`hercdaecjaebtapbibifscpdidb`cacbnbne`cwc`exb`apb`fseecieqgf`p`z",
+"d`d`acd`d`d`fjd`fjfjd`fjfjd`fjd`fjfjfjfjfjfjfjfjayfjayayayayddayddayayddddayddayayayayddayaydhayddddddayddayayddbtaydhdddhddb`difleeapdkbodkgigecwaociapfseqdbcpapadecfkfgawdnbzdn``ek`kaaaaenenenenenflexcwgbdg`s`sdydy`sdy`sdy`sdybwdvdnec`sdydnfhfpfl`f`rckaebsckbkdm`lblehbl`mekfncscxa`gheyarbj`yaveecsblblbre`fjb`ffffeqbtbga`dsdsa`a`cfcbfl`celcjcjcjcjcjcjcjcjcjcjcjcjeleqflcbau`vezergi`udzdpcogfcz`uc`bofjexcieydkcs`he`asbgbgbt`cexdbfldeacbgaebm`hfwemczbcaueqeqciffbcgf`p`z`z",
+"aod`d`fjfjfjd`fjd`fjd`fjfjfjfjfjfjfjfjfjfjfjfjdhfjayayayayayayayddayddayayddddddddddddayayddddayddayddaydddddhdddddhdddddhddexdocpapggc`bhgegegicwapcibtapcidbeqdgadecfgfk`wfkaldnawekaafp`kendifldididoencpb`bfeaaqamdg`sdy`sdy`sdyfkdifpfkdydyfc``dvffbu`f`rdxaeaedxbkbldccsblahbbfn`ubrfzaeercycgbdbx`iafeuceewasdxao`cflexbtaea`fzdsa`bicfcbfl`cbncjcjcjcjcjcjcjcjcjcjcjcmcpflcbcybodxdh`ecbcqatejggc`fta`aecjcjcjcmexau`pgf`hehereheleedbeqgffacs`heher`ide`f`f`uemb`ciexeqgadp`fcgey",
+"d`aoaofjd`d`d`fjfjfjfjfjfjfjfjfjfjfjfjfjfjdhfjdhfjayayayayddayddfwddddddddayddayddddddddddddayddddayddddddaydddhaydhdddhbtfseqdocicwdkgggegigidk`hapexfseeeqffb`fjdgec`wfgeceacochfy````fpendifhfl`ceqcpffdodiciexeebfcwadaqdy`sdy`s`wfpfpbzdyecdbfcfcbzbzfccp`rdfghbgdt`o`gdcbl`tbdbbbbczbrcxaeer`ubjbd`p`ueybldxe`ghckd`exexfjaebifzdsa`dscfcidi`cbncjcjcjcjcjcjcjcjcjcjd`dbffb``vezerc`dodoclbcapfta`cjcjcjcjcjcjcjcjbgfsco`zcz`jcragdxaggiapdzbvaidzauejax`ugfaffrdbflbc`bepfrdz`zdpai",
+"d`fjd`fjd`fjfjd`fjfjfjfjfjfjdhfjdhdhdhdhfjdhfjayayayayayayayayddayayayddayddddddayayddddayddddddddddaydddddhddaydhdddhdddhapdben`cfjbogiczgigedkcdeaeqb`apexcpeegbaqdy`w`sbfczalaw``fpfpctendiendb`capeefs`ccpdbcp`cbtbtfqdg`s`sdydyecfcdidnecbzdvdbfcbzbzdnfhcqaxcycmaebmag`gazazah`ybbegfabrfzaeer`pbdbjejey`vab`oerehdtca`cbtaebgdsa`a`a`elcidi`celcjcjcjcjcjcjcjcjcjdddb`edddmgfbccpdiaiapfta`cjcjcjcjcjcjcjcjcjcjcjcjcjel`cdbbuczdqewf`dxezaxbucqfrfrepfaembedpflfndz`j`jejep`f`fb`b`",
+"aod`fjfjfjd`fjfjfjfjfjdhfjaydhdhdhdhdhfjayaydhdhayayayayayddayddayddddayddddddddddddddayddddayddaydddddddddddddddddddddddheedbenci`ccogic`gidkdaewggcpb`ap`cfffs`d`sdy`sdgaqbwfuchatfpenenenenctfffsdhdhacfjeeexcpffeq`c`cex`wdy`s`sfkdvenfc`ndnfpdibzececfkaw``dbaxcycacjdtcs`tazahahbjbbatfaeba`bidwdzbvepgg`vce`hehehcae`dhb`bnaea`a`dsbibneqflexcacjcjcjcjcjcjcjaefsdidedwgfalflfh`edabicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjdhdodbcbgiezdqe`ezemembccoep`jejcqcqaiepbeepfrdpcq`fc`acdtas",
+"d`fjfjd`fjd`fjfjfjdhfjdhdhdhdhayayayayayayayaydhayayayayayddddayddddddddddddfwddddddayddddayddddaydhdddddddddddddhddddddddb`fldocpexcodegigegidafbexexeefseqdbbtfbdy`saqaddadefkfu``aactenfpdododieecmcabiel`dbtap`ccpffdbcpcocofkaq`n``endi``dvdifcdy`s`sdydydydnbu`rfscmbiewbl`tahahazbjatfnamebfzbidwdz`z`uemabduehdaehdxcfapfsbiaea`dsfzbnexdieq`daecjcjcjcjcjcjfsdi`cerejfhfhbccaaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaccp`eejfndpczbobo`bafem`bczfnfhdicqaudzgacqdbdp`e`iehbmbgasbg",
+"fjd`fjfjfjfjfjfjfjdhdhfjayayayayayayayayayayayayayayayayayddayddayddddayddddddddddddddddaydddddhddddddaydddhdddhdddhddbtdheefldieqexggeqapgegidadacofsfsbtexflbtfbdy`samadfbc`bwalaw`kaadofhfhdicici`celaecjaebicfd`cidodbdbfhdv`nfkfu``doenfpfhenfkaq`s`saqaqfqea``buexbqcabmew`g`t`yaz`taregbucecxa`bifwdzepb``beher`idkdxcacmb`d`aea`a`gccdexdieqcmbgcjcjcjcjbib`didbexffdo`facaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaccbggemfrbveg`zbcgigidw`b`bgfejepdzgacqcqdp`u`i`bagdtbiasdtbncd",
+"d`fjfjfjfjfjfjfjdhfjdhayayayayddayddddayddayddayayayayddayayddayddddddddddddddddddddddayddddddaydddhdddhddddddddddddddddddeeflflcicibcdeggapgeboapcifsfsdheqflfsgbdyaqadgbftd`ggbu``ekdo``fhenenffb`b`btaecjcjcjbiaccpdocpb`ciffbubuchflfpfhflfcfhcpeadyecbwbubueqcocbcib`ddbnbg`xfvaz`y`tfv`y`zcoabcxa`cf`ibeeyczerghcv`idaf`ghca`ccfcja`gccdeqdbcpfsfsexbtbgelcbdidodbff`fc`bicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjd`cbb``j`zbvep`zfnfncbczdweh`hdk`vgfaicq`udae`e`dxdxghe`ghcmdd`edb",
+"fjfjfjfjfjfjfjfjdhaydhayayayayddddayddayayddayayayddayayayayddddayddayddddddddddaydddddddddddddddddddhddddddddddddbtddddddb`diflcbcieqbcbuczdkbhemciapapdhcpdbbtadaqamadftgcgcdgbwfc``fpbuenfhctfleecmd`cfcjcjcjcjel`cdidbfsfqee`ceqeqfffffldvfccbcpdifldoendobtbicdgbgifd`cfjcjbsgd`gfvarfvfvar`pbwducxaecm`rbebeapghf`ddfwerehbiacb`ela`fzcdeqcbfldidofldbexcbdbcbcpexd`biaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjddcbfs`bbvdz`jdzcqatfnbvfngaaobnbgedbhbcdwdtbibncac``ub``cdeaudz`zat",
+"fjfjfjfjfjfjfjdhdhfjayayayayddayddayddddddddayddayayayddayddayddayddddddddddddddddddddddaydddddhddddddddddddddddddddddddddb`diflcicicofccoggdkcwbfeqapeefsdbcbfqadaqdggbcucdcdfbaqdnfcchfcaaenenenb`cabncfaecjcjcjbgd`dbenflexexcpcicpdbdvflfhdncbflfldbdododidhcjcjaecudd`cfdacaebm`xducscscefvdcepfkcucjaeagcybeeydddxergigiagelaefseqcadselexciflcbeeapapdbdoeqb`btaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaefscpcmgccrepbebegagafregegfnfneqapaobibmererfjfsb``ecbcicpbuepfrbdegeg",
+"fjfjfjfjfjfjdhfjdhfjdhayayayddddddddddayddayddddayddayayddayddddayddayddddddddddddaydddddddddhdddhdddhddddddddddddfsddbtfsexflcpciciffcpdegggeewcw`capeeeedbexfjamaqadgbcucdgbdgdgbf`nchfubb`kaactbubf`daecjcjcjcjcjbiapflenenctdofhflctctaafhbzecbzflctendoffbtcfbiaeaegcfjeebccmcjbmduduckabcefvarepczaecjbgeobebeczaoe`aocr`bghbsbieqcpcagcexcifl`cbndddzexffcibicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbtcpcmaeezeybefa`jfrfn`zdzbqapaycacadhd`cmbhbtayfjdwerbsaeacexflbb`p`jbv",
+"fjfjfjdhfjdhfjfjdhdhdhdhayddayddddfwddddddayddayddddddddayddayddddddddddddddddddddddddddddddddddddddddbtddddddddbtddfsddfsexdicbffflflcbdegfbhbica`capee`cffb`fqam`sdggbcdcugbeabwam`sbzchchbb`k`kfhcb`caccjcjcjcjcjcjbnbtffdoenfldn``fpdofpawfu`wec`wexcbcp`c`c`capfjcfaea`gbbc`cbnae`ogd`ockabce`g`j`zb`bicjaefebebec`e`e`dwc``icabgcfcpeqca`cexflcica`uflcybceqacelbiaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjfjcpacbgdqey`uem`jfncqdefjbicjcjcjcjcjcjbncacacfbgbmbmaecjcjcjaefj`fdeeh`j",
+"fjdhfjdhfjfjdhdhdhdhdhayayayddayddddddddddddddddayayddayayddayddayddayddddddddddayddayddddddddddddddddddddddbtddddddddfsapeqdoeqexdoffcoc`adewa`ftb`eeeeexdb`cd`aq`sdggbcdcdgbadfkdn`w`wfuchchekbb``fceqapacaecja`bielcuadecbzeq`w`wbz`nfgbz`wfkfgdyadaddg`w`w`weceaeabtbtcabneabu`cbia``xduefckabebboepcqapcjcjbgfe`uc`aodtdx`ico`ughae`dffexeqexffffgigadpcyaidbdicpexfscfbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjacff`ccfckcreybegadvbcftaecjcjcjcjcjcjcjcjcjcjaebibibicjcjcjcjcjcjcjcfeq`cdk",
+"fjdhdhdhdhdhfjdhaydhayddayddaydddddddddddddddddddddddddhddddayddddddayddayddddddddddddddddddddddddddfsddddddddfsddfsfsbtapciencp`cdbdvcodkfbgcaed`exb`apeqdb`cad`s`samgbel`a`ddg`sdvdvch`wfgfg`nawchchfgbaba`sdgdgdgadamdy`wec`sadgbgbfbcucugbgbgbcufbgbdg`wdnco`saqamdgadcwad`sdndv`cbgdsdu`xe`cke`dtdk`zfhaycjcjbmfwfwcwcfbmeobcdpdecfaefsdbcpapcbflcpdbdzbc`zfldiclcqdvcpex`capdhaccabnbnbibibgbgcjaebgcafscifscadxdwcrdzfpcicwaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbn`cco",
+"fjfjdhfjfjdhdhfjdhayayddddddddddddddfwddddddddddayddaydddddhddddayddddddayddayddddddddddddfsddddddfsbtddfsddddfsddfsfsddeecbdodbcicpdb`egicweda`fjcbb`btcidb`ccaaqecaqfbgcgcgbad`sbzfhfhawbz`nfk`nanchchanchan`nar`wec`wbzbzdygbelbibibibibia`bgbibigccdgbamdndifc`necaqamaqfkfkbzfcflfscjgc`xdtdtcke`e`cyfhdofjcjcjdxfecmcmbndtcraxcq`eelcab`cpcicpfffl`e`fcqclfldpfrbvfrfrfrauaicbbucpcpcpciexci`cb`eeeedhcmcadteh`b`ubucpddbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgee",
+"dhdhdhdhdhdhdhdhdhayddddddddfsfscvfsfscvdddddddddddddddhdddhdhddddddddddddddddddddddddfsddfsbtfsddddddddfsddfsddfsfsfsddeecpdodbcpdbffgggggieda`dhffb`dhciflexelam`waqgbcdgccudg`sfkfcfpenfhfpfcaw````ekfyfybb``````fpdbdn`cgbgcbibia`aeaecjcjcjcja`bibigccdcwfkdbdofcbwecdyecdyfkdndnfffjcjbmdtbsdtcke`ezaienffcfcjaef`dff`cfbgdxcraifhb`elbnddbcdicpdifhdididiaxbqcbfnfnegegfrej`j`jgffedkddayfjaoftelelckftdtewbodefhcicfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjae",
+"btaydhbtbtddfsddfsddfsfsfsddddfsddfsfsdddddddddddddddddddhddddddddddddddddddddddddddddddddbtddddbtfsfsfsfsfsfsfsfsbtfsfseedbdiexdbdicpczgabfewaefjdbb`fsciflb`bnbffkdygbcdelgbdgaqecbz``fpenfhfpfhaaenctenenenenenfhco`wecam`dbia`aeaea`bi`aela`aecjbifzbibicdgb`sfcdv``dnbwecdy`sdyfkfccicfcjbmbmbge`ckbkafcqdo`ecfcjaeageoerbnbgck`iaiflapbibielfdflfldiclbcapex`cex`fcpdpcqatfnfr`pem`bdwfe`bfwgigfdw`heoehe`gicoclbqbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ddbtdhdhdhdhdhdhdhdhayayayddddfsddfsddfsfwfsfsfsddddayddddddddddbtddddddddddddddddddfsddfsb`apddddddfsbtfsfsbtfsfsfsfsfseeffflexfldbcbcoeqgicdcjfjdb`capcbffeecfec`ndyadgbcdgbdg`sdyfgchawfpaafpflfpfhctctcten``bzececececamcdaeaegccdgbadgbgbcdbiaea`bibielcugbgbamcofcdnfcfpdn`waqeaawfc`cbmaedtbmcje`bkfegafhcpaxbncjbge`bncfbibmckfeaiflfsbnbnfeaiflflb`bgcjbiaoexcpde`icybc`fdpfnfnfnfr`eejeyafaf`bdfbkao`cdb`ccacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ayaybtdddhdddhddddddddfsddddddddfsfwfsfsfsddfsddddddddddddddbtddddddbtddddddddddfsddbtfscbdodb`cfsddddfsfsddfsfsfsfsddfseedbdicicbflcbfcczdkeda`apff`cfscbfffscabzbzecdggbfbadam`sdy`wfk`nch``aaenenaafpfpdi``fk`wfk`w`wecadcdgcfbgbadadadadgbgbcdgca`bigcgcfbgbadaddgbwdnbzdnfh``bw`wfcawbub`aebgdtbgaedxfocycqcqdpbqbgcjcjbncfcaaebgdt`bdpflcyfeeofdclclfjcjcjcjcjcjcfayeeapcvfwfw`i`uczgiboehftewe`agf``iff`eaccjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aodddhdhdhbtdhddddddfsfsfscvfscvfsfsddfsddfsfsfsfsddfsddddddddddddddddfsddddddddddddfscictdocici`cbtfsfsbtfsfsfsfsfsfsfsb`dbfleeeqflfl`ec`daelgceedbb`apcpdbbfd`dvbzecamadgbad`s`sdydy`wfk`nchfyfp`kfpfcfcfcbz`n`wecec`s`samadadadadgbgbgbeaaqgbcucdgcbibigc`a`dgbgbaddg`wbwbzbzfc``fp``fc``dvapbmbsdtaebgbkfedzfl`f`fddcjcjbgelelcdcjcjdxcy`fcpcicrcydpcob`bicjcjcjcjcjcjaecfd`fjfs`icvfwerefe`bmcjaeckggffapbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgelfjdhdddhdhdhddddddddddfsfsfsfsfsfsddfsfsddddfsfsfsddfsddddddddddddddddfsfsfsbtapcpdoffcpd`fjciapddfsfsfsfsfsfsapfsfsb`didbeeeqdbdiggbcbhcucdapcpb`btcpdieebtdvdn`wamadadam`sdy`sdyec`w`nbzchchdnchbzfkfkfkecdydy`sdy`s`sdggbdgadeacocpffcpbweaadcugcbibibigccdgbgbadbf`wco`n`wfkdndnbzfcaafhczeldtbmcjdtfoeudpclbecid`cjcjbibielbicjeweybe`fcpax`udpauciaccjcjcjcjcjcjcjcjcjcjcfcaacdd`icycyddaccmbccbaccjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaebgbncafjddddddayddddddfsddfsddfsddfsddfsfscvddddfsfsfsddfsfsfsddddfsfsapapddfscpdo`cbnb`cifsb``cbtfsfsfsfsfsfsfsfsap`cdidieqeqdvfh`cejczdq`deecpb`fjcbdieebtfpdnfkaqdgadamdydy`sdydydy`wfkfk`nfk`w`w`wdydy`s`s`s`s`sdyecameaeqcpciexeqfldoendbbwbfgb`agca`bigccdgbgbdgdy`wbwfkdy`secdy`nfcfhdob`e`dtbgcjckfecyclaidr`ecacjcjbibnelbgewemafcyai`f`fcibcffeecjcjcjcjcjcjcjcjcjcjcjcjcjaebielcfelbibnfjcacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bibgbibibibncad`dhddfsfsapapbqbqapcvfscvfsfsfsfsfsfsfsfsfsfsddfsddfsfsbtfsapfsfscidocibibg`cdoff`ceqeefsfsfsfsfsapfsfsapexdodiexeqcpbucoczdedkcwb`ff`cfjcbdiapbtdvdnbzecdgdgam`s`s`sdy`sdy`w`wfk`w`wecec`s`s`sdy`sdydyfkbz`cciflcobtelaebgd`ex`ccpenflbwadcdbibibigccdgbaddgdyfkfk`w`s`s`sdy`wbzfpdifse`dtaeaeckezbecldzai`cbncjcjbibnaebibo`beyai`eaiffcicpeeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"`daeaebnelcfcfcfcmdheeb`eeapcvapfsapapfsfsfscvfsapcvfsfsfsfsfsfsfsfsfsfsbtfsapexdocpac`dexb`ciflciexb`fsfsfsfsfsapapfsapexdifl`ecoggggbuczc`ddd`b`cp`cdhffdibtbtflfcfc`naqamam`sdy`sdy`w`w`w`w`wecdy`s`s`s`s`s`s`sfkfcdbfldienffcmcjaebiaebnd`cfcfeeffdv`cdggbgcbibibigbamdgamec`w`wec`sdy`s`secchdofldwe`dtaebse``bdpclcyaieeaecjaeghbicjewdu`idr`fax`fcpfsbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"fsfsfsfsapeeb`fd`ceeapapfsfsfsfsfsfsfsfsfsfsfsfsfsfsfscvfsfsapfsfsfsfsapapap`cdidi`cbfcodkgccmdbdbexexapfsfsapapapapeeeeexdidocpc`gigibwdegibhfqb`ci`cfsdbdiapfjdnfc``dndyaqaq`s`s`sec`w`w`w`wdy`sdy`sdy`s`s`s`wdndidodifldodoflcacjbgelbifs`cbicjcjca`cdvcoaq`dgca`elgb`saqaqdyec`wecdydy`sdy`s`wdnencpf`e`dtbgdteh`ufldzcy`faocjcjdte`cjcd`hercygadbdicpcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"eeb``cb`eeapapfsfscveebqbqeeeecvfsfsfsfsfscvfsfscvapfsapapapfsfsfseeapfsapapcpffdvcochfadudufsffdoffexb`fsfsapfsapeeapeecifldbeadkgigeapauggbhdh`ccpeedhcpfleefjcifc``dn`w`s`s`secdydyececdy`s`sdy`s`s`s`secdnflctdodbdododododoeecfcfcacfapeqelcjcjcjbgbtcbexdgfbgcgcdg`sdy`sdydy`w`wec`sdy`sdydyfkawdobcdxdxe`bme``bcq`f`bcycicfcjbgdtdtdqgfeweo`q`fdicpcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ddddddfsddfsfsfsfsfsddfscveeeeeebqbqcvfsfsfsfsfsapfsapfsfsfsfsfsfsfsfsfsfs`cdbcbfh``ardcdcdndvfs`cdocp`capfsfseeeeapapeecbdbfffsbhddgigegf`cbhbh`ccpbtd`cpfleeacbzfcfcfc`ndy`s`wbzec`sdy`s`sdy`s`s`s`s`wdnfhctctdoflffcieqexeqcbcbcbeqex`c`ceqeebtddaecjcjcacbbueagbcdaddydy`s`sdyecececdy`sdy`sbzbzfkdvdoapdxcke`dterepclfwagbcaxbncjbse`dabyboag`rcldoclcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ddfsfsddfsfsfsfscvfsfsapfsfsfsapbqee`cb`bqeebqfsapfscvapfsapapfsfsfsfsfsfsexdbfffhfudcbbaaatdnfb`dcidiciapapapeeeeapeeb`cidbffddbhdkgegibfgibobhexcbfsfjcbdib``deqfcfc``bzdy`sec`wdy`s`s`sdy`sdydyfkdnflenenfldveqbwecea`sam`samameaeaeabffqacfjfsexb`elcfapbudifheaadaq`sdy`sdy`sdydydy`sdy`s`sbzbzdychendicvdxbkbkdx`bdpexghezdz`cbgcjdteh`v`pafeucqflaxaccjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ddfsfsddcvfsfsfsfsapbqeecvfsfscvfsapapeeb`fdb`bqapfsfsfsfsfsfsfsapfsfsfsfsexcbffdnfgfy`kaa`kfuejap`dffdoeqeeeeapeeapapb`ciflfffsbhddgigigegibhbfcoffapbtcbdbexaccodndv``dnecdy`s`s`sdy`sdy`sdy`sdybzdndnenenfffkecec`w`w`wfk`wdyaqaqamamdgad`d`acubfcocpcp`cd`fjfkcidy`sdy`sdy`s`sdy`sdydy`sdy`saqdgamfk``dodbddckfwdfeheycqaybife`fb`aeaedxbhepaifdcifdcvfjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"ddfsddfsfsfscvfscvbqb`fsfsfsapapfsfscvfsfseeeefdb`bqapapfsfsfsfsfsfsfsfsapexdidveafn`kbb`k`karfabwbtapdidocieeapeeapeeb`eqffdbapbhgegigigigegegfcbdbb`d`ciffexd`eqbzfc``fcfk`sdy`s`s`sdy`sdy`s`sdyececdndbdnfk`w`wecececdyecdydydy`sdydydydy`sdgaqaqecfcbzgbgcelgbeadnbwdy`s`sdy`sdy`sdy`s`s`s`sdgadadambzfpfhffaoeofwbkfegacbbnbm`idpapcje`eyfrdpdpcpbqd`d`bgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bqapfsfsfsfsfsfsfsapapcvfsapfsfsapapapapapapapeeeeeeapfsapapfsapfsfsfsfsapexdoflfffpbbeken`kei`tdcde`ccpdodieqeeeeapeeb`ciffdi`cdhgigigegigedkeabudbb`dheqdbeq`dbwbzcofp``dnec`s`sdy`sdy`s`sdy`s`s`secfk`wececdydy`s`sdy`sdy`s`sdydy`s`sdy`sdy`sdydy`sdy`samadadgbdg`cfcbzdydy`sdy`sfkdndydyaqadgbgbgbdgecdn``fhcp`cfjbkfo`jatapaeefcy`facbg`bdr`zcqdocbfjd`bicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"exfdbqb`b`bqapapapbqeeeeapapapbqbqapeecvfsddddfsbqb`eeapapfsapapfsapfsfseecidiffffflfpaaenbbccccdcdceqfldodofleqb`fseeexdbenflapfjgigigegigidkbfciff`cfseqcpeqcwb`dnfkfc``fcbz`wdy`sdy`sdy`sdy`sdydydydydy`s`sdy`sdydy`sdy`sdy`sdy`s`sdy`sdy`s`s`s`sdy`s`sdydy`s`saqecdnfpbzdydy`s`secbz`sdyaqgbgbfqadam`sfkfcfpdidbfje`ageugacpcacjckey`eerdteugaaicpcb`cdhaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cmdhdhfsfdexexfdfd`cfdeeb`b`bqb`bqapeeeecmbgaecaapbqb`b`apapeeeeapfsfseeb`exexfldbdvfhctctbbcccccccc`gggflendidbcbb`exdbdiffffdhaogegigigedddkgicodbexbt`ceq`cdhbfdnggbzfp````dnfkdy`s`sdy`s`sdy`s`sdy`sdy`sdy`s`s`s`sdy`sdy`sdy`s`s`s`s`s`s`saq`s`s`s`sdy`s`sdy`sdyecbzfcfcecdy`sdy`s`sdy`sdydgeadveaam`sdydn``fpdicierckfobedpdebibgck`u`eftdxbebecv`ccbbtaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebscfbnelayeeapapapayelf`apcvapapapcvapaoaeaeckeeeeeeb`b`eeapfsfsapfsapeefseecicibccqaact`k`meiccccccfaeacpdiffdbdbdodo`c`cdbbtcwddgegigedkdkgicidbeqfseeexb`eefqci`wfkfcdv````dnfkdydy`sdy`s`sdy`sdy`sdy`s`sdy`sdydy`sdy`s`s`s`s`sdy`wfkbzbzbzbzfkecdy`s`sdy`sdy`sdydyfkbz`ndy`s`sdyaq`s`saqdgadamdgam`sdyfk``fpfhdocpfedxfwbeclfscjbsehcyaxacdfaffe`ccpbtcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaecfelcjelapapfsapaocjbgayeeapeeapapbqaybscjcmapapapee`capfsapapfsapeeapapfsb`ciexdbdvataa`kbbccccccccbofqeqcpeqendocbexffdoeeacddgeddgedkbhc`coffcpeeapeqb`b`gbbzbwecfkfcdien``bzfk`wecdy`s`s`sdy`s`sdy`sdy`sdy`s`s`s`s`s`secbzdnfcflfpendodofpfcdnbzfkdy`sdy`s`saq`sdyec`wec`sdyaqamamamadgbcacugbam`sdy`wdn``dodoenexckfoeuaidpcfcjbmagdzaxfw`ibedbdbfsbgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cjaebscfbgbgfseefsapfjaeaeacapcvapapapapapcacjcaapapfsapapapfsfsapapapapapapapapexcpdvfhdv`kenaaaneiccccdcdubteqfldoflfldbdienb`dadkgigedkdadkczbudbcpexb`cbb`exfjecdnggecbzflfpfcawdndnbzbzfc`n`s`sdy`s`s`s`s`sdy`sdy`saqecbzfcdnflenenfhfh``dnbzbzfkfk`nec`s`sdy`saq`sdydydydy`sdyaqaqamadcugcgcbngbdg`sdy`wbzfcendododifdfofe`jdpfdbgaeckeuga`fdr`fdidiffcacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aecjaeelbnaefjbqapeefjbgaeghfseeeeapapapbqd`aecaapapapeeapapapapapapapapapapapapeecbdidofl``aaaaaabbccccccdceaeacpdodiflffdbdoexfjdkddgebhdagec`buflcpexb`cbb`exapeabzfkec`wdndv``dnfcfcfc``dofc`nfkecdyfkec`sdy`s`sdy`s`sdndvdnbzdnfcdvfh``fcfcbz`n`w`sdydydy`s`sdy`s`s`sdydy`sdy`saqaqdg`dgcaea`elgbdg`s`s`wfkdnenendodbdbaxfweufrcpdwaebmfecydrcpdidododoapcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaedtcfbge`apbqapddelbsdtfsbqeeapapbqapaybgcaapapeeeeapapapfsapapapapapapapapapb`dbdodicq``aaaa`k`mei`manahgebfcbdoflcbffeneqbhbhgedkdabhgigiexdbcp`cfscpb`eqb`fqfkbwececfkfcfpbzbzawawfcfc``fcawdnbzfcbzfk`wecdydy`secbz`w`wfkfkfk`w`nfcbufcdnfk`wecdy`s`s`saqaqamaqaqaqamaqdgadgbgbcadgbtgccdgbadam`sdy`wfkdndoctdoeqcbctaxfwbegacicmaee`fwbe`fcqdidodocpelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebgaebgghbnbgaob`apbqaobsbsddbqcveebqapeeapbnelapb`b`apapapapeeapapapapapapapapapb`dbdbffdifhfpfpaaaaek`m`m`mar`gdgcbdocpciflexbhaygibhdadkgeapbcffcb`cfsff`cci`c`deabz`wec`wfkdnbzfkbzdnbzbzchdndnawawdnbzbzbzfk`w`w`wecec`w`w`w`wececec`ndnfkdnbz`w`wecdy`saqdgdgdgdgbfamaqamadcwcubngcb`exgbgbadam`s`sdy`wfkcpenctdi`ccidifl`rafcy`ecybscjbkfxdrcqdoctdodieecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaebgaeele`bgghbqbqapfscfaecmapeeapeecveeapcfbgee`ceeeeeeeeapapapeeapapeeapeeapeeexdidocpcldofldvfpaa`kbbbdeiccardcfaeqdiflcpexfjdkdkdqbhgegigiggcpcpcbfscpcbdbcoacgbecbwdydy`wfkbzfk`wfkbwbwecameafkfkfkfk`w`w`w`w`wfk`w`wfkfk`w`wfk`wfk`wfkfk`w`wfk`w`wdy`saqdgdgdgam`sdyeaaqdgbwbfcdcdfqdgdg`s`s`sdy`sdyfkfkffdiendib`bcdbdodbdzafejcbcmcje`dfcycqdododidbcpcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaebgbgbmelbsbgayb`eebqacbsbmfseeapeeeeapbqddcmb`b`apeeeeapeeeeapapapapapeeeeapapexdocbbuclflcqalal``at`k`kbbeicceidcgedefldiciacbhdadadkgidkapc`eqdbffdhcifldicpdhcdaqececdydyececfkfkdyamaqeaeadg`sbf`saqamam`secececdyececdyecec`w`wecececececec`wfk`w`wececdyecdyeaec`w`weceafkbfamamamam`s`sdy`s`s`secfkecfldbctdbeeexdbffcldbaibecbb`bmdxfecy`fdbdbfleecpeecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaebgaebgcfbsaeca`rbqbqfse`bsayeeeecveebqeeeeapb`bqbqeeeeeeeeeeeeeeeeapeeeeapeeapeqflfjcydidoflcpej`uaw`k`kaaekan`mei`gfgawawcicwcwdabhgigegigeapcodbcpbtexdidodo`cd``dgbdg`saqaqaqdy`wecdydy`saqamaq`s`seaambf`s`s`s`s`s`s`s`s`sdydydydydydy`s`sececfk`wfkfkfk`w`w`w`wecfkfk`wfk`wfkfk`wecdyaqamaqam`sdydyaq`cflcbencpfjexcpeqb`cidbdrbccpaydffw`rai`fcpffb`cpcpcacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaebgaeaedtcfaebgfjb`bqbqfjbmd`bqeeeebqbqbqbqb`fdeefdeeeeeeeeapeeeeeeeeeeeeeeeeapcpcpe`ezcqdi`eb`gabzal`z``en`kbbek`m`meibdbbfcbhfjdkdkgegigigegicodbcpddfsffflfldbcpexbfcfelcucucdgbamdyec`samaqam`s`saq`s`saq`sdydy`s`s`s`sdy`s`s`s`s`s`s`sdy`sdyececececececececdydydyececececececececdydyaqdgdgdgamdggbadcpcpexenexca`ccieecffsciffej`ffdfweu`fdbfldoffcbdidi`ccjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaebgaebscadtcje`b`bqeeapghcmapeeeebqb`bqeefdb`b`b`eebqeeeeeeeeeeeeeeeeeeb`eeb`dbexefcr`fffb`gi`fenflfkbaan`k`kekekbb`m`mbbcqapbhdkgigigegigidkbcdbff`ceedbfl`cb`fffffleqfqelca`del`acacucagbgbcwaddgdgdgdgam`sdy`sdy`sdy`sdy`sdydy`s`sdydydydydy`sdyaqamamamdgamamamaq`s`sdy`s`sdy`s`sdy`sdgadadam`wfkexcbdoex`cdiapcm`cexapbgghbq`ecbdpcpfwcvflctdodocpcidbdiffcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaedtelbgbgfjfdeebqaoacbqbqeeeebqb`fdb`b`b`bqbqbqbqeeeeeeeeeeeeeeeeb``cexfffsasaf`ecibqb`clfldodbaubafuekaa`k`m`mbbbbekb`bhgigigegigegibh`cdbdbcidhdbdocpeq`capfjeecbcp`cbtfqbtbffjcfbibigcbnelcdgbfbgbaqdydy`sdydy`sdy`s`saqaqaqaqamaqamaqamamadadadadadadadadadamaq`s`saqamamdgamaqecbwbuffffcbffctdoex`ccbfjfjap`capbia`fbeeexcbflaxdd`fcpdoclcbcpcbdidbexbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaebnelbgcab`bqeeapayeebqbqbqbqb``cb`fdb`bqb`bqbqbqeeeeeeapeeeeeeee`ccicbehajcyex`c`c`cfdflclcldofhffchfuekaa`kbbbbdvggdkgigegigigeddbhggcpdbcpbt`ceqciflflcpap`dd`apexcpcpcbexapbtapb`eeapbfbffj`d`daccwcwadaddgdgdgdgadadadadaddgadadadadadadadaddgbfdgdgbfbfaq`w`w`weabwbzcbdvdbffcpeqcbeqb`cbendoffcbex`dbtacexeafzgcgcfbb`bcexclcicpcpfldbffffcidbdbfffjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaee`cfdtddb`b`bqaybqbqeebqee`rex`c`cb`b`bqbqb`eeb`eeeeeeeeeeeeeeb`cbexghevbccpexcib`cpctcqdpdpflctdofnfnfpaaaafpcqbcddgegigegidkgeddczcbffflcidhcacafseeexcpcpeqexexcidbdbcpcbcbffcpcicieqeqexggb`bwex`ceq`cee`ceaea`c`cb`eceaeaeaecggbwcodnbubufffcdvcpfcdbdbdbcpcbcbcbexeefsbtbtfsapeqcicbcpdiflfldi`cd`fjcfeqfsgcczbha`gidbb`eedbdicpeedbdbeqexffffcp`cbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aecjaeaeaeaeaeaeaecfbngheefdb`bqfsfdbqeeeeb``c`cfdb`bqb`b`eebqeeeeeeb`eeeeeeeeeecpex`odfcicpexcieqdodododbeycygadienenfhdodofhfhcogiddgegidkgigigebfcidbfldieqdhd`fsfsfseefsfjeeexexcbcpffdbffffcieqffdbdbffffcbex`ceeb`b`b`eqcicbcbci`c`ceqbucpcpex`c`ceeeebfbfbtbfbfapeaeab`eeapbtbtfsfseeb`exeqeqffdbdbcpcbcpdbfl`cddaccmcbbffzgieabgftciexaycidocpddcidiexcbcpdbcicbacaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaeaebscfghdhb`fd`cfd`ceebqbqee`c`c`cb`eebqbqeeeeee`ccbflcpb`eeb``ccpapckcrffciexexfldododiai`odlesdzcqdicldidicldidib`dkgegigegidkdkapffdifldoflcpeq`cee`c`cb`eefsapfsdhd`bt`cb`b``cexeqexb`excicpcbffffcpdbffdbffci`capapapb`cicbexapfjd`d`fjdhfsbtap`cexeqcpdbcpcpcicpeq`cb`b`b`fsbtbtapb`eeb``cexcbeeapdheeffaoa`bigcbga`elgib`b`didbfs`cfldbdbcpflcicp`ccfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaeaeaeaebmcffsb`b``cfdbqbqee`cfd`cb`b`bqeeb`eeee`cflffex`ccicicpdbflcvdlemffexcpcpdidicl`pezaefidlfwfldbcpfhdicbdbdbc`dkdkgidkgigidkboexbccpdiflflfldbcpflffcieq`ceeeeb`apapapfjbnbgcaacdheeapfseeeeeeapdhfjbtapee`cexexeq`cexcicicieqexcicbcpcpciexeeb`eeapapapdhfjfjd`cfaecfd`btd``dd`btddbtdhdhapb`dddd`cciciewa`a`a`cjcja`gcdhapffcp`ddhcidbffb`dbcbeqcbfjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaeaeaeaeaebnfjeeb``cexb`b`b`fdeeeeb``ceebqb`ee`cfl`ccabicafs`ccbdbdbfw`ocyffcidbdidbdodzdjajaeajdldmflflfldiflcpdbffbtbhgigegigegigidaapfbeedb`c`ccicpcpdbdododododbcpcpcieqexb`btee`cb``c`ceefsfsbtbtfjcmcmd``dd`accfcaelaebicfcfcabncfd`dhfjcmcmcmacfjdhfjd``d`dacac`dcfacdhfjdhfjd`btddfjfjfjfjapfsbtb`eqcieebia`a`aecjcja`a`gcdhffapaebnbtciflb`exdbexcpeebgcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaeaebgaeaeaeaeaeaeaeaeaeckb`b`b`ex`c`cb`b`eeb`eeb`b`b`ee`ccpeeelbicacaelbicfeeggckab`cffdbdododiflav`lakdsdldlfeflclflcqclciffcbcwdagigidkgigigedkdafbczdi`cgigibtdhbtb`eqeqcpffffdbdbdidoendododododidiflflcpcpcieqexcicpeqeqex`ceefjacfjbtdhbtfjfjbt`dcfcmd`btfjfjaccacad`d``dcfelacdh`dcmd`fjddddfjfjfjdhbtfsee`cffcpb`cmdsa`a`cjcjcad`fza`aocbelcjbgca`cexffcifleqcpdbfjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebgaeaeaeaeaeaeaeaebgaeaebsfjb`b`exax`ceeeeeeeebqb`b`b`b`cifs`d`dcdgcdsa`cjel`cdhdldm`edbdbdoffdocl`j`lakfiakdldjcldpga`fciexcicpaocwgigeddgegigegidadab`fhdegigidkcwcmft`dcwdhfsbtdhd`fjbtfsapexcicpfffldododododbcbcbfffldidbfffffldbffffffffffdbffcpeqcbffcpffcpeq`cee`c`ceeapddfsb`b`dhfseeb`eeee`cexee`cexcpdbfldidbd`aea`a`a`cja`apapdsa`bhcibibgbibiacbtdbdbffcpcbdbexbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaebgaebgaebgaebgbgaebsapfdexex`cb`eeb`b`b`b`b`b`cicpcmdhfjfza`a`a`a`ftexerajfwcbcbcpcpcidibvavesajfiakdley`f`ffdaici`ceqfffsacdkdkbhddgeddgebhboc`dbgggebhgieqc`bhdadadafjaoftcfcdcdbnaeaebicf`dfjfjfjbtapb`exeqcbcbcbexb`apfsfsfsfsb`exb`eqcpcbffeqffdbffdododbcpdiflffffdbcpcpexexcicpcpcpcpffcpcpcpeq`ceqd`dhb`gcaedsa`a`aefzbhcua`a`fseqbgaebibgbid``cexffflfleqcbcfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaebgaeaebsbsaebsbgbgbgaeacex`c`c`cb`eeb`eeeeeeb`eecicpd`fsfqbnfza`dsdscw`cftdlcycpexcpexcbdidzcnesdlefakab`qfdbebe`eex`c`ccbdbeqc`ddbhbodkdkdkcwdaeaflggbhbhcodoeqgiggc`boggc`dacwda`hcubibgbnftacftcfgcdsa`bibibielcf`dd`fseeeeb`exexexcbcicicpeqeq`cexcpdbflflffciffexaoca`dfj`dcfeleldhd`cacaelelelbnbgbidhgccuapelaea`a`a`a`a`dsa`a`a`eeexaecjaeaeaecffs`dcpdodoexcibtcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaebgbsbsbsbsaebgbscfb`fd`cexb`b`b`eeb`b`b`eeexcpdhbtbtcdgcdsa`dsfqggefevbccbb`ci`cffcqavetbpfidlakeuaifweuaxax`c`c`cexflflcpeqeafjbhcwcwftfbgiffggbobcfhdogaapffffggflcodkdagiggeacucdgbczb`cwfteldsa`a`cjaecjcjaea`aea`bibielcdd`dh`cex`ccbcpflfldidicpdbdibcfqb`apbiaebnbicjcjcfeecdaeaefzaeaeaea`a`bfftdagggca`a`dsa`a`a`a`a`a`bg`c`cbgcjcjcjcjbgbtcffsdidocbciexaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebgaebgaebgaeaebsbgbgaebsdtelcab`b``cex`ceeb`b`b`eeb`ee`ccpb`fjbt`dcda`fzelc`gifiabex`c`ceq`cflbuavesakfiakevbedz`bbyci`e`cb``c`cexdbdodbdbcp`cfjghcddaggdbdeczflendodvapfcfldodifldegicbbubqaccuggfhbudafbcdedfza`dsa`aea`a`a`a`a`a`a`a`a`cwbtcdbheeexdbdbflexcicpexexeqeacddscdaccmelcadhddedgccdfqdkfza`a`a`dsfqdafjgg`aa`a`a`a`a`dsa`a`aeaeeqexcacjcjcjaeaeacacbiexdodicpcpcfcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaebgaebgaebgaeaebgbsghcacmbqb`b`b`ex`cb`b`b`b`eeeeb`b`eqcibtapbt`dcdcafbggdafidwcibtapexcidbdrcnesakajbpes`feyfe`u`fex`c`c`c`c`c`ccbfldididoff`cb`cpdbflcbcbdvcicbdvggbucocidvdvbucobuc`au`cgfcpclffdk`hcacdgca`a`a`a`dsa`a`dsa`a`a`a`a`a``hgicufsdedeeqggciexciap`dggbuggftcw`afzdaczbhdsa`dqbfc`fta`a`a`a`dsaybhdkggdsa`a`a`a`a`a`a`a`cdfjdbcbcacjcjcjcjaeelbtaed`flenffffd`aecjcjcjcjcjaecjaeaeaecjaeaecjaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaeaebgaebgbgaebsaeaebmbncab`fdb`b`b``cex`c`cb`b`b`eeb``ccbdiex`cb`bffqd`btex`haj`bcidhfs`ccidb`pcnesdldlesetdpaffxdecpex`c`c`c`c`c`c`c`ceqfldoctctctctcpdvdbeqgi`hacapczclc`dkbudibucpbubcendbcidodvflc`cwcwfteddsdsdsa`a`a`a`dsa`a`a`a`a`aeaecwbfewcucaeaciciexfseqc`c`b`dacua`a`dscdgca`a`a`gccda`a`a`a`a`a`dsgebfc`b`a`a`a`a`a`a`aefzcwbteqdocicacjcjcjcjcjbicmbibiexdoffffb`aecjcjaeaeaecjaeaeaeaeaeaeaeaeaecjaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebsbgbgbgaebgaebgaebgbmbgacb``cb`b`b``cexexb`b`eeb`eqffflfldbcp`cb`apbtfjeabcefaj`i`cdhfsexff`zav`lbpfiakesdrga`bcv`fci`c`c`c`c`cex`c`cexcpdidienffcbclfhdidifleqggfjfbbh`cgiaobqdec`ggdvdbbwgibuffcodbcibhdkdacucdcdcdgcfzdsa`a`a`dsa`a`a`a`a`ds`hfbeddab`coggggbfdadegieda`a`a`a`a`a`a`a`a`a`a`a`a`a`a`dsa`a`dsfsc`ggbfaea`a`cdcdaefteedhdhdbdicpd`biaecjcjcjaebgbgbgdhdiffff`cbgcjcjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbsbsbgbmdtbsbgaeaebgbmbgcab`b``cb`b``cex`c`c`ccidbcbb`apb`b`cpcieefsfjdhexeaajez`eeebtapexdbaucnesesfibpbydpdrdm`iffci`c`c`c`c`cexexexdbctctdicbbccobucpclffdictdoflcpcobceabhaobhfjbhdkdabielc`gibhbccbfjdkdafbftcucucdgca`a`dsa`dsdsa`a`a`a`dsedcubfapcu`agibhc`accwgia`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`aefzggb`eqcufzdscd`cfqgeffdvapcbdifffffjelaecjcjaecjcjaebncf`ccbffexbicjaeaeaeaebgbgbgbgbgbgaeaebgaebgaeaeaeaecjaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbsbgbsbsbsbsaebsbgaebnbgbsddfdb`b`b``cexcicpdbffb`btapapeeee`ccp`cbfbtbtcibfefafclbtdhb`eqffavavesdldles`qcqeufwexcp`c`c`c`c`c`c`cexcpendodidodbcpcpcbcoeqau`effdodoctdodifldvbueqggczbhcmcaacfjdacwcwfjcm`hfbehfbftewgcgca`aea`a`a`a`a`aecja`a`cd`hcuewaea`gcbfcwbhewbhfja`a`gcfza`a`a`a`a`a`a`a`a`a`dsedcdcdfqbucbcoayfqcw`cfhdvdoenfhcpcidbcicbbfcfbgcjcjcjaeaeaebibnaccicbexcfcjaeaeaeaebgaebgbgbgbgbgbgaebgaebgaeaeaeaeaeaeaecjaeaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbgbsbsbgbgbgaeaeaeaebgbgaebneeb``cexciffdbexeeb`b`eqciapb``cb`cicbeefsb`cpcwevdeclapfsexcpcbavcnesdlakesdp`fdjcycpeq`c`c`c`c`c`c`ccbdodocbcpcpdbdodbauczgfbfc`bcffdvclffdbcp`e`ecobudbflclcbaude`cc`apgigidddkdkdkbhdacwftcucdelbncdgcgcbia`bidsgccwcaa`a`a`a`ftcmcadkcuapbhgcewelgcgcgcgcededcdftcwbteab`eab`cbflbuggeqcpflendodidbdbffeqaufleqcbddcdaecjaecjaeaeaeaeelcmexexciaccjcjaeaeaebgaebsaebsaeaeaebgaeaeaebgaeaeaeaeaeaeaecjaeaeaeaeaecjaecjaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcj",
+"bsbsbgbgbgbgaebsaeaecjaebgbgaecm`c`cciflfl`cacbt`cflcpfsdhfsee`cb`cicifsbweqeweh`fdb`cb`exffep`qesakbsescncqbe`idecpci`c`cex`cex`ccididbb`cidifheqggcbflffcoeadkggdbdidvffdvffcbeqexgg`cfffhffcpfffhdiffcpbuffffffffbuci`ecoeqeqeqbwex`cggeefsbtfqcwacft`acdewewcacfewbhczgigidabofjbhbodkapgggg`capgiddgib``cb`cbdicoffdoenctdiffcpcpffaudecbdbcocbd`bgcjcjcjaeaeaeaeaebneleeexcpfjcjaeaeaeaeaebgbgaebsaebgbgaeaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaecjcjcjcjcjcjcjcj",
+"bgbsbsbgbgaebsaeaeaeaecjbgbicjbn`cexcbdieqfjfjfscbflb`fjd`cwdhd`acfs`ccidbexewabcldbeqexeqdbdzcnesdlbses`q`zfx`rcbciex`cex`c`c`cexdbdieefjgeggcbdbffco`ecbdvcleqggdeeqbudiflfldbffcpff`eb`ggcico`ceqbucicide`cggggeq`cc`apgiapgigigibfddgibtdkbhbhfjfjbhdkdkdkdkbhbhbhbtggbcggdeggbcde`cbcggapczb`c`ggco`edeggcodibucibuflctdibucbcocoggc`embwexeqcbftcjcjaecjcjaeaeaebgaebifsdbdbdhcjcjaeaeaebgaebgaeaeaeaeaeaebgaebgaebgaebgaeaeaeaebgaeaebgaeaebgaebgaebgaeaeaeaeaeaeaeaecjcjcjcjcjcjcj",
+"aebgaebgaebsaeaeaeaecjcjbgbgaebib``ccpflfsdhfs`cdiexfjcacdcwftgcfzftbtexdidee`fefldiciexciclavavesdsfiesdpdrafaicbciex`c`c`cex`ccpeneqdabhgiddbhc``effdvci`cexcidbbubcc``ccpcoexcocldvflffcbcbclflcbcbdbdveqb`dkfjfjaygidkdkdkbhbhdkddaydkbtdkayaybhdhbhbhbhbhbhfjbhbhbhdkc`c`apgibfgibfczggb`c`apggdeexggb`dvdv`cggcoclendicbggggbcb`dafqc`c`b`ffcpcacjcjaecjaeaecjaebiaeaecmffflapcjcjcjaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaebsaebgbgbgbgaebgbgaebgbgbgbgbgbgbgbgbgbgbgaeaeaeaeaeaecjcjcjcjcj",
+"bgbgaebgaeaeaeaeaeaecjaeaebiaeaefjexcpcpdhfs`cdbcpfjcdgccdftcddsdsfz`deedb`cef`bfhdocpexcpcoavcnakbsdlavdpeucycpcieq`cexexexexcidodbfjfbbhdkbocwewelcafscicpeq`c`cbccbcbexdeb`apapc`ggbc`cdecoffdbfldiflcldvdbbucocococicocbcocicbcicbcoeqdededebc`cbcbc`cbc`cggb`b`c`b`gggg`ccobuexggbcbw`cbccobufldvbcbcffeqcwewcwdedidicoc`dkggggayfbdac`c`ggflcbcfcjcjcjaecjaeaeaeaeaecjelcpdieecjcjaecjaecjaeaecjaeaeaecjaeaeaeaebgaebgbgbgbgbgbgbsbgbsbgbsbgbsbsbsbsbgbsbgbsbgbgaeaeaeaecjaecjcjcjcj",
+"aeaeaeaeaeaeaeaeaeaeaecjaebgbgcjbib`db`cdheecbflbtcdbidsgcgcgcfza`dsedfjdbb``ocrdidodbciffep`qesaka`evdraifwcicpcb`c`cexexcicbdictcpd`ewcuewedgcdsa`cjcjbnd`eecbcbcobwbceqbu`cgibobhbhfqdkgigic`bccpfhdoendidbdoctctctctctctendodvffflflflfldiffffffbucieqdeeqeqdedecoeqcocbdiendicbcbcpffbucpdvffciggczggdagca`fzdaclcpdec`dabhdec`cwcwgegidkggcpcoelcjaecjaecjaeaeaeaecjcjbicidoeqbscjcjcjaecjcjcjaecjcjaecjaeaeaeaeaeaebgbgbgbsbgbgbsbgbsbsbsbsbsbsbsbsbsbsbsbsbsbsbsbgaeaeaecjcjcjcjcj",
+"bgaeaeaeaeaeaeaeaecjcjcjcjaebncjaebtdbbtd`exdbeecdgcgcfzfza`a`fzgcdsfzcacbb`dleudidodbcpcbepcnesdlbsesclax`iflclexexexeqeqcbdieneqdh`cggftfzfza`a`a`a`a`cjcjbgeld``ccpbucococbeqgggiftcdew`hdadk`cbufhdodododidbcqfldodododoflflflflfhflfldbdbcpcbbubucbcbcocicbbuffbudvflfldodidbffdvdiffcbcbcodeggcwewgca`aefzdabudvczapbhfbdkggc`daaogfbfdkggcicicdcjcjcjaeaeaecjaecjcjcjae`cdocpelcjcjcjcjcjaecjcjcjcjcjcjaecjaeaeaebgaebsbgbsbsbsbgbsbsbsbsbsbsbsbsbsbsbsbsbmbsbsbsbgbgaeaecjcjcjcjcj",
+"aeaeaeaeaeaeaeaecjcjcjcjcjaeaecjcj`dcpd`accpcbcabncdgcgcfza`a`a`gcgcfzftcpcz`obyclfldbdb`e`qcnesbgdxavclcy`fdici`c`cexeqeqcpdocpacelaoc``cgicaftcua`a`a`a`aeaecjcjfzftgieqcbcpcbbudec`cafza`a`gccaftdabh`ccldodoflflflcqfldidididbffffclcbexdeexbwauexcbcbcbdvbuffdvdododocpcocbbuffflffexggczeagfgiftdsa`a`a`dacpflbccwbo`heddkgiapcwdadkbhgieqcb`cbncjcjaecjaeaecjaecjcjcjcjeedicpelcjcjcjcjcjcjcjcjcjbib`dtcjcjcjaeaeaebgbgbgbgbgbgbsaebsaebsbgbsbgbsbsbmbsbmbsbmbsbsbsaeaeaeaeaecjcjcj",
+"bgaeaeaeaeaeaecjcjcjcjcjcjaeaeaeaecaexacapdbbtcdcdelgcgca`dsa`dsfzgcelftcpb`akey`fdbdbflauavcnakbsdm`faiaxdicpexex`cexexcicpdbapcffqaygiapb`deb`gibhcdfza`a`a`a`a`a`a`dsfzacb`cbcpcpbub`aceda`a`aea`a`a`gcewdkciflfhdifhdvdbcqbubuclffcodeexeqggdddqftca`hacdqcwgiclenflb`bobhdkb`dvclcobcapgiddbh`hgca`a`fzbhbudb`cdkcucwew`aapgic`cwfjdkbobfcbcoapelcjcjcjaeaecjaecjcjcjcjcjdhdbfldhaecjcjcjcjcjcjcjcjaebcdoflgge`aecjbgaebgaebgbgaebgbgbsaebsbgbsbsbsbsbsbsbsbsbsbsbsbgbsaeaecjcjcjcjcj",
+"aeaeaeaeaeaeaeaeaecjaecjcjcjaeaecj`d`cd`ciex`d`dcafzfzdsa`a`a`a`gccdcubtdb`cakafdbdbdoffep`q`l`odtafdpaxdbdbexexexexexeqexdbcpd`ddcp`ebfdkdkgiczcocobcgiewfza`a`a`a`a`a`a`a`gcelfjbccpfldbbwacaecjaea`a`a`a`aea`cmb`dvcqfldiff`cggdebceqbucbeqdeaueqapfjcucdedbhcldv`cda`hcwdqbhaucb`eggbocuewedfzdsa`a`a`gifldi`cfbcaewdaewfbgggic``hbodadkggffexdhbncjcjaeaeaecjcjcjcjcjcjcjacdbdici`capcmbncjcjcjcjcjcjcjcjacexctflfsaeaeaeaeaebgaebgaebgbgbsaebsaebsbgbsbsbmbsbsbsbsaebgaeaeaeaecjcjcj",
+"bgaeaeaecjcjcjcjcjcjcjcjcjcjcjaeaed`b`fsffbf`d`d`adsdsa`a`a`a`a`dscdfjapdbb``oafdpdbctcbejcnese`ezdzclclflciexex`ceqeqexexdbcpdheedoendvgggidkgegiggcocicobfftgcdsa`a`a`a`a`dsa`a`bgcwb`cbfldiggaceda`a`a`aeaecjcjaecdapcoclflclauggc`gigiczcobubueqcocoeqc`da`cdvgicuedcd`abhauapdabocucdedfza`a`a`a`fzgidbdibccdel`afbdkewdagggfeafbfbcwgiaucbgiaobncjcjaecjcjcjcjcjcjbicafj`cfldodiffffdiflfjcjcjcjcjcjcjcjcjcjaefjcictcbaobgcjaeaeaeaebgbgaebsbgbsbsbsbsbsbsbsbsbsbgbsaebgaecjcjcjcjcj",
+"aeaeaeaeaeaeaecjcjcjcjcjcjcjcjaeaedheeeeeqaccw`dgcdsdsdsa`a`a`dscdfqbteadbbq`oetcpcpflgg`jetakeffwdrdbflciexexexexexexeqexflcpfjb`flclfhflcoczc`gigic`ap`cexbcc`fbeddsfzbidsdsdsa`a`cjcjbnfscbfldieqfqedbga`cjcjcja`a`a`edbhggcocbbucobcggc`gigiczggaucoggggggffcpggddcddscwdeddfzgcededgca`a`a`a`a`cdbfffdib`bia``acddafjewgebfb`dkftcwboc`auexfsaybicjcjaecjcjaecadheeexffdodidodoflexb`cidbcpbtbgcjcjcjcjcjcjcjcjcjcjcmdodbct`faoaeaeaeaebsaebsaebgaebgbgbgbsbsbsbsbsbgbgaeaeaecjcjcjcj",
+"bgaeaeaecjaecjaecjcjcjcjcjcjcjcjaebtapb`ee`dd``delgcfzgcelcdcd`dbfapeacbdob``oafcpcpciembydjeveh`icqdicpexexex`cexexexeqcifldbfjb`dv`eggcofhfh`egegieaemfqapcz`cbcapdacdfzfzfzdsa`a`a`aecjcjelfqbcflfleqfselaeaegcfzfza`aecja`ftgiggcoffdvbuaubceagidkgic`ggggbuclczbhcddkeqbha`a`gcfzdsa`a`a`a`a`ftapb`dv`cbicja`gccudafbcuc`dkggfbewbhdkbc`c`cdhdhbicjaecjcjbib`flcpcpfldbdiflffffflb``dcmaodhbcexcacjcjcjcjcjcjcjcjaeghcpcjbgfsdbctcieraeaeaebgbgbsbgbsbgbsbgbsbsbsbgaeaeaeaecjcjcjcjcj",
+"aeaeaeaeaecjaeaecjcjcjcjcjcjcjcjaebtfsb`fs`d`d`dcfgcelcu`d`d`dcwbtexfldodobcdw`q`eex`eembybpeherdzdodbciexexexexexexexexcidbdbgiapflbugfdkb`clffgigeapgidkddgibfczeqeqead`cdfzfzfzdsa`a`aea`a`cjbicafscpdicbfscacucdeda`cjcja`aea`gcftgicoflffcoaucococzgigedkb`dvczdkdecbbha`a`a`a`a`a`a`a`a`a`cuapapciexbicja`fzedcudaewfbapdkc`edcugigibwc`ead`btaeaeaecjcjapcpb`eqffdbci`ccbdbdbdi`celbnbnaebidh`cdhaecjcjcjcjcjcjcjcfcbcjaecjcjbgdddbct`eaoaeaeaebgbsbgbsbsbsbgbsbgbsaeaeaeaecjcjcjcj",
+"bgaeaeaecjaecjaecjcjcjcjcjcjcjcjbifsapb`apac`dcagbapggexcicbcbbucbfffldbdb`c`idz`feqeqeydjes`ofjcbcbfsexciexexexeqexexexeqdbfl`caydveneqgidkdebugegiauggddgigigigiapap`c`cbfaocugcgcdsa`a`a`a`a`a`cja`cdbtciflff`cfj`aaecja`a`a`a`aecja`edcwc`audeaubcbcbceagegicbcoc`czdqa`a`a`a`a`dsa`a`a`a`cwgigideeqelcja`a`bigcewcwew`hdkgidkfzftdkc`degiapcmfjaeaecjcjcfcb`ceqdbexaoacfqdbendodocpeeb`fjbicjcjeleebtaecjcjcjcjcjcjcacpcjcjaeaeaecjaebsfsclctciaoaeaeaebsbsbsbsbsbgbgaeaeaecjaecjcjcj",
+"aeaeaeaecjaecjcjcjcjcjcjcjcjcjcjbieedhb`apfj`dcfelcdca`dggcoapap`cffdidoflbq`iaidbffcobydjbpehaycpeecfapcpcbcieqexeqexexcidbdo`ccwbccidvbuggeqcogicbdiggczfcggdkdkbfgic`b`exeqbwczfbbia`a`a`a`a`a`fza`a`a`gcdab`buff`cacelbidsa`a`a`cja`a`a`gcew`hgiczggdeczczc`codvgiftgcdsa`a`dsa`a`a`a`a`cwdkdd`ccpaccjcja`a`dsfz`aew`adkdkb`cwfzfjgebcggbhbtcafjbicjcjcjaydbffcpap`da`a`gcd`excpdidifleeelcjcjcjcjbifsddbicjcjcjcjcjcfcpcjcjcjcjaecjcjaecaexctctctctaxghbgbgbmbsbsbsbsbsbgaeaeaecjcjcj",
+"aeaeaecjaecjcjcjcjcjcjcjcjcjcjcjbifsfjeebtfsfjelbgaea`cdcwbngccdcdcubtcpenci`ugadicpejbydjeyfe`ccbaccjcmb`cicbeqexexeqexcidbdi`cacbtdkapdedvflcoaudoflggcodo`uapc`ddgic`c`b``ccicbcoc`ftbgaea`a`a`a`a`fzgcfzdsa`bnbteqffffeqeaftgcbgbigcdsa`aea`a`dsfzedcdfbcwbhgic``h`afza`a`a`a`a`dsa`dsaoddcwc`cbgia`cja`a`a`a`fzewcdcugigidecugcgigibwc`daddacacaecjcjcjelffdbbtbtd`gca`a`cjaebi`ddhd`bicjcjaea`aecjcdcpeecjcjcjcjcjcfcpcjcjcjaeaecf`cdoctctctctctctctctdie`bsbsbsbsaebsaeaeaecjaecjcj",
+"aeaecjaecjcjcjcjcjaeaecjcjcjcjcjbieefjb`dhbteacfbia`fza`aea`elfzeddsa`fjcpdidpcldoff`udjescycidb`cbgcjaecafsexciciexexeqciffdicofjfjdkdkgic`aubuflfhffggfldocbdvcpgigigegigiapcz`ccbeqeqb`cweda`aea`dsa`dsa`fza`aea`fzfbczfffhdiff`cfq`hftcda`aeaeaea`a`a`a`dsfzfza`dsdsa`dsa`a`a`a`a`a`cwbhfbgicoczgca`a`aea`a`a`fzewewcwgic`deedewgic`dedkgidhfjcfcjcjcjcjcjb`ffeefjfscwbna`aecjcjcjaeaeaecja`a`a`aeaeeedi`caecjcjcjcjcfcbcjbgaccienctctctctctctctctctctctctcabsbsbsbsbsbgaeaecjaecjaecj",
+"aeaeaecjaecjcjaeaecjcjcjcjcjcjcjbiapbtcbapbt`capcfbnbia`cjfzfzfz`adsa`dsfsdiflcqdoclcy`ldfbkbucbfsaecjcjbicmfj`ccpcieqeqciffdodi`cdkdkgegidkgibucldebucoclfhenencieqc`dkgibhdkbtdkbtgiee`ccp`cbtftfzaea`aea`a`a`a`a`a`a`a`gcdk`ccpffcpexb`btcfcjaecja`a`a`a`a`a`a`a`a`a`a`a`a`dsa`a`a`cacwcabfeqexcda`a`a`a`a`a`a`gccucddadac`b`gcdkgfggczboggfjfsbncjcjcjcjcjd`cbexeeapfsbtfqfqela`bgaeaea`a`a`gcfqcubfflcpfjaecjcjcjcjcmdicpctctctctctctctctctctctctenexcmbgaebmbsbsbsbgaebgaeaeaecjaecj",
+"aeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjbiapbfcpcpbtb`exee`delbibifzdsgcedfza`gcddflcqcldicbbydjabf`exexcacjcjcjbgelcaddexexcbcbciffdidodococ`dkgegiczcoapgicobubcexdbflcocbggcocoaygigibhbhfj`dftfscpdodv`cfqcda`aedsa`a`a`a`a`a`a`aecjelbt`c`cb`eecwaecjcjcja`a`dsa`a`a`a`a`a`a`dsa`a`a`a`ewftgcfjbcexfta`a`a`a`a`a`dsa``acd`adadac`bocdeafsejddbfexacfjbgcjcjcjcjcjbi`cexcpdbcicpdbcpfjgcgcgcfza`a`a`cwexcpdbdib`cjcjcjaefjcpctctctctctctctctctctctctdoexcaaebgaebsbsbsbsbsbgbgbsaeaeaeaecjaeae",
+"bgaeaeaecjaecjcjaecjaecjcjcjcjcjbifsfjbffleqbtap`ceed`caelbia`gcgcgcgccabffldbdpdicieyes`oayb``cbncjcjcjcjcjaebnd`fsffffcbdbdifldbdoflcoapgegibh`hgicbclapdkdecpco`ecbcb`cgieqexbhaocwacca`deqendobudeeq`ccwdscjcja`a`a`a`a`a`a`cjcja`cfbfeeb`eedhcfcjcjcja`a`a`aea`a`dsa`a`a`dsa`elcagcaobfdhelaea`a`a`a`a`a`a`bicdfzewdabhczcu`hb`c`ggcw`cexcacacjcjcjcjcjcjcjfsfldidoctctfl`cfq`d`d`d`dgcfzcad`fqcpfl`cfsbgd`cictctctctctctctctctctctctcteqcmaeaeaebgbgbsbsbsbgbgbgaeaeaeaeaeaeaeaecjae",
+"bgaeaeaeaecjaecjcjcjcjcjcjcjcjcjbgapfsfj`cflffexb`eebtfqfj`dgcfzedgc`d`d`cdocqfldoai`vevftapeeb`bgcjcjcjcjcjcjcjbgacciffcpdbdiflcbbudvfldvauapdkdagiczczdkgieqclcococbdedededoeqfjapapftcacweqendodbexb`bwciexbtbncjcja`a`dsa`a`a`a`a`cjcjbicfd`dhbfb`apcwgcaecjcjcjaea`a`a`a`aea`cfbgcmfjcaaecja`a`a`dsa`a`dsa`ds`aa`ftcwbhgicdgec`c`c`giexddcfbncjcjcjcjcjel`cffdbdiflflfldiffexapbfbtd``dfjbfb`eqdbdieeeqctctctctctctctctctctctctencicmaecjcjaeaeaeaeaebgaebgbgaeaebgaeaeaeaeaecjaecjae",
+"aeaeaecjaecjcjcjcjcjcjcjcjcjcjcjaefseefsee`cflendbcib`fseeeafqcucd`dadbtcpdo`fdbdo`fdm`od`fjexdhaecjcjcjcjcjcjcjcjcaeqcpciffdodocpciffgacbfldvejb`bcc`dkdkgibcbucbbuggbudododobcdabcflc`acdacbdbeqexeqcibcapggeqcbbwdhewbia`a`a`a`a`a`a`a`aeaecjcjgcfbfjc`bcb`fqcfaecjcjcjcjcjcjcfd`exexaobicjcja`a`dsa`a`a`a`a`dsdsa`ft`hbhdkcac`giggdkexb`cfbicjcjcjcjcjaccbflffcib`b``c`cexdbdicpexbwexcidbfldbcpeqeqdhctctctctctctctctctctdoexcacjcjcjcjaeaeaeaeaeaebgbgbgaebgbgaebgaeaeaeaeaeaeaeaeae",
+"bgaeaeaecjaecjaecjcjcjcjcjcjcjcjaedhbffs`cbtapffctdoff`ceeapbfd`fjfsfs`cffdi`edidiafabe`aoayeecmcjcjcjcjcjcjcjaecfbtcpcbeqcpdidiffcocpflffcobudidvaubwggc`giapdecocbcifldoenenggbhcobubuc`gecodvapcwacbt`ccocideb`ee`cex`cc``dfza`a`a`a`a`a`a`a`a`a`aea`gccdcmbtb`ggdhcdbgcjcjbicf`cenexgca`a`aea`a`a`a`dsa`a`dsgca`gcft`hbfcw`hczgiapapcbfqbncjcjcjcjcjfjcpdbexapbtfjd`acfjfjapexffdidoendoctencpfsd``cd`ctctctctctctctfl`ccfcjcjcjcjcjcjcjcjcjcjaeaebgaebgaebgaebgbgaebgaeaeaeaeaecjaeae",
+"bgaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjacbtbt`capd`b`cbflctflci`capbtb``c`ccbdbffbcdoclcrakcadhapeebiaeaecjcjcjbncmayb`cbffcbcicpdiflcieqciffdvdbclfldbdvdvcbcoauczczgeeqdicbcpbudi`cgicpggex`eczcbdvgfcfgc`acdbhggeqbu`cfj`dcwfs`cggdhcugca`aea`a`a`a`a`a`a`a`aeaeaebiftbteab`btftcafjdbcocua`a`a`aea`a`a`a`a`a`a`dsfza``acudab``hgieadkgieqeqcabicjcjcjbiapcpb`acd`fsdhcaelelbnbibicafjbteqffcbci`cbtfjee`cacctctctctdib`bncjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgaebgaeaebgaeaebgaeaeaeaeaeaeaeae",
+"aeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcadhcaeeeebtbfee`cffflffcp`capb`apeqcpdbciaxdiclfdabaofjciapcjaecjcjbiac`cciffdbffcpcbcbcpdidbcigid`de`ebuflenffbccoflcpcoco`cbfgfb`bccoczcpgggiff`cdeauggcbdbexb``hfzdsftbhdhbfgiap`caycaelelddexbcbhcugca`aea`a`a`a`a`a`a`a`a`a`a`a`bicadd`cdbfffjdsa`a`a`a`aea`dsa`a`dsa`a`a`dscucaczapcwdegibteecpfsbiaecjaeacciciacelfjeefjcdbia`a`a`aeaeaebgbielcmcmd`d`elfjb`fjacctdo`ccmcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaebgbgbgbsaeaebgaeaebgaeaeaeaeaeae",
+"aeaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjca`cbtbtfqbtbfapb`fsbwcicb`c`dd`btcbdidoexcidocldjevay`cexbncjcjae`d`ccpdbffffcpcpcicieqcididocpfsftcwaycocpflendbaucbdvffcbauggeac`c`apemcbgggidbcbggaubcbudvciflcodkcdftfjdkbheweleld`apfsd`cfaceaexexb`dkcua`aea`a`a`a`a`a`a`a`a`a`a`a`a`apfhdecwdsa`a`a`a`a`a`a`a`a`a`a`dsa`gcewfbggdadkggdaayco`celcjcjcjfjdocpcfeldhfsd`bia`a`aeaeaea`gcgcaecjcjaeaeaecjaebnbtcfcadielcmfsbgcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaebsbgbsacaebsbgbsbgbgbgbgaebsbgbgaebg",
+"bgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjel`cffcpexapeebtbfapdhb`fffleefjeqdidodocidbdoaxesdmdhexcacjcjbifscpdidbffffcbcieqcicicicifldoffb`aobhbhgiczcoffflfhflcpdeaucbeqdedeggczeaczapdkcofleqbucb`effcbfldbffco`cgidaftcucuelbicjbnfs`c`cgid`acfqeeex`cfqgca`aea`a`a`a`a`a`a`a`aeftcbcbdedka`a`dsa`a`a`a`dsa`a`dsa`a`a`edcdbhc`eweagiaceeexbtcjcjcjcjapdocpdhbtd`cugcaea`cmcda``afjaccuaecjcjcjcjcjcjcjcjcmacelflcmcacbaccjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgghflaebgbgbgbgbgaebgbgbgbgaebgae",
+"aebgaebgaeaecjaecjaecjcjcjcjcjcjcjcjeld`fsexcpffeqbtcaacfqbtb`cpfldododidbcpdidobeeseveefjcjcjca`cdidiffcbcbeqeqcicicicicicidbdoflexbhdkdkdkgigfb`decobufhcbco`edvbucocoauggczgidkc`buflffczggbucoffdeapbcffffcogidafbewbgaebncffjczb`eegifjfjfjee`cco`cfqfzaeaea`dsa`dsa`fzgg`cbtcbbfdsa`a`a`a`a`a`a`a`a`a`a`a`fzewewggddftb`aoayex`ccfcjcjcjcjcmflcbfsd``dcdbnaeaefjfqbifqbwfqgcaecjcjcjcjcjcjcjcjbnfjbnexfjelb`fscjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaebgaeghflaebgbgaebgbgbgaebgaeaebgaebs",
+"aeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjelfjb`eqcp`cbt`delelbtdbdodocpffdbdidbfxbpcmeecacjd`cpdidbcbcicieqcicieqeqciciciciffctfleqapdkdkgegibfgegib`de`ecofldbdobub`dedveqgg`cgggic`bcczgib`dedecoflc`acgiggdecbbubcfjaeaeacdabhfjfjfjd`dhdhelcjd`cpb`ggggbtdscja`a`a`cjfjeqcacmcbbfa`a`a`a`a`a`a`dsa`bia`dsa`bicudaggcdaoeefj`c`cfjcjcjcjcjcjbneqcbfs`dd`ftgccjcjfqeecdb`b`cafza`aea`bicjcjcjcjcjaefjbicjcmelcffjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecfflaeaebgbgaebgaebgaebgbgbgbgbg",
+"bgbgbgaeaeaeaecjaeaeaecjaecjcjcjcjcjcjcjcjcjbgcf`dfjb`cicpcbexexffcpcicicpfldbclfxbpaoeecacmcpdidbcbeqcieqcieqcieqcicicieqcicpctffexeedkdkdkgigegigegiapgfczbccofhcpc`c`ffbucbcoggdeczgigiapggaubcggdidobubcbhdqgiggcocbb`bfbfdkbhbhbhfjcacafbcabidh`caeaecf`ddhd`bicjcjgcb`btcjcdeq`cgca`bieddsa`a`a`a`a`a`a`a`edcdbfcwfzfsdheeeq`cbicjcjcjcjcjbncbdbapd`d`ftbicjcjfjcifqbwbtgccdftd`d`elaecjcjcjcjcjaccfflflflflflflflflflflflflflflflflflflflflflflflfldiflaeaebgaebgaebgbgbgbgbgbgbgbg",
+"aeaebgaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjaebibnelcfaceedbflcbeqeqcbdidofl`fbpckfsbtcfb`dbdbcpcicicieqcicicicicieqcicicicpdododbcoddbhgigigegigigigieabfapddb`cldvcbbubucoffffeqb`czc`giggggggbhdedoendoflauc`dhcwftbtcbdveqc`ddbhdadqfjfjcwcafseqbncjcjcjaecafqacbgd`eabiaecddeb`bfgca`caftcdbia`dsa`dsa`a``acagidselfsb``ceqb`elcjcjcjcjcjelcpffeefqfjcabnbgcjacbu`cexfjftapbffjcagcbgbiaeaecjcjbneleeeeeeeeapeeapeeeeapeeapeeapeeapeeeeapeeapeebcdoctflcjaeaeaeaeaebgaebgbgbgbgbgbg",
+"bgbgbibgbga`bgbgbgaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaebgaeaeelexcbciciciffencp`c`ievckcwcmcfcidbcpcieqeqcicieqcieqcicicicicicpcpdictdodoffgidkdkddgigigiapc`gfgedkbfbcclfldiflcbcqffbuffauc`czdeczggbhbfdoctfhdbdidicpfscafbgeczeqbubueqb`gibhbhfjcwb`bu`cex`cacbgcjaebnd``ccmaea`cdbccwddc`gcedeaeagca`a`a`a`a`fzcddacwcjcaeeexcbb`acdhcjcjcjcjcjd`ci`cci`cfjaccwbncjaccpfleqeeciexcwcwfjcdbibibgaecjcjaebicjcjcacacfd`aecjcjcjcjcjcjcjcjcjcjcjcjbmeecpctctctflaeaeaeaeaeaeaeaebgbgbgbgbsbg",
+"bgbgbsbgbsbgbgbgbgaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaebtcicbcicidienbtaeajevftelcafscbcpcieqcicicicicicicicicicicicicbcpdictdodiendvgggidkgigiapgigeddbfdkgigideal`edidodifhdvcbbubudedeggb`bhcwcodoctfhcbclfhfldvaugggfbhbhapeqcpcb`cc`gibhggcoacb`didbeq`daecjfs`caea`gccwdedafbfsbfftc`exfta`a`dsa`dsdsftcz`aaefjcicbb`dhaobtbncjcjcjae`cexcifffsfqbtd`bna`fjcpdoffffexbfeecieacfaeaecjcjcjcjcjcabicjelbhgcbfcfcjcjcjcjcjcjcjcjaeca`cdoctctctctctctflcjaecjaeaeaeaebgaebgbgbsbsbg",
+"bmbmbgbsbgbgbgbgaeaeaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcacicbciffdodod`bsakakdteld``ccbcieqciciciciciciciciciciciciciciciffdododbdidoenbubqgigigegidkddgegigic`gfbwb`ggdvdictdoflbucbdvffbcczdddagiapcbcldeggbcdebudidoffexc`dddafjapbccocobccocoftapded`apeq`caceqfscja`a`bhcogidaftacc`eqdkgca`a`a`a`a`a`fqgia`cfdeciexcffsb`fjaccjcjcjcaexexcp`cbtbtfjelaebifqcpdodociggcpexcwbiaecjcjcjcjcjcjcjftgcaea`dsa`gid`cjcjcjcjcjaefscienctctctctctctctctctdicjcjaecjaeaeaeaeaebgbgbgbsbs",
+"bsbsbsbgbsbsbgbgaeaecjaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjbnexcbcbdiflfffdfwdjdjddfjeaexeqcicicicicicicicicicicicicicicicbcicbdbdododicbcpendicoc`dabhdkdkdkgec`c`ggc`bcb`declcpfhenctendvcocoaudeeqggdadkapbfbhdabhc`decodvdodibucogggicwbhcodvbudefjggeqcdcjaobuapcpgia`a`a`gccbeqbhcdeldecoewa`a`dsa`a`a`a`dkfba`apdbcpbtcjcaex`cd`aecjaeb`cbciffeebtfqcdbicjbnbtffdodocbcbgg`dgccjcjcjcjcjcjcjcjaecugcaea`a`a`bhftaeaeelb`dbctctctctctctctctctctctctctflcjcjcjcjcjcjaeaeaeaebgbgbgbg",
+"bmbmbmbmbmbmbsbgbgbgaeaeaecjcjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjbicicbffencpexcb`eafc`bhdqggcbcicicicicicicicicicicicicicicbcicbcicbcidbctdodicpffdictdvggbhdada`hcwgigiczb`ggcpcobudededidiendoflcbcocpffbucob`gidkda`h`hbhgigic`bccbflfhflcpeqc`czco`e`cfq`cdicibfggeqbtffbha`a`a`edeqcbgiel`h`cbtftgca`a`a`a`a`bibhgccdbcflb`bicjcjfscieeaccjaccp`capcpeafjcfcdbngccuapdbenffeqb`fscwelaecjcjcjcjcjcjcjcjewfza`a`aeaefzd`exenctctctctctctctctctctctctctctcpfsaecjcjcjcjaecjaeaeaeaebgbgbgbg",
+"bmbmdtdtbmbsbsbgbgbgaeaeaecjcjcjcjcjcjcjaeaeaecjcjcjcjcjcjcjaeeecpdoflb`b`bceaay`ha`ebbwcpcbcicicicicicicicicicicicbcicicbcicbcicifffldbdodododienendodvggdafbftcwczdecocbdvffgg`ecbcbcb`efldoendiffclcbcobucbc`dadabhgidkbhdkgeapczbucldvdbdvffdbcbggbhczffbuggggcogibucwa`a`dsftdeeedkbhbtgi`aedewa`a`a`a`a`gccwcd`cdbcbcfcjcjbn`ceqcbd`bgeecpd``cexfqcacdcdcd`dbtcbctfl`c`ccicidaa`aecjcjcjcjcjcjcja`gca`aea`cwexdoctctctctctctctctctctctctctdoeqd`aecjcjcjcjcjaecjcjcjcjcjaeaeaeaebgbg",
+"dtdtbmbmbsbsbgaeaecjaecjcjaeaecjaecjaeaeaecjcjcjcjcjcjcjcjcjcjfsfldo`cddb`eeacelfzdscu`effcbcicbcicicicicicbcicbcicicicbcicicbcicbcpdbdbdoctctctctdodoctdoffggdacabhggdecbeqcbdvcocbdecocbbudidbffdiflffcqffdecbdegigedddkddgedkdkgecifldbflcqdvcbbu`cddgiaugggigib`czcpftdsa`edaccodeda`ccofjewfzfza`bia`a`aebieldddodbb`elcjcjcdex`ccpeefscbfsfjb`btcacdcdewd`bt`cdoctdiflflcbfscaa`a`aecjcjcjcjcjcja`a`apcpctctctctctctctctctctctctctctcpeebncjcjcjcjaecjcjcjaecjcjcjcjaecjaeaeaeaeaebg",
+"dtdtbmbsbsbgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjddenffd`bteqap`aa`a`fz`xcodicbcbcicicicicicicicbcicicbcicbcbcpdbfldidodbdbdbdicpcpfldododododododefjcwaoc`cobubucbbcdecbbucleqdecbeeczbufldidodvcoeqbuauc`gedkgeddgegideff`ecofldbgieeczgedkczczgedkcw`cbufta`a`fzftdebwbccbbcddftfza`a`a`a`a`cjaed`cpdocbdd`daea`biee`ceqcbcpeqelfjbtaccfcucdftap`cffendidienflbtcfcddsa`a`a`aecjcjcjcja`cfctctctctctctctctctctctctdoexd`aecjcjcjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaebg",
+"bmbmbsbmbsbsbsbgaecjaecjcjcjcjcjaeaea`aecjcjcjcjcjcjcjcjcjcjcjbtct`celeecibhfzdsa`fzcualflcpcicbcicbcicbcicicicbcpffdbdidoctenfleqeeaybfb`eq`cbc`ecpdienctdoflcqfleqdkdagiczaubccoffcqcbdecbdeddbhbhgiggcbfhdiflffffdvdbcoc`apgegigic`cbdvcocbdoggapczdkgidkgigidkcw`ccogcdsa`a`ed`capggdv`cbffta`a`a`dsa`aecjbicbflcbeqeeaobia`aecdfsapdbdifsbgd`bt`dgbcaewfqb`cidofleqb`eqdbexcacfgcdsa`a`aecjcjcja`a`a`cfb`dbctctctctctctcbapbncjcjcjaecjaebgaeaeaecjcjcjcjcjcjaecjcjcjcjaecjaecjaeaeae",
+"bmbmbmbmbmbsbsaeaeaeaecjaecjaecjcjaeaecjcjcjcjcjcjcjcjcjcjcjcjapdbaccm`cexfta`a`a`ds`xeqflcbcbcbcbcicicbcbcpfffldoenctctendb`cdhfjfqdkddgibfgfc`cz`eclflfldoendofhdifldegiayapeqaucbcbbubuffcp`cdeb`gedkczcb`edecz`edvflfhdodvauczczgigiembccoclcoc`c`gedkdkgigedkdab`eqgcdsa`a`daggc`czapb`ggcwfza`dsa`a`aebgeedieqfscp`cbfewaeaeaecafjeqeneebicabtfqcw`dd`fsexffdoffb`eeeefseqb`cdcdfza`a`aecja`a`a`a`a`aea`bifjapcictctdbeebncjcjcjaecjaeaeaeaecjcjcjcjaecjaecjcjcjcjcjcjcjcjcjaecjaeae",
+"bsbmbsbgbgaeaeaecjcjcjcjcjcjcjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjb`exelddexeagca`a`a`dscugaflcpcbcbcicicpcpfldidienctctdoff`cbtfjbhdddkgigigigigigigiggauggggcpdoctdbbudbdofleqggdec``ccobccbffbuggcwbhgidkgiexbcapbhdkgiggcocldiendicbbwggc`gibhcwddgfc`dkgigigedddkacb`eq`afza`fzapciapcwaocwcadacda`a`a`a`aefqflcbd`btdb`capgba`cjcjbi`deedoff`dcfbtbtacfqfseeeqffdoffeebtd`cf`db`fqbifzdsaecjcja`a`dsdsa`a`a`ftcp`ceebicmcictctdob`elaecjcjaecjcjcjcjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjae",
+"bmbsbsbsaebgaeaeaecjaecjaeaeaeaecjaecjaecjcjcjcjcjcjcjcjcjcjae`c`ccagg`cfjgca`a`a`a`gbffdicpcbcbcbcbfldodidbfldbcieqb`dhfjdkddgigegigegigigedkgigegigiddb`cpdbflctdodbffffcpdbffcoc`aodaczdede`cc`apgiddgib`bwbceqaugibhapcz`edvflendibucobcczapgibfc`dkgedkgigefjcdc`eqelfza`gccdggggfbftcucdfzeddsa`a`aecdcpfffsaodhcbeqc`bha`cjcjcjcfdhcido`c`dfsfsbtapb``cexflfffsdhfjftcdfzcabfcda`a`aecja`a`a`gcgcfza`gc`dcbdob`aecjcjcjca`cdictdibccmaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bsbsbgbgbgaeaecjaeaeaeaeaea`aecjaeaeaecjaeaecjcjcjcjcjcjcjcjcjdhffb`apapfta`a`a`a`a`fbbudicpcbcbcbdbdodododbeqfjelcfcfftdadkgegigigigigegidkddgegigidkdkgi`efhdodidbdidbflcpbccpdbcbexggfqbhdecpdegigiapbfap`cggbuenbudecbc`bhapggcbdbdododvffdvcodegggidkdkgidkfjeweeexeddsa`dsgcc`eqgi`aelewdsa`a`a`a`gceqdbapbtdhbtdecoggdddscjcjcjaecaapcbffapbtbffseeeeeeffflfjcud`ftcdewcda`cucdfza`aea`a`a`dselcdgcgccffqexcpcmcjcjcjcjcjcjcjbnapcpctctcpddbicjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbgbgbgaeaeaebgbgaeaeaeaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjbgexflcoggcwdsdsa`a`dsbhcbffcpcbcpdbfldodbee`delaegcelcdedcd`hdabhbobhbofjcwcwdabobobhbhdkdkgi`ccpdocpcidbdbdbdbexexeqeqdbffbcbcbwapgegidkddbhb`ggeqdodofhdobuapbofjgicz`edvdofhflflfhflffcoczgidkdacab`degca`a`a`fzgidddkgiewgca`a`a`a`a`czdbeed`dhgigic``cbcc`gca`cjcjcjelcmb`cpdbexbtapggbfexdiap`dfjftcdewcdgca`a`dsgca`a`a`a`a`fzcd`dcd`dd`bfexexbgcjcjcjcjcjcjcjcjcjcjaed`eqenctfl`ccdcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcj",
+"bgaeaebgbgbsbgbgaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjbiexdbbcapdacwelftayaobtciffcpdbdididbeqbtacbiaebidsa`a`gc`acuftfb`hfbcaewcafbftfbfb`hcwbobhbhbhexdidbcpcbffcpdvcpeqcocbffdidocbgfbfdkdkdkbhczeq`ccodidodoenclapdkdkdkdkgiczbcbudvcpfhfhdbfldvcib`bhb`ci`aa`a`a`a`bfdkgcftbhcua`a`a`aefbdvded`d`bfapcwddcoeqggcdaecjcjcjaebndh`ceqcpcbffcp`cflcpcabffjcacdcdgcfzcdgca`a`a`a`a`dsbigc`dcwcaca`d`dbtbtaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcfb`flctenb`cjaecjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbgbsbsaebgaeaeaebgaebgaebgaebgbgbgaeaeaeaeaecjcjcjcjcjcjcjcjcjcjbneeexbwdeapfqacgcbgapcpcpfffldodbcicpffexftaea`a`a`a`fzedewfb`h`hfbcaftcwdqcwdqcwdqcwdabodkaobhggcidbdbffcbcicpffcpcbcbcbdidoflcbc`gidkdagiggczc`bccoflctencpbwc`gebh`hcwbhgiggcbdifhcbcocbbueqciffflaoa`a`a`a`dddkgcfzedcudsa`a`edggcbddfqgiap`hgcdkbu`cde`aaecjaea`a`bielb`fscifldienfldoeqcfbtfjftcdedgcelcdgcgcfza`dsa`gcft`dfj`cd`eqeqeqeqeqeqeqeqeqeqeqeqeqeqeqeqeqeqeqciexciexdictcbcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbsbsbgbsbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgaecjcjcjcjcjcjcjcjcjcjcjcjaebgelcfgcaecjcjaeeeffcpflfldicbeqcpdicbbfa`aeaea`a`gccdcu`hfbftcaft`h`h`h`h`h`h`h`hcwdabhdkdkbtgiapdedvdidiflfffldidbdbdbfhflflflcoc`dabhgiczgigic`ggflctdiclbudegifjdaaodkdkgi`efhclclbucocodecpflgidsa`a`dsdkdaa`a`a`a`a`a`gc`cbuapbtapb`bh`aewbtdeggbwcdcjaea`a`a`dsa``deeexdidbdidodbcpfjfjfq`dewelfzgcelcdcddsdsdsbiftfqcwbwcid`ctctctctctctctctctctctctctctctctctctctctctctctctctcicjaecjaecjaecjcjcjcjaecjcjae",
+"bgbgbgaebgaebgbgbgaebgaebgbgbgbgbgbgbgbgaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeapffdbdidiff`cexeqflcpee`aaea`a`a`gccdcuft`xcaewftftfbfbfbfbfbcwdagidkbobhdddkgidkdkc`cbdbflflffcicpdidididoffeqcbdiffggc`gidkgidkgicbctctdoclcbbuexbfgeddgedkggbubfembccobucocbdococda`a`a`fjcwdsa`a`a`a`fzeedvexeafsbqeafbewcwbhczeqeqcdcja`a`a`a`a`a`fzbtbtcpex`dciflci`cfjbtfjcdcdcfel`acdedcdgcelcufqbteedbbwdhctctctctctctctctctctctctctctctctctctctctctctctctctcbaecjaecjaecjaecjaeaecjcjaecj",
+"aeaeaebgaeaebgaebgbgaebgaebgaebgbgbgaeaeaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeapdbdididi`capapggcbcqbwdda`a`a`dsgc`acuftcaelewft`hdadadabhbhbhapbwau`cemdkdkgegigidkgegiapapgegic`bcffflfldiffdeeqfhdidbauczgidadkb`dvdifhcbbubucpcl`eczdkdkgfcoczdkgedkdkaob`cbfta`a`a`a`bocwa`a`a`a`bib`dbdeb`ggb`apcwcacwdabhggcbcoela`a`a`dsa`a`a`a`ewgieecpcffjdidbffapbtfjca`d`dewewcaftac`dcud`bfb`dbdodbfjctctctctctctctctctctctctctctctctctctctctctctctctctciaeaeaeaeaeaeaeaeaecjaeaecjae",
+"bgaebgaebgaebgaebgbgbgbsbgaebgbsbgaebgaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjfsdifldbciapdkgeczdeflcbggfba`a`a`fzedcdedbifzedcdcu`hcwcwcwdqdadq`hbhb`ggggbfbobhdkgigigegegegedkgieaczdebufldofhcicocbffflffcogggfgic`aucibucbcbcocidbbudeapbfauc`dkgigibhbncfb`a`a`a`a`a`dacwa`a`a`fzgidvffcieqexc`daftdqfjd`dagicbeqgca`a`a`a`a`a`a`a`gcfjaceqeebi`cdiffcpeefqbt`d`d`d`d`dd`fqfqfqbteecidbexfjcactctctctctctctctctctctctctctctctctctctctctctctctctcbaebgbgbgbga`bgaeaeaecjaeaeae",
+"bgbgbgbsbsbsbsbgbgbgbsbsbgbgbgbgbgaebgaebgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjaeaeeefldbexapc`czgedkczcbflauc`gca`a`a`dsa`aeaefzgcgc`aewft`xftfbcuftcuelcddac`czggczdkdkdkgidkddgic`gigigic`c`c``ccbdiflbucbcbcpcldbffggdkbhdkc`bceq`ecbdofhcogigidec`gegigeaca`eleefza`a`a`dsfj`ha`aea`fjdvcpffffcb`cfjftacdafjdafbfjau`cgca`a`a`dsa`a`a`a`a`elacfjcpcabicicpex`cbtbt`d`dfqaccwbtapapapeeb`dbb`elcjeldibibibibibibibibibibibibibibibibibnbibnbibmbnbnbnbgaeaeaeaeaebgaeaeaeaeaeaecjae",
+"bgaebsbsbsbsbsbsbsbsbsbgbgbgbgbgbgaebgbgaebgaeaeaeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjaeae`cdicibfbhgiggggczgiczffcbdebhdsa`a`a`aecja`ftcufzedewewewewewewewcdbnewcuftcwdkgigidacwdabhgiczczc`gfc`ggbweq`ecbflendoflcpdvffcpbucpcoggdkbhfjbhggflflbuffgggiggggdkgidkcfaeel`cfza`a`a`a`bhfba`cjftcpdbcbflflcb`ccw`hfjdacwcwdafq`cczfza`a`a`a`a`a`dsa`cjgcd`cfeq`cbgcfcicibtd`fjfjfjdhapb`b``c`cb`eeeqdbd`cjcjelflcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaebgaeaebgaebgaebgbgaebgbgaeaeaeaeaeaeae",
+"bgbgbgaebgbsbsbsbsbgbgbgbgbgaebgbgbgaebgaebgaebgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcffscbffapbhgigegic`auggc`audvcogg`hdsa`a`cja`aeda`ha`gc`acdcuewewewcucdcdcaft`xftft`hdadagebceabobhbhczcbbudvdicqffdiclfldictdofldvcpbucicocicogggifjapflcqcbdbdbauggbcbhdkdaelcjel`cgca`a`a`dsdafta`el`cdoeqcidbdicb`cbhdabhcwcwaodddkggapfza`a`a`dsa`a`a`a`a`dscwcmd`cbd`cjcacpcifj`dbtapeeb`eeb`b`b``ceqflexaecjcjeldicjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgbgbgbgbgbgbgbgbgaebgbgbgbgaebgbgaeaebg",
+"aebgaebgbsbgbgaebgaebgaebgaebsaebgaebsaebgbgbgbgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjfjdbcpapbtdkapggc`ggggggdedeflffgggicda`a`cja`a`cubhededcdcacwcwfbftcughewfbfbdqcwdabhgiggggczdkdkbfggcoauc`bcflcoexflfldodofldododocleq`ecocbcicbdvcbggcidvdbfhdoffauggdkdkcwelcjbib`cdcja`a`cdbhftew`ccidicpciffdicbexc`fqdacwaobfgifjggapfza`a`a`a`a`a`dsa`a`a`cd`dbnexb`bncjeleqcifjbt`cexapeeexcpdbdbcbexcacjaecjbiapcjaecjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaebgbgbgbgbgaebgaebgbgaebgaebsaebgbsaebg",
+"bgbgbgbsbgaebgaebgaebgbgbgbgbgbgbsbgbsaebsaeaeaebgaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjdhcpfsaobhdkgiggcobucoauaubufhffb`ggcwgcbia`a`a`a`bhcwedew`xfbcwda`hcacufbdacwdadkgiggbac`czggauauczbh`hewftc`bucocbfhflfldidbcldidbffdbcigg`cbceq`efffhdbcbeqdecodeggggbtbhaocdcjbib`cfaecj`ddeggcweeffcpfldocpcpdbdbcb`caydafjgiapbhgcapapa`a`a`dsa`a`a`a`a`a`a`cjcmelfjcicfbicjbn`cflflflflfldifldbcidhcabnaeaeaeaecjcjaecjaeaecjaecjcjcjcjcjaecjaeaeaeaeaebgbgaebgbgbgbgbgbsbgbgbgbgbgbgbgbgbgbgbgbg",
+"bgbsbgbgaebgbgbgbgbgbgbgbgbgbgbgbgbsbsbsaebgaebgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjfjcbbffjdkddgegebcflflclcpdifhbudeczbccwededbia`a`fzbhfbewftcuft`hdqftcwdadabhgiggauggggeqcodegiacewfza`a``agfffffdpflflcldodofldbcpcpcpffflcoapapggeqexcocldvclcidegg`cczddbhcfcjbgeeftcjcacicpex`ccbdbcpdiendbcicpflflggddapb`c`bhfteweagifza`a`a`a`a`dsa`dsa`cjcjelcaelcidhcjcjcjel`ccbapfseeeebtaccfbnbgcjaeaeaebgcfflaebgaeaeaeaecjaeaeaecjaeaeaeaeaeaebgbgbgbsbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbgbg",
+"bsbsbsbsbsbsbgbsbgbgbgaeaebgaebgbgbgaeaeaeaeaeaeaeaecjaeaecjcjcjcjcjcjcjcjcjcjcjcj`deqc`bhdkdkgegicobucldvclfhclggaudkbf`ccwcdewedfzdsgcfbcdcdew`xftfbfbdadkc`bccoaubceqbcdkfbew`afza`dsgc`acwbwffffcbdvdbdbflcbcicieqexexcicifldbco`cc`b`ggbccicpfldvcpffbudeapfbaecjdh`dbgeqcpeqapcbcpdbcpcpdidicpciffdicib`ggb`apgibccoc``aa`a`a`a`bia`a`a`a`aecjcjcjaceldh`caecjcjcjcjelbiaeaecjcjaeaecjaeaeaeaebgbgcfflaebgbgaeaeaeaeaeaeaeaeaeaeaebgbgbgbgbsbsbsbsbsbsbsbgbgbgbgbgbgbgbgbgbsbgbgbgbg",
+"bgbgbgbgbgaeaeaeaeaeaeaebgaebgaeaeaeaeaeaeaeaecjaeaecjaeaecjcjcjcjcjcjcjcjcjcjcjcjelexb`dkdddkgiczcocodedecbbucbczb`c``hgigggiftcuewcdgcgc`aewftfbcuftdkb`debubudeczapcw`aedgca`a`a`gccdcufbgi`ecocbcoflfhded`cmacb`ciex`c`c`cexcicpdbclexb``cggbceqeqcocpdbflcp`cd`elaoapb`dodiee`ccpcpdecbbudbenflcibceqcbeq`cb`eqffcbc`cda`a`a`dsa`a`dsa`a`aeaecjcjcjelcfbi`ccacjcjcjcjcjcjcjcjcjcjcjcjcjaeaebgbgbgbgcfflaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaebgbsbgbgbgbgaebgdscxaebsaebg",
+"bgbgaebgaebgaebgaebsbgbgbgaeaeaeaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjaeaecjcjcjcjcjaeb`bcdkdkgegib`aubu`edegaffflggapdec`eaco`ec`bocwdqcwdqdabodadagibccobucldec`dacu`a`agca`a`a`a`gc`afbdadkggggggcbclcpbqcaaecjcjcfb`cieqex`c`c`c`cexcbdvdbciexb`apb`bcggc`b`decobucieqdidiflcpexffdbcbciffffbudiendicpffffflflflflco`hdsa`a`a`a`a`a`a`a`a`a`a`a`a`aecjaecfbgfsb`cjcjcjcjcjcjcjcjcjcjcjaeaeaeaebgbgbsbsghdo`cb``c`cgg`cgg`cb``cb``cb``cb`fd`cb``cfd`cfdb`fdfjaebgbgbgbgebcefmfmg`bgbgbgbg",
+"aebgbgbgaeaebgaebgbgaeaeaeaeaeaeaeaeaecjaecjaecjaeaecjcjcjcjcjcjcjaecfbicjcjcjcjcjcjbtgggigegigiggcoclffdvffbuffczgec`ggc`ggcocbauczdkdkgigebtgfdefffldvdec`daewewew`afza`a`a`a`fz`afbdabhgieagfggcb`ccabiaecjcjcjcjbnd`eeexciciex`c`cb`exciffffcobcggfsc``cggc`apc``ccpenencpcbdbffcicbcoaucbcocididodbffcpbucbdec`aca`a`a`a`a`a`a`dsa`a`a`a`a`a`a`a`a`cjbnbibnexelcjcjcjcjcjcjcjcjcjcjcjcjaeaebgbgbsbscfctctctctctctctctctctctctctctctctctctctctctctctctctcbaebsdsfvfmfmfmfmfmfmfzbgbgbg",
+"bgaebgaebgaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjaecjcjcjcjcjcjcjacbcbfdkgic`aucobubuclffdvcogigidkapgidkemc`ggdebcgggigibcbudvbudec`gi`hcucu`agca`a`a`a`fzgccdfbdadadadaap`cexfsbiaecjcjcjcjcjcjcjaebnacap`cexeq`cb``c`c`cexcicpffciex`cb`cbeq`cc`apbcdbflflffdeggggggggbcggc`b`exbcfqcwcaedfzfza`a`a`a`aeaedsa`a`a`dsa`a`dsa`a`a`aecjaeelaeeebtcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgbgbsghctctctctctctctctctctctctctctctctctctctctctctctctctcibsbsbsgdfmfmfmfmfmfmcedsbgbg",
+"bgaeaeaeaeaeaebgaeaeaeaecjaeaeaeaeaebsbsaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgb`b`gedkc`cobubu`e`ecbclffczbhbhbobhdkfqdacwdqfqgiczc`boapeqgggigedafbcdgcdsa`a`a`fzgccdewcuehft`hbhap`c`cd`aecjcjcjcjcjcjcjcjcjcjcjbielaodd`ccbex`cb``c`c`ceqffdbdbcpcbffggeqeqbwexcifldibuc`c`czggb`gfgifjftftewfza`a`a`a`a`a`a`a`cjcjaea`a`dsa`a`a`a`a`a`a`a`a`cjcjbiae`db`bgcjcjcjcjcjcjcjcjcjcjcjaeaeaebgbgbscfctctctctctctctctctctctctctctctctctctctctctctctctctcbaebsdscxfmfmfmfmfmfmfmbgbgbg",
+"aeaeaeaeaeaeaeaeaeaeaeaeaeaecjaecjaeghacgcaeaeaecjaecjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjfqb`gegiggdedeggbwauggbcczbhfbewewcd`acd`acded`a`acdewcuc`degfdkdkcw`adsdsa`a`dsfzcdewcufb`xcafbeebcb`apelcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbicadhcbci`cb`b``c`c`cexcbdbffffdoffffciapapcbdbcob`gigiapdkdqcuedgca`a`dsdsa`a`a`a`a`a`a`aecjcjaea`a`a`a`dsa`a`dsa`a`a`cjcjcjcjcjaefsd`cjcjcjcjcjcjcjcjcjcjaeaeaebgaebsbge`ctctctctctctctctctctctctctctctctctctctctctctctctctcibgbsbsbsg`fmfmfmfmfmfmfzbsbs",
+"aeaeaeaeaeaecjaeaeaeaeaecjaeaeaeaeaebibnbibmcdelbgcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjca`cgigiggb`gfggdecobcgibhcdbia`dsa`a`a`dsa`a`a`a`a`fzdkaubfdkbhcw`adsa`a`a`a`dsedewewftftftdd`c`cb`acaecjcjcjcjaecjaeaecjcjcjcjcjcjcjcjcjbieleeexb`b``cb``cb``c`cciffflendidbfhbcgg`cbcggc`gedaftcucdcdfza`a`gcedgcbia`a`a`a`a`a`a`aeaea`a`a`dsa`a`a`a`a`a`a`cjcjcjcjcjcjcj`deeaecjcjcjcjcjcjcjcjcjcjcjaeaeaeaebgcfdocacacmcacacmcacmcacmcacmcacmcacmcmcacmcacmcmcmb`cbbgbmbsds`gfmfmfmfmfmfmgdbsbg",
+"aeaeaeaeaeaeaeaecjaecjaeaecjcjaecjaeaecjaeaeaeaebgaeaecjaeaecjaecjcjcjcjcjcjbgcjcjcjcjbgggc`ddgiggcocoggczggea`hcjcja`a`a`a`a`a`a`a`dsa`dscwcobcbhdafbcda`a`a`a`dsa`fzed`aewcfcw`cci`caybncjcjcjaeaecjaeaecjaecjaecjcjcjcjcjcjcjbgbi`db`b`b`b`b`b``c`c`c`ccicpdidoclflggggcoggge`hftewewcu`afza`dsedcd`aedfza`a`a`a`a`a`a`a`a`a`a`a`a`a`dsa`a`a`aecjcjcjcjcjcjcjcjbnfscfcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaecfflaebgbgbgbsbsbsbmbsbsbgbsbsbsbsbmbsbsbmbmbmbmbgaocibgbmbmbsebfmfmfmg`gdcxa`bsbg",
+"cjcjcjcjcjaecjcjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaecjcjaecjcjcjelbicjcjcjcjbtczgegiggcbcoc`bocuddapfjewgcgcgcdsa`a`dsa`a`a`cdbccbgecwft`aa`dsa`dsa`a`a`dsbicdcmapclcpfselcjcjcjaeaecjaeaecjaeaeaecjcjcjcjcjcjcjcjcjaebicaeeb`eeb`b`b`b`b`b``cexeqdbdicpfldeapgibhcdgcewewcucdgca`a`edewcucd`agcdsa`a`dsa`a`a`a`a`a`dsa`dsa`a`a`a`aeaecjcjcjcjcjcjcjcjaed`d`cjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaee`flaebsaebgbsbsbsbsbsbsbsbsbsbgbsbmbsbmbsbmbsbsbmaocibgbsbsbsa`fvbrbsbgdsbsbsbgbs",
+"cjaeaeaeaecjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaecjcjcjaecjcjcjcjac`cbhgegiczbcbc`ha`cufsb`b`ggdk`hgca`a`a`a`a`gcapbuc`daftcdfza`a`a`a`a`dsa`aebncwexdbexd`aecjaeaeaeaeaeaeaeaeaeaecjaecjaecjcjcjcjcjcjcjcjbncfddeeeeb`b`b`b`b``cb``cexcpendvdvcogebofb`acdcuewewgca`dsedcdcuewewgca`dsfzdsa`a`dsa`dsa`a`a`a`a`a`biaecjaea`aeaecjcjcjcjcjcjcjeldhbncjcjcjcjcjcjcjcjcjcjaecjaecjaebncbaebgbgaebgbgbgbsbsbgbsbgbsbgbsbsbsbsbsbsbsbsbmcmexaebsbsbsbmbsbsasbsbmbsbmbsbs",
+"aecjaecjaeaeaeaeaeaeaeaeaeaebgbgbgbsbsbsbsbsbgbgbgasbmbgaeaeaeaebgaeaeaecjaecjcjcjcjcjcjbib``cc`czdkgeeaapdaewcacdftda`hewfzdsa`dsa`a`dqbudebhaceweddsa`a`a`a`dsa`bielfscpciaybscjcjaeaeaeaeaeaeaeaeaeaeaeaeaeaecjcjcjcjcjcjcjcjcjaebnfjb`eeeeeeeeb`b`b`b`b``ccidodbcbclapcwfbewcucuewgca`dsedewcuew`agca`gc`agcgcbia`a`a`a`a`dsa`a`a`a`aecjaea`a`a`cjcjcjcjcjcjcjcjaebtd`cjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjaeaebgaebgbgbgbgbsbsbgbgbsbgbgbsbsbgbgbsbmbmaeaebgbsbsbsbsbsbsbsbsbsbsbmbsbm",
+"aeaeaeaeaeaeaeaeaeaeaebsbsbsbsbsbsbsbsbmbmbmbsbsbsdtdtbmbgbgbgbgasbnbgaecjaecjcjcjcjcjcjcjfjdv`cdeb`gedkdqcwddfbaecja`a`a`a`a`a`a`a`fz`ccbgedaew`adsa`aeaea`a`a`gcbheqcpfsbmaecjaebgbgaebgaebgaeaeaebgaebgaeaeaeaecjcjcjcjcjcjcjcjcjbicab`apeeeeeeeeb`b`b`b`b``cdiflcbdvc`cwdqftcueweddsfzcdcuewewcdgcfzgcewcd`agcfza`dsa`a`a`a`a`dsa`a`cjaeaea`a`a`aecjcjaea`a`cjcjcjfqfscjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaebsaeaeaebmcfghcabmbgaeaebgbgaebgbsbsbsbmbmbsbsbsbgbsbsbsbsbsbsbsbsbs",
+"aeaeaeaeaeaeaebsbsbmbmbsbsbsbsbsbsbmbmbmbmbsbmbmbmbsbmbsbsbsbgbgbgbgbgaeaeaecjaecjcjcjcjcjbneqflcodegggifbewcdacdaela`a`a`a`a`a`a`a`dadvczdkftela`a`a`a`a`cjaeca`ccbb`cfaecjaeaebgaeaebgbgaebgbgbgbsbgaeaeaeaecjcjcjcjcjcjcjcjcjcjaebicfeeeeapeeeeeeeeeeb`b`b`b`cpdocpdvggbofj`hew`afzgcewewcuewelgcfzedewewcuewgcfza`a`a`a`a`dsa`dsa`aecdgbfza`a`aecjcja`a`a`a`aecjaecfapacbgcjcjcjbgbgcjcjcjcjcjcjcjcjcjaecjaeaeaeaebmapclctctctctctctctclfsbsaeaebgbgbgbgbsbsbsbgbsbgbsbsbgbsbsbsbsbsbs",
+"aebgbgbgbgbgbsbmbmbsbsbsbsbmbmbmdtbmbmbmbmbmbmbmbmbmbmbsbsbsbsbgbgbgbgaeaeaecjaecjcjcjcjcjcjelcifl`ededeapdacuedcdcudsa`aea`a`a`a`fzexcogiaocfa`aea`aeaeaedsfqci`ccfbgaeaeaebgaebgbgbgbgbgbgbsbsbgbgaebgaeaeaecjaeaecjcjcjcjcjcjcjcjbicaapeeapeeeeeeeeb`b`b`b`b`cidicldbcodkbhftewededewcucuewelgced`acucucuew`afzdsa`a`dsa`a`a`a`a`dsa`fzapc`cdaecjcja`a`a`a`a`cjcjcjbneeb`cmcjcjcjbibicjcjcjcjcjcjcjcjcjcjaecjaeaeexctctctctctctctctctctctctctbcbmaebgaebgbsbsbsbsbgbgbgbgbsbsbgbsbgbsbg",
+"bgbgbgbgbsbsbsbsbsbmbmbmdtdtdtbmbmbmdtdtdtdtdtbmdtbmdtbmbmbsbsbsbgbgaeaeaeaeaecjcjcjcjcjcjcjcjcmbcffco`caugggi`hcdfza`a`dsa`a`a`cjfqcbapbhacgccjcjaeaefzfbb`eqaobgaebgaeaeaebgbgaebgbgaebgaebgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaecabteeapapeeeeeeeeeeeeb`b``cfldvclffgfbhftelcdewcuftcdgced`aewcuftcuewedfza`a`a`a`a`a`dscafzaefzaccda`daeaftcja`a`a`a`a`a`aeaebiacfscbfscjcjcjcjcjbgbgcjcjcjcjcjcjbgbiaecjeldoctctctctctctctctctctctctctctctctfsaeaebgaebgbgbgbgbgbsaebsaebgbgbsbgbs",
+"bgbsbgbsbsbsbsbsbmbmdtdtbmbmbmdtdtdtbmdtbmdtbmdtbmdtbmbmbsbsbgbgbgbgaebgaeaecjaecjcjcjcjcjcjcjaecf`dciff`cb`czc`dacdgcdsa`a`a`aebnco`cbhaoewaecjfzcugeggdeapbnaebibgaeaebgbgaebgbgbgbgaeaebgaeaeaeaeaeaeaecjaeaecjcjcjcjcjcjcjcjcjcjcjbnfjb`apfseeapeeeeeeeeeeee`cffdbffffapdaftewew`xcaedaselewcuft`xcaewgcdsdsfzfzbia`dsa`a`dadk`aaeewbffbaegcbtfjcda`a`a`a`aea`gcbfapd`ex`cbgcjcjcjcjaeaeaecjcjcjcjcjbgbgcjacctctctctctctctctctctctctctctctctctctctbcaeaebgbgbgbgbgaebgbgbgbgbsbgbgbgbg",
+"bgbsbsbsbsbmbmbmbmbmbmbmbmdtbmbmbsbmbmbmbmbmbmbmbmbmbmbsbsbgbgbgbgbgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjel`cdveqgidkdacdgcfza`a`a`aefscpgibh`da`gcdaggcbciapelcjaebsaeaeaebgaeaebgbgbgbgaebgaebgbgbgbgaeaeaeaeaecjcjcjaecjcjcjcjcjcjcjaebgaeacb`eeeefsapapapapeeeeeeeecbflcpdvczda`hewcucuelgccdcu`xftewcu`afzdsgccdcdedfzdsa`a`a`fzcwbfcwfzewgiftcja`dadkcwa`a`aea`daczbtgcaed`cicfcjcjcjcjcjbncwcacjcjcjcjcjcjcfctctctctctctctctctctctctctctctctctctctctctbcaeaebgbgbgbgbgbgbgbgaebgbgbgbgbg",
+"bgbsbsbsbsbmbsbsbmdtbsbmbsbmbsbmbmbmbmbmbmbmbsbmbmbsbsbsbgbgbgbgaebgaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjbgfjcpdb`ccwbidsa`dsa`cjftexeebhaobhapcifhcbdhelcjcjaeaeaeaeaebgbgbgbgaebgbgbgbgbsbsbgbgbgaebgaeaecjcjcjcjaecjcjcjcjcjcjaeaebgaeaeelapb`fsfsapfsapapapeeeeeeeqflcbffdebo`hcuewcdgcewftewftcucdedbigccdewcucuedgcdsa`a`a`a`a`cdgidacjbifbcaa`aecdcudsaegceaggfba`aea`edeqdhcjcjcjcjcjeld`elcjcjcjcjcjbgdoctctdb`cayaccacacmcacacacacacaacayeecbenctcteeaebsbgbgbgbgbgbgbgbgbgbgbgaebg",
+"bgbsbsbsbmbsbsbmbmbsbsbsbmbmbmbmbsbsbsbsbsbmbsbsbsbsbsaebgbgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjeleeffbuapcdaeaecjbn`capfjb`buffcpeecwbncjcjcjaecjaeaeaebgaeaeaebgbgbsbgbgaebgbgaeaeaeaeaecjcjcjcjaeaeaecjcjcjcjaeaeaeaeaeaeaebsfjeeeefsfsfsapapapeeapeeexdbcicpcodk`hcucdelewftcuftewewcdcdcdca`xftftcuedgca`a`a`a`a`a`edftcwcwaea`ftdafza`aefzfqaugg`aaea`a`gcgc`cb`cjcjcjcjcjaebgcjcjcjcjcjcjcbctexbgaeaecjbgaebgaebgbgdtcmdtbgbgaebgaebgayctctbmaebgbgbgbgbgbgbsbgbgbgbgbgbg",
+"bgbgbgbgbsbsbmbsbmbmbmbmbsbsbsbsbsbsbsbsbsbsbsbsbgbgbgaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjeleecbb`caaecjbteqeabudbcidhelaecjcjcjaeaeaeaeaebgaebgaebgbgbsbsbsbsbsbgaeaeaeaeaecjcjaecjaeaecjcjcjcjcjaecjaeaeaeaeaeaeaeaecaeeeefsfsapfsfsfsapapee`ccpcbcbbugiftftewcdcafb`h`h`hfbewewftftftcuewcdgcdsa`a`a`a`a`ftdafza`cfcwgcdscugca`cdggbugifza`a`a`a`fzbibtcibicjcjcjcjcjcjcjcjcjcjcjbnctapcjcjaecjaebgaeaebgbgbselcmbmbgbgbgbgbgbgaebidieqaebgbgbgaebgbgbgbgbgbgbgbgbg",
+"aebgaebgbsbsbgbsbsbsbsbsbsbsaebsaebsbsbgbsbsbsbgbgaebgaeaeaeaeaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjelfjeeddbfci`capfscwelcjcjcjcjaecjaecjaebgaeaeaeaebgbsbsbsbsbgaeaeaeaeaeaeaeaeaecjaeaeaeaeaecjcjcjaecjaecjaeaeaebgaeaeaedtfsb`apfsfsfsfsfsapapapb`cbcbbccpgg`hdqghftdqdadqfbftdabhehcucuewcdfzdsa`a`a`a`dsa`a`dab`fba`aeedftfza`a`fjgaeqfba`a`a`a`a`a`bifzcfeqaccjcjcjcjcjcjcjcjcjcjaeapdbcjcjaecjaeaeaeaebgbgaebgbgbgbgaebgbgbgbgbgbsaeayctaebsbgbsbgbsaebgbgbgbgbgbgbg",
+"aeaebgaebgaebgaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgbgaeaeaeaecjaecjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjbgbncfcfcfeldtbgcjaecjaeaeaeaeaeaeaebgbgbgbsdtdtbsbgaeaeaebgaeaeaeaeaeaeaeaeaeaecjaecjaeaecjcjcjaeaeaeaebgbgbgaeaeaed`eefsfsddfsfsfsfsfsapeeeqbuc`cbcocw`hcwdabh`hftftftcabhdkfbeddsds`afza`a`a`a`a`a`fzcdfbgicwftdacdedfbggffbffza`a`a`a`a`a`a`a`ewcaapfscjcjcjcjcjcjcjcjcjcjaeexdhcjcjcjcjaecjaeaeaebgbgbgaebsaebsaebgbsaebsbgbgbgctdtbgbsbgbsbsbsbsbgbgbgbgbgbg",
+"aeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebsaebsaeaeaeaecjaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaebgcjcjcjcjcjbgaeaeaebnelelcacfbnbgcjaeaecjaeaeaeaebgbnbmbgbmelbsbgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaeaeaeaeaeaebgbsbsaebgbgaebnddfsfsfsbtfsfsfsfsfseebcffcobuffbhftbhdabhdadqfbcucded`hfjcda`dsddgicda`a`bia`a`cddaapftbhbudegic`ffbucwa`a`a`a`a`a`a`a`a`a`ftc`de`ccjcjcjcjcjcjcjcjbgcjcjcpelcjcjcjcjaeaeaeaebgaebgbgbgbgbgbsaebsaebsbgbgbgaedbaobsbgbgbsbgbsbgbsbsbsbsbsbg",
+"cjaeaeaeaeaeaeaeaecjaecjaecjaeaeaeaeaeaebgaebgaebgaeaeaeaecjaeaecjaecjcjaecjaecjcjcjcjcjcjcjcjbgbibgcjaeaecjcjcjbicaftbnaebncacfbnbgbgbgaeaecjaeaebgbgaeaebge`bnaebgbgaebgaebgaeaeaeaeaeaeaeaeaeaeaebgaeaeaecjcja`cjaeaeaeaebgbibsbgbsbsbgaeaeaofsddddddbtddfsfsfsfs`ccicocbdicoemfqcwdadacw`hcuew`agccubhdqededdkapcweda`a`gcfbb`ggcwgiffdvdbflexfta`a`a`a`a`a`dsa`a`a`a`a`ft`ccibncjcjcjcjcjcjcjbicjcjffbncjcjcjcjcjaeaebgbgbsaeaebgaeaebgbgaebsaebgbsbgaeciaobsbsbsbsbsbsbsbsbsbsbgbsbs",
+"cjcjcjcjcjcjcjcjcjaecjcjcjaecjcjaeaeaeaeaeaeaeaeaeaebgaeaeaeaecjaecjaeaecjcjcjaecjcjcjcjcjcjcjbicfbicjcjcjcjcjcjcaaoelbiaebgbgbibnelbibgcjaeaeaebgbibgaeaebgbgaebgaebgaebgaeaeaebgaeaeaeaeaeaeaebgbgbgaeaeaecjaecjaeaeaeaebgbsbsbgbsbsbgbgaeaecfapfsddddddbtfsfsfsfsb`exdeddbueneqggczgfbhfbewewftgidaewfbbhdkcwcddagidagcdsbhc`eqclcbdbdeggbucibhedfza`a`a`dsa`a`a`a`bia`a`cjbg`caccjcjcjcjcjcjcjaebibgcbcmcjcjaebibgcjcjcpghaeaebgbgaebsaeaeaebgaebgbgbgaeffcmbgbgbsbsbsbsbsbmbsbsbsbsbg",
+"cjaecjcjaecjcjaecjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgaebgbgbgaeaeaeaeaeaecjaecjaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaecjaebgbiaeaeaebgbieldtbiaecjaeaeaeaebgbgaeaeaebgaeaebgbgaeaeaebgaeaeaeaeaeaeaeaeaebgbgbgaeaeaeaecjaeaeaeaeaebgbgbgbsbsbsbsaebsaeaeaefjapddfsdhddbtddbtfsee`cco`cclenggdkggcocbcobcc`giczczbhewcudadkbhcucugiggeqffdvffeqcbbugg`cdeapgicwfzdsa`a`a`a`dsa`a`cddabiaegcbtcmcjcjcjcjcjcjcjcjcacfeqcicjcjcjbibgcjaecbcabgbgbgbgbgaebsaebgaeaeaeaeaeaectelaebgaebsbsbsbsbsbsbsbgbgbs",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaebgaebgaebgbgbgaebgaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaeaeaeaeaebgbgaeaecjaeaeaecjaeaeaeaeaeaebgaebgbgaebgaebgbgaeaebgaeaeaeaeaebgbgbsaeaeaeaeaeaeaeaeaeaebgbgbgbibsbgbsbgbgbsbsaeaecjbifsfsdddddhddbtddbtee`cco`ceqdofleqggbuflfhfhfhbubudvclbwc`giggeqexcocbffdbcbaucbeqgfbcdvdbbubcczacfzdsa`a`dsa`a`a`a`gcfbfqdaacbtfjcjcjcjcjcjcjcjcjelcfeectcmcjcjcjcjaecjcpghbsaebgaeaebsaebgaeaeaeaeaeaebqctaebgbgbsbgbgbgbgbgbgbgbgbsbg",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaebgbgbgbgbgbgbgaeaebgaeaeaeaeaecjaecjaecjcjcjcjcjcjcjcjcjaeaeaeaebgbgbgaebgaeaeaeaecjaebnbiaecjaeaecjbgbgaebgaebgaebgbsaebgaeaebgaeaeaeaeaeaeaebgbgaebgaebgaeaeaeaebgaeaebgbgbsbsbgbsbsbgbsaebgaeaecjcjcmapfsddbtddbtddddapb`exb`aycbfhcbcbfffldvclbubucobucbcbcqffbucococpcbcobcggcobccoffbueqdeauczcwgca`a`a`a`a`a`dsa`gccdbicwdegicwddcjcjcjcjcjcjcjcjaeelcactctcpapfjcacacadbcabgaebsaebgaeaeaebgbgbsaeaecactcpaeaebgaeaeaeaeaeaebgaebsaebs",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaebgaebgbsbsbgbgbgbgbgbgaebsaeaeaeaeaeaecjaecjcjcjcjcjcjaeaeaeaeaebgbgbgbgbgbgaebgaeaeaeaeaeaecjaeaeaebgelbmbgaebgaebsaeaebsaebgaeaeaeaeaeaeaeaeaeaebgaeaebgaeaeaeaebgbgaebgbgbgbgbgbsbsbgbsaebsaecjaeaecjbgacfsddaydhaybtayfseeeqggdd`cdvczczbc`ecoau`ecb`fbuclcbbuflbuco`e`ebudvbubucobudbdvbuaub`c`cwfza`a`dsa`a`dsa`a`a`a`acdkcwcwbhb`apcjcjcjcjcjcjcjcjcjbibneqctctctctctctctctghaebsaebsaebgaeaeaecjaebgbqctctcaaeaeaebgaebgaeaebgaeaeaeaebg",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaebgbgbsbsbgbsbsbsbsbsbgbgaeaeaeaecjaecjaecjcjaecjaeaeaeaeaebgbgbgbgbgbgbgbsbgbgbgcjaecjcjaecjaebgaeaeaeaeaebgaebgaebsaebsaeaebgaeaeaeaeaeaeaeaebgaeaebgaeaebgaebgbgbgaeaebgbgbgbgbgbgbsbgbgaebgaeaeaeaeaecjaed`dddddhdddhbtbtapexdegg`cdbcogigeapggggczggggbccogabwdebudvffbubucpcqffdbfhcpau`caubcbh`afzdsa`a`a`a`a`a`dsa`a`cdgggg`hbheqeqbicjcjcjcjcjcjcjcjcjcjaedictctctctctctctcabgbgbgbgbgaeaeaeaeca`cdoctctdbcjaecjaeaeaeaeaebgaeaeaeaeaebg",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaebgbgbsbsbsbsbsbsbsbgbgbgaeaeaeaeaeaecjaeaeaeaeaeaebgbgbgbgbgbsbsbsbsbsbsbgaebgaeaeaecjcjaeaebiaeaeaebgbmbgbgbgbsaebsaeaebgaeaeaeaeaeaeaeaeaeaeaebgaebgaebgaeaeaeaeaebgbsbgbgaebgaebgaebgaebgbgaeaeaecjaecjbnfjddfsaydhdhdhfsbcexexcofldvgggegegeeagfgegigiczggde`eauclcqcbcbcodebccoffc`gidkgiemfbgcdsa`a`a`a`a`dsa`a`a`a``hggdec`ddfs`caccjcjcjcjcjcjcjcjcjcjcjbidoctctctctctctcaaebsaebsaebsaeaecictctctctctcfcjcjaecjcjcjaeaeaeaecjaeaeaeae",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaebgaebsbsbsbsbsbmbsbsbsbsbgbgaeaeaeaeaeaeaeaeaeaeaebgbgbgbgbgbsbsbsbsbmbsbsbsbgbgaeaeaecjcjaeaecjaeaeaeaeaebmghbmbgbgbgbgbgaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaeaeaebgaeaebgbgbgaebgbgbgbgaeaeaeaeaeaeaeaeaeaecjaecjcfayfsfsdhdhdhdh`ccobccpfleqcogfgidkgiczbfgegiapgigiczeqco`ccobu`udabhbucogigigibfcw`agca`dsa`dsa`a`a`a`a`a`a`cddaacapgicfdhbncjcjcjcjcjcjcjcjcjcjcjcjbgcpctctctctctcaaeaebgaeaeaeaecjapeqeqeqeqbqcjcjcjcjaecjaecjcjcjcjaecjcjaecj",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaeaebgbgbgbsbsbsbsbsbsbsbgbgbgaeaeaeaeaeaeaeaebgbgbgbsbsbmbsbmbsbmbmbmbmbsbsbsbgaeaeaecjaeaecjaeaeaecjbge`bnbsbmbmbgbgbgbgaebgaebgaeaeaeaeaeaeaeaeaebgaebgaeaeaebgaeaeaeaeaebgaebgbgbgaeaebgbgaeaeaeaeaeaeaecjaeaeaeaecfdhfsfsddfjdheacbdecodiczgg`cdkgigigic`gigeeaczfagic`bcggczggczbhggbugic`deggczbhewgcdsa`a`a`a`bia`dsa`bia`a`dsgcacdhbtdhaecjcjcjcjcjcjcjcjcjcjcjbibnbgcaexdictctghaebgaebsaeaeaeaecjcjcjcjcjcjcjcjcjaecjaecjcjcjcjcjcjcjaecjae",
+"cjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaeaeaeaebgaebsbsbsbsbsbsbsbgbgaeaeaebgaeaeaeaebgbsbsbsbsbsbmbmbmbmdtbmbsbsbsbsbsbgaeaeaecjaecjaecjaeaeelbsbgcad`bmbgbgbgbgbgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaeaeaebgaeaebgaebgbgbgaebgaeaeaeaeaeaeaeaecjaeaeaeaeaecjaecmayfsdddhfjfseqeq`cfhdegibwczdkgegigfeagegiapeaczgigegggggidagibuggcwczcoaubcc`ewfza`a`a`a`a`a`a`a`gccweda`a`cffjcffsfjcjcjcjcjcjcjcjcjcjcjcjcjaebibicjcjcjcjaeaeaeaebgaeaebgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjae",
+"cjcjcjcjcjcjcjcjcjaecjaecjaecjaeaeaeaeaeaebgbgbgbsbsbsbsbgbgaeaebgaeaeaebgaebgbgbsbsbsbmbmbmbmdtbmbmbmbmbsbsbsbgaeaeaecjaecjcjaecjaebsghghbgbmbmbsbgbgbgbgbgaebsaeaeaeaeaeaeaecjaeaeaeaeaebgaebgaeaebgaeaee`e`aeaebgbgbgaeaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaeeldhddfsaydh`ccb`cdvffbfemdec`dkgegigigfgegegigiczc`gec`czdafjauapdaggapbhc`apgca`a`a`a`dsa`dsa`a`fzdkdaa`aebicmfjcaddcacjcjcjcjcjcjcjcjcjelcteqcmcjcjcjcjaeaeaeaebgaebgaeaeaeaecjaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cjcjcjcjcjaeaeaecjaeaecjaeaeaecjaeaeaebgaeaeaebgaebgaeaeaeaeaeaeaeaeaeaeaebgbgbsbsbsbmbmdtbmdtbmbmdtbmbmbsbsaebgaecjaecjcjaecjaeaeaebgbsbmbsbsbgbsbgbgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaeaebgaebgaeaebge`ddghaebgbgaeaebgbgaebgaeaeaeaecjaeaeaeaeaeaeaeaeaecjcjelfjbtddddeecpeqcbcqc`dkczggbfgigegibfapgegigiembfc`gidkbhggczboggdkewfbgecwfza`a`a`a`a`a`a`a`a`a`cdfba`cjcjaodhcffsbicjcjcjcjaecjcjaecjcjbiapffctcicmaecjcjaeaeaebgaebgaeaeaeaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cjcjcjaeaecjcjaeaeaecjaeaecjaeaecjaeaeaeaebgaeaeaeaeaeaebgaeaeaeaeaeaeaebgbgbsbsbsbmbmbmbmbmdtbmbmbsbsbsbgbgaeaecjaecjcjcjcjcjaeaebgbgbgbsbsbsbsbsaebgbgbgaeaeaeaeaeaeaeaecjaeaeaeaeaeaebgbgbgaeaebgaebgele`bgaebgbgbsbme`ercme`bsaecjaeaeaeaeaebgaeaeaeaecjcjcjcjcffjbtayapco`e`cflcogidkgggggiddgegigegigigegigigic`bocuapb`bfc`dk`hgidkgcdsa`a`a`bia`a`a`a`a`a`a`a`a`cjelfs`dfjfjcjcjcjaeaecjaecjcjaecjcjcjcjaefsffctciacbgcjaeaebgaeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaecjaeaeaecjaeaeaeaeaecjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaebsbgbsbsbmbmbmbmdtbmbmbmbsbsbsaebgaeaeaeaecjcjcjcjaecjaeaebgbgbsbsbsbsbgbgbgbgaeaeaeaeaeaecjaeaeaeaeaeaebgbgaebsbgaebgbgaebgaebgaeaebgbgbgbgbsbncmacf`bnbsaebgaebselbgaeaebgaeaecjaecjcjcjcjelfjayfs`ccbggffcoggdkgeczczgegigegigegigegigegigebhdqcuboaugicwb`bcftfzdsa`aeaea`a`a`a`bia`a`dsa`cjaebtd`accaelcjaeaecjaecjaeaecjaecjcjcjcjcjcjcjbseqctctexe`aeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaeaeaeaeaeaecjaeaecjcjaecjcjcjaecjcjaeaeaeaeaeaecjaecjaeaeaeaebgbgbgbsbmbsbmbmbmbmbsbsbsbsbgbsaeaeaeaeaecjcjcjcjcjcjaeaebgaebgbgbgbsbsbgbsaeaeaeaeaeaeaeaeaecjaeaeaebgaeaebgbsaebgbgbgaebgbgaeaebgaebgaeaeaeaebgaeaeaeaeaeaebsbsaeaeaeaebgdtbsaeaecjcjcjcjcjcjbifjddb`codecibcggc`dkgib`faddgeddgigegigegigigedacwdqbhdadecoaudkdqgca`a`cjaedsa`a`a`a`a`a`a`cjcjfjacacacaebgaecjcjaeaeaeaeaeaecjaecjcjcjcjcjcjcjayexcfexdofl`ce`aeaeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaebgaeaebgaeaeaeaecjaecjaecjaecjcjcjaecjcjcjaecjaecjaeaeaeaeaebgbgbgbgbgbsbsbsbsbsbsbsbsbgaebgaeaeaecjcjcjcjcjcjcjcjaecjaeaebgbgbgbsbgbgbgaeaeaeaeaeaecjcjaeaeaeaeaeaeaebsaebsbgbsbgbgbgaebgaeaebgaebgaebgaebgaebgaeaeaeaeaeaeaeaeaebgdtbsaebibgaecjcjcjcjcjcjcjcjelfjeeexeqdeauc`ggapdkgieagfbfgegeddgegigegidkdaftfbftdqcicbgiftcuewgccjcjfzfzdsa`a`a`dsdsaecjfqapfjfjaecjaecjaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjayexcjcjaecf`cdoflbqbncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebgbgbgbgaebgaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjaecjaecjaeaecjaeaeaeaebgaebgbgbsbsbsbsbsbsbgbgbgaeaeaeaecjaecjaecjcjcjcjcjcjcjaeaeaeaeaebgbgbgaebgaeaeaecjaecjaeaecjaeaeaeaeaebgaebsbgbgbgbgbgbgbgaeaebgaeaebgaeaeaeaebgaeaebgaeaeaeaeaeaeaeeld`cfaeaeaeaeaeaecjcjcjcjcjcjcjbid`b`exeqcigeczgggegebfemgigeddgegidkgibhdaft`xcuftcwdkftcdcugcfzfzaebicddsa`a`dsdsa`aeaeddb`dhfsbncjcjaeaeaeaeaeaebgaeaeaeaeaecjaecjcjcjcjcjdhexcjcjaecjaeaecaeqdodib`cfcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaebgaebgaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaeaeaeaeaebgbgbgbgbgbsaebgaeaeaeaeaecjaecjcjcjcjcjcjcjcjaecjcjaecjaebgbgaeaebgaeaeaeaecjcjaecjaeaeaeaeaeaebsbsbgbsaebsbgbsbgbgbgbgaeaeaebgaeaeaeaebgaeaeaeaeaeaeaebgbgaeaeaebsbnbsaeaeaeaecjcjcjcjcjcjcjcjcjcjbgfjggcocbgidkczc`gigegibfgigegidkaydkbhda`hftcu`a`agcgcfzfzbia`bibi`aedfzfzbiaea`aegbb`apapfjbicjcjaecjaeaeaebgbgaebgaeaeaeaeaecjaecjcjcjcjdhexcjaecjaeaecjaecjaebcctctdib`bncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgbgaebgbgaeaeaecjaecjcjcjcjaecjcjcjcjcjcjaecjaecjaecjaecjaeaeaeaeaeaeaeaebgaebgaeaeaeaeaeaecjcjcjcjcjcjaecjaecjaecjcjcjcjaecjaeaeaeaeaeaeaeaeaeaecjcjaecjaecjaecjaeaebgaebgbgbgbsbgbgaebsaebgbgbgaeaebgaeaebgaeaebscke`bsdte`elbsbgbsbsaeaeaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjaed``ccbeqggapczgidkdkgidkgedddkbhdkbhbhcwfbghftfbercwftfbcacacfcdgcgcfzaecjaecfb`eqaydheeelcjcjaecjaeaeaebgaebgaebgbgaeaeaeaeaecjaecjcjcjfjexcjcjcjcjcjaecfexctctctctctctctflfscjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"bgaebgaeaeaeaeaeaecjcjcjaecjcjcjcjcjcjaecjcjaecjaecjaeaeaecjaeaeaeaeaeaeaeaeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjaecjaecjcjcjaecjcjcjaecjaeaeaeaeaecjcjcjcjcjcjcjaecjaeaeaeaebsbsbgbgbgbgbsbsbgbgbgaeaeaeaebgaeaeaeaeaeaee`fjcmdtcaghelbncfcabnaeaeaebgaebgaeaeaeaecjaecjcjcjcjcjcjcjcjaecwexcpeqcpco`cfjcw`haogibhbhaydkaydkbhbhbhbhaydkfjdaaccaewcfelgca`aeaeacexcieeacdheebncjcjaecjaeaeaeaeaebgaebsbgaebgaebgaeaeaecjaecjcjdhexcjcjcjcabcdoctctctctctctctctctctctelcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aebgaeaeaeaeaecjcjcjcjcjcjcjcjcjcjaecjcjaeaecjaecjaecjaecjaeaecjaecjaeaeaeaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjaecjcjcjaecjcjcjaecjcjaecjaecjaecjaecjaecjcjaecjcjaecjaebsaebgbgbgbgbgbgbgaebgbgbgbgaeaeaeaeaeaeaeaeaeaebmelbsbgbsbsbgbsbmbsbgaeaebgbgbgaebgaeaeaeaeaeaecjaecjcjcjcjcjcjaefjeqeqcpdbdveqaycmfbaofjbhbhbhfjbhbhaybhddbhbhfj`hghcdelelelelcfbtexcbcidhaceedhbscjaeaecjaeaeaeaeaebgaebgaebsbgbgaebgaeaeaeaeaecjcjdhcid`eqctctctctctctctctctctctctcteqd`cjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaeaeaeaecjcjaecjcjaecjcjaecjaeaecjaecjaecjaecjaeaeaeaeaecjaecjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjaecjcjaecjaecjaecjcjcjaecjcjcjaecjcjcjcjcjcjcjcjcjcjaecjaeaeaebsbgbgbgbgbsbgbgbgbsaebgaeaebgaeaeaeaeaeaeaebgaebgaebgaebgaeaeaeaeaeaebgbgaeaebgbgaeaeaeaeaeaeaeaeaecjcjcjcjcjcjcjbnbtbqexeqflflciapaygiaydaacdwayaybhaybhfjaoeracacac`hfjbqcbciciapcmcmfs`cd`bgaeaeaeaeaeaeaeaeaebgbgbgbsaebgbgbgbgaeaebgaecjcjaed`ffctctctctctctctctctctctctenexcmcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aeaecjaecjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaeaeaecjaecjaecjcjaecjcjcjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgaebgbgbgaebgaebgbgaebgaeaeaeaeaeaeaeaeaeaeaebgaebgaebgaeaebgaeaeaeaeaeaebgaebgbgaeaeaeaeaebicdbiaecjcjcjcjcjcjcjcjcjbgcaapb`excidbffcbeq`ceqci`ebc`cc`ddbhayddfsapfs`cciexdhaofjfsb`fsdtaeaeaeaeaeaeaeaeaeaebgaeaeaeaebsbgbgbgbsbgaeaebgbhcbctctctctctctctctctctctctdoexcacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"aecjaecjcjcjcjcjcjcjcjaecjaeaeaeaeaeaecjaeaecjaecjaeaecjaecjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaebgbgaebgaebgaebgbgaeaebgaeaeaeaeaeaeaeaeaeaeaebgbgbgaebgaeaebgaeaeaeaeaeaebgaebgaeaebgaeaebgaeaedtelaeaeaecjaecjcjcjcjcjcjcjcjcjelcmd`dheeb`cicicidbdbclcb`eexexapayaycacaacacfjapeefje`aeaebgaebgaeaeaeaeaeaeaeaebsbgbgbsbgbgbgbgbgaecm`ectctctctctctctctctctctctct`ccacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaeaeaeaeaeaeaeaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaeaebgaebgaeaebgaebgaeaeaeaeaeaeaecjaeaeaeaebgaeaeaebgaebgaeaeaeaeaeaeaeaeaebgaebgbgaeaeaeaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaebnelcaacaofsfsfseeap`cbq`cbqfsdheraccfbmcjaebgaebgbgbgaeaeaeaeaeaeaeaeaebsaeaebgbgbgbgbsaoctctctctctctctctctctctdoexcmcjcjcjcjcjcjcjcjcjcjcjcjaeaecjaeaecjaecjcjcjcjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaeaeaeaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaebgaeaeaeaebgaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaebgaeaeaeaeaeaeaeaeaeaeaeaebgaebgaeaeaeaeaebgaebgaebgaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaebgbibneldtbnbibsbsbgbsbgaebgbgbgbgbgbgaebgaeaeaeaeaebgaebsaebgbgbgaebgaoctctctctctctctctdo`ccacjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjaecjaeaecjcjcjcjcjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaeaeaeaeaeaeaebgaebgaebgaeaeaebgaebgaebgbgaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaebgaeaebgaeaeaeaeaeaeaeaeaeaebgbgaebgbgbgaoctctctctctdob`elcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaecjcjaecjaecjcjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaeaeaeaeaeaeaeaeaeaeaeaeaecjaeaeaeaeaebgaeaeaeaeaecjaeaecjaeaeaeaeaeaebgaeaebgaeaeaeaebgaebgbgbgbgaebgaecjaecjcjcjcjcjcjcjcjcjaeaeaecjcjaecjaecjaecjaeaeaecjaecjaecjaeaecjaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaebgaeaeaeaoctctflb`bncjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjcjcjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjcjaeaecjaeaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjaecjcjaecjaecjaecjaecjaeaeaeaeaeaeaeaeaeaeaeaecjaecjcjaecjaeaeaeaebgaebgaeaeaeaeaeaebgaebgbgbgbsaeaeaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaecjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaebgaeaebgaeaeaeaecjaecjaeaeaebgaeaeaeaeaeaeaed`dbbncjaecjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjaeaeaecjaecjcjaecjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaecjaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjaecjcjcjaecjaeaeaecjaeaeaeaebgaeaeaecjcjcjcjcjaecjaecjaeaeaeaebgbgaeaeaeaeaeaeaeaebgbgbgbgbgbgaeaecjaecjaecjcjcjcjcjcjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjaecjcjaecjcjcjcjaecjaecjaeaeaeaeaeaeaeaecjaecjcjaeaeaeaeaeaeaeaeaeaed`cicjaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjcjcjcj",
+"cjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjcjcjaecjaecjaeaeaeaeaeaeaeaecjaecjaecjaecjcjcjcjaeaeaeaeaebgaeaeaeaeaecjaeaeaeaebgbgbgbgaeaeaeaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjcjaecjcjcjcjaecjaeaecjaecjaocicjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecj",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjaecjaecjaeaeaeaebgaeaeaecjcjcjcjcjcjcjaecjaeaeaeaeaebgaeaeaeaecjaeaeaeaeaebgbgbgbgbgaeaecjcjaecjaecjaecjaecjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjcjcjcjcjcjcjcjaecjaecjaecjcjcjcjbicacjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjaecjaecjcjaecjae",
+"cjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaeaeaeaeaeaecjcjcjcjcjcjcjcjaecjaecjaebgaeaeaeaeaecjaecjcjaeaeaeaebgaeaeaeaeaeaecjaeaeaecjaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjcjcjcjcjcjaecjcjcjcjcjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjcjaecjaecjaecj",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaecjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaeaeaecjaecjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaeaeaecjcjaecjaeaeaeaeaeaeaeaeaecjaecjaecjaeaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaeaecjae",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjcjaecjaeaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaeaecjcjaecjaecjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaeaecjcjcjcjcjcjaeaeaeaeaeaeaeaecjaecjaeaeaecjaeaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjae",
+"cjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjaecjaecjaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaeaecjaecjcjcjcjcjcjcjcjcjcjcjcjaecjaeaeaeaeaecjaecjaecjaecjaeaeaeaeaeaecjcjaecjaecjaeaeaeaecjaeaecjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjcjaecjaecjcjae"
+};
diff --git a/Background b/Background
new file mode 100755
index 0000000..9a630cb
--- /dev/null
+++ b/Background
@@ -0,0 +1,6 @@
+#!/bin/sh
+if [ "$3" = "0x00000000" ]; then
+  display -window root $4 > /dev/null
+else
+  display -window "$3" $4 > /dev/null
+fi
diff --git a/Imakefile b/Imakefile
new file mode 100644
index 0000000..3b99c2f
--- /dev/null
+++ b/Imakefile
@@ -0,0 +1,87 @@
+
+	PROGRAMS = amiwm requestchoice executecmd
+
+	AMIWM_HOME = /usr/X11/lib/X11/amiwm
+
+	SRCS1 = main.c drawinfo.c client.c frame.c icc.c \
+		icon.c menu.c diskobject.c gram.c lex.c rc.c
+	OBJS1 = main.o drawinfo.o client.o frame.o icc.o \
+		icon.o menu.o diskobject.o gram.o lex.o rc.o
+
+	SRCS2 = requestchoice.c drawinfo.c
+	OBJS2 = requestchoice.o drawinfo.o
+
+	SRCS3 = executecmd.c drawinfo.c
+	OBJS3 = executecmd.o drawinfo.o
+
+	YFLAGS = -d
+
+all::
+
+/* Some old implementations does not have LexFile and YaccFile... */
+
+#ifndef LexFile
+#define LexFile(file)                                                   @@\
+depend:: file.c                                                         @@\
+                                                                        @@\
+clean::                                                                 @@\
+	$(RM) lex.yy.c file.c
+#endif /* LexFile */
+ 
+#ifndef YaccFile
+#define YaccFile(file,flags)                                            @@\
+depend:: file.c                                                         @@\
+                                                                        @@\
+file.h file.c: file.y                                                   @@\
+	$(YACC) flags file.y                                            @@\
+	$(MV) y.tab.c file.c                                            @@\
+	$(MV) y.tab.h file.h                                            @@\
+                                                                        @@\
+clean::                                                                 @@\
+	$(RM) y.tab.c y.tab.h file.h file.c
+#endif /* YaccFile */
+
+LexFile(lex)
+
+YaccFile(gram,$(YFLAGS))
+
+ComplexProgramTarget_1(amiwm, $(XLIB) $(XMULIB), $(OTHER_LIBS))
+
+ComplexProgramTarget_2(requestchoice, $(XLIB), $(OTHER_LIBS))
+
+ComplexProgramTarget_3(executecmd, $(XLIB), $(OTHER_LIBS))
+
+SpecialCObjectRule(menu,$(_NOOP_),'-DAMIWM_HOME="$(AMIWM_HOME)"')
+SpecialCObjectRule(rc,$(_NOOP_),'-DAMIWM_HOME="$(AMIWM_HOME)"')
+
+install ::
+	MakeDir($(AMIWM_HOME))
+	RemoveFile($(AMIWM_HOME)/requestchoice)
+	$(LN) $(BINDIR)/requestchoice $(AMIWM_HOME)/requestchoice
+	RemoveFile($(AMIWM_HOME)/executecmd)
+	$(LN) $(BINDIR)/executecmd $(AMIWM_HOME)/executecmd
+
+InstallNonExec(system.amiwmrc, $(AMIWM_HOME)/system.amiwmrc)
+InstallNonExec(def_tool.info, $(AMIWM_HOME)/def_tool.info)
+
+
+/*  Targets for my private use.  Not very portable.   // Marcus  */
+
+DISTFILES = README INSTALL Imakefile smakefile scoptions *.[chly] \
+	system.amiwmrc def_tool.info
+
+patch :
+	mv version.h old_version.h
+	sed < old_version.h 's/l/"/' | awk '-F"' '{ printf "%s\"%sl%s\"\n",$$1,$$2,1+$$3 }' > version.h
+	rm old_version.h
+
+dist : version.h clean
+	( version=`sed < version.h -e 's/^[^"]*"//' -e 's/"[^"]*$$//'`; \
+	  tarname="amiwm$$version.tar"; \
+	  mkdir amiwm; \
+	  cp $(DISTFILES) amiwm/; \
+	  rm -f $$tarname $$tarname.gz; \
+	  tar cf $$tarname amiwm; \
+	  rm -rf amiwm/; \
+	  gzip $$tarname; \
+	)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..128781a
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,44 @@
+
+amiwm is Copyright 1995-1998 by Marcus Comstedt <marcus@lysator.liu.se>
+
+Amiga, AmigaOS and Workbench are registered trademarks of
+AMIGA International Inc.
+
+
+Generic amiwm License
+=====================
+
+This license applies to whomever receives this file.  It is a generic
+license to use and distribute amiwm.  If you want to acquire the software
+under a different license, please contact the author.  This license is
+in part based on the XV license by John Bradley.
+
+Permission to copy and distribute amiwm in its entirety, for
+non-commercial purposes, is hereby granted without fee, provided
+that this license information and copyright notice appear in all copies.
+
+If you redistribute amiwm, the *entire* contents of this distribution
+must be distributed, including the README, INSTALL and LICENSE files,
+the sources, and the various scripts and Makefiles.
+
+You may distribute binaries built from the unmodified amiwm sources, for
+non-commercial purposes, provided that the entire amiwm source distribution
+is also included, as per the preceding paragraph.
+
+You may distribute amiwm as a component of an aggregate software
+distribution, provided that no other condition of this license is violated.
+In particular, the entire amiwm distribution must be included in the
+aggregate software distribution.
+
+Unrestricted use of the software is also hereby granted without fee.
+Distribution and modification of source or binaries are not considered use
+and explicitly covered by other paragraphs of this license.
+
+The software may be modified for your own purposes, but modified versions
+may not be distributed without prior consent of the author.  You may
+freely distribute patches against the unmodified source code.
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the author be held liable for any damages
+arising from the use of this software.
+
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..aed56fb
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,221 @@
+srcdir = .
+
+SHELL = /bin/sh
+CC = gcc
+LEX = flex
+YACC = bison -y
+CFLAGS = -g -O2
+YFLAGS = -d
+DEFS = -DPACKAGE_NAME=\"\" -DPACKAGE_TARNAME=\"\" -DPACKAGE_VERSION=\"\" -DPACKAGE_STRING=\"\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DYYTEXT_POINTER=1 -DSTDC_HEADERS=1 -DHAVE_SYS_WAIT_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_FCNTL_H=1 -DHAVE_LIMITS_H=1 -DHAVE_SYS_TIME_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_UNISTD_H=1 -DHAVE_SYS_SELECT_H=1 -DHAVE_SYS_RESOURCE_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_TERMIO_H=1 -DHAVE_X11_EXTENSIONS_SHAPE_H=1 -DTIME_WITH_SYS_TIME=1 -DHAVE_ALLOCA_H=1 -DHAVE_ALLOCA=1 -DRETSIGTYPE=void -DHAVE_WAIT3=1 -DHAVE_SELECT=1 -DHAVE_STRDUP=1 -DHAVE_WAITPID=1 -DHAVE_XSHAPE=1 -DBSD_STYLE_GETTIMEOFDAY=1 -DHAVE_XCREATEFONTSET=1 -DHAVE_XMBTEXTESCAPEMENT=1 -DHAVE_XUTF8DRAWIMAGESTRING=1 -DUSE_FONTSETS=1 -DLAME_ENDIAN=1
+ALL_CFLAGS = -I. -I. -I./libami $(DEFS) $(CFLAGS) 
+LIBS =   -lSM -lICE -Llibami -lami  -lXext -lXmu \
+	-lX11  
+prefix = /usr/local
+exec_prefix = ${prefix}
+bindir = $(exec_prefix)/bin
+libdir = $(exec_prefix)/lib
+mandir = $(prefix)/man
+INSTALL = /usr/bin/install -c
+LN_S = ln -s
+RM = -rm -f
+LIBAMI = libami/libami.a
+DT_DIR = /etc/dt
+STRIPFLAG = -s
+
+PROGS = amiwm requestchoice executecmd ppmtoinfo
+
+MODULES = $(srcdir)/Background Keyboard Launcher
+
+OBJS  = main.o screen.o client.o frame.o icc.o \
+		icon.o menu.o diskobject.o gram.o lex.o rc.o \
+		module.o
+
+SRCS = main.c screen.c client.c frame.c icc.c \
+		icon.c menu.c diskobject.c gram.c lex.c rc.c \
+		module.c \
+		requestchoice.c executecmd.c kbdmodule.c kbdlexer.c \
+		launchermodule.c
+
+DISTFILES = README README.modules INSTALL LICENSE amiwm.1 \
+	configure configure.in Makefile.in install-sh smakefile scoptions \
+	*.[chly] system.amiwmrc def_*.info *.map \
+	Background Xresources.amiwm.in Amilogo.?m Xsession*.in Xinitrc.in \
+	amiwm-init libami/Makefile.in libami/*.[chly]
+
+PACKAGENAME = amiwm
+
+AMIWM_HOME = $(libdir)/amiwm
+
+all : lib_all
+	@$(MAKE) local_all
+
+local_all : $(PROGS) $(MODULES)
+
+lib_all :
+	@( cd libami; $(MAKE) all )
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
+
+menu.o : menu.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+rc.o : rc.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+diskobject.o : diskobject.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+filesystem.o : joke_fs.c
+	$(CC) -o $@ -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+ppmtoinfo.o : ppmtoinfo.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+gram.h gram.c: gram.y
+	$(YACC) $(YFLAGS) $<
+	mv y.tab.c gram.c
+	mv y.tab.h gram.h
+
+lex.c : lex.l
+	$(LEX) -t $< > lex.c
+
+kbdmodule.h kbdmodule.c: kbdmodule.y
+	$(YACC) $(YFLAGS) $<
+	mv y.tab.c kbdmodule.c
+	mv y.tab.h kbdmodule.h
+
+kbdlexer.c : kbdlexer.l
+	$(LEX) -t $< > kbdlexer.c
+
+install : $(PROGS) $(MODULES) Xsession Xsession2 Xinitrc amiwm-init
+	-mkdir -p $(AMIWM_HOME)
+	$(INSTALL) $(STRIPFLAG) requestchoice $(AMIWM_HOME)/requestchoice
+	$(INSTALL) $(STRIPFLAG) executecmd $(AMIWM_HOME)/executecmd
+	for module in $(MODULES); do \
+	  if [ "$$module" = "$(srcdir)/Background" ]; then \
+	    $(INSTALL) $$module $(AMIWM_HOME)/Background; \
+	  else \
+	    $(INSTALL) $(STRIPFLAG) $$module $(AMIWM_HOME)/$$module; \
+	  fi; \
+	done
+	$(INSTALL) -m 644 $(srcdir)/system.amiwmrc $(AMIWM_HOME)/system.amiwmrc
+	$(INSTALL) -m 644 $(srcdir)/def_tool.info $(AMIWM_HOME)/def_tool.info
+	$(INSTALL) -m 644 $(srcdir)/system.map $(AMIWM_HOME)/system.map
+	$(INSTALL) -m 644 $(srcdir)/magicwb.map $(AMIWM_HOME)/magicwb.map
+	$(INSTALL) -m 644 $(srcdir)/schwartz.map $(AMIWM_HOME)/schwartz.map
+	$(INSTALL) -m 755 Xsession $(AMIWM_HOME)/Xsession
+	$(INSTALL) -m 755 Xsession2 $(AMIWM_HOME)/Xsession2
+	$(INSTALL) -m 755 Xinitrc $(AMIWM_HOME)/Xinitrc
+	$(INSTALL) -m 755 $(srcdir)/amiwm-init $(AMIWM_HOME)/amiwm-init
+	-mkdir -p $(bindir)
+	$(INSTALL) $(STRIPFLAG) amiwm $(bindir)/amiwm
+	$(INSTALL) $(STRIPFLAG) ppmtoinfo $(bindir)/ppmtoinfo
+	$(RM) $(bindir)/requestchoice
+	$(LN_S) $(AMIWM_HOME)/requestchoice $(bindir)/requestchoice
+	-mkdir -p $(mandir)/man1
+	$(INSTALL) -m 644 $(srcdir)/amiwm.1 $(mandir)/man1/amiwm.1
+
+fs-install : Filesystem
+	$(INSTALL) $(STRIPFLAG) Filesystem $(AMIWM_HOME)/Filesystem
+	$(INSTALL) -m 644 def_disk.info $(AMIWM_HOME)/def_disk.info
+	$(INSTALL) -m 644 def_drawer.info $(AMIWM_HOME)/def_disk.info
+
+cde-install : Xresources.amiwm Amilogo.bm Amilogo.pm
+	-mkdir -p $(DT_DIR)/config/C/Xresources.d
+	$(INSTALL) -m 644 Xresources.amiwm $(DT_DIR)/config/C/Xresources.d/Xresources.amiwm
+	-mkdir -p $(DT_DIR)/appconfig/icons/C
+	$(INSTALL) -m 644 Amilogo.bm $(DT_DIR)/appconfig/icons/C/Amilogo.bm
+	$(INSTALL) -m 644 Amilogo.pm $(DT_DIR)/appconfig/icons/C/Amilogo.pm
+
+
+amiwm : $(OBJS) $(LIBAMI)
+	$(CC) -o amiwm $(OBJS) $(LIBS)
+
+requestchoice : requestchoice.o $(LIBAMI)
+	$(CC) -o requestchoice requestchoice.o $(LIBS)
+
+executecmd : executecmd.o $(LIBAMI)
+	$(CC) -o executecmd executecmd.o $(LIBS)
+
+Filesystem : filesystem.o $(LIBAMI)
+	$(CC) -o Filesystem filesystem.o $(LIBS)
+
+Keyboard : kbdmodule.o kbdlexer.o $(LIBAMI)
+	$(CC) -o Keyboard kbdmodule.o kbdlexer.o $(LIBS)
+
+Launcher : launchermodule.o $(LIBAMI)
+	$(CC) -o Launcher launchermodule.o $(LIBS)
+
+ppmtoinfo : ppmtoinfo.o
+	$(CC) -o ppmtoinfo ppmtoinfo.o -lm
+
+localetest : localetest.o $(LIBAMI)
+	$(CC) -o localetest localetest.o $(LIBS)
+
+clean :
+	$(RM) core $(PROGS) $(LIBAMI) Keyboard Launcher *.o libami/*.o
+	$(RM) lex.yy.c lex.c y.tab.c y.tab.h gram.h gram.c
+	$(RM) kbdlexer.c kbdmodule.h kbdmodule.c
+	$(RM) config.log
+
+distclean : clean
+	$(RM) config.status config.cache *~
+	$(RM) Makefile libami/Makefile Xresources.amiwm Xsession Xsession2 Xinitrc
+
+spotless : distclean
+
+TAGS:
+	etags *.[ch] libami/*.[ch]
+
+patch :
+	mv version.h old_version.h
+	sed < old_version.h 's/l/"/' | awk '-F"' '{ printf "%s\"%sl%s\"\n",$$1,$$2,1+$$3 }' > version.h
+	rm old_version.h
+
+dist : version.h clean
+	( version=`sed < version.h -e 's/^[^"]*"//' -e 's/"[^"]*$$//'`; \
+	  tarname="$(PACKAGENAME)$$version.tar"; \
+	  mkdir $(PACKAGENAME)$$version; \
+	  tar cf - $(DISTFILES) | (cd $(PACKAGENAME)$$version/; tar xf - ); \
+	  rm -f $$tarname $$tarname.gz; \
+	  tar cf $$tarname $(PACKAGENAME)$$version; \
+	  rm -rf $(PACKAGENAME)$$version; \
+	  gzip $$tarname; \
+	)
+
+$(srcdir)/configure: $(srcdir)/configure.in
+	autoconf $(srcdir)/configure.in > $(srcdir)/configure
+
+config.status: $(srcdir)/configure
+	$(srcdir)/configure
+
+Makefile: $(srcdir)/Makefile.in config.status
+	./config.status
+
+libami/Makefile: $(srcdir)/libami/Makefile.in config.status
+	./config.status
+
+Xresources.amiwm: $(srcdir)/Xresources.amiwm.in
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xresources.amiwm.in > Xresources.amiwm
+
+Xsession: $(srcdir)/Xsession.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xsession.in > Xsession
+
+Xsession2: $(srcdir)/Xsession2.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xsession2.in > Xsession2
+
+Xinitrc: $(srcdir)/Xinitrc.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xinitrc.in > Xinitrc
+
+
+depend:: $(SRCS)
+	-@rm Makefile.bak
+	mv Makefile Makefile.bak
+	( sed '/^#--DO NOT REMOVE THIS LINE--$$/q' < Makefile.bak ; \
+	  $(CC) -MM $(ALL_CFLAGS) $(SRCS) ) > Makefile
+
+depend::
+	@( cd libami; $(MAKE) depend )
+
+#--DO NOT REMOVE THIS LINE--
diff --git a/Makefile.in b/Makefile.in
new file mode 100644
index 0000000..cb3e800
--- /dev/null
+++ b/Makefile.in
@@ -0,0 +1,221 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+SHELL = /bin/sh
+CC = @CC@
+LEX = @LEX@
+YACC = @YACC@
+CFLAGS = @CFLAGS@
+YFLAGS = -d
+DEFS = @DEFS@
+ALL_CFLAGS = -I. -I@srcdir@ -I@srcdir@/libami $(DEFS) $(CFLAGS) @X_CFLAGS@
+LIBS = @X_LIBS@ @X_PRE_LIBS@ -Llibami -lami @XT_LIB_KLUDGE@ -lXext -lXmu \
+	-lX11 @X_EXTRA_LIBS@ @LIBS@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+bindir = $(exec_prefix)/bin
+libdir = $(exec_prefix)/lib
+mandir = $(prefix)/man
+INSTALL = @INSTALL@
+LN_S = @LN_S@
+RM = -rm -f
+LIBAMI = libami/libami.a
+DT_DIR = /etc/dt
+STRIPFLAG = -s
+
+PROGS = amiwm requestchoice executecmd ppmtoinfo
+
+MODULES = $(srcdir)/Background Keyboard Launcher
+
+OBJS  = main.o screen.o client.o frame.o icc.o \
+		icon.o menu.o diskobject.o gram.o lex.o rc.o \
+		module.o
+
+SRCS = main.c screen.c client.c frame.c icc.c \
+		icon.c menu.c diskobject.c gram.c lex.c rc.c \
+		module.c \
+		requestchoice.c executecmd.c kbdmodule.c kbdlexer.c \
+		launchermodule.c
+
+DISTFILES = README README.modules INSTALL LICENSE amiwm.1 \
+	configure configure.in Makefile.in install-sh smakefile scoptions \
+	*.[chly] system.amiwmrc def_*.info *.map \
+	Background Xresources.amiwm.in Amilogo.?m Xsession*.in Xinitrc.in \
+	amiwm-init libami/Makefile.in libami/*.[chly]
+
+PACKAGENAME = amiwm
+
+AMIWM_HOME = $(libdir)/amiwm
+
+all : lib_all
+	@$(MAKE) local_all
+
+local_all : $(PROGS) $(MODULES)
+
+lib_all :
+	@( cd libami; $(MAKE) all )
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
+
+menu.o : menu.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+rc.o : rc.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+diskobject.o : diskobject.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+filesystem.o : joke_fs.c
+	$(CC) -o $@ -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+ppmtoinfo.o : ppmtoinfo.c
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) -DAMIWM_HOME=\"$(AMIWM_HOME)\" $<
+
+gram.h gram.c: gram.y
+	$(YACC) $(YFLAGS) $<
+	mv y.tab.c gram.c
+	mv y.tab.h gram.h
+
+lex.c : lex.l
+	$(LEX) -t $< > lex.c
+
+kbdmodule.h kbdmodule.c: kbdmodule.y
+	$(YACC) $(YFLAGS) $<
+	mv y.tab.c kbdmodule.c
+	mv y.tab.h kbdmodule.h
+
+kbdlexer.c : kbdlexer.l
+	$(LEX) -t $< > kbdlexer.c
+
+install : $(PROGS) $(MODULES) Xsession Xsession2 Xinitrc amiwm-init
+	-mkdir -p $(AMIWM_HOME)
+	$(INSTALL) $(STRIPFLAG) requestchoice $(AMIWM_HOME)/requestchoice
+	$(INSTALL) $(STRIPFLAG) executecmd $(AMIWM_HOME)/executecmd
+	for module in $(MODULES); do \
+	  if [ "$$module" = "$(srcdir)/Background" ]; then \
+	    $(INSTALL) $$module $(AMIWM_HOME)/Background; \
+	  else \
+	    $(INSTALL) $(STRIPFLAG) $$module $(AMIWM_HOME)/$$module; \
+	  fi; \
+	done
+	$(INSTALL) -m 644 $(srcdir)/system.amiwmrc $(AMIWM_HOME)/system.amiwmrc
+	$(INSTALL) -m 644 $(srcdir)/def_tool.info $(AMIWM_HOME)/def_tool.info
+	$(INSTALL) -m 644 $(srcdir)/system.map $(AMIWM_HOME)/system.map
+	$(INSTALL) -m 644 $(srcdir)/magicwb.map $(AMIWM_HOME)/magicwb.map
+	$(INSTALL) -m 644 $(srcdir)/schwartz.map $(AMIWM_HOME)/schwartz.map
+	$(INSTALL) -m 755 Xsession $(AMIWM_HOME)/Xsession
+	$(INSTALL) -m 755 Xsession2 $(AMIWM_HOME)/Xsession2
+	$(INSTALL) -m 755 Xinitrc $(AMIWM_HOME)/Xinitrc
+	$(INSTALL) -m 755 $(srcdir)/amiwm-init $(AMIWM_HOME)/amiwm-init
+	-mkdir -p $(bindir)
+	$(INSTALL) $(STRIPFLAG) amiwm $(bindir)/amiwm
+	$(INSTALL) $(STRIPFLAG) ppmtoinfo $(bindir)/ppmtoinfo
+	$(RM) $(bindir)/requestchoice
+	$(LN_S) $(AMIWM_HOME)/requestchoice $(bindir)/requestchoice
+	-mkdir -p $(mandir)/man1
+	$(INSTALL) -m 644 $(srcdir)/amiwm.1 $(mandir)/man1/amiwm.1
+
+fs-install : Filesystem
+	$(INSTALL) $(STRIPFLAG) Filesystem $(AMIWM_HOME)/Filesystem
+	$(INSTALL) -m 644 def_disk.info $(AMIWM_HOME)/def_disk.info
+	$(INSTALL) -m 644 def_drawer.info $(AMIWM_HOME)/def_disk.info
+
+cde-install : Xresources.amiwm Amilogo.bm Amilogo.pm
+	-mkdir -p $(DT_DIR)/config/C/Xresources.d
+	$(INSTALL) -m 644 Xresources.amiwm $(DT_DIR)/config/C/Xresources.d/Xresources.amiwm
+	-mkdir -p $(DT_DIR)/appconfig/icons/C
+	$(INSTALL) -m 644 Amilogo.bm $(DT_DIR)/appconfig/icons/C/Amilogo.bm
+	$(INSTALL) -m 644 Amilogo.pm $(DT_DIR)/appconfig/icons/C/Amilogo.pm
+
+
+amiwm : $(OBJS) $(LIBAMI)
+	$(CC) -o amiwm $(OBJS) $(LIBS)
+
+requestchoice : requestchoice.o $(LIBAMI)
+	$(CC) -o requestchoice requestchoice.o $(LIBS)
+
+executecmd : executecmd.o $(LIBAMI)
+	$(CC) -o executecmd executecmd.o $(LIBS)
+
+Filesystem : filesystem.o $(LIBAMI)
+	$(CC) -o Filesystem filesystem.o $(LIBS)
+
+Keyboard : kbdmodule.o kbdlexer.o $(LIBAMI)
+	$(CC) -o Keyboard kbdmodule.o kbdlexer.o $(LIBS)
+
+Launcher : launchermodule.o $(LIBAMI)
+	$(CC) -o Launcher launchermodule.o $(LIBS)
+
+ppmtoinfo : ppmtoinfo.o
+	$(CC) -o ppmtoinfo ppmtoinfo.o -lm
+
+localetest : localetest.o $(LIBAMI)
+	$(CC) -o localetest localetest.o $(LIBS)
+
+clean :
+	$(RM) core $(PROGS) $(LIBAMI) Keyboard Launcher *.o libami/*.o
+	$(RM) lex.yy.c lex.c y.tab.c y.tab.h gram.h gram.c
+	$(RM) kbdlexer.c kbdmodule.h kbdmodule.c
+	$(RM) config.log
+
+distclean : clean
+	$(RM) config.status config.cache *~
+	$(RM) Makefile libami/Makefile Xresources.amiwm Xsession Xsession2 Xinitrc
+
+spotless : distclean
+
+TAGS:
+	etags *.[ch] libami/*.[ch]
+
+patch :
+	mv version.h old_version.h
+	sed < old_version.h 's/l/"/' | awk '-F"' '{ printf "%s\"%sl%s\"\n",$$1,$$2,1+$$3 }' > version.h
+	rm old_version.h
+
+dist : version.h clean
+	( version=`sed < version.h -e 's/^[^"]*"//' -e 's/"[^"]*$$//'`; \
+	  tarname="$(PACKAGENAME)$$version.tar"; \
+	  mkdir $(PACKAGENAME)$$version; \
+	  tar cf - $(DISTFILES) | (cd $(PACKAGENAME)$$version/; tar xf - ); \
+	  rm -f $$tarname $$tarname.gz; \
+	  tar cf $$tarname $(PACKAGENAME)$$version; \
+	  rm -rf $(PACKAGENAME)$$version; \
+	  gzip $$tarname; \
+	)
+
+$(srcdir)/configure: $(srcdir)/configure.in
+	autoconf $(srcdir)/configure.in > $(srcdir)/configure
+
+config.status: $(srcdir)/configure
+	$(srcdir)/configure
+
+Makefile: $(srcdir)/Makefile.in config.status
+	./config.status
+
+libami/Makefile: $(srcdir)/libami/Makefile.in config.status
+	./config.status
+
+Xresources.amiwm: $(srcdir)/Xresources.amiwm.in
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xresources.amiwm.in > Xresources.amiwm
+
+Xsession: $(srcdir)/Xsession.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xsession.in > Xsession
+
+Xsession2: $(srcdir)/Xsession2.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xsession2.in > Xsession2
+
+Xinitrc: $(srcdir)/Xinitrc.in config.status
+	sed -e 's:[@]bindir[@]:$(bindir):g' -e 's:[@]AMIWM_HOME[@]:$(AMIWM_HOME):g' < $(srcdir)/Xinitrc.in > Xinitrc
+
+
+depend:: $(SRCS)
+	-@rm Makefile.bak
+	mv Makefile Makefile.bak
+	( sed '/^#--DO NOT REMOVE THIS LINE--$$/q' < Makefile.bak ; \
+	  $(CC) -MM $(ALL_CFLAGS) $(SRCS) ) > Makefile
+
+depend::
+	@( cd libami; $(MAKE) depend )
+
+#--DO NOT REMOVE THIS LINE--
diff --git a/README b/README
new file mode 100644
index 0000000..6e1311f
--- /dev/null
+++ b/README
@@ -0,0 +1,174 @@
+
+< amiwm >  by Marcus Comstedt (marcus@mc.pp.se)
+
+
+0. Legal notices
+
+This program is distributed as FreeWare.  The copyright remains with
+the author.  See the file LICENSE for more information.
+
+Amiga and Workbench are registered trademarks of AMIGA International Inc.
+
+1. Intro
+
+This is amiwm, an X window manager that tries to make your workstation
+look like an Amiga®.  "Why?" you ask.  Because I wanted it to.  So there!
+
+2. Compiling etc.
+
+For instructions on building and installing, read the file INSTALL.
+
+3. Configuration
+
+amiwm reads the file .amiwmrc in the directory pointed to by $HOME
+when starting.  If this file does not exist, it reads the file
+system.amiwmrc instead.
+
+The configuration file can contain any of the following statements:
+
+FastQuit {yes|no}
+
+Specifies whether amiwm should quit directly when the Quit menu item
+is selected, rather than popping up a requester.
+(on/off or true/false can be used instead of yes/no.)
+
+SizeBorder {right|bottom|both|none}
+
+Specifies which border should be enlarged when a sizegadget is present.
+
+ForceMove {manual|auto|always}
+
+Enables you to move windows outside the perimeter of the root window
+when pressing shift, when trying to drag at least 25% of the window
+ofscreen, or always, respectively.
+
+IconDir "path"
+
+Specifies a directory in which amiwm will look for icons.
+
+DefaultIcon "name"
+
+Gives the filename of the .info file to use as a default icon.
+It is relative to the IconDir.
+
+IconPalette {system|magicwb|schwartz|"filename"}
+
+Selects either the Workbench® default palette, or the MagicWorkbench
+standard palette for use with icons.  The third option is a 16 color
+palette used on the "Eric Schwartz Productions CD Archive".  Alternatively,
+the filename of a PPM file representing the palette to use can be used.
+
+ScreenFont "fontname"
+
+Selects a font to use for windowtitles etc.
+
+IconFont "fontname"
+
+Selects a font for icontitles.
+
+{detailpen|blockpen|textpen|shinepen|shadowpen|fillpen|filltextpen|
+	backgroundpen|highlighttextpen|bardetailpen|barblockpen|
+	bartrimpen} "colorname"
+
+Modifies the colour scheme for the window manager.
+
+CustomIconsOnly {yes|no}
+
+This prevent applications to display their own icons when in iconified state.
+Only icons defined in amiwmrc for each apps will be used.
+Because apps own icon are too different from one eachother.
+They comes in various sizes and themes. Some icons will be 32x32,
+while some other will be a 128x128 or even bigger .. By using this option,
+You have the possibility to decide which icon should be used for each app.  
+If no custom icons are defined at all, the def_tool.info will be used for 
+all iconified apps. Format is: style { class "myClass" icon "myIcon.info" }
+To find out a given program's class, use "xlsclients -l" to list all opened
+applications, and then use "xprop -id <0x0000000>" to list a 
+given app's properties. Use either WM_CLASS or WM_ICON_NAME strings in amiwmrc.
+
+ShortLabelIcons {yes|no}
+
+This limit the length of the text for iconified programs. For example, if this 
+option is activated, an iconified program text will be limited to 8 chars + ".."
+Use this option if you don't want iconified program text to be loong strings..
+
+TitleBarClock {yes|no}
+
+Enables a clock in the titlebar.  It displays the date and time.
+
+TitleClockFormat [<number>] "time string"
+
+This lets you choose a new format to display the Title Bar Clock.
+The time string is formatted with the standard strftime() parameters.
+The default is "%c".  It has been found that "%a %b %e %Y   %l:%M %p" works
+well too.  Number is the update interval in seconds.  
+
+ToolItem "name" "command" ["hotkey"]
+
+Adds an item in the Tools menu with the specified name, which executes
+the command when selected.  A string containing a single uppercase letter
+may be specified as the third argument, making this letter a hotkey for the
+item.
+
+ToolItem Separator
+
+Inserts a separator bar in the Tools menu.
+
+ToolItem "name" { <tool item commands> }
+
+Create ToolItem:s in a submenu with the specified name.  It is not legal
+to create a submenu inside another submenu.
+
+Screen [<number>] "name"
+
+Create a new screen with the specified name.  It will be placed below all
+earlier created screens.  To move a window between two screens, iconify it
+and drag the icon over to the other screen.  If the second argument is given,
+this screen is placed on the corresponding X screen.
+
+ModulePath "path(:path...)"
+
+Sets one or more directories where amiwm will look for module binaries.
+The default is AMIWM_HOME.  Note that the module binaries cannot be
+shared amongst different architectures.
+
+Module "name" ["initstring"]
+
+Start a module with the specified name.  If initstring is specified, it
+is sent to the module.  There are currently two modules shipped with
+amiwm; Background and Keyboard.  These are documented in the file
+README.modules.  If a module is limited to a single screen, like the
+Background module, the screen that was created last is used.
+
+InterScreenGap number
+
+Sets the size in number of pixels of the "video DMA off" area that appears
+between screens when they are dragged.
+
+AutoRaise {yes|no}
+
+Selects wheteher windows will automatically be moved to the front when
+they are activated.
+
+Focus {followmouse|sloppy|clicktotype}
+
+Sets the policy by which windows are given focus.  Followmouse is the
+default and means that the window that contains the mouse pointer will
+have focus.  Sloppy means that the window that had focus last will keep
+it when the pointer is not over a window.  ClickToType is the original AmigaOS
+policy in which you have to explicitly give focus to windows by clicking
+in them.
+
+
+4. Troubleshooting
+
+The most likely reason for the windowmanager to crash is if it
+can't find its default icon, or if this is not accepted as an
+.info file.  If this happens, amiwm _will_ dump core.  So make
+sure that either 'make install' runs successfully (in which case
+amiwm will know where its icon is), or that the file .amiwmrc
+contains a correct specification of the icon's location.
+
+Don't mail me bug reports just because amiwm prints "Bad Window" on
+stderr once in a while.  Redirect it to /dev/null or live with it.  :)
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..9c7ec74
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# amiwm
+Amiga Workbench-like Window Manager for Xorg
\ No newline at end of file
diff --git a/README.modules b/README.modules
new file mode 100644
index 0000000..a1b4c46
--- /dev/null
+++ b/README.modules
@@ -0,0 +1,70 @@
+
+Background module
+-----------------
+
+To get background images on your screens, use the Background module.
+The Module command should come after the Screen command, and the
+initstring should be the filename of the picture(*).  Example:
+
+Screen "My Screen"
+Module "Background" "~/pliki/im"
+
+The Background module is really a shell script that requires that the
+program 'display' from imagemagick package. Currently, it doesn't
+support any standard imagemagick parameters.
+
+Keyboard module
+---------------
+
+With the Keyboard module, you can bind window manager functions to keys
+on the keyboard.  The initstring should consist of keybindings on the
+form
+
+modifiers<keysym>:where:func
+
+modifiers
+=========
+
+Modifiers is 0 or more of:
+  Shift Control Meta Lock
+  Mod1 Mod2 Mod3 Mod4 Mod5
+  Button1 Button2 Button3 Button4 Button5
+
+The modifiers listed must be pressed together with the key to activate
+the binding.
+
+keysym
+======
+
+Keysym is a standard X keysym name, like F1 or Prior.
+
+where
+=====
+
+where is either "all", or one or more of window, frame, icon, root
+separated with '|' (bar).  This controls in what areas of the screen
+that the key will be active.
+
+func
+====
+
+The function to perform when the key is pressed.
+Currently the following are defined:
+
+rotatescreens  -  Move the frontmost screen to the back
+front          -  Move the window in which the key is pressed to the front
+back           -  Move the window in which the key is pressed to the back
+iconify        -  Iconify the window in which the key is pressed
+
+
+Example:
+
+Module "Keyboard" "\
+	Meta<F1>:window|frame:front\
+	Meta<F2>:window|frame:iconify\
+	Meta<F3>:window|frame:back"
+
+This binds the keys Meta-F1, Meta-F2 and Meta-F3 to front, back and
+iconify respectively.  The will only have effect inside windows and in
+window frames.  (These are the only places that front/iconfy/back has
+effect anyway.)
diff --git a/Xinitrc b/Xinitrc
new file mode 100644
index 0000000..7ab6eff
--- /dev/null
+++ b/Xinitrc
@@ -0,0 +1,18 @@
+#!/bin/ksh 
+# AmiWM startup script
+
+xrdb $OPENWINHOME/lib/Xdefaults		# Load Default X11 resource database
+if [ -f $HOME/.Xdefaults ]; then
+    xrdb -merge $HOME/.Xdefaults	# Load Users X11 resource database
+fi
+
+xsetroot -solid black
+/usr/local/bin/amiwm & wmpid=$!
+
+if [ -x $HOME/.amiwm-init ]; then
+    $HOME/.amiwm-init			# Custom amiwm tools
+else
+    /usr/local/lib/amiwm/amiwm-init   	# Default amiwm tools
+fi
+
+wait $wmpid				# Wait for wm (key client) to exit
diff --git a/Xinitrc.in b/Xinitrc.in
new file mode 100644
index 0000000..5702fa6
--- /dev/null
+++ b/Xinitrc.in
@@ -0,0 +1,18 @@
+#!/bin/ksh 
+# AmiWM startup script
+
+xrdb $OPENWINHOME/lib/Xdefaults		# Load Default X11 resource database
+if [ -f $HOME/.Xdefaults ]; then
+    xrdb -merge $HOME/.Xdefaults	# Load Users X11 resource database
+fi
+
+xsetroot -solid black
+@bindir@/amiwm & wmpid=$!
+
+if [ -x $HOME/.amiwm-init ]; then
+    $HOME/.amiwm-init			# Custom amiwm tools
+else
+    @AMIWM_HOME@/amiwm-init   	# Default amiwm tools
+fi
+
+wait $wmpid				# Wait for wm (key client) to exit
diff --git a/Xresources.amiwm.in b/Xresources.amiwm.in
new file mode 100644
index 0000000..78ae9e6
--- /dev/null
+++ b/Xresources.amiwm.in
@@ -0,0 +1,17 @@
+!!######################################################################
+!!
+!!   Xresources.amiwm
+!!
+!!   Configuration file for the amiwm alternate desktop resources 
+!!
+!!######################################################################
+!!
+!!  This file used by the Solaris Desktop Login manager
+
+
+Dtlogin*altDtsIncrement:	True
+
+Dtlogin*altDtName:	AmiWM Desktop
+Dtlogin*altDtKey:	@bindir@/amiwm
+Dtlogin*altDtStart:	@AMIWM_HOME@/Xsession
+Dtlogin*altDtLogo:	Amilogo
diff --git a/Xsession b/Xsession
new file mode 100644
index 0000000..d3e8972
--- /dev/null
+++ b/Xsession
@@ -0,0 +1,26 @@
+#!/bin/ksh 
+
+if [ -z "$SESSIONTYPE" ]
+then
+	export SESSIONTYPE="altDt"
+fi
+
+if [ -z "$DTSTARTIMS" ]
+then
+	export DTSTARTIMS="False"
+fi
+
+if [ -z "$SDT_ALT_SESSION" ]
+then
+	export SDT_ALT_SESSION="/usr/local/lib/amiwm/Xsession2"
+fi
+
+if [ -z "$SDT_ALT_HELLO" ]
+then
+  export SDT_ALT_HELLO="/usr/dt/bin/dthello -string 'Starting the AmiWM Desktop' &"
+fi
+
+export SDT_NO_DSDM=""
+
+
+/usr/dt/bin/Xsession
diff --git a/Xsession.in b/Xsession.in
new file mode 100644
index 0000000..ab6cf40
--- /dev/null
+++ b/Xsession.in
@@ -0,0 +1,26 @@
+#!/bin/ksh 
+
+if [ -z "$SESSIONTYPE" ]
+then
+	export SESSIONTYPE="altDt"
+fi
+
+if [ -z "$DTSTARTIMS" ]
+then
+	export DTSTARTIMS="False"
+fi
+
+if [ -z "$SDT_ALT_SESSION" ]
+then
+	export SDT_ALT_SESSION="@AMIWM_HOME@/Xsession2"
+fi
+
+if [ -z "$SDT_ALT_HELLO" ]
+then
+  export SDT_ALT_HELLO="/usr/dt/bin/dthello -string 'Starting the AmiWM Desktop' &"
+fi
+
+export SDT_NO_DSDM=""
+
+
+/usr/dt/bin/Xsession
diff --git a/Xsession2 b/Xsession2
new file mode 100644
index 0000000..fb2f0ee
--- /dev/null
+++ b/Xsession2
@@ -0,0 +1,34 @@
+#!/bin/ksh 
+
+unset SDT_ALT_SESSION
+unset SDT_ALT_HELLO
+unset SDT_NO_DSDM
+
+#
+# Find "xinitrc" file by standard precedence rules and start 
+# the user's AmiWM Desktop.
+#
+
+DEFAULT_XINITRC="/usr/local/lib/amiwm/Xinitrc"
+HOME_XINITRC="$HOME/.xinitrc"
+
+    if [ -z "$XINITRC" ]; then
+	if [ -f $HOME_XINITRC ]; then
+	    XINITRC=$HOME_XINITRC
+	else
+	    XINITRC=$DEFAULT_XINITRC
+	fi
+    fi
+
+    echo "AmiWM Desktop Login"
+
+    if [ -f $XINITRC ]; then
+	echo "using xinitrc file: $XINITRC"
+        /bin/ksh $XINITRC
+    else
+	echo "xinitrc file: $XINITRC not found"
+	if [ -f $DEFAULT_XINITRC ]; then
+	    echo "using xinitrc: $DEFAULT_XINITRC"
+	    /bin/ksh $DEFAULT_XINITRC 
+	fi
+    fi
diff --git a/Xsession2.in b/Xsession2.in
new file mode 100644
index 0000000..a5e6481
--- /dev/null
+++ b/Xsession2.in
@@ -0,0 +1,34 @@
+#!/bin/ksh 
+
+unset SDT_ALT_SESSION
+unset SDT_ALT_HELLO
+unset SDT_NO_DSDM
+
+#
+# Find "xinitrc" file by standard precedence rules and start 
+# the user's AmiWM Desktop.
+#
+
+DEFAULT_XINITRC="@AMIWM_HOME@/Xinitrc"
+HOME_XINITRC="$HOME/.xinitrc"
+
+    if [ -z "$XINITRC" ]; then
+	if [ -f $HOME_XINITRC ]; then
+	    XINITRC=$HOME_XINITRC
+	else
+	    XINITRC=$DEFAULT_XINITRC
+	fi
+    fi
+
+    echo "AmiWM Desktop Login"
+
+    if [ -f $XINITRC ]; then
+	echo "using xinitrc file: $XINITRC"
+        /bin/ksh $XINITRC
+    else
+	echo "xinitrc file: $XINITRC not found"
+	if [ -f $DEFAULT_XINITRC ]; then
+	    echo "using xinitrc: $DEFAULT_XINITRC"
+	    /bin/ksh $DEFAULT_XINITRC 
+	fi
+    fi
diff --git a/alloc.h b/alloc.h
new file mode 100644
index 0000000..e71ba68
--- /dev/null
+++ b/alloc.h
@@ -0,0 +1,8 @@
+#ifndef ALLOC_H
+#define ALLOC_H
+
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+
+#endif
diff --git a/amiwm.1 b/amiwm.1
new file mode 100644
index 0000000..21395c4
--- /dev/null
+++ b/amiwm.1
@@ -0,0 +1,187 @@
+.\" @(#)amiwm.1
+'\"macro stdmacro
+.nr X
+.TH amiwm 1 "26 Mar 2017"
+.SH NAME
+amiwm \- Amiga Workbench-like X Window Manager
+
+.SH SYNOPSIS
+amiwm
+
+.SH DESCRIPTION
+.I amiwm
+is an X Window manager that tries to make your workstation look like
+an Amiga\*R.
+
+.SH OPTIONS
+.I Amiwm 
+is configurable with a $HOME/\.amiwmrc-file containing some or all
+of the following options:
+.SH FastQuit:  {yes|no}
+
+Specifies whether amiwm should quit directly when the Quit
+menu item is selected, rather than popping up a requester.
+(on/off or true/false can be used instead of yes/no.)
+
+.SH SizeBorder {right|bottom|both|none}
+
+Specifies which border should be enlarged when a sizegadget is present.
+
+.SH ForceMove {manual|auto|always}
+
+Enables you to move windows outside the perimeter of the root window
+when pressing shift, when trying to drag at least 25% of the window
+ofscreen, or always, respectively.
+
+.SH IconDir path
+
+Specifies a directory in which amiwm will look for icons.
+
+.SH DefaultIcon name
+
+Gives the filename of the .info file to use as a default icon.
+It is relative to the IconDir.
+
+.SH IconPalette {system|magicwb|schwartz|\f1\*(lq\f3filename"}
+
+Selects either the Workbench\*R default palette, or the MagicWorkbench
+standard palette for use with icons.  The third option is a 16 color
+palette used on the "Eric Schwartz Productions CD Archive".  Alternatively,
+the filename of a PPM file representing the palette to use can be used.
+
+.SH ScreenFont \f1\*(lq\f3fontname"
+
+Selects a font to use for windowtitles etc.
+
+.SH IconFont \f1\*(lq\f3fontname"
+
+Selects a font for icontitles.
+
+.SH {detailpen|blockpen|textpen|shinepen|shadowpen|fillpen|filltextpen|
+        backgroundpen|highlighttextpen|bardetailpen|barblockpen|
+        bartrimpen} \f1\*(lq\f3colorname"
+
+Modifies the colour scheme for the window manager.
+
+.SH CustomIconsOnly {yes|no}
+
+This prevent applications to display their own icons when in iconified state.
+Only icons defined in amiwmrc for each apps will be used.
+Because apps own icon are too different from one eachother.
+They comes in various sizes and themes. Some icons will be 32x32,
+while some other will be a 128x128 or even bigger .. By using this option,
+You have the possibility to decide which icon should be used for each app.  
+If no custom icons are defined at all, the def_tool.info will be used for 
+all iconified apps. Format is: style { class "myClass" icon "myIcon.info" }
+To find out a given program's class, use "xlsclients -l" to list all opened
+applications, and then use "xprop -id <0x0000000>" to list a 
+given app's properties. Use either WM_CLASS or WM_ICON_NAME strings in amiwmrc.
+
+.SH ShortLabelIcons {yes|no}
+
+This limit the length of the text for iconified programs. For example, if this 
+option is activated, an iconified program text will be limited to 8 chars + ".."
+Use this option if you don't want iconified program text to be loong strings..
+
+.SH TitleBarClock {yes|no}
+
+Enables a clock in the titlebar.  It displays the date and time.
+
+.SH TitleClockFormat [<number>] "time string"
+
+This lets you choose a new format to display the Title Bar Clock.
+The time string is formatted with the standard strftime() parameters.
+The default is "%c".  It has been found that "%a %b %e %Y   %l:%M %p" works
+well too.  Number is the update interval in seconds.  
+
+.SH ToolItem \f1\*(lq\f3name" \f1\*(lq\f3command" \f1\*(lq\f3hotkey"
+
+Adds an item in the Tools menu with the specified name, which executes
+the command when selected.  A string containing a single uppercase letter
+may be specified as the third argument, making this letter a hotkey for the
+item.
+
+.SH ToolItem Separator
+
+Inserts a separator bar in the Tools menu.
+
+.SH ToolItem \f1\*(lq\f3name" { <tool item commands>}
+
+Create ToolItem:s in a submenu with the specified name.  It is not legal
+to create a submenu inside another submenu.
+
+.SH Screen [<number>] \f1\*(lq\f3name"
+
+Create a new screen with the specified name.  It will be placed below all
+earlier created screens.  To move a window between two screens, iconify it
+and drag the icon over to the other screen.  If the second argument is given,
+this screen is placed on the corresponding X screen.
+
+.SH ModulePath \f1\*(lq\f3path(:path...)"
+ 
+Sets one or more directories where amiwm will look for module binaries.
+The default is AMIWM_HOME.  Note that the module binaries cannot be
+shared amongst different architectures.
+ 
+.SH Module \f1\*(lq\f3name" ["initstring"]
+ 
+Start a module with the specified name.  If initstring is specified, it
+is sent to the module.  There are currently two modules shipped with
+amiwm; Background and Keyboard.  These are documented in the file
+README.modules.  If a module is limited to a single screen, like the
+Background module, the screen that was created last is used.
+
+.SH InterScreenGap number
+ 
+Sets the size in number of pixels of the "video DMA off" area that appears
+between screens when they are dragged.
+ 
+.SH AutoRaise {yes|no}
+ 
+Selects whether windows will automatically be moved to the front when
+they are activated.
+
+.SH Focus {followmouse|sloppy|clicktotype}
+
+Sets the policy by which windows are given focus.  Followmouse is the
+default and means that the window that contains the mouse pointer will
+have focus.  Sloppy means that the window that had focus last will keep
+it when the pointer is not over a window.  ClickToType is the original AmigaOS
+policy in which you have to explicitly give focus to windows by clicking
+in them.
+
+
+.SH TROUBLESHOOTING
+
+The most likely reason for amiwm to crash is if it
+can't find its default icon, or if this is not accepted as a
+*.info file.  If this happens, amiwm _will_ dump core.  So make
+sure that either 'make install' runs successfully (in which case
+amiwm will know where its icon is), or that the file .amiwmrc
+contains a correct specification of the icon's location.
+ 
+.SH CONFIGURATION FILES
+.nf
+$HOME/.amiwmrc
+$AMIWM_HOME/system.amiwmrc
+.fi
+
+.SH COPYRIGHT NOTICES
+This program is distributed as freeware. The copyright remains with
+the author. See the file LICENSE for more information.
+Amiga and Workbench are registered trademarks of AMIGA International Inc.
+
+.SH ORIGINAL AUTHOR
+Marcus Comstedt,
+.I marcus@mc.pp.se
+
+.SH CONTRIBUTORS
+
+Scott Lawrence,
+.I amiwm10@umlautllama.com
+
+Nicolas Sipieter,
+.I freeeaks@gmail.com
+
+redsPL,
+.I reds@desu.gq
diff --git a/client.c b/client.c
new file mode 100644
index 0000000..ef639fb
--- /dev/null
+++ b/client.c
@@ -0,0 +1,361 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "drawinfo.h"
+#include "screen.h"
+#include "icon.h"
+#include "client.h"
+#include "icc.h"
+#include "prefs.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+extern Display *dpy;
+extern XContext client_context, screen_context;
+extern Client *activeclient;
+extern Scrn *menuactive;
+extern void setfocus(Window);
+
+Client *clients=NULL;
+
+void grav_map_frame_to_win(Client *c, int x0, int y0, int *x, int *y)
+{
+  switch(c->gravity) {
+  case EastGravity:
+  case NorthEastGravity:
+  case SouthEastGravity:
+    *x=x0+c->framewidth-c->old_bw-c->old_bw; break;
+  case CenterGravity:
+  case NorthGravity:
+  case SouthGravity:
+    *x=x0+4-c->old_bw; break;
+  case WestGravity:
+  case NorthWestGravity:
+  case SouthWestGravity:
+  default:
+    *x=x0; break;
+  }
+  switch(c->gravity) {
+  case SouthGravity:
+  case SouthEastGravity:
+  case SouthWestGravity:
+    *y=y0+c->frameheight-c->old_bw-c->old_bw; break;
+  case CenterGravity:
+  case EastGravity:
+  case WestGravity:
+    *y=y0+c->scr->bh-c->old_bw; break;
+  case NorthGravity:
+  case NorthEastGravity:
+  case NorthWestGravity:
+  default:
+    *y=y0; break;
+  }
+}
+
+void grav_map_win_to_frame(Client *c, int x0, int y0, int *x, int *y)
+{
+  switch(c->gravity) {
+  case EastGravity:
+  case NorthEastGravity:
+  case SouthEastGravity:
+    *x=x0-c->framewidth+c->old_bw+c->old_bw; break;
+  case CenterGravity:
+  case NorthGravity:
+  case SouthGravity:
+    *x=x0-4+c->old_bw; break;
+  case WestGravity:
+  case NorthWestGravity:
+  case SouthWestGravity:
+  default:
+    *x=x0; break;
+  }
+  switch(c->gravity) {
+  case SouthGravity:
+  case SouthEastGravity:
+  case SouthWestGravity:
+    *y=y0-c->frameheight+c->old_bw+c->old_bw; break;
+  case CenterGravity:
+  case EastGravity:
+  case WestGravity:
+    *y=y0-c->scr->bh+c->old_bw; break;
+  case NorthGravity:
+  case NorthEastGravity:
+  case NorthWestGravity:
+  default:
+    *y=y0; break;
+  }
+}
+
+void sendconfig(Client *c)
+{
+  XConfigureEvent ce;
+
+  ce.type = ConfigureNotify;
+  ce.event = c->window;
+  ce.window = c->window;
+/*
+   grav_map_frame_to_win(c, c->x, c->y, &ce.x, &ce.y);
+*/
+  ce.x = c->x+4;
+#ifndef ASSIMILATE_WINDOWS
+  ce.y = c->y+c->scr->bh+c->scr->y;
+#else
+  ce.y = c->y+c->scr->bh;
+#endif
+  ce.width = c->pwidth-c->framewidth;
+  ce.height = c->pheight-c->frameheight;
+  ce.border_width = c->old_bw;
+  ce.above = None;
+  ce.override_redirect = 0;
+  XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent*)&ce);
+  XSync(dpy, False);
+}
+
+void scrsendconfig(Scrn *s)
+{
+  Client *c;
+  for (c=clients; c; c = c->next)
+    if(c->scr == s)
+      sendconfig(c);
+}
+
+void checksizehints(Client *c)
+{
+  long supplied;
+
+  XGetWMNormalHints(dpy, c->window, &c->sizehints, &supplied);
+  if(!(c->sizehints.flags&PMinSize))
+    c->sizehints.min_width=c->sizehints.min_height=0;
+  if(!(c->sizehints.flags&PMaxSize))
+    c->sizehints.max_width=c->sizehints.max_height=1<<30;
+  if(!(c->sizehints.flags&PResizeInc))
+    c->sizehints.width_inc=c->sizehints.height_inc=1;
+  if(c->sizehints.flags&PBaseSize) {
+    c->sizehints.min_width=c->sizehints.base_width;
+    c->sizehints.min_height=c->sizehints.base_height;
+  }
+  if(c->sizehints.min_width<1) c->sizehints.min_width=1;
+  if(c->sizehints.min_height<1) c->sizehints.min_height=1;
+  c->sizehints.base_width=c->sizehints.min_width;
+  c->sizehints.base_height=c->sizehints.min_height;
+  if(c->sizehints.flags&PWinGravity) c->gravity=c->sizehints.win_gravity;
+}
+
+void setclientstate(Client *c, int state)
+{
+  long data[2];
+
+  data[0] = (long) state;
+  data[1] = (long) None;
+
+  c->state = state;
+  XChangeProperty(dpy, c->window, wm_state, wm_state, 32,
+		  PropModeReplace, (unsigned char *)data, 2);
+}
+
+void getstate(Client *c)
+{
+  long *data=NULL;
+
+  if(_getprop(c->window, wm_state, wm_state, 2l, (char **)&data)>0) {
+    c->state=*data;
+    XFree((char *)data);
+  }
+}
+
+Client *createclient(Window w)
+{
+  extern void checkstyle(Client *c);
+
+  XWindowAttributes attr;
+  Client *c;
+
+  if(w==0) return 0;
+  if(!XFindContext(dpy, w, client_context, (XPointer*)&c)) return c;
+
+  XGetWindowAttributes(dpy, w, &attr);
+
+  c = (Client *)calloc(1, sizeof(Client));
+  c->scr = scr;
+  c->window = w;
+  c->parent = scr->root;
+  c->old_bw = attr.border_width;
+  c->next = clients;
+  c->state = WithdrawnState;
+  c->gravity = NorthWestGravity;
+  c->reparenting = 0;
+  XSelectInput(dpy, c->window, PropertyChangeMask);
+#ifdef USE_FONTSETS
+  {
+    XTextProperty prop;
+    c->title = NULL;
+    if(XGetWMName(dpy, c->window, &prop) && prop.value) {
+      char **list;
+      int n;
+      if(XmbTextPropertyToTextList(dpy, &prop, &list, &n) >= Success) {
+	if(n > 0)
+	  c->title = strdup(list[0]);
+	XFreeStringList(list);
+      }
+      XFree(prop.value);
+    }
+  }
+#else
+  XGetWMName(dpy, c->window, &c->title);
+#endif
+  c->style = NULL;
+  checkstyle(c);
+  checksizehints(c);
+  c->zoomx=0;
+  c->zoomy=scr->bh;
+  if(c->sizehints.width_inc) {
+    c->zoomw=scr->width-c->sizehints.base_width-22;
+    c->zoomw-=c->zoomw%c->sizehints.width_inc;
+    c->zoomw+=c->sizehints.base_width;
+    if(c->zoomw>c->sizehints.max_width)
+      c->zoomw=c->sizehints.max_width;
+    if(c->zoomw<c->sizehints.min_width)
+      c->zoomw=c->sizehints.min_width;
+  } else
+    c->zoomw=attr.width;
+  if(c->sizehints.height_inc) {
+    c->zoomh=scr->height-c->sizehints.base_height-scr->bh-c->zoomy-2;
+    c->zoomh-=c->zoomh%c->sizehints.height_inc;
+    c->zoomh+=c->sizehints.base_height;
+    if(c->zoomh>c->sizehints.max_height)
+      c->zoomh=c->sizehints.max_height;
+    if(c->zoomh<c->sizehints.min_height)
+      c->zoomh=c->sizehints.min_height;
+  } else
+    c->zoomh=attr.height;
+  XSaveContext(dpy, w, client_context, (XPointer)c);
+  return clients = c;
+}
+
+void rmclient(Client *c)
+{
+    Client *cc;
+
+    if (c == clients)
+      clients = c->next;
+    else
+      if((cc = clients))
+	for (; cc->next; cc = cc->next)
+	  if (cc->next == c) {
+            cc->next = cc->next->next;
+	    break;
+	  }
+
+    if(c->active) {
+      if(!menuactive)
+	setfocus(None);
+      c->active=False;
+      activeclient = NULL;
+      XInstallColormap(dpy, scr->cmap);
+    } else if(prefs.focus==FOC_CLICKTOTYPE)
+      XUngrabButton(dpy, Button1, AnyModifier, c->parent);
+#ifdef USE_FONTSETS
+    if(c->title)
+      free(c->title);
+#else
+    if(c->title.value)
+      XFree(c->title.value);
+#endif
+    if(c->parent != c->scr->root) {
+      XDestroyWindow(dpy, c->parent);
+      XDeleteContext(dpy, c->parent, client_context);
+    }
+    if(c->close)
+      XDeleteContext(dpy, c->close, client_context);
+    if(c->drag)
+      XDeleteContext(dpy, c->drag, client_context);
+    if(c->iconify)
+      XDeleteContext(dpy, c->iconify, client_context);
+    if(c->zoom)
+      XDeleteContext(dpy, c->zoom, client_context);
+    if(c->depth)
+      XDeleteContext(dpy, c->depth, client_context);
+    if(c->resize)
+      XDeleteContext(dpy, c->resize, client_context);
+    if(c->icon)
+      rmicon(c->icon);
+    if(c->window)
+      XDeleteContext(dpy, c->window, client_context);
+    free(c);
+}
+
+int screen_has_clients()
+{
+  int n = 0;
+  Client *c = clients;
+  while(c) {
+    if(c->scr == scr)
+      n++;
+    c = c->next;
+  }
+  return n;
+}
+
+void flushclients()
+{
+  unsigned int i, nwins;
+  Window dw1, dw2, *wins;
+  Client *c;
+#ifdef ASSIMILATE_WINDOWS
+  Scrn *scr2;
+#endif
+
+  if((scr = front)) do {
+    scr = scr->upfront;
+    XQueryTree(dpy, scr->back, &dw1, &dw2, &wins, &nwins);
+    for(i=0; i<nwins; i++)
+      if((!XFindContext(dpy, wins[i], client_context, (XPointer *)&c))&&wins[i]==c->parent) {
+	int x,y;
+	grav_map_frame_to_win(c, c->x, c->y, &x, &y);
+	XReparentWindow(dpy, c->window, scr->root, x, y);
+	XSetWindowBorderWidth(dpy, c->window, c->old_bw);
+	XRemoveFromSaveSet(dpy, c->window);
+	wins[i]=c->window;
+	rmclient(c);
+      }
+#ifdef ASSIMILATE_WINDOWS
+      else if((!XFindContext(dpy, wins[i], screen_context, (XPointer *)&scr2)) && scr2==scr) {
+	XWindowAttributes attr;
+	XSetWindowAttributes xsa;
+	XGetWindowAttributes(dpy, wins[i], &attr);
+	XReparentWindow(dpy, wins[i], scr->root, attr.x, attr.y);
+	xsa.override_redirect = True;
+	XChangeWindowAttributes(dpy, wins[i], CWOverrideRedirect, &xsa);
+	XDeleteContext(dpy, wins[i], screen_context);
+	XRemoveFromSaveSet(dpy, wins[i]);
+      }
+#endif
+    /*
+      if(nwins) {
+      for(i=0; i<(nwins>>1); i++) {
+      Window w=wins[i];
+      wins[i]=wins[nwins-1-i];
+      wins[nwins-1-i]=w;
+      }
+      XRestackWindows(dpy, wins, nwins);
+      }
+      */
+    XFree((void *) wins);
+  } while(scr!=front);
+  while((c=clients)) {
+    if(c->parent != c->scr->root) {
+      int x,y;
+      grav_map_frame_to_win(c, c->x, c->y, &x, &y);
+      XReparentWindow(dpy, c->window, c->scr->root, x, y);
+      XSetWindowBorderWidth(dpy, c->window, c->old_bw);
+      XRemoveFromSaveSet(dpy, c->window);
+    }
+    rmclient(c);
+  }
+}
diff --git a/client.h b/client.h
new file mode 100644
index 0000000..0754eec
--- /dev/null
+++ b/client.h
@@ -0,0 +1,46 @@
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+struct _Icon;
+struct _Scrn;
+typedef struct _Client {
+  struct _Client *next;
+  struct _Scrn *scr;
+  struct _Icon *icon;
+  struct module *module;
+  int wflags;
+  Window window, parent;
+  Window close, drag, iconify, zoom, depth, resize;
+  Window clicked;
+  Colormap colormap;
+  int x, y, pwidth, pheight, dragw, framewidth, frameheight;
+  int zoomx, zoomy, zoomw, zoomh;
+  int old_bw, proto, state, gravity, reparenting;
+  int active, shaped;
+#ifdef USE_FONTSETS
+  char *title;
+#else
+  XTextProperty title;
+#endif
+  XSizeHints sizehints;
+  struct _Style *style;
+} Client;
+
+extern Client *clients;
+
+extern Client *getclient(Window);
+extern Client *getclientbyicon(Window);
+extern Client *createclient(Window);
+extern void rmclient(Client *);
+extern void flushclients(void);
+extern void scrsendconfig(struct _Scrn *);
+extern void sendconfig(Client *);
+extern void getstate(Client *);
+extern void grav_map_frame_to_win(Client *, int, int, int *, int *);
+extern void grav_map_win_to_frame(Client *, int, int, int *, int *);
+extern void setclientstate(Client *, int);
+
+#endif
diff --git a/configure b/configure
new file mode 100755
index 0000000..1a2f5f8
--- /dev/null
+++ b/configure
@@ -0,0 +1,6504 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+PACKAGE_URL=
+
+ac_unique_file="diskobject.c"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='LTLIBOBJS
+LIBOBJS
+x_libraries
+x_includes
+XT_LIB_KLUDGE
+ALLOCA
+EGREP
+GREP
+X_EXTRA_LIBS
+X_LIBS
+X_PRE_LIBS
+X_CFLAGS
+CPP
+XMKMF
+RANLIB
+LN_S
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+LEXLIB
+LEX_OUTPUT_ROOT
+LEX
+YFLAGS
+YACC
+AWK
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_fontsets
+with_x
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+YACC
+YFLAGS
+XMKMF
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures this package to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+X features:
+  --x-includes=DIR    X include files are in DIR
+  --x-libraries=DIR   X library files are in DIR
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-fontsets
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-x                use the X Window System
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  YACC        The `Yet Another Compiler Compiler' implementation to use.
+              Defaults to the first program found out of: `bison -y', `byacc',
+              `yacc'.
+  YFLAGS      The list of arguments that will be passed by default to $YACC.
+              This script will default YFLAGS to the empty string to avoid a
+              default value of `-d' given by some make applications.
+  XMKMF       Path to xmkmf, Makefile generator for X Window System
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to the package provider.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+configure
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by $as_me, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+# Check whether --enable-fontsets was given.
+if test "${enable_fontsets+set}" = set; then :
+  enableval=$enable_fontsets; use_fontsets="$enableval"
+else
+  use_fontsets=auto
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing strerror" >&5
+$as_echo_n "checking for library containing strerror... " >&6; }
+if ${ac_cv_search_strerror+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_func_search_save_LIBS=$LIBS
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strerror ();
+int
+main ()
+{
+return strerror ();
+  ;
+  return 0;
+}
+_ACEOF
+for ac_lib in '' cposix; do
+  if test -z "$ac_lib"; then
+    ac_res="none required"
+  else
+    ac_res=-l$ac_lib
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+  fi
+  if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_search_strerror=$ac_res
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext
+  if ${ac_cv_search_strerror+:} false; then :
+  break
+fi
+done
+if ${ac_cv_search_strerror+:} false; then :
+
+else
+  ac_cv_search_strerror=no
+fi
+rm conftest.$ac_ext
+LIBS=$ac_func_search_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_strerror" >&5
+$as_echo "$ac_cv_search_strerror" >&6; }
+ac_res=$ac_cv_search_strerror
+if test "$ac_res" != no; then :
+  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+
+fi
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+for ac_prog in 'bison -y' byacc
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_YACC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$YACC"; then
+  ac_cv_prog_YACC="$YACC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_YACC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+YACC=$ac_cv_prog_YACC
+if test -n "$YACC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
+$as_echo "$YACC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$YACC" && break
+done
+test -n "$YACC" || YACC="yacc"
+
+for ac_prog in flex lex
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_LEX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$LEX"; then
+  ac_cv_prog_LEX="$LEX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LEX="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LEX=$ac_cv_prog_LEX
+if test -n "$LEX"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
+$as_echo "$LEX" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$LEX" && break
+done
+test -n "$LEX" || LEX=":"
+
+if test "x$LEX" != "x:"; then
+  cat >conftest.l <<_ACEOF
+%%
+a { ECHO; }
+b { REJECT; }
+c { yymore (); }
+d { yyless (1); }
+e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
+    yyless ((input () != 0)); }
+f { unput (yytext[0]); }
+. { BEGIN INITIAL; }
+%%
+#ifdef YYTEXT_POINTER
+extern char *yytext;
+#endif
+int
+main (void)
+{
+  return ! yylex () + ! yywrap ();
+}
+_ACEOF
+{ { ac_try="$LEX conftest.l"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$LEX conftest.l") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
+$as_echo_n "checking lex output file root... " >&6; }
+if ${ac_cv_prog_lex_root+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+if test -f lex.yy.c; then
+  ac_cv_prog_lex_root=lex.yy
+elif test -f lexyy.c; then
+  ac_cv_prog_lex_root=lexyy
+else
+  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
+$as_echo "$ac_cv_prog_lex_root" >&6; }
+LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+
+if test -z "${LEXLIB+set}"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
+$as_echo_n "checking lex library... " >&6; }
+if ${ac_cv_lib_lex+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    ac_save_LIBS=$LIBS
+    ac_cv_lib_lex='none needed'
+    for ac_lib in '' -lfl -ll; do
+      LIBS="$ac_lib $ac_save_LIBS"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+`cat $LEX_OUTPUT_ROOT.c`
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_lex=$ac_lib
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+      test "$ac_cv_lib_lex" != 'none needed' && break
+    done
+    LIBS=$ac_save_LIBS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
+$as_echo "$ac_cv_lib_lex" >&6; }
+  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
+$as_echo_n "checking whether yytext is a pointer... " >&6; }
+if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # POSIX says lex can declare yytext either as a pointer or an array; the
+# default is implementation-dependent.  Figure out which it is, since
+# not all implementations provide the %pointer and %array declarations.
+ac_cv_prog_lex_yytext_pointer=no
+ac_save_LIBS=$LIBS
+LIBS="$LEXLIB $ac_save_LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+  #define YYTEXT_POINTER 1
+`cat $LEX_OUTPUT_ROOT.c`
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_prog_lex_yytext_pointer=yes
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_save_LIBS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
+$as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
+if test $ac_cv_prog_lex_yytext_pointer = yes; then
+
+$as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
+
+fi
+rm -f conftest.l $LEX_OUTPUT_ROOT.c
+
+fi
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+  ./ | .// | /[cC]/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+$as_echo_n "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+$as_echo "no, using $LN_S" >&6; }
+fi
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
+$as_echo_n "checking for X... " >&6; }
+
+
+# Check whether --with-x was given.
+if test "${with_x+set}" = set; then :
+  withval=$with_x;
+fi
+
+# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
+if test "x$with_x" = xno; then
+  # The user explicitly disabled X.
+  have_x=disabled
+else
+  case $x_includes,$x_libraries in #(
+    *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
+    *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # One or both of the vars are not set, and there is no cached value.
+ac_x_includes=no ac_x_libraries=no
+rm -f -r conftest.dir
+if mkdir conftest.dir; then
+  cd conftest.dir
+  cat >Imakefile <<'_ACEOF'
+incroot:
+	@echo incroot='${INCROOT}'
+usrlibdir:
+	@echo usrlibdir='${USRLIBDIR}'
+libdir:
+	@echo libdir='${LIBDIR}'
+_ACEOF
+  if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
+    # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+    for ac_var in incroot usrlibdir libdir; do
+      eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
+    done
+    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
+    for ac_extension in a so sl dylib la dll; do
+      if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
+	 test -f "$ac_im_libdir/libX11.$ac_extension"; then
+	ac_im_usrlibdir=$ac_im_libdir; break
+      fi
+    done
+    # Screen out bogus values from the imake configuration.  They are
+    # bogus both because they are the default anyway, and because
+    # using them would break gcc on systems where it needs fixed includes.
+    case $ac_im_incroot in
+	/usr/include) ac_x_includes= ;;
+	*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
+    esac
+    case $ac_im_usrlibdir in
+	/usr/lib | /usr/lib64 | /lib | /lib64) ;;
+	*) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
+    esac
+  fi
+  cd ..
+  rm -f -r conftest.dir
+fi
+
+# Standard set of common directories for X headers.
+# Check X11 before X11Rn because it is often a symlink to the current release.
+ac_x_header_dirs='
+/usr/X11/include
+/usr/X11R7/include
+/usr/X11R6/include
+/usr/X11R5/include
+/usr/X11R4/include
+
+/usr/include/X11
+/usr/include/X11R7
+/usr/include/X11R6
+/usr/include/X11R5
+/usr/include/X11R4
+
+/usr/local/X11/include
+/usr/local/X11R7/include
+/usr/local/X11R6/include
+/usr/local/X11R5/include
+/usr/local/X11R4/include
+
+/usr/local/include/X11
+/usr/local/include/X11R7
+/usr/local/include/X11R6
+/usr/local/include/X11R5
+/usr/local/include/X11R4
+
+/usr/X386/include
+/usr/x386/include
+/usr/XFree86/include/X11
+
+/usr/include
+/usr/local/include
+/usr/unsupported/include
+/usr/athena/include
+/usr/local/x11r5/include
+/usr/lpp/Xamples/include
+
+/usr/openwin/include
+/usr/openwin/share/include'
+
+if test "$ac_x_includes" = no; then
+  # Guess where to find include files, by looking for Xlib.h.
+  # First, try using that file with no special directory specified.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <X11/Xlib.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # We can compile using X headers with no special include directory.
+ac_x_includes=
+else
+  for ac_dir in $ac_x_header_dirs; do
+  if test -r "$ac_dir/X11/Xlib.h"; then
+    ac_x_includes=$ac_dir
+    break
+  fi
+done
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+fi # $ac_x_includes = no
+
+if test "$ac_x_libraries" = no; then
+  # Check for the libraries.
+  # See if we find them without any special options.
+  # Don't add to $LIBS permanently.
+  ac_save_LIBS=$LIBS
+  LIBS="-lX11 $LIBS"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <X11/Xlib.h>
+int
+main ()
+{
+XrmInitialize ()
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  LIBS=$ac_save_LIBS
+# We can link X programs with no special library path.
+ac_x_libraries=
+else
+  LIBS=$ac_save_LIBS
+for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
+do
+  # Don't even attempt the hair of trying to link an X program!
+  for ac_extension in a so sl dylib la dll; do
+    if test -r "$ac_dir/libX11.$ac_extension"; then
+      ac_x_libraries=$ac_dir
+      break 2
+    fi
+  done
+done
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi # $ac_x_libraries = no
+
+case $ac_x_includes,$ac_x_libraries in #(
+  no,* | *,no | *\'*)
+    # Didn't find X, or a directory has "'" in its name.
+    ac_cv_have_x="have_x=no";; #(
+  *)
+    # Record where we found X for the cache.
+    ac_cv_have_x="have_x=yes\
+	ac_x_includes='$ac_x_includes'\
+	ac_x_libraries='$ac_x_libraries'"
+esac
+fi
+;; #(
+    *) have_x=yes;;
+  esac
+  eval "$ac_cv_have_x"
+fi # $with_x != no
+
+if test "$have_x" != yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
+$as_echo "$have_x" >&6; }
+  no_x=yes
+else
+  # If each of the values was on the command line, it overrides each guess.
+  test "x$x_includes" = xNONE && x_includes=$ac_x_includes
+  test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
+  # Update the cache value to reflect the command line values.
+  ac_cv_have_x="have_x=yes\
+	ac_x_includes='$x_includes'\
+	ac_x_libraries='$x_libraries'"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
+$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
+fi
+
+if test "$no_x" = yes; then
+  # Not all programs may use this symbol, but it does not hurt to define it.
+
+$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
+
+  X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
+else
+  if test -n "$x_includes"; then
+    X_CFLAGS="$X_CFLAGS -I$x_includes"
+  fi
+
+  # It would also be nice to do this for all -L options, not just this one.
+  if test -n "$x_libraries"; then
+    X_LIBS="$X_LIBS -L$x_libraries"
+    # For Solaris; some versions of Sun CC require a space after -R and
+    # others require no space.  Words are not sufficient . . . .
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
+$as_echo_n "checking whether -R must be followed by a space... " >&6; }
+    ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
+    ac_xsave_c_werror_flag=$ac_c_werror_flag
+    ac_c_werror_flag=yes
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+       X_LIBS="$X_LIBS -R$x_libraries"
+else
+  LIBS="$ac_xsave_LIBS -R $x_libraries"
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	  X_LIBS="$X_LIBS -R $x_libraries"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
+$as_echo "neither works" >&6; }
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    ac_c_werror_flag=$ac_xsave_c_werror_flag
+    LIBS=$ac_xsave_LIBS
+  fi
+
+  # Check for system-dependent libraries X programs must link with.
+  # Do this before checking for the system-independent R6 libraries
+  # (-lICE), since we may need -lsocket or whatever for X linking.
+
+  if test "$ISC" = yes; then
+    X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet"
+  else
+    # Martyn Johnson says this is needed for Ultrix, if the X
+    # libraries were built with DECnet support.  And Karl Berry says
+    # the Alpha needs dnet_stub (dnet does not exist).
+    ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char XOpenDisplay ();
+int
+main ()
+{
+return XOpenDisplay ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
+$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
+if ${ac_cv_lib_dnet_dnet_ntoa+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldnet  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dnet_ntoa ();
+int
+main ()
+{
+return dnet_ntoa ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dnet_dnet_ntoa=yes
+else
+  ac_cv_lib_dnet_dnet_ntoa=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
+$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
+if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
+fi
+
+    if test $ac_cv_lib_dnet_dnet_ntoa = no; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
+$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
+if ${ac_cv_lib_dnet_stub_dnet_ntoa+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldnet_stub  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dnet_ntoa ();
+int
+main ()
+{
+return dnet_ntoa ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dnet_stub_dnet_ntoa=yes
+else
+  ac_cv_lib_dnet_stub_dnet_ntoa=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
+$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
+if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
+fi
+
+    fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    LIBS="$ac_xsave_LIBS"
+
+    # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,
+    # to get the SysV transport functions.
+    # Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4)
+    # needs -lnsl.
+    # The nsl library prevents programs from opening the X display
+    # on Irix 5.2, according to T.E. Dickey.
+    # The functions gethostbyname, getservbyname, and inet_addr are
+    # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
+    ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
+if test "x$ac_cv_func_gethostbyname" = xyes; then :
+
+fi
+
+    if test $ac_cv_func_gethostbyname = no; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
+$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
+if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lnsl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char gethostbyname ();
+int
+main ()
+{
+return gethostbyname ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_nsl_gethostbyname=yes
+else
+  ac_cv_lib_nsl_gethostbyname=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
+$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
+if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
+fi
+
+      if test $ac_cv_lib_nsl_gethostbyname = no; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
+$as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
+if ${ac_cv_lib_bsd_gethostbyname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lbsd  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char gethostbyname ();
+int
+main ()
+{
+return gethostbyname ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_bsd_gethostbyname=yes
+else
+  ac_cv_lib_bsd_gethostbyname=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
+$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
+if test "x$ac_cv_lib_bsd_gethostbyname" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
+fi
+
+      fi
+    fi
+
+    # lieder@skyler.mavd.honeywell.com says without -lsocket,
+    # socket/setsockopt and other routines are undefined under SCO ODT
+    # 2.0.  But -lsocket is broken on IRIX 5.2 (and is not necessary
+    # on later versions), says Simon Leinen: it contains gethostby*
+    # variants that don't use the name server (or something).  -lsocket
+    # must be given before -lnsl if both are needed.  We assume that
+    # if connect needs -lnsl, so does gethostbyname.
+    ac_fn_c_check_func "$LINENO" "connect" "ac_cv_func_connect"
+if test "x$ac_cv_func_connect" = xyes; then :
+
+fi
+
+    if test $ac_cv_func_connect = no; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
+$as_echo_n "checking for connect in -lsocket... " >&6; }
+if ${ac_cv_lib_socket_connect+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char connect ();
+int
+main ()
+{
+return connect ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_socket_connect=yes
+else
+  ac_cv_lib_socket_connect=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
+$as_echo "$ac_cv_lib_socket_connect" >&6; }
+if test "x$ac_cv_lib_socket_connect" = xyes; then :
+  X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
+fi
+
+    fi
+
+    # Guillermo Gomez says -lposix is necessary on A/UX.
+    ac_fn_c_check_func "$LINENO" "remove" "ac_cv_func_remove"
+if test "x$ac_cv_func_remove" = xyes; then :
+
+fi
+
+    if test $ac_cv_func_remove = no; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
+$as_echo_n "checking for remove in -lposix... " >&6; }
+if ${ac_cv_lib_posix_remove+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lposix  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char remove ();
+int
+main ()
+{
+return remove ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_posix_remove=yes
+else
+  ac_cv_lib_posix_remove=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
+$as_echo "$ac_cv_lib_posix_remove" >&6; }
+if test "x$ac_cv_lib_posix_remove" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
+fi
+
+    fi
+
+    # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
+    ac_fn_c_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
+if test "x$ac_cv_func_shmat" = xyes; then :
+
+fi
+
+    if test $ac_cv_func_shmat = no; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
+$as_echo_n "checking for shmat in -lipc... " >&6; }
+if ${ac_cv_lib_ipc_shmat+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lipc  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shmat ();
+int
+main ()
+{
+return shmat ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_ipc_shmat=yes
+else
+  ac_cv_lib_ipc_shmat=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
+$as_echo "$ac_cv_lib_ipc_shmat" >&6; }
+if test "x$ac_cv_lib_ipc_shmat" = xyes; then :
+  X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
+fi
+
+    fi
+  fi
+
+  # Check for libraries that X11R6 Xt/Xaw programs need.
+  ac_save_LDFLAGS=$LDFLAGS
+  test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries"
+  # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to
+  # check for ICE first), but we must link in the order -lSM -lICE or
+  # we get undefined symbols.  So assume we have SM if we have ICE.
+  # These have to be linked with before -lX11, unlike the other
+  # libraries we check for below, so use a different variable.
+  # John Interrante, Karl Berry
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
+$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
+if ${ac_cv_lib_ICE_IceConnectionNumber+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lICE $X_EXTRA_LIBS $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char IceConnectionNumber ();
+int
+main ()
+{
+return IceConnectionNumber ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_ICE_IceConnectionNumber=yes
+else
+  ac_cv_lib_ICE_IceConnectionNumber=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
+$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
+if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes; then :
+  X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
+fi
+
+  LDFLAGS=$ac_save_LDFLAGS
+
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5
+$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; }
+if ${ac_cv_header_sys_wait_h+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <sys/wait.h>
+#ifndef WEXITSTATUS
+# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)
+#endif
+#ifndef WIFEXITED
+# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
+#endif
+
+int
+main ()
+{
+  int s;
+  wait (&s);
+  s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_sys_wait_h=yes
+else
+  ac_cv_header_sys_wait_h=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5
+$as_echo "$ac_cv_header_sys_wait_h" >&6; }
+if test $ac_cv_header_sys_wait_h = yes; then
+
+$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in fcntl.h limits.h sys/time.h sys/types.h unistd.h sys/select.h sys/resource.h sys/stat.h termio.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+ac_save_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$X_CFLAGS $CPPFLAGS"
+for ac_header in X11/extensions/shape.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "X11/extensions/shape.h" "ac_cv_header_X11_extensions_shape_h" "$ac_includes_default"
+if test "x$ac_cv_header_X11_extensions_shape_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_X11_EXTENSIONS_SHAPE_H 1
+_ACEOF
+
+fi
+
+done
+
+CPPFLAGS="$ac_save_CPPFLAGS"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
+$as_echo_n "checking for an ANSI C-conforming const... " >&6; }
+if ${ac_cv_c_const+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+#ifndef __cplusplus
+  /* Ultrix mips cc rejects this sort of thing.  */
+  typedef int charset[2];
+  const charset cs = { 0, 0 };
+  /* SunOS 4.1.1 cc rejects this.  */
+  char const *const *pcpcc;
+  char **ppc;
+  /* NEC SVR4.0.2 mips cc rejects this.  */
+  struct point {int x, y;};
+  static struct point const zero = {0,0};
+  /* AIX XL C 1.02.0.0 rejects this.
+     It does not let you subtract one const X* pointer from another in
+     an arm of an if-expression whose if-part is not a constant
+     expression */
+  const char *g = "string";
+  pcpcc = &g + (g ? g-g : 0);
+  /* HPUX 7.0 cc rejects these. */
+  ++pcpcc;
+  ppc = (char**) pcpcc;
+  pcpcc = (char const *const *) ppc;
+  { /* SCO 3.2v4 cc rejects this sort of thing.  */
+    char tx;
+    char *t = &tx;
+    char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+    *t++ = 0;
+    if (s) return 0;
+  }
+  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+    int x[] = {25, 17};
+    const int *foo = &x[0];
+    ++foo;
+  }
+  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+    typedef const int *iptr;
+    iptr p = 0;
+    ++p;
+  }
+  { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
+       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+    struct s { int j; const int *ap[3]; } bx;
+    struct s *b = &bx; b->j = 5;
+  }
+  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+    const int foo = 10;
+    if (!foo) return 0;
+  }
+  return !cs[0] && !zero.x;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_const=yes
+else
+  ac_cv_c_const=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
+$as_echo "$ac_cv_c_const" >&6; }
+if test $ac_cv_c_const = no; then
+
+$as_echo "#define const /**/" >>confdefs.h
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether char is unsigned" >&5
+$as_echo_n "checking whether char is unsigned... " >&6; }
+if ${ac_cv_c_char_unsigned+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+main ()
+{
+static int test_array [1 - 2 * !(((char) -1) < 0)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_char_unsigned=no
+else
+  ac_cv_c_char_unsigned=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_char_unsigned" >&5
+$as_echo "$ac_cv_c_char_unsigned" >&6; }
+if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
+  $as_echo "#define __CHAR_UNSIGNED__ 1" >>confdefs.h
+
+fi
+
+ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default"
+if test "x$ac_cv_type_pid_t" = xyes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define pid_t int
+_ACEOF
+
+fi
+
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
+_ACEOF
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
+$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
+if ${ac_cv_header_time+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+
+int
+main ()
+{
+if ((struct tm *) 0)
+return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_time=yes
+else
+  ac_cv_header_time=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
+$as_echo "$ac_cv_header_time" >&6; }
+if test $ac_cv_header_time = yes; then
+
+$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
+$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
+if ${ac_cv_struct_tm+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <time.h>
+
+int
+main ()
+{
+struct tm tm;
+				     int *p = &tm.tm_sec;
+				     return !p;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_struct_tm=time.h
+else
+  ac_cv_struct_tm=sys/time.h
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
+$as_echo "$ac_cv_struct_tm" >&6; }
+if test $ac_cv_struct_tm = sys/time.h; then
+
+$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
+
+fi
+
+
+# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+# for constant arguments.  Useless!
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5
+$as_echo_n "checking for working alloca.h... " >&6; }
+if ${ac_cv_working_alloca_h+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <alloca.h>
+int
+main ()
+{
+char *p = (char *) alloca (2 * sizeof (int));
+			  if (p) return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_working_alloca_h=yes
+else
+  ac_cv_working_alloca_h=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5
+$as_echo "$ac_cv_working_alloca_h" >&6; }
+if test $ac_cv_working_alloca_h = yes; then
+
+$as_echo "#define HAVE_ALLOCA_H 1" >>confdefs.h
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for alloca" >&5
+$as_echo_n "checking for alloca... " >&6; }
+if ${ac_cv_func_alloca_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __GNUC__
+# define alloca __builtin_alloca
+#else
+# ifdef _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# else
+#  ifdef HAVE_ALLOCA_H
+#   include <alloca.h>
+#  else
+#   ifdef _AIX
+ #pragma alloca
+#   else
+#    ifndef alloca /* predefined by HP cc +Olibcalls */
+void *alloca (size_t);
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+int
+main ()
+{
+char *p = (char *) alloca (1);
+				    if (p) return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_func_alloca_works=yes
+else
+  ac_cv_func_alloca_works=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5
+$as_echo "$ac_cv_func_alloca_works" >&6; }
+
+if test $ac_cv_func_alloca_works = yes; then
+
+$as_echo "#define HAVE_ALLOCA 1" >>confdefs.h
+
+else
+  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
+# that cause trouble.  Some versions do not even contain alloca or
+# contain a buggy version.  If you still want to use their alloca,
+# use ar to extract alloca.o from them instead of compiling alloca.c.
+
+ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+
+$as_echo "#define C_ALLOCA 1" >>confdefs.h
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether \`alloca.c' needs Cray hooks" >&5
+$as_echo_n "checking whether \`alloca.c' needs Cray hooks... " >&6; }
+if ${ac_cv_os_cray+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#if defined CRAY && ! defined CRAY2
+webecray
+#else
+wenotbecray
+#endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "webecray" >/dev/null 2>&1; then :
+  ac_cv_os_cray=yes
+else
+  ac_cv_os_cray=no
+fi
+rm -f conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_cray" >&5
+$as_echo "$ac_cv_os_cray" >&6; }
+if test $ac_cv_os_cray = yes; then
+  for ac_func in _getb67 GETB67 getb67; do
+    as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+
+cat >>confdefs.h <<_ACEOF
+#define CRAY_STACKSEG_END $ac_func
+_ACEOF
+
+    break
+fi
+
+  done
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking stack direction for C alloca" >&5
+$as_echo_n "checking stack direction for C alloca... " >&6; }
+if ${ac_cv_c_stack_direction+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_c_stack_direction=0
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+find_stack_direction (int *addr, int depth)
+{
+  int dir, dummy = 0;
+  if (! addr)
+    addr = &dummy;
+  *addr = addr < &dummy ? 1 : addr == &dummy ? 0 : -1;
+  dir = depth ? find_stack_direction (addr, depth - 1) : 0;
+  return dir + dummy;
+}
+
+int
+main (int argc, char **argv)
+{
+  return find_stack_direction (0, argc + !argv + 20) < 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_c_stack_direction=1
+else
+  ac_cv_c_stack_direction=-1
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5
+$as_echo "$ac_cv_c_stack_direction" >&6; }
+cat >>confdefs.h <<_ACEOF
+#define STACK_DIRECTION $ac_cv_c_stack_direction
+_ACEOF
+
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5
+$as_echo_n "checking return type of signal handlers... " >&6; }
+if ${ac_cv_type_signal+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <signal.h>
+
+int
+main ()
+{
+return *(signal (0, 0)) (0) == 1;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_type_signal=int
+else
+  ac_cv_type_signal=void
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal" >&5
+$as_echo "$ac_cv_type_signal" >&6; }
+
+cat >>confdefs.h <<_ACEOF
+#define RETSIGTYPE $ac_cv_type_signal
+_ACEOF
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for wait3 that fills in rusage" >&5
+$as_echo_n "checking for wait3 that fills in rusage... " >&6; }
+if ${ac_cv_func_wait3_rusage+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_wait3_rusage=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+/* HP-UX has wait3 but does not fill in rusage at all.  */
+int
+main ()
+{
+  struct rusage r;
+  int i;
+  /* Use a field that we can force nonzero --
+     voluntary context switches.
+     For systems like NeXT and OSF/1 that don't set it,
+     also use the system CPU time.  And page faults (I/O) for Linux.  */
+  r.ru_nvcsw = 0;
+  r.ru_stime.tv_sec = 0;
+  r.ru_stime.tv_usec = 0;
+  r.ru_majflt = r.ru_minflt = 0;
+  switch (fork ())
+    {
+    case 0: /* Child.  */
+      sleep(1); /* Give up the CPU.  */
+      _exit(0);
+      break;
+    case -1: /* What can we do?  */
+      _exit(0);
+      break;
+    default: /* Parent.  */
+      wait3(&i, 0, &r);
+      /* Avoid "text file busy" from rm on fast HP-UX machines.  */
+      sleep(2);
+      return (r.ru_nvcsw == 0 && r.ru_majflt == 0 && r.ru_minflt == 0
+	      && r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0);
+    }
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_wait3_rusage=yes
+else
+  ac_cv_func_wait3_rusage=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_wait3_rusage" >&5
+$as_echo "$ac_cv_func_wait3_rusage" >&6; }
+if test $ac_cv_func_wait3_rusage = yes; then
+
+$as_echo "#define HAVE_WAIT3 1" >>confdefs.h
+
+fi
+
+for ac_func in select strdup waitpid
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken libXmu" >&5
+$as_echo_n "checking for broken libXmu... " >&6; }
+old_LIBS="$LIBS"
+LIBS="$X_LIBS $X_PRE_LIBS -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  extern void XmuCopyISOLatin1Lowered(char *,char *);
+  char foo[]="FOO";
+  XmuCopyISOLatin1Lowered (foo, foo);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+XT_LIB_KLUDGE=""
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+XT_LIB_KLUDGE="-lXt"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS="$old_LIBS"
+
+
+
+if test "x$ac_cv_header_X11_extensions_shape_h" = xyes; then
+  ac_save_LIBS="$LIBS"
+  LIBS="$X_LIBS $X_PRE_LIBS $XT_LIB_KLUDGE -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+  ac_fn_c_check_func "$LINENO" "XShapeQueryExtension" "ac_cv_func_XShapeQueryExtension"
+if test "x$ac_cv_func_XShapeQueryExtension" = xyes; then :
+
+$as_echo "#define HAVE_XSHAPE 1" >>confdefs.h
+
+fi
+
+  LIBS="$ac_save_LIBS"
+else
+  :
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking number of arguments to gettimeofday" >&5
+$as_echo_n "checking number of arguments to gettimeofday... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+int
+main ()
+{
+
+  struct timeval tp;
+  struct timezone tz;
+  gettimeofday(&tp, &tz);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+$as_echo "#define BSD_STYLE_GETTIMEOFDAY 1" >>confdefs.h
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: 2" >&5
+$as_echo "2" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: 1" >&5
+$as_echo "1" >&6; }
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+
+ac_fn_c_check_type "$LINENO" "caddr_t" "ac_cv_type_caddr_t" "$ac_includes_default"
+if test "x$ac_cv_type_caddr_t" = xyes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define caddr_t char *
+_ACEOF
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XPointer" >&5
+$as_echo_n "checking for XPointer... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$x_includes${x_includes:+/}X11/Xlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "XPointer[^a-zA-Z_]" >/dev/null 2>&1; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+
+$as_echo "#define XPointer caddr_t" >>confdefs.h
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+rm -f conftest*
+
+
+ac_save_LIBS="$LIBS"
+LIBS="$X_LIBS $X_PRE_LIBS $XT_LIB_KLUDGE -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+for ac_func in XCreateFontSet XmbTextEscapement Xutf8DrawImageString
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+LIBS="$ac_save_LIBS"
+
+if test "x$ac_cv_func_XCreateFontSet:$ac_cv_func_XmbTextEscapement:$use_fontsets" = xyes:yes:auto; then
+  use_fontsets=yes
+else
+  :
+fi
+
+if test "x$use_fontsets" = xyes; then
+  $as_echo "#define USE_FONTSETS 1" >>confdefs.h
+
+else
+  :
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking byteorder" >&5
+$as_echo_n "checking byteorder... " >&6; }
+if test "$cross_compiling" = yes; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no idea" >&5
+$as_echo "no idea" >&6; }
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int main()
+{
+  union { int i; char c[sizeof(int)]; } v;
+  v.i=0;
+  v.c[0]=1;
+  if(v.i==1) exit(0); else exit(1);
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+$as_echo "#define LAME_ENDIAN 1" >>confdefs.h
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: backward" >&5
+$as_echo "backward" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: normal" >&5
+$as_echo "normal" >&6; }
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+
+
+
+ac_config_files="$ac_config_files Makefile libami/Makefile"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# Transform confdefs.h into DEFS.
+# Protect against shell expansion while executing Makefile rules.
+# Protect against Makefile macro expansion.
+#
+# If the first sed substitution is executed (which looks for macros that
+# take arguments), then branch to the quote section.  Otherwise,
+# look for a macro that doesn't take arguments.
+ac_script='
+:mline
+/\\$/{
+ N
+ s,\\\n,,
+ b mline
+}
+t clear
+:clear
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+b any
+:quote
+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
+s/\[/\\&/g
+s/\]/\\&/g
+s/\$/$$/g
+H
+:any
+${
+	g
+	s/^\n//
+	s/\n/ /g
+	p
+}
+'
+DEFS=`sed -n "$ac_script" confdefs.h`
+
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+
+Configuration files:
+$config_files
+
+Report bugs to the package provider."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+config.status
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h |  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+    "libami/Makefile") CONFIG_FILES="$CONFIG_FILES libami/Makefile" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+
+eval set X "  :F $CONFIG_FILES      "
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+
+
+
+  esac
+
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
diff --git a/configure.in b/configure.in
new file mode 100644
index 0000000..5ffbde0
--- /dev/null
+++ b/configure.in
@@ -0,0 +1,115 @@
+AC_INIT(diskobject.c)
+
+AC_ENABLE(fontsets,
+	  [use_fontsets="$enableval"], [use_fontsets=auto])
+
+AC_PROG_CC
+AC_ISC_POSIX
+AC_PROG_AWK
+AC_PROG_YACC
+AC_PROG_LEX
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_RANLIB
+
+AC_PATH_XTRA
+
+AC_HEADER_STDC
+AC_HEADER_SYS_WAIT
+AC_CHECK_HEADERS(fcntl.h limits.h sys/time.h sys/types.h unistd.h sys/select.h sys/resource.h sys/stat.h termio.h)
+ac_save_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$X_CFLAGS $CPPFLAGS"
+AC_CHECK_HEADERS(X11/extensions/shape.h)
+CPPFLAGS="$ac_save_CPPFLAGS"
+
+AC_C_CONST
+AC_C_CHAR_UNSIGNED
+AC_TYPE_PID_T
+AC_TYPE_SIZE_T
+AC_HEADER_TIME
+AC_STRUCT_TM
+
+AC_FUNC_ALLOCA
+AC_TYPE_SIGNAL
+AC_FUNC_WAIT3
+AC_CHECK_FUNCS(select strdup waitpid)
+
+
+dnl  On SunOS4, libXmu seems to be all in one unit forcing references
+dnl  to libXt into the linking.  Only fix I can think of is to link with
+dnl  libXt too, so that's what we'll do.
+
+AC_MSG_CHECKING([for broken libXmu])
+old_LIBS="$LIBS"
+LIBS="$X_LIBS $X_PRE_LIBS -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+AC_TRY_LINK([],[
+  extern void XmuCopyISOLatin1Lowered(char *,char *);
+  char foo[]="FOO";
+  XmuCopyISOLatin1Lowered (foo, foo);
+], AC_MSG_RESULT([no])
+XT_LIB_KLUDGE="", AC_MSG_RESULT([yes])
+XT_LIB_KLUDGE="-lXt")
+LIBS="$old_LIBS"
+AC_SUBST(XT_LIB_KLUDGE)
+
+
+if test "x$ac_cv_header_X11_extensions_shape_h" = xyes; then
+  ac_save_LIBS="$LIBS"
+  LIBS="$X_LIBS $X_PRE_LIBS $XT_LIB_KLUDGE -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+  AC_CHECK_FUNC(XShapeQueryExtension, AC_DEFINE([HAVE_XSHAPE],1,[Define this if your Xlib supports the SHAPE X server extension.]))
+  LIBS="$ac_save_LIBS"
+else
+  :
+fi
+
+AC_MSG_CHECKING([number of arguments to gettimeofday])
+AC_TRY_LINK([
+#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+],[
+  struct timeval tp;
+  struct timezone tz;
+  gettimeofday(&tp, &tz);
+], AC_DEFINE(BSD_STYLE_GETTIMEOFDAY,1,[Define this if gettimeofday() takes two arguments.])
+AC_MSG_RESULT([2]), AC_MSG_RESULT([1]))
+
+AC_CHECK_TYPE(caddr_t, char *)
+AC_MSG_CHECKING([for XPointer])
+AC_EGREP_HEADER([XPointer[^a-zA-Z_]], [$]x_includes[$]{x_includes:+/}X11/Xlib.h, AC_MSG_RESULT([yes]), AC_DEFINE(XPointer, caddr_t,[Define this to a pointer type if XPointer is not a predefined type])
+AC_MSG_RESULT([no]))
+
+ac_save_LIBS="$LIBS"
+LIBS="$X_LIBS $X_PRE_LIBS $XT_LIB_KLUDGE -lXext -lXmu -lX11 $X_EXTRA_LIBS $LIBS"
+AC_CHECK_FUNCS(XCreateFontSet XmbTextEscapement Xutf8DrawImageString)
+LIBS="$ac_save_LIBS"
+
+if test "x$ac_cv_func_XCreateFontSet:$ac_cv_func_XmbTextEscapement:$use_fontsets" = xyes:yes:auto; then
+  use_fontsets=yes
+else
+  :
+fi
+
+if test "x$use_fontsets" = xyes; then
+  AC_DEFINE([USE_FONTSETS])
+else
+  :
+fi
+
+AC_MSG_CHECKING([byteorder])
+AC_TRY_RUN([
+int main()
+{
+  union { int i; char c[sizeof(int)]; } v;
+  v.i=0;
+  v.c[0]=1;
+  if(v.i==1) exit(0); else exit(1);
+  return 0;
+}
+], AC_DEFINE([LAME_ENDIAN],1,[Define this is your achitecture stores integers backwards in memory])
+AC_MSG_RESULT([backward]), AC_MSG_RESULT([normal]), AC_MSG_RESULT([no idea]))
+
+AC_SUBST(x_includes)
+AC_SUBST(x_libraries)
+AC_OUTPUT(Makefile libami/Makefile)
diff --git a/def_disk.info b/def_disk.info
new file mode 100644
index 0000000..cf5cfd0
Binary files /dev/null and b/def_disk.info differ
diff --git a/def_drawer.info b/def_drawer.info
new file mode 100644
index 0000000..3acd3b7
Binary files /dev/null and b/def_drawer.info differ
diff --git a/def_project.info b/def_project.info
new file mode 100644
index 0000000..2a38679
Binary files /dev/null and b/def_project.info differ
diff --git a/def_tool.info b/def_tool.info
new file mode 100644
index 0000000..c3bcd18
Binary files /dev/null and b/def_tool.info differ
diff --git a/diskobject.c b/diskobject.c
new file mode 100644
index 0000000..504c5a5
--- /dev/null
+++ b/diskobject.c
@@ -0,0 +1,199 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <string.h>
+
+#include "alloc.h"
+#include "drawinfo.h"
+#include "prefs.h"
+#include "screen.h"
+#include "libami.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+extern Display *dpy;
+extern char *progname;
+
+char *iconcolorname[256];
+int iconcolormask;
+
+static char *sysiconcolorname[]={
+  "#aaaaaa", "#000000", "#ffffff", "#6688bb",
+  "#ee4444", "#55dd55", "#0044dd", "#ee9e00"
+};
+
+static char *magicwbcolorname[]={
+  "#aaaaaa", "#000000", "#ffffff", "#6688bb",
+  "#999999", "#bbbbbb", "#bbaa99", "#ffbbaa"  
+};
+
+static char *schwartziconcolorname[]={
+  "#aaa0aa", "#000000", "#ffffff", "#5b78f5",
+  "#999099", "#bbb0bb", "#bbaa99", "#ffbbaa",
+  "#d922f1", "#915a46", "#3e3e41", "#6e6973",
+  "#ff1919", "#ffff00", "#727d92", "#00c800"
+};
+
+Pixmap image_to_pixmap_scr(Scrn *scr, struct Image *im, int width, int height,
+			   struct ColorStore *cs)
+{
+  return image_to_pixmap(dpy, scr->back, scr->gc,
+			 scr->dri.dri_Pens[BACKGROUNDPEN],
+			 scr->iconcolor, iconcolormask, im, width, height, cs);
+}
+
+void load_do(const char *filename, struct IconPixmaps *ip)
+{
+  struct DiskObject *dobj;
+#ifdef AMIGAOS
+  char fn[256];
+  strncpy(fn, prefs.icondir, sizeof(fn)-1);
+  fn[sizeof(fn)-1]='\0';
+  AddPart(fn,filename,sizeof(fn));
+#else
+  int rl=strlen(filename)+strlen(prefs.icondir)+2;
+#ifdef HAVE_ALLOCA
+  char *fn=alloca(rl);
+#else
+  char fn[1024];
+#endif
+  sprintf(fn, "%s/%s", prefs.icondir, filename);
+#endif
+  fn[strlen(fn)-5]=0;
+  if((dobj=GetDiskObject(fn))) {
+    ip->pm=image_to_pixmap_scr(scr, (struct Image *)dobj->do_Gadget.GadgetRender,
+			       dobj->do_Gadget.Width, dobj->do_Gadget.Height, &ip->cs);
+    ip->pm2=image_to_pixmap_scr(scr, (struct Image *)dobj->do_Gadget.SelectRender,
+				dobj->do_Gadget.Width, dobj->do_Gadget.Height, &ip->cs2);
+    FreeDiskObject(dobj);
+  } else ip->pm=ip->pm2=None;
+}
+
+void init_iconpalette()
+{
+  extern Status myXAllocNamedColor(Display *, Colormap, char *, XColor *, XColor *);
+  XColor scrp, xact;
+  char *name;
+  int i;
+
+  for(i=0; i<=iconcolormask; i++) {
+    if(!myXAllocNamedColor(dpy, scr->cmap, name = iconcolorname[i], &scrp, &xact)) {
+      fprintf(stderr, "%s: cannot allocate color %s\n", progname, name);
+      exit(1);
+    }
+    scr->iconcolor[i]=scrp.pixel;
+    scr->iconcolorsallocated=i+1;
+  }
+}
+
+void set_mwb_palette()
+{
+  iconcolormask=7;
+  memcpy(iconcolorname, magicwbcolorname, sizeof(magicwbcolorname));
+}
+
+void set_sys_palette()
+{
+  iconcolormask=7;
+  memcpy(iconcolorname, sysiconcolorname, sizeof(sysiconcolorname));
+}
+
+void set_schwartz_palette()
+{
+  iconcolormask=15;
+  memcpy(iconcolorname, schwartziconcolorname, sizeof(schwartziconcolorname));
+}
+
+#ifndef HAVE_STRDUP
+/* defined in gram.y */
+extern char *strdup(char *);
+#endif
+
+static int custom_palette_from_file(char *fn, int ignorenofile)
+{
+  FILE *file;
+  int rows, cols, pixels, pixel;
+  int format, mv;
+
+  if(!(file=fopen(fn, "r"))) {
+    if(!ignorenofile)
+      perror(fn);
+    return 0;
+  }
+
+  if(4!=fscanf(file, "P%d %d %d %d", &format, &cols, &rows, &mv) ||
+     (format!=3 && format!=6)) {
+    fprintf(stderr, "%s: bad magic number - not a ppm file\n", fn);
+    fclose(file);
+    return 0;
+  }
+  if(format==6)
+    getc(file);
+  pixels = rows*cols;
+  if(pixels>256)
+    pixels = 256;
+  for(pixel=0; pixel<pixels; ++pixel) {
+    unsigned int r, g, b;
+    char nam[16];
+    if(format==3)
+      fscanf(file, "%u %u %u", &r, &g, &b);
+    else {
+      r = getc(file);
+      g = getc(file);
+      b = getc(file);
+    }
+    if(mv==255)
+      sprintf(nam, "#%02x%02x%02x", r&0xff, g&0xff, b&0xff);
+    else if(mv==65536)
+      sprintf(nam, "#%04x%04x%04x", r&0xffff, g&0xffff, b&0xffff);
+    else if(mv<255)
+      sprintf(nam, "#%02x%02x%02x", (r*0xff/mv)&0xff,
+	      (g*0xff/mv)&0xff, (b*0xff/mv)&0xff);
+    else
+      sprintf(nam, "#%04x%04x%04x", (r*0xffff/mv)&0xffff,
+	      (g*0xffff/mv)&0xffff, (b*0xffff/mv)&0xffff);
+    iconcolorname[pixel] = strdup(nam);
+  }
+  fclose(file);
+  while(pixels&(pixels-1))
+    iconcolorname[pixels++]="black";
+  iconcolormask=pixels-1;
+  return 1;
+}
+
+void set_custom_palette(char *fn)
+{
+  if(*fn!='/') {
+    char *fn2;
+    int r;
+#ifdef HAVE_ALLOCA
+    fn2 = alloca(strlen(fn)+strlen(AMIWM_HOME)+2);
+#else
+    fn2 = malloc(strlen(fn)+strlen(AMIWM_HOME)+2);
+#endif
+    sprintf(fn2, "%s/%s", AMIWM_HOME, fn);
+    r=custom_palette_from_file(fn2, 1);
+#ifndef HAVE_ALLOCA
+    free(fn2);
+#endif
+    if(r)
+      return;
+  }
+  custom_palette_from_file(fn, 0);
+}
+
+char *get_current_icondir()
+{
+  return prefs.icondir;
+}
diff --git a/executecmd.c b/executecmd.c
new file mode 100644
index 0000000..f152723
--- /dev/null
+++ b/executecmd.c
@@ -0,0 +1,579 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#include <errno.h>
+#ifdef USE_FONTSETS
+#include <locale.h>
+#include <wchar.h>
+#endif
+
+#include "drawinfo.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#define MAX_CMD_CHARS 256
+#define VISIBLE_CMD_CHARS 35
+
+#define BOT_SPACE 4
+#define TEXT_SIDE 8
+#define BUT_SIDE 12
+#define TOP_SPACE 4
+#define INT_SPACE 7
+#define BUT_VSPACE 2
+#define BUT_HSPACE 8
+
+static const char ok_txt[]="Ok", cancel_txt[]="Cancel";
+static const char enter_txt[]="Enter Command and its Arguments:";
+static const char cmd_txt[]="Command:";
+
+static int selected=0, depressed=0, stractive=1;
+static Window button[3];
+static const char *buttxt[]={ NULL, ok_txt, cancel_txt };
+
+char cmdline[MAX_CMD_CHARS+1];
+int buf_len=0;
+int cur_pos=0;
+int left_pos=0;
+int cur_x=6;
+
+char *progname;
+
+Display *dpy;
+
+struct DrawInfo dri;
+
+Window root, mainwin, strwin;
+GC gc;
+
+int strgadw, strgadh, fh, mainw, mainh, butw;
+
+#ifdef USE_FONTSETS
+static XIM xim = (XIM) NULL;
+static XIC xic = (XIC) NULL;
+#endif
+
+int getchoice(Window w)
+{
+  int i;
+  for(i=1; i<3; i++)
+    if(button[i]==w)
+      return i;
+  return 0;
+}
+
+void refresh_button(Window w, const char *txt, int idx)
+{
+  int h=fh+2*BUT_VSPACE, l=strlen(txt);
+#ifdef USE_FONTSETS
+  int tw=XmbTextEscapement(dri.dri_FontSet, txt, l);
+#else
+  int tw=XTextWidth(dri.dri_Font, txt, l);
+#endif
+  XSetForeground(dpy, gc, dri.dri_Pens[TEXTPEN]);
+#ifdef USE_FONTSETS
+  XmbDrawString(dpy, w, dri.dri_FontSet, gc, (butw-tw)>>1,
+		dri.dri_Ascent+BUT_VSPACE, txt, l);
+#else
+  XDrawString(dpy, w, gc, (butw-tw)>>1,
+	      dri.dri_Ascent+BUT_VSPACE, txt, l);
+#endif
+  XSetForeground(dpy, gc, dri.dri_Pens[(selected==idx && depressed)?
+				     SHADOWPEN:SHINEPEN]);
+  XDrawLine(dpy, w, gc, 0, 0, butw-2, 0);
+  XDrawLine(dpy, w, gc, 0, 0, 0, h-2);
+  XSetForeground(dpy, gc, dri.dri_Pens[(selected==idx && depressed)?
+				     SHINEPEN:SHADOWPEN]);
+  XDrawLine(dpy, w, gc, 1, h-1, butw-1, h-1);
+  XDrawLine(dpy, w, gc, butw-1, 1, butw-1, h-1);  
+  XSetForeground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+  XDrawPoint(dpy, w, gc, butw-1, 0);
+  XDrawPoint(dpy, w, gc, 0, h-1);
+}
+
+void refresh_main(void)
+{
+  int w;
+
+  XSetForeground(dpy, gc, dri.dri_Pens[TEXTPEN]);
+#ifdef USE_FONTSETS
+  XmbDrawString(dpy, mainwin, dri.dri_FontSet, gc, TEXT_SIDE,
+		TOP_SPACE+dri.dri_Ascent, enter_txt, strlen(enter_txt));
+#else
+  XDrawString(dpy, mainwin, gc, TEXT_SIDE, TOP_SPACE+dri.dri_Ascent,
+	      enter_txt, strlen(enter_txt));
+#endif
+  XSetForeground(dpy, gc, dri.dri_Pens[HIGHLIGHTTEXTPEN]);
+#ifdef USE_FONTSETS
+  w=XmbTextEscapement(dri.dri_FontSet, cmd_txt, strlen(cmd_txt));
+  XmbDrawString(dpy, mainwin, dri.dri_FontSet, gc,
+		mainw-strgadw-w-TEXT_SIDE-BUT_SIDE,
+		TOP_SPACE+fh+INT_SPACE+dri.dri_Ascent,
+		cmd_txt, strlen(cmd_txt));
+#else
+  w=XTextWidth(dri.dri_Font, cmd_txt, strlen(cmd_txt));
+  XDrawString(dpy, mainwin, gc, mainw-strgadw-w-TEXT_SIDE-BUT_SIDE,
+	      TOP_SPACE+fh+INT_SPACE+dri.dri_Ascent,
+	      cmd_txt, strlen(cmd_txt));
+#endif
+}
+
+void refresh_str_text(void)
+{
+  int l, mx=6;
+  XSetForeground(dpy, gc, dri.dri_Pens[TEXTPEN]);
+  if(buf_len>left_pos) {
+#ifdef USE_FONTSETS
+    int w, c;
+    for(l=0; l<buf_len-left_pos; ) {
+      c=mbrlen(cmdline+left_pos+l, buf_len-left_pos-l, NULL);
+      w=6+XmbTextEscapement(dri.dri_FontSet, cmdline+left_pos, l+c);
+      if(w>strgadw-6)
+	break;
+      mx=w;
+      l+=c;
+    }
+    XmbDrawImageString(dpy, strwin, dri.dri_FontSet, gc, 6, 3+dri.dri_Ascent,
+		       cmdline+left_pos, l);
+#else
+    mx+=XTextWidth(dri.dri_Font, cmdline+left_pos, l=buf_len-left_pos);
+    while(mx>strgadw-6)
+      mx-=XTextWidth(dri.dri_Font, cmdline+left_pos+--l, 1);
+    XDrawImageString(dpy, strwin, gc, 6, 3+dri.dri_Ascent,
+		     cmdline+left_pos, l);
+#endif
+  }
+  XSetForeground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+  XFillRectangle(dpy, strwin, gc, mx, 3, strgadw-mx-6, fh);
+  if(stractive) {
+    if(cur_pos<buf_len) {
+      XSetBackground(dpy, gc, ~0);
+#ifdef USE_FONTSETS
+      l=mbrlen(cmdline+cur_pos, buf_len-cur_pos, NULL);
+      XmbDrawImageString(dpy, strwin, dri.dri_FontSet, gc, cur_x,
+			 3+dri.dri_Ascent, cmdline+cur_pos, l);
+#else
+      XDrawImageString(dpy, strwin, gc, cur_x, 3+dri.dri_Ascent,
+		       cmdline+cur_pos, 1);
+#endif
+      XSetBackground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+    } else {
+      XSetForeground(dpy, gc, ~0);
+#ifdef USE_FONTSETS
+      XFillRectangle(dpy, strwin, gc, cur_x, 3,
+		     XExtentsOfFontSet(dri.dri_FontSet)->
+		     max_logical_extent.width, fh);
+#else
+      XFillRectangle(dpy, strwin, gc, cur_x, 3,
+		     dri.dri_Font->max_bounds.width, fh);
+#endif
+    }
+  }
+}
+
+void refresh_str(void)
+{
+  refresh_str_text();
+  XSetForeground(dpy, gc, dri.dri_Pens[SHINEPEN]);
+  XDrawLine(dpy, strwin, gc, 0, strgadh-1, 0, 0);
+  XDrawLine(dpy, strwin, gc, 0, 0, strgadw-2, 0);
+  XDrawLine(dpy, strwin, gc, 3, strgadh-2, strgadw-4, strgadh-2);
+  XDrawLine(dpy, strwin, gc, strgadw-4, strgadh-2, strgadw-4, 2);
+  XDrawLine(dpy, strwin, gc, 1, 1, 1, strgadh-2);
+  XDrawLine(dpy, strwin, gc, strgadw-3, 1, strgadw-3, strgadh-2);
+  XSetForeground(dpy, gc, dri.dri_Pens[SHADOWPEN]);
+  XDrawLine(dpy, strwin, gc, 1, strgadh-1, strgadw-1, strgadh-1);
+  XDrawLine(dpy, strwin, gc, strgadw-1, strgadh-1, strgadw-1, 0);
+  XDrawLine(dpy, strwin, gc, 3, strgadh-3, 3, 1);
+  XDrawLine(dpy, strwin, gc, 3, 1, strgadw-4, 1);
+  XDrawLine(dpy, strwin, gc, 2, 1, 2, strgadh-2);
+  XDrawLine(dpy, strwin, gc, strgadw-2, 1, strgadw-2, strgadh-2);
+}
+
+void strkey(XKeyEvent *e)
+{
+  void endchoice(void);
+#ifdef USE_FONTSETS
+  Status stat;
+#else
+  static XComposeStatus stat;
+#endif
+  KeySym ks;
+  char buf[256];
+  int x, i, n;
+#ifndef USE_FONTSETS
+  n=XLookupString(e, buf, sizeof(buf), &ks, &stat);
+#else
+  n=XmbLookupString(xic, e, buf, sizeof(buf), &ks, &stat);
+  if(stat == XLookupKeySym || stat == XLookupBoth)
+#endif
+  switch(ks) {
+  case XK_Return:
+  case XK_Linefeed:
+    selected=1;
+    endchoice();
+    break;
+  case XK_Left:
+    if(cur_pos) {
+#ifdef USE_FONTSETS
+      int p=cur_pos;
+      int z;
+      while(p>0) {
+	--p;
+	if(((int)mbrlen(cmdline+p, cur_pos-p, NULL))>0) {
+	  cur_pos=p;
+	  break;
+	}
+      }
+#else
+      --cur_pos;
+#endif
+    }
+    break;
+  case XK_Right:
+    if(cur_pos<buf_len) {
+#ifdef USE_FONTSETS
+      int l=mbrlen(cmdline+cur_pos, buf_len-cur_pos, NULL);
+      if(l>0)
+	cur_pos+=l;
+#else
+      cur_pos++;
+#endif
+    }
+    break;
+  case XK_Begin:
+    cur_pos=0;
+    break;
+  case XK_End:
+    cur_pos=buf_len;
+    break;
+  case XK_Delete:
+    if(cur_pos<buf_len) {
+      int l=1;
+#ifdef USE_FONTSETS
+      l=mbrlen(cmdline+cur_pos, buf_len-cur_pos, NULL);
+      if(l<=0)
+	break;
+#endif
+      buf_len-=l;
+      for(x=cur_pos; x<buf_len; x++)
+	cmdline[x]=cmdline[x+l];
+      cmdline[x] = 0;
+    } else XBell(dpy, 100);
+    break;
+  case XK_BackSpace:
+    if(cur_pos>0) {
+      int l=1;
+#ifdef USE_FONTSETS
+      int p=cur_pos;
+      while(p>0) {
+	--p;
+	if(((int)mbrlen(cmdline+p, cur_pos-p, NULL))>0) {
+	  l=cur_pos-p;
+	  break;
+	}
+      }
+#endif
+      buf_len-=l;
+      for(x=(cur_pos-=l); x<buf_len; x++)
+	cmdline[x]=cmdline[x+l];
+      cmdline[x] = 0;
+    } else XBell(dpy, 100);
+    break;
+#ifdef USE_FONTSETS
+  default:
+    if(stat == XLookupBoth)
+      stat = XLookupChars;
+  }
+  if(stat == XLookupChars) {
+#else
+  default:
+#endif
+    for(i=0; i<n && buf_len<MAX_CMD_CHARS; i++) {
+      for(x=buf_len; x>cur_pos; --x)
+	cmdline[x]=cmdline[x-1];
+      cmdline[cur_pos++]=buf[i];
+      buf_len++;
+    }
+    if(i<n)
+      XBell(dpy, 100);
+  }
+  if(cur_pos<left_pos)
+    left_pos=cur_pos;
+  cur_x=6;
+#ifdef USE_FONTSETS
+  if(cur_pos>left_pos)
+    cur_x+=XmbTextEscapement(dri.dri_FontSet, cmdline+left_pos, cur_pos-left_pos);
+  if(cur_pos<buf_len) {
+    int l=mbrlen(cmdline+cur_pos, buf_len-cur_pos, NULL);
+    x=XmbTextEscapement(dri.dri_FontSet, cmdline+cur_pos, l);
+  } else
+    x=XExtentsOfFontSet(dri.dri_FontSet)->max_logical_extent.width;
+#else
+  if(cur_pos>left_pos)
+    cur_x+=XTextWidth(dri.dri_Font, cmdline+left_pos, cur_pos-left_pos);
+  if(cur_pos<buf_len)
+    x=XTextWidth(dri.dri_Font, cmdline+cur_pos, 1);
+  else
+    x=dri.dri_Font->max_bounds.width;
+#endif
+  if((x+=cur_x-(strgadw-6))>0) {
+    cur_x-=x;
+    while(x>0) {
+#ifdef USE_FONTSETS
+      int l=mbrlen(cmdline+left_pos, buf_len-left_pos, NULL);
+      x-=XmbTextEscapement(dri.dri_FontSet, cmdline+left_pos, l);
+      left_pos += l;
+#else
+      x-=XTextWidth(dri.dri_Font, cmdline+left_pos++, 1);
+#endif
+    }
+    cur_x+=x;
+  }
+  refresh_str_text();
+}
+
+void strbutton(XButtonEvent *e)
+{
+  int w, l=1;
+  stractive=1;
+  cur_pos=left_pos;
+  cur_x=6;
+  while(cur_x<e->x && cur_pos<buf_len) {
+#ifdef USE_FONTSETS
+    l=mbrlen(cmdline+cur_pos, buf_len-cur_pos, NULL);
+    if(l<=0)
+      break;
+    w=XmbTextEscapement(dri.dri_FontSet, cmdline+cur_pos, l);
+#else
+    w=XTextWidth(dri.dri_Font, cmdline+cur_pos, 1);
+#endif
+    if(cur_x+w>e->x)
+      break;
+    cur_x+=w;
+    cur_pos+=l;
+  }
+  refresh_str();
+}
+
+void toggle(int c)
+{
+  XSetWindowBackground(dpy, button[c], dri.dri_Pens[(depressed&&c==selected)?
+						  FILLPEN:BACKGROUNDPEN]);
+  XClearWindow(dpy, button[c]);
+  refresh_button(button[c], buttxt[c], c);
+}
+
+void abortchoice()
+{
+  if(depressed) {
+    depressed=0;
+    toggle(selected);
+  }
+  selected=0;
+}
+
+void endchoice()
+{
+  int c=selected;
+
+  abortchoice();
+  XCloseDisplay(dpy);
+  if(c==1)
+    system(cmdline);
+  exit(0);
+}
+
+int main(int argc, char *argv[])
+{
+  XWindowAttributes attr;
+  static XSizeHints size_hints;
+  static XTextProperty txtprop1, txtprop2;
+  Window ok, cancel;
+  int w2, c;
+#ifdef USE_FONTSETS
+  char *p;
+
+  setlocale(LC_CTYPE, "");
+#endif
+  progname=argv[0];
+  if(!(dpy = XOpenDisplay(NULL))) {
+    fprintf(stderr, "%s: cannot connect to X server %s\n", progname,
+	    XDisplayName(NULL));
+    exit(1);
+  }
+  root = RootWindow(dpy, DefaultScreen(dpy));
+  XGetWindowAttributes(dpy, root, &attr);
+  init_dri(&dri, dpy, root, attr.colormap, False);
+
+#ifdef USE_FONTSETS
+  strgadw=VISIBLE_CMD_CHARS*XExtentsOfFontSet(dri.dri_FontSet)->
+    max_logical_extent.width+12;
+#else
+  strgadw=VISIBLE_CMD_CHARS*dri.dri_Font->max_bounds.width+12;
+#endif
+  strgadh=(fh=dri.dri_Ascent+dri.dri_Descent)+6;
+
+#ifdef USE_FONTSETS
+  butw=XmbTextEscapement(dri.dri_FontSet, ok_txt, strlen(ok_txt))+2*BUT_HSPACE;
+  w2=XmbTextEscapement(dri.dri_FontSet, cancel_txt, strlen(cancel_txt))+2*BUT_HSPACE;
+#else
+  butw=XTextWidth(dri.dri_Font, ok_txt, strlen(ok_txt))+2*BUT_HSPACE;
+  w2=XTextWidth(dri.dri_Font, cancel_txt, strlen(cancel_txt))+2*BUT_HSPACE;
+#endif
+  if(w2>butw)
+    butw=w2;
+
+  mainw=2*(BUT_SIDE+butw)+BUT_SIDE;
+#ifdef USE_FONTSETS
+  w2=XmbTextEscapement(dri.dri_FontSet, enter_txt, strlen(enter_txt))+2*TEXT_SIDE;
+#else
+  w2=XTextWidth(dri.dri_Font, enter_txt, strlen(enter_txt))+2*TEXT_SIDE;
+#endif
+  if(w2>mainw)
+    mainw=w2;
+#ifdef USE_FONTSETS
+  w2=strgadw+XmbTextEscapement(dri.dri_FontSet, cmd_txt, strlen(cmd_txt))+
+    2*TEXT_SIDE+2*BUT_SIDE+butw;
+#else
+  w2=strgadw+XTextWidth(dri.dri_Font, cmd_txt, strlen(cmd_txt))+
+    2*TEXT_SIDE+2*BUT_SIDE+butw;
+#endif
+  if(w2>mainw)
+    mainw=w2;
+
+  mainh=3*fh+TOP_SPACE+BOT_SPACE+2*INT_SPACE+2*BUT_VSPACE;
+  
+  mainwin=XCreateSimpleWindow(dpy, root, 20, 20, mainw, mainh, 1,
+			      dri.dri_Pens[SHADOWPEN],
+			      dri.dri_Pens[BACKGROUNDPEN]);
+  strwin=XCreateSimpleWindow(dpy, mainwin, mainw-BUT_SIDE-strgadw,
+			     TOP_SPACE+fh+INT_SPACE-3,
+			     strgadw, strgadh, 0,
+			     dri.dri_Pens[SHADOWPEN],
+			     dri.dri_Pens[BACKGROUNDPEN]);
+  ok=XCreateSimpleWindow(dpy, mainwin, BUT_SIDE,
+			 mainh-BOT_SPACE-2*BUT_VSPACE-fh,
+			 butw, fh+2*BUT_VSPACE, 0,
+			 dri.dri_Pens[SHADOWPEN],
+			 dri.dri_Pens[BACKGROUNDPEN]);
+  cancel=XCreateSimpleWindow(dpy, mainwin, mainw-butw-BUT_SIDE,
+			     mainh-BOT_SPACE-2*BUT_VSPACE-fh,
+			     butw, fh+2*BUT_VSPACE, 0,
+			     dri.dri_Pens[SHADOWPEN],
+			     dri.dri_Pens[BACKGROUNDPEN]);
+  button[0]=None;
+  button[1]=ok;
+  button[2]=cancel;
+  XSelectInput(dpy, mainwin, ExposureMask|KeyPressMask|ButtonPressMask);
+  XSelectInput(dpy, strwin, ExposureMask|ButtonPressMask);
+  XSelectInput(dpy, ok, ExposureMask|ButtonPressMask|ButtonReleaseMask|
+		 EnterWindowMask|LeaveWindowMask);
+  XSelectInput(dpy, cancel, ExposureMask|ButtonPressMask|ButtonReleaseMask|
+		 EnterWindowMask|LeaveWindowMask);
+  gc=XCreateGC(dpy, mainwin, 0, NULL);
+  XSetBackground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+#ifndef USE_FONTSETS
+  XSetFont(dpy, gc, dri.dri_Font->fid);
+#endif
+
+#ifdef USE_FONTSETS
+  if ((p = XSetLocaleModifiers("@im=none")) != NULL && *p)
+    xim = XOpenIM(dpy, NULL, NULL, NULL);
+  if (!xim)
+    fprintf(stderr, "Failed to open input method.\n");
+  else {
+    xic = XCreateIC(xim,
+		    XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
+		    XNClientWindow, mainwin,
+		    XNFocusWindow, mainwin,
+		    NULL);
+    if (!xic)
+      fprintf(stderr, "Failed to create input context.\n");
+  }
+  if (!xic)
+    exit(1);
+#endif
+
+  size_hints.flags = PResizeInc;
+  txtprop1.value=(unsigned char *)"Execute a File";
+  txtprop2.value=(unsigned char *)"ExecuteCmd";
+  txtprop2.encoding=txtprop1.encoding=XA_STRING;
+  txtprop2.format=txtprop1.format=8;
+  txtprop1.nitems=strlen((char *)txtprop1.value);
+  txtprop2.nitems=strlen((char *)txtprop2.value);
+  XSetWMProperties(dpy, mainwin, &txtprop1, &txtprop2, argv, argc,
+		   &size_hints, NULL, NULL);
+  XMapSubwindows(dpy, mainwin);
+  XMapRaised(dpy, mainwin);
+  for(;;) {
+    XEvent event;
+    XNextEvent(dpy, &event);
+#ifdef USE_FONTSETS
+    if(!XFilterEvent(&event, mainwin))
+#endif
+    switch(event.type) {
+    case Expose:
+      if(!event.xexpose.count)
+	if(event.xexpose.window == mainwin)
+	  refresh_main();	
+	else if(event.xexpose.window == strwin)
+	  refresh_str();
+	else if(event.xexpose.window == ok)
+	  refresh_button(ok, ok_txt, 1);
+	else if(event.xexpose.window == cancel)
+	  refresh_button(cancel, cancel_txt, 2);
+    case LeaveNotify:
+      if(depressed && event.xcrossing.window==button[selected]) {
+	depressed=0;
+	toggle(selected);
+      }
+      break;
+    case EnterNotify:
+      if((!depressed) && selected && event.xcrossing.window==button[selected]) {
+	depressed=1;
+	toggle(selected);
+      }
+      break;
+    case ButtonPress:
+      if(event.xbutton.button==Button1) {
+	if(stractive && event.xbutton.window!=strwin) {
+	  stractive=0;
+	  refresh_str();
+	}
+	if((c=getchoice(event.xbutton.window))) {
+	  abortchoice();
+	  depressed=1;
+	  toggle(selected=c);
+	} else if(event.xbutton.window==strwin)
+	  strbutton(&event.xbutton);
+      }
+      break;
+    case ButtonRelease:
+      if(event.xbutton.button==Button1 && selected)
+	if(depressed)
+	  endchoice();
+	else
+	  abortchoice();
+      break;
+    case KeyPress:
+      if(stractive)
+	strkey(&event.xkey);
+    }
+  }
+}
diff --git a/frame.c b/frame.c
new file mode 100644
index 0000000..ddbdd4e
--- /dev/null
+++ b/frame.c
@@ -0,0 +1,591 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xresource.h>
+#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
+#include <X11/extensions/shape.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "drawinfo.h"
+#include "screen.h"
+#include "icon.h"
+#include "client.h"
+#include "icc.h"
+#include "prefs.h"
+#include "module.h"
+#include "libami.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#define mx(a,b) ((a)>(b)?(a):(b))
+
+extern Display *dpy;
+extern XContext client_context, screen_context;
+extern Cursor wm_curs;
+extern int shape_extn;
+extern void redrawmenubar(Window);
+void reshape_frame(Client *c);
+
+Window creategadget(Client *c, Window p, int x, int y, int w, int h)
+{
+  XSetWindowAttributes attr;
+  Window r;
+
+  attr.override_redirect=True;
+  attr.background_pixel=scr->dri.dri_Pens[BACKGROUNDPEN];
+  r=XCreateWindow(dpy, p, x, y, w, h, 0, CopyFromParent, InputOutput,
+		  CopyFromParent, CWOverrideRedirect|CWBackPixel, &attr);
+  XSelectInput(dpy, r, ExposureMask|ButtonPressMask|ButtonReleaseMask|
+	       EnterWindowMask|LeaveWindowMask);
+  XSaveContext(dpy, r, client_context, (XPointer)c);
+  return r;
+}
+
+void spread_top_gadgets(Client *c)
+{
+  int w=c->pwidth;
+  w-=23; XMoveWindow(dpy, c->depth, w, 0);
+  if(c->zoom) {
+    w-=23; XMoveWindow(dpy, c->zoom, w, 0);
+  }
+  if(c->iconify) {
+    w-=23; XMoveWindow(dpy, c->iconify, w, 0);
+  }
+  XResizeWindow(dpy, c->drag, c->dragw=mx(4, w-19), scr->bh);
+}
+
+void setclientborder(Client *c, int old, int new)
+{
+  int wc=0;
+  int x=c->x, y=c->y, oldpw=c->pwidth, oldph=c->pheight;
+  old&=(Psizeright|Psizebottom|Psizetrans);
+  new&=(Psizeright|Psizebottom|Psizetrans);
+  if(new!=old) {
+    if((new & Psizeright)&&!(old & Psizeright))
+      { c->pwidth+=14; wc++; }
+    else if((old & Psizeright)&&!(new & Psizeright))
+      { c->pwidth-=14; wc++; }
+    if((new & Psizebottom)&&!(old & Psizebottom))
+      c->pheight+=8;
+    else if((old & Psizebottom)&&!(new & Psizebottom))
+      c->pheight-=8;
+    XResizeWindow(dpy, c->parent, c->pwidth, c->pheight);
+    if(c->resize)
+      XMoveWindow(dpy, c->resize, c->pwidth-18, c->pheight-10);
+    if(wc) 
+      spread_top_gadgets(c);
+  }
+  c->proto = (c->proto&~(Psizeright|Psizebottom|Psizetrans)) | new;
+  c->framewidth=((new&Psizeright)?22:8);
+  c->frameheight=scr->bh+((new&Psizebottom)?10:2);
+  if(c->gravity==EastGravity || c->gravity==NorthEastGravity ||
+     c->gravity==SouthEastGravity)
+    x-=(c->pwidth-oldpw);
+  if(c->gravity==SouthGravity || c->gravity==SouthEastGravity ||
+     c->gravity==SouthWestGravity)
+    y-=(c->pheight-oldph);
+  if(x!=c->x || y!=c->y)
+    XMoveWindow(dpy, c->parent, c->x=x, c->y=y);
+}
+
+void resizeclientwindow(Client *c, int width, int height)
+{
+  if(width!=c->pwidth || height!=c->pheight) {
+    int old_width=c->pwidth;
+    XResizeWindow(dpy, c->parent, c->pwidth=width, c->pheight=height);
+    if(width!=old_width)
+      spread_top_gadgets(c);
+    if(c->resize)
+      XMoveWindow(dpy, c->resize, c->pwidth-18, c->pheight-10);
+    XResizeWindow(dpy, c->window, c->pwidth-c->framewidth, c->pheight-c->frameheight);
+    if(c->shaped)
+      reshape_frame(c);
+    sendconfig(c);
+  }
+}
+
+static int resizable(XSizeHints *xsh)
+{
+  int r=0;
+  if(xsh->width_inc) {
+    if(xsh->min_width+xsh->width_inc<=xsh->max_width)
+      r++;
+  }
+  if(xsh->height_inc) {
+    if(xsh->min_height+xsh->height_inc<=xsh->max_height)
+      r+=2;
+  }
+  return r;
+}
+
+extern unsigned int meta_mask;
+
+void reshape_frame(Client *c)
+{
+  XRectangle r;
+
+#ifdef HAVE_XSHAPE
+  if(!shape_extn)
+    return;
+
+  XShapeCombineShape(dpy, c->parent, ShapeBounding, 4, c->scr->bh, c->window,
+		     ShapeBounding, ShapeSet);
+
+  r.x = 0;
+  r.y = 0;
+  r.width = c->pwidth;
+  r.height = c->scr->bh;
+
+  XShapeCombineRectangles(dpy, c->parent, ShapeBounding,
+			  0, 0, &r, 1, ShapeUnion, Unsorted);
+
+  if(c->proto & Psizeright) {
+    r.x = c->pwidth-18;
+    r.y = 0;
+    r.width = 18;
+    r.height = c->pheight;
+    XShapeCombineRectangles(dpy, c->parent, ShapeBounding,
+			    0, 0, &r, 1, ShapeUnion, Unsorted);
+  }
+  if(c->proto & Psizebottom) {
+    r.x = 0;
+    r.y = c->pheight-10;
+    r.width = c->pwidth;
+    r.height = 10;
+    XShapeCombineRectangles(dpy, c->parent, ShapeBounding,
+			    0, 0, &r, 1, ShapeUnion, Unsorted);
+  }
+#endif
+}
+
+void redrawclient(Client *);
+
+void reparent(Client *c)
+{
+  XWindowAttributes attr;
+  XSetWindowAttributes attr2;
+  XTextProperty screen_prop;
+  Scrn *s=scr;
+  int cb;
+  Window leader;
+  Client *lc;
+  struct mcmd_keygrab *kg;
+  extern struct mcmd_keygrab *keygrabs;
+  char **cargv = NULL;
+  int cargc;
+
+  if(XGetTransientForHint(dpy, c->window, &leader) &&
+     !XFindContext(dpy, leader, client_context, (XPointer *)&lc))
+    c->scr = lc->scr;
+  else if(XGetTextProperty(dpy, c->window, &screen_prop, amiwm_screen)) {
+    do {
+      if(s->root == scr->root &&
+	 (!s->deftitle[screen_prop.nitems])&&!strncmp(s->deftitle,
+		      (char *)screen_prop.value, screen_prop.nitems))
+	break;
+      s=s->behind;
+    } while(s!=scr);
+    XFree(screen_prop.value);
+    c->scr=s;
+  } else if(XGetCommand(dpy, c->window, &cargv, &cargc)) {
+    XrmDatabase db = (XrmDatabase)NULL;
+    XrmValue value;
+    char *str_type;
+    static XrmOptionDescRec table [] = {
+      {"-xrm", NULL, XrmoptionResArg, (caddr_t) NULL},
+    };
+    XrmParseCommand(&db, table, 1, "amiwm", &cargc, cargv);
+    if(XrmGetResource(db, "amiwm.screen", "Amiwm.Screen",
+		      &str_type, &value) == True &&
+       value.size != 0) {
+      do {
+	if(s->root == scr->root &&
+	   (!s->deftitle[value.size])&&!strncmp(s->deftitle, value.addr,
+						value.size))
+	  break;
+	s=s->behind;
+      } while(s!=scr);
+      c->scr=s;
+    }
+    XrmDestroyDatabase (db);
+  }
+  scr=c->scr;
+  if(c->parent && c->parent != scr->root)
+    return;
+  getproto(c);
+  getwflags(c);
+  XAddToSaveSet(dpy, c->window);
+  XGetWindowAttributes(dpy, c->window, &attr);
+  c->colormap = attr.colormap;
+  c->old_bw = attr.border_width;
+  c->framewidth=8;
+  c->frameheight=scr->bh+2;
+  attr2.override_redirect=True;
+  grav_map_win_to_frame(c, attr.x, attr.y, &c->x, &c->y);
+  c->parent=XCreateWindow(dpy, scr->back, c->x, c->y,
+			  c->pwidth=attr.width+8, c->pheight=attr.height+2+scr->bh,
+			  0, CopyFromParent, InputOutput, CopyFromParent,
+			  CWOverrideRedirect, &attr2);
+  XSaveContext(dpy, c->parent, client_context, (XPointer)c);
+  XSaveContext(dpy, c->parent, screen_context, (XPointer)c->scr);
+  XSetWindowBackground(dpy, c->parent, scr->dri.dri_Pens[BACKGROUNDPEN]);
+  XSetWindowBorderWidth(dpy, c->window, 0);
+  XReparentWindow(dpy, c->window, c->parent, 4, scr->bh);
+  XSelectInput(dpy, c->window, EnterWindowMask | LeaveWindowMask |
+	       ColormapChangeMask | PropertyChangeMask |
+	       (c->module? SubstructureNotifyMask:0));
+#ifdef HAVE_XSHAPE
+  if(shape_extn)
+    XShapeSelectInput(dpy, c->window, ShapeNotifyMask);
+#endif
+  XSelectInput(dpy, c->parent, SubstructureRedirectMask |
+	       SubstructureNotifyMask | StructureNotifyMask | ExposureMask |
+	       EnterWindowMask | LeaveWindowMask | ButtonPressMask);
+  for(kg=keygrabs; kg; kg=kg->next)
+    XGrabKey(dpy, kg->keycode, kg->modifiers, c->window, False, GrabModeAsync,
+	     GrabModeAsync);
+  cb=(resizable(&c->sizehints)? prefs.sizeborder:0);
+  c->close=creategadget(c, c->parent, 0, 0, 19, scr->bh);
+  c->drag=creategadget(c, c->parent, 19, 0, 1, 1);
+  if(c->wflags&WF_NOICONIFY)
+    c->iconify=None;
+  else
+    c->iconify=creategadget(c, c->parent, 0, 0, 23, scr->bh);
+  if(cb)
+    c->zoom=creategadget(c, c->parent, 0, 0, 23, scr->bh);
+  c->depth=creategadget(c, c->parent, 0, 0, 23, scr->bh);
+  spread_top_gadgets(c);
+  setclientborder(c, 0, cb);
+  if(cb)
+    c->resize=creategadget(c, c->parent, c->pwidth-18, c->pheight-10, 18, 10);
+  c->shaped = 0;
+#ifdef HAVE_XSHAPE
+  if(shape_extn) {
+    int xbs, ybs, cShaped, xcs, ycs;
+    unsigned int wbs, hbs, wcs, hcs;
+    XShapeQueryExtents (dpy, c->window, &c->shaped, &xbs, &ybs, &wbs, &hbs,
+			&cShaped, &xcs, &ycs, &wcs, &hcs);
+    if(c->shaped)
+      reshape_frame(c);
+  }
+#endif
+  XMapSubwindows(dpy, c->parent);
+  sendconfig(c);
+  setstringprop(c->window, amiwm_screen, scr->deftitle);
+  if(prefs.focus == FOC_CLICKTOTYPE)
+    XGrabButton(dpy, Button1, AnyModifier, c->parent, True,
+		ButtonPressMask, GrabModeSync, GrabModeAsync, None, wm_curs);
+}
+
+void redraw(Client *c, Window w)
+{
+  if(w==c->parent) {
+    int x, y;
+    x=c->pwidth-((c->proto&Psizeright)?18:4);
+    y=c->pheight-((c->proto&Psizebottom)?10:2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, c->pwidth-1, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, c->pheight-1);
+    XDrawLine(dpy, w, scr->gc, 4, y, x, y);
+    XDrawLine(dpy, w, scr->gc, x, scr->bh, x, y);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 1, c->pheight-1, c->pwidth-1, c->pheight-1);
+    XDrawLine(dpy, w, scr->gc, c->pwidth-1, 1, c->pwidth-1, c->pheight-1);
+    XDrawLine(dpy, w, scr->gc, 3, scr->bh-1, 3, y);
+    XDrawLine(dpy, w, scr->gc, 3, scr->bh-1, x, scr->bh-1);
+  } else if(w==c->close) {
+    if(c->active) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+      XFillRectangle(dpy, w, scr->gc, 7, scr->h3, 4, scr->h7-scr->h3);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawRectangle(dpy, w, scr->gc, 7, scr->h3, 4, scr->h7-scr->h3);
+    if(c->clicked==w) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawLine(dpy, w, scr->gc, 0, 0, 18, 0);
+      XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-2);
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+      XDrawLine(dpy, w, scr->gc, 0, scr->bh-1, 18, scr->bh-1);
+      XDrawLine(dpy, w, scr->gc, 18, 1, 18, scr->bh-1);
+    } else {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+      XDrawLine(dpy, w, scr->gc, 0, 0, 18, 0);
+      XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-1);
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawLine(dpy, w, scr->gc, 1, scr->bh-1, 18, scr->bh-1);
+      XDrawLine(dpy, w, scr->gc, 18, 1, 18, scr->bh-1);    
+    }
+  } else if(w==c->drag) {
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->active?FILLTEXTPEN:TEXTPEN]);
+    XSetBackground(dpy, scr->gc, scr->dri.dri_Pens[c->active?FILLPEN:BACKGROUNDPEN]);
+#ifdef USE_FONTSETS
+    if(c->title)
+      XmbDrawImageString(dpy, w, scr->dri.dri_FontSet, scr->gc,
+			 11, 1+scr->dri.dri_Ascent,
+			 c->title, strlen(c->title));
+#else
+    if(c->title.value)
+      XDrawImageString(dpy, w, scr->gc, 11, 1+scr->dri.dri_Ascent,
+		       (char *)c->title.value, c->title.nitems);
+#endif
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, c->dragw-1, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, scr->bh-1, c->dragw-1, scr->bh-1);
+    XDrawLine(dpy, w, scr->gc, c->dragw-1, 1, c->dragw-1, scr->bh-1);
+  } else if(w==c->iconify) {
+    if(c->active) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+      XFillRectangle(dpy, w, scr->gc, 7, scr->h8-4, 4, 2);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawRectangle(dpy, w, scr->gc, 7, scr->h8-4, 4, 2);
+    if(c->clicked==w) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->active? FILLPEN:BACKGROUNDPEN]);
+      XDrawRectangle(dpy, w, scr->gc, 5, scr->h2, 12, scr->h8-scr->h2);
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawRectangle(dpy, w, scr->gc, 5, scr->h8-(scr->bh>11? 7:6), 9, (scr->bh>11? 7:6));
+    } else {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->active? FILLPEN:BACKGROUNDPEN]);
+      XDrawRectangle(dpy, w, scr->gc, 5, scr->h8-(scr->bh>11? 7:6), 9, (scr->bh>11? 7:6));
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawRectangle(dpy, w, scr->gc, 5, scr->h2, 12, scr->h8-scr->h2);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w?SHADOWPEN:SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 22, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w?SHINEPEN:SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, scr->bh-1, 22, scr->bh-1);
+    XDrawLine(dpy, w, scr->gc, 22, 0, 22, scr->bh-1);
+  } else if(w==c->zoom) {
+    if(c->active) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? SHINEPEN:FILLPEN]);
+      XFillRectangle(dpy, w, scr->gc, 5, scr->h2, 12, scr->h8-scr->h2);
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? FILLPEN:SHINEPEN]);
+      XFillRectangle(dpy, w, scr->gc, 6, scr->h2, 5, scr->h5-scr->h2);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawRectangle(dpy, w, scr->gc, 6, scr->h2, 5, scr->h5-scr->h2);
+    XDrawRectangle(dpy, w, scr->gc, 5, scr->h2, 7, scr->h5-scr->h2);
+    XDrawRectangle(dpy, w, scr->gc, 5, scr->h2, 12, scr->h8-scr->h2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? SHADOWPEN:SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 22, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? SHINEPEN:SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, scr->bh-1, 22, scr->bh-1);
+    XDrawLine(dpy, w, scr->gc, 22, 0, 22, scr->bh-1);
+  } else if(w==c->depth) {
+    if(c->active) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[BACKGROUNDPEN]);
+      XFillRectangle(dpy, w, scr->gc, 4, scr->h2, 10, scr->h6-scr->h2);
+    }
+    if(c->clicked!=w) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawRectangle(dpy, w, scr->gc, 4, scr->h2, 10, scr->h6-scr->h2);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->active?SHINEPEN:BACKGROUNDPEN]);
+    XFillRectangle(dpy, w, scr->gc, 8, scr->h4, 10, scr->h8-scr->h4);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawRectangle(dpy, w, scr->gc, 8, scr->h4, 10, scr->h8-scr->h4);
+    if(c->clicked==w)
+      XDrawRectangle(dpy, w, scr->gc, 4, scr->h2, 10, scr->h6-scr->h2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? SHADOWPEN:SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 22, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, scr->bh-2);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[c->clicked==w? SHINEPEN:SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, scr->bh-1, 22, scr->bh-1);
+    XDrawLine(dpy, w, scr->gc, 22, 0, 22, scr->bh-1);
+  } else if(w==c->resize) {
+    static XPoint points[]={{4,6},{13,2},{14,2},{14,7},{4,7}};
+    if(c->active) {
+      XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+      XFillPolygon(dpy, w, scr->gc, points, sizeof(points)/sizeof(points[0]), Convex, CoordModeOrigin);
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawLines(dpy, w, scr->gc, points, sizeof(points)/sizeof(points[0]), CoordModeOrigin);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 16, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, 8);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 9, 17, 9);
+    XDrawLine(dpy, w, scr->gc, 17, 0, 17, 9);
+  }
+}
+
+void redrawclient(Client *c)
+{
+  unsigned long bgpix;
+
+  scr=c->scr;
+  if((!c->parent) || c->parent == scr->root)
+    return;
+  bgpix=scr->dri.dri_Pens[c->active?FILLPEN:BACKGROUNDPEN];
+  XSetWindowBackground(dpy, c->parent, bgpix);
+  XSetWindowBackground(dpy, c->close, bgpix);
+  XSetWindowBackground(dpy, c->drag, bgpix);
+  if(c->iconify)
+    XSetWindowBackground(dpy, c->iconify, bgpix);
+  if(c->zoom)
+    XSetWindowBackground(dpy, c->zoom, bgpix);
+  XSetWindowBackground(dpy, c->depth, bgpix);
+  if(c->resize)
+    XSetWindowBackground(dpy, c->resize, bgpix);
+  XClearWindow(dpy, c->parent);
+  XClearWindow(dpy, c->close);
+  XClearWindow(dpy, c->drag);
+  if(c->iconify)
+    XClearWindow(dpy, c->iconify);
+  if(c->zoom)
+    XClearWindow(dpy, c->zoom);
+  XClearWindow(dpy, c->depth);
+  if(c->resize)
+    XClearWindow(dpy, c->resize);
+  redraw(c, c->parent);
+  redraw(c, c->close);
+  redraw(c, c->drag);
+  if(c->iconify)
+    redraw(c, c->iconify);
+  if(c->zoom)
+    redraw(c, c->zoom);
+  redraw(c, c->depth);
+  if(c->resize)
+    redraw(c, c->resize);
+}
+
+extern Client *clickclient;
+extern Window clickwindow;
+extern Scrn *mbdclick, *mbdscr;
+
+void clickenter()
+{
+  if((scr=mbdscr)&& clickwindow == scr->menubardepth) {
+    mbdclick = scr;
+    redrawmenubar(scr->menubardepth);
+  } else {
+    scr = clickclient->scr;
+    redraw(clickclient, clickclient->clicked=clickwindow);
+  }
+}
+
+void clickleave()
+{
+  if((scr=mbdscr)&& clickwindow == scr->menubardepth) {
+    mbdclick = NULL;
+    redrawmenubar(scr->menubardepth);
+  } else {
+    scr = clickclient->scr;
+    clickclient->clicked=None;
+    redraw(clickclient, clickwindow);
+  }
+}
+
+void gadgetclicked(Client *c, Window w, XEvent *e)
+{
+  scr=c->scr;
+  redraw(c, clickwindow=(clickclient=c)->clicked=w);
+}
+
+void gadgetaborted(Client *c)
+{
+  Window w;
+  scr=c->scr;
+  if((w=c->clicked)) {
+    c->clicked=None;
+    redraw(c, w);
+  }
+  clickwindow=None;
+  clickclient=NULL;
+}
+
+static Client *topmostmappedclient(Window *children, unsigned int nchildren)
+{
+  int n;
+  Client *c;
+  for(n=nchildren-1; n>=0; --n)
+    if((!XFindContext(dpy, children[n], client_context, (XPointer*)&c)) &&
+       (children[n]==c->parent || children[n]==c->window) &&
+       c->state==NormalState)
+      return c;
+  return NULL;
+}
+
+static Client *bottommostmappedclient(Window *children, unsigned int nchildren)
+{
+  int n;
+  Client *c;
+  for(n=0; n<nchildren; n++)
+    if((!XFindContext(dpy, children[n], client_context, (XPointer*)&c)) &&
+       children[n]==c->parent && c->state==NormalState)
+      return c;
+  return NULL;
+}
+
+void raiselowerclient(Client *c, int place)
+{
+  Window r,p,*children;
+  unsigned int nchildren;
+  if(place!=PlaceOnTop &&
+     XQueryTree(dpy, scr->back, &r, &p, &children, &nchildren)) {
+    if(place==PlaceOnBottom || topmostmappedclient(children, nchildren)==c) {
+      Client *c2 = bottommostmappedclient(children, nchildren);
+      if(c2 != NULL && c2 != c) {
+	Window ws[2];
+	ws[0]=c2->parent;
+	ws[1]=c->parent;
+	XRestackWindows(dpy, ws, 2);
+      } else if(place!=PlaceOnBottom)
+	XRaiseWindow(dpy, c->parent);
+    } else
+      XRaiseWindow(dpy, c->parent);
+    if(children) XFree(children);
+  } else XRaiseWindow(dpy, c->parent);
+}
+
+void gadgetunclicked(Client *c, XEvent *e)
+{
+  extern void adjusticon(Icon *);
+  Window w;
+  scr=c->scr;
+  if((w=c->clicked)) {
+    c->clicked=None;
+    redraw(c, w);
+    if(w==c->close) {
+      if((c->proto & Pdelete)&&!(e->xbutton.state&ShiftMask))
+	sendcmessage(c->window, wm_protocols, wm_delete);
+      else
+	XKillClient(dpy, c->window);
+    } else if(w==c->depth)
+      raiselowerclient(c, -1);
+    else if(w==c->zoom) {
+      XWindowAttributes xwa;
+      XGetWindowAttributes(dpy, c->parent, &xwa);
+      XMoveWindow(dpy, c->parent, c->x=c->zoomx, c->y=c->zoomy);
+      resizeclientwindow(c, c->zoomw+c->framewidth, c->zoomh+c->frameheight);
+      c->zoomx=xwa.x;
+      c->zoomy=xwa.y;
+      c->zoomw=xwa.width-c->framewidth;
+      c->zoomh=xwa.height-c->frameheight;
+/*      XWarpPointer(dpy, None, c->zoom, 0, 0, 0, 0, 23/2, scr->h5);  */
+      sendconfig(c);
+    } else if(w==c->iconify) {
+      if(!(c->icon))
+	createicon(c);
+      XUnmapWindow(dpy, c->parent);
+      /*      XUnmapWindow(dpy, c->window); */
+      adjusticon(c->icon);
+      XMapWindow(dpy, c->icon->window);
+      if(c->icon->labelwidth)
+	XMapWindow(dpy, c->icon->labelwin);
+      c->icon->mapped=1;
+      setclientstate(c, IconicState);
+    }
+  }
+  clickwindow=None;
+  clickclient=NULL;
+}
diff --git a/gnome.c b/gnome.c
new file mode 100644
index 0000000..e682df4
--- /dev/null
+++ b/gnome.c
@@ -0,0 +1,184 @@
+/* GNOME Window Manager Compliance support for amiwm
+   by Peter Bortas february 2000 */
+
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <X11/Xproto.h>
+#include <X11/Xatom.h>
+
+#include <X11/Xutil.h>
+
+
+extern void gnome_setup()
+{
+  /* Section 1 - Detection of a GNOME compliant Window Manager
+
+     There is a single unambiguous way to detect if there currently is
+     a GNOME compliant Window Manager running. It is the job of the
+     Window Manager to set up a few things to make this
+     possible. Using the following method it is also possible for
+     applications to detect compliance by receiving an event when the
+     Window Manager exits.
+
+     To do this the Window Manager should create a Window, that is a
+     child of the root window. There is no need to map it, just create
+     it. The Window Manager may reuse ANY window it has for this
+     purpose - even if it is mapped, just as long as the window is
+     never destroyed while the Window Manager is running.
+
+     Once the Window is created the Window Manager should set a
+     property on the root window of the name _WIN_SUPPORTING_WM_CHECK,
+     and type CARDINAL. The atom's data would be a CARDINAL that is
+     the Window ID of the window that was created above. The window
+     that was created would ALSO have this property set on it with the
+     same values and type.*/
+
+  Display            *disp;
+  Window              root_window;
+  Atom                atom_set;
+  CARD32              val;
+  Window              win;
+
+  Atom                list[10];
+
+  atom_set = XInternAtom(disp, "_WIN_SUPPORTING_WM_CHECK", False);
+  win = XCreateSimpleWindow(disp, root_window, -200, -200, 5, 5, 0, 0, 0);
+  val = win;
+  XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32, 
+		  PropModeReplace, (unsigned char *)&val, 1);
+  XChangeProperty(disp, win, atom_set, XA_CARDINAL, 32, PropModeReplace,
+		  (unsigned char *)&val, 1); 
+
+  /* Section 2 - Listing GNOME Window Manager Compliance
+
+     It is important to list which parts of GNOME Window Manager
+     compliance are supported. This is done fairly easily by doing the
+     following:
+
+     Create a property on the root window of the atom name
+     _WIN_PROTOCOLS. This property contains a list(array)of atoms that
+     are all the properties the Window Manager supports. These atoms
+     are any number of the following:
+
+     _WIN_LAYER 
+     _WIN_STATE 
+     _WIN_HINTS 
+     _WIN_APP_STATE 
+     _WIN_EXPANDED_SIZE 
+     _WIN_ICONS 
+     _WIN_WORKSPACE 
+     _WIN_WORKSPACE_COUNT 
+     _WIN_WORKSPACE_NAMES 
+     _WIN_CLIENT_LIST
+
+     If you list one of these properties then you support it and
+     applications can expect information provided by, or accepted by
+     the Window Manager to work. */
+
+  atom_set = XInternAtom(disp, "_WIN_PROTOCOLS", False);
+  list[0] = XInternAtom(disp, "_WIN_LAYER", False);
+  list[1] = XInternAtom(disp, "_WIN_STATE", False);
+  list[2] = XInternAtom(disp, "_WIN_HINTS", False);
+  list[3] = XInternAtom(disp, "_WIN_APP_STATE", False);
+  list[4] = XInternAtom(disp, "_WIN_EXPANDED_SIZE", False);
+  list[5] = XInternAtom(disp, "_WIN_ICONS", False);
+  list[6] = XInternAtom(disp, "_WIN_WORKSPACE", False);
+  list[7] = XInternAtom(disp, "_WIN_WORKSPACE_COUNT", False);
+  list[8] = XInternAtom(disp, "_WIN_WORKSPACE_NAMES", False);
+  list[9] = XInternAtom(disp, "_WIN_CLIENT_LIST", False);
+  XChangeProperty(disp, root_window, atom_set, XA_ATOM, 32, PropModeReplace,
+		  (unsigned char *)list, 10);  
+}
+
+extern void gnome_managed_clients()
+{
+  /* Section 3 - Providing Shortcuts Managed Clients
+
+     As an aide in having external applications be able to list and
+     access clients being managed by the Window Manager, a property
+     should be set on the root window of the name _WIN_CLIENT_LIST
+     which is an array of type CARDINAL. Each entry is the Window ID
+     of a managed client. If the list of managed clients changes,
+     clients are added or deleted, this list should be updated. */
+
+  Display            *disp;
+  Window              root_window;
+  Atom                atom_set;
+  Window             *wl;
+  int                 num;
+  
+  fprintf(stderr, "FIXME: snome_managed_clients is a stub\n");
+
+  atom_set = XInternAtom(disp, "_WIN_CLIENT_LIST", False);
+  num = 0;  /* FIXME: number of clients goes here */
+  wl = malloc(sizeof(Window) * num);
+  /* FIXME: Fill in array of window ID's */
+  XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32, 
+		  PropModeReplace, (unsigned char *)wl, num);
+  if (wl)
+    free(wl);
+}
+
+extern void gnome_multiple_desktops()
+{
+  /* Section 3 - Providing Multiple/Virtual Desktop Information.
+
+     If your Window Manager supports the concept of Multiple/Virtual
+     Desktops or Workspaces then you will definitely want to include
+     it. This involves your Window Manager setting several properties
+     on the root window.
+
+     First you should advertise how many Desktops your Window Manager
+     supports. This is done by setting a property on the root window
+     with the atom name _WIN_WORKSPACE_COUNT of type CARDINAL. The
+     properties data is a 32-bit integer that is the number of
+     Desktops your Window Manager currently supports. If you can add
+     and delete desktops while running, you may change this property
+     and its value whenever required. You should also set a property
+     of the atom _WIN_WORKSPACE of type CARDINAL that contains the
+     number of the currently active desktop (which is a number between
+     0 and the number advertised by _WIN_WORKSPACE_COUNT -
+     1). Whenever the active desktop changes, change this property.
+
+     Lastly you should set a property that is a list of strings called
+     _WIN_WORKSPACE_NAMES that contains names for the desktops (the
+     first string is the name of the first desktop, the second string
+     is the second desktop, etc.). This will allow applications toq
+     know what the name of the desktop is too, possibly to display it. */
+
+  Display            *disp;
+  Window              root_window;
+  Atom                atom_set;
+  XTextProperty       text;
+  int                 i, current_desk, number_of_desks;
+  char              **names, s[1024];
+  CARD32              val;
+  
+  /* FIXME: set current_desk, number_of_desks  names */
+
+  atom_set = XInternAtom(disp, "_WIN_WORKSPACE", False);
+  val = (CARD32) current_desk;
+  XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32, 
+		  PropModeReplace, (unsigned char *)&val, 1);
+  atom_set = XInternAtom(disp, "_WIN_WORKSPACE_COUNT", False);
+
+  val = (CARD32) number_of_desks;
+  XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32, 
+		  PropModeReplace, (unsigned char *)&val, 1);
+  atom_set = XInternAtom(disp, "_WIN_WORKSPACE_NAMES", False);
+  names = malloc(sizeof(char *) * number_of_desks);
+  for (i = 0; i < number_of_desks; i++)
+  {
+    snprintf(s, sizeof(s), "Desktop %i", i);
+    names[i] = malloc(strlen(s) + 1);
+    strcpy(names[i], s);
+  }
+  if (XStringListToTextProperty(names, mode.numdesktops,  ))
+  {
+    XSetTextProperty(disp, root_window, &val, atom_set);
+    XFree(text.value);
+  }
+  for (i = 0; i < number_of_desks; i++)
+    free(names[i]);
+  free(names);
+}
diff --git a/gram.c b/gram.c
new file mode 100644
index 0000000..8cf2612
--- /dev/null
+++ b/gram.c
@@ -0,0 +1,2101 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "gram.y" /* yacc.c:339  */
+
+#include <X11/Xlib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "prefs.h"
+#include "drawinfo.h"
+#include "screen.h"
+#include "icc.h"
+#include "style.h"
+extern void set_sys_palette(void);
+extern void set_mwb_palette(void);
+extern void set_schwartz_palette(void);
+extern void set_custom_palette(char *fn);
+extern void add_toolitem(char *, char *, char *, int);
+extern Scrn *openscreen(char *, Window);
+extern void create_module(Scrn *, char *, char *);
+extern char *default_colors[NUMDRIPENS];
+extern char *default_screenfont, *label_font_name;
+extern Display *dpy;
+#ifndef HAVE_ALLOCA
+#define alloca malloc
+#endif
+#ifndef HAVE_STRDUP
+char *strdup(s) char *s;
+{
+  char *ptr=(char *)malloc(strlen(s)+1);
+  if(ptr) strcpy(ptr, s);
+  return ptr;
+}
+#endif
+
+static void append_to(char **x, char *y)
+{
+  if(*x==NULL)
+    *x=y;
+  else {
+    char *t = malloc(strlen(y)+strlen(*x)+2);
+    sprintf(t, "%s\n%s", *x, y);
+    free(*x);
+    free(y);
+    *x=t;
+  }
+}
+
+static int ti_level=0;
+
+#line 114 "y.tab.c" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "y.tab.h".  */
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    ERRORTOKEN = 258,
+    LEFTBRACE = 259,
+    RIGHTBRACE = 260,
+    YES = 261,
+    NO = 262,
+    RIGHT = 263,
+    BOTTOM = 264,
+    BOTH = 265,
+    NONE = 266,
+    MAGICWB = 267,
+    SYSTEM = 268,
+    SCHWARTZ = 269,
+    ALWAYS = 270,
+    AUTO = 271,
+    MANUAL = 272,
+    SEPARATOR = 273,
+    T_DETAILPEN = 274,
+    T_BLOCKPEN = 275,
+    T_TEXTPEN = 276,
+    T_SHINEPEN = 277,
+    T_SHADOWPEN = 278,
+    T_FILLPEN = 279,
+    T_FILLTEXTPEN = 280,
+    T_BACKGROUNDPEN = 281,
+    T_HIGHLIGHTTEXTPEN = 282,
+    T_BARDETAILPEN = 283,
+    T_BARBLOCKPEN = 284,
+    T_BARTRIMPEN = 285,
+    FASTQUIT = 286,
+    SIZEBORDER = 287,
+    DEFAULTICON = 288,
+    ICONDIR = 289,
+    ICONPALETTE = 290,
+    SCREENFONT = 291,
+    ICONFONT = 292,
+    TOOLITEM = 293,
+    FORCEMOVE = 294,
+    SCREEN = 295,
+    MODULE = 296,
+    MODULEPATH = 297,
+    INTERSCREENGAP = 298,
+    AUTORAISE = 299,
+    FOCUS = 300,
+    FOLLOWMOUSE = 301,
+    CLICKTOTYPE = 302,
+    SLOPPY = 303,
+    CUSTOMICONSONLY = 304,
+    TITLEBARCLOCK = 305,
+    TITLECLOCKFORMAT = 306,
+    OPAQUEMOVE = 307,
+    OPAQUERESIZE = 308,
+    SCREENMENU = 309,
+    STYLE = 310,
+    CLASS = 311,
+    TITLE = 312,
+    ICONTITLE = 313,
+    ICON = 314,
+    SHORTLABELICONS = 315,
+    STRING = 316,
+    NUMBER = 317
+  };
+#endif
+/* Tokens.  */
+#define ERRORTOKEN 258
+#define LEFTBRACE 259
+#define RIGHTBRACE 260
+#define YES 261
+#define NO 262
+#define RIGHT 263
+#define BOTTOM 264
+#define BOTH 265
+#define NONE 266
+#define MAGICWB 267
+#define SYSTEM 268
+#define SCHWARTZ 269
+#define ALWAYS 270
+#define AUTO 271
+#define MANUAL 272
+#define SEPARATOR 273
+#define T_DETAILPEN 274
+#define T_BLOCKPEN 275
+#define T_TEXTPEN 276
+#define T_SHINEPEN 277
+#define T_SHADOWPEN 278
+#define T_FILLPEN 279
+#define T_FILLTEXTPEN 280
+#define T_BACKGROUNDPEN 281
+#define T_HIGHLIGHTTEXTPEN 282
+#define T_BARDETAILPEN 283
+#define T_BARBLOCKPEN 284
+#define T_BARTRIMPEN 285
+#define FASTQUIT 286
+#define SIZEBORDER 287
+#define DEFAULTICON 288
+#define ICONDIR 289
+#define ICONPALETTE 290
+#define SCREENFONT 291
+#define ICONFONT 292
+#define TOOLITEM 293
+#define FORCEMOVE 294
+#define SCREEN 295
+#define MODULE 296
+#define MODULEPATH 297
+#define INTERSCREENGAP 298
+#define AUTORAISE 299
+#define FOCUS 300
+#define FOLLOWMOUSE 301
+#define CLICKTOTYPE 302
+#define SLOPPY 303
+#define CUSTOMICONSONLY 304
+#define TITLEBARCLOCK 305
+#define TITLECLOCKFORMAT 306
+#define OPAQUEMOVE 307
+#define OPAQUERESIZE 308
+#define SCREENMENU 309
+#define STYLE 310
+#define CLASS 311
+#define TITLE 312
+#define ICONTITLE 313
+#define ICON 314
+#define SHORTLABELICONS 315
+#define STRING 316
+#define NUMBER 317
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 50 "gram.y" /* yacc.c:355  */
+
+    int num;
+    char *ptr;
+
+#line 283 "y.tab.c" /* yacc.c:355  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 300 "y.tab.c" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  3
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   126
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  63
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  16
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  75
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  111
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   317
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,    81,    81,    84,    85,    88,    89,    90,    91,    92,
+      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
+     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
+     113,   114,   115,   116,   117,   120,   121,   124,   127,   128,
+     131,   132,   133,   136,   149,   150,   153,   154,   155,   156,
+     159,   162,   163,   166,   167,   168,   169,   170,   173,   174,
+     175,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   192,   193,   194
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 0
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "ERRORTOKEN", "LEFTBRACE", "RIGHTBRACE",
+  "YES", "NO", "RIGHT", "BOTTOM", "BOTH", "NONE", "MAGICWB", "SYSTEM",
+  "SCHWARTZ", "ALWAYS", "AUTO", "MANUAL", "SEPARATOR", "T_DETAILPEN",
+  "T_BLOCKPEN", "T_TEXTPEN", "T_SHINEPEN", "T_SHADOWPEN", "T_FILLPEN",
+  "T_FILLTEXTPEN", "T_BACKGROUNDPEN", "T_HIGHLIGHTTEXTPEN",
+  "T_BARDETAILPEN", "T_BARBLOCKPEN", "T_BARTRIMPEN", "FASTQUIT",
+  "SIZEBORDER", "DEFAULTICON", "ICONDIR", "ICONPALETTE", "SCREENFONT",
+  "ICONFONT", "TOOLITEM", "FORCEMOVE", "SCREEN", "MODULE", "MODULEPATH",
+  "INTERSCREENGAP", "AUTORAISE", "FOCUS", "FOLLOWMOUSE", "CLICKTOTYPE",
+  "SLOPPY", "CUSTOMICONSONLY", "TITLEBARCLOCK", "TITLECLOCKFORMAT",
+  "OPAQUEMOVE", "OPAQUERESIZE", "SCREENMENU", "STYLE", "CLASS", "TITLE",
+  "ICONTITLE", "ICON", "SHORTLABELICONS", "STRING", "NUMBER", "$accept",
+  "amiwmrc", "stmts", "stmt", "toolsubmenu", "toolitems", "toolitem",
+  "stylespec", "styleitems", "styleitem", "string", "truth", "sizeborder",
+  "focuspolicy", "dri_pen", "forcemove_policy", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
+     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+     315,   316,   317
+};
+# endif
+
+#define YYPACT_NINF -46
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-46)))
+
+#define YYTABLE_NINF -3
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int8 yypact[] =
+{
+     -46,    14,    66,   -46,   -46,   -46,   -46,   -46,   -46,   -46,
+     -46,   -46,   -46,   -46,   -46,   -46,   -46,    33,    24,   -45,
+     -45,    -1,   -45,   -45,   -12,     3,   -20,   -45,   -45,   -40,
+      33,   -10,    33,    33,   -17,    33,    33,    33,    25,    33,
+     -46,   -46,   -46,   -46,   -45,   -46,   -46,   -46,   -46,   -46,
+     -46,   -46,   -46,   -46,   -46,   -46,   -46,   -46,   -46,   -46,
+     -46,   -46,   -46,   -46,    -2,   -46,   -46,   -46,   -46,   -45,
+     -46,   -15,   -46,   -46,   -46,   -46,   -46,   -46,   -46,   -46,
+     -46,   -45,   -46,   -46,   -46,   -46,   -46,   -46,     5,    12,
+     -46,   -46,   -45,   -46,   -46,   -46,   -46,   -12,   -46,   -46,
+     -45,   -45,   -45,   -45,   -46,   -46,   -45,   -46,   -46,   -46,
+     -46
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       4,     0,     0,     1,     5,    61,    62,    63,    64,    65,
+      66,    67,    68,    69,    70,    71,    72,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       3,    39,     6,    45,     0,    51,    52,     8,    57,    53,
+      54,    55,    56,     9,    50,    10,    11,    13,    12,    14,
+      15,    17,    18,    42,     0,    73,    74,    75,    19,     0,
+      20,    24,    22,    25,    26,    58,    60,    59,    29,    30,
+      32,     0,    33,    27,    28,    35,    43,    31,     0,     0,
+      16,    37,    40,    21,    23,    34,     7,     0,    38,    36,
+       0,     0,     0,     0,    44,    41,     0,    46,    47,    48,
+      49
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+     -46,   -46,   -46,   -46,   -46,   -46,   -41,   -46,   -46,   -46,
+     -19,    -9,   -46,   -46,   -46,   -46
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,     1,     2,    40,    41,    88,    42,    43,    89,   104,
+      92,    47,    53,    78,    44,    68
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_int8 yytable[] =
+{
+      55,    56,    91,    61,    62,    64,    63,    70,    71,    72,
+      96,    57,    58,    59,     3,    82,    54,    99,    65,    66,
+      67,    74,    73,    79,    80,    90,    83,    84,    85,    86,
+      87,    48,    49,    50,    51,    52,    75,    76,    77,    45,
+      46,    54,    69,    97,    54,    81,    94,    98,     0,    54,
+      93,     0,     0,     0,     0,     0,     0,     0,     0,    54,
+      60,     0,    95,     0,     0,     0,    -2,     4,   100,   101,
+     102,   103,     0,   105,     0,     0,     0,     0,   106,     0,
+       0,   107,   108,   109,   110,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,     0,     0,     0,    32,    33,    34,    35,    36,
+      37,    38,     0,     0,     0,     0,    39
+};
+
+static const yytype_int8 yycheck[] =
+{
+      19,    20,     4,    22,    23,    24,    18,    26,    27,    28,
+       5,    12,    13,    14,     0,    34,    61,     5,    15,    16,
+      17,    30,    62,    32,    33,    44,    35,    36,    37,     4,
+      39,     7,     8,     9,    10,    11,    46,    47,    48,     6,
+       7,    61,    62,    38,    61,    62,    61,    88,    -1,    61,
+      69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    61,
+      61,    -1,    81,    -1,    -1,    -1,     0,     1,    56,    57,
+      58,    59,    -1,    92,    -1,    -1,    -1,    -1,    97,    -1,
+      -1,   100,   101,   102,   103,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    -1,    -1,    -1,    49,    50,    51,    52,    53,
+      54,    55,    -1,    -1,    -1,    -1,    60
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,    64,    65,     0,     1,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    49,    50,    51,    52,    53,    54,    55,    60,
+      66,    67,    69,    70,    77,     6,     7,    74,     7,     8,
+       9,    10,    11,    75,    61,    73,    73,    12,    13,    14,
+      61,    73,    73,    18,    73,    15,    16,    17,    78,    62,
+      73,    73,    73,    62,    74,    46,    47,    48,    76,    74,
+      74,    62,    73,    74,    74,    74,     4,    74,    68,    71,
+      73,     4,    73,    73,    61,    73,     5,    38,    69,     5,
+      56,    57,    58,    59,    72,    73,    73,    73,    73,    73,
+      73
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    63,    64,    65,    65,    66,    66,    66,    66,    66,
+      66,    66,    66,    66,    66,    66,    66,    66,    66,    66,
+      66,    66,    66,    66,    66,    66,    66,    66,    66,    66,
+      66,    66,    66,    66,    66,    66,    66,    67,    68,    68,
+      69,    69,    69,    70,    71,    71,    72,    72,    72,    72,
+      73,    74,    74,    75,    75,    75,    75,    75,    76,    76,
+      76,    77,    77,    77,    77,    77,    77,    77,    77,    77,
+      77,    77,    77,    78,    78,    78
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     2,     0,     1,     1,     3,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     3,     2,     3,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     3,     2,     3,     3,     2,     0,
+       3,     4,     2,     2,     2,     0,     2,     2,     2,     2,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              );
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+{
+  YYUSE (yyvaluep);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/* The lookahead symbol.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (void)
+{
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex ();
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 7:
+#line 90 "gram.y" /* yacc.c:1646  */
+    { ti_level=0; }
+#line 1470 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 91 "gram.y" /* yacc.c:1646  */
+    { prefs.fastquit = (yyvsp[0].num); }
+#line 1476 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 92 "gram.y" /* yacc.c:1646  */
+    { prefs.sizeborder = (yyvsp[0].num); }
+#line 1482 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 93 "gram.y" /* yacc.c:1646  */
+    { prefs.defaulticon = (yyvsp[0].ptr); }
+#line 1488 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 11:
+#line 94 "gram.y" /* yacc.c:1646  */
+    { prefs.icondir = (yyvsp[0].ptr); }
+#line 1494 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 12:
+#line 95 "gram.y" /* yacc.c:1646  */
+    { set_sys_palette(); }
+#line 1500 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 13:
+#line 96 "gram.y" /* yacc.c:1646  */
+    { set_mwb_palette(); }
+#line 1506 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 14:
+#line 97 "gram.y" /* yacc.c:1646  */
+    { set_schwartz_palette(); }
+#line 1512 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 15:
+#line 98 "gram.y" /* yacc.c:1646  */
+    { set_custom_palette((yyvsp[0].ptr)); }
+#line 1518 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 16:
+#line 99 "gram.y" /* yacc.c:1646  */
+    { default_colors[(yyvsp[-1].num)] = (yyvsp[0].ptr); }
+#line 1524 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 17:
+#line 100 "gram.y" /* yacc.c:1646  */
+    { default_screenfont = (yyvsp[0].ptr); }
+#line 1530 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 18:
+#line 101 "gram.y" /* yacc.c:1646  */
+    { label_font_name = (yyvsp[0].ptr); }
+#line 1536 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 19:
+#line 102 "gram.y" /* yacc.c:1646  */
+    { prefs.forcemove = (yyvsp[0].num); }
+#line 1542 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 20:
+#line 103 "gram.y" /* yacc.c:1646  */
+    { openscreen((yyvsp[0].ptr),DefaultRootWindow(dpy)); }
+#line 1548 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 21:
+#line 104 "gram.y" /* yacc.c:1646  */
+    { if(((yyvsp[-1].num)==DefaultScreen(dpy)||prefs.manage_all) && (yyvsp[-1].num)<ScreenCount(dpy)) openscreen((yyvsp[0].ptr),RootWindow(dpy,(yyvsp[-1].num))); }
+#line 1554 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 22:
+#line 105 "gram.y" /* yacc.c:1646  */
+    { prefs.module_path = (yyvsp[0].ptr); }
+#line 1560 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 23:
+#line 106 "gram.y" /* yacc.c:1646  */
+    { create_module((front? front->upfront:NULL), (yyvsp[-1].ptr), (yyvsp[0].ptr)); }
+#line 1566 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 24:
+#line 107 "gram.y" /* yacc.c:1646  */
+    { create_module((front? front->upfront:NULL), (yyvsp[0].ptr), NULL); }
+#line 1572 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 25:
+#line 108 "gram.y" /* yacc.c:1646  */
+    { prefs.borderwidth=(yyvsp[0].num); }
+#line 1578 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 26:
+#line 109 "gram.y" /* yacc.c:1646  */
+    { prefs.autoraise=(yyvsp[0].num); }
+#line 1584 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 27:
+#line 110 "gram.y" /* yacc.c:1646  */
+    { prefs.opaquemove=(yyvsp[0].num); }
+#line 1590 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 28:
+#line 111 "gram.y" /* yacc.c:1646  */
+    { prefs.opaqueresize=(yyvsp[0].num); }
+#line 1596 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 29:
+#line 112 "gram.y" /* yacc.c:1646  */
+    { prefs.focus=(yyvsp[0].num); }
+#line 1602 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 30:
+#line 113 "gram.y" /* yacc.c:1646  */
+    { prefs.customiconsonly = (yyvsp[0].num); }
+#line 1608 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 31:
+#line 114 "gram.y" /* yacc.c:1646  */
+    { prefs.shortlabelicons = (yyvsp[0].num); }
+#line 1614 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 32:
+#line 115 "gram.y" /* yacc.c:1646  */
+    { prefs.titlebarclock = (yyvsp[0].num); }
+#line 1620 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 33:
+#line 116 "gram.y" /* yacc.c:1646  */
+    { prefs.titleclockformat = (yyvsp[0].ptr); }
+#line 1626 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 34:
+#line 117 "gram.y" /* yacc.c:1646  */
+    { 
+					prefs.titleclockinterval=(yyvsp[-1].num); 
+					prefs.titleclockformat=(yyvsp[0].ptr); }
+#line 1634 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 35:
+#line 120 "gram.y" /* yacc.c:1646  */
+    { prefs.screenmenu=(yyvsp[0].num); }
+#line 1640 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 37:
+#line 124 "gram.y" /* yacc.c:1646  */
+    { add_toolitem((yyvsp[-1].ptr), NULL, NULL, -1); ti_level=1; }
+#line 1646 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 40:
+#line 131 "gram.y" /* yacc.c:1646  */
+    { add_toolitem((yyvsp[-1].ptr), (yyvsp[0].ptr), NULL, ti_level); }
+#line 1652 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 41:
+#line 132 "gram.y" /* yacc.c:1646  */
+    { add_toolitem((yyvsp[-2].ptr), (yyvsp[-1].ptr), (yyvsp[0].ptr), ti_level); }
+#line 1658 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 42:
+#line 133 "gram.y" /* yacc.c:1646  */
+    { add_toolitem(NULL, NULL, NULL, ti_level); }
+#line 1664 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 43:
+#line 136 "gram.y" /* yacc.c:1646  */
+    { Style *s = malloc(sizeof(Style));
+				    memset(s, 0, sizeof(*s));
+				    s->next=NULL; s->style_class=NULL;
+				    s->style_title=s->style_icon_title=NULL;
+				    s->icon_name=NULL;
+				    s->icon_pms.cs.colors=NULL;
+				    s->icon_pms.cs2.colors=NULL;
+				    if(prefs.firststyle)
+				      prefs.laststyle->next=s;
+				    else
+				      prefs.firststyle=s;
+				    prefs.laststyle=s; }
+#line 1681 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 46:
+#line 153 "gram.y" /* yacc.c:1646  */
+    { append_to(&prefs.laststyle->style_class, (yyvsp[0].ptr));}
+#line 1687 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 47:
+#line 154 "gram.y" /* yacc.c:1646  */
+    { append_to(&prefs.laststyle->style_title, (yyvsp[0].ptr));}
+#line 1693 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 48:
+#line 155 "gram.y" /* yacc.c:1646  */
+    { append_to(&prefs.laststyle->style_icon_title, (yyvsp[0].ptr));}
+#line 1699 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 49:
+#line 156 "gram.y" /* yacc.c:1646  */
+    { prefs.laststyle->icon_name=(yyvsp[0].ptr); }
+#line 1705 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 50:
+#line 159 "gram.y" /* yacc.c:1646  */
+    { (yyval.ptr) = strdup((yyvsp[0].ptr)); }
+#line 1711 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 51:
+#line 162 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = True; }
+#line 1717 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 52:
+#line 163 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = False; }
+#line 1723 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 53:
+#line 166 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = Psizeright; }
+#line 1729 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 54:
+#line 167 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = Psizebottom; }
+#line 1735 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 55:
+#line 168 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = Psizeright|Psizebottom; }
+#line 1741 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 56:
+#line 169 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = Psizetrans; }
+#line 1747 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 57:
+#line 170 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = Psizetrans; }
+#line 1753 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 58:
+#line 173 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FOC_FOLLOWMOUSE; }
+#line 1759 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 59:
+#line 174 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FOC_SLOPPY; }
+#line 1765 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 60:
+#line 175 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FOC_CLICKTOTYPE; }
+#line 1771 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 61:
+#line 178 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = DETAILPEN; }
+#line 1777 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 62:
+#line 179 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = BLOCKPEN; }
+#line 1783 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 63:
+#line 180 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = TEXTPEN; }
+#line 1789 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 64:
+#line 181 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = SHINEPEN; }
+#line 1795 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 65:
+#line 182 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = SHADOWPEN; }
+#line 1801 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 66:
+#line 183 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FILLPEN; }
+#line 1807 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 67:
+#line 184 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FILLTEXTPEN; }
+#line 1813 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 68:
+#line 185 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = BACKGROUNDPEN; }
+#line 1819 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 69:
+#line 186 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = HIGHLIGHTTEXTPEN; }
+#line 1825 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 70:
+#line 187 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = BARDETAILPEN; }
+#line 1831 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 71:
+#line 188 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = BARBLOCKPEN; }
+#line 1837 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 72:
+#line 189 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = BARTRIMPEN; }
+#line 1843 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 73:
+#line 192 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FM_ALWAYS; }
+#line 1849 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 74:
+#line 193 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FM_AUTO; }
+#line 1855 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 75:
+#line 194 "gram.y" /* yacc.c:1646  */
+    { (yyval.num) = FM_MANUAL; }
+#line 1861 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+
+#line 1865 "y.tab.c" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 197 "gram.y" /* yacc.c:1906  */
+
+extern char *progname;
+extern int ParseError;
+int yyerror(s) char *s;
+{
+    fprintf (stderr, "%s: error in input file:  %s\n", progname, s ? s : "");
+    ParseError = 1;
+    return 0;
+}
diff --git a/gram.h b/gram.h
new file mode 100644
index 0000000..0f1330d
--- /dev/null
+++ b/gram.h
@@ -0,0 +1,195 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    ERRORTOKEN = 258,
+    LEFTBRACE = 259,
+    RIGHTBRACE = 260,
+    YES = 261,
+    NO = 262,
+    RIGHT = 263,
+    BOTTOM = 264,
+    BOTH = 265,
+    NONE = 266,
+    MAGICWB = 267,
+    SYSTEM = 268,
+    SCHWARTZ = 269,
+    ALWAYS = 270,
+    AUTO = 271,
+    MANUAL = 272,
+    SEPARATOR = 273,
+    T_DETAILPEN = 274,
+    T_BLOCKPEN = 275,
+    T_TEXTPEN = 276,
+    T_SHINEPEN = 277,
+    T_SHADOWPEN = 278,
+    T_FILLPEN = 279,
+    T_FILLTEXTPEN = 280,
+    T_BACKGROUNDPEN = 281,
+    T_HIGHLIGHTTEXTPEN = 282,
+    T_BARDETAILPEN = 283,
+    T_BARBLOCKPEN = 284,
+    T_BARTRIMPEN = 285,
+    FASTQUIT = 286,
+    SIZEBORDER = 287,
+    DEFAULTICON = 288,
+    ICONDIR = 289,
+    ICONPALETTE = 290,
+    SCREENFONT = 291,
+    ICONFONT = 292,
+    TOOLITEM = 293,
+    FORCEMOVE = 294,
+    SCREEN = 295,
+    MODULE = 296,
+    MODULEPATH = 297,
+    INTERSCREENGAP = 298,
+    AUTORAISE = 299,
+    FOCUS = 300,
+    FOLLOWMOUSE = 301,
+    CLICKTOTYPE = 302,
+    SLOPPY = 303,
+    CUSTOMICONSONLY = 304,
+    TITLEBARCLOCK = 305,
+    TITLECLOCKFORMAT = 306,
+    OPAQUEMOVE = 307,
+    OPAQUERESIZE = 308,
+    SCREENMENU = 309,
+    STYLE = 310,
+    CLASS = 311,
+    TITLE = 312,
+    ICONTITLE = 313,
+    ICON = 314,
+    SHORTLABELICONS = 315,
+    STRING = 316,
+    NUMBER = 317
+  };
+#endif
+/* Tokens.  */
+#define ERRORTOKEN 258
+#define LEFTBRACE 259
+#define RIGHTBRACE 260
+#define YES 261
+#define NO 262
+#define RIGHT 263
+#define BOTTOM 264
+#define BOTH 265
+#define NONE 266
+#define MAGICWB 267
+#define SYSTEM 268
+#define SCHWARTZ 269
+#define ALWAYS 270
+#define AUTO 271
+#define MANUAL 272
+#define SEPARATOR 273
+#define T_DETAILPEN 274
+#define T_BLOCKPEN 275
+#define T_TEXTPEN 276
+#define T_SHINEPEN 277
+#define T_SHADOWPEN 278
+#define T_FILLPEN 279
+#define T_FILLTEXTPEN 280
+#define T_BACKGROUNDPEN 281
+#define T_HIGHLIGHTTEXTPEN 282
+#define T_BARDETAILPEN 283
+#define T_BARBLOCKPEN 284
+#define T_BARTRIMPEN 285
+#define FASTQUIT 286
+#define SIZEBORDER 287
+#define DEFAULTICON 288
+#define ICONDIR 289
+#define ICONPALETTE 290
+#define SCREENFONT 291
+#define ICONFONT 292
+#define TOOLITEM 293
+#define FORCEMOVE 294
+#define SCREEN 295
+#define MODULE 296
+#define MODULEPATH 297
+#define INTERSCREENGAP 298
+#define AUTORAISE 299
+#define FOCUS 300
+#define FOLLOWMOUSE 301
+#define CLICKTOTYPE 302
+#define SLOPPY 303
+#define CUSTOMICONSONLY 304
+#define TITLEBARCLOCK 305
+#define TITLECLOCKFORMAT 306
+#define OPAQUEMOVE 307
+#define OPAQUERESIZE 308
+#define SCREENMENU 309
+#define STYLE 310
+#define CLASS 311
+#define TITLE 312
+#define ICONTITLE 313
+#define ICON 314
+#define SHORTLABELICONS 315
+#define STRING 316
+#define NUMBER 317
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 50 "gram.y" /* yacc.c:1909  */
+
+    int num;
+    char *ptr;
+
+#line 183 "y.tab.h" /* yacc.c:1909  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
diff --git a/gram.y b/gram.y
new file mode 100644
index 0000000..80f46b7
--- /dev/null
+++ b/gram.y
@@ -0,0 +1,205 @@
+%{
+#include <X11/Xlib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "prefs.h"
+#include "drawinfo.h"
+#include "screen.h"
+#include "icc.h"
+#include "style.h"
+extern void set_sys_palette(void);
+extern void set_mwb_palette(void);
+extern void set_schwartz_palette(void);
+extern void set_custom_palette(char *fn);
+extern void add_toolitem(char *, char *, char *, int);
+extern Scrn *openscreen(char *, Window);
+extern void create_module(Scrn *, char *, char *);
+extern char *default_colors[NUMDRIPENS];
+extern char *default_screenfont, *label_font_name;
+extern Display *dpy;
+#ifndef HAVE_ALLOCA
+#define alloca malloc
+#endif
+#ifndef HAVE_STRDUP
+char *strdup(s) char *s;
+{
+  char *ptr=(char *)malloc(strlen(s)+1);
+  if(ptr) strcpy(ptr, s);
+  return ptr;
+}
+#endif
+
+static void append_to(char **x, char *y)
+{
+  if(*x==NULL)
+    *x=y;
+  else {
+    char *t = malloc(strlen(y)+strlen(*x)+2);
+    sprintf(t, "%s\n%s", *x, y);
+    free(*x);
+    free(y);
+    *x=t;
+  }
+}
+
+static int ti_level=0;
+%}
+
+%union
+{
+    int num;
+    char *ptr;
+};
+
+%token <num> ERRORTOKEN LEFTBRACE RIGHTBRACE
+%token <num> YES NO
+%token <num> RIGHT BOTTOM BOTH NONE
+%token <num> MAGICWB SYSTEM SCHWARTZ
+%token <num> ALWAYS AUTO MANUAL
+%token <num> SEPARATOR
+%token <num> T_DETAILPEN T_BLOCKPEN T_TEXTPEN T_SHINEPEN T_SHADOWPEN
+%token <num> T_FILLPEN T_FILLTEXTPEN T_BACKGROUNDPEN T_HIGHLIGHTTEXTPEN
+%token <num> T_BARDETAILPEN T_BARBLOCKPEN T_BARTRIMPEN
+%token <num> FASTQUIT SIZEBORDER DEFAULTICON ICONDIR ICONPALETTE SCREENFONT
+%token <num> ICONFONT TOOLITEM FORCEMOVE SCREEN MODULE MODULEPATH
+%token <num> INTERSCREENGAP AUTORAISE FOCUS FOLLOWMOUSE CLICKTOTYPE SLOPPY
+%token <num> CUSTOMICONSONLY
+%token <num> TITLEBARCLOCK TITLECLOCKFORMAT
+%token <num> OPAQUEMOVE OPAQUERESIZE SCREENMENU STYLE CLASS TITLE ICONTITLE ICON
+%token <num> SHORTLABELICONS
+%token <ptr> STRING
+%token <num> NUMBER
+
+%type <num> truth sizeborder dri_pen forcemove_policy focuspolicy
+%type <ptr> string
+
+%start amiwmrc
+
+%%
+
+amiwmrc		: stmts
+		;
+
+stmts		: stmts stmt
+		|
+		;
+
+stmt		: error
+		| toolitem
+		| toolsubmenu toolitems RIGHTBRACE { ti_level=0; }
+		| FASTQUIT truth { prefs.fastquit = $2; }
+		| SIZEBORDER sizeborder { prefs.sizeborder = $2; }
+		| DEFAULTICON string { prefs.defaulticon = $2; }
+		| ICONDIR string { prefs.icondir = $2; }
+		| ICONPALETTE SYSTEM { set_sys_palette(); }
+		| ICONPALETTE MAGICWB { set_mwb_palette(); }
+		| ICONPALETTE SCHWARTZ { set_schwartz_palette(); }
+		| ICONPALETTE STRING { set_custom_palette($2); }
+		| dri_pen string { default_colors[$1] = $2; }
+		| SCREENFONT string { default_screenfont = $2; }
+		| ICONFONT string { label_font_name = $2; }
+		| FORCEMOVE forcemove_policy { prefs.forcemove = $2; }
+		| SCREEN string { openscreen($2,DefaultRootWindow(dpy)); }
+		| SCREEN NUMBER string { if(($2==DefaultScreen(dpy)||prefs.manage_all) && $2<ScreenCount(dpy)) openscreen($3,RootWindow(dpy,$2)); }
+		| MODULEPATH string { prefs.module_path = $2; }
+		| MODULE string STRING { create_module((front? front->upfront:NULL), $2, $3); }
+		| MODULE string { create_module((front? front->upfront:NULL), $2, NULL); }
+		| INTERSCREENGAP NUMBER { prefs.borderwidth=$2; }
+		| AUTORAISE truth { prefs.autoraise=$2; }
+		| OPAQUEMOVE truth { prefs.opaquemove=$2; }
+		| OPAQUERESIZE truth { prefs.opaqueresize=$2; }
+		| FOCUS focuspolicy { prefs.focus=$2; }
+		| CUSTOMICONSONLY truth { prefs.customiconsonly = $2; }
+		| SHORTLABELICONS truth { prefs.shortlabelicons = $2; }
+		| TITLEBARCLOCK truth { prefs.titlebarclock = $2; }
+		| TITLECLOCKFORMAT string { prefs.titleclockformat = $2; }
+		| TITLECLOCKFORMAT NUMBER string { 
+					prefs.titleclockinterval=$2; 
+					prefs.titleclockformat=$3; }
+		| SCREENMENU truth { prefs.screenmenu=$2; }
+		| stylespec styleitems RIGHTBRACE
+		;
+
+toolsubmenu	: TOOLITEM string LEFTBRACE { add_toolitem($2, NULL, NULL, -1); ti_level=1; }
+		;
+
+toolitems	: toolitems toolitem
+		|
+		;
+
+toolitem	: TOOLITEM string string { add_toolitem($2, $3, NULL, ti_level); }
+		| TOOLITEM string string string { add_toolitem($2, $3, $4, ti_level); }
+		| TOOLITEM SEPARATOR { add_toolitem(NULL, NULL, NULL, ti_level); }
+		;
+
+stylespec	: STYLE LEFTBRACE { Style *s = malloc(sizeof(Style));
+				    memset(s, 0, sizeof(*s));
+				    s->next=NULL; s->style_class=NULL;
+				    s->style_title=s->style_icon_title=NULL;
+				    s->icon_name=NULL;
+				    s->icon_pms.cs.colors=NULL;
+				    s->icon_pms.cs2.colors=NULL;
+				    if(prefs.firststyle)
+				      prefs.laststyle->next=s;
+				    else
+				      prefs.firststyle=s;
+				    prefs.laststyle=s; }
+
+styleitems	: styleitems styleitem
+		|
+		;
+
+styleitem	: CLASS string { append_to(&prefs.laststyle->style_class, $2);}
+		| TITLE string { append_to(&prefs.laststyle->style_title, $2);}
+		| ICONTITLE string { append_to(&prefs.laststyle->style_icon_title, $2);}
+		| ICON string { prefs.laststyle->icon_name=$2; }
+
+
+string		: STRING { $$ = strdup($1); }
+		;
+
+truth		: YES { $$ = True; }
+		| NO { $$ = False; }
+		;
+
+sizeborder	: RIGHT { $$ = Psizeright; }
+		| BOTTOM { $$ = Psizebottom; }
+		| BOTH { $$ = Psizeright|Psizebottom; }
+		| NONE { $$ = Psizetrans; }
+		| NO { $$ = Psizetrans; }
+		;
+
+focuspolicy	: FOLLOWMOUSE { $$ = FOC_FOLLOWMOUSE; }
+		| SLOPPY { $$ = FOC_SLOPPY; }
+		| CLICKTOTYPE { $$ = FOC_CLICKTOTYPE; }
+		;
+
+dri_pen		: T_DETAILPEN { $$ = DETAILPEN; }
+		| T_BLOCKPEN { $$ = BLOCKPEN; }
+		| T_TEXTPEN { $$ = TEXTPEN; }
+		| T_SHINEPEN { $$ = SHINEPEN; }
+		| T_SHADOWPEN { $$ = SHADOWPEN; }
+		| T_FILLPEN { $$ = FILLPEN; }
+		| T_FILLTEXTPEN { $$ = FILLTEXTPEN; }
+		| T_BACKGROUNDPEN { $$ = BACKGROUNDPEN; }
+		| T_HIGHLIGHTTEXTPEN { $$ = HIGHLIGHTTEXTPEN; }
+		| T_BARDETAILPEN { $$ = BARDETAILPEN; }
+		| T_BARBLOCKPEN { $$ = BARBLOCKPEN; }
+		| T_BARTRIMPEN { $$ = BARTRIMPEN; }
+		;
+
+forcemove_policy : ALWAYS { $$ = FM_ALWAYS; }
+		 | AUTO { $$ = FM_AUTO; }
+		 | MANUAL { $$ = FM_MANUAL; }
+		 ;
+
+%%
+extern char *progname;
+extern int ParseError;
+int yyerror(s) char *s;
+{
+    fprintf (stderr, "%s: error in input file:  %s\n", progname, s ? s : "");
+    ParseError = 1;
+    return 0;
+}
diff --git a/icc.c b/icc.c
new file mode 100644
index 0000000..9b59070
--- /dev/null
+++ b/icc.c
@@ -0,0 +1,286 @@
+#include "drawinfo.h"
+#include "screen.h"
+#include "icc.h"
+#include "icon.h"
+#include "style.h"
+#include "prefs.h"
+
+#include <string.h>
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+extern void redraw(Client *, Window);
+
+Atom wm_state, wm_change_state, wm_protocols, wm_delete, wm_take_focus;
+Atom wm_colormaps, wm_name, wm_normal_hints, wm_hints, wm_icon_name, wm_class;
+Atom amiwm_screen, swm_vroot, amiwm_wflags, amiwm_appiconmsg, amiwm_appwindowmsg;
+
+extern Display *dpy;
+
+void init_atoms()
+{
+  wm_state = XInternAtom(dpy, "WM_STATE", False);
+  wm_change_state = XInternAtom(dpy, "WM_CHANGE_STATE", False);
+  wm_protocols = XInternAtom(dpy, "WM_PROTOCOLS", False);
+  wm_delete = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
+  wm_take_focus = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
+  wm_colormaps = XInternAtom(dpy, "WM_COLORMAP_WINDOWS", False);
+  wm_name = XInternAtom(dpy, "WM_NAME", False);
+  wm_normal_hints = XInternAtom(dpy, "WM_NORMAL_HINTS", False);
+  wm_hints = XInternAtom(dpy, "WM_HINTS", False);
+  wm_icon_name = XInternAtom(dpy, "WM_ICON_NAME", False);
+  wm_class = XInternAtom(dpy, "WM_CLASS", False);
+  amiwm_screen = XInternAtom(dpy, "AMIWM_SCREEN", False);
+  swm_vroot = XInternAtom(dpy, "__SWM_VROOT", False);
+  amiwm_wflags = XInternAtom(dpy, "AMIWM_WFLAGS", False);
+  amiwm_appiconmsg = XInternAtom(dpy, "AMIWM_APPICONMSG", False);
+  amiwm_appwindowmsg = XInternAtom(dpy, "AMIWM_APPWINDOWMSG", False);
+}
+
+void setstringprop(Window w, Atom a, char *str)
+{
+    XTextProperty txtp;
+
+    txtp.value=(unsigned char *)str;
+    txtp.encoding=XA_STRING;
+    txtp.format=8;
+    txtp.nitems=strlen(str);
+    XSetTextProperty(dpy, w, &txtp, a);
+}
+
+XEvent *mkcmessage(Window w, Atom a, long x)
+{
+  static XEvent ev;
+
+  memset(&ev, 0, sizeof(ev));
+  ev.xclient.type = ClientMessage;
+  ev.xclient.window = w;
+  ev.xclient.message_type = a;
+  ev.xclient.format = 32;
+  ev.xclient.data.l[0] = x;
+  ev.xclient.data.l[1] = CurrentTime;
+  return &ev;
+}
+
+void sendcmessage(Window w, Atom a, long x)
+{
+  if(!(XSendEvent(dpy, w, False, 0L, mkcmessage(w, a, x))))
+    XBell(dpy, 100);
+}
+
+long _getprop(Window w, Atom a, Atom type, long len, char **p)
+{
+  Atom real_type;
+  int format;
+  unsigned long n, extra;
+  int status;
+  
+  status = XGetWindowProperty(dpy, w, a, 0L, len, False, type, &real_type, &format,
+			      &n, &extra, (unsigned char **)p);
+  if (status != Success || *p == 0)
+    return -1;
+  if (n == 0)
+    XFree((void*) *p);
+  return n;
+}
+
+void getwflags(Client *c)
+{
+  BITS32 *p;
+  long n;
+
+  c->wflags = 0;
+  if ((n = _getprop(c->window, amiwm_wflags, amiwm_wflags, 1L, (char**)&p)) <= 0)
+    return;
+
+  c->wflags = p[0];
+  
+  XFree((char *) p);
+}
+
+void getproto(Client *c)
+{
+  Atom *p;
+  int i;
+  long n;
+  Window w;
+
+  w = c->window;
+  c->proto &= ~(Pdelete|Ptakefocus);
+  if ((n = _getprop(w, wm_protocols, XA_ATOM, 20L, (char**)&p)) <= 0)
+    return;
+
+  for (i = 0; i < n; i++)
+    if (p[i] == wm_delete)
+      c->proto |= Pdelete;
+    else if (p[i] == wm_take_focus)
+      c->proto |= Ptakefocus;
+  
+  XFree((char *) p);
+}
+
+static int stylematch_low(char *p, int l, char *m)
+{
+  char *lf;
+  int ml;
+  --m;
+  do {
+    lf = strchr(++m, '\n');
+    ml = (lf? lf-m:strlen(m));
+    if(ml == l && !strncmp(m, p, ml))
+      return 1;
+  } while((m=lf));
+  return 0;
+}
+
+static int stylematch_tprop(XTextProperty *p, char *m)
+{
+  return stylematch_low((char *)p->value, p->nitems, m);
+}
+
+#ifdef USE_FONTSETS
+static int stylematch_str(char *p, char *m)
+{
+  return stylematch_low(p, strlen(p), m);
+}
+#endif
+
+void checkstyle(Client *c)
+{
+  XTextProperty icon_name, class_name;
+  Style *style;
+
+  if(prefs.firststyle==NULL)
+    return;
+
+  if(!XGetTextProperty(dpy, c->window, &class_name, wm_class))
+    class_name.value=NULL;
+  else
+    /* This value seems to be 2x it's correct value always... */
+    class_name.nitems=strlen((char *)class_name.value);
+  if(!XGetWMIconName(dpy, c->window, &icon_name))
+    icon_name.value=NULL;
+
+  for(style=prefs.firststyle; style!=NULL; style=style->next)
+    if((class_name.value!=NULL && style->style_class!=NULL &&
+	stylematch_tprop(&class_name, style->style_class)) ||
+#ifdef USE_FONTSETS
+       (c->title!=NULL && style->style_title!=NULL &&
+	stylematch_str(c->title, style->style_title)) ||
+#else
+       (c->title.value!=NULL && style->style_title!=NULL &&
+	stylematch_tprop(&c->title, style->style_title)) ||
+#endif
+       (icon_name.value!=NULL && style->style_icon_title!=NULL &&
+	stylematch_tprop(&icon_name, style->style_icon_title))) {
+      c->style = style;
+      break;
+    }
+
+  if(icon_name.value)
+    XFree(icon_name.value);
+  if(class_name.value)
+    XFree(class_name.value);
+}
+
+void propertychange(Client *c, Atom a)
+{
+  extern void checksizehints(Client *);
+  extern void newicontitle(Client *);
+
+  if(a==wm_name) {
+#ifdef USE_FONTSETS
+    XTextProperty prop;
+    if(c->title) {
+      free(c->title);
+      c->title = NULL;
+    }
+    if(XGetWMName(dpy, c->window, &prop) && prop.value) {
+      char **list;
+      int n;
+      if(XmbTextPropertyToTextList(dpy, &prop, &list, &n) >= Success) {
+	if(n > 0)
+	  c->title = strdup(list[0]);
+	XFreeStringList(list);
+      }
+      XFree(prop.value);
+    }
+#else
+    if(c->title.value)
+      XFree(c->title.value);
+    XGetWMName(dpy, c->window, &c->title);
+#endif
+    if(c->style==NULL)
+      checkstyle(c);
+    if(c->drag) {
+      XClearWindow(dpy, c->drag);
+      redraw(c, c->drag);
+    }
+  } else if(a==wm_normal_hints) {
+    checksizehints(c);
+  } else if(a==wm_hints) {
+    XWMHints *xwmh;
+    if((xwmh=XGetWMHints(dpy, c->window))) {
+      if((xwmh->flags&(IconWindowHint|IconPixmapHint))&&c->icon) {
+	destroyiconicon(c->icon);
+	createiconicon(c->icon, xwmh);
+      }
+      if((xwmh->flags&IconPositionHint)&&c->icon&&c->icon->window) {
+	XMoveWindow(dpy, c->icon->window, c->icon->x=xwmh->icon_x,
+		    c->icon->y=xwmh->icon_y);
+	adjusticon(c->icon);
+      }
+      XFree(xwmh);
+    }
+  } else if(a==wm_protocols) {
+    getproto(c);
+  } else if(a==wm_icon_name) {
+    if(c->style==NULL)
+      checkstyle(c);
+    if(c->icon) newicontitle(c);
+  } else if(a==wm_state) {
+    if(c->parent==c->scr->root) {
+      getstate(c);
+      if(c->state==NormalState)
+	c->state=WithdrawnState;
+    }
+  } else if(a==wm_class && c->style==NULL)
+    checkstyle(c);
+}
+
+void handle_client_message(Client *c, XClientMessageEvent *xcme)
+{
+  if(xcme->message_type == wm_change_state) {
+    int state=xcme->data.l[0];
+    if(state==IconicState)
+      if(c->state!=IconicState) {
+	if(!(c->icon))
+	  createicon(c);
+	XUnmapWindow(dpy, c->parent);
+	/*	XUnmapWindow(dpy, c->window); */
+	adjusticon(c->icon);
+	XMapWindow(dpy, c->icon->window);
+	if(c->icon->labelwidth)
+	  XMapWindow(dpy, c->icon->labelwin);
+	c->icon->mapped=1;
+	setclientstate(c, IconicState);
+      } else ;
+    else
+      if(c->state==IconicState && c->icon) {
+	Icon *i=c->icon;
+	if(i->labelwin)
+	  XUnmapWindow(dpy, i->labelwin);
+	if(i->window)
+	  XUnmapWindow(dpy, i->window);
+	i->mapped=0;
+	deselecticon(i);
+	XMapWindow(dpy, c->window);
+	if(c->parent!=c->scr->root)
+	  XMapRaised(dpy, c->parent);
+	setclientstate(c, NormalState);
+      }
+  }
+}
diff --git a/icc.h b/icc.h
new file mode 100644
index 0000000..3b61598
--- /dev/null
+++ b/icc.h
@@ -0,0 +1,24 @@
+#ifndef ICC_H
+#define ICC_H
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include "client.h"
+
+extern void init_atoms(void);
+extern void sendcmessage(Window, Atom, long);
+extern void getproto(Client *c);
+extern void setstringprop(Window, Atom, char *);
+extern void propertychange(Client *, Atom);
+extern long _getprop(Window, Atom, Atom, long, char **);
+extern void getwflags(Client *);
+
+extern Atom wm_state, wm_change_state, wm_protocols, wm_delete, wm_take_focus, wm_colormaps, wm_hints, amiwm_screen, swm_vroot;
+
+#define Pdelete 1
+#define Ptakefocus 2
+#define Psizebottom 4
+#define Psizeright 8
+#define Psizetrans 16
+
+#endif
diff --git a/icon.c b/icon.c
new file mode 100644
index 0000000..ae0d8f2
--- /dev/null
+++ b/icon.c
@@ -0,0 +1,637 @@
+#include <X11/Xlib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "drawinfo.h"
+#include "screen.h"
+#include "icon.h"
+#include "client.h"
+#include "prefs.h"
+#include "icc.h"
+#include "style.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#define NO_ICON_POSITION	(0x80000000)
+
+extern Display *dpy;
+extern char *progname;
+extern XContext icon_context, client_context, screen_context;
+
+extern void init_iconpalette();
+
+#ifdef USE_FONTSETS
+XFontSet labelfontset;
+int labelfont_ascent;
+#else
+XFontStruct *labelfont;
+#endif
+
+char *label_font_name="-b&h-lucida-medium-r-normal-sans-10-*-*-*-*-*-iso8859-1"
+#ifdef USE_FONTSETS
+",-misc-fixed-medium-r-normal--10-*-*-*-*-*-iso10646-1"
+#endif
+;
+
+void redrawicon(Icon *i, Window w)
+{
+  Pixmap pm;
+
+  scr=i->scr;
+  if(w==i->window) {
+    pm=i->iconpm;
+    if(i->selected && i->secondpm)
+      pm=i->secondpm;
+    if(pm) {
+      XGCValues xgc;
+      Window r;
+      int x, y;
+      unsigned int w, h, bw, d;
+      XGetGeometry(dpy, pm, &r, &x, &y, &w, &h, &bw, &d);
+      if(i->maskpm) {
+	xgc.clip_mask = i->maskpm;
+	xgc.clip_x_origin = xgc.clip_y_origin = 4;
+	XChangeGC(dpy, scr->gc, GCClipXOrigin|GCClipYOrigin|GCClipMask, &xgc);
+      }
+      if(d!=scr->depth) {
+	XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+	XSetBackground(dpy, scr->gc, scr->dri.dri_Pens[BACKGROUNDPEN]);
+	XCopyPlane(dpy, pm, i->window, scr->gc, 0, 0,
+		i->width-8, i->height-8, 4, 4, 1);
+      }
+      else
+	XCopyArea(dpy, pm, i->window, scr->gc, 0, 0,
+		  i->width-8, i->height-8, 4, 4);
+      if(i->maskpm) {
+	xgc.clip_mask = None;
+	XChangeGC(dpy, scr->gc, GCClipMask, &xgc);
+      }
+    }
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[i->selected? SHADOWPEN:SHINEPEN]);
+    XDrawLine(dpy, w, scr->gc, 0, 0, i->width-1, 0);
+    XDrawLine(dpy, w, scr->gc, 0, 0, 0, i->height-1);
+    XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[i->selected? SHINEPEN:SHADOWPEN]);
+    XDrawLine(dpy, w, scr->gc, 1, i->height-1, i->width-1, i->height-1);
+    XDrawLine(dpy, w, scr->gc, i->width-1, 1, i->width-1, i->height-1);
+#ifdef USE_FONTSETS
+  } else if(w==i->labelwin && i->label) {
+    XmbDrawImageString(dpy, w, labelfontset, scr->icongc, 0, labelfont_ascent,
+		       i->label, strlen(i->label));
+#else
+  } else if(w==i->labelwin && i->label.value) {
+    XDrawImageString(dpy, w, scr->icongc, 0, labelfont->ascent,
+		     (char *)i->label.value, i->label.nitems);
+#endif
+  }
+}
+
+void selecticon(Icon *i)
+{
+  if(!(i->selected)) {
+    i->nextselected = i->scr->firstselected;
+    i->scr->firstselected = i;
+    i->selected = 1;
+    if(i->mapped)
+      redrawicon(i, i->window);
+  }
+}
+
+void deselecticon(Icon *i)
+{
+  Icon *i2;
+  if(i==i->scr->firstselected)
+    i->scr->firstselected = i->nextselected;
+  else for(i2=i->scr->firstselected; i2; i2=i2->nextselected)
+    if(i2->nextselected==i) {
+      i2->nextselected = i->nextselected;
+      break;
+    }
+  i->nextselected = NULL;
+  i->selected=0;
+  if(i->mapped)
+    redrawicon(i, i->window);
+}
+
+void deselect_all_icons(Scrn *scr)
+{
+  while(scr->firstselected)
+    deselecticon(scr->firstselected);
+}
+
+void select_all_icons(Scrn *scr)
+{
+  Icon *i;
+  for(i=scr->icons; i; i=i->next)
+    if(i->window && i->mapped)
+      selecticon(i);
+}
+
+void reparenticon(Icon *i, Scrn *s, int x, int y)
+{
+  Icon **ip;
+  int os=i->selected;
+  if(s==i->scr) {
+    if(x!=i->x || y!=i->y)
+      XMoveWindow(dpy, i->window, i->x=x, i->y=y);
+    return;
+  }
+  if(os)
+    deselecticon(i);
+  for(ip=&i->scr->icons; *ip; ip=&(*ip)->next)
+    if(*ip==i) {
+      *ip=i->next;
+      break;
+    }
+  XReparentWindow(dpy, i->window, s->back, i->x=x, i->y=y);
+  if(i->labelwin) {
+    XReparentWindow(dpy, i->labelwin, s->back,
+		    x+(i->width>>1)-(i->labelwidth>>1),
+		    y+i->height+1);
+  }
+  i->scr=s;
+  i->next=s->icons;
+  s->icons=i;
+  if(i->client) {
+    i->client->scr=s;
+    if(i->client->parent != i->client->scr->root)
+      XReparentWindow(dpy, i->client->parent, s->back,
+		      i->client->x, i->client->y);
+    setstringprop(i->client->window, amiwm_screen, s->deftitle);
+    sendconfig(i->client);
+  }
+  if(os)
+    selecticon(i);
+}
+
+void createdefaulticons()
+{
+  Window r;
+  int x,y;
+  unsigned int b,d;
+  extern void load_do(const char *, struct IconPixmaps *);
+
+  init_iconpalette();
+  load_do(prefs.defaulticon, &scr->default_tool_pms);
+  if(scr->default_tool_pms.pm == None) {
+    fprintf(stderr, "%s: Cannot load default icon \"%s\".\n",
+	    progname, prefs.defaulticon);
+    exit(1);
+  }
+  XGetGeometry(dpy, scr->default_tool_pms.pm, &r, &x, &y,
+	       &scr->default_tool_pm_w, &scr->default_tool_pm_h, &b, &d);
+}
+
+void adjusticon(Icon *i)
+{
+  Window w=i->window,lw=i->labelwin;
+  int nx, ny;
+  Window rt, ws[3];
+  Icon *i2;
+  int xx, yy;
+  unsigned int maxx, maxy, bw, dd;
+
+  scr=i->scr;
+  maxx=scr->width; maxy=scr->height;
+  if(i->parent!=scr->back)
+    XGetGeometry(dpy, i->parent, &rt, &xx, &yy, &maxx, &maxy, &bw, &dd);
+  nx=i->x; ny=i->y;
+  for(i2=scr->icons; i2; i2=i2->next)
+    if(i2->parent==i->parent && i2!=i && i2->mapped &&
+       nx<i2->x+i2->width && nx+i->width>i2->x &&
+       ny<i2->y+i2->height+scr->lh+2 && ny+i->height+scr->lh+2>i2->y) {
+      ny=i2->y+i2->height+scr->lh+4;
+      if(ny+i->height+scr->lh+1>maxy) {
+	nx=i2->x+i2->width+5;
+	if(i->parent==scr->back && nx+i->width>maxx) {
+	  ny=maxy;
+	  break;
+	} else
+	  ny=scr->bh+4;
+      }
+      i2=scr->icons;
+      continue;
+    }
+
+  if(i->parent==scr->back) {
+    if(nx+i->width>maxx)
+      nx=maxx-i->width;
+    if(ny+i->height>maxy)
+      ny=maxy-i->height;
+    if(nx<0) nx=0;
+    if(ny<scr->bh) ny=scr->bh;
+  }
+  if(nx!=i->x || ny!=i->y)
+    XMoveWindow(dpy, w, i->x=nx, i->y=ny);
+  if(i->parent==scr->back) {
+    ws[0]=scr->menubar;
+    ws[1]=w;
+    ws[2]=lw;
+    XRestackWindows(dpy, ws, 3);
+  } else {
+    XRaiseWindow(dpy, lw);
+    XRaiseWindow(dpy, w);
+  }
+  XMoveWindow(dpy, lw, nx+(i->width>>1)-(i->labelwidth>>1),
+	      ny+i->height+1);
+}
+
+void destroyiconicon(Icon *i)
+{
+  if(i->innerwin) {
+    XUnmapWindow(dpy, i->innerwin);
+    XReparentWindow(dpy, i->innerwin, i->scr->root, i->x+4, i->y+4);
+    XRemoveFromSaveSet(dpy, i->innerwin);
+    i->innerwin=None;
+  }
+  i->iconpm = i->secondpm = i->maskpm = None;
+}
+
+static void setstdiconicon(Icon *i, unsigned int *w, unsigned int *h)
+{
+  Style *s;
+  if(i->client && (s=i->client->style) && s->icon_name) {
+    if(s->icon_pms.pm==None) {
+      Window r;
+      int x,y;
+      unsigned int b,d;
+      extern void load_do(const char *, struct IconPixmaps *);
+      load_do(s->icon_name, &s->icon_pms);
+      if(s->icon_pms.pm == None) {
+	fprintf(stderr, "%s: Cannot load icon \"%s\".\n",
+		progname, s->icon_name);
+	s->icon_name = NULL;
+      } else
+	XGetGeometry(dpy, s->icon_pms.pm, &r, &x, &y,
+		     &s->icon_pm_w, &s->icon_pm_h, &b, &d);
+    }
+    if(s->icon_pms.pm!=None) {
+      i->iconpm=s->icon_pms.pm;
+      i->secondpm=s->icon_pms.pm2;
+      i->maskpm=None;
+      *w=s->icon_pm_w+8;
+      *h=s->icon_pm_h+8;
+      return;
+    }
+  }
+  i->iconpm=scr->default_tool_pms.pm;
+  i->secondpm=scr->default_tool_pms.pm2;
+  i->maskpm=None;
+  *w=scr->default_tool_pm_w+8;
+  *h=scr->default_tool_pm_h+8;
+}
+
+void createiconicon(Icon *i, XWMHints *wmhints)
+{
+  XSetWindowAttributes attr;
+  int x=20, y=20;
+  unsigned int w=40, h=40;
+  Window win=None;
+  void newicontitle(Client *);
+
+  scr=i->scr;
+  if(wmhints && !prefs.customiconsonly) {
+    if((wmhints->flags&IconWindowHint) && wmhints->icon_window) {
+      Window r;
+      unsigned int b, d;
+      i->innerwin=win=wmhints->icon_window;
+      XGetGeometry(dpy, win, &r, &x, &y, &w, &h, &b, &d);
+      x-=4; y-=4; w+=8; h+=8;
+    } else if((wmhints->flags&IconPixmapHint) && wmhints->icon_pixmap) {
+      Window r;
+      int x, y;
+      unsigned int b, d;
+      i->iconpm=wmhints->icon_pixmap;
+      i->secondpm=None;
+      if(wmhints->flags&IconMaskHint)
+	i->maskpm = wmhints->icon_mask;
+      else
+	i->maskpm = None;
+      XGetGeometry(dpy, i->iconpm, &r, &x, &y, &w, &h, &b, &d);
+      w+=8;
+      h+=8;
+    } else
+      setstdiconicon(i, &w, &h);
+    if(wmhints->flags&IconPositionHint) {
+      x=wmhints->icon_x;
+      y=wmhints->icon_y;
+    } else if(i->window) {
+      Window r;
+      unsigned int w, h, bw, d;
+      XGetGeometry(dpy, i->window, &r, &x, &y, &w, &h, &bw, &d);
+    }
+  } else
+    setstdiconicon(i, &w, &h);
+
+  if(!(i->window)) {  
+    attr.override_redirect=True;
+    attr.background_pixel=scr->dri.dri_Pens[BACKGROUNDPEN];
+    i->window=XCreateWindow(dpy, scr->back, i->x=x, i->y=y,
+			    i->width=w, i->height=h, 0, CopyFromParent,
+			    InputOutput, CopyFromParent,
+			    CWOverrideRedirect|CWBackPixel, &attr);
+    i->mapped=0;
+    XSaveContext(dpy, i->window, icon_context, (XPointer)i);
+    XLowerWindow(dpy, i->window);
+    XSelectInput(dpy, i->window,ExposureMask|ButtonPressMask|ButtonReleaseMask);
+  } else {
+    XMoveResizeWindow(dpy, i->window, i->x=x, i->y=y, i->width=w, i->height=h);
+    if(i->mapped)
+      redrawicon(i, i->window);
+  }
+  if(!(i->labelwin)) {
+    i->labelwin=XCreateWindow(dpy, scr->back, 0, 0, 1, 1, 0,
+			      CopyFromParent, InputOutput, CopyFromParent,
+			      CWOverrideRedirect|CWBackPixel, &attr);
+    XSaveContext(dpy, i->labelwin, icon_context, (XPointer)i);
+    XLowerWindow(dpy, i->labelwin);
+    XSelectInput(dpy, i->labelwin, ExposureMask);
+  }
+  if(i->client)
+    newicontitle(i->client);
+  if((win=i->innerwin)) {
+    XAddToSaveSet(dpy, win);
+    XReparentWindow(dpy, win, i->window, 4, 4);
+    XSelectInput(dpy, win, SubstructureRedirectMask);
+    XMapWindow(dpy, win);
+  }
+  adjusticon(i);
+}
+
+void createicon(Client *c)
+{
+  XWMHints *wmhints;
+  Icon *i;
+
+  c->icon=i=(Icon *)calloc(1, sizeof(Icon));
+  i->scr=scr=c->scr;
+  i->client=c;
+  i->module=NULL;
+  i->next=scr->icons;
+  i->parent=scr->back;
+  scr->icons=i;
+
+  wmhints=XGetWMHints(dpy, c->window);
+  createiconicon(i, wmhints);
+  if(wmhints) XFree(wmhints);
+}
+
+Icon *createappicon(struct module *m, Window p, char *name,
+		    Pixmap pm1, Pixmap pm2, Pixmap pmm, int x, int y)
+{
+  Icon *i;
+  Client *c;
+  int tx, ty, ap=0;
+  unsigned int w, h, b, d;
+  Window r, ws[3];
+  XSetWindowAttributes attr;
+
+  if(x==NO_ICON_POSITION || y==NO_ICON_POSITION) {
+    x=0; y=0; ap++;
+  }
+
+  i=(Icon *)calloc(1, sizeof(Icon));
+  if(!XFindContext(dpy, p, client_context, (XPointer*)&c)) {
+    scr=c->scr;
+  } else
+    if(XFindContext(dpy, p, screen_context, (XPointer*)&scr))
+      scr=front;
+  if(p==scr->root) p=scr->back;
+
+  i->scr=scr;
+  i->client=NULL;
+  i->module=m;
+  i->next=scr->icons;
+  i->parent=p;
+  scr->icons=i;
+
+  i->iconpm=pm1;
+  i->secondpm=pm2;
+  i->maskpm=pmm;
+  XGetGeometry(dpy, i->iconpm, &r, &tx, &ty, &w, &h, &b, &d);
+  w+=8;
+  h+=8;
+
+  attr.override_redirect=True;
+  attr.background_pixel=scr->dri.dri_Pens[BACKGROUNDPEN];
+  i->window=XCreateWindow(dpy, p, i->x=x, i->y=y,
+			  i->width=w, i->height=h, 0, CopyFromParent,
+			  InputOutput, CopyFromParent,
+			  CWOverrideRedirect|CWBackPixel, &attr);
+  XSaveContext(dpy, i->window, icon_context, (XPointer)i);
+  XSelectInput(dpy, i->window,ExposureMask|ButtonPressMask|ButtonReleaseMask);
+
+  i->labelwin=XCreateWindow(dpy, p, 0, 0, 1, 1, 0,
+			    CopyFromParent, InputOutput, CopyFromParent,
+			    CWOverrideRedirect|CWBackPixel, &attr);
+  XSaveContext(dpy, i->labelwin, icon_context, (XPointer)i);
+  XSelectInput(dpy, i->labelwin, ExposureMask);
+
+#ifdef USE_FONTSETS
+  if((i->label=malloc(strlen(name)+1))!=NULL) {
+    strcpy(i->label, name);
+    i->labelwidth=XmbTextEscapement(labelfontset, i->label,
+				    strlen(i->label));
+#else
+  if((i->label.value=malloc((i->label.nitems=strlen(name))+1))!=NULL) {
+    strcpy((char *)i->label.value, name);
+    i->labelwidth=XTextWidth(labelfont, (char *)i->label.value,
+			     i->label.nitems);
+#endif
+    if(i->labelwidth)
+      XResizeWindow(dpy, i->labelwin, i->labelwidth, scr->lh);
+    XMoveWindow(dpy, i->labelwin,
+		i->x+(i->width>>1)-(i->labelwidth>>1),
+		i->y+i->height+1);
+  }
+
+  if(i->parent==scr->back) {
+    ws[0]=scr->menubar;
+    ws[1]=i->window;
+    ws[2]=i->labelwin;
+    XRestackWindows(dpy, ws, 3);
+  } else {
+    XRaiseWindow(dpy, i->labelwin);
+    XRaiseWindow(dpy, i->window);
+  }
+
+  if(ap) adjusticon(i);
+
+  i->mapped=1;
+  if(i->labelwidth)
+    XMapWindow(dpy, i->labelwin);
+  XMapWindow(dpy, i->window);
+
+  return i;
+}
+
+void rmicon(Icon *i)
+{
+  Icon *ii;
+
+  if (i->selected)
+    deselecticon(i);
+
+  if (i == i->scr->icons)
+    i->scr->icons = i->next;
+  else
+    if((ii = i->scr->icons))
+      for (; ii->next; ii = ii->next)
+	if (ii->next == i) {
+	  ii->next = i->next;
+	  break;
+	}
+
+  destroyiconicon(i);
+  XDestroyWindow(dpy, i->window);
+  XDeleteContext(dpy, i->window, icon_context);
+  if(i->labelwin) {
+    XDestroyWindow(dpy, i->labelwin);
+    XDeleteContext(dpy, i->labelwin, icon_context);
+  }
+#ifdef USE_FONTSETS
+  if(i->label)
+    free(i->label);
+#else
+  if(i->label.value)
+    if(i->module)
+      free(i->label.value);
+    else
+      XFree(i->label.value);
+#endif
+  free(i);
+}
+
+static int cmp_iconpos(const Icon **p1, const Icon **p2)
+{
+  int r;
+  return((r=(*p2)->mapped-(*p1)->mapped)?r:((r=(*p1)->x-(*p2)->x)?r:
+					    (*p1)->y-(*p2)->y));
+}
+
+static void placeicons(Icon **p, int n, int x, int w)
+{
+  int i;
+
+  x+=w>>1;
+  for(i=0; i<n; i++) {
+    Icon *i=*p++;
+    XMoveWindow(dpy, i->window, i->x=x-(i->width>>1), i->y);
+    XMoveWindow(dpy, i->labelwin, x-(i->labelwidth>>1),
+		i->y+i->height+1);
+  }
+}
+
+void cleanupicons()
+{
+  Icon *i, **icons;
+  int nicons=0, maxicons=16;
+
+  if((icons=calloc(maxicons, sizeof(Icon*)))) {
+    for(i=scr->icons; i; i=i->next)
+      if(i->window) {
+	if(nicons>=maxicons)
+	  if(!(icons=realloc(icons, sizeof(Icon*)*(maxicons<<=1))))
+	    return;
+	icons[nicons]=i;
+	i->x+=i->width>>1;
+	nicons++;
+      }
+    if(nicons) {
+      int i0=0, i, x=5, y=scr->bh+4, w, mw=0;
+      qsort(icons, nicons, sizeof(*icons),
+	    (int (*)(const void *, const void *))cmp_iconpos);
+      for(i=0; i<nicons; i++) {
+	if(i>i0 && y+icons[i]->height>scr->height-4-scr->lh) {
+	  placeicons(icons+i0, i-i0, x, mw);
+	  x+=mw+5;
+	  y=scr->bh+4;
+	  mw=0;
+	  i0=i;
+	}
+	icons[i]->y=y;
+	w=icons[i]->width;
+	if(icons[i]->mapped && icons[i]->labelwidth>w)
+	  w=icons[i]->labelwidth;
+	if(w>mw)
+	  mw=w;
+	y+=icons[i]->height+4+scr->lh;
+      }
+      placeicons(icons+i0, nicons-i0, x, mw);
+    }
+    free(icons);
+  }
+}
+
+void newicontitle(Client *c)
+{
+  Icon *i=c->icon;
+#ifdef USE_FONTSETS
+  XTextProperty prop;
+  if(i->label) {
+    free(i->label);
+    i->label = NULL;
+  }
+  if(XGetWMIconName(dpy, c->window, &prop) && prop.value) {
+    char **list;
+    int n;
+    if(XmbTextPropertyToTextList(dpy, &prop, &list, &n) >= Success) {
+      if(n > 0) {
+	if( prefs.shortlabelicons )
+	{
+	  if (strlen(list[0])>10){
+	    char *str1=list[0];
+	    char str2[11];
+	    strncpy (str2,str1,8);
+	    str2[8]='.';
+	    str2[9]='.';
+	    str2[10]='\0';
+	    i->label = strdup(str2);
+	  } else {
+	    i->label = strdup(list[0]);
+	  }
+	} else {
+	  i->label = strdup(list[0]);
+	}
+	i->labelwidth=XmbTextEscapement(labelfontset, i->label,
+					strlen(i->label));
+      }
+      XFreeStringList(list);
+    }
+    XFree(prop.value);
+  }
+  if(!i->label)
+    i->labelwidth = 0;
+#else
+  if(i->label.value)
+    XFree(i->label.value);
+  if(!(XGetWMIconName(dpy, c->window, &i->label))) {
+    i->label.value=NULL;
+    i->labelwidth=0;
+  } else
+    i->labelwidth=XTextWidth(labelfont, (char *)i->label.value,
+			     i->label.nitems);
+#endif
+  if(i->labelwidth)
+    XResizeWindow(dpy, i->labelwin, i->labelwidth, c->scr->lh);
+  if(i->mapped && i->labelwidth>0)
+    XMapWindow(dpy, i->labelwin);
+  else
+    XUnmapWindow(dpy, i->labelwin);
+  XMoveWindow(dpy, i->labelwin,
+	      i->x+(i->width>>1)-(i->labelwidth>>1),
+	      i->y+i->height+1);
+  if(i->mapped)
+    redrawicon(i, i->labelwin);
+}
+
+void free_icon_pms(struct IconPixmaps *pms)
+{
+  if(pms->pm!=None) XFreePixmap(dpy, pms->pm);
+  if(pms->pm2!=None) XFreePixmap(dpy, pms->pm2);
+  free_color_store(dpy, &pms->cs);
+  free_color_store(dpy, &pms->cs2);
+}
diff --git a/icon.h b/icon.h
new file mode 100644
index 0000000..9ca81f4
--- /dev/null
+++ b/icon.h
@@ -0,0 +1,43 @@
+#ifndef ICON_H
+#define ICON_H
+
+#include "client.h"
+#include "libami.h"
+
+struct _Scrn;
+typedef struct _Icon {
+  struct _Icon *next, *nextselected;
+  struct _Scrn *scr;
+  Client *client;
+  struct module *module;
+  Window parent, window, labelwin, innerwin;
+  Pixmap iconpm, secondpm, maskpm;
+#ifdef USE_FONTSETS
+  char *label;
+#else
+  XTextProperty label;
+#endif
+  int x, y, width, height;
+  int labelwidth;
+  int selected, mapped;
+} Icon;
+
+struct IconPixmaps
+{
+  Pixmap pm, pm2;
+  struct ColorStore cs, cs2;
+};
+
+extern void redrawicon(Icon *, Window);
+extern void rmicon(Icon *);
+extern void createicon(Client *);
+extern void createiconicon(Icon *i, XWMHints *);
+extern void destroyiconicon(Icon *);
+extern void cleanupicons();
+extern void createdefaulticons();
+extern void adjusticon(Icon *);
+extern void selecticon(Icon *);
+extern void deselecticon(Icon *);
+extern void free_icon_pms(struct IconPixmaps *pms);
+
+#endif
diff --git a/iconinfo.pl b/iconinfo.pl
new file mode 100755
index 0000000..6038c9d
--- /dev/null
+++ b/iconinfo.pl
@@ -0,0 +1,66 @@
+#!/usr/local/bin/perl
+
+sub chompstring {
+    my ($len, $rest)=unpack("Na*", $_[0]);
+    return unpack("a".$len."a*", $rest);
+}
+
+sub imginfo {
+    my ($left, $top, $width, $height, $depth, $pp, $poo, $rest) =
+	unpack("n5x4CCx4a*", $_[0]);
+
+    print "Image: ${width}x${height}+$left+$top $depth bit\n";
+
+    my $bpr=2*(($width+15)>>4);
+    my $imgsz=$bpr*$height*$depth;
+
+    return substr($rest, $imgsz);
+}
+
+
+%itypes=( 1=>disk, 2=>drawer, 3=>tool, 4=>project, 5=>garbage, 6=>device,
+	  7=>kick, 8=>appicon );
+undef $/; $i=<>;
+
+($magic, $version, $gad, $ty, $deftool, $tts, $x, $y, $drwdata, $toolwin, $stacksize, $rest) =
+    unpack("nna44CxNNNNNNNa*", $i);
+
+($left, $top, $width, $height, $flags, $activ, $gty, $gid, $gud) =
+    unpack("x4n7x20nN", $gad);
+
+if($x==0x80000000) { $x="no position"; }
+if($y==0x80000000) { $y="no position"; }
+
+printf "Magic: %04x  Version: %d  Revision: %d  Type: $itypes{$ty}\n", $magic, $version, $gud&0xff;
+print "X=$x, Y=$y, stacksize=$stacksize\n";
+printf "Gadget: ${width}x${height}+$left+$top flags=%04x, activ=%04x\n", $flags, $activ;
+
+if($drwdata!=0) {
+    ($left, $top, $width, $height, $panx, $pany, $rest) =
+	unpack("n4x40N2a*", $rest);
+    printf "Window: ${width}x${height}+$left+$top(+$panx+$pany)\n";
+}
+
+$rest=imginfo($rest);
+if($flags&2) { $rest=imginfo($rest); }
+
+if($deftool!=0) {
+    ($deftool, $rest)=chompstring($rest);
+    printf "Default tool: $deftool\n";
+}
+if($tts) {
+    ($arraybytes, $rest)=unpack("Na*", $rest);
+    for(2..$arraybytes>>2) {
+	($tooltype, $rest)=chompstring($rest);
+	print "ToolType: $tooltype\n";
+    }
+}
+if($toolwin) {
+    ($toolwin, $rest)=chompstring($rest);
+    print "ToolWin: $toolwin\n";
+}
+if($drwdata!=0 and $version>0) {
+    ($wflags, $vmodes, $rest)=unpack("Nna*", $rest);
+    printf "Window: flags=%08x viewmodes=%04x\n",$wflags,$vmodes;
+}
+printf "%d bytes remaining.\n", length($rest);
diff --git a/install-sh b/install-sh
new file mode 100755
index 0000000..ab74c88
--- /dev/null
+++ b/install-sh
@@ -0,0 +1,238 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+#
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+tranformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0
diff --git a/intui_look.txt b/intui_look.txt
new file mode 100644
index 0000000..dd0f79a
--- /dev/null
+++ b/intui_look.txt
@@ -0,0 +1,157 @@
+
+wwwwwwwwwwwwwwwwwww          wwwwww
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkbbb .XX....  ..|||k
+bkwbbbbbbbbbbbkkkkk .XXXXXX
+bkwbbbbbbbbbbbbbbbb .......
+bkwbbbbbbbbbbbbbbbb
+kkkkkkkkkkkkkkkkkkk
+
+H=48
+h=11
+HH=78
+
+
+ 0        -------    0    --------    0    -----------   0        ---------   0    ---------
+
+14(3)[23] -------    9(2) --------    9(2) ----------- > 8(2)[12]<---------  32(2) ---------
+           close            zoom              depth                 icon1            icon2
+33(7)[54] -------   24(5) --------   19(4) -----------  35(4)     ---------  35(4) ---------
+
+47        -------   38(8) --------   28(6) -----------  37(6)     ---------  37(6) ---------
+
+                    47    --------   38(8) ----------- >39(8)[65]<--------- >39(8)<---------
+
+                                     47    -----------  47        ---------  47    ---------
+
+
+h0  0  0  0      i1h1  8(2) [h1-e]
+h2  9  2  1/5    i1h2 39(8) [h7+e]
+h3 14  3  3/10
+h4 19  4  2/5
+h5 24  5  1/2
+h6 28  6  3/5
+h7 33  7  7/10
+h8 38  8  4/5
+h10 47 10  0-e
+
+
+h0 0/10
+h2 2/10
+h3 3/10
+h4 4/10
+h5 5/10
+h6 6/10
+h7 7/10
+h8 8/10
+h10 10/10-e
+
+ 0 *
+ 1
+ 2
+ 3
+ 4             10
+ 5            9
+ 6          78
+ 7
+ 8         6
+ 9 *      5    10
+10            9
+11
+12       4   8
+13          7
+14 *           10
+15
+16      3  6  9
+17
+18           8
+19 *      5    10      0 *
+20          7          1       678910
+21            9        2 *   45  8910
+22                     3 *  3  67 910
+23                     4 *    5 78910
+24 *   2 4 6 8 10      5 * 2 4 6 8 10
+25                     6 *    5 78910
+26            9        7 *  3  67 910
+27          7          8 *   45  8910
+28 *      5    10      9       678910
+29                    10 *
+30           8
+31
+32      3  6  9
+33 *           10
+34          7
+35
+36       4   8
+37            9
+38 *      5    10
+39
+40         6
+41          7
+42           89
+43             10
+44
+45
+46
+47 *
+
+
+
+
+wwwwwwwwwwwwwwwwwwwwwwwwwww        wwKKKKKKKKKKKKKKKKKKKKKKKww
+bkwbbbbbbbbbbbbbbbbbbbbbkwb x7(1)  bkKbbbbbbbbbbbbbbbbbbbbbWwb x31(1)
+bkwbbbbkkkkkkkkkkkkkbbbbkwb        bkKbbbbkkkkkkkkkkkkkbbbbWwb
+bkwbbbbkbbbbbbbbbbbkbbbbkwb x26(1) bkKbbbbkbbbbbbbbbbbkbbbbWwb x2(1) (2 if h>11)
+bkwbbbbkbkkkkbbbbbbkbbbbkwb        bkKbbbbkbkkkkbbbbbbkbbbbWwb
+bkwbbbbkbkwwkbbbbbbkbbbbkwb x1     bkKbbbbkbkwwkbbbbbbkbbbbWwb x1
+bkwbbbbkbkkkkbbbbbbkbbbbkwb        bkKbbbbkbkkkkbbbbbbkbbbbWwb
+bkwbbbbkbbbbbbbbbbbkbbbbkwb x1     bkKbbbbkbbbbbbbbbbbkbbbbWwb x1
+bkwbbbbkkkkkkkkkkkkkbbbbkwb        bkKbbbbkkkkkkkkkkkkkbbbbWwb
+bkwbbbbbbbbbbbbbbbbbbbbbkwb x7(1)  bkKbbbbbbbbbbbbbbbbbbbbbWwb x7(1)
+kkkkkkkkkkkkkkkkkkkkkkkkkkk        kkWWWWWWWWWWWWWWWWWWWWWWWkk
+
+
+wwwwwwwwwwwwwwwwwwwwww        wwwwwwwwwwwwwwwwwwwwwwwwwww        wwwwwwwwwwwwwwwwwwwwwwwww
+wbbbbbbbbbbbbbbbbbkwbb x13(2) bkwbbbbbbbbbbbbbbbbbbbbbkwb x8(1)  bkwbbbbbbbbbbbbbbbbbbbbbk x8(1)
+wbbbbbbkkkkkbbbbbbkwbb        bkwbbbbkkkkkkkkkkkkkbbbbkwb        bkwbbbkkkkkkkkkkkbbbbbbbk
+wbbbbbbkwwwkbbbbbbkwbb x18(3) bkwbbbbkkwwwkkbbbbbkbbbbkwb x14(2) bkwbbbk         kbbbbbbbk x9(1)
+wbbbbbbkkkkkbbbbbbkwbb        bkwbbbbkkkkkkkbbbbbkbbbbkwb        bkwbbbk   kkkkkkkkkkkbbbk
+wbbbbbbbbbbbbbbbbbkwbb x13(2) bkwbbbbkbbbbbbbbbbbkbbbbkwb x13(2) bkwbbbk   kwwwwwwwwwkbbbk x8(1)
+wkkkkkkkkkkkkkkkkkkkkk        bkwbbbbkkkkkkkkkkkkkbbbbkwb        bkwbbbkkkkkwwwwwwwwwkbbbk
+wbbk                          bkwbbbbbbbbbbbbbbbbbbbbbkwb x8(1)  bkwbbbbbbbkwwwwwwwwwkbbbk x9(1)
+wbbk                          kkkkkkkkkkkkkkkkkkkkkkkkkkk        bkwbbbbbbbkkkkkkkkkkkbbbk
+                                                                 bkwbbbbbbbbbbbbbbbbbbbbbk x8(1)
+                                                                 kkkkkkkkkkkkkkkkkkkkkkkkk
+                                                                                      wbbk
+
+KKKKKKKKKKKKKKKKKKKwww        wwKKKKKKKKKKKKKKKKKKKKKKKww        wwKKKKKKKKKKKKKKKKKKKKKKK
+KbbbbbbbbbbbbbbbbbWwbb x13(2) bkKbbbbbbbbbbbbbbbbbbbbbWwb x8(1)  bkKbbbbbbbbbbbbbbbbbbbbbW x8(1)
+KbbbbbbkkkkkbbbbbbWwbb        bkKbbbbkkkkkkkkkkkkkbbbbWwb        bkKbbbkkkkkkkkkkkbbbbbbbW
+Kbbbbbbk···kbbbbbbWwbb x18(3) bkKbbbbkkBBBkkWWWWWkbbbbWwb x14(2) bkKbbbk         kbbbbbbbW x9(1)
+KbbbbbbkkkkkbbbbbbWwbb        bkKbbbbkkkkkkkWWWWWkbbbbWwb        bkKbbbk   kkkkkkkkkkkbbbW
+KbbbbbbbbbbbbbbbbbWwbb x13(2) bkKbbbbkWWWWWWWWWWWkbbbbWwb x13(2) bkKbbbk   kwwwwwKwwwkbbbW x8(1)
+wWWWWWWWWWWWWWWWWWWkkk        bkKbbbbkkkkkkkkkkkkkbbbbWwb        bkKbbbkkkkkKKKKKKwwwkbbbW
+wbbk                          bkKbbbbbbbbbbbbbbbbbbbbbWwb x8(1)  bkKbbbbbbbkwwwwwwwwwkbbbW x9(1)
+wbbk                          kkWWWWWWWWWWWWWWWWWWWWWWWkk        bkKbbbbbbbkkkkkkkkkkkbbbW
+                                                                 bkKbbbbbbbbbbbbbbbbbbbbbW x8(1)
+                                                                 kkWWWWWWWWWWWWWWWWWWWWWWW
+                                                                                      wbbk
+
+
+                        wbbbbbbbbbbbbbbbbk
+                    wwwwwwwwwwwwwwwwwwwwwk
+                      bbwbbbbbbbbbbbbbbbbk
+                       bwbbbbbbbbbbbkkkbbk
+                        wbbbbbbbbbkkwwkbbk
+                        wbbbbbbbkkwwwwkbbk
+wbbk                    wbbbbbkkwwwwwwkbbk
+wbbk                    wbbbkkwwwwwwwwkbbk
+wbbk                    wbbbkkkkkkkkkkkbbk
+wbbkwwwwwwwwwwww      wwwbbbbbbbbbbbbbbbbk
+wkkkkkkkkkkkkkkk      kkkkkkkkkkkkkkkkkkkk
+
+
diff --git a/joke_fs.c b/joke_fs.c
new file mode 100644
index 0000000..ef9ba75
--- /dev/null
+++ b/joke_fs.c
@@ -0,0 +1,390 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "libami.h"
+#include "drawinfo.h"
+
+#ifdef BSD_STYLE_GETTIMEOFDAY
+#define GETTIMEOFDAY(tp) gettimeofday(tp, NULL)
+#else
+#define GETTIMEOFDAY(tp) gettimeofday(tp)
+#endif
+
+#define FIXUPTV(tv) { \
+    while((tv).tv_usec<0) { (tv).tv_usec+=1000000; (tv).tv_sec--; } \
+    while((tv).tv_usec>=1000000) { (tv).tv_usec-=1000000; (tv).tv_sec++; } \
+}
+
+#define BIN_PREFIX AMIWM_HOME"/"
+
+#define NFMT 2
+
+char fmt[NFMT+2][80];
+int fmtw[NFMT];
+
+
+Display *dpy;
+char *progname;
+unsigned long color_scheme[2];
+int scr, coloralloc, state=0;
+Window root, win, win2;
+Colormap cmap;
+GC gc;
+XFontStruct *font;
+int gh, gw, ascent;
+char *rcpath = BIN_PREFIX"requestchoice";
+char *rcmsg = "Notice";
+Pixmap disk_icon1, disk_icon2;
+struct ColorStore colorstore1, colorstore2;
+struct DrawInfo dri;
+Atom appiconmsg;
+char *currentdir = NULL;
+XContext dircontext;
+int my_in_fd, my_out_fd;
+
+void load_diskicon()
+{
+  struct DiskObject *disk_do;
+
+  disk_do = GetDefDiskObject(1/*WBDISK*/);
+  if(disk_do == NULL)
+    disk_do = GetDefDiskObject(2/*WBDRAWER*/);
+  if(disk_do == NULL)
+    disk_do = GetDefDiskObject(3/*WBTOOL*/);
+  if(disk_do == NULL) {
+    md_errormsg(md_root, "Failed to load disk icon");
+    md_exit(0);
+  }
+  disk_icon1 =
+    md_image_to_pixmap(md_root, dri.dri_Pens[BACKGROUNDPEN],
+		       (struct Image *)disk_do->do_Gadget.GadgetRender,
+		       disk_do->do_Gadget.Width, disk_do->do_Gadget.Height,
+		       &colorstore1);
+
+  disk_icon2 =
+    md_image_to_pixmap(md_root, dri.dri_Pens[BACKGROUNDPEN],
+		       (struct Image *)disk_do->do_Gadget.SelectRender,
+		       disk_do->do_Gadget.Width, disk_do->do_Gadget.Height,
+		       &colorstore2);
+
+  FreeDiskObject(disk_do);
+  XSync(dpy, False);
+}
+
+void broker_cb(XEvent *evt, unsigned long mask)
+{
+  XPointer ret;
+
+  if(evt->type != ClientMessage || evt->xclient.message_type != appiconmsg)
+    return;
+
+  if(!XFindContext(dpy, evt->xclient.window, dircontext, &ret))
+    currentdir = (char*)ret;
+}
+
+void create_broker()
+{
+  cx_broker(0, broker_cb);
+}
+
+void create_baseicons(char *dirs)
+{
+  char *dir, *dup = malloc(strlen(dirs)+1);
+  if(dup == NULL)
+    return;
+  strcpy(dup, dirs);
+  for(dir=strtok(dup, ":"); dir; dir=strtok(NULL, ":")) {
+    Window win = md_create_appicon(md_root, 0x80000000, 0x80000000,
+				   dir, disk_icon1, disk_icon2, None);
+    XSaveContext(dpy, win, dircontext, (XPointer)dir);
+  }
+  free(dup);
+}
+
+void migrate(int amount)
+{
+  Window r, p, *c = NULL;
+  unsigned int i, nc;
+  if(XQueryTree(dpy, root, &r, &p, &c, &nc)) {
+    XWarpPointer(dpy, None, None, 0, 0, 0, 0, 0, amount);
+    for(i=0; i<nc; i++) {
+      int x,y;
+      unsigned int w, h, bw, d;
+      if(XGetGeometry(dpy, c[i], &r, &x, &y, &w, &h, &bw, &d)) {
+	XMoveWindow(dpy, c[i], x, y+amount);
+      }
+    }
+  }
+  if(c != NULL)
+    XFree(c);
+}
+
+void activate()
+{
+  Window r, ch;
+  int x, y, wx, wy;
+  unsigned int m;
+  XGrabServer(dpy);
+  migrate(gh);
+  XMoveWindow(dpy, win, 0, 0);
+  XMapRaised(dpy, win);
+  XQueryPointer(dpy, win, &r, &ch, &x, &y, &wx, &wy, &m);
+  XMoveResizeWindow(dpy, win2, x, y, 1, 1);
+  XMapRaised(dpy, win2);
+  XGrabPointer(dpy, win, False, ButtonPressMask, GrabModeAsync, GrabModeSync, win2, None, CurrentTime);
+}
+
+void deactivate()
+{
+  XUngrabPointer(dpy, CurrentTime);
+  XUnmapWindow(dpy, win2);
+  XUnmapWindow(dpy, win);
+  migrate(-gh);
+  XUngrabServer(dpy);
+}
+
+void install_kw(char *dst, char *src)
+{
+  int i, n = strlen(src);
+  for(i=0; i<2*n; i+=2) {
+    char c = src[(i>=n? i-n+1:i)];
+    if((c>'@' && c<'[')||(c>'`' && c<'{'))
+      c = (c&0xe0)|((((c&0x1f)+12)%26)+1);
+    *dst++ = c;
+  }
+  *dst = '\0';
+}
+
+void setup()
+{
+  XWindowAttributes attr;
+  XSetWindowAttributes nw;
+  XGCValues gcv;
+  XColor clr;
+  int i;
+
+  dircontext = XUniqueContext();
+  XGetWindowAttributes(dpy, root, &attr);
+  cmap = attr.colormap;
+  coloralloc = 0;
+  color_scheme[0] = BlackPixel(dpy, scr);
+  clr.flags = DoRed|DoGreen|DoBlue;
+  clr.red = ~0;
+  clr.green = 0;
+  clr.blue = 0;
+  if(XAllocColor(dpy, cmap, &clr)) {
+    color_scheme[1] = clr.pixel;
+    coloralloc = 1;
+  } else
+    color_scheme[1] = WhitePixel(dpy, scr);
+  nw.background_pixel = color_scheme[0];
+  nw.border_pixel = color_scheme[1];
+  nw.backing_store = NotUseful;
+  nw.save_under = False;
+  nw.event_mask = ExposureMask|ButtonPressMask;
+  nw.override_redirect = True;
+  nw.colormap = cmap;
+  nw.cursor = None;
+  install_kw(fmt[0], "Fsbgs gzjbnhefrr  Sonhvgyghbear .g b   pCbeargfvfa hyrr.");
+  win = XCreateWindow(dpy, root, 0, 0, gw = attr.width, gh = 84, 0,
+		      attr.depth, InputOutput, attr.visual,
+		      CWBackPixel|CWBorderPixel|CWBackingStore|CWSaveUnder|
+		      CWEventMask|CWOverrideRedirect|CWColormap|CWCursor, &nw);
+  install_kw(fmt[1], "T0h0e0h0 0Z0r0q4v.g0n0g0v0bNaO 7#8");
+  win2 = XCreateWindow(dpy, root, 0, 0, 1, 1, 0, 0, InputOnly,
+		       attr.visual, CWOverrideRedirect, &nw);
+  install_kw(fmt[2], "NYC!E!V!Y\n' F   S:B-B)");
+  font = XLoadQueryFont(dpy, "-*-courier-bold-r-normal--14-*-*-*-*-*-iso8859-1");
+  if(font == NULL)
+    font = XLoadQueryFont(dpy, "fixed");
+  install_kw(fmt[3], "Ubrqu ,w btxbr");
+  gcv.font = font->fid;
+  gc = XCreateGC(dpy, win, GCFont, &gcv);
+
+  for(i=0; i<NFMT; i++) {
+    int dir, d;
+    XCharStruct o;
+    XTextExtents(font, fmt[i], strlen(fmt[i]), &dir, &ascent, &d, &o);
+    fmtw[i] = o.width;
+  }
+
+  XGetWindowAttributes(dpy, md_root, &attr);
+  init_dri(&dri, dpy, md_root, attr.colormap, False);
+
+  appiconmsg = XInternAtom(dpy, "AMIWM_APPICONMSG", False);
+}
+
+void post(char **msg)
+{
+  int pid;
+
+  msg[0]=rcpath;
+  msg[1]=rcmsg;  
+  if(!(pid=fork())) {
+    int of = open("/dev/null", O_WRONLY);
+    if(my_in_fd>=0)
+      close(my_in_fd);
+    if(my_out_fd>=0 && my_out_fd != my_in_fd)
+      close(my_out_fd);
+    if(of>=0) {
+      if(of!=1) dup2(of, 1);
+      if(of!=2) dup2(of, 2);
+    }
+    execv(msg[0], msg);
+    perror("execv");
+    _exit(1);
+  } else if(pid<0) {
+    perror("fork");
+    exit(1);
+  }
+}
+
+void cleanup()
+{
+  XFreeGC(dpy, gc);
+  XFreeFont(dpy, font);
+  XDestroyWindow(dpy, win);
+  XDestroyWindow(dpy, win2);
+  if(coloralloc)
+    XFreeColors(dpy, cmap, color_scheme+1, 1, 0);
+}
+
+void post_cleanup()
+{
+  char *clu[5];
+  int i;
+  for(i=0; i<4; i++)
+    clu[i]=fmt[i];
+  clu[4]=NULL;
+  post(clu);
+}
+
+void redraw()
+{
+  int i;
+  if(state)
+    XSetForeground(dpy, gc, color_scheme[1]);
+  else
+    XSetForeground(dpy, gc, color_scheme[0]);
+  XFillRectangle(dpy, win, gc, 2, 2, 8, gh-4);
+  XFillRectangle(dpy, win, gc, gw-10, 2, 8, gh-4);
+  XFillRectangle(dpy, win, gc, 2, 2, gw-4, 8);
+  XFillRectangle(dpy, win, gc, 2, gh-10, gw-4, 8);
+  if(!state)
+    XSetForeground(dpy, gc, color_scheme[1]);
+  for(i=0; i<NFMT; i++)
+    XDrawString(dpy, win, gc, (gw-fmtw[i])>>1, 22+i*26+ascent,
+		fmt[i], strlen(fmt[i]));
+}
+
+int main(int argc, char *argv[])
+{
+  int x_fd, cnt=0;
+  fd_set rfd_set;
+  struct timeval nextt;
+  char *basedir;
+
+  progname = argv[0];
+
+  basedir = md_init(argc, argv);
+  if(basedir == NULL)
+    basedir = "/";
+
+  my_in_fd=strtol(argv[1], NULL, 0);
+  my_out_fd=strtol(argv[2], NULL, 0);
+
+  if(!(dpy = md_display())) {
+    fprintf(stderr, "%s: cannot connect to X server %s\n", progname,
+	    XDisplayName(NULL));
+    exit(1);
+  }
+  scr = DefaultScreen(dpy);
+  root = RootWindow(dpy, scr);
+
+  x_fd = ConnectionNumber(dpy);
+
+  setup();
+  load_diskicon();
+  create_broker();
+  create_baseicons(basedir);
+
+  do
+    md_process_queued_events();
+  while(currentdir == NULL && md_handle_input()>=0);
+  activate();
+  XSync(dpy, False);
+
+  GETTIMEOFDAY(&nextt);
+  for(;;) {
+    XEvent event;
+    struct timeval t;
+
+    while(QLength(dpy)>0) {
+      XNextEvent(dpy, &event);
+      switch(event.type) {
+      case Expose:
+	redraw();
+	break;
+      case ButtonPress:
+	cnt = 999;
+	break;
+      }
+    }
+    FD_ZERO(&rfd_set);
+    FD_SET(x_fd, &rfd_set);
+
+    GETTIMEOFDAY(&t);
+    t.tv_sec = nextt.tv_sec - t.tv_sec;
+    t.tv_usec = nextt.tv_usec - t.tv_usec;
+    FIXUPTV(t);
+    while(t.tv_sec<0) {
+      state = !state;
+      cnt++;
+      redraw();
+      t.tv_usec += 800000;
+      nextt.tv_usec += 800000;
+      FIXUPTV(nextt);
+      FIXUPTV(t);
+    }
+    
+    XFlush(dpy);
+    if(cnt>=16)
+      break;
+    if(select(x_fd+1, &rfd_set, NULL, NULL, &t)<0) {
+      perror("select");
+      break;
+    } 
+
+    if(FD_ISSET(x_fd, &rfd_set))
+      XPeekEvent(dpy, &event);
+  }
+
+  deactivate();
+  cleanup();
+
+  post_cleanup();
+
+  XCloseDisplay(dpy);
+  md_exit(0);
+  return 0;
+}
diff --git a/kbdlexer.c b/kbdlexer.c
new file mode 100644
index 0000000..7335a43
--- /dev/null
+++ b/kbdlexer.c
@@ -0,0 +1,1971 @@
+int yywrap() { return 1; }
+
+#line 2 "<stdout>"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 3
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+    #define yy_create_buffer yy_create_buffer
+
+    #define yy_delete_buffer yy_delete_buffer
+
+    #define yy_scan_buffer yy_scan_buffer
+
+    #define yy_scan_string yy_scan_string
+
+    #define yy_scan_bytes yy_scan_bytes
+
+    #define yy_init_buffer yy_init_buffer
+
+    #define yy_flush_buffer yy_flush_buffer
+
+    #define yy_load_buffer_state yy_load_buffer_state
+
+    #define yy_switch_to_buffer yy_switch_to_buffer
+
+    #define yypush_buffer_state yypush_buffer_state
+
+    #define yypop_buffer_state yypop_buffer_state
+
+    #define yyensure_buffer_stack yyensure_buffer_stack
+
+    #define yylex yylex
+
+    #define yyrestart yyrestart
+
+    #define yylex_init yylex_init
+
+    #define yylex_init_extra yylex_init_extra
+
+    #define yylex_destroy yylex_destroy
+
+    #define yyget_debug yyget_debug
+
+    #define yyset_debug yyset_debug
+
+    #define yyget_extra yyget_extra
+
+    #define yyset_extra yyset_extra
+
+    #define yyget_in yyget_in
+
+    #define yyset_in yyset_in
+
+    #define yyget_out yyget_out
+
+    #define yyset_out yyset_out
+
+    #define yyget_leng yyget_leng
+
+    #define yyget_text yyget_text
+
+    #define yyget_lineno yyget_lineno
+
+    #define yyset_lineno yyset_lineno
+
+    #define yywrap yywrap
+
+    #define yyalloc yyalloc
+
+    #define yyrealloc yyrealloc
+
+    #define yyfree yyfree
+
+    #define yytext yytext
+
+    #define yyleng yyleng
+
+    #define yyin yyin
+
+    #define yyout yyout
+
+    #define yy_flex_debug yy_flex_debug
+
+    #define yylineno yylineno
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart(yyin  )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+extern int yyleng;
+
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+    
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = (yy_hold_char); \
+		YY_RESTORE_YY_MORE_OFFSET \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, (yytext_ptr)  )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = NULL;
+static int yy_init = 0;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart ( FILE *input_file  );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
+void yy_delete_buffer ( YY_BUFFER_STATE b  );
+void yy_flush_buffer ( YY_BUFFER_STATE b  );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state ( void );
+
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
+
+void *yyalloc ( yy_size_t  );
+void *yyrealloc ( void *, yy_size_t  );
+void yyfree ( void *  );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+typedef flex_uint8_t YY_CHAR;
+
+FILE *yyin = NULL, *yyout = NULL;
+
+typedef int yy_state_type;
+
+extern int yylineno;
+int yylineno = 1;
+
+extern char *yytext;
+#ifdef yytext_ptr
+#undef yytext_ptr
+#endif
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg  );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	(yytext_ptr) = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	(yy_hold_char) = *yy_cp; \
+	*yy_cp = '\0'; \
+	(yy_c_buf_p) = yy_cp;
+#define YY_NUM_RULES 8
+#define YY_END_OF_BUFFER 9
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[18] =
+    {   0,
+        0,    0,    9,    7,    6,    6,    7,    3,    4,    7,
+        5,    0,    1,    3,    0,    2,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    1,    4,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    6,    1,    7,
+        1,    8,    1,    1,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        1,    1,    1,    1,    1,    1,    5,    5,    5,    5,
+
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    1,    9,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[10] =
+    {   0,
+        1,    1,    2,    1,    1,    1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[20] =
+    {   0,
+        0,    0,   19,   20,   20,   20,   15,   12,   20,    8,
+       20,   12,   20,    9,    5,   20,   20,    9,   11
+    } ;
+
+static const flex_int16_t yy_def[20] =
+    {   0,
+       17,    1,   17,   17,   17,   17,   18,   17,   17,   19,
+       17,   18,   17,   17,   19,   17,    0,   17,   17
+    } ;
+
+static const flex_int16_t yy_nxt[30] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,    4,   11,   12,
+       12,   15,   16,   14,   13,   16,   14,   13,   17,    3,
+       17,   17,   17,   17,   17,   17,   17,   17,   17
+    } ;
+
+static const flex_int16_t yy_chk[30] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,   18,
+       18,   19,   15,   14,   12,   10,    8,    7,    3,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "kbdlexer.l"
+#line 2 "kbdlexer.l"
+#include <X11/Xmu/CharSet.h>
+#include <string.h>
+
+#include "libami.h"
+#include "kbdmodule.h"
+
+unsigned char *inptr;
+extern char *progname;
+
+#ifdef FLEX_SCANNER
+
+#undef YY_INPUT
+#define YY_INPUT(buf,result,size) ((result) = doinput((buf),(size)))
+int doinput (char *buf, int size)
+{
+  int l=strlen((char *)inptr);
+  if(l>size) l=size;
+  if(l>0) {
+    memcpy(buf, inptr, l);
+    inptr+=l;
+  }
+  return l;
+}
+#endif
+
+static void k_rotscreens(Window w)
+{
+  Window root;
+  int x, y;
+  unsigned int width, height, bw, d;
+  if(XGetGeometry(md_display(), w, &root, &x, &y, &width, &height, &bw, &d))
+    md_rotate_screen(root);
+}
+
+typedef void (*mdfuncp)(Window);
+
+int parse_keyword(char *str, YYSTYPE *val)
+{
+   struct { char *name; mdfuncp func; } functab[] = {
+     { "back", (mdfuncp)md_back },
+     { "front", (mdfuncp)md_front },
+     { "iconify", (mdfuncp)md_iconify },
+     { "rotatescreens", (mdfuncp)k_rotscreens },
+   };
+#define N_FUNC (sizeof(functab)/sizeof(functab[0]))
+   struct { char *name; int token, num; } kwtab[] = {
+     { "all", WHEREABOUTS, IN_ANYTHING_MASK },
+     { "b1", MODIFIER, Button1Mask },
+     { "b2", MODIFIER, Button2Mask },
+     { "b3", MODIFIER, Button3Mask },
+     { "b4", MODIFIER, Button4Mask },
+     { "b5", MODIFIER, Button5Mask },
+     { "button1", MODIFIER, Button1Mask },
+     { "button2", MODIFIER, Button2Mask },
+     { "button3", MODIFIER, Button3Mask },
+     { "button4", MODIFIER, Button4Mask },
+     { "button5", MODIFIER, Button5Mask },
+     { "control", MODIFIER, ControlMask },
+     { "frame", WHEREABOUTS, IN_FRAME_MASK },
+     { "icon", WHEREABOUTS, IN_ICON_MASK },
+     { "lock", MODIFIER, LockMask },
+     { "m", META, 0 },
+     { "m1", MODIFIER, Mod1Mask },
+     { "m2", MODIFIER, Mod2Mask },
+     { "m3", MODIFIER, Mod3Mask },
+     { "m4", MODIFIER, Mod4Mask },
+     { "m5", MODIFIER, Mod5Mask },
+     { "meta", META, 0 },
+     { "mod1", MODIFIER, Mod1Mask },
+     { "mod2", MODIFIER, Mod2Mask },
+     { "mod3", MODIFIER, Mod3Mask },
+     { "mod4", MODIFIER, Mod4Mask },
+     { "mod5", MODIFIER, Mod5Mask },
+     { "root", WHEREABOUTS, IN_ROOT_MASK },
+     { "shift", MODIFIER, ShiftMask },
+     { "window", WHEREABOUTS, IN_WINDOW_MASK },
+   };
+#define N_KW (sizeof(kwtab)/sizeof(kwtab[0]))
+  int l=0, h=N_FUNC-1;
+  
+  XmuCopyISOLatin1Lowered (str, str);
+  while(h>=l) {
+    int i=(h+l)>>1, c=strcmp(str, functab[i].name);
+    if(!c) {
+      val->function=functab[i].func;
+      return FUNCTION;
+    } else if(c>=0)
+      l=i+1;
+    else
+      h=i-1;
+  }
+  l=0; h=N_KW-1;
+  while(h>=l) {
+    int i=(h+l)>>1, c=strcmp(str, kwtab[i].name);
+    if(!c) {
+      val->num=kwtab[i].num;
+      return kwtab[i].token;
+    } else if(c>=0)
+      l=i+1;
+    else
+      h=i-1;
+  }
+  return ERRORTOKEN;
+}
+
+#line 625 "<stdout>"
+#line 626 "<stdout>"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals ( void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( void );
+
+int yyget_debug ( void );
+
+void yyset_debug ( int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra ( void );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in ( void );
+
+void yyset_in  ( FILE * _in_str  );
+
+FILE *yyget_out ( void );
+
+void yyset_out  ( FILE * _out_str  );
+
+			int yyget_leng ( void );
+
+char *yyget_text ( void );
+
+int yyget_lineno ( void );
+
+void yyset_lineno ( int _line_number  );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( void );
+#else
+extern int yywrap ( void );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+    
+    static void yyunput ( int c, char *buf_ptr  );
+    
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * );
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( void );
+#else
+static int input ( void );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer(yyin,YY_BUF_SIZE );
+		}
+
+		yy_load_buffer_state( );
+		}
+
+	{
+#line 108 "kbdlexer.l"
+
+
+#line 846 "<stdout>"
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = (yy_c_buf_p);
+
+		/* Support of yytext. */
+		*yy_cp = (yy_hold_char);
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = (yy_start);
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				(yy_last_accepting_state) = yy_current_state;
+				(yy_last_accepting_cpos) = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 18 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 20 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = (yy_hold_char);
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			goto yy_find_action;
+
+case 1:
+/* rule 1 can match eol */
+YY_RULE_SETUP
+#line 110 "kbdlexer.l"
+{ ; }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 112 "kbdlexer.l"
+{ *((char*)strchr(yytext, '>'))=0;
+		  yylval.keysym=XStringToKeysym(yytext+1);
+		  if(yylval.keysym == 0) {
+                    fprintf(stderr, "%s: ignoring unknown keysym: %s\n",
+                            progname, yytext+1);
+		  } else
+		    return KEYSYM;
+		}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 121 "kbdlexer.l"
+{ int token = parse_keyword(yytext, &yylval);
+                  if(token == ERRORTOKEN) {
+                    fprintf(stderr, "%s: ignoring unknown keyword: %s\n",
+                            progname, yytext);
+                  } else
+                    return token;
+                }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 129 "kbdlexer.l"
+{ return COLON; }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 131 "kbdlexer.l"
+{ return BAR; }
+	YY_BREAK
+case 6:
+/* rule 6 can match eol */
+YY_RULE_SETUP
+#line 133 "kbdlexer.l"
+{ ; }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 135 "kbdlexer.l"
+{ fprintf(stderr, "%s: illegal character \"%s\" ignored\n",
+                          progname, yytext); }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 137 "kbdlexer.l"
+ECHO;
+	YY_BREAK
+#line 959 "<stdout>"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = (yy_hold_char);
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state(  );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++(yy_c_buf_p);
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = (yy_c_buf_p);
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer(  ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				(yy_did_buffer_switch_on_eof) = 0;
+
+				if ( yywrap( ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				(yy_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = (yytext_ptr);
+	int number_to_move, i;
+	int ret_val;
+
+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2)  );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	if ( (yy_n_chars) == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart(yyin  );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+	}
+
+	(yy_n_chars) += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (void)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    
+	yy_current_state = (yy_start);
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			(yy_last_accepting_state) = yy_current_state;
+			(yy_last_accepting_cpos) = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 18 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+	int yy_is_jam;
+    	char *yy_cp = (yy_c_buf_p);
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		(yy_last_accepting_state) = yy_current_state;
+		(yy_last_accepting_cpos) = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 18 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 17);
+
+		return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp )
+{
+	char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
+
+	/* undo effects of setting up yytext */
+	*yy_cp = (yy_hold_char);
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = (yy_n_chars) + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+	(yytext_ptr) = yy_bp;
+	(yy_hold_char) = *yy_cp;
+	(yy_c_buf_p) = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (void)
+#else
+    static int input  (void)
+#endif
+
+{
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
+
+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			/* This was really a NUL. */
+			*(yy_c_buf_p) = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
+			++(yy_c_buf_p);
+
+			switch ( yy_get_next_buffer(  ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart(yyin );
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( ) )
+						return 0;
+
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					(yy_c_buf_p) = (yytext_ptr) + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
+	(yy_hold_char) = *++(yy_c_buf_p);
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file )
+{
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer(yyin,YY_BUF_SIZE );
+	}
+
+	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+	yy_load_buffer_state( );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void yy_load_buffer_state  (void)
+{
+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	(yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer(b,file );
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree((void *) b->yy_ch_buf  );
+
+	yyfree((void *) b  );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+
+{
+	int oerrno = errno;
+    
+	yy_flush_buffer(b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+    	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+    	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack();
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		(yy_buffer_stack_top)++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( );
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void yypop_buffer_state (void)
+{
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( );
+		(yy_did_buffer_switch_on_eof) = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+	yy_size_t num_to_alloc;
+    
+	if (!(yy_buffer_stack)) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		(yy_buffer_stack_max) = num_to_alloc;
+		(yy_buffer_stack_top) = 0;
+		return;
+	}
+
+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+		(yy_buffer_stack_max) = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer(b  );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr )
+{
+    
+	return yy_scan_bytes(yystr,(int) strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc(n  );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer(buf,n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg )
+{
+			(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = (yy_hold_char); \
+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+    
+    return yylineno;
+}
+
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+int yyget_leng  (void)
+{
+        return yyleng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *yyget_text  (void)
+{
+        return yytext;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * 
+ */
+void yyset_lineno (int  _line_number )
+{
+    
+    yylineno = _line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str )
+{
+        yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str )
+{
+        yyout = _out_str ;
+}
+
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug )
+{
+        yy_flex_debug = _bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = NULL;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = NULL;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer(YY_CURRENT_BUFFER  );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state();
+	}
+
+	/* Destroy the stack itself. */
+	yyfree((yy_buffer_stack) );
+	(yy_buffer_stack) = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( );
+
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n )
+{
+		
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s )
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size )
+{
+			return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size )
+{
+		
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr )
+{
+			free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 137 "kbdlexer.l"
+
+
+#ifndef yywrap
+int yywrap() { return 1; }
+#endif
+#undef input
+#define input() ((*inptr)?(*inptr++):0)
+#undef unput
+#define unput(c) (*--inptr=c)
+
diff --git a/kbdlexer.l b/kbdlexer.l
new file mode 100644
index 0000000..79184f6
--- /dev/null
+++ b/kbdlexer.l
@@ -0,0 +1,145 @@
+%{
+#include <X11/Xmu/CharSet.h>
+#include <string.h>
+
+#include "libami.h"
+#include "kbdmodule.h"
+
+unsigned char *inptr;
+extern char *progname;
+
+#ifdef FLEX_SCANNER
+
+#undef YY_INPUT
+#define YY_INPUT(buf,result,size) ((result) = doinput((buf),(size)))
+int doinput (char *buf, int size)
+{
+  int l=strlen((char *)inptr);
+  if(l>size) l=size;
+  if(l>0) {
+    memcpy(buf, inptr, l);
+    inptr+=l;
+  }
+  return l;
+}
+#endif
+
+static void k_rotscreens(Window w)
+{
+  Window root;
+  int x, y;
+  unsigned int width, height, bw, d;
+  if(XGetGeometry(md_display(), w, &root, &x, &y, &width, &height, &bw, &d))
+    md_rotate_screen(root);
+}
+
+typedef void (*mdfuncp)(Window);
+
+int parse_keyword(char *str, YYSTYPE *val)
+{
+   struct { char *name; mdfuncp func; } functab[] = {
+     { "back", (mdfuncp)md_back },
+     { "front", (mdfuncp)md_front },
+     { "iconify", (mdfuncp)md_iconify },
+     { "rotatescreens", (mdfuncp)k_rotscreens },
+   };
+#define N_FUNC (sizeof(functab)/sizeof(functab[0]))
+   struct { char *name; int token, num; } kwtab[] = {
+     { "all", WHEREABOUTS, IN_ANYTHING_MASK },
+     { "b1", MODIFIER, Button1Mask },
+     { "b2", MODIFIER, Button2Mask },
+     { "b3", MODIFIER, Button3Mask },
+     { "b4", MODIFIER, Button4Mask },
+     { "b5", MODIFIER, Button5Mask },
+     { "button1", MODIFIER, Button1Mask },
+     { "button2", MODIFIER, Button2Mask },
+     { "button3", MODIFIER, Button3Mask },
+     { "button4", MODIFIER, Button4Mask },
+     { "button5", MODIFIER, Button5Mask },
+     { "control", MODIFIER, ControlMask },
+     { "frame", WHEREABOUTS, IN_FRAME_MASK },
+     { "icon", WHEREABOUTS, IN_ICON_MASK },
+     { "lock", MODIFIER, LockMask },
+     { "m", META, 0 },
+     { "m1", MODIFIER, Mod1Mask },
+     { "m2", MODIFIER, Mod2Mask },
+     { "m3", MODIFIER, Mod3Mask },
+     { "m4", MODIFIER, Mod4Mask },
+     { "m5", MODIFIER, Mod5Mask },
+     { "meta", META, 0 },
+     { "mod1", MODIFIER, Mod1Mask },
+     { "mod2", MODIFIER, Mod2Mask },
+     { "mod3", MODIFIER, Mod3Mask },
+     { "mod4", MODIFIER, Mod4Mask },
+     { "mod5", MODIFIER, Mod5Mask },
+     { "root", WHEREABOUTS, IN_ROOT_MASK },
+     { "shift", MODIFIER, ShiftMask },
+     { "window", WHEREABOUTS, IN_WINDOW_MASK },
+   };
+#define N_KW (sizeof(kwtab)/sizeof(kwtab[0]))
+  int l=0, h=N_FUNC-1;
+  
+  XmuCopyISOLatin1Lowered (str, str);
+  while(h>=l) {
+    int i=(h+l)>>1, c=strcmp(str, functab[i].name);
+    if(!c) {
+      val->function=functab[i].func;
+      return FUNCTION;
+    } else if(c>=0)
+      l=i+1;
+    else
+      h=i-1;
+  }
+  l=0; h=N_KW-1;
+  while(h>=l) {
+    int i=(h+l)>>1, c=strcmp(str, kwtab[i].name);
+    if(!c) {
+      val->num=kwtab[i].num;
+      return kwtab[i].token;
+    } else if(c>=0)
+      l=i+1;
+    else
+      h=i-1;
+  }
+  return ERRORTOKEN;
+}
+
+%}
+%%
+
+\#[^\n]*\n	{ ; }
+
+\<[^\n\>]*\>	{ *((char*)strchr(yytext, '>'))=0;
+		  yylval.keysym=XStringToKeysym(yytext+1);
+		  if(yylval.keysym == 0) {
+                    fprintf(stderr, "%s: ignoring unknown keysym: %s\n",
+                            progname, yytext+1);
+		  } else
+		    return KEYSYM;
+		}
+
+[a-zA-Z0-9]+	{ int token = parse_keyword(yytext, &yylval);
+                  if(token == ERRORTOKEN) {
+                    fprintf(stderr, "%s: ignoring unknown keyword: %s\n",
+                            progname, yytext);
+                  } else
+                    return token;
+                }
+
+\:		{ return COLON; }
+
+\|		{ return BAR; }
+
+[\r\n\t ]       { ; }
+
+.               { fprintf(stderr, "%s: illegal character \"%s\" ignored\n",
+                          progname, yytext); }
+%%
+
+#ifndef yywrap
+int yywrap() { return 1; }
+#endif
+#undef input
+#define input() ((*inptr)?(*inptr++):0)
+#undef unput
+#define unput(c) (*--inptr=c)
diff --git a/kbdmodule.c b/kbdmodule.c
new file mode 100644
index 0000000..bba9aac
--- /dev/null
+++ b/kbdmodule.c
@@ -0,0 +1,1526 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "kbdmodule.y" /* yacc.c:339  */
+
+#include <stdio.h>
+#include <string.h>
+#include "libami.h"
+
+void docmd(XEvent *e, void *callback)
+{
+  ((void (*)(Window))callback)(e->xany.window);
+}
+
+
+#line 78 "y.tab.c" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "y.tab.h".  */
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    ERRORTOKEN = 258,
+    META = 259,
+    MODIFIER = 260,
+    WHEREABOUTS = 261,
+    COLON = 262,
+    BAR = 263,
+    KEYSYM = 264,
+    FUNCTION = 265
+  };
+#endif
+/* Tokens.  */
+#define ERRORTOKEN 258
+#define META 259
+#define MODIFIER 260
+#define WHEREABOUTS 261
+#define COLON 262
+#define BAR 263
+#define KEYSYM 264
+#define FUNCTION 265
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 14 "kbdmodule.y" /* yacc.c:355  */
+
+  int num;
+  char *ptr;
+  KeySym keysym;
+  struct { unsigned int mods; int meta; } modifiers;
+  void (*function)(Window);
+
+#line 146 "y.tab.c" /* yacc.c:355  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 163 "y.tab.c" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  2
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   9
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  11
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  6
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  10
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  16
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   265
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,    37,    37,    38,    41,    44,    45,    46,    49,    50,
+      53
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 0
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "ERRORTOKEN", "META", "MODIFIER",
+  "WHEREABOUTS", "COLON", "BAR", "KEYSYM", "FUNCTION", "$accept",
+  "bindings", "binding", "modifiers", "whereabouts", "command", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265
+};
+# endif
+
+#define YYPACT_NINF -6
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-6)))
+
+#define YYTABLE_NINF -1
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int8 yypact[] =
+{
+      -6,     4,    -6,    -6,    -4,    -6,    -6,    -1,     1,    -6,
+      -5,    -2,     1,    -6,    -6,    -6
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       3,     7,     1,     2,     0,     6,     5,     0,     0,     9,
+       0,     0,     0,    10,     4,     8
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+      -6,    -6,    -6,    -6,    -3,    -6
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,     1,     3,     4,    10,    14
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_uint8 yytable[] =
+{
+       5,     6,    11,    12,     2,     7,     8,     9,    13,    15
+};
+
+static const yytype_uint8 yycheck[] =
+{
+       4,     5,     7,     8,     0,     9,     7,     6,    10,    12
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,    12,     0,    13,    14,     4,     5,     9,     7,     6,
+      15,     7,     8,    10,    16,    15
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    11,    12,    12,    13,    14,    14,    14,    15,    15,
+      16
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     2,     0,     6,     2,     2,     0,     3,     1,
+       1
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              );
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+{
+  YYUSE (yyvaluep);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/* The lookahead symbol.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (void)
+{
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex ();
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 4:
+#line 41 "kbdmodule.y" /* yacc.c:1646  */
+    { cx_hotkey((yyvsp[-4].keysym), (yyvsp[-5].modifiers).mods, (yyvsp[-5].modifiers).meta, (yyvsp[-2].num), docmd, (void*)(yyvsp[0].function)); }
+#line 1237 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 5:
+#line 44 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.modifiers).mods=(yyvsp[-1].modifiers).mods|(yyvsp[0].num); (yyval.modifiers).meta=(yyvsp[-1].modifiers).meta; }
+#line 1243 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 6:
+#line 45 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.modifiers).mods=(yyvsp[-1].modifiers).mods; (yyval.modifiers).meta=1; }
+#line 1249 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 7:
+#line 46 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.modifiers).mods=(yyval.modifiers).meta=0; }
+#line 1255 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 49 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.num)=(yyvsp[-2].num)|(yyvsp[0].num); }
+#line 1261 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 50 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.num)=(yyvsp[0].num); }
+#line 1267 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 53 "kbdmodule.y" /* yacc.c:1646  */
+    { (yyval.function)=(yyvsp[0].function); }
+#line 1273 "y.tab.c" /* yacc.c:1646  */
+    break;
+
+
+#line 1277 "y.tab.c" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 56 "kbdmodule.y" /* yacc.c:1906  */
+
+
+char *progname;
+
+int yyerror(s) char *s;
+{
+    fprintf (stderr, "%s: error in input file:  %s\n", progname, s ? s : "");
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  char *arg=md_init(argc, argv);
+  progname=argv[0];
+  if(arg) {
+    extern unsigned char *inptr;
+    inptr=(unsigned char *)arg;
+    yyparse();
+    md_main_loop();
+  }
+  return 0;
+}
diff --git a/kbdmodule.h b/kbdmodule.h
new file mode 100644
index 0000000..b5cd9e3
--- /dev/null
+++ b/kbdmodule.h
@@ -0,0 +1,94 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    ERRORTOKEN = 258,
+    META = 259,
+    MODIFIER = 260,
+    WHEREABOUTS = 261,
+    COLON = 262,
+    BAR = 263,
+    KEYSYM = 264,
+    FUNCTION = 265
+  };
+#endif
+/* Tokens.  */
+#define ERRORTOKEN 258
+#define META 259
+#define MODIFIER 260
+#define WHEREABOUTS 261
+#define COLON 262
+#define BAR 263
+#define KEYSYM 264
+#define FUNCTION 265
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 14 "kbdmodule.y" /* yacc.c:1909  */
+
+  int num;
+  char *ptr;
+  KeySym keysym;
+  struct { unsigned int mods; int meta; } modifiers;
+  void (*function)(Window);
+
+#line 82 "y.tab.h" /* yacc.c:1909  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
diff --git a/kbdmodule.y b/kbdmodule.y
new file mode 100644
index 0000000..96adb35
--- /dev/null
+++ b/kbdmodule.y
@@ -0,0 +1,77 @@
+%{
+#include <stdio.h>
+#include <string.h>
+#include "libami.h"
+
+void docmd(XEvent *e, void *callback)
+{
+  ((void (*)(Window))callback)(e->xany.window);
+}
+
+%}
+
+%union
+{
+  int num;
+  char *ptr;
+  KeySym keysym;
+  struct { unsigned int mods; int meta; } modifiers;
+  void (*function)(Window);
+};
+
+%token <num> ERRORTOKEN
+%token <num> META MODIFIER WHEREABOUTS COLON BAR
+%token <keysym> KEYSYM
+%token <function> FUNCTION
+
+%type <num> whereabouts
+%type <modifiers> modifiers
+%type <function> command
+
+%left BAR
+
+%start bindings
+
+%%
+
+bindings		: bindings binding
+			|
+			;
+
+binding			: modifiers KEYSYM COLON whereabouts COLON command { cx_hotkey($2, $1.mods, $1.meta, $4, docmd, (void*)$6); }
+			;
+
+modifiers		: modifiers MODIFIER { $$.mods=$1.mods|$2; $$.meta=$1.meta; }
+			| modifiers META { $$.mods=$1.mods; $$.meta=1; }
+			| { $$.mods=$$.meta=0; }
+			;
+
+whereabouts		: whereabouts BAR whereabouts { $$=$1|$3; }
+			| WHEREABOUTS { $$=$1; }
+			;
+
+command			: FUNCTION { $$=$1; }
+			;
+
+%%
+
+char *progname;
+
+int yyerror(s) char *s;
+{
+    fprintf (stderr, "%s: error in input file:  %s\n", progname, s ? s : "");
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  char *arg=md_init(argc, argv);
+  progname=argv[0];
+  if(arg) {
+    extern unsigned char *inptr;
+    inptr=(unsigned char *)arg;
+    yyparse();
+    md_main_loop();
+  }
+  return 0;
+}
diff --git a/launchermodule.c b/launchermodule.c
new file mode 100644
index 0000000..4a57ba5
--- /dev/null
+++ b/launchermodule.c
@@ -0,0 +1,249 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "libami.h"
+#include "drawinfo.h"
+
+char *progname;
+
+Display *dpy;
+XContext launchercontext;
+struct DrawInfo dri;
+Atom appiconmsg;
+char *icondir;
+
+struct launcher {
+  struct ColorStore colorstore1, colorstore2;
+  char cmdline[1];
+};
+
+#ifdef AMIGAOS
+void spawn(const char *cmd)
+{
+  char *line=malloc(strlen(cmd)+12);
+  if(line) {
+    sprintf(line, "RUN <>NIL: %s", cmd);
+    system(line);
+    free(line);
+  }
+}
+#else
+void spawn(const char *cmd)
+{
+#ifdef HAVE_ALLOCA
+  char *line=alloca(strlen(cmd)+4);
+#else
+  char *line=malloc(strlen(cmd)+4);
+  if(line) {
+#endif
+  sprintf(line, "%s &", cmd);
+#ifdef __ultrix
+  {
+    int pid, status;
+    if ((pid = fork ()) == 0) {
+      (void) setsid();
+      execl ("/bin/sh", "sh", "-c", line, 0);
+    } else
+      waitpid (pid, &status, 0);
+  }
+#else
+  system(line);
+#endif
+#ifndef HAVE_ALLOCA
+    free(line);
+  }
+#endif
+}
+#endif
+
+static void broker_cb(XEvent *evt, unsigned long mask)
+{
+  XPointer ret;
+
+  if(evt->type != ClientMessage || evt->xclient.message_type != appiconmsg)
+    return;
+
+  if(!XFindContext(dpy, evt->xclient.window, launchercontext, &ret)) {
+    struct launcher *l = (struct launcher*)ret;
+    spawn(l->cmdline);
+  }
+}
+
+static void create_broker()
+{
+  cx_broker(0, broker_cb);
+}
+
+static void create_launcher(char *label, char *icon, char *cmdline)
+{
+  struct DiskObject *icon_do = NULL;
+  Pixmap icon_icon1, icon_icon2;
+  Window win;
+
+  struct launcher *l = malloc(sizeof(struct launcher)+strlen(cmdline));
+  if (l == NULL) {
+    fprintf(stderr, "%s: out of memory!\n", progname);
+    exit(1);
+  }
+
+  memset(l, 0, sizeof(*l));
+  strcpy(l->cmdline, cmdline);
+
+  if (icon != NULL && *icon != 0) {
+#ifdef AMIGAOS
+    char fn[256];
+    strncpy(fn, icondir, sizeof(fn)-1);
+    fn[sizeof(fn)-1]='\0';
+    AddPart(fn,icon,sizeof(fn));
+#else
+    int rl=strlen(icon)+strlen(icondir)+2;
+#ifdef HAVE_ALLOCA
+    char *fn=alloca(rl);
+#else
+    char fn[1024];
+#endif
+    sprintf(fn, "%s/%s", icondir, icon);
+#endif
+    fn[strlen(fn)-5]=0;
+    icon_do = GetDiskObject(fn);
+  }
+
+  if(icon_do == NULL)
+    icon_do = GetDefDiskObject(3/*WBTOOL*/);
+
+  if(icon_do == NULL) {
+    md_errormsg(md_root, "Failed to load icon");
+    md_exit(0);
+  }
+
+  icon_icon1 =
+    md_image_to_pixmap(md_root, dri.dri_Pens[BACKGROUNDPEN],
+		       (struct Image *)icon_do->do_Gadget.GadgetRender,
+		       icon_do->do_Gadget.Width, icon_do->do_Gadget.Height,
+		       &l->colorstore1);
+
+  icon_icon2 =
+    md_image_to_pixmap(md_root, dri.dri_Pens[BACKGROUNDPEN],
+		       (struct Image *)icon_do->do_Gadget.SelectRender,
+		       icon_do->do_Gadget.Width, icon_do->do_Gadget.Height,
+		       &l->colorstore2);
+
+  FreeDiskObject(icon_do);
+  XSync(dpy, False);
+  win = md_create_appicon(md_root, 0x80000000, 0x80000000,
+			  label, icon_icon1, icon_icon2, None);
+  XSaveContext(dpy, win, launchercontext, (XPointer)l);
+}
+
+static int skip_ws(char *arg, int len)
+{
+  int n = 0;
+  while(len > 0 && isspace(*(unsigned char *)arg)) { n++; arg++; --len; }
+  return n;
+}
+
+static int get_string(char *arg, int len, int lineno)
+{
+  int n;
+  if (len < 1 || *arg != '(') {
+    fprintf(stderr, "%s: missing '(' on line %d\n", progname, lineno);
+    return 0;
+  }
+  for (n=1; n<len; n++)
+    if (arg[n] == ')')
+      break;
+  if (n >= len) {
+    fprintf(stderr, "%s: missing ')' on line %d\n", progname, lineno);
+    return 0;
+  }
+  return n+1;
+}
+
+static char *create_string(char *arg, int l)
+{
+  char *p = malloc(l+1);
+  if (!p) {
+    fprintf(stderr, "%s: out of memory!\n", progname);
+    exit(1);
+  }
+  if(l>0) memcpy(p, arg, l);
+  p[l] = 0;
+  return p;
+}
+
+static void create_appicons_line(char *arg, int len, int lineno)
+{
+  int l;
+  char *label, *icon, *cmdline;
+  if (*arg == '#')
+    return;
+  l = skip_ws(arg, len);
+  arg += l; len -= l;
+  if (!len) return;
+  l = get_string(arg, len, lineno);
+  if (!l) return;
+  label = create_string(arg+1, l-2);
+  arg += l; len -= l;
+  l = skip_ws(arg, len);
+  arg += l; len -= l;
+  l = get_string(arg, len, lineno);
+  if (!l) { free(label); return; }
+  icon = create_string(arg+1, l-2);
+  arg += l; len -= l;
+  l = skip_ws(arg, len);
+  arg += l; len -= l;
+  l = get_string(arg, len, lineno);
+  if (!l) { free(icon); free(label); return; }
+  cmdline = create_string(arg+1, l-2);
+  arg += l; len -= l;
+  l = skip_ws(arg, len);
+  arg += l; len -= l;
+  if (len) fprintf(stderr, "%s: junk at end of line %d\n", progname, lineno);
+  create_launcher(label, icon, cmdline);
+  free(cmdline);
+  free(icon);
+  free(label);
+}
+
+static void create_appicons(char *arg)
+{
+  char *p;
+  int l = 1;
+  while((p = strchr(arg, '\n'))) {
+    create_appicons_line(arg, p-arg, l++);
+    arg = p+1;
+  }
+  create_appicons_line(arg, strlen(arg), l);
+}
+
+static void setup()
+{
+  XWindowAttributes attr;
+  launchercontext = XUniqueContext();
+  XGetWindowAttributes(dpy, md_root, &attr);
+  init_dri(&dri, dpy, md_root, attr.colormap, False);
+  appiconmsg = XInternAtom(dpy, "AMIWM_APPICONMSG", False);
+  icondir = get_current_icondir();
+  if(!icondir) icondir="";
+}
+
+int main(int argc, char *argv[])
+{
+  char *arg=md_init(argc, argv);
+  progname=argv[0];
+
+  if(!(dpy = md_display())) {
+    fprintf(stderr, "%s: cannot connect to X server %s\n", progname,
+	    XDisplayName(NULL));
+    exit(1);
+  }
+  if(arg) {
+    setup();
+    create_broker();
+    create_appicons(arg);
+    md_main_loop();
+  }
+  return 0;
+}
diff --git a/lex.c b/lex.c
new file mode 100644
index 0000000..ecdecb0
--- /dev/null
+++ b/lex.c
@@ -0,0 +1,1901 @@
+
+#line 2 "<stdout>"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 3
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+    #define yy_create_buffer yy_create_buffer
+
+    #define yy_delete_buffer yy_delete_buffer
+
+    #define yy_scan_buffer yy_scan_buffer
+
+    #define yy_scan_string yy_scan_string
+
+    #define yy_scan_bytes yy_scan_bytes
+
+    #define yy_init_buffer yy_init_buffer
+
+    #define yy_flush_buffer yy_flush_buffer
+
+    #define yy_load_buffer_state yy_load_buffer_state
+
+    #define yy_switch_to_buffer yy_switch_to_buffer
+
+    #define yypush_buffer_state yypush_buffer_state
+
+    #define yypop_buffer_state yypop_buffer_state
+
+    #define yyensure_buffer_stack yyensure_buffer_stack
+
+    #define yylex yylex
+
+    #define yyrestart yyrestart
+
+    #define yylex_init yylex_init
+
+    #define yylex_init_extra yylex_init_extra
+
+    #define yylex_destroy yylex_destroy
+
+    #define yyget_debug yyget_debug
+
+    #define yyset_debug yyset_debug
+
+    #define yyget_extra yyget_extra
+
+    #define yyset_extra yyset_extra
+
+    #define yyget_in yyget_in
+
+    #define yyset_in yyset_in
+
+    #define yyget_out yyget_out
+
+    #define yyset_out yyset_out
+
+    #define yyget_leng yyget_leng
+
+    #define yyget_text yyget_text
+
+    #define yyget_lineno yyget_lineno
+
+    #define yyset_lineno yyset_lineno
+
+    #define yywrap yywrap
+
+    #define yyalloc yyalloc
+
+    #define yyrealloc yyrealloc
+
+    #define yyfree yyfree
+
+    #define yytext yytext
+
+    #define yyleng yyleng
+
+    #define yyin yyin
+
+    #define yyout yyout
+
+    #define yy_flex_debug yy_flex_debug
+
+    #define yylineno yylineno
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart(yyin  )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+extern int yyleng;
+
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+    
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = (yy_hold_char); \
+		YY_RESTORE_YY_MORE_OFFSET \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, (yytext_ptr)  )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = NULL;
+static int yy_init = 0;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart ( FILE *input_file  );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
+void yy_delete_buffer ( YY_BUFFER_STATE b  );
+void yy_flush_buffer ( YY_BUFFER_STATE b  );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state ( void );
+
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
+
+void *yyalloc ( yy_size_t  );
+void *yyrealloc ( void *, yy_size_t  );
+void yyfree ( void *  );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+typedef flex_uint8_t YY_CHAR;
+
+FILE *yyin = NULL, *yyout = NULL;
+
+typedef int yy_state_type;
+
+extern int yylineno;
+int yylineno = 1;
+
+extern char *yytext;
+#ifdef yytext_ptr
+#undef yytext_ptr
+#endif
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg  );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	(yytext_ptr) = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	(yy_hold_char) = *yy_cp; \
+	*yy_cp = '\0'; \
+	(yy_c_buf_p) = yy_cp;
+#define YY_NUM_RULES 9
+#define YY_END_OF_BUFFER 10
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[21] =
+    {   0,
+        0,    0,   10,    8,    7,    7,    8,    8,    3,    4,
+        5,    6,    0,    2,    0,    0,    1,    3,    4,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    4,    5,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    1,    1,    1,
+        1,    1,    1,    1,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        1,    8,    1,    1,    1,    1,    7,    7,    7,    7,
+
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    9,    1,   10,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[11] =
+    {   0,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[23] =
+    {   0,
+        0,    0,   25,   26,   26,   26,    7,   21,   17,   12,
+       26,   26,   12,   26,   15,   14,   26,    8,    6,   26,
+       11,   20
+    } ;
+
+static const flex_int16_t yy_def[23] =
+    {   0,
+       20,    1,   20,   20,   20,   20,   21,   22,   20,   20,
+       20,   20,   21,   20,   21,   22,   20,   20,   20,    0,
+       20,   20
+    } ;
+
+static const flex_int16_t yy_nxt[37] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,    4,   11,   12,
+       14,   13,   19,   18,   15,   14,   17,   13,   19,   15,
+       16,   16,   18,   17,   20,    3,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20
+    } ;
+
+static const flex_int16_t yy_chk[37] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        7,   21,   19,   18,    7,   13,   16,   15,   10,   13,
+       22,   22,    9,    8,    3,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "lex.l"
+#line 2 "lex.l"
+#include <stdio.h>
+#include "gram.h"
+extern char *progname;
+extern int ParseError;
+extern FILE *rcfile;
+#undef yyin
+#define yyin rcfile
+#define yywrap() 1
+extern int parse_keyword(char *);
+void fixup_string(char *, char *);
+#define YY_SKIP_YYWRAP
+#line 535 "<stdout>"
+#line 536 "<stdout>"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals ( void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( void );
+
+int yyget_debug ( void );
+
+void yyset_debug ( int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra ( void );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in ( void );
+
+void yyset_in  ( FILE * _in_str  );
+
+FILE *yyget_out ( void );
+
+void yyset_out  ( FILE * _out_str  );
+
+			int yyget_leng ( void );
+
+char *yyget_text ( void );
+
+int yyget_lineno ( void );
+
+void yyset_lineno ( int _line_number  );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( void );
+#else
+extern int yywrap ( void );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+    
+    static void yyunput ( int c, char *buf_ptr  );
+    
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * );
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( void );
+#else
+static int input ( void );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer(yyin,YY_BUF_SIZE );
+		}
+
+		yy_load_buffer_state( );
+		}
+
+	{
+#line 14 "lex.l"
+
+
+#line 756 "<stdout>"
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = (yy_c_buf_p);
+
+		/* Support of yytext. */
+		*yy_cp = (yy_hold_char);
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = (yy_start);
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				(yy_last_accepting_state) = yy_current_state;
+				(yy_last_accepting_cpos) = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 21 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 26 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = (yy_hold_char);
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			goto yy_find_action;
+
+case 1:
+/* rule 1 can match eol */
+YY_RULE_SETUP
+#line 16 "lex.l"
+{ ; }
+	YY_BREAK
+case 2:
+/* rule 2 can match eol */
+YY_RULE_SETUP
+#line 18 "lex.l"
+{ fixup_string(yytext, yytext); yylval.ptr=yytext;
+			  return STRING; }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 21 "lex.l"
+{ yylval.num=atoi(yytext); return NUMBER; }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 23 "lex.l"
+{ int token = parse_keyword(yytext);
+		  if(token == ERRORTOKEN) {
+		    fprintf(stderr, "%s: ignoring unknown keyword: %s\n",
+			    progname, yytext);
+		    ParseError=1;
+		  } else
+		    return token;
+		}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 32 "lex.l"
+{ return LEFTBRACE; }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 34 "lex.l"
+{ return RIGHTBRACE; }
+	YY_BREAK
+case 7:
+/* rule 7 can match eol */
+YY_RULE_SETUP
+#line 36 "lex.l"
+{ ; }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 38 "lex.l"
+{ fprintf(stderr, "%s: illegal character \"%s\" ignored\n",
+			  progname, yytext);
+		  ParseError=1; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 42 "lex.l"
+ECHO;
+	YY_BREAK
+#line 871 "<stdout>"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = (yy_hold_char);
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state(  );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++(yy_c_buf_p);
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = (yy_c_buf_p);
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer(  ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				(yy_did_buffer_switch_on_eof) = 0;
+
+				if ( yywrap( ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				(yy_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = (yytext_ptr);
+	int number_to_move, i;
+	int ret_val;
+
+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2)  );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	if ( (yy_n_chars) == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart(yyin  );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+	}
+
+	(yy_n_chars) += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (void)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    
+	yy_current_state = (yy_start);
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			(yy_last_accepting_state) = yy_current_state;
+			(yy_last_accepting_cpos) = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 21 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+	int yy_is_jam;
+    	char *yy_cp = (yy_c_buf_p);
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		(yy_last_accepting_state) = yy_current_state;
+		(yy_last_accepting_cpos) = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 21 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 20);
+
+		return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp )
+{
+	char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
+
+	/* undo effects of setting up yytext */
+	*yy_cp = (yy_hold_char);
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = (yy_n_chars) + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+	(yytext_ptr) = yy_bp;
+	(yy_hold_char) = *yy_cp;
+	(yy_c_buf_p) = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (void)
+#else
+    static int input  (void)
+#endif
+
+{
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
+
+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			/* This was really a NUL. */
+			*(yy_c_buf_p) = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
+			++(yy_c_buf_p);
+
+			switch ( yy_get_next_buffer(  ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart(yyin );
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( ) )
+						return 0;
+
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					(yy_c_buf_p) = (yytext_ptr) + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
+	(yy_hold_char) = *++(yy_c_buf_p);
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file )
+{
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer(yyin,YY_BUF_SIZE );
+	}
+
+	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+	yy_load_buffer_state( );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void yy_load_buffer_state  (void)
+{
+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	(yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer(b,file );
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree((void *) b->yy_ch_buf  );
+
+	yyfree((void *) b  );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+
+{
+	int oerrno = errno;
+    
+	yy_flush_buffer(b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+    	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+    	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack();
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		(yy_buffer_stack_top)++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( );
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void yypop_buffer_state (void)
+{
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( );
+		(yy_did_buffer_switch_on_eof) = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+	yy_size_t num_to_alloc;
+    
+	if (!(yy_buffer_stack)) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		(yy_buffer_stack_max) = num_to_alloc;
+		(yy_buffer_stack_top) = 0;
+		return;
+	}
+
+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+		(yy_buffer_stack_max) = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer(b  );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr )
+{
+    
+	return yy_scan_bytes(yystr,(int) strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc(n  );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer(buf,n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg )
+{
+			(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = (yy_hold_char); \
+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+    
+    return yylineno;
+}
+
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+int yyget_leng  (void)
+{
+        return yyleng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *yyget_text  (void)
+{
+        return yytext;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * 
+ */
+void yyset_lineno (int  _line_number )
+{
+    
+    yylineno = _line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str )
+{
+        yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str )
+{
+        yyout = _out_str ;
+}
+
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug )
+{
+        yy_flex_debug = _bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = NULL;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = NULL;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer(YY_CURRENT_BUFFER  );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state();
+	}
+
+	/* Destroy the stack itself. */
+	yyfree((yy_buffer_stack) );
+	(yy_buffer_stack) = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( );
+
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n )
+{
+		
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s )
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size )
+{
+			return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size )
+{
+		
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr )
+{
+			free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 42 "lex.l"
+
+void fixup_string(char *src, char *dest)
+{
+  src++;
+  while(*src!='"')
+    if((*dest++=*src++)=='\\')
+      switch((dest[-1]=*src++)) {
+      case 'n':
+	dest[-1]='\n';
+	break;
+      case 'r':
+	dest[-1]='\r';
+	break;
+      case 'a':
+	dest[-1]='\a';
+	break;
+      case 'b':
+	dest[-1]='\b';
+	break;
+      case 't':
+	dest[-1]='\t';
+	break;
+      case 'e':
+	dest[-1]='\033';
+	break;
+      }
+  *dest='\0';
+}
+
diff --git a/lex.l b/lex.l
new file mode 100644
index 0000000..5f653d2
--- /dev/null
+++ b/lex.l
@@ -0,0 +1,69 @@
+%{
+#include <stdio.h>
+#include "gram.h"
+extern char *progname;
+extern int ParseError;
+extern FILE *rcfile;
+#undef yyin
+#define yyin rcfile
+#define yywrap() 1
+extern int parse_keyword(char *);
+void fixup_string(char *, char *);
+#define YY_SKIP_YYWRAP
+%}
+%%
+
+\#[^\n]*\n	{ ; }
+
+\"([^"\n\\]|\\.|\\\n)*\"    { fixup_string(yytext, yytext); yylval.ptr=yytext;
+			  return STRING; }
+
+[0-9]+ { yylval.num=atoi(yytext); return NUMBER; }
+
+[a-zA-Z]+	{ int token = parse_keyword(yytext);
+		  if(token == ERRORTOKEN) {
+		    fprintf(stderr, "%s: ignoring unknown keyword: %s\n",
+			    progname, yytext);
+		    ParseError=1;
+		  } else
+		    return token;
+		}
+
+\{		{ return LEFTBRACE; }
+
+\}		{ return RIGHTBRACE; }
+
+[\r\n\t ]	{ ; }
+
+.		{ fprintf(stderr, "%s: illegal character \"%s\" ignored\n",
+			  progname, yytext);
+		  ParseError=1; }
+
+%%
+void fixup_string(char *src, char *dest)
+{
+  src++;
+  while(*src!='"')
+    if((*dest++=*src++)=='\\')
+      switch((dest[-1]=*src++)) {
+      case 'n':
+	dest[-1]='\n';
+	break;
+      case 'r':
+	dest[-1]='\r';
+	break;
+      case 'a':
+	dest[-1]='\a';
+	break;
+      case 'b':
+	dest[-1]='\b';
+	break;
+      case 't':
+	dest[-1]='\t';
+	break;
+      case 'e':
+	dest[-1]='\033';
+	break;
+      }
+  *dest='\0';
+}
diff --git a/libami/Makefile b/libami/Makefile
new file mode 100644
index 0000000..28b4294
--- /dev/null
+++ b/libami/Makefile
@@ -0,0 +1,45 @@
+srcdir = .
+
+SHELL = /bin/sh
+CC = gcc
+LEX = flex
+YACC = bison -y
+RANLIB = ranlib
+CFLAGS = -g -O2
+YFLAGS = -d
+DEFS = -DPACKAGE_NAME=\"\" -DPACKAGE_TARNAME=\"\" -DPACKAGE_VERSION=\"\" -DPACKAGE_STRING=\"\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DYYTEXT_POINTER=1 -DSTDC_HEADERS=1 -DHAVE_SYS_WAIT_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_FCNTL_H=1 -DHAVE_LIMITS_H=1 -DHAVE_SYS_TIME_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_UNISTD_H=1 -DHAVE_SYS_SELECT_H=1 -DHAVE_SYS_RESOURCE_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_TERMIO_H=1 -DHAVE_X11_EXTENSIONS_SHAPE_H=1 -DTIME_WITH_SYS_TIME=1 -DHAVE_ALLOCA_H=1 -DHAVE_ALLOCA=1 -DRETSIGTYPE=void -DHAVE_WAIT3=1 -DHAVE_SELECT=1 -DHAVE_STRDUP=1 -DHAVE_WAITPID=1 -DHAVE_XSHAPE=1 -DBSD_STYLE_GETTIMEOFDAY=1 -DHAVE_XCREATEFONTSET=1 -DHAVE_XMBTEXTESCAPEMENT=1 -DHAVE_XUTF8DRAWIMAGESTRING=1 -DUSE_FONTSETS=1 -DLAME_ENDIAN=1
+ALL_CFLAGS = -I. -I.. $(DEFS) $(CFLAGS) 
+LIBS =   -lSM -lICE -lXext -lXmu -lX11  
+prefix = /usr/local
+exec_prefix = ${prefix}
+bindir = $(exec_prefix)/bin
+libdir = $(exec_prefix)/lib
+INSTALL = /usr/bin/install -c
+LN_S = ln -s
+
+OBJS  = drawinfo.o module.o broker.o eventdispatcher.o mdscreen.o \
+	mdicon.o mdwindow.o kbdsupport.o hotkey.o \
+	lists.o readargs.o iconlib.o iconutil.o error.o strutil.o \
+	iffparse.o
+
+SRCS = drawinfo.c module.c broker.c eventdispatcher.c mdscreen.c \
+	mdicon.c mdwindow.c kbdsupport.c hotkey.c \
+	lists.c readargs.c iconlib.c iconutil.c error.c strutil.c \
+	iffparse.c
+
+all : libami.a
+
+libami.a : $(OBJS)
+	ar rc libami.a $(OBJS)
+	$(RANLIB) libami.a
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
+
+depend: $(SRCS)
+	-@rm Makefile.bak
+	mv Makefile Makefile.bak
+	( sed '/^#--DO NOT REMOVE THIS LINE--$$/q' < Makefile.bak ; \
+	  $(CC) -MM $(ALL_CFLAGS) $(SRCS) ) > Makefile
+
+#--DO NOT REMOVE THIS LINE--
diff --git a/libami/Makefile.in b/libami/Makefile.in
new file mode 100644
index 0000000..8d652c9
--- /dev/null
+++ b/libami/Makefile.in
@@ -0,0 +1,45 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+SHELL = /bin/sh
+CC = @CC@
+LEX = @LEX@
+YACC = @YACC@
+RANLIB = @RANLIB@
+CFLAGS = @CFLAGS@
+YFLAGS = -d
+DEFS = @DEFS@
+ALL_CFLAGS = -I@srcdir@ -I@top_srcdir@ $(DEFS) $(CFLAGS) @X_CFLAGS@
+LIBS = @X_LIBS@ @X_PRE_LIBS@ -lXext -lXmu -lX11 @X_EXTRA_LIBS@ @LIBS@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+bindir = $(exec_prefix)/bin
+libdir = $(exec_prefix)/lib
+INSTALL = @INSTALL@
+LN_S = @LN_S@
+
+OBJS  = drawinfo.o module.o broker.o eventdispatcher.o mdscreen.o \
+	mdicon.o mdwindow.o kbdsupport.o hotkey.o \
+	lists.o readargs.o iconlib.o iconutil.o error.o strutil.o \
+	iffparse.o
+
+SRCS = drawinfo.c module.c broker.c eventdispatcher.c mdscreen.c \
+	mdicon.c mdwindow.c kbdsupport.c hotkey.c \
+	lists.c readargs.c iconlib.c iconutil.c error.c strutil.c \
+	iffparse.c
+
+all : libami.a
+
+libami.a : $(OBJS)
+	ar rc libami.a $(OBJS)
+	$(RANLIB) libami.a
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
+
+depend: $(SRCS)
+	-@rm Makefile.bak
+	mv Makefile Makefile.bak
+	( sed '/^#--DO NOT REMOVE THIS LINE--$$/q' < Makefile.bak ; \
+	  $(CC) -MM $(ALL_CFLAGS) $(SRCS) ) > Makefile
+
+#--DO NOT REMOVE THIS LINE--
diff --git a/libami/broker.c b/libami/broker.c
new file mode 100644
index 0000000..27bf136
--- /dev/null
+++ b/libami/broker.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "libami.h"
+#include "module.h"
+
+extern void (*md_broker_func)(XEvent *, unsigned long);
+
+int cx_broker(unsigned long mask, void (*callback)(XEvent *, unsigned long))
+{
+  md_broker_func=callback;
+  return md_command0(md_root, MCMD_SET_BROKER, &mask, sizeof(mask));
+}
+
+int cx_send_event(unsigned long mask, XEvent *e)
+{
+  struct mcmd_event me;
+  me.mask=mask;
+  me.event=*e;
+  return md_command0(md_root, MCMD_SEND_EVENT, &me, sizeof(me));
+}
diff --git a/libami/drawinfo.c b/libami/drawinfo.c
new file mode 100644
index 0000000..cafedd2
--- /dev/null
+++ b/libami/drawinfo.c
@@ -0,0 +1,235 @@
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "alloc.h"
+#include "drawinfo.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#define TAG_DRI_VERSION 1
+#define TAG_DRI_PENS    2
+#define TAG_DRI_FONT    3
+#define TAG_DRI_FONTSET 4
+
+extern char *progname;
+
+static char black[] = "#000000";
+static char white[] = "#ffffff";
+static char grey[] = "#aaaaaa";
+static char blue[] = "#6688bb";
+
+char *default_colors[NUMDRIPENS] = {
+  black, white, black, white, black, blue, black, grey, white,
+  black, white, black
+};
+
+char *default_screenfont =
+"-b&h-lucida-medium-r-normal-sans-12-*-*-*-*-*-iso8859-1"
+#ifdef USE_FONTSETS
+",-b&h-lucida-medium-r-normal-sans-12-*-*-*-*-*-iso10646-1"
+",-misc-fixed-medium-r-normal--14-*-*-*-*-*-jisx0208.1983-0"
+#endif
+;
+
+static void setdriprop(Display *dpy, Atom atom, Atom typ, Window win,
+		       struct DrawInfo *dri)
+{
+  CARD32 prop[/* NUMDRIPENS+6 */ 100], *p=prop;
+  CARD16 i;
+  *p++=TAG_DRI_VERSION;
+  *p++=dri->dri_Version;
+#ifdef USE_FONTSETS
+  *p++=TAG_DRI_FONTSET;
+  *p++=dri->dri_FontSetAtom;
+#else
+  *p++=TAG_DRI_FONT;
+  *p++=dri->dri_Font->fid;
+#endif
+  *p++=TAG_DRI_PENS;
+  *p++=dri->dri_NumPens;
+  for(i=0; i<dri->dri_NumPens; i++)
+    *p++=dri->dri_Pens[i];
+  XChangeProperty(dpy, win, atom, typ, 32, PropModeReplace,
+		  (unsigned char *)prop, p-prop);
+}
+
+static void getdriprop(Display *dpy, Atom atom, Atom typ, Window win,
+		       struct DrawInfo *dri)
+{
+  Atom atyp;
+  int afmt;
+  unsigned long nitems, extra;
+  int i,j,n;
+  CARD32 *prop=NULL;
+  if(XGetWindowProperty(dpy, win, atom, 0l, NUMDRIPENS+6, False, typ,
+			&atyp, &afmt, &nitems, &extra,
+			(unsigned char **)&prop) == Success &&
+     atyp==typ && afmt==32) {
+    for(i=0; i<nitems; )
+      switch(prop[i++]) {
+      case TAG_DRI_VERSION:
+	if(i<nitems)
+	  dri->dri_Version=prop[i++];
+	break;
+#ifdef USE_FONTSETS
+      case TAG_DRI_FONTSET:
+	if(i<nitems)
+	  dri->dri_FontSetAtom=prop[i++];
+	break;
+#else
+      case TAG_DRI_FONT:
+	if(i<nitems)
+	  dri->dri_Font=XQueryFont(dpy, prop[i++]);
+	break;
+#endif
+      case TAG_DRI_PENS:
+	if(i<nitems) {
+	  n=prop[i++];
+	  if(n>nitems-i)
+	    n=nitems-i;
+	  if(n>0) {
+	    dri->dri_NumPens=n;
+	    if((dri->dri_Pens=calloc(sizeof(unsigned long), n)))
+	      for(j=0; j<n; j++)
+		dri->dri_Pens[j]=prop[i++];
+	  }
+	}
+	break;
+      }
+  }
+  if(prop)
+    XFree(prop);
+}
+
+Status myXAllocNamedColor(Display *dpy, Colormap cmap, char *color_name,
+			  XColor *screen_def, XColor *exact_def)
+{
+  Status s;
+
+  if((s=XAllocNamedColor(dpy, cmap, color_name, screen_def, exact_def)))
+    return s;
+  if((s=XLookupColor(dpy, cmap, color_name, screen_def, exact_def))||
+     (s=XParseColor(dpy, cmap, color_name, exact_def))) {
+    *screen_def = *exact_def;
+    screen_def->pixel = 0;
+    screen_def->flags = DoRed|DoGreen|DoBlue;
+    s=XAllocColor(dpy, cmap, screen_def);
+  }
+  return s;
+}
+
+unsigned long allocdripen(Display *dpy, int n, Colormap cm)
+{
+  XColor screen, exact;
+  char *name;
+
+  if(!myXAllocNamedColor(dpy, cm, name = default_colors[n],
+			 &screen, &exact)) {
+    fprintf(stderr, "%s: cannot allocate color %s\n", progname, name);
+    exit(1);
+  }
+  return screen.pixel;
+}
+
+void term_dri(struct DrawInfo *dri, Display *dpy, Colormap cm)
+{
+  if(dri->dri_Pens) {
+    XFreeColors(dpy, cm, dri->dri_Pens, dri->dri_NumPens, 0);
+    free(dri->dri_Pens);
+    dri->dri_Pens = NULL;
+  }
+#ifdef USE_FONTSETS
+  if(dri->dri_FontSet) {
+    XFreeFontSet(dpy, dri->dri_FontSet);
+    dri->dri_FontSet = NULL;
+  }
+#else
+  if(dri->dri_Font) {
+    XFreeFont(dpy, dri->dri_Font);
+    dri->dri_Font = NULL;
+  }
+#endif
+}
+
+void init_dri(struct DrawInfo *dri, Display *dpy, Window root, Colormap cm,
+	      int override)
+{
+  int i;
+  Atom driatom, dritypatom;
+
+  driatom=XInternAtom(dpy, "AMIWM_DRAWINFO", False);
+  dritypatom=XInternAtom(dpy, "DRAWINFO", False);
+  if(!override) {
+    memset(dri, 0, sizeof(*dri));
+    getdriprop(dpy, driatom, dritypatom, root, dri);
+  }
+  if(!dri->dri_Version)
+    dri->dri_Version = DRI_VERSION;
+  if(!dri->dri_Pens) {
+    if(!(dri->dri_Pens = calloc(sizeof(unsigned long), NUMDRIPENS))) {
+      fprintf(stderr, "%s: out of memory\n", progname);
+      exit(1);
+    }
+    for(i=0; i<NUMDRIPENS; i++)
+      dri->dri_Pens[i] = allocdripen(dpy, i, cm);
+    dri->dri_NumPens = NUMDRIPENS;
+  }
+#ifdef USE_FONTSETS
+  if(!dri->dri_FontSet)
+    {
+      char *fn;
+      XFontStruct **fsl;
+      char **fnl;
+      char **missing_charsets = NULL;
+      int n_missing_charsets = 0;
+
+      if(dri->dri_FontSetAtom) {
+	fn = XGetAtomName(dpy, dri->dri_FontSetAtom);
+      } else {
+	dri->dri_FontSetAtom = XInternAtom(dpy, fn=default_screenfont, False);
+      }
+
+      dri->dri_FontSet = XCreateFontSet(dpy, fn,
+					&missing_charsets,
+					&n_missing_charsets, NULL);
+      if(missing_charsets)
+	XFreeStringList(missing_charsets);
+      if(!dri->dri_FontSet) {
+	fprintf(stderr, "%s: cannot open font %s\n", progname, fn);
+	exit(1);
+      }
+      if(XFontsOfFontSet(dri->dri_FontSet, &fsl, &fnl) < 1) {
+	fprintf(stderr, "%s: fontset %s is empty\n", progname, fn);
+	exit(1);
+      }
+      if(fn != default_screenfont)
+	XFree(fn);
+#if 0
+      //dri->dri_Font = fsl[0];
+      dri->dri_Font = malloc(sizeof(XFontStruct));
+      memcpy(dri->dri_Font, fsl[0], sizeof(XFontStruct));
+#else
+      dri->dri_Ascent = fsl[0]->ascent;
+      dri->dri_Descent = fsl[0]->descent;
+      dri->dri_MaxBoundsWidth = fsl[0]->max_bounds.width;
+#endif
+    }
+#else
+  if(!dri->dri_Font)
+    if(!(dri->dri_Font = XLoadQueryFont(dpy, default_screenfont))) {
+      fprintf(stderr, "%s: cannot open font %s\n", progname,
+	      default_screenfont);
+      exit(1);
+    }
+  dri->dri_Ascent = dri->dri_Font->ascent;
+  dri->dri_Descent = dri->dri_Font->descent;
+  dri->dri_MaxBoundsWidth = dri->dri_Font->max_bounds.width;
+#endif
+  if(override)
+    setdriprop(dpy, driatom, dritypatom, root, dri);
+}
diff --git a/libami/drawinfo.h b/libami/drawinfo.h
new file mode 100644
index 0000000..ca58198
--- /dev/null
+++ b/libami/drawinfo.h
@@ -0,0 +1,65 @@
+#ifndef DRAWINFO_H
+#include <X11/Xlib.h>
+#include <X11/Xmd.h>
+
+#define DRI_VERSION     (2)
+
+struct DrawInfo
+{
+    CARD16        dri_Version;    /* will be  DRI_VERSION                 */
+    CARD16        dri_NumPens;    /* guaranteed to be >= 9                */
+    unsigned long *dri_Pens;      /* pointer to pen array                 */
+ 
+#ifdef USE_FONTSETS
+    XFontSet     dri_FontSet;    /* screen default font          */
+#else
+    XFontStruct  *dri_Font;      /* screen default font          */
+#endif
+    CARD16       dri_Depth;      /* (initial) depth of screen bitmap     */
+ 
+    struct {      /* from DisplayInfo database for initial display mode */
+        CARD16   X;
+        CARD16   Y;
+    }           dri_Resolution;
+ 
+    BITS32      dri_Flags;              /* defined below                */
+/* New for V39: dri_CheckMark, dri_AmigaKey. */
+    Pixmap      dri_CheckMark; /* pointer to scaled checkmark image
+                                         * Will be NULL if DRI_VERSION < 2
+                                         */
+    Pixmap      dri_AmigaKey;  /* pointer to scaled Amiga-key image
+                                         * Will be NULL if DRI_VERSION < 2
+                                         */
+    CARD32      dri_Ascent;
+    CARD32      dri_Descent;
+    CARD32      dri_MaxBoundsWidth;
+#ifdef USE_FONTSETS
+    Atom        dri_FontSetAtom;
+    CARD32      dri_Reserved;        /* avoid recompilation ;^)      */
+#else
+    CARD32      dri_Reserved[2];        /* avoid recompilation ;^)      */
+#endif
+};
+
+#define DETAILPEN        (0x0000)     /* compatible Intuition rendering pens */
+#define BLOCKPEN         (0x0001)     /* compatible Intuition rendering pens */
+#define TEXTPEN          (0x0002)     /* text on background                  */
+#define SHINEPEN         (0x0003)     /* bright edge on 3D objects           */
+#define SHADOWPEN        (0x0004)     /* dark edge on 3D objects             */
+#define FILLPEN          (0x0005)     /* active-window/selected-gadget fill  */
+#define FILLTEXTPEN      (0x0006)     /* text over FILLPEN                   */
+#define BACKGROUNDPEN    (0x0007)     /* always color 0                      */
+#define HIGHLIGHTTEXTPEN (0x0008)     /* special color text, on background   */
+/* New for V39, only present if DRI_VERSION >= 2: */
+#define BARDETAILPEN     (0x0009)     /* text/detail in screen-bar/menus */
+#define BARBLOCKPEN      (0x000A)     /* screen-bar/menus fill */
+#define BARTRIMPEN       (0x000B)     /* trim under screen-bar */
+ 
+#define NUMDRIPENS       (0x000C)
+
+#define DRAWINFO_H
+
+extern void term_dri(struct DrawInfo *, Display *, Colormap);
+extern void init_dri(struct DrawInfo *, Display *, Window, Colormap, int);
+
+#endif
diff --git a/libami/error.c b/libami/error.c
new file mode 100644
index 0000000..d2df879
--- /dev/null
+++ b/libami/error.c
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <string.h>
+#include "libami.h"
+
+#ifndef AMIGAOS
+
+static int amiga_errno=0;
+
+#define MIN_ERRNO 103
+
+static const char *syserrmsg[] = {
+  "not enough memory available", /* 103 */
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+  "bad template", /* 114 */
+  "bad number", /* 115 */
+  "required argument missing", /* 116 */
+  "value after keyword missing", /* 117 */
+  "wrong number of arguments", /* 118 */
+  NULL,
+  "argument line invalid or too long" /* 120 */
+};
+
+BOOL Fault(LONG code, UBYTE *header, UBYTE *buffer, LONG len)
+{
+  amiga_errno=code;
+  if(header) {
+    int hdlen=strlen((char *)header);
+    if(hdlen+2>len)
+      return FALSE;
+    strcpy((char *)buffer, (char *)header);
+    buffer+=hdlen;
+    *buffer++=':';
+    *buffer++=' ';
+    len-=hdlen+2;
+  }
+  if(code>=MIN_ERRNO && code<MIN_ERRNO+sizeof(syserrmsg)/sizeof(syserrmsg[0])
+     && syserrmsg[code-MIN_ERRNO]) {
+    if(len<strlen(syserrmsg[code-MIN_ERRNO])+1)
+      return FALSE;
+    strcpy((char *)buffer, syserrmsg[code-MIN_ERRNO]);
+  } else {
+    char number[6+4*sizeof(LONG)];
+    sprintf(number, "Error %ld", code);
+    if(len<strlen(number)+1)
+      return FALSE;
+    strcpy((char *)buffer, number);
+  }
+  return TRUE;
+}
+
+BOOL PrintFault(LONG code, UBYTE *header)
+{
+  UBYTE buf[128];
+  if(Fault(code, header, buf, sizeof(buf))) {
+    fprintf(stderr, "%s\n", (char *)buf);
+    return TRUE;
+  } else return FALSE;
+}
+
+LONG IoErr()
+{
+  return amiga_errno;
+}
+
+LONG SetIoErr(LONG code)
+{
+  LONG old_errno=amiga_errno;
+  amiga_errno=code;
+  return old_errno;
+}
+
+#endif
diff --git a/libami/eventdispatcher.c b/libami/eventdispatcher.c
new file mode 100644
index 0000000..1227d86
--- /dev/null
+++ b/libami/eventdispatcher.c
@@ -0,0 +1,21 @@
+#include "libami.h"
+
+static int (*eventfunc[LASTEvent])(XEvent*);
+
+static unsigned long eventmask=0;
+
+static void eb_dispatch(XEvent *e, unsigned long mask)
+{
+  if(e->type<0 || e->type>=LASTEvent || (!eventfunc[e->type]) ||
+     (!eventfunc[e->type](e)))
+    cx_send_event(mask, e);
+}
+
+void cx_event_broker(int type, unsigned long mask, int (*callback)(XEvent*))
+{
+  if(type>=0 && type<LASTEvent) {
+    eventfunc[type]=callback;
+    cx_broker(eventmask|=mask, eb_dispatch);
+  }
+}
+
diff --git a/libami/hotkey.c b/libami/hotkey.c
new file mode 100644
index 0000000..c244f27
--- /dev/null
+++ b/libami/hotkey.c
@@ -0,0 +1,152 @@
+#include "libami.h"
+#include <X11/keysym.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct hotkey {
+  struct hotkey *next;
+  KeySym keysym;
+  unsigned int mod0;
+  int keycode;
+  unsigned int modifiers;
+  int meta, position;
+  int grab;
+  void (*callback)(XEvent *, void *);
+  void *client_data;
+} *hotkeys = NULL;
+
+static XModifierKeymap *modmap=NULL;
+static KeySym *keymap=NULL;
+static int kbd_mincode, kbd_maxcode, kbd_maxsym;
+static unsigned int meta_mask, switch_mask;
+static Display *dpy=NULL;
+
+static void lookup_meta()
+{
+  int i, j, k;
+  KeySym *kp;
+  unsigned int alt_mask = 0;
+
+  meta_mask = switch_mask = 0;
+  for(i=3; i<8; i++)
+    for(j=0; j<modmap->max_keypermod; j++)
+      for(kp=keymap+(modmap->modifiermap[i*modmap->max_keypermod+j]-
+		     kbd_mincode)*kbd_maxsym, k=0; k<kbd_maxsym; k++)
+	switch(*kp++) {
+	case XK_Meta_L:
+	case XK_Meta_R:
+	  meta_mask|=1<<i;
+	  break;
+	case XK_Mode_switch:
+	  switch_mask|=1<<i;
+	  break;
+	case XK_Alt_L:
+	case XK_Alt_R:
+	  alt_mask|=1<<i;
+	  break;
+	}
+  if(meta_mask == 0)
+    meta_mask = (alt_mask? alt_mask :
+		 (switch_mask? switch_mask : Mod1Mask));
+}
+
+static void lookup_hotkey(struct hotkey *hk)
+{
+  if(!keymap) {
+    XDisplayKeycodes(dpy, &kbd_mincode, &kbd_maxcode);
+    keymap=XGetKeyboardMapping(dpy, kbd_mincode, kbd_maxcode-kbd_mincode+1,
+			       &kbd_maxsym);
+  }
+  if(!modmap) {
+    modmap=XGetModifierMapping(dpy);
+    if(keymap)
+      lookup_meta();
+  }
+  hk->modifiers=hk->mod0|(hk->meta? meta_mask:0);
+  if(!(hk->keycode=XKeysymToKeycode(dpy, hk->keysym)))
+    if((hk->keysym&~0x20)>=XK_A && (hk->keysym&~0x20)<=XK_Z)
+      hk->keycode=XKeysymToKeycode(dpy, hk->keysym^0x20);
+
+  if(hk->keycode && keymap)
+    if(keymap[(hk->keycode-kbd_mincode)*kbd_maxsym])
+      ;
+    else if(kbd_maxsym>1 && keymap[(hk->keycode-kbd_mincode)*kbd_maxsym+1])
+      hk->modifiers|=ShiftMask;
+    else if(kbd_maxsym>2 && keymap[(hk->keycode-kbd_mincode)*kbd_maxsym+2])
+      hk->modifiers|=switch_mask;
+    else if(kbd_maxsym>3 && keymap[(hk->keycode-kbd_mincode)*kbd_maxsym+3])
+      hk->modifiers|=ShiftMask|switch_mask;
+}
+
+static void rethink_keymap()
+{
+  struct hotkey *hk;
+
+  if(keymap) {
+    XFree(keymap);
+    keymap=NULL;
+  }
+  if(modmap) {
+    XFreeModifiermap(modmap);
+    modmap=NULL;
+  }
+  for(hk=hotkeys; hk; hk=hk->next) {
+    int oldkc=hk->keycode;
+    unsigned oldmd=hk->modifiers;
+    lookup_hotkey(hk);
+    if(hk->grab>=0 && (hk->keycode!=oldkc || hk->modifiers!=oldmd)) {
+      md_ungrabkey(hk->grab);
+      hk->grab=-1;
+    }
+    if((hk->position & IN_WINDOW_MASK) && hk->grab<0)
+      hk->grab=md_grabkey(hk->keycode, hk->modifiers);
+  }
+}
+
+static int mappingfunc(XEvent *e)
+{
+  if(e->xmapping.request==MappingKeyboard ||
+     e->xmapping.request==MappingModifier) {
+    e->xmapping.display=dpy;
+    XRefreshKeyboardMapping(&e->xmapping);
+  }
+  rethink_keymap();
+  return 0;
+}
+
+static int keypressfunc(XEvent *e)
+{
+  struct hotkey *hk;
+
+  for(hk=hotkeys; hk; hk=hk->next)
+    if(hk->keycode==e->xkey.keycode &&
+       (hk->modifiers==e->xkey.state || (hk->modifiers & AnyModifier))) {
+      hk->callback(e, hk->client_data);
+      return 1;
+    }
+  
+  return 0;
+}
+
+void cx_hotkey(KeySym ks, unsigned int mod, int m, int pos,
+	       void (*cb)(XEvent *, void *), void *cd)
+{
+  struct hotkey *hk=malloc(sizeof(struct hotkey));
+  if(hk) {
+    if(!dpy) {
+      dpy=md_display();
+      cx_event_broker(KeyPress, KeyPressMask, keypressfunc);
+      cx_event_broker(MappingNotify, 0, mappingfunc);
+    }
+    hk->next=hotkeys;
+    hk->keysym=ks;
+    hk->mod0=mod;
+    hk->meta=m;
+    hk->position=pos;
+    hk->callback=cb;
+    hk->client_data=cd;
+    lookup_hotkey(hk);
+    hk->grab=((pos&IN_WINDOW_MASK)? md_grabkey(hk->keycode, hk->modifiers):-1);
+    hotkeys=hk;
+  }
+}
diff --git a/libami/iconlib.c b/libami/iconlib.c
new file mode 100644
index 0000000..1c07d6f
--- /dev/null
+++ b/libami/iconlib.c
@@ -0,0 +1,579 @@
+#include "libami.h"
+#include "alloc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+#ifndef AMIGAOS
+
+#define	WBDISK		1
+#define	WBDRAWER	2
+#define	WBTOOL		3
+#define	WBPROJECT	4
+#define	WBGARBAGE	5
+#define	WBDEVICE	6
+#define	WBKICK		7
+#define WBAPPICON	8
+
+#define WB_DISKMAGIC    0xe310
+
+
+char *BumpRevision(char *newbuf, char *oldname)
+{
+  char tmpbuf[32];
+  int n;
+  if(!strncmp(oldname, "copy_of_", 8)) {
+    sprintf(newbuf, "copy_2_of_%.*s", 20, oldname);
+  } else if(2==sscanf(oldname, "copy_%d_of_%30s", &n, tmpbuf)) {
+    sprintf(newbuf, "copy_%d_of_", n+1);
+    tmpbuf[30-strlen(newbuf)]='\0';
+    strcat(newbuf, tmpbuf);
+  } else {
+    sprintf(newbuf, "copy_of_%.*s", 22, oldname);
+  }
+  return newbuf;
+}
+
+BOOL DeleteDiskObject(char *name)
+{
+  int res;
+#ifdef HAVE_ALLOCA
+  char *infoname=alloca(strlen(name)+8);
+#else
+  char *infoname=malloc(strlen(name)+8);
+  if(infoname==NULL)
+    return FALSE;
+#endif
+  sprintf(infoname, "%s.info", name);
+  res=unlink(infoname)>=0;
+#ifndef HAVE_ALLOCA
+  free(infoname);
+#endif
+  return res;
+}
+
+char *FindToolType(char **toolTypeArray, char *typeName)
+{
+  char *p;
+  while((p=*toolTypeArray++)) {
+    char *p2=typeName;
+    while(*p2)
+      if(ToUpper(*p2)!=ToUpper(*p))
+	break;
+      else { p2++; p++; }
+    if(!*p2) {
+      if(!*p) return p;
+      if(*p=='=') return p+1;
+    }
+  }
+  return NULL;
+}
+
+void FreeDiskObject(struct DiskObject *diskobj)
+{
+  if(diskobj->do_Gadget.GadgetRender) free(diskobj->do_Gadget.GadgetRender);
+  if(diskobj->do_Gadget.SelectRender) free(diskobj->do_Gadget.SelectRender);
+  if(diskobj->do_DefaultTool) free(diskobj->do_DefaultTool);
+  if(diskobj->do_ToolTypes) {
+    char *p, **pp=diskobj->do_ToolTypes;
+    while((p=*pp++)) free(p);
+    free(diskobj->do_ToolTypes);
+  }
+  if(diskobj->do_DrawerData) free(diskobj->do_DrawerData);
+  if(diskobj->do_ToolWindow) free(diskobj->do_ToolWindow);
+  free(diskobj);
+}
+
+static UWORD getu16(char **p)
+{
+  union { UWORD n; char b[2]; } v;
+
+#ifdef LAME_ENDIAN
+  v.b[1]=*(*p)++;
+  v.b[0]=*(*p)++;
+#else
+  v.b[0]=*(*p)++;
+  v.b[1]=*(*p)++;
+#endif
+  return v.n;
+}
+
+static WORD get16(char **p)
+{
+  union { WORD n; char b[2]; } v;
+
+#ifdef LAME_ENDIAN
+  v.b[1]=*(*p)++;
+  v.b[0]=*(*p)++;
+#else
+  v.b[0]=*(*p)++;
+  v.b[1]=*(*p)++;
+#endif
+  return v.n;
+}
+
+static ULONG getu32(char **p)
+{
+  union { ULONG n; char b[4]; } v;
+
+#ifdef LAME_ENDIAN
+  v.b[3]=*(*p)++;
+  v.b[2]=*(*p)++;
+  v.b[1]=*(*p)++;
+  v.b[0]=*(*p)++;
+#else
+  v.b[0]=*(*p)++;
+  v.b[1]=*(*p)++;
+  v.b[2]=*(*p)++;
+  v.b[3]=*(*p)++;
+#endif
+  return v.n;
+}
+
+static LONG get32(char **p)
+{
+  union { LONG n; char b[4]; } v;
+
+#ifdef LAME_ENDIAN
+  v.b[3]=*(*p)++;
+  v.b[2]=*(*p)++;
+  v.b[1]=*(*p)++;
+  v.b[0]=*(*p)++;
+#else
+  v.b[0]=*(*p)++;
+  v.b[1]=*(*p)++;
+  v.b[2]=*(*p)++;
+  v.b[3]=*(*p)++;
+#endif
+  return v.n;
+}
+
+
+#define SANITYMAXLEN (1<<20)
+
+static char *loadstring(FILE *f)
+{
+  ULONG l;
+  char buf[4], *p=buf;
+  if(1!=fread(buf, 4, 1, f) || (l=getu32(&p))>SANITYMAXLEN || !(p=malloc(l)))
+    return NULL;
+  fread(p, 1, l, f);
+  return p;
+}
+
+static char **loadtooltypes(FILE *f)
+{
+  LONG i, n;
+  char **p, buf[4], *tp=buf;
+  if(1!=fread(buf, 4, 1, f) || (n=(getu32(&tp)>>2))>SANITYMAXLEN ||
+     !(p=calloc(n, sizeof(char *))))
+    return NULL;
+  --n;
+  for(i=0; i<n; i++)
+    if(!(p[i]=loadstring(f))) {
+      while(--i>=0)
+	free(p[i]);
+      free(p);
+      return NULL;
+    }
+  return p;
+}
+
+#define MAXICONSIZE 2000
+
+static struct Image *loadimage(FILE *f)
+{
+  char buf[20], *p=buf;
+  WORD le, te, w, h, d;
+  int imgsz;
+  struct Image *im;
+  if(1!=fread(buf, 20, 1, f))
+    return NULL;
+  le=get16(&p); te=get16(&p); w=get16(&p); h=get16(&p); d=get16(&p);
+  if(w<=0 || w>MAXICONSIZE || h<=0 || h>MAXICONSIZE || d<1 || d>8)
+    return NULL;
+  imgsz=2*((w+15)>>4)*h*d;
+  if(!(im=malloc(imgsz+sizeof(struct Image))))
+    return NULL;
+  im->LeftEdge=le; im->TopEdge=te; im->Width=w; im->Height=h;
+  im->Depth=d; im->ImageData=(UWORD*)getu32(&p);
+  im->PlanePick=*p++; im->PlaneOnOff=*p++;
+  im->NextImage=(struct Image *)getu32(&p);
+  if(im->ImageData) {
+    im->ImageData=(UWORD *)(im+1);
+    fread(im->ImageData, 1, imgsz, f);
+  }
+  return im;
+}
+
+static struct Image *backfillimage(struct Image *im)
+{
+  return NULL;
+}
+
+#define GETBITS(v,n) do{if(bits<(n)){if(!srclen--)return dst-dst0;data=(data\
+<<8)|*src++;bits+=8;};v=(data>>(bits-(n)))&((1<<(n))-1);bits-=(n);}while(0)
+
+static LONG unpack_rle(unsigned char *src, LONG srclen, char *dst, LONG dstlen,
+		       int bpp, int comp)
+{
+  char *dst0 = dst;
+  unsigned char *srcn = src+srclen;
+  int bits=0, data=0;
+  if(!comp) {
+    if(srclen>dstlen)
+      srclen = dstlen;
+    memcpy(dst, src, srclen);
+    return srclen;
+  }
+  while(dstlen>0) {
+    int code;
+    GETBITS(code, 8);
+    if(code&0x80) {
+      char rpt;
+      GETBITS(rpt, bpp);
+      code -= 0x100;
+      if((dstlen-=(1-code))<0)
+	break;
+      do { *dst++ = rpt; } while(code++);
+    } else {
+      if((dstlen-=(code+1))<0)
+	break;
+      do GETBITS(*dst++, bpp); while(code--);
+    }
+  }
+  if(src != srcn)
+    fprintf(stderr, "Warning:  Left %d bytes unused.\n", srcn-src);
+  return dst-dst0;
+}
+
+static void decode_IMAG(unsigned char *buf, LONG len, int width, int height,
+			APTR *im)
+{
+  struct {
+    int transp, ncolors, flags, bodycomp, palcomp, bpp;
+    int bodybytes, palbytes;
+  } hdr;
+  char *dbuf;
+  struct Image *ii;
+
+  if(len<10)
+    return;
+
+  hdr.transp = *buf++;
+  hdr.ncolors = (*buf++)+1;
+  hdr.flags = *buf++;
+  hdr.bodycomp = *buf++;
+  hdr.palcomp = *buf++;
+  hdr.bpp = *buf++;
+  hdr.bodybytes = ((buf[0]<<8)|(buf[1]))+1;
+  hdr.palbytes = ((buf[2]<<8)|(buf[3]))+1;
+  buf+=4;
+  len -= 10;
+  if(!(hdr.flags&1))
+    hdr.transp = -1;
+  if(!(hdr.flags&2))
+    hdr.ncolors = 0;
+
+  if(hdr.bodybytes > len)
+    hdr.bodybytes = len;
+  if(hdr.palbytes+hdr.bodybytes > len)
+    hdr.palbytes = len-hdr.bodybytes;
+
+  if(hdr.bodycomp>1 || hdr.palcomp>1)
+    return;
+
+  if((dbuf = malloc(sizeof(struct Image)+width*height+3*hdr.ncolors+3))==NULL)
+    return;
+
+  /* body */
+  if(unpack_rle(buf, hdr.bodybytes, dbuf+sizeof(struct Image), width*height,
+		hdr.bpp, hdr.bodycomp) != width*height) {
+    free(dbuf);
+    return;
+  }
+  /* palette */
+  if(unpack_rle(buf+hdr.bodybytes, hdr.palbytes,
+		dbuf+sizeof(struct Image)+width*height+3, 3*hdr.ncolors,
+		8, hdr.palcomp) != 3*hdr.ncolors) {
+    free(dbuf);
+    return;
+  }
+
+  if(*im != NULL)
+    free(*im);
+  *im = (APTR) (ii = (struct Image *)dbuf);
+  dbuf += sizeof(struct Image);
+  ii->ImageData = (UWORD *)dbuf;
+  dbuf += width*height;
+
+  *dbuf++ = hdr.transp;
+  *dbuf++ = hdr.ncolors-1;
+  *dbuf++ = hdr.flags;
+
+  ii->LeftEdge = ii->TopEdge = 0;
+  ii->Width = width;
+  ii->Height = height;
+  ii->Depth = -1;
+  ii->PlanePick = ii->PlaneOnOff = 0;
+  ii->NextImage = NULL;
+
+  return;
+}
+
+static void decode_glowicon(struct DiskObject *diskobj, char *glow, LONG len)
+{
+  int imgno=0, gotface=0;
+  struct { char width, height; UWORD dunno1, dunno2; } face;
+  while(len>=8) {
+    ULONG id = getu32(&glow);
+    LONG clen = get32(&glow);
+    char *chunk = glow;
+    len -= 8;
+    if(clen<0)
+      clen = len;
+    if(clen>len)
+      break;
+    switch(id) {
+     case 0x46414345: /* FACE */
+       if(clen>=6) {
+	 face.width = 1+*chunk++;
+	 face.height = 1+*chunk++;
+	 face.dunno1 = getu16(&chunk);
+	 face.dunno2 = getu16(&chunk);
+	 gotface = 1;
+	 diskobj->do_Gadget.Width = face.width;
+	 diskobj->do_Gadget.Height = face.height;
+       break;
+       }
+       break;
+     case 0x494d4147: /* IMAG */
+       if(!gotface || imgno>1)
+	 break;
+       decode_IMAG((unsigned char *)chunk, clen, face.width, face.height,
+		   (imgno++? &diskobj->do_Gadget.SelectRender :
+		    &diskobj->do_Gadget.GadgetRender));
+       break;
+    }
+    if(clen&1)
+      clen++;
+    len -= clen;
+    glow += clen;
+  }
+}
+
+static struct DiskObject *int_load_do(char *filename)
+{
+  FILE *f;
+  struct DiskObject *diskobj;
+  char buf[78], *p=buf;
+  int error=0;
+  if((f=fopen(filename, "r"))) {
+    if(1==fread(buf, 78, 1, f) &&
+       (diskobj=calloc(1, sizeof(struct DiskObject)))) {
+      diskobj->do_Magic=getu16(&p); diskobj->do_Version=getu16(&p);
+      if(diskobj->do_Magic!=WB_DISKMAGIC) {
+	free(diskobj);
+	return NULL;
+      }
+      diskobj->do_Gadget.NextGadget=(struct Gadget *)getu32(&p);
+      diskobj->do_Gadget.LeftEdge=get16(&p);
+      diskobj->do_Gadget.TopEdge=get16(&p);
+      diskobj->do_Gadget.Width=get16(&p); diskobj->do_Gadget.Height=get16(&p);
+      diskobj->do_Gadget.Flags=getu16(&p);
+      diskobj->do_Gadget.Activation=getu16(&p);
+      diskobj->do_Gadget.GadgetType=getu16(&p);
+      diskobj->do_Gadget.GadgetRender=(APTR)getu32(&p);
+      diskobj->do_Gadget.SelectRender=(APTR)getu32(&p);
+      diskobj->do_Gadget.GadgetText=(struct IntuiText *)getu32(&p);
+      diskobj->do_Gadget.MutualExclude=get32(&p);
+      diskobj->do_Gadget.SpecialInfo=(APTR)getu32(&p);
+      diskobj->do_Gadget.GadgetID=getu16(&p);
+      diskobj->do_Gadget.UserData=(APTR)getu32(&p);
+      diskobj->do_Type=*p; p+=2;
+      diskobj->do_DefaultTool=(char *)getu32(&p);
+      diskobj->do_ToolTypes=(char **)getu32(&p);
+      diskobj->do_CurrentX=get32(&p);
+      diskobj->do_CurrentY=get32(&p);
+      diskobj->do_DrawerData=(struct DrawerData *)getu32(&p);
+      diskobj->do_ToolWindow=(char *)getu32(&p);
+      diskobj->do_StackSize=get32(&p);
+      
+      if(diskobj->do_DrawerData) {
+	struct DrawerData *dd;
+	if(1==fread(buf, 56, 1, f) &&
+	   (diskobj->do_DrawerData=dd=calloc(1, sizeof(struct DrawerData)))) {
+	  p=buf;
+	  dd->dd_NewWindow.LeftEdge=get16(&p);
+	  dd->dd_NewWindow.TopEdge=get16(&p);
+	  dd->dd_NewWindow.Width=get16(&p);
+	  dd->dd_NewWindow.Height=get16(&p);
+	  dd->dd_NewWindow.DetailPen=*p++;
+	  dd->dd_NewWindow.BlockPen=*p++;
+	  dd->dd_NewWindow.IDCMPFlags=getu32(&p);
+	  dd->dd_NewWindow.Flags=getu32(&p);
+	  dd->dd_NewWindow.FirstGadget=(struct Gadget *)getu32(&p);
+	  dd->dd_NewWindow.CheckMark=(struct Image *)getu32(&p);
+	  dd->dd_NewWindow.Title=(UBYTE *)getu32(&p);
+	  dd->dd_NewWindow.Screen=(struct Screen *)getu32(&p);
+	  dd->dd_NewWindow.BitMap=(struct BitMap *)getu32(&p);
+	  dd->dd_NewWindow.MinWidth=get16(&p);
+	  dd->dd_NewWindow.MinHeight=get16(&p);
+	  dd->dd_NewWindow.MaxWidth=getu16(&p);
+	  dd->dd_NewWindow.MaxHeight=getu16(&p);
+	  dd->dd_NewWindow.Type=getu16(&p);
+	  dd->dd_CurrentX=get32(&p);
+	  dd->dd_CurrentY=get32(&p);
+	} else error++;
+      }
+
+      if(!(diskobj->do_Gadget.GadgetRender=loadimage(f)))
+	error++;
+	
+      if(diskobj->do_Gadget.Flags&2)
+	if(!(diskobj->do_Gadget.SelectRender=loadimage(f)))
+	  error++;
+	else ;
+      else if(diskobj->do_Gadget.Flags&1)
+	if(!(diskobj->do_Gadget.SelectRender=
+	     backfillimage((struct Image *)diskobj->do_Gadget.GadgetRender)))
+	  error++;
+	else ;
+      else diskobj->do_Gadget.SelectRender=NULL;
+      
+      if(diskobj->do_DefaultTool)
+	if(!(diskobj->do_DefaultTool=loadstring(f)))
+	  error++;
+
+      if(diskobj->do_ToolTypes)
+	if(!(diskobj->do_ToolTypes=loadtooltypes(f)))
+	  error++;
+
+      if(diskobj->do_ToolWindow)
+	if(!(diskobj->do_ToolWindow=loadstring(f)))
+	  error++;
+
+      if(diskobj->do_DrawerData && diskobj->do_Version) {
+	char buf[6], *p=buf;
+	if(1==fread(buf, 6, 1, f)) {
+	  diskobj->do_DrawerData->dd_Flags=getu32(&p);
+	  diskobj->do_DrawerData->dd_ViewModes=getu16(&p);
+	}
+      }
+
+      if(diskobj->do_Version) {
+	/* Check for GlowIcon */
+	char buf[8], *p = buf, *glowicon;
+	LONG len;
+	if(1==fread(buf, 4, 1, f) && !strncmp(buf, "FORM", 4) &&
+	   1==fread(buf, 8, 1, f) && !strncmp(buf+4, "ICON", 4) &&
+	   (len = get32(&p))>4 && (glowicon = malloc(len))!=NULL) {
+	  if(1==fread(glowicon, len-4, 1, f))
+	    decode_glowicon(diskobj, glowicon, len-4);
+	  free(glowicon);
+	}
+      }
+
+      if(!error) {
+	fclose(f);
+	return diskobj;
+      }
+
+      FreeDiskObject(diskobj);
+    }
+    fclose(f);
+    }
+  return NULL;
+}
+
+struct DiskObject *GetDefDiskObject(LONG def_type)
+{
+  static char *defnames[]= {
+    "disk", "drawer", "tool", "project",
+    "garbage", "device", "kick", "appicon"
+  };
+  static char *icondir=NULL;
+  static int l;
+  char *buf;
+  struct DiskObject *diskobj;
+
+  if(def_type<WBDISK || def_type>WBAPPICON)
+    return NULL;
+  if(!icondir)
+    if(!(icondir = get_current_icondir()))
+      return NULL;
+    else
+      l = strlen(icondir);
+
+#ifdef HAVE_ALLOCA
+  buf = alloca(l+18);
+#else
+  buf = malloc(l+18);
+  if(buf==NULL) return NULL;
+#endif
+  sprintf(buf, "%s/def_%s.info", icondir, defnames[def_type-WBDISK]);
+  diskobj=int_load_do(buf);
+#ifndef HAVE_ALLOCA
+  free(buf);
+#endif
+  return diskobj;
+}
+
+struct DiskObject *GetDiskObject(char *name)
+{
+  struct DiskObject *diskobj;
+#ifdef HAVE_ALLOCA
+  char *buf = alloca(strlen(name)+6);
+#else
+  char *buf = malloc(strlen(name)+6);
+  if(buf==NULL) return NULL;
+#endif
+  sprintf(buf, "%s.info", name);
+  diskobj=int_load_do(buf);
+#ifndef HAVE_ALLOCA
+  free(buf);
+#endif
+  return diskobj;
+}
+
+struct DiskObject *GetDiskObjectNew(char *name)
+{
+  struct DiskObject *d;
+  struct stat st;
+
+  if((d=GetDiskObject(name))) return d;
+  if(stat(name, &st)<0) return NULL;
+  if(S_ISREG(st.st_mode))
+    if(st.st_mode&0555)
+      return GetDefDiskObject(WBTOOL);
+    else
+      return GetDefDiskObject(WBPROJECT);
+  else if(S_ISDIR(st.st_mode))
+    return GetDefDiskObject(WBDRAWER);
+  else if(S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
+    return GetDefDiskObject(WBDEVICE);
+  else
+    return NULL;
+}
+
+#ifdef notdef
+
+BOOL MatchToolValue(char *typeString, char *value)
+{
+
+}
+
+BOOL PutDiskObject(char *name, struct DiskObject *diskobj)
+{
+
+}
+
+#endif
+
+#endif
diff --git a/libami/iconutil.c b/libami/iconutil.c
new file mode 100644
index 0000000..43275cc
--- /dev/null
+++ b/libami/iconutil.c
@@ -0,0 +1,126 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+#include "libami.h"
+#include "alloc.h"
+#include "drawinfo.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+Pixmap image_to_pixmap(Display *dpy, Window win, GC gc, unsigned long bg,
+		       unsigned long *iconcolor, int iconcolormask,
+		       struct Image *im, int width, int height,
+		       struct ColorStore *cs)
+{
+  int bpr, bitmap_pad, x, y;
+  XImage *ximg;
+  unsigned char *img;
+  Pixmap pm;
+  XWindowAttributes attr;
+  int fail=0;
+
+  if(!dpy || !win || !gc || !im || !(img=(unsigned char *)im->ImageData))
+    return None;
+
+  if(width<=0) width=im->Width;
+  if(height<=0) height=im->Height;
+
+  XGetWindowAttributes(dpy, win, &attr);
+  
+  bpr=2*((im->Width+15)>>4);
+  if (attr.depth > 16)
+    bitmap_pad = 32;
+  else if (attr.depth > 8)
+    bitmap_pad = 16;
+  else
+    bitmap_pad = 8;
+  ximg=XCreateImage(dpy, attr.visual, attr.depth, ZPixmap, 0, NULL,
+		    im->Width, im->Height, bitmap_pad, 0);
+#ifndef HAVE_ALLOCA
+  if(!(ximg->data = malloc(ximg->bytes_per_line * im->Height))) {
+    XDestroyImage(ximg);
+    return None;
+  }
+#else
+  ximg->data = alloca(ximg->bytes_per_line * im->Height);
+#endif
+  if(im->Depth==-1) {
+    int transp, ncolors, flags;
+    unsigned char *pal = img + im->Width * im->Height;
+    unsigned long ic[256];
+    transp = *pal++;
+    ncolors = 1+*pal++;
+    flags = *pal++;
+    if(!(flags&1))
+      transp = -1;
+    if(!(flags&2))
+      ncolors = 0;
+    memset(ic, 0, sizeof(ic));
+    if(!ncolors) {
+      if(cs) cs->colors = NULL;
+    } else if(!cs || !(cs->colors = calloc(ncolors, sizeof(unsigned long)))) {
+      ncolors = 0;
+      fail = 1;
+    }
+    for(x=0; x<ncolors; x++) {
+      XColor color;
+      color.pixel = 0;
+      color.red = (*pal++)*0x101;
+      color.green = (*pal++)*0x101;
+      color.blue = (*pal++)*0x101;
+      color.flags = DoRed|DoGreen|DoBlue;
+      XAllocColor(dpy, attr.colormap, &color);
+      ic[x] = color.pixel;
+    }      
+    if(cs) {
+      cs->cmap = attr.colormap;
+      cs->ncolors = ncolors;
+      if(ncolors) memcpy(cs->colors, ic, ncolors*sizeof(unsigned long));
+    }
+    for(y=0; y<im->Height; y++)
+      for(x=0; x<im->Width; x++)
+	XPutPixel(ximg, x, y, ic[*img++]);
+  } else
+    for(y=0; y<im->Height; y++)
+      for(x=0; x<im->Width; x++) {
+	unsigned char b=1, v=im->PlaneOnOff&~(im->PlanePick);
+	INT16 p=0;
+	while(p<im->Depth && b) {
+	  if(b&im->PlanePick)
+	    if(img[(p++*im->Height+y)*bpr+(x>>3)]&(128>>(x&7)))
+	      v|=b;
+	  b<<=1;
+	}
+	XPutPixel(ximg, x, y, iconcolor[v&iconcolormask]);
+      }
+  if((pm=(fail?None:XCreatePixmap(dpy, win, width, height, attr.depth)))) {
+    XSetForeground(dpy, gc, bg);
+    XFillRectangle(dpy, pm, gc, 0, 0, width, height);
+    XPutImage(dpy, pm, gc, ximg, 0, 0, im->LeftEdge, im->TopEdge,
+	      im->Width, im->Height);
+  }
+#ifndef HAVE_ALLOCA
+  free(ximg->data);
+#endif
+  ximg->data=NULL;
+  XDestroyImage(ximg);
+  if(pm == None)
+    free_color_store(dpy, cs);
+  return pm;
+}
+
+void free_color_store(Display *dpy, struct ColorStore *cs)
+{
+  if(cs && cs->colors) {
+    XFreeColors(dpy, cs->cmap, cs->colors, cs->ncolors, 0);
+    free(cs->colors);
+    cs->colors = NULL;
+  }
+}
diff --git a/libami/iffparse.c b/libami/iffparse.c
new file mode 100644
index 0000000..675aebd
--- /dev/null
+++ b/libami/iffparse.c
@@ -0,0 +1,163 @@
+#include "libami.h"
+#include "alloc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifndef AMIGAOS
+
+static LONG callIFFHook(struct IFFHandle *iff, LONG cmd, APTR buf, LONG nby)
+{
+  struct IFFStreamCmd c;
+  c.sc_Command = cmd;
+  c.sc_Buf = buf;
+  c.sc_NBytes = nby;
+  if(iff->iff_Hook == NULL)
+    return IFFERR_NOHOOK;
+  else
+    return iff->iff_Hook->h_SubEntry(iff->iff_Hook, iff, &c);
+}
+
+LONG ReadChunkBytes( struct IFFHandle *iff, APTR buf, long numBytes );
+LONG WriteChunkBytes( struct IFFHandle *iff, APTR buf, long numBytes );
+LONG ReadChunkRecords( struct IFFHandle *iff, APTR buf, long bytesPerRecord,
+	long numRecords );
+LONG WriteChunkRecords( struct IFFHandle *iff, APTR buf, long bytesPerRecord,
+	long numRecords );
+
+LONG PushChunk( struct IFFHandle *iff, long type, long id, long size );
+LONG PopChunk( struct IFFHandle *iff );
+
+LONG EntryHandler( struct IFFHandle *iff, long type, long id, long position,
+	struct Hook *handler, APTR object );
+LONG ExitHandler( struct IFFHandle *iff, long type, long id, long position,
+	struct Hook *handler, APTR object );
+
+LONG PropChunk( struct IFFHandle *iff, long type, long id );
+LONG PropChunks( struct IFFHandle *iff, LONG *propArray, long numPairs );
+LONG StopChunk( struct IFFHandle *iff, long type, long id );
+LONG StopChunks( struct IFFHandle *iff, LONG *propArray, long numPairs );
+LONG CollectionChunk( struct IFFHandle *iff, long type, long id );
+LONG CollectionChunks( struct IFFHandle *iff, LONG *propArray,
+	long numPairs );
+LONG StopOnExit( struct IFFHandle *iff, long type, long id );
+
+struct StoredProperty *FindProp( struct IFFHandle *iff, long type, long id );
+struct CollectionItem *FindCollection( struct IFFHandle *iff, long type,
+	long id );
+struct ContextNode *FindPropContext( struct IFFHandle *iff );
+struct ContextNode *CurrentChunk( struct IFFHandle *iff );
+struct ContextNode *ParentChunk( struct ContextNode *contextNode );
+
+struct LocalContextItem *AllocLocalItem( long type, long id, long ident,
+	long dataSize );
+APTR LocalItemData( struct LocalContextItem *localItem );
+void SetLocalItemPurge( struct LocalContextItem *localItem,
+	struct Hook *purgeHook );
+void FreeLocalItem( struct LocalContextItem *localItem );
+struct LocalContextItem *FindLocalItem( struct IFFHandle *iff, long type,
+	long id, long ident );
+LONG StoreLocalItem( struct IFFHandle *iff, struct LocalContextItem *localItem,
+	long position );
+void StoreItemInContext( struct IFFHandle *iff,
+	struct LocalContextItem *localItem,
+	struct ContextNode *contextNode );
+
+LONG GoodID( long id );
+LONG GoodType( long type );
+STRPTR IDtoStr( long id, STRPTR buf );
+
+
+void InitIFF( struct IFFHandle *iff, long flags, struct Hook *streamHook )
+{
+  iff->iff_Flags = flags;
+  iff->iff_Hook = streamHook;
+}
+
+struct IFFHandle *AllocIFF( void )
+{
+  return (struct IFFHandle *)calloc(1, sizeof(struct IFFHandle));
+}
+
+LONG OpenIFF( struct IFFHandle *iff, long rwMode )
+{
+  return callIFFHook(iff, IFFCMD_INIT, NULL, 0);
+}
+
+LONG ParseIFF( struct IFFHandle *iff, long control )
+{
+  return IFFERR_NOHOOK;
+}
+
+void CloseIFF( struct IFFHandle *iff )
+{
+  callIFFHook(iff, IFFCMD_CLEANUP, NULL, 0);
+}
+
+void FreeIFF( struct IFFHandle *iff )
+{
+  free(iff);
+}
+
+
+
+#else
+
+static ULONG __saveds __asm hllDispatch(register __a0 struct Hook *hook,
+					register __a2 APTR object,
+					register __a1 APTR message)
+{
+  return ((ULONG (*)(struct Hook *, APTR, APTR))hook->h_SubEntry)
+    (hook, object, message);
+}
+
+#endif
+
+static ULONG iffFileHook(struct Hook *hook, APTR object, APTR message)
+{
+  struct IFFStreamCmd *cmd = (struct IFFStreamCmd *)message;
+  switch(cmd->sc_Command) {
+  case IFFCMD_INIT:
+    return 0;
+  case IFFCMD_CLEANUP:
+    close(((struct IFFHandle *)object)->iff_Stream);
+    return 0;
+  case IFFCMD_READ:
+    return IFFERR_READ;
+  case IFFCMD_WRITE:
+    return IFFERR_WRITE;
+  case IFFCMD_SEEK:
+    return IFFERR_SEEK;
+  }
+  return 0;
+}
+
+LONG OpenIFFasFile( struct IFFHandle *iff, char *fn, char *mode )
+{
+  static struct Hook hook =
+#ifdef AMIGAOS
+  { { 0, 0 }, hllDispatch, iffFileHook, 0 };
+#else
+  { { 0, 0 }, 0, iffFileHook, 0 };
+#endif
+  int m, fd;
+  LONG r;
+
+  if((fd = open(fn, (strchr(mode, 'w')==NULL? O_RDONLY :
+		     (O_WRONLY|O_TRUNC|O_CREAT)), 0666))<0)
+    return IFFERR_READ;
+  iff->iff_Stream = fd;
+  InitIFF( iff, (strchr(mode, 'w')==NULL? (m=IFFF_READ|IFFF_RSEEK) :
+		 (m=IFFF_WRITE|IFFF_RSEEK)), &hook );
+  if((r=OpenIFF( iff, m ))!=0) {
+    close(fd);
+    return r;
+  }
+  return 0;
+}
diff --git a/libami/kbdsupport.c b/libami/kbdsupport.c
new file mode 100644
index 0000000..c291168
--- /dev/null
+++ b/libami/kbdsupport.c
@@ -0,0 +1,23 @@
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <stdlib.h>
+#include <string.h>
+#include "libami.h"
+#include "module.h"
+
+
+int md_grabkey(int keycode, unsigned int modifiers)
+{
+  int pkt[2], res=-1;
+  char *ptr=NULL;
+  pkt[0]=keycode; pkt[1]=modifiers;
+  if(md_command(None, MCMD_ADD_KEYGRAB, pkt, sizeof(pkt), &ptr)>=sizeof(int))
+    res=*((int*)ptr);
+  if(ptr) free(ptr);
+  return res;
+}
+
+int md_ungrabkey(int id)
+{
+  return md_command0(None, MCMD_DEL_KEYGRAB, &id, sizeof(id));
+}
diff --git a/libami/libami.a b/libami/libami.a
new file mode 100644
index 0000000..c463de3
Binary files /dev/null and b/libami/libami.a differ
diff --git a/libami/libami.h b/libami/libami.h
new file mode 100644
index 0000000..f02f74e
--- /dev/null
+++ b/libami/libami.h
@@ -0,0 +1,393 @@
+#ifndef LIBAMI_H
+#define LIBAMI_H
+
+#include <X11/Xlib.h>
+#include <X11/Xmd.h>
+
+#ifdef AMIGAOS
+#include <exec/types.h>
+#include <exec/nodes.h>
+#include <exec/lists.h>
+#include <utility/hooks.h>
+#include <dos/dos.h>
+#include <dos/rdargs.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <proto/icon.h>
+#include <proto/iffparse.h>
+#include <proto/locale.h>
+#else
+
+#define GLOBAL	extern
+#define IMPORT	extern
+#define STATIC	static
+#define REGISTER register
+
+#ifndef VOID
+#define VOID	void
+#endif
+
+#ifndef BYTE
+#define BYTE Amiga_BYTE
+#endif
+#ifndef BOOL
+#define BOOL Amiga_BOOL
+#endif
+
+typedef void   *APTR;
+typedef INT32  LONG;
+typedef CARD32 ULONG;
+typedef BITS32 LONGBITS;
+typedef INT16  WORD;
+typedef CARD16 UWORD;
+typedef BITS16 WORDBITS;
+typedef INT8   BYTE;
+typedef CARD8  UBYTE;
+typedef CARD8  BYTEBITS;
+typedef CARD16 RPTR;
+typedef unsigned char  *STRPTR;
+typedef INT16  BOOL;
+
+#ifndef TRUE
+#define TRUE	1
+#endif
+#ifndef FALSE
+#define FALSE	0
+#endif
+#ifndef NULL
+#define NULL	0L
+#endif
+
+#define WF_NOICONIFY 1
+
+struct Node {
+  struct  Node *ln_Succ;
+  struct  Node *ln_Pred;
+  UBYTE   ln_Type;
+  BYTE    ln_Pri;
+  char    *ln_Name;
+};
+
+struct MinNode {
+  struct MinNode *mln_Succ;
+  struct MinNode *mln_Pred;
+};
+
+struct List {
+  struct  Node *lh_Head;
+  struct  Node *lh_Tail;
+  struct  Node *lh_TailPred;
+  UBYTE   lh_Type;
+  UBYTE   l_pad;
+};
+
+struct MinList {
+  struct  MinNode *mlh_Head;
+  struct  MinNode *mlh_Tail;
+  struct  MinNode *mlh_TailPred;
+};
+
+extern void AddHead(struct List *, struct Node *);
+extern void AddTail(struct List *, struct Node *);
+extern void Enqueue(struct List *, struct Node *);
+extern struct Node *FindName(struct List *, STRPTR);
+extern void Insert(struct List *, struct Node *, struct Node *);
+extern struct Node *RemHead(struct List *);
+extern void Remove(struct Node *);
+extern struct Node *RemTail(struct List *);
+extern void NewList(struct List *);
+
+struct CSource {
+  UBYTE	*CS_Buffer;
+  LONG	CS_Length;
+  LONG	CS_CurChr;
+};
+
+struct RDArgs {
+  struct CSource RDA_Source;
+  void *RDA_DAList;
+  UBYTE *RDA_Buffer;
+  LONG RDA_BufSiz;
+  UBYTE *RDA_ExtHelp;
+  LONG RDA_Flags;
+};
+
+struct Image
+{
+  WORD LeftEdge, TopEdge, Width, Height, Depth;
+  UWORD *ImageData;
+  UBYTE PlanePick, PlaneOnOff;
+  struct Image *NextImage;
+};
+
+struct Gadget
+{
+  struct Gadget *NextGadget;
+  WORD LeftEdge, TopEdge, Width, Height;
+  UWORD Flags, Activation, GadgetType;
+  APTR GadgetRender, SelectRender;
+  struct IntuiText *GadgetText;
+  LONG MutualExclude;
+  APTR SpecialInfo;
+  UWORD GadgetID;
+  APTR UserData;
+};
+
+struct NewWindow
+{
+  WORD LeftEdge, TopEdge, Width, Height;
+  UBYTE DetailPen, BlockPen;
+  ULONG IDCMPFlags, Flags;
+  struct Gadget *FirstGadget;
+  struct Image *CheckMark;
+  UBYTE *Title;
+  struct Screen *Screen;
+  struct BitMap *BitMap;
+  WORD MinWidth, MinHeight;
+  UWORD MaxWidth, MaxHeight;
+  UWORD Type;
+};
+
+struct DrawerData {
+  struct NewWindow dd_NewWindow;
+  LONG dd_CurrentX;
+  LONG dd_CurrentY;
+  ULONG dd_Flags;
+  UWORD dd_ViewModes;
+};
+
+struct DiskObject {
+  UWORD do_Magic;
+  UWORD do_Version;
+  struct Gadget do_Gadget;
+  UBYTE do_Type;
+  char *do_DefaultTool;
+  char **do_ToolTypes;
+  LONG do_CurrentX;
+  LONG do_CurrentY;
+  struct DrawerData *do_DrawerData;
+  char *do_ToolWindow;
+  LONG do_StackSize;
+};
+
+struct Hook
+{
+  struct MinNode h_MinNode;
+  ULONG	   (*h_Entry)();	/* assembler entry point */
+  ULONG	   (*h_SubEntry)();	/* often HLL entry point */
+  APTR	   h_Data;		/* owner specific	 */
+};
+
+struct IFFHandle
+{
+  ULONG iff_Stream;
+  ULONG iff_Flags;
+  LONG  iff_Depth;	/*  Depth of context stack */
+  /* private fields */
+  struct Hook *iff_Hook;
+};
+
+struct IFFStreamCmd
+{
+    LONG sc_Command;	/* Operation to be performed (IFFCMD_) */
+    APTR sc_Buf;	/* Pointer to data buffer	       */
+    LONG sc_NBytes;	/* Number of bytes to be affected      */
+};
+
+
+#define RDAB_STDIN	0	/* Use "STDIN" rather than "COMMAND LINE" */
+#define RDAF_STDIN	1
+#define RDAB_NOALLOC	1	/* If set, do not allocate extra string space.*/
+#define RDAF_NOALLOC	2
+#define RDAB_NOPROMPT	2	/* Disable reprompting for string input. */
+#define RDAF_NOPROMPT	4
+
+#define ITEM_EQUAL	-2	/* "=" Symbol */
+#define ITEM_ERROR	-1	/* error */
+#define ITEM_NOTHING	0	/* *N, ;, endstreamch */
+#define ITEM_UNQUOTED	1	/* unquoted item */
+#define ITEM_QUOTED	2	/* quoted item */
+
+#define MAX_TEMPLATE_ITEMS 100
+#define MAX_MULTIARGS 128
+
+#define ERROR_NO_FREE_STORE  103
+#define ERROR_BAD_TEMPLATE  114
+#define ERROR_BAD_NUMBER  115
+#define ERROR_REQUIRED_ARG_MISSING  116
+#define ERROR_KEY_NEEDS_ARG  117
+#define ERROR_TOO_MANY_ARGS  118
+#define ERROR_LINE_TOO_LONG  120
+
+#define IFFERR_EOF	  -1L	/* Reached logical end of file	*/
+#define IFFERR_EOC	  -2L	/* About to leave context	*/
+#define IFFERR_NOSCOPE	  -3L	/* No valid scope for property	*/
+#define IFFERR_NOMEM	  -4L	/* Internal memory alloc failed */
+#define IFFERR_READ	  -5L	/* Stream read error		*/
+#define IFFERR_WRITE	  -6L	/* Stream write error		*/
+#define IFFERR_SEEK	  -7L	/* Stream seek error		*/
+#define IFFERR_MANGLED	  -8L	/* Data in file is corrupt	*/
+#define IFFERR_SYNTAX	  -9L	/* IFF syntax error		*/
+#define IFFERR_NOTIFF	  -10L	/* Not an IFF file		*/
+#define IFFERR_NOHOOK	  -11L	/* No call-back hook provided	*/
+#define IFF_RETURN2CLIENT -12L	/* Client handler normal return */
+
+#define IFFF_READ	0L			 /* read mode - default    */
+#define IFFF_WRITE	1L			 /* write mode		   */
+#define IFFF_RWBITS	(IFFF_READ | IFFF_WRITE) /* read/write bits	   */
+#define IFFF_FSEEK	(1L<<1)		 /* forward seek only	   */
+#define IFFF_RSEEK	(1L<<2)		 /* random seek	   */
+#define IFFF_RESERVED	0xFFFF0000L		 /* Don't touch these bits */
+
+#define IFFCMD_INIT	0	/* Prepare the stream for a session */
+#define IFFCMD_CLEANUP	1	/* Terminate stream session	    */
+#define IFFCMD_READ	2	/* Read bytes from stream	    */
+#define IFFCMD_WRITE	3	/* Write bytes to stream	    */
+#define IFFCMD_SEEK	4	/* Seek on stream		    */
+#define IFFCMD_ENTRY	5	/* You just entered a new context   */
+#define IFFCMD_EXIT	6	/* You're about to leave a context  */
+#define IFFCMD_PURGELCI 7	/* Purge a LocalContextItem	    */
+
+
+extern void FreeArgs(struct RDArgs *);
+extern LONG ReadItem(STRPTR, LONG, struct CSource *);
+extern LONG FindArg(STRPTR, STRPTR);
+extern struct RDArgs * ReadArgs(STRPTR, LONG *, struct RDArgs *);
+
+extern UBYTE ToUpper(UBYTE);
+extern LONG StrToLong(STRPTR, LONG *);
+extern LONG Stricmp(STRPTR, STRPTR);
+
+extern char *BumpRevision(char *, char *);
+extern BOOL DeleteDiskObject(char *);
+extern void FreeDiskObject(struct DiskObject *);
+extern struct DiskObject *GetDefDiskObject(LONG);
+extern struct DiskObject *GetDiskObject(char *);
+extern struct DiskObject *GetDiskObjectNew(char *);
+extern BOOL MatchToolValue(char *, char *);
+extern BOOL PutDiskObject(char *, struct DiskObject *);
+
+extern BOOL Fault(LONG, UBYTE *, UBYTE *, LONG);
+extern BOOL PrintFault(LONG, UBYTE *);
+extern LONG IoErr();
+extern LONG SetIoErr(LONG);
+
+extern struct IFFHandle *AllocIFF( void );
+extern LONG OpenIFF( struct IFFHandle *iff, long rwMode );
+extern LONG ParseIFF( struct IFFHandle *iff, long control );
+extern void CloseIFF( struct IFFHandle *iff );
+extern void FreeIFF( struct IFFHandle *iff );
+
+extern LONG ReadChunkBytes( struct IFFHandle *iff, APTR buf, long numBytes );
+extern LONG WriteChunkBytes( struct IFFHandle *iff, APTR buf, long numBytes );
+extern LONG ReadChunkRecords( struct IFFHandle *iff, APTR buf, long bytesPerRecord, long numRecords );
+extern LONG WriteChunkRecords( struct IFFHandle *iff, APTR buf, long bytesPerRecord, long numRecords );
+
+extern LONG PushChunk( struct IFFHandle *iff, long type, long id, long size );
+extern LONG PopChunk( struct IFFHandle *iff );
+
+extern LONG EntryHandler( struct IFFHandle *iff, long type, long id, long position, struct Hook *handler, APTR object );
+extern LONG ExitHandler( struct IFFHandle *iff, long type, long id, long position, struct Hook *handler, APTR object );
+
+extern LONG PropChunk( struct IFFHandle *iff, long type, long id );
+extern LONG PropChunks( struct IFFHandle *iff, LONG *propArray, long numPairs );
+extern LONG StopChunk( struct IFFHandle *iff, long type, long id );
+extern LONG StopChunks( struct IFFHandle *iff, LONG *propArray, long numPairs );
+extern LONG CollectionChunk( struct IFFHandle *iff, long type, long id );
+extern LONG CollectionChunks( struct IFFHandle *iff, LONG *propArray, long numPairs );
+extern LONG StopOnExit( struct IFFHandle *iff, long type, long id );
+
+extern struct StoredProperty *FindProp( struct IFFHandle *iff, long type, long id );
+extern struct CollectionItem *FindCollection( struct IFFHandle *iff, long type, long id );
+extern struct ContextNode *FindPropContext( struct IFFHandle *iff );
+extern struct ContextNode *CurrentChunk( struct IFFHandle *iff );
+extern struct ContextNode *ParentChunk( struct ContextNode *contextNode );
+
+extern struct LocalContextItem *AllocLocalItem( long type, long id, long ident, long dataSize );
+extern APTR LocalItemData( struct LocalContextItem *localItem );
+extern void SetLocalItemPurge( struct LocalContextItem *localItem, struct Hook *purgeHook );
+extern void FreeLocalItem( struct LocalContextItem *localItem );
+extern struct LocalContextItem *FindLocalItem( struct IFFHandle *iff, long type, long id, long ident );
+extern LONG StoreLocalItem( struct IFFHandle *iff, struct LocalContextItem *localItem, long position );
+extern void StoreItemInContext( struct IFFHandle *iff, struct LocalContextItem *localItem, struct ContextNode *contextNode );
+
+extern void InitIFF( struct IFFHandle *iff, long flags, struct Hook *streamHook );
+
+extern LONG GoodID( long id );
+extern LONG GoodType( long type );
+extern STRPTR IDtoStr( long id, STRPTR buf );
+
+#endif
+
+extern LONG OpenIFFasFile( struct IFFHandle *iff, char *fn, char *mode );
+
+struct ColorStore { unsigned long *colors; int ncolors; Colormap cmap; };
+extern Pixmap image_to_pixmap(Display *, Window, GC, unsigned long,
+			      unsigned long *, int, struct Image *, int, int,
+			      struct ColorStore *);
+extern void free_color_store(Display *, struct ColorStore *);
+
+typedef union { LONG num; APTR ptr; } Argtype;
+
+extern void initargs(int, char **);
+
+extern char *amiwm_version;
+
+extern int md_fd;
+extern Window md_root;
+
+#define WINDOW_EVENT(e) ((e)->xany.display==(Display *)1)
+#define FRAME_EVENT(e) ((e)->xany.display==(Display *)2)
+#define ICON_EVENT(e) ((e)->xany.display==(Display *)3)
+
+#define IN_ROOT_MASK 1
+#define IN_WINDOW_MASK 2
+#define IN_FRAME_MASK 4
+#define IN_ICON_MASK 8
+#define IN_ANYTHING_MASK (~0)
+
+/* module.c */
+extern void md_exit(int);
+extern int md_handle_input(void);
+extern void md_process_queued_events(void);
+extern void md_main_loop(void);
+extern int md_connection_number(void);
+extern int md_command(XID, int, void *, int, char **);
+extern int md_command0(XID, int, void *, int);
+extern int md_command00(XID, int);
+extern Display *md_display(void);
+extern char *md_init(int, char *[]);
+
+/* broker.c */
+extern int cx_broker(unsigned long, void (*)(XEvent *, unsigned long));
+extern int cx_send_event(unsigned long, XEvent *);
+
+/* mdscreen.c */
+extern int md_rotate_screen(Window);
+extern int md_front(Window);
+extern int md_back(Window);
+extern int md_iconify(Window);
+extern int md_errormsg(Window, char *);
+
+/* eventdispatcher.c */
+extern void cx_event_broker(int, unsigned long, int (*)(XEvent*));
+
+/* kbdsupport.c */
+extern int md_grabkey(int, unsigned int);
+extern int md_ungrabkey(int);
+
+/* hotkey.c */
+extern void cx_hotkey(KeySym, unsigned int, int, int,
+		      void (*)(XEvent*,void*), void*);
+
+/* mdicon.c */
+extern Window md_create_appicon(Window, int, int, char *,
+				Pixmap, Pixmap, Pixmap);
+extern Pixmap md_image_to_pixmap(Window, unsigned long, struct Image *,
+				 int, int, struct ColorStore *);
+extern char *get_current_icondir(void);
+
+/* mdwindow.c */
+extern int md_set_appwindow(Window);
+
+#endif
diff --git a/libami/lists.c b/libami/lists.c
new file mode 100644
index 0000000..169ba3a
--- /dev/null
+++ b/libami/lists.c
@@ -0,0 +1,85 @@
+#include "libami.h"
+
+#ifndef AMIGAOS
+
+void NewList(struct List *list)
+{
+  list->lh_TailPred = (struct Node *)&list->lh_Head;
+  list->lh_Tail = NULL;
+  list->lh_Head = (struct Node *)&list->lh_Tail;
+}
+
+void AddHead(struct List *list, struct Node *node)
+{
+  struct Node *oldhead = list->lh_Head;
+  list->lh_Head = node;
+  node->ln_Succ = oldhead;
+  node->ln_Pred = (struct Node *)&list->lh_Head;
+  oldhead->ln_Pred = node;
+}
+
+void AddTail(struct List *list, struct Node *node)
+{
+  struct Node *oldtail = list->lh_TailPred;
+  list->lh_TailPred = node;
+  node->ln_Succ = (struct Node *)&list->lh_Tail;
+  node->ln_Pred = oldtail;
+  oldtail->ln_Succ = node;
+}
+
+struct Node *RemHead(struct List *list)
+{
+  struct Node *node = list->lh_Head;
+  if(node->ln_Succ) {
+    list->lh_Head = node->ln_Succ;
+    node->ln_Succ->ln_Pred = (struct Node *)&list->lh_Head;
+    return node;
+  } else return NULL;
+}
+
+struct Node *RemTail(struct List *list)
+{
+  struct Node *node = list->lh_TailPred;
+  if(node->ln_Pred) {
+    list->lh_TailPred = node->ln_Pred;
+    node->ln_Pred->ln_Succ = (struct Node *)&list->lh_Tail;
+    return node;
+  } else return NULL;
+}
+
+void Insert(struct List *list, struct Node *node, struct Node *after)
+{
+  if(!after) after = (struct Node *)&list->lh_Head;
+  node->ln_Succ = after->ln_Succ;
+  node->ln_Pred = after;
+  after->ln_Succ->ln_Pred = node;  
+  after->ln_Succ = node;
+}
+
+void Remove(struct Node *node)
+{
+  node->ln_Pred->ln_Succ = node->ln_Succ;
+  node->ln_Succ->ln_Pred = node->ln_Pred;
+}
+
+void Enqueue(struct List *list, struct Node *node)
+{
+  struct Node *before = list->lh_Head;
+  while(before->ln_Succ && before->ln_Pri >= node->ln_Pri)
+    before = before->ln_Succ;
+  node->ln_Succ = before;
+  node->ln_Pred = before->ln_Pred;
+  before->ln_Pred->ln_Succ = node;  
+  before->ln_Pred = node;
+}
+
+struct Node *FindName(struct List *list, STRPTR name)
+{
+  struct Node *node;
+  for(node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
+    if(!strcmp((char *)name, node->ln_Name))
+      return node;
+  return NULL;
+}
+
+#endif
diff --git a/libami/mdicon.c b/libami/mdicon.c
new file mode 100644
index 0000000..14e199f
--- /dev/null
+++ b/libami/mdicon.c
@@ -0,0 +1,71 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "libami.h"
+#include "module.h"
+#include "alloc.h"
+
+Window md_create_appicon(Window p, int x, int y, char *name,
+			 Pixmap pm1, Pixmap pm2, Pixmap pmm)
+{
+  char *data;
+  Window w;
+  int res, l=strlen(name);
+#ifdef HAVE_ALLOCA
+  struct NewAppIcon *nai=alloca(sizeof(struct NewAppIcon)+l);
+#else
+  struct NewAppIcon *nai=malloc(sizeof(struct NewAppIcon)+l);
+  if(nai==NULL) return None;
+#endif
+  nai->x=x; nai->y=y;
+  nai->pm1=pm1; nai->pm2=pm2; nai->pmm=pmm;
+  strcpy(nai->name, name);
+  res=md_command(p, MCMD_CREATEAPPICON, nai, sizeof(struct NewAppIcon)+l,
+		 &data);
+  if(res<sizeof(w)) {
+    if(data) free(data);
+#ifndef HAVE_ALLOCA
+    free(nai);
+#endif
+    return None;
+  }
+  memcpy(&w, data, sizeof(w));
+  free(data);
+#ifndef HAVE_ALLOCA
+  free(nai);
+#endif
+  return w;
+}
+
+Pixmap md_image_to_pixmap(Window w, unsigned long bgcolor, struct Image *i,
+			  int width, int height, struct ColorStore *cs)
+{
+  Display *dpy = md_display();
+  static GC gc = None;
+  Pixmap pm;
+  static int iconcolormask;
+  static unsigned long *iconcolor = NULL;
+  if(gc == None && w != None)
+    gc = XCreateGC(dpy, w, 0, NULL);
+  if(iconcolor == NULL) {
+    char *p;
+    int res = md_command(w, MCMD_GETICONPALETTE, NULL, 0, &p);
+    if(res<0)
+      return None;
+    iconcolor = (unsigned long *)(void *)p;
+    iconcolormask = (res/sizeof(unsigned long))-1;
+  }
+  pm = image_to_pixmap(md_display(), w, gc, bgcolor, iconcolor, iconcolormask,
+		       i, width, height, cs);
+  return pm;
+}
+
+char *get_current_icondir()
+{
+  char *p;
+  if(md_command(None, MCMD_GETICONDIR, NULL, 0, &p)>=0 && p)
+    return p;
+  if(p) free(p);
+  return NULL;
+}
+
diff --git a/libami/mdscreen.c b/libami/mdscreen.c
new file mode 100644
index 0000000..c7c1312
--- /dev/null
+++ b/libami/mdscreen.c
@@ -0,0 +1,35 @@
+#include "libami.h"
+#include "module.h"
+#include <string.h>
+
+int md_rotate_screen(XID id)
+{
+  return md_command00(id, MCMD_ROTATE_SCREEN);
+}
+
+int md_front(XID id)
+{
+  return md_command00(id, MCMD_FRONT);
+}
+
+int md_back(XID id)
+{
+  return md_command00(id, MCMD_BACK);
+}
+
+int md_iconify(XID id)
+{
+  return md_command00(id, MCMD_ICONIFY);
+}
+
+int md_errormsg(Window id, char *str)
+{
+  return md_command0(id, MCMD_ERRORMSG, str, strlen(str));
+}
+
+int md_managemenu(Window id, int menu, int item, int subitem)
+{
+  int data[3];
+  data[0]=menu; data[1]=item; data[2]=subitem;
+  return md_command0(id, MCMD_MANAGEMENU, data, sizeof(data));
+}
diff --git a/libami/mdwindow.c b/libami/mdwindow.c
new file mode 100644
index 0000000..10b7bde
--- /dev/null
+++ b/libami/mdwindow.c
@@ -0,0 +1,7 @@
+#include "libami.h"
+#include "module.h"
+
+int md_set_appwindow(Window w)
+{
+  return md_command00(w, MCMD_SETAPPWINDOW);
+}
diff --git a/libami/module.c b/libami/module.c
new file mode 100644
index 0000000..6978870
--- /dev/null
+++ b/libami/module.c
@@ -0,0 +1,236 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <signal.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "libami.h"
+#include "module.h"
+#include "alloc.h"
+
+static int md_in_fd=-1, md_out_fd=-1;
+
+static char *md_name = "";
+
+char *amiwm_version;
+
+Window md_root = None;
+
+static int md_int_len=0;
+static char *md_int_buf=NULL;
+void (*md_broker_func)(XEvent *, unsigned long);
+
+void md_exit(int signal)
+{
+  if(md_in_fd>=0)
+    close(md_in_fd);
+  if(md_out_fd>=0)
+    close(md_out_fd);
+  exit(0);
+}
+
+static int md_write(void *ptr, int len)
+{
+  char *p=ptr;
+  int r, tot=0;
+  while(len>0) {
+    if((r=write(md_out_fd, p, len))<0)
+      if(errno==EINTR)
+	continue;
+      else
+	return r;
+    if(!r)
+      return tot;
+    tot+=r;
+    p+=r;
+    len-=r;
+  }
+  return tot;
+}
+
+static int md_read(void *ptr, int len)
+{
+  char *p=ptr;
+  int r, tot=0;
+  while(len>0) {
+    if((r=read(md_in_fd, p, len))<0)
+      if(errno==EINTR)
+	continue;
+      else
+	return r;
+    if(!r)
+      if(tot)
+	return tot;
+      else
+	md_exit(0);
+    tot+=r;
+    p+=r;
+    len-=r;
+  }
+  return tot;
+}
+
+static int md_int_load(int len)
+{
+  if(len>=md_int_len)
+    if(md_int_buf!=NULL)
+      md_int_buf=realloc(md_int_buf, md_int_len=len+1);
+    else
+      md_int_buf=malloc(md_int_len=len+1);
+  md_int_buf[len]='\0';
+  return md_read(md_int_buf, len);
+}
+
+static struct md_queued_event {
+  struct md_queued_event *next;
+  struct mcmd_event e;
+} *event_head=NULL, *event_tail=NULL;
+
+void md_process_queued_events()
+{
+  struct md_queued_event *e;
+
+  while((e=event_head)) {
+    event_head=e->next;
+    md_broker_func(&e->e.event, e->e.mask);
+    free(e);
+  }
+}
+
+static void md_enqueue(struct mcmd_event *e)
+{
+  struct md_queued_event *qe=malloc(sizeof(struct md_queued_event));
+  if(qe) {
+    qe->e=*e;
+    qe->next=NULL;
+    if(event_head) {
+      event_tail->next=qe;
+      event_tail=qe;
+    } else {
+      event_head=event_tail=qe;
+    }
+  }
+}
+
+static int md_get_async(int len)
+{
+  if(md_int_load(len)!=len)
+    return -1;
+  if(md_broker_func)
+    md_enqueue((struct mcmd_event *)md_int_buf);
+  return 1;
+}
+
+int md_handle_input()
+{
+  int res;
+
+  if(md_read(&res, sizeof(res))!=sizeof(res))
+    return -1;
+  if(res>=0) {
+    if(!res)
+      return 0;
+    md_int_load(res);
+    return 0;
+  } else {
+    res=~res;
+    if(!res)
+      return 0;
+    return md_get_async(res);
+  }
+}
+
+int md_command(XID id, int cmd, void *data, int data_len, char **buffer)
+{
+  int res;
+  struct mcmd_header mcmd;
+
+  *buffer=NULL;
+
+  mcmd.id = id;
+  mcmd.cmd = cmd;
+  mcmd.len = data_len;
+
+  if(md_write(&mcmd, sizeof(mcmd))!=sizeof(mcmd) ||
+     md_write(data, data_len)!=data_len ||
+     md_read(&res, sizeof(res))!=sizeof(res))
+    return -1;
+
+  while(res<-1) {
+    md_get_async(~res);
+    if(md_read(&res, sizeof(res))!=sizeof(res))
+      return -1;
+  }
+  if(res>0) {
+    *buffer=malloc(res);
+    if(md_read(*buffer, res)!=res)
+      return -1;
+  }
+  return res;
+}
+
+int md_command0(XID id, int cmd, void *data, int data_len)
+{
+  char *ptr=NULL;
+  int res=md_command(id, cmd, data, data_len, &ptr);
+  if(ptr) free(ptr);
+  return res;
+}
+
+int md_command00(XID id, int cmd)
+{
+  return md_command0(id, cmd, NULL, 0);
+}
+
+static void md_fail()
+{
+  fprintf(stderr, "%s: cannot establish connection to amiwm\n", md_name);
+  exit(1);
+}
+
+Display *md_display()
+{
+  static Display *dpy=NULL;
+  if(!dpy)
+    dpy=XOpenDisplay(NULL);
+  return dpy;
+}
+
+char *md_init(int argc, char *argv[])
+{
+  if(argc>0)
+    md_name=argv[0];
+  if(argc>2) {
+    md_in_fd=strtol(argv[1], NULL, 0);
+    md_out_fd=strtol(argv[2], NULL, 0);
+  } else
+    md_fail();
+
+  signal(SIGHUP, md_exit);
+  signal(SIGPIPE, md_exit);
+
+  if(argc>3)
+    md_root=strtol(argv[3], NULL, 0);
+  else
+    md_root=None;
+
+  if(md_command(None, MCMD_GET_VERSION, NULL, 0, &amiwm_version)<=0)
+    md_fail();
+
+  return (argc>4? argv[4]:NULL);
+}
+
+void md_main_loop()
+{
+  do md_process_queued_events(); while(md_handle_input()>=0);
+}
+
+int md_connection_number()
+{
+  return md_in_fd;
+}
diff --git a/libami/readargs.c b/libami/readargs.c
new file mode 100644
index 0000000..ec97863
--- /dev/null
+++ b/libami/readargs.c
@@ -0,0 +1,537 @@
+#include "libami.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef AMIGAOS
+
+void initargs(int argc, char **argv)
+{
+}
+
+#else
+
+static char *cmdline=NULL;
+int cmdline_allocated=0, cmdline_used=0;
+
+static void addachar(char c)
+{
+  if(cmdline_used>=cmdline_allocated) {
+    if(!cmdline_allocated) cmdline_allocated=128;
+    while(cmdline_allocated<=cmdline_used)
+      cmdline_allocated<<=1;
+    if(cmdline!=NULL)
+      cmdline=realloc(cmdline, cmdline_allocated);
+    else
+      cmdline=malloc(cmdline_allocated);
+  }
+  cmdline[cmdline_used++]=c;
+}
+
+static void addquoted(const char *arg)
+{
+  char ch;
+  addachar(' '); addachar('"');
+  while((ch=*arg++)) switch(ch) {
+  case '\n': addachar('*'); addachar('N'); break;
+  case '\"': addachar('*'); addachar('\"'); break;
+  case '*': addachar(ch);
+  default: addachar(ch);
+  }
+  addachar('"');
+}
+
+static void addunquoted(const char *arg, int cnt)
+{
+  if(cnt) {
+    addachar(' ');
+    while(cnt--)
+      addachar(*arg++);
+  }
+}
+
+static void addarg(const char *arg)
+{
+  if(*arg!='\"') {
+    int plain=strcspn(arg, "\t\n ;=");
+    if(!arg[plain]) {
+      addunquoted(arg, plain);
+      return;
+    } else if(arg[plain]=='=') {
+      addunquoted(arg, plain);
+      addunquoted("=", 1);
+      arg+=plain+1;
+      if(!*arg)
+	return;
+    }
+  }
+  addquoted(arg);
+}
+
+void initargs(int argc, char **argv)
+{
+  while(--argc) addarg(*++argv);
+  addachar('\n');
+  addachar('\0');
+}
+
+#endif
+
+#ifndef AMIGAOS
+
+#define RDAF_PRIVATE1 0x40000000
+#define RDAF_PRIVATE2 0x20000000
+
+
+void FreeArgs(struct RDArgs *rdargs)
+{
+  if(rdargs) {
+    APTR daelt, nextda = (APTR)rdargs->RDA_DAList;
+
+    rdargs->RDA_Buffer = NULL;
+    rdargs->RDA_Flags &= (RDAF_PRIVATE1 | RDAF_PRIVATE2);
+    rdargs->RDA_DAList = NULL;
+    while((daelt = nextda)) {
+      nextda = ((Argtype *)daelt)->ptr;
+      free(daelt);
+    }
+  }
+}
+
+
+
+static UBYTE * ra_alloc(struct RDArgs *rdargs, ULONG size)
+{
+  UBYTE *ptr=NULL;
+
+  if((!(rdargs->RDA_Flags & RDAF_NOALLOC)) &&
+     (ptr=malloc(size+sizeof(Argtype)))) {
+    memset(ptr, 0, size+sizeof(Argtype));
+    ((Argtype *)ptr)->ptr=rdargs->RDA_DAList;
+    rdargs->RDA_DAList=ptr;
+    ptr+=sizeof(Argtype);
+  }
+  return ptr;
+}
+
+static UBYTE * ra_realloc(struct RDArgs *rdargs, UBYTE **start, UBYTE **end)
+{
+  UBYTE *oldstart=*start;
+  ULONG newlength=((*end-oldstart+144)&~0x7f)-8;
+  UBYTE *newstart=ra_alloc(rdargs, newlength+4);
+
+  if(!newstart)
+    return NULL;
+
+  *start=newstart;
+  *end=newstart+newlength;
+  return oldstart;
+}
+
+
+
+static LONG CS_ReadChar(struct CSource *cSource)
+{
+  if(!cSource || ((LONG)cSource)==-1 || !cSource->CS_Buffer) {
+    if(cmdline && *cmdline) {
+      return (unsigned char)(*cmdline++);
+    } else
+      return getchar();
+  }
+  if(cSource->CS_CurChr >= cSource->CS_Length)
+    return -1;
+  return cSource->CS_Buffer[cSource->CS_CurChr++];
+}
+
+static void CS_UnReadChar(struct CSource *cSource, UBYTE ch)
+{
+  if(!cSource || ((LONG)cSource)==-1 || !cSource->CS_Buffer) {
+    if(cmdline && *cmdline)
+      --cmdline;
+    else
+      ungetc(ch, stdin);
+  } else if(cSource->CS_CurChr > 0)
+    --cSource->CS_CurChr;
+}
+
+static LONG intreaditem(STRPTR buffer, LONG maxchars, struct CSource *input,
+		int mode, UBYTE **start, UBYTE **end)
+{
+  int itemlen=0;
+  int ch, quote='\0';
+
+  buffer[0]='\0';
+  do ch=CS_ReadChar(input); while(ch==' ' || ch=='\t');
+  if(ch=='"') { quote=ch; ch=CS_ReadChar(input); }
+
+  while(ch!='\n' && ch>=0) {
+    if(quote) {
+      if(ch==quote)
+        return ITEM_QUOTED;
+      if(ch=='*') {
+	ch=CS_ReadChar(input);
+	if(ch<0 || ch=='\n') break;
+	if(ch=='e' || ch=='E') ch='\033';
+	if(ch=='n' || ch=='N') ch='\n';
+      }
+    } else {
+      if(ch==';')
+        break;
+      if(ch==' ' || ch=='\t' || (ch=='=' && itemlen)) {
+        if(mode<0)
+          CS_UnReadChar(input, ch);
+        return ITEM_UNQUOTED;
+      }
+      if(ch=='=')
+        return ITEM_EQUAL;
+    }
+    if(++itemlen>=maxchars) {
+      UBYTE *bufswap;
+      if(mode<=0 || !(bufswap=ra_realloc((struct RDArgs *)input, start, end)))
+        return ITEM_ERROR;
+      memcpy(*start, bufswap, itemlen-1);
+      buffer=*start+itemlen-1;
+      maxchars=*end-*start;
+    }
+    if(mode<0) {
+      buffer[itemlen]=ch;
+      buffer[itemlen+1]='\0';
+      buffer[0]=itemlen;
+    } else {
+      *buffer++=ch;
+      *buffer='\0';
+    }
+    ch=CS_ReadChar(input);
+  }
+  CS_UnReadChar(input, ch);
+  return (quote? ITEM_ERROR : (itemlen? ITEM_UNQUOTED : ITEM_NOTHING));
+}
+
+LONG ReadItem(STRPTR buffer, LONG maxchars, struct CSource *input)
+{
+  return intreaditem(buffer, maxchars, input, 0, NULL, NULL);
+}
+
+
+
+
+
+LONG FindArg(STRPTR template, STRPTR keyword)
+{
+  int kwlen=strlen((char *)keyword);
+  int kwindex, argindex=0;
+  char ch;
+
+  for(;;) {
+
+    kwindex=0;
+    do {
+      ch=*template++;
+      if(!ch)
+        return (kwindex == kwlen? argindex : -1);
+      if(ch == ',' || ch == '=' || ch == '/')
+        if(kwindex == kwlen)
+          return argindex;
+        else
+          break;
+    } while(ToUpper(ch) == ToUpper(keyword[kwindex++]));
+
+    while(ch != '=') {
+      if(ch == ',') {
+        argindex++;
+        break;
+      }
+      ch=*template++;
+      if(!ch)
+        return -1;
+    }
+  }
+}
+
+#define RA_ALWAYS  1
+#define RA_KEYWORD 2
+#define RA_SWITCH  4
+#define RA_NUMERIC 8
+#define RA_FORCE   16
+#define RA_TOGGLE  32
+#define RA_MULTI   64
+#define RA_FOUND   128
+
+static LONG parseswitches(STRPTR template, LONG len, UBYTE *flags, int *numargs)
+{
+  static struct ra_switch { UBYTE flag, ch; } switches[] = {
+    { RA_ALWAYS,  'A' },
+    { RA_KEYWORD, 'K' },
+    { RA_SWITCH,  'S' },
+    { RA_NUMERIC, 'N' },
+    { RA_FORCE,   'F' },
+    { RA_TOGGLE,  'T' },
+    { RA_MULTI,   '.' },
+    { RA_MULTI,   'M' },
+    {  0,  0  }
+  };
+  struct ra_switch *sw;
+  int m_used=0;
+  UBYTE ch;
+
+  *numargs=0;
+  while(++*numargs<=MAX_TEMPLATE_ITEMS) {
+    *flags++=0;
+    do {
+      if(--len<0)
+        return 0;
+
+      if((ch=*template++)=='/') {
+        ch=ToUpper(*template++);
+        --len;
+
+        for(sw=switches; sw->ch; sw++)
+          if(sw->ch == ch) {
+            flags[-1]|=sw->flag;
+            if((sw->flag&RA_MULTI) && m_used++)
+              return ERROR_BAD_TEMPLATE;
+          }
+      }
+    } while(ch != ',');
+  }
+  return ERROR_LINE_TOO_LONG;
+}
+
+static LONG rareaditem(struct RDArgs *rdargs, UBYTE **start, UBYTE **end)
+{
+  while(*end-*start-1<0)
+    if(!rdargs || !ra_realloc(rdargs, start, end))
+      return ITEM_ERROR;
+  return (rdargs?
+    intreaditem(*start, *end-*start-1, &rdargs->RDA_Source, 1, start, end):
+    intreaditem(*start, *end-*start-2, (struct CSource *)-1, -1, start, end));
+}
+
+struct RDArgs * ReadArgs(STRPTR template, LONG *array, struct RDArgs *rdargs)
+{
+  LONG itemtype;
+  UBYTE *multiargs[MAX_MULTIARGS+1];
+  UBYTE switches[MAX_TEMPLATE_ITEMS];
+  UBYTE *start, *end, sw, *swptr;
+  Argtype *lastmarg=NULL;
+  int multinum=0;
+  int argnum;
+  LONG ch, error=0;
+  int numargs;
+  int munched;
+
+  if(rdargs) {
+    rdargs->RDA_DAList=NULL;
+    if(!rdargs->RDA_Buffer) {
+      if(!(rdargs->RDA_Buffer=ra_alloc(rdargs, 128+4)))
+        goto nomemfail;
+      rdargs->RDA_BufSiz=128;
+    }
+  } else {
+    rdargs=malloc(128+4+sizeof(struct RDArgs)+sizeof(Argtype));
+    if(!rdargs)
+      goto nomemfail;
+    memset(rdargs, 0, 128+4+sizeof(struct RDArgs)+sizeof(Argtype));
+    rdargs=(struct RDArgs *)(((char *)rdargs)+sizeof(Argtype));
+    rdargs->RDA_Buffer=((UBYTE*)rdargs)+sizeof(struct RDArgs);
+    rdargs->RDA_DAList=(((char *)rdargs)-sizeof(Argtype));
+    rdargs->RDA_BufSiz=128;
+  }
+  start=rdargs->RDA_Buffer;
+  end=rdargs->RDA_Buffer+rdargs->RDA_BufSiz;
+  if((error=parseswitches(template, strlen((char *)template),
+			  switches, &numargs)))
+    goto fail;
+
+  for(;;) {
+    argnum=-1;
+    switch(itemtype=rareaditem(rdargs, &start, &end)) {
+    case ITEM_NOTHING:
+
+      swptr=switches;
+
+      while(numargs-->0) {
+        int isnumeric=0;
+
+        if((*swptr)&RA_MULTI)
+	  if(multinum) {
+	    ((Argtype *)array)->ptr=ra_alloc(rdargs,
+					     sizeof(Argtype)*(multinum+1));
+            if(!((Argtype *)array)->ptr)
+              goto nomemfail;
+            memcpy(((Argtype *)array)->ptr, multiargs, sizeof(Argtype)*multinum);
+            lastmarg=((Argtype *)(((Argtype *)array)->ptr))+multinum-1;
+            lastmarg[1].ptr=NULL;
+            isnumeric=((*swptr)&RA_NUMERIC)!=0;
+          }
+	  else ((Argtype *)array)->ptr=NULL;
+        array=(LONG*)(((Argtype *)array)+1);
+        if(!((sw=*swptr++)&RA_FOUND) && (sw&RA_ALWAYS)) {
+          if((!lastmarg) || (sw&RA_KEYWORD) || multinum<2 ||
+	     isnumeric!=((sw&RA_NUMERIC)!=0)) {
+            error=ERROR_REQUIRED_ARG_MISSING;
+            goto fail;
+          }
+	  ((Argtype *)array)[-1].ptr=lastmarg->ptr;
+          (lastmarg--)->ptr=NULL;
+          --multinum;
+        }
+      }
+      CS_ReadChar(&rdargs->RDA_Source);
+      return rdargs;
+
+    case ITEM_UNQUOTED:
+      argnum=FindArg(template, start);
+      if(argnum<0)
+	goto not_namedarg;
+      sw=switches[argnum];
+      if(sw&RA_SWITCH) {
+	((Argtype *)array)[argnum].num=-1;
+        break;
+      }
+      if(!(sw&RA_FORCE)) {
+	LONG argt;
+        if((argt=rareaditem(rdargs, &start, &end))==ITEM_EQUAL)
+	  argt=rareaditem(rdargs, &start, &end);
+        if(argt==ITEM_NOTHING) {
+	  error=ERROR_KEY_NEEDS_ARG;
+	  goto fail;
+        } else if(argt<0) {
+	  error=ERROR_LINE_TOO_LONG;
+	  goto fail;
+        } else
+	  goto quoted;
+      }
+      munched=0;
+force:
+      if(end-start<=munched) {
+	UBYTE *old;
+	if(!(old=ra_realloc(rdargs, &start, &end)))
+	  goto nomemfail;
+	memcpy(start, old, munched);
+      }
+      if((ch=CS_ReadChar(&rdargs->RDA_Source))>=0 && ch!='\n') {
+        start[munched++]=ch;
+	goto force;
+      }
+      if(itemtype!=ITEM_QUOTED)
+        while((start[munched-1]==' ' || start[munched-1]=='\t') && --munched>0);
+      start[munched]='\0';
+      goto quoted2;
+
+not_namedarg:
+      ch=CS_ReadChar(&rdargs->RDA_Source);
+      if(ch<0)
+	goto quoted;
+      if(ch=='\n' && start[0]=='?' && start[1]=='\0' &&
+	 !(rdargs->RDA_Flags & RDAF_NOPROMPT)) {
+	UBYTE *helptext = template;
+	if(!(rdargs->RDA_Flags & RDAF_PRIVATE1)) {
+	  rdargs->RDA_Flags |= RDAF_PRIVATE1;
+	  if(rdargs->RDA_ExtHelp)
+	    helptext=rdargs->RDA_ExtHelp;
+	}
+	fprintf(stderr, "%s: ", (char *)helptext);
+	fflush(stderr);
+	break;
+      }
+quoted2:
+      CS_UnReadChar((struct CSource *)rdargs, ch);
+
+quoted:
+    case ITEM_QUOTED:
+      if(argnum<0) {
+        swptr=switches;
+        error=ERROR_TOO_MANY_ARGS;
+        for(;;) {
+          if(++argnum>=numargs)
+            goto fail;
+          if((*swptr)&RA_MULTI)
+            break;
+          if((sw=*swptr++)&RA_FOUND)
+            continue;
+          if(sw&RA_FORCE) {
+	    munched=strlen((char *)start);
+	    if(itemtype!=ITEM_QUOTED)
+	      start[munched++]=' ';
+	    goto force;
+	  }
+          if(!(sw&RA_KEYWORD))
+	    if(!(sw&=(RA_TOGGLE|RA_SWITCH)))
+	      break;
+        }
+      }
+      sw=switches[argnum];
+      switches[argnum]|=RA_FOUND;
+      if(!rdargs) {
+        ((Argtype *)array)[argnum].num=((LONG)start)>>2;
+        start+=((*start)&~3)+4;
+        continue;
+      }
+      if(sw&RA_MULTI) {
+        if(multinum>=MAX_MULTIARGS-1) {
+	  error=ERROR_LINE_TOO_LONG;
+          goto fail;
+        } if(sw&RA_NUMERIC)
+          goto numeric;
+        multiargs[multinum++]=start;
+      } else if((sw&RA_FOUND)&&!(sw&RA_SWITCH)) {
+        error=ERROR_TOO_MANY_ARGS;
+        goto fail;
+      } else if(sw&RA_TOGGLE) {
+        if(Stricmp(start, (STRPTR)"yes"))
+	  ((Argtype*)array)[argnum].num=-1;
+        else if(Stricmp(start, (STRPTR)"no"))
+	  ((Argtype*)array)[argnum].num=0;
+        else if(Stricmp(start, (STRPTR)"on"))
+	  ((Argtype*)array)[argnum].num=-1;
+        else if(Stricmp(start, (STRPTR)"off"))
+	  ((Argtype*)array)[argnum].num=0;
+        else {
+	  error=ERROR_KEY_NEEDS_ARG;
+	  goto fail;
+        }
+      } else if(sw&RA_NUMERIC) {
+        LONG n; int len;
+numeric:
+        if((len=StrToLong(start, &n))<=0 || len!=strlen((char *)start)) {
+	  error=ERROR_BAD_NUMBER;
+	  goto fail;
+        }
+	start+=sizeof(Argtype)-1;
+	start-=((LONG)start)&(sizeof(Argtype)-1);
+        if(end-start<sizeof(LONG))
+	  if(!ra_realloc(rdargs, &start, &end))
+	    goto nomemfail;
+        *(LONG *)start=n;
+        if(sw&RA_MULTI)
+	  multiargs[multinum++]=start;
+        else
+	  ((Argtype*)array)[argnum].ptr=start;
+        start+=sizeof(LONG);
+        continue;
+      } else
+        ((Argtype*)array)[argnum].ptr=start;
+
+      start+=strlen((char *)start)+1;
+      break;
+
+    default:
+      error=ERROR_LINE_TOO_LONG;
+      goto fail;
+    }
+  }
+
+nomemfail:
+  error=ERROR_NO_FREE_STORE;
+fail:
+  do
+    ch=CS_ReadChar(&rdargs->RDA_Source);
+  while(ch!='\n' && ch!=';' && ch>=0);
+  if(rdargs)
+    FreeArgs(rdargs);
+  SetIoErr(error);
+  return NULL;
+}
+
+#endif
diff --git a/libami/strutil.c b/libami/strutil.c
new file mode 100644
index 0000000..6426dcf
--- /dev/null
+++ b/libami/strutil.c
@@ -0,0 +1,36 @@
+#include "libami.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
+#include <ctype.h>
+
+#ifndef AMIGAOS
+
+UBYTE ToUpper(UBYTE ch)
+{
+  static int firstcall=1;
+  if(firstcall) {
+    setlocale(LC_CTYPE, "");
+    firstcall=0;
+  }
+  return toupper(ch);
+}
+
+LONG StrToLong(STRPTR str, LONG *n)
+{
+  STRPTR end;
+
+  *n=strtol((char *)str, (char **)&end, 0);
+  return end-str;
+}
+
+LONG Stricmp(STRPTR a, STRPTR b)
+{
+  while(*a && *b)
+    if(ToUpper(*a++)!=ToUpper(*b++))
+      return FALSE;
+  return !(*a || *b);
+}
+
+#endif
diff --git a/magicwb.map b/magicwb.map
new file mode 100644
index 0000000..ea74178
--- /dev/null
+++ b/magicwb.map
@@ -0,0 +1,3 @@
+P3 4 2 255
+170 170 170    0   0   0  255 255 255  102 136 187
+153 153 153  187 187 187  187 170 153  255 187 170
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..59b23c4
--- /dev/null
+++ b/main.c
@@ -0,0 +1,1582 @@
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/cursorfont.h>
+#include <X11/Xproto.h>
+#include <X11/Xresource.h>
+#include <X11/keysym.h>
+#include <X11/Xmu/Error.h>
+#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
+#include <X11/extensions/shape.h>
+#endif
+#ifdef AMIGAOS
+#include <x11/xtrans.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <signal.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef USE_FONTSETS
+#include <locale.h>
+#endif
+
+#include "drawinfo.h"
+#include "screen.h"
+#include "icon.h"
+#include "client.h"
+#include "prefs.h"
+#include "module.h"
+#include "icc.h"
+#include "libami.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+
+struct timeval {
+  long tv_sec;
+  long tv_usec;
+};
+
+#define fd_set XTransFdset
+#undef FD_ZERO
+#undef FD_SET
+#define FD_ZERO XTransFdZero
+#define FD_SET XTransFdSet
+#define select XTransSelect
+#endif
+
+#define HYSTERESIS 5
+
+typedef struct _DragIcon {
+  Icon *icon;
+  Window w;
+  Pixmap pm;
+  int x, y;
+} DragIcon;
+
+Display *dpy = NULL;
+char *progname;
+Cursor wm_curs;
+int signalled=0, forcemoving=0;
+Client *activeclient=NULL, *dragclient=NULL, *resizeclient=NULL;
+Client *rubberclient=NULL, *clickclient=NULL, *doubleclient=NULL;
+Scrn *boundingscr=NULL; Window boundingwin=None;
+DragIcon *dragiconlist=NULL;
+int numdragicons=0;
+Window clickwindow=None;
+int rubberx, rubbery, rubberh, rubberw, rubberx0, rubbery0, olddragx, olddragy;
+Time last_icon_click=0, last_double=0;
+int initting=0;
+static int ignore_badwindow=0;
+int dblClickTime=1500;
+XContext client_context, screen_context, icon_context, menu_context, vroot_context;
+Scrn *dragscreen=NULL, *menuactive=NULL;
+static int d_offset=0;
+static fd_set master_fd_set;
+static int max_fd=0;
+char *free_screentitle=NULL;
+char *x_server=NULL;
+int shape_event_base, shape_error_base, shape_extn=0;
+int server_grabs=0;
+
+unsigned int meta_mask, switch_mask;
+
+static char **main_argv;
+
+extern Scrn *mbdclick, *mbdscr;
+
+extern void reparent(Client *);
+extern void redraw(Client *, Window);
+extern void redrawclient(Client *);
+extern void redrawmenubar(Window);
+extern void gadgetclicked(Client *c, Window w, XEvent *e);
+extern void gadgetunclicked(Client *c, XEvent *e);
+extern void gadgetaborted(Client *c);
+extern void clickenter(void);
+extern void clickleave(void);
+extern void menu_on(void);
+extern void menu_off(void);
+extern void menubar_enter(Window);
+extern void menubar_leave(Window);
+extern void *getitembyhotkey(KeySym);
+extern void menuaction(void *);
+extern void screentoback();
+extern void openscreen(char *, Window);
+extern void realizescreens(void);
+extern Scrn *getscreenbyroot(Window);
+extern void assimilate(Window, int, int);
+extern void deselect_all_icons(Scrn *);
+extern void reparenticon(Icon *, Scrn *, int, int);
+extern void handle_client_message(Client *, XClientMessageEvent *);
+extern void handle_module_input(fd_set *);
+extern int dispatch_event_to_broker(XEvent *, unsigned long, struct module *);
+extern XEvent *mkcmessage(Window w, Atom a, long x);
+extern void reshape_frame(Client *c);
+extern void read_rc_file(char *filename, int manage_all);
+extern void init_modules();
+extern void flushmodules();
+extern void raiselowerclient(Client *, int);
+
+#ifndef AMIGAOS
+void restart_amiwm()
+{
+  flushmodules();
+  flushclients();
+  XFlush(dpy);
+  XCloseDisplay(dpy);
+  execvp(main_argv[0], main_argv);
+}
+#endif
+
+int handler(Display *d, XErrorEvent *e)
+{
+  if (initting && (e->request_code == X_ChangeWindowAttributes) &&
+      (e->error_code == BadAccess)) {
+    fprintf(stderr, "%s: Another window manager is already running.  Not started.\n", progname);
+    exit(1);
+  }
+  
+  if (ignore_badwindow &&
+      (e->error_code == BadWindow || e->error_code == BadColor))
+    return 0;
+
+  if ((e->error_code == BadMatch && e->request_code == X_ChangeSaveSet) ||
+      (e->error_code == BadWindow && e->request_code == X_ChangeProperty) ||
+      (e->error_code == BadWindow && e->request_code == X_GetProperty) ||
+      (e->error_code == BadWindow && e->request_code == X_GetWindowAttributes) ||
+      (e->error_code == BadWindow && e->request_code == X_ChangeWindowAttributes) ||
+      (e->error_code == BadDrawable && e->request_code == X_GetGeometry) ||
+      (e->error_code == BadWindow && e->request_code == X_SendEvent))
+    return 0;
+  
+  XmuPrintDefaultErrorMessage(d, e, stderr);
+  
+  if (initting) {
+    fprintf(stderr, "%s: failure during initialisation; aborting\n",
+	    progname);
+    exit(1);
+  }
+  return 0;
+}
+
+static struct coevent {
+  struct coevent *next;
+  struct timeval when;
+  void (*what)(void *);
+  void *with;
+} *eventlist=NULL;
+
+#define FIXUPTV(tv) { \
+    while((tv).tv_usec<0) { (tv).tv_usec+=1000000; (tv).tv_sec--; } \
+    while((tv).tv_usec>=1000000) { (tv).tv_usec-=1000000; (tv).tv_sec++; } \
+}
+
+void remove_call_out(void (*what)(void *), void *with)
+{
+  struct coevent *ee, **e=&eventlist;
+
+  while(*e && ((*e)->what != what || (*e)->with != with))
+    e=&(*e)->next;
+  if((ee=*e)) {
+    *e=(*e)->next;
+    free(ee);
+  }
+}
+
+#ifdef BSD_STYLE_GETTIMEOFDAY
+#define GETTIMEOFDAY(tp) gettimeofday(tp, NULL)
+#else
+#define GETTIMEOFDAY(tp) gettimeofday(tp)
+#endif
+
+void call_out(int howlong_s, int howlong_u, void (*what)(void *), void *with)
+{
+  struct coevent *ce=malloc(sizeof(struct coevent));
+  if(ce) {
+    struct coevent **e=&eventlist;
+    GETTIMEOFDAY(&ce->when);
+    ce->when.tv_sec+=howlong_s;
+    ce->when.tv_usec+=howlong_u;
+    FIXUPTV(ce->when);
+    ce->what=what;
+    ce->with=with;
+    while(*e && ((*e)->when.tv_sec<ce->when.tv_sec ||
+		 ((*e)->when.tv_sec==ce->when.tv_sec &&
+		  (*e)->when.tv_usec<=ce->when.tv_usec)))
+      e=&(*e)->next;
+    ce->next=*e;
+    *e=ce;
+  }
+}
+
+static void call_call_out()
+{
+  struct timeval now;
+  struct coevent *e;
+  GETTIMEOFDAY(&now);
+  FIXUPTV(now);
+  while((e=eventlist) && (e->when.tv_sec<now.tv_sec ||
+			  (e->when.tv_sec==now.tv_sec &&
+			   e->when.tv_usec<=now.tv_usec))) {
+    eventlist=e->next;
+    (e->what)(e->with);
+    free(e);
+  }
+}
+
+static void fill_in_call_out(struct timeval *tv)
+{
+  GETTIMEOFDAY(tv);
+  tv->tv_sec=eventlist->when.tv_sec-tv->tv_sec;
+  tv->tv_usec=eventlist->when.tv_usec-tv->tv_usec;
+  FIXUPTV(*tv);
+  if(tv->tv_sec<0)
+    tv->tv_sec = tv->tv_usec = 0;
+}
+
+void add_fd_to_set(int fd)
+{
+  FD_SET(fd, &master_fd_set);
+  if(fd>=max_fd)
+    max_fd=fd+1;
+}
+
+void remove_fd_from_set(int fd)
+{
+  FD_CLR(fd, &master_fd_set);
+}
+
+void lookup_keysyms()
+{
+  int i,j,k,maxsym,mincode,maxcode;
+  XModifierKeymap *map=XGetModifierMapping(dpy);
+  KeySym *kp, *kmap;
+  unsigned int alt_mask = 0;
+  meta_mask=0, switch_mask=0;
+  XDisplayKeycodes(dpy, &mincode, &maxcode);
+  kmap=XGetKeyboardMapping(dpy, mincode, maxcode-mincode+1, &maxsym);
+  for(i=3; i<8; i++)
+    for(j=0; j<map->max_keypermod; j++)
+      if(map->modifiermap[i*map->max_keypermod+j] >= mincode)
+	for(kp=kmap+(map->modifiermap[i*map->max_keypermod+j]-mincode)*maxsym,
+	      k=0; k<maxsym; k++)
+	  switch(*kp++) {
+	  case XK_Meta_L:
+	  case XK_Meta_R:
+	    meta_mask|=1<<i;
+	    break;
+	  case XK_Mode_switch:
+	    switch_mask|=1<<i;
+	    break;
+	  case XK_Alt_L:
+	  case XK_Alt_R:
+	    alt_mask|=1<<i;
+	    break;
+	  }
+  XFree(kmap);
+  XFreeModifiermap(map);
+  if(meta_mask == 0)
+    meta_mask = (alt_mask? alt_mask :
+		 (switch_mask? switch_mask : Mod1Mask));
+}
+
+
+void restorescreentitle(Scrn *s)
+{
+  (scr=s)->title=s->deftitle;
+  XClearWindow(dpy, s->menubar);
+  redrawmenubar(s->menubar);  
+  if(free_screentitle) {
+    free(free_screentitle);
+    free_screentitle=NULL;
+  }
+}
+
+void wberror(Scrn *s, char *message)
+{
+  remove_call_out((void(*)(void *))restorescreentitle, s);
+  (scr=s)->title=message;
+  XClearWindow(dpy, s->menubar);
+  redrawmenubar(s->menubar);
+  XBell(dpy, 100);
+  call_out(2, 0, (void(*)(void *))restorescreentitle, s);
+}
+
+void setfocus(Window w)
+{
+  if(w == None && prefs.focus != FOC_CLICKTOTYPE)
+    w = PointerRoot;
+  XSetInputFocus(dpy, w, (prefs.focus==FOC_CLICKTOTYPE? RevertToNone:RevertToPointerRoot), CurrentTime);
+}
+
+static void update_clock(void *dontcare);
+
+void grab_server()
+{
+  if(!server_grabs++)
+    XGrabServer(dpy);
+}
+
+void ungrab_server()
+{
+  if(!--server_grabs) {
+    XUngrabServer(dpy);
+    if(prefs.titlebarclock) {
+      remove_call_out(update_clock, NULL);
+      update_clock(NULL);
+    }
+  }
+}
+
+void drawrubber()
+{
+  if(rubberclient)
+    XDrawRectangle(dpy, rubberclient->scr->back, rubberclient->scr->rubbergc,
+		   rubberx, rubbery, rubberw-1, rubberh-1);
+  else if(boundingwin) {
+    const char dash_list[] = { 6 };
+    int x=rubberx, y=rubbery, w=rubberw, h=rubberh;
+    if(w<0) { x+=w; w=-w; }
+    if(h<0) { y+=h; h=-h; }
+    if(w>=HYSTERESIS || h>=HYSTERESIS) {
+      XSetDashes(dpy, boundingscr->rubbergc, d_offset,
+		 dash_list, sizeof(dash_list));
+      XSetLineAttributes(dpy, boundingscr->rubbergc, 0, LineOnOffDash,
+			 CapButt, JoinMiter);
+      XDrawRectangle(dpy, boundingwin, boundingscr->rubbergc, x, y, w, h);
+      XSetLineAttributes(dpy, boundingscr->rubbergc, 0, LineSolid,
+			 CapButt, JoinMiter);
+    }
+  }
+}
+
+static void move_dashes(void *dontcare)
+{
+  call_out(0, 50000, move_dashes, dontcare);
+  drawrubber();
+  if((--d_offset)<0)
+    d_offset=11;
+  drawrubber();
+}
+
+void endrubber()
+{
+  if(rubberclient) {
+    if((!prefs.opaquemove||dragclient==NULL) && 
+       (!prefs.opaqueresize||resizeclient==NULL))
+      drawrubber();
+    rubberclient=NULL;
+  } else if(boundingwin) {
+    if((!prefs.opaquemove||dragclient==NULL) && 
+       (!prefs.opaqueresize||resizeclient==NULL))
+      drawrubber();
+    boundingwin=None;
+  }
+}
+
+void initrubber(int x0, int y0, Client *c)
+{
+  endrubber();
+  rubberx=c->x;
+  rubbery=c->y;
+  rubberw=c->pwidth;
+  rubberh=c->pheight;
+  rubberx0=x0;
+  rubbery0=y0;
+  rubberclient=c;
+}
+
+void abortrubber()
+{
+  if(rubberclient) {
+    endrubber();
+    dragclient=resizeclient=NULL;
+    ungrab_server();
+    XUngrabPointer(dpy, CurrentTime);
+  } else if(boundingwin) {
+    endrubber();
+    boundingwin=None;
+    boundingscr=NULL;
+    ungrab_server();
+    XUngrabPointer(dpy, CurrentTime);
+  }
+}
+
+void startbounding(Scrn *s, Window w, XEvent *e)
+{
+  last_icon_click=e->xbutton.time;
+  boundingscr=s;
+  boundingwin=w;
+  XGrabPointer(dpy, w, False, Button1MotionMask|ButtonPressMask|
+	       ButtonReleaseMask, GrabModeAsync, GrabModeAsync, s->back, None,
+	       CurrentTime);
+  grab_server();
+  rubberx=e->xbutton.x;
+  rubbery=e->xbutton.y;
+  rubberx0=e->xbutton.x_root;
+  rubbery0=e->xbutton.y_root;
+  rubberw=0;
+  rubberh=0;
+  drawrubber();
+  call_out(0, 0, move_dashes, NULL);
+}
+
+void endbounding(XEvent *e)
+{
+  Icon *i;
+  int bx, by;
+  Window cc;
+
+  if(boundingscr) {
+    remove_call_out(move_dashes, NULL);
+    endrubber();
+    if(!(e->xbutton.state & ShiftMask))
+      deselect_all_icons(boundingscr);
+
+    if(rubberw<0) {
+      rubberx+=rubberw;
+      rubberw=-rubberw;
+    }
+    if(rubberh<0) {
+      rubbery+=rubberh;
+      rubberh=-rubberh;
+    }
+    if(rubberw>=HYSTERESIS || rubberh>=HYSTERESIS)
+      for(i=boundingscr->icons; i; i=i->next)
+	if(i->window && i->mapped &&
+	   XTranslateCoordinates(dpy, i->parent, scr->back, i->x, i->y,
+				 &bx, &by, &cc) &&
+	   bx<rubberx+rubberw && by<rubbery+rubberh &&
+	   bx+i->width>rubberx && by+i->height>rubbery)
+	  selecticon(i);
+    boundingscr=NULL;
+    ungrab_server();
+    XUngrabPointer(dpy, CurrentTime);
+  }
+}
+
+void startdragging(Client *c, XEvent *e)
+{
+  scr=c->scr;
+  dragclient=c;
+  XGrabPointer(dpy, c->drag, False, Button1MotionMask|ButtonPressMask|
+	       ButtonReleaseMask, GrabModeAsync, GrabModeAsync, scr->back,
+	       None, CurrentTime);
+  if(!prefs.opaquemove)
+    grab_server();
+  initrubber(e->xbutton.x_root, e->xbutton.y_root, c);
+  rubberx0-=rubberx;
+  rubbery0-=rubbery;
+  if(!forcemoving) {
+    if(rubberx+rubberw>scr->width)
+      rubberx=scr->width-rubberw;
+    if(rubbery+rubberh>scr->height)
+      rubbery=scr->height-rubberh;
+    if(rubberx<0)
+      rubberx=0;
+    if(rubbery<0)
+      rubbery=0;
+  }
+  if(!prefs.opaquemove)
+    drawrubber();
+}
+
+void startscreendragging(Scrn *s, XEvent *e)
+{
+  dragscreen=s;
+  XGrabPointer(dpy, s->menubar, False, Button1MotionMask|ButtonPressMask|
+	       ButtonReleaseMask, GrabModeAsync, GrabModeAsync, s->root, None,
+	       CurrentTime);
+  olddragy=rubbery=s->y;
+  rubbery0=e->xbutton.y_root-rubbery;
+}
+
+void endscreendragging()
+{
+  Scrn *s;
+  if((s=dragscreen)) {
+#ifndef ASSIMILATE_WINDOWS
+    scrsendconfig(dragscreen);
+#endif
+    dragscreen=NULL;
+    XUngrabPointer(dpy, CurrentTime);
+  }
+}
+
+void abortscreendragging()
+{
+  if(dragscreen) {
+    XMoveWindow(dpy, dragscreen->back, -dragscreen->bw,
+		(dragscreen->y=olddragy)-dragscreen->bw);
+    endscreendragging();
+  }
+}
+
+void aborticondragging()
+{
+  if(numdragicons) {
+    int i;
+    for(i=0; i<numdragicons; i++) {
+      XDestroyWindow(dpy, dragiconlist[i].w);
+      if(dragiconlist[i].pm)
+	XFreePixmap(dpy, dragiconlist[i].pm);
+    }
+    numdragicons=0;
+    free(dragiconlist);
+    dragiconlist=NULL;
+    XUngrabPointer(dpy, CurrentTime);
+  }
+}
+
+void badicondrop()
+{
+  wberror(dragiconlist[0].icon->scr,
+	  "Icons cannot be moved into this window");
+  aborticondragging();
+}
+
+void endicondragging(XEvent *e)
+{
+  int i;
+  Client *c;
+  int wx, wy;
+  Window ch;
+
+  scr=front;
+  for(;;) {
+    if(scr->root == e->xbutton.root && e->xbutton.y_root>=scr->y)
+      break;
+    if((scr=scr->behind)==front) {
+      badicondrop();
+      return;
+    }
+  }
+
+  if(XTranslateCoordinates(dpy, scr->root, scr->back,
+			   e->xbutton.x_root, e->xbutton.y_root,
+			   &wx, &wy, &ch) && ch!=None) {
+    if(XFindContext(dpy, ch, client_context, (XPointer*)&c) ||
+       c->scr != scr || c->state != NormalState)
+      c = NULL;
+  } else
+    c = NULL;
+
+  if(c) {
+    if(c->module) {
+      extern Atom amiwm_appwindowmsg;
+      XTranslateCoordinates(dpy, scr->back, c->window, -4, -4, &wx, &wy, &ch);
+      for(i=0; i<numdragicons; i++) {
+	XEvent *e=mkcmessage(c->window, amiwm_appwindowmsg,
+			     dragiconlist[i].icon->window);
+	e->xclient.data.l[2] = dragiconlist[i].x+wx;
+	e->xclient.data.l[3] = dragiconlist[i].y+wy;
+	dispatch_event_to_broker(e, 0, c->module);
+      }
+      aborticondragging();
+    } else
+      badicondrop();
+    return;
+  }
+
+  for(i=0; i<numdragicons; i++)
+    dragiconlist[i].icon->mapped=0;
+  for(i=0; i<numdragicons; i++) {
+    if(dragiconlist[i].icon->scr!=scr)
+      reparenticon(dragiconlist[i].icon, scr,
+		   dragiconlist[i].x-4, dragiconlist[i].y-4-scr->y);
+    else
+      XMoveWindow(dpy, dragiconlist[i].icon->window,
+		  dragiconlist[i].icon->x = dragiconlist[i].x-4,
+		  dragiconlist[i].icon->y = dragiconlist[i].y-4-scr->y);
+    dragiconlist[i].icon->mapped=1;
+    adjusticon(dragiconlist[i].icon);
+  }
+  aborticondragging();
+}
+
+void starticondragging(Scrn *scr, XEvent *e)
+{
+  XWindowAttributes xwa;
+  XSetWindowAttributes xswa;
+  Icon *i;
+  Window ww;
+
+  aborticondragging();
+  for(i=scr->firstselected; i; i=i->nextselected)
+    numdragicons++;
+  if(!numdragicons)
+    return;
+
+  if(!(dragiconlist=calloc(numdragicons, sizeof(DragIcon)))) {
+    numdragicons=0;
+    XBell(dpy, 100);
+    return;
+  }
+
+  for(numdragicons=0, i=scr->firstselected; i; i=i->nextselected) {
+    dragiconlist[numdragicons].icon = i;
+    XGetWindowAttributes(dpy, i->window, &xwa);
+    if(i->parent!=scr->back)
+      XTranslateCoordinates(dpy, i->parent, scr->back, xwa.x, xwa.y,
+			    &xwa.x, &xwa.y, &ww);
+    dragiconlist[numdragicons].x = xwa.x+4;
+    dragiconlist[numdragicons].y = xwa.y+4+scr->y;
+    xswa.save_under=True;
+    xswa.override_redirect=True;
+    if(i->innerwin) {
+      XGetWindowAttributes(dpy, i->innerwin, &xwa);
+      xswa.background_pixmap = dragiconlist[numdragicons].pm =
+	XCreatePixmap(dpy, i->innerwin, xwa.width, xwa.height, xwa.depth);
+      XCopyArea(dpy, i->innerwin, dragiconlist[numdragicons].pm, scr->gc,
+		0, 0, xwa.width, xwa.height, 0, 0);
+    } else {
+      if(i->secondpm) {
+	xswa.background_pixmap = i->secondpm;
+	XGetGeometry(dpy, i->secondpm, &xwa.root, &xwa.x, &xwa.y,
+		     (unsigned int *)&xwa.width, (unsigned int *)&xwa.height,
+		     (unsigned int *)&xwa.border_width,
+		     (unsigned int *)&xwa.depth);
+      } else if(i->iconpm) {
+	xswa.background_pixmap = i->iconpm;
+	XGetGeometry(dpy, i->iconpm, &xwa.root, &xwa.x, &xwa.y,
+		     (unsigned int *)&xwa.width, (unsigned int *)&xwa.height,
+		     (unsigned int *)&xwa.border_width,
+		     (unsigned int *)&xwa.depth);
+      }
+      if(xwa.depth!=scr->depth) {
+	dragiconlist[numdragicons].pm =
+	  XCreatePixmap(dpy, i->window, xwa.width, xwa.height, scr->depth);
+	XSetForeground(dpy, scr->gc, scr->dri.dri_Pens[SHADOWPEN]);
+	XSetBackground(dpy, scr->gc, scr->dri.dri_Pens[BACKGROUNDPEN]);
+	XCopyPlane(dpy, xswa.background_pixmap, dragiconlist[numdragicons].pm,
+		   scr->gc, 0, 0, xwa.width, xwa.height, 0, 0, 1);
+	xswa.background_pixmap = dragiconlist[numdragicons].pm;
+	xwa.depth = scr->depth;
+      }
+    }
+    xswa.colormap=xwa.colormap;
+    dragiconlist[numdragicons].w =
+      XCreateWindow(dpy, scr->root,
+		    dragiconlist[numdragicons].x,
+		    dragiconlist[numdragicons].y,
+		    xwa.width, xwa.height, 0,
+		    xwa.depth, xwa.class, xwa.visual,
+		    CWBackPixmap|CWOverrideRedirect|CWSaveUnder|CWColormap,
+		    &xswa);
+#ifdef HAVE_XSHAPE
+    if(shape_extn)
+      if(i->innerwin) {
+	int bShaped, xbs, ybs, cShaped, xcs, ycs;
+	unsigned int wbs, hbs, wcs, hcs;
+	XShapeQueryExtents(dpy, i->innerwin, &bShaped, &xbs, &ybs, &wbs, &hbs,
+			   &cShaped, &xcs, &ycs, &wcs, &hcs);
+	if(bShaped)
+	  XShapeCombineShape(dpy, dragiconlist[numdragicons].w, ShapeBounding,
+			     0, 0, i->innerwin, ShapeBounding, ShapeSet);
+      } else if(i->maskpm) {
+	XShapeCombineMask(dpy, dragiconlist[numdragicons].w, ShapeBounding,
+			  0, 0, i->maskpm, ShapeSet);
+      }
+#endif
+    XMapRaised(dpy, dragiconlist[numdragicons].w);
+    numdragicons++;
+  }
+  XGrabPointer(dpy, scr->back, False, Button1MotionMask|ButtonPressMask|
+	       ButtonReleaseMask, GrabModeAsync, GrabModeAsync, scr->root,
+	       None, CurrentTime);
+  olddragx = rubberx0 = e->xbutton.x_root;
+  olddragy = rubbery0 = e->xbutton.y_root;
+}
+
+void enddragging()
+{
+  if(dragclient) {
+    Client *c=dragclient;
+    endrubber();
+    if(rubbery<=-(c->scr->bh))
+      rubbery=1-(c->scr->bh);
+    XMoveWindow(dpy, c->parent, c->x=rubberx, c->y=rubbery);
+    dragclient=NULL;
+    if(!prefs.opaquemove)
+      ungrab_server();
+    XUngrabPointer(dpy, CurrentTime);
+    sendconfig(c);
+  }
+}
+
+void do_icon_double_click(Scrn *scr)
+{
+  extern Atom amiwm_appiconmsg;
+  Icon *i, *next;
+  Client *c;
+
+  for(i=scr->firstselected; i; i=next) {
+    next=i->nextselected;
+    if(i->module) {
+      dispatch_event_to_broker(mkcmessage(i->window, amiwm_appiconmsg, 0),
+			       0, i->module);
+    } else {
+      if(i->labelwin)
+	XUnmapWindow(dpy, i->labelwin);
+      if(i->window)
+	XUnmapWindow(dpy, i->window);
+      i->mapped=0;
+      deselecticon(i);
+      if((c=(i->client))) {
+	XMapWindow(dpy, c->window);
+	if(c->parent!=c->scr->root)
+	  XMapRaised(dpy, c->parent);
+	setclientstate(c, NormalState);
+      }
+    }
+  }
+}
+
+void startresizing(Client *c, XEvent *e)
+{
+  resizeclient=c;
+  XGrabPointer(dpy, c->resize, False, Button1MotionMask|ButtonPressMask|
+	       ButtonReleaseMask, GrabModeAsync, GrabModeAsync,
+	       c->scr->back, None, CurrentTime);
+  if(!prefs.opaqueresize)
+    grab_server(); 
+  initrubber(e->xbutton.x_root, e->xbutton.y_root, c);
+  rubberx0-=rubberw;
+  rubbery0-=rubberh;
+  if(!prefs.opaqueresize)
+    drawrubber();
+}
+
+void endresizing()
+{
+  extern void resizeclientwindow(Client *c, int, int);
+  if(resizeclient) {
+    Client *c=resizeclient;
+    endrubber();
+    if(!prefs.opaqueresize)
+      ungrab_server();
+    resizeclientwindow(c, rubberw, rubberh);
+    resizeclient=NULL;
+    XUngrabPointer(dpy, CurrentTime);
+  }
+}
+
+void abortfocus()
+{
+  if(activeclient) {
+    activeclient->active=False;
+    redrawclient(activeclient);
+    if(prefs.focus==FOC_CLICKTOTYPE)
+      XGrabButton(dpy, Button1, AnyModifier, activeclient->parent,
+		  True, ButtonPressMask, GrabModeSync, GrabModeAsync,
+		  None, wm_curs);
+    activeclient = NULL;
+  }
+  setfocus(None);
+}
+
+RETSIGTYPE sighandler(int sig)
+{
+  signalled=1;
+  signal(sig, SIG_IGN);
+}
+
+static void instcmap(Colormap c)
+{
+  XInstallColormap(dpy, (c == None) ? scr->cmap : c);
+}
+
+void internal_broker(XEvent *e)
+{
+  int event_loc=(int)e->xany.display;
+  e->xany.display=dpy;
+  if(event_loc==1) {
+    XSendEvent(dpy, e->xany.window, False, 0, e);
+  } else switch(e->type) {
+  case MappingNotify:
+    if(e->xmapping.request==MappingKeyboard ||
+       e->xmapping.request==MappingModifier)
+      XRefreshKeyboardMapping(&e->xmapping);
+    lookup_keysyms(dpy, &meta_mask, &switch_mask);
+    break;
+  case KeyPress:
+    if(e->xkey.state & meta_mask) {
+      KeySym ks=XLookupKeysym(&e->xkey,
+			      ((e->xkey.state & ShiftMask)?1:0)+
+			      ((e->xkey.state & switch_mask)?2:0));
+      void *item;
+      if((item=getitembyhotkey(ks)))
+	menuaction(item);
+    }
+    break;
+  }
+}
+
+static void update_clock(void *dontcare)
+{
+  if(server_grabs)
+    return;
+  call_out(prefs.titleclockinterval, 0, update_clock, dontcare);
+  scr = front;
+  do {
+    redrawmenubar(scr->menubar);
+    scr=scr->behind;
+  } while(scr!=front);
+}
+
+void cleanup()
+{
+  extern void free_prefs();
+  struct coevent *e;
+  flushmodules();
+  flushclients();
+  scr=front;
+  while(scr)
+    closescreen();
+  free_prefs();
+  if(dpy) {
+    XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
+    XFlush(dpy);
+    XCloseDisplay(dpy);
+  }
+  while((e = eventlist)) {
+    eventlist = e->next;
+    free(e);
+  }
+  if(x_server)
+    free(x_server);
+}
+
+int main(int argc, char *argv[])
+{
+  int x_fd, sc;
+  static Argtype array[3];
+  struct RDArgs *ra;
+
+#ifdef USE_FONTSETS
+  setlocale(LC_CTYPE, "");
+  setlocale(LC_TIME, "");
+#endif
+
+  main_argv=argv;
+  progname=argv[0];
+
+  atexit(cleanup);
+
+  memset(array, 0, sizeof(array));
+  initargs(argc, argv);
+  if(!(ra=ReadArgs((UBYTE *)"RCFILE,DISPLAY/K,SINGLE/S",
+		   (LONG *)array, NULL))) {
+    PrintFault(IoErr(), (UBYTE *)progname);
+    exit(1);
+  }
+
+  x_server = strdup(XDisplayName(array[1].ptr));
+
+  XrmInitialize();
+
+  if(!(dpy = XOpenDisplay(array[1].ptr))) {
+    fprintf(stderr, "%s: cannot connect to X server %s\n", progname, x_server);
+    FreeArgs(ra);
+    exit(1);
+  }
+
+  if(array[1].ptr) {
+    char *env=malloc(strlen((char *)array[1].ptr)+10);
+    sprintf(env, "DISPLAY=%s", (char *)array[1].ptr);
+    putenv(env);
+  }
+
+  client_context = XUniqueContext();
+  screen_context = XUniqueContext();
+  icon_context = XUniqueContext();
+  menu_context = XUniqueContext();
+  vroot_context = XUniqueContext();
+
+  wm_curs=XCreateFontCursor(dpy, XC_top_left_arrow);
+
+  FD_ZERO(&master_fd_set);
+  FD_SET((x_fd=ConnectionNumber(dpy)), &master_fd_set);
+  max_fd=x_fd+1;
+
+  initting = 1;
+  XSetErrorHandler(handler);
+
+#ifdef HAVE_XSHAPE
+  if(XShapeQueryExtension(dpy, &shape_event_base, &shape_error_base))
+    shape_extn = 1;
+#endif
+
+  XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask);
+  XSync(dpy, False);
+  XSelectInput(dpy, DefaultRootWindow(dpy), NoEventMask);
+
+  init_modules();
+  read_rc_file(array[0].ptr, !array[2].num);
+  if( prefs.titleclockinterval < 1 ) prefs.titleclockinterval = 1;
+  FreeArgs(ra);
+
+  if (signal(SIGTERM, sighandler) == SIG_IGN)
+    signal(SIGTERM, SIG_IGN);
+  if (signal(SIGINT, sighandler) == SIG_IGN)
+    signal(SIGINT, SIG_IGN);
+#ifdef SIGHUP
+  if (signal(SIGHUP, sighandler) == SIG_IGN)
+    signal(SIGHUP, SIG_IGN);
+#endif
+
+  init_atoms();
+
+#ifndef AMIGAOS
+  if((fcntl(ConnectionNumber(dpy), F_SETFD, 1)) == -1)
+    fprintf(stderr, "%s: child cannot disinherit TCP fd\n", progname);
+#endif
+
+  lookup_keysyms(dpy, &meta_mask, &switch_mask);
+
+  for(sc=0; sc<ScreenCount(dpy); sc++)
+    if(sc==DefaultScreen(dpy) || prefs.manage_all)
+      if(!getscreenbyroot(RootWindow(dpy, sc))) {
+	char buf[64];
+	sprintf(buf, "Screen.%d", sc);
+	openscreen((sc? strdup(buf):"Workbench Screen"), RootWindow(dpy, sc));
+      }
+  /*
+  if(!front)
+    openscreen("Workbench Screen", DefaultRootWindow(dpy));
+    */
+  realizescreens();
+
+  setfocus(None);
+
+  initting = 0;
+
+  if(prefs.titlebarclock)
+    call_out(0, 0, update_clock, NULL);
+
+  while(!signalled) {
+    fd_set rfds;
+    struct timeval t;
+    XEvent event;
+    Window dummy_root;
+    int dummy_x, dummy_y;
+    unsigned int dummy_w, dummy_h, dummy_bw, dummy_d;
+
+    while((!signalled) && QLength(dpy)>0) {
+      Client *c; Icon *i;
+      int motionx, motiony;
+      
+      XNextEvent(dpy, &event);
+      if(!XFindContext(dpy, event.xany.window, client_context,
+		       (XPointer*)&c)) {
+	scr=c->scr;
+      } else {
+	c = NULL;
+	if(XFindContext(dpy, event.xany.window, screen_context,
+			(XPointer*)&scr))
+	  scr=front;
+      }
+      if(XFindContext(dpy, event.xany.window, icon_context, (XPointer*)&i))
+	i=NULL;
+      else
+	scr=i->scr;
+      switch(event.type) {
+      case Expose:
+	if(!event.xexpose.count) {
+	  if((rubberclient || boundingscr)&&!prefs.opaquemove
+             &&!prefs.opaqueresize) 
+            drawrubber();
+	  if(c)
+	    redraw(c, event.xexpose.window);
+	  else if(i)
+	    redrawicon(i, event.xexpose.window);
+	  else if(scr)
+	    redrawmenubar(event.xexpose.window);
+	  if((rubberclient || boundingscr)&&!prefs.opaquemove) drawrubber();
+	}
+	break;
+      case CreateNotify:
+	if(!XFindContext(dpy, event.xcreatewindow.window, client_context,
+			 (XPointer *)&c))
+	  break;
+	if(!event.xcreatewindow.override_redirect) {
+	  if(!(scr=getscreenbyroot(event.xcreatewindow.parent)))
+	    scr=front;
+	  createclient(event.xcreatewindow.window);
+	}
+#ifdef ASSIMILATE_WINDOWS
+	else if(XFindContext(dpy, event.xcreatewindow.window, screen_context, (XPointer*)&scr)
+		&& (scr=getscreenbyroot(event.xcreatewindow.parent))) {
+	  XGetWindowAttributes(dpy, event.xcreatewindow.window, &attr);
+	  assimilate(event.xcreatewindow.window, attr.x, attr.y);
+	}
+#endif
+	break;
+      case DestroyNotify:
+	if(!XFindContext(dpy, event.xdestroywindow.window, client_context,
+			 (XPointer*)&c)) {
+	  ignore_badwindow = 1;
+	  rmclient(c);
+	  XSync(dpy, False);
+	  ignore_badwindow = 0;
+	} else if(!XFindContext(dpy, event.xdestroywindow.window, icon_context,
+				(XPointer*)&i)) {
+	  ignore_badwindow = 1;
+	  if(i->client)
+	    i->client->icon=NULL;
+	  rmicon(i);
+	  XSync(dpy, False);
+	  ignore_badwindow = 0;	  
+	} else if(event.xdestroywindow.window)
+	  XDeleteContext(dpy, event.xdestroywindow.window, screen_context);
+	break;
+      case UnmapNotify:
+	if(c && c->active && (event.xunmap.window==c->parent)) {
+	  c->active=False;
+	  activeclient = NULL;
+	  redrawclient(c);
+	  if(prefs.focus == FOC_CLICKTOTYPE)
+	    XGrabButton(dpy, Button1, AnyModifier, c->parent, True,
+			ButtonPressMask, GrabModeSync, GrabModeAsync,
+			None, wm_curs);
+	  if(!menuactive)
+	    setfocus(None);
+	}
+	if(c && (event.xunmap.window==c->window)) {
+	  if((!c->reparenting) && c->parent != c->scr->root) {
+	    Icon *i=c->icon;
+	    XUnmapWindow(dpy, c->parent);
+	    if(i) {
+	      if(i->labelwin)
+		XUnmapWindow(dpy, i->labelwin);
+	      if(i->window)
+		XUnmapWindow(dpy, i->window);
+	      i->mapped=0;
+	      deselecticon(i);
+	    }
+	    setclientstate(c, WithdrawnState);
+	  }
+	  c->reparenting = 0;
+	}
+	break;
+      case ConfigureNotify:
+	if((!XFindContext(dpy, event.xconfigure.window, icon_context,
+			 (XPointer *)&i)) &&
+	   event.xconfigure.window == i->window){
+	  i->x=event.xconfigure.x; i->y=event.xconfigure.y;
+	  i->width=event.xconfigure.width; i->height=event.xconfigure.height;
+	  if(i->labelwin) {
+	    XWindowChanges xwc;
+	    xwc.x=i->x+(i->width>>1)-(i->labelwidth>>1);
+	    xwc.y=i->y+i->height+1;
+	    xwc.sibling=i->window;
+	    xwc.stack_mode=Below;
+	    XConfigureWindow(dpy, i->labelwin, CWX|CWY|CWSibling|CWStackMode,
+			       &xwc);
+	  }
+	}
+	break;
+      case ReparentNotify:
+	if((!XFindContext(dpy, event.xreparent.window, icon_context,
+			 (XPointer *)&i)) &&
+	   event.xreparent.window == i->window){
+	  i->parent=event.xreparent.parent;
+	  i->x=event.xreparent.x; i->y=event.xreparent.y;
+	  if(i->labelwin) {
+	    XWindowChanges xwc;
+	    XReparentWindow(dpy, i->labelwin, i->parent,
+			i->x+(i->width>>1)-(i->labelwidth>>1),
+			i->y+i->height+1);
+	    xwc.sibling=i->window;
+	    xwc.stack_mode=Below;
+	    XConfigureWindow(dpy, i->labelwin, CWSibling|CWStackMode, &xwc);
+	  }
+	}
+	break;
+      case CirculateNotify:
+      case GravityNotify:
+      case NoExpose:
+      case GraphicsExpose:
+	break;
+      case ClientMessage:
+	if(c)
+	  handle_client_message(c, &event.xclient);
+	break;
+      case ColormapNotify:
+	if(event.xcolormap.new && c)
+	  if(c->colormap!=event.xcolormap.colormap) {
+	    c->colormap=event.xcolormap.colormap;
+	    if(c->active)
+	      instcmap(c->colormap);
+	  }
+	break;
+      case ConfigureRequest:
+	if(XFindContext(dpy, event.xconfigurerequest.window, client_context,
+			(XPointer*)&c))
+	  c = NULL;
+	if(c && event.xconfigurerequest.window==c->window &&
+	   c->parent!=c->scr->root) {
+	  extern void resizeclientwindow(Client *c, int, int);
+	  if(event.xconfigurerequest.value_mask&CWBorderWidth)
+	    c->old_bw=event.xconfigurerequest.border_width;
+	  resizeclientwindow(c, (event.xconfigurerequest.value_mask&CWWidth)?
+			     event.xconfigurerequest.width+c->framewidth:c->pwidth,
+			     (event.xconfigurerequest.value_mask&CWHeight)?
+			     event.xconfigurerequest.height+c->frameheight:c->pheight);
+	  if((event.xconfigurerequest.value_mask&(CWX|CWY)) &&
+	     c->state==WithdrawnState)
+	    XMoveWindow(dpy, c->parent,
+			c->x=((event.xconfigurerequest.value_mask&CWX)?
+			      event.xconfigurerequest.x:c->x),
+			c->y=((event.xconfigurerequest.value_mask&CWY)?
+			      event.xconfigurerequest.y:c->y));
+	} else {
+	  if(!XFindContext(dpy, event.xconfigurerequest.window,
+			    screen_context, (XPointer *)&scr))
+	    if((event.xconfigurerequest.y-=scr->y)<0)
+	      event.xconfigurerequest.y=0;
+	  XConfigureWindow(dpy, event.xconfigurerequest.window,
+			   event.xconfigurerequest.value_mask,
+			   (XWindowChanges *)&event.xconfigurerequest.x);
+	}
+	break;
+      case CirculateRequest:
+	if(XFindContext(dpy, event.xcirculaterequest.window, client_context, (XPointer*)&c))
+	  if(event.xcirculaterequest.place==PlaceOnTop)
+	    XRaiseWindow(dpy, event.xcirculaterequest.window);
+	  else {
+	    Client *c2;
+	    Window r,p,*children;
+	    unsigned int nchildren;
+	    if(XQueryTree(dpy, scr->back, &r, &p, &children, &nchildren)) {
+	      int n;
+	      for(n=0; n<nchildren; n++)
+		if((!XFindContext(dpy, children[n], client_context, (XPointer*)&c2)) &&
+		   children[n]==c2->parent)
+		  break;
+	      if(n<nchildren) {
+		Window ws[2];
+		ws[0]=children[n];
+		ws[1]=event.xcirculaterequest.window;
+		XRestackWindows(dpy, ws, 2);
+	      }
+	    }
+	  }
+	else
+	  raiselowerclient(c, event.xcirculaterequest.place);
+	break;
+      case MapRequest:
+	if(XFindContext(dpy, event.xmaprequest.window, client_context, (XPointer*)&c)) {
+	  if(!(scr=getscreenbyroot(event.xmaprequest.parent)))
+	    scr=front;
+	  c=createclient(event.xmaprequest.window);
+	}
+	{
+	  XWMHints *xwmh;
+	  if(c->parent==c->scr->root && (xwmh=XGetWMHints(dpy, c->window))) {
+	    if(c->state==WithdrawnState && (xwmh->flags&StateHint)
+	       && xwmh->initial_state==IconicState)
+	      c->state=IconicState;
+	    XFree(xwmh);
+	  }
+	  switch(c->state) {
+	  case WithdrawnState:
+	    if(c->parent == c->scr->root)
+	      reparent(c);
+	  case NormalState:
+	    XMapWindow(dpy, c->window);
+	    XMapRaised(dpy, c->parent);
+	    setclientstate(c, NormalState);
+	    break;
+	  case IconicState:
+	    if(c->parent == c->scr->root)
+	      reparent(c);
+	    if(!(c->icon))
+	      createicon(c);
+	    adjusticon(c->icon);
+	    XMapWindow(dpy, c->icon->window);
+	    if(c->icon->labelwidth)
+	      XMapWindow(dpy, c->icon->labelwin);
+	    c->icon->mapped=1;
+	    setclientstate(c, IconicState);
+	    break;
+	  }
+	}
+	break;
+      case MapNotify:
+	if(prefs.focus == FOC_CLICKTOTYPE && c &&
+	   event.xmap.window == c->parent && c->parent != c->scr->root &&
+	   (!c->active)) {
+	  if(activeclient) {
+	    XGrabButton(dpy, Button1, AnyModifier, activeclient->parent,
+			True, ButtonPressMask, GrabModeSync, GrabModeAsync,
+			None, wm_curs);
+	    activeclient->active=False;
+	    redrawclient(activeclient);
+	  }
+	  c->active=True;
+	  activeclient = c;
+	  XUngrabButton(dpy, Button1, AnyModifier, c->parent);
+	  redrawclient(c);
+	  setfocus(c->window);
+	}
+	break;
+      case EnterNotify:
+	if(menuactive) {
+	  scr=menuactive;
+	  menubar_enter(event.xcrossing.window);
+	} else if(clickwindow && event.xcrossing.window == clickwindow)
+	  clickenter();
+	else if(c) {
+	  if((!c->active) && (c->state==NormalState) &&
+	     prefs.focus!=FOC_CLICKTOTYPE) {
+	    if(activeclient) {
+	      activeclient->active=False;
+	      redrawclient(activeclient);
+	    }
+	    setfocus(c->window);
+	    c->active=True;
+	    activeclient = c;
+	    redrawclient(c);
+	    if(prefs.autoraise && c->parent!=c->scr->root)
+	      XRaiseWindow(dpy, c->parent);
+	  }
+	  if(event.xcrossing.window==c->window)
+	    instcmap(c->colormap);
+	}
+	break;
+      case LeaveNotify:
+	if(menuactive) {
+	  scr=menuactive;
+	  menubar_leave(event.xcrossing.window);
+	} else if(clickwindow && event.xcrossing.window == clickwindow)
+	  clickleave();
+	else if(c) {
+	  if(c->active && event.xcrossing.window==c->parent &&
+	     event.xcrossing.detail!=NotifyInferior &&
+	     prefs.focus == FOC_FOLLOWMOUSE) {
+	    if(!menuactive)
+	      setfocus(None);
+	    c->active=False;
+	    activeclient = NULL;
+	    instcmap(None);
+	    redrawclient(c);
+	  } else if(event.xcrossing.window==c->window &&
+		    event.xcrossing.detail!=NotifyInferior &&
+		    event.xcrossing.mode==NotifyNormal)
+	    instcmap(None);
+	}
+	break;
+      case ButtonPress:
+	if(!rubberclient && !boundingscr && clickwindow==None &&
+	   !dragiconlist && event.xbutton.button==Button1 &&
+	   !dragscreen && !menuactive)
+	  if(c) {
+	    if((!c->active) && prefs.focus==FOC_CLICKTOTYPE &&
+	       (c->state==NormalState)) {
+	      if(activeclient) {
+		activeclient->active=False;
+		redrawclient(activeclient);
+		XGrabButton(dpy, Button1, AnyModifier, activeclient->parent,
+			    True, ButtonPressMask, GrabModeSync, GrabModeAsync,
+			    None, wm_curs);
+	      }
+	      setfocus(c->window);
+	      c->active=True;
+	      activeclient = c;
+	      redrawclient(c);
+	      XUngrabButton(dpy, Button1, AnyModifier, c->parent);
+	      if(prefs.autoraise && c->parent!=c->scr->root)
+		XRaiseWindow(dpy, c->parent);
+	    }
+	    if(event.xbutton.window!=c->depth &&
+	       event.xbutton.window!=c->window)
+	      if(c==doubleclient && (event.xbutton.time-last_double)<
+		 dblClickTime) {
+		XRaiseWindow(dpy, c->parent);
+	      } else {
+		doubleclient=c;
+		last_double=event.xbutton.time;
+	      }
+	    if(event.xbutton.window==c->drag) {
+	      forcemoving=(prefs.forcemove==FM_ALWAYS) ||
+		(event.xbutton.state & ShiftMask);
+	      startdragging(c, &event);
+	    } else if(event.xbutton.window==c->resize)
+	      startresizing(c, &event);
+	    else if(event.xbutton.window==c->window ||
+		    event.xbutton.window==c->parent)
+	      ;
+	    else
+	      gadgetclicked(c, event.xbutton.window, &event);
+	  } else if(i && event.xbutton.window==i->window) {
+	    abortfocus();
+	    if(i->selected && (event.xbutton.time-last_icon_click)<dblClickTime) {
+	      do_icon_double_click(i->scr);
+	    } else {
+	      if(!(event.xbutton.state & ShiftMask))
+		deselect_all_icons(i->scr);
+	      last_icon_click=event.xbutton.time;
+	      selecticon(i);
+	      starticondragging(i->scr, &event);
+	    }
+	  } else if(scr&&event.xbutton.window==scr->menubardepth) {
+	    clickwindow=scr->menubardepth;
+	    mbdclick=mbdscr=scr;
+	    redrawmenubar(scr->menubardepth);
+	  } else if(scr&&event.xbutton.window==scr->menubar &&
+		    scr->back!=scr->root) {
+	    startscreendragging(scr, &event);
+	  }
+	  else if(scr&&scr->back==event.xbutton.window) {
+	    abortfocus();
+	    startbounding(scr, scr->back, &event);
+	  } else ;
+	else if(event.xbutton.button==3) {
+	  if(rubberclient || boundingscr)
+	    abortrubber();
+	  else if(scr&&(scr==mbdscr)&&clickwindow==scr->menubardepth) {
+	    mbdclick=NULL;
+	    clickwindow=None;
+	    redrawmenubar(scr->menubardepth);
+	  } else if(clickclient)
+	    gadgetaborted(clickclient);
+	  else if(dragiconlist)
+	    aborticondragging();
+	  else if(dragscreen)
+	    abortscreendragging();
+	  else if(scr&&!menuactive) {
+	    menu_on();
+	    menuactive=scr;
+	  }
+	}
+	if(prefs.focus == FOC_CLICKTOTYPE && !menuactive) {
+	  XSync(dpy,0);
+	  XAllowEvents(dpy,ReplayPointer,CurrentTime);
+	  XSync(dpy,0);
+	}
+	break;
+      case ButtonRelease:
+	if(event.xbutton.button==Button1) {
+	  if(rubberclient) {
+	    if(dragclient) enddragging();
+	    else if(resizeclient) endresizing();
+	  } else if(boundingwin)
+	    endbounding(&event);
+	  else if(clickclient)
+	    gadgetunclicked(clickclient, &event);
+	  else if(dragiconlist) {
+	    endicondragging(&event);
+	  } else if(dragscreen)
+	    endscreendragging();
+	  else if((scr=mbdscr)&& clickwindow==scr->menubardepth) {
+	    if(mbdclick) {
+	      mbdclick=NULL;
+	      redrawmenubar(scr->menubardepth);
+	      screentoback();
+	    }
+	    clickwindow=None;
+	  }
+	} else if(event.xbutton.button==Button3 && (scr=menuactive)) {
+	  menu_off();
+	  menuactive=NULL;
+	}
+	break;
+      case MotionNotify:
+	do {
+	  motionx=event.xmotion.x_root;
+	  motiony=event.xmotion.y_root;
+	} while(XCheckTypedEvent(dpy, MotionNotify, &event));
+	if(dragclient) {
+	  scr=dragclient->scr;
+	  if(!prefs.opaquemove)
+	    drawrubber();
+	  rubberx=motionx-rubberx0;
+	  rubbery=motiony-rubbery0;
+	  if(!forcemoving) {
+	    if(prefs.forcemove==FM_AUTO &&
+	       (rubberx+rubberw-scr->width>(rubberw>>2) ||
+		rubbery+rubberh-scr->height>(rubberh>>2) ||
+		-rubberx>(rubberw>>2)||
+		-rubbery>(rubberh>>2)))
+	      forcemoving=1;
+	    else {
+	      if(rubberx+rubberw>scr->width)
+		rubberx=scr->width-rubberw;
+	      if(rubbery+rubberh>scr->height)
+		rubbery=scr->height-rubberh;
+	      if(rubberx<0)
+		rubberx=0;
+	      if(rubbery<0)
+		rubbery=0;
+	    }
+	  }
+	  if(prefs.opaquemove) {
+	    if(rubbery<=-(c->scr->bh))
+	      rubbery=1-(c->scr->bh);
+	    XMoveWindow(dpy, c->parent, c->x=rubberx, c->y=rubbery);
+	  } else {
+	    drawrubber();
+	  }
+	} else if(resizeclient) {
+	  int rw=rubberw, rh=rubberh;
+	  scr=resizeclient->scr;
+	  if(resizeclient->sizehints.width_inc) {
+	    rw=motionx-rubberx0-resizeclient->sizehints.base_width-
+	      resizeclient->framewidth;
+	    rw-=rw%resizeclient->sizehints.width_inc;
+	    rw+=resizeclient->sizehints.base_width;
+	    if(rw>resizeclient->sizehints.max_width)
+	      rw=resizeclient->sizehints.max_width;
+	    if(rw<resizeclient->sizehints.min_width)
+	      rw=resizeclient->sizehints.min_width;
+	    rw+=resizeclient->framewidth;
+	  }
+	  if(resizeclient->sizehints.height_inc) {
+	    rh=motiony-rubbery0-resizeclient->sizehints.base_height-
+	      resizeclient->frameheight;
+	    rh-=rh%resizeclient->sizehints.height_inc;
+	    rh+=resizeclient->sizehints.base_height;
+	    if(rh>resizeclient->sizehints.max_height)
+	      rh=resizeclient->sizehints.max_height;
+	    if(rh<resizeclient->sizehints.min_height)
+	      rh=resizeclient->sizehints.min_height;
+	    rh+=resizeclient->frameheight;
+	  }
+          if(rw!=rubberw || rh!=rubberh) {
+            if(prefs.opaqueresize) {
+              Client *c = resizeclient;
+              extern void resizeclientwindow(Client *c, int, int);
+              rubberw=rw;
+              rubberh=rh;
+              resizeclientwindow(c, rubberw, rubberh);
+            } else {
+              drawrubber();
+              rubberw=rw;
+              rubberh=rh;
+              drawrubber();
+            }
+	  }
+	} else if(dragiconlist) {
+	  int i;
+	  for(i=0; i<numdragicons; i++)
+	    XMoveWindow(dpy, dragiconlist[i].w,
+			dragiconlist[i].x+=motionx-rubberx0,
+			dragiconlist[i].y+=motiony-rubbery0);
+	  rubberx0=motionx;
+	  rubbery0=motiony;
+	} else if(dragscreen) {
+	  rubbery=motiony-rubbery0;
+	  if(rubbery<0)
+	    rubbery=0;
+	  else if(rubbery>=dragscreen->height)
+	    rubbery=dragscreen->height-1;
+	  XMoveWindow(dpy, dragscreen->back, -dragscreen->bw,
+		      (dragscreen->y=rubbery)-dragscreen->bw);
+	} else if(boundingscr) {
+	  drawrubber();
+	  rubberw=motionx-rubberx0;
+	  rubberh=motiony-rubbery0;
+	  drawrubber();
+	}
+	break;
+      case KeyPress:
+	if(!dispatch_event_to_broker(&event, KeyPressMask, modules))
+	  internal_broker(&event);
+	break;
+      case KeyRelease:
+	if(!dispatch_event_to_broker(&event, KeyPressMask, modules))
+	  internal_broker(&event);
+	break;
+      case MappingNotify:
+	if(!dispatch_event_to_broker(&event, 0, modules))
+	  internal_broker(&event);
+	break;
+      case PropertyNotify:
+	if(event.xproperty.atom != None && c &&
+	   event.xproperty.window==c->window &&
+	   XGetGeometry(dpy, c->window, &dummy_root, &dummy_x, &dummy_y,
+			&dummy_w, &dummy_h, &dummy_bw, &dummy_d))
+	  propertychange(c, event.xproperty.atom);
+	break;
+      case FocusOut:
+	/* Ignore */
+	break;
+      case FocusIn:
+	if(event.xfocus.detail == NotifyDetailNone &&
+	   prefs.focus == FOC_CLICKTOTYPE &&
+	   (scr = getscreenbyroot(event.xfocus.window))) {
+	  Window w;
+	  int rt;
+	  XGetInputFocus(dpy, &w, &rt);
+	  if(w == None)
+	    setfocus(scr->inputbox);
+	}
+	break;
+      default:
+#ifdef HAVE_XSHAPE
+	if(shape_extn && event.type == shape_event_base + ShapeNotify) {
+	  XShapeEvent *s = (XShapeEvent *) &event;
+	  if(c && s->kind == ShapeBounding) {
+	    c->shaped = s->shaped;
+	    reshape_frame(c);
+	  }
+	  break;
+	}
+#endif
+	fprintf(stderr, "%s: got unexpected event type %d.\n",
+		progname, event.type);
+      }
+    }
+    if(signalled) break;
+    rfds = master_fd_set;
+    t.tv_sec = t.tv_usec = 0;
+    if (select(max_fd, &rfds, NULL, NULL, &t) > 0) {
+      handle_module_input(&rfds);
+      if(FD_ISSET(x_fd, &rfds))
+	XPeekEvent(dpy, &event);
+      continue;
+    }
+    if(signalled) break;
+    XFlush(dpy);
+    rfds = master_fd_set;
+    if(eventlist)
+      fill_in_call_out(&t);
+    if(select(max_fd, &rfds, NULL, NULL, (eventlist? &t:NULL))<0) {
+      if (errno != EINTR) {
+	perror("select");
+	break;
+      }
+    } else {
+      call_call_out();
+      handle_module_input(&rfds);
+      if(FD_ISSET(x_fd, &rfds))
+	XPeekEvent(dpy, &event);
+    }
+  }
+
+  if(prefs.titlebarclock)
+    remove_call_out(update_clock, NULL);
+
+  if(signalled)
+    fprintf(stderr, "%s: exiting on signal\n", progname);
+
+  exit(signalled? 0:1);
+}
+
diff --git a/menu.c b/menu.c
new file mode 100644
index 0000000..99192e1
--- /dev/null
+++ b/menu.c
@@ -0,0 +1,949 @@
+#include <X11/Xlib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "alloc.h"
+#include "drawinfo.h"
+#include "prefs.h"
+#include "screen.h"
+#include "client.h"
+#include "icon.h"
+#include "version.h"
+
+#define ABOUT_STRING(LF) \
+     " " LF "version "VERSION LF "by Marcus Comstedt" LF \
+     "<marcus@lysator.liu.se>" LF " " LF \
+     "Contributions by Scott Lawrence" LF "<amiwm10@umlautllama.com>" LF \
+     "and Nicolas Sipieter " LF "<freeeaks@gmail.com>" LF " " LF
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#ifdef AMIGAOS
+#define BIN_PREFIX AMIWM_HOME
+#else
+#define BIN_PREFIX AMIWM_HOME"/"
+#endif
+
+#define CHECKIT 1
+#define CHECKED 2
+#define DISABLED 4
+
+extern Display *dpy;
+extern Cursor wm_curs;
+extern XContext screen_context, client_context;
+extern Client *activeclient;
+
+extern void select_all_icons(Scrn *i);
+extern void mod_menuselect(struct module *, int, int, int);
+extern void setfocus(Window);
+extern void flushmodules();
+
+Scrn *mbdclick=NULL, *mbdscr=NULL;
+
+static struct ToolItem {
+  struct ToolItem *next;
+  const char *name, *cmd;
+  char hotkey;
+  int level;
+  struct Menu *submenu;
+} *firsttoolitem=NULL, *lasttoolitem=NULL;
+
+static struct Item {
+  struct Item *next;
+  Window win;
+  const char *text;
+  int textlen;
+  char hotkey, flags;
+  struct Menu *menu, *sub;
+  struct module *owner;
+  struct Item *mod_chain;
+} *activeitem=NULL, *activesubitem=NULL;
+
+static struct Menu {
+  struct Menu *next;
+  struct Item *item;
+  Window win, parent;
+  const char *title;
+  int titlelen;
+  int width, height;
+  char flags;
+  struct Item *firstitem, *lastitem;
+} *activemenu=NULL, *activesubmenu=NULL;
+
+#ifdef AMIGAOS
+void spawn(const char *cmd)
+{
+  char *line=malloc(strlen(cmd)+12);
+  if(line) {
+    sprintf(line, "RUN <>NIL: %s", cmd);
+    system(line);
+    free(line);
+  }
+}
+#else
+void spawn(const char *cmd)
+{
+  extern char *x_server;
+#ifdef HAVE_ALLOCA
+  char *line=alloca(strlen(x_server)+strlen(cmd)+28);
+#else
+  char *line=malloc(strlen(x_server)+strlen(cmd)+28);
+  if(line) {
+#endif
+  char *dot;
+  sprintf(line, "DISPLAY='%s", x_server);
+  if(!(dot=strrchr(line, '.')) || strchr(dot, ':'))
+    dot=line+strlen(line);
+  sprintf(dot, ".%d' %s &", scr->number, cmd);
+#ifdef __ultrix
+  {
+    int pid, status;
+    if ((pid = fork ()) == 0) {
+      (void) setsid();
+      execl ("/bin/sh", "sh", "-c", line, 0);
+    } else
+      waitpid (pid, &status, 0);
+  }
+#else
+  system(line);
+#endif
+#ifndef HAVE_ALLOCA
+    free(line);
+  }
+#endif
+}
+#endif
+
+void add_toolitem(const char *n, const char *c, const char *k, int l)
+{
+  struct ToolItem *ti;
+  if((ti=malloc(sizeof(struct ToolItem)))) {
+    ti->name=n;
+    ti->cmd=c;
+    if(k)
+      ti->hotkey=k[0];
+    else
+      ti->hotkey=0;
+    ti->level=l;
+    ti->next=NULL;
+    if(lasttoolitem)
+      lasttoolitem->next=ti;
+    else
+      firsttoolitem=ti;
+    lasttoolitem=ti;
+  }
+}
+
+static void menu_layout(struct Menu *menu)
+{
+  XSetWindowAttributes attr;
+  XWindowAttributes attr2;
+  int w, x, y;
+  struct Item *item;
+  if(menu->win) {
+    XGetWindowAttributes(dpy, menu->win, &attr2);
+    x=attr2.x; y=scr->bh-2;
+  } else {
+    XGetWindowAttributes(dpy, menu->item->win, &attr2);
+    x=attr2.x+attr2.width-scr->hotkeyspace+9; y=attr2.y-2;
+    XGetWindowAttributes(dpy, menu->item->menu->parent, &attr2);
+    x+=attr2.x; y+=attr2.y;
+  }
+  menu->width=menu->height=0;
+  for(item=menu->firstitem; item; item=item->next) {
+    if(item->text)
+      menu->height+=scr->dri.dri_Ascent+scr->dri.dri_Descent+1;
+    else
+      menu->height+=6;
+#ifdef USE_FONTSETS
+    w=XmbTextEscapement(scr->dri.dri_FontSet, item->text, item->textlen)+2;
+#else
+    w=XTextWidth(scr->dri.dri_Font, item->text, item->textlen)+2;
+#endif
+    if(item->hotkey)
+      w+=scr->hotkeyspace;
+    if(item->flags&CHECKIT)
+      w+=scr->checkmarkspace;
+    if(item->sub)
+      w+=scr->subspace;
+    if(w>menu->width)
+      menu->width=w;
+  }
+  menu->width+=6;
+  menu->height+=2;
+  attr.override_redirect=True;
+  attr.background_pixel=scr->dri.dri_Pens[BARBLOCKPEN];
+  attr.border_pixel=scr->dri.dri_Pens[BARDETAILPEN];
+  menu->parent=XCreateWindow(dpy, scr->back, x, y,
+			     menu->width, menu->height, 1,
+			     CopyFromParent, InputOutput, CopyFromParent,
+			     CWOverrideRedirect|CWBackPixel|CWBorderPixel,
+			     &attr);
+  XSaveContext(dpy, menu->parent, screen_context, (XPointer)scr);
+  XSelectInput(dpy, menu->parent, ExposureMask);
+  w=1;
+  for(item=menu->firstitem; item; item=item->next) {
+    int h=(item->text? scr->dri.dri_Ascent+scr->dri.dri_Descent+1:6);
+    item->win=XCreateWindow(dpy, menu->parent, 3, w, menu->width-6, h, 0,
+			    CopyFromParent, InputOutput, CopyFromParent,
+			    CWOverrideRedirect|CWBackPixel, &attr);
+    XSaveContext(dpy, item->win, screen_context, (XPointer)scr);
+    w+=h;
+    XSelectInput(dpy, item->win, ExposureMask|ButtonReleaseMask|
+		 EnterWindowMask|LeaveWindowMask);
+  }
+  XMapSubwindows(dpy, menu->parent);
+}
+
+static struct Menu *add_menu(const char *name, char flags)
+{
+  struct Menu *menu=calloc(1, sizeof(struct Menu));
+  XSetWindowAttributes attr;
+  int w;
+
+  if(menu) {
+    attr.override_redirect=True;
+    attr.background_pixel=scr->dri.dri_Pens[BARBLOCKPEN];
+#ifdef USE_FONTSETS
+    w=XmbTextEscapement(scr->dri.dri_FontSet, name, menu->titlelen=strlen(name))+8;
+#else
+    w=XTextWidth(scr->dri.dri_Font, name, menu->titlelen=strlen(name))+8;
+#endif
+    menu->win=XCreateWindow(dpy, scr->menubarparent, scr->menuleft, 0, w, scr->bh-1, 0,
+			    CopyFromParent, InputOutput, CopyFromParent,
+			    CWOverrideRedirect|CWBackPixel, &attr);
+    XSaveContext(dpy, menu->win, screen_context, (XPointer)scr);
+    XMapWindow(dpy, menu->win);
+    XSelectInput(dpy, menu->win, ExposureMask|EnterWindowMask|LeaveWindowMask);
+    scr->menuleft+=w+6;
+    menu->flags=flags;
+    menu->title=name;
+    menu->item=NULL;
+    menu->firstitem=menu->lastitem=NULL;
+    menu->next=scr->firstmenu;
+    scr->firstmenu=menu;
+  }
+  return menu;
+}
+
+static struct Item *add_item(struct Menu *m, const char *name, char key,
+			     char flags)
+{
+  struct Item *item=calloc(1, sizeof(struct Item));
+
+  if(item) {
+    if(name) {
+      item->text=name;
+      item->textlen=strlen(name);
+    } else item->text=NULL;
+    item->hotkey=key;
+    item->flags=flags;
+    item->menu=m;
+    item->sub=NULL;
+    item->next=NULL;
+    if(m->lastitem)
+      m->lastitem->next=item;
+    else
+      m->firstitem=item;
+    m->lastitem=item;
+  }
+  return item;  
+}
+
+static struct Menu *sub_menu(struct Item *i, char flags)
+{
+  struct Menu *menu=calloc(1, sizeof(struct Menu));
+
+  if(menu) {
+    menu->flags=flags;
+    menu->title=NULL;
+    menu->firstitem=menu->lastitem=NULL;
+    menu->next=NULL;
+    menu->item=i;
+    i->sub=menu;
+  }
+  return menu;
+}
+
+void redraw_menu(struct Menu *m, Window w)
+{
+  int active=(m==activemenu && !(m->flags & DISABLED));
+  XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[active?BARBLOCKPEN:
+					      BARDETAILPEN]);
+  XSetBackground(dpy, scr->menubargc, scr->dri.dri_Pens[active?BARDETAILPEN:
+					      BARBLOCKPEN]);
+#ifdef USE_FONTSETS
+  XmbDrawImageString(dpy, w, scr->dri.dri_FontSet,
+		     scr->menubargc, 4, 1+scr->dri.dri_Ascent,
+		     m->title, m->titlelen);
+#else
+  XDrawImageString(dpy, w, scr->menubargc, 4, 1+scr->dri.dri_Ascent,
+		   m->title, m->titlelen);
+#endif
+}
+
+void redraw_item(struct Item *i, Window w)
+{
+  struct Menu *m=i->menu;
+  int s=scr->dri.dri_Ascent>>1;
+  if((i==activeitem || i==activesubitem) && !(i->flags&DISABLED)) {
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARBLOCKPEN]);
+    XSetBackground(dpy, scr->menubargc, scr->dri.dri_Pens[BARDETAILPEN]);
+  } else {
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARDETAILPEN]);
+    XSetBackground(dpy, scr->menubargc, scr->dri.dri_Pens[BARBLOCKPEN]);
+  }
+  if(i->text)
+#ifdef USE_FONTSETS
+    XmbDrawImageString(dpy, w, scr->dri.dri_FontSet,
+		       scr->menubargc, (i->flags&CHECKIT)?1+scr->checkmarkspace:1,
+		       scr->dri.dri_Ascent+1, i->text, i->textlen);
+#else
+    XDrawImageString(dpy, w, scr->menubargc, (i->flags&CHECKIT)?1+scr->checkmarkspace:1,
+		     scr->dri.dri_Ascent+1, i->text, i->textlen);
+#endif
+  else
+    XFillRectangle(dpy, w, scr->menubargc, 2, 2, m->width-10, 2);
+  if(i->sub) {
+    int x=m->width-6-scr->hotkeyspace-1+8;
+#ifdef USE_FONTSETS
+#ifdef HAVE_XUTF8DRAWIMAGESTRING
+    Xutf8DrawImageString(dpy, w, scr->dri.dri_FontSet,
+			 scr->menubargc, x+scr->dri.dri_Ascent+1,
+			 1+scr->dri.dri_Ascent, "\302\273", 2);
+#else
+    XmbDrawImageString(dpy, w, scr->dri.dri_FontSet,
+		       scr->menubargc, x+scr->dri.dri_Ascent+1,
+		       1+scr->dri.dri_Ascent, "»", 1);
+#endif
+#else
+    XDrawImageString(dpy, w, scr->menubargc, x+scr->dri.dri_Ascent+1,
+		     1+scr->dri.dri_Ascent, "»", 1);
+#endif
+  } else if(i->hotkey) {
+    int x=m->width-6-scr->hotkeyspace-1+8;
+    XDrawLine(dpy, w, scr->menubargc, x, 1+s, x+s, 1);
+    XDrawLine(dpy, w, scr->menubargc, x+s, 1, x+s+s, 1+s);
+    XDrawLine(dpy, w, scr->menubargc, x+s+s, 1+s, x+s, 1+s+s);
+    XDrawLine(dpy, w, scr->menubargc, x+s, 1+s+s, x, 1+s);
+#ifdef USE_FONTSETS
+    XmbDrawImageString(dpy, w, scr->dri.dri_FontSet,
+		       scr->menubargc, x+scr->dri.dri_Ascent+1,
+		       1+scr->dri.dri_Ascent, &i->hotkey, 1);
+#else
+    XDrawImageString(dpy, w, scr->menubargc, x+scr->dri.dri_Ascent+1,
+		     1+scr->dri.dri_Ascent, &i->hotkey, 1);
+#endif
+  }
+  if(i->flags&CHECKED) {
+    XDrawLine(dpy, w, scr->menubargc, 0, s, s, scr->dri.dri_Ascent);
+    XDrawLine(dpy, w, scr->menubargc, s, scr->dri.dri_Ascent, s+s, 0);
+  }
+  if(i->flags&DISABLED) {
+    XSetStipple(dpy, scr->menubargc, scr->disabled_stipple);
+    XSetFillStyle(dpy, scr->menubargc, FillStippled);
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARBLOCKPEN]);
+    XFillRectangle(dpy, w, scr->menubargc, 0, 0,
+		   m->width-6, scr->dri.dri_Ascent+scr->dri.dri_Descent+1);
+    XSetFillStyle(dpy, scr->menubargc, FillSolid);
+  }
+}
+
+void createmenubar()
+{
+  XSetWindowAttributes attr;
+  struct Menu *m, *sm1, *sm2, *sm3;
+  struct ToolItem *ti;
+  GC gc;
+
+  scr->firstmenu = NULL;
+  attr.override_redirect=True;
+  attr.background_pixel=scr->dri.dri_Pens[BARBLOCKPEN];
+  scr->menubar=XCreateWindow(dpy, scr->back, 0, 0, scr->width, scr->bh, 0,
+			     CopyFromParent,
+			     InputOutput, CopyFromParent,
+			     CWOverrideRedirect|CWBackPixel,
+			     &attr);
+  XSaveContext(dpy, scr->menubar, screen_context, (XPointer)scr);
+  scr->menubarparent=XCreateWindow(dpy, scr->menubar, 0, 0, scr->width,
+				   scr->bh-1, 0,
+				   CopyFromParent, InputOutput, CopyFromParent,
+				   CWOverrideRedirect|CWBackPixel, &attr);
+  XSaveContext(dpy, scr->menubarparent, screen_context, (XPointer)scr);
+  attr.background_pixel=scr->dri.dri_Pens[BACKGROUNDPEN];
+  scr->menubardepth=XCreateWindow(dpy, scr->menubar, scr->width-23,
+				  0, 23, scr->bh, 0,
+				  CopyFromParent, InputOutput, CopyFromParent,
+				  CWOverrideRedirect|CWBackPixel, &attr);
+  XSaveContext(dpy, scr->menubardepth, screen_context, (XPointer)scr);
+  scr->disabled_stipple=XCreatePixmap(dpy, scr->back, 6, 2, 1);
+  gc=XCreateGC(dpy, scr->disabled_stipple, 0, NULL);
+  XSetForeground(dpy, gc, 0);
+  XFillRectangle(dpy, scr->disabled_stipple, gc, 0, 0, 6, 2);
+  XSetForeground(dpy, gc, 1);
+  XDrawPoint(dpy, scr->disabled_stipple, gc, 0, 0);
+  XDrawPoint(dpy, scr->disabled_stipple, gc, 3, 1);
+  XFreeGC(dpy, gc);
+  scr->menubargc=XCreateGC(dpy, scr->menubar, 0, NULL); 
+#ifndef USE_FONTSETS
+  XSetFont(dpy, scr->menubargc, scr->dri.dri_Font->fid);
+#endif
+  XSetBackground(dpy, scr->menubargc, scr->dri.dri_Pens[BARBLOCKPEN]);
+  XSelectInput(dpy, scr->menubar, ExposureMask|ButtonPressMask|ButtonReleaseMask);
+  XSelectInput(dpy, scr->menubardepth, ExposureMask|ButtonPressMask|
+	       ButtonReleaseMask|EnterWindowMask|LeaveWindowMask);
+  XMapWindow(dpy, scr->menubardepth);
+  XMapWindow(dpy, scr->menubar);
+  scr->hotkeyspace=8+1+scr->dri.dri_MaxBoundsWidth+
+    scr->dri.dri_Ascent;
+  scr->checkmarkspace=4+scr->dri.dri_Ascent;
+  scr->subspace=scr->hotkeyspace-scr->dri.dri_Ascent;
+  scr->menuleft=4;
+  m=add_menu("Workbench", 0);
+  add_item(m,"Backdrop",'B',CHECKIT|CHECKED|DISABLED);
+  add_item(m,"Execute Command...",'E',0);
+  add_item(m,"Redraw All",0,0);
+  add_item(m,"Update All",0,DISABLED);
+  add_item(m,"Last Message",0,DISABLED);
+  add_item(m,"About...",'?',0);
+  add_item(m,"Quit...",'Q',0);
+  menu_layout(m);
+  m=add_menu("Window", 0);
+  add_item(m,"New Drawer",'N',DISABLED);
+  add_item(m,"Open Parent",0,DISABLED);
+  add_item(m,"Close",'K',DISABLED);
+  add_item(m,"Update",0,DISABLED);
+  add_item(m,"Select Contents",'A',0);
+  add_item(m,"Clean Up",'.',0);
+  sm1=sub_menu(add_item(m,"Snapshot",0,DISABLED),0);
+  add_item(sm1, "Window",0,DISABLED);
+  add_item(sm1, "All",0,DISABLED);
+  sm2=sub_menu(add_item(m,"Show",0,DISABLED),0);
+  add_item(sm2, "Only Icons",0,CHECKIT|CHECKED|DISABLED);
+  add_item(sm2, "All Files",'V',CHECKIT|DISABLED);
+  sm3=sub_menu(add_item(m,"View By",0,DISABLED),0);
+  add_item(sm3, "Icon",0,CHECKIT|CHECKED|DISABLED);
+  add_item(sm3, "Name",0,CHECKIT|DISABLED);
+  add_item(sm3, "Date",0,CHECKIT|DISABLED);
+  add_item(sm3, "Size",0,CHECKIT|DISABLED);
+  menu_layout(m);
+  menu_layout(sm1);
+  menu_layout(sm2);
+  menu_layout(sm3);
+  m=add_menu("Icons", DISABLED);
+  add_item(m,"Open",'O',DISABLED);
+  add_item(m,"Copy",'C',DISABLED);
+  add_item(m,"Rename...",'R',DISABLED);
+  add_item(m,"Information...",'I',DISABLED);
+  add_item(m,"Snapshot",'S',DISABLED);
+  add_item(m,"UnSnapshot",'U',DISABLED);
+  add_item(m,"Leave Out",'L',DISABLED);
+  add_item(m,"Put Away",'P',DISABLED);
+  add_item(m,NULL,0,DISABLED);
+  add_item(m,"Delete...",'D',DISABLED);
+  add_item(m,"Format Disk...",0,DISABLED);
+  add_item(m,"Empty Trash",0,DISABLED);
+  menu_layout(m);
+  m=add_menu("Tools", 0);
+#ifdef AMIGAOS
+  add_item(m,"ResetWB",0,DISABLED);
+#else
+  add_item(m,"ResetWB",0,0);
+#endif
+
+  for(ti=firsttoolitem; ti; ti=ti->next)
+    if(ti->level<0)
+      ti->submenu=sm1=sub_menu(add_item(m,ti->name,ti->hotkey,0),0);
+    else {
+      ti->submenu=NULL;
+      add_item((ti->level? sm1:m), ti->name,ti->hotkey,(ti->cmd? 0:DISABLED));
+    }
+  menu_layout(m);
+  for(ti=firsttoolitem; ti; ti=ti->next)
+    if(ti->submenu) {
+      menu_layout(ti->submenu);
+      ti->submenu=NULL;
+    }
+  if(prefs.screenmenu) {
+    m=add_menu("Screens",0);
+    add_item(m,"New Screen",0,0);
+    add_item(m,"Delete Screen",0,0);
+    menu_layout(m);
+  }
+}
+
+void redrawmenubar(Window w)
+{
+  static const char defaultTimeFormat[] = "%c";
+
+  struct Menu *m;
+  struct Item *item;
+
+  if(!w)
+    return;
+  if(w==scr->menubar) {
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARDETAILPEN]);
+    XSetBackground(dpy, scr->menubargc, scr->dri.dri_Pens[BARBLOCKPEN]);
+#ifdef USE_FONTSETS
+    XmbDrawImageString(dpy, w, scr->dri.dri_FontSet,
+		       scr->menubargc, 4, 1+scr->dri.dri_Ascent,
+		       scr->title, strlen(scr->title));
+#else
+    XDrawImageString(dpy, w, scr->menubargc, 4, 1+scr->dri.dri_Ascent,
+		     scr->title, strlen(scr->title));
+#endif
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARTRIMPEN]);  
+    XDrawLine(dpy, w, scr->menubargc, 0, scr->bh-1, scr->width-1, scr->bh-1);
+    if( prefs.titlebarclock )
+    {
+      char clockbuf[512];
+      const char * fmt = defaultTimeFormat;
+      time_t the_time;
+      int l;
+      if( prefs.titleclockformat ) fmt = prefs.titleclockformat;
+      time( &the_time );
+      strftime( clockbuf, 512, fmt, localtime( &the_time ) );
+#ifdef USE_FONTSETS
+      l = XmbTextEscapement(scr->dri.dri_FontSet, clockbuf, strlen(clockbuf));
+      XmbDrawImageString(dpy, w, scr->dri.dri_FontSet, scr->menubargc,
+			 (scr->width-30-l), 1+scr->dri.dri_Ascent,
+			 clockbuf, strlen(clockbuf));
+#else
+      l = XTextWidth(scr->dri.dri_Font, clockbuf, strlen(clockbuf));
+      XDrawImageString( dpy, w, scr->menubargc,(scr->width-30-l),
+			1+scr->dri.dri_Ascent, clockbuf, strlen(clockbuf));
+#endif
+    }    
+  } else if(w==scr->menubardepth) {
+    if(!mbdclick) {
+      XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[SHADOWPEN]);
+      XDrawRectangle(dpy, w, scr->menubargc, 4, scr->h2, 10, scr->h6-scr->h2);
+    }
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[SHINEPEN]);
+    XFillRectangle(dpy, w, scr->menubargc, 8, scr->h4, 10, scr->h8-scr->h4);
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[SHADOWPEN]);
+    XDrawRectangle(dpy, w, scr->menubargc, 8, scr->h4, 10, scr->h8-scr->h4);
+    if(mbdclick)
+      XDrawRectangle(dpy, w, scr->menubargc, 4, scr->h2, 10, scr->h6-scr->h2);
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[mbdclick?SHADOWPEN:SHINEPEN]);
+    XDrawLine(dpy, w, scr->menubargc, 0, 0, 22, 0);
+    XDrawLine(dpy, w, scr->menubargc, 0, 0, 0, scr->bh-2);
+    XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[mbdclick?SHINEPEN:SHADOWPEN]);
+    XDrawLine(dpy, w, scr->menubargc, 0, scr->bh-1, 22, scr->bh-1);
+    XDrawLine(dpy, w, scr->menubargc, 22, 0, 22, scr->bh-1);
+  } else {
+    for(m=scr->firstmenu; m; m=m->next)
+      if(m->win==w)
+	redraw_menu(m, w);
+    if(activemenu) {
+      for(item=activemenu->firstitem; item; item=item->next)
+	if(item->win==w)
+	  redraw_item(item, w);
+      if(w==activemenu->parent) {
+	XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARDETAILPEN]);
+	XDrawLine(dpy, w, scr->menubargc, 0, 0, 0, activemenu->height-1);
+	XDrawLine(dpy, w, scr->menubargc, activemenu->width-1, 0,
+		  activemenu->width-1, activemenu->height-1);
+      }
+    }
+    if(activesubmenu) {
+      for(item=activesubmenu->firstitem; item; item=item->next)
+	if(item->win==w)
+	  redraw_item(item, w);
+      if(w==activesubmenu->parent) {
+	XSetForeground(dpy, scr->menubargc, scr->dri.dri_Pens[BARDETAILPEN]);
+	XDrawLine(dpy, w, scr->menubargc, 0, 0, 0, activesubmenu->height-1);
+	XDrawLine(dpy, w, scr->menubargc, activesubmenu->width-1, 0,
+		  activesubmenu->width-1, activesubmenu->height-1);
+      }      
+    }
+  }
+}
+
+static void leave_item(struct Item *i, Window w)
+{
+  if(i==activesubitem)
+    activesubitem=NULL;
+  if(i==activeitem)
+    if(activesubmenu && i->sub==activesubmenu)
+      return;
+    else
+      activeitem=NULL;
+  XSetWindowBackground(dpy, i->win, scr->dri.dri_Pens[BARBLOCKPEN]);
+  XClearWindow(dpy, i->win);
+  redraw_item(i, i->win);    
+}
+
+static void enter_item(struct Item *i, Window w)
+{
+  if(activesubitem)
+    leave_item(activesubitem, activesubitem->win);
+  if(activesubmenu!=i->sub && i->menu!=activesubmenu) {
+    if(activesubmenu)
+      XUnmapWindow(dpy, activesubmenu->parent);
+    if(i->sub)
+      XMapRaised(dpy, i->sub->parent);
+    activesubmenu=i->sub;
+  }
+  if(activeitem && !(activeitem->sub && i->menu==activeitem->sub))
+    leave_item(activeitem, activeitem->win);
+  if(!(i->flags&DISABLED)) {
+    if(activeitem)
+      activesubitem=i;
+    else
+      activeitem=i;
+    XSetWindowBackground(dpy, i->win, scr->dri.dri_Pens[BARDETAILPEN]);
+    XClearWindow(dpy, i->win);
+    redraw_item(i, i->win);    
+  }
+}
+
+static void enter_menu(struct Menu *m, Window w)
+{
+  if(m!=activemenu) {
+    struct Menu *oa=activemenu;
+    if(activesubitem)
+      leave_item(activeitem, activesubitem->win);
+    if(activesubmenu) {
+      XUnmapWindow(dpy, activesubmenu->parent);
+      activesubmenu=NULL;
+    }
+    if(activeitem)
+      leave_item(activeitem, activeitem->win);
+    if(!(m->flags & DISABLED))
+      XSetWindowBackground(dpy, w, scr->dri.dri_Pens[BARDETAILPEN]);
+    XClearWindow(dpy, w);
+    redraw_menu(activemenu=m, w);
+    if(m->parent)
+      XMapRaised(dpy, m->parent);
+    if(oa) {
+      if(oa->parent)
+	XUnmapWindow(dpy, oa->parent);
+      XSetWindowBackground(dpy, oa->win, scr->dri.dri_Pens[BARBLOCKPEN]);
+      XClearWindow(dpy, oa->win);
+      redraw_menu(oa, oa->win);
+    }
+  }
+}
+
+void menubar_enter(Window w)
+{
+  struct Menu *m;
+  struct Item *i;
+
+  for(m=scr->firstmenu; m; m=m->next)
+    if(m->win==w) {
+      enter_menu(m, w);
+      return;
+    }
+  if((m=activemenu))
+    for(i=m->firstitem; i; i=i->next)
+      if(w==i->win) {
+	enter_item(i, w);
+	return;
+      }
+  if((m=activesubmenu))
+    for(i=m->firstitem; i; i=i->next)
+      if(w==i->win) {
+	enter_item(i, w);
+	return;
+      }
+}
+
+void menubar_leave(Window w)
+{
+  if(activesubitem && activesubitem->win==w)
+    leave_item(activesubitem, w);
+  if(activeitem && activeitem->win==w)
+    leave_item(activeitem, w);
+}
+
+void menu_on()
+{
+  Window r, c;
+  int rx, ry, x, y;
+  unsigned int m;
+
+  if(scr->menubarparent) {
+    XMapRaised(dpy, scr->menubarparent);
+    XRaiseWindow(dpy, scr->menubar);
+    XGrabPointer(dpy, scr->back, True, ButtonPressMask|ButtonReleaseMask|
+		EnterWindowMask|LeaveWindowMask, GrabModeAsync, GrabModeAsync,
+		scr->back, wm_curs, CurrentTime);
+    XSetInputFocus(dpy, scr->menubar, RevertToParent, CurrentTime);
+    if(XQueryPointer(dpy, scr->menubarparent, &r, &c, &rx, &ry, &x, &y, &m))
+      menubar_enter(c);
+  }
+}
+
+void menuaction(struct Item *i, struct Item *si)
+{
+  extern void restart_amiwm(void);
+  extern int screen_has_clients(void);
+  struct Menu *m;
+  struct Item *mi;
+  struct ToolItem *ti;
+  int menu=0, item=0, sub=0;
+
+  for(m=i->menu->next; m; m=m->next) menu++;
+  for(mi=i->menu->firstitem; mi&&mi!=i; mi=mi->next) item++;
+  if(i->sub) {
+    for(mi=i->sub->firstitem; mi&&mi!=si; mi=mi->next) sub++;
+    if(!mi)
+      sub=-1;
+  } else
+    --sub;
+  mi=(sub>=0? si:i);
+  if(mi->flags & DISABLED)
+    return;
+  if(mi->owner) {
+    mod_menuselect(mi->owner, menu, item, sub);
+    return;
+  }
+  switch(menu) {
+  case 0: /* Workbench */
+    switch(item) {
+    case 1:
+      spawn(BIN_PREFIX"executecmd");
+      break;
+    case 2:
+      {
+	XSetWindowAttributes xswa;
+	unsigned long mask;
+	Window win;
+	xswa.background_pixmap = None;
+	xswa.override_redirect = True;
+	xswa.backing_store = NotUseful;
+	xswa.save_under = False;
+	mask = CWBackPixmap|CWOverrideRedirect|CWBackingStore|CWSaveUnder;
+	win = XCreateWindow(dpy, scr->back, 0, 0, scr->width, scr->height,
+			    0, scr->depth, InputOutput,
+			    scr->visual, mask, &xswa);
+	XMapWindow(dpy, win);
+	XDestroyWindow(dpy, win);
+      }
+      break;
+    case 5:
+#ifdef AMIGAOS
+      spawn(BIN_PREFIX"requestchoice >NIL: amiwm \""
+	    ABOUT_STRING("*N") "\" Ok");
+#else
+      spawn(BIN_PREFIX"requestchoice >/dev/null amiwm '"
+	    ABOUT_STRING("\n") "' Ok");
+#endif
+      break;      
+    case 6:
+#ifndef AMIGAOS
+      if(prefs.fastquit) {
+#endif
+	exit(0);
+#ifndef AMIGAOS
+      } else {
+#ifdef HAVE_ALLOCA
+	char *buf=alloca(256);
+#else
+	char buf[256];
+#endif
+	sprintf(buf, "; export DISPLAY; ( if [ `"BIN_PREFIX"requestchoice "
+		"Workbench 'Do you really want\nto quit workbench?' Ok Cancel`"
+		" = 1 ]; then kill %d; fi; )", (int)getpid());
+	spawn(buf);
+      }
+#endif
+      break;
+    }
+    break;
+  case 1: /* Window */
+    switch(item) {
+    case 4:
+      select_all_icons(scr);
+      break;
+    case 5:
+      cleanupicons();
+      break;
+    }
+    break;
+  case 2: /* Icons */
+    break;
+  case 3: /* Tools */
+#ifndef AMIGAOS
+    if(item==0)
+      restart_amiwm();
+#endif
+    if(item>0) {
+      int it=0, si=-1;
+      for(ti=firsttoolitem; ti; ti=ti->next) {
+	if(ti->level>0)
+	  si++;
+	else {
+	  it++;
+	  si=-1;
+	}
+	if(it==item && si==sub) break;
+      }
+      if(ti && ti->cmd) spawn(ti->cmd);
+    }
+    break;
+  case 4: /* Screens */
+    if(item==0) {
+      openscreen("New Screen", DefaultRootWindow(dpy));
+      realizescreens();
+      scr=front->upfront;
+      screentoback();
+    }
+    if(item==1) {
+      if(scr->behind == scr)
+	wberror(scr,"Cannot close last Screen");
+      else if(screen_has_clients())
+	wberror(scr,"Can't close a screen with running programs on it");
+      else
+	closescreen();
+    }
+    break;
+  }
+}
+
+void menu_off()
+{
+  struct Menu *oa;
+  struct Item *oi, *osi;
+
+  if(scr->menubarparent) {
+    Window r,p,*children;
+    unsigned int nchildren;
+    XUngrabPointer(dpy, CurrentTime);
+    setfocus((activeclient && activeclient->state==NormalState?
+	      activeclient->window:None));
+    XUnmapWindow(dpy, scr->menubarparent);
+    if(XQueryTree(dpy, scr->back, &r, &p, &children, &nchildren)) {
+      int n;
+      Client *c2;
+      for(n=0; n<nchildren; n++)
+	if((!XFindContext(dpy, children[n], client_context, (XPointer*)&c2)) &&
+	   children[n]==c2->parent)
+	  break;
+      if(n<nchildren) {
+	Window ws[2];
+	ws[0]=children[n];
+	ws[1]=scr->menubar;
+	XRestackWindows(dpy, ws, 2);
+      }
+      if(children) XFree(children);
+    }
+  }
+  if((osi=activesubitem))
+    leave_item(osi, osi->win);
+  if((oi=activeitem))
+    leave_item(oi, oi->win);
+  if((oa=activesubmenu)) {
+    activesubmenu=NULL;
+    if(oa->parent)
+      XUnmapWindow(dpy, oa->parent);
+  }
+  if((oa=activemenu)) {
+    activemenu=NULL;
+    if(oa->parent)
+      XUnmapWindow(dpy, oa->parent);
+    XSetWindowBackground(dpy, oa->win, scr->dri.dri_Pens[BARBLOCKPEN]);
+    XClearWindow(dpy, oa->win);
+    redraw_menu(oa, oa->win);
+  }
+  if(oi) {
+    XSync(dpy, False);
+    menuaction(oi, osi);
+  }
+}
+
+struct Item *getitembyhotkey(KeySym key)
+{
+  struct Menu *m;
+  struct Item *i;
+
+  if(key) {
+    if(key>='a' && key<='z')
+      key-=0x20;
+    for(m=scr->firstmenu; m; m=m->next)
+      for(i=m->firstitem; i; i=i->next)
+	if(i->hotkey==key)
+	  return i;
+  }
+  return NULL;
+}
+
+static struct Item *own_item(struct module *m, struct Item *i, struct Item *c)
+{
+  if(i->owner)
+    return NULL;
+  i->owner = m;
+  i->mod_chain = c;
+  i->flags &= ~DISABLED;
+  redraw_item(i, i->win);
+  return i;
+}
+
+void disown_item_chain(struct module *m, struct Item *i)
+{
+  while(i)
+    if(i->owner == m) {
+      struct Item *c = i->mod_chain;
+      i->owner = NULL;
+      i->mod_chain = NULL;
+      i->flags |= DISABLED;
+      redraw_item(i, i->win);
+      i = c;
+    } else
+      i=i->mod_chain;
+}
+
+struct Item *own_items(struct module *m, Scrn *s,
+		       int menu, int item, int sub, struct Item *c)
+{
+  struct Item *cl, *chain = NULL, *endlink = NULL;
+  int m0, m1, mn;
+  struct Menu *mm;
+  if(!s) return NULL;
+  if(menu<0) {
+    m0 = 0; m1 = 65535;
+  } else m0 = m1 = menu;
+  for(mn=0, mm=s->firstmenu; mm && mn <= m1; mm=mm->next, mn++)
+    if(mn>=m0) {
+      int i0, i1, in;
+      struct Item *ii;
+      if(item<0) {
+	i0 = 0; i1 = 65535;
+      } else i0 = i1 = item;
+      for(in=0, ii=mm->firstitem; ii && in <= i1; ii=ii->next, in++)
+	if(in>=i0) {
+	  int s0, s1, sn;
+	  struct Item *ss;
+	  if(!(cl=own_item(m, ii, chain))) {
+	    disown_item_chain(m, chain);
+	    return NULL;
+	  } else chain=cl;
+	  if(!endlink) endlink=chain;
+	  if(ii->sub) {
+	    if(sub<0) {
+	      s0 = 0; s1 = 65535;
+	    } else s0 = s1 = sub;
+	    for(sn=0, ss=ii->sub->firstitem; ss && sn <= i1; ss=ss->next, sn++)
+	      if(sn>=s0) {
+		if(!(cl=own_item(m, ss, chain))) {
+		  disown_item_chain(m, chain);
+		  return NULL;
+		} else chain=cl;
+	      }
+	  }
+	}
+    }
+  if(endlink)
+    endlink->next = c;
+  return chain;
+}
diff --git a/module.c b/module.c
new file mode 100644
index 0000000..d3e5f60
--- /dev/null
+++ b/module.c
@@ -0,0 +1,573 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+#include <X11/Xlib.h>
+
+#include "alloc.h"
+#include "drawinfo.h"
+#include "screen.h"
+#include "prefs.h"
+#include "module.h"
+#include "client.h"
+#include "icon.h"
+#include "version.h"
+
+extern XContext client_context, icon_context, screen_context;
+
+extern FILE *rcfile;
+extern Display *dpy;
+
+extern void add_fd_to_set(int);
+extern void remove_fd_from_set(int);
+
+extern void screentoback();
+extern void raiselowerclient(Client *, int);
+extern void wberror(Scrn *, char *);
+
+extern Icon *createappicon(struct module *, Window, char *,
+			   Pixmap, Pixmap, Pixmap, int, int);
+
+extern struct Item *own_items(struct module *, Scrn *,
+			       int, int, int, struct Item *);
+extern void disown_item_chain(struct module *, struct Item *);
+
+struct module *modules = NULL;
+
+struct mcmd_keygrab *keygrabs = NULL;
+
+static struct mcmd_keygrab *find_keygrab(int keycode, unsigned int modifiers)
+{
+  struct mcmd_keygrab *kg=keygrabs;
+
+  while(kg)
+    if(kg->keycode == keycode && kg->modifiers == modifiers)
+      return kg;
+    else kg=kg->next;
+  return NULL;
+}
+
+int create_keygrab(struct module *m, int keycode, unsigned int modifiers)
+{
+  static int id=1;
+  struct mcmd_keygrab *kg=malloc(sizeof(struct mcmd_keygrab));
+  Client *c;
+
+  if(kg) {
+    kg->next = keygrabs;
+    kg->id=id++;
+    kg->owner=m;
+    kg->keycode=keycode;
+    kg->modifiers=modifiers;
+    keygrabs=kg;
+    for(c=clients; c; c=c->next)
+      if(c->parent && c->parent!=c->scr->root)
+	XGrabKey(dpy, keycode, modifiers, c->window, False,
+		 GrabModeAsync, GrabModeAsync);
+    return kg->id;
+  } else return -1;
+}
+
+void delete_keygrab(struct module *m, int id)
+{
+  struct mcmd_keygrab *kg=keygrabs, *last=NULL;
+  Client *c;
+
+  while(kg) {
+    if(kg->owner==m && (id<0 || kg->id==id)) {
+      if(last)
+	last->next=kg->next;
+      else
+	keygrabs=kg->next;
+      if(!find_keygrab(kg->keycode, kg->modifiers))
+	for(c=clients; c; c=c->next)
+	  if(c->parent && c->parent!=c->scr->root)
+	    XUngrabKey(dpy, kg->keycode, kg->modifiers, c->window);
+    } else last=kg;
+    kg=kg->next;
+  }
+}
+
+static void destroy_module(struct module *m)
+{
+  Scrn *s=front;
+  delete_keygrab(m, -1);
+  do {
+    Icon *i, *ni;
+    for(i=scr->icons; i; i=ni) {
+      ni=i->next;
+      if(i->module==m)
+	rmicon(i);
+    }
+    s=s->behind;
+  } while(s!=front);
+  disown_item_chain(m, m->menuitems);
+  if(m->in_fd>=0) { remove_fd_from_set(m->in_fd); close(m->in_fd); }
+  if(m->out_fd>=0) { close(m->out_fd); }
+  free(m);
+}
+
+static void sieve_modules()
+{
+  struct module *m, **p;
+  for(p=&modules; (m=*p); )
+    if(!m->pid) {
+      *p=m->next;
+      destroy_module(m);
+    } else p=&(m->next);
+}
+
+void reap_children(int sig)
+{
+  pid_t pid;
+  int stat;
+#ifdef HAVE_WAITPID
+  while((pid=waitpid(-1, &stat, WNOHANG))>0)
+#else
+#ifdef HAVE_WAIT3
+  while((pid=wait3(&stat, WNOHANG, NULL))>0)
+#else
+  if((pid=wait(&stat))>0)
+#endif
+#endif
+#ifdef WIFSTOPPED
+    if(!WIFSTOPPED(stat)) {
+#else
+    {
+#endif
+      struct module *m;
+      for(m=modules; m; m=m->next)
+	if(m->pid==pid) {
+	  m->pid=0;
+	  break;
+	}
+    }
+  if(pid<0 && errno!=ECHILD && errno!=EINTR)
+    perror("wait");
+  if(sig>0)
+    signal(sig, reap_children);
+}
+
+void init_modules()
+{
+  modules = NULL;
+#ifdef SIGCHLD
+  signal(SIGCHLD, reap_children);
+#else
+#ifdef SIGCLD
+  signal(SIGCLD, reap_children);
+#endif
+#endif
+}
+
+void create_module(Scrn *screen, char *module_name, char *module_arg)
+{
+  pid_t pid;
+  int fds1[2], fds2[2];
+  char fd1num[16], fd2num[16], scrnum[16], destpath[1024], *pathelt=NULL;
+  struct module *m;
+  char *temppath;
+
+#ifdef HAVE_WAITPID
+  reap_children(0);
+#else
+#ifdef HAVE_WAIT3
+  reap_children(0);
+#endif
+#endif
+  sieve_modules();
+#ifdef HAVE_ALLOCA
+  temppath = alloca(strlen(prefs.module_path)+2);
+  {
+#else
+  if((temppath = malloc(strlen(prefs.module_path)+2))) {
+#endif
+    strcpy(temppath, prefs.module_path);
+    for(pathelt=strtok(temppath, ":"); pathelt;
+	pathelt=strtok(NULL, ":")) {
+      sprintf(destpath, "%s/%s", pathelt, module_name);
+      if(access(destpath, X_OK)>=0)
+	break;
+    }
+#ifndef HAVE_ALLOCA
+    free(temppath);
+#endif
+  }
+  if(!pathelt) {
+    fprintf(stderr, "%s: no such module\n", module_name);
+    return;
+  }
+
+  if(pipe(fds1)>=0) {
+    if(pipe(fds2)>=0) {
+      if((pid=fork())) {
+	close(fds1[0]);
+	close(fds2[1]);
+	if(pid<0)
+	  perror("fork");
+	else {
+	  m=calloc(sizeof(struct module),1);
+	  m->pid=pid;
+	  m->in_fd=fds2[0];
+	  m->out_fd=fds1[1];
+	  m->in_buf=malloc(m->in_buf_size=64);
+	  m->in_phase=0;
+	  m->in_ptr=(char *)&m->mcmd;
+	  m->in_left=sizeof(m->mcmd);
+	  m->next=modules;
+	  modules=m;
+	  add_fd_to_set(m->in_fd);
+	}
+      } else {
+	if(rcfile)
+	  close(fileno(rcfile));
+	for(m=modules; m; m=m->next) {
+	  if(m->in_fd>=0) close(m->in_fd);
+	  if(m->out_fd>=0) close(m->out_fd);
+	}
+	close(fds1[1]);
+	close(fds2[0]);
+	sprintf(fd1num, "%d", fds1[0]);
+	sprintf(fd2num, "%d", fds2[1]);
+	sprintf(scrnum, "0x%08lx", (screen? (screen->back):None));
+	execl(destpath, module_name, fd1num, fd2num, scrnum, module_arg, NULL);
+	perror(destpath);
+	_exit(1);
+      }
+    } else {
+      perror("pipe");
+      close(fds1[0]);
+      close(fds1[1]);
+    }
+  } else perror("pipe");
+}
+
+static int m_write(int fd, char *ptr, int len)
+{
+  char *p=ptr;
+  int r, tot=0;
+  while(len>0) {
+    if((r=write(fd, p, len))<0)
+      if(errno==EINTR)
+	continue;
+      else
+	return r;
+    if(!r)
+      return tot;
+    tot+=r;
+    p+=r;
+    len-=r;
+  }
+  return tot;  
+}
+
+static void reply_module(struct module *m, char *data, int len)
+{
+  m_write(m->out_fd, (char *)&len, sizeof(len));
+  if(len<0) len=~len;
+  if(len>0)
+    m_write(m->out_fd, data, len);
+}
+
+int dispatch_event_to_broker(XEvent *e, unsigned long mask, struct module *m)
+{
+  Client *c;
+  Icon *i;
+  e->xany.display=(Display *)0;
+  if(!XFindContext(dpy, e->xany.window, client_context, (XPointer *)&c))
+    if(e->xany.window==c->window)
+      e->xany.display=(Display *)1;
+    else
+      e->xany.display=(Display *)2;
+  else if(!XFindContext(dpy, e->xany.window, icon_context, (XPointer *)&i))
+    if(e->xany.window==i->window)
+      e->xany.display=(Display *)3;
+
+  while(m) {
+    if(m->out_fd>=0 && ((m->broker.mask & mask)||(m->broker.exists && !mask))) {
+      struct mcmd_event me;
+      me.mask=mask;
+      me.event=*e;
+      reply_module(m, (char *)&me, ~sizeof(me));
+      return 1;
+    }
+    m=m->next;
+  }
+  return 0;
+}
+
+static void incoming_event(struct module *m, struct mcmd_event *me)
+{
+  extern void internal_broker(XEvent *);
+
+  if(!dispatch_event_to_broker(&me->event, me->mask, m->next))
+    internal_broker(&me->event);
+}
+
+void mod_menuselect(struct module *m, int menu, int item, int subitem)
+{
+  fprintf(stderr, "Nu valde någon minsann menyitem %d:%d:%d.\n"
+	  "Man kanske skulle berätta detta för modul %d\n?",
+	  menu, item, subitem, (int)m->pid);
+}
+
+static void handle_module_cmd(struct module *m, char *data, int data_len)
+{
+  extern Scrn *getscreen(Window);
+  extern int iconcolormask;
+  XID id=m->mcmd.id;
+  Client *c;
+
+  switch(m->mcmd.cmd) {
+  case MCMD_NOP:
+    reply_module(m, NULL, 0);
+    break;
+  case MCMD_GET_VERSION:
+    reply_module(m, "amiwm "VERSION, sizeof("amiwm "VERSION));
+    break;
+  case MCMD_SEND_EVENT:
+    if(data_len>=sizeof(struct mcmd_event)) {
+      incoming_event(m, (struct mcmd_event *)data);
+      reply_module(m, NULL, 0);
+    } else 
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_SET_BROKER:
+    if(data_len>=sizeof(m->broker.mask)) {
+      m->broker.mask=*(unsigned long *)data;
+      m->broker.exists=1;
+      reply_module(m, NULL, 0);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_ROTATE_SCREEN:
+    scr=getscreen(id);
+    screentoback();
+    reply_module(m, NULL, 0);
+    break;
+  case MCMD_ADD_KEYGRAB:
+    if(data_len>=sizeof(int[2])) {
+      int res=create_keygrab(m, ((int*)data)[0], ((int*)data)[1]);
+      reply_module(m, (char *)&res, sizeof(res));
+    } else reply_module(m, NULL, -1);
+    break;
+  case MCMD_DEL_KEYGRAB:
+    if(data_len>=sizeof(int)) {
+      delete_keygrab(m, ((int*)data)[0]);
+      reply_module(m, NULL, 0);
+    } else reply_module(m, NULL, -1);
+    break;
+  case MCMD_FRONT:
+    if(!XFindContext(dpy, id, client_context, (XPointer*)&c)) {
+      raiselowerclient(c, PlaceOnTop);
+      reply_module(m, NULL, 0);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_BACK:
+    if(!XFindContext(dpy, id, client_context, (XPointer*)&c)) {
+      raiselowerclient(c, PlaceOnBottom);
+      reply_module(m, NULL, 0);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_ICONIFY:
+    if(!XFindContext(dpy, id, client_context, (XPointer*)&c)) {
+      if(!(c->icon))
+	createicon(c);
+      XUnmapWindow(dpy, c->parent);
+      /* XUnmapWindow(dpy, c->window); */
+      adjusticon(c->icon);
+      XMapWindow(dpy, c->icon->window);
+      if(c->icon->labelwidth)
+	XMapWindow(dpy, c->icon->labelwin);
+      c->icon->mapped=1;
+      setclientstate(c, IconicState);
+      reply_module(m, NULL, 0);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_CREATEAPPICON:
+    if(data_len>=sizeof(struct NewAppIcon)) {
+      struct NewAppIcon *nai=(struct NewAppIcon *)data;
+      Window w=None;
+      Icon *i=createappicon(m, id, nai->name,
+			    nai->pm1, nai->pm2, nai->pmm, nai->x, nai->y);
+      if(i!=NULL) w=i->window;
+      reply_module(m, (char *)&w, sizeof(w));
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_ERRORMSG:
+    if(data_len>0) {
+      extern char *free_screentitle;
+      if(free_screentitle) free(free_screentitle);
+      free_screentitle=malloc(data_len+1);
+      if(free_screentitle==NULL)
+	reply_module(m, NULL, -1);
+      else {
+	scr=getscreen(id);
+	memcpy(free_screentitle, data, data_len);
+	free_screentitle[data_len]='\0';
+	wberror(scr, free_screentitle);
+	reply_module(m, NULL, 0);
+      }
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_SETAPPWINDOW:
+    if(!XFindContext(dpy, id, client_context, (XPointer*)&c)) {
+      c->module=m;
+      reply_module(m, NULL, 0);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  case MCMD_GETICONDIR:
+    reply_module(m, prefs.icondir, strlen(prefs.icondir)+1);
+    break;
+  case MCMD_GETICONPALETTE:
+    if(!XFindContext(dpy, id, client_context, (XPointer*)&c)) {
+      scr=c->scr;
+    } else
+      if(XFindContext(dpy, id, screen_context, (XPointer*)&scr)) {
+	reply_module(m, NULL, -1);
+	break;
+      }
+    reply_module(m, (void *)scr->iconcolor,
+		 (iconcolormask+1)*sizeof(unsigned long));
+    break;
+  case MCMD_MANAGEMENU:
+    if(data_len>=sizeof(int[3])) {
+      struct Item *i;
+      scr=getscreen(id);
+      if((i=own_items(m, scr, ((int*)data)[0], ((int*)data)[1],
+		      ((int*)data)[3], m->menuitems))) {
+	m->menuitems = i;
+	reply_module(m, NULL, 0);
+      } else
+	reply_module(m, NULL, -1);
+    } else
+      reply_module(m, NULL, -1);
+    break;
+  default:
+    reply_module(m, NULL, -1);
+  }
+}
+
+static void module_input_callback(struct module *m)
+{
+  unsigned char buffer[8192], *p=buffer;
+  int r;
+  if(!(m->pid)) {
+    sieve_modules();
+    return;
+  }
+  r=read(m->in_fd, buffer, sizeof(buffer));
+  if(r==0 || (r<0 && errno!=EINTR)) {
+    if(r<0)
+      perror("module");
+    else
+      fprintf(stderr, "module %d exited!?\n", (int)m->pid);
+    remove_fd_from_set(m->in_fd);
+    close(m->in_fd);
+    close(m->out_fd);
+    m->in_fd=m->out_fd=-1;
+#ifdef HAVE_WAITPID
+    reap_children(0);
+#else
+#ifdef HAVE_WAIT3
+    reap_children(0);
+#endif
+#endif
+    sieve_modules();
+    return;
+  }
+  while(r>0) {
+    int t=(r>m->in_left? m->in_left:r);
+    memcpy(m->in_ptr, p, t);
+    m->in_ptr+=t;
+    if(!(m->in_left-=t))
+      if(m->in_phase || ((!m->mcmd.len)&&(m->in_ptr=m->in_buf))) {
+	*m->in_ptr=0;
+	handle_module_cmd(m, m->in_buf, m->mcmd.len);
+	m->in_ptr=(char *)&m->mcmd;
+	m->in_left=sizeof(m->mcmd);
+	m->in_phase=0;
+      } else {
+	if(m->mcmd.len>=m->in_buf_size) {
+	  if((m->in_buf_size<<=1)<=m->mcmd.len)
+	    m->in_buf_size=m->mcmd.len+1; {
+	  m->in_buf=realloc(m->in_buf, m->in_buf_size);
+	  }
+	}
+	m->in_ptr=m->in_buf;
+	m->in_left=m->mcmd.len;
+	m->in_phase++;
+      }
+    p+=t;
+    r-=t;
+  }
+}
+
+void handle_module_input(fd_set *r)
+{
+  struct module *m;
+
+  for(m=modules; m; m=m->next)
+    if(m->in_fd>=0 && FD_ISSET(m->in_fd, r)) {
+      module_input_callback(m);
+      break;
+    }
+}
+
+void flushmodules()
+{
+  struct module *n, *m=modules;
+  int i;
+  extern char *progname;
+
+  while(m) {
+    n=m->next;
+    if(m->in_fd>=0) {
+      close(m->in_fd);
+      remove_fd_from_set(m->in_fd);
+      m->in_fd=-1;
+    }
+    if(m->out_fd>=0) {
+      close(m->out_fd);
+      m->out_fd=-1;
+    }
+    if(m->pid>0)
+      kill(m->pid, SIGHUP);
+    m=n;
+  }
+  for(i=5; i>0; --i) {
+    sieve_modules();
+    if(!modules)
+      break;
+    sleep(1);
+  }
+  sieve_modules();
+  if(modules)
+    fprintf(stderr, "%s: giving up waiting for modules to die!\n", progname);
+}
diff --git a/module.h b/module.h
new file mode 100644
index 0000000..0abdb39
--- /dev/null
+++ b/module.h
@@ -0,0 +1,58 @@
+#define MCMD_NOP 1
+#define MCMD_GET_VERSION 2
+#define MCMD_SEND_EVENT 4
+#define MCMD_SET_BROKER 5
+#define MCMD_ROTATE_SCREEN 6
+#define MCMD_ADD_KEYGRAB 7
+#define MCMD_DEL_KEYGRAB 8
+#define MCMD_FRONT 9
+#define MCMD_BACK 10
+#define MCMD_ICONIFY 11
+#define MCMD_CREATEAPPICON 12
+#define MCMD_ERRORMSG 14
+#define MCMD_SETAPPWINDOW 15
+#define MCMD_GETICONDIR 16
+#define MCMD_GETICONPALETTE 17
+#define MCMD_MANAGEMENU 18
+
+struct mcmd_header {
+  XID id;
+  int cmd;
+  int len;
+};
+
+struct mcmd_event {
+  unsigned long mask;
+  XEvent event;
+};
+
+struct mcmd_keygrab {
+  struct mcmd_keygrab *next;
+  int id;
+  struct module *owner;
+  int keycode;
+  unsigned int modifiers;
+};
+
+struct NewAppIcon {
+  int x, y;
+  Pixmap pm1, pm2, pmm;
+  char name[1];
+};
+
+extern struct module {
+  struct module *next;
+  int in_fd, out_fd;
+  pid_t pid;
+  struct mcmd_header mcmd;
+  char *in_ptr;
+  int in_left;
+  int in_phase;
+  char *in_buf;
+  int in_buf_size;
+  struct {
+    int exists;
+    unsigned long mask;
+  } broker;
+  struct Item *menuitems;
+} *modules;
diff --git a/module_cmds b/module_cmds
new file mode 100644
index 0000000..55fe84a
--- /dev/null
+++ b/module_cmds
@@ -0,0 +1,18 @@
+%{
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <X11/Xlib.h>
+#include "module.h"
+%}
+struct module_cmd ;
+%%
+NOP, MCMD_NOP
+GET_VERSION, MCMD_GET_VERSION
+LIST_SCREENS, MCMD_LIST_SCREENS
+SEND_EVENT, MCMD_SEND_EVENT
+SET_BROKER, MCMD_SET_BROKER
+%%
+
diff --git a/ppmtoinfo.c b/ppmtoinfo.c
new file mode 100644
index 0000000..e4cc072
--- /dev/null
+++ b/ppmtoinfo.c
@@ -0,0 +1,526 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#define WB_DISKMAGIC	0xe310
+#define WB_DISKVERSION	1
+#define WB_DISKREVISION	1
+#define WB_DISKREVISIONMASK	255
+
+#define NO_ICON_POSITION	(0x80000000)
+
+#define	WBDISK		1
+#define	WBDRAWER	2
+#define	WBTOOL		3
+#define	WBPROJECT	4
+#define	WBGARBAGE	5
+#define	WBDEVICE	6
+#define	WBKICK		7
+#define WBAPPICON	8
+
+#define NONNULL 0x123456
+
+
+struct { char *name; int minl, code; } icontype[] = {
+  { "appicon", 1, WBAPPICON },
+  { "device", 2, WBDEVICE },
+  { "disk", 2, WBDISK },
+  { "drawer", 2, WBDRAWER },
+  { "garbage", 1, WBGARBAGE },
+  { "kick", 1, WBKICK },
+  { "project", 1, WBPROJECT },
+  { "tool", 1, WBTOOL },
+};
+#define NUM_ICONTYPES (sizeof(icontype)/sizeof(icontype[0]))
+
+typedef unsigned short pixval;
+typedef struct {
+  pixval r, g, b;
+} pixel;
+
+void usage()
+{
+  fprintf(stderr, "usage:  ppmtoinfo [-type icontype][-floyd|-fs] [-map mapfile] [ppmfile] [ppmfile]\n");
+  exit(1);
+}
+
+void w16(FILE *file, int v)
+{
+  putc((v>>8)&0xff, file);
+  putc(v&0xff, file);
+}
+
+void w32(FILE *file, int v)
+{
+  w16(file, v>>16);
+  w16(file, v);
+}
+
+char *myalloc(int size)
+{
+  char *p=malloc(size);
+  if(!p) {
+    fprintf(stderr, "out of memory!\n");
+    exit(1);
+  }
+  return p;
+}
+
+pixel **readppm(FILE *file, int *colsP, int *rowsP, pixval *maxvalP)
+{
+  pixel** pixels;
+  int row, col;
+  int format, mv;
+
+  if(4!=fscanf(file, "P%d %d %d %d", &format, colsP, rowsP, &mv) ||
+     (format!=3 && format!=6)) {
+    fprintf(stderr, "bad magic number - not a ppm file\n");
+    exit(1);
+  }
+  if(format==6)
+    getc(file);
+  *maxvalP=mv;
+  pixels = (pixel **)myalloc(*rowsP * sizeof(pixel*));
+  pixels[0] = (pixel *)myalloc(*rowsP * *colsP * sizeof(pixel));
+  for(row=1; row<*rowsP; row++)
+    pixels[row] = &(pixels[0][row * *colsP]);
+  for ( row = 0; row < *rowsP; ++row )
+    if(format==3)
+      for( col = 0; col < *colsP; ++col) {
+	int r, g, b;
+	fscanf(file, "%d %d %d", &r, &g, &b);
+	pixels[row][col].r=r;
+	pixels[row][col].g=g;
+	pixels[row][col].b=b;
+      }
+    else
+      for( col = 0; col < *colsP; ++col) {
+	pixels[row][col].r=getc(file);
+	pixels[row][col].g=getc(file);
+	pixels[row][col].b=getc(file);
+      }  
+  return pixels;
+}
+
+char *makelibfilename(char *oldname)
+{
+  char *newname;
+  if(*oldname=='/') return oldname;
+  newname=myalloc(strlen(oldname)+strlen(AMIWM_HOME)+2);
+  sprintf(newname, AMIWM_HOME"/%s", oldname);
+  return newname;
+}
+
+#define HSTYLE_COMPL    0
+#define HSTYLE_BACKFILL 1
+#define HSTYLE_IMAGE    2
+
+void writeiconheader(FILE *file, int type, int hstyle, int cols, int rows,
+		     char *deftool, char **tooltypes, char *toolwin,
+		     int stksize)
+{
+  int drw=0;
+
+  if(type==1 || type==2 || type==5 || type==6)
+    drw=1;
+  w16(file, WB_DISKMAGIC); w16(file, WB_DISKVERSION);
+  w32(file, 0);
+  w16(file, 0); w16(file, 0); w16(file, cols); w16(file, rows);
+  w16(file, 4|hstyle); w16(file, 3); w16(file, 1);
+  w32(file, NONNULL); w32(file, (hstyle==HSTYLE_IMAGE? NONNULL:0));
+  w32(file, 0); w32(file, 0); w32(file, 0);
+  w16(file, 0); w32(file, WB_DISKREVISION);
+  putc(type, file); putc(0, file);
+  w32(file, (deftool!=NULL? NONNULL:0));
+  w32(file, (tooltypes!=NULL? NONNULL:0));
+  w32(file, NO_ICON_POSITION); w32(file, NO_ICON_POSITION);
+  w32(file, (drw? NONNULL:0)); w32(file, (toolwin? NONNULL:0));
+  w32(file, stksize);
+  if(drw) {
+    w16(file, 50); w16(file, 50); w16(file, 400); w16(file, 100);
+    w16(file, ~0); w32(file, 0); w32(file, 0x0240027f);
+    w32(file, 0); w32(file, 0); w32(file, NONNULL);
+    w32(file, 0); w32(file, 0);
+    w16(file, 90); w16(file, 40); w16(file, ~0); w16(file, ~0);
+    w16(file, 1);
+    w32(file, 0); w32(file, 0);
+  }
+}
+
+void writeiconinit(FILE *file, int cols, int rows, int planes)
+{
+  w16(file, 0); w16(file, 0);
+  w16(file, cols); w16(file, rows); w16(file, planes);
+  w32(file, NONNULL);
+  putc((1<<planes)-1, file); putc(0, file);
+  w32(file, 0);
+}
+
+void writeiconimage(FILE *file, unsigned char *pixels,
+		    int cols, int rows, int planes)
+{
+  register int i, j, k, l;
+  register unsigned char pat;
+  for(i=0; i<planes; i++)
+    for(j=0; j<rows; j++)
+      for(k=0; k<cols; k+=8) {
+	pat=0;
+	for(l=0; l<8; l++)
+	  if(pixels[j*cols+k+l]&(1<<i))
+	    pat|=0x80>>l;
+	putc(pat, file);
+      }
+}
+
+void writeiconstr(FILE *file, char *str)
+{
+  int l=strlen(str)+1;
+  w32(file, l);
+  fwrite(str, 1, l, file);
+}
+
+void writeiconend(FILE *file, int type,
+		  char *deftool, char **tooltypes, char *toolwin)
+{
+  if(deftool) writeiconstr(file, deftool);
+  if(tooltypes) {
+    int n;
+    for(n=0; tooltypes[n]!=NULL; n++);
+    w32(file, 4*(n+1));
+    for(n=0; tooltypes[n]!=NULL; n++)
+      writeiconstr(file, tooltypes[n]);
+  }
+  if(toolwin) writeiconstr(file, toolwin);
+  if(type==1 || type==2 || type==5 || type==6) {
+    w32(file, 0); w16(file, 0);
+  }
+}
+
+#define mx(a,b) ((a)>(b)?(a):(b))
+
+unsigned char *processicon(FILE *ifp, int floyd, pixel **mappixels,
+			   int maprows, int mapcols, pixval *mapmaxval,
+			   int *rowsP, int *colsP, int *planesP)
+{
+  int rows, cols, planes, bpr, imgsz;
+  pixval maxval;
+  pixel **pixels, *colormap;
+  unsigned char *outimg, *oip;
+  register int row, col, limitcol;
+  register pixel *pP;
+  int newcolors;
+  register int ind;
+  long* thisrerr;
+  long* nextrerr;
+  long* thisgerr;
+  long* nextgerr;
+  long* thisberr;
+  long* nextberr;
+  long* temperr;
+  register long sr, sg, sb, err;
+  int fs_direction, dscale;
+
+  pixels = readppm( ifp, &cols, &rows, &maxval );
+  if(ifp != stdin)
+    fclose( ifp );
+
+  if ( *mapmaxval != maxval ) {
+    if ( *mapmaxval > maxval )
+      fprintf(stderr, "rescaling colormap colors\n");
+    for ( row = 0; row < maprows; ++row )
+      for ( col = 0, pP = mappixels[row]; col < mapcols; ++col, ++pP ) {
+	pP->r=((int)pP->r*maxval+*mapmaxval/2)/ *mapmaxval;
+        pP->g=((int)pP->g*maxval+*mapmaxval/2)/ *mapmaxval;
+	pP->b=((int)pP->b*maxval+*mapmaxval/2)/ *mapmaxval;
+      }
+    *mapmaxval = maxval;
+  }
+
+  newcolors=mapcols*maprows;
+  colormap=mappixels[0];
+  if(newcolors>256) newcolors=256;
+  for(planes=1; (1<<planes)<newcolors; planes++);
+
+  bpr=2*((cols+15)>>4);
+  imgsz=rows*bpr*8*sizeof(unsigned char);
+  outimg = (unsigned char *)myalloc(imgsz);
+  memset(outimg, 0, imgsz);
+  oip = outimg;
+
+  dscale = 0;
+  if(maxval>=16384)
+    while(maxval>=(16384<<dscale))
+      dscale++;
+
+  if ( floyd ) {
+    /* Initialize Floyd-Steinberg error vectors. */
+    thisrerr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    nextrerr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    thisgerr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    nextgerr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    thisberr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    nextberr = (long*) myalloc( (cols + 2) * sizeof(long) );
+    srand( (int) ( time( 0 ) ^ getpid( ) ) );
+    for ( col = 0; col < cols + 2; ++col ) {
+      thisrerr[col] = rand( ) % ( 1024 * 2 ) - 1024;
+      thisgerr[col] = rand( ) % ( 1024 * 2 ) - 1024;
+      thisberr[col] = rand( ) % ( 1024 * 2 ) - 1024;
+      /* (random errors in [-1 .. 1]) */
+    }
+    fs_direction = 1;
+  }
+  for ( row = 0; row < rows; ++row ) {
+    if ( floyd )
+      for ( col = 0; col < cols + 2; ++col )
+	nextrerr[col] = nextgerr[col] = nextberr[col] = 0;
+    if ( ( ! floyd ) || fs_direction ) {
+      col = 0;
+      limitcol = cols;
+      pP = pixels[row];
+    } else {
+      col = cols - 1;
+      limitcol = -1;
+      pP = &(pixels[row][col]);
+    }
+    do {
+      register int i, r2, g2, b2;
+      register long dist, newdist;
+
+      if ( floyd ) {
+	/* Use Floyd-Steinberg errors to adjust actual color. */
+	sr = pP->r + thisrerr[col + 1] / 1024;
+	sg = pP->g + thisgerr[col + 1] / 1024;
+	sb = pP->b + thisberr[col + 1] / 1024;
+	if ( sr < 0 ) sr = 0;
+	else if ( sr > maxval ) sr = maxval;
+	if ( sg < 0 ) sg = 0;
+	else if ( sg > maxval ) sg = maxval;
+	if ( sb < 0 ) sb = 0;
+	else if ( sb > maxval ) sb = maxval;
+      } else {
+	sr = pP->r;
+	sg = pP->g;
+	sb = pP->b;
+      }
+
+      for ( i = 0; i < newcolors; ++i ) {
+	r2 = sr - colormap[i].r;
+	g2 = sg - colormap[i].g;
+	b2 = sb - colormap[i].b;
+	if (dscale) {
+	  r2 >>= dscale;
+	  g2 >>= dscale;
+	  b2 >>= dscale;
+	}
+
+	newdist = r2 * r2 + g2 * g2 + b2 * b2;
+	if ( i==0 || newdist < dist ) {
+	  ind = i;
+	  dist = newdist;
+	}
+      }
+      
+      if ( floyd ) {
+	/* Propagate Floyd-Steinberg error terms. */
+	if ( fs_direction ) {
+	  err = ( sr - (long) colormap[ind].r ) * 1024;
+	  thisrerr[col + 2] += ( err * 7 ) / 16;
+	  nextrerr[col    ] += ( err * 3 ) / 16;
+	  nextrerr[col + 1] += ( err * 5 ) / 16;
+	  nextrerr[col + 2] += ( err     ) / 16;
+	  err = ( sg - (long) colormap[ind].g ) * 1024;
+	  thisgerr[col + 2] += ( err * 7 ) / 16;
+	  nextgerr[col    ] += ( err * 3 ) / 16;
+	  nextgerr[col + 1] += ( err * 5 ) / 16;
+	  nextgerr[col + 2] += ( err     ) / 16;
+	  err = ( sb - (long) colormap[ind].b ) * 1024;
+	  thisberr[col + 2] += ( err * 7 ) / 16;
+	  nextberr[col    ] += ( err * 3 ) / 16;
+	  nextberr[col + 1] += ( err * 5 ) / 16;
+	  nextberr[col + 2] += ( err     ) / 16;
+	} else {
+	  err = ( sr - (long) colormap[ind].r ) * 1024;
+	  thisrerr[col    ] += ( err * 7 ) / 16;
+	  nextrerr[col + 2] += ( err * 3 ) / 16;
+	  nextrerr[col + 1] += ( err * 5 ) / 16;
+	  nextrerr[col    ] += ( err     ) / 16;
+	  err = ( sg - (long) colormap[ind].g ) * 1024;
+	  thisgerr[col    ] += ( err * 7 ) / 16;
+	  nextgerr[col + 2] += ( err * 3 ) / 16;
+	  nextgerr[col + 1] += ( err * 5 ) / 16;
+	  nextgerr[col    ] += ( err     ) / 16;
+	  err = ( sb - (long) colormap[ind].b ) * 1024;
+	  thisberr[col    ] += ( err * 7 ) / 16;
+	  nextberr[col + 2] += ( err * 3 ) / 16;
+	  nextberr[col + 1] += ( err * 5 ) / 16;
+	  nextberr[col    ] += ( err     ) / 16;
+	}
+      }
+      
+      oip[col] = ind;
+      
+      if ( ( ! floyd ) || fs_direction ) {
+	++col;
+	++pP;
+      } else {
+	--col;
+	--pP;
+      }
+    }
+    while ( col != limitcol );
+
+    oip += bpr*8;
+
+    if ( floyd ) {
+      temperr = thisrerr;
+      thisrerr = nextrerr;
+      nextrerr = temperr;
+      temperr = thisgerr;
+      thisgerr = nextgerr;
+      nextgerr = temperr;
+      temperr = thisberr;
+      thisberr = nextberr;
+      nextberr = temperr;
+      fs_direction = ! fs_direction;
+    }
+
+  }
+
+  if(floyd) {
+    free(thisrerr); free(nextrerr);
+    free(thisgerr); free(nextgerr);
+    free(thisberr); free(nextberr);
+  }
+  free(pixels[0]); free(pixels);
+  *rowsP=rows; *colsP=cols; *planesP=planes;
+  return outimg;
+}
+
+
+int main(int argc, char *argv[])
+{
+  char *mapname = "system.map";
+  int argn, maprows, mapcols;
+  int floyd;
+  pixel **mappixels;
+  pixval mapmaxval;
+  FILE* ifp;
+  FILE *ifp2=NULL;
+  unsigned char *outimg;
+  int planes, rows, cols;
+  char *deftool=NULL, **tooltypes=NULL, *toolwin=NULL;
+  int stksize=0;
+  int type=WBPROJECT;
+
+  argn = 1;
+  floyd = 0;
+
+  while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' ) {
+    int l=strlen(argv[argn]);
+    if ( !strncmp( argv[argn], "-fs", mx(l, 2) ) ||
+	 !strncmp( argv[argn], "-floyd", mx(l, 2) ) )
+      floyd = 1;
+    else if ( !strncmp( argv[argn], "-nofs", mx(l, 2) ) ||
+	      !strncmp( argv[argn], "-nofloyd", mx(l, 2) ) )
+      floyd = 0;
+    else if ( !strncmp( argv[argn], "-map", mx(l, 2) ) ) {
+      ++argn;
+      if ( argn == argc )
+	usage();
+      mapname = argv[argn];
+    }
+    else if ( !strncmp( argv[argn], "-type", mx(l, 2) ) ) {
+      int i;
+      ++argn;
+      if ( argn == argc )
+	usage();      
+      l=strlen(argv[argn]);
+      for(i=0; i<NUM_ICONTYPES; i++)
+	if( !strncmp( argv[argn], icontype[i].name, mx(l, icontype[i].minl))) {
+	  type = icontype[i].code;
+	  break;
+	}
+      if(i>=NUM_ICONTYPES) {
+	fprintf(stderr, "Unknown icon type.  Supported types:\n");
+	for(i=0; i<NUM_ICONTYPES; i++)
+	  fprintf(stderr, "  %s\n", icontype[i].name);
+	exit(1);
+      }
+    } else
+      usage();
+    ++argn;
+  }
+  
+  if(!strcmp(mapname, "-"))
+    ifp = stdin;
+  else
+    if((ifp = fopen(mapname, "r"))==NULL)
+      ifp = fopen(makelibfilename(mapname), "r");
+  if(!ifp) {
+    perror(mapname);
+    exit(1);
+  }
+  mappixels = readppm( ifp, &mapcols, &maprows, &mapmaxval );
+  if(ifp != stdin)
+    fclose( ifp );
+  if ( mapcols == 0 || maprows == 0 ) {
+    fprintf(stderr, "null colormap??\n");
+    exit(1);
+  }
+
+  if ( argn != argc ) {
+    if(!strcmp(argv[argn], "-"))
+      ifp = stdin;
+    else
+      ifp = fopen(argv[argn], "r");
+    if(!ifp) {
+      perror(argv[argn]);
+      exit(1);
+    }
+    ++argn;
+  }
+  else
+    ifp = stdin;
+
+  if ( argn != argc ) {
+    if(!strcmp(argv[argn], "-"))
+      ifp2 = stdin;
+    else
+      ifp2 = fopen(argv[argn], "r");
+    if(!ifp) {
+      perror(argv[argn]);
+      exit(1);
+    }
+    ++argn;
+  }
+
+  if ( argn != argc )
+    usage();
+
+  outimg = processicon(ifp, floyd, mappixels, maprows, mapcols, &mapmaxval,
+		       &rows, &cols, &planes);
+  writeiconheader(stdout, type,
+		  (ifp2==NULL? HSTYLE_BACKFILL:HSTYLE_IMAGE),
+		  cols, rows, deftool, tooltypes, toolwin, stksize);
+  writeiconinit(stdout, cols, rows, planes);
+  writeiconimage(stdout, outimg, 16*((cols+15)>>4), rows, planes);
+  free(outimg);
+
+  if(ifp2) {
+    outimg = processicon(ifp2, floyd, mappixels, maprows, mapcols, &mapmaxval,
+			 &rows, &cols, &planes);
+    writeiconinit(stdout, cols, rows, planes);
+    writeiconimage(stdout, outimg, 16*((cols+15)>>4), rows, planes);
+    free(outimg);
+  }
+
+  writeiconend(stdout, type, deftool, tooltypes, toolwin);
+
+  return 0;
+}
diff --git a/prefs.h b/prefs.h
new file mode 100644
index 0000000..44ce0d7
--- /dev/null
+++ b/prefs.h
@@ -0,0 +1,30 @@
+#ifndef PREFS_H
+#define PREFS_H
+
+extern struct prefs_struct {
+  int fastquit;
+  int sizeborder;
+  int forcemove;
+  int borderwidth;
+  int autoraise;
+  int opaquemove;
+  int opaqueresize;
+  int customiconsonly;
+  int shortlabelicons;
+  char *icondir, *module_path, *defaulticon;
+  int focus, manage_all, screenmenu;
+  int titlebarclock;			/* display titlebar clock? */
+  char *titleclockformat;		/* format to use for the clock */
+  int titleclockinterval;		/* how often do we update the clock?*/
+  struct _Style *firststyle, *laststyle;
+} prefs;
+
+#define FM_MANUAL 0
+#define FM_ALWAYS 1
+#define FM_AUTO 2
+
+#define FOC_FOLLOWMOUSE 0
+#define FOC_CLICKTOTYPE 1
+#define FOC_SLOPPY 2
+
+#endif
diff --git a/rc.c b/rc.c
new file mode 100644
index 0000000..324830d
--- /dev/null
+++ b/rc.c
@@ -0,0 +1,191 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/Xmu/CharSet.h>
+
+#include "alloc.h"
+#include "prefs.h"
+#include "drawinfo.h"
+#include "screen.h"
+#include "gram.h"
+#include "icc.h"
+#include "style.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xmu1_pragmas.h>
+extern struct Library *Xmu1Base;
+#endif
+
+extern void set_sys_palette(void);
+extern int yyparse (void);
+
+struct prefs_struct prefs;
+
+#ifndef RC_FILENAME
+#define RC_FILENAME ".amiwmrc"
+#endif
+
+FILE *rcfile;
+int ParseError=0;
+
+void read_rc_file(char *filename, int manage_all)
+{
+  char *home, *fn;
+
+  memset(&prefs, 0, sizeof(prefs));
+  prefs.manage_all = manage_all;
+  prefs.sizeborder=Psizeright;
+  prefs.icondir=AMIWM_HOME;
+  prefs.module_path=AMIWM_HOME;
+  prefs.defaulticon="def_tool.info";
+  prefs.borderwidth=1;
+  prefs.titleclockinterval=1;
+  prefs.opaquemove=False;
+  prefs.opaqueresize=False;
+  prefs.screenmenu=False;
+  prefs.firststyle=NULL;
+  prefs.laststyle=NULL;
+  set_sys_palette();
+
+  if(filename!=NULL && (rcfile=fopen(filename, "r"))) {
+    yyparse();
+    fclose(rcfile);
+    rcfile=NULL;
+    return;
+  }
+
+  home=getenv("HOME");
+#ifdef AMIGAOS
+  {
+    char fn[256];
+    strncpy(fn, home, sizeof(fn)-1);
+    fn[sizeof(fn)-1]='\0';
+    AddPart(fn, RC_FILENAME, sizeof(fn));
+    if((rcfile=fopen(fn, "r"))) {
+      yyparse();
+      fclose(rcfile);
+      rcfile=NULL;
+      return;
+    }
+  }
+#else
+#ifdef HAVE_ALLOCA
+  if((fn=alloca(strlen(home)+strlen(RC_FILENAME)+4))) {
+#else
+  if((fn=malloc(strlen(home)+strlen(RC_FILENAME)+4))) {
+#endif
+    sprintf(fn, "%s/"RC_FILENAME, home);
+    if((rcfile=fopen(fn, "r"))) {
+      yyparse();
+      fclose(rcfile);
+#ifndef HAVE_ALLOCA
+      free(fn);
+#endif
+      return;
+    }
+#ifndef HAVE_ALLOCA
+    free(fn);
+#endif
+  }
+#endif
+  if((rcfile=fopen(AMIWM_HOME"/system"RC_FILENAME, "r"))) {
+    yyparse();
+    fclose(rcfile);
+  }
+}
+
+struct keyword { char *name; int token; } keywords[] = {
+  { "always", ALWAYS },
+  { "auto", AUTO },
+  { "autoraise", AUTORAISE },
+  { "backgroundpen", T_BACKGROUNDPEN },
+  { "barblockpen", T_BARBLOCKPEN },
+  { "bardetailpen", T_BARDETAILPEN },
+  { "bartrimpen", T_BARTRIMPEN },
+  { "blockpen", T_BLOCKPEN },
+  { "both", BOTH },
+  { "bottom", BOTTOM },
+  { "class", CLASS },
+  { "clicktotype", CLICKTOTYPE },
+  { "customiconsonly", CUSTOMICONSONLY },
+  { "defaulticon", DEFAULTICON },
+  { "detailpen", T_DETAILPEN },
+  { "false", NO },
+  { "fastquit", FASTQUIT },
+  { "fillpen", T_FILLPEN },
+  { "filltextpen", T_FILLTEXTPEN },
+  { "focus", FOCUS },
+  { "followmouse", FOLLOWMOUSE },
+  { "forcemove", FORCEMOVE },
+  { "highlighttextpen", T_HIGHLIGHTTEXTPEN },
+  { "icon", ICON },
+  { "icondir", ICONDIR },
+  { "iconfont", ICONFONT },
+  { "iconpalette", ICONPALETTE },
+  { "icontitle", ICONTITLE },
+  { "interscreengap", INTERSCREENGAP },
+  { "magicwb", MAGICWB },
+  { "manual", MANUAL },
+  { "module", MODULE },
+  { "modulepath", MODULEPATH },
+  { "no", NO },
+  { "none", NONE },
+  { "off", NO },
+  { "on", YES },
+  { "opaquemove", OPAQUEMOVE },
+  { "opaqueresize", OPAQUERESIZE },
+  { "right", RIGHT },
+  { "schwartz", SCHWARTZ },
+  { "screen", SCREEN },
+  { "screenfont", SCREENFONT },
+  { "screenmenu", SCREENMENU },
+  { "separator", SEPARATOR },
+  { "shadowpen", T_SHADOWPEN },
+  { "shinepen", T_SHINEPEN },
+  { "shortlabelicons", SHORTLABELICONS },
+  { "sizeborder", SIZEBORDER },
+  { "sloppy", SLOPPY },
+  { "style", STYLE },
+  { "system", SYSTEM },
+  { "textpen", T_TEXTPEN },
+  { "title", TITLE },
+  { "titlebarclock", TITLEBARCLOCK },
+  { "titleclockformat", TITLECLOCKFORMAT },
+  { "toolitem", TOOLITEM },
+  { "true", YES },
+  { "yes", YES }
+};
+
+#define N_KW (sizeof(keywords)/sizeof(keywords[0]))
+
+int parse_keyword(char *str)
+{
+  int l=0, h=N_KW-1;
+  
+  XmuCopyISOLatin1Lowered (str, str);
+  while(h>=l) {
+    int i=(h+l)>>1, c=strcmp(str, keywords[i].name);
+    if(!c)
+      return keywords[i].token;
+    else if(c>=0)
+      l=i+1;
+    else
+      h=i-1;
+  }
+  return ERRORTOKEN;
+}
+
+void free_prefs()
+{
+  Style *s;
+  while((s = prefs.firststyle)) {
+    prefs.firststyle = s->next;
+    if(s->style_class) free(s->style_class);
+    if(s->style_title) free(s->style_title);
+    if(s->style_icon_title) free(s->style_icon_title);
+    if(s->icon_name) free(s->icon_name);
+    free_icon_pms(&s->icon_pms);
+    free(s);
+  }
+  prefs.laststyle = NULL;
+}
diff --git a/requestchoice.c b/requestchoice.c
new file mode 100644
index 0000000..941d28e
--- /dev/null
+++ b/requestchoice.c
@@ -0,0 +1,335 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "drawinfo.h"
+#include "libami.h"
+
+#ifdef AMIGAOS
+#include <pragmas/xlib_pragmas.h>
+extern struct Library *XLibBase;
+#endif
+
+#define BUT_BUTSPACE (2*(2+5))
+#define BUT_INTSPACE 12
+#define BUT_EXTSPACE 4
+#define BUT_VSPACE   6
+#define TXT_HSPACE   48
+#define TXT_TOPSPACE 4
+#define TXT_MIDSPACE 3
+#define TXT_BOTSPACE 4
+
+struct choice {
+  struct choice *next;
+  const char *text;
+  int l, w;
+  Window win;
+} *firstchoice=NULL, *lastchoice=NULL;
+
+struct line {
+  struct line *next;
+  const char *text;
+  int l, w, h;
+} *firstline=NULL, *lastline=NULL;
+
+Display *dpy;
+Window root, mainwin, textwin;
+char *progname;
+GC gc;
+Pixmap stipple;
+
+int totw=0, maxw=0, toth=0, nchoices=0;
+int depressed=0;
+struct choice *selected=NULL;
+
+struct DrawInfo dri;
+
+struct RDArgs *ra=NULL;
+
+void selection(int n)
+{
+  printf("%d\n", n);
+  XDestroyWindow(dpy, mainwin);
+  XCloseDisplay(dpy);
+  FreeArgs(ra);
+  exit(0);
+}
+
+void *myalloc(size_t s)
+{
+  void *p=calloc(s,1);
+  if(p)
+    return p;
+  fprintf(stderr, "%s: out of memory!\n", progname);
+  FreeArgs(ra);
+  exit(1);
+}
+
+void addchoice(const char *txt)
+{
+  struct choice *c=myalloc(sizeof(struct choice));
+  if(lastchoice)
+    lastchoice->next=c;
+  else
+    firstchoice=c;
+  lastchoice=c;
+  c->l=strlen(c->text=txt);
+#ifdef USE_FONTSETS
+  totw+=(c->w=XmbTextEscapement(dri.dri_FontSet, c->text, c->l))+BUT_BUTSPACE;
+#else
+  totw+=(c->w=XTextWidth(dri.dri_Font, c->text, c->l))+BUT_BUTSPACE;
+#endif
+  nchoices++;
+}
+
+void addline(const char *txt)
+{
+  struct line *l=myalloc(sizeof(struct line));
+  if(lastline)
+    lastline->next=l;
+  else
+    firstline=l;
+  lastline=l;
+  l->l=strlen(l->text=txt);
+#ifdef USE_FONTSETS
+  l->w=XmbTextEscapement(dri.dri_FontSet, l->text, l->l);
+#else
+  l->w=XTextWidth(dri.dri_Font, l->text, l->l);
+#endif
+  toth+=l->h=dri.dri_Ascent+dri.dri_Descent;
+  if(l->w>maxw)
+    maxw=l->w;
+}
+
+void refresh_text()
+{
+  int w=totw-BUT_EXTSPACE-BUT_EXTSPACE;
+  int h=toth-TXT_TOPSPACE-TXT_MIDSPACE-TXT_BOTSPACE-BUT_VSPACE-
+    (dri.dri_Ascent+dri.dri_Descent);
+  int x=(totw-maxw+TXT_HSPACE)>>1;
+  int y=((dri.dri_Ascent+dri.dri_Descent)>>1)+dri.dri_Ascent;
+  struct line *l;
+  XSetForeground(dpy, gc, dri.dri_Pens[SHADOWPEN]);
+  XDrawLine(dpy, textwin, gc, 0, 0, w-2, 0);
+  XDrawLine(dpy, textwin, gc, 0, 0, 0, h-2);
+  XSetForeground(dpy, gc, dri.dri_Pens[SHINEPEN]);
+  XDrawLine(dpy, textwin, gc, 0, h-1, w-1, h-1);
+  XDrawLine(dpy, textwin, gc, w-1, 0, w-1, h-1);  
+  XSetForeground(dpy, gc, dri.dri_Pens[TEXTPEN]);
+  for(l=firstline; l; l=l->next) {
+#ifdef USE_FONTSETS
+    XmbDrawString(dpy, textwin, dri.dri_FontSet, gc, x, y, l->text, l->l);
+#else
+    XDrawString(dpy, textwin, gc, x, y, l->text, l->l);
+#endif
+    y+=dri.dri_Ascent+dri.dri_Descent;
+  }
+}
+
+void refresh_choice(struct choice *c)
+{
+  int w=c->w+BUT_BUTSPACE;
+  int h=dri.dri_Ascent+dri.dri_Descent+BUT_VSPACE;
+  XSetForeground(dpy, gc, dri.dri_Pens[TEXTPEN]);
+#ifdef USE_FONTSETS
+  XmbDrawString(dpy, c->win, dri.dri_FontSet, gc, BUT_BUTSPACE/2,
+		dri.dri_Ascent+BUT_VSPACE/2, c->text, c->l);
+#else
+  XDrawString(dpy, c->win, gc, BUT_BUTSPACE/2,
+	      dri.dri_Ascent+BUT_VSPACE/2, c->text, c->l);
+#endif
+  XSetForeground(dpy, gc, dri.dri_Pens[(c==selected && depressed)?
+				     SHADOWPEN:SHINEPEN]);
+  XDrawLine(dpy, c->win, gc, 0, 0, w-2, 0);
+  XDrawLine(dpy, c->win, gc, 0, 0, 0, h-2);
+  XSetForeground(dpy, gc, dri.dri_Pens[(c==selected && depressed)?
+				     SHINEPEN:SHADOWPEN]);
+  XDrawLine(dpy, c->win, gc, 1, h-1, w-1, h-1);
+  XDrawLine(dpy, c->win, gc, w-1, 1, w-1, h-1);  
+  XSetForeground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+  XDrawPoint(dpy, c->win, gc, w-1, 0);
+  XDrawPoint(dpy, c->win, gc, 0, h-1);
+}
+
+void split(char *str, const char *delim, void (*func)(const char *))
+{
+  char *p;
+  if((p=strtok(str, delim)))
+    do {
+      (*func)(p);
+    } while((p=strtok(NULL, delim)));
+}
+
+struct choice *getchoice(Window w)
+{
+  struct choice *c;
+  for(c=firstchoice; c; c=c->next)
+    if(w == c->win)
+      return c;
+  return NULL;
+}
+
+void toggle(struct choice *c)
+{
+  XSetWindowBackground(dpy, c->win, dri.dri_Pens[(depressed&&c==selected)?
+					       FILLPEN:BACKGROUNDPEN]);
+  XClearWindow(dpy, c->win);
+  refresh_choice(c);
+}
+
+void abortchoice()
+{
+  if(depressed) {
+    depressed=0;
+    toggle(selected);
+  }
+  selected=NULL;
+}
+
+void endchoice()
+{
+  struct choice *c=selected, *c2=firstchoice;
+  int n;
+
+  abortchoice();
+  if(c==lastchoice)
+    selection(0);
+  for(n=1; c2; n++, c2=c2->next)
+    if(c2==c)
+      selection(n);
+  selection(0);
+}
+
+int main(int argc, char *argv[])
+{
+  XWindowAttributes attr;
+  static XSizeHints size_hints;
+  static XTextProperty txtprop1, txtprop2;
+  int x, y, extra=0, n=0;
+  struct choice *c;
+  Argtype array[3], *atp;
+
+  progname=argv[0];
+  initargs(argc, argv);
+  if(!(ra=ReadArgs((STRPTR)"TITLE/A,BODY/A,GADGETS/M", (LONG *)array, NULL))) {
+    PrintFault(IoErr(), (UBYTE *)progname);
+    exit(1);
+  }
+  if(!(dpy = XOpenDisplay(NULL))) {
+    fprintf(stderr, "%s: cannot connect to X server %s\n", progname,
+	    XDisplayName(NULL));
+    FreeArgs(ra);
+    exit(1);
+  }
+  root = RootWindow(dpy, DefaultScreen(dpy));
+  XGetWindowAttributes(dpy, root, &attr);
+  init_dri(&dri, dpy, root, attr.colormap, False);
+
+  split(array[1].ptr, "\n", addline);
+  if((atp=array[2].ptr) != NULL)
+    for(; atp->ptr; atp++)
+      split(atp->ptr, "|\n", addchoice);
+
+  totw+=BUT_EXTSPACE+BUT_EXTSPACE+BUT_INTSPACE*(nchoices-1);
+  toth+=2*(dri.dri_Ascent+dri.dri_Descent)+TXT_TOPSPACE+
+    TXT_MIDSPACE+TXT_BOTSPACE+BUT_VSPACE;
+  maxw+=TXT_HSPACE+BUT_EXTSPACE+BUT_EXTSPACE;
+
+  if(maxw>totw) {
+    extra=maxw-totw;
+    totw=maxw;
+  }
+
+  mainwin=XCreateSimpleWindow(dpy, root, 0, 0, totw, toth, 1,
+			      dri.dri_Pens[SHADOWPEN],
+			      dri.dri_Pens[BACKGROUNDPEN]);
+  gc=XCreateGC(dpy, mainwin, 0, NULL);
+  XSetBackground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+#ifndef USE_FONTSETS
+  XSetFont(dpy, gc, dri.dri_Font->fid);
+#endif
+  stipple=XCreatePixmap(dpy, mainwin, 2, 2, attr.depth);
+  XSetForeground(dpy, gc, dri.dri_Pens[BACKGROUNDPEN]);
+  XFillRectangle(dpy, stipple, gc, 0, 0, 2, 2);
+  XSetForeground(dpy, gc, dri.dri_Pens[SHINEPEN]);
+  XDrawPoint(dpy, stipple, gc, 0, 1);
+  XDrawPoint(dpy, stipple, gc, 1, 0);
+  XSetWindowBackgroundPixmap(dpy, mainwin, stipple);
+  textwin=XCreateSimpleWindow(dpy, mainwin, BUT_EXTSPACE, TXT_TOPSPACE, totw-
+			      BUT_EXTSPACE-BUT_EXTSPACE, toth-TXT_TOPSPACE-
+			      TXT_MIDSPACE-TXT_BOTSPACE-BUT_VSPACE-
+			      (dri.dri_Ascent+dri.dri_Descent),
+			      0, dri.dri_Pens[SHADOWPEN],
+			      dri.dri_Pens[BACKGROUNDPEN]);
+  XSelectInput(dpy, textwin, ExposureMask);
+  x=BUT_EXTSPACE;
+  y=toth-TXT_BOTSPACE-(dri.dri_Ascent+dri.dri_Descent)-BUT_VSPACE;
+  for(c=firstchoice; c; c=c->next) {
+    c->win=XCreateSimpleWindow(dpy, mainwin,
+			       x+(nchoices==1? (extra>>1):
+				  n++*extra/(nchoices-1)),
+			       y, c->w+BUT_BUTSPACE,
+			       dri.dri_Ascent+dri.dri_Descent+
+			       BUT_VSPACE, 0,
+			       dri.dri_Pens[SHADOWPEN],
+			       dri.dri_Pens[BACKGROUNDPEN]);
+    XSelectInput(dpy, c->win, ExposureMask|ButtonPressMask|ButtonReleaseMask|
+		 EnterWindowMask|LeaveWindowMask);
+    x+=c->w+BUT_BUTSPACE+BUT_INTSPACE;
+  }
+  size_hints.flags = PResizeInc;
+  txtprop1.value=(unsigned char *)array[0].ptr;
+  txtprop2.value=(unsigned char *)"RequestChoice";
+  txtprop2.encoding=txtprop1.encoding=XA_STRING;
+  txtprop2.format=txtprop1.format=8;
+  txtprop1.nitems=strlen((char *)txtprop1.value);
+  txtprop2.nitems=strlen((char *)txtprop2.value);
+  XSetWMProperties(dpy, mainwin, &txtprop1, &txtprop2, argv, argc,
+		   &size_hints, NULL, NULL);
+  XMapSubwindows(dpy, mainwin);
+  XMapRaised(dpy, mainwin);
+  for(;;) {
+    XEvent event;
+    XNextEvent(dpy, &event);
+    switch(event.type) {
+    case Expose:
+      if(!event.xexpose.count)
+	if(event.xexpose.window == textwin)
+	  refresh_text();
+	else if((c=getchoice(event.xexpose.window)))
+	  refresh_choice(c);
+      break;
+    case LeaveNotify:
+      if(depressed && event.xcrossing.window==selected->win) {
+	depressed=0;
+	toggle(selected);
+      }
+      break;
+    case EnterNotify:
+      if((!depressed) && selected && event.xcrossing.window==selected->win) {
+	depressed=1;
+	toggle(selected);
+      }
+      break;
+    case ButtonPress:
+      if(event.xbutton.button==Button1 &&
+	 (c=getchoice(event.xbutton.window))) {
+	abortchoice();
+	depressed=1;
+	toggle(selected=c);
+      }
+      break;
+    case ButtonRelease:
+      if(event.xbutton.button==Button1 && selected)
+	if(depressed)
+	  endchoice();
+	else
+	  abortchoice();
+      break;
+    }
+  }
+  FreeArgs(ra);
+}
diff --git a/schwartz.map b/schwartz.map
new file mode 100644
index 0000000..67a2fa4
--- /dev/null
+++ b/schwartz.map
@@ -0,0 +1,5 @@
+P3 4 4 255
+170 160 170    0   0   0  255 255 255   91 120 245
+153 144 153  187 176 187  187 170 153  255 187 170
+217  34 241  145  90  70   62  62  65  110 105 115
+255  25  25  255 255   0  114 125 146    0 200   0
diff --git a/scoptions b/scoptions
new file mode 100644
index 0000000..8827e95
--- /dev/null
+++ b/scoptions
@@ -0,0 +1,13 @@
+DATA=FAR
+NOSTACKCHECK
+OPTIMIZE
+STRIPDEBUG
+NOICONS
+INCLUDEDIR=x11:sasc/include
+INCLUDEDIR=include:netinclude
+DEFINE AMIGAOS
+LIBRARY=x11:sasc/lib/x11.lib
+IGNORE=161
+IGNORE=93
+IGNORE=100
+IDentifierLENgth=63
diff --git a/screen.c b/screen.c
new file mode 100644
index 0000000..42d1bf7
--- /dev/null
+++ b/screen.c
@@ -0,0 +1,386 @@
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "drawinfo.h"
+#include "screen.h"
+#include "icon.h"
+#include "client.h"
+#include "prefs.h"
+#include "icc.h"
+
+extern Display *dpy;
+extern Cursor wm_curs;
+#ifdef USE_FONTSETS
+extern XFontSet labelfontset;
+extern int labelfont_ascent;
+#else
+extern XFontStruct *labelfont;
+#endif
+extern char *progname;
+extern XContext screen_context, client_context, vroot_context;
+
+extern void createmenubar();
+extern void reparent(Client *);
+
+Scrn *front = NULL, *scr = NULL;
+
+static Scrn *getvroot(Window root)
+{
+  Scrn *s;
+  if(!XFindContext(dpy, root, vroot_context, (XPointer *)&s))
+    return s;
+  return NULL;
+}
+
+static void setvroot(Window root, Scrn *s)
+{
+  XSaveContext(dpy, root, vroot_context, (XPointer)s);
+}
+
+void setvirtualroot(Scrn *s)
+{
+  if(s) {
+    Scrn *old_vroot = getvroot(s->root);
+
+    if(s==old_vroot) return;
+    if(old_vroot)
+      XDeleteProperty(dpy, old_vroot->back, swm_vroot);
+    setvroot(s->root, s);
+    XChangeProperty(dpy, s->back, swm_vroot, XA_WINDOW, 32, PropModeReplace,
+		    (unsigned char *)&(s->back), 1);
+  }
+}
+
+Scrn *getscreenbyroot(Window w);
+
+void screentoback(void)
+{
+  Scrn *f;
+  if((!scr)||(scr->back==scr->root)) return;
+  if(scr==front) {
+    XLowerWindow(dpy, scr->back);
+    front=scr->behind;
+  } else if(scr==getscreenbyroot(scr->root)) {
+    XLowerWindow(dpy, scr->back);
+    scr->upfront->behind=scr->behind;
+    scr->behind->upfront=scr->upfront;
+    scr->upfront=front->upfront;
+    scr->behind=front;
+    front->upfront->behind=scr;
+    front->upfront=scr;
+  } else if(scr->behind==front) {
+    XRaiseWindow(dpy, scr->back);
+    front=scr;
+  } else {
+    XRaiseWindow(dpy, scr->back);
+    scr->upfront->behind=scr->behind;
+    scr->behind->upfront=scr->upfront;
+    scr->upfront=front->upfront;
+    scr->behind=front;
+    front->upfront->behind=scr;
+    front->upfront=scr;
+    front=scr;
+  }
+  if((f = getscreenbyroot(scr->root))) {
+    init_dri(&f->dri, dpy, f->root, f->cmap, True);
+    setvirtualroot(f);
+  }
+}
+
+void assimilate(Window w, int x, int y)
+{
+#ifdef ASSIMILATE_WINDOWS
+  XSetWindowAttributes xsa;
+
+  XAddToSaveSet(dpy, w);
+  XReparentWindow(dpy, w, scr->back, x, (y<scr->y? 0:y-scr->y));
+  XSaveContext(dpy, w, screen_context, (XPointer)scr);
+  xsa.override_redirect = False;
+  XChangeWindowAttributes(dpy, w, CWOverrideRedirect, &xsa);
+#endif
+}
+
+static void scanwins()
+{
+  unsigned int i, nwins;
+  Client *c;
+  Window dw1, dw2, *wins;
+  XWindowAttributes *pattr=NULL;
+  XPointer dummy;
+  Scrn *s=scr;
+
+  XQueryTree(dpy, scr->root, &dw1, &dw2, &wins, &nwins);
+  if(nwins && (pattr=calloc(nwins, sizeof(XWindowAttributes)))) {
+    for (i = 0; i < nwins; i++)
+      XGetWindowAttributes(dpy, wins[i], pattr+i);
+    for (i = 0; i < nwins; i++) {
+      if (!XFindContext(dpy, wins[i], client_context, &dummy))
+	continue;
+      if (pattr[i].override_redirect) {
+	if(scr->back!=scr->root && XFindContext(dpy, wins[i], screen_context, &dummy))
+	  assimilate(wins[i], pattr[i].x, pattr[i].y);
+	continue;
+      }
+      c = createclient(wins[i]);
+      if (c != 0 && c->window == wins[i]) {
+	if (pattr[i].map_state == IsViewable) {
+	  c->state=NormalState;
+	  getstate(c);
+	  reparent(c);
+	  if(c->state==IconicState) {
+	    createicon(c);
+	    adjusticon(c->icon);
+	    XMapWindow(dpy, c->icon->window);
+	    if(c->icon->labelwidth)
+	      XMapWindow(dpy, c->icon->labelwin);
+	    c->icon->mapped=1;
+	  } else if(c->state==NormalState)
+	    XMapRaised(dpy, c->parent);
+	  else
+	    XRaiseWindow(dpy, c->parent);
+	  c->reparenting=1;
+	  scr=s;
+	}
+      }
+    }
+    free(pattr);
+  }
+  XFree((void *) wins);
+  cleanupicons();
+}
+
+void closescreen(void)
+{
+  Scrn *dummy;
+
+  if(scr->behind == scr)
+    scr->behind = NULL;
+  else {
+    scr->upfront->behind=scr->behind;
+    scr->behind->upfront=scr->upfront;
+  }
+
+  XDeleteContext(dpy,scr->menubardepth,screen_context);
+  XDestroyWindow(dpy,scr->menubardepth);
+  XDeleteContext(dpy,scr->menubarparent,screen_context);
+  XDestroyWindow(dpy,scr->menubarparent);
+  XDeleteContext(dpy,scr->menubar,screen_context);
+  XDestroyWindow(dpy,scr->menubar);
+  if(scr->inputbox != None) {
+    XDeleteContext(dpy,scr->inputbox,screen_context);
+    XDestroyWindow(dpy,scr->inputbox);
+  }
+
+  XFreeGC(dpy,scr->rubbergc);
+  XFreeGC(dpy,scr->icongc);
+  XFreeGC(dpy,scr->gc);
+  XDeleteContext(dpy,scr->back,screen_context);
+  XDestroyWindow(dpy,scr->back);
+  free_icon_pms(&scr->default_tool_pms);
+  term_dri(&scr->dri, dpy, scr->cmap);
+  if(scr->iconcolorsallocated)
+    XFreeColors(dpy, scr->cmap, scr->iconcolor, scr->iconcolorsallocated, 0);
+  if(front==scr)
+    front=scr->behind;
+  dummy=scr->behind;
+  free(scr);
+  scr=dummy;
+}
+
+Scrn *openscreen(char *deftitle, Window root)
+{
+  Scrn *s;
+  XWindowAttributes attr;
+  XSetWindowAttributes swa;
+  XGCValues gcv;
+  extern char *label_font_name;
+
+  if(!root)
+    root = DefaultRootWindow(dpy);
+
+  XGetWindowAttributes(dpy, root, &attr);
+
+  s = (Scrn *)calloc(1, sizeof(Scrn));
+  s->root = root;
+  s->cmap = attr.colormap;
+  s->depth = attr.depth;
+  s->visual = attr.visual;
+  s->number = XScreenNumberOfScreen(attr.screen);
+  s->inputbox = None;
+
+  init_dri(&s->dri, dpy, s->root, s->cmap, True);
+
+  swa.background_pixel = s->dri.dri_Pens[BACKGROUNDPEN];
+  swa.override_redirect = True;
+  swa.colormap = attr.colormap;
+  swa.cursor = wm_curs;
+  swa.border_pixel = BlackPixel(dpy, DefaultScreen(dpy));
+
+  s->back = XCreateWindow(dpy, root,
+			  -prefs.borderwidth, (s->y=0)-prefs.borderwidth,
+			  s->width = attr.width, s->height = attr.height,
+			  s->bw=prefs.borderwidth, CopyFromParent,
+			  InputOutput, CopyFromParent,
+			  CWBackPixel|CWOverrideRedirect|CWColormap|CWCursor|
+			  CWBorderPixel,
+			  &swa);
+
+  XSaveContext(dpy, s->back, screen_context, (XPointer)s);
+
+  gcv.background = s->dri.dri_Pens[BACKGROUNDPEN];
+
+#ifdef USE_FONTSETS
+  s->gc = XCreateGC(dpy, s->back, GCBackground, &gcv);
+
+  if(!labelfontset) {
+    char **missing_charsets = NULL;
+    int n_missing_charsets = 0;
+    labelfontset =  XCreateFontSet(dpy, label_font_name,
+				   &missing_charsets,
+				   &n_missing_charsets, NULL);
+    if(missing_charsets)
+      XFreeStringList(missing_charsets);
+    if(!labelfontset) { 
+      fprintf(stderr, "%s: cannot open font %s\n", progname, label_font_name);
+      labelfontset = s->dri.dri_FontSet;
+    }
+  }
+  {
+    XFontStruct **fsl;
+    char **fnl;
+    if(XFontsOfFontSet(labelfontset, &fsl, &fnl) < 1) {
+      fprintf(stderr, "%s: fontset %s is empty\n", progname,
+	      label_font_name);
+      exit(1);
+    }
+    labelfont_ascent = fsl[0]->ascent;
+    s->lh = fsl[0]->ascent+fsl[0]->descent;
+  }
+  gcv.foreground = s->dri.dri_Pens[TEXTPEN];
+
+  s->icongc = XCreateGC(dpy, s->back, GCForeground|GCBackground, &gcv);
+#else  
+  gcv.font = s->dri.dri_Font->fid;
+
+  s->gc = XCreateGC(dpy, s->back, GCBackground|GCFont, &gcv);
+  
+  if(!labelfont)
+    if(!(labelfont = XLoadQueryFont(dpy, label_font_name))) {
+      fprintf(stderr, "%s: cannot open font %s\n", progname, label_font_name);
+      labelfont = s->dri.dri_Font;
+    }
+
+  s->lh = labelfont->ascent+labelfont->descent;
+  gcv.font = labelfont->fid;
+  gcv.foreground = s->dri.dri_Pens[TEXTPEN];
+
+  s->icongc = XCreateGC(dpy, s->back, GCForeground|GCBackground|GCFont, &gcv);
+#endif
+
+  gcv.function = GXinvert;
+  gcv.subwindow_mode = IncludeInferiors;
+
+  s->rubbergc = XCreateGC(dpy, s->back, GCFunction|GCSubwindowMode, &gcv);
+
+  s->title = s->deftitle = deftitle;
+
+  s->default_tool_pms.pm = None;
+  s->default_tool_pms.pm2 = None;
+  s->default_tool_pms.cs.colors = NULL;
+  s->default_tool_pms.cs2.colors = NULL;
+  s->default_tool_pm_w=0;
+  s->default_tool_pm_h=0;
+
+  if(front) {
+    s->behind=front;
+    s->upfront=front->upfront;
+    front->upfront->behind=s;
+    front->upfront=s;
+  } else {
+    s->behind = s->upfront = s;
+    front = s;
+  }
+
+  scr=s;
+
+  return s;
+}
+
+void realizescreens(void)
+{
+  scr = front;
+
+  do {
+    if(!scr->realized) {
+      scr->fh = scr->dri.dri_Ascent+scr->dri.dri_Descent;
+      scr->bh=scr->fh+3;
+      scr->h2=(2*scr->bh)/10; scr->h3=(3*scr->bh)/10;
+      scr->h4=(4*scr->bh)/10; scr->h5=(5*scr->bh)/10;
+      scr->h6=(6*scr->bh)/10; scr->h7=(7*scr->bh)/10;
+      scr->h8=(8*scr->bh)/10;
+      createmenubar();
+      createdefaulticons();
+
+      if (scr->inputbox == None && prefs.focus == FOC_CLICKTOTYPE) {
+	scr->inputbox = XCreateWindow(dpy, scr->back, 0, 0,
+				      scr->width, scr->height, 0, 0,
+				      InputOnly, CopyFromParent, 0, NULL);
+	XSaveContext(dpy, scr->inputbox, screen_context, (XPointer)scr);
+	XSelectInput(dpy, scr->inputbox, KeyPressMask|KeyReleaseMask);
+	XLowerWindow(dpy, scr->inputbox);
+	XMapWindow(dpy, scr->inputbox);
+      }
+
+      XSelectInput(dpy, scr->root,
+		   SubstructureNotifyMask|SubstructureRedirectMask|
+		   KeyPressMask|KeyReleaseMask|
+		   ButtonPressMask|ButtonReleaseMask|FocusChangeMask);
+      if(scr->back != scr->root)
+	XSelectInput(dpy, scr->back,
+		     SubstructureNotifyMask|SubstructureRedirectMask|
+		     KeyPressMask|KeyReleaseMask|
+		     ButtonPressMask|ButtonReleaseMask);
+
+      XStoreName(dpy, scr->back, scr->title);
+      XLowerWindow(dpy, scr->back);
+      XMapWindow(dpy, scr->back);
+    }
+    scr=scr->behind;
+  } while(scr!=front);
+  do {  
+    if(!scr->realized) {
+      scanwins();
+      if(!getvroot(scr->root)) {
+	init_dri(&scr->dri, dpy, scr->root, scr->cmap, True);
+	setvirtualroot(scr);
+      }
+      scr->realized=1;
+    }
+    scr=scr->behind;
+  } while(scr!=front);
+}
+
+Scrn *getscreen(Window w)
+{
+  Scrn *s=front;
+  if(w && s)
+    do {
+      if(s->back == w || s->root == w)
+	return s;
+      s=s->behind;
+    } while(s!=front);
+  return front;
+}
+
+Scrn *getscreenbyroot(Window w)
+{
+  Scrn *s=front;
+  if(s)
+    do {
+      if(s->root == w)
+	return s;
+      s=s->behind;
+    } while(s!=front);
+  return NULL;
+}
diff --git a/screen.h b/screen.h
new file mode 100644
index 0000000..cfda1ad
--- /dev/null
+++ b/screen.h
@@ -0,0 +1,30 @@
+#ifndef SCREEN_H
+#define SCREEN_H
+
+#include "icon.h"
+
+typedef struct _Scrn {
+  struct _Scrn *behind, *upfront;
+  Window root, back, inputbox;
+  Colormap cmap;
+  Visual *visual;
+  GC gc, icongc, rubbergc, menubargc;
+  char *title;
+  char *deftitle;
+  struct DrawInfo dri;
+  int fh,bh,h2,h3,h4,h5,h6,h7,h8;
+  int width, height, depth, y, bw;
+  struct IconPixmaps default_tool_pms;
+  Pixmap disabled_stipple;
+  unsigned int default_tool_pm_w, default_tool_pm_h, lh;
+  Window menubar, menubarparent, menubardepth;
+  int hotkeyspace, checkmarkspace, subspace, menuleft;
+  struct _Icon *icons, *firstselected;
+  struct Menu *firstmenu;
+  int number, realized, iconcolorsallocated;
+  unsigned long iconcolor[256];
+} Scrn;
+
+extern Scrn *scr, *front;
+
+#endif
diff --git a/smakefile b/smakefile
new file mode 100644
index 0000000..b53e0c2
--- /dev/null
+++ b/smakefile
@@ -0,0 +1,47 @@
+
+PROGRAMS = amiwm requestchoice
+
+AMIWM_HOME = amiwm:
+
+SRCS1 = main.c drawinfo.c client.c frame.c icc.c \
+	icon.c menu.c diskobject.c gram.c lex.c rc.c
+OBJS1 = main.o drawinfo.o client.o frame.o icc.o \
+	icon.o menu.o diskobject.o gram.o lex.o rc.o
+
+SRCS2 = requestchoice.c drawinfo.c
+OBJS2 = requestchoice.o drawinfo.o
+
+
+all : $(PROGRAMS)
+
+amiwm : $(OBJS1)
+	sc LINK PNAME amiwm $(OBJS1)
+
+requestchoice : $(OBJS2)
+	sc LINK PNAME requestchoice $(OBJS2)
+
+gram.c : gram.y
+	bison -y -d -o gram.c gram.y
+
+lex.c : lex.l
+	flex -t < lex.l > lex.c
+
+gram.o : gram.c
+
+lex.o : lex.c
+
+menu.o : menu.c
+	sc menu DEF AMIWM_HOME="$(AMIWM_HOME)"
+
+rc.o : rc.c
+	sc rc DEF AMIWM_HOME="$(AMIWM_HOME)"
+
+clean : tidy
+	-delete FORCE $(PROGRAMS)
+
+tidy :
+	-delete FORCE \#?.(o|q|tmp|lnk) lex.c gram.c gram.h core
+
+install :
+	copy amiwm requestchoice system.amiwmrc def_tool.info $(AMIWM_HOME)
+
diff --git a/style.h b/style.h
new file mode 100644
index 0000000..679cac4
--- /dev/null
+++ b/style.h
@@ -0,0 +1,16 @@
+#ifndef STYLE_H
+#define STYLE_H
+
+#include <X11/Xlib.h>
+
+#include "icon.h"
+
+typedef struct _Style {
+  struct _Style *next;
+  char *style_class, *style_title, *style_icon_title;
+  struct IconPixmaps icon_pms;
+  unsigned int icon_pm_w, icon_pm_h;
+  char *icon_name;
+} Style;
+
+#endif
diff --git a/system.amiwmrc b/system.amiwmrc
new file mode 100644
index 0000000..da70466
--- /dev/null
+++ b/system.amiwmrc
@@ -0,0 +1,10 @@
+FastQuit Off
+SizeBorder Right
+IconPalette MagicWB
+DefaultIcon "def_tool.info"
+CustomIconsOnly Off
+ShortLabelIcons Off
+TitlebarClock Off
+TitleClockFormat "%c"
+Screen "Workbench Screen"
+Module "Keyboard" "Meta<M>:all:rotatescreens"
diff --git a/system.map b/system.map
new file mode 100644
index 0000000..d640353
--- /dev/null
+++ b/system.map
@@ -0,0 +1,3 @@
+P3 4 2 255
+170 170 170    0   0   0  255 255 255  102 136 187
+238  68  68   85 221  85    0  68 221  238 153   0
diff --git a/version.h b/version.h
new file mode 100644
index 0000000..1562106
--- /dev/null
+++ b/version.h
@@ -0,0 +1 @@
+#define VERSION "0.22"