/* See comments below */

const unsigned char gzipped_data[] = {
/* 000000 */  0x1f,  0x8b,  0x08,  0x19,  0xc3,  0x4e,  0x37,  0x38,
/* 0x0008 */  0x02,  0x03,  0x73,  0x65,  0x6c,  0x66,  0x75,  0x6e,
/* 0x0010 */  0x63,  0x2e,  0x63,  0000,  0x49,  0x20,  0x61,  0x6d,
/* 0x0018 */  0x20,  0x61,  0x20,  0x71,  0x75,  0x69,  0x6e,  0x65,
/* 0x0020 */  0x21,  0000,  0xc5,  0x5b,  0x7b,  0x73,  0xdb,  0xc6,
/* 0x0028 */  0x11,  0xff,  0x5b,  0x9a,  0x7c,  0x88,  0x8b,  0x33,
/* 0x0030 */  0x76,  0x08,  0x11,  0x92,  0x08,  0x52,  0x7c,  0x99,
/* 0x0038 */  0x92,  0xdb,  0xc4,  0x49,  0x1a,  0x75,  0x62,  0x27,
/* 0x0040 */  0x13,  0xdb,  0x93,  0xb6,  0x89,  0x46,  0xc5,  0xe3,
/* 0x0048 */  0x48,  0x42,  0xc2,  0xcb,  0x78,  0x48,  0x62,  0x1d,
/* 0x0050 */  0x7d,  0xf7,  0xee,  0xee,  0x1d,  0x80,  0xc3,  0x83,
/* 0x0058 */  0x14,  0x31,  0x4d,  0xdb,  0x4e,  0x6a,  0x9b,  0xb8,
/* 0x0060 */  0xdb,  0xbd,  0xbd,  0xbd,  0xdf,  0xbe,  0xee,  0x71,
/* 0x0068 */  0x7a,  0xc4,  0xde,  0xaf,  0xdd,  0x84,  0xc1,  0x7f,
/* 0x0070 */  0x26,  0x4b,  0xb8,  0xb7,  0x8c,  0x79,  0xc4,  0x7a,
/* 0x0078 */  0x1f,  0x33,  0x37,  0xe0,  0x1a,  0x8b,  0xe2,  0x70,
/* 0x0080 */  0x15,  0x9b,  0xfe,  0x09,  0x63,  0x97,  0x29,  0xcb,
/* 0x0088 */  0x12,  0x9e,  0xb0,  0x74,  0xcd,  0x99,  0x69,  0x85,
/* 0x0090 */  0x77,  0x9c,  0x39,  0x66,  0x6a,  0xb2,  0xde,  0xfd,
/* 0x0098 */  0xda,  0xb5,  0xd7,  0x87,  0xec,  0x08,  0xe9,  0x83,
/* 0x00a0 */  0x90,  0x85,  0xd0,  0x1e,  0x43,  0x27,  0x33,  0xa0,
/* 0x00a8 */  0x9e,  0xab,  0x7f,  0xb9,  0x51,  0xc4,  0x1d,  0x06,
/* 0x00b0 */  0x3c,  0x63,  0x9e,  0xf0,  0x20,  0x35,  0x53,  0x37,
/* 0x00b8 */  0x0c,  0x58,  0xb8,  0x64,  0xfc,  0x8e,  0xc7,  0x9b,
/* 0x00c0 */  0x74,  0xed,  0x06,  0x2b,  0x96,  0xa4,  0x66,  0x9c,
/* 0x00c8 */  0xc2,  0x3f,  0x90,  0xcb,  0x32,  0x0e,  0x7d,  0xa0,
/* 0x00d0 */  0x04,  0x66,  0x76,  0xe8,  0xfb,  0x40,  0xa0,  0xb1,
/* 0x00d8 */  0x34,  0x04,  0x31,  0xdc,  0x20,  0x65,  0x6e,  0x9a,
/* 0x00e0 */  0xb0,  0xf0,  0x3e,  0x60,  0x9e,  0x9b,  0x60,  0x77,
/* 0x00e8 */  0x10,  0xea,  0xad,  0x99,  0x66,  0xb1,  0xe9,  0x79,
/* 0x00f0 */  0x1b,  0x5d,  0xd0,  0xf8,  0xdc,  0x0c,  0x12,  0x64,
/* 0x00f8 */  0x03,  0x02,  0xa4,  0xec,  0x9e,  0xb3,  0x80,  0xc3,
/* 0x0100 */  0xe0,  0x49,  0xe8,  0x73,  0x96,  0x05,  0xc0,  0x10,
/* 0x0108 */  0x85,  0x48,  0x50,  0x80,  0x38,  0xcc,  0x80,  0x05,
/* 0x0110 */  0x4f,  0x80,  0xc7,  0x7b,  0xec,  0x0a,  0xb4,  0xf7,
/* 0x0118 */  0x92,  0x84,  0xa4,  0x41,  0x1e,  0xf7,  0x6e,  0xba,
/* 0x0120 */  0x3e,  0x61,  0x47,  0xa7,  0x87,  0x87,  0x5f,  0xb8,
/* 0x0128 */  0x81,  0xed,  0x65,  0x0e,  0x67,  0xe7,  0x49,  0xea,
/* 0x0130 */  0xb8,  0xe1,  0xc9,  0xfa,  0xd5,  0xe1,  0x67,  0x87,
/* 0x0138 */  0xa7,  0x47,  0xec,  0xf8,  0xf8,  0x98,  0xfd,  0xe5,
/* 0x0140 */  0x1f,  0x97,  0x3f,  0xb1,  0xa5,  0xeb,  0x71,  0xb6,
/* 0x0148 */  0x0c,  0x63,  0x1f,  0x58,  0xb4,  0x0f,  0x44,  0x7d,
/* 0x0150 */  0x91,  0xd7,  0x29,  0xaa,  0x1b,  0x3b,  0x7b,  0x5e,
/* 0x0158 */  0x78,  0x8f,  0xb3,  0x2f,  0x7a,  0xf4,  0x82,  0x30,
/* 0x0160 */  0x35,  0x2d,  0x6f,  0x43,  0x8a,  0xcb,  0x02,  0xd0,
/* 0x0168 */  0x5c,  0x4f,  0xd3,  0xd8,  0x12,  0xf8,  0x91,  0xce,
/* 0x0170 */  0x2c,  0x0e,  0x04,  0x28,  0x57,  0x39,  0x40,  0xa1,
/* 0x0178 */  0x5e,  0x5c,  0x0a,  0x9a,  0x0a,  0xdf,  0x30,  0x33,
/* 0x0180 */  0xe6,  0x2c,  0xe5,  0x71,  0xec,  0x22,  0xab,  0x04,
/* 0x0188 */  0x68,  0x18,  0x08,  0x85,  0x2c,  0x53,  0x33,  0xb9,
/* 0x0190 */  0xd5,  0x99,  0x95,  0xd1,  0xe4,  0x5c,  0x9a,  0x33,
/* 0x0198 */  0x72,  0xc9,  0x7c,  0x60,  0x40,  0xfa,  0x4a,  0x91,
/* 0x01a0 */  0xfc,  0x3e,  0x8c,  0x6f,  0x61,  0xb9,  0xcc,  0x24,
/* 0x01a8 */  0x0c,  0x48,  0x98,  0x7b,  0xee,  0x79,  0x39,  0x6b,
/* 0x01b0 */  0x27,  0x0c,  0xbe,  0x4c,  0xe1,  0x4f,  0x66,  0x06,
/* 0x01b8 */  0x1b,  0x64,  0x02,  0xa3,  0x84,  0x31,  0xb3,  0xd7,
/* 0x01c0 */  0xdc,  0xbe,  0x85,  0x99,  0x10,  0x6f,  0x62,  0xf2,
/* 0x01c8 */  0x25,  0x88,  0000,  0xc8,  0xb1,  0x88,  0x01,  0xcc,
/* 0x01d0 */  0x0a,  0x96,  0x30,  0x64,  0x77,  0x99,  0x17,  0xf0,
/* 0x01d8 */  0x18,  0x3e,  0x71,  0x5c,  0x51,  0x2b,  0x5b,  0xad,
/* 0x01e0 */  0x88,  0x07,  0xa1,  0x88,  0xbb,  0x08,  0x1b,  0x18,
/* 0x01e8 */  0xe6,  0xab,  0x40,  0000,  0xc8,  0xf5,  0xa3,  0x30,
/* 0x01f0 */  0x4e,  0x4d,  0x58,  0x74,  0xcf,  0xf5,  0x5d,  0x89,
/* 0x01f8 */  0x9a,  0x1e,  0xf2,  0x07,  0xc1,  0xef,  0xc3,  0xcc,
/* 0x0200 */  0x73,  0x40,  0x1f,  0x28,  0x7e,  0x9a,  0x0a,  0x49,
/* 0x0208 */  0xcc,  0x64,  0x83,  0x6c,  0x57,  0x3c,  0x05,  0x05,
/* 0x0210 */  0x84,  0x59,  0xe0,  0x68,  0x38,  0xbf,  0x7c,  0x5a,
/* 0x0218 */  0x62,  0x14,  0x3f,  0x4b,  0x52,  0x98,  0x5a,  0xe2,
/* 0x0220 */  0xc2,  0x4a,  0xba,  0x01,  0x80,  0xc5,  0x0f,  0x63,
/* 0x0228 */  0x40,  0x0e,  0xa9,  0x02,  0x99,  0xa0,  0xa4,  0x30,
/* 0x0230 */  0x73,  0x87,  0x99,  0x64,  0x0a,  0x29,  0xfc,  0xdb,
/* 0x0238 */  0xcf,  0xa7,  0xbe,  0x36,  0x01,  0xf1,  0x16,  0xe7,
/* 0x0240 */  0x01,  0x43,  0xdc,  0x82,  0x54,  0x69,  0x8a,  0x13,
/* 0x0248 */  0xe1,  0x49,  0xca,  0x1d,  0x92,  0x7b,  0x73,  0x6f,
/* 0x0250 */  0x6e,  0x74,  0x82,  0x0d,  0x8c,  0x89,  0xe0,  0xc6,
/* 0x0258 */  0x71,  0x13,  0x5e,  0xac,  0x5f,  0x42,  0x0b,  0xb3,
/* 0x0260 */  0x0a,  0x43,  0x07,  0x81,  0xa2,  0xb3,  0x4b,  0x16,
/* 0x0268 */  0x09,  0x6d,  0xf9,  0x28,  0x0b,  0xca,  0x18,  0x65,
/* 0x0270 */  0x96,  0xe7,  0xda,  0xa4,  0x93,  0xd0,  0x37,  0xdd,
/* 0x0278 */  0000,  0xd8,  0x02,  0x66,  0xbe,  0x31,  0xef,  0x5c,
/* 0x0280 */  0x87,  0xbd,  0x31,  0x9d,  0x10,  0xc8,  0xcf,  0x1d,
/* 0x0288 */  0xfc,  0x75,  0xe2,  0xd3,  0xaf,  0x3f,  0xf3,  0x20,
/* 0x0290 */  0x39,  0x59,  0xc6,  0xaf,  0x98,  0x31,  0x9f,  0xcf,
/* 0x0298 */  0x4f,  0x0d,  0xe3,  0x74,  0x68,  0x10,  0xc2,  0xb2,
/* 0x02a0 */  0x20,  0x71,  0x57,  0x01,  0x2c,  0x2a,  0xd8,  0xcc,
/* 0x02a8 */  0x61,  0xc4,  0xf9,  0xed,  0xb5,  0x85,  0x96,  0xd3,
/* 0x02b0 */  0xb3,  0x41,  0x08,  0x84,  0xa7,  0x6c,  0xb5,  0xd7,
/* 0x02b8 */  0x66,  0xcc,  0x8e,  0x50,  0x31,  0x3a,  0xf3,  0x42,
/* 0x02c0 */  0000,  0x62,  0xa4,  0x23,  0x05,  0xfb,  0xa8,  0x1d,
/* 0x02c8 */  0x32,  0xfc,  0x1f,  0000,  0xf5,  0x67,  0x54,  0xc6,
/* 0x02d0 */  0x47,  0x46,  0xe4,  0xb9,  0x91,  0x0a,  0x0b,  0x85,
/* 0x02d8 */  0x4f,  0x2c,  0xca,  0x8d,  0x55,  0xaa,  0x37,  0x0a,
/* 0x02e0 */  0x81,  0x1c,  0xb1,  0x04,  0xab,  0xbb,  0x11,  0x3c,
/* 0x02e8 */  0xe4,  0xfa,  0xc2,  0x4c,  0xbe,  0xc1,  0x1e,  0xe8,
/* 0x02f0 */  0x65,  0x02,  0xa9,  0xbb,  0x63,  0x1e,  0x38,  0x2e,
/* 0x02f8 */  0x78,  0x09,  0x61,  0x35,  0x64,  0x67,  0x9f,  0x80,
/* 0x0300 */  0x48,  0x15,  0x1e,  0x60,  0x96,  0xdc,  0xf3,  0x78,
/* 0x0308 */  0x01,  0x9f,  0xf1,  0x97,  0x1d,  0xa4,  0x0b,  0x94,
/* 0x0310 */  0xea,  0x6d,  0xe6,  0x5b,  0xa0,  0x5e,  0xf0,  0x21,
/* 0x0318 */  0x24,  0x98,  0xe9,  0xe1,  0x9a,  0x6d,  0x58,  0xe4,
/* 0x0320 */  0x99,  0x36,  0xd1,  0x49,  0x32,  0xe4,  0xc8,  0xc4,
/* 0x0328 */  0x2c,  0x43,  0x0b,  0xa6,  0x68,  0x11,  0xf1,  0x8f,
/* 0x0330 */  0xcb,  0x65,  0x82,  0x18,  0x09,  0x1c,  0xe6,  0xf1,
/* 0x0338 */  0x60,  0x95,  0xae,  0x25,  0x1f,  0x30,  0x61,  0x0e,
/* 0x0340 */  0xa0,  0x42,  0x9b,  0x07,  0x0e,  0x76,  0x16,  0xc7,
/* 0x0348 */  0xe0,  0x7b,  0x60,  0x1e,  0x29,  0x27,  0x9d,  0xb2,
/* 0x0350 */  0x9c,  0xe9,  0x05,  0x1b,  0xa0,  0x3c,  0x20,  0x35,
/* 0x0358 */  0xeb,  0xa1,  0x44,  0x17,  0x03,  0xb6,  0xc0,  0xbf,
/* 0x0360 */  0xcf,  0x3f,  0x32,  0xe2,  0x0f,  0xff,  0x64,  0x59,
/* 0x0368 */  0x04,  0x93,  0x16,  0xa2,  0x58,  0x21,  0x48,  0x76,
/* 0x0370 */  0x74,  0xca,  0x84,  0x4e,  0x3f,  0x49,  0xad,  0x84,
/* 0x0378 */  0x16,  0xf0,  0xe9,  0x45,  0x7d,  0xe8,  0xac,  0x3d,
/* 0x0380 */  0x9f,  0x2d,  0xe4,  0x57,  0x0f,  0xbf,  0xce,  0x8e,
/* 0x0388 */  0x43,  0x2b,  0xff,  0xe0,  0x2e,  0xc5,  0x18,  0x7d,
/* 0x0390 */  0x68,  0x79,  0x05,  0xeb,  0xa0,  0x1d,  0x1e,  0x50,
/* 0x0398 */  0x9f,  0x8f,  0xc7,  0xa8,  0x0a,  0xd9,  0x49,  0xca,
/* 0x03a0 */  0xf5,  0x3b,  0x30,  0xec,  0xa9,  0xca,  0xd3,  0x7a,
/* 0x03a8 */  0x3d,  0x54,  0xfd,  0xaf,  0x72,  0x98,  0xd3,  0xd9,
/* 0x03b0 */  0xd5,  0xab,  0x57,  0xa1,  0xa5,  0xbd,  0xe8,  0xf5,
/* 0x03b8 */  0x8c,  0x0f,  0xe7,  0xe7,  0x9e,  0xa5,  0x1d,  0x1b,
/* 0x03c0 */  0x9a,  0xa6,  0x9d,  0x9f,  0x2b,  0xac,  0x50,  0xf6,
/* 0x03c8 */  0xfe,  0x05,  0x6a,  0x8a,  0x3e,  0x3c,  0xc2,  0x9f,
/* 0x03d0 */  0x60,  0x60,  0x59,  0x1c,  0x14,  0x0b,  0xf1,  0x58,
/* 0x03d8 */  0x43,  0x17,  0x6a,  0x7e,  0x4f,  0x74,  0x1d,  0xed,
/* 0x03e0 */  0x86,  0x17,  0x98,  0x5c,  0x04,  0xd3,  0x28,  0xe0,
/* 0x03e8 */  0xda,  0xd3,  0x84,  0x3b,  0x31,  0xbd,  0x24,  0x04,
/* 0x03f0 */  0x3a,  0x1b,  0x3d,  0x12,  0x98,  0x08,  0xac,  0x08,
/* 0x03f8 */  0xfb,  0xb8,  0x1b,  0x2c,  0xea,  0x5a,  0x29,  0xe8,
/* 0x0400 */  0x17,  0xa2,  0xa0,  0x14,  0x1f,  0x35,  0x9c,  0xdf,
/* 0x0408 */  0x51,  0x84,  0x73,  0xfd,  0xb8,  0x68,  0x9d,  0xe4,
/* 0x0410 */  0x5d,  0xe8,  0x3a,  0x87,  0xbe,  0x79,  0xcb,  0xaf,
/* 0x0418 */  0xed,  0xd0,  0xe1,  0xd7,  0x29,  0x79,  0x2d,  0x39,
/* 0x0420 */  0x45,  0x9a,  0x59,  0xe2,  0xfe,  0x4b,  0x7e,  0xfe,
/* 0x0428 */  0xf5,  0x4a,  0xcc,  0x8b,  0x7e,  0x5c,  0x0b,  0x4c,
/* 0x0430 */  0xe9,  0x87,  0x07,  0x07,  0x55,  0xe1,  0x4a,  0x36,
/* 0x0438 */  0x79,  0x7f,  0xdf,  0x7c,  0x40,  0xc1,  0x4a,  0x6d,
/* 0x0440 */  0xbc,  0x81,  0xe1,  0xc0,  0xed,  0x60,  0x4f,  0xc1,
/* 0x0448 */  0x4c,  0x98,  0x97,  0x99,  0xe3,  0x94,  0xbe,  0x81,
/* 0x0450 */  0x25,  0xbd,  0xe3,  0x9c,  0xc5,  0x4b,  0xdb,  0x98,
/* 0x0458 */  0x8f,  0x0d,  0x1d,  0xe2,  0x35,  0x39,  0x97,  0xc2,
/* 0x0460 */  0xda,  0x46,  0x27,  0xc3,  0x93,  0xa1,  0x4e,  0xf0,
/* 0x0468 */  0x74,  0x78,  0x6a,  0xba,  0x1e,  0x44,  0xcc,  0x40,
/* 0x0470 */  0x84,  0xb6,  0x32,  0x40,  0x0a,  0x9f,  0xa6,  0xcc,
/* 0x0478 */  0xa1,  0x20,  0x87,  0x19,  0x02,  0x51,  0x20,  0xa2,
/* 0x0480 */  0x7c,  0x69,  0x1f,  0xf8,  0xeb,  0xfb,  0x6c,  0xb9,
/* 0x0488 */  0xf4,  0xc1,  0x5e,  0x51,  0xbe,  0x84,  0x06,  0xe0,
/* 0x0490 */  0xa6,  0xbd,  0x86,  0x4e,  0x29,  0x04,  0x1b,  0x1d,
/* 0x0498 */  0x0d,  0xaa,  0xe0,  0x82,  0xdd,  0x15,  0xbd,  0xc5,
/* 0x04a0 */  0xdc,  0xe6,  0xee,  0x9d,  0x4c,  0x1d,  0x30,  0x74,
/* 0x04a8 */  0x65,  0x68,  0x1c,  0x82,  0x0f,  0xfa,  0x3f,  0xc8,
/* 0x04b0 */  0x39,  0xa0,  0xf5,  0xa4,  0x24,  0x57,  0x34,  0x29,
/* 0x04b8 */  0x9c,  0xb8,  0x90,  0x35,  0x97,  0x84,  0xda,  0x61,
/* 0x04c0 */  0x45,  0x4d,  0x2f,  0x5a,  0x9b,  0x16,  0x18,  0xb3,
/* 0x04c8 */  0xe8,  0xaa,  0x55,  0x64,  0x90,  0xea,  0xcd,  0xe9,
/* 0x04d0 */  0xe1,  0xa7,  0xeb,  0x9b,  0x1e,  0xc0,  0x09,  0x02,
/* 0x04d8 */  0xa2,  0x1c,  0x5d,  0xd2,  0x15,  0x68,  0xa2,  0x14,
/* 0x04e0 */  0x43,  0x67,  0x37,  0x8b,  0x3a,  0xb2,  0xb0,  0x33,
/* 0x04e8 */  0xe1,  0x8a,  0xa8,  0x2a,  0x1e,  0xc0,  0xbd,  0x30,
/* 0x04f0 */  0xc0,  0xee,  0xdd,  0xf3,  0x8b,  0x7c,  0x3c,  0xf8,
/* 0x04f8 */  0xd1,  0xef,  0xd7,  0xcc,  0x5d,  0x74,  0xbd,  0x21,
/* 0x0500 */  0x57,  0x71,  0x73,  0x5e,  0x99,  0x1e,  0x7c,  0xa0,
/* 0x0508 */  0xee,  0x07,  0x9f,  0x0e,  0x0f,  0xa4,  0xc1,  0x2b,
/* 0x0510 */  0xd0,  0xba,  0xb9,  0xba,  0xb8,  0x70,  0xb1,  0x95,
/* 0x0518 */  0xac,  0xb3,  0x84,  0xd0,  0xcd,  0x15,  0x48,  0x81,
/* 0x0520 */  0xbf,  0xfb,  0xfd,  0xc5,  0xe1,  0xc1,  0x63,  0x6e,
/* 0x0528 */  0xbe,  0x28,  0xdd,  0xf9,  0xf9,  0x05,  0x33,  0x72,
/* 0x0530 */  0xfb,  0x05,  0x24,  0xa3,  0x95,  0x3a,  0x9c,  0x68,
/* 0x0538 */  0xc3,  0x80,  0xef,  0x65,  0xa6,  0xf9,  0x70,  0xfb,
/* 0x0540 */  0x83,  0xbd,  0xec,  0xdf,  0x15,  0xf4,  0xdf,  0x90,
/* 0x0548 */  0x68,  0x0c,  0x45,  0x53,  0x96,  0x13,  0x21,  0x55,
/* 0x0550 */  0x0d,  0x2e,  0x7a,  0x19,  0x7f,  0000,  0xca,  0x14,
/* 0x0558 */  0x7d,  0x8a,  0xa5,  0x16,  0x29,  0x28,  0xb8,  0x6e,
/* 0x0560 */  0xcf,  0xc3,  0xa4,  0x20,  0x77,  0x16,  0x0e,  0xfa,
/* 0x0568 */  0x0a,  0xca,  0x56,  0x23,  0xc8,  0x45,  0x20,  0x83,
/* 0x0570 */  0x04,  0x9f,  0xcc,  0x4c,  0x1f,  0x72,  0x03,  0xc8,
/* 0x0578 */  0x29,  0xb3,  0x84,  0xf2,  0x4d,  0xc9,  0xa1,  0x9c,
/* 0x0580 */  0x20,  0x05,  0x06,  0x05,  0xbb,  0x10,  0xcb,  0x40,
/* 0x0588 */  0x7b,  0x6e,  0x24,  0x92,  0xda,  0xd2,  0x0a,  0x38,
/* 0x0590 */  0xe4,  0x60,  0x0e,  0xe5,  0xa0,  0x6d,  0xae,  0x48,
/* 0x0598 */  0000,  0x46,  0x45,  0x54,  0x0d,  0x3c,  0xb9,  0xf3,
/* 0x05a0 */  0x03,  0xaf,  0x07,  0xdc,  0x36,  0x85,  0x0b,  0xc4,
/* 0x05a8 */  0x14,  0xc1,  0x73,  0x6f,  0xb9,  0x47,  0xc9,  0x8c,
/* 0x05b0 */  0x85,  0xf9,  0xab,  0x0d,  0x79,  0x9e,  0x09,  0x19,
/* 0x05b8 */  0xc7,  0x31,  0xb3,  0x4c,  0xfb,  0xf6,  0xde,  0x8c,
/* 0x05c0 */  0x1d,  0x1d,  0x0c,  0xe1,  0x50,  0x9a,  0x6b,  0x16,
/* 0x05c8 */  0x27,  0xfc,  0x44,  0x44,  0xba,  0x1c,  0x90,  0x03,
/* 0x05d0 */  0x02,  0x64,  0x1b,  0x1e,  0xa5,  0x04,  0x3d,  0xfc,
/* 0x05d8 */  0xfb,  0xfc,  0xdc,  0xd0,  0x58,  0xbf,  0xe9,  0x20,
/* 0x05e0 */  0x7b,  0x47,  0x91,  0xd6,  0x07,  0x99,  0x0d,  0x4d,
/* 0x05e8 */  0xca,  0xf9,  0x16,  0x12,  0x48,  0xfe,  0x60,  0xfa,
/* 0x05f0 */  0x90,  0xa2,  0x0a,  0x8b,  0x4f,  0x36,  0xbe,  0x15,
/* 0x05f8 */  0x7a,  0x15,  0x63,  0x44,  0x61,  0x97,  0x2e,  0x68,
/* 0x0600 */  0x0e,  0xd7,  0x91,  0x72,  0x2e,  0x08,  0xe9,  0x90,
/* 0x0608 */  0x16,  0x92,  0xed,  0x09,  0x51,  0x97,  0x6e,  0x9c,
/* 0x0610 */  0xa4,  0x62,  0x9e,  0x92,  0x92,  0xa4,  0xc1,  0000,
/* 0x0618 */  0x52,  0x91,  0x7f,  0xa7,  0x95,  0xa8,  0x46,  0xd5,
/* 0x0620 */  0xb4,  0x15,  0xc2,  0xe1,  0x8b,  0x17,  0xf0,  0x99,
/* 0x0628 */  0x66,  0xf8,  0xea,  0x55,  0x4f,  0x2a,  0xe1,  0xb8,
/* 0x0630 */  0xd2,  0x0d,  0x72,  0xea,  0x8b,  0x8b,  0x9a,  0x35,
/* 0x0638 */  0x69,  0x85,  0x09,  0x8a,  0xb0,  0x50,  0x21,  0x58,
/* 0x0640 */  0xe0,  0x77,  0x19,  0x23,  0x6e,  0x0a,  0x7b,  0xc3,
/* 0x0648 */  0x3f,  0x97,  0x54,  0x97,  0x80,  0x20,  0x50,  0x16,
/* 0x0650 */  0x40,  0x2e,  0xac,  0xb3,  0x67,  0xef,  0x29,  0xe7,
/* 0x0658 */  0xa3,  0x69,  0x8a,  0x64,  0x19,  0x83,  0x08,  0x78,
/* 0x0660 */  0xe9,  0x20,  0xe1,  0x2f,  0xd9,  0xf3,  0x2f,  0x1e,
/* 0x0668 */  0x7e,  0x0b,  0x9e,  0xe9,  0x34,  0x36,  0xa9,  0x97,
/* 0x0670 */  0x3f,  0000,  0x90,  0x7b,  0xa8,  0xea,  0x47,  0x2a,
/* 0x0678 */  0x0c,  0x2e,  0x25,  0xd1,  0x6d,  0000,  0x4a,  0x97,
/* 0x0680 */  0x4e,  0x1b,  0xf9,  0x25,  0x6b,  0x99,  0xf1,  0x4a,
/* 0x0688 */  0xcf,  0x2d,  0xdd,  0x3f,  0xf4,  0xe6,  0x09,  0xf6,
/* 0x0690 */  0x4f,  0x38,  0x64,  0x91,  0xb0,  0x06,  0x89,  0x49,
/* 0x0698 */  0xc9,  0x70,  0x0f,  0xb8,  0x86,  0x01,  0x60,  0x08,
/* 0x06a0 */  0xeb,  0x27,  0x4a,  0x3d,  0xd5,  0x34,  0xd3,  0x33,
/* 0x06a8 */  0x61,  0x21,  0x22,  0x33,  0x36,  0xa1,  0xb0,  0x8b,
/* 0x06b0 */  0xc8,  0xbd,  0xcb,  0x20,  0x42,  0xc1,  0xc3,  0xd0,
/* 0x06b8 */  0x60,  0x0c,  0x63,  0x2c,  0x0b,  0x3a,  0xd3,  0xf3,
/* 0x06c0 */  0x43,  0xf4,  0x02,  0x3c,  0xc6,  0xb0,  0x80,  0xf5,
/* 0x06c8 */  0x84,  0xb9,  0xe4,  0xe4,  0xec,  0x65,  0x01,  0x21,
/* 0x06d0 */  0x18,  0xc6,  0x2b,  0xc8,  0x83,  0x41,  0x7a,  0x1b,
/* 0x06d8 */  0x2c,  0x03,  0xb3,  0xda,  0x15,  0xb8,  0xfb,  0x40,
/* 0x06e0 */  0xac,  0xfd,  0x91,  0x70,  0x0c,  0x31,  0x90,  0xa7,
/* 0x06e8 */  0x14,  0x8b,  0x54,  0x6f,  0x8e,  0xf9,  0xe2,  0x8a,
/* 0x06f0 */  0xc7,  0x49,  0x2e,  0xda,  0x6b,  0xb4,  0xf2,  0xc0,
/* 0x06f8 */  0x01,  0x8c,  0x13,  0x26,  0xbe,  0x70,  0xf8,  0x12,
/* 0x0700 */  0x61,  0xf7,  0xfa,  0x87,  0x6f,  0xdf,  0x5e,  0xbf,
/* 0x0708 */  0xf9,  0xea,  0x6f,  0x5f,  0x5f,  0xbe,  0x7f,  0x87,
/* 0x0710 */  0xb2,  0xe5,  0xdf,  0xbf,  0xff,  0xe1,  0xf2,  0x7d,
/* 0x0718 */  0xeb,  0xf7,  0x6f,  0x2e,  0xdf,  0x55,  0x1a,  0xf2,
/* 0x0720 */  0xa2,  0xcb,  0x37,  0x57,  0xae,  0x0d,  0x51,  0x40,
/* 0x0728 */  0x80,  0x16,  0xa5,  0x48,  0x4e,  0x4e,  0x9a,  0x43,
/* 0x0730 */  0xbd,  0x7f,  0x77,  0xf9,  0x8f,  0x6f,  0x21,  0xab,
/* 0x0738 */  0xae,  0x0e,  0x24,  0xbe,  0x0e,  0x67,  0xb3,  0xda,
/* 0x0740 */  0x38,  0xe2,  0xfb,  0x68,  0x20,  0xb3,  0x06,  0xa8,
/* 0x0748 */  0x40,  0xae,  0xf3,  0x08,  0xb5,  0xbf,  0xb3,  0xc5,
/* 0x0750 */  0x96,  0x35,  0x24,  0xc6,  0xd7,  0x0a,  0xf2,  0xca,
/* 0x0758 */  0x51,  0xaf,  0x64,  0xb7,  0x8a,  0x93,  0xa1,  0xee,
/* 0x0760 */  0x0a,  0x8c,  0x9b,  0xdd,  0x05,  0x57,  0x07,  0xaa,
/* 0x0768 */  0xe5,  0x0a,  0xdb,  0x52,  0xea,  0x76,  0xbe,  0x44,
/* 0x0770 */  0xa0,  0x32,  0x56,  0x08,  0x4a,  0xcf,  0xfd,  0x1d,
/* 0x0778 */  0xba,  0x5b,  0xd5,  0x25,  0xe6,  0x93,  0x16,  0x96,
/* 0x0780 */  0x5e,  0x58,  0xb8,  0x30,  0xe1,  0x44,  0x34,  0x37,
/* 0x0788 */  0xf2,  0x84,  0x40,  0x17,  0xae,  0x18,  0xe0,  0xa4,
/* 0x0790 */  0x0b,  0x30,  0xb9,  0xe0,  0xfb,  0x4d,  0xef,  0x54,
/* 0x0798 */  0x4d,  0x7a,  0x08,  0x6f,  0x14,  0x09,  0x5c,  0xc4,
/* 0x07a0 */  0x87,  0xcd,  0xab,  0xa9,  0x82,  0x26,  0x93,  0x22,
/* 0x07a8 */  0x15,  0xc6,  0x53,  0x84,  0x57,  0x6e,  0x26,  0x4a,
/* 0x07b0 */  0x36,  0x54,  0xf8,  0xeb,  0x42,  0xe3,  0xba,  0x98,
/* 0x07b8 */  0x30,  0xfc,  0x65,  0xc3,  0x98,  0x8b,  0xc3,  0x3c,
/* 0x07c0 */  0x92,  0x91,  0x1f,  0x87,  0x2f,  0xd7,  0xf7,  0xdc,
/* 0x07c8 */  0x8d,  0x1d,  0x50,  0x45,  0xb0,  0x02,  0x5d,  0x94,
/* 0x07d0 */  0xf8,  0xb8,  0x22,  0x21,  0x2e,  0xd8,  0x27,  0x66,
/* 0x07d8 */  0x4c,  0xc0,  0x5d,  0x4e,  0xe1,  0xff,  0x33,  0x9d,
/* 0x07e0 */  0x0d,  0x74,  0x06,  0x7f,  0xc2,  0x8f,  0xb9,  0xce,
/* 0x07e8 */  0xf0,  0x33,  0xfc,  0x1e,  0xc3,  0x5f,  0x90,  0xa9,
/* 0x07f0 */  0x9d,  0xc1,  0x5f,  0x90,  0x99,  0x8d,  0xe0,  0x2f,
/* 0x07f8 */  0xf8,  0x3f,  0xfc,  0xcb,  0xc0,  0x2f,  0xf0,  0xdf,
/* 0x0800 */  0x98,  0x3d,  0x2e,  0x72,  0x81,  0x68,  0x40,  0x65,
/* 0x0808 */  0xad,  0x94,  0xe1,  0x9a,  0x59,  0x09,  0xf6,  0x55,
/* 0x0810 */  0x96,  0xa9,  0xd6,  0x17,  0xbb,  0x34,  0x53,  0x19,
/* 0x0818 */  0x2b,  0x6f,  0x8a,  0x39,  0x96,  0x98,  0xe0,  0xb5,
/* 0x0820 */  0xa8,  0x6a,  0x41,  0xf5,  0x41,  0xf5,  0xcb,  0x31,
/* 0x0828 */  0xb8,  0x72,  0xf4,  0xe3,  0xcb,  0xad,  0xda,  0x3c,
/* 0x0830 */  0x51,  0xea,  0x2a,  0x60,  0x72,  0x7d,  0x67,  0x7a,
/* 0x0838 */  0x14,  0xde,  0x50,  0x97,  0xa0,  0x0e,  0xa5,  0x22,
/* 0x0840 */  0x10,  0x40,  0x87,  0x84,  0x7b,  0x4c,  0xce,  0x8e,
/* 0x0848 */  0xd4,  0xbc,  0xbb,  0x07,  0x4e,  0x69,  0x4b,  0x8f,
/* 0x0850 */  0x33,  0x6d,  0xd1,  0x88,  0x11,  0x67,  0x7d,  0x41,
/* 0x0858 */  0xa1,  0x86,  0x87,  0xba,  0x06,  0x9b,  0x4b,  0x78,
/* 0x0860 */  0x73,  0x75,  0x25,  0xf1,  0xd3,  0x3e,  0xd2,  0x48,
/* 0x0868 */  0x19,  0x09,  0x47,  0x51,  0x5c,  0x42,  0xe7,  0x81,
/* 0x0870 */  0xf2,  0x78,  0xdf,  0x2c,  0x25,  0xaa,  0xd4,  0xba,
/* 0x0878 */  0xe2,  0x78,  0xa8,  0x78,  0x60,  0xf5,  0xe5,  0xd5,
/* 0x0880 */  0x2b,  0x5e,  0x50,  0x13,  0x65,  0x8b,  0x5c,  0xc2,
/* 0x0888 */  0x7c,  0x14,  0xb9,  0x1c,  0xd5,  0x0c,  0x35,  0x57,
/* 0x0890 */  0xd6,  0x70,  0x3c,  0xed,  0xd3,  0x1a,  0xb5,  0x05,
/* 0x0898 */  0x53,  0xac,  0x2a,  0xd5,  0x2c,  0xb1,  0x50,  0xc6,
/* 0x08a0 */  0xd3,  0x72,  0xee,  0x25,  0x6a,  0x11,  0xb0,  0xad,
/* 0x08a8 */  0x73,  0x63,  0x82,  0xb1,  0xb6,  0xee,  0xeb,  0x28,
/* 0x08b0 */  0xa3,  0x2d,  0x0a,  0x5f,  0xee,  0x41,  0xd0,  0x13,
/* 0x08b8 */  0xfd,  0x31,  0x56,  0x0b,  0x12,  0x91,  0x21,  0x03,
/* 0x08c0 */  0x74,  0x6f,  0xc1,  0x7b,  0x02,  0xe4,  0xe0,  0xd7,
/* 0x08c8 */  0xed,  0x96,  0x25,  0x1c,  0x6a,  0x14,  0xb3,  0x85,
/* 0x08d0 */  0x02,  0x3c,  0x52,  0x80,  0x77,  0x7e,  0xdb,  0x1f,
/* 0x08d8 */  0x61,  0x76,  0x70,  0xd3,  0xf7,  0x54,  0x5d,  0x78,
/* 0x08e0 */  0x22,  0xfd,  0xc6,  0x51,  0x1b,  0x32,  0xf5,  0x3d,
/* 0x08e8 */  0x94,  0xaa,  0xf1,  0xf9,  0xd8,  0x10,  0x29,  0xc1,
/* 0x08f0 */  0x0d,  0x15,  0xcb,  0xc7,  0x86,  0xcc,  0x0f,  0xca,
/* 0x08f8 */  0xc5,  0x80,  0x91,  0x8e,  0x3d,  0xb2,  0xab,  0xf7,
/* 0x0900 */  0xdf,  0x5f,  0xbe,  0x63,  0xf0,  0xdf,  0xbb,  0x1f,
/* 0x0908 */  0xd9,  0x87,  0xbf,  0xfc,  0xf0,  0xf7,  0xcf,  0xd1,
/* 0x0910 */  0x76,  0x0e,  0xd4,  0x85,  0xda,  0xc2,  0xfc,  0x71,
/* 0x0918 */  0x8b,  0x22,  0xa6,  0x1d,  0x15,  0x31,  0xfa,  0x23,
/* 0x0920 */  0x15,  0x31,  0xd8,  0x67,  0xd6,  0xd5,  0xe9,  0x0d,
/* 0x0928 */  0x76,  0xcc,  0x65,  0xd6,  0x71,  0x2e,  0xd3,  0xf6,
/* 0x0930 */  0xb9,  0x18,  0xc6,  0x7f,  0x67,  0x32,  0x86,  0xb1,
/* 0x0938 */  0x63,  0x36,  0x8f,  0x15,  0x0f,  0xa1,  0xa4,  0x07,
/* 0x0940 */  0xaa,  0x71,  0xb5,  0x62,  0xbc,  0xdd,  0x1d,  0xd4,
/* 0x0948 */  0xba,  0xea,  0x4a,  0xc6,  0x21,  0xcd,  0xac,  0x16,
/* 0x0950 */  0xed,  0xf5,  0x4a,  0xf2,  0xd3,  0xe2,  0x1b,  0xcb,
/* 0x0958 */  0xc9,  0x54,  0x44,  0xaa,  0x27,  0x03,  0x24,  0x53,
/* 0x0960 */  0xe1,  0xc6,  0xd5,  0x49,  0x19,  0x7d,  0xe1,  0xb0,
/* 0x0968 */  0x55,  0x72,  0x40,  0xf4,  0x6b,  0x88,  0xf4,  0x9b,
/* 0x0970 */  0x30,  0x63,  0x49,  0xc4,  0x3d,  0xef,  0x25,  0xfb,
/* 0x0978 */  0xe7,  0x3f,  0xed,  0x30,  0xda,  0x1c,  0x47,  0x90,
/* 0x0980 */  0x53,  0xf2,  0x2f,  0xbf,  0xfc,  0x93,  0x88,  0x0d,
/* 0x0988 */  0xff,  0x4f,  0xbf,  0xd2,  0x3a,  0xc1,  0xff,  0x99,
/* 0x0990 */  0x63,  0x29,  0x95,  0xa6,  0x22,  0xb0,  0x21,  0x93,
/* 0x0998 */  0x74,  0x2c,  0x8d,  0xef,  0x2d,  0x9e,  0xe5,  0x7f,
/* 0x09a0 */  0xe5,  0x09,  0x3a,  0x49,  0x3e,  0xd8,  0x57,  0xca,
/* 0x09a8 */  0x3f,  0xdc,  0xc6,  0xff,  0x08,  0x31,  0x6b,  0xc6,
/* 0x09b0 */  0xab,  0x24,  0xf1,  0x4f,  0x9b,  0xca,  0x16,  0xf3,
/* 0x09b8 */  0xad,  0xf5,  0xd5,  0xd5,  0xd2,  0x20,  0x37,  0xe0,
/* 0x09c0 */  0x5a,  0x5a,  0xad,  0x57,  0xcb,  0x94,  0xa2,  0x06,
/* 0x09c8 */  0xc4,  0x3a,  0xa5,  0x67,  0xbb,  0xb1,  0x9d,  0x41,
/* 0x09d0 */  0x5d,  0xa5,  0xb1,  0x30,  0x4b,  0xb1,  0xa2,  0xb2,
/* 0x09d8 */  0x20,  0xc9,  0xa6,  0x03,  0x12,  0x3a,  0xaa,  0xf3,
/* 0x09e0 */  0x38,  0x68,  0x2d,  0x83,  0x9c,  0x3a,  0x36,  0xed,
/* 0x09e8 */  0x5b,  0xac,  0xb1,  0x70,  0x6b,  0x20,  0xe6,  0xd0,
/* 0x09f0 */  0x83,  0x43,  0x76,  0x2c,  0x92,  0x5c,  0xe4,  0xf5,
/* 0x09f8 */  0xc6,  0x0d,  0x68,  0xd7,  0x4b,  0x50,  0x53,  0xc1,
/* 0x0a00 */  0x83,  0x67,  0x15,  0xb8,  0xa5,  0x8a,  0xe9,  0x34,
/* 0x0a08 */  0xd5,  0x88,  0x59,  0xc2,  0x97,  0x99,  0xc7,  0xc0,
/* 0x0a10 */  0xfe,  0x33,  0x5e,  0x29,  0x85,  0xbe,  0xfe,  0xf0,
/* 0x0a18 */  0xdd,  0x77,  0xdf,  0xfe,  0x7c,  0x2d,  0xaa,  0x9b,
/* 0x0a20 */  0xe1,  0x74,  0x32,  0x23,  0x96,  0x3f,  0xd1,  0x26,
/* 0x0a28 */  0x7f,  0x8c,  0xd5,  0x26,  0xa5,  0xf8,  0x90,  0x06,
/* 0x0a30 */  0x9a,  0xb6,  0xfc,  0x60,  0x41,  0xfe,  0xe8,  0x38,
/* 0x0a38 */  0xe2,  0x04,  0000,  0x1b,  0xe5,  0xb0,  0xc0,  0x33,
/* 0x0a40 */  0xc1,  0x13,  0x1c,  0xbb,  0x96,  0x8a,  0x52,  0xeb,
/* 0x0a48 */  0x75,  0x94,  0xca,  0xfc,  0x25,  0x9f,  0xbc,  0xa4,
/* 0x0a50 */  0x02,  0x60,  0x70,  0x6f,  0xd9,  0x46,  0x4c,  0xa9,
/* 0x0a58 */  0xa7,  0xe8,  0xf5,  0xab,  0x22,  0x24,  0x98,  0x8e,
/* 0x0a60 */  0xa8,  0xc0,  0xa2,  0x0c,  0xeb,  0x65,  0x28,  0xac,
/* 0x0a68 */  0xab,  0x14,  0xf6,  0xba,  0x2c,  0x5e,  0xde,  0xa5,
/* 0x0a70 */  0x78,  0x9a,  0x82,  0x2e,  0x89,  0x76,  0xf8,  0x65,
/* 0x0a78 */  0xf9,  0x59,  0xd1,  0x35,  0xc3,  0x7d,  0x67,  0xac,
/* 0x0a80 */  0xdf,  0x37,  0x38,  0x2f,  0x28,  0xff,  0x63,  0x97,
/* 0x0a88 */  0xdf,  0xa1,  0xe8,  0xcb,  0xa2,  0xfa,  0x10,  0x25,
/* 0x0a90 */  0x70,  0xa1,  0x77,  0x87,  0x99,  0x2b,  0x3a,  0xb6,
/* 0x0a98 */  0x91,  0x25,  0x86,  0x14,  0xb1,  0x9c,  0x67,  0xbf,
/* 0x0aa0 */  0x4f,  0xfb,  0x76,  0xeb,  0x45,  0xd1,  0x48,  0xb3,
/* 0x0aa8 */  0x7f,  0x7e,  0xa1,  0xea,  0xba,  0xba,  0xc9,  0x8e,
/* 0x0ab0 */  0x92,  0xd3,  0x84,  0x40,  0xc4,  0xca,  0xf6,  0x3e,
/* 0x0ab8 */  0xd5,  0x42,  0xea,  0x56,  0xba,  0x90,  0xaf,  0x98,
/* 0x0ac0 */  0x93,  0x4e,  0x1d,  0xe8,  0x9f,  0x50,  0xc6,  0xe3,
/* 0x0ac8 */  0xd9,  0x54,  0xb9,  0xa1,  0x56,  0xc3,  0x94,  0x14,
/* 0x0ad0 */  0x57,  0xee,  0x70,  0x48,  0xa9,  0x7b,  0x8a,  0xd8,
/* 0x0ad8 */  0x3d,  0x45,  0xbc,  0x63,  0x1a,  0x57,  0x7b,  0x5e,
/* 0x0ae0 */  0x55,  0xfc,  0xa3,  0x52,  0xfc,  0x8a,  0x63,  0xe1,
/* 0x0ae8 */  0x3d,  0x4b,  0x5f,  0x65,  0x97,  0xf1,  0xa9,  0xf2,
/* 0x0af0 */  0xb7,  0x65,  0x83,  0xf1,  0xa9,  0x12,  0x58,  0xe5,
/* 0x0af8 */  0xfe,  0x64,  0x19,  0xdc,  0xc6,  0x7f,  0x57,  0x29,
/* 0x0b00 */  0x4c,  0x44,  0x38,  0x6b,  0xd6,  0x3b,  0x62,  0xb6,
/* 0x0b08 */  0xe9,  0x79,  0x68,  0x84,  0x5a,  0x1d,  0x75,  0x8e,
/* 0x0b10 */  0xa6,  0x6c,  0x76,  0x0a,  0xb3,  0000,  0x7b,  0xc9,
/* 0x0b18 */  0xc0,  0x28,  0x95,  0x73,  0x62,  0x3a,  0xcb,  0x7e,
/* 0x0b20 */  0x0d,  0x2c,  0x0a,  0x3e,  0xb8,  0x53,  0x42,  0xbb,
/* 0x0b28 */  0x6d,  0x85,  0x81,  0x15,  0xa8,  0x2b,  0xe9,  0xb8,
/* 0x0b30 */  0xd3,  0xbe,  0xfd,  0x68,  0x51,  0x41,  0x76,  0xbf,
/* 0x0b38 */  0xc6,  0x43,  0xe9,  0x1e,  0x33,  0x98,  0x26,  0xe3,
/* 0x0b40 */  0xf1,  0xd6,  0x68,  0xfc,  0x74,  0xfa,  0xb1,  0x47,
/* 0x0b48 */  0xfe,  0x91,  0x47,  0x62,  0x76,  0xce,  0x86,  0xe3,
/* 0x0b50 */  0x89,  0xf4,  0xa2,  0x34,  0xef,  0x1f,  0x44,  0x4d,
/* 0x0b58 */  0x9f,  0x27,  0x07,  0x98,  0x1e,  0x1c,  0x14,  0x46,
/* 0x0b60 */  0x5a,  0xd5,  0x97,  0xc6,  0x2c,  0x0c,  0x01,  0x85,
/* 0x0b68 */  0x1a,  0x5a,  0x9b,  0x05,  0x13,  0xe1,  0xcc,  0x6b,
/* 0x0b70 */  0x11,  0xa7,  0x36,  0xf2,  0xb7,  0xa2,  0x96,  0xb5,
/* 0x0b78 */  0xbc,  0x10,  0x78,  0x15,  0xc3,  0x0b,  0xa4,  0x2f,
/* 0x0b80 */  0x1a,  0xf4,  0xaf,  0x90,  0x7e,  0xaa,  0xd2,  0x7f,
/* 0x0b88 */  0x8d,  0x32,  0x14,  0x06,  0x5e,  0x99,  0x40,  0x55,
/* 0x0b90 */  0xe3,  0xa0,  0xf2,  0xea,  0x17,  0xb9,  0x37,  0x4e,
/* 0x0b98 */  0x56,  0xd8,  0x68,  0xc3,  0x20,  0x98,  0xdc,  0xbb,
/* 0x0ba0 */  0x29,  0xac,  0x2f,  0x8e,  0x4b,  0x61,  0x8c,  0xa2,
/* 0x0ba8 */  0xa4,  0x8d,  0x87,  0x5c,  0x20,  0xc3,  0xcb,  0xfc,
/* 0x0bb0 */  0xf0,  0xe5,  0x82,  0x8d,  0x16,  0xcc,  0x82,  0x50,
/* 0x0bb8 */  0x79,  0xbb,  0x50,  0xda,  0x67,  0x4a,  0xfb,  0x59,
/* 0x0bc0 */  0x4b,  0xfb,  0x5c,  0x69,  0x1f,  0x37,  0xdb,  0x27,
/* 0x0bc8 */  0x03,  0xa5,  0x7d,  0xd2,  0xd2,  0x6e,  0x28,  0xed,
/* 0x0bd0 */  0xd3,  0x96,  0xf6,  0xa1,  0xd2,  0x3e,  0x6b,  0x69,
/* 0x0bd8 */  0x1f,  0x29,  0xed,  0xf3,  0x96,  0xf6,  0x33,  0xa5,
/* 0x0be0 */  0xdd,  0x18,  0xb4,  0x74,  0x18,  0xab,  0x1d,  0x0c,
/* 0x0be8 */  0xd6,  0x6f,  0x4d,  0x16,  0x0c,  0xad,  0x85,  0x72,
/* 0x0bf0 */  0xa2,  0x52,  0x8e,  0xba,  0x50,  0xaa,  0x4a,  0x37,
/* 0x0bf8 */  0xc6,  0x5d,  0x28,  0xd5,  0xe5,  0x80,  0xc4,  0xac,
/* 0x0c00 */  0x03,  0xa5,  0xba,  0x50,  0xc6,  0x7c,  0x0b,  0xe5,
/* 0x0c08 */  0xb0,  0x85,  0x72,  0xaa,  0x2e,  0xe1,  0x70,  0xd4,
/* 0x0c10 */  0x85,  0x52,  0x5d,  0xdc,  0xe1,  0xb4,  0x0b,  0xa5,
/* 0x0c18 */  0xba,  0xec,  0x23,  0xa3,  0x0b,  0xa5,  0x0a,  0x88,
/* 0x0c20 */  0xd1,  0x36,  0xdd,  0x8e,  0xda,  0x28,  0x55,  0xa8,
/* 0x0c28 */  0x9c,  0x8d,  0xba,  0x50,  0xaa,  0x18,  0x1a,  0x1b,
/* 0x0c30 */  0x5d,  0x28,  0x55,  0x0c,  0x8d,  0xe7,  0x5d,  0x28,
/* 0x0c38 */  0x55,  0x0c,  0x4d,  0xb6,  0xe9,  0xf6,  0xac,  0x8d,
/* 0x0c40 */  0x52,  0xc5,  0xd0,  0x6c,  0xd4,  0x85,  0x52,  0xc5,
/* 0x0c48 */  0xd0,  0x7c,  0xde,  0x81,  0x72,  0x36,  0xa8,  0x58,
/* 0x0c50 */  0xd9,  0xb8,  0x0b,  0xa9,  0x51,  0x31,  0xb3,  0x6d,
/* 0x0c58 */  0xda,  0x1d,  0xb7,  0x91,  0xaa,  0x28,  0x32,  0x26,
/* 0x0c60 */  0xa3,  0x2e,  0xa4,  0xa3,  0x8a,  0xb9,  0x8c,  0xbb,
/* 0x0c68 */  0x90,  0xaa,  0x38,  0x1a,  0x6e,  0x85,  0x7d,  0x2b,
/* 0x0c70 */  0xa9,  0x0a,  0x24,  0xf0,  0xbd,  0x6a,  0x0f,  0x48,
/* 0x0c78 */  0x95,  0xcd,  0xcc,  0x4b,  0x5f,  0x8a,  0x3a,  0xa4,
/* 0x0c80 */  0x79,  0x1c,  0xf4,  0x21,  0xe0,  0x0f,  0x11,  0xb7,
/* 0x0c88 */  0xf1,  0xbc,  0xbb,  0xb6,  0xb1,  0x4d,  0x7b,  0xe3,
/* 0x0c90 */  0xcf,  0x1d,  0x3a,  0x0f,  0xb2,  0x44,  0xd5,  0xa3,
/* 0x0c98 */  0x9e,  0x07,  0x1d,  0x60,  0x7c,  0x3b,  0xb0,  0xb6,
/* 0x0ca0 */  0x47,  0xec,  0xa7,  0x2a,  0x8e,  0x83,  0x3d,  0x0a,
/* 0x0ca8 */  0x0e,  0x25,  0x06,  0x35,  0x82,  0x10,  0x60,  0x43,
/* 0x0cb0 */  0xee,  0xd7,  0x1a,  0x0d,  0x95,  0x18,  0x45,  0xdb,
/* 0x0cb8 */  0xb0,  0xa9,  0xae,  0xa2,  0xad,  0x19,  0xb8,  0x46,
/* 0x0cc0 */  0x45,  0x5b,  0x33,  0x68,  0x9d,  0x15,  0x6d,  0x1d,
/* 0x0cc8 */  0x5c,  0xef,  0xb8,  0x20,  0xea,  0xe0,  0x75,  0x27,
/* 0x0cd0 */  0x05,  0x51,  0x07,  0x87,  0x3b,  0x2d,  0xd5,  0xd1,
/* 0x0cd8 */  0xc1,  0xd9,  0xce,  0x4a,  0xaa,  0xe9,  0xfe,  0x6e,
/* 0x0ce0 */  0x64,  0x5e,  0xaa,  0xb7,  0x83,  0xab,  0x34,  0xca,
/* 0x0ce8 */  0x15,  0x1b,  0x75,  0xf0,  0x1f,  0x46,  0xb9,  0x98,
/* 0x0cf0 */  0x67,  0x1d,  0x9c,  0x87,  0x51,  0xae,  0xf3,  0xa4,
/* 0x0cf8 */  0x83,  0x1d,  0x1a,  0x25,  0x04,  0xe6,  0x1d,  0x6c,
/* 0x0d00 */  0xd0,  0x28,  0xd1,  0x61,  0x0c,  0xb7,  0x49,  0x39,
/* 0x0d08 */  0x69,  0xa1,  0x2b,  0x01,  0x62,  0xcc,  0x47,  0x1d,
/* 0x0d10 */  0xe8,  0x26,  0xca,  0x12,  0x6c,  0x93,  0x73,  0xda,
/* 0x0d18 */  0x42,  0x57,  0xc2,  0x64,  0x34,  0x1b,  0x77,  0xa0,
/* 0x0d20 */  0x2b,  0x81,  0x32,  0xde,  0x8a,  0xaf,  0x59,  0x0b,
/* 0x0d28 */  0x5d,  0x09,  0x95,  0xe9,  0x64,  0xbe,  0x3f,  0xdd,
/* 0x0d30 */  0x50,  0xb1,  0xee,  0xc1,  0x56,  0x90,  0xcd,  0x5b,
/* 0x0d38 */  0x08,  0x4b,  0xb4,  0x18,  0xe3,  0xd1,  0xb4,  0x03,
/* 0x0d40 */  0x61,  0x89,  0x97,  0xe1,  0x60,  0x2b,  0xd0,  0x8c,
/* 0x0d48 */  0x41,  0x0b,  0x65,  0x09,  0x99,  0xd1,  0x60,  0x3a,
/* 0x0d50 */  0xea,  0x42,  0x59,  0xa2,  0xe6,  0x6c,  0xb0,  0x15,
/* 0x0d58 */  0x6e,  0x46,  0x5b,  0x62,  0x56,  0xe2,  0x66,  0x62,
/* 0x0d60 */  0x9c,  0x8d,  0xbb,  0x50,  0x96,  0xc8,  0x99,  0x6d,
/* 0x0d68 */  0x87,  0x9c,  0xd1,  0x9a,  0x24,  0x29,  0x18,  0x1f,
/* 0x0d70 */  0xce,  0xe6,  0x5d,  0x48,  0x15,  0x3f,  0x33,  0xd9,
/* 0x0d78 */  0x0e,  0x3c,  0xa3,  0x2d,  0x65,  0x51,  0x9c,  0xcd,
/* 0x0d80 */  0xd9,  0x78,  0x3a,  0xdd,  0x8f,  0xb4,  0x43,  0xd8,
/* 0x0d88 */  0xcb,  0x8f,  0x6c,  0xf7,  0x0b,  0x78,  0xd5,  0x8d,
/* 0x0d90 */  0xbf,  0xe2,  0xf6,  0x47,  0xb1,  0xd7,  0xf7,  0xa9,
/* 0x0d98 */  0x76,  0x5e,  0x2d,  0x37,  0x76,  0xc4,  0xa6,  0x22,
/* 0x0da0 */  0x1e,  0x4a,  0xe2,  0x9d,  0x3f,  0xb9,  0x5b,  0x42,
/* 0x0da8 */  0x1b,  0x15,  0x72,  0x9c,  0xa2,  0xda,  0xb4,  0xd7,
/* 0x0db0 */  0xf9,  0xa7,  0xb2,  0xc4,  0xcc,  0xbf,  0x3d,  0x2a,
/* 0x0db8 */  0x85,  0xe5,  0x63,  0xb1,  0xa5,  0xe1,  0x06,  0x4b,
/* 0x0dc0 */  0x0f,  0x6f,  0x0e,  0xed,  0xb9,  0xa3,  0xd1,  0x69,
/* 0x0dc8 */  0x43,  0xe0,  0x8d,  0x09,  0x82,  0x56,  0xef,  0x8b,
/* 0x0dd0 */  0x17,  0xd7,  0xbd,  0x51,  0x15,  0x74,  0xe6,  0xcd,
/* 0x0dd8 */  0xc5,  0xf8,  0x3e,  0x4f,  0xd7,  0xa1,  0x53,  0x39,
/* 0x0de0 */  0xbe,  0xb6,  0xf0,  0x2a,  0x07,  0x68,  0x33,  0xdd,
/* 0x0de8 */  0x44,  0x7c,  0x71,  0xf8,  0xf4,  0x2d,  0x82,  0xc6,
/* 0x0df0 */  0x69,  0xf0,  0x8e,  0xfd,  0x93,  0x92,  0xdf,  0xae,
/* 0x0df8 */  0x8d,  0x93,  0x26,  0xc7,  0x5d,  0x3b,  0x26,  0xb8,
/* 0x0e00 */  0x2d,  0x41,  0x5b,  0x64,  0x2f,  0x71,  0x03,  0x8c,
/* 0x0e08 */  0xee,  0xa1,  0x5c,  0x6c,  0x8b,  0xda,  0xd8,  0x03,
/* 0x0e10 */  0xe7,  0xb5,  0x63,  0x23,  0x3e,  0xdf,  0x70,  0x10,
/* 0x0e18 */  0xdd,  0000,  0xfb,  0xec,  0xf7,  0xdf,  0xcb,  0x5f,
/* 0x0e20 */  0xc3,  0xb6,  0xfb,  0x42,  0x95,  0xd6,  0x03,  0xdc,
/* 0x0e28 */  0x92,  0xd9,  0x04,  0xa6,  0xef,  0xda,  0xf5,  0x4b,
/* 0x0e30 */  0x0c,  0x78,  0x4c,  0xa7,  0x5e,  0xe4,  0xc8,  0xc7,
/* 0x0e38 */  0x55,  0x37,  0x43,  0xd4,  0xe4,  0xab,  0xbe,  0x3b,
/* 0x0e40 */  0x92,  0xf7,  0x6b,  0x64,  0x69,  0x75,  0xfd,  0x68,
/* 0x0e48 */  0xea,  0xc9,  0x04,  0x49,  0xf4,  0x9d,  0xfb,  0000,
/* 0x0e50 */  0xba,  0xac,  0xde,  0xb6,  0x44,  0x71,  0x8a,  0x5d,
/* 0x0e58 */  0xf4,  0x1b,  0x81,  0xf6,  0xea,  0x71,  0x8f,  0x71,
/* 0x0e60 */  0x76,  0x56,  0xde,  0x25,  0xdc,  0x7a,  0xf8,  0x34,
/* 0x0e68 */  0x53,  0x76,  0xd7,  0xc5,  0x99,  0xf0,  0x64,  0x0f,
/* 0x0e70 */  0xaa,  0x79,  0x9d,  0x6a,  0x36,  0xd8,  0x83,  0x6a,
/* 0x0e78 */  0x5a,  0xa3,  0x6a,  0x39,  0x24,  0x7b,  0x4a,  0xd0,
/* 0x0e80 */  0xae,  0xc7,  0x64,  0xfb,  0x9c,  0x93,  0x35,  0x34,
/* 0x0e88 */  0xd7,  0xb6,  0xff,  0x7f,  0xb0,  0xfd,  0000,  0x60,
/* 0x0e90 */  0xbc,  0x45,  0xb2,  0xa7,  0xf3,  0xf1,  0x7d,  0x8e,
/* 0x0e98 */  0000,  0x8a,  0x83,  0x94,  0x72,  0x23,  0x55,  0x81,
/* 0x0ea0 */  0xde,  0x3e,  0xb0,  0x7b,  0x1a,  0x72,  0xd8,  0xab,
/* 0x0ea8 */  0xf0,  0x4e,  0xe5,  0x4d,  0x6f,  0x65,  0x23,  0x2c,
/* 0x0eb0 */  0x37,  0x92,  0x41,  0x79,  0xec,  0xf7,  0x36,  0x0c,
/* 0x0eb8 */  0x58,  0xb9,  0xed,  0x58,  0xdd,  0x50,  0xcb,  0x2d,
/* 0x0ec0 */  0xac,  0xbe,  0xff,  0xa5,  0xb3,  0x40,  0xde,  0xa8,
/* 0x0ec8 */  0x69,  0xb6,  0x36,  0xbe,  0x0a,  0x87,  0x46,  0x1b,
/* 0x0ed0 */  0x97,  0xb4,  0xcd,  0x19,  0xe1,  0x45,  0xc5,  0xa3,
/* 0x0ed8 */  0xa8,  0x3f,  0xd5,  0x4e,  0x67,  0x74,  0x94,  0xfe,
/* 0x0ee0 */  0xd7,  0xcc,  0x8f,  0xf0,  0x60,  0x01,  0x42,  0x8b,
/* 0x0ee8 */  0xbc,  0x97,  0x6f,  0xe1,  0x33,  0x0f,  0xbc,  0x1a,
/* 0x0ef0 */  0x59,  0x6c,  0xcb,  0x6d,  0xbf,  0x3e,  0x62,  0x4c,
/* 0x0ef8 */  0x0a,  0x4b,  0x0b,  0xf6,  0xea,  0xd5,  0x88,  0x44,
/* 0x0f00 */  0x65,  0x18,  0x22,  0x4b,  0xb4,  0xb6,  0xb0,  0x98,
/* 0x0f08 */  0x09,  0x8c,  0x15,  0x01,  0x47,  0x86,  0xba,  0x32,
/* 0x0f10 */  0xda,  0x58,  0x5a,  0xe5,  0x20,  0x8a,  0xec,  0xbe,
/* 0x0f18 */  0x72,  0x59,  0xb8,  0x11,  0x4d,  0x5f,  0x2b,  0xe1,
/* 0x0f20 */  0x81,  0x96,  0xe6,  0xb9,  0x43,  0x4f,  0x55,  0x92,
/* 0x0f28 */  0x2c,  0xc2,  0x47,  0x32,  0xdc,  0x39,  0x11,  0x41,
/* 0x0f30 */  0x15,  0xdb,  0x4a,  0x7f,  0x52,  0x44,  0xd6,  0x7c,
/* 0x0f38 */  0x24,  0x5a,  0xdb,  0xcf,  0xa5,  0xdf,  0x15,  0x0b,
/* 0x0f40 */  0xbb,  0x0a,  0x41,  0xa1,  0xe4,  0x91,  0xcb,  0x2d,
/* 0x0f48 */  0x7c,  0x7a,  0x78,  0xb4,  0x5f,  0xb4,  0x13,  0x23,
/* 0x0f50 */  0x75,  0x0b,  0x79,  0x1f,  0xb6,  0x3e,  0x5e,  0x72,
/* 0x0f58 */  0xe4,  0x0b,  0x91,  0xfc,  0x21,  0x49,  0x71,  0xc6,
/* 0x0f60 */  0x24,  0x75,  0x4b,  0x8f,  0x74,  0xe4,  0x1e,  0x78,
/* 0x0f68 */  0xa5,  0x8f,  0x29,  0x24,  0x4a,  0xe5,  0x3b,  0x2e,
/* 0x0f70 */  0x37,  0x70,  0x53,  0xd7,  0xf4,  0xc0,  0x02,  0xe8,
/* 0x0f78 */  0x20,  0x6a,  0x80,  0xd2,  0x78,  0x38,  0x1e,  0x2e,
/* 0x0f80 */  0x29,  0x3e,  0x05,  0x2b,  0xb8,  0x88,  0x57,  0x4e,
/* 0x0f88 */  0x74,  0x9c,  0x7d,  0x8f,  0x4f,  0x8d,  0xf0,  0x06,
/* 0x0f90 */  0x25,  0xde,  0x32,  0xae,  0x6e,  0xcd,  0x43,  0x48,
/* 0x0f98 */  0x8e,  0xe9,  0x4d,  0x92,  0x83,  0x6f,  0xcf,  0x72,
/* 0x0fa0 */  0x81,  0x34,  0xbd,  0x14,  0x06,  0xaf,  0x0c,  0xe7,
/* 0x0fa8 */  0xeb,  0x4b,  0x13,  0x28,  0x82,  0x78,  0x6a,  0xde,
/* 0x0fb0 */  0xd2,  0x95,  0xe5,  0xa0,  0xa6,  0x49,  0xf5,  0x16,
/* 0x0fb8 */  0x9c,  0xd8,  0x8d,  0xc6,  0x6e,  0xa4,  0x48,  0xf1,
/* 0x0fc0 */  0x72,  0x4d,  0xde,  0x65,  0x46,  0xb6,  0xf8,  0x80,
/* 0x0fc8 */  0x2d,  0xb3,  0xf1,  0x1a,  0xb0,  0x7b,  0x87,  0x17,
/* 0x0fd0 */  0x83,  0xe9,  0xea,  0x3d,  0x3e,  0x42,  0x6a,  0x3d,
/* 0x0fd8 */  0x11,  0x20,  0xd3,  0x68,  0x1e,  0x0b,  0x88,  0x44,
/* 0x0fe0 */  0xc9,  0xd7,  0xd9,  0xd2,  0x5b,  0x91,  0x91,  0x11,
/* 0x0fe8 */  0x1a,  0xda,  0x01,  0xcc,  0x3e,  0x07,  0xd3,  0x7f,
/* 0x0ff0 */  0x30,  0xf2,  0x73,  0x2e,  0x8c,  0xaa,  0xbb,  0x3a,
/* 0x0ff8 */  0xce,  0xac,  0xfa,  0x75,  0xf7,  0x06,  0x82,  0xdf,
/* 0x1000 */  0x86,  0x78,  0x9f,  0xae,  0x58,  0x70,  0xf9,  0xe4,
/* 0x1008 */  0x07,  0x50,  0xbb,  0x03,  0xae,  0xb6,  0xbf,  0xc3,
/* 0x1010 */  0xc2,  0xf2,  0xb7,  0x31,  0xbe,  0x14,  0xe1,  0x49,
/* 0x1018 */  0x09,  0x54,  0x1b,  0x92,  0x99,  0x54,  0xbb,  0x15,
/* 0x1020 */  0xd9,  0xfe,  0x0e,  0x99,  0x40,  0x79,  0x4f,  0x0b,
/* 0x1028 */  0x85,  0x9d,  0x5e,  0x80,  0x50,  0x3c,  0x77,  0x9f,
/* 0x1030 */  0x4d,  0x69,  0x7e,  0x31,  0x69,  0xc1,  0x5f,  0xc2,
/* 0x1038 */  0xfa,  0xe0,  0x55,  0xdf,  0x40,  0xde,  0xff,  0x8e,
/* 0x1040 */  0xf1,  0x0e,  0x23,  0x69,  0x0a,  0x52,  0xbe,  0x55,
/* 0x1048 */  0x52,  0x28,  0xa8,  0x75,  0x07,  0000,  0xeb,  0000,
/* 0x1050 */  0xbc,  0x32,  0xbc,  0x0a,  0xf0,  0x28,  0xd3,  0x0f,
/* 0x1058 */  0x1d,  0x77,  0xe9,  0xda,  0xe2,  0x9d,  0x5c,  0xea,
/* 0x1060 */  0xfa,  0xf2,  0xac,  0x62,  0x5b,  0x3d,  0x58,  0x12,
/* 0x1068 */  0x82,  0x37,  0x8d,  0x4d,  0x31,  0xde,  0xbe,  0x24,
/* 0x1070 */  0x3f,  0xbe,  0x13,  0x6e,  0x88,  0xba,  0x57,  0xa6,
/* 0x1078 */  0x7c,  0x56,  0x5b,  0x07,  0x3c,  0x69,  0xbd,  0x05,
/* 0x1080 */  0x6f,  0x12,  0xe2,  0x73,  0x38,  0x31,  0x12,  0x59,
/* 0x1088 */  0x79,  0xe1,  0xb0,  0x2b,  0x41,  0xe1,  0x81,  0xa2,
/* 0x1090 */  0x85,  0x6c,  0x79,  0xd8,  0xcb,  0x4b,  0x8b,  0xdb,
/* 0x1098 */  0xda,  0xbd,  0x1e,  0x3a,  0000,  0x0d,  0x49,  0xb4,
/* 0x10a0 */  0xa3,  0x59,  0xcd,  0xe3,  0xe5,  0xb2,  0xcd,  0x76,
/* 0x10a8 */  0xc9,  0x46,  0xef,  0x37,  0x21,  0x13,  0x54,  0x8e,
/* 0x10b0 */  0x78,  0xf2,  0xe3,  0xb3,  0x2d,  0xd0,  0xd7,  0xb6,
/* 0x10b8 */  0x0c,  0x63,  0x0c,  0x76,  0x8d,  0x23,  0xdf,  0xb4,
/* 0x10c0 */  0xfe,  0xc7,  0xa3,  0x0c,  0xcb,  0xc8,  0x2c,  0x17,
/* 0x10c8 */  0xe5,  0xf5,  0xcf,  0xaf,  0x8d,  0x49,  0xce,  0x77,
/* 0x10d0 */  0x87,  0xd6,  0x8a,  0x72,  0xa6,  0xbc,  0x8a,  0xa3,
/* 0x10d8 */  0xe6,  0x02,  0x78,  0xc3,  0xe7,  0xe7,  0xd7,  0xa3,
/* 0x10e0 */  0x21,  0x39,  0xb5,  0x4b,  0x4a,  0x8a,  0x10,  0x96,
/* 0x10e8 */  0xf2,  0x15,  0x25,  0x0f,  0xf0,  0xad,  0xe3,  0x2f,
/* 0x10f0 */  0x5c,  0x5e,  0x53,  0xe7,  0x78,  0xcb,  0xdb,  0x92,
/* 0x10f8 */  0x2f,  0x7e,  0x43,  0xf0,  0xc2,  0xe1,  0x2d,  0xf4,
/* 0x1100 */  0x3c,  0xcc,  0xef,  0xf6,  0xfa,  0xe4,  0x86,  0xc4,
/* 0x1108 */  0xad,  0x06,  0x7c,  0xfd,  0x8a,  0x87,  0x71,  0x1d,
/* 0x1110 */  0x5f,  0xcb,  0x7e,  0x26,  0x62,  0x52,  0x19,  0x3d,
/* 0x1118 */  0x9b,  0x47,  0xfa,  0xa8,  0xe7,  0x28,  0x4b,  0xe9,
/* 0x1120 */  0xb7,  0x28,  0xe5,  0xe4,  0xab,  0x17,  0xbc,  0xff,
/* 0x1128 */  0xc4,  0x7a,  0x48,  0x5f,  0x46,  0x1f,  0x71,  0x09,
/* 0x1130 */  0x1c,  0xbe,  0x97,  0xef,  0x9a,  0x7f,  0x29,  0xce,
/* 0x1138 */  0xc3,  0x8b,  0x87,  0x8c,  0xf2,  0x3a,  0x40,  0x2e,
/* 0x1140 */  0x21,  0x7a,  0x55,  0x31,  0xad,  0xe2,  0x75,  0x53,
/* 0x1148 */  0x1a,  0x46,  0xe2,  0x19,  0x03,  0xb8,  0x7b,  0x9c,
/* 0x1150 */  0x8d,  0x9e,  0x5f,  0x51,  0x0e,  0xf0,  0x05,  0xb1,
/* 0x1158 */  0xf2,  0x40,  0xd7,  0x4d,  0xc5,  0xab,  0x54,  0x7c,
/* 0x1160 */  0xf9,  0x9a,  0xf2,  0x0a,  0x8f,  0x18,  0xef,  0xcc,
/* 0x1168 */  0xab,  0x4c,  0xda,  0x0f,  0x73,  0x5d,  0x5c,  0x16,
/* 0x1170 */  0xf1,  0x3e,  0x93,  0x8c,  0x23,  0x77,  0x26,  0xcf,
/* 0x1178 */  0xe4,  0xb5,  0x5d,  0x09,  0xa9,  0x44,  0xbc,  0x0f,
/* 0x1180 */  0x06,  0x16,  0xbf,  0x05,  0xb9,  0xdf,  0x28,  0xba,
/* 0x1188 */  0xb6,  0x05,  0x73,  0xe9,  0x8c,  0x29,  0xcb,  0xfc,
/* 0x1190 */  0x15,  0x33,  0xdb,  0x4f,  0xcf,  0xb4,  0x45,  0xe3,
/* 0x1198 */  0x19,  0x09,  0x26,  0x92,  0xe1,  0xb2,  0xa7,  0x76,
/* 0x11a0 */  0xd6,  0x5a,  0xdf,  0x38,  0x11,  0x3c,  0xdd,  0xe7,
/* 0x11a8 */  0xb3,  0x3c,  0x6f,  0x3c,  0x28,  0x06,  0xff,  0x2d,
/* 0x11b0 */  0000,  0x49,  0x9f,  0x0f,  0xbe,  0x98,  0x3c,  0x80,
/* 0x11b8 */  0x70,  0xcf,  0x74,  0xb7,  0x30,  0xde,  0xa2,  0x07,
/* 0x11c0 */  0xc3,  0xe6,  0xb3,  0x07,  0x1d,  0xdc,  0x6f,  0x45,
/* 0x11c8 */  0x2a,  0xf7,  0x4a,  0xc1,  0xbf,  0xc2,  0xef,  0x71,
/* 0x11d0 */  0x01,  0x73,  0x5c,  0x16,  0xb3,  0xcc,  0xaf,  0xe5,
/* 0x11d8 */  0xc8,  0xcc,  0x45,  0x65,  0xa1,  0xb3,  0x17,  0x75,
/* 0x11e0 */  0x84,  0xcb,  0x6b,  0x0e,  0x03,  0xc4,  0xc9,  0xbf,
/* 0x11e8 */  0x01,  0xc0,  0xb2,  0x81,  0x1e,  0xfb,  0x3e,  0000,
/* 0x11f0 */  0000,
};

/* This is a selfrep (quine) program.  It uses the above data (which
 * is no other than the gzipped representation of everything starting
 * from this comment) to print its own listing.  Naturally, this means
 * that we need some uncompression routines.  That is what we start
 * with. */

#include <stdio.h>

/* --- GZIP file format uncompression routines --- */

/* The following routines (notably the unzip()) function below
 * uncompress gzipped data.  They are terribly slow at the task, but
 * it is presumed that they work reasonably well.  They don't do any
 * error checking, but they're probably not too vulnerable to buggy
 * data either.  Another important limitation (but it would be pretty
 * easy to get around) is that the data must reside in memory, it is
 * not read as a stream.  They have been very little tested.  Anyway,
 * whatever these functions are good for, I put them in the public
 * domain.  -- David Madore <david.madore@ens.fr> 1999/11/21 */

unsigned int
peek_bits (const unsigned char *data, long p, int q)
     /* Read q bits starting from bit p from the data pointed to by
      * data.  Data is in little-endian format. */
{
  unsigned int answer;
  int cnt; /* Number of bits already placed in answer */
  char ob, lb; /* Offset and length of bit field within current byte */

  answer = 0;
  for ( cnt=0 ; cnt<q ; /* cnt updated in body */ )
    {
      ob = (p+cnt)%8;
      lb = 8-ob;
      if ( cnt+lb > q )
	lb = q-cnt;
      answer |= ((unsigned int)((data[(p+cnt)/8]>>ob)&((1U<<lb)-1)))<<cnt;
      cnt += lb;
    }
  return answer;
}

unsigned int
read_bits (const unsigned char *data, long *p, int q)
     /* Read q bits as per peek_bits(), but also increase p by q. */
{
  unsigned int answer;

  answer = peek_bits (data, *p, q);
  *p += q;
  return answer;
}

void
make_code_table (const char size_table[], int table_length,
		 unsigned int code_table[], int maxbits)
     /* Make a code table from a length table.  See rfc1951, section
      * 3.2.2, for details on what this means.  The size_table
      * contains the length of the Huffman codes for each letter, and
      * the code_table receives the computed codes themselves.
      * table_length is the size of the tables (alphabet length) and
      * maxbits is the maximal allowed code length. */
{
  int i, j;
  unsigned int code;

  code = 0;
  for ( i=1 ; i<=maxbits ; i++ )
    {
      for ( j=0 ; j<table_length ; j++ )
	{
	  if ( size_table[j]==i )
	    code_table[j] = code++;
	}
      code <<= 1;
    }
}

int
decode_one (const unsigned char *data, long *p,
	    const char size_table[], int table_length,
	    const unsigned int code_table[], int maxbits)
     /* Decode one alphabet letter from the data, starting at bit p
      * (which will be increased by the appropriate amount) using
      * size_table and code_table to decipher the Huffman encoding. */
{
  unsigned int code;
  int i, j;

  code = 0;
  /* Read as many bits as are likely to be necessary - backward, of
   * course. */
  for ( i=0 ; i<maxbits ; i++ )
    code = (code<<1) + peek_bits (data, (*p)+i, 1);
  /* Now examine each symbol of the table to find one that matches the
   * first bits of the code read. */
  for ( j=0 ; j<table_length ; j++ )
    {
      if ( size_table[j]
	   && ( (code>>(maxbits-size_table[j])) == code_table[j] ) )
	{
	  *p += size_table[j];
	  return j;
	}
    }
  fprintf (stderr, "These bits don't make sense: %#x\n", code);
  exit (1);
}

/* I don't know what these should be.  The rfc1951 doesn't seem to say
 * (it only mentions them in the last paragraph of section 3.2.1).  15
 * is almost certainly safe, and it is the largest I can put given the
 * constraints on the size of integers in the C standard. */
#define CLEN_MAXBITS 15
#define HLIT_MAXBITS 15
#define HDIST_MAXBITS 15

/* The magical table sizes... */
#define CLEN_TSIZE 19
#define HLIT_TSIZE 288
#define HDIST_TSIZE 30

void
get_tables (const unsigned char *data, long *p,
	    char hlit_size_table[HLIT_TSIZE],
	    unsigned int hlit_code_table[HLIT_TSIZE],
	    char hdist_size_table[HDIST_TSIZE],
	    unsigned int hdist_code_table[HDIST_TSIZE])
     /* Fill the Huffman tables (first the code lengths table, and
      * then, using it, the literal/length table and the distance
      * table).  See section 3.2.7 of rfc1951 for details. */
{
  char hlit, hdist, hclen;
  const int clen_weird_tangle[CLEN_TSIZE]
    = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
  char clen_size_table[CLEN_TSIZE];
  unsigned int clen_code_table[CLEN_TSIZE];
  int j;
  unsigned int b;
  int remainder; /* See note at end of section 3.2.7 of rfc1951. */
  char rem_val;

  hlit = read_bits (data, p, 5);
  hdist = read_bits (data, p, 5);
  hclen = read_bits (data, p, 4);
  for ( j=0 ; j<4+hclen ; j++ )
    clen_size_table[clen_weird_tangle[j]]
      = read_bits (data, p, 3);
  for ( ; j<CLEN_TSIZE ; j++ )
    clen_size_table[clen_weird_tangle[j]] = 0;
  make_code_table (clen_size_table, CLEN_TSIZE,
		   clen_code_table, CLEN_MAXBITS);
  remainder = 0;
  rem_val = 0;
  for ( j=0 ; j<257+hlit ; j++ )
    {
      b = decode_one (data, p, clen_size_table, CLEN_TSIZE,
		      clen_code_table, CLEN_MAXBITS);
      if ( b<16 )
	hlit_size_table[j] = b;
      else if ( b == 16 )
	{
	  int k, l;

	  k = read_bits (data, p, 2);
	  for ( l=0 ; l<k+3 && j+l<257+hlit ; l++ )
	    hlit_size_table[j+l] = hlit_size_table[j-1];
	  j += l-1;
	  remainder = k+3-l; /* THIS IS SO UGLY! */
	  rem_val = hlit_size_table[j-1];
	}
      else if ( b == 17 )
	{
	  int k, l;

	  k = read_bits (data, p, 3);
	  for ( l=0 ; l<k+3 && j+l<257+hlit ; l++ )
	    hlit_size_table[j+l] = 0;
	  j += l-1;
	  remainder = k+3-l;
	  rem_val = 0;
	}
      else if ( b == 18 )
	{
	  int k, l;

	  k = read_bits (data, p, 7);
	  for ( l=0 ; l<k+11 && j+l<257+hlit ; l++ )
	    hlit_size_table[j+l] = 0;
	  j += l-1;
	  remainder = k+11-l;
	  rem_val = 0;
	}
    }
  for ( ; j<HLIT_TSIZE ; j++ )
    hlit_size_table[j] = 0;
  make_code_table (hlit_size_table, HLIT_TSIZE,
		   hlit_code_table, HLIT_MAXBITS);
  for ( j=0 ; j<remainder ; j++ )
    hdist_size_table[j] = rem_val;
  for ( ; j<1+hdist ; j++ )
    /* Can you spell: ``copy-paste''? */
    {
      b = decode_one (data, p, clen_size_table, CLEN_TSIZE,
		      clen_code_table, CLEN_MAXBITS);
      if ( b<16 )
	hdist_size_table[j] = b;
      else if ( b == 16 )
	{
	  int k, l;

	  k = read_bits (data, p, 2);
	  for ( l=0 ; l<k+3 && j+l<1+hdist ; l++ )
	    hdist_size_table[j+l] = hdist_size_table[j-1];
	  j += l-1;
	}
      else if ( b == 17 )
	{
	  int k, l;

	  k = read_bits (data, p, 3);
	  for ( l=0 ; l<k+3 && j+l<1+hdist ; l++ )
	    hdist_size_table[j+l] = 0;
	  j += l-1;
	}
      else if ( b == 18 )
	{
	  int k, l;

	  k = read_bits (data, p, 7);
	  for ( l=0 ; l<k+11 && j+l<1+hdist ; l++ )
	    hdist_size_table[j+l] = 0;
	  j += l-1;
	}
    }
  for ( ; j<HDIST_TSIZE ; j++ )
    hdist_size_table[j] = 0;
  make_code_table (hdist_size_table, HDIST_TSIZE,
		   hdist_code_table, HDIST_MAXBITS);
}

/* The (circular) output buffer.  This lets us track
 * backreferences. */

/* Minimal buffer size.  Also the only useful value. */
#define BUFFER_SIZE 32768

/* Pointer to the character to be added to the buffer */
static unsigned int buffer_ptr = 0;

/* The buffer itself */
static unsigned char buffer[BUFFER_SIZE];

void
pushout (unsigned char ch)
     /* Store one byte in the output buffer so it may be retrieved if
      * it is referenced again. */
{
  buffer[buffer_ptr++] = ch;
  buffer_ptr %= BUFFER_SIZE;
}

unsigned char
pushin (unsigned int dist)
     /* Retrieve one byte, dist bytes away, from the output buffer. */
{
  return buffer[(buffer_ptr+(BUFFER_SIZE-dist))%BUFFER_SIZE];
}

void
get_data (const unsigned char *data, long *p,
	  const char hlit_size_table[HLIT_TSIZE],
	  const unsigned int hlit_code_table[HLIT_TSIZE],
	  const char hdist_size_table[HDIST_TSIZE],
	  const unsigned int hdist_code_table[HDIST_TSIZE],
	  void (* callback) (unsigned char d))
     /* Do the actual uncompressing.  Call callback on each character
      * uncompressed. */
{
  unsigned int b;

  while ( 1 ) {
    b = decode_one (data, p, hlit_size_table, HLIT_TSIZE,
		    hlit_code_table, HLIT_MAXBITS);
    if ( b < 256 )
      /* Literal */
      {
	pushout ((unsigned char) b);
	callback ((unsigned char) b);
      }
    else if ( b == 256 )
      /* End of block */
      return;
    else if ( b >= 257 )
      /* Back reference */
      {
	unsigned int bb;
	unsigned int length, dist;
	unsigned int l;

	switch ( b )
	  {
	  case 257: length = 3; break;
	  case 258: length = 4; break;
	  case 259: length = 5; break;
	  case 260: length = 6; break;
	  case 261: length = 7; break;
	  case 262: length = 8; break;
	  case 263: length = 9; break;
	  case 264: length = 10; break;
	  case 265: length = 11 + read_bits (data, p, 1); break;
	  case 266: length = 13 + read_bits (data, p, 1); break;
	  case 267: length = 15 + read_bits (data, p, 1); break;
	  case 268: length = 17 + read_bits (data, p, 1); break;
	  case 269: length = 19 + read_bits (data, p, 2); break;
	  case 270: length = 23 + read_bits (data, p, 2); break;
	  case 271: length = 27 + read_bits (data, p, 2); break;
	  case 272: length = 31 + read_bits (data, p, 2); break;
	  case 273: length = 35 + read_bits (data, p, 3); break;
	  case 274: length = 43 + read_bits (data, p, 3); break;
	  case 275: length = 51 + read_bits (data, p, 3); break;
	  case 276: length = 59 + read_bits (data, p, 3); break;
	  case 277: length = 67 + read_bits (data, p, 4); break;
	  case 278: length = 83 + read_bits (data, p, 4); break;
	  case 279: length = 99 + read_bits (data, p, 4); break;
	  case 280: length = 115 + read_bits (data, p, 4); break;
	  case 281: length = 131 + read_bits (data, p, 5); break;
	  case 282: length = 163 + read_bits (data, p, 5); break;
	  case 283: length = 195 + read_bits (data, p, 5); break;
	  case 284: length = 227 + read_bits (data, p, 5); break;
	  case 285: length = 258; break;
	  default:
	    fprintf (stderr, "Unexpected literal/length code %d\n", b);
	    exit (1);
	  }
	bb = decode_one (data, p, hdist_size_table, HDIST_TSIZE,
			 hdist_code_table, HDIST_MAXBITS);
	switch ( bb )
	  {
	  case 0: dist = 1; break;
	  case 1: dist = 2; break;
	  case 2: dist = 3; break;
	  case 3: dist = 4; break;
	  case 4: dist = 5 + read_bits (data, p, 1); break;
	  case 5: dist = 7 + read_bits (data, p, 1); break;
	  case 6: dist = 9 + read_bits (data, p, 2); break;
	  case 7: dist = 13 + read_bits (data, p, 2); break;
	  case 8: dist = 17 + read_bits (data, p, 3); break;
	  case 9: dist = 25 + read_bits (data, p, 3); break;
	  case 10: dist = 33 + read_bits (data, p, 4); break;
	  case 11: dist = 49 + read_bits (data, p, 4); break;
	  case 12: dist = 65 + read_bits (data, p, 5); break;
	  case 13: dist = 97 + read_bits (data, p, 5); break;
	  case 14: dist = 129 + read_bits (data, p, 6); break;
	  case 15: dist = 193 + read_bits (data, p, 6); break;
	  case 16: dist = 257 + read_bits (data, p, 7); break;
	  case 17: dist = 385 + read_bits (data, p, 7); break;
	  case 18: dist = 513 + read_bits (data, p, 8); break;
	  case 19: dist = 769 + read_bits (data, p, 8); break;
	  case 20: dist = 1025 + read_bits (data, p, 9); break;
	  case 21: dist = 1537 + read_bits (data, p, 9); break;
	  case 22: dist = 2049 + read_bits (data, p, 10); break;
	  case 23: dist = 3073 + read_bits (data, p, 10); break;
	  case 24: dist = 4097 + read_bits (data, p, 11); break;
	  case 25: dist = 6145 + read_bits (data, p, 11); break;
	  case 26: dist = 8193 + read_bits (data, p, 12); break;
	  case 27: dist = 12289 + read_bits (data, p, 12); break;
	  case 28: dist = 16385 + read_bits (data, p, 13); break;
	  case 29: dist = 24577 + read_bits (data, p, 13); break;
	  default:
	    fprintf (stderr, "Unexpected distance code %d\n", b);
	    exit (1);
	  }
	for ( l=0 ; l<length ; l++ )
	  {
	    unsigned char ch;

	    ch = pushin (dist);
	    pushout (ch);
	    callback (ch);
	  }
      }
  }
}

void
inflate (const unsigned char *data, long *p,
	 void (* callback) (unsigned char d))
     /* Main uncompression function for the deflate method */
{
  char blast, btype;
  char hlit_size_table[HLIT_TSIZE];
  unsigned int hlit_code_table[HLIT_TSIZE];
  char hdist_size_table[HDIST_TSIZE];
  unsigned int hdist_code_table[HDIST_TSIZE];

 again:
  blast = read_bits (data, p, 1);
  btype = read_bits (data, p, 2);
  if ( btype == 1 || btype == 2 )
    {
      if ( btype == 2 )
	/* Dynamic Huffman tables */
	get_tables (data, p,
		    hlit_size_table, hlit_code_table,
		    hdist_size_table, hdist_code_table);
      else
	/* Fixed Huffman codes */
	{
	  int j;

	  for ( j=0 ; j<144 ; j++ )
	    hlit_size_table[j] = 8;
	  for ( ; j<256 ; j++ )
	    hlit_size_table[j] = 9;
	  for ( ; j<280 ; j++ )
	    hlit_size_table[j] = 7;
	  for ( ; j<HLIT_TSIZE ; j++ )
	    hlit_size_table[j] = 8;
	  make_code_table (hlit_size_table, HLIT_TSIZE,
			   hlit_code_table, HLIT_MAXBITS);
	  for ( j=0 ; j<HDIST_TSIZE ; j++ )
	    hdist_size_table[j] = 5;
	  make_code_table (hdist_size_table, HDIST_TSIZE,
			   hdist_code_table, HDIST_MAXBITS);
	}
      get_data (data, p,
		hlit_size_table, hlit_code_table,
		hdist_size_table, hdist_code_table,
		callback);
    }
  else if ( btype == 0 )
    /* Non compressed block */
    {
      unsigned int len, nlen;
      unsigned int l;
      unsigned char b;

      *p = (*p+7)/8; /* Jump to next byte boundary */
      len = read_bits (data, p, 16);
      nlen = read_bits (data, p, 16);
      for ( l=0 ; l<len ; l++ )
	{
	  b = read_bits (data, p, 8);
	  pushout (b);
	  callback (b);
	}
    }
  else
    {
      fprintf (stderr, "Compression type %d not supported.\n", btype);
      exit (1);
    }
  if ( ! blast )
    goto again;
}

void
unzip (const unsigned char *data, long *p,
       void (* callback) (unsigned char d))
     /* Uncompress gzipped data.  data is a pointer to the data, p is
      * a pointer to a long that is initialized to 0 (unless for some
      * reason you want to start uncompressing further down the data),
      * and callback is a function taking an unsigned char and
      * returning void that will be called successively for every
      * uncompressed byte. */
{
  unsigned char cm, flg;

  if ( read_bits (data, p, 8) != 0x1f
       || read_bits (data, p, 8) != 0x8b )
    {
      fprintf (stderr, "Not in gzipped format.\n");
      exit (1);
    }
  cm = read_bits (data, p, 8);
  if ( cm != 0x8 )
    {
      fprintf (stderr, "Compression method %d not supported.\n", cm);
      exit (1);
    }
  flg = read_bits (data, p, 8);
  if ( flg & 0xe0 )
    fprintf (stderr, "Warning: unknown bits are set in flags.\n");
  read_bits (data, p, 32); /* Ignore modification time */
  read_bits (data, p, 8); /* Ignore extra flags */
  read_bits (data, p, 8); /* Ignore OS type */
  if ( flg & 0x4 )
    {
      /* Skip over extra data */
      unsigned int xlen;

      xlen = read_bits (data, p, 16);
      *p += ((long)xlen)*8;
    }
  if ( flg & 0x8 )
    {
      /* Skip over file name */
      while ( read_bits (data, p, 8) );
    }
  if ( flg & 0x10 )
    {
      /* Skip over comment */
      while ( read_bits (data, p, 8) );
    }
  if ( flg & 0x2 )
    /* Ignore CRC16 */
    read_bits (data, p, 16);
  inflate (data, p, callback);
  /* CRC32 and ISIZE are at the end.  We don't even bother to look at
   * them. */
}

/* --- End GZIP file format uncompression routines --- */

void
callback (unsigned char ch)
{
  putchar (ch);
}

int
main (void)
     /* The main program.  We output the data in the format used at
      * the top of this file, and then we uncompress it to generate
      * the rest of this file. */
{
  unsigned int i;
  long p;

  printf ("/* See comments below */\n\n");
  printf ("const unsigned char gzipped_data[] = {");
  for ( i=0 ; i<sizeof(gzipped_data) ; i++ )
    {
      if ( i%8 == 0 )
	printf ("\n/* %0#6x */",i);
      printf ("  %0#4x,", gzipped_data[i]);
    }
  printf ("\n};\n\f\n");
  p = 0;
  unzip (gzipped_data, &p, callback);
  return 0;
}