path
stringlengths 14
112
| content
stringlengths 0
6.32M
| size
int64 0
6.32M
| max_lines
int64 1
100k
| repo_name
stringclasses 2
values | autogenerated
bool 1
class |
|---|---|---|---|---|---|
cosmopolitan/third_party/python/Modules/cjkcodecs/__big5_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __big5_encmap_ptr;
static const unsigned char __big5_encmap_rodata[] = {
0xd4, 0xbc, 0x07, 0x57, 0x6a, 0xcb, 0xd2, 0x36, 0xfa, 0xd7, 0xcc, 0x39, 0xe7,
0x9c, 0x73, 0x0e, 0xcb, 0x1c, 0xfe, 0x0b, 0x39, 0xe7, 0x24, 0x88, 0x80, 0x88,
0x4c, 0x81, 0x49, 0x14, 0x10, 0x10, 0x50, 0x50, 0x50, 0x10, 0x44, 0x11, 0xb3,
0xcb, 0x75, 0x8b, 0xde, 0x6c, 0x8f, 0x6b, 0xef, 0x7d, 0xce, 0x7b, 0xde, 0x7b,
0xbf, 0x71, 0xef, 0xb8, 0x8e, 0xd1, 0xdd, 0x55, 0xd5, 0x61, 0x76, 0x57, 0x57,
0x3d, 0x5d, 0x33, 0x60, 0x09, 0xb1, 0x94, 0xf8, 0xeb, 0x57, 0x11, 0x24, 0x01,
0xe1, 0xd7, 0x5f, 0xfe, 0xda, 0x88, 0xc7, 0xdf, 0x64, 0x75, 0x7f, 0xab, 0xff,
0xdf, 0xfd, 0xd9, 0xff, 0x1f, 0xf6, 0x77, 0x10, 0x54, 0xa4, 0x5f, 0xbf, 0x94,
0xa4, 0x3d, 0x92, 0x1a, 0xca, 0xc3, 0x7f, 0x33, 0xda, 0x2e, 0xa9, 0x88, 0x54,
0x4c, 0x2a, 0x21, 0x95, 0x92, 0xca, 0x48, 0xe5, 0xa4, 0x0a, 0x52, 0x25, 0xa9,
0x8a, 0x54, 0x4d, 0xaa, 0x21, 0xd5, 0x92, 0xea, 0x48, 0xf5, 0xa4, 0x06, 0x52,
0x23, 0xa9, 0x09, 0x7a, 0x37, 0x93, 0x5a, 0x48, 0xad, 0xa4, 0x36, 0x52, 0x3b,
0xa9, 0x83, 0xd4, 0x49, 0xfa, 0x7d, 0x84, 0x2e, 0x52, 0x37, 0xa9, 0x87, 0xd4,
0x4b, 0xea, 0x23, 0xf5, 0x93, 0x06, 0x48, 0x83, 0xa4, 0x21, 0xd2, 0x30, 0x69,
0x84, 0x34, 0x4a, 0x1a, 0x23, 0x8d, 0x93, 0x26, 0x48, 0x93, 0xa4, 0x29, 0x68,
0x3f, 0x4d, 0x9a, 0x21, 0xcd, 0x92, 0xe6, 0x48, 0xf3, 0xa4, 0x05, 0xd2, 0x22,
0x49, 0x84, 0xfd, 0x37, 0xf3, 0x17, 0x60, 0x42, 0x4c, 0x8c, 0x49, 0x30, 0x29,
0x26, 0xc3, 0x76, 0x30, 0x39, 0xa6, 0xf8, 0xad, 0xd7, 0x2e, 0xa6, 0xc4, 0xf6,
0x30, 0x15, 0xa6, 0xc6, 0x34, 0xd8, 0x3e, 0xa6, 0xc5, 0x0e, 0x30, 0x1d, 0x76,
0x88, 0xe9, 0x31, 0x0c, 0x3b, 0xc2, 0x0c, 0x98, 0x11, 0x33, 0x61, 0x38, 0x66,
0xc6, 0xac, 0x98, 0x0d, 0xb3, 0x63, 0x0e, 0xec, 0x18, 0x73, 0x62, 0x2e, 0xcc,
0x8d, 0x9d, 0x60, 0x1e, 0xcc, 0x8b, 0xf9, 0xb0, 0x53, 0xcc, 0x8f, 0x05, 0xb0,
0x20, 0x76, 0x86, 0x9d, 0x63, 0x21, 0x2c, 0x8c, 0x5d, 0x60, 0x97, 0x58, 0x04,
0x8b, 0x62, 0x57, 0xd8, 0x35, 0x5c, 0xc5, 0x82, 0xb5, 0x10, 0xda, 0x72, 0xfa,
0xa2, 0x10, 0xa8, 0x88, 0xa2, 0x11, 0xe8, 0x5f, 0x1a, 0x2c, 0x46, 0x54, 0x15,
0xa1, 0xf2, 0xdf, 0xe8, 0x94, 0x8d, 0xe4, 0xac, 0x6f, 0xb5, 0x7c, 0x44, 0x6b,
0x09, 0x15, 0x60, 0x37, 0xfb, 0x39, 0x79, 0x25, 0xf1, 0xd7, 0xff, 0x8f, 0xfe,
0xe4, 0x44, 0x05, 0x71, 0x97, 0xa8, 0x24, 0xee, 0x11, 0x55, 0x44, 0x35, 0x51,
0x43, 0xdc, 0x27, 0x6a, 0xff, 0x8f, 0xce, 0xff, 0x89, 0x90, 0x21, 0x3c, 0x13,
0x1e, 0x91, 0x6e, 0x5e, 0x08, 0xaf, 0x84, 0x77, 0xc2, 0x1b, 0xc1, 0x99, 0xd3,
0xd4, 0x29, 0xe1, 0x9a, 0x70, 0x85, 0xe8, 0x9f, 0x90, 0x7f, 0xe4, 0xa4, 0x97,
0x84, 0x08, 0x21, 0x81, 0xe8, 0xe4, 0x37, 0x4d, 0xa7, 0x08, 0xb7, 0xbf, 0xed,
0xca, 0xc5, 0xff, 0xc2, 0x8b, 0xfc, 0xff, 0xa1, 0xad, 0x8f, 0x10, 0xf8, 0xaa,
0xf5, 0x10, 0xbc, 0x84, 0xff, 0xef, 0x76, 0x22, 0xfa, 0x7f, 0xe3, 0xda, 0x31,
0x42, 0x0c, 0x8b, 0x63, 0x37, 0x58, 0x02, 0x4b, 0x62, 0xb7, 0x58, 0x0a, 0xbb,
0xc3, 0xee, 0xb1, 0xf4, 0x3f, 0x7a, 0xe1, 0x03, 0x96, 0xc1, 0x1e, 0xb1, 0x27,
0xec, 0x19, 0x7b, 0xc1, 0x5e, 0xb1, 0x37, 0xec, 0x1d, 0xfb, 0xc0, 0x56, 0x60,
0xa7, 0x57, 0xff, 0x61, 0xb7, 0xd7, 0x73, 0xb2, 0x8d, 0x5c, 0xb9, 0x99, 0x2b,
0xb7, 0x72, 0xe5, 0xd2, 0x5f, 0xfa, 0xfc, 0xf8, 0x0b, 0xbf, 0xf8, 0x17, 0x7e,
0xe1, 0x2f, 0xfc, 0xfc, 0x7f, 0x69, 0x61, 0xe4, 0xff, 0xd0, 0x8e, 0x82, 0xea,
0x68, 0x7f, 0x6b, 0x41, 0x45, 0x92, 0x6d, 0x22, 0x81, 0x48, 0x22, 0x12, 0x89,
0x6c, 0x22, 0x87, 0xc8, 0x25, 0x76, 0xfc, 0x5b, 0xcd, 0x0e, 0x10, 0x07, 0x89,
0x43, 0xc4, 0x61, 0xe2, 0x08, 0x71, 0x94, 0x38, 0x46, 0x1c, 0x27, 0xce, 0x11,
0x67, 0x89, 0x33, 0xc4, 0x69, 0xe2, 0x14, 0x71, 0x92, 0x38, 0xf1, 0x35, 0xf6,
0x32, 0x71, 0xed, 0x1f, 0x67, 0xb2, 0x47, 0x50, 0xfe, 0x8f, 0x7b, 0x26, 0x25,
0x48, 0xfe, 0xd6, 0x46, 0x4d, 0x50, 0xfd, 0x4d, 0xb6, 0x4b, 0x50, 0xe4, 0x64,
0x22, 0x54, 0xca, 0x08, 0xe2, 0xff, 0xca, 0x1e, 0xe8, 0x44, 0x06, 0x91, 0x45,
0x64, 0x12, 0xe5, 0x84, 0x1d, 0xd4, 0xfe, 0xe1, 0xff, 0x55, 0x0b, 0xbe, 0x23,
0xa4, 0x09, 0xf7, 0x84, 0x3c, 0x42, 0x01, 0xa1, 0x90, 0x20, 0x84, 0x2b, 0x93,
0xf5, 0x68, 0x7f, 0x09, 0x0b, 0x84, 0x69, 0xc2, 0x0c, 0x61, 0x89, 0xb0, 0x4c,
0x58, 0x23, 0xac, 0x13, 0xc6, 0x09, 0x13, 0x84, 0x62, 0xd0, 0xe0, 0x30, 0x61,
0xe4, 0x2f, 0xb3, 0x63, 0x10, 0x98, 0x48, 0x72, 0x40, 0xd4, 0x11, 0x0f, 0x89,
0x7a, 0x22, 0x46, 0x3c, 0x22, 0x1a, 0x88, 0x46, 0xa2, 0xe9, 0x7f, 0x89, 0x41,
0x14, 0x3d, 0x55, 0x4f, 0xd3, 0xd3, 0xf5, 0x0c, 0x3d, 0x53, 0xcf, 0xd2, 0xb3,
0xf5, 0x1c, 0x3d, 0x57, 0xcf, 0xd3, 0xf3, 0xf5, 0x02, 0xbd, 0x50, 0x2f, 0xd2,
0x8b, 0xf5, 0x12, 0xbd, 0x54, 0x2f, 0xd3, 0xef, 0xe8, 0xe5, 0x7a, 0x85, 0x7e,
0x57, 0xaf, 0xd4, 0xef, 0xe9, 0x55, 0x7a, 0xb5, 0x5e, 0xa3, 0xdf, 0xd7, 0x6b,
0xf5, 0x07, 0x7a, 0x9d, 0xfe, 0x50, 0xaf, 0xd7, 0x63, 0xfa, 0x23, 0xbd, 0x41,
0x6f, 0xd4, 0x9b, 0xf4, 0xb8, 0xde, 0xac, 0xb7, 0xe8, 0xad, 0x7a, 0x9b, 0xde,
0xae, 0x77, 0xe8, 0x8f, 0xf5, 0x4e, 0xbd, 0x4b, 0xef, 0xd6, 0x9f, 0xe8, 0x3d,
0x7a, 0xaf, 0xde, 0xa7, 0x3f, 0xd5, 0xfb, 0xf5, 0x01, 0x7d, 0x50, 0x7f, 0xa6,
0x3f, 0xd7, 0x87, 0xf4, 0x61, 0xfd, 0x85, 0xfe, 0x52, 0x1f, 0xd1, 0x47, 0xf5,
0x57, 0xfa, 0x6b, 0x7d, 0x4c, 0x1f, 0xd7, 0xdf, 0xe8, 0x13, 0xfa, 0xa4, 0xfe,
0x56, 0x9f, 0xd2, 0xdf, 0xe9, 0xef, 0xf5, 0x69, 0xfd, 0x83, 0x3e, 0xa3, 0x7f,
0xd4, 0x3f, 0xe9, 0x9f, 0xf5, 0x7f, 0x9f, 0x37, 0x51, 0x4f, 0x42, 0xd2, 0x17,
0xfd, 0xab, 0xfe, 0x4d, 0xff, 0xae, 0xff, 0xd0, 0xff, 0xd4, 0x7f, 0xea, 0xf3,
0xb0, 0x7c, 0xac, 0x00, 0x2b, 0xc4, 0x8a, 0xb0, 0x62, 0xac, 0x04, 0x2b, 0xc5,
0xca, 0xb0, 0x72, 0xac, 0x02, 0xab, 0xc4, 0xaa, 0xb0, 0x6a, 0xac, 0x06, 0xab,
0xc5, 0xea, 0xb0, 0x7a, 0xac, 0x01, 0x6b, 0xc4, 0x9a, 0xb0, 0x66, 0xac, 0x05,
0x6b, 0xc5, 0xda, 0xb0, 0x76, 0xac, 0x03, 0xeb, 0xc4, 0xba, 0xb0, 0x6e, 0xac,
0x07, 0xeb, 0xc5, 0xfa, 0xb0, 0x7e, 0x6c, 0x00, 0x1b, 0xc4, 0x86, 0xb0, 0x61,
0x6c, 0x04, 0x1b, 0xc5, 0xc6, 0xb0, 0x71, 0x6c, 0x02, 0x9b, 0xc4, 0xa6, 0xb0,
0x69, 0x6c, 0x06, 0x9b, 0xc5, 0xe6, 0xb0, 0x79, 0x6c, 0x01, 0x5b, 0xc4, 0x7e,
0x60, 0x4b, 0xd8, 0x32, 0xb6, 0x82, 0xad, 0x62, 0x6b, 0xd8, 0x3a, 0xb6, 0x81,
0x6d, 0x62, 0x5b, 0xd8, 0x36, 0x46, 0xc0, 0x88, 0x18, 0x09, 0x23, 0x63, 0x14,
0x8c, 0x8a, 0xd1, 0x30, 0x3a, 0xc6, 0xc0, 0x98, 0x18, 0x0b, 0x63, 0x63, 0x1c,
0x8c, 0x8b, 0xf1, 0x30, 0xfe, 0x5f, 0xd0, 0x85, 0xa0, 0xff, 0x41, 0x5a, 0x22,
0x2d, 0x93, 0x56, 0x48, 0xab, 0xa4, 0x35, 0xd2, 0x3a, 0x69, 0x83, 0xb4, 0x49,
0xda, 0x22, 0x6d, 0x93, 0x08, 0x24, 0x22, 0x89, 0x44, 0x22, 0x93, 0x28, 0x24,
0x2a, 0x89, 0x46, 0xa2, 0x93, 0x18, 0x24, 0x26, 0x89, 0x45, 0x62, 0x93, 0x38,
0x24, 0x2e, 0x89, 0x47, 0xe2, 0x93, 0x04, 0x24, 0x21, 0x49, 0x44, 0x12, 0x93,
0x24, 0x24, 0x29, 0x49, 0x46, 0xda, 0x21, 0xc9, 0x49, 0x0a, 0x92, 0x86, 0xd0,
0x4c, 0x6c, 0xf9, 0xb7, 0x3b, 0x5f, 0x47, 0xac, 0x27, 0x36, 0xa0, 0xda, 0xa6,
0xff, 0x23, 0x27, 0x54, 0xeb, 0x3f, 0x8c, 0xd2, 0x88, 0x64, 0x37, 0x84, 0x38,
0xb2, 0xca, 0x5a, 0x62, 0x1e, 0xb9, 0x80, 0xfc, 0xeb, 0x57, 0x21, 0x39, 0x17,
0x1f, 0x18, 0x5a, 0xc8, 0x4d, 0xe4, 0x56, 0x72, 0x33, 0xb9, 0xc4, 0x40, 0x22,
0xd7, 0x1a, 0xaa, 0x0d, 0x44, 0x32, 0x01, 0xd5, 0x15, 0x50, 0xf2, 0x29, 0x79,
0x14, 0x68, 0x49, 0xf9, 0x24, 0xff, 0x39, 0xd6, 0x39, 0x25, 0x44, 0xf9, 0x3e,
0xf6, 0x01, 0xfd, 0x2b, 0x9e, 0x84, 0x36, 0x64, 0x72, 0x9d, 0x01, 0xec, 0x96,
0x3c, 0x68, 0x88, 0x53, 0x05, 0xa6, 0x3f, 0x6b, 0xda, 0xc9, 0x54, 0xa8, 0x2b,
0xa2, 0x0c, 0x19, 0xfe, 0xd5, 0x2f, 0xcf, 0x50, 0x04, 0xb2, 0x4e, 0x48, 0xa5,
0x86, 0x2e, 0x34, 0x3a, 0x0d, 0xf2, 0x62, 0x4a, 0x29, 0xa5, 0x04, 0x8d, 0x1f,
0xa6, 0x5c, 0xa0, 0x52, 0x07, 0xe3, 0x2b, 0x39, 0xf9, 0xa8, 0x45, 0xbe, 0xa1,
0x98, 0xdc, 0x43, 0xee, 0x26, 0xff, 0x7d, 0x85, 0x97, 0x94, 0xbf, 0xcb, 0x0e,
0xe9, 0xff, 0xa4, 0x1f, 0x2e, 0xbf, 0xd2, 0x89, 0xe6, 0x2d, 0x15, 0xf8, 0x85,
0xfe, 0x5f, 0xbf, 0x4a, 0x60, 0x34, 0x06, 0x1a, 0x51, 0x4f, 0x2f, 0x25, 0x97,
0x19, 0x7a, 0x11, 0xcd, 0x24, 0xb3, 0xc9, 0xf5, 0x06, 0x0e, 0x99, 0x95, 0xbb,
0x56, 0x04, 0xc6, 0xc7, 0xd0, 0x78, 0x47, 0xf4, 0x62, 0xd6, 0xaf, 0x5f, 0x7d,
0x64, 0x2e, 0xd4, 0x44, 0x29, 0xd7, 0x94, 0x2b, 0xa8, 0xb9, 0xa1, 0x66, 0x6b,
0x0c, 0x74, 0x23, 0xbd, 0x84, 0x55, 0xca, 0xfa, 0xc2, 0x51, 0x0e, 0xc2, 0x3d,
0x7f, 0x36, 0x77, 0x3f, 0x95, 0x7d, 0x9b, 0x35, 0x9f, 0xcc, 0x23, 0x37, 0x18,
0x04, 0x64, 0x19, 0xc8, 0x84, 0x64, 0x11, 0xb9, 0xc9, 0xd0, 0x68, 0x90, 0x90,
0xa5, 0xc0, 0x89, 0x7f, 0x5b, 0x5b, 0x05, 0xa5, 0x92, 0x52, 0x45, 0xa9, 0xa6,
0x94, 0x53, 0xea, 0x28, 0x13, 0xa0, 0xbb, 0x11, 0xc3, 0xb8, 0xa1, 0x9e, 0xd2,
0x0f, 0x57, 0x1c, 0x03, 0xae, 0x86, 0x52, 0x4b, 0x29, 0x43, 0xeb, 0x1e, 0x36,
0x8c, 0x1a, 0xbe, 0xf7, 0x7b, 0xa4, 0xf0, 0x0d, 0x69, 0xca, 0x13, 0x45, 0x61,
0xe0, 0x1a, 0x1e, 0x28, 0xc2, 0x5c, 0x5d, 0x06, 0xda, 0x3e, 0x43, 0x8a, 0x51,
0x04, 0x86, 0x17, 0x8a, 0x04, 0xa4, 0x72, 0x83, 0x14, 0xd5, 0x89, 0x0c, 0x71,
0x4a, 0x82, 0xf2, 0x0a, 0x75, 0xb7, 0x14, 0x96, 0xe1, 0x9e, 0x92, 0xa2, 0xdc,
0x51, 0x76, 0x0d, 0x3b, 0x06, 0x9e, 0x21, 0x89, 0xc6, 0x67, 0x1b, 0x6e, 0x72,
0xfa, 0x15, 0x7f, 0x5d, 0x47, 0x66, 0xf8, 0xbb, 0x6e, 0x39, 0x86, 0x11, 0x23,
0x58, 0x0d, 0x2d, 0x83, 0xf4, 0x31, 0x6a, 0xbc, 0x87, 0xb2, 0x88, 0xf6, 0xeb,
0xd7, 0x2b, 0x94, 0x2f, 0xd4, 0x4e, 0xe3, 0x07, 0xf5, 0x99, 0xda, 0x67, 0x1c,
0x83, 0x36, 0x43, 0x90, 0xde, 0x50, 0xab, 0x9f, 0xd4, 0x5b, 0x6a, 0x29, 0xad,
0xdb, 0x88, 0x34, 0x66, 0x4a, 0x50, 0x0b, 0x69, 0x49, 0xea, 0x23, 0xf5, 0x89,
0x3a, 0x60, 0xec, 0x31, 0xbe, 0x53, 0x1f, 0xa8, 0x1d, 0xc6, 0x14, 0x75, 0xd8,
0x58, 0x4c, 0x2b, 0xa3, 0xa5, 0xa9, 0x79, 0xb4, 0x12, 0xda, 0x1d, 0x75, 0xd0,
0x98, 0x4f, 0x1b, 0x37, 0x76, 0x19, 0x3f, 0xa9, 0xbd, 0xa8, 0x57, 0x3f, 0xe4,
0x1e, 0xba, 0xda, 0x64, 0x32, 0xd9, 0x60, 0x87, 0x70, 0x93, 0x89, 0xee, 0x42,
0x3b, 0x65, 0xa1, 0xcb, 0x4d, 0x6e, 0xfa, 0x8e, 0x49, 0x69, 0x3a, 0x30, 0xed,
0x9b, 0x82, 0x74, 0x2f, 0x5d, 0x64, 0x92, 0x98, 0x4e, 0xe9, 0x56, 0xba, 0xd4,
0xa4, 0x35, 0x19, 0x4c, 0x4e, 0xfa, 0xae, 0x49, 0x6c, 0x3a, 0xa6, 0xcb, 0x4c,
0x27, 0x74, 0x05, 0xd8, 0xaa, 0x03, 0x7a, 0x99, 0x21, 0xf9, 0xe9, 0x3a, 0x53,
0x80, 0x7e, 0x04, 0x12, 0xbd, 0xc9, 0x68, 0xf2, 0xd1, 0x55, 0x26, 0x21, 0xd0,
0x1a, 0x93, 0x9d, 0x7e, 0x68, 0xc2, 0xe9, 0x98, 0xe9, 0x3f, 0xfb, 0x5f, 0x0b,
0xab, 0x02, 0x59, 0xc0, 0xb9, 0xf9, 0xda, 0xfc, 0xeb, 0x57, 0x39, 0xab, 0x9e,
0xd5, 0x0d, 0xfc, 0xad, 0x39, 0x61, 0xbe, 0x32, 0xe7, 0x22, 0x69, 0x56, 0xd2,
0x7c, 0x61, 0x6e, 0x67, 0xd5, 0xb1, 0xda, 0x58, 0x41, 0x90, 0xc5, 0x21, 0x85,
0xcc, 0x4d, 0xac, 0x30, 0x94, 0x01, 0x73, 0x27, 0xab, 0x86, 0xd5, 0xca, 0xaa,
0x86, 0x3e, 0x67, 0xe6, 0x4b, 0x90, 0xdc, 0x98, 0x9b, 0x59, 0x0d, 0xac, 0xa8,
0xb9, 0x83, 0x15, 0x33, 0x47, 0xcc, 0xb5, 0xac, 0x2e, 0x56, 0x23, 0xab, 0x8a,
0x55, 0xc6, 0xfa, 0xa7, 0x6b, 0xa7, 0xa0, 0xfd, 0x09, 0x67, 0x1f, 0xec, 0xce,
0x0e, 0xc9, 0xcd, 0xb1, 0xd9, 0xac, 0x36, 0xa7, 0xcd, 0x65, 0xd3, 0x01, 0x67,
0xe6, 0xe4, 0x22, 0x43, 0x8e, 0x85, 0xf3, 0x67, 0x7b, 0x83, 0x0d, 0xe3, 0x18,
0x6d, 0xb0, 0x62, 0x90, 0x1c, 0x73, 0x54, 0x1c, 0x35, 0x27, 0x60, 0x53, 0xf3,
0x41, 0x87, 0x1c, 0x13, 0xc7, 0x64, 0xb3, 0x72, 0x3a, 0x9d, 0x7a, 0x8e, 0xdb,
0xe6, 0xe2, 0x38, 0x39, 0x46, 0x8e, 0xc5, 0x76, 0x02, 0x2d, 0x8f, 0x6c, 0x06,
0x8e, 0xc7, 0xe6, 0xe0, 0xe0, 0x36, 0x0d, 0xf4, 0x39, 0xe0, 0x68, 0x39, 0x5e,
0x9b, 0x8d, 0x73, 0xc8, 0xf1, 0x72, 0x4e, 0x39, 0xc7, 0x36, 0x0f, 0xc8, 0x4e,
0x6d, 0x66, 0x9b, 0x1f, 0x5a, 0xda, 0x21, 0xf9, 0x20, 0x39, 0x6c, 0x7f, 0x5e,
0xed, 0x28, 0x77, 0xdd, 0x41, 0x67, 0x2b, 0x78, 0xa0, 0x08, 0xae, 0xd3, 0xe5,
0x1c, 0x70, 0x0a, 0xf9, 0xcd, 0x4e, 0x29, 0xbf, 0xdd, 0xd9, 0xe0, 0x14, 0xf3,
0x5b, 0x9c, 0x72, 0xbe, 0x0a, 0xe4, 0xa3, 0x50, 0x5f, 0x0f, 0x49, 0x01, 0xf4,
0x08, 0xf2, 0x56, 0x09, 0xbf, 0xcd, 0x29, 0xe0, 0x37, 0x3a, 0x6b, 0x9d, 0xdd,
0xce, 0x3a, 0x67, 0x8d, 0xb3, 0xc3, 0xd9, 0xe7, 0xec, 0x77, 0xca, 0xf8, 0xd9,
0xba, 0x4e, 0x4f, 0x8f, 0xb3, 0xda, 0xd9, 0x0b, 0xed, 0xf6, 0xf9, 0x43, 0x4e,
0x0d, 0xbf, 0x0a, 0xa8, 0x26, 0xe7, 0xb0, 0x53, 0xc9, 0xdf, 0xe5, 0xef, 0xf0,
0xf7, 0x50, 0x1b, 0x1e, 0xca, 0xf9, 0x28, 0x3f, 0x12, 0xfd, 0xfa, 0xd5, 0xe3,
0x69, 0xf5, 0x00, 0x42, 0x00, 0xd5, 0xeb, 0xf9, 0x63, 0x56, 0xcd, 0x9e, 0x36,
0x8f, 0x4e, 0xd4, 0x8e, 0x38, 0x4c, 0xd4, 0x0d, 0x65, 0xa3, 0xa7, 0xc1, 0x63,
0x80, 0x16, 0x46, 0x91, 0x5e, 0x64, 0x12, 0xd5, 0x7b, 0xba, 0x3c, 0x1d, 0x9e,
0xa6, 0x5c, 0xeb, 0x03, 0x51, 0x8b, 0xe7, 0xaf, 0xda, 0x37, 0x4a, 0x75, 0x52,
0x99, 0xdf, 0x2c, 0xdd, 0xf3, 0x6b, 0xfc, 0x7a, 0x29, 0x26, 0x55, 0xf8, 0x0f,
0xa5, 0x07, 0x7e, 0x93, 0x54, 0x07, 0x08, 0xa0, 0xf6, 0xe3, 0x52, 0xf0, 0x1e,
0xbf, 0x41, 0x2a, 0x01, 0x4e, 0xe5, 0x57, 0x42, 0xbe, 0xe3, 0x3f, 0x92, 0x4a,
0xfd, 0x16, 0xe9, 0xae, 0x5f, 0xeb, 0x97, 0xfb, 0xf7, 0x11, 0x4e, 0x48, 0xe5,
0x22, 0x39, 0xb4, 0x83, 0xf4, 0x7a, 0x7e, 0x7f, 0x2e, 0x94, 0xf3, 0xe4, 0xe9,
0x73, 0x74, 0x77, 0x29, 0x7f, 0x84, 0xf2, 0x19, 0xd1, 0x9f, 0x28, 0xff, 0x79,
0xfe, 0x72, 0xce, 0x95, 0xdf, 0x9d, 0xb3, 0xe5, 0x0f, 0xe7, 0x32, 0xf9, 0x13,
0xc8, 0xde, 0xce, 0xf9, 0x72, 0x8e, 0xfc, 0xe3, 0xfc, 0xfd, 0x5c, 0x02, 0xfd,
0x33, 0x20, 0x79, 0xd9, 0x4d, 0x5c, 0x82, 0xbf, 0x5f, 0xbe, 0xee, 0x42, 0x5f,
0x48, 0x77, 0x97, 0xc9, 0xcb, 0xe8, 0xe5, 0x13, 0x50, 0x6f, 0xbb, 0x57, 0x97,
0x8f, 0xbb, 0x3f, 0x77, 0xe3, 0x97, 0x37, 0x97, 0xef, 0xbb, 0x1f, 0xbb, 0xf7,
0x97, 0xb7, 0x97, 0xa9, 0xcb, 0x3f, 0xd6, 0xc1, 0x54, 0xbd, 0x5c, 0xd3, 0x54,
0x8f, 0xd7, 0x0c, 0x15, 0x4b, 0x05, 0x77, 0x3a, 0xd7, 0x74, 0xc8, 0x9f, 0xaf,
0x61, 0xc4, 0x6b, 0x14, 0x35, 0x6a, 0xf6, 0x12, 0x2b, 0x9a, 0xdd, 0x04, 0xa0,
0x72, 0x42, 0x91, 0x90, 0x27, 0xb2, 0x32, 0x55, 0x62, 0x49, 0x93, 0x2d, 0x77,
0x52, 0xf2, 0xd4, 0xaf, 0x5f, 0xd7, 0x97, 0xb2, 0xd4, 0xaa, 0xa6, 0xf7, 0xe0,
0xe6, 0x3e, 0x71, 0x0f, 0xf6, 0xa8, 0xf3, 0xe8, 0xf6, 0x1f, 0x35, 0x8f, 0x53,
0x87, 0x93, 0x87, 0xb6, 0x67, 0xf0, 0x08, 0x72, 0x3f, 0x59, 0x0e, 0x28, 0xb7,
0x43, 0x6e, 0xa4, 0x34, 0x50, 0x3e, 0x28, 0xef, 0x94, 0x9f, 0x94, 0x37, 0x40,
0x97, 0x0a, 0x5a, 0x39, 0xad, 0x92, 0xf6, 0x75, 0xca, 0x80, 0x1f, 0x9e, 0xd1,
0x43, 0x90, 0xf7, 0x80, 0xa5, 0xb7, 0x13, 0x83, 0xb6, 0x0e, 0xa2, 0x96, 0xdf,
0x45, 0xec, 0x24, 0xf6, 0x81, 0xde, 0xbb, 0x89, 0x3b, 0xf2, 0x1e, 0x38, 0xd3,
0x2a, 0x60, 0x1c, 0x05, 0xf9, 0x93, 0x12, 0x86, 0x76, 0x95, 0xe4, 0x3d, 0xf2,
0x2e, 0x59, 0x89, 0xf0, 0x33, 0x8f, 0xfa, 0xc7, 0x28, 0x55, 0xb4, 0x4b, 0xfa,
0x05, 0x3d, 0x92, 0x3b, 0x07, 0x02, 0x39, 0xfb, 0x63, 0xab, 0xbe, 0xef, 0x5a,
0x0d, 0xe0, 0x58, 0x13, 0xa5, 0x19, 0xe1, 0x5b, 0x3e, 0xf4, 0x9b, 0x00, 0x34,
0xe9, 0x63, 0xf5, 0xb2, 0xce, 0x6d, 0x67, 0xb6, 0x03, 0xb0, 0x17, 0x15, 0xb9,
0xf9, 0x1b, 0xd2, 0x99, 0xc1, 0xfb, 0xfb, 0x61, 0x46, 0xe7, 0x30, 0x56, 0x90,
0x73, 0xf6, 0xe5, 0x49, 0x1c, 0x18, 0xb3, 0x25, 0x87, 0x91, 0x05, 0x54, 0xe5,
0x57, 0x8f, 0x6a, 0x5a, 0x0d, 0xac, 0x69, 0x12, 0xe1, 0x94, 0xc5, 0x14, 0xa5,
0x5b, 0xbf, 0xa1, 0x47, 0xd8, 0x76, 0x61, 0xbb, 0x80, 0x11, 0x2e, 0xc1, 0x43,
0x42, 0xb6, 0x4b, 0x4e, 0x98, 0x13, 0xe2, 0x44, 0x80, 0x1e, 0x73, 0xfe, 0x51,
0xdf, 0x8f, 0x2c, 0xec, 0xd0, 0x9f, 0x17, 0xfa, 0x83, 0xff, 0xdc, 0xe5, 0xaa,
0x5e, 0x61, 0x0f, 0xaa, 0xc8, 0x1d, 0xe4, 0xff, 0x84, 0x40, 0x3a, 0xbe, 0x19,
0xac, 0x56, 0x0e, 0x36, 0x50, 0x60, 0x50, 0x43, 0xcb, 0x76, 0x4a, 0x2b, 0xa5,
0x0d, 0xcd, 0xed, 0x8a, 0x5e, 0x4d, 0xae, 0x01, 0xc9, 0x00, 0xea, 0xaf, 0x21,
0xef, 0x93, 0xb5, 0x64, 0x95, 0xa1, 0x03, 0xea, 0x26, 0x61, 0xc6, 0x25, 0xb0,
0x7a, 0xb5, 0xa1, 0x88, 0x5a, 0x4c, 0xdd, 0x43, 0xf3, 0x2f, 0xa5, 0x16, 0x52,
0xff, 0x1c, 0x73, 0xca, 0x98, 0x60, 0x4e, 0xa3, 0x55, 0xcc, 0xa0, 0xbc, 0x8e,
0x56, 0x8b, 0xf6, 0xaa, 0x91, 0x56, 0x4f, 0x6b, 0xc8, 0xed, 0x5a, 0x12, 0xf4,
0x9c, 0xa0, 0x3b, 0x4d, 0x76, 0x93, 0x03, 0x56, 0x69, 0x33, 0xdd, 0xd2, 0xe3,
0xf4, 0x18, 0xc8, 0x6e, 0xe8, 0xd7, 0xdf, 0x4e, 0xe2, 0x14, 0xd0, 0x83, 0xac,
0x3b, 0x40, 0xaa, 0x63, 0xd3, 0x18, 0x68, 0xf2, 0xde, 0x3c, 0xc4, 0x1a, 0x65,
0x8d, 0xb0, 0x86, 0x59, 0x03, 0x39, 0x4c, 0xbb, 0x06, 0x1d, 0x5c, 0x71, 0x6e,
0x6c, 0x91, 0x9c, 0x76, 0xaf, 0x6c, 0xd7, 0x9c, 0x28, 0x27, 0xc6, 0x89, 0xd9,
0xe2, 0x50, 0x13, 0xb5, 0x25, 0x6c, 0xbf, 0x3d, 0x77, 0x12, 0x1d, 0xf2, 0xc7,
0x9d, 0x93, 0xce, 0x09, 0xe7, 0x94, 0x53, 0x8f, 0xfc, 0xdb, 0x02, 0xab, 0xb7,
0x8a, 0x6c, 0x90, 0xdb, 0xa4, 0x18, 0x78, 0x95, 0xde, 0x7f, 0xe4, 0x37, 0xf8,
0xed, 0xe0, 0x7f, 0x56, 0x69, 0x7e, 0xa8, 0x20, 0xb4, 0x2b, 0x57, 0xc8, 0x3b,
0x2e, 0x90, 0x9d, 0x28, 0xf3, 0x95, 0x05, 0xca, 0x22, 0x65, 0xfa, 0xf2, 0xe1,
0xb2, 0x50, 0xf9, 0xc7, 0x78, 0x3c, 0xd8, 0x49, 0x3e, 0xb2, 0x90, 0xe4, 0xfd,
0xc1, 0xa3, 0xf6, 0xd1, 0x0e, 0x36, 0x5b, 0x9b, 0xd3, 0x77, 0x17, 0xa5, 0x13,
0xe9, 0xb1, 0x0c, 0xe9, 0x45, 0x83, 0xb4, 0xd4, 0x4c, 0x6b, 0xa1, 0x35, 0xd1,
0x5a, 0x69, 0xb3, 0xc6, 0x39, 0xe3, 0xbf, 0xdb, 0x91, 0x7b, 0xba, 0x0b, 0x34,
0x72, 0x07, 0x2b, 0x4f, 0x9b, 0xa7, 0x58, 0x0f, 0xe6, 0xc9, 0xdc, 0x4a, 0xc7,
0xa1, 0x9c, 0xc8, 0xd1, 0xc9, 0xaf, 0x55, 0x61, 0xfc, 0x19, 0xb0, 0x00, 0x23,
0x7f, 0xda, 0x19, 0x11, 0x18, 0xf8, 0x47, 0xb0, 0x26, 0x27, 0xac, 0xe5, 0x58,
0xe4, 0x10, 0x39, 0xa4, 0xd9, 0x7a, 0x97, 0xd4, 0x2d, 0x75, 0x02, 0x75, 0x8c,
0xb8, 0x42, 0xb0, 0x8e, 0xa2, 0x9c, 0x85, 0x3c, 0x5e, 0x16, 0x2b, 0x33, 0xe0,
0xc5, 0x02, 0x95, 0x3a, 0xb1, 0x06, 0x1e, 0x79, 0x7b, 0xdf, 0xac, 0x03, 0x6d,
0x93, 0x0f, 0xc8, 0x2d, 0x30, 0x57, 0x1d, 0xf9, 0x90, 0xdc, 0x4d, 0xe9, 0x81,
0x15, 0x94, 0x53, 0xe7, 0x8d, 0x6e, 0xd3, 0x09, 0xcc, 0x69, 0x9a, 0x75, 0x6b,
0xc3, 0xf9, 0x26, 0xfe, 0xa0, 0x67, 0x00, 0x59, 0x5b, 0x1d, 0x59, 0x4f, 0xee,
0x85, 0x16, 0x66, 0x7e, 0x21, 0xf4, 0x98, 0x32, 0xf4, 0x01, 0xad, 0x35, 0x54,
0x52, 0x2b, 0xa8, 0xfb, 0x86, 0x36, 0xda, 0xf7, 0x35, 0xc5, 0xd1, 0xee, 0xcc,
0xc2, 0x4c, 0x4f, 0xa4, 0xc5, 0x21, 0xa5, 0x3c, 0xcb, 0xbd, 0x21, 0x84, 0xf8,
0xf9, 0x00, 0x6b, 0x40, 0x1a, 0xf3, 0x98, 0x32, 0x66, 0x1b, 0xdf, 0xc2, 0xb7,
0xf2, 0xeb, 0x81, 0x1f, 0x22, 0x9b, 0x89, 0x46, 0x28, 0x0d, 0xe4, 0x23, 0xf2,
0x20, 0x65, 0x00, 0x46, 0x9e, 0x36, 0x1c, 0xe4, 0x3c, 0xe5, 0x91, 0x9e, 0xa6,
0x67, 0xe8, 0x0f, 0xc8, 0x4e, 0x66, 0x90, 0x46, 0x5c, 0xb0, 0xe6, 0x06, 0x68,
0x6d, 0x82, 0x34, 0x4c, 0x19, 0x82, 0xd6, 0x0b, 0x48, 0xbf, 0x4f, 0xdf, 0x6c,
0xa9, 0x15, 0x7a, 0x8f, 0x52, 0x46, 0x28, 0x55, 0xd4, 0x6a, 0xea, 0xa2, 0xb1,
0x1d, 0xe6, 0xd7, 0x01, 0xe9, 0x99, 0xfe, 0x42, 0x7f, 0x85, 0x56, 0xb3, 0xac,
0x47, 0x74, 0xe2, 0xde, 0xa0, 0x99, 0x16, 0x41, 0x5b, 0xfc, 0x9b, 0xdf, 0xe8,
0x72, 0x57, 0xfe, 0x61, 0x5c, 0x42, 0xe3, 0x7a, 0x41, 0x1b, 0x3e, 0x48, 0xcf,
0xe6, 0x27, 0xf3, 0xab, 0xf9, 0xc5, 0x3c, 0x07, 0xb3, 0x98, 0x73, 0x26, 0x39,
0x29, 0x5b, 0xe2, 0xcb, 0xcb, 0x87, 0x3c, 0x6e, 0x98, 0xd5, 0xf0, 0x17, 0xf2,
0x97, 0x84, 0xf6, 0xe4, 0x5f, 0x34, 0xd8, 0x4f, 0xea, 0xfe, 0x2b, 0x16, 0x86,
0xd1, 0xc7, 0xfe, 0x12, 0x93, 0xda, 0xf9, 0x5f, 0xf1, 0x38, 0x79, 0x98, 0x6c,
0x21, 0x9b, 0x61, 0x36, 0xd6, 0xdf, 0x3c, 0xf9, 0x1d, 0x66, 0xfd, 0x46, 0xff,
0xc8, 0xad, 0x70, 0x3e, 0x67, 0x19, 0xb7, 0x70, 0xfd, 0xf7, 0xeb, 0x5a, 0xed,
0x08, 0x79, 0x82, 0xb2, 0x46, 0xf9, 0x01, 0xa3, 0xce, 0x52, 0x66, 0x28, 0x4b,
0x94, 0x45, 0xca, 0x14, 0x65, 0x9d, 0x32, 0x4d, 0x19, 0xa7, 0xac, 0x52, 0x56,
0x28, 0xcb, 0x94, 0xc9, 0xac, 0x8e, 0xd0, 0x35, 0xe7, 0x51, 0xbe, 0x41, 0x99,
0xa3, 0x34, 0x82, 0xa5, 0xb6, 0x53, 0x9b, 0x21, 0xef, 0xa4, 0x1e, 0x1a, 0xda,
0xa8, 0x35, 0xd4, 0x7a, 0x6a, 0x13, 0xb5, 0x8e, 0xda, 0x4a, 0xed, 0xa0, 0xd6,
0x52, 0x1b, 0xa8, 0x2d, 0xd4, 0x2e, 0xea, 0xbf, 0xae, 0xbf, 0x6d, 0xdc, 0x00,
0x5d, 0x8c, 0xd2, 0x36, 0x8d, 0x9d, 0xb4, 0x6e, 0xda, 0x12, 0x6d, 0x2e, 0xb7,
0xe3, 0x14, 0xe3, 0x96, 0xb1, 0x97, 0xd6, 0x4f, 0x23, 0x1b, 0xc7, 0x68, 0xab,
0xc6, 0x1f, 0xb4, 0x65, 0x5a, 0x17, 0x6d, 0x1a, 0xea, 0x96, 0x8d, 0x8b, 0x90,
0x0f, 0x41, 0x9a, 0xa1, 0xcd, 0xd2, 0x56, 0x8c, 0x53, 0xb4, 0x89, 0x2c, 0xda,
0xd1, 0xe6, 0x69, 0x04, 0x63, 0x0f, 0x50, 0x0b, 0x34, 0x92, 0x71, 0x84, 0x36,
0x08, 0xd4, 0xba, 0x71, 0x80, 0x46, 0x35, 0x0e, 0x03, 0x35, 0x9e, 0x1b, 0xb3,
0x8f, 0x46, 0xfc, 0xf2, 0x97, 0xb5, 0x7f, 0xe3, 0x39, 0x37, 0xa6, 0xb8, 0xa9,
0x96, 0x91, 0x34, 0xa5, 0x4c, 0x97, 0xa6, 0x2b, 0xd3, 0xad, 0xa9, 0x8e, 0x91,
0x95, 0x86, 0x4c, 0x11, 0x84, 0xa2, 0x31, 0x53, 0xb9, 0xa5, 0x92, 0x51, 0x6d,
0xf9, 0x49, 0x8f, 0x9a, 0x3e, 0xe9, 0x55, 0x8c, 0x62, 0x46, 0x3e, 0xd4, 0x87,
0x4d, 0x45, 0x8c, 0x72, 0x46, 0x03, 0xe3, 0xc2, 0xe4, 0x37, 0x15, 0x32, 0x02,
0xa6, 0x33, 0x68, 0x5b, 0x02, 0xf2, 0x32, 0xc6, 0xa9, 0xe9, 0x1c, 0xf5, 0xab,
0x67, 0x54, 0x33, 0xae, 0x4d, 0x8d, 0x20, 0xab, 0x60, 0x04, 0x4d, 0xa5, 0x68,
0xcc, 0x02, 0x46, 0x1e, 0x94, 0x09, 0xa8, 0xaf, 0x61, 0xfc, 0xeb, 0xfa, 0x65,
0x96, 0x77, 0x73, 0xa5, 0x05, 0xd9, 0xb4, 0x79, 0x95, 0x45, 0x67, 0xfd, 0x60,
0xd1, 0x58, 0x5b, 0x2c, 0x32, 0x6b, 0x81, 0xf5, 0x61, 0x2e, 0xb4, 0x90, 0x58,
0xb5, 0x16, 0x0a, 0xec, 0xd1, 0x1a, 0xda, 0xa7, 0x62, 0x4b, 0x81, 0x65, 0x05,
0xa8, 0x37, 0x33, 0x95, 0x55, 0x61, 0xd9, 0x64, 0x55, 0x59, 0x18, 0xac, 0x45,
0xd6, 0x36, 0x6b, 0x83, 0x95, 0x67, 0x21, 0xb0, 0x4a, 0x2c, 0xa5, 0x96, 0x75,
0x16, 0x91, 0xb5, 0xfc, 0x15, 0xb7, 0x2d, 0xb1, 0x3e, 0xcd, 0xdf, 0xd7, 0x5a,
0x64, 0xf9, 0x7d, 0xed, 0x35, 0xc0, 0x17, 0xd9, 0xdf, 0x39, 0xf7, 0x80, 0x0b,
0x4f, 0xb6, 0x0c, 0x27, 0x8f, 0x9b, 0xb1, 0xa5, 0x38, 0xaf, 0x9c, 0x4f, 0xce,
0x3b, 0x48, 0xde, 0x38, 0x3f, 0x91, 0x55, 0x7e, 0xda, 0x1e, 0x39, 0x8f, 0x39,
0xe4, 0x28, 0xb0, 0x17, 0xda, 0xc1, 0x7e, 0x39, 0xf9, 0xf6, 0x07, 0x4e, 0x21,
0x17, 0x4e, 0x7f, 0xdb, 0x3d, 0xb4, 0x29, 0xb1, 0xbf, 0xda, 0x7e, 0xda, 0x9e,
0x38, 0x05, 0xdc, 0x37, 0xdb, 0x07, 0x27, 0xcf, 0x5e, 0x6a, 0x27, 0x80, 0xcf,
0x16, 0xdb, 0x8b, 0xb8, 0x77, 0x9c, 0x0f, 0xdb, 0x03, 0xf4, 0x7d, 0x41, 0x23,
0xa5, 0xd1, 0x28, 0xcf, 0xb6, 0x7f, 0xf3, 0x44, 0xc4, 0x96, 0xcf, 0xcd, 0x96,
0x2b, 0xd0, 0xf7, 0x92, 0x4f, 0x73, 0x86, 0xf9, 0x67, 0xfc, 0x4d, 0xe7, 0x29,
0x9f, 0xe8, 0x8c, 0xf2, 0x97, 0x9d, 0x1b, 0xce, 0x75, 0x67, 0x9a, 0x13, 0xe2,
0x53, 0xa0, 0x96, 0xee, 0x5c, 0x84, 0xfc, 0x1a, 0xfc, 0x84, 0xe1, 0xbc, 0x02,
0x8b, 0xf7, 0xf2, 0xdd, 0xfc, 0x6d, 0xe7, 0x31, 0x50, 0x54, 0x90, 0xfb, 0xf8,
0x4c, 0xc8, 0x7f, 0x38, 0xc9, 0xce, 0x00, 0x7f, 0xc9, 0xb9, 0xea, 0xdc, 0x42,
0x67, 0x5d, 0x90, 0xef, 0xe7, 0x5f, 0x7f, 0x79, 0xc7, 0x05, 0x50, 0x27, 0x7c,
0x87, 0x00, 0xf0, 0x83, 0xbf, 0xe6, 0x8c, 0xf0, 0xcf, 0xf9, 0x24, 0xa7, 0x2b,
0x57, 0xeb, 0xe4, 0xff, 0xd3, 0xec, 0xe6, 0x9d, 0x0b, 0xce, 0x89, 0x9c, 0x57,
0x9e, 0x88, 0x7c, 0xa2, 0x25, 0xcf, 0xad, 0x68, 0xd5, 0xe3, 0x11, 0xcd, 0x7b,
0x82, 0xa2, 0x4b, 0xd1, 0x9e, 0x04, 0x9d, 0xb6, 0xa2, 0x19, 0x4f, 0x4a, 0x74,
0x2a, 0xba, 0x10, 0x2d, 0x7b, 0x4e, 0xfc, 0x1b, 0x9e, 0x59, 0x68, 0x3f, 0xe2,
0x59, 0xf4, 0x4c, 0x7b, 0x42, 0xa2, 0x35, 0xd4, 0x37, 0x20, 0xba, 0x17, 0xc5,
0x61, 0xde, 0x67, 0x22, 0x3f, 0xe4, 0x57, 0x90, 0xd6, 0x3d, 0x53, 0x9e, 0x05,
0xcf, 0x0f, 0xcf, 0x98, 0x67, 0xc5, 0xe3, 0x15, 0x8d, 0x42, 0xab, 0x73, 0xd1,
0x9d, 0x28, 0x21, 0x1a, 0xf7, 0x44, 0x45, 0x08, 0xb3, 0x45, 0x31, 0x51, 0x04,
0xa8, 0xb9, 0x6f, 0xb1, 0xe0, 0x8d, 0xe8, 0x8f, 0xd2, 0xe5, 0xb7, 0xc3, 0xd9,
0x73, 0xee, 0x37, 0xfa, 0x8f, 0xfd, 0x11, 0x69, 0x54, 0x1a, 0x94, 0xfa, 0xfd,
0xd7, 0x52, 0xab, 0xdf, 0xe2, 0xc7, 0xfd, 0x41, 0xbf, 0x5f, 0xea, 0xf1, 0x9b,
0xfd, 0x67, 0x52, 0xb7, 0xdf, 0x27, 0x75, 0xf8, 0xbd, 0xfe, 0x53, 0x14, 0xfd,
0x9d, 0xf9, 0x2f, 0xa4, 0x26, 0x7f, 0x40, 0x6a, 0x03, 0xce, 0x03, 0xe8, 0x7e,
0x29, 0xf5, 0xf9, 0xcf, 0xa5, 0x21, 0xe9, 0x95, 0xf4, 0x54, 0xda, 0x4b, 0xf4,
0x4a, 0x9d, 0xfe, 0x6f, 0xd1, 0x03, 0x42, 0xff, 0x40, 0x4e, 0x62, 0x96, 0x1f,
0x01, 0x12, 0x35, 0x87, 0xea, 0xe1, 0x24, 0xa8, 0x0c, 0x69, 0xe5, 0x2a, 0x79,
0x53, 0x48, 0x2d, 0xaf, 0x09, 0xd5, 0x01, 0xdf, 0x08, 0x49, 0x07, 0xb5, 0x26,
0xf9, 0x21, 0x42, 0xab, 0xf2, 0x90, 0x5e, 0x8e, 0xc9, 0xab, 0x42, 0x38, 0x70,
0x15, 0xa1, 0xda, 0xd0, 0x81, 0xbc, 0x2c, 0x64, 0x90, 0xef, 0xe7, 0x90, 0x4c,
0x23, 0xaf, 0x0e, 0x35, 0x40, 0x0f, 0xa3, 0xfc, 0x77, 0x1d, 0x97, 0x82, 0xac,
0x5a, 0x59, 0x1a, 0x01, 0xab, 0x84, 0x54, 0xaa, 0x6c, 0x54, 0x36, 0x01, 0xe2,
0x55, 0x28, 0x0b, 0x22, 0x55, 0xca, 0xd7, 0xcb, 0x06, 0xa0, 0x4b, 0x22, 0xe5,
0xca, 0xb2, 0x48, 0x19, 0x50, 0x85, 0x91, 0xe2, 0x48, 0xa5, 0x32, 0x3f, 0xf2,
0x76, 0xf9, 0x8c, 0x62, 0xca, 0x49, 0xcf, 0x4f, 0x28, 0x9f, 0x2e, 0x3f, 0x2e,
0xdf, 0xa1, 0x7c, 0x81, 0x54, 0xab, 0xfc, 0xb2, 0xf3, 0x1c, 0x55, 0xa7, 0xfc,
0xbc, 0x14, 0xaa, 0xf2, 0x22, 0xb9, 0x67, 0x12, 0x31, 0xf0, 0x39, 0x38, 0x4d,
0x54, 0xaa, 0x82, 0x98, 0x54, 0xa5, 0x50, 0xe5, 0x03, 0x2f, 0x57, 0x49, 0x54,
0x3b, 0x2a, 0x91, 0x6a, 0x4f, 0x55, 0x18, 0xfb, 0xbc, 0x56, 0xaa, 0x3e, 0xae,
0x77, 0x55, 0x45, 0xb1, 0xbc, 0x58, 0x3d, 0x8c, 0xa0, 0x56, 0x95, 0xc4, 0x64,
0x2a, 0xf1, 0x57, 0x64, 0xa7, 0x4f, 0x1c, 0x25, 0x36, 0x34, 0x86, 0x04, 0x96,
0x38, 0x4c, 0xe8, 0x12, 0x5b, 0x9a, 0x83, 0xc4, 0xb6, 0xe6, 0xcf, 0xba, 0xfd,
0x84, 0x36, 0xb1, 0xae, 0x21, 0x68, 0x36, 0x91, 0x44, 0x03, 0x11, 0x6c, 0x9d,
0x16, 0xa2, 0xd9, 0x94, 0x22, 0xa5, 0x4e, 0xed, 0x41, 0xfc, 0xba, 0x9b, 0x52,
0xa5, 0x7e, 0x5f, 0x7b, 0xdf, 0x41, 0xfa, 0xfe, 0xe1, 0xbe, 0x05, 0xce, 0xd2,
0xcc, 0xfd, 0xdd, 0xfd, 0xe3, 0xfd, 0xfd, 0x7d, 0xbd, 0x36, 0x17, 0x93, 0x3d,
0xe4, 0x67, 0xda, 0x75, 0x79, 0x99, 0x36, 0x5d, 0xab, 0xee, 0xcf, 0xd6, 0x1d,
0xba, 0xc3, 0x47, 0xfd, 0x23, 0xd8, 0xba, 0xce, 0xab, 0x3b, 0xd5, 0xe9, 0x80,
0xf2, 0x3c, 0x9d, 0x3c, 0xc1, 0x69, 0x77, 0x38, 0x7b, 0x38, 0x73, 0xe8, 0x7d,
0x3a, 0x3a, 0xa4, 0xbe, 0xe4, 0xe2, 0x82, 0x43, 0xc0, 0xd6, 0x97, 0x5b, 0xc4,
0x95, 0xa3, 0xf3, 0x68, 0x8b, 0xb2, 0x09, 0xd8, 0xdd, 0x4b, 0xed, 0xa1, 0x62,
0x86, 0x6e, 0xaa, 0x1e, 0xc9, 0xd6, 0x68, 0x0c, 0xc0, 0x47, 0x3a, 0xc2, 0xc8,
0x15, 0xda, 0x3a, 0xc2, 0x4f, 0x1a, 0x70, 0xab, 0xbf, 0x9d, 0xc7, 0x77, 0x80,
0x5d, 0xf7, 0xa6, 0xa6, 0x2f, 0xf4, 0x62, 0xb2, 0xca, 0xec, 0xe5, 0xf6, 0x62,
0x6e, 0x09, 0xf2, 0x5b, 0xb6, 0x33, 0xc6, 0xbf, 0xe1, 0xb3, 0x9c, 0x71, 0xfe,
0xa6, 0x27, 0x2d, 0xfa, 0x7a, 0xce, 0x2e, 0x8d, 0x4b, 0x43, 0x60, 0x41, 0x56,
0xd8, 0x6b, 0x0b, 0xa4, 0xf2, 0x48, 0x59, 0xac, 0x14, 0x34, 0x3d, 0xf9, 0x3a,
0x4a, 0x6e, 0x87, 0x6b, 0xcf, 0x18, 0x66, 0xbf, 0x22, 0xd9, 0x01, 0xea, 0x08,
0xd5, 0x00, 0xdc, 0x10, 0x75, 0x90, 0x7a, 0x64, 0x18, 0xa6, 0xf6, 0xa3, 0x73,
0xa3, 0x8f, 0x6a, 0xfc, 0xed, 0x39, 0x00, 0x15, 0xcd, 0x89, 0x04, 0xf9, 0x16,
0x8d, 0x99, 0x43, 0x75, 0x16, 0x94, 0x04, 0x90, 0x70, 0x8c, 0x1b, 0x34, 0xae,
0x91, 0x6d, 0xdc, 0xa6, 0x11, 0x69, 0x14, 0x1a, 0x99, 0xb6, 0x49, 0xe3, 0x19,
0xff, 0x53, 0x1c, 0xdb, 0xce, 0xf8, 0x84, 0x35, 0x75, 0xc2, 0x8a, 0x3a, 0x20,
0xe5, 0xe1, 0x6d, 0x8c, 0x56, 0xc6, 0x23, 0x48, 0x32, 0x90, 0xd2, 0xa6, 0x67,
0xd3, 0x93, 0xe9, 0xc1, 0xf4, 0x61, 0xfa, 0x69, 0x7a, 0x33, 0xbd, 0x98, 0x5a,
0x72, 0xeb, 0x7e, 0x37, 0x75, 0x31, 0xf2, 0xf1, 0x2c, 0xf5, 0x0a, 0xad, 0x58,
0xac, 0x66, 0xc6, 0x5f, 0xde, 0x75, 0xb1, 0x9a, 0x10, 0xce, 0x76, 0xe4, 0xd0,
0x56, 0xc8, 0x6a, 0xb3, 0xf4, 0x00, 0xdd, 0x6c, 0x69, 0xb7, 0x74, 0x5a, 0xba,
0x2d, 0xad, 0x40, 0xb7, 0x58, 0xea, 0x2d, 0x0d, 0x16, 0x0e, 0x20, 0x35, 0x8f,
0xc5, 0x65, 0x35, 0x5a, 0xba, 0x2c, 0x7f, 0x7b, 0xd7, 0xf7, 0xdb, 0xdd, 0x77,
0x9d, 0xa5, 0x11, 0x70, 0xb7, 0xc1, 0xde, 0x6a, 0xaf, 0x81, 0xb2, 0xde, 0x5e,
0x07, 0x79, 0x13, 0xa4, 0x36, 0x7b, 0x29, 0xb7, 0x02, 0x69, 0xbf, 0xd6, 0xde,
0x6c, 0xff, 0xa3, 0x6d, 0x39, 0xb7, 0x02, 0x28, 0x3e, 0x4b, 0xe1, 0x6c, 0x81,
0xb2, 0x1a, 0x52, 0x19, 0xb7, 0xca, 0xfe, 0xdb, 0xd8, 0x08, 0x11, 0x13, 0xfc,
0x3b, 0xfe, 0xbe, 0x93, 0xe7, 0xdc, 0x73, 0xde, 0xf3, 0xd5, 0x20, 0x39, 0x84,
0x64, 0x40, 0x35, 0x1a, 0xa7, 0xd8, 0xa9, 0xcc, 0xc6, 0x87, 0xce, 0x23, 0xa7,
0xca, 0x29, 0x77, 0x0a, 0x9d, 0x54, 0x0f, 0xdf, 0xf9, 0xc8, 0x97, 0x39, 0x9f,
0xf8, 0x69, 0x3e, 0xc7, 0x79, 0xe0, 0x94, 0x38, 0x45, 0x4e, 0xbd, 0xf3, 0x21,
0x7b, 0x1f, 0xef, 0x4c, 0xf2, 0x53, 0xfc, 0x5d, 0xa7, 0xd4, 0x59, 0xc9, 0xbd,
0xe5, 0xef, 0x38, 0x31, 0xa7, 0xc9, 0xa9, 0x85, 0xbe, 0xba, 0xdc, 0x1d, 0x06,
0xd7, 0xf9, 0xf5, 0xbc, 0x13, 0x10, 0x8c, 0xe9, 0x61, 0x78, 0xde, 0x44, 0x44,
0xa0, 0xde, 0x45, 0xaf, 0x60, 0x23, 0x64, 0xcf, 0x93, 0x88, 0x0e, 0x1c, 0xc9,
0x43, 0xf1, 0x6c, 0x79, 0x32, 0x20, 0x11, 0x7a, 0x04, 0x1e, 0xae, 0xe7, 0x41,
0xf4, 0x2c, 0x7a, 0x11, 0x55, 0xda, 0x59, 0x9e, 0x47, 0x51, 0x86, 0xcf, 0xf1,
0x6c, 0x7b, 0xf8, 0x1e, 0x1e, 0xb4, 0x13, 0x41, 0x4a, 0x81, 0x35, 0xb1, 0xff,
0x76, 0x67, 0x4c, 0xf3, 0x5c, 0xf9, 0x33, 0xd2, 0x67, 0x69, 0x5a, 0x1a, 0xf5,
0xc7, 0xfd, 0x11, 0x68, 0x93, 0x90, 0x3e, 0x49, 0xc3, 0xfe, 0x3b, 0x69, 0x0c,
0xe8, 0x5b, 0x69, 0x52, 0x9a, 0xf0, 0xa7, 0xa4, 0xb7, 0x40, 0xdf, 0xf8, 0x6f,
0xa4, 0xb9, 0x88, 0x50, 0x7a, 0xe7, 0xbf, 0xf4, 0x27, 0x11, 0xbe, 0x5d, 0xa0,
0xfc, 0x1e, 0x6a, 0x1e, 0x20, 0x5d, 0x03, 0x77, 0x8f, 0x24, 0xdd, 0x21, 0x9b,
0x7c, 0x10, 0xc5, 0xbe, 0x2e, 0x79, 0x6f, 0x68, 0x24, 0xd4, 0x1a, 0x3a, 0x91,
0xdb, 0xe5, 0x5d, 0xa1, 0x66, 0x65, 0x67, 0x68, 0x28, 0xe4, 0x00, 0x8b, 0x76,
0xcb, 0x3b, 0x42, 0x7d, 0xa1, 0xe1, 0x50, 0x4b, 0xc8, 0x29, 0xef, 0x41, 0x2d,
0x07, 0x42, 0x63, 0xa1, 0xb6, 0x50, 0x3f, 0xd0, 0xc7, 0xf2, 0xd1, 0x5c, 0xdc,
0xdc, 0xfe, 0x67, 0xa9, 0xac, 0x8c, 0xb4, 0x2a, 0x5b, 0x94, 0xd5, 0x91, 0x06,
0xc0, 0xa1, 0x1a, 0x48, 0xf5, 0x91, 0x2e, 0x40, 0x17, 0x8a, 0xaa, 0x33, 0x8b,
0x75, 0x91, 0x3a, 0x90, 0x74, 0x28, 0x6b, 0x21, 0xaf, 0x82, 0xd4, 0xa6, 0xfc,
0xbe, 0xc6, 0x6a, 0xf0, 0x9b, 0xda, 0x58, 0x45, 0x6c, 0x5f, 0x55, 0x05, 0x94,
0x46, 0x55, 0x13, 0x43, 0xcf, 0x09, 0x54, 0x75, 0x31, 0xad, 0xaa, 0x3c, 0x56,
0x19, 0xfb, 0x7a, 0xa6, 0xaf, 0xc1, 0x01, 0x71, 0xc8, 0x1a, 0x73, 0x82, 0xa4,
0x31, 0x25, 0x88, 0x1a, 0x23, 0x70, 0x8d, 0xda, 0x06, 0xed, 0xd3, 0xfd, 0x0b,
0x44, 0x8f, 0xcf, 0xf7, 0xfd, 0x07, 0x03, 0x07, 0xe8, 0x29, 0xc9, 0x41, 0x41,
0xa6, 0x13, 0x61, 0xca, 0xf1, 0xb3, 0xe3, 0x39, 0x0d, 0x48, 0x31, 0x46, 0xb6,
0xfd, 0xf1, 0x9c, 0xf4, 0xcb, 0xef, 0x7b, 0xbf, 0x2c, 0xf3, 0x43, 0xf4, 0x13,
0xf6, 0x27, 0xed, 0xf7, 0xc8, 0xc7, 0x43, 0x8d, 0x91, 0x0e, 0xe4, 0x93, 0xfc,
0x6f, 0xde, 0x55, 0x80, 0xf7, 0x59, 0xda, 0xed, 0x55, 0xc8, 0x1a, 0x5f, 0xe1,
0x3a, 0x7e, 0xdd, 0x38, 0x79, 0x9b, 0x32, 0x97, 0x8d, 0x9f, 0xa9, 0x63, 0xe0,
0xc9, 0xdd, 0x39, 0x3f, 0x79, 0x06, 0xab, 0xf1, 0x81, 0xde, 0x4e, 0xe5, 0x5e,
0xc8, 0x27, 0xe0, 0x7a, 0x76, 0xf2, 0x31, 0xd9, 0x41, 0xee, 0x34, 0x38, 0xc9,
0x04, 0xca, 0x3c, 0xb4, 0x27, 0x7e, 0x8b, 0x6a, 0xc7, 0xa9, 0x13, 0xb9, 0xe8,
0xd1, 0x04, 0x35, 0x74, 0x98, 0x97, 0x20, 0x77, 0xcd, 0x7e, 0x46, 0x21, 0x78,
0x61, 0x2f, 0xa3, 0x8f, 0xd1, 0xc3, 0xe8, 0xc8, 0xd9, 0xb7, 0x94, 0x25, 0x61,
0xc9, 0x58, 0x62, 0xf0, 0x9d, 0x7e, 0xcb, 0x00, 0x43, 0x04, 0x65, 0x35, 0xb7,
0x06, 0x66, 0x54, 0x0b, 0xc9, 0x9c, 0xb3, 0xc4, 0x4f, 0x91, 0xd8, 0xf3, 0xf2,
0x75, 0xc6, 0xbf, 0xc0, 0x6e, 0x07, 0xe4, 0x7e, 0xf9, 0x04, 0xec, 0x4f, 0xb7,
0x52, 0x07, 0xe8, 0xae, 0x49, 0xf9, 0x9e, 0x9c, 0xcf, 0x93, 0x64, 0x12, 0xcc,
0x82, 0x4c, 0xb1, 0x1b, 0xa6, 0xa8, 0xb3, 0x30, 0x03, 0xab, 0xc1, 0x6c, 0x98,
0xa1, 0xda, 0x0c, 0x0e, 0x03, 0x6e, 0x98, 0xa7, 0xce, 0x51, 0xa7, 0xa9, 0x93,
0x54, 0xcb, 0x17, 0x2e, 0x89, 0x90, 0xbe, 0xf8, 0x34, 0xa9, 0x51, 0x6e, 0xdc,
0x81, 0xf9, 0x31, 0x69, 0x42, 0x24, 0xe1, 0xd1, 0x24, 0x46, 0x91, 0x91, 0x9b,
0xd3, 0x26, 0x83, 0xc6, 0x06, 0x4a, 0x6c, 0xdc, 0x35, 0xca, 0x8c, 0x1c, 0x9a,
0x80, 0x26, 0xa6, 0x09, 0x8d, 0x0a, 0x23, 0xeb, 0x1b, 0xc6, 0x8e, 0x32, 0x66,
0x41, 0x4b, 0xb5, 0x78, 0x19, 0x3e, 0xc7, 0x68, 0xc4, 0x8b, 0xf0, 0x4a, 0x84,
0x33, 0x23, 0x8c, 0x62, 0x7c, 0x88, 0x51, 0x85, 0xd7, 0xe1, 0x83, 0x50, 0x5b,
0x8f, 0x57, 0x80, 0xb4, 0x1a, 0xd2, 0x02, 0x63, 0x9c, 0xd1, 0x84, 0x37, 0x00,
0x35, 0xc3, 0x98, 0x62, 0x94, 0xe3, 0x93, 0x8c, 0x52, 0xbc, 0x04, 0x9f, 0x60,
0x8c, 0x31, 0xe6, 0x19, 0xd3, 0x8c, 0x61, 0x68, 0x5b, 0x03, 0x75, 0x72, 0xd0,
0x82, 0x86, 0x35, 0x6b, 0xd9, 0x61, 0x8d, 0x5a, 0x06, 0x61, 0x37, 0x17, 0x2d,
0x03, 0x90, 0xef, 0xb2, 0xa6, 0x2c, 0x2a, 0xd6, 0x3e, 0xd4, 0x29, 0x59, 0x73,
0x16, 0x35, 0x94, 0x2d, 0xdc, 0x65, 0xcb, 0x10, 0xda, 0xed, 0x11, 0xcb, 0xb4,
0x65, 0xde, 0xb2, 0x64, 0x59, 0xb0, 0x4c, 0x5a, 0x66, 0x90, 0x64, 0xcc, 0x72,
0xc0, 0x9a, 0xb0, 0x8c, 0x5b, 0x7e, 0x58, 0x14, 0xac, 0x61, 0x8b, 0x16, 0x5a,
0xef, 0x7d, 0xc3, 0xa7, 0x2e, 0xee, 0x00, 0xe8, 0xbf, 0x13, 0xed, 0x7c, 0x1f,
0x50, 0x75, 0x40, 0x35, 0x43, 0xea, 0xb5, 0x77, 0xd9, 0xfb, 0xed, 0xf5, 0xdc,
0xce, 0x2c, 0x5a, 0x71, 0x1b, 0x40, 0x32, 0x68, 0x6f, 0xe4, 0xb6, 0xa2, 0x76,
0x6d, 0x90, 0x77, 0x70, 0x73, 0x3e, 0x91, 0x2b, 0xbb, 0xed, 0x3d, 0x5f, 0x38,
0x35, 0x04, 0x94, 0xd3, 0xf9, 0xca, 0xd7, 0x7a, 0x8e, 0x9d, 0x51, 0xb4, 0x73,
0x79, 0x10, 0xad, 0x5d, 0x02, 0xf5, 0xc9, 0x7f, 0xe3, 0x27, 0x9d, 0x01, 0xe7,
0x39, 0xd0, 0x85, 0x82, 0xb8, 0x33, 0xec, 0x7c, 0xe7, 0x17, 0x41, 0xdd, 0x95,
0x33, 0x82, 0xda, 0xb9, 0x9d, 0x37, 0xce, 0x33, 0xa7, 0x0f, 0x68, 0x9b, 0x33,
0xe1, 0xf4, 0x3b, 0xad, 0x40, 0x15, 0x08, 0x42, 0xce, 0x5b, 0x67, 0xd0, 0xe9,
0x70, 0x9e, 0x38, 0x2d, 0xc0, 0xe7, 0x43, 0xfb, 0x53, 0xa7, 0xc7, 0xf9, 0xc1,
0xb7, 0x03, 0x17, 0x73, 0xfe, 0xcc, 0x46, 0x91, 0x4e, 0x17, 0xea, 0x7f, 0xed,
0xfc, 0xee, 0x73, 0x79, 0xe2, 0x5d, 0xc0, 0x9a, 0x1d, 0x8f, 0xc1, 0xb3, 0xe7,
0x31, 0x02, 0x55, 0x20, 0xce, 0x9d, 0xfe, 0x9e, 0x83, 0x6f, 0x18, 0xa4, 0xf3,
0x60, 0x1e, 0x13, 0xf0, 0x17, 0x4e, 0xb3, 0xa7, 0x34, 0x00, 0xf3, 0x12, 0x5b,
0x3c, 0x52, 0x8f, 0x26, 0xfb, 0xfc, 0x0f, 0xb5, 0xca, 0x17, 0x17, 0x89, 0x71,
0x8f, 0xd5, 0xa3, 0xf0, 0xc8, 0x10, 0x2f, 0x47, 0xb9, 0xca, 0xa3, 0xf4, 0x14,
0xc3, 0x78, 0x47, 0x88, 0x53, 0x43, 0xbe, 0xef, 0x91, 0x78, 0xde, 0xfc, 0x2f,
0xfe, 0x02, 0x59, 0x9e, 0xac, 0x30, 0xf0, 0xea, 0x2f, 0x0a, 0xe4, 0x05, 0x9e,
0xfd, 0x25, 0x81, 0x27, 0xff, 0x4f, 0xff, 0xa7, 0xf4, 0xa7, 0xf4, 0x43, 0xfa,
0xee, 0xcf, 0x0f, 0xbc, 0x4a, 0xf3, 0x65, 0x70, 0x46, 0x01, 0x3e, 0x7d, 0xfa,
0x1f, 0xfc, 0x1f, 0xfe, 0x37, 0x69, 0x41, 0xe0, 0xd1, 0xff, 0x2e, 0x2d, 0x0e,
0xfc, 0x8e, 0x89, 0x33, 0xa1, 0xb0, 0x3c, 0x24, 0xbf, 0x90, 0xaf, 0x87, 0xe6,
0x42, 0xcb, 0xa1, 0xc9, 0xd0, 0x5a, 0x68, 0x35, 0xb4, 0x19, 0x5a, 0x0a, 0x05,
0xe5, 0x3f, 0x42, 0x97, 0xe0, 0x7b, 0xd3, 0xa1, 0x33, 0xc8, 0x37, 0x42, 0xe7,
0xf2, 0xd9, 0xd0, 0x42, 0x68, 0x25, 0x34, 0x1f, 0x9a, 0x0a, 0x7d, 0xbd, 0x89,
0x0e, 0x35, 0x47, 0xfa, 0x95, 0x6d, 0x91, 0xd6, 0x48, 0x47, 0xa4, 0x0b, 0x90,
0xa8, 0x17, 0x90, 0xa8, 0x05, 0xca, 0xa6, 0x48, 0x77, 0xa4, 0x33, 0xd2, 0x9e,
0x95, 0x40, 0xea, 0x89, 0x0c, 0x2a, 0x7b, 0xa0, 0xa6, 0x4f, 0x39, 0x80, 0x90,
0xaa, 0x2f, 0xd2, 0x8a, 0x50, 0xa8, 0x25, 0xd6, 0x0c, 0x65, 0x5b, 0xac, 0x1e,
0xf2, 0x86, 0x58, 0x47, 0xac, 0x11, 0xca, 0x43, 0x55, 0x17, 0xe4, 0x9d, 0xb1,
0x26, 0xc8, 0xed, 0x09, 0xba, 0xc6, 0x9a, 0x70, 0x26, 0x8e, 0x13, 0xed, 0xc0,
0xd1, 0x20, 0x4a, 0x72, 0x24, 0x2c, 0x09, 0x77, 0xc2, 0x95, 0xa0, 0x02, 0x6d,
0x03, 0xbc, 0xd2, 0xe7, 0xe2, 0xac, 0xa6, 0x5c, 0x14, 0xb4, 0x9f, 0x7a, 0xbb,
0x7f, 0xbf, 0xff, 0xb8, 0xef, 0x42, 0x78, 0xd5, 0x0d, 0x79, 0x61, 0x06, 0x34,
0xf7, 0x88, 0x3d, 0xa2, 0xef, 0x21, 0x9e, 0xfc, 0x4f, 0xae, 0x67, 0x1a, 0x44,
0x39, 0x53, 0xe4, 0x69, 0x40, 0x94, 0x19, 0xb2, 0x8b, 0x4c, 0xa1, 0x1c, 0x1b,
0x16, 0xa8, 0x8b, 0xe0, 0xbb, 0x32, 0xda, 0x0e, 0x4d, 0x4a, 0x93, 0x80, 0x9f,
0x2d, 0x22, 0x0c, 0x6a, 0xc6, 0x97, 0x18, 0x3f, 0x18, 0x2d, 0x78, 0x6e, 0xef,
0xc0, 0x92, 0xbb, 0xb9, 0xc3, 0x60, 0x6f, 0x77, 0xd9, 0xbb, 0x16, 0x41, 0xa9,
0x38, 0xe5, 0x2c, 0x81, 0x5d, 0x89, 0x80, 0x6e, 0xb6, 0x42, 0x18, 0xcc, 0x83,
0xa1, 0x39, 0x81, 0x19, 0xf5, 0xc0, 0x35, 0xe7, 0x00, 0x23, 0x17, 0xc0, 0xeb,
0xa9, 0x94, 0x45, 0xc3, 0x32, 0x8c, 0xfc, 0x83, 0xba, 0x44, 0x5d, 0x81, 0x52,
0x41, 0x93, 0xc3, 0xe8, 0x4a, 0xe3, 0x2e, 0xf2, 0xe5, 0x3d, 0x63, 0x2b, 0x8c,
0xdd, 0x06, 0x69, 0x99, 0xb1, 0xca, 0x58, 0x67, 0xac, 0x30, 0x36, 0x18, 0x6b,
0xdf, 0xa2, 0x84, 0x23, 0xd6, 0x21, 0x0b, 0x63, 0x19, 0x58, 0x7a, 0xd6, 0x88,
0x7d, 0x25, 0x87, 0xaf, 0x63, 0xf6, 0x51, 0xfb, 0x60, 0xd6, 0x67, 0xfe, 0xf0,
0x22, 0xee, 0x00, 0x77, 0x88, 0xdb, 0x0f, 0xf4, 0x08, 0x77, 0x98, 0xfb, 0xed,
0x6d, 0x8d, 0x20, 0xed, 0xbc, 0x77, 0x96, 0x83, 0xf5, 0x96, 0x09, 0x4a, 0x05,
0x95, 0x82, 0x12, 0x01, 0x3a, 0x99, 0x3c, 0x0e, 0x4f, 0xb9, 0xd8, 0xee, 0x71,
0x83, 0x05, 0x55, 0x8a, 0x9d, 0x9e, 0x32, 0x71, 0x85, 0xf8, 0x18, 0xe8, 0x32,
0xb0, 0x87, 0xf2, 0x40, 0xc5, 0x97, 0x55, 0x44, 0xe5, 0xb7, 0xf2, 0xed, 0xd0,
0xb5, 0x3c, 0x21, 0x27, 0x84, 0x92, 0xf2, 0x98, 0x3c, 0x2e, 0xbf, 0x92, 0xdf,
0xc8, 0x47, 0x94, 0x36, 0xcf, 0xa8, 0x72, 0x18, 0xf6, 0x6f, 0x48, 0xd9, 0x1d,
0x3b, 0x52, 0x79, 0x12, 0x5e, 0xf4, 0xc4, 0x75, 0xe8, 0xa0, 0x17, 0x56, 0x3c,
0x0b, 0xda, 0x5c, 0xa5, 0x1a, 0x41, 0x47, 0xe3, 0xf6, 0x51, 0x34, 0x93, 0x1a,
0x41, 0xb5, 0xa0, 0x4a, 0x50, 0x25, 0xae, 0x16, 0x9f, 0x78, 0x52, 0x72, 0x83,
0x6a, 0x8e, 0xdc, 0x65, 0x70, 0x93, 0x7f, 0x20, 0x2c, 0x74, 0x1a, 0xd6, 0x72,
0x68, 0xbd, 0xf9, 0xb5, 0xde, 0x4a, 0x74, 0xfd, 0x79, 0x18, 0xe7, 0x84, 0xec,
0x42, 0xad, 0x54, 0x80, 0x90, 0x6a, 0x48, 0xca, 0x1c, 0xf2, 0x79, 0x3c, 0x35,
0xa0, 0xef, 0xaa, 0xdc, 0x3c, 0x99, 0x9a, 0x05, 0x32, 0x9d, 0xec, 0x21, 0x2f,
0x19, 0x68, 0x80, 0xc0, 0x1a, 0x9a, 0x9a, 0xb6, 0x47, 0x53, 0xa1, 0x96, 0xed,
0xf8, 0x36, 0x83, 0xc0, 0xe8, 0xc0, 0xb7, 0xd0, 0xd8, 0x16, 0xd6, 0xaa, 0xc5,
0xcc, 0x32, 0xb1, 0x70, 0xd6, 0x04, 0x77, 0x0c, 0xcd, 0x6c, 0xd2, 0x3e, 0xce,
0x9d, 0x80, 0x7d, 0xec, 0xe1, 0x3e, 0x20, 0x1f, 0xae, 0x13, 0xd4, 0x23, 0xfd,
0xd4, 0x42, 0x7e, 0x27, 0x27, 0x86, 0xc6, 0x94, 0xe3, 0xb0, 0xca, 0xfe, 0x08,
0x4b, 0xa3, 0x4d, 0x1d, 0x40, 0xfc, 0x1d, 0xd0, 0xd1, 0x5f, 0x2a, 0x0d, 0x5e,
0x98, 0xd9, 0x22, 0xa4, 0x15, 0xc3, 0xf2, 0x17, 0x9e, 0xaf, 0x53, 0x4f, 0x0c,
0x1e, 0x83, 0x1b, 0x78, 0xef, 0x5f, 0xde, 0x41, 0x61, 0x30, 0x6f, 0xad, 0x51,
0x67, 0xd4, 0x1b, 0x0f, 0x8c, 0x3a, 0x9a, 0x06, 0xb8, 0x7d, 0xe3, 0x3e, 0x4d,
0x4b, 0x3b, 0x34, 0x1e, 0x19, 0x0f, 0x68, 0x86, 0xbf, 0x44, 0x9b, 0x63, 0x60,
0x03, 0x03, 0x78, 0x37, 0x4e, 0x62, 0x0c, 0xe3, 0x83, 0x78, 0x17, 0x3e, 0x8e,
0x4f, 0xe1, 0xa3, 0x78, 0x1f, 0x4e, 0x61, 0x8c, 0xe0, 0x54, 0x46, 0x3f, 0x3e,
0x84, 0x77, 0xe2, 0xbd, 0xf8, 0x24, 0x4e, 0x83, 0x15, 0xd1, 0x21, 0xf5, 0xe0,
0x13, 0x38, 0x91, 0x41, 0x66, 0xfc, 0xfb, 0x88, 0x95, 0x65, 0x21, 0x5b, 0x98,
0x16, 0x92, 0x85, 0x62, 0xd9, 0xb2, 0x6c, 0x80, 0xed, 0xb0, 0x2d, 0x0c, 0xcb,
0x1a, 0x94, 0x36, 0x16, 0xcd, 0x42, 0x87, 0x92, 0x6a, 0xd9, 0xb4, 0xac, 0x5b,
0xac, 0x2c, 0xa2, 0x65, 0x1b, 0x59, 0x16, 0xc1, 0xc2, 0xf9, 0x5b, 0x6c, 0x39,
0x0b, 0xda, 0x9a, 0x81, 0x34, 0x65, 0x9f, 0xe4, 0xce, 0x80, 0xbe, 0xe6, 0xb8,
0xb3, 0x08, 0x77, 0x17, 0x41, 0x36, 0xcf, 0x9d, 0xb3, 0x73, 0x2d, 0x0b, 0xc0,
0x4f, 0x67, 0x5b, 0x40, 0x9a, 0xb6, 0xcf, 0xdb, 0x17, 0xbe, 0x6c, 0xb0, 0x51,
0xd0, 0x20, 0xc8, 0x45, 0x4f, 0xce, 0x57, 0xe7, 0xbb, 0xb3, 0x49, 0xf0, 0x09,
0xba, 0x6e, 0x13, 0xe4, 0xbb, 0x00, 0xcf, 0xa1, 0xa6, 0x45, 0xd0, 0x03, 0x79,
0xa7, 0xe0, 0xd9, 0xd9, 0x0c, 0xe5, 0x93, 0x33, 0xe3, 0x2c, 0x74, 0xbd, 0x40,
0x8b, 0x56, 0x41, 0x81, 0xab, 0x4b, 0xf0, 0xd3, 0xf9, 0xe1, 0xec, 0x16, 0xbc,
0x39, 0xdb, 0x05, 0x5f, 0xcf, 0x24, 0xa0, 0x5f, 0x9e, 0xeb, 0xca, 0x73, 0xeb,
0xb9, 0xf0, 0xd4, 0x8b, 0xcf, 0x3c, 0x29, 0x8f, 0xd7, 0x93, 0xf0, 0xc4, 0x3d,
0x97, 0x60, 0xbf, 0x49, 0x4f, 0x14, 0xf2, 0xa0, 0xe7, 0xce, 0xe3, 0xf7, 0xc4,
0x3c, 0x3e, 0xa0, 0xef, 0x21, 0x35, 0x80, 0xad, 0xdc, 0x78, 0x6a, 0x03, 0x01,
0x4f, 0x2d, 0x50, 0x21, 0x90, 0xd4, 0x89, 0xcf, 0x3d, 0x11, 0x84, 0xa1, 0xe1,
0x1c, 0x26, 0x5f, 0x7f, 0x61, 0x73, 0x63, 0xce, 0xaa, 0x5a, 0x02, 0x35, 0x40,
0xd5, 0x41, 0x6a, 0x0e, 0x34, 0x05, 0x0a, 0x01, 0x3f, 0x4f, 0x3d, 0x0d, 0xa8,
0xae, 0x08, 0xe8, 0xea, 0x40, 0xfd, 0x97, 0x97, 0x30, 0x00, 0x03, 0xf9, 0x21,
0x1a, 0xe4, 0xdc, 0x10, 0x25, 0xc4, 0x09, 0x09, 0x42, 0xe4, 0x10, 0x3d, 0x44,
0x02, 0xfe, 0x1e, 0x10, 0x81, 0x1a, 0x4a, 0xcb, 0xd9, 0x21, 0x56, 0x88, 0x89,
0x90, 0x92, 0xf7, 0x85, 0x97, 0xc3, 0x91, 0xd1, 0xc8, 0xa4, 0x72, 0x0c, 0x30,
0x71, 0x10, 0xd2, 0x40, 0x64, 0x0a, 0xf2, 0x89, 0xc8, 0x84, 0x72, 0x3a, 0x32,
0x14, 0x19, 0x8f, 0x4c, 0x46, 0x46, 0x22, 0x7f, 0xb6, 0xec, 0x8f, 0x8d, 0xc4,
0xfa, 0x62, 0xc3, 0x80, 0x7b, 0x3d, 0xb1, 0xb1, 0xd8, 0x50, 0x6c, 0x3c, 0x36,
0x18, 0xeb, 0x8d, 0x8d, 0x02, 0x3f, 0x11, 0x1b, 0x80, 0xdc, 0x97, 0xe0, 0x01,
0x06, 0x72, 0x20, 0xb1, 0x35, 0x5c, 0x74, 0xff, 0xa8, 0x03, 0x5b, 0x5d, 0xb8,
0xff, 0x89, 0x9e, 0xfc, 0x15, 0x65, 0x8a, 0x01, 0xf7, 0xfa, 0xc0, 0x33, 0x0d,
0x80, 0x7c, 0x41, 0x28, 0x8d, 0xd9, 0xf2, 0x69, 0x01, 0x90, 0x69, 0xfe, 0x30,
0xf0, 0x64, 0x80, 0xd2, 0xfd, 0xfc, 0xf5, 0x7d, 0x11, 0x79, 0x83, 0xea, 0x33,
0x18, 0x8d, 0x12, 0x7a, 0x2f, 0xd2, 0xf8, 0x12, 0x99, 0x49, 0x61, 0x50, 0xe8,
0x28, 0xbe, 0x3a, 0x44, 0x3e, 0xf5, 0x03, 0x76, 0xb6, 0x35, 0xb0, 0x4c, 0x5e,
0x21, 0xaf, 0x92, 0x7d, 0x28, 0xf6, 0xb3, 0x67, 0xef, 0x4a, 0x72, 0x36, 0xd3,
0x28, 0x5e, 0x23, 0x77, 0x1b, 0x58, 0x14, 0x36, 0x65, 0x15, 0xfc, 0x60, 0xf3,
0xcf, 0x48, 0x0c, 0xac, 0x5c, 0x0f, 0xbd, 0x71, 0x64, 0xed, 0x5c, 0x64, 0xad,
0x33, 0x38, 0x9b, 0xc1, 0x62, 0x4c, 0xe3, 0x0c, 0xc6, 0x2c, 0xce, 0x64, 0x70,
0x40, 0xe6, 0x80, 0x71, 0x9c, 0x2c, 0x91, 0x85, 0x6f, 0x11, 0x58, 0x84, 0x16,
0xb1, 0xe5, 0x18, 0x45, 0x0c, 0x3f, 0xec, 0x8b, 0x60, 0x5b, 0xcb, 0x70, 0xd5,
0xa5, 0x6f, 0xb8, 0x36, 0x20, 0x28, 0x01, 0x3b, 0xe8, 0x17, 0x0c, 0x0a, 0xfa,
0xbe, 0x2c, 0xa3, 0x59, 0x5c, 0x0c, 0xb2, 0x16, 0xf1, 0x03, 0xec, 0x65, 0xab,
0x38, 0xed, 0x69, 0x12, 0x7f, 0xdd, 0xfd, 0x06, 0xba, 0x02, 0xc5, 0xb2, 0xce,
0x40, 0x7b, 0xa0, 0x2d, 0xb7, 0x6b, 0xe2, 0xd0, 0xb3, 0xfc, 0x11, 0x76, 0xe7,
0x49, 0x2e, 0x0c, 0x89, 0x60, 0x4f, 0x1e, 0xe4, 0xf3, 0x91, 0x59, 0xd0, 0xf8,
0xb4, 0x72, 0x2e, 0x32, 0xa3, 0x9c, 0x52, 0x66, 0xd0, 0x93, 0x86, 0xe9, 0xd8,
0x64, 0x6c, 0x2a, 0x36, 0x13, 0xf1, 0x27, 0xf8, 0x9a, 0xd3, 0xc4, 0x61, 0x4a,
0x9f, 0x9a, 0x89, 0x7d, 0x82, 0x56, 0xd7, 0xc9, 0x1c, 0xca, 0x36, 0xf5, 0xd4,
0xb0, 0x05, 0xeb, 0xe3, 0x31, 0x4a, 0xb2, 0xb6, 0x41, 0xe6, 0x52, 0x5c, 0xac,
0x36, 0xb8, 0xe2, 0x1a, 0xac, 0x7b, 0x1d, 0x92, 0x1f, 0xe1, 0xc0, 0x11, 0xcd,
0x66, 0xb4, 0x18, 0x0d, 0x34, 0xb3, 0xd1, 0x6a, 0xb4, 0xc3, 0xea, 0xb1, 0x6f,
0xb1, 0x9b, 0x88, 0x21, 0x66, 0x08, 0x90, 0x2e, 0xf8, 0x8c, 0x1d, 0x8b, 0x30,
0xe7, 0xc3, 0x6e, 0x58, 0xb5, 0xcc, 0x22, 0xb7, 0x48, 0x2d, 0x0a, 0xcb, 0x09,
0x6b, 0x8d, 0xbb, 0x04, 0xab, 0x5f, 0xb1, 0xaf, 0x70, 0x57, 0xed, 0xab, 0xdc,
0x65, 0xa0, 0x25, 0x96, 0x52, 0x57, 0x85, 0xab, 0xd2, 0x55, 0xe6, 0x1a, 0x15,
0x8c, 0x08, 0x86, 0x04, 0xc3, 0x82, 0x72, 0xd7, 0x17, 0x7a, 0x20, 0x5d, 0x74,
0x88, 0x3b, 0x61, 0x1e, 0x5d, 0xe2, 0xee, 0x40, 0x6f, 0xa0, 0x3f, 0x50, 0x26,
0x2b, 0x95, 0xb5, 0x8b, 0xfb, 0x02, 0x3d, 0xb0, 0xf2, 0x1d, 0x64, 0x7d, 0xd2,
0x90, 0x32, 0xf4, 0x22, 0xdf, 0x0b, 0x29, 0x42, 0xaf, 0x72, 0x59, 0x48, 0x12,
0xda, 0x0d, 0xcd, 0x29, 0x17, 0x23, 0xf2, 0xd0, 0x82, 0xf2, 0x47, 0x64, 0x5e,
0xf9, 0x43, 0xb9, 0x14, 0x99, 0x55, 0x2e, 0x02, 0xee, 0x2d, 0xc6, 0xe6, 0x63,
0x73, 0xb1, 0x85, 0xd8, 0x2c, 0x3a, 0xa1, 0x47, 0xe0, 0x0e, 0xa0, 0x24, 0x53,
0x0a, 0xb6, 0x64, 0x7a, 0x3c, 0x7b, 0x6a, 0x46, 0xdf, 0xd2, 0x48, 0x18, 0x46,
0xb4, 0x1e, 0x4f, 0x2e, 0xb6, 0xdb, 0x20, 0xfb, 0xc9, 0x3c, 0x4a, 0x00, 0x56,
0x6e, 0xa2, 0x39, 0x60, 0xb5, 0xbb, 0x16, 0x6f, 0xf6, 0xe9, 0xa3, 0x7c, 0x33,
0xf7, 0x44, 0x99, 0x80, 0xec, 0xa1, 0x5c, 0xb6, 0x45, 0x0e, 0x90, 0x83, 0x20,
0x13, 0x50, 0xf8, 0x60, 0x59, 0x41, 0x03, 0x11, 0xe4, 0xc7, 0xd0, 0x1e, 0x47,
0xa3, 0xcd, 0xe3, 0x0b, 0xf8, 0x22, 0xe0, 0xa0, 0x94, 0x21, 0x63, 0xcc, 0xe1,
0x3b, 0x39, 0xbd, 0xf8, 0x58, 0x4a, 0xb0, 0xb1, 0x75, 0xfb, 0x3a, 0x58, 0xc1,
0x1a, 0xe8, 0x61, 0x5c, 0x50, 0xe5, 0x9a, 0x10, 0x54, 0xe7, 0xd6, 0xde, 0x9d,
0xdb, 0xeb, 0x01, 0xb4, 0xbf, 0xea, 0x90, 0x0a, 0x56, 0xfa, 0x0e, 0x7b, 0xb8,
0xa4, 0x5c, 0x8e, 0x18, 0x55, 0x3f, 0x62, 0x02, 0xf0, 0x8b, 0xc5, 0x43, 0xcf,
0xbf, 0xec, 0x1c, 0xc6, 0xdf, 0xb3, 0x4c, 0x0a, 0x32, 0x9e, 0x0a, 0x59, 0xce,
0x7a, 0xb4, 0x7f, 0xd6, 0x59, 0x60, 0x16, 0x66, 0xda, 0x29, 0xcc, 0x7c, 0x23,
0x8b, 0x6a, 0x82, 0x42, 0xd1, 0x8c, 0x60, 0x4a, 0xd0, 0x03, 0x57, 0xd0, 0x84,
0x3e, 0xe4, 0xcb, 0xa0, 0x99, 0x2a, 0xc3, 0x19, 0xac, 0xd1, 0x65, 0xb4, 0xd2,
0x9c, 0x46, 0x1b, 0x9a, 0xb3, 0x92, 0xb1, 0x82, 0x2f, 0xe3, 0xbb, 0x0c, 0x39,
0x43, 0xc1, 0x58, 0x42, 0x71, 0x42, 0x80, 0xa5, 0xb2, 0x9c, 0xb3, 0xfc, 0xac,
0x30, 0x2b, 0xc8, 0x3a, 0x63, 0x85, 0x72, 0x1a, 0xda, 0xe2, 0x6e, 0x72, 0x37,
0x72, 0x76, 0x5c, 0xeb, 0x9a, 0x15, 0x2c, 0x08, 0xe6, 0x60, 0xcf, 0x6a, 0x5c,
0x4b, 0x90, 0xcf, 0x0b, 0xea, 0x5c, 0x3f, 0x04, 0x8b, 0x39, 0x7b, 0x7e, 0xf2,
0x3c, 0x82, 0x1d, 0xf7, 0x8b, 0x7b, 0xc5, 0x7d, 0xe2, 0x67, 0x4f, 0xa5, 0x6c,
0x28, 0x50, 0x25, 0x1b, 0x44, 0xab, 0x5b, 0x41, 0xc8, 0xb0, 0xaa, 0xdc, 0x0f,
0xad, 0xc0, 0x5c, 0x7e, 0xc2, 0x2a, 0x83, 0x89, 0xa5, 0x98, 0x50, 0x13, 0x48,
0xe4, 0xa5, 0xcb, 0x32, 0xe5, 0xb0, 0x43, 0x67, 0xd9, 0x6f, 0x38, 0x72, 0xf7,
0x44, 0x1b, 0xc8, 0x0e, 0x1d, 0x34, 0x27, 0xcc, 0x33, 0x6c, 0xf0, 0x18, 0x4f,
0x8c, 0x6e, 0xd0, 0x74, 0xc8, 0x70, 0x6e, 0x20, 0x53, 0x8f, 0x69, 0x76, 0x1a,
0x29, 0xe7, 0xa3, 0x7b, 0x8c, 0x55, 0x98, 0xb7, 0x8a, 0x11, 0x80, 0xda, 0x33,
0x63, 0xd0, 0xb8, 0x86, 0x56, 0xe1, 0xcb, 0x7e, 0xc7, 0x40, 0x73, 0x43, 0x5f,
0xaf, 0xf1, 0xd4, 0x18, 0x02, 0xce, 0x05, 0xb4, 0xdf, 0x18, 0x31, 0x6a, 0xb2,
0xcf, 0xb5, 0x8d, 0x27, 0xc0, 0x9d, 0x1b, 0x2f, 0xb2, 0xe7, 0x33, 0xf0, 0xfb,
0x8c, 0xcb, 0xbf, 0x3d, 0x3d, 0xe1, 0xe1, 0x44, 0x7c, 0x1b, 0xe7, 0xe2, 0x0c,
0xfc, 0x8a, 0xa5, 0x65, 0x30, 0x71, 0x0e, 0x7e, 0xc1, 0x62, 0xe3, 0x07, 0x8c,
0x23, 0x86, 0x9e, 0x41, 0x82, 0x6b, 0x6c, 0xe2, 0x14, 0xdc, 0xcc, 0xe0, 0xe3,
0x97, 0x2c, 0x2a, 0x70, 0x11, 0x96, 0x81, 0x41, 0x87, 0xd2, 0x6c, 0x89, 0xb2,
0x36, 0x70, 0x23, 0xe3, 0x9a, 0x65, 0x62, 0x60, 0x0c, 0x9c, 0x41, 0xc3, 0xd7,
0x71, 0x16, 0xae, 0x43, 0xb6, 0xb0, 0x85, 0x93, 0x71, 0x02, 0x7e, 0x08, 0xb4,
0x1a, 0x2c, 0x42, 0xf3, 0xdb, 0x69, 0x65, 0xb4, 0x10, 0xec, 0x26, 0xcb, 0x2d,
0xcb, 0x62, 0xd1, 0x59, 0x92, 0x2c, 0x3d, 0xd4, 0x61, 0xa8, 0xde, 0x60, 0x89,
0xa1, 0x1d, 0x20, 0x21, 0xdd, 0x1f, 0x5a, 0xf6, 0x2d, 0x64, 0x44, 0x59, 0x2d,
0xdb, 0xdc, 0x2d, 0xfb, 0x11, 0xb4, 0xd9, 0xb4, 0x1f, 0x58, 0x70, 0xd4, 0x36,
0xc1, 0x22, 0x70, 0xd3, 0x2c, 0x22, 0xd7, 0x66, 0xd9, 0xb6, 0xdf, 0xb0, 0xa8,
0xdc, 0x7b, 0xd6, 0x1d, 0x2b, 0xc5, 0xa2, 0x70, 0xed, 0x16, 0x1a, 0x37, 0x0e,
0xa3, 0x68, 0x2d, 0xff, 0xee, 0xac, 0x5d, 0x16, 0x90, 0xed, 0x54, 0xb0, 0x19,
0xba, 0x9d, 0xce, 0xe5, 0x72, 0x1b, 0x5d, 0x6c, 0x3b, 0xc9, 0xbe, 0x2a, 0xa8,
0x07, 0x1b, 0xe5, 0x70, 0x59, 0x5c, 0x6e, 0xf6, 0x89, 0x0c, 0xd0, 0x14, 0x28,
0xd9, 0x5c, 0x86, 0x9d, 0xc7, 0x65, 0xa1, 0x53, 0x94, 0xc9, 0x65, 0xda, 0x39,
0x76, 0x1a, 0xd0, 0x0c, 0xee, 0x1a, 0xec, 0x3e, 0xd1, 0xbe, 0xf2, 0x85, 0x69,
0xeb, 0x82, 0xdf, 0xaf, 0xd0, 0xec, 0xea, 0x71, 0x0d, 0x81, 0x25, 0x6e, 0x0a,
0x48, 0x82, 0x61, 0x71, 0x9f, 0x8b, 0x29, 0x78, 0xf5, 0xb4, 0xb8, 0x88, 0x02,
0x8a, 0x60, 0x5b, 0xd0, 0xe4, 0x1a, 0x70, 0x0d, 0xbb, 0xca, 0xbd, 0x70, 0xa2,
0xb8, 0x7e, 0x7a, 0x08, 0x02, 0xba, 0x80, 0x2d, 0xe8, 0x76, 0xbd, 0x78, 0xfa,
0x5d, 0x1b, 0x82, 0x37, 0xcf, 0x90, 0xeb, 0xc3, 0xd3, 0x0e, 0x57, 0x1f, 0x80,
0xde, 0xad, 0xae, 0x36, 0x17, 0x0d, 0x8d, 0x4c, 0x15, 0x74, 0xba, 0x58, 0x82,
0x5e, 0x17, 0x59, 0xd0, 0x05, 0x75, 0x0c, 0xc1, 0x88, 0x78, 0x50, 0xfc, 0x0e,
0x76, 0xd7, 0x01, 0xdc, 0x96, 0xe0, 0xef, 0x2b, 0x9c, 0x14, 0xcf, 0x8a, 0xf3,
0xbc, 0xf5, 0xb2, 0x69, 0x71, 0x91, 0x77, 0x5e, 0x3c, 0x1c, 0x28, 0xf1, 0x36,
0xca, 0xc6, 0xc5, 0x53, 0xe2, 0x52, 0xb8, 0x6a, 0x99, 0xb7, 0xc6, 0xbb, 0x28,
0x6e, 0x02, 0x7f, 0xaa, 0xf0, 0xd6, 0x7a, 0x0b, 0xbd, 0x3d, 0x40, 0x35, 0xcb,
0x16, 0xc4, 0xf9, 0xde, 0x3a, 0xa8, 0xed, 0x96, 0xcd, 0x89, 0x6b, 0x64, 0xd5,
0x40, 0xfd, 0x10, 0x17, 0x7b, 0x3f, 0x3d, 0x13, 0xe2, 0x02, 0xa0, 0x2b, 0x21,
0x55, 0xcb, 0x1a, 0x64, 0xa3, 0xe2, 0x2a, 0xa0, 0xea, 0x72, 0xbe, 0x38, 0x96,
0xf3, 0xe6, 0x2e, 0xd9, 0x41, 0x68, 0x0e, 0x6c, 0x7e, 0x2c, 0xa0, 0x05, 0x7f,
0x9e, 0x0a, 0xcc, 0x20, 0xfb, 0x9f, 0x84, 0xbc, 0x13, 0x5a, 0x4e, 0x04, 0x7a,
0x73, 0xed, 0x1d, 0x08, 0xd7, 0x3a, 0x64, 0x79, 0x8a, 0xf9, 0x80, 0x0e, 0xd1,
0x6d, 0xb2, 0xf1, 0xc0, 0x74, 0xe0, 0x53, 0x5e, 0x2b, 0x1b, 0x09, 0x8c, 0x06,
0xf2, 0x15, 0xad, 0xb2, 0x76, 0x59, 0x8b, 0x6c, 0x16, 0xf5, 0x3f, 0x0a, 0x19,
0x42, 0x96, 0xd0, 0x96, 0xd2, 0x05, 0x2d, 0x4b, 0x15, 0x80, 0x6a, 0x0a, 0x1b,
0x50, 0x9b, 0xca, 0xc3, 0x50, 0x31, 0x70, 0xce, 0x50, 0xa1, 0xa2, 0x08, 0x4a,
0x7b, 0x88, 0x19, 0x59, 0x57, 0xce, 0xc0, 0x4c, 0x8e, 0x43, 0x24, 0xa5, 0x09,
0x5a, 0x6c, 0x80, 0xb7, 0x11, 0x95, 0xfa, 0x90, 0x31, 0x84, 0x85, 0xcc, 0xa1,
0x32, 0xc5, 0x9a, 0xb2, 0x00, 0xda, 0xad, 0x47, 0xac, 0x50, 0x47, 0x80, 0x3a,
0x32, 0x24, 0x1c, 0xe8, 0x6d, 0xe5, 0x5a, 0xe4, 0xdb, 0xfb, 0xab, 0x88, 0x45,
0xb5, 0x1a, 0x21, 0xc5, 0x18, 0x11, 0x3a, 0xd4, 0x53, 0x95, 0xb8, 0x8a, 0x1a,
0x21, 0x46, 0xd8, 0x40, 0xaf, 0xe6, 0x9e, 0xbf, 0x30, 0x95, 0x04, 0x68, 0xbf,
0x0c, 0x1c, 0x05, 0x4a, 0x7a, 0x64, 0x0b, 0x72, 0x16, 0xba, 0x3b, 0xa2, 0x28,
0x57, 0x62, 0x66, 0x15, 0x2d, 0x42, 0x53, 0x32, 0x94, 0xe4, 0x08, 0x47, 0x49,
0x8a, 0x6c, 0x46, 0x36, 0x22, 0x26, 0x15, 0x2b, 0xb2, 0x1e, 0x3b, 0x4f, 0xd8,
0xe0, 0x4e, 0x83, 0x08, 0xbd, 0xb6, 0x21, 0x85, 0x20, 0x02, 0xb7, 0xab, 0x08,
0x40, 0x6d, 0xc6, 0xc4, 0x9a, 0x33, 0xe0, 0xd6, 0x62, 0x1b, 0x31, 0x89, 0xe6,
0x58, 0x25, 0xd2, 0x38, 0x54, 0x32, 0xcd, 0x56, 0xcc, 0xaa, 0xfa, 0xeb, 0x5e,
0x5a, 0x21, 0x4a, 0xc0, 0xbe, 0x3d, 0x55, 0xbe, 0x4a, 0x1c, 0xa5, 0x2e, 0x50,
0x24, 0xdf, 0xa2, 0x8d, 0x24, 0x2e, 0x13, 0x52, 0x4d, 0x38, 0x11, 0x4d, 0xd8,
0x52, 0x78, 0xca, 0x02, 0xad, 0x0c, 0x29, 0x23, 0xe4, 0xe6, 0x94, 0x29, 0x35,
0x8a, 0x9e, 0x05, 0x4d, 0x1c, 0x8c, 0x1f, 0x8c, 0x1d, 0xf4, 0xeb, 0x2a, 0x32,
0x03, 0xba, 0xfc, 0xf4, 0x99, 0x0e, 0x7f, 0x3c, 0xd7, 0xfd, 0x38, 0x34, 0x1e,
0x7a, 0x01, 0x63, 0x7d, 0xcf, 0xa7, 0x08, 0x69, 0x15, 0xaf, 0xe7, 0xe4, 0x4d,
0x83, 0x08, 0x90, 0x88, 0x4a, 0xa5, 0x51, 0x29, 0x80, 0x34, 0x74, 0xaa, 0x8f,
0xe6, 0xcd, 0x3e, 0x93, 0xc1, 0xad, 0x0c, 0x0b, 0xf2, 0x66, 0x9e, 0x9d, 0x23,
0xe0, 0xe6, 0x2c, 0x6d, 0x49, 0xbc, 0x10, 0xe8, 0x93, 0xf5, 0xcb, 0x7e, 0x04,
0x96, 0x03, 0x4b, 0xb0, 0x57, 0x27, 0xa0, 0x4d, 0x77, 0xa8, 0x5c, 0xe1, 0x81,
0x92, 0x1d, 0xe1, 0x82, 0x4e, 0x9c, 0xb0, 0x8a, 0x1d, 0x4d, 0xab, 0x56, 0x0e,
0x78, 0x1e, 0xca, 0x9d, 0x2a, 0x51, 0x84, 0x39, 0x42, 0xdc, 0xce, 0xb0, 0x31,
0x1c, 0x8c, 0x07, 0x96, 0xc3, 0x72, 0x8c, 0x3c, 0x94, 0x6f, 0xe7, 0x73, 0x79,
0x82, 0x65, 0x71, 0xbd, 0x37, 0x0c, 0x2d, 0xb7, 0xc9, 0x17, 0x90, 0x6f, 0x19,
0x64, 0x14, 0x29, 0x45, 0x4c, 0x91, 0xe4, 0xd0, 0x91, 0x45, 0x8d, 0x19, 0x6e,
0x0c, 0x4c, 0xea, 0x05, 0xa0, 0xe4, 0x25, 0xa4, 0xb8, 0x21, 0x6a, 0xb8, 0x36,
0x30, 0xa8, 0x11, 0x43, 0xc2, 0x70, 0xf5, 0x5b, 0x24, 0x1f, 0xa2, 0xc5, 0x69,
0xd7, 0xb4, 0x3b, 0x63, 0xd2, 0xf8, 0x68, 0x8c, 0xd2, 0x9e, 0xb2, 0x28, 0x49,
0x7b, 0x80, 0x3c, 0x42, 0x4b, 0x19, 0x6f, 0x8d, 0x17, 0xb4, 0x8c, 0xf1, 0x92,
0x76, 0xcc, 0x08, 0xd2, 0xee, 0x41, 0x76, 0x65, 0x3c, 0x85, 0x35, 0xde, 0xd2,
0x12, 0xc6, 0xb4, 0xf1, 0x9c, 0x16, 0x06, 0xfa, 0x1a, 0xa4, 0x31, 0x63, 0x1c,
0xf2, 0x24, 0xed, 0x8a, 0x96, 0xa0, 0xdd, 0x18, 0x6f, 0x68, 0x01, 0x9a, 0x9f,
0x16, 0xa3, 0xfd, 0xe7, 0x2f, 0xb7, 0x42, 0x0c, 0x15, 0x2e, 0xc3, 0xfd, 0x8c,
0x14, 0x43, 0x84, 0x2b, 0x70, 0x25, 0xae, 0xc6, 0xe3, 0xa0, 0xb5, 0x5d, 0x5c,
0x8c, 0x5f, 0x33, 0x76, 0x00, 0x27, 0x35, 0xb8, 0x17, 0xf8, 0x3d, 0xfc, 0x82,
0x11, 0x66, 0x48, 0xf1, 0x13, 0xa4, 0x51, 0x0f, 0xe4, 0x6e, 0x48, 0xb7, 0x8c,
0x28, 0xe3, 0x9c, 0xe1, 0x64, 0xc8, 0xf1, 0x33, 0x86, 0x8b, 0x71, 0xc5, 0xb8,
0x63, 0x38, 0x2d, 0x97, 0x0c, 0x09, 0xee, 0x63, 0x04, 0x18, 0xc1, 0xec, 0x9b,
0x45, 0x46, 0x92, 0x71, 0xc3, 0x88, 0x30, 0x62, 0x8c, 0x53, 0x46, 0x86, 0xf5,
0x9f, 0x66, 0xe1, 0xb3, 0xe4, 0xb3, 0x5f, 0x58, 0x6f, 0xac, 0x3c, 0x76, 0xd4,
0xf2, 0x93, 0x25, 0xb0, 0x0b, 0xb8, 0x85, 0xec, 0x13, 0xcb, 0x99, 0xe5, 0x93,
0x15, 0xb4, 0x9c, 0x5a, 0x2e, 0x2c, 0x11, 0xcb, 0x33, 0xeb, 0x9d, 0x55, 0xc0,
0x16, 0x71, 0xcf, 0x2d, 0xaf, 0xac, 0x62, 0xb6, 0x37, 0x87, 0x90, 0x1f, 0x2c,
0x21, 0xf7, 0x09, 0x46, 0x76, 0x5b, 0x02, 0x16, 0x97, 0xc5, 0x63, 0xf1, 0x5b,
0x84, 0xf6, 0x22, 0x36, 0xac, 0xca, 0x12, 0xb6, 0x5c, 0x5a, 0x1e, 0x59, 0xff,
0xf3, 0x97, 0xa3, 0xfb, 0x5c, 0x95, 0x5d, 0xcd, 0xd5, 0x70, 0xc5, 0x76, 0x1d,
0xe0, 0xa3, 0x14, 0x61, 0xf6, 0x88, 0x4b, 0x6f, 0xd7, 0x00, 0x27, 0x83, 0x64,
0xb0, 0x2b, 0xec, 0x4a, 0xee, 0x96, 0x6b, 0xcf, 0xae, 0xe2, 0x4a, 0xa0, 0xd6,
0x64, 0x57, 0xdb, 0x77, 0xb8, 0x3b, 0x76, 0x89, 0x5d, 0x6a, 0x97, 0x73, 0x0f,
0xed, 0xb8, 0x7d, 0x97, 0xab, 0xb4, 0xef, 0xda, 0x0f, 0xb8, 0x5a, 0xae, 0x98,
0xab, 0xe0, 0xee, 0x71, 0x8f, 0x10, 0xe6, 0x6a, 0xed, 0x32, 0xae, 0xc8, 0x6e,
0xb4, 0xef, 0xdb, 0x0f, 0xec, 0x98, 0xfd, 0x9f, 0xae, 0x3c, 0x0a, 0x08, 0x28,
0x13, 0x98, 0x04, 0x46, 0xb0, 0x4d, 0x35, 0xa4, 0x35, 0xd7, 0x92, 0x6b, 0xc1,
0x45, 0x75, 0x29, 0x04, 0x42, 0x64, 0xad, 0x2b, 0x2e, 0xba, 0x58, 0x2a, 0x20,
0x40, 0x2b, 0x5c, 0x60, 0x10, 0x6c, 0xb8, 0x26, 0x50, 0x24, 0x72, 0x24, 0x20,
0xb9, 0xc6, 0x5d, 0x7b, 0x82, 0x7d, 0x01, 0x11, 0xf8, 0x45, 0x97, 0x56, 0xa0,
0x14, 0x8c, 0x01, 0xb5, 0x2a, 0xa6, 0xb8, 0xe6, 0x5d, 0x98, 0xe0, 0x87, 0x8b,
0xec, 0xd2, 0x43, 0xff, 0x06, 0x40, 0x3b, 0x91, 0x60, 0xd6, 0xb5, 0x23, 0x38,
0x00, 0x4e, 0x25, 0x58, 0x75, 0xcd, 0xb8, 0xa6, 0x5c, 0xdb, 0x2e, 0xbe, 0x40,
0x27, 0x10, 0x0b, 0x56, 0xc4, 0x9b, 0x2e, 0x09, 0xc8, 0x05, 0x02, 0x8d, 0x60,
0x57, 0x20, 0x17, 0xcc, 0xb9, 0x0e, 0x05, 0xd3, 0xae, 0x75, 0xd7, 0xb2, 0xab,
0xc9, 0xdb, 0xe8, 0xfd, 0x67, 0x4d, 0x4d, 0xba, 0x86, 0xa0, 0x66, 0x1d, 0xf0,
0x6a, 0xc2, 0xdb, 0xee, 0x1d, 0xf5, 0xae, 0x04, 0xb6, 0xc4, 0x93, 0xde, 0x19,
0xef, 0xa6, 0xb8, 0xcb, 0x3b, 0xed, 0x9d, 0xf2, 0x6e, 0x8b, 0x9b, 0xbd, 0x6b,
0x62, 0x12, 0xd4, 0x13, 0xc4, 0xe3, 0xd0, 0xb2, 0xd7, 0x4b, 0x11, 0xcf, 0x79,
0xc7, 0xbc, 0xf3, 0x5e, 0x8e, 0x98, 0x25, 0x1e, 0xf1, 0x0e, 0x67, 0xcf, 0x0d,
0x6f, 0xb7, 0x97, 0x0c, 0x2d, 0x88, 0x62, 0xb9, 0xbd, 0x05, 0x78, 0x59, 0xa0,
0xd5, 0xbb, 0x21, 0x66, 0x8a, 0xd7, 0xc0, 0x17, 0xa9, 0x62, 0x9a, 0xb8, 0xcd,
0x3b, 0xeb, 0x5d, 0x0d, 0xf4, 0x79, 0x3b, 0xbd, 0x0c, 0x71, 0xbf, 0xb7, 0x07,
0xcd, 0x84, 0x2b, 0x9e, 0x43, 0x28, 0xbc, 0x19, 0x10, 0x04, 0xa4, 0x01, 0x66,
0x60, 0x4a, 0xb6, 0x1b, 0x18, 0x97, 0xad, 0x43, 0x8f, 0x8d, 0xc0, 0x80, 0x6c,
0x52, 0x46, 0x0e, 0xcc, 0xc8, 0x66, 0x65, 0x14, 0xe0, 0x85, 0x81, 0x9d, 0xc0,
0x04, 0xb4, 0x1d, 0x92, 0x91, 0x02, 0x5b, 0x01, 0x45, 0x80, 0x1e, 0x60, 0x04,
0xb6, 0x03, 0xe2, 0x00, 0x2b, 0x20, 0x09, 0x70, 0xa0, 0x7e, 0x58, 0xe6, 0x0d,
0x8d, 0xc9, 0x46, 0x64, 0xf2, 0x00, 0x3f, 0xc0, 0x46, 0x48, 0x4d, 0x08, 0x34,
0x2a, 0x78, 0x81, 0x69, 0x19, 0x2d, 0x7b, 0xfd, 0x5c, 0xe4, 0x3e, 0x2a, 0x1b,
0x94, 0xdd, 0x86, 0x44, 0x01, 0x2e, 0xf0, 0xc4, 0xbf, 0x3c, 0xbf, 0x8a, 0x01,
0x4e, 0xf8, 0x42, 0x11, 0xc8, 0x13, 0xa1, 0x7a, 0x05, 0x5b, 0x1c, 0x0f, 0x55,
0x29, 0x72, 0xcf, 0x14, 0x14, 0xf7, 0x20, 0x3d, 0x0d, 0x5d, 0x87, 0xfc, 0xa1,
0xab, 0x50, 0xad, 0xe2, 0x26, 0x34, 0x90, 0xd3, 0x63, 0x3a, 0x74, 0x11, 0x6a,
0x50, 0x28, 0x22, 0x3c, 0x40, 0x97, 0xbb, 0x50, 0x2a, 0xd4, 0xa4, 0xe0, 0x44,
0xf8, 0x4a, 0x2e, 0x60, 0xf0, 0x59, 0xe8, 0x3c, 0x14, 0x08, 0x85, 0x43, 0xc1,
0xd0, 0x43, 0xa8, 0x46, 0x21, 0x50, 0xd6, 0x29, 0x9a, 0x61, 0xb4, 0x10, 0x8c,
0x93, 0x44, 0x67, 0x4c, 0x14, 0xe5, 0x02, 0x68, 0x59, 0xa1, 0x10, 0x2b, 0x99,
0x31, 0x69, 0x44, 0x12, 0x91, 0x21, 0xe4, 0x17, 0x47, 0x24, 0x30, 0xda, 0xae,
0x72, 0x07, 0x72, 0xb9, 0x92, 0x17, 0x11, 0x46, 0x94, 0x91, 0x7d, 0xa5, 0x1a,
0x38, 0x51, 0xa4, 0xc3, 0x2b, 0x54, 0xca, 0x23, 0x7c, 0x68, 0xa7, 0x55, 0xee,
0x44, 0xaa, 0x15, 0x32, 0xe5, 0x25, 0x1a, 0x47, 0x01, 0xb5, 0x2a, 0xa5, 0x46,
0xb9, 0xa7, 0x54, 0x02, 0x25, 0x55, 0xee, 0x46, 0x44, 0xca, 0x03, 0xe5, 0xef,
0xeb, 0xf3, 0xa8, 0xbc, 0x2a, 0x46, 0x2c, 0xac, 0x3a, 0x03, 0x14, 0x74, 0xab,
0x02, 0x2a, 0x56, 0xec, 0x54, 0xe5, 0x02, 0xda, 0x0f, 0x89, 0x1e, 0xdb, 0xd5,
0x9c, 0x40, 0x19, 0x54, 0x29, 0x34, 0xb4, 0x18, 0x15, 0x4e, 0x82, 0x73, 0xe0,
0x42, 0x90, 0x28, 0x31, 0x72, 0x4c, 0xa9, 0xe1, 0xc6, 0x7c, 0x2a, 0xf6, 0xd7,
0x13, 0xff, 0x3d, 0xc0, 0x4f, 0xad, 0x26, 0x9e, 0x48, 0x00, 0xde, 0xab, 0x81,
0x4e, 0x26, 0x62, 0x40, 0xdd, 0x24, 0x34, 0x9a, 0x03, 0xe0, 0xae, 0x13, 0x2a,
0xcd, 0xbe, 0xa6, 0x5d, 0xcb, 0x89, 0xb5, 0xa1, 0xa8, 0xb8, 0x47, 0xeb, 0x04,
0xec, 0xef, 0xd2, 0x76, 0x6b, 0x4f, 0x52, 0xc7, 0xa9, 0x0e, 0xad, 0x3d, 0x35,
0x79, 0xe0, 0x02, 0x89, 0x3b, 0xe5, 0x80, 0xbc, 0x53, 0x5b, 0x90, 0xfe, 0xf5,
0xab, 0x38, 0x8d, 0xbe, 0x38, 0x49, 0x17, 0xa5, 0x4b, 0xd3, 0x53, 0x07, 0x85,
0x88, 0xab, 0xc9, 0x0c, 0xe9, 0xaa, 0x33, 0x55, 0x99, 0xca, 0xcc, 0xa0, 0x6e,
0x18, 0xee, 0x3c, 0xcd, 0x8f, 0x61, 0x5d, 0x08, 0x3d, 0x8f, 0x0b, 0x3d, 0x9d,
0x3f, 0x5d, 0x3c, 0x99, 0x0e, 0x97, 0x0e, 0x03, 0xcf, 0xe1, 0x27, 0xf4, 0xcb,
0xa1, 0x67, 0xf3, 0x21, 0x7e, 0xf8, 0x70, 0xc8, 0x78, 0x49, 0xbd, 0x5c, 0x22,
0x64, 0x5f, 0xf0, 0xf2, 0xd0, 0x7c, 0xd9, 0xd4, 0x67, 0xe3, 0x3d, 0x2d, 0x05,
0x48, 0x79, 0x07, 0x69, 0x1f, 0xbf, 0x67, 0x94, 0x00, 0x86, 0x5c, 0x01, 0xc6,
0x5c, 0x43, 0x2a, 0x65, 0x5b, 0xc0, 0x7f, 0x75, 0xdc, 0x43, 0xae, 0xf9, 0xcb,
0x8f, 0x8f, 0xc1, 0x77, 0xac, 0x90, 0x68, 0x2e, 0xb7, 0xc0, 0x25, 0xb0, 0x00,
0x60, 0x39, 0x05, 0x36, 0xe4, 0xb5, 0xcb, 0x5e, 0xb3, 0x80, 0x97, 0x8b, 0x2e,
0x04, 0x62, 0xa1, 0x78, 0xc9, 0xbb, 0xea, 0xe5, 0x8b, 0x17, 0xbd, 0x2b, 0xd9,
0xb8, 0x04, 0xd2, 0x3c, 0xb2, 0x65, 0x25, 0xb2, 0xab, 0x16, 0x45, 0x26, 0x74,
0xa1, 0xd2, 0x29, 0xf7, 0x22, 0x87, 0x4a, 0xbd, 0x52, 0x1d, 0x51, 0x45, 0x34,
0x11, 0x01, 0x9a, 0x11, 0x3f, 0x96, 0x4a, 0xdc, 0x26, 0x74, 0x9a, 0x43, 0x4d,
0x19, 0x5a, 0x67, 0xe4, 0xeb, 0x8b, 0x99, 0xb5, 0x9c, 0x55, 0x89, 0xc5, 0x22,
0xf1, 0x1e, 0x8c, 0xe2, 0x49, 0x5d, 0xe8, 0x82, 0xcf, 0x51, 0xa8, 0xd7, 0x03,
0x3a, 0x79, 0x04, 0x27, 0x82, 0x75, 0xef, 0x86, 0x77, 0x41, 0xf6, 0x18, 0x6a,
0x55, 0x08, 0x61, 0xac, 0x2b, 0xf2, 0x0e, 0x9c, 0x44, 0x69, 0x86, 0x16, 0xb0,
0x3c, 0x66, 0x29, 0x63, 0x7b, 0x61, 0x96, 0x9b, 0x5e, 0x89, 0x78, 0x11, 0xe6,
0xb1, 0x1f, 0xd1, 0x22, 0x6b, 0xba, 0x4b, 0xf4, 0x6a, 0xef, 0x5e, 0xae, 0x61,
0x8c, 0x03, 0xfc, 0x81, 0x51, 0x0e, 0x6b, 0x8f, 0x67, 0xe3, 0x5a, 0xae, 0xc3,
0x6e, 0xb3, 0xdb, 0xed, 0x47, 0x5c, 0xeb, 0xd7, 0xba, 0x4f, 0x05, 0x7e, 0x01,
0xdd, 0x15, 0x10, 0xf8, 0x04, 0x5b, 0x30, 0x8f, 0x6d, 0xaf, 0x0a, 0xad, 0xa3,
0x5d, 0xd1, 0x86, 0xbc, 0xe0, 0x3e, 0xe1, 0x85, 0xdd, 0xaa, 0x48, 0x97, 0xa7,
0x6b, 0xe1, 0x1e, 0xa1, 0xc7, 0x50, 0xc1, 0x46, 0x3e, 0x43, 0x96, 0xc3, 0x0c,
0xb8, 0x54, 0x0e, 0xba, 0x0f, 0xe0, 0x51, 0xf9, 0xd4, 0x5b, 0x43, 0xd2, 0xf0,
0x62, 0x4c, 0xd3, 0xde, 0x8d, 0x6f, 0xc6, 0x57, 0xe3, 0xc7, 0x57, 0x44, 0x9f,
0x61, 0x18, 0xf0, 0x43, 0xdc, 0x82, 0xbf, 0xc3, 0xd9, 0xf1, 0xca, 0x30, 0xe2,
0x7a, 0xdc, 0x8c, 0xbf, 0x30, 0xf2, 0x98, 0x47, 0xb8, 0x0e, 0xff, 0x64, 0x98,
0xf0, 0x67, 0x06, 0x8e, 0xbf, 0x31, 0x3e, 0x18, 0x36, 0xdc, 0x8a, 0x63, 0xf8,
0x13, 0xe3, 0x91, 0xf1, 0xf3, 0xb7, 0xe7, 0x52, 0x29, 0xcb, 0x23, 0xcc, 0xbb,
0x8e, 0x5d, 0xcd, 0x4e, 0x58, 0xee, 0x81, 0x6a, 0x64, 0x57, 0xb2, 0xef, 0x2c,
0x35, 0xec, 0x7a, 0x34, 0x8f, 0x07, 0x90, 0x54, 0xb1, 0x5f, 0x2c, 0xb5, 0xc0,
0x35, 0xb0, 0x93, 0x96, 0xb4, 0xe5, 0xc9, 0x72, 0x6b, 0xb9, 0x41, 0x27, 0xc9,
0xb3, 0x25, 0xf3, 0x5b, 0xcc, 0x6d, 0xe3, 0x1a, 0xb8, 0x38, 0xe8, 0xd3, 0x0a,
0xc9, 0x05, 0xab, 0x37, 0x72, 0x8f, 0x21, 0xb7, 0xa0, 0xd3, 0xc1, 0x04, 0xb9,
0xdb, 0x6e, 0xe6, 0xfe, 0xf6, 0x86, 0xd5, 0x75, 0x26, 0x60, 0xb9, 0x38, 0xae,
0xa0, 0xe0, 0x42, 0xe0, 0x84, 0x96, 0x4c, 0x17, 0x17, 0x30, 0xf9, 0x5c, 0xc0,
0x70, 0x85, 0x41, 0xdf, 0xa1, 0xac, 0xa5, 0x80, 0xbe, 0x88, 0x90, 0xa4, 0x62,
0x85, 0x58, 0x26, 0xa6, 0x78, 0xe9, 0x40, 0xef, 0x80, 0x9d, 0xc8, 0xc5, 0x2a,
0x31, 0x16, 0xa0, 0x7a, 0x95, 0x62, 0x92, 0x97, 0x00, 0xb2, 0x3d, 0x90, 0x91,
0x73, 0x7b, 0xbc, 0x06, 0x7b, 0xa4, 0x0e, 0x2c, 0xcb, 0x56, 0x64, 0x4b, 0x32,
0x5d, 0xe0, 0x20, 0xa0, 0x09, 0x6c, 0x20, 0xeb, 0xd1, 0x06, 0x76, 0x91, 0x85,
0xe9, 0x03, 0xfb, 0x81, 0x55, 0xd9, 0x0f, 0xd9, 0xba, 0xec, 0x30, 0x87, 0x53,
0x5d, 0xb0, 0x0f, 0x2f, 0xa1, 0xe7, 0xd0, 0x53, 0xa8, 0x43, 0xf1, 0xaf, 0xd9,
0x75, 0x2a, 0x0e, 0x23, 0x47, 0x91, 0x23, 0xe4, 0xeb, 0x98, 0xd2, 0x10, 0xd1,
0x45, 0x8c, 0x4a, 0x3d, 0xec, 0xbc, 0x41, 0x79, 0x00, 0x39, 0x16, 0x89, 0xa9,
0xa2, 0xaa, 0xdd, 0x98, 0x22, 0xfb, 0xb5, 0x41, 0x4c, 0x0c, 0xb9, 0x24, 0xe7,
0xc5, 0x57, 0xe0, 0xdb, 0x97, 0xaa, 0x6b, 0x95, 0x28, 0x16, 0x51, 0x49, 0x63,
0xb2, 0x98, 0x12, 0xc9, 0x77, 0x50, 0x9e, 0x4e, 0xe4, 0x9e, 0x3e, 0x82, 0x37,
0xfb, 0x53, 0x7a, 0x8d, 0x2f, 0x75, 0x9a, 0xea, 0xd3, 0xce, 0x1c, 0x54, 0x82,
0xbd, 0x4e, 0xa3, 0xf8, 0xad, 0x3e, 0xd3, 0x00, 0x56, 0x30, 0x02, 0xde, 0x58,
0x97, 0xb9, 0x84, 0xfc, 0xec, 0xd9, 0x72, 0xc8, 0x7c, 0x61, 0xbd, 0x80, 0x75,
0x65, 0xef, 0xcc, 0xa9, 0x42, 0xea, 0x03, 0x78, 0x9b, 0x1d, 0x6f, 0x62, 0xdb,
0xb9, 0x97, 0xc8, 0x77, 0x1c, 0x7c, 0x58, 0xaf, 0x58, 0x23, 0xc6, 0x45, 0x0c,
0xd0, 0xc0, 0xa6, 0xec, 0x2d, 0xf4, 0x8a, 0x90, 0xeb, 0x86, 0x2c, 0xa2, 0x3a,
0xf0, 0x02, 0xe6, 0xaf, 0x5f, 0xf9, 0x90, 0x5e, 0x2d, 0x6f, 0xb0, 0x57, 0x27,
0x76, 0x8f, 0xdd, 0xc1, 0x3d, 0x86, 0x5d, 0x70, 0x72, 0x79, 0xe8, 0x64, 0x8c,
0xc2, 0x18, 0x5a, 0xd0, 0xcb, 0xbe, 0xf8, 0x28, 0xb0, 0x7e, 0xf6, 0x1e, 0xda,
0x43, 0xf3, 0xec, 0xd7, 0x8e, 0xea, 0x12, 0x70, 0x3d, 0x25, 0x65, 0x8f, 0xb2,
0x4b, 0x51, 0x51, 0x14, 0x28, 0x2e, 0x93, 0x82, 0x2d, 0x3e, 0x19, 0x24, 0x54,
0x19, 0xb2, 0xc9, 0x7b, 0xc3, 0x9d, 0xe1, 0xc1, 0x90, 0x36, 0x3c, 0x1a, 0xc4,
0xd4, 0x94, 0x21, 0xf3, 0x2d, 0x2a, 0xfb, 0x69, 0xfc, 0x49, 0xfb, 0x34, 0x16,
0x9a, 0x3e, 0x60, 0xa6, 0xa5, 0xa6, 0x02, 0x53, 0xb1, 0xe9, 0x91, 0xf6, 0x44,
0x7b, 0xa6, 0xbd, 0x00, 0x9f, 0x47, 0x87, 0xf9, 0x98, 0xde, 0x68, 0xf9, 0x50,
0xe6, 0x99, 0x4a, 0x4c, 0x30, 0x33, 0x5a, 0x91, 0xe9, 0x9d, 0x96, 0xa1, 0x7d,
0xfe, 0x43, 0xcc, 0xd5, 0x0a, 0x33, 0x77, 0xe2, 0x85, 0x90, 0x57, 0x33, 0x6b,
0x98, 0x25, 0xcc, 0x36, 0x66, 0x19, 0xd3, 0x8f, 0x37, 0x32, 0x4f, 0xf0, 0x72,
0x66, 0x14, 0xbf, 0xc2, 0xcf, 0x70, 0x0f, 0xde, 0xc2, 0xbc, 0xc4, 0xeb, 0x99,
0xb5, 0xd0, 0x26, 0x02, 0xde, 0x7a, 0x81, 0x9f, 0xe2, 0xc7, 0xb8, 0x0f, 0xaf,
0x00, 0xbe, 0x0e, 0x52, 0x11, 0x33, 0x88, 0x07, 0x70, 0x17, 0xd4, 0x34, 0x30,
0x43, 0xb8, 0x1b, 0x6f, 0x66, 0x5e, 0xe3, 0xc5, 0x20, 0xaf, 0x62, 0x7a, 0xf1,
0x30, 0xde, 0x04, 0x54, 0x29, 0xb3, 0x12, 0xf2, 0x73, 0xfc, 0x3f, 0xc5, 0x3b,
0x9d, 0xd6, 0x2e, 0xf6, 0x38, 0x78, 0x40, 0x8b, 0xb5, 0xca, 0x3a, 0xc0, 0xae,
0xb0, 0x76, 0xb2, 0x8b, 0xad, 0xc3, 0xec, 0x06, 0xeb, 0xa7, 0x25, 0xdf, 0xfa,
0xf5, 0x04, 0xd4, 0xfa, 0x6e, 0xa9, 0xb7, 0xf6, 0x5b, 0xfb, 0xd8, 0x25, 0xd6,
0x36, 0x90, 0xfe, 0xb4, 0xf4, 0x5a, 0xfb, 0xac, 0x83, 0xd6, 0x0e, 0x6b, 0xa5,
0xb5, 0xd1, 0x3a, 0xc2, 0x6e, 0x67, 0xf7, 0xb3, 0xa7, 0xd9, 0x2d, 0xec, 0x36,
0xf6, 0x1f, 0xed, 0x0b, 0xad, 0x13, 0xec, 0x41, 0x76, 0xb7, 0x35, 0xcf, 0x3a,
0xc5, 0x1e, 0x65, 0x97, 0xa3, 0x71, 0x26, 0xd9, 0x75, 0xd6, 0x32, 0xeb, 0x10,
0xbb, 0xcb, 0xda, 0x04, 0x7c, 0x0f, 0x7b, 0xc0, 0x5a, 0x6a, 0xed, 0x60, 0xb7,
0x5b, 0x6b, 0xad, 0xbd, 0xec, 0x66, 0x6b, 0x2b, 0xfb, 0xc3, 0x32, 0xc6, 0xbe,
0xe0, 0x76, 0xb3, 0x6b, 0xac, 0xd5, 0xd6, 0x82, 0x6c, 0x0b, 0x48, 0xad, 0xa8,
0x67, 0x33, 0x3b, 0x61, 0x8f, 0x73, 0x93, 0xe0, 0x45, 0x21, 0xfb, 0x19, 0xf7,
0x06, 0x76, 0xd8, 0x07, 0xf4, 0x85, 0xfd, 0x06, 0x72, 0xaf, 0x3d, 0x63, 0x77,
0xe5, 0x3c, 0xef, 0xc1, 0x7e, 0x0b, 0x92, 0x94, 0x3d, 0xc0, 0xbd, 0xe6, 0x46,
0x80, 0x8a, 0xda, 0xef, 0xec, 0x57, 0x50, 0x86, 0xed, 0x7e, 0x7b, 0xc0, 0x1e,
0xb7, 0x5f, 0x22, 0xd4, 0x72, 0x73, 0x7d, 0xdc, 0xb4, 0x3d, 0x68, 0x8f, 0x72,
0xc3, 0xa8, 0x5f, 0x84, 0x9b, 0xe0, 0x9e, 0x72, 0xaf, 0xb8, 0x31, 0x7b, 0x8c,
0xeb, 0x01, 0xc9, 0x09, 0xf7, 0x14, 0xda, 0x9d, 0xd9, 0xcf, 0xb9, 0xf7, 0xf6,
0x6b, 0xfb, 0xb9, 0xfd, 0x92, 0x1b, 0x02, 0xa9, 0x97, 0xeb, 0xe7, 0xfe, 0x6f,
0x7e, 0x7f, 0xa4, 0x03, 0x0b, 0x14, 0xbb, 0x24, 0x2e, 0x39, 0x94, 0x47, 0xae,
0x43, 0xc8, 0x55, 0xae, 0x3d, 0x57, 0x52, 0xb0, 0xef, 0xb2, 0xb9, 0xf8, 0xc0,
0xd9, 0x5d, 0x07, 0x2e, 0x97, 0xcb, 0xe0, 0x4a, 0x08, 0x30, 0xd7, 0x95, 0xe0,
0x43, 0x90, 0xce, 0x3e, 0x89, 0x16, 0x3c, 0x0a, 0x04, 0x50, 0x67, 0x71, 0x39,
0x5d, 0xb8, 0xeb, 0x18, 0xd9, 0xb0, 0xc6, 0x25, 0x74, 0x39, 0x5c, 0x5a, 0x57,
0x5c, 0xf0, 0x0c, 0x2d, 0x4c, 0xae, 0xbb, 0xdc, 0x7d, 0x8b, 0xd1, 0x25, 0x72,
0xbd, 0x00, 0xfd, 0x26, 0x30, 0xbb, 0xde, 0x05, 0x31, 0x81, 0xc2, 0x65, 0x45,
0xed, 0x53, 0x82, 0x57, 0x81, 0xd2, 0xa5, 0x77, 0xc9, 0x5c, 0xbb, 0xae, 0x8c,
0x40, 0xea, 0xba, 0x16, 0xdc, 0x0b, 0x6e, 0x05, 0x6a, 0x57, 0x90, 0xab, 0xf1,
0xde, 0x08, 0xfe, 0xd3, 0x8c, 0x1f, 0xa0, 0xf6, 0xc0, 0xeb, 0xf5, 0x5a, 0xbc,
0x6e, 0xf0, 0x19, 0xbb, 0x78, 0xcf, 0xeb, 0x10, 0x9b, 0xc1, 0xeb, 0xf4, 0xde,
0x63, 0xaf, 0x45, 0xcc, 0xf2, 0xba, 0xbc, 0x3a, 0xb1, 0xc8, 0x8b, 0x89, 0xf5,
0x50, 0x7b, 0x02, 0x89, 0xe3, 0xb5, 0x7a, 0x6d, 0x5e, 0x83, 0xf8, 0x50, 0xbc,
0x0b, 0xad, 0x6c, 0x62, 0x29, 0xe4, 0x76, 0x2f, 0x2e, 0x36, 0x78, 0xdd, 0x5e,
0xbe, 0x57, 0xe2, 0xe5, 0x01, 0x6f, 0x12, 0x6b, 0xbd, 0xc1, 0x80, 0xc0, 0x6b,
0x15, 0x2b, 0xbc, 0x0e, 0xaf, 0x51, 0x2c, 0xf3, 0x8a, 0xbd, 0x87, 0x5e, 0xb3,
0xf8, 0x40, 0xec, 0x15, 0x1f, 0x79, 0x31, 0x2f, 0xdb, 0x7b, 0x24, 0x76, 0x7a,
0x95, 0x5e, 0x55, 0xb6, 0xad, 0xd7, 0xe8, 0x65, 0x7a, 0x8f, 0xc5, 0x2e, 0xb1,
0xd0, 0x2b, 0xf7, 0xee, 0x7b, 0x9d, 0xe2, 0x1d, 0xaf, 0xce, 0x7b, 0x02, 0x35,
0xb8, 0xf7, 0xdf, 0xcf, 0xda, 0xf3, 0x55, 0xc7, 0xfd, 0xa2, 0xd2, 0x01, 0x2a,
0xa0, 0xe2, 0x5d, 0xe0, 0x34, 0x70, 0x1e, 0xf0, 0x02, 0x0e, 0x26, 0x02, 0xa6,
0x80, 0x03, 0xca, 0x78, 0x20, 0x13, 0xf0, 0x43, 0x69, 0x0d, 0x84, 0x03, 0x57,
0x81, 0x63, 0xa0, 0x2e, 0x03, 0x36, 0x84, 0x93, 0x27, 0x01, 0x4f, 0x80, 0x2e,
0xbb, 0x09, 0xc4, 0x80, 0xc3, 0x03, 0xb7, 0x90, 0xa7, 0x02, 0xf7, 0x01, 0xb6,
0x8c, 0x0c, 0xe3, 0xec, 0xb8, 0x9c, 0x81, 0x68, 0xc0, 0x15, 0x20, 0xc8, 0x04,
0xb2, 0x64, 0x80, 0x27, 0x63, 0xc9, 0x8c, 0x01, 0x12, 0xc8, 0xcd, 0x01, 0x3e,
0xe4, 0x81, 0x80, 0x01, 0x5a, 0x33, 0x64, 0xa1, 0x80, 0x3d, 0xc0, 0x94, 0xf9,
0x02, 0xdb, 0x32, 0x8f, 0xf8, 0x22, 0xa0, 0xf6, 0x5a, 0xd0, 0xb8, 0xd7, 0x01,
0x8a, 0x2c, 0x12, 0x20, 0xca, 0xce, 0x02, 0x1c, 0x99, 0x3b, 0xf0, 0xf0, 0x5b,
0xec, 0x48, 0x93, 0xe9, 0x83, 0x68, 0xde, 0xb2, 0xdf, 0x7e, 0xeb, 0x14, 0x2e,
0x0b, 0x83, 0xed, 0x87, 0x4b, 0x20, 0x6f, 0x0b, 0x6f, 0xc9, 0x7a, 0x15, 0x05,
0xe1, 0x6e, 0xa0, 0x4b, 0xc3, 0xcd, 0xe1, 0x21, 0x45, 0x37, 0x60, 0x78, 0x27,
0x70, 0x79, 0xe1, 0x0e, 0xc8, 0x67, 0x15, 0xf5, 0xe1, 0xfe, 0xf0, 0xb4, 0xa2,
0x3c, 0xdc, 0xa3, 0xa8, 0x0c, 0xb7, 0x87, 0x47, 0x15, 0x45, 0xe1, 0x49, 0x45,
0xbf, 0xa2, 0x3a, 0x5c, 0x18, 0xfe, 0x00, 0x9c, 0x6c, 0x0d, 0x8f, 0x29, 0xfa,
0xc2, 0x3f, 0x43, 0xc3, 0xd0, 0xab, 0x11, 0xda, 0x8f, 0x28, 0x8a, 0xc3, 0x75,
0xe1, 0xaa, 0x70, 0x0d, 0xd0, 0x7d, 0x8a, 0xde, 0xf0, 0x8c, 0xa2, 0x16, 0xa8,
0x81, 0x30, 0xfa, 0xe2, 0x20, 0xd4, 0x14, 0x1e, 0x54, 0x4c, 0x29, 0x26, 0x14,
0xf9, 0xe1, 0x96, 0xf0, 0x38, 0x3a, 0x2b, 0x06, 0x14, 0x0d, 0xe1, 0xaf, 0xf7,
0xe7, 0xe1, 0xbf, 0x6a, 0xde, 0x05, 0x27, 0x85, 0x3d, 0x62, 0x8e, 0x84, 0x22,
0xc1, 0x88, 0x19, 0x9d, 0x24, 0x91, 0x88, 0x33, 0xe2, 0x51, 0x9e, 0xa2, 0x08,
0xc2, 0x16, 0xf1, 0x45, 0x5c, 0xca, 0x5b, 0xa0, 0x6f, 0x22, 0x81, 0x88, 0x05,
0xc9, 0xc2, 0x91, 0xcb, 0x88, 0x5d, 0xe9, 0x89, 0x1c, 0x47, 0x8c, 0x11, 0x8b,
0xd2, 0x0d, 0x7d, 0xae, 0x22, 0x27, 0x4a, 0x53, 0x24, 0x19, 0x39, 0x8f, 0x44,
0x23, 0x4e, 0x34, 0xc6, 0x05, 0xb4, 0x8c, 0x43, 0xf2, 0x02, 0x77, 0xac, 0xf4,
0x47, 0xac, 0x91, 0x54, 0x04, 0x8f, 0x5c, 0x47, 0x6c, 0xc0, 0xbb, 0x41, 0x7e,
0x12, 0xb1, 0x2a, 0x71, 0xa5, 0x23, 0xe2, 0x00, 0xde, 0x04, 0x29, 0x16, 0x49,
0x44, 0xbc, 0x11, 0x63, 0xec, 0xef, 0x96, 0xa1, 0x05, 0x99, 0x2a, 0xf6, 0x84,
0x9e, 0x41, 0xdc, 0xa8, 0xee, 0x54, 0x09, 0x15, 0x1e, 0x3b, 0x89, 0xc5, 0x55,
0xba, 0x98, 0x39, 0x76, 0x16, 0xb1, 0xa0, 0x1e, 0xf7, 0x50, 0x1b, 0x88, 0x3d,
0xaa, 0x5e, 0x54, 0x1a, 0xe0, 0x33, 0xc0, 0x9d, 0xc6, 0xfc, 0x31, 0x07, 0x40,
0x81, 0x01, 0xd5, 0x1f, 0xc7, 0x7c, 0x31, 0x2f, 0x50, 0x29, 0x55, 0x52, 0x65,
0x8a, 0x1d, 0x65, 0xdf, 0x10, 0xc7, 0x3c, 0xb1, 0x67, 0x95, 0x3b, 0xf6, 0xa0,
0x4a, 0x43, 0x6b, 0x1b, 0x48, 0xd4, 0xb1, 0xfd, 0xd8, 0x41, 0xcc, 0x15, 0xb3,
0xc6, 0x6e, 0x41, 0xa2, 0x07, 0x89, 0xf3, 0xb7, 0xd9, 0x60, 0x7f, 0x99, 0x9b,
0x55, 0x53, 0x9c, 0x3c, 0xd2, 0x3c, 0xc2, 0x69, 0x99, 0x9f, 0x34, 0x6a, 0xca,
0x92, 0x70, 0xcf, 0x0a, 0xf4, 0x33, 0x3a, 0x3d, 0xcb, 0x93, 0x0f, 0x89, 0xcf,
0xec, 0x73, 0x15, 0x4d, 0x51, 0xb2, 0x22, 0xf9, 0x33, 0x61, 0xd0, 0xe4, 0x25,
0x33, 0x09, 0x1b, 0x7a, 0xc3, 0x52, 0x9a, 0x7c, 0x4d, 0xe0, 0x40, 0xbd, 0x27,
0x5e, 0x12, 0x0e, 0xcd, 0x5b, 0xc2, 0xa4, 0xb1, 0x68, 0x0a, 0x93, 0x4f, 0x89,
0x12, 0x18, 0xa1, 0x20, 0x99, 0xfb, 0x4d, 0x91, 0xf6, 0x2a, 0x35, 0xa6, 0x1d,
0xcf, 0x3d, 0x57, 0x1e, 0xd0, 0x46, 0x21, 0xfa, 0xba, 0x48, 0x5d, 0xa6, 0x46,
0xb4, 0xc1, 0x54, 0x38, 0x35, 0x0c, 0xf2, 0xb3, 0xaf, 0xa7, 0x2f, 0xa3, 0xda,
0x21, 0xe0, 0x03, 0xa9, 0x50, 0x2a, 0x92, 0x93, 0xd5, 0xa7, 0x6b, 0xd2, 0xad,
0x70, 0x5a, 0xb7, 0xa4, 0x9b, 0xd2, 0xb5, 0x50, 0x2e, 0x1c, 0x7c, 0xfb, 0xba,
0x2b, 0x3d, 0x7f, 0x60, 0xd6, 0x34, 0xa6, 0xe7, 0x0e, 0xda, 0xd2, 0x0d, 0xe9,
0xea, 0xf4, 0x79, 0xae, 0xcf, 0x2c, 0xb4, 0xa9, 0x4a, 0xb7, 0xc0, 0xb9, 0xde,
0x9c, 0x69, 0x4e, 0x8f, 0xc1, 0xa9, 0xde, 0x9e, 0xe9, 0xc8, 0x34, 0x65, 0xda,
0x40, 0xd2, 0x98, 0xf9, 0xfa, 0xe6, 0xfb, 0xb1, 0x35, 0x73, 0xa5, 0x8b, 0xe8,
0xac, 0x8f, 0x8e, 0x47, 0xc0, 0xb7, 0x47, 0xdb, 0x63, 0x34, 0xf7, 0x9d, 0x60,
0xe4, 0x29, 0xfa, 0xb4, 0x7c, 0x78, 0xf9, 0x94, 0xfb, 0x9a, 0xf3, 0xd9, 0x7a,
0x78, 0xfe, 0x1c, 0x7a, 0x66, 0xa3, 0x6f, 0x01, 0x5b, 0xf4, 0x0f, 0x2f, 0xf7,
0x2f, 0xe9, 0x97, 0x4c, 0xee, 0x3b, 0xc1, 0xdd, 0x57, 0xb8, 0x6b, 0x20, 0xef,
0x64, 0xbf, 0xe5, 0x86, 0x53, 0x2d, 0x86, 0x4e, 0xb5, 0xa1, 0xdc, 0x19, 0xf5,
0x68, 0x7f, 0x06, 0xd4, 0x7e, 0x82, 0xf4, 0x62, 0xff, 0x29, 0x38, 0x71, 0xbd,
0x02, 0xe5, 0x76, 0x79, 0x5c, 0x5e, 0x97, 0xcf, 0x7b, 0x2a, 0x3e, 0xf5, 0x06,
0xbc, 0x7e, 0xb1, 0x4f, 0xec, 0x07, 0x8c, 0x78, 0x0b, 0xbc, 0x04, 0x9e, 0xc1,
0x13, 0x9f, 0x02, 0x8f, 0x01, 0xa1, 0xec, 0x35, 0x30, 0xa7, 0x18, 0x0c, 0x0f,
0x87, 0xe7, 0x15, 0x43, 0xe1, 0x53, 0xb0, 0x27, 0x9f, 0xf2, 0x0e, 0xd9, 0xea,
0x59, 0x2c, 0x18, 0x3b, 0x47, 0x3b, 0xf7, 0x0a, 0xbb, 0x5a, 0x99, 0x3c, 0xce,
0xde, 0xa3, 0xa4, 0x26, 0xb4, 0xed, 0xe9, 0x95, 0xc3, 0x5b, 0xb2, 0x9a, 0x22,
0xa7, 0x16, 0xd0, 0x3b, 0x98, 0x9d, 0x4c, 0xf4, 0x5e, 0x09, 0x9d, 0x7a, 0x6f,
0x5f, 0x31, 0xb1, 0x28, 0xe7, 0xd1, 0xf6, 0xe8, 0x9b, 0x6a, 0x52, 0x9b, 0xca,
0xfe, 0x3a, 0x07, 0x45, 0x15, 0x37, 0x78, 0x17, 0x33, 0x0e, 0xb3, 0x1e, 0xb6,
0xce, 0xb2, 0x47, 0x60, 0xde, 0x73, 0xd0, 0xef, 0xc3, 0x7e, 0xcb, 0x4d, 0xc2,
0xc9, 0x12, 0x74, 0xf9, 0x5d, 0x01, 0xd7, 0x29, 0x60, 0xb8, 0x0f, 0xe1, 0x78,
0xd0, 0x1b, 0xf2, 0x06, 0xc5, 0x67, 0xde, 0x80, 0xf8, 0x1c, 0xe6, 0xfc, 0x8e,
0x90, 0x63, 0x24, 0x3c, 0x1a, 0x1e, 0x03, 0x3f, 0x7c, 0x88, 0xa4, 0x23, 0x7e,
0xe5, 0x7d, 0x24, 0x13, 0x09, 0xa1, 0x19, 0x86, 0x63, 0x17, 0x50, 0x56, 0x25,
0x9d, 0x9a, 0x29, 0x6d, 0x07, 0xec, 0xdb, 0xb5, 0xae, 0x17, 0x22, 0x96, 0x79,
0xf6, 0xa8, 0x35, 0x85, 0xce, 0xac, 0x4f, 0x40, 0xf6, 0x33, 0x71, 0x18, 0xc6,
0x91, 0xc8, 0xc4, 0x68, 0x6e, 0xe3, 0xe1, 0x89, 0x70, 0x40, 0x19, 0x54, 0x46,
0x62, 0x97, 0xb1, 0x58, 0xea, 0xe2, 0xf9, 0x8e, 0xdc, 0x67, 0xd0, 0x64, 0x7f,
0xe1, 0x4a, 0x2f, 0x83, 0xa8, 0x65, 0x81, 0x2d, 0x95, 0xdd, 0xc3, 0xac, 0xc7,
0xac, 0x8b, 0xec, 0x71, 0x98, 0xa7, 0x4b, 0x93, 0x46, 0x77, 0x1b, 0x09, 0x98,
0xfb, 0x04, 0xf0, 0x05, 0x8e, 0x7c, 0xc7, 0x27, 0xac, 0xf6, 0xa7, 0xbd, 0xd0,
0x91, 0xe7, 0x40, 0x5f, 0xa0, 0x08, 0xf3, 0x85, 0xe8, 0xf7, 0x4a, 0xe2, 0x0b,
0xb8, 0xca, 0xa5, 0x37, 0x92, 0xc3, 0xe2, 0xfc, 0x60, 0x41, 0x30, 0x0f, 0x50,
0xee, 0x67, 0xe0, 0x33, 0x20, 0x93, 0x4d, 0x86, 0x9f, 0x23, 0x4f, 0x91, 0xc7,
0xc8, 0x4b, 0xe4, 0x2a, 0x16, 0x8d, 0xbd, 0xab, 0xae, 0x61, 0xd6, 0x6e, 0x4d,
0x35, 0xd8, 0x6e, 0x3c, 0xd5, 0x99, 0xbe, 0x02, 0x1b, 0x78, 0x20, 0x6b, 0x29,
0xfb, 0x30, 0x8f, 0x6e, 0x66, 0xbf, 0x61, 0xdb, 0xb0, 0x0b, 0x5a, 0x7b, 0x36,
0x94, 0x9b, 0x2a, 0x4c, 0x3d, 0xa0, 0xe7, 0x24, 0x5c, 0xfd, 0x07, 0x7b, 0xd2,
0x3a, 0x05, 0x33, 0xb8, 0xe3, 0x66, 0xb8, 0x45, 0x8e, 0x07, 0xee, 0x3d, 0x37,
0x0d, 0x2b, 0x3c, 0x73, 0x15, 0x08, 0x2f, 0xb2, 0xef, 0x59, 0xc5, 0x61, 0x71,
0x14, 0x5d, 0x79, 0x41, 0x91, 0x81, 0x19, 0x13, 0x40, 0x0b, 0x07, 0x28, 0xba,
0x23, 0xa3, 0x08, 0x4e, 0x4f, 0x21, 0x19, 0x0e, 0x29, 0x3a, 0x4a, 0x11, 0x9d,
0x88, 0xf8, 0x97, 0x5c, 0x5c, 0xf7, 0x61, 0xf8, 0x34, 0xe4, 0x19, 0x0f, 0xa9,
0x7a, 0xea, 0xbb, 0x61, 0x1f, 0xae, 0xf9, 0x0a, 0xf2, 0x9f, 0x06, 0x2d, 0x50,
0x7b, 0x90, 0x54, 0x90, 0x74, 0xd4, 0x37, 0x83, 0x92, 0x5a, 0x4c, 0x57, 0x53,
0x35, 0xd4, 0x83, 0xdc, 0xdb, 0x8b, 0x4e, 0x53, 0xbb, 0xa9, 0xca, 0x54, 0x4f,
0x6f, 0x34, 0x55, 0xd1, 0xab, 0x41, 0x6b, 0xcd, 0x90, 0x1a, 0x4c, 0xb5, 0xf4,
0x7a, 0x53, 0x0b, 0xbd, 0xc3, 0xd4, 0x06, 0x31, 0x60, 0x47, 0xf6, 0xf7, 0x58,
0x20, 0xad, 0xa6, 0x77, 0x41, 0xde, 0x44, 0x6f, 0x05, 0xbe, 0xd8, 0x5c, 0x4a,
0xef, 0xa1, 0x37, 0xd3, 0x6b, 0x4c, 0x15, 0xf4, 0x76, 0x7a, 0x8b, 0xa9, 0x8c,
0x5e, 0x4e, 0x2f, 0x34, 0xd7, 0x9a, 0xea, 0xe8, 0x9d, 0xf4, 0x6e, 0x53, 0x9d,
0xa9, 0x06, 0xda, 0x34, 0xd2, 0x6f, 0xf1, 0x2e, 0x7a, 0xab, 0xa9, 0x01, 0xe8,
0x6e, 0x7a, 0x09, 0xbd, 0xc9, 0x54, 0x49, 0x6f, 0x33, 0x15, 0x99, 0xff, 0xfd,
0x29, 0x38, 0xc1, 0x5c, 0x67, 0x3e, 0xe2, 0xf3, 0xa0, 0xa5, 0x4a, 0xf3, 0x00,
0xe4, 0xc3, 0xcc, 0x02, 0x68, 0xfd, 0x80, 0x3f, 0xe3, 0xd3, 0xcc, 0x59, 0xe6,
0x1b, 0xbe, 0xcc, 0x1c, 0x63, 0x8e, 0x30, 0x47, 0x99, 0x4b, 0xcc, 0x52, 0xf3,
0x1c, 0xf3, 0x15, 0x7f, 0xc7, 0x67, 0x98, 0x8b, 0xcc, 0x0f, 0xbc, 0x02, 0x5a,
0x2d, 0xb1, 0xd7, 0xa0, 0xc7, 0x20, 0xb3, 0x1c, 0xe8, 0x6a, 0xf3, 0x0b, 0x5e,
0x6b, 0xce, 0x33, 0x4f, 0x31, 0x33, 0xf8, 0x24, 0x73, 0x8b, 0xb9, 0x00, 0x35,
0x69, 0x7c, 0xc9, 0xba, 0xca, 0xdc, 0x64, 0xe6, 0x9b, 0x4b, 0xa0, 0xc5, 0x36,
0x73, 0x85, 0x39, 0xce, 0xec, 0x05, 0xf9, 0x10, 0xa4, 0x27, 0xbc, 0x8f, 0x59,
0x03, 0xd2, 0x3b, 0x3c, 0x85, 0xff, 0xc4, 0xef, 0xf1, 0x0d, 0xe6, 0x23, 0xf7,
0x07, 0xf3, 0x13, 0xef, 0x87, 0x3a, 0x6a, 0x2e, 0x16, 0xac, 0x32, 0x6f, 0x5a,
0x09, 0xb0, 0x67, 0x64, 0xeb, 0x0a, 0xf2, 0x55, 0x9a, 0x95, 0x69, 0x65, 0x5b,
0x7f, 0x58, 0x97, 0xd9, 0x1b, 0xec, 0x72, 0x07, 0x87, 0x4d, 0xb1, 0x72, 0xac,
0x1b, 0xd6, 0xc5, 0x9c, 0x1f, 0x0f, 0x39, 0xb6, 0xd9, 0x44, 0xeb, 0xaa, 0x75,
0xdd, 0x4a, 0x81, 0xfe, 0x5b, 0xd6, 0x2d, 0xf6, 0x9c, 0x95, 0x0e, 0x75, 0x2c,
0x54, 0xbf, 0x0e, 0x32, 0x3a, 0x7b, 0xda, 0xca, 0x64, 0xaf, 0xb2, 0xb9, 0x6c,
0x86, 0x75, 0xd6, 0xca, 0x62, 0xf7, 0x38, 0xca, 0xcc, 0x9b, 0xec, 0x15, 0xf6,
0xb2, 0x75, 0xc6, 0xca, 0x66, 0x93, 0xd9, 0x24, 0x2b, 0x83, 0x4d, 0x63, 0xaf,
0x59, 0x09, 0xec, 0x79, 0x2b, 0x91, 0x4d, 0x62, 0x2f, 0x58, 0xa9, 0xd6, 0x35,
0xf6, 0xb6, 0xf5, 0xbf, 0x8f, 0xdd, 0xaa, 0x1c, 0x3f, 0xb9, 0x85, 0xbc, 0xdc,
0xdb, 0x0f, 0x47, 0xa7, 0xa3, 0xd5, 0x51, 0xe1, 0xa8, 0x76, 0x94, 0x38, 0x4a,
0x1d, 0x15, 0xbc, 0x37, 0x6e, 0x8b, 0xa3, 0xd7, 0x51, 0xcc, 0x7b, 0x02, 0xbb,
0xcb, 0xe3, 0xd5, 0x38, 0x0a, 0x78, 0xb5, 0x8e, 0x76, 0x47, 0x2e, 0x4a, 0xe6,
0x8d, 0x39, 0xca, 0x1c, 0x1f, 0xdc, 0x77, 0x6e, 0x19, 0xaf, 0xd8, 0x31, 0xe2,
0xe8, 0x70, 0x8c, 0x3a, 0xfa, 0x1d, 0x8d, 0x8e, 0x01, 0xa8, 0xef, 0x72, 0x0c,
0x3b, 0x06, 0x1d, 0xe5, 0xbc, 0x26, 0xc7, 0x2b, 0xf7, 0x85, 0x9b, 0xcf, 0x2b,
0xe5, 0xf5, 0x39, 0x4a, 0x78, 0xf5, 0x8e, 0x42, 0xf0, 0x9b, 0x71, 0x47, 0x9d,
0xa3, 0xd2, 0xf1, 0xc9, 0xad, 0xe4, 0x3d, 0xc3, 0xa8, 0x6d, 0x8e, 0x6e, 0xc7,
0xff, 0x3c, 0xc7, 0x61, 0x61, 0xc8, 0x15, 0x01, 0xa4, 0x68, 0x10, 0xd6, 0x21,
0xcf, 0x2b, 0x15, 0x5e, 0xb8, 0xc2, 0xae, 0x4e, 0xa0, 0xaf, 0x5d, 0xcd, 0x90,
0xbf, 0xb9, 0x4a, 0xdd, 0x45, 0xc2, 0x67, 0xd7, 0x9d, 0x6b, 0x54, 0x78, 0x0e,
0xed, 0x3e, 0x20, 0x0d, 0x09, 0xdb, 0x84, 0x83, 0xc2, 0x1a, 0x61, 0xc2, 0xf5,
0xe9, 0x7a, 0x72, 0xd5, 0x0a, 0xcb, 0x85, 0xc5, 0x6e, 0xb0, 0x74, 0x57, 0x9e,
0xbb, 0x5e, 0xd8, 0x2e, 0x2c, 0x70, 0xc7, 0x5d, 0xef, 0xae, 0x94, 0xab, 0xc8,
0xdd, 0x23, 0x2c, 0x11, 0x76, 0x09, 0x33, 0xae, 0xb4, 0xeb, 0xc1, 0xd5, 0x28,
0xbc, 0x75, 0x25, 0x5d, 0x65, 0xc2, 0x2b, 0x57, 0x89, 0xbb, 0x42, 0x78, 0xef,
0x1a, 0x83, 0xb1, 0x07, 0x84, 0x51, 0x57, 0xaf, 0xb0, 0x5b, 0x38, 0x22, 0x7c,
0x71, 0xf5, 0x0b, 0x1b, 0x1c, 0xaf, 0xae, 0x3e, 0x61, 0xbe, 0xbb, 0x58, 0xf8,
0xe8, 0x6a, 0x15, 0xc6, 0x5c, 0x2d, 0xd0, 0xa2, 0x49, 0x58, 0x25, 0xac, 0x14,
0x5e, 0x79, 0x0b, 0xdd, 0x37, 0x08, 0xcd, 0x3e, 0xb2, 0xef, 0x5c, 0x84, 0xff,
0x9d, 0xf6, 0xf3, 0x25, 0x1d, 0xc2, 0x5b, 0xf1, 0x93, 0xf7, 0x03, 0x3c, 0x3a,
0xee, 0xbd, 0x11, 0x5f, 0x89, 0xcb, 0x7d, 0x49, 0xf1, 0xbd, 0x38, 0x21, 0x7e,
0x14, 0x57, 0xfb, 0x8a, 0x7c, 0xe8, 0xdc, 0xf6, 0xbe, 0x89, 0x33, 0xe2, 0x9f,
0xde, 0x4b, 0x71, 0x85, 0xaf, 0xd0, 0x77, 0x2d, 0x7e, 0xf6, 0x3e, 0x8b, 0x9b,
0x7d, 0x2d, 0x50, 0x17, 0x11, 0x97, 0xf9, 0x5e, 0xc5, 0xef, 0xde, 0xa4, 0xf7,
0xd6, 0xfb, 0x53, 0x9c, 0xf6, 0xbe, 0x7a, 0x1f, 0xb2, 0xf8, 0x29, 0x2e, 0x92,
0xa4, 0xbc, 0xd7, 0xde, 0x18, 0xd0, 0x37, 0xde, 0xb8, 0xf8, 0x05, 0xca, 0x17,
0x71, 0x01, 0xfa, 0x45, 0xc4, 0x9b, 0xb7, 0xd1, 0x57, 0xe9, 0x8b, 0x8a, 0xeb,
0x7d, 0x69, 0xb8, 0xe2, 0x5d, 0xf6, 0x5d, 0x95, 0x2f, 0x25, 0xce, 0xf7, 0x65,
0xbc, 0x9f, 0xde, 0x52, 0x49, 0xb1, 0xaf, 0xc0, 0x77, 0xe7, 0x2d, 0x94, 0xd4,
0xfa, 0xaa, 0x7c, 0x4d, 0xbe, 0x98, 0x38, 0xcf, 0x57, 0x02, 0xbd, 0x4a, 0xd1,
0x2c, 0x1e, 0xc4, 0x4f, 0xd0, 0xba, 0xc4, 0x57, 0x2c, 0x79, 0xf4, 0x5e, 0xa2,
0x75, 0xd6, 0xf9, 0x6a, 0x7c, 0x0d, 0xbe, 0xff, 0xb4, 0xba, 0x84, 0x37, 0x4f,
0x92, 0xfb, 0xc6, 0x22, 0xd8, 0x17, 0x2c, 0x09, 0xee, 0x01, 0x1e, 0xf7, 0x06,
0xcb, 0x83, 0x15, 0x80, 0x92, 0x98, 0x6c, 0x2c, 0xa8, 0x95, 0xf5, 0x00, 0x55,
0x18, 0x3c, 0x92, 0xa9, 0x64, 0x0d, 0xc1, 0xb2, 0x60, 0x65, 0x70, 0x30, 0xb8,
0x23, 0x9b, 0x08, 0x0e, 0x04, 0xf7, 0x65, 0xad, 0x41, 0x1c, 0xa1, 0xb7, 0x49,
0x76, 0xf8, 0x07, 0x8a, 0x07, 0xe5, 0xb2, 0xe6, 0x60, 0x55, 0xb0, 0x3d, 0x38,
0x1c, 0x34, 0x83, 0x64, 0x57, 0xd6, 0x04, 0x7d, 0xab, 0x83, 0x3a, 0xa0, 0x0f,
0x64, 0x75, 0xc1, 0x8e, 0xe0, 0x50, 0xb0, 0x34, 0x58, 0x1f, 0x54, 0xca, 0x3a,
0x83, 0x06, 0x99, 0x46, 0x56, 0x13, 0x54, 0xcb, 0x8a, 0x83, 0x8d, 0xc1, 0xd1,
0xe0, 0xa7, 0x98, 0xaf, 0x68, 0x09, 0x4e, 0x85, 0xdb, 0x82, 0x23, 0x41, 0xbd,
0xac, 0x36, 0xa8, 0x90, 0x19, 0x65, 0x77, 0xca, 0x22, 0xe8, 0xdd, 0x1d, 0xcc,
0xc5, 0x7b, 0xc1, 0xff, 0xb4, 0x0a, 0x66, 0x98, 0xa3, 0xd8, 0x0a, 0x93, 0xc3,
0x44, 0x88, 0x13, 0x67, 0xc2, 0x3c, 0xc8, 0x57, 0x14, 0xd3, 0x61, 0x7e, 0x58,
0xa0, 0x98, 0x0f, 0x93, 0xe0, 0x84, 0x5a, 0x0c, 0x8b, 0xc2, 0xbc, 0xf0, 0x92,
0x82, 0xa0, 0x68, 0x8c, 0x72, 0x15, 0x5b, 0x8a, 0x59, 0x90, 0x71, 0xc3, 0x24,
0x05, 0x2b, 0xbc, 0x13, 0x5e, 0x0a, 0x6f, 0xa3, 0x58, 0x52, 0x1a, 0x66, 0x87,
0x37, 0x51, 0x9c, 0xb9, 0x19, 0x5e, 0x56, 0xfc, 0x50, 0xd0, 0x11, 0xbd, 0x1e,
0x5e, 0x09, 0xaf, 0x42, 0xbd, 0x10, 0x92, 0x2c, 0x2c, 0x09, 0xaf, 0x2b, 0xe4,
0xe1, 0x6d, 0x05, 0x0d, 0xea, 0xe6, 0xc2, 0x6f, 0x91, 0x35, 0x90, 0xae, 0x2a,
0xd8, 0x0a, 0x86, 0x62, 0x43, 0x41, 0x09, 0xff, 0x08, 0x33, 0x15, 0xb4, 0x30,
0x59, 0x41, 0x55, 0x2c, 0x42, 0x3d, 0x23, 0x4c, 0x08, 0x2f, 0x84, 0x29, 0x0a,
0x41, 0x58, 0x1c, 0xde, 0x08, 0xd3, 0xa1, 0xe5, 0x9a, 0xe2, 0x4c, 0x49, 0x0d,
0xbf, 0xc2, 0x79, 0xce, 0x09, 0xff, 0xe3, 0xbb, 0xd3, 0x70, 0x51, 0xb4, 0x26,
0x1a, 0x56, 0x56, 0x47, 0xdb, 0xa3, 0x97, 0xca, 0xca, 0xe8, 0xaf, 0x5f, 0xb5,
0xd1, 0x54, 0xf6, 0x17, 0x1c, 0xd1, 0x2b, 0xc8, 0x1b, 0xa2, 0x77, 0xb1, 0x07,
0x65, 0x5a, 0xd9, 0x14, 0x2d, 0x8c, 0xf6, 0x44, 0x93, 0x20, 0xb9, 0x50, 0xb6,
0x42, 0x9b, 0xce, 0x68, 0x5f, 0xb4, 0x39, 0x5a, 0x1e, 0x8d, 0x2a, 0x63, 0xca,
0x7b, 0x65, 0x22, 0xfb, 0x6e, 0x3e, 0x4a, 0x44, 0xe3, 0x97, 0x45, 0x7b, 0xa3,
0xd7, 0xc0, 0xdf, 0x28, 0xfb, 0xa3, 0xe7, 0xca, 0x96, 0xe8, 0x7b, 0xa4, 0x2b,
0x7a, 0x06, 0x71, 0x43, 0x05, 0xf4, 0x0a, 0x29, 0x8b, 0xa3, 0x11, 0xe5, 0x47,
0x84, 0xa5, 0xc8, 0x07, 0xae, 0x23, 0x5a, 0x10, 0xcd, 0x8b, 0xc6, 0xa1, 0x6d,
0x1b, 0x70, 0x9f, 0x91, 0xfa, 0x68, 0x5d, 0xb4, 0x3b, 0x5a, 0x1a, 0xbd, 0xfd,
0xed, 0xe9, 0xeb, 0x03, 0x9c, 0x8f, 0xe5, 0xea, 0x4f, 0x55, 0x5e, 0xfc, 0x26,
0x96, 0xaf, 0x7e, 0x8e, 0x95, 0xa9, 0x0b, 0xd5, 0x8f, 0xb1, 0xda, 0xe4, 0x7b,
0xac, 0x20, 0xfe, 0x16, 0x8b, 0xc5, 0x5e, 0x62, 0x45, 0xf1, 0x92, 0xf8, 0x4f,
0x55, 0x71, 0xbc, 0x48, 0x5d, 0xa1, 0x06, 0xab, 0x84, 0xf4, 0x19, 0x2b, 0x51,
0xbf, 0x42, 0xbf, 0x64, 0x2c, 0x9d, 0xfd, 0xed, 0x48, 0xac, 0x58, 0x5d, 0xa0,
0xfe, 0x50, 0xe5, 0xa9, 0xef, 0xb3, 0x5c, 0x24, 0x11, 0x4b, 0xc5, 0xf2, 0xe3,
0x99, 0x58, 0x3c, 0x56, 0x93, 0x2c, 0x8c, 0xdf, 0xc6, 0x3e, 0xbe, 0x62, 0xd3,
0xfa, 0xe4, 0x05, 0x8a, 0x32, 0x4f, 0x50, 0x7e, 0xaa, 0x69, 0x4c, 0xb6, 0x27,
0x5b, 0x93, 0x5e, 0x8d, 0x4f, 0x13, 0xd2, 0x74, 0x24, 0x1b, 0x92, 0x7e, 0x90,
0xb7, 0x24, 0x9b, 0x93, 0x9d, 0xc9, 0x30, 0x50, 0x01, 0xcd, 0xb9, 0xa6, 0x29,
0x79, 0xa9, 0x09, 0x6a, 0x22, 0x1a, 0x8f, 0xa6, 0x0d, 0x4e, 0xf0, 0x3a, 0x14,
0x81, 0x3e, 0xa3, 0xa8, 0x70, 0x5e, 0x9b, 0x49, 0x3d, 0x01, 0x35, 0xab, 0x4d,
0xa7, 0x1e, 0x52, 0xb7, 0x48, 0xf6, 0x14, 0x4b, 0xa5, 0xe6, 0xb4, 0x37, 0x40,
0x4f, 0x6b, 0x5f, 0x52, 0x33, 0xda, 0x44, 0x2a, 0x99, 0xba, 0x4f, 0x2d, 0x42,
0x04, 0xba, 0x80, 0xa2, 0xd5, 0xbb, 0xd4, 0xea, 0x41, 0x6f, 0x7a, 0x38, 0xbd,
0x76, 0xd0, 0x95, 0x5e, 0x3e, 0x58, 0x3c, 0x18, 0x4d, 0xaf, 0x40, 0x64, 0xf9,
0xe3, 0xa0, 0x27, 0xdd, 0x9f, 0x1e, 0x48, 0x0f, 0xa6, 0x47, 0x20, 0xae, 0x79,
0x4c, 0x75, 0xa7, 0x97, 0x0e, 0x86, 0xd2, 0x63, 0xe9, 0xbe, 0x74, 0xee, 0x1b,
0x8c, 0xcc, 0x84, 0xae, 0x2f, 0x33, 0xa9, 0x1b, 0xcb, 0xf4, 0x66, 0xba, 0xb2,
0x4f, 0x18, 0x33, 0x03, 0x99, 0xe1, 0xcc, 0x50, 0x66, 0x34, 0xd3, 0x09, 0xdc,
0xb8, 0x6e, 0x30, 0x33, 0x92, 0x19, 0xcf, 0xf4, 0x67, 0x8e, 0x1f, 0x9d, 0x8f,
0x9e, 0x47, 0x2f, 0xc4, 0x9e, 0xee, 0xc7, 0x93, 0x47, 0x17, 0x94, 0xb1, 0xaf,
0xdf, 0xa9, 0xac, 0x1e, 0xde, 0xa0, 0xe8, 0xf3, 0xfa, 0x29, 0xf6, 0x14, 0x7f,
0x5a, 0x3b, 0x04, 0x0c, 0x79, 0xbe, 0x7c, 0xfe, 0xf5, 0x8b, 0xf7, 0x92, 0x39,
0xe4, 0xbc, 0xf0, 0x5f, 0xb8, 0x2f, 0x8f, 0x2f, 0xad, 0xfa, 0x61, 0x3d, 0xe9,
0x75, 0x0a, 0xe2, 0x4f, 0xe2, 0xab, 0xed, 0xd5, 0xfe, 0xfa, 0xf8, 0xf5, 0xf4,
0x15, 0xa3, 0xe6, 0xa3, 0xa7, 0x95, 0x3d, 0x70, 0xc2, 0xf7, 0xc2, 0x79, 0x3d,
0x00, 0xa9, 0x17, 0xe8, 0x3e, 0x7a, 0xff, 0xbf, 0xfe, 0x23, 0x88, 0xb9, 0xc3,
0xdc, 0x6c, 0x6e, 0x30, 0x37, 0xe5, 0x4e, 0x70, 0x32, 0x33, 0xf7, 0xff, 0x61,
0x50, 0xd9, 0x62, 0x26, 0x31, 0x1b, 0xcd, 0x75, 0x66, 0x02, 0xb3, 0x15, 0xea,
0xeb, 0xcd, 0x14, 0x66, 0xfb, 0xd7, 0x49, 0xcf, 0x83, 0x53, 0x4b, 0x84, 0x4e,
0x2e, 0x19, 0xfb, 0xeb, 0x7f, 0x0e, 0x01, 0xcf, 0x63, 0x0b, 0xd9, 0x62, 0xb6,
0x94, 0x2d, 0x62, 0x0b, 0xad, 0x02, 0xe0, 0x05, 0x6c, 0xb1, 0x55, 0x02, 0x25,
0xd7, 0x2a, 0x81, 0x76, 0xfc, 0x5c, 0x5b, 0xfe, 0x6f, 0x67, 0xde, 0x8a, 0x63,
0xd5, 0xb1, 0xe6, 0xa8, 0x83, 0x73, 0xad, 0x8a, 0x37, 0x03, 0x27, 0xcc, 0xb2,
0x63, 0xc3, 0x51, 0x0f, 0xdc, 0x94, 0x63, 0xc1, 0x31, 0xe9, 0x58, 0x42, 0x67,
0xce, 0xbc, 0xa3, 0x9a, 0x57, 0xcb, 0x5b, 0x07, 0x7a, 0xc2, 0x31, 0xed, 0x58,
0x84, 0xf2, 0x87, 0x63, 0xd3, 0x31, 0x07, 0x65, 0x0d, 0xef, 0x9f, 0x3c, 0x68,
0x5a, 0x58, 0xe3, 0x46, 0xb8, 0xe7, 0xae, 0x82, 0xb2, 0xcd, 0x5d, 0xe1, 0x6e,
0x75, 0x8f, 0x0b, 0xcb, 0xdc, 0x9d, 0xbe, 0x06, 0xf7, 0x14, 0xe0, 0x7d, 0xa3,
0xbb, 0x05, 0xe4, 0x1d, 0x90, 0x6a, 0x21, 0x35, 0xa1, 0xb6, 0x13, 0xc2, 0x49,
0x61, 0xbb, 0xbb, 0xda, 0x5d, 0xee, 0xee, 0x04, 0xbe, 0x1e, 0xc9, 0x9a, 0xdd,
0xb9, 0x77, 0x26, 0x50, 0x96, 0x49, 0xca, 0x25, 0xc3, 0xbe, 0x5a, 0x40, 0xc9,
0x76, 0xdf, 0x80, 0xaf, 0xcd, 0x57, 0x25, 0xe9, 0xf3, 0xf5, 0x00, 0xa6, 0xf6,
0xfa, 0x2a, 0x40, 0x36, 0xf8, 0x0d, 0x5d, 0xbb, 0x7c, 0x1d, 0xbe, 0x4a, 0x49,
0xb7, 0xaf, 0x3f, 0x27, 0xab, 0xce, 0x21, 0xeb, 0xd0, 0x6f, 0x08, 0x3c, 0x17,
0x5c, 0x09, 0xae, 0x05, 0x09, 0x80, 0x67, 0x3e, 0xd9, 0x24, 0xe4, 0x0e, 0x40,
0xc7, 0xf5, 0xe0, 0x89, 0x8c, 0x18, 0xb4, 0x00, 0xb5, 0x05, 0x92, 0xe9, 0xe0,
0x76, 0x70, 0x0a, 0x4a, 0x3f, 0xf0, 0xab, 0x41, 0xab, 0x8c, 0x04, 0xb4, 0x53,
0x36, 0x1f, 0xf4, 0xca, 0x36, 0x83, 0xb3, 0xc1, 0xe5, 0xe0, 0x42, 0x70, 0x26,
0x68, 0x97, 0x79, 0x64, 0x6e, 0xd9, 0xb1, 0xec, 0x54, 0x66, 0x93, 0x2d, 0x41,
0xbd, 0x0b, 0xda, 0xd6, 0xc0, 0xf5, 0x36, 0x80, 0x5e, 0xfc, 0x86, 0x95, 0x3f,
0x10, 0xbd, 0x0f, 0x78, 0x20, 0x46, 0x78, 0xb6, 0x17, 0x3e, 0x08, 0xab, 0x81,
0x93, 0x2a, 0x54, 0x61, 0x6d, 0x58, 0x01, 0x94, 0x32, 0x2c, 0xf9, 0x7a, 0x12,
0xab, 0x09, 0xef, 0x66, 0x71, 0x0e, 0x78, 0x21, 0x92, 0xe9, 0x80, 0x13, 0x29,
0x46, 0xa3, 0x43, 0xd1, 0xb9, 0xe8, 0x44, 0x74, 0x2a, 0x9a, 0x51, 0x8e, 0x44,
0x67, 0xa2, 0x48, 0xd3, 0xd1, 0x49, 0x28, 0xe7, 0xa3, 0xcf, 0xca, 0xb1, 0xe8,
0x2c, 0x50, 0x8f, 0x08, 0x29, 0x06, 0xa3, 0xc3, 0xd1, 0x27, 0xe5, 0x40, 0x74,
0x01, 0x24, 0xe3, 0xa8, 0x5d, 0x45, 0xbc, 0x5e, 0x8d, 0x34, 0x1a, 0x6f, 0x8c,
0x57, 0xaa, 0xcb, 0xe3, 0x55, 0xf1, 0xea, 0x78, 0x59, 0xbc, 0x59, 0xdd, 0xa2,
0x2e, 0x8d, 0xb7, 0xc4, 0xeb, 0xe3, 0xb5, 0xea, 0x2a, 0x75, 0x5d, 0xbc, 0x26,
0x9e, 0x6d, 0xd3, 0xa0, 0x6e, 0x88, 0x57, 0x43, 0xeb, 0x1a, 0x48, 0xb5, 0xf1,
0x3a, 0x75, 0x25, 0x48, 0x9b, 0xe2, 0x8d, 0xea, 0xd6, 0x78, 0x5b, 0xbc, 0x09,
0x8d, 0x72, 0xa5, 0xb9, 0xd5, 0x74, 0x25, 0x07, 0xc0, 0xb7, 0xfb, 0x92, 0x71,
0x4d, 0x4c, 0x13, 0xd5, 0xf4, 0xe4, 0xee, 0x34, 0x13, 0x9a, 0x1b, 0xcd, 0x35,
0x20, 0x41, 0x7f, 0xb2, 0x3b, 0xd9, 0x0b, 0xb2, 0x64, 0xee, 0x77, 0x65, 0x2b,
0xda, 0x77, 0xf0, 0xf1, 0x1f, 0xda, 0x25, 0xed, 0xcf, 0xd4, 0xb2, 0xf6, 0x2d,
0xf5, 0x9a, 0x9a, 0x4a, 0x7f, 0x64, 0xbd, 0x3e, 0xbd, 0x7e, 0x30, 0x89, 0xbc,
0x76, 0x02, 0xf2, 0xf1, 0xf4, 0x06, 0xba, 0xb7, 0x9c, 0x42, 0x5e, 0x38, 0x91,
0x99, 0xfc, 0xba, 0x53, 0xf4, 0x3f, 0x9e, 0x3e, 0xc6, 0x41, 0xea, 0x7b, 0x4c,
0x3c, 0x25, 0x91, 0x5f, 0x46, 0x9f, 0x05, 0xe8, 0xfe, 0xef, 0xe9, 0x45, 0xf9,
0xba, 0xa6, 0xd7, 0xbf, 0x3e, 0x81, 0xef, 0x51, 0x99, 0x34, 0xe4, 0x3b, 0x3b,
0x5f, 0x5e, 0x91, 0xd2, 0x3c, 0x83, 0x9c, 0xce, 0x6c, 0xe0, 0x05, 0x64, 0x2f,
0xd9, 0xaf, 0xab, 0x85, 0x3b, 0x8a, 0x01, 0x88, 0xe3, 0x65, 0xd6, 0x2d, 0xb0,
0xde, 0x43, 0xd0, 0xeb, 0x9d, 0xe6, 0x95, 0xcc, 0x60, 0xee, 0x58, 0xe5, 0xd6,
0x11, 0x5f, 0x1d, 0xb2, 0x14, 0x32, 0xda, 0xab, 0xa0, 0x4c, 0x8f, 0xd0, 0xfb,
0x05, 0x34, 0xba, 0x79, 0xf0, 0x46, 0x1e, 0xf5, 0xbd, 0x67, 0x7f, 0x9d, 0x4d,
0x2d, 0x30, 0x1e, 0x51, 0x87, 0xe9, 0x43, 0xf4, 0x41, 0x7a, 0x5f, 0xee, 0xbf,
0x15, 0x30, 0xe1, 0x9a, 0x2c, 0x66, 0x27, 0x78, 0xa7, 0x02, 0x3c, 0x6b, 0xcf,
0xaa, 0x60, 0xef, 0x42, 0x29, 0x67, 0x2b, 0xad, 0xbb, 0x30, 0x0f, 0xa2, 0x83,
0xe0, 0xd8, 0x76, 0x34, 0x82, 0x9f, 0x74, 0xbb, 0x7b, 0xdc, 0xb3, 0xc2, 0x2e,
0x77, 0xaf, 0xbb, 0x41, 0x32, 0x87, 0xa2, 0x9e, 0x7a, 0xc9, 0xa4, 0x6f, 0x02,
0xac, 0x72, 0xcc, 0x37, 0x0e, 0xf9, 0x94, 0x8f, 0x1a, 0xa4, 0x04, 0x19, 0x70,
0x75, 0x7a, 0x90, 0x16, 0x94, 0x2b, 0x0c, 0x70, 0xfd, 0xa3, 0xb0, 0x42, 0x81,
0x85, 0x17, 0x61, 0x0f, 0x7f, 0x44, 0x5f, 0x61, 0x26, 0xed, 0xf1, 0x0e, 0xb4,
0x47, 0x0b, 0xe9, 0xad, 0x83, 0xf9, 0xf4, 0x5c, 0x7a, 0x26, 0x3d, 0x9b, 0xbe,
0xd1, 0x4d, 0x65, 0x6e, 0x9f, 0x9e, 0x41, 0x1b, 0x1f, 0x30, 0x43, 0x8a, 0x01,
0xa3, 0x50, 0x73, 0x77, 0x30, 0x85, 0xc6, 0xa2, 0xaf, 0x77, 0x26, 0x23, 0x68,
0xb6, 0x03, 0xd9, 0xff, 0xd0, 0x60, 0x62, 0x33, 0x87, 0x4d, 0xa3, 0xf4, 0x41,
0xd3, 0x08, 0x7d, 0xd4, 0x34, 0x84, 0xe4, 0xbd, 0x66, 0x95, 0xb5, 0xdb, 0x3c,
0x04, 0x6b, 0xe0, 0xc0, 0x6a, 0xf8, 0xcc, 0x61, 0x73, 0x3f, 0xd0, 0x03, 0x90,
0xba, 0xcc, 0x3c, 0x66, 0x8f, 0x99, 0xcb, 0x1c, 0x04, 0xba, 0x0f, 0x21, 0x90,
0xd6, 0xba, 0xc7, 0x56, 0xc1, 0xca, 0x0e, 0xad, 0x6a, 0x58, 0xa7, 0x0e, 0x92,
0xc6, 0xaa, 0x64, 0x1f, 0x58, 0xf7, 0xff, 0x12, 0x4b, 0xd3, 0x1d, 0x14, 0xd0,
0x31, 0xcd, 0xd1, 0xc6, 0x6b, 0xe5, 0x35, 0xf3, 0xc8, 0x0e, 0x86, 0xa3, 0x89,
0xd7, 0xc2, 0xa3, 0x3a, 0x46, 0xdd, 0x24, 0x07, 0xf3, 0x5b, 0x2c, 0x3b, 0xe0,
0x1e, 0x01, 0xff, 0x1e, 0x76, 0xcf, 0xf8, 0xd6, 0x90, 0x87, 0x8e, 0x01, 0x37,
0xe8, 0x9e, 0xf6, 0xfd, 0x40, 0x3a, 0x5a, 0x14, 0xf6, 0xbb, 0x87, 0xdc, 0x4b,
0x40, 0x2f, 0x08, 0xe7, 0x85, 0x7d, 0xee, 0xf1, 0x1c, 0x26, 0xcc, 0xf9, 0x56,
0xa0, 0x75, 0x93, 0x64, 0xd9, 0xb7, 0x08, 0x65, 0x4b, 0xce, 0xc7, 0x97, 0xd0,
0x08, 0xb3, 0xbe, 0x79, 0xdf, 0x0f, 0xdf, 0x82, 0xaf, 0x59, 0xb2, 0xea, 0x6b,
0x94, 0x9c, 0xa1, 0xa8, 0x88, 0x13, 0x64, 0x07, 0x99, 0xa0, 0xdb, 0xb0, 0x2c,
0x24, 0xe3, 0x42, 0xc9, 0x0a, 0x1a, 0xc3, 0xbb, 0x8a, 0xf3, 0xdc, 0x3d, 0x39,
0x3f, 0xc8, 0x03, 0x99, 0x39, 0x6c, 0x0a, 0xbf, 0x81, 0x96, 0x95, 0x0a, 0x3c,
0xbc, 0x1c, 0xfd, 0xfa, 0xdd, 0xb9, 0x72, 0x29, 0xba, 0x1d, 0xdd, 0x8a, 0x6e,
0x80, 0x64, 0x3d, 0xba, 0x12, 0x5d, 0x8d, 0xae, 0x45, 0x37, 0xa3, 0x04, 0x54,
0xdf, 0x1b, 0xef, 0x8a, 0x77, 0xc7, 0x5b, 0xd5, 0x9d, 0xf1, 0xfe, 0x78, 0x5f,
0xbc, 0x07, 0xf6, 0x66, 0x28, 0x39, 0x9c, 0xbc, 0x07, 0xab, 0x4f, 0x6b, 0x06,
0xc1, 0xfe, 0xd7, 0xb4, 0x9f, 0xa9, 0x55, 0xed, 0x36, 0x58, 0x35, 0xe1, 0x60,
0x5a, 0x37, 0x93, 0x99, 0xce, 0x04, 0x1e, 0x53, 0x4f, 0xeb, 0x87, 0xd7, 0xcf,
0x57, 0xcf, 0xb1, 0xe7, 0x23, 0x8a, 0xde, 0xda, 0xce, 0x5b, 0x16, 0x4e, 0xb8,
0x0d, 0x14, 0x9a, 0xe1, 0x27, 0x3a, 0x3d, 0x8a, 0x73, 0x3b, 0x36, 0x65, 0x9a,
0x30, 0x4d, 0x9a, 0xc6, 0x4c, 0x63, 0xf4, 0xf1, 0x6f, 0xff, 0x15, 0x63, 0x1a,
0x76, 0x40, 0xc4, 0x9c, 0x34, 0x8f, 0x9a, 0x27, 0x80, 0x1a, 0x31, 0x4b, 0x98,
0xe3, 0x50, 0x0a, 0x99, 0x02, 0xd8, 0x35, 0x31, 0x73, 0xca, 0x3c, 0xf6, 0x75,
0x46, 0x68, 0xd9, 0x87, 0x6c, 0x8b, 0xd5, 0x6c, 0xc5, 0xad, 0x6a, 0xb6, 0xcb,
0x6a, 0x82, 0xbd, 0xd9, 0x67, 0xf3, 0x40, 0xeb, 0x0e, 0xab, 0xcd, 0xaa, 0x83,
0xdd, 0x3b, 0xb2, 0x1e, 0x83, 0xcc, 0x68, 0x75, 0x5a, 0xed, 0x56, 0x43, 0x76,
0x0f, 0xd9, 0x6e, 0x2b, 0x66, 0x3d, 0xf8, 0xf2, 0x1c, 0xb1, 0x83, 0xe5, 0x90,
0x42, 0x7b, 0xae, 0x43, 0xee, 0x50, 0x38, 0xd8, 0x8e, 0x1d, 0x87, 0xc4, 0x21,
0x72, 0xc8, 0x1c, 0xbd, 0x59, 0x4b, 0x46, 0xa8, 0x2f, 0x80, 0x5a, 0x0e, 0x24,
0xbe, 0x63, 0xd7, 0x21, 0x74, 0xf4, 0xf0, 0xac, 0x30, 0x4a, 0x07, 0xaf, 0xeb,
0xdb, 0x89, 0xb0, 0xea, 0x9e, 0x76, 0x4f, 0xc2, 0x7e, 0x4d, 0x41, 0x5a, 0x84,
0xf4, 0xc3, 0x3d, 0xe7, 0xde, 0x10, 0x2e, 0xb9, 0x17, 0xdc, 0xb3, 0xc0, 0xad,
0x09, 0x67, 0xdc, 0x2b, 0xc2, 0x75, 0xe1, 0xbc, 0x7b, 0xcd, 0xdd, 0xc9, 0x5b,
0x15, 0xae, 0xb8, 0x97, 0xdd, 0x9b, 0x7f, 0xbb, 0x1b, 0xd8, 0xce, 0xa1, 0x36,
0xc1, 0xd7, 0x07, 0x7b, 0x4c, 0x43, 0x1c, 0xc3, 0x47, 0xf4, 0x75, 0x48, 0xa8,
0x3e, 0x8a, 0xaf, 0x53, 0xd2, 0x0f, 0xd2, 0x01, 0x09, 0xdd, 0xd7, 0x26, 0xd9,
0xf2, 0x6d, 0xf8, 0x48, 0xbe, 0x75, 0x5f, 0xaf, 0x64, 0xd3, 0x47, 0xf6, 0x31,
0x7d, 0xed, 0x92, 0x1e, 0x49, 0x97, 0xa4, 0x3b, 0x67, 0x19, 0xad, 0x92, 0xaf,
0x77, 0xf3, 0x32, 0x59, 0xf0, 0x5a, 0xb6, 0x0b, 0xfb, 0x2d, 0x80, 0xa4, 0xcc,
0xa1, 0xb4, 0x30, 0x28, 0x02, 0x6a, 0x2f, 0xa8, 0x08, 0xee, 0x04, 0xe5, 0x41,
0x49, 0x50, 0x0c, 0x9c, 0x2a, 0x18, 0x01, 0xfb, 0x90, 0x02, 0x15, 0x97, 0x5d,
0xca, 0x6e, 0x64, 0x09, 0xe0, 0xae, 0x64, 0x51, 0x64, 0x33, 0x96, 0xb0, 0x4a,
0xb1, 0x87, 0xd0, 0xf9, 0x18, 0xfc, 0xf4, 0x43, 0xa9, 0x46, 0xf4, 0xbe, 0xc2,
0x19, 0xbe, 0x90, 0x69, 0x14, 0xb6, 0xb0, 0x23, 0x6c, 0x05, 0xb9, 0x3d, 0x17,
0x61, 0xb2, 0x90, 0xb5, 0x30, 0xa3, 0xb4, 0x68, 0xde, 0xde, 0x40, 0x3c, 0x7f,
0x8f, 0x9a, 0x8d, 0xef, 0xc0, 0xd2, 0xe8, 0x51, 0x4a, 0x94, 0x18, 0x65, 0x44,
0x49, 0x51, 0x72, 0xf4, 0xe7, 0x57, 0x94, 0x37, 0x0e, 0x96, 0x33, 0x02, 0xb6,
0x34, 0x1c, 0x1f, 0x85, 0x7c, 0x24, 0xd9, 0x01, 0xa8, 0x3b, 0x08, 0x54, 0x1b,
0x94, 0x5d, 0xea, 0x4e, 0xf5, 0x50, 0x7c, 0x0c, 0xb8, 0x76, 0xe0, 0xa6, 0x93,
0x8f, 0x9a, 0x75, 0xed, 0x93, 0xe6, 0x41, 0x33, 0x91, 0x1c, 0x83, 0x5e, 0x93,
0x90, 0x66, 0x92, 0x19, 0xcd, 0x54, 0x72, 0x14, 0x21, 0x72, 0xc1, 0x5d, 0xf1,
0xdd, 0x52, 0x3a, 0xef, 0x0e, 0x7c, 0x22, 0x53, 0x02, 0x39, 0xf1, 0xa0, 0xe8,
0x6e, 0x43, 0x9b, 0x7f, 0x57, 0x78, 0x57, 0x7a, 0xb7, 0x0c, 0x88, 0xfb, 0x23,
0xfd, 0xe7, 0x35, 0x49, 0x07, 0x8b, 0x39, 0x7a, 0xe6, 0x2b, 0x06, 0x4a, 0xea,
0xee, 0x9f, 0x12, 0xba, 0x87, 0xa7, 0xbb, 0xa7, 0xf4, 0x93, 0xed, 0x50, 0xf8,
0x62, 0xa4, 0xcc, 0x98, 0x95, 0x8e, 0x3d, 0xc7, 0x96, 0x50, 0x1d, 0xec, 0x56,
0x93, 0x0f, 0x36, 0x0e, 0x45, 0x2f, 0xa6, 0xec, 0x7f, 0x5c, 0x30, 0xf7, 0xa1,
0xff, 0xa1, 0x76, 0x02, 0x16, 0xe0, 0xf9, 0x86, 0x02, 0x2a, 0x87, 0xda, 0xb1,
0x2d, 0x24, 0xe4, 0xf6, 0x94, 0x05, 0x7b, 0xa7, 0x0d, 0xee, 0x07, 0x35, 0x41,
0x17, 0x68, 0xc5, 0x1d, 0x3e, 0x09, 0x6b, 0x91, 0xce, 0x38, 0x51, 0x36, 0xd2,
0xce, 0x78, 0xbc, 0x47, 0xdd, 0x0b, 0x6b, 0x5a, 0x48, 0xce, 0x26, 0xe7, 0x92,
0xf3, 0xc9, 0xf2, 0xbb, 0xb2, 0xbb, 0x4d, 0xed, 0x4a, 0x3a, 0xf8, 0x88, 0xc3,
0x35, 0xf4, 0x59, 0x2c, 0x15, 0x1e, 0x64, 0xbd, 0x34, 0xfb, 0xdb, 0x0a, 0x07,
0x09, 0x8d, 0x3a, 0x28, 0x19, 0x82, 0x7d, 0xb5, 0x50, 0xac, 0x94, 0x12, 0xe3,
0x04, 0x7d, 0x9c, 0x8e, 0xb1, 0xbd, 0x56, 0xb6, 0xcf, 0x46, 0xb1, 0x53, 0x1c,
0x94, 0xe3, 0xdc, 0x97, 0x55, 0x93, 0xf4, 0x29, 0xfa, 0x8c, 0x69, 0x1a, 0x79,
0x91, 0x94, 0xb9, 0x60, 0x9e, 0x33, 0xcf, 0xff, 0xf6, 0xcc, 0xc4, 0x67, 0x3d,
0x45, 0x73, 0x36, 0xb1, 0x0d, 0x70, 0x0d, 0x23, 0xfb, 0xe8, 0xcb, 0x07, 0xfa,
0xbe, 0x6c, 0x79, 0x88, 0x37, 0xc8, 0xdb, 0x77, 0x0c, 0xf0, 0xfa, 0x41, 0xa2,
0x45, 0xd8, 0x45, 0x15, 0x6e, 0xb8, 0xd7, 0xdd, 0x64, 0x21, 0x25, 0xb7, 0xba,
0x11, 0xc9, 0xb0, 0x84, 0x8b, 0xac, 0x93, 0xe3, 0xa3, 0x7d, 0xb3, 0xe2, 0xa4,
0xec, 0x30, 0x78, 0x2b, 0xd3, 0xe5, 0xac, 0xcc, 0x13, 0xe6, 0x46, 0x0b, 0xf6,
0x26, 0xe2, 0xb9, 0x5f, 0x2a, 0xc1, 0x1e, 0x51, 0x0f, 0x28, 0xe8, 0xcc, 0xdb,
0x3c, 0x74, 0x52, 0x16, 0xd1, 0xbc, 0xe8, 0x42, 0x6f, 0xf8, 0x00, 0x69, 0x66,
0xd6, 0x34, 0x87, 0x66, 0xfd, 0xc3, 0xbc, 0xc3, 0x94, 0xa3, 0x93, 0x4d, 0xc6,
0xfc, 0x7a, 0x5e, 0xcc, 0xb6, 0xb1, 0xcd, 0x6c, 0x0b, 0xcc, 0xd5, 0x8f, 0x66,
0x1f, 0xb0, 0xe2, 0x5f, 0xf3, 0x3e, 0x80, 0x19, 0x8e, 0xf1, 0xc6, 0x61, 0xae,
0x2c, 0xa1, 0x01, 0xe8, 0x19, 0xde, 0x14, 0xcf, 0xe8, 0x38, 0x74, 0x4c, 0xf2,
0x26, 0x78, 0xc3, 0xbc, 0x23, 0x07, 0xe6, 0xd0, 0x39, 0xa6, 0xa1, 0x56, 0xef,
0x18, 0x81, 0x7c, 0x14, 0xad, 0x92, 0x2d, 0x24, 0xb8, 0x89, 0x6e, 0x8e, 0x70,
0xd3, 0xbd, 0xed, 0x26, 0xbb, 0x49, 0xee, 0x2d, 0xf0, 0x50, 0x86, 0x90, 0x09,
0x2b, 0x91, 0xfa, 0x26, 0x25, 0x13, 0x12, 0xbe, 0x6f, 0x0c, 0x34, 0x2d, 0xf2,
0x4d, 0x49, 0xc4, 0xbe, 0x69, 0x89, 0xc0, 0x37, 0x2a, 0x19, 0x97, 0x48, 0x60,
0xbd, 0x42, 0x1f, 0xef, 0x5b, 0x5c, 0xe5, 0xc8, 0xde, 0xaf, 0x06, 0xef, 0x64,
0x0f, 0xb2, 0xb4, 0xec, 0x59, 0xf6, 0x24, 0x3b, 0x0e, 0xda, 0x83, 0xc6, 0xa0,
0x25, 0x68, 0x0e, 0x66, 0x64, 0xb6, 0x20, 0x1e, 0x74, 0x06, 0x4d, 0xc1, 0x47,
0x59, 0x4a, 0x76, 0x0f, 0x3e, 0x64, 0xf8, 0x8a, 0x8f, 0x4e, 0xc3, 0x98, 0xe2,
0x2c, 0xac, 0x57, 0xf8, 0xc3, 0x87, 0xb0, 0xee, 0xa3, 0xa0, 0x35, 0x18, 0xcc,
0x9e, 0x7d, 0x8a, 0xf3, 0x70, 0x20, 0xec, 0x43, 0x1e, 0x24, 0x88, 0x4a, 0xa2,
0xb2, 0xa8, 0x28, 0x2a, 0x8c, 0xf2, 0xa3, 0xc5, 0x7b, 0x85, 0x7b, 0x65, 0x7b,
0xe5, 0x7b, 0xe2, 0x68, 0xc9, 0x1e, 0x2f, 0x5a, 0xba, 0xa7, 0x53, 0x48, 0xa3,
0x45, 0x7b, 0x39, 0xd4, 0x04, 0xcd, 0x4e, 0xc6, 0x17, 0xe3, 0xd3, 0xf1, 0x85,
0xf8, 0x6c, 0xbc, 0x4f, 0x3d, 0x8f, 0x34, 0xdd, 0x0f, 0x56, 0x35, 0x00, 0x69,
0x2e, 0x3e, 0x13, 0xff, 0xfa, 0xf5, 0xa4, 0xe6, 0xc7, 0x1f, 0xf7, 0x26, 0x9a,
0x95, 0xe4, 0x52, 0x72, 0x19, 0xd1, 0xaf, 0xb9, 0x68, 0xa5, 0x1a, 0x3c, 0x85,
0xa0, 0xad, 0xb9, 0x43, 0xdf, 0xf8, 0x6a, 0x6b, 0xef, 0xb6, 0xb5, 0x55, 0x77,
0x75, 0xc0, 0x55, 0x20, 0x09, 0xed, 0x60, 0x35, 0x4d, 0x3f, 0x98, 0x05, 0x2f,
0xa9, 0xbc, 0x9b, 0xcb, 0xf9, 0xca, 0xad, 0xee, 0x0c, 0xee, 0x1e, 0xb6, 0x0f,
0x33, 0x4f, 0x5b, 0x70, 0xa7, 0x10, 0x7f, 0x7e, 0x3c, 0x7c, 0x3a, 0xcc, 0xca,
0xf1, 0x57, 0xf4, 0xc4, 0x97, 0x1d, 0x84, 0x3d, 0x9a, 0x91, 0xcc, 0x4a, 0x5c,
0x14, 0x23, 0xb5, 0x14, 0x10, 0x7e, 0xde, 0x34, 0x0d, 0xf7, 0x01, 0x0a, 0xd8,
0x4d, 0x07, 0xfb, 0x98, 0xed, 0x64, 0x53, 0xdd, 0x26, 0xc7, 0x2c, 0xda, 0x07,
0xae, 0x90, 0x82, 0x4e, 0xb8, 0x1d, 0xdf, 0x3c, 0xe8, 0x5b, 0xe6, 0x9b, 0x43,
0xb8, 0xe5, 0x0a, 0x56, 0xec, 0xed, 0x46, 0x77, 0xa2, 0xf2, 0xa8, 0x22, 0xfa,
0x0d, 0x5f, 0x61, 0xd6, 0xf5, 0x77, 0xb9, 0xff, 0xf2, 0x90, 0x99, 0x83, 0x68,
0xe9, 0xf1, 0xc9, 0x4d, 0x59, 0x32, 0xcf, 0xe5, 0xec, 0x76, 0x41, 0xe2, 0x46,
0x3a, 0x0e, 0x81, 0x0e, 0x2b, 0xf7, 0x7e, 0xc0, 0xda, 0x1b, 0xee, 0x16, 0x32,
0x27, 0xc8, 0x2f, 0x76, 0x99, 0x27, 0xec, 0x33, 0xab, 0x87, 0xed, 0x06, 0xab,
0x71, 0xb1, 0x71, 0xc7, 0x3c, 0xea, 0xb3, 0xc0, 0x5b, 0xcc, 0xf5, 0xe5, 0x0b,
0x69, 0x6e, 0xde, 0x37, 0x3b, 0x96, 0xfb, 0x04, 0xc2, 0x45, 0xc9, 0x49, 0xf0,
0x45, 0xf6, 0x9a, 0xdd, 0x3b, 0xd8, 0x27, 0xa3, 0xa2, 0x6a, 0x6f, 0x48, 0xbd,
0x14, 0x1f, 0x04, 0xcd, 0xae, 0x25, 0xdf, 0x40, 0x77, 0x8d, 0x77, 0x8b, 0x19,
0x0f, 0x65, 0x86, 0xbe, 0x6a, 0x5e, 0x31, 0x2b, 0x99, 0xcb, 0xe6, 0x3d, 0xe6,
0x1a, 0x58, 0x74, 0xc4, 0x7a, 0xca, 0xf6, 0xb1, 0xaf, 0xac, 0x51, 0xeb, 0x19,
0x5c, 0x2b, 0xc8, 0xf6, 0x66, 0xbf, 0xbb, 0xb3, 0x86, 0xad, 0x17, 0xa0, 0x93,
0x73, 0xf6, 0xb9, 0xd5, 0xcf, 0xbe, 0xb4, 0x06, 0xbe, 0x6c, 0xd7, 0xea, 0x38,
0x76, 0xd8, 0x1d, 0x36, 0xb0, 0x5a, 0x67, 0x2e, 0x46, 0x70, 0x39, 0xdc, 0x0e,
0x0b, 0xd0, 0x66, 0x48, 0x4b, 0xbc, 0x65, 0x98, 0xdf, 0x89, 0xc3, 0x91, 0x3d,
0x77, 0x40, 0x4f, 0x1e, 0xc7, 0x0a, 0xef, 0x47, 0x6e, 0xc6, 0xcc, 0xac, 0xc5,
0x42, 0x62, 0xb9, 0xd9, 0x6e, 0xae, 0x9b, 0xe3, 0x16, 0xba, 0x25, 0x42, 0xa1,
0x50, 0x2a, 0xa4, 0xbb, 0x65, 0x42, 0x81, 0x5b, 0x2c, 0xe4, 0xb9, 0x45, 0xdf,
0xd6, 0xa3, 0xf4, 0xa9, 0x7c, 0x0a, 0xdf, 0x2e, 0xb2, 0x5d, 0xb5, 0x6f, 0xdf,
0xa7, 0xf5, 0xed, 0xf9, 0x34, 0xbe, 0x1f, 0x48, 0xdb, 0xa7, 0xa0, 0xb5, 0xf3,
0xa0, 0x27, 0xe8, 0xff, 0x43, 0x7b, 0xc1, 0x40, 0xf0, 0x4d, 0x56, 0xb8, 0x03,
0x77, 0xca, 0x32, 0x6f, 0xd0, 0x17, 0xb4, 0x28, 0x4a, 0x76, 0x3e, 0x41, 0x07,
0x45, 0x3b, 0x1f, 0xb2, 0xb3, 0x60, 0xf1, 0x4e, 0x30, 0x98, 0xbf, 0xf3, 0x2e,
0x2b, 0xd8, 0x09, 0x07, 0xa3, 0xe1, 0xeb, 0x7f, 0x78, 0xa2, 0x90, 0xb7, 0x83,
0xde, 0x60, 0x85, 0x71, 0x45, 0x2c, 0x6c, 0x56, 0x5c, 0x85, 0xc3, 0xe1, 0x48,
0x38, 0x1e, 0x36, 0x29, 0x2e, 0xa1, 0x6d, 0xcd, 0x9e, 0x3a, 0xaa, 0x82, 0x1d,
0xad, 0xdf, 0xab, 0xdd, 0x53, 0x46, 0xab, 0xf7, 0xf6, 0x80, 0xae, 0xcb, 0xd9,
0xf2, 0x16, 0xec, 0x17, 0x01, 0xd2, 0x76, 0x7c, 0x39, 0xbe, 0x1e, 0x5f, 0x8b,
0xaf, 0xc4, 0x47, 0xd4, 0xa3, 0xea, 0x61, 0xf5, 0x6a, 0x7c, 0x23, 0xbe, 0x09,
0xf2, 0x31, 0xd0, 0x7b, 0xde, 0x3e, 0x29, 0xfb, 0xa6, 0x48, 0xb3, 0x91, 0xfc,
0xd4, 0xe4, 0xef, 0xa3, 0x2f, 0x11, 0x34, 0xc4, 0xe4, 0x66, 0xf2, 0x5d, 0x43,
0x48, 0xae, 0x27, 0xb7, 0x93, 0x5b, 0xc8, 0xae, 0x9b, 0xef, 0xc8, 0x5a, 0x8a,
0x96, 0x08, 0x77, 0xd4, 0x24, 0x74, 0x57, 0xdd, 0x04, 0x36, 0xb3, 0x81, 0xd0,
0x9e, 0x01, 0xd8, 0xb3, 0x96, 0x5e, 0xcf, 0x9e, 0x04, 0x99, 0x95, 0xcc, 0x52,
0x66, 0x39, 0x73, 0x8e, 0x7e, 0x95, 0x98, 0xd2, 0xdd, 0x3c, 0x8b, 0x21, 0xa2,
0x7c, 0x3e, 0x7c, 0x79, 0x79, 0x7d, 0x19, 0xd1, 0x7b, 0x29, 0x21, 0xd8, 0xa1,
0x03, 0xd0, 0xd6, 0x45, 0xf6, 0x8e, 0x89, 0x32, 0x0b, 0xd6, 0xab, 0x02, 0xeb,
0xbd, 0xb6, 0xc6, 0xac, 0xab, 0x48, 0xff, 0x3a, 0xdf, 0x92, 0xa4, 0x74, 0xa7,
0x60, 0x9f, 0x9c, 0xdc, 0x4c, 0xaf, 0x66, 0x4e, 0x73, 0xd8, 0x4b, 0x30, 0xaf,
0x9b, 0x37, 0xcd, 0xdb, 0xe6, 0x2d, 0xf3, 0x86, 0x59, 0xcd, 0x0c, 0xb3, 0xd3,
0xb0, 0xe7, 0x49, 0x6b, 0x1c, 0x21, 0xd6, 0x3d, 0xca, 0x2f, 0xd9, 0x11, 0xf6,
0x9d, 0x35, 0x65, 0xbd, 0xb5, 0xde, 0x58, 0x13, 0xd6, 0x07, 0xeb, 0x05, 0xfb,
0xaf, 0xfa, 0xdb, 0x84, 0xf1, 0xc9, 0x3c, 0x12, 0x2f, 0xe4, 0x38, 0x75, 0x78,
0x61, 0xdf, 0x09, 0x3c, 0xb9, 0x7b, 0x9d, 0x17, 0x74, 0x84, 0x1d, 0x97, 0x8e,
0x73, 0x87, 0xcf, 0x41, 0xe4, 0x9d, 0x39, 0x02, 0x8e, 0x35, 0x5e, 0xc4, 0x41,
0xe1, 0x5d, 0x38, 0xb6, 0x78, 0x7e, 0x68, 0xb3, 0xcd, 0xdb, 0xf8, 0xc7, 0x3b,
0x53, 0x39, 0x58, 0x80, 0x02, 0xf9, 0x97, 0xc8, 0x2d, 0x71, 0xcb, 0x80, 0xda,
0x71, 0x4b, 0xdd, 0x0a, 0x90, 0xee, 0x02, 0x2d, 0x76, 0xff, 0xbd, 0xc7, 0x91,
0x6f, 0x59, 0x62, 0x83, 0x75, 0x1f, 0x42, 0xb2, 0x43, 0xd2, 0xfb, 0x30, 0x64,
0x33, 0x56, 0x9f, 0xc5, 0x67, 0xf2, 0xed, 0x08, 0x57, 0x24, 0x06, 0x1f, 0xee,
0x5b, 0x95, 0x98, 0x7d, 0xc6, 0xbf, 0x3c, 0xe1, 0xbb, 0x05, 0x4d, 0xa5, 0x83,
0x35, 0xb0, 0xfb, 0x77, 0xe1, 0xfa, 0x9d, 0x3b, 0x64, 0x4b, 0xc9, 0xe0, 0x75,
0x30, 0x1e, 0xbc, 0x09, 0x5e, 0x66, 0x9f, 0xc8, 0x21, 0xbb, 0xa8, 0x82, 0xbc,
0x6c, 0xe7, 0x0a, 0xf8, 0x5a, 0xa0, 0xea, 0x76, 0xa2, 0xc1, 0x58, 0xf0, 0x3e,
0x58, 0xb1, 0x53, 0xb9, 0x93, 0x0a, 0x46, 0x72, 0x08, 0x99, 0x0e, 0xdb, 0x14,
0x99, 0x70, 0x22, 0xf8, 0x14, 0x76, 0x2a, 0x9e, 0xc3, 0x0f, 0xd9, 0xb8, 0x42,
0x91, 0x0a, 0x1f, 0x2b, 0x12, 0xe1, 0xfb, 0xf0, 0x63, 0xf8, 0x16, 0xd9, 0x5c,
0x39, 0xf4, 0xbe, 0x09, 0x3b, 0x14, 0xc9, 0x6f, 0x16, 0xd8, 0xb4, 0xb7, 0x1f,
0x6d, 0x03, 0x6b, 0x6a, 0x41, 0x16, 0x65, 0xcd, 0x62, 0x6b, 0xd4, 0x10, 0x6d,
0x44, 0x1c, 0x16, 0x35, 0x46, 0x9b, 0xf7, 0x1a, 0xf6, 0x0e, 0xa2, 0x9a, 0xe8,
0x61, 0x54, 0x1b, 0x6d, 0xdf, 0xd3, 0x21, 0x64, 0xd1, 0x47, 0x5b, 0xf7, 0xbe,
0xde, 0x1f, 0xa8, 0xe9, 0x60, 0x67, 0xc4, 0x38, 0x35, 0xce, 0x8e, 0x73, 0xe2,
0x8c, 0x38, 0x33, 0x4e, 0x03, 0x9e, 0x0c, 0x69, 0x4a, 0x3d, 0xae, 0x26, 0xc5,
0x29, 0x59, 0xb4, 0x55, 0xb3, 0x20, 0x2f, 0x41, 0xb6, 0xc7, 0x4c, 0x52, 0x92,
0xc5, 0x88, 0x2a, 0x84, 0x9c, 0x9d, 0x2c, 0xda, 0xa7, 0x27, 0x19, 0x49, 0x6a,
0x92, 0x93, 0x6c, 0xb9, 0x2b, 0xdd, 0xa7, 0x81, 0x2d, 0x72, 0x93, 0xac, 0xdc,
0x9d, 0x62, 0x07, 0xc2, 0xad, 0x56, 0xc8, 0xa9, 0x60, 0x93, 0x9d, 0x77, 0xdd,
0x77, 0x5d, 0x77, 0x6d, 0x77, 0xed, 0x48, 0x4a, 0x02, 0x7b, 0x64, 0x82, 0x65,
0x6e, 0xa7, 0x89, 0xe9, 0xad, 0x34, 0x19, 0x59, 0x2a, 0x01, 0xf2, 0xf5, 0xcc,
0x56, 0x66, 0x2d, 0x33, 0xaf, 0xdb, 0xc8, 0x6c, 0x66, 0xb6, 0x33, 0x0b, 0xba,
0x1f, 0xba, 0x45, 0x5d, 0x08, 0xec, 0xf5, 0x02, 0x52, 0xf8, 0x31, 0xf7, 0x6b,
0x15, 0x74, 0x77, 0x28, 0x79, 0x79, 0x7b, 0xf1, 0x23, 0x1b, 0x5c, 0x30, 0x69,
0x98, 0x24, 0xf3, 0x3e, 0x53, 0xcb, 0x24, 0x02, 0x16, 0xbd, 0x58, 0x9f, 0xad,
0x51, 0x76, 0x8c, 0x7d, 0xcd, 0xbe, 0x62, 0x67, 0xac, 0x4f, 0xd6, 0x47, 0x64,
0x83, 0xd7, 0x0e, 0x1a, 0x2f, 0xe1, 0xb8, 0x71, 0xc4, 0x1d, 0x51, 0x07, 0x95,
0xc7, 0xe4, 0x71, 0xfe, 0x40, 0x62, 0xde, 0x95, 0x23, 0xe6, 0x60, 0xf3, 0x58,
0x3c, 0x06, 0x8f, 0xce, 0xd3, 0x82, 0x6d, 0x68, 0xdc, 0x4a, 0xf7, 0x2e, 0xd8,
0xca, 0x9e, 0x5b, 0x29, 0x54, 0xb9, 0xd5, 0xee, 0x7d, 0x90, 0xed, 0x21, 0x4c,
0x71, 0xc1, 0xde, 0x3b, 0x7d, 0xc7, 0x3e, 0xc7, 0x97, 0x0d, 0x3c, 0x05, 0x1b,
0x60, 0x47, 0x1e, 0x82, 0x8f, 0xb0, 0x87, 0x8d, 0x40, 0x35, 0xed, 0x64, 0xbe,
0x3d, 0x0f, 0xc8, 0xbf, 0x80, 0xd3, 0x26, 0xfc, 0x06, 0x7b, 0x75, 0xa2, 0x70,
0x29, 0xdc, 0x8a, 0x42, 0xe0, 0x0b, 0x2e, 0x3e, 0xc3, 0x3f, 0xc3, 0x1f, 0xe1,
0xf7, 0x70, 0xde, 0xc5, 0x0b, 0xd4, 0x98, 0xa2, 0xb6, 0xa8, 0x25, 0x87, 0xf6,
0xe6, 0x28, 0x1e, 0xb5, 0x02, 0xcd, 0x05, 0x5d, 0x4f, 0xab, 0xcb, 0xf6, 0xf9,
0xa0, 0xc5, 0xf2, 0x7d, 0x5e, 0xb2, 0xf7, 0xae, 0xe7, 0x8e, 0x06, 0xfa, 0xa3,
0xa4, 0x59, 0x07, 0x84, 0x0c, 0xe1, 0xf0, 0x19, 0x56, 0x2f, 0x7b, 0x91, 0xbe,
0xd0, 0x0d, 0x71, 0xf6, 0x0d, 0xfb, 0x00, 0xe6, 0xd7, 0xb2, 0x13, 0xa0, 0x2c,
0xd0, 0xe7, 0xe9, 0x73, 0xb9, 0xe7, 0x4e, 0x64, 0x14, 0x63, 0xe8, 0x98, 0x07,
0xe0, 0xbd, 0xb7, 0xe0, 0x6b, 0x6f, 0xd6, 0x9f, 0xd6, 0x77, 0xd0, 0x42, 0x82,
0x9d, 0x44, 0x9e, 0xf7, 0x6a, 0xfd, 0x00, 0x4e, 0x92, 0xf3, 0x9e, 0x07, 0xc7,
0xa3, 0x23, 0xe3, 0x10, 0xf2, 0x52, 0x08, 0x8b, 0xf9, 0x3c, 0x1e, 0xc8, 0x45,
0x3c, 0x01, 0xe4, 0x62, 0x5e, 0xda, 0x91, 0x74, 0xdc, 0x3a, 0xee, 0x1d, 0x77,
0x7f, 0x79, 0x2f, 0xa1, 0x77, 0x63, 0xee, 0x43, 0xb8, 0xb2, 0xce, 0xad, 0x12,
0x6e, 0x01, 0x9e, 0xba, 0x7d, 0x1e, 0x9f, 0xcf, 0xb7, 0x89, 0x90, 0x75, 0x1d,
0xf2, 0x13, 0xdf, 0x86, 0xc4, 0xeb, 0x5b, 0x43, 0x7c, 0xfe, 0xd9, 0x73, 0xf0,
0x2d, 0xf8, 0x19, 0xec, 0xd8, 0xf9, 0x00, 0xed, 0xbc, 0x07, 0x5f, 0x82, 0xaf,
0xc1, 0xb6, 0x9d, 0xbc, 0xb3, 0x56, 0xd0, 0x58, 0xd7, 0x4e, 0xe7, 0x4e, 0x7b,
0x16, 0x75, 0x73, 0x7a, 0x2b, 0x07, 0x1d, 0x95, 0xa1, 0xff, 0x4c, 0x57, 0x84,
0x72, 0x8f, 0xa2, 0xf4, 0xa2, 0xe4, 0xc2, 0xfb, 0xed, 0xfb, 0xb5, 0x1e, 0xb0,
0x5c, 0x07, 0x68, 0xa9, 0x77, 0xaf, 0x73, 0xaf, 0x1b, 0xe8, 0x8e, 0xbd, 0xae,
0x9c, 0x2d, 0xf3, 0x40, 0x6f, 0x73, 0x6a, 0x41, 0x9c, 0x0f, 0x65, 0xf1, 0xc5,
0x82, 0x7a, 0x5e, 0x3d, 0xa3, 0x9e, 0x55, 0xff, 0xab, 0xa7, 0x04, 0xf4, 0x29,
0x4a, 0x56, 0xec, 0x8b, 0xa1, 0x94, 0x26, 0x85, 0x49, 0x01, 0xb2, 0xd2, 0xbe,
0x3b, 0xa6, 0x96, 0xae, 0x65, 0x7c, 0xfd, 0x1e, 0x8b, 0x9a, 0xa6, 0xa5, 0x39,
0x60, 0x97, 0xec, 0x03, 0x52, 0x86, 0x9c, 0x21, 0xc2, 0x79, 0xfb, 0xf2, 0xf4,
0x8a, 0xec, 0x2d, 0x48, 0x29, 0x33, 0x2e, 0x82, 0x86, 0x29, 0x66, 0x3d, 0xf3,
0x90, 0x49, 0x45, 0x3a, 0xce, 0xb3, 0xa5, 0xd8, 0x9f, 0xd6, 0x3b, 0xa4, 0x55,
0x29, 0xef, 0xc5, 0xf1, 0xe4, 0xf8, 0x70, 0xc8, 0x78, 0xcf, 0x8e, 0x77, 0xc7,
0xab, 0xe3, 0x0d, 0xe9, 0xec, 0xc8, 0x6d, 0x04, 0x3d, 0xa9, 0xc1, 0x82, 0x0c,
0x6e, 0x8d, 0x90, 0x28, 0x21, 0x48, 0xb6, 0x25, 0xa7, 0x5f, 0x16, 0x54, 0x74,
0xd6, 0xbd, 0xd3, 0x03, 0xeb, 0x2f, 0x3c, 0x2b, 0x38, 0xfb, 0xfa, 0x0e, 0xe4,
0xe2, 0x54, 0xe1, 0x53, 0x54, 0x5e, 0x54, 0x81, 0x06, 0xfa, 0xf7, 0xfa, 0x60,
0x75, 0x92, 0xf8, 0x71, 0xd4, 0x15, 0x75, 0x46, 0xc5, 0x71, 0x61, 0x5c, 0x1a,
0x17, 0xc1, 0xfa, 0x16, 0x73, 0xeb, 0x92, 0x25, 0x2b, 0xf7, 0x77, 0x92, 0x72,
0xb4, 0x12, 0x96, 0x96, 0x0d, 0xab, 0x58, 0x42, 0xd1, 0x8a, 0xfd, 0xf0, 0xec,
0xdb, 0x7f, 0xa9, 0xc8, 0xff, 0xed, 0x7f, 0x5a, 0xfd, 0x74, 0xec, 0x7c, 0xc3,
0x4d, 0x85, 0x48, 0x8e, 0xfe, 0x1b, 0x0e, 0x59, 0x12, 0xf0, 0x91, 0x24, 0xfe,
0xaf, 0x99, 0x15, 0xc3, 0x7c, 0xfc, 0x8a, 0xea, 0x8b, 0x80, 0xe2, 0xb7, 0xe7,
0xe6, 0x3a, 0x4a, 0xf6, 0x37, 0x79, 0x54, 0x8c, 0x49, 0x83, 0xf5, 0xa7, 0x61,
0xdd, 0xf7, 0xec, 0x02, 0x5b, 0x21, 0x1a, 0x3f, 0xef, 0xb8, 0xe0, 0x58, 0x0e,
0x23, 0x17, 0x1d, 0x97, 0x1e, 0x17, 0x1f, 0xe7, 0xfe, 0x27, 0xdc, 0x71, 0xe1,
0xf1, 0xa7, 0x43, 0xc1, 0x2b, 0x3b, 0xce, 0x3f, 0xfe, 0xfa, 0x5e, 0xd6, 0xad,
0x17, 0xfa, 0xdd, 0x07, 0xa0, 0x11, 0x97, 0x1b, 0x83, 0x7c, 0x1f, 0x92, 0xcd,
0x1d, 0x70, 0xdb, 0xdd, 0x16, 0xf7, 0x21, 0xd0, 0x5a, 0x48, 0x4e, 0xf7, 0x89,
0x5b, 0x27, 0xf4, 0xb8, 0x8f, 0x84, 0x5e, 0xb7, 0xd5, 0xed, 0x76, 0xfb, 0xdc,
0x0e, 0xb7, 0xd9, 0x6d, 0x42, 0xd8, 0x7d, 0x8a, 0xf2, 0xb3, 0xaf, 0x99, 0x5e,
0xe6, 0xa8, 0x73, 0x5f, 0xd4, 0x47, 0x93, 0xe0, 0xee, 0x90, 0x8f, 0x22, 0x09,
0xfa, 0xd8, 0x92, 0xb0, 0x8f, 0x25, 0xb9, 0xf0, 0x71, 0x24, 0x74, 0x09, 0x57,
0xc2, 0x00, 0x4b, 0x64, 0x42, 0xa2, 0x42, 0x8a, 0xfc, 0x05, 0xc3, 0xfb, 0x77,
0xea, 0x60, 0xad, 0x8d, 0x67, 0xa5, 0x67, 0x55, 0x67, 0x25, 0x67, 0x83, 0xb0,
0x1b, 0x15, 0xb9, 0xbd, 0x28, 0x3b, 0x1b, 0x00, 0xae, 0xf6, 0xac, 0xe6, 0xac,
0xf2, 0xac, 0xfa, 0xac, 0xfc, 0x2c, 0xa4, 0x68, 0x38, 0xeb, 0xdd, 0xa9, 0x3f,
0xfb, 0xfb, 0x09, 0xd2, 0x0d, 0x7b, 0x75, 0xad, 0x68, 0x83, 0xfc, 0x4a, 0x51,
0x03, 0x79, 0xdd, 0xc5, 0xb9, 0xa2, 0xf9, 0xa2, 0xe9, 0xa2, 0xf5, 0x22, 0xa2,
0x68, 0xb8, 0xa8, 0x47, 0xb6, 0x7c, 0xa9, 0x38, 0x53, 0x34, 0x5e, 0x84, 0x15,
0xed, 0x17, 0x9d, 0xc0, 0xb7, 0x5c, 0xd4, 0x5e, 0x5c, 0x20, 0xdd, 0x8e, 0xc3,
0x0d, 0x29, 0x7a, 0xa6, 0x79, 0xf1, 0xfb, 0x98, 0xde, 0xe8, 0x00, 0xec, 0xfd,
0x29, 0xd8, 0xfa, 0x20, 0xb2, 0xf0, 0xe1, 0xbd, 0x20, 0xd0, 0xee, 0x68, 0x54,
0xe1, 0xff, 0x8a, 0x0f, 0x3d, 0x40, 0xf5, 0xed, 0x8c, 0xa1, 0xfa, 0x21, 0xc8,
0x47, 0xf6, 0x46, 0x21, 0x5f, 0x56, 0x07, 0xa2, 0x27, 0xd1, 0x09, 0xa0, 0x7c,
0xdf, 0x22, 0x49, 0x4d, 0x7c, 0x17, 0x45, 0xc6, 0x87, 0xf1, 0x1f, 0xea, 0xbd,
0xf8, 0xaa, 0xfa, 0x20, 0xae, 0x88, 0xcb, 0xe2, 0xfa, 0x78, 0xfd, 0xfe, 0x9a,
0x5a, 0x1b, 0xdf, 0x89, 0xaf, 0xa8, 0x95, 0xf1, 0x0d, 0xb5, 0x3c, 0xae, 0x8a,
0xaf, 0xab, 0xf7, 0xe3, 0xba, 0xaf, 0x28, 0xda, 0x94, 0xc4, 0x93, 0xca, 0xe4,
0x41, 0x72, 0x1f, 0x59, 0x59, 0xed, 0xfe, 0x51, 0x52, 0x0d, 0x75, 0x6a, 0xe0,
0x0c, 0xc9, 0x9a, 0x7d, 0x55, 0x72, 0x2f, 0x89, 0x25, 0x75, 0x49, 0x3d, 0xf0,
0x8a, 0xa4, 0x31, 0x59, 0x05, 0xa7, 0xc2, 0x61, 0xd2, 0x92, 0xd4, 0x26, 0xeb,
0xf6, 0xab, 0xf7, 0x35, 0xc9, 0xdd, 0xa4, 0x39, 0xb9, 0xa4, 0xfe, 0x7d, 0x65,
0x83, 0xe8, 0x04, 0xe8, 0xbf, 0x1b, 0xbd, 0xe3, 0x6b, 0x87, 0xef, 0x86, 0xee,
0x84, 0xda, 0x89, 0x3b, 0x01, 0xd8, 0xee, 0xe4, 0xdd, 0xd8, 0x1d, 0x57, 0x3b,
0x7e, 0x37, 0x70, 0xc7, 0xd3, 0x72, 0xb4, 0xac, 0xf4, 0x08, 0x6a, 0x37, 0x85,
0x72, 0x7a, 0xee, 0xce, 0x55, 0x78, 0xc0, 0x3f, 0x60, 0x02, 0xcd, 0x4e, 0x33,
0xd2, 0x82, 0x03, 0xee, 0x01, 0xef, 0x40, 0x84, 0xee, 0xad, 0x56, 0xc1, 0xee,
0x99, 0x60, 0x9b, 0x8c, 0x0c, 0x2d, 0x43, 0xcd, 0xd0, 0x81, 0x5a, 0xd1, 0xad,
0x21, 0x5f, 0xb8, 0x43, 0x79, 0xe4, 0xf1, 0x12, 0x9d, 0x1e, 0x6f, 0xe0, 0xcb,
0x1f, 0x4f, 0x9f, 0x4f, 0x3f, 0x9f, 0xde, 0x91, 0x57, 0x93, 0x0e, 0x89, 0x28,
0x8a, 0x3f, 0x3e, 0x74, 0x1c, 0x3a, 0x0f, 0x93, 0xcf, 0x89, 0x67, 0xc0, 0xa8,
0x97, 0x9d, 0x97, 0x8f, 0x97, 0x36, 0x3d, 0xdc, 0x7f, 0xeb, 0xa7, 0x51, 0x74,
0xbf, 0xad, 0xc7, 0xb3, 0xbf, 0x27, 0x42, 0x3e, 0x5f, 0x6c, 0x2b, 0xb1, 0x15,
0x21, 0x8b, 0x7f, 0x00, 0xfb, 0x2f, 0xb5, 0x95, 0xd9, 0xca, 0x11, 0x57, 0x7e,
0x5c, 0x8b, 0x6c, 0xbc, 0xfa, 0x78, 0x97, 0x57, 0x09, 0x54, 0xd5, 0x71, 0x4d,
0xce, 0xe6, 0x2b, 0x8e, 0x0d, 0x60, 0xd3, 0x41, 0xb7, 0x49, 0x78, 0xee, 0x36,
0x0a, 0xcf, 0xbe, 0x45, 0x20, 0xd7, 0x3e, 0x1e, 0x58, 0x64, 0xdc, 0x77, 0xe5,
0x0b, 0x81, 0x94, 0x8f, 0xf0, 0x32, 0xf6, 0x9b, 0x7d, 0xb6, 0x80, 0xb5, 0x0d,
0xed, 0x34, 0x9d, 0x0d, 0xef, 0x34, 0x9f, 0x8d, 0xec, 0xe4, 0x9e, 0x6e, 0x28,
0xfa, 0x2f, 0x7a, 0x2e, 0xfa, 0x2e, 0xe2, 0x8a, 0x1b, 0x45, 0xef, 0x37, 0xab,
0x39, 0x43, 0xbb, 0x7d, 0x0e, 0xf9, 0xe4, 0x5e, 0x38, 0x1a, 0x82, 0xb2, 0x1f,
0xee, 0xd9, 0x8d, 0x71, 0x53, 0x1c, 0x83, 0x1d, 0x3b, 0x8a, 0x6f, 0xaa, 0xb7,
0xd4, 0x06, 0xa0, 0x5a, 0xd1, 0xf9, 0xdd, 0xb8, 0xdf, 0xb6, 0xdf, 0xb4, 0xdf,
0xb2, 0xdf, 0x00, 0x5c, 0xf3, 0xff, 0x55, 0xde, 0x97, 0x78, 0x25, 0xee, 0x74,
0x0b, 0xfe, 0x6b, 0xae, 0xed, 0xd2, 0xee, 0xad, 0x6d, 0x77, 0xbb, 0xb6, 0x4b,
0xdb, 0xda, 0xae, 0xed, 0xbe, 0xfe, 0x2f, 0xe0, 0x8e, 0x22, 0x08, 0x82, 0x60,
0x64, 0x09, 0x9b, 0xed, 0x82, 0xa2, 0x51, 0xa3, 0x06, 0x4d, 0x94, 0x68, 0x22,
0x81, 0x40, 0x08, 0xab, 0xad, 0xfe, 0xe6, 0x92, 0x8f, 0xe7, 0xeb, 0xdf, 0xf7,
0xbd, 0x79, 0x73, 0xce, 0x9c, 0x33, 0xef, 0xcd, 0x9c, 0xe1, 0x9c, 0x5b, 0x75,
0xeb, 0x56, 0x51, 0x54, 0xdd, 0x3d, 0x0b, 0x09, 0xfa, 0x76, 0x07, 0x8b, 0xed,
0x28, 0x1d, 0xc3, 0x81, 0xc3, 0x4a, 0x80, 0x95, 0xe8, 0x84, 0x63, 0xd2, 0x91,
0x9d, 0x78, 0x00, 0xde, 0x65, 0x01, 0x67, 0x5e, 0x92, 0x73, 0x29, 0xb7, 0x74,
0x17, 0xc4, 0x10, 0x78, 0xc2, 0x65, 0xf7, 0x2f, 0x45, 0x7c, 0xb5, 0xc4, 0x13,
0x5d, 0x2d, 0xf6, 0xa4, 0x56, 0x63, 0xab, 0x4f, 0xab, 0xc9, 0xd5, 0xf7, 0x9e,
0xc4, 0xaa, 0x45, 0x65, 0x56, 0x7d, 0xc1, 0x76, 0x54, 0x1f, 0xb0, 0xcf, 0x98,
0x5d, 0x55, 0x85, 0x7d, 0xc2, 0x3e, 0x62, 0x36, 0x95, 0x43, 0x55, 0x83, 0x99,
0x54, 0xd5, 0xd8, 0x2f, 0x95, 0x53, 0xb5, 0xab, 0x72, 0xa9, 0x2a, 0xb1, 0x0a,
0xac, 0x16, 0xb3, 0xaa, 0xb6, 0x55, 0xe8, 0x1f, 0xfe, 0x28, 0x7c, 0xfe, 0x08,
0x9c, 0xd0, 0xe9, 0x58, 0x28, 0x8f, 0x34, 0xe7, 0x1a, 0x4c, 0x73, 0xa9, 0xb9,
0xd0, 0x9c, 0x02, 0xff, 0xee, 0xce, 0xef, 0x81, 0x46, 0x9f, 0x7b, 0x34, 0x0f,
0xe7, 0xa1, 0xf3, 0x63, 0x8d, 0xef, 0x3c, 0x70, 0x1e, 0x3c, 0x3f, 0xd1, 0xf8,
0xcf, 0x71, 0x8d, 0x5b, 0x73, 0xa6, 0x61, 0xce, 0x0f, 0x34, 0x9c, 0xc4, 0x5b,
0x3e, 0xc3, 0xe1, 0xdf, 0x57, 0x91, 0x2b, 0x8d, 0x2e, 0x75, 0x15, 0xbf, 0xe2,
0xaf, 0x12, 0x57, 0x1b, 0xba, 0x10, 0x70, 0x96, 0x93, 0xb8, 0xdb, 0x6d, 0x88,
0x42, 0xbd, 0xae, 0x7b, 0x82, 0xd2, 0xa0, 0xdb, 0xd2, 0x05, 0x25, 0xaa, 0x51,
0x17, 0xbe, 0xd2, 0xea, 0x92, 0x57, 0xc2, 0x55, 0x0c, 0xda, 0xe2, 0x95, 0x5e,
0x17, 0xb8, 0x42, 0x74, 0x87, 0x9a, 0x4d, 0xdd, 0xb6, 0xee, 0x8f, 0xa7, 0x26,
0x18, 0x1a, 0xc8, 0x26, 0xf2, 0x2b, 0xd9, 0x0e, 0x92, 0xa9, 0x23, 0x3f, 0x93,
0x5d, 0x20, 0x95, 0x66, 0xb2, 0x8d, 0xac, 0x27, 0x3f, 0x01, 0xa5, 0x36, 0xe3,
0x1d, 0x5a, 0xc8, 0x2f, 0x64, 0x23, 0xf9, 0x03, 0xfa, 0x3a, 0x0d, 0xdf, 0xc8,
0x0e, 0x43, 0x2b, 0xd0, 0x7f, 0xfe, 0x21, 0x2b, 0x7e, 0xab, 0xcb, 0x37, 0x66,
0x1a, 0xf2, 0x09, 0x5b, 0x63, 0xbe, 0xc4, 0x56, 0xbb, 0xd4, 0x33, 0xec, 0x6b,
0x81, 0x7a, 0xd4, 0xf7, 0x0d, 0xca, 0xd7, 0xad, 0xdf, 0x5b, 0x23, 0xbe, 0x7e,
0x5f, 0x70, 0x2b, 0xb6, 0x15, 0x05, 0xff, 0x20, 0x6e, 0xa5, 0xa0, 0x6c, 0xf5,
0x3d, 0x6d, 0x0d, 0xf8, 0xe2, 0x5b, 0x81, 0xad, 0x41, 0x5f, 0x68, 0x2b, 0xbc,
0x95, 0xdc, 0xfa, 0xee, 0xeb, 0xf0, 0xb5, 0xc1, 0xf8, 0x6e, 0x5f, 0xa7, 0xaf,
0xc7, 0xf7, 0x02, 0x63, 0xc6, 0x7d, 0x91, 0xad, 0x5e, 0x5f, 0x1f, 0xd0, 0x7e,
0x64, 0x7e, 0xef, 0xf9, 0xcd, 0x87, 0x33, 0x0f, 0xfd, 0xa6, 0x71, 0xd3, 0xb0,
0x89, 0x06, 0xdd, 0xf8, 0x69, 0x1a, 0x31, 0x85, 0x1f, 0xba, 0x4d, 0x6c, 0xfa,
0xcc, 0xb3, 0xe4, 0x41, 0xb8, 0x87, 0x87, 0x87, 0x41, 0xd3, 0xa8, 0xe9, 0x3e,
0x7d, 0xbd, 0x01, 0x28, 0xa1, 0x87, 0x5e, 0x13, 0xff, 0x10, 0x7c, 0x98, 0x30,
0xfd, 0xbc, 0xef, 0x81, 0x76, 0xe0, 0xc1, 0x07, 0x3d, 0x93, 0x26, 0xff, 0x43,
0x9f, 0xe9, 0xf1, 0xcd, 0xb3, 0xc8, 0x2d, 0x8b, 0x96, 0x19, 0xcb, 0x85, 0xff,
0xc8, 0x4f, 0xf8, 0x31, 0xff, 0xa5, 0x7f, 0xc9, 0x22, 0xb3, 0x1c, 0xf8, 0x4f,
0xfc, 0x5e, 0xff, 0x99, 0xff, 0xca, 0x7f, 0x28, 0xf9, 0x91, 0x73, 0xff, 0xac,
0xe5, 0xd4, 0xbf, 0x60, 0x99, 0xb7, 0x78, 0xfc, 0xc7, 0x7e, 0xb7, 0x1f, 0xf7,
0xcf, 0x59, 0x6e, 0xfc, 0xd7, 0x19, 0x1f, 0x73, 0x15, 0x3c, 0x0f, 0x36, 0x81,
0x06, 0x7a, 0x82, 0x9f, 0xd1, 0x4e, 0xd4, 0x1b, 0xfc, 0x8a, 0x36, 0xa0, 0x58,
0xb0, 0x0d, 0xed, 0x40, 0x6f, 0x82, 0xf5, 0xe8, 0x59, 0xb0, 0x1d, 0xa5, 0x82,
0xd7, 0xc1, 0xe3, 0x60, 0x33, 0xfa, 0x05, 0xfd, 0x8e, 0x5e, 0x04, 0x5b, 0xd1,
0x93, 0x60, 0x23, 0x4a, 0x06, 0x5b, 0xd0, 0x3a, 0xf4, 0x32, 0xf8, 0x0d, 0xc5,
0x25, 0xcf, 0x44, 0x64, 0xb2, 0xce, 0xde, 0xf0, 0x50, 0xd8, 0x68, 0x1b, 0x0d,
0x6f, 0xd8, 0x74, 0xb6, 0xbe, 0xf0, 0x48, 0x78, 0x20, 0xbc, 0x65, 0xdb, 0x04,
0xef, 0xd2, 0x03, 0x7e, 0x44, 0x6f, 0x1b, 0x0c, 0x0f, 0x87, 0x0d, 0xb6, 0x9f,
0xe1, 0xfe, 0xf0, 0xbf, 0xad, 0xdf, 0x10, 0xd9, 0xb4, 0x1b, 0xec, 0x1b, 0xe0,
0x45, 0x74, 0x00, 0x1b, 0x11, 0x0d, 0xe8, 0xbd, 0x3e, 0xb2, 0x65, 0xdf, 0x8c,
0xa8, 0x23, 0xaa, 0x88, 0x36, 0xb2, 0x1e, 0xd1, 0xdb, 0x75, 0x91, 0xd5, 0xe8,
0x8c, 0x63, 0xda, 0xa1, 0x04, 0xbf, 0xa2, 0x8a, 0xae, 0x45, 0x65, 0x99, 0x73,
0x02, 0x5c, 0x8c, 0x8d, 0x3d, 0x82, 0x6d, 0x30, 0x31, 0x7f, 0x2c, 0xe2, 0x08,
0x00, 0x26, 0x40, 0x4f, 0x0e, 0x58, 0xca, 0x99, 0x13, 0x77, 0xf2, 0x89, 0x73,
0xa7, 0x31, 0x99, 0x95, 0xca, 0x49, 0xbd, 0x26, 0xb3, 0x53, 0xdd, 0xae, 0x43,
0xb0, 0x9c, 0xdf, 0xab, 0x7d, 0x27, 0x7b, 0x92, 0xbe, 0x5f, 0x69, 0x9e, 0xaf,
0x5e, 0x32, 0xb6, 0x4e, 0xfa, 0xbb, 0xd0, 0x5b, 0x69, 0xfd, 0x08, 0xac, 0x74,
0x2b, 0x62, 0x8c, 0xc8, 0x1d, 0x41, 0x98, 0x2d, 0x37, 0x91, 0x74, 0x16, 0x49,
0x67, 0x8b, 0x77, 0x15, 0xc3, 0x52, 0x76, 0x57, 0x2a, 0xf9, 0x9a, 0x66, 0xac,
0x0e, 0x6b, 0xc2, 0x1a, 0xb0, 0x7d, 0x55, 0x23, 0x56, 0x0f, 0x5e, 0x46, 0x00,
0x8d, 0x7f, 0xbd, 0xca, 0x22, 0x3a, 0xc9, 0x2e, 0xb2, 0xd7, 0xd0, 0x67, 0xf8,
0x4e, 0xfe, 0x20, 0x3b, 0xc8, 0x1e, 0xd0, 0xbe, 0x2c, 0x04, 0xb2, 0x22, 0xc3,
0x04, 0x68, 0xc2, 0x94, 0x49, 0x78, 0x98, 0x06, 0x29, 0x2e, 0x5b, 0xee, 0xfc,
0x94, 0xff, 0xd6, 0x4f, 0x07, 0x7d, 0xc1, 0xbb, 0x0c, 0xcf, 0x10, 0xd8, 0xb3,
0xd1, 0xbe, 0x1d, 0xc9, 0x4b, 0xa4, 0x9c, 0x5b, 0xc9, 0xa3, 0x85, 0x7d, 0xc5,
0x9e, 0xa2, 0xdc, 0xf3, 0x2c, 0xe5, 0x35, 0x65, 0x9e, 0x16, 0xf8, 0x85, 0x03,
0x55, 0xe4, 0xfc, 0x6b, 0xc6, 0x9f, 0x79, 0x35, 0xb1, 0x73, 0xf1, 0x3c, 0x7a,
0x4e, 0x80, 0x55, 0xe6, 0x10, 0xb9, 0x44, 0x36, 0x01, 0x19, 0x89, 0xa1, 0x87,
0xec, 0x26, 0x7b, 0xc9, 0x9f, 0x86, 0x01, 0xc9, 0x4b, 0x45, 0x1e, 0xa2, 0xa0,
0x21, 0x33, 0x26, 0xf1, 0xc1, 0xe7, 0x57, 0x58, 0xc6, 0x81, 0xdb, 0x63, 0x61,
0xc4, 0x6e, 0x8a, 0x98, 0xec, 0xdb, 0x76, 0x75, 0x94, 0x8f, 0x89, 0x0e, 0xcf,
0x42, 0x85, 0xe7, 0x65, 0xb5, 0x1d, 0x3b, 0x54, 0xb5, 0x61, 0xad, 0x30, 0xb3,
0x1b, 0xb8, 0xf2, 0x3b, 0x7d, 0x57, 0xca, 0x79, 0xfc, 0x3c, 0x71, 0x7e, 0xad,
0x49, 0x9e, 0xdf, 0x68, 0x9e, 0xcf, 0x53, 0xe7, 0x4f, 0xe7, 0x24, 0xfc, 0x8e,
0x59, 0x67, 0x01, 0x1b, 0xcc, 0x23, 0x32, 0xf7, 0x1e, 0x92, 0xfd, 0x60, 0x4f,
0x33, 0xbe, 0x5c, 0x24, 0x1b, 0xc9, 0x41, 0x26, 0x7d, 0x53, 0xb0, 0xbf, 0x69,
0x5f, 0x0a, 0x7e, 0xf1, 0xe9, 0x41, 0x66, 0x4a, 0x3c, 0xc4, 0x1f, 0x92, 0x0f,
0xb1, 0x07, 0xa5, 0x85, 0xf6, 0xaf, 0x58, 0x56, 0x2d, 0x0f, 0xc1, 0x1f, 0xe8,
0x7d, 0x70, 0x29, 0x04, 0xb9, 0x69, 0x78, 0x32, 0xbc, 0x0d, 0x1c, 0x36, 0xd9,
0xba, 0x51, 0x73, 0xc4, 0x12, 0x59, 0x8f, 0xce, 0x3a, 0x8e, 0x41, 0x2a, 0x27,
0x0b, 0xaf, 0xab, 0x07, 0x8a, 0x23, 0x55, 0x65, 0x26, 0x53, 0xb2, 0xea, 0xb0,
0x85, 0x6c, 0x65, 0x95, 0xe7, 0x83, 0x27, 0x4b, 0x99, 0xa3, 0x3c, 0x85, 0x11,
0xd5, 0x9e, 0x63, 0xd5, 0x37, 0x0c, 0x53, 0x79, 0x54, 0x27, 0xb0, 0xce, 0x6c,
0x9c, 0x82, 0x35, 0x65, 0xe1, 0xaf, 0xb0, 0xde, 0x01, 0xc9, 0xe2, 0x65, 0xb0,
0x02, 0x39, 0x70, 0x77, 0xcd, 0xf2, 0xe0, 0xbf, 0x07, 0xbd, 0x66, 0x32, 0x9c,
0x0d, 0x49, 0x51, 0xe7, 0x6c, 0x61, 0x70, 0x5f, 0xe1, 0xce, 0x55, 0xd6, 0xa4,
0x9f, 0x6e, 0x9d, 0xe1, 0xe2, 0xa9, 0xaa, 0x03, 0x3b, 0xcb, 0x78, 0xbe, 0x5c,
0x5c, 0xba, 0x9b, 0x4f, 0x93, 0x83, 0xe7, 0x01, 0x76, 0xfb, 0x76, 0x0e, 0xe3,
0x1d, 0x51, 0x40, 0xe4, 0x13, 0x68, 0xc6, 0xfb, 0x0c, 0x01, 0x67, 0x87, 0x01,
0xf2, 0x41, 0xa6, 0xb3, 0x3e, 0xb9, 0x2f, 0x0f, 0xf9, 0xe3, 0xc9, 0xb9, 0x92,
0x3d, 0x3e, 0xbf, 0x59, 0x25, 0x23, 0xd9, 0x56, 0x3f, 0xda, 0x87, 0xf6, 0xa0,
0xbd, 0xe8, 0x00, 0x58, 0xd7, 0x54, 0xd8, 0x62, 0x33, 0xdb, 0xac, 0x11, 0x4d,
0xe6, 0x8a, 0xdb, 0xbc, 0x73, 0xce, 0x79, 0x2e, 0xf9, 0xf2, 0xdf, 0xe9, 0xa7,
0x3e, 0x18, 0x6c, 0xba, 0x11, 0xc3, 0x3b, 0x98, 0x11, 0x5f, 0x58, 0xde, 0xbd,
0x58, 0xb8, 0x94, 0x7a, 0x56, 0xdc, 0x23, 0xfb, 0xd0, 0xb7, 0x3f, 0x0a, 0xba,
0x37, 0xb4, 0x3f, 0x02, 0xe5, 0xf8, 0xd2, 0xf0, 0xfe, 0xe4, 0xd2, 0xc4, 0xd2,
0xd8, 0xfe, 0x58, 0xe6, 0x68, 0xe3, 0x58, 0x71, 0xa4, 0x50, 0x42, 0x64, 0x3c,
0xcc, 0x9c, 0xb7, 0xc4, 0x14, 0x67, 0x8a, 0x93, 0xf4, 0x15, 0x26, 0xf7, 0xaa,
0xfb, 0x1c, 0x6a, 0x8f, 0x62, 0x0a, 0x46, 0x9e, 0x2a, 0x54, 0x52, 0xf4, 0x5c,
0x83, 0xd2, 0xad, 0xf8, 0xa7, 0xff, 0x21, 0x78, 0x0a, 0x94, 0x85, 0xca, 0x06,
0xe0, 0x4d, 0xad, 0xe7, 0x8b, 0xa7, 0xd5, 0xf3, 0x15, 0xb0, 0x22, 0x65, 0x87,
0xa7, 0x44, 0xd9, 0xe6, 0xa9, 0xf7, 0x7c, 0xfe, 0x47, 0x74, 0x25, 0x5a, 0x3c,
0x79, 0xca, 0x76, 0xcf, 0x47, 0x4f, 0x93, 0xe7, 0x9d, 0xf2, 0xbd, 0xb2, 0xd9,
0x53, 0xae, 0x2c, 0x55, 0xfe, 0xf5, 0xd7, 0x27, 0x4f, 0x31, 0x94, 0x8d, 0x9e,
0x32, 0x65, 0xbe, 0xf2, 0xdb, 0xdf, 0xf2, 0xdc, 0x2b, 0xe0, 0xad, 0x4f, 0x75,
0xa1, 0x3a, 0x57, 0x75, 0x61, 0x37, 0x2a, 0x42, 0xd5, 0x2d, 0xf1, 0xfd, 0x5a,
0xf5, 0x03, 0xeb, 0xc4, 0x7a, 0xb1, 0x3b, 0x15, 0xa5, 0x2a, 0x24, 0xfa, 0xb0,
0x1e, 0x0c, 0x97, 0x64, 0x70, 0xa9, 0xf2, 0x42, 0x4d, 0x02, 0xdc, 0xfe, 0x87,
0x67, 0x15, 0xca, 0x70, 0x1a, 0xa4, 0x92, 0x8f, 0x17, 0x80, 0x7c, 0x0a, 0x01,
0x2a, 0xf0, 0x12, 0xbc, 0x18, 0xea, 0x52, 0xbc, 0x12, 0xbf, 0xd7, 0x3c, 0x6a,
0xde, 0x01, 0x5e, 0x0e, 0xc0, 0xc0, 0xa8, 0x07, 0xcd, 0x7b, 0xbc, 0x08, 0x70,
0x9f, 0x86, 0xfd, 0x97, 0x6b, 0x1d, 0xbf, 0x74, 0x95, 0x92, 0x0e, 0x97, 0x13,
0x7b, 0x6f, 0x31, 0xa5, 0x98, 0x90, 0x81, 0x0e, 0xed, 0xea, 0xca, 0xa4, 0x9e,
0xf7, 0x84, 0x53, 0xb7, 0xaf, 0xab, 0x20, 0x76, 0x74, 0xa5, 0x44, 0x01, 0xe2,
0xd2, 0x95, 0x10, 0x07, 0x3a, 0x87, 0xce, 0xfe, 0x47, 0x04, 0x1a, 0x25, 0x87,
0x61, 0xfc, 0x24, 0xc0, 0x20, 0x29, 0x27, 0xc7, 0xd2, 0x91, 0x85, 0x9c, 0x34,
0xcc, 0x1a, 0xa6, 0x01, 0x1b, 0x49, 0xdb, 0x85, 0x64, 0x81, 0x53, 0x86, 0x19,
0x72, 0xdc, 0x30, 0x66, 0x18, 0x27, 0xa7, 0x0d, 0x6e, 0xf8, 0xf6, 0x14, 0x39,
0x44, 0x4e, 0x18, 0x64, 0x06, 0xb9, 0xe1, 0xed, 0x6e, 0x37, 0xa4, 0x10, 0xe4,
0x5d, 0x8a, 0x2c, 0x48, 0x71, 0x62, 0xde, 0xb7, 0xe8, 0x2b, 0x46, 0xe6, 0x7c,
0xef, 0x11, 0x85, 0x6f, 0xd9, 0xb7, 0x04, 0xb4, 0xa2, 0x3f, 0xf4, 0x2b, 0x9b,
0x01, 0xeb, 0x63, 0x96, 0x4c, 0xb9, 0xcc, 0xa2, 0x69, 0xd6, 0x34, 0x67, 0x9a,
0x37, 0x65, 0x31, 0xaf, 0x0f, 0x0b, 0xa0, 0xf1, 0x39, 0xcc, 0x8b, 0xa4, 0x75,
0x8f, 0x7e, 0xd1, 0xbf, 0x6e, 0x51, 0x43, 0xae, 0x17, 0xf4, 0x87, 0x40, 0xfb,
0xfc, 0x00, 0xbc, 0x9f, 0xf5, 0x0b, 0x7e, 0x95, 0x25, 0xec, 0x0f, 0x40, 0x2b,
0x02, 0xc0, 0xf9, 0x87, 0x50, 0x36, 0xc8, 0x07, 0xc7, 0xd0, 0x09, 0x74, 0x14,
0x1d, 0x01, 0xbd, 0x1c, 0x46, 0x07, 0xd1, 0xc7, 0x60, 0x20, 0xf8, 0x13, 0x0d,
0xa6, 0xaf, 0xa6, 0xa1, 0x5c, 0xfa, 0xae, 0xd0, 0xa0, 0x15, 0xac, 0x14, 0xb5,
0xc9, 0xc2, 0xd3, 0xe1, 0x19, 0xc9, 0x53, 0xdb, 0xc0, 0x43, 0xa1, 0x11, 0xb3,
0x7d, 0x23, 0x3a, 0xe7, 0xd0, 0x82, 0x06, 0x87, 0x63, 0xf9, 0x89, 0x05, 0x67,
0x6e, 0x2a, 0x2f, 0x75, 0xe1, 0xbc, 0x02, 0x5d, 0xc5, 0x15, 0x55, 0x44, 0x19,
0x32, 0x89, 0x86, 0x82, 0x04, 0xb4, 0xee, 0x55, 0xb4, 0xea, 0x43, 0xc6, 0x57,
0x44, 0xfd, 0xde, 0x85, 0x0a, 0xe9, 0x09, 0xbf, 0xd5, 0x44, 0x0d, 0xf1, 0x91,
0x28, 0x47, 0x34, 0x96, 0x6b, 0x18, 0x73, 0xa1, 0xf8, 0xee, 0x79, 0x50, 0xf5,
0x63, 0x7e, 0x90, 0x51, 0x2d, 0x31, 0x97, 0x3e, 0x33, 0x83, 0x68, 0x2d, 0x53,
0xa8, 0xcd, 0xa6, 0x8b, 0xde, 0x2c, 0x5c, 0x4a, 0x3a, 0xca, 0xa8, 0xaa, 0xf0,
0x43, 0xe0, 0x5d, 0x25, 0xb2, 0xe2, 0xcb, 0x67, 0xde, 0xf2, 0xac, 0x85, 0x23,
0xdd, 0x2c, 0x59, 0x85, 0x50, 0x0b, 0xeb, 0xee, 0x4e, 0x4f, 0xa5, 0x34, 0xf7,
0x4f, 0x49, 0xbb, 0xfc, 0xa0, 0x3b, 0xac, 0xea, 0x51, 0xc5, 0x49, 0x3a, 0x34,
0x20, 0xd1, 0x6a, 0xf1, 0x6a, 0xfc, 0x23, 0xce, 0x69, 0x82, 0x9a, 0x80, 0xe6,
0x03, 0xce, 0x6b, 0x6a, 0x40, 0x33, 0x3e, 0x11, 0x9f, 0x61, 0x75, 0x5f, 0x88,
0x05, 0x90, 0xd6, 0x22, 0xc0, 0x3c, 0xb9, 0x94, 0x2e, 0x61, 0x0d, 0x73, 0xe9,
0x63, 0x11, 0x89, 0xef, 0xc5, 0xcc, 0x3b, 0xa6, 0x88, 0x79, 0xcf, 0x14, 0x32,
0x05, 0xf0, 0xcb, 0x31, 0x7f, 0xdc, 0x9f, 0xf0, 0x6f, 0x58, 0x74, 0x16, 0x21,
0x18, 0x0e, 0x46, 0x80, 0x47, 0xb3, 0x61, 0x39, 0x70, 0xc6, 0x01, 0x7c, 0x71,
0x46, 0xec, 0x50, 0xce, 0x43, 0xe4, 0xd1, 0x47, 0x37, 0x81, 0x37, 0xef, 0x12,
0xa1, 0x04, 0x92, 0xbc, 0x5d, 0x98, 0x06, 0xbb, 0x9b, 0x46, 0xef, 0x60, 0xaf,
0x9f, 0xf0, 0x3a, 0xf8, 0xbd, 0x6c, 0x57, 0x71, 0xe6, 0xca, 0xe3, 0xfb, 0xbd,
0xd2, 0x3d, 0xdf, 0x42, 0xd9, 0x5e, 0x89, 0xd4, 0x96, 0xef, 0xcf, 0xee, 0x4f,
0xbe, 0x5d, 0x81, 0x94, 0xed, 0xcb, 0xe0, 0x7b, 0xf2, 0xa5, 0xa9, 0xfd, 0x89,
0xfd, 0xf1, 0xfd, 0xe9, 0xfd, 0x99, 0xa5, 0x99, 0xfd, 0xae, 0x8c, 0x65, 0xe9,
0xdd, 0x5e, 0x85, 0xce, 0xbd, 0x09, 0x36, 0x4c, 0x28, 0xb6, 0xdd, 0xa4, 0x42,
0xe3, 0xb6, 0xba, 0x5d, 0xee, 0x07, 0x85, 0xdd, 0xed, 0x03, 0x7e, 0x19, 0xdd,
0x16, 0x37, 0x0a, 0x7d, 0x1b, 0xee, 0x3b, 0xc5, 0xb5, 0x62, 0xcb, 0x4d, 0x2b,
0x18, 0xc5, 0x2d, 0xd0, 0xaf, 0x14, 0x66, 0xb7, 0xc1, 0xed, 0x74, 0x3f, 0x2a,
0xee, 0x15, 0x94, 0xc2, 0xe4, 0x0e, 0xa8, 0x10, 0xf7, 0x8d, 0x82, 0x85, 0x1e,
0x2d, 0x8c, 0xb6, 0xb9, 0x1d, 0xff, 0xc9, 0xfd, 0xad, 0x2d, 0xca, 0x7a, 0x65,
0x9b, 0xf2, 0xab, 0x72, 0xc0, 0x33, 0xe4, 0x69, 0x00, 0x4e, 0xff, 0x80, 0x95,
0x7c, 0x54, 0x36, 0x03, 0xd6, 0xaa, 0x6c, 0x57, 0xca, 0x3d, 0xa3, 0xd0, 0xae,
0x51, 0xca, 0x3c, 0x9f, 0x95, 0xb5, 0xca, 0x2a, 0x65, 0x1f, 0xb4, 0x66, 0x3c,
0x83, 0x9e, 0x11, 0xcf, 0x3c, 0x60, 0xdf, 0x94, 0xd3, 0x9e, 0x46, 0xe5, 0x98,
0x67, 0xce, 0x33, 0xec, 0x19, 0xf7, 0x4c, 0x49, 0x7b, 0xe8, 0xf1, 0xcc, 0x7a,
0x26, 0x25, 0xac, 0xdb, 0xd3, 0xef, 0x69, 0x52, 0x7e, 0x51, 0x7e, 0x50, 0x7e,
0x52, 0x56, 0x2b, 0x3b, 0x94, 0xbd, 0x9e, 0x79, 0xac, 0x4e, 0x92, 0xe5, 0x84,
0x27, 0xfb, 0x5f, 0x9e, 0xba, 0xb1, 0x84, 0x3d, 0x81, 0x4c, 0x47, 0x40, 0xa2,
0xb3, 0xd8, 0x34, 0x94, 0x1a, 0x00, 0x05, 0xc0, 0x0c, 0xc0, 0x32, 0x36, 0x86,
0x4d, 0x61, 0x3a, 0xec, 0x45, 0xa5, 0xc4, 0xe6, 0xb0, 0xa0, 0x4a, 0x8b, 0x0d,
0x01, 0x75, 0x15, 0xe0, 0x59, 0x95, 0x50, 0x0d, 0x62, 0x31, 0x55, 0x54, 0x95,
0x52, 0xad, 0x60, 0x82, 0x2a, 0xa9, 0xfa, 0xe9, 0xa9, 0x27, 0x16, 0x24, 0xbd,
0x98, 0xc0, 0x7e, 0xab, 0x26, 0x31, 0x19, 0xf6, 0xaa, 0x1a, 0xc6, 0x54, 0x40,
0x59, 0xc3, 0xf4, 0x98, 0xa8, 0x0a, 0xab, 0x36, 0x30, 0x35, 0xb6, 0x88, 0xc9,
0xb1, 0xb8, 0x2a, 0xa2, 0x1a, 0xc5, 0x78, 0xd5, 0x3a, 0x16, 0x82, 0x5f, 0x1e,
0xc7, 0xfe, 0xfa, 0xdf, 0xfc, 0x34, 0xe2, 0xcd, 0x78, 0x3b, 0x3e, 0x8e, 0x3f,
0x6b, 0x22, 0xa0, 0xe9, 0x0d, 0xf8, 0x8b, 0xe6, 0x55, 0xf3, 0x1d, 0xef, 0xc3,
0x87, 0x41, 0x0f, 0x5b, 0x00, 0x3a, 0xa5, 0xd8, 0x93, 0xa5, 0x1d, 0xc5, 0x7f,
0xe2, 0x4f, 0x9a, 0xa4, 0xa6, 0x17, 0xef, 0xc2, 0xeb, 0xf1, 0x90, 0xe6, 0x2b,
0xfe, 0x19, 0x7a, 0x12, 0x9a, 0x94, 0xe6, 0x1b, 0xde, 0x8a, 0x47, 0x35, 0x83,
0xb8, 0xa0, 0x69, 0xc3, 0x27, 0xf0, 0x6e, 0xa0, 0xfe, 0xc0, 0xc3, 0x30, 0xd7,
0x6f, 0x00, 0x51, 0xf3, 0x05, 0x6f, 0xc2, 0xfb, 0xf1, 0x11, 0x3c, 0x5b, 0x5b,
0x87, 0x77, 0xe0, 0x3d, 0x78, 0x5c, 0xf2, 0x79, 0x63, 0xf8, 0x00, 0x3e, 0x84,
0xff, 0xcf, 0xd6, 0x14, 0x83, 0x31, 0xdd, 0x44, 0x33, 0x81, 0xeb, 0xa6, 0x89,
0x45, 0x42, 0x41, 0x9c, 0xe9, 0xbe, 0x13, 0xb3, 0x44, 0x27, 0x31, 0x4a, 0xdc,
0xe9, 0x06, 0x09, 0x12, 0x2c, 0x6e, 0x88, 0x68, 0x00, 0x8d, 0x9d, 0x93, 0x6c,
0x98, 0xd5, 0xc9, 0x88, 0x61, 0x62, 0x95, 0xe8, 0x27, 0x7e, 0x81, 0x75, 0xa8,
0x88, 0x07, 0x5d, 0x2f, 0x31, 0x41, 0x3c, 0xea, 0x4e, 0x75, 0x3f, 0x09, 0x25,
0xf1, 0x83, 0x68, 0x23, 0xfa, 0x60, 0x5c, 0x2b, 0xf1, 0x95, 0xf0, 0xe8, 0xe6,
0x89, 0x2e, 0x62, 0x09, 0x5a, 0xcb, 0xc4, 0x85, 0xee, 0x5a, 0x77, 0xa9, 0xbb,
0xd5, 0xcd, 0x10, 0x57, 0xba, 0x11, 0xe2, 0x1b, 0xd0, 0x4e, 0x74, 0x8d, 0x84,
0x9c, 0x58, 0x21, 0xda, 0x09, 0x4a, 0xa7, 0x26, 0x06, 0x88, 0x1e, 0xa0, 0x1d,
0xeb, 0xee, 0xd3, 0xbe, 0x91, 0x60, 0xa0, 0x1c, 0x23, 0xbc, 0xba, 0x73, 0xdd,
0x8d, 0x0e, 0xd3, 0xd1, 0xba, 0x71, 0xa2, 0x83, 0x98, 0x24, 0x5a, 0x88, 0x05,
0xe2, 0xef, 0x2b, 0x5f, 0xfb, 0xa7, 0x76, 0xd3, 0x1f, 0xed, 0x1d, 0x58, 0xdd,
0x35, 0x59, 0x63, 0x38, 0x80, 0x7a, 0x8f, 0xd4, 0x91, 0xcb, 0x06, 0x27, 0x79,
0x49, 0xa2, 0xe4, 0xba, 0xe1, 0x82, 0xb4, 0x90, 0x3e, 0xdd, 0x11, 0x69, 0x25,
0xcf, 0x49, 0xb5, 0x61, 0x09, 0xec, 0x5c, 0x41, 0x6a, 0x60, 0xd4, 0x3e, 0x69,
0x27, 0xbd, 0xa4, 0x8b, 0xd4, 0x1b, 0x70, 0x68, 0x29, 0x81, 0xbe, 0x4b, 0x1e,
0x93, 0x7a, 0xd2, 0x03, 0xad, 0x5b, 0x72, 0x9d, 0x3c, 0x81, 0x9a, 0x04, 0x58,
0x21, 0x09, 0x58, 0x9f, 0x91, 0x34, 0x90, 0x2a, 0x18, 0xb3, 0x4d, 0x9a, 0x49,
0x37, 0x79, 0x43, 0x6a, 0x00, 0xd7, 0x02, 0xa8, 0xc9, 0x15, 0xc3, 0x06, 0x79,
0x45, 0x6e, 0x00, 0xbe, 0x6a, 0x58, 0x33, 0xe8, 0x0c, 0x14, 0x89, 0x91, 0x87,
0x52, 0x5e, 0x82, 0x90, 0x5b, 0xa4, 0xc2, 0xb0, 0x4a, 0x2e, 0x1a, 0x1c, 0xa4,
0x92, 0xb4, 0x49, 0xb4, 0x4d, 0x92, 0xc8, 0x1c, 0xa5, 0x2c, 0x64, 0x62, 0x81,
0xf6, 0x6f, 0xe7, 0x34, 0x54, 0xe4, 0x19, 0xb9, 0x46, 0x36, 0x23, 0x98, 0x14,
0x17, 0x6c, 0x52, 0xb9, 0xea, 0xdb, 0xf3, 0x7d, 0x42, 0x10, 0x9f, 0xd3, 0x57,
0x87, 0x98, 0x7d, 0x9f, 0x11, 0x95, 0xcf, 0xed, 0x5b, 0xf3, 0xa1, 0xd0, 0xa7,
0x94, 0xfa, 0x2d, 0xbe, 0x5f, 0x3e, 0x97, 0x6f, 0xcb, 0xa7, 0xf3, 0x69, 0xa1,
0xbd, 0xe1, 0xdb, 0xf1, 0x9d, 0xf8, 0xb6, 0x7d, 0x5f, 0xc0, 0x93, 0x6d, 0x42,
0x7b, 0x1f, 0xa0, 0x01, 0xd1, 0xfb, 0xd4, 0x3e, 0xab, 0xef, 0xab, 0xe4, 0xdd,
0x6a, 0x90, 0x46, 0xc4, 0xe0, 0xd3, 0x00, 0xbd, 0x16, 0x39, 0x25, 0x3f, 0x22,
0x76, 0xc0, 0xaa, 0x91, 0x56, 0xa4, 0x1e, 0x71, 0xf8, 0x8c, 0xbe, 0x75, 0xdf,
0x81, 0xcf, 0xe4, 0x6b, 0x41, 0x3c, 0xbe, 0x26, 0xe4, 0x08, 0x7a, 0x76, 0x7d,
0x87, 0x99, 0x63, 0x99, 0x63, 0xdf, 0x7f, 0xac, 0x51, 0x83, 0xcc, 0x10, 0xd3,
0xc1, 0x7c, 0x63, 0x5a, 0x98, 0x0d, 0x88, 0x49, 0xab, 0xa6, 0x11, 0x66, 0x98,
0x59, 0x26, 0x9b, 0x98, 0x56, 0xa6, 0x01, 0xbc, 0x67, 0x3f, 0xf3, 0x15, 0xca,
0x51, 0xe6, 0x0b, 0xf3, 0x89, 0x69, 0x63, 0x7a, 0x99, 0x4e, 0x46, 0x6f, 0x2a,
0x07, 0x4a, 0x4f, 0xc6, 0xa7, 0x6f, 0x9a, 0x4c, 0x64, 0x1d, 0x53, 0xc5, 0xd4,
0x30, 0x93, 0x4c, 0x3d, 0xf3, 0x81, 0xa9, 0x64, 0xca, 0xa0, 0x47, 0x6d, 0x6a,
0x67, 0x54, 0x26, 0xad, 0xa9, 0x99, 0xf9, 0xce, 0x2c, 0x9b, 0xc6, 0x98, 0x29,
0x66, 0x05, 0xe6, 0xae, 0x65, 0x7e, 0x30, 0x7d, 0x4c, 0x35, 0x33, 0xce, 0x68,
0xa0, 0xb5, 0x6e, 0x2a, 0x61, 0x74, 0xa6, 0x9f, 0xcc, 0x47, 0xa6, 0x8b, 0xa9,
0x60, 0x1a, 0x99, 0xcf, 0x8c, 0xd2, 0xb4, 0x66, 0xea, 0x66, 0xa6, 0x99, 0x09,
0x66, 0x80, 0xf9, 0xd7, 0x75, 0x96, 0x02, 0x4d, 0x61, 0x2a, 0xe2, 0xc0, 0xe2,
0xb8, 0x5c, 0x28, 0x11, 0x4b, 0x3e, 0x97, 0xf2, 0x67, 0x73, 0x05, 0x9c, 0xc1,
0xb2, 0x6d, 0xd1, 0x4b, 0x67, 0x4a, 0x7e, 0xfb, 0x4b, 0x38, 0x29, 0xfb, 0x83,
0xf2, 0xd9, 0x5f, 0xc3, 0x95, 0x73, 0x49, 0xff, 0x3b, 0xfe, 0xd5, 0xbf, 0x09,
0xbd, 0xc5, 0x40, 0xab, 0xe6, 0x2c, 0x80, 0x55, 0x72, 0x2f, 0xfe, 0x3c, 0xae,
0x90, 0xcb, 0xe1, 0x3e, 0x72, 0x1f, 0xb8, 0x0a, 0xce, 0x68, 0xd9, 0xb2, 0x98,
0x2d, 0x4f, 0xfe, 0x5a, 0xce, 0x64, 0x29, 0x95, 0xbe, 0xff, 0x9e, 0xcb, 0xe4,
0x2e, 0xdc, 0x07, 0x3e, 0x8b, 0xcf, 0xe7, 0xab, 0xf8, 0x3c, 0xfe, 0x77, 0x30,
0x9b, 0x07, 0xef, 0x0e, 0x71, 0x37, 0x1a, 0x2c, 0xe5, 0xcb, 0x79, 0x31, 0x28,
0x43, 0x2b, 0xf9, 0x22, 0x7e, 0x09, 0xad, 0xe0, 0x73, 0x78, 0x05, 0x9a, 0x0a,
0x56, 0x71, 0xc5, 0x7c, 0x01, 0x1f, 0x0b, 0xd6, 0xf0, 0x73, 0xd2, 0x59, 0x81,
0x79, 0x34, 0x11, 0x2c, 0x84, 0xef, 0x54, 0xf3, 0xef, 0xf9, 0x97, 0xe0, 0x22,
0x3a, 0x8b, 0x96, 0xf0, 0xaf, 0xc1, 0x8f, 0x7c, 0x32, 0x98, 0xcb, 0x97, 0xf1,
0x4f, 0xc1, 0x67, 0x88, 0x45, 0xfb, 0xb6, 0x78, 0x70, 0x19, 0x75, 0xd8, 0x66,
0xde, 0xce, 0x23, 0x2c, 0xa0, 0xbf, 0x6c, 0x5a, 0x88, 0x4f, 0xcb, 0xe1, 0xb9,
0xb0, 0x22, 0xbc, 0x11, 0x36, 0x84, 0x37, 0xc3, 0x7b, 0xb6, 0x5d, 0xe9, 0x3c,
0xeb, 0x4a, 0xd8, 0x18, 0x5e, 0x0b, 0x2f, 0x40, 0xef, 0x52, 0x78, 0x31, 0xac,
0x0c, 0x6b, 0xc2, 0xf3, 0xe1, 0xd5, 0xf0, 0x7a, 0x78, 0x07, 0x7a, 0x55, 0x40,
0x75, 0xda, 0xd4, 0x61, 0xbb, 0xcd, 0x65, 0x3b, 0x8b, 0xe8, 0xfe, 0x11, 0xfb,
0xe1, 0xb8, 0xcc, 0x1d, 0x39, 0x8e, 0xec, 0x46, 0x0e, 0x20, 0xce, 0x9d, 0x46,
0xac, 0xf6, 0xcb, 0xc8, 0x09, 0x60, 0x7b, 0x91, 0xab, 0x08, 0x16, 0xb1, 0xdb,
0x1d, 0x76, 0x1c, 0x5a, 0xfb, 0x11, 0x8b, 0x1d, 0xb5, 0xbb, 0x22, 0x87, 0x91,
0x5f, 0xd0, 0xba, 0x88, 0x9c, 0x47, 0x76, 0x22, 0x47, 0x99, 0xb3, 0x46, 0xe6,
0xa8, 0xd3, 0xee, 0x89, 0x2c, 0x3a, 0x96, 0x1d, 0x0b, 0x10, 0x25, 0xed, 0x51,
0x24, 0x6a, 0x8c, 0x9a, 0xa2, 0x5b, 0x52, 0x26, 0x6c, 0x89, 0xa2, 0x51, 0x85,
0x63, 0x15, 0xe8, 0xd6, 0xa8, 0xd2, 0xb1, 0xe2, 0xb0, 0xbd, 0xdd, 0x91, 0xb6,
0xe4, 0xf8, 0x77, 0xb9, 0x45, 0x1d, 0x42, 0x2c, 0x11, 0x8b, 0x3b, 0xb6, 0xa3,
0x71, 0xc8, 0xe8, 0x5f, 0x62, 0xd1, 0xd8, 0xef, 0xd8, 0x53, 0xcc, 0x10, 0x8d,
0xc5, 0xf4, 0xe1, 0xd7, 0x98, 0x18, 0x4b, 0x02, 0xf5, 0x39, 0x16, 0x81, 0xb2,
0x38, 0x11, 0x73, 0xa4, 0xa4, 0xac, 0x3f, 0x9a, 0x78, 0x9f, 0x28, 0x4a, 0x14,
0x24, 0x0a, 0x13, 0x25, 0x70, 0x44, 0x78, 0xe9, 0x8c, 0x24, 0xc2, 0x89, 0x58,
0x42, 0x04, 0x3c, 0x9e, 0xb8, 0x72, 0x0a, 0xd2, 0x53, 0x6b, 0xb6, 0xa5, 0x3b,
0xdc, 0xf2, 0x53, 0xef, 0x52, 0x05, 0xd2, 0x99, 0xa6, 0x9d, 0x94, 0x29, 0x55,
0xbe, 0xe7, 0x87, 0xd8, 0xf8, 0x1d, 0x62, 0x91, 0x01, 0xdb, 0xc4, 0xb2, 0xd4,
0x39, 0xda, 0x29, 0xc9, 0x93, 0x4e, 0x42, 0xe9, 0xd7, 0x19, 0xc0, 0x66, 0x37,
0x0d, 0x46, 0x28, 0x4f, 0x7d, 0x33, 0xcc, 0x27, 0xee, 0x0b, 0xf7, 0x19, 0xe4,
0xbc, 0x82, 0xd6, 0xf2, 0x5b, 0xe1, 0xf9, 0x14, 0x0d, 0xd1, 0x7e, 0xd7, 0xbd,
0xe7, 0xfe, 0xe5, 0xde, 0x71, 0x73, 0x30, 0xcb, 0xb2, 0x67, 0x51, 0x8a, 0x76,
0x0b, 0x50, 0x76, 0x2a, 0x7f, 0x28, 0xbb, 0x94, 0x4b, 0xff, 0xf2, 0x86, 0x03,
0x07, 0x86, 0x62, 0x16, 0x29, 0xbe, 0x64, 0xab, 0x6d, 0xd8, 0x3b, 0xf5, 0x36,
0xb6, 0x9f, 0x3e, 0x1e, 0xc3, 0x4c, 0x50, 0xe6, 0xaa, 0x0f, 0xb1, 0x5d, 0x0c,
0xc1, 0xac, 0xd8, 0x1e, 0xe6, 0xc2, 0xec, 0x40, 0x29, 0x54, 0x1f, 0x60, 0x66,
0x69, 0xf4, 0x0e, 0x66, 0xc4, 0x0a, 0xd4, 0x79, 0x6a, 0x27, 0xb4, 0x7e, 0x61,
0x5b, 0x58, 0xbe, 0x3a, 0xe7, 0xed, 0xc9, 0xc5, 0x25, 0xda, 0x79, 0xfc, 0xbd,
0x16, 0x78, 0x88, 0xaf, 0xe0, 0x85, 0xda, 0x77, 0xda, 0x19, 0x7c, 0x19, 0x5f,
0xc4, 0xe7, 0xf0, 0x55, 0x5c, 0x89, 0xab, 0x70, 0x35, 0x3e, 0x8d, 0xe7, 0x6b,
0xe5, 0xb8, 0x0c, 0x5f, 0xc3, 0x0b, 0xb4, 0xb3, 0x78, 0x91, 0x36, 0x4f, 0xbb,
0x80, 0x97, 0xc2, 0xf8, 0x62, 0xad, 0x22, 0x13, 0x35, 0x04, 0x9d, 0x05, 0x7c,
0xeb, 0x06, 0xc1, 0x83, 0xe7, 0x63, 0x48, 0x13, 0xb1, 0x4e, 0x04, 0x74, 0x7a,
0x22, 0xa4, 0xdb, 0x22, 0x0c, 0x44, 0x44, 0xc7, 0x49, 0xf9, 0xb0, 0x86, 0xd0,
0x11, 0xe1, 0xf4, 0x3d, 0x0b, 0x30, 0xd2, 0x4c, 0x6c, 0x13, 0x9b, 0x84, 0x91,
0x40, 0x88, 0xa0, 0xee, 0xef, 0xfb, 0x63, 0x49, 0x9e, 0xa4, 0x49, 0x3f, 0xb9,
0x65, 0x78, 0x20, 0xad, 0x92, 0xc7, 0xb3, 0x18, 0xcc, 0x86, 0x20, 0x89, 0x1a,
0x6c, 0x06, 0x1f, 0x19, 0x26, 0xed, 0x06, 0x93, 0x61, 0xdb, 0x10, 0x20, 0x1d,
0x86, 0x3b, 0xf2, 0x9e, 0x0c, 0x91, 0x9c, 0xe4, 0x0d, 0xa3, 0xbe, 0x47, 0x1f,
0xf2, 0x96, 0x2b, 0x77, 0x21, 0xd7, 0xbe, 0x88, 0xef, 0xc6, 0xd7, 0x0e, 0xde,
0x8b, 0x00, 0x1f, 0x44, 0xfb, 0xbc, 0xbe, 0x0e, 0xe4, 0xdc, 0x27, 0xf8, 0xbe,
0x23, 0xbc, 0x2f, 0xe4, 0xc3, 0x7d, 0x3d, 0xc8, 0x03, 0xd0, 0x29, 0x1f, 0xe3,
0xbb, 0x82, 0x5a, 0xf4, 0x71, 0xbe, 0x7b, 0xdf, 0x99, 0xaf, 0x13, 0x09, 0xa4,
0xcf, 0xce, 0x20, 0x61, 0x28, 0xfd, 0xbe, 0x6f, 0x08, 0x0b, 0xf5, 0x9d, 0xaf,
0x0d, 0xb9, 0xf4, 0xdd, 0xfa, 0x82, 0x3e, 0x52, 0xf2, 0x66, 0xbe, 0x3f, 0x7c,
0x1a, 0x6a, 0x7a, 0x24, 0x35, 0x0c, 0xc2, 0xac, 0x33, 0x4a, 0x46, 0xc1, 0xd8,
0x4c, 0x4b, 0xcc, 0x0f, 0x44, 0xc6, 0x58, 0x4d, 0x8b, 0x8c, 0xc5, 0xb4, 0xca,
0x2c, 0x33, 0x46, 0x66, 0x83, 0x59, 0x63, 0xb4, 0x0c, 0x62, 0x5a, 0x61, 0xcc,
0x8c, 0x9c, 0x99, 0x65, 0xb6, 0x98, 0x6d, 0x93, 0x85, 0x31, 0x9b, 0xac, 0x8c,
0x9a, 0xb9, 0xf0, 0xe9, 0x19, 0x15, 0x63, 0x60, 0x74, 0x19, 0xcf, 0xb3, 0xc0,
0x18, 0x4d, 0x26, 0x66, 0xcb, 0x34, 0xc7, 0x98, 0x4c, 0x6d, 0xdc, 0x26, 0xb3,
0xfd, 0x87, 0x47, 0xfa, 0xca, 0x19, 0x4c, 0x56, 0xcb, 0x0f, 0xae, 0x03, 0xb4,
0xa7, 0x9d, 0x6b, 0xe6, 0xfa, 0x32, 0xde, 0xc2, 0x91, 0xbe, 0x03, 0x89, 0xfb,
0xce, 0x75, 0x72, 0x4d, 0x5c, 0x23, 0xd7, 0x0d, 0xd4, 0x16, 0xae, 0x81, 0x6b,
0x85, 0xba, 0x97, 0xab, 0xe3, 0x7a, 0xb8, 0x2e, 0xce, 0x66, 0x41, 0x25, 0x3f,
0x65, 0xb7, 0x7c, 0xe3, 0xf6, 0xc3, 0x7f, 0x3c, 0xaf, 0x9e, 0x5f, 0x47, 0x1b,
0xf8, 0x2f, 0xfc, 0x57, 0xbe, 0x83, 0xaf, 0x07, 0x8f, 0xd1, 0xcf, 0xaf, 0xa1,
0x5d, 0x7c, 0x13, 0xff, 0x83, 0xff, 0xc6, 0xf7, 0xf0, 0x8d, 0xbc, 0x16, 0xd5,
0xa0, 0xcd, 0x7c, 0x2f, 0xff, 0x89, 0xef, 0xe6, 0x57, 0xc1, 0x53, 0xb4, 0xf1,
0xad, 0xfc, 0x77, 0xbe, 0x8e, 0x57, 0x03, 0xbe, 0x81, 0xb6, 0xf0, 0x9d, 0xbc,
0x0e, 0x6d, 0xe7, 0xff, 0x6d, 0x36, 0x25, 0xaa, 0x42, 0x77, 0xc2, 0x4e, 0x69,
0xfe, 0x83, 0xf0, 0x6e, 0xd8, 0x0d, 0x98, 0x39, 0xec, 0x0a, 0x1f, 0x87, 0xfb,
0x78, 0x5b, 0xf8, 0xc8, 0x36, 0xcf, 0x98, 0xc2, 0x7b, 0x61, 0x47, 0x18, 0x0d,
0x6f, 0x87, 0x91, 0xb0, 0x07, 0x7a, 0xad, 0x61, 0x4b, 0xd8, 0x6d, 0xfb, 0x05,
0xd8, 0x81, 0xe4, 0x67, 0x0e, 0x6d, 0xf6, 0xf0, 0x11, 0xb4, 0x6e, 0x22, 0x24,
0xf8, 0x81, 0x5d, 0xbb, 0x37, 0xe2, 0xb2, 0xd3, 0x69, 0xbf, 0x61, 0x7f, 0x88,
0x10, 0x91, 0xc3, 0x30, 0x1b, 0xb9, 0x86, 0xd6, 0x8e, 0xdd, 0x07, 0xe5, 0x7d,
0x84, 0x8a, 0x30, 0x91, 0xbb, 0xc8, 0x6d, 0xe4, 0x97, 0x74, 0x3e, 0xd9, 0x19,
0x75, 0xa5, 0x9f, 0xe0, 0x1b, 0x5d, 0x73, 0xa8, 0x1c, 0xbb, 0xd1, 0x1d, 0xc0,
0x1d, 0x00, 0x39, 0xf1, 0xfc, 0x78, 0x76, 0xfc, 0xaf, 0xbf, 0x9e, 0x1c, 0xb9,
0xf1, 0x94, 0x23, 0xe9, 0x48, 0x38, 0xf2, 0xe2, 0x95, 0x89, 0x72, 0xb0, 0xe4,
0xb2, 0x44, 0x56, 0xbc, 0x22, 0xf1, 0x2e, 0x5e, 0x0a, 0x78, 0x2a, 0x81, 0x27,
0x12, 0x09, 0xc2, 0x99, 0x4c, 0x3c, 0x41, 0xcb, 0x92, 0x7c, 0x72, 0x9a, 0x93,
0xa6, 0xe4, 0x6f, 0x27, 0x64, 0xfc, 0xae, 0xde, 0xd4, 0x62, 0x6a, 0x21, 0xb5,
0x94, 0xba, 0x5f, 0x50, 0x80, 0x1d, 0x1e, 0x61, 0x9e, 0x4c, 0x5e, 0x67, 0x05,
0x0d, 0x2e, 0x88, 0x5b, 0x93, 0x0f, 0x0b, 0xdd, 0xca, 0x95, 0x8c, 0x85, 0xae,
0xe3, 0x65, 0x60, 0x11, 0x36, 0x02, 0x25, 0x44, 0xd0, 0x68, 0xa7, 0x01, 0x65,
0xec, 0x10, 0x71, 0x1c, 0x99, 0xeb, 0x5d, 0x4e, 0xcb, 0xb3, 0x93, 0xc9, 0xfc,
0x23, 0x6d, 0xd5, 0x13, 0x54, 0xac, 0x79, 0x94, 0x9e, 0x9e, 0xf4, 0x9b, 0xef,
0x60, 0xc6, 0x0b, 0xac, 0x48, 0x7d, 0x8e, 0x9d, 0x02, 0x46, 0x60, 0x27, 0x18,
0x86, 0x15, 0x83, 0x5d, 0x96, 0x49, 0xb6, 0xe9, 0xc5, 0x4a, 0xd5, 0x57, 0x18,
0x8e, 0x9d, 0x61, 0xef, 0xd5, 0x25, 0xea, 0xcb, 0xb7, 0xac, 0xb2, 0x42, 0xab,
0x01, 0xbb, 0xab, 0xd1, 0xda, 0xf0, 0x6a, 0xad, 0x43, 0xb2, 0x40, 0x03, 0x5e,
0xa5, 0xb5, 0x03, 0xa6, 0xc5, 0x3f, 0x68, 0x2d, 0x38, 0x82, 0x9b, 0xf0, 0x4d,
0xdc, 0x2c, 0xf5, 0x94, 0x6b, 0xb7, 0xa0, 0x36, 0xe2, 0x3a, 0x28, 0xad, 0x12,
0x65, 0x1b, 0xdf, 0x80, 0x5a, 0x8f, 0x57, 0x6a, 0xd1, 0xb7, 0x9c, 0x2f, 0xae,
0x73, 0x67, 0x72, 0xa3, 0x5d, 0x62, 0x9f, 0x70, 0x11, 0x4e, 0xc2, 0x0e, 0xed,
0x3d, 0xe2, 0x80, 0xf8, 0x05, 0xf5, 0x0e, 0x11, 0xd5, 0xc5, 0xfe, 0x66, 0xa7,
0x47, 0x84, 0xdb, 0x10, 0x21, 0x93, 0xa4, 0x48, 0x46, 0xc1, 0xfe, 0x52, 0x00,
0x47, 0x60, 0x7d, 0x3b, 0x86, 0x43, 0x83, 0x40, 0x3a, 0x88, 0x3d, 0xc3, 0x2f,
0x43, 0x82, 0x8c, 0x93, 0xbb, 0x86, 0x7d, 0x43, 0x8c, 0x74, 0x41, 0xcf, 0x81,
0xe1, 0xdf, 0xbf, 0x1b, 0xf7, 0x0d, 0x49, 0x59, 0x45, 0x0e, 0x9d, 0x4d, 0x43,
0xfc, 0xf4, 0x8d, 0x20, 0x59, 0x74, 0xc2, 0x97, 0xf4, 0xf5, 0x22, 0xfd, 0x40,
0x7f, 0xf1, 0xc5, 0x7c, 0x3f, 0x91, 0x01, 0x24, 0xe5, 0x7b, 0xf5, 0x3d, 0xfb,
0x06, 0x91, 0x27, 0xdf, 0x21, 0xd1, 0x27, 0x8d, 0xb7, 0x31, 0xbb, 0x8c, 0x0b,
0xf8, 0xe9, 0x66, 0xf6, 0x4c, 0x4e, 0xc6, 0x0e, 0xd6, 0x71, 0x00, 0xe0, 0x34,
0xed, 0x33, 0x3b, 0xa6, 0x5f, 0x26, 0x07, 0xb3, 0x6b, 0xda, 0x63, 0x5c, 0xcc,
0x0e, 0xf3, 0x8b, 0x19, 0xce, 0x1c, 0x0b, 0xf7, 0x73, 0x53, 0x60, 0x09, 0x7b,
0x96, 0x51, 0x6e, 0x1c, 0xea, 0x5f, 0x96, 0x01, 0x6e, 0x18, 0xea, 0x31, 0xce,
0x65, 0xd9, 0xb5, 0x4c, 0x72, 0x83, 0xdc, 0x10, 0x37, 0xc1, 0xfd, 0xe4, 0x46,
0xb8, 0x1d, 0xcb, 0x4f, 0xd0, 0xe4, 0x01, 0x7e, 0x13, 0x1d, 0xe5, 0x8d, 0x52,
0x54, 0xd4, 0xa3, 0x83, 0xfc, 0x16, 0x3a, 0x24, 0xe9, 0xf7, 0x30, 0x3f, 0x06,
0xb5, 0x01, 0xe8, 0xe7, 0x92, 0x7e, 0x5f, 0x42, 0x89, 0x85, 0xcf, 0x24, 0xfc,
0x34, 0x8c, 0x87, 0x2f, 0xc2, 0x23, 0xfc, 0x89, 0xd4, 0x72, 0xdb, 0x03, 0x91,
0x50, 0x44, 0x88, 0xf8, 0x23, 0x5c, 0x84, 0x8f, 0x84, 0x23, 0x87, 0xf6, 0x03,
0xfb, 0xbe, 0x3d, 0x18, 0x79, 0x8c, 0xec, 0x45, 0xd5, 0x10, 0x9f, 0xf6, 0xa5,
0x68, 0x55, 0x14, 0xff, 0xed, 0x78, 0x1f, 0x7f, 0x76, 0x14, 0xc6, 0x8b, 0xe3,
0x4b, 0xa0, 0x67, 0x55, 0x89, 0x45, 0xe7, 0x4b, 0xe2, 0x39, 0x7d, 0x2d, 0x43,
0x8a, 0x32, 0x85, 0xa9, 0xa2, 0xd4, 0xfb, 0x54, 0x31, 0x44, 0x98, 0x8a, 0x3d,
0x16, 0x74, 0xa6, 0x57, 0xe9, 0xc4, 0x13, 0xc0, 0xfd, 0x27, 0xd2, 0x03, 0x96,
0x12, 0x91, 0xa2, 0xe4, 0x6c, 0xe6, 0x7c, 0x4e, 0x6d, 0xe6, 0xed, 0x18, 0x1f,
0xd3, 0xef, 0x0f, 0x23, 0x92, 0xba, 0x13, 0xe2, 0x58, 0x92, 0xe3, 0x6f, 0xd2,
0x63, 0xc8, 0xa5, 0xdf, 0xd1, 0xf9, 0xc0, 0xe1, 0x3c, 0xfa, 0x90, 0xf1, 0x30,
0x47, 0x69, 0x7e, 0x65, 0xae, 0xed, 0xec, 0x43, 0x8d, 0xa0, 0xe3, 0xfc, 0x24,
0x3f, 0x21, 0xed, 0xf0, 0x38, 0x73, 0x45, 0x35, 0x1a, 0x11, 0x61, 0xf6, 0x83,
0xe8, 0xba, 0x14, 0x4b, 0x5f, 0x1c, 0xd5, 0x89, 0x0f, 0x89, 0x3a, 0xd7, 0xff,
0xfa, 0xa8, 0x65, 0x6e, 0x49, 0xe5, 0xe9, 0x53, 0xfe, 0xc2, 0x5d, 0x92, 0x3e,
0xed, 0xe0, 0xa7, 0xc4, 0x19, 0x91, 0x4b, 0x61, 0xb0, 0x92, 0x67, 0x32, 0x9b,
0xca, 0xa2, 0x72, 0xa8, 0x63, 0xc3, 0x2b, 0xf9, 0x42, 0xe6, 0x51, 0xb0, 0x7b,
0xba, 0x00, 0xd6, 0x54, 0x48, 0x63, 0xcc, 0xb1, 0xe4, 0xdf, 0x4e, 0x98, 0x69,
0x6e, 0x8a, 0x9f, 0xe6, 0x4f, 0x60, 0x0d, 0xb1, 0x88, 0x3b, 0xaa, 0x81, 0xdf,
0x2e, 0x89, 0xd7, 0x24, 0x96, 0x81, 0x33, 0xaf, 0x89, 0x92, 0xd4, 0x3c, 0xec,
0x74, 0x40, 0xf9, 0x53, 0xa9, 0x96, 0xec, 0x6c, 0xdd, 0xd3, 0x0f, 0x56, 0x53,
0x0d, 0xd6, 0x51, 0x05, 0x50, 0xa9, 0xfe, 0xa4, 0xae, 0x50, 0x7f, 0x56, 0x5f,
0x63, 0x1f, 0xa1, 0xf5, 0x41, 0x5d, 0xab, 0xae, 0x51, 0x97, 0x4b, 0x96, 0xd3,
0x04, 0xfc, 0xf8, 0xac, 0x3d, 0xc0, 0x1b, 0x25, 0xfe, 0x34, 0x6b, 0xbf, 0x40,
0x5d, 0x97, 0x7e, 0x3b, 0xa2, 0xb4, 0xc2, 0x4f, 0x80, 0xed, 0xe3, 0x0d, 0x52,
0xdf, 0x2e, 0x5e, 0x2f, 0xd5, 0x79, 0x7a, 0xc8, 0xe1, 0xa4, 0xb7, 0x39, 0x5c,
0x10, 0xf9, 0xfa, 0x94, 0xee, 0x05, 0x38, 0x4e, 0x1b, 0x8a, 0xa8, 0x2b, 0xe2,
0x55, 0xd2, 0xfc, 0x6b, 0xe2, 0x86, 0xc8, 0x85, 0x7e, 0x0a, 0x76, 0x75, 0x07,
0xe0, 0x23, 0x70, 0xe2, 0x9c, 0xa0, 0x89, 0x1c, 0xfd, 0x2d, 0x41, 0x42, 0x3b,
0x4b, 0xff, 0x5b, 0x57, 0xa0, 0x27, 0x08, 0x2f, 0x71, 0x99, 0x3e, 0x7a, 0x97,
0x66, 0x7a, 0x4e, 0x4b, 0x4d, 0x57, 0x48, 0x91, 0x86, 0x2b, 0x49, 0xff, 0xcf,
0xa0, 0xbc, 0x37, 0x9c, 0x43, 0x79, 0x62, 0xb8, 0x35, 0xdc, 0x18, 0x28, 0xc0,
0x70, 0x83, 0xd7, 0x80, 0x19, 0x4e, 0x0d, 0x15, 0x54, 0x29, 0x95, 0x4f, 0x15,
0x03, 0x87, 0xee, 0x0c, 0x95, 0x94, 0xcf, 0x70, 0x29, 0x7d, 0xa3, 0x00, 0xda,
0xe5, 0xd4, 0x7b, 0xaa, 0x8c, 0x2a, 0xa1, 0xae, 0x0d, 0xef, 0xa8, 0x8b, 0x8c,
0x1d, 0x95, 0xd0, 0x63, 0xc8, 0x24, 0x68, 0x79, 0x19, 0xf0, 0x72, 0x1e, 0x29,
0xa5, 0xa7, 0x01, 0x3f, 0x32, 0x95, 0x43, 0x6b, 0x0e, 0x79, 0x4f, 0x2f, 0x64,
0xf4, 0x7f, 0x3c, 0x1d, 0xff, 0x0c, 0x53, 0x50, 0x4e, 0x20, 0x33, 0x88, 0x1c,
0x19, 0x45, 0x16, 0x91, 0x59, 0x68, 0xc9, 0x90, 0x62, 0xfa, 0xdf, 0x64, 0x77,
0x9e, 0xbe, 0x46, 0x9f, 0xf1, 0x52, 0x97, 0x50, 0x9f, 0x33, 0x57, 0xa6, 0x3b,
0x86, 0x60, 0xf6, 0x4d, 0x3e, 0xe6, 0x9a, 0x39, 0x33, 0xdd, 0x80, 0x94, 0x4e,
0x4d, 0xb7, 0xcc, 0xa1, 0x89, 0x64, 0xce, 0x18, 0xb7, 0x49, 0xc1, 0x61, 0x30,
0xca, 0x03, 0x70, 0x01, 0x70, 0x0a, 0xbd, 0x17, 0xcc, 0x81, 0x09, 0x67, 0x2e,
0x99, 0x2b, 0x06, 0x37, 0x79, 0x19, 0x8a, 0xa1, 0x81, 0x46, 0x98, 0x4e, 0x2c,
0xf3, 0xdc, 0x0a, 0xb7, 0xc4, 0xcd, 0x70, 0xab, 0x9c, 0x0c, 0xac, 0x6e, 0x11,
0xc0, 0x6d, 0xc1, 0x2c, 0x4a, 0x29, 0x72, 0x1d, 0x81, 0x06, 0x5e, 0x5a, 0x4e,
0x2d, 0x2a, 0x6e, 0x99, 0xf3, 0x58, 0xe4, 0xdc, 0x95, 0x65, 0x96, 0x9b, 0xe3,
0x08, 0xcb, 0x85, 0xe5, 0x18, 0x66, 0x3d, 0xb4, 0xa8, 0x39, 0x2f, 0x8c, 0x38,
0xb3, 0xac, 0x71, 0xc7, 0x96, 0x73, 0x0b, 0x0e, 0xb8, 0x1d, 0x9d, 0xe3, 0x95,
0xbc, 0x82, 0x5f, 0x05, 0x8d, 0xb5, 0xa2, 0xf3, 0x50, 0xae, 0xf0, 0xdb, 0xe8,
0x22, 0xef, 0x40, 0x67, 0xf9, 0x25, 0x5e, 0xc5, 0x2f, 0x70, 0xcb, 0xbc, 0x9c,
0x37, 0xa1, 0x32, 0xde, 0x8c, 0xaa, 0x79, 0x0b, 0xba, 0xc6, 0xdb, 0xd0, 0x19,
0x18, 0x85, 0x82, 0xdd, 0x2e, 0xf0, 0xde, 0xb0, 0x3f, 0x7c, 0x1f, 0x66, 0xc2,
0x44, 0x18, 0x03, 0x3d, 0xbb, 0x0a, 0x9f, 0xdb, 0xce, 0xa0, 0x7e, 0x0c, 0xdf,
0x86, 0x6f, 0xc2, 0x34, 0xd8, 0xee, 0x35, 0x00, 0x19, 0x66, 0xc3, 0x0f, 0x50,
0x9f, 0xda, 0x82, 0x61, 0x2e, 0x7c, 0x17, 0x0e, 0x84, 0x7d, 0xd0, 0x4a, 0x45,
0x8e, 0xec, 0xd9, 0xa2, 0xe4, 0x49, 0xe3, 0xe7, 0x76, 0x2a, 0x9c, 0x88, 0x9c,
0xd8, 0x93, 0x91, 0x17, 0xc9, 0x0a, 0x4f, 0xed, 0x67, 0xf6, 0x78, 0x24, 0x4b,
0xcc, 0x11, 0x9f, 0x22, 0xcf, 0x91, 0xd7, 0xc8, 0xef, 0x48, 0xae, 0x78, 0x6c,
0xc7, 0xed, 0x18, 0x44, 0x25, 0x8f, 0xdd, 0x03, 0xd6, 0xbe, 0xe9, 0x38, 0x94,
0x6c, 0xfe, 0x04, 0x4a, 0x2c, 0xaa, 0x73, 0x9c, 0x46, 0x8f, 0x01, 0x3b, 0x8a,
0x1a, 0x1c, 0x1b, 0x8e, 0x33, 0xc0, 0xf4, 0x0e, 0x6d, 0x26, 0x6f, 0x7d, 0x95,
0xea, 0x2c, 0x67, 0x59, 0xbc, 0x34, 0x5e, 0x11, 0xaf, 0x84, 0xb8, 0x95, 0xed,
0xfc, 0x98, 0xa8, 0x4b, 0x28, 0xc0, 0x0e, 0x3e, 0x81, 0x5f, 0xa8, 0x4d, 0x7c,
0x49, 0x7c, 0x86, 0x3a, 0x17, 0x72, 0x50, 0xaf, 0x33, 0x27, 0x99, 0x05, 0x75,
0x76, 0xe6, 0x1f, 0xf7, 0xaf, 0xce, 0x17, 0x27, 0x9a, 0xb4, 0x25, 0xb3, 0xc0,
0x56, 0x4b, 0x53, 0x65, 0xa9, 0x0e, 0xa8, 0x7b, 0x00, 0x96, 0x53, 0xbf, 0x52,
0x0b, 0xe9, 0xf7, 0xc4, 0x82, 0xd6, 0x1f, 0xe2, 0x55, 0x54, 0x05, 0x7d, 0xcf,
0xb8, 0xd2, 0xd7, 0x7c, 0x51, 0x3e, 0x9c, 0x07, 0x7b, 0xca, 0x4b, 0x2e, 0x2e,
0xdd, 0x60, 0x5f, 0xd4, 0x5f, 0xb5, 0xd5, 0xd4, 0x07, 0xca, 0x6b, 0x7a, 0x60,
0xae, 0x4d, 0xeb, 0x3c, 0x9e, 0xf1, 0x06, 0x23, 0xae, 0xa5, 0xa5, 0x7d, 0x37,
0x29, 0x45, 0x9d, 0x96, 0xf4, 0x5b, 0x0a, 0x71, 0x0f, 0xcc, 0x73, 0x0f, 0xda,
0x5d, 0xa8, 0x7f, 0x00, 0x3d, 0xfc, 0x48, 0xd5, 0x50, 0xb5, 0xa0, 0x9f, 0x95,
0x74, 0x15, 0xbd, 0x84, 0x5c, 0x5b, 0x6e, 0x4c, 0x37, 0x20, 0x27, 0x1d, 0xaf,
0xe1, 0x37, 0x78, 0x2d, 0xbf, 0x03, 0xbf, 0x13, 0x0a, 0xbf, 0x13, 0xf3, 0xc5,
0xb9, 0xfd, 0x7a, 0x75, 0x9d, 0x9a, 0x82, 0x79, 0x8e, 0x25, 0xeb, 0x63, 0x88,
0x07, 0xa2, 0x08, 0xec, 0xe3, 0x33, 0xf5, 0x85, 0xfa, 0x24, 0xbd, 0x1d, 0x94,
0x35, 0x30, 0xe9, 0xa3, 0x6c, 0x64, 0x19, 0x74, 0x93, 0x61, 0xb4, 0xdc, 0x3a,
0xa7, 0xe1, 0x48, 0xcb, 0x26, 0xaf, 0x07, 0xf9, 0x45, 0xc2, 0x42, 0x38, 0x1c,
0x2e, 0x80, 0xd5, 0x2a, 0x52, 0xcb, 0x4b, 0x83, 0x60, 0xfd, 0x43, 0xca, 0x06,
0x75, 0xa3, 0xfa, 0x0e, 0xbb, 0xc5, 0x4e, 0x60, 0xbe, 0xef, 0xda, 0x6f, 0xda,
0x56, 0x6d, 0x87, 0xb6, 0x5d, 0xdb, 0x26, 0xd9, 0x71, 0xb1, 0xde, 0x0f, 0x2b,
0x0c, 0x1a, 0x4a, 0xf4, 0x95, 0xfa, 0x00, 0xf1, 0x41, 0x5f, 0xa5, 0xaf, 0xd1,
0x73, 0x04, 0x4b, 0x94, 0xeb, 0xdf, 0xeb, 0x4b, 0xf5, 0x8f, 0x44, 0xb5, 0xbe,
0x42, 0x5f, 0xa6, 0x0f, 0x19, 0x78, 0x43, 0xc0, 0x10, 0x86, 0x5f, 0xf5, 0x1b,
0x38, 0x28, 0x1f, 0x01, 0xea, 0xa4, 0xb5, 0x54, 0x83, 0x65, 0xac, 0x22, 0x4a,
0x64, 0x05, 0xd6, 0xf2, 0x01, 0xf0, 0x1a, 0x00, 0x3f, 0x13, 0x00, 0x9d, 0x66,
0x4c, 0x41, 0x86, 0x32, 0x3d, 0x42, 0x7a, 0xfb, 0x68, 0xba, 0x37, 0x3d, 0x98,
0xee, 0x4c, 0x2c, 0x73, 0x6b, 0xe2, 0x19, 0x0e, 0xfa, 0x58, 0xd0, 0x5a, 0x9f,
0x89, 0x36, 0xe9, 0x40, 0xbb, 0x37, 0x39, 0x3d, 0x94, 0x06, 0x8e, 0xb2, 0x6c,
0x48, 0xba, 0xbe, 0x8f, 0x1a, 0xf8, 0x5f, 0xe8, 0x01, 0xba, 0x87, 0xee, 0xa2,
0x62, 0x38, 0x0e, 0x3a, 0x15, 0x03, 0x88, 0x86, 0x2f, 0x6c, 0x85, 0x62, 0x91,
0x78, 0x61, 0x2f, 0x16, 0x2f, 0xa5, 0x2c, 0x66, 0x0b, 0x34, 0xc0, 0xe8, 0xa8,
0x92, 0xae, 0x74, 0xe7, 0x38, 0x3f, 0xc4, 0xeb, 0x13, 0x2b, 0xce, 0x55, 0x90,
0x7e, 0x3e, 0x48, 0x39, 0xc7, 0xf5, 0xd7, 0xff, 0x65, 0x1f, 0x05, 0xe8, 0x55,
0x97, 0xb6, 0x53, 0x5b, 0x4f, 0x35, 0x00, 0xdf, 0xd6, 0x10, 0x23, 0xe7, 0x37,
0x6d, 0x71, 0x46, 0x7e, 0x05, 0xe8, 0x1a, 0xcf, 0x88, 0x72, 0x18, 0x24, 0xe5,
0xc3, 0x9a, 0xd4, 0x34, 0x76, 0x06, 0x52, 0x3a, 0x05, 0xc0, 0x24, 0xe9, 0xf3,
0xc4, 0x27, 0xc9, 0x37, 0x06, 0x89, 0xda, 0xcc, 0xbb, 0x73, 0x42, 0xc4, 0x47,
0xc0, 0x9a, 0xa8, 0x16, 0xaa, 0x99, 0xfa, 0x4a, 0xb5, 0x53, 0x8d, 0xd4, 0x37,
0xaa, 0x95, 0x6a, 0xa3, 0xd4, 0xc8, 0x47, 0xc9, 0x4b, 0xa9, 0x40, 0x12, 0x11,
0x26, 0x2c, 0x45, 0x0b, 0xce, 0x14, 0x62, 0x04, 0xc0, 0x02, 0xc0, 0x6f, 0x04,
0xb8, 0xbb, 0xcd, 0xb9, 0x41, 0xcf, 0x4a, 0xc4, 0x32, 0xf1, 0xbd, 0x58, 0x2a,
0x9e, 0x47, 0xab, 0x25, 0xee, 0xf5, 0xa5, 0x56, 0x97, 0x46, 0x95, 0xf7, 0x18,
0x83, 0x3d, 0xa4, 0xf3, 0x2b, 0xbc, 0x1b, 0x34, 0xe3, 0x3c, 0x7d, 0x26, 0x4c,
0x7b, 0x09, 0xe5, 0x15, 0x8e, 0x4b, 0x2b, 0xf9, 0x4d, 0x34, 0xeb, 0x45, 0x22,
0x25, 0xc5, 0xcb, 0x3a, 0x7d, 0xa3, 0x3e, 0x42, 0x7c, 0xd6, 0xc7, 0x89, 0x6e,
0xaa, 0x01, 0x56, 0x23, 0x00, 0x35, 0x41, 0x44, 0x89, 0x27, 0x22, 0x4c, 0x24,
0x89, 0x7a, 0x7d, 0x93, 0x3e, 0x46, 0x7c, 0x01, 0x7a, 0xc4, 0xf0, 0x9d, 0x12,
0x0c, 0x7d, 0x54, 0x2f, 0x95, 0x04, 0x8d, 0x49, 0x19, 0xfa, 0x29, 0xd1, 0xd0,
0x43, 0x25, 0x0c, 0x3f, 0xa9, 0x4e, 0xe0, 0xc2, 0x0f, 0x2a, 0x6a, 0xe8, 0xa0,
0xba, 0xa8, 0x01, 0x2a, 0x66, 0x18, 0xa4, 0xfe, 0xc8, 0x78, 0x60, 0xec, 0x3a,
0x52, 0x47, 0x7f, 0xa5, 0x3f, 0xd3, 0x2d, 0xb0, 0xa7, 0x4f, 0x74, 0x03, 0xdd,
0x4a, 0x37, 0xd3, 0x4d, 0x74, 0x23, 0xb4, 0x6a, 0xe9, 0x7a, 0x69, 0x9f, 0x5f,
0xa0, 0x14, 0x4c, 0xbc, 0xe9, 0x37, 0x93, 0xcd, 0xe6, 0xb2, 0x59, 0x6c, 0x92,
0x79, 0x62, 0xf2, 0xd9, 0x1c, 0xf6, 0x99, 0x79, 0xc7, 0xa6, 0x98, 0x3c, 0x36,
0x64, 0x8a, 0x99, 0x44, 0x93, 0xc8, 0x44, 0x4d, 0x61, 0x53, 0x94, 0x89, 0x33,
0x31, 0xe6, 0x85, 0x79, 0x05, 0x5e, 0x44, 0x80, 0x17, 0x41, 0xc9, 0x83, 0x27,
0xa0, 0xe5, 0xe2, 0xee, 0xc0, 0x0a, 0x4d, 0x9c, 0xcf, 0xf2, 0x60, 0xb1, 0x01,
0x87, 0x2c, 0xdc, 0xfd, 0x3f, 0xf2, 0x7f, 0xce, 0xc1, 0x99, 0xb9, 0x1d, 0xce,
0xca, 0x39, 0x39, 0x1a, 0x28, 0xb7, 0x16, 0x34, 0xdd, 0xcb, 0x7b, 0xd0, 0x43,
0xf4, 0x18, 0x3d, 0x42, 0xcd, 0x3c, 0xc2, 0x6f, 0x81, 0xbd, 0x99, 0xa4, 0x8c,
0x60, 0x9b, 0xcf, 0x17, 0x6e, 0x6c, 0xbf, 0xc3, 0x4f, 0xa0, 0xa9, 0x97, 0xb6,
0x6c, 0x21, 0x4b, 0x48, 0x84, 0x73, 0x85, 0xe7, 0xf0, 0xb5, 0x2d, 0x15, 0xce,
0x11, 0x92, 0xe1, 0x2b, 0x9b, 0xd7, 0xf6, 0x12, 0x26, 0x6c, 0xaf, 0xd0, 0x9f,
0x27, 0x54, 0x81, 0x75, 0xde, 0xd8, 0xcb, 0xa1, 0xfc, 0x20, 0x79, 0x4a, 0xc2,
0x5e, 0x29, 0x52, 0xa0, 0xd3, 0xd7, 0x00, 0x15, 0x40, 0x21, 0xed, 0xd5, 0xe2,
0xd5, 0xdb, 0x53, 0x4a, 0xb6, 0x1d, 0x66, 0xd0, 0xf4, 0xcb, 0xa8, 0xc9, 0x81,
0x47, 0xbd, 0xf6, 0x8b, 0x28, 0xe2, 0xc8, 0x75, 0xe6, 0x3b, 0x3f, 0xc6, 0xf3,
0x9c, 0x35, 0x20, 0xbd, 0xaf, 0x09, 0xa5, 0xb3, 0x39, 0xb1, 0xe6, 0x6c, 0x4c,
0x34, 0x24, 0x5a, 0x12, 0xad, 0x89, 0x77, 0xa0, 0xfd, 0x4d, 0x52, 0x5e, 0xe4,
0x4a, 0xda, 0x93, 0x8e, 0xa4, 0x33, 0x59, 0x0f, 0xb6, 0x50, 0x99, 0xaa, 0x48,
0x95, 0xa7, 0xfa, 0x21, 0x47, 0x32, 0xa7, 0x56, 0x52, 0xbd, 0x2e, 0xe5, 0x52,
0xf3, 0x1f, 0xef, 0xda, 0x7b, 0x32, 0xfc, 0x5d, 0x57, 0xe3, 0x12, 0x77, 0x7e,
0x49, 0xd6, 0x48, 0x82, 0x77, 0xab, 0x11, 0xff, 0xf6, 0x0c, 0xb8, 0xd4, 0xda,
0x12, 0xaf, 0x18, 0x57, 0x8e, 0xa5, 0xcf, 0x53, 0xc3, 0x2c, 0x2c, 0xf6, 0x55,
0xfd, 0x88, 0xb5, 0x48, 0xf3, 0x91, 0x38, 0x21, 0xe9, 0x4a, 0x8f, 0xf6, 0x06,
0xbf, 0xc6, 0xbd, 0x78, 0xaf, 0x96, 0xc2, 0x6f, 0x33, 0x59, 0x73, 0xae, 0x37,
0xdb, 0x9b, 0xef, 0x7d, 0xe7, 0x2d, 0xf1, 0x82, 0x47, 0xf4, 0x16, 0x43, 0x99,
0xe3, 0x7d, 0x06, 0xbd, 0x29, 0x92, 0xde, 0xf6, 0xf4, 0xde, 0x9b, 0xe7, 0x2d,
0xf0, 0xbe, 0x10, 0x2d, 0xfa, 0x2c, 0xef, 0x2b, 0xf1, 0x55, 0xdf, 0x0a, 0xda,
0xf3, 0x62, 0x18, 0xa6, 0x46, 0xa9, 0x11, 0x6a, 0x92, 0xfa, 0x0d, 0x2b, 0x1c,
0xa3, 0x86, 0xa8, 0x71, 0x6a, 0x82, 0x7a, 0x36, 0xbc, 0x1a, 0xa6, 0x40, 0x5b,
0x3a, 0xe8, 0x6f, 0xa0, 0x01, 0x6d, 0x74, 0x3b, 0xad, 0x45, 0x74, 0x88, 0x06,
0xd9, 0x40, 0x4a, 0xd9, 0x32, 0xb6, 0x88, 0x05, 0x9f, 0xc6, 0x26, 0x4d, 0x2f,
0xa6, 0x84, 0xe9, 0xd5, 0x94, 0x32, 0xbd, 0x97, 0xde, 0x5a, 0x5a, 0xc2, 0x16,
0xb2, 0x59, 0xe6, 0xdf, 0xd2, 0xbe, 0x9e, 0x4c, 0xcf, 0x50, 0x17, 0x00, 0x7d,
0x8f, 0x63, 0x25, 0x59, 0x1f, 0x70, 0x7e, 0xcb, 0x11, 0xb7, 0xcf, 0xed, 0x72,
0x87, 0xdc, 0xa3, 0xc5, 0x0d, 0xfb, 0x66, 0x24, 0x3a, 0x86, 0x9e, 0xa3, 0x28,
0xc8, 0xf7, 0x14, 0xb5, 0xf2, 0x27, 0xe8, 0x19, 0xfa, 0x4e, 0x28, 0x10, 0x0a,
0x05, 0x0a, 0x38, 0x52, 0x24, 0x80, 0x46, 0xd8, 0xee, 0xec, 0x9f, 0xc4, 0xcf,
0x62, 0xad, 0xf8, 0x51, 0xfc, 0x22, 0xde, 0xda, 0xaf, 0xa3, 0x44, 0xd4, 0x1b,
0xbd, 0x89, 0x5e, 0x45, 0xc9, 0xe8, 0x27, 0x90, 0xcc, 0xe7, 0x78, 0x6d, 0xfc,
0x9d, 0xb3, 0x2d, 0xa1, 0x72, 0xb6, 0x27, 0x0a, 0x93, 0x05, 0xc9, 0xff, 0x4a,
0x6f, 0xa3, 0x5a, 0x6a, 0x93, 0xbc, 0x45, 0x56, 0xe6, 0x3d, 0x7f, 0x7a, 0x29,
0xc3, 0x09, 0xc0, 0xae, 0xb8, 0xb7, 0xfb, 0x95, 0x7c, 0xf6, 0x29, 0x47, 0x81,
0x53, 0xbd, 0xd4, 0xa6, 0xce, 0x86, 0x51, 0x75, 0xe2, 0x7f, 0x34, 0xcf, 0x82,
0x74, 0xe5, 0x64, 0x1d, 0x7c, 0xd4, 0xc6, 0x92, 0x76, 0x49, 0x23, 0x65, 0xd1,
0xf3, 0x40, 0x73, 0xbb, 0x21, 0xbe, 0xb9, 0x43, 0xd2, 0x75, 0x24, 0x41, 0x71,
0xe0, 0x3e, 0x74, 0x87, 0x15, 0xc7, 0x6e, 0x8f, 0xfb, 0xe4, 0x5f, 0xae, 0x76,
0xe8, 0x3d, 0x1b, 0x9e, 0x29, 0xa5, 0xd6, 0x33, 0xab, 0x9c, 0x51, 0x4e, 0x82,
0xc6, 0xcc, 0x01, 0x4c, 0x2b, 0xe5, 0x50, 0xca, 0x94, 0x3a, 0xc8, 0x51, 0x27,
0x32, 0xef, 0x5f, 0xed, 0x52, 0x73, 0x98, 0x80, 0x75, 0xa8, 0x7b, 0x41, 0x8f,
0x3a, 0xd5, 0x3c, 0x16, 0xc6, 0xba, 0xd5, 0x7e, 0x2c, 0x88, 0x7d, 0x57, 0xb7,
0xab, 0x03, 0xd8, 0x0f, 0x75, 0x08, 0xeb, 0x51, 0x7f, 0xfb, 0xf7, 0xb7, 0x48,
0xe2, 0x0f, 0x78, 0x7f, 0xfa, 0x1d, 0x8e, 0xda, 0x11, 0x2d, 0x2d, 0xe9, 0xd7,
0x8c, 0x76, 0x54, 0x3b, 0xa5, 0xfd, 0x09, 0xb4, 0x3e, 0xed, 0x80, 0x76, 0x5a,
0x7b, 0x8f, 0x0f, 0x6b, 0xc7, 0xb4, 0x43, 0xda, 0x71, 0x2d, 0x83, 0x4f, 0x6a,
0x07, 0xb5, 0x77, 0xff, 0x72, 0xbe, 0xbe, 0xd4, 0xdb, 0xae, 0x2f, 0x07, 0xdd,
0xeb, 0xd0, 0x77, 0x02, 0xaf, 0xca, 0xbc, 0xdf, 0xf4, 0x5d, 0x50, 0x7f, 0xcf,
0x78, 0xd9, 0x02, 0xe3, 0x2c, 0x55, 0x6e, 0x9c, 0x01, 0x3d, 0xab, 0x30, 0xe6,
0x03, 0x7f, 0x64, 0x92, 0x7f, 0x2a, 0x06, 0x4c, 0x4e, 0xe5, 0x1a, 0x73, 0xa0,
0x2e, 0x35, 0x96, 0x18, 0xdf, 0x1b, 0x8b, 0x8c, 0x65, 0xc6, 0x69, 0x2a, 0xcf,
0xf8, 0xce, 0x58, 0x28, 0xf1, 0xda, 0x80, 0x20, 0xc0, 0x6b, 0x0b, 0x62, 0x44,
0xcc, 0xc8, 0x76, 0xfa, 0x0c, 0x31, 0x80, 0x09, 0xd9, 0xca, 0x64, 0x98, 0x55,
0x6c, 0xae, 0x39, 0xdb, 0x0c, 0x76, 0x0f, 0xda, 0x97, 0x67, 0xce, 0x31, 0x57,
0xb2, 0x15, 0x80, 0x85, 0x2d, 0xe5, 0x2c, 0x6f, 0x09, 0x5a, 0x3c, 0x5c, 0xbe,
0x39, 0x64, 0x39, 0xe6, 0x22, 0x96, 0x13, 0x4e, 0xb0, 0x5c, 0xa0, 0x76, 0x1e,
0x47, 0xbd, 0xe8, 0x15, 0x4a, 0xa0, 0x3e, 0xdb, 0x25, 0x6a, 0xe3, 0x31, 0xee,
0xce, 0x46, 0x83, 0xf6, 0xd1, 0xf6, 0x7b, 0xf0, 0x0e, 0x14, 0xe4, 0x43, 0x37,
0xce, 0x6b, 0xa7, 0x5e, 0x92, 0x4a, 0xcd, 0x5e, 0x5f, 0x3a, 0xcb, 0xdf, 0xfb,
0xb0, 0x57, 0xb9, 0x07, 0x51, 0x59, 0xba, 0xf6, 0xa5, 0xd8, 0x5f, 0xdc, 0x5f,
0xdd, 0x5f, 0xda, 0xdf, 0x5c, 0xda, 0x4a, 0xdf, 0xd1, 0xb4, 0x6f, 0x5c, 0x5a,
0x91, 0xe4, 0x69, 0x78, 0xfb, 0x0f, 0xf7, 0x99, 0x1b, 0x77, 0x47, 0x15, 0x98,
0xfb, 0xdc, 0x7d, 0xea, 0x8e, 0x28, 0x62, 0x20, 0x4f, 0xf1, 0xed, 0xfa, 0xb5,
0xc1, 0xb3, 0xed, 0x31, 0x82, 0x84, 0x16, 0x41, 0x42, 0x4b, 0x00, 0x08, 0xe0,
0x26, 0x8f, 0x05, 0xca, 0x79, 0xa5, 0xf9, 0x1f, 0xe7, 0xdd, 0x94, 0x7f, 0xdc,
0xf3, 0x83, 0x6f, 0x79, 0x22, 0xd8, 0x6f, 0x2c, 0x85, 0x45, 0xb1, 0x18, 0xf6,
0x84, 0x3d, 0x63, 0x03, 0xb0, 0x9e, 0x04, 0x26, 0x62, 0xfd, 0xea, 0x9f, 0xea,
0x38, 0xf6, 0x82, 0x25, 0xa5, 0xcc, 0x48, 0xa6, 0x15, 0xf0, 0x47, 0x3c, 0x84,
0x87, 0x71, 0x39, 0xc8, 0x8a, 0xc5, 0xfd, 0xf8, 0xa6, 0x27, 0x80, 0x07, 0x71,
0x0e, 0xef, 0xce, 0x70, 0xfe, 0xa3, 0xf7, 0x94, 0xab, 0xf5, 0x56, 0x7b, 0x67,
0xb5, 0xbd, 0xfa, 0x0f, 0xde, 0xcf, 0xde, 0x4f, 0xde, 0x1f, 0xfa, 0x7a, 0x6f,
0x95, 0xb7, 0xce, 0x5b, 0xe1, 0xfd, 0xe2, 0xad, 0xf1, 0xf6, 0xc0, 0x38, 0x05,
0x48, 0x63, 0x9e, 0x5a, 0xa1, 0x16, 0xa8, 0x39, 0x6a, 0x91, 0xaa, 0x04, 0xce,
0x2f, 0x03, 0x65, 0x89, 0xaa, 0x32, 0xa2, 0x88, 0x15, 0xe9, 0xa5, 0x07, 0xe8,
0x4e, 0xba, 0x87, 0xb6, 0x21, 0xdd, 0x74, 0x17, 0xdd, 0x4f, 0xff, 0xa0, 0xbf,
0xd3, 0x7d, 0xe0, 0x2b, 0x3e, 0xb3, 0x85, 0xe6, 0x62, 0xe1, 0x23, 0x5b, 0xcb,
0xd6, 0xb0, 0x95, 0xde, 0x02, 0xf3, 0x17, 0xb6, 0x9a, 0x7d, 0x67, 0x2e, 0x32,
0x7f, 0x62, 0xcf, 0x38, 0xd1, 0x72, 0xce, 0xe1, 0x60, 0xf9, 0x0e, 0xfe, 0x1a,
0x7d, 0x2f, 0x94, 0x48, 0x6f, 0xfc, 0x28, 0x15, 0x1a, 0xc4, 0x7a, 0xf1, 0x0e,
0xf8, 0x7c, 0x1b, 0xad, 0x8b, 0xd7, 0xc7, 0xbf, 0xc4, 0xbf, 0x25, 0xd4, 0x4e,
0x64, 0x49, 0xa1, 0x5c, 0x56, 0x0e, 0xab, 0x87, 0xd4, 0x59, 0xa7, 0xd9, 0xa7,
0xaf, 0xb0, 0xab, 0x41, 0x75, 0x0c, 0xb4, 0x2b, 0x8e, 0x47, 0xf0, 0x39, 0xad,
0x08, 0x58, 0xf4, 0x4d, 0xd7, 0x9a, 0xbc, 0x5f, 0xbd, 0x0d, 0xde, 0x66, 0x6f,
0x9f, 0xbe, 0xd1, 0xdb, 0x2f, 0xed, 0x6f, 0xf0, 0xba, 0xc6, 0x58, 0x0d, 0xeb,
0xfd, 0x00, 0xb0, 0x4a, 0x29, 0x25, 0xad, 0x1a, 0xa4, 0x87, 0x69, 0x17, 0x62,
0x07, 0x1d, 0x71, 0x22, 0x0e, 0x64, 0x88, 0xfe, 0x49, 0xff, 0x71, 0x26, 0x8b,
0x6d, 0x64, 0x9b, 0xd8, 0x52, 0x73, 0x33, 0x5b, 0xc7, 0xd6, 0xb3, 0xc5, 0xe9,
0xa7, 0x36, 0x99, 0x1b, 0xd8, 0x92, 0xf4, 0x33, 0xbd, 0x60, 0xb5, 0x5e, 0xee,
0x92, 0xbb, 0xe2, 0xa2, 0x96, 0x0b, 0xee, 0x8f, 0xab, 0xf0, 0xbc, 0x93, 0xdf,
0xe1, 0x29, 0x74, 0x9f, 0x27, 0xd1, 0x5d, 0xfe, 0x80, 0xdf, 0xe3, 0x5d, 0xfc,
0x0d, 0x44, 0xfd, 0x72, 0xd8, 0x53, 0x85, 0x50, 0x06, 0x65, 0x95, 0x70, 0x6f,
0x7b, 0xb0, 0x35, 0x89, 0x8c, 0xbd, 0x52, 0x68, 0x14, 0x1f, 0xec, 0xf7, 0xd1,
0x87, 0xa8, 0xc5, 0x41, 0xc3, 0x3e, 0x7d, 0x00, 0x0d, 0xf1, 0x42, 0xc8, 0xa2,
0x8a, 0x92, 0xbf, 0x92, 0x3b, 0xe0, 0xb3, 0x72, 0x5d, 0x0d, 0xae, 0xdd, 0xe4,
0x00, 0x44, 0x8e, 0x3e, 0xd7, 0xf6, 0x52, 0x1c, 0xb4, 0xe3, 0x23, 0xac, 0xdc,
0xea, 0x30, 0x2d, 0xad, 0x28, 0xe7, 0xb5, 0x03, 0x7a, 0xc6, 0x96, 0x00, 0x1a,
0xea, 0xb1, 0x7a, 0x72, 0x4e, 0xc1, 0x47, 0xab, 0x47, 0xd4, 0x13, 0xea, 0x3c,
0xc0, 0xc6, 0xd5, 0xa3, 0x6f, 0xd6, 0x9a, 0x7b, 0xba, 0xa4, 0x7d, 0x06, 0x9e,
0x2c, 0x6a, 0x97, 0xb5, 0x39, 0x17, 0x2b, 0xda, 0x57, 0x3c, 0xeb, 0x22, 0x81,
0x2b, 0xb4, 0xb9, 0xd2, 0xbb, 0x62, 0x52, 0xd0, 0xf3, 0x84, 0x27, 0xf1, 0x05,
0xd0, 0x87, 0xec, 0x8b, 0xdf, 0xf8, 0x4b, 0x86, 0x7b, 0x3d, 0x60, 0x9b, 0xdd,
0xde, 0x2e, 0x6f, 0x8b, 0x77, 0xc0, 0xdb, 0xee, 0xed, 0xf3, 0x8e, 0x78, 0x7b,
0xbd, 0xe3, 0xc0, 0xc3, 0x61, 0x7d, 0x2b, 0xf4, 0x74, 0x7a, 0x47, 0xd3, 0xd6,
0xea, 0x1d, 0xd3, 0x4f, 0xe8, 0x7f, 0x40, 0xfb, 0xa7, 0x7e, 0x50, 0x3f, 0xea,
0x1d, 0x06, 0x6c, 0xc8, 0xfb, 0x2d, 0xdd, 0x06, 0x18, 0xd1, 0xbf, 0xfd, 0x7f,
0x5d, 0x3f, 0xe8, 0x6d, 0xf3, 0x76, 0x78, 0xfb, 0xff, 0x78, 0xc7, 0xea, 0x16,
0xbd, 0x09, 0xdc, 0x57, 0x53, 0x76, 0xea, 0x80, 0xd2, 0x52, 0x5f, 0xd3, 0xbb,
0xa2, 0x6a, 0x8d, 0x9f, 0x8d, 0xed, 0xc6, 0x75, 0x49, 0x2a, 0x5f, 0x8c, 0xf5,
0xc6, 0x6f, 0xc6, 0xba, 0xb7, 0x37, 0xa5, 0xb6, 0x19, 0x8d, 0xe9, 0xcc, 0x8d,
0x6a, 0x31, 0x1a, 0xa8, 0x46, 0xe3, 0x1e, 0xd5, 0x6a, 0xfc, 0x45, 0x6d, 0x53,
0x2e, 0xaa, 0xd9, 0xa8, 0xa2, 0x76, 0x29, 0x07, 0xf4, 0xed, 0x53, 0x9f, 0xa4,
0xd1, 0x1d, 0xc6, 0x06, 0xa9, 0xd6, 0x01, 0xcd, 0x44, 0xa1, 0x50, 0x3a, 0xa9,
0x26, 0xe3, 0x06, 0xa5, 0xa1, 0xcc, 0x6f, 0x59, 0x0e, 0x42, 0x6d, 0x01, 0x6e,
0xa1, 0x6c, 0x50, 0xee, 0x64, 0xa8, 0x63, 0x20, 0xf7, 0x1d, 0x64, 0x8e, 0x9e,
0xa0, 0x0f, 0x10, 0x0f, 0xa2, 0xa4, 0x75, 0xf4, 0x02, 0xfd, 0x0b, 0xb4, 0x42,
0x41, 0xeb, 0x61, 0xc4, 0x2e, 0xb2, 0x4e, 0xeb, 0xe9, 0x35, 0x18, 0xa3, 0xa6,
0x8d, 0xb4, 0x86, 0x9e, 0xa1, 0x97, 0x25, 0x3d, 0x39, 0x86, 0x11, 0x6e, 0x64,
0x8a, 0x5e, 0xa1, 0xf7, 0x91, 0x79, 0x7a, 0x0f, 0xd1, 0xd2, 0x72, 0x7a, 0x9c,
0x3e, 0x44, 0x0c, 0x52, 0xef, 0x24, 0xad, 0xa2, 0x57, 0xe9, 0x45, 0x7a, 0x94,
0x1e, 0xa1, 0x65, 0xf4, 0x06, 0x7d, 0x84, 0x6c, 0xd2, 0xd3, 0xf4, 0x2c, 0x5d,
0xf5, 0xc7, 0x53, 0xec, 0xbf, 0x98, 0x6b, 0xcc, 0x73, 0xac, 0x8c, 0xed, 0x60,
0x2b, 0x32, 0xd4, 0x72, 0xf3, 0xc7, 0x0c, 0xd6, 0xce, 0x56, 0x9b, 0x07, 0xd8,
0x56, 0xb6, 0x8d, 0x2d, 0x33, 0xcf, 0xb2, 0x9f, 0xcc, 0x43, 0xec, 0x38, 0x3b,
0xc8, 0xf2, 0x5c, 0x1f, 0x3b, 0xca, 0x0e, 0xb3, 0xdf, 0xd9, 0x16, 0x76, 0x9a,
0xad, 0x35, 0xcf, 0x80, 0x17, 0x1b, 0x03, 0xe8, 0x61, 0x7f, 0xb0, 0xdf, 0xd8,
0xcc, 0xbd, 0x6a, 0xec, 0x24, 0xdb, 0xc5, 0x4e, 0xb0, 0x72, 0xa9, 0xfd, 0x01,
0xe6, 0x1b, 0x61, 0xa7, 0xd8, 0x9f, 0x6c, 0x37, 0x5b, 0x99, 0x99, 0x7b, 0x89,
0xee, 0x67, 0x3f, 0x9b, 0x3b, 0xd9, 0x3f, 0xae, 0x44, 0x70, 0x09, 0x8b, 0xc8,
0x85, 0xb9, 0xbc, 0xc0, 0x6f, 0x88, 0x53, 0xd9, 0x81, 0x24, 0x97, 0x1b, 0x78,
0xe4, 0xe2, 0xa0, 0xdd, 0x2f, 0xe9, 0x1c, 0x0c, 0x6a, 0x92, 0xcb, 0x09, 0x40,
0x5c, 0x0b, 0xbc, 0x72, 0x41, 0x2e, 0xc0, 0xdd, 0x71, 0x59, 0xe9, 0x27, 0x98,
0x71, 0x11, 0xee, 0x85, 0xcb, 0xb5, 0xe6, 0x43, 0x0f, 0x8b, 0xe6, 0x5b, 0x5f,
0x2d, 0x0f, 0x30, 0x32, 0xc4, 0xdd, 0x70, 0x14, 0x17, 0xb3, 0xe4, 0x58, 0x9f,
0x2c, 0x0c, 0x97, 0xe0, 0x04, 0x2e, 0xdb, 0x7a, 0xcd, 0xf9, 0xd0, 0x14, 0xf7,
0xcc, 0x3d, 0xa7, 0x23, 0x21, 0x97, 0x67, 0x4d, 0x65, 0xa2, 0x61, 0xd2, 0x12,
0xe3, 0x7e, 0x73, 0x71, 0x68, 0xd1, 0xdc, 0x93, 0x64, 0x4b, 0xf7, 0xdc, 0xbf,
0x46, 0x43, 0x3f, 0x77, 0x02, 0xd9, 0x00, 0xce, 0xdf, 0xa3, 0x0c, 0x7a, 0xcd,
0xdf, 0xa2, 0x01, 0xde, 0xc7, 0x5f, 0xf0, 0x97, 0xfc, 0x1d, 0x50, 0x79, 0xf4,
0x96, 0x3f, 0xe6, 0x29, 0xfe, 0x94, 0x0f, 0xf2, 0x41, 0x94, 0x43, 0xcf, 0x80,
0xc6, 0x02, 0x5c, 0xf1, 0x0c, 0x94, 0x8f, 0xbc, 0x87, 0x7f, 0x00, 0x1b, 0xf4,
0x4b, 0xd9, 0xe2, 0x0d, 0x94, 0x7e, 0x94, 0x90, 0xf0, 0x00, 0x4a, 0x67, 0xce,
0x0a, 0xd3, 0xe8, 0x39, 0x7f, 0x0f, 0x38, 0xc9, 0xfb, 0xb8, 0x07, 0x1e, 0x4b,
0x7f, 0x0b, 0xbe, 0xc1, 0x41, 0x7d, 0x87, 0x1e, 0xbe, 0x9d, 0x39, 0x6e, 0x16,
0x3e, 0x0b, 0x8f, 0x10, 0x03, 0xaa, 0x85, 0x56, 0xa1, 0x4e, 0xf0, 0x02, 0xbd,
0x5d, 0xa8, 0x01, 0x9b, 0x66, 0x6d, 0x4d, 0x82, 0xdf, 0x16, 0xb1, 0x85, 0x6d,
0x5f, 0x05, 0xc1, 0x56, 0x0b, 0x94, 0x4f, 0x42, 0x83, 0xd0, 0x02, 0xb5, 0x9b,
0xe7, 0x6c, 0x5d, 0x42, 0x87, 0xf0, 0x43, 0x68, 0x14, 0xbe, 0x08, 0xdf, 0x85,
0x2e, 0xb1, 0x1e, 0xa8, 0x3c, 0xcc, 0x11, 0xb4, 0x1d, 0xf1, 0x21, 0x5b, 0x9b,
0xf0, 0x4d, 0x08, 0xd8, 0x3a, 0x85, 0x0f, 0x40, 0xfd, 0x28, 0xfc, 0xcb, 0xb5,
0x47, 0xc8, 0x0b, 0x5a, 0x45, 0xce, 0x3e, 0x20, 0xe5, 0x07, 0x5f, 0xc5, 0x00,
0x44, 0x9e, 0x6e, 0xc0, 0xbf, 0x8b, 0x82, 0xfd, 0xa7, 0xd8, 0x22, 0xb6, 0x8b,
0x8f, 0xf6, 0x21, 0x68, 0xf7, 0x88, 0xfd, 0x62, 0xc8, 0x1e, 0xb5, 0x47, 0xec,
0x9d, 0x62, 0x1b, 0xb4, 0x83, 0x76, 0xde, 0xde, 0x2c, 0xfa, 0x61, 0x34, 0x6b,
0x0f, 0xdb, 0xfb, 0x44, 0x11, 0xb0, 0x1f, 0xe2, 0xb0, 0x18, 0xcb, 0xe4, 0xb5,
0x1d, 0x30, 0xa6, 0xf7, 0x6f, 0x39, 0x87, 0x18, 0xcd, 0x89, 0xc5, 0xa2, 0xcf,
0xd1, 0x6f, 0xe2, 0x53, 0xf4, 0x31, 0x9a, 0x15, 0xb3, 0x3b, 0x82, 0xd1, 0xd7,
0x68, 0x54, 0x3a, 0x1f, 0x60, 0x93, 0x8e, 0xf6, 0xf3, 0x62, 0x71, 0x68, 0xfd,
0x8e, 0xbe, 0x44, 0x99, 0x68, 0x76, 0x2c, 0x12, 0x4d, 0x44, 0xb9, 0x68, 0x28,
0x9a, 0x1b, 0x4b, 0x45, 0xd9, 0x68, 0x20, 0xca, 0x47, 0x93, 0xd0, 0x8b, 0x3a,
0x84, 0xe8, 0xdf, 0x64, 0x16, 0xfd, 0xfb, 0x7e, 0xc2, 0xd1, 0xaf, 0xf1, 0x6f,
0xf1, 0x72, 0xe7, 0x77, 0xc8, 0xd0, 0x8a, 0xc0, 0xcf, 0xb5, 0xc5, 0xbb, 0xe2,
0x65, 0xce, 0x62, 0xc0, 0xde, 0x3b, 0x9b, 0xe3, 0x1d, 0xf1, 0x52, 0x67, 0x7b,
0xbc, 0xc4, 0xd9, 0x14, 0x6f, 0x8d, 0xb7, 0xc0, 0x88, 0xc6, 0x78, 0x67, 0xe6,
0x19, 0x7e, 0xeb, 0xce, 0x9e, 0x44, 0x7f, 0xa2, 0x3b, 0xd1, 0x9b, 0xe8, 0x4b,
0x74, 0x26, 0xba, 0x12, 0x1d, 0x52, 0x8e, 0xfd, 0x23, 0xf1, 0x3d, 0xa1, 0x71,
0x6a, 0xa5, 0xbb, 0xac, 0xdf, 0x83, 0xb7, 0x2c, 0xfd, 0x23, 0xcb, 0x2b, 0x49,
0x96, 0x41, 0x8b, 0x82, 0xbe, 0xe2, 0x24, 0xe9, 0xbc, 0x75, 0x66, 0xce, 0x25,
0x26, 0x0f, 0x92, 0x79, 0xae, 0x3d, 0xe8, 0xf9, 0x90, 0xaa, 0x4a, 0x55, 0xa7,
0x9a, 0x5c, 0x35, 0xa9, 0x46, 0xd7, 0xc7, 0xd4, 0xcf, 0xd4, 0x70, 0x6a, 0x28,
0xf5, 0xdd, 0x35, 0x98, 0xca, 0xfc, 0xf7, 0xd1, 0xd5, 0xef, 0x1a, 0x70, 0x8d,
0xba, 0xac, 0x29, 0x34, 0x65, 0x49, 0xed, 0xa6, 0x92, 0x52, 0x5c, 0xce, 0xbb,
0x18, 0xf3, 0xce, 0xb3, 0x23, 0x12, 0xdf, 0x52, 0x40, 0x59, 0x55, 0x4e, 0x4a,
0x5e, 0x36, 0x1f, 0x3c, 0xe9, 0xbb, 0x8b, 0x55, 0xf0, 0xa0, 0xd3, 0xfa, 0x09,
0xef, 0xb8, 0x77, 0x56, 0x3f, 0xa5, 0x9f, 0xf4, 0xce, 0xe8, 0xe5, 0x7a, 0x99,
0x7e, 0x32, 0xe3, 0x05, 0xbf, 0x4b, 0x3e, 0xc9, 0x43, 0x1d, 0x82, 0x2f, 0x39,
0xa2, 0xdc, 0x50, 0x9e, 0x80, 0xe7, 0x38, 0x43, 0x70, 0xe4, 0x5c, 0xca, 0x4e,
0x30, 0xe4, 0x14, 0xea, 0x45, 0x76, 0x81, 0xad, 0x33, 0x2f, 0x81, 0x4d, 0x2e,
0xb3, 0xf5, 0x19, 0x3b, 0x2d, 0x0d, 0xbc, 0x0f, 0x88, 0xa0, 0x69, 0x45, 0x81,
0xe2, 0xc0, 0x3b, 0xeb, 0xbb, 0x40, 0x59, 0xa0, 0x30, 0x50, 0x12, 0x08, 0x49,
0x3a, 0x29, 0xa4, 0xcf, 0x39, 0xf0, 0x22, 0xca, 0xf3, 0x11, 0x34, 0xcc, 0x87,
0xd0, 0x30, 0x2a, 0xa0, 0x05, 0xd2, 0x53, 0x1f, 0x63, 0xb6, 0x5e, 0xa1, 0x5b,
0xe8, 0x11, 0x44, 0x5b, 0xdc, 0x16, 0xcd, 0x9c, 0x23, 0x19, 0x15, 0xc7, 0xc4,
0x38, 0x68, 0x40, 0x7e, 0xac, 0x20, 0xf6, 0x2e, 0xe6, 0x70, 0x54, 0x38, 0x7b,
0xe2, 0xdd, 0xf1, 0x1f, 0xf1, 0x27, 0xd8, 0x8b, 0x62, 0x17, 0x74, 0x76, 0xef,
0x71, 0xe1, 0xe3, 0xde, 0xe7, 0xbd, 0xda, 0xcc, 0xbd, 0x3c, 0x6b, 0x90, 0xaf,
0xa0, 0x90, 0xad, 0xd8, 0x96, 0xd4, 0xfb, 0x96, 0x25, 0xd5, 0xbe, 0x72, 0xdf,
0xba, 0x64, 0x5e, 0xfa, 0xdb, 0x93, 0x52, 0xdd, 0x84, 0xfb, 0x45, 0x71, 0xe5,
0xbe, 0x84, 0xcc, 0xf3, 0x59, 0xf1, 0x1b, 0xe6, 0xc9, 0x5a, 0xf1, 0xba, 0x5f,
0xff, 0xb8, 0x0b, 0xcf, 0xe5, 0x59, 0x53, 0xaa, 0x94, 0x6a, 0xe5, 0x8e, 0xc7,
0xee, 0x51, 0x2a, 0x1d, 0x90, 0xb9, 0x38, 0x3d, 0xb6, 0xcc, 0x55, 0x88, 0x39,
0x89, 0x7b, 0x32, 0x75, 0xfe, 0xa9, 0x5c, 0x3d, 0xaf, 0x7e, 0x07, 0x71, 0x6b,
0x46, 0x3d, 0xa5, 0x9e, 0x56, 0xcf, 0xfe, 0x71, 0x74, 0xa4, 0xd4, 0x16, 0x5d,
0xe8, 0xb4, 0x85, 0xe9, 0x37, 0xfc, 0x5d, 0xac, 0x6b, 0x8b, 0x2f, 0x56, 0xf4,
0x2a, 0xad, 0x46, 0xbb, 0xa6, 0xd5, 0x6a, 0x37, 0xb4, 0xea, 0xcc, 0xf9, 0xe4,
0x82, 0x8b, 0x45, 0xfd, 0x34, 0xc4, 0x96, 0x59, 0x29, 0xbe, 0xc8, 0xbd, 0xab,
0xfa, 0x25, 0xfd, 0xb2, 0x7e, 0xca, 0x3b, 0xe3, 0x95, 0x79, 0xe7, 0xf4, 0x0b,
0xe9, 0x8c, 0x45, 0x3f, 0x2f, 0xc9, 0x01, 0xa3, 0x8e, 0xa9, 0x13, 0xaa, 0xcb,
0xf8, 0x03, 0xa4, 0x71, 0x4a, 0x75, 0x1a, 0x2f, 0x80, 0xe7, 0x57, 0xc8, 0x25,
0x94, 0x88, 0xe4, 0xaf, 0xb7, 0xe9, 0x15, 0xe0, 0xbd, 0x42, 0xf2, 0x89, 0x05,
0xd6, 0x42, 0x6b, 0x79, 0xa0, 0x08, 0x3c, 0x5c, 0x1c, 0xb8, 0x1c, 0x05, 0x88,
0xf1, 0x51, 0xf0, 0x09, 0x7d, 0x42, 0x22, 0x63, 0x45, 0x31, 0x34, 0x7b, 0x05,
0xf2, 0x30, 0x75, 0x81, 0xf4, 0xd6, 0xbd, 0x92, 0x0b, 0xbd, 0x56, 0xa9, 0x9f,
0xf3, 0x2e, 0x78, 0x55, 0xfa, 0x35, 0xbd, 0x5a, 0xbf, 0xae, 0x9f, 0xf7, 0xf6,
0x1a, 0xfb, 0x8c, 0x3d, 0x46, 0x02, 0xe9, 0x36, 0x9e, 0x65, 0xa2, 0x8c, 0x17,
0x59, 0x65, 0x2b, 0x02, 0xc5, 0xd6, 0x38, 0xda, 0x2f, 0x0c, 0x09, 0x29, 0xdb,
0x80, 0xf0, 0x64, 0x4b, 0xda, 0x86, 0x85, 0xdf, 0xb6, 0x41, 0xb0, 0xfe, 0x71,
0x31, 0x61, 0x4b, 0xa6, 0xaf, 0x49, 0x4b, 0x9a, 0x9c, 0xb3, 0x62, 0xd0, 0x6e,
0xbe, 0xbd, 0x51, 0x5a, 0xa3, 0x5f, 0xf2, 0x2e, 0x7a, 0xb5, 0xd2, 0x3e, 0x2e,
0xa9, 0x41, 0x63, 0xbf, 0xf1, 0x82, 0xfa, 0x69, 0x3c, 0xa7, 0x06, 0x60, 0x2f,
0x78, 0x3a, 0xd6, 0xd1, 0xd7, 0xb0, 0x0f, 0x15, 0xac, 0xbd, 0xc1, 0xac, 0x64,
0x1b, 0xcd, 0x4d, 0xe6, 0x35, 0xb6, 0x19, 0x74, 0xa8, 0x12, 0xf4, 0xa1, 0xcc,
0xfa, 0xde, 0x5a, 0x61, 0xfd, 0x10, 0x28, 0xb1, 0x56, 0x05, 0xca, 0xa5, 0xff,
0x29, 0x97, 0x42, 0x99, 0xe2, 0x7f, 0x4b, 0x5a, 0x94, 0x40, 0x9f, 0xf8, 0x24,
0x9a, 0xe4, 0x13, 0xd0, 0x1a, 0x15, 0x46, 0x84, 0x67, 0xdb, 0x98, 0x30, 0x23,
0x3e, 0xd9, 0xa7, 0xc5, 0x09, 0x31, 0x65, 0x9f, 0x14, 0xa7, 0x40, 0xe3, 0x0b,
0x63, 0x45, 0x31, 0x27, 0xf8, 0x81, 0x0f, 0x92, 0x25, 0xf5, 0x4a, 0x76, 0x59,
0xe9, 0xac, 0x72, 0xf6, 0x49, 0xd8, 0x86, 0x53, 0xe7, 0x1c, 0x90, 0x6c, 0x32,
0xdf, 0x75, 0x94, 0x2c, 0x80, 0x63, 0xde, 0xc3, 0xa4, 0x27, 0xf9, 0xce, 0x55,
0x0b, 0xf6, 0xa4, 0x4c, 0xfd, 0xa9, 0x31, 0xb9, 0x99, 0xb7, 0x65, 0x0c, 0xc1,
0xaa, 0xcd, 0xe9, 0x68, 0xca, 0x56, 0x5a, 0xab, 0x60, 0x2d, 0x79, 0xe9, 0x77,
0xd7, 0x9a, 0x7f, 0xdb, 0xd7, 0x33, 0x59, 0xed, 0x07, 0xa0, 0xdd, 0x39, 0x35,
0xca, 0x52, 0x90, 0xfc, 0x32, 0xc8, 0x75, 0x05, 0x40, 0x01, 0x70, 0x4d, 0x5d,
0x51, 0xc3, 0xf0, 0xdd, 0x11, 0x23, 0x41, 0x79, 0x61, 0xd7, 0x56, 0xda, 0x49,
0xdf, 0x20, 0x16, 0x1a, 0xa5, 0x7f, 0xd1, 0x76, 0x7a, 0x87, 0x76, 0xd0, 0x36,
0xda, 0x45, 0x93, 0x92, 0x4d, 0x69, 0x81, 0x17, 0xeb, 0x6c, 0x2b, 0xf0, 0xa0,
0xc5, 0xac, 0x61, 0xdb, 0xde, 0x62, 0xee, 0x47, 0xc9, 0x42, 0x6a, 0x02, 0xd5,
0xd6, 0xea, 0xc0, 0x33, 0xec, 0xf9, 0x95, 0xcf, 0x0e, 0x65, 0x85, 0x80, 0x1f,
0xe8, 0x0b, 0x2f, 0x13, 0x5e, 0x6c, 0xd3, 0x82, 0x5c, 0x78, 0x05, 0x9b, 0x99,
0x04, 0x89, 0xcc, 0x08, 0x53, 0xc2, 0xb8, 0x90, 0x65, 0x9f, 0x78, 0xf3, 0xcd,
0x32, 0xc9, 0xfe, 0x67, 0x45, 0x39, 0xd4, 0xc5, 0x31, 0xd0, 0xcb, 0xcc, 0x7f,
0x07, 0xfb, 0xd3, 0xff, 0x9e, 0x03, 0xee, 0xe8, 0x9d, 0xe5, 0xc9, 0x8a, 0x64,
0xa1, 0xeb, 0x18, 0x64, 0xd8, 0x09, 0x9c, 0xd0, 0x2a, 0x37, 0xf4, 0x7b, 0xf4,
0x2e, 0xad, 0x63, 0x37, 0x24, 0xbd, 0x7a, 0x42, 0x73, 0x43, 0x39, 0xa1, 0x79,
0x61, 0x56, 0x58, 0x10, 0xe6, 0xa4, 0x59, 0x9f, 0xed, 0x73, 0xe2, 0xbc, 0xb8,
0x00, 0xf3, 0x0d, 0xc0, 0x1c, 0x3f, 0x81, 0x8f, 0x27, 0xff, 0x74, 0xbc, 0xba,
0x21, 0x71, 0xa5, 0x36, 0x90, 0x07, 0xab, 0xd4, 0x49, 0x38, 0x05, 0x3b, 0xfc,
0x14, 0xc8, 0xb6, 0x2f, 0x0a, 0x2f, 0xe9, 0xa7, 0xa5, 0xc6, 0x4a, 0x63, 0xd5,
0xce, 0xca, 0xa4, 0x5e, 0x89, 0x68, 0xb7, 0xb5, 0x65, 0x17, 0x3a, 0xbd, 0x5e,
0xbf, 0xea, 0xdd, 0x04, 0x5d, 0x99, 0x00, 0x5e, 0x4d, 0x19, 0x49, 0x8a, 0xa2,
0x6e, 0xa8, 0x51, 0xe3, 0x98, 0x71, 0xd2, 0x38, 0x2e, 0x79, 0xa2, 0x7d, 0xfa,
0x16, 0xb9, 0x93, 0xb8, 0xb4, 0xcd, 0x76, 0x98, 0x37, 0x59, 0x3d, 0xac, 0x0d,
0x61, 0xdb, 0x25, 0x1e, 0xd5, 0x01, 0xef, 0x0d, 0xac, 0x89, 0xdd, 0x62, 0x8d,
0x40, 0xfd, 0x06, 0xb4, 0xcf, 0x40, 0xf9, 0x12, 0xa8, 0x81, 0xb2, 0x4e, 0xe2,
0xdd, 0x67, 0x28, 0x3f, 0x59, 0x3f, 0x5a, 0xbf, 0x00, 0xa5, 0xd6, 0xfa, 0xef,
0xeb, 0xcc, 0x4f, 0x3f, 0x99, 0x3f, 0xf4, 0x2e, 0x54, 0x14, 0xfa, 0x0d, 0x96,
0x72, 0x1a, 0x2c, 0x0c, 0x15, 0x00, 0x25, 0xcf, 0x9e, 0x63, 0xcf, 0xb7, 0xe7,
0xda, 0x97, 0x84, 0x65, 0x41, 0x21, 0xbc, 0xcb, 0x58, 0x8f, 0x42, 0xcc, 0x72,
0x2c, 0xc1, 0x9e, 0xb3, 0x1d, 0x8b, 0xe2, 0xb2, 0xf8, 0x6a, 0xaf, 0x8c, 0x95,
0x01, 0x27, 0xcb, 0x63, 0x15, 0xb1, 0x9f, 0xf1, 0x8f, 0xc0, 0xc7, 0x1a, 0x80,
0xa1, 0xc4, 0x60, 0xc2, 0x90, 0xf1, 0xdd, 0x3e, 0x67, 0x91, 0xab, 0xd9, 0xf5,
0x29, 0xb5, 0x96, 0x52, 0xa5, 0xfe, 0x6b, 0x8e, 0xe3, 0x37, 0x95, 0x4a, 0xc9,
0xa3, 0xdc, 0x52, 0x07, 0xb4, 0x9b, 0xf6, 0x01, 0xb7, 0x68, 0xc4, 0xcc, 0x7e,
0x97, 0x78, 0xf4, 0x0c, 0xfb, 0x5b, 0x01, 0xe9, 0x15, 0xd8, 0x95, 0x62, 0x8e,
0x63, 0x55, 0x5c, 0x13, 0x57, 0xc4, 0xe1, 0x78, 0x55, 0xec, 0x03, 0xec, 0xc1,
0x05, 0x76, 0x32, 0x24, 0xd9, 0xc5, 0x20, 0x94, 0xc3, 0x09, 0xf5, 0x7f, 0xba,
0x5e, 0x43, 0x46, 0xe3, 0x8d, 0x52, 0xbd, 0xa8, 0x2e, 0x04, 0x6f, 0x52, 0x9e,
0x7e, 0xf7, 0x2e, 0x48, 0x0f, 0xd1, 0x1b, 0xf5, 0x6b, 0xb0, 0x06, 0x13, 0xe0,
0x5b, 0x92, 0xe5, 0x6f, 0x43, 0x39, 0x03, 0x12, 0xbc, 0x93, 0xfc, 0x89, 0x8f,
0xb2, 0x82, 0x84, 0xa6, 0x8d, 0x32, 0xa3, 0xdc, 0x78, 0x04, 0xd6, 0x74, 0x48,
0xdf, 0xc3, 0x2a, 0x1f, 0x00, 0x3c, 0xb4, 0x85, 0x65, 0x91, 0x4e, 0x58, 0x2b,
0x93, 0x39, 0xfa, 0xad, 0xb7, 0xa2, 0xec, 0x0f, 0x73, 0x97, 0xd9, 0xc6, 0x3a,
0x59, 0x3b, 0xeb, 0x60, 0xbb, 0xa1, 0xef, 0xab, 0xb5, 0x49, 0x92, 0x5e, 0xa3,
0xb5, 0x01, 0x24, 0xda, 0x2c, 0xe1, 0xf5, 0x81, 0xf7, 0x20, 0xb3, 0xc6, 0x40,
0x83, 0xb5, 0x29, 0x50, 0x16, 0x2a, 0x09, 0x95, 0x86, 0xaa, 0x42, 0xef, 0xed,
0x95, 0xa1, 0xea, 0xd0, 0x87, 0x50, 0x45, 0xa8, 0x1c, 0xfa, 0x5e, 0xde, 0xee,
0xc5, 0x59, 0x03, 0x0e, 0x28, 0x85, 0x62, 0x7b, 0xa1, 0xbd, 0x28, 0xfd, 0xcf,
0x46, 0x68, 0xad, 0x83, 0x44, 0x73, 0x61, 0xff, 0x6a, 0x51, 0x25, 0xe6, 0x41,
0xfd, 0x29, 0x56, 0x0b, 0x1c, 0xa9, 0x01, 0xa8, 0x8e, 0xfd, 0x72, 0xec, 0x38,
0x3e, 0xc7, 0x46, 0x12, 0x46, 0xe7, 0x68, 0xbc, 0xd6, 0x39, 0x12, 0xff, 0x08,
0xd4, 0xd1, 0x04, 0x0d, 0xf2, 0xfd, 0xea, 0xfa, 0x0c, 0x3c, 0x5a, 0x4f, 0xfd,
0x57, 0x9d, 0xa1, 0xd9, 0x52, 0x56, 0x5c, 0xd4, 0x84, 0x10, 0x89, 0xe3, 0x27,
0xf4, 0x31, 0xdd, 0x2c, 0x69, 0x75, 0x2d, 0xec, 0xed, 0x23, 0x40, 0x89, 0x5d,
0x23, 0x6a, 0xc5, 0x5d, 0x29, 0xeb, 0xd1, 0xa4, 0x96, 0xd4, 0x16, 0xbd, 0x59,
0x4f, 0x53, 0x0f, 0xd4, 0x9c, 0xf1, 0x9e, 0x9a, 0x35, 0xce, 0x1b, 0x99, 0x8c,
0x2f, 0x3f, 0xa5, 0xcf, 0xe9, 0x33, 0xe0, 0xfa, 0x45, 0xe6, 0x88, 0xf1, 0x11,
0xc1, 0x69, 0x2c, 0x83, 0x5f, 0x42, 0x7d, 0x00, 0xb2, 0x39, 0x62, 0x8f, 0xd9,
0x1d, 0x76, 0x9f, 0xfd, 0xc5, 0xf6, 0x9a, 0x07, 0xcc, 0x83, 0xe6, 0x5d, 0x76,
0x8f, 0xfd, 0x69, 0x76, 0xb3, 0x1e, 0xf6, 0x90, 0x1d, 0x02, 0x09, 0xf4, 0x9b,
0x5d, 0x6c, 0x0f, 0xd4, 0x7d, 0x92, 0x56, 0xb5, 0x5a, 0xbf, 0x05, 0xda, 0x02,
0xad, 0xb0, 0x9a, 0x4e, 0x80, 0xef, 0x81, 0x0e, 0x28, 0x5b, 0x02, 0x2d, 0xd6,
0xaf, 0x50, 0xb7, 0x07, 0xda, 0x24, 0xf9, 0x7c, 0x49, 0x4b, 0x27, 0x54, 0x17,
0x6a, 0x08, 0xd5, 0x87, 0x3e, 0x87, 0x9a, 0x42, 0x2d, 0xa1, 0xe6, 0xd0, 0xd7,
0x50, 0x96, 0xed, 0x15, 0xfd, 0x14, 0x6a, 0x0d, 0x69, 0x05, 0xbd, 0x60, 0x10,
0x36, 0xd3, 0x92, 0x10, 0x74, 0x82, 0x1a, 0x6a, 0x8d, 0x50, 0x6a, 0x57, 0x41,
0xbd, 0x21, 0xf9, 0x1a, 0xab, 0xa8, 0x13, 0xf3, 0xa5, 0x9d, 0xbd, 0x73, 0x6c,
0x88, 0x46, 0xd1, 0x22, 0x6e, 0x8a, 0x66, 0x90, 0x19, 0x02, 0xb0, 0x25, 0x9a,
0x44, 0x83, 0xa8, 0x07, 0x6c, 0x1b, 0xa0, 0x39, 0xd6, 0x18, 0xdb, 0x73, 0x34,
0xc4, 0x5a, 0x63, 0x5f, 0x41, 0x4e, 0xfb, 0x8e, 0xfa, 0xd8, 0x17, 0xa8, 0xeb,
0x62, 0x6e, 0x47, 0x53, 0xec, 0xc0, 0xd1, 0x12, 0x1b, 0x8b, 0xcf, 0x48, 0x3a,
0x3e, 0x1e, 0xaf, 0x73, 0xca, 0xe2, 0x5f, 0x9c, 0xd3, 0xf1, 0xa9, 0xf8, 0x67,
0xe7, 0x64, 0xfc, 0x93, 0x73, 0x02, 0xe8, 0xd3, 0x09, 0x59, 0x62, 0x06, 0x3c,
0xd9, 0x64, 0x02, 0x71, 0x8e, 0x25, 0xa6, 0x12, 0xb3, 0x80, 0xcb, 0x13, 0xe3,
0x89, 0x89, 0xc4, 0x96, 0xb3, 0x2a, 0xc9, 0x80, 0xcc, 0x3f, 0x24, 0xef, 0x9d,
0x0f, 0xff, 0xf8, 0x87, 0x5c, 0xb2, 0xd8, 0x35, 0x02, 0xb2, 0xef, 0x4a, 0x7b,
0xcb, 0xd4, 0x0f, 0xd7, 0x46, 0x4a, 0x97, 0xb2, 0xa7, 0x6c, 0xa9, 0x09, 0x97,
0x3b, 0xf5, 0xd7, 0x7f, 0xd3, 0x67, 0x59, 0xca, 0x41, 0x1e, 0x41, 0xd2, 0x2c,
0x80, 0x1f, 0xe1, 0x90, 0x2b, 0x90, 0xe8, 0x09, 0xdb, 0x2d, 0x69, 0xca, 0xb0,
0xb9, 0xdd, 0xda, 0x05, 0x58, 0x4f, 0xe0, 0x1b, 0xc8, 0xa4, 0x2d, 0xf4, 0x23,
0x60, 0x14, 0xca, 0xec, 0x68, 0x26, 0xa3, 0xfe, 0x16, 0x6b, 0x93, 0x62, 0x42,
0xbb, 0x54, 0xca, 0x81, 0x1b, 0xf5, 0xce, 0xb9, 0x84, 0xdf, 0xb9, 0xed, 0x64,
0x9d, 0x8f, 0xce, 0xd3, 0x64, 0x0b, 0xec, 0x53, 0x91, 0xc9, 0x71, 0xb6, 0x24,
0xa9, 0x14, 0x81, 0xcd, 0x2f, 0xa4, 0xdf, 0x0d, 0x2f, 0x69, 0x4f, 0x00, 0xf1,
0x66, 0xb4, 0xe8, 0x94, 0xc5, 0xd8, 0xef, 0xd6, 0x11, 0xf3, 0x28, 0x68, 0x07,
0xce, 0x9e, 0xb3, 0x67, 0x52, 0x04, 0xe9, 0x0d, 0x0c, 0xc0, 0x6f, 0xf7, 0x07,
0xfa, 0x02, 0x1d, 0xd6, 0xef, 0xa1, 0x6f, 0xa1, 0xf6, 0x50, 0x07, 0xe8, 0x44,
0xb9, 0x7d, 0x5b, 0x30, 0x09, 0x15, 0x60, 0x87, 0x08, 0xcc, 0x69, 0x17, 0x6d,
0xa2, 0x53, 0x2c, 0x70, 0x38, 0x60, 0x4d, 0x1d, 0xb1, 0xce, 0xd8, 0x77, 0x69,
0x2d, 0xb3, 0xf1, 0x85, 0xf8, 0x5c, 0x7c, 0x3e, 0x3e, 0x9f, 0x30, 0x65, 0xbc,
0x6a, 0x75, 0xb2, 0x26, 0xf9, 0x11, 0xa2, 0xcd, 0x7b, 0x57, 0xab, 0x4b, 0x9f,
0x5a, 0x81, 0x55, 0x8d, 0x99, 0x3b, 0xad, 0x66, 0x98, 0x61, 0x41, 0x8a, 0xe7,
0x8e, 0x54, 0x31, 0xac, 0x6d, 0xd2, 0xb5, 0xaa, 0xfe, 0x99, 0x7e, 0xc7, 0x0e,
0xd0, 0x5d, 0xd2, 0x2e, 0xd3, 0x2f, 0xa8, 0x50, 0xc2, 0xe8, 0x6b, 0xfa, 0x06,
0xd6, 0x1a, 0x44, 0x78, 0xe4, 0x92, 0x9d, 0x30, 0x8f, 0x9b, 0x2f, 0x60, 0x85,
0x9d, 0xb0, 0x1a, 0xab, 0x60, 0x13, 0x50, 0xe1, 0x83, 0xbd, 0xca, 0x5e, 0x09,
0x2b, 0x6a, 0x74, 0x2e, 0x01, 0x17, 0x1a, 0x9c, 0xcb, 0x89, 0x25, 0x98, 0xb5,
0xc4, 0x75, 0x96, 0x34, 0x69, 0xfd, 0x19, 0x2b, 0xba, 0xa5, 0x49, 0x9a, 0x92,
0xf6, 0x7b, 0x07, 0xdf, 0xbd, 0x66, 0xaf, 0xd8, 0xdb, 0xcc, 0x31, 0xa9, 0x4f,
0xaa, 0xa7, 0xcc, 0x14, 0xeb, 0x95, 0x30, 0x82, 0x25, 0xd9, 0x1b, 0x76, 0x52,
0xb2, 0x94, 0xe9, 0xc0, 0x58, 0x60, 0x24, 0x20, 0x0b, 0x8c, 0xc2, 0xaa, 0x06,
0xd3, 0xef, 0x89, 0x93, 0xe4, 0x32, 0x14, 0xf8, 0x19, 0x1a, 0x0e, 0xc8, 0x03,
0xff, 0xf4, 0x0c, 0x88, 0x40, 0x97, 0x75, 0x32, 0x30, 0x01, 0xd4, 0x99, 0xb7,
0x9e, 0xae, 0x50, 0x8f, 0xf4, 0x0c, 0xc9, 0xee, 0xf4, 0x93, 0xe5, 0x42, 0x7d,
0xa1, 0x41, 0xa8, 0x07, 0x42, 0xfd, 0xa1, 0x5e, 0xa8, 0x7f, 0x00, 0xe4, 0xda,
0x72, 0x20, 0x03, 0xc8, 0xb3, 0x65, 0xdb, 0x86, 0xff, 0x78, 0xb7, 0xdc, 0x2f,
0x61, 0x1f, 0x38, 0xb0, 0x2b, 0xb8, 0x33, 0xd9, 0xc0, 0x61, 0x9a, 0x1f, 0xc2,
0x27, 0xfb, 0x0e, 0xd4, 0x4e, 0xe1, 0x00, 0x4a, 0x87, 0x60, 0x17, 0x6a, 0xed,
0x35, 0xf6, 0x6a, 0xfb, 0x3f, 0x6b, 0xd4, 0x9e, 0x70, 0x24, 0x9e, 0x89, 0xc5,
0x0e, 0x0f, 0xf0, 0x0f, 0x13, 0x71, 0xf1, 0xbd, 0xe3, 0x04, 0xb0, 0x3d, 0x80,
0x5d, 0xf1, 0x5c, 0x74, 0x43, 0xbd, 0x2f, 0x9e, 0x8a, 0x07, 0x62, 0x91, 0xa3,
0x10, 0xec, 0x73, 0x47, 0xfc, 0x25, 0x1e, 0x67, 0xf4, 0xe9, 0xf0, 0x6f, 0x47,
0x6a, 0xdd, 0xb1, 0xbe, 0xd8, 0x5b, 0x26, 0x63, 0xef, 0x89, 0x0d, 0xc6, 0x06,
0x62, 0x3f, 0x62, 0x23, 0x40, 0xeb, 0x02, 0x38, 0x72, 0xfc, 0xcc, 0xf4, 0xf6,
0xc6, 0x0e, 0x1d, 0xc3, 0x12, 0x3e, 0xf4, 0x36, 0x7e, 0x25, 0xae, 0xf8, 0xb7,
0x23, 0x2a, 0xa8, 0x95, 0x71, 0x75, 0xbc, 0x59, 0xd2, 0x83, 0xb5, 0xb8, 0x0a,
0xda, 0xcb, 0xf1, 0xd5, 0x78, 0x53, 0x46, 0x2f, 0x2c, 0xce, 0x8d, 0x84, 0x2a,
0xa1, 0x05, 0x69, 0xe9, 0x13, 0x1a, 0x28, 0xd7, 0x00, 0x50, 0xe7, 0x7a, 0x42,
0x97, 0xb0, 0x3a, 0x57, 0x13, 0xfd, 0x31, 0xb5, 0xa4, 0x1d, 0x4a, 0x28, 0x15,
0x00, 0x2b, 0x09, 0xb3, 0xf3, 0x4b, 0xb2, 0x3e, 0xd9, 0x94, 0xac, 0x4b, 0x36,
0x83, 0x36, 0x7d, 0x06, 0xa8, 0x05, 0xe0, 0x9c, 0x0d, 0xc9, 0xa0, 0x33, 0xe0,
0xfc, 0x94, 0x6c, 0x7c, 0xcb, 0x68, 0xae, 0x92, 0xa5, 0x2e, 0x02, 0x5a, 0x97,
0xc9, 0x73, 0x89, 0x76, 0x91, 0xc4, 0x93, 0x5f, 0xde, 0xec, 0xbc, 0x3e, 0x55,
0x27, 0xe1, 0xe3, 0x50, 0x8e, 0xa5, 0x46, 0x53, 0x13, 0x50, 0x0f, 0xba, 0x86,
0x5c, 0x7b, 0xa9, 0xc3, 0xff, 0x36, 0x5f, 0xf0, 0x7f, 0xf2, 0x63, 0xd6, 0xaa,
0xbc, 0x41, 0xb0, 0x84, 0x45, 0x23, 0x27, 0xd9, 0x43, 0x20, 0x63, 0x15, 0x77,
0xb4, 0x8f, 0x16, 0x90, 0x10, 0x42, 0xd3, 0x61, 0x84, 0x05, 0xed, 0xe7, 0xd8,
0x7b, 0x36, 0xc0, 0xd2, 0xec, 0x03, 0xe0, 0x0c, 0xeb, 0x97, 0xec, 0x41, 0x66,
0x0e, 0xb1, 0x3c, 0x3b, 0x6d, 0x7e, 0x64, 0x83, 0xec, 0xcc, 0xdf, 0xde, 0x8b,
0xb8, 0x0a, 0x7a, 0xde, 0x07, 0x9e, 0x69, 0x31, 0xf0, 0x03, 0xca, 0xb9, 0x80,
0x22, 0xa0, 0x4c, 0x7b, 0x0c, 0xc0, 0x97, 0x03, 0x0b, 0x81, 0xb5, 0xc0, 0x3c,
0xb4, 0x56, 0x02, 0xdd, 0xd0, 0x9e, 0x0d, 0xf4, 0x40, 0xd9, 0x6b, 0x5d, 0xca,
0x58, 0xc6, 0x72, 0x68, 0x22, 0x34, 0x19, 0x9a, 0x09, 0x4d, 0x81, 0xd6, 0x8f,
0x48, 0x9a, 0x3f, 0x1e, 0x9a, 0x0f, 0x4d, 0x4b, 0x58, 0x3e, 0x58, 0xc4, 0x62,
0x68, 0x2e, 0xf4, 0xce, 0xb6, 0x10, 0x1a, 0x0d, 0xc9, 0x43, 0xb3, 0x40, 0x95,
0xbd, 0x59, 0xc7, 0x89, 0x70, 0x2a, 0xe0, 0x92, 0x5d, 0x1c, 0x43, 0xf9, 0xd9,
0x7e, 0x29, 0x78, 0x84, 0x2b, 0xc0, 0xce, 0x85, 0x0b, 0xc1, 0x2b, 0x9c, 0x09,
0xd7, 0x02, 0x26, 0x1c, 0x09, 0x5f, 0xc0, 0x2e, 0x08, 0xa1, 0xce, 0x5e, 0xfa,
0xc7, 0x1d, 0xb0, 0x63, 0x21, 0x41, 0x64, 0xc5, 0x72, 0x07, 0x2d, 0x56, 0x48,
0xd4, 0xa0, 0xc8, 0x88, 0xd7, 0x62, 0x99, 0xc3, 0x2f, 0xde, 0x8b, 0x0f, 0xa0,
0xfb, 0x17, 0x22, 0x29, 0xf2, 0x50, 0x73, 0x00, 0x3e, 0x80, 0x90, 0x78, 0x23,
0x5e, 0x8a, 0x01, 0xc0, 0x08, 0xf1, 0x51, 0xa4, 0xc4, 0xb0, 0xe8, 0x15, 0x4b,
0x1c, 0x57, 0xe2, 0xad, 0x78, 0x97, 0xb1, 0x94, 0x69, 0xd0, 0xf8, 0x49, 0x00,
0x39, 0xc0, 0x5a, 0x6c, 0x3e, 0x36, 0x15, 0x1b, 0x8b, 0x2d, 0xc6, 0x66, 0x62,
0xb3, 0xb1, 0x89, 0x98, 0x22, 0x36, 0x1a, 0x93, 0xc5, 0x16, 0x62, 0x4b, 0xb1,
0x95, 0xd8, 0x38, 0xf4, 0xab, 0x62, 0xea, 0xd8, 0x72, 0x4c, 0x19, 0x9b, 0x03,
0x1c, 0x8d, 0x3b, 0xd2, 0x57, 0xf5, 0xc0, 0x06, 0xec, 0xf1, 0x5f, 0x71, 0x57,
0xbc, 0xc5, 0x69, 0x8a, 0x6b, 0xe3, 0x9a, 0x78, 0x9b, 0xd3, 0x12, 0xb7, 0xc6,
0xb7, 0xe3, 0x1b, 0xd0, 0x6b, 0x8c, 0xaf, 0xc2, 0x48, 0x5d, 0xbc, 0xd5, 0x89,
0x40, 0x6b, 0x0b, 0x40, 0x1f, 0xb7, 0xa5, 0x73, 0xff, 0x38, 0x92, 0x70, 0xc6,
0x77, 0xe2, 0xe6, 0xb8, 0x21, 0xbe, 0x9d, 0x30, 0x27, 0x0c, 0x09, 0x1b, 0xcc,
0xe3, 0x4c, 0xd8, 0x13, 0x76, 0xa7, 0x2d, 0x81, 0x26, 0xb6, 0x12, 0x9b, 0x09,
0x53, 0xc2, 0x95, 0x30, 0x26, 0x2c, 0x60, 0x31, 0x9d, 0xc9, 0xde, 0x64, 0x5b,
0xb2, 0x23, 0xc9, 0x3b, 0x7f, 0x80, 0x15, 0xfc, 0x4c, 0x5a, 0x81, 0xd6, 0x9e,
0xec, 0x4b, 0x0e, 0x26, 0xbb, 0x92, 0xad, 0xc9, 0x1e, 0xa0, 0x75, 0x27, 0x07,
0x92, 0xfd, 0x49, 0x47, 0xe2, 0x7b, 0xb2, 0x25, 0xf9, 0x2d, 0x59, 0xe6, 0x2a,
0x77, 0x7d, 0x05, 0xea, 0x43, 0xf2, 0x3a, 0x79, 0x9f, 0xbc, 0x4b, 0xfa, 0x92,
0xde, 0x24, 0x99, 0x64, 0x92, 0xb7, 0x49, 0x2a, 0x79, 0x03, 0x74, 0x1a, 0xa0,
0x01, 0x2c, 0xa4, 0x11, 0xa0, 0x39, 0xd5, 0x94, 0x6a, 0x49, 0x7d, 0x4d, 0x4d,
0xa5, 0x26, 0x53, 0x9b, 0xd0, 0x36, 0x00, 0x38, 0x53, 0x63, 0xae, 0x29, 0x88,
0x3b, 0x47, 0xa9, 0x69, 0xd7, 0xff, 0x4b, 0xf6, 0x61, 0xc9, 0x1c, 0xff, 0x7a,
0x1c, 0xbb, 0xc0, 0xe3, 0x0a, 0x57, 0x25, 0xac, 0xde, 0xaa, 0xe5, 0xd3, 0xd7,
0x1b, 0x8c, 0x61, 0xc9, 0x0a, 0xd4, 0x81, 0xf5, 0x80, 0x2a, 0xb0, 0x12, 0x52,
0x84, 0x0a, 0x6c, 0xa4, 0xb0, 0x1a, 0xba, 0x91, 0x74, 0x50, 0x14, 0x2b, 0x1d,
0x1f, 0x1c, 0x11, 0x49, 0x1f, 0xaa, 0x40, 0xab, 0xd6, 0x63, 0xda, 0x98, 0x26,
0xb6, 0x17, 0x6f, 0x07, 0x99, 0x84, 0x9c, 0x6c, 0xb2, 0x55, 0xf2, 0x26, 0x27,
0x29, 0x14, 0xe6, 0xbf, 0x87, 0xe8, 0x23, 0xcf, 0xd8, 0x8f, 0x36, 0xa0, 0x01,
0x4b, 0x50, 0x66, 0xb4, 0xba, 0xda, 0x71, 0xec, 0xd8, 0x49, 0xec, 0x67, 0x3c,
0x8f, 0x4d, 0x1b, 0x49, 0xff, 0x3f, 0x12, 0x46, 0x46, 0x61, 0xde, 0xa1, 0xa4,
0xf5, 0xed, 0x0c, 0xf7, 0x5a, 0x66, 0x7c, 0x9b, 0x0b, 0xd5, 0xcf, 0x99, 0x0b,
0x6d, 0xc3, 0x49, 0x5b, 0xfa, 0xba, 0x3c, 0xfb, 0xd3, 0xba, 0x11, 0xd0, 0xc1,
0x7c, 0x03, 0x60, 0x63, 0xaa, 0x50, 0x89, 0xad, 0xd8, 0xf6, 0xde, 0x56, 0x64,
0xa3, 0x84, 0xfa, 0x4c, 0x74, 0xd0, 0xc5, 0x36, 0x62, 0x9b, 0x31, 0x7d, 0xec,
0x44, 0xd2, 0xfb, 0x7d, 0xd8, 0xa1, 0x3b, 0x7e, 0x10, 0xff, 0xe6, 0xfc, 0x05,
0xda, 0x30, 0x92, 0x1c, 0x4d, 0x86, 0x9d, 0x6d, 0xa9, 0xe9, 0xd4, 0x30, 0xec,
0x59, 0xed, 0xd5, 0x07, 0xd4, 0xa1, 0x98, 0x18, 0x82, 0x9d, 0xaf, 0x87, 0xee,
0x84, 0xdb, 0xb7, 0xe3, 0xd1, 0xb1, 0x64, 0x15, 0xf4, 0xb7, 0xa7, 0x66, 0x32,
0xab, 0x5c, 0x36, 0x46, 0x58, 0x11, 0x38, 0xb3, 0x19, 0x50, 0x40, 0x46, 0xd1,
0x60, 0xf7, 0xc1, 0xc8, 0xa3, 0x78, 0x87, 0xd3, 0x13, 0x3f, 0x8c, 0x8f, 0x83,
0x96, 0x3c, 0x02, 0xac, 0x40, 0xcf, 0x46, 0x48, 0x1b, 0xd2, 0x84, 0x68, 0x69,
0x1e, 0x56, 0x60, 0x84, 0x07, 0xe1, 0x5e, 0x68, 0xb4, 0xc7, 0x45, 0x63, 0x0c,
0x73, 0x18, 0x62, 0xc7, 0xf1, 0xfd, 0xc4, 0x5e, 0xc2, 0xe1, 0xdc, 0x4d, 0x4c,
0x25, 0x27, 0x93, 0x13, 0x92, 0xa7, 0x16, 0x61, 0xf7, 0x86, 0x40, 0x29, 0x78,
0x81, 0x84, 0x98, 0x14, 0x0f, 0x12, 0xd3, 0x12, 0xd5, 0x9f, 0xfc, 0x96, 0x32,
0xa6, 0x4e, 0x53, 0x51, 0xa4, 0xcc, 0xf6, 0x28, 0xa4, 0xc4, 0x93, 0xf8, 0x8c,
0x44, 0x5f, 0x00, 0x3e, 0xe9, 0x42, 0x7e, 0xe1, 0x49, 0xfc, 0x2d, 0x3e, 0x8b,
0x66, 0xb0, 0x99, 0xad, 0xd8, 0x77, 0xa7, 0x29, 0xb6, 0x1d, 0x3b, 0x75, 0x20,
0xb1, 0x73, 0xd8, 0xf1, 0x99, 0xe3, 0x34, 0x8e, 0xc5, 0x3b, 0x9d, 0x5d, 0x52,
0xcc, 0x71, 0x39, 0xdd, 0x09, 0x27, 0x60, 0xb3, 0xc9, 0xb9, 0xa4, 0x3c, 0x29,
0x4b, 0x56, 0xc3, 0xae, 0xb8, 0x64, 0x20, 0x19, 0x4c, 0x7e, 0x70, 0x75, 0xa4,
0xba, 0x52, 0x9d, 0xa9, 0xef, 0xd2, 0x0e, 0xb1, 0xff, 0x34, 0x0e, 0x0c, 0x4a,
0x39, 0x72, 0xbb, 0xdd, 0x12, 0x3b, 0x03, 0x6e, 0xee, 0x38, 0x0f, 0xa5, 0x38,
0x75, 0x96, 0xf9, 0xce, 0x50, 0xe6, 0x58, 0x55, 0x0f, 0xf2, 0x3a, 0x82, 0x1e,
0x59, 0xaa, 0x78, 0xf7, 0xf9, 0xba, 0x58, 0x56, 0x2b, 0x03, 0x8f, 0x25, 0xab,
0x93, 0x35, 0xc9, 0x9a, 0x65, 0xad, 0xb2, 0x36, 0x59, 0x87, 0xec, 0xbb, 0xec,
0x87, 0xac, 0x5b, 0xd6, 0x27, 0xeb, 0x97, 0x0d, 0xca, 0x86, 0x64, 0xa3, 0xb2,
0x31, 0xd9, 0xa4, 0x6c, 0x4a, 0xf6, 0x76, 0x56, 0x4b, 0xb6, 0x23, 0xdb, 0x93,
0xed, 0xcb, 0x7e, 0xc9, 0x76, 0x65, 0xf5, 0xb2, 0x52, 0xa0, 0x97, 0x03, 0x54,
0xca, 0xaa, 0x64, 0x1f, 0x64, 0xd5, 0x80, 0x4d, 0xcb, 0x66, 0x64, 0x32, 0x99,
0x5c, 0x36, 0x2b, 0x9b, 0x93, 0x1d, 0xc8, 0xdc, 0xb2, 0x43, 0xd9, 0x8d, 0x8c,
0x94, 0x51, 0xb2, 0x5b, 0xd9, 0x9d, 0x34, 0x47, 0x89, 0xbc, 0x54, 0x5e, 0x26,
0x2f, 0x02, 0x5c, 0x29, 0xcb, 0x95, 0x17, 0xca, 0xd7, 0x00, 0x6b, 0x90, 0x35,
0xca, 0x54, 0xb2, 0x23, 0x59, 0xb6, 0xcc, 0x23, 0xcb, 0x93, 0x65, 0xcb, 0x55,
0x72, 0xb5, 0x7c, 0x5d, 0xae, 0x91, 0x6b, 0xe5, 0x1b, 0x72, 0x9d, 0x5c, 0x2f,
0xdf, 0x94, 0x1b, 0xe4, 0x05, 0xb2, 0x77, 0xb2, 0x33, 0x19, 0x2e, 0x3b, 0x97,
0x15, 0xca, 0x8a, 0xe4, 0x47, 0x72, 0x8f, 0xfc, 0x58, 0x7e, 0x22, 0xc7, 0xe4,
0xa7, 0xf2, 0x33, 0xf9, 0xb9, 0x1c, 0x97, 0x5f, 0xc8, 0x2f, 0xe5, 0x57, 0x72,
0x42, 0xee, 0x95, 0x5f, 0xcb, 0x6f, 0xe4, 0xa4, 0x9c, 0x92, 0xdf, 0xca, 0xef,
0xe4, 0x3e, 0x39, 0x2d, 0xbf, 0x97, 0x3f, 0xc8, 0x19, 0x39, 0x2b, 0xff, 0xeb,
0xaf, 0x1c, 0xe9, 0x69, 0x8b, 0x0e, 0xf8, 0xc5, 0x47, 0xb9, 0x5f, 0xce, 0xc9,
0x03, 0xf2, 0xa0, 0x9c, 0x97, 0x87, 0xe4, 0x61, 0xb9, 0x20, 0x8f, 0xc8, 0x45,
0x79, 0x54, 0x1e, 0x93, 0xc7, 0xe5, 0x09, 0x79, 0x52, 0x9e, 0x92, 0x3f, 0xc9,
0x7f, 0xcb, 0x9f, 0xe5, 0x2f, 0xf2, 0x57, 0x79, 0xd6, 0x6c, 0xf6, 0x6c, 0xce,
0x6c, 0xee, 0xec, 0x57, 0x59, 0x8d, 0xac, 0x45, 0xf6, 0xb7, 0xff, 0xaf, 0xca,
0xfe, 0xfa, 0xff, 0xf8, 0x63, 0x97, 0xfd, 0x0f,
};
optimizesize void *__big5_encmap(void) {
return xload(&__big5_encmap_ptr,
__big5_encmap_rodata,
29219, 43528); /* 67.1269% profit */
}
| 180,123 | 2,261 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/gbcommon_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) gbcommon_encmap_ptr;
static const unsigned char gbcommon_encmap_rodata[] = {
0xed, 0xce, 0xbb, 0x32, 0x03, 0x61, 0x18, 0x87, 0xf1, 0xef, 0xcb, 0x66, 0x57,
0xb0, 0x88, 0x65, 0x11, 0xc7, 0x84, 0x04, 0x4b, 0x10, 0x11, 0x71, 0x88, 0x63,
0xc4, 0x61, 0x9d, 0xd7, 0x31, 0xab, 0xd2, 0xab, 0x5d, 0x80, 0x1b, 0x30, 0xa3,
0x34, 0x0a, 0x05, 0xb9, 0x0a, 0x45, 0x1a, 0x0a, 0x85, 0x52, 0x61, 0x68, 0x33,
0x6a, 0x9d, 0xc2, 0xe0, 0x29, 0x95, 0x1a, 0xa9, 0x3c, 0x33, 0xbf, 0xe6, 0x9d,
0xf9, 0xcf, 0xbc, 0x52, 0x5c, 0x7f, 0x1c, 0x08, 0xf9, 0x92, 0x94, 0xce, 0x53,
0x5e, 0x9e, 0xdd, 0xbf, 0x4b, 0xe9, 0x88, 0x22, 0x66, 0x7b, 0xfc, 0xa9, 0x63,
0x8f, 0x72, 0xae, 0x2b, 0xbe, 0xfc, 0xad, 0x62, 0x18, 0x77, 0xca, 0xe1, 0x85,
0xf4, 0x8a, 0xc2, 0xab, 0x57, 0x4d, 0xff, 0x66, 0x1f, 0x51, 0xc5, 0x67, 0x58,
0x53, 0x2d, 0x5b, 0x0b, 0x5e, 0x3d, 0x68, 0xa7, 0x8f, 0xc5, 0xfa, 0xdb, 0x2c,
0x11, 0x5f, 0xa6, 0x0f, 0xa5, 0x28, 0x43, 0x39, 0x74, 0x54, 0xa0, 0x12, 0x55,
0xf0, 0xa3, 0x1a, 0x06, 0x6a, 0x50, 0x0b, 0x13, 0x75, 0xa8, 0x47, 0x03, 0x02,
0x68, 0x44, 0x13, 0x9a, 0xd1, 0x82, 0x56, 0xb4, 0x21, 0x88, 0x10, 0xda, 0xd1,
0x81, 0x30, 0x22, 0xe8, 0x44, 0x17, 0xba, 0x61, 0xa1, 0x07, 0xbd, 0x88, 0xa2,
0x0f, 0xfd, 0x18, 0x40, 0x0c, 0x83, 0x88, 0x63, 0x08, 0x09, 0x0c, 0x23, 0x89,
0x11, 0x8c, 0x62, 0x0c, 0xe3, 0x48, 0x61, 0x02, 0x93, 0x98, 0xc2, 0x34, 0x66,
0x30, 0x8b, 0x34, 0xe6, 0x90, 0xc1, 0x3c, 0x16, 0xb0, 0x88, 0x25, 0xd8, 0x58,
0xc6, 0x0a, 0x56, 0xb1, 0x86, 0x75, 0x6c, 0x60, 0x13, 0x0e, 0xb6, 0xb0, 0x8d,
0x1d, 0xec, 0x62, 0x0f, 0xfb, 0xc8, 0x8a, 0x9c, 0xf8, 0xef, 0xcf, 0xbb, 0xc9,
0x46, 0xdf, 0x4e, 0x5c, 0xdd, 0xfa, 0x79, 0xbb, 0x74, 0x63, 0x47, 0xcf, 0xae,
0x2c, 0x7c, 0x03,
};
optimizesize void *gbcommon_encmap(void) {
return xload(&gbcommon_encmap_ptr,
gbcommon_encmap_rodata,
263, 1024); /* 25.6836% profit */
}
| 1,940 | 34 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/jisx0212_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) jisx0212_decmap_ptr;
static const unsigned char jisx0212_decmap_rodata[] = {
0xed, 0xcb, 0x2f, 0x2c, 0xc4, 0x71, 0x1c, 0xc6, 0xf1, 0xef, 0xef, 0x70, 0x87,
0x73, 0xdc, 0xf9, 0xf7, 0x0b, 0x97, 0x9e, 0x8d, 0x09, 0xc2, 0x4d, 0x30, 0x41,
0x3a, 0x23, 0x09, 0x08, 0x92, 0x80, 0x99, 0x60, 0x82, 0x09, 0xb7, 0x9b, 0xb1,
0x47, 0xb0, 0x0b, 0x92, 0x60, 0x82, 0x60, 0x82, 0x24, 0x98, 0x20, 0x09, 0x92,
0x60, 0xc2, 0x25, 0xc1, 0x84, 0x0b, 0x26, 0x48, 0x17, 0x4c, 0x90, 0x6c, 0xde,
0x9a, 0xc9, 0x82, 0x70, 0xef, 0xed, 0xb5, 0x7d, 0x9e, 0xf0, 0x09, 0xe1, 0x7f,
0x14, 0x85, 0xc2, 0xe6, 0xcf, 0x3d, 0x19, 0x96, 0x77, 0x96, 0xc2, 0x84, 0xbf,
0xef, 0x93, 0xa0, 0xd9, 0x6a, 0x50, 0x79, 0x20, 0x52, 0xf9, 0xf7, 0xdf, 0x76,
0x24, 0x3f, 0x61, 0x2c, 0x21, 0x1f, 0xe1, 0x1d, 0x73, 0x4d, 0xf2, 0x25, 0x32,
0xcd, 0xf2, 0x3a, 0xee, 0x31, 0xd4, 0x22, 0x57, 0xf0, 0x82, 0x62, 0x52, 0x3e,
0xc5, 0x27, 0x16, 0x52, 0xf2, 0x35, 0xe2, 0x56, 0xb9, 0x84, 0x07, 0x8c, 0xb4,
0xc9, 0x07, 0xa8, 0x63, 0xba, 0x5d, 0x3e, 0x47, 0x2a, 0x2d, 0xaf, 0xe2, 0x16,
0xea, 0x90, 0x77, 0x51, 0xc3, 0x78, 0x46, 0x3e, 0xc6, 0x07, 0xe6, 0x3b, 0xe5,
0x2b, 0xe4, 0xba, 0xe4, 0x0d, 0x54, 0x31, 0x9c, 0x95, 0xf7, 0xf1, 0x8a, 0xa9,
0x9c, 0x7c, 0x86, 0xa8, 0x5b, 0x5e, 0xc4, 0x0d, 0xf2, 0x3d, 0xf2, 0x16, 0x1e,
0x31, 0xda, 0x2b, 0x1f, 0xe2, 0x0d, 0x33, 0x7d, 0xf2, 0x05, 0xd2, 0xfd, 0xf2,
0x1a, 0xee, 0x30, 0x18, 0xcb, 0x7b, 0x78, 0x8e, 0xb5, 0x12, 0x1a, 0x35, 0xfa,
0x83, 0xbe, 0x00,
};
optimizesize void *jisx0212_decmap(void) {
return xload(&jisx0212_decmap_ptr,
jisx0212_decmap_rodata,
224, 1024); /* 21.875% profit */
}
| 1,699 | 31 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/cp932ext_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) cp932ext_decmap_ptr;
static const unsigned char cp932ext_decmap_rodata[] = {
0x63, 0x60, 0x18, 0x05, 0x23, 0x1d, 0x30, 0x32, 0xc4, 0x9f, 0xc2, 0x26, 0x9e,
0xcb, 0xe0, 0x30, 0x67, 0x34, 0x74, 0x06, 0x1f, 0x38, 0xc5, 0xe0, 0xf0, 0xa7,
0x9d, 0xd1, 0xe1, 0x0f, 0x29, 0x7a, 0x5c, 0x98, 0x1c, 0xfe, 0x30, 0x32, 0x3b,
0xfc, 0xd9, 0xc7, 0xec, 0xe0, 0x8d, 0x2c, 0x0e, 0x00,
};
optimizesize void *cp932ext_decmap(void) {
return xload(&cp932ext_decmap_ptr,
cp932ext_decmap_rodata,
48, 1024); /* 4.6875% profit */
}
| 614 | 17 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__ksx1001_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __ksx1001_decmap_ptr;
static const unsigned char __ksx1001_decmap_rodata[10685] = {
0xb5, 0x79, 0x0d, 0x78, 0x93, 0x55, 0x9a, 0xf6, 0x3e, 0xe7, 0x9c, 0xf7, 0x27,
0x6f, 0xfe, 0x93, 0x36, 0x4d, 0xff, 0x4b, 0x29, 0x50, 0x7e, 0x06, 0x11, 0x10,
0x11, 0x1d, 0xc5, 0x3f, 0x74, 0x18, 0x65, 0x18, 0x2f, 0xd7, 0x8f, 0x75, 0x1d,
0x65, 0x9d, 0xd9, 0x19, 0xc7, 0xcf, 0x71, 0x9d, 0xd9, 0xd9, 0x59, 0x77, 0xc6,
0x71, 0x43, 0x0c, 0x21, 0x86, 0x10, 0x6a, 0x0c, 0x25, 0x94, 0x10, 0x4a, 0x2c,
0x21, 0x86, 0x18, 0x43, 0x89, 0x21, 0xc6, 0x52, 0x62, 0xac, 0xb5, 0x94, 0x58,
0x63, 0x09, 0xb5, 0x13, 0x6b, 0x28, 0xb5, 0x86, 0x58, 0x6b, 0x8d, 0xb5, 0x53,
0x4a, 0xa8, 0xe5, 0x7b, 0x53, 0xca, 0x8f, 0x33, 0x3b, 0xfb, 0x5d, 0xd7, 0x77,
0x7d, 0x9b, 0x5e, 0xa4, 0xe7, 0x3d, 0xef, 0x39, 0xe7, 0xf9, 0xbb, 0x9f, 0xfb,
0x3c, 0x4f, 0xd1, 0x44, 0x00, 0xa1, 0x1d, 0x47, 0xa1, 0xef, 0x8f, 0xe8, 0xc2,
0x1f, 0x83, 0x47, 0xe1, 0xe0, 0x51, 0x88, 0xff, 0xb1, 0x91, 0xf5, 0x8d, 0xd1,
0x17, 0xbf, 0xa1, 0xdf, 0x63, 0x11, 0x8d, 0x46, 0x6e, 0x43, 0xc5, 0xe8, 0xf2,
0xe7, 0xd8, 0x51, 0xb8, 0x6f, 0x75, 0xf7, 0x66, 0x60, 0xd1, 0x36, 0x58, 0xb4,
0x45, 0x0f, 0xba, 0xe7, 0x51, 0x23, 0x5e, 0x3f, 0x94, 0xa3, 0x11, 0xfb, 0x6e,
0x9a, 0xc6, 0xc7, 0x64, 0x46, 0x94, 0x84, 0xbd, 0x84, 0x0b, 0x40, 0xf9, 0x29,
0x3d, 0xb8, 0x9f, 0xaf, 0x2f, 0x82, 0x7f, 0x65, 0x41, 0x0c, 0x3f, 0x80, 0xb9,
0xa0, 0x82, 0x93, 0x32, 0x8c, 0x08, 0x9a, 0xba, 0xe9, 0xc3, 0x15, 0x68, 0x1f,
0xac, 0xb9, 0x6d, 0x89, 0x12, 0xdd, 0x43, 0x8f, 0x03, 0x12, 0xa0, 0x43, 0x00,
0x18, 0x8d, 0x8d, 0xd3, 0x7b, 0x27, 0x68, 0xb2, 0x81, 0xde, 0xb3, 0x19, 0x12,
0x39, 0xe6, 0xb5, 0x51, 0xa6, 0x9a, 0xa3, 0xe0, 0x6d, 0xb6, 0x9d, 0xfd, 0x86,
0xbd, 0xc5, 0xc9, 0xb6, 0xfc, 0xf1, 0x26, 0x7c, 0x6a, 0x33, 0x74, 0x6e, 0x82,
0x43, 0xd8, 0xa9, 0x02, 0x39, 0xf4, 0x21, 0x06, 0xb1, 0x84, 0x79, 0x59, 0x9a,
0x12, 0xfd, 0xe0, 0x61, 0xf4, 0xc7, 0x1a, 0x44, 0x03, 0xd0, 0x53, 0xf9, 0xb3,
0xca, 0xc8, 0x07, 0x3b, 0x20, 0xf1, 0x47, 0x94, 0xa1, 0x08, 0xa1, 0x88, 0x47,
0xc9, 0x20, 0xe2, 0x5a, 0xf2, 0x2e, 0x6c, 0xbd, 0x6b, 0x60, 0xed, 0xf1, 0xb5,
0x91, 0xb5, 0x8b, 0xbe, 0x5c, 0xfb, 0x39, 0x5c, 0xf8, 0x4f, 0xd7, 0x79, 0x06,
0xfd, 0x3f, 0x7f, 0x7a, 0xd0, 0x87, 0xff, 0xd7, 0x35, 0x26, 0xf4, 0x69, 0x98,
0x46, 0xff, 0x93, 0x9f, 0xb7, 0x56, 0x5f, 0x19, 0x1a, 0x73, 0xf4, 0xdf, 0xf1,
0x9f, 0xb7, 0x72, 0x57, 0x25, 0x7a, 0x2e, 0x4d, 0xfd, 0xdd, 0xdf, 0xfd, 0xe9,
0xeb, 0xbf, 0xb2, 0x94, 0xcc, 0x2c, 0xf9, 0x9a, 0xb9, 0xb4, 0xe4, 0xef, 0x76,
0xfd, 0xcd, 0x35, 0x23, 0x3a, 0x20, 0x05, 0xac, 0x8c, 0x91, 0x55, 0x49, 0xab,
0x64, 0xff, 0x46, 0xd4, 0xfc, 0x50, 0xcd, 0x0f, 0xab, 0xfe, 0xbe, 0x42, 0x5c,
0x21, 0xbb, 0x73, 0x6e, 0xe1, 0xdc, 0x82, 0xc7, 0x40, 0x01, 0x14, 0x1f, 0xe5,
0x6a, 0x7e, 0x0b, 0xcb, 0xff, 0xa3, 0xaf, 0xfc, 0x90, 0xcb, 0x87, 0xa0, 0xfa,
0x9b, 0x10, 0xda, 0xb2, 0xd6, 0xb8, 0x76, 0xc3, 0xed, 0xfc, 0xc3, 0x55, 0x40,
0xad, 0xff, 0x0f, 0x84, 0x34, 0xb0, 0x0d, 0xd0, 0xf3, 0xb7, 0x23, 0xd9, 0x95,
0xd9, 0x5f, 0xe7, 0xbf, 0x9e, 0x9a, 0x1e, 0xfe, 0x24, 0xff, 0xf5, 0xf1, 0x0f,
0x02, 0x6b, 0xd1, 0xaf, 0x10, 0xb2, 0xc2, 0xac, 0xeb, 0x10, 0xda, 0xf0, 0x53,
0x7e, 0xea, 0xf1, 0x62, 0xba, 0x52, 0x34, 0x77, 0xe1, 0xc5, 0x13, 0x50, 0xf0,
0xc3, 0x09, 0xf0, 0x5f, 0x60, 0x76, 0x5e, 0x60, 0x6c, 0x17, 0x98, 0x6f, 0x73,
0x0c, 0xf9, 0x10, 0xc6, 0xe0, 0x75, 0x74, 0x6f, 0x1d, 0xba, 0x31, 0x93, 0x63,
0xde, 0x0a, 0xfe, 0x77, 0x21, 0x38, 0xb5, 0xe2, 0x6f, 0xbe, 0x7a, 0xe9, 0x2f,
0x9e, 0xcf, 0x98, 0xc1, 0xab, 0x05, 0xf4, 0xba, 0x16, 0x48, 0x98, 0xff, 0x8d,
0xd0, 0x57, 0x9b, 0xe0, 0xa1, 0xdb, 0x9f, 0x2e, 0x20, 0x9c, 0x8c, 0xbc, 0x0c,
0x41, 0x38, 0x0b, 0xb7, 0x76, 0xc3, 0x8d, 0x78, 0x24, 0x0a, 0xff, 0x8d, 0xbc,
0x6f, 0x6f, 0xf8, 0x9b, 0xaf, 0x36, 0xfd, 0xc5, 0xbe, 0x97, 0xb6, 0x83, 0x18,
0x69, 0xff, 0x53, 0x95, 0x77, 0x60, 0xee, 0xd6, 0xff, 0xff, 0xd8, 0x29, 0xfb,
0x1f, 0x41, 0xe4, 0x89, 0xc3, 0x97, 0xcc, 0x98, 0xb7, 0xe0, 0x6f, 0x2e, 0x71,
0x7c, 0x75, 0x19, 0x73, 0x33, 0x9f, 0xdd, 0x5f, 0x5d, 0x82, 0xde, 0xca, 0xbf,
0xed, 0x9c, 0x01, 0x07, 0x85, 0xe8, 0x7c, 0x20, 0x45, 0xd7, 0x62, 0x93, 0x66,
0x65, 0xf9, 0x81, 0x84, 0x1f, 0xa8, 0x88, 0x84, 0x65, 0x6b, 0xf3, 0x6b, 0x88,
0x68, 0xfa, 0x65, 0x7e, 0x31, 0x7b, 0xf9, 0x3d, 0x22, 0x34, 0x9a, 0x1e, 0xb2,
0x34, 0xcb, 0x2a, 0x88, 0x62, 0x7a, 0x1d, 0x3f, 0xc7, 0x7f, 0xf1, 0x27, 0xd2,
0x6c, 0x7e, 0x4f, 0xfe, 0x00, 0x05, 0x3d, 0x7d, 0x98, 0x6c, 0xe6, 0xe9, 0xd2,
0x42, 0x84, 0xb8, 0x2b, 0x0b, 0xd5, 0x48, 0x32, 0x57, 0x71, 0x69, 0x85, 0x62,
0x46, 0x1e, 0xbf, 0x83, 0x5f, 0xbd, 0xf2, 0xb2, 0x68, 0x3e, 0x03, 0x78, 0x39,
0x84, 0xbd, 0xa4, 0x06, 0x4b, 0x5f, 0x55, 0x52, 0xb2, 0x31, 0x3f, 0x7f, 0x59,
0x63, 0x35, 0x9d, 0x17, 0xa1, 0x42, 0x1c, 0xcd, 0x6f, 0x25, 0x24, 0x2f, 0x32,
0x2f, 0x48, 0xc2, 0x4b, 0x40, 0xb5, 0x92, 0xbc, 0xe6, 0x6c, 0xfe, 0x50, 0x56,
0x72, 0x49, 0xb6, 0x4c, 0x3d, 0xa3, 0x19, 0x2d, 0xcb, 0xbf, 0x53, 0x4d, 0x6f,
0x22, 0xd3, 0x8a, 0xb1, 0xb7, 0x5e, 0x56, 0x79, 0xda, 0xce, 0xbc, 0x8f, 0xa6,
0xbd, 0x93, 0x3f, 0xf0, 0x1a, 0x0f, 0xc9, 0xb8, 0x35, 0x68, 0x5a, 0x39, 0x2e,
0x3f, 0x23, 0xfa, 0xee, 0xbb, 0x7c, 0xb2, 0xb2, 0xec, 0x92, 0xcb, 0xae, 0xe0,
0xf2, 0xbe, 0x53, 0xdf, 0x3b, 0xed, 0xbf, 0xbc, 0xb9, 0x8a, 0xfc, 0xe1, 0xf4,
0xb4, 0x0f, 0x89, 0xa4, 0x56, 0xb6, 0x72, 0x5a, 0x05, 0x24, 0xc9, 0xeb, 0xc8,
0xbf, 0x9d, 0x96, 0x98, 0x3f, 0x7a, 0xda, 0x23, 0x33, 0x27, 0x90, 0x19, 0x65,
0x78, 0x42, 0xb8, 0xa4, 0x0e, 0x7b, 0x55, 0xe2, 0x33, 0xd3, 0xef, 0xa6, 0x35,
0xe1, 0xa3, 0x40, 0xae, 0xcc, 0xb3, 0x79, 0xff, 0xe6, 0xb5, 0xc8, 0x47, 0x87,
0xcd, 0xbf, 0x24, 0xbc, 0x56, 0xb5, 0xb5, 0xb2, 0x4b, 0x8a, 0xac, 0xbc, 0x6c,
0x67, 0xad, 0x6c, 0xc1, 0x74, 0x78, 0xf2, 0x1e, 0x94, 0x71, 0x92, 0x2b, 0xae,
0xbf, 0x14, 0x85, 0xe9, 0xb3, 0xa6, 0xa3, 0x25, 0xfb, 0xae, 0xa5, 0xcf, 0xe7,
0x95, 0xfb, 0x2b, 0xf3, 0x6b, 0xef, 0xe5, 0x87, 0x25, 0x12, 0x59, 0xed, 0x4a,
0xf6, 0x89, 0x69, 0x7f, 0x73, 0x6b, 0xa6, 0xed, 0x63, 0xd7, 0xcc, 0x1c, 0xa6,
0x98, 0xb6, 0x96, 0x9d, 0x71, 0xf1, 0xcc, 0xb6, 0xbc, 0x39, 0xd7, 0x78, 0xb0,
0x82, 0xac, 0xf9, 0x4b, 0x79, 0x57, 0xd7, 0x4a, 0xd8, 0x12, 0xa2, 0xb8, 0x02,
0xab, 0xea, 0x15, 0x32, 0xf6, 0x2a, 0xc2, 0x88, 0xe4, 0xaa, 0x51, 0xd3, 0xf6,
0xd1, 0x57, 0x67, 0x66, 0x7e, 0xf3, 0xb1, 0xb9, 0xe5, 0xea, 0xd4, 0xb4, 0x2f,
0xa7, 0xfd, 0x4d, 0x5f, 0x8d, 0x2f, 0x3f, 0x21, 0x29, 0x59, 0x73, 0xd9, 0xf7,
0x79, 0xbc, 0x5e, 0x9b, 0x1a, 0xbc, 0xb7, 0xb9, 0x95, 0xd3, 0xb1, 0xbf, 0x04,
0xf3, 0x2a, 0xb4, 0xe6, 0xb2, 0xf7, 0xf2, 0x10, 0xbf, 0x02, 0x1a, 0x1e, 0xb4,
0x68, 0x7a, 0x8a, 0xb7, 0xbf, 0x96, 0xd7, 0x91, 0xce, 0x5b, 0x4e, 0xaf, 0xbd,
0x9a, 0x54, 0xe4, 0x52, 0x44, 0xa7, 0xbf, 0xf2, 0xb1, 0xbb, 0x8a, 0xee, 0xfc,
0xa8, 0x64, 0xdd, 0xd5, 0x1c, 0x10, 0x5d, 0x09, 0x84, 0x64, 0x1a, 0x3e, 0xd3,
0x99, 0xb7, 0x64, 0x06, 0xff, 0x79, 0x15, 0x64, 0xb5, 0xb2, 0xe9, 0xbd, 0xaa,
0x4b, 0xe1, 0x9e, 0x91, 0x8f, 0x88, 0x4c, 0x3d, 0xed, 0x86, 0x92, 0x7c, 0x64,
0xaf, 0xb8, 0x62, 0xed, 0x15, 0xcb, 0x78, 0xb1, 0xf4, 0x4c, 0x6a, 0x5d, 0x8b,
0xe0, 0x8a, 0xf5, 0xd3, 0xf2, 0xf2, 0xc9, 0xb8, 0x80, 0x7f, 0xca, 0x4f, 0x5e,
0x8a, 0x07, 0xfb, 0xfc, 0xca, 0x05, 0x92, 0x4b, 0x6e, 0x0d, 0xc2, 0x82, 0xe9,
0xb4, 0x5a, 0x77, 0xc5, 0x97, 0x04, 0x5d, 0xc9, 0x96, 0x6b, 0xf3, 0xf4, 0x4a,
0xfe, 0xe7, 0xa1, 0x35, 0x6d, 0xee, 0x0c, 0x68, 0x38, 0xf2, 0x17, 0x8b, 0xa6,
0x21, 0x5b, 0x22, 0xb9, 0x9c, 0xee, 0x97, 0xfc, 0x71, 0x49, 0x75, 0x24, 0xbb,
0x92, 0x3c, 0x33, 0x81, 0xbb, 0x94, 0x3d, 0xbc, 0x0d, 0xe4, 0x92, 0xe9, 0xdc,
0xd5, 0x38, 0x4b, 0x66, 0x4c, 0x9d, 0xa6, 0x92, 0x69, 0xd8, 0x4d, 0x67, 0x3d,
0x97, 0xbf, 0x3d, 0xa7, 0x73, 0x73, 0xc6, 0x56, 0x1a, 0xad, 0x9c, 0x09, 0x32,
0x9d, 0x97, 0xfc, 0xc4, 0x92, 0x19, 0x87, 0xe7, 0xb3, 0x30, 0xef, 0xd1, 0xcb,
0xcc, 0x30, 0x4d, 0x1e, 0xf9, 0x34, 0x7d, 0x38, 0x7f, 0x6a, 0x3e, 0x9b, 0xf3,
0xf0, 0x55, 0x5f, 0xd5, 0x65, 0x3a, 0x25, 0xb9, 0xe9, 0xef, 0xe9, 0xfb, 0xfa,
0xaa, 0x55, 0x34, 0x77, 0x05, 0x07, 0xaa, 0x69, 0xcb, 0xaf, 0x50, 0x6e, 0x5e,
0xf5, 0xab, 0x3c, 0x33, 0x9d, 0x48, 0x33, 0x69, 0x3d, 0xc3, 0xb3, 0xb2, 0x69,
0x2a, 0xb8, 0xc4, 0xaa, 0x84, 0xbb, 0xe6, 0x50, 0xf5, 0x5f, 0x63, 0xfa, 0x2a,
0x6d, 0x5c, 0xa6, 0x1f, 0xc9, 0x8c, 0xda, 0x7f, 0xb1, 0x70, 0xfa, 0x20, 0x11,
0x99, 0x8e, 0xfd, 0x25, 0x79, 0x79, 0x5c, 0x4e, 0xef, 0xbe, 0xa4, 0x7f, 0x9e,
0xd1, 0xf2, 0x99, 0x30, 0x43, 0xfb, 0xa2, 0x6b, 0xe4, 0xf2, 0xac, 0xca, 0x49,
0xae, 0xe1, 0xa4, 0xcb, 0x2f, 0xa7, 0x63, 0x9b, 0x17, 0xb9, 0xf2, 0x2a, 0xae,
0xf8, 0xf3, 0x24, 0xf9, 0x94, 0xa8, 0x45, 0x92, 0x2b, 0x99, 0x5e, 0x7d, 0x8d,
0x96, 0x33, 0xd9, 0x79, 0x89, 0x0d, 0x2e, 0x7b, 0x72, 0xcd, 0x55, 0xc0, 0xe7,
0x5d, 0xc5, 0x0b, 0xa4, 0xb9, 0xbf, 0x80, 0x47, 0xf5, 0x15, 0x5e, 0xe0, 0x91,
0x39, 0x4d, 0x35, 0x33, 0x56, 0x49, 0xd4, 0x33, 0x01, 0x5b, 0x7d, 0xd9, 0xf2,
0x5a, 0xb4, 0x66, 0xe5, 0xca, 0x2a, 0x7a, 0x86, 0x49, 0xd8, 0xe9, 0x2c, 0x9e,
0xbe, 0x18, 0xbe, 0x63, 0x16, 0x9b, 0xb7, 0x6a, 0xcd, 0x5f, 0xa3, 0xb5, 0x4a,
0xc6, 0x56, 0x5f, 0x83, 0xdd, 0x92, 0x35, 0x33, 0x66, 0x54, 0xa9, 0xaf, 0x12,
0x0c, 0xbb, 0x84, 0xbd, 0x16, 0xdb, 0xd7, 0x18, 0x71, 0xe9, 0x12, 0xfb, 0x2b,
0xe2, 0x42, 0xb5, 0x6b, 0xbe, 0x93, 0xc8, 0x57, 0x9c, 0x97, 0x7f, 0x5e, 0x79,
0xed, 0x72, 0x8e, 0x37, 0x8f, 0xa7, 0xd0, 0x6b, 0x14, 0x90, 0x2c, 0xb8, 0x76,
0xc7, 0x25, 0x2d, 0xd8, 0x35, 0xd7, 0xc6, 0x5f, 0xf2, 0x5d, 0x5f, 0x2d, 0x58,
0x73, 0x25, 0xb7, 0xbf, 0x63, 0xd6, 0x92, 0x99, 0x07, 0x8e, 0xb0, 0x4b, 0x56,
0xb2, 0x15, 0x44, 0xb2, 0xf2, 0x2f, 0x28, 0x93, 0xf7, 0xdd, 0x77, 0xee, 0x81,
0x4b, 0x84, 0xfd, 0x1d, 0xb0, 0xfe, 0x55, 0x92, 0x3f, 0xfd, 0x5f, 0xe5, 0x7b,
0x1e, 0x13, 0x32, 0xc5, 0xd5, 0xa4, 0x5d, 0xb0, 0x26, 0xef, 0xb1, 0xcb, 0xf5,
0x82, 0x68, 0x66, 0xea, 0x32, 0x31, 0xce, 0x78, 0x62, 0xed, 0x35, 0x26, 0x71,
0xf4, 0x77, 0xdc, 0x77, 0xc5, 0xa2, 0xff, 0xc2, 0xb5, 0x97, 0x12, 0xec, 0xd2,
0x8e, 0x69, 0xc5, 0x54, 0x64, 0xfa, 0x1e, 0x91, 0xcc, 0x5c, 0xb7, 0x33, 0x72,
0xf9, 0x05, 0xf4, 0xd5, 0x78, 0x95, 0x7c, 0xe7, 0x1c, 0xfa, 0xf2, 0x7d, 0x20,
0x99, 0x3e, 0x83, 0xbd, 0x36, 0x7f, 0x8e, 0xed, 0x23, 0x4f, 0xb9, 0xf1, 0x20,
0xea, 0xa2, 0x1d, 0x94, 0x09, 0xf5, 0x43, 0x07, 0xc9, 0x2a, 0x86, 0xb0, 0x73,
0x61, 0x8a, 0xa0, 0x67, 0xc2, 0xe2, 0xe1, 0x59, 0x1a, 0x76, 0x4c, 0xde, 0x5a,
0xfd, 0x80, 0xab, 0xf0, 0xf1, 0x3e, 0xba, 0x89, 0x33, 0x93, 0x5e, 0xd2, 0x83,
0x53, 0xf3, 0x0e, 0x3b, 0xd0, 0x28, 0x69, 0x44, 0xb1, 0xeb, 0xc7, 0xb0, 0x7f,
0xbe, 0xab, 0xaa, 0xfe, 0x86, 0x48, 0xf5, 0x12, 0xe7, 0x75, 0xc7, 0x6c, 0xc8,
0xcc, 0x65, 0x4a, 0xc6, 0x50, 0x1f, 0xd8, 0x14, 0x12, 0xbb, 0x78, 0x94, 0x31,
0x49, 0x62, 0xc8, 0x85, 0xfc, 0x65, 0x23, 0x25, 0x39, 0x94, 0x60, 0x5c, 0x64,
0x04, 0xb7, 0x91, 0x09, 0xb9, 0x93, 0xa1, 0xc7, 0x66, 0xc5, 0x17, 0x7c, 0x60,
0x47, 0x83, 0x65, 0x81, 0xbb, 0x73, 0x65, 0xa9, 0xf9, 0x56, 0x41, 0xdf, 0x9c,
0x21, 0xc5, 0x0b, 0x4c, 0xe0, 0xf6, 0xbd, 0x2f, 0xa3, 0x61, 0x79, 0x08, 0xb7,
0x15, 0xb8, 0xa4, 0xad, 0xa8, 0x1d, 0xb4, 0xe2, 0x94, 0x20, 0x2d, 0xf0, 0x49,
0x73, 0xa5, 0x41, 0xd4, 0x4f, 0x1a, 0xb0, 0x55, 0x35, 0x74, 0x7f, 0x9b, 0x04,
0xe9, 0xbf, 0xf7, 0xe9, 0x21, 0x64, 0x99, 0x6b, 0x7a, 0xbc, 0x7b, 0x71, 0xe7,
0xdd, 0x7e, 0xf1, 0x79, 0x13, 0x4a, 0xaa, 0xdc, 0x8c, 0x51, 0x38, 0x0c, 0x11,
0x5a, 0x8f, 0xaa, 0x92, 0x6c, 0x7c, 0x61, 0xb0, 0x46, 0x1d, 0x28, 0x77, 0xa1,
0xe7, 0x82, 0x4c, 0x1d, 0xd3, 0x80, 0xfb, 0xc5, 0xfd, 0x92, 0x00, 0x13, 0xad,
0x74, 0x8a, 0xc7, 0x8a, 0xce, 0xbd, 0x81, 0x36, 0xb8, 0x49, 0x8c, 0x69, 0x29,
0x8e, 0xcf, 0x96, 0x3c, 0xe8, 0x94, 0x0e, 0x28, 0xba, 0x0a, 0xdc, 0x25, 0x51,
0xdc, 0x08, 0x03, 0x8a, 0x96, 0xb2, 0x18, 0x3b, 0x14, 0xc7, 0x87, 0x76, 0xe0,
0x0e, 0x66, 0x87, 0x06, 0xb5, 0xa9, 0xf7, 0xc9, 0xfb, 0xf5, 0xd4, 0xee, 0xaf,
0xb1, 0x49, 0x34, 0x71, 0xcf, 0x2e, 0x3d, 0x72, 0x49, 0xac, 0xd5, 0xed, 0x74,
0x42, 0x19, 0x42, 0xbd, 0x54, 0xc9, 0x68, 0x8d, 0x8d, 0x4b, 0x55, 0xeb, 0x1e,
0xd0, 0x42, 0xc7, 0x41, 0xfc, 0xa2, 0x13, 0xd7, 0x31, 0x69, 0xf4, 0xcd, 0x4b,
0x28, 0x0b, 0x29, 0xaa, 0x79, 0xc5, 0x04, 0xb6, 0xb1, 0xce, 0x59, 0x81, 0x8d,
0xed, 0xca, 0x74, 0x65, 0x5f, 0xc1, 0x70, 0xc9, 0xae, 0xd7, 0x51, 0x9a, 0x6d,
0xfd, 0xc7, 0x46, 0xfc, 0xe5, 0x23, 0x06, 0x9a, 0x6b, 0xdc, 0x18, 0x58, 0xee,
0xfe, 0xa5, 0x61, 0xd9, 0x87, 0x7e, 0x64, 0x58, 0xa1, 0x3f, 0x06, 0x27, 0xa7,
0x20, 0x7a, 0xb7, 0x41, 0x10, 0xc6, 0x83, 0xe2, 0x3a, 0xc1, 0x44, 0x41, 0xdd,
0x3d, 0xcd, 0x55, 0xe9, 0x65, 0x7b, 0x72, 0x90, 0xfd, 0xe5, 0xa3, 0x7e, 0xc1,
0xd0, 0xac, 0x0c, 0x9e, 0x60, 0xdb, 0x66, 0x77, 0x33, 0x29, 0x65, 0xdf, 0xb2,
0xed, 0x5f, 0xc0, 0xc0, 0xbc, 0x80, 0x70, 0xe2, 0xc6, 0x04, 0xd3, 0xbd, 0xf0,
0xfd, 0x01, 0xb0, 0xdf, 0xe6, 0xfa, 0xe5, 0xc4, 0xf7, 0x27, 0xcb, 0x86, 0xc8,
0xb1, 0x97, 0x51, 0x17, 0xa9, 0x87, 0x08, 0xaa, 0x83, 0x71, 0x5a, 0x3d, 0x88,
0x06, 0xa4, 0x2e, 0xe2, 0x53, 0x8f, 0xe0, 0x4e, 0xe6, 0xa9, 0x36, 0x51, 0x0b,
0xd2, 0x13, 0x1b, 0xfc, 0xa6, 0x9d, 0xee, 0x57, 0x4e, 0x0a, 0x7b, 0xa1, 0x4f,
0x22, 0x5a, 0xeb, 0x20, 0x2e, 0x4e, 0x83, 0xd2, 0xcc, 0x62, 0x87, 0xc0, 0x0e,
0x3a, 0xee, 0xc1, 0x10, 0x1e, 0x17, 0x34, 0x56, 0xa6, 0x24, 0x1a, 0x62, 0x93,
0xb6, 0xc9, 0x9e, 0x6c, 0x63, 0xed, 0xf4, 0x09, 0x3f, 0x72, 0xaa, 0xba, 0x84,
0x3e, 0xd2, 0xc4, 0xb6, 0xe3, 0x41, 0x79, 0x80, 0xea, 0x57, 0xf7, 0xc1, 0x33,
0xba, 0xa2, 0xb6, 0x92, 0x5e, 0xe2, 0x15, 0xa4, 0xa8, 0x49, 0xae, 0x9f, 0xaa,
0xb6, 0x2d, 0x6e, 0x46, 0x2d, 0xb4, 0x63, 0xfe, 0x70, 0xd9, 0xb1, 0x03, 0x88,
0x8b, 0xc2, 0x3a, 0x0b, 0xe7, 0x13, 0xba, 0x68, 0x1f, 0xee, 0x17, 0xd8, 0xe4,
0x1a, 0x41, 0xd9, 0xc3, 0x7d, 0xc4, 0xc1, 0x1f, 0x30, 0x21, 0x9c, 0xaa, 0x71,
0xa3, 0x3e, 0xac, 0x15, 0x7a, 0x0a, 0x53, 0xd0, 0xc2, 0x8f, 0x7c, 0xd4, 0xe2,
0x34, 0x76, 0x32, 0xfd, 0x02, 0x3d, 0x1a, 0x60, 0x5a, 0xde, 0xc4, 0xef, 0xef,
0xc7, 0x4d, 0x92, 0x66, 0x49, 0x84, 0x1e, 0x10, 0x8c, 0xcb, 0x4e, 0xf0, 0x6b,
0xef, 0xf0, 0x51, 0x61, 0x7a, 0x60, 0xcd, 0xc8, 0x3d, 0xdd, 0x77, 0x9d, 0xde,
0x85, 0x32, 0x90, 0x54, 0x0d, 0xcd, 0xee, 0xe1, 0x56, 0x0e, 0xa8, 0x13, 0x05,
0xc3, 0x3f, 0x36, 0xdd, 0x7f, 0xee, 0x28, 0x84, 0x9a, 0xc9, 0x91, 0xf3, 0x68,
0x97, 0x17, 0x39, 0x19, 0xae, 0x8f, 0x0c, 0x55, 0x3b, 0xb9, 0x1e, 0xc1, 0x2a,
0x03, 0x37, 0x8c, 0xdc, 0x74, 0xcb, 0xaa, 0x68, 0x49, 0xf7, 0x92, 0xa9, 0xa2,
0xe4, 0xc2, 0x37, 0xf7, 0xa3, 0xd4, 0x8a, 0x2e, 0xb5, 0x5b, 0xa5, 0xb9, 0x61,
0x48, 0xa9, 0xab, 0xcd, 0x94, 0x3c, 0x34, 0x2c, 0x8a, 0x09, 0x72, 0xc2, 0x71,
0xe5, 0x67, 0x9f, 0x81, 0x67, 0x91, 0xef, 0x99, 0xbe, 0x85, 0xfe, 0x46, 0x7c,
0x7c, 0x0f, 0x95, 0x9d, 0xe7, 0x86, 0x91, 0x42, 0x5f, 0x85, 0x41, 0x60, 0x2f,
0x68, 0x97, 0x76, 0x23, 0x4b, 0x69, 0x4a, 0x32, 0x24, 0x1f, 0x2f, 0xea, 0x11,
0x0e, 0xd4, 0xd8, 0xc4, 0xdf, 0xec, 0x46, 0xa9, 0x95, 0x0e, 0xce, 0x1b, 0x80,
0xaf, 0x36, 0xa1, 0x29, 0xda, 0xcf, 0x64, 0x55, 0x56, 0x75, 0xae, 0xd2, 0x5f,
0xdc, 0x26, 0x8e, 0xb3, 0x6e, 0x32, 0x56, 0x1e, 0x55, 0x25, 0xee, 0xff, 0xfc,
0x05, 0x34, 0xb4, 0xba, 0xf1, 0x5f, 0x5e, 0x6d, 0x83, 0x04, 0x6b, 0xad, 0x74,
0x23, 0x5b, 0x79, 0x0e, 0x77, 0xd3, 0x9a, 0xb2, 0x81, 0x77, 0xe1, 0xd3, 0x29,
0xb0, 0xe8, 0xa1, 0x59, 0xd2, 0xb7, 0xea, 0xcf, 0x5a, 0x94, 0x64, 0x83, 0x52,
0x0d, 0x89, 0x14, 0xba, 0x39, 0x33, 0xe8, 0xcb, 0xef, 0x75, 0x09, 0x13, 0xac,
0xb7, 0x3a, 0x29, 0x89, 0x52, 0xa9, 0xc2, 0x20, 0xd7, 0x45, 0xf7, 0x49, 0x9c,
0x74, 0x47, 0x55, 0x3d, 0x4c, 0x50, 0xa3, 0x55, 0x4d, 0x94, 0x97, 0xda, 0x1f,
0x44, 0x0f, 0x2f, 0x49, 0x40, 0x82, 0x98, 0x68, 0x33, 0xad, 0x83, 0x76, 0x44,
0xba, 0x91, 0x89, 0x8e, 0x52, 0x0f, 0x77, 0xca, 0x34, 0x8c, 0x85, 0xea, 0x15,
0x85, 0xf0, 0xa8, 0xa0, 0x4b, 0xf0, 0x78, 0x1b, 0x63, 0xa4, 0x87, 0xe1, 0x3e,
0x2f, 0x04, 0x05, 0x41, 0xa6, 0x55, 0x30, 0x85, 0x92, 0x30, 0x21, 0x79, 0xb0,
0x81, 0xb3, 0x88, 0xac, 0x5c, 0x9a, 0x51, 0x70, 0x1e, 0xac, 0x57, 0x39, 0x85,
0x16, 0xc6, 0xc0, 0x38, 0xa9, 0x08, 0x4a, 0xd3, 0x4d, 0x10, 0x2a, 0x4b, 0x43,
0x07, 0xd7, 0x87, 0x8d, 0xcc, 0x3e, 0x27, 0x1a, 0x2a, 0xb0, 0x3a, 0xc0, 0xfb,
0x23, 0x95, 0xa5, 0xec, 0x90, 0x07, 0xe5, 0x76, 0x81, 0xad, 0x60, 0xa8, 0x26,
0x53, 0xe4, 0x66, 0xdf, 0xfe, 0x14, 0xea, 0xe4, 0x8d, 0xe5, 0xe6, 0x47, 0xce,
0xfc, 0xa1, 0x53, 0x1c, 0xfb, 0xd5, 0x93, 0x91, 0xca, 0x96, 0x25, 0x5b, 0x73,
0xd0, 0xc4, 0x6a, 0xf0, 0x14, 0x38, 0x25, 0x3d, 0xd7, 0x4d, 0x81, 0xbf, 0x62,
0x94, 0xcb, 0xcc, 0x79, 0xc5, 0x0c, 0x83, 0xcf, 0x3b, 0xef, 0xb5, 0xd7, 0xb4,
0x96, 0xbf, 0x11, 0x06, 0x8b, 0x24, 0xa9, 0xc8, 0xfd, 0xef, 0x56, 0xf9, 0xd4,
0xfc, 0xf1, 0x29, 0xb4, 0xa7, 0x93, 0x68, 0x0b, 0x26, 0x74, 0x50, 0xb7, 0xaa,
0xfe, 0x1c, 0x3a, 0x62, 0xa5, 0x74, 0xe2, 0x28, 0x9b, 0x9d, 0x3f, 0xa4, 0x4e,
0xcd, 0x0b, 0xca, 0x87, 0x04, 0xaa, 0x51, 0x76, 0xa4, 0x3c, 0x50, 0xd0, 0x21,
0xd5, 0x09, 0xd3, 0x85, 0x7f, 0x32, 0x22, 0x1e, 0x39, 0xcf, 0x36, 0xab, 0x7b,
0x67, 0x35, 0xdd, 0x94, 0xd8, 0x8d, 0x4f, 0x87, 0xc9, 0xae, 0x9f, 0x69, 0xc8,
0xb3, 0xfe, 0x5b, 0x47, 0x4b, 0xc2, 0xa8, 0x23, 0x00, 0x07, 0x76, 0xa2, 0x56,
0x46, 0x03, 0xad, 0x37, 0x47, 0xa5, 0x1e, 0xce, 0xc4, 0x4c, 0xcd, 0x6f, 0x28,
0xed, 0x2b, 0x1f, 0x24, 0xe6, 0x22, 0x33, 0xed, 0x57, 0x64, 0xe7, 0x68, 0x2e,
0xa2, 0x6f, 0xdd, 0x54, 0xc3, 0xc2, 0xf1, 0x45, 0x53, 0x24, 0x27, 0x8f, 0xcd,
0x6d, 0x28, 0x7c, 0xb6, 0x77, 0xb6, 0xa7, 0x08, 0x45, 0x70, 0x4f, 0x2b, 0x7e,
0x6f, 0x27, 0x7e, 0xa3, 0x0e, 0x4d, 0x29, 0x82, 0xd7, 0xdb, 0x04, 0xda, 0xda,
0xf8, 0x1d, 0x36, 0xd8, 0xfd, 0x16, 0x58, 0x85, 0x63, 0xbb, 0xc0, 0x35, 0xfb,
0xe3, 0x76, 0x28, 0x89, 0x0b, 0x0a, 0x42, 0x72, 0x1b, 0x72, 0xe1, 0x29, 0x44,
0xfc, 0xe4, 0xe7, 0x36, 0x18, 0x60, 0x6d, 0x78, 0x12, 0xda, 0x71, 0x03, 0xb2,
0x53, 0x19, 0xce, 0x27, 0x56, 0x8f, 0x13, 0xf4, 0x7c, 0x92, 0x12, 0x07, 0xe9,
0x20, 0xee, 0xc6, 0x01, 0xe0, 0x8c, 0x94, 0xb3, 0xc8, 0x8e, 0x58, 0x3f, 0xdc,
0xe1, 0xc1, 0x12, 0x9d, 0xa8, 0x0f, 0x9a, 0x40, 0x84, 0x7e, 0x16, 0x64, 0x7b,
0xa8, 0x31, 0x64, 0x67, 0x26, 0x61, 0x5d, 0x2b, 0xd8, 0xe6, 0x8e, 0x90, 0x51,
0x9c, 0x22, 0x09, 0x15, 0x3d, 0xa9, 0x4a, 0x41, 0x0e, 0x21, 0x2f, 0x24, 0x65,
0xdb, 0x5f, 0x80, 0x03, 0x6f, 0x82, 0x4b, 0xd1, 0x79, 0x73, 0xac, 0x30, 0xb7,
0x1f, 0x4e, 0x64, 0xe1, 0x8c, 0xdc, 0xb9, 0x97, 0x42, 0xa7, 0x2f, 0x10, 0x6b,
0x65, 0x57, 0x1f, 0xb9, 0xd0, 0x4b, 0x36, 0x3a, 0x7a, 0x2f, 0x95, 0x34, 0xa7,
0xf7, 0xe1, 0x81, 0x7d, 0x38, 0x3f, 0x3a, 0x1c, 0xc2, 0xc1, 0x50, 0x7e, 0xb4,
0xb5, 0x93, 0x98, 0x3b, 0xc9, 0xb6, 0xbd, 0xa4, 0x6e, 0x2f, 0x41, 0xe7, 0x0c,
0x38, 0x67, 0xc0, 0xfb, 0x3e, 0x22, 0x0f, 0xbd, 0xbb, 0xda, 0xba, 0x93, 0x7a,
0xa5, 0x9d, 0x38, 0x19, 0x57, 0x41, 0xca, 0x43, 0x4e, 0x6d, 0x27, 0xbd, 0xdb,
0xf9, 0x33, 0x5e, 0xcf, 0xe2, 0xe6, 0x2c, 0x46, 0x9f, 0x47, 0xf1, 0x07, 0xed,
0x60, 0x17, 0x37, 0x4e, 0x4e, 0x9f, 0xfb, 0xe1, 0x41, 0x2a, 0x71, 0x90, 0xda,
0xba, 0x97, 0x8a, 0x56, 0xc6, 0x57, 0x45, 0x36, 0xb6, 0x0c, 0xe2, 0x3f, 0x4f,
0xf1, 0x71, 0x8a, 0xa9, 0xfb, 0x1f, 0x7c, 0xf5, 0x17, 0x23, 0x10, 0x12, 0xa4,
0xd1, 0x81, 0x8a, 0xca, 0x3f, 0xd5, 0x18, 0x1b, 0x28, 0xfe, 0xc5, 0x90, 0xaa,
0x1b, 0xb7, 0x0c, 0xf2, 0x1b, 0x0f, 0xbd, 0x4c, 0x02, 0x2f, 0x5f, 0x52, 0xec,
0xfd, 0x6f, 0x51, 0xfc, 0xdb, 0x6b, 0x7a, 0xf0, 0x8b, 0xfb, 0x89, 0xd6, 0x45,
0xd0, 0xd6, 0x14, 0x4e, 0xdf, 0xb8, 0xe9, 0x2d, 0xf0, 0x9c, 0x21, 0xe8, 0xed,
0xd3, 0xb8, 0xed, 0x34, 0x46, 0x2f, 0x8f, 0x91, 0xfa, 0xb1, 0xcb, 0x05, 0xda,
0x07, 0xe7, 0xc9, 0x44, 0x0b, 0x9c, 0x34, 0x82, 0xe7, 0x21, 0xdd, 0xd7, 0xd3,
0x76, 0xa1, 0xc3, 0x67, 0x70, 0xf0, 0x0c, 0x46, 0x6f, 0x8e, 0x91, 0xee, 0x3b,
0x4e, 0xfc, 0x7c, 0xfc, 0x57, 0xc7, 0x1e, 0x0a, 0xb9, 0xe1, 0xfc, 0x49, 0xc8,
0x41, 0x23, 0x8a, 0x17, 0x27, 0xa8, 0x14, 0xed, 0x28, 0x89, 0x16, 0x3f, 0x1a,
0x50, 0x0c, 0x11, 0x3f, 0x17, 0x99, 0xab, 0x13, 0xa5, 0x88, 0x86, 0x49, 0xce,
0x36, 0x33, 0x91, 0xea, 0x6e, 0xf6, 0x58, 0x18, 0xf4, 0x8b, 0x26, 0x24, 0x93,
0x6c, 0xe8, 0xc9, 0x0b, 0x5f, 0xc0, 0x08, 0x93, 0x9c, 0x1f, 0x10, 0xa5, 0x99,
0x40, 0xd9, 0x18, 0x34, 0xf1, 0xc4, 0x37, 0xa2, 0x76, 0xcd, 0x1f, 0xa3, 0x0c,
0x12, 0x9d, 0xdc, 0x40, 0xb9, 0x90, 0xb1, 0x72, 0x67, 0x03, 0x68, 0x66, 0x6b,
0xd5, 0xe3, 0x6b, 0xed, 0x82, 0x5d, 0x5f, 0xc2, 0xa0, 0xd0, 0x0b, 0x56, 0x75,
0xa7, 0xc4, 0xc7, 0xe9, 0xe4, 0xde, 0xa5, 0x91, 0xf2, 0xf0, 0xc2, 0xa1, 0x47,
0x5e, 0x8c, 0xa0, 0xce, 0xea, 0x65, 0xa3, 0x74, 0x4c, 0xd8, 0x81, 0x8c, 0xfc,
0xed, 0x98, 0xe2, 0x92, 0x5c, 0xd3, 0xcd, 0xe6, 0x9b, 0x9c, 0x25, 0x49, 0x59,
0xd3, 0x3c, 0xe7, 0xac, 0x83, 0xdb, 0xd0, 0xa0, 0x6c, 0x02, 0xbf, 0x7d, 0x47,
0x1f, 0xb3, 0x31, 0xa6, 0x6c, 0x25, 0x77, 0x8d, 0x48, 0x9a, 0xc0, 0x8b, 0x3c,
0x28, 0x48, 0x7a, 0x71, 0x82, 0x78, 0x04, 0x59, 0xb0, 0xa3, 0x5e, 0xd9, 0x30,
0xb2, 0x30, 0x5e, 0x91, 0x05, 0xd2, 0xa8, 0x91, 0x04, 0xd8, 0x16, 0x65, 0x18,
0x65, 0x59, 0x2b, 0xb2, 0xcc, 0xeb, 0x54, 0x19, 0xc4, 0x26, 0xe2, 0xe1, 0x99,
0xba, 0xfa, 0xf9, 0x04, 0x6a, 0x14, 0x74, 0x8b, 0x62, 0xd4, 0xcb, 0x7e, 0xc8,
0xc8, 0x9a, 0x04, 0x56, 0x30, 0xe1, 0x71, 0x69, 0x48, 0xd0, 0xc9, 0x8e, 0x70,
0x9d, 0xcb, 0x5e, 0x3b, 0x01, 0x2d, 0x55, 0xad, 0x0a, 0x1f, 0xd2, 0x62, 0x7b,
0x51, 0x93, 0xa2, 0x07, 0x39, 0x9f, 0x1c, 0x5d, 0x7c, 0xc2, 0x85, 0xdc, 0x7e,
0x78, 0xcf, 0x07, 0x0e, 0xe1, 0x1d, 0x75, 0x64, 0x84, 0x04, 0x57, 0x58, 0x8b,
0x5a, 0xb1, 0x03, 0x4d, 0xc9, 0x5a, 0x04, 0x9a, 0xe2, 0x11, 0x66, 0x50, 0xe4,
0x50, 0xa7, 0xc4, 0x6d, 0x2b, 0x3f, 0xd4, 0xa1, 0xf1, 0xf5, 0x46, 0xe6, 0x69,
0xe3, 0x4d, 0x29, 0x65, 0x6f, 0x75, 0xd7, 0x47, 0xf8, 0x40, 0x00, 0x3b, 0xa5,
0xde, 0xaa, 0x0b, 0x23, 0xe0, 0xdc, 0x01, 0x01, 0xdc, 0xb5, 0xe2, 0x91, 0x16,
0xfa, 0x8b, 0xe3, 0xf0, 0x0d, 0x33, 0xb1, 0x34, 0x55, 0x9e, 0x56, 0xd8, 0x95,
0xc1, 0x05, 0x91, 0x82, 0x76, 0xb5, 0xa5, 0xe6, 0x43, 0x0b, 0x4a, 0x5d, 0xdf,
0xf9, 0x09, 0xf9, 0x74, 0x2b, 0x09, 0xd5, 0x8c, 0x95, 0x8c, 0x53, 0x93, 0xc4,
0x57, 0xd1, 0xf0, 0x0a, 0xde, 0x74, 0x88, 0x4c, 0x4a, 0x8c, 0x22, 0xfd, 0xdc,
0x50, 0x69, 0x24, 0x81, 0x3f, 0xdb, 0x8b, 0xcd, 0xd5, 0xc9, 0x6f, 0xd1, 0x91,
0x83, 0x54, 0x5a, 0xe9, 0x78, 0xb4, 0xac, 0xb7, 0x20, 0xcc, 0x34, 0xad, 0x1f,
0x78, 0xec, 0x95, 0xd7, 0x91, 0xef, 0xcf, 0xb0, 0xff, 0x38, 0x78, 0x2a, 0xcc,
0x90, 0x28, 0xf2, 0x28, 0xfd, 0xd7, 0x37, 0x0b, 0x06, 0xca, 0x7c, 0x92, 0x66,
0x38, 0xbb, 0x1b, 0x1c, 0xcf, 0x99, 0x8b, 0x5f, 0xdd, 0x0f, 0x0d, 0xb3, 0x5c,
0xc5, 0x4d, 0x2a, 0x0b, 0x49, 0x80, 0xeb, 0xbe, 0xd0, 0x9c, 0xd7, 0x37, 0x23,
0xf3, 0x0a, 0x17, 0x97, 0x78, 0x29, 0xbf, 0xad, 0xfb, 0x1e, 0xe3, 0x3d, 0x5f,
0x36, 0x80, 0x9f, 0x6a, 0xa7, 0x22, 0x90, 0x7d, 0xb8, 0x91, 0x0e, 0xaf, 0xa5,
0x9f, 0xaa, 0x53, 0xb5, 0xcf, 0xb2, 0xc8, 0x33, 0xdc, 0x21, 0x03, 0xd2, 0xd2,
0x93, 0x74, 0x03, 0x95, 0x58, 0xa0, 0xe3, 0x1a, 0xb1, 0x59, 0xe2, 0x29, 0xe8,
0x28, 0xe8, 0xad, 0x19, 0x5c, 0x6a, 0x16, 0x58, 0x57, 0x0c, 0x29, 0x64, 0x49,
0xd9, 0xd3, 0x9f, 0xf9, 0x51, 0xcf, 0xfa, 0x01, 0x45, 0x4c, 0x61, 0xaf, 0x19,
0xd9, 0x10, 0xa9, 0xfc, 0xb4, 0x07, 0xfa, 0xa1, 0x5d, 0xa4, 0xa9, 0x8d, 0xb1,
0x1a, 0x71, 0xcf, 0x9c, 0x71, 0xc1, 0x94, 0x3c, 0x5b, 0x9b, 0xc3, 0x5d, 0x22,
0xfe, 0x4a, 0x0f, 0x80, 0x0d, 0x75, 0xff, 0x72, 0x42, 0x32, 0xf6, 0xd8, 0xd7,
0x07, 0x60, 0xb4, 0xa4, 0x57, 0xed, 0x96, 0x4d, 0x5c, 0xff, 0xd2, 0xec, 0x7d,
0x16, 0x3e, 0x8b, 0xf5, 0x95, 0xb1, 0x17, 0xa9, 0xe3, 0xa3, 0x44, 0x43, 0xda,
0x04, 0xde, 0x75, 0xe3, 0xe5, 0x49, 0xf9, 0x13, 0x59, 0xf0, 0xdf, 0xe6, 0x65,
0x75, 0xca, 0x26, 0x68, 0xc4, 0x96, 0xf2, 0x83, 0xc7, 0x50, 0x48, 0x03, 0xe6,
0x5a, 0xd3, 0x46, 0x7d, 0xc1, 0xa1, 0xed, 0x48, 0xd7, 0x40, 0xbd, 0x7e, 0x92,
0x3c, 0xeb, 0x50, 0xd7, 0x2b, 0xc6, 0x50, 0x96, 0xf1, 0x29, 0x03, 0x35, 0x46,
0xb5, 0x17, 0x5c, 0x15, 0x5e, 0x92, 0xac, 0xca, 0xc9, 0xea, 0xb9, 0x71, 0xf8,
0x70, 0x27, 0xa4, 0x71, 0x54, 0xd6, 0xad, 0x1e, 0xbf, 0x65, 0xfc, 0x7b, 0xb5,
0xe7, 0xd7, 0x7d, 0xf9, 0x1e, 0x74, 0xaa, 0xdb, 0xab, 0x34, 0x35, 0x71, 0x85,
0xb3, 0xa2, 0x45, 0xf6, 0xe6, 0x51, 0x30, 0x3f, 0x37, 0xc6, 0xc6, 0x8b, 0xb3,
0x3f, 0x5a, 0xb2, 0x5c, 0x5f, 0x7b, 0x66, 0x1f, 0x72, 0x0b, 0xdc, 0x8b, 0xe2,
0x42, 0x7d, 0xe9, 0xd0, 0x92, 0x8c, 0xbc, 0x87, 0x0a, 0x57, 0x0f, 0x2a, 0x34,
0x8b, 0x7b, 0x16, 0xc4, 0xe4, 0x9f, 0x37, 0xa0, 0x6e, 0x2a, 0xca, 0x0e, 0xac,
0x30, 0x4b, 0x87, 0x48, 0x6f, 0x59, 0xa6, 0xb4, 0x8e, 0x74, 0x95, 0x06, 0x64,
0xbd, 0x0b, 0xba, 0x04, 0x2f, 0x6c, 0x47, 0x96, 0xfb, 0xa3, 0xac, 0x96, 0x69,
0x90, 0x04, 0xa9, 0x34, 0x35, 0x26, 0xf5, 0xc1, 0x28, 0xae, 0xc7, 0x66, 0x81,
0xf6, 0x87, 0x83, 0xcb, 0xcf, 0xec, 0x46, 0xda, 0x3b, 0xad, 0x1f, 0xc2, 0x3b,
0xbb, 0x79, 0xac, 0xf6, 0x2d, 0x73, 0xde, 0x69, 0xbf, 0x6d, 0xf0, 0xee, 0xa3,
0xad, 0x30, 0x4a, 0xbb, 0x4a, 0xad, 0xef, 0x92, 0x37, 0xb6, 0xe2, 0xb3, 0x66,
0x34, 0x1a, 0x84, 0x4f, 0xc2, 0x50, 0xd9, 0xf4, 0xe8, 0xe4, 0x1d, 0x6d, 0x92,
0xb4, 0xda, 0xb0, 0xf6, 0x8d, 0x06, 0xe4, 0xe0, 0xef, 0xfb, 0x11, 0x98, 0xc2,
0xbe, 0x72, 0x9d, 0xbc, 0xab, 0x24, 0x40, 0x19, 0x94, 0x9e, 0x82, 0x11, 0xb0,
0x93, 0x1c, 0xb4, 0xbe, 0x4c, 0x2e, 0x6e, 0x23, 0xd6, 0x92, 0x06, 0xd1, 0xf3,
0x4e, 0xa9, 0xa9, 0xb0, 0xa6, 0x67, 0x36, 0xdb, 0x54, 0xd0, 0xa5, 0xfc, 0xc8,
0x81, 0xa2, 0xbf, 0x6a, 0x12, 0xd4, 0x09, 0xdb, 0xee, 0xee, 0xaf, 0x1e, 0xad,
0xcc, 0xa8, 0xea, 0x04, 0xdb, 0xfb, 0x20, 0xa3, 0x8e, 0x17, 0x0f, 0xad, 0xe8,
0x7b, 0xf0, 0xe4, 0x1f, 0x5a, 0x39, 0x0f, 0x0c, 0x52, 0x1f, 0x6e, 0xd4, 0xae,
0xae, 0xa3, 0xad, 0xc2, 0x0d, 0x86, 0x17, 0x20, 0x4e, 0x77, 0x89, 0xdf, 0xdc,
0x8a, 0x46, 0x04, 0xf5, 0x77, 0x4e, 0xfc, 0xc0, 0xc1, 0x86, 0x97, 0x6d, 0x32,
0x22, 0x53, 0x61, 0xa8, 0xb4, 0x5b, 0x32, 0x41, 0xb9, 0xd9, 0x20, 0xd3, 0x2b,
0x72, 0x21, 0x7d, 0xd5, 0x86, 0x2c, 0x19, 0x2f, 0xb3, 0x2f, 0xed, 0xc2, 0x71,
0x91, 0xbf, 0x74, 0xb0, 0x76, 0x58, 0x78, 0xd4, 0x8e, 0xc2, 0x2b, 0x06, 0xe5,
0x1a, 0x55, 0xcb, 0x3f, 0x44, 0x8b, 0x1b, 0x57, 0x1e, 0x7a, 0x05, 0xb5, 0x2f,
0x74, 0x17, 0x23, 0x5d, 0xb9, 0xef, 0xe1, 0x36, 0x7a, 0x52, 0xd4, 0x8c, 0x9a,
0x50, 0xf4, 0x7b, 0xe3, 0xd4, 0xee, 0x4f, 0xa1, 0x8f, 0x69, 0xc6, 0x3c, 0x90,
0xe7, 0xa7, 0xa9, 0x1e, 0x6c, 0x15, 0x7b, 0x54, 0xce, 0x95, 0xba, 0x1b, 0x36,
0xb4, 0x48, 0x0c, 0x0b, 0xcf, 0x3f, 0xa1, 0x5b, 0xac, 0x9b, 0x97, 0x91, 0x76,
0xca, 0xb7, 0x6e, 0x43, 0x99, 0x3b, 0xea, 0xca, 0x7c, 0xd2, 0x39, 0xc9, 0xe5,
0xef, 0xf0, 0x48, 0x3c, 0x0d, 0x5b, 0xcf, 0x40, 0x1d, 0x64, 0x88, 0x66, 0x43,
0xbd, 0xb4, 0x7f, 0xfe, 0xca, 0xd6, 0x92, 0x87, 0x87, 0xff, 0xd9, 0x55, 0x7e,
0xfa, 0x18, 0xd8, 0xfe, 0xe1, 0xa3, 0xf7, 0x21, 0x2e, 0xe8, 0x07, 0xe7, 0x1a,
0x07, 0xb2, 0x72, 0xd9, 0xc2, 0x48, 0x55, 0x13, 0x36, 0x2d, 0xee, 0xa1, 0xc3,
0x42, 0xeb, 0xbc, 0x14, 0x09, 0xcd, 0xff, 0xf4, 0xc7, 0x07, 0x3e, 0x85, 0x0e,
0xa6, 0x81, 0xea, 0x2a, 0x1d, 0x91, 0xfb, 0x45, 0xed, 0x22, 0x34, 0xc4, 0xb6,
0x11, 0xa7, 0xa0, 0x97, 0x2e, 0x33, 0x94, 0x90, 0x08, 0x33, 0x22, 0x6c, 0x47,
0x13, 0x55, 0x9d, 0x9c, 0x05, 0xc6, 0x2b, 0xd7, 0x77, 0x50, 0xef, 0xed, 0x80,
0x78, 0xa1, 0xaf, 0xc8, 0xac, 0xc8, 0x42, 0x44, 0xd8, 0xbe, 0x0d, 0x4e, 0x76,
0x80, 0x8b, 0x9c, 0xbe, 0xdf, 0xb0, 0x32, 0xfd, 0x6f, 0x27, 0xdb, 0xa0, 0xa3,
0xc0, 0x44, 0x4c, 0x85, 0xfd, 0xca, 0x4e, 0xc1, 0x14, 0x31, 0x97, 0x0e, 0x28,
0x7b, 0x2b, 0x34, 0x55, 0xce, 0xdb, 0xf7, 0x6c, 0x42, 0x4d, 0x8b, 0xf4, 0xd2,
0x55, 0xcf, 0xe7, 0x50, 0x07, 0x33, 0x44, 0x46, 0xc5, 0x0d, 0x6c, 0x27, 0x78,
0x0b, 0xbd, 0xc2, 0x18, 0xd5, 0x3d, 0xdb, 0x2f, 0xed, 0xc0, 0x71, 0xc1, 0x68,
0x41, 0x88, 0x8d, 0xcf, 0x1f, 0x53, 0x7f, 0x6d, 0x41, 0xfd, 0x36, 0xb4, 0xed,
0x2d, 0x94, 0x63, 0x92, 0x7c, 0xb9, 0x92, 0x5d, 0x9d, 0x2a, 0x75, 0xdf, 0x81,
0x5c, 0xe2, 0x5e, 0xf5, 0xf0, 0xcd, 0x29, 0xea, 0xf4, 0x76, 0xe4, 0xfd, 0xb9,
0xbb, 0xe8, 0x8b, 0x7f, 0xef, 0x52, 0x77, 0xd0, 0x0d, 0x44, 0xcb, 0xb6, 0xc1,
0x44, 0xb9, 0x8d, 0x4e, 0xa2, 0x66, 0xa5, 0xcc, 0x38, 0x3b, 0x51, 0x18, 0x14,
0x8d, 0x16, 0x99, 0x55, 0xdd, 0xca, 0x44, 0xb9, 0xab, 0xe2, 0xbc, 0x01, 0x4d,
0xf1, 0x98, 0x6a, 0x41, 0x1d, 0x92, 0x5e, 0x84, 0x3c, 0xea, 0x16, 0xdc, 0x5f,
0xf2, 0xa0, 0xbf, 0x36, 0xfd, 0xe8, 0xee, 0xb3, 0xe0, 0x7d, 0x0d, 0x32, 0xd2,
0xcf, 0x06, 0x20, 0x87, 0xd3, 0xdf, 0xd7, 0x51, 0xed, 0x48, 0xc7, 0x19, 0x44,
0x4d, 0xdc, 0x70, 0x69, 0x0b, 0x1e, 0x2e, 0xd5, 0xf2, 0xd5, 0x4b, 0x4a, 0xdc,
0x8b, 0xec, 0xe2, 0xae, 0xf9, 0xf6, 0xb2, 0x3a, 0xe1, 0x2e, 0x0f, 0xf2, 0xca,
0xf4, 0xa8, 0x6c, 0xe0, 0xe6, 0x08, 0xe5, 0xc6, 0x4e, 0x9e, 0x4f, 0x7b, 0x44,
0x09, 0x81, 0x47, 0xd1, 0x45, 0xd9, 0xb1, 0x0e, 0x2f, 0x71, 0x33, 0x0f, 0x3d,
0x1e, 0x90, 0xc5, 0x94, 0x19, 0x55, 0xa6, 0x72, 0xb2, 0x2a, 0x8c, 0x3f, 0xb2,
0x21, 0xe7, 0x6a, 0x27, 0x33, 0x35, 0x27, 0x49, 0x7a, 0xca, 0x1c, 0x3f, 0x89,
0x49, 0x07, 0x90, 0xad, 0xda, 0x03, 0xc7, 0xbc, 0x28, 0x01, 0xb9, 0x12, 0x9e,
0xf8, 0xb8, 0x56, 0xb6, 0x9f, 0xd4, 0x09, 0xa7, 0x84, 0xe3, 0x20, 0xab, 0x03,
0x1d, 0xed, 0x64, 0x63, 0x05, 0xfa, 0xda, 0x90, 0xdc, 0x22, 0xf1, 0xe2, 0x1e,
0x54, 0x87, 0xfa, 0x98, 0x1e, 0xa6, 0x45, 0x92, 0xc4, 0x0e, 0x95, 0x4d, 0xd5,
0x32, 0x67, 0x73, 0x2b, 0x5a, 0xd6, 0xbf, 0x9f, 0x3a, 0xb9, 0x99, 0x6a, 0xad,
0x30, 0x88, 0x87, 0x51, 0x58, 0xea, 0x2e, 0xf5, 0x0a, 0x13, 0x2a, 0x4b, 0x6d,
0x59, 0xa0, 0x0a, 0xdd, 0x6b, 0x96, 0x5a, 0x04, 0x1d, 0x6c, 0xb8, 0xe0, 0xcf,
0x76, 0xa4, 0x85, 0x9e, 0x55, 0x99, 0xb9, 0x2e, 0x08, 0xde, 0x84, 0x4c, 0x2f,
0xc3, 0xbb, 0xdf, 0x40, 0xf7, 0xe2, 0xd6, 0xf2, 0x1e, 0xf0, 0x4a, 0xc6, 0xb6,
0x93, 0x77, 0x87, 0xb1, 0xae, 0x2c, 0x86, 0xd2, 0x3f, 0xdc, 0x79, 0x00, 0x4d,
0xf9, 0x21, 0x2a, 0x1b, 0xda, 0xb0, 0x65, 0x3b, 0xea, 0x5c, 0x92, 0x5a, 0x60,
0x91, 0x54, 0x35, 0x20, 0x77, 0x91, 0xa7, 0x66, 0xaa, 0xec, 0xe3, 0x0d, 0x9d,
0xe5, 0xdf, 0x9a, 0xa0, 0x81, 0x1e, 0x55, 0xfb, 0x96, 0x4c, 0xa9, 0x1a, 0x6b,
0x53, 0xb4, 0x53, 0xd0, 0x7f, 0x43, 0xfd, 0x6d, 0x3e, 0xaa, 0xd7, 0x80, 0xb7,
0xd9, 0xa8, 0xf6, 0xc5, 0x96, 0x66, 0x68, 0x91, 0x49, 0x82, 0xf8, 0xf8, 0x79,
0xd0, 0xd4, 0x43, 0x87, 0x05, 0xa6, 0xb8, 0x4f, 0xde, 0x41, 0xdd, 0x4c, 0x9a,
0x8a, 0x2d, 0x0c, 0xb1, 0x5d, 0x15, 0x2b, 0xad, 0xb4, 0x96, 0xf4, 0x55, 0xda,
0xe5, 0x06, 0x6c, 0x90, 0xb9, 0x89, 0xf5, 0xc7, 0xa3, 0xf3, 0xe2, 0xf8, 0x94,
0x1b, 0x19, 0x66, 0x55, 0x19, 0xa5, 0xd9, 0xf9, 0x23, 0xca, 0x5e, 0xba, 0x9b,
0xd2, 0x93, 0x2e, 0xb9, 0x99, 0x9a, 0x5c, 0x95, 0x56, 0x3e, 0x6d, 0x11, 0x64,
0x25, 0x2f, 0x6a, 0x90, 0x89, 0x19, 0x67, 0xf9, 0xdb, 0xaf, 0xca, 0x2b, 0xeb,
0x28, 0xd7, 0xad, 0x4d, 0x54, 0x0e, 0xd3, 0x9d, 0x4c, 0x5a, 0x3a, 0x05, 0x69,
0x15, 0x49, 0xcc, 0x4f, 0x0a, 0x4e, 0x9c, 0x84, 0x2f, 0x1e, 0xe7, 0x1d, 0x35,
0x27, 0xcb, 0x57, 0x80, 0x68, 0xa4, 0xb8, 0xa7, 0xb0, 0xa7, 0xaa, 0x13, 0x59,
0x38, 0x4d, 0xad, 0xb6, 0xd4, 0xcb, 0x46, 0x6a, 0xfa, 0xb9, 0x68, 0xed, 0x89,
0xb7, 0x50, 0x3d, 0xf6, 0x91, 0x7c, 0x89, 0xbd, 0x74, 0x84, 0x4e, 0x40, 0xa3,
0xb8, 0x9e, 0x1a, 0x27, 0x19, 0xbc, 0xc2, 0x07, 0x8d, 0x42, 0xeb, 0x17, 0xe4,
0xf4, 0xc7, 0x44, 0x2b, 0xda, 0x68, 0xae, 0x1c, 0x21, 0x4e, 0x49, 0xff, 0xec,
0x66, 0x32, 0x22, 0x0c, 0xb0, 0xc8, 0x02, 0x31, 0xd4, 0x0c, 0xfc, 0x95, 0x57,
0x1c, 0xe6, 0x4c, 0xb0, 0x60, 0x14, 0x4c, 0xd0, 0x27, 0xca, 0x60, 0x8d, 0x7c,
0xbd, 0x47, 0x62, 0x17, 0xed, 0x3d, 0x80, 0xf6, 0x91, 0x76, 0xb6, 0x5e, 0x30,
0xc5, 0x46, 0xd1, 0x72, 0x67, 0x49, 0x27, 0x6d, 0xc5, 0x6d, 0x92, 0xbe, 0xe2,
0x90, 0xa2, 0x57, 0xa5, 0x2f, 0xf2, 0xc0, 0xef, 0x9d, 0x2a, 0x4f, 0x6d, 0xaa,
0x76, 0xe4, 0x45, 0xbc, 0xd3, 0x4d, 0x4d, 0xdc, 0x1a, 0x07, 0xbd, 0xf8, 0x90,
0xaa, 0x6d, 0x9e, 0x83, 0x69, 0xbb, 0xd5, 0x5c, 0xd4, 0xfd, 0xdc, 0x6b, 0x47,
0x91, 0x81, 0x9b, 0x10, 0x2c, 0x58, 0x37, 0xa8, 0x6e, 0xc5, 0x9d, 0xb2, 0x1e,
0xd6, 0xcf, 0xd7, 0x6a, 0x1b, 0x7d, 0xa2, 0x11, 0x26, 0xc2, 0x26, 0xf3, 0x7f,
0x56, 0x8f, 0xe0, 0xfe, 0x66, 0xf2, 0x99, 0x95, 0x18, 0x19, 0x3f, 0x3b, 0x05,
0x06, 0x8a, 0xee, 0xe1, 0xea, 0x28, 0x2f, 0x6b, 0xc0, 0xcd, 0xc8, 0x80, 0xfa,
0xd9, 0xb8, 0xc8, 0xce, 0x38, 0xf9, 0x66, 0xcd, 0x41, 0xb5, 0xc8, 0x8d, 0xc5,
0x39, 0x2a, 0x52, 0xbc, 0xc7, 0x89, 0x26, 0xe5, 0x3a, 0x79, 0x44, 0xdd, 0x55,
0x30, 0x81, 0x93, 0xb4, 0x87, 0xbb, 0xb7, 0x4e, 0xd0, 0x48, 0x8d, 0xfd, 0x74,
0x43, 0xfc, 0x7b, 0x27, 0x93, 0x10, 0x5b, 0x10, 0x5d, 0xdf, 0xfd, 0xf3, 0xb3,
0x3e, 0xf4, 0x5c, 0xd5, 0x6f, 0x3b, 0x81, 0xe8, 0x21, 0x02, 0x11, 0x92, 0x16,
0x8a, 0xec, 0x24, 0x8c, 0xb3, 0xb8, 0x91, 0x1d, 0x81, 0x14, 0x0a, 0x30, 0x15,
0x05, 0x29, 0xe6, 0x99, 0x3e, 0xca, 0x80, 0xea, 0xc5, 0x19, 0x76, 0xae, 0x59,
0xc0, 0x0d, 0x22, 0xbb, 0xb0, 0x85, 0x3c, 0x67, 0xa3, 0x62, 0xcc, 0x84, 0x28,
0xa7, 0x98, 0x20, 0x64, 0x75, 0x14, 0xe2, 0x6c, 0x1f, 0x09, 0x82, 0x5b, 0x64,
0xa6, 0xb5, 0xb4, 0x9e, 0x1a, 0xe6, 0x15, 0x1c, 0xa0, 0xca, 0xa6, 0xf8, 0x76,
0xc2, 0x8a, 0xcc, 0x82, 0x1c, 0x6e, 0x9a, 0xd5, 0x8e, 0x27, 0x15, 0xfb, 0x0f,
0xa1, 0x56, 0x3b, 0xf5, 0xea, 0x71, 0xe2, 0x3d, 0x4e, 0x5e, 0x79, 0x85, 0x6a,
0xa2, 0xcd, 0xf3, 0x07, 0x67, 0x0f, 0x96, 0x0e, 0x95, 0x37, 0x53, 0x63, 0x30,
0x56, 0x64, 0xac, 0x09, 0x2d, 0xcb, 0xaa, 0xbe, 0x76, 0xa2, 0xe0, 0x86, 0x78,
0x59, 0x87, 0xaa, 0xfe, 0xc7, 0xc7, 0x52, 0xd0, 0xf6, 0x1a, 0xf5, 0x4e, 0x07,
0xe9, 0xa4, 0xbb, 0x0b, 0xea, 0x1e, 0x18, 0x15, 0xb8, 0xc4, 0x67, 0x5f, 0x02,
0xeb, 0x62, 0xa7, 0x11, 0xc2, 0x25, 0xc7, 0x3d, 0x28, 0xc9, 0x2d, 0x69, 0x84,
0x2e, 0x59, 0x07, 0x24, 0xa1, 0xbb, 0xa0, 0x19, 0x9b, 0xb1, 0x9f, 0x6a, 0x82,
0x45, 0x77, 0x0d, 0xb0, 0x2d, 0xe5, 0xbc, 0xf6, 0xd2, 0x4e, 0x29, 0xad, 0x41,
0x59, 0x59, 0x52, 0x60, 0x13, 0xb4, 0xcb, 0x5a, 0x6b, 0xb4, 0x64, 0x8a, 0x27,
0xca, 0x1c, 0x4c, 0xd6, 0x5e, 0xe0, 0xb9, 0xfd, 0xd7, 0x9a, 0x7f, 0xfa, 0xa2,
0x0f, 0x3a, 0xcd, 0xd4, 0x8e, 0x49, 0xbe, 0x75, 0x6b, 0x2c, 0xbc, 0x78, 0x5b,
0x92, 0x13, 0xd5, 0xbd, 0x44, 0x0e, 0x9c, 0xc7, 0x07, 0x8c, 0x30, 0x0c, 0x5a,
0xa5, 0x0b, 0xaf, 0x0b, 0x60, 0x23, 0xce, 0xb1, 0x49, 0x6c, 0x67, 0x0c, 0x54,
0x1d, 0xdc, 0xda, 0x42, 0x42, 0xd8, 0x3e, 0xb7, 0x85, 0x69, 0x2c, 0xd3, 0xb0,
0x71, 0x08, 0xd1, 0x69, 0x2a, 0x49, 0xc2, 0x92, 0x46, 0x29, 0x8f, 0x5b, 0x95,
0x59, 0xd8, 0x7d, 0x9d, 0x0b, 0x76, 0xd8, 0x90, 0x1f, 0x34, 0xca, 0x14, 0x97,
0x2d, 0x68, 0x85, 0x30, 0xd1, 0x28, 0x87, 0xa8, 0x00, 0xed, 0xae, 0xe6, 0xb3,
0x70, 0x89, 0x71, 0x79, 0x84, 0x7a, 0xe5, 0x25, 0xbe, 0x23, 0x9c, 0x84, 0x09,
0x99, 0x59, 0xe5, 0x47, 0x1d, 0x25, 0x23, 0xa2, 0x06, 0xe8, 0x9a, 0x55, 0x2f,
0x36, 0x70, 0x7a, 0xd0, 0xc3, 0x33, 0x49, 0x9e, 0xd4, 0xfb, 0x65, 0xe3, 0xe0,
0xa2, 0x9a, 0x98, 0xdf, 0x98, 0x50, 0x54, 0xda, 0xc4, 0x58, 0xb8, 0x3e, 0xb1,
0x87, 0x6b, 0x66, 0xdd, 0x74, 0xbc, 0x20, 0x2a, 0xd8, 0xba, 0x0f, 0x75, 0xcf,
0xd6, 0x2f, 0xef, 0x17, 0x77, 0x82, 0x8e, 0x44, 0x7f, 0xe4, 0x90, 0x44, 0x24,
0x83, 0x38, 0x07, 0x9a, 0xeb, 0x73, 0xb3, 0xb6, 0x06, 0x90, 0xff, 0xc7, 0xa3,
0xca, 0x8e, 0x1f, 0xc6, 0xe7, 0x38, 0x0a, 0x86, 0x67, 0x05, 0xf0, 0xc5, 0x36,
0xe8, 0x9d, 0xd5, 0x29, 0xd7, 0x38, 0xc8, 0x31, 0x3d, 0x65, 0x64, 0x9b, 0x99,
0x71, 0xb9, 0x0b, 0x7b, 0x89, 0x43, 0xa6, 0x01, 0xeb, 0xb2, 0x46, 0xdc, 0x26,
0xbc, 0xaf, 0x47, 0x9e, 0x50, 0xae, 0x4c, 0xe3, 0xf1, 0x9a, 0xc1, 0xd2, 0x73,
0xdb, 0x90, 0x4d, 0xd9, 0xf8, 0x78, 0x27, 0xdd, 0xb7, 0x2c, 0x43, 0x46, 0x98,
0xa9, 0x2c, 0xfe, 0xb6, 0x19, 0x6f, 0xf9, 0x14, 0xf4, 0x82, 0x36, 0xb6, 0x43,
0x1c, 0x00, 0xbe, 0xe6, 0x6e, 0x91, 0xeb, 0x29, 0x27, 0x6a, 0x66, 0x4d, 0x9c,
0x45, 0x66, 0xc3, 0x5d, 0xa4, 0x9f, 0x32, 0xa2, 0x3e, 0xe2, 0x16, 0x77, 0x03,
0xd4, 0xa3, 0xac, 0xd2, 0x81, 0xeb, 0x61, 0x08, 0x2f, 0x4d, 0x57, 0x6a, 0x21,
0x80, 0x92, 0xb2, 0xe6, 0x22, 0x37, 0xb8, 0x41, 0xc7, 0x4e, 0x15, 0x68, 0x05,
0xc7, 0x5e, 0x45, 0x9e, 0xa5, 0xe9, 0x85, 0x83, 0x6a, 0xfb, 0x2d, 0x49, 0xc6,
0xba, 0x54, 0xc3, 0x5a, 0x44, 0x67, 0xbb, 0xa1, 0x89, 0x6b, 0x54, 0xa7, 0xb5,
0x10, 0x5a, 0x6c, 0xac, 0x3e, 0xbc, 0x03, 0xce, 0x3d, 0xe6, 0x28, 0xe8, 0x28,
0x8d, 0x14, 0x6b, 0x7f, 0x6d, 0x46, 0xc1, 0xc2, 0xfa, 0xaa, 0x57, 0x77, 0xa2,
0x51, 0x3b, 0x75, 0xb4, 0x89, 0xe4, 0xaa, 0xea, 0x9e, 0x3a, 0xb1, 0xa8, 0x6b,
0xce, 0x87, 0x5b, 0x50, 0xb7, 0x34, 0xc6, 0x86, 0x71, 0x1c, 0x8d, 0x53, 0x46,
0xc6, 0x84, 0xdb, 0xc9, 0x82, 0x4e, 0x2a, 0x24, 0xb4, 0x91, 0xe7, 0x72, 0xc4,
0x8d, 0x02, 0x44, 0xc7, 0x47, 0xcc, 0x49, 0x25, 0x50, 0x27, 0xf6, 0xb3, 0xc3,
0x9c, 0x8e, 0x38, 0x90, 0x03, 0xf5, 0xa0, 0x0c, 0x9f, 0xd2, 0xad, 0x02, 0x1f,
0x72, 0x21, 0x07, 0xe3, 0xc5, 0xab, 0x86, 0x50, 0x8e, 0xd4, 0xd3, 0x75, 0x6c,
0x2b, 0x65, 0xe5, 0x93, 0xb8, 0x97, 0x0b, 0xb0, 0x11, 0x1c, 0x97, 0x58, 0x89,
0x16, 0xba, 0xf9, 0xda, 0x76, 0x4d, 0x93, 0x74, 0x25, 0x7a, 0xe4, 0xc1, 0x3a,
0x62, 0xa7, 0x73, 0xc4, 0x0c, 0x5b, 0xf7, 0xa0, 0x84, 0x22, 0x88, 0x7c, 0x02,
0x07, 0x34, 0xdd, 0x6b, 0xa1, 0x8d, 0x02, 0x1d, 0xe7, 0x47, 0xb6, 0xeb, 0xb2,
0xe2, 0x23, 0x36, 0x88, 0xd1, 0x6b, 0xfc, 0x28, 0xa1, 0xe2, 0x15, 0xa2, 0x3a,
0xf0, 0x30, 0xe9, 0xa5, 0x27, 0x51, 0x7f, 0x51, 0x50, 0xd4, 0x87, 0xa2, 0x12,
0x33, 0xe3, 0x90, 0x8d, 0xe2, 0x0e, 0x92, 0xa1, 0x53, 0x30, 0xa5, 0x6c, 0x03,
0x7d, 0xa9, 0x8f, 0x8e, 0x2b, 0xfb, 0xe8, 0x0f, 0x52, 0x60, 0xde, 0x05, 0xe1,
0x8a, 0x21, 0xc1, 0x5b, 0xa7, 0x60, 0xb5, 0x0e, 0x86, 0xff, 0x71, 0x72, 0x79,
0x7d, 0xd1, 0xfe, 0x47, 0x5f, 0x5b, 0xe6, 0xfe, 0xd7, 0x8e, 0x39, 0xcf, 0x1e,
0xf8, 0x12, 0x7e, 0xeb, 0xe0, 0x86, 0x99, 0x04, 0x64, 0x6f, 0xa9, 0x93, 0xb4,
0xfd, 0x53, 0x68, 0x6e, 0xf3, 0x4d, 0xfb, 0x76, 0x23, 0x9b, 0x24, 0x2c, 0xf2,
0x48, 0x9a, 0xb1, 0x9b, 0x5e, 0x04, 0x43, 0xb4, 0x83, 0x0c, 0x92, 0xb1, 0xc2,
0x41, 0x98, 0x3b, 0x41, 0x3d, 0x15, 0x5f, 0x64, 0x52, 0xfa, 0xa9, 0xfa, 0x12,
0x87, 0xf2, 0x37, 0x16, 0x65, 0x23, 0xa6, 0xb3, 0x90, 0xa1, 0xd6, 0x6e, 0xed,
0x86, 0x88, 0x74, 0x5c, 0x14, 0xa1, 0x26, 0x05, 0x11, 0xb5, 0x85, 0x33, 0x09,
0x79, 0x4e, 0x98, 0xaf, 0x5f, 0xac, 0x97, 0xc5, 0x24, 0xd1, 0x79, 0xb7, 0x6e,
0x3d, 0xc0, 0x13, 0x58, 0x04, 0x02, 0x8a, 0x4e, 0x95, 0x9f, 0x36, 0xa8, 0x32,
0xf2, 0x2c, 0x72, 0x2f, 0x1e, 0x11, 0xf5, 0xc8, 0x3c, 0xd2, 0xa0, 0xcc, 0x83,
0x86, 0xe8, 0x26, 0xf6, 0xde, 0x21, 0x62, 0x16, 0x45, 0x15, 0xfd, 0xd8, 0x7b,
0x00, 0x7f, 0xe4, 0xc2, 0x07, 0x92, 0x90, 0x16, 0xf0, 0x7d, 0xb9, 0xe2, 0x98,
0xe2, 0xae, 0xac, 0x64, 0x72, 0xe9, 0xc0, 0x61, 0xb2, 0xc9, 0xc7, 0x17, 0xfc,
0x8e, 0x02, 0xcf, 0x0a, 0xf3, 0xac, 0x2f, 0xb2, 0xa0, 0x55, 0x0c, 0xda, 0xa8,
0xc3, 0x46, 0xfc, 0xf2, 0x41, 0x38, 0xf3, 0x6f, 0x31, 0xde, 0x73, 0x36, 0x99,
0x59, 0xa9, 0x17, 0xf2, 0xe9, 0x7a, 0x7b, 0xc7, 0xed, 0x49, 0xec, 0x16, 0x07,
0x29, 0x03, 0xd3, 0xb6, 0xc4, 0x84, 0xec, 0x82, 0x61, 0xa9, 0x1b, 0xf6, 0xef,
0x40, 0xdd, 0x0a, 0x2b, 0x31, 0xa3, 0x30, 0xf7, 0x84, 0x4d, 0x18, 0x55, 0xb7,
0xcb, 0xc2, 0x5b, 0xa1, 0x49, 0x30, 0xa6, 0xd4, 0x49, 0xbb, 0xc4, 0x1f, 0x6f,
0x47, 0x29, 0xe2, 0x2c, 0x36, 0x89, 0x47, 0x99, 0xcc, 0xcd, 0xc6, 0xe7, 0x6d,
0x7c, 0x42, 0xd7, 0x8b, 0x2f, 0x7c, 0x04, 0x91, 0x1d, 0x60, 0x95, 0x0e, 0x94,
0x6e, 0xd3, 0xa2, 0x4c, 0x79, 0x92, 0xb4, 0xe2, 0xb6, 0xca, 0xa1, 0x5b, 0xe3,
0x2b, 0x5c, 0xf7, 0x9c, 0xe5, 0x6f, 0xac, 0x79, 0x4d, 0xab, 0x03, 0xaf, 0xc2,
0x57, 0x21, 0x34, 0x59, 0x1b, 0x2d, 0xed, 0x55, 0xd7, 0x15, 0x76, 0xdc, 0x34,
0x65, 0x82, 0xfd, 0x2e, 0x94, 0x24, 0x7a, 0x91, 0xab, 0xd0, 0x28, 0x1b, 0x57,
0x35, 0x97, 0xb6, 0x2c, 0x1c, 0x98, 0x17, 0x58, 0xdf, 0x8b, 0x2e, 0x9a, 0x51,
0xf6, 0xe6, 0x00, 0x09, 0xd5, 0xfa, 0x6f, 0xd7, 0x8a, 0x75, 0x8f, 0xbc, 0xf2,
0x06, 0x38, 0x7f, 0xdc, 0xfe, 0x1f, 0x3d, 0xf0, 0xe7, 0x56, 0x14, 0x62, 0xc6,
0xa9, 0x58, 0x79, 0xb8, 0x32, 0x27, 0x1c, 0x2b, 0xb0, 0xd6, 0x4c, 0xdc, 0x38,
0x39, 0x88, 0x4f, 0x38, 0xf0, 0x9b, 0x9d, 0x60, 0xf8, 0x9c, 0xa0, 0x4f, 0xbf,
0xc6, 0xd1, 0x22, 0x2b, 0x6d, 0x83, 0x04, 0x89, 0x57, 0x27, 0x0e, 0xe2, 0xed,
0x6e, 0xca, 0xe2, 0xa6, 0xd0, 0xab, 0x5a, 0xaa, 0x55, 0xe0, 0x2d, 0xd0, 0x4a,
0x26, 0xf9, 0x86, 0xa7, 0x87, 0xb4, 0x9d, 0x20, 0xa7, 0x23, 0xa4, 0x19, 0xc7,
0x85, 0xc3, 0xc2, 0x1e, 0x2a, 0x26, 0xff, 0x5d, 0x4c, 0x92, 0x43, 0xf5, 0x93,
0xf8, 0xcc, 0x59, 0x3c, 0x78, 0x16, 0x7f, 0x15, 0xc1, 0xa3, 0x11, 0x7c, 0xf2,
0x08, 0x4e, 0xaa, 0x73, 0x0a, 0xad, 0x09, 0x9f, 0xdd, 0x84, 0xb7, 0x1a, 0x50,
0xb8, 0x3a, 0xa8, 0x36, 0xce, 0x99, 0x2a, 0x8d, 0x49, 0xb2, 0x77, 0x3a, 0x6e,
0x49, 0xd2, 0x4d, 0xb2, 0x0f, 0xde, 0x44, 0x83, 0x77, 0x04, 0xf1, 0x44, 0xe5,
0xe8, 0x23, 0x9b, 0xdb, 0x21, 0x59, 0x39, 0x5c, 0xd6, 0xbe, 0x66, 0xe4, 0xa7,
0x63, 0xf8, 0xc2, 0x51, 0x08, 0x78, 0xe0, 0x48, 0x2f, 0xe8, 0xa8, 0x6c, 0x61,
0x23, 0xd7, 0x39, 0xbf, 0x71, 0xfe, 0x9e, 0xdb, 0xf5, 0xd7, 0xbd, 0xff, 0xd8,
0x05, 0xa1, 0x13, 0xc7, 0x78, 0x6d, 0xd0, 0xb7, 0x17, 0x89, 0x46, 0x43, 0xa1,
0xf7, 0x42, 0x64, 0x12, 0x77, 0x05, 0xc8, 0x9e, 0x97, 0x49, 0x54, 0x9e, 0xda,
0x44, 0x2e, 0x7c, 0x82, 0x9f, 0xcb, 0x60, 0xd3, 0x92, 0x5b, 0xba, 0xdd, 0xf8,
0xe3, 0x4d, 0x38, 0xb5, 0x89, 0x6f, 0x4a, 0xdf, 0x3d, 0x48, 0x75, 0x1c, 0xa4,
0x4e, 0xe9, 0xa9, 0x40, 0x45, 0xa0, 0x24, 0xfb, 0x3e, 0xdf, 0xc9, 0x6e, 0x27,
0xf6, 0xd9, 0xc3, 0xcb, 0x5a, 0x42, 0x78, 0x9b, 0x0b, 0x7b, 0xe6, 0x7f, 0x61,
0x46, 0xfc, 0xed, 0xc9, 0xac, 0xf3, 0xd0, 0x81, 0x73, 0xe4, 0xf5, 0x21, 0xd2,
0x3c, 0x44, 0xd0, 0xc5, 0x5e, 0x32, 0xdf, 0xfb, 0x27, 0x72, 0xe0, 0x6d, 0x62,
0x15, 0x3f, 0xe3, 0xc0, 0x5c, 0x1b, 0xb4, 0x92, 0xc9, 0x57, 0xc9, 0x67, 0x4e,
0xe2, 0x83, 0x35, 0x63, 0x8d, 0x64, 0xef, 0x5e, 0x52, 0x33, 0xe5, 0x20, 0x2f,
0x6e, 0x26, 0xab, 0x63, 0x3a, 0x72, 0x6c, 0x02, 0xf7, 0x09, 0xd2, 0x23, 0xf8,
0xfd, 0x2f, 0x71, 0xfc, 0x4b, 0xfc, 0xf2, 0xbb, 0xb8, 0xa9, 0x64, 0xd4, 0xc3,
0x4b, 0xfe, 0xd6, 0x8e, 0x35, 0x7b, 0xf0, 0xf1, 0x51, 0x14, 0x1b, 0xe5, 0x3b,
0xe3, 0x43, 0x83, 0x44, 0xb3, 0x3c, 0xe0, 0x27, 0x1f, 0xef, 0x25, 0x29, 0xbe,
0xd7, 0x3f, 0xbd, 0x1d, 0x6f, 0x31, 0xa0, 0xa1, 0x9d, 0xbc, 0x31, 0xfb, 0xde,
0x23, 0x4d, 0xef, 0x91, 0xd7, 0x9a, 0x48, 0x1b, 0xd2, 0x88, 0x4c, 0x37, 0x85,
0xc0, 0xfd, 0x31, 0x3e, 0xb5, 0x1d, 0x27, 0x0a, 0xfc, 0x92, 0xaf, 0x53, 0xd0,
0x7e, 0x82, 0x9c, 0xd8, 0x4b, 0xea, 0xd6, 0xb6, 0x9e, 0xc2, 0xe8, 0x2d, 0xbe,
0xd0, 0xd9, 0x4c, 0xa1, 0xcf, 0xbe, 0x22, 0xa3, 0xf4, 0x78, 0x86, 0xec, 0xec,
0x22, 0x7d, 0xd0, 0x23, 0x7c, 0xd2, 0xca, 0x8d, 0x23, 0x3d, 0x55, 0x4f, 0x9a,
0xf9, 0x32, 0xa7, 0x36, 0xca, 0xd3, 0x81, 0x93, 0xce, 0xd9, 0xc8, 0x2b, 0x3b,
0x88, 0x6b, 0x07, 0x39, 0xfc, 0x32, 0xc9, 0x30, 0x26, 0x89, 0x51, 0x1e, 0x1a,
0xc6, 0xe8, 0xdb, 0x24, 0x4e, 0x95, 0xf7, 0x15, 0xb6, 0x1f, 0xc0, 0x1f, 0xee,
0xc2, 0x89, 0x5d, 0xf8, 0x90, 0x11, 0x07, 0x8c, 0x18, 0x7d, 0xfa, 0x1a, 0x15,
0x67, 0xea, 0x5d, 0xd4, 0x9f, 0x1c, 0x54, 0x33, 0xd3, 0x74, 0xdf, 0x58, 0x61,
0x58, 0xac, 0x11, 0x0f, 0xc9, 0xdb, 0x85, 0xb6, 0x59, 0x29, 0xd1, 0xda, 0x4c,
0x17, 0x7e, 0xe7, 0x1d, 0xec, 0xa0, 0x03, 0xa4, 0x0f, 0xdb, 0xde, 0xc0, 0x5b,
0xec, 0xd8, 0x68, 0xc7, 0xc7, 0xf9, 0xcb, 0x02, 0x9f, 0xdb, 0x8f, 0x46, 0x61,
0x02, 0x75, 0x63, 0x2f, 0x37, 0x8c, 0x0b, 0xbb, 0xe8, 0x3a, 0xce, 0x0f, 0x49,
0x94, 0xe1, 0xdb, 0xe5, 0x71, 0x45, 0x60, 0x90, 0x7c, 0x72, 0x9a, 0xd8, 0x24,
0xdd, 0xa8, 0x93, 0xa7, 0xd6, 0xb4, 0xa4, 0x59, 0x1c, 0xe2, 0xaf, 0xda, 0x18,
0xdd, 0x53, 0x55, 0xbf, 0x38, 0x24, 0xb1, 0xaf, 0xf1, 0x08, 0xcf, 0x19, 0x51,
0x76, 0xb5, 0xb6, 0xd4, 0x08, 0x03, 0xbf, 0xdf, 0x63, 0x86, 0x31, 0xd5, 0x18,
0x6d, 0x95, 0xf7, 0x4a, 0x86, 0x2a, 0x5f, 0x3e, 0x09, 0xc6, 0x8a, 0x89, 0xeb,
0x92, 0xab, 0xd7, 0x05, 0x29, 0xe7, 0x1c, 0xf7, 0x9d, 0x59, 0xb5, 0x99, 0xfb,
0xd8, 0x0b, 0x9a, 0x52, 0x7d, 0x11, 0x1a, 0x2f, 0xcb, 0x28, 0x5b, 0x51, 0x3b,
0xf7, 0xca, 0x31, 0xd0, 0x53, 0x15, 0xa6, 0xe5, 0xad, 0xd0, 0x2e, 0x37, 0x15,
0x27, 0x60, 0x69, 0x8f, 0xbc, 0xa9, 0x50, 0xc7, 0x26, 0xc9, 0xef, 0x2d, 0x82,
0xbe, 0xea, 0xb6, 0x79, 0xed, 0xcc, 0xdb, 0x6d, 0x70, 0xba, 0x7c, 0xac, 0xd8,
0x41, 0x47, 0x95, 0xd1, 0xb2, 0xb7, 0xb6, 0x81, 0x77, 0x5e, 0xd7, 0xdd, 0x86,
0xa5, 0xaf, 0xff, 0xc1, 0x2b, 0x8f, 0x82, 0xff, 0xef, 0x13, 0x6c, 0xcf, 0x4b,
0x04, 0x1d, 0x7c, 0x85, 0x72, 0x93, 0x61, 0xf5, 0x24, 0xee, 0x06, 0x03, 0xd4,
0xb3, 0xbe, 0x73, 0x04, 0xbd, 0x91, 0x25, 0x43, 0x05, 0x53, 0x7c, 0x43, 0xd4,
0x03, 0x9a, 0x93, 0xe4, 0x9d, 0x13, 0x84, 0x77, 0xff, 0x97, 0x47, 0x49, 0xf6,
0x28, 0xd9, 0xb4, 0x97, 0x74, 0x0a, 0xc2, 0x3b, 0xc8, 0xd7, 0x93, 0x78, 0x9d,
0x5f, 0xb2, 0xb8, 0x8d, 0xee, 0xa7, 0x9a, 0xce, 0xe0, 0xfd, 0xef, 0xe1, 0x26,
0xba, 0x95, 0x1e, 0x2d, 0x48, 0xec, 0xc7, 0x9b, 0xf7, 0xe3, 0xa6, 0xd9, 0x07,
0x4e, 0x43, 0x66, 0xae, 0x4e, 0xd0, 0x73, 0x87, 0x69, 0x91, 0xad, 0xe4, 0xd8,
0x45, 0x08, 0xe1, 0x04, 0xee, 0x27, 0x9a, 0x02, 0x1d, 0xee, 0x17, 0x4d, 0x09,
0xad, 0x9c, 0x6b, 0xd6, 0x88, 0x34, 0x88, 0x1d, 0xd0, 0x22, 0xb4, 0x0b, 0x4d,
0x98, 0x35, 0x7f, 0xcf, 0x28, 0x74, 0xd2, 0xda, 0x39, 0x56, 0x95, 0x15, 0x62,
0x3b, 0xf1, 0x17, 0x5e, 0x4a, 0x8f, 0x3b, 0x49, 0x06, 0xb5, 0x70, 0xf4, 0x7a,
0x77, 0x85, 0x0d, 0x9c, 0x30, 0xac, 0x8c, 0xc3, 0xa0, 0xbc, 0xeb, 0xfa, 0x09,
0xd2, 0xcd, 0x57, 0xe2, 0x76, 0x4e, 0x0b, 0xeb, 0x1b, 0xc4, 0x23, 0x9c, 0x5d,
0x68, 0x15, 0x5b, 0x50, 0xc7, 0x1c, 0xfe, 0x66, 0x42, 0x43, 0x38, 0xa8, 0x68,
0x07, 0xb4, 0xbf, 0x0e, 0x39, 0x97, 0x9a, 0x4a, 0x0c, 0x30, 0xc9, 0x24, 0x6b,
0x02, 0xb3, 0xeb, 0x1f, 0xb6, 0x94, 0x7f, 0xbd, 0x1f, 0x65, 0xbc, 0xd4, 0x67,
0x47, 0x89, 0x8d, 0x1a, 0x94, 0x8e, 0x32, 0x8e, 0x55, 0x11, 0x2e, 0xc8, 0x65,
0x17, 0x5a, 0x8b, 0xc3, 0x60, 0x21, 0x6f, 0xff, 0xd0, 0xb7, 0xe1, 0xed, 0x66,
0x34, 0xb6, 0x15, 0xc6, 0xac, 0xb0, 0xa9, 0x1e, 0x85, 0x04, 0x3a, 0x6a, 0x90,
0x05, 0x27, 0xca, 0x0a, 0x1f, 0x98, 0xc2, 0x9d, 0x72, 0x1f, 0x19, 0xe2, 0x9c,
0xd5, 0x19, 0x34, 0x4a, 0x6e, 0x89, 0x48, 0x1c, 0xc4, 0x4f, 0xc6, 0x6e, 0xea,
0x57, 0x19, 0x4a, 0x83, 0x24, 0xb6, 0x1f, 0xbf, 0xb7, 0x0d, 0x0f, 0x33, 0x7a,
0xe5, 0x7e, 0x3e, 0x47, 0x1b, 0xc0, 0xad, 0xdc, 0x67, 0x42, 0x13, 0xd8, 0x83,
0x5c, 0x5c, 0x48, 0x62, 0x16, 0x3e, 0x5c, 0xc7, 0x76, 0x15, 0x46, 0x0a, 0xc2,
0x15, 0x46, 0x59, 0x33, 0xdb, 0x31, 0xd7, 0x2d, 0xac, 0x17, 0xfb, 0xa1, 0x19,
0x47, 0xd8, 0x09, 0x3c, 0xfd, 0x7f, 0x08, 0x85, 0xc3, 0xe5, 0x06, 0xc9, 0x91,
0xc3, 0xa8, 0x85, 0x68, 0x69, 0x3f, 0x84, 0xf7, 0x51, 0xaf, 0x5b, 0xf8, 0x9a,
0xc8, 0x59, 0xf4, 0x90, 0x4f, 0xc8, 0x03, 0xb8, 0x8d, 0x79, 0xfe, 0x01, 0x34,
0xce, 0x65, 0x28, 0xbe, 0x4d, 0xe8, 0x24, 0x67, 0xdf, 0x23, 0xa2, 0xd4, 0x7b,
0xe4, 0x83, 0xb7, 0x09, 0xf2, 0x89, 0xfb, 0xa0, 0xbd, 0x99, 0xbc, 0xe2, 0x23,
0x2e, 0x1f, 0x39, 0x79, 0x80, 0x78, 0xc4, 0xc8, 0xd3, 0x40, 0x4e, 0xef, 0x20,
0x1e, 0x1c, 0xb2, 0x90, 0x3f, 0x6f, 0x23, 0x13, 0xdb, 0x08, 0x7a, 0x27, 0x8b,
0x9d, 0xf2, 0x31, 0x36, 0xac, 0xd0, 0x33, 0x7a, 0xa8, 0xd1, 0x8b, 0x6b, 0xea,
0xd8, 0xa2, 0x67, 0x1d, 0x58, 0x83, 0x3a, 0xe9, 0xb6, 0x5d, 0x18, 0x6d, 0xdf,
0x42, 0x59, 0xb6, 0x50, 0xdf, 0x1e, 0x21, 0xc3, 0x0f, 0x3c, 0x10, 0x1d, 0xc4,
0x68, 0x3f, 0x7f, 0x8d, 0x56, 0xd9, 0x85, 0xa1, 0x71, 0x9e, 0xf8, 0x5e, 0x25,
0x7a, 0x79, 0x6e, 0x79, 0xfb, 0x92, 0xc6, 0xc3, 0xf8, 0xa2, 0x03, 0x67, 0xc5,
0x96, 0x97, 0xf2, 0x7f, 0xd2, 0x3a, 0xf2, 0x19, 0x3e, 0xf3, 0x1f, 0xf6, 0x95,
0xb6, 0x1b, 0x3a, 0x6b, 0x1d, 0xc7, 0xf1, 0x39, 0x03, 0x65, 0x99, 0xcd, 0xf7,
0x4a, 0xf3, 0xcd, 0xcf, 0xe9, 0x2a, 0x07, 0x64, 0xaf, 0xef, 0x43, 0xa6, 0x22,
0xdb, 0x2f, 0x74, 0x3f, 0xd1, 0xdf, 0xad, 0xa7, 0xc7, 0xf1, 0xeb, 0x09, 0x68,
0xa8, 0xe9, 0x33, 0xc3, 0xd9, 0x1c, 0xf4, 0xde, 0x36, 0xf0, 0x9f, 0x53, 0xcf,
0x1c, 0x79, 0x13, 0xe5, 0x20, 0x86, 0x43, 0x0b, 0xd2, 0x85, 0xfd, 0x38, 0x29,
0x6c, 0x96, 0x69, 0x84, 0xb6, 0x79, 0x4d, 0x02, 0x53, 0xe5, 0x38, 0xd7, 0x23,
0xea, 0x15, 0xc4, 0xa1, 0x59, 0x90, 0x41, 0xe3, 0xea, 0xa3, 0x26, 0xbe, 0xd0,
0x5e, 0xeb, 0x3a, 0x48, 0xa1, 0xf7, 0xb5, 0xd4, 0x00, 0x1a, 0xb9, 0x48, 0xfe,
0xf4, 0x15, 0xe9, 0x26, 0x1a, 0x30, 0xe1, 0xa9, 0x74, 0xfe, 0x8f, 0x6d, 0xc7,
0x1d, 0xa4, 0x8b, 0x9e, 0xda, 0x49, 0xce, 0xbe, 0x44, 0xc2, 0xe0, 0xaf, 0x23,
0x27, 0x2f, 0xe2, 0x9e, 0x8b, 0xf8, 0xf0, 0x59, 0xbc, 0xce, 0x09, 0x61, 0xbe,
0x7b, 0xf5, 0x26, 0x31, 0x3a, 0x15, 0xc0, 0x4a, 0xb7, 0xb4, 0x6d, 0x3f, 0x46,
0x5f, 0xbc, 0x80, 0x97, 0xb4, 0xbe, 0x80, 0xd1, 0xe7, 0x2e, 0xe2, 0x2a, 0xd1,
0xd4, 0x90, 0x8d, 0x2d, 0x8b, 0x8e, 0x7d, 0x0d, 0x12, 0x9d, 0x38, 0x49, 0xe5,
0x76, 0x51, 0xa7, 0xad, 0x54, 0x3b, 0x1b, 0x14, 0x59, 0x99, 0x46, 0x71, 0x16,
0x45, 0x57, 0x69, 0x7c, 0x04, 0xbd, 0x38, 0x8a, 0xeb, 0x8b, 0xc6, 0x93, 0xf8,
0xcd, 0xf7, 0xf1, 0x98, 0xb4, 0xe3, 0x28, 0xde, 0x62, 0xc4, 0x05, 0xe3, 0x2f,
0x62, 0xf4, 0xd9, 0xeb, 0x54, 0x80, 0xba, 0x77, 0x7c, 0x4e, 0xef, 0xb2, 0x5c,
0xb5, 0x57, 0x0f, 0xbc, 0x4b, 0xd4, 0x17, 0x3c, 0x68, 0x60, 0x5e, 0x0b, 0x72,
0x40, 0xbc, 0x38, 0xcd, 0xab, 0xf6, 0xf6, 0x45, 0xdc, 0x76, 0x11, 0xbf, 0x9f,
0xc4, 0x99, 0x39, 0x6f, 0x7d, 0x09, 0xad, 0x4c, 0xba, 0x81, 0xe7, 0xb3, 0x8f,
0xbc, 0x54, 0x48, 0xd2, 0x3b, 0x3b, 0xb1, 0x07, 0x4e, 0x7d, 0x00, 0x31, 0x71,
0x9f, 0x20, 0x5a, 0xf0, 0x94, 0x93, 0x92, 0x70, 0xe6, 0x82, 0x4e, 0xac, 0x5f,
0x61, 0x67, 0x3c, 0x38, 0x5f, 0x31, 0x4f, 0x22, 0x9b, 0x28, 0x21, 0x0f, 0x08,
0x3b, 0x99, 0x49, 0x92, 0x62, 0x06, 0x51, 0x67, 0x41, 0x33, 0x63, 0xac, 0x3d,
0xbd, 0x07, 0xb5, 0x48, 0x74, 0xd2, 0xd4, 0xcd, 0x39, 0x70, 0xcf, 0x7f, 0x36,
0x47, 0xd5, 0x2d, 0x6e, 0x54, 0x4e, 0xad, 0xca, 0x14, 0x0e, 0x96, 0x6c, 0x32,
0xa0, 0xe1, 0x1b, 0x06, 0xb8, 0x36, 0x69, 0x47, 0xf9, 0xae, 0x5f, 0x06, 0x6a,
0xfb, 0xab, 0x9b, 0xaf, 0x1f, 0x06, 0xdb, 0x92, 0xd8, 0xaa, 0x03, 0xaf, 0x20,
0x07, 0xb6, 0xc8, 0xdd, 0x05, 0x66, 0xf4, 0x44, 0x0e, 0x82, 0x5c, 0x2f, 0xeb,
0x84, 0x01, 0xe4, 0x93, 0xc7, 0x44, 0x1d, 0xc8, 0x22, 0x34, 0xa0, 0x6e, 0x48,
0xcb, 0xcc, 0xa2, 0x8c, 0x83, 0x9c, 0x6c, 0x20, 0xe3, 0xc4, 0x53, 0x6c, 0x66,
0x9c, 0xca, 0x2e, 0x90, 0xb5, 0xd3, 0x6d, 0x78, 0x04, 0x0d, 0xc0, 0xef, 0xec,
0xa2, 0x61, 0x59, 0xb3, 0xa2, 0x5e, 0xda, 0x49, 0xf6, 0x58, 0xd1, 0x84, 0xa8,
0x55, 0x50, 0xa7, 0x08, 0x97, 0xe8, 0x0b, 0x92, 0xd8, 0x0b, 0x09, 0x15, 0xdf,
0x98, 0xd2, 0x1d, 0x2b, 0x22, 0x0b, 0x22, 0xd2, 0xb8, 0x40, 0x77, 0x3b, 0xfd,
0x76, 0x00, 0xda, 0xe6, 0x4c, 0xde, 0xd2, 0x30, 0x6b, 0xff, 0x76, 0x24, 0xe9,
0x60, 0xec, 0xe2, 0xc6, 0x42, 0xa3, 0x32, 0x22, 0xd3, 0x28, 0x47, 0x99, 0x6e,
0xe4, 0xe3, 0x7a, 0xa9, 0x29, 0x85, 0x13, 0x5c, 0xdc, 0x78, 0x51, 0x8e, 0x1a,
0x54, 0x35, 0x91, 0x16, 0x88, 0xd0, 0x1d, 0x72, 0xb7, 0xc0, 0xcf, 0xf0, 0x24,
0x81, 0xbc, 0x6a, 0x67, 0xf5, 0xb9, 0x43, 0xa8, 0x8b, 0xf8, 0x4a, 0xa3, 0xd8,
0x5b, 0x1d, 0x26, 0x53, 0x73, 0x1a, 0xa5, 0x23, 0x76, 0xf2, 0xe5, 0x36, 0x62,
0x91, 0xda, 0xf1, 0x20, 0x19, 0x60, 0xa2, 0x74, 0x48, 0xd2, 0x5f, 0xd1, 0x4a,
0x07, 0x78, 0xdc, 0x4c, 0x42, 0x3d, 0x5d, 0xd1, 0x0f, 0x71, 0xf1, 0x6e, 0x0b,
0x7a, 0x7a, 0x94, 0x0c, 0xa1, 0x2a, 0x0f, 0x5e, 0x35, 0x52, 0xb4, 0xa2, 0x03,
0xc7, 0xb9, 0x06, 0x30, 0x71, 0x1a, 0xc6, 0x43, 0xb7, 0x17, 0xf5, 0x4a, 0x2c,
0xd0, 0x2d, 0x09, 0xd3, 0x4d, 0xc2, 0x46, 0x22, 0x5b, 0x1a, 0x25, 0x01, 0xe5,
0xf3, 0x77, 0x2d, 0xb5, 0x08, 0x5b, 0xaf, 0x6b, 0x54, 0xaa, 0x86, 0x85, 0x6e,
0x70, 0x20, 0x0b, 0x69, 0x14, 0xb6, 0x52, 0xd5, 0x69, 0xf4, 0x9a, 0x1d, 0xb5,
0xaf, 0xee, 0x03, 0xed, 0xc2, 0xfa, 0x9a, 0x98, 0x7c, 0x18, 0x0f, 0xd3, 0x07,
0xdd, 0xd0, 0x32, 0xa7, 0x99, 0x89, 0xde, 0xa1, 0xa5, 0x5b, 0xaf, 0x1b, 0xfd,
0x65, 0x4e, 0xde, 0x28, 0xfe, 0x7a, 0x18, 0x3c, 0x78, 0x62, 0x2b, 0x7c, 0xfe,
0x19, 0xb8, 0xd1, 0x92, 0x14, 0xbd, 0xd4, 0x25, 0x1d, 0x2f, 0xf4, 0x31, 0x31,
0x2e, 0x09, 0x56, 0xb0, 0x22, 0x03, 0x35, 0x24, 0x30, 0xb2, 0x4f, 0xfa, 0x21,
0x81, 0x88, 0x89, 0x4e, 0x50, 0xbc, 0x3c, 0x1c, 0xc6, 0x1a, 0x7a, 0xfd, 0xd3,
0xcf, 0x6b, 0x18, 0x3d, 0x4a, 0x0a, 0x53, 0x90, 0x23, 0x51, 0xb6, 0x97, 0x98,
0x79, 0x0a, 0x1d, 0x04, 0xad, 0xa0, 0x11, 0x8f, 0x2a, 0xc6, 0x2b, 0xe2, 0x38,
0x43, 0x3b, 0x14, 0xab, 0xec, 0xc8, 0x8e, 0x62, 0x7c, 0xad, 0x1c, 0x93, 0x36,
0x82, 0x28, 0x86, 0x6c, 0x65, 0xaf, 0x1f, 0x46, 0x41, 0xfe, 0x02, 0x8b, 0x73,
0xa3, 0x45, 0x3a, 0x92, 0xa4, 0x0c, 0xe2, 0x56, 0x65, 0x7f, 0x99, 0x7d, 0xee,
0x14, 0x1d, 0x2d, 0x49, 0x4a, 0xf5, 0xe2, 0x71, 0xc6, 0x26, 0xb6, 0x88, 0x7d,
0xca, 0xa7, 0xdb, 0x90, 0x83, 0x4c, 0x96, 0x9e, 0x3b, 0x8a, 0xb2, 0x7c, 0x25,
0xde, 0x82, 0x2d, 0x92, 0xb6, 0xd9, 0x3e, 0x98, 0x92, 0xb5, 0x93, 0x10, 0xf1,
0xc3, 0x28, 0x82, 0x7b, 0x35, 0xf4, 0x6f, 0x63, 0xc4, 0x5f, 0xd0, 0x0c, 0xa3,
0x7c, 0xcb, 0x61, 0x04, 0x0d, 0xd7, 0xc8, 0x85, 0x58, 0xd6, 0xc8, 0xd3, 0xc9,
0x10, 0x5f, 0x99, 0xd7, 0x41, 0x27, 0xf4, 0x12, 0x1f, 0x9b, 0x29, 0xec, 0x46,
0xfd, 0x92, 0x1e, 0x08, 0x08, 0xe3, 0xb8, 0x95, 0x6e, 0x80, 0x61, 0xca, 0x2f,
0x0f, 0xa0, 0x46, 0xf5, 0xc1, 0x3e, 0xc8, 0x6e, 0xe8, 0x5d, 0xd3, 0xa8, 0x3e,
0x75, 0x06, 0x06, 0xd1, 0x57, 0xd5, 0xe6, 0x5b, 0x0d, 0xb7, 0x7f, 0xb1, 0x15,
0xfa, 0xbf, 0x67, 0x96, 0x35, 0x91, 0x71, 0x94, 0x28, 0x37, 0x14, 0x78, 0x8a,
0x35, 0x6a, 0xb7, 0x28, 0x00, 0x1e, 0x34, 0x26, 0x9a, 0x5a, 0xaa, 0xb2, 0x14,
0x06, 0xd0, 0xf6, 0x97, 0x91, 0xa6, 0xca, 0x5b, 0xa2, 0xc5, 0x06, 0xc5, 0xd4,
0x33, 0x9f, 0xb4, 0x81, 0x9b, 0x4f, 0xd8, 0x7a, 0xac, 0x9f, 0xdb, 0xb5, 0x1b,
0x0e, 0x1f, 0x02, 0xec, 0xa5, 0x9d, 0x62, 0xab, 0xc0, 0x28, 0x98, 0xc0, 0xfa,
0x0a, 0x37, 0xd6, 0xe0, 0xdf, 0x4c, 0x2a, 0xac, 0xe0, 0x27, 0x7a, 0x2a, 0x41,
0xba, 0x45, 0x5d, 0xb4, 0xb1, 0x74, 0x18, 0x3d, 0x38, 0x0c, 0x39, 0xf9, 0x84,
0x22, 0x22, 0xb6, 0xf2, 0x4e, 0x08, 0xf0, 0xfc, 0x3e, 0x89, 0xc3, 0x84, 0x1d,
0x14, 0xda, 0x54, 0xaf, 0xfd, 0xa1, 0x97, 0x7e, 0xe3, 0x30, 0x8c, 0x10, 0x23,
0xd6, 0xa9, 0xbb, 0x64, 0x36, 0xd2, 0x32, 0xa7, 0x43, 0x1a, 0x16, 0x4d, 0x10,
0x2f, 0x15, 0x21, 0xed, 0xf2, 0x4c, 0xe1, 0xd4, 0xf2, 0xa9, 0x4a, 0x37, 0x78,
0x8b, 0x33, 0xa2, 0x0b, 0xff, 0x78, 0x80, 0xbf, 0x30, 0xb1, 0xfb, 0x33, 0x30,
0xcf, 0xdd, 0x7b, 0x1e, 0x5a, 0x7e, 0x72, 0x9a, 0xf2, 0x0a, 0x47, 0x37, 0x1e,
0x79, 0x1d, 0xfa, 0x67, 0xf7, 0x17, 0xee, 0x91, 0xf5, 0xdd, 0x98, 0x91, 0x0d,
0xa3, 0xfa, 0xea, 0x58, 0xb1, 0xb3, 0x64, 0x8a, 0x3e, 0xcf, 0xb7, 0x83, 0x2a,
0x2d, 0x36, 0x72, 0x55, 0xbe, 0xea, 0x84, 0x48, 0x14, 0xa7, 0x34, 0x78, 0x14,
0x35, 0xa1, 0x76, 0xb2, 0x28, 0x25, 0x99, 0xc4, 0xbf, 0x6d, 0xe2, 0x46, 0xab,
0x35, 0xd0, 0x41, 0xca, 0x74, 0x52, 0x8b, 0x24, 0x02, 0x03, 0x38, 0x81, 0x96,
0x47, 0xe5, 0x19, 0x71, 0xff, 0x51, 0xfc, 0xd5, 0x61, 0x3c, 0x86, 0x32, 0xdc,
0x85, 0x7f, 0xee, 0x14, 0xdd, 0x12, 0x96, 0xb5, 0xb3, 0xa7, 0x5f, 0x83, 0x06,
0x1c, 0xe5, 0xc6, 0x16, 0xa4, 0x71, 0x17, 0x4b, 0xda, 0xf8, 0x9e, 0xb8, 0x9b,
0x87, 0xaf, 0x8d, 0x0e, 0x15, 0x04, 0xd1, 0x6f, 0xc6, 0x50, 0x0b, 0xc4, 0xc9,
0xef, 0x93, 0x10, 0xe4, 0xdb, 0xd1, 0xda, 0x16, 0x69, 0x46, 0x14, 0x17, 0xb7,
0xd3, 0x3e, 0xbe, 0x09, 0xe1, 0x0d, 0x42, 0xe3, 0xe2, 0x61, 0xae, 0xca, 0x8d,
0x36, 0x3b, 0x50, 0x52, 0x3e, 0x5a, 0xd4, 0x8a, 0x1b, 0xc5, 0x43, 0xb5, 0xd9,
0xeb, 0xb3, 0xb8, 0x47, 0xd6, 0x8d, 0x9c, 0x65, 0xd6, 0xc2, 0x5c, 0x51, 0x1b,
0x8e, 0xb2, 0xbb, 0x5f, 0xe5, 0x03, 0x14, 0x3f, 0x41, 0xb6, 0x1a, 0xa8, 0xc8,
0x4f, 0x4c, 0xab, 0x9a, 0xee, 0x36, 0x2b, 0x1b, 0x85, 0xfb, 0xfa, 0x20, 0xc7,
0x36, 0xad, 0x38, 0xbd, 0x19, 0x0c, 0xb4, 0x19, 0x25, 0x24, 0x5e, 0xb6, 0xb1,
0x62, 0x0a, 0xd2, 0xcb, 0xf5, 0xd0, 0x75, 0x83, 0x43, 0xd8, 0x71, 0x1e, 0x7f,
0xee, 0xc3, 0x5a, 0xd4, 0x41, 0x1f, 0x0f, 0xf0, 0x2d, 0x9a, 0xee, 0x3e, 0x83,
0xb8, 0xe7, 0xf1, 0x46, 0xaa, 0x67, 0xe1, 0x37, 0x43, 0x30, 0xb5, 0x70, 0x84,
0xd5, 0x09, 0x7f, 0x96, 0x28, 0xb2, 0x53, 0xfd, 0x82, 0xbd, 0x4c, 0x8c, 0xd1,
0x2d, 0xef, 0xa7, 0xd2, 0xe5, 0x2e, 0xc5, 0xb3, 0xfb, 0x79, 0x54, 0xce, 0x35,
0xd7, 0x98, 0x05, 0xda, 0x0d, 0x9b, 0x0e, 0x81, 0x57, 0x38, 0xac, 0x68, 0x9d,
0x8d, 0xa2, 0x68, 0x50, 0x92, 0x7c, 0x70, 0xf4, 0x0e, 0x76, 0xd7, 0x08, 0x2c,
0x71, 0x0b, 0x26, 0xb8, 0xfa, 0x82, 0x0e, 0x45, 0x23, 0x32, 0x30, 0x09, 0x59,
0x1f, 0x7a, 0xb0, 0x17, 0x7a, 0x44, 0x23, 0xca, 0x3e, 0xe8, 0x90, 0xd6, 0x8b,
0x06, 0xe5, 0xb1, 0x92, 0x08, 0xc9, 0x51, 0x31, 0xbc, 0x2d, 0x0e, 0xe3, 0x65,
0x8d, 0xd2, 0xf5, 0x5a, 0x49, 0x56, 0x66, 0x7c, 0xc0, 0xa1, 0xea, 0x52, 0x1b,
0xa9, 0xd8, 0xd2, 0x47, 0x4e, 0x6d, 0x42, 0x3d, 0xff, 0x10, 0xbd, 0xdf, 0x7b,
0xf7, 0x07, 0x5f, 0xc0, 0x48, 0xa5, 0xae, 0xcc, 0x5f, 0x0f, 0x5f, 0xf7, 0x42,
0xfb, 0x01, 0xea, 0x94, 0x83, 0x8a, 0xcd, 0xd3, 0x17, 0x86, 0xd1, 0x28, 0x6a,
0x65, 0xd3, 0xa8, 0xab, 0xc6, 0x5d, 0x9e, 0x58, 0xe8, 0xbd, 0x61, 0xaa, 0x32,
0x04, 0x47, 0xf6, 0xa2, 0x0e, 0xb9, 0x47, 0xe0, 0x94, 0x64, 0x14, 0xf1, 0x52,
0x43, 0xd5, 0x00, 0x09, 0xa8, 0x7a, 0x4a, 0x43, 0x15, 0xf5, 0x92, 0xc9, 0xb2,
0x5e, 0xd2, 0x25, 0xe8, 0xa7, 0xc6, 0xa4, 0x1a, 0xe8, 0xa4, 0x77, 0xef, 0x44,
0x63, 0x42, 0x37, 0x4a, 0xd7, 0xf6, 0x28, 0x3b, 0x16, 0xf6, 0xae, 0xec, 0xb9,
0xfb, 0x91, 0xb8, 0xf2, 0xa3, 0x6d, 0xa8, 0xe1, 0x7b, 0xf1, 0x3b, 0x72, 0x24,
0x52, 0x16, 0xe1, 0x74, 0x8a, 0x75, 0x9e, 0x95, 0x16, 0x78, 0xaf, 0x93, 0x67,
0x22, 0xbf, 0x3c, 0x5a, 0x18, 0xbc, 0x39, 0x2b, 0x8a, 0x32, 0x03, 0xf7, 0x47,
0x18, 0xaf, 0xe0, 0x68, 0x04, 0xb4, 0x15, 0x86, 0x0a, 0xe3, 0x5a, 0x83, 0xd8,
0x5a, 0x66, 0x5a, 0x6a, 0x54, 0x24, 0x26, 0xd0, 0x79, 0x07, 0x35, 0xf1, 0x80,
0xb7, 0x24, 0x40, 0x0d, 0xdc, 0x6c, 0x5a, 0x5e, 0x57, 0xb8, 0x71, 0x78, 0xfe,
0x97, 0x4e, 0xd4, 0x06, 0xdd, 0x82, 0xde, 0xa5, 0xfd, 0xd8, 0x07, 0xe6, 0xa2,
0x7e, 0xa8, 0x83, 0x20, 0x0e, 0x17, 0xbb, 0xd1, 0x48, 0x59, 0x07, 0x2a, 0x31,
0xe0, 0xdf, 0x59, 0x4a, 0xda, 0x98, 0x30, 0x64, 0x40, 0xc3, 0x8e, 0x96, 0xe9,
0x49, 0x58, 0xfa, 0xc0, 0x9a, 0x53, 0x5b, 0x90, 0xbd, 0x2c, 0xf4, 0x54, 0xa2,
0xa8, 0xfb, 0x96, 0xac, 0xf0, 0xe2, 0x11, 0x68, 0x91, 0x8e, 0x97, 0xfb, 0xf6,
0xc3, 0xd6, 0x6f, 0x20, 0x2b, 0x0f, 0x4a, 0x52, 0x8a, 0x30, 0x6e, 0x15, 0x86,
0x7f, 0x91, 0x66, 0x87, 0x14, 0x2d, 0x37, 0xbc, 0x7a, 0x04, 0x5e, 0x58, 0x1f,
0xbf, 0xbe, 0x77, 0xde, 0x7b, 0x37, 0x45, 0x6b, 0x7b, 0x70, 0xac, 0x30, 0x01,
0x31, 0xd4, 0x20, 0x77, 0xcc, 0x72, 0x8a, 0xfa, 0x67, 0xf7, 0x51, 0xb1, 0x92,
0x66, 0xa1, 0x47, 0xe0, 0x21, 0xbf, 0x71, 0xf2, 0x2d, 0x9f, 0x4c, 0x87, 0xb4,
0xe2, 0xa0, 0xd8, 0xc7, 0x9c, 0x3b, 0x82, 0xea, 0xf7, 0x80, 0x56, 0x16, 0xa6,
0x7d, 0x90, 0x85, 0x4e, 0x81, 0xb7, 0xc4, 0x33, 0x77, 0x85, 0x01, 0xf9, 0xc9,
0xa9, 0x03, 0x10, 0x10, 0x19, 0x16, 0xbd, 0xf4, 0x22, 0x64, 0x1e, 0xec, 0x4b,
0xc1, 0x6b, 0x41, 0x14, 0x5c, 0x35, 0xbc, 0x34, 0xf4, 0xab, 0x1e, 0x58, 0xbe,
0x79, 0x2f, 0x68, 0x75, 0x60, 0x17, 0xe8, 0x6a, 0x3e, 0x19, 0x84, 0x76, 0x18,
0x67, 0x74, 0xb2, 0x71, 0xa6, 0xf9, 0xc7, 0xde, 0xef, 0x8f, 0x41, 0x2f, 0xea,
0xc2, 0xc3, 0x8b, 0x63, 0x52, 0xef, 0x6c, 0x97, 0xe4, 0xc2, 0x1b, 0xe8, 0x34,
0x1d, 0x52, 0x06, 0x6f, 0x18, 0x58, 0xbe, 0xfd, 0x9e, 0x23, 0xcb, 0x42, 0x48,
0x53, 0x34, 0x54, 0x6a, 0xa2, 0x4d, 0x6c, 0xaa, 0xaa, 0x4b, 0x66, 0x21, 0x63,
0x52, 0xaf, 0x6c, 0x75, 0x12, 0x46, 0x25, 0x8f, 0x4e, 0x8a, 0x9f, 0x48, 0x53,
0x26, 0x6e, 0x48, 0x91, 0x9e, 0x95, 0xac, 0x48, 0x08, 0x5b, 0x55, 0x3b, 0x02,
0x68, 0x12, 0xe2, 0x36, 0xb4, 0xf9, 0xfb, 0xef, 0x8f, 0x80, 0xe3, 0x17, 0x99,
0xb2, 0x7d, 0x7f, 0x4c, 0x2e, 0x49, 0x2f, 0x4e, 0x2b, 0xfb, 0x71, 0x7b, 0x89,
0x4d, 0x36, 0xfc, 0xf3, 0x56, 0xfa, 0xab, 0xc5, 0xc7, 0x6e, 0x6c, 0x80, 0xad,
0xbf, 0x7c, 0xf5, 0x2e, 0x7b, 0x51, 0x00, 0xf5, 0x8b, 0x47, 0x70, 0x7d, 0x79,
0x3b, 0xa5, 0x47, 0x11, 0x79, 0x2b, 0x1b, 0xf9, 0x69, 0xfd, 0xfa, 0x01, 0xf1,
0x86, 0x33, 0x2e, 0xd4, 0x25, 0x1a, 0x60, 0xb2, 0xac, 0xd1, 0x48, 0x7d, 0x98,
0x22, 0x89, 0x14, 0x39, 0x96, 0x20, 0x16, 0x7a, 0x90, 0xea, 0xa8, 0x7c, 0x24,
0x2d, 0x5b, 0xd4, 0xfa, 0xbf, 0xa2, 0xb5, 0xef, 0x5f, 0xe4, 0xdb, 0xe3, 0x08,
0xd5, 0x56, 0xd9, 0x24, 0xc8, 0xcc, 0xb5, 0x16, 0x78, 0xc0, 0xbe, 0x3c, 0xb0,
0xec, 0x54, 0x1b, 0x68, 0xf7, 0xc2, 0x4b, 0xbf, 0x8b, 0xdd, 0x3f, 0x54, 0x93,
0xbc, 0xfe, 0xe0, 0x87, 0xd0, 0x7c, 0x9d, 0x5d, 0x75, 0x62, 0xe5, 0x84, 0xa0,
0xe5, 0x76, 0xb7, 0x8f, 0x1c, 0xee, 0xc6, 0x6f, 0xc6, 0xa1, 0x83, 0x1b, 0x2b,
0x18, 0x2e, 0xed, 0x21, 0xe3, 0xb5, 0x09, 0xbe, 0x22, 0xea, 0x5b, 0xd9, 0xaf,
0x32, 0xb1, 0x83, 0x0b, 0x13, 0x42, 0x6d, 0x95, 0x6b, 0x33, 0x3e, 0x9f, 0x20,
0xe1, 0x85, 0xfb, 0x17, 0xa5, 0xe1, 0x8b, 0x75, 0x3a, 0xa1, 0x43, 0x94, 0x3a,
0x01, 0x9f, 0x38, 0xc1, 0x57, 0xe6, 0x68, 0x27, 0x27, 0xeb, 0xc8, 0x48, 0x61,
0x2b, 0xdb, 0xbd, 0xf6, 0x40, 0x3f, 0x98, 0xee, 0x49, 0x3f, 0xda, 0x53, 0xe1,
0x2d, 0x1d, 0xad, 0xda, 0xb4, 0x17, 0xb5, 0xce, 0xf6, 0x40, 0xf7, 0xec, 0xb1,
0x37, 0x20, 0xb8, 0x68, 0xd7, 0x59, 0x08, 0xdd, 0x15, 0xde, 0x06, 0x9f, 0x9f,
0x87, 0x4e, 0x61, 0x9f, 0xc4, 0xab, 0x68, 0x67, 0x1b, 0x20, 0x27, 0xe8, 0x29,
0x0c, 0x41, 0x9f, 0xd2, 0xca, 0x4e, 0x4a, 0xf5, 0xe5, 0xc3, 0xa2, 0xbe, 0x45,
0x13, 0xb5, 0x9f, 0xed, 0x44, 0x2d, 0x05, 0xb9, 0xd5, 0x96, 0x85, 0x41, 0xce,
0xf4, 0x58, 0x4e, 0xd8, 0x23, 0x68, 0x96, 0x7d, 0x6b, 0xe1, 0x0b, 0xdb, 0xd6,
0xef, 0xbf, 0xfb, 0xa3, 0xa0, 0xaa, 0x69, 0xb1, 0x56, 0x69, 0x28, 0xef, 0xc0,
0x0d, 0xca, 0x01, 0x14, 0x28, 0xeb, 0xff, 0xbe, 0x57, 0x74, 0x3a, 0x00, 0xd1,
0xd5, 0x3d, 0x54, 0xea, 0x8e, 0xc3, 0x5a, 0xd8, 0x73, 0x77, 0x23, 0x1a, 0xbc,
0xc7, 0xb4, 0x5a, 0x33, 0x37, 0xca, 0x6a, 0xd9, 0x8e, 0xdb, 0x23, 0xe5, 0xbd,
0x82, 0x77, 0x6f, 0xd8, 0x79, 0x0a, 0x2c, 0x65, 0xb9, 0x9a, 0xf0, 0xaf, 0xeb,
0x8a, 0x3f, 0xef, 0x85, 0xe1, 0xd2, 0x06, 0xf1, 0x14, 0xac, 0x1f, 0x2d, 0x1e,
0x79, 0x4a, 0xaf, 0xb0, 0xdd, 0xde, 0x84, 0xf9, 0xec, 0xce, 0x49, 0x64, 0x64,
0x84, 0xca, 0x80, 0x85, 0xd5, 0x94, 0xb9, 0x58, 0x23, 0xb7, 0xa8, 0x03, 0x0d,
0x24, 0xc9, 0xf1, 0x00, 0x31, 0xa2, 0xfa, 0x59, 0x5a, 0xae, 0xb7, 0xda, 0x09,
0x29, 0x5a, 0x4f, 0x3b, 0x21, 0x28, 0x35, 0xa2, 0xd1, 0xd2, 0x56, 0xa1, 0x4b,
0xed, 0xe6, 0x76, 0xfe, 0x19, 0x52, 0xb3, 0x1e, 0xc8, 0xd4, 0x0c, 0x31, 0xda,
0x46, 0xf2, 0x8a, 0x9b, 0xaa, 0xe3, 0x92, 0xcb, 0xba, 0x19, 0x8d, 0xda, 0x24,
0xec, 0x56, 0x46, 0x8a, 0x4c, 0x0a, 0xcd, 0x2d, 0x4e, 0x99, 0xfd, 0x7a, 0x6a,
0x8a, 0x7a, 0xa1, 0x1e, 0xb5, 0xec, 0x80, 0x9d, 0x77, 0x76, 0xe8, 0xc1, 0x45,
0xb5, 0x5c, 0x6f, 0x22, 0x9f, 0x66, 0x20, 0x25, 0x32, 0xdf, 0xc7, 0x57, 0xbb,
0xf7, 0xb8, 0x2b, 0xf5, 0x45, 0x2f, 0x99, 0x90, 0x7e, 0x89, 0x05, 0x99, 0x97,
0x6b, 0xca, 0xbc, 0xf4, 0x03, 0xe3, 0xaa, 0x6c, 0x45, 0xeb, 0xc3, 0xbb, 0x5f,
0x43, 0xc9, 0x2d, 0xe8, 0x8c, 0x01, 0x59, 0x29, 0xa7, 0xbc, 0xbb, 0x70, 0x54,
0x15, 0x2f, 0xd7, 0x97, 0xb4, 0x55, 0xb4, 0xdd, 0x92, 0x92, 0x06, 0x0a, 0x1b,
0x25, 0xf6, 0xd2, 0x11, 0xe5, 0x96, 0x6d, 0xa8, 0x8b, 0xf3, 0x1f, 0x04, 0x83,
0x32, 0xb2, 0xf6, 0x9d, 0x2d, 0xc8, 0xab, 0x58, 0xdb, 0x51, 0x18, 0x2b, 0xae,
0x17, 0x6a, 0xd1, 0x08, 0x8c, 0xdf, 0x12, 0x44, 0xd1, 0x87, 0xd0, 0x24, 0xd2,
0xd3, 0x6f, 0xef, 0x40, 0x4d, 0xdf, 0xc0, 0xb6, 0x3f, 0x43, 0x1f, 0xdb, 0x80,
0x7a, 0xd0, 0xba, 0x81, 0x07, 0xc7, 0x84, 0xed, 0xab, 0xed, 0x8a, 0xe1, 0xd5,
0x41, 0xa9, 0xae, 0xea, 0xcc, 0xab, 0x48, 0x83, 0xad, 0x06, 0x68, 0x5a, 0xad,
0xb9, 0x79, 0x63, 0x1d, 0xfa, 0xc6, 0x81, 0xba, 0xa0, 0x73, 0x21, 0x5f, 0x23,
0x8b, 0x82, 0xfc, 0xd5, 0xe4, 0x55, 0xba, 0xb1, 0x51, 0xde, 0x4d, 0x5b, 0xee,
0x6a, 0xa7, 0x1c, 0x74, 0xcb, 0x69, 0x8c, 0xb6, 0x18, 0xf0, 0xb1, 0xfd, 0xa8,
0x9f, 0x6e, 0x91, 0x47, 0x84, 0x66, 0xc6, 0xc1, 0x5a, 0xc1, 0xa3, 0x4e, 0x55,
0x68, 0x64, 0xbd, 0x9c, 0xf7, 0xb1, 0x04, 0xe3, 0x40, 0x43, 0x10, 0x54, 0xf5,
0xcc, 0xa9, 0xc7, 0xdf, 0xec, 0x45, 0x63, 0x7f, 0xff, 0xce, 0xc6, 0xb6, 0x9b,
0x7c, 0xb3, 0xb3, 0xff, 0x62, 0x2c, 0x78, 0x3b, 0x0d, 0xb1, 0xc2, 0x30, 0x97,
0xfd, 0x6d, 0xea, 0xb7, 0x89, 0x52, 0x2b, 0xb1, 0x83, 0x0e, 0xb6, 0x6e, 0x43,
0x36, 0xc1, 0x44, 0x10, 0xbc, 0xd2, 0x6f, 0xf7, 0x81, 0x61, 0x8e, 0xb1, 0xda,
0xf7, 0xab, 0x1d, 0x66, 0x68, 0x7f, 0x0d, 0x92, 0x92, 0x17, 0x74, 0xa8, 0xe7,
0xf1, 0x9e, 0x5f, 0x4d, 0xce, 0x7b, 0xd5, 0x81, 0x22, 0xcb, 0x07, 0xd9, 0x26,
0x61, 0xbb, 0xbc, 0xb1, 0x44, 0x23, 0x6d, 0x16, 0x3e, 0x69, 0xe4, 0x79, 0xf5,
0xde, 0xe1, 0xa2, 0x5b, 0xb5, 0xd8, 0x2d, 0x0b, 0xaa, 0xb3, 0xed, 0xf8, 0x83,
0x00, 0xee, 0x2a, 0x8c, 0xa9, 0xdf, 0x1a, 0x83, 0xf6, 0xe7, 0x6c, 0x37, 0x6a,
0x6f, 0xfb, 0x7c, 0x0c, 0x3e, 0x5a, 0x98, 0x11, 0x27, 0x8a, 0xa6, 0x24, 0xda,
0xe2, 0xf1, 0x5a, 0x8d, 0xca, 0xb6, 0x92, 0x04, 0xb9, 0xe4, 0x2d, 0xd1, 0xc2,
0xed, 0x2e, 0x14, 0xe2, 0x1a, 0xf0, 0x58, 0xa1, 0xaf, 0x32, 0x72, 0x83, 0x8d,
0x1d, 0x21, 0xf5, 0xc0, 0x77, 0x87, 0xd8, 0x27, 0xd0, 0xa0, 0xe8, 0xcd, 0x7e,
0xf9, 0x14, 0xea, 0xaa, 0x08, 0x20, 0xad, 0xc8, 0xa8, 0xfe, 0xa6, 0x11, 0x75,
0xdf, 0x68, 0xe1, 0x6f, 0x0f, 0x5b, 0x61, 0xec, 0xf7, 0x03, 0xb3, 0x3b, 0xc5,
0xa1, 0xa2, 0xf3, 0x4d, 0xc8, 0x00, 0x89, 0xa2, 0x66, 0xf9, 0x5a, 0x3d, 0xca,
0x8a, 0x06, 0x05, 0x0e, 0x51, 0x8d, 0x4e, 0x1a, 0x06, 0x83, 0x6a, 0x92, 0x8a,
0x81, 0x19, 0xb5, 0xa1, 0x10, 0xb2, 0x81, 0x22, 0x03, 0x69, 0x81, 0x87, 0x7a,
0xd2, 0x84, 0xd2, 0xb4, 0x45, 0xd8, 0x27, 0x76, 0x53, 0x7a, 0xa1, 0x91, 0x31,
0x32, 0x7c, 0x8d, 0x45, 0x57, 0x7b, 0x88, 0x5e, 0x96, 0xc6, 0xba, 0x72, 0xb7,
0xbc, 0x13, 0x0e, 0xa4, 0xc0, 0x48, 0x45, 0x8f, 0xc2, 0x9b, 0x7d, 0x30, 0xb4,
0x38, 0x5e, 0x69, 0x06, 0xad, 0x5a, 0x6f, 0x87, 0x17, 0xbf, 0x84, 0x30, 0x1e,
0x7a, 0x62, 0xc7, 0x2e, 0xbe, 0xb0, 0x35, 0xdd, 0x30, 0x04, 0x3e, 0xe8, 0x93,
0x24, 0x97, 0x64, 0xe6, 0xb8, 0x24, 0xa9, 0xfb, 0x8e, 0xbb, 0xd1, 0x30, 0x35,
0x5a, 0x3c, 0x74, 0xcb, 0x80, 0xda, 0x5a, 0xe0, 0x97, 0x3d, 0x9e, 0x9e, 0x3d,
0x49, 0x74, 0x25, 0x8d, 0xb8, 0x8b, 0xb2, 0x2d, 0xf4, 0x19, 0xf1, 0x6b, 0x09,
0xf2, 0xb4, 0x63, 0x1d, 0x1f, 0x96, 0xcf, 0xfc, 0xd0, 0x56, 0x3e, 0x2c, 0xf1,
0x0a, 0x3c, 0xc2, 0x38, 0x9b, 0x15, 0x99, 0x2a, 0xce, 0x29, 0xfb, 0x18, 0xbe,
0x03, 0x11, 0xf3, 0x1d, 0xd6, 0xac, 0x89, 0xfb, 0x3b, 0xe7, 0x4d, 0xd0, 0x27,
0xdf, 0x02, 0x2f, 0x9d, 0x94, 0xeb, 0x7f, 0x66, 0x99, 0x7b, 0x78, 0x3b, 0x0a,
0x5d, 0x1f, 0xa2, 0x3a, 0x51, 0x37, 0xfa, 0xed, 0xca, 0x11, 0x25, 0x8a, 0x8a,
0x43, 0xa2, 0x16, 0x3a, 0x01, 0xcd, 0x7c, 0x13, 0xd6, 0x28, 0xee, 0x61, 0xc6,
0x0a, 0x62, 0xd0, 0x53, 0x66, 0x94, 0x8d, 0xcd, 0x9e, 0x50, 0x0f, 0x57, 0x1d,
0xf0, 0xa1, 0x94, 0x24, 0x5c, 0xe5, 0x40, 0x7e, 0xfc, 0xb3, 0x76, 0x2a, 0x25,
0x0f, 0xa3, 0x66, 0x49, 0x93, 0x58, 0xc3, 0xe8, 0xf0, 0x98, 0x50, 0xb3, 0xc8,
0x2d, 0x1e, 0xa6, 0x22, 0x12, 0xb7, 0x34, 0xc4, 0x6e, 0xfa, 0x1c, 0x52, 0x2f,
0xc0, 0x91, 0xc7, 0x3c, 0x37, 0x37, 0xbb, 0xe0, 0xe0, 0x24, 0xf8, 0x69, 0x9f,
0xb2, 0x67, 0xde, 0xef, 0x0d, 0x94, 0x97, 0xe9, 0x53, 0xfe, 0x66, 0x48, 0x3e,
0x7a, 0x93, 0xf6, 0x4e, 0xff, 0xec, 0xb7, 0x3c, 0x28, 0x01, 0x5a, 0x49, 0x06,
0x1e, 0x69, 0xa0, 0x9e, 0x1d, 0x9b, 0xd5, 0x40, 0x0d, 0x54, 0x74, 0xd7, 0x8e,
0x08, 0xe2, 0xcf, 0x9c, 0x1c, 0x83, 0x25, 0x03, 0x3c, 0xc9, 0x0f, 0x6f, 0xac,
0x47, 0xbd, 0x30, 0xb4, 0xae, 0x5d, 0xce, 0xc3, 0x22, 0xf2, 0xdc, 0xa6, 0x08,
0x84, 0xef, 0x34, 0x2d, 0xec, 0xfa, 0xe1, 0x07, 0xef, 0x40, 0xa3, 0x20, 0xbe,
0xe1, 0x83, 0xeb, 0x3b, 0x60, 0x40, 0x16, 0xe4, 0x26, 0x17, 0x24, 0x7e, 0xde,
0x2b, 0x8b, 0xde, 0xfa, 0xa7, 0x56, 0xd4, 0xfd, 0xa0, 0x73, 0x69, 0x50, 0xa1,
0xbd, 0x6b, 0xb3, 0x0d, 0x12, 0x07, 0x21, 0xb1, 0xf6, 0x4c, 0x33, 0x4a, 0xa1,
0x26, 0xd2, 0xf7, 0x84, 0xee, 0x47, 0xcd, 0xff, 0x7e, 0x6e, 0x00, 0xec, 0x05,
0x43, 0x85, 0xb9, 0x82, 0x57, 0xb6, 0xc0, 0xf0, 0x2c, 0xbb, 0x16, 0x1c, 0xcb,
0xbf, 0xf8, 0xc3, 0x2a, 0xc5, 0xee, 0x47, 0xb2, 0x4b, 0x1a, 0x96, 0xf9, 0xd7,
0xa6, 0xd9, 0x4f, 0xdb, 0xa0, 0x8e, 0x4c, 0x4a, 0x1c, 0xb8, 0x0d, 0x5a, 0x45,
0x61, 0xa2, 0x17, 0x35, 0x48, 0x78, 0x47, 0x24, 0x65, 0x75, 0x28, 0xbd, 0x60,
0x35, 0x4a, 0x62, 0x4d, 0x59, 0x33, 0x0c, 0xaa, 0x26, 0x17, 0xfc, 0x1f,
};
optimizesize void *__ksx1001_decmap(void) {
return xloadzd(&__ksx1001_decmap_ptr,
__ksx1001_decmap_rodata,
10685, 13606, 8264, 2, 0x91d24d83u); /* 64.6479% profit */
}
| 66,115 | 835 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__cp932ext_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __cp932ext_decmap_ptr;
static const unsigned char __cp932ext_decmap_rodata[872] = {
0xe5, 0x92, 0x5d, 0x4c, 0xd3, 0x67, 0x18, 0xc5, 0x7d, 0x3e, 0xfe, 0x6f, 0x0b,
0x54, 0xac, 0x5b, 0xd7, 0x2a, 0x73, 0xe0, 0x62, 0x63, 0x1a, 0x56, 0x75, 0x2e,
0x8c, 0xcd, 0x8e, 0x75, 0x49, 0x53, 0x59, 0xec, 0x1a, 0x62, 0x0c, 0x21, 0x06,
0xc9, 0xb6, 0x38, 0x35, 0xc3, 0x79, 0xc5, 0x12, 0xb2, 0x70, 0xb1, 0x60, 0x29,
0x55, 0x71, 0x36, 0x45, 0xa0, 0x5b, 0xa0, 0x6c, 0x32, 0xca, 0x87, 0xcd, 0xca,
0x66, 0xd9, 0x54, 0xaa, 0x28, 0x10, 0x17, 0x1b, 0x43, 0x88, 0x32, 0x07, 0x84,
0x31, 0xc2, 0xb0, 0x21, 0x02, 0x8e, 0x49, 0x21, 0x40, 0xa1, 0x91, 0x6d, 0x59,
0x80, 0xdb, 0xc5, 0xbb, 0x65, 0xe7, 0xea, 0xe4, 0x39, 0x39, 0x27, 0xcf, 0xc5,
0x6f, 0x21, 0x26, 0x33, 0x4f, 0xcf, 0x8a, 0xa9, 0x59, 0x31, 0x19, 0x13, 0xb0,
0x19, 0x05, 0xf6, 0x2d, 0x09, 0x1c, 0xbf, 0x26, 0xb0, 0xfb, 0xba, 0xe0, 0x0c,
0xbe, 0xd8, 0x2e, 0x70, 0x45, 0xb3, 0xd7, 0x04, 0x5f, 0x89, 0xca, 0xac, 0x3d,
0x31, 0xd9, 0xb9, 0x98, 0xac, 0x7b, 0x41, 0x16, 0x8d, 0x88, 0x85, 0x88, 0xe0,
0x3f, 0x22, 0x02, 0xcb, 0x41, 0xef, 0x51, 0xd2, 0x57, 0x6e, 0xb0, 0x7f, 0x8a,
0x17, 0xe8, 0xd6, 0x92, 0xe8, 0xa4, 0xab, 0x84, 0x57, 0x88, 0x84, 0x5c, 0x3f,
0x1d, 0x95, 0xdd, 0xa8, 0x02, 0xf8, 0x58, 0x0e, 0xeb, 0x61, 0x1f, 0x6c, 0x07,
0x35, 0x9c, 0x54, 0xb7, 0xbc, 0xb5, 0xbc, 0x87, 0x90, 0x8b, 0x0d, 0x7d, 0x37,
0xc5, 0xba, 0x55, 0x4d, 0xce, 0x0b, 0x31, 0x07, 0x18, 0x87, 0x97, 0x00, 0x7c,
0xf3, 0x2b, 0x81, 0x7f, 0x5e, 0xe0, 0xec, 0x9c, 0x28, 0x99, 0x5a, 0x7b, 0x65,
0x4d, 0x0d, 0x8a, 0x55, 0xeb, 0x5b, 0x14, 0xe3, 0x01, 0x91, 0xbf, 0x25, 0x27,
0x3f, 0xf9, 0xed, 0x63, 0xe9, 0x8a, 0x0a, 0x78, 0x45, 0x52, 0x1a, 0x5f, 0xe8,
0x02, 0xc4, 0x14, 0x3c, 0xbe, 0x37, 0x78, 0x69, 0x65, 0xaf, 0x34, 0x20, 0x1c,
0x01, 0xd1, 0x79, 0x53, 0x70, 0x79, 0xc6, 0x94, 0xa5, 0xdf, 0xe2, 0xc8, 0xfc,
0xbb, 0xfd, 0x3b, 0x60, 0x62, 0x99, 0x04, 0xf0, 0x93, 0x39, 0xf9, 0x23, 0xb1,
0xe7, 0x19, 0x37, 0x9e, 0x41, 0xe8, 0xc0, 0x0a, 0xd4, 0x60, 0xc7, 0x34, 0x7a,
0x53, 0x07, 0x74, 0xcb, 0xd8, 0x9f, 0xde, 0x70, 0x1f, 0xc2, 0x25, 0x50, 0x91,
0xda, 0x12, 0x3f, 0xda, 0x0c, 0x4b, 0xdf, 0xc2, 0x64, 0x72, 0x9b, 0x39, 0x82,
0xe9, 0x72, 0x71, 0xc2, 0xf0, 0xc9, 0x86, 0xad, 0x09, 0x05, 0x63, 0xf0, 0xc6,
0x5e, 0xe3, 0xfe, 0xec, 0x43, 0x5e, 0xe8, 0x80, 0xd7, 0xc2, 0x90, 0x56, 0x60,
0xca, 0x3b, 0xe0, 0x44, 0x55, 0x5a, 0xba, 0x25, 0xd1, 0xe0, 0x01, 0x93, 0x31,
0x67, 0xf4, 0x0b, 0xe9, 0x41, 0x95, 0xb4, 0xcd, 0xf8, 0x0d, 0x38, 0xb1, 0x51,
0xb6, 0xc9, 0x09, 0xaf, 0x83, 0xeb, 0x8c, 0x34, 0xac, 0xf9, 0x45, 0xf3, 0xa0,
0x54, 0xd2, 0x05, 0xc0, 0x05, 0x4a, 0x56, 0xd8, 0x40, 0x7f, 0x55, 0xdc, 0x87,
0xe1, 0xa3, 0xfe, 0xa3, 0xba, 0x23, 0x2e, 0xd4, 0x15, 0x1e, 0x39, 0x18, 0x8b,
0x70, 0xed, 0x0c, 0xe7, 0xb8, 0x01, 0x77, 0x7e, 0x2d, 0x6d, 0x3f, 0x76, 0x01,
0xb2, 0x9e, 0xc0, 0xfe, 0xf8, 0x66, 0xd8, 0xe8, 0x86, 0x43, 0x46, 0xeb, 0xfa,
0xbb, 0x30, 0x07, 0x8d, 0xf8, 0xa5, 0xd4, 0x07, 0x45, 0x87, 0x8b, 0x31, 0x8c,
0xa9, 0xd6, 0x0f, 0x2c, 0x29, 0x7f, 0xed, 0x3c, 0xcf, 0x91, 0x1e, 0x6e, 0xef,
0x61, 0x6b, 0xa2, 0x36, 0xa9, 0x50, 0x77, 0x39, 0xc4, 0xa5, 0xb7, 0xd9, 0x07,
0x2d, 0x58, 0x8f, 0x36, 0x70, 0x80, 0x1b, 0x4f, 0xff, 0xc8, 0x3f, 0x77, 0xf1,
0x40, 0x17, 0xcf, 0x77, 0x72, 0x25, 0x78, 0xa0, 0x70, 0x5f, 0xae, 0x3a, 0x04,
0x1c, 0xa6, 0x5e, 0x30, 0x64, 0xef, 0xe8, 0x83, 0x6c, 0x07, 0xee, 0xca, 0xd2,
0x67, 0x1e, 0x48, 0x50, 0x15, 0x65, 0xe6, 0xa7, 0x3a, 0xf0, 0x3c, 0xe5, 0x16,
0xc3, 0x56, 0x36, 0x05, 0xc1, 0x1a, 0x82, 0xe7, 0xbe, 0x83, 0x97, 0xd0, 0x53,
0xcf, 0x4d, 0x75, 0x5c, 0x34, 0x86, 0x49, 0xdd, 0x10, 0xae, 0xe1, 0xf6, 0x6a,
0xfe, 0x0c, 0x36, 0x25, 0x25, 0xbd, 0x78, 0x7c, 0xdb, 0x61, 0x39, 0xc4, 0x7f,
0x98, 0xa5, 0xbf, 0x05, 0x43, 0xd0, 0xc8, 0x69, 0x2c, 0xa9, 0x47, 0xcf, 0x71,
0xdd, 0x59, 0xf6, 0x9f, 0x87, 0x70, 0x15, 0xe4, 0xea, 0xf5, 0x8f, 0xf0, 0x6e,
0x09, 0x23, 0x9e, 0xb5, 0xb1, 0xd3, 0xc6, 0xcb, 0x27, 0xf9, 0x11, 0xeb, 0x27,
0x62, 0xf4, 0x5b, 0x8c, 0xc6, 0xf0, 0x49, 0x94, 0x2e, 0xce, 0x90, 0xee, 0x32,
0xec, 0x38, 0xb1, 0x00, 0x13, 0xf4, 0x3d, 0x2c, 0x8e, 0x53, 0xdb, 0x10, 0x75,
0x81, 0xc1, 0x05, 0xef, 0x7a, 0x61, 0x00, 0x6e, 0xa0, 0xe2, 0xce, 0x04, 0x35,
0x4c, 0xd0, 0xc3, 0x5e, 0xfa, 0xf5, 0x1e, 0x8d, 0xdc, 0x23, 0x6c, 0x0d, 0xd1,
0x10, 0x05, 0xd9, 0x62, 0x87, 0xbc, 0x9d, 0x26, 0x47, 0x3b, 0xf5, 0x5f, 0xa7,
0x20, 0x1c, 0x1c, 0x95, 0xe4, 0x19, 0x21, 0x18, 0x0c, 0x50, 0x93, 0x9f, 0x7c,
0x7e, 0xc2, 0xa5, 0x46, 0x9a, 0x02, 0x57, 0x03, 0xd5, 0x79, 0x49, 0x3b, 0x86,
0x52, 0x62, 0x32, 0x3e, 0x8b, 0x26, 0x55, 0xc2, 0xfb, 0x0a, 0x99, 0x56, 0xbd,
0x61, 0x57, 0x5e, 0x31, 0xbc, 0x87, 0xc3, 0x90, 0xc2, 0x1b, 0x5b, 0x6a, 0xa9,
0xbe, 0x96, 0xd4, 0x9b, 0xbd, 0x20, 0x7b, 0x67, 0xd0, 0x43, 0x15, 0x1e, 0x7a,
0x33, 0xe3, 0xd5, 0x21, 0xd8, 0x5d, 0x0d, 0xe6, 0x97, 0xd3, 0x0a, 0x74, 0xa2,
0x52, 0xaa, 0x2c, 0xa7, 0x6a, 0xf8, 0xdc, 0x49, 0xda, 0xd3, 0xa8, 0x54, 0xaa,
0x98, 0xe5, 0x76, 0xde, 0x52, 0x76, 0x8a, 0xf0, 0x94, 0x9d, 0xca, 0xec, 0x54,
0x63, 0xa3, 0x11, 0x74, 0xa3, 0x08, 0xa0, 0x64, 0x30, 0xab, 0xca, 0x60, 0x44,
0x8a, 0xb3, 0xcf, 0x60, 0xd3, 0x63, 0x7c, 0x8c, 0x83, 0x76, 0x5a, 0x57, 0xb3,
0xb8, 0xc6, 0x72, 0x6f, 0x54, 0x70, 0x1b, 0xc5, 0xd5, 0xcf, 0xad, 0x9d, 0x76,
0xaf, 0xba, 0xc8, 0x3f, 0x61, 0x5d, 0xab, 0xf8, 0xc1, 0xac, 0x6e, 0x66, 0xdf,
0x53, 0xa3, 0xf8, 0x30, 0x28, 0xb5, 0x06, 0xa5, 0x7f, 0xc9, 0x23, 0xfe, 0x4f,
0x61, 0xbc, 0xa3, 0xb9, 0xad, 0x79, 0x5a, 0x1e, 0xb5, 0xff, 0x41, 0x14, 0xff,
0x04,
};
optimizesize void *__cp932ext_decmap(void) {
return xloadzd(&__cp932ext_decmap_ptr,
__cp932ext_decmap_rodata,
872, 1534, 969, 2, 0xde26b180u); /* 44.9948% profit */
}
| 5,728 | 81 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__gbcommon_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __gbcommon_encmap_ptr;
static const unsigned char __gbcommon_encmap_rodata[26264] = {
0xbc, 0xbc, 0x79, 0x74, 0x6b, 0x45, 0x9a, 0x27, 0x98, 0xbf, 0x2f, 0x84, 0xde,
0xab, 0x84, 0xec, 0x47, 0x17, 0xcc, 0xf0, 0xaa, 0xa0, 0x4f, 0x92, 0x05, 0x59,
0x50, 0x05, 0x7d, 0xa0, 0x0f, 0xd9, 0x0d, 0xd3, 0xc9, 0x0c, 0xf4, 0x21, 0xab,
0xa1, 0x0a, 0xf2, 0x40, 0x17, 0x6f, 0x06, 0xce, 0x24, 0x79, 0xa0, 0x1b, 0xa6,
0x60, 0x0a, 0xba, 0x60, 0x8a, 0x9c, 0x49, 0xba, 0x93, 0x3a, 0x29, 0xef, 0xf2,
0x2e, 0xd9, 0xb2, 0x2d, 0xdb, 0xf2, 0x2e, 0xdb, 0xb2, 0x2d, 0xdb, 0xb2, 0x2d,
0xdb, 0x92, 0x2d, 0xdb, 0xf2, 0xbe, 0xef, 0xcb, 0xf3, 0x2a, 0xef, 0xbb, 0xfd,
0x9e, 0xbc, 0xdb, 0xb2, 0x6c, 0x4f, 0xc4, 0xbd, 0xb2, 0x9f, 0x1f, 0x90, 0xd5,
0x75, 0x7a, 0x6a, 0x4a, 0x7f, 0x28, 0x22, 0xbe, 0xf8, 0x22, 0x6e, 0x2c, 0xdf,
0x1e, 0x71, 0x6f, 0x5f, 0x10, 0x8a, 0x3c, 0xca, 0xef, 0x65, 0x7b, 0x94, 0xa1,
0xb0, 0x1c, 0x2b, 0xbf, 0x27, 0xfd, 0x2a, 0x3d, 0xca, 0x3f, 0x3b, 0xf5, 0x48,
0x85, 0xf2, 0x23, 0xaa, 0x38, 0xa2, 0xef, 0xfd, 0xbd, 0xbf, 0x63, 0x8f, 0xd2,
0xeb, 0xf1, 0x35, 0xfd, 0x5e, 0xf9, 0xb4, 0x92, 0x55, 0x4d, 0xcb, 0xa5, 0x42,
0x9e, 0x7f, 0x32, 0x6c, 0x5a, 0x99, 0xcd, 0xd3, 0x7c, 0x09, 0x96, 0xc2, 0x73,
0x99, 0x22, 0x77, 0xe4, 0x51, 0x7a, 0x3c, 0xca, 0x38, 0x5e, 0x4c, 0x9a, 0x56,
0x86, 0x4f, 0x2b, 0x9f, 0x71, 0x4c, 0x2b, 0xbf, 0xd9, 0x6f, 0xd9, 0xb4, 0xd2,
0x7a, 0x0e, 0x2d, 0x9e, 0x56, 0x5a, 0xbe, 0x89, 0x51, 0x30, 0xad, 0x34, 0x7f,
0xbb, 0x95, 0xef, 0x17, 0x30, 0x45, 0x81, 0x53, 0x7c, 0xe0, 0x7e, 0x53, 0xe4,
0x2f, 0xd2, 0xef, 0x65, 0x4d, 0x2b, 0x8d, 0xbf, 0x13, 0x5b, 0xfa, 0x25, 0x4f,
0x2b, 0x0d, 0x7f, 0x3f, 0xc6, 0x3f, 0xca, 0xaf, 0x72, 0x5a, 0x69, 0x9b, 0x56,
0xe6, 0x4e, 0x2b, 0x4d, 0xd3, 0xca, 0xb4, 0x69, 0x65, 0xfa, 0xb4, 0x32, 0x61,
0x5a, 0xa9, 0x9f, 0x56, 0xc6, 0x4e, 0x2b, 0x75, 0xd3, 0x4a, 0xed, 0xb4, 0x32,
0x66, 0x5a, 0x19, 0x3d, 0xad, 0xd4, 0x4c, 0x2b, 0x23, 0xa7, 0x95, 0xc1, 0xfe,
0x0a, 0xf5, 0xd4, 0x37, 0xd6, 0xff, 0x64, 0x92, 0x4e, 0x27, 0xe9, 0x7b, 0xff,
0x04, 0xbf, 0x92, 0x63, 0x65, 0xe9, 0xb1, 0xb2, 0xec, 0x58, 0x59, 0x61, 0x50,
0x90, 0xd7, 0x75, 0xd7, 0x33, 0x8f, 0x5c, 0x54, 0xaf, 0x56, 0xd0, 0x37, 0x7e,
0x86, 0x65, 0x65, 0xe2, 0xb2, 0x52, 0xce, 0x47, 0x2d, 0xfb, 0x16, 0xf3, 0x78,
0x49, 0xf9, 0x4d, 0xbc, 0xc9, 0x25, 0xe5, 0xd8, 0x39, 0x34, 0x95, 0x59, 0xe6,
0xef, 0x5e, 0xf6, 0xea, 0x79, 0xb9, 0xea, 0x5b, 0xdd, 0x5f, 0xfc, 0x1e, 0xfd,
0x6f, 0xd4, 0x1b, 0xe6, 0x94, 0xbd, 0x73, 0xca, 0x30, 0xb5, 0xa2, 0x65, 0x9c,
0xbe, 0x77, 0xe0, 0xa2, 0x92, 0x3f, 0x3c, 0xf3, 0x53, 0x28, 0x72, 0x8e, 0x95,
0x19, 0xc7, 0x4a, 0x4a, 0xe7, 0x84, 0x9e, 0xc2, 0x53, 0xc3, 0x39, 0xc1, 0xef,
0xb8, 0xa8, 0xd8, 0xa0, 0x30, 0x1e, 0x5f, 0x8c, 0x22, 0xd7, 0xa3, 0x34, 0x79,
0x94, 0xe5, 0x1e, 0x25, 0x59, 0x3d, 0xca, 0x2d, 0x17, 0x6d, 0xcb, 0x73, 0x0f,
0xf7, 0x28, 0x7f, 0x5c, 0xea, 0x51, 0xde, 0x76, 0x91, 0x5b, 0x00, 0x36, 0x5d,
0x74, 0xeb, 0xae, 0x45, 0xc9, 0xf2, 0x28, 0x8d, 0x9e, 0x3b, 0x53, 0xe9, 0x1c,
0xa7, 0xae, 0xf1, 0xff, 0x6f, 0x1b, 0x95, 0xbc, 0x7f, 0x79, 0xe9, 0x82, 0xf7,
0x45, 0xe7, 0xd5, 0x7b, 0x77, 0x20, 0xf9, 0x7b, 0xdf, 0xdd, 0x7f, 0x08, 0x1f,
0x3a, 0x53, 0x06, 0xf2, 0xc1, 0xac, 0xbb, 0x04, 0x5e, 0x80, 0x41, 0xb1, 0xe6,
0x1b, 0xd9, 0x6d, 0x8f, 0xd2, 0xcd, 0x27, 0xe5, 0x51, 0x6e, 0x0b, 0xc0, 0xbc,
0x8b, 0x16, 0xa4, 0x39, 0x2c, 0x7a, 0x94, 0x4b, 0x1c, 0xd0, 0xed, 0x51, 0xde,
0x37, 0x93, 0xac, 0x38, 0x49, 0x56, 0xcc, 0xf0, 0xd2, 0xb4, 0x8b, 0x66, 0x5c,
0x34, 0xeb, 0x51, 0xce, 0x79, 0x94, 0x7b, 0xbc, 0xcb, 0xab, 0x78, 0x70, 0x9c,
0x83, 0x6f, 0x7a, 0x94, 0xa3, 0x72, 0x6f, 0x35, 0x1e, 0x25, 0x9e, 0xbf, 0x7f,
0x45, 0x2e, 0xf4, 0x7a, 0x94, 0x7d, 0x97, 0xa6, 0xdf, 0xef, 0x51, 0x0e, 0x88,
0xe2, 0xa0, 0x47, 0x39, 0x24, 0x83, 0xa7, 0x5c, 0xe4, 0xba, 0x9b, 0x8a, 0x3a,
0x3d, 0xca, 0xdf, 0x1b, 0xe1, 0x95, 0xcd, 0xbc, 0xf3, 0x95, 0x64, 0x05, 0x8d,
0xfb, 0xaa, 0xdb, 0x79, 0xb9, 0xcd, 0xf3, 0x0f, 0x62, 0xc6, 0xb1, 0x29, 0x1a,
0x17, 0x2c, 0x32, 0xe1, 0x51, 0x4e, 0x5e, 0x6e, 0x31, 0xef, 0x51, 0x2e, 0xfc,
0xee, 0x1e, 0x6e, 0xba, 0x28, 0xc8, 0xa0, 0x88, 0xb9, 0x43, 0x41, 0x55, 0xfb,
0x77, 0x70, 0x77, 0xf6, 0x95, 0xdf, 0x41, 0x53, 0x3f, 0xff, 0x0e, 0x98, 0xf3,
0x61, 0xfa, 0xc7, 0xfb, 0xa5, 0x8f, 0x8b, 0x21, 0x0c, 0xbb, 0xfe, 0x21, 0xb8,
0x9a, 0xbb, 0xd7, 0x31, 0xf2, 0xbc, 0xd1, 0xf9, 0x84, 0xdc, 0x62, 0x49, 0x36,
0xa7, 0x78, 0x6e, 0xed, 0x92, 0xfc, 0xd0, 0xf2, 0xed, 0xd2, 0x7d, 0x6b, 0x51,
0x22, 0x39, 0x54, 0x73, 0x01, 0x5d, 0xe6, 0x8d, 0x96, 0x2e, 0xda, 0xc4, 0xf1,
0x3a, 0xbd, 0xa8, 0x4b, 0xf1, 0x28, 0x53, 0x79, 0x9a, 0xc8, 0xcb, 0x86, 0xef,
0x58, 0xd6, 0x79, 0xf1, 0x28, 0xaa, 0x37, 0x28, 0x90, 0xc9, 0x6b, 0x27, 0xa6,
0x68, 0x72, 0xea, 0xbf, 0x8f, 0xf2, 0xed, 0x1e, 0x65, 0x95, 0x47, 0x59, 0xed,
0x51, 0xfe, 0x96, 0xe8, 0xfb, 0x45, 0xc7, 0xca, 0x82, 0x63, 0xe5, 0x61, 0xba,
0xe2, 0x3f, 0x35, 0x66, 0x9c, 0xcf, 0x4c, 0x49, 0xa6, 0x14, 0x45, 0x9e, 0x41,
0x91, 0x00, 0xfa, 0x7d, 0x0a, 0x94, 0x79, 0x76, 0x98, 0x3f, 0x7d, 0x88, 0x3f,
0xf0, 0x64, 0xfc, 0x62, 0x81, 0x6e, 0xfd, 0x2e, 0xce, 0xab, 0xbe, 0xad, 0xa4,
0x7f, 0xf4, 0x9f, 0xfe, 0x96, 0x6f, 0x49, 0xaa, 0xf9, 0x08, 0xae, 0x92, 0x85,
0x3f, 0xbc, 0x7a, 0xfd, 0xff, 0x87, 0xe7, 0xf0, 0x5f, 0xcc, 0x9a, 0x78, 0x54,
0xb9, 0xb4, 0x2c, 0x4a, 0xaa, 0x09, 0x54, 0xfc, 0x43, 0x1a, 0x85, 0x5c, 0xbf,
0xc8, 0x66, 0x9e, 0x13, 0x7a, 0xfb, 0x38, 0x75, 0x8c, 0xff, 0x93, 0xe8, 0x91,
0xcb, 0xbf, 0x75, 0xb1, 0x45, 0x2b, 0x77, 0x3d, 0x77, 0x51, 0x80, 0xe6, 0x38,
0x68, 0x7a, 0x9c, 0x66, 0xfe, 0x01, 0x23, 0x9a, 0x1a, 0x27, 0xd7, 0x1d, 0xb4,
0x89, 0x71, 0x9a, 0xe4, 0xa5, 0x31, 0xde, 0xc9, 0x28, 0x4f, 0x87, 0xc7, 0xa9,
0x64, 0x92, 0xca, 0xbe, 0xa8, 0x35, 0x53, 0xfd, 0x3a, 0x9a, 0xd6, 0x41, 0x94,
0xd1, 0x8b, 0xa2, 0x1f, 0x26, 0x3c, 0x67, 0x64, 0x4b, 0x0f, 0x39, 0x1f, 0xeb,
0x4e, 0xc0, 0x4c, 0x20, 0x4a, 0x2b, 0x51, 0x67, 0xc4, 0x6c, 0x0c, 0x8c, 0x95,
0x64, 0x37, 0xa1, 0xe0, 0xa5, 0xfc, 0x57, 0xba, 0x9f, 0x8f, 0x98, 0x44, 0xc1,
0x32, 0x56, 0xdf, 0xd9, 0xf5, 0x47, 0xfd, 0xaf, 0x8b, 0xae, 0x98, 0x6e, 0x0c,
0x3d, 0xe7, 0x30, 0xf2, 0xf6, 0x35, 0x66, 0x72, 0x9a, 0x29, 0x51, 0x45, 0xc6,
0x97, 0x0f, 0xeb, 0xd0, 0x39, 0x03, 0xcd, 0x8b, 0xb5, 0x46, 0x14, 0x64, 0x91,
0xe6, 0x43, 0xc7, 0x6b, 0x09, 0x3f, 0xf1, 0x14, 0x80, 0xc6, 0x72, 0x69, 0x32,
0x97, 0xea, 0xad, 0xd4, 0x64, 0xa5, 0xcd, 0x33, 0xb8, 0xcf, 0x90, 0x67, 0x84,
0xd9, 0x88, 0xc1, 0x5e, 0x84, 0xfc, 0xc7, 0x88, 0x8f, 0x92, 0x7e, 0x64, 0x2b,
0x80, 0x3d, 0x80, 0xec, 0x57, 0xcd, 0x1f, 0x77, 0x88, 0x2e, 0xe3, 0x76, 0xa1,
0xdf, 0x45, 0x6e, 0x04, 0xe5, 0x47, 0x50, 0xb7, 0x11, 0x47, 0x6f, 0xcf, 0xbd,
0xb8, 0x52, 0x8d, 0x61, 0x33, 0x72, 0x7f, 0x98, 0xf4, 0xf0, 0xfc, 0x5f, 0xa7,
0xfc, 0x60, 0xe6, 0x71, 0x75, 0x20, 0xd5, 0x6f, 0xa0, 0x9b, 0xad, 0x5d, 0x31,
0xad, 0x20, 0x32, 0x9d, 0x34, 0xe9, 0x94, 0x61, 0xa3, 0xa8, 0xaf, 0xe3, 0x1d,
0xa0, 0x1a, 0x23, 0x76, 0x3e, 0x1e, 0x7f, 0x54, 0xf5, 0x4c, 0xc0, 0x7d, 0x7f,
0xe3, 0x6e, 0xe5, 0xfd, 0xd1, 0xd6, 0x04, 0x76, 0x27, 0x40, 0xad, 0x46, 0x48,
0xfd, 0xf3, 0xdf, 0xed, 0x63, 0xbc, 0x54, 0xea, 0x45, 0xc0, 0x02, 0x82, 0x17,
0x70, 0xb1, 0xfb, 0xda, 0x55, 0xe8, 0x56, 0x7d, 0xc5, 0x59, 0x15, 0x2d, 0xa8,
0x28, 0xcf, 0x86, 0xcc, 0xab, 0x61, 0x16, 0x1c, 0x4c, 0x22, 0xe4, 0xcd, 0x96,
0x60, 0x44, 0x3e, 0xd0, 0xfc, 0x66, 0x8c, 0x9a, 0x76, 0xac, 0xa8, 0xff, 0xc8,
0xf6, 0xab, 0xca, 0x27, 0x36, 0x5f, 0xce, 0x89, 0x24, 0x2a, 0xcb, 0x46, 0x45,
0x36, 0x0e, 0x9c, 0xa8, 0x56, 0x54, 0x34, 0xf3, 0xf6, 0xda, 0x6c, 0x2c, 0x28,
0xb6, 0x9e, 0x39, 0x78, 0x21, 0x29, 0x94, 0x12, 0xb4, 0x54, 0x70, 0xdf, 0xfe,
0x07, 0x9d, 0xbf, 0xed, 0xfa, 0xa1, 0xf9, 0x09, 0xe3, 0x1e, 0xca, 0xdb, 0x10,
0xf2, 0x67, 0xfb, 0x3f, 0x6d, 0x7e, 0x46, 0xe3, 0xc7, 0x9f, 0xb2, 0xbc, 0x02,
0xeb, 0x6b, 0x15, 0xe9, 0x28, 0x4e, 0x47, 0x69, 0xba, 0x78, 0x72, 0xe8, 0x22,
0x1c, 0x2f, 0xf7, 0x89, 0x51, 0x6e, 0x39, 0xd0, 0xfb, 0x68, 0xef, 0x95, 0xa6,
0x97, 0xd9, 0xab, 0x69, 0x9f, 0x16, 0x3d, 0x66, 0x7f, 0xbd, 0xcd, 0x46, 0xfd,
0x7c, 0x6a, 0x9f, 0x5e, 0x1b, 0xd5, 0x90, 0xdf, 0x22, 0xfc, 0xde, 0x0a, 0x2e,
0x27, 0x3a, 0xf1, 0x42, 0x75, 0x82, 0x80, 0x1a, 0xda, 0x8d, 0x45, 0xe8, 0x4f,
0x66, 0x14, 0x99, 0x4f, 0x14, 0xfc, 0x2a, 0xe7, 0xbd, 0xf4, 0x76, 0xde, 0x81,
0x5f, 0x06, 0x06, 0x59, 0xf8, 0x9f, 0x2d, 0xac, 0x62, 0xc2, 0x08, 0x97, 0x11,
0xcd, 0x56, 0x5a, 0x79, 0xae, 0xeb, 0x15, 0x5d, 0x0d, 0x68, 0xde, 0x88, 0x25,
0x23, 0x4a, 0x6a, 0xd0, 0x77, 0xbd, 0xf7, 0x86, 0xf5, 0x88, 0x23, 0x8f, 0x39,
0x31, 0xe9, 0x44, 0x5c, 0x21, 0x4a, 0xaf, 0xf2, 0x9a, 0x69, 0x23, 0x36, 0x3f,
0xff, 0xb3, 0xf8, 0x38, 0x3e, 0xa0, 0xb2, 0x45, 0x54, 0x2c, 0x22, 0x21, 0x8f,
0x92, 0xf2, 0xa8, 0x37, 0x8f, 0x06, 0xf2, 0xe8, 0xf6, 0x06, 0xb6, 0x37, 0x7c,
0xab, 0xb4, 0xc3, 0x11, 0xaf, 0x2f, 0xf0, 0x1e, 0xe3, 0xba, 0x31, 0xf8, 0x5a,
0xd0, 0x03, 0x85, 0x70, 0x7f, 0x64, 0x69, 0x96, 0x2a, 0x6b, 0x0a, 0x91, 0x77,
0x5f, 0xc1, 0xfb, 0x0f, 0xa7, 0xff, 0x2a, 0x26, 0x1b, 0x54, 0x36, 0x87, 0xd4,
0x07, 0x43, 0x3f, 0xc9, 0xac, 0x10, 0x8b, 0xa3, 0xcb, 0xc6, 0xfc, 0x2c, 0x46,
0x5e, 0xac, 0x79, 0xd7, 0xf9, 0x6e, 0x14, 0xaf, 0x4c, 0xee, 0x81, 0xe6, 0x4f,
0x44, 0x86, 0x72, 0x6b, 0xc9, 0xf8, 0x48, 0x70, 0x26, 0xd5, 0x65, 0xa2, 0x21,
0x13, 0xe5, 0xcd, 0x64, 0x6b, 0xa6, 0x1a, 0x3f, 0x72, 0xfa, 0x51, 0xd9, 0x2c,
0x2a, 0x66, 0x11, 0x30, 0x8e, 0xe0, 0x71, 0xf1, 0xef, 0x78, 0xbe, 0x23, 0x53,
0x7a, 0x4c, 0x7b, 0x09, 0x75, 0x95, 0x10, 0xb5, 0x96, 0x52, 0x47, 0xa9, 0x3c,
0xa6, 0xb2, 0x1e, 0x4c, 0x7c, 0x68, 0x0a, 0x41, 0x0e, 0xea, 0xef, 0x0f, 0xae,
0xc2, 0xec, 0x30, 0x16, 0x86, 0xa1, 0x4d, 0x25, 0x5d, 0x2a, 0xad, 0x67, 0xe2,
0x57, 0x07, 0x0f, 0x55, 0x3d, 0x98, 0x18, 0x88, 0x28, 0x15, 0xa2, 0x14, 0x57,
0x7a, 0xe8, 0xf8, 0x2f, 0x37, 0xf6, 0x38, 0x69, 0x54, 0xc1, 0xfb, 0xe0, 0x00,
0xf3, 0x66, 0xa0, 0x2e, 0x1b, 0x0d, 0xd9, 0xd8, 0xdc, 0x82, 0x7b, 0x8b, 0x0f,
0x2c, 0x98, 0x52, 0x83, 0x89, 0xa6, 0xeb, 0x91, 0x17, 0x88, 0x88, 0x16, 0xce,
0x2d, 0xf1, 0x94, 0xff, 0xa5, 0x27, 0x13, 0xc7, 0x99, 0x38, 0x95, 0x9e, 0xbf,
0x97, 0x09, 0xc5, 0x6e, 0x26, 0x8e, 0x32, 0x31, 0xff, 0xd3, 0x19, 0x17, 0x87,
0x04, 0x64, 0x61, 0xf1, 0xde, 0x8d, 0x22, 0x9e, 0x4b, 0xab, 0x22, 0x5d, 0x02,
0xa2, 0xb2, 0x30, 0x1f, 0x44, 0x4b, 0x41, 0xd4, 0xea, 0x42, 0x87, 0x0b, 0x91,
0x59, 0xd0, 0x64, 0x21, 0x2e, 0x0b, 0xfa, 0x2c, 0x50, 0x48, 0x16, 0xc2, 0x78,
0x12, 0x5a, 0x4c, 0x11, 0xc5, 0xbc, 0xaf, 0xb4, 0x2c, 0xca, 0xcc, 0xa2, 0x9d,
0x5a, 0xec, 0xd7, 0x82, 0x0e, 0x3a, 0xe0, 0xe9, 0xe0, 0xc9, 0x29, 0xbc, 0x67,
0x38, 0x88, 0xa5, 0xbe, 0x0f, 0x12, 0x22, 0xd0, 0xf7, 0xb6, 0xfd, 0x87, 0x81,
0x1f, 0x9b, 0x8c, 0xc8, 0x32, 0x22, 0xc7, 0x88, 0xe2, 0x5e, 0x1c, 0xbc, 0x99,
0x9f, 0x26, 0xd3, 0xeb, 0x3a, 0x16, 0xd6, 0x2f, 0x48, 0x79, 0xac, 0x91, 0x26,
0x1b, 0xc5, 0xfe, 0x54, 0x92, 0xe9, 0x6a, 0x54, 0x38, 0x9c, 0x12, 0xdd, 0xaf,
0x47, 0xd0, 0xad, 0x08, 0x9e, 0x1e, 0x64, 0x21, 0xed, 0xb5, 0xb4, 0x87, 0x77,
0xff, 0x53, 0x8b, 0xcc, 0x0e, 0xd1, 0x93, 0x28, 0x7b, 0xb3, 0xa5, 0x80, 0x86,
0x8d, 0x18, 0xe5, 0x6c, 0x69, 0x44, 0x6e, 0x3a, 0xbc, 0x6a, 0x58, 0x1e, 0x1a,
0x30, 0xc2, 0xde, 0x06, 0x47, 0x1b, 0xc6, 0x8c, 0x98, 0xe4, 0xb8, 0xcb, 0x46,
0xac, 0x19, 0xc1, 0xff, 0xb5, 0x1f, 0xe8, 0x3e, 0x58, 0xe1, 0x80, 0xd5, 0x04,
0x1a, 0x79, 0x73, 0xf5, 0x03, 0x55, 0x1e, 0x85, 0x6b, 0x28, 0x4a, 0x43, 0x3e,
0x3c, 0xf2, 0x61, 0x1e, 0xb4, 0x91, 0xa7, 0x8d, 0x97, 0x38, 0x3d, 0xcd, 0x19,
0x71, 0x49, 0xe4, 0x2a, 0x0e, 0x8c, 0x48, 0x4e, 0x47, 0x7c, 0x33, 0x05, 0x64,
0x23, 0x98, 0xef, 0x7c, 0x6c, 0x39, 0xc5, 0x97, 0x53, 0x86, 0x86, 0x8c, 0x1a,
0x5e, 0x7d, 0x32, 0x8a, 0x82, 0x57, 0x1d, 0xef, 0xbb, 0x9d, 0x08, 0xcd, 0x46,
0x04, 0xaf, 0x6e, 0xd4, 0x51, 0x8b, 0x8e, 0xea, 0x6a, 0xa8, 0xa1, 0x86, 0x24,
0xfe, 0x2a, 0xfb, 0xb4, 0x4d, 0x23, 0xd2, 0xff, 0xa1, 0xf2, 0xed, 0xb9, 0x43,
0x64, 0x65, 0x43, 0x89, 0xcc, 0xec, 0x4b, 0x4f, 0x18, 0x2b, 0xc7, 0x64, 0x39,
0xba, 0x4b, 0xd0, 0x57, 0x82, 0x9d, 0x0d, 0xec, 0x4b, 0x04, 0x5b, 0x92, 0x0d,
0xab, 0x40, 0x8a, 0x4b, 0xa4, 0xb9, 0x2f, 0x2b, 0x44, 0x6e, 0x38, 0x1b, 0xa3,
0xd9, 0xb0, 0x67, 0xa3, 0xee, 0x0d, 0xef, 0x96, 0xd4, 0xbc, 0x35, 0x1b, 0x1d,
0x52, 0x47, 0x7b, 0x66, 0x1c, 0x9a, 0x91, 0x32, 0x82, 0xf4, 0x91, 0xf3, 0x7e,
0x4b, 0xe2, 0xc9, 0x1a, 0x2f, 0x67, 0x97, 0xb3, 0xb1, 0x76, 0xe7, 0x79, 0x89,
0xfb, 0xd8, 0xfe, 0x61, 0xbe, 0xc0, 0x3b, 0xc9, 0x86, 0x2a, 0x07, 0x14, 0x99,
0x83, 0x46, 0x3d, 0x4a, 0xff, 0x55, 0x66, 0xa4, 0xa8, 0xb6, 0xe7, 0x93, 0x23,
0x9f, 0xa8, 0x38, 0x94, 0x4a, 0x43, 0x45, 0xb9, 0xae, 0x9d, 0x1a, 0xda, 0xbf,
0x53, 0x15, 0x6d, 0xda, 0xc9, 0x6d, 0xa7, 0xba, 0x1c, 0x34, 0xe4, 0x80, 0xff,
0x8f, 0xe9, 0x30, 0xa9, 0x83, 0x93, 0x77, 0x98, 0x55, 0x45, 0x39, 0x55, 0x12,
0xca, 0x6a, 0x07, 0x6d, 0x74, 0xf8, 0xd0, 0x6f, 0xe6, 0xa0, 0xf2, 0xe5, 0x98,
0x65, 0x04, 0xe2, 0x5b, 0x3d, 0xd5, 0xf5, 0xa2, 0xa1, 0x57, 0x06, 0x87, 0x9a,
0x10, 0x61, 0xe2, 0xd9, 0x3c, 0x35, 0x99, 0xd5, 0x97, 0x50, 0x52, 0x4c, 0xe8,
0x7d, 0xd9, 0xbd, 0x22, 0x90, 0x72, 0x4d, 0x80, 0x32, 0x47, 0x20, 0x51, 0xd6,
0x0c, 0x72, 0x66, 0x10, 0x9a, 0x48, 0x11, 0x89, 0x12, 0x56, 0xc2, 0x1e, 0x92,
0xf6, 0xee, 0xf4, 0x3f, 0x68, 0xc2, 0xf7, 0xbb, 0x4c, 0x50, 0x50, 0xaf, 0x09,
0x03, 0x26, 0x19, 0xde, 0xb8, 0x81, 0x96, 0x8d, 0xbb, 0x87, 0xb0, 0x15, 0x41,
0xbb, 0x11, 0x7f, 0xaf, 0xd6, 0xdd, 0xb2, 0xd2, 0x50, 0x30, 0x4a, 0xae, 0x0d,
0xd4, 0x40, 0x5b, 0x8b, 0xdc, 0x6b, 0xf3, 0x5f, 0x2e, 0x85, 0xa0, 0xca, 0x8e,
0x9b, 0xfd, 0xe8, 0x7c, 0x27, 0x27, 0x8f, 0x06, 0xb5, 0x34, 0xa2, 0xa5, 0x5c,
0x3f, 0xca, 0x17, 0x82, 0xb2, 0xbb, 0x9c, 0xfa, 0xb8, 0xb8, 0xbb, 0x3d, 0x86,
0x91, 0x67, 0x15, 0xfa, 0x3c, 0xb1, 0x89, 0x55, 0xa4, 0xaf, 0xa2, 0xd8, 0x0a,
0x8a, 0xaf, 0x90, 0x27, 0x1c, 0x4f, 0x0d, 0x7c, 0x73, 0xca, 0x37, 0x61, 0xdb,
0x04, 0xd9, 0x6f, 0xc1, 0x71, 0x0b, 0x74, 0xd2, 0x4d, 0xce, 0xc7, 0x0c, 0x3f,
0x1a, 0x78, 0x7f, 0x20, 0x0f, 0x29, 0x51, 0x14, 0xfb, 0x88, 0x35, 0x9f, 0x96,
0xf3, 0x68, 0xe9, 0x17, 0xd9, 0xbf, 0x19, 0x7d, 0x3b, 0xf4, 0xd1, 0xbd, 0xc7,
0xda, 0x42, 0x10, 0x56, 0x8a, 0xbc, 0x76, 0x64, 0xdd, 0x70, 0x3f, 0x3f, 0xb3,
0xc8, 0x17, 0x3a, 0x95, 0x06, 0x7e, 0x75, 0xc2, 0x06, 0x0a, 0x41, 0x9b, 0x27,
0x70, 0x9f, 0xf0, 0x3e, 0x0a, 0x69, 0xe0, 0xa5, 0x22, 0xde, 0xd9, 0x72, 0x33,
0xb9, 0x43, 0xe0, 0xa9, 0x11, 0x33, 0xed, 0xf7, 0xa7, 0x21, 0x7f, 0xce, 0x5f,
0x7e, 0xe4, 0xff, 0x8b, 0xa0, 0x57, 0x3d, 0x9b, 0xe8, 0xed, 0xc1, 0x40, 0x0f,
0xea, 0xe3, 0x68, 0xfc, 0x0f, 0xd7, 0x3c, 0x1c, 0x23, 0x3c, 0x9f, 0xa2, 0xf2,
0xe9, 0x38, 0x07, 0xa7, 0x39, 0xd8, 0xe2, 0x2c, 0xfd, 0x10, 0x4f, 0xa5, 0x2d,
0xe3, 0x03, 0x89, 0xc4, 0x21, 0x1f, 0xf3, 0x71, 0x09, 0xcd, 0x3f, 0x14, 0x9c,
0x8e, 0x42, 0x3d, 0x32, 0x9f, 0x5e, 0x89, 0xa3, 0x65, 0x2d, 0xed, 0xff, 0x45,
0xe2, 0xab, 0x51, 0x51, 0x82, 0x6f, 0xf9, 0xb4, 0x22, 0x81, 0x39, 0x3e, 0xd1,
0xe5, 0x78, 0x5a, 0x13, 0x44, 0x97, 0xb5, 0x8f, 0x9c, 0x7d, 0x6c, 0x96, 0xa2,
0xe3, 0xde, 0x9c, 0x5c, 0xec, 0x85, 0xd1, 0x61, 0x18, 0x05, 0x55, 0xd1, 0xc6,
0x33, 0x86, 0x30, 0x2e, 0x75, 0x52, 0x29, 0x38, 0x95, 0x9a, 0x6b, 0xa9, 0xad,
0x56, 0x5e, 0x5d, 0x41, 0x11, 0xed, 0xe1, 0xd4, 0x15, 0x4e, 0xe1, 0x67, 0x88,
0x3a, 0x03, 0x25, 0xa6, 0x53, 0xf8, 0x83, 0x26, 0x2b, 0xa7, 0xc2, 0x32, 0x2a,
0x2d, 0x93, 0x91, 0xea, 0x0b, 0xd0, 0x54, 0x80, 0xb4, 0x43, 0x64, 0x1e, 0x82,
0x73, 0x58, 0xe3, 0xb5, 0x30, 0x23, 0x51, 0xa4, 0x83, 0x34, 0x0e, 0xd2, 0x1a,
0x31, 0xff, 0xd4, 0x61, 0x2f, 0xca, 0x26, 0x71, 0xf4, 0xe5, 0xee, 0x7d, 0xfe,
0x8f, 0xe6, 0xfc, 0xb6, 0x3c, 0x10, 0x1d, 0x26, 0x9a, 0xae, 0xc3, 0xc4, 0xd7,
0xff, 0xb5, 0x25, 0x1c, 0xe1, 0x2f, 0x87, 0xb9, 0x41, 0x67, 0x65, 0xb4, 0xfb,
0x52, 0xd4, 0xcf, 0x54, 0x16, 0xf4, 0xea, 0x68, 0x40, 0x47, 0x54, 0xcd, 0x15,
0xcd, 0xbd, 0x81, 0x16, 0x50, 0x4a, 0x1f, 0xaa, 0x6f, 0x4c, 0x1a, 0xc5, 0xce,
0x7c, 0x34, 0x91, 0x8b, 0xbf, 0xf0, 0xbc, 0x6e, 0xff, 0xa2, 0xfe, 0xfe, 0x11,
0x27, 0x0d, 0x36, 0xd2, 0x08, 0x97, 0x4d, 0xcd, 0x1b, 0x68, 0x13, 0x44, 0x93,
0xeb, 0x45, 0xbe, 0x97, 0xa7, 0xc9, 0x5e, 0x54, 0x3f, 0x30, 0x1e, 0x4d, 0xb7,
0x3b, 0x69, 0xbb, 0x93, 0xd2, 0x2c, 0x88, 0xfb, 0xda, 0x66, 0xa6, 0x31, 0x07,
0x4d, 0x3a, 0xf8, 0xe4, 0x2d, 0xc8, 0xe1, 0x7d, 0xf6, 0xda, 0xd0, 0xfa, 0xf4,
0xe2, 0xbd, 0xc1, 0x8a, 0xce, 0xb7, 0x55, 0x4f, 0x73, 0x81, 0xb0, 0x57, 0x40,
0x87, 0x05, 0x94, 0xc7, 0x6b, 0x56, 0x43, 0x60, 0x7d, 0x68, 0xe0, 0xe5, 0xa8,
0x19, 0x99, 0x0c, 0x4f, 0x06, 0xa1, 0x1a, 0x42, 0x99, 0x05, 0x63, 0x3f, 0xd3,
0x70, 0xe2, 0xed, 0x37, 0x53, 0xce, 0xb5, 0xa2, 0x14, 0xce, 0x89, 0x33, 0x70,
0xcc, 0x60, 0xfe, 0x10, 0x4b, 0x87, 0x10, 0xee, 0x40, 0xa3, 0x05, 0x2d, 0x16,
0xb4, 0x5b, 0xd0, 0xc5, 0xfb, 0xe8, 0xb4, 0xa0, 0x87, 0x27, 0x14, 0xdb, 0x47,
0xf1, 0x7d, 0xd4, 0xa8, 0xa7, 0x16, 0x3d, 0x75, 0xaf, 0x62, 0xea, 0xdf, 0x14,
0xa5, 0x4b, 0x5c, 0x5c, 0x42, 0x8e, 0x12, 0xd1, 0x84, 0x5a, 0x2c, 0x77, 0xc8,
0xf8, 0xb6, 0x05, 0xdb, 0x16, 0xa4, 0xa5, 0x50, 0x66, 0x8a, 0xc8, 0x63, 0xd7,
0x22, 0xab, 0x25, 0x2f, 0xba, 0xbc, 0x3e, 0x96, 0x08, 0x2a, 0x81, 0xba, 0x84,
0x4b, 0xfb, 0x12, 0x84, 0x95, 0xf8, 0x40, 0x71, 0x51, 0xa4, 0x8f, 0xa2, 0x80,
0x6d, 0x84, 0xbc, 0xbf, 0xfb, 0x47, 0xe3, 0xf7, 0x39, 0x5e, 0xd3, 0x3f, 0x37,
0xf8, 0xb1, 0x53, 0x12, 0x16, 0x91, 0x55, 0x14, 0xef, 0x87, 0xe4, 0x3f, 0xcb,
0xfe, 0x61, 0xc7, 0xaf, 0xc9, 0x2d, 0x64, 0x8c, 0x1f, 0x37, 0x21, 0x7e, 0x6f,
0xe4, 0xea, 0xb8, 0xf6, 0xce, 0x53, 0x83, 0x72, 0xb0, 0xf3, 0x8a, 0x57, 0xd8,
0x2a, 0x95, 0x1d, 0x54, 0x25, 0xc4, 0x41, 0x64, 0x0b, 0x34, 0x2d, 0xe8, 0x0e,
0xa2, 0xbe, 0x20, 0xaa, 0xeb, 0x41, 0x43, 0x8f, 0x78, 0x52, 0x62, 0x0e, 0x0c,
0x39, 0xd8, 0xd3, 0xd2, 0xa1, 0x68, 0x9b, 0x96, 0x83, 0xcc, 0x1c, 0x34, 0xc7,
0x53, 0x9b, 0x4f, 0x88, 0x55, 0xfb, 0x53, 0xad, 0xbf, 0x64, 0x01, 0xef, 0x23,
0x6c, 0xff, 0x12, 0x03, 0xb7, 0xe7, 0xa0, 0x2b, 0xe7, 0xbc, 0xac, 0x2d, 0x42,
0xc6, 0xcb, 0x15, 0x9c, 0xfe, 0xe9, 0xac, 0x88, 0x0e, 0x6f, 0x58, 0x1e, 0x1a,
0x6f, 0x10, 0x55, 0x07, 0xfd, 0x64, 0xbe, 0xd6, 0xd3, 0x40, 0x75, 0x03, 0x68,
0x18, 0x90, 0x64, 0x48, 0x11, 0xf2, 0x8b, 0xb0, 0x98, 0x84, 0xba, 0x07, 0xf2,
0x8b, 0x05, 0x20, 0xdb, 0x0a, 0xbf, 0x5f, 0x1d, 0x3f, 0x91, 0xd3, 0x47, 0x63,
0xad, 0x74, 0x2b, 0x16, 0xb7, 0xca, 0xf8, 0x3e, 0x35, 0x62, 0xa3, 0x11, 0x94,
0x97, 0x4e, 0x87, 0x57, 0xad, 0x09, 0x94, 0x3c, 0x8a, 0xd4, 0x51, 0xd0, 0x5e,
0x19, 0x0e, 0x79, 0x25, 0x05, 0xd9, 0x48, 0x6d, 0xe3, 0x2d, 0xcf, 0xca, 0xe0,
0x6f, 0xbd, 0x33, 0x9e, 0x75, 0x2f, 0x72, 0xee, 0x09, 0x7b, 0xaa, 0xb6, 0x8b,
0xdb, 0x19, 0x56, 0x4c, 0xbc, 0xb9, 0x1b, 0x40, 0xd3, 0x1b, 0x98, 0xdb, 0xc0,
0xed, 0x43, 0x6c, 0x1f, 0x82, 0x5b, 0x63, 0xfb, 0x56, 0xb4, 0xde, 0xc6, 0xd0,
0x03, 0x71, 0x6f, 0xcc, 0x3e, 0x75, 0x6b, 0x50, 0x30, 0x90, 0x89, 0x82, 0x6f,
0xb8, 0x87, 0xb0, 0xda, 0x47, 0x2b, 0x7a, 0xfc, 0x79, 0x8f, 0x0d, 0x7e, 0xf5,
0x94, 0xfa, 0xaf, 0x2b, 0xae, 0x58, 0x02, 0x39, 0x75, 0x74, 0x91, 0xaa, 0x9b,
0xe6, 0xbb, 0x68, 0xa9, 0x8b, 0x42, 0xfb, 0x28, 0xa9, 0x12, 0xeb, 0x4f, 0xe4,
0xbe, 0xab, 0xbe, 0x6f, 0xe0, 0xdd, 0xd6, 0x77, 0xb9, 0xd4, 0x2a, 0xb4, 0xe2,
0xec, 0x09, 0xcb, 0x24, 0x12, 0xcc, 0x48, 0x32, 0x63, 0x6c, 0x12, 0x93, 0x93,
0x7c, 0x88, 0x56, 0x84, 0xdf, 0x58, 0x7a, 0xe9, 0xf8, 0x81, 0xa4, 0x29, 0x1c,
0x18, 0x49, 0xf5, 0x6c, 0xf3, 0x43, 0xce, 0x08, 0x0a, 0x31, 0x50, 0xcc, 0xab,
0x87, 0x43, 0xc8, 0x30, 0xc3, 0x68, 0x96, 0xa4, 0xe7, 0x21, 0x72, 0x38, 0x69,
0x65, 0xb4, 0x93, 0xb1, 0x5d, 0xb0, 0x92, 0xee, 0xdd, 0x80, 0x67, 0x55, 0x9c,
0x2d, 0x42, 0x74, 0x14, 0xa6, 0xa3, 0xa0, 0x7e, 0xbc, 0xd5, 0xf5, 0xf0, 0x86,
0x15, 0xb2, 0x2b, 0xda, 0xd9, 0x45, 0x3d, 0x5d, 0x9c, 0x0d, 0x75, 0xd4, 0xa4,
0xa3, 0x02, 0x33, 0x15, 0x99, 0xf9, 0x66, 0x97, 0x23, 0xb0, 0x1c, 0xf6, 0x66,
0x38, 0xb8, 0x19, 0x35, 0x3c, 0x8a, 0xbe, 0xc7, 0xd4, 0xe5, 0x08, 0x2a, 0x47,
0xe4, 0xe3, 0xf1, 0x63, 0x28, 0x68, 0xa3, 0xd4, 0xa7, 0x34, 0x29, 0x12, 0x99,
0x94, 0x43, 0x53, 0xee, 0x5b, 0xa2, 0xc4, 0x3c, 0x18, 0x84, 0x48, 0xa4, 0xdb,
0x7b, 0xd8, 0x16, 0xb2, 0x3a, 0x7a, 0x0c, 0x31, 0x63, 0x68, 0xde, 0xc5, 0xf4,
0xbb, 0xa6, 0x6e, 0x09, 0x25, 0xad, 0x1d, 0xd3, 0x01, 0xd0, 0x3d, 0xd1, 0xf0,
0x5e, 0xe7, 0xa3, 0x9b, 0x6f, 0x2e, 0xd9, 0x65, 0x42, 0xd3, 0x70, 0x95, 0x12,
0xbe, 0x89, 0xa8, 0x4d, 0xc4, 0xed, 0x63, 0xff, 0xea, 0xed, 0x0f, 0xf5, 0x5f,
0x7b, 0x86, 0x50, 0xe9, 0x47, 0x55, 0x42, 0xe6, 0x0e, 0xe7, 0x21, 0x32, 0x01,
0x4b, 0x4e, 0x2e, 0x33, 0x12, 0x29, 0xef, 0x7a, 0xed, 0x83, 0x31, 0xf7, 0x45,
0x68, 0xe9, 0x28, 0x11, 0xd8, 0x79, 0x6c, 0xf8, 0xc3, 0x98, 0x0f, 0x32, 0x74,
0xa8, 0x78, 0xa8, 0xeb, 0xf1, 0xda, 0xe7, 0xe2, 0xdf, 0x38, 0x78, 0xbb, 0xe2,
0xf1, 0xa6, 0x76, 0xb4, 0x97, 0xa3, 0xe4, 0xfa, 0xec, 0xfb, 0xdb, 0xaf, 0xa8,
0x14, 0xb7, 0x16, 0x71, 0x9c, 0x88, 0xc8, 0x5c, 0xa8, 0x73, 0x11, 0x98, 0x24,
0xf6, 0xb6, 0x1d, 0x6a, 0x8e, 0xd1, 0x4e, 0x2d, 0x0f, 0x72, 0xc3, 0xf5, 0x2c,
0x11, 0xfe, 0x49, 0xb8, 0x59, 0x48, 0x15, 0x57, 0x56, 0xff, 0x30, 0xaa, 0x9e,
0xd2, 0xe6, 0x30, 0xfb, 0xc7, 0xd1, 0x8f, 0xfb, 0x5f, 0x37, 0x3c, 0x37, 0x73,
0x35, 0xe2, 0xa5, 0xc5, 0x97, 0xdc, 0x63, 0x38, 0x8a, 0xa4, 0xed, 0x2f, 0xb5,
0x5f, 0x1a, 0x04, 0x5b, 0x04, 0xa5, 0x90, 0x3a, 0x85, 0x1a, 0xb5, 0x34, 0xfe,
0xcc, 0xc8, 0x83, 0x83, 0x9f, 0xad, 0xa4, 0x89, 0xe6, 0xfc, 0x01, 0xa7, 0x89,
0xa0, 0x6c, 0x3b, 0xf5, 0x3e, 0x92, 0x74, 0xdd, 0xcb, 0xe6, 0xec, 0x54, 0x52,
0x44, 0x99, 0x7f, 0xde, 0xff, 0x93, 0xaa, 0x67, 0x8e, 0x7e, 0xdf, 0x78, 0x82,
0xea, 0x5a, 0x54, 0x3d, 0xce, 0x9f, 0xde, 0x3e, 0x85, 0xa9, 0xcf, 0xf2, 0x39,
0x9b, 0x24, 0x4e, 0x21, 0xf2, 0xff, 0xcc, 0x6f, 0xa1, 0x20, 0x17, 0x0a, 0xdf,
0xac, 0x28, 0xa4, 0xc1, 0x29, 0x8c, 0x4c, 0x21, 0x65, 0x00, 0xe9, 0x9c, 0x84,
0x93, 0x93, 0x90, 0xca, 0x47, 0x5a, 0xd9, 0x4c, 0x55, 0xcd, 0x14, 0xd9, 0x41,
0x9a, 0x0e, 0xba, 0x59, 0x4e, 0xf9, 0xc9, 0xb0, 0x88, 0xf1, 0x53, 0x46, 0x30,
0x19, 0x83, 0xa9, 0x5c, 0x9a, 0xcb, 0x27, 0xea, 0x4f, 0x94, 0x19, 0x4f, 0x1b,
0x9f, 0xce, 0x4f, 0x42, 0xb5, 0x07, 0x8e, 0x47, 0xfc, 0x5d, 0xd2, 0x56, 0x84,
0x06, 0x53, 0x44, 0x30, 0xe5, 0x26, 0x81, 0xc3, 0xd3, 0x92, 0x90, 0x99, 0x84,
0x90, 0x5a, 0x84, 0xd5, 0x9e, 0x53, 0x72, 0x4d, 0x12, 0xfe, 0xa8, 0xf5, 0x67,
0x4b, 0x2e, 0x34, 0x16, 0x51, 0x94, 0x0e, 0xf7, 0x0e, 0x7e, 0xac, 0xe7, 0xec,
0x77, 0xb6, 0x85, 0xcd, 0x9f, 0x6a, 0x1e, 0x9f, 0xe1, 0xa6, 0x41, 0x41, 0x2a,
0x15, 0xa5, 0x52, 0x6f, 0x12, 0x06, 0x92, 0xd0, 0x98, 0x84, 0x96, 0x24, 0x14,
0xfb, 0x53, 0xa9, 0xc4, 0xa2, 0xc9, 0x8d, 0x28, 0xf9, 0xb4, 0xaf, 0x88, 0xfa,
0x53, 0x69, 0xee, 0xed, 0xa3, 0x4f, 0x37, 0x2a, 0x28, 0xab, 0x16, 0x39, 0xb5,
0x98, 0x4e, 0x82, 0x56, 0x8f, 0x81, 0x87, 0x32, 0x93, 0x89, 0x8e, 0xb4, 0x94,
0xfa, 0x6b, 0x9a, 0x4c, 0xc2, 0x60, 0x12, 0x46, 0xa4, 0x31, 0x07, 0xa2, 0x3d,
0x19, 0x0f, 0xda, 0x92, 0x31, 0x98, 0x0c, 0x24, 0x3e, 0x6a, 0x7d, 0x94, 0xa2,
0xae, 0x87, 0xfc, 0x7c, 0xe4, 0x27, 0x33, 0xc9, 0x28, 0x31, 0x90, 0xd5, 0x40,
0xbd, 0xad, 0x18, 0x68, 0xc5, 0x41, 0x32, 0xe9, 0x55, 0x98, 0x4b, 0xe6, 0x4d,
0xf6, 0x26, 0x70, 0xc8, 0x7d, 0xa5, 0x9b, 0xc9, 0x18, 0x4f, 0xc6, 0xd9, 0x20,
0xfc, 0x87, 0x30, 0x96, 0x8c, 0x4d, 0x07, 0xd2, 0xdf, 0xb5, 0x7d, 0xb4, 0x9d,
0x8c, 0xee, 0x62, 0xea, 0x2b, 0xa6, 0x89, 0x3a, 0x3a, 0xfc, 0x85, 0xfd, 0xcd,
0xa2, 0x4f, 0xb7, 0xb9, 0x83, 0x35, 0x9d, 0x8c, 0xc5, 0x97, 0x22, 0xff, 0x2e,
0xb0, 0x06, 0x4f, 0xc5, 0xbd, 0x90, 0xfa, 0x82, 0x92, 0x94, 0x2b, 0x1c, 0xcf,
0x4c, 0x7d, 0x66, 0x9a, 0xe5, 0x5d, 0xf2, 0x6e, 0x39, 0xc6, 0x55, 0xc5, 0xf2,
0xb3, 0x82, 0x81, 0x85, 0x35, 0x58, 0x49, 0xa9, 0xcf, 0xad, 0x7c, 0x92, 0xf6,
0xee, 0xfc, 0xa3, 0xb6, 0xfb, 0x4c, 0xdc, 0x22, 0xd9, 0x4b, 0x26, 0xeb, 0xcb,
0x4d, 0x13, 0x42, 0xc2, 0x34, 0xc2, 0xf8, 0xa4, 0x2b, 0x59, 0x5e, 0xb0, 0xc1,
0x3e, 0x1a, 0xe9, 0xa3, 0x10, 0x0b, 0x25, 0xe9, 0xe0, 0x4e, 0x46, 0xb3, 0x19,
0x6d, 0x66, 0xf8, 0x0d, 0x21, 0x70, 0x48, 0xd4, 0xaf, 0xae, 0x63, 0xf3, 0xbd,
0xf1, 0x36, 0x0a, 0x19, 0xa3, 0xb0, 0x31, 0x09, 0xff, 0x38, 0x19, 0xc3, 0x6f,
0x8c, 0xbe, 0xe1, 0xe5, 0xcd, 0x43, 0x0c, 0x08, 0x33, 0xc8, 0xbd, 0x24, 0x1b,
0x90, 0x2a, 0x65, 0xd3, 0x0c, 0xc8, 0x34, 0x20, 0x91, 0xe7, 0x17, 0x35, 0x50,
0x15, 0x72, 0x21, 0x6c, 0x40, 0x12, 0x2f, 0x71, 0x88, 0xc1, 0x80, 0x9a, 0x42,
0x72, 0x16, 0x52, 0xaf, 0x1b, 0x49, 0xd7, 0x4e, 0x5f, 0x3d, 0x2a, 0x83, 0xb5,
0x9b, 0xaa, 0x13, 0x51, 0xcb, 0xc9, 0x8b, 0x3a, 0x13, 0xd1, 0x93, 0x28, 0x89,
0x53, 0x09, 0x73, 0x71, 0x01, 0x2d, 0xaf, 0xf1, 0x9e, 0xb2, 0x0d, 0x30, 0x19,
0x70, 0x6c, 0xa0, 0x95, 0xf7, 0xe3, 0x6b, 0x10, 0xb4, 0x07, 0x35, 0x67, 0xbd,
0x12, 0x03, 0x0a, 0x6b, 0x30, 0x27, 0x0f, 0x88, 0x17, 0xac, 0xd2, 0xa3, 0x6b,
0x0c, 0xe8, 0xa1, 0x6d, 0xa9, 0x0f, 0xda, 0x4c, 0x84, 0x5b, 0xca, 0x95, 0xd7,
0x90, 0x8d, 0x5b, 0xb3, 0x21, 0xfe, 0x94, 0x7f, 0x5f, 0xc8, 0xe3, 0xc1, 0x7f,
0x37, 0xc7, 0x51, 0xfb, 0x83, 0x68, 0x88, 0xbb, 0x0a, 0x76, 0xac, 0x3d, 0x12,
0xf4, 0xd9, 0x92, 0xcf, 0x58, 0x8b, 0x13, 0x5b, 0x79, 0xf6, 0x92, 0x6e, 0x9c,
0xbb, 0x03, 0x89, 0x48, 0x7b, 0x33, 0x69, 0x15, 0x32, 0xfb, 0x24, 0xa4, 0x52,
0x4c, 0x20, 0xd6, 0x5f, 0x5d, 0x78, 0xb5, 0xfd, 0x17, 0xe3, 0xfc, 0xe1, 0xe1,
0x49, 0xa4, 0x52, 0xc1, 0x2f, 0x01, 0xff, 0x65, 0x3b, 0x01, 0x7a, 0xd1, 0xca,
0x2f, 0x05, 0x81, 0x29, 0x08, 0x4d, 0x42, 0x04, 0x2f, 0x05, 0x24, 0x21, 0x58,
0x00, 0xd3, 0x3a, 0x48, 0x6f, 0x41, 0x18, 0xcf, 0x26, 0xba, 0x30, 0xf8, 0xb6,
0xbb, 0x84, 0x64, 0x5a, 0xf5, 0x09, 0x93, 0x31, 0x18, 0xc6, 0x2e, 0x64, 0x6f,
0x6b, 0x12, 0x3a, 0x92, 0x50, 0xd0, 0x8e, 0xa2, 0x76, 0x94, 0xa7, 0xc0, 0x96,
0x82, 0x9b, 0x41, 0x34, 0x1e, 0x44, 0xdd, 0x49, 0xe8, 0xe3, 0xb4, 0xdf, 0x8d,
0xda, 0x6e, 0xd4, 0xf1, 0xa6, 0x4e, 0xb9, 0x79, 0x61, 0x12, 0x9a, 0x5f, 0xda,
0x17, 0xcd, 0x65, 0xf2, 0x15, 0x00, 0x2a, 0x12, 0x75, 0xed, 0x49, 0x78, 0x22,
0xfc, 0xbd, 0xaa, 0xf7, 0x38, 0x70, 0x3e, 0x09, 0x4b, 0x32, 0x7a, 0xfd, 0x36,
0xf6, 0xdf, 0xe9, 0x49, 0xc2, 0x6a, 0x12, 0x36, 0xb8, 0xde, 0x98, 0x43, 0xc3,
0x1c, 0xfa, 0x6f, 0x41, 0x77, 0xe3, 0x07, 0x57, 0x46, 0xce, 0x39, 0x60, 0x39,
0x09, 0xdf, 0x27, 0x17, 0xc7, 0x1f, 0x4e, 0xc2, 0xa8, 0x9c, 0x10, 0xaf, 0x94,
0x07, 0xb0, 0x95, 0x84, 0x5d, 0xb9, 0xab, 0xf6, 0x5b, 0xf0, 0xbf, 0xc1, 0x87,
0xca, 0x07, 0x7c, 0x65, 0xc0, 0x47, 0xfb, 0x82, 0xfc, 0x02, 0x34, 0x58, 0x29,
0x20, 0x9a, 0x4f, 0xc6, 0x12, 0x2f, 0x38, 0x28, 0x58, 0x05, 0x95, 0xe3, 0x7c,
0x7a, 0x8d, 0x13, 0x68, 0xe1, 0x64, 0x57, 0x13, 0x4b, 0xce, 0x58, 0xbe, 0x58,
0x06, 0x3c, 0x66, 0x12, 0xfb, 0x75, 0xc2, 0x99, 0xc5, 0x9f, 0x67, 0x38, 0x41,
0x9d, 0x4a, 0xb4, 0x78, 0x94, 0x8c, 0x2b, 0x81, 0xa2, 0xa6, 0xb3, 0x11, 0xe1,
0x91, 0x18, 0xef, 0xa3, 0xd9, 0x3a, 0x2c, 0xd4, 0xa1, 0xd9, 0x8d, 0x36, 0x6e,
0x04, 0x85, 0x1b, 0x10, 0x65, 0x40, 0xe7, 0x3c, 0x7a, 0xe6, 0x85, 0x61, 0x6a,
0x25, 0xbd, 0xf5, 0xb2, 0xa5, 0x9b, 0x62, 0xc0, 0x95, 0xe9, 0x17, 0xd4, 0xc3,
0xd2, 0x53, 0x65, 0xaa, 0xa1, 0x4a, 0x03, 0xd8, 0x7d, 0xa5, 0x06, 0xdc, 0xa1,
0x11, 0xaa, 0x33, 0xa0, 0xc9, 0x00, 0x5e, 0x51, 0x25, 0xca, 0x09, 0x81, 0xb4,
0xf6, 0xef, 0xfd, 0xae, 0xed, 0x3f, 0x63, 0x7f, 0x77, 0x7f, 0x57, 0xd4, 0x37,
0x1a, 0xd0, 0x22, 0x21, 0xc6, 0xd6, 0x50, 0xbc, 0xf0, 0x82, 0xa8, 0x97, 0x17,
0xfb, 0x0c, 0xe7, 0x73, 0x99, 0x30, 0xe0, 0xde, 0xb5, 0xf3, 0x52, 0x0d, 0x37,
0x97, 0x5f, 0x73, 0x0b, 0xf3, 0x6a, 0xd3, 0x00, 0xb7, 0xe1, 0x1b, 0xee, 0xc1,
0xe6, 0x0c, 0xdc, 0x33, 0x97, 0x60, 0x69, 0x29, 0xc8, 0x4c, 0xf1, 0x95, 0xcf,
0x4e, 0xe0, 0x7f, 0x2a, 0xf2, 0xb2, 0x01, 0x7b, 0xf9, 0xe7, 0x17, 0x45, 0x81,
0x51, 0x17, 0xa5, 0xe9, 0x14, 0xcc, 0xf1, 0x46, 0xb3, 0x29, 0x58, 0xe0, 0xc9,
0x4d, 0x3f, 0x4a, 0xbf, 0x56, 0xb5, 0x8d, 0xc5, 0x14, 0x14, 0xe8, 0xe0, 0xf8,
0x32, 0xe4, 0x21, 0xcf, 0xf3, 0x83, 0x6f, 0x54, 0xad, 0x21, 0xba, 0x85, 0x62,
0x5a, 0x7c, 0x8f, 0x4d, 0x81, 0x3b, 0x05, 0x5b, 0x3d, 0xd8, 0xe5, 0xc6, 0x49,
0x48, 0x1a, 0x15, 0x3c, 0x53, 0xd1, 0xc3, 0x9f, 0xb3, 0x8c, 0x98, 0x3f, 0xf7,
0x8a, 0xc7, 0x1f, 0xa7, 0xa0, 0xd3, 0x80, 0x0e, 0xae, 0x93, 0x6e, 0xdb, 0x29,
0xf0, 0xcd, 0x5b, 0x6f, 0xa8, 0x52, 0x39, 0xb4, 0x3e, 0x98, 0x9c, 0x9f, 0x04,
0xa6, 0x22, 0xa4, 0x17, 0x61, 0xbd, 0xc8, 0x38, 0x43, 0xfa, 0x7f, 0x44, 0x70,
0x2a, 0xee, 0x98, 0xb9, 0xbe, 0x5f, 0x56, 0x1a, 0x72, 0xd2, 0xb8, 0x23, 0xb9,
0x81, 0x78, 0x31, 0xef, 0xfe, 0x43, 0x0c, 0x1d, 0x4a, 0x3a, 0xb1, 0x17, 0x9e,
0x87, 0x15, 0xbb, 0x65, 0xe0, 0x46, 0xc6, 0x6c, 0x08, 0xd6, 0x42, 0xb8, 0xc3,
0xad, 0xc7, 0x61, 0x27, 0x5d, 0x58, 0x1d, 0x7c, 0xc3, 0xcb, 0xb0, 0xc3, 0x5d,
0xde, 0x74, 0xa9, 0xdc, 0x5a, 0x46, 0x1d, 0x65, 0xd4, 0xd9, 0x86, 0x9e, 0x36,
0x1c, 0x97, 0xe1, 0x54, 0x42, 0xe9, 0xcf, 0xa5, 0xa1, 0x5c, 0x9e, 0x34, 0xd1,
0x50, 0x13, 0xe5, 0x59, 0xd1, 0xf8, 0xe2, 0xc1, 0x73, 0x47, 0xd7, 0x82, 0xff,
0xaf, 0xf6, 0x0f, 0x72, 0x8c, 0xf2, 0xe2, 0x18, 0x29, 0x90, 0xe7, 0xe2, 0x2c,
0x64, 0x7c, 0x69, 0xe4, 0xc5, 0x38, 0x33, 0x2c, 0x5f, 0x65, 0xbf, 0xd7, 0xf0,
0xdb, 0xcd, 0x57, 0x46, 0x38, 0x17, 0xc7, 0x66, 0x50, 0x7c, 0x06, 0xad, 0xbb,
0x71, 0xcb, 0x0d, 0xad, 0x15, 0xf7, 0x76, 0xdf, 0x18, 0xb8, 0x61, 0xb0, 0x8a,
0xac, 0xce, 0x8a, 0xbd, 0x70, 0x3a, 0x0c, 0x17, 0x6c, 0x6e, 0x85, 0x9e, 0x5b,
0x06, 0xc9, 0x56, 0xf4, 0x7f, 0xe1, 0x16, 0x9d, 0xe6, 0x5a, 0x01, 0xb3, 0x64,
0x06, 0x29, 0x22, 0xfb, 0x69, 0xe9, 0x99, 0x8d, 0x2b, 0xaa, 0xff, 0x43, 0x51,
0x25, 0x01, 0xf8, 0x0e, 0x3a, 0x9f, 0xb6, 0xc8, 0x26, 0xd2, 0xcd, 0x74, 0xca,
0xff, 0xcc, 0x72, 0x6e, 0x2e, 0x4d, 0xb4, 0x91, 0xab, 0x4d, 0xe2, 0x2d, 0x2b,
0xfe, 0x5d, 0x99, 0x1a, 0x4b, 0x9f, 0xfa, 0xff, 0x8b, 0x01, 0x2b, 0x42, 0xb2,
0xa9, 0xf6, 0x8b, 0x2e, 0x2b, 0x42, 0xcb, 0x11, 0x51, 0x8e, 0xd9, 0x2e, 0x5a,
0xe8, 0xa2, 0x31, 0x6e, 0xd2, 0x7c, 0xb1, 0x22, 0x9e, 0xc4, 0x73, 0x93, 0x56,
0x0c, 0x5b, 0x31, 0x2a, 0xba, 0xe9, 0xb4, 0xa2, 0xe7, 0x8e, 0xf5, 0x15, 0x59,
0x4b, 0xc7, 0x8f, 0x45, 0xcc, 0xf9, 0x4a, 0xc7, 0x7a, 0x3a, 0xd5, 0x73, 0xd1,
0x3c, 0x4c, 0x7d, 0xe9, 0x08, 0x2e, 0x97, 0xec, 0xa2, 0x43, 0xbe, 0x1c, 0xa1,
0xd4, 0x74, 0xc3, 0x9f, 0x17, 0xb9, 0xf9, 0xa2, 0x80, 0xc8, 0xc8, 0x46, 0x59,
0xe4, 0x30, 0x6e, 0x07, 0x42, 0x25, 0x62, 0x98, 0x27, 0x56, 0xa8, 0xce, 0x0d,
0x16, 0xaa, 0x2b, 0x45, 0x43, 0x29, 0x62, 0xcb, 0x11, 0x2f, 0x81, 0x52, 0xca,
0x91, 0x2e, 0x32, 0x69, 0xe5, 0xa8, 0x7c, 0xb7, 0xfb, 0x09, 0x13, 0xf7, 0xf4,
0x86, 0x4b, 0x31, 0x5a, 0x0a, 0x5f, 0x92, 0xbc, 0x8d, 0xd4, 0x6d, 0xa1, 0x77,
0x3b, 0x88, 0x2b, 0x87, 0x7c, 0x11, 0x5d, 0x59, 0x2f, 0xc5, 0xad, 0x52, 0xc8,
0xff, 0x7c, 0xc8, 0xc1, 0xd4, 0x13, 0x2c, 0x94, 0x42, 0x3b, 0x6d, 0x08, 0xcf,
0x7a, 0xa7, 0x14, 0xfb, 0x02, 0x4e, 0x27, 0xa5, 0x50, 0x95, 0xe1, 0xa8, 0x14,
0xa1, 0x66, 0x04, 0x4f, 0x73, 0x73, 0xb9, 0x87, 0xaa, 0x7a, 0xa4, 0x21, 0x1c,
0xe5, 0x90, 0x37, 0x47, 0xca, 0x65, 0xbb, 0x60, 0x92, 0xf4, 0xf7, 0x72, 0x07,
0xad, 0x9d, 0xbb, 0xd6, 0xe7, 0xa4, 0x65, 0xb7, 0xc2, 0x71, 0xbe, 0x18, 0x59,
0x07, 0xd8, 0xfe, 0xad, 0xf5, 0xd7, 0x44, 0x8b, 0x07, 0x58, 0x39, 0xe0, 0x86,
0xc7, 0x01, 0x4c, 0x3c, 0xa1, 0xec, 0x5d, 0x98, 0x24, 0x1e, 0xa5, 0xea, 0x00,
0xaa, 0x0d, 0x90, 0x91, 0x57, 0xad, 0xd8, 0x90, 0x1b, 0xae, 0xef, 0xc0, 0xf3,
0xbf, 0xec, 0x5a, 0xbf, 0xe5, 0xa3, 0x37, 0xda, 0xd0, 0x62, 0x03, 0x37, 0xe4,
0xee, 0xe1, 0xab, 0x10, 0x52, 0x48, 0x61, 0x85, 0x74, 0x74, 0x0c, 0xef, 0xb1,
0x70, 0x86, 0xca, 0x91, 0x2a, 0x16, 0x44, 0x32, 0x13, 0x77, 0x54, 0x94, 0xf1,
0xa0, 0x3e, 0x4e, 0xf6, 0xc6, 0x43, 0xb9, 0xfa, 0xb7, 0x89, 0xaa, 0x82, 0x21,
0xa4, 0xdd, 0xdf, 0x73, 0x11, 0xbd, 0xec, 0x8f, 0xa3, 0x82, 0xe7, 0x55, 0xdd,
0xdf, 0xf6, 0xb3, 0xb3, 0xec, 0xc8, 0xb1, 0x4b, 0xfa, 0x6f, 0x96, 0x32, 0x67,
0x79, 0x5a, 0x6c, 0x47, 0xa9, 0xfd, 0xd2, 0x60, 0x1a, 0xed, 0x68, 0x11, 0xe5,
0xa3, 0x1a, 0xf2, 0xd6, 0xdc, 0xdd, 0x56, 0x1b, 0x4c, 0xba, 0x60, 0x9f, 0x8c,
0x38, 0xc5, 0xfa, 0x95, 0xa8, 0x60, 0xb2, 0x77, 0xc0, 0xd1, 0x81, 0x62, 0x3f,
0x2a, 0xe5, 0x26, 0x62, 0x42, 0x3e, 0x25, 0x71, 0x19, 0x61, 0xaf, 0x21, 0x07,
0x6f, 0x59, 0xee, 0x82, 0xcd, 0x75, 0xde, 0x71, 0x7b, 0x2a, 0xba, 0x52, 0xb1,
0x33, 0x42, 0xfb, 0x23, 0x9c, 0x5c, 0xe6, 0x68, 0x44, 0xa6, 0xa0, 0xc5, 0x16,
0x5a, 0x69, 0xa1, 0xd6, 0x35, 0x74, 0xac, 0x49, 0xe1, 0xce, 0x06, 0xf8, 0xfd,
0x49, 0xc8, 0x95, 0x78, 0xbe, 0xb9, 0x7e, 0x0d, 0x48, 0x8c, 0x40, 0x6a, 0x0f,
0xad, 0xbb, 0x70, 0x8b, 0x77, 0xb3, 0xde, 0x40, 0xb7, 0x1a, 0x44, 0x93, 0x83,
0x54, 0xb0, 0xd3, 0x54, 0x04, 0x8d, 0x90, 0x7a, 0x84, 0xb8, 0x9d, 0xea, 0x87,
0xad, 0xbf, 0x8c, 0xe8, 0xa0, 0xf0, 0x56, 0x44, 0x3e, 0x3c, 0xfd, 0x9e, 0xb7,
0x96, 0xb2, 0xce, 0x90, 0xc3, 0x3d, 0xdc, 0x90, 0x1d, 0x84, 0xed, 0x80, 0xb6,
0x5c, 0xa8, 0x7b, 0x3d, 0xf7, 0xbe, 0xa9, 0x87, 0xf8, 0x3e, 0x6f, 0x15, 0x61,
0x5f, 0x72, 0x45, 0x8e, 0x8a, 0x11, 0x7b, 0x9f, 0xc6, 0x81, 0xe1, 0x79, 0x8c,
0x72, 0x19, 0x5d, 0x17, 0x4d, 0xc5, 0x57, 0xeb, 0x9e, 0x2b, 0xed, 0xa4, 0xe1,
0x4e, 0x1a, 0xe5, 0xa2, 0x20, 0xb1, 0x80, 0xda, 0xde, 0x1f, 0xea, 0x44, 0x5e,
0x34, 0x99, 0xa3, 0xf9, 0x64, 0x17, 0xb8, 0x08, 0x47, 0x61, 0x20, 0xba, 0x5e,
0x5c, 0x7a, 0x35, 0xd8, 0x82, 0x10, 0xae, 0x2e, 0x65, 0xbf, 0xae, 0x73, 0x90,
0x7a, 0x06, 0x69, 0x3d, 0x80, 0x6e, 0xf1, 0x6d, 0xce, 0x5e, 0x21, 0xd3, 0xca,
0x5d, 0x0b, 0xb6, 0xac, 0xa3, 0x7b, 0xdc, 0x3a, 0x2a, 0xd4, 0x93, 0x45, 0x4f,
0x7b, 0x95, 0x64, 0x7a, 0xb1, 0x4f, 0x6c, 0x67, 0xab, 0x93, 0x3a, 0x9c, 0x22,
0x48, 0x17, 0x8b, 0xac, 0x5f, 0xe5, 0xfc, 0xea, 0xe8, 0xfd, 0xc9, 0x1d, 0xec,
0x74, 0x61, 0xf1, 0x37, 0x43, 0x4f, 0xaa, 0xd3, 0xa9, 0x5c, 0x4d, 0x36, 0x2e,
0x24, 0x16, 0x63, 0xb1, 0x12, 0x2b, 0x1e, 0xd2, 0xdb, 0x47, 0xfe, 0xd7, 0xfb,
0xb8, 0x1f, 0xb4, 0x39, 0x8f, 0xb6, 0xbf, 0x34, 0x69, 0x11, 0x69, 0x20, 0x8d,
0x41, 0x74, 0x9f, 0xa7, 0x85, 0x59, 0x2b, 0x91, 0x75, 0x2c, 0x37, 0x28, 0x92,
0x3f, 0xec, 0xd9, 0x85, 0x82, 0x3b, 0x33, 0xfb, 0x36, 0x50, 0x17, 0x39, 0x78,
0x4d, 0xbb, 0x9e, 0xe2, 0x43, 0x50, 0xc1, 0x73, 0x76, 0x2d, 0x1c, 0x5a, 0x79,
0x33, 0x22, 0x53, 0x88, 0xfb, 0x0c, 0x63, 0x1a, 0x9a, 0xd4, 0x70, 0xb7, 0x5b,
0x8b, 0x36, 0x1f, 0x9c, 0xec, 0x89, 0xe4, 0x10, 0x41, 0x9e, 0x55, 0x2d, 0x3a,
0x3f, 0xb7, 0xf9, 0x49, 0xee, 0xac, 0x95, 0xea, 0xee, 0x6f, 0x29, 0x43, 0xc6,
0x3b, 0x9d, 0x57, 0xc7, 0xb7, 0x40, 0xcb, 0x5a, 0xfc, 0xb3, 0x49, 0x2d, 0x6e,
0xcf, 0x62, 0x7b, 0x16, 0xab, 0xe5, 0x14, 0x6c, 0xc4, 0x92, 0xdc, 0x9c, 0x37,
0xda, 0xd0, 0x22, 0x37, 0x8f, 0xf2, 0xf3, 0xf8, 0xd6, 0xcf, 0xc2, 0x36, 0x2b,
0x18, 0xb4, 0x8a, 0xd4, 0x55, 0x97, 0x17, 0x24, 0x34, 0x06, 0x11, 0x31, 0xf0,
0x9b, 0x45, 0xa0, 0xa8, 0x9e, 0xea, 0xc6, 0x4c, 0x37, 0x8e, 0x76, 0xe1, 0xdd,
0x45, 0xf5, 0x1e, 0x6e, 0x3f, 0x1d, 0xa6, 0x01, 0x8d, 0x65, 0xc1, 0x95, 0x85,
0xef, 0xeb, 0x62, 0x40, 0x09, 0x31, 0x48, 0x8a, 0x11, 0xbd, 0xcb, 0x99, 0xb8,
0x18, 0xe8, 0xa5, 0x22, 0xf7, 0x3f, 0x4a, 0xc5, 0x40, 0x03, 0x92, 0x28, 0x38,
0x89, 0x53, 0x6c, 0x09, 0x85, 0x3d, 0xed, 0x08, 0xe2, 0xe6, 0x46, 0x0c, 0x2c,
0x31, 0xa8, 0xe9, 0x27, 0x67, 0xbf, 0x10, 0x7d, 0x29, 0xe4, 0x4a, 0x39, 0xd7,
0x4e, 0x53, 0x88, 0x7f, 0xbd, 0x2b, 0x06, 0xed, 0x31, 0xe0, 0xff, 0x5b, 0x61,
0xb4, 0x1b, 0x26, 0xc1, 0x9b, 0x63, 0xd0, 0x26, 0xba, 0x1c, 0x8c, 0xc1, 0x88,
0xd4, 0x35, 0x87, 0x50, 0x5b, 0x0c, 0xd1, 0xd6, 0x1e, 0x74, 0x1f, 0xce, 0xc4,
0xdc, 0xe1, 0x8b, 0xdb, 0x31, 0xd8, 0x96, 0x8a, 0x29, 0xb5, 0x94, 0x7e, 0x11,
0x55, 0x09, 0xd0, 0x21, 0x58, 0x27, 0x69, 0x61, 0x1d, 0xe2, 0x79, 0x26, 0xc5,
0x4c, 0xe9, 0xe6, 0x8b, 0x36, 0xc3, 0x33, 0xa8, 0x78, 0x23, 0xee, 0xcb, 0xd4,
0x2f, 0xb9, 0xc5, 0x4a, 0x89, 0x3a, 0x18, 0x24, 0xd4, 0x9a, 0x75, 0x38, 0xd7,
0xbf, 0x1d, 0xa1, 0x1b, 0x4c, 0xa7, 0x91, 0xf4, 0x3b, 0x79, 0x6f, 0x38, 0xc6,
0x75, 0x77, 0x63, 0xed, 0xe9, 0x70, 0xa8, 0xf3, 0xf9, 0x8a, 0x47, 0x3a, 0x14,
0xbc, 0x67, 0xda, 0x42, 0x86, 0x0a, 0x46, 0x15, 0x44, 0xd1, 0x2b, 0x63, 0x47,
0xc6, 0x41, 0x13, 0xc7, 0x8d, 0x70, 0x07, 0xc5, 0x3f, 0xd7, 0x15, 0xea, 0x53,
0xff, 0x35, 0xe4, 0xe4, 0x0c, 0x19, 0xb4, 0x05, 0xb5, 0x1c, 0xd5, 0xcc, 0x8e,
0x83, 0x29, 0x0e, 0xf2, 0x7f, 0x4a, 0x1c, 0xd2, 0xe3, 0x90, 0x1c, 0x87, 0xd4,
0x38, 0x21, 0x72, 0xe3, 0x90, 0x29, 0xd2, 0x92, 0x38, 0xac, 0x37, 0x22, 0x7d,
0x4c, 0x64, 0xac, 0x1c, 0x50, 0x1c, 0x87, 0x52, 0x9e, 0x24, 0xa7, 0x50, 0x6a,
0x0a, 0xb5, 0xc6, 0xa1, 0x23, 0x4e, 0xea, 0xa8, 0x31, 0x0e, 0x2d, 0x71, 0xf8,
0xee, 0x88, 0xde, 0x72, 0x1c, 0xd6, 0xee, 0xaa, 0x3b, 0x8e, 0x03, 0x54, 0xf1,
0xf8, 0x9d, 0x21, 0xc0, 0xc2, 0x78, 0x58, 0xe2, 0xb1, 0xda, 0x8e, 0x8d, 0x76,
0x6e, 0x08, 0xc5, 0xc3, 0x7a, 0x81, 0x5b, 0x17, 0x8f, 0x86, 0xf8, 0x6f, 0xea,
0xf8, 0xe5, 0x41, 0xe8, 0x5e, 0x1c, 0x49, 0xc0, 0x60, 0x02, 0xe7, 0x08, 0x6c,
0xbf, 0xbd, 0x3d, 0x8d, 0xc5, 0x41, 0x4c, 0x87, 0x23, 0xe6, 0xbd, 0x91, 0x4f,
0x0b, 0x5f, 0x58, 0x65, 0x37, 0x1f, 0xe9, 0x73, 0x63, 0x2f, 0x8b, 0x0e, 0xb3,
0xb8, 0x4a, 0x4b, 0x40, 0xbd, 0x09, 0x07, 0xf7, 0x96, 0x5a, 0xb1, 0x7c, 0xa3,
0x8b, 0x5b, 0x04, 0x37, 0xdb, 0x68, 0xfc, 0x51, 0x95, 0x89, 0x5a, 0xfb, 0xd0,
0xd1, 0xc7, 0xbb, 0xec, 0x0e, 0xa1, 0xe0, 0xcf, 0x3a, 0xb8, 0x6b, 0x93, 0x00,
0x77, 0x02, 0x6a, 0x06, 0xc9, 0x29, 0xe2, 0x06, 0x34, 0x1f, 0x4d, 0x4b, 0x5c,
0x02, 0xb4, 0xa7, 0x51, 0x57, 0x1a, 0xdf, 0x17, 0x03, 0x96, 0xfd, 0x51, 0x9b,
0x46, 0xf5, 0x9c, 0xe3, 0xff, 0x2a, 0xf2, 0xe5, 0x85, 0x49, 0x4c, 0xcf, 0xa3,
0xe0, 0xf1, 0xce, 0x4f, 0xc6, 0xdd, 0x94, 0x11, 0x48, 0xb6, 0xab, 0x1b, 0x9c,
0xbf, 0x37, 0x5b, 0xc9, 0xdd, 0xca, 0xdb, 0x4e, 0x19, 0x30, 0x63, 0xc0, 0xac,
0x01, 0x0b, 0x06, 0x24, 0x0c, 0xc1, 0xef, 0xab, 0xa4, 0x5f, 0x1d, 0xab, 0xa0,
0xf9, 0x65, 0xc5, 0x03, 0xed, 0x81, 0x48, 0xfd, 0x68, 0x41, 0x4d, 0x27, 0xf3,
0x14, 0xff, 0x6e, 0xe7, 0x93, 0x93, 0x3f, 0xeb, 0xbf, 0xde, 0xf6, 0xe9, 0x72,
0x2e, 0xba, 0x9a, 0x84, 0x87, 0x22, 0xfc, 0xf4, 0xd3, 0x2e, 0x69, 0x45, 0x66,
0x60, 0xe1, 0x96, 0x59, 0x6c, 0x3b, 0xf9, 0xff, 0x72, 0xf8, 0xca, 0xe0, 0x1b,
0xb5, 0x4e, 0xda, 0x31, 0xa0, 0xec, 0xcb, 0x7c, 0x11, 0x15, 0x8f, 0xb4, 0xd2,
0xe6, 0xf3, 0x7d, 0x1f, 0x17, 0x05, 0x72, 0x41, 0xe2, 0xa4, 0x05, 0x27, 0x2d,
0x3a, 0x69, 0xe3, 0xdd, 0xea, 0x17, 0xcf, 0xae, 0xd9, 0x24, 0x7b, 0xf3, 0x8c,
0xcb, 0x0d, 0xc1, 0x07, 0x07, 0x46, 0xf2, 0x1a, 0x29, 0xab, 0x9d, 0x56, 0x3e,
0xae, 0x9d, 0xbd, 0x58, 0xfd, 0x61, 0x1d, 0x4d, 0xdd, 0x17, 0xf4, 0xaa, 0x63,
0x85, 0xb6, 0xba, 0x68, 0x97, 0x3f, 0x2d, 0x23, 0x05, 0x8b, 0xd1, 0xe0, 0x4a,
0x87, 0x6a, 0xa6, 0xe0, 0x9c, 0x92, 0xed, 0xf7, 0x14, 0x58, 0xb8, 0x05, 0x97,
0x82, 0xa2, 0x73, 0x7b, 0x70, 0x79, 0x86, 0xc6, 0xaf, 0x4c, 0xbe, 0x3d, 0xf9,
0xd0, 0xf2, 0xe7, 0xce, 0x29, 0xee, 0xad, 0x84, 0x52, 0x58, 0x28, 0x1d, 0x0c,
0x91, 0x67, 0x88, 0x3f, 0x28, 0x82, 0x3c, 0x11, 0xb4, 0x5e, 0x43, 0xb7, 0x38,
0xb1, 0xb5, 0x1f, 0x61, 0xe1, 0xf1, 0x15, 0xc9, 0x35, 0x0b, 0xdf, 0x46, 0xd4,
0x36, 0x52, 0x22, 0x29, 0x9d, 0xbb, 0xee, 0x53, 0xa3, 0x54, 0x55, 0x87, 0xf5,
0x5c, 0xc4, 0xd4, 0xd3, 0xd8, 0x22, 0x4d, 0x2e, 0x52, 0x65, 0x24, 0x55, 0x45,
0x52, 0x6e, 0x22, 0x36, 0xbb, 0xa0, 0x5f, 0x92, 0x94, 0x85, 0x1d, 0x5d, 0x76,
0x0c, 0x2e, 0x22, 0xec, 0x69, 0x9e, 0x66, 0xac, 0xc1, 0x28, 0x69, 0x87, 0x7e,
0x3b, 0x86, 0x24, 0x4d, 0x35, 0x61, 0x27, 0x97, 0x5d, 0x24, 0x70, 0x89, 0x72,
0x6e, 0x18, 0xa5, 0xff, 0xc8, 0xfe, 0x75, 0x7c, 0x1b, 0xb4, 0x81, 0x38, 0xbb,
0x9e, 0xf9, 0xf2, 0xd9, 0x1f, 0x57, 0x5e, 0x37, 0xfe, 0x30, 0xf4, 0x4d, 0xc7,
0x2a, 0x7f, 0x9e, 0x9d, 0x66, 0x38, 0x6e, 0x74, 0x1c, 0xb9, 0x1e, 0x38, 0xf9,
0xe9, 0xdc, 0x2b, 0x7d, 0x47, 0x5c, 0xae, 0x84, 0xd1, 0xd6, 0xb5, 0x91, 0xaf,
0xa7, 0x6f, 0x08, 0x45, 0x43, 0x69, 0x2e, 0x64, 0x0a, 0x3d, 0x55, 0x93, 0x02,
0xa7, 0x34, 0xcd, 0xca, 0x50, 0xaa, 0x0a, 0xa5, 0x8c, 0x53, 0xec, 0x3d, 0xc5,
0xd5, 0x59, 0x73, 0x0a, 0xda, 0x52, 0x90, 0x92, 0x4f, 0xa3, 0x11, 0x22, 0xe3,
0x53, 0x92, 0x29, 0x18, 0xfe, 0xc0, 0x70, 0x8a, 0xea, 0x28, 0xaa, 0x3d, 0xb7,
0x81, 0xb5, 0x6b, 0x48, 0xfd, 0xe9, 0xbe, 0x30, 0x46, 0x68, 0x67, 0x11, 0xfb,
0x8b, 0x38, 0x0a, 0xa2, 0xad, 0x07, 0x6e, 0xc9, 0x61, 0xf3, 0xb3, 0x22, 0xf8,
0x0b, 0xd5, 0x13, 0x5d, 0x0c, 0x45, 0x14, 0xcf, 0x44, 0x16, 0xe3, 0xfb, 0xc1,
0x3c, 0x0d, 0x5f, 0xa3, 0xa8, 0x35, 0xd2, 0x16, 0x23, 0x23, 0x0b, 0x39, 0x59,
0x9c, 0xb9, 0xd7, 0x8b, 0x71, 0xab, 0x18, 0x6a, 0x49, 0x4d, 0x51, 0x38, 0xc7,
0x0a, 0x94, 0xb3, 0x37, 0x6f, 0x61, 0xf2, 0x36, 0x62, 0x2d, 0x40, 0xec, 0x6f,
0xcd, 0xe2, 0x78, 0x28, 0xc1, 0x82, 0x24, 0xae, 0x8a, 0x16, 0x10, 0xb6, 0x80,
0x6c, 0x0b, 0x4c, 0x16, 0x70, 0x48, 0x48, 0x13, 0x32, 0x77, 0x05, 0x7a, 0x81,
0x05, 0x45, 0x16, 0x64, 0x55, 0x52, 0x4e, 0x25, 0xc9, 0xb5, 0xe7, 0xc9, 0x9d,
0x5a, 0x39, 0xe8, 0x67, 0x41, 0xad, 0x2f, 0x5b, 0x3e, 0x09, 0xdb, 0xa4, 0x6f,
0x82, 0xbd, 0x87, 0x18, 0xe0, 0xf6, 0xf2, 0x4d, 0x0b, 0x14, 0xf3, 0xbf, 0xa9,
0x32, 0xd3, 0xc9, 0x04, 0xa9, 0x26, 0x69, 0x71, 0x19, 0x2b, 0xcb, 0x5c, 0x5f,
0xea, 0xa9, 0x81, 0x5b, 0x7d, 0xb1, 0xa3, 0x14, 0x3f, 0x7a, 0x49, 0x3c, 0x55,
0xd3, 0x61, 0xb5, 0x7c, 0x9c, 0x73, 0xc6, 0x7b, 0x54, 0x95, 0x70, 0x6b, 0xd0,
0x82, 0xba, 0x4a, 0xd8, 0x7c, 0x4a, 0xb1, 0xc6, 0x40, 0x4e, 0x49, 0x6f, 0xd1,
0xd4, 0x02, 0xcd, 0x2c, 0x50, 0xc2, 0x16, 0x92, 0x24, 0x79, 0x14, 0x5b, 0x82,
0x78, 0x8e, 0x9d, 0x5c, 0x82, 0x54, 0x39, 0x22, 0x9a, 0x5b, 0x82, 0xfc, 0x12,
0x14, 0x96, 0x00, 0xa5, 0x25, 0x28, 0xdf, 0x22, 0xdb, 0x96, 0xd0, 0xb5, 0xb3,
0xd0, 0x3f, 0x5b, 0x21, 0x23, 0x14, 0x97, 0x88, 0x9a, 0xf3, 0x38, 0x4a, 0x09,
0x58, 0xd3, 0x45, 0x69, 0xeb, 0xab, 0xdd, 0xaf, 0xb8, 0x4a, 0x00, 0x2a, 0x3f,
0x51, 0x25, 0x5d, 0xf6, 0x72, 0x4a, 0xe0, 0xe6, 0x48, 0xcb, 0x25, 0x58, 0x2b,
0xc1, 0x62, 0x09, 0x56, 0x4a, 0x2e, 0x49, 0xa2, 0x9d, 0x12, 0xec, 0x97, 0xe0,
0xb8, 0x04, 0x57, 0x82, 0xb9, 0x9d, 0x18, 0x50, 0x8a, 0x60, 0xc9, 0x5c, 0x3c,
0x2b, 0x81, 0x7f, 0xe9, 0x5d, 0x02, 0x2b, 0xa1, 0x14, 0x49, 0xa5, 0xdf, 0x2d,
0xc2, 0xea, 0x4b, 0xd1, 0x24, 0xaa, 0x9a, 0x4b, 0xd1, 0x26, 0xd2, 0xc0, 0xef,
0x46, 0xbb, 0xe3, 0x66, 0x5c, 0x98, 0xd4, 0x56, 0x68, 0xce, 0xcd, 0xc1, 0x68,
0x3f, 0x8a, 0xf1, 0xbb, 0x0b, 0x5f, 0xf6, 0x08, 0x53, 0x56, 0x69, 0x4d, 0x8d,
0x0a, 0x2e, 0x0c, 0x22, 0xf7, 0x70, 0xf6, 0x6b, 0xcd, 0x26, 0x67, 0xce, 0x61,
0x4a, 0xfd, 0x2f, 0x83, 0x2f, 0x0f, 0x3f, 0x36, 0xfd, 0xa0, 0x61, 0x98, 0xda,
0x55, 0xd4, 0xa5, 0xe2, 0xc4, 0xec, 0xa6, 0x86, 0x2c, 0xcc, 0x75, 0x21, 0xbc,
0x9d, 0x8a, 0xde, 0xd5, 0x3e, 0xb2, 0xf7, 0xe9, 0xca, 0x21, 0x97, 0xf7, 0x5e,
0x98, 0xe4, 0xf0, 0x73, 0xeb, 0x10, 0xd6, 0x3f, 0xaf, 0xe0, 0x62, 0x66, 0x73,
0x97, 0xbc, 0x1f, 0xe6, 0x7e, 0x60, 0xd8, 0xa2, 0xe6, 0x48, 0x3a, 0x78, 0x93,
0x33, 0x73, 0xbb, 0x96, 0xba, 0x44, 0x5c, 0x78, 0xf8, 0x04, 0xa3, 0x27, 0x5c,
0xe2, 0xdb, 0x30, 0xf1, 0xf4, 0xdc, 0xd3, 0x66, 0x9b, 0x94, 0xdd, 0xfa, 0x6c,
0xf7, 0x11, 0x8b, 0x9a, 0x1a, 0xcb, 0x49, 0xf3, 0x77, 0x05, 0x4f, 0x2e, 0x6b,
0x90, 0xaf, 0x41, 0x7f, 0x00, 0xb6, 0x17, 0xce, 0x87, 0xd9, 0xbc, 0x42, 0x03,
0xc1, 0xd8, 0x97, 0x05, 0xcc, 0xec, 0x09, 0xce, 0xfe, 0xeb, 0x02, 0x7f, 0x70,
0xa7, 0x0d, 0x3d, 0x36, 0x99, 0x94, 0x2b, 0x70, 0x5c, 0x89, 0xb0, 0x5b, 0x9c,
0x92, 0x39, 0x20, 0xf1, 0xff, 0xde, 0x2e, 0x94, 0xcc, 0xc8, 0x42, 0xca, 0x2c,
0xa4, 0x84, 0x0a, 0xf4, 0xe7, 0x60, 0x63, 0xd2, 0x67, 0x2a, 0x76, 0x53, 0xd7,
0xb9, 0xe1, 0x5a, 0x5c, 0x81, 0xde, 0x2f, 0xfd, 0x65, 0xbf, 0xb3, 0xb2, 0x02,
0x55, 0x15, 0xdc, 0x92, 0xa9, 0x80, 0x83, 0x27, 0xd5, 0x15, 0x58, 0x2d, 0x83,
0x69, 0xed, 0x1b, 0xab, 0x1b, 0x3b, 0x4e, 0x2b, 0xcf, 0x67, 0x5f, 0x19, 0xca,
0xa3, 0xf9, 0x6d, 0x5a, 0xda, 0xa6, 0x20, 0x0f, 0xd4, 0x1e, 0xec, 0xa5, 0xa0,
0x98, 0x53, 0xff, 0x07, 0x3f, 0xce, 0xb9, 0x85, 0xe5, 0x61, 0x1a, 0xcd, 0x42,
0x8c, 0xd8, 0xa1, 0x61, 0x17, 0x46, 0x5d, 0x98, 0x4a, 0xa1, 0x92, 0x77, 0x63,
0xf6, 0x79, 0x71, 0x8d, 0x6a, 0x6d, 0xf2, 0xf6, 0x4e, 0x1c, 0x21, 0xe4, 0x7f,
0x6a, 0x52, 0x21, 0xb3, 0x14, 0x27, 0x35, 0xa4, 0x7e, 0x33, 0xe5, 0xd7, 0xfb,
0x65, 0xe8, 0x2d, 0x83, 0x7b, 0x91, 0x56, 0x0b, 0x69, 0xfa, 0xa9, 0xae, 0x31,
0x5a, 0x1d, 0xa7, 0x8d, 0x71, 0xca, 0xc8, 0xa1, 0x90, 0x17, 0xc2, 0xcc, 0x02,
0x51, 0x18, 0x64, 0xa5, 0x88, 0xb3, 0x60, 0x2e, 0x10, 0x33, 0xb2, 0xfc, 0x8c,
0x0e, 0xa1, 0x98, 0x10, 0xf9, 0x14, 0xba, 0x14, 0x15, 0xa5, 0xb0, 0x97, 0xa2,
0xec, 0xfd, 0xc8, 0x7f, 0xa9, 0x7e, 0xcb, 0xf6, 0x62, 0xad, 0xd4, 0x40, 0x76,
0x7c, 0xee, 0x28, 0xb6, 0x5c, 0x1b, 0x75, 0xb2, 0xfd, 0x6a, 0xdf, 0xa1, 0x65,
0x19, 0x30, 0xad, 0x46, 0xad, 0x83, 0x8b, 0xd6, 0x4a, 0xf2, 0x54, 0x4a, 0xfa,
0xa8, 0x0c, 0x4b, 0x77, 0x51, 0xcf, 0x51, 0x19, 0xbc, 0xdc, 0xa3, 0x91, 0xfe,
0xcf, 0x61, 0x95, 0x7d, 0xa8, 0xea, 0x43, 0xd6, 0x21, 0x66, 0xef, 0x57, 0x73,
0x13, 0xe0, 0xa4, 0x8d, 0x54, 0xc2, 0x0b, 0xea, 0x6e, 0x42, 0xf5, 0xf5, 0xbd,
0x0f, 0x5b, 0xbe, 0xa8, 0x7f, 0x6c, 0xfe, 0x99, 0xb4, 0x7b, 0xfc, 0xf3, 0x84,
0x4c, 0x6d, 0xc2, 0x50, 0x13, 0x0a, 0x0f, 0xa9, 0xa8, 0x12, 0xfe, 0xf5, 0x90,
0x4c, 0xd6, 0x35, 0x1d, 0xf9, 0xd5, 0x23, 0xb0, 0x1e, 0xe1, 0x63, 0x14, 0x35,
0x46, 0x9b, 0x3b, 0x70, 0xef, 0x20, 0x6d, 0x8a, 0x22, 0x7e, 0x2f, 0x9e, 0x4b,
0x79, 0xbb, 0x9b, 0x1c, 0x6e, 0x21, 0x38, 0xf8, 0x86, 0xff, 0x76, 0x43, 0x3a,
0x2e, 0xec, 0xb5, 0xd0, 0xe1, 0x33, 0xb3, 0x6f, 0xd5, 0xf6, 0x53, 0xa2, 0x09,
0x48, 0x35, 0x71, 0x56, 0x36, 0x89, 0xa4, 0x46, 0x4d, 0x4e, 0x35, 0xa5, 0x18,
0x28, 0xdd, 0x70, 0x3e, 0xb2, 0x55, 0x4a, 0x7f, 0x2d, 0x29, 0x83, 0x0a, 0x4c,
0x28, 0x12, 0xa7, 0x85, 0x35, 0x91, 0x70, 0x46, 0x7e, 0x83, 0x4f, 0x6e, 0x9b,
0xb0, 0x6d, 0xc2, 0xfa, 0x28, 0xdd, 0xbe, 0xdf, 0xb5, 0x4a, 0xad, 0xe5, 0x42,
0xf0, 0x42, 0xe1, 0x96, 0x0e, 0x17, 0x0b, 0xf7, 0x60, 0x11, 0x11, 0xed, 0x23,
0x1b, 0x2a, 0x7f, 0x66, 0x3d, 0xc1, 0x4e, 0x28, 0xed, 0x87, 0x52, 0xc8, 0x11,
0xc2, 0xb8, 0x58, 0xaf, 0xdf, 0xa3, 0x1a, 0xe6, 0x7f, 0x44, 0x3b, 0x87, 0xb4,
0xff, 0xa6, 0x8a, 0xcf, 0x6e, 0x78, 0x15, 0xd9, 0x57, 0x4f, 0xb7, 0x90, 0x6d,
0x87, 0x49, 0x28, 0x8a, 0x3c, 0x3b, 0xcc, 0x76, 0x14, 0xef, 0xa1, 0x74, 0x0f,
0x7b, 0x5b, 0x34, 0x71, 0x65, 0xe8, 0x48, 0x98, 0x25, 0x6a, 0xf2, 0xfe, 0xb0,
0xe7, 0x19, 0xab, 0x1d, 0x01, 0x2d, 0xb4, 0xf5, 0xc7, 0x87, 0x1b, 0x54, 0x66,
0x47, 0x90, 0x01, 0x6a, 0x03, 0x26, 0xf4, 0x28, 0x7a, 0xc4, 0xf2, 0xb5, 0xe4,
0x1f, 0xa5, 0x9d, 0x20, 0x93, 0x93, 0x75, 0x28, 0xf9, 0x73, 0xd3, 0xd1, 0x6e,
0x87, 0xc3, 0x8e, 0xa3, 0x55, 0x52, 0xbf, 0x6c, 0xfb, 0x82, 0xe7, 0xa8, 0xda,
0x8e, 0x5a, 0x49, 0x37, 0x25, 0x6e, 0xc1, 0x20, 0x1b, 0x59, 0xd4, 0x6d, 0x47,
0x9f, 0x1d, 0x75, 0x1e, 0x34, 0x78, 0x20, 0x94, 0x57, 0xc8, 0xcf, 0x27, 0x7d,
0xde, 0x93, 0xac, 0xb9, 0x72, 0xd7, 0x28, 0x5f, 0xa2, 0xdf, 0x79, 0x3b, 0xb2,
0xf5, 0x88, 0x18, 0x90, 0xa5, 0xf0, 0x29, 0x6c, 0xaf, 0x45, 0x37, 0x41, 0x1f,
0x88, 0x43, 0x3e, 0xd5, 0xb3, 0x72, 0xf8, 0x73, 0x72, 0x2f, 0xeb, 0xa1, 0xe0,
0x67, 0x2d, 0xa9, 0xe4, 0x57, 0x81, 0x8a, 0x27, 0x91, 0xfc, 0xaf, 0x37, 0xc4,
0xa1, 0x4b, 0x68, 0x05, 0x5a, 0x9f, 0x0d, 0x78, 0xac, 0xe0, 0x4f, 0x02, 0xc5,
0x09, 0x5e, 0x77, 0x29, 0xfa, 0x38, 0x2d, 0x95, 0x2d, 0x21, 0xff, 0xd9, 0x08,
0xde, 0x84, 0x73, 0x5c, 0x14, 0x4f, 0xfa, 0xb7, 0x31, 0xb4, 0x2d, 0x95, 0xce,
0xc2, 0x11, 0xd5, 0x20, 0x32, 0xd7, 0x52, 0x39, 0x7c, 0x75, 0x9b, 0x36, 0xb6,
0x05, 0xc7, 0x14, 0x51, 0x7c, 0x11, 0x09, 0x1e, 0x4c, 0xe2, 0xd0, 0xad, 0x53,
0xec, 0x9e, 0x22, 0x72, 0x84, 0x96, 0xd2, 0x10, 0x67, 0x46, 0xfe, 0xb5, 0xed,
0x57, 0xea, 0x59, 0xe9, 0x7b, 0x8a, 0xab, 0x94, 0x53, 0x21, 0xce, 0x95, 0x63,
0x2b, 0x11, 0x5f, 0xc9, 0xed, 0xdc, 0x4a, 0x9c, 0x3c, 0xef, 0x7d, 0x3e, 0x93,
0x67, 0x8b, 0xcd, 0x54, 0x6a, 0xa6, 0x84, 0x75, 0xdc, 0x7e, 0x39, 0xe0, 0x8d,
0x28, 0xce, 0xf3, 0x25, 0x95, 0xb0, 0x56, 0xa2, 0xb0, 0x12, 0x41, 0x41, 0x48,
0x7a, 0xd2, 0xa0, 0xe3, 0x66, 0xd3, 0x06, 0x59, 0xca, 0x91, 0xc3, 0x91, 0xc9,
0xde, 0x47, 0xaa, 0x44, 0xd8, 0x5f, 0xeb, 0xb8, 0x76, 0xf8, 0x42, 0x8d, 0x51,
0x5c, 0x44, 0x28, 0x15, 0xe0, 0xe3, 0x2c, 0x3a, 0xcd, 0x92, 0xa6, 0xdf, 0x59,
0x89, 0x9e, 0x4a, 0x39, 0x0a, 0x33, 0x8f, 0xb0, 0x77, 0xf6, 0x23, 0xb8, 0x17,
0x53, 0x89, 0xae, 0x4a, 0x6c, 0x45, 0xa0, 0xfb, 0x4f, 0xc7, 0x3e, 0x30, 0xe8,
0xcf, 0x4d, 0x7a, 0x07, 0xcd, 0x39, 0xb8, 0xdb, 0x4b, 0x45, 0x9c, 0x28, 0xb3,
0x9a, 0x28, 0xa7, 0x89, 0xc2, 0x47, 0x29, 0x8a, 0x2b, 0xa4, 0xd8, 0x38, 0x92,
0xee, 0xaa, 0x44, 0x47, 0xe2, 0x1e, 0x3d, 0xa7, 0xae, 0xe4, 0x48, 0xa4, 0x4a,
0x44, 0x56, 0x3d, 0x44, 0x99, 0xad, 0x58, 0xfc, 0x5b, 0x7f, 0x2e, 0x28, 0xb3,
0x22, 0x11, 0xde, 0x89, 0xee, 0x6b, 0x43, 0xa5, 0x98, 0x2a, 0xc3, 0xe9, 0xbb,
0xb1, 0x3f, 0x4f, 0x9f, 0xa2, 0xbc, 0x20, 0xf2, 0x7b, 0xb4, 0x28, 0x5b, 0xb0,
0x0a, 0xf5, 0x71, 0x21, 0x19, 0xbb, 0x42, 0xf1, 0x2b, 0x14, 0xc0, 0x05, 0x96,
0x02, 0xdd, 0x5f, 0x25, 0xfd, 0xa6, 0xa2, 0x1c, 0x07, 0xbb, 0xf0, 0x70, 0x37,
0x8b, 0xca, 0xca, 0xd1, 0xfc, 0xb9, 0x57, 0x0a, 0xf6, 0xd4, 0x07, 0x51, 0x13,
0xf7, 0x3e, 0xaa, 0xcb, 0x31, 0x9f, 0x85, 0x4c, 0x29, 0xd6, 0xdb, 0x5c, 0x8e,
0x36, 0x5e, 0x1c, 0xa2, 0xa5, 0x21, 0x1a, 0x2c, 0xc7, 0x88, 0xf0, 0xd0, 0x6f,
0x96, 0xe3, 0xbe, 0x9e, 0x72, 0x0c, 0x97, 0x63, 0xb4, 0x1c, 0x75, 0x6a, 0x32,
0x3d, 0x20, 0x0e, 0xd2, 0x8b, 0x87, 0xa9, 0x74, 0x98, 0x4b, 0xe8, 0x2d, 0x70,
0x6b, 0xde, 0x6e, 0x21, 0x87, 0x85, 0x8b, 0xcf, 0x48, 0xdc, 0xfc, 0xdb, 0x81,
0xbf, 0x58, 0x2b, 0x47, 0xbb, 0x95, 0xba, 0xac, 0x34, 0x51, 0x8e, 0xe3, 0x56,
0x8c, 0x9f, 0x5c, 0x74, 0x65, 0xef, 0x27, 0x07, 0x37, 0xed, 0x56, 0xcb, 0x31,
0x56, 0x89, 0x96, 0xcd, 0x73, 0xce, 0x39, 0x33, 0x52, 0xd4, 0xe7, 0xbb, 0x02,
0x21, 0xa0, 0x83, 0xc2, 0xfe, 0x67, 0xaf, 0x7c, 0xe2, 0x7e, 0x3c, 0x44, 0xa7,
0x43, 0x42, 0x75, 0x69, 0x29, 0x89, 0xcb, 0xf7, 0xc8, 0x0a, 0x68, 0x2a, 0x20,
0x13, 0x47, 0x46, 0x30, 0x45, 0xbd, 0x15, 0x5f, 0x81, 0xb4, 0x30, 0x4a, 0x78,
0xbd, 0x6a, 0x58, 0x0e, 0x7f, 0x6c, 0xd2, 0xee, 0x63, 0xd9, 0xcf, 0xee, 0xb3,
0x85, 0x3d, 0x0a, 0x3f, 0xa5, 0x85, 0x56, 0x94, 0x35, 0xa2, 0xe2, 0xde, 0xa5,
0xfb, 0x37, 0xef, 0xb5, 0x70, 0x7b, 0xaa, 0x20, 0x88, 0xf4, 0x6f, 0xf2, 0x26,
0xeb, 0xc3, 0x74, 0x8b, 0x37, 0x38, 0xca, 0xa0, 0xe0, 0x47, 0xf7, 0x65, 0x8d,
0x95, 0x51, 0x81, 0xd8, 0x3a, 0xd8, 0xa4, 0x2b, 0xb7, 0xad, 0x51, 0xe8, 0x88,
0x42, 0xee, 0x1e, 0x9e, 0x1a, 0x11, 0xfc, 0xda, 0x1d, 0x85, 0xd9, 0x27, 0x0a,
0x5f, 0x99, 0x39, 0x92, 0xe3, 0xbc, 0x15, 0x68, 0xaa, 0x90, 0x0e, 0x0d, 0xf7,
0xe0, 0x91, 0x2e, 0x13, 0x24, 0xcf, 0x51, 0x4b, 0x01, 0x46, 0x39, 0x70, 0xb0,
0x02, 0x85, 0xc5, 0x08, 0x5c, 0xa2, 0xb1, 0x0a, 0x64, 0x45, 0x40, 0x25, 0xae,
0xad, 0x70, 0xd8, 0x48, 0xc5, 0x77, 0x68, 0xd3, 0x93, 0x6d, 0xa8, 0x76, 0x2e,
0xa4, 0xe7, 0xed, 0x1d, 0xda, 0xde, 0xa1, 0x70, 0x1b, 0xa2, 0x6c, 0x38, 0xba,
0x49, 0xde, 0x9b, 0x94, 0x90, 0x46, 0x49, 0xdc, 0x6a, 0xaf, 0x4b, 0xa3, 0x86,
0x34, 0xba, 0x3b, 0x12, 0xdb, 0xaa, 0x41, 0x87, 0x46, 0x34, 0x2d, 0xa8, 0xa6,
0x22, 0x49, 0xde, 0x1e, 0xdc, 0xa4, 0x9c, 0x6b, 0x43, 0x6d, 0xe7, 0x36, 0x45,
0x04, 0x39, 0xa5, 0xe5, 0x93, 0x35, 0xd8, 0x58, 0x1b, 0x4d, 0xb6, 0x7d, 0x87,
0x32, 0x8f, 0x54, 0x31, 0x8d, 0x8a, 0x91, 0xdf, 0x2e, 0x02, 0xe5, 0x88, 0xcf,
0x89, 0x0d, 0x2a, 0x3b, 0x7c, 0xf7, 0x0c, 0x4b, 0xb4, 0xb0, 0x6a, 0x2f, 0xc6,
0x9d, 0x66, 0x47, 0x81, 0x11, 0xc1, 0x5d, 0x92, 0xc3, 0x9d, 0x6b, 0x47, 0xfe,
0xa5, 0xa8, 0x4b, 0xb9, 0x1d, 0x36, 0x5f, 0x71, 0x78, 0x8a, 0x46, 0xc5, 0x05,
0xd1, 0xf5, 0x4d, 0xba, 0x25, 0xef, 0xec, 0x6c, 0x10, 0x2d, 0x04, 0x51, 0x77,
0x10, 0x1b, 0xd9, 0x81, 0x47, 0xee, 0xef, 0x4c, 0x8b, 0x89, 0x32, 0xb8, 0x9a,
0xb9, 0x79, 0x8b, 0x19, 0xfb, 0xb7, 0x96, 0x26, 0xb9, 0x94, 0x52, 0x4b, 0xef,
0x06, 0x25, 0x56, 0xc1, 0x50, 0x75, 0x81, 0xd8, 0x39, 0x82, 0x1e, 0xdf, 0x3d,
0x96, 0x89, 0x18, 0xb8, 0x62, 0xb0, 0xba, 0x48, 0x1b, 0x8b, 0xb4, 0x1c, 0x49,
0xfb, 0x7f, 0x73, 0xf6, 0x57, 0x13, 0x0f, 0x35, 0x5f, 0x6d, 0x78, 0x78, 0xe2,
0xf3, 0x98, 0xcf, 0x26, 0x5e, 0xf1, 0x70, 0x3a, 0x0b, 0xa9, 0xc2, 0xcd, 0x34,
0x6c, 0x54, 0x61, 0xf8, 0xed, 0xae, 0x6d, 0x84, 0x17, 0x91, 0x3e, 0x1a, 0xfb,
0x22, 0xe6, 0x7a, 0x90, 0x0a, 0x4f, 0x2a, 0xf6, 0x52, 0x21, 0x92, 0x1d, 0x9e,
0x1c, 0x4a, 0x91, 0xd8, 0xdc, 0x01, 0xca, 0x1f, 0xa0, 0xe3, 0x54, 0x9c, 0xa6,
0x62, 0xba, 0x96, 0xe6, 0x24, 0x77, 0x79, 0x76, 0x9f, 0x3e, 0x3b, 0xe4, 0xb4,
0x91, 0x38, 0x41, 0x86, 0x09, 0x99, 0xd2, 0xe2, 0x81, 0xce, 0x21, 0xec, 0xbe,
0x55, 0xf8, 0x89, 0xc5, 0x9f, 0xf1, 0x92, 0x49, 0xf8, 0x78, 0xab, 0x99, 0x7c,
0xe5, 0x41, 0xf9, 0xf1, 0xe8, 0x4d, 0xa5, 0xdd, 0x37, 0xb9, 0x3e, 0xe5, 0x86,
0x4f, 0xc4, 0x01, 0x68, 0xbd, 0x98, 0x42, 0xde, 0x1d, 0xb9, 0xbf, 0xe1, 0x4d,
0x57, 0xae, 0x70, 0x44, 0x62, 0x69, 0x2d, 0x96, 0xcf, 0xb4, 0x8b, 0x52, 0xbb,
0x7c, 0x93, 0x9a, 0xef, 0xa4, 0xa5, 0x4e, 0xbe, 0x80, 0xdc, 0x07, 0x7f, 0xd1,
0xe6, 0x46, 0x77, 0x1b, 0xf5, 0x7d, 0xd5, 0x7f, 0x23, 0xea, 0x47, 0x71, 0xff,
0xea, 0xe8, 0x2f, 0x53, 0xef, 0x4d, 0xbd, 0xa1, 0x37, 0x71, 0xa9, 0x11, 0xc2,
0xe6, 0x42, 0x18, 0x55, 0xaf, 0x53, 0xed, 0x3a, 0x57, 0x47, 0x65, 0x54, 0xc5,
0x45, 0x67, 0xfb, 0x6d, 0xea, 0xba, 0x4d, 0x91, 0xbb, 0x08, 0x50, 0x63, 0xf4,
0x31, 0x87, 0xb0, 0x69, 0xa7, 0xbc, 0x34, 0xe3, 0x95, 0x4c, 0xd5, 0x5e, 0xaa,
0x7b, 0x21, 0x5d, 0xcd, 0xe4, 0x2d, 0x54, 0xd1, 0xe2, 0x0f, 0x03, 0x9f, 0x0b,
0xdc, 0xc4, 0xac, 0x8e, 0xce, 0x7e, 0x11, 0xfc, 0x78, 0xd3, 0xbb, 0x49, 0xbb,
0xf0, 0x5b, 0xa5, 0x99, 0x9f, 0x18, 0x05, 0x65, 0x95, 0xf4, 0x61, 0xeb, 0x37,
0x87, 0xf7, 0x8e, 0x3c, 0x30, 0x6a, 0xa6, 0xe8, 0x29, 0x3a, 0x78, 0x22, 0x2c,
0x88, 0x51, 0x88, 0x95, 0xc2, 0x78, 0xe5, 0x6a, 0x19, 0x8d, 0xfe, 0xa1, 0x4e,
0xf2, 0x06, 0x12, 0x83, 0x98, 0x81, 0x57, 0x50, 0xfd, 0x2e, 0x35, 0xed, 0x4a,
0x31, 0x39, 0xca, 0xb1, 0x53, 0x6f, 0x1f, 0x4a, 0x7e, 0x92, 0xf1, 0xeb, 0x1c,
0x2f, 0xc5, 0x72, 0xe7, 0x9d, 0x2b, 0xfd, 0xc8, 0x0d, 0x8a, 0xd9, 0xa0, 0x04,
0x37, 0x32, 0x82, 0xb0, 0xf8, 0x7d, 0xf5, 0xab, 0x7f, 0x7d, 0x70, 0x7f, 0xcf,
0x57, 0xe3, 0x1c, 0x4b, 0xcd, 0x6c, 0x6f, 0xb7, 0x5e, 0x6b, 0x6a, 0xa2, 0xb1,
0x05, 0x9a, 0x5c, 0xa0, 0xee, 0x3e, 0x3a, 0xfc, 0x69, 0xec, 0xaf, 0x36, 0xd4,
0x6c, 0x55, 0x47, 0x51, 0x3f, 0x0b, 0x57, 0x61, 0xf2, 0xc3, 0xa2, 0x47, 0x42,
0x1f, 0x5f, 0x8c, 0x45, 0x1f, 0x1f, 0x78, 0xab, 0x8d, 0x3a, 0x6c, 0x7c, 0x92,
0xf5, 0xb4, 0xf8, 0x3f, 0x96, 0x8e, 0x52, 0xee, 0x09, 0x0e, 0x5e, 0xef, 0x7b,
0x60, 0xef, 0xf5, 0xf8, 0x50, 0x94, 0x72, 0x13, 0xbf, 0xb9, 0x9d, 0x2a, 0x9e,
0x34, 0xbd, 0x55, 0xfe, 0x58, 0xfa, 0x2e, 0x2a, 0x17, 0xa9, 0x6a, 0x91, 0xea,
0xf2, 0xe8, 0xf0, 0xde, 0x8e, 0x14, 0x5a, 0xed, 0x43, 0xe5, 0xd7, 0x46, 0xc9,
0x14, 0xab, 0x2e, 0xa1, 0xa5, 0x57, 0x36, 0x9f, 0x1b, 0x7b, 0x28, 0xdd, 0x4e,
0x47, 0x5e, 0x3a, 0x7c, 0x28, 0x70, 0x51, 0xe2, 0x92, 0x2d, 0xa8, 0xff, 0x43,
0xf4, 0x2a, 0xda, 0x42, 0xc5, 0xfa, 0xac, 0x76, 0xd1, 0x06, 0xdf, 0x8b, 0x7e,
0x3d, 0x0d, 0xe9, 0xe5, 0x50, 0x04, 0x69, 0x84, 0x1c, 0x6e, 0xdf, 0xc2, 0xec,
0x9b, 0x45, 0xf5, 0x54, 0xa8, 0xa5, 0x9b, 0x57, 0xf5, 0xf7, 0x97, 0x3f, 0x53,
0xff, 0x62, 0x97, 0x11, 0xcd, 0x8f, 0x1d, 0x7f, 0xd4, 0xca, 0x72, 0x38, 0xa9,
0x07, 0x85, 0x31, 0x75, 0x18, 0x5b, 0x2f, 0xa7, 0xf0, 0x57, 0x3c, 0x87, 0xc2,
0x18, 0xdf, 0x85, 0x38, 0xe3, 0x98, 0x4e, 0xc7, 0x5c, 0xba, 0x4c, 0xa3, 0x25,
0xfd, 0x58, 0xfe, 0x99, 0x21, 0x9e, 0xfb, 0x58, 0x71, 0xa4, 0x93, 0x22, 0x9f,
0xd9, 0x5a, 0xda, 0x78, 0xc9, 0xd1, 0x0f, 0x6d, 0x3c, 0xc5, 0xfd, 0x44, 0x1c,
0xe5, 0x9e, 0x6c, 0x42, 0x75, 0x0b, 0x8d, 0xfd, 0xc8, 0xb3, 0x61, 0xf2, 0x89,
0xda, 0x17, 0xeb, 0x1e, 0x88, 0xbb, 0x6e, 0xee, 0x97, 0xce, 0xcb, 0xfc, 0x99,
0xde, 0x9f, 0x9d, 0x9b, 0x4b, 0xed, 0xd4, 0xf6, 0xb4, 0x95, 0x5b, 0x7c, 0x63,
0xb4, 0xae, 0x08, 0xb9, 0x6e, 0xda, 0x17, 0x46, 0x66, 0x39, 0x95, 0x96, 0x53,
0x6f, 0x3f, 0x06, 0xfa, 0x85, 0xe9, 0xd7, 0x0f, 0xbe, 0x82, 0x6b, 0xbc, 0xe9,
0x72, 0x3f, 0x4f, 0x24, 0x2b, 0xcd, 0x43, 0x5d, 0x8f, 0xef, 0x73, 0x69, 0xb7,
0xd5, 0x8f, 0xc5, 0x8f, 0xc7, 0xed, 0x92, 0x6b, 0x1c, 0x45, 0x96, 0x28, 0x3a,
0xde, 0xa3, 0x53, 0x49, 0xde, 0x85, 0x6c, 0xd3, 0xe1, 0x9b, 0x9d, 0x6f, 0xcf,
0x65, 0xc1, 0xdb, 0x0f, 0xfb, 0x3e, 0x1c, 0xfb, 0x08, 0x1a, 0x40, 0xee, 0x6b,
0x29, 0x0f, 0xf5, 0x94, 0x50, 0x5d, 0x05, 0x35, 0x88, 0x5b, 0x49, 0xcb, 0xfe,
0xb4, 0xe6, 0x4f, 0x9b, 0xfd, 0xe4, 0xee, 0xf7, 0x0d, 0xc7, 0xde, 0x40, 0x8e,
0x06, 0x5a, 0x4e, 0xa2, 0xd0, 0x8f, 0x76, 0x4f, 0xa9, 0x66, 0x84, 0x9c, 0x23,
0x54, 0xde, 0x43, 0x93, 0xcf, 0x9b, 0xee, 0x9f, 0xfa, 0x32, 0xc6, 0x43, 0x69,
0x03, 0xf8, 0xc1, 0x83, 0x86, 0x01, 0x6c, 0x66, 0xc0, 0x9d, 0xc1, 0x6d, 0xff,
0x46, 0x5a, 0xf8, 0xc2, 0x3c, 0xc0, 0xd5, 0xf4, 0x36, 0x4a, 0x02, 0x91, 0x73,
0x40, 0xe1, 0xfe, 0x2c, 0x8a, 0xf3, 0xce, 0x00, 0x4c, 0x03, 0x88, 0x1d, 0x40,
0x3c, 0xaf, 0x13, 0x76, 0x64, 0xde, 0x20, 0xcc, 0x83, 0xc8, 0x1a, 0x44, 0xce,
0x20, 0xd7, 0x9f, 0x05, 0xd4, 0x55, 0x20, 0x0c, 0x84, 0xdb, 0x30, 0x3c, 0x12,
0xf9, 0xd9, 0xf6, 0x63, 0x7d, 0xc9, 0xd4, 0x1a, 0xc0, 0x3a, 0x02, 0xf8, 0xa2,
0x24, 0x07, 0x52, 0x6a, 0xe0, 0x79, 0x8c, 0x76, 0x10, 0x5d, 0x83, 0xe8, 0x1f,
0x44, 0xc1, 0xcb, 0x2a, 0x1d, 0x4d, 0x78, 0xc9, 0xe5, 0x95, 0xbd, 0xb5, 0x3e,
0x1a, 0x63, 0x55, 0x43, 0x97, 0x1c, 0xbe, 0xcd, 0x41, 0xb8, 0x07, 0xb1, 0xe8,
0xc5, 0x8a, 0x17, 0x21, 0x43, 0x08, 0x1b, 0xc2, 0xd6, 0x20, 0x76, 0x07, 0x25,
0x5b, 0xb0, 0x8b, 0x06, 0xba, 0xe8, 0x60, 0x10, 0x5b, 0xc5, 0xd8, 0x78, 0xc8,
0xfb, 0xc7, 0x81, 0xcd, 0x9c, 0x22, 0x46, 0x69, 0x48, 0x76, 0x14, 0x77, 0x06,
0xa1, 0xe4, 0x2d, 0x29, 0x3c, 0x88, 0x6d, 0x5f, 0x31, 0x9c, 0xf0, 0x0d, 0xe5,
0xc4, 0xf4, 0x97, 0x86, 0x3c, 0xdf, 0x35, 0x96, 0x21, 0xb4, 0xbf, 0x31, 0x90,
0x4e, 0x85, 0xdc, 0x5e, 0xd8, 0x20, 0xde, 0xb1, 0x52, 0x3a, 0xdb, 0x55, 0x44,
0x0e, 0x41, 0x33, 0x24, 0x1d, 0x5f, 0x52, 0x60, 0x0a, 0x35, 0x47, 0xb0, 0xa4,
0xfb, 0x8b, 0xbc, 0x17, 0x42, 0x35, 0x53, 0x96, 0x7f, 0x75, 0x91, 0xd4, 0x10,
0xc9, 0x25, 0x5b, 0x20, 0xeb, 0x09, 0x64, 0xb3, 0x19, 0x58, 0xc8, 0x40, 0xcd,
0x10, 0x9c, 0xbc, 0xdd, 0xbc, 0x89, 0xd2, 0x6f, 0x94, 0x70, 0xbd, 0x10, 0x82,
0x41, 0x7f, 0xd4, 0xaa, 0x59, 0x77, 0x0a, 0xf5, 0x9d, 0x47, 0x06, 0xc7, 0x86,
0x30, 0x39, 0x84, 0x9d, 0x0c, 0xda, 0xcf, 0x10, 0x13, 0x3b, 0x82, 0x5b, 0xd6,
0x51, 0xc3, 0x43, 0x18, 0x1d, 0x3a, 0x97, 0x97, 0x19, 0x27, 0x64, 0x3c, 0x21,
0x6d, 0x2d, 0xe9, 0x84, 0x28, 0x5b, 0x1d, 0xc2, 0xc6, 0xd0, 0x1d, 0x99, 0x7b,
0xec, 0xa4, 0x16, 0x52, 0x7d, 0x66, 0x1b, 0xf0, 0x81, 0x36, 0xdb, 0xc9, 0xdd,
0x4e, 0xd1, 0xc3, 0x48, 0x54, 0xc1, 0x3c, 0x4c, 0xd9, 0x15, 0x64, 0xaa, 0xb8,
0x13, 0x42, 0xf7, 0x67, 0x73, 0x37, 0x4a, 0xb9, 0xef, 0x53, 0x90, 0x49, 0xea,
0x9f, 0xe7, 0x0c, 0x83, 0x26, 0x06, 0xe0, 0x92, 0x9a, 0xb6, 0x6e, 0xa3, 0x63,
0x5b, 0x76, 0xd2, 0xfc, 0x59, 0x87, 0x44, 0xb1, 0xbe, 0xdb, 0x3c, 0x05, 0xa5,
0xd4, 0x79, 0x43, 0xfd, 0x7b, 0xdb, 0x27, 0xb4, 0xb9, 0x0d, 0xb7, 0x84, 0xb3,
0x53, 0x43, 0xfb, 0x35, 0x14, 0xca, 0x97, 0x32, 0x6c, 0x10, 0x41, 0x83, 0x50,
0x0f, 0x62, 0x7d, 0x89, 0x6e, 0x89, 0xf0, 0x49, 0xf8, 0x20, 0xa2, 0x06, 0x91,
0xd2, 0x43, 0xe9, 0x3d, 0xdc, 0xe8, 0xc8, 0xa7, 0xf1, 0xf3, 0x63, 0x3b, 0x7b,
0x30, 0x4b, 0xba, 0x91, 0x59, 0x4a, 0x69, 0x83, 0xc8, 0x1c, 0x44, 0x65, 0x29,
0x55, 0x49, 0x3a, 0x22, 0x97, 0x6f, 0xdd, 0x33, 0x15, 0x59, 0x32, 0xe1, 0x4c,
0x65, 0xd1, 0x8c, 0x30, 0xc4, 0xca, 0x87, 0x60, 0x1b, 0x82, 0x7d, 0x08, 0x8e,
0x21, 0x84, 0xab, 0x59, 0x94, 0x9a, 0xfd, 0xae, 0xa8, 0x5d, 0x81, 0x83, 0x8a,
0x1c, 0x17, 0xde, 0xc8, 0x10, 0xbc, 0x17, 0x4b, 0x93, 0xab, 0xa2, 0x7c, 0x95,
0x1c, 0x35, 0xb2, 0xd0, 0xda, 0x9d, 0x4b, 0x52, 0x5c, 0x3b, 0x16, 0x0c, 0xa3,
0x48, 0x3e, 0x00, 0x2d, 0x1c, 0x25, 0x0b, 0xa7, 0x8d, 0xca, 0x61, 0x84, 0x3f,
0xde, 0x22, 0x2d, 0x7d, 0x41, 0x1e, 0x4e, 0x59, 0x3d, 0xf7, 0x2d, 0x4d, 0x94,
0xe5, 0xc6, 0x6d, 0x15, 0xe2, 0xb7, 0x68, 0x70, 0x93, 0x46, 0x36, 0xc5, 0xe5,
0x43, 0xda, 0xfe, 0xca, 0xe7, 0xc9, 0x26, 0x6c, 0x52, 0x12, 0x07, 0xcd, 0x72,
0xaf, 0x55, 0x03, 0xbd, 0x1f, 0x37, 0x4d, 0x4f, 0x28, 0x9e, 0x53, 0x54, 0x6f,
0x13, 0x0d, 0x34, 0x51, 0xde, 0x18, 0x99, 0x85, 0x25, 0xd6, 0x9f, 0x8d, 0x9d,
0x75, 0xae, 0x71, 0x19, 0x15, 0x4c, 0x51, 0xd1, 0x14, 0xcd, 0x76, 0xd3, 0x42,
0x37, 0xb7, 0x08, 0x99, 0xf1, 0x8a, 0x47, 0x88, 0xe0, 0xbc, 0x2d, 0x4a, 0x7f,
0x25, 0x82, 0xdb, 0xbf, 0x19, 0x47, 0x64, 0x3c, 0x92, 0x02, 0xd9, 0xd9, 0x08,
0xb1, 0x62, 0x57, 0x34, 0x5e, 0x34, 0xd1, 0x8a, 0x89, 0x5b, 0x5f, 0xe4, 0x2a,
0xa7, 0x4d, 0x2f, 0xdc, 0xfc, 0xc1, 0x7e, 0x7b, 0x14, 0xb8, 0xf7, 0x4d, 0x33,
0x24, 0x91, 0xa4, 0x48, 0x03, 0xb7, 0xdc, 0x6f, 0x47, 0xc1, 0x14, 0xc9, 0xc4,
0xee, 0x22, 0xf7, 0x36, 0x46, 0xb4, 0x2c, 0x2f, 0x13, 0x66, 0x71, 0x33, 0xb8,
0xc0, 0x43, 0x45, 0x1e, 0x71, 0xff, 0x50, 0xd5, 0x43, 0x79, 0x7f, 0xa7, 0x8d,
0x43, 0x6d, 0x0c, 0xdf, 0x9c, 0x13, 0x6e, 0xd4, 0xc1, 0xd7, 0xbc, 0x7d, 0x8a,
0x12, 0x9f, 0x5c, 0x0a, 0x62, 0x83, 0xdb, 0x34, 0xb2, 0x4d, 0x75, 0xa7, 0x68,
0x38, 0x45, 0x59, 0x2a, 0x2a, 0x52, 0xa1, 0xf5, 0x90, 0xce, 0x43, 0x75, 0x39,
0x14, 0xf3, 0xa0, 0x25, 0xe6, 0xe2, 0x24, 0x7e, 0x9f, 0x3a, 0xb8, 0xf0, 0x1a,
0xcb, 0x44, 0xa2, 0x1a, 0xfb, 0x62, 0x8b, 0xb3, 0x6a, 0x29, 0xa7, 0x96, 0x26,
0x32, 0x81, 0xd5, 0x5c, 0xac, 0xe4, 0x62, 0x4e, 0xba, 0x91, 0x3c, 0xa1, 0x25,
0xcf, 0xdf, 0x2c, 0x64, 0x62, 0x36, 0x13, 0x05, 0x6f, 0x6b, 0xf6, 0x39, 0x37,
0x64, 0x62, 0x49, 0xd4, 0x2c, 0x67, 0x22, 0x23, 0x01, 0x11, 0x17, 0xe1, 0xf9,
0xf2, 0x24, 0xb2, 0x25, 0xd1, 0xfc, 0x1c, 0x2d, 0xcd, 0x09, 0x5f, 0x82, 0x6e,
0xbe, 0xe1, 0x7c, 0x7c, 0xe9, 0xfd, 0xbc, 0x2b, 0x66, 0x7f, 0xce, 0x65, 0xd1,
0x74, 0x44, 0x51, 0x1f, 0x73, 0x8f, 0xc3, 0x89, 0xf8, 0x0d, 0xe9, 0x18, 0xc9,
0x4c, 0x07, 0x7f, 0x9a, 0x7a, 0x93, 0x4b, 0xd7, 0x34, 0xd2, 0xcb, 0x57, 0x8e,
0x63, 0xcd, 0x88, 0x37, 0x23, 0x43, 0xc7, 0xd4, 0x2b, 0x30, 0x98, 0x41, 0xbd,
0x43, 0x34, 0x20, 0xec, 0xce, 0x3c, 0x33, 0xcc, 0x66, 0xe4, 0x86, 0xb3, 0xfc,
0x70, 0x56, 0xde, 0x4a, 0x29, 0x8f, 0x8e, 0x2c, 0x0b, 0xae, 0x09, 0xa7, 0xe6,
0x6b, 0xf1, 0x9f, 0x17, 0x89, 0x6b, 0x52, 0x95, 0x66, 0x54, 0x89, 0xb4, 0xd8,
0x8c, 0x52, 0x33, 0xf2, 0x74, 0x34, 0x7a, 0xef, 0x90, 0x74, 0xd9, 0x41, 0x66,
0xe6, 0xba, 0x36, 0x9a, 0x7b, 0x6b, 0xe6, 0x00, 0x17, 0x24, 0x25, 0xbf, 0x64,
0xd0, 0x68, 0x46, 0x0b, 0x6f, 0xd5, 0x6e, 0x86, 0x52, 0xdc, 0x04, 0x91, 0x34,
0x8e, 0x17, 0x1a, 0x2f, 0xca, 0xf5, 0x64, 0xe3, 0x0a, 0xa8, 0xd3, 0x8c, 0x1e,
0x33, 0x5a, 0x57, 0xa8, 0xe3, 0xfc, 0x50, 0xe6, 0x64, 0x9a, 0x4c, 0xcf, 0x8c,
0x72, 0x42, 0x9c, 0x32, 0x63, 0xc6, 0x2c, 0xae, 0xe0, 0x51, 0xd8, 0x1f, 0xe8,
0x3f, 0x3d, 0x78, 0xe7, 0xf4, 0x1d, 0x85, 0xcb, 0x0c, 0x45, 0x76, 0x3a, 0x99,
0xa4, 0x10, 0xbc, 0x7c, 0xd9, 0x77, 0xd3, 0x0c, 0xb7, 0x59, 0x1c, 0xc9, 0x8b,
0x9b, 0x31, 0x83, 0x2b, 0x34, 0xb2, 0x42, 0xb1, 0xa1, 0x2c, 0x5e, 0xd2, 0x75,
0xb4, 0xe5, 0xa0, 0xf6, 0x47, 0x75, 0xff, 0x2e, 0x5f, 0x78, 0xb6, 0x83, 0x36,
0x1a, 0xb1, 0x09, 0xc3, 0x6d, 0xc0, 0x82, 0xe0, 0x42, 0x50, 0xe2, 0x09, 0x0c,
0x27, 0x7c, 0x40, 0x85, 0xfd, 0x64, 0x11, 0x92, 0xfe, 0x28, 0x90, 0xbc, 0x81,
0x14, 0x5b, 0x88, 0x78, 0x5e, 0x59, 0x93, 0x48, 0x4e, 0xc9, 0x0a, 0x48, 0x29,
0x44, 0x7a, 0xa1, 0x74, 0x7a, 0x6b, 0x26, 0xb7, 0x74, 0x68, 0xb0, 0x53, 0x4f,
0x3b, 0x6f, 0xaf, 0xc5, 0x49, 0xfd, 0x97, 0x15, 0xa2, 0xa2, 0xf0, 0xce, 0xbd,
0x8b, 0x42, 0xe8, 0x9f, 0x2c, 0x0d, 0x92, 0xca, 0xdc, 0x4b, 0x0d, 0x96, 0x8f,
0xd0, 0x8b, 0x63, 0x58, 0x69, 0x8c, 0xc0, 0xee, 0xac, 0x47, 0x4f, 0xbd, 0x74,
0x64, 0x59, 0x88, 0xb5, 0xc2, 0xdf, 0x1d, 0x61, 0x5f, 0x2e, 0xa4, 0xb5, 0x42,
0x4a, 0x2e, 0x02, 0x9d, 0x44, 0x23, 0xa9, 0xf6, 0x1c, 0x2c, 0x5f, 0xd5, 0xa3,
0xbc, 0x22, 0x98, 0x8b, 0xe4, 0xc6, 0x5b, 0xc1, 0xb4, 0x1b, 0x4c, 0x7b, 0x76,
0xf2, 0xfc, 0xe9, 0xde, 0x5f, 0xed, 0x72, 0x82, 0x5f, 0x2d, 0xc2, 0x46, 0x11,
0x2a, 0xa3, 0x58, 0x55, 0x14, 0xa3, 0xe3, 0x6e, 0x3a, 0xed, 0xa6, 0xa0, 0x60,
0xca, 0x7a, 0x54, 0xf3, 0xb4, 0xc1, 0x73, 0x1e, 0xeb, 0xf2, 0x53, 0xd3, 0x3c,
0x5b, 0x7a, 0x3f, 0x2d, 0x01, 0x99, 0x8d, 0x14, 0x7e, 0x4c, 0x51, 0xc7, 0xdc,
0x26, 0x2b, 0xc0, 0x52, 0x01, 0x24, 0x7a, 0xe9, 0x51, 0x61, 0xb4, 0x00, 0x67,
0x37, 0xc9, 0x5f, 0xe8, 0x82, 0xac, 0x2c, 0xca, 0xc9, 0xe2, 0x66, 0x36, 0x73,
0x46, 0xb0, 0xd5, 0x3a, 0xda, 0xa8, 0xf3, 0x99, 0xcc, 0x05, 0xb0, 0x16, 0xa0,
0xb8, 0x8d, 0x4a, 0xdb, 0xa8, 0x39, 0x9d, 0xe2, 0x9e, 0x1c, 0x7e, 0xfd, 0x34,
0x02, 0x15, 0x21, 0xd4, 0x5c, 0x4c, 0x6d, 0xc5, 0x34, 0x76, 0x86, 0xc9, 0x33,
0x50, 0xb4, 0x93, 0xa6, 0x5e, 0x72, 0x9f, 0x49, 0x4a, 0x6b, 0x9d, 0xba, 0xb8,
0x25, 0xe7, 0xa7, 0xa7, 0x40, 0xbe, 0xe7, 0xf3, 0x56, 0x5a, 0xb2, 0x52, 0x86,
0x9a, 0x86, 0x9f, 0xf5, 0x70, 0x9b, 0xa7, 0xfc, 0x90, 0x6c, 0x87, 0xd4, 0x6f,
0x43, 0xc0, 0xd7, 0xa3, 0xdc, 0x04, 0x9b, 0xb0, 0xc1, 0x65, 0x03, 0x37, 0xf4,
0x3b, 0x5e, 0x4a, 0xf9, 0xaa, 0xe1, 0x6a, 0x84, 0x9a, 0x4d, 0xd9, 0x30, 0xc3,
0xbd, 0xbb, 0xf6, 0x40, 0xea, 0x92, 0xb5, 0xe0, 0x98, 0x8a, 0x4d, 0xaa, 0xd8,
0xba, 0x0d, 0xa1, 0xbf, 0xae, 0x7c, 0xad, 0xf4, 0xad, 0x53, 0x61, 0x6a, 0x06,
0x8c, 0x51, 0xf0, 0x98, 0x38, 0xe2, 0xa1, 0xcc, 0x5f, 0x28, 0x6f, 0x71, 0xf4,
0x63, 0x37, 0x9d, 0xba, 0x29, 0x39, 0x8e, 0xb9, 0x9e, 0x75, 0x2e, 0xd0, 0x89,
0x05, 0x3b, 0x57, 0x76, 0x6d, 0xd8, 0xb4, 0xc1, 0x6d, 0xc3, 0xa2, 0x0d, 0x6b,
0x52, 0xc4, 0x4b, 0x2e, 0xee, 0x99, 0xa9, 0xf5, 0x53, 0xa7, 0x9e, 0x95, 0xad,
0x52, 0x05, 0xf7, 0x9e, 0x92, 0xf7, 0x28, 0x95, 0xaf, 0x66, 0xb4, 0x1d, 0x31,
0xdc, 0xe7, 0x37, 0x92, 0xc9, 0x48, 0x7e, 0x76, 0x04, 0x4a, 0x1a, 0xac, 0x24,
0x9d, 0xac, 0xe9, 0x32, 0xd5, 0x53, 0x4f, 0xa0, 0x70, 0xdb, 0x26, 0x93, 0x85,
0x72, 0xab, 0xe9, 0x26, 0x67, 0x37, 0x95, 0xef, 0xd2, 0xc8, 0xdf, 0x36, 0xbd,
0x96, 0x2a, 0x50, 0xb7, 0x2c, 0x14, 0xf1, 0xe4, 0x8a, 0x5a, 0xc4, 0x29, 0x2a,
0xb8, 0x53, 0xc1, 0xfd, 0x0d, 0xee, 0x4b, 0x34, 0xd7, 0x50, 0xc1, 0x4b, 0xbb,
0x5e, 0x9f, 0x67, 0xe1, 0x37, 0x45, 0x6b, 0x59, 0x48, 0xe2, 0xd8, 0x5a, 0x3b,
0x74, 0x76, 0x24, 0xd8, 0x85, 0x42, 0xfe, 0x03, 0xbd, 0x05, 0x51, 0x17, 0xee,
0x42, 0x9c, 0x1d, 0x7a, 0x3b, 0xb8, 0x06, 0xad, 0x9b, 0xc0, 0x9c, 0xee, 0x8e,
0x80, 0xaf, 0x4c, 0x64, 0x15, 0x6f, 0x76, 0x3f, 0x63, 0x7e, 0xc1, 0x76, 0xe5,
0xdf, 0x9b, 0x84, 0xb1, 0xd3, 0x6b, 0xc7, 0xf7, 0x15, 0x4d, 0x76, 0x44, 0xee,
0x51, 0x4f, 0x35, 0x9a, 0x5f, 0x51, 0x9f, 0xe0, 0xb8, 0x8d, 0x4e, 0xdb, 0xce,
0xa3, 0x1e, 0xd9, 0x5a, 0x66, 0xe2, 0x12, 0xf6, 0x3c, 0x20, 0x9f, 0xbb, 0x4a,
0xf9, 0x7c, 0xae, 0x7e, 0x2e, 0x8a, 0x37, 0x22, 0xf7, 0xd5, 0x78, 0x3f, 0x4a,
0x18, 0xa6, 0xc8, 0x17, 0x25, 0x14, 0x79, 0x91, 0xed, 0x98, 0xe4, 0x43, 0x2a,
0x25, 0xcb, 0x57, 0x6b, 0xd2, 0x68, 0xc6, 0x82, 0x69, 0x32, 0x98, 0x7a, 0xe3,
0x58, 0x66, 0x34, 0x72, 0xde, 0x50, 0xd4, 0xb5, 0xa1, 0xa5, 0x0d, 0xaa, 0x2a,
0xac, 0xdb, 0xd1, 0x9e, 0x0e, 0xdb, 0xb8, 0xef, 0xb2, 0xed, 0x58, 0x11, 0x4d,
0x72, 0x51, 0xbd, 0x57, 0x4f, 0xdd, 0x0f, 0xb5, 0xc8, 0x77, 0xaa, 0x16, 0xed,
0x58, 0x11, 0x5d, 0x1c, 0x24, 0x91, 0xe7, 0x3c, 0xda, 0xbb, 0x6c, 0x47, 0xf4,
0x6b, 0x1e, 0xbf, 0x3b, 0x8e, 0x0f, 0x25, 0x09, 0xcf, 0x67, 0x33, 0x8e, 0x26,
0xde, 0xcb, 0xba, 0xe2, 0xe6, 0x52, 0xde, 0xcf, 0x43, 0x2d, 0x9f, 0x57, 0xbc,
0xa5, 0xae, 0x42, 0x68, 0x15, 0xd8, 0x41, 0x35, 0x9a, 0x5e, 0x37, 0x7d, 0x71,
0xf6, 0xc9, 0xf2, 0xbf, 0x0d, 0x74, 0xf1, 0x9e, 0xd8, 0xf6, 0x0c, 0x10, 0x56,
0x85, 0xd5, 0x53, 0x6c, 0x9c, 0x22, 0xab, 0x0a, 0x39, 0x55, 0x48, 0xce, 0xa5,
0xf0, 0xfb, 0xf3, 0x2b, 0xe9, 0xec, 0x16, 0xb5, 0x5c, 0x4d, 0x35, 0x23, 0xd5,
0xe7, 0x4b, 0x49, 0x84, 0x5f, 0x5f, 0x0d, 0x52, 0x4c, 0x77, 0x61, 0xa1, 0x0b,
0x8d, 0x81, 0xe8, 0x0a, 0x84, 0xe2, 0xc8, 0x0c, 0xef, 0xc7, 0x66, 0x15, 0x25,
0x54, 0x23, 0xa9, 0xfa, 0x7c, 0xbd, 0x0b, 0xab, 0x61, 0xa9, 0x86, 0xdd, 0x44,
0x11, 0xff, 0xd9, 0x52, 0x7d, 0x27, 0x58, 0x37, 0x4a, 0x55, 0xa3, 0x34, 0x55,
0x8d, 0x99, 0x6a, 0xd4, 0xf7, 0x51, 0xe4, 0xeb, 0x03, 0xc9, 0xe7, 0xeb, 0x74,
0xb3, 0x1a, 0xe3, 0x02, 0xf1, 0x3c, 0x0d, 0x3a, 0x22, 0xf5, 0xd1, 0x1d, 0x6e,
0xae, 0xb6, 0x51, 0xad, 0xb8, 0x1e, 0xdb, 0xde, 0x47, 0xc6, 0xa7, 0x77, 0x9e,
0x37, 0x48, 0xf1, 0xd3, 0x10, 0x0b, 0x85, 0x59, 0xa8, 0xdc, 0x4c, 0x96, 0x6b,
0x6a, 0x6e, 0xe3, 0x94, 0x58, 0xc9, 0x6a, 0xa5, 0x68, 0x07, 0x62, 0x1c, 0xb8,
0x78, 0xe3, 0xb1, 0x6c, 0x83, 0x2a, 0x36, 0x28, 0xd9, 0x81, 0x54, 0xdf, 0xd5,
0x27, 0x6e, 0xe1, 0xcd, 0xf4, 0xf9, 0x6e, 0xb3, 0x14, 0x1f, 0x52, 0xe9, 0xa1,
0x1c, 0xae, 0x67, 0x4e, 0x03, 0xa3, 0x23, 0x15, 0x79, 0xb9, 0x16, 0x1f, 0xde,
0xa4, 0xd1, 0x4d, 0xea, 0x6f, 0x23, 0x9f, 0x8b, 0x5c, 0x52, 0x48, 0x56, 0x6e,
0xc6, 0x6c, 0xd9, 0xb1, 0x7b, 0xc9, 0xff, 0x3c, 0xe0, 0x12, 0xc3, 0x4e, 0xd1,
0x55, 0x38, 0xcb, 0x44, 0x8c, 0xf0, 0x62, 0x07, 0x67, 0x69, 0x44, 0xdc, 0x32,
0x98, 0x77, 0xa0, 0xdb, 0x01, 0xeb, 0x11, 0xad, 0x3b, 0x70, 0x4b, 0x7a, 0x6a,
0x46, 0x15, 0x8c, 0x62, 0x11, 0x07, 0xe3, 0x68, 0x44, 0xbe, 0xcc, 0x50, 0x56,
0x85, 0x8a, 0x2a, 0x24, 0x04, 0x53, 0xb0, 0x42, 0xe7, 0x4f, 0xc5, 0x55, 0x28,
0xad, 0x82, 0x76, 0x8d, 0x74, 0x77, 0xc5, 0x78, 0xd3, 0x6a, 0x40, 0xe9, 0xe2,
0xce, 0xfd, 0x44, 0x15, 0x5c, 0x17, 0x0e, 0xad, 0x5f, 0x3e, 0x05, 0x72, 0x1d,
0x38, 0x16, 0x4f, 0x93, 0xe2, 0x32, 0xf3, 0x60, 0x15, 0x46, 0xa4, 0xba, 0xcd,
0x2a, 0xb8, 0x45, 0x66, 0x2b, 0x8a, 0xed, 0x46, 0xb1, 0xfe, 0x28, 0x36, 0xc4,
0xc5, 0xd7, 0x5e, 0x15, 0x0e, 0xab, 0xbe, 0x25, 0x24, 0x53, 0xd2, 0x28, 0x9d,
0x2b, 0xb2, 0xdc, 0x6a, 0xe4, 0xf3, 0xb5, 0x3e, 0xd2, 0x32, 0x2f, 0xa7, 0xd7,
0x8c, 0x6a, 0x68, 0xb3, 0x50, 0xe1, 0x12, 0x60, 0x33, 0x1f, 0xb6, 0x6f, 0x21,
0xe3, 0x1c, 0xd0, 0x4b, 0x93, 0x28, 0xe1, 0x73, 0xe2, 0x99, 0x94, 0x3a, 0xa4,
0xd7, 0x71, 0x57, 0xca, 0x81, 0x36, 0x79, 0x45, 0x5b, 0x17, 0x28, 0xcc, 0x84,
0xdf, 0x2f, 0xe2, 0xa5, 0xb1, 0x51, 0x9a, 0x14, 0x02, 0xaf, 0xd3, 0x81, 0x1e,
0x07, 0x32, 0x54, 0xcc, 0xa8, 0x62, 0x83, 0x0e, 0x8c, 0x38, 0xc4, 0x6b, 0x3c,
0x96, 0x77, 0x48, 0xd1, 0x24, 0x9a, 0xe4, 0x3a, 0x90, 0xef, 0xdb, 0x8c, 0xf2,
0x19, 0x3a, 0xcd, 0x42, 0x15, 0x2f, 0x2d, 0x3a, 0xb0, 0xc2, 0x13, 0x8e, 0x1d,
0x3b, 0x8f, 0xb5, 0xb4, 0x3b, 0x1c, 0xca, 0x2b, 0x0a, 0xdf, 0x8a, 0x8f, 0x24,
0x1f, 0x86, 0x0f, 0x8f, 0x96, 0x1d, 0x58, 0xe3, 0x69, 0xf8, 0x24, 0x45, 0x71,
0x5a, 0x08, 0xaa, 0x27, 0x75, 0xbd, 0xd0, 0x7a, 0x0e, 0xa8, 0x6a, 0xa4, 0x63,
0xe3, 0x33, 0x07, 0xfc, 0x6b, 0xce, 0x27, 0x1e, 0x59, 0x03, 0x4d, 0x0d, 0x8a,
0x6b, 0x50, 0x5a, 0x83, 0x82, 0x1a, 0x14, 0xd5, 0xa0, 0x72, 0x8f, 0xaa, 0xf6,
0xe4, 0x25, 0xce, 0xf4, 0xa1, 0xd5, 0xb8, 0xc9, 0x29, 0x82, 0xbd, 0x79, 0x35,
0x50, 0x98, 0x6a, 0x2e, 0xaf, 0x59, 0x79, 0x0d, 0x6c, 0x35, 0xb8, 0x9c, 0xf1,
0x45, 0xec, 0x13, 0x59, 0x69, 0x22, 0xbb, 0x59, 0x83, 0xf1, 0x4b, 0xc0, 0xb4,
0x60, 0x96, 0x19, 0x7c, 0xd9, 0x82, 0x3c, 0xe1, 0x95, 0xa7, 0x3e, 0x84, 0x94,
0x28, 0x4a, 0x8f, 0xe2, 0x66, 0x30, 0xb9, 0x06, 0x2e, 0x2a, 0x55, 0xb5, 0xd8,
0x3c, 0x22, 0xb7, 0x44, 0xec, 0xd9, 0xb5, 0x30, 0xd5, 0x62, 0x27, 0x9e, 0xf6,
0xc5, 0xd6, 0x26, 0xd4, 0x72, 0xc5, 0xe5, 0xeb, 0x39, 0xad, 0x16, 0x3f, 0xb0,
0xc8, 0x05, 0x7b, 0x2d, 0x1c, 0x3c, 0x37, 0xd6, 0x42, 0x93, 0x2d, 0x17, 0x4a,
0xb3, 0x16, 0x1d, 0xe7, 0xa8, 0x3c, 0x9f, 0x31, 0x8a, 0x8d, 0x78, 0x36, 0x5c,
0x8b, 0xf1, 0x3a, 0xf9, 0x90, 0x29, 0x97, 0xf2, 0x85, 0x78, 0xdf, 0xa9, 0xc3,
0x7e, 0xdd, 0xa5, 0xa9, 0x95, 0x27, 0x30, 0x5b, 0x82, 0x6f, 0xb0, 0x41, 0x4e,
0xa8, 0x9d, 0xdc, 0xea, 0x73, 0x22, 0xd0, 0x29, 0x68, 0xd5, 0x4a, 0x23, 0xc2,
0xcf, 0x5f, 0x36, 0xd1, 0x9a, 0xe9, 0xa2, 0x41, 0x9e, 0x13, 0x66, 0x27, 0x52,
0x9c, 0x40, 0xa6, 0x53, 0xea, 0x27, 0xcb, 0x89, 0x1c, 0xe7, 0x79, 0x8f, 0xdd,
0x4e, 0xf4, 0xf9, 0x0a, 0x0a, 0x6a, 0x75, 0xa2, 0xc3, 0x89, 0x66, 0x27, 0xf2,
0xf4, 0xd8, 0x1e, 0xa5, 0x7f, 0xfa, 0xdf, 0x71, 0x07, 0xf5, 0xbf, 0xde, 0xf7,
0xb0, 0xee, 0x46, 0xcb, 0xe7, 0x22, 0x1e, 0x7b, 0x36, 0x40, 0xfe, 0x83, 0x97,
0x6e, 0x38, 0x45, 0x26, 0x93, 0x26, 0xf9, 0xce, 0x65, 0x24, 0xfe, 0x1f, 0x9b,
0x80, 0xf1, 0x5e, 0x21, 0xa6, 0xd6, 0xa9, 0x6a, 0x5d, 0x3a, 0x19, 0xb4, 0x61,
0x80, 0x2b, 0x38, 0xae, 0x54, 0x8f, 0x3e, 0xef, 0x31, 0x51, 0x49, 0x17, 0x59,
0xb9, 0xd3, 0x3f, 0x1c, 0xc2, 0x46, 0x43, 0x2e, 0xef, 0xb0, 0xac, 0xfe, 0xce,
0x2f, 0x23, 0x6a, 0xe8, 0x80, 0xe6, 0x03, 0x91, 0x7c, 0xb5, 0xe7, 0x8b, 0xa3,
0x1f, 0xfa, 0xf7, 0x71, 0x0d, 0x68, 0xa5, 0x18, 0xeb, 0xdd, 0x43, 0x0b, 0xd0,
0xb3, 0x60, 0x3d, 0xbb, 0xed, 0xa0, 0xfa, 0x9f, 0x5a, 0x25, 0x01, 0x54, 0xd6,
0xc4, 0x1d, 0xdd, 0xf7, 0xf7, 0xdf, 0xb7, 0x34, 0x21, 0x44, 0xcf, 0x46, 0x06,
0x61, 0x6d, 0x42, 0x5c, 0x36, 0x65, 0x3c, 0x9c, 0xf5, 0xc1, 0x4c, 0x3a, 0x2b,
0x6e, 0x42, 0x69, 0x93, 0x14, 0xd5, 0xe5, 0xff, 0x8e, 0x26, 0xa1, 0x85, 0xc8,
0x24, 0xce, 0xaf, 0xea, 0x78, 0xde, 0xd9, 0x24, 0x5f, 0xe6, 0x68, 0x42, 0x5b,
0xd3, 0xf9, 0x20, 0x06, 0x9b, 0x30, 0x72, 0x51, 0x98, 0xb2, 0x63, 0x3d, 0x19,
0xc3, 0x3f, 0xcd, 0xd4, 0xb2, 0x9b, 0xe9, 0x34, 0x7e, 0x7e, 0xf1, 0xe2, 0xb6,
0x8e, 0x6d, 0xeb, 0x58, 0xf2, 0x09, 0x59, 0x1a, 0x71, 0x8b, 0xcb, 0xb5, 0xf0,
0x0c, 0x8a, 0xca, 0x90, 0x95, 0x65, 0x09, 0xe9, 0x4b, 0x68, 0x73, 0x8c, 0xdc,
0x63, 0x34, 0x3b, 0x45, 0x0b, 0x5c, 0xb8, 0x2d, 0x6b, 0xd9, 0x7e, 0x08, 0x66,
0x93, 0xf1, 0xcf, 0x14, 0xe3, 0x6f, 0xad, 0x0d, 0x51, 0x73, 0x36, 0x6b, 0xcb,
0x66, 0x5a, 0x17, 0xe9, 0xe4, 0x37, 0xcc, 0xa3, 0xe3, 0x29, 0x26, 0xfe, 0x7c,
0x76, 0x9c, 0x40, 0x9b, 0x1b, 0xe1, 0x2f, 0xdc, 0xba, 0xd8, 0x2a, 0x8a, 0x17,
0x66, 0x77, 0x63, 0x2d, 0x5a, 0x6a, 0x51, 0x5f, 0x8b, 0x26, 0x41, 0xa5, 0xcd,
0xb5, 0x68, 0x13, 0x69, 0x6f, 0x2d, 0x06, 0xce, 0xa9, 0xf6, 0x66, 0x2d, 0x14,
0x18, 0x95, 0x4b, 0x13, 0xb5, 0x70, 0xd5, 0x22, 0xa1, 0x81, 0xba, 0x9e, 0x0f,
0x79, 0x7b, 0x64, 0x8a, 0x36, 0x5d, 0x94, 0xf3, 0x83, 0xb5, 0x18, 0x34, 0x27,
0x23, 0x67, 0x9c, 0xa6, 0x04, 0x52, 0x79, 0x2f, 0x62, 0xb8, 0x7c, 0xa3, 0xce,
0x48, 0xd6, 0x13, 0xc9, 0xa6, 0x6b, 0x91, 0x12, 0x0d, 0xee, 0x6f, 0xf0, 0xba,
0x99, 0x5a, 0x9c, 0xf8, 0xb3, 0xcc, 0x5f, 0x86, 0x04, 0xc1, 0x7f, 0x03, 0x8a,
0x19, 0x81, 0x7d, 0x10, 0xcf, 0x1c, 0x3f, 0x71, 0x3e, 0xc8, 0x2d, 0xb9, 0xf9,
0x5a, 0x2c, 0x71, 0x0e, 0xab, 0xa5, 0xb9, 0x0f, 0x74, 0x2e, 0x2e, 0x6f, 0x52,
0x69, 0x24, 0x55, 0xe2, 0xbc, 0x60, 0x32, 0x05, 0x73, 0x06, 0xad, 0x24, 0xfd,
0xe3, 0x3b, 0xff, 0xd6, 0xdb, 0x2d, 0x83, 0x8e, 0x7e, 0x9d, 0x79, 0x4a, 0x3b,
0xfe, 0xac, 0xcf, 0x88, 0x1c, 0xf9, 0x7e, 0x57, 0x72, 0x31, 0xa5, 0x8a, 0x23,
0xe9, 0x4a, 0x17, 0x4a, 0x3e, 0xd9, 0x68, 0xa1, 0x90, 0x00, 0x16, 0x16, 0xc0,
0x38, 0x3d, 0x25, 0x9a, 0x68, 0xfc, 0xb5, 0xcd, 0x4f, 0xf7, 0x5e, 0xf4, 0x5e,
0xcb, 0x7b, 0x22, 0xf8, 0xb3, 0x9e, 0x32, 0xce, 0x51, 0x0e, 0x52, 0x0b, 0x77,
0xb1, 0x7a, 0x1a, 0xb4, 0xfa, 0x4e, 0x4e, 0xa5, 0xac, 0xc9, 0x1c, 0x54, 0xeb,
0xa0, 0x12, 0x2f, 0x59, 0xbd, 0xd4, 0x3c, 0x8d, 0xb6, 0x69, 0xc8, 0xff, 0xb4,
0x5e, 0x40, 0xb7, 0x44, 0xe8, 0xa2, 0x78, 0x90, 0xea, 0x5f, 0xdc, 0x8d, 0x66,
0xb4, 0xde, 0x4b, 0x23, 0x4f, 0x2d, 0x5f, 0x53, 0x59, 0x69, 0x7e, 0x1a, 0xf7,
0x8f, 0x4c, 0xa3, 0xbd, 0x95, 0x66, 0xdf, 0x2d, 0x4a, 0x67, 0xa2, 0xbc, 0xc4,
0x5b, 0xdc, 0x1e, 0xa4, 0xc0, 0x5f, 0xdd, 0xe2, 0x99, 0x41, 0x1b, 0x12, 0x9f,
0x70, 0x4f, 0xe3, 0xe2, 0x12, 0x24, 0xb7, 0xfb, 0x3c, 0x37, 0xc5, 0xc1, 0x81,
0x9a, 0xcd, 0xa9, 0xd9, 0xf0, 0x0c, 0x8d, 0xce, 0x50, 0xc8, 0x0c, 0x3a, 0xbf,
0x2a, 0xb9, 0x7f, 0x4d, 0x11, 0xf0, 0x72, 0xa6, 0x91, 0xed, 0x4d, 0x23, 0x32,
0x03, 0x51, 0x8f, 0x1f, 0x4e, 0xd2, 0xd6, 0xb4, 0xb8, 0xb8, 0x9a, 0xbe, 0xcb,
0xd1, 0xa7, 0x71, 0x6f, 0xa3, 0x11, 0xa5, 0x81, 0x82, 0xba, 0x6b, 0x34, 0xcc,
0xf3, 0x79, 0x4b, 0xba, 0x78, 0x01, 0x71, 0x8f, 0x65, 0x7d, 0xb1, 0xf4, 0x79,
0xe5, 0xb5, 0x52, 0x93, 0xec, 0x31, 0x50, 0xd0, 0x63, 0xa7, 0x82, 0x51, 0x12,
0xbb, 0x69, 0xfd, 0x1d, 0x75, 0x36, 0xab, 0x9e, 0xa1, 0xda, 0x19, 0x51, 0x9e,
0x81, 0x61, 0x86, 0x8b, 0x90, 0x19, 0xfc, 0x41, 0xa4, 0x74, 0xc0, 0x7d, 0x8f,
0x6e, 0x06, 0x0a, 0x8a, 0xd4, 0x32, 0x0d, 0x57, 0x30, 0xf5, 0x63, 0xd4, 0x34,
0x46, 0xc9, 0x33, 0x28, 0xf9, 0x6a, 0xf5, 0x0d, 0xd3, 0x7f, 0x88, 0x19, 0xa2,
0xf6, 0x49, 0xea, 0xe2, 0xd2, 0x5b, 0x3e, 0x8d, 0xed, 0xde, 0x20, 0x4b, 0x04,
0xd2, 0x79, 0xfb, 0xb4, 0x19, 0x28, 0x73, 0x7f, 0xa9, 0xfb, 0xa5, 0x65, 0x06,
0x89, 0x19, 0x64, 0xc8, 0x20, 0x6d, 0x1e, 0x9b, 0xbb, 0x8d, 0xa0, 0x27, 0xa8,
0x62, 0x06, 0x79, 0x33, 0x38, 0x7e, 0x63, 0xf3, 0x89, 0x99, 0x17, 0xe2, 0x5f,
0x14, 0xb8, 0x53, 0x87, 0x34, 0xc3, 0x39, 0x48, 0x7e, 0x9b, 0x81, 0xc6, 0xa6,
0x30, 0x29, 0x8e, 0x23, 0x9b, 0x4d, 0x34, 0xf3, 0x17, 0x2b, 0x53, 0x98, 0x98,
0x82, 0x4b, 0x2a, 0x77, 0x51, 0x9b, 0x14, 0x3a, 0x1d, 0x2c, 0xa1, 0x11, 0x4e,
0xda, 0x53, 0xb8, 0x4f, 0x1b, 0x82, 0xfd, 0x05, 0xae, 0x46, 0xe3, 0xd8, 0xa4,
0xec, 0x85, 0xd0, 0xea, 0x21, 0x6d, 0x1c, 0x52, 0xb8, 0x0b, 0x51, 0x7c, 0xab,
0xfd, 0x82, 0x98, 0x7f, 0x2e, 0xc4, 0xcb, 0x0d, 0x67, 0x53, 0x52, 0x32, 0xab,
0x63, 0x0d, 0xbf, 0x35, 0x3d, 0xef, 0x99, 0x42, 0x80, 0x0b, 0xc1, 0x82, 0x18,
0x32, 0x5c, 0x30, 0xba, 0x10, 0xea, 0xc7, 0x5c, 0xaf, 0xee, 0x5d, 0x2f, 0xb9,
0x32, 0xc2, 0xad, 0xb4, 0xe3, 0x15, 0x3a, 0x5d, 0xa1, 0x2c, 0x97, 0xa0, 0x96,
0x90, 0x01, 0x8a, 0x7c, 0xf2, 0x8f, 0xfa, 0x92, 0x45, 0x9e, 0x7b, 0xee, 0xed,
0xb1, 0x28, 0xca, 0x66, 0xc9, 0x2e, 0xf4, 0xa6, 0x61, 0x34, 0x0d, 0xf1, 0x2e,
0xa4, 0xf8, 0xb1, 0xb0, 0x2c, 0x44, 0x7f, 0x1d, 0xf3, 0xb5, 0x4e, 0xa2, 0xad,
0xf2, 0x44, 0x3a, 0x7b, 0xd7, 0xb6, 0x4d, 0xa1, 0x2e, 0x44, 0xb8, 0xa0, 0x75,
0x81, 0x83, 0x7d, 0xa3, 0xf1, 0x25, 0x53, 0xc3, 0x34, 0x33, 0xcc, 0x2d, 0x80,
0x60, 0x16, 0x76, 0xdd, 0x23, 0x02, 0xe6, 0x5c, 0xcb, 0xe7, 0x58, 0x50, 0x24,
0x35, 0x1f, 0x4b, 0xa5, 0xc9, 0x54, 0x61, 0x5f, 0xb2, 0x8a, 0x1f, 0xe4, 0x08,
0x6d, 0x52, 0xe8, 0x82, 0x45, 0x26, 0xda, 0x92, 0x2a, 0xb2, 0x72, 0x2e, 0xac,
0x9f, 0xa2, 0x26, 0xce, 0xcb, 0xf5, 0x25, 0x94, 0x77, 0xfd, 0x56, 0x3b, 0xdf,
0xe1, 0x4c, 0x72, 0x66, 0x9e, 0x07, 0xd0, 0x27, 0x5c, 0x70, 0xb9, 0x30, 0xc8,
0x1b, 0xa4, 0xbd, 0xbf, 0x2b, 0x5f, 0x86, 0x2c, 0xa9, 0x25, 0x6b, 0x2d, 0xe5,
0xde, 0xa2, 0x86, 0x68, 0x84, 0x46, 0x20, 0x22, 0x02, 0x9d, 0xef, 0x94, 0x56,
0x50, 0xaf, 0x3f, 0x9b, 0x78, 0xa8, 0x28, 0x89, 0x6d, 0x76, 0x53, 0xc2, 0xbf,
0x74, 0x7e, 0x50, 0xfe, 0x6c, 0xec, 0xcf, 0xfa, 0x2c, 0x68, 0xe0, 0x2d, 0xeb,
0x5c, 0x88, 0x7e, 0x63, 0x80, 0x1b, 0x27, 0xcb, 0x39, 0xb4, 0x96, 0xc3, 0x19,
0x20, 0x84, 0xa9, 0x45, 0x04, 0x3a, 0x98, 0xd5, 0xfa, 0x54, 0xe2, 0xaa, 0x0b,
0x05, 0xd5, 0xd0, 0x27, 0x09, 0x0b, 0x3a, 0x86, 0x96, 0x9e, 0x0b, 0x7a, 0x3b,
0xf0, 0x6d, 0x8f, 0x18, 0x64, 0xe3, 0x1a, 0x4d, 0x3e, 0x25, 0x7b, 0x46, 0x95,
0xad, 0x54, 0xd5, 0x2a, 0x1d, 0x7b, 0x4d, 0xd3, 0xdc, 0x34, 0x2d, 0xd7, 0xd1,
0xca, 0xfb, 0xfe, 0xe2, 0xd2, 0x36, 0xa7, 0xe0, 0x7b, 0xe3, 0x67, 0x10, 0x3d,
0x83, 0x42, 0x07, 0x84, 0xbd, 0xb6, 0x9a, 0x45, 0x1b, 0x59, 0xa4, 0x9d, 0x81,
0x4e, 0xba, 0xd3, 0x5d, 0x96, 0x4b, 0x05, 0x5f, 0xcd, 0xa5, 0xb1, 0xba, 0x40,
0xd6, 0xc0, 0x49, 0xb8, 0xb7, 0x93, 0x06, 0x3a, 0xb9, 0xab, 0xc1, 0xac, 0xe9,
0xe2, 0x71, 0x01, 0xcc, 0x15, 0xc0, 0x92, 0xcd, 0x94, 0x6a, 0xa6, 0xa9, 0x3a,
0xd2, 0x04, 0xa0, 0xef, 0xe2, 0x32, 0xfc, 0xc9, 0x20, 0xa9, 0x86, 0xa4, 0xb3,
0x86, 0x74, 0xf2, 0xcf, 0xa0, 0xea, 0x19, 0xac, 0x3f, 0x37, 0xfe, 0x5c, 0xdf,
0x0c, 0x42, 0x4f, 0xc8, 0x69, 0x40, 0x17, 0xef, 0x3d, 0xdc, 0x48, 0x51, 0x46,
0x6a, 0x9d, 0x41, 0xc6, 0xa7, 0x1b, 0x9d, 0x44, 0xb3, 0x33, 0x58, 0xe0, 0xd0,
0x04, 0x23, 0x25, 0x19, 0xf9, 0xac, 0x06, 0x69, 0xf5, 0x67, 0x23, 0x5c, 0xa0,
0xa7, 0x91, 0x36, 0x14, 0x6d, 0x6d, 0xe2, 0x4d, 0x3b, 0x0e, 0xb5, 0xd1, 0x86,
0x4d, 0x5c, 0x8c, 0x1b, 0x9d, 0xc1, 0x91, 0x8d, 0xbc, 0x36, 0xc1, 0x52, 0x4e,
0x0d, 0xa3, 0xce, 0x19, 0xf4, 0xcc, 0x60, 0x71, 0x97, 0x56, 0x76, 0xb9, 0x9e,
0x5c, 0x34, 0xd2, 0x8a, 0x91, 0x0a, 0x16, 0xa8, 0xe8, 0xe2, 0x82, 0x41, 0xc0,
0x14, 0xa5, 0x7f, 0xbd, 0x74, 0x71, 0x4f, 0x3d, 0xb9, 0x86, 0xe2, 0xdf, 0x53,
0x4b, 0xd7, 0x0d, 0x02, 0xf8, 0x7f, 0xe0, 0xac, 0x08, 0x8b, 0x5b, 0xd5, 0x4c,
0xf6, 0x00, 0xa9, 0x3c, 0x85, 0x6c, 0x22, 0xc4, 0x17, 0x37, 0x0b, 0xfd, 0xec,
0x25, 0xe5, 0x5e, 0x3c, 0x8b, 0x52, 0x5e, 0xae, 0x9c, 0x45, 0xd5, 0xec, 0x37,
0x4c, 0xc0, 0xdc, 0x1a, 0xda, 0xbb, 0x2f, 0x5d, 0x5c, 0xf8, 0x2d, 0xd9, 0x26,
0xeb, 0x36, 0x15, 0x9e, 0xd2, 0xb8, 0x01, 0x23, 0x1c, 0x6d, 0x53, 0xcb, 0xdc,
0xb2, 0xf3, 0x62, 0x9f, 0xc5, 0xe2, 0xcb, 0x99, 0x99, 0xe7, 0x47, 0x90, 0xb3,
0x98, 0x13, 0xbd, 0xd4, 0x6c, 0x92, 0x93, 0x53, 0x5e, 0xf7, 0x2c, 0xfa, 0x78,
0x71, 0x38, 0x8f, 0x46, 0xf3, 0xf8, 0x4c, 0x67, 0xb1, 0x31, 0x0b, 0xf9, 0x9f,
0xc6, 0x2a, 0x68, 0x52, 0x0a, 0x02, 0x1e, 0x37, 0xd3, 0x69, 0x33, 0x05, 0xcc,
0xe1, 0x9f, 0xeb, 0xe7, 0x7c, 0xd7, 0x28, 0x03, 0x06, 0x28, 0xea, 0x8b, 0x43,
0x8e, 0xb4, 0x35, 0x4b, 0xfb, 0xbf, 0x3d, 0x9d, 0xc5, 0xd9, 0x2c, 0xfc, 0xe7,
0x84, 0x26, 0xc8, 0x66, 0xa3, 0x8d, 0xf0, 0x48, 0xe3, 0x8c, 0x4c, 0x65, 0x9a,
0x54, 0x3e, 0x84, 0x9a, 0x78, 0x72, 0x0a, 0x9d, 0x12, 0x3d, 0x87, 0x98, 0x39,
0xc8, 0xb4, 0x54, 0x1d, 0x4f, 0x41, 0x4f, 0x0f, 0x7c, 0xbd, 0xdd, 0x8c, 0xc4,
0x39, 0x18, 0x78, 0xcb, 0xa3, 0x48, 0xe6, 0x15, 0x51, 0xa8, 0xfe, 0x24, 0xd2,
0xbf, 0xa0, 0x6c, 0x0c, 0x41, 0x5b, 0x08, 0x4a, 0xe7, 0x70, 0x73, 0x8d, 0x22,
0xaf, 0xea, 0xaf, 0xf6, 0xad, 0x51, 0x50, 0x11, 0xf3, 0xfc, 0x75, 0x54, 0xe3,
0xa5, 0x0b, 0x75, 0xab, 0x69, 0x6c, 0x43, 0x32, 0x30, 0x8b, 0xe7, 0x51, 0x3a,
0x7f, 0x71, 0xef, 0x6e, 0x92, 0x1a, 0x84, 0x57, 0x31, 0x3b, 0x41, 0x0b, 0x13,
0xfc, 0xe1, 0xf3, 0x70, 0xca, 0x75, 0xd3, 0x1b, 0x34, 0x27, 0xe2, 0x40, 0xd3,
0x3b, 0x34, 0xf7, 0x4a, 0xe6, 0x1b, 0xae, 0xf9, 0x4b, 0x17, 0x25, 0x17, 0x48,
0xba, 0x15, 0x72, 0x30, 0x0f, 0x8f, 0x04, 0xde, 0x9c, 0x07, 0x5b, 0x0f, 0xc1,
0xcc, 0x3a, 0x65, 0x2c, 0xc0, 0xb8, 0x80, 0x93, 0x79, 0xa8, 0x16, 0x20, 0x1f,
0xd6, 0x8c, 0xa5, 0xd3, 0x24, 0xd7, 0xbd, 0x97, 0x3f, 0xbc, 0x70, 0x56, 0x4c,
0xfe, 0x16, 0x5f, 0x98, 0xb0, 0x90, 0x03, 0x8b, 0x44, 0x45, 0xf6, 0x02, 0x4c,
0x0b, 0xf0, 0xbd, 0x22, 0x73, 0x71, 0x99, 0x74, 0x96, 0x22, 0x84, 0x6f, 0xd1,
0x38, 0x46, 0xdc, 0x1b, 0x2c, 0xdb, 0xa4, 0x0a, 0xc1, 0xfe, 0x63, 0x0b, 0x98,
0x14, 0x4d, 0xd2, 0xb6, 0x28, 0x73, 0xcb, 0xa7, 0xf9, 0x9b, 0x29, 0xf4, 0xa3,
0x99, 0x3c, 0x3e, 0xbd, 0xde, 0x05, 0x0c, 0x2c, 0x60, 0x76, 0x01, 0x0b, 0x02,
0x45, 0x46, 0x1d, 0x5e, 0xc0, 0xe8, 0x02, 0xce, 0x9b, 0x49, 0xc6, 0x4f, 0x1e,
0x6b, 0x11, 0xd8, 0x5b, 0x79, 0xcc, 0xd3, 0x04, 0x0f, 0x07, 0x1f, 0x2c, 0x00,
0x09, 0x5f, 0xeb, 0x66, 0xef, 0x22, 0x98, 0xd0, 0x7d, 0x8a, 0xd8, 0x97, 0xd4,
0x57, 0x36, 0xd5, 0x66, 0xcb, 0xd7, 0xae, 0xe7, 0x30, 0x34, 0x77, 0x89, 0xae,
0xb2, 0x2a, 0x58, 0x4e, 0x05, 0xa3, 0xe5, 0x39, 0xac, 0x71, 0xf0, 0xe6, 0x1c,
0xdc, 0xbe, 0xda, 0x83, 0x60, 0xe6, 0x09, 0x66, 0x07, 0x73, 0xf0, 0xf8, 0x00,
0xe1, 0xf3, 0x88, 0x3a, 0x5f, 0xc5, 0xe9, 0x45, 0xc4, 0x76, 0x61, 0xbf, 0xe4,
0x92, 0x3d, 0x95, 0x31, 0x0f, 0xe3, 0x3c, 0xf8, 0xff, 0x3d, 0xf9, 0xf3, 0xb8,
0x7c, 0x0b, 0xb2, 0x6e, 0x01, 0x4a, 0xc7, 0x02, 0xfe, 0x5b, 0x76, 0x5f, 0xca,
0x0c, 0xa5, 0xcf, 0x5c, 0x0c, 0x7c, 0x11, 0x0a, 0xf5, 0xe2, 0xf9, 0xbb, 0xa7,
0x8b, 0xd0, 0x9f, 0xe7, 0xef, 0x7c, 0x1f, 0x45, 0xfe, 0xce, 0x03, 0x9f, 0xda,
0x22, 0x6a, 0x17, 0xbf, 0xdd, 0xfb, 0xb1, 0x8e, 0x9d, 0xea, 0x98, 0x18, 0xe8,
0xdc, 0x37, 0x6a, 0x8f, 0x16, 0xe1, 0xbd, 0x0b, 0x14, 0x1b, 0xc9, 0xe6, 0x1a,
0x31, 0x9b, 0x85, 0xf8, 0x4d, 0x5a, 0xcd, 0x66, 0xfa, 0xeb, 0x43, 0x82, 0x34,
0xa9, 0x60, 0x8f, 0xc2, 0xde, 0x30, 0xe6, 0xd1, 0x81, 0x1f, 0xf3, 0xf8, 0x71,
0xc0, 0x51, 0x0a, 0x79, 0x53, 0x68, 0x22, 0x8f, 0x82, 0xd4, 0x18, 0x59, 0x46,
0x54, 0x87, 0x44, 0xf5, 0x03, 0xd0, 0x88, 0xd8, 0x78, 0xe5, 0x36, 0x6d, 0x3d,
0x6f, 0xce, 0xe7, 0x68, 0x9b, 0xe5, 0xe4, 0x2e, 0x17, 0x8c, 0x58, 0xc4, 0x1c,
0x45, 0xac, 0x6e, 0x9c, 0x36, 0x1f, 0x0b, 0xb3, 0x22, 0x87, 0x63, 0x6b, 0x33,
0x49, 0xc7, 0x19, 0xb3, 0xb0, 0x03, 0x0a, 0x73, 0xc7, 0x5d, 0x63, 0xaa, 0xee,
0x40, 0x4d, 0x25, 0x4a, 0x9f, 0x6f, 0x7f, 0xb8, 0xfa, 0x91, 0x3e, 0x7f, 0xc6,
0x8b, 0xb5, 0x1d, 0xe8, 0x2e, 0x67, 0x7d, 0xe5, 0xbc, 0xc3, 0xd6, 0x0e, 0x54,
0xbe, 0x17, 0xfa, 0xdb, 0x88, 0x1c, 0xd6, 0xdd, 0x21, 0x5e, 0xf1, 0xcc, 0x7e,
0x3e, 0xaa, 0x88, 0x8b, 0xc9, 0x0e, 0xc4, 0x05, 0x62, 0xf5, 0xa9, 0xfd, 0x67,
0x27, 0xa5, 0x37, 0xf3, 0xed, 0xfb, 0xe4, 0xd8, 0x17, 0xd0, 0x81, 0xbb, 0xbb,
0x2e, 0x8c, 0x61, 0xe3, 0x0f, 0x8d, 0x78, 0x28, 0x21, 0x93, 0x0c, 0x22, 0x6c,
0xbe, 0x5e, 0x49, 0xb7, 0x24, 0x93, 0x26, 0x5a, 0xc5, 0x62, 0x54, 0x2c, 0x37,
0x9d, 0x35, 0xbd, 0xb6, 0x10, 0x8e, 0xf6, 0x46, 0x74, 0x45, 0xb3, 0x83, 0x4e,
0x4a, 0xf9, 0x69, 0xfc, 0x53, 0xfe, 0x93, 0x54, 0xe7, 0xa4, 0x06, 0xe7, 0xb9,
0x7f, 0xd0, 0x4a, 0x7d, 0xad, 0xd4, 0xb9, 0x4c, 0x3d, 0x22, 0x2c, 0x3a, 0x9c,
0xc6, 0x46, 0x2f, 0x39, 0x7a, 0x54, 0x60, 0xa3, 0x8c, 0xf7, 0xfa, 0xe4, 0xe0,
0x4c, 0x79, 0x17, 0x6c, 0x5d, 0x5c, 0x76, 0x75, 0xa1, 0xaa, 0x0b, 0xdd, 0x1a,
0x16, 0xdf, 0x24, 0x32, 0xe1, 0x5d, 0xe8, 0xdd, 0x40, 0xed, 0xf5, 0xf4, 0xf4,
0x4b, 0xcd, 0x76, 0xd4, 0x6c, 0xff, 0x22, 0x64, 0x3f, 0xd5, 0x85, 0xce, 0x4f,
0x7b, 0x3e, 0x75, 0x89, 0xd7, 0xed, 0x14, 0xa1, 0x53, 0x14, 0x31, 0x75, 0xf7,
0x66, 0x1e, 0x75, 0xc1, 0x2b, 0xbd, 0x8a, 0x77, 0xd2, 0x05, 0x55, 0x37, 0xc2,
0xb5, 0x2c, 0x4a, 0xcb, 0xa6, 0x22, 0xd8, 0x4c, 0xc4, 0x5d, 0x41, 0xff, 0xac,
0x6e, 0xe4, 0x74, 0x63, 0x78, 0x8c, 0x46, 0xe5, 0xd0, 0xcb, 0xd8, 0x16, 0x4d,
0x6e, 0x51, 0x68, 0x37, 0x92, 0xdf, 0xdb, 0xff, 0x45, 0x69, 0x37, 0xe4, 0x0f,
0x80, 0xd0, 0xbe, 0xb8, 0x13, 0x51, 0xdd, 0x8d, 0x2b, 0x2d, 0x12, 0xa8, 0xae,
0x1b, 0x0d, 0xdd, 0x90, 0xff, 0xe9, 0xf6, 0x18, 0x6d, 0x8f, 0xf9, 0x9c, 0xa6,
0x06, 0x32, 0x37, 0xc8, 0x67, 0xd1, 0x35, 0xd4, 0x53, 0x23, 0xfb, 0xff, 0x54,
0x21, 0x85, 0xa3, 0xa7, 0xa6, 0x68, 0x46, 0x8c, 0x71, 0xb3, 0x1b, 0xf5, 0xbf,
0x2e, 0x6d, 0x96, 0xb1, 0x86, 0x69, 0x32, 0x04, 0xdb, 0xdd, 0xe7, 0x52, 0xa2,
0x1b, 0xfe, 0xe2, 0x9d, 0xe6, 0xea, 0x5a, 0x56, 0x5b, 0x2b, 0x0f, 0x33, 0xae,
0x07, 0xfa, 0x1e, 0xc8, 0xff, 0x5c, 0xa4, 0xf4, 0x20, 0xb8, 0xe7, 0x62, 0xaf,
0x16, 0x5d, 0xb4, 0x72, 0xe9, 0x5b, 0x51, 0xf3, 0x1e, 0x5a, 0xf2, 0xc8, 0xac,
0xde, 0x83, 0x83, 0x4f, 0x9d, 0xd5, 0x77, 0xaa, 0x26, 0x7a, 0xe1, 0x92, 0x3e,
0x94, 0x50, 0x5d, 0x4c, 0xb5, 0xc5, 0x34, 0xdb, 0x8b, 0x05, 0xdf, 0x77, 0x13,
0x92, 0x75, 0x94, 0xaa, 0xbb, 0x83, 0x78, 0xd6, 0x0b, 0xff, 0xbe, 0xbb, 0xae,
0x37, 0x3b, 0xd8, 0xa9, 0xe3, 0xbb, 0x8e, 0x49, 0x14, 0xd4, 0xd8, 0x87, 0x96,
0x4b, 0xb8, 0xc3, 0x7d, 0x18, 0xed, 0x43, 0x67, 0x36, 0xf5, 0x64, 0x53, 0xe2,
0x26, 0x19, 0x84, 0xd8, 0xca, 0x1d, 0x46, 0xf2, 0x06, 0x5a, 0xea, 0x85, 0x8c,
0x57, 0xb3, 0x83, 0xeb, 0xb7, 0x3e, 0x2e, 0x09, 0x41, 0xcb, 0x83, 0x15, 0x66,
0x56, 0x9f, 0x41, 0x4d, 0x19, 0xd4, 0x3f, 0x4c, 0x43, 0xc3, 0xb4, 0xb5, 0x8b,
0xdd, 0xdd, 0xf3, 0x4f, 0xd2, 0xac, 0x52, 0xf8, 0x3b, 0x6e, 0x27, 0x6f, 0xc0,
0x45, 0xdf, 0x52, 0x02, 0xfa, 0xa4, 0x03, 0x95, 0xc1, 0x61, 0x8c, 0x88, 0xcc,
0xcd, 0x61, 0x8c, 0xf3, 0xb4, 0xbf, 0x86, 0x86, 0x6a, 0x28, 0xf2, 0x16, 0x69,
0x6e, 0xd1, 0xd6, 0x28, 0x76, 0x47, 0xb1, 0xb3, 0x45, 0xfb, 0x5b, 0x74, 0x7b,
0x8b, 0xba, 0xaf, 0x39, 0x25, 0xc6, 0x1b, 0xc5, 0xbc, 0x1e, 0x33, 0x5b, 0x14,
0xd0, 0x4e, 0xc1, 0x12, 0xb1, 0x87, 0x8e, 0xe1, 0x6a, 0xe0, 0x18, 0x68, 0x6f,
0x92, 0xb8, 0x25, 0x4c, 0x05, 0x4b, 0x54, 0x24, 0xce, 0x95, 0x5a, 0xfb, 0xa9,
0xeb, 0xea, 0xa9, 0x88, 0xfe, 0xc4, 0xf2, 0xca, 0xd8, 0xff, 0x1c, 0xfa, 0xd3,
0x52, 0xde, 0x9e, 0xe7, 0xe3, 0xe5, 0xf7, 0x03, 0x23, 0xf3, 0xd9, 0x76, 0x1f,
0x52, 0xc7, 0x90, 0x3c, 0x76, 0xe7, 0x9f, 0x52, 0xc6, 0x90, 0x3e, 0x76, 0x79,
0x99, 0xda, 0xc7, 0xd0, 0x75, 0x17, 0x60, 0x79, 0x8e, 0x3c, 0x1f, 0xb9, 0x4f,
0x30, 0x9c, 0xc3, 0x56, 0x4c, 0xd2, 0x27, 0x16, 0x68, 0xeb, 0x04, 0xbb, 0x27,
0x58, 0xcc, 0xa1, 0xdd, 0x27, 0xa9, 0xf9, 0x05, 0xdb, 0xf9, 0xf1, 0xd9, 0xd1,
0x09, 0xce, 0x42, 0x70, 0x1a, 0x82, 0x6a, 0x0b, 0xaa, 0x38, 0x97, 0xd2, 0x4e,
0x2d, 0xdb, 0x97, 0x76, 0x3f, 0xe0, 0x14, 0x50, 0x9f, 0x62, 0x27, 0x91, 0xed,
0x27, 0xb2, 0xa0, 0x53, 0x91, 0x17, 0xb1, 0xb0, 0x34, 0x16, 0x96, 0xc6, 0x86,
0xc3, 0xd8, 0x68, 0x18, 0xa3, 0xc0, 0x1f, 0x53, 0x68, 0x02, 0x8b, 0x48, 0x60,
0xed, 0x75, 0x6c, 0xe0, 0x5e, 0x4f, 0x99, 0xbc, 0x53, 0xd9, 0x59, 0xa4, 0x30,
0x66, 0x89, 0x97, 0xfc, 0x99, 0xff, 0x47, 0x25, 0x0f, 0x1a, 0x7e, 0x79, 0xfc,
0xcc, 0xc1, 0x95, 0xc3, 0xe7, 0xaf, 0xde, 0x23, 0x80, 0x59, 0x59, 0x94, 0x16,
0x88, 0x96, 0x5c, 0x96, 0x92, 0x45, 0x2d, 0x54, 0x16, 0x82, 0x28, 0x93, 0x24,
0xba, 0xb2, 0xa8, 0x28, 0x8b, 0xf2, 0xb2, 0xc8, 0x9c, 0xe5, 0xa3, 0xae, 0x74,
0x5a, 0x11, 0x1e, 0x64, 0xa4, 0x91, 0x69, 0x8c, 0x02, 0xe3, 0x20, 0x9d, 0x3c,
0xe9, 0x74, 0x3b, 0x9d, 0x06, 0x25, 0xa7, 0xee, 0x54, 0x54, 0x16, 0x18, 0x58,
0xdc, 0xcf, 0x3a, 0xea, 0x00, 0x6f, 0xba, 0xf8, 0x18, 0x0f, 0x7d, 0x9f, 0x63,
0xf8, 0x10, 0xb9, 0xf9, 0xb9, 0x42, 0x6d, 0xd7, 0x43, 0x7f, 0xae, 0xfe, 0x9a,
0xa3, 0xe6, 0x6e, 0x50, 0x3e, 0xd7, 0xad, 0x27, 0xe9, 0xa4, 0xe2, 0xae, 0xe7,
0x59, 0x1d, 0xf3, 0xe7, 0x7b, 0x9c, 0x11, 0x48, 0x8b, 0x8f, 0xdc, 0xa3, 0x91,
0x7c, 0xd1, 0xd8, 0x1a, 0xa6, 0xf9, 0x28, 0x78, 0xec, 0xf2, 0x79, 0x1a, 0x65,
0x67, 0x90, 0x89, 0x57, 0x16, 0x64, 0x50, 0x51, 0xc6, 0x9d, 0x70, 0x76, 0x49,
0x06, 0x59, 0x33, 0x2e, 0x3e, 0x01, 0x92, 0x41, 0x0d, 0x19, 0x97, 0x5f, 0x38,
0xc8, 0xa0, 0xac, 0x77, 0x3d, 0x47, 0x22, 0x1d, 0xe1, 0x70, 0xe7, 0x5d, 0x87,
0x7a, 0x46, 0x2a, 0x92, 0x5f, 0x64, 0xcb, 0x5a, 0xa7, 0x1c, 0xee, 0xf7, 0x47,
0x1b, 0x59, 0x8c, 0x91, 0x35, 0x4e, 0x53, 0xcb, 0x34, 0xd5, 0x1c, 0x90, 0xf3,
0x80, 0xcb, 0xba, 0x68, 0xba, 0x15, 0xcd, 0x99, 0x34, 0x9a, 0xdc, 0xd1, 0x92,
0x78, 0xb2, 0x32, 0x9b, 0x55, 0xcc, 0x7e, 0x3d, 0x8b, 0xdd, 0xca, 0xe2, 0x99,
0x93, 0x68, 0x52, 0x69, 0xf8, 0xde, 0x68, 0x28, 0x58, 0xe3, 0x53, 0x3c, 0x87,
0x14, 0x71, 0x48, 0x9b, 0xe9, 0xcc, 0xcd, 0x85, 0x55, 0x82, 0x86, 0x86, 0x2d,
0xa8, 0x7d, 0xab, 0xd4, 0x4d, 0xc9, 0x26, 0xa6, 0xd1, 0x23, 0x4a, 0x60, 0xc5,
0x6a, 0x28, 0x9e, 0xa7, 0x67, 0xd1, 0x94, 0x31, 0x0c, 0xe3, 0xa2, 0xe8, 0x2f,
0x59, 0x43, 0xa9, 0x1a, 0xca, 0xd6, 0x90, 0x49, 0xee, 0x26, 0x4b, 0x43, 0x98,
0xfd, 0x2a, 0x22, 0x94, 0x91, 0x7d, 0x94, 0x1c, 0xa3, 0x64, 0xd7, 0xd0, 0x81,
0x13, 0x5e, 0x27, 0x6c, 0x9a, 0xf3, 0x10, 0x8e, 0x86, 0xe4, 0x7c, 0x99, 0x86,
0x2a, 0x34, 0xd4, 0x3e, 0x44, 0x5d, 0x92, 0x29, 0xdb, 0xae, 0xa1, 0x2e, 0x0d,
0xd5, 0x6b, 0xa8, 0x49, 0x43, 0xcd, 0x1a, 0x6a, 0x13, 0x38, 0x9b, 0x1b, 0xcc,
0xbd, 0x21, 0x1d, 0xa2, 0x68, 0xa8, 0x47, 0xee, 0xe0, 0xf2, 0x52, 0x14, 0xc7,
0xb2, 0xd2, 0x58, 0x16, 0x6e, 0x61, 0x6f, 0xd5, 0x16, 0xf3, 0x07, 0x16, 0x30,
0x95, 0x1e, 0x8e, 0x58, 0xe9, 0x21, 0xb1, 0x74, 0xf6, 0xb9, 0x2d, 0xe0, 0x82,
0xe3, 0x6f, 0xf3, 0x61, 0xed, 0xfa, 0x46, 0x50, 0x33, 0x44, 0x4e, 0xfe, 0xc4,
0xde, 0x58, 0xc2, 0x50, 0xac, 0x48, 0x06, 0x62, 0x69, 0x2c, 0x96, 0x26, 0x63,
0xa9, 0x3b, 0x96, 0xfa, 0x62, 0xa9, 0x3f, 0x96, 0x38, 0x7c, 0x38, 0x96, 0x46,
0x79, 0x57, 0xb9, 0x66, 0xa6, 0xbe, 0x5e, 0x79, 0xe5, 0xcb, 0x1e, 0x83, 0xd4,
0x97, 0x9f, 0x8e, 0x05, 0x4a, 0x02, 0x3f, 0x45, 0x4b, 0xe9, 0xda, 0xbb, 0x05,
0x89, 0xbc, 0x91, 0x5a, 0x6a, 0xd0, 0x8a, 0x97, 0xdf, 0x5b, 0xb4, 0x54, 0xaf,
0xa5, 0xe9, 0x0a, 0xf1, 0x75, 0x84, 0x51, 0xea, 0xd0, 0x52, 0x89, 0x86, 0xed,
0x92, 0x33, 0xf2, 0x2e, 0x21, 0x34, 0xa6, 0xa5, 0x49, 0xde, 0xcb, 0x62, 0x17,
0x5b, 0xe9, 0x92, 0x2a, 0x6a, 0x36, 0x68, 0xe8, 0x7f, 0xdf, 0xd0, 0xfa, 0xe6,
0x59, 0xac, 0xa3, 0x52, 0x1d, 0x15, 0x70, 0xc1, 0x66, 0xd6, 0x91, 0xdd, 0xc2,
0x1c, 0x16, 0x76, 0x0e, 0xe4, 0xcb, 0xa7, 0xa3, 0x0a, 0x9e, 0xd6, 0xe9, 0xa8,
0x41, 0x47, 0x25, 0x3a, 0xb2, 0xea, 0x2e, 0x77, 0xac, 0xa3, 0x49, 0x1d, 0xf9,
0xbe, 0xf3, 0xe1, 0x8b, 0x57, 0xe8, 0xe8, 0x1e, 0x72, 0xe9, 0xbe, 0x29, 0x00,
0x77, 0x74, 0xb4, 0xaf, 0xa3, 0xef, 0x98, 0x89, 0xf4, 0x2a, 0x0a, 0x99, 0xe2,
0xee, 0x7c, 0xc8, 0xa2, 0x9f, 0xa9, 0xfb, 0x59, 0xf7, 0x1e, 0xfa, 0xf6, 0x20,
0xff, 0xb7, 0xa7, 0xb0, 0xf0, 0x77, 0xf2, 0xdf, 0x2f, 0x8a, 0x63, 0x9b, 0x2a,
0xe6, 0x56, 0xf9, 0xa6, 0x96, 0x76, 0x42, 0x6d, 0x9f, 0x8f, 0x47, 0x4a, 0x73,
0x90, 0xc9, 0x23, 0x20, 0x9d, 0xad, 0xbf, 0xba, 0xbd, 0xec, 0xab, 0xcf, 0xd3,
0x90, 0x59, 0xda, 0x8a, 0xf6, 0x79, 0xea, 0x9a, 0xbf, 0x88, 0xec, 0x35, 0x92,
0xad, 0xd1, 0xb7, 0xfd, 0x97, 0xff, 0x85, 0x7d, 0x35, 0xca, 0xba, 0x92, 0xb1,
0xf7, 0xbf, 0xf5, 0xc4, 0xb2, 0x9b, 0x21, 0x6c, 0x9c, 0x3b, 0x68, 0xad, 0xb1,
0xac, 0x23, 0x56, 0xea, 0xae, 0x37, 0x96, 0x0d, 0xf0, 0x5c, 0xe3, 0x06, 0xd9,
0x1f, 0x55, 0x45, 0xb2, 0xb3, 0x51, 0xa6, 0x99, 0xc1, 0xcd, 0x63, 0x74, 0xec,
0xb2, 0x29, 0x23, 0x69, 0x3f, 0xb4, 0x3e, 0x3c, 0xff, 0x8b, 0x9c, 0x9f, 0x78,
0x63, 0x99, 0xdf, 0x02, 0x0b, 0x5c, 0x60, 0x25, 0x26, 0xd6, 0xfd, 0x53, 0xff,
0x05, 0x76, 0xa0, 0x22, 0x3f, 0xa1, 0x59, 0x19, 0x25, 0x1b, 0x28, 0xd5, 0x40,
0xc7, 0x2a, 0x3a, 0x95, 0x8e, 0xc3, 0xa3, 0x37, 0x59, 0xcc, 0x26, 0x23, 0x3f,
0x3f, 0x0a, 0xf4, 0xe3, 0x42, 0xca, 0x8f, 0x62, 0x1b, 0x91, 0xda, 0xc4, 0xc2,
0xfd, 0x68, 0xeb, 0xb7, 0x2a, 0x21, 0x92, 0x69, 0xd8, 0xc8, 0x46, 0x25, 0x41,
0x12, 0x6b, 0x65, 0xd6, 0x8f, 0x3b, 0x5e, 0x3f, 0xfb, 0x7f, 0x92, 0x0e, 0x2f,
0x54, 0x99, 0x85, 0x99, 0xee, 0x77, 0x0a, 0x65, 0x5f, 0x3d, 0xc5, 0x6a, 0xa7,
0x7c, 0x13, 0xb6, 0xfb, 0x91, 0xc3, 0x8f, 0xba, 0x37, 0x58, 0x9f, 0xa0, 0xe5,
0xb2, 0x2e, 0xb6, 0xdb, 0x81, 0x06, 0xf9, 0x08, 0xe4, 0xd8, 0x40, 0xa7, 0xe2,
0x94, 0xb2, 0xdb, 0x8f, 0xfa, 0x38, 0x64, 0xb6, 0x99, 0x2d, 0x34, 0x33, 0xb1,
0xf5, 0x75, 0x07, 0x68, 0x10, 0xa7, 0xaa, 0xf6, 0x58, 0xe6, 0x88, 0x65, 0x47,
0x3b, 0x94, 0xf9, 0xd5, 0xf8, 0xb1, 0x98, 0x98, 0xfc, 0x5f, 0xe0, 0x40, 0xb0,
0x8d, 0x55, 0x4e, 0xb0, 0x86, 0x87, 0x0e, 0x1b, 0x19, 0x8d, 0x1d, 0x63, 0xf2,
0x18, 0xe5, 0x26, 0x36, 0x6a, 0xc6, 0xcd, 0xdf, 0xd8, 0x0e, 0x04, 0x20, 0x57,
0x45, 0x8e, 0x9f, 0xb4, 0xb5, 0x4a, 0x63, 0x58, 0xdc, 0x21, 0xd5, 0x57, 0x2b,
0xc7, 0x68, 0xdd, 0x60, 0xdb, 0xf7, 0x79, 0xe7, 0x81, 0x80, 0x3c, 0x78, 0x4d,
0xa0, 0x1a, 0x37, 0x32, 0xf9, 0x98, 0xe6, 0x8f, 0xb1, 0xfa, 0x69, 0x1f, 0x37,
0x71, 0x0e, 0xc2, 0x99, 0xf6, 0x85, 0xba, 0xab, 0x5d, 0x82, 0x18, 0x39, 0x10,
0xf7, 0x04, 0x1d, 0x71, 0x9d, 0xc6, 0xb6, 0x16, 0x68, 0xf0, 0x5e, 0xbf, 0x1b,
0x6b, 0x4f, 0xcc, 0x70, 0x2e, 0x58, 0x3c, 0xc6, 0xca, 0xb1, 0xa4, 0xcd, 0x0e,
0x68, 0xe4, 0x40, 0xf8, 0x81, 0xb3, 0x9f, 0x1b, 0xb8, 0xf6, 0x3a, 0x46, 0xef,
0x02, 0x1b, 0x58, 0x60, 0x34, 0xab, 0x66, 0x0b, 0xdc, 0xbe, 0xf1, 0xcb, 0x66,
0x81, 0xd9, 0xbc, 0x1f, 0xad, 0x9d, 0xe9, 0x6a, 0xa0, 0xf4, 0x1c, 0xe3, 0xf8,
0x18, 0xca, 0x2b, 0x2a, 0x2f, 0x26, 0xfa, 0xd8, 0xdc, 0x90, 0xfc, 0xf2, 0x24,
0xed, 0x45, 0x30, 0x8f, 0x06, 0xa7, 0x3c, 0x6f, 0x77, 0x33, 0x87, 0x5b, 0x8c,
0xb6, 0xf1, 0x90, 0xb5, 0x1c, 0x32, 0x0a, 0xf5, 0x22, 0xc2, 0xcb, 0xfd, 0x58,
0x2f, 0x14, 0x79, 0x6e, 0x58, 0x37, 0x58, 0xac, 0x17, 0xf1, 0x5e, 0xf8, 0xc0,
0x0a, 0xdf, 0x79, 0xb2, 0x0c, 0xe4, 0x44, 0xe7, 0x45, 0xa6, 0x74, 0xf7, 0x20,
0xc1, 0x8b, 0x24, 0x2f, 0x32, 0xbc, 0x50, 0x2a, 0x78, 0x3a, 0x78, 0x84, 0x11,
0x71, 0x71, 0x21, 0x31, 0x88, 0xb5, 0x84, 0x8b, 0xec, 0xcd, 0x23, 0x8c, 0x1f,
0xa1, 0xcc, 0xc6, 0xc2, 0x1c, 0xa8, 0xd6, 0x63, 0x85, 0x33, 0x73, 0xfd, 0x06,
0x3b, 0xbb, 0x57, 0xf5, 0x69, 0x53, 0x24, 0x1b, 0x3b, 0xc2, 0x24, 0xc7, 0x9e,
0x38, 0x82, 0x8b, 0x27, 0xc3, 0x47, 0xa8, 0xfe, 0xbc, 0xe2, 0x73, 0x91, 0xed,
0x4c, 0x61, 0x3d, 0x29, 0x42, 0xa7, 0x1d, 0x61, 0xff, 0x08, 0xf3, 0x47, 0xb8,
0xe7, 0x9e, 0x6d, 0x0e, 0x5e, 0x3d, 0xc2, 0xc6, 0x11, 0xce, 0x25, 0x92, 0x5d,
0xa5, 0x50, 0x07, 0x92, 0xd5, 0xf7, 0x29, 0x19, 0xbb, 0x17, 0x0e, 0x2f, 0x2a,
0xbd, 0xa8, 0x92, 0x01, 0x8d, 0x5e, 0xb4, 0x78, 0x71, 0xf1, 0xad, 0x99, 0x55,
0x2f, 0x6d, 0x78, 0xcf, 0x39, 0xd3, 0x8b, 0x71, 0x01, 0x9c, 0xf0, 0xc2, 0x75,
0xfe, 0x21, 0x1a, 0xda, 0x99, 0x60, 0xfb, 0x13, 0x9c, 0xd2, 0x37, 0x58, 0xc7,
0x06, 0xcb, 0x53, 0x29, 0x14, 0x26, 0x15, 0x67, 0xcc, 0x00, 0x37, 0x05, 0xbb,
0xe9, 0xe6, 0x06, 0x1b, 0xdf, 0x60, 0xf6, 0x2e, 0x16, 0x7b, 0xb5, 0x6a, 0x10,
0xf1, 0x9c, 0x70, 0xf2, 0x66, 0x98, 0x79, 0x86, 0x51, 0xa2, 0x1f, 0x19, 0x78,
0x29, 0xc5, 0x4f, 0x91, 0xee, 0xa7, 0x48, 0xf1, 0xa3, 0x74, 0xf1, 0xe2, 0x67,
0x04, 0x4b, 0xe2, 0xc6, 0x62, 0x96, 0x1f, 0xe5, 0xf8, 0xdd, 0x61, 0xee, 0xf3,
0x0f, 0x87, 0xf8, 0x46, 0x90, 0xc7, 0xc6, 0xb9, 0x53, 0x35, 0xb6, 0x42, 0xa7,
0x9f, 0xf2, 0x21, 0xdc, 0x35, 0x10, 0x11, 0x59, 0x67, 0x23, 0x5c, 0x79, 0x84,
0x70, 0xaf, 0x60, 0x8f, 0xf3, 0xf4, 0xd4, 0x3a, 0xf5, 0xbf, 0x52, 0x5a, 0xcc,
0xb2, 0x0e, 0x29, 0xe7, 0x90, 0x2a, 0x8f, 0xa9, 0xea, 0x98, 0x0b, 0x87, 0x08,
0x0a, 0x3f, 0xc4, 0x6e, 0x2c, 0xba, 0xaf, 0x4d, 0xbc, 0x9d, 0x76, 0x75, 0x6d,
0x82, 0x25, 0xb6, 0x32, 0x43, 0x2b, 0x3b, 0x99, 0x67, 0xe1, 0xf7, 0xc5, 0xbf,
0xbc, 0xcf, 0xe5, 0x73, 0xa7, 0x81, 0x49, 0x52, 0xf4, 0xac, 0x92, 0xf9, 0xdb,
0x24, 0xb2, 0x4c, 0x8e, 0xa0, 0xd4, 0x8b, 0x2f, 0x4f, 0x95, 0x58, 0x99, 0xfd,
0x85, 0x5b, 0x1b, 0x6c, 0x2c, 0x9a, 0xa2, 0xf3, 0xb0, 0x61, 0x63, 0xfd, 0x5c,
0x16, 0x0a, 0x3f, 0xf6, 0x28, 0x84, 0xa5, 0x7e, 0xe5, 0xe2, 0x6a, 0x2c, 0xc3,
0xc2, 0x8c, 0x16, 0x16, 0xb2, 0xc1, 0xc2, 0x38, 0xcd, 0xfa, 0xa5, 0xb0, 0x40,
0xbe, 0x25, 0x3e, 0x0d, 0xc7, 0xf5, 0x1d, 0xad, 0x9a, 0x30, 0x62, 0x63, 0x8b,
0x6d, 0x6c, 0xa5, 0x8d, 0xed, 0x44, 0xd3, 0x7e, 0xf4, 0xe5, 0x33, 0x8d, 0x68,
0x62, 0x81, 0xb2, 0x30, 0x71, 0x53, 0xe4, 0x6b, 0xa5, 0x36, 0x16, 0xaa, 0xa1,
0x08, 0x01, 0x90, 0xd3, 0x92, 0x2d, 0x3a, 0xbb, 0x66, 0xe5, 0xfc, 0xad, 0x88,
0xd3, 0x90, 0x5e, 0x43, 0xb3, 0x36, 0xb6, 0x20, 0x8f, 0x31, 0x45, 0x43, 0x41,
0x36, 0x44, 0x2b, 0xf4, 0x0e, 0x70, 0x49, 0x96, 0xa6, 0x63, 0x99, 0x3a, 0x26,
0x1f, 0x44, 0x73, 0xbf, 0x70, 0x95, 0x52, 0xae, 0x98, 0xdd, 0x94, 0xa6, 0xa1,
0x4c, 0xd1, 0x57, 0xae, 0x86, 0xf2, 0x35, 0x17, 0x9e, 0x0d, 0xcf, 0x39, 0x2e,
0x4a, 0x8d, 0x1a, 0x2a, 0xac, 0xc1, 0x6e, 0xb7, 0xc4, 0xdc, 0x94, 0x6b, 0x60,
0xdc, 0xf3, 0x68, 0x9d, 0x46, 0x94, 0x9b, 0xf1, 0x9a, 0xc6, 0x5c, 0x84, 0xd9,
0x58, 0x64, 0x2c, 0x69, 0xb8, 0xc6, 0xe9, 0x1f, 0x64, 0x85, 0x4f, 0xfb, 0xab,
0x2e, 0x7f, 0x0e, 0x33, 0xcd, 0xcd, 0x32, 0x05, 0x6b, 0xcc, 0x72, 0xad, 0xfc,
0xce, 0xc0, 0x3b, 0xca, 0x39, 0xd1, 0xed, 0x74, 0x35, 0xdb, 0x7c, 0xa9, 0xef,
0x98, 0x9d, 0xeb, 0xb7, 0x7b, 0x86, 0x7f, 0xd3, 0xc3, 0xf7, 0x79, 0x8b, 0x0f,
0xbe, 0x08, 0x23, 0x75, 0x97, 0xf5, 0x4c, 0x08, 0x57, 0x28, 0x6a, 0x2d, 0x17,
0xe0, 0xa4, 0xee, 0xe7, 0xeb, 0x69, 0x61, 0x5e, 0x0b, 0x1b, 0x36, 0x73, 0x61,
0xc1, 0x8e, 0x6e, 0xd3, 0xcd, 0x40, 0x0c, 0xed, 0x32, 0xdf, 0x72, 0x52, 0x9c,
0x96, 0xf4, 0x1c, 0x3b, 0x31, 0x8e, 0x19, 0xe2, 0x58, 0xa2, 0x96, 0x0c, 0xb2,
0x92, 0x4b, 0xde, 0xa3, 0xf4, 0x3d, 0x5f, 0x14, 0xff, 0xc8, 0x0d, 0xaf, 0xfb,
0xee, 0x97, 0x64, 0xa6, 0x48, 0x73, 0xc7, 0x6f, 0x59, 0x3e, 0x62, 0x6b, 0x47,
0x22, 0x80, 0x55, 0xc3, 0x76, 0x6d, 0x58, 0x93, 0xcf, 0xee, 0xbb, 0x33, 0x58,
0xc5, 0xa3, 0x49, 0x7e, 0x6c, 0x7d, 0x8b, 0xcc, 0xbb, 0x94, 0x1c, 0x4d, 0xa9,
0xd1, 0x62, 0xa6, 0x43, 0x83, 0xec, 0xe4, 0x26, 0x9b, 0x69, 0x43, 0xf7, 0x02,
0xea, 0xaf, 0x5b, 0x22, 0xc4, 0xac, 0x0b, 0x8d, 0xcc, 0xc2, 0x05, 0x6c, 0x96,
0x9e, 0x72, 0xf4, 0xbe, 0x7f, 0xb1, 0x64, 0xb1, 0x2c, 0xf6, 0x97, 0xea, 0x1f,
0x85, 0x55, 0x22, 0xb1, 0x00, 0x61, 0x0f, 0x3b, 0x4c, 0xf2, 0x04, 0xcb, 0xf4,
0x54, 0xc1, 0xeb, 0x6b, 0xca, 0x58, 0xd0, 0xbf, 0x68, 0xe9, 0xe3, 0xb0, 0x4a,
0x3d, 0x37, 0x2d, 0xd1, 0x50, 0xc9, 0xb4, 0x6a, 0xa6, 0x53, 0xb3, 0x59, 0x37,
0x65, 0xbe, 0x4b, 0x4e, 0x3d, 0x6d, 0x85, 0xb0, 0xdd, 0x10, 0x66, 0xe7, 0xb8,
0x55, 0x7a, 0x2a, 0xd1, 0x93, 0x55, 0xf4, 0x5a, 0xac, 0xa7, 0x52, 0x3d, 0x95,
0xeb, 0xe9, 0xfe, 0xce, 0xf7, 0x77, 0x0f, 0xce, 0xc1, 0x1c, 0xe9, 0x9f, 0xf7,
0xf0, 0xf4, 0xa8, 0x92, 0x79, 0x2b, 0x79, 0x97, 0xcd, 0x56, 0xd6, 0xc6, 0xe9,
0x3f, 0xc0, 0xc4, 0x06, 0x9e, 0x72, 0x7d, 0xc8, 0x79, 0x88, 0x57, 0x2e, 0x76,
0xb2, 0x95, 0x4e, 0x96, 0x70, 0xc2, 0x92, 0x4e, 0xc4, 0x40, 0xb4, 0x2b, 0x4c,
0xb7, 0xc2, 0xe4, 0xef, 0x50, 0x09, 0xcd, 0xa6, 0xa7, 0x2e, 0x3d, 0x8d, 0xe9,
0x69, 0x52, 0xef, 0xbb, 0x72, 0xe9, 0x33, 0x1c, 0x42, 0x33, 0x98, 0x59, 0x0d,
0x72, 0xe9, 0x25, 0x3d, 0x9b, 0xa0, 0x61, 0x49, 0x9a, 0xcb, 0x1b, 0xb5, 0xa7,
0xa7, 0xba, 0x62, 0xa8, 0x5e, 0x2d, 0xfd, 0x24, 0x57, 0x87, 0xa2, 0xc2, 0xf3,
0xaa, 0xce, 0x49, 0xd6, 0x33, 0x29, 0x0a, 0xfd, 0x36, 0x36, 0x64, 0xf3, 0x41,
0x05, 0x21, 0xdd, 0x4c, 0xa6, 0xf1, 0x64, 0xca, 0x3d, 0x66, 0xf9, 0x9c, 0x0e,
0xd2, 0xda, 0x58, 0xf4, 0x6b, 0x87, 0x9f, 0x55, 0x71, 0xf3, 0xae, 0x24, 0x42,
0x61, 0x8d, 0x50, 0x2c, 0x27, 0xd3, 0x9a, 0x38, 0x30, 0xaa, 0x4b, 0x66, 0xda,
0x0f, 0x86, 0x8e, 0xd9, 0x66, 0x32, 0xb1, 0xab, 0x1b, 0x1c, 0x22, 0x37, 0xe0,
0x45, 0x77, 0x32, 0xc9, 0xff, 0xab, 0xc9, 0xc4, 0x2b, 0xc2, 0x23, 0x14, 0x51,
0x11, 0xe7, 0x84, 0xd7, 0x5a, 0xcd, 0xa2, 0x1f, 0x1f, 0x6d, 0x44, 0x75, 0x20,
0xb2, 0x3e, 0x9e, 0x0b, 0x11, 0xe0, 0x20, 0x03, 0xa9, 0xa5, 0xb7, 0x45, 0x36,
0xeb, 0x98, 0x9b, 0x53, 0x58, 0x8d, 0x4a, 0xe1, 0x14, 0x84, 0x3a, 0x1f, 0xad,
0x58, 0x8a, 0x56, 0x88, 0xaf, 0xb4, 0x50, 0xa8, 0x15, 0xf3, 0xcf, 0x04, 0x4b,
0xd4, 0x5b, 0xef, 0x60, 0x4d, 0xc2, 0xe7, 0xca, 0x35, 0x50, 0x89, 0x0d, 0x93,
0x43, 0xe2, 0xea, 0x95, 0x81, 0x8a, 0x0c, 0x77, 0x5b, 0x1a, 0xd5, 0xf5, 0xac,
0x56, 0x38, 0x56, 0x9d, 0x06, 0xea, 0x91, 0xab, 0x06, 0x0d, 0x34, 0x62, 0xa0,
0x7e, 0x03, 0x0d, 0xf1, 0xf2, 0x66, 0x17, 0x73, 0x73, 0x6d, 0xa4, 0x5d, 0x64,
0xba, 0x45, 0x79, 0xe2, 0xe7, 0x9a, 0x75, 0xd3, 0x40, 0xee, 0xf3, 0xbe, 0x7c,
0x22, 0xb8, 0x3e, 0x8d, 0x9a, 0xd2, 0xee, 0x74, 0xdf, 0x9f, 0x46, 0x43, 0x72,
0x71, 0x2a, 0x8d, 0x66, 0xd2, 0xbe, 0x61, 0xf8, 0x1c, 0xa4, 0x91, 0x47, 0x86,
0x0d, 0x72, 0x56, 0x50, 0x8b, 0x2b, 0x18, 0xee, 0x41, 0x16, 0x60, 0x61, 0xc1,
0x16, 0x76, 0x92, 0x45, 0x47, 0x09, 0xf0, 0x54, 0x4b, 0xee, 0x8b, 0x91, 0x82,
0x8d, 0x14, 0xe0, 0x10, 0xc6, 0x65, 0xb0, 0xf1, 0xa2, 0x79, 0xb4, 0x91, 0x62,
0x78, 0x29, 0xf7, 0x90, 0x92, 0x6e, 0x68, 0xc4, 0xd7, 0x24, 0x8c, 0xdc, 0xbc,
0x4a, 0xf8, 0x5f, 0xe7, 0xff, 0x8d, 0xe7, 0x4a, 0x44, 0x20, 0x78, 0x15, 0x07,
0xe8, 0x8d, 0xa4, 0x28, 0xd4, 0x33, 0x8b, 0x9e, 0xf1, 0x42, 0x68, 0x22, 0x32,
0x6b, 0x98, 0x14, 0xe1, 0x61, 0x11, 0x8b, 0x2c, 0xc3, 0x48, 0xc6, 0xf3, 0xde,
0xb2, 0xfc, 0x14, 0xfb, 0xd7, 0x2d, 0x2b, 0xac, 0xd0, 0x48, 0x16, 0x19, 0x56,
0xe9, 0xa6, 0x83, 0xcf, 0x4b, 0xb9, 0x44, 0x2f, 0xeb, 0x66, 0x1e, 0x13, 0x1c,
0x12, 0xb4, 0xce, 0x48, 0x0d, 0x52, 0x66, 0x67, 0x8f, 0xed, 0xef, 0xb1, 0x3b,
0xb6, 0x70, 0x42, 0x2e, 0x25, 0xe5, 0xde, 0x15, 0xfa, 0xc8, 0x25, 0xcb, 0x65,
0x40, 0x7d, 0x2e, 0x35, 0xc9, 0xe5, 0xd5, 0x70, 0xe6, 0xff, 0x40, 0xd0, 0xfb,
0xee, 0x9b, 0x2c, 0xdc, 0xc1, 0x32, 0x7e, 0x62, 0x71, 0x33, 0x3f, 0x3d, 0xeb,
0x7c, 0xb0, 0xcf, 0xcc, 0x7c, 0x76, 0x4d, 0xc1, 0x21, 0x2b, 0xe2, 0xda, 0x77,
0x2c, 0x56, 0x31, 0x19, 0xab, 0xd8, 0xab, 0x66, 0x87, 0xd5, 0x5c, 0xfb, 0x30,
0xb3, 0x10, 0x77, 0xbd, 0x93, 0xac, 0xe3, 0x7e, 0x35, 0xdf, 0x8d, 0xbd, 0x64,
0x3a, 0x4c, 0x96, 0x2c, 0x99, 0x0a, 0xd9, 0x6c, 0xa5, 0x02, 0x2f, 0x49, 0xb7,
0x3e, 0x43, 0x0c, 0xd4, 0xea, 0xc6, 0x40, 0x84, 0xa2, 0xd5, 0xc1, 0xf2, 0x9f,
0x4c, 0xd7, 0xb1, 0x55, 0x15, 0xdb, 0x50, 0xb1, 0x70, 0xe9, 0xad, 0xf8, 0x58,
0x03, 0xc5, 0x1b, 0x88, 0xcb, 0xef, 0xcd, 0x47, 0x0f, 0xcf, 0xc9, 0x6c, 0x71,
0x81, 0xad, 0x70, 0x9b, 0x21, 0x44, 0xcb, 0xc2, 0xb4, 0x6c, 0x78, 0x83, 0x8d,
0x72, 0xd1, 0x7e, 0x33, 0x85, 0x8d, 0xa7, 0xb0, 0x2c, 0x03, 0xc1, 0xc4, 0x37,
0xb8, 0xd0, 0x40, 0x16, 0x69, 0x9f, 0xa3, 0x23, 0x15, 0x31, 0x91, 0x0a, 0xbf,
0x72, 0x66, 0xbb, 0xd2, 0x25, 0xb3, 0x46, 0xa5, 0x81, 0xaa, 0x0c, 0xe2, 0x43,
0x17, 0x8a, 0x53, 0xbd, 0x82, 0xf2, 0xfc, 0x98, 0x99, 0x4b, 0x70, 0x27, 0x05,
0xa5, 0x91, 0x3a, 0x8d, 0x72, 0xa3, 0x15, 0xf9, 0x9c, 0x28, 0x27, 0x02, 0xc8,
0x15, 0xf0, 0xcd, 0x17, 0xd1, 0x8c, 0x2c, 0x5e, 0x98, 0x70, 0x8b, 0x06, 0x5a,
0x31, 0xd0, 0xaa, 0x81, 0x36, 0x38, 0x89, 0xaa, 0x15, 0xb6, 0x47, 0xaa, 0x99,
0xed, 0x36, 0x5b, 0x3c, 0x66, 0x2b, 0x3e, 0xb1, 0x5a, 0xd9, 0xc5, 0xaa, 0xba,
0xee, 0x30, 0x68, 0x68, 0x0a, 0x45, 0xc8, 0x77, 0x53, 0x65, 0x32, 0xf9, 0x76,
0x30, 0x41, 0xf6, 0x01, 0x52, 0xa8, 0x41, 0xa0, 0xd5, 0x27, 0xb2, 0xa6, 0x44,
0x16, 0xb7, 0xc8, 0x5c, 0x8f, 0x6b, 0x72, 0x41, 0x8d, 0xad, 0xd8, 0x98, 0x11,
0x6d, 0xda, 0x23, 0x15, 0xa9, 0xbb, 0x38, 0x8a, 0x86, 0x29, 0x8f, 0xed, 0x39,
0x59, 0xe9, 0xf3, 0x2d, 0xa1, 0xac, 0x30, 0x91, 0x2c, 0x89, 0x24, 0xff, 0x8b,
0x88, 0x63, 0x3d, 0x8b, 0x12, 0x5c, 0xb1, 0x1c, 0xc7, 0x46, 0xee, 0xd7, 0x05,
0x31, 0x71, 0x33, 0x6d, 0xb0, 0x17, 0xf5, 0x8f, 0x27, 0x3d, 0xe9, 0x10, 0x7c,
0xe0, 0x17, 0xa9, 0x58, 0xfb, 0x38, 0x29, 0x9b, 0x9d, 0xcc, 0x30, 0x47, 0x2b,
0x9a, 0x12, 0x25, 0x5a, 0x88, 0x9c, 0x67, 0x81, 0xad, 0x88, 0x30, 0x5c, 0xf0,
0x69, 0xa4, 0x81, 0x14, 0x11, 0x32, 0x8f, 0x68, 0x0d, 0xa4, 0x33, 0x5c, 0xa6,
0x90, 0x09, 0x66, 0x99, 0xb8, 0x34, 0x81, 0xe3, 0x49, 0x76, 0x3a, 0x79, 0xa7,
0x3c, 0x5d, 0xc9, 0xe6, 0xb8, 0xe8, 0x9b, 0x88, 0x60, 0x2e, 0x29, 0xd0, 0xb4,
0xbe, 0xc2, 0x10, 0xf3, 0x9e, 0xc8, 0xa7, 0x2d, 0xb2, 0xcc, 0x45, 0x16, 0x52,
0xc8, 0x22, 0xb8, 0xd9, 0x66, 0x38, 0xbf, 0xb3, 0xc2, 0x2a, 0x36, 0xd8, 0x94,
0x5a, 0x31, 0x23, 0x7d, 0x49, 0x5f, 0x5a, 0x86, 0x6c, 0x35, 0x33, 0x7e, 0x19,
0xc8, 0xbd, 0x87, 0x80, 0x38, 0x0a, 0x8e, 0xa3, 0x1d, 0x95, 0x62, 0x5f, 0x48,
0x85, 0x10, 0x0e, 0x51, 0xc7, 0x71, 0x1f, 0x5b, 0x11, 0x98, 0xa1, 0x90, 0x2f,
0xa1, 0x73, 0x50, 0x71, 0x1a, 0xaa, 0x84, 0x7b, 0x1a, 0x1a, 0x47, 0x11, 0x71,
0x34, 0x9c, 0xc1, 0x46, 0x33, 0x38, 0xcf, 0xa7, 0x28, 0xbc, 0x21, 0x24, 0x7d,
0x4c, 0x43, 0x46, 0x0c, 0x8f, 0x54, 0x44, 0x45, 0x2a, 0x7c, 0x1d, 0x46, 0xc7,
0x51, 0x8c, 0xa8, 0xd2, 0xc6, 0x11, 0x8a, 0x6f, 0xa3, 0x25, 0x50, 0x51, 0x93,
0xa2, 0x70, 0xa6, 0x28, 0x32, 0xe2, 0xe8, 0xca, 0xf4, 0x01, 0x22, 0x22, 0x15,
0x69, 0x71, 0x34, 0x93, 0xc0, 0xa7, 0x92, 0x40, 0x73, 0x09, 0x34, 0x96, 0x40,
0x93, 0x09, 0xd2, 0xed, 0xb9, 0x04, 0xda, 0x4d, 0xa0, 0xd6, 0x1d, 0xd6, 0xb1,
0xc3, 0xe2, 0xa6, 0x99, 0x7e, 0x9a, 0x2d, 0x26, 0xd0, 0x4a, 0x82, 0xef, 0x43,
0x20, 0x09, 0xb4, 0x91, 0x40, 0x21, 0x7a, 0x0a, 0xd3, 0x93, 0x56, 0xa3, 0xd0,
0x69, 0x14, 0xad, 0xb7, 0xd9, 0xe4, 0x4d, 0xdc, 0x12, 0xfd, 0xa8, 0x15, 0xfa,
0x1f, 0x19, 0xde, 0x4b, 0xf8, 0x71, 0x8b, 0x85, 0xb5, 0xc7, 0x2a, 0xba, 0x62,
0x15, 0x9b, 0xc9, 0x0a, 0x77, 0xb2, 0xe2, 0x24, 0x81, 0x54, 0x7a, 0xe2, 0xff,
0xf5, 0x26, 0x34, 0x38, 0xd9, 0x41, 0x02, 0x79, 0x38, 0xf6, 0x51, 0x02, 0x79,
0x13, 0x68, 0x2f, 0x81, 0x0e, 0x13, 0x2e, 0xad, 0x7a, 0xb4, 0x9e, 0x62, 0xb8,
0xe8, 0x0f, 0xd7, 0x13, 0x34, 0x3c, 0x4d, 0xd3, 0x53, 0xa6, 0x9e, 0x02, 0x56,
0x58, 0xf0, 0x0a, 0x3b, 0x4e, 0x50, 0x9c, 0x26, 0x28, 0x92, 0xf5, 0x94, 0xca,
0x2b, 0x22, 0xdb, 0x99, 0xa6, 0x9d, 0x9d, 0xec, 0x30, 0xd5, 0xae, 0xe4, 0x69,
0xe8, 0x29, 0xfe, 0xfc, 0xd5, 0xaa, 0x23, 0x95, 0xc2, 0xcb, 0x17, 0xb2, 0x4c,
0xbe, 0x47, 0x49, 0x79, 0x29, 0x8a, 0xcc, 0x1f, 0x87, 0x1d, 0xb2, 0x3a, 0x1b,
0x6b, 0x90, 0x34, 0xc3, 0xff, 0x5b, 0xde, 0xd7, 0x00, 0xb5, 0x75, 0xa4, 0x09,
0x4e, 0xf7, 0xf7, 0x35, 0xb1, 0xc7, 0xd9, 0xb3, 0x77, 0x92, 0xdd, 0xe4, 0xca,
0x73, 0x9b, 0xdc, 0x26, 0xb7, 0xf1, 0x6d, 0x72, 0x15, 0x5f, 0x65, 0xea, 0x92,
0xda, 0x49, 0x55, 0xb2, 0x97, 0xdc, 0x25, 0x5b, 0x93, 0xda, 0x64, 0xd7, 0xbe,
0xca, 0xd4, 0x26, 0x75, 0xd9, 0xda, 0xc9, 0x96, 0x73, 0x95, 0xdd, 0xdb, 0xa9,
0x4d, 0xf6, 0x92, 0x2b, 0x67, 0xce, 0x02, 0x84, 0xc1, 0x20, 0xfe, 0x8c, 0xb0,
0x84, 0x25, 0xfe, 0x8c, 0x00, 0x61, 0x04, 0x08, 0x10, 0x46, 0xfc, 0xcb, 0x48,
0x80, 0x00, 0x61, 0x84, 0x11, 0x20, 0x7e, 0x6c, 0x04, 0x12, 0x20, 0x40, 0x58,
0x92, 0x01, 0x83, 0x0d, 0xb6, 0xaf, 0xfb, 0x3d, 0xc9, 0x26, 0x33, 0x3b, 0xbb,
0x93, 0xdd, 0x9d, 0xb9, 0xa9, 0x3a, 0x15, 0xf4, 0xeb, 0xfe, 0xfa, 0xff, 0x7b,
0xfd, 0xbe, 0xdf, 0x7e, 0xfd, 0x78, 0xc6, 0x23, 0x9d, 0x22, 0x67, 0x5a, 0x81,
0x86, 0x20, 0x69, 0x15, 0xd1, 0x61, 0x1e, 0xec, 0xcb, 0x75, 0x90, 0x73, 0x0e,
0x92, 0xf0, 0x1b, 0x63, 0xd3, 0xe4, 0x82, 0x68, 0x75, 0xc2, 0x08, 0x53, 0x9c,
0x89, 0xc6, 0x79, 0xd6, 0xb4, 0x56, 0xe6, 0x4a, 0xb2, 0x11, 0x4c, 0x4b, 0xbd,
0x5a, 0x89, 0xae, 0x96, 0xab, 0x20, 0xe5, 0xcd, 0x5a, 0xc1, 0x58, 0x69, 0xa9,
0x8e, 0x1a, 0xa4, 0xfd, 0x07, 0x35, 0x3a, 0x6a, 0xd6, 0xd1, 0xcb, 0x3e, 0x70,
0x48, 0xcb, 0x99, 0xce, 0xa5, 0xa2, 0x39, 0x44, 0x2c, 0x3c, 0xaf, 0x59, 0x47,
0x5b, 0x45, 0x91, 0xb0, 0x06, 0x6f, 0x6a, 0x50, 0x70, 0x1e, 0xde, 0x86, 0x00,
0x5c, 0xd6, 0x51, 0x87, 0xb8, 0xda, 0x83, 0xd0, 0x1b, 0x04, 0xba, 0xbc, 0x04,
0x21, 0x59, 0x1d, 0xf4, 0x8f, 0xc2, 0xe2, 0x28, 0x3c, 0x60, 0x65, 0xd3, 0x3a,
0x7a, 0x5d, 0xf7, 0x40, 0xbd, 0xd7, 0x62, 0x03, 0x7f, 0xae, 0x05, 0x73, 0xda,
0x7f, 0x8b, 0x43, 0xa3, 0x3a, 0xba, 0x11, 0xcb, 0xdc, 0xd1, 0xd1, 0x7b, 0xba,
0xf8, 0x52, 0xeb, 0x29, 0xa0, 0xce, 0x82, 0x98, 0xc1, 0xb6, 0x80, 0x36, 0xfa,
0x89, 0x92, 0xf3, 0xe4, 0xd1, 0x02, 0x3a, 0x5e, 0xf0, 0xb5, 0xa7, 0x73, 0xb9,
0x80, 0x86, 0x62, 0x90, 0xcb, 0xa5, 0xe8, 0x4e, 0xa5, 0xe4, 0x56, 0xc1, 0x5e,
0x73, 0x42, 0xd3, 0x2e, 0x58, 0x77, 0xe1, 0x17, 0xd9, 0xa8, 0x51, 0xe3, 0x03,
0xf5, 0x0f, 0xf5, 0x31, 0x1b, 0x6e, 0x25, 0x27, 0x5a, 0xc3, 0x64, 0xf3, 0x33,
0xe7, 0x1e, 0x4e, 0x8e, 0xfd, 0x39, 0xe8, 0xca, 0x89, 0x91, 0x83, 0xa8, 0x9e,
0x8e, 0xb9, 0xc8, 0xc0, 0x32, 0xd0, 0xfb, 0x1e, 0x48, 0x1a, 0x83, 0x25, 0x3d,
0xb6, 0x26, 0x13, 0x73, 0x81, 0xb0, 0xef, 0x71, 0x1a, 0x87, 0x6b, 0x65, 0x24,
0x68, 0x03, 0x11, 0xdf, 0xd5, 0xd3, 0xc2, 0x42, 0xe8, 0xdc, 0x27, 0x6f, 0xf8,
0x5b, 0xca, 0xc1, 0x15, 0xd1, 0x46, 0xc7, 0x32, 0xd8, 0x78, 0xe5, 0xb6, 0x65,
0x30, 0xbb, 0xc8, 0x90, 0x97, 0xcc, 0x6c, 0x4a, 0x1d, 0x6d, 0xe9, 0xf1, 0x8e,
0x9e, 0xcb, 0x10, 0x9c, 0xd2, 0x8c, 0x7a, 0xc9, 0x45, 0x4e, 0xb3, 0xc7, 0x8a,
0xa9, 0xb7, 0xf8, 0x01, 0xdf, 0x9b, 0x2e, 0xa6, 0x09, 0x3c, 0x99, 0x9b, 0x8a,
0xea, 0x54, 0xe4, 0x0c, 0x90, 0x5e, 0x8f, 0x73, 0xc0, 0x89, 0x6c, 0x1c, 0x78,
0xf7, 0x62, 0x09, 0x59, 0x2c, 0xa6, 0xcb, 0x95, 0x18, 0xaa, 0x44, 0xba, 0xe3,
0x87, 0x7b, 0x7e, 0xa0, 0xb3, 0xc5, 0x30, 0x71, 0xbc, 0x75, 0x23, 0x36, 0x8f,
0xdb, 0xc5, 0x74, 0x37, 0x56, 0x65, 0x62, 0x06, 0xa6, 0x1e, 0x50, 0x87, 0xbb,
0xc5, 0x54, 0x51, 0x22, 0x0e, 0xcd, 0x81, 0x90, 0xe5, 0xeb, 0xe8, 0xba, 0x66,
0x05, 0x5f, 0x4c, 0x3c, 0xf9, 0xa9, 0xd3, 0xdc, 0x57, 0x1d, 0x70, 0xc3, 0x01,
0x75, 0x0e, 0x68, 0x70, 0x48, 0xae, 0xfa, 0x5d, 0xb0, 0x09, 0x54, 0x67, 0xe6,
0x43, 0x8e, 0x70, 0x66, 0xef, 0x44, 0xe0, 0x5e, 0x04, 0xe8, 0xcf, 0x18, 0x78,
0xbe, 0xc9, 0x2f, 0xd1, 0x02, 0xca, 0x07, 0xe3, 0xa9, 0x34, 0x50, 0x93, 0xe1,
0x1f, 0xad, 0xf2, 0xf5, 0xae, 0x1e, 0x32, 0x49, 0xbe, 0x8e, 0x2a, 0xa9, 0xbb,
0xf2, 0x1b, 0x74, 0x8e, 0xdf, 0xac, 0xab, 0x6f, 0xfe, 0xc3, 0x96, 0x12, 0xda,
0x2e, 0xef, 0x84, 0xa9, 0x2c, 0xc5, 0x8b, 0xf2, 0x57, 0x04, 0x5a, 0x4c, 0xb4,
0xdd, 0xf4, 0xcf, 0xe8, 0x2f, 0x5c, 0x06, 0x37, 0xcb, 0x7e, 0xde, 0x8a, 0x2f,
0x30, 0x53, 0xbd, 0xf0, 0xf5, 0x9d, 0x09, 0xd2, 0x68, 0x09, 0xd9, 0x28, 0x21,
0x3a, 0x33, 0x29, 0x32, 0x93, 0xd9, 0x0f, 0xe7, 0x3f, 0xbc, 0xff, 0x76, 0xc6,
0x9f, 0x67, 0x55, 0x11, 0x3a, 0x67, 0x24, 0xe9, 0x47, 0xbb, 0x9f, 0x98, 0xf9,
0x51, 0xe7, 0x02, 0x4d, 0xac, 0xc7, 0xde, 0x41, 0x32, 0xfd, 0x45, 0xd3, 0x1b,
0xbe, 0x17, 0x23, 0x11, 0xe8, 0x33, 0x40, 0xca, 0xf1, 0x94, 0x17, 0x5c, 0x27,
0xd7, 0x9e, 0x4a, 0xfe, 0x70, 0xd7, 0x80, 0xb4, 0x65, 0x0d, 0xee, 0xa4, 0x92,
0xd4, 0x8f, 0xd2, 0x3f, 0xe2, 0xeb, 0x44, 0x43, 0x02, 0x3f, 0x8c, 0xbe, 0x9c,
0xf3, 0xc4, 0x8d, 0xc3, 0xef, 0x18, 0xde, 0x58, 0x9f, 0x22, 0xb7, 0xa6, 0x08,
0x2d, 0xf8, 0xa2, 0xe2, 0xd9, 0xe4, 0x3f, 0xb9, 0x53, 0x46, 0xd6, 0xa6, 0xc8,
0xf8, 0x47, 0xb7, 0x9f, 0x57, 0x57, 0x92, 0xfe, 0x93, 0xbb, 0x3e, 0xa8, 0x5b,
0x10, 0x47, 0x2d, 0x4c, 0x1f, 0xf0, 0xfe, 0xc5, 0xd9, 0x1f, 0x66, 0xe4, 0x91,
0x6b, 0x07, 0xa7, 0xf1, 0xea, 0x6b, 0xb7, 0x4e, 0xd0, 0xc4, 0x32, 0x72, 0xe3,
0x2d, 0x9b, 0x0d, 0xda, 0x3c, 0x70, 0x15, 0x52, 0x5f, 0x77, 0x56, 0x93, 0x6c,
0x13, 0x29, 0xfa, 0x93, 0x8d, 0x3f, 0xbb, 0xb8, 0x40, 0x75, 0x36, 0xd8, 0xf8,
0x33, 0x3a, 0x37, 0x48, 0x02, 0x83, 0x84, 0xae, 0xfd, 0xaf, 0x99, 0xef, 0x68,
0x9e, 0xaf, 0xcd, 0x26, 0xab, 0x13, 0xc4, 0xb7, 0xcf, 0x64, 0xc1, 0xc2, 0x05,
0x2e, 0x45, 0xbe, 0xd6, 0xb4, 0x6f, 0xe3, 0xad, 0xe9, 0x3c, 0x32, 0x73, 0x2c,
0xe9, 0x75, 0xce, 0xad, 0xaa, 0xc9, 0xad, 0xc3, 0x3d, 0x8f, 0x6e, 0xeb, 0x08,
0xad, 0x36, 0x91, 0xce, 0x5c, 0xcc, 0xe6, 0x65, 0x7e, 0x6b, 0xd0, 0x4e, 0x02,
0x76, 0x92, 0xc5, 0x07, 0xc0, 0x53, 0x79, 0x66, 0xd2, 0xfc, 0x84, 0xfb, 0xa5,
0xc1, 0x37, 0x06, 0x26, 0x48, 0xf1, 0x3b, 0x17, 0xde, 0xc9, 0x94, 0xb6, 0x1b,
0x92, 0xa6, 0x2e, 0x2e, 0x9d, 0x61, 0xe2, 0x02, 0x2d, 0x1d, 0x25, 0x86, 0xd1,
0x98, 0x5a, 0x34, 0xf2, 0x9e, 0xff, 0x77, 0xac, 0x7f, 0x23, 0xfc, 0x1e, 0x5f,
0x6a, 0xbf, 0x94, 0x34, 0x38, 0x23, 0xb9, 0x60, 0x24, 0xce, 0x17, 0xcf, 0x37,
0xd1, 0xa5, 0x12, 0x5c, 0x29, 0xc1, 0xa6, 0x39, 0xb0, 0xce, 0xc5, 0x50, 0x5f,
0xd9, 0x44, 0x2f, 0x36, 0x89, 0x90, 0x8a, 0xd3, 0xb4, 0x1e, 0xf8, 0x30, 0xf4,
0x68, 0x79, 0xef, 0x0a, 0x97, 0x3e, 0xc2, 0x25, 0xb0, 0xf6, 0x65, 0x91, 0x1e,
0xed, 0x3b, 0xd0, 0x50, 0x47, 0xd4, 0x2e, 0xda, 0x66, 0xc4, 0x4e, 0xa3, 0x58,
0x00, 0x1a, 0x17, 0x3d, 0xef, 0x12, 0xaf, 0xd9, 0xf5, 0x6c, 0xf1, 0x81, 0x4a,
0x4b, 0xa2, 0xd8, 0x45, 0xfb, 0x7f, 0xd4, 0xb0, 0xaf, 0xb5, 0x52, 0xe8, 0x72,
0x26, 0xd0, 0x9a, 0x80, 0x96, 0xbb, 0x68, 0x41, 0x36, 0xe9, 0x9e, 0x86, 0x2a,
0x17, 0x35, 0xc9, 0x47, 0x97, 0xb8, 0xa8, 0x59, 0x8a, 0xc4, 0x36, 0x88, 0x35,
0xbb, 0x68, 0x6b, 0xfc, 0x45, 0x3d, 0x3a, 0xd7, 0x05, 0x81, 0x2e, 0x18, 0x0e,
0xc2, 0xd5, 0x20, 0xf4, 0x6f, 0x83, 0x6b, 0x5b, 0x1a, 0x65, 0xae, 0x01, 0xd5,
0x06, 0x94, 0xbd, 0x67, 0x78, 0x96, 0x33, 0xa0, 0x31, 0x0b, 0x1d, 0xca, 0x26,
0xee, 0x6c, 0x32, 0x6e, 0xa1, 0x35, 0x4e, 0x30, 0x3b, 0x81, 0xae, 0x07, 0xe0,
0x16, 0x97, 0xe5, 0xa6, 0x2d, 0xf4, 0x7a, 0x7c, 0xfb, 0xd8, 0x12, 0x8f, 0x04,
0x2d, 0x74, 0xc1, 0x42, 0x57, 0x64, 0x50, 0x5e, 0x09, 0x6c, 0x25, 0x93, 0x2c,
0xde, 0x54, 0x55, 0x84, 0x26, 0xbe, 0x5d, 0x6b, 0x85, 0x21, 0x0b, 0x75, 0x5b,
0xe8, 0x96, 0x0b, 0xee, 0x08, 0x49, 0x6b, 0xd4, 0x8a, 0xe3, 0x56, 0xd1, 0x4f,
0xd3, 0x65, 0x6a, 0xbd, 0x4c, 0xed, 0xed, 0xd0, 0xdb, 0x0e, 0xb3, 0x16, 0x3a,
0x6f, 0x89, 0x1d, 0x99, 0x06, 0x1b, 0x79, 0x44, 0xb4, 0xa5, 0x59, 0x86, 0xf3,
0xcb, 0x32, 0x02, 0xf3, 0xea, 0x71, 0x16, 0x14, 0x0a, 0x7a, 0xcb, 0x22, 0xd6,
0x7d, 0x4b, 0x33, 0x45, 0x6b, 0x33, 0x9f, 0x54, 0x33, 0x6d, 0x95, 0xdc, 0x7d,
0x1d, 0xcd, 0xd4, 0xd6, 0x4c, 0xab, 0x4a, 0x70, 0xe1, 0xb9, 0xb3, 0x4e, 0xec,
0x6a, 0xa6, 0xdd, 0xcd, 0x71, 0xa5, 0xdc, 0x84, 0x8a, 0xbf, 0xee, 0x15, 0xaa,
0xf2, 0x90, 0x0d, 0x9a, 0xdf, 0x4a, 0x4b, 0xc3, 0x1a, 0x15, 0x5e, 0xa9, 0x23,
0xa9, 0xef, 0x5f, 0x3d, 0xa6, 0x95, 0x3c, 0xb2, 0x7d, 0x76, 0xba, 0xb9, 0x4a,
0xc6, 0xff, 0x74, 0x85, 0x53, 0x3f, 0xcd, 0x36, 0x9c, 0xdf, 0x86, 0x05, 0x3b,
0x0d, 0xda, 0x29, 0x0f, 0x27, 0xfd, 0x64, 0xc6, 0x4f, 0xfa, 0x67, 0x48, 0xd2,
0x27, 0x0b, 0xd9, 0x44, 0xed, 0x44, 0x2a, 0x67, 0x71, 0xca, 0x68, 0xa7, 0x21,
0x7b, 0x2c, 0xa4, 0xab, 0x02, 0x82, 0xa4, 0x89, 0x3f, 0x3c, 0x31, 0xc2, 0xba,
0x66, 0xa7, 0x11, 0x3b, 0x9d, 0xad, 0xc3, 0xf9, 0x3a, 0xe4, 0xf1, 0x8c, 0x9f,
0x34, 0x1c, 0xbd, 0xfd, 0x03, 0x07, 0xef, 0xa0, 0xb4, 0x1d, 0x0d, 0xed, 0xa8,
0x69, 0xc2, 0xf3, 0x4d, 0x58, 0x50, 0x8e, 0xfa, 0x72, 0xa4, 0xb7, 0xb7, 0x20,
0xc9, 0x42, 0xee, 0xf0, 0x36, 0x6e, 0xdb, 0xe9, 0xae, 0x68, 0xca, 0xaf, 0xc4,
0xff, 0xb9, 0xf2, 0xa7, 0x59, 0x7f, 0xad, 0x70, 0x48, 0x72, 0xa8, 0x83, 0x9e,
0x76, 0xd0, 0xd2, 0x14, 0x34, 0xa4, 0x70, 0xa4, 0x65, 0x44, 0x21, 0x27, 0x0a,
0x7b, 0x79, 0x4f, 0x7c, 0x17, 0xa4, 0x83, 0x8e, 0x6e, 0x10, 0x45, 0x8b, 0x0c,
0x6d, 0x74, 0xd0, 0x4b, 0x8e, 0xaf, 0x13, 0x0b, 0x9d, 0x97, 0x92, 0x12, 0x2f,
0xc7, 0xc8, 0x2c, 0xec, 0x1e, 0x1e, 0xb0, 0x43, 0xb2, 0x0f, 0x6a, 0x8f, 0x78,
0x9b, 0xc1, 0xbe, 0x0a, 0xbd, 0xab, 0x30, 0x98, 0x81, 0x3b, 0x87, 0x06, 0xf4,
0x72, 0xed, 0x3c, 0x1f, 0x3d, 0xc7, 0x71, 0x33, 0xe2, 0x02, 0x8f, 0x0b, 0x26,
0x1a, 0x61, 0xaa, 0x11, 0xb2, 0x2d, 0x78, 0x61, 0x9f, 0x7b, 0x90, 0xf8, 0x07,
0x89, 0xd2, 0x84, 0xa5, 0x3e, 0x5a, 0xef, 0x23, 0xbd, 0x4f, 0x3a, 0x3e, 0x73,
0x59, 0xa0, 0xa5, 0x0e, 0x8f, 0xe5, 0x98, 0x79, 0xcd, 0x49, 0x1d, 0x8e, 0x3c,
0x9e, 0xe3, 0x26, 0x45, 0x3e, 0xaa, 0xe3, 0x7f, 0x21, 0x62, 0x7a, 0x35, 0x2b,
0x47, 0x94, 0xcd, 0xfe, 0xc8, 0xd2, 0x05, 0x31, 0x17, 0x78, 0xb1, 0x8f, 0x5e,
0xf0, 0x09, 0xd2, 0x83, 0x7a, 0x33, 0x36, 0xfa, 0x28, 0xea, 0x52, 0x49, 0xf7,
0x4b, 0x79, 0xd8, 0xf4, 0x78, 0xeb, 0x5f, 0xd5, 0x7c, 0x6e, 0xfe, 0xfc, 0xbc,
0x8f, 0x2e, 0x5b, 0x31, 0x24, 0x2d, 0x10, 0x7a, 0xcd, 0x89, 0x9d, 0x41, 0x32,
0xf9, 0xd5, 0x6e, 0x9c, 0x33, 0x95, 0x6f, 0xc3, 0x1d, 0x0d, 0xa9, 0x15, 0xdd,
0x53, 0xbf, 0x86, 0x5c, 0xd7, 0x90, 0x51, 0xa5, 0x38, 0xf0, 0xa1, 0x71, 0x95,
0xf8, 0x06, 0x91, 0xfa, 0xcb, 0x70, 0xb1, 0x0c, 0xe9, 0x1a, 0xd7, 0xf6, 0x3e,
0xd6, 0x3a, 0x69, 0xbf, 0x74, 0x83, 0xbf, 0x53, 0xfd, 0x78, 0xc3, 0xe3, 0xbc,
0x4a, 0x76, 0x0e, 0xda, 0x7e, 0x50, 0xf4, 0xf1, 0xb7, 0x67, 0x07, 0x89, 0x77,
0x90, 0x34, 0xf8, 0xe8, 0x9a, 0x16, 0x23, 0x5a, 0x94, 0x55, 0x9c, 0x2d, 0x17,
0xde, 0x71, 0x61, 0x8d, 0x4f, 0x1c, 0x3b, 0xd9, 0x20, 0x89, 0x08, 0x9a, 0x26,
0x38, 0x2f, 0x3c, 0xd4, 0x4d, 0xed, 0x68, 0x6d, 0x47, 0x9a, 0xa9, 0xc4, 0xdb,
0x4f, 0xa6, 0x17, 0x22, 0x0e, 0xf2, 0x46, 0x37, 0x3f, 0x58, 0x7d, 0xb9, 0x7a,
0xdf, 0x39, 0x3d, 0x09, 0x6b, 0x89, 0xfe, 0x4f, 0xb4, 0x46, 0x28, 0xee, 0xc1,
0x0b, 0x3d, 0x28, 0xef, 0x39, 0x8b, 0xe9, 0x2a, 0xb4, 0xcf, 0x47, 0x07, 0x7c,
0x5f, 0xbb, 0x47, 0xb3, 0x3e, 0x3a, 0x2f, 0xf0, 0x5a, 0x83, 0x9e, 0x1a, 0x3c,
0x33, 0x09, 0xc6, 0x2f, 0x03, 0xa2, 0x40, 0xd8, 0x47, 0x6f, 0xfa, 0xe8, 0xd0,
0x19, 0x74, 0x9f, 0x91, 0x0f, 0x97, 0xda, 0x84, 0xdd, 0x4d, 0x88, 0x91, 0xf7,
0xb2, 0x59, 0xa8, 0x98, 0x85, 0x2e, 0x3f, 0xed, 0xf6, 0xd3, 0x9a, 0x1c, 0xcc,
0x79, 0xfb, 0xfa, 0xc7, 0xdd, 0xc2, 0xa2, 0xde, 0x64, 0x46, 0x68, 0x37, 0x63,
0x8f, 0x9f, 0x4e, 0xe6, 0x90, 0xc8, 0x93, 0x0d, 0x42, 0xd2, 0xef, 0xe3, 0x19,
0x4e, 0xd9, 0xdc, 0x3e, 0xe8, 0xa7, 0x57, 0xa4, 0x58, 0xa1, 0x1b, 0x4a, 0xdc,
0x20, 0x27, 0xc7, 0xfc, 0xd4, 0x2b, 0x80, 0xfc, 0x1a, 0xce, 0x20, 0xce, 0x30,
0x5c, 0x1e, 0x04, 0xdf, 0x89, 0x00, 0x07, 0xad, 0xfa, 0xe9, 0x0d, 0xa9, 0xf8,
0xa8, 0x19, 0x6d, 0x1f, 0x2e, 0x3d, 0xaf, 0xd6, 0x73, 0x2a, 0xf9, 0xd5, 0x0c,
0x54, 0x7f, 0x16, 0x18, 0xc6, 0x69, 0x3f, 0xbd, 0x2e, 0xb7, 0xba, 0xe4, 0xa7,
0x2b, 0xbc, 0xae, 0x13, 0x6f, 0x3a, 0xc5, 0x48, 0x75, 0x66, 0x2c, 0x32, 0x63,
0xd8, 0x4f, 0x6f, 0xc6, 0x6c, 0xfc, 0xb9, 0x2e, 0x54, 0xbb, 0xf8, 0x6d, 0xf0,
0xc1, 0xe5, 0xa7, 0x93, 0x5e, 0xa8, 0x18, 0x93, 0xee, 0x5a, 0x4a, 0x80, 0xa6,
0x05, 0xf8, 0xc3, 0x3a, 0x47, 0xdb, 0xe7, 0xa8, 0x6e, 0x17, 0x8a, 0x76, 0x21,
0x33, 0x40, 0x73, 0x1e, 0xec, 0x2c, 0x4a, 0x5d, 0x83, 0xf4, 0x35, 0xf9, 0xfe,
0xce, 0xa6, 0x41, 0xe7, 0xb3, 0x06, 0x29, 0xe7, 0xcc, 0x35, 0xa8, 0x38, 0x99,
0xb1, 0x4a, 0xac, 0xa9, 0xa4, 0xb5, 0x07, 0x68, 0x94, 0x53, 0x05, 0xa7, 0xb8,
0x1b, 0x01, 0x6a, 0x0d, 0xd0, 0xb6, 0x00, 0xed, 0x0c, 0xfc, 0x1c, 0x36, 0x58,
0xe6, 0xc4, 0x0a, 0x31, 0xba, 0xcb, 0x21, 0xea, 0x10, 0x7e, 0xbc, 0x66, 0x50,
0x58, 0x61, 0xc4, 0x41, 0xd7, 0x92, 0x68, 0x77, 0x9f, 0x84, 0xdf, 0xba, 0x76,
0xa0, 0xe6, 0x98, 0xab, 0x78, 0xb5, 0x0b, 0x3a, 0x3e, 0x34, 0xe9, 0x31, 0xea,
0xa0, 0x1b, 0x0e, 0x1a, 0x75, 0x81, 0x22, 0x8d, 0xd0, 0x9b, 0x0e, 0x1a, 0x76,
0xd0, 0x8e, 0x09, 0x62, 0x3c, 0x9e, 0xe6, 0x94, 0xca, 0x65, 0x72, 0xd1, 0x25,
0x8b, 0xff, 0x8b, 0x97, 0x9a, 0x9d, 0x54, 0xb6, 0x4f, 0x46, 0xfd, 0xb0, 0xe1,
0x97, 0x5b, 0xd9, 0x54, 0x01, 0x67, 0x81, 0x41, 0xc8, 0x9b, 0x81, 0xc5, 0xa7,
0x78, 0xd3, 0x19, 0xc2, 0x69, 0x9e, 0x2e, 0x79, 0xce, 0xcf, 0xf4, 0x50, 0x55,
0x0f, 0xdd, 0x34, 0x61, 0x68, 0x89, 0x14, 0x67, 0xd3, 0xf3, 0xd9, 0xf4, 0x6c,
0x0f, 0xcd, 0xee, 0xa1, 0x85, 0x33, 0xa4, 0xe0, 0xf9, 0x01, 0x17, 0xa6, 0xf2,
0x52, 0xa5, 0x5b, 0x64, 0xf5, 0x50, 0xe7, 0xe7, 0x03, 0x79, 0x24, 0x5b, 0x41,
0x8b, 0x7a, 0x90, 0x57, 0xcf, 0xea, 0x89, 0x57, 0x15, 0x43, 0xce, 0xeb, 0xa1,
0xe7, 0x38, 0xa0, 0x6d, 0x0e, 0x3a, 0xe7, 0x40, 0xd3, 0x43, 0xcf, 0xf7, 0x50,
0x39, 0xe4, 0xf7, 0xa0, 0x87, 0xd7, 0x78, 0xc0, 0x50, 0x82, 0x90, 0xb4, 0x0c,
0xd5, 0x3d, 0xb4, 0x56, 0x02, 0xd5, 0xf7, 0x50, 0xcb, 0x83, 0xbc, 0xae, 0x1e,
0xda, 0xdd, 0x23, 0x63, 0xab, 0xbf, 0x8f, 0xda, 0x5d, 0xa4, 0xf2, 0x31, 0x6b,
0x25, 0xd6, 0x6f, 0xc0, 0xe2, 0xd3, 0xb5, 0xef, 0x95, 0x48, 0x7e, 0xb4, 0x2a,
0x23, 0xb4, 0x3d, 0x17, 0x1c, 0x06, 0x5a, 0x6d, 0x84, 0x6c, 0x33, 0x39, 0x6b,
0x26, 0x26, 0xae, 0x3e, 0xc8, 0x0f, 0x55, 0xa5, 0x11, 0x2e, 0x0a, 0x83, 0x9c,
0xce, 0x0a, 0x45, 0x56, 0x68, 0x34, 0x42, 0xea, 0x33, 0x9d, 0x83, 0xb0, 0xb5,
0x0e, 0xce, 0x1f, 0x3c, 0xd2, 0x6a, 0x84, 0x3a, 0x23, 0xd4, 0x7f, 0x1c, 0x90,
0x54, 0xfe, 0x26, 0x23, 0x7c, 0xe7, 0xe0, 0x25, 0x5e, 0x76, 0x7d, 0x16, 0x54,
0x4f, 0xad, 0xd8, 0x20, 0xdf, 0x08, 0xfc, 0x11, 0xd1, 0x19, 0xa1, 0x88, 0x03,
0x79, 0x62, 0xe2, 0x64, 0xfa, 0x63, 0x8b, 0x39, 0x38, 0x68, 0x84, 0xdf, 0x4b,
0x78, 0x6a, 0x22, 0x8f, 0x14, 0x7c, 0x57, 0x69, 0x26, 0xb9, 0x47, 0x4f, 0x1f,
0xad, 0x57, 0x92, 0x1b, 0x26, 0xec, 0x69, 0xc7, 0x12, 0x35, 0x31, 0xf2, 0xb2,
0xbc, 0xa5, 0xdf, 0xe8, 0x3b, 0x96, 0x25, 0x1e, 0xc7, 0x7e, 0x2e, 0x57, 0xbf,
0x30, 0xc0, 0x61, 0xcd, 0x46, 0xe0, 0xdd, 0x51, 0xde, 0x5f, 0x03, 0xbf, 0xdc,
0xf6, 0xc1, 0xc5, 0x57, 0xae, 0x1a, 0x61, 0xd8, 0x08, 0xdf, 0xe6, 0x92, 0x2e,
0xb9, 0x53, 0x49, 0xb6, 0xde, 0xa8, 0x0d, 0xc1, 0xb2, 0x13, 0x9c, 0x4f, 0xef,
0x8b, 0xbe, 0xae, 0xf8, 0xc3, 0x2c, 0x23, 0x64, 0xa8, 0x70, 0xe5, 0x47, 0x06,
0x5e, 0x7a, 0x5a, 0x8f, 0xe6, 0xcf, 0x6b, 0x8d, 0xb0, 0x3a, 0x81, 0xdb, 0xbf,
0x7b, 0x5d, 0x45, 0x9e, 0x69, 0x37, 0xc2, 0xa4, 0x11, 0x9e, 0xb5, 0xbf, 0x5b,
0xf9, 0xac, 0x41, 0xa2, 0x7d, 0xeb, 0x1b, 0x70, 0x4b, 0xd0, 0xf0, 0x4d, 0x0f,
0x6e, 0x7b, 0xb0, 0x66, 0x08, 0xcc, 0x43, 0xc0, 0xb5, 0x3e, 0x70, 0xf0, 0xda,
0xbc, 0x0f, 0xde, 0x53, 0x4a, 0x22, 0xa6, 0x27, 0xa2, 0xdd, 0x08, 0xbd, 0xb2,
0x79, 0x32, 0xa5, 0x03, 0xca, 0xdf, 0x8b, 0xbe, 0x78, 0xe9, 0xf5, 0xe1, 0x43,
0x37, 0x3f, 0x7e, 0xec, 0xf7, 0xfe, 0x43, 0x80, 0x83, 0x47, 0x8d, 0x30, 0x6e,
0x84, 0x9e, 0x52, 0x0c, 0x7c, 0xc9, 0x93, 0x23, 0x46, 0xf0, 0xc8, 0xd5, 0xa9,
0xdb, 0x08, 0x31, 0x3c, 0xf2, 0x6e, 0x93, 0x60, 0x53, 0x00, 0x1e, 0x3a, 0xf4,
0x8c, 0x38, 0xf4, 0xf4, 0xc5, 0x7e, 0x4e, 0xbe, 0x32, 0x71, 0xeb, 0x3f, 0x57,
0x70, 0x55, 0x33, 0x5e, 0x97, 0x17, 0x9e, 0x31, 0x02, 0x1f, 0xc6, 0xe1, 0x9d,
0xe7, 0xb2, 0x15, 0x24, 0xe4, 0xc6, 0xcc, 0xdb, 0xf0, 0xa4, 0xf9, 0x3d, 0xa7,
0x11, 0xfc, 0x46, 0x58, 0x34, 0x0a, 0x5a, 0x91, 0x57, 0x0d, 0xe7, 0xaa, 0x81,
0xea, 0xaa, 0xa1, 0x88, 0x5f, 0xec, 0x06, 0xbc, 0xf0, 0xbf, 0x0d, 0xd5, 0x30,
0x32, 0x8a, 0x9e, 0x51, 0x79, 0xd1, 0x57, 0xc3, 0xed, 0x53, 0x81, 0x53, 0x7d,
0x4a, 0xc2, 0x69, 0x75, 0xbd, 0x0e, 0x2d, 0x3a, 0x99, 0xd6, 0x54, 0xe3, 0x45,
0x05, 0xa1, 0xee, 0x6a, 0xb8, 0x5c, 0x0d, 0xdf, 0x4e, 0x38, 0x53, 0x48, 0x3a,
0x9d, 0xb8, 0xbe, 0x03, 0xfe, 0x97, 0x6a, 0x95, 0x84, 0x94, 0xfd, 0xbb, 0xd0,
0x73, 0x88, 0x4b, 0xbf, 0xbf, 0xf8, 0xfb, 0x5c, 0x81, 0x78, 0x7e, 0xdc, 0x13,
0x1b, 0x6c, 0xa9, 0x05, 0x6d, 0x19, 0x44, 0xcc, 0x94, 0xdf, 0xc3, 0xfd, 0x09,
0x57, 0xe3, 0x93, 0x58, 0x30, 0x82, 0xfd, 0x03, 0x93, 0x92, 0xb3, 0x49, 0x1d,
0x06, 0xa5, 0xf6, 0xd7, 0xb7, 0xe1, 0x96, 0x90, 0x2e, 0xee, 0x57, 0x83, 0x12,
0xee, 0x49, 0xe5, 0xa2, 0x46, 0xd8, 0xe0, 0x91, 0x64, 0x13, 0xdc, 0xa3, 0x69,
0x55, 0xb0, 0x69, 0x84, 0x6d, 0xbe, 0xda, 0xaa, 0xe0, 0x6c, 0x55, 0xac, 0x95,
0xe4, 0x2a, 0x38, 0x70, 0x20, 0xe5, 0x63, 0x43, 0x26, 0x6f, 0x00, 0xeb, 0xaa,
0x60, 0xf9, 0x33, 0xae, 0x3a, 0xfc, 0x0d, 0x35, 0x55, 0x41, 0x61, 0x15, 0x24,
0xa6, 0x92, 0xb4, 0x54, 0x52, 0x70, 0xc4, 0x70, 0x24, 0xa7, 0x0a, 0x32, 0xab,
0xa0, 0xf2, 0x13, 0x6b, 0x2e, 0x27, 0x38, 0x46, 0x78, 0x5e, 0xaa, 0xbf, 0x6a,
0x84, 0x1b, 0x46, 0xc8, 0x6f, 0x41, 0x2d, 0x67, 0x84, 0xcb, 0x06, 0x0c, 0x19,
0xb0, 0xd4, 0x80, 0x06, 0x2e, 0x8b, 0xa4, 0x34, 0x61, 0x5a, 0x93, 0x18, 0x12,
0xaf, 0xc4, 0xab, 0x16, 0x54, 0x81, 0x9e, 0xd7, 0xae, 0x82, 0x8b, 0xa2, 0x5a,
0xfe, 0x18, 0x46, 0xaa, 0x85, 0xad, 0x46, 0x53, 0x05, 0x43, 0x26, 0x32, 0x6f,
0x22, 0xa7, 0x05, 0xb8, 0xb9, 0x0a, 0x5a, 0xc5, 0xb5, 0x20, 0x05, 0x15, 0x1f,
0xea, 0xab, 0x64, 0x73, 0xdc, 0x64, 0x35, 0xf8, 0xff, 0xa6, 0xf9, 0xc8, 0xb6,
0x2c, 0x8c, 0x85, 0x39, 0xb2, 0x23, 0xd5, 0xc2, 0xae, 0x61, 0x02, 0x15, 0x97,
0xc4, 0x68, 0xa1, 0x09, 0x4a, 0x4c, 0xc0, 0xe7, 0xbb, 0xf5, 0xc6, 0x9d, 0x30,
0xc4, 0xa1, 0xb4, 0xd8, 0x04, 0xeb, 0x27, 0x82, 0x07, 0x02, 0x4f, 0xb5, 0xbf,
0x9a, 0x65, 0x82, 0x98, 0xd8, 0x26, 0xdd, 0x17, 0x13, 0x34, 0x88, 0x68, 0xb5,
0x09, 0x46, 0x3f, 0x4d, 0xd2, 0xca, 0x0c, 0x38, 0xca, 0x31, 0x7d, 0xf5, 0x48,
0xc7, 0xcb, 0x5b, 0x87, 0xc7, 0xef, 0xc7, 0x17, 0x48, 0xaa, 0x09, 0xd2, 0x63,
0x75, 0x46, 0x4c, 0xe0, 0x11, 0xd1, 0x72, 0x13, 0x6c, 0x7d, 0x5a, 0xa2, 0x8d,
0x0b, 0x02, 0x8d, 0x26, 0xb8, 0x24, 0xc0, 0xb1, 0xf4, 0x35, 0x13, 0xf8, 0xe4,
0x0a, 0xe5, 0x4e, 0x30, 0x3a, 0x61, 0xc1, 0x04, 0x64, 0x38, 0x8f, 0xb8, 0xf2,
0xf8, 0x43, 0x26, 0xc0, 0x89, 0x67, 0x50, 0x79, 0x06, 0xfb, 0xfa, 0x71, 0xa0,
0x5f, 0xaa, 0xb1, 0x64, 0x82, 0x15, 0x13, 0xb4, 0x59, 0xd1, 0x7d, 0x42, 0xf5,
0xec, 0xbc, 0x28, 0x92, 0x37, 0x82, 0xe7, 0x46, 0x30, 0xb1, 0x06, 0x94, 0x35,
0x70, 0xd9, 0x80, 0xee, 0x2f, 0x36, 0x4c, 0xb0, 0xc3, 0xef, 0x9b, 0x09, 0x64,
0x58, 0x8c, 0xf6, 0x8e, 0x0d, 0xa3, 0x77, 0x58, 0x34, 0x31, 0x59, 0x07, 0x14,
0xc7, 0xeb, 0xa0, 0xd1, 0x8c, 0x2b, 0x0a, 0xe2, 0xaa, 0x83, 0xfe, 0x3a, 0xe0,
0x61, 0xdc, 0x79, 0x56, 0x07, 0xed, 0x75, 0x90, 0xa7, 0xc5, 0x73, 0x7c, 0xc4,
0x0b, 0x5b, 0x10, 0xdc, 0x12, 0x39, 0x43, 0x75, 0xe0, 0xae, 0xfb, 0x9a, 0x82,
0x72, 0xc6, 0x01, 0x2a, 0xae, 0x42, 0x72, 0x39, 0xcd, 0xac, 0xc2, 0xe5, 0x3a,
0x08, 0x89, 0xec, 0xf0, 0x30, 0xdc, 0x7b, 0x8a, 0xdd, 0xe1, 0x51, 0xd9, 0x2e,
0x77, 0xbf, 0x0e, 0x92, 0xcc, 0x9c, 0x48, 0xc1, 0x59, 0x33, 0xd0, 0xd4, 0x00,
0xa4, 0x07, 0x44, 0x1b, 0x6d, 0x4a, 0x34, 0x1d, 0x17, 0x90, 0x42, 0x33, 0x94,
0xf0, 0x4b, 0xb1, 0x19, 0xc2, 0x6f, 0x9d, 0xdd, 0x06, 0x9d, 0x19, 0x8a, 0x78,
0x72, 0xd6, 0x87, 0xf3, 0x3e, 0x94, 0x26, 0xab, 0x2b, 0xc7, 0xa2, 0x72, 0xcc,
0x6b, 0xc2, 0x90, 0x92, 0x5c, 0x94, 0x4b, 0x5e, 0x30, 0x43, 0x99, 0x19, 0x7e,
0xab, 0x5d, 0x36, 0xfa, 0x75, 0x70, 0x69, 0x41, 0x88, 0x58, 0x55, 0x66, 0x30,
0xed, 0x35, 0x03, 0xae, 0xd5, 0x40, 0x84, 0xcf, 0x7c, 0xbd, 0x06, 0x6e, 0xd5,
0xc0, 0x5e, 0xee, 0x53, 0xdc, 0x08, 0x17, 0xa4, 0x5d, 0x2d, 0x2d, 0x3a, 0x6c,
0xd7, 0x61, 0x59, 0x31, 0x56, 0x14, 0xf3, 0xfa, 0xd7, 0x46, 0xc1, 0x37, 0x0a,
0x0f, 0x5d, 0x9f, 0xf5, 0x8d, 0x60, 0x69, 0x84, 0x7c, 0x1f, 0x6a, 0x7d, 0x0f,
0x04, 0xb8, 0xb0, 0x06, 0x6f, 0x3c, 0xa1, 0xdc, 0xe3, 0x0f, 0x9a, 0x50, 0xe1,
0xf6, 0x0f, 0x11, 0x9d, 0x34, 0xdc, 0x4c, 0x9c, 0xd8, 0x1a, 0x40, 0xf9, 0xc3,
0x15, 0x90, 0x26, 0xed, 0x49, 0x2c, 0xa8, 0x87, 0xd9, 0x64, 0x72, 0xf3, 0x85,
0xf4, 0xbd, 0x1f, 0xb5, 0x6c, 0xa9, 0x87, 0x4e, 0x9e, 0xdb, 0x5c, 0x0f, 0xad,
0x52, 0xa1, 0x07, 0x11, 0x6a, 0xaf, 0x87, 0x5e, 0x11, 0x1b, 0xac, 0x87, 0x2b,
0x0f, 0xf7, 0x34, 0x8e, 0xd4, 0x83, 0xa7, 0x1e, 0xf2, 0x27, 0x41, 0x3b, 0x29,
0x60, 0xc3, 0xf5, 0xf0, 0x9b, 0xfb, 0x66, 0x78, 0x76, 0x6a, 0x15, 0xa6, 0x57,
0xa1, 0x34, 0xb1, 0xae, 0x20, 0x5e, 0x14, 0xa7, 0x20, 0x43, 0xa9, 0x05, 0x0c,
0x71, 0xbd, 0xbb, 0xc6, 0x02, 0xe6, 0xbd, 0x36, 0x81, 0xe9, 0x20, 0x14, 0x7d,
0xcf, 0x16, 0x87, 0x4c, 0x58, 0x60, 0x4a, 0xc4, 0xa7, 0x2d, 0x70, 0xdd, 0x02,
0xf6, 0x10, 0xf4, 0x86, 0xe4, 0x54, 0xe6, 0xbb, 0xda, 0x77, 0x3d, 0xb1, 0x52,
0xb3, 0x16, 0x98, 0xb7, 0x80, 0xdf, 0x02, 0x8b, 0xf1, 0x6a, 0x7b, 0x0d, 0x0d,
0x65, 0x56, 0xac, 0x90, 0xa5, 0xbf, 0xbe, 0x00, 0x1a, 0xde, 0xac, 0x28, 0x41,
0x9a, 0xda, 0x04, 0xaa, 0x26, 0xc8, 0x28, 0xc0, 0xac, 0x82, 0x98, 0x80, 0xda,
0x04, 0xe7, 0x9a, 0x62, 0xe5, 0x97, 0x76, 0x61, 0x45, 0x12, 0xd8, 0x86, 0x46,
0xd0, 0x3d, 0x82, 0x3f, 0xa3, 0x23, 0x37, 0xcf, 0x42, 0xeb, 0xac, 0x30, 0x44,
0x58, 0x21, 0x47, 0xb6, 0x5c, 0xe4, 0x59, 0xe1, 0x9c, 0x75, 0xcf, 0x14, 0xfc,
0x25, 0xb8, 0x58, 0x22, 0xb9, 0xa5, 0xac, 0x60, 0xb6, 0xfe, 0xb4, 0xb2, 0x3c,
0x6a, 0x85, 0x71, 0x2e, 0x40, 0xec, 0x71, 0xcb, 0xc4, 0xcd, 0x74, 0x33, 0x20,
0xc9, 0xa5, 0x61, 0x2b, 0xdc, 0x94, 0xb2, 0xf6, 0xf6, 0xdd, 0xb2, 0x4c, 0x35,
0x33, 0xa4, 0xe4, 0xbb, 0xbb, 0x07, 0x46, 0x0e, 0x08, 0x7c, 0xb6, 0x2d, 0xd3,
0xce, 0x65, 0x19, 0xf1, 0x11, 0xf0, 0x88, 0x95, 0x10, 0x0e, 0xc0, 0x4d, 0xb1,
0x68, 0x9b, 0x52, 0xc0, 0x9a, 0x12, 0x6f, 0x79, 0x3d, 0x80, 0xea, 0x1d, 0x52,
0x12, 0xa2, 0x85, 0x21, 0xca, 0x43, 0x5a, 0xa5, 0x42, 0x53, 0xdc, 0x8e, 0x6e,
0x1f, 0x44, 0xed, 0x2c, 0x41, 0x52, 0xac, 0x23, 0xa6, 0x83, 0x91, 0x0c, 0xb2,
0x53, 0x4c, 0x2e, 0x3d, 0xdd, 0xf3, 0x5a, 0x7b, 0x75, 0x2c, 0xbf, 0x80, 0x23,
0x22, 0x9b, 0x24, 0xa7, 0xd2, 0xa4, 0x54, 0x6a, 0x09, 0xc9, 0x37, 0x4b, 0x3a,
0xc9, 0x21, 0x33, 0x84, 0x39, 0x21, 0xb9, 0x50, 0x53, 0x04, 0x6e, 0x26, 0x93,
0x5e, 0x39, 0xb7, 0x3f, 0x44, 0xcb, 0xbf, 0xb8, 0xc9, 0x45, 0x98, 0xe1, 0x10,
0xdd, 0xff, 0x1d, 0xb8, 0x12, 0xa2, 0x63, 0x21, 0xea, 0x0d, 0x49, 0x5b, 0x54,
0x18, 0x76, 0xf3, 0x48, 0x5b, 0x88, 0x1e, 0x84, 0xab, 0xa2, 0xf4, 0x60, 0x88,
0x5e, 0x91, 0x6b, 0x2d, 0x4f, 0x43, 0x48, 0x08, 0x9b, 0xfe, 0x10, 0x5d, 0x0c,
0xd1, 0x4d, 0x0d, 0xba, 0x1e, 0x31, 0xe5, 0xe0, 0x64, 0x48, 0xec, 0x22, 0xae,
0x3e, 0xa4, 0x9a, 0x43, 0xba, 0x14, 0xa2, 0x8f, 0xfe, 0xab, 0x47, 0x85, 0xf0,
0x65, 0x77, 0x62, 0xaf, 0x90, 0xc5, 0x86, 0x42, 0x34, 0x9a, 0x47, 0xba, 0x15,
0x58, 0x36, 0x03, 0x15, 0x33, 0x80, 0xd3, 0x21, 0x8a, 0x53, 0xf2, 0x8b, 0xec,
0x1e, 0xac, 0xf0, 0x88, 0xb1, 0xdd, 0x0e, 0xd1, 0xdd, 0x90, 0x7c, 0xad, 0xea,
0x22, 0x15, 0x26, 0xbc, 0xe6, 0x83, 0xeb, 0x9f, 0x51, 0xdc, 0xb7, 0x21, 0xa0,
0xab, 0x21, 0xda, 0xf2, 0x95, 0x51, 0x52, 0x06, 0x47, 0x66, 0xd0, 0x33, 0x83,
0x3d, 0x2a, 0x74, 0xaa, 0x70, 0xce, 0x8b, 0x8b, 0xab, 0xe4, 0x9e, 0x28, 0x71,
0x9f, 0x37, 0x99, 0x00, 0xa2, 0x89, 0x9d, 0x10, 0x95, 0x20, 0xb4, 0x20, 0x0a,
0x0a, 0x25, 0xd1, 0xaf, 0xd1, 0xea, 0x44, 0xac, 0x4d, 0xc4, 0xd2, 0xbb, 0x60,
0x79, 0xaa, 0xd6, 0x07, 0x2d, 0x61, 0xda, 0x1e, 0xa6, 0x83, 0xd5, 0x78, 0xa5,
0x1a, 0xed, 0x61, 0xda, 0x1b, 0xe6, 0x68, 0xb6, 0xe2, 0x1d, 0x27, 0x39, 0x7c,
0x25, 0x4c, 0xfb, 0xc2, 0x74, 0x20, 0x2c, 0xa4, 0xa5, 0x30, 0xed, 0x0e, 0x4b,
0xb7, 0x3f, 0x4c, 0xc7, 0xc3, 0xe2, 0xf0, 0x0e, 0xea, 0x0e, 0x3f, 0x48, 0x8d,
0x84, 0xa9, 0x47, 0xe4, 0xae, 0x86, 0xe9, 0x0d, 0x7e, 0x5d, 0x08, 0xd3, 0x47,
0x67, 0xc2, 0xf1, 0xd5, 0x14, 0x82, 0x9b, 0x5f, 0xcd, 0xde, 0x27, 0x9e, 0x30,
0xd2, 0xe9, 0x30, 0xbd, 0x1e, 0xa6, 0xab, 0xdb, 0x70, 0x43, 0x52, 0xb1, 0x67,
0xc3, 0x74, 0x5e, 0x6a, 0xdc, 0x85, 0xdd, 0x2e, 0x8c, 0xa7, 0x84, 0xbd, 0x2d,
0x4c, 0x15, 0x11, 0x2e, 0x75, 0x84, 0x29, 0x62, 0x24, 0xde, 0x10, 0xcd, 0x88,
0x70, 0x99, 0x93, 0xe6, 0x46, 0xa8, 0x5a, 0xbc, 0x03, 0x98, 0xec, 0xc6, 0xd3,
0x6e, 0x4c, 0x09, 0x60, 0xba, 0x44, 0x0e, 0x2a, 0x23, 0xf4, 0xd0, 0x63, 0xd4,
0x14, 0x91, 0x6e, 0x2a, 0xbd, 0x45, 0xbb, 0xd7, 0x68, 0xdf, 0x1a, 0x1d, 0x10,
0xfb, 0xe0, 0xd7, 0xa8, 0x5b, 0x9c, 0x4f, 0x18, 0xa1, 0xe6, 0x08, 0xf5, 0x6b,
0x71, 0x51, 0x66, 0x10, 0xd5, 0x11, 0x5a, 0x2b, 0x4a, 0x5f, 0x5b, 0xa3, 0xbe,
0xf8, 0x91, 0x55, 0x3d, 0x26, 0x74, 0x9a, 0x30, 0x2e, 0x45, 0x9f, 0x59, 0xa7,
0xaa, 0x75, 0xe9, 0x84, 0x39, 0xdc, 0xdf, 0xcd, 0x3b, 0x5e, 0xa7, 0xea, 0x75,
0x1a, 0x3f, 0x71, 0x2e, 0xfe, 0x2a, 0x22, 0x9d, 0x6d, 0xc4, 0xf9, 0x46, 0xa4,
0x97, 0x23, 0xd4, 0xc1, 0xd3, 0xb1, 0x8b, 0x58, 0x17, 0x11, 0x1a, 0x12, 0xb1,
0xe1, 0x08, 0xdd, 0x3f, 0x23, 0x83, 0xae, 0x45, 0xe8, 0x1c, 0xbd, 0x4e, 0x03,
0x91, 0xf8, 0xde, 0x99, 0x08, 0x0d, 0x46, 0xf6, 0x96, 0xa5, 0x67, 0xa2, 0x54,
0x25, 0xed, 0x12, 0x97, 0xdf, 0xe9, 0xe6, 0x98, 0x88, 0x50, 0x45, 0x74, 0x8f,
0xdb, 0xf9, 0x2e, 0x9c, 0x95, 0xbc, 0xaf, 0xf9, 0x51, 0xaa, 0x95, 0xe0, 0x3a,
0x2f, 0x14, 0x79, 0x63, 0x66, 0xd9, 0x28, 0xbd, 0xf8, 0xa0, 0x6c, 0x5b, 0x94,
0x76, 0x46, 0xa9, 0x5f, 0x8f, 0x86, 0x6a, 0xd2, 0x2d, 0x41, 0xbb, 0xa2, 0x54,
0x8e, 0xd0, 0xbe, 0x28, 0xdd, 0xdc, 0x21, 0xb6, 0x35, 0xfc, 0x29, 0x5d, 0x21,
0x2f, 0x0d, 0xce, 0xc5, 0x4c, 0xbc, 0x35, 0x1b, 0xd4, 0xbc, 0xc1, 0xb9, 0xf1,
0x06, 0x6d, 0x10, 0x47, 0x02, 0x4d, 0xef, 0xc2, 0x75, 0x41, 0x54, 0xf8, 0x0c,
0x06, 0xb3, 0x89, 0x29, 0x46, 0x9a, 0x4b, 0x15, 0xa8, 0x45, 0x55, 0xcc, 0x80,
0x5c, 0xaf, 0x44, 0x0b, 0x17, 0x75, 0xca, 0x5d, 0x68, 0x74, 0xe1, 0xd0, 0x2e,
0xb8, 0xe3, 0x86, 0xe5, 0x42, 0x2f, 0x66, 0xe9, 0xc9, 0xd0, 0xab, 0x8a, 0xaf,
0x72, 0x77, 0xc9, 0xcd, 0x6d, 0xa4, 0x19, 0xbb, 0x68, 0xba, 0x4f, 0xe6, 0x77,
0xe9, 0x92, 0x1e, 0xb7, 0xde, 0x9f, 0xdf, 0xc0, 0x94, 0x19, 0x48, 0x9b, 0x81,
0xd2, 0x7c, 0x34, 0xe4, 0xe3, 0xc2, 0x2e, 0x0d, 0x4a, 0xbb, 0x44, 0x86, 0x82,
0xe0, 0x0e, 0x4a, 0xdc, 0x7b, 0x6b, 0x97, 0xde, 0x3a, 0xb0, 0x7e, 0x60, 0x7b,
0x97, 0x56, 0x47, 0xe1, 0xd2, 0xe7, 0xfc, 0x9a, 0x92, 0xc8, 0x92, 0x72, 0xe8,
0xe9, 0xa8, 0x38, 0x44, 0x98, 0xa6, 0xf1, 0x4b, 0x7e, 0x04, 0xb5, 0x11, 0x9c,
0x34, 0xe1, 0x8c, 0x74, 0xfb, 0x4a, 0x73, 0xd1, 0xc0, 0xc5, 0x20, 0x3a, 0xa6,
0x40, 0xaf, 0x3c, 0xd6, 0x25, 0x2e, 0xf3, 0xca, 0x84, 0x43, 0x3e, 0x3c, 0x65,
0x68, 0x06, 0xdc, 0x31, 0x25, 0xba, 0xff, 0x2e, 0xa6, 0x2b, 0x58, 0x59, 0x1a,
0x56, 0x08, 0xfe, 0xd1, 0x11, 0x40, 0x9b, 0xcc, 0x5f, 0x76, 0xee, 0xd3, 0x7b,
0xd2, 0x3b, 0xfd, 0x89, 0x0a, 0x50, 0x4a, 0x3b, 0xbd, 0x0a, 0x76, 0x51, 0xff,
0xaa, 0xc2, 0x86, 0xc2, 0xa6, 0xdf, 0xf0, 0x89, 0x9a, 0xc3, 0xe4, 0x7d, 0xd5,
0x02, 0x75, 0x0a, 0x38, 0x27, 0x22, 0xfd, 0xb3, 0xe0, 0x9a, 0x85, 0xcd, 0x1d,
0x50, 0x3e, 0xb2, 0xc1, 0x05, 0xe7, 0xa6, 0x0d, 0x61, 0x44, 0x73, 0xc9, 0x66,
0xa4, 0x8e, 0x0d, 0x6a, 0x13, 0x38, 0x55, 0x00, 0x4e, 0xf4, 0x91, 0xa9, 0x3e,
0x22, 0x5c, 0x8c, 0xe5, 0x0a, 0x30, 0xc6, 0xb7, 0x91, 0xf1, 0x9c, 0xfd, 0xed,
0x0a, 0x68, 0x2b, 0xc1, 0xd9, 0x83, 0x45, 0xc2, 0x82, 0x50, 0xd8, 0x8e, 0x43,
0xcf, 0xdc, 0x98, 0xe5, 0xab, 0x4b, 0x01, 0x0e, 0x05, 0x74, 0x29, 0xa0, 0x5b,
0xea, 0xc4, 0x87, 0xae, 0x18, 0xb7, 0xc4, 0x7e, 0x05, 0xb8, 0xe4, 0xfa, 0xd7,
0x66, 0xd0, 0x37, 0x83, 0xb9, 0x4a, 0x66, 0x4d, 0xa6, 0x33, 0x32, 0x68, 0x41,
0x01, 0x07, 0x0e, 0x05, 0xe4, 0x78, 0x54, 0x01, 0x1b, 0x22, 0x36, 0xc4, 0x05,
0x17, 0x69, 0x3c, 0x05, 0xb9, 0x58, 0x91, 0x43, 0x6e, 0x49, 0xb9, 0x6d, 0x32,
0xb7, 0xa4, 0xc9, 0x89, 0x70, 0x3a, 0x11, 0x12, 0x13, 0x41, 0x99, 0x08, 0x0f,
0x17, 0xc7, 0x48, 0x32, 0x78, 0xb8, 0x42, 0xd4, 0x9f, 0x81, 0xae, 0x8c, 0x9f,
0x6b, 0xf6, 0x6d, 0xdb, 0xa6, 0x65, 0xd3, 0x64, 0x5e, 0x96, 0xae, 0x69, 0xae,
0x12, 0xd4, 0xca, 0xbf, 0xcf, 0xce, 0xda, 0xac, 0x84, 0x56, 0x25, 0x20, 0xcd,
0xcb, 0xc1, 0x73, 0x39, 0x58, 0x97, 0x88, 0x0d, 0x89, 0x98, 0xad, 0x84, 0xb3,
0xbc, 0x70, 0xf9, 0x32, 0x1a, 0x97, 0xf1, 0x9f, 0x6e, 0x50, 0xee, 0x99, 0xc6,
0xae, 0x47, 0xd3, 0x82, 0x18, 0x5d, 0xc2, 0xc5, 0xe7, 0x36, 0x0e, 0x73, 0x39,
0x7e, 0xd8, 0x48, 0xf2, 0x1f, 0x09, 0x8a, 0x13, 0x6b, 0x57, 0xca, 0x60, 0x49,
0xb2, 0xfb, 0x0e, 0x5b, 0x88, 0xc5, 0xcb, 0x3b, 0x19, 0xde, 0xa2, 0x57, 0xb7,
0xc4, 0xdc, 0xb6, 0xa8, 0x67, 0x2b, 0x16, 0x4e, 0x6c, 0xd1, 0xa9, 0x2d, 0xe9,
0x41, 0xf0, 0xe2, 0x39, 0x2f, 0x6a, 0x36, 0xe9, 0x56, 0x2a, 0x3d, 0x7b, 0x57,
0x0c, 0xa9, 0x50, 0xda, 0x0d, 0xc2, 0x57, 0xcf, 0x26, 0x35, 0x6c, 0x4a, 0x7e,
0x51, 0x50, 0x15, 0xc2, 0x1e, 0x4b, 0xf8, 0x6c, 0x1a, 0xce, 0xc7, 0xe4, 0x8f,
0xae, 0x20, 0x74, 0x07, 0xe1, 0x9f, 0x66, 0xa3, 0xde, 0xdc, 0xa6, 0xdb, 0xdb,
0x0f, 0x85, 0x09, 0x2d, 0x5c, 0xd7, 0xc2, 0x37, 0x34, 0xbf, 0x0f, 0xdd, 0x05,
0xf7, 0xdd, 0x9f, 0xf6, 0x2c, 0xe4, 0xa6, 0xa2, 0xfd, 0xbb, 0xde, 0xb2, 0x78,
0xad, 0x7c, 0x13, 0x6a, 0x4d, 0xf8, 0x0d, 0xed, 0xf1, 0xff, 0x12, 0x06, 0x7f,
0xbb, 0x03, 0x7a, 0x1d, 0xf0, 0x0f, 0xf6, 0xd2, 0x9c, 0x08, 0xad, 0x89, 0xf0,
0xcf, 0xec, 0x6a, 0x36, 0x80, 0xf3, 0xf2, 0x63, 0xbc, 0xe9, 0xc0, 0x6d, 0x07,
0x7e, 0xf3, 0x59, 0x2d, 0x6c, 0x42, 0xc7, 0x17, 0x2d, 0x4f, 0x56, 0xec, 0xab,
0x78, 0x7d, 0xf4, 0x68, 0xd2, 0x97, 0xb4, 0xf4, 0xe5, 0xf2, 0x43, 0x03, 0x6f,
0x8d, 0xfd, 0xb1, 0xd5, 0x81, 0x7d, 0x05, 0x18, 0xc4, 0x05, 0xbc, 0x76, 0xac,
0x62, 0x0d, 0x87, 0x97, 0x51, 0xf7, 0x48, 0xfa, 0x49, 0x6a, 0x7f, 0xa6, 0xf7,
0x99, 0x9d, 0xdf, 0xdb, 0x39, 0xe1, 0x7d, 0x51, 0x31, 0x86, 0x9a, 0x7a, 0xb4,
0xbf, 0x7b, 0xeb, 0xad, 0xfe, 0xb7, 0x83, 0xdf, 0x9d, 0xfa, 0xef, 0x39, 0x87,
0xe8, 0xe4, 0xbb, 0x57, 0xde, 0x9c, 0xfb, 0x9e, 0xab, 0x09, 0x17, 0xce, 0x60,
0xde, 0x73, 0x25, 0x47, 0xee, 0x7d, 0xa7, 0xf0, 0x60, 0x55, 0x1a, 0x71, 0x69,
0x88, 0x70, 0x6d, 0xf9, 0xd5, 0xa8, 0x7a, 0x8a, 0x93, 0x87, 0xd7, 0x6c, 0xaf,
0xe5, 0xbe, 0xae, 0x7e, 0x9d, 0x0e, 0xe9, 0x88, 0x4d, 0x45, 0x72, 0x0e, 0x66,
0x7e, 0x95, 0xfc, 0xa4, 0x5a, 0x4d, 0x68, 0x7e, 0x32, 0x49, 0xfa, 0xe8, 0x26,
0x1a, 0x9e, 0x5a, 0x4b, 0x25, 0x57, 0x3e, 0xdc, 0xfc, 0x4c, 0x5b, 0x4c, 0xa8,
0x63, 0x13, 0x16, 0x82, 0x38, 0xff, 0x46, 0xc5, 0xe3, 0xfa, 0xc3, 0x79, 0x2f,
0x9e, 0x7b, 0x71, 0xe4, 0xf0, 0xec, 0x47, 0x96, 0x93, 0x79, 0xaf, 0xfe, 0x27,
0xdf, 0xf7, 0xab, 0x7e, 0x70, 0xfa, 0xd5, 0x8a, 0x83, 0x9a, 0xe3, 0x4b, 0xdf,
0x4f, 0xca, 0x21, 0xab, 0x19, 0x44, 0xf9, 0xf4, 0xca, 0xa7, 0xb4, 0xe6, 0x55,
0xf3, 0xab, 0xba, 0x3c, 0x52, 0x94, 0x47, 0x52, 0x3f, 0xbe, 0xf9, 0xbe, 0xf6,
0xd1, 0xc2, 0x57, 0xae, 0xd4, 0xe0, 0xb2, 0x1a, 0xa3, 0xaf, 0xd4, 0xfe, 0x30,
0x3f, 0x8f, 0x18, 0x9f, 0x88, 0x9c, 0xac, 0x3e, 0x52, 0x7b, 0x84, 0xea, 0x8e,
0x16, 0x1d, 0xe5, 0xd4, 0xbf, 0x98, 0x58, 0x8a, 0x09, 0x0c, 0x3d, 0xe3, 0x7e,
0x66, 0xf3, 0x83, 0x3b, 0x1f, 0xe8, 0x37, 0xa1, 0x40, 0x78, 0xe0, 0x1a, 0x8f,
0x78, 0x1e, 0x99, 0x38, 0x4d, 0x5a, 0x2b, 0xa5, 0x2f, 0x19, 0x75, 0x7d, 0xe6,
0xf9, 0xed, 0x1b, 0x1f, 0xd2, 0xe6, 0x0f, 0x36, 0x7e, 0xb7, 0xf7, 0x15, 0xda,
0xf2, 0x49, 0xc3, 0x93, 0xe9, 0xef, 0xd1, 0x91, 0x77, 0x3c, 0xef, 0xd0, 0x1a,
0x25, 0x89, 0xec, 0x3c, 0x40, 0x6c, 0xd3, 0x3a, 0x5a, 0xd7, 0xa5, 0x4d, 0xe1,
0x69, 0xec, 0xde, 0x36, 0xb9, 0x98, 0x0d, 0x95, 0xd9, 0xc0, 0x43, 0x3a, 0x51,
0x8d, 0x53, 0x71, 0x61, 0x8d, 0xb6, 0xa9, 0xa0, 0x53, 0xf2, 0xbb, 0x6f, 0x36,
0xc2, 0x76, 0x6c, 0x37, 0xfc, 0x74, 0x19, 0x2e, 0xbd, 0xd7, 0xbb, 0x81, 0xf1,
0x33, 0xa0, 0x71, 0xe0, 0x44, 0x5a, 0x6e, 0x2c, 0x55, 0x3d, 0x03, 0xb5, 0x12,
0x01, 0xbf, 0x9b, 0x01, 0x79, 0xb9, 0x34, 0x87, 0x29, 0xb5, 0x2c, 0xa6, 0x2f,
0xa9, 0x40, 0xc5, 0x5b, 0x8a, 0x5d, 0xf0, 0x1a, 0xaf, 0x16, 0x22, 0xe7, 0x54,
0x50, 0x38, 0x86, 0x25, 0x63, 0xb1, 0xda, 0x85, 0x2a, 0x28, 0x11, 0xbd, 0x95,
0xab, 0xc0, 0xa8, 0x82, 0x5f, 0x8a, 0xf7, 0xea, 0x9b, 0x3e, 0x2d, 0x8d, 0x06,
0x16, 0xca, 0x21, 0xb3, 0x9f, 0x5f, 0x4c, 0x63, 0x6d, 0x4a, 0x36, 0x76, 0xd8,
0x93, 0x46, 0x7a, 0x1e, 0x9f, 0x3b, 0x79, 0x3d, 0x8f, 0x54, 0x9f, 0xb8, 0xf8,
0x69, 0xf9, 0x57, 0x37, 0x8f, 0xad, 0x3f, 0x51, 0x75, 0xac, 0xe1, 0x29, 0xe5,
0xdf, 0x35, 0x7d, 0x7e, 0x7f, 0x5f, 0xc3, 0x6f, 0xd9, 0x9a, 0x09, 0xb5, 0x7f,
0x91, 0xf1, 0xce, 0x55, 0x3b, 0xb9, 0x3c, 0x41, 0x22, 0x7f, 0x60, 0x7f, 0x31,
0xeb, 0xd1, 0x74, 0x1b, 0x19, 0x79, 0xdf, 0xf3, 0x7e, 0xb6, 0x95, 0xac, 0x81,
0xa2, 0x9d, 0x24, 0x1a, 0x88, 0x05, 0xae, 0xbc, 0x3d, 0x7e, 0xc0, 0xf4, 0x0e,
0x4d, 0xe0, 0x18, 0x51, 0x92, 0xb1, 0x37, 0xaf, 0x3d, 0xd2, 0xed, 0x26, 0x9b,
0xa7, 0x5a, 0xf0, 0xfe, 0xb1, 0xd3, 0x1c, 0x63, 0xe1, 0x59, 0x58, 0xfb, 0x2c,
0x4d, 0x4d, 0xe6, 0x8c, 0xa4, 0x35, 0x88, 0x8d, 0x2a, 0xbc, 0xfe, 0xce, 0xe6,
0x3b, 0xb3, 0x7f, 0x50, 0xfb, 0xda, 0x81, 0x6b, 0x07, 0x57, 0x34, 0xd8, 0xa8,
0xc1, 0xe5, 0x17, 0x3c, 0xcf, 0x35, 0x7d, 0xba, 0xf0, 0x58, 0x50, 0xc7, 0xfc,
0x76, 0x34, 0x9a, 0x48, 0xa7, 0x38, 0x8d, 0x20, 0x59, 0xc1, 0x4e, 0x2b, 0xd8,
0x65, 0x0d, 0x38, 0x78, 0x6a, 0x33, 0x03, 0xb7, 0x39, 0x63, 0x18, 0xd3, 0x40,
0x62, 0x94, 0x38, 0x3f, 0x3f, 0xf3, 0x79, 0xf7, 0x2b, 0x53, 0xc3, 0x0f, 0x10,
0x60, 0xd7, 0xb3, 0x5e, 0x3d, 0xa3, 0xcb, 0x1a, 0xc8, 0x48, 0xa1, 0xdb, 0x7a,
0x26, 0xd1, 0x35, 0xcc, 0x78, 0x69, 0x65, 0x50, 0x2a, 0xb2, 0xa5, 0x81, 0x3b,
0xbc, 0x8d, 0xbb, 0x1a, 0x50, 0xec, 0x21, 0x75, 0x73, 0x56, 0x0c, 0x70, 0xad,
0x07, 0x9b, 0xfb, 0xb1, 0xb5, 0xff, 0x6b, 0xb8, 0xac, 0xd3, 0x42, 0x83, 0x16,
0xc6, 0x54, 0xd8, 0xf7, 0x76, 0x92, 0x8d, 0x14, 0xe5, 0x03, 0xad, 0xca, 0x07,
0x53, 0x3e, 0xe8, 0xf2, 0x81, 0x27, 0x8a, 0xf3, 0xe1, 0x42, 0x3e, 0xd4, 0xe7,
0x62, 0xd6, 0x57, 0x15, 0xc2, 0xcd, 0x5a, 0x57, 0x80, 0x2a, 0x25, 0xe1, 0xd1,
0xfc, 0x7c, 0xd0, 0x4a, 0x2f, 0x11, 0x6b, 0xaa, 0xd8, 0xd5, 0xc7, 0x9d, 0x6a,
0x56, 0xce, 0x53, 0x1c, 0x9e, 0x38, 0x86, 0xca, 0x31, 0x49, 0xbf, 0xdb, 0xe4,
0xa3, 0xb8, 0x25, 0x66, 0xa3, 0x81, 0x7d, 0x11, 0x0d, 0xf4, 0xac, 0xa3, 0x7b,
0x9a, 0xe8, 0xd6, 0x89, 0x3a, 0x83, 0x0f, 0x79, 0x55, 0x03, 0x09, 0x41, 0x31,
0x71, 0x7b, 0x18, 0x7b, 0xc3, 0x58, 0x97, 0xca, 0xd4, 0x61, 0xf2, 0xbb, 0xbb,
0x1c, 0x52, 0x15, 0x40, 0x93, 0xa0, 0x34, 0x35, 0x6d, 0x68, 0x6e, 0xc3, 0x9a,
0x1d, 0x34, 0xef, 0x60, 0x0a, 0x9f, 0x09, 0xca, 0x3b, 0x97, 0xf9, 0xa4, 0x6e,
0x6b, 0x60, 0x37, 0x7e, 0x82, 0x43, 0xb3, 0x16, 0x5a, 0xc5, 0x34, 0xb3, 0xb5,
0x50, 0x9f, 0x46, 0x1c, 0x25, 0x38, 0x57, 0xcc, 0x02, 0xc5, 0x8c, 0x6e, 0xb6,
0xe3, 0x76, 0xbb, 0xc4, 0x95, 0xb5, 0xa0, 0x7f, 0x80, 0x87, 0x4a, 0x2d, 0xac,
0x4e, 0x93, 0x1b, 0xd3, 0xc4, 0xc8, 0x41, 0x3a, 0x5e, 0xa4, 0x8c, 0x54, 0xc8,
0x99, 0xa3, 0x06, 0x76, 0x41, 0x4d, 0x2c, 0x39, 0xd8, 0xa8, 0x85, 0x4b, 0x5a,
0xe0, 0x21, 0x72, 0xac, 0x94, 0x6b, 0x41, 0x94, 0x8c, 0xe1, 0x48, 0xea, 0x0d,
0x3a, 0x79, 0x44, 0xee, 0x15, 0xed, 0x5a, 0x78, 0x94, 0x5a, 0xb5, 0xd0, 0xd6,
0x8e, 0x9d, 0xbc, 0xb3, 0xd4, 0x49, 0xc8, 0xb4, 0x91, 0x71, 0x05, 0xfd, 0xf6,
0x99, 0x72, 0xd2, 0xdd, 0x21, 0x61, 0x99, 0x17, 0xa1, 0x8e, 0x58, 0xff, 0xc5,
0x05, 0x70, 0xa1, 0x60, 0xef, 0xc3, 0x51, 0x5d, 0xc5, 0x6a, 0xab, 0x18, 0x6d,
0x29, 0x80, 0x76, 0x0e, 0xaf, 0x2f, 0x60, 0x97, 0x0f, 0xdc, 0x32, 0xb0, 0x05,
0x2d, 0xb0, 0x1b, 0x5a, 0xc8, 0xcd, 0x67, 0x57, 0x35, 0xac, 0x5c, 0x07, 0x46,
0x1d, 0xd4, 0xe8, 0xc0, 0x2c, 0x1f, 0x1b, 0xd3, 0xa4, 0x03, 0x2b, 0x8f, 0x4d,
0x17, 0xb3, 0xeb, 0xc5, 0xac, 0xa3, 0x18, 0x6d, 0xc2, 0x06, 0xd0, 0xa6, 0x83,
0x4e, 0x1d, 0x54, 0x96, 0xb1, 0x8b, 0x65, 0xb1, 0x67, 0xb6, 0x5f, 0x07, 0xe8,
0x14, 0x35, 0x86, 0x74, 0xe0, 0x8e, 0x1f, 0x38, 0x33, 0xa1, 0x83, 0x29, 0x1d,
0xc8, 0xe1, 0xde, 0x17, 0x9b, 0x06, 0x31, 0xe5, 0x0f, 0x95, 0x99, 0x8c, 0xfa,
0x47, 0x71, 0x91, 0x8b, 0x1b, 0x1a, 0x2d, 0x3b, 0x1f, 0x7f, 0xf6, 0x27, 0x6d,
0x38, 0x63, 0xc3, 0x9f, 0x7d, 0x04, 0xfb, 0xfa, 0x61, 0xa0, 0x1f, 0xe8, 0xaf,
0xc5, 0x83, 0xfe, 0xb3, 0xbf, 0x31, 0x13, 0x3b, 0x9b, 0x42, 0xca, 0xfe, 0xea,
0xfc, 0x87, 0xee, 0x66, 0x5c, 0x1a, 0x85, 0x94, 0x3f, 0x4a, 0xfb, 0xa3, 0x3a,
0x3d, 0xa9, 0x7d, 0x32, 0xf7, 0x15, 0xf1, 0xc9, 0x70, 0x2a, 0x7c, 0xaf, 0x14,
0x09, 0xd2, 0xea, 0x34, 0x52, 0x9b, 0x46, 0xba, 0x8e, 0x77, 0x1f, 0x1f, 0x33,
0x13, 0xa3, 0x92, 0x0d, 0x8f, 0x82, 0x38, 0x13, 0x7f, 0xca, 0x4c, 0x2a, 0x7b,
0x88, 0xe9, 0xd9, 0x7b, 0x25, 0x24, 0x7f, 0x8e, 0x38, 0x8e, 0x74, 0x3c, 0x72,
0xd6, 0x46, 0x06, 0x46, 0x21, 0x79, 0x84, 0x4f, 0x79, 0x6c, 0x80, 0xac, 0x7c,
0xe7, 0x46, 0x1a, 0xbb, 0x3f, 0x8c, 0x9e, 0xf7, 0x3b, 0x8e, 0xfa, 0x1f, 0xdb,
0x78, 0x62, 0xea, 0x58, 0xc6, 0xb1, 0xac, 0x63, 0x7d, 0x27, 0xce, 0x7c, 0x78,
0x55, 0xcd, 0xda, 0x8c, 0x6c, 0xfa, 0xc0, 0x79, 0x0b, 0x47, 0xe0, 0xda, 0x36,
0x46, 0xb6, 0xc5, 0x74, 0x32, 0x78, 0x4a, 0x65, 0x61, 0x67, 0x2c, 0x4c, 0x25,
0xe0, 0x74, 0xc9, 0xc4, 0xc6, 0x8f, 0xab, 0x85, 0xd4, 0x44, 0x97, 0x02, 0xb0,
0xc2, 0xb5, 0xf4, 0x3a, 0x0b, 0x6b, 0x10, 0x59, 0x73, 0x1b, 0xd8, 0xf8, 0x92,
0xd6, 0xc8, 0x68, 0xe5, 0x35, 0xf4, 0x1d, 0x1d, 0x30, 0x61, 0xaa, 0x0f, 0xef,
0xfd, 0xbe, 0xaa, 0x09, 0x13, 0xd5, 0x2c, 0xf2, 0xcc, 0xb9, 0x88, 0x84, 0x9c,
0x9a, 0x1a, 0x34, 0xd7, 0xe0, 0xba, 0x11, 0x0b, 0x3f, 0x50, 0x2b, 0x59, 0xea,
0x02, 0x14, 0x58, 0x89, 0xde, 0x4a, 0xd2, 0x16, 0x80, 0x16, 0x66, 0xb2, 0xab,
0x9f, 0x5c, 0x31, 0x60, 0xa9, 0x92, 0xed, 0xfe, 0x59, 0xe9, 0x93, 0xd1, 0x97,
0xca, 0x5f, 0x9e, 0x37, 0x31, 0x5a, 0xe5, 0x44, 0x93, 0x13, 0x33, 0x16, 0x00,
0xf6, 0xa5, 0x2f, 0x40, 0xca, 0x02, 0xb0, 0x70, 0x17, 0xb9, 0xf9, 0x06, 0x57,
0xa6, 0xcb, 0x0c, 0xec, 0x6c, 0x17, 0x51, 0x2f, 0x40, 0xbd, 0x1b, 0x2d, 0x6e,
0xa4, 0xd9, 0x0b, 0x70, 0x56, 0xec, 0x0e, 0xbb, 0x1f, 0xc2, 0xc2, 0xb7, 0xdb,
0x9f, 0x0f, 0x9c, 0x61, 0x62, 0x33, 0x1a, 0x76, 0x17, 0x22, 0xd5, 0xf5, 0xe0,
0xce, 0x23, 0x29, 0x78, 0x76, 0xdf, 0xcd, 0x1f, 0x91, 0xfe, 0x64, 0x12, 0x0c,
0x22, 0x5d, 0x6f, 0xc2, 0x17, 0x4c, 0xef, 0x15, 0x2d, 0x80, 0x66, 0x01, 0xce,
0x2f, 0x40, 0x7f, 0x0f, 0x46, 0x9e, 0xed, 0xfc, 0xbe, 0xbf, 0x8b, 0x24, 0x95,
0xb3, 0xae, 0x1e, 0xec, 0xee, 0x41, 0xdd, 0x02, 0xd4, 0xb4, 0x13, 0x57, 0x29,
0xb3, 0xd1, 0x3a, 0x27, 0xa6, 0xbe, 0xdb, 0xaa, 0x61, 0x5b, 0xa3, 0xb8, 0xf4,
0x41, 0xce, 0x9f, 0x57, 0x3c, 0xeb, 0x7a, 0x63, 0xb8, 0x99, 0x98, 0x8b, 0x05,
0x35, 0x58, 0x82, 0x1b, 0xb1, 0x77, 0x3b, 0x96, 0x97, 0xa0, 0xc6, 0x4e, 0xcc,
0x76, 0xb2, 0x22, 0x03, 0xb6, 0xf8, 0x65, 0x7b, 0x09, 0x16, 0x1a, 0x31, 0xc8,
0xb5, 0xc2, 0x85, 0x75, 0xac, 0x7f, 0xf3, 0xbc, 0x95, 0xcd, 0xd5, 0x61, 0xa0,
0x0e, 0x69, 0xb8, 0x8c, 0x15, 0x1d, 0xf7, 0x0c, 0xe3, 0xdd, 0x25, 0x50, 0x70,
0x09, 0xd1, 0x5e, 0x87, 0xbd, 0x75, 0xb2, 0x7a, 0xd2, 0xcc, 0x56, 0x9a, 0xd9,
0x68, 0x19, 0x73, 0xb5, 0x11, 0xfe, 0x64, 0xd9, 0x48, 0x27, 0xc7, 0x29, 0x6d,
0xb6, 0x60, 0xed, 0x3b, 0x2a, 0x5e, 0xf0, 0x4c, 0x10, 0x54, 0x31, 0x89, 0x52,
0x13, 0x84, 0xb1, 0x2f, 0x23, 0x3e, 0xcc, 0x6c, 0xc2, 0x9c, 0x26, 0xa4, 0xa5,
0x41, 0x30, 0x48, 0x39, 0x3a, 0x13, 0x46, 0xa0, 0x56, 0xf2, 0x91, 0xd3, 0xaa,
0x20, 0x5c, 0x7b, 0x39, 0xbd, 0x24, 0xb6, 0x32, 0x9b, 0x82, 0x60, 0x0d, 0xc2,
0x65, 0x2b, 0xeb, 0x54, 0x90, 0xd3, 0x56, 0x6c, 0x0e, 0x02, 0x5a, 0xa5, 0x2a,
0x31, 0x39, 0xf5, 0xa1, 0xb8, 0xea, 0xb7, 0xe0, 0xa2, 0x05, 0xef, 0x1b, 0x59,
0x52, 0x15, 0x9b, 0xf4, 0xc1, 0x8c, 0x0f, 0xea, 0xd4, 0xd8, 0xa0, 0xc6, 0x6a,
0x35, 0xd6, 0xaa, 0xb1, 0x5e, 0x8d, 0x96, 0x78, 0xc8, 0xd5, 0x3d, 0x35, 0x8e,
0x1d, 0xc9, 0x3e, 0x7a, 0x7e, 0x0d, 0xe9, 0x50, 0x3b, 0x73, 0xb7, 0xf3, 0xe1,
0x0e, 0x77, 0xe0, 0xd5, 0x0e, 0xec, 0x52, 0x63, 0xb7, 0x1a, 0x8b, 0xeb, 0xb1,
0xeb, 0xe3, 0x48, 0x32, 0x99, 0xfb, 0x63, 0x8f, 0x0f, 0x3b, 0xd4, 0x48, 0xba,
0xde, 0x74, 0xbc, 0xd9, 0xa9, 0xc6, 0xcd, 0x5c, 0x4c, 0x39, 0x68, 0x7b, 0xb4,
0xef, 0xe3, 0xd3, 0xb7, 0x91, 0x46, 0x73, 0x71, 0x83, 0xf3, 0xf3, 0x09, 0x33,
0x6a, 0x39, 0xae, 0x1a, 0xd5, 0xc8, 0xda, 0xd5, 0xc8, 0x2f, 0x97, 0x78, 0x07,
0xd9, 0x2a, 0x76, 0x56, 0xc5, 0x84, 0x16, 0x86, 0x96, 0x4f, 0x13, 0x52, 0x1e,
0x1f, 0x30, 0x8a, 0x66, 0x6c, 0xa2, 0xeb, 0x36, 0x35, 0x76, 0x8a, 0x2b, 0xef,
0x09, 0x46, 0x93, 0x89, 0xf4, 0xf0, 0x4f, 0x2a, 0x59, 0xd6, 0x8f, 0xaf, 0x08,
0xe8, 0xa8, 0x1a, 0x7b, 0x0e, 0x67, 0xa7, 0x11, 0x93, 0x95, 0xd1, 0x21, 0x35,
0xba, 0xd5, 0xd8, 0xa6, 0x63, 0x9d, 0x3a, 0x36, 0xac, 0xc6, 0xab, 0x6a, 0x69,
0x93, 0xae, 0x85, 0x39, 0xc4, 0xda, 0x8d, 0x9a, 0xd8, 0x86, 0x49, 0x2c, 0xef,
0x21, 0x23, 0x5b, 0xc9, 0x23, 0x8b, 0x22, 0x73, 0xae, 0x92, 0x05, 0x2a, 0x19,
0x97, 0x8b, 0x42, 0xea, 0xbf, 0xef, 0xb9, 0xf6, 0xb7, 0xb3, 0x45, 0x31, 0x53,
0xd4, 0xe4, 0xe3, 0xf9, 0x7c, 0x14, 0xdf, 0xa7, 0x41, 0x2c, 0xca, 0xdf, 0x53,
0xb4, 0x26, 0x1f, 0xcd, 0xf9, 0x58, 0x9f, 0x8f, 0x96, 0x38, 0xb4, 0x2d, 0x1f,
0x3b, 0x1f, 0x96, 0x18, 0xcc, 0xc7, 0x2b, 0xf9, 0x5c, 0xef, 0xce, 0xd0, 0x62,
0x96, 0x30, 0xfb, 0x36, 0xe3, 0xb8, 0x92, 0x9c, 0xb1, 0x10, 0xfd, 0x6b, 0x1d,
0x6f, 0x99, 0xf9, 0xb3, 0x0e, 0x39, 0x8d, 0x70, 0x3b, 0x83, 0xed, 0x0a, 0x9e,
0x43, 0xeb, 0xec, 0xd8, 0x60, 0x47, 0xba, 0x5a, 0xc9, 0x6e, 0x54, 0x32, 0xba,
0xd3, 0x88, 0x3d, 0x4f, 0x3b, 0x3c, 0x9c, 0xcf, 0x9a, 0x81, 0x44, 0x57, 0x89,
0x69, 0x99, 0x0c, 0x1b, 0x48, 0x64, 0x82, 0xb7, 0x3d, 0x61, 0x86, 0xb2, 0x51,
0x72, 0x2f, 0x99, 0x0d, 0x35, 0x33, 0x77, 0x33, 0x1b, 0x76, 0xe3, 0x2d, 0x2e,
0xbe, 0x5d, 0x9b, 0x25, 0xc1, 0x59, 0x32, 0x6e, 0x86, 0x51, 0x33, 0x34, 0xf3,
0xc8, 0x13, 0x35, 0x07, 0x15, 0x47, 0xcf, 0x56, 0x12, 0x8f, 0xb0, 0xdf, 0xce,
0xf2, 0x60, 0xad, 0x9b, 0x5c, 0x59, 0x97, 0x1d, 0xcb, 0x66, 0xf0, 0x99, 0xa1,
0xcb, 0xc2, 0xba, 0x2d, 0x6c, 0xb6, 0x12, 0xe7, 0x2b, 0x31, 0xd3, 0xc2, 0x8c,
0xc9, 0x34, 0x61, 0x9e, 0x17, 0x5b, 0x30, 0x03, 0xb6, 0xe5, 0x91, 0x92, 0xb8,
0x14, 0x5d, 0xbd, 0x8d, 0xe6, 0xc7, 0xee, 0xc9, 0xd2, 0xb5, 0xd8, 0x5a, 0x4f,
0xef, 0xc4, 0x0c, 0xc2, 0x89, 0xf5, 0xa0, 0xe4, 0x5a, 0x64, 0xb2, 0xd0, 0x24,
0x93, 0x24, 0xd3, 0x2a, 0x8f, 0x12, 0xd9, 0x48, 0x7b, 0xa6, 0x1e, 0x54, 0xf5,
0xb0, 0x07, 0x53, 0x89, 0x1d, 0x4c, 0xd9, 0xc1, 0xd6, 0xac, 0x98, 0xf9, 0xec,
0xbd, 0x19, 0x6c, 0x51, 0xb2, 0xab, 0xef, 0x0f, 0x1f, 0x9a, 0x7b, 0x43, 0x9f,
0xc8, 0x5a, 0x72, 0x58, 0x7b, 0x0e, 0x7b, 0xe8, 0x07, 0x2a, 0x67, 0x33, 0xe5,
0xec, 0xd7, 0x88, 0x5c, 0x7f, 0x7d, 0x8b, 0x9d, 0x8e, 0x85, 0x74, 0xec, 0xe7,
0xf5, 0x92, 0xd8, 0x04, 0xca, 0x26, 0xf8, 0x47, 0xba, 0xda, 0x69, 0x86, 0x7b,
0xcd, 0x3f, 0xff, 0x40, 0x53, 0x2b, 0xd4, 0x5a, 0xe1, 0x57, 0x3c, 0xab, 0x98,
0xa9, 0xb7, 0x1d, 0xc6, 0xf7, 0xbe, 0x42, 0xfc, 0x8f, 0xf5, 0x52, 0xd5, 0x01,
0xa6, 0x0e, 0xf8, 0x45, 0xba, 0xaa, 0xb6, 0x41, 0xad, 0x0d, 0xfe, 0xc9, 0x13,
0x2a, 0xbb, 0x0c, 0x15, 0x97, 0xf7, 0x7a, 0x1b, 0xda, 0xba, 0xa0, 0xb3, 0x0b,
0x7e, 0x45, 0x2b, 0x22, 0xd1, 0x09, 0x4a, 0xe7, 0x37, 0xe9, 0x6c, 0xc2, 0x09,
0x53, 0x4e, 0xf8, 0x79, 0x5d, 0x15, 0x0b, 0x33, 0x6e, 0xd3, 0x8f, 0x32, 0x7f,
0xe2, 0xf4, 0x11, 0xce, 0xe3, 0xfb, 0xf5, 0xc4, 0xa5, 0x27, 0xf4, 0xec, 0x32,
0x67, 0x4f, 0x6c, 0x3d, 0xa1, 0xd6, 0x4f, 0x30, 0x6b, 0x19, 0xb2, 0x97, 0x81,
0x43, 0x4a, 0x2f, 0x33, 0xb5, 0x57, 0x9c, 0x1d, 0x38, 0x4b, 0x26, 0x1f, 0x1d,
0x50, 0x91, 0x82, 0xb7, 0x4b, 0xdf, 0xe9, 0xfe, 0xee, 0x9d, 0x09, 0x42, 0xab,
0x3e, 0x19, 0x7d, 0xa9, 0xf1, 0x99, 0xf6, 0xd7, 0x06, 0x8f, 0xf7, 0x7a, 0x08,
0x49, 0x20, 0x7e, 0x03, 0x09, 0x1a, 0x08, 0x9d, 0xd0, 0x93, 0x29, 0x3d, 0x91,
0xc3, 0xe5, 0x08, 0x09, 0xc9, 0x2f, 0xb1, 0xac, 0x7d, 0x10, 0xf9, 0x80, 0xe6,
0x3b, 0x89, 0xd6, 0x49, 0xea, 0xff, 0xaa, 0xf4, 0xb0, 0xee, 0x7f, 0xdc, 0x7c,
0x55, 0x61, 0x21, 0x77, 0xf5, 0x24, 0x7a, 0x70, 0x3c, 0x9f, 0xf9, 0xe3, 0xb6,
0x8b, 0xa9, 0x20, 0x4c, 0x88, 0xf8, 0x38, 0x0f, 0xc6, 0x24, 0x53, 0x1c, 0xb9,
0x1a, 0x84, 0xa1, 0x20, 0x64, 0xa7, 0x90, 0x89, 0xe7, 0x57, 0xc4, 0x67, 0x7a,
0x6a, 0xfe, 0xd2, 0xfc, 0x97, 0x19, 0x3f, 0xc9, 0xfa, 0x09, 0x75, 0x70, 0x0e,
0xc3, 0x8b, 0x38, 0x69, 0x0f, 0xff, 0x9f, 0x9c, 0x22, 0xe9, 0x2f, 0x5c, 0xad,
0x95, 0xf6, 0x7f, 0xdf, 0x39, 0x96, 0x71, 0xca, 0x2b, 0xce, 0x08, 0xbe, 0xf6,
0xb7, 0xbe, 0xbf, 0x1d, 0xfb, 0x0b, 0xef, 0x5f, 0xb4, 0x94, 0x11, 0xc3, 0x19,
0xb6, 0xc4, 0x99, 0xf6, 0x5a, 0x33, 0x89, 0x34, 0x13, 0xff, 0xff, 0x49, 0x3e,
0x14, 0xca, 0x22, 0x64, 0xe1, 0x06, 0xd9, 0x7d, 0xe2, 0xc6, 0x38, 0xa1, 0xba,
0x93, 0x45, 0x27, 0xa9, 0x66, 0x96, 0x34, 0xfc, 0x28, 0x78, 0x92, 0xd2, 0x54,
0x1d, 0xb9, 0x7e, 0xd0, 0x94, 0x21, 0x8d, 0xbb, 0xf1, 0xc4, 0xa5, 0x13, 0xba,
0x55, 0x72, 0xe7, 0x0f, 0x0c, 0x66, 0xd2, 0xbb, 0x00, 0x76, 0xc1, 0xf8, 0xbb,
0x17, 0xa0, 0x27, 0x88, 0xa7, 0x93, 0x49, 0x57, 0x23, 0x19, 0x7e, 0x65, 0x37,
0x83, 0x24, 0x9e, 0x38, 0x57, 0xc7, 0xa2, 0x4b, 0xb8, 0x7d, 0x8a, 0xcb, 0xe0,
0x2d, 0x01, 0x72, 0xf1, 0x5f, 0xbb, 0x1e, 0xf1, 0x3c, 0x76, 0xb3, 0x8e, 0xd0,
0x5b, 0x4b, 0xb0, 0xbe, 0x04, 0x87, 0x7e, 0x83, 0x4b, 0xdf, 0x25, 0xe4, 0x7a,
0x09, 0xe9, 0x0b, 0x90, 0x5d, 0x3f, 0xe1, 0x8c, 0x9c, 0xb3, 0x73, 0x9a, 0x19,
0x20, 0x91, 0x97, 0x4a, 0xcc, 0x82, 0x8d, 0x2f, 0x08, 0x4e, 0xde, 0x75, 0xc2,
0x30, 0x8c, 0x73, 0x4b, 0xd0, 0x5c, 0x4d, 0xf4, 0x79, 0x4c, 0x8e, 0xb4, 0x56,
0x13, 0xea, 0x9f, 0x26, 0x93, 0x4f, 0xd9, 0xc4, 0x8b, 0x7c, 0x53, 0x4b, 0x30,
0x21, 0xf1, 0x7c, 0xcf, 0x12, 0x8c, 0xf0, 0x3f, 0x07, 0xf1, 0x3a, 0x38, 0xf3,
0x76, 0x2f, 0xc1, 0x20, 0x07, 0x57, 0x5b, 0x49, 0xed, 0x83, 0x03, 0xc7, 0xc4,
0x79, 0x7a, 0xf3, 0x65, 0xac, 0x79, 0x09, 0xee, 0x5b, 0x49, 0x92, 0x38, 0xa0,
0xd0, 0xc2, 0x8b, 0x8c, 0x2c, 0xa1, 0x67, 0x29, 0xbe, 0x24, 0xae, 0x79, 0x99,
0xcf, 0xcb, 0x7e, 0x55, 0x74, 0xac, 0x5a, 0xcf, 0x14, 0x0a, 0x92, 0xfa, 0x49,
0xfa, 0x27, 0x26, 0x3d, 0x66, 0x06, 0xd8, 0xca, 0x67, 0x35, 0x9f, 0xdc, 0x7b,
0xef, 0xe2, 0xa7, 0x6b, 0xef, 0x46, 0xde, 0xed, 0xd3, 0x91, 0x01, 0xf1, 0x91,
0x62, 0x05, 0xb1, 0xbe, 0xa5, 0x79, 0x63, 0xec, 0x79, 0xcb, 0x31, 0xd5, 0xf1,
0xaa, 0x53, 0xa6, 0x53, 0x17, 0xf4, 0xb8, 0xea, 0x62, 0x5a, 0xd6, 0xf9, 0xc8,
0xad, 0x32, 0x42, 0xf3, 0x5e, 0x3d, 0xf7, 0x6a, 0x91, 0x1e, 0x75, 0x7a, 0x3c,
0xf3, 0xb6, 0xea, 0x6d, 0x41, 0xc5, 0xde, 0xba, 0xf7, 0x56, 0xa3, 0x9d, 0x28,
0x5e, 0xbe, 0xa4, 0x22, 0x67, 0xf5, 0xb8, 0x64, 0x64, 0x5e, 0x15, 0x9f, 0x68,
0x96, 0x1e, 0x33, 0xf4, 0x48, 0x55, 0x7a, 0x1c, 0x75, 0xb2, 0xf1, 0x34, 0xa2,
0xb0, 0x61, 0xa1, 0x9b, 0x95, 0xb8, 0xd9, 0xdd, 0x2e, 0x24, 0x49, 0x71, 0x59,
0x3d, 0xd5, 0x86, 0xe9, 0x22, 0x7e, 0x37, 0x95, 0x29, 0xd2, 0x18, 0xcd, 0xb3,
0x61, 0xbf, 0x8a, 0x04, 0x3f, 0x49, 0xc2, 0xdd, 0x03, 0xcd, 0x7f, 0x2e, 0x49,
0x9a, 0x34, 0xdf, 0x85, 0x8a, 0x47, 0xc9, 0x79, 0x1b, 0x96, 0x2d, 0xb3, 0xf9,
0xcf, 0x1d, 0x1b, 0xa8, 0xb1, 0x21, 0x4f, 0x45, 0x9d, 0xec, 0xfc, 0xa1, 0xc5,
0x27, 0xfe, 0xa3, 0xfd, 0xfb, 0x6e, 0xbd, 0xc8, 0x2d, 0x28, 0x65, 0xaa, 0x7d,
0x9b, 0x87, 0x4f, 0x37, 0x31, 0xda, 0x14, 0x42, 0xab, 0xf0, 0xf3, 0x94, 0xda,
0x70, 0xe4, 0xcd, 0x5b, 0x4a, 0x26, 0x70, 0xd6, 0x1f, 0x60, 0xae, 0x00, 0x6f,
0xae, 0xde, 0x86, 0x16, 0x1b, 0xea, 0x46, 0x98, 0xf2, 0xcb, 0xf3, 0x93, 0x98,
0x37, 0xc3, 0xce, 0xcd, 0x30, 0xda, 0x6c, 0xc3, 0xbe, 0x27, 0x97, 0x1e, 0xf3,
0x3f, 0x77, 0x45, 0xcd, 0x78, 0xbc, 0x55, 0x1e, 0x5d, 0x97, 0x0d, 0xbb, 0x6d,
0xc8, 0xc3, 0x8c, 0x8f, 0xc7, 0x9f, 0xcf, 0x79, 0x34, 0x18, 0xfa, 0x1a, 0xea,
0x57, 0x67, 0x30, 0xe3, 0xbf, 0xdc, 0x29, 0x65, 0x31, 0xcd, 0x63, 0x73, 0x17,
0x2f, 0xdd, 0x47, 0x9d, 0x1d, 0x8b, 0xec, 0xd8, 0x74, 0x1f, 0xcd, 0xdf, 0x4d,
0xf3, 0x0b, 0x31, 0x61, 0x90, 0x5d, 0x18, 0x64, 0xb4, 0xdc, 0x8e, 0xa9, 0x55,
0x24, 0xeb, 0xab, 0x0b, 0x5c, 0x2e, 0x8e, 0x4e, 0xe0, 0xc6, 0xc4, 0xc3, 0x96,
0xfa, 0xef, 0xa3, 0xeb, 0x7e, 0x3c, 0x39, 0x68, 0xc7, 0x2b, 0x9c, 0xef, 0xd7,
0x95, 0x60, 0x03, 0x17, 0xe2, 0xa2, 0x46, 0xb6, 0xc1, 0xa5, 0xc1, 0xcb, 0x1e,
0x70, 0x78, 0xb8, 0xcc, 0xc8, 0xff, 0x67, 0xfb, 0x88, 0x41, 0xcf, 0xc6, 0x54,
0x6c, 0xfc, 0xd9, 0x24, 0x2e, 0xd5, 0xe6, 0x85, 0xd0, 0x03, 0xd5, 0xc7, 0xed,
0x07, 0x1a, 0x9c, 0xcc, 0x1f, 0x86, 0xc5, 0x30, 0x2f, 0x35, 0xc3, 0x82, 0x27,
0x73, 0x54, 0x24, 0x33, 0x83, 0xce, 0xcc, 0x72, 0x39, 0xc8, 0x03, 0x6e, 0x5e,
0x6f, 0x73, 0x82, 0x6d, 0x4f, 0x3c, 0x5c, 0x63, 0x73, 0x1e, 0x08, 0xc4, 0xb7,
0x30, 0x94, 0xfb, 0xf0, 0x4e, 0x3a, 0xd9, 0xc9, 0x23, 0x17, 0x97, 0x85, 0x43,
0xb8, 0x7e, 0x0c, 0x2c, 0x62, 0xb7, 0x52, 0xcb, 0x18, 0xb4, 0xf3, 0x6b, 0x9f,
0x91, 0x69, 0x90, 0x0b, 0xe6, 0x83, 0xcb, 0xec, 0xca, 0x32, 0x93, 0x4c, 0xd9,
0x68, 0xdb, 0xc0, 0xfe, 0x10, 0x9e, 0xd6, 0x90, 0x5e, 0x5e, 0xa0, 0x3e, 0x82,
0x96, 0x08, 0x0e, 0x8e, 0xc1, 0x7a, 0x12, 0xd9, 0x4e, 0x22, 0x0b, 0x83, 0xc4,
0x5c, 0xca, 0xcb, 0x75, 0xd8, 0xd8, 0xc6, 0x0a, 0x21, 0x57, 0x44, 0x53, 0x61,
0x3d, 0xbb, 0xc9, 0x95, 0x7f, 0x59, 0xba, 0x94, 0x0c, 0x6c, 0x89, 0x2c, 0x98,
0xc8, 0xec, 0x51, 0xec, 0x8d, 0xe2, 0x9e, 0xd5, 0x5a, 0xef, 0x05, 0x8b, 0x17,
0x68, 0xa3, 0x17, 0x2e, 0xf1, 0x4b, 0x93, 0x17, 0xac, 0x5e, 0xa8, 0x31, 0x32,
0xb3, 0x51, 0xaa, 0xb4, 0x13, 0x66, 0x03, 0xc7, 0x2d, 0x12, 0xc3, 0xed, 0xf3,
0xc2, 0x80, 0xf7, 0xef, 0x21, 0xc3, 0xb9, 0x6a, 0xa6, 0x6a, 0x23, 0x69, 0x93,
0x5c, 0x70, 0xb1, 0xb2, 0x20, 0x97, 0x02, 0x37, 0xad, 0x6c, 0xdb, 0xca, 0x72,
0x67, 0x98, 0x9a, 0xdf, 0xe3, 0x11, 0x0f, 0xf3, 0x78, 0x98, 0xdf, 0xc2, 0x2a,
0x0e, 0x1d, 0xd1, 0x1a, 0x38, 0x6a, 0xdc, 0xe8, 0xe6, 0x7a, 0x04, 0xcd, 0x74,
0xb3, 0x1c, 0x77, 0x1c, 0x37, 0x98, 0xd9, 0xce, 0xbc, 0x7f, 0x6c, 0x5d, 0xc3,
0xb9, 0x08, 0x0b, 0x44, 0x24, 0x68, 0xf5, 0x18, 0xd4, 0x8e, 0x3d, 0x70, 0xdd,
0xcb, 0x68, 0x11, 0xb2, 0x63, 0x14, 0xdd, 0x51, 0xec, 0x8b, 0xb2, 0x81, 0x28,
0x2f, 0xd6, 0xcf, 0x81, 0x03, 0x63, 0xd0, 0x37, 0x06, 0x03, 0x22, 0xbb, 0x34,
0x9f, 0x19, 0xf2, 0x59, 0xec, 0x61, 0xf4, 0xb7, 0xb1, 0xc5, 0x36, 0x46, 0x35,
0x5e, 0x38, 0x1f, 0x1f, 0x75, 0xa5, 0x17, 0x2e, 0x7a, 0x61, 0x32, 0xcc, 0x66,
0xc2, 0xac, 0xc6, 0x0b, 0x66, 0x0e, 0xaf, 0xf6, 0x42, 0xad, 0x17, 0xe4, 0xf0,
0x9b, 0xb2, 0xb1, 0x96, 0xbb, 0x58, 0xf3, 0xc4, 0x8a, 0x9a, 0xd5, 0x0c, 0xb1,
0xf3, 0x82, 0xf4, 0x84, 0x2b, 0x49, 0x52, 0x87, 0xd4, 0x7d, 0x79, 0x08, 0x8d,
0x21, 0x8c, 0x06, 0x70, 0xed, 0xf9, 0xf9, 0x1c, 0xf6, 0xcb, 0xda, 0xaf, 0xfd,
0x0b, 0x52, 0xa4, 0xb2, 0x0d, 0xd4, 0xfd, 0x38, 0xfd, 0xbf, 0x18, 0x8c, 0x44,
0x97, 0x46, 0x36, 0x0f, 0x45, 0x1e, 0x4f, 0xfb, 0x30, 0xfb, 0x93, 0xe6, 0xf7,
0xfc, 0x07, 0x9c, 0x21, 0x52, 0xaf, 0xa4, 0xee, 0x4f, 0x03, 0x5a, 0xd2, 0xf8,
0x77, 0x6b, 0x6f, 0x25, 0x82, 0xf9, 0xb1, 0xf2, 0xa7, 0x7d, 0xc3, 0x44, 0x33,
0x41, 0xe6, 0x07, 0x59, 0xdf, 0x06, 0x67, 0x2f, 0x1b, 0xd0, 0xb3, 0x01, 0x97,
0x4f, 0xe9, 0x8e, 0x56, 0x18, 0x58, 0x62, 0x1a, 0x6b, 0xcf, 0x23, 0x1c, 0x54,
0x17, 0xc1, 0x89, 0x77, 0x5b, 0xbf, 0xe7, 0xce, 0x90, 0xca, 0x94, 0x25, 0x93,
0xa1, 0x4f, 0x37, 0x6e, 0x70, 0x0a, 0xb5, 0x4e, 0xce, 0xad, 0x13, 0x6a, 0xdb,
0x80, 0xc2, 0x75, 0xe6, 0xbb, 0x47, 0x68, 0x86, 0x91, 0x0c, 0xe8, 0x7f, 0x31,
0x12, 0x9b, 0xe7, 0x63, 0xe7, 0x7c, 0x9c, 0x0e, 0x89, 0x3d, 0x37, 0x67, 0x33,
0x51, 0x7e, 0x0f, 0x8b, 0x66, 0x97, 0xb3, 0x7b, 0x1a, 0x22, 0x00, 0x62, 0xef,
0x22, 0xf3, 0xfc, 0x20, 0x4b, 0xbe, 0xbb, 0x48, 0x73, 0x9b, 0xb0, 0xf6, 0xf8,
0xa2, 0xef, 0x17, 0xb2, 0x5a, 0x2f, 0xf9, 0x61, 0xc5, 0x0f, 0x34, 0xba, 0xc5,
0x36, 0xb6, 0xfe, 0xc1, 0xd1, 0x94, 0x05, 0xa0, 0x22, 0x00, 0xbf, 0x08, 0xc2,
0x57, 0x03, 0x40, 0x22, 0x5f, 0x2f, 0xda, 0xd4, 0x82, 0xd6, 0x16, 0x5c, 0x1e,
0x61, 0xa1, 0x11, 0xd6, 0x1c, 0xdb, 0x05, 0x9b, 0x6d, 0x22, 0xca, 0xbf, 0xae,
0xf9, 0x6f, 0x9e, 0xef, 0x8d, 0x7c, 0xec, 0xf8, 0x84, 0xaf, 0xcc, 0x9a, 0x16,
0xcc, 0xa8, 0x23, 0x39, 0x6f, 0xdd, 0x3b, 0x51, 0xcb, 0x4b, 0x94, 0x0f, 0x31,
0xe3, 0x10, 0xeb, 0xd8, 0x65, 0x59, 0x76, 0xd2, 0xd0, 0x82, 0x43, 0x41, 0x56,
0x54, 0x47, 0x26, 0xbe, 0x48, 0xaf, 0x67, 0xb4, 0xbe, 0x05, 0x27, 0x7e, 0x70,
0xfb, 0x7d, 0x4f, 0x19, 0x19, 0x4c, 0x23, 0xf7, 0x2e, 0xb3, 0xba, 0x16, 0x2c,
0xe3, 0x5a, 0xf8, 0x0e, 0x5b, 0x6b, 0xc3, 0x48, 0x1b, 0xea, 0xba, 0x58, 0x6d,
0x32, 0xa1, 0xe5, 0xa7, 0x8c, 0xa7, 0xb8, 0x70, 0xf1, 0x51, 0xf7, 0xcb, 0x53,
0x98, 0x7c, 0xa4, 0x33, 0x75, 0xcf, 0xe4, 0x86, 0x94, 0xe8, 0x56, 0x22, 0x6d,
0xf3, 0x60, 0xa7, 0x07, 0x7f, 0xd9, 0xf2, 0xd9, 0xaf, 0x42, 0x25, 0xe8, 0xb3,
0xb3, 0x9b, 0xff, 0xb5, 0xec, 0x70, 0xeb, 0xc1, 0xea, 0x2f, 0x1c, 0xef, 0x5d,
0xac, 0x63, 0x2d, 0xca, 0x04, 0xf5, 0xeb, 0xdd, 0x39, 0xa4, 0xff, 0xc7, 0xae,
0x1f, 0x53, 0x5d, 0x09, 0x29, 0x2a, 0x21, 0x77, 0x5f, 0x2d, 0x7c, 0xae, 0xe4,
0xe3, 0x6c, 0x23, 0xc9, 0x32, 0x72, 0xb1, 0x2e, 0x9a, 0x4d, 0x06, 0xec, 0xac,
0xca, 0xcb, 0x3c, 0x06, 0xf1, 0xd5, 0xf7, 0xbb, 0x4f, 0x2b, 0xeb, 0xc9, 0x78,
0x23, 0x8e, 0x36, 0x62, 0x9d, 0x8b, 0xd4, 0x7e, 0xe9, 0xe5, 0xd8, 0x9a, 0x73,
0x33, 0x55, 0x21, 0xd9, 0x3a, 0x75, 0xe7, 0x14, 0xf5, 0x70, 0x7d, 0x98, 0x67,
0x25, 0x26, 0x12, 0x65, 0x22, 0xe1, 0x09, 0xbf, 0x91, 0x9d, 0xfd, 0x3b, 0xae,
0xb2, 0xe2, 0x06, 0xd2, 0xb2, 0x1c, 0x52, 0x91, 0xc3, 0xc5, 0xa4, 0xd7, 0x8b,
0x5e, 0xef, 0x6d, 0x44, 0x7b, 0x23, 0xce, 0x59, 0x88, 0x31, 0x18, 0x43, 0xf6,
0x60, 0x04, 0x88, 0x5b, 0xda, 0x58, 0x33, 0x14, 0x01, 0x68, 0xda, 0x20, 0xe9,
0x0b, 0x8c, 0xc7, 0x38, 0x48, 0x0e, 0x85, 0x3f, 0x1a, 0x48, 0xc2, 0x15, 0x1e,
0x8b, 0x6f, 0xbc, 0xe0, 0xf2, 0x29, 0xbf, 0x78, 0xa5, 0xe8, 0x74, 0x04, 0xae,
0x47, 0x40, 0x57, 0xc2, 0x8a, 0x4a, 0x44, 0x83, 0x4d, 0x21, 0x66, 0x0d, 0x31,
0x09, 0x45, 0x93, 0x11, 0x98, 0x89, 0x80, 0x1c, 0x0a, 0xff, 0x4a, 0x04, 0xe6,
0xa5, 0x88, 0x3f, 0x02, 0x8b, 0x11, 0x98, 0x8b, 0x40, 0x20, 0x02, 0xcb, 0x11,
0x08, 0x45, 0x1e, 0xac, 0xc2, 0xf5, 0x08, 0xdc, 0x8a, 0xc0, 0xed, 0x08, 0xec,
0xc6, 0x61, 0x19, 0x51, 0xcc, 0x8a, 0x4a, 0xb6, 0x56, 0xf9, 0x65, 0x34, 0xd9,
0xb9, 0xb8, 0x0e, 0x1e, 0x11, 0x1d, 0x5b, 0x07, 0xef, 0xfa, 0x9e, 0x25, 0xbc,
0xbc, 0x0e, 0x21, 0x91, 0x5e, 0x5b, 0x87, 0xc8, 0x5e, 0x78, 0x4d, 0x00, 0xcd,
0x5c, 0xf7, 0x5c, 0x8f, 0xe0, 0xad, 0x48, 0xfc, 0xce, 0x2d, 0xb7, 0x61, 0x9e,
0x99, 0x28, 0xa4, 0xa1, 0x2e, 0x8c, 0xb2, 0xf2, 0x43, 0x9d, 0x61, 0x92, 0xec,
0x20, 0x49, 0x0e, 0x72, 0x75, 0x03, 0x86, 0x36, 0x00, 0xc9, 0x15, 0xb1, 0x8b,
0x91, 0xc7, 0xdc, 0x1b, 0xb0, 0xa9, 0x65, 0xdb, 0x5a, 0x36, 0xbc, 0x01, 0x3c,
0x8f, 0x72, 0x89, 0xda, 0x70, 0x99, 0xfd, 0xfa, 0xae, 0xb3, 0x5f, 0xb3, 0x0e,
0x62, 0xaa, 0xf9, 0x82, 0x12, 0x83, 0x4a, 0x2c, 0x1e, 0x63, 0xad, 0x6e, 0xc2,
0x23, 0x74, 0x49, 0x29, 0xba, 0x0e, 0xf0, 0x70, 0x4e, 0x89, 0xfc, 0xd2, 0x52,
0x90, 0xe0, 0x55, 0x8b, 0xf4, 0x9c, 0xc8, 0xf0, 0x29, 0xf1, 0x1a, 0xbf, 0x5e,
0x97, 0x0a, 0x09, 0x48, 0xa5, 0x9e, 0xa4, 0x97, 0xb2, 0x59, 0xa5, 0x3c, 0xde,
0xa5, 0x09, 0xb2, 0x32, 0x21, 0x49, 0xca, 0x57, 0x94, 0x38, 0xa8, 0x44, 0x39,
0xa4, 0x2e, 0x25, 0xf6, 0x2b, 0xe3, 0x33, 0xd2, 0xcc, 0x91, 0xf1, 0x05, 0xd6,
0x26, 0xa5, 0xad, 0x32, 0xb4, 0xad, 0x9d, 0xdd, 0x93, 0xbe, 0xcc, 0xd6, 0xca,
0xd3, 0x2d, 0xfc, 0x5f, 0x3e, 0x68, 0x39, 0x94, 0x88, 0x74, 0x95, 0xff, 0xd3,
0xf8, 0x09, 0xcd, 0x01, 0x9e, 0xf0, 0xf3, 0xff, 0xb2, 0x09, 0x52, 0xc1, 0x19,
0x09, 0x8f, 0xcd, 0x25, 0xe2, 0x05, 0x25, 0xfe, 0x7f, 0x7f, 0x2f, 0xff, 0x59,
0x1d, 0x8c, 0x4e, 0xb3, 0xdd, 0x5a, 0x92, 0xeb, 0x26, 0x6a, 0x37, 0x59, 0x6b,
0x20, 0xbd, 0xb3, 0xac, 0xcf, 0xcb, 0x4e, 0x1f, 0x75, 0x18, 0xd9, 0x84, 0xec,
0x57, 0x8e, 0x9e, 0xe4, 0x71, 0x7f, 0x25, 0x5b, 0xac, 0x64, 0xc3, 0x26, 0x24,
0x85, 0x3f, 0xe6, 0xc2, 0x9f, 0xce, 0xca, 0x5c, 0x19, 0x44, 0x18, 0xb2, 0x07,
0x78, 0xa1, 0xb5, 0x8c, 0x04, 0xc3, 0x2c, 0xa9, 0x9a, 0x20, 0xb7, 0x92, 0x13,
0xfa, 0x79, 0xba, 0xba, 0x8f, 0xd4, 0xf6, 0x91, 0xca, 0x25, 0x72, 0x71, 0x49,
0xfa, 0xb0, 0x75, 0x09, 0x29, 0x29, 0x21, 0xb4, 0xdd, 0x84, 0x2d, 0x26, 0x2c,
0xaf, 0x26, 0xf3, 0x13, 0x8c, 0x47, 0xda, 0x45, 0xeb, 0x1d, 0x26, 0xb4, 0x99,
0x90, 0x87, 0x8b, 0x87, 0xa7, 0x72, 0xc4, 0x95, 0xc6, 0x8a, 0x49, 0xb9, 0xb4,
0xcb, 0x84, 0xe1, 0x09, 0xd2, 0xa0, 0x4c, 0xe8, 0x8a, 0xbb, 0xb8, 0xb1, 0x81,
0xc7, 0xb8, 0x66, 0x10, 0xf8, 0xdc, 0x6a, 0xc2, 0x46, 0x13, 0x5e, 0xda, 0xe3,
0xfb, 0x4e, 0x29, 0xc0, 0x44, 0x97, 0x20, 0x93, 0xd8, 0x9c, 0x83, 0xad, 0xd2,
0x5b, 0x24, 0x1d, 0x3c, 0xec, 0xe4, 0xff, 0xf1, 0x3d, 0x8f, 0x82, 0xde, 0xe7,
0xe0, 0x92, 0x87, 0x34, 0x2c, 0x3c, 0xe0, 0x69, 0x63, 0x39, 0xe8, 0xcd, 0x41,
0x39, 0x94, 0xe9, 0x58, 0x80, 0x79, 0x84, 0x66, 0xb1, 0x07, 0x6f, 0x75, 0xc5,
0xd8, 0x20, 0xfc, 0x1d, 0xcd, 0xc5, 0xd8, 0xca, 0xaf, 0x7d, 0x4b, 0x6c, 0x60,
0x89, 0x4d, 0xe6, 0x21, 0x9d, 0xca, 0x93, 0xea, 0x14, 0x28, 0x13, 0xf4, 0xca,
0x04, 0x41, 0xb3, 0x32, 0x58, 0x50, 0x58, 0xfc, 0x86, 0xfb, 0x58, 0xde, 0x91,
0xed, 0x4e, 0x72, 0xc3, 0x8c, 0x89, 0x69, 0x09, 0xca, 0xb4, 0x04, 0x3a, 0xeb,
0x61, 0xf3, 0x1e, 0x26, 0x3e, 0x74, 0xcc, 0x56, 0xb8, 0x40, 0xb2, 0x2a, 0x2a,
0xae, 0xe4, 0xe1, 0x42, 0x1e, 0x12, 0xf9, 0x12, 0xe4, 0x10, 0x7f, 0x1e, 0x2e,
0xe6, 0xe1, 0x52, 0x1e, 0x72, 0x10, 0x2f, 0x91, 0x10, 0x94, 0x9a, 0xe7, 0xb1,
0x1b, 0x79, 0x0f, 0xe6, 0xa9, 0x69, 0xc7, 0xf3, 0xed, 0xc8, 0x43, 0xaa, 0x6d,
0xc7, 0x4d, 0x2d, 0x6e, 0xc7, 0xb7, 0xc9, 0x4a, 0x97, 0xcc, 0x02, 0xcc, 0x29,
0x40, 0x1e, 0xd6, 0x29, 0xa8, 0xad, 0x20, 0x21, 0x3b, 0x97, 0x9d, 0xcd, 0x65,
0x34, 0x35, 0x33, 0x21, 0x3d, 0x93, 0x8f, 0xaf, 0x38, 0x97, 0x5d, 0xc8, 0x65,
0x4d, 0x89, 0xcc, 0x9a, 0x28, 0xcf, 0xbf, 0xc3, 0xc9, 0x6c, 0x4e, 0xd6, 0xac,
0xc6, 0xd6, 0x87, 0x66, 0xd2, 0x3e, 0x35, 0x0e, 0xf0, 0x54, 0xbf, 0x1a, 0x5d,
0xea, 0xb8, 0x3c, 0x9f, 0xab, 0x41, 0xb5, 0x06, 0xf3, 0x35, 0xa8, 0xd5, 0xe0,
0xdd, 0xba, 0x04, 0x85, 0x39, 0x81, 0xc7, 0xe9, 0x39, 0x8d, 0xbc, 0xe5, 0x54,
0x83, 0x45, 0x9a, 0x3d, 0xab, 0x70, 0x62, 0x9a, 0x9d, 0xd5, 0x10, 0xa7, 0x03,
0xbf, 0xc9, 0xfa, 0x1d, 0x36, 0x26, 0x98, 0x32, 0x68, 0x45, 0x21, 0x17, 0x5f,
0x0a, 0x51, 0xfe, 0x92, 0x90, 0xcc, 0x25, 0xac, 0xc4, 0x6c, 0x25, 0xe7, 0x0b,
0xf7, 0x36, 0x56, 0x1f, 0x61, 0x65, 0xff, 0x56, 0x31, 0x42, 0xbc, 0x42, 0xaf,
0x9b, 0xc8, 0x49, 0x58, 0x39, 0x15, 0x89, 0x09, 0xc3, 0xbd, 0xfb, 0xbf, 0xf5,
0x2f, 0xf7, 0xb3, 0xef, 0x77, 0xfc, 0x03, 0xcd, 0x5d, 0xde, 0xdf, 0xfd, 0x2f,
0xd9, 0x99, 0xf4, 0xeb, 0xda, 0x6f, 0x7b, 0xd0, 0x66, 0xc7, 0x7e, 0x09, 0xf5,
0xdb, 0x09, 0x9b, 0x09, 0xb7, 0x12, 0xd6, 0x13, 0xe8, 0xcd, 0x84, 0x6f, 0x7d,
0x2b, 0x9c, 0x10, 0x49, 0x90, 0x32, 0xd7, 0xf8, 0xcd, 0x5c, 0x49, 0x58, 0x4a,
0xa0, 0x8b, 0x09, 0xdf, 0xf2, 0x27, 0x88, 0xef, 0x5f, 0xd1, 0x9e, 0xfd, 0xe7,
0x03, 0x34, 0x3f, 0x40, 0xe9, 0xbf, 0xa7, 0xbf, 0x43, 0xff, 0x0d, 0xfd, 0x6d,
0xfa, 0x9b, 0x94, 0x51, 0xb1, 0x26, 0x8d, 0x01, 0xca, 0x6b, 0xd4, 0x4c, 0x3d,
0xc4, 0x9f, 0x7e, 0x8a, 0x16, 0x48, 0x49, 0xf5, 0x14, 0xcd, 0x9d, 0xfa, 0xfa,
0x8d, 0xb8, 0x35, 0x49, 0xd7, 0x27, 0xe5, 0xd7, 0x91, 0x79, 0x7a, 0x2b, 0x61,
0x37, 0x81, 0xfe, 0x92, 0x7e, 0x65, 0xfb, 0x8d, 0x3b, 0x09, 0xdf, 0xfa, 0x7f,
0xfc, 0xab, 0xbe, 0x93, 0x40, 0xbd, 0xc5, 0x58, 0xa7, 0xc1, 0x06, 0x0d, 0x2e,
0x68, 0xf1, 0xff, 0x02,
};
optimizesize void *__gbcommon_encmap(void) {
return xloadzd(&__gbcommon_encmap_ptr,
__gbcommon_encmap_rodata,
26264, 41357, 23231, 2, 0xa0748ffcu); /* 56.5279% profit */
}
| 161,993 | 2,034 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__gb18030ext_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __gb18030ext_decmap_ptr;
static const unsigned char __gb18030ext_decmap_rodata[405] = {
0xeb, 0x99, 0xcc, 0xce, 0x44, 0x11, 0xf8, 0x92, 0xfd, 0x31, 0x9b, 0x89, 0xb6,
0x60, 0x4b, 0xd6, 0xc6, 0x2c, 0x42, 0x6a, 0x3e, 0x65, 0x32, 0xc0, 0xc0, 0xfa,
0x24, 0xb0, 0xc8, 0xb2, 0x24, 0x06, 0x52, 0xc1, 0xe2, 0xbf, 0x6c, 0x4d, 0xb3,
0xd9, 0x16, 0x21, 0x34, 0xce, 0x4f, 0x62, 0x9a, 0x87, 0x6c, 0xcc, 0xec, 0x24,
0xa6, 0xab, 0x94, 0x86, 0x57, 0xc6, 0xc7, 0x0c, 0x5a, 0x87, 0x57, 0xfa, 0xc6,
0x74, 0x82, 0xe1, 0x95, 0xc6, 0x40, 0x75, 0x30, 0x3d, 0x09, 0x61, 0xfe, 0x6b,
0x16, 0x0a, 0x83, 0x29, 0xf5, 0x63, 0x2a, 0x21, 0x35, 0x9b, 0x52, 0x19, 0x68,
0x01, 0x1a, 0x61, 0xde, 0xd8, 0xcd, 0x4c, 0x61, 0x3c, 0xa4, 0x6c, 0x4c, 0x21,
0x18, 0x0f, 0xc9, 0x38, 0x5c, 0xf1, 0x31, 0x11, 0xaa, 0xe2, 0x49, 0x22, 0x0e,
0x15, 0x0f, 0xa1, 0x2a, 0xae, 0x21, 0x2b, 0xb8, 0x9c, 0xc8, 0x74, 0x09, 0xcc,
0x3f, 0x9f, 0x78, 0x21, 0x91, 0xe1, 0x2c, 0xcc, 0x10, 0xa6, 0x8d, 0x14, 0xa6,
0xa9, 0x2f, 0x49, 0x1f, 0x93, 0x08, 0xc6, 0x07, 0xc1, 0x1c, 0xb7, 0x3b, 0x11,
0x55, 0xc7, 0x82, 0x44, 0x42, 0x3a, 0xe6, 0x26, 0xe2, 0xb0, 0xec, 0x43, 0x02,
0x6e, 0x4d, 0x6f, 0x13, 0xde, 0x25, 0x30, 0x74, 0xfe, 0x60, 0xef, 0xfa, 0xc1,
0xfe, 0x32, 0x01, 0x14, 0x84, 0x09, 0xc4, 0xc4, 0xfb, 0xc3, 0x04, 0xac, 0x16,
0xed, 0x48, 0x60, 0xd8, 0x9a, 0xb0, 0x2d, 0x61, 0x33, 0x50, 0x76, 0x43, 0x02,
0xb1, 0x69, 0xe8, 0xff, 0x3e, 0xb6, 0xd9, 0x8c, 0x48, 0x86, 0xb4, 0x1d, 0x60,
0x9b, 0x8c, 0x62, 0xfc, 0x9f, 0x78, 0x2a, 0xa6, 0xd8, 0x9f, 0xf1, 0xa8, 0x4e,
0x9e, 0xab, 0xc0, 0x34, 0x0a, 0x46, 0x01, 0x69, 0x60, 0x97, 0x38, 0x88, 0xdc,
0x2f, 0x3e, 0x1a, 0x12, 0xa3, 0x80, 0x44, 0x70, 0xfa, 0x3a, 0xeb, 0xaa, 0x67,
0xac, 0x4c, 0x4c, 0xcb, 0x9f, 0xb1, 0xde, 0x13, 0x0f, 0xff, 0x2b, 0xc6, 0xb6,
0xec, 0x19, 0xeb, 0xff, 0x93, 0xac, 0x3f, 0x18, 0xc5, 0x9b, 0xe5, 0xc4, 0xd6,
0x69, 0xaf, 0x66, 0x9c, 0xb3, 0x87, 0x75, 0xed, 0x4e, 0x56, 0x85, 0x15, 0x4c,
0x47, 0x99, 0xb6, 0xed, 0x64, 0x65, 0xda, 0xbd, 0x99, 0xf5, 0x00, 0xcb, 0x13,
0xc6, 0x8f, 0x16, 0x53, 0x80, 0xba, 0xfa, 0x9f, 0xb1, 0xde, 0x70, 0x9b, 0xc4,
0xf2, 0xd0, 0x6b, 0x52, 0x50, 0x7b, 0x10, 0x1b, 0x53, 0xc7, 0x33, 0xd6, 0xc9,
0x93, 0x58, 0x39, 0x1f, 0x06, 0x1f, 0x09, 0xf9, 0xc4, 0x3c, 0x8d, 0x4d, 0xf3,
0x5d, 0x3b, 0xeb, 0xb7, 0xb8, 0xad, 0x8f, 0x59, 0x79, 0x96, 0x31, 0x2a, 0xb5,
0x26, 0xff, 0xca, 0x4c, 0x63, 0xe3, 0x62, 0x62, 0x61, 0x32, 0x62, 0xb7, 0x60,
0xdc, 0xf3, 0x8b, 0x85, 0xe9, 0xf1, 0x3b, 0x16, 0x60, 0x7b, 0x2c, 0x38, 0xec,
0x11, 0xb4, 0xb0, 0x5d, 0xc5, 0xf4, 0xe6, 0x15, 0xcb, 0x77, 0x7e, 0x9a, 0xfa,
0x16, 0x00,
};
optimizesize void *__gb18030ext_decmap(void) {
return xloadzd(&__gb18030ext_decmap_ptr,
__gb18030ext_decmap_rodata,
405, 2867, 2729, 2, 0x8e6ddc4au); /* 7.4203% profit */
}
| 2,864 | 45 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__jisx0212_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __jisx0212_decmap_ptr;
static const unsigned char __jisx0212_decmap_rodata[3327] = {
0x8d, 0x58, 0x5d, 0xa8, 0x6d, 0x55, 0x15, 0x6e, 0x8d, 0x3d, 0x9d, 0x6b, 0x38,
0xcf, 0x74, 0xde, 0xe9, 0x74, 0xb9, 0xdc, 0x6d, 0xb7, 0xdb, 0xe3, 0xe1, 0x74,
0xb1, 0x8b, 0xc8, 0xe5, 0xa2, 0x25, 0x26, 0x94, 0x11, 0x22, 0x08, 0xf5, 0x26,
0xf4, 0xd2, 0x43, 0x2f, 0x45, 0x81, 0x26, 0x81, 0x18, 0x51, 0x74, 0x23, 0x8c,
0x40, 0x32, 0x4a, 0xfa, 0x83, 0xe8, 0x0f, 0xa3, 0x02, 0xb9, 0x66, 0x62, 0x19,
0x5a, 0xf6, 0x47, 0x2f, 0x12, 0xf8, 0x92, 0x52, 0x66, 0x0f, 0x5e, 0x30, 0x82,
0xb2, 0x13, 0x3d, 0xd4, 0x3d, 0x2a, 0x7d, 0xdf, 0x37, 0xf7, 0x91, 0x28, 0x88,
0xce, 0xb9, 0xf7, 0xb0, 0xf7, 0x5a, 0x73, 0xce, 0xf1, 0xf7, 0x8d, 0x6f, 0x8c,
0x31, 0x1f, 0xdc, 0xb9, 0xe2, 0x2b, 0xfe, 0x33, 0xf7, 0xdf, 0xf9, 0x33, 0x3e,
0xfc, 0xe0, 0xfc, 0x7b, 0xb2, 0xfd, 0xed, 0x60, 0x7c, 0x4d, 0xff, 0x79, 0xf4,
0xe5, 0x31, 0x9d, 0x7a, 0xe5, 0xa5, 0xa3, 0xaf, 0xff, 0xfb, 0xe7, 0x93, 0x2f,
0x8f, 0x97, 0x0f, 0xe9, 0x8f, 0xa7, 0x87, 0xc3, 0xd3, 0xc3, 0xd9, 0xd3, 0xc3,
0x57, 0xef, 0x0c, 0x66, 0x6f, 0xf9, 0xf6, 0xc1, 0xf8, 0xfc, 0xc1, 0x78, 0xf6,
0x60, 0xfc, 0xc3, 0xc1, 0x78, 0xfd, 0xb7, 0x0e, 0xc6, 0xdf, 0x1f, 0x8c, 0xcf,
0xe9, 0xf8, 0x6f, 0x1e, 0x8c, 0x66, 0xf6, 0x86, 0x0f, 0xde, 0x75, 0xd1, 0xbc,
0xb8, 0xf6, 0x86, 0xf7, 0xda, 0xab, 0x3f, 0xc1, 0x9e, 0x7b, 0xf1, 0xff, 0x10,
0xf8, 0xf4, 0x5f, 0xc6, 0x7f, 0xdf, 0xf3, 0xbd, 0x72, 0xdf, 0xf0, 0xec, 0xe1,
0x78, 0xe6, 0x70, 0x7c, 0xf0, 0x70, 0xfc, 0xc2, 0xe1, 0xf8, 0xc5, 0xc3, 0xf1,
0x9f, 0xe7, 0xc6, 0xc5, 0x2b, 0xe7, 0xc6, 0x17, 0xce, 0x8d, 0xcf, 0x0f, 0x7f,
0x1f, 0x9e, 0x39, 0x37, 0x9e, 0x39, 0x37, 0xde, 0x6b, 0x4f, 0xfc, 0x97, 0x35,
0x67, 0x5e, 0x1a, 0x6f, 0xbd, 0xf1, 0xb6, 0x29, 0xa4, 0x69, 0xd1, 0xc2, 0xfd,
0xc3, 0x23, 0xc3, 0x0b, 0xc3, 0x67, 0xec, 0xa9, 0xe1, 0x43, 0x83, 0x2f, 0x3e,
0x36, 0x7c, 0x7e, 0xf1, 0xa5, 0x85, 0x7f, 0x64, 0x71, 0xf7, 0x10, 0xfc, 0x53,
0xc3, 0xdd, 0x03, 0xfe, 0x0c, 0x71, 0xf8, 0xda, 0x30, 0x8e, 0xf9, 0xc9, 0xc3,
0xf1, 0xe7, 0x87, 0x63, 0xf0, 0x85, 0x3f, 0xc0, 0x67, 0x1f, 0x0f, 0x8f, 0xdb,
0x8e, 0xef, 0x2c, 0x43, 0xf4, 0x45, 0xf5, 0xc5, 0x0b, 0x43, 0xc0, 0xfe, 0x73,
0x8b, 0xd3, 0x36, 0xfe, 0x79, 0x78, 0x05, 0x1f, 0x1d, 0x2b, 0xf3, 0xe2, 0x5e,
0xc3, 0xd2, 0x6f, 0xd8, 0xaf, 0x87, 0x5f, 0x0e, 0x3b, 0x75, 0xdc, 0x79, 0x0e,
0x2f, 0xc6, 0x9f, 0x0e, 0x0f, 0xd8, 0x23, 0xb6, 0xc0, 0xbe, 0xef, 0x1b, 0xbe,
0xbf, 0x55, 0x22, 0xdf, 0xbc, 0xb8, 0x39, 0xf8, 0x2d, 0x37, 0xfb, 0x2d, 0x58,
0xff, 0x6e, 0x48, 0xfb, 0xe1, 0xe2, 0xcc, 0x22, 0xfc, 0xf8, 0x70, 0x7c, 0xf4,
0x70, 0xf4, 0xdb, 0xf1, 0xec, 0x17, 0x8b, 0x67, 0xff, 0x31, 0xde, 0x8f, 0x2f,
0xaf, 0x4a, 0xfc, 0x8e, 0x24, 0x3e, 0x46, 0x89, 0x67, 0x86, 0x27, 0x5e, 0x95,
0xf8, 0x14, 0x95, 0x3b, 0x3b, 0xfc, 0x87, 0xc4, 0x17, 0x87, 0xf0, 0xd7, 0x01,
0xfb, 0xee, 0x79, 0x08, 0xbe, 0x2b, 0x79, 0xe5, 0xe6, 0x31, 0x9a, 0xa5, 0xd9,
0x62, 0x9c, 0x5a, 0x28, 0xc9, 0x66, 0xf3, 0xbc, 0x6e, 0x96, 0xf7, 0xa7, 0x69,
0x35, 0x59, 0x32, 0xcb, 0x25, 0x84, 0x50, 0xe5, 0xec, 0x14, 0x2d, 0x63, 0x75,
0x38, 0x11, 0xdf, 0xf5, 0x4e, 0x3c, 0x0c, 0x31, 0x84, 0x8c, 0xc7, 0x19, 0x1f,
0x8b, 0x63, 0x59, 0xcc, 0x58, 0x16, 0xf1, 0x1b, 0xcc, 0x8d, 0x0b, 0xf0, 0x8d,
0x1f, 0x8f, 0x27, 0x7e, 0xec, 0x4f, 0xf1, 0x6b, 0x21, 0x4e, 0x1e, 0xd6, 0x61,
0xe2, 0xe7, 0x18, 0x23, 0x4f, 0x72, 0xec, 0x32, 0xf3, 0x84, 0x53, 0x2c, 0xcc,
0x3c, 0xc5, 0xf1, 0x14, 0x4f, 0x24, 0x21, 0x72, 0x99, 0xbd, 0xff, 0x9e, 0x01,
0x2f, 0xdd, 0x4d, 0x67, 0x24, 0xfe, 0x35, 0xab, 0xc9, 0x9a, 0xde, 0xc6, 0xc4,
0x0d, 0x78, 0x4b, 0xb5, 0xa8, 0x54, 0x72, 0x87, 0xc2, 0x3a, 0xf7, 0x8d, 0x37,
0x14, 0x69, 0x90, 0xbc, 0x2b, 0xc6, 0xa7, 0xad, 0x26, 0x88, 0xb0, 0x92, 0xc2,
0xc9, 0x64, 0x25, 0x4e, 0xf8, 0x36, 0xcd, 0x7c, 0x17, 0x61, 0x31, 0x75, 0xcc,
0x1e, 0x1b, 0x64, 0xc5, 0xc9, 0xe2, 0x8a, 0x7a, 0x4f, 0x19, 0x82, 0x4a, 0xf3,
0x25, 0x3e, 0x53, 0xb5, 0x54, 0x9b, 0x59, 0x09, 0x90, 0x5b, 0x64, 0x9d, 0x9c,
0x54, 0x2d, 0x53, 0x3d, 0x18, 0x14, 0x82, 0x47, 0xa8, 0x92, 0x20, 0x94, 0x3e,
0x73, 0xba, 0xa2, 0xc5, 0x82, 0x7d, 0x21, 0x45, 0x79, 0x4d, 0x76, 0x60, 0x0d,
0x9e, 0xf9, 0x34, 0xac, 0x03, 0xfc, 0x58, 0x2c, 0x95, 0x04, 0x2d, 0x33, 0xb7,
0x39, 0xfc, 0x89, 0x33, 0x74, 0x5c, 0x4c, 0x13, 0x36, 0x71, 0x63, 0xb6, 0xf5,
0x6a, 0xaf, 0x14, 0xb8, 0x25, 0x41, 0x8b, 0x35, 0xd4, 0x0d, 0x1b, 0x1a, 0x22,
0xa3, 0x69, 0x00, 0x9d, 0x80, 0x13, 0xa2, 0x3c, 0x14, 0xf9, 0x1e, 0xe7, 0x17,
0x28, 0xb1, 0x3f, 0x41, 0x16, 0xbf, 0xe1, 0x54, 0xba, 0xa5, 0x9c, 0x80, 0xdd,
0x0c, 0xb1, 0xe3, 0x21, 0x3c, 0x08, 0x33, 0x22, 0xff, 0x9d, 0x0a, 0x5b, 0xb7,
0x43, 0xbb, 0xa5, 0xb5, 0xb4, 0xc2, 0x99, 0x54, 0x83, 0xe1, 0xc0, 0x3a, 0x2f,
0xab, 0x86, 0xd3, 0xa3, 0x32, 0xb0, 0x1c, 0xf7, 0xd8, 0x23, 0x1d, 0xba, 0xdd,
0xf8, 0x9c, 0x26, 0x6d, 0xa5, 0x0b, 0x2c, 0x6e, 0x78, 0x72, 0x53, 0x78, 0x8b,
0x30, 0x80, 0xb3, 0xbd, 0x14, 0xe7, 0x59, 0xa3, 0x2d, 0x63, 0xf7, 0xa5, 0x59,
0xdb, 0x09, 0xcd, 0x00, 0x38, 0xa8, 0xed, 0x89, 0xe7, 0x50, 0x4d, 0xbc, 0xc4,
0x1f, 0xb8, 0x39, 0xe3, 0x37, 0xed, 0x4a, 0xbb, 0x9e, 0xf7, 0xd6, 0x11, 0x15,
0x43, 0xab, 0xf2, 0x10, 0x3e, 0x5f, 0xb2, 0x4f, 0x7d, 0xd3, 0x04, 0xeb, 0x72,
0xa5, 0x7b, 0x11, 0x80, 0x44, 0x9c, 0x18, 0xa3, 0xfe, 0x8e, 0x5b, 0x6d, 0x1d,
0x75, 0x50, 0x2a, 0x99, 0xbe, 0x34, 0xa8, 0x09, 0xd5, 0x76, 0x5d, 0x4f, 0xa5,
0x3c, 0x54, 0x2b, 0x34, 0x32, 0x56, 0xdb, 0x3f, 0x96, 0x11, 0x03, 0x5a, 0xe6,
0xc0, 0x66, 0x99, 0xf6, 0xe1, 0x27, 0xac, 0xfa, 0xed, 0xc3, 0xc3, 0xaf, 0x1e,
0x1e, 0x1c, 0x2b, 0x8b, 0xe2, 0xe9, 0x70, 0x50, 0x96, 0xf5, 0xa1, 0xd2, 0x4b,
0x7c, 0xb8, 0xa1, 0xe0, 0x50, 0x53, 0xcf, 0x06, 0x7c, 0x4c, 0x3c, 0x38, 0x22,
0xc7, 0xe8, 0xbe, 0x22, 0x2f, 0x35, 0xaf, 0xfc, 0x36, 0x27, 0x26, 0x4b, 0x8c,
0x57, 0x52, 0xb6, 0xa7, 0x06, 0x08, 0x53, 0xb7, 0xb8, 0x4a, 0x91, 0x79, 0x41,
0x94, 0xa7, 0x24, 0x33, 0x91, 0x1a, 0x40, 0xc7, 0x1c, 0x1c, 0xe8, 0x28, 0x0c,
0x5b, 0xd9, 0x5c, 0x7f, 0x2d, 0x94, 0xf3, 0x3a, 0xb7, 0xc9, 0xb2, 0xd7, 0x29,
0xdb, 0xaa, 0x7b, 0xc4, 0x5d, 0x90, 0xd9, 0xe7, 0xd1, 0xcc, 0x59, 0x40, 0x6f,
0x19, 0xe8, 0x7b, 0xcb, 0x1b, 0x48, 0xde, 0xcc, 0x85, 0x49, 0x2f, 0xc0, 0x44,
0xbb, 0x89, 0x80, 0x62, 0x30, 0x60, 0x25, 0x24, 0x21, 0x02, 0x00, 0xd9, 0xcc,
0x03, 0xa2, 0x57, 0xec, 0xde, 0x40, 0xe8, 0xce, 0xd5, 0x38, 0x69, 0x05, 0x60,
0x9e, 0x3a, 0x86, 0xe7, 0x53, 0x44, 0xa6, 0xd0, 0xd0, 0xd5, 0x58, 0x2f, 0x3b,
0x41, 0x91, 0x39, 0xc6, 0xa6, 0x58, 0x25, 0xa5, 0x00, 0xe2, 0x6b, 0xc5, 0x01,
0x5f, 0x9b, 0x60, 0xd3, 0x62, 0xe2, 0x97, 0x8d, 0x01, 0xb1, 0xf0, 0x03, 0xcc,
0x5f, 0xef, 0x4c, 0xb1, 0xad, 0xd2, 0x05, 0x95, 0xf0, 0x0d, 0x53, 0x8f, 0xe7,
0xee, 0x1c, 0xaf, 0x64, 0x70, 0x71, 0xc4, 0x04, 0xa0, 0xe4, 0x21, 0x32, 0x42,
0x25, 0x94, 0x7c, 0x35, 0x94, 0xcb, 0x73, 0xa4, 0x8e, 0x84, 0x2d, 0x4c, 0x0e,
0x49, 0xa8, 0x80, 0x58, 0x64, 0x08, 0x32, 0x22, 0x56, 0xe1, 0x22, 0xda, 0x8c,
0xf0, 0x01, 0x26, 0xc9, 0x2f, 0xa8, 0x44, 0xdb, 0x32, 0x8a, 0x25, 0x68, 0x54,
0xec, 0x59, 0x29, 0x72, 0xf2, 0x30, 0x47, 0x84, 0x86, 0xd9, 0x94, 0x5a, 0x0e,
0xf0, 0x06, 0xa8, 0x03, 0x27, 0x64, 0xcf, 0xd3, 0xca, 0xb6, 0x79, 0x8b, 0x70,
0xc1, 0x0e, 0x1c, 0x8d, 0xc7, 0x91, 0x06, 0x71, 0x2b, 0x1f, 0x41, 0x72, 0x5c,
0x45, 0x3a, 0x4b, 0x8e, 0xb5, 0x2d, 0xe8, 0x11, 0xce, 0x44, 0x15, 0x43, 0x45,
0x88, 0x4f, 0x84, 0x65, 0xce, 0xca, 0x30, 0x9a, 0x90, 0x04, 0x3f, 0x05, 0x22,
0x82, 0x66, 0xb1, 0x08, 0x90, 0xe9, 0xa9, 0x90, 0xc2, 0x08, 0x38, 0xec, 0x43,
0x0e, 0x02, 0x44, 0x50, 0x85, 0xb0, 0x76, 0xc6, 0x3b, 0xf3, 0x28, 0x58, 0x5a,
0x1b, 0x72, 0x25, 0xee, 0x62, 0xf1, 0x55, 0xd0, 0x9a, 0x9b, 0xd3, 0x84, 0xe8,
0xed, 0xd6, 0x50, 0x95, 0x12, 0x81, 0x28, 0xd9, 0xa3, 0x9a, 0x20, 0x08, 0xeb,
0x2c, 0xa3, 0x60, 0x02, 0x12, 0x4a, 0x72, 0xb1, 0x21, 0xcc, 0xa5, 0x0a, 0xc8,
0x72, 0x88, 0x5d, 0x93, 0x56, 0x08, 0x2d, 0x44, 0x25, 0x31, 0xcb, 0x91, 0x02,
0x84, 0xb0, 0x93, 0xc5, 0x8d, 0x20, 0x48, 0x35, 0x2c, 0x9d, 0xce, 0xca, 0xdb,
0x4c, 0x03, 0xb4, 0x4a, 0xa0, 0x48, 0x64, 0x70, 0xe8, 0xbc, 0xef, 0x05, 0x61,
0x4a, 0x12, 0x49, 0xb5, 0x57, 0x22, 0x86, 0x44, 0xe8, 0x51, 0x7e, 0xea, 0x62,
0x09, 0xfe, 0x14, 0x1b, 0x5d, 0x0b, 0x8a, 0x04, 0xab, 0x17, 0xdf, 0x20, 0x66,
0xa9, 0x62, 0x29, 0x14, 0x87, 0xab, 0x6c, 0x46, 0x24, 0xb0, 0x0d, 0xd0, 0xde,
0xe3, 0x41, 0xcc, 0x55, 0xe7, 0x3f, 0xe0, 0x5b, 0xc4, 0x2d, 0x6e, 0x20, 0xb9,
0xe5, 0x45, 0xa3, 0xfb, 0xd3, 0x79, 0xad, 0xd7, 0x91, 0x87, 0xed, 0xeb, 0x78,
0xb3, 0x7f, 0x71, 0x98, 0x8e, 0x31, 0xca, 0xe3, 0x86, 0x4c, 0x5a, 0x14, 0x26,
0x27, 0xdb, 0x64, 0xb9, 0x1c, 0x66, 0xa4, 0xe2, 0x0d, 0xb1, 0x5e, 0xce, 0x28,
0x6e, 0x40, 0x4c, 0xd8, 0x9b, 0x41, 0x73, 0x08, 0x57, 0x45, 0xec, 0x51, 0x23,
0x32, 0x5c, 0x45, 0x83, 0x50, 0xd4, 0xb0, 0x17, 0x16, 0xdf, 0x75, 0x87, 0x98,
0x0e, 0xa9, 0x18, 0x13, 0x18, 0xc2, 0xed, 0x91, 0xe1, 0xc3, 0x38, 0xa7, 0x0d,
0xaa, 0x37, 0x88, 0x2f, 0x1c, 0x14, 0x60, 0x53, 0xdc, 0x15, 0x6d, 0xd1, 0x5c,
0x15, 0xc0, 0x35, 0x89, 0x0f, 0x6e, 0x84, 0xf6, 0x6d, 0x8a, 0xa2, 0x7c, 0x56,
0xa5, 0x1a, 0x3b, 0xec, 0x94, 0x5d, 0x2d, 0x2a, 0x66, 0x76, 0x0d, 0xa9, 0xa2,
0x44, 0x24, 0xbc, 0xf7, 0xc2, 0xca, 0x53, 0x2a, 0xd6, 0xac, 0x28, 0xa9, 0x57,
0xb0, 0x0a, 0xb5, 0x5a, 0x84, 0xd1, 0x33, 0x92, 0x0b, 0x67, 0x43, 0x64, 0x58,
0x22, 0xfd, 0x81, 0x3d, 0x27, 0xd5, 0x38, 0xcf, 0x62, 0x95, 0x14, 0x32, 0x1b,
0xce, 0x03, 0x42, 0x98, 0x51, 0x60, 0x10, 0x3c, 0xcb, 0x84, 0x50, 0x64, 0x81,
0x8a, 0x03, 0xcb, 0x01, 0x16, 0x17, 0x24, 0x2e, 0x13, 0x5c, 0x9c, 0x03, 0x4b,
0x81, 0xec, 0x4c, 0x8c, 0x20, 0x02, 0x2c, 0x0f, 0x10, 0x9d, 0x62, 0x21, 0x5d,
0x41, 0x93, 0xb8, 0xef, 0x72, 0xa0, 0x40, 0x5c, 0x3b, 0x2c, 0x50, 0xb4, 0x51,
0xed, 0x70, 0x0c, 0x1c, 0x47, 0x42, 0x62, 0xc6, 0x17, 0x22, 0xd9, 0xc5, 0x70,
0xe6, 0xb3, 0x3c, 0x89, 0xcf, 0x1b, 0xb9, 0xc2, 0x98, 0xca, 0x88, 0x3a, 0x53,
0x66, 0x8f, 0xc8, 0xde, 0x96, 0x49, 0xf2, 0x3f, 0xdf, 0x7a, 0xd8, 0x65, 0x22,
0xe1, 0x90, 0xa5, 0xd9, 0xe9, 0xc5, 0xa7, 0x17, 0x90, 0x14, 0xe3, 0xc9, 0xc2,
0x37, 0xd5, 0x96, 0x39, 0x4d, 0x22, 0xf9, 0x7d, 0x3c, 0x65, 0xd2, 0x8b, 0x56,
0x74, 0x6c, 0xf4, 0xcc, 0x02, 0xe5, 0x7e, 0x8d, 0xa7, 0x99, 0x05, 0xb2, 0xd2,
0x22, 0x41, 0x36, 0x8a, 0xed, 0xd3, 0x5c, 0xc3, 0x6e, 0xce, 0x2c, 0x92, 0x91,
0x19, 0xc9, 0xbc, 0x20, 0x92, 0xae, 0x0b, 0x36, 0xb3, 0x55, 0xc1, 0x21, 0x0d,
0xff, 0x67, 0xa6, 0x34, 0x13, 0xe7, 0xb2, 0xb7, 0xa9, 0x2c, 0xa9, 0x75, 0xc9,
0xbe, 0x47, 0xfc, 0x46, 0xb5, 0x2e, 0xd8, 0x98, 0x44, 0x8b, 0x70, 0x17, 0xf8,
0x9f, 0x31, 0xd8, 0x75, 0x10, 0x1a, 0x4b, 0x3a, 0x45, 0xe5, 0xa9, 0xa1, 0xe2,
0xa8, 0x84, 0x13, 0x07, 0x0d, 0x9a, 0x5c, 0x7e, 0x15, 0x69, 0x0b, 0x71, 0x77,
0xd4, 0x66, 0x6a, 0xd4, 0x0a, 0x85, 0x1c, 0xef, 0xc6, 0x7b, 0xbd, 0xaa, 0x99,
0x2a, 0x5b, 0xdc, 0x84, 0x99, 0xe6, 0x15, 0xf5, 0x18, 0x6a, 0x0a, 0xd8, 0x67,
0xed, 0xc1, 0xc4, 0x84, 0xf2, 0x95, 0x02, 0x7b, 0x0e, 0x6c, 0x25, 0x65, 0x16,
0xb2, 0xe1, 0x75, 0x4a, 0xdf, 0x89, 0xd4, 0x9d, 0x48, 0xaf, 0x90, 0x65, 0x28,
0x99, 0xea, 0xb0, 0x98, 0x93, 0x29, 0x2a, 0xac, 0x54, 0x0c, 0x2f, 0x53, 0x5d,
0x51, 0xec, 0x84, 0x60, 0x11, 0x3f, 0x25, 0xaf, 0x09, 0x17, 0x97, 0xdb, 0x69,
0x92, 0x38, 0x1c, 0xc6, 0xb1, 0x42, 0xa2, 0xe4, 0xe8, 0x29, 0xcd, 0x0c, 0xaa,
0x1d, 0x39, 0x28, 0x30, 0x56, 0x89, 0x44, 0x61, 0x8c, 0xab, 0x4d, 0x35, 0x4e,
0x42, 0xd4, 0x2f, 0x10, 0x8a, 0xfc, 0x3e, 0x5b, 0xd8, 0x16, 0x64, 0x20, 0xbe,
0x34, 0xf9, 0xf6, 0xe8, 0xa7, 0x16, 0x75, 0x83, 0x08, 0x40, 0xca, 0x84, 0x1f,
0x77, 0xc2, 0x31, 0x8c, 0x49, 0xee, 0x7e, 0x0d, 0xd1, 0xb6, 0xe5, 0x3e, 0x2a,
0x13, 0x82, 0x37, 0x11, 0x07, 0x17, 0x32, 0x81, 0x3d, 0x65, 0x3a, 0x61, 0xe9,
0xea, 0xf3, 0x98, 0xd0, 0xca, 0x39, 0xfc, 0x41, 0xda, 0x25, 0xa0, 0x65, 0xad,
0xaa, 0xc3, 0x27, 0xb3, 0x6a, 0x7e, 0x46, 0xec, 0xe9, 0x37, 0x58, 0x81, 0xee,
0x90, 0x81, 0xe4, 0x61, 0xa1, 0x16, 0xa5, 0x8a, 0xaa, 0xf4, 0xb6, 0x8f, 0xa0,
0x0c, 0x35, 0x1b, 0xd0, 0x60, 0x7d, 0x51, 0xef, 0x4d, 0x26, 0xc7, 0x66, 0xba,
0x36, 0xae, 0x50, 0x68, 0x6b, 0xef, 0xe6, 0xb6, 0xd3, 0x46, 0xdc, 0x75, 0x15,
0x57, 0xb6, 0x10, 0xec, 0x43, 0x99, 0x8c, 0xb9, 0x3f, 0xe2, 0x53, 0x4a, 0x4d,
0xd2, 0x0c, 0xf0, 0x20, 0x03, 0x90, 0xaf, 0xe5, 0x99, 0x18, 0x05, 0x4f, 0x14,
0x4a, 0x24, 0x3c, 0x33, 0x26, 0x21, 0x5c, 0xf0, 0xa7, 0x37, 0xc6, 0x3a, 0x8a,
0xf7, 0x98, 0x17, 0x34, 0x7c, 0xe2, 0xb6, 0xb8, 0xf4, 0x5e, 0x8b, 0xc3, 0x52,
0x49, 0xee, 0x53, 0xe8, 0xfd, 0x89, 0x2f, 0x7d, 0x89, 0xf8, 0xb6, 0x91, 0x2c,
0xdb, 0x9b, 0xe6, 0xaa, 0xce, 0x93, 0xd5, 0x28, 0xd8, 0xfa, 0x42, 0xd1, 0x6f,
0xb5, 0xd5, 0x45, 0xdc, 0x57, 0xb2, 0x36, 0x1a, 0x89, 0x89, 0x84, 0x11, 0xb6,
0xdd, 0x90, 0xe8, 0x83, 0xa9, 0x00, 0x9f, 0x00, 0x68, 0xa9, 0xf7, 0x52, 0x96,
0x94, 0x7b, 0x78, 0xc7, 0x3c, 0x47, 0x79, 0x0c, 0x2a, 0xb8, 0x84, 0x08, 0x08,
0x82, 0x39, 0x87, 0x87, 0x9e, 0x59, 0x4e, 0x54, 0x2a, 0xa2, 0x54, 0x34, 0xc6,
0x4b, 0xfd, 0x14, 0xcc, 0xac, 0xf0, 0x7e, 0xe8, 0x6c, 0x17, 0xd1, 0x5e, 0xb5,
0x42, 0xbb, 0x27, 0x98, 0x1f, 0xa7, 0x95, 0x6a, 0x20, 0x04, 0xb6, 0xd5, 0xec,
0xde, 0x1b, 0x46, 0xa6, 0x07, 0xfd, 0x52, 0xca, 0xdc, 0x7b, 0x0a, 0x6c, 0x5d,
0x41, 0xae, 0xaa, 0x6b, 0x22, 0x74, 0x7a, 0xe1, 0x87, 0xa3, 0xd9, 0x29, 0x60,
0xe9, 0x0a, 0x18, 0x14, 0x29, 0xf5, 0xca, 0xa0, 0xde, 0x0f, 0x23, 0x1c, 0x55,
0x4c, 0x22, 0xee, 0xa5, 0xcf, 0x63, 0x2f, 0x5d, 0xf2, 0x49, 0x10, 0xc1, 0x44,
0xa6, 0x26, 0xd8, 0x3c, 0x4f, 0x59, 0x99, 0x9d, 0x62, 0x6f, 0x53, 0x18, 0xb7,
0xd8, 0x70, 0xf6, 0x9a, 0x0c, 0x19, 0x94, 0x6c, 0x08, 0x0c, 0x90, 0x44, 0xf5,
0x48, 0x8c, 0x41, 0xcd, 0x14, 0xf2, 0x20, 0xd7, 0x6d, 0x22, 0xf4, 0x3e, 0x98,
0xdd, 0x60, 0xe5, 0x5e, 0xe5, 0xa0, 0x04, 0xb6, 0xf0, 0xf6, 0x37, 0x29, 0x4b,
0x14, 0x97, 0x75, 0x25, 0x2f, 0x9a, 0x98, 0x01, 0x7e, 0x04, 0x91, 0xb3, 0x06,
0x72, 0xb4, 0x40, 0xf9, 0x25, 0xa8, 0x63, 0x52, 0x02, 0xd1, 0xe6, 0xc7, 0x6c,
0x08, 0xe2, 0x04, 0xf4, 0x2d, 0x55, 0x4c, 0xc4, 0xf2, 0x0c, 0x56, 0x34, 0x51,
0x44, 0x62, 0xa5, 0xc5, 0xca, 0x52, 0x99, 0xdc, 0x19, 0x26, 0x32, 0x48, 0x41,
0xcb, 0xb1, 0x5e, 0xf0, 0x85, 0x5a, 0x45, 0xbd, 0x17, 0x4b, 0xb9, 0xf5, 0x71,
0xc0, 0xaf, 0x43, 0xdd, 0x75, 0x5f, 0x22, 0xf9, 0xc9, 0xe1, 0x2b, 0xdb, 0xa4,
0xee, 0xb0, 0xba, 0x92, 0xe1, 0x54, 0xa3, 0xb2, 0x2b, 0x65, 0xcb, 0x93, 0xd8,
0x0e, 0x34, 0xbc, 0xcf, 0xa9, 0xd1, 0x1a, 0x70, 0xf0, 0xb4, 0xb9, 0x84, 0xae,
0x87, 0xf1, 0x11, 0xb0, 0x0b, 0x65, 0xf7, 0x58, 0xe0, 0x68, 0x42, 0x97, 0xc4,
0xce, 0x78, 0x3d, 0xb7, 0x85, 0xd6, 0xa4, 0x8c, 0x84, 0x8b, 0x9b, 0xe2, 0x05,
0xa4, 0xb0, 0x73, 0x42, 0x64, 0xfb, 0x6c, 0x40, 0x96, 0xd2, 0xa4, 0x67, 0x7d,
0x2a, 0xb1, 0x4e, 0x5a, 0xa4, 0x97, 0x32, 0xa5, 0x44, 0xad, 0x03, 0x0b, 0xb8,
0xe6, 0x49, 0xfc, 0xff, 0xec, 0x70, 0x87, 0xf6, 0xb1, 0x84, 0xb0, 0x87, 0x56,
0x62, 0x65, 0x15, 0xca, 0x53, 0x35, 0xc9, 0xbc, 0x22, 0x8a, 0x08, 0xa4, 0xdd,
0x10, 0xf7, 0x39, 0x8a, 0x91, 0x28, 0xda, 0xe7, 0xec, 0xbb, 0xac, 0x94, 0xa2,
0x41, 0x76, 0x24, 0x4f, 0x0f, 0x9f, 0xb0, 0x69, 0xd9, 0x47, 0x93, 0x1e, 0x41,
0xcd, 0x88, 0x59, 0xbd, 0x24, 0xdc, 0x0a, 0x5f, 0xb4, 0xaa, 0x1c, 0xe9, 0xcf,
0x12, 0x7b, 0xe1, 0x36, 0xab, 0x9f, 0x4a, 0x77, 0xde, 0xce, 0x16, 0x92, 0xbd,
0xf7, 0x52, 0xdd, 0xde, 0x76, 0xc2, 0x6c, 0x45, 0x41, 0x67, 0x81, 0xef, 0xcc,
0x50, 0x9c, 0x8a, 0x86, 0x3e, 0xe5, 0x45, 0xba, 0x92, 0xf2, 0x56, 0x8a, 0x6a,
0xc7, 0x5b, 0xbc, 0xf1, 0x56, 0x9c, 0xa4, 0x8e, 0x83, 0xf1, 0x67, 0xdc, 0xac,
0x77, 0x70, 0x19, 0xeb, 0x18, 0x0e, 0xe4, 0x76, 0x77, 0x8c, 0x0e, 0x4d, 0x6c,
0x52, 0x2d, 0x1e, 0xa7, 0x6c, 0xe2, 0x5b, 0x5c, 0xd8, 0xf7, 0x40, 0xd0, 0x92,
0xb9, 0xa2, 0x46, 0xf5, 0x71, 0x0c, 0xf9, 0x81, 0x8d, 0x99, 0x08, 0x87, 0x48,
0xc1, 0x72, 0x7a, 0xb0, 0xf4, 0x49, 0x3b, 0xd4, 0x99, 0xd5, 0x0a, 0xd9, 0xd3,
0xea, 0xd1, 0xa5, 0x09, 0xf7, 0xc9, 0x60, 0x17, 0x5d, 0x35, 0x61, 0x87, 0x13,
0x0d, 0xd5, 0x91, 0x56, 0x2c, 0xe9, 0x49, 0x54, 0x89, 0xde, 0xe2, 0x02, 0xdb,
0x22, 0x9f, 0x20, 0xe6, 0xbc, 0x9b, 0x7a, 0xf6, 0xf5, 0xea, 0xad, 0x3a, 0x52,
0x6b, 0x48, 0x27, 0xc5, 0xaf, 0xa8, 0xbc, 0x51, 0x95, 0x5f, 0x93, 0x77, 0x8d,
0x4d, 0x80, 0x9e, 0x40, 0x2d, 0x8a, 0x2b, 0x8e, 0xce, 0x04, 0xad, 0x58, 0x92,
0x7b, 0xe1, 0x0d, 0x66, 0x63, 0xe2, 0x5a, 0x8d, 0xcb, 0xe8, 0x8f, 0x39, 0x8c,
0x30, 0x51, 0x51, 0xdd, 0xe9, 0x89, 0x93, 0x3c, 0x6c, 0xe5, 0x82, 0x48, 0x64,
0x52, 0x91, 0x03, 0x54, 0xc2, 0x19, 0x2d, 0xb6, 0x23, 0x7d, 0xee, 0x24, 0x21,
0x8b, 0xde, 0x3c, 0xac, 0xfb, 0x6c, 0x2d, 0xee, 0x77, 0x95, 0x7f, 0xe4, 0x6f,
0xea, 0xbc, 0x9c, 0xd4, 0xfd, 0x52, 0x15, 0x78, 0x5e, 0xad, 0x11, 0x5b, 0x20,
0x8c, 0xce, 0xf6, 0xfa, 0x9b, 0x62, 0x49, 0xa2, 0x0e, 0x1a, 0x90, 0x2e, 0xd9,
0x4b, 0x53, 0xd3, 0x68, 0xb1, 0xa5, 0x4e, 0x6c, 0x7a, 0x88, 0x02, 0x78, 0x23,
0xa2, 0xe1, 0x16, 0xef, 0x46, 0x75, 0x29, 0x9c, 0xa0, 0x91, 0x29, 0x44, 0x0a,
0x79, 0xa4, 0x9e, 0xb0, 0x99, 0x01, 0x2d, 0xec, 0xbd, 0x38, 0x7a, 0x33, 0xef,
0x58, 0x5c, 0x73, 0x4b, 0x7e, 0xdf, 0x00, 0xff, 0xef, 0x45, 0xf6, 0x72, 0xe4,
0x4e, 0xce, 0xfa, 0xfd, 0x12, 0xa4, 0xf7, 0xd3, 0xbc, 0x90, 0x61, 0xb3, 0x8c,
0x5c, 0x7b, 0xcf, 0xfb, 0x00, 0x35, 0xc6, 0x15, 0xa0, 0x91, 0x4b, 0x19, 0xc7,
0x2d, 0x44, 0xd8, 0xe4, 0xa5, 0xde, 0xf0, 0xaa, 0xc4, 0x9a, 0xda, 0xf3, 0x5c,
0x44, 0xd7, 0xd4, 0x83, 0xb5, 0x27, 0xf5, 0x6c, 0x43, 0x06, 0xd7, 0x65, 0x96,
0x66, 0xaf, 0x3d, 0x4e, 0x3b, 0x08, 0xa2, 0xdc, 0xaf, 0x0c, 0xbc, 0x93, 0x65,
0x64, 0xd0, 0x6b, 0xa7, 0x64, 0x2c, 0xf8, 0x80, 0xc6, 0x97, 0x0d, 0x5d, 0xb4,
0xed, 0xe6, 0x8d, 0x03, 0x08, 0xc8, 0x9f, 0x4e, 0x06, 0x2b, 0xfa, 0x32, 0xae,
0x2c, 0x9f, 0x4f, 0xab, 0xd8, 0xc8, 0xd7, 0x0d, 0xa9, 0x81, 0x37, 0x2e, 0x4b,
0xa9, 0x9f, 0xfa, 0x0d, 0x8d, 0x71, 0x94, 0x04, 0xba, 0x36, 0x97, 0x72, 0xaa,
0xb1, 0x55, 0xaf, 0xc0, 0xf9, 0x75, 0x37, 0x5f, 0x8c, 0x28, 0x4d, 0x4a, 0x8e,
0xc0, 0xe3, 0x94, 0x3b, 0x68, 0xee, 0x45, 0x99, 0x9d, 0xa3, 0x38, 0x35, 0x80,
0x04, 0xb7, 0x65, 0x33, 0xb3, 0x13, 0xe2, 0xa0, 0x4d, 0xc2, 0x34, 0x81, 0x26,
0xf8, 0x76, 0xa4, 0xd3, 0x80, 0x8c, 0x02, 0x2e, 0x8e, 0xc9, 0x9a, 0xb5, 0x6c,
0xdb, 0x94, 0xc7, 0x3e, 0x44, 0xa8, 0x39, 0x64, 0x81, 0xd4, 0x44, 0x93, 0xd5,
0x85, 0x6c, 0x65, 0xea, 0x6a, 0x89, 0x2a, 0xaa, 0xf9, 0x73, 0xb1, 0xad, 0x3a,
0x3e, 0x2d, 0x68, 0x6a, 0xdd, 0x53, 0xe8, 0xa7, 0xb2, 0x30, 0x6c, 0x2f, 0xb2,
0xec, 0x68, 0x9c, 0xb4, 0xce, 0x2b, 0x9d, 0x88, 0xe4, 0x4f, 0xb6, 0xea, 0xc4,
0x1b, 0xb3, 0xae, 0x74, 0xca, 0x60, 0xbf, 0x89, 0xf7, 0xbb, 0xba, 0x02, 0xa1,
0x6c, 0x57, 0xa3, 0x15, 0x7b, 0x39, 0x91, 0x45, 0x3d, 0x1c, 0x31, 0xf6, 0xb9,
0x3f, 0xb0, 0x69, 0x33, 0xbf, 0xe2, 0x64, 0x3c, 0x92, 0x96, 0xb3, 0x88, 0xc5,
0xf6, 0x17, 0xda, 0xc2, 0x7f, 0x3d, 0x72, 0x75, 0x63, 0xbd, 0x5c, 0x2c, 0x32,
0x35, 0x69, 0x62, 0xd9, 0xd4, 0x8f, 0xde, 0x1f, 0xfe, 0xb4, 0x00, 0x76, 0x88,
0xf1, 0x8d, 0x3c, 0xcd, 0x4a, 0x06, 0x71, 0xac, 0xfa, 0xbd, 0xdd, 0xeb, 0x44,
0x7c, 0x9b, 0x0c, 0xcf, 0xa9, 0x53, 0x9c, 0x39, 0x67, 0x31, 0x94, 0xe9, 0x5c,
0xb6, 0xbd, 0x4f, 0xaa, 0xc9, 0x95, 0x9a, 0x9c, 0x8a, 0xcb, 0x6e, 0xfd, 0xc9,
0xd9, 0xe1, 0x49, 0xb0, 0x0e, 0xeb, 0x7f, 0x06, 0x79, 0x42, 0x99, 0x3d, 0x2a,
0x04, 0xaa, 0x40, 0x33, 0x56, 0x5c, 0xb6, 0x58, 0x85, 0xb7, 0xd4, 0x7d, 0xd1,
0xfa, 0x65, 0x9f, 0xda, 0xd8, 0x13, 0x1c, 0xb9, 0x6a, 0xeb, 0x98, 0x5e, 0x1d,
0x94, 0xb7, 0xe1, 0xfc, 0x0c, 0xbc, 0x10, 0x3f, 0xab, 0x88, 0xd2, 0xc3, 0xf9,
0x8c, 0x17, 0x5f, 0x9a, 0xa3, 0xc3, 0xe5, 0xa7, 0x32, 0x8b, 0x8e, 0x76, 0x57,
0x95, 0x9d, 0x8f, 0xca, 0x77, 0xa2, 0x33, 0xd0, 0xc2, 0x09, 0x45, 0x81, 0xed,
0xb8, 0xf5, 0x8e, 0x5a, 0xf4, 0xe4, 0xb9, 0x77, 0xdb, 0xd6, 0x07, 0xb0, 0x64,
0x79, 0x7b, 0x05, 0x79, 0x27, 0xea, 0xc7, 0x24, 0x16, 0x02, 0x2e, 0x32, 0x87,
0x22, 0x8e, 0x5b, 0x47, 0xe3, 0xa7, 0x33, 0x52, 0x6c, 0xa2, 0x75, 0x28, 0x47,
0x54, 0x0b, 0x9b, 0x9d, 0xa8, 0x6e, 0x15, 0xee, 0xfb, 0xf2, 0xb0, 0x8d, 0x5e,
0x1f, 0xb8, 0xa2, 0x14, 0xed, 0xcc, 0x63, 0xba, 0x05, 0xed, 0x75, 0xa0, 0xf7,
0x20, 0xb6, 0x9d, 0x7a, 0x84, 0x4e, 0x42, 0x49, 0xa1, 0x9f, 0xd9, 0x92, 0xf4,
0x92, 0xd8, 0xaf, 0xb2, 0x4c, 0x77, 0xa4, 0xba, 0x8b, 0xd9, 0xfa, 0x07, 0xc9,
0xa6, 0xea, 0x4e, 0xc7, 0xea, 0x18, 0xec, 0xe5, 0x0c, 0x90, 0xd8, 0x9e, 0xeb,
0x8e, 0xaf, 0x83, 0xa9, 0x79, 0x4f, 0xb7, 0xd0, 0xdb, 0x41, 0xe3, 0xdd, 0x5a,
0xf6, 0xd0, 0xaf, 0xbd, 0x7a, 0xc7, 0xcb, 0x2f, 0xd9, 0x2e, 0xdd, 0x9c, 0x97,
0x35, 0xbc, 0xff, 0x66, 0x58, 0xa6, 0xb0, 0x7f, 0xe1, 0x46, 0xd2, 0xf6, 0x54,
0x54, 0x42, 0x3b, 0x46, 0x7a, 0x6c, 0x36, 0xfb, 0x20, 0x89, 0x82, 0x7c, 0x92,
0x87, 0x7b, 0x46, 0xb5, 0xc6, 0xa9, 0xd3, 0xd5, 0xf4, 0xdb, 0xb4, 0x1d, 0x7d,
0x93, 0x6e, 0x03, 0xc0, 0x46, 0xcb, 0x63, 0xa9, 0xf7, 0xd7, 0x08, 0xdf, 0x8f,
0x86, 0x6d, 0x0f, 0x03, 0x65, 0x8b, 0x6e, 0x1f, 0xfa, 0x94, 0x6a, 0x7b, 0x68,
0x03, 0xa7, 0xa4, 0x84, 0x65, 0x78, 0xc0, 0x5b, 0x39, 0x6f, 0xe7, 0x7b, 0xdd,
0x40, 0xb9, 0x5a, 0xcc, 0x9e, 0xfe, 0xdd, 0x29, 0xcb, 0x6d, 0x67, 0x3a, 0x59,
0xbf, 0x6b, 0x01, 0x86, 0xf7, 0xfb, 0x0e, 0x5e, 0xd4, 0x85, 0x7f, 0x01,
};
optimizesize void *__jisx0212_decmap(void) {
return xloadzd(&__jisx0212_decmap_ptr,
__jisx0212_decmap_rodata,
3327, 6340, 6179, 2, 0xebc09e11u); /* 26.9218% profit */
}
| 20,837 | 269 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/_codecs_kr.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Python 3 â
â https://docs.python.org/3/license.html â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
/* clang-format off */
/*
* _codecs_kr.c: Codecs collection for Korean encodings
*
* Written by Hye-Shik "Bourne to Macro" Chang <[email protected]>
*/
#include "third_party/python/Modules/cjkcodecs/cjkcodecs.h"
#include "third_party/python/Include/yoink.h"
#include "third_party/python/Include/import.h"
PYTHON_PROVIDE("_codecs_kr");
PYTHON_PROVIDE("_codecs_kr.__map_cp949");
PYTHON_PROVIDE("_codecs_kr.__map_cp949ext");
PYTHON_PROVIDE("_codecs_kr.__map_ksx1001");
PYTHON_PROVIDE("_codecs_kr.getcodec");
/*
* EUC-KR codec
*/
#define EUCKR_JAMO_FIRSTBYTE 0xA4
#define EUCKR_JAMO_FILLER 0xD4
static const unsigned char u2cgk_choseong[19] = {
0xa1, 0xa2, 0xa4, 0xa7, 0xa8, 0xa9, 0xb1, 0xb2,
0xb3, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb,
0xbc, 0xbd, 0xbe
};
static const unsigned char u2cgk_jungseong[21] = {
0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6,
0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
0xcf, 0xd0, 0xd1, 0xd2, 0xd3
};
static const unsigned char u2cgk_jongseong[28] = {
0xd4, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0,
0xb1, 0xb2, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xba,
0xbb, 0xbc, 0xbd, 0xbe
};
ENCODER(euc_kr)
{
while (*inpos < inlen) {
Py_UCS4 c = INCHAR1;
DBCHAR code;
if (c < 0x80) {
WRITEBYTE1((unsigned char)c);
NEXT(1, 1);
continue;
}
if (c > 0xFFFF)
return 1;
REQUIRE_OUTBUF(2);
if (TRYMAP_ENC(cp949, code, c))
;
else
return 1;
if ((code & 0x8000) == 0) {
/* KS X 1001 coded character */
OUTBYTE1((code >> 8) | 0x80);
OUTBYTE2((code & 0xFF) | 0x80);
NEXT(1, 2);
}
else {
/* Mapping is found in CP949 extension,
but we encode it in KS X 1001:1998 Annex 3,
make-up sequence for EUC-KR. */
REQUIRE_OUTBUF(8);
/* syllable composition precedence */
OUTBYTE1(EUCKR_JAMO_FIRSTBYTE);
OUTBYTE2(EUCKR_JAMO_FILLER);
/* All code points in CP949 extension are in unicode
* Hangul Syllable area. */
assert(0xac00 <= c && c <= 0xd7a3);
c -= 0xac00;
OUTBYTE3(EUCKR_JAMO_FIRSTBYTE);
OUTBYTE4(u2cgk_choseong[c / 588]);
NEXT_OUT(4);
OUTBYTE1(EUCKR_JAMO_FIRSTBYTE);
OUTBYTE2(u2cgk_jungseong[(c / 28) % 21]);
OUTBYTE3(EUCKR_JAMO_FIRSTBYTE);
OUTBYTE4(u2cgk_jongseong[c % 28]);
NEXT(1, 4);
}
}
return 0;
}
#define NONE 127
static const unsigned char cgk2u_choseong[] = { /* [A1, BE] */
0, 1, NONE, 2, NONE, NONE, 3, 4,
5, NONE, NONE, NONE, NONE, NONE, NONE, NONE,
6, 7, 8, NONE, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18
};
static const unsigned char cgk2u_jongseong[] = { /* [A1, BE] */
1, 2, 3, 4, 5, 6, 7, NONE,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, NONE, 18, 19, 20, 21, 22,
NONE, 23, 24, 25, 26, 27
};
DECODER(euc_kr)
{
while (inleft > 0) {
unsigned char c = INBYTE1;
Py_UCS4 decoded;
if (c < 0x80) {
OUTCHAR(c);
NEXT_IN(1);
continue;
}
REQUIRE_INBUF(2);
if (c == EUCKR_JAMO_FIRSTBYTE &&
INBYTE2 == EUCKR_JAMO_FILLER) {
/* KS X 1001:1998 Annex 3 make-up sequence */
DBCHAR cho, jung, jong;
REQUIRE_INBUF(8);
if ((*inbuf)[2] != EUCKR_JAMO_FIRSTBYTE ||
(*inbuf)[4] != EUCKR_JAMO_FIRSTBYTE ||
(*inbuf)[6] != EUCKR_JAMO_FIRSTBYTE)
return 1;
c = (*inbuf)[3];
if (0xa1 <= c && c <= 0xbe)
cho = cgk2u_choseong[c - 0xa1];
else
cho = NONE;
c = (*inbuf)[5];
jung = (0xbf <= c && c <= 0xd3) ? c - 0xbf : NONE;
c = (*inbuf)[7];
if (c == EUCKR_JAMO_FILLER)
jong = 0;
else if (0xa1 <= c && c <= 0xbe)
jong = cgk2u_jongseong[c - 0xa1];
else
jong = NONE;
if (cho == NONE || jung == NONE || jong == NONE)
return 1;
OUTCHAR(0xac00 + cho*588 + jung*28 + jong);
NEXT_IN(8);
}
else if (TRYMAP_DEC(ksx1001, decoded, c ^ 0x80, INBYTE2 ^ 0x80)) {
OUTCHAR(decoded);
NEXT_IN(2);
}
else
return 1;
}
return 0;
}
#undef NONE
/*
* CP949 codec
*/
ENCODER(cp949)
{
while (*inpos < inlen) {
Py_UCS4 c = INCHAR1;
DBCHAR code;
if (c < 0x80) {
WRITEBYTE1((unsigned char)c);
NEXT(1, 1);
continue;
}
if (c > 0xFFFF)
return 1;
REQUIRE_OUTBUF(2);
if (TRYMAP_ENC(cp949, code, c))
;
else
return 1;
OUTBYTE1((code >> 8) | 0x80);
if (code & 0x8000)
OUTBYTE2(code & 0xFF); /* MSB set: CP949 */
else
OUTBYTE2((code & 0xFF) | 0x80); /* MSB unset: ks x 1001 */
NEXT(1, 2);
}
return 0;
}
DECODER(cp949)
{
while (inleft > 0) {
unsigned char c = INBYTE1;
Py_UCS4 decoded;
if (c < 0x80) {
OUTCHAR(c);
NEXT_IN(1);
continue;
}
REQUIRE_INBUF(2);
if (TRYMAP_DEC(ksx1001, decoded, c ^ 0x80, INBYTE2 ^ 0x80))
OUTCHAR(decoded);
else if (TRYMAP_DEC(cp949ext, decoded, c, INBYTE2))
OUTCHAR(decoded);
else
return 1;
NEXT_IN(2);
}
return 0;
}
/*
* JOHAB codec
*/
static const unsigned char u2johabidx_choseong[32] = {
0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14,
};
static const unsigned char u2johabidx_jungseong[32] = {
0x03, 0x04, 0x05, 0x06, 0x07,
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x1a, 0x1b, 0x1c, 0x1d,
};
static const unsigned char u2johabidx_jongseong[32] = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
};
static const DBCHAR u2johabjamo[] = {
0x8841, 0x8c41, 0x8444, 0x9041, 0x8446, 0x8447, 0x9441,
0x9841, 0x9c41, 0x844a, 0x844b, 0x844c, 0x844d, 0x844e, 0x844f,
0x8450, 0xa041, 0xa441, 0xa841, 0x8454, 0xac41, 0xb041, 0xb441,
0xb841, 0xbc41, 0xc041, 0xc441, 0xc841, 0xcc41, 0xd041, 0x8461,
0x8481, 0x84a1, 0x84c1, 0x84e1, 0x8541, 0x8561, 0x8581, 0x85a1,
0x85c1, 0x85e1, 0x8641, 0x8661, 0x8681, 0x86a1, 0x86c1, 0x86e1,
0x8741, 0x8761, 0x8781, 0x87a1,
};
ENCODER(johab)
{
while (*inpos < inlen) {
Py_UCS4 c = INCHAR1;
DBCHAR code;
if (c < 0x80) {
WRITEBYTE1((unsigned char)c);
NEXT(1, 1);
continue;
}
if (c > 0xFFFF)
return 1;
REQUIRE_OUTBUF(2);
if (c >= 0xac00 && c <= 0xd7a3) {
c -= 0xac00;
code = 0x8000 |
(u2johabidx_choseong[c / 588] << 10) |
(u2johabidx_jungseong[(c / 28) % 21] << 5) |
u2johabidx_jongseong[c % 28];
}
else if (c >= 0x3131 && c <= 0x3163)
code = u2johabjamo[c - 0x3131];
else if (TRYMAP_ENC(cp949, code, c)) {
unsigned char c1, c2, t2;
unsigned short t1;
assert((code & 0x8000) == 0);
c1 = code >> 8;
c2 = code & 0xff;
if (((c1 >= 0x21 && c1 <= 0x2c) ||
(c1 >= 0x4a && c1 <= 0x7d)) &&
(c2 >= 0x21 && c2 <= 0x7e)) {
t1 = (c1 < 0x4a ? (c1 - 0x21 + 0x1b2) :
(c1 - 0x21 + 0x197));
t2 = ((t1 & 1) ? 0x5e : 0) + (c2 - 0x21);
OUTBYTE1(t1 >> 1);
OUTBYTE2(t2 < 0x4e ? t2 + 0x31 : t2 + 0x43);
NEXT(1, 2);
continue;
}
else
return 1;
}
else
return 1;
OUTBYTE1(code >> 8);
OUTBYTE2(code & 0xff);
NEXT(1, 2);
}
return 0;
}
#define FILL 0xfd
#define NONE 0xff
static const unsigned char johabidx_choseong[32] = {
NONE, FILL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, NONE, NONE, NONE,
NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,
};
static const unsigned char johabidx_jungseong[32] = {
NONE, NONE, FILL, 0x00, 0x01, 0x02, 0x03, 0x04,
NONE, NONE, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
NONE, NONE, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
NONE, NONE, 0x11, 0x12, 0x13, 0x14, NONE, NONE,
};
static const unsigned char johabidx_jongseong[32] = {
NONE, FILL, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
0x0f, 0x10, NONE, 0x11, 0x12, 0x13, 0x14, 0x15,
0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, NONE, NONE,
};
static const unsigned char johabjamo_choseong[32] = {
NONE, FILL, 0x31, 0x32, 0x34, 0x37, 0x38, 0x39,
0x41, 0x42, 0x43, 0x45, 0x46, 0x47, 0x48, 0x49,
0x4a, 0x4b, 0x4c, 0x4d, 0x4e, NONE, NONE, NONE,
NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,
};
static const unsigned char johabjamo_jungseong[32] = {
NONE, NONE, FILL, 0x4f, 0x50, 0x51, 0x52, 0x53,
NONE, NONE, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
NONE, NONE, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
NONE, NONE, 0x60, 0x61, 0x62, 0x63, NONE, NONE,
};
static const unsigned char johabjamo_jongseong[32] = {
NONE, FILL, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, NONE, 0x42, 0x44, 0x45, 0x46, 0x47,
0x48, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, NONE, NONE,
};
DECODER(johab)
{
while (inleft > 0) {
unsigned char c = INBYTE1, c2;
Py_UCS4 decoded;
if (c < 0x80) {
OUTCHAR(c);
NEXT_IN(1);
continue;
}
REQUIRE_INBUF(2);
c2 = INBYTE2;
if (c < 0xd8) {
/* johab hangul */
unsigned char c_cho, c_jung, c_jong;
unsigned char i_cho, i_jung, i_jong;
c_cho = (c >> 2) & 0x1f;
c_jung = ((c << 3) | c2 >> 5) & 0x1f;
c_jong = c2 & 0x1f;
i_cho = johabidx_choseong[c_cho];
i_jung = johabidx_jungseong[c_jung];
i_jong = johabidx_jongseong[c_jong];
if (i_cho == NONE || i_jung == NONE || i_jong == NONE)
return 1;
/* we don't use U+1100 hangul jamo yet. */
if (i_cho == FILL) {
if (i_jung == FILL) {
if (i_jong == FILL)
OUTCHAR(0x3000);
else
OUTCHAR(0x3100 |
johabjamo_jongseong[c_jong]);
}
else {
if (i_jong == FILL)
OUTCHAR(0x3100 |
johabjamo_jungseong[c_jung]);
else
return 1;
}
} else {
if (i_jung == FILL) {
if (i_jong == FILL)
OUTCHAR(0x3100 |
johabjamo_choseong[c_cho]);
else
return 1;
}
else
OUTCHAR(0xac00 +
i_cho * 588 +
i_jung * 28 +
(i_jong == FILL ? 0 : i_jong));
}
NEXT_IN(2);
} else {
/* KS X 1001 except hangul jamos and syllables */
if (c == 0xdf || c > 0xf9 ||
c2 < 0x31 || (c2 >= 0x80 && c2 < 0x91) ||
(c2 & 0x7f) == 0x7f ||
(c == 0xda && (c2 >= 0xa1 && c2 <= 0xd3)))
return 1;
else {
unsigned char t1, t2;
t1 = (c < 0xe0 ? 2 * (c - 0xd9) :
2 * c - 0x197);
t2 = (c2 < 0x91 ? c2 - 0x31 : c2 - 0x43);
t1 = t1 + (t2 < 0x5e ? 0 : 1) + 0x21;
t2 = (t2 < 0x5e ? t2 : t2 - 0x5e) + 0x21;
if (TRYMAP_DEC(ksx1001, decoded, t1, t2)) {
OUTCHAR(decoded);
NEXT_IN(2);
}
else {
return 1;
}
}
}
}
return 0;
}
#undef NONE
#undef FILL
BEGIN_MAPPINGS_LIST
MAPPING_DECONLY(ksx1001)
MAPPING_ENCONLY(cp949)
MAPPING_DECONLY(cp949ext)
END_MAPPINGS_LIST
BEGIN_CODECS_LIST
CODEC_STATELESS(euc_kr)
CODEC_STATELESS(cp949)
CODEC_STATELESS(johab)
END_CODECS_LIST
I_AM_A_MODULE_FOR(kr)
_Section(".rodata.pytab.1") const struct _inittab _PyImport_Inittab__codecs_kr = {
"_codecs_kr",
PyInit__codecs_kr,
};
| 14,256 | 489 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__jisx0213_emp_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __jisx0213_emp_encmap_ptr;
static const unsigned char __jisx0213_emp_encmap_rodata[] = {
0xed, 0x5a, 0xdb, 0x4e, 0xe2, 0x50, 0x14, 0xfd, 0x16, 0x40, 0xe2, 0x80, 0x8e,
0x38, 0x55, 0xbc, 0x30, 0x82, 0x0e, 0x3a, 0xde, 0x47, 0x1c, 0x2f, 0x28, 0x2a,
0x5e, 0x82, 0x62, 0xbc, 0x11, 0x44, 0x0b, 0x22, 0xca, 0xbf, 0x90, 0x96, 0xa4,
0x0f, 0x5c, 0xfe, 0x0c, 0x28, 0x2d, 0x42, 0x29, 0xb4, 0x43, 0x7c, 0x60, 0x46,
0x87, 0x02, 0x07, 0xda, 0xd2, 0xd2, 0xae, 0x07, 0x42, 0x0e, 0xe7, 0xac, 0xbd,
0xd6, 0xda, 0xfb, 0x90, 0x94, 0xa0, 0x1d, 0x61, 0x15, 0x0b, 0x4d, 0x0c, 0xf4,
0xc4, 0x50, 0xed, 0xc4, 0x48, 0x6c, 0x22, 0xb6, 0x18, 0xf3, 0xc7, 0xa4, 0xe3,
0x23, 0xdc, 0x42, 0x4b, 0x28, 0xa6, 0xac, 0xbe, 0x6a, 0x11, 0x3d, 0x32, 0x88,
0xb0, 0x2a, 0x24, 0x89, 0x6f, 0x08, 0x84, 0x4c, 0x21, 0xb3, 0xa2, 0xf4, 0xe7,
0x87, 0xa2, 0xa7, 0x60, 0x15, 0xd9, 0xea, 0xda, 0xff, 0x36, 0xe2, 0x42, 0x8e,
0xd4, 0xbb, 0xc4, 0xee, 0x38, 0x42, 0x6a, 0x0a, 0x1d, 0xc1, 0x88, 0x5a, 0xd0,
0xcf, 0x6b, 0x10, 0xca, 0xf3, 0x77, 0x0a, 0x6a, 0x45, 0x5d, 0x68, 0x6f, 0xfc,
0xd9, 0x4d, 0x60, 0xfb, 0x8f, 0xba, 0xd2, 0xe9, 0xf9, 0x70, 0xfa, 0x18, 0x95,
0xe7, 0x4c, 0xdc, 0x70, 0xea, 0xbe, 0x06, 0x76, 0x14, 0x40, 0xd7, 0x4d, 0x9d,
0x68, 0x78, 0x6c, 0x52, 0x09, 0x46, 0x95, 0x7d, 0x67, 0xf5, 0x71, 0x28, 0x7e,
0x6a, 0xb2, 0xc5, 0x97, 0xe2, 0xfd, 0xea, 0xd0, 0xe3, 0xd8, 0xed, 0x91, 0x37,
0x67, 0x3c, 0x62, 0x8a, 0xc6, 0x47, 0xb1, 0x49, 0x0c, 0xec, 0xdc, 0x14, 0xd6,
0x69, 0xc5, 0xef, 0x00, 0x27, 0x2d, 0x1d, 0x54, 0xf9, 0xd9, 0xe0, 0xcc, 0x5c,
0x7d, 0x6d, 0x16, 0x80, 0x71, 0x19, 0xe3, 0x3b, 0xed, 0x55, 0x6c, 0x0d, 0xf3,
0x39, 0x0e, 0x31, 0x79, 0x4d, 0xa7, 0x17, 0x63, 0x55, 0xd4, 0x70, 0x8b, 0x69,
0x13, 0xdb, 0xcc, 0x50, 0x42, 0x4d, 0x82, 0x1b, 0xa3, 0x89, 0xcd, 0xc4, 0x85,
0xc4, 0x13, 0xba, 0x4b, 0x04, 0x12, 0x03, 0x49, 0x28, 0xf9, 0x79, 0xdd, 0x90,
0x34, 0x26, 0xe5, 0x93, 0xb4, 0x39, 0x39, 0xfe, 0x41, 0xed, 0x74, 0xd2, 0x99,
0x1c, 0x48, 0x71, 0xed, 0x7e, 0x4d, 0x5a, 0x60, 0xa1, 0x15, 0xe9, 0x52, 0x96,
0x94, 0x7c, 0x27, 0xd7, 0x5e, 0xd3, 0x6e, 0x4d, 0xcd, 0xd4, 0x5e, 0x17, 0xea,
0x2e, 0x96, 0xea, 0xef, 0x56, 0xea, 0xef, 0xe6, 0x53, 0xbb, 0xa9, 0xbd, 0x7f,
0x7c, 0x3a, 0xdb, 0xf4, 0x7c, 0x98, 0x52, 0xf2, 0xf7, 0x42, 0x28, 0xf5, 0xd4,
0x03, 0xff, 0xc6, 0xb4, 0xb0, 0xfc, 0x01, 0xd8, 0x9e, 0x9e, 0x4d, 0xcf, 0x73,
0x56, 0x99, 0x4b, 0xbb, 0x5a, 0x28, 0xd8, 0xe0, 0x45, 0xa1, 0x21, 0xc8, 0x8f,
0x1f, 0x28, 0x78, 0x96, 0x66, 0x55, 0xb0, 0xd7, 0x80, 0x29, 0x5c, 0xa5, 0xfd,
0xc0, 0xb9, 0xc1, 0x69, 0x5d, 0x66, 0x3c, 0xa3, 0xe4, 0x94, 0x4f, 0x83, 0x2b,
0x4d, 0xfc, 0xc3, 0xa4, 0xf0, 0x0a, 0x8e, 0x32, 0xea, 0xac, 0xb7, 0xd1, 0x27,
0x1e, 0x53, 0x3a, 0xc9, 0x1c, 0x67, 0xa0, 0xec, 0x52, 0xf6, 0x57, 0x56, 0xcd,
0xb5, 0xf7, 0x38, 0x13, 0xb9, 0x0b, 0xe7, 0x59, 0x6d, 0x6e, 0x2c, 0xa7, 0xcc,
0xac, 0xa7, 0x73, 0xb7, 0xa1, 0xed, 0x5c, 0x24, 0x37, 0x82, 0x03, 0x3f, 0x53,
0xe1, 0x66, 0x7c, 0x01, 0x77, 0xe3, 0xbc, 0x77, 0x1f, 0x17, 0xc3, 0xb7, 0xb7,
0xeb, 0x2a, 0x57, 0x38, 0xdc, 0x90, 0x23, 0x84, 0x3f, 0xe3, 0xea, 0x1d, 0xfe,
0x0b, 0x4d, 0x9e, 0x1f, 0x9e, 0x01, 0x40, 0x1e, 0x5d, 0xfe, 0x4b, 0x5e, 0x38,
0x57, 0xc3, 0x79, 0x6b, 0x5e, 0xde, 0x7d, 0x89, 0x3e, 0x49, 0x51, 0xd5, 0x72,
0xde, 0x10, 0x56, 0xef, 0x0c, 0x18, 0x0e, 0xf3, 0x4b, 0x22, 0x67, 0x06, 0x37,
0x9c, 0xfd, 0x60, 0x7e, 0xa7, 0x85, 0x0e, 0x88, 0xb0, 0x11, 0x56, 0x82, 0xf3,
0xb9, 0x94, 0xd8, 0x22, 0xdc, 0x04, 0xa8, 0x96, 0x63, 0xc2, 0x17, 0x7e, 0x20,
0xf8, 0xf5, 0xf7, 0xc8, 0xc1, 0x17, 0x7a, 0x5f, 0x87, 0x09, 0xb9, 0x4e, 0xca,
0x2b, 0x80, 0xf2, 0x48, 0x8b, 0xbd, 0x5a, 0x72, 0x80, 0x14, 0x5b, 0xff, 0x20,
0xa9, 0xac, 0x9b, 0x6d, 0xe2, 0xf0, 0x3b, 0xd2, 0x51, 0x0e, 0x66, 0x72, 0xbc,
0xe1, 0x39, 0xab, 0xe4, 0x52, 0xb5, 0x2b, 0xac, 0xcf, 0xed, 0xc3, 0x41, 0x5e,
0x01, 0x64, 0x73, 0x43, 0x06, 0xc8, 0x30, 0x69, 0x2e, 0x08, 0xaf, 0xcb, 0x52,
0x58, 0x2c, 0x38, 0x39, 0xeb, 0xec, 0x17, 0x0e, 0xba, 0xd0, 0xe0, 0x2e, 0xf4,
0x6f, 0x3f, 0x4f, 0x0a, 0x9e, 0x1e, 0xb8, 0xbb, 0x16, 0xa9, 0xa6, 0x5f, 0x90,
0x3a, 0x0f, 0x12, 0x9b, 0x07, 0xf7, 0xf3, 0x82, 0x04, 0xff, 0x03, 0xb2, 0xf0,
0xd6, 0x7f, 0xb7, 0x65, 0xe3, 0x6d, 0x2c, 0xc2, 0x5b, 0xd7, 0xde, 0xe0, 0x3e,
0x48, 0x48, 0x53, 0xd4, 0x16, 0xa3, 0x6f, 0x2b, 0x91, 0xb1, 0xa2, 0x30, 0xfc,
0x13, 0xc5, 0x8b, 0xe2, 0x39, 0x2f, 0xdc, 0x37, 0x45, 0x5f, 0x51, 0xec, 0x74,
0x1e, 0x8a, 0xc6, 0x92, 0xa1, 0xd4, 0xe1, 0x13, 0x7e, 0x49, 0x0e, 0xfd, 0xbf,
0x6d, 0x7a, 0x1f, 0xc6, 0x4b, 0x33, 0x6d, 0xbb, 0xb0, 0x09, 0xea, 0xd7, 0x5e,
0x72, 0x96, 0x3c, 0xa5, 0x50, 0xc3, 0x1a, 0xe1, 0xff, 0x56, 0x9f, 0x4b, 0x7a,
0xca, 0x44, 0x41, 0xd4, 0x34, 0x65, 0xa7, 0x04, 0xff, 0xc5, 0x81, 0x5a, 0x79,
0x69, 0xb4, 0xee, 0xa2, 0xd8, 0x3e, 0xc7, 0x31, 0xf5, 0xfb, 0xc5, 0x2b, 0x39,
0x97, 0x37, 0xd4, 0xb3, 0x6c, 0x93, 0x8f, 0x52, 0x9a, 0xf2, 0x70, 0x99, 0x97,
0x27, 0xbf, 0xf2, 0xe6, 0x3b, 0x8f, 0x83, 0x07, 0xb6, 0xbd, 0x0e, 0x39, 0x2e,
0xca, 0xde, 0xb2, 0xf0, 0x99, 0xdd, 0x97, 0x03, 0xe5, 0x68, 0xc3, 0x3a, 0x1a,
0x1a, 0x9c, 0xed, 0x2b, 0x2d, 0x9c, 0xd2, 0x61, 0x9e, 0xb9, 0x27, 0x68, 0x71,
0xa6, 0x72, 0xb2, 0x45, 0x1d, 0xdb, 0x87, 0xcf, 0xad, 0xf4, 0x86, 0x80, 0xba,
0x1c, 0xf4, 0x1e, 0xcd, 0xca, 0x1c, 0x07, 0xb2, 0x77, 0xc0, 0x3f, 0x8e, 0x68,
0x37, 0x50, 0x2a, 0x67, 0xb2, 0xc8, 0xf0, 0xa2, 0x0f, 0x3a, 0x7d, 0x49, 0x5f,
0xa9, 0xf3, 0x2a, 0x19, 0xdc, 0xd3, 0xda, 0x4a, 0xab, 0x3d, 0xba, 0xca, 0x54,
0xc5, 0x5e, 0x59, 0xaf, 0xf4, 0x7b, 0x16, 0xce, 0x8a, 0x4b, 0x54, 0x8f, 0xee,
0x4a, 0xb0, 0x32, 0x5c, 0x5d, 0xab, 0xba, 0xaa, 0xfc, 0xf2, 0xae, 0x73, 0xf0,
0xb9, 0xab, 0xbd, 0x4e, 0xf8, 0xb0, 0x07, 0x0a, 0x2e, 0x81, 0x6a, 0xfa, 0x9b,
0xec, 0xbe, 0xab, 0xea, 0x99, 0x21, 0xa6, 0x5d, 0x26, 0x03, 0x23, 0x87, 0x99,
0x37, 0x33, 0xac, 0x82, 0x00, 0x31, 0xde, 0xe8, 0x3e, 0x73, 0xc0, 0xf8, 0x18,
0x3f, 0xa0, 0xef, 0x80, 0xa2, 0x72, 0xea, 0x1e, 0x41, 0xe6, 0x0f,
};
optimizesize void *__jisx0213_emp_encmap(void) {
return xload(&__jisx0213_emp_encmap_ptr,
__jisx0213_emp_encmap_rodata,
934, 17574); /* 5.31467% profit */
}
| 6,099 | 85 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__cp950ext_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __cp950ext_encmap_ptr;
static const unsigned char __cp950ext_encmap_rodata[] = {
0xed, 0x93, 0x49, 0x0e, 0x82, 0x40, 0x14, 0x44, 0xaf, 0x26, 0x46, 0x71, 0xe7,
0x1d, 0xbb, 0xbd, 0x89, 0x87, 0x00, 0x1c, 0x01, 0x1b, 0xd0, 0x05, 0x38, 0xe1,
0xf4, 0x36, 0x40, 0x87, 0xf4, 0x05, 0x48, 0x9a, 0x95, 0x5d, 0x8b, 0x5a, 0xfc,
0xd4, 0xa2, 0x52, 0x79, 0x7f, 0x2d, 0xe6, 0xa2, 0x75, 0xea, 0x95, 0xae, 0x3c,
0xf9, 0xdf, 0x0b, 0x3c, 0x0d, 0x0b, 0xb5, 0xf8, 0x51, 0x70, 0xe3, 0xc0, 0x85,
0x07, 0x31, 0x25, 0x6f, 0x14, 0x57, 0xbe, 0xe4, 0xe8, 0x14, 0x89, 0xf6, 0x17,
0x27, 0xce, 0xdc, 0x39, 0x52, 0xf1, 0x21, 0xd3, 0x97, 0x9a, 0x14, 0x9b, 0x6d,
0x1a, 0x36, 0xec, 0xd9, 0x12, 0xb0, 0x23, 0x22, 0x64, 0x39, 0x88, 0xd4, 0xa9,
0x6c, 0x46, 0x23, 0x7b, 0x62, 0x81, 0x13, 0xe5, 0xfe, 0xae, 0xf5, 0xe5, 0xc2,
0x2c, 0x39, 0x93, 0x1d,
};
optimizesize void *__cp950ext_encmap(void) {
return xload(&__cp950ext_encmap_ptr,
__cp950ext_encmap_rodata,
121, 1162); /* 10.4131% profit */
}
| 1,076 | 23 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/jisx0213_2_bmp_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) jisx0213_2_bmp_decmap_ptr;
static const unsigned char jisx0213_2_bmp_decmap_rodata[] = {
0x63, 0x60, 0x18, 0x78, 0xc0, 0xc8, 0xa0, 0x54, 0x07, 0xa2, 0xe3, 0x18, 0x14,
0xeb, 0xf6, 0x00, 0xb1, 0x14, 0xa3, 0x62, 0x2d, 0x4c, 0xae, 0x9c, 0x51, 0xb1,
0x0e, 0x59, 0xed, 0x55, 0x20, 0xdf, 0x98, 0x49, 0xb1, 0x6e, 0x22, 0x10, 0xbf,
0x67, 0x42, 0x95, 0x1b, 0x49, 0xc0, 0x97, 0x59, 0xb1, 0x6e, 0x35, 0x10, 0x73,
0xb2, 0x28, 0xd6, 0xa5, 0x03, 0xf1, 0x51, 0x16, 0xa5, 0x3a, 0x25, 0x56, 0xc5,
0xba, 0x06, 0x20, 0xbe, 0x07, 0xc4, 0x36, 0x6c, 0x8a, 0xb5, 0x33, 0xd9, 0x94,
0xeb, 0xbe, 0xb2, 0x29, 0xd6, 0x05, 0xb3, 0x2b, 0xd6, 0x6e, 0x60, 0x57, 0xaa,
0xe5, 0xe1, 0x50, 0xaa, 0xcb, 0xe4, 0x50, 0xac, 0x3b, 0x0e, 0xc4, 0xaa, 0x9c,
0x8a, 0xa5, 0x0c, 0xa3, 0x60, 0xc4, 0x03, 0x00,
};
optimizesize void *jisx0213_2_bmp_decmap(void) {
return xload(&jisx0213_2_bmp_decmap_ptr,
jisx0213_2_bmp_decmap_rodata,
112, 1024); /* 10.9375% profit */
}
| 1,040 | 22 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/cp949_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) cp949_encmap_ptr;
static const unsigned char cp949_encmap_rodata[] = {
0xcd, 0xd0, 0x5b, 0x48, 0x93, 0x61, 0x18, 0x07, 0xf0, 0xe7, 0xfd, 0x0e, 0xfb,
0x76, 0xe8, 0x6b, 0x6d, 0x6a, 0xab, 0x65, 0xa6, 0x35, 0x9d, 0x1d, 0xb6, 0xd4,
0xa5, 0x36, 0x2d, 0xb5, 0xa5, 0x56, 0xeb, 0xe8, 0x3c, 0x55, 0x5a, 0xae, 0xe3,
0x4c, 0xb3, 0xb3, 0xd9, 0x61, 0xb9, 0xd1, 0x45, 0x04, 0x81, 0xd0, 0x45, 0x37,
0xe9, 0x4d, 0x44, 0x77, 0x5d, 0x15, 0x04, 0x42, 0x37, 0x41, 0x20, 0x5d, 0x14,
0x4e, 0x82, 0x84, 0xf0, 0xa6, 0x13, 0x8d, 0xa2, 0xc0, 0xd9, 0x94, 0xef, 0xdb,
0xfb, 0xbe, 0x3d, 0xd7, 0x5d, 0xd5, 0x8d, 0xf4, 0x87, 0xdf, 0xcd, 0x1f, 0x1e,
0x78, 0xf8, 0x13, 0x78, 0xc0, 0xba, 0xc0, 0x16, 0x79, 0x06, 0x63, 0x53, 0xaf,
0xe1, 0xee, 0x2b, 0x03, 0x21, 0x4d, 0x30, 0x8f, 0x69, 0x27, 0x39, 0x8f, 0x7f,
0x12, 0xf1, 0xed, 0x0b, 0x01, 0x1e, 0x45, 0x44, 0xbb, 0xbd, 0x5b, 0x0c, 0x27,
0xa7, 0x45, 0x48, 0xbc, 0x94, 0xe4, 0xbe, 0xbf, 0xb9, 0xf7, 0xc8, 0x90, 0x76,
0x19, 0x4a, 0x87, 0x6e, 0x1a, 0x20, 0x26, 0x28, 0xf1, 0xa9, 0xf9, 0xfa, 0x3b,
0xac, 0x80, 0xde, 0x69, 0x24, 0x5a, 0x9b, 0x49, 0xe0, 0x2d, 0x66, 0xa0, 0x21,
0x0b, 0xf0, 0xd0, 0x02, 0x79, 0xae, 0x51, 0x15, 0xb5, 0x9a, 0x85, 0x12, 0xf3,
0x5b, 0x0d, 0x9a, 0x77, 0x91, 0x98, 0x29, 0xb6, 0x01, 0x2d, 0xb2, 0x5b, 0xb9,
0x23, 0x8b, 0x24, 0x21, 0x5b, 0xd6, 0xd2, 0xd9, 0x84, 0xa6, 0x72, 0x14, 0xf6,
0x6d, 0xb1, 0xa0, 0x7f, 0x76, 0x10, 0xfe, 0x69, 0x89, 0x55, 0x4f, 0x2c, 0x25,
0x7c, 0xdc, 0x09, 0x7c, 0x7c, 0x19, 0x99, 0x1d, 0xcb, 0x55, 0xd9, 0xe8, 0x72,
0xe0, 0xa3, 0x79, 0x06, 0xfe, 0x74, 0x05, 0xb0, 0x27, 0xf9, 0x76, 0x6d, 0xb8,
0x00, 0xf8, 0xf0, 0x4a, 0x41, 0xbf, 0xb7, 0x4a, 0xfa, 0x3e, 0xe8, 0x32, 0xa6,
0x7a, 0x0a, 0x2d, 0x7a, 0x47, 0x91, 0x83, 0xd7, 0xbb, 0x09, 0x0b, 0x14, 0x13,
0x5a, 0xbb, 0x5a, 0xe2, 0xd5, 0x6b, 0x80, 0xfa, 0xd7, 0x9a, 0x99, 0x77, 0x1d,
0x99, 0x2d, 0xf4, 0x90, 0x4c, 0x81, 0x17, 0x58, 0xfe, 0x7a, 0x92, 0xca, 0x2a,
0x11, 0x74, 0xb5, 0x94, 0xe8, 0xc6, 0x32, 0xe0, 0x46, 0x9f, 0x35, 0xf9, 0xd1,
0xa7, 0xb0, 0xf7, 0x1b, 0x40, 0x7f, 0x57, 0x6e, 0x1a, 0xe9, 0xad, 0xa8, 0xc8,
0x94, 0x55, 0x02, 0x2d, 0xd9, 0x28, 0x30, 0x8f, 0x5f, 0x66, 0xee, 0x2a, 0x42,
0x5d, 0xd5, 0x62, 0x26, 0x6f, 0x93, 0x8d, 0xab, 0x9b, 0x05, 0x66, 0xae, 0x01,
0x66, 0xaa, 0x95, 0xa9, 0x50, 0xa7, 0xcc, 0xcd, 0xd4, 0x01, 0x4b, 0x6d, 0x81,
0xfb, 0x43, 0x81, 0x4a, 0xda, 0xba, 0x55, 0x4a, 0x35, 0xd4, 0x9b, 0x59, 0x55,
0x83, 0x48, 0xcb, 0x1b, 0x81, 0xfa, 0xb6, 0x09, 0xbf, 0xdc, 0xdb, 0xd5, 0x8c,
0x63, 0x87, 0x94, 0x36, 0x07, 0xa5, 0xd8, 0xad, 0xe0, 0xc0, 0x87, 0xe9, 0x60,
0xae, 0x3e, 0xb1, 0x13, 0xf8, 0xc4, 0x2e, 0x60, 0x89, 0xdd, 0x22, 0x7f, 0xb3,
0x87, 0xfc, 0x78, 0xbe, 0xd7, 0xf9, 0xf5, 0xce, 0x3e, 0x35, 0xdd, 0xdf, 0x64,
0xd2, 0x22, 0x21, 0xe7, 0x4c, 0xa0, 0x59, 0x19, 0xf9, 0xd7, 0xdd, 0x27, 0x9b,
0x81, 0x4f, 0xb6, 0xa0, 0x56, 0xd4, 0x86, 0xda, 0xd1, 0x7e, 0x74, 0x00, 0x1d,
0x44, 0x1d, 0xa8, 0x13, 0x1d, 0x42, 0x87, 0x51, 0x17, 0x0a, 0xa3, 0x23, 0xe8,
0x28, 0x3a, 0x86, 0x8e, 0xa3, 0x13, 0xe8, 0x24, 0x8a, 0xa0, 0x6e, 0x74, 0x0a,
0xf5, 0xa0, 0x5e, 0x74, 0x1a, 0xf5, 0xa1, 0x33, 0xe8, 0x2c, 0x3a, 0x87, 0xce,
0xa3, 0x0b, 0xe8, 0x22, 0xba, 0x84, 0xfa, 0xd1, 0x65, 0x34, 0x80, 0xae, 0xa0,
0xab, 0xe8, 0x1a, 0xba, 0x8e, 0xa2, 0xe8, 0x06, 0x1a, 0x84, 0x87, 0xf0, 0x1f,
0x24, 0x1a, 0x03, 0x1e, 0x8d, 0x83, 0xe5, 0xcf, 0xfe, 0x76, 0x9c, 0x7c, 0xf9,
0x0d,
};
optimizesize void *cp949_encmap(void) {
return xload(&cp949_encmap_ptr,
cp949_encmap_rodata,
534, 1024); /* 52.1484% profit */
}
| 3,593 | 55 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/cp950ext_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) cp950ext_decmap_ptr;
static const unsigned char cp950ext_decmap_rodata[] = {
0x63, 0x60, 0x18, 0x05, 0xa3, 0x60, 0x60, 0x01, 0x23, 0x83, 0xeb, 0xe7, 0x0d,
0x0c, 0x8e, 0xee, 0xdb, 0x19, 0x1e, 0x3e, 0x1c, 0x0d, 0x0d, 0xea, 0x83, 0x1d,
0x0c, 0xd7, 0xfe, 0xe1, 0x92, 0x03, 0x00,
};
optimizesize void *cp950ext_decmap(void) {
return xload(&cp950ext_decmap_ptr,
cp950ext_decmap_rodata,
33, 1024); /* 3.22266% profit */
}
| 523 | 16 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/jisxcommon_encmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) jisxcommon_encmap_ptr;
static const unsigned char jisxcommon_encmap_rodata[] = {
0xed, 0xcb, 0x3d, 0x4f, 0x93, 0x61, 0x18, 0xc5, 0xf1, 0x73, 0xdd, 0xcf, 0x53,
0x6a, 0xd1, 0x0a, 0xad, 0xa8, 0x55, 0xaa, 0xf8, 0x86, 0x50, 0xb0, 0x82, 0x56,
0x4b, 0x2b, 0x2a, 0xd0, 0x82, 0x56, 0xc0, 0x4a, 0xdf, 0x0c, 0xa5, 0x4d, 0xfc,
0x08, 0x8e, 0x1a, 0x12, 0x27, 0x1a, 0xd3, 0xd9, 0xd5, 0x44, 0xa7, 0x26, 0xce,
0xc6, 0x60, 0xf4, 0x0b, 0xb0, 0x39, 0xb9, 0x3a, 0xea, 0x6a, 0x88, 0x1a, 0xb4,
0xed, 0x7d, 0x1d, 0x1f, 0xbe, 0x81, 0x13, 0x2c, 0xfe, 0x93, 0xdf, 0x72, 0x92,
0x23, 0xa8, 0xb3, 0x05, 0xfc, 0x7a, 0x29, 0x5b, 0x5f, 0xde, 0x4a, 0xe3, 0x93,
0x15, 0x79, 0x84, 0x3d, 0xac, 0x6e, 0xfa, 0xa7, 0x9b, 0xc6, 0xf9, 0xbc, 0xe6,
0xa0, 0x05, 0x37, 0x1c, 0xde, 0xdd, 0xc4, 0xc5, 0xf7, 0x6d, 0xd7, 0xf7, 0xf8,
0x9f, 0xfe, 0x3e, 0x28, 0xf6, 0xa1, 0x5a, 0x0f, 0x58, 0xf3, 0x7b, 0x0e, 0x40,
0xd7, 0x02, 0xd0, 0x6a, 0x2f, 0x58, 0x3d, 0x88, 0x76, 0xf9, 0x90, 0xb0, 0x14,
0x04, 0x4b, 0x87, 0x7d, 0xcc, 0xf7, 0x81, 0xf9, 0x7e, 0xd8, 0xe5, 0x90, 0xe1,
0x62, 0x18, 0x36, 0x77, 0x04, 0xcc, 0x0d, 0x88, 0x5d, 0x38, 0x2a, 0x9a, 0x3d,
0x06, 0x66, 0x8f, 0x0b, 0x33, 0x11, 0xbf, 0x4d, 0x9f, 0x00, 0xd3, 0x27, 0x3d,
0x83, 0xd2, 0x4e, 0x44, 0x7b, 0x18, 0x3f, 0x05, 0xc6, 0x4f, 0x7b, 0x86, 0x3c,
0x67, 0x8c, 0x8d, 0x9d, 0x05, 0x63, 0xe7, 0x60, 0x47, 0xce, 0x1b, 0x0e, 0x5f,
0x30, 0x3f, 0x23, 0xc3, 0x6e, 0x37, 0x74, 0x11, 0x0c, 0x8d, 0x88, 0xf6, 0x8d,
0xc2, 0x06, 0x63, 0x0e, 0x7b, 0xc7, 0xa0, 0x81, 0x71, 0x43, 0xff, 0x25, 0xd0,
0x1f, 0x77, 0xe8, 0x5e, 0x86, 0x3a, 0x13, 0xe8, 0x62, 0xd2, 0x50, 0x27, 0xd1,
0xed, 0x5c, 0x01, 0x3b, 0x57, 0x8d, 0xfe, 0x4e, 0x40, 0x77, 0xae, 0xa1, 0xf3,
0xe3, 0x3a, 0x5e, 0xbd, 0x48, 0x26, 0x59, 0x9f, 0x82, 0xd6, 0x52, 0x86, 0xd5,
0x34, 0x74, 0xf5, 0x06, 0xec, 0xc3, 0x69, 0x61, 0xe5, 0x26, 0x58, 0xb9, 0x05,
0x2d, 0xdf, 0x06, 0xcb, 0x33, 0xa2, 0xc5, 0x59, 0x61, 0x61, 0x0e, 0x2c, 0x64,
0xf0, 0x7a, 0x3b, 0x33, 0xc5, 0x8f, 0x59, 0xe1, 0x87, 0x79, 0xd1, 0xf7, 0x0b,
0xd0, 0xcd, 0x3b, 0xe0, 0xe6, 0x5d, 0x4f, 0xce, 0x73, 0x0f, 0xf6, 0xdd, 0xa2,
0x34, 0x52, 0x4b, 0x4f, 0xbe, 0xbd, 0x59, 0x8a, 0x76, 0x9a, 0xcb, 0x60, 0xf3,
0xbe, 0xe8, 0xf3, 0xbc, 0x61, 0xe3, 0x81, 0x70, 0x63, 0x05, 0xdc, 0x28, 0xe0,
0xcf, 0xb3, 0xa2, 0xd1, 0xf5, 0x92, 0xe1, 0xd3, 0xb2, 0x69, 0xe1, 0x7f, 0xfb,
0x56, 0xb4, 0x22, 0x5f, 0xff, 0x02,
};
optimizesize void *jisxcommon_encmap(void) {
return xload(&jisxcommon_encmap_ptr,
jisxcommon_encmap_rodata,
370, 1024); /* 36.1328% profit */
}
| 2,608 | 42 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__big5_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __big5_decmap_ptr;
static const unsigned char __big5_decmap_rodata[14386] = {
0xad, 0xbb, 0x7b, 0x74, 0x55, 0xe7, 0x75, 0x2f, 0x7a, 0xe7, 0xfc, 0x5e, 0xeb,
0xbd, 0xd6, 0x5e, 0xfb, 0xfd, 0xde, 0xda, 0xda, 0x7a, 0xbf, 0x85, 0x24, 0x84,
0x10, 0x02, 0x83, 0xc0, 0x18, 0x8b, 0x37, 0x06, 0x4c, 0x09, 0xc6, 0x18, 0x13,
0xc7, 0xb1, 0x31, 0x71, 0x1d, 0x5f, 0xd7, 0x76, 0x5c, 0x45, 0x21, 0xaa, 0xa2,
0x70, 0x88, 0xa2, 0x28, 0xaa, 0x42, 0x28, 0x96, 0x15, 0x55, 0x21, 0x54, 0xc1,
0xaa, 0xaa, 0x10, 0x99, 0x10, 0x4a, 0x08, 0x21, 0x54, 0xd1, 0x21, 0x84, 0x10,
0x4a, 0x29, 0x21, 0x1c, 0x85, 0x52, 0x4a, 0x29, 0x21, 0x84, 0x10, 0x85, 0x10,
0x72, 0x3e, 0xf5, 0xde, 0x73, 0x7b, 0xc7, 0x19, 0x23, 0x43, 0xfc, 0x71, 0xd6,
0x18, 0x6b, 0x68, 0x69, 0x4b, 0x7b, 0xad, 0x35, 0xbf, 0x39, 0xe7, 0xef, 0xb1,
0xbe, 0x6f, 0x35, 0x1f, 0x83, 0x9e, 0x23, 0xfc, 0x8b, 0x47, 0x38, 0xca, 0x1f,
0xff, 0xf8, 0x3b, 0x7e, 0xe7, 0x77, 0x1c, 0xb4, 0xd9, 0xef, 0x91, 0x2f, 0x4c,
0x72, 0x38, 0x3f, 0xc9, 0xf7, 0xd3, 0xaf, 0xd0, 0x6f, 0xdc, 0x13, 0x87, 0xef,
0x09, 0x44, 0x6c, 0xa7, 0x9f, 0xff, 0x3d, 0x3f, 0x32, 0xc9, 0x3f, 0x98, 0xe4,
0x47, 0x27, 0xf9, 0xef, 0x27, 0x78, 0xf3, 0xcf, 0x79, 0xcd, 0x1d, 0xc4, 0xaf,
0x12, 0x1c, 0xa3, 0xf4, 0x07, 0x14, 0xbf, 0x3f, 0xca, 0xf1, 0x94, 0xdc, 0x7f,
0x2c, 0xf7, 0x73, 0x72, 0xff, 0xb9, 0xdc, 0xaf, 0xca, 0xfd, 0xdf, 0xe5, 0x7e,
0x53, 0xee, 0xff, 0x2a, 0xf7, 0xeb, 0xff, 0xbf, 0x9f, 0x85, 0x78, 0x8a, 0xff,
0x5f, 0xd3, 0x6d, 0xdf, 0xe3, 0xf2, 0xd2, 0x9f, 0xfd, 0x2d, 0x47, 0x8e, 0xcd,
0xf3, 0xf0, 0x47, 0x73, 0x59, 0xdf, 0xef, 0x38, 0x57, 0xfe, 0xea, 0x77, 0xfc,
0xab, 0xef, 0x8c, 0x7e, 0x1b, 0x7e, 0x91, 0xaf, 0xcc, 0x84, 0xda, 0x1d, 0xf0,
0x16, 0x3c, 0x01, 0x75, 0x70, 0x7a, 0xc6, 0xb7, 0x16, 0xfd, 0x37, 0x32, 0xf6,
0x90, 0x7f, 0x1f, 0x7f, 0xfe, 0x4b, 0x31, 0xf9, 0x1f, 0x42, 0x7e, 0x89, 0x61,
0x2e, 0xe2, 0x39, 0xa4, 0xff, 0x3e, 0x29, 0xe6, 0x7d, 0x16, 0xce, 0x7e, 0x1a,
0x76, 0xde, 0xe5, 0x14, 0xfe, 0xe3, 0x0e, 0x47, 0xf3, 0x53, 0xf0, 0x42, 0xa2,
0xe5, 0xf6, 0xd4, 0xf9, 0xf1, 0xc7, 0xb7, 0x79, 0x0e, 0xde, 0x83, 0xcf, 0x20,
0x1c, 0xc3, 0x81, 0x46, 0xf8, 0xc1, 0x22, 0x6e, 0x41, 0x8f, 0x43, 0xe1, 0x95,
0x5f, 0x78, 0x28, 0xa3, 0x0a, 0x52, 0xd8, 0x83, 0xe4, 0xc2, 0xaf, 0xf8, 0x86,
0xa7, 0x37, 0xbc, 0xf2, 0xed, 0xdf, 0x8a, 0x8b, 0xdf, 0x86, 0x9f, 0x7d, 0x1b,
0xf0, 0xc4, 0x6f, 0x45, 0x8d, 0x1c, 0x0d, 0xe3, 0xd8, 0xaf, 0xe5, 0x49, 0xfe,
0xe6, 0x00, 0xff, 0x18, 0xe2, 0xe6, 0xa7, 0x73, 0xf0, 0xc5, 0xaf, 0x8e, 0xc3,
0xd9, 0xe3, 0x48, 0x39, 0x28, 0xb4, 0xcd, 0xdd, 0xf9, 0xf6, 0x58, 0xf2, 0x4b,
0x3f, 0xc5, 0xff, 0x77, 0xb3, 0xe0, 0x3f, 0xb7, 0x2f, 0x81, 0x2d, 0xb7, 0xdb,
0xf0, 0x55, 0xa4, 0x03, 0xf8, 0x79, 0x54, 0x14, 0xe5, 0x00, 0xf4, 0xdd, 0x98,
0x7e, 0x34, 0xde, 0xbd, 0x21, 0x6f, 0x7e, 0x4e, 0x2c, 0xe4, 0x69, 0x41, 0x79,
0x4f, 0xff, 0x02, 0x88, 0x87, 0xaf, 0xf1, 0xff, 0x75, 0x6e, 0xfc, 0xe5, 0xbd,
0xff, 0x3a, 0xbe, 0x5d, 0xf7, 0xbf, 0x8e, 0x86, 0x76, 0x01, 0xc7, 0xd1, 0xf7,
0x19, 0xfe, 0xb1, 0xcd, 0xfa, 0xa3, 0x7f, 0xf9, 0xfc, 0x2f, 0xc4, 0xff, 0xfe,
0x11, 0xfd, 0x7f, 0x7e, 0x38, 0x7f, 0xe4, 0xf3, 0xc9, 0x11, 0xf8, 0xaf, 0xcf,
0x2e, 0x7f, 0x6b, 0xfa, 0x88, 0xfe, 0xf9, 0x5b, 0xfc, 0x8f, 0x5e, 0xfe, 0xdd,
0x0f, 0x20, 0x89, 0x4c, 0xb9, 0x31, 0x88, 0xc3, 0xf0, 0x3e, 0xd0, 0x66, 0xa8,
0x5a, 0x65, 0x6c, 0x6c, 0xd7, 0x9a, 0x8c, 0x1b, 0x30, 0x0f, 0x47, 0xf0, 0x2e,
0xac, 0xaf, 0xb9, 0x00, 0xbf, 0x0f, 0xc8, 0x0c, 0xcd, 0x8f, 0x9c, 0xb5, 0xbe,
0x69, 0xf1, 0x52, 0xd8, 0x9c, 0x7b, 0x54, 0x6b, 0x25, 0xb7, 0x48, 0x27, 0xec,
0xc2, 0xaa, 0x49, 0xa3, 0x47, 0xac, 0xc9, 0xf4, 0xc0, 0x61, 0x81, 0x74, 0x0c,
0x4b, 0x73, 0x8b, 0x5f, 0xbd, 0xc0, 0x9c, 0x10, 0x62, 0xe0, 0x3a, 0xf4, 0x60,
0xc4, 0xb9, 0x6b, 0x4c, 0xdc, 0xa3, 0xd3, 0xde, 0xe0, 0x3f, 0x7d, 0x9f, 0x01,
0x9b, 0xc7, 0xdd, 0xcc, 0xa5, 0x99, 0xff, 0xa3, 0xc6, 0x55, 0x18, 0x8d, 0x35,
0x00, 0xe7, 0x68, 0x30, 0x34, 0x1f, 0xaa, 0xa4, 0xc9, 0x40, 0xb2, 0xf6, 0x28,
0xa4, 0x10, 0xaf, 0x11, 0x8e, 0xa5, 0x8b, 0x12, 0x40, 0x2a, 0x9b, 0x76, 0x03,
0xf0, 0xa3, 0xbe, 0x37, 0x29, 0xf0, 0xd3, 0xca, 0x7d, 0xcc, 0x2d, 0x7e, 0xb1,
0x9d, 0xef, 0xc6, 0x36, 0x59, 0xef, 0x97, 0xb0, 0x5d, 0xdd, 0x58, 0xc8, 0x8f,
0xeb, 0x43, 0x90, 0x8a, 0x14, 0xae, 0xef, 0xa6, 0xe5, 0xf3, 0x6e, 0xdb, 0x3b,
0xa1, 0xb4, 0x1f, 0x5c, 0xeb, 0x85, 0x25, 0xb7, 0x9c, 0x87, 0x3c, 0xa4, 0x85,
0x32, 0xb4, 0x0f, 0x8e, 0x92, 0x9f, 0x7f, 0x11, 0x18, 0x80, 0xb2, 0x28, 0x43,
0xe1, 0x20, 0x86, 0xa7, 0xd2, 0x10, 0x42, 0xbf, 0x76, 0x5a, 0x85, 0x76, 0xc0,
0xc6, 0x3d, 0x80, 0x24, 0x33, 0x88, 0x30, 0x0e, 0x98, 0x36, 0x7e, 0xe7, 0x9c,
0xf7, 0x40, 0x39, 0x24, 0x60, 0x0f, 0xbc, 0xe0, 0x4f, 0x98, 0x54, 0x85, 0x7c,
0xc1, 0xbc, 0xaa, 0xe2, 0x00, 0xf8, 0x9d, 0xd8, 0x31, 0x1d, 0x26, 0x95, 0x33,
0x5f, 0x66, 0xd3, 0x97, 0xd6, 0x97, 0x19, 0x6f, 0x05, 0x7a, 0x54, 0x6c, 0xbc,
0x83, 0x17, 0x38, 0x40, 0x2d, 0x5e, 0x01, 0xb7, 0x1d, 0x4b, 0x61, 0xea, 0xa6,
0x3b, 0xe5, 0x05, 0x61, 0xbf, 0xd9, 0x02, 0x1d, 0x8c, 0x10, 0xa4, 0x37, 0x9d,
0x73, 0xd0, 0x06, 0xb0, 0xc2, 0x05, 0x32, 0x11, 0x3e, 0x40, 0xb4, 0x01, 0xe6,
0xdb, 0x6a, 0xb9, 0xff, 0x59, 0x48, 0x43, 0x70, 0x95, 0x6c, 0x49, 0x6f, 0xba,
0x48, 0xac, 0xf4, 0x6e, 0xd6, 0x86, 0x37, 0xf1, 0x20, 0xfc, 0xd3, 0x30, 0xe0,
0x36, 0x2c, 0xde, 0x1c, 0xa0, 0x30, 0x02, 0xbe, 0x54, 0x3c, 0x60, 0x73, 0x24,
0xb3, 0x14, 0xcd, 0xcf, 0x7d, 0x8a, 0xef, 0x81, 0x42, 0x80, 0xce, 0x73, 0x6b,
0x17, 0x9d, 0x06, 0x1d, 0x85, 0xb3, 0x07, 0xc7, 0xa0, 0x12, 0x7a, 0x01, 0x87,
0xe4, 0x08, 0x13, 0x23, 0xee, 0x33, 0x23, 0x42, 0x55, 0x03, 0x76, 0x68, 0xaf,
0x4e, 0x60, 0x10, 0x98, 0xad, 0x01, 0xd7, 0xaf, 0x08, 0xac, 0xc3, 0x1e, 0x08,
0x06, 0x74, 0xe1, 0xc2, 0xa0, 0xc0, 0x4d, 0xb2, 0x48, 0x26, 0xa0, 0xf6, 0x24,
0x8c, 0xb1, 0x15, 0x57, 0x80, 0x74, 0xb5, 0x4e, 0x1f, 0xed, 0x4f, 0x3f, 0xc5,
0x42, 0x0f, 0x90, 0xdd, 0x56, 0x08, 0xf2, 0x01, 0xb0, 0xd9, 0x11, 0xfd, 0x1a,
0x82, 0x22, 0x31, 0x0e, 0x8b, 0x5f, 0xf0, 0x30, 0xe5, 0x82, 0xdd, 0x0a, 0xa5,
0x87, 0x70, 0x37, 0xe8, 0xd4, 0xc0, 0xa4, 0x16, 0xd2, 0xa3, 0x78, 0xc2, 0xb9,
0x2c, 0xc8, 0x71, 0xe7, 0x9e, 0xe7, 0x2e, 0x6b, 0xc7, 0x07, 0xca, 0x7e, 0xd8,
0xd6, 0x06, 0xd4, 0x35, 0xe6, 0xf7, 0x80, 0x8f, 0xe2, 0x41, 0x66, 0xb9, 0x6e,
0x2a, 0xa1, 0xec, 0x03, 0x25, 0x74, 0xd1, 0x3e, 0x20, 0x42, 0xa5, 0xa3, 0xf4,
0x44, 0xe5, 0x4f, 0xdf, 0xc5, 0x9b, 0x30, 0x86, 0xd4, 0x4e, 0x59, 0xab, 0x97,
0xe9, 0x4f, 0xcc, 0xc3, 0x3c, 0x46, 0x02, 0xe9, 0x32, 0x5f, 0x9d, 0xa9, 0x3c,
0xdb, 0x50, 0xb6, 0x48, 0x29, 0xc8, 0x5c, 0x15, 0x40, 0x57, 0xb4, 0x00, 0x5e,
0x02, 0xd0, 0x90, 0xb4, 0xa2, 0x1c, 0xdb, 0x5b, 0x32, 0x7a, 0x7a, 0x06, 0x53,
0xf1, 0x79, 0x65, 0x2b, 0x96, 0x36, 0xb0, 0x64, 0xa1, 0xbe, 0x34, 0x36, 0x3f,
0x8b, 0x32, 0xaf, 0x85, 0x45, 0xb5, 0x4a, 0x5c, 0x0f, 0x46, 0x1e, 0x68, 0x46,
0xd0, 0x3a, 0x0a, 0x56, 0x56, 0x64, 0xa2, 0x6f, 0xfa, 0x48, 0xff, 0xa3, 0x8f,
0x59, 0xc9, 0x0c, 0xe4, 0x5d, 0xe7, 0xfb, 0xe0, 0x28, 0xf8, 0x8b, 0xbd, 0x9a,
0x97, 0x79, 0x4a, 0xb3, 0x3c, 0x35, 0xb7, 0x39, 0x10, 0xdc, 0x02, 0xca, 0x61,
0xcc, 0x97, 0xc9, 0xed, 0x07, 0xe4, 0xf6, 0x51, 0x36, 0xbf, 0x15, 0x6d, 0x7e,
0x11, 0x22, 0x35, 0xed, 0x40, 0x0a, 0xe9, 0x51, 0x39, 0xc6, 0xde, 0xc5, 0x7a,
0x24, 0x7a, 0x46, 0x81, 0x6b, 0x90, 0x0b, 0x45, 0xde, 0xdc, 0x99, 0x75, 0x51,
0xaa, 0xea, 0x0d, 0x0b, 0x57, 0xad, 0x5e, 0x46, 0x88, 0xff, 0x9a, 0x46, 0xd9,
0x1d, 0x6c, 0xa5, 0xe7, 0x21, 0x4b, 0xe6, 0x3e, 0xa0, 0x3b, 0x05, 0xac, 0x2a,
0xac, 0xec, 0x95, 0xe5, 0x71, 0x0d, 0x6a, 0x5f, 0x2f, 0xb3, 0x50, 0x14, 0x3f,
0x9b, 0x2a, 0x9e, 0x5b, 0xfb, 0xf8, 0x46, 0x51, 0x60, 0x64, 0x85, 0xbc, 0x99,
0x64, 0xa9, 0xa5, 0x14, 0x5d, 0xb7, 0x0d, 0x54, 0xcf, 0x09, 0x80, 0x53, 0x40,
0xf6, 0x93, 0x41, 0x0e, 0x21, 0xec, 0x62, 0x17, 0xe1, 0x3a, 0x39, 0x22, 0x3f,
0xbb, 0x85, 0xed, 0xda, 0x88, 0xda, 0xc2, 0x98, 0x4f, 0xe5, 0x50, 0x7e, 0x9f,
0x2f, 0xba, 0xf0, 0x6b, 0x32, 0x6d, 0x90, 0xff, 0xf2, 0x6b, 0x42, 0x1f, 0x44,
0x77, 0xc3, 0xc6, 0x5b, 0x4a, 0x22, 0xd1, 0x01, 0xbb, 0x49, 0xa8, 0x15, 0x6e,
0x93, 0x86, 0x3e, 0x52, 0x98, 0x51, 0x00, 0xbe, 0xf7, 0x7d, 0xb8, 0x32, 0x06,
0x69, 0x47, 0xb0, 0x71, 0xbc, 0x0f, 0xc6, 0xb8, 0x47, 0x70, 0x93, 0x7e, 0xb6,
0x17, 0x37, 0xd7, 0x95, 0xa7, 0x78, 0x04, 0x5b, 0xc9, 0xc6, 0xe4, 0x8c, 0x50,
0xce, 0xa6, 0xa4, 0xca, 0x72, 0xb4, 0xdc, 0x39, 0x99, 0x9a, 0xb2, 0x34, 0x2d,
0x19, 0x11, 0x84, 0xe7, 0xc7, 0x80, 0xb6, 0x43, 0x33, 0xbc, 0xcd, 0x80, 0x7b,
0x89, 0x13, 0xb8, 0x0f, 0xec, 0xa0, 0x84, 0x5d, 0x52, 0x98, 0x96, 0xb8, 0x0b,
0x84, 0x8f, 0x22, 0x9d, 0x3f, 0xbb, 0xae, 0x40, 0x15, 0x91, 0x58, 0xd0, 0x9b,
0x3f, 0x47, 0x2b, 0x8e, 0xbd, 0x62, 0x2c, 0x8a, 0xa6, 0x2f, 0xa8, 0x9d, 0x18,
0x0c, 0x83, 0xad, 0x91, 0xf2, 0x63, 0x7c, 0x03, 0x41, 0x91, 0x3a, 0x07, 0xac,
0xb2, 0xda, 0xbf, 0xc8, 0xef, 0x63, 0xc4, 0xf1, 0x54, 0x2b, 0x0d, 0xe1, 0x11,
0xae, 0xc1, 0x0b, 0x9c, 0x48, 0x34, 0x79, 0x08, 0x1b, 0xd9, 0x9d, 0xdd, 0xd3,
0xa7, 0xf1, 0x17, 0xbb, 0xd9, 0x04, 0x14, 0x95, 0xc6, 0xa9, 0x41, 0xc7, 0x18,
0x15, 0x60, 0x78, 0x4f, 0x43, 0x23, 0xd3, 0x4c, 0x3c, 0x06, 0x9b, 0x91, 0x1e,
0x94, 0xfd, 0xc9, 0x8e, 0x03, 0xaf, 0xb3, 0x7d, 0x29, 0xad, 0xc6, 0x98, 0x93,
0x5f, 0x10, 0x32, 0x28, 0x4d, 0xde, 0x13, 0xb0, 0x06, 0xe8, 0x3b, 0x5d, 0xc0,
0x6d, 0x95, 0x7b, 0x2a, 0xdd, 0x67, 0x56, 0xa0, 0x87, 0xcd, 0x2d, 0x84, 0x7c,
0x37, 0xdb, 0x28, 0x5b, 0xb2, 0x72, 0x19, 0xc1, 0xac, 0x19, 0x8d, 0x57, 0xd4,
0xb3, 0x50, 0xf8, 0x76, 0x15, 0x98, 0xba, 0x08, 0x45, 0x13, 0x86, 0x9f, 0xed,
0xa2, 0xe4, 0x04, 0xd4, 0xfb, 0x1e, 0x5f, 0xbb, 0x52, 0x49, 0x15, 0xeb, 0xcb,
0x31, 0xe1, 0xf3, 0x67, 0xaa, 0x97, 0x98, 0x25, 0xd9, 0xce, 0x84, 0xd5, 0x0a,
0x58, 0xbe, 0x1f, 0x9d, 0x0e, 0xa2, 0x05, 0x3e, 0x05, 0x35, 0x95, 0xcf, 0xf9,
0x90, 0x34, 0xbd, 0xbc, 0x86, 0x54, 0x87, 0xfc, 0x4e, 0xce, 0xaa, 0xec, 0xf5,
0xcf, 0x89, 0x26, 0x3d, 0x6b, 0x76, 0x2b, 0xe4, 0xe8, 0xbe, 0x23, 0xe3, 0xd3,
0x63, 0xeb, 0x8f, 0xbe, 0x4d, 0x4d, 0xc5, 0x4e, 0x0c, 0x70, 0x0c, 0xa4, 0x1a,
0x64, 0x10, 0xb1, 0x00, 0x31, 0x87, 0x09, 0x78, 0x42, 0xfa, 0x10, 0x3f, 0x06,
0x02, 0xcf, 0x91, 0xb7, 0x37, 0xd3, 0x09, 0x52, 0xde, 0xc2, 0x28, 0x76, 0x20,
0x5c, 0x45, 0x68, 0xc1, 0x36, 0x65, 0x50, 0xdd, 0x01, 0x77, 0xe1, 0x06, 0x16,
0xb0, 0x44, 0xd2, 0x47, 0x02, 0x5e, 0xed, 0x26, 0xad, 0x4c, 0x8c, 0x63, 0x91,
0xc8, 0x4f, 0xcd, 0xae, 0xb2, 0x55, 0xd3, 0xe7, 0x16, 0x44, 0x62, 0xe6, 0x41,
0x6b, 0xd1, 0x57, 0x7f, 0x04, 0xdd, 0xff, 0x04, 0x27, 0xc3, 0xad, 0xd4, 0x60,
0xa7, 0x08, 0x37, 0xb5, 0x3e, 0xea, 0x1b, 0xb7, 0xdc, 0x51, 0x5c, 0x0c, 0xc2,
0x25, 0xb7, 0x60, 0xd3, 0x39, 0x08, 0xfd, 0xbe, 0x0f, 0x63, 0x78, 0x8d, 0xae,
0xd3, 0x53, 0xf3, 0xe3, 0x24, 0x36, 0x23, 0xdc, 0x68, 0x15, 0x44, 0x56, 0x36,
0x06, 0x49, 0x79, 0x30, 0xb5, 0xf4, 0x18, 0x7f, 0x1d, 0x12, 0x97, 0xd0, 0x6f,
0x49, 0x38, 0x14, 0xcd, 0x48, 0x75, 0xd2, 0x03, 0x5d, 0xb0, 0xb8, 0xa1, 0x05,
0xfa, 0x48, 0x7e, 0x59, 0x93, 0x9a, 0x95, 0x1d, 0xc9, 0x57, 0xd5, 0x9c, 0xd2,
0xfb, 0x83, 0xd3, 0xe7, 0xef, 0x57, 0x83, 0x4c, 0xa9, 0x10, 0x86, 0x2f, 0x9b,
0x94, 0x37, 0xab, 0xad, 0xe8, 0x16, 0x72, 0x58, 0x3f, 0xb7, 0x7a, 0xa7, 0x10,
0x12, 0xfe, 0x7a, 0x50, 0x2c, 0x9b, 0xa9, 0xd5, 0xcc, 0xd6, 0x92, 0xa1, 0x1a,
0xfd, 0x12, 0x7b, 0x8d, 0x13, 0x59, 0x5b, 0x30, 0x05, 0xf2, 0x64, 0x2f, 0x9a,
0x63, 0xb4, 0xc9, 0xd1, 0x8f, 0xc0, 0x22, 0x63, 0x3f, 0xc4, 0x96, 0xec, 0x58,
0xc4, 0x34, 0x14, 0x1a, 0xeb, 0xc4, 0x00, 0xd7, 0x4a, 0xaa, 0x96, 0x2c, 0xb2,
0xf5, 0x99, 0x6c, 0x15, 0x80, 0x7e, 0x58, 0x1c, 0xc2, 0xd7, 0xc2, 0xe1, 0x78,
0x7e, 0x4e, 0xc2, 0x57, 0x64, 0xd8, 0x2c, 0xe3, 0xad, 0x8b, 0xdf, 0x57, 0x8c,
0x71, 0xc8, 0x2c, 0x69, 0x05, 0x27, 0x6c, 0x39, 0x49, 0xd7, 0x0d, 0x0f, 0x90,
0x0e, 0xba, 0xae, 0x7e, 0x96, 0xa8, 0xfd, 0xa8, 0xb9, 0x0b, 0x82, 0xc6, 0x53,
0x91, 0x59, 0x4d, 0x81, 0xa7, 0x4b, 0x13, 0x85, 0x9f, 0x86, 0x55, 0xae, 0xea,
0x1f, 0xb2, 0x2a, 0xf9, 0xa6, 0x3a, 0xad, 0x03, 0xce, 0xe1, 0x4e, 0x58, 0x66,
0x97, 0xce, 0xac, 0x58, 0x92, 0x63, 0x9e, 0xfe, 0xc1, 0xf4, 0x69, 0xfc, 0xf4,
0x0f, 0x28, 0x45, 0xbb, 0xfa, 0xc9, 0x36, 0xc8, 0x4e, 0xc7, 0x35, 0x6b, 0x69,
0x5d, 0xb3, 0x95, 0x30, 0x4d, 0x2e, 0x53, 0xe3, 0xed, 0xe1, 0x3b, 0x81, 0x69,
0x37, 0xc0, 0x83, 0x83, 0x24, 0x37, 0xee, 0xa9, 0x09, 0x87, 0x4f, 0xb3, 0xdc,
0x46, 0x46, 0xd9, 0x31, 0x30, 0xa5, 0x36, 0x3b, 0x40, 0x62, 0x88, 0xcd, 0x40,
0x18, 0x7d, 0xc3, 0x86, 0x34, 0x0d, 0x93, 0xc0, 0x01, 0xd2, 0x94, 0xb1, 0xf1,
0x8e, 0x14, 0x4f, 0x70, 0x15, 0xb0, 0x14, 0xcd, 0xeb, 0x48, 0x1f, 0x00, 0x69,
0xe6, 0xed, 0xc8, 0x55, 0x57, 0xfe, 0xe3, 0x55, 0x65, 0x10, 0xb6, 0xb4, 0x43,
0x88, 0x29, 0x4b, 0x8e, 0x61, 0xc2, 0x5f, 0x82, 0x4e, 0xa1, 0x1e, 0x4e, 0x19,
0xe6, 0x41, 0xba, 0xb1, 0x9d, 0xd4, 0xd2, 0x05, 0x76, 0xa0, 0x7e, 0x4e, 0x9d,
0xf5, 0xb2, 0x56, 0x95, 0x7a, 0xc2, 0x66, 0x11, 0x7f, 0x28, 0x55, 0xda, 0x65,
0xae, 0xa2, 0x30, 0x20, 0xea, 0x07, 0xe9, 0x00, 0xbc, 0xa0, 0xe3, 0x21, 0x8d,
0xee, 0x27, 0xd0, 0x02, 0xc3, 0x14, 0x4e, 0x51, 0xaf, 0x70, 0xd4, 0xe1, 0x63,
0xd3, 0x03, 0xcc, 0x7b, 0xc7, 0x08, 0x31, 0x95, 0x13, 0x44, 0x09, 0x53, 0x59,
0x88, 0xad, 0x78, 0xc3, 0xda, 0x4b, 0x54, 0xc4, 0x03, 0xd4, 0x3a, 0x01, 0x8d,
0x46, 0xec, 0x34, 0x6e, 0x53, 0x6e, 0x21, 0xff, 0xe4, 0xd7, 0xf1, 0x10, 0x0c,
0x33, 0x2c, 0xfe, 0xf0, 0x76, 0x78, 0x7a, 0x4b, 0x4e, 0xf2, 0xa5, 0x59, 0xaa,
0x0d, 0x25, 0x46, 0x7e, 0xfe, 0xcb, 0x9b, 0x8b, 0x62, 0xf0, 0x84, 0xfa, 0x0e,
0x5b, 0xb7, 0x61, 0xc1, 0x35, 0xb6, 0x02, 0xd9, 0x5a, 0xd0, 0xb5, 0x6e, 0x34,
0x6c, 0x8b, 0xee, 0x21, 0x07, 0x60, 0x1e, 0xd9, 0x09, 0x9d, 0x74, 0x45, 0xfc,
0xa5, 0x8f, 0x97, 0x44, 0xf2, 0x83, 0x55, 0x4f, 0x29, 0xc1, 0x15, 0xd5, 0x42,
0xb4, 0xc0, 0x5c, 0x6f, 0xe6, 0xba, 0xc0, 0x07, 0x98, 0xf1, 0xd8, 0xbb, 0x60,
0x17, 0xed, 0x00, 0x49, 0x0f, 0x68, 0x29, 0x5c, 0xd8, 0x4b, 0x5f, 0xe0, 0x86,
0xa8, 0x60, 0x27, 0xd8, 0x45, 0xf2, 0x43, 0xe4, 0x9c, 0xe8, 0x96, 0x02, 0x3d,
0xb2, 0x64, 0x14, 0xf5, 0x30, 0xa6, 0x48, 0x16, 0x71, 0x8c, 0x40, 0xf8, 0x2e,
0x79, 0x87, 0x4c, 0x55, 0x6d, 0x17, 0x1e, 0x97, 0x92, 0xb3, 0x53, 0x0a, 0xe3,
0xe9, 0x53, 0xf9, 0x8d, 0x87, 0x94, 0x16, 0x68, 0xe5, 0xc2, 0x28, 0xac, 0x51,
0xc3, 0x96, 0x6d, 0xa6, 0x27, 0xf8, 0x05, 0x2c, 0xf4, 0xec, 0x83, 0x64, 0xbc,
0x29, 0x47, 0x71, 0xf5, 0x78, 0x71, 0x4e, 0x0e, 0xb2, 0x25, 0x30, 0x29, 0xb0,
0x17, 0x56, 0x28, 0xf7, 0xc1, 0x32, 0x82, 0x09, 0xdd, 0x14, 0xb7, 0xb0, 0x16,
0x69, 0x17, 0x2d, 0x4d, 0x91, 0xc8, 0x0c, 0x37, 0xf3, 0x54, 0x17, 0x7e, 0x13,
0x5f, 0xd4, 0xf2, 0x3e, 0x0f, 0xa3, 0x90, 0x14, 0x56, 0x45, 0xcd, 0x73, 0xda,
0xaa, 0x4e, 0x13, 0x36, 0x5e, 0x90, 0x14, 0x4b, 0x48, 0x0f, 0xb9, 0x0b, 0x6b,
0xc3, 0xf0, 0x58, 0x06, 0x66, 0xbf, 0xb6, 0xb4, 0xae, 0x3a, 0xaf, 0xca, 0xbf,
0x88, 0x64, 0x85, 0xe6, 0x6e, 0xba, 0x69, 0xc4, 0x42, 0xfe, 0x2c, 0xeb, 0x1c,
0x6b, 0x96, 0x03, 0xcc, 0x14, 0x15, 0xf6, 0xe1, 0x69, 0xa8, 0xad, 0x8e, 0xfa,
0x82, 0x37, 0x99, 0x54, 0x1a, 0x30, 0x06, 0x16, 0x2d, 0x40, 0x1f, 0x30, 0xd7,
0x3b, 0x40, 0x96, 0x54, 0x71, 0x39, 0xd6, 0x5e, 0x74, 0x5a, 0xc8, 0x6e, 0xf0,
0xa4, 0xab, 0x4b, 0xf9, 0xee, 0x77, 0xa7, 0x0f, 0xef, 0x6f, 0xdf, 0xa5, 0x4e,
0x18, 0x72, 0x4f, 0x52, 0x35, 0x05, 0x1e, 0x07, 0x74, 0xde, 0x25, 0x59, 0xdf,
0xb6, 0x78, 0xd6, 0x05, 0x54, 0xfa, 0x60, 0x43, 0xe0, 0x36, 0x1b, 0x42, 0x6f,
0x10, 0x8a, 0x69, 0x54, 0x68, 0x1a, 0x8d, 0x87, 0xe8, 0x51, 0x65, 0xc9, 0x8b,
0x5b, 0x44, 0x3b, 0x64, 0x98, 0x42, 0x9a, 0xe8, 0x55, 0x4c, 0x67, 0x17, 0x96,
0x59, 0x99, 0xa8, 0x5a, 0xe8, 0x8f, 0x44, 0xc3, 0x0f, 0x08, 0xe4, 0xa7, 0xaa,
0xe4, 0xad, 0xee, 0x93, 0x5a, 0x69, 0x19, 0xf5, 0x66, 0x97, 0x9b, 0x79, 0x50,
0x33, 0xcb, 0x62, 0x73, 0x56, 0xc9, 0x52, 0xef, 0x33, 0x5e, 0x9a, 0x57, 0x92,
0xd6, 0x66, 0x95, 0x9a, 0xfb, 0x85, 0xe5, 0x43, 0x55, 0x1c, 0xe5, 0x36, 0x21,
0xae, 0x3f, 0x32, 0xc5, 0x3e, 0xb7, 0x94, 0xad, 0xb0, 0x42, 0x96, 0xff, 0x0d,
0xda, 0x44, 0xd5, 0x13, 0xa4, 0x17, 0xb4, 0xb8, 0xab, 0xeb, 0x09, 0xdd, 0x09,
0x1f, 0x96, 0xca, 0x46, 0x68, 0x57, 0x40, 0x95, 0x1a, 0x55, 0xd3, 0x35, 0x76,
0xce, 0x3a, 0x4a, 0x90, 0x1c, 0x1e, 0x98, 0xbe, 0x46, 0xbf, 0x37, 0x40, 0xa8,
0x15, 0x34, 0x0e, 0xc3, 0x69, 0xa5, 0x8b, 0x4c, 0x92, 0xcd, 0x7b, 0x20, 0xe2,
0xfb, 0xdd, 0x30, 0x4e, 0x0a, 0xfe, 0x58, 0x81, 0x70, 0x63, 0x59, 0xb5, 0xe9,
0xe5, 0xd6, 0x3c, 0xe0, 0xcb, 0xff, 0xfc, 0x18, 0x90, 0xcb, 0xe4, 0xd5, 0x43,
0x12, 0x44, 0xb5, 0x93, 0x60, 0x01, 0x7b, 0x1d, 0x7c, 0x4d, 0x48, 0xda, 0xf1,
0x4e, 0xd3, 0xbf, 0x2f, 0x5a, 0x2c, 0x16, 0x54, 0xf1, 0xd9, 0x56, 0xc5, 0x12,
0xd3, 0x78, 0xf2, 0xc5, 0x75, 0xde, 0x8d, 0xcf, 0x6c, 0x7f, 0x26, 0x56, 0x3c,
0x21, 0x2b, 0x6c, 0x90, 0x34, 0x69, 0xe2, 0x49, 0xa5, 0xd8, 0xd9, 0xf6, 0x16,
0x3d, 0x4d, 0x77, 0xc2, 0x7e, 0x12, 0x70, 0xea, 0x94, 0xd5, 0xa2, 0xc9, 0xce,
0x53, 0xc6, 0x25, 0x76, 0x13, 0xd9, 0xc5, 0x92, 0x1e, 0x00, 0x86, 0xa7, 0x80,
0x1b, 0xc1, 0x89, 0xa8, 0xa1, 0xac, 0xf2, 0x02, 0x2d, 0xc0, 0x93, 0xdd, 0x64,
0x50, 0xfe, 0x51, 0x69, 0x46, 0xa9, 0x33, 0xdc, 0x5b, 0x52, 0xee, 0x15, 0x32,
0xba, 0x9e, 0x6a, 0xba, 0x0b, 0xe2, 0x24, 0x59, 0x3c, 0xa3, 0xd4, 0x59, 0x54,
0xb2, 0x75, 0x65, 0xcb, 0xef, 0xa7, 0x4f, 0xdf, 0x2f, 0x1f, 0x50, 0xaf, 0xbe,
0x6c, 0x6e, 0x2d, 0x8b, 0x57, 0x2e, 0x6d, 0xcc, 0x19, 0x60, 0xb8, 0x61, 0x88,
0x59, 0x1f, 0x59, 0x1c, 0xe2, 0x7f, 0x92, 0xdc, 0x92, 0xf9, 0xd8, 0x8e, 0xb9,
0x7a, 0xf9, 0x33, 0x6f, 0x3e, 0xae, 0xa4, 0x9d, 0xc0, 0x0c, 0x16, 0x57, 0xb3,
0x21, 0x73, 0x52, 0x98, 0xaa, 0x43, 0x7e, 0x31, 0xf7, 0xca, 0x5c, 0x97, 0x41,
0x07, 0x40, 0x7a, 0x91, 0x74, 0x02, 0xfb, 0x90, 0xf9, 0x14, 0x62, 0x1f, 0xc2,
0xef, 0xae, 0x68, 0x5b, 0x39, 0xce, 0x36, 0x86, 0xe3, 0x8d, 0x1f, 0xf5, 0xbc,
0xee, 0x4d, 0x56, 0x3e, 0xdd, 0x02, 0x25, 0x4b, 0x21, 0xe1, 0x06, 0x3c, 0x74,
0xce, 0x15, 0xad, 0x03, 0xb7, 0xe0, 0x3b, 0x27, 0xd9, 0xc6, 0xed, 0x33, 0x96,
0x6e, 0x2a, 0x28, 0x2f, 0x85, 0xc0, 0x5b, 0xca, 0xcc, 0xc6, 0x85, 0x9b, 0x6b,
0x3e, 0x09, 0xef, 0x90, 0x67, 0x22, 0x1d, 0xf0, 0x0f, 0xb0, 0x24, 0x9d, 0x93,
0xb1, 0x98, 0xbe, 0x80, 0xcc, 0xd8, 0x09, 0x4f, 0x2f, 0x1b, 0x30, 0x52, 0x18,
0x8e, 0xee, 0x95, 0xc5, 0xab, 0x1c, 0x42, 0x50, 0x99, 0x71, 0x09, 0x1e, 0x80,
0x66, 0x72, 0x49, 0x6f, 0xa4, 0xb8, 0x63, 0x70, 0xfa, 0xe0, 0xfe, 0xdb, 0x20,
0x5d, 0x62, 0x48, 0x7e, 0x15, 0xb1, 0x06, 0xa9, 0xf1, 0xe7, 0x16, 0xf2, 0x16,
0xb2, 0x0b, 0x88, 0x3b, 0x0a, 0x16, 0xd1, 0x29, 0x9d, 0xa0, 0xcb, 0x03, 0x07,
0x29, 0xd7, 0xf6, 0xe2, 0x41, 0xe4, 0xdd, 0xe8, 0x84, 0xd3, 0x7a, 0x58, 0x4b,
0x9d, 0x62, 0x1a, 0x99, 0x40, 0xb6, 0xf1, 0xd3, 0x10, 0xe0, 0x4a, 0x92, 0xa7,
0x0b, 0x72, 0x93, 0xd0, 0xa3, 0x1c, 0x07, 0xb1, 0x95, 0x2a, 0x5d, 0xb0, 0x51,
0x9c, 0x25, 0x15, 0x11, 0x87, 0x58, 0xc1, 0x23, 0x64, 0x9b, 0x74, 0x23, 0x07,
0x58, 0x4a, 0x9f, 0xbb, 0x26, 0xb8, 0x2c, 0xbb, 0xc2, 0x76, 0xbd, 0xa5, 0x2b,
0x15, 0xf4, 0xcd, 0xbf, 0xa4, 0xfd, 0xe4, 0xcb, 0x70, 0xf8, 0xaf, 0xc0, 0xf4,
0xc6, 0xe2, 0x69, 0x6d, 0x06, 0xa9, 0xea, 0xe2, 0xdd, 0x50, 0xb4, 0xa8, 0x42,
0xf1, 0x48, 0xaa, 0x90, 0x94, 0x12, 0x36, 0x68, 0x48, 0x44, 0x85, 0x75, 0x5a,
0x49, 0xef, 0x03, 0x0e, 0x12, 0xb8, 0x9b, 0x09, 0x0c, 0x81, 0x38, 0x4e, 0x95,
0xbb, 0x34, 0x18, 0x61, 0x21, 0x41, 0xc2, 0x9a, 0x4b, 0xb3, 0x72, 0x83, 0x9a,
0x79, 0xee, 0xef, 0xa7, 0xaf, 0xd1, 0xbf, 0x39, 0x42, 0xb4, 0xd4, 0x08, 0xdc,
0x82, 0x65, 0x71, 0xa6, 0x18, 0xe2, 0x98, 0x75, 0x9c, 0x04, 0x88, 0x66, 0x2b,
0x14, 0xfd, 0xfb, 0xa5, 0x56, 0xf9, 0xfc, 0x0e, 0x38, 0xf9, 0x1a, 0x1e, 0x34,
0xbb, 0x79, 0x2f, 0xf7, 0x35, 0x15, 0xff, 0xed, 0x28, 0x16, 0xd8, 0xf9, 0x76,
0x56, 0x31, 0xa5, 0xe3, 0x4f, 0xff, 0xd5, 0x9a, 0x16, 0xe9, 0x32, 0x83, 0x37,
0x00, 0xc8, 0x43, 0xe8, 0x96, 0xba, 0x5f, 0x5b, 0xf6, 0x54, 0x2c, 0x57, 0x2d,
0xaa, 0x8a, 0x15, 0x85, 0x15, 0x7b, 0xb3, 0x1a, 0xff, 0x0e, 0x5c, 0x87, 0xb2,
0xf9, 0x71, 0xed, 0xf9, 0x40, 0x63, 0xf6, 0x75, 0x76, 0x82, 0xaa, 0xbe, 0x64,
0x08, 0x93, 0x82, 0x0f, 0x13, 0x1c, 0x87, 0x83, 0x74, 0x51, 0x75, 0xae, 0x1b,
0xea, 0x21, 0xe4, 0x38, 0xe8, 0x16, 0x7b, 0x0d, 0x9b, 0x0e, 0x51, 0x65, 0x66,
0xee, 0x4d, 0xec, 0x00, 0x9b, 0xf3, 0xd7, 0x7b, 0x24, 0x43, 0xd1, 0xdb, 0xb0,
0xe5, 0x0d, 0x24, 0x67, 0x69, 0xea, 0x43, 0xca, 0x9a, 0x37, 0xac, 0x95, 0x35,
0x4f, 0x04, 0xcc, 0xeb, 0xf0, 0x1f, 0x50, 0x57, 0x96, 0xeb, 0xc9, 0xec, 0xa1,
0x6b, 0x46, 0x58, 0x49, 0x2b, 0xc4, 0x57, 0xcd, 0x65, 0xd6, 0xc4, 0xed, 0xe9,
0xd3, 0xf9, 0x8f, 0xb7, 0x69, 0x3a, 0x27, 0xed, 0x2f, 0xc5, 0x5f, 0xc8, 0x3a,
0xf0, 0xc6, 0x6f, 0xc1, 0x2f, 0xa0, 0x61, 0x8c, 0x39, 0x02, 0x37, 0x42, 0xc3,
0x43, 0xa4, 0x0a, 0x35, 0x1b, 0x4b, 0x14, 0x73, 0x37, 0xe2, 0x3c, 0x72, 0x58,
0x3c, 0x11, 0xb0, 0x61, 0xe3, 0x93, 0xc5, 0xa6, 0x99, 0x59, 0x3a, 0x2f, 0x5e,
0x26, 0x9d, 0xae, 0x26, 0x3e, 0x03, 0xe9, 0xfd, 0xf8, 0x2f, 0xd0, 0xaa, 0x0a,
0x7e, 0x08, 0x48, 0xd3, 0xb6, 0x77, 0x90, 0xb5, 0x2a, 0x6e, 0xed, 0xf3, 0xe9,
0x17, 0x67, 0xad, 0xd6, 0x88, 0xdd, 0x0c, 0xec, 0xc3, 0x5b, 0xcb, 0x3f, 0x09,
0x66, 0x27, 0x7c, 0xbc, 0x32, 0x27, 0x5a, 0xfa, 0xe4, 0xfc, 0x3d, 0xf8, 0x29,
0xf8, 0x19, 0xbc, 0x58, 0x38, 0x67, 0xa3, 0xc7, 0x7b, 0x57, 0xc3, 0x90, 0x2f,
0x5e, 0xb8, 0xe3, 0x2b, 0x70, 0x85, 0xee, 0x10, 0x37, 0x31, 0x2b, 0xe1, 0xef,
0xa3, 0x49, 0x37, 0x8b, 0xa7, 0x90, 0xa8, 0x79, 0x01, 0x7a, 0x9f, 0x60, 0x3b,
0xc0, 0x6d, 0x30, 0x1d, 0x2f, 0x18, 0xf4, 0x10, 0x62, 0x15, 0x9b, 0xbf, 0xe2,
0x1a, 0x1c, 0x91, 0x38, 0x96, 0xe0, 0x47, 0xb8, 0xca, 0x75, 0x75, 0x08, 0xc7,
0xbf, 0x38, 0x7d, 0x94, 0xff, 0xfd, 0x8b, 0x14, 0xf6, 0x01, 0x19, 0x87, 0x48,
0xd2, 0x47, 0xa9, 0x49, 0x14, 0xba, 0x97, 0x19, 0x77, 0x30, 0x5a, 0x9e, 0xb3,
0xba, 0x15, 0x94, 0x2c, 0x4d, 0xc4, 0xf8, 0x4f, 0xdf, 0x85, 0xde, 0xaf, 0x01,
0xbe, 0xb4, 0x1b, 0xb6, 0xf5, 0x4a, 0x6d, 0x67, 0xb0, 0x82, 0x88, 0x1d, 0xb3,
0xe6, 0x1f, 0x41, 0xdf, 0x1e, 0x51, 0xe5, 0x2f, 0x7c, 0xba, 0x7a, 0x17, 0x7c,
0x01, 0x36, 0x52, 0x7e, 0x12, 0xbe, 0x04, 0x33, 0x6a, 0xff, 0x7c, 0x8b, 0x7f,
0xf9, 0x25, 0x58, 0xed, 0x5d, 0xbe, 0xf6, 0xf9, 0xc0, 0xa4, 0xda, 0x86, 0x7a,
0x7e, 0x85, 0xe5, 0xe6, 0xc5, 0xee, 0xb0, 0x73, 0x80, 0x59, 0xfd, 0x24, 0x77,
0x0c, 0x97, 0xf8, 0xdd, 0x05, 0x5a, 0xae, 0xe5, 0xf7, 0x66, 0x1b, 0x62, 0x5e,
0xb7, 0x32, 0x7f, 0x43, 0xc4, 0xe3, 0x53, 0x74, 0x2d, 0xc8, 0xc1, 0x35, 0xfb,
0x89, 0x2a, 0xf6, 0x40, 0x22, 0x3b, 0xe1, 0x51, 0x13, 0x05, 0x37, 0x28, 0x53,
0x8e, 0x61, 0x3f, 0x5a, 0xc2, 0xd2, 0x95, 0x1e, 0x12, 0xce, 0xf7, 0x8f, 0x01,
0x3d, 0x37, 0x65, 0xa0, 0x63, 0x33, 0x0a, 0xb3, 0xb8, 0xc7, 0xd7, 0x6a, 0xa9,
0xc2, 0xb8, 0xf8, 0xb5, 0xe9, 0xab, 0xf6, 0x27, 0x5f, 0x23, 0x20, 0x26, 0xa5,
0x5c, 0x8f, 0x3a, 0x68, 0x55, 0x67, 0xde, 0x54, 0x80, 0xe2, 0x0a, 0x3e, 0x42,
0x5e, 0x45, 0x7a, 0x94, 0x70, 0x09, 0x64, 0x6a, 0x8b, 0x74, 0xa7, 0x3e, 0x9f,
0xf2, 0x57, 0xdf, 0xc1, 0xf3, 0x8a, 0xc3, 0x30, 0x63, 0x66, 0x07, 0x94, 0x60,
0xf9, 0x6d, 0x6e, 0x1b, 0x27, 0x64, 0xff, 0x12, 0x89, 0xe9, 0x57, 0x34, 0xb7,
0x20, 0xb7, 0x2c, 0x56, 0xe0, 0xcb, 0x60, 0xa0, 0xc0, 0x9a, 0x89, 0x0d, 0x33,
0x3b, 0x19, 0x76, 0xb3, 0xb0, 0x25, 0x0d, 0x6d, 0xe9, 0x9c, 0xf9, 0x0b, 0xcb,
0x93, 0xe6, 0x28, 0x1d, 0x61, 0x0e, 0x8f, 0x02, 0x78, 0x12, 0xc9, 0x5b, 0x9a,
0x71, 0x98, 0x6c, 0xe8, 0x05, 0x29, 0x38, 0x77, 0xc3, 0x00, 0xd0, 0x0b, 0xcc,
0xff, 0xea, 0xca, 0x75, 0x2b, 0x16, 0x38, 0x96, 0x04, 0x05, 0xdb, 0x8d, 0x7b,
0xc3, 0x33, 0xcc, 0x2d, 0xe7, 0x08, 0x4e, 0x88, 0xb5, 0x73, 0x43, 0x3c, 0x95,
0x35, 0x2b, 0x62, 0x9b, 0xab, 0xe6, 0x62, 0xd6, 0x38, 0xdb, 0x96, 0x3e, 0x4d,
0xa2, 0x04, 0x63, 0xd9, 0xf9, 0xfe, 0x9b, 0xd0, 0xa7, 0x2d, 0xed, 0xbb, 0x38,
0x7d, 0x1a, 0xbf, 0x7f, 0x91, 0xd6, 0x95, 0x04, 0xe7, 0x7f, 0x46, 0xda, 0xc0,
0x57, 0xea, 0x79, 0xd8, 0xdf, 0x14, 0x59, 0x69, 0xd8, 0x17, 0xc4, 0xda, 0xbd,
0x00, 0xf9, 0x6b, 0xc6, 0xb4, 0xc8, 0xe2, 0x59, 0xa1, 0xe7, 0x22, 0x6b, 0xc8,
0xdc, 0xf0, 0x62, 0x12, 0x6f, 0xfa, 0xb8, 0xb1, 0x22, 0xb5, 0x9a, 0x45, 0x46,
0xb4, 0x40, 0x4a, 0xad, 0xae, 0xf7, 0xa7, 0xf4, 0x19, 0x95, 0x66, 0x59, 0x63,
0xf6, 0x29, 0x52, 0x3e, 0x46, 0x62, 0x3a, 0x4c, 0xd0, 0x02, 0xd5, 0x07, 0xb3,
0x48, 0x15, 0xc5, 0x11, 0x2a, 0xd5, 0x52, 0x32, 0x1d, 0x07, 0x57, 0xf3, 0xc3,
0x79, 0x82, 0x93, 0x90, 0x52, 0x6d, 0xad, 0x38, 0x2e, 0x4b, 0x91, 0xeb, 0x3d,
0x78, 0x0c, 0x1b, 0x2b, 0x30, 0xc8, 0xc2, 0x85, 0x34, 0xef, 0x1e, 0xd1, 0xe8,
0xf9, 0xc2, 0x9f, 0x16, 0x1c, 0x05, 0x62, 0x04, 0x03, 0x52, 0xe6, 0xe3, 0x41,
0xd2, 0x09, 0x7f, 0x0f, 0x31, 0xb3, 0x8b, 0x51, 0x7a, 0x84, 0xcc, 0x28, 0x4f,
0xc6, 0x3e, 0x3c, 0xa0, 0xa8, 0xe8, 0x6c, 0x07, 0x71, 0x15, 0xe9, 0x46, 0x72,
0x91, 0x80, 0x93, 0xe3, 0x6a, 0xf6, 0xc0, 0xfd, 0xe9, 0xf3, 0xf7, 0x19, 0x59,
0xef, 0x79, 0x47, 0xa5, 0xaa, 0xbd, 0xa7, 0xf8, 0xff, 0x34, 0xd8, 0x06, 0x71,
0x6d, 0xc1, 0xa2, 0xac, 0x39, 0xe6, 0x7a, 0x6a, 0x28, 0x4b, 0x87, 0x14, 0xc2,
0x47, 0xb0, 0xca, 0x0f, 0xa6, 0xe4, 0x2f, 0xe4, 0xca, 0x3e, 0xb6, 0x0b, 0xfd,
0x1a, 0x17, 0x9a, 0x52, 0x12, 0x60, 0x5d, 0x52, 0x5c, 0x74, 0xa0, 0x85, 0x61,
0x6e, 0x95, 0xfa, 0x2b, 0xde, 0xfc, 0x50, 0x7e, 0x99, 0x3f, 0x44, 0x22, 0xf4,
0xcf, 0xd6, 0xdc, 0x15, 0x2b, 0xa4, 0x84, 0x64, 0x28, 0xb2, 0xd3, 0xc0, 0x47,
0x29, 0x71, 0x2d, 0xc5, 0x4a, 0xea, 0xb4, 0x87, 0xf4, 0x81, 0xe1, 0x0f, 0x1d,
0xc0, 0xdc, 0x61, 0x04, 0x37, 0x2b, 0x53, 0x56, 0xa9, 0x4a, 0x99, 0x01, 0x4a,
0x0e, 0xef, 0x23, 0xda, 0x01, 0xc9, 0x91, 0xc7, 0xe0, 0x12, 0xcc, 0x9b, 0xa3,
0x71, 0x52, 0x97, 0xac, 0xcc, 0x99, 0x55, 0xa8, 0xd8, 0x41, 0xa3, 0xe6, 0x81,
0xd1, 0x4c, 0x05, 0xee, 0x90, 0x55, 0xb2, 0x41, 0x21, 0x52, 0x18, 0xd7, 0xd3,
0x11, 0x44, 0xea, 0x71, 0xf4, 0x2b, 0xc4, 0xee, 0xda, 0x3b, 0x7d, 0x74, 0x9f,
0xdc, 0x4b, 0xf0, 0x06, 0x12, 0x7e, 0x91, 0x76, 0x28, 0xc3, 0x5c, 0xaa, 0x86,
0xc8, 0x2f, 0x47, 0xd1, 0xf2, 0xc4, 0x4b, 0x73, 0x54, 0x9d, 0xce, 0x5b, 0x58,
0x73, 0x07, 0xfa, 0xb0, 0x17, 0xe1, 0xb2, 0x1c, 0xfe, 0x3e, 0x95, 0xd6, 0x88,
0x19, 0xa5, 0x51, 0xae, 0x60, 0x49, 0x83, 0x5b, 0xe2, 0xcc, 0x38, 0x41, 0xc9,
0x51, 0xe6, 0x6a, 0x29, 0x4f, 0x56, 0xc8, 0x6e, 0xc6, 0x15, 0x8c, 0xee, 0x92,
0xb0, 0xc0, 0x34, 0x9e, 0x0d, 0x34, 0xd0, 0x8f, 0x67, 0xc1, 0xd5, 0x15, 0xa9,
0x20, 0xa9, 0xba, 0xf1, 0x00, 0x9c, 0xa0, 0x7c, 0x3f, 0x71, 0xa2, 0x94, 0x3d,
0x04, 0xfe, 0xc2, 0x1b, 0x6b, 0x3a, 0x61, 0x2f, 0xb7, 0x43, 0xeb, 0x0b, 0x50,
0xa8, 0xa4, 0xee, 0x06, 0x1e, 0x56, 0x3f, 0x24, 0x7a, 0x61, 0x5d, 0x45, 0xcd,
0xca, 0xe2, 0xe7, 0x5f, 0x8d, 0xdd, 0x22, 0x9b, 0x5e, 0x82, 0x1e, 0x62, 0xf8,
0x1f, 0xea, 0xa1, 0x9c, 0xf5, 0x39, 0x4b, 0xec, 0x67, 0x6a, 0x95, 0xa4, 0x5b,
0xcb, 0xe6, 0x36, 0x3c, 0x59, 0x37, 0x77, 0x9c, 0xf3, 0xd3, 0xa4, 0xd9, 0x98,
0x53, 0x54, 0x38, 0xe7, 0xc5, 0xc2, 0xd9, 0xa1, 0x59, 0xe1, 0x79, 0xa3, 0xdf,
0x9d, 0xbe, 0x44, 0x7f, 0xff, 0x5d, 0x9a, 0x2c, 0x5d, 0x6b, 0xe9, 0xf1, 0x68,
0xb1, 0x32, 0x0c, 0xdf, 0x82, 0xb7, 0x0a, 0xe3, 0x4f, 0xae, 0x3d, 0xac, 0x69,
0x33, 0x23, 0x7a, 0xec, 0x02, 0xee, 0x07, 0xe5, 0x12, 0x86, 0xf6, 0x53, 0xa9,
0x47, 0xa5, 0x47, 0xdf, 0x83, 0x83, 0x38, 0x83, 0x10, 0xdf, 0x5e, 0x42, 0x8f,
0xa3, 0x49, 0x67, 0x1f, 0x63, 0x0b, 0x9c, 0x90, 0x57, 0x97, 0x15, 0x48, 0x8e,
0x23, 0xbf, 0x03, 0xd0, 0x06, 0x52, 0xcb, 0x05, 0xbd, 0x45, 0x8d, 0x86, 0x47,
0x5d, 0xf5, 0x2c, 0xbb, 0x41, 0x15, 0xbc, 0x4f, 0xfc, 0x79, 0xf3, 0x71, 0xf6,
0x9a, 0x22, 0xa9, 0x51, 0xca, 0xea, 0xbc, 0xdc, 0xbf, 0xc4, 0x5f, 0xdd, 0x26,
0xae, 0x48, 0x13, 0xf6, 0x10, 0xc4, 0x86, 0x4e, 0xb2, 0x39, 0x61, 0x52, 0x3f,
0x1f, 0x83, 0xdc, 0x48, 0xc4, 0xb7, 0xe1, 0x81, 0xea, 0xb5, 0xc8, 0x53, 0x5a,
0x7e, 0xd1, 0xa6, 0x1c, 0x27, 0xf7, 0xd3, 0xb0, 0xbe, 0xd0, 0xbc, 0xa1, 0x2e,
0x6c, 0xa8, 0xe0, 0x89, 0x99, 0x6f, 0xce, 0x8e, 0x76, 0x89, 0x44, 0x54, 0x03,
0xad, 0x60, 0xeb, 0x53, 0xb7, 0xf8, 0x8c, 0x8c, 0x56, 0x94, 0x1f, 0x4d, 0x8f,
0xfc, 0x64, 0xfa, 0x34, 0x7e, 0xf5, 0x27, 0x44, 0xe5, 0x49, 0xd3, 0x8d, 0xb4,
0x8a, 0x45, 0xb2, 0xe7, 0x09, 0x0e, 0xe3, 0x46, 0x71, 0x1a, 0x86, 0x28, 0xe1,
0xa4, 0x17, 0xef, 0xa3, 0xad, 0x58, 0x5e, 0x4d, 0x51, 0xc9, 0x03, 0x04, 0xe3,
0xe0, 0x14, 0x17, 0xb7, 0x51, 0x47, 0xcb, 0x25, 0xd5, 0xe5, 0x6e, 0x68, 0x5d,
0x61, 0xaf, 0x61, 0xa1, 0x4e, 0xe1, 0x06, 0xe1, 0xb0, 0xc5, 0xd8, 0x38, 0x09,
0xee, 0x04, 0xcc, 0x97, 0x4a, 0x81, 0xf6, 0x03, 0xb5, 0xd8, 0x6d, 0xbc, 0x44,
0xf0, 0xa5, 0x43, 0x80, 0x57, 0x39, 0x65, 0x9d, 0xe2, 0x21, 0x24, 0x3e, 0xfb,
0x81, 0x4c, 0x9b, 0xae, 0xb8, 0x06, 0x8a, 0x83, 0xe4, 0x3c, 0x22, 0x2a, 0x6c,
0x1c, 0x76, 0x92, 0x49, 0x35, 0x42, 0xcc, 0x88, 0xdf, 0xbf, 0x46, 0x75, 0xeb,
0xde, 0x32, 0xb1, 0x57, 0x6d, 0x80, 0xc2, 0x92, 0x8c, 0xca, 0x76, 0x93, 0x51,
0x1e, 0x4d, 0x15, 0x95, 0x8a, 0x71, 0x22, 0x1d, 0xd8, 0x1d, 0xc0, 0xdb, 0xd4,
0xb3, 0x57, 0x1e, 0xb5, 0xa0, 0xad, 0x11, 0x83, 0x9d, 0x81, 0x55, 0x12, 0x94,
0x5a, 0x44, 0xdc, 0xca, 0xb2, 0x37, 0x4c, 0xfe, 0x76, 0xfa, 0x5c, 0x7e, 0xea,
0x3e, 0x0d, 0xaa, 0xb9, 0xab, 0x4a, 0x6a, 0x66, 0xd5, 0x67, 0xfb, 0x92, 0x55,
0xcd, 0x78, 0x4f, 0x31, 0x7c, 0x4b, 0xf2, 0x57, 0x3b, 0xf3, 0xfc, 0xd9, 0x34,
0xbf, 0xa4, 0x16, 0x48, 0x56, 0x26, 0xc7, 0x4d, 0xef, 0x24, 0x14, 0x6f, 0x52,
0xe6, 0xb2, 0xab, 0xa6, 0x78, 0xb9, 0xb2, 0x4e, 0x9d, 0xb9, 0x38, 0xea, 0x29,
0x49, 0xf0, 0xb2, 0xc5, 0x0f, 0xa9, 0x54, 0x94, 0xf3, 0xf1, 0x8e, 0xf9, 0xa6,
0xf3, 0x7c, 0x61, 0xf6, 0xd6, 0x8a, 0xec, 0x3a, 0xef, 0xbc, 0x3c, 0x6f, 0x70,
0xdb, 0x27, 0x3e, 0x8d, 0x23, 0x18, 0x87, 0x66, 0x35, 0xa2, 0x79, 0x2e, 0x49,
0x86, 0xbb, 0x86, 0x6e, 0x3f, 0x6d, 0xb4, 0x55, 0xfa, 0x50, 0xe6, 0xdd, 0xf5,
0x6a, 0x54, 0xc5, 0xdb, 0x30, 0x6f, 0xcd, 0x39, 0x34, 0x35, 0x4d, 0x6f, 0x66,
0xba, 0x3f, 0x15, 0x2c, 0xad, 0xc8, 0xbf, 0xcc, 0x98, 0xc2, 0x74, 0xe5, 0x3a,
0xc0, 0x43, 0xa2, 0xe4, 0x26, 0x33, 0xa8, 0x3f, 0xb6, 0xfe, 0x01, 0x19, 0xa4,
0xf9, 0x6a, 0x68, 0x61, 0x7e, 0x3c, 0xa0, 0x7a, 0x94, 0xc0, 0x17, 0xe1, 0xf5,
0x4a, 0x6b, 0x92, 0xd1, 0x1d, 0xfb, 0x3e, 0x39, 0x7d, 0x74, 0x5f, 0x6b, 0xa6,
0x6f, 0xde, 0x60, 0x88, 0x5c, 0x27, 0x0f, 0xcd, 0xa6, 0x85, 0xeb, 0xde, 0x96,
0xb5, 0x98, 0x21, 0xe1, 0xe5, 0xaf, 0x3e, 0x69, 0x4d, 0xaa, 0x51, 0x5a, 0x64,
0x64, 0x92, 0x71, 0xe2, 0xb7, 0x3a, 0x28, 0xbd, 0x86, 0x9e, 0x00, 0x52, 0xff,
0x55, 0x5e, 0xec, 0x67, 0x1f, 0x7a, 0x69, 0xc3, 0x67, 0xa1, 0xd4, 0x64, 0xf1,
0x26, 0x4f, 0x09, 0x6f, 0x9c, 0x60, 0xb4, 0xfe, 0x3a, 0x10, 0x87, 0x38, 0xe8,
0x47, 0x33, 0xe6, 0xe9, 0xc1, 0xad, 0x4a, 0x07, 0x56, 0x47, 0xb4, 0x9c, 0x2a,
0x2f, 0x65, 0xa3, 0x78, 0x12, 0x88, 0xe2, 0x63, 0x4a, 0x94, 0x5a, 0x6d, 0x4c,
0xba, 0x04, 0xdf, 0x1d, 0x64, 0xba, 0x6f, 0x10, 0x28, 0xb5, 0x77, 0x32, 0xaf,
0xd8, 0xf6, 0xd6, 0x8e, 0x85, 0x51, 0xb7, 0xd8, 0xbf, 0xea, 0xad, 0x7b, 0xba,
0x32, 0xc0, 0xe8, 0xd4, 0x03, 0xa2, 0x0d, 0x44, 0xe9, 0x47, 0x5f, 0xfc, 0x20,
0x1e, 0x04, 0x17, 0x8c, 0x76, 0x12, 0x4e, 0x08, 0xaf, 0xc2, 0xac, 0x23, 0x64,
0x3b, 0xee, 0xa8, 0x87, 0x6d, 0xf6, 0x41, 0xce, 0x6f, 0x7c, 0x76, 0xfa, 0x2a,
0xfd, 0xf5, 0x67, 0xc9, 0x38, 0x2f, 0x4c, 0xfd, 0xa0, 0x07, 0xcf, 0xed, 0xc1,
0x3f, 0x8c, 0xa2, 0x21, 0x84, 0x76, 0x1e, 0xd6, 0x6c, 0x93, 0x36, 0xfd, 0x18,
0x8c, 0x9b, 0x99, 0x58, 0x52, 0xcd, 0x8f, 0x12, 0x16, 0x22, 0xcc, 0x9b, 0xdf,
0xad, 0x32, 0x97, 0x9c, 0xc5, 0xcb, 0xbc, 0xb4, 0x4d, 0x6a, 0x8d, 0xfa, 0x49,
0xe3, 0x8c, 0xfa, 0x58, 0xf9, 0x9c, 0x56, 0x28, 0x71, 0x42, 0xe4, 0x0c, 0x1c,
0xd0, 0x84, 0x2f, 0x89, 0xf5, 0x45, 0x5c, 0x0d, 0x44, 0x73, 0x69, 0xd1, 0x4d,
0xec, 0x67, 0x3c, 0x19, 0xe0, 0xf1, 0x76, 0x4b, 0xa5, 0x0d, 0x99, 0x9c, 0x39,
0x81, 0x7a, 0x28, 0x12, 0xd9, 0x6b, 0x4a, 0xfa, 0x68, 0xfd, 0x5e, 0xbc, 0x6f,
0x65, 0x25, 0x1b, 0xe7, 0xd4, 0xcd, 0x08, 0x45, 0x4c, 0x96, 0xd4, 0xf3, 0xbb,
0x94, 0x80, 0x45, 0xbd, 0x91, 0x99, 0x85, 0x01, 0x5e, 0x81, 0xa7, 0xf8, 0x75,
0x6a, 0xf9, 0x2d, 0xd9, 0xd4, 0x6b, 0xf0, 0xb4, 0x14, 0x56, 0x17, 0x91, 0xdc,
0x43, 0x82, 0x46, 0x2b, 0x8b, 0x66, 0xd4, 0x87, 0x78, 0x1a, 0xd1, 0x36, 0xe0,
0x32, 0x1c, 0xa5, 0x3b, 0x3e, 0x07, 0x35, 0x1e, 0xc3, 0x61, 0x97, 0x09, 0x5e,
0xa7, 0xd7, 0xff, 0xe2, 0x11, 0x9e, 0xfd, 0xff, 0x05, 0xf5, 0xe4, 0x3a, 0x2a,
0xe4, 0x59, 0x67, 0xd9, 0xab, 0x6f, 0x23, 0x7b, 0xad, 0x9b, 0x7b, 0x25, 0x19,
0x47, 0x7a, 0x01, 0x27, 0xf4, 0x44, 0xd6, 0x3c, 0x7c, 0xd2, 0x58, 0xcc, 0x82,
0x63, 0x4a, 0x2d, 0x28, 0x05, 0xfb, 0x49, 0x27, 0x71, 0xc2, 0x86, 0xb7, 0x13,
0x45, 0x33, 0xcb, 0x8f, 0x1b, 0x89, 0xc7, 0x03, 0x56, 0x8a, 0xa3, 0xdf, 0x6b,
0x70, 0xe3, 0x32, 0xa3, 0x4d, 0xc7, 0xa1, 0x97, 0xe5, 0xf0, 0x98, 0x47, 0xec,
0xa2, 0x41, 0x57, 0xbd, 0x01, 0x64, 0x1f, 0x01, 0x45, 0xf7, 0x91, 0xbb, 0x78,
0x44, 0x22, 0x69, 0xf1, 0x5b, 0xaf, 0x8b, 0xf0, 0x93, 0x9b, 0x96, 0x16, 0x7b,
0x8b, 0xd5, 0x60, 0x65, 0xc1, 0x09, 0xed, 0x02, 0x41, 0xba, 0xf6, 0x55, 0xae,
0x79, 0x0c, 0xd1, 0x03, 0xe8, 0xdb, 0x3a, 0x84, 0x0e, 0x17, 0xde, 0x50, 0xc1,
0x05, 0x52, 0xee, 0x65, 0x86, 0x39, 0x40, 0xfc, 0x89, 0xdd, 0x44, 0x79, 0x27,
0xfa, 0xfa, 0x59, 0x68, 0xe3, 0x31, 0x4e, 0x8b, 0xdc, 0xfb, 0x5c, 0xdc, 0xc1,
0xc4, 0xcf, 0x3f, 0x40, 0x3f, 0x4d, 0xb7, 0x8a, 0x61, 0x2b, 0x9a, 0xf2, 0xd3,
0x5b, 0x7f, 0xfd, 0x08, 0x8f, 0xc2, 0xff, 0x9a, 0xed, 0x52, 0x65, 0x5f, 0x9f,
0x50, 0x75, 0x7d, 0x10, 0xee, 0xe3, 0x96, 0xfd, 0x8c, 0x70, 0xf5, 0x1a, 0x1e,
0x27, 0x13, 0xd2, 0x4b, 0x98, 0x5a, 0x43, 0xf5, 0x69, 0xa0, 0x23, 0x52, 0xc9,
0x39, 0x29, 0xaf, 0xa1, 0xc5, 0x03, 0x07, 0x10, 0x07, 0x99, 0xb4, 0xa5, 0xf9,
0xc9, 0x7a, 0xfd, 0x9d, 0x57, 0x9e, 0xa8, 0x34, 0x53, 0x93, 0xd8, 0x0f, 0xeb,
0x37, 0xf6, 0xda, 0x95, 0xd9, 0xa8, 0x4a, 0x22, 0xfc, 0x29, 0x5c, 0x00, 0xbf,
0x93, 0x57, 0x49, 0x6f, 0x09, 0x3b, 0x61, 0x83, 0x03, 0x4e, 0xde, 0x01, 0x48,
0x9f, 0xa3, 0xf4, 0x16, 0xb5, 0xbc, 0xf4, 0x08, 0x17, 0xbe, 0x23, 0xd8, 0x49,
0x64, 0x60, 0xaa, 0xb1, 0x13, 0x3a, 0xa8, 0xd4, 0x9a, 0x99, 0x71, 0xe4, 0x17,
0xf1, 0x0c, 0x74, 0x30, 0x23, 0x6e, 0x16, 0xae, 0x93, 0x74, 0x48, 0xa7, 0x3a,
0xb2, 0x8f, 0xa5, 0x9c, 0xb8, 0x9a, 0x2e, 0xcb, 0x04, 0xf3, 0x45, 0x58, 0x4b,
0xe4, 0xf8, 0x92, 0x07, 0xe8, 0x65, 0x74, 0x6f, 0x4c, 0x4d, 0x46, 0xc8, 0xb2,
0x66, 0x1e, 0x47, 0x9a, 0xce, 0x90, 0x7f, 0xcd, 0xfc, 0x33, 0x70, 0xc7, 0xd8,
0xff, 0x6f, 0xd3, 0x17, 0xef, 0xaf, 0xfe, 0x8d, 0xe8, 0xf5, 0x7e, 0x5e, 0x93,
0x97, 0x37, 0x7f, 0xf6, 0x61, 0x32, 0xcc, 0xd2, 0xb3, 0x1b, 0x82, 0xd5, 0x29,
0x88, 0xf1, 0x2b, 0x4c, 0x8d, 0x05, 0xb5, 0xcb, 0x70, 0x82, 0xb9, 0x94, 0x66,
0x15, 0xb3, 0x8a, 0xd0, 0x04, 0x25, 0x2f, 0xec, 0x46, 0x0e, 0x42, 0xde, 0xd8,
0x71, 0xa4, 0x8c, 0xde, 0x25, 0xba, 0xc2, 0x25, 0x68, 0x10, 0x8b, 0x21, 0xb9,
0x83, 0xe7, 0x40, 0x25, 0x13, 0xfc, 0xc5, 0xbf, 0x83, 0x3d, 0xf0, 0x54, 0xcd,
0x8c, 0xe7, 0xc7, 0x21, 0x3b, 0xab, 0xb0, 0x48, 0xbf, 0xa9, 0x22, 0x0a, 0x72,
0x9e, 0x58, 0xf5, 0xbb, 0x80, 0xee, 0xc4, 0x6d, 0xd7, 0xe0, 0x0a, 0x3c, 0x94,
0x44, 0x48, 0x2e, 0x73, 0x06, 0x7c, 0x2f, 0x57, 0x7a, 0x58, 0x1b, 0x24, 0x24,
0x0d, 0x9d, 0x84, 0xc8, 0x8f, 0xbe, 0x8e, 0xd7, 0xb4, 0xca, 0xf3, 0x0a, 0x1c,
0x53, 0xc7, 0x9c, 0x5d, 0x5a, 0x2f, 0xb4, 0xe8, 0x24, 0xe4, 0x04, 0x65, 0xf9,
0x90, 0x31, 0xda, 0x05, 0x7b, 0x2c, 0xb3, 0xd4, 0x66, 0xbe, 0x3c, 0xbc, 0x82,
0x95, 0xdb, 0x47, 0x3c, 0x34, 0xec, 0x04, 0x4b, 0xc9, 0x05, 0xe9, 0x5f, 0xf5,
0x87, 0x8c, 0x5c, 0xa5, 0xe5, 0x83, 0xd0, 0xc2, 0xe8, 0xf8, 0xc0, 0x23, 0x18,
0x91, 0x01, 0x7a, 0x9e, 0x49, 0x81, 0xd1, 0xcf, 0x8e, 0xe1, 0x35, 0x69, 0xc1,
0x4f, 0x01, 0x8e, 0x33, 0xc1, 0x83, 0x1a, 0xd9, 0x45, 0x2e, 0x32, 0x74, 0x85,
0x15, 0xb7, 0x2e, 0x4b, 0x17, 0x49, 0x27, 0x01, 0x0e, 0x32, 0xfa, 0x7a, 0xbb,
0xfd, 0xe4, 0x62, 0x6e, 0x56, 0xf8, 0x20, 0xa7, 0x53, 0xba, 0xd8, 0xec, 0x71,
0xbe, 0x7e, 0x27, 0x5c, 0xa7, 0xe9, 0x30, 0x8c, 0xd1, 0x1b, 0xb8, 0x9f, 0xf9,
0x38, 0x51, 0xbd, 0xe7, 0xa1, 0x13, 0xa5, 0x01, 0x14, 0xda, 0x49, 0x8a, 0x8b,
0xdb, 0x64, 0x5d, 0x86, 0xd2, 0x2a, 0x51, 0xca, 0x28, 0xbb, 0xaf, 0x50, 0x5d,
0xdb, 0x43, 0x75, 0x46, 0xf9, 0x2e, 0x19, 0x39, 0xb7, 0x7a, 0x60, 0x3f, 0xc8,
0xd1, 0xd3, 0x4e, 0x43, 0x9b, 0xbc, 0xb6, 0xb4, 0x41, 0x67, 0x25, 0x2a, 0xef,
0x04, 0xde, 0x09, 0x00, 0xf7, 0x01, 0x5e, 0xf8, 0x88, 0xdd, 0xc7, 0x43, 0xbc,
0x99, 0xbf, 0x58, 0xfa, 0xcb, 0x6f, 0xe2, 0x55, 0xff, 0x1d, 0x05, 0xf9, 0x80,
0x71, 0x68, 0x37, 0x7e, 0xbf, 0x05, 0x77, 0x19, 0x1a, 0x40, 0xb7, 0x91, 0xe8,
0x13, 0xac, 0xc3, 0xb1, 0x99, 0xd9, 0xe1, 0x57, 0xdc, 0x28, 0xb7, 0xf9, 0x25,
0x61, 0x75, 0x4b, 0x59, 0x3c, 0x48, 0x76, 0x0d, 0x4f, 0x1f, 0xfd, 0x5f, 0x0c,
0xd3, 0x56, 0x16, 0xa9, 0x3c, 0x85, 0x30, 0x4c, 0xe8, 0x38, 0xeb, 0x67, 0x43,
0x78, 0x17, 0xc9, 0x01, 0x21, 0x29, 0x40, 0x77, 0xcf, 0x2b, 0x34, 0x94, 0xc4,
0x43, 0xf4, 0x2b, 0xf2, 0x7f, 0x38, 0x1c, 0x53, 0xfa, 0x9c, 0x60, 0xa4, 0x20,
0x81, 0x99, 0x36, 0xc5, 0xe7, 0xe4, 0x69, 0x27, 0x18, 0x78, 0x9c, 0x93, 0xa2,
0x46, 0xc4, 0xd3, 0x41, 0xf4, 0xe4, 0x5e, 0xe6, 0xf4, 0x2a, 0xf3, 0x16, 0x66,
0x79, 0x63, 0xfa, 0x31, 0xa2, 0x1f, 0x85, 0xc3, 0xd2, 0x56, 0x52, 0x76, 0x4d,
0x49, 0xc6, 0x66, 0x6a, 0xf9, 0x68, 0x86, 0x0a, 0x02, 0xa1, 0x70, 0xfa, 0xba,
0x18, 0x22, 0x9b, 0x76, 0x03, 0x7b, 0xed, 0x1e, 0x34, 0x9c, 0x04, 0x9d, 0x1f,
0x9f, 0x1a, 0xa8, 0x3d, 0x84, 0x5f, 0x27, 0x87, 0x08, 0x64, 0x69, 0x97, 0xf8,
0xf2, 0xb4, 0x4d, 0xc7, 0xa9, 0x26, 0xe6, 0xff, 0xe6, 0x20, 0x5e, 0xb1, 0x12,
0x12, 0xe2, 0xcf, 0x28, 0xa3, 0x2a, 0x7f, 0xed, 0x0e, 0x0c, 0x88, 0xcb, 0x0e,
0x3d, 0x62, 0x08, 0x6d, 0x8f, 0x68, 0x81, 0x76, 0xbb, 0xdf, 0x1f, 0xa5, 0x47,
0xc4, 0x79, 0xb6, 0x9f, 0x0d, 0x70, 0xde, 0xa2, 0x2b, 0x14, 0x46, 0xf9, 0xa6,
0x41, 0xe6, 0xf1, 0x9d, 0x40, 0x7c, 0xb0, 0xe4, 0x7f, 0x34, 0xc2, 0xce, 0xd6,
0xe9, 0xa3, 0xff, 0xcd, 0xa7, 0x69, 0x17, 0xb9, 0x8e, 0x23, 0xa2, 0x07, 0x0f,
0x58, 0xa4, 0xbc, 0x24, 0xa4, 0x09, 0xde, 0xa5, 0xe0, 0x3e, 0x36, 0x08, 0x6f,
0xdf, 0x66, 0x42, 0x77, 0x93, 0xa1, 0x53, 0x9c, 0x4c, 0x32, 0x5b, 0x61, 0x57,
0x8d, 0xd2, 0x3d, 0x6a, 0x81, 0x7e, 0x4a, 0xec, 0x63, 0xfb, 0xf9, 0x5e, 0x84,
0x83, 0xd0, 0x8a, 0x9a, 0x45, 0x8e, 0x08, 0xfd, 0x82, 0xfa, 0xc6, 0xb6, 0xdd,
0xb0, 0x59, 0x21, 0x3f, 0x1e, 0x45, 0xec, 0x0c, 0x00, 0xed, 0x57, 0x87, 0xcc,
0xe3, 0x4c, 0xde, 0xed, 0x51, 0x03, 0xee, 0xc0, 0x7e, 0xd6, 0xef, 0xb8, 0xde,
0xdb, 0x38, 0xe2, 0xee, 0x93, 0x97, 0xb9, 0xac, 0x90, 0x03, 0xfc, 0x1c, 0xbb,
0xef, 0x79, 0xa8, 0xb0, 0x2b, 0xf4, 0x50, 0xb8, 0x38, 0xa7, 0x53, 0x91, 0x8e,
0xbd, 0x9b, 0xd1, 0x3e, 0xb8, 0xc5, 0xb9, 0x31, 0xc8, 0x6f, 0x31, 0x4e, 0xf6,
0x93, 0x5e, 0xe8, 0x56, 0xae, 0xab, 0x1a, 0xd5, 0x88, 0x6e, 0xde, 0xe2, 0x83,
0x0c, 0xcd, 0x3d, 0x92, 0x13, 0xc8, 0x55, 0x72, 0x49, 0x42, 0x11, 0xe9, 0xc3,
0x76, 0x64, 0xa3, 0x52, 0xfe, 0x72, 0x2d, 0xe6, 0x1d, 0x23, 0xfd, 0xb0, 0xa6,
0x15, 0x7c, 0xf8, 0x93, 0x51, 0x84, 0x3d, 0x01, 0x0a, 0x37, 0xdd, 0x03, 0xaa,
0xbc, 0xe9, 0x09, 0x6d, 0xcc, 0x18, 0x0f, 0x1e, 0x84, 0x2b, 0x5e, 0xeb, 0x8c,
0x71, 0x8a, 0x8d, 0xe3, 0x29, 0x42, 0xfa, 0x1f, 0xa1, 0x21, 0xbe, 0xf8, 0x25,
0x7a, 0x51, 0x83, 0xa3, 0x8e, 0xec, 0xf6, 0x81, 0x04, 0xdb, 0x83, 0x6d, 0x7c,
0x90, 0xe3, 0x5d, 0x46, 0xf7, 0x92, 0xd3, 0x62, 0x52, 0x8f, 0xe0, 0x79, 0x5d,
0x5e, 0x9d, 0x9c, 0xc3, 0x73, 0xa4, 0x99, 0xda, 0xed, 0xd8, 0x01, 0x97, 0x69,
0x59, 0x84, 0x0d, 0x71, 0xe5, 0x30, 0xdb, 0x41, 0xd6, 0x7c, 0xee, 0x2b, 0xd8,
0x15, 0x3b, 0xe7, 0x9c, 0x34, 0x1c, 0xd8, 0x29, 0x4e, 0x39, 0x5d, 0x79, 0x57,
0x82, 0x23, 0x1c, 0xe8, 0x25, 0x85, 0x93, 0xbd, 0xe6, 0xa0, 0xc7, 0xba, 0x2a,
0x86, 0xcd, 0x5d, 0x3e, 0xd8, 0x6f, 0x33, 0xa5, 0xcd, 0xd8, 0x4d, 0x2f, 0x92,
0x07, 0x04, 0xc5, 0x24, 0x48, 0xf7, 0xce, 0x39, 0xec, 0xe3, 0x77, 0xf1, 0x00,
0x7c, 0xaf, 0x17, 0x87, 0x94, 0xd6, 0x8a, 0xab, 0xc5, 0x03, 0x21, 0x1c, 0x63,
0x77, 0xe2, 0x3b, 0x2e, 0xa5, 0xf9, 0xaa, 0x09, 0x03, 0x94, 0x6f, 0x67, 0x4e,
0x15, 0x8e, 0xb9, 0xe7, 0xb4, 0x21, 0xdd, 0x10, 0x3b, 0xf1, 0x1c, 0x5e, 0x16,
0xad, 0xe4, 0xa5, 0xdd, 0x74, 0x84, 0xe3, 0x4e, 0xc4, 0x2e, 0x69, 0xce, 0xd5,
0xdf, 0x7f, 0x12, 0x4f, 0x96, 0xef, 0xf1, 0x77, 0x96, 0xd3, 0x3d, 0x65, 0xed,
0xfc, 0xb8, 0xf7, 0x98, 0x31, 0xa1, 0x91, 0x16, 0xe7, 0x22, 0xb9, 0xcd, 0xf6,
0xc0, 0x59, 0xeb, 0x87, 0x1f, 0xc0, 0xcd, 0x78, 0xf3, 0xf2, 0xc3, 0xd9, 0xfd,
0xe6, 0xb0, 0xc6, 0x3f, 0xff, 0x4a, 0x73, 0xd5, 0x5e, 0xe3, 0x90, 0x71, 0x5b,
0x93, 0x8c, 0x98, 0xc4, 0x87, 0xea, 0xf7, 0x96, 0x9c, 0x4f, 0x1d, 0xca, 0xfd,
0xf9, 0xfb, 0xb0, 0xf3, 0x3d, 0xd8, 0x4d, 0xce, 0xe9, 0xfc, 0x1f, 0x5b, 0xa1,
0x67, 0xf7, 0xf4, 0x23, 0xf6, 0x87, 0x6f, 0xf1, 0xef, 0x00, 0xfe, 0x2d, 0xbe,
0x81, 0xff, 0xc7, 0xb7, 0xd8, 0xff, 0x91, 0xb3, 0x0c, 0x1d, 0x99, 0x7e, 0xa5,
0xc1, 0xd7, 0x8f, 0xfc, 0xef, 0x2b, 0x0d, 0xbe, 0xfb, 0x77, 0x80, 0x79, 0x85,
0x7f, 0x74, 0x11, 0x44, 0x6d, 0xf5, 0x1f, 0xbd, 0x5e, 0x5f, 0xf3, 0x7f, 0x2d,
0x73, 0x08, 0xfc, 0x7f, 0x47, 0xed, 0x5f, 0x85, 0xaa, 0x61, 0x6b, 0x8c, 0x9e,
0x81, 0x5f, 0xfb, 0xb5, 0xd7, 0x77, 0x41, 0x57, 0xd6, 0x8d, 0x5d, 0xec, 0x5b,
0xf7, 0x68, 0xbb, 0xf1, 0xfd, 0x85, 0xb7, 0xcd, 0x5f, 0x9a, 0xf3, 0xc6, 0x60,
0x93, 0x05, 0xbd, 0xfa, 0x29, 0x76, 0x45, 0xd2, 0xc6, 0x69, 0xf3, 0xa4, 0x58,
0x75, 0x4a, 0xbf, 0x2c, 0x4e, 0x24, 0xfb, 0x83, 0x95, 0x1d, 0x70, 0x3e, 0xf4,
0xe5, 0x0e, 0x08, 0x5c, 0xc0, 0x60, 0xc4, 0x16, 0xb2, 0x1b, 0x7b, 0xe9, 0xe6,
0x41, 0x1b, 0xaf, 0x8b, 0xf2, 0x7e, 0x55, 0xb6, 0xe3, 0xaa, 0x57, 0xa1, 0x8f,
0x4f, 0x02, 0xdd, 0xcd, 0x9a, 0xd5, 0xdd, 0xd0, 0x9e, 0x77, 0xf6, 0x87, 0xd3,
0x67, 0xed, 0x73, 0x3f, 0xa4, 0x11, 0x21, 0xae, 0x85, 0xe9, 0x08, 0xb9, 0x14,
0xea, 0x8f, 0xee, 0x5f, 0xfb, 0xee, 0x5e, 0xf4, 0xe5, 0xbf, 0xdc, 0xb0, 0x30,
0xe1, 0x49, 0x17, 0x56, 0xf3, 0xba, 0x78, 0x3c, 0x59, 0x7f, 0x54, 0x3b, 0x01,
0x5e, 0x6b, 0x50, 0x5a, 0x43, 0xb6, 0xf1, 0xcd, 0xfb, 0x30, 0xa2, 0x93, 0x7d,
0x20, 0x7c, 0x1d, 0x4a, 0x1b, 0x08, 0xd7, 0xcb, 0x4d, 0xe7, 0xa0, 0x78, 0x88,
0xa9, 0x83, 0xd2, 0x8c, 0xf0, 0xe3, 0x6c, 0x10, 0x13, 0x0f, 0xa0, 0x7c, 0x04,
0x8e, 0x03, 0xa8, 0x7b, 0x34, 0x6a, 0x30, 0x4d, 0x78, 0x2c, 0x3d, 0xd0, 0x25,
0x43, 0x62, 0xaa, 0x34, 0x24, 0x1a, 0xf3, 0x8c, 0x79, 0x37, 0x86, 0x7c, 0x61,
0xd5, 0xe7, 0xc1, 0x31, 0xe7, 0xa2, 0x18, 0x04, 0x1c, 0x96, 0xce, 0xe1, 0x00,
0xbb, 0x69, 0x8f, 0x7a, 0x4f, 0x1b, 0x8a, 0x22, 0x7b, 0xcc, 0x9e, 0x30, 0x0e,
0xc5, 0xe4, 0xe9, 0xcc, 0xbd, 0x01, 0x2a, 0xf8, 0x97, 0xbe, 0x8c, 0xd5, 0xcb,
0x2a, 0x7c, 0xe9, 0x27, 0x57, 0x15, 0x44, 0x66, 0x97, 0x3e, 0x65, 0x84, 0x1a,
0x2f, 0x29, 0x6b, 0x4e, 0x02, 0x95, 0x2e, 0x16, 0x0f, 0xc1, 0x08, 0x24, 0x6a,
0x25, 0xf9, 0x5a, 0xe1, 0x35, 0xf1, 0x75, 0xdc, 0x0d, 0x8f, 0xbf, 0x3f, 0xbd,
0x98, 0xf9, 0xe4, 0xfb, 0x2c, 0x13, 0xad, 0x10, 0x8b, 0x4e, 0x6b, 0x26, 0x19,
0x05, 0xc5, 0x62, 0xd4, 0xba, 0xce, 0x5f, 0x1b, 0x87, 0xa8, 0xe3, 0xf1, 0xe4,
0x67, 0x43, 0xb9, 0x7e, 0x51, 0x28, 0x83, 0x48, 0xe5, 0x25, 0x4c, 0x4e, 0x5c,
0x5b, 0x44, 0x68, 0x37, 0x5b, 0xa3, 0xdc, 0x07, 0x22, 0x0d, 0xff, 0x6d, 0x28,
0x3f, 0x04, 0xf2, 0x5b, 0x00, 0x75, 0xaa, 0xa1, 0x65, 0x73, 0x28, 0xf5, 0x3b,
0x8a, 0x16, 0xdc, 0xa5, 0x76, 0x82, 0x4b, 0x51, 0x0b, 0x17, 0xf9, 0xc0, 0x9b,
0xb6, 0xb2, 0x0c, 0x3f, 0x6d, 0xd5, 0xef, 0xa0, 0x44, 0x35, 0xde, 0xcb, 0x68,
0x46, 0x78, 0x44, 0x61, 0x32, 0x12, 0x6f, 0x77, 0x3b, 0x41, 0x2a, 0xb9, 0x2c,
0xa5, 0xd2, 0x52, 0x66, 0x13, 0x7d, 0xcb, 0xd3, 0x55, 0x31, 0xeb, 0xa3, 0x91,
0x68, 0x71, 0xee, 0xb8, 0x6d, 0x9c, 0x15, 0xa3, 0x40, 0x0c, 0xae, 0x9a, 0x81,
0x5e, 0x22, 0x89, 0x98, 0x9c, 0xe1, 0x20, 0xcd, 0xd8, 0x05, 0x32, 0xa9, 0xdd,
0x8a, 0x1e, 0x07, 0xc5, 0x43, 0x7d, 0xd7, 0x05, 0x78, 0x5d, 0x4e, 0xcf, 0x3f,
0xc2, 0x54, 0xf7, 0xbf, 0xfe, 0x9a, 0x98, 0x78, 0x3d, 0xaf, 0xcf, 0xf4, 0x1e,
0x23, 0x54, 0x31, 0x5d, 0xb3, 0x37, 0x60, 0x5b, 0xe4, 0x57, 0xef, 0x4a, 0x24,
0x99, 0xe9, 0xda, 0xdc, 0xca, 0x22, 0x85, 0x6a, 0xf8, 0xa9, 0x6e, 0x78, 0x7a,
0xf3, 0x63, 0x8e, 0xa7, 0x3c, 0x64, 0xfb, 0x82, 0xc9, 0xdc, 0xd5, 0xfc, 0x8a,
0x52, 0x4f, 0x6f, 0x01, 0xc3, 0xdc, 0x82, 0x6e, 0xdc, 0x0b, 0xb8, 0x45, 0x5a,
0x85, 0x6b, 0xc4, 0xa6, 0xa9, 0xb8, 0x31, 0x2b, 0xa1, 0x54, 0x58, 0x4e, 0x74,
0xd9, 0xec, 0x28, 0xec, 0xf8, 0x88, 0xc2, 0x06, 0x34, 0x7a, 0x13, 0xb8, 0x4a,
0x0c, 0x30, 0x7c, 0x7e, 0xc3, 0xc6, 0x6c, 0xa3, 0x70, 0x1f, 0x7f, 0xf5, 0x0a,
0x68, 0x85, 0x30, 0xb3, 0xca, 0xef, 0x37, 0xac, 0xdc, 0x27, 0x42, 0xdc, 0xc9,
0xcb, 0x3d, 0xc4, 0xf9, 0x46, 0x29, 0xc6, 0xf8, 0x69, 0xf0, 0x8a, 0x42, 0xdd,
0x54, 0xc2, 0x8a, 0xcf, 0xef, 0x30, 0xaf, 0x93, 0xd6, 0xbd, 0x13, 0x8c, 0x69,
0xfb, 0xa8, 0x8e, 0xb8, 0x79, 0xa3, 0x90, 0xc5, 0x62, 0x75, 0x80, 0x19, 0xae,
0x5c, 0x7a, 0xed, 0x0f, 0xd3, 0x57, 0xec, 0x17, 0xfe, 0x40, 0x57, 0x47, 0x6a,
0x2b, 0x94, 0x98, 0xb7, 0x80, 0xd7, 0x57, 0x13, 0x95, 0xe5, 0xde, 0x16, 0xab,
0xae, 0x80, 0x55, 0x97, 0x93, 0x17, 0xca, 0x9f, 0xa9, 0x89, 0x50, 0xb6, 0xe5,
0xb4, 0x4b, 0xbb, 0x91, 0xbb, 0x17, 0xc2, 0x4e, 0xcc, 0x1b, 0x76, 0x1c, 0x6a,
0xdb, 0xf9, 0x30, 0x4e, 0xf2, 0xef, 0x41, 0x45, 0xa3, 0x32, 0x53, 0xab, 0xcb,
0x26, 0xc9, 0x4a, 0xc8, 0x5e, 0x12, 0x75, 0x8a, 0x74, 0xc5, 0x83, 0x35, 0x7d,
0x96, 0xcc, 0xe8, 0x31, 0x78, 0xe7, 0x26, 0x0c, 0xcb, 0x74, 0x15, 0x2c, 0xac,
0x5f, 0xfa, 0xda, 0x33, 0x95, 0x51, 0xdb, 0xe5, 0xcb, 0xb4, 0xb9, 0x81, 0x95,
0xab, 0x73, 0x67, 0x1d, 0x81, 0xd9, 0x57, 0xe0, 0x7b, 0xa0, 0x97, 0x74, 0xc2,
0xea, 0xaa, 0xb2, 0x56, 0x5b, 0xc9, 0x89, 0x85, 0x49, 0x44, 0xcb, 0x2b, 0x2f,
0x39, 0x2d, 0xa4, 0x8a, 0x8d, 0xc4, 0x73, 0xbd, 0xd4, 0x88, 0x6a, 0x03, 0xd2,
0xd1, 0x98, 0x82, 0x84, 0xe2, 0xcd, 0x2c, 0x30, 0x35, 0xd7, 0xbe, 0x17, 0x42,
0x07, 0x69, 0x1b, 0x10, 0xd0, 0x5a, 0xa5, 0x52, 0xa5, 0xd0, 0xd6, 0xfb, 0x08,
0xcf, 0xf7, 0x7b, 0x65, 0xad, 0xb1, 0x5d, 0x52, 0x83, 0xf1, 0x66, 0x49, 0x37,
0x1d, 0x78, 0xdb, 0x18, 0x81, 0x06, 0x7f, 0x21, 0xb3, 0xaf, 0xb1, 0x66, 0x9c,
0x57, 0x90, 0x45, 0x78, 0x55, 0xd4, 0x8a, 0xcd, 0xae, 0xd5, 0x83, 0xa6, 0x53,
0x39, 0xbb, 0x21, 0x9c, 0xb7, 0xd7, 0x96, 0x8d, 0x77, 0x26, 0x38, 0x69, 0x9a,
0x8e, 0xee, 0x02, 0x3d, 0x44, 0xa8, 0xaa, 0xb0, 0xce, 0x80, 0x02, 0xc4, 0xfd,
0xf7, 0x2f, 0xa1, 0x1d, 0x7b, 0xac, 0x94, 0x7a, 0x73, 0x1d, 0x36, 0xdb, 0x5e,
0x91, 0x97, 0x98, 0x69, 0x98, 0xdb, 0x86, 0x54, 0xed, 0x16, 0xd0, 0x7b, 0xf0,
0x4e, 0x8d, 0xec, 0xc6, 0x13, 0xb4, 0x22, 0x64, 0xaf, 0x09, 0x76, 0x7d, 0x00,
0x7f, 0xf3, 0x01, 0x78, 0x56, 0xcc, 0x4d, 0xe0, 0x93, 0xcf, 0xf4, 0xc0, 0x8c,
0xda, 0xbf, 0x94, 0xea, 0xfc, 0x4f, 0xda, 0x8d, 0x12, 0xd4, 0xca, 0x02, 0x06,
0x31, 0x15, 0x8f, 0x2f, 0xe4, 0x57, 0x8f, 0xb2, 0xca, 0x5d, 0xb0, 0x17, 0x59,
0x2a, 0x13, 0xcf, 0xab, 0xe3, 0xa0, 0x67, 0xc7, 0xb4, 0x99, 0x31, 0x1f, 0x2d,
0xa8, 0xf7, 0x9a, 0xf7, 0xf8, 0x29, 0x6c, 0x43, 0x27, 0x18, 0x08, 0xa6, 0x4e,
0xee, 0x9a, 0xbe, 0x01, 0xff, 0x7e, 0x17, 0x13, 0x32, 0x92, 0x10, 0x43, 0xd5,
0x24, 0x4e, 0xba, 0xb2, 0x85, 0xae, 0x40, 0x64, 0x4a, 0x0f, 0x06, 0x89, 0xe9,
0xd0, 0x13, 0xb0, 0x6c, 0xc5, 0x66, 0x29, 0x35, 0x6b, 0xea, 0xf3, 0x2a, 0x62,
0x41, 0x9a, 0x89, 0x07, 0x69, 0xdd, 0xc7, 0xe7, 0xe5, 0xc7, 0x9c, 0xfd, 0x02,
0x7b, 0xf0, 0x6d, 0x52, 0x54, 0xe9, 0x2f, 0x8b, 0x15, 0xb3, 0x3c, 0xe2, 0xcb,
0xc5, 0x19, 0x35, 0x33, 0xfc, 0x7d, 0x2a, 0x3d, 0x0d, 0x85, 0xb7, 0xa0, 0x20,
0xcd, 0x2b, 0x7c, 0x22, 0x6d, 0x27, 0x66, 0x95, 0x6a, 0xfe, 0xe3, 0x04, 0x27,
0x70, 0xcb, 0xea, 0x68, 0xe3, 0x63, 0x6f, 0xce, 0x2d, 0xf3, 0xc4, 0x9a, 0x4c,
0x75, 0x75, 0xf9, 0x8c, 0x36, 0x00, 0xdb, 0xff, 0x98, 0xa7, 0xb0, 0xd2, 0x7d,
0xab, 0x0b, 0x3e, 0xba, 0xec, 0xb1, 0xd9, 0x3b, 0xfc, 0x0d, 0xcf, 0xa2, 0xb9,
0x6c, 0xce, 0x61, 0x73, 0x04, 0xe8, 0xd6, 0x79, 0xd4, 0x91, 0x90, 0xbd, 0x9b,
0x86, 0xcc, 0x68, 0x1d, 0x7f, 0xda, 0x7e, 0x66, 0x18, 0x3e, 0x54, 0x38, 0x7f,
0xae, 0x27, 0xab, 0x6e, 0xc9, 0xe4, 0xd8, 0xf4, 0xa9, 0xfb, 0xed, 0x0f, 0x68,
0x69, 0xc3, 0x87, 0x43, 0x5b, 0x3e, 0x56, 0x19, 0x7a, 0xbc, 0xaa, 0xc2, 0x3a,
0x6d, 0x95, 0x35, 0x84, 0x21, 0x9e, 0x8b, 0xc1, 0x21, 0xee, 0x60, 0xa3, 0xc2,
0xd5, 0x51, 0xa8, 0x52, 0x78, 0x30, 0x20, 0xd8, 0x09, 0xdc, 0x0d, 0x5e, 0x83,
0x05, 0x19, 0xc0, 0xf6, 0x75, 0x8e, 0x47, 0xe3, 0xd1, 0xdc, 0xe3, 0x94, 0x36,
0x43, 0x25, 0x1e, 0x05, 0xbe, 0x8f, 0x74, 0x4b, 0x93, 0x2a, 0x2d, 0x82, 0x96,
0xa3, 0xc0, 0x45, 0x82, 0xf5, 0x01, 0x0c, 0x07, 0x24, 0x98, 0xea, 0xa9, 0x5b,
0x94, 0x82, 0x0e, 0x7d, 0x68, 0x53, 0xcb, 0xbe, 0x8a, 0x64, 0x00, 0x36, 0xe1,
0x1d, 0x26, 0x2d, 0x2c, 0x4a, 0xe2, 0xd7, 0xcc, 0x83, 0xea, 0xab, 0x62, 0x4b,
0x27, 0x58, 0xa8, 0x2d, 0x3a, 0x8e, 0x59, 0x95, 0x71, 0x8f, 0x1e, 0xf3, 0xd7,
0x7b, 0x79, 0x76, 0x20, 0x68, 0x38, 0x89, 0x8a, 0xab, 0xb4, 0xf1, 0x1a, 0xb4,
0xc3, 0x12, 0x35, 0x36, 0xa7, 0xfc, 0xa9, 0x31, 0xf8, 0x2b, 0x28, 0xa8, 0xb7,
0xfd, 0x69, 0x5e, 0x9a, 0x25, 0xfd, 0xdc, 0xfe, 0xbb, 0xd3, 0x03, 0xca, 0xdf,
0xdd, 0x25, 0xa2, 0xca, 0xd4, 0xbb, 0x2c, 0xe6, 0x78, 0xf6, 0x8a, 0x48, 0x25,
0x87, 0x73, 0x6c, 0x0b, 0x3f, 0x6f, 0x4e, 0xa8, 0x24, 0x12, 0xed, 0xa3, 0x1f,
0xa6, 0xc5, 0x49, 0xd3, 0x55, 0x58, 0x0f, 0x85, 0x16, 0x57, 0xa5, 0xd4, 0xa3,
0xfc, 0xac, 0x07, 0x2b, 0x68, 0x28, 0x11, 0x2b, 0x78, 0x12, 0xde, 0x51, 0xfc,
0x1f, 0xc5, 0x79, 0x9a, 0x62, 0xc5, 0x74, 0xba, 0xb0, 0x87, 0xbd, 0x06, 0xdb,
0x75, 0xe4, 0xc6, 0x00, 0x9a, 0x76, 0x08, 0xbd, 0x91, 0xf3, 0xd0, 0x02, 0xbd,
0xd8, 0xc1, 0xff, 0x02, 0x5e, 0x54, 0x9f, 0x0a, 0xc5, 0x5f, 0xaa, 0xd6, 0x94,
0x59, 0x4d, 0xc1, 0xbc, 0xca, 0xb8, 0xc0, 0xb2, 0x8d, 0x7e, 0xe7, 0xa6, 0xc0,
0x2e, 0x32, 0x0e, 0x1f, 0x00, 0x2b, 0x0b, 0x79, 0x40, 0x10, 0xd7, 0x71, 0x4b,
0x9c, 0x3d, 0xec, 0x8d, 0x7d, 0x84, 0x95, 0x62, 0x85, 0xee, 0x84, 0xf3, 0x0b,
0xef, 0xd0, 0xd7, 0x0d, 0xa9, 0x44, 0x07, 0x80, 0x0c, 0x61, 0x6e, 0x16, 0x37,
0x5c, 0xf3, 0x0a, 0x85, 0x66, 0x34, 0x04, 0xdd, 0x8d, 0x6c, 0xfb, 0x4d, 0xc2,
0x22, 0x07, 0x1f, 0x61, 0x52, 0xfb, 0xb7, 0x0f, 0xe9, 0x71, 0x98, 0x61, 0x67,
0xb2, 0x6a, 0x67, 0x64, 0x0c, 0x91, 0x2c, 0x8c, 0x76, 0xf3, 0x0d, 0x17, 0x50,
0x5a, 0xb4, 0xd5, 0xe5, 0x18, 0x8f, 0x1c, 0xc7, 0x9f, 0x60, 0x06, 0xa2, 0x39,
0xe5, 0xe1, 0xc5, 0x42, 0x5b, 0x57, 0x95, 0xb7, 0xcc, 0x53, 0xd1, 0x50, 0xe2,
0xec, 0x54, 0x44, 0x33, 0x4a, 0xa7, 0xd7, 0x81, 0x85, 0x65, 0xbe, 0x16, 0x82,
0x3d, 0x54, 0xdd, 0x54, 0x82, 0x4e, 0x4a, 0xf9, 0x58, 0x4d, 0x41, 0xa5, 0x97,
0xd2, 0x06, 0x6f, 0xb2, 0xc4, 0x4f, 0x33, 0xd4, 0x68, 0xc8, 0x29, 0x50, 0x7b,
0x0c, 0x4e, 0x14, 0xfe, 0xea, 0x81, 0x35, 0xbf, 0x5a, 0x7d, 0x04, 0x88, 0xa2,
0x82, 0xf6, 0xf6, 0x01, 0x56, 0x82, 0x99, 0x1f, 0x49, 0xf3, 0xb3, 0xe5, 0x4f,
0x7d, 0x01, 0xda, 0x28, 0x4e, 0xc0, 0xcf, 0xc0, 0x5a, 0xee, 0x9a, 0xdb, 0x97,
0x86, 0x66, 0x2d, 0x2a, 0xfe, 0x11, 0xbc, 0xba, 0x28, 0x4c, 0x95, 0x7f, 0x86,
0x8b, 0x60, 0x53, 0xbb, 0xa6, 0xc7, 0xf4, 0x90, 0x50, 0xf6, 0xa5, 0x59, 0x5f,
0x9f, 0xe5, 0x57, 0x43, 0x34, 0x68, 0xda, 0x88, 0xb9, 0xc1, 0xdc, 0xe3, 0xec,
0xa5, 0x5d, 0x87, 0x1e, 0x01, 0x57, 0x0e, 0x51, 0xe8, 0x42, 0x5d, 0xf7, 0xd9,
0xcc, 0x31, 0xfa, 0x89, 0x11, 0x8a, 0xcf, 0x58, 0x2b, 0x8c, 0xb0, 0xd7, 0x35,
0x5d, 0xc6, 0x30, 0x75, 0x93, 0x60, 0x21, 0xae, 0x7f, 0x4d, 0xe9, 0x83, 0xb4,
0xee, 0x0a, 0xf0, 0x28, 0xbd, 0xe4, 0x9d, 0xfd, 0x40, 0xfc, 0x1c, 0xd2, 0xd9,
0x8a, 0x82, 0x8e, 0x36, 0x49, 0x5c, 0x6f, 0xae, 0x6e, 0x1a, 0x12, 0xbc, 0x7d,
0x1e, 0xeb, 0x24, 0xb5, 0x82, 0x11, 0x0f, 0xc0, 0x08, 0x62, 0x30, 0x06, 0x2c,
0x4a, 0xe1, 0x2c, 0x72, 0x61, 0x20, 0x61, 0x7d, 0xb0, 0x23, 0x98, 0x88, 0xfa,
0x4c, 0xaa, 0xa8, 0xee, 0x55, 0x16, 0x31, 0xa5, 0xfb, 0xb3, 0x87, 0x11, 0x82,
0xcc, 0x27, 0xc1, 0x31, 0xcc, 0x58, 0xaf, 0xaa, 0x31, 0xca, 0xc8, 0xeb, 0x62,
0x0b, 0x90, 0x41, 0x58, 0xa1, 0xb6, 0x10, 0xdb, 0x12, 0x21, 0x5d, 0x6b, 0xa1,
0x1b, 0xbd, 0x7b, 0xa9, 0x5e, 0xfa, 0xd4, 0x8e, 0x75, 0x5b, 0x4a, 0x68, 0xb5,
0xd7, 0x18, 0xfd, 0xd5, 0xf4, 0x45, 0xf9, 0x9b, 0x3b, 0x24, 0xf4, 0x7c, 0x62,
0xc1, 0x0b, 0xe9, 0x97, 0x63, 0xa2, 0xd4, 0xd6, 0xeb, 0x89, 0x65, 0x7d, 0x24,
0xd6, 0xf0, 0xf8, 0xfc, 0x6e, 0x03, 0x7a, 0xc1, 0xc8, 0xf6, 0x28, 0x91, 0x92,
0x54, 0x96, 0x96, 0x28, 0x98, 0x17, 0x74, 0x8c, 0x6c, 0xee, 0x4d, 0x84, 0x95,
0xcb, 0x1c, 0x57, 0x39, 0x28, 0x62, 0xf1, 0x58, 0x32, 0x5f, 0xf5, 0x3a, 0x83,
0xfc, 0x86, 0x92, 0x5a, 0xbc, 0x0a, 0x06, 0x08, 0x7d, 0x93, 0xc2, 0x21, 0x4a,
0xcf, 0x53, 0x4f, 0x84, 0x09, 0xd7, 0x96, 0xe6, 0xcd, 0x67, 0x4a, 0xd7, 0x6b,
0x84, 0x25, 0xe5, 0x3b, 0x17, 0x24, 0xc2, 0xee, 0xc2, 0x88, 0xbd, 0xd3, 0xe5,
0x53, 0xf3, 0xe6, 0x93, 0xa2, 0x17, 0x7e, 0x36, 0x8c, 0x13, 0x42, 0xf7, 0x30,
0x1a, 0xb6, 0x33, 0x85, 0xab, 0xb5, 0x60, 0x55, 0x56, 0xf9, 0x97, 0x60, 0x73,
0x95, 0x8f, 0xda, 0x38, 0x5b, 0xdf, 0xa8, 0xcd, 0x94, 0xfe, 0xfb, 0x10, 0x52,
0x90, 0x2a, 0x8f, 0x8d, 0xc0, 0x65, 0x18, 0x16, 0xf8, 0xa7, 0x69, 0x3e, 0xd3,
0xbb, 0x2c, 0xbd, 0x0e, 0xd4, 0xc6, 0xf0, 0x9d, 0x03, 0xd3, 0x63, 0xe4, 0xcf,
0xff, 0x86, 0x35, 0x6d, 0x2b, 0x29, 0x48, 0x54, 0xc7, 0xb4, 0xc0, 0x43, 0xce,
0xae, 0x93, 0xca, 0xe7, 0xf2, 0x67, 0x94, 0x87, 0x72, 0x52, 0x81, 0x64, 0x6e,
0xd9, 0xe3, 0x3b, 0x2a, 0xfc, 0x89, 0xb0, 0xe5, 0xdf, 0x90, 0x9d, 0xbf, 0xb2,
0x2a, 0x50, 0x6d, 0x5b, 0x75, 0x9e, 0x21, 0xd6, 0x46, 0x6d, 0x96, 0xf1, 0x3c,
0xc9, 0x76, 0xcc, 0x4a, 0x18, 0x56, 0x45, 0x3a, 0x9c, 0x57, 0xe5, 0x8f, 0x96,
0xe6, 0xec, 0x82, 0x77, 0x21, 0x91, 0x97, 0xbb, 0xd8, 0x5c, 0xe0, 0xd3, 0xf2,
0xaa, 0x06, 0xa9, 0x18, 0x00, 0x18, 0xc6, 0x76, 0x92, 0x93, 0x61, 0x46, 0x5e,
0x6d, 0x75, 0x25, 0x14, 0xcd, 0x9f, 0x9d, 0x16, 0x89, 0x5e, 0xea, 0xbd, 0x0f,
0x5c, 0x33, 0xb1, 0x75, 0x4a, 0xf8, 0xa8, 0xee, 0x79, 0x62, 0x78, 0x77, 0x44,
0x7d, 0x95, 0xa8, 0x16, 0xfa, 0x95, 0x82, 0x92, 0x35, 0x8f, 0xe7, 0xfa, 0x15,
0x5f, 0xf8, 0xaa, 0xba, 0x6d, 0x89, 0xad, 0x36, 0xc3, 0x9c, 0x44, 0x52, 0xcf,
0x9f, 0x35, 0xa7, 0xdc, 0x5d, 0xd0, 0x02, 0x7f, 0xba, 0xec, 0x43, 0x2d, 0xf0,
0xdc, 0x8a, 0x1f, 0xc1, 0x29, 0x38, 0xfa, 0xcb, 0xe9, 0x2b, 0xf1, 0xb3, 0x77,
0xa4, 0xe0, 0x4c, 0x89, 0x59, 0x27, 0xc5, 0x5d, 0x18, 0x42, 0xa1, 0x13, 0x6e,
0xdc, 0xc4, 0xe3, 0x2c, 0xe6, 0x86, 0x3e, 0x84, 0xcd, 0xc0, 0xce, 0xe3, 0x7f,
0x27, 0x2f, 0xb8, 0xec, 0xc3, 0xf0, 0xf6, 0xc2, 0xb2, 0x9a, 0xa2, 0x2c, 0x6b,
0xc7, 0xea, 0x78, 0xa4, 0x4e, 0xf5, 0x17, 0x96, 0xd4, 0xac, 0xe3, 0xc5, 0x2a,
0x09, 0xdf, 0xd1, 0x98, 0x82, 0xc3, 0x40, 0x08, 0x92, 0x23, 0x38, 0xc8, 0x0b,
0x5c, 0x68, 0x21, 0x9f, 0x23, 0x6f, 0x9a, 0x4f, 0xbd, 0xb3, 0x60, 0xfd, 0x2b,
0xe5, 0xe0, 0x29, 0x5b, 0xe6, 0x41, 0x52, 0xb9, 0x3a, 0xbc, 0x99, 0x7f, 0xb4,
0x26, 0x27, 0xa2, 0x5b, 0x8d, 0x73, 0xd6, 0x3c, 0xe9, 0x2d, 0x5e, 0xfe, 0xd0,
0xc8, 0x2d, 0x9a, 0xb7, 0xb0, 0x7c, 0x66, 0x7e, 0x56, 0x5d, 0x1e, 0xb7, 0x22,
0x39, 0x36, 0x29, 0xf4, 0x84, 0xae, 0xc8, 0xd2, 0xe7, 0x47, 0x50, 0x4f, 0xfa,
0xac, 0x28, 0xf1, 0xa4, 0x12, 0xe7, 0xe0, 0x12, 0x50, 0x96, 0x60, 0xc2, 0x67,
0xea, 0x94, 0x47, 0xa0, 0x24, 0x7f, 0x94, 0xc1, 0x79, 0x50, 0xd8, 0xe5, 0xfd,
0xd3, 0xc7, 0xf5, 0x2f, 0xfb, 0xa5, 0xfc, 0x83, 0x87, 0xa8, 0x77, 0xc1, 0x38,
0x78, 0xc9, 0xd4, 0x72, 0x70, 0x5f, 0x59, 0xb1, 0x3e, 0x40, 0x7d, 0x1e, 0x49,
0xfe, 0x4f, 0x36, 0x04, 0xf6, 0x53, 0x4e, 0xd1, 0x74, 0xbc, 0x23, 0xf0, 0x8e,
0xbc, 0xfb, 0x21, 0xd4, 0xc4, 0x18, 0x66, 0x72, 0xe2, 0x81, 0x28, 0x4d, 0x54,
0x67, 0xc2, 0xf9, 0x3a, 0xa5, 0xdc, 0x98, 0xed, 0x4e, 0x30, 0x85, 0x44, 0xfa,
0xd1, 0x51, 0x89, 0x12, 0xa8, 0x60, 0xe5, 0x86, 0x07, 0x03, 0xf1, 0x9c, 0x7b,
0xca, 0x56, 0x0b, 0xc9, 0x26, 0xa4, 0x1c, 0xbd, 0x8e, 0x3e, 0x08, 0xc0, 0xd6,
0x0b, 0xad, 0x97, 0x44, 0x24, 0x39, 0x46, 0x23, 0x51, 0x1e, 0xcc, 0x78, 0xb5,
0xcb, 0x64, 0x99, 0x6a, 0xe9, 0x64, 0x27, 0x8c, 0xd2, 0x5c, 0xad, 0x3a, 0xc7,
0xdc, 0xf2, 0x4c, 0x4d, 0x34, 0x5f, 0x79, 0xbc, 0xa1, 0x70, 0x9d, 0xe1, 0xa6,
0x49, 0x62, 0x4e, 0x78, 0x99, 0x6f, 0x69, 0xa2, 0xf2, 0xd9, 0x65, 0x73, 0x96,
0xbd, 0xb2, 0xf8, 0xa1, 0xc6, 0xce, 0x82, 0xbd, 0xfb, 0x5f, 0x1e, 0xa1, 0xc3,
0xae, 0x12, 0x50, 0xfc, 0xde, 0xf2, 0xb8, 0xae, 0xe5, 0x97, 0x59, 0x68, 0xe9,
0xb8, 0x9f, 0x6f, 0x0f, 0xe5, 0xea, 0x4e, 0xd2, 0x93, 0x22, 0x66, 0x22, 0x4a,
0x45, 0xc4, 0x99, 0x6b, 0xa9, 0xd7, 0xc9, 0x7e, 0xe0, 0xe2, 0x10, 0x78, 0xb4,
0xe8, 0x21, 0x85, 0xce, 0xc7, 0x79, 0x2b, 0x86, 0x08, 0x21, 0xad, 0x60, 0x78,
0x0c, 0x7a, 0x90, 0x1a, 0x92, 0xbd, 0x5c, 0x6c, 0x65, 0x15, 0x46, 0x20, 0x59,
0xb8, 0x97, 0xa8, 0x86, 0x42, 0x70, 0x4e, 0x29, 0xb2, 0x8b, 0x40, 0xa9, 0x49,
0x0f, 0xa2, 0xc3, 0xa8, 0x96, 0x57, 0x18, 0xc7, 0x50, 0xdc, 0xe8, 0xb1, 0x42,
0xf4, 0x3a, 0x89, 0x13, 0x43, 0x5a, 0xff, 0xf3, 0x38, 0x82, 0xc7, 0xc9, 0x55,
0xfc, 0xcd, 0x57, 0x50, 0x07, 0x5f, 0x4e, 0xf9, 0x5c, 0x97, 0x26, 0x3e, 0xf2,
0x82, 0x37, 0xa9, 0x0d, 0x91, 0x1b, 0xf0, 0x80, 0xc2, 0x00, 0xf2, 0x73, 0xa2,
0x94, 0x39, 0x1f, 0xdd, 0x4b, 0xbe, 0x87, 0x71, 0xbf, 0xd5, 0xf4, 0xe1, 0xc6,
0xac, 0xcc, 0xd2, 0x44, 0xd5, 0xd2, 0xe2, 0x50, 0xce, 0x03, 0x76, 0x98, 0xc6,
0x76, 0xbf, 0x3b, 0x7d, 0x97, 0xfd, 0xc3, 0xbb, 0x4c, 0x73, 0x85, 0xf6, 0xfc,
0x00, 0x2c, 0xf4, 0x40, 0x79, 0xc8, 0x63, 0x07, 0xc0, 0x0f, 0x89, 0x71, 0xba,
0x97, 0x55, 0x07, 0x9e, 0x58, 0x21, 0x9e, 0xdc, 0xb8, 0x7a, 0x95, 0x55, 0x52,
0xf9, 0x1f, 0xd2, 0x89, 0x19, 0x91, 0x3c, 0xa7, 0xfe, 0x4f, 0x68, 0x22, 0x25,
0x45, 0xec, 0x1e, 0x36, 0x8b, 0xb8, 0xcc, 0x54, 0xde, 0x5e, 0x2c, 0xc5, 0xc2,
0x8a, 0xd5, 0xbe, 0xa0, 0xb7, 0x96, 0x59, 0x0b, 0xac, 0xf2, 0x82, 0xe0, 0x8a,
0x12, 0x4f, 0x2a, 0x4b, 0xf1, 0x2a, 0x3e, 0xed, 0x21, 0x61, 0x07, 0xe9, 0x5e,
0x00, 0xe3, 0x08, 0x4d, 0xe6, 0x16, 0xe7, 0x79, 0x7b, 0x61, 0x41, 0x79, 0x28,
0x2b, 0x59, 0x5f, 0xad, 0xd0, 0x3f, 0xdb, 0x09, 0x85, 0x5a, 0x38, 0x4b, 0xb3,
0x1e, 0xd2, 0x2e, 0x56, 0x07, 0xf5, 0xa5, 0xdc, 0x5a, 0x37, 0x42, 0x7e, 0x8c,
0x2b, 0x8b, 0x8b, 0x1f, 0xab, 0xe3, 0x17, 0xe0, 0x53, 0xf8, 0x58, 0x03, 0x94,
0xe5, 0xab, 0x59, 0x9a, 0x06, 0x6c, 0x45, 0x05, 0x1d, 0x66, 0x2f, 0x72, 0xdd,
0x0e, 0xb1, 0x65, 0x69, 0x4c, 0x35, 0xd2, 0x0b, 0xd7, 0x1f, 0x61, 0xee, 0xe4,
0x1a, 0x4d, 0x26, 0xb4, 0xb8, 0x13, 0x77, 0xf6, 0x61, 0xb7, 0xf2, 0xb1, 0x2d,
0xcb, 0xf7, 0xc2, 0x5b, 0xc4, 0xaa, 0xff, 0xd8, 0xfc, 0xa0, 0x99, 0xa9, 0x63,
0xb3, 0xb2, 0x9b, 0x3e, 0xfe, 0xc6, 0x19, 0xf8, 0x0d, 0x1e, 0x86, 0x05, 0x2b,
0xf7, 0xc2, 0xcc, 0xe5, 0x1b, 0x20, 0x6f, 0x11, 0x44, 0x3e, 0x0f, 0x7a, 0x21,
0x3a, 0xb1, 0x85, 0x2f, 0x3e, 0x57, 0xb8, 0x3e, 0xf5, 0x2d, 0xb8, 0xaa, 0x4a,
0xd5, 0x3a, 0x04, 0x9c, 0x8a, 0x15, 0xdb, 0x28, 0xbe, 0xd9, 0x23, 0xba, 0x00,
0x97, 0xaf, 0x79, 0xe7, 0x2f, 0x01, 0x9d, 0xba, 0x97, 0xf3, 0x69, 0x6d, 0xf1,
0xd7, 0xa1, 0xb4, 0xdc, 0x9f, 0x2e, 0x7a, 0x65, 0xed, 0x66, 0x5f, 0x50, 0x7b,
0xc6, 0xb3, 0x23, 0xad, 0x3f, 0x57, 0x12, 0x5b, 0x94, 0x79, 0xab, 0x0f, 0xf2,
0x72, 0x17, 0x2c, 0x5e, 0x9a, 0xff, 0x2c, 0x2e, 0xde, 0xa5, 0x93, 0xf4, 0x87,
0xb7, 0xf1, 0x28, 0x65, 0xa9, 0x1c, 0x37, 0x33, 0xe7, 0x0a, 0x4d, 0x6c, 0x44,
0x06, 0xc6, 0x6e, 0x34, 0x97, 0x44, 0x13, 0x34, 0x18, 0x50, 0x4d, 0x96, 0x59,
0x79, 0x82, 0x4a, 0x36, 0x2c, 0x38, 0xf3, 0xfe, 0x23, 0xcc, 0x40, 0xbf, 0x4f,
0xad, 0x90, 0x12, 0x06, 0x3d, 0xe4, 0xc9, 0x74, 0x92, 0x17, 0x24, 0x5c, 0xdc,
0x83, 0xb0, 0xa5, 0x79, 0xa8, 0x16, 0x7e, 0x80, 0xac, 0x43, 0x8a, 0x56, 0x64,
0xae, 0xad, 0x29, 0x0c, 0xfb, 0x31, 0x76, 0x1d, 0x14, 0xf4, 0xa4, 0x15, 0x53,
0xa1, 0x26, 0x78, 0x95, 0x7e, 0x0a, 0x40, 0x64, 0x5f, 0x99, 0xae, 0x7d, 0x00,
0xf7, 0x4c, 0x2d, 0x46, 0x88, 0xbb, 0x8a, 0x42, 0xa3, 0xe5, 0x39, 0x87, 0xa7,
0xfa, 0xfd, 0x16, 0x96, 0x06, 0x93, 0x3c, 0xcd, 0xab, 0xeb, 0xb3, 0x12, 0x15,
0xb4, 0xb0, 0x2c, 0x96, 0x75, 0x45, 0x60, 0x13, 0xbe, 0x41, 0xf0, 0xa5, 0xbb,
0x12, 0xfd, 0x2f, 0xe1, 0xea, 0xcb, 0x60, 0x39, 0xcc, 0xf6, 0xa6, 0x72, 0x2e,
0xa0, 0xe3, 0x4a, 0x43, 0xbf, 0x03, 0xe9, 0x4b, 0xbb, 0xc8, 0x7e, 0x5c, 0xb3,
0xe6, 0x7b, 0xb0, 0x62, 0xcd, 0x53, 0xac, 0x5c, 0xaf, 0xfa, 0x02, 0xd0, 0x45,
0xf6, 0xe3, 0x3b, 0xe1, 0x71, 0x27, 0xbc, 0x6c, 0x76, 0x11, 0x77, 0x1a, 0xd6,
0x35, 0x83, 0xf1, 0xec, 0x36, 0xff, 0x5f, 0xc0, 0x96, 0xee, 0xdb, 0xd3, 0x37,
0xdb, 0x8f, 0x6e, 0x93, 0x25, 0xcf, 0xfb, 0x2a, 0x57, 0xbd, 0x0b, 0xab, 0xe8,
0xea, 0xed, 0x8f, 0x07, 0x5e, 0xfd, 0xf3, 0x45, 0x23, 0xba, 0x4f, 0xc9, 0x49,
0x79, 0x52, 0xe1, 0x58, 0x3c, 0xc5, 0xb2, 0xd3, 0x25, 0xb7, 0x58, 0x0c, 0xc6,
0xa0, 0x6e, 0x36, 0x38, 0xc4, 0x36, 0x54, 0xc3, 0xbf, 0x0f, 0x5e, 0xe9, 0x21,
0x1c, 0x76, 0x49, 0xd3, 0x76, 0x0d, 0x20, 0x6f, 0x5e, 0x45, 0x29, 0xe6, 0x61,
0x44, 0xb2, 0x3a, 0xe5, 0xbd, 0x4a, 0x23, 0xbc, 0xa6, 0x44, 0x5d, 0xb1, 0x8f,
0x08, 0x77, 0x9f, 0xd4, 0x8f, 0x7a, 0xc2, 0x08, 0x1b, 0x4a, 0x56, 0x22, 0xfb,
0x1c, 0x75, 0x38, 0xe4, 0x38, 0x9e, 0x54, 0x14, 0x63, 0x7e, 0x43, 0x75, 0xfc,
0x6d, 0xcc, 0x52, 0x0f, 0x92, 0xa6, 0xe5, 0x2a, 0x0b, 0xc5, 0x65, 0xb7, 0x5a,
0x84, 0x1c, 0x91, 0xee, 0x8e, 0x4f, 0x4d, 0x87, 0xd5, 0x2c, 0x28, 0x0d, 0x95,
0xb0, 0x60, 0x26, 0x87, 0xb8, 0x64, 0xd1, 0x13, 0x55, 0x8e, 0x9f, 0x64, 0xa7,
0xc7, 0xcc, 0x0c, 0x28, 0xb7, 0x88, 0xc7, 0x77, 0xf3, 0xaf, 0xa7, 0x0f, 0xea,
0xdf, 0xfe, 0x9a, 0xe8, 0x6c, 0x27, 0x18, 0xea, 0x46, 0x98, 0x04, 0x85, 0x0c,
0xe3, 0x89, 0xa9, 0x19, 0x76, 0x7b, 0x40, 0xf9, 0xf7, 0xef, 0x20, 0x6e, 0xdd,
0xad, 0x50, 0xab, 0xac, 0xd8, 0x28, 0xca, 0xd7, 0xb3, 0xd3, 0xa6, 0xa7, 0x8a,
0xe4, 0xd0, 0xa3, 0xf4, 0x24, 0x12, 0x8e, 0xbb, 0xcd, 0xf2, 0xb8, 0x94, 0x48,
0xb9, 0xb3, 0xf2, 0x93, 0x4b, 0x56, 0xe7, 0x7e, 0x06, 0xe4, 0x19, 0x22, 0xc1,
0xe8, 0x9a, 0x27, 0x42, 0x25, 0xfd, 0xec, 0x21, 0x2d, 0x14, 0x05, 0x44, 0x34,
0xcd, 0x30, 0x13, 0x22, 0xe4, 0x9d, 0xdd, 0x14, 0xeb, 0xc6, 0x6e, 0xc1, 0xa4,
0xa7, 0x35, 0x15, 0x35, 0xe1, 0x86, 0x03, 0x71, 0xd7, 0x57, 0x44, 0x4b, 0xf3,
0x56, 0xee, 0x62, 0x14, 0x77, 0x41, 0xfe, 0x03, 0x1a, 0xad, 0xa8, 0x89, 0xe8,
0x51, 0x1f, 0xa8, 0x7b, 0xa5, 0xc0, 0x06, 0xc1, 0xc9, 0x5d, 0xb0, 0x74, 0x4d,
0xdc, 0x91, 0xc4, 0x4c, 0xba, 0x58, 0x3f, 0xe0, 0x9c, 0xaa, 0xb8, 0x10, 0xe5,
0x25, 0xf3, 0x9e, 0x2c, 0x3d, 0x46, 0x3a, 0xbe, 0x0d, 0x9f, 0xf9, 0x36, 0x50,
0x38, 0xce, 0xd7, 0xeb, 0x4b, 0xa8, 0xa7, 0x54, 0x19, 0xf9, 0xc5, 0x23, 0x3c,
0x2d, 0xfc, 0x05, 0x4d, 0x3d, 0xee, 0xe5, 0xf3, 0x49, 0x01, 0x96, 0x54, 0xf9,
0xec, 0xca, 0xa0, 0xfe, 0x44, 0xaa, 0xa9, 0x9a, 0xce, 0x7c, 0xfc, 0x85, 0xdc,
0x70, 0xce, 0x71, 0xb6, 0xa8, 0x05, 0xae, 0xa1, 0xe1, 0xaa, 0x2a, 0x24, 0xd4,
0x99, 0x67, 0x70, 0x97, 0x6a, 0x2e, 0x2d, 0xce, 0x4f, 0x3c, 0x67, 0x2c, 0x79,
0xd6, 0x2d, 0xa4, 0xf3, 0x9f, 0xc3, 0xbc, 0xed, 0x1f, 0xf3, 0xad, 0xf8, 0x37,
0xe8, 0x40, 0x29, 0x82, 0x57, 0x6e, 0x7a, 0x6a, 0xeb, 0xec, 0x92, 0x6d, 0xcb,
0xb3, 0x52, 0x79, 0x4b, 0xc2, 0x74, 0xce, 0xbc, 0x85, 0x3d, 0xf0, 0x89, 0x2e,
0xe9, 0xe6, 0xc0, 0x90, 0x1e, 0xe5, 0xea, 0x07, 0xf4, 0x2b, 0xa3, 0x14, 0xa5,
0xea, 0x3f, 0xa9, 0xbd, 0x1e, 0xfd, 0xd8, 0x96, 0xc7, 0x82, 0x18, 0x4a, 0x3b,
0x91, 0x50, 0x81, 0xb2, 0x70, 0x6d, 0xb6, 0x59, 0xb7, 0x74, 0xd5, 0xac, 0x90,
0x56, 0x29, 0x3e, 0x61, 0x0a, 0x28, 0x65, 0xf5, 0xc1, 0x3a, 0xfd, 0xf9, 0x52,
0xff, 0x29, 0x2d, 0x42, 0xd2, 0x6c, 0x4e, 0xad, 0x96, 0x32, 0xa2, 0x9e, 0x39,
0xc5, 0x05, 0xce, 0x92, 0xac, 0x38, 0x3f, 0x7f, 0x78, 0xfa, 0x98, 0x7e, 0x75,
0x98, 0xba, 0x91, 0x1b, 0xe4, 0x6d, 0xd0, 0x80, 0x5c, 0x42, 0xc3, 0x94, 0x5e,
0x1f, 0xee, 0x11, 0x03, 0x2d, 0x30, 0x4a, 0x12, 0x48, 0x82, 0x8a, 0x65, 0xed,
0xc1, 0x7a, 0x80, 0x79, 0xa3, 0x40, 0xfe, 0xb5, 0xec, 0x42, 0xc5, 0xbc, 0x60,
0xd0, 0x22, 0x0c, 0xca, 0x0b, 0x54, 0x8f, 0xe3, 0x8c, 0x62, 0xed, 0x8a, 0xdb,
0xe0, 0xc3, 0xa8, 0xa2, 0x24, 0x48, 0x8e, 0x96, 0x7f, 0x0d, 0x4e, 0x63, 0xae,
0xae, 0xfa, 0xd3, 0x49, 0xac, 0x99, 0xed, 0x9d, 0x57, 0x51, 0x5c, 0xdd, 0x42,
0x0d, 0x55, 0x0c, 0xa1, 0x85, 0xa6, 0x46, 0x22, 0x71, 0xc7, 0x3f, 0x80, 0x20,
0xf6, 0xc0, 0x3d, 0x69, 0x5b, 0x2d, 0xbf, 0x1b, 0x8e, 0x11, 0x88, 0x97, 0x92,
0x9c, 0x7d, 0x8c, 0xaa, 0xc3, 0x84, 0xe8, 0x91, 0xa8, 0xe1, 0xcf, 0xcf, 0x71,
0xcc, 0x94, 0x93, 0x34, 0x0b, 0x0f, 0x09, 0x22, 0x50, 0x79, 0x0d, 0xe8, 0x0b,
0xd8, 0x0e, 0xad, 0x4c, 0x94, 0x56, 0x47, 0xa2, 0x56, 0xea, 0xbd, 0x8f, 0xdc,
0x7f, 0xa1, 0x5c, 0xe2, 0xdd, 0x23, 0xac, 0xf4, 0xf8, 0xd5, 0x7d, 0x52, 0x37,
0x89, 0xeb, 0x55, 0x41, 0xf9, 0x05, 0xed, 0xe7, 0x58, 0x3a, 0x8f, 0x17, 0x93,
0xe5, 0x79, 0x59, 0xbb, 0x60, 0xce, 0xcb, 0x75, 0x9b, 0x17, 0x42, 0x0d, 0x14,
0x9d, 0xc3, 0x1f, 0xe1, 0x52, 0xae, 0xef, 0x82, 0x97, 0x5f, 0xfc, 0x2c, 0xe4,
0xce, 0x7c, 0x17, 0xae, 0xc2, 0xcc, 0xdc, 0x82, 0xad, 0xe9, 0x97, 0x0b, 0x89,
0x51, 0x37, 0x08, 0x2f, 0xff, 0x35, 0x84, 0xb2, 0xd8, 0x8b, 0xc5, 0x7f, 0x5a,
0xf1, 0x62, 0xb0, 0x6a, 0xf6, 0x3d, 0xcd, 0x0c, 0x17, 0x66, 0x3f, 0xde, 0x30,
0x04, 0x5f, 0x83, 0x62, 0xd5, 0xf6, 0x97, 0xda, 0x7d, 0xc2, 0x4f, 0x31, 0xc5,
0x20, 0xaa, 0xdc, 0xc0, 0xe2, 0x36, 0x30, 0x80, 0x01, 0xd5, 0x7d, 0xbd, 0x98,
0x32, 0x67, 0x2f, 0xd8, 0x11, 0xa0, 0xf1, 0x18, 0x09, 0x1b, 0x3b, 0x45, 0x42,
0x5e, 0x89, 0xce, 0x23, 0xd2, 0x0c, 0x8e, 0x22, 0xae, 0x50, 0x29, 0xca, 0xc1,
0x15, 0xf4, 0x08, 0x24, 0x43, 0x1a, 0x9b, 0x5d, 0xa9, 0x83, 0x16, 0x30, 0xdd,
0x7e, 0xc9, 0x90, 0xa0, 0x51, 0xd4, 0xdd, 0xdd, 0x2c, 0xe7, 0xe1, 0xd1, 0x47,
0x88, 0xed, 0x28, 0xd1, 0x82, 0x03, 0x84, 0x51, 0xaa, 0x11, 0x0f, 0x3f, 0x36,
0xf5, 0x70, 0xcd, 0xb7, 0xc0, 0xb7, 0xfe, 0xf9, 0xad, 0xe6, 0x92, 0xaf, 0x41,
0xad, 0x58, 0x06, 0xb3, 0xd2, 0x96, 0xf3, 0xb1, 0xb5, 0x89, 0x4f, 0x2c, 0x4a,
0xe4, 0x34, 0x3e, 0xae, 0x99, 0xbe, 0xc7, 0x2f, 0x9a, 0x52, 0x91, 0xdf, 0x92,
0x7a, 0xca, 0xd8, 0xbe, 0x9e, 0xab, 0xec, 0x81, 0x84, 0x4d, 0xfd, 0x30, 0x12,
0x3c, 0x82, 0x5d, 0xc0, 0x6f, 0x22, 0x27, 0xda, 0x6d, 0x42, 0xae, 0xe0, 0x3e,
0xce, 0xf5, 0x61, 0x7e, 0x1f, 0xbe, 0x3e, 0x8a, 0xd9, 0x3c, 0x1d, 0x28, 0x93,
0xf2, 0x33, 0xab, 0x52, 0x91, 0xca, 0xfe, 0x36, 0x39, 0x83, 0x78, 0x66, 0xea,
0x25, 0x88, 0x49, 0xb8, 0xa7, 0x66, 0x7b, 0x8c, 0xa2, 0xdc, 0x48, 0x75, 0x26,
0xcb, 0x5e, 0x54, 0xa1, 0xea, 0xbd, 0x5a, 0x38, 0xdf, 0xc9, 0x56, 0x89, 0xbf,
0x34, 0x2b, 0xe2, 0x93, 0x0e, 0xce, 0x08, 0x57, 0xaa, 0x97, 0xa5, 0x9f, 0x99,
0x90, 0x42, 0x35, 0x59, 0x98, 0xcc, 0x25, 0x4e, 0x16, 0x51, 0xd3, 0x51, 0x10,
0x09, 0xcf, 0x10, 0x9e, 0x85, 0x23, 0x1d, 0xd3, 0x33, 0xf6, 0x37, 0x3a, 0x58,
0x33, 0x1e, 0xa5, 0x84, 0xb9, 0x41, 0xcb, 0x9b, 0x0b, 0x52, 0x6a, 0xa5, 0xf3,
0x8c, 0x61, 0x82, 0x7a, 0x3b, 0x9a, 0x86, 0x27, 0x66, 0x2a, 0x26, 0xbd, 0x02,
0xb0, 0x7e, 0x37, 0xdc, 0x64, 0xa2, 0xb2, 0x2e, 0x97, 0x3e, 0x86, 0x0d, 0x7a,
0x7e, 0x70, 0x6e, 0xd3, 0x1c, 0xdf, 0xea, 0x4d, 0x1e, 0xff, 0x00, 0x21, 0x4a,
0xb3, 0xd2, 0x18, 0xa3, 0xa5, 0x54, 0xa0, 0xcf, 0x8e, 0x37, 0xc3, 0xfb, 0xf0,
0xc2, 0xe3, 0x24, 0xcb, 0x89, 0x24, 0x37, 0xfd, 0xf9, 0x06, 0xc8, 0x0e, 0x65,
0x26, 0xc9, 0x86, 0x16, 0xc9, 0x15, 0xe3, 0x00, 0xf5, 0xfb, 0x34, 0x2d, 0x77,
0xe5, 0xc6, 0x57, 0xaa, 0x44, 0xea, 0x29, 0xc7, 0x5f, 0x39, 0xa3, 0xb6, 0x30,
0x9e, 0xd2, 0xcc, 0x8a, 0xcd, 0xd5, 0xe9, 0x67, 0x5e, 0x9c, 0x39, 0xb7, 0xd4,
0xc3, 0x5e, 0xff, 0x14, 0x98, 0x5b, 0xc3, 0xc9, 0xf9, 0x6d, 0x9c, 0x4b, 0x37,
0x8e, 0xb8, 0x08, 0x5f, 0xeb, 0xd5, 0x97, 0x89, 0x4c, 0xe3, 0xd3, 0xef, 0xfc,
0xdf, 0xdb, 0x9e, 0x68, 0x87, 0x8f, 0x60, 0x24, 0xbe, 0x68, 0xe5, 0x13, 0x75,
0xd7, 0x1f, 0x61, 0xe5, 0xca, 0xe7, 0xbe, 0x4b, 0xdf, 0xfc, 0x15, 0xf8, 0xdf,
0xc9, 0x4d, 0x86, 0xcc, 0x2f, 0x40, 0xad, 0xf5, 0xe2, 0x5b, 0xb6, 0xd9, 0x0a,
0xb3, 0xe6, 0xbe, 0x5d, 0x9d, 0x9d, 0x2e, 0xaa, 0x1c, 0x57, 0x5d, 0xd3, 0xa3,
0xb1, 0x48, 0x5e, 0x40, 0x2d, 0xbe, 0x88, 0x89, 0x36, 0x98, 0xca, 0x88, 0x4f,
0x51, 0x07, 0x69, 0x9a, 0x28, 0xcc, 0x6f, 0xf5, 0x23, 0xc5, 0xbb, 0x90, 0xbb,
0x4b, 0xf6, 0x9b, 0x2b, 0x4c, 0xdf, 0x29, 0xec, 0x24, 0xaa, 0xcb, 0xf2, 0x32,
0x59, 0x09, 0xed, 0x32, 0xb5, 0x7d, 0xa6, 0xba, 0x7a, 0x43, 0xd8, 0x52, 0x43,
0x5e, 0x29, 0xae, 0xa2, 0x18, 0x00, 0x00, 0x25, 0xee, 0x23, 0x87, 0xb0, 0x61,
0x06, 0x98, 0x64, 0x27, 0x72, 0x09, 0xc9, 0x23, 0x98, 0x9f, 0x2d, 0x3b, 0xdb,
0x03, 0x89, 0xb0, 0x27, 0xf7, 0xab, 0xfd, 0x70, 0xa0, 0x1f, 0x02, 0x0b, 0xee,
0x48, 0x05, 0x40, 0x2e, 0x92, 0x54, 0x60, 0x8e, 0x55, 0x0a, 0xda, 0xf2, 0x2d,
0x5e, 0xaa, 0xe1, 0x2c, 0xdf, 0xc2, 0xa6, 0x59, 0x96, 0xa3, 0xda, 0x2b, 0xce,
0xf1, 0xcb, 0x80, 0xd4, 0x3c, 0xd6, 0x3c, 0x7d, 0x74, 0x7f, 0xf7, 0x07, 0xf2,
0x2a, 0x5c, 0xa4, 0x8c, 0x29, 0x52, 0x0c, 0x76, 0xe1, 0x4e, 0x2d, 0xc2, 0x48,
0x4d, 0x7e, 0xb0, 0x88, 0xb2, 0x98, 0x1a, 0x09, 0x2d, 0x4c, 0x96, 0x36, 0x3c,
0xef, 0xcb, 0xaf, 0x88, 0x6e, 0xd3, 0x9e, 0x8d, 0x19, 0xe6, 0xc6, 0xb7, 0xea,
0x2b, 0x3f, 0xb4, 0x9d, 0x11, 0xf7, 0xa9, 0x39, 0xbd, 0xa2, 0x9f, 0x24, 0xb5,
0x56, 0x78, 0x2a, 0x3b, 0xc9, 0x6d, 0xba, 0xa2, 0xa4, 0x90, 0x39, 0x4f, 0x66,
0x6c, 0x9e, 0x58, 0xbd, 0x42, 0x9a, 0xbb, 0x99, 0x98, 0xce, 0xf3, 0x16, 0xcf,
0x19, 0x17, 0x49, 0x1f, 0x3a, 0x4a, 0x32, 0xa6, 0x6b, 0x7e, 0x01, 0x57, 0x51,
0x21, 0xd0, 0x2d, 0x65, 0x7c, 0x2b, 0xc9, 0x8e, 0x5a, 0xcc, 0x3a, 0xcd, 0xd7,
0xe2, 0x05, 0xd0, 0x9d, 0x87, 0x92, 0x20, 0x4d, 0x16, 0x4b, 0x46, 0x4c, 0x05,
0x40, 0xda, 0xd3, 0x1e, 0x89, 0xa2, 0x30, 0x38, 0xa5, 0x0e, 0x18, 0x61, 0x3e,
0xa6, 0x1f, 0x05, 0xdb, 0xd2, 0xaf, 0x52, 0xf8, 0x93, 0x25, 0x8f, 0x35, 0x05,
0x8b, 0x67, 0x4d, 0x7c, 0x63, 0xfa, 0x56, 0x7b, 0xff, 0x1b, 0x24, 0x98, 0x7e,
0xae, 0xbe, 0x6c, 0x71, 0x37, 0xfc, 0x3d, 0x04, 0x73, 0x23, 0x4f, 0x04, 0x2a,
0x4b, 0x84, 0x11, 0x89, 0xad, 0x74, 0x1b, 0x83, 0xd9, 0xdf, 0x82, 0x09, 0x0f,
0x3f, 0x02, 0xc3, 0xb0, 0x84, 0x29, 0xd2, 0xf2, 0x4a, 0x9b, 0x4d, 0xf6, 0x01,
0x74, 0xc2, 0x41, 0x44, 0x69, 0xac, 0xad, 0x41, 0x84, 0x65, 0x5e, 0x0a, 0x8e,
0xea, 0x3b, 0x47, 0xb6, 0x2a, 0x07, 0x01, 0xe7, 0x23, 0xe9, 0xe7, 0xc8, 0xaf,
0xf2, 0x1f, 0x1e, 0x42, 0x65, 0xc3, 0x2b, 0x31, 0x94, 0x25, 0x89, 0xf1, 0x48,
0x0b, 0xc7, 0x31, 0x20, 0xc3, 0xa6, 0xee, 0x2b, 0x09, 0xb9, 0xc0, 0x32, 0x74,
0x46, 0xd8, 0x97, 0x95, 0xd1, 0xa3, 0xa9, 0x63, 0xa4, 0x8f, 0x47, 0xf3, 0xb3,
0x78, 0x88, 0x99, 0xe2, 0x08, 0x34, 0x2b, 0x7e, 0x57, 0x87, 0x88, 0xdf, 0xe7,
0x71, 0x0c, 0xe2, 0x1b, 0x62, 0x57, 0x29, 0x71, 0xc2, 0xa9, 0x38, 0x0d, 0x08,
0xcd, 0x54, 0xba, 0x49, 0x90, 0x8b, 0x83, 0xef, 0xbc, 0xff, 0x36, 0xe7, 0x67,
0xe0, 0xac, 0xf4, 0xa2, 0xb6, 0x77, 0x07, 0x44, 0x2b, 0x6e, 0x3c, 0xc2, 0x1a,
0x9c, 0xef, 0xfd, 0x96, 0xda, 0xb5, 0x24, 0x1a, 0x2e, 0xf7, 0xe4, 0x2d, 0xdd,
0x03, 0x77, 0xa1, 0x45, 0xa5, 0x4d, 0xbe, 0xea, 0x8c, 0x16, 0x16, 0x40, 0x4b,
0xc5, 0xcb, 0x9d, 0x50, 0x71, 0x84, 0x28, 0x40, 0xb7, 0xe3, 0x4e, 0xaa, 0x9a,
0xae, 0x16, 0xd6, 0xfa, 0x4c, 0x23, 0xfd, 0x5c, 0x6e, 0xdd, 0xe3, 0xe1, 0x37,
0x1e, 0xcb, 0xf1, 0xbe, 0x4a, 0xe7, 0xac, 0xfa, 0x88, 0x68, 0x9a, 0x95, 0x1c,
0x86, 0x57, 0x16, 0x14, 0x66, 0xb2, 0xb2, 0xea, 0xd5, 0xfc, 0x48, 0x51, 0xc5,
0xe6, 0x39, 0x39, 0x8d, 0xf7, 0xa8, 0x1c, 0x05, 0x50, 0x0e, 0xc9, 0x52, 0xe4,
0x0f, 0x8d, 0xea, 0x21, 0x70, 0xdf, 0xf9, 0xb0, 0x2a, 0xf8, 0xea, 0x9c, 0x97,
0x9e, 0x7a, 0x63, 0xae, 0xb7, 0xf8, 0xe9, 0xba, 0xb9, 0xc4, 0x7a, 0x13, 0x3e,
0xfa, 0x01, 0x1c, 0x07, 0x5f, 0xa6, 0x68, 0xd5, 0x9f, 0xed, 0x58, 0x50, 0x5c,
0xfc, 0x5c, 0x7e, 0x38, 0x7d, 0x4b, 0x61, 0x79, 0x85, 0x49, 0x3d, 0x11, 0x2a,
0x73, 0x4c, 0x83, 0xb9, 0xd1, 0x40, 0x68, 0x8c, 0xd0, 0x07, 0xa8, 0x87, 0x50,
0x92, 0xa2, 0xe4, 0xa8, 0xb1, 0x47, 0x98, 0xed, 0xfd, 0xe6, 0x30, 0x1d, 0xa3,
0x14, 0x85, 0x2a, 0x1c, 0x1e, 0x64, 0xfb, 0x10, 0x6e, 0x49, 0x72, 0x32, 0x55,
0x05, 0x2c, 0x4f, 0x2c, 0xdc, 0x82, 0xf2, 0x4c, 0x57, 0x09, 0xd5, 0xa1, 0x9d,
0x65, 0xe7, 0x33, 0x8d, 0x19, 0x41, 0x15, 0xb5, 0x3e, 0x62, 0x81, 0x30, 0xcc,
0x7f, 0xa8, 0x6d, 0x9d, 0x7d, 0x47, 0x6a, 0x83, 0x36, 0x9a, 0x1f, 0xce, 0x6e,
0x9c, 0xe3, 0x4b, 0x17, 0xf4, 0x52, 0xae, 0xc0, 0x05, 0x3a, 0x33, 0xc1, 0x92,
0xbe, 0x46, 0x4f, 0x5e, 0x4a, 0x05, 0x12, 0x3f, 0xc8, 0x5f, 0x52, 0x58, 0xb3,
0x0c, 0x8f, 0xea, 0x74, 0x12, 0xf8, 0x24, 0x15, 0xe0, 0x89, 0x78, 0xc8, 0x43,
0x78, 0x55, 0xd2, 0x38, 0xe1, 0x03, 0x7a, 0xe9, 0xba, 0xf8, 0xaa, 0x6a, 0x55,
0xc9, 0x14, 0xd4, 0xf9, 0x1f, 0xdb, 0xfc, 0x6c, 0x4c, 0x29, 0x7b, 0xe9, 0x95,
0x45, 0xb3, 0x83, 0x8e, 0x5b, 0xbc, 0x1c, 0x36, 0x94, 0xad, 0xf1, 0xa7, 0xd7,
0xa9, 0xf3, 0x97, 0xbf, 0xee, 0xff, 0x04, 0x3a, 0xe0, 0x6b, 0x70, 0x52, 0x4f,
0xc4, 0x8a, 0xaf, 0xd1, 0xd1, 0x6b, 0xd3, 0xd7, 0xe3, 0x0f, 0x27, 0x48, 0x04,
0x73, 0xcf, 0xc1, 0x3f, 0x43, 0xb5, 0xb0, 0x3c, 0x09, 0xd3, 0x13, 0x49, 0xb0,
0x19, 0x24, 0x4d, 0x32, 0x2c, 0x16, 0xcc, 0x76, 0x8b, 0xd6, 0xeb, 0x39, 0x1a,
0x9d, 0x20, 0xe7, 0xd1, 0x72, 0x3c, 0x72, 0xb8, 0x72, 0x52, 0x2a, 0x53, 0x87,
0xa5, 0x4b, 0x95, 0x28, 0x2f, 0x4e, 0x12, 0x4f, 0xb4, 0x46, 0xca, 0xae, 0x19,
0xb5, 0x15, 0x54, 0xcb, 0x2d, 0xf0, 0xf0, 0xda, 0x31, 0x96, 0xd8, 0x09, 0x83,
0x20, 0x55, 0x63, 0x94, 0xfb, 0xee, 0xa0, 0xd0, 0x24, 0xbe, 0x72, 0x69, 0x69,
0x2b, 0x0c, 0x55, 0x95, 0x95, 0x99, 0x43, 0x0c, 0xd5, 0x55, 0x79, 0x3f, 0xb5,
0x83, 0xd4, 0xe0, 0x61, 0x1c, 0x65, 0x0c, 0x6c, 0xa5, 0x8d, 0x08, 0x82, 0x4e,
0xd0, 0x91, 0xf5, 0xac, 0x78, 0x90, 0x8a, 0x5e, 0x16, 0x46, 0x51, 0xb9, 0xb0,
0xb2, 0x31, 0xdb, 0x4c, 0x67, 0x1b, 0x59, 0x8b, 0x9e, 0x6e, 0x9a, 0x4d, 0x8c,
0xf2, 0x8a, 0xa9, 0x45, 0x0a, 0x6e, 0x11, 0x3d, 0x3f, 0x32, 0x7d, 0x4c, 0x9f,
0xff, 0x06, 0x59, 0x5f, 0x9d, 0xdd, 0xa1, 0x6f, 0x96, 0x3e, 0xe4, 0x3a, 0x21,
0x5b, 0xb6, 0x72, 0x7d, 0x08, 0x36, 0x2b, 0x7a, 0x07, 0x80, 0x6c, 0x27, 0x97,
0x83, 0xad, 0x86, 0xba, 0x71, 0x10, 0xa2, 0xa5, 0xd2, 0x5c, 0x93, 0xdd, 0x24,
0x4e, 0x25, 0x7b, 0xa9, 0x11, 0x1a, 0x0e, 0xf9, 0x4f, 0x4b, 0xc8, 0x71, 0x00,
0x0e, 0x00, 0x5b, 0x1c, 0x61, 0xfe, 0x14, 0xa8, 0xb6, 0x70, 0x7a, 0x39, 0xe1,
0xd4, 0x4e, 0x99, 0x26, 0x8d, 0x30, 0x78, 0xc8, 0x7a, 0xe1, 0x0d, 0xfc, 0xd7,
0x6f, 0xa2, 0x47, 0xe1, 0x9e, 0x3d, 0x64, 0x90, 0x5d, 0xc4, 0x7d, 0x5a, 0x32,
0xa6, 0x85, 0x99, 0x4f, 0xcb, 0xab, 0x1c, 0x43, 0xb8, 0xc8, 0xfd, 0x21, 0xaf,
0xea, 0xe8, 0xbe, 0x3e, 0x95, 0x52, 0x23, 0x0c, 0xcc, 0xc8, 0x44, 0x0d, 0xd2,
0x47, 0xee, 0x73, 0xcd, 0x26, 0x31, 0x55, 0x06, 0xeb, 0x53, 0xa9, 0x36, 0xb5,
0x5c, 0xc2, 0xbd, 0x3b, 0x95, 0x6e, 0x36, 0x0e, 0x13, 0x70, 0x5c, 0x04, 0xb2,
0x37, 0x65, 0x65, 0xd4, 0x40, 0x76, 0xdb, 0x23, 0x34, 0xd8, 0xef, 0x27, 0xa9,
0xb9, 0xae, 0xdb, 0x04, 0x1d, 0xf4, 0xe0, 0x87, 0x5f, 0x2b, 0x2f, 0x9f, 0x31,
0x02, 0x3d, 0xc0, 0x9a, 0xc6, 0xa9, 0x97, 0xfa, 0x50, 0xc9, 0x26, 0x90, 0x39,
0x08, 0x7d, 0xc6, 0xd6, 0x59, 0xf5, 0x1f, 0x79, 0x69, 0x75, 0x43, 0xca, 0xad,
0xf6, 0xae, 0xdc, 0x3a, 0x47, 0xa1, 0xab, 0xf4, 0x3c, 0xd0, 0x6a, 0x74, 0xcf,
0xe3, 0x8d, 0x36, 0xd8, 0x68, 0xef, 0xa3, 0x40, 0xfb, 0x80, 0x63, 0x1d, 0xbc,
0x09, 0xfc, 0xb4, 0x55, 0xbf, 0x7c, 0xb1, 0x3f, 0xa3, 0xff, 0x58, 0x52, 0x98,
0x39, 0x67, 0xfd, 0x82, 0x51, 0xf8, 0x36, 0xb8, 0xa1, 0x28, 0x59, 0x92, 0x34,
0x8b, 0x96, 0xcd, 0x6e, 0x9c, 0xcd, 0xc9, 0x01, 0x85, 0x31, 0xb3, 0xbe, 0x08,
0x7d, 0xae, 0x97, 0x39, 0xd9, 0x35, 0x33, 0x7d, 0xf9, 0xb8, 0x93, 0x60, 0x37,
0x61, 0xa8, 0x99, 0x06, 0x1c, 0xa0, 0x35, 0x46, 0x90, 0xf0, 0xd0, 0x39, 0xb8,
0x01, 0x97, 0x91, 0x28, 0x21, 0xe9, 0x26, 0x18, 0xe9, 0xc6, 0xb5, 0xd7, 0x91,
0x4b, 0x45, 0x6e, 0x49, 0x8a, 0x19, 0x7b, 0xef, 0x11, 0xd6, 0x7c, 0xbf, 0x47,
0x77, 0xb1, 0x90, 0xd0, 0x82, 0x9a, 0x6d, 0x60, 0x20, 0x8a, 0x6d, 0xe4, 0x18,
0x2a, 0x52, 0x70, 0x53, 0x26, 0x8c, 0xd3, 0x54, 0x53, 0xbc, 0x76, 0xca, 0x1f,
0x4b, 0x3f, 0x51, 0x6c, 0xeb, 0x89, 0x1c, 0xeb, 0x1a, 0xa1, 0xdc, 0xc4, 0x16,
0x96, 0xf0, 0xfa, 0x73, 0x31, 0xac, 0xc6, 0x4c, 0xcd, 0x29, 0x51, 0x2c, 0x8f,
0x95, 0x9e, 0x5a, 0x8f, 0x85, 0x64, 0xfb, 0xdb, 0xaf, 0x43, 0xab, 0xec, 0x47,
0xbf, 0x13, 0x10, 0x5e, 0x4d, 0x38, 0x44, 0x4b, 0x76, 0xc3, 0x49, 0x49, 0xb8,
0x0f, 0xf5, 0xac, 0xa6, 0xd9, 0x46, 0xcc, 0x53, 0x66, 0xd4, 0x2f, 0x9c, 0x3f,
0x3b, 0xe2, 0xad, 0x7d, 0xa2, 0xae, 0x78, 0xe1, 0x3c, 0x6b, 0x6e, 0xc6, 0x5c,
0xff, 0xa4, 0xc7, 0x93, 0xb6, 0x6e, 0x11, 0x0a, 0xb7, 0x68, 0xd0, 0x11, 0xe0,
0x35, 0x0b, 0xe9, 0x9c, 0x58, 0xed, 0xec, 0x00, 0x86, 0x2a, 0x52, 0x0e, 0xc9,
0x3a, 0xc0, 0x1d, 0x1f, 0x43, 0xd3, 0x17, 0xb7, 0xf4, 0x10, 0x0b, 0xf7, 0x93,
0xcb, 0xe4, 0xc8, 0xb9, 0xe9, 0xab, 0xf1, 0x9b, 0xe7, 0x48, 0x8a, 0x62, 0xd9,
0xf6, 0x67, 0xd4, 0xf4, 0xf2, 0x62, 0x6e, 0x95, 0x26, 0x43, 0x83, 0x1c, 0xc9,
0x18, 0x98, 0x1c, 0xb8, 0xc4, 0x85, 0xed, 0xb4, 0x67, 0xea, 0xf5, 0x56, 0x2d,
0x6e, 0xa0, 0xf4, 0x59, 0x0f, 0xe0, 0x8e, 0xe4, 0x14, 0x26, 0x35, 0xf1, 0x4e,
0xc6, 0x69, 0xe0, 0x3a, 0xbc, 0x4a, 0xa5, 0xe1, 0x66, 0x52, 0xe2, 0x0d, 0x71,
0x4f, 0x51, 0x69, 0x85, 0x7b, 0x1e, 0x3e, 0x05, 0xca, 0x63, 0x4e, 0x56, 0x56,
0x3b, 0x54, 0xcc, 0x91, 0xc7, 0xfd, 0x20, 0x45, 0xfc, 0x0c, 0xf2, 0xe6, 0x73,
0x8d, 0x4f, 0xac, 0x49, 0x09, 0x7f, 0x91, 0x0d, 0xe1, 0x80, 0x47, 0xad, 0x19,
0xd7, 0xd2, 0x71, 0x15, 0x85, 0xeb, 0x75, 0x2e, 0x90, 0xb5, 0xdb, 0x2d, 0xd2,
0x89, 0x84, 0x8d, 0x82, 0xf3, 0xa6, 0xce, 0xaf, 0x12, 0xd5, 0xa1, 0x37, 0xa0,
0x17, 0x88, 0x09, 0xa1, 0xb0, 0x25, 0xfd, 0x2d, 0x31, 0xfc, 0xd6, 0xeb, 0x12,
0x65, 0xde, 0xd8, 0x23, 0x45, 0xa3, 0x9f, 0x32, 0x39, 0x82, 0xa4, 0xa8, 0xe6,
0xec, 0xe7, 0x1f, 0x61, 0x7d, 0x70, 0x27, 0x09, 0x1c, 0xe6, 0x51, 0x97, 0x78,
0x0b, 0x83, 0xaa, 0x2f, 0xdb, 0x35, 0xce, 0x4a, 0x93, 0xb1, 0x0c, 0x56, 0xe0,
0xe2, 0xf2, 0xb5, 0x52, 0xf2, 0x01, 0xa3, 0xc2, 0xed, 0x16, 0x47, 0x2d, 0x13,
0x4d, 0x02, 0xaa, 0xc2, 0xe8, 0x01, 0x95, 0xa8, 0xfc, 0x90, 0x6a, 0x47, 0xe2,
0xae, 0x0a, 0x2e, 0xec, 0x81, 0x9b, 0x80, 0xed, 0xe2, 0x06, 0x92, 0xfd, 0x8c,
0x75, 0x28, 0x51, 0x6b, 0xad, 0xa9, 0x81, 0xe2, 0xed, 0x33, 0x74, 0xdd, 0x31,
0x95, 0x61, 0x84, 0x97, 0x16, 0xdf, 0x26, 0xf7, 0x2c, 0xb7, 0x60, 0xf1, 0xcc,
0x62, 0x61, 0xb0, 0x92, 0x90, 0x6a, 0x65, 0x2f, 0x11, 0x39, 0xd9, 0xcb, 0x82,
0x05, 0x96, 0xd1, 0x49, 0xfa, 0x61, 0x14, 0x5a, 0xed, 0x85, 0xdd, 0x30, 0x37,
0x61, 0xa6, 0x75, 0xb0, 0xf3, 0x0b, 0x34, 0xe3, 0x8e, 0x48, 0x79, 0x7c, 0xd1,
0x50, 0xb4, 0x8f, 0xab, 0x78, 0x86, 0xd6, 0x98, 0xd5, 0x55, 0x5c, 0x09, 0xfa,
0x8e, 0xcb, 0xbc, 0xb3, 0x1b, 0xf0, 0x10, 0x35, 0x24, 0x87, 0xa1, 0x1d, 0x7a,
0x88, 0xd7, 0xd2, 0xa0, 0xe3, 0x11, 0x4a, 0xf2, 0x0b, 0xef, 0x51, 0xe6, 0xe9,
0x80, 0x56, 0xea, 0xd3, 0x4c, 0xf4, 0xe6, 0x06, 0x35, 0xe3, 0x34, 0xb2, 0xeb,
0x08, 0x2a, 0x15, 0xc6, 0x29, 0xa0, 0xd8, 0xc6, 0x7c, 0xb3, 0x62, 0x20, 0x72,
0x67, 0x94, 0x96, 0x25, 0x2c, 0x9d, 0x78, 0x34, 0xb7, 0x48, 0x6a, 0xc7, 0x23,
0xa4, 0x9d, 0x25, 0x8c, 0xf8, 0x81, 0x17, 0xde, 0x7d, 0x21, 0xda, 0xe0, 0xb1,
0x66, 0x2f, 0x9a, 0x19, 0x50, 0x63, 0xde, 0x6e, 0xfa, 0x1a, 0x48, 0xde, 0x20,
0xaf, 0xed, 0xe3, 0xae, 0x43, 0x54, 0xea, 0xdf, 0x70, 0x15, 0x80, 0x9e, 0x36,
0x58, 0xa2, 0x3c, 0x3b, 0x50, 0x50, 0xbe, 0x7c, 0x95, 0x57, 0x59, 0xaa, 0x45,
0xca, 0x97, 0x92, 0xc7, 0xb6, 0x3b, 0x49, 0x2b, 0xa4, 0xcc, 0x9c, 0x3f, 0x77,
0x6a, 0xc2, 0xa7, 0xd1, 0x4e, 0x74, 0x4a, 0xa0, 0xc9, 0xe3, 0xe5, 0x05, 0x22,
0x22, 0xac, 0x68, 0x8d, 0x0e, 0xbe, 0x02, 0xbb, 0xd0, 0x28, 0xa2, 0xae, 0xa9,
0xcd, 0x5f, 0xd7, 0xca, 0x89, 0x4b, 0x79, 0xba, 0x3a, 0x70, 0x7e, 0x8a, 0x64,
0x00, 0xcf, 0xd3, 0x63, 0x3f, 0x9e, 0x3e, 0x75, 0x3f, 0xf8, 0x31, 0x21, 0x6a,
0xd0, 0x28, 0xcd, 0xe1, 0x3c, 0x6a, 0xa8, 0xa4, 0xd8, 0x63, 0xdd, 0xa0, 0xf3,
0x29, 0x90, 0x26, 0x18, 0x93, 0x49, 0x39, 0x2a, 0x9d, 0x23, 0x13, 0xea, 0x24,
0x61, 0xed, 0xcc, 0xbc, 0x8b, 0x27, 0xc0, 0x31, 0x89, 0x41, 0x05, 0x6f, 0x51,
0x66, 0xaf, 0xff, 0x22, 0x44, 0xe3, 0x2f, 0x3e, 0xae, 0x54, 0x3d, 0x6d, 0x61,
0x22, 0xd2, 0xf8, 0x69, 0xa8, 0x4f, 0x2c, 0x20, 0x8c, 0x35, 0x1a, 0xca, 0x0c,
0xa6, 0x29, 0x95, 0xcf, 0x05, 0x2e, 0x49, 0x52, 0xd7, 0x69, 0x54, 0xb6, 0x91,
0xb8, 0x2e, 0x55, 0x93, 0x26, 0x5a, 0xd0, 0x52, 0x29, 0xec, 0x80, 0xba, 0x5e,
0xe0, 0x06, 0x08, 0x72, 0x42, 0x5a, 0x16, 0x22, 0x75, 0x89, 0x14, 0x01, 0x67,
0x20, 0x40, 0x8e, 0x83, 0xad, 0x4b, 0x92, 0x20, 0xd2, 0xb0, 0x10, 0xeb, 0x1e,
0x36, 0x4b, 0x9d, 0xa9, 0xf6, 0xc8, 0xba, 0x8e, 0x79, 0x59, 0x40, 0xf2, 0xeb,
0xec, 0x5a, 0x92, 0x68, 0xe3, 0xb1, 0xa6, 0x67, 0x6d, 0xa4, 0x96, 0xbd, 0xf7,
0x11, 0x16, 0x92, 0xfe, 0xb2, 0x9d, 0x4c, 0xcd, 0x11, 0xba, 0xec, 0x73, 0x1f,
0xbf, 0xfd, 0xda, 0x61, 0x06, 0xca, 0xa2, 0xf2, 0xcc, 0x7c, 0x65, 0x09, 0xc0,
0xd6, 0x1e, 0xf8, 0xe9, 0x07, 0x28, 0xf0, 0x9c, 0x5f, 0x51, 0xb9, 0x54, 0x37,
0x7a, 0x8f, 0xb8, 0x48, 0x71, 0x0a, 0xc2, 0xf1, 0x9c, 0x69, 0xc5, 0x90, 0x9b,
0x86, 0x5a, 0x90, 0x3b, 0x68, 0x68, 0xa6, 0xea, 0x52, 0x73, 0x48, 0x7a, 0xac,
0x87, 0x04, 0xd9, 0x45, 0x3b, 0xa8, 0x2c, 0xae, 0x0e, 0x0a, 0x4c, 0xe5, 0x98,
0x13, 0x78, 0x1e, 0x76, 0xc2, 0xa4, 0xad, 0x61, 0x50, 0x49, 0xe8, 0x71, 0x54,
0xd7, 0xae, 0x56, 0x73, 0x6f, 0x09, 0xa2, 0xfb, 0xf4, 0x3b, 0xb2, 0x63, 0x1d,
0x7f, 0x88, 0xd9, 0x9a, 0xd5, 0x2f, 0x35, 0x9b, 0x3c, 0xf6, 0x70, 0x85, 0xf7,
0x40, 0xe9, 0xa6, 0x41, 0x62, 0xb7, 0xb3, 0x88, 0x85, 0x7e, 0x8b, 0x4a, 0xd3,
0x26, 0x4d, 0xfd, 0x7d, 0x1e, 0x49, 0x5a, 0x10, 0x4b, 0xba, 0x54, 0xe7, 0x81,
0x0b, 0x4a, 0xd0, 0x90, 0x1a, 0x8c, 0x45, 0x13, 0x1e, 0x71, 0x82, 0x11, 0x99,
0xc0, 0xfb, 0x30, 0xca, 0xf0, 0xc2, 0xe4, 0xf4, 0x81, 0xfe, 0xf3, 0x24, 0x91,
0x42, 0x64, 0xd0, 0xcc, 0xe8, 0x1c, 0xe2, 0x54, 0x62, 0x93, 0x1a, 0xe2, 0x3a,
0xcb, 0xd3, 0x6a, 0xfb, 0xe1, 0x1f, 0x01, 0xac, 0xf3, 0xf8, 0x80, 0x81, 0x30,
0x25, 0x89, 0xe9, 0xf9, 0xf1, 0xa4, 0xe3, 0xa9, 0x2a, 0x08, 0x7c, 0x62, 0x1b,
0x5d, 0x11, 0x0e, 0xfa, 0x6f, 0x4e, 0x2d, 0xcb, 0xd2, 0x7d, 0x68, 0x1f, 0x17,
0x4c, 0xa4, 0x98, 0x96, 0x29, 0x93, 0xe4, 0x17, 0xcc, 0x64, 0xa5, 0x6c, 0x6f,
0x29, 0x65, 0x1d, 0x74, 0xdb, 0x62, 0x80, 0xd3, 0x60, 0x10, 0x32, 0xca, 0x0c,
0xe2, 0x01, 0xc7, 0xa2, 0x41, 0xb0, 0x44, 0xa8, 0xe0, 0x2a, 0x41, 0xe4, 0x87,
0x45, 0x06, 0xf9, 0x39, 0xd9, 0xdb, 0x8e, 0xda, 0xad, 0xac, 0x34, 0x96, 0xcc,
0xa4, 0x79, 0xf5, 0x15, 0xb5, 0x41, 0x27, 0x2b, 0x9c, 0x36, 0xb2, 0x17, 0xcf,
0x9d, 0x1f, 0x55, 0x42, 0x59, 0xf4, 0xa2, 0x82, 0x32, 0xcf, 0x8b, 0xf9, 0xfb,
0x57, 0xe1, 0xf0, 0x55, 0x59, 0x04, 0xbb, 0xa4, 0x64, 0xdb, 0x8d, 0x32, 0x5e,
0xd3, 0xd8, 0xff, 0xde, 0x23, 0x60, 0xe6, 0x7b, 0x84, 0x6f, 0xa5, 0x8c, 0x36,
0x0e, 0xca, 0xc6, 0x1d, 0x87, 0x4e, 0x54, 0xc9, 0x01, 0xc9, 0x9c, 0x8a, 0x27,
0x62, 0xca, 0x52, 0xba, 0x8b, 0xb5, 0xeb, 0x05, 0x2e, 0x0e, 0x15, 0x52, 0xe9,
0x1e, 0x81, 0x09, 0x1a, 0xe4, 0x35, 0xb3, 0x62, 0x7e, 0xe5, 0x28, 0xf7, 0x08,
0x35, 0x9d, 0x8c, 0x31, 0x6f, 0x40, 0xa5, 0x01, 0x93, 0x5e, 0xa7, 0xd2, 0x61,
0x35, 0x42, 0x71, 0x42, 0xfa, 0x07, 0x58, 0xec, 0x7e, 0x47, 0x3a, 0xe6, 0xe3,
0xec, 0x38, 0xdc, 0xc7, 0x5b, 0x3a, 0x35, 0xa5, 0x30, 0x99, 0x5a, 0x59, 0xb5,
0xfd, 0xbc, 0x82, 0xd8, 0xa6, 0x49, 0x16, 0x67, 0x93, 0x4a, 0x8f, 0xe1, 0x32,
0xc1, 0xe9, 0x4d, 0x18, 0x01, 0x68, 0xa1, 0x9d, 0x8e, 0x99, 0xa7, 0x39, 0xd1,
0x7c, 0x16, 0xac, 0x99, 0x49, 0xd2, 0x3b, 0xb1, 0x57, 0xc2, 0xcd, 0x1e, 0x27,
0x66, 0x7a, 0x0b, 0xbd, 0x88, 0x46, 0x76, 0xc4, 0x8e, 0x9d, 0x10, 0x84, 0xa9,
0xfc, 0xd8, 0xd4, 0xdb, 0x87, 0xe4, 0x9c, 0xa2, 0x47, 0x43, 0x03, 0xd0, 0xc5,
0xce, 0x32, 0xd4, 0x37, 0x5c, 0xa0, 0xe4, 0xe4, 0x97, 0xa7, 0x47, 0x97, 0x0f,
0xbe, 0x4c, 0x55, 0x55, 0x1a, 0xb1, 0x5b, 0x88, 0xdd, 0xc2, 0x65, 0xe1, 0xc4,
0x04, 0x92, 0x1e, 0xc9, 0x0b, 0xb6, 0x65, 0x07, 0x6c, 0x1a, 0x3c, 0x49, 0xe0,
0x55, 0xbe, 0x65, 0x17, 0x48, 0x9b, 0x76, 0x54, 0x5a, 0x01, 0x64, 0xb4, 0xc3,
0x32, 0x44, 0x9e, 0x63, 0x45, 0x59, 0xa1, 0x61, 0xcc, 0xb5, 0x14, 0xd3, 0xdf,
0xe0, 0x75, 0xb3, 0x94, 0x23, 0x8a, 0xee, 0x86, 0x31, 0xc3, 0x41, 0xf5, 0x86,
0x3c, 0x01, 0xfb, 0x18, 0xb3, 0x51, 0xf8, 0x54, 0xa1, 0x89, 0x4d, 0x9b, 0xa0,
0x19, 0x46, 0x98, 0x4d, 0xbd, 0xb9, 0x9c, 0x78, 0x7c, 0x42, 0x7a, 0xd1, 0x0b,
0xe4, 0x05, 0x58, 0x7c, 0x41, 0x7a, 0xb0, 0xa9, 0x47, 0x66, 0x64, 0x27, 0x09,
0xa8, 0x1e, 0x2d, 0xb4, 0x1b, 0x7a, 0xf1, 0x3f, 0x97, 0xe2, 0x80, 0xbc, 0xfa,
0x04, 0xb0, 0x09, 0xa5, 0xc4, 0x09, 0x97, 0x7b, 0x57, 0x85, 0xe7, 0x46, 0x9e,
0x79, 0x73, 0xa6, 0xaf, 0xca, 0x1f, 0xcd, 0xf2, 0x45, 0x33, 0x85, 0x83, 0xfc,
0x30, 0xe0, 0xd4, 0xdb, 0xc2, 0x52, 0x08, 0x93, 0xa1, 0xaf, 0x4c, 0x9f, 0xc7,
0x2f, 0xbe, 0x27, 0x9b, 0x7c, 0x19, 0xca, 0x92, 0x66, 0x8a, 0x7e, 0x66, 0x4a,
0xc8, 0x76, 0x21, 0x08, 0xc9, 0xc2, 0xd7, 0x40, 0x4d, 0xd9, 0x92, 0xac, 0x89,
0x25, 0x54, 0x62, 0x5f, 0xc2, 0x4e, 0xd9, 0xf5, 0x64, 0xad, 0x54, 0x45, 0xfe,
0x29, 0x9c, 0x89, 0xcd, 0xe4, 0x85, 0x49, 0x16, 0x92, 0xae, 0xf6, 0x30, 0xf7,
0xb9, 0xba, 0x52, 0x92, 0xb0, 0x63, 0x1a, 0xc6, 0xb3, 0x5d, 0xd9, 0xd6, 0xb5,
0xd9, 0x8e, 0x95, 0xe3, 0x33, 0x9c, 0x39, 0x17, 0x28, 0xdb, 0xf4, 0xc6, 0x96,
0x5c, 0x0c, 0xb9, 0x88, 0xdf, 0x19, 0xc2, 0x7b, 0x26, 0x27, 0x57, 0x94, 0x13,
0x6a, 0x8b, 0x86, 0xa7, 0x29, 0xf6, 0x11, 0xbc, 0xad, 0x1c, 0x91, 0x79, 0x27,
0x3d, 0xa4, 0x93, 0xaa, 0xb8, 0xcf, 0x61, 0x3a, 0x49, 0xdb, 0x0c, 0xf7, 0xf8,
0x4d, 0xdd, 0x61, 0x2c, 0xed, 0xb5, 0xa4, 0x2c, 0x51, 0xed, 0x58, 0xbf, 0xc0,
0xfd, 0x78, 0x80, 0xc0, 0x03, 0x3a, 0x21, 0x20, 0x7f, 0xd3, 0x51, 0x22, 0x51,
0x68, 0xc9, 0x35, 0x4a, 0x14, 0xa9, 0x5e, 0x0f, 0x3c, 0x42, 0x06, 0xff, 0xf2,
0x4b, 0x74, 0x12, 0x09, 0x76, 0x61, 0x3f, 0x93, 0x32, 0x85, 0x9c, 0xc5, 0x3d,
0x9c, 0x73, 0xb8, 0x4b, 0xdb, 0xa5, 0xf1, 0x91, 0xed, 0xbc, 0x55, 0x0e, 0xd8,
0x1d, 0x6b, 0x21, 0x65, 0x75, 0xd5, 0xde, 0x98, 0x26, 0xac, 0xf8, 0xa8, 0xd4,
0xb8, 0x86, 0xe0, 0x7b, 0x18, 0x1f, 0x80, 0xb7, 0xcf, 0x32, 0x5f, 0x38, 0x30,
0x25, 0x13, 0x5b, 0xd4, 0x21, 0x09, 0x97, 0x07, 0x24, 0x6e, 0x49, 0xa9, 0x79,
0x8d, 0xde, 0x44, 0x72, 0x13, 0xe4, 0x2f, 0x43, 0xaa, 0x53, 0xb6, 0x24, 0x4b,
0x2b, 0x2a, 0x55, 0xcb, 0xe3, 0xc1, 0xb2, 0x80, 0x27, 0x65, 0x39, 0xa2, 0x2c,
0x91, 0x95, 0xf1, 0xb3, 0x54, 0x51, 0x8d, 0x7f, 0x48, 0x50, 0xd8, 0xc7, 0xe4,
0xa5, 0xe9, 0x4e, 0x90, 0x10, 0x2d, 0x73, 0x72, 0x02, 0x70, 0x2f, 0x92, 0x40,
0x18, 0x1c, 0x19, 0x07, 0x53, 0x49, 0x28, 0xac, 0xf9, 0xfc, 0x23, 0xc8, 0x45,
0x97, 0xa4, 0x86, 0xbb, 0x84, 0x65, 0xc5, 0x22, 0x33, 0x3a, 0xe0, 0x63, 0x96,
0x9d, 0x66, 0xfe, 0x41, 0xae, 0x07, 0x4c, 0xbf, 0x61, 0x07, 0x4e, 0x7e, 0x66,
0xfa, 0x3c, 0x7e, 0xeb, 0x33, 0x24, 0xe8, 0xc4, 0x72, 0x7c, 0xa6, 0x63, 0x78,
0xb5, 0xda, 0xa2, 0x9c, 0x14, 0x4a, 0xb7, 0x23, 0x1d, 0x33, 0x70, 0xe9, 0x04,
0xc8, 0x06, 0x8d, 0x80, 0xd8, 0xf1, 0xf5, 0x0f, 0x50, 0x56, 0x29, 0x5c, 0x70,
0x74, 0xec, 0x72, 0xa1, 0x4d, 0x53, 0x4e, 0xd0, 0x1e, 0xe3, 0x88, 0x71, 0x3a,
0xa8, 0x5b, 0x7e, 0xa7, 0xd5, 0x8f, 0x06, 0x91, 0xd0, 0x7b, 0x50, 0x30, 0x18,
0x63, 0xc3, 0x7c, 0x80, 0x8d, 0xb3, 0xc3, 0x4c, 0x21, 0x63, 0x06, 0x1c, 0xc5,
0x21, 0xce, 0x90, 0xab, 0x56, 0x33, 0xb9, 0x24, 0xe5, 0xe3, 0x45, 0x7e, 0xcf,
0xc9, 0x08, 0x53, 0x91, 0xbe, 0xdb, 0x0a, 0x83, 0xeb, 0xb7, 0xda, 0x94, 0x20,
0xd1, 0x14, 0x3b, 0xd1, 0x70, 0x92, 0x0a, 0x4d, 0x3a, 0xaf, 0x87, 0x0c, 0x9e,
0x7f, 0x11, 0x0f, 0x70, 0xe5, 0x10, 0x1e, 0x25, 0x52, 0xbd, 0x30, 0x7a, 0x56,
0x1a, 0x88, 0xeb, 0xb0, 0x4b, 0x13, 0x6a, 0x38, 0x1f, 0x82, 0x6e, 0x3c, 0xe2,
0xcf, 0x8f, 0x5f, 0xe7, 0x00, 0xfd, 0x4c, 0x6b, 0xc7, 0xc6, 0x56, 0x69, 0x86,
0x99, 0x3e, 0x84, 0xe4, 0x24, 0x51, 0x5c, 0x42, 0xc0, 0x6c, 0xfb, 0xcb, 0xe9,
0x03, 0xfe, 0x7d, 0x37, 0xd9, 0x8b, 0x53, 0x75, 0x4e, 0x16, 0x97, 0x0f, 0x93,
0x28, 0xa4, 0x3c, 0x1a, 0xaa, 0x6c, 0x90, 0x83, 0xa1, 0x19, 0x5c, 0xcb, 0xb2,
0x88, 0xad, 0x57, 0x16, 0x60, 0xb4, 0xb6, 0x44, 0x34, 0x54, 0x54, 0x55, 0x77,
0x90, 0xc6, 0xa9, 0x77, 0x58, 0x37, 0x32, 0x5a, 0x5a, 0x57, 0x0a, 0x1b, 0xff,
0xf6, 0xbb, 0xb8, 0x27, 0x05, 0xc6, 0xb8, 0x36, 0x22, 0xb0, 0x53, 0x13, 0xc7,
0xe9, 0xe5, 0x10, 0x18, 0xe2, 0x6c, 0x90, 0x61, 0x1b, 0xed, 0xf0, 0x20, 0xaa,
0x3d, 0x42, 0x66, 0x6d, 0x90, 0x0c, 0x33, 0x39, 0x02, 0x83, 0xbc, 0x19, 0x3a,
0xb4, 0x87, 0x30, 0x29, 0x81, 0x4e, 0xc6, 0x47, 0x61, 0x04, 0xd9, 0x31, 0xfe,
0x00, 0x77, 0x1c, 0x54, 0xf7, 0x60, 0xa7, 0x8d, 0xc4, 0x34, 0x94, 0x9b, 0x42,
0x62, 0x9f, 0xda, 0xc3, 0xf6, 0x02, 0xbc, 0xd9, 0xca, 0x0d, 0xd9, 0x53, 0xba,
0xfc, 0x9a, 0xbc, 0x19, 0x5b, 0x52, 0x69, 0x27, 0xa1, 0x63, 0xa2, 0xdd, 0x50,
0x74, 0x54, 0x6c, 0xe9, 0xc6, 0xd8, 0x1d, 0xfd, 0x14, 0xee, 0x46, 0x38, 0x21,
0x51, 0x53, 0x6a, 0x64, 0x0d, 0x6d, 0x2e, 0x91, 0xb0, 0xfb, 0x11, 0x1e, 0xba,
0x77, 0x13, 0x97, 0x34, 0xcb, 0x4e, 0xcc, 0xa4, 0x6a, 0x60, 0x82, 0x50, 0x8f,
0xe6, 0xd7, 0x63, 0xaa, 0xca, 0x48, 0xc0, 0x1c, 0xe3, 0x9e, 0x90, 0x88, 0x6b,
0x21, 0x7f, 0xcc, 0x97, 0x04, 0xd2, 0x30, 0xd7, 0x19, 0x26, 0xaf, 0xb5, 0x4b,
0xf3, 0x92, 0x5a, 0xb5, 0x26, 0xf2, 0x0f, 0x1f, 0x48, 0x1f, 0xb7, 0x2f, 0x0c,
0xdd, 0x78, 0x48, 0x74, 0x6b, 0x07, 0xbf, 0x06, 0x7f, 0xff, 0x15, 0xb8, 0x2a,
0xb9, 0x7c, 0xcc, 0x10, 0x13, 0x70, 0x80, 0x8d, 0x3b, 0xc8, 0xee, 0x61, 0x9f,
0x0b, 0x1d, 0xe2, 0x98, 0xec, 0x90, 0x8b, 0xfa, 0x29, 0x36, 0xe0, 0xc2, 0x65,
0xe5, 0xa0, 0xbd, 0xd7, 0x36, 0x4c, 0xee, 0xf7, 0xf1, 0xab, 0x42, 0xe6, 0xb5,
0x95, 0x11, 0x79, 0x86, 0xbd, 0x9c, 0x32, 0x76, 0x1f, 0xf7, 0x93, 0x87, 0xac,
0x87, 0xc0, 0xb0, 0x3a, 0xae, 0x85, 0x1d, 0xdd, 0x1a, 0x37, 0xf1, 0xf5, 0x41,
0x95, 0xb7, 0x4b, 0xf2, 0xb9, 0x4a, 0x0d, 0x29, 0x16, 0x88, 0x4f, 0x09, 0xd3,
0x8b, 0x5c, 0xd8, 0x41, 0x27, 0x92, 0x97, 0x29, 0x88, 0xd8, 0x21, 0x12, 0xf5,
0x39, 0xe0, 0xd7, 0x0e, 0x90, 0x58, 0x23, 0xe6, 0x16, 0xd7, 0x02, 0x44, 0x42,
0x97, 0x5b, 0xa6, 0x0f, 0xf9, 0x4b, 0x2d, 0x12, 0xb8, 0xf1, 0x9b, 0x7d, 0xa8,
0xb7, 0xb8, 0x47, 0x69, 0x73, 0x76, 0xb3, 0xc0, 0x31, 0xa7, 0xc7, 0x2f, 0x85,
0x4e, 0xab, 0xb8, 0xad, 0xf9, 0xae, 0xe8, 0x27, 0xd9, 0x43, 0x80, 0xeb, 0xda,
0x45, 0xe5, 0x2a, 0x39, 0xa5, 0x0f, 0xda, 0x37, 0x04, 0x90, 0xe2, 0x4e, 0x13,
0x3b, 0x0d, 0x29, 0x27, 0x8f, 0x1b, 0xa0, 0x9d, 0xd5, 0x18, 0x4e, 0xaa, 0xc7,
0x61, 0xea, 0x15, 0xf4, 0xfa, 0x3b, 0xea, 0x2d, 0x68, 0xc3, 0x2e, 0xaa, 0x80,
0x10, 0xf4, 0x04, 0x17, 0xae, 0x90, 0x80, 0x8c, 0x8e, 0x97, 0x58, 0xa3, 0xf8,
0x00, 0x56, 0x6c, 0x44, 0xfc, 0x6e, 0x1f, 0x8e, 0xcc, 0xea, 0xc2, 0x63, 0x7e,
0xd9, 0xe6, 0x1d, 0xfe, 0x36, 0xd1, 0x86, 0x97, 0x7c, 0x78, 0x8c, 0x5d, 0x31,
0x68, 0x37, 0x9e, 0x92, 0x2e, 0x93, 0xec, 0x36, 0x71, 0x4c, 0x16, 0xc8, 0x84,
0x21, 0x2d, 0x76, 0x1b, 0x0e, 0x73, 0xec, 0x91, 0x10, 0xd6, 0x1d, 0x04, 0x4a,
0xe9, 0xa0, 0x7e, 0x96, 0x5e, 0x24, 0x9d, 0x86, 0x01, 0x47, 0x38, 0x95, 0x14,
0x21, 0x11, 0x7b, 0x3f, 0xe4, 0xbf, 0xbd, 0x45, 0xd6, 0xf9, 0x37, 0xde, 0xc3,
0x8e, 0xe7, 0x3b, 0xcb, 0xf7, 0x94, 0xdd, 0xf4, 0x5f, 0x27, 0x87, 0x8d, 0x09,
0x4d, 0x21, 0x70, 0x3e, 0xb8, 0x5f, 0x4a, 0x7a, 0x49, 0x89, 0x70, 0x92, 0xe4,
0x5f, 0xff, 0xd4, 0x23, 0x2c, 0xd6, 0xf9, 0x24, 0xf9, 0xcd, 0x11, 0x60, 0xfd,
0x95, 0xd7, 0x72, 0xf6, 0x0b, 0xa0, 0x47, 0xcd, 0x07, 0x64, 0x8f, 0x32, 0x6f,
0x67, 0xfa, 0x0c, 0xc5, 0x21, 0x38, 0x80, 0x5d, 0x70, 0x07, 0x29, 0xde, 0xc7,
0x09, 0x9d, 0x4e, 0xd0, 0x4f, 0xfe, 0x1a, 0x0e, 0x66, 0x3a, 0x63, 0x63, 0x2b,
0x46, 0xb3, 0x46, 0x82, 0x53, 0x0b, 0xc9, 0x60, 0x17, 0x39, 0xaf, 0xff, 0xec,
0x7d, 0x38, 0xb1, 0x62, 0xbf, 0xff, 0x54, 0xf6, 0xcd, 0xe4, 0x03, 0xe5, 0x53,
0xef, 0xc1, 0xcd, 0xcf, 0xc1, 0x3e, 0xe5, 0x24, 0xff, 0xd7, 0x43, 0x92, 0xbf,
0x46, 0x61, 0x84, 0x7c, 0x64, 0x1f, 0xfc, 0x4f,
};
optimizesize void *__big5_decmap(void) {
return xloadzd(&__big5_decmap_ptr,
__big5_decmap_rodata,
14386, 19990, 16702, 2, 0xc97b9dedu); /* 43.0667% profit */
}
| 88,877 | 1,120 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/__jisx0213_2_emp_decmap.c | #include "libc/x/x.h"
/* clang-format off */
static _Atomic(void *) __jisx0213_2_emp_decmap_ptr;
static const unsigned char __jisx0213_2_emp_decmap_rodata[] = {
0xeb, 0x64, 0xf8, 0xf7, 0x1f, 0x1d, 0x2e, 0x02, 0x8b, 0x2d, 0x41, 0x93, 0x59,
0xc4, 0x88, 0xa9, 0x12, 0x19, 0x0a, 0x33, 0xe1, 0x97, 0x27, 0x07, 0x6a, 0x33,
0x23, 0xf3, 0x1a, 0x81, 0xbc, 0x42, 0xe6, 0x9f, 0x60, 0x31, 0x2f, 0x96, 0x7f,
0xff, 0x39, 0x59, 0x31, 0x75, 0x5c, 0x63, 0xd5, 0x60, 0x43, 0xf0, 0xfc, 0xd9,
0x91, 0xe5, 0xd8, 0x39, 0xfe, 0xfd, 0xb7, 0xe2, 0x40, 0xd7, 0xb1, 0x13, 0x4d,
0xa4, 0x86, 0x73, 0x2e, 0x27, 0x82, 0x77, 0x99, 0x0b, 0x44, 0xca, 0x72, 0x93,
0xe3, 0x7a, 0x57, 0xde, 0x87, 0xbc, 0xc8, 0xfc, 0xa9, 0x7c, 0xb9, 0x7c, 0xa8,
0x2a, 0x52, 0xc0, 0xfc, 0x78, 0x7e, 0xf2, 0x42, 0x87, 0x51, 0x08, 0x44, 0x86,
0x02, 0xc9, 0x6a, 0x21, 0x98, 0x58, 0x89, 0x10, 0xb2, 0x8a, 0x27, 0x42, 0xd7,
0x51, 0xf8, 0x7f, 0x81, 0x3c, 0x33, 0x61, 0x17, 0xe1, 0x23, 0xc2, 0xb8, 0xcc,
0xcc, 0x15, 0xc1, 0x2e, 0x7e, 0x5d, 0x14, 0xc1, 0xd6, 0xcc, 0x01, 0x91, 0xee,
0x62, 0xb8, 0x5d, 0xc6, 0x26, 0xee, 0x24, 0x4e, 0xdd, 0x94, 0x70, 0x58, 0x32,
0x4c, 0x06, 0x99, 0xaf, 0x2b, 0xeb, 0x2a, 0xfb, 0xef, 0x7f, 0x85, 0x6c, 0x92,
0x2c, 0x84, 0xbf, 0x50, 0x76, 0x8e, 0x2c, 0x4c, 0x6e, 0x12, 0x98, 0xb5, 0x1d,
0x48, 0x3e, 0x90, 0x35, 0x96, 0xc3, 0x6f, 0xae, 0x9c, 0x3c, 0x36, 0xd1, 0x32,
0x24, 0xd1, 0x5f, 0xf2, 0xd5, 0x8a, 0x18, 0xba, 0x94, 0x61, 0xac, 0xb5, 0xca,
0x94, 0xf9, 0xeb, 0xb3, 0x1a, 0xb1, 0x2a, 0xa3, 0x35, 0x50, 0xf9, 0xab, 0xe1,
0xfc, 0x7e, 0xcd, 0x1d, 0x5a, 0xf0, 0x14, 0xaf, 0x1d, 0xa0, 0x8d, 0xaa, 0xce,
0x0d, 0xc8, 0x97, 0xd5, 0x59, 0x06, 0x15, 0x55, 0xd1, 0x21, 0xd7, 0xa5, 0x0f,
0x75, 0xa9, 0x1a, 0x9f, 0x86, 0x5f, 0x0d, 0xb7, 0x19, 0x12, 0xaf, 0xbe, 0xc8,
0x18, 0x98, 0x17, 0x8d, 0x2f, 0x19, 0xc3, 0xf8, 0x17, 0x8c, 0x9f, 0x18, 0x5f,
0x05, 0xf3, 0x6e, 0x01, 0xc9, 0xfb, 0xc6, 0xd8, 0x75, 0x79, 0x99, 0x04, 0x9a,
0x78, 0x9b, 0x40, 0xd8, 0xa9, 0x26, 0xe4, 0xb9, 0xf4, 0x89, 0x49, 0x94, 0xe9,
0x14, 0x53, 0x62, 0x55, 0x5b, 0x9a, 0xb9, 0x9b, 0xfd, 0xfb, 0x6f, 0x61, 0x66,
0x65, 0x86, 0x4d, 0x56, 0xc6, 0x1c, 0x9b, 0x28, 0x0f, 0x9a, 0x68, 0x0a, 0x1a,
0xff, 0xbf, 0xf9, 0x73, 0x24, 0x11, 0x15, 0x0b, 0x18, 0xcb, 0xd6, 0x62, 0x86,
0x15, 0x21, 0xf7, 0xd4, 0xdb, 0x10, 0xeb, 0x72, 0x06, 0x5b, 0x62, 0x54, 0x39,
0x00, 0x55, 0xfd, 0xb2, 0xfd, 0x69, 0x7b, 0xd9, 0xb6, 0xce, 0x9e, 0x58, 0x93,
0xa7, 0x39, 0x20, 0xd8, 0xcc, 0x8e, 0xc4, 0xe9, 0x39, 0x06, 0x51, 0xe7, 0xb8,
0xc7, 0x99, 0x90, 0x4a, 0x4d, 0x37, 0x04, 0x7b, 0xa9, 0x1b, 0xe9, 0xf1, 0x3b,
0xcd, 0x83, 0xba, 0x25, 0x95, 0xaf, 0x57, 0x98, 0xf7, 0xbf, 0xff, 0xf9, 0xde,
0x30, 0xbe, 0x98, 0x0f, 0x3e, 0xd5, 0x22, 0xbe, 0xa4, 0x9a, 0xcf, 0xe7, 0x07,
0xa1, 0xcd, 0xfd, 0x60, 0x22, 0x59, 0x60, 0x56, 0xb7, 0x1f, 0x8e, 0x3c, 0x10,
0x00, 0xac, 0x23, 0x02, 0x40, 0x2c, 0xa5, 0xc0, 0x95, 0x81, 0xff, 0xfe, 0x3f,
0x0d, 0x3c, 0x1b, 0x08, 0x2d, 0xc5, 0x82, 0x20, 0xb4, 0x4f, 0x10, 0x21, 0x3b,
0xf5, 0x42, 0xb0, 0x89, 0xde, 0x0c, 0x21, 0xc6, 0xbd, 0xcb, 0x43, 0x49, 0x0f,
0xc3, 0x95, 0xe1, 0x5b, 0xc2, 0xaf, 0x44, 0x62, 0xcd, 0x8d, 0x51, 0x8f, 0xa3,
0xfe, 0xfd, 0xff, 0x18, 0x45, 0xd8, 0x8c, 0x4d, 0xd1, 0xd8, 0x44, 0xbd, 0x63,
0x52, 0x62, 0x88, 0x75, 0x85, 0x5e, 0x5c, 0x58, 0x5c, 0x6a, 0xdc, 0xbf, 0xff,
0x49, 0x71, 0x10, 0xfe, 0x0d, 0x20, 0x7d, 0x28, 0xee, 0x05, 0x90, 0x54, 0x8e,
0x07, 0xf1, 0x63, 0xe2, 0x91, 0x55, 0x3f, 0x88, 0xbf, 0x02, 0xe7, 0xf3, 0x24,
0xfc, 0x8e, 0x47, 0x35, 0x4b, 0x3c, 0x01, 0xc6, 0x4a, 0x48, 0xc0, 0x65, 0xdf,
0xdb, 0x04, 0xd2, 0x43, 0xaa, 0x20, 0xe9, 0xdf, 0xff, 0xb6, 0x24, 0x64, 0x11,
0x9f, 0x64, 0x70, 0x2a, 0x81, 0xe6, 0x66, 0xa6, 0x94, 0xba, 0x34, 0x98, 0xcc,
0x86, 0x34, 0xec, 0x66, 0xc8, 0xa6, 0xe3, 0xb7, 0xe3, 0x6e, 0xc6, 0xbf, 0xff,
0xaf, 0x80, 0x38, 0x30, 0x13, 0xc4, 0xcb, 0x07, 0x92, 0x77, 0x33, 0xa1, 0x29,
0x28, 0x0b, 0x59, 0x5d, 0x04, 0x12, 0xaf, 0x07, 0xcc, 0xde, 0x9e, 0x55, 0x9c,
0x83, 0xc5, 0xbc, 0x1c, 0x7c, 0xb6, 0xa5, 0xe6, 0x91, 0x16, 0x02, 0x53, 0xf2,
0xd1, 0x45, 0x7e, 0xe4, 0x7f, 0xcb, 0xff, 0x9e, 0x4f, 0x48, 0x1f, 0x6f, 0x21,
0xb8, 0xbc, 0x2e, 0xa4, 0x7e, 0xab, 0x15, 0x06, 0x6f, 0x17, 0xdf, 0x2a, 0x46,
0xe2, 0x83, 0xd9, 0x02, 0x25, 0x30, 0xbe, 0x67, 0x89, 0x68, 0x99, 0x48, 0xd9,
0xbf, 0xff, 0x86, 0x65, 0xa8, 0xba, 0x26, 0xa3, 0xf1, 0xf9, 0xca, 0x81, 0xe9,
0xad, 0x1c, 0xc2, 0x0e, 0x2a, 0x27, 0xce, 0xe6, 0xd6, 0x4a, 0x5c, 0x32, 0x2d,
0x55, 0xc4, 0x99, 0xb0, 0xb9, 0xfa, 0xdf, 0xff, 0x7d, 0xd5, 0xc7, 0xab, 0x77,
0xd4, 0x60, 0xca, 0x2d, 0xa8, 0x05, 0xfb, 0xa4, 0x0e, 0x59, 0x6c, 0x7b, 0x3d,
0xba, 0xaa, 0xae, 0x06, 0x04, 0x7b, 0x77, 0x03, 0x21, 0xfb, 0x9a, 0x9a, 0xe0,
0x2d, 0xa2, 0x26, 0xb4, 0xda, 0xb1, 0x05, 0xc6, 0x0a, 0x6d, 0xc1, 0x67, 0x42,
0x76, 0x2b, 0x84, 0x3e, 0xd1, 0x7a, 0xb2, 0x15, 0x6b, 0x0b, 0xb6, 0x0d, 0xdc,
0x9a, 0x6b, 0xa3, 0x2c, 0x4e, 0x3d, 0x3b, 0xdd, 0x3a, 0x51, 0x6c, 0xed, 0xc4,
0xad, 0xb6, 0xbd, 0xb3, 0x03, 0xab, 0xec, 0xae, 0xce, 0xdd, 0x38, 0x74, 0xc9,
0x75, 0x69, 0x76, 0x61, 0x13, 0x2f, 0xec, 0x72, 0xc6, 0x10, 0x9f, 0xd9, 0x75,
0x16, 0x49, 0xec, 0x49, 0xd7, 0xdd, 0x2e, 0xfc, 0x2e, 0x3f, 0xd8, 0xfd, 0xbe,
0x1b, 0x55, 0x44, 0xa0, 0x17, 0x6c, 0x36, 0x90, 0xfc, 0xdd, 0x2b, 0xdf, 0x07,
0x11, 0x33, 0x83, 0xd2, 0x9d, 0x40, 0xfa, 0x35, 0x10, 0x1b, 0xf5, 0xa3, 0xe5,
0xad, 0xfe, 0x05, 0x93, 0x36, 0x4e, 0x22, 0x36, 0xb4, 0x26, 0x4c, 0xc1, 0x14,
0x3b, 0x3f, 0x15, 0x4b, 0x2b, 0x65, 0x1a, 0xa6, 0xd8, 0x07, 0xb0, 0x98, 0xe4,
0x74, 0x08, 0x2f, 0x60, 0x3a, 0xa9, 0x31, 0x75, 0x6c, 0x46, 0xd1, 0x2c, 0x8a,
0x72, 0xef, 0x5c, 0xdb, 0x79, 0xb8, 0xe4, 0x44, 0x81, 0x32, 0x5d, 0x40, 0xec,
0x89, 0x45, 0xc5, 0x11, 0x24, 0xb1, 0x97, 0x60, 0xf6, 0xed, 0x79, 0xe7, 0xe6,
0x43, 0xf8, 0xfa, 0x0b, 0xfe, 0xfd, 0x97, 0x5a, 0x80, 0xac, 0xfa, 0x27, 0x98,
0xd7, 0xb4, 0x80, 0x7c, 0x77, 0x4a, 0x28, 0xc1, 0xcb, 0xdc, 0xc5, 0xc0, 0x56,
0xc1, 0x12, 0xe2, 0x74, 0x7d, 0x5c, 0x0a, 0xac, 0x1b, 0x96, 0x01, 0x5d, 0xb3,
0x0c, 0x5a, 0x5b, 0x2e, 0x03, 0x00,
};
optimizesize void *__jisx0213_2_emp_decmap(void) {
return xload(&__jisx0213_2_emp_decmap_ptr,
__jisx0213_2_emp_decmap_rodata,
942, 4106); /* 22.942% profit */
}
| 6,157 | 86 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/cjkcodecs/clinic/multibytecodec.inc | /* clang-format off */
/*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(_multibytecodec_MultibyteCodec_encode__doc__,
"encode($self, /, input, errors=None)\n"
"--\n"
"\n"
"Return an encoded string version of `input\'.\n"
"\n"
"\'errors\' may be given to set a different error handling scheme. Default is\n"
"\'strict\' meaning that encoding errors raise a UnicodeEncodeError. Other possible\n"
"values are \'ignore\', \'replace\' and \'xmlcharrefreplace\' as well as any other name\n"
"registered with codecs.register_error that can handle UnicodeEncodeErrors.");
#define _MULTIBYTECODEC_MULTIBYTECODEC_ENCODE_METHODDEF \
{"encode", (PyCFunction)_multibytecodec_MultibyteCodec_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,
PyObject *input,
const char *errors);
static PyObject *
_multibytecodec_MultibyteCodec_encode(MultibyteCodecObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"input", "errors", NULL};
static _PyArg_Parser _parser = {"O|z:encode", _keywords, 0};
PyObject *input;
const char *errors = NULL;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &errors)) {
goto exit;
}
return_value = _multibytecodec_MultibyteCodec_encode_impl(self, input, errors);
exit:
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteCodec_decode__doc__,
"decode($self, /, input, errors=None)\n"
"--\n"
"\n"
"Decodes \'input\'.\n"
"\n"
"\'errors\' may be given to set a different error handling scheme. Default is\n"
"\'strict\' meaning that encoding errors raise a UnicodeDecodeError. Other possible\n"
"values are \'ignore\' and \'replace\' as well as any other name registered with\n"
"codecs.register_error that is able to handle UnicodeDecodeErrors.\"");
#define _MULTIBYTECODEC_MULTIBYTECODEC_DECODE_METHODDEF \
{"decode", (PyCFunction)_multibytecodec_MultibyteCodec_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,
Py_buffer *input,
const char *errors);
static PyObject *
_multibytecodec_MultibyteCodec_decode(MultibyteCodecObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"input", "errors", NULL};
static _PyArg_Parser _parser = {"y*|z:decode", _keywords, 0};
Py_buffer input = {NULL, NULL};
const char *errors = NULL;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &errors)) {
goto exit;
}
return_value = _multibytecodec_MultibyteCodec_decode_impl(self, &input, errors);
exit:
/* Cleanup for input */
if (input.obj) {
PyBuffer_Release(&input);
}
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_encode__doc__,
"encode($self, /, input, final=False)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_ENCODE_METHODDEF \
{"encode", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,
PyObject *input,
int final);
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"input", "final", NULL};
static _PyArg_Parser _parser = {"O|i:encode", _keywords, 0};
PyObject *input;
int final = 0;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &final)) {
goto exit;
}
return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final);
exit:
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_reset__doc__,
"reset($self, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_RESET_METHODDEF \
{"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalEncoder_reset__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_reset_impl(MultibyteIncrementalEncoderObject *self);
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_reset(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
{
return _multibytecodec_MultibyteIncrementalEncoder_reset_impl(self);
}
PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_decode__doc__,
"decode($self, /, input, final=False)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_DECODE_METHODDEF \
{"decode", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
Py_buffer *input,
int final);
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"input", "final", NULL};
static _PyArg_Parser _parser = {"y*|i:decode", _keywords, 0};
Py_buffer input = {NULL, NULL};
int final = 0;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &final)) {
goto exit;
}
return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final);
exit:
/* Cleanup for input */
if (input.obj) {
PyBuffer_Release(&input);
}
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_reset__doc__,
"reset($self, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_RESET_METHODDEF \
{"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalDecoder_reset__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_reset_impl(MultibyteIncrementalDecoderObject *self);
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_reset(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
{
return _multibytecodec_MultibyteIncrementalDecoder_reset_impl(self);
}
PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_read__doc__,
"read($self, sizeobj=None, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READ_METHODDEF \
{"read", (PyCFunction)_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
PyObject *sizeobj);
static PyObject *
_multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject *self, PyObject **args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *sizeobj = Py_None;
if (!_PyArg_UnpackStack(args, nargs, "read",
0, 1,
&sizeobj)) {
goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj);
exit:
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readline__doc__,
"readline($self, sizeobj=None, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINE_METHODDEF \
{"readline", (PyCFunction)_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
PyObject *sizeobj);
static PyObject *
_multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject *self, PyObject **args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *sizeobj = Py_None;
if (!_PyArg_UnpackStack(args, nargs, "readline",
0, 1,
&sizeobj)) {
goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj);
exit:
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readlines__doc__,
"readlines($self, sizehintobj=None, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINES_METHODDEF \
{"readlines", (PyCFunction)_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
PyObject *sizehintobj);
static PyObject *
_multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject *self, PyObject **args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *sizehintobj = Py_None;
if (!_PyArg_UnpackStack(args, nargs, "readlines",
0, 1,
&sizehintobj)) {
goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj);
exit:
return return_value;
}
PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_reset__doc__,
"reset($self, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_RESET_METHODDEF \
{"reset", (PyCFunction)_multibytecodec_MultibyteStreamReader_reset, METH_NOARGS, _multibytecodec_MultibyteStreamReader_reset__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_reset_impl(MultibyteStreamReaderObject *self);
static PyObject *
_multibytecodec_MultibyteStreamReader_reset(MultibyteStreamReaderObject *self, PyObject *Py_UNUSED(ignored))
{
return _multibytecodec_MultibyteStreamReader_reset_impl(self);
}
PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_write__doc__,
"write($self, strobj, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITE_METHODDEF \
{"write", (PyCFunction)_multibytecodec_MultibyteStreamWriter_write, METH_O, _multibytecodec_MultibyteStreamWriter_write__doc__},
PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_writelines__doc__,
"writelines($self, lines, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITELINES_METHODDEF \
{"writelines", (PyCFunction)_multibytecodec_MultibyteStreamWriter_writelines, METH_O, _multibytecodec_MultibyteStreamWriter_writelines__doc__},
PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_reset__doc__,
"reset($self, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_RESET_METHODDEF \
{"reset", (PyCFunction)_multibytecodec_MultibyteStreamWriter_reset, METH_NOARGS, _multibytecodec_MultibyteStreamWriter_reset__doc__},
static PyObject *
_multibytecodec_MultibyteStreamWriter_reset_impl(MultibyteStreamWriterObject *self);
static PyObject *
_multibytecodec_MultibyteStreamWriter_reset(MultibyteStreamWriterObject *self, PyObject *Py_UNUSED(ignored))
{
return _multibytecodec_MultibyteStreamWriter_reset_impl(self);
}
PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
"__create_codec($module, arg, /)\n"
"--\n"
"\n");
#define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
{"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
/*[clinic end generated code: output=dc2352619de9d74f input=a9049054013a1b77]*/
| 12,243 | 335 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/_multiprocessing/multiprocessing.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Python 3 â
â https://docs.python.org/3/license.html â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "third_party/python/Include/yoink.h"
#include "third_party/python/Modules/_multiprocessing/multiprocessing.h"
/* clang-format off */
PYTHON_PROVIDE("_multiprocessing");
PYTHON_PROVIDE("_multiprocessing.flags");
/*
* Extension module used by multiprocessing package
*
* multiprocessing.c
*
* Copyright (c) 2006-2008, R Oudkerk
* Licensed to PSF under a Contributor Agreement.
*/
/*
* Function which raises exceptions based on error codes
*/
PyObject *
_PyMp_SetError(PyObject *Type, int num)
{
switch (num) {
#ifdef MS_WINDOWS
case MP_STANDARD_ERROR:
if (Type == NULL)
Type = PyExc_OSError;
PyErr_SetExcFromWindowsErr(Type, 0);
break;
case MP_SOCKET_ERROR:
if (Type == NULL)
Type = PyExc_OSError;
PyErr_SetExcFromWindowsErr(Type, WSAGetLastError());
break;
#else /* !MS_WINDOWS */
case MP_STANDARD_ERROR:
case MP_SOCKET_ERROR:
if (Type == NULL)
Type = PyExc_OSError;
PyErr_SetFromErrno(Type);
break;
#endif /* !MS_WINDOWS */
case MP_MEMORY_ERROR:
PyErr_NoMemory();
break;
case MP_EXCEPTION_HAS_BEEN_SET:
break;
default:
PyErr_Format(PyExc_RuntimeError,
"unknown error number %d", num);
}
return NULL;
}
#ifdef MS_WINDOWS
static PyObject *
multiprocessing_closesocket(PyObject *self, PyObject *args)
{
HANDLE handle;
int ret;
if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = closesocket((SOCKET) handle);
Py_END_ALLOW_THREADS
if (ret)
return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
Py_RETURN_NONE;
}
static PyObject *
multiprocessing_recv(PyObject *self, PyObject *args)
{
HANDLE handle;
int size, nread;
PyObject *buf;
if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size))
return NULL;
buf = PyBytes_FromStringAndSize(NULL, size);
if (!buf)
return NULL;
Py_BEGIN_ALLOW_THREADS
nread = recv((SOCKET) handle, PyBytes_AS_STRING(buf), size, 0);
Py_END_ALLOW_THREADS
if (nread < 0) {
Py_DECREF(buf);
return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
}
_PyBytes_Resize(&buf, nread);
return buf;
}
static PyObject *
multiprocessing_send(PyObject *self, PyObject *args)
{
HANDLE handle;
Py_buffer buf;
int ret, length;
if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf))
return NULL;
length = (int)Py_MIN(buf.len, INT_MAX);
Py_BEGIN_ALLOW_THREADS
ret = send((SOCKET) handle, buf.buf, length, 0);
Py_END_ALLOW_THREADS
PyBuffer_Release(&buf);
if (ret < 0)
return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
return PyLong_FromLong(ret);
}
#endif
/*
* Function table
*/
static PyMethodDef module_methods[] = {
#ifdef MS_WINDOWS
{"closesocket", multiprocessing_closesocket, METH_VARARGS, ""},
{"recv", multiprocessing_recv, METH_VARARGS, ""},
{"send", multiprocessing_send, METH_VARARGS, ""},
#endif
#if !defined(POSIX_SEMAPHORES_NOT_ENABLED) && !defined(__ANDROID__)
{"sem_unlink", _PyMp_sem_unlink, METH_VARARGS, ""},
#endif
{NULL}
};
/*
* Initialize
*/
static struct PyModuleDef multiprocessing_module = {
PyModuleDef_HEAD_INIT,
"_multiprocessing",
NULL,
-1,
module_methods,
NULL,
NULL,
NULL,
NULL
};
PyMODINIT_FUNC
PyInit__multiprocessing(void)
{
PyObject *module, *temp, *value = NULL;
/* Initialize module */
module = PyModule_Create(&multiprocessing_module);
if (!module)
return NULL;
#if defined(MS_WINDOWS) || \
(defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED))
/* Add _PyMp_SemLock type to module */
if (PyType_Ready(&_PyMp_SemLockType) < 0)
return NULL;
Py_INCREF(&_PyMp_SemLockType);
{
PyObject *py_sem_value_max;
/* Some systems define SEM_VALUE_MAX as an unsigned value that
* causes it to be negative when used as an int (NetBSD). */
if ((int)(SEM_VALUE_MAX) < 0)
py_sem_value_max = PyLong_FromLong(INT_MAX);
else
py_sem_value_max = PyLong_FromLong(SEM_VALUE_MAX);
if (py_sem_value_max == NULL)
return NULL;
PyDict_SetItemString(_PyMp_SemLockType.tp_dict, "SEM_VALUE_MAX",
py_sem_value_max);
}
PyModule_AddObject(module, "SemLock", (PyObject*)&_PyMp_SemLockType);
#endif
/* Add configuration macros */
temp = PyDict_New();
if (!temp)
return NULL;
#define ADD_FLAG(name) \
value = Py_BuildValue("i", name); \
if (value == NULL) { Py_DECREF(temp); return NULL; } \
if (PyDict_SetItemString(temp, #name, value) < 0) { \
Py_DECREF(temp); Py_DECREF(value); return NULL; } \
Py_DECREF(value)
#if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)
ADD_FLAG(HAVE_SEM_OPEN);
#endif
#ifdef HAVE_SEM_TIMEDWAIT
ADD_FLAG(HAVE_SEM_TIMEDWAIT);
#endif
#ifdef HAVE_BROKEN_SEM_GETVALUE
ADD_FLAG(HAVE_BROKEN_SEM_GETVALUE);
#endif
#ifdef HAVE_BROKEN_SEM_UNLINK
ADD_FLAG(HAVE_BROKEN_SEM_UNLINK);
#endif
if (PyModule_AddObject(module, "flags", temp) < 0)
return NULL;
return module;
}
_Section(".rodata.pytab.1") const struct _inittab _PyImport_Inittab__multiprocessing = {
"_multiprocessing",
PyInit__multiprocessing,
};
| 6,500 | 232 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/_multiprocessing/semaphore.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Python 3 â
â https://docs.python.org/3/license.html â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/sysv/consts/o.h"
#include "libc/thread/semaphore.h"
#include "third_party/python/Modules/_multiprocessing/multiprocessing.h"
/* clang-format off */
/*
* A type which wraps a semaphore
*
* semaphore.c
*
* Copyright (c) 2006-2008, R Oudkerk
* Licensed to PSF under a Contributor Agreement.
*/
enum { RECURSIVE_MUTEX, SEMAPHORE };
typedef struct {
PyObject_HEAD
SEM_HANDLE handle;
long last_tid;
int count;
int maxvalue;
int kind;
char *name;
} SemLockObject;
#define ISMINE(o) (o->count > 0 && PyThread_get_thread_ident() == o->last_tid)
#ifdef MS_WINDOWS
/*
* Windows definitions
*/
#define SEM_FAILED NULL
#define SEM_CLEAR_ERROR() SetLastError(0)
#define SEM_GET_LAST_ERROR() GetLastError()
#define SEM_CREATE(name, val, max) CreateSemaphore(NULL, val, max, NULL)
#define SEM_CLOSE(sem) (CloseHandle(sem) ? 0 : -1)
#define SEM_GETVALUE(sem, pval) _GetSemaphoreValue(sem, pval)
#define SEM_UNLINK(name) 0
static int
_GetSemaphoreValue(HANDLE handle, long *value)
{
long previous;
switch (WaitForSingleObjectEx(handle, 0, FALSE)) {
case WAIT_OBJECT_0:
if (!ReleaseSemaphore(handle, 1, &previous))
return MP_STANDARD_ERROR;
*value = previous + 1;
return 0;
case WAIT_TIMEOUT:
*value = 0;
return 0;
default:
return MP_STANDARD_ERROR;
}
}
static PyObject *
semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
{
int blocking = 1;
double timeout;
PyObject *timeout_obj = Py_None;
DWORD res, full_msecs, nhandles;
HANDLE handles[2], sigint_event;
static char *kwlist[] = {"block", "timeout", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
&blocking, &timeout_obj))
return NULL;
/* calculate timeout */
if (!blocking) {
full_msecs = 0;
} else if (timeout_obj == Py_None) {
full_msecs = INFINITE;
} else {
timeout = PyFloat_AsDouble(timeout_obj);
if (PyErr_Occurred())
return NULL;
timeout *= 1000.0; /* convert to millisecs */
if (timeout < 0.0) {
timeout = 0.0;
} else if (timeout >= 0.5 * INFINITE) { /* 25 days */
PyErr_SetString(PyExc_OverflowError,
"timeout is too large");
return NULL;
}
full_msecs = (DWORD)(timeout + 0.5);
}
/* check whether we already own the lock */
if (self->kind == RECURSIVE_MUTEX && ISMINE(self)) {
++self->count;
Py_RETURN_TRUE;
}
/* check whether we can acquire without releasing the GIL and blocking */
if (WaitForSingleObjectEx(self->handle, 0, FALSE) == WAIT_OBJECT_0) {
self->last_tid = GetCurrentThreadId();
++self->count;
Py_RETURN_TRUE;
}
/* prepare list of handles */
nhandles = 0;
handles[nhandles++] = self->handle;
if (_PyOS_IsMainThread()) {
sigint_event = _PyOS_SigintEvent();
assert(sigint_event != NULL);
handles[nhandles++] = sigint_event;
}
else {
sigint_event = NULL;
}
/* do the wait */
Py_BEGIN_ALLOW_THREADS
if (sigint_event != NULL)
ResetEvent(sigint_event);
res = WaitForMultipleObjectsEx(nhandles, handles, FALSE, full_msecs, FALSE);
Py_END_ALLOW_THREADS
/* handle result */
switch (res) {
case WAIT_TIMEOUT:
Py_RETURN_FALSE;
case WAIT_OBJECT_0 + 0:
self->last_tid = GetCurrentThreadId();
++self->count;
Py_RETURN_TRUE;
case WAIT_OBJECT_0 + 1:
errno = EINTR;
return PyErr_SetFromErrno(PyExc_IOError);
case WAIT_FAILED:
return PyErr_SetFromWindowsErr(0);
default:
PyErr_Format(PyExc_RuntimeError, "WaitForSingleObject() or "
"WaitForMultipleObjects() gave unrecognized "
"value %d", res);
return NULL;
}
}
static PyObject *
semlock_release(SemLockObject *self, PyObject *args)
{
if (self->kind == RECURSIVE_MUTEX) {
if (!ISMINE(self)) {
PyErr_SetString(PyExc_AssertionError, "attempt to "
"release recursive lock not owned "
"by thread");
return NULL;
}
if (self->count > 1) {
--self->count;
Py_RETURN_NONE;
}
assert(self->count == 1);
}
if (!ReleaseSemaphore(self->handle, 1, NULL)) {
if (GetLastError() == ERROR_TOO_MANY_POSTS) {
PyErr_SetString(PyExc_ValueError, "semaphore or lock "
"released too many times");
return NULL;
} else {
return PyErr_SetFromWindowsErr(0);
}
}
--self->count;
Py_RETURN_NONE;
}
#else /* !MS_WINDOWS */
/*
* Unix definitions
*/
#define SEM_CLEAR_ERROR()
#define SEM_GET_LAST_ERROR() 0
#define SEM_CREATE(name, val, max) sem_open(name, O_CREAT | O_EXCL, 0600, val)
#define SEM_CLOSE(sem) sem_close(sem)
#define SEM_GETVALUE(sem, pval) sem_getvalue(sem, pval)
#define SEM_UNLINK(name) sem_unlink(name)
/* OS X 10.4 defines SEM_FAILED as -1 instead of (sem_t *)-1; this gives
compiler warnings, and (potentially) undefined behaviour. */
#ifdef __APPLE__
# undef SEM_FAILED
# define SEM_FAILED ((sem_t *)-1)
#endif
#ifndef HAVE_SEM_UNLINK
# define sem_unlink(name) 0
#endif
#ifndef HAVE_SEM_TIMEDWAIT
# define sem_timedwait(sem,deadline) sem_timedwait_save(sem,deadline,_save)
static int
sem_timedwait_save(sem_t *sem, struct timespec *deadline, PyThreadState *_save)
{
int res;
unsigned long delay, difference;
struct timeval now, tvdeadline, tvdelay;
errno = 0;
tvdeadline.tv_sec = deadline->tv_sec;
tvdeadline.tv_usec = deadline->tv_nsec / 1000;
for (delay = 0 ; ; delay += 1000) {
/* poll */
if (sem_trywait(sem) == 0)
return 0;
else if (errno != EAGAIN)
return MP_STANDARD_ERROR;
/* get current time */
if (gettimeofday(&now, NULL) < 0)
return MP_STANDARD_ERROR;
/* check for timeout */
if (tvdeadline.tv_sec < now.tv_sec ||
(tvdeadline.tv_sec == now.tv_sec &&
tvdeadline.tv_usec <= now.tv_usec)) {
errno = ETIMEDOUT;
return MP_STANDARD_ERROR;
}
/* calculate how much time is left */
difference = (tvdeadline.tv_sec - now.tv_sec) * 1000000 +
(tvdeadline.tv_usec - now.tv_usec);
/* check delay not too long -- maximum is 20 msecs */
if (delay > 20000)
delay = 20000;
if (delay > difference)
delay = difference;
/* sleep */
tvdelay.tv_sec = delay / 1000000;
tvdelay.tv_usec = delay % 1000000;
if (select(0, NULL, NULL, NULL, &tvdelay) < 0)
return MP_STANDARD_ERROR;
/* check for signals */
Py_BLOCK_THREADS
res = PyErr_CheckSignals();
Py_UNBLOCK_THREADS
if (res) {
errno = EINTR;
return MP_EXCEPTION_HAS_BEEN_SET;
}
}
}
#endif /* !HAVE_SEM_TIMEDWAIT */
static PyObject *
semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
{
int blocking = 1, res, err = 0;
double timeout;
PyObject *timeout_obj = Py_None;
struct timespec deadline = {0};
struct timeval now;
long sec, nsec;
static char *kwlist[] = {"block", "timeout", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
&blocking, &timeout_obj))
return NULL;
if (self->kind == RECURSIVE_MUTEX && ISMINE(self)) {
++self->count;
Py_RETURN_TRUE;
}
if (timeout_obj != Py_None) {
timeout = PyFloat_AsDouble(timeout_obj);
if (PyErr_Occurred())
return NULL;
if (timeout < 0.0)
timeout = 0.0;
if (gettimeofday(&now, NULL) < 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
sec = (long) timeout;
nsec = (long) (1e9 * (timeout - sec) + 0.5);
deadline.tv_sec = now.tv_sec + sec;
deadline.tv_nsec = now.tv_usec * 1000 + nsec;
deadline.tv_sec += (deadline.tv_nsec / 1000000000);
deadline.tv_nsec %= 1000000000;
}
do {
Py_BEGIN_ALLOW_THREADS
if (blocking && timeout_obj == Py_None)
res = sem_wait(self->handle);
else if (!blocking)
res = sem_trywait(self->handle);
else
res = sem_timedwait(self->handle, &deadline);
Py_END_ALLOW_THREADS
err = errno;
if (res == MP_EXCEPTION_HAS_BEEN_SET)
break;
} while (res < 0 && errno == EINTR && !PyErr_CheckSignals());
if (res < 0) {
errno = err;
if (errno == EAGAIN || errno == ETIMEDOUT)
Py_RETURN_FALSE;
else if (errno == EINTR)
return NULL;
else
return PyErr_SetFromErrno(PyExc_OSError);
}
++self->count;
self->last_tid = PyThread_get_thread_ident();
Py_RETURN_TRUE;
}
static PyObject *
semlock_release(SemLockObject *self, PyObject *args)
{
if (self->kind == RECURSIVE_MUTEX) {
if (!ISMINE(self)) {
PyErr_SetString(PyExc_AssertionError, "attempt to "
"release recursive lock not owned "
"by thread");
return NULL;
}
if (self->count > 1) {
--self->count;
Py_RETURN_NONE;
}
assert(self->count == 1);
} else {
#ifdef HAVE_BROKEN_SEM_GETVALUE
/* We will only check properly the maxvalue == 1 case */
if (self->maxvalue == 1) {
/* make sure that already locked */
if (sem_trywait(self->handle) < 0) {
if (errno != EAGAIN) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
/* it is already locked as expected */
} else {
/* it was not locked so undo wait and raise */
if (sem_post(self->handle) < 0) {
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
PyErr_SetString(PyExc_ValueError, "semaphore "
"or lock released too many "
"times");
return NULL;
}
}
#else
int sval;
/* This check is not an absolute guarantee that the semaphore
does not rise above maxvalue. */
if (sem_getvalue(self->handle, &sval) < 0) {
return PyErr_SetFromErrno(PyExc_OSError);
} else if (sval >= self->maxvalue) {
PyErr_SetString(PyExc_ValueError, "semaphore or lock "
"released too many times");
return NULL;
}
#endif
}
if (sem_post(self->handle) < 0)
return PyErr_SetFromErrno(PyExc_OSError);
--self->count;
Py_RETURN_NONE;
}
#endif /* !MS_WINDOWS */
/*
* All platforms
*/
static PyObject *
newsemlockobject(PyTypeObject *type, SEM_HANDLE handle, int kind, int maxvalue,
char *name)
{
SemLockObject *self;
self = PyObject_New(SemLockObject, type);
if (!self)
return NULL;
self->handle = handle;
self->kind = kind;
self->count = 0;
self->last_tid = 0;
self->maxvalue = maxvalue;
self->name = name;
return (PyObject*)self;
}
static PyObject *
semlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
SEM_HANDLE handle = SEM_FAILED;
int kind, maxvalue, value, unlink;
PyObject *result;
char *name, *name_copy = NULL;
static char *kwlist[] = {"kind", "value", "maxvalue", "name", "unlink",
NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "iiisi", kwlist,
&kind, &value, &maxvalue, &name, &unlink))
return NULL;
if (kind != RECURSIVE_MUTEX && kind != SEMAPHORE) {
PyErr_SetString(PyExc_ValueError, "unrecognized kind");
return NULL;
}
if (!unlink) {
name_copy = PyMem_Malloc(strlen(name) + 1);
if (name_copy == NULL) {
return PyErr_NoMemory();
}
strcpy(name_copy, name);
}
SEM_CLEAR_ERROR();
handle = SEM_CREATE(name, value, maxvalue);
/* On Windows we should fail if GetLastError()==ERROR_ALREADY_EXISTS */
if (handle == SEM_FAILED || SEM_GET_LAST_ERROR() != 0)
goto failure;
if (unlink && SEM_UNLINK(name) < 0)
goto failure;
result = newsemlockobject(type, handle, kind, maxvalue, name_copy);
if (!result)
goto failure;
return result;
failure:
if (handle != SEM_FAILED)
SEM_CLOSE(handle);
PyMem_Free(name_copy);
if (!PyErr_Occurred()) {
_PyMp_SetError(NULL, MP_STANDARD_ERROR);
}
return NULL;
}
static PyObject *
semlock_rebuild(PyTypeObject *type, PyObject *args)
{
SEM_HANDLE handle;
int kind, maxvalue;
char *name, *name_copy = NULL;
if (!PyArg_ParseTuple(args, F_SEM_HANDLE "iiz",
&handle, &kind, &maxvalue, &name))
return NULL;
if (name != NULL) {
name_copy = PyMem_Malloc(strlen(name) + 1);
if (name_copy == NULL)
return PyErr_NoMemory();
strcpy(name_copy, name);
}
#ifndef MS_WINDOWS
if (name != NULL) {
handle = sem_open(name, 0);
if (handle == SEM_FAILED) {
PyMem_Free(name_copy);
return PyErr_SetFromErrno(PyExc_OSError);
}
}
#endif
return newsemlockobject(type, handle, kind, maxvalue, name_copy);
}
static void
semlock_dealloc(SemLockObject* self)
{
if (self->handle != SEM_FAILED)
SEM_CLOSE(self->handle);
PyMem_Free(self->name);
PyObject_Del(self);
}
static PyObject *
semlock_count(SemLockObject *self)
{
return PyLong_FromLong((long)self->count);
}
static PyObject *
semlock_ismine(SemLockObject *self)
{
/* only makes sense for a lock */
return PyBool_FromLong(ISMINE(self));
}
static PyObject *
semlock_getvalue(SemLockObject *self)
{
#ifdef HAVE_BROKEN_SEM_GETVALUE
PyErr_SetNone(PyExc_NotImplementedError);
return NULL;
#else
int sval;
if (SEM_GETVALUE(self->handle, &sval) < 0)
return _PyMp_SetError(NULL, MP_STANDARD_ERROR);
/* some posix implementations use negative numbers to indicate
the number of waiting threads */
if (sval < 0)
sval = 0;
return PyLong_FromLong((long)sval);
#endif
}
static PyObject *
semlock_iszero(SemLockObject *self)
{
#ifdef HAVE_BROKEN_SEM_GETVALUE
if (sem_trywait(self->handle) < 0) {
if (errno == EAGAIN)
Py_RETURN_TRUE;
return _PyMp_SetError(NULL, MP_STANDARD_ERROR);
} else {
if (sem_post(self->handle) < 0)
return _PyMp_SetError(NULL, MP_STANDARD_ERROR);
Py_RETURN_FALSE;
}
#else
int sval;
if (SEM_GETVALUE(self->handle, &sval) < 0)
return _PyMp_SetError(NULL, MP_STANDARD_ERROR);
return PyBool_FromLong((long)sval == 0);
#endif
}
static PyObject *
semlock_afterfork(SemLockObject *self)
{
self->count = 0;
Py_RETURN_NONE;
}
/*
* Semaphore methods
*/
static PyMethodDef semlock_methods[] = {
{"acquire", (PyCFunction)semlock_acquire, METH_VARARGS | METH_KEYWORDS,
"acquire the semaphore/lock"},
{"release", (PyCFunction)semlock_release, METH_NOARGS,
"release the semaphore/lock"},
{"__enter__", (PyCFunction)semlock_acquire, METH_VARARGS | METH_KEYWORDS,
"enter the semaphore/lock"},
{"__exit__", (PyCFunction)semlock_release, METH_VARARGS,
"exit the semaphore/lock"},
{"_count", (PyCFunction)semlock_count, METH_NOARGS,
"num of `acquire()`s minus num of `release()`s for this process"},
{"_is_mine", (PyCFunction)semlock_ismine, METH_NOARGS,
"whether the lock is owned by this thread"},
{"_get_value", (PyCFunction)semlock_getvalue, METH_NOARGS,
"get the value of the semaphore"},
{"_is_zero", (PyCFunction)semlock_iszero, METH_NOARGS,
"returns whether semaphore has value zero"},
{"_rebuild", (PyCFunction)semlock_rebuild, METH_VARARGS | METH_CLASS,
""},
{"_after_fork", (PyCFunction)semlock_afterfork, METH_NOARGS,
"rezero the net acquisition count after fork()"},
{NULL}
};
/*
* Member table
*/
static PyMemberDef semlock_members[] = {
{"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), READONLY,
""},
{"kind", T_INT, offsetof(SemLockObject, kind), READONLY,
""},
{"maxvalue", T_INT, offsetof(SemLockObject, maxvalue), READONLY,
""},
{"name", T_STRING, offsetof(SemLockObject, name), READONLY,
""},
{NULL}
};
/*
* Semaphore type
*/
PyTypeObject _PyMp_SemLockType = {
PyVarObject_HEAD_INIT(NULL, 0)
/* tp_name */ "_multiprocessing.SemLock",
/* tp_basicsize */ sizeof(SemLockObject),
/* tp_itemsize */ 0,
/* tp_dealloc */ (destructor)semlock_dealloc,
/* tp_print */ 0,
/* tp_getattr */ 0,
/* tp_setattr */ 0,
/* tp_reserved */ 0,
/* tp_repr */ 0,
/* tp_as_number */ 0,
/* tp_as_sequence */ 0,
/* tp_as_mapping */ 0,
/* tp_hash */ 0,
/* tp_call */ 0,
/* tp_str */ 0,
/* tp_getattro */ 0,
/* tp_setattro */ 0,
/* tp_as_buffer */ 0,
/* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
/* tp_doc */ "Semaphore/Mutex type",
/* tp_traverse */ 0,
/* tp_clear */ 0,
/* tp_richcompare */ 0,
/* tp_weaklistoffset */ 0,
/* tp_iter */ 0,
/* tp_iternext */ 0,
/* tp_methods */ semlock_methods,
/* tp_members */ semlock_members,
/* tp_getset */ 0,
/* tp_base */ 0,
/* tp_dict */ 0,
/* tp_descr_get */ 0,
/* tp_descr_set */ 0,
/* tp_dictoffset */ 0,
/* tp_init */ 0,
/* tp_alloc */ 0,
/* tp_new */ semlock_new,
};
/*
* Function to unlink semaphore names
*/
PyObject *
_PyMp_sem_unlink(PyObject *ignore, PyObject *args)
{
char *name;
if (!PyArg_ParseTuple(args, "s", &name))
return NULL;
if (SEM_UNLINK(name) < 0) {
_PyMp_SetError(NULL, MP_STANDARD_ERROR);
return NULL;
}
Py_RETURN_NONE;
}
| 19,538 | 689 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/_multiprocessing/multiprocessing.h | #ifndef MULTIPROCESSING_H
#define MULTIPROCESSING_H
#define PY_SSIZE_T_CLEAN
#include "libc/thread/semaphore.h"
#include "third_party/python/Include/Python.h"
#include "third_party/python/Include/pythread.h"
#include "third_party/python/Include/structmember.h"
/* clang-format off */
/*
* Platform includes and definitions
*/
#if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)
typedef sem_t *SEM_HANDLE;
#endif
#define HANDLE int
#define SOCKET int
#define BOOL int
#define UINT32 uint32_t
#define INT32 int32_t
#define TRUE 1
#define FALSE 0
#define INVALID_HANDLE_VALUE (-1)
/*
* Issue 3110 - Solaris does not define SEM_VALUE_MAX
*/
#ifndef SEM_VALUE_MAX
#if defined(HAVE_SYSCONF) && defined(_SC_SEM_VALUE_MAX)
# define SEM_VALUE_MAX sysconf(_SC_SEM_VALUE_MAX)
#elif defined(_SEM_VALUE_MAX)
# define SEM_VALUE_MAX _SEM_VALUE_MAX
#elif defined(_POSIX_SEM_VALUE_MAX)
# define SEM_VALUE_MAX _POSIX_SEM_VALUE_MAX
#else
# define SEM_VALUE_MAX INT_MAX
#endif
#endif
/*
* Format codes
*/
#if SIZEOF_VOID_P == SIZEOF_LONG
# define F_POINTER "k"
# define T_POINTER T_ULONG
#elif SIZEOF_VOID_P == SIZEOF_LONG_LONG
# define F_POINTER "K"
# define T_POINTER T_ULONGLONG
#else
# error "can't find format code for unsigned integer of same size as void*"
#endif
#ifdef MS_WINDOWS
# define F_HANDLE F_POINTER
# define T_HANDLE T_POINTER
# define F_SEM_HANDLE F_HANDLE
# define T_SEM_HANDLE T_HANDLE
# define F_DWORD "k"
# define T_DWORD T_ULONG
#else
# define F_HANDLE "i"
# define T_HANDLE T_INT
# define F_SEM_HANDLE F_POINTER
# define T_SEM_HANDLE T_POINTER
#endif
/*
* Error codes which can be returned by functions called without GIL
*/
#define MP_SUCCESS (0)
#define MP_STANDARD_ERROR (-1)
#define MP_MEMORY_ERROR (-1001)
#define MP_SOCKET_ERROR (-1002)
#define MP_EXCEPTION_HAS_BEEN_SET (-1003)
PyObject *_PyMp_SetError(PyObject *Type, int num);
/*
* Externs - not all will really exist on all platforms
*/
extern PyTypeObject _PyMp_SemLockType;
extern PyObject *_PyMp_sem_unlink(PyObject *ignore, PyObject *args);
#endif /* MULTIPROCESSING_H */
| 2,147 | 89 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/latin1tab.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
| 3,427 | 66 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/iasciitab.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
| 3,444 | 67 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/nametab.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
static const unsigned namingBitmap[] = {
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
0xFFFFFFFF, 0x77FFFFFF,
};
static const unsigned char nmstrtPages[] = {
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x15, 0x16, 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, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
static const unsigned char namePages[] = {
0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x27, 0x16, 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, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
| 9,049 | 138 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmltok_impl.h.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
enum {
BT_NONXML, /* e.g. noncharacter-FFFF */
BT_MALFORM, /* illegal, with regard to encoding */
BT_LT, /* less than = "<" */
BT_AMP, /* ampersand = "&" */
BT_RSQB, /* right square bracket = "[" */
BT_LEAD2, /* lead byte of a 2-byte UTF-8 character */
BT_LEAD3, /* lead byte of a 3-byte UTF-8 character */
BT_LEAD4, /* lead byte of a 4-byte UTF-8 character */
BT_TRAIL, /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
BT_CR, /* carriage return = "\r" */
BT_LF, /* line feed = "\n" */
BT_GT, /* greater than = ">" */
BT_QUOT, /* quotation character = "\"" */
BT_APOS, /* aposthrophe = "'" */
BT_EQUALS, /* equal sign = "=" */
BT_QUEST, /* question mark = "?" */
BT_EXCL, /* exclamation mark = "!" */
BT_SOL, /* solidus, slash = "/" */
BT_SEMI, /* semicolon = ";" */
BT_NUM, /* number sign = "#" */
BT_LSQB, /* left square bracket = "[" */
BT_S, /* white space, e.g. "\t", " "[, "\r"] */
BT_NMSTRT, /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
BT_COLON, /* colon = ":" */
BT_HEX, /* hex letter = "A".."F" + "a".."f" */
BT_DIGIT, /* digit = "0".."9" */
BT_NAME, /* dot and middle dot = "." + chr(0xb7) */
BT_MINUS, /* minus = "-" */
BT_OTHER, /* known not to be a name or name start character */
BT_NONASCII, /* might be a name or name start character */
BT_PERCNT, /* percent sign = "%" */
BT_LPAR, /* left parenthesis = "(" */
BT_RPAR, /* right parenthesis = "(" */
BT_AST, /* asterisk = "*" */
BT_PLUS, /* plus sign = "+" */
BT_COMMA, /* comma = "," */
BT_VERBAR /* vertical bar = "|" */
};
| 3,341 | 73 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/siphash.inc | /* clang-format off */
/* ==========================================================================
* siphash.h - SipHash-2-4 in a single header file
* --------------------------------------------------------------------------
* Derived by William Ahern from the reference implementation[1] published[2]
* by Jean-Philippe Aumasson and Daniel J. Berstein.
* Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
* Licensed under the CC0 Public Domain Dedication license.
*
* 1. https://www.131002.net/siphash/siphash24.c
* 2. https://www.131002.net/siphash/
* --------------------------------------------------------------------------
* HISTORY:
*
* 2019-08-03 (Sebastian Pipping)
* - Mark part of sip24_valid as to be excluded from clang-format
* - Re-format code using clang-format 9
*
* 2018-07-08 (Anton Maklakov)
* - Add "fall through" markers for GCC's -Wimplicit-fallthrough
*
* 2017-11-03 (Sebastian Pipping)
* - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
*
* 2017-07-25 (Vadim Zeitlin)
* - Fix use of SIPHASH_MAIN macro
*
* 2017-07-05 (Sebastian Pipping)
* - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
* - Add const qualifiers at two places
* - Ensure <=80 characters line length (assuming tab width 4)
*
* 2017-06-23 (Victor Stinner)
* - Address Win64 compile warnings
*
* 2017-06-18 (Sebastian Pipping)
* - Clarify license note in the header
* - Address C89 issues:
* - Stop using inline keyword (and let compiler decide)
* - Replace _Bool by int
* - Turn macro siphash24 into a function
* - Address invalid conversion (void pointer) by explicit cast
* - Address lack of stdint.h for Visual Studio 2003 to 2008
* - Always expose sip24_valid (for self-tests)
*
* 2012-11-04 - Born. (William Ahern)
* --------------------------------------------------------------------------
* USAGE:
*
* SipHash-2-4 takes as input two 64-bit words as the key, some number of
* message bytes, and outputs a 64-bit word as the message digest. This
* implementation employs two data structures: a struct sipkey for
* representing the key, and a struct siphash for representing the hash
* state.
*
* For converting a 16-byte unsigned char array to a key, use either the
* macro sip_keyof or the routine sip_tokey. The former instantiates a
* compound literal key, while the latter requires a key object as a
* parameter.
*
* unsigned char secret[16];
* arc4random_buf(secret, sizeof secret);
* struct sipkey *key = sip_keyof(secret);
*
* For hashing a message, use either the convenience macro siphash24 or the
* routines sip24_init, sip24_update, and sip24_final.
*
* struct siphash state;
* void *msg;
* size_t len;
* uint64_t hash;
*
* sip24_init(&state, key);
* sip24_update(&state, msg, len);
* hash = sip24_final(&state);
*
* or
*
* hash = siphash24(msg, len, key);
*
* To convert the 64-bit hash value to a canonical 8-byte little-endian
* binary representation, use either the macro sip_binof or the routine
* sip_tobin. The former instantiates and returns a compound literal array,
* while the latter requires an array object as a parameter.
* --------------------------------------------------------------------------
* NOTES:
*
* o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
* lacking compound literal support. Instead, you must use the lower-level
* interfaces which take as parameters the temporary state objects.
*
* o Uppercase macros may evaluate parameters more than once. Lowercase
* macros should not exhibit any such side effects.
* ==========================================================================
*/
#ifndef SIPHASH_H
#define SIPHASH_H
/*
* Workaround to not require a C++11 compiler for using ULL suffix
* if this code is included and compiled as C++; related GCC warning is:
* warning: use of C++11 long long integer constant [-Wlong-long]
*/
#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
#define SIP_U32TO8_LE(p, v) \
(p)[0] = (uint8_t)((v) >> 0); \
(p)[1] = (uint8_t)((v) >> 8); \
(p)[2] = (uint8_t)((v) >> 16); \
(p)[3] = (uint8_t)((v) >> 24);
#define SIP_U64TO8_LE(p, v) \
SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0)); \
SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
#define SIP_U8TO64_LE(p) \
(((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8) \
| ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) \
| ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) \
| ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
#define SIPHASH_INITIALIZER \
{ 0, 0, 0, 0, {0}, 0, 0 }
struct siphash {
uint64_t v0, v1, v2, v3;
unsigned char buf[8], *p;
uint64_t c;
}; /* struct siphash */
#define SIP_KEYLEN 16
struct sipkey {
uint64_t k[2];
}; /* struct sipkey */
#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
static struct sipkey *
sip_tokey(struct sipkey *key, const void *src) {
key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
return key;
} /* sip_tokey() */
#ifdef SIPHASH_TOBIN
# define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
static void *
sip_tobin(void *dst, uint64_t u64) {
SIP_U64TO8_LE((unsigned char *)dst, u64);
return dst;
} /* sip_tobin() */
#endif /* SIPHASH_TOBIN */
static void
sip_round(struct siphash *H, const int rounds) {
int i;
for (i = 0; i < rounds; i++) {
H->v0 += H->v1;
H->v1 = SIP_ROTL(H->v1, 13);
H->v1 ^= H->v0;
H->v0 = SIP_ROTL(H->v0, 32);
H->v2 += H->v3;
H->v3 = SIP_ROTL(H->v3, 16);
H->v3 ^= H->v2;
H->v0 += H->v3;
H->v3 = SIP_ROTL(H->v3, 21);
H->v3 ^= H->v0;
H->v2 += H->v1;
H->v1 = SIP_ROTL(H->v1, 17);
H->v1 ^= H->v2;
H->v2 = SIP_ROTL(H->v2, 32);
}
} /* sip_round() */
static struct siphash *
sip24_init(struct siphash *H, const struct sipkey *key) {
H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
H->p = H->buf;
H->c = 0;
return H;
} /* sip24_init() */
#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
static struct siphash *
sip24_update(struct siphash *H, const void *src, size_t len) {
const unsigned char *p = (const unsigned char *)src, *pe = p + len;
uint64_t m;
do {
while (p < pe && H->p < sip_endof(H->buf))
*H->p++ = *p++;
if (H->p < sip_endof(H->buf))
break;
m = SIP_U8TO64_LE(H->buf);
H->v3 ^= m;
sip_round(H, 2);
H->v0 ^= m;
H->p = H->buf;
H->c += 8;
} while (p < pe);
return H;
} /* sip24_update() */
static uint64_t
sip24_final(struct siphash *H) {
const char left = (char)(H->p - H->buf);
uint64_t b = (H->c + left) << 56;
switch (left) {
case 7:
b |= (uint64_t)H->buf[6] << 48;
/* fall through */
case 6:
b |= (uint64_t)H->buf[5] << 40;
/* fall through */
case 5:
b |= (uint64_t)H->buf[4] << 32;
/* fall through */
case 4:
b |= (uint64_t)H->buf[3] << 24;
/* fall through */
case 3:
b |= (uint64_t)H->buf[2] << 16;
/* fall through */
case 2:
b |= (uint64_t)H->buf[1] << 8;
/* fall through */
case 1:
b |= (uint64_t)H->buf[0] << 0;
/* fall through */
case 0:
break;
}
H->v3 ^= b;
sip_round(H, 2);
H->v0 ^= b;
H->v2 ^= 0xff;
sip_round(H, 4);
return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
} /* sip24_final() */
static uint64_t
siphash24(const void *src, size_t len, const struct sipkey *key) {
struct siphash state = SIPHASH_INITIALIZER;
return sip24_final(sip24_update(sip24_init(&state, key), src, len));
} /* siphash24() */
/*
* SipHash-2-4 output with
* k = 00 01 02 ...
* and
* in = (empty string)
* in = 00 (1 byte)
* in = 00 01 (2 bytes)
* in = 00 01 02 (3 bytes)
* ...
* in = 00 01 02 ... 3e (63 bytes)
*/
static int
sip24_valid(void) {
/* clang-format off */
static const unsigned char vectors[64][8] = {
{ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
{ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
{ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
{ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
{ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
{ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
{ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
{ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
{ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
{ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
{ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
{ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
{ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
{ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
{ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
{ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
{ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
{ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
{ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
{ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
{ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
{ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
{ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
{ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
{ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
{ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
{ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
{ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
{ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
{ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
{ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
{ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
{ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
{ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
{ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
{ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
{ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
{ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
{ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
{ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
{ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
{ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
{ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
{ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
{ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
{ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
{ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
{ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
{ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
{ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
{ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
{ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
{ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
{ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
{ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
{ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
{ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
{ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
{ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
{ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
{ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
{ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
{ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
{ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
};
/* clang-format on */
unsigned char in[64];
struct sipkey k;
size_t i;
sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
"\012\013\014\015\016\017");
for (i = 0; i < sizeof in; ++i) {
in[i] = (unsigned char)i;
if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i])) return 0;
}
return 1;
} /* sip24_valid() */
#ifdef SIPHASH_MAIN
#include <stdio.h>
int main(void) {
const int ok = sip24_valid();
if (ok)
puts("OK");
else
puts("FAIL");
return !ok;
} /* main() */
#endif /* SIPHASH_MAIN */
#endif /* SIPHASH_H */
| 12,903 | 387 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmlparse.c | #include "libc/assert.h"
#include "libc/calls/calls.h"
#include "libc/calls/struct/timeval.h"
#include "libc/errno.h"
#include "libc/limits.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/rdtsc.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/stdio.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/grnd.h"
#include "libc/time/time.h"
#include "third_party/python/Modules/expat/expat.h"
#include "third_party/python/Modules/expat/expat_config.h"
/* clang-format off */
/* f2d0ab6d1d4422a08cf1cf3bbdfba96b49dea42fb5ff4615e03a2a25c306e769 (2.2.8+)
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
asm(".ident\t\"\\n\\n\
expat (MIT License)\\n\
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd\\n\
Copyright (c) 2000-2017 Expat development team\"");
asm(".include \"libc/disclaimer.inc\"");
#define XML_BUILDING_EXPAT 1
#include "third_party/python/Modules/expat/ascii.inc"
#include "third_party/python/Modules/expat/siphash.inc"
#if defined(_WIN32) && !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
#endif
#ifdef XML_UNICODE
#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
#define XmlConvert XmlUtf16Convert
#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
#define XmlEncode XmlUtf16Encode
/* Using pointer subtraction to convert to integer type. */
#define MUST_CONVERT(enc, s) \
(!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
typedef unsigned short ICHAR;
#else
#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
#define XmlConvert XmlUtf8Convert
#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
#define XmlEncode XmlUtf8Encode
#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
typedef char ICHAR;
#endif
#ifndef XML_NS
#define XmlInitEncodingNS XmlInitEncoding
#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
#undef XmlGetInternalEncodingNS
#define XmlGetInternalEncodingNS XmlGetInternalEncoding
#define XmlParseXmlDeclNS XmlParseXmlDecl
#endif
#ifdef XML_UNICODE
#ifdef XML_UNICODE_WCHAR_T
#define XML_T(x) (const wchar_t) x
#define XML_L(x) L##x
#else
#define XML_T(x) (const unsigned short)x
#define XML_L(x) x
#endif
#else
#define XML_T(x) x
#define XML_L(x) x
#endif
/* Round up n to be a multiple of sz, where sz is a power of 2. */
#define ROUND_UP(n, sz) (((n) + ((sz)-1)) & ~((sz)-1))
/* Do safe (NULL-aware) pointer arithmetic */
#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)
#include "third_party/python/Modules/expat/internal.inc"
#include "third_party/python/Modules/expat/xmlrole.h"
#include "third_party/python/Modules/expat/xmltok.h"
typedef const XML_Char *KEY;
typedef struct {
KEY name;
} NAMED;
typedef struct {
NAMED **v;
unsigned char power;
size_t size;
size_t used;
const XML_Memory_Handling_Suite *mem;
} HASH_TABLE;
static size_t keylen(KEY s);
static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
/* For probing (after a collision) we need a step size relative prime
to the hash table size, which is a power of 2. We use double-hashing,
since we can calculate a second hash value cheaply by taking those bits
of the first hash value that were discarded (masked out) when the table
index was calculated: index = hash & mask, where mask = table->size - 1.
We limit the maximum step size to table->size / 4 (mask >> 2) and make
it odd, since odd numbers are always relative prime to a power of 2.
*/
#define SECOND_HASH(hash, mask, power) \
((((hash) & ~(mask)) >> ((power)-1)) & ((mask) >> 2))
#define PROBE_STEP(hash, mask, power) \
((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
typedef struct {
NAMED **p;
NAMED **end;
} HASH_TABLE_ITER;
#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
#define INIT_DATA_BUF_SIZE 1024
#define INIT_ATTS_SIZE 16
#define INIT_ATTS_VERSION 0xFFFFFFFF
#define INIT_BLOCK_SIZE 1024
#define INIT_BUFFER_SIZE 1024
#define EXPAND_SPARE 24
typedef struct binding {
struct prefix *prefix;
struct binding *nextTagBinding;
struct binding *prevPrefixBinding;
const struct attribute_id *attId;
XML_Char *uri;
int uriLen;
int uriAlloc;
} BINDING;
typedef struct prefix {
const XML_Char *name;
BINDING *binding;
} PREFIX;
typedef struct {
const XML_Char *str;
const XML_Char *localPart;
const XML_Char *prefix;
int strLen;
int uriLen;
int prefixLen;
} TAG_NAME;
/* TAG represents an open element.
The name of the element is stored in both the document and API
encodings. The memory buffer 'buf' is a separately-allocated
memory area which stores the name. During the XML_Parse()/
XMLParseBuffer() when the element is open, the memory for the 'raw'
version of the name (in the document encoding) is shared with the
document buffer. If the element is open across calls to
XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
contain the 'raw' name as well.
A parser re-uses these structures, maintaining a list of allocated
TAG objects in a free list.
*/
typedef struct tag {
struct tag *parent; /* parent of this element */
const char *rawName; /* tagName in the original encoding */
int rawNameLength;
TAG_NAME name; /* tagName in the API encoding */
char *buf; /* buffer for name components */
char *bufEnd; /* end of the buffer */
BINDING *bindings;
} TAG;
typedef struct {
const XML_Char *name;
const XML_Char *textPtr;
int textLen; /* length in XML_Chars */
int processed; /* # of processed bytes - when suspended */
const XML_Char *systemId;
const XML_Char *base;
const XML_Char *publicId;
const XML_Char *notation;
XML_Bool open_;
XML_Bool is_param;
XML_Bool is_internal; /* true if declared in internal subset outside PE */
} ENTITY;
typedef struct {
enum XML_Content_Type type;
enum XML_Content_Quant quant;
const XML_Char *name;
int firstchild;
int lastchild;
int childcnt;
int nextsib;
} CONTENT_SCAFFOLD;
#define INIT_SCAFFOLD_ELEMENTS 32
typedef struct block {
struct block *next;
int size;
XML_Char s[1];
} BLOCK;
typedef struct {
BLOCK *blocks;
BLOCK *freeBlocks;
const XML_Char *end;
XML_Char *ptr;
XML_Char *start;
const XML_Memory_Handling_Suite *mem;
} STRING_POOL;
/* The XML_Char before the name is used to determine whether
an attribute has been specified. */
typedef struct attribute_id {
XML_Char *name;
PREFIX *prefix;
XML_Bool maybeTokenized;
XML_Bool xmlns;
} ATTRIBUTE_ID;
typedef struct {
const ATTRIBUTE_ID *id;
XML_Bool isCdata;
const XML_Char *value;
} DEFAULT_ATTRIBUTE;
typedef struct {
unsigned long version;
unsigned long hash;
const XML_Char *uriName;
} NS_ATT;
typedef struct {
const XML_Char *name;
PREFIX *prefix;
const ATTRIBUTE_ID *idAtt;
int nDefaultAtts;
int allocDefaultAtts;
DEFAULT_ATTRIBUTE *defaultAtts;
} ELEMENT_TYPE;
typedef struct {
HASH_TABLE generalEntities;
HASH_TABLE elementTypes;
HASH_TABLE attributeIds;
HASH_TABLE prefixes;
STRING_POOL pool;
STRING_POOL entityValuePool;
/* false once a parameter entity reference has been skipped */
XML_Bool keepProcessing;
/* true once an internal or external PE reference has been encountered;
this includes the reference to an external subset */
XML_Bool hasParamEntityRefs;
XML_Bool standalone;
#ifdef XML_DTD
/* indicates if external PE has been read */
XML_Bool paramEntityRead;
HASH_TABLE paramEntities;
#endif /* XML_DTD */
PREFIX defaultPrefix;
/* === scaffolding for building content model === */
XML_Bool in_eldecl;
CONTENT_SCAFFOLD *scaffold;
unsigned contentStringLen;
unsigned scaffSize;
unsigned scaffCount;
int scaffLevel;
int *scaffIndex;
} DTD;
typedef struct open_internal_entity {
const char *internalEventPtr;
const char *internalEventEndPtr;
struct open_internal_entity *next;
ENTITY *entity;
int startTagLevel;
XML_Bool betweenDecl; /* WFC: PE Between Declarations */
} OPEN_INTERNAL_ENTITY;
typedef enum XML_Error Processor(XML_Parser parser, const char *start,
const char *end, const char **endPtr);
static Processor prologProcessor;
static Processor prologInitProcessor;
static Processor contentProcessor;
static Processor cdataSectionProcessor;
#ifdef XML_DTD
static Processor ignoreSectionProcessor;
static Processor externalParEntProcessor;
static Processor externalParEntInitProcessor;
static Processor entityValueProcessor;
static Processor entityValueInitProcessor;
#endif /* XML_DTD */
static Processor epilogProcessor;
static Processor errorProcessor;
static Processor externalEntityInitProcessor;
static Processor externalEntityInitProcessor2;
static Processor externalEntityInitProcessor3;
static Processor externalEntityContentProcessor;
static Processor internalEntityProcessor;
static enum XML_Error handleUnknownEncoding(XML_Parser parser,
const XML_Char *encodingName);
static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
const char *s, const char *next);
static enum XML_Error initializeEncoding(XML_Parser parser);
static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
const char *s, const char *end, int tok,
const char *next, const char **nextPtr,
XML_Bool haveMore, XML_Bool allowClosingDoctype);
static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
XML_Bool betweenDecl);
static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
const ENCODING *enc, const char *start,
const char *end, const char **endPtr,
XML_Bool haveMore);
static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
const char **startPtr, const char *end,
const char **nextPtr, XML_Bool haveMore);
#ifdef XML_DTD
static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
const char **startPtr, const char *end,
const char **nextPtr, XML_Bool haveMore);
#endif /* XML_DTD */
static void freeBindings(XML_Parser parser, BINDING *bindings);
static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
const char *s, TAG_NAME *tagNamePtr,
BINDING **bindingsPtr);
static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
const ATTRIBUTE_ID *attId, const XML_Char *uri,
BINDING **bindingsPtr);
static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
XML_Bool isId, const XML_Char *dfltValue,
XML_Parser parser);
static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
XML_Bool isCdata, const char *,
const char *, STRING_POOL *);
static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
XML_Bool isCdata, const char *,
const char *, STRING_POOL *);
static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end);
static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end);
static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end);
static int reportComment(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end);
static void reportDefault(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end);
static const XML_Char *getContext(XML_Parser parser);
static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
static void normalizePublicId(XML_Char *s);
static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);
/* do not call if m_parentParser != NULL */
static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
const XML_Memory_Handling_Suite *ms);
static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
const XML_Memory_Handling_Suite *ms);
static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *, STRING_POOL *,
const HASH_TABLE *);
static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
size_t createSize);
static void hashTableInit(HASH_TABLE *,
const XML_Memory_Handling_Suite *ms);
static void hashTableClear(HASH_TABLE *);
static void hashTableDestroy(HASH_TABLE *);
static void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
static NAMED *hashTableIterNext(HASH_TABLE_ITER *);
static void poolInit(STRING_POOL *,
const XML_Memory_Handling_Suite *ms);
static void poolClear(STRING_POOL *);
static void poolDestroy(STRING_POOL *);
static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end);
static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end);
static XML_Bool poolGrow(STRING_POOL *pool);
static const XML_Char *poolCopyString(STRING_POOL *pool,
const XML_Char *s);
static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
int n);
static const XML_Char *poolAppendString(STRING_POOL *pool,
const XML_Char *s);
static int nextScaffoldPart(XML_Parser parser);
static XML_Content *build_model(XML_Parser parser);
static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
const char *ptr, const char *end);
static XML_Char *copyString(const XML_Char *s,
const XML_Memory_Handling_Suite *memsuite);
static XML_Bool startParsing(XML_Parser parser);
static XML_Parser parserCreate(const XML_Char *encodingName,
const XML_Memory_Handling_Suite *memsuite,
const XML_Char *nameSep, DTD *dtd);
static void parserInit(XML_Parser parser, const XML_Char *encodingName);
#define poolStart(pool) ((pool)->start)
#define poolEnd(pool) ((pool)->ptr)
#define poolLength(pool) ((pool)->ptr - (pool)->start)
#define poolChop(pool) ((void)--(pool->ptr))
#define poolLastChar(pool) (((pool)->ptr)[-1])
#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
#define poolFinish(pool) ((pool)->start = (pool)->ptr)
#define poolAppendChar(pool, c) \
(((pool)->ptr == (pool)->end && !poolGrow(pool)) \
? 0 \
: ((*((pool)->ptr)++ = c), 1))
struct XML_ParserStruct {
/* The first member must be m_userData so that the XML_GetUserData
macro works. */
void *m_userData;
void *m_handlerArg;
char *m_buffer;
const XML_Memory_Handling_Suite m_mem;
/* first character to be parsed */
const char *m_bufferPtr;
/* past last character to be parsed */
char *m_bufferEnd;
/* allocated end of m_buffer */
const char *m_bufferLim;
XML_Index m_parseEndByteIndex;
const char *m_parseEndPtr;
XML_Char *m_dataBuf;
XML_Char *m_dataBufEnd;
XML_StartElementHandler m_startElementHandler;
XML_EndElementHandler m_endElementHandler;
XML_CharacterDataHandler m_characterDataHandler;
XML_ProcessingInstructionHandler m_processingInstructionHandler;
XML_CommentHandler m_commentHandler;
XML_StartCdataSectionHandler m_startCdataSectionHandler;
XML_EndCdataSectionHandler m_endCdataSectionHandler;
XML_DefaultHandler m_defaultHandler;
XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
XML_NotationDeclHandler m_notationDeclHandler;
XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
XML_NotStandaloneHandler m_notStandaloneHandler;
XML_ExternalEntityRefHandler m_externalEntityRefHandler;
XML_Parser m_externalEntityRefHandlerArg;
XML_SkippedEntityHandler m_skippedEntityHandler;
XML_UnknownEncodingHandler m_unknownEncodingHandler;
XML_ElementDeclHandler m_elementDeclHandler;
XML_AttlistDeclHandler m_attlistDeclHandler;
XML_EntityDeclHandler m_entityDeclHandler;
XML_XmlDeclHandler m_xmlDeclHandler;
const ENCODING *m_encoding;
INIT_ENCODING m_initEncoding;
const ENCODING *m_internalEncoding;
const XML_Char *m_protocolEncodingName;
XML_Bool m_ns;
XML_Bool m_ns_triplets;
void *m_unknownEncodingMem;
void *m_unknownEncodingData;
void *m_unknownEncodingHandlerData;
void(*m_unknownEncodingRelease)(void *);
PROLOG_STATE m_prologState;
Processor *m_processor;
enum XML_Error m_errorCode;
const char *m_eventPtr;
const char *m_eventEndPtr;
const char *m_positionPtr;
OPEN_INTERNAL_ENTITY *m_openInternalEntities;
OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
XML_Bool m_defaultExpandInternalEntities;
int m_tagLevel;
ENTITY *m_declEntity;
const XML_Char *m_doctypeName;
const XML_Char *m_doctypeSysid;
const XML_Char *m_doctypePubid;
const XML_Char *m_declAttributeType;
const XML_Char *m_declNotationName;
const XML_Char *m_declNotationPublicId;
ELEMENT_TYPE *m_declElementType;
ATTRIBUTE_ID *m_declAttributeId;
XML_Bool m_declAttributeIsCdata;
XML_Bool m_declAttributeIsId;
DTD *m_dtd;
const XML_Char *m_curBase;
TAG *m_tagStack;
TAG *m_freeTagList;
BINDING *m_inheritedBindings;
BINDING *m_freeBindingList;
int m_attsSize;
int m_nSpecifiedAtts;
int m_idAttIndex;
ATTRIBUTE *m_atts;
NS_ATT *m_nsAtts;
unsigned long m_nsAttsVersion;
unsigned char m_nsAttsPower;
#ifdef XML_ATTR_INFO
XML_AttrInfo *m_attInfo;
#endif
POSITION m_position;
STRING_POOL m_tempPool;
STRING_POOL m_temp2Pool;
char *m_groupConnector;
unsigned int m_groupSize;
XML_Char m_namespaceSeparator;
XML_Parser m_parentParser;
XML_ParsingStatus m_parsingStatus;
#ifdef XML_DTD
XML_Bool m_isParamEntity;
XML_Bool m_useForeignDTD;
enum XML_ParamEntityParsing m_paramEntityParsing;
#endif
unsigned long m_hash_secret_salt;
};
#define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
#define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
#define FREE(parser, p) (parser->m_mem.free_fcn((p)))
XML_Parser XML_ParserCreate(const XML_Char *encodingName) {
return XML_ParserCreate_MM(encodingName, NULL, NULL);
}
XML_Parser XML_ParserCreateNS(const XML_Char *encodingName,
XML_Char nsSep) {
XML_Char tmp[2];
*tmp = nsSep;
return XML_ParserCreate_MM(encodingName, NULL, tmp);
}
static const XML_Char implicitContext[] = {
ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h,
ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH,
ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD,
ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r,
ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8,
ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e,
'\0'};
static unsigned long get_hash_secret_salt(XML_Parser parser) {
if (parser->m_parentParser != NULL)
return get_hash_secret_salt(parser->m_parentParser);
return parser->m_hash_secret_salt;
}
static XML_Bool /* only valid for root parser */
startParsing(XML_Parser parser) {
/* hash functions must be initialized before setContext() is called */
if (!parser->m_hash_secret_salt) {
parser->m_hash_secret_salt = rdrand();
}
if (parser->m_ns) {
/* implicit context only set for root parser, since child
parsers (i.e. external entity parsers) will inherit it
*/
return setContext(parser, implicitContext);
}
return XML_TRUE;
}
XML_Parser XML_ParserCreate_MM(
const XML_Char *encodingName, const XML_Memory_Handling_Suite *memsuite,
const XML_Char *nameSep) {
return parserCreate(encodingName, memsuite, nameSep, NULL);
}
static XML_Parser parserCreate(const XML_Char *encodingName,
const XML_Memory_Handling_Suite *memsuite,
const XML_Char *nameSep, DTD *dtd) {
XML_Parser parser;
if (memsuite) {
XML_Memory_Handling_Suite *mtemp;
parser = (XML_Parser)memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
if (parser != NULL) {
mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
mtemp->malloc_fcn = memsuite->malloc_fcn;
mtemp->realloc_fcn = memsuite->realloc_fcn;
mtemp->free_fcn = memsuite->free_fcn;
}
} else {
XML_Memory_Handling_Suite *mtemp;
parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
if (parser != NULL) {
mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
mtemp->malloc_fcn = malloc;
mtemp->realloc_fcn = realloc;
mtemp->free_fcn = free;
}
}
if (!parser) return parser;
parser->m_buffer = NULL;
parser->m_bufferLim = NULL;
parser->m_attsSize = INIT_ATTS_SIZE;
parser->m_atts =
(ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
if (parser->m_atts == NULL) {
FREE(parser, parser);
return NULL;
}
#ifdef XML_ATTR_INFO
parser->m_attInfo =
(XML_AttrInfo *)MALLOC(parser, parser->m_attsSize * sizeof(XML_AttrInfo));
if (parser->m_attInfo == NULL) {
FREE(parser, parser->m_atts);
FREE(parser, parser);
return NULL;
}
#endif
parser->m_dataBuf =
(XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
if (parser->m_dataBuf == NULL) {
FREE(parser, parser->m_atts);
#ifdef XML_ATTR_INFO
FREE(parser, parser->m_attInfo);
#endif
FREE(parser, parser);
return NULL;
}
parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
if (dtd)
parser->m_dtd = dtd;
else {
parser->m_dtd = dtdCreate(&parser->m_mem);
if (parser->m_dtd == NULL) {
FREE(parser, parser->m_dataBuf);
FREE(parser, parser->m_atts);
#ifdef XML_ATTR_INFO
FREE(parser, parser->m_attInfo);
#endif
FREE(parser, parser);
return NULL;
}
}
parser->m_freeBindingList = NULL;
parser->m_freeTagList = NULL;
parser->m_freeInternalEntities = NULL;
parser->m_groupSize = 0;
parser->m_groupConnector = NULL;
parser->m_unknownEncodingHandler = NULL;
parser->m_unknownEncodingHandlerData = NULL;
parser->m_namespaceSeparator = ASCII_EXCL;
parser->m_ns = XML_FALSE;
parser->m_ns_triplets = XML_FALSE;
parser->m_nsAtts = NULL;
parser->m_nsAttsVersion = 0;
parser->m_nsAttsPower = 0;
parser->m_protocolEncodingName = NULL;
poolInit(&parser->m_tempPool, &(parser->m_mem));
poolInit(&parser->m_temp2Pool, &(parser->m_mem));
parserInit(parser, encodingName);
if (encodingName && !parser->m_protocolEncodingName) {
XML_ParserFree(parser);
return NULL;
}
if (nameSep) {
parser->m_ns = XML_TRUE;
parser->m_internalEncoding = XmlGetInternalEncodingNS();
parser->m_namespaceSeparator = *nameSep;
} else {
parser->m_internalEncoding = XmlGetInternalEncoding();
}
return parser;
}
static void parserInit(XML_Parser parser, const XML_Char *encodingName) {
parser->m_processor = prologInitProcessor;
XmlPrologStateInit(&parser->m_prologState);
if (encodingName != NULL) {
parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
}
parser->m_curBase = NULL;
XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
parser->m_userData = NULL;
parser->m_handlerArg = NULL;
parser->m_startElementHandler = NULL;
parser->m_endElementHandler = NULL;
parser->m_characterDataHandler = NULL;
parser->m_processingInstructionHandler = NULL;
parser->m_commentHandler = NULL;
parser->m_startCdataSectionHandler = NULL;
parser->m_endCdataSectionHandler = NULL;
parser->m_defaultHandler = NULL;
parser->m_startDoctypeDeclHandler = NULL;
parser->m_endDoctypeDeclHandler = NULL;
parser->m_unparsedEntityDeclHandler = NULL;
parser->m_notationDeclHandler = NULL;
parser->m_startNamespaceDeclHandler = NULL;
parser->m_endNamespaceDeclHandler = NULL;
parser->m_notStandaloneHandler = NULL;
parser->m_externalEntityRefHandler = NULL;
parser->m_externalEntityRefHandlerArg = parser;
parser->m_skippedEntityHandler = NULL;
parser->m_elementDeclHandler = NULL;
parser->m_attlistDeclHandler = NULL;
parser->m_entityDeclHandler = NULL;
parser->m_xmlDeclHandler = NULL;
parser->m_bufferPtr = parser->m_buffer;
parser->m_bufferEnd = parser->m_buffer;
parser->m_parseEndByteIndex = 0;
parser->m_parseEndPtr = NULL;
parser->m_declElementType = NULL;
parser->m_declAttributeId = NULL;
parser->m_declEntity = NULL;
parser->m_doctypeName = NULL;
parser->m_doctypeSysid = NULL;
parser->m_doctypePubid = NULL;
parser->m_declAttributeType = NULL;
parser->m_declNotationName = NULL;
parser->m_declNotationPublicId = NULL;
parser->m_declAttributeIsCdata = XML_FALSE;
parser->m_declAttributeIsId = XML_FALSE;
bzero(&parser->m_position, sizeof(POSITION));
parser->m_errorCode = XML_ERROR_NONE;
parser->m_eventPtr = NULL;
parser->m_eventEndPtr = NULL;
parser->m_positionPtr = NULL;
parser->m_openInternalEntities = NULL;
parser->m_defaultExpandInternalEntities = XML_TRUE;
parser->m_tagLevel = 0;
parser->m_tagStack = NULL;
parser->m_inheritedBindings = NULL;
parser->m_nSpecifiedAtts = 0;
parser->m_unknownEncodingMem = NULL;
parser->m_unknownEncodingRelease = NULL;
parser->m_unknownEncodingData = NULL;
parser->m_parentParser = NULL;
parser->m_parsingStatus.parsing = XML_INITIALIZED;
#ifdef XML_DTD
parser->m_isParamEntity = XML_FALSE;
parser->m_useForeignDTD = XML_FALSE;
parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
#endif
parser->m_hash_secret_salt = 0;
}
/* moves list of bindings to m_freeBindingList */
static void moveToFreeBindingList(XML_Parser parser,
BINDING *bindings) {
while (bindings) {
BINDING *b = bindings;
bindings = bindings->nextTagBinding;
b->nextTagBinding = parser->m_freeBindingList;
parser->m_freeBindingList = b;
}
}
XML_Bool XML_ParserReset(XML_Parser parser,
const XML_Char *encodingName) {
TAG *tStk;
OPEN_INTERNAL_ENTITY *openEntityList;
if (parser == NULL) return XML_FALSE;
if (parser->m_parentParser) return XML_FALSE;
/* move m_tagStack to m_freeTagList */
tStk = parser->m_tagStack;
while (tStk) {
TAG *tag = tStk;
tStk = tStk->parent;
tag->parent = parser->m_freeTagList;
moveToFreeBindingList(parser, tag->bindings);
tag->bindings = NULL;
parser->m_freeTagList = tag;
}
/* move m_openInternalEntities to m_freeInternalEntities */
openEntityList = parser->m_openInternalEntities;
while (openEntityList) {
OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
openEntityList = openEntity->next;
openEntity->next = parser->m_freeInternalEntities;
parser->m_freeInternalEntities = openEntity;
}
moveToFreeBindingList(parser, parser->m_inheritedBindings);
FREE(parser, parser->m_unknownEncodingMem);
if (parser->m_unknownEncodingRelease)
parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
poolClear(&parser->m_tempPool);
poolClear(&parser->m_temp2Pool);
FREE(parser, (void *)parser->m_protocolEncodingName);
parser->m_protocolEncodingName = NULL;
parserInit(parser, encodingName);
dtdReset(parser->m_dtd, &parser->m_mem);
return XML_TRUE;
}
enum XML_Status XML_SetEncoding(XML_Parser parser,
const XML_Char *encodingName) {
if (parser == NULL) return XML_STATUS_ERROR;
/* Block after XML_Parse()/XML_ParseBuffer() has been called.
XXX There's no way for the caller to determine which of the
XXX possible error cases caused the XML_STATUS_ERROR return.
*/
if (parser->m_parsingStatus.parsing == XML_PARSING ||
parser->m_parsingStatus.parsing == XML_SUSPENDED)
return XML_STATUS_ERROR;
/* Get rid of any previous encoding name */
FREE(parser, (void *)parser->m_protocolEncodingName);
if (encodingName == NULL) /* No new encoding name */
parser->m_protocolEncodingName = NULL;
else {
/* Copy the new encoding name into allocated memory */
parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
if (!parser->m_protocolEncodingName) return XML_STATUS_ERROR;
}
return XML_STATUS_OK;
}
XML_Parser
XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,
const XML_Char *encodingName) {
XML_Parser parser = oldParser;
DTD *newDtd = NULL;
DTD *oldDtd;
XML_StartElementHandler oldStartElementHandler;
XML_EndElementHandler oldEndElementHandler;
XML_CharacterDataHandler oldCharacterDataHandler;
XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
XML_CommentHandler oldCommentHandler;
XML_StartCdataSectionHandler oldStartCdataSectionHandler;
XML_EndCdataSectionHandler oldEndCdataSectionHandler;
XML_DefaultHandler oldDefaultHandler;
XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
XML_NotationDeclHandler oldNotationDeclHandler;
XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
XML_NotStandaloneHandler oldNotStandaloneHandler;
XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
XML_SkippedEntityHandler oldSkippedEntityHandler;
XML_UnknownEncodingHandler oldUnknownEncodingHandler;
XML_ElementDeclHandler oldElementDeclHandler;
XML_AttlistDeclHandler oldAttlistDeclHandler;
XML_EntityDeclHandler oldEntityDeclHandler;
XML_XmlDeclHandler oldXmlDeclHandler;
ELEMENT_TYPE *oldDeclElementType;
void *oldUserData;
void *oldHandlerArg;
XML_Bool oldDefaultExpandInternalEntities;
XML_Parser oldExternalEntityRefHandlerArg;
#ifdef XML_DTD
enum XML_ParamEntityParsing oldParamEntityParsing;
int oldInEntityValue;
#endif
XML_Bool oldns_triplets;
/* Note that the new parser shares the same hash secret as the old
parser, so that dtdCopy and copyEntityTable can lookup values
from hash tables associated with either parser without us having
to worry which hash secrets each table has.
*/
unsigned long oldhash_secret_salt;
/* Validate the oldParser parameter before we pull everything out of it */
if (oldParser == NULL) return NULL;
/* Stash the original parser contents on the stack */
oldDtd = parser->m_dtd;
oldStartElementHandler = parser->m_startElementHandler;
oldEndElementHandler = parser->m_endElementHandler;
oldCharacterDataHandler = parser->m_characterDataHandler;
oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
oldCommentHandler = parser->m_commentHandler;
oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
oldDefaultHandler = parser->m_defaultHandler;
oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
oldNotationDeclHandler = parser->m_notationDeclHandler;
oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
oldNotStandaloneHandler = parser->m_notStandaloneHandler;
oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
oldSkippedEntityHandler = parser->m_skippedEntityHandler;
oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
oldElementDeclHandler = parser->m_elementDeclHandler;
oldAttlistDeclHandler = parser->m_attlistDeclHandler;
oldEntityDeclHandler = parser->m_entityDeclHandler;
oldXmlDeclHandler = parser->m_xmlDeclHandler;
oldDeclElementType = parser->m_declElementType;
oldUserData = parser->m_userData;
oldHandlerArg = parser->m_handlerArg;
oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
#ifdef XML_DTD
oldParamEntityParsing = parser->m_paramEntityParsing;
oldInEntityValue = parser->m_prologState.inEntityValue;
#endif
oldns_triplets = parser->m_ns_triplets;
/* Note that the new parser shares the same hash secret as the old
parser, so that dtdCopy and copyEntityTable can lookup values
from hash tables associated with either parser without us having
to worry which hash secrets each table has.
*/
oldhash_secret_salt = parser->m_hash_secret_salt;
#ifdef XML_DTD
if (!context) newDtd = oldDtd;
#endif /* XML_DTD */
/* Note that the magical uses of the pre-processor to make field
access look more like C++ require that `parser' be overwritten
here. This makes this function more painful to follow than it
would be otherwise.
*/
if (parser->m_ns) {
XML_Char tmp[2];
*tmp = parser->m_namespaceSeparator;
parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
} else {
parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
}
if (!parser) return NULL;
parser->m_startElementHandler = oldStartElementHandler;
parser->m_endElementHandler = oldEndElementHandler;
parser->m_characterDataHandler = oldCharacterDataHandler;
parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
parser->m_commentHandler = oldCommentHandler;
parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
parser->m_defaultHandler = oldDefaultHandler;
parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
parser->m_notationDeclHandler = oldNotationDeclHandler;
parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
parser->m_notStandaloneHandler = oldNotStandaloneHandler;
parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
parser->m_skippedEntityHandler = oldSkippedEntityHandler;
parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
parser->m_elementDeclHandler = oldElementDeclHandler;
parser->m_attlistDeclHandler = oldAttlistDeclHandler;
parser->m_entityDeclHandler = oldEntityDeclHandler;
parser->m_xmlDeclHandler = oldXmlDeclHandler;
parser->m_declElementType = oldDeclElementType;
parser->m_userData = oldUserData;
if (oldUserData == oldHandlerArg)
parser->m_handlerArg = parser->m_userData;
else
parser->m_handlerArg = parser;
if (oldExternalEntityRefHandlerArg != oldParser)
parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
parser->m_ns_triplets = oldns_triplets;
parser->m_hash_secret_salt = oldhash_secret_salt;
parser->m_parentParser = oldParser;
#ifdef XML_DTD
parser->m_paramEntityParsing = oldParamEntityParsing;
parser->m_prologState.inEntityValue = oldInEntityValue;
if (context) {
#endif /* XML_DTD */
if (!dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem) ||
!setContext(parser, context)) {
XML_ParserFree(parser);
return NULL;
}
parser->m_processor = externalEntityInitProcessor;
#ifdef XML_DTD
} else {
/* The DTD instance referenced by parser->m_dtd is shared between the
document's root parser and external PE parsers, therefore one does not
need to call setContext. In addition, one also *must* not call
setContext, because this would overwrite existing prefix->binding
pointers in parser->m_dtd with ones that get destroyed with the external
PE parser. This would leave those prefixes with dangling pointers.
*/
parser->m_isParamEntity = XML_TRUE;
XmlPrologStateInitExternalEntity(&parser->m_prologState);
parser->m_processor = externalParEntInitProcessor;
}
#endif /* XML_DTD */
return parser;
}
static void destroyBindings(BINDING *bindings, XML_Parser parser) {
for (;;) {
BINDING *b = bindings;
if (!b) break;
bindings = b->nextTagBinding;
FREE(parser, b->uri);
FREE(parser, b);
}
}
void XML_ParserFree(XML_Parser parser) {
TAG *tagList;
OPEN_INTERNAL_ENTITY *entityList;
if (parser == NULL) return;
/* free m_tagStack and m_freeTagList */
tagList = parser->m_tagStack;
for (;;) {
TAG *p;
if (tagList == NULL) {
if (parser->m_freeTagList == NULL) break;
tagList = parser->m_freeTagList;
parser->m_freeTagList = NULL;
}
p = tagList;
tagList = tagList->parent;
FREE(parser, p->buf);
destroyBindings(p->bindings, parser);
FREE(parser, p);
}
/* free m_openInternalEntities and m_freeInternalEntities */
entityList = parser->m_openInternalEntities;
for (;;) {
OPEN_INTERNAL_ENTITY *openEntity;
if (entityList == NULL) {
if (parser->m_freeInternalEntities == NULL) break;
entityList = parser->m_freeInternalEntities;
parser->m_freeInternalEntities = NULL;
}
openEntity = entityList;
entityList = entityList->next;
FREE(parser, openEntity);
}
destroyBindings(parser->m_freeBindingList, parser);
destroyBindings(parser->m_inheritedBindings, parser);
poolDestroy(&parser->m_tempPool);
poolDestroy(&parser->m_temp2Pool);
FREE(parser, (void *)parser->m_protocolEncodingName);
#ifdef XML_DTD
/* external parameter entity parsers share the DTD structure
parser->m_dtd with the root parser, so we must not destroy it
*/
if (!parser->m_isParamEntity && parser->m_dtd)
#else
if (parser->m_dtd)
#endif /* XML_DTD */
dtdDestroy(parser->m_dtd, (XML_Bool)!parser->m_parentParser,
&parser->m_mem);
FREE(parser, (void *)parser->m_atts);
#ifdef XML_ATTR_INFO
FREE(parser, (void *)parser->m_attInfo);
#endif
FREE(parser, parser->m_groupConnector);
FREE(parser, parser->m_buffer);
FREE(parser, parser->m_dataBuf);
FREE(parser, parser->m_nsAtts);
FREE(parser, parser->m_unknownEncodingMem);
if (parser->m_unknownEncodingRelease)
parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
FREE(parser, parser);
}
void XML_UseParserAsHandlerArg(XML_Parser parser) {
if (parser != NULL) parser->m_handlerArg = parser;
}
enum XML_Error XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
if (parser == NULL) return XML_ERROR_INVALID_ARGUMENT;
#ifdef XML_DTD
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parser->m_parsingStatus.parsing == XML_PARSING ||
parser->m_parsingStatus.parsing == XML_SUSPENDED)
return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
parser->m_useForeignDTD = useDTD;
return XML_ERROR_NONE;
#else
return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
#endif
}
void XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
if (parser == NULL) return;
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parser->m_parsingStatus.parsing == XML_PARSING ||
parser->m_parsingStatus.parsing == XML_SUSPENDED)
return;
parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
}
void XML_SetUserData(XML_Parser parser, void *p) {
if (parser == NULL) return;
if (parser->m_handlerArg == parser->m_userData)
parser->m_handlerArg = parser->m_userData = p;
else
parser->m_userData = p;
}
enum XML_Status XML_SetBase(XML_Parser parser, const XML_Char *p) {
if (parser == NULL) return XML_STATUS_ERROR;
if (p) {
p = poolCopyString(&parser->m_dtd->pool, p);
if (!p) return XML_STATUS_ERROR;
parser->m_curBase = p;
} else
parser->m_curBase = NULL;
return XML_STATUS_OK;
}
const XML_Char *XML_GetBase(XML_Parser parser) {
if (parser == NULL) return NULL;
return parser->m_curBase;
}
int XML_GetSpecifiedAttributeCount(XML_Parser parser) {
if (parser == NULL) return -1;
return parser->m_nSpecifiedAtts;
}
int XML_GetIdAttributeIndex(XML_Parser parser) {
if (parser == NULL) return -1;
return parser->m_idAttIndex;
}
#ifdef XML_ATTR_INFO
const XML_AttrInfo *XML_GetAttributeInfo(XML_Parser parser) {
if (parser == NULL) return NULL;
return parser->m_attInfo;
}
#endif
void XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,
XML_EndElementHandler end) {
if (parser == NULL) return;
parser->m_startElementHandler = start;
parser->m_endElementHandler = end;
}
void XML_SetStartElementHandler(XML_Parser parser,
XML_StartElementHandler start) {
if (parser != NULL) parser->m_startElementHandler = start;
}
void XML_SetEndElementHandler(XML_Parser parser,
XML_EndElementHandler end) {
if (parser != NULL) parser->m_endElementHandler = end;
}
void XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler) {
if (parser != NULL) parser->m_characterDataHandler = handler;
}
void XML_SetProcessingInstructionHandler(
XML_Parser parser, XML_ProcessingInstructionHandler handler) {
if (parser != NULL) parser->m_processingInstructionHandler = handler;
}
void XML_SetCommentHandler(XML_Parser parser,
XML_CommentHandler handler) {
if (parser != NULL) parser->m_commentHandler = handler;
}
void XML_SetCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end) {
if (parser == NULL) return;
parser->m_startCdataSectionHandler = start;
parser->m_endCdataSectionHandler = end;
}
void XML_SetStartCdataSectionHandler(
XML_Parser parser, XML_StartCdataSectionHandler start) {
if (parser != NULL) parser->m_startCdataSectionHandler = start;
}
void XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end) {
if (parser != NULL) parser->m_endCdataSectionHandler = end;
}
void XML_SetDefaultHandler(XML_Parser parser,
XML_DefaultHandler handler) {
if (parser == NULL) return;
parser->m_defaultHandler = handler;
parser->m_defaultExpandInternalEntities = XML_FALSE;
}
void XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler) {
if (parser == NULL) return;
parser->m_defaultHandler = handler;
parser->m_defaultExpandInternalEntities = XML_TRUE;
}
void XML_SetDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end) {
if (parser == NULL) return;
parser->m_startDoctypeDeclHandler = start;
parser->m_endDoctypeDeclHandler = end;
}
void XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start) {
if (parser != NULL) parser->m_startDoctypeDeclHandler = start;
}
void XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end) {
if (parser != NULL) parser->m_endDoctypeDeclHandler = end;
}
void XML_SetUnparsedEntityDeclHandler(
XML_Parser parser, XML_UnparsedEntityDeclHandler handler) {
if (parser != NULL) parser->m_unparsedEntityDeclHandler = handler;
}
void XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler) {
if (parser != NULL) parser->m_notationDeclHandler = handler;
}
void XML_SetNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end) {
if (parser == NULL) return;
parser->m_startNamespaceDeclHandler = start;
parser->m_endNamespaceDeclHandler = end;
}
void XML_SetStartNamespaceDeclHandler(
XML_Parser parser, XML_StartNamespaceDeclHandler start) {
if (parser != NULL) parser->m_startNamespaceDeclHandler = start;
}
void XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end) {
if (parser != NULL) parser->m_endNamespaceDeclHandler = end;
}
void XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler) {
if (parser != NULL) parser->m_notStandaloneHandler = handler;
}
void XML_SetExternalEntityRefHandler(
XML_Parser parser, XML_ExternalEntityRefHandler handler) {
if (parser != NULL) parser->m_externalEntityRefHandler = handler;
}
void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
if (parser == NULL) return;
if (arg)
parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
else
parser->m_externalEntityRefHandlerArg = parser;
}
void XML_SetSkippedEntityHandler(XML_Parser parser,
XML_SkippedEntityHandler handler) {
if (parser != NULL) parser->m_skippedEntityHandler = handler;
}
void XML_SetUnknownEncodingHandler(XML_Parser parser,
XML_UnknownEncodingHandler handler,
void *data) {
if (parser == NULL) return;
parser->m_unknownEncodingHandler = handler;
parser->m_unknownEncodingHandlerData = data;
}
void XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl) {
if (parser != NULL) parser->m_elementDeclHandler = eldecl;
}
void XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl) {
if (parser != NULL) parser->m_attlistDeclHandler = attdecl;
}
void XML_SetEntityDeclHandler(XML_Parser parser,
XML_EntityDeclHandler handler) {
if (parser != NULL) parser->m_entityDeclHandler = handler;
}
void XML_SetXmlDeclHandler(XML_Parser parser,
XML_XmlDeclHandler handler) {
if (parser != NULL) parser->m_xmlDeclHandler = handler;
}
int XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing peParsing) {
if (parser == NULL) return 0;
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parser->m_parsingStatus.parsing == XML_PARSING ||
parser->m_parsingStatus.parsing == XML_SUSPENDED)
return 0;
#ifdef XML_DTD
parser->m_paramEntityParsing = peParsing;
return 1;
#else
return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
#endif
}
int XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
if (parser == NULL) return 0;
if (parser->m_parentParser)
return XML_SetHashSalt(parser->m_parentParser, hash_salt);
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parser->m_parsingStatus.parsing == XML_PARSING ||
parser->m_parsingStatus.parsing == XML_SUSPENDED)
return 0;
parser->m_hash_secret_salt = hash_salt;
return 1;
}
enum XML_Status XML_Parse(XML_Parser parser, const char *s, int len,
int isFinal) {
if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
if (parser != NULL) parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
return XML_STATUS_ERROR;
}
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
parser->m_errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR;
case XML_FINISHED:
parser->m_errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;
case XML_INITIALIZED:
if (parser->m_parentParser == NULL && !startParsing(parser)) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return XML_STATUS_ERROR;
}
/* fall through */
default:
parser->m_parsingStatus.parsing = XML_PARSING;
}
if (len == 0) {
parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
if (!isFinal) return XML_STATUS_OK;
parser->m_positionPtr = parser->m_bufferPtr;
parser->m_parseEndPtr = parser->m_bufferEnd;
/* If data are left over from last buffer, and we now know that these
data are the final chunk of input, then we have to check them again
to detect errors based on that fact.
*/
parser->m_errorCode =
parser->m_processor(parser, parser->m_bufferPtr, parser->m_parseEndPtr,
&parser->m_bufferPtr);
if (parser->m_errorCode == XML_ERROR_NONE) {
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
/* It is hard to be certain, but it seems that this case
* cannot occur. This code is cleaning up a previous parse
* with no new data (since len == 0). Changing the parsing
* state requires getting to execute a handler function, and
* there doesn't seem to be an opportunity for that while in
* this circumstance.
*
* Given the uncertainty, we retain the code but exclude it
* from coverage tests.
*
* LCOV_EXCL_START
*/
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
parser->m_bufferPtr, &parser->m_position);
parser->m_positionPtr = parser->m_bufferPtr;
return XML_STATUS_SUSPENDED;
/* LCOV_EXCL_STOP */
case XML_INITIALIZED:
case XML_PARSING:
parser->m_parsingStatus.parsing = XML_FINISHED;
/* fall through */
default:
return XML_STATUS_OK;
}
}
parser->m_eventEndPtr = parser->m_eventPtr;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
}
#ifndef XML_CONTEXT_BYTES
else if (parser->m_bufferPtr == parser->m_bufferEnd) {
const char *end;
int nLeftOver;
enum XML_Status result;
/* Detect overflow (a+b > MAX <==> b > MAX-a) */
if (len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
parser->m_eventPtr = parser->m_eventEndPtr = NULL;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
}
parser->m_parseEndByteIndex += len;
parser->m_positionPtr = s;
parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
parser->m_errorCode =
parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
if (parser->m_errorCode != XML_ERROR_NONE) {
parser->m_eventEndPtr = parser->m_eventPtr;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
} else {
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_PARSING:
if (isFinal) {
parser->m_parsingStatus.parsing = XML_FINISHED;
return XML_STATUS_OK;
}
/* fall through */
default:
result = XML_STATUS_OK;
}
}
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
&parser->m_position);
nLeftOver = s + len - end;
if (nLeftOver) {
if (parser->m_buffer == NULL ||
nLeftOver > parser->m_bufferLim - parser->m_buffer) {
/* avoid _signed_ integer overflow */
char *temp = NULL;
const int bytesToAllocate = (int)((unsigned)len * 2U);
if (bytesToAllocate > 0) {
temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
}
if (temp == NULL) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
parser->m_eventPtr = parser->m_eventEndPtr = NULL;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
}
parser->m_buffer = temp;
parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
}
memcpy(parser->m_buffer, end, nLeftOver);
}
parser->m_bufferPtr = parser->m_buffer;
parser->m_bufferEnd = parser->m_buffer + nLeftOver;
parser->m_positionPtr = parser->m_bufferPtr;
parser->m_parseEndPtr = parser->m_bufferEnd;
parser->m_eventPtr = parser->m_bufferPtr;
parser->m_eventEndPtr = parser->m_bufferPtr;
return result;
}
#endif /* not defined XML_CONTEXT_BYTES */
else {
void *buff = XML_GetBuffer(parser, len);
if (buff == NULL)
return XML_STATUS_ERROR;
else {
memcpy(buff, s, len);
return XML_ParseBuffer(parser, len, isFinal);
}
}
}
enum XML_Status XML_ParseBuffer(XML_Parser parser, int len,
int isFinal) {
const char *start;
enum XML_Status result = XML_STATUS_OK;
if (parser == NULL) return XML_STATUS_ERROR;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
parser->m_errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR;
case XML_FINISHED:
parser->m_errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;
case XML_INITIALIZED:
if (parser->m_parentParser == NULL && !startParsing(parser)) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return XML_STATUS_ERROR;
}
/* fall through */
default:
parser->m_parsingStatus.parsing = XML_PARSING;
}
start = parser->m_bufferPtr;
parser->m_positionPtr = start;
parser->m_bufferEnd += len;
parser->m_parseEndPtr = parser->m_bufferEnd;
parser->m_parseEndByteIndex += len;
parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
parser->m_errorCode = parser->m_processor(
parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
if (parser->m_errorCode != XML_ERROR_NONE) {
parser->m_eventEndPtr = parser->m_eventPtr;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
} else {
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_PARSING:
if (isFinal) {
parser->m_parsingStatus.parsing = XML_FINISHED;
return result;
}
default:; /* should not happen */
}
}
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
parser->m_bufferPtr, &parser->m_position);
parser->m_positionPtr = parser->m_bufferPtr;
return result;
}
void *XML_GetBuffer(XML_Parser parser, int len) {
if (parser == NULL) return NULL;
if (len < 0) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return NULL;
}
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
parser->m_errorCode = XML_ERROR_SUSPENDED;
return NULL;
case XML_FINISHED:
parser->m_errorCode = XML_ERROR_FINISHED;
return NULL;
default:;
}
if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
#ifdef XML_CONTEXT_BYTES
int keep;
#endif /* defined XML_CONTEXT_BYTES */
/* Do not invoke signed arithmetic overflow: */
int neededSize =
(int)((unsigned)len + (unsigned)EXPAT_SAFE_PTR_DIFF(
parser->m_bufferEnd, parser->m_bufferPtr));
if (neededSize < 0) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return NULL;
}
#ifdef XML_CONTEXT_BYTES
keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
if (keep > XML_CONTEXT_BYTES) keep = XML_CONTEXT_BYTES;
neededSize += keep;
#endif /* defined XML_CONTEXT_BYTES */
if (neededSize <=
EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
#ifdef XML_CONTEXT_BYTES
if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
int offset =
(int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer) -
keep;
/* The buffer pointers cannot be NULL here; we have at least some bytes
* in the buffer */
memmove(parser->m_buffer, &parser->m_buffer[offset],
parser->m_bufferEnd - parser->m_bufferPtr + keep);
parser->m_bufferEnd -= offset;
parser->m_bufferPtr -= offset;
}
#else
if (parser->m_buffer && parser->m_bufferPtr) {
memmove(parser->m_buffer, parser->m_bufferPtr,
EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
parser->m_bufferEnd =
parser->m_buffer +
EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
parser->m_bufferPtr = parser->m_buffer;
}
#endif /* not defined XML_CONTEXT_BYTES */
} else {
char *newBuf;
int bufferSize =
(int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
if (bufferSize == 0) bufferSize = INIT_BUFFER_SIZE;
do {
/* Do not invoke signed arithmetic overflow: */
bufferSize = (int)(2U * (unsigned)bufferSize);
} while (bufferSize < neededSize && bufferSize > 0);
if (bufferSize <= 0) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return NULL;
}
newBuf = (char *)MALLOC(parser, bufferSize);
if (newBuf == 0) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return NULL;
}
parser->m_bufferLim = newBuf + bufferSize;
#ifdef XML_CONTEXT_BYTES
if (parser->m_bufferPtr) {
memcpy(newBuf, &parser->m_bufferPtr[-keep],
EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr) +
keep);
FREE(parser, parser->m_buffer);
parser->m_buffer = newBuf;
parser->m_bufferEnd =
parser->m_buffer +
EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr) +
keep;
parser->m_bufferPtr = parser->m_buffer + keep;
} else {
/* This must be a brand new buffer with no data in it yet */
parser->m_bufferEnd = newBuf;
parser->m_bufferPtr = parser->m_buffer = newBuf;
}
#else
if (parser->m_bufferPtr) {
memcpy(newBuf, parser->m_bufferPtr,
EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
FREE(parser, parser->m_buffer);
parser->m_bufferEnd = newBuf + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd,
parser->m_bufferPtr);
} else {
/* This must be a brand new buffer with no data in it yet */
parser->m_bufferEnd = newBuf;
}
parser->m_bufferPtr = parser->m_buffer = newBuf;
#endif /* not defined XML_CONTEXT_BYTES */
}
parser->m_eventPtr = parser->m_eventEndPtr = NULL;
parser->m_positionPtr = NULL;
}
return parser->m_bufferEnd;
}
enum XML_Status XML_StopParser(XML_Parser parser, XML_Bool resumable) {
if (parser == NULL) return XML_STATUS_ERROR;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
if (resumable) {
parser->m_errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR;
}
parser->m_parsingStatus.parsing = XML_FINISHED;
break;
case XML_FINISHED:
parser->m_errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;
default:
if (resumable) {
#ifdef XML_DTD
if (parser->m_isParamEntity) {
parser->m_errorCode = XML_ERROR_SUSPEND_PE;
return XML_STATUS_ERROR;
}
#endif
parser->m_parsingStatus.parsing = XML_SUSPENDED;
} else
parser->m_parsingStatus.parsing = XML_FINISHED;
}
return XML_STATUS_OK;
}
enum XML_Status XML_ResumeParser(XML_Parser parser) {
enum XML_Status result = XML_STATUS_OK;
if (parser == NULL) return XML_STATUS_ERROR;
if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
return XML_STATUS_ERROR;
}
parser->m_parsingStatus.parsing = XML_PARSING;
parser->m_errorCode = parser->m_processor(
parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
if (parser->m_errorCode != XML_ERROR_NONE) {
parser->m_eventEndPtr = parser->m_eventPtr;
parser->m_processor = errorProcessor;
return XML_STATUS_ERROR;
} else {
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_PARSING:
if (parser->m_parsingStatus.finalBuffer) {
parser->m_parsingStatus.parsing = XML_FINISHED;
return result;
}
default:;
}
}
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
parser->m_bufferPtr, &parser->m_position);
parser->m_positionPtr = parser->m_bufferPtr;
return result;
}
void XML_GetParsingStatus(XML_Parser parser,
XML_ParsingStatus *status) {
if (parser == NULL) return;
assert(status != NULL);
*status = parser->m_parsingStatus;
}
enum XML_Error XML_GetErrorCode(XML_Parser parser) {
if (parser == NULL) return XML_ERROR_INVALID_ARGUMENT;
return parser->m_errorCode;
}
XML_Index XML_GetCurrentByteIndex(XML_Parser parser) {
if (parser == NULL) return -1;
if (parser->m_eventPtr)
return (XML_Index)(parser->m_parseEndByteIndex -
(parser->m_parseEndPtr - parser->m_eventPtr));
return -1;
}
int XML_GetCurrentByteCount(XML_Parser parser) {
if (parser == NULL) return 0;
if (parser->m_eventEndPtr && parser->m_eventPtr)
return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
return 0;
}
const char *XML_GetInputContext(XML_Parser parser, int *offset,
int *size) {
#ifdef XML_CONTEXT_BYTES
if (parser == NULL) return NULL;
if (parser->m_eventPtr && parser->m_buffer) {
if (offset != NULL) *offset = (int)(parser->m_eventPtr - parser->m_buffer);
if (size != NULL) *size = (int)(parser->m_bufferEnd - parser->m_buffer);
return parser->m_buffer;
}
#else
(void)parser;
(void)offset;
(void)size;
#endif /* defined XML_CONTEXT_BYTES */
return (char *)0;
}
XML_Size XML_GetCurrentLineNumber(XML_Parser parser) {
if (parser == NULL) return 0;
if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
parser->m_eventPtr, &parser->m_position);
parser->m_positionPtr = parser->m_eventPtr;
}
return parser->m_position.lineNumber + 1;
}
XML_Size XML_GetCurrentColumnNumber(XML_Parser parser) {
if (parser == NULL) return 0;
if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
parser->m_eventPtr, &parser->m_position);
parser->m_positionPtr = parser->m_eventPtr;
}
return parser->m_position.columnNumber;
}
void XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
if (parser != NULL) FREE(parser, model);
}
void *XML_MemMalloc(XML_Parser parser, size_t size) {
if (parser == NULL) return NULL;
return MALLOC(parser, size);
}
void *XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
if (parser == NULL) return NULL;
return REALLOC(parser, ptr, size);
}
void XML_MemFree(XML_Parser parser, void *ptr) {
if (parser != NULL) FREE(parser, ptr);
}
void XML_DefaultCurrent(XML_Parser parser) {
if (parser == NULL) return;
if (parser->m_defaultHandler) {
if (parser->m_openInternalEntities)
reportDefault(parser, parser->m_internalEncoding,
parser->m_openInternalEntities->internalEventPtr,
parser->m_openInternalEntities->internalEventEndPtr);
else
reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
parser->m_eventEndPtr);
}
}
const XML_LChar *XML_ErrorString(enum XML_Error code) {
switch (code) {
case XML_ERROR_NONE:
return NULL;
case XML_ERROR_NO_MEMORY:
return XML_L("out of memory");
case XML_ERROR_SYNTAX:
return XML_L("syntax error");
case XML_ERROR_NO_ELEMENTS:
return XML_L("no element found");
case XML_ERROR_INVALID_TOKEN:
return XML_L("not well-formed (invalid token)");
case XML_ERROR_UNCLOSED_TOKEN:
return XML_L("unclosed token");
case XML_ERROR_PARTIAL_CHAR:
return XML_L("partial character");
case XML_ERROR_TAG_MISMATCH:
return XML_L("mismatched tag");
case XML_ERROR_DUPLICATE_ATTRIBUTE:
return XML_L("duplicate attribute");
case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
return XML_L("junk after document element");
case XML_ERROR_PARAM_ENTITY_REF:
return XML_L("illegal parameter entity reference");
case XML_ERROR_UNDEFINED_ENTITY:
return XML_L("undefined entity");
case XML_ERROR_RECURSIVE_ENTITY_REF:
return XML_L("recursive entity reference");
case XML_ERROR_ASYNC_ENTITY:
return XML_L("asynchronous entity");
case XML_ERROR_BAD_CHAR_REF:
return XML_L("reference to invalid character number");
case XML_ERROR_BINARY_ENTITY_REF:
return XML_L("reference to binary entity");
case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
return XML_L("reference to external entity in attribute");
case XML_ERROR_MISPLACED_XML_PI:
return XML_L("XML or text declaration not at start of entity");
case XML_ERROR_UNKNOWN_ENCODING:
return XML_L("unknown encoding");
case XML_ERROR_INCORRECT_ENCODING:
return XML_L("encoding specified in XML declaration is incorrect");
case XML_ERROR_UNCLOSED_CDATA_SECTION:
return XML_L("unclosed CDATA section");
case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
return XML_L("error in processing external entity reference");
case XML_ERROR_NOT_STANDALONE:
return XML_L("document is not standalone");
case XML_ERROR_UNEXPECTED_STATE:
return XML_L("unexpected parser state - please send a bug report");
case XML_ERROR_ENTITY_DECLARED_IN_PE:
return XML_L("entity declared in parameter entity");
case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
return XML_L("requested feature requires XML_DTD support in Expat");
case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
return XML_L("cannot change setting once parsing has begun");
/* Added in 1.95.7. */
case XML_ERROR_UNBOUND_PREFIX:
return XML_L("unbound prefix");
/* Added in 1.95.8. */
case XML_ERROR_UNDECLARING_PREFIX:
return XML_L("must not undeclare prefix");
case XML_ERROR_INCOMPLETE_PE:
return XML_L("incomplete markup in parameter entity");
case XML_ERROR_XML_DECL:
return XML_L("XML declaration not well-formed");
case XML_ERROR_TEXT_DECL:
return XML_L("text declaration not well-formed");
case XML_ERROR_PUBLICID:
return XML_L("illegal character(s) in public id");
case XML_ERROR_SUSPENDED:
return XML_L("parser suspended");
case XML_ERROR_NOT_SUSPENDED:
return XML_L("parser not suspended");
case XML_ERROR_ABORTED:
return XML_L("parsing aborted");
case XML_ERROR_FINISHED:
return XML_L("parsing finished");
case XML_ERROR_SUSPEND_PE:
return XML_L("cannot suspend in external parameter entity");
/* Added in 2.0.0. */
case XML_ERROR_RESERVED_PREFIX_XML:
return XML_L("reserved prefix (xml) must not be undeclared or bound to "
"another namespace name");
case XML_ERROR_RESERVED_PREFIX_XMLNS:
return XML_L(
"reserved prefix (xmlns) must not be declared or undeclared");
case XML_ERROR_RESERVED_NAMESPACE_URI:
return XML_L(
"prefix must not be bound to one of the reserved namespace names");
/* Added in 2.2.5. */
case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
return XML_L("invalid argument");
}
return NULL;
}
const XML_LChar *XML_ExpatVersion(void) {
/* V1 is used to string-ize the version number. However, it would
string-ize the actual version macro *names* unless we get them
substituted before being passed to V1. CPP is defined to expand
a macro, then rescan for more expansions. Thus, we use V2 to expand
the version macros, then CPP will expand the resulting V1() macro
with the correct numerals. */
/* ### I'm assuming cpp is portable in this respect... */
#define V1(a, b, c) XML_L(#a) XML_L(".") XML_L(#b) XML_L(".") XML_L(#c)
#define V2(a, b, c) XML_L("expat_") V1(a, b, c)
return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
#undef V1
#undef V2
}
XML_Expat_Version XML_ExpatVersionInfo(void) {
XML_Expat_Version version;
version.major = XML_MAJOR_VERSION;
version.minor = XML_MINOR_VERSION;
version.micro = XML_MICRO_VERSION;
return version;
}
const XML_Feature *XML_GetFeatureList(void) {
static const XML_Feature features[] = {
{XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
sizeof(XML_Char)},
{XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
sizeof(XML_LChar)},
#ifdef XML_UNICODE
{XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
#endif
#ifdef XML_UNICODE_WCHAR_T
{XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},
#endif
#ifdef XML_DTD
{XML_FEATURE_DTD, XML_L("XML_DTD"), 0},
#endif
#ifdef XML_CONTEXT_BYTES
{XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),
XML_CONTEXT_BYTES},
#endif
#ifdef XML_MIN_SIZE
{XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
#endif
#ifdef XML_NS
{XML_FEATURE_NS, XML_L("XML_NS"), 0},
#endif
#ifdef XML_LARGE_SIZE
{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
#endif
#ifdef XML_ATTR_INFO
{XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
#endif
{XML_FEATURE_END, NULL, 0}};
return features;
}
/* Initially tag->rawName always points into the parse buffer;
for those TAG instances opened while the current parse buffer was
processed, and not yet closed, we need to store tag->rawName in a more
permanent location, since the parse buffer is about to be discarded.
*/
static XML_Bool storeRawNames(XML_Parser parser) {
TAG *tag = parser->m_tagStack;
while (tag) {
int bufSize;
int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
char *rawNameBuf = tag->buf + nameLen;
/* Stop if already stored. Since m_tagStack is a stack, we can stop
at the first entry that has already been copied; everything
below it in the stack is already been accounted for in a
previous call to this function.
*/
if (tag->rawName == rawNameBuf) break;
/* For re-use purposes we need to ensure that the
size of tag->buf is a multiple of sizeof(XML_Char).
*/
bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
if (bufSize > tag->bufEnd - tag->buf) {
char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
if (temp == NULL) return XML_FALSE;
/* if tag->name.str points to tag->buf (only when namespace
processing is off) then we have to update it
*/
if (tag->name.str == (XML_Char *)tag->buf)
tag->name.str = (XML_Char *)temp;
/* if tag->name.localPart is set (when namespace processing is on)
then update it as well, since it will always point into tag->buf
*/
if (tag->name.localPart)
tag->name.localPart =
(XML_Char *)temp + (tag->name.localPart - (XML_Char *)tag->buf);
tag->buf = temp;
tag->bufEnd = temp + bufSize;
rawNameBuf = temp + nameLen;
}
memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
tag->rawName = rawNameBuf;
tag = tag->parent;
}
return XML_TRUE;
}
static enum XML_Error contentProcessor(XML_Parser parser,
const char *start,
const char *end,
const char **endPtr) {
enum XML_Error result =
doContent(parser, 0, parser->m_encoding, start, end, endPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer);
if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser)) return XML_ERROR_NO_MEMORY;
}
return result;
}
static enum XML_Error externalEntityInitProcessor(XML_Parser parser,
const char *start,
const char *end,
const char **endPtr) {
enum XML_Error result = initializeEncoding(parser);
if (result != XML_ERROR_NONE) return result;
parser->m_processor = externalEntityInitProcessor2;
return externalEntityInitProcessor2(parser, start, end, endPtr);
}
static enum XML_Error
externalEntityInitProcessor2(XML_Parser parser, const char *start,
const char *end, const char **endPtr) {
const char *next = start; /* XmlContentTok doesn't always set the last arg */
int tok = XmlContentTok(parser->m_encoding, start, end, &next);
switch (tok) {
case XML_TOK_BOM:
/* If we are at the end of the buffer, this would cause the next stage,
i.e. externalEntityInitProcessor3, to pass control directly to
doContent (by detecting XML_TOK_NONE) without processing any xml text
declaration - causing the error XML_ERROR_MISPLACED_XML_PI in
doContent.
*/
if (next == end && !parser->m_parsingStatus.finalBuffer) {
*endPtr = next;
return XML_ERROR_NONE;
}
start = next;
break;
case XML_TOK_PARTIAL:
if (!parser->m_parsingStatus.finalBuffer) {
*endPtr = start;
return XML_ERROR_NONE;
}
parser->m_eventPtr = start;
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (!parser->m_parsingStatus.finalBuffer) {
*endPtr = start;
return XML_ERROR_NONE;
}
parser->m_eventPtr = start;
return XML_ERROR_PARTIAL_CHAR;
}
parser->m_processor = externalEntityInitProcessor3;
return externalEntityInitProcessor3(parser, start, end, endPtr);
}
static enum XML_Error
externalEntityInitProcessor3(XML_Parser parser, const char *start,
const char *end, const char **endPtr) {
int tok;
const char *next = start; /* XmlContentTok doesn't always set the last arg */
parser->m_eventPtr = start;
tok = XmlContentTok(parser->m_encoding, start, end, &next);
parser->m_eventEndPtr = next;
switch (tok) {
case XML_TOK_XML_DECL: {
enum XML_Error result;
result = processXmlDecl(parser, 1, start, next);
if (result != XML_ERROR_NONE) return result;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*endPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default:
start = next;
}
} break;
case XML_TOK_PARTIAL:
if (!parser->m_parsingStatus.finalBuffer) {
*endPtr = start;
return XML_ERROR_NONE;
}
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (!parser->m_parsingStatus.finalBuffer) {
*endPtr = start;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
}
parser->m_processor = externalEntityContentProcessor;
parser->m_tagLevel = 1;
return externalEntityContentProcessor(parser, start, end, endPtr);
}
static enum XML_Error
externalEntityContentProcessor(XML_Parser parser, const char *start,
const char *end, const char **endPtr) {
enum XML_Error result =
doContent(parser, 1, parser->m_encoding, start, end, endPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer);
if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser)) return XML_ERROR_NO_MEMORY;
}
return result;
}
static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
const ENCODING *enc, const char *s,
const char *end, const char **nextPtr,
XML_Bool haveMore) {
/* save one level of indirection */
DTD *const dtd = parser->m_dtd;
const char **eventPP;
const char **eventEndPP;
if (enc == parser->m_encoding) {
eventPP = &parser->m_eventPtr;
eventEndPP = &parser->m_eventEndPtr;
} else {
eventPP = &(parser->m_openInternalEntities->internalEventPtr);
eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
}
*eventPP = s;
for (;;) {
const char *next = s; /* XmlContentTok doesn't always set the last arg */
int tok = XmlContentTok(enc, s, end, &next);
*eventEndPP = next;
switch (tok) {
case XML_TOK_TRAILING_CR:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
*eventEndPP = end;
if (parser->m_characterDataHandler) {
XML_Char c = 0xA;
parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
*/
if (startTagLevel == 0) return XML_ERROR_NO_ELEMENTS;
if (parser->m_tagLevel != startTagLevel) return XML_ERROR_ASYNC_ENTITY;
*nextPtr = end;
return XML_ERROR_NONE;
case XML_TOK_NONE:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
if (startTagLevel > 0) {
if (parser->m_tagLevel != startTagLevel)
return XML_ERROR_ASYNC_ENTITY;
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_NO_ELEMENTS;
case XML_TOK_INVALID:
*eventPP = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_ENTITY_REF: {
const XML_Char *name;
ENTITY *entity;
XML_Char ch = (XML_Char)XmlPredefinedEntityName(
enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
if (ch) {
if (parser->m_characterDataHandler)
parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
}
name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!name) return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
poolDiscard(&dtd->pool);
/* First, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal,
otherwise call the skipped entity or default handler.
*/
if (!dtd->hasParamEntityRefs || dtd->standalone) {
if (!entity)
return XML_ERROR_UNDEFINED_ENTITY;
else if (!entity->is_internal)
return XML_ERROR_ENTITY_DECLARED_IN_PE;
} else if (!entity) {
if (parser->m_skippedEntityHandler)
parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
}
if (entity->open_) return XML_ERROR_RECURSIVE_ENTITY_REF;
if (entity->notation) return XML_ERROR_BINARY_ENTITY_REF;
if (entity->textPtr) {
enum XML_Error result;
if (!parser->m_defaultExpandInternalEntities) {
if (parser->m_skippedEntityHandler)
parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
0);
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
}
result = processInternalEntity(parser, entity, XML_FALSE);
if (result != XML_ERROR_NONE) return result;
} else if (parser->m_externalEntityRefHandler) {
const XML_Char *context;
entity->open_ = XML_TRUE;
context = getContext(parser);
entity->open_ = XML_FALSE;
if (!context) return XML_ERROR_NO_MEMORY;
if (!parser->m_externalEntityRefHandler(
parser->m_externalEntityRefHandlerArg, context, entity->base,
entity->systemId, entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
poolDiscard(&parser->m_tempPool);
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
}
case XML_TOK_START_TAG_NO_ATTS:
/* fall through */
case XML_TOK_START_TAG_WITH_ATTS: {
TAG *tag;
enum XML_Error result;
XML_Char *toPtr;
if (parser->m_freeTagList) {
tag = parser->m_freeTagList;
parser->m_freeTagList = parser->m_freeTagList->parent;
} else {
tag = (TAG *)MALLOC(parser, sizeof(TAG));
if (!tag) return XML_ERROR_NO_MEMORY;
tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
if (!tag->buf) {
FREE(parser, tag);
return XML_ERROR_NO_MEMORY;
}
tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
}
tag->bindings = NULL;
tag->parent = parser->m_tagStack;
parser->m_tagStack = tag;
tag->name.localPart = NULL;
tag->name.prefix = NULL;
tag->rawName = s + enc->minBytesPerChar;
tag->rawNameLength = XmlNameLength(enc, tag->rawName);
++parser->m_tagLevel;
{
const char *rawNameEnd = tag->rawName + tag->rawNameLength;
const char *fromPtr = tag->rawName;
toPtr = (XML_Char *)tag->buf;
for (;;) {
int bufSize;
int convLen;
const enum XML_Convert_Result convert_res =
XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,
(ICHAR *)tag->bufEnd - 1);
convLen = (int)(toPtr - (XML_Char *)tag->buf);
if ((fromPtr >= rawNameEnd) ||
(convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
tag->name.strLen = convLen;
break;
}
bufSize = (int)(tag->bufEnd - tag->buf) << 1;
{
char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
if (temp == NULL) return XML_ERROR_NO_MEMORY;
tag->buf = temp;
tag->bufEnd = temp + bufSize;
toPtr = (XML_Char *)temp + convLen;
}
}
}
tag->name.str = (XML_Char *)tag->buf;
*toPtr = XML_T('\0');
result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
if (result) return result;
if (parser->m_startElementHandler)
parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
(const XML_Char **)parser->m_atts);
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
poolClear(&parser->m_tempPool);
break;
}
case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
/* fall through */
case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {
const char *rawName = s + enc->minBytesPerChar;
enum XML_Error result;
BINDING *bindings = NULL;
XML_Bool noElmHandlers = XML_TRUE;
TAG_NAME name;
name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
rawName + XmlNameLength(enc, rawName));
if (!name.str) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_tempPool);
result = storeAtts(parser, enc, s, &name, &bindings);
if (result != XML_ERROR_NONE) {
freeBindings(parser, bindings);
return result;
}
poolFinish(&parser->m_tempPool);
if (parser->m_startElementHandler) {
parser->m_startElementHandler(parser->m_handlerArg, name.str,
(const XML_Char **)parser->m_atts);
noElmHandlers = XML_FALSE;
}
if (parser->m_endElementHandler) {
if (parser->m_startElementHandler) *eventPP = *eventEndPP;
parser->m_endElementHandler(parser->m_handlerArg, name.str);
noElmHandlers = XML_FALSE;
}
if (noElmHandlers && parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
poolClear(&parser->m_tempPool);
freeBindings(parser, bindings);
}
if ((parser->m_tagLevel == 0) &&
(parser->m_parsingStatus.parsing != XML_FINISHED)) {
if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
parser->m_processor = epilogProcessor;
else
return epilogProcessor(parser, next, end, nextPtr);
}
break;
case XML_TOK_END_TAG:
if (parser->m_tagLevel == startTagLevel)
return XML_ERROR_ASYNC_ENTITY;
else {
int len;
const char *rawName;
TAG *tag = parser->m_tagStack;
parser->m_tagStack = tag->parent;
tag->parent = parser->m_freeTagList;
parser->m_freeTagList = tag;
rawName = s + enc->minBytesPerChar * 2;
len = XmlNameLength(enc, rawName);
if (len != tag->rawNameLength ||
bcmp(tag->rawName, rawName, len)) {
*eventPP = rawName;
return XML_ERROR_TAG_MISMATCH;
}
--parser->m_tagLevel;
if (parser->m_endElementHandler) {
const XML_Char *localPart;
const XML_Char *prefix;
XML_Char *uri;
localPart = tag->name.localPart;
if (parser->m_ns && localPart) {
/* localPart and prefix may have been overwritten in
tag->name.str, since this points to the binding->uri
buffer which gets re-used; so we have to add them again
*/
uri = (XML_Char *)tag->name.str + tag->name.uriLen;
/* don't need to check for space - already done in storeAtts() */
while (*localPart) *uri++ = *localPart++;
prefix = (XML_Char *)tag->name.prefix;
if (parser->m_ns_triplets && prefix) {
*uri++ = parser->m_namespaceSeparator;
while (*prefix) *uri++ = *prefix++;
}
*uri = XML_T('\0');
}
parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
while (tag->bindings) {
BINDING *b = tag->bindings;
if (parser->m_endNamespaceDeclHandler)
parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
b->prefix->name);
tag->bindings = tag->bindings->nextTagBinding;
b->nextTagBinding = parser->m_freeBindingList;
parser->m_freeBindingList = b;
b->prefix->binding = b->prevPrefixBinding;
}
if ((parser->m_tagLevel == 0) &&
(parser->m_parsingStatus.parsing != XML_FINISHED)) {
if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
parser->m_processor = epilogProcessor;
else
return epilogProcessor(parser, next, end, nextPtr);
}
}
break;
case XML_TOK_CHAR_REF: {
int n = XmlCharRefNumber(enc, s);
if (n < 0) return XML_ERROR_BAD_CHAR_REF;
if (parser->m_characterDataHandler) {
XML_Char buf[XML_ENCODE_MAX];
parser->m_characterDataHandler(parser->m_handlerArg, buf,
XmlEncode(n, (ICHAR *)buf));
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
} break;
case XML_TOK_XML_DECL:
return XML_ERROR_MISPLACED_XML_PI;
case XML_TOK_DATA_NEWLINE:
if (parser->m_characterDataHandler) {
XML_Char c = 0xA;
parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
case XML_TOK_CDATA_SECT_OPEN: {
enum XML_Error result;
if (parser->m_startCdataSectionHandler)
parser->m_startCdataSectionHandler(parser->m_handlerArg);
/* BEGIN disabled code */
/* Suppose you doing a transformation on a document that involves
changing only the character data. You set up a defaultHandler
and a characterDataHandler. The defaultHandler simply copies
characters through. The characterDataHandler does the
transformation and writes the characters out escaping them as
necessary. This case will fail to work if we leave out the
following two lines (because & and < inside CDATA sections will
be incorrectly escaped).
However, now we have a start/endCdataSectionHandler, so it seems
easier to let the user deal with this.
*/
else if (0 && parser->m_characterDataHandler)
parser->m_characterDataHandler(parser->m_handlerArg,
parser->m_dataBuf, 0);
/* END disabled code */
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
if (result != XML_ERROR_NONE)
return result;
else if (!next) {
parser->m_processor = cdataSectionProcessor;
return result;
}
} break;
case XML_TOK_TRAILING_RSQB:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
if (parser->m_characterDataHandler) {
if (MUST_CONVERT(enc, s)) {
ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
parser->m_characterDataHandler(
parser->m_handlerArg, parser->m_dataBuf,
(int)(dataPtr - (ICHAR *)parser->m_dataBuf));
} else
parser->m_characterDataHandler(
parser->m_handlerArg, (XML_Char *)s,
(int)((XML_Char *)end - (XML_Char *)s));
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
*/
if (startTagLevel == 0) {
*eventPP = end;
return XML_ERROR_NO_ELEMENTS;
}
if (parser->m_tagLevel != startTagLevel) {
*eventPP = end;
return XML_ERROR_ASYNC_ENTITY;
}
*nextPtr = end;
return XML_ERROR_NONE;
case XML_TOK_DATA_CHARS: {
XML_CharacterDataHandler charDataHandler =
parser->m_characterDataHandler;
if (charDataHandler) {
if (MUST_CONVERT(enc, s)) {
for (;;) {
ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
const enum XML_Convert_Result convert_res = XmlConvert(
enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
*eventEndPP = s;
charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
(int)(dataPtr - (ICHAR *)parser->m_dataBuf));
if ((convert_res == XML_CONVERT_COMPLETED) ||
(convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
*eventPP = s;
}
} else
charDataHandler(parser->m_handlerArg, (XML_Char *)s,
(int)((XML_Char *)next - (XML_Char *)s));
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
} break;
case XML_TOK_PI:
if (!reportProcessingInstruction(parser, enc, s, next))
return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_COMMENT:
if (!reportComment(parser, enc, s, next)) return XML_ERROR_NO_MEMORY;
break;
default:
/* All of the tokens produced by XmlContentTok() have their own
* explicit cases, so this default is not strictly necessary.
* However it is a useful safety net, so we retain the code and
* simply exclude it from the coverage tests.
*
* LCOV_EXCL_START
*/
if (parser->m_defaultHandler) reportDefault(parser, enc, s, next);
break;
/* LCOV_EXCL_STOP */
}
*eventPP = s = next;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default:;
}
}
/* not reached */
}
/* This function does not call free() on the allocated memory, merely
* moving it to the parser's m_freeBindingList where it can be freed or
* reused as appropriate.
*/
static void freeBindings(XML_Parser parser, BINDING *bindings) {
while (bindings) {
BINDING *b = bindings;
/* m_startNamespaceDeclHandler will have been called for this
* binding in addBindings(), so call the end handler now.
*/
if (parser->m_endNamespaceDeclHandler)
parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
bindings = bindings->nextTagBinding;
b->nextTagBinding = parser->m_freeBindingList;
parser->m_freeBindingList = b;
b->prefix->binding = b->prevPrefixBinding;
}
}
/* Precondition: all arguments must be non-NULL;
Purpose:
- normalize attributes
- check attributes for well-formedness
- generate namespace aware attribute names (URI, prefix)
- build list of attributes for startElementHandler
- default attributes
- process namespace declarations (check and report them)
- generate namespace aware element name (URI, prefix)
*/
static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
const char *attStr, TAG_NAME *tagNamePtr,
BINDING **bindingsPtr) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
ELEMENT_TYPE *elementType;
int nDefaultAtts;
const XML_Char **appAtts; /* the attribute list for the application */
int attIndex = 0;
int prefixLen;
int i;
int n;
XML_Char *uri;
int nPrefixes = 0;
BINDING *binding;
const XML_Char *localPart;
/* lookup the element type name */
elementType =
(ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
if (!elementType) {
const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
if (!name) return XML_ERROR_NO_MEMORY;
elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
sizeof(ELEMENT_TYPE));
if (!elementType) return XML_ERROR_NO_MEMORY;
if (parser->m_ns && !setElementTypePrefix(parser, elementType))
return XML_ERROR_NO_MEMORY;
}
nDefaultAtts = elementType->nDefaultAtts;
/* get the attributes from the tokenizer */
n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
if (n + nDefaultAtts > parser->m_attsSize) {
int oldAttsSize = parser->m_attsSize;
ATTRIBUTE *temp;
#ifdef XML_ATTR_INFO
XML_AttrInfo *temp2;
#endif
parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
parser->m_attsSize * sizeof(ATTRIBUTE));
if (temp == NULL) {
parser->m_attsSize = oldAttsSize;
return XML_ERROR_NO_MEMORY;
}
parser->m_atts = temp;
#ifdef XML_ATTR_INFO
temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
parser->m_attsSize * sizeof(XML_AttrInfo));
if (temp2 == NULL) {
parser->m_attsSize = oldAttsSize;
return XML_ERROR_NO_MEMORY;
}
parser->m_attInfo = temp2;
#endif
if (n > oldAttsSize) XmlGetAttributes(enc, attStr, n, parser->m_atts);
}
appAtts = (const XML_Char **)parser->m_atts;
for (i = 0; i < n; i++) {
ATTRIBUTE *currAtt = &parser->m_atts[i];
#ifdef XML_ATTR_INFO
XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
#endif
/* add the name and value to the attribute list */
ATTRIBUTE_ID *attId =
getAttributeId(parser, enc, currAtt->name,
currAtt->name + XmlNameLength(enc, currAtt->name));
if (!attId) return XML_ERROR_NO_MEMORY;
#ifdef XML_ATTR_INFO
currAttInfo->nameStart =
parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
currAttInfo->nameEnd =
currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);
currAttInfo->valueStart = parser->m_parseEndByteIndex -
(parser->m_parseEndPtr - currAtt->valuePtr);
currAttInfo->valueEnd = parser->m_parseEndByteIndex -
(parser->m_parseEndPtr - currAtt->valueEnd);
#endif
/* Detect duplicate attributes by their QNames. This does not work when
namespace processing is turned on and different prefixes for the same
namespace are used. For this case we have a check further down.
*/
if ((attId->name)[-1]) {
if (enc == parser->m_encoding)
parser->m_eventPtr = parser->m_atts[i].name;
return XML_ERROR_DUPLICATE_ATTRIBUTE;
}
(attId->name)[-1] = 1;
appAtts[attIndex++] = attId->name;
if (!parser->m_atts[i].normalized) {
enum XML_Error result;
XML_Bool isCdata = XML_TRUE;
/* figure out whether declared as other than CDATA */
if (attId->maybeTokenized) {
int j;
for (j = 0; j < nDefaultAtts; j++) {
if (attId == elementType->defaultAtts[j].id) {
isCdata = elementType->defaultAtts[j].isCdata;
break;
}
}
}
/* normalize the attribute value */
result =
storeAttributeValue(parser, enc, isCdata, parser->m_atts[i].valuePtr,
parser->m_atts[i].valueEnd, &parser->m_tempPool);
if (result) return result;
appAtts[attIndex] = poolStart(&parser->m_tempPool);
poolFinish(&parser->m_tempPool);
} else {
/* the value did not need normalizing */
appAtts[attIndex] =
poolStoreString(&parser->m_tempPool, enc, parser->m_atts[i].valuePtr,
parser->m_atts[i].valueEnd);
if (appAtts[attIndex] == 0) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_tempPool);
}
/* handle prefixed attribute names */
if (attId->prefix) {
if (attId->xmlns) {
/* deal with namespace declarations here */
enum XML_Error result = addBinding(parser, attId->prefix, attId,
appAtts[attIndex], bindingsPtr);
if (result) return result;
--attIndex;
} else {
/* deal with other prefixed names later */
attIndex++;
nPrefixes++;
(attId->name)[-1] = 2;
}
} else
attIndex++;
}
/* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
parser->m_nSpecifiedAtts = attIndex;
if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
for (i = 0; i < attIndex; i += 2)
if (appAtts[i] == elementType->idAtt->name) {
parser->m_idAttIndex = i;
break;
}
} else
parser->m_idAttIndex = -1;
/* do attribute defaulting */
for (i = 0; i < nDefaultAtts; i++) {
const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
if (!(da->id->name)[-1] && da->value) {
if (da->id->prefix) {
if (da->id->xmlns) {
enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
da->value, bindingsPtr);
if (result) return result;
} else {
(da->id->name)[-1] = 2;
nPrefixes++;
appAtts[attIndex++] = da->id->name;
appAtts[attIndex++] = da->value;
}
} else {
(da->id->name)[-1] = 1;
appAtts[attIndex++] = da->id->name;
appAtts[attIndex++] = da->value;
}
}
}
appAtts[attIndex] = 0;
/* expand prefixed attribute names, check for duplicates,
and clear flags that say whether attributes were specified */
i = 0;
if (nPrefixes) {
int j; /* hash table index */
unsigned long version = parser->m_nsAttsVersion;
int nsAttsSize = (int)1 << parser->m_nsAttsPower;
unsigned char oldNsAttsPower = parser->m_nsAttsPower;
/* size of hash table must be at least 2 * (# of prefixed attributes) */
if ((nPrefixes << 1) >>
parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
NS_ATT *temp;
/* hash table size must also be a power of 2 and >= 8 */
while (nPrefixes >> parser->m_nsAttsPower++)
;
if (parser->m_nsAttsPower < 3) parser->m_nsAttsPower = 3;
nsAttsSize = (int)1 << parser->m_nsAttsPower;
temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
nsAttsSize * sizeof(NS_ATT));
if (!temp) {
/* Restore actual size of memory in m_nsAtts */
parser->m_nsAttsPower = oldNsAttsPower;
return XML_ERROR_NO_MEMORY;
}
parser->m_nsAtts = temp;
version = 0; /* force re-initialization of m_nsAtts hash table */
}
/* using a version flag saves us from initializing m_nsAtts every time */
if (!version) { /* initialize version flags when version wraps around */
version = INIT_ATTS_VERSION;
for (j = nsAttsSize; j != 0;) parser->m_nsAtts[--j].version = version;
}
parser->m_nsAttsVersion = --version;
/* expand prefixed names and check for duplicates */
for (; i < attIndex; i += 2) {
const XML_Char *s = appAtts[i];
if (s[-1] == 2) { /* prefixed */
ATTRIBUTE_ID *id;
const BINDING *b;
unsigned long uriHash;
struct siphash sip_state;
struct sipkey sip_key;
copy_salt_to_sipkey(parser, &sip_key);
sip24_init(&sip_state, &sip_key);
((XML_Char *)s)[-1] = 0; /* clear flag */
id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
if (!id || !id->prefix) {
/* This code is walking through the appAtts array, dealing
* with (in this case) a prefixed attribute name. To be in
* the array, the attribute must have already been bound, so
* has to have passed through the hash table lookup once
* already. That implies that an entry for it already
* exists, so the lookup above will return a pointer to
* already allocated memory. There is no opportunaity for
* the allocator to fail, so the condition above cannot be
* fulfilled.
*
* Since it is difficult to be certain that the above
* analysis is complete, we retain the test and merely
* remove the code from coverage tests.
*/
return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
}
b = id->prefix->binding;
if (!b) return XML_ERROR_UNBOUND_PREFIX;
for (j = 0; j < b->uriLen; j++) {
const XML_Char c = b->uri[j];
if (!poolAppendChar(&parser->m_tempPool, c))
return XML_ERROR_NO_MEMORY;
}
sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
while (*s++ != XML_T(ASCII_COLON))
;
sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
do { /* copies null terminator */
if (!poolAppendChar(&parser->m_tempPool, *s))
return XML_ERROR_NO_MEMORY;
} while (*s++);
uriHash = (unsigned long)sip24_final(&sip_state);
{ /* Check hash table for duplicate of expanded name (uriName).
Derived from code in lookup(parser, HASH_TABLE *table, ...).
*/
unsigned char step = 0;
unsigned long mask = nsAttsSize - 1;
j = uriHash & mask; /* index into hash table */
while (parser->m_nsAtts[j].version == version) {
/* for speed we compare stored hash values first */
if (uriHash == parser->m_nsAtts[j].hash) {
const XML_Char *s1 = poolStart(&parser->m_tempPool);
const XML_Char *s2 = parser->m_nsAtts[j].uriName;
/* s1 is null terminated, but not s2 */
for (; *s1 == *s2 && *s1 != 0; s1++, s2++)
;
if (*s1 == 0) return XML_ERROR_DUPLICATE_ATTRIBUTE;
}
if (!step) step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
j < step ? (j += nsAttsSize - step) : (j -= step);
}
}
if (parser->m_ns_triplets) { /* append namespace separator and prefix */
parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
s = b->prefix->name;
do {
if (!poolAppendChar(&parser->m_tempPool, *s))
return XML_ERROR_NO_MEMORY;
} while (*s++);
}
/* store expanded name in attribute list */
s = poolStart(&parser->m_tempPool);
poolFinish(&parser->m_tempPool);
appAtts[i] = s;
/* fill empty slot with new version, uriName and hash value */
parser->m_nsAtts[j].version = version;
parser->m_nsAtts[j].hash = uriHash;
parser->m_nsAtts[j].uriName = s;
if (!--nPrefixes) {
i += 2;
break;
}
} else /* not prefixed */
((XML_Char *)s)[-1] = 0; /* clear flag */
}
}
/* clear flags for the remaining attributes */
for (; i < attIndex; i += 2) ((XML_Char *)(appAtts[i]))[-1] = 0;
for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
binding->attId->name[-1] = 0;
if (!parser->m_ns) return XML_ERROR_NONE;
/* expand the element type name */
if (elementType->prefix) {
binding = elementType->prefix->binding;
if (!binding) return XML_ERROR_UNBOUND_PREFIX;
localPart = tagNamePtr->str;
while (*localPart++ != XML_T(ASCII_COLON))
;
} else if (dtd->defaultPrefix.binding) {
binding = dtd->defaultPrefix.binding;
localPart = tagNamePtr->str;
} else
return XML_ERROR_NONE;
prefixLen = 0;
if (parser->m_ns_triplets && binding->prefix->name) {
for (; binding->prefix->name[prefixLen++];)
; /* prefixLen includes null terminator */
}
tagNamePtr->localPart = localPart;
tagNamePtr->uriLen = binding->uriLen;
tagNamePtr->prefix = binding->prefix->name;
tagNamePtr->prefixLen = prefixLen;
for (i = 0; localPart[i++];)
; /* i includes null terminator */
n = i + binding->uriLen + prefixLen;
if (n > binding->uriAlloc) {
TAG *p;
uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
if (!uri) return XML_ERROR_NO_MEMORY;
binding->uriAlloc = n + EXPAND_SPARE;
memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
for (p = parser->m_tagStack; p; p = p->parent)
if (p->name.str == binding->uri) p->name.str = uri;
FREE(parser, binding->uri);
binding->uri = uri;
}
/* if m_namespaceSeparator != '\0' then uri includes it already */
uri = binding->uri + binding->uriLen;
memcpy(uri, localPart, i * sizeof(XML_Char));
/* we always have a namespace separator between localPart and prefix */
if (prefixLen) {
uri += i - 1;
*uri = parser->m_namespaceSeparator; /* replace null terminator */
memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
}
tagNamePtr->str = binding->uri;
return XML_ERROR_NONE;
}
/* addBinding() overwrites the value of prefix->binding without checking.
Therefore one must keep track of the old value outside of addBinding().
*/
static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
const ATTRIBUTE_ID *attId, const XML_Char *uri,
BINDING **bindingsPtr) {
static const XML_Char xmlNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON,
ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o,
ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M,
ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9,
ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m,
ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
ASCII_e, '\0'};
static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;
static const XML_Char xmlnsNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH,
ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,
ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH,
ASCII_2, ASCII_0, ASCII_0, ASCII_0, ASCII_SLASH, ASCII_x,
ASCII_m, ASCII_l, ASCII_n, ASCII_s, ASCII_SLASH, '\0'};
static const int xmlnsLen =
(int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;
XML_Bool mustBeXML = XML_FALSE;
XML_Bool isXML = XML_TRUE;
XML_Bool isXMLNS = XML_TRUE;
BINDING *b;
int len;
/* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
if (*uri == XML_T('\0') && prefix->name) return XML_ERROR_UNDECLARING_PREFIX;
if (prefix->name && prefix->name[0] == XML_T(ASCII_x) &&
prefix->name[1] == XML_T(ASCII_m) && prefix->name[2] == XML_T(ASCII_l)) {
/* Not allowed to bind xmlns */
if (prefix->name[3] == XML_T(ASCII_n) &&
prefix->name[4] == XML_T(ASCII_s) && prefix->name[5] == XML_T('\0'))
return XML_ERROR_RESERVED_PREFIX_XMLNS;
if (prefix->name[3] == XML_T('\0')) mustBeXML = XML_TRUE;
}
for (len = 0; uri[len]; len++) {
if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
isXML = XML_FALSE;
if (!mustBeXML && isXMLNS &&
(len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
isXMLNS = XML_FALSE;
}
isXML = isXML && len == xmlLen;
isXMLNS = isXMLNS && len == xmlnsLen;
if (mustBeXML != isXML)
return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
: XML_ERROR_RESERVED_NAMESPACE_URI;
if (isXMLNS) return XML_ERROR_RESERVED_NAMESPACE_URI;
if (parser->m_namespaceSeparator) len++;
if (parser->m_freeBindingList) {
b = parser->m_freeBindingList;
if (len > b->uriAlloc) {
XML_Char *temp = (XML_Char *)REALLOC(
parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
if (temp == NULL) return XML_ERROR_NO_MEMORY;
b->uri = temp;
b->uriAlloc = len + EXPAND_SPARE;
}
parser->m_freeBindingList = b->nextTagBinding;
} else {
b = (BINDING *)MALLOC(parser, sizeof(BINDING));
if (!b) return XML_ERROR_NO_MEMORY;
b->uri =
(XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
if (!b->uri) {
FREE(parser, b);
return XML_ERROR_NO_MEMORY;
}
b->uriAlloc = len + EXPAND_SPARE;
}
b->uriLen = len;
memcpy(b->uri, uri, len * sizeof(XML_Char));
if (parser->m_namespaceSeparator)
b->uri[len - 1] = parser->m_namespaceSeparator;
b->prefix = prefix;
b->attId = attId;
b->prevPrefixBinding = prefix->binding;
/* NULL binding when default namespace undeclared */
if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
prefix->binding = NULL;
else
prefix->binding = b;
b->nextTagBinding = *bindingsPtr;
*bindingsPtr = b;
/* if attId == NULL then we are not starting a namespace scope */
if (attId && parser->m_startNamespaceDeclHandler)
parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
prefix->binding ? uri : 0);
return XML_ERROR_NONE;
}
/* The idea here is to avoid using stack for each CDATA section when
the whole file is parsed with one call.
*/
static enum XML_Error cdataSectionProcessor(XML_Parser parser,
const char *start,
const char *end,
const char **endPtr) {
enum XML_Error result =
doCdataSection(parser, parser->m_encoding, &start, end, endPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer);
if (result != XML_ERROR_NONE) return result;
if (start) {
if (parser->m_parentParser) { /* we are parsing an external entity */
parser->m_processor = externalEntityContentProcessor;
return externalEntityContentProcessor(parser, start, end, endPtr);
} else {
parser->m_processor = contentProcessor;
return contentProcessor(parser, start, end, endPtr);
}
}
return result;
}
/* startPtr gets set to non-null if the section is closed, and to null if
the section is not yet closed.
*/
static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,
const char **startPtr, const char *end,
const char **nextPtr, XML_Bool haveMore) {
const char *s = *startPtr;
const char **eventPP;
const char **eventEndPP;
if (enc == parser->m_encoding) {
eventPP = &parser->m_eventPtr;
*eventPP = s;
eventEndPP = &parser->m_eventEndPtr;
} else {
eventPP = &(parser->m_openInternalEntities->internalEventPtr);
eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
}
*eventPP = s;
*startPtr = NULL;
for (;;) {
const char *next;
int tok = XmlCdataSectionTok(enc, s, end, &next);
*eventEndPP = next;
switch (tok) {
case XML_TOK_CDATA_SECT_CLOSE:
if (parser->m_endCdataSectionHandler)
parser->m_endCdataSectionHandler(parser->m_handlerArg);
/* BEGIN disabled code */
/* see comment under XML_TOK_CDATA_SECT_OPEN */
else if (0 && parser->m_characterDataHandler)
parser->m_characterDataHandler(parser->m_handlerArg,
parser->m_dataBuf, 0);
/* END disabled code */
else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
*startPtr = next;
*nextPtr = next;
if (parser->m_parsingStatus.parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
else
return XML_ERROR_NONE;
case XML_TOK_DATA_NEWLINE:
if (parser->m_characterDataHandler) {
XML_Char c = 0xA;
parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
break;
case XML_TOK_DATA_CHARS: {
XML_CharacterDataHandler charDataHandler =
parser->m_characterDataHandler;
if (charDataHandler) {
if (MUST_CONVERT(enc, s)) {
for (;;) {
ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
const enum XML_Convert_Result convert_res = XmlConvert(
enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
*eventEndPP = next;
charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
(int)(dataPtr - (ICHAR *)parser->m_dataBuf));
if ((convert_res == XML_CONVERT_COMPLETED) ||
(convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
*eventPP = s;
}
} else
charDataHandler(parser->m_handlerArg, (XML_Char *)s,
(int)((XML_Char *)next - (XML_Char *)s));
} else if (parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
} break;
case XML_TOK_INVALID:
*eventPP = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_PARTIAL:
case XML_TOK_NONE:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_UNCLOSED_CDATA_SECTION;
default:
/* Every token returned by XmlCdataSectionTok() has its own
* explicit case, so this default case will never be executed.
* We retain it as a safety net and exclude it from the coverage
* statistics.
*
* LCOV_EXCL_START
*/
*eventPP = next;
return XML_ERROR_UNEXPECTED_STATE;
/* LCOV_EXCL_STOP */
}
*eventPP = s = next;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default:;
}
}
/* not reached */
}
#ifdef XML_DTD
/* The idea here is to avoid using stack for each IGNORE section when
the whole file is parsed with one call.
*/
static enum XML_Error ignoreSectionProcessor(XML_Parser parser,
const char *start,
const char *end,
const char **endPtr) {
enum XML_Error result =
doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer);
if (result != XML_ERROR_NONE) return result;
if (start) {
parser->m_processor = prologProcessor;
return prologProcessor(parser, start, end, endPtr);
}
return result;
}
/* startPtr gets set to non-null is the section is closed, and to null
if the section is not yet closed.
*/
static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,
const char **startPtr, const char *end,
const char **nextPtr, XML_Bool haveMore) {
const char *next;
int tok;
const char *s = *startPtr;
const char **eventPP;
const char **eventEndPP;
if (enc == parser->m_encoding) {
eventPP = &parser->m_eventPtr;
*eventPP = s;
eventEndPP = &parser->m_eventEndPtr;
} else {
/* It's not entirely clear, but it seems the following two lines
* of code cannot be executed. The only occasions on which 'enc'
* is not 'encoding' are when this function is called
* from the internal entity processing, and IGNORE sections are an
* error in internal entities.
*
* Since it really isn't clear that this is true, we keep the code
* and just remove it from our coverage tests.
*
* LCOV_EXCL_START
*/
eventPP = &(parser->m_openInternalEntities->internalEventPtr);
eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
/* LCOV_EXCL_STOP */
}
*eventPP = s;
*startPtr = NULL;
tok = XmlIgnoreSectionTok(enc, s, end, &next);
*eventEndPP = next;
switch (tok) {
case XML_TOK_IGNORE_SECT:
if (parser->m_defaultHandler) reportDefault(parser, enc, s, next);
*startPtr = next;
*nextPtr = next;
if (parser->m_parsingStatus.parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
else
return XML_ERROR_NONE;
case XML_TOK_INVALID:
*eventPP = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_PARTIAL:
case XML_TOK_NONE:
if (haveMore) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
default:
/* All of the tokens that XmlIgnoreSectionTok() returns have
* explicit cases to handle them, so this default case is never
* executed. We keep it as a safety net anyway, and remove it
* from our test coverage statistics.
*
* LCOV_EXCL_START
*/
*eventPP = next;
return XML_ERROR_UNEXPECTED_STATE;
/* LCOV_EXCL_STOP */
}
/* not reached */
}
#endif /* XML_DTD */
static enum XML_Error initializeEncoding(XML_Parser parser) {
const char *s;
#ifdef XML_UNICODE
char encodingBuf[128];
/* See comments abount `protoclEncodingName` in parserInit() */
if (!parser->m_protocolEncodingName)
s = NULL;
else {
int i;
for (i = 0; parser->m_protocolEncodingName[i]; i++) {
if (i == sizeof(encodingBuf) - 1 ||
(parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
encodingBuf[0] = '\0';
break;
}
encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
}
encodingBuf[i] = '\0';
s = encodingBuf;
}
#else
s = parser->m_protocolEncodingName;
#endif
if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
&parser->m_initEncoding, &parser->m_encoding, s))
return XML_ERROR_NONE;
return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
}
static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
const char *s, const char *next) {
const char *encodingName = NULL;
const XML_Char *storedEncName = NULL;
const ENCODING *newEncoding = NULL;
const char *version = NULL;
const char *versionend;
const XML_Char *storedversion = NULL;
int standalone = -1;
if (!(parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
&version, &versionend, &encodingName, &newEncoding, &standalone)) {
if (isGeneralTextEntity)
return XML_ERROR_TEXT_DECL;
else
return XML_ERROR_XML_DECL;
}
if (!isGeneralTextEntity && standalone == 1) {
parser->m_dtd->standalone = XML_TRUE;
#ifdef XML_DTD
if (parser->m_paramEntityParsing ==
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
#endif /* XML_DTD */
}
if (parser->m_xmlDeclHandler) {
if (encodingName != NULL) {
storedEncName = poolStoreString(
&parser->m_temp2Pool, parser->m_encoding, encodingName,
encodingName + XmlNameLength(parser->m_encoding, encodingName));
if (!storedEncName) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_temp2Pool);
}
if (version) {
storedversion =
poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
versionend - parser->m_encoding->minBytesPerChar);
if (!storedversion) return XML_ERROR_NO_MEMORY;
}
parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
standalone);
} else if (parser->m_defaultHandler)
reportDefault(parser, parser->m_encoding, s, next);
if (parser->m_protocolEncodingName == NULL) {
if (newEncoding) {
/* Check that the specified encoding does not conflict with what
* the parser has already deduced. Do we have the same number
* of bytes in the smallest representation of a character? If
* this is UTF-16, is it the same endianness?
*/
if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar ||
(newEncoding->minBytesPerChar == 2 &&
newEncoding != parser->m_encoding)) {
parser->m_eventPtr = encodingName;
return XML_ERROR_INCORRECT_ENCODING;
}
parser->m_encoding = newEncoding;
} else if (encodingName) {
enum XML_Error result;
if (!storedEncName) {
storedEncName = poolStoreString(
&parser->m_temp2Pool, parser->m_encoding, encodingName,
encodingName + XmlNameLength(parser->m_encoding, encodingName));
if (!storedEncName) return XML_ERROR_NO_MEMORY;
}
result = handleUnknownEncoding(parser, storedEncName);
poolClear(&parser->m_temp2Pool);
if (result == XML_ERROR_UNKNOWN_ENCODING)
parser->m_eventPtr = encodingName;
return result;
}
}
if (storedEncName || storedversion) poolClear(&parser->m_temp2Pool);
return XML_ERROR_NONE;
}
static enum XML_Error handleUnknownEncoding(XML_Parser parser,
const XML_Char *encodingName) {
if (parser->m_unknownEncodingHandler) {
XML_Encoding info;
int i;
for (i = 0; i < 256; i++) info.map[i] = -1;
info.convert = NULL;
info.data = NULL;
info.release = NULL;
if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
encodingName, &info)) {
ENCODING *enc;
parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
if (!parser->m_unknownEncodingMem) {
if (info.release) info.release(info.data);
return XML_ERROR_NO_MEMORY;
}
enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
parser->m_unknownEncodingMem, info.map, info.convert, info.data);
if (enc) {
parser->m_unknownEncodingData = info.data;
parser->m_unknownEncodingRelease = info.release;
parser->m_encoding = enc;
return XML_ERROR_NONE;
}
}
if (info.release != NULL) info.release(info.data);
}
return XML_ERROR_UNKNOWN_ENCODING;
}
static enum XML_Error prologInitProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr) {
enum XML_Error result = initializeEncoding(parser);
if (result != XML_ERROR_NONE) return result;
parser->m_processor = prologProcessor;
return prologProcessor(parser, s, end, nextPtr);
}
#ifdef XML_DTD
static enum XML_Error externalParEntInitProcessor(
XML_Parser parser, const char *s, const char *end, const char **nextPtr) {
enum XML_Error result = initializeEncoding(parser);
if (result != XML_ERROR_NONE) return result;
/* we know now that XML_Parse(Buffer) has been called,
so we consider the external parameter entity read */
parser->m_dtd->paramEntityRead = XML_TRUE;
if (parser->m_prologState.inEntityValue) {
parser->m_processor = entityValueInitProcessor;
return entityValueInitProcessor(parser, s, end, nextPtr);
} else {
parser->m_processor = externalParEntProcessor;
return externalParEntProcessor(parser, s, end, nextPtr);
}
}
static enum XML_Error entityValueInitProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr) {
int tok;
const char *start = s;
const char *next = start;
parser->m_eventPtr = start;
for (;;) {
tok = XmlPrologTok(parser->m_encoding, start, end, &next);
parser->m_eventEndPtr = next;
if (tok <= 0) {
if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s;
return XML_ERROR_NONE;
}
switch (tok) {
case XML_TOK_INVALID:
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_NONE: /* start == end */
default:
break;
}
/* found end of entity value - can store it now */
return storeEntityValue(parser, parser->m_encoding, s, end);
} else if (tok == XML_TOK_XML_DECL) {
enum XML_Error result;
result = processXmlDecl(parser, 0, start, next);
if (result != XML_ERROR_NONE) return result;
/* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED. For
* that to happen, a parameter entity parsing handler must have attempted
* to suspend the parser, which fails and raises an error. The parser can
* be aborted, but can't be suspended.
*/
if (parser->m_parsingStatus.parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
*nextPtr = next;
/* stop scanning for text declaration - we found one */
parser->m_processor = entityValueProcessor;
return entityValueProcessor(parser, next, end, nextPtr);
}
/* If we are at the end of the buffer, this would cause XmlPrologTok to
return XML_TOK_NONE on the next call, which would then cause the
function to exit with *nextPtr set to s - that is what we want for other
tokens, but not for the BOM - we would rather like to skip it;
then, when this routine is entered the next time, XmlPrologTok will
return XML_TOK_INVALID, since the BOM is still in the buffer
*/
else if (tok == XML_TOK_BOM && next == end &&
!parser->m_parsingStatus.finalBuffer) {
*nextPtr = next;
return XML_ERROR_NONE;
}
/* If we get this token, we have the start of what might be a
normal tag, but not a declaration (i.e. it doesn't begin with
"<!"). In a DTD context, that isn't legal.
*/
else if (tok == XML_TOK_INSTANCE_START) {
*nextPtr = next;
return XML_ERROR_SYNTAX;
}
start = next;
parser->m_eventPtr = start;
}
}
static enum XML_Error externalParEntProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr) {
const char *next = s;
int tok;
tok = XmlPrologTok(parser->m_encoding, s, end, &next);
if (tok <= 0) {
if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s;
return XML_ERROR_NONE;
}
switch (tok) {
case XML_TOK_INVALID:
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_NONE: /* start == end */
default:
break;
}
}
/* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
However, when parsing an external subset, doProlog will not accept a BOM
as valid, and report a syntax error, so we have to skip the BOM
*/
else if (tok == XML_TOK_BOM) {
s = next;
tok = XmlPrologTok(parser->m_encoding, s, end, &next);
}
parser->m_processor = prologProcessor;
return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer, XML_TRUE);
}
static enum XML_Error entityValueProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr) {
const char *start = s;
const char *next = s;
const ENCODING *enc = parser->m_encoding;
int tok;
for (;;) {
tok = XmlPrologTok(enc, start, end, &next);
if (tok <= 0) {
if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s;
return XML_ERROR_NONE;
}
switch (tok) {
case XML_TOK_INVALID:
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
return XML_ERROR_PARTIAL_CHAR;
case XML_TOK_NONE: /* start == end */
default:
break;
}
/* found end of entity value - can store it now */
return storeEntityValue(parser, enc, s, end);
}
start = next;
}
}
#endif /* XML_DTD */
static enum XML_Error prologProcessor(XML_Parser parser, const char *s,
const char *end,
const char **nextPtr) {
const char *next = s;
int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer, XML_TRUE);
}
static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
const char *s, const char *end, int tok,
const char *next, const char **nextPtr,
XML_Bool haveMore,
XML_Bool allowClosingDoctype) {
#ifdef XML_DTD
static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'};
#endif /* XML_DTD */
static const XML_Char atypeCDATA[] = {ASCII_C, ASCII_D, ASCII_A,
ASCII_T, ASCII_A, '\0'};
static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'};
static const XML_Char atypeIDREF[] = {ASCII_I, ASCII_D, ASCII_R,
ASCII_E, ASCII_F, '\0'};
static const XML_Char atypeIDREFS[] = {ASCII_I, ASCII_D, ASCII_R, ASCII_E,
ASCII_F, ASCII_S, '\0'};
static const XML_Char atypeENTITY[] = {ASCII_E, ASCII_N, ASCII_T, ASCII_I,
ASCII_T, ASCII_Y, '\0'};
static const XML_Char atypeENTITIES[] = {ASCII_E, ASCII_N, ASCII_T,
ASCII_I, ASCII_T, ASCII_I,
ASCII_E, ASCII_S, '\0'};
static const XML_Char atypeNMTOKEN[] = {ASCII_N, ASCII_M, ASCII_T, ASCII_O,
ASCII_K, ASCII_E, ASCII_N, '\0'};
static const XML_Char atypeNMTOKENS[] = {ASCII_N, ASCII_M, ASCII_T,
ASCII_O, ASCII_K, ASCII_E,
ASCII_N, ASCII_S, '\0'};
static const XML_Char notationPrefix[] = {
ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T,
ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'};
static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'};
static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'};
/* save one level of indirection */
DTD *const dtd = parser->m_dtd;
const char **eventPP;
const char **eventEndPP;
enum XML_Content_Quant quant;
if (enc == parser->m_encoding) {
eventPP = &parser->m_eventPtr;
eventEndPP = &parser->m_eventEndPtr;
} else {
eventPP = &(parser->m_openInternalEntities->internalEventPtr);
eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
}
for (;;) {
int role;
XML_Bool handleDefault = XML_TRUE;
*eventPP = s;
*eventEndPP = next;
if (tok <= 0) {
if (haveMore && tok != XML_TOK_INVALID) {
*nextPtr = s;
return XML_ERROR_NONE;
}
switch (tok) {
case XML_TOK_INVALID:
*eventPP = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
return XML_ERROR_PARTIAL_CHAR;
case -XML_TOK_PROLOG_S:
tok = -tok;
break;
case XML_TOK_NONE:
#ifdef XML_DTD
/* for internal PE NOT referenced between declarations */
if (enc != parser->m_encoding &&
!parser->m_openInternalEntities->betweenDecl) {
*nextPtr = s;
return XML_ERROR_NONE;
}
/* WFC: PE Between Declarations - must check that PE contains
complete markup, not only for external PEs, but also for
internal PEs if the reference occurs between declarations.
*/
if (parser->m_isParamEntity || enc != parser->m_encoding) {
if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end,
enc) == XML_ROLE_ERROR)
return XML_ERROR_INCOMPLETE_PE;
*nextPtr = s;
return XML_ERROR_NONE;
}
#endif /* XML_DTD */
return XML_ERROR_NO_ELEMENTS;
default:
tok = -tok;
next = end;
break;
}
}
role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
switch (role) {
case XML_ROLE_XML_DECL: {
enum XML_Error result = processXmlDecl(parser, 0, s, next);
if (result != XML_ERROR_NONE) return result;
enc = parser->m_encoding;
handleDefault = XML_FALSE;
} break;
case XML_ROLE_DOCTYPE_NAME:
if (parser->m_startDoctypeDeclHandler) {
parser->m_doctypeName =
poolStoreString(&parser->m_tempPool, enc, s, next);
if (!parser->m_doctypeName) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_tempPool);
parser->m_doctypePubid = NULL;
handleDefault = XML_FALSE;
}
parser->m_doctypeSysid = NULL; /* always initialize to NULL */
break;
case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
if (parser->m_startDoctypeDeclHandler) {
parser->m_startDoctypeDeclHandler(
parser->m_handlerArg, parser->m_doctypeName,
parser->m_doctypeSysid, parser->m_doctypePubid, 1);
parser->m_doctypeName = NULL;
poolClear(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
break;
#ifdef XML_DTD
case XML_ROLE_TEXT_DECL: {
enum XML_Error result = processXmlDecl(parser, 1, s, next);
if (result != XML_ERROR_NONE) return result;
enc = parser->m_encoding;
handleDefault = XML_FALSE;
} break;
#endif /* XML_DTD */
case XML_ROLE_DOCTYPE_PUBLIC_ID:
#ifdef XML_DTD
parser->m_useForeignDTD = XML_FALSE;
parser->m_declEntity = (ENTITY *)lookup(
parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
if (!parser->m_declEntity) return XML_ERROR_NO_MEMORY;
#endif /* XML_DTD */
dtd->hasParamEntityRefs = XML_TRUE;
if (parser->m_startDoctypeDeclHandler) {
XML_Char *pubId;
if (!XmlIsPublicId(enc, s, next, eventPP)) return XML_ERROR_PUBLICID;
pubId = poolStoreString(&parser->m_tempPool, enc,
s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!pubId) return XML_ERROR_NO_MEMORY;
normalizePublicId(pubId);
poolFinish(&parser->m_tempPool);
parser->m_doctypePubid = pubId;
handleDefault = XML_FALSE;
goto alreadyChecked;
}
/* fall through */
case XML_ROLE_ENTITY_PUBLIC_ID:
if (!XmlIsPublicId(enc, s, next, eventPP)) return XML_ERROR_PUBLICID;
alreadyChecked:
if (dtd->keepProcessing && parser->m_declEntity) {
XML_Char *tem =
poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!tem) return XML_ERROR_NO_MEMORY;
normalizePublicId(tem);
parser->m_declEntity->publicId = tem;
poolFinish(&dtd->pool);
/* Don't suppress the default handler if we fell through from
* the XML_ROLE_DOCTYPE_PUBLIC_ID case.
*/
if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_DOCTYPE_CLOSE:
if (allowClosingDoctype != XML_TRUE) {
/* Must not close doctype from within expanded parameter entities */
return XML_ERROR_INVALID_TOKEN;
}
if (parser->m_doctypeName) {
parser->m_startDoctypeDeclHandler(
parser->m_handlerArg, parser->m_doctypeName,
parser->m_doctypeSysid, parser->m_doctypePubid, 0);
poolClear(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
/* parser->m_doctypeSysid will be non-NULL in the case of a previous
XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
was not set, indicating an external subset
*/
#ifdef XML_DTD
if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE;
if (parser->m_paramEntityParsing &&
parser->m_externalEntityRefHandler) {
ENTITY *entity =
(ENTITY *)lookup(parser, &dtd->paramEntities,
externalSubsetName, sizeof(ENTITY));
if (!entity) {
/* The external subset name "#" will have already been
* inserted into the hash table at the start of the
* external entity parsing, so no allocation will happen
* and lookup() cannot fail.
*/
return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
}
if (parser->m_useForeignDTD) entity->base = parser->m_curBase;
dtd->paramEntityRead = XML_FALSE;
if (!parser->m_externalEntityRefHandler(
parser->m_externalEntityRefHandlerArg, 0, entity->base,
entity->systemId, entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead) {
if (!dtd->standalone && parser->m_notStandaloneHandler &&
!parser->m_notStandaloneHandler(parser->m_handlerArg))
return XML_ERROR_NOT_STANDALONE;
}
/* if we didn't read the foreign DTD then this means that there
is no external subset and we must reset dtd->hasParamEntityRefs
*/
else if (!parser->m_doctypeSysid)
dtd->hasParamEntityRefs = hadParamEntityRefs;
/* end of DTD - no need to update dtd->keepProcessing */
}
parser->m_useForeignDTD = XML_FALSE;
}
#endif /* XML_DTD */
if (parser->m_endDoctypeDeclHandler) {
parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_INSTANCE_START:
#ifdef XML_DTD
/* if there is no DOCTYPE declaration then now is the
last chance to read the foreign DTD
*/
if (parser->m_useForeignDTD) {
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE;
if (parser->m_paramEntityParsing &&
parser->m_externalEntityRefHandler) {
ENTITY *entity =
(ENTITY *)lookup(parser, &dtd->paramEntities,
externalSubsetName, sizeof(ENTITY));
if (!entity) return XML_ERROR_NO_MEMORY;
entity->base = parser->m_curBase;
dtd->paramEntityRead = XML_FALSE;
if (!parser->m_externalEntityRefHandler(
parser->m_externalEntityRefHandlerArg, 0, entity->base,
entity->systemId, entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead) {
if (!dtd->standalone && parser->m_notStandaloneHandler &&
!parser->m_notStandaloneHandler(parser->m_handlerArg))
return XML_ERROR_NOT_STANDALONE;
}
/* if we didn't read the foreign DTD then this means that there
is no external subset and we must reset dtd->hasParamEntityRefs
*/
else
dtd->hasParamEntityRefs = hadParamEntityRefs;
/* end of DTD - no need to update dtd->keepProcessing */
}
}
#endif /* XML_DTD */
parser->m_processor = contentProcessor;
return contentProcessor(parser, s, end, nextPtr);
case XML_ROLE_ATTLIST_ELEMENT_NAME:
parser->m_declElementType = getElementType(parser, enc, s, next);
if (!parser->m_declElementType) return XML_ERROR_NO_MEMORY;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_NAME:
parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
if (!parser->m_declAttributeId) return XML_ERROR_NO_MEMORY;
parser->m_declAttributeIsCdata = XML_FALSE;
parser->m_declAttributeType = NULL;
parser->m_declAttributeIsId = XML_FALSE;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
parser->m_declAttributeIsCdata = XML_TRUE;
parser->m_declAttributeType = atypeCDATA;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_ID:
parser->m_declAttributeIsId = XML_TRUE;
parser->m_declAttributeType = atypeID;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
parser->m_declAttributeType = atypeIDREF;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
parser->m_declAttributeType = atypeIDREFS;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
parser->m_declAttributeType = atypeENTITY;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
parser->m_declAttributeType = atypeENTITIES;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
parser->m_declAttributeType = atypeNMTOKEN;
goto checkAttListDeclHandler;
case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
parser->m_declAttributeType = atypeNMTOKENS;
checkAttListDeclHandler:
if (dtd->keepProcessing && parser->m_attlistDeclHandler)
handleDefault = XML_FALSE;
break;
case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
const XML_Char *prefix;
if (parser->m_declAttributeType) {
prefix = enumValueSep;
} else {
prefix =
(role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix
: enumValueStart);
}
if (!poolAppendString(&parser->m_tempPool, prefix))
return XML_ERROR_NO_MEMORY;
if (!poolAppend(&parser->m_tempPool, enc, s, next))
return XML_ERROR_NO_MEMORY;
parser->m_declAttributeType = parser->m_tempPool.start;
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
if (dtd->keepProcessing) {
if (!defineAttribute(parser->m_declElementType,
parser->m_declAttributeId,
parser->m_declAttributeIsCdata,
parser->m_declAttributeIsId, 0, parser))
return XML_ERROR_NO_MEMORY;
if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN) ||
(*parser->m_declAttributeType == XML_T(ASCII_N) &&
parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
/* Enumerated or Notation type */
if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN)) ||
!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
return XML_ERROR_NO_MEMORY;
parser->m_declAttributeType = parser->m_tempPool.start;
poolFinish(&parser->m_tempPool);
}
*eventEndPP = s;
parser->m_attlistDeclHandler(
parser->m_handlerArg, parser->m_declElementType->name,
parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
poolClear(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
}
break;
case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
if (dtd->keepProcessing) {
const XML_Char *attVal;
enum XML_Error result =
storeAttributeValue(parser, enc, parser->m_declAttributeIsCdata,
s + enc->minBytesPerChar,
next - enc->minBytesPerChar, &dtd->pool);
if (result) return result;
attVal = poolStart(&dtd->pool);
poolFinish(&dtd->pool);
/* ID attributes aren't allowed to have a default */
if (!defineAttribute(
parser->m_declElementType, parser->m_declAttributeId,
parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
return XML_ERROR_NO_MEMORY;
if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN) ||
(*parser->m_declAttributeType == XML_T(ASCII_N) &&
parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
/* Enumerated or Notation type */
if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN)) ||
!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
return XML_ERROR_NO_MEMORY;
parser->m_declAttributeType = parser->m_tempPool.start;
poolFinish(&parser->m_tempPool);
}
*eventEndPP = s;
parser->m_attlistDeclHandler(
parser->m_handlerArg, parser->m_declElementType->name,
parser->m_declAttributeId->name, parser->m_declAttributeType,
attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
poolClear(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
}
break;
case XML_ROLE_ENTITY_VALUE:
if (dtd->keepProcessing) {
enum XML_Error result =
storeEntityValue(parser, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (parser->m_declEntity) {
parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
parser->m_declEntity->textLen =
(int)(poolLength(&dtd->entityValuePool));
poolFinish(&dtd->entityValuePool);
if (parser->m_entityDeclHandler) {
*eventEndPP = s;
parser->m_entityDeclHandler(
parser->m_handlerArg, parser->m_declEntity->name,
parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
handleDefault = XML_FALSE;
}
} else
poolDiscard(&dtd->entityValuePool);
if (result != XML_ERROR_NONE) return result;
}
break;
case XML_ROLE_DOCTYPE_SYSTEM_ID:
#ifdef XML_DTD
parser->m_useForeignDTD = XML_FALSE;
#endif /* XML_DTD */
dtd->hasParamEntityRefs = XML_TRUE;
if (parser->m_startDoctypeDeclHandler) {
parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (parser->m_doctypeSysid == NULL) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
#ifdef XML_DTD
else
/* use externalSubsetName to make parser->m_doctypeSysid non-NULL
for the case where no parser->m_startDoctypeDeclHandler is set */
parser->m_doctypeSysid = externalSubsetName;
#endif /* XML_DTD */
if (!dtd->standalone
#ifdef XML_DTD
&& !parser->m_paramEntityParsing
#endif /* XML_DTD */
&& parser->m_notStandaloneHandler &&
!parser->m_notStandaloneHandler(parser->m_handlerArg))
return XML_ERROR_NOT_STANDALONE;
#ifndef XML_DTD
break;
#else /* XML_DTD */
if (!parser->m_declEntity) {
parser->m_declEntity = (ENTITY *)lookup(
parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
if (!parser->m_declEntity) return XML_ERROR_NO_MEMORY;
parser->m_declEntity->publicId = NULL;
}
#endif /* XML_DTD */
/* fall through */
case XML_ROLE_ENTITY_SYSTEM_ID:
if (dtd->keepProcessing && parser->m_declEntity) {
parser->m_declEntity->systemId =
poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!parser->m_declEntity->systemId) return XML_ERROR_NO_MEMORY;
parser->m_declEntity->base = parser->m_curBase;
poolFinish(&dtd->pool);
/* Don't suppress the default handler if we fell through from
* the XML_ROLE_DOCTYPE_SYSTEM_ID case.
*/
if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_ENTITY_COMPLETE:
if (dtd->keepProcessing && parser->m_declEntity &&
parser->m_entityDeclHandler) {
*eventEndPP = s;
parser->m_entityDeclHandler(
parser->m_handlerArg, parser->m_declEntity->name,
parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
parser->m_declEntity->systemId, parser->m_declEntity->publicId,
0);
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_ENTITY_NOTATION_NAME:
if (dtd->keepProcessing && parser->m_declEntity) {
parser->m_declEntity->notation =
poolStoreString(&dtd->pool, enc, s, next);
if (!parser->m_declEntity->notation) return XML_ERROR_NO_MEMORY;
poolFinish(&dtd->pool);
if (parser->m_unparsedEntityDeclHandler) {
*eventEndPP = s;
parser->m_unparsedEntityDeclHandler(
parser->m_handlerArg, parser->m_declEntity->name,
parser->m_declEntity->base, parser->m_declEntity->systemId,
parser->m_declEntity->publicId, parser->m_declEntity->notation);
handleDefault = XML_FALSE;
} else if (parser->m_entityDeclHandler) {
*eventEndPP = s;
parser->m_entityDeclHandler(
parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
parser->m_declEntity->base, parser->m_declEntity->systemId,
parser->m_declEntity->publicId, parser->m_declEntity->notation);
handleDefault = XML_FALSE;
}
}
break;
case XML_ROLE_GENERAL_ENTITY_NAME: {
if (XmlPredefinedEntityName(enc, s, next)) {
parser->m_declEntity = NULL;
break;
}
if (dtd->keepProcessing) {
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
if (!name) return XML_ERROR_NO_MEMORY;
parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
name, sizeof(ENTITY));
if (!parser->m_declEntity) return XML_ERROR_NO_MEMORY;
if (parser->m_declEntity->name != name) {
poolDiscard(&dtd->pool);
parser->m_declEntity = NULL;
} else {
poolFinish(&dtd->pool);
parser->m_declEntity->publicId = NULL;
parser->m_declEntity->is_param = XML_FALSE;
/* if we have a parent parser or are reading an internal parameter
entity, then the entity declaration is not considered "internal"
*/
parser->m_declEntity->is_internal =
!(parser->m_parentParser || parser->m_openInternalEntities);
if (parser->m_entityDeclHandler) handleDefault = XML_FALSE;
}
} else {
poolDiscard(&dtd->pool);
parser->m_declEntity = NULL;
}
} break;
case XML_ROLE_PARAM_ENTITY_NAME:
#ifdef XML_DTD
if (dtd->keepProcessing) {
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
if (!name) return XML_ERROR_NO_MEMORY;
parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
name, sizeof(ENTITY));
if (!parser->m_declEntity) return XML_ERROR_NO_MEMORY;
if (parser->m_declEntity->name != name) {
poolDiscard(&dtd->pool);
parser->m_declEntity = NULL;
} else {
poolFinish(&dtd->pool);
parser->m_declEntity->publicId = NULL;
parser->m_declEntity->is_param = XML_TRUE;
/* if we have a parent parser or are reading an internal parameter
entity, then the entity declaration is not considered "internal"
*/
parser->m_declEntity->is_internal =
!(parser->m_parentParser || parser->m_openInternalEntities);
if (parser->m_entityDeclHandler) handleDefault = XML_FALSE;
}
} else {
poolDiscard(&dtd->pool);
parser->m_declEntity = NULL;
}
#else /* not XML_DTD */
parser->m_declEntity = NULL;
#endif /* XML_DTD */
break;
case XML_ROLE_NOTATION_NAME:
parser->m_declNotationPublicId = NULL;
parser->m_declNotationName = NULL;
if (parser->m_notationDeclHandler) {
parser->m_declNotationName =
poolStoreString(&parser->m_tempPool, enc, s, next);
if (!parser->m_declNotationName) return XML_ERROR_NO_MEMORY;
poolFinish(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_NOTATION_PUBLIC_ID:
if (!XmlIsPublicId(enc, s, next, eventPP)) return XML_ERROR_PUBLICID;
if (parser->m_declNotationName) { /* means m_notationDeclHandler != NULL
*/
XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!tem) return XML_ERROR_NO_MEMORY;
normalizePublicId(tem);
parser->m_declNotationPublicId = tem;
poolFinish(&parser->m_tempPool);
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_NOTATION_SYSTEM_ID:
if (parser->m_declNotationName && parser->m_notationDeclHandler) {
const XML_Char *systemId = poolStoreString(
&parser->m_tempPool, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!systemId) return XML_ERROR_NO_MEMORY;
*eventEndPP = s;
parser->m_notationDeclHandler(
parser->m_handlerArg, parser->m_declNotationName,
parser->m_curBase, systemId, parser->m_declNotationPublicId);
handleDefault = XML_FALSE;
}
poolClear(&parser->m_tempPool);
break;
case XML_ROLE_NOTATION_NO_SYSTEM_ID:
if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
*eventEndPP = s;
parser->m_notationDeclHandler(
parser->m_handlerArg, parser->m_declNotationName,
parser->m_curBase, 0, parser->m_declNotationPublicId);
handleDefault = XML_FALSE;
}
poolClear(&parser->m_tempPool);
break;
case XML_ROLE_ERROR:
switch (tok) {
case XML_TOK_PARAM_ENTITY_REF:
/* PE references in internal subset are
not allowed within declarations. */
return XML_ERROR_PARAM_ENTITY_REF;
case XML_TOK_XML_DECL:
return XML_ERROR_MISPLACED_XML_PI;
default:
return XML_ERROR_SYNTAX;
}
#ifdef XML_DTD
case XML_ROLE_IGNORE_SECT: {
enum XML_Error result;
if (parser->m_defaultHandler) reportDefault(parser, enc, s, next);
handleDefault = XML_FALSE;
result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
if (result != XML_ERROR_NONE)
return result;
else if (!next) {
parser->m_processor = ignoreSectionProcessor;
return result;
}
} break;
#endif /* XML_DTD */
case XML_ROLE_GROUP_OPEN:
if (parser->m_prologState.level >= parser->m_groupSize) {
if (parser->m_groupSize) {
{
char *const new_connector = (char *)REALLOC(
parser, parser->m_groupConnector, parser->m_groupSize *= 2);
if (new_connector == NULL) {
parser->m_groupSize /= 2;
return XML_ERROR_NO_MEMORY;
}
parser->m_groupConnector = new_connector;
}
if (dtd->scaffIndex) {
int *const new_scaff_index = (int *)REALLOC(
parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
if (new_scaff_index == NULL) return XML_ERROR_NO_MEMORY;
dtd->scaffIndex = new_scaff_index;
}
} else {
parser->m_groupConnector =
(char *)MALLOC(parser, parser->m_groupSize = 32);
if (!parser->m_groupConnector) {
parser->m_groupSize = 0;
return XML_ERROR_NO_MEMORY;
}
}
}
parser->m_groupConnector[parser->m_prologState.level] = 0;
if (dtd->in_eldecl) {
int myindex = nextScaffoldPart(parser);
if (myindex < 0) return XML_ERROR_NO_MEMORY;
assert(dtd->scaffIndex != NULL);
dtd->scaffIndex[dtd->scaffLevel] = myindex;
dtd->scaffLevel++;
dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
}
break;
case XML_ROLE_GROUP_SEQUENCE:
if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
return XML_ERROR_SYNTAX;
parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
if (dtd->in_eldecl && parser->m_elementDeclHandler)
handleDefault = XML_FALSE;
break;
case XML_ROLE_GROUP_CHOICE:
if (parser->m_groupConnector[parser->m_prologState.level] ==
ASCII_COMMA)
return XML_ERROR_SYNTAX;
if (dtd->in_eldecl &&
!parser->m_groupConnector[parser->m_prologState.level] &&
(dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type !=
XML_CTYPE_MIXED)) {
dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type =
XML_CTYPE_CHOICE;
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
}
parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
break;
case XML_ROLE_PARAM_ENTITY_REF:
#ifdef XML_DTD
case XML_ROLE_INNER_PARAM_ENTITY_REF:
dtd->hasParamEntityRefs = XML_TRUE;
if (!parser->m_paramEntityParsing)
dtd->keepProcessing = dtd->standalone;
else {
const XML_Char *name;
ENTITY *entity;
name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!name) return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
poolDiscard(&dtd->pool);
/* first, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal,
otherwise call the skipped entity handler
*/
if (parser->m_prologState.documentEntity &&
(dtd->standalone ? !parser->m_openInternalEntities
: !dtd->hasParamEntityRefs)) {
if (!entity)
return XML_ERROR_UNDEFINED_ENTITY;
else if (!entity->is_internal) {
/* It's hard to exhaustively search the code to be sure,
* but there doesn't seem to be a way of executing the
* following line. There are two cases:
*
* If 'standalone' is false, the DTD must have no
* parameter entities or we wouldn't have passed the outer
* 'if' statement. That measn the only entity in the hash
* table is the external subset name "#" which cannot be
* given as a parameter entity name in XML syntax, so the
* lookup must have returned NULL and we don't even reach
* the test for an internal entity.
*
* If 'standalone' is true, it does not seem to be
* possible to create entities taking this code path that
* are not internal entities, so fail the test above.
*
* Because this analysis is very uncertain, the code is
* being left in place and merely removed from the
* coverage test statistics.
*/
return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
}
} else if (!entity) {
dtd->keepProcessing = dtd->standalone;
/* cannot report skipped entities in declarations */
if ((role == XML_ROLE_PARAM_ENTITY_REF) &&
parser->m_skippedEntityHandler) {
parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
handleDefault = XML_FALSE;
}
break;
}
if (entity->open_) return XML_ERROR_RECURSIVE_ENTITY_REF;
if (entity->textPtr) {
enum XML_Error result;
XML_Bool betweenDecl =
(role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
result = processInternalEntity(parser, entity, betweenDecl);
if (result != XML_ERROR_NONE) return result;
handleDefault = XML_FALSE;
break;
}
if (parser->m_externalEntityRefHandler) {
dtd->paramEntityRead = XML_FALSE;
entity->open_ = XML_TRUE;
if (!parser->m_externalEntityRefHandler(
parser->m_externalEntityRefHandlerArg, 0, entity->base,
entity->systemId, entity->publicId)) {
entity->open_ = XML_FALSE;
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
entity->open_ = XML_FALSE;
handleDefault = XML_FALSE;
if (!dtd->paramEntityRead) {
dtd->keepProcessing = dtd->standalone;
break;
}
} else {
dtd->keepProcessing = dtd->standalone;
break;
}
}
#endif /* XML_DTD */
if (!dtd->standalone && parser->m_notStandaloneHandler &&
!parser->m_notStandaloneHandler(parser->m_handlerArg))
return XML_ERROR_NOT_STANDALONE;
break;
/* Element declaration stuff */
case XML_ROLE_ELEMENT_NAME:
if (parser->m_elementDeclHandler) {
parser->m_declElementType = getElementType(parser, enc, s, next);
if (!parser->m_declElementType) return XML_ERROR_NO_MEMORY;
dtd->scaffLevel = 0;
dtd->scaffCount = 0;
dtd->in_eldecl = XML_TRUE;
handleDefault = XML_FALSE;
}
break;
case XML_ROLE_CONTENT_ANY:
case XML_ROLE_CONTENT_EMPTY:
if (dtd->in_eldecl) {
if (parser->m_elementDeclHandler) {
XML_Content *content =
(XML_Content *)MALLOC(parser, sizeof(XML_Content));
if (!content) return XML_ERROR_NO_MEMORY;
content->quant = XML_CQUANT_NONE;
content->name = NULL;
content->numchildren = 0;
content->children = NULL;
content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY
: XML_CTYPE_EMPTY);
*eventEndPP = s;
parser->m_elementDeclHandler(
parser->m_handlerArg, parser->m_declElementType->name, content);
handleDefault = XML_FALSE;
}
dtd->in_eldecl = XML_FALSE;
}
break;
case XML_ROLE_CONTENT_PCDATA:
if (dtd->in_eldecl) {
dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type =
XML_CTYPE_MIXED;
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
}
break;
case XML_ROLE_CONTENT_ELEMENT:
quant = XML_CQUANT_NONE;
goto elementContent;
case XML_ROLE_CONTENT_ELEMENT_OPT:
quant = XML_CQUANT_OPT;
goto elementContent;
case XML_ROLE_CONTENT_ELEMENT_REP:
quant = XML_CQUANT_REP;
goto elementContent;
case XML_ROLE_CONTENT_ELEMENT_PLUS:
quant = XML_CQUANT_PLUS;
elementContent:
if (dtd->in_eldecl) {
ELEMENT_TYPE *el;
const XML_Char *name;
int nameLen;
const char *nxt =
(quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
int myindex = nextScaffoldPart(parser);
if (myindex < 0) return XML_ERROR_NO_MEMORY;
dtd->scaffold[myindex].type = XML_CTYPE_NAME;
dtd->scaffold[myindex].quant = quant;
el = getElementType(parser, enc, s, nxt);
if (!el) return XML_ERROR_NO_MEMORY;
name = el->name;
dtd->scaffold[myindex].name = name;
nameLen = 0;
for (; name[nameLen++];)
;
dtd->contentStringLen += nameLen;
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
}
break;
case XML_ROLE_GROUP_CLOSE:
quant = XML_CQUANT_NONE;
goto closeGroup;
case XML_ROLE_GROUP_CLOSE_OPT:
quant = XML_CQUANT_OPT;
goto closeGroup;
case XML_ROLE_GROUP_CLOSE_REP:
quant = XML_CQUANT_REP;
goto closeGroup;
case XML_ROLE_GROUP_CLOSE_PLUS:
quant = XML_CQUANT_PLUS;
closeGroup:
if (dtd->in_eldecl) {
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
dtd->scaffLevel--;
dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
if (dtd->scaffLevel == 0) {
if (!handleDefault) {
XML_Content *model = build_model(parser);
if (!model) return XML_ERROR_NO_MEMORY;
*eventEndPP = s;
parser->m_elementDeclHandler(
parser->m_handlerArg, parser->m_declElementType->name, model);
}
dtd->in_eldecl = XML_FALSE;
dtd->contentStringLen = 0;
}
}
break;
/* End element declaration stuff */
case XML_ROLE_PI:
if (!reportProcessingInstruction(parser, enc, s, next))
return XML_ERROR_NO_MEMORY;
handleDefault = XML_FALSE;
break;
case XML_ROLE_COMMENT:
if (!reportComment(parser, enc, s, next)) return XML_ERROR_NO_MEMORY;
handleDefault = XML_FALSE;
break;
case XML_ROLE_NONE:
switch (tok) {
case XML_TOK_BOM:
handleDefault = XML_FALSE;
break;
}
break;
case XML_ROLE_DOCTYPE_NONE:
if (parser->m_startDoctypeDeclHandler) handleDefault = XML_FALSE;
break;
case XML_ROLE_ENTITY_NONE:
if (dtd->keepProcessing && parser->m_entityDeclHandler)
handleDefault = XML_FALSE;
break;
case XML_ROLE_NOTATION_NONE:
if (parser->m_notationDeclHandler) handleDefault = XML_FALSE;
break;
case XML_ROLE_ATTLIST_NONE:
if (dtd->keepProcessing && parser->m_attlistDeclHandler)
handleDefault = XML_FALSE;
break;
case XML_ROLE_ELEMENT_NONE:
if (parser->m_elementDeclHandler) handleDefault = XML_FALSE;
break;
} /* end of big switch */
if (handleDefault && parser->m_defaultHandler)
reportDefault(parser, enc, s, next);
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default:
s = next;
tok = XmlPrologTok(enc, s, end, &next);
}
}
/* not reached */
}
static enum XML_Error epilogProcessor(XML_Parser parser, const char *s,
const char *end,
const char **nextPtr) {
parser->m_processor = epilogProcessor;
parser->m_eventPtr = s;
for (;;) {
const char *next = NULL;
int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
parser->m_eventEndPtr = next;
switch (tok) {
/* report partial linebreak - it might be the last token */
case -XML_TOK_PROLOG_S:
if (parser->m_defaultHandler) {
reportDefault(parser, parser->m_encoding, s, next);
if (parser->m_parsingStatus.parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
}
*nextPtr = next;
return XML_ERROR_NONE;
case XML_TOK_NONE:
*nextPtr = s;
return XML_ERROR_NONE;
case XML_TOK_PROLOG_S:
if (parser->m_defaultHandler)
reportDefault(parser, parser->m_encoding, s, next);
break;
case XML_TOK_PI:
if (!reportProcessingInstruction(parser, parser->m_encoding, s, next))
return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_COMMENT:
if (!reportComment(parser, parser->m_encoding, s, next))
return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_INVALID:
parser->m_eventPtr = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
if (!parser->m_parsingStatus.finalBuffer) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (!parser->m_parsingStatus.finalBuffer) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
default:
return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
}
parser->m_eventPtr = s = next;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default:;
}
}
}
static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
XML_Bool betweenDecl) {
const char *textStart, *textEnd;
const char *next;
enum XML_Error result;
OPEN_INTERNAL_ENTITY *openEntity;
if (parser->m_freeInternalEntities) {
openEntity = parser->m_freeInternalEntities;
parser->m_freeInternalEntities = openEntity->next;
} else {
openEntity =
(OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
if (!openEntity) return XML_ERROR_NO_MEMORY;
}
entity->open_ = XML_TRUE;
entity->processed = 0;
openEntity->next = parser->m_openInternalEntities;
parser->m_openInternalEntities = openEntity;
openEntity->entity = entity;
openEntity->startTagLevel = parser->m_tagLevel;
openEntity->betweenDecl = betweenDecl;
openEntity->internalEventPtr = NULL;
openEntity->internalEventEndPtr = NULL;
textStart = (char *)entity->textPtr;
textEnd = (char *)(entity->textPtr + entity->textLen);
/* Set a safe default value in case 'next' does not get set */
next = textStart;
#ifdef XML_DTD
if (entity->is_param) {
int tok =
XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
tok, next, &next, XML_FALSE, XML_FALSE);
} else
#endif /* XML_DTD */
result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
textStart, textEnd, &next, XML_FALSE);
if (result == XML_ERROR_NONE) {
if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
entity->processed = (int)(next - textStart);
parser->m_processor = internalEntityProcessor;
} else {
entity->open_ = XML_FALSE;
parser->m_openInternalEntities = openEntity->next;
/* put openEntity back in list of free instances */
openEntity->next = parser->m_freeInternalEntities;
parser->m_freeInternalEntities = openEntity;
}
}
return result;
}
static enum XML_Error internalEntityProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr) {
ENTITY *entity;
const char *textStart, *textEnd;
const char *next;
enum XML_Error result;
OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
if (!openEntity) return XML_ERROR_UNEXPECTED_STATE;
entity = openEntity->entity;
textStart = ((char *)entity->textPtr) + entity->processed;
textEnd = (char *)(entity->textPtr + entity->textLen);
/* Set a safe default value in case 'next' does not get set */
next = textStart;
#ifdef XML_DTD
if (entity->is_param) {
int tok =
XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
tok, next, &next, XML_FALSE, XML_TRUE);
} else
#endif /* XML_DTD */
result =
doContent(parser, openEntity->startTagLevel, parser->m_internalEncoding,
textStart, textEnd, &next, XML_FALSE);
if (result != XML_ERROR_NONE)
return result;
else if (textEnd != next &&
parser->m_parsingStatus.parsing == XML_SUSPENDED) {
entity->processed = (int)(next - (char *)entity->textPtr);
return result;
} else {
entity->open_ = XML_FALSE;
parser->m_openInternalEntities = openEntity->next;
/* put openEntity back in list of free instances */
openEntity->next = parser->m_freeInternalEntities;
parser->m_freeInternalEntities = openEntity;
}
#ifdef XML_DTD
if (entity->is_param) {
int tok;
parser->m_processor = prologProcessor;
tok = XmlPrologTok(parser->m_encoding, s, end, &next);
return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer, XML_TRUE);
} else
#endif /* XML_DTD */
{
parser->m_processor = contentProcessor;
/* see externalEntityContentProcessor vs contentProcessor */
return doContent(parser, parser->m_parentParser ? 1 : 0, parser->m_encoding,
s, end, nextPtr,
(XML_Bool)!parser->m_parsingStatus.finalBuffer);
}
}
static enum XML_Error errorProcessor(XML_Parser parser, const char *s,
const char *end,
const char **nextPtr) {
UNUSED_P(s);
UNUSED_P(end);
UNUSED_P(nextPtr);
return parser->m_errorCode;
}
static enum XML_Error storeAttributeValue(XML_Parser parser,
const ENCODING *enc, XML_Bool isCdata,
const char *ptr, const char *end,
STRING_POOL *pool) {
enum XML_Error result =
appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
if (result) return result;
if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
poolChop(pool);
if (!poolAppendChar(pool, XML_T('\0'))) return XML_ERROR_NO_MEMORY;
return XML_ERROR_NONE;
}
static enum XML_Error appendAttributeValue(XML_Parser parser,
const ENCODING *enc,
XML_Bool isCdata, const char *ptr,
const char *end, STRING_POOL *pool) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
for (;;) {
const char *next;
int tok = XmlAttributeValueTok(enc, ptr, end, &next);
switch (tok) {
case XML_TOK_NONE:
return XML_ERROR_NONE;
case XML_TOK_INVALID:
if (enc == parser->m_encoding) parser->m_eventPtr = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
if (enc == parser->m_encoding) parser->m_eventPtr = ptr;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_CHAR_REF: {
XML_Char buf[XML_ENCODE_MAX];
int i;
int n = XmlCharRefNumber(enc, ptr);
if (n < 0) {
if (enc == parser->m_encoding) parser->m_eventPtr = ptr;
return XML_ERROR_BAD_CHAR_REF;
}
if (!isCdata && n == 0x20 /* space */
&& (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
break;
n = XmlEncode(n, (ICHAR *)buf);
/* The XmlEncode() functions can never return 0 here. That
* error return happens if the code point passed in is either
* negative or greater than or equal to 0x110000. The
* XmlCharRefNumber() functions will all return a number
* strictly less than 0x110000 or a negative value if an error
* occurred. The negative value is intercepted above, so
* XmlEncode() is never passed a value it might return an
* error for.
*/
for (i = 0; i < n; i++) {
if (!poolAppendChar(pool, buf[i])) return XML_ERROR_NO_MEMORY;
}
} break;
case XML_TOK_DATA_CHARS:
if (!poolAppend(pool, enc, ptr, next)) return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_TRAILING_CR:
next = ptr + enc->minBytesPerChar;
/* fall through */
case XML_TOK_ATTRIBUTE_VALUE_S:
case XML_TOK_DATA_NEWLINE:
if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
break;
if (!poolAppendChar(pool, 0x20)) return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_ENTITY_REF: {
const XML_Char *name;
ENTITY *entity;
char checkEntityDecl;
XML_Char ch = (XML_Char)XmlPredefinedEntityName(
enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
if (ch) {
if (!poolAppendChar(pool, ch)) return XML_ERROR_NO_MEMORY;
break;
}
name = poolStoreString(&parser->m_temp2Pool, enc,
ptr + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!name) return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
poolDiscard(&parser->m_temp2Pool);
/* First, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal.
*/
if (pool == &dtd->pool) /* are we called from prolog? */
checkEntityDecl =
#ifdef XML_DTD
parser->m_prologState.documentEntity &&
#endif /* XML_DTD */
(dtd->standalone ? !parser->m_openInternalEntities
: !dtd->hasParamEntityRefs);
else /* if (pool == &parser->m_tempPool): we are called from content */
checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;
if (checkEntityDecl) {
if (!entity)
return XML_ERROR_UNDEFINED_ENTITY;
else if (!entity->is_internal)
return XML_ERROR_ENTITY_DECLARED_IN_PE;
} else if (!entity) {
/* Cannot report skipped entity here - see comments on
parser->m_skippedEntityHandler.
if (parser->m_skippedEntityHandler)
parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
*/
/* Cannot call the default handler because this would be
out of sync with the call to the startElementHandler.
if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
reportDefault(parser, enc, ptr, next);
*/
break;
}
if (entity->open_) {
if (enc == parser->m_encoding) {
/* It does not appear that this line can be executed.
*
* The "if (entity->open_)" check catches recursive entity
* definitions. In order to be called with an open
* entity, it must have gone through this code before and
* been through the recursive call to
* appendAttributeValue() some lines below. That call
* sets the local encoding ("enc") to the parser's
* internal encoding (internal_utf8 or internal_utf16),
* which can never be the same as the principle encoding.
* It doesn't appear there is another code path that gets
* here with entity->open_ being TRUE.
*
* Since it is not certain that this logic is watertight,
* we keep the line and merely exclude it from coverage
* tests.
*/
parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
}
return XML_ERROR_RECURSIVE_ENTITY_REF;
}
if (entity->notation) {
if (enc == parser->m_encoding) parser->m_eventPtr = ptr;
return XML_ERROR_BINARY_ENTITY_REF;
}
if (!entity->textPtr) {
if (enc == parser->m_encoding) parser->m_eventPtr = ptr;
return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
} else {
enum XML_Error result;
const XML_Char *textEnd = entity->textPtr + entity->textLen;
entity->open_ = XML_TRUE;
result = appendAttributeValue(parser, parser->m_internalEncoding,
isCdata, (char *)entity->textPtr,
(char *)textEnd, pool);
entity->open_ = XML_FALSE;
if (result) return result;
}
} break;
default:
/* The only token returned by XmlAttributeValueTok() that does
* not have an explicit case here is XML_TOK_PARTIAL_CHAR.
* Getting that would require an entity name to contain an
* incomplete XML character (e.g. \xE2\x82); however previous
* tokenisers will have already recognised and rejected such
* names before XmlAttributeValueTok() gets a look-in. This
* default case should be retained as a safety net, but the code
* excluded from coverage tests.
*
* LCOV_EXCL_START
*/
if (enc == parser->m_encoding) parser->m_eventPtr = ptr;
return XML_ERROR_UNEXPECTED_STATE;
/* LCOV_EXCL_STOP */
}
ptr = next;
}
/* not reached */
}
static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
const char *entityTextPtr,
const char *entityTextEnd) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
STRING_POOL *pool = &(dtd->entityValuePool);
enum XML_Error result = XML_ERROR_NONE;
#ifdef XML_DTD
int oldInEntityValue = parser->m_prologState.inEntityValue;
parser->m_prologState.inEntityValue = 1;
#endif /* XML_DTD */
/* never return Null for the value argument in EntityDeclHandler,
since this would indicate an external entity; therefore we
have to make sure that entityValuePool.start is not null */
if (!pool->blocks) {
if (!poolGrow(pool)) return XML_ERROR_NO_MEMORY;
}
for (;;) {
const char *next;
int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
switch (tok) {
case XML_TOK_PARAM_ENTITY_REF:
#ifdef XML_DTD
if (parser->m_isParamEntity || enc != parser->m_encoding) {
const XML_Char *name;
ENTITY *entity;
name = poolStoreString(&parser->m_tempPool, enc,
entityTextPtr + enc->minBytesPerChar,
next - enc->minBytesPerChar);
if (!name) {
result = XML_ERROR_NO_MEMORY;
goto endEntityValue;
}
entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
poolDiscard(&parser->m_tempPool);
if (!entity) {
/* not a well-formedness error - see XML 1.0: WFC Entity Declared */
/* cannot report skipped entity here - see comments on
parser->m_skippedEntityHandler
if (parser->m_skippedEntityHandler)
parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
*/
dtd->keepProcessing = dtd->standalone;
goto endEntityValue;
}
if (entity->open_) {
if (enc == parser->m_encoding) parser->m_eventPtr = entityTextPtr;
result = XML_ERROR_RECURSIVE_ENTITY_REF;
goto endEntityValue;
}
if (entity->systemId) {
if (parser->m_externalEntityRefHandler) {
dtd->paramEntityRead = XML_FALSE;
entity->open_ = XML_TRUE;
if (!parser->m_externalEntityRefHandler(
parser->m_externalEntityRefHandlerArg, 0, entity->base,
entity->systemId, entity->publicId)) {
entity->open_ = XML_FALSE;
result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
goto endEntityValue;
}
entity->open_ = XML_FALSE;
if (!dtd->paramEntityRead) dtd->keepProcessing = dtd->standalone;
} else
dtd->keepProcessing = dtd->standalone;
} else {
entity->open_ = XML_TRUE;
result = storeEntityValue(
parser, parser->m_internalEncoding, (char *)entity->textPtr,
(char *)(entity->textPtr + entity->textLen));
entity->open_ = XML_FALSE;
if (result) goto endEntityValue;
}
break;
}
#endif /* XML_DTD */
/* In the internal subset, PE references are not legal
within markup declarations, e.g entity values in this case. */
parser->m_eventPtr = entityTextPtr;
result = XML_ERROR_PARAM_ENTITY_REF;
goto endEntityValue;
case XML_TOK_NONE:
result = XML_ERROR_NONE;
goto endEntityValue;
case XML_TOK_ENTITY_REF:
case XML_TOK_DATA_CHARS:
if (!poolAppend(pool, enc, entityTextPtr, next)) {
result = XML_ERROR_NO_MEMORY;
goto endEntityValue;
}
break;
case XML_TOK_TRAILING_CR:
next = entityTextPtr + enc->minBytesPerChar;
/* fall through */
case XML_TOK_DATA_NEWLINE:
if (pool->end == pool->ptr && !poolGrow(pool)) {
result = XML_ERROR_NO_MEMORY;
goto endEntityValue;
}
*(pool->ptr)++ = 0xA;
break;
case XML_TOK_CHAR_REF: {
XML_Char buf[XML_ENCODE_MAX];
int i;
int n = XmlCharRefNumber(enc, entityTextPtr);
if (n < 0) {
if (enc == parser->m_encoding) parser->m_eventPtr = entityTextPtr;
result = XML_ERROR_BAD_CHAR_REF;
goto endEntityValue;
}
n = XmlEncode(n, (ICHAR *)buf);
/* The XmlEncode() functions can never return 0 here. That
* error return happens if the code point passed in is either
* negative or greater than or equal to 0x110000. The
* XmlCharRefNumber() functions will all return a number
* strictly less than 0x110000 or a negative value if an error
* occurred. The negative value is intercepted above, so
* XmlEncode() is never passed a value it might return an
* error for.
*/
for (i = 0; i < n; i++) {
if (pool->end == pool->ptr && !poolGrow(pool)) {
result = XML_ERROR_NO_MEMORY;
goto endEntityValue;
}
*(pool->ptr)++ = buf[i];
}
} break;
case XML_TOK_PARTIAL:
if (enc == parser->m_encoding) parser->m_eventPtr = entityTextPtr;
result = XML_ERROR_INVALID_TOKEN;
goto endEntityValue;
case XML_TOK_INVALID:
if (enc == parser->m_encoding) parser->m_eventPtr = next;
result = XML_ERROR_INVALID_TOKEN;
goto endEntityValue;
default:
/* This default case should be unnecessary -- all the tokens
* that XmlEntityValueTok() can return have their own explicit
* cases -- but should be retained for safety. We do however
* exclude it from the coverage statistics.
*
* LCOV_EXCL_START
*/
if (enc == parser->m_encoding) parser->m_eventPtr = entityTextPtr;
result = XML_ERROR_UNEXPECTED_STATE;
goto endEntityValue;
/* LCOV_EXCL_STOP */
}
entityTextPtr = next;
}
endEntityValue:
#ifdef XML_DTD
parser->m_prologState.inEntityValue = oldInEntityValue;
#endif /* XML_DTD */
return result;
}
static void normalizeLines(XML_Char *s) {
XML_Char *p;
for (;; s++) {
if (*s == XML_T('\0')) return;
if (*s == 0xD) break;
}
p = s;
do {
if (*s == 0xD) {
*p++ = 0xA;
if (*++s == 0xA) s++;
} else
*p++ = *s++;
} while (*s);
*p = XML_T('\0');
}
static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end) {
const XML_Char *target;
XML_Char *data;
const char *tem;
if (!parser->m_processingInstructionHandler) {
if (parser->m_defaultHandler) reportDefault(parser, enc, start, end);
return 1;
}
start += enc->minBytesPerChar * 2;
tem = start + XmlNameLength(enc, start);
target = poolStoreString(&parser->m_tempPool, enc, start, tem);
if (!target) return 0;
poolFinish(&parser->m_tempPool);
data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
end - enc->minBytesPerChar * 2);
if (!data) return 0;
normalizeLines(data);
parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
poolClear(&parser->m_tempPool);
return 1;
}
static int reportComment(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end) {
XML_Char *data;
if (!parser->m_commentHandler) {
if (parser->m_defaultHandler) reportDefault(parser, enc, start, end);
return 1;
}
data = poolStoreString(&parser->m_tempPool, enc,
start + enc->minBytesPerChar * 4,
end - enc->minBytesPerChar * 3);
if (!data) return 0;
normalizeLines(data);
parser->m_commentHandler(parser->m_handlerArg, data);
poolClear(&parser->m_tempPool);
return 1;
}
static void reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
const char *end) {
if (MUST_CONVERT(enc, s)) {
enum XML_Convert_Result convert_res;
const char **eventPP;
const char **eventEndPP;
if (enc == parser->m_encoding) {
eventPP = &parser->m_eventPtr;
eventEndPP = &parser->m_eventEndPtr;
} else {
/* To get here, two things must be true; the parser must be
* using a character encoding that is not the same as the
* encoding passed in, and the encoding passed in must need
* conversion to the internal format (UTF-8 unless XML_UNICODE
* is defined). The only occasions on which the encoding passed
* in is not the same as the parser's encoding are when it is
* the internal encoding (e.g. a previously defined parameter
* entity, already converted to internal format). This by
* definition doesn't need conversion, so the whole branch never
* gets executed.
*
* For safety's sake we don't delete these lines and merely
* exclude them from coverage statistics.
*
* LCOV_EXCL_START
*/
eventPP = &(parser->m_openInternalEntities->internalEventPtr);
eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
/* LCOV_EXCL_STOP */
}
do {
ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
convert_res =
XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
*eventEndPP = s;
parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
(int)(dataPtr - (ICHAR *)parser->m_dataBuf));
*eventPP = s;
} while ((convert_res != XML_CONVERT_COMPLETED) &&
(convert_res != XML_CONVERT_INPUT_INCOMPLETE));
} else
parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
(int)((XML_Char *)end - (XML_Char *)s));
}
static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId,
XML_Bool isCdata, XML_Bool isId,
const XML_Char *value, XML_Parser parser) {
DEFAULT_ATTRIBUTE *att;
if (value || isId) {
/* The handling of default attributes gets messed up if we have
a default which duplicates a non-default. */
int i;
for (i = 0; i < type->nDefaultAtts; i++)
if (attId == type->defaultAtts[i].id) return 1;
if (isId && !type->idAtt && !attId->xmlns) type->idAtt = attId;
}
if (type->nDefaultAtts == type->allocDefaultAtts) {
if (type->allocDefaultAtts == 0) {
type->allocDefaultAtts = 8;
type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(
parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
if (!type->defaultAtts) {
type->allocDefaultAtts = 0;
return 0;
}
} else {
DEFAULT_ATTRIBUTE *temp;
int count = type->allocDefaultAtts * 2;
temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
(count * sizeof(DEFAULT_ATTRIBUTE)));
if (temp == NULL) return 0;
type->allocDefaultAtts = count;
type->defaultAtts = temp;
}
}
att = type->defaultAtts + type->nDefaultAtts;
att->id = attId;
att->value = value;
att->isCdata = isCdata;
if (!isCdata) attId->maybeTokenized = XML_TRUE;
type->nDefaultAtts += 1;
return 1;
}
static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
const XML_Char *name;
for (name = elementType->name; *name; name++) {
if (*name == XML_T(ASCII_COLON)) {
PREFIX *prefix;
const XML_Char *s;
for (s = elementType->name; s != name; s++) {
if (!poolAppendChar(&dtd->pool, *s)) return 0;
}
if (!poolAppendChar(&dtd->pool, XML_T('\0'))) return 0;
prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
sizeof(PREFIX));
if (!prefix) return 0;
if (prefix->name == poolStart(&dtd->pool))
poolFinish(&dtd->pool);
else
poolDiscard(&dtd->pool);
elementType->prefix = prefix;
break;
}
}
return 1;
}
static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
const char *start, const char *end) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
ATTRIBUTE_ID *id;
const XML_Char *name;
if (!poolAppendChar(&dtd->pool, XML_T('\0'))) return NULL;
name = poolStoreString(&dtd->pool, enc, start, end);
if (!name) return NULL;
/* skip quotation mark - its storage will be re-used (like in name[-1]) */
++name;
id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
sizeof(ATTRIBUTE_ID));
if (!id) return NULL;
if (id->name != name)
poolDiscard(&dtd->pool);
else {
poolFinish(&dtd->pool);
if (!parser->m_ns)
;
else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m) &&
name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n) &&
name[4] == XML_T(ASCII_s) &&
(name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
if (name[5] == XML_T('\0'))
id->prefix = &dtd->defaultPrefix;
else
id->prefix =
(PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
id->xmlns = XML_TRUE;
} else {
int i;
for (i = 0; name[i]; i++) {
/* attributes without prefix are *not* in the default namespace */
if (name[i] == XML_T(ASCII_COLON)) {
int j;
for (j = 0; j < i; j++) {
if (!poolAppendChar(&dtd->pool, name[j])) return NULL;
}
if (!poolAppendChar(&dtd->pool, XML_T('\0'))) return NULL;
id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
poolStart(&dtd->pool), sizeof(PREFIX));
if (!id->prefix) return NULL;
if (id->prefix->name == poolStart(&dtd->pool))
poolFinish(&dtd->pool);
else
poolDiscard(&dtd->pool);
break;
}
}
}
}
return id;
}
#define CONTEXT_SEP XML_T(ASCII_FF)
static const XML_Char *getContext(XML_Parser parser) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
HASH_TABLE_ITER iter;
XML_Bool needSep = XML_FALSE;
if (dtd->defaultPrefix.binding) {
int i;
int len;
if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS))) return NULL;
len = dtd->defaultPrefix.binding->uriLen;
if (parser->m_namespaceSeparator) len--;
for (i = 0; i < len; i++) {
if (!poolAppendChar(&parser->m_tempPool,
dtd->defaultPrefix.binding->uri[i])) {
/* Because of memory caching, I don't believe this line can be
* executed.
*
* This is part of a loop copying the default prefix binding
* URI into the parser's temporary string pool. Previously,
* that URI was copied into the same string pool, with a
* terminating NUL character, as part of setContext(). When
* the pool was cleared, that leaves a block definitely big
* enough to hold the URI on the free block list of the pool.
* The URI copy in getContext() therefore cannot run out of
* memory.
*
* If the pool is used between the setContext() and
* getContext() calls, the worst it can do is leave a bigger
* block on the front of the free list. Given that this is
* all somewhat inobvious and program logic can be changed, we
* don't delete the line but we do exclude it from the test
* coverage statistics.
*/
return NULL; /* LCOV_EXCL_LINE */
}
}
needSep = XML_TRUE;
}
hashTableIterInit(&iter, &(dtd->prefixes));
for (;;) {
int i;
int len;
const XML_Char *s;
PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
if (!prefix) break;
if (!prefix->binding) {
/* This test appears to be (justifiable) paranoia. There does
* not seem to be a way of injecting a prefix without a binding
* that doesn't get errored long before this function is called.
* The test should remain for safety's sake, so we instead
* exclude the following line from the coverage statistics.
*/
continue; /* LCOV_EXCL_LINE */
}
if (needSep && !poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
return NULL;
for (s = prefix->name; *s; s++)
if (!poolAppendChar(&parser->m_tempPool, *s)) return NULL;
if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS))) return NULL;
len = prefix->binding->uriLen;
if (parser->m_namespaceSeparator) len--;
for (i = 0; i < len; i++)
if (!poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
return NULL;
needSep = XML_TRUE;
}
hashTableIterInit(&iter, &(dtd->generalEntities));
for (;;) {
const XML_Char *s;
ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
if (!e) break;
if (!e->open_) continue;
if (needSep && !poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
return NULL;
for (s = e->name; *s; s++)
if (!poolAppendChar(&parser->m_tempPool, *s)) return 0;
needSep = XML_TRUE;
}
if (!poolAppendChar(&parser->m_tempPool, XML_T('\0'))) return NULL;
return parser->m_tempPool.start;
}
static XML_Bool setContext(XML_Parser parser, const XML_Char *context) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
const XML_Char *s = context;
while (*context != XML_T('\0')) {
if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
ENTITY *e;
if (!poolAppendChar(&parser->m_tempPool, XML_T('\0'))) return XML_FALSE;
e = (ENTITY *)lookup(parser, &dtd->generalEntities,
poolStart(&parser->m_tempPool), 0);
if (e) e->open_ = XML_TRUE;
if (*s != XML_T('\0')) s++;
context = s;
poolDiscard(&parser->m_tempPool);
} else if (*s == XML_T(ASCII_EQUALS)) {
PREFIX *prefix;
if (poolLength(&parser->m_tempPool) == 0)
prefix = &dtd->defaultPrefix;
else {
if (!poolAppendChar(&parser->m_tempPool, XML_T('\0'))) return XML_FALSE;
prefix =
(PREFIX *)lookup(parser, &dtd->prefixes,
poolStart(&parser->m_tempPool), sizeof(PREFIX));
if (!prefix) return XML_FALSE;
if (prefix->name == poolStart(&parser->m_tempPool)) {
prefix->name = poolCopyString(&dtd->pool, prefix->name);
if (!prefix->name) return XML_FALSE;
}
poolDiscard(&parser->m_tempPool);
}
for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0');
context++)
if (!poolAppendChar(&parser->m_tempPool, *context)) return XML_FALSE;
if (!poolAppendChar(&parser->m_tempPool, XML_T('\0'))) return XML_FALSE;
if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
&parser->m_inheritedBindings) != XML_ERROR_NONE)
return XML_FALSE;
poolDiscard(&parser->m_tempPool);
if (*context != XML_T('\0')) ++context;
s = context;
} else {
if (!poolAppendChar(&parser->m_tempPool, *s)) return XML_FALSE;
s++;
}
}
return XML_TRUE;
}
static void normalizePublicId(XML_Char *publicId) {
XML_Char *p = publicId;
XML_Char *s;
for (s = publicId; *s; s++) {
switch (*s) {
case 0x20:
case 0xD:
case 0xA:
if (p != publicId && p[-1] != 0x20) *p++ = 0x20;
break;
default:
*p++ = *s;
}
}
if (p != publicId && p[-1] == 0x20) --p;
*p = XML_T('\0');
}
static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms) {
DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
if (p == NULL) return p;
poolInit(&(p->pool), ms);
poolInit(&(p->entityValuePool), ms);
hashTableInit(&(p->generalEntities), ms);
hashTableInit(&(p->elementTypes), ms);
hashTableInit(&(p->attributeIds), ms);
hashTableInit(&(p->prefixes), ms);
#ifdef XML_DTD
p->paramEntityRead = XML_FALSE;
hashTableInit(&(p->paramEntities), ms);
#endif /* XML_DTD */
p->defaultPrefix.name = NULL;
p->defaultPrefix.binding = NULL;
p->in_eldecl = XML_FALSE;
p->scaffIndex = NULL;
p->scaffold = NULL;
p->scaffLevel = 0;
p->scaffSize = 0;
p->scaffCount = 0;
p->contentStringLen = 0;
p->keepProcessing = XML_TRUE;
p->hasParamEntityRefs = XML_FALSE;
p->standalone = XML_FALSE;
return p;
}
static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms) {
HASH_TABLE_ITER iter;
hashTableIterInit(&iter, &(p->elementTypes));
for (;;) {
ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
if (!e) break;
if (e->allocDefaultAtts != 0) ms->free_fcn(e->defaultAtts);
}
hashTableClear(&(p->generalEntities));
#ifdef XML_DTD
p->paramEntityRead = XML_FALSE;
hashTableClear(&(p->paramEntities));
#endif /* XML_DTD */
hashTableClear(&(p->elementTypes));
hashTableClear(&(p->attributeIds));
hashTableClear(&(p->prefixes));
poolClear(&(p->pool));
poolClear(&(p->entityValuePool));
p->defaultPrefix.name = NULL;
p->defaultPrefix.binding = NULL;
p->in_eldecl = XML_FALSE;
ms->free_fcn(p->scaffIndex);
p->scaffIndex = NULL;
ms->free_fcn(p->scaffold);
p->scaffold = NULL;
p->scaffLevel = 0;
p->scaffSize = 0;
p->scaffCount = 0;
p->contentStringLen = 0;
p->keepProcessing = XML_TRUE;
p->hasParamEntityRefs = XML_FALSE;
p->standalone = XML_FALSE;
}
static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
const XML_Memory_Handling_Suite *ms) {
HASH_TABLE_ITER iter;
hashTableIterInit(&iter, &(p->elementTypes));
for (;;) {
ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
if (!e) break;
if (e->allocDefaultAtts != 0) ms->free_fcn(e->defaultAtts);
}
hashTableDestroy(&(p->generalEntities));
#ifdef XML_DTD
hashTableDestroy(&(p->paramEntities));
#endif /* XML_DTD */
hashTableDestroy(&(p->elementTypes));
hashTableDestroy(&(p->attributeIds));
hashTableDestroy(&(p->prefixes));
poolDestroy(&(p->pool));
poolDestroy(&(p->entityValuePool));
if (isDocEntity) {
ms->free_fcn(p->scaffIndex);
ms->free_fcn(p->scaffold);
}
ms->free_fcn(p);
}
/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
The new DTD has already been initialized.
*/
static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
const XML_Memory_Handling_Suite *ms) {
HASH_TABLE_ITER iter;
/* Copy the prefix table. */
hashTableIterInit(&iter, &(oldDtd->prefixes));
for (;;) {
const XML_Char *name;
const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
if (!oldP) break;
name = poolCopyString(&(newDtd->pool), oldP->name);
if (!name) return 0;
if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX))) return 0;
}
hashTableIterInit(&iter, &(oldDtd->attributeIds));
/* Copy the attribute id table. */
for (;;) {
ATTRIBUTE_ID *newA;
const XML_Char *name;
const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
if (!oldA) break;
/* Remember to allocate the scratch byte before the name. */
if (!poolAppendChar(&(newDtd->pool), XML_T('\0'))) return 0;
name = poolCopyString(&(newDtd->pool), oldA->name);
if (!name) return 0;
++name;
newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
sizeof(ATTRIBUTE_ID));
if (!newA) return 0;
newA->maybeTokenized = oldA->maybeTokenized;
if (oldA->prefix) {
newA->xmlns = oldA->xmlns;
if (oldA->prefix == &oldDtd->defaultPrefix)
newA->prefix = &newDtd->defaultPrefix;
else
newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
oldA->prefix->name, 0);
}
}
/* Copy the element type table. */
hashTableIterInit(&iter, &(oldDtd->elementTypes));
for (;;) {
int i;
ELEMENT_TYPE *newE;
const XML_Char *name;
const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
if (!oldE) break;
name = poolCopyString(&(newDtd->pool), oldE->name);
if (!name) return 0;
newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
sizeof(ELEMENT_TYPE));
if (!newE) return 0;
if (oldE->nDefaultAtts) {
newE->defaultAtts = (DEFAULT_ATTRIBUTE *)ms->malloc_fcn(
oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
if (!newE->defaultAtts) {
return 0;
}
}
if (oldE->idAtt)
newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),
oldE->idAtt->name, 0);
newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
if (oldE->prefix)
newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
oldE->prefix->name, 0);
for (i = 0; i < newE->nDefaultAtts; i++) {
newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(
oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
if (oldE->defaultAtts[i].value) {
newE->defaultAtts[i].value =
poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
if (!newE->defaultAtts[i].value) return 0;
} else
newE->defaultAtts[i].value = NULL;
}
}
/* Copy the entity tables. */
if (!copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),
&(oldDtd->generalEntities)))
return 0;
#ifdef XML_DTD
if (!copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),
&(oldDtd->paramEntities)))
return 0;
newDtd->paramEntityRead = oldDtd->paramEntityRead;
#endif /* XML_DTD */
newDtd->keepProcessing = oldDtd->keepProcessing;
newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
newDtd->standalone = oldDtd->standalone;
/* Don't want deep copying for scaffolding */
newDtd->in_eldecl = oldDtd->in_eldecl;
newDtd->scaffold = oldDtd->scaffold;
newDtd->contentStringLen = oldDtd->contentStringLen;
newDtd->scaffSize = oldDtd->scaffSize;
newDtd->scaffLevel = oldDtd->scaffLevel;
newDtd->scaffIndex = oldDtd->scaffIndex;
return 1;
} /* End dtdCopy */
static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
STRING_POOL *newPool, const HASH_TABLE *oldTable) {
HASH_TABLE_ITER iter;
const XML_Char *cachedOldBase = NULL;
const XML_Char *cachedNewBase = NULL;
hashTableIterInit(&iter, oldTable);
for (;;) {
ENTITY *newE;
const XML_Char *name;
const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
if (!oldE) break;
name = poolCopyString(newPool, oldE->name);
if (!name) return 0;
newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
if (!newE) return 0;
if (oldE->systemId) {
const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
if (!tem) return 0;
newE->systemId = tem;
if (oldE->base) {
if (oldE->base == cachedOldBase)
newE->base = cachedNewBase;
else {
cachedOldBase = oldE->base;
tem = poolCopyString(newPool, cachedOldBase);
if (!tem) return 0;
cachedNewBase = newE->base = tem;
}
}
if (oldE->publicId) {
tem = poolCopyString(newPool, oldE->publicId);
if (!tem) return 0;
newE->publicId = tem;
}
} else {
const XML_Char *tem =
poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
if (!tem) return 0;
newE->textPtr = tem;
newE->textLen = oldE->textLen;
}
if (oldE->notation) {
const XML_Char *tem = poolCopyString(newPool, oldE->notation);
if (!tem) return 0;
newE->notation = tem;
}
newE->is_param = oldE->is_param;
newE->is_internal = oldE->is_internal;
}
return 1;
}
#define INIT_POWER 6
static XML_Bool keyeq(KEY s1, KEY s2) {
for (; *s1 == *s2; s1++, s2++)
if (*s1 == 0) return XML_TRUE;
return XML_FALSE;
}
static size_t keylen(KEY s) {
size_t len = 0;
for (; *s; s++, len++)
;
return len;
}
static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
key->k[0] = 0;
key->k[1] = get_hash_secret_salt(parser);
}
static unsigned long hash(XML_Parser parser, KEY s) {
struct siphash state;
struct sipkey key;
(void)sip24_valid;
copy_salt_to_sipkey(parser, &key);
sip24_init(&state, &key);
sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
return (unsigned long)sip24_final(&state);
}
static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
size_t createSize) {
size_t i;
if (table->size == 0) {
size_t tsize;
if (!createSize) return NULL;
table->power = INIT_POWER;
/* table->size is a power of 2 */
table->size = (size_t)1 << INIT_POWER;
tsize = table->size * sizeof(NAMED *);
table->v = (NAMED **)table->mem->malloc_fcn(tsize);
if (!table->v) {
table->size = 0;
return NULL;
}
bzero(table->v, tsize);
i = hash(parser, name) & ((unsigned long)table->size - 1);
} else {
unsigned long h = hash(parser, name);
unsigned long mask = (unsigned long)table->size - 1;
unsigned char step = 0;
i = h & mask;
while (table->v[i]) {
if (keyeq(name, table->v[i]->name)) return table->v[i];
if (!step) step = PROBE_STEP(h, mask, table->power);
i < step ? (i += table->size - step) : (i -= step);
}
if (!createSize) return NULL;
/* check for overflow (table is half full) */
if (table->used >> (table->power - 1)) {
unsigned char newPower = table->power + 1;
size_t newSize = (size_t)1 << newPower;
unsigned long newMask = (unsigned long)newSize - 1;
size_t tsize = newSize * sizeof(NAMED *);
NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
if (!newV) return NULL;
bzero(newV, tsize);
for (i = 0; i < table->size; i++)
if (table->v[i]) {
unsigned long newHash = hash(parser, table->v[i]->name);
size_t j = newHash & newMask;
step = 0;
while (newV[j]) {
if (!step) step = PROBE_STEP(newHash, newMask, newPower);
j < step ? (j += newSize - step) : (j -= step);
}
newV[j] = table->v[i];
}
table->mem->free_fcn(table->v);
table->v = newV;
table->power = newPower;
table->size = newSize;
i = h & newMask;
step = 0;
while (table->v[i]) {
if (!step) step = PROBE_STEP(h, newMask, newPower);
i < step ? (i += newSize - step) : (i -= step);
}
}
}
table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
if (!table->v[i]) return NULL;
bzero(table->v[i], createSize);
table->v[i]->name = name;
(table->used)++;
return table->v[i];
}
static void hashTableClear(HASH_TABLE *table) {
size_t i;
for (i = 0; i < table->size; i++) {
table->mem->free_fcn(table->v[i]);
table->v[i] = NULL;
}
table->used = 0;
}
static void hashTableDestroy(HASH_TABLE *table) {
size_t i;
for (i = 0; i < table->size; i++) table->mem->free_fcn(table->v[i]);
table->mem->free_fcn(table->v);
}
static void hashTableInit(HASH_TABLE *p,
const XML_Memory_Handling_Suite *ms) {
p->power = 0;
p->size = 0;
p->used = 0;
p->v = NULL;
p->mem = ms;
}
static void hashTableIterInit(HASH_TABLE_ITER *iter,
const HASH_TABLE *table) {
iter->p = table->v;
iter->end = iter->p + table->size;
}
static NAMED *hashTableIterNext(HASH_TABLE_ITER *iter) {
while (iter->p != iter->end) {
NAMED *tem = *(iter->p)++;
if (tem) return tem;
}
return NULL;
}
static void poolInit(STRING_POOL *pool,
const XML_Memory_Handling_Suite *ms) {
pool->blocks = NULL;
pool->freeBlocks = NULL;
pool->start = NULL;
pool->ptr = NULL;
pool->end = NULL;
pool->mem = ms;
}
static void poolClear(STRING_POOL *pool) {
if (!pool->freeBlocks)
pool->freeBlocks = pool->blocks;
else {
BLOCK *p = pool->blocks;
while (p) {
BLOCK *tem = p->next;
p->next = pool->freeBlocks;
pool->freeBlocks = p;
p = tem;
}
}
pool->blocks = NULL;
pool->start = NULL;
pool->ptr = NULL;
pool->end = NULL;
}
static void poolDestroy(STRING_POOL *pool) {
BLOCK *p = pool->blocks;
while (p) {
BLOCK *tem = p->next;
pool->mem->free_fcn(p);
p = tem;
}
p = pool->freeBlocks;
while (p) {
BLOCK *tem = p->next;
pool->mem->free_fcn(p);
p = tem;
}
}
static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end) {
if (!pool->ptr && !poolGrow(pool)) return NULL;
for (;;) {
const enum XML_Convert_Result convert_res =
XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
if ((convert_res == XML_CONVERT_COMPLETED) ||
(convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
if (!poolGrow(pool)) return NULL;
}
return pool->start;
}
static const XML_Char *poolCopyString(STRING_POOL *pool,
const XML_Char *s) {
do {
if (!poolAppendChar(pool, *s)) return NULL;
} while (*s++);
s = pool->start;
poolFinish(pool);
return s;
}
static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
int n) {
if (!pool->ptr && !poolGrow(pool)) {
/* The following line is unreachable given the current usage of
* poolCopyStringN(). Currently it is called from exactly one
* place to copy the text of a simple general entity. By that
* point, the name of the entity is already stored in the pool, so
* pool->ptr cannot be NULL.
*
* If poolCopyStringN() is used elsewhere as it well might be,
* this line may well become executable again. Regardless, this
* sort of check shouldn't be removed lightly, so we just exclude
* it from the coverage statistics.
*/
return NULL; /* LCOV_EXCL_LINE */
}
for (; n > 0; --n, s++) {
if (!poolAppendChar(pool, *s)) return NULL;
}
s = pool->start;
poolFinish(pool);
return s;
}
static const XML_Char *poolAppendString(STRING_POOL *pool,
const XML_Char *s) {
while (*s) {
if (!poolAppendChar(pool, *s)) return NULL;
s++;
}
return pool->start;
}
static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end) {
if (!poolAppend(pool, enc, ptr, end)) return NULL;
if (pool->ptr == pool->end && !poolGrow(pool)) return NULL;
*(pool->ptr)++ = 0;
return pool->start;
}
static size_t poolBytesToAllocateFor(int blockSize) {
/* Unprotected math would be:
** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
**
** Detect overflow, avoiding _signed_ overflow undefined behavior
** For a + b * c we check b * c in isolation first, so that addition of a
** on top has no chance of making us accept a small non-negative number
*/
const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
if (blockSize <= 0) return 0;
if (blockSize > (int)(INT_MAX / stretch)) return 0;
{
const int stretchedBlockSize = blockSize * (int)stretch;
const int bytesToAllocate =
(int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
if (bytesToAllocate < 0) return 0;
return (size_t)bytesToAllocate;
}
}
static XML_Bool poolGrow(STRING_POOL *pool) {
if (pool->freeBlocks) {
if (pool->start == 0) {
pool->blocks = pool->freeBlocks;
pool->freeBlocks = pool->freeBlocks->next;
pool->blocks->next = NULL;
pool->start = pool->blocks->s;
pool->end = pool->start + pool->blocks->size;
pool->ptr = pool->start;
return XML_TRUE;
}
if (pool->end - pool->start < pool->freeBlocks->size) {
BLOCK *tem = pool->freeBlocks->next;
pool->freeBlocks->next = pool->blocks;
pool->blocks = pool->freeBlocks;
pool->freeBlocks = tem;
memcpy(pool->blocks->s, pool->start,
(pool->end - pool->start) * sizeof(XML_Char));
pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
pool->start = pool->blocks->s;
pool->end = pool->start + pool->blocks->size;
return XML_TRUE;
}
}
if (pool->blocks && pool->start == pool->blocks->s) {
BLOCK *temp;
int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);
size_t bytesToAllocate;
/* NOTE: Needs to be calculated prior to calling `realloc`
to avoid dangling pointers: */
const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
if (blockSize < 0) {
/* This condition traps a situation where either more than
* INT_MAX/2 bytes have already been allocated. This isn't
* readily testable, since it is unlikely that an average
* machine will have that much memory, so we exclude it from the
* coverage statistics.
*/
return XML_FALSE; /* LCOV_EXCL_LINE */
}
bytesToAllocate = poolBytesToAllocateFor(blockSize);
if (bytesToAllocate == 0) return XML_FALSE;
temp = (BLOCK *)pool->mem->realloc_fcn(pool->blocks,
(unsigned)bytesToAllocate);
if (temp == NULL) return XML_FALSE;
pool->blocks = temp;
pool->blocks->size = blockSize;
pool->ptr = pool->blocks->s + offsetInsideBlock;
pool->start = pool->blocks->s;
pool->end = pool->start + blockSize;
} else {
BLOCK *tem;
int blockSize = (int)(pool->end - pool->start);
size_t bytesToAllocate;
if (blockSize < 0) {
/* This condition traps a situation where either more than
* INT_MAX bytes have already been allocated (which is prevented
* by various pieces of program logic, not least this one, never
* mind the unlikelihood of actually having that much memory) or
* the pool control fields have been corrupted (which could
* conceivably happen in an extremely buggy user handler
* function). Either way it isn't readily testable, so we
* exclude it from the coverage statistics.
*/
return XML_FALSE; /* LCOV_EXCL_LINE */
}
if (blockSize < INIT_BLOCK_SIZE)
blockSize = INIT_BLOCK_SIZE;
else {
/* Detect overflow, avoiding _signed_ overflow undefined behavior */
if ((int)((unsigned)blockSize * 2U) < 0) {
return XML_FALSE;
}
blockSize *= 2;
}
bytesToAllocate = poolBytesToAllocateFor(blockSize);
if (bytesToAllocate == 0) return XML_FALSE;
tem = (BLOCK *)pool->mem->malloc_fcn(bytesToAllocate);
if (!tem) return XML_FALSE;
tem->size = blockSize;
tem->next = pool->blocks;
pool->blocks = tem;
if (pool->ptr != pool->start)
memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
pool->ptr = tem->s + (pool->ptr - pool->start);
pool->start = tem->s;
pool->end = tem->s + blockSize;
}
return XML_TRUE;
}
static int nextScaffoldPart(XML_Parser parser) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
CONTENT_SCAFFOLD *me;
int next;
if (!dtd->scaffIndex) {
dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
if (!dtd->scaffIndex) return -1;
dtd->scaffIndex[0] = 0;
}
if (dtd->scaffCount >= dtd->scaffSize) {
CONTENT_SCAFFOLD *temp;
if (dtd->scaffold) {
temp = (CONTENT_SCAFFOLD *)REALLOC(
parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
if (temp == NULL) return -1;
dtd->scaffSize *= 2;
} else {
temp = (CONTENT_SCAFFOLD *)MALLOC(
parser, INIT_SCAFFOLD_ELEMENTS * sizeof(CONTENT_SCAFFOLD));
if (temp == NULL) return -1;
dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
}
dtd->scaffold = temp;
}
next = dtd->scaffCount++;
me = &dtd->scaffold[next];
if (dtd->scaffLevel) {
CONTENT_SCAFFOLD *parent =
&dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];
if (parent->lastchild) {
dtd->scaffold[parent->lastchild].nextsib = next;
}
if (!parent->childcnt) parent->firstchild = next;
parent->lastchild = next;
parent->childcnt++;
}
me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
return next;
}
static void build_node(XML_Parser parser, int src_node, XML_Content *dest,
XML_Content **contpos, XML_Char **strpos) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
dest->type = dtd->scaffold[src_node].type;
dest->quant = dtd->scaffold[src_node].quant;
if (dest->type == XML_CTYPE_NAME) {
const XML_Char *src;
dest->name = *strpos;
src = dtd->scaffold[src_node].name;
for (;;) {
*(*strpos)++ = *src;
if (!*src) break;
src++;
}
dest->numchildren = 0;
dest->children = NULL;
} else {
unsigned int i;
int cn;
dest->numchildren = dtd->scaffold[src_node].childcnt;
dest->children = *contpos;
*contpos += dest->numchildren;
for (i = 0, cn = dtd->scaffold[src_node].firstchild; i < dest->numchildren;
i++, cn = dtd->scaffold[cn].nextsib) {
build_node(parser, cn, &(dest->children[i]), contpos, strpos);
}
dest->name = NULL;
}
}
static XML_Content *build_model(XML_Parser parser) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
XML_Content *ret;
XML_Content *cpos;
XML_Char *str;
int allocsize = (dtd->scaffCount * sizeof(XML_Content) +
(dtd->contentStringLen * sizeof(XML_Char)));
ret = (XML_Content *)MALLOC(parser, allocsize);
if (!ret) return NULL;
str = (XML_Char *)(&ret[dtd->scaffCount]);
cpos = &ret[1];
build_node(parser, 0, ret, &cpos, &str);
return ret;
}
static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
const char *ptr, const char *end) {
DTD *const dtd = parser->m_dtd; /* save one level of indirection */
const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
ELEMENT_TYPE *ret;
if (!name) return NULL;
ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
sizeof(ELEMENT_TYPE));
if (!ret) return NULL;
if (ret->name != name)
poolDiscard(&dtd->pool);
else {
poolFinish(&dtd->pool);
if (!setElementTypePrefix(parser, ret)) return NULL;
}
return ret;
}
static XML_Char *copyString(const XML_Char *s,
const XML_Memory_Handling_Suite *memsuite) {
int charsRequired = 0;
XML_Char *result;
/* First determine how long the string is */
while (s[charsRequired] != 0) {
charsRequired++;
}
/* Include the terminator */
charsRequired++;
/* Now allocate space for the copy */
result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
if (result == NULL) return NULL;
/* Copy the original into place */
memcpy(result, s, charsRequired * sizeof(XML_Char));
return result;
}
| 234,222 | 6,273 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmltok.c | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
asm(".ident\t\"\\n\\n\
expat (MIT License)\\n\
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd\\n\
Copyright (c) 2000-2017 Expat development team\"");
asm(".include \"libc/disclaimer.inc\"");
#include "third_party/python/Modules/expat/expat_config.h"
#include "third_party/python/Modules/expat/expat_external.h"
#include "third_party/python/Modules/expat/internal.inc"
#include "third_party/python/Modules/expat/xmltok.h"
#include "libc/str/str.h"
#include "third_party/python/Modules/expat/nametab.inc"
#include "third_party/python/Modules/expat/xmltok_impl.h.inc"
#ifdef XML_DTD
# define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
#else
# define IGNORE_SECTION_TOK_VTABLE /* as nothing */
#endif
#define VTABLE1 \
{PREFIX(prologTok), PREFIX(contentTok), \
PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE}, \
{PREFIX(attributeValueTok), PREFIX(entityValueTok)}, \
PREFIX(nameMatchesAscii), PREFIX(nameLength), PREFIX(skipS), \
PREFIX(getAtts), PREFIX(charRefNumber), PREFIX(predefinedEntityName), \
PREFIX(updatePosition), PREFIX(isPublicId)
#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
#define UCS2_GET_NAMING(pages, hi, lo) \
(namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo)&0x1F)))
/* A 2 byte UTF-8 representation splits the characters 11 bits between
the bottom 5 and 6 bits of the bytes. We need 8 bits to index into
pages, 3 bits to add to that index and 5 bits to generate the mask.
*/
#define UTF8_GET_NAMING2(pages, byte) \
(namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
+ ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)] \
& (1u << (((byte)[1]) & 0x1F)))
/* A 3 byte UTF-8 representation splits the characters 16 bits between
the bottom 4, 6 and 6 bits of the bytes. We need 8 bits to index
into pages, 3 bits to add to that index and 5 bits to generate the
mask.
*/
#define UTF8_GET_NAMING3(pages, byte) \
(namingBitmap \
[((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)] \
<< 3) \
+ ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)] \
& (1u << (((byte)[2]) & 0x1F)))
#define UTF8_GET_NAMING(pages, p, n) \
((n) == 2 \
? UTF8_GET_NAMING2(pages, (const unsigned char *)(p)) \
: ((n) == 3 ? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) : 0))
/* Detection of invalid UTF-8 sequences is based on Table 3.1B
of Unicode 3.2: http://www.unicode.org/unicode/reports/tr28/
with the additional restriction of not allowing the Unicode
code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
Implementation details:
(A & 0x80) == 0 means A < 0x80
and
(A & 0xC0) == 0xC0 means A > 0xBF
*/
#define UTF8_INVALID2(p) \
((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0)
#define UTF8_INVALID3(p) \
(((p)[2] & 0x80) == 0 \
|| ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD \
: ((p)[2] & 0xC0) == 0xC0) \
|| ((*p) == 0xE0 \
? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0 \
: ((p)[1] & 0x80) == 0 \
|| ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
#define UTF8_INVALID4(p) \
(((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0 \
|| ((p)[2] & 0xC0) == 0xC0 \
|| ((*p) == 0xF0 \
? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0 \
: ((p)[1] & 0x80) == 0 \
|| ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
static int
isNever(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
UNUSED_P(p);
return 0;
}
static int
utf8_isName2(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
}
static int
utf8_isName3(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
}
#define utf8_isName4 isNever
static int
utf8_isNmstrt2(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
}
static int
utf8_isNmstrt3(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
}
#define utf8_isNmstrt4 isNever
static int
utf8_isInvalid2(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_INVALID2((const unsigned char *)p);
}
static int
utf8_isInvalid3(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_INVALID3((const unsigned char *)p);
}
static int
utf8_isInvalid4(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return UTF8_INVALID4((const unsigned char *)p);
}
struct normal_encoding {
ENCODING enc;
unsigned char type[256];
#ifdef XML_MIN_SIZE
int(*byteType)(const ENCODING *, const char *);
int(*isNameMin)(const ENCODING *, const char *);
int(*isNmstrtMin)(const ENCODING *, const char *);
int(*byteToAscii)(const ENCODING *, const char *);
int(*charMatches)(const ENCODING *, const char *, int);
#endif /* XML_MIN_SIZE */
int(*isName2)(const ENCODING *, const char *);
int(*isName3)(const ENCODING *, const char *);
int(*isName4)(const ENCODING *, const char *);
int(*isNmstrt2)(const ENCODING *, const char *);
int(*isNmstrt3)(const ENCODING *, const char *);
int(*isNmstrt4)(const ENCODING *, const char *);
int(*isInvalid2)(const ENCODING *, const char *);
int(*isInvalid3)(const ENCODING *, const char *);
int(*isInvalid4)(const ENCODING *, const char *);
};
#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc))
#ifdef XML_MIN_SIZE
# define STANDARD_VTABLE(E) \
E##byteType, E##isNameMin, E##isNmstrtMin, E##byteToAscii, E##charMatches,
#else
# define STANDARD_VTABLE(E) /* as nothing */
#endif
#define NORMAL_VTABLE(E) \
E##isName2, E##isName3, E##isName4, E##isNmstrt2, E##isNmstrt3, \
E##isNmstrt4, E##isInvalid2, E##isInvalid3, E##isInvalid4
#define NULL_VTABLE \
/* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL, \
/* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL, \
/* isInvalid2 */ NULL, /* isInvalid3 */ NULL, /* isInvalid4 */ NULL
static int checkCharRefNumber(int);
#include "third_party/python/Modules/expat/ascii.inc"
#ifdef XML_MIN_SIZE
# define sb_isNameMin isNever
# define sb_isNmstrtMin isNever
#endif
#ifdef XML_MIN_SIZE
# define MINBPC(enc) ((enc)->minBytesPerChar)
#else
/* minimum bytes per character */
# define MINBPC(enc) 1
#endif
#define SB_BYTE_TYPE(enc, p) \
(((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
#ifdef XML_MIN_SIZE
static int
sb_byteType(const ENCODING *enc, const char *p) {
return SB_BYTE_TYPE(enc, p);
}
# define BYTE_TYPE(enc, p) (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
#else
# define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
#endif
#ifdef XML_MIN_SIZE
# define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
static int
sb_byteToAscii(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return *p;
}
#else
# define BYTE_TO_ASCII(enc, p) (*(p))
#endif
#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p))
#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p))
#define IS_INVALID_CHAR(enc, p, n) \
(AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
#ifdef XML_MIN_SIZE
# define IS_NAME_CHAR_MINBPC(enc, p) \
(AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
# define IS_NMSTRT_CHAR_MINBPC(enc, p) \
(AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
#else
# define IS_NAME_CHAR_MINBPC(enc, p) (0)
# define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
#endif
#ifdef XML_MIN_SIZE
# define CHAR_MATCHES(enc, p, c) \
(AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
static int
sb_charMatches(const ENCODING *enc, const char *p, int c) {
UNUSED_P(enc);
return *p == c;
}
#else
/* c is an ASCII character */
# define CHAR_MATCHES(enc, p, c) (*(p) == c)
#endif
#define PREFIX(ident) normal_##ident
#define XML_TOK_IMPL_C
#include "third_party/python/Modules/expat/xmltok_impl.inc"
#undef XML_TOK_IMPL_C
#undef MINBPC
#undef BYTE_TYPE
#undef BYTE_TO_ASCII
#undef CHAR_MATCHES
#undef IS_NAME_CHAR
#undef IS_NAME_CHAR_MINBPC
#undef IS_NMSTRT_CHAR
#undef IS_NMSTRT_CHAR_MINBPC
#undef IS_INVALID_CHAR
enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
UTF8_cval1 = 0x00,
UTF8_cval2 = 0xc0,
UTF8_cval3 = 0xe0,
UTF8_cval4 = 0xf0
};
void
_INTERNAL_trim_to_complete_utf8_characters(const char *from,
const char **fromLimRef) {
const char *fromLim = *fromLimRef;
size_t walked = 0;
for (; fromLim > from; fromLim--, walked++) {
const unsigned char prev = (unsigned char)fromLim[-1];
if ((prev & 0xf8u)
== 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
if (walked + 1 >= 4) {
fromLim += 4 - 1;
break;
} else {
walked = 0;
}
} else if ((prev & 0xf0u)
== 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
if (walked + 1 >= 3) {
fromLim += 3 - 1;
break;
} else {
walked = 0;
}
} else if ((prev & 0xe0u)
== 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
if (walked + 1 >= 2) {
fromLim += 2 - 1;
break;
} else {
walked = 0;
}
} else if ((prev & 0x80u)
== 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
break;
}
}
*fromLimRef = fromLim;
}
static enum XML_Convert_Result
utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
char **toP, const char *toLim) {
bool input_incomplete = false;
bool output_exhausted = false;
/* Avoid copying partial characters (due to limited space). */
const ptrdiff_t bytesAvailable = fromLim - *fromP;
const ptrdiff_t bytesStorable = toLim - *toP;
UNUSED_P(enc);
if (bytesAvailable > bytesStorable) {
fromLim = *fromP + bytesStorable;
output_exhausted = true;
}
/* Avoid copying partial characters (from incomplete input). */
{
const char *const fromLimBefore = fromLim;
_INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim);
if (fromLim < fromLimBefore) {
input_incomplete = true;
}
}
{
const ptrdiff_t bytesToCopy = fromLim - *fromP;
memcpy(*toP, *fromP, bytesToCopy);
*fromP += bytesToCopy;
*toP += bytesToCopy;
}
if (output_exhausted) /* needs to go first */
return XML_CONVERT_OUTPUT_EXHAUSTED;
else if (input_incomplete)
return XML_CONVERT_INPUT_INCOMPLETE;
else
return XML_CONVERT_COMPLETED;
}
static enum XML_Convert_Result
utf8_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) {
enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
unsigned short *to = *toP;
const char *from = *fromP;
while (from < fromLim && to < toLim) {
switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
case BT_LEAD2:
if (fromLim - from < 2) {
res = XML_CONVERT_INPUT_INCOMPLETE;
goto after;
}
*to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
from += 2;
break;
case BT_LEAD3:
if (fromLim - from < 3) {
res = XML_CONVERT_INPUT_INCOMPLETE;
goto after;
}
*to++ = (unsigned short)(((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6)
| (from[2] & 0x3f));
from += 3;
break;
case BT_LEAD4: {
unsigned long n;
if (toLim - to < 2) {
res = XML_CONVERT_OUTPUT_EXHAUSTED;
goto after;
}
if (fromLim - from < 4) {
res = XML_CONVERT_INPUT_INCOMPLETE;
goto after;
}
n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
| ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
n -= 0x10000;
to[0] = (unsigned short)((n >> 10) | 0xD800);
to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
to += 2;
from += 4;
} break;
default:
*to++ = *from++;
break;
}
}
if (from < fromLim)
res = XML_CONVERT_OUTPUT_EXHAUSTED;
after:
*fromP = from;
*toP = to;
return res;
}
#ifdef XML_NS
static const struct normal_encoding utf8_encoding_ns
= {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
{
#include "third_party/python/Modules/expat/asciitab.inc"
#include "third_party/python/Modules/expat/utf8tab.inc"
},
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
#endif
static const struct normal_encoding utf8_encoding
= {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/asciitab.inc"
#undef BT_COLON
#include "third_party/python/Modules/expat/utf8tab.inc"
},
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
#ifdef XML_NS
static const struct normal_encoding internal_utf8_encoding_ns
= {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
{
#include "third_party/python/Modules/expat/iasciitab.inc"
#include "third_party/python/Modules/expat/utf8tab.inc"
},
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
#endif
static const struct normal_encoding internal_utf8_encoding
= {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/iasciitab.inc"
#undef BT_COLON
#include "third_party/python/Modules/expat/utf8tab.inc"
},
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
static enum XML_Convert_Result
latin1_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
char **toP, const char *toLim) {
UNUSED_P(enc);
for (;;) {
unsigned char c;
if (*fromP == fromLim)
return XML_CONVERT_COMPLETED;
c = (unsigned char)**fromP;
if (c & 0x80) {
if (toLim - *toP < 2)
return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = (char)((c >> 6) | UTF8_cval2);
*(*toP)++ = (char)((c & 0x3f) | 0x80);
(*fromP)++;
} else {
if (*toP == toLim)
return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = *(*fromP)++;
}
}
}
static enum XML_Convert_Result
latin1_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) {
UNUSED_P(enc);
while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = (unsigned char)*(*fromP)++;
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
}
#ifdef XML_NS
static const struct normal_encoding latin1_encoding_ns
= {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
{
#include "third_party/python/Modules/expat/asciitab.inc"
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(sb_) NULL_VTABLE};
#endif
static const struct normal_encoding latin1_encoding
= {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/asciitab.inc"
#undef BT_COLON
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(sb_) NULL_VTABLE};
static enum XML_Convert_Result
ascii_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
char **toP, const char *toLim) {
UNUSED_P(enc);
while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = *(*fromP)++;
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
}
#ifdef XML_NS
static const struct normal_encoding ascii_encoding_ns
= {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
{
#include "third_party/python/Modules/expat/asciitab.inc"
/* BT_NONXML == 0 */
},
STANDARD_VTABLE(sb_) NULL_VTABLE};
#endif
static const struct normal_encoding ascii_encoding
= {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/asciitab.inc"
#undef BT_COLON
/* BT_NONXML == 0 */
},
STANDARD_VTABLE(sb_) NULL_VTABLE};
static int
unicode_byte_type(char hi, char lo) {
switch ((unsigned char)hi) {
/* 0xD800â0xDBFF first 16-bit code unit or high surrogate (W1) */
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
return BT_LEAD4;
/* 0xDC00â0xDFFF second 16-bit code unit or low surrogate (W2) */
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
return BT_TRAIL;
case 0xFF:
switch ((unsigned char)lo) {
case 0xFF: /* noncharacter-FFFF */
case 0xFE: /* noncharacter-FFFE */
return BT_NONXML;
}
break;
}
return BT_NONASCII;
}
#define DEFINE_UTF16_TO_UTF8(E) \
static enum XML_Convert_Result E##toUtf8( \
const ENCODING *enc, const char **fromP, const char *fromLim, \
char **toP, const char *toLim) { \
const char *from = *fromP; \
UNUSED_P(enc); \
fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \
for (; from < fromLim; from += 2) { \
int plane; \
unsigned char lo2; \
unsigned char lo = GET_LO(from); \
unsigned char hi = GET_HI(from); \
switch (hi) { \
case 0: \
if (lo < 0x80) { \
if (*toP == toLim) { \
*fromP = from; \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
*(*toP)++ = lo; \
break; \
} \
/* fall through */ \
case 0x1: \
case 0x2: \
case 0x3: \
case 0x4: \
case 0x5: \
case 0x6: \
case 0x7: \
if (toLim - *toP < 2) { \
*fromP = from; \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
*(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \
*(*toP)++ = ((lo & 0x3f) | 0x80); \
break; \
default: \
if (toLim - *toP < 3) { \
*fromP = from; \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
*(*toP)++ = ((hi >> 4) | UTF8_cval3); \
*(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
*(*toP)++ = ((lo & 0x3f) | 0x80); \
break; \
case 0xD8: \
case 0xD9: \
case 0xDA: \
case 0xDB: \
if (toLim - *toP < 4) { \
*fromP = from; \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
if (fromLim - from < 4) { \
*fromP = from; \
return XML_CONVERT_INPUT_INCOMPLETE; \
} \
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
*(*toP)++ = (char)((plane >> 2) | UTF8_cval4); \
*(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
from += 2; \
lo2 = GET_LO(from); \
*(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2) \
| (lo2 >> 6) | 0x80); \
*(*toP)++ = ((lo2 & 0x3f) | 0x80); \
break; \
} \
} \
*fromP = from; \
if (from < fromLim) \
return XML_CONVERT_INPUT_INCOMPLETE; \
else \
return XML_CONVERT_COMPLETED; \
}
#define DEFINE_UTF16_TO_UTF16(E) \
static enum XML_Convert_Result E##toUtf16( \
const ENCODING *enc, const char **fromP, const char *fromLim, \
unsigned short **toP, const unsigned short *toLim) { \
enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
UNUSED_P(enc); \
fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */ \
/* Avoid copying first half only of surrogate */ \
if (fromLim - *fromP > ((toLim - *toP) << 1) \
&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
fromLim -= 2; \
res = XML_CONVERT_INPUT_INCOMPLETE; \
} \
for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
*(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
if ((*toP == toLim) && (*fromP < fromLim)) \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
else \
return res; \
}
#define SET2(ptr, ch) (((ptr)[0] = ((ch)&0xff)), ((ptr)[1] = ((ch) >> 8)))
#define GET_LO(ptr) ((unsigned char)(ptr)[0])
#define GET_HI(ptr) ((unsigned char)(ptr)[1])
DEFINE_UTF16_TO_UTF8(little2_)
DEFINE_UTF16_TO_UTF16(little2_)
#undef SET2
#undef GET_LO
#undef GET_HI
#define SET2(ptr, ch) (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch)&0xFF)))
#define GET_LO(ptr) ((unsigned char)(ptr)[1])
#define GET_HI(ptr) ((unsigned char)(ptr)[0])
DEFINE_UTF16_TO_UTF8(big2_)
DEFINE_UTF16_TO_UTF16(big2_)
#undef SET2
#undef GET_LO
#undef GET_HI
#define LITTLE2_BYTE_TYPE(enc, p) \
((p)[1] == 0 ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \
: unicode_byte_type((p)[1], (p)[0]))
#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1)
#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == c)
#define LITTLE2_IS_NAME_CHAR_MINBPC(p) \
UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p) \
UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
#ifdef XML_MIN_SIZE
static int
little2_byteType(const ENCODING *enc, const char *p) {
return LITTLE2_BYTE_TYPE(enc, p);
}
static int
little2_byteToAscii(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return LITTLE2_BYTE_TO_ASCII(p);
}
static int
little2_charMatches(const ENCODING *enc, const char *p, int c) {
UNUSED_P(enc);
return LITTLE2_CHAR_MATCHES(p, c);
}
static int
little2_isNameMin(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return LITTLE2_IS_NAME_CHAR_MINBPC(p);
}
static int
little2_isNmstrtMin(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
}
# undef VTABLE
# define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
#else /* not XML_MIN_SIZE */
# undef PREFIX
# define PREFIX(ident) little2_##ident
# define MINBPC(enc) 2
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
# define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
# define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p)
# define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c)
# define IS_NAME_CHAR(enc, p, n) 0
# define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p)
# define IS_NMSTRT_CHAR(enc, p, n) (0)
# define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
# define XML_TOK_IMPL_C
#include "third_party/python/Modules/expat/xmltok_impl.inc"
# undef XML_TOK_IMPL_C
# undef MINBPC
# undef BYTE_TYPE
# undef BYTE_TO_ASCII
# undef CHAR_MATCHES
# undef IS_NAME_CHAR
# undef IS_NAME_CHAR_MINBPC
# undef IS_NMSTRT_CHAR
# undef IS_NMSTRT_CHAR_MINBPC
# undef IS_INVALID_CHAR
#endif /* not XML_MIN_SIZE */
#ifdef XML_NS
static const struct normal_encoding little2_encoding_ns
= {{VTABLE, 2, 0,
# if BYTEORDER == 1234
1
# else
0
# endif
},
{
#include "third_party/python/Modules/expat/asciitab.inc"
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(little2_) NULL_VTABLE};
#endif
static const struct normal_encoding little2_encoding
= {{VTABLE, 2, 0,
#if BYTEORDER == 1234
1
#else
0
#endif
},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/asciitab.inc"
#undef BT_COLON
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(little2_) NULL_VTABLE};
#if BYTEORDER != 4321
# ifdef XML_NS
static const struct normal_encoding internal_little2_encoding_ns
= {{VTABLE, 2, 0, 1},
{
# include "third_party/python/Modules/expat/iasciitab.inc"
# include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(little2_) NULL_VTABLE};
# endif
static const struct normal_encoding internal_little2_encoding
= {{VTABLE, 2, 0, 1},
{
# define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/iasciitab.inc"
# undef BT_COLON
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(little2_) NULL_VTABLE};
#endif
#define BIG2_BYTE_TYPE(enc, p) \
((p)[0] == 0 \
? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
: unicode_byte_type((p)[0], (p)[1]))
#define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (p)[1] : -1)
#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == c)
#define BIG2_IS_NAME_CHAR_MINBPC(p) \
UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
#define BIG2_IS_NMSTRT_CHAR_MINBPC(p) \
UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
#ifdef XML_MIN_SIZE
static int
big2_byteType(const ENCODING *enc, const char *p) {
return BIG2_BYTE_TYPE(enc, p);
}
static int
big2_byteToAscii(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return BIG2_BYTE_TO_ASCII(p);
}
static int
big2_charMatches(const ENCODING *enc, const char *p, int c) {
UNUSED_P(enc);
return BIG2_CHAR_MATCHES(p, c);
}
static int
big2_isNameMin(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return BIG2_IS_NAME_CHAR_MINBPC(p);
}
static int
big2_isNmstrtMin(const ENCODING *enc, const char *p) {
UNUSED_P(enc);
return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
}
# undef VTABLE
# define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
#else /* not XML_MIN_SIZE */
# undef PREFIX
# define PREFIX(ident) big2_##ident
# define MINBPC(enc) 2
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
# define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
# define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(p)
# define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c)
# define IS_NAME_CHAR(enc, p, n) 0
# define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p)
# define IS_NMSTRT_CHAR(enc, p, n) (0)
# define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p)
# define XML_TOK_IMPL_C
#include "third_party/python/Modules/expat/xmltok_impl.inc"
# undef XML_TOK_IMPL_C
# undef MINBPC
# undef BYTE_TYPE
# undef BYTE_TO_ASCII
# undef CHAR_MATCHES
# undef IS_NAME_CHAR
# undef IS_NAME_CHAR_MINBPC
# undef IS_NMSTRT_CHAR
# undef IS_NMSTRT_CHAR_MINBPC
# undef IS_INVALID_CHAR
#endif /* not XML_MIN_SIZE */
#ifdef XML_NS
static const struct normal_encoding big2_encoding_ns
= {{VTABLE, 2, 0,
# if BYTEORDER == 4321
1
# else
0
# endif
},
{
#include "third_party/python/Modules/expat/asciitab.inc"
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(big2_) NULL_VTABLE};
#endif
static const struct normal_encoding big2_encoding
= {{VTABLE, 2, 0,
#if BYTEORDER == 4321
1
#else
0
#endif
},
{
#define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/asciitab.inc"
#undef BT_COLON
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(big2_) NULL_VTABLE};
#if BYTEORDER != 1234
# ifdef XML_NS
static const struct normal_encoding internal_big2_encoding_ns
= {{VTABLE, 2, 0, 1},
{
# include "third_party/python/Modules/expat/iasciitab.inc"
# include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(big2_) NULL_VTABLE};
# endif
static const struct normal_encoding internal_big2_encoding
= {{VTABLE, 2, 0, 1},
{
# define BT_COLON BT_NMSTRT
#include "third_party/python/Modules/expat/iasciitab.inc"
# undef BT_COLON
#include "third_party/python/Modules/expat/latin1tab.inc"
},
STANDARD_VTABLE(big2_) NULL_VTABLE};
#endif
#undef PREFIX
static int
streqci(const char *s1, const char *s2) {
for (;;) {
char c1 = *s1++;
char c2 = *s2++;
if (ASCII_a <= c1 && c1 <= ASCII_z)
c1 += ASCII_A - ASCII_a;
if (ASCII_a <= c2 && c2 <= ASCII_z)
/* The following line will never get executed. streqci() is
* only called from two places, both of which guarantee to put
* upper-case strings into s2.
*/
c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
if (c1 != c2)
return 0;
if (! c1)
break;
}
return 1;
}
static void
initUpdatePosition(const ENCODING *enc, const char *ptr, const char *end,
POSITION *pos) {
UNUSED_P(enc);
normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
}
static int
toAscii(const ENCODING *enc, const char *ptr, const char *end) {
char buf[1];
char *p = buf;
XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
if (p == buf)
return -1;
else
return buf[0];
}
static int
isSpace(int c) {
switch (c) {
case 0x20:
case 0xD:
case 0xA:
case 0x9:
return 1;
}
return 0;
}
/* Return 1 if there's just optional white space or there's an S
followed by name=val.
*/
static int
parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end,
const char **namePtr, const char **nameEndPtr,
const char **valPtr, const char **nextTokPtr) {
int c;
char open;
if (ptr == end) {
*namePtr = NULL;
return 1;
}
if (! isSpace(toAscii(enc, ptr, end))) {
*nextTokPtr = ptr;
return 0;
}
do {
ptr += enc->minBytesPerChar;
} while (isSpace(toAscii(enc, ptr, end)));
if (ptr == end) {
*namePtr = NULL;
return 1;
}
*namePtr = ptr;
for (;;) {
c = toAscii(enc, ptr, end);
if (c == -1) {
*nextTokPtr = ptr;
return 0;
}
if (c == ASCII_EQUALS) {
*nameEndPtr = ptr;
break;
}
if (isSpace(c)) {
*nameEndPtr = ptr;
do {
ptr += enc->minBytesPerChar;
} while (isSpace(c = toAscii(enc, ptr, end)));
if (c != ASCII_EQUALS) {
*nextTokPtr = ptr;
return 0;
}
break;
}
ptr += enc->minBytesPerChar;
}
if (ptr == *namePtr) {
*nextTokPtr = ptr;
return 0;
}
ptr += enc->minBytesPerChar;
c = toAscii(enc, ptr, end);
while (isSpace(c)) {
ptr += enc->minBytesPerChar;
c = toAscii(enc, ptr, end);
}
if (c != ASCII_QUOT && c != ASCII_APOS) {
*nextTokPtr = ptr;
return 0;
}
open = (char)c;
ptr += enc->minBytesPerChar;
*valPtr = ptr;
for (;; ptr += enc->minBytesPerChar) {
c = toAscii(enc, ptr, end);
if (c == open)
break;
if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)
&& ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD
&& c != ASCII_MINUS && c != ASCII_UNDERSCORE) {
*nextTokPtr = ptr;
return 0;
}
}
*nextTokPtr = ptr + enc->minBytesPerChar;
return 1;
}
static const char KW_version[]
= {ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'};
static const char KW_encoding[] = {ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d,
ASCII_i, ASCII_n, ASCII_g, '\0'};
static const char KW_standalone[]
= {ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a,
ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'};
static const char KW_yes[] = {ASCII_y, ASCII_e, ASCII_s, '\0'};
static const char KW_no[] = {ASCII_n, ASCII_o, '\0'};
static int
doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *,
const char *),
int isGeneralTextEntity, const ENCODING *enc, const char *ptr,
const char *end, const char **badPtr, const char **versionPtr,
const char **versionEndPtr, const char **encodingName,
const ENCODING **encoding, int *standalone) {
const char *val = NULL;
const char *name = NULL;
const char *nameEnd = NULL;
ptr += 5 * enc->minBytesPerChar;
end -= 2 * enc->minBytesPerChar;
if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
|| ! name) {
*badPtr = ptr;
return 0;
}
if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
if (! isGeneralTextEntity) {
*badPtr = name;
return 0;
}
} else {
if (versionPtr)
*versionPtr = val;
if (versionEndPtr)
*versionEndPtr = ptr;
if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
*badPtr = ptr;
return 0;
}
if (! name) {
if (isGeneralTextEntity) {
/* a TextDecl must have an EncodingDecl */
*badPtr = ptr;
return 0;
}
return 1;
}
}
if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
int c = toAscii(enc, val, end);
if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) {
*badPtr = val;
return 0;
}
if (encodingName)
*encodingName = val;
if (encoding)
*encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
*badPtr = ptr;
return 0;
}
if (! name)
return 1;
}
if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
|| isGeneralTextEntity) {
*badPtr = name;
return 0;
}
if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
if (standalone)
*standalone = 1;
} else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
if (standalone)
*standalone = 0;
} else {
*badPtr = val;
return 0;
}
while (isSpace(toAscii(enc, ptr, end)))
ptr += enc->minBytesPerChar;
if (ptr != end) {
*badPtr = ptr;
return 0;
}
return 1;
}
static int
checkCharRefNumber(int result) {
switch (result >> 8) {
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
return -1;
case 0:
if (latin1_encoding.type[result] == BT_NONXML)
return -1;
break;
case 0xFF:
if (result == 0xFFFE || result == 0xFFFF)
return -1;
break;
}
return result;
}
int
XmlUtf8Encode(int c, char *buf) {
enum {
/* minN is minimum legal resulting value for N byte sequence */
min2 = 0x80,
min3 = 0x800,
min4 = 0x10000
};
if (c < 0)
return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
if (c < min2) {
buf[0] = (char)(c | UTF8_cval1);
return 1;
}
if (c < min3) {
buf[0] = (char)((c >> 6) | UTF8_cval2);
buf[1] = (char)((c & 0x3f) | 0x80);
return 2;
}
if (c < min4) {
buf[0] = (char)((c >> 12) | UTF8_cval3);
buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
buf[2] = (char)((c & 0x3f) | 0x80);
return 3;
}
if (c < 0x110000) {
buf[0] = (char)((c >> 18) | UTF8_cval4);
buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
buf[3] = (char)((c & 0x3f) | 0x80);
return 4;
}
return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */
}
int
XmlUtf16Encode(int charNum, unsigned short *buf) {
if (charNum < 0)
return 0;
if (charNum < 0x10000) {
buf[0] = (unsigned short)charNum;
return 1;
}
if (charNum < 0x110000) {
charNum -= 0x10000;
buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
return 2;
}
return 0;
}
struct unknown_encoding {
struct normal_encoding normal;
CONVERTER convert;
void *userData;
unsigned short utf16[256];
char utf8[256][4];
};
#define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *)(enc))
int
XmlSizeOfUnknownEncoding(void) {
return sizeof(struct unknown_encoding);
}
static int
unknown_isName(const ENCODING *enc, const char *p) {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
int c = uenc->convert(uenc->userData, p);
if (c & ~0xFFFF)
return 0;
return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
}
static int
unknown_isNmstrt(const ENCODING *enc, const char *p) {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
int c = uenc->convert(uenc->userData, p);
if (c & ~0xFFFF)
return 0;
return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
}
static int
unknown_isInvalid(const ENCODING *enc, const char *p) {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
int c = uenc->convert(uenc->userData, p);
return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
}
static enum XML_Convert_Result
unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
char **toP, const char *toLim) {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
char buf[XML_UTF8_ENCODE_MAX];
for (;;) {
const char *utf8;
int n;
if (*fromP == fromLim)
return XML_CONVERT_COMPLETED;
utf8 = uenc->utf8[(unsigned char)**fromP];
n = *utf8++;
if (n == 0) {
int c = uenc->convert(uenc->userData, *fromP);
n = XmlUtf8Encode(c, buf);
if (n > toLim - *toP)
return XML_CONVERT_OUTPUT_EXHAUSTED;
utf8 = buf;
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
- (BT_LEAD2 - 2));
} else {
if (n > toLim - *toP)
return XML_CONVERT_OUTPUT_EXHAUSTED;
(*fromP)++;
}
memcpy(*toP, utf8, n);
*toP += n;
}
}
static enum XML_Convert_Result
unknown_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
while (*fromP < fromLim && *toP < toLim) {
unsigned short c = uenc->utf16[(unsigned char)**fromP];
if (c == 0) {
c = (unsigned short)uenc->convert(uenc->userData, *fromP);
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
- (BT_LEAD2 - 2));
} else
(*fromP)++;
*(*toP)++ = c;
}
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
}
ENCODING *
XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
void *userData) {
int i;
struct unknown_encoding *e = (struct unknown_encoding *)mem;
memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
for (i = 0; i < 128; i++)
if (latin1_encoding.type[i] != BT_OTHER
&& latin1_encoding.type[i] != BT_NONXML && table[i] != i)
return 0;
for (i = 0; i < 256; i++) {
int c = table[i];
if (c == -1) {
e->normal.type[i] = BT_MALFORM;
/* This shouldn't really get used. */
e->utf16[i] = 0xFFFF;
e->utf8[i][0] = 1;
e->utf8[i][1] = 0;
} else if (c < 0) {
if (c < -4)
return 0;
/* Multi-byte sequences need a converter function */
if (! convert)
return 0;
e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
e->utf8[i][0] = 0;
e->utf16[i] = 0;
} else if (c < 0x80) {
if (latin1_encoding.type[c] != BT_OTHER
&& latin1_encoding.type[c] != BT_NONXML && c != i)
return 0;
e->normal.type[i] = latin1_encoding.type[c];
e->utf8[i][0] = 1;
e->utf8[i][1] = (char)c;
e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
} else if (checkCharRefNumber(c) < 0) {
e->normal.type[i] = BT_NONXML;
/* This shouldn't really get used. */
e->utf16[i] = 0xFFFF;
e->utf8[i][0] = 1;
e->utf8[i][1] = 0;
} else {
if (c > 0xFFFF)
return 0;
if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
e->normal.type[i] = BT_NMSTRT;
else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
e->normal.type[i] = BT_NAME;
else
e->normal.type[i] = BT_OTHER;
e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
e->utf16[i] = (unsigned short)c;
}
}
e->userData = userData;
e->convert = convert;
if (convert) {
e->normal.isName2 = unknown_isName;
e->normal.isName3 = unknown_isName;
e->normal.isName4 = unknown_isName;
e->normal.isNmstrt2 = unknown_isNmstrt;
e->normal.isNmstrt3 = unknown_isNmstrt;
e->normal.isNmstrt4 = unknown_isNmstrt;
e->normal.isInvalid2 = unknown_isInvalid;
e->normal.isInvalid3 = unknown_isInvalid;
e->normal.isInvalid4 = unknown_isInvalid;
}
e->normal.enc.utf8Convert = unknown_toUtf8;
e->normal.enc.utf16Convert = unknown_toUtf16;
return &(e->normal.enc);
}
/* If this enumeration is changed, getEncodingIndex and encodings
must also be changed. */
enum {
UNKNOWN_ENC = -1,
ISO_8859_1_ENC = 0,
US_ASCII_ENC,
UTF_8_ENC,
UTF_16_ENC,
UTF_16BE_ENC,
UTF_16LE_ENC,
/* must match encodingNames up to here */
NO_ENC
};
static const char KW_ISO_8859_1[]
= {ASCII_I, ASCII_S, ASCII_O, ASCII_MINUS, ASCII_8, ASCII_8,
ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1, '\0'};
static const char KW_US_ASCII[]
= {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S,
ASCII_C, ASCII_I, ASCII_I, '\0'};
static const char KW_UTF_8[]
= {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'};
static const char KW_UTF_16[]
= {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'};
static const char KW_UTF_16BE[]
= {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
ASCII_6, ASCII_B, ASCII_E, '\0'};
static const char KW_UTF_16LE[]
= {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
ASCII_6, ASCII_L, ASCII_E, '\0'};
static int
getEncodingIndex(const char *name) {
static const char *const encodingNames[] = {
KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE,
};
int i;
if (name == NULL)
return NO_ENC;
for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
if (streqci(name, encodingNames[i]))
return i;
return UNKNOWN_ENC;
}
/* For binary compatibility, we store the index of the encoding
specified at initialization in the isUtf16 member.
*/
#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
/* This is what detects the encoding. encodingTable maps from
encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
the external (protocol) specified encoding; state is
XML_CONTENT_STATE if we're parsing an external text entity, and
XML_PROLOG_STATE otherwise.
*/
static int
initScan(const ENCODING *const *encodingTable, const INIT_ENCODING *enc,
int state, const char *ptr, const char *end, const char **nextTokPtr) {
const ENCODING **encPtr;
if (ptr >= end)
return XML_TOK_NONE;
encPtr = enc->encPtr;
if (ptr + 1 == end) {
/* only a single byte available for auto-detection */
#ifndef XML_DTD /* FIXME */
/* a well-formed document entity must have more than one byte */
if (state != XML_CONTENT_STATE)
return XML_TOK_PARTIAL;
#endif
/* so we're parsing an external text entity... */
/* if UTF-16 was externally specified, then we need at least 2 bytes */
switch (INIT_ENC_INDEX(enc)) {
case UTF_16_ENC:
case UTF_16LE_ENC:
case UTF_16BE_ENC:
return XML_TOK_PARTIAL;
}
switch ((unsigned char)*ptr) {
case 0xFE:
case 0xFF:
case 0xEF: /* possibly first byte of UTF-8 BOM */
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
break;
/* fall through */
case 0x00:
case 0x3C:
return XML_TOK_PARTIAL;
}
} else {
switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
case 0xFEFF:
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
break;
*nextTokPtr = ptr + 2;
*encPtr = encodingTable[UTF_16BE_ENC];
return XML_TOK_BOM;
/* 00 3C is handled in the default case */
case 0x3C00:
if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
|| INIT_ENC_INDEX(enc) == UTF_16_ENC)
&& state == XML_CONTENT_STATE)
break;
*encPtr = encodingTable[UTF_16LE_ENC];
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
case 0xFFFE:
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
break;
*nextTokPtr = ptr + 2;
*encPtr = encodingTable[UTF_16LE_ENC];
return XML_TOK_BOM;
case 0xEFBB:
/* Maybe a UTF-8 BOM (EF BB BF) */
/* If there's an explicitly specified (external) encoding
of ISO-8859-1 or some flavour of UTF-16
and this is an external text entity,
don't look for the BOM,
because it might be a legal data.
*/
if (state == XML_CONTENT_STATE) {
int e = INIT_ENC_INDEX(enc);
if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC
|| e == UTF_16_ENC)
break;
}
if (ptr + 2 == end)
return XML_TOK_PARTIAL;
if ((unsigned char)ptr[2] == 0xBF) {
*nextTokPtr = ptr + 3;
*encPtr = encodingTable[UTF_8_ENC];
return XML_TOK_BOM;
}
break;
default:
if (ptr[0] == '\0') {
/* 0 isn't a legal data character. Furthermore a document
entity can only start with ASCII characters. So the only
way this can fail to be big-endian UTF-16 if it it's an
external parsed general entity that's labelled as
UTF-16LE.
*/
if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
break;
*encPtr = encodingTable[UTF_16BE_ENC];
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
} else if (ptr[1] == '\0') {
/* We could recover here in the case:
- parsing an external entity
- second byte is 0
- no externally specified encoding
- no encoding declaration
by assuming UTF-16LE. But we don't, because this would mean when
presented just with a single byte, we couldn't reliably determine
whether we needed further bytes.
*/
if (state == XML_CONTENT_STATE)
break;
*encPtr = encodingTable[UTF_16LE_ENC];
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
}
break;
}
}
*encPtr = encodingTable[INIT_ENC_INDEX(enc)];
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
}
#define NS(x) x
#define ns(x) x
#define XML_TOK_NS_C
#include "third_party/python/Modules/expat/xmltok_ns.inc"
#undef XML_TOK_NS_C
#undef NS
#undef ns
#ifdef XML_NS
# define NS(x) x##NS
# define ns(x) x##_ns
# define XML_TOK_NS_C
#include "third_party/python/Modules/expat/xmltok_ns.inc"
# undef XML_TOK_NS_C
# undef NS
# undef ns
ENCODING *
XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
void *userData) {
ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
if (enc)
((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
return enc;
}
#endif /* XML_NS */
| 54,686 | 1,662 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmltok_ns.inc | /* clang-format off */
/* This file is included!
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
i Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifdef XML_TOK_NS_C
const ENCODING *
NS(XmlGetUtf8InternalEncoding)(void) {
return &ns(internal_utf8_encoding).enc;
}
const ENCODING *
NS(XmlGetUtf16InternalEncoding)(void) {
# if BYTEORDER == 1234
return &ns(internal_little2_encoding).enc;
# elif BYTEORDER == 4321
return &ns(internal_big2_encoding).enc;
# else
const short n = 1;
return (*(const char *)&n ? &ns(internal_little2_encoding).enc
: &ns(internal_big2_encoding).enc);
# endif
}
static const ENCODING *const NS(encodings)[] = {
&ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
&ns(utf8_encoding).enc, &ns(big2_encoding).enc,
&ns(big2_encoding).enc, &ns(little2_encoding).enc,
&ns(utf8_encoding).enc /* NO_ENC */
};
static int
NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
ptr, end, nextTokPtr);
}
static int
NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
ptr, end, nextTokPtr);
}
int
NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
const char *name) {
int i = getEncodingIndex(name);
if (i == UNKNOWN_ENC)
return 0;
SET_INIT_ENC_INDEX(p, i);
p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
p->initEnc.updatePosition = initUpdatePosition;
p->encPtr = encPtr;
*encPtr = &(p->initEnc);
return 1;
}
static const ENCODING *
NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
# define ENCODING_MAX 128
char buf[ENCODING_MAX] = {0}; /* [jart] wut */
char *p = buf;
int i;
XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
if (ptr != end)
return 0;
*p = 0;
if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
return enc;
i = getEncodingIndex(buf);
if (i == UNKNOWN_ENC)
return 0;
return NS(encodings)[i];
}
int
NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
const char *ptr, const char *end, const char **badPtr,
const char **versionPtr, const char **versionEndPtr,
const char **encodingName, const ENCODING **encoding,
int *standalone) {
return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
badPtr, versionPtr, versionEndPtr, encodingName,
encoding, standalone);
}
#endif /* XML_TOK_NS_C */
| 4,367 | 120 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/expat_config.h | #ifndef EXPAT_CONFIG_H
#define EXPAT_CONFIG_H
#include "third_party/python/pyconfig.h"
#ifdef WORDS_BIGENDIAN
#define BYTEORDER 4321
#else
#define BYTEORDER 1234
#endif
#define XML_NS 1
#define XML_DTD 1
#define XML_CONTEXT_BYTES 1024
#endif /* EXPAT_CONFIG_H */
| 287 | 16 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/asciitab.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
| 3,374 | 66 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/utf8tab.inc | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
| 3,376 | 66 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmltok.h | #ifndef XmlTok_INCLUDED
#define XmlTok_INCLUDED 1
#include "third_party/python/Modules/expat/expat_external.h"
COSMOPOLITAN_C_START_
/* clang-format off */
/* The following token may be returned by XmlContentTok */
#define XML_TOK_TRAILING_RSQB \
-5 /* ] or ]] at the end of the scan; might be \
start of illegal ]]> sequence */
/* The following tokens may be returned by both XmlPrologTok and
XmlContentTok.
*/
#define XML_TOK_NONE -4 /* The string to be scanned is empty */
#define XML_TOK_TRAILING_CR \
-3 /* A CR at the end of the scan; \
might be part of CRLF sequence */
#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
#define XML_TOK_PARTIAL -1 /* only part of a token */
#define XML_TOK_INVALID 0
/* The following tokens are returned by XmlContentTok; some are also
returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
*/
#define XML_TOK_START_TAG_WITH_ATTS 1
#define XML_TOK_START_TAG_NO_ATTS 2
#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
#define XML_TOK_END_TAG 5
#define XML_TOK_DATA_CHARS 6
#define XML_TOK_DATA_NEWLINE 7
#define XML_TOK_CDATA_SECT_OPEN 8
#define XML_TOK_ENTITY_REF 9
#define XML_TOK_CHAR_REF 10 /* numeric character reference */
/* The following tokens may be returned by both XmlPrologTok and
XmlContentTok.
*/
#define XML_TOK_PI 11 /* processing instruction */
#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
#define XML_TOK_COMMENT 13
#define XML_TOK_BOM 14 /* Byte order mark */
/* The following tokens are returned only by XmlPrologTok */
#define XML_TOK_PROLOG_S 15
#define XML_TOK_DECL_OPEN 16 /* <!foo */
#define XML_TOK_DECL_CLOSE 17 /* > */
#define XML_TOK_NAME 18
#define XML_TOK_NMTOKEN 19
#define XML_TOK_POUND_NAME 20 /* #name */
#define XML_TOK_OR 21 /* | */
#define XML_TOK_PERCENT 22
#define XML_TOK_OPEN_PAREN 23
#define XML_TOK_CLOSE_PAREN 24
#define XML_TOK_OPEN_BRACKET 25
#define XML_TOK_CLOSE_BRACKET 26
#define XML_TOK_LITERAL 27
#define XML_TOK_PARAM_ENTITY_REF 28
#define XML_TOK_INSTANCE_START 29
/* The following occur only in element type declarations */
#define XML_TOK_NAME_QUESTION 30 /* name? */
#define XML_TOK_NAME_ASTERISK 31 /* name* */
#define XML_TOK_NAME_PLUS 32 /* name+ */
#define XML_TOK_COND_SECT_OPEN 33 /* <![ */
#define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */
#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
#define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */
#define XML_TOK_COMMA 38
/* The following token is returned only by XmlAttributeValueTok */
#define XML_TOK_ATTRIBUTE_VALUE_S 39
/* The following token is returned only by XmlCdataSectionTok */
#define XML_TOK_CDATA_SECT_CLOSE 40
/* With namespace processing this is returned by XmlPrologTok for a
name with a colon.
*/
#define XML_TOK_PREFIXED_NAME 41
#ifdef XML_DTD
# define XML_TOK_IGNORE_SECT 42
#endif /* XML_DTD */
#ifdef XML_DTD
# define XML_N_STATES 4
#else /* not XML_DTD */
# define XML_N_STATES 3
#endif /* not XML_DTD */
#define XML_PROLOG_STATE 0
#define XML_CONTENT_STATE 1
#define XML_CDATA_SECTION_STATE 2
#ifdef XML_DTD
# define XML_IGNORE_SECTION_STATE 3
#endif /* XML_DTD */
#define XML_N_LITERAL_TYPES 2
#define XML_ATTRIBUTE_VALUE_LITERAL 0
#define XML_ENTITY_VALUE_LITERAL 1
/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
#define XML_UTF8_ENCODE_MAX 4
/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
#define XML_UTF16_ENCODE_MAX 2
typedef struct position {
/* first line and first column are 0 not 1 */
XML_Size lineNumber;
XML_Size columnNumber;
} POSITION;
typedef struct {
const char *name;
const char *valuePtr;
const char *valueEnd;
char normalized;
} ATTRIBUTE;
struct encoding;
typedef struct encoding ENCODING;
typedef int( *SCANNER)(const ENCODING *, const char *, const char *,
const char **);
enum XML_Convert_Result {
XML_CONVERT_COMPLETED = 0,
XML_CONVERT_INPUT_INCOMPLETE = 1,
XML_CONVERT_OUTPUT_EXHAUSTED
= 2 /* and therefore potentially input remaining as well */
};
struct encoding {
SCANNER scanners[XML_N_STATES];
SCANNER literalScanners[XML_N_LITERAL_TYPES];
int(*nameMatchesAscii)(const ENCODING *, const char *, const char *,
const char *);
int(*nameLength)(const ENCODING *, const char *);
const char *(*skipS)(const ENCODING *, const char *);
int(*getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
ATTRIBUTE *atts);
int(*charRefNumber)(const ENCODING *enc, const char *ptr);
int(*predefinedEntityName)(const ENCODING *, const char *,
const char *);
void(*updatePosition)(const ENCODING *, const char *ptr,
const char *end, POSITION *);
int(*isPublicId)(const ENCODING *enc, const char *ptr,
const char *end, const char **badPtr);
enum XML_Convert_Result(*utf8Convert)(const ENCODING *enc,
const char **fromP,
const char *fromLim, char **toP,
const char *toLim);
enum XML_Convert_Result(*utf16Convert)(const ENCODING *enc,
const char **fromP,
const char *fromLim,
unsigned short **toP,
const unsigned short *toLim);
int minBytesPerChar;
char isUtf8;
char isUtf16;
};
/* Scan the string starting at ptr until the end of the next complete
token, but do not scan past eptr. Return an integer giving the
type of token.
Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
Return XML_TOK_PARTIAL when the string does not contain a complete
token; nextTokPtr will not be set.
Return XML_TOK_INVALID when the string does not start a valid
token; nextTokPtr will be set to point to the character which made
the token invalid.
Otherwise the string starts with a valid token; nextTokPtr will be
set to point to the character following the end of that token.
Each data character counts as a single token, but adjacent data
characters may be returned together. Similarly for characters in
the prolog outside literals, comments and processing instructions.
*/
#define XmlTok(enc, state, ptr, end, nextTokPtr) \
(((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
#define XmlContentTok(enc, ptr, end, nextTokPtr) \
XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
#ifdef XML_DTD
# define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
#endif /* XML_DTD */
/* This is used for performing a 2nd-level tokenization on the content
of a literal that has already been returned by XmlTok.
*/
#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
(((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
(((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
#define XmlGetAttributes(enc, ptr, attsMax, atts) \
(((enc)->getAtts)(enc, ptr, attsMax, atts))
#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
#define XmlPredefinedEntityName(enc, ptr, end) \
(((enc)->predefinedEntityName)(enc, ptr, end))
#define XmlUpdatePosition(enc, ptr, end, pos) \
(((enc)->updatePosition)(enc, ptr, end, pos))
#define XmlIsPublicId(enc, ptr, end, badPtr) \
(((enc)->isPublicId)(enc, ptr, end, badPtr))
#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
(((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
(((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
typedef struct {
ENCODING initEnc;
const ENCODING **encPtr;
} INIT_ENCODING;
int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
const char *ptr, const char *end, const char **badPtr,
const char **versionPtr, const char **versionEndPtr,
const char **encodingNamePtr,
const ENCODING **namedEncodingPtr, int *standalonePtr);
int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
const ENCODING *XmlGetUtf8InternalEncoding(void);
const ENCODING *XmlGetUtf16InternalEncoding(void);
int XmlUtf8Encode(int charNumber, char *buf);
int XmlUtf16Encode(int charNumber, unsigned short *buf);
int XmlSizeOfUnknownEncoding(void);
typedef int(*CONVERTER)(void *userData, const char *p);
ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
void *userData);
int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
const char *ptr, const char *end, const char **badPtr,
const char **versionPtr, const char **versionEndPtr,
const char **encodingNamePtr,
const ENCODING **namedEncodingPtr, int *standalonePtr);
int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
const ENCODING *XmlGetUtf8InternalEncodingNS(void);
const ENCODING *XmlGetUtf16InternalEncodingNS(void);
ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
void *userData);
COSMOPOLITAN_C_END_
#endif /* not XmlTok_INCLUDED */
| 10,794 | 281 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/expat.h | #ifndef Expat_INCLUDED
#define Expat_INCLUDED 1
#include "third_party/python/Modules/expat/expat_external.h"
COSMOPOLITAN_C_START_
struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser;
typedef unsigned char XML_Bool;
#define XML_TRUE ((XML_Bool)1)
#define XML_FALSE ((XML_Bool)0)
/* The XML_Status enum gives the possible return values for several
API functions. The preprocessor #defines are included so this
stanza can be added to code that still needs to support older
versions of Expat 1.95.x:
#ifndef XML_STATUS_OK
#define XML_STATUS_OK 1
#define XML_STATUS_ERROR 0
#endif
Otherwise, the #define hackery is quite ugly and would have been
dropped.
*/
enum XML_Status {
XML_STATUS_ERROR = 0,
#define XML_STATUS_ERROR XML_STATUS_ERROR
XML_STATUS_OK = 1,
#define XML_STATUS_OK XML_STATUS_OK
XML_STATUS_SUSPENDED = 2
#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
};
enum XML_Error {
XML_ERROR_NONE,
XML_ERROR_NO_MEMORY,
XML_ERROR_SYNTAX,
XML_ERROR_NO_ELEMENTS,
XML_ERROR_INVALID_TOKEN,
XML_ERROR_UNCLOSED_TOKEN,
XML_ERROR_PARTIAL_CHAR,
XML_ERROR_TAG_MISMATCH,
XML_ERROR_DUPLICATE_ATTRIBUTE,
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
XML_ERROR_PARAM_ENTITY_REF,
XML_ERROR_UNDEFINED_ENTITY,
XML_ERROR_RECURSIVE_ENTITY_REF,
XML_ERROR_ASYNC_ENTITY,
XML_ERROR_BAD_CHAR_REF,
XML_ERROR_BINARY_ENTITY_REF,
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
XML_ERROR_MISPLACED_XML_PI,
XML_ERROR_UNKNOWN_ENCODING,
XML_ERROR_INCORRECT_ENCODING,
XML_ERROR_UNCLOSED_CDATA_SECTION,
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
XML_ERROR_NOT_STANDALONE,
XML_ERROR_UNEXPECTED_STATE,
XML_ERROR_ENTITY_DECLARED_IN_PE,
XML_ERROR_FEATURE_REQUIRES_XML_DTD,
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
/* Added in 1.95.7. */
XML_ERROR_UNBOUND_PREFIX,
/* Added in 1.95.8. */
XML_ERROR_UNDECLARING_PREFIX,
XML_ERROR_INCOMPLETE_PE,
XML_ERROR_XML_DECL,
XML_ERROR_TEXT_DECL,
XML_ERROR_PUBLICID,
XML_ERROR_SUSPENDED,
XML_ERROR_NOT_SUSPENDED,
XML_ERROR_ABORTED,
XML_ERROR_FINISHED,
XML_ERROR_SUSPEND_PE,
/* Added in 2.0. */
XML_ERROR_RESERVED_PREFIX_XML,
XML_ERROR_RESERVED_PREFIX_XMLNS,
XML_ERROR_RESERVED_NAMESPACE_URI,
/* Added in 2.2.1. */
XML_ERROR_INVALID_ARGUMENT
};
enum XML_Content_Type {
XML_CTYPE_EMPTY = 1,
XML_CTYPE_ANY,
XML_CTYPE_MIXED,
XML_CTYPE_NAME,
XML_CTYPE_CHOICE,
XML_CTYPE_SEQ
};
enum XML_Content_Quant {
XML_CQUANT_NONE,
XML_CQUANT_OPT,
XML_CQUANT_REP,
XML_CQUANT_PLUS
};
/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
XML_CQUANT_NONE, and the other fields will be zero or NULL.
If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
numchildren will contain number of elements that may be mixed in
and children point to an array of XML_Content cells that will be
all of XML_CTYPE_NAME type with no quantification.
If type == XML_CTYPE_NAME, then the name points to the name, and
the numchildren field will be zero and children will be NULL. The
quant fields indicates any quantifiers placed on the name.
CHOICE and SEQ will have name NULL, the number of children in
numchildren and children will point, recursively, to an array
of XML_Content cells.
The EMPTY, ANY, and MIXED types will only occur at top level.
*/
typedef struct XML_cp XML_Content;
struct XML_cp {
enum XML_Content_Type type;
enum XML_Content_Quant quant;
XML_Char *name;
unsigned int numchildren;
XML_Content *children;
};
/* This is called for an element declaration. See above for
description of the model argument. It's the caller's responsibility
to free model when finished with it.
*/
typedef void (*XML_ElementDeclHandler)(void *userData, const XML_Char *name,
XML_Content *model);
void XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl);
/* The Attlist declaration handler is called for *each* attribute. So
a single Attlist declaration with multiple attributes declared will
generate multiple calls to this handler. The "default" parameter
may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
keyword. The "isrequired" parameter will be true and the default
value will be NULL in the case of "#REQUIRED". If "isrequired" is
true and default is non-NULL, then this is a "#FIXED" default.
*/
typedef void (*XML_AttlistDeclHandler)(void *userData, const XML_Char *elname,
const XML_Char *attname,
const XML_Char *att_type,
const XML_Char *dflt, int isrequired);
void XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl);
/* The XML declaration handler is called for *both* XML declarations
and text declarations. The way to distinguish is that the version
parameter will be NULL for text declarations. The encoding
parameter may be NULL for XML declarations. The standalone
parameter will be -1, 0, or 1 indicating respectively that there
was no standalone parameter in the declaration, that it was given
as no, or that it was given as yes.
*/
typedef void (*XML_XmlDeclHandler)(void *userData, const XML_Char *version,
const XML_Char *encoding, int standalone);
void XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
typedef struct {
void *(*malloc_fcn)(size_t size);
void *(*realloc_fcn)(void *ptr, size_t size);
void (*free_fcn)(void *ptr);
} XML_Memory_Handling_Suite;
/* Constructs a new parser; encoding is the encoding specified by the
external protocol or NULL if there is none specified.
*/
XML_Parser XML_ParserCreate(const XML_Char *encoding);
/* Constructs a new parser and namespace processor. Element type
names and attribute names that belong to a namespace will be
expanded; unprefixed attribute names are never expanded; unprefixed
element type names are expanded only if there is a default
namespace. The expanded name is the concatenation of the namespace
URI, the namespace separator character, and the local part of the
name. If the namespace separator is '\0' then the namespace URI
and the local part will be concatenated without any separator.
It is a programming error to use the separator '\0' with namespace
triplets (see XML_SetReturnNSTriplet).
*/
XML_Parser XML_ParserCreateNS(const XML_Char *encoding,
XML_Char namespaceSeparator);
/* Constructs a new parser using the memory management suite referred to
by memsuite. If memsuite is NULL, then use the standard library memory
suite. If namespaceSeparator is non-NULL it creates a parser with
namespace processing as described above. The character pointed at
will serve as the namespace separator.
All further memory operations used for the created parser will come from
the given suite.
*/
XML_Parser XML_ParserCreate_MM(const XML_Char *encoding,
const XML_Memory_Handling_Suite *memsuite,
const XML_Char *namespaceSeparator);
/* Prepare a parser object to be re-used. This is particularly
valuable when memory allocation overhead is disproportionately high,
such as when a large number of small documnents need to be parsed.
All handlers are cleared from the parser, except for the
unknownEncodingHandler. The parser's external state is re-initialized
except for the values of ns and ns_triplets.
Added in Expat 1.95.3.
*/
XML_Bool XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
/* atts is array of name/value pairs, terminated by 0;
names and values are 0 terminated.
*/
typedef void (*XML_StartElementHandler)(void *userData, const XML_Char *name,
const XML_Char **atts);
typedef void (*XML_EndElementHandler)(void *userData, const XML_Char *name);
/* s is not 0 terminated. */
typedef void (*XML_CharacterDataHandler)(void *userData, const XML_Char *s,
int len);
/* target and data are 0 terminated */
typedef void (*XML_ProcessingInstructionHandler)(void *userData,
const XML_Char *target,
const XML_Char *data);
/* data is 0 terminated */
typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
typedef void (*XML_StartCdataSectionHandler)(void *userData);
typedef void (*XML_EndCdataSectionHandler)(void *userData);
/* This is called for any characters in the XML document for which
there is no applicable handler. This includes both characters that
are part of markup which is of a kind that is not reported
(comments, markup declarations), or characters that are part of a
construct which could be reported but for which no handler has been
supplied. The characters are passed exactly as they were in the XML
document except that they will be encoded in UTF-8 or UTF-16.
Line boundaries are not normalized. Note that a byte order mark
character is not passed to the default handler. There are no
guarantees about how characters are divided between calls to the
default handler: for example, a comment might be split between
multiple calls.
*/
typedef void (*XML_DefaultHandler)(void *userData, const XML_Char *s, int len);
/* This is called for the start of the DOCTYPE declaration, before
any DTD or internal subset is parsed.
*/
typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
const XML_Char *doctypeName,
const XML_Char *sysid,
const XML_Char *pubid,
int has_internal_subset);
/* This is called for the start of the DOCTYPE declaration when the
closing > is encountered, but after processing any external
subset.
*/
typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
/* This is called for entity declarations. The is_parameter_entity
argument will be non-zero if the entity is a parameter entity, zero
otherwise.
For internal entities (<!ENTITY foo "bar">), value will
be non-NULL and systemId, publicID, and notationName will be NULL.
The value string is NOT nul-terminated; the length is provided in
the value_length argument. Since it is legal to have zero-length
values, do not use this argument to test for internal entities.
For external entities, value will be NULL and systemId will be
non-NULL. The publicId argument will be NULL unless a public
identifier was provided. The notationName argument will have a
non-NULL value only for unparsed entity declarations.
Note that is_parameter_entity can't be changed to XML_Bool, since
that would break binary compatibility.
*/
typedef void (*XML_EntityDeclHandler)(
void *userData, const XML_Char *entityName, int is_parameter_entity,
const XML_Char *value, int value_length, const XML_Char *base,
const XML_Char *systemId, const XML_Char *publicId,
const XML_Char *notationName);
void XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
/* OBSOLETE -- OBSOLETE -- OBSOLETE
This handler has been superseded by the EntityDeclHandler above.
It is provided here for backward compatibility.
This is called for a declaration of an unparsed (NDATA) entity.
The base argument is whatever was set by XML_SetBase. The
entityName, systemId and notationName arguments will never be
NULL. The other arguments may be.
*/
typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
const XML_Char *entityName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName);
/* This is called for a declaration of notation. The base argument is
whatever was set by XML_SetBase. The notationName will never be
NULL. The other arguments can be.
*/
typedef void (*XML_NotationDeclHandler)(void *userData,
const XML_Char *notationName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
/* When namespace processing is enabled, these are called once for
each namespace declaration. The call to the start and end element
handlers occur between the calls to the start and end namespace
declaration handlers. For an xmlns attribute, prefix will be
NULL. For an xmlns="" attribute, uri will be NULL.
*/
typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
const XML_Char *prefix,
const XML_Char *uri);
typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
const XML_Char *prefix);
/* This is called if the document is not standalone, that is, it has an
external subset or a reference to a parameter entity, but does not
have standalone="yes". If this handler returns XML_STATUS_ERROR,
then processing will not continue, and the parser will return a
XML_ERROR_NOT_STANDALONE error.
If parameter entity parsing is enabled, then in addition to the
conditions above this handler will only be called if the referenced
entity was actually read.
*/
typedef int (*XML_NotStandaloneHandler)(void *userData);
/* This is called for a reference to an external parsed general
entity. The referenced entity is not automatically parsed. The
application can parse it immediately or later using
XML_ExternalEntityParserCreate.
The parser argument is the parser parsing the entity containing the
reference; it can be passed as the parser argument to
XML_ExternalEntityParserCreate. The systemId argument is the
system identifier as specified in the entity declaration; it will
not be NULL.
The base argument is the system identifier that should be used as
the base for resolving systemId if systemId was relative; this is
set by XML_SetBase; it may be NULL.
The publicId argument is the public identifier as specified in the
entity declaration, or NULL if none was specified; the whitespace
in the public identifier will have been normalized as required by
the XML spec.
The context argument specifies the parsing context in the format
expected by the context argument to XML_ExternalEntityParserCreate;
context is valid only until the handler returns, so if the
referenced entity is to be parsed later, it must be copied.
context is NULL only when the entity is a parameter entity.
The handler should return XML_STATUS_ERROR if processing should not
continue because of a fatal error in the handling of the external
entity. In this case the calling parser will return an
XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
Note that unlike other handlers the first argument is the parser,
not userData.
*/
typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
/* This is called in two situations:
1) An entity reference is encountered for which no declaration
has been read *and* this is not an error.
2) An internal entity reference is read, but not expanded, because
XML_SetDefaultHandler has been called.
Note: skipped parameter entities in declarations and skipped general
entities in attribute values cannot be reported, because
the event would be out of sync with the reporting of the
declarations or attribute values
*/
typedef void (*XML_SkippedEntityHandler)(void *userData,
const XML_Char *entityName,
int is_parameter_entity);
/* This structure is filled in by the XML_UnknownEncodingHandler to
provide information to the parser about encodings that are unknown
to the parser.
The map[b] member gives information about byte sequences whose
first byte is b.
If map[b] is c where c is >= 0, then b by itself encodes the
Unicode scalar value c.
If map[b] is -1, then the byte sequence is malformed.
If map[b] is -n, where n >= 2, then b is the first byte of an
n-byte sequence that encodes a single Unicode scalar value.
The data member will be passed as the first argument to the convert
function.
The convert function is used to convert multibyte sequences; s will
point to a n-byte sequence where map[(unsigned char)*s] == -n. The
convert function must return the Unicode scalar value represented
by this byte sequence or -1 if the byte sequence is malformed.
The convert function may be NULL if the encoding is a single-byte
encoding, that is if map[b] >= -1 for all bytes b.
When the parser is finished with the encoding, then if release is
not NULL, it will call release passing it the data member; once
release has been called, the convert function will not be called
again.
Expat places certain restrictions on the encodings that are supported
using this mechanism.
1. Every ASCII character that can appear in a well-formed XML document,
other than the characters
$@\^`{}~
must be represented by a single byte, and that byte must be the
same byte that represents that character in ASCII.
2. No character may require more than 4 bytes to encode.
3. All characters encoded must have Unicode scalar values <=
0xFFFF, (i.e., characters that would be encoded by surrogates in
UTF-16 are not allowed). Note that this restriction doesn't
apply to the built-in support for UTF-8 and UTF-16.
4. No Unicode character may be encoded by more than one distinct
sequence of bytes.
*/
typedef struct {
int map[256];
void *data;
int (*convert)(void *data, const char *s);
void (*release)(void *data);
} XML_Encoding;
/* This is called for an encoding that is unknown to the parser.
The encodingHandlerData argument is that which was passed as the
second argument to XML_SetUnknownEncodingHandler.
The name argument gives the name of the encoding as specified in
the encoding declaration.
If the callback can provide information about the encoding, it must
fill in the XML_Encoding structure, and return XML_STATUS_OK.
Otherwise it must return XML_STATUS_ERROR.
If info does not describe a suitable encoding, then the parser will
return an XML_UNKNOWN_ENCODING error.
*/
typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
const XML_Char *name,
XML_Encoding *info);
void XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
XML_EndElementHandler end);
void XML_SetStartElementHandler(XML_Parser parser,
XML_StartElementHandler handler);
void XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
void XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler);
void XML_SetProcessingInstructionHandler(
XML_Parser parser, XML_ProcessingInstructionHandler handler);
void XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
void XML_SetCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end);
void XML_SetStartCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start);
void XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end);
/* This sets the default handler and also inhibits expansion of
internal entities. These entity references will be passed to the
default handler, or to the skipped entity handler, if one is set.
*/
void XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
/* This sets the default handler but does not inhibit expansion of
internal entities. The entity reference will not be passed to the
default handler.
*/
void XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
void XML_SetDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end);
void XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start);
void XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end);
void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler);
void XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler);
void XML_SetNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end);
void XML_SetStartNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start);
void XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end);
void XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler);
void XML_SetExternalEntityRefHandler(XML_Parser parser,
XML_ExternalEntityRefHandler handler);
/* If a non-NULL value for arg is specified here, then it will be
passed as the first argument to the external entity ref handler
instead of the parser object.
*/
void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
void XML_SetSkippedEntityHandler(XML_Parser parser,
XML_SkippedEntityHandler handler);
void XML_SetUnknownEncodingHandler(XML_Parser parser,
XML_UnknownEncodingHandler handler,
void *encodingHandlerData);
/* This can be called within a handler for a start element, end
element, processing instruction or character data. It causes the
corresponding markup to be passed to the default handler.
*/
void XML_DefaultCurrent(XML_Parser parser);
/* If do_nst is non-zero, and namespace processing is in effect, and
a name has a prefix (i.e. an explicit namespace qualifier) then
that name is returned as a triplet in a single string separated by
the separator character specified when the parser was created: URI
+ sep + local_name + sep + prefix.
If do_nst is zero, then namespace information is returned in the
default manner (URI + sep + local_name) whether or not the name
has a prefix.
Note: Calling XML_SetReturnNSTriplet after XML_Parse or
XML_ParseBuffer has no effect.
*/
void XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
/* This value is passed as the userData argument to callbacks. */
void XML_SetUserData(XML_Parser parser, void *userData);
/* Returns the last value set by XML_SetUserData or NULL. */
#define XML_GetUserData(parser) (*(void **)(parser))
/* This is equivalent to supplying an encoding argument to
XML_ParserCreate. On success XML_SetEncoding returns non-zero,
zero otherwise.
Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
has no effect and returns XML_STATUS_ERROR.
*/
enum XML_Status XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
/* If this function is called, then the parser will be passed as the
first argument to callbacks instead of userData. The userData will
still be accessible using XML_GetUserData.
*/
void XML_UseParserAsHandlerArg(XML_Parser parser);
/* If useDTD == XML_TRUE is passed to this function, then the parser
will assume that there is an external subset, even if none is
specified in the document. In such a case the parser will call the
externalEntityRefHandler with a value of NULL for the systemId
argument (the publicId and context arguments will be NULL as well).
Note: For the purpose of checking WFC: Entity Declared, passing
useDTD == XML_TRUE will make the parser behave as if the document
had a DTD with an external subset.
Note: If this function is called, then this must be done before
the first call to XML_Parse or XML_ParseBuffer, since it will
have no effect after that. Returns
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
Note: If the document does not have a DOCTYPE declaration at all,
then startDoctypeDeclHandler and endDoctypeDeclHandler will not
be called, despite an external subset being parsed.
Note: If XML_DTD is not defined when Expat is compiled, returns
XML_ERROR_FEATURE_REQUIRES_XML_DTD.
Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
*/
enum XML_Error XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
/* Sets the base to be used for resolving relative URIs in system
identifiers in declarations. Resolving relative identifiers is
left to the application: this value will be passed through as the
base argument to the XML_ExternalEntityRefHandler,
XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
argument will be copied. Returns XML_STATUS_ERROR if out of memory,
XML_STATUS_OK otherwise.
*/
enum XML_Status XML_SetBase(XML_Parser parser, const XML_Char *base);
const XML_Char *XML_GetBase(XML_Parser parser);
/* Returns the number of the attribute/value pairs passed in last call
to the XML_StartElementHandler that were specified in the start-tag
rather than defaulted. Each attribute/value pair counts as 2; thus
this correspondds to an index into the atts array passed to the
XML_StartElementHandler. Returns -1 if parser == NULL.
*/
int XML_GetSpecifiedAttributeCount(XML_Parser parser);
/* Returns the index of the ID attribute passed in the last call to
XML_StartElementHandler, or -1 if there is no ID attribute or
parser == NULL. Each attribute/value pair counts as 2; thus this
correspondds to an index into the atts array passed to the
XML_StartElementHandler.
*/
int XML_GetIdAttributeIndex(XML_Parser parser);
#ifdef XML_ATTR_INFO
/* Source file byte offsets for the start and end of attribute names and values.
The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
file an attribute value of "blah" will yield:
info->valueEnd - info->valueStart = 4 bytes.
*/
typedef struct {
XML_Index nameStart; /* Offset to beginning of the attribute name. */
XML_Index nameEnd; /* Offset after the attribute name's last byte. */
XML_Index valueStart; /* Offset to beginning of the attribute value. */
XML_Index valueEnd; /* Offset after the attribute value's last byte. */
} XML_AttrInfo;
/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
passed in last call to the XML_StartElementHandler that were specified
in the start-tag rather than defaulted. Each attribute/value pair counts
as 1; thus the number of entries in the array is
XML_GetSpecifiedAttributeCount(parser) / 2.
*/
const XML_AttrInfo *XML_GetAttributeInfo(XML_Parser parser);
#endif
/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
detected. The last call to XML_Parse must have isFinal true; len
may be zero for this call (or any other).
Though the return values for these functions has always been
described as a Boolean value, the implementation, at least for the
1.95.x series, has always returned exactly one of the XML_Status
values.
*/
enum XML_Status XML_Parse(XML_Parser parser, const char *s, int len,
int isFinal);
void *XML_GetBuffer(XML_Parser parser, int len);
enum XML_Status XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
Must be called from within a call-back handler, except when aborting
(resumable = 0) an already suspended parser. Some call-backs may
still follow because they would otherwise get lost. Examples:
- endElementHandler() for empty elements when stopped in
startElementHandler(),
- endNameSpaceDeclHandler() when stopped in endElementHandler(),
and possibly others.
Can be called from most handlers, including DTD related call-backs,
except when parsing an external parameter entity and resumable != 0.
Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
Possible error codes:
- XML_ERROR_SUSPENDED: when suspending an already suspended parser.
- XML_ERROR_FINISHED: when the parser has already finished.
- XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
When resumable != 0 (true) then parsing is suspended, that is,
XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
*Note*:
This will be applied to the current parser instance only, that is, if
there is a parent parser then it will continue parsing when the
externalEntityRefHandler() returns. It is up to the implementation of
the externalEntityRefHandler() to call XML_StopParser() on the parent
parser (recursively), if one wants to stop parsing altogether.
When suspended, parsing can be resumed by calling XML_ResumeParser().
*/
enum XML_Status XML_StopParser(XML_Parser parser, XML_Bool resumable);
/* Resumes parsing after it has been suspended with XML_StopParser().
Must not be called from within a handler call-back. Returns same
status codes as XML_Parse() or XML_ParseBuffer().
Additional error code XML_ERROR_NOT_SUSPENDED possible.
*Note*:
This must be called on the most deeply nested child parser instance
first, and on its parent parser only after the child parser has finished,
to be applied recursively until the document entity's parser is restarted.
That is, the parent parser will not resume by itself and it is up to the
application to call XML_ResumeParser() on it at the appropriate moment.
*/
enum XML_Status XML_ResumeParser(XML_Parser parser);
enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
typedef struct {
enum XML_Parsing parsing;
XML_Bool finalBuffer;
} XML_ParsingStatus;
/* Returns status of parser with respect to being initialized, parsing,
finished, or suspended and processing the final buffer.
XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
*/
void XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
/* Creates an XML_Parser object that can parse an external general
entity; context is a '\0'-terminated string specifying the parse
context; encoding is a '\0'-terminated string giving the name of
the externally specified encoding, or NULL if there is no
externally specified encoding. The context string consists of a
sequence of tokens separated by formfeeds (\f); a token consisting
of a name specifies that the general entity of the name is open; a
token of the form prefix=uri specifies the namespace for a
particular prefix; a token of the form =uri specifies the default
namespace. This can be called at any point after the first call to
an ExternalEntityRefHandler so longer as the parser has not yet
been freed. The new parser is completely independent and may
safely be used in a separate thread. The handlers and userData are
initialized from the parser argument. Returns NULL if out of memory.
Otherwise returns a new XML_Parser object.
*/
XML_Parser XML_ExternalEntityParserCreate(XML_Parser parser,
const XML_Char *context,
const XML_Char *encoding);
enum XML_ParamEntityParsing {
XML_PARAM_ENTITY_PARSING_NEVER,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
XML_PARAM_ENTITY_PARSING_ALWAYS
};
/* Controls parsing of parameter entities (including the external DTD
subset). If parsing of parameter entities is enabled, then
references to external parameter entities (including the external
DTD subset) will be passed to the handler set with
XML_SetExternalEntityRefHandler. The context passed will be 0.
Unlike external general entities, external parameter entities can
only be parsed synchronously. If the external parameter entity is
to be parsed, it must be parsed during the call to the external
entity ref handler: the complete sequence of
XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
XML_ParserFree calls must be made during this call. After
XML_ExternalEntityParserCreate has been called to create the parser
for the external parameter entity (context must be 0 for this
call), it is illegal to make any calls on the old parser until
XML_ParserFree has been called on the newly created parser.
If the library has been compiled without support for parameter
entity parsing (ie without XML_DTD being defined), then
XML_SetParamEntityParsing will return 0 if parsing of parameter
entities is requested; otherwise it will return non-zero.
Note: If XML_SetParamEntityParsing is called after XML_Parse or
XML_ParseBuffer, then it has no effect and will always return 0.
Note: If parser == NULL, the function will do nothing and return 0.
*/
int XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing parsing);
/* Sets the hash salt to use for internal hash calculations.
Helps in preventing DoS attacks based on predicting hash
function behavior. This must be called before parsing is started.
Returns 1 if successful, 0 when called after parsing has started.
Note: If parser == NULL, the function will do nothing and return 0.
*/
int XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
XML_GetErrorCode returns information about the error.
*/
enum XML_Error XML_GetErrorCode(XML_Parser parser);
/* These functions return information about the current parse
location. They may be called from any callback called to report
some parse event; in this case the location is the location of the
first of the sequence of characters that generated the event. When
called from callbacks generated by declarations in the document
prologue, the location identified isn't as neatly defined, but will
be within the relevant markup. When called outside of the callback
functions, the position indicated will be just past the last parse
event (regardless of whether there was an associated callback).
They may also be called after returning from a call to XML_Parse
or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then
the location is the location of the character at which the error
was detected; otherwise the location is the location of the last
parse event, as described above.
Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
return 0 to indicate an error.
Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
*/
XML_Size XML_GetCurrentLineNumber(XML_Parser parser);
XML_Size XML_GetCurrentColumnNumber(XML_Parser parser);
XML_Index XML_GetCurrentByteIndex(XML_Parser parser);
/* Return the number of bytes in the current event.
Returns 0 if the event is in an internal entity.
*/
int XML_GetCurrentByteCount(XML_Parser parser);
/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
the integer pointed to by offset to the offset within this buffer
of the current parse position, and sets the integer pointed to by size
to the size of this buffer (the number of input bytes). Otherwise
returns a NULL pointer. Also returns a NULL pointer if a parse isn't
active.
NOTE: The character pointer returned should not be used outside
the handler that makes the call.
*/
const char *XML_GetInputContext(XML_Parser parser, int *offset, int *size);
/* For backwards compatibility with previous versions. */
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
/* Frees the content model passed to the element declaration handler */
void XML_FreeContentModel(XML_Parser parser, XML_Content *model);
/* Exposing the memory handling functions used in Expat */
void *XML_ATTR_MALLOC XML_ATTR_ALLOC_SIZE(2)
XML_MemMalloc(XML_Parser parser, size_t size);
void *XML_ATTR_ALLOC_SIZE(3)
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
void XML_MemFree(XML_Parser parser, void *ptr);
/* Frees memory used by the parser. */
void XML_ParserFree(XML_Parser parser);
/* Returns a string describing the error. */
const XML_LChar *XML_ErrorString(enum XML_Error code);
/* Return a string containing the version number of this expat */
const XML_LChar *XML_ExpatVersion(void);
typedef struct {
int major;
int minor;
int micro;
} XML_Expat_Version;
/* Return an XML_Expat_Version structure containing numeric version
number information for this version of expat.
*/
XML_Expat_Version XML_ExpatVersionInfo(void);
/* Added in Expat 1.95.5. */
enum XML_FeatureEnum {
XML_FEATURE_END = 0,
XML_FEATURE_UNICODE,
XML_FEATURE_UNICODE_WCHAR_T,
XML_FEATURE_DTD,
XML_FEATURE_CONTEXT_BYTES,
XML_FEATURE_MIN_SIZE,
XML_FEATURE_SIZEOF_XML_CHAR,
XML_FEATURE_SIZEOF_XML_LCHAR,
XML_FEATURE_NS,
XML_FEATURE_LARGE_SIZE,
XML_FEATURE_ATTR_INFO
/* Additional features must be added to the end of this enum. */
};
typedef struct {
enum XML_FeatureEnum feature;
const XML_LChar *name;
long int value;
} XML_Feature;
const XML_Feature *XML_GetFeatureList(void);
/* Expat follows the semantic versioning convention.
See http://semver.org.
*/
#define XML_MAJOR_VERSION 2
#define XML_MINOR_VERSION 2
#define XML_MICRO_VERSION 8
COSMOPOLITAN_C_END_
#endif /* not Expat_INCLUDED */
| 39,038 | 926 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/ascii.inc | /* clang-format off */
#define ASCII_A 0x41
#define ASCII_B 0x42
#define ASCII_C 0x43
#define ASCII_D 0x44
#define ASCII_E 0x45
#define ASCII_F 0x46
#define ASCII_G 0x47
#define ASCII_H 0x48
#define ASCII_I 0x49
#define ASCII_J 0x4A
#define ASCII_K 0x4B
#define ASCII_L 0x4C
#define ASCII_M 0x4D
#define ASCII_N 0x4E
#define ASCII_O 0x4F
#define ASCII_P 0x50
#define ASCII_Q 0x51
#define ASCII_R 0x52
#define ASCII_S 0x53
#define ASCII_T 0x54
#define ASCII_U 0x55
#define ASCII_V 0x56
#define ASCII_W 0x57
#define ASCII_X 0x58
#define ASCII_Y 0x59
#define ASCII_Z 0x5A
#define ASCII_a 0x61
#define ASCII_b 0x62
#define ASCII_c 0x63
#define ASCII_d 0x64
#define ASCII_e 0x65
#define ASCII_f 0x66
#define ASCII_g 0x67
#define ASCII_h 0x68
#define ASCII_i 0x69
#define ASCII_j 0x6A
#define ASCII_k 0x6B
#define ASCII_l 0x6C
#define ASCII_m 0x6D
#define ASCII_n 0x6E
#define ASCII_o 0x6F
#define ASCII_p 0x70
#define ASCII_q 0x71
#define ASCII_r 0x72
#define ASCII_s 0x73
#define ASCII_t 0x74
#define ASCII_u 0x75
#define ASCII_v 0x76
#define ASCII_w 0x77
#define ASCII_x 0x78
#define ASCII_y 0x79
#define ASCII_z 0x7A
#define ASCII_0 0x30
#define ASCII_1 0x31
#define ASCII_2 0x32
#define ASCII_3 0x33
#define ASCII_4 0x34
#define ASCII_5 0x35
#define ASCII_6 0x36
#define ASCII_7 0x37
#define ASCII_8 0x38
#define ASCII_9 0x39
#define ASCII_TAB 0x09
#define ASCII_SPACE 0x20
#define ASCII_EXCL 0x21
#define ASCII_QUOT 0x22
#define ASCII_AMP 0x26
#define ASCII_APOS 0x27
#define ASCII_MINUS 0x2D
#define ASCII_PERIOD 0x2E
#define ASCII_COLON 0x3A
#define ASCII_SEMI 0x3B
#define ASCII_LT 0x3C
#define ASCII_EQUALS 0x3D
#define ASCII_GT 0x3E
#define ASCII_LSQB 0x5B
#define ASCII_RSQB 0x5D
#define ASCII_UNDERSCORE 0x5F
#define ASCII_LPAREN 0x28
#define ASCII_RPAREN 0x29
#define ASCII_FF 0x0C
#define ASCII_SLASH 0x2F
#define ASCII_HASH 0x23
#define ASCII_PIPE 0x7C
#define ASCII_COMMA 0x2C
| 2,019 | 91 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/COPYING | Copyright (c) 1998-2000 Thai Open Source Software Center Ltd and Clark Cooper
Copyright (c) 2001-2017 Expat maintainers
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
| 1,144 | 22 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/expat_external.h | #ifndef Expat_External_INCLUDED
#define Expat_External_INCLUDED 1
#include "third_party/python/Modules/expat/pyexpatns.h"
COSMOPOLITAN_C_START_
/* clang-format off */
#if defined(__GNUC__) \
&& (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
# define XML_ATTR_MALLOC __attribute__((__malloc__))
#else
# define XML_ATTR_MALLOC
#endif
#if defined(__GNUC__) \
&& ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
# define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
#else
# define XML_ATTR_ALLOC_SIZE(x)
#endif
typedef char XML_Char;
typedef char XML_LChar;
typedef long long XML_Index;
typedef unsigned long long XML_Size;
COSMOPOLITAN_C_END_
#endif /* not Expat_External_INCLUDED */
| 846 | 29 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/pyexpatns.h | #ifndef PYEXPATNS_H
#define PYEXPATNS_H
/* clang-format off */
#define XML_DefaultCurrent PyExpat_XML_DefaultCurrent
#define XML_ErrorString PyExpat_XML_ErrorString
#define XML_ExpatVersion PyExpat_XML_ExpatVersion
#define XML_ExpatVersionInfo PyExpat_XML_ExpatVersionInfo
#define XML_ExternalEntityParserCreate PyExpat_XML_ExternalEntityParserCreate
#define XML_FreeContentModel PyExpat_XML_FreeContentModel
#define XML_GetBase PyExpat_XML_GetBase
#define XML_GetBuffer PyExpat_XML_GetBuffer
#define XML_GetCurrentByteCount PyExpat_XML_GetCurrentByteCount
#define XML_GetCurrentByteIndex PyExpat_XML_GetCurrentByteIndex
#define XML_GetCurrentColumnNumber PyExpat_XML_GetCurrentColumnNumber
#define XML_GetCurrentLineNumber PyExpat_XML_GetCurrentLineNumber
#define XML_GetErrorCode PyExpat_XML_GetErrorCode
#define XML_GetFeatureList PyExpat_XML_GetFeatureList
#define XML_GetIdAttributeIndex PyExpat_XML_GetIdAttributeIndex
#define XML_GetInputContext PyExpat_XML_GetInputContext
#define XML_GetParsingStatus PyExpat_XML_GetParsingStatus
#define XML_GetSpecifiedAttributeCount PyExpat_XML_GetSpecifiedAttributeCount
#define XmlGetUtf16InternalEncoding PyExpat_XmlGetUtf16InternalEncoding
#define XmlGetUtf16InternalEncodingNS PyExpat_XmlGetUtf16InternalEncodingNS
#define XmlGetUtf8InternalEncoding PyExpat_XmlGetUtf8InternalEncoding
#define XmlGetUtf8InternalEncodingNS PyExpat_XmlGetUtf8InternalEncodingNS
#define XmlInitEncoding PyExpat_XmlInitEncoding
#define XmlInitEncodingNS PyExpat_XmlInitEncodingNS
#define XmlInitUnknownEncoding PyExpat_XmlInitUnknownEncoding
#define XmlInitUnknownEncodingNS PyExpat_XmlInitUnknownEncodingNS
#define XML_MemFree PyExpat_XML_MemFree
#define XML_MemMalloc PyExpat_XML_MemMalloc
#define XML_MemRealloc PyExpat_XML_MemRealloc
#define XML_Parse PyExpat_XML_Parse
#define XML_ParseBuffer PyExpat_XML_ParseBuffer
#define XML_ParserCreate PyExpat_XML_ParserCreate
#define XML_ParserCreate_MM PyExpat_XML_ParserCreate_MM
#define XML_ParserCreateNS PyExpat_XML_ParserCreateNS
#define XML_ParserFree PyExpat_XML_ParserFree
#define XML_ParserReset PyExpat_XML_ParserReset
#define XmlParseXmlDecl PyExpat_XmlParseXmlDecl
#define XmlParseXmlDeclNS PyExpat_XmlParseXmlDeclNS
#define XmlPrologStateInit PyExpat_XmlPrologStateInit
#define XmlPrologStateInitExternalEntity PyExpat_XmlPrologStateInitExternalEntity
#define XML_ResumeParser PyExpat_XML_ResumeParser
#define XML_SetAttlistDeclHandler PyExpat_XML_SetAttlistDeclHandler
#define XML_SetBase PyExpat_XML_SetBase
#define XML_SetCdataSectionHandler PyExpat_XML_SetCdataSectionHandler
#define XML_SetCharacterDataHandler PyExpat_XML_SetCharacterDataHandler
#define XML_SetCommentHandler PyExpat_XML_SetCommentHandler
#define XML_SetDefaultHandler PyExpat_XML_SetDefaultHandler
#define XML_SetDefaultHandlerExpand PyExpat_XML_SetDefaultHandlerExpand
#define XML_SetDoctypeDeclHandler PyExpat_XML_SetDoctypeDeclHandler
#define XML_SetElementDeclHandler PyExpat_XML_SetElementDeclHandler
#define XML_SetElementHandler PyExpat_XML_SetElementHandler
#define XML_SetEncoding PyExpat_XML_SetEncoding
#define XML_SetEndCdataSectionHandler PyExpat_XML_SetEndCdataSectionHandler
#define XML_SetEndDoctypeDeclHandler PyExpat_XML_SetEndDoctypeDeclHandler
#define XML_SetEndElementHandler PyExpat_XML_SetEndElementHandler
#define XML_SetEndNamespaceDeclHandler PyExpat_XML_SetEndNamespaceDeclHandler
#define XML_SetEntityDeclHandler PyExpat_XML_SetEntityDeclHandler
#define XML_SetExternalEntityRefHandler PyExpat_XML_SetExternalEntityRefHandler
#define XML_SetExternalEntityRefHandlerArg PyExpat_XML_SetExternalEntityRefHandlerArg
#define XML_SetHashSalt PyExpat_XML_SetHashSalt
#define XML_SetNamespaceDeclHandler PyExpat_XML_SetNamespaceDeclHandler
#define XML_SetNotationDeclHandler PyExpat_XML_SetNotationDeclHandler
#define XML_SetNotStandaloneHandler PyExpat_XML_SetNotStandaloneHandler
#define XML_SetParamEntityParsing PyExpat_XML_SetParamEntityParsing
#define XML_SetProcessingInstructionHandler PyExpat_XML_SetProcessingInstructionHandler
#define XML_SetReturnNSTriplet PyExpat_XML_SetReturnNSTriplet
#define XML_SetSkippedEntityHandler PyExpat_XML_SetSkippedEntityHandler
#define XML_SetStartCdataSectionHandler PyExpat_XML_SetStartCdataSectionHandler
#define XML_SetStartDoctypeDeclHandler PyExpat_XML_SetStartDoctypeDeclHandler
#define XML_SetStartElementHandler PyExpat_XML_SetStartElementHandler
#define XML_SetStartNamespaceDeclHandler PyExpat_XML_SetStartNamespaceDeclHandler
#define XML_SetUnknownEncodingHandler PyExpat_XML_SetUnknownEncodingHandler
#define XML_SetUnparsedEntityDeclHandler PyExpat_XML_SetUnparsedEntityDeclHandler
#define XML_SetUserData PyExpat_XML_SetUserData
#define XML_SetXmlDeclHandler PyExpat_XML_SetXmlDeclHandler
#define XmlSizeOfUnknownEncoding PyExpat_XmlSizeOfUnknownEncoding
#define XML_StopParser PyExpat_XML_StopParser
#define XML_UseForeignDTD PyExpat_XML_UseForeignDTD
#define XML_UseParserAsHandlerArg PyExpat_XML_UseParserAsHandlerArg
#define XmlUtf16Encode PyExpat_XmlUtf16Encode
#define XmlUtf8Encode PyExpat_XmlUtf8Encode
#endif /* !PYEXPATNS_H */
| 5,846 | 88 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmlrole.h | #ifndef XmlRole_INCLUDED
#define XmlRole_INCLUDED 1
#include "third_party/python/Modules/expat/xmltok.h"
COSMOPOLITAN_C_START_
/* clang-format off */
enum {
XML_ROLE_ERROR = -1,
XML_ROLE_NONE = 0,
XML_ROLE_XML_DECL,
XML_ROLE_INSTANCE_START,
XML_ROLE_DOCTYPE_NONE,
XML_ROLE_DOCTYPE_NAME,
XML_ROLE_DOCTYPE_SYSTEM_ID,
XML_ROLE_DOCTYPE_PUBLIC_ID,
XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
XML_ROLE_DOCTYPE_CLOSE,
XML_ROLE_GENERAL_ENTITY_NAME,
XML_ROLE_PARAM_ENTITY_NAME,
XML_ROLE_ENTITY_NONE,
XML_ROLE_ENTITY_VALUE,
XML_ROLE_ENTITY_SYSTEM_ID,
XML_ROLE_ENTITY_PUBLIC_ID,
XML_ROLE_ENTITY_COMPLETE,
XML_ROLE_ENTITY_NOTATION_NAME,
XML_ROLE_NOTATION_NONE,
XML_ROLE_NOTATION_NAME,
XML_ROLE_NOTATION_SYSTEM_ID,
XML_ROLE_NOTATION_NO_SYSTEM_ID,
XML_ROLE_NOTATION_PUBLIC_ID,
XML_ROLE_ATTRIBUTE_NAME,
XML_ROLE_ATTRIBUTE_TYPE_CDATA,
XML_ROLE_ATTRIBUTE_TYPE_ID,
XML_ROLE_ATTRIBUTE_TYPE_IDREF,
XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
XML_ROLE_ATTRIBUTE_ENUM_VALUE,
XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
XML_ROLE_ATTLIST_NONE,
XML_ROLE_ATTLIST_ELEMENT_NAME,
XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
XML_ROLE_FIXED_ATTRIBUTE_VALUE,
XML_ROLE_ELEMENT_NONE,
XML_ROLE_ELEMENT_NAME,
XML_ROLE_CONTENT_ANY,
XML_ROLE_CONTENT_EMPTY,
XML_ROLE_CONTENT_PCDATA,
XML_ROLE_GROUP_OPEN,
XML_ROLE_GROUP_CLOSE,
XML_ROLE_GROUP_CLOSE_REP,
XML_ROLE_GROUP_CLOSE_OPT,
XML_ROLE_GROUP_CLOSE_PLUS,
XML_ROLE_GROUP_CHOICE,
XML_ROLE_GROUP_SEQUENCE,
XML_ROLE_CONTENT_ELEMENT,
XML_ROLE_CONTENT_ELEMENT_REP,
XML_ROLE_CONTENT_ELEMENT_OPT,
XML_ROLE_CONTENT_ELEMENT_PLUS,
XML_ROLE_PI,
XML_ROLE_COMMENT,
#ifdef XML_DTD
XML_ROLE_TEXT_DECL,
XML_ROLE_IGNORE_SECT,
XML_ROLE_INNER_PARAM_ENTITY_REF,
#endif /* XML_DTD */
XML_ROLE_PARAM_ENTITY_REF
};
typedef struct prolog_state {
int(*handler)(struct prolog_state *state, int tok, const char *ptr,
const char *end, const ENCODING *enc);
unsigned level;
int role_none;
#ifdef XML_DTD
unsigned includeLevel;
int documentEntity;
int inEntityValue;
#endif /* XML_DTD */
} PROLOG_STATE;
void XmlPrologStateInit(PROLOG_STATE *);
#ifdef XML_DTD
void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
#endif /* XML_DTD */
#define XmlTokenRole(state, tok, ptr, end, enc) \
(((state)->handler)(state, tok, ptr, end, enc))
COSMOPOLITAN_C_END_
#endif /* not XmlRole_INCLUDED */
| 2,619 | 96 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmlrole.c | /* clang-format off */
/*
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
asm(".ident\t\"\\n\\n\
expat (MIT License)\\n\
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd\\n\
Copyright (c) 2000-2017 Expat development team\"");
asm(".include \"libc/disclaimer.inc\"");
#include "third_party/python/Modules/expat/expat_config.h"
#include "third_party/python/Modules/expat/expat_external.h"
#include "third_party/python/Modules/expat/internal.inc"
#include "third_party/python/Modules/expat/xmlrole.h"
#include "third_party/python/Modules/expat/ascii.inc"
/* Doesn't check:
that ,| are not mixed in a model group
content of literals
*/
static const char KW_ANY[] = {ASCII_A, ASCII_N, ASCII_Y, '\0'};
static const char KW_ATTLIST[]
= {ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0'};
static const char KW_CDATA[]
= {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
static const char KW_DOCTYPE[]
= {ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0'};
static const char KW_ELEMENT[]
= {ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0'};
static const char KW_EMPTY[]
= {ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0'};
static const char KW_ENTITIES[] = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
ASCII_I, ASCII_E, ASCII_S, '\0'};
static const char KW_ENTITY[]
= {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
static const char KW_FIXED[]
= {ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0'};
static const char KW_ID[] = {ASCII_I, ASCII_D, '\0'};
static const char KW_IDREF[]
= {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
static const char KW_IDREFS[]
= {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
#ifdef XML_DTD
static const char KW_IGNORE[]
= {ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0'};
#endif
static const char KW_IMPLIED[]
= {ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0'};
#ifdef XML_DTD
static const char KW_INCLUDE[]
= {ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0'};
#endif
static const char KW_NDATA[]
= {ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
static const char KW_NMTOKEN[]
= {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
static const char KW_NMTOKENS[] = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
ASCII_E, ASCII_N, ASCII_S, '\0'};
static const char KW_NOTATION[] = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T,
ASCII_I, ASCII_O, ASCII_N, '\0'};
static const char KW_PCDATA[]
= {ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
static const char KW_PUBLIC[]
= {ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0'};
static const char KW_REQUIRED[] = {ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I,
ASCII_R, ASCII_E, ASCII_D, '\0'};
static const char KW_SYSTEM[]
= {ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0'};
#ifndef MIN_BYTES_PER_CHAR
# define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
#endif
#ifdef XML_DTD
# define setTopLevel(state) \
((state)->handler \
= ((state)->documentEntity ? internalSubset : externalSubset1))
#else /* not XML_DTD */
# define setTopLevel(state) ((state)->handler = internalSubset)
#endif /* not XML_DTD */
typedef int PROLOG_HANDLER(PROLOG_STATE *state, int tok,
const char *ptr, const char *end,
const ENCODING *enc);
static PROLOG_HANDLER prolog0, prolog1, prolog2, doctype0, doctype1, doctype2,
doctype3, doctype4, doctype5, internalSubset, entity0, entity1, entity2,
entity3, entity4, entity5, entity6, entity7, entity8, entity9, entity10,
notation0, notation1, notation2, notation3, notation4, attlist0, attlist1,
attlist2, attlist3, attlist4, attlist5, attlist6, attlist7, attlist8,
attlist9, element0, element1, element2, element3, element4, element5,
element6, element7,
#ifdef XML_DTD
externalSubset0, externalSubset1, condSect0, condSect1, condSect2,
#endif /* XML_DTD */
declClose, error;
static int common(PROLOG_STATE *state, int tok);
static int
prolog0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
state->handler = prolog1;
return XML_ROLE_NONE;
case XML_TOK_XML_DECL:
state->handler = prolog1;
return XML_ROLE_XML_DECL;
case XML_TOK_PI:
state->handler = prolog1;
return XML_ROLE_PI;
case XML_TOK_COMMENT:
state->handler = prolog1;
return XML_ROLE_COMMENT;
case XML_TOK_BOM:
return XML_ROLE_NONE;
case XML_TOK_DECL_OPEN:
if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_DOCTYPE))
break;
state->handler = doctype0;
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_INSTANCE_START:
state->handler = error;
return XML_ROLE_INSTANCE_START;
}
return common(state, tok);
}
static int
prolog1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_PI:
return XML_ROLE_PI;
case XML_TOK_COMMENT:
return XML_ROLE_COMMENT;
case XML_TOK_BOM:
/* This case can never arise. To reach this role function, the
* parse must have passed through prolog0 and therefore have had
* some form of input, even if only a space. At that point, a
* byte order mark is no longer a valid character (though
* technically it should be interpreted as a non-breaking space),
* so will be rejected by the tokenizing stages.
*/
return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
case XML_TOK_DECL_OPEN:
if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_DOCTYPE))
break;
state->handler = doctype0;
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_INSTANCE_START:
state->handler = error;
return XML_ROLE_INSTANCE_START;
}
return common(state, tok);
}
static int
prolog2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_PI:
return XML_ROLE_PI;
case XML_TOK_COMMENT:
return XML_ROLE_COMMENT;
case XML_TOK_INSTANCE_START:
state->handler = error;
return XML_ROLE_INSTANCE_START;
}
return common(state, tok);
}
static int
doctype0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = doctype1;
return XML_ROLE_DOCTYPE_NAME;
}
return common(state, tok);
}
static int
doctype1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_OPEN_BRACKET:
state->handler = internalSubset;
return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
case XML_TOK_DECL_CLOSE:
state->handler = prolog2;
return XML_ROLE_DOCTYPE_CLOSE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
state->handler = doctype3;
return XML_ROLE_DOCTYPE_NONE;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
state->handler = doctype2;
return XML_ROLE_DOCTYPE_NONE;
}
break;
}
return common(state, tok);
}
static int
doctype2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_LITERAL:
state->handler = doctype3;
return XML_ROLE_DOCTYPE_PUBLIC_ID;
}
return common(state, tok);
}
static int
doctype3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_LITERAL:
state->handler = doctype4;
return XML_ROLE_DOCTYPE_SYSTEM_ID;
}
return common(state, tok);
}
static int
doctype4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_OPEN_BRACKET:
state->handler = internalSubset;
return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
case XML_TOK_DECL_CLOSE:
state->handler = prolog2;
return XML_ROLE_DOCTYPE_CLOSE;
}
return common(state, tok);
}
static int
doctype5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_DECL_CLOSE:
state->handler = prolog2;
return XML_ROLE_DOCTYPE_CLOSE;
}
return common(state, tok);
}
static int
internalSubset(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_DECL_OPEN:
if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_ENTITY)) {
state->handler = entity0;
return XML_ROLE_ENTITY_NONE;
}
if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_ATTLIST)) {
state->handler = attlist0;
return XML_ROLE_ATTLIST_NONE;
}
if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_ELEMENT)) {
state->handler = element0;
return XML_ROLE_ELEMENT_NONE;
}
if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
KW_NOTATION)) {
state->handler = notation0;
return XML_ROLE_NOTATION_NONE;
}
break;
case XML_TOK_PI:
return XML_ROLE_PI;
case XML_TOK_COMMENT:
return XML_ROLE_COMMENT;
case XML_TOK_PARAM_ENTITY_REF:
return XML_ROLE_PARAM_ENTITY_REF;
case XML_TOK_CLOSE_BRACKET:
state->handler = doctype5;
return XML_ROLE_DOCTYPE_NONE;
case XML_TOK_NONE:
return XML_ROLE_NONE;
}
return common(state, tok);
}
#ifdef XML_DTD
static int
externalSubset0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
state->handler = externalSubset1;
if (tok == XML_TOK_XML_DECL)
return XML_ROLE_TEXT_DECL;
return externalSubset1(state, tok, ptr, end, enc);
}
static int
externalSubset1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_COND_SECT_OPEN:
state->handler = condSect0;
return XML_ROLE_NONE;
case XML_TOK_COND_SECT_CLOSE:
if (state->includeLevel == 0)
break;
state->includeLevel -= 1;
return XML_ROLE_NONE;
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_CLOSE_BRACKET:
break;
case XML_TOK_NONE:
if (state->includeLevel)
break;
return XML_ROLE_NONE;
default:
return internalSubset(state, tok, ptr, end, enc);
}
return common(state, tok);
}
#endif /* XML_DTD */
static int
entity0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_PERCENT:
state->handler = entity1;
return XML_ROLE_ENTITY_NONE;
case XML_TOK_NAME:
state->handler = entity2;
return XML_ROLE_GENERAL_ENTITY_NAME;
}
return common(state, tok);
}
static int
entity1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_NAME:
state->handler = entity7;
return XML_ROLE_PARAM_ENTITY_NAME;
}
return common(state, tok);
}
static int
entity2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
state->handler = entity4;
return XML_ROLE_ENTITY_NONE;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
state->handler = entity3;
return XML_ROLE_ENTITY_NONE;
}
break;
case XML_TOK_LITERAL:
state->handler = declClose;
state->role_none = XML_ROLE_ENTITY_NONE;
return XML_ROLE_ENTITY_VALUE;
}
return common(state, tok);
}
static int
entity3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_LITERAL:
state->handler = entity4;
return XML_ROLE_ENTITY_PUBLIC_ID;
}
return common(state, tok);
}
static int
entity4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_LITERAL:
state->handler = entity5;
return XML_ROLE_ENTITY_SYSTEM_ID;
}
return common(state, tok);
}
static int
entity5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return XML_ROLE_ENTITY_COMPLETE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
state->handler = entity6;
return XML_ROLE_ENTITY_NONE;
}
break;
}
return common(state, tok);
}
static int
entity6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_NAME:
state->handler = declClose;
state->role_none = XML_ROLE_ENTITY_NONE;
return XML_ROLE_ENTITY_NOTATION_NAME;
}
return common(state, tok);
}
static int
entity7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
state->handler = entity9;
return XML_ROLE_ENTITY_NONE;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
state->handler = entity8;
return XML_ROLE_ENTITY_NONE;
}
break;
case XML_TOK_LITERAL:
state->handler = declClose;
state->role_none = XML_ROLE_ENTITY_NONE;
return XML_ROLE_ENTITY_VALUE;
}
return common(state, tok);
}
static int
entity8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_LITERAL:
state->handler = entity9;
return XML_ROLE_ENTITY_PUBLIC_ID;
}
return common(state, tok);
}
static int
entity9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_LITERAL:
state->handler = entity10;
return XML_ROLE_ENTITY_SYSTEM_ID;
}
return common(state, tok);
}
static int
entity10(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ENTITY_NONE;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return XML_ROLE_ENTITY_COMPLETE;
}
return common(state, tok);
}
static int
notation0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NOTATION_NONE;
case XML_TOK_NAME:
state->handler = notation1;
return XML_ROLE_NOTATION_NAME;
}
return common(state, tok);
}
static int
notation1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NOTATION_NONE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
state->handler = notation3;
return XML_ROLE_NOTATION_NONE;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
state->handler = notation2;
return XML_ROLE_NOTATION_NONE;
}
break;
}
return common(state, tok);
}
static int
notation2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NOTATION_NONE;
case XML_TOK_LITERAL:
state->handler = notation4;
return XML_ROLE_NOTATION_PUBLIC_ID;
}
return common(state, tok);
}
static int
notation3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NOTATION_NONE;
case XML_TOK_LITERAL:
state->handler = declClose;
state->role_none = XML_ROLE_NOTATION_NONE;
return XML_ROLE_NOTATION_SYSTEM_ID;
}
return common(state, tok);
}
static int
notation4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NOTATION_NONE;
case XML_TOK_LITERAL:
state->handler = declClose;
state->role_none = XML_ROLE_NOTATION_NONE;
return XML_ROLE_NOTATION_SYSTEM_ID;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return XML_ROLE_NOTATION_NO_SYSTEM_ID;
}
return common(state, tok);
}
static int
attlist0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = attlist1;
return XML_ROLE_ATTLIST_ELEMENT_NAME;
}
return common(state, tok);
}
static int
attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = attlist2;
return XML_ROLE_ATTRIBUTE_NAME;
}
return common(state, tok);
}
static int
attlist2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NAME: {
static const char *const types[] = {
KW_CDATA, KW_ID, KW_IDREF, KW_IDREFS,
KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS,
};
int i;
for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++)
if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
state->handler = attlist8;
return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
}
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
state->handler = attlist5;
return XML_ROLE_ATTLIST_NONE;
}
break;
case XML_TOK_OPEN_PAREN:
state->handler = attlist3;
return XML_ROLE_ATTLIST_NONE;
}
return common(state, tok);
}
static int
attlist3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NMTOKEN:
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = attlist4;
return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
}
return common(state, tok);
}
static int
attlist4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_CLOSE_PAREN:
state->handler = attlist8;
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_OR:
state->handler = attlist3;
return XML_ROLE_ATTLIST_NONE;
}
return common(state, tok);
}
static int
attlist5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_OPEN_PAREN:
state->handler = attlist6;
return XML_ROLE_ATTLIST_NONE;
}
return common(state, tok);
}
static int
attlist6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NAME:
state->handler = attlist7;
return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
}
return common(state, tok);
}
static int
attlist7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_CLOSE_PAREN:
state->handler = attlist8;
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_OR:
state->handler = attlist6;
return XML_ROLE_ATTLIST_NONE;
}
return common(state, tok);
}
/* default value */
static int
attlist8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_POUND_NAME:
if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
KW_IMPLIED)) {
state->handler = attlist1;
return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
}
if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
KW_REQUIRED)) {
state->handler = attlist1;
return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
}
if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
KW_FIXED)) {
state->handler = attlist9;
return XML_ROLE_ATTLIST_NONE;
}
break;
case XML_TOK_LITERAL:
state->handler = attlist1;
return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
}
return common(state, tok);
}
static int
attlist9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_LITERAL:
state->handler = attlist1;
return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
}
return common(state, tok);
}
static int
element0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = element1;
return XML_ROLE_ELEMENT_NAME;
}
return common(state, tok);
}
static int
element1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
return XML_ROLE_CONTENT_EMPTY;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
return XML_ROLE_CONTENT_ANY;
}
break;
case XML_TOK_OPEN_PAREN:
state->handler = element2;
state->level = 1;
return XML_ROLE_GROUP_OPEN;
}
return common(state, tok);
}
static int
element2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_POUND_NAME:
if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
KW_PCDATA)) {
state->handler = element3;
return XML_ROLE_CONTENT_PCDATA;
}
break;
case XML_TOK_OPEN_PAREN:
state->level = 2;
state->handler = element6;
return XML_ROLE_GROUP_OPEN;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT;
case XML_TOK_NAME_QUESTION:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_OPT;
case XML_TOK_NAME_ASTERISK:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_REP;
case XML_TOK_NAME_PLUS:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_PLUS;
}
return common(state, tok);
}
static int
element3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_CLOSE_PAREN:
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
return XML_ROLE_GROUP_CLOSE;
case XML_TOK_CLOSE_PAREN_ASTERISK:
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
return XML_ROLE_GROUP_CLOSE_REP;
case XML_TOK_OR:
state->handler = element4;
return XML_ROLE_ELEMENT_NONE;
}
return common(state, tok);
}
static int
element4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = element5;
return XML_ROLE_CONTENT_ELEMENT;
}
return common(state, tok);
}
static int
element5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_CLOSE_PAREN_ASTERISK:
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
return XML_ROLE_GROUP_CLOSE_REP;
case XML_TOK_OR:
state->handler = element4;
return XML_ROLE_ELEMENT_NONE;
}
return common(state, tok);
}
static int
element6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_OPEN_PAREN:
state->level += 1;
return XML_ROLE_GROUP_OPEN;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT;
case XML_TOK_NAME_QUESTION:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_OPT;
case XML_TOK_NAME_ASTERISK:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_REP;
case XML_TOK_NAME_PLUS:
state->handler = element7;
return XML_ROLE_CONTENT_ELEMENT_PLUS;
}
return common(state, tok);
}
static int
element7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ELEMENT_NONE;
case XML_TOK_CLOSE_PAREN:
state->level -= 1;
if (state->level == 0) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
}
return XML_ROLE_GROUP_CLOSE;
case XML_TOK_CLOSE_PAREN_ASTERISK:
state->level -= 1;
if (state->level == 0) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
}
return XML_ROLE_GROUP_CLOSE_REP;
case XML_TOK_CLOSE_PAREN_QUESTION:
state->level -= 1;
if (state->level == 0) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
}
return XML_ROLE_GROUP_CLOSE_OPT;
case XML_TOK_CLOSE_PAREN_PLUS:
state->level -= 1;
if (state->level == 0) {
state->handler = declClose;
state->role_none = XML_ROLE_ELEMENT_NONE;
}
return XML_ROLE_GROUP_CLOSE_PLUS;
case XML_TOK_COMMA:
state->handler = element6;
return XML_ROLE_GROUP_SEQUENCE;
case XML_TOK_OR:
state->handler = element6;
return XML_ROLE_GROUP_CHOICE;
}
return common(state, tok);
}
#ifdef XML_DTD
static int
condSect0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
state->handler = condSect1;
return XML_ROLE_NONE;
}
if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
state->handler = condSect2;
return XML_ROLE_NONE;
}
break;
}
return common(state, tok);
}
static int
condSect1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_OPEN_BRACKET:
state->handler = externalSubset1;
state->includeLevel += 1;
return XML_ROLE_NONE;
}
return common(state, tok);
}
static int
condSect2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_OPEN_BRACKET:
state->handler = externalSubset1;
return XML_ROLE_IGNORE_SECT;
}
return common(state, tok);
}
#endif /* XML_DTD */
static int
declClose(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return state->role_none;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return state->role_none;
}
return common(state, tok);
}
/* This function will only be invoked if the internal logic of the
* parser has broken down. It is used in two cases:
*
* 1: When the XML prolog has been finished. At this point the
* processor (the parser level above these role handlers) should
* switch from prologProcessor to contentProcessor and reinitialise
* the handler function.
*
* 2: When an error has been detected (via common() below). At this
* point again the processor should be switched to errorProcessor,
* which will never call a handler.
*
* The result of this is that error() can only be called if the
* processor switch failed to happen, which is an internal error and
* therefore we shouldn't be able to provoke it simply by using the
* library. It is a necessary backstop, however, so we merely exclude
* it from the coverage statistics.
*
* LCOV_EXCL_START
*/
static int
error(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(state);
UNUSED_P(tok);
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
return XML_ROLE_NONE;
}
/* LCOV_EXCL_STOP */
static int
common(PROLOG_STATE *state, int tok) {
#ifdef XML_DTD
if (! state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
return XML_ROLE_INNER_PARAM_ENTITY_REF;
#endif
state->handler = error;
return XML_ROLE_ERROR;
}
void
XmlPrologStateInit(PROLOG_STATE *state) {
state->handler = prolog0;
#ifdef XML_DTD
state->documentEntity = 1;
state->includeLevel = 0;
state->inEntityValue = 0;
#endif /* XML_DTD */
}
#ifdef XML_DTD
void
XmlPrologStateInitExternalEntity(PROLOG_STATE *state) {
state->handler = externalSubset0;
state->documentEntity = 0;
state->includeLevel = 0;
}
#endif /* XML_DTD */
| 34,778 | 1,246 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/xmltok_impl.inc | /* clang-format off */
/* This file is included!
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifdef XML_TOK_IMPL_C
# ifndef IS_INVALID_CHAR
# define IS_INVALID_CHAR(enc, ptr, n) (0)
# endif
# define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
case BT_LEAD##n: \
if (end - ptr < n) \
return XML_TOK_PARTIAL_CHAR; \
if (IS_INVALID_CHAR(enc, ptr, n)) { \
*(nextTokPtr) = (ptr); \
return XML_TOK_INVALID; \
} \
ptr += n; \
break;
# define INVALID_CASES(ptr, nextTokPtr) \
INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
case BT_NONXML: \
case BT_MALFORM: \
case BT_TRAIL: \
*(nextTokPtr) = (ptr); \
return XML_TOK_INVALID;
# define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
case BT_LEAD##n: \
if (end - ptr < n) \
return XML_TOK_PARTIAL_CHAR; \
if (! IS_NAME_CHAR(enc, ptr, n)) { \
*nextTokPtr = ptr; \
return XML_TOK_INVALID; \
} \
ptr += n; \
break;
# define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
case BT_NONASCII: \
if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \
*nextTokPtr = ptr; \
return XML_TOK_INVALID; \
} \
/* fall through */ \
case BT_NMSTRT: \
case BT_HEX: \
case BT_DIGIT: \
case BT_NAME: \
case BT_MINUS: \
ptr += MINBPC(enc); \
break; \
CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
# define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
case BT_LEAD##n: \
if (end - ptr < n) \
return XML_TOK_PARTIAL_CHAR; \
if (! IS_NMSTRT_CHAR(enc, ptr, n)) { \
*nextTokPtr = ptr; \
return XML_TOK_INVALID; \
} \
ptr += n; \
break;
# define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
case BT_NONASCII: \
if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
*nextTokPtr = ptr; \
return XML_TOK_INVALID; \
} \
/* fall through */ \
case BT_NMSTRT: \
case BT_HEX: \
ptr += MINBPC(enc); \
break; \
CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
# ifndef PREFIX
# define PREFIX(ident) ident
# endif
# define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
# define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
# define REQUIRE_CHARS(enc, ptr, end, count) \
{ \
if (! HAS_CHARS(enc, ptr, end, count)) { \
return XML_TOK_PARTIAL; \
} \
}
# define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
/* ptr points to character following "<!-" */
static int
PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
if (HAS_CHAR(enc, ptr, end)) {
if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_MINUS:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_COMMENT;
}
break;
default:
ptr += MINBPC(enc);
break;
}
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following "<!" */
static int
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_MINUS:
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_LSQB:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_COND_SECT_OPEN;
case BT_NMSTRT:
case BT_HEX:
ptr += MINBPC(enc);
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_PERCNT:
REQUIRE_CHARS(enc, ptr, end, 2);
/* don't allow <!ENTITY% foo "whatever"> */
switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
case BT_S:
case BT_CR:
case BT_LF:
case BT_PERCNT:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
/* fall through */
case BT_S:
case BT_CR:
case BT_LF:
*nextTokPtr = ptr;
return XML_TOK_DECL_OPEN;
case BT_NMSTRT:
case BT_HEX:
ptr += MINBPC(enc);
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
static int
PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
int *tokPtr) {
int upper = 0;
UNUSED_P(enc);
*tokPtr = XML_TOK_PI;
if (end - ptr != MINBPC(enc) * 3)
return 1;
switch (BYTE_TO_ASCII(enc, ptr)) {
case ASCII_x:
break;
case ASCII_X:
upper = 1;
break;
default:
return 1;
}
ptr += MINBPC(enc);
switch (BYTE_TO_ASCII(enc, ptr)) {
case ASCII_m:
break;
case ASCII_M:
upper = 1;
break;
default:
return 1;
}
ptr += MINBPC(enc);
switch (BYTE_TO_ASCII(enc, ptr)) {
case ASCII_l:
break;
case ASCII_L:
upper = 1;
break;
default:
return 1;
}
if (upper)
return 0;
*tokPtr = XML_TOK_XML_DECL;
return 1;
}
/* ptr points to character following "<?" */
static int
PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
int tok;
const char *target = ptr;
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S:
case BT_CR:
case BT_LF:
if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_QUEST:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr + MINBPC(enc);
return tok;
}
break;
default:
ptr += MINBPC(enc);
break;
}
}
return XML_TOK_PARTIAL;
case BT_QUEST:
if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr + MINBPC(enc);
return tok;
}
/* fall through */
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
static int
PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
static const char CDATA_LSQB[]
= {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
int i;
UNUSED_P(enc);
/* CDATA[ */
REQUIRE_CHARS(enc, ptr, end, 6);
for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
*nextTokPtr = ptr;
return XML_TOK_CDATA_SECT_OPEN;
}
static int
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
if (n & (MINBPC(enc) - 1)) {
n &= ~(MINBPC(enc) - 1);
if (n == 0)
return XML_TOK_PARTIAL;
end = ptr + n;
}
}
switch (BYTE_TYPE(enc, ptr)) {
case BT_RSQB:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
break;
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr -= MINBPC(enc);
break;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CDATA_SECT_CLOSE;
case BT_CR:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
*nextTokPtr = ptr;
return XML_TOK_DATA_NEWLINE;
case BT_LF:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_DATA_NEWLINE;
INVALID_CASES(ptr, nextTokPtr)
default:
ptr += MINBPC(enc);
break;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
*nextTokPtr = ptr; \
return XML_TOK_DATA_CHARS; \
} \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_NONXML:
case BT_MALFORM:
case BT_TRAIL:
case BT_CR:
case BT_LF:
case BT_RSQB:
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
default:
ptr += MINBPC(enc);
break;
}
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
}
/* ptr points to character following "</" */
static int
PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S:
case BT_CR:
case BT_LF:
for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_S:
case BT_CR:
case BT_LF:
break;
case BT_GT:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_END_TAG;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
# ifdef XML_NS
case BT_COLON:
/* no need to check qname syntax here,
since end-tag must match exactly */
ptr += MINBPC(enc);
break;
# endif
case BT_GT:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_END_TAG;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following "&#X" */
static int
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
if (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
break;
case BT_SEMI:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CHAR_REF;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following "&#" */
static int
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
if (HAS_CHAR(enc, ptr, end)) {
if (CHAR_MATCHES(enc, ptr, ASCII_x))
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
break;
case BT_SEMI:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CHAR_REF;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following "&" */
static int
PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_NUM:
return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_ENTITY_REF;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following first character of attribute name */
static int
PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
# ifdef XML_NS
int hadColon = 0;
# endif
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
# ifdef XML_NS
case BT_COLON:
if (hadColon) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
hadColon = 1;
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
break;
# endif
case BT_S:
case BT_CR:
case BT_LF:
for (;;) {
int t;
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
t = BYTE_TYPE(enc, ptr);
if (t == BT_EQUALS)
break;
switch (t) {
case BT_S:
case BT_LF:
case BT_CR:
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
/* fall through */
case BT_EQUALS: {
int open;
# ifdef XML_NS
hadColon = 0;
# endif
for (;;) {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
open = BYTE_TYPE(enc, ptr);
if (open == BT_QUOT || open == BT_APOS)
break;
switch (open) {
case BT_S:
case BT_LF:
case BT_CR:
break;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
ptr += MINBPC(enc);
/* in attribute value */
for (;;) {
int t;
REQUIRE_CHAR(enc, ptr, end);
t = BYTE_TYPE(enc, ptr);
if (t == open)
break;
switch (t) {
INVALID_CASES(ptr, nextTokPtr)
case BT_AMP: {
int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
if (tok <= 0) {
if (tok == XML_TOK_INVALID)
*nextTokPtr = ptr;
return tok;
}
break;
}
case BT_LT:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
default:
ptr += MINBPC(enc);
break;
}
}
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_S:
case BT_CR:
case BT_LF:
break;
case BT_SOL:
goto sol;
case BT_GT:
goto gt;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
/* ptr points to closing quote */
for (;;) {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S:
case BT_CR:
case BT_LF:
continue;
case BT_GT:
gt:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_START_TAG_WITH_ATTS;
case BT_SOL:
sol:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
break;
}
break;
}
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
/* ptr points to character following "<" */
static int
PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
# ifdef XML_NS
int hadColon;
# endif
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_EXCL:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_MINUS:
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_LSQB:
return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
}
*nextTokPtr = ptr;
return XML_TOK_INVALID;
case BT_QUEST:
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_SOL:
return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
# ifdef XML_NS
hadColon = 0;
# endif
/* we have a start-tag */
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
# ifdef XML_NS
case BT_COLON:
if (hadColon) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
hadColon = 1;
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
break;
# endif
case BT_S:
case BT_CR:
case BT_LF: {
ptr += MINBPC(enc);
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_GT:
goto gt;
case BT_SOL:
goto sol;
case BT_S:
case BT_CR:
case BT_LF:
ptr += MINBPC(enc);
continue;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
}
return XML_TOK_PARTIAL;
}
case BT_GT:
gt:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_START_TAG_NO_ATTS;
case BT_SOL:
sol:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
static int
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
if (n & (MINBPC(enc) - 1)) {
n &= ~(MINBPC(enc) - 1);
if (n == 0)
return XML_TOK_PARTIAL;
end = ptr + n;
}
}
switch (BYTE_TYPE(enc, ptr)) {
case BT_LT:
return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_AMP:
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_CR:
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
*nextTokPtr = ptr;
return XML_TOK_DATA_NEWLINE;
case BT_LF:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_DATA_NEWLINE;
case BT_RSQB:
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_RSQB;
if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
break;
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_RSQB;
if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr -= MINBPC(enc);
break;
}
*nextTokPtr = ptr;
return XML_TOK_INVALID;
INVALID_CASES(ptr, nextTokPtr)
default:
ptr += MINBPC(enc);
break;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
*nextTokPtr = ptr; \
return XML_TOK_DATA_CHARS; \
} \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_RSQB:
if (HAS_CHARS(enc, ptr, end, 2)) {
if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
ptr += MINBPC(enc);
break;
}
if (HAS_CHARS(enc, ptr, end, 3)) {
if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
ptr += MINBPC(enc);
break;
}
*nextTokPtr = ptr + 2 * MINBPC(enc);
return XML_TOK_INVALID;
}
}
/* fall through */
case BT_AMP:
case BT_LT:
case BT_NONXML:
case BT_MALFORM:
case BT_TRAIL:
case BT_CR:
case BT_LF:
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
default:
ptr += MINBPC(enc);
break;
}
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
}
/* ptr points to character following "%" */
static int
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S:
case BT_LF:
case BT_CR:
case BT_PERCNT:
*nextTokPtr = ptr;
return XML_TOK_PERCENT;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_PARAM_ENTITY_REF;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return XML_TOK_PARTIAL;
}
static int
PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_CR:
case BT_LF:
case BT_S:
case BT_RPAR:
case BT_GT:
case BT_PERCNT:
case BT_VERBAR:
*nextTokPtr = ptr;
return XML_TOK_POUND_NAME;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return -XML_TOK_POUND_NAME;
}
static int
PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
while (HAS_CHAR(enc, ptr, end)) {
int t = BYTE_TYPE(enc, ptr);
switch (t) {
INVALID_CASES(ptr, nextTokPtr)
case BT_QUOT:
case BT_APOS:
ptr += MINBPC(enc);
if (t != open)
break;
if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_LITERAL;
*nextTokPtr = ptr;
switch (BYTE_TYPE(enc, ptr)) {
case BT_S:
case BT_CR:
case BT_LF:
case BT_GT:
case BT_PERCNT:
case BT_LSQB:
return XML_TOK_LITERAL;
default:
return XML_TOK_INVALID;
}
default:
ptr += MINBPC(enc);
break;
}
}
return XML_TOK_PARTIAL;
}
static int
PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
int tok;
if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
if (n & (MINBPC(enc) - 1)) {
n &= ~(MINBPC(enc) - 1);
if (n == 0)
return XML_TOK_PARTIAL;
end = ptr + n;
}
}
switch (BYTE_TYPE(enc, ptr)) {
case BT_QUOT:
return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_APOS:
return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_LT: {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_EXCL:
return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_QUEST:
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_NMSTRT:
case BT_HEX:
case BT_NONASCII:
case BT_LEAD2:
case BT_LEAD3:
case BT_LEAD4:
*nextTokPtr = ptr - MINBPC(enc);
return XML_TOK_INSTANCE_START;
}
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
case BT_CR:
if (ptr + MINBPC(enc) == end) {
*nextTokPtr = end;
/* indicate that this might be part of a CR/LF pair */
return -XML_TOK_PROLOG_S;
}
/* fall through */
case BT_S:
case BT_LF:
for (;;) {
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
break;
switch (BYTE_TYPE(enc, ptr)) {
case BT_S:
case BT_LF:
break;
case BT_CR:
/* don't split CR/LF pair */
if (ptr + MINBPC(enc) != end)
break;
/* fall through */
default:
*nextTokPtr = ptr;
return XML_TOK_PROLOG_S;
}
}
*nextTokPtr = ptr;
return XML_TOK_PROLOG_S;
case BT_PERCNT:
return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_COMMA:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_COMMA;
case BT_LSQB:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_OPEN_BRACKET;
case BT_RSQB:
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_CLOSE_BRACKET;
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
REQUIRE_CHARS(enc, ptr, end, 2);
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
*nextTokPtr = ptr + 2 * MINBPC(enc);
return XML_TOK_COND_SECT_CLOSE;
}
}
*nextTokPtr = ptr;
return XML_TOK_CLOSE_BRACKET;
case BT_LPAR:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_OPEN_PAREN;
case BT_RPAR:
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_CLOSE_PAREN;
switch (BYTE_TYPE(enc, ptr)) {
case BT_AST:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CLOSE_PAREN_ASTERISK;
case BT_QUEST:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CLOSE_PAREN_QUESTION;
case BT_PLUS:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CLOSE_PAREN_PLUS;
case BT_CR:
case BT_LF:
case BT_S:
case BT_GT:
case BT_COMMA:
case BT_VERBAR:
case BT_RPAR:
*nextTokPtr = ptr;
return XML_TOK_CLOSE_PAREN;
}
*nextTokPtr = ptr;
return XML_TOK_INVALID;
case BT_VERBAR:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_OR;
case BT_GT:
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_DECL_CLOSE;
case BT_NUM:
return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
# define LEAD_CASE(n) \
case BT_LEAD##n: \
if (end - ptr < n) \
return XML_TOK_PARTIAL_CHAR; \
if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
ptr += n; \
tok = XML_TOK_NAME; \
break; \
} \
if (IS_NAME_CHAR(enc, ptr, n)) { \
ptr += n; \
tok = XML_TOK_NMTOKEN; \
break; \
} \
*nextTokPtr = ptr; \
return XML_TOK_INVALID;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_NMSTRT:
case BT_HEX:
tok = XML_TOK_NAME;
ptr += MINBPC(enc);
break;
case BT_DIGIT:
case BT_NAME:
case BT_MINUS:
# ifdef XML_NS
case BT_COLON:
# endif
tok = XML_TOK_NMTOKEN;
ptr += MINBPC(enc);
break;
case BT_NONASCII:
if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
ptr += MINBPC(enc);
tok = XML_TOK_NAME;
break;
}
if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
ptr += MINBPC(enc);
tok = XML_TOK_NMTOKEN;
break;
}
/* fall through */
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_GT:
case BT_RPAR:
case BT_COMMA:
case BT_VERBAR:
case BT_LSQB:
case BT_PERCNT:
case BT_S:
case BT_CR:
case BT_LF:
*nextTokPtr = ptr;
return tok;
# ifdef XML_NS
case BT_COLON:
ptr += MINBPC(enc);
switch (tok) {
case XML_TOK_NAME:
REQUIRE_CHAR(enc, ptr, end);
tok = XML_TOK_PREFIXED_NAME;
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
default:
tok = XML_TOK_NMTOKEN;
break;
}
break;
case XML_TOK_PREFIXED_NAME:
tok = XML_TOK_NMTOKEN;
break;
}
break;
# endif
case BT_PLUS:
if (tok == XML_TOK_NMTOKEN) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_NAME_PLUS;
case BT_AST:
if (tok == XML_TOK_NMTOKEN) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_NAME_ASTERISK;
case BT_QUEST:
if (tok == XML_TOK_NMTOKEN) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_NAME_QUESTION;
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
}
return -tok;
}
static int
PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
const char *start;
if (ptr >= end)
return XML_TOK_NONE;
else if (! HAS_CHAR(enc, ptr, end)) {
/* This line cannot be executed. The incoming data has already
* been tokenized once, so incomplete characters like this have
* already been eliminated from the input. Retaining the paranoia
* check is still valuable, however.
*/
return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
}
start = ptr;
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_AMP:
if (ptr == start)
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_LT:
/* this is for inside entity references */
*nextTokPtr = ptr;
return XML_TOK_INVALID;
case BT_LF:
if (ptr == start) {
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_DATA_NEWLINE;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_CR:
if (ptr == start) {
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
*nextTokPtr = ptr;
return XML_TOK_DATA_NEWLINE;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_S:
if (ptr == start) {
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_ATTRIBUTE_VALUE_S;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
default:
ptr += MINBPC(enc);
break;
}
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
}
static int
PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
const char *start;
if (ptr >= end)
return XML_TOK_NONE;
else if (! HAS_CHAR(enc, ptr, end)) {
/* This line cannot be executed. The incoming data has already
* been tokenized once, so incomplete characters like this have
* already been eliminated from the input. Retaining the paranoia
* check is still valuable, however.
*/
return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
}
start = ptr;
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_AMP:
if (ptr == start)
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_PERCNT:
if (ptr == start) {
int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_LF:
if (ptr == start) {
*nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_DATA_NEWLINE;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
case BT_CR:
if (ptr == start) {
ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
*nextTokPtr = ptr;
return XML_TOK_DATA_NEWLINE;
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
default:
ptr += MINBPC(enc);
break;
}
}
*nextTokPtr = ptr;
return XML_TOK_DATA_CHARS;
}
# ifdef XML_DTD
static int
PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) {
int level = 0;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
if (n & (MINBPC(enc) - 1)) {
n &= ~(MINBPC(enc) - 1);
end = ptr + n;
}
}
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_LT:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
++level;
ptr += MINBPC(enc);
}
}
break;
case BT_RSQB:
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr += MINBPC(enc);
if (level == 0) {
*nextTokPtr = ptr;
return XML_TOK_IGNORE_SECT;
}
--level;
}
}
break;
default:
ptr += MINBPC(enc);
break;
}
}
return XML_TOK_PARTIAL;
}
# endif /* XML_DTD */
static int
PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
const char **badPtr) {
ptr += MINBPC(enc);
end -= MINBPC(enc);
for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
case BT_MINUS:
case BT_APOS:
case BT_LPAR:
case BT_RPAR:
case BT_PLUS:
case BT_COMMA:
case BT_SOL:
case BT_EQUALS:
case BT_QUEST:
case BT_CR:
case BT_LF:
case BT_SEMI:
case BT_EXCL:
case BT_AST:
case BT_PERCNT:
case BT_NUM:
# ifdef XML_NS
case BT_COLON:
# endif
break;
case BT_S:
if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
*badPtr = ptr;
return 0;
}
break;
case BT_NAME:
case BT_NMSTRT:
if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
break;
/* fall through */
default:
switch (BYTE_TO_ASCII(enc, ptr)) {
case 0x24: /* $ */
case 0x40: /* @ */
break;
default:
*badPtr = ptr;
return 0;
}
break;
}
}
return 1;
}
/* This must only be called for a well-formed start-tag or empty
element tag. Returns the number of attributes. Pointers to the
first attsMax attributes are stored in atts.
*/
static int
PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
ATTRIBUTE *atts) {
enum { other, inName, inValue } state = inName;
int nAtts = 0;
int open = 0; /* defined when state == inValue;
initialization just to shut up compilers */
for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
# define START_NAME \
if (state == other) { \
if (nAtts < attsMax) { \
atts[nAtts].name = ptr; \
atts[nAtts].normalized = 1; \
} \
state = inName; \
}
# define LEAD_CASE(n) \
case BT_LEAD##n: \
START_NAME ptr += (n - MINBPC(enc)); \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_NONASCII:
case BT_NMSTRT:
case BT_HEX:
START_NAME
break;
# undef START_NAME
case BT_QUOT:
if (state != inValue) {
if (nAtts < attsMax)
atts[nAtts].valuePtr = ptr + MINBPC(enc);
state = inValue;
open = BT_QUOT;
} else if (open == BT_QUOT) {
state = other;
if (nAtts < attsMax)
atts[nAtts].valueEnd = ptr;
nAtts++;
}
break;
case BT_APOS:
if (state != inValue) {
if (nAtts < attsMax)
atts[nAtts].valuePtr = ptr + MINBPC(enc);
state = inValue;
open = BT_APOS;
} else if (open == BT_APOS) {
state = other;
if (nAtts < attsMax)
atts[nAtts].valueEnd = ptr;
nAtts++;
}
break;
case BT_AMP:
if (nAtts < attsMax)
atts[nAtts].normalized = 0;
break;
case BT_S:
if (state == inName)
state = other;
else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized
&& (ptr == atts[nAtts].valuePtr
|| BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
|| BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
|| BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
atts[nAtts].normalized = 0;
break;
case BT_CR:
case BT_LF:
/* This case ensures that the first attribute name is counted
Apart from that we could just change state on the quote. */
if (state == inName)
state = other;
else if (state == inValue && nAtts < attsMax)
atts[nAtts].normalized = 0;
break;
case BT_GT:
case BT_SOL:
if (state != inValue)
return nAtts;
break;
default:
break;
}
}
/* not reached */
}
static int
PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
int result = 0;
/* skip &# */
UNUSED_P(enc);
ptr += 2 * MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
ptr += MINBPC(enc)) {
int c = BYTE_TO_ASCII(enc, ptr);
switch (c) {
case ASCII_0:
case ASCII_1:
case ASCII_2:
case ASCII_3:
case ASCII_4:
case ASCII_5:
case ASCII_6:
case ASCII_7:
case ASCII_8:
case ASCII_9:
result <<= 4;
result |= (c - ASCII_0);
break;
case ASCII_A:
case ASCII_B:
case ASCII_C:
case ASCII_D:
case ASCII_E:
case ASCII_F:
result <<= 4;
result += 10 + (c - ASCII_A);
break;
case ASCII_a:
case ASCII_b:
case ASCII_c:
case ASCII_d:
case ASCII_e:
case ASCII_f:
result <<= 4;
result += 10 + (c - ASCII_a);
break;
}
if (result >= 0x110000)
return -1;
}
} else {
for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
int c = BYTE_TO_ASCII(enc, ptr);
result *= 10;
result += (c - ASCII_0);
if (result >= 0x110000)
return -1;
}
}
return checkCharRefNumber(result);
}
static int
PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
const char *end) {
UNUSED_P(enc);
switch ((end - ptr) / MINBPC(enc)) {
case 2:
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
switch (BYTE_TO_ASCII(enc, ptr)) {
case ASCII_l:
return ASCII_LT;
case ASCII_g:
return ASCII_GT;
}
}
break;
case 3:
if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_p))
return ASCII_AMP;
}
}
break;
case 4:
switch (BYTE_TO_ASCII(enc, ptr)) {
case ASCII_q:
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_t))
return ASCII_QUOT;
}
}
break;
case ASCII_a:
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
ptr += MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_s))
return ASCII_APOS;
}
}
break;
}
}
return 0;
}
static int
PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
const char *end1, const char *ptr2) {
UNUSED_P(enc);
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
if (end1 - ptr1 < MINBPC(enc)) {
/* This line cannot be executed. The incoming data has already
* been tokenized once, so incomplete characters like this have
* already been eliminated from the input. Retaining the
* paranoia check is still valuable, however.
*/
return 0; /* LCOV_EXCL_LINE */
}
if (! CHAR_MATCHES(enc, ptr1, *ptr2))
return 0;
}
return ptr1 == end1;
}
static int
PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
const char *start = ptr;
for (;;) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_NONASCII:
case BT_NMSTRT:
# ifdef XML_NS
case BT_COLON:
# endif
case BT_HEX:
case BT_DIGIT:
case BT_NAME:
case BT_MINUS:
ptr += MINBPC(enc);
break;
default:
return (int)(ptr - start);
}
}
}
static const char *
PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
for (;;) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_LF:
case BT_CR:
case BT_S:
ptr += MINBPC(enc);
break;
default:
return ptr;
}
}
}
static void
PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
POSITION *pos) {
while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \
case BT_LEAD##n: \
ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE
case BT_LF:
pos->columnNumber = (XML_Size)-1;
pos->lineNumber++;
ptr += MINBPC(enc);
break;
case BT_CR:
pos->lineNumber++;
ptr += MINBPC(enc);
if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
pos->columnNumber = (XML_Size)-1;
break;
default:
ptr += MINBPC(enc);
break;
}
pos->columnNumber++;
}
}
# undef DO_LEAD_CASE
# undef MULTIBYTE_CASES
# undef INVALID_CASES
# undef CHECK_NAME_CASE
# undef CHECK_NAME_CASES
# undef CHECK_NMSTRT_CASE
# undef CHECK_NMSTRT_CASES
#endif /* XML_TOK_IMPL_C */
| 52,338 | 1,806 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Modules/expat/internal.inc | /* clang-format off */
/* internal.h
Note: Use of these macros is based on judgement, not hard rules,
and therefore subject to change.
__ __ _
___\ \/ /_ __ __ _| |_
/ _ \\ /| '_ \ / _` | __|
| __// \| |_) | (_| | |_
\___/_/\_\ .__/ \__,_|\__|
|_| XML parser
Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
Copyright (c) 2000-2017 Expat development team
Licensed under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
/* We'll use this version by default only where we know it helps.
regparm() generates warnings on Solaris boxes. See SF bug #692878.
Instability reported with egcs on a RedHat Linux 7.3.
Let's comment out:
#define FASTCALL __attribute__((stdcall, regparm(3)))
and let's try this:
*/
# define FASTCALL __attribute__((regparm(3)))
# define PTRFASTCALL __attribute__((regparm(3)))
#endif
/* Using __fastcall seems to have an unexpected negative effect under
MS VC++, especially for function pointers, so we won't use it for
now on that platform. It may be reconsidered for a future release
if it can be made more effective.
Likely reason: __fastcall on Windows is like stdcall, therefore
the compiler cannot perform stack optimizations for call clusters.
*/
/* Make sure all of these are defined if they aren't already. */
#ifndef XML_MIN_SIZE
# if ! defined(__cplusplus) && ! defined(inline)
# ifdef __GNUC__
# define inline __inline
# endif /* __GNUC__ */
# endif
#endif /* XML_MIN_SIZE */
#ifdef __cplusplus
# define inline inline
#else
# ifndef inline
# define inline
# endif
#endif
#ifndef UNUSED_P
# define UNUSED_P(p) (void)p
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef XML_ENABLE_VISIBILITY
# if XML_ENABLE_VISIBILITY
__attribute__((visibility("default")))
# endif
#endif
void
_INTERNAL_trim_to_complete_utf8_characters(const char *from,
const char **fromLimRef);
#ifdef __cplusplus
}
#endif
| 3,313 | 97 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/README | This directory contains a number of Python programs that are useful
while building or extending Python.
buildbot Batchfiles for running on Windows buildslaves.
ccbench A Python threads-based concurrency benchmark. (*)
demo Several Python programming demos.
freeze Create a stand-alone executable from a Python program.
gdb Python code to be run inside gdb, to make it easier to
debug Python itself (by David Malcolm).
i18n Tools for internationalization. pygettext.py
parses Python source code and generates .pot files,
and msgfmt.py generates a binary message catalog
from a catalog in text format.
iobench Benchmark for the new Python I/O system. (*)
msi Support for packaging Python as an MSI package on Windows.
parser Un-parsing tool to generate code from an AST.
pybench Low-level benchmarking for the Python evaluation loop. (*)
pynche A Tkinter-based color editor.
scripts A number of useful single-file programs, e.g. tabnanny.py
by Tim Peters, which checks for inconsistent mixing of
tabs and spaces, and 2to3, which converts Python 2 code
to Python 3 code.
stringbench A suite of micro-benchmarks for various operations on
strings (both 8-bit and unicode). (*)
test2to3 A demonstration of how to use 2to3 transparently in setup.py.
unicode Tools for generating unicodedata and codecs from unicode.org
and other mapping files (by Fredrik Lundh, Marc-Andre Lemburg
and Martin von Loewis).
unittestgui A Tkinter based GUI test runner for unittest, with test
discovery.
(*) A generic benchmark suite is maintained separately at https://github.com/python/performance
| 1,902 | 49 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/ssl/multissltests.py | #!./python
"""Run Python tests against multiple installations of OpenSSL and LibreSSL
The script
(1) downloads OpenSSL / LibreSSL tar bundle
(2) extracts it to ./src
(3) compiles OpenSSL / LibreSSL
(4) installs OpenSSL / LibreSSL into ../multissl/$LIB/$VERSION/
(5) forces a recompilation of Python modules using the
header and library files from ../multissl/$LIB/$VERSION/
(6) runs Python's test suite
The script must be run with Python's build directory as current working
directory.
The script uses LD_RUN_PATH, LD_LIBRARY_PATH, CPPFLAGS and LDFLAGS to bend
search paths for header files and shared libraries. It's known to work on
Linux with GCC and clang.
Please keep this script compatible with Python 2.7, and 3.4 to 3.7.
(c) 2013-2017 Christian Heimes <[email protected]>
"""
from __future__ import print_function
import argparse
from datetime import datetime
import logging
import os
try:
from urllib.request import urlopen
except ImportError:
from urllib2 import urlopen
import subprocess
import shutil
import sys
import tarfile
log = logging.getLogger("multissl")
OPENSSL_OLD_VERSIONS = [
"0.9.8zh",
"1.0.1u",
"1.0.2",
]
OPENSSL_RECENT_VERSIONS = [
"1.0.2p",
"1.1.0i",
"1.1.1",
]
LIBRESSL_OLD_VERSIONS = [
"2.5.5",
"2.6.4",
]
LIBRESSL_RECENT_VERSIONS = [
"2.7.4",
]
# store files in ../multissl
HERE = os.path.dirname(os.path.abspath(__file__))
PYTHONROOT = os.path.abspath(os.path.join(HERE, '..', '..'))
MULTISSL_DIR = os.path.abspath(os.path.join(PYTHONROOT, '..', 'multissl'))
parser = argparse.ArgumentParser(
prog='multissl',
description=(
"Run CPython tests with multiple OpenSSL and LibreSSL "
"versions."
)
)
parser.add_argument(
'--debug',
action='store_true',
help="Enable debug logging",
)
parser.add_argument(
'--disable-ancient',
action='store_true',
help="Don't test OpenSSL < 1.0.2 and LibreSSL < 2.5.3.",
)
parser.add_argument(
'--openssl',
nargs='+',
default=(),
help=(
"OpenSSL versions, defaults to '{}' (ancient: '{}') if no "
"OpenSSL and LibreSSL versions are given."
).format(OPENSSL_RECENT_VERSIONS, OPENSSL_OLD_VERSIONS)
)
parser.add_argument(
'--libressl',
nargs='+',
default=(),
help=(
"LibreSSL versions, defaults to '{}' (ancient: '{}') if no "
"OpenSSL and LibreSSL versions are given."
).format(LIBRESSL_RECENT_VERSIONS, LIBRESSL_OLD_VERSIONS)
)
parser.add_argument(
'--tests',
nargs='*',
default=(),
help="Python tests to run, defaults to all SSL related tests.",
)
parser.add_argument(
'--base-directory',
default=MULTISSL_DIR,
help="Base directory for OpenSSL / LibreSSL sources and builds."
)
parser.add_argument(
'--no-network',
action='store_false',
dest='network',
help="Disable network tests."
)
parser.add_argument(
'--steps',
choices=['library', 'modules', 'tests'],
default='tests',
help=(
"Which steps to perform. 'library' downloads and compiles OpenSSL "
"or LibreSSL. 'module' also compiles Python modules. 'tests' builds "
"all and runs the test suite."
)
)
parser.add_argument(
'--system',
default='',
help="Override the automatic system type detection."
)
parser.add_argument(
'--force',
action='store_true',
dest='force',
help="Force build and installation."
)
parser.add_argument(
'--keep-sources',
action='store_true',
dest='keep_sources',
help="Keep original sources for debugging."
)
class AbstractBuilder(object):
library = None
url_template = None
src_template = None
build_template = None
install_target = 'install'
module_files = ("Modules/_ssl.c",
"Modules/_hashopenssl.c")
module_libs = ("_ssl", "_hashlib")
def __init__(self, version, args):
self.version = version
self.args = args
# installation directory
self.install_dir = os.path.join(
os.path.join(args.base_directory, self.library.lower()), version
)
# source file
self.src_dir = os.path.join(args.base_directory, 'src')
self.src_file = os.path.join(
self.src_dir, self.src_template.format(version))
# build directory (removed after install)
self.build_dir = os.path.join(
self.src_dir, self.build_template.format(version))
self.system = args.system
def __str__(self):
return "<{0.__class__.__name__} for {0.version}>".format(self)
def __eq__(self, other):
if not isinstance(other, AbstractBuilder):
return NotImplemented
return (
self.library == other.library
and self.version == other.version
)
def __hash__(self):
return hash((self.library, self.version))
@property
def openssl_cli(self):
"""openssl CLI binary"""
return os.path.join(self.install_dir, "bin", "openssl")
@property
def openssl_version(self):
"""output of 'bin/openssl version'"""
cmd = [self.openssl_cli, "version"]
return self._subprocess_output(cmd)
@property
def pyssl_version(self):
"""Value of ssl.OPENSSL_VERSION"""
cmd = [
sys.executable,
'-c', 'import ssl; print(ssl.OPENSSL_VERSION)'
]
return self._subprocess_output(cmd)
@property
def include_dir(self):
return os.path.join(self.install_dir, "include")
@property
def lib_dir(self):
return os.path.join(self.install_dir, "lib")
@property
def has_openssl(self):
return os.path.isfile(self.openssl_cli)
@property
def has_src(self):
return os.path.isfile(self.src_file)
def _subprocess_call(self, cmd, env=None, **kwargs):
log.debug("Call '{}'".format(" ".join(cmd)))
return subprocess.check_call(cmd, env=env, **kwargs)
def _subprocess_output(self, cmd, env=None, **kwargs):
log.debug("Call '{}'".format(" ".join(cmd)))
if env is None:
env = os.environ.copy()
env["LD_LIBRARY_PATH"] = self.lib_dir
out = subprocess.check_output(cmd, env=env, **kwargs)
return out.strip().decode("utf-8")
def _download_src(self):
"""Download sources"""
src_dir = os.path.dirname(self.src_file)
if not os.path.isdir(src_dir):
os.makedirs(src_dir)
url = self.url_template.format(self.version)
log.info("Downloading from {}".format(url))
req = urlopen(url)
# KISS, read all, write all
data = req.read()
log.info("Storing {}".format(self.src_file))
with open(self.src_file, "wb") as f:
f.write(data)
def _unpack_src(self):
"""Unpack tar.gz bundle"""
# cleanup
if os.path.isdir(self.build_dir):
shutil.rmtree(self.build_dir)
os.makedirs(self.build_dir)
tf = tarfile.open(self.src_file)
name = self.build_template.format(self.version)
base = name + '/'
# force extraction into build dir
members = tf.getmembers()
for member in list(members):
if member.name == name:
members.remove(member)
elif not member.name.startswith(base):
raise ValueError(member.name, base)
member.name = member.name[len(base):].lstrip('/')
log.info("Unpacking files to {}".format(self.build_dir))
tf.extractall(self.build_dir, members)
def _build_src(self):
"""Now build openssl"""
log.info("Running build in {}".format(self.build_dir))
cwd = self.build_dir
cmd = [
"./config",
"shared", "--debug",
"--prefix={}".format(self.install_dir)
]
env = os.environ.copy()
# set rpath
env["LD_RUN_PATH"] = self.lib_dir
if self.system:
env['SYSTEM'] = self.system
self._subprocess_call(cmd, cwd=cwd, env=env)
# Old OpenSSL versions do not support parallel builds.
self._subprocess_call(["make", "-j1"], cwd=cwd, env=env)
def _make_install(self):
self._subprocess_call(
["make", "-j1", self.install_target],
cwd=self.build_dir
)
if not self.args.keep_sources:
shutil.rmtree(self.build_dir)
def install(self):
log.info(self.openssl_cli)
if not self.has_openssl or self.args.force:
if not self.has_src:
self._download_src()
else:
log.debug("Already has src {}".format(self.src_file))
self._unpack_src()
self._build_src()
self._make_install()
else:
log.info("Already has installation {}".format(self.install_dir))
# validate installation
version = self.openssl_version
if self.version not in version:
raise ValueError(version)
def recompile_pymods(self):
log.warning("Using build from {}".format(self.build_dir))
# force a rebuild of all modules that use OpenSSL APIs
for fname in self.module_files:
os.utime(fname, None)
# remove all build artefacts
for root, dirs, files in os.walk('build'):
for filename in files:
if filename.startswith(self.module_libs):
os.unlink(os.path.join(root, filename))
# overwrite header and library search paths
env = os.environ.copy()
env["CPPFLAGS"] = "-I{}".format(self.include_dir)
env["LDFLAGS"] = "-L{}".format(self.lib_dir)
# set rpath
env["LD_RUN_PATH"] = self.lib_dir
log.info("Rebuilding Python modules")
cmd = [sys.executable, "setup.py", "build"]
self._subprocess_call(cmd, env=env)
self.check_imports()
def check_imports(self):
cmd = [sys.executable, "-c", "import _ssl; import _hashlib"]
self._subprocess_call(cmd)
def check_pyssl(self):
version = self.pyssl_version
if self.version not in version:
raise ValueError(version)
def run_python_tests(self, tests, network=True):
if not tests:
cmd = [sys.executable, 'Lib/test/ssltests.py', '-j0']
elif sys.version_info < (3, 3):
cmd = [sys.executable, '-m', 'test.regrtest']
else:
cmd = [sys.executable, '-m', 'test', '-j0']
if network:
cmd.extend(['-u', 'network', '-u', 'urlfetch'])
cmd.extend(['-w', '-r'])
cmd.extend(tests)
self._subprocess_call(cmd, stdout=None)
class BuildOpenSSL(AbstractBuilder):
library = "OpenSSL"
url_template = "https://www.openssl.org/source/openssl-{}.tar.gz"
src_template = "openssl-{}.tar.gz"
build_template = "openssl-{}"
# only install software, skip docs
install_target = 'install_sw'
class BuildLibreSSL(AbstractBuilder):
library = "LibreSSL"
url_template = (
"https://ftp.openbsd.org/pub/OpenBSD/LibreSSL/libressl-{}.tar.gz")
src_template = "libressl-{}.tar.gz"
build_template = "libressl-{}"
def configure_make():
if not os.path.isfile('Makefile'):
log.info('Running ./configure')
subprocess.check_call([
'./configure', '--config-cache', '--quiet',
'--with-pydebug'
])
log.info('Running make')
subprocess.check_call(['make', '--quiet'])
def main():
args = parser.parse_args()
if not args.openssl and not args.libressl:
args.openssl = list(OPENSSL_RECENT_VERSIONS)
args.libressl = list(LIBRESSL_RECENT_VERSIONS)
if not args.disable_ancient:
args.openssl.extend(OPENSSL_OLD_VERSIONS)
args.libressl.extend(LIBRESSL_OLD_VERSIONS)
logging.basicConfig(
level=logging.DEBUG if args.debug else logging.INFO,
format="*** %(levelname)s %(message)s"
)
start = datetime.now()
if args.steps in {'modules', 'tests'}:
for name in ['setup.py', 'Modules/_ssl.c']:
if not os.path.isfile(os.path.join(PYTHONROOT, name)):
parser.error(
"Must be executed from CPython build dir"
)
if not os.path.samefile('python', sys.executable):
parser.error(
"Must be executed with ./python from CPython build dir"
)
# check for configure and run make
configure_make()
# download and register builder
builds = []
for version in args.openssl:
build = BuildOpenSSL(
version,
args
)
build.install()
builds.append(build)
for version in args.libressl:
build = BuildLibreSSL(
version,
args
)
build.install()
builds.append(build)
if args.steps in {'modules', 'tests'}:
for build in builds:
try:
build.recompile_pymods()
build.check_pyssl()
if args.steps == 'tests':
build.run_python_tests(
tests=args.tests,
network=args.network,
)
except Exception as e:
log.exception("%s failed", build)
print("{} failed: {}".format(build, e), file=sys.stderr)
sys.exit(2)
log.info("\n{} finished in {}".format(
args.steps.capitalize(),
datetime.now() - start
))
print('Python: ', sys.version)
if args.steps == 'tests':
if args.tests:
print('Executed Tests:', ' '.join(args.tests))
else:
print('Executed all SSL tests.')
print('OpenSSL / LibreSSL versions:')
for build in builds:
print(" * {0.library} {0.version}".format(build))
if __name__ == "__main__":
main()
| 14,039 | 474 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/ssl/sslspeed.vcxproj | <?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{F068BCCF-C0D6-478D-A2C5-26BA3237C992}</ProjectGuid>
<RootNamespace>sslspeed</RootNamespace>
</PropertyGroup>
<Import Project="..\..\PCBuild\python.props" />
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<Import Project="..\..\PCBuild\openssl.props" />
<PropertyGroup Label="Configuration">
<OriginalOutDir>$(OutDir)</OriginalOutDir>
<OutDir>$(MSBuildProjectDirectory)\$(ArchName)\</OutDir>
<IntDir>$(MSBuildProjectDirectory)\$(ArchName)\obj\</IntDir>
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ItemGroup>
<ClCompile Include="$(opensslDir)apps\speed.c" />
<ClCompile Include="$(opensslDir)apps\apps.c" />
</ItemGroup>
<ItemDefinitionGroup>
<ClCompile>
<PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(opensslIncDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<AdditionalDependencies>ws2_32.lib;crypt32.lib;libeay$(PyDebugExt).lib;ssleay$(PyDebugExt).lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(OriginalOutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Console</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="..\..\PCBuild\ssleay.vcxproj">
<Project>{10615b24-73bf-4efa-93aa-236916321317}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
</ProjectReference>
<ProjectReference Include="..\..\PCBuild\libeay.vcxproj">
<Project>{e5b04cc0-eb4c-42ab-b4dc-18ef95f864b0}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
</Project> | 2,854 | 70 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/ssl/make_ssl_data.py | #! /usr/bin/env python3
"""
This script should be called *manually* when we want to upgrade SSLError
`library` and `reason` mnemnonics to a more recent OpenSSL version.
It takes two arguments:
- the path to the OpenSSL source tree (e.g. git checkout)
- the path to the C file to be generated
(probably Modules/_ssl_data.h)
"""
import datetime
import os
import re
import sys
import _ssl
def parse_error_codes(h_file, prefix, libcode):
pat = re.compile(r"#define\W+(%s([\w]+))\W+(\d+)\b" % re.escape(prefix))
codes = []
with open(h_file, "r", encoding="latin1") as f:
for line in f:
match = pat.search(line)
if match:
code, name, num = match.groups()
num = int(num)
# e.g. ("SSL_R_BAD_DATA", ("ERR_LIB_SSL", "BAD_DATA", 390))
codes.append((code, (libcode, name, num)))
return codes
if __name__ == "__main__":
openssl_inc = sys.argv[1]
outfile = sys.argv[2]
use_stdout = outfile == '-'
f = sys.stdout if use_stdout else open(outfile, "w")
error_libraries = {
# mnemonic -> (library code, error prefix, header file)
'PEM': ('ERR_LIB_PEM', 'PEM_R_', 'crypto/pem/pem.h'),
'SSL': ('ERR_LIB_SSL', 'SSL_R_', 'ssl/ssl.h'),
'X509': ('ERR_LIB_X509', 'X509_R_', 'crypto/x509/x509.h'),
}
# Read codes from libraries
new_codes = []
for libcode, prefix, h_file in sorted(error_libraries.values()):
new_codes += parse_error_codes(os.path.join(openssl_inc, h_file),
prefix, libcode)
new_code_nums = set((libcode, num)
for (code, (libcode, name, num)) in new_codes)
# Merge with existing codes (in case some old codes disappeared).
codes = {}
for errname, (libnum, errnum) in _ssl.err_names_to_codes.items():
lib = error_libraries[_ssl.lib_codes_to_names[libnum]]
libcode = lib[0] # e.g. ERR_LIB_PEM
errcode = lib[1] + errname # e.g. SSL_R_BAD_SSL_SESSION_ID_LENGTH
# Only keep it if the numeric codes weren't reused
if (libcode, errnum) not in new_code_nums:
codes[errcode] = libcode, errname, errnum
codes.update(dict(new_codes))
def w(l):
f.write(l + "\n")
w("/* File generated by Tools/ssl/make_ssl_data.py */")
w("/* Generated on %s */" % datetime.datetime.now().isoformat())
w("")
w("static struct py_ssl_library_code library_codes[] = {")
for mnemo, (libcode, _, _) in sorted(error_libraries.items()):
w(' {"%s", %s},' % (mnemo, libcode))
w(' { NULL }')
w('};')
w("")
w("static struct py_ssl_error_code error_codes[] = {")
for errcode, (libcode, name, num) in sorted(codes.items()):
w(' #ifdef %s' % (errcode))
w(' {"%s", %s, %s},' % (name, libcode, errcode))
w(' #else')
w(' {"%s", %s, %d},' % (name, libcode, num))
w(' #endif')
w(' { NULL }')
w('};')
if not use_stdout:
f.close()
| 3,064 | 88 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/clinic/clinic.py | #!/usr/bin/env python3
#
# Argument Clinic
# Copyright 2012-2013 by Larry Hastings.
# Licensed to the PSF under a contributor agreement.
#
import abc
import ast
import atexit
import collections
import contextlib
import copy
import cpp
import functools
import hashlib
import inspect
import io
import itertools
import os
import pprint
import re
import shlex
import string
import sys
import tempfile
import textwrap
import traceback
import types
import uuid
from types import *
NoneType = type(None)
# TODO:
#
# soon:
#
# * allow mixing any two of {positional-only, positional-or-keyword,
# keyword-only}
# * dict constructor uses positional-only and keyword-only
# * max and min use positional only with an optional group
# and keyword-only
#
version = '1'
_empty = inspect._empty
_void = inspect._void
NoneType = type(None)
class Unspecified:
def __repr__(self):
return '<Unspecified>'
unspecified = Unspecified()
class Null:
def __repr__(self):
return '<Null>'
NULL = Null()
class Unknown:
def __repr__(self):
return '<Unknown>'
unknown = Unknown()
sig_end_marker = '--'
_text_accumulator_nt = collections.namedtuple("_text_accumulator", "text append output")
def _text_accumulator():
text = []
def output():
s = ''.join(text)
text.clear()
return s
return _text_accumulator_nt(text, text.append, output)
text_accumulator_nt = collections.namedtuple("text_accumulator", "text append")
def text_accumulator():
"""
Creates a simple text accumulator / joiner.
Returns a pair of callables:
append, output
"append" appends a string to the accumulator.
"output" returns the contents of the accumulator
joined together (''.join(accumulator)) and
empties the accumulator.
"""
text, append, output = _text_accumulator()
return text_accumulator_nt(append, output)
def warn_or_fail(fail=False, *args, filename=None, line_number=None):
joined = " ".join([str(a) for a in args])
add, output = text_accumulator()
if fail:
add("Error")
else:
add("Warning")
if clinic:
if filename is None:
filename = clinic.filename
if getattr(clinic, 'block_parser', None) and (line_number is None):
line_number = clinic.block_parser.line_number
if filename is not None:
add(' in file "' + filename + '"')
if line_number is not None:
add(" on line " + str(line_number))
add(':\n')
add(joined)
print(output())
if fail:
sys.exit(-1)
def warn(*args, filename=None, line_number=None):
return warn_or_fail(False, *args, filename=filename, line_number=line_number)
def fail(*args, filename=None, line_number=None):
return warn_or_fail(True, *args, filename=filename, line_number=line_number)
def quoted_for_c_string(s):
for old, new in (
('\\', '\\\\'), # must be first!
('"', '\\"'),
("'", "\\'"),
):
s = s.replace(old, new)
return s
def c_repr(s):
return '"' + s + '"'
is_legal_c_identifier = re.compile('^[A-Za-z_][A-Za-z0-9_]*$').match
def is_legal_py_identifier(s):
return all(is_legal_c_identifier(field) for field in s.split('.'))
# identifiers that are okay in Python but aren't a good idea in C.
# so if they're used Argument Clinic will add "_value" to the end
# of the name in C.
c_keywords = set("""
asm auto break case char const continue default do double
else enum extern float for goto if inline int long
register return short signed sizeof static struct switch
typedef typeof union unsigned void volatile while
""".strip().split())
def ensure_legal_c_identifier(s):
# for now, just complain if what we're given isn't legal
if not is_legal_c_identifier(s):
fail("Illegal C identifier: {}".format(s))
# but if we picked a C keyword, pick something else
if s in c_keywords:
return s + "_value"
return s
def rstrip_lines(s):
text, add, output = _text_accumulator()
for line in s.split('\n'):
add(line.rstrip())
add('\n')
text.pop()
return output()
def format_escape(s):
# double up curly-braces, this string will be used
# as part of a format_map() template later
s = s.replace('{', '{{')
s = s.replace('}', '}}')
return s
def linear_format(s, **kwargs):
"""
Perform str.format-like substitution, except:
* The strings substituted must be on lines by
themselves. (This line is the "source line".)
* If the substitution text is empty, the source line
is removed in the output.
* If the field is not recognized, the original line
is passed unmodified through to the output.
* If the substitution text is not empty:
* Each line of the substituted text is indented
by the indent of the source line.
* A newline will be added to the end.
"""
add, output = text_accumulator()
for line in s.split('\n'):
indent, curly, trailing = line.partition('{')
if not curly:
add(line)
add('\n')
continue
name, curly, trailing = trailing.partition('}')
if not curly or name not in kwargs:
add(line)
add('\n')
continue
if trailing:
fail("Text found after {" + name + "} block marker! It must be on a line by itself.")
if indent.strip():
fail("Non-whitespace characters found before {" + name + "} block marker! It must be on a line by itself.")
value = kwargs[name]
if not value:
continue
value = textwrap.indent(rstrip_lines(value), indent)
add(value)
add('\n')
return output()[:-1]
def indent_all_lines(s, prefix):
"""
Returns 's', with 'prefix' prepended to all lines.
If the last line is empty, prefix is not prepended
to it. (If s is blank, returns s unchanged.)
(textwrap.indent only adds to non-blank lines.)
"""
split = s.split('\n')
last = split.pop()
final = []
for line in split:
final.append(prefix)
final.append(line)
final.append('\n')
if last:
final.append(prefix)
final.append(last)
return ''.join(final)
def suffix_all_lines(s, suffix):
"""
Returns 's', with 'suffix' appended to all lines.
If the last line is empty, suffix is not appended
to it. (If s is blank, returns s unchanged.)
"""
split = s.split('\n')
last = split.pop()
final = []
for line in split:
final.append(line)
final.append(suffix)
final.append('\n')
if last:
final.append(last)
final.append(suffix)
return ''.join(final)
def version_splitter(s):
"""Splits a version string into a tuple of integers.
The following ASCII characters are allowed, and employ
the following conversions:
a -> -3
b -> -2
c -> -1
(This permits Python-style version strings such as "1.4b3".)
"""
version = []
accumulator = []
def flush():
if not accumulator:
raise ValueError('Unsupported version string: ' + repr(s))
version.append(int(''.join(accumulator)))
accumulator.clear()
for c in s:
if c.isdigit():
accumulator.append(c)
elif c == '.':
flush()
elif c in 'abc':
flush()
version.append('abc'.index(c) - 3)
else:
raise ValueError('Illegal character ' + repr(c) + ' in version string ' + repr(s))
flush()
return tuple(version)
def version_comparitor(version1, version2):
iterator = itertools.zip_longest(version_splitter(version1), version_splitter(version2), fillvalue=0)
for i, (a, b) in enumerate(iterator):
if a < b:
return -1
if a > b:
return 1
return 0
class CRenderData:
def __init__(self):
# The C statements to declare variables.
# Should be full lines with \n eol characters.
self.declarations = []
# The C statements required to initialize the variables before the parse call.
# Should be full lines with \n eol characters.
self.initializers = []
# The C statements needed to dynamically modify the values
# parsed by the parse call, before calling the impl.
self.modifications = []
# The entries for the "keywords" array for PyArg_ParseTuple.
# Should be individual strings representing the names.
self.keywords = []
# The "format units" for PyArg_ParseTuple.
# Should be individual strings that will get
self.format_units = []
# The varargs arguments for PyArg_ParseTuple.
self.parse_arguments = []
# The parameter declarations for the impl function.
self.impl_parameters = []
# The arguments to the impl function at the time it's called.
self.impl_arguments = []
# For return converters: the name of the variable that
# should receive the value returned by the impl.
self.return_value = "return_value"
# For return converters: the code to convert the return
# value from the parse function. This is also where
# you should check the _return_value for errors, and
# "goto exit" if there are any.
self.return_conversion = []
# The C statements required to clean up after the impl call.
self.cleanup = []
class FormatCounterFormatter(string.Formatter):
"""
This counts how many instances of each formatter
"replacement string" appear in the format string.
e.g. after evaluating "string {a}, {b}, {c}, {a}"
the counts dict would now look like
{'a': 2, 'b': 1, 'c': 1}
"""
def __init__(self):
self.counts = collections.Counter()
def get_value(self, key, args, kwargs):
self.counts[key] += 1
return ''
class Language(metaclass=abc.ABCMeta):
start_line = ""
body_prefix = ""
stop_line = ""
checksum_line = ""
def __init__(self, filename):
pass
@abc.abstractmethod
def render(self, clinic, signatures):
pass
def parse_line(self, line):
pass
def validate(self):
def assert_only_one(attr, *additional_fields):
"""
Ensures that the string found at getattr(self, attr)
contains exactly one formatter replacement string for
each valid field. The list of valid fields is
['dsl_name'] extended by additional_fields.
e.g.
self.fmt = "{dsl_name} {a} {b}"
# this passes
self.assert_only_one('fmt', 'a', 'b')
# this fails, the format string has a {b} in it
self.assert_only_one('fmt', 'a')
# this fails, the format string doesn't have a {c} in it
self.assert_only_one('fmt', 'a', 'b', 'c')
# this fails, the format string has two {a}s in it,
# it must contain exactly one
self.fmt2 = '{dsl_name} {a} {a}'
self.assert_only_one('fmt2', 'a')
"""
fields = ['dsl_name']
fields.extend(additional_fields)
line = getattr(self, attr)
fcf = FormatCounterFormatter()
fcf.format(line)
def local_fail(should_be_there_but_isnt):
if should_be_there_but_isnt:
fail("{} {} must contain {{{}}} exactly once!".format(
self.__class__.__name__, attr, name))
else:
fail("{} {} must not contain {{{}}}!".format(
self.__class__.__name__, attr, name))
for name, count in fcf.counts.items():
if name in fields:
if count > 1:
local_fail(True)
else:
local_fail(False)
for name in fields:
if fcf.counts.get(name) != 1:
local_fail(True)
assert_only_one('start_line')
assert_only_one('stop_line')
field = "arguments" if "{arguments}" in self.checksum_line else "checksum"
assert_only_one('checksum_line', field)
class PythonLanguage(Language):
language = 'Python'
start_line = "#/*[{dsl_name} input]"
body_prefix = "#"
stop_line = "#[{dsl_name} start generated code]*/"
checksum_line = "#/*[{dsl_name} end generated code: {arguments}]*/"
def permute_left_option_groups(l):
"""
Given [1, 2, 3], should yield:
()
(3,)
(2, 3)
(1, 2, 3)
"""
yield tuple()
accumulator = []
for group in reversed(l):
accumulator = list(group) + accumulator
yield tuple(accumulator)
def permute_right_option_groups(l):
"""
Given [1, 2, 3], should yield:
()
(1,)
(1, 2)
(1, 2, 3)
"""
yield tuple()
accumulator = []
for group in l:
accumulator.extend(group)
yield tuple(accumulator)
def permute_optional_groups(left, required, right):
"""
Generator function that computes the set of acceptable
argument lists for the provided iterables of
argument groups. (Actually it generates a tuple of tuples.)
Algorithm: prefer left options over right options.
If required is empty, left must also be empty.
"""
required = tuple(required)
result = []
if not required:
assert not left
accumulator = []
counts = set()
for r in permute_right_option_groups(right):
for l in permute_left_option_groups(left):
t = l + required + r
if len(t) in counts:
continue
counts.add(len(t))
accumulator.append(t)
accumulator.sort(key=len)
return tuple(accumulator)
def strip_leading_and_trailing_blank_lines(s):
lines = s.rstrip().split('\n')
while lines:
line = lines[0]
if line.strip():
break
del lines[0]
return '\n'.join(lines)
@functools.lru_cache()
def normalize_snippet(s, *, indent=0):
"""
Reformats s:
* removes leading and trailing blank lines
* ensures that it does not end with a newline
* dedents so the first nonwhite character on any line is at column "indent"
"""
s = strip_leading_and_trailing_blank_lines(s)
s = textwrap.dedent(s)
if indent:
s = textwrap.indent(s, ' ' * indent)
return s
def wrap_declarations(text, length=78):
"""
A simple-minded text wrapper for C function declarations.
It views a declaration line as looking like this:
xxxxxxxx(xxxxxxxxx,xxxxxxxxx)
If called with length=30, it would wrap that line into
xxxxxxxx(xxxxxxxxx,
xxxxxxxxx)
(If the declaration has zero or one parameters, this
function won't wrap it.)
If this doesn't work properly, it's probably better to
start from scratch with a more sophisticated algorithm,
rather than try and improve/debug this dumb little function.
"""
lines = []
for line in text.split('\n'):
prefix, _, after_l_paren = line.partition('(')
if not after_l_paren:
lines.append(line)
continue
parameters, _, after_r_paren = after_l_paren.partition(')')
if not _:
lines.append(line)
continue
if ',' not in parameters:
lines.append(line)
continue
parameters = [x.strip() + ", " for x in parameters.split(',')]
prefix += "("
if len(prefix) < length:
spaces = " " * len(prefix)
else:
spaces = " " * 4
while parameters:
line = prefix
first = True
while parameters:
if (not first and
(len(line) + len(parameters[0]) > length)):
break
line += parameters.pop(0)
first = False
if not parameters:
line = line.rstrip(", ") + ")" + after_r_paren
lines.append(line.rstrip())
prefix = spaces
return "\n".join(lines)
class CLanguage(Language):
body_prefix = "#"
language = 'C'
start_line = "/*[{dsl_name} input]"
body_prefix = ""
stop_line = "[{dsl_name} start generated code]*/"
checksum_line = "/*[{dsl_name} end generated code: {arguments}]*/"
def __init__(self, filename):
super().__init__(filename)
self.cpp = cpp.Monitor(filename)
self.cpp.fail = fail
def parse_line(self, line):
self.cpp.writeline(line)
def render(self, clinic, signatures):
function = None
for o in signatures:
if isinstance(o, Function):
if function:
fail("You may specify at most one function per block.\nFound a block containing at least two:\n\t" + repr(function) + " and " + repr(o))
function = o
return self.render_function(clinic, function)
def docstring_for_c_string(self, f):
text, add, output = _text_accumulator()
# turn docstring into a properly quoted C string
for line in f.docstring.split('\n'):
add('"')
add(quoted_for_c_string(line))
add('\\n"\n')
if text[-2] == sig_end_marker:
# If we only have a signature, add the blank line that the
# __text_signature__ getter expects to be there.
add('"\\n"')
else:
text.pop()
add('"')
return ''.join(text)
def output_templates(self, f):
parameters = list(f.parameters.values())
assert parameters
assert isinstance(parameters[0].converter, self_converter)
del parameters[0]
converters = [p.converter for p in parameters]
has_option_groups = parameters and (parameters[0].group or parameters[-1].group)
default_return_converter = (not f.return_converter or
f.return_converter.type == 'PyObject *')
positional = parameters and parameters[-1].is_positional_only()
all_boring_objects = False # yes, this will be false if there are 0 parameters, it's fine
first_optional = len(parameters)
for i, p in enumerate(parameters):
c = p.converter
if type(c) != object_converter:
break
if c.format_unit != 'O':
break
if p.default is not unspecified:
first_optional = min(first_optional, i)
else:
all_boring_objects = True
new_or_init = f.kind in (METHOD_NEW, METHOD_INIT)
meth_o = (len(parameters) == 1 and
parameters[0].is_positional_only() and
not converters[0].is_optional() and
not new_or_init)
# we have to set these things before we're done:
#
# docstring_prototype
# docstring_definition
# impl_prototype
# methoddef_define
# parser_prototype
# parser_definition
# impl_definition
# cpp_if
# cpp_endif
# methoddef_ifndef
return_value_declaration = "PyObject *return_value = NULL;"
methoddef_define = normalize_snippet("""
#define {methoddef_name} \\
{{"{name}", (PyCFunction){c_basename}, {methoddef_flags}, {c_basename}__doc__}},
""")
if new_or_init and not f.docstring:
docstring_prototype = docstring_definition = ''
else:
docstring_prototype = normalize_snippet("""
PyDoc_VAR({c_basename}__doc__);
""")
docstring_definition = normalize_snippet("""
PyDoc_STRVAR({c_basename}__doc__,
{docstring});
""")
impl_definition = normalize_snippet("""
static {impl_return_type}
{c_basename}_impl({impl_parameters})
""")
impl_prototype = parser_prototype = parser_definition = None
parser_prototype_keyword = normalize_snippet("""
static PyObject *
{c_basename}({self_type}{self_name}, PyObject *args, PyObject *kwargs)
""")
parser_prototype_fastcall = normalize_snippet("""
static PyObject *
{c_basename}({self_type}{self_name}, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
""")
parser_prototype_varargs = normalize_snippet("""
static PyObject *
{c_basename}({self_type}{self_name}, PyObject *args)
""")
# parser_body_fields remembers the fields passed in to the
# previous call to parser_body. this is used for an awful hack.
parser_body_fields = ()
def parser_body(prototype, *fields):
nonlocal parser_body_fields
add, output = text_accumulator()
add(prototype)
parser_body_fields = fields
fields = list(fields)
fields.insert(0, normalize_snippet("""
{{
{return_value_declaration}
{declarations}
{initializers}
""") + "\n")
# just imagine--your code is here in the middle
fields.append(normalize_snippet("""
{modifications}
{return_value} = {c_basename}_impl({impl_arguments});
{return_conversion}
{exit_label}
{cleanup}
return return_value;
}}
"""))
for field in fields:
add('\n')
add(field)
return output()
def insert_keywords(s):
return linear_format(s, declarations=
'static const char * const _keywords[] = {{{keywords}, NULL}};\n'
'static _PyArg_Parser _parser = {{"{format_units}:{name}", _keywords, 0}};\n'
'{declarations}')
if not parameters:
# no parameters, METH_NOARGS
flags = "METH_NOARGS"
parser_prototype = normalize_snippet("""
static PyObject *
{c_basename}({self_type}{self_name}, PyObject *Py_UNUSED(ignored))
""")
parser_definition = parser_prototype
if default_return_converter:
parser_definition = parser_prototype + '\n' + normalize_snippet("""
{{
return {c_basename}_impl({impl_arguments});
}}
""")
else:
parser_definition = parser_body(parser_prototype)
elif meth_o:
flags = "METH_O"
if (isinstance(converters[0], object_converter) and
converters[0].format_unit == 'O'):
meth_o_prototype = normalize_snippet("""
static PyObject *
{c_basename}({impl_parameters})
""")
if default_return_converter:
# maps perfectly to METH_O, doesn't need a return converter.
# so we skip making a parse function
# and call directly into the impl function.
impl_prototype = parser_prototype = parser_definition = ''
impl_definition = meth_o_prototype
else:
# SLIGHT HACK
# use impl_parameters for the parser here!
parser_prototype = meth_o_prototype
parser_definition = parser_body(parser_prototype)
else:
argname = 'arg'
if parameters[0].name == argname:
argname += '_'
parser_prototype = normalize_snippet("""
static PyObject *
{c_basename}({self_type}{self_name}, PyObject *%s)
""" % argname)
parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) {{
goto exit;
}}
""" % argname, indent=4))
elif has_option_groups:
# positional parameters with option groups
# (we have to generate lots of PyArg_ParseTuple calls
# in a big switch statement)
flags = "METH_VARARGS"
parser_prototype = parser_prototype_varargs
parser_definition = parser_body(parser_prototype, ' {option_group_parsing}')
elif positional and all_boring_objects:
# positional-only, but no option groups,
# and nothing but normal objects:
# PyArg_UnpackTuple!
flags = "METH_VARARGS"
parser_prototype = parser_prototype_varargs
parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_UnpackTuple(args, "{name}",
{unpack_min}, {unpack_max},
{parse_arguments})) {{
goto exit;
}}
""", indent=4))
elif positional:
# positional-only, but no option groups
# we only need one call to PyArg_ParseTuple
flags = "METH_VARARGS"
parser_prototype = parser_prototype_varargs
parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_ParseTuple(args, "{format_units}:{name}",
{parse_arguments})) {{
goto exit;
}}
""", indent=4))
elif not new_or_init:
flags = "METH_FASTCALL"
parser_prototype = parser_prototype_fastcall
body = normalize_snippet("""
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
{parse_arguments})) {{
goto exit;
}}
""", indent=4)
parser_definition = parser_body(parser_prototype, body)
parser_definition = insert_keywords(parser_definition)
else:
# positional-or-keyword arguments
flags = "METH_VARARGS|METH_KEYWORDS"
parser_prototype = parser_prototype_keyword
body = normalize_snippet("""
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
{parse_arguments})) {{
goto exit;
}}
""", indent=4)
parser_definition = parser_body(parser_prototype, body)
parser_definition = insert_keywords(parser_definition)
if new_or_init:
methoddef_define = ''
if f.kind == METHOD_NEW:
parser_prototype = parser_prototype_keyword
else:
return_value_declaration = "int return_value = -1;"
parser_prototype = normalize_snippet("""
static int
{c_basename}({self_type}{self_name}, PyObject *args, PyObject *kwargs)
""")
fields = list(parser_body_fields)
parses_positional = 'METH_NOARGS' not in flags
parses_keywords = 'METH_KEYWORDS' in flags
if parses_keywords:
assert parses_positional
if not parses_keywords:
fields.insert(0, normalize_snippet("""
if ({self_type_check}!_PyArg_NoKeywords("{name}", kwargs)) {{
goto exit;
}}
""", indent=4))
if not parses_positional:
fields.insert(0, normalize_snippet("""
if ({self_type_check}!_PyArg_NoPositional("{name}", args)) {{
goto exit;
}}
""", indent=4))
parser_definition = parser_body(parser_prototype, *fields)
if parses_keywords:
parser_definition = insert_keywords(parser_definition)
if f.methoddef_flags:
flags += '|' + f.methoddef_flags
methoddef_define = methoddef_define.replace('{methoddef_flags}', flags)
methoddef_ifndef = ''
conditional = self.cpp.condition()
if not conditional:
cpp_if = cpp_endif = ''
else:
cpp_if = "#if " + conditional
cpp_endif = "#endif /* " + conditional + " */"
if methoddef_define and f.full_name not in clinic.ifndef_symbols:
clinic.ifndef_symbols.add(f.full_name)
methoddef_ifndef = normalize_snippet("""
#ifndef {methoddef_name}
#define {methoddef_name}
#endif /* !defined({methoddef_name}) */
""")
# add ';' to the end of parser_prototype and impl_prototype
# (they mustn't be None, but they could be an empty string.)
assert parser_prototype is not None
if parser_prototype:
assert not parser_prototype.endswith(';')
parser_prototype += ';'
if impl_prototype is None:
impl_prototype = impl_definition
if impl_prototype:
impl_prototype += ";"
parser_definition = parser_definition.replace("{return_value_declaration}", return_value_declaration)
d = {
"docstring_prototype" : docstring_prototype,
"docstring_definition" : docstring_definition,
"impl_prototype" : impl_prototype,
"methoddef_define" : methoddef_define,
"parser_prototype" : parser_prototype,
"parser_definition" : parser_definition,
"impl_definition" : impl_definition,
"cpp_if" : cpp_if,
"cpp_endif" : cpp_endif,
"methoddef_ifndef" : methoddef_ifndef,
}
# make sure we didn't forget to assign something,
# and wrap each non-empty value in \n's
d2 = {}
for name, value in d.items():
assert value is not None, "got a None value for template " + repr(name)
if value:
value = '\n' + value + '\n'
d2[name] = value
return d2
@staticmethod
def group_to_variable_name(group):
adjective = "left_" if group < 0 else "right_"
return "group_" + adjective + str(abs(group))
def render_option_group_parsing(self, f, template_dict):
# positional only, grouped, optional arguments!
# can be optional on the left or right.
# here's an example:
#
# [ [ [ A1 A2 ] B1 B2 B3 ] C1 C2 ] D1 D2 D3 [ E1 E2 E3 [ F1 F2 F3 ] ]
#
# Here group D are required, and all other groups are optional.
# (Group D's "group" is actually None.)
# We can figure out which sets of arguments we have based on
# how many arguments are in the tuple.
#
# Note that you need to count up on both sides. For example,
# you could have groups C+D, or C+D+E, or C+D+E+F.
#
# What if the number of arguments leads us to an ambiguous result?
# Clinic prefers groups on the left. So in the above example,
# five arguments would map to B+C, not C+D.
add, output = text_accumulator()
parameters = list(f.parameters.values())
if isinstance(parameters[0].converter, self_converter):
del parameters[0]
groups = []
group = None
left = []
right = []
required = []
last = unspecified
for p in parameters:
group_id = p.group
if group_id != last:
last = group_id
group = []
if group_id < 0:
left.append(group)
elif group_id == 0:
group = required
else:
right.append(group)
group.append(p)
count_min = sys.maxsize
count_max = -1
add("switch (PyTuple_GET_SIZE(args)) {\n")
for subset in permute_optional_groups(left, required, right):
count = len(subset)
count_min = min(count_min, count)
count_max = max(count_max, count)
if count == 0:
add(""" case 0:
break;
""")
continue
group_ids = {p.group for p in subset} # eliminate duplicates
d = {}
d['count'] = count
d['name'] = f.name
d['format_units'] = "".join(p.converter.format_unit for p in subset)
parse_arguments = []
for p in subset:
p.converter.parse_argument(parse_arguments)
d['parse_arguments'] = ", ".join(parse_arguments)
group_ids.discard(0)
lines = [self.group_to_variable_name(g) + " = 1;" for g in group_ids]
lines = "\n".join(lines)
s = """
case {count}:
if (!PyArg_ParseTuple(args, "{format_units}:{name}", {parse_arguments})) {{
goto exit;
}}
{group_booleans}
break;
"""[1:]
s = linear_format(s, group_booleans=lines)
s = s.format_map(d)
add(s)
add(" default:\n")
s = ' PyErr_SetString(PyExc_TypeError, "{} requires {} to {} arguments");\n'
add(s.format(f.full_name, count_min, count_max))
add(' goto exit;\n')
add("}")
template_dict['option_group_parsing'] = format_escape(output())
def render_function(self, clinic, f):
if not f:
return ""
add, output = text_accumulator()
data = CRenderData()
assert f.parameters, "We should always have a 'self' at this point!"
parameters = f.render_parameters
converters = [p.converter for p in parameters]
templates = self.output_templates(f)
f_self = parameters[0]
selfless = parameters[1:]
assert isinstance(f_self.converter, self_converter), "No self parameter in " + repr(f.full_name) + "!"
last_group = 0
first_optional = len(selfless)
positional = selfless and selfless[-1].is_positional_only()
new_or_init = f.kind in (METHOD_NEW, METHOD_INIT)
default_return_converter = (not f.return_converter or
f.return_converter.type == 'PyObject *')
has_option_groups = False
# offset i by -1 because first_optional needs to ignore self
for i, p in enumerate(parameters, -1):
c = p.converter
if (i != -1) and (p.default is not unspecified):
first_optional = min(first_optional, i)
# insert group variable
group = p.group
if last_group != group:
last_group = group
if group:
group_name = self.group_to_variable_name(group)
data.impl_arguments.append(group_name)
data.declarations.append("int " + group_name + " = 0;")
data.impl_parameters.append("int " + group_name)
has_option_groups = True
c.render(p, data)
if has_option_groups and (not positional):
fail("You cannot use optional groups ('[' and ']')\nunless all parameters are positional-only ('/').")
# HACK
# when we're METH_O, but have a custom return converter,
# we use "impl_parameters" for the parsing function
# because that works better. but that means we must
# suppress actually declaring the impl's parameters
# as variables in the parsing function. but since it's
# METH_O, we have exactly one anyway, so we know exactly
# where it is.
if ("METH_O" in templates['methoddef_define'] and
'{impl_parameters}' in templates['parser_prototype']):
data.declarations.pop(0)
template_dict = {}
full_name = f.full_name
template_dict['full_name'] = full_name
if new_or_init:
name = f.cls.name
else:
name = f.name
template_dict['name'] = name
if f.c_basename:
c_basename = f.c_basename
else:
fields = full_name.split(".")
if fields[-1] == '__new__':
fields.pop()
c_basename = "_".join(fields)
template_dict['c_basename'] = c_basename
methoddef_name = "{}_METHODDEF".format(c_basename.upper())
template_dict['methoddef_name'] = methoddef_name
template_dict['docstring'] = self.docstring_for_c_string(f)
template_dict['self_name'] = template_dict['self_type'] = template_dict['self_type_check'] = ''
f_self.converter.set_template_dict(template_dict)
f.return_converter.render(f, data)
template_dict['impl_return_type'] = f.return_converter.type
template_dict['declarations'] = format_escape("\n".join(data.declarations))
template_dict['initializers'] = "\n\n".join(data.initializers)
template_dict['modifications'] = '\n\n'.join(data.modifications)
template_dict['keywords'] = '"' + '", "'.join(data.keywords) + '"'
template_dict['format_units'] = ''.join(data.format_units)
template_dict['parse_arguments'] = ', '.join(data.parse_arguments)
template_dict['impl_parameters'] = ", ".join(data.impl_parameters)
template_dict['impl_arguments'] = ", ".join(data.impl_arguments)
template_dict['return_conversion'] = format_escape("".join(data.return_conversion).rstrip())
template_dict['cleanup'] = format_escape("".join(data.cleanup))
template_dict['return_value'] = data.return_value
# used by unpack tuple code generator
ignore_self = -1 if isinstance(converters[0], self_converter) else 0
unpack_min = first_optional
unpack_max = len(selfless)
template_dict['unpack_min'] = str(unpack_min)
template_dict['unpack_max'] = str(unpack_max)
if has_option_groups:
self.render_option_group_parsing(f, template_dict)
# buffers, not destination
for name, destination in clinic.destination_buffers.items():
template = templates[name]
if has_option_groups:
template = linear_format(template,
option_group_parsing=template_dict['option_group_parsing'])
template = linear_format(template,
declarations=template_dict['declarations'],
return_conversion=template_dict['return_conversion'],
initializers=template_dict['initializers'],
modifications=template_dict['modifications'],
cleanup=template_dict['cleanup'],
)
# Only generate the "exit:" label
# if we have any gotos
need_exit_label = "goto exit;" in template
template = linear_format(template,
exit_label="exit:" if need_exit_label else ''
)
s = template.format_map(template_dict)
# mild hack:
# reflow long impl declarations
if name in {"impl_prototype", "impl_definition"}:
s = wrap_declarations(s)
if clinic.line_prefix:
s = indent_all_lines(s, clinic.line_prefix)
if clinic.line_suffix:
s = suffix_all_lines(s, clinic.line_suffix)
destination.append(s)
return clinic.get_destination('block').dump()
@contextlib.contextmanager
def OverrideStdioWith(stdout):
saved_stdout = sys.stdout
sys.stdout = stdout
try:
yield
finally:
assert sys.stdout is stdout
sys.stdout = saved_stdout
def create_regex(before, after, word=True, whole_line=True):
"""Create an re object for matching marker lines."""
group_re = r"\w+" if word else ".+"
pattern = r'{}({}){}'
if whole_line:
pattern = '^' + pattern + '$'
pattern = pattern.format(re.escape(before), group_re, re.escape(after))
return re.compile(pattern)
class Block:
r"""
Represents a single block of text embedded in
another file. If dsl_name is None, the block represents
verbatim text, raw original text from the file, in
which case "input" will be the only non-false member.
If dsl_name is not None, the block represents a Clinic
block.
input is always str, with embedded \n characters.
input represents the original text from the file;
if it's a Clinic block, it is the original text with
the body_prefix and redundant leading whitespace removed.
dsl_name is either str or None. If str, it's the text
found on the start line of the block between the square
brackets.
signatures is either list or None. If it's a list,
it may only contain clinic.Module, clinic.Class, and
clinic.Function objects. At the moment it should
contain at most one of each.
output is either str or None. If str, it's the output
from this block, with embedded '\n' characters.
indent is either str or None. It's the leading whitespace
that was found on every line of input. (If body_prefix is
not empty, this is the indent *after* removing the
body_prefix.)
preindent is either str or None. It's the whitespace that
was found in front of every line of input *before* the
"body_prefix" (see the Language object). If body_prefix
is empty, preindent must always be empty too.
To illustrate indent and preindent: Assume that '_'
represents whitespace. If the block processed was in a
Python file, and looked like this:
____#/*[python]
____#__for a in range(20):
____#____print(a)
____#[python]*/
"preindent" would be "____" and "indent" would be "__".
"""
def __init__(self, input, dsl_name=None, signatures=None, output=None, indent='', preindent=''):
assert isinstance(input, str)
self.input = input
self.dsl_name = dsl_name
self.signatures = signatures or []
self.output = output
self.indent = indent
self.preindent = preindent
def __repr__(self):
dsl_name = self.dsl_name or "text"
def summarize(s):
s = repr(s)
if len(s) > 30:
return s[:26] + "..." + s[0]
return s
return "".join((
"<Block ", dsl_name, " input=", summarize(self.input), " output=", summarize(self.output), ">"))
class BlockParser:
"""
Block-oriented parser for Argument Clinic.
Iterator, yields Block objects.
"""
def __init__(self, input, language, *, verify=True):
"""
"input" should be a str object
with embedded \n characters.
"language" should be a Language object.
"""
language.validate()
self.input = collections.deque(reversed(input.splitlines(keepends=True)))
self.block_start_line_number = self.line_number = 0
self.language = language
before, _, after = language.start_line.partition('{dsl_name}')
assert _ == '{dsl_name}'
self.find_start_re = create_regex(before, after, whole_line=False)
self.start_re = create_regex(before, after)
self.verify = verify
self.last_checksum_re = None
self.last_dsl_name = None
self.dsl_name = None
self.first_block = True
def __iter__(self):
return self
def __next__(self):
while True:
if not self.input:
raise StopIteration
if self.dsl_name:
return_value = self.parse_clinic_block(self.dsl_name)
self.dsl_name = None
self.first_block = False
return return_value
block = self.parse_verbatim_block()
if self.first_block and not block.input:
continue
self.first_block = False
return block
def is_start_line(self, line):
match = self.start_re.match(line.lstrip())
return match.group(1) if match else None
def _line(self, lookahead=False):
self.line_number += 1
line = self.input.pop()
if not lookahead:
self.language.parse_line(line)
return line
def parse_verbatim_block(self):
add, output = text_accumulator()
self.block_start_line_number = self.line_number
while self.input:
line = self._line()
dsl_name = self.is_start_line(line)
if dsl_name:
self.dsl_name = dsl_name
break
add(line)
return Block(output())
def parse_clinic_block(self, dsl_name):
input_add, input_output = text_accumulator()
self.block_start_line_number = self.line_number + 1
stop_line = self.language.stop_line.format(dsl_name=dsl_name)
body_prefix = self.language.body_prefix.format(dsl_name=dsl_name)
def is_stop_line(line):
# make sure to recognize stop line even if it
# doesn't end with EOL (it could be the very end of the file)
if not line.startswith(stop_line):
return False
remainder = line[len(stop_line):]
return (not remainder) or remainder.isspace()
# consume body of program
while self.input:
line = self._line()
if is_stop_line(line) or self.is_start_line(line):
break
if body_prefix:
line = line.lstrip()
assert line.startswith(body_prefix)
line = line[len(body_prefix):]
input_add(line)
# consume output and checksum line, if present.
if self.last_dsl_name == dsl_name:
checksum_re = self.last_checksum_re
else:
before, _, after = self.language.checksum_line.format(dsl_name=dsl_name, arguments='{arguments}').partition('{arguments}')
assert _ == '{arguments}'
checksum_re = create_regex(before, after, word=False)
self.last_dsl_name = dsl_name
self.last_checksum_re = checksum_re
# scan forward for checksum line
output_add, output_output = text_accumulator()
arguments = None
while self.input:
line = self._line(lookahead=True)
match = checksum_re.match(line.lstrip())
arguments = match.group(1) if match else None
if arguments:
break
output_add(line)
if self.is_start_line(line):
break
output = output_output()
if arguments:
d = {}
for field in shlex.split(arguments):
name, equals, value = field.partition('=')
if not equals:
fail("Mangled Argument Clinic marker line: {!r}".format(line))
d[name.strip()] = value.strip()
if self.verify:
if 'input' in d:
checksum = d['output']
input_checksum = d['input']
else:
checksum = d['checksum']
input_checksum = None
computed = compute_checksum(output, len(checksum))
if checksum != computed:
fail("Checksum mismatch!\nExpected: {}\nComputed: {}\n"
"Suggested fix: remove all generated code including "
"the end marker,\n"
"or use the '-f' option."
.format(checksum, computed))
else:
# put back output
output_lines = output.splitlines(keepends=True)
self.line_number -= len(output_lines)
self.input.extend(reversed(output_lines))
output = None
return Block(input_output(), dsl_name, output=output)
class BlockPrinter:
def __init__(self, language, f=None):
self.language = language
self.f = f or io.StringIO()
def print_block(self, block):
input = block.input
output = block.output
dsl_name = block.dsl_name
write = self.f.write
assert not ((dsl_name == None) ^ (output == None)), "you must specify dsl_name and output together, dsl_name " + repr(dsl_name)
if not dsl_name:
write(input)
return
write(self.language.start_line.format(dsl_name=dsl_name))
write("\n")
body_prefix = self.language.body_prefix.format(dsl_name=dsl_name)
if not body_prefix:
write(input)
else:
for line in input.split('\n'):
write(body_prefix)
write(line)
write("\n")
write(self.language.stop_line.format(dsl_name=dsl_name))
write("\n")
input = ''.join(block.input)
output = ''.join(block.output)
if output:
if not output.endswith('\n'):
output += '\n'
write(output)
arguments="output={} input={}".format(compute_checksum(output, 16), compute_checksum(input, 16))
write(self.language.checksum_line.format(dsl_name=dsl_name, arguments=arguments))
write("\n")
def write(self, text):
self.f.write(text)
class BufferSeries:
"""
Behaves like a "defaultlist".
When you ask for an index that doesn't exist yet,
the object grows the list until that item exists.
So o[n] will always work.
Supports negative indices for actual items.
e.g. o[-1] is an element immediately preceding o[0].
"""
def __init__(self):
self._start = 0
self._array = []
self._constructor = _text_accumulator
def __getitem__(self, i):
i -= self._start
if i < 0:
self._start += i
prefix = [self._constructor() for x in range(-i)]
self._array = prefix + self._array
i = 0
while i >= len(self._array):
self._array.append(self._constructor())
return self._array[i]
def clear(self):
for ta in self._array:
ta._text.clear()
def dump(self):
texts = [ta.output() for ta in self._array]
return "".join(texts)
class Destination:
def __init__(self, name, type, clinic, *args):
self.name = name
self.type = type
self.clinic = clinic
valid_types = ('buffer', 'file', 'suppress')
if type not in valid_types:
fail("Invalid destination type " + repr(type) + " for " + name + " , must be " + ', '.join(valid_types))
extra_arguments = 1 if type == "file" else 0
if len(args) < extra_arguments:
fail("Not enough arguments for destination " + name + " new " + type)
if len(args) > extra_arguments:
fail("Too many arguments for destination " + name + " new " + type)
if type =='file':
d = {}
filename = clinic.filename
d['path'] = filename
dirname, basename = os.path.split(filename)
if not dirname:
dirname = '.'
d['dirname'] = dirname
d['basename'] = basename
d['basename_root'], d['basename_extension'] = os.path.splitext(filename)
self.filename = args[0].format_map(d)
self.buffers = BufferSeries()
def __repr__(self):
if self.type == 'file':
file_repr = " " + repr(self.filename)
else:
file_repr = ''
return "".join(("<Destination ", self.name, " ", self.type, file_repr, ">"))
def clear(self):
if self.type != 'buffer':
fail("Can't clear destination" + self.name + " , it's not of type buffer")
self.buffers.clear()
def dump(self):
return self.buffers.dump()
# maps strings to Language objects.
# "languages" maps the name of the language ("C", "Python").
# "extensions" maps the file extension ("c", "py").
languages = { 'C': CLanguage, 'Python': PythonLanguage }
extensions = { name: CLanguage for name in "c cc cpp cxx h hh hpp hxx".split() }
extensions['py'] = PythonLanguage
# maps strings to callables.
# these callables must be of the form:
# def foo(name, default, *, ...)
# The callable may have any number of keyword-only parameters.
# The callable must return a CConverter object.
# The callable should not call builtins.print.
converters = {}
# maps strings to callables.
# these callables follow the same rules as those for "converters" above.
# note however that they will never be called with keyword-only parameters.
legacy_converters = {}
# maps strings to callables.
# these callables must be of the form:
# def foo(*, ...)
# The callable may have any number of keyword-only parameters.
# The callable must return a CConverter object.
# The callable should not call builtins.print.
return_converters = {}
clinic = None
class Clinic:
presets_text = """
preset block
everything block
methoddef_ifndef buffer 1
docstring_prototype suppress
parser_prototype suppress
cpp_if suppress
cpp_endif suppress
preset original
everything block
methoddef_ifndef buffer 1
docstring_prototype suppress
parser_prototype suppress
cpp_if suppress
cpp_endif suppress
preset file
everything file
methoddef_ifndef file 1
docstring_prototype suppress
parser_prototype suppress
impl_definition block
preset buffer
everything buffer
methoddef_ifndef buffer 1
impl_definition block
docstring_prototype suppress
impl_prototype suppress
parser_prototype suppress
preset partial-buffer
everything buffer
methoddef_ifndef buffer 1
docstring_prototype block
impl_prototype suppress
methoddef_define block
parser_prototype block
impl_definition block
"""
def __init__(self, language, printer=None, *, force=False, verify=True, filename=None):
# maps strings to Parser objects.
# (instantiated from the "parsers" global.)
self.parsers = {}
self.language = language
if printer:
fail("Custom printers are broken right now")
self.printer = printer or BlockPrinter(language)
self.verify = verify
self.force = force
self.filename = filename
self.modules = collections.OrderedDict()
self.classes = collections.OrderedDict()
self.functions = []
self.line_prefix = self.line_suffix = ''
self.destinations = {}
self.add_destination("block", "buffer")
self.add_destination("suppress", "suppress")
self.add_destination("buffer", "buffer")
if filename:
self.add_destination("file", "file", "{dirname}/clinic/{basename}.h")
d = self.get_destination_buffer
self.destination_buffers = collections.OrderedDict((
('cpp_if', d('file')),
('docstring_prototype', d('suppress')),
('docstring_definition', d('file')),
('methoddef_define', d('file')),
('impl_prototype', d('file')),
('parser_prototype', d('suppress')),
('parser_definition', d('file')),
('cpp_endif', d('file')),
('methoddef_ifndef', d('file', 1)),
('impl_definition', d('block')),
))
self.destination_buffers_stack = []
self.ifndef_symbols = set()
self.presets = {}
preset = None
for line in self.presets_text.strip().split('\n'):
line = line.strip()
if not line:
continue
name, value, *options = line.split()
if name == 'preset':
self.presets[value] = preset = collections.OrderedDict()
continue
if len(options):
index = int(options[0])
else:
index = 0
buffer = self.get_destination_buffer(value, index)
if name == 'everything':
for name in self.destination_buffers:
preset[name] = buffer
continue
assert name in self.destination_buffers
preset[name] = buffer
global clinic
clinic = self
def add_destination(self, name, type, *args):
if name in self.destinations:
fail("Destination already exists: " + repr(name))
self.destinations[name] = Destination(name, type, self, *args)
def get_destination(self, name):
d = self.destinations.get(name)
if not d:
fail("Destination does not exist: " + repr(name))
return d
def get_destination_buffer(self, name, item=0):
d = self.get_destination(name)
return d.buffers[item]
def parse(self, input):
printer = self.printer
self.block_parser = BlockParser(input, self.language, verify=self.verify)
for block in self.block_parser:
dsl_name = block.dsl_name
if dsl_name:
if dsl_name not in self.parsers:
assert dsl_name in parsers, "No parser to handle {!r} block.".format(dsl_name)
self.parsers[dsl_name] = parsers[dsl_name](self)
parser = self.parsers[dsl_name]
try:
parser.parse(block)
except Exception:
fail('Exception raised during parsing:\n' +
traceback.format_exc().rstrip())
printer.print_block(block)
second_pass_replacements = {}
# these are destinations not buffers
for name, destination in self.destinations.items():
if destination.type == 'suppress':
continue
output = destination.dump()
if output:
block = Block("", dsl_name="clinic", output=output)
if destination.type == 'buffer':
block.input = "dump " + name + "\n"
warn("Destination buffer " + repr(name) + " not empty at end of file, emptying.")
printer.write("\n")
printer.print_block(block)
continue
if destination.type == 'file':
try:
dirname = os.path.dirname(destination.filename)
try:
os.makedirs(dirname)
except FileExistsError:
if not os.path.isdir(dirname):
fail("Can't write to destination {}, "
"can't make directory {}!".format(
destination.filename, dirname))
if self.verify:
with open(destination.filename, "rt") as f:
parser_2 = BlockParser(f.read(), language=self.language)
blocks = list(parser_2)
if (len(blocks) != 1) or (blocks[0].input != 'preserve\n'):
fail("Modified destination file " + repr(destination.filename) + ", not overwriting!")
except FileNotFoundError:
pass
block.input = 'preserve\n'
printer_2 = BlockPrinter(self.language)
printer_2.print_block(block)
with open(destination.filename, "wt") as f:
f.write(printer_2.f.getvalue())
continue
text = printer.f.getvalue()
if second_pass_replacements:
printer_2 = BlockPrinter(self.language)
parser_2 = BlockParser(text, self.language)
changed = False
for block in parser_2:
if block.dsl_name:
for id, replacement in second_pass_replacements.items():
if id in block.output:
changed = True
block.output = block.output.replace(id, replacement)
printer_2.print_block(block)
if changed:
text = printer_2.f.getvalue()
return text
def _module_and_class(self, fields):
"""
fields should be an iterable of field names.
returns a tuple of (module, class).
the module object could actually be self (a clinic object).
this function is only ever used to find the parent of where
a new class/module should go.
"""
in_classes = False
parent = module = self
cls = None
so_far = []
for field in fields:
so_far.append(field)
if not in_classes:
child = parent.modules.get(field)
if child:
parent = module = child
continue
in_classes = True
if not hasattr(parent, 'classes'):
return module, cls
child = parent.classes.get(field)
if not child:
fail('Parent class or module ' + '.'.join(so_far) + " does not exist.")
cls = parent = child
return module, cls
def parse_file(filename, *, force=False, verify=True, output=None, encoding='utf-8'):
extension = os.path.splitext(filename)[1][1:]
if not extension:
fail("Can't extract file type for file " + repr(filename))
try:
language = extensions[extension](filename)
except KeyError:
fail("Can't identify file type for file " + repr(filename))
with open(filename, 'r', encoding=encoding) as f:
raw = f.read()
# exit quickly if there are no clinic markers in the file
find_start_re = BlockParser("", language).find_start_re
if not find_start_re.search(raw):
return
clinic = Clinic(language, force=force, verify=verify, filename=filename)
cooked = clinic.parse(raw)
if (cooked == raw) and not force:
return
directory = os.path.dirname(filename) or '.'
with tempfile.TemporaryDirectory(prefix="clinic", dir=directory) as tmpdir:
bytes = cooked.encode(encoding)
tmpfilename = os.path.join(tmpdir, os.path.basename(filename))
with open(tmpfilename, "wb") as f:
f.write(bytes)
os.replace(tmpfilename, output or filename)
def compute_checksum(input, length=None):
input = input or ''
s = hashlib.sha1(input.encode('utf-8')).hexdigest()
if length:
s = s[:length]
return s
class PythonParser:
def __init__(self, clinic):
pass
def parse(self, block):
s = io.StringIO()
with OverrideStdioWith(s):
exec(block.input)
block.output = s.getvalue()
class Module:
def __init__(self, name, module=None):
self.name = name
self.module = self.parent = module
self.modules = collections.OrderedDict()
self.classes = collections.OrderedDict()
self.functions = []
def __repr__(self):
return "<clinic.Module " + repr(self.name) + " at " + str(id(self)) + ">"
class Class:
def __init__(self, name, module=None, cls=None, typedef=None, type_object=None):
self.name = name
self.module = module
self.cls = cls
self.typedef = typedef
self.type_object = type_object
self.parent = cls or module
self.classes = collections.OrderedDict()
self.functions = []
def __repr__(self):
return "<clinic.Class " + repr(self.name) + " at " + str(id(self)) + ">"
unsupported_special_methods = set("""
__abs__
__add__
__and__
__bytes__
__call__
__complex__
__delitem__
__divmod__
__eq__
__float__
__floordiv__
__ge__
__getattr__
__getattribute__
__getitem__
__gt__
__hash__
__iadd__
__iand__
__ifloordiv__
__ilshift__
__imatmul__
__imod__
__imul__
__index__
__int__
__invert__
__ior__
__ipow__
__irshift__
__isub__
__iter__
__itruediv__
__ixor__
__le__
__len__
__lshift__
__lt__
__matmul__
__mod__
__mul__
__neg__
__new__
__next__
__or__
__pos__
__pow__
__radd__
__rand__
__rdivmod__
__repr__
__rfloordiv__
__rlshift__
__rmatmul__
__rmod__
__rmul__
__ror__
__round__
__rpow__
__rrshift__
__rshift__
__rsub__
__rtruediv__
__rxor__
__setattr__
__setitem__
__str__
__sub__
__truediv__
__xor__
""".strip().split())
INVALID, CALLABLE, STATIC_METHOD, CLASS_METHOD, METHOD_INIT, METHOD_NEW = """
INVALID, CALLABLE, STATIC_METHOD, CLASS_METHOD, METHOD_INIT, METHOD_NEW
""".replace(",", "").strip().split()
class Function:
"""
Mutable duck type for inspect.Function.
docstring - a str containing
* embedded line breaks
* text outdented to the left margin
* no trailing whitespace.
It will always be true that
(not docstring) or ((not docstring[0].isspace()) and (docstring.rstrip() == docstring))
"""
def __init__(self, parameters=None, *, name,
module, cls=None, c_basename=None,
full_name=None,
return_converter, return_annotation=_empty,
docstring=None, kind=CALLABLE, coexist=False,
docstring_only=False):
self.parameters = parameters or collections.OrderedDict()
self.return_annotation = return_annotation
self.name = name
self.full_name = full_name
self.module = module
self.cls = cls
self.parent = cls or module
self.c_basename = c_basename
self.return_converter = return_converter
self.docstring = docstring or ''
self.kind = kind
self.coexist = coexist
self.self_converter = None
# docstring_only means "don't generate a machine-readable
# signature, just a normal docstring". it's True for
# functions with optional groups because we can't represent
# those accurately with inspect.Signature in 3.4.
self.docstring_only = docstring_only
self.rendered_parameters = None
__render_parameters__ = None
@property
def render_parameters(self):
if not self.__render_parameters__:
self.__render_parameters__ = l = []
for p in self.parameters.values():
p = p.copy()
p.converter.pre_render()
l.append(p)
return self.__render_parameters__
@property
def methoddef_flags(self):
if self.kind in (METHOD_INIT, METHOD_NEW):
return None
flags = []
if self.kind == CLASS_METHOD:
flags.append('METH_CLASS')
elif self.kind == STATIC_METHOD:
flags.append('METH_STATIC')
else:
assert self.kind == CALLABLE, "unknown kind: " + repr(self.kind)
if self.coexist:
flags.append('METH_COEXIST')
return '|'.join(flags)
def __repr__(self):
return '<clinic.Function ' + self.name + '>'
def copy(self, **overrides):
kwargs = {
'name': self.name, 'module': self.module, 'parameters': self.parameters,
'cls': self.cls, 'c_basename': self.c_basename,
'full_name': self.full_name,
'return_converter': self.return_converter, 'return_annotation': self.return_annotation,
'docstring': self.docstring, 'kind': self.kind, 'coexist': self.coexist,
'docstring_only': self.docstring_only,
}
kwargs.update(overrides)
f = Function(**kwargs)
parameters = collections.OrderedDict()
for name, value in f.parameters.items():
value = value.copy(function=f)
parameters[name] = value
f.parameters = parameters
return f
class Parameter:
"""
Mutable duck type of inspect.Parameter.
"""
def __init__(self, name, kind, *, default=_empty,
function, converter, annotation=_empty,
docstring=None, group=0):
self.name = name
self.kind = kind
self.default = default
self.function = function
self.converter = converter
self.annotation = annotation
self.docstring = docstring or ''
self.group = group
def __repr__(self):
return '<clinic.Parameter ' + self.name + '>'
def is_keyword_only(self):
return self.kind == inspect.Parameter.KEYWORD_ONLY
def is_positional_only(self):
return self.kind == inspect.Parameter.POSITIONAL_ONLY
def copy(self, **overrides):
kwargs = {
'name': self.name, 'kind': self.kind, 'default':self.default,
'function': self.function, 'converter': self.converter, 'annotation': self.annotation,
'docstring': self.docstring, 'group': self.group,
}
kwargs.update(overrides)
if 'converter' not in overrides:
converter = copy.copy(self.converter)
converter.function = kwargs['function']
kwargs['converter'] = converter
return Parameter(**kwargs)
class LandMine:
# try to access any
def __init__(self, message):
self.__message__ = message
def __repr__(self):
return '<LandMine ' + repr(self.__message__) + ">"
def __getattribute__(self, name):
if name in ('__repr__', '__message__'):
return super().__getattribute__(name)
# raise RuntimeError(repr(name))
fail("Stepped on a land mine, trying to access attribute " + repr(name) + ":\n" + self.__message__)
def add_c_converter(f, name=None):
if not name:
name = f.__name__
if not name.endswith('_converter'):
return f
name = name[:-len('_converter')]
converters[name] = f
return f
def add_default_legacy_c_converter(cls):
# automatically add converter for default format unit
# (but without stomping on the existing one if it's already
# set, in case you subclass)
if ((cls.format_unit not in ('O&', '')) and
(cls.format_unit not in legacy_converters)):
legacy_converters[cls.format_unit] = cls
return cls
def add_legacy_c_converter(format_unit, **kwargs):
"""
Adds a legacy converter.
"""
def closure(f):
if not kwargs:
added_f = f
else:
added_f = functools.partial(f, **kwargs)
if format_unit:
legacy_converters[format_unit] = added_f
return f
return closure
class CConverterAutoRegister(type):
def __init__(cls, name, bases, classdict):
add_c_converter(cls)
add_default_legacy_c_converter(cls)
class CConverter(metaclass=CConverterAutoRegister):
"""
For the init function, self, name, function, and default
must be keyword-or-positional parameters. All other
parameters must be keyword-only.
"""
# The C name to use for this variable.
name = None
# The Python name to use for this variable.
py_name = None
# The C type to use for this variable.
# 'type' should be a Python string specifying the type, e.g. "int".
# If this is a pointer type, the type string should end with ' *'.
type = None
# The Python default value for this parameter, as a Python value.
# Or the magic value "unspecified" if there is no default.
# Or the magic value "unknown" if this value is a cannot be evaluated
# at Argument-Clinic-preprocessing time (but is presumed to be valid
# at runtime).
default = unspecified
# If not None, default must be isinstance() of this type.
# (You can also specify a tuple of types.)
default_type = None
# "default" converted into a C value, as a string.
# Or None if there is no default.
c_default = None
# "default" converted into a Python value, as a string.
# Or None if there is no default.
py_default = None
# The default value used to initialize the C variable when
# there is no default, but not specifying a default may
# result in an "uninitialized variable" warning. This can
# easily happen when using option groups--although
# properly-written code won't actually use the variable,
# the variable does get passed in to the _impl. (Ah, if
# only dataflow analysis could inline the static function!)
#
# This value is specified as a string.
# Every non-abstract subclass should supply a valid value.
c_ignored_default = 'NULL'
# The C converter *function* to be used, if any.
# (If this is not None, format_unit must be 'O&'.)
converter = None
# Should Argument Clinic add a '&' before the name of
# the variable when passing it into the _impl function?
impl_by_reference = False
# Should Argument Clinic add a '&' before the name of
# the variable when passing it into PyArg_ParseTuple (AndKeywords)?
parse_by_reference = True
#############################################################
#############################################################
## You shouldn't need to read anything below this point to ##
## write your own converter functions. ##
#############################################################
#############################################################
# The "format unit" to specify for this variable when
# parsing arguments using PyArg_ParseTuple (AndKeywords).
# Custom converters should always use the default value of 'O&'.
format_unit = 'O&'
# What encoding do we want for this variable? Only used
# by format units starting with 'e'.
encoding = None
# Should this object be required to be a subclass of a specific type?
# If not None, should be a string representing a pointer to a
# PyTypeObject (e.g. "&PyUnicode_Type").
# Only used by the 'O!' format unit (and the "object" converter).
subclass_of = None
# Do we want an adjacent '_length' variable for this variable?
# Only used by format units ending with '#'.
length = False
# Should we show this parameter in the generated
# __text_signature__? This is *almost* always True.
# (It's only False for __new__, __init__, and METH_STATIC functions.)
show_in_signature = True
# Overrides the name used in a text signature.
# The name used for a "self" parameter must be one of
# self, type, or module; however users can set their own.
# This lets the self_converter overrule the user-settable
# name, *just* for the text signature.
# Only set by self_converter.
signature_name = None
# keep in sync with self_converter.__init__!
def __init__(self, name, py_name, function, default=unspecified, *, c_default=None, py_default=None, annotation=unspecified, **kwargs):
self.name = name
self.py_name = py_name
if default is not unspecified:
if self.default_type and not isinstance(default, (self.default_type, Unknown)):
if isinstance(self.default_type, type):
types_str = self.default_type.__name__
else:
types_str = ', '.join((cls.__name__ for cls in self.default_type))
fail("{}: default value {!r} for field {} is not of type {}".format(
self.__class__.__name__, default, name, types_str))
self.default = default
if c_default:
self.c_default = c_default
if py_default:
self.py_default = py_default
if annotation != unspecified:
fail("The 'annotation' parameter is not currently permitted.")
# this is deliberate, to prevent you from caching information
# about the function in the init.
# (that breaks if we get cloned.)
# so after this change we will noisily fail.
self.function = LandMine("Don't access members of self.function inside converter_init!")
self.converter_init(**kwargs)
self.function = function
def converter_init(self):
pass
def is_optional(self):
return (self.default is not unspecified)
def _render_self(self, parameter, data):
self.parameter = parameter
original_name = self.name
name = ensure_legal_c_identifier(original_name)
# impl_arguments
s = ("&" if self.impl_by_reference else "") + name
data.impl_arguments.append(s)
if self.length:
data.impl_arguments.append(self.length_name())
# impl_parameters
data.impl_parameters.append(self.simple_declaration(by_reference=self.impl_by_reference))
if self.length:
data.impl_parameters.append("Py_ssize_clean_t " + self.length_name())
def _render_non_self(self, parameter, data):
self.parameter = parameter
original_name = self.name
name = ensure_legal_c_identifier(original_name)
# declarations
d = self.declaration()
data.declarations.append(d)
# initializers
initializers = self.initialize()
if initializers:
data.initializers.append('/* initializers for ' + name + ' */\n' + initializers.rstrip())
# modifications
modifications = self.modify()
if modifications:
data.modifications.append('/* modifications for ' + name + ' */\n' + modifications.rstrip())
# keywords
if parameter.is_positional_only():
data.keywords.append('')
else:
data.keywords.append(parameter.name)
# format_units
if self.is_optional() and '|' not in data.format_units:
data.format_units.append('|')
if parameter.is_keyword_only() and '$' not in data.format_units:
data.format_units.append('$')
data.format_units.append(self.format_unit)
# parse_arguments
self.parse_argument(data.parse_arguments)
# cleanup
cleanup = self.cleanup()
if cleanup:
data.cleanup.append('/* Cleanup for ' + name + ' */\n' + cleanup.rstrip() + "\n")
def render(self, parameter, data):
"""
parameter is a clinic.Parameter instance.
data is a CRenderData instance.
"""
self._render_self(parameter, data)
self._render_non_self(parameter, data)
def length_name(self):
"""Computes the name of the associated "length" variable."""
if not self.length:
return None
return ensure_legal_c_identifier(self.name) + "_length"
# Why is this one broken out separately?
# For "positional-only" function parsing,
# which generates a bunch of PyArg_ParseTuple calls.
def parse_argument(self, list):
assert not (self.converter and self.encoding)
if self.format_unit == 'O&':
assert self.converter
list.append(self.converter)
if self.encoding:
list.append(c_repr(self.encoding))
elif self.subclass_of:
list.append(self.subclass_of)
legal_name = ensure_legal_c_identifier(self.name)
s = ("&" if self.parse_by_reference else "") + legal_name
list.append(s)
if self.length:
list.append("&" + self.length_name())
#
# All the functions after here are intended as extension points.
#
def simple_declaration(self, by_reference=False):
"""
Computes the basic declaration of the variable.
Used in computing the prototype declaration and the
variable declaration.
"""
prototype = [self.type]
if by_reference or not self.type.endswith('*'):
prototype.append(" ")
if by_reference:
prototype.append('*')
prototype.append(ensure_legal_c_identifier(self.name))
return "".join(prototype)
def declaration(self):
"""
The C statement to declare this variable.
"""
declaration = [self.simple_declaration()]
default = self.c_default
if not default and self.parameter.group:
default = self.c_ignored_default
if default:
declaration.append(" = ")
declaration.append(default)
declaration.append(";")
if self.length:
declaration.append('\nPy_ssize_clean_t ')
declaration.append(self.length_name())
declaration.append(';')
return "".join(declaration)
def initialize(self):
"""
The C statements required to set up this variable before parsing.
Returns a string containing this code indented at column 0.
If no initialization is necessary, returns an empty string.
"""
return ""
def modify(self):
"""
The C statements required to modify this variable after parsing.
Returns a string containing this code indented at column 0.
If no initialization is necessary, returns an empty string.
"""
return ""
def cleanup(self):
"""
The C statements required to clean up after this variable.
Returns a string containing this code indented at column 0.
If no cleanup is necessary, returns an empty string.
"""
return ""
def pre_render(self):
"""
A second initialization function, like converter_init,
called just before rendering.
You are permitted to examine self.function here.
"""
pass
class bool_converter(CConverter):
type = 'int'
default_type = bool
format_unit = 'p'
c_ignored_default = '0'
def converter_init(self):
if self.default is not unspecified:
self.default = bool(self.default)
self.c_default = str(int(self.default))
class char_converter(CConverter):
type = 'char'
default_type = (bytes, bytearray)
format_unit = 'c'
c_ignored_default = "'\0'"
def converter_init(self):
if isinstance(self.default, self.default_type) and (len(self.default) != 1):
fail("char_converter: illegal default value " + repr(self.default))
@add_legacy_c_converter('B', bitwise=True)
class unsigned_char_converter(CConverter):
type = 'unsigned char'
default_type = int
format_unit = 'b'
c_ignored_default = "'\0'"
def converter_init(self, *, bitwise=False):
if bitwise:
self.format_unit = 'B'
class byte_converter(unsigned_char_converter): pass
class short_converter(CConverter):
type = 'short'
default_type = int
format_unit = 'h'
c_ignored_default = "0"
class unsigned_short_converter(CConverter):
type = 'unsigned short'
default_type = int
format_unit = 'H'
c_ignored_default = "0"
def converter_init(self, *, bitwise=False):
if not bitwise:
fail("Unsigned shorts must be bitwise (for now).")
@add_legacy_c_converter('C', accept={str})
class int_converter(CConverter):
type = 'int'
default_type = int
format_unit = 'i'
c_ignored_default = "0"
def converter_init(self, *, accept={int}, type=None):
if accept == {str}:
self.format_unit = 'C'
elif accept != {int}:
fail("int_converter: illegal 'accept' argument " + repr(accept))
if type != None:
self.type = type
class unsigned_int_converter(CConverter):
type = 'unsigned int'
default_type = int
format_unit = 'I'
c_ignored_default = "0"
def converter_init(self, *, bitwise=False):
if not bitwise:
fail("Unsigned ints must be bitwise (for now).")
class long_converter(CConverter):
type = 'long'
default_type = int
format_unit = 'l'
c_ignored_default = "0"
class unsigned_long_converter(CConverter):
type = 'unsigned long'
default_type = int
format_unit = 'k'
c_ignored_default = "0"
def converter_init(self, *, bitwise=False):
if not bitwise:
fail("Unsigned longs must be bitwise (for now).")
class long_long_converter(CConverter):
type = 'long long'
default_type = int
format_unit = 'L'
c_ignored_default = "0"
class unsigned_long_long_converter(CConverter):
type = 'unsigned long long'
default_type = int
format_unit = 'K'
c_ignored_default = "0"
def converter_init(self, *, bitwise=False):
if not bitwise:
fail("Unsigned long long must be bitwise (for now).")
class Py_ssize_t_converter(CConverter):
type = 'Py_ssize_t'
default_type = int
format_unit = 'n'
c_ignored_default = "0"
class float_converter(CConverter):
type = 'float'
default_type = float
format_unit = 'f'
c_ignored_default = "0.0"
class double_converter(CConverter):
type = 'double'
default_type = float
format_unit = 'd'
c_ignored_default = "0.0"
class Py_complex_converter(CConverter):
type = 'Py_complex'
default_type = complex
format_unit = 'D'
c_ignored_default = "{0.0, 0.0}"
class object_converter(CConverter):
type = 'PyObject *'
format_unit = 'O'
def converter_init(self, *, converter=None, type=None, subclass_of=None):
if converter:
if subclass_of:
fail("object: Cannot pass in both 'converter' and 'subclass_of'")
self.format_unit = 'O&'
self.converter = converter
elif subclass_of:
self.format_unit = 'O!'
self.subclass_of = subclass_of
if type is not None:
self.type = type
#
# We define three conventions for buffer types in the 'accept' argument:
#
# buffer : any object supporting the buffer interface
# rwbuffer: any object supporting the buffer interface, but must be writeable
# robuffer: any object supporting the buffer interface, but must not be writeable
#
class buffer: pass
class rwbuffer: pass
class robuffer: pass
def str_converter_key(types, encoding, zeroes):
return (frozenset(types), bool(encoding), bool(zeroes))
str_converter_argument_map = {}
class str_converter(CConverter):
type = 'const char *'
default_type = (str, Null, NoneType)
format_unit = 's'
def converter_init(self, *, accept={str}, encoding=None, zeroes=False):
key = str_converter_key(accept, encoding, zeroes)
format_unit = str_converter_argument_map.get(key)
if not format_unit:
fail("str_converter: illegal combination of arguments", key)
self.format_unit = format_unit
self.length = bool(zeroes)
if encoding:
if self.default not in (Null, None, unspecified):
fail("str_converter: Argument Clinic doesn't support default values for encoded strings")
self.encoding = encoding
self.type = 'char *'
# sorry, clinic can't support preallocated buffers
# for es# and et#
self.c_default = "NULL"
def cleanup(self):
if self.encoding:
name = ensure_legal_c_identifier(self.name)
return "".join(["if (", name, ") {\n PyMem_FREE(", name, ");\n}\n"])
#
# This is the fourth or fifth rewrite of registering all the
# crazy string converter format units. Previous approaches hid
# bugs--generally mismatches between the semantics of the format
# unit and the arguments necessary to represent those semantics
# properly. Hopefully with this approach we'll get it 100% right.
#
# The r() function (short for "register") both registers the
# mapping from arguments to format unit *and* registers the
# legacy C converter for that format unit.
#
def r(format_unit, *, accept, encoding=False, zeroes=False):
if not encoding and format_unit != 's':
# add the legacy c converters here too.
#
# note: add_legacy_c_converter can't work for
# es, es#, et, or et#
# because of their extra encoding argument
#
# also don't add the converter for 's' because
# the metaclass for CConverter adds it for us.
kwargs = {}
if accept != {str}:
kwargs['accept'] = accept
if zeroes:
kwargs['zeroes'] = True
added_f = functools.partial(str_converter, **kwargs)
legacy_converters[format_unit] = added_f
d = str_converter_argument_map
key = str_converter_key(accept, encoding, zeroes)
if key in d:
sys.exit("Duplicate keys specified for str_converter_argument_map!")
d[key] = format_unit
r('es', encoding=True, accept={str})
r('es#', encoding=True, zeroes=True, accept={str})
r('et', encoding=True, accept={bytes, bytearray, str})
r('et#', encoding=True, zeroes=True, accept={bytes, bytearray, str})
r('s', accept={str})
r('s#', zeroes=True, accept={robuffer, str})
r('y', accept={robuffer})
r('y#', zeroes=True, accept={robuffer})
r('z', accept={str, NoneType})
r('z#', zeroes=True, accept={robuffer, str, NoneType})
del r
class PyBytesObject_converter(CConverter):
type = 'PyBytesObject *'
format_unit = 'S'
# accept = {bytes}
class PyByteArrayObject_converter(CConverter):
type = 'PyByteArrayObject *'
format_unit = 'Y'
# accept = {bytearray}
class unicode_converter(CConverter):
type = 'PyObject *'
default_type = (str, Null, NoneType)
format_unit = 'U'
@add_legacy_c_converter('u#', zeroes=True)
@add_legacy_c_converter('Z', accept={str, NoneType})
@add_legacy_c_converter('Z#', accept={str, NoneType}, zeroes=True)
class Py_UNICODE_converter(CConverter):
type = 'Py_UNICODE *'
default_type = (str, Null, NoneType)
format_unit = 'u'
def converter_init(self, *, accept={str}, zeroes=False):
format_unit = 'Z' if accept=={str, NoneType} else 'u'
if zeroes:
format_unit += '#'
self.length = True
self.format_unit = format_unit
@add_legacy_c_converter('s*', accept={str, buffer})
@add_legacy_c_converter('z*', accept={str, buffer, NoneType})
@add_legacy_c_converter('w*', accept={rwbuffer})
class Py_buffer_converter(CConverter):
type = 'Py_buffer'
format_unit = 'y*'
impl_by_reference = True
c_ignored_default = "{NULL, NULL}"
def converter_init(self, *, accept={buffer}):
if self.default not in (unspecified, None):
fail("The only legal default value for Py_buffer is None.")
self.c_default = self.c_ignored_default
if accept == {str, buffer, NoneType}:
format_unit = 'z*'
elif accept == {str, buffer}:
format_unit = 's*'
elif accept == {buffer}:
format_unit = 'y*'
elif accept == {rwbuffer}:
format_unit = 'w*'
else:
fail("Py_buffer_converter: illegal combination of arguments")
self.format_unit = format_unit
def cleanup(self):
name = ensure_legal_c_identifier(self.name)
return "".join(["if (", name, ".obj) {\n PyBuffer_Release(&", name, ");\n}\n"])
def correct_name_for_self(f):
if f.kind in (CALLABLE, METHOD_INIT):
if f.cls:
return "PyObject *", "self"
return "PyObject *", "module"
if f.kind == STATIC_METHOD:
return "void *", "null"
if f.kind in (CLASS_METHOD, METHOD_NEW):
return "PyTypeObject *", "type"
raise RuntimeError("Unhandled type of function f: " + repr(f.kind))
def required_type_for_self_for_parser(f):
type, _ = correct_name_for_self(f)
if f.kind in (METHOD_INIT, METHOD_NEW, STATIC_METHOD, CLASS_METHOD):
return type
return None
class self_converter(CConverter):
"""
A special-case converter:
this is the default converter used for "self".
"""
type = None
format_unit = ''
def converter_init(self, *, type=None):
self.specified_type = type
def pre_render(self):
f = self.function
default_type, default_name = correct_name_for_self(f)
self.signature_name = default_name
self.type = self.specified_type or self.type or default_type
kind = self.function.kind
new_or_init = kind in (METHOD_NEW, METHOD_INIT)
if (kind == STATIC_METHOD) or new_or_init:
self.show_in_signature = False
# tp_new (METHOD_NEW) functions are of type newfunc:
# typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
# PyTypeObject is a typedef for struct _typeobject.
#
# tp_init (METHOD_INIT) functions are of type initproc:
# typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
#
# All other functions generated by Argument Clinic are stored in
# PyMethodDef structures, in the ml_meth slot, which is of type PyCFunction:
# typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
# However! We habitually cast these functions to PyCFunction,
# since functions that accept keyword arguments don't fit this signature
# but are stored there anyway. So strict type equality isn't important
# for these functions.
#
# So:
#
# * The name of the first parameter to the impl and the parsing function will always
# be self.name.
#
# * The type of the first parameter to the impl will always be of self.type.
#
# * If the function is neither tp_new (METHOD_NEW) nor tp_init (METHOD_INIT):
# * The type of the first parameter to the parsing function is also self.type.
# This means that if you step into the parsing function, your "self" parameter
# is of the correct type, which may make debugging more pleasant.
#
# * Else if the function is tp_new (METHOD_NEW):
# * The type of the first parameter to the parsing function is "PyTypeObject *",
# so the type signature of the function call is an exact match.
# * If self.type != "PyTypeObject *", we cast the first parameter to self.type
# in the impl call.
#
# * Else if the function is tp_init (METHOD_INIT):
# * The type of the first parameter to the parsing function is "PyObject *",
# so the type signature of the function call is an exact match.
# * If self.type != "PyObject *", we cast the first parameter to self.type
# in the impl call.
@property
def parser_type(self):
return required_type_for_self_for_parser(self.function) or self.type
def render(self, parameter, data):
"""
parameter is a clinic.Parameter instance.
data is a CRenderData instance.
"""
if self.function.kind == STATIC_METHOD:
return
self._render_self(parameter, data)
if self.type != self.parser_type:
# insert cast to impl_argument[0], aka self.
# we know we're in the first slot in all the CRenderData lists,
# because we render parameters in order, and self is always first.
assert len(data.impl_arguments) == 1
assert data.impl_arguments[0] == self.name
data.impl_arguments[0] = '(' + self.type + ")" + data.impl_arguments[0]
def set_template_dict(self, template_dict):
template_dict['self_name'] = self.name
template_dict['self_type'] = self.parser_type
kind = self.function.kind
cls = self.function.cls
if ((kind in (METHOD_NEW, METHOD_INIT)) and cls and cls.typedef):
if kind == METHOD_NEW:
passed_in_type = self.name
else:
passed_in_type = 'Py_TYPE({})'.format(self.name)
line = '({passed_in_type} == {type_object}) &&\n '
d = {
'type_object': self.function.cls.type_object,
'passed_in_type': passed_in_type
}
template_dict['self_type_check'] = line.format_map(d)
def add_c_return_converter(f, name=None):
if not name:
name = f.__name__
if not name.endswith('_return_converter'):
return f
name = name[:-len('_return_converter')]
return_converters[name] = f
return f
class CReturnConverterAutoRegister(type):
def __init__(cls, name, bases, classdict):
add_c_return_converter(cls)
class CReturnConverter(metaclass=CReturnConverterAutoRegister):
# The C type to use for this variable.
# 'type' should be a Python string specifying the type, e.g. "int".
# If this is a pointer type, the type string should end with ' *'.
type = 'PyObject *'
# The Python default value for this parameter, as a Python value.
# Or the magic value "unspecified" if there is no default.
default = None
def __init__(self, *, py_default=None, **kwargs):
self.py_default = py_default
try:
self.return_converter_init(**kwargs)
except TypeError as e:
s = ', '.join(name + '=' + repr(value) for name, value in kwargs.items())
sys.exit(self.__class__.__name__ + '(' + s + ')\n' + str(e))
def return_converter_init(self):
pass
def declare(self, data, name="_return_value"):
line = []
add = line.append
add(self.type)
if not self.type.endswith('*'):
add(' ')
add(name + ';')
data.declarations.append(''.join(line))
data.return_value = name
def err_occurred_if(self, expr, data):
data.return_conversion.append('if (({}) && PyErr_Occurred()) {{\n goto exit;\n}}\n'.format(expr))
def err_occurred_if_null_pointer(self, variable, data):
data.return_conversion.append('if ({} == NULL) {{\n goto exit;\n}}\n'.format(variable))
def render(self, function, data):
"""
function is a clinic.Function instance.
data is a CRenderData instance.
"""
pass
add_c_return_converter(CReturnConverter, 'object')
class NoneType_return_converter(CReturnConverter):
def render(self, function, data):
self.declare(data)
data.return_conversion.append('''
if (_return_value != Py_None) {
goto exit;
}
return_value = Py_None;
Py_INCREF(Py_None);
'''.strip())
class bool_return_converter(CReturnConverter):
type = 'int'
def render(self, function, data):
self.declare(data)
self.err_occurred_if("_return_value == -1", data)
data.return_conversion.append('return_value = PyBool_FromLong((long)_return_value);\n')
class long_return_converter(CReturnConverter):
type = 'long'
conversion_fn = 'PyLong_FromLong'
cast = ''
unsigned_cast = ''
def render(self, function, data):
self.declare(data)
self.err_occurred_if("_return_value == {}-1".format(self.unsigned_cast), data)
data.return_conversion.append(
''.join(('return_value = ', self.conversion_fn, '(', self.cast, '_return_value);\n')))
class int_return_converter(long_return_converter):
type = 'int'
cast = '(long)'
class init_return_converter(long_return_converter):
"""
Special return converter for __init__ functions.
"""
type = 'int'
cast = '(long)'
def render(self, function, data):
pass
class unsigned_long_return_converter(long_return_converter):
type = 'unsigned long'
conversion_fn = 'PyLong_FromUnsignedLong'
unsigned_cast = '(unsigned long)'
class unsigned_int_return_converter(unsigned_long_return_converter):
type = 'unsigned int'
cast = '(unsigned long)'
unsigned_cast = '(unsigned int)'
class Py_ssize_t_return_converter(long_return_converter):
type = 'Py_ssize_t'
conversion_fn = 'PyLong_FromSsize_t'
class size_t_return_converter(long_return_converter):
type = 'size_t'
conversion_fn = 'PyLong_FromSize_t'
unsigned_cast = '(size_t)'
class double_return_converter(CReturnConverter):
type = 'double'
cast = ''
def render(self, function, data):
self.declare(data)
self.err_occurred_if("_return_value == -1.0", data)
data.return_conversion.append(
'return_value = PyFloat_FromDouble(' + self.cast + '_return_value);\n')
class float_return_converter(double_return_converter):
type = 'float'
cast = '(double)'
class DecodeFSDefault_return_converter(CReturnConverter):
type = 'char *'
def render(self, function, data):
self.declare(data)
self.err_occurred_if_null_pointer("_return_value", data)
data.return_conversion.append(
'return_value = PyUnicode_DecodeFSDefault(_return_value);\n')
def eval_ast_expr(node, globals, *, filename='-'):
"""
Takes an ast.Expr node. Compiles and evaluates it.
Returns the result of the expression.
globals represents the globals dict the expression
should see. (There's no equivalent for "locals" here.)
"""
if isinstance(node, ast.Expr):
node = node.value
node = ast.Expression(node)
co = compile(node, filename, 'eval')
fn = types.FunctionType(co, globals)
return fn()
class IndentStack:
def __init__(self):
self.indents = []
self.margin = None
def _ensure(self):
if not self.indents:
fail('IndentStack expected indents, but none are defined.')
def measure(self, line):
"""
Returns the length of the line's margin.
"""
if '\t' in line:
fail('Tab characters are illegal in the Argument Clinic DSL.')
stripped = line.lstrip()
if not len(stripped):
# we can't tell anything from an empty line
# so just pretend it's indented like our current indent
self._ensure()
return self.indents[-1]
return len(line) - len(stripped)
def infer(self, line):
"""
Infer what is now the current margin based on this line.
Returns:
1 if we have indented (or this is the first margin)
0 if the margin has not changed
-N if we have dedented N times
"""
indent = self.measure(line)
margin = ' ' * indent
if not self.indents:
self.indents.append(indent)
self.margin = margin
return 1
current = self.indents[-1]
if indent == current:
return 0
if indent > current:
self.indents.append(indent)
self.margin = margin
return 1
# indent < current
if indent not in self.indents:
fail("Illegal outdent.")
outdent_count = 0
while indent != current:
self.indents.pop()
current = self.indents[-1]
outdent_count -= 1
self.margin = margin
return outdent_count
@property
def depth(self):
"""
Returns how many margins are currently defined.
"""
return len(self.indents)
def indent(self, line):
"""
Indents a line by the currently defined margin.
"""
return self.margin + line
def dedent(self, line):
"""
Dedents a line by the currently defined margin.
(The inverse of 'indent'.)
"""
margin = self.margin
indent = self.indents[-1]
if not line.startswith(margin):
fail('Cannot dedent, line does not start with the previous margin:')
return line[indent:]
class DSLParser:
def __init__(self, clinic):
self.clinic = clinic
self.directives = {}
for name in dir(self):
# functions that start with directive_ are added to directives
_, s, key = name.partition("directive_")
if s:
self.directives[key] = getattr(self, name)
# functions that start with at_ are too, with an @ in front
_, s, key = name.partition("at_")
if s:
self.directives['@' + key] = getattr(self, name)
self.reset()
def reset(self):
self.function = None
self.state = self.state_dsl_start
self.parameter_indent = None
self.keyword_only = False
self.positional_only = False
self.group = 0
self.parameter_state = self.ps_start
self.seen_positional_with_default = False
self.indent = IndentStack()
self.kind = CALLABLE
self.coexist = False
self.parameter_continuation = ''
self.preserve_output = False
def directive_version(self, required):
global version
if version_comparitor(version, required) < 0:
fail("Insufficient Clinic version!\n Version: " + version + "\n Required: " + required)
def directive_module(self, name):
fields = name.split('.')
new = fields.pop()
module, cls = self.clinic._module_and_class(fields)
if cls:
fail("Can't nest a module inside a class!")
if name in module.classes:
fail("Already defined module " + repr(name) + "!")
m = Module(name, module)
module.modules[name] = m
self.block.signatures.append(m)
def directive_class(self, name, typedef, type_object):
fields = name.split('.')
in_classes = False
parent = self
name = fields.pop()
so_far = []
module, cls = self.clinic._module_and_class(fields)
parent = cls or module
if name in parent.classes:
fail("Already defined class " + repr(name) + "!")
c = Class(name, module, cls, typedef, type_object)
parent.classes[name] = c
self.block.signatures.append(c)
def directive_set(self, name, value):
if name not in ("line_prefix", "line_suffix"):
fail("unknown variable", repr(name))
value = value.format_map({
'block comment start': '/*',
'block comment end': '*/',
})
self.clinic.__dict__[name] = value
def directive_destination(self, name, command, *args):
if command == 'new':
self.clinic.add_destination(name, *args)
return
if command == 'clear':
self.clinic.get_destination(name).clear()
fail("unknown destination command", repr(command))
def directive_output(self, command_or_name, destination=''):
fd = self.clinic.destination_buffers
if command_or_name == "preset":
preset = self.clinic.presets.get(destination)
if not preset:
fail("Unknown preset " + repr(destination) + "!")
fd.update(preset)
return
if command_or_name == "push":
self.clinic.destination_buffers_stack.append(fd.copy())
return
if command_or_name == "pop":
if not self.clinic.destination_buffers_stack:
fail("Can't 'output pop', stack is empty!")
previous_fd = self.clinic.destination_buffers_stack.pop()
fd.update(previous_fd)
return
# secret command for debugging!
if command_or_name == "print":
self.block.output.append(pprint.pformat(fd))
self.block.output.append('\n')
return
d = self.clinic.get_destination(destination)
if command_or_name == "everything":
for name in list(fd):
fd[name] = d
return
if command_or_name not in fd:
fail("Invalid command / destination name " + repr(command_or_name) + ", must be one of:\n preset push pop print everything " + " ".join(fd))
fd[command_or_name] = d
def directive_dump(self, name):
self.block.output.append(self.clinic.get_destination(name).dump())
def directive_print(self, *args):
self.block.output.append(' '.join(args))
self.block.output.append('\n')
def directive_preserve(self):
if self.preserve_output:
fail("Can't have preserve twice in one block!")
self.preserve_output = True
def at_classmethod(self):
if self.kind is not CALLABLE:
fail("Can't set @classmethod, function is not a normal callable")
self.kind = CLASS_METHOD
def at_staticmethod(self):
if self.kind is not CALLABLE:
fail("Can't set @staticmethod, function is not a normal callable")
self.kind = STATIC_METHOD
def at_coexist(self):
if self.coexist:
fail("Called @coexist twice!")
self.coexist = True
def parse(self, block):
self.reset()
self.block = block
self.saved_output = self.block.output
block.output = []
block_start = self.clinic.block_parser.line_number
lines = block.input.split('\n')
for line_number, line in enumerate(lines, self.clinic.block_parser.block_start_line_number):
if '\t' in line:
fail('Tab characters are illegal in the Clinic DSL.\n\t' + repr(line), line_number=block_start)
self.state(line)
self.next(self.state_terminal)
self.state(None)
block.output.extend(self.clinic.language.render(clinic, block.signatures))
if self.preserve_output:
if block.output:
fail("'preserve' only works for blocks that don't produce any output!")
block.output = self.saved_output
@staticmethod
def ignore_line(line):
# ignore comment-only lines
if line.lstrip().startswith('#'):
return True
# Ignore empty lines too
# (but not in docstring sections!)
if not line.strip():
return True
return False
@staticmethod
def calculate_indent(line):
return len(line) - len(line.strip())
def next(self, state, line=None):
# real_print(self.state.__name__, "->", state.__name__, ", line=", line)
self.state = state
if line is not None:
self.state(line)
def state_dsl_start(self, line):
# self.block = self.ClinicOutputBlock(self)
if self.ignore_line(line):
return
# is it a directive?
fields = shlex.split(line)
directive_name = fields[0]
directive = self.directives.get(directive_name, None)
if directive:
try:
directive(*fields[1:])
except TypeError as e:
fail(str(e))
return
self.next(self.state_modulename_name, line)
def state_modulename_name(self, line):
# looking for declaration, which establishes the leftmost column
# line should be
# modulename.fnname [as c_basename] [-> return annotation]
# square brackets denote optional syntax.
#
# alternatively:
# modulename.fnname [as c_basename] = modulename.existing_fn_name
# clones the parameters and return converter from that
# function. you can't modify them. you must enter a
# new docstring.
#
# (but we might find a directive first!)
#
# this line is permitted to start with whitespace.
# we'll call this number of spaces F (for "function").
if not line.strip():
return
self.indent.infer(line)
# are we cloning?
before, equals, existing = line.rpartition('=')
if equals:
full_name, _, c_basename = before.partition(' as ')
full_name = full_name.strip()
c_basename = c_basename.strip()
existing = existing.strip()
if (is_legal_py_identifier(full_name) and
(not c_basename or is_legal_c_identifier(c_basename)) and
is_legal_py_identifier(existing)):
# we're cloning!
fields = [x.strip() for x in existing.split('.')]
function_name = fields.pop()
module, cls = self.clinic._module_and_class(fields)
for existing_function in (cls or module).functions:
if existing_function.name == function_name:
break
else:
existing_function = None
if not existing_function:
print("class", cls, "module", module, "existing", existing)
print("cls. functions", cls.functions)
fail("Couldn't find existing function " + repr(existing) + "!")
fields = [x.strip() for x in full_name.split('.')]
function_name = fields.pop()
module, cls = self.clinic._module_and_class(fields)
if not (existing_function.kind == self.kind and existing_function.coexist == self.coexist):
fail("'kind' of function and cloned function don't match! (@classmethod/@staticmethod/@coexist)")
self.function = existing_function.copy(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename, docstring='')
self.block.signatures.append(self.function)
(cls or module).functions.append(self.function)
self.next(self.state_function_docstring)
return
line, _, returns = line.partition('->')
full_name, _, c_basename = line.partition(' as ')
full_name = full_name.strip()
c_basename = c_basename.strip() or None
if not is_legal_py_identifier(full_name):
fail("Illegal function name: {}".format(full_name))
if c_basename and not is_legal_c_identifier(c_basename):
fail("Illegal C basename: {}".format(c_basename))
return_converter = None
if returns:
ast_input = "def x() -> {}: pass".format(returns)
module = None
try:
module = ast.parse(ast_input)
except SyntaxError:
pass
if not module:
fail("Badly-formed annotation for " + full_name + ": " + returns)
try:
name, legacy, kwargs = self.parse_converter(module.body[0].returns)
if legacy:
fail("Legacy converter {!r} not allowed as a return converter"
.format(name))
if name not in return_converters:
fail("No available return converter called " + repr(name))
return_converter = return_converters[name](**kwargs)
except ValueError:
fail("Badly-formed annotation for " + full_name + ": " + returns)
fields = [x.strip() for x in full_name.split('.')]
function_name = fields.pop()
module, cls = self.clinic._module_and_class(fields)
fields = full_name.split('.')
if fields[-1] == '__new__':
if (self.kind != CLASS_METHOD) or (not cls):
fail("__new__ must be a class method!")
self.kind = METHOD_NEW
elif fields[-1] == '__init__':
if (self.kind != CALLABLE) or (not cls):
fail("__init__ must be a normal method, not a class or static method!")
self.kind = METHOD_INIT
if not return_converter:
return_converter = init_return_converter()
elif fields[-1] in unsupported_special_methods:
fail(fields[-1] + " is a special method and cannot be converted to Argument Clinic! (Yet.)")
if not return_converter:
return_converter = CReturnConverter()
if not module:
fail("Undefined module used in declaration of " + repr(full_name.strip()) + ".")
self.function = Function(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename,
return_converter=return_converter, kind=self.kind, coexist=self.coexist)
self.block.signatures.append(self.function)
# insert a self converter automatically
type, name = correct_name_for_self(self.function)
kwargs = {}
if cls and type == "PyObject *":
kwargs['type'] = cls.typedef
sc = self.function.self_converter = self_converter(name, name, self.function, **kwargs)
p_self = Parameter(sc.name, inspect.Parameter.POSITIONAL_ONLY, function=self.function, converter=sc)
self.function.parameters[sc.name] = p_self
(cls or module).functions.append(self.function)
self.next(self.state_parameters_start)
# Now entering the parameters section. The rules, formally stated:
#
# * All lines must be indented with spaces only.
# * The first line must be a parameter declaration.
# * The first line must be indented.
# * This first line establishes the indent for parameters.
# * We'll call this number of spaces P (for "parameter").
# * Thenceforth:
# * Lines indented with P spaces specify a parameter.
# * Lines indented with > P spaces are docstrings for the previous
# parameter.
# * We'll call this number of spaces D (for "docstring").
# * All subsequent lines indented with >= D spaces are stored as
# part of the per-parameter docstring.
# * All lines will have the first D spaces of the indent stripped
# before they are stored.
# * It's illegal to have a line starting with a number of spaces X
# such that P < X < D.
# * A line with < P spaces is the first line of the function
# docstring, which ends processing for parameters and per-parameter
# docstrings.
# * The first line of the function docstring must be at the same
# indent as the function declaration.
# * It's illegal to have any line in the parameters section starting
# with X spaces such that F < X < P. (As before, F is the indent
# of the function declaration.)
#
# Also, currently Argument Clinic places the following restrictions on groups:
# * Each group must contain at least one parameter.
# * Each group may contain at most one group, which must be the furthest
# thing in the group from the required parameters. (The nested group
# must be the first in the group when it's before the required
# parameters, and the last thing in the group when after the required
# parameters.)
# * There may be at most one (top-level) group to the left or right of
# the required parameters.
# * You must specify a slash, and it must be after all parameters.
# (In other words: either all parameters are positional-only,
# or none are.)
#
# Said another way:
# * Each group must contain at least one parameter.
# * All left square brackets before the required parameters must be
# consecutive. (You can't have a left square bracket followed
# by a parameter, then another left square bracket. You can't
# have a left square bracket, a parameter, a right square bracket,
# and then a left square bracket.)
# * All right square brackets after the required parameters must be
# consecutive.
#
# These rules are enforced with a single state variable:
# "parameter_state". (Previously the code was a miasma of ifs and
# separate boolean state variables.) The states are:
#
# [ [ a, b, ] c, ] d, e, f=3, [ g, h, [ i ] ] <- line
# 01 2 3 4 5 6 <- state transitions
#
# 0: ps_start. before we've seen anything. legal transitions are to 1 or 3.
# 1: ps_left_square_before. left square brackets before required parameters.
# 2: ps_group_before. in a group, before required parameters.
# 3: ps_required. required parameters, positional-or-keyword or positional-only
# (we don't know yet). (renumber left groups!)
# 4: ps_optional. positional-or-keyword or positional-only parameters that
# now must have default values.
# 5: ps_group_after. in a group, after required parameters.
# 6: ps_right_square_after. right square brackets after required parameters.
ps_start, ps_left_square_before, ps_group_before, ps_required, \
ps_optional, ps_group_after, ps_right_square_after = range(7)
def state_parameters_start(self, line):
if self.ignore_line(line):
return
# if this line is not indented, we have no parameters
if not self.indent.infer(line):
return self.next(self.state_function_docstring, line)
self.parameter_continuation = ''
return self.next(self.state_parameter, line)
def to_required(self):
"""
Transition to the "required" parameter state.
"""
if self.parameter_state != self.ps_required:
self.parameter_state = self.ps_required
for p in self.function.parameters.values():
p.group = -p.group
def state_parameter(self, line):
if self.parameter_continuation:
line = self.parameter_continuation + ' ' + line.lstrip()
self.parameter_continuation = ''
if self.ignore_line(line):
return
assert self.indent.depth == 2
indent = self.indent.infer(line)
if indent == -1:
# we outdented, must be to definition column
return self.next(self.state_function_docstring, line)
if indent == 1:
# we indented, must be to new parameter docstring column
return self.next(self.state_parameter_docstring_start, line)
line = line.rstrip()
if line.endswith('\\'):
self.parameter_continuation = line[:-1]
return
line = line.lstrip()
if line in ('*', '/', '[', ']'):
self.parse_special_symbol(line)
return
if self.parameter_state in (self.ps_start, self.ps_required):
self.to_required()
elif self.parameter_state == self.ps_left_square_before:
self.parameter_state = self.ps_group_before
elif self.parameter_state == self.ps_group_before:
if not self.group:
self.to_required()
elif self.parameter_state in (self.ps_group_after, self.ps_optional):
pass
else:
fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".a)")
# handle "as" for parameters too
c_name = None
name, have_as_token, trailing = line.partition(' as ')
if have_as_token:
name = name.strip()
if ' ' not in name:
fields = trailing.strip().split(' ')
if not fields:
fail("Invalid 'as' clause!")
c_name = fields[0]
if c_name.endswith(':'):
name += ':'
c_name = c_name[:-1]
fields[0] = name
line = ' '.join(fields)
base, equals, default = line.rpartition('=')
if not equals:
base = default
default = None
module = None
try:
ast_input = "def x({}): pass".format(base)
module = ast.parse(ast_input)
except SyntaxError:
try:
# the last = was probably inside a function call, like
# c: int(accept={str})
# so assume there was no actual default value.
default = None
ast_input = "def x({}): pass".format(line)
module = ast.parse(ast_input)
except SyntaxError:
pass
if not module:
fail("Function " + self.function.name + " has an invalid parameter declaration:\n\t" + line)
function_args = module.body[0].args
if len(function_args.args) > 1:
fail("Function " + self.function.name + " has an invalid parameter declaration (comma?):\n\t" + line)
if function_args.defaults or function_args.kw_defaults:
fail("Function " + self.function.name + " has an invalid parameter declaration (default value?):\n\t" + line)
if function_args.vararg or function_args.kwarg:
fail("Function " + self.function.name + " has an invalid parameter declaration (*args? **kwargs?):\n\t" + line)
parameter = function_args.args[0]
parameter_name = parameter.arg
name, legacy, kwargs = self.parse_converter(parameter.annotation)
if not default:
if self.parameter_state == self.ps_optional:
fail("Can't have a parameter without a default (" + repr(parameter_name) + ")\nafter a parameter with a default!")
value = unspecified
if 'py_default' in kwargs:
fail("You can't specify py_default without specifying a default value!")
else:
if self.parameter_state == self.ps_required:
self.parameter_state = self.ps_optional
default = default.strip()
bad = False
ast_input = "x = {}".format(default)
bad = False
try:
module = ast.parse(ast_input)
if 'c_default' not in kwargs:
# we can only represent very simple data values in C.
# detect whether default is okay, via a blacklist
# of disallowed ast nodes.
class DetectBadNodes(ast.NodeVisitor):
bad = False
def bad_node(self, node):
self.bad = True
# inline function call
visit_Call = bad_node
# inline if statement ("x = 3 if y else z")
visit_IfExp = bad_node
# comprehensions and generator expressions
visit_ListComp = visit_SetComp = bad_node
visit_DictComp = visit_GeneratorExp = bad_node
# literals for advanced types
visit_Dict = visit_Set = bad_node
visit_List = visit_Tuple = bad_node
# "starred": "a = [1, 2, 3]; *a"
visit_Starred = bad_node
# allow ellipsis, for now
# visit_Ellipsis = bad_node
blacklist = DetectBadNodes()
blacklist.visit(module)
bad = blacklist.bad
else:
# if they specify a c_default, we can be more lenient about the default value.
# but at least make an attempt at ensuring it's a valid expression.
try:
value = eval(default)
if value == unspecified:
fail("'unspecified' is not a legal default value!")
except NameError:
pass # probably a named constant
except Exception as e:
fail("Malformed expression given as default value\n"
"{!r} caused {!r}".format(default, e))
if bad:
fail("Unsupported expression as default value: " + repr(default))
expr = module.body[0].value
# mild hack: explicitly support NULL as a default value
if isinstance(expr, ast.Name) and expr.id == 'NULL':
value = NULL
py_default = 'None'
c_default = "NULL"
elif (isinstance(expr, ast.BinOp) or
(isinstance(expr, ast.UnaryOp) and not isinstance(expr.operand, ast.Num))):
c_default = kwargs.get("c_default")
if not (isinstance(c_default, str) and c_default):
fail("When you specify an expression (" + repr(default) + ") as your default value,\nyou MUST specify a valid c_default.")
py_default = default
value = unknown
elif isinstance(expr, ast.Attribute):
a = []
n = expr
while isinstance(n, ast.Attribute):
a.append(n.attr)
n = n.value
if not isinstance(n, ast.Name):
fail("Unsupported default value " + repr(default) + " (looked like a Python constant)")
a.append(n.id)
py_default = ".".join(reversed(a))
c_default = kwargs.get("c_default")
if not (isinstance(c_default, str) and c_default):
fail("When you specify a named constant (" + repr(py_default) + ") as your default value,\nyou MUST specify a valid c_default.")
try:
value = eval(py_default)
except NameError:
value = unknown
else:
value = ast.literal_eval(expr)
py_default = repr(value)
if isinstance(value, (bool, None.__class__)):
c_default = "Py_" + py_default
elif isinstance(value, str):
c_default = c_repr(value)
else:
c_default = py_default
except SyntaxError as e:
fail("Syntax error: " + repr(e.text))
except (ValueError, AttributeError):
value = unknown
c_default = kwargs.get("c_default")
py_default = default
if not (isinstance(c_default, str) and c_default):
fail("When you specify a named constant (" + repr(py_default) + ") as your default value,\nyou MUST specify a valid c_default.")
kwargs.setdefault('c_default', c_default)
kwargs.setdefault('py_default', py_default)
dict = legacy_converters if legacy else converters
legacy_str = "legacy " if legacy else ""
if name not in dict:
fail('{} is not a valid {}converter'.format(name, legacy_str))
# if you use a c_name for the parameter, we just give that name to the converter
# but the parameter object gets the python name
converter = dict[name](c_name or parameter_name, parameter_name, self.function, value, **kwargs)
kind = inspect.Parameter.KEYWORD_ONLY if self.keyword_only else inspect.Parameter.POSITIONAL_OR_KEYWORD
if isinstance(converter, self_converter):
if len(self.function.parameters) == 1:
if (self.parameter_state != self.ps_required):
fail("A 'self' parameter cannot be marked optional.")
if value is not unspecified:
fail("A 'self' parameter cannot have a default value.")
if self.group:
fail("A 'self' parameter cannot be in an optional group.")
kind = inspect.Parameter.POSITIONAL_ONLY
self.parameter_state = self.ps_start
self.function.parameters.clear()
else:
fail("A 'self' parameter, if specified, must be the very first thing in the parameter block.")
p = Parameter(parameter_name, kind, function=self.function, converter=converter, default=value, group=self.group)
if parameter_name in self.function.parameters:
fail("You can't have two parameters named " + repr(parameter_name) + "!")
self.function.parameters[parameter_name] = p
def parse_converter(self, annotation):
if isinstance(annotation, ast.Str):
return annotation.s, True, {}
if isinstance(annotation, ast.Name):
return annotation.id, False, {}
if not isinstance(annotation, ast.Call):
fail("Annotations must be either a name, a function call, or a string.")
name = annotation.func.id
symbols = globals()
kwargs = {node.arg: eval_ast_expr(node.value, symbols) for node in annotation.keywords}
return name, False, kwargs
def parse_special_symbol(self, symbol):
if symbol == '*':
if self.keyword_only:
fail("Function " + self.function.name + " uses '*' more than once.")
self.keyword_only = True
elif symbol == '[':
if self.parameter_state in (self.ps_start, self.ps_left_square_before):
self.parameter_state = self.ps_left_square_before
elif self.parameter_state in (self.ps_required, self.ps_group_after):
self.parameter_state = self.ps_group_after
else:
fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".b)")
self.group += 1
self.function.docstring_only = True
elif symbol == ']':
if not self.group:
fail("Function " + self.function.name + " has a ] without a matching [.")
if not any(p.group == self.group for p in self.function.parameters.values()):
fail("Function " + self.function.name + " has an empty group.\nAll groups must contain at least one parameter.")
self.group -= 1
if self.parameter_state in (self.ps_left_square_before, self.ps_group_before):
self.parameter_state = self.ps_group_before
elif self.parameter_state in (self.ps_group_after, self.ps_right_square_after):
self.parameter_state = self.ps_right_square_after
else:
fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".c)")
elif symbol == '/':
if self.positional_only:
fail("Function " + self.function.name + " uses '/' more than once.")
self.positional_only = True
# ps_required and ps_optional are allowed here, that allows positional-only without option groups
# to work (and have default values!)
if (self.parameter_state not in (self.ps_required, self.ps_optional, self.ps_right_square_after, self.ps_group_before)) or self.group:
fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".d)")
if self.keyword_only:
fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
# fixup preceding parameters
for p in self.function.parameters.values():
if (p.kind != inspect.Parameter.POSITIONAL_OR_KEYWORD and not isinstance(p.converter, self_converter)):
fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
p.kind = inspect.Parameter.POSITIONAL_ONLY
def state_parameter_docstring_start(self, line):
self.parameter_docstring_indent = len(self.indent.margin)
assert self.indent.depth == 3
return self.next(self.state_parameter_docstring, line)
# every line of the docstring must start with at least F spaces,
# where F > P.
# these F spaces will be stripped.
def state_parameter_docstring(self, line):
stripped = line.strip()
if stripped.startswith('#'):
return
indent = self.indent.measure(line)
if indent < self.parameter_docstring_indent:
self.indent.infer(line)
assert self.indent.depth < 3
if self.indent.depth == 2:
# back to a parameter
return self.next(self.state_parameter, line)
assert self.indent.depth == 1
return self.next(self.state_function_docstring, line)
assert self.function.parameters
last_parameter = next(reversed(list(self.function.parameters.values())))
new_docstring = last_parameter.docstring
if new_docstring:
new_docstring += '\n'
if stripped:
new_docstring += self.indent.dedent(line)
last_parameter.docstring = new_docstring
# the final stanza of the DSL is the docstring.
def state_function_docstring(self, line):
if self.group:
fail("Function " + self.function.name + " has a ] without a matching [.")
stripped = line.strip()
if stripped.startswith('#'):
return
new_docstring = self.function.docstring
if new_docstring:
new_docstring += "\n"
if stripped:
line = self.indent.dedent(line).rstrip()
else:
line = ''
new_docstring += line
self.function.docstring = new_docstring
def format_docstring(self):
f = self.function
new_or_init = f.kind in (METHOD_NEW, METHOD_INIT)
if new_or_init and not f.docstring:
# don't render a docstring at all, no signature, nothing.
return f.docstring
text, add, output = _text_accumulator()
parameters = f.render_parameters
##
## docstring first line
##
if new_or_init:
# classes get *just* the name of the class
# not __new__, not __init__, and not module.classname
assert f.cls
add(f.cls.name)
else:
add(f.name)
add('(')
# populate "right_bracket_count" field for every parameter
assert parameters, "We should always have a self parameter. " + repr(f)
assert isinstance(parameters[0].converter, self_converter)
# self is always positional-only.
assert parameters[0].is_positional_only()
parameters[0].right_bracket_count = 0
positional_only = True
for p in parameters[1:]:
if not p.is_positional_only():
positional_only = False
else:
assert positional_only
if positional_only:
p.right_bracket_count = abs(p.group)
else:
# don't put any right brackets around non-positional-only parameters, ever.
p.right_bracket_count = 0
right_bracket_count = 0
def fix_right_bracket_count(desired):
nonlocal right_bracket_count
s = ''
while right_bracket_count < desired:
s += '['
right_bracket_count += 1
while right_bracket_count > desired:
s += ']'
right_bracket_count -= 1
return s
need_slash = False
added_slash = False
need_a_trailing_slash = False
# we only need a trailing slash:
# * if this is not a "docstring_only" signature
# * and if the last *shown* parameter is
# positional only
if not f.docstring_only:
for p in reversed(parameters):
if not p.converter.show_in_signature:
continue
if p.is_positional_only():
need_a_trailing_slash = True
break
added_star = False
first_parameter = True
last_p = parameters[-1]
line_length = len(''.join(text))
indent = " " * line_length
def add_parameter(text):
nonlocal line_length
nonlocal first_parameter
if first_parameter:
s = text
first_parameter = False
else:
s = ' ' + text
if line_length + len(s) >= 72:
add('\n')
add(indent)
line_length = len(indent)
s = text
line_length += len(s)
add(s)
for p in parameters:
if not p.converter.show_in_signature:
continue
assert p.name
is_self = isinstance(p.converter, self_converter)
if is_self and f.docstring_only:
# this isn't a real machine-parsable signature,
# so let's not print the "self" parameter
continue
if p.is_positional_only():
need_slash = not f.docstring_only
elif need_slash and not (added_slash or p.is_positional_only()):
added_slash = True
add_parameter('/,')
if p.is_keyword_only() and not added_star:
added_star = True
add_parameter('*,')
p_add, p_output = text_accumulator()
p_add(fix_right_bracket_count(p.right_bracket_count))
if isinstance(p.converter, self_converter):
# annotate first parameter as being a "self".
#
# if inspect.Signature gets this function,
# and it's already bound, the self parameter
# will be stripped off.
#
# if it's not bound, it should be marked
# as positional-only.
#
# note: we don't print "self" for __init__,
# because this isn't actually the signature
# for __init__. (it can't be, __init__ doesn't
# have a docstring.) if this is an __init__
# (or __new__), then this signature is for
# calling the class to construct a new instance.
p_add('$')
name = p.converter.signature_name or p.name
p_add(name)
if p.converter.is_optional():
p_add('=')
value = p.converter.py_default
if not value:
value = repr(p.converter.default)
p_add(value)
if (p != last_p) or need_a_trailing_slash:
p_add(',')
add_parameter(p_output())
add(fix_right_bracket_count(0))
if need_a_trailing_slash:
add_parameter('/')
add(')')
# PEP 8 says:
#
# The Python standard library will not use function annotations
# as that would result in a premature commitment to a particular
# annotation style. Instead, the annotations are left for users
# to discover and experiment with useful annotation styles.
#
# therefore this is commented out:
#
# if f.return_converter.py_default:
# add(' -> ')
# add(f.return_converter.py_default)
if not f.docstring_only:
add("\n" + sig_end_marker + "\n")
docstring_first_line = output()
# now fix up the places where the brackets look wrong
docstring_first_line = docstring_first_line.replace(', ]', ',] ')
# okay. now we're officially building the "parameters" section.
# create substitution text for {parameters}
spacer_line = False
for p in parameters:
if not p.docstring.strip():
continue
if spacer_line:
add('\n')
else:
spacer_line = True
add(" ")
add(p.name)
add('\n')
add(textwrap.indent(rstrip_lines(p.docstring.rstrip()), " "))
parameters = output()
if parameters:
parameters += '\n'
##
## docstring body
##
docstring = f.docstring.rstrip()
lines = [line.rstrip() for line in docstring.split('\n')]
# Enforce the summary line!
# The first line of a docstring should be a summary of the function.
# It should fit on one line (80 columns? 79 maybe?) and be a paragraph
# by itself.
#
# Argument Clinic enforces the following rule:
# * either the docstring is empty,
# * or it must have a summary line.
#
# Guido said Clinic should enforce this:
# http://mail.python.org/pipermail/python-dev/2013-June/127110.html
if len(lines) >= 2:
if lines[1]:
fail("Docstring for " + f.full_name + " does not have a summary line!\n" +
"Every non-blank function docstring must start with\n" +
"a single line summary followed by an empty line.")
elif len(lines) == 1:
# the docstring is only one line right now--the summary line.
# add an empty line after the summary line so we have space
# between it and the {parameters} we're about to add.
lines.append('')
parameters_marker_count = len(docstring.split('{parameters}')) - 1
if parameters_marker_count > 1:
fail('You may not specify {parameters} more than once in a docstring!')
if not parameters_marker_count:
# insert after summary line
lines.insert(2, '{parameters}')
# insert at front of docstring
lines.insert(0, docstring_first_line)
docstring = "\n".join(lines)
add(docstring)
docstring = output()
docstring = linear_format(docstring, parameters=parameters)
docstring = docstring.rstrip()
return docstring
def state_terminal(self, line):
"""
Called when processing the block is done.
"""
assert not line
if not self.function:
return
if self.keyword_only:
values = self.function.parameters.values()
if not values:
no_parameter_after_star = True
else:
last_parameter = next(reversed(list(values)))
no_parameter_after_star = last_parameter.kind != inspect.Parameter.KEYWORD_ONLY
if no_parameter_after_star:
fail("Function " + self.function.name + " specifies '*' without any parameters afterwards.")
# remove trailing whitespace from all parameter docstrings
for name, value in self.function.parameters.items():
if not value:
continue
value.docstring = value.docstring.rstrip()
self.function.docstring = self.format_docstring()
# maps strings to callables.
# the callable should return an object
# that implements the clinic parser
# interface (__init__ and parse).
#
# example parsers:
# "clinic", handles the Clinic DSL
# "python", handles running Python code
#
parsers = {'clinic' : DSLParser, 'python': PythonParser}
clinic = None
def main(argv):
import sys
if sys.version_info.major < 3 or sys.version_info.minor < 3:
sys.exit("Error: clinic.py requires Python 3.3 or greater.")
import argparse
cmdline = argparse.ArgumentParser()
cmdline.add_argument("-f", "--force", action='store_true')
cmdline.add_argument("-o", "--output", type=str)
cmdline.add_argument("-v", "--verbose", action='store_true')
cmdline.add_argument("--converters", action='store_true')
cmdline.add_argument("--make", action='store_true')
cmdline.add_argument("filename", type=str, nargs="*")
ns = cmdline.parse_args(argv)
if ns.converters:
if ns.filename:
print("Usage error: can't specify --converters and a filename at the same time.")
print()
cmdline.print_usage()
sys.exit(-1)
converters = []
return_converters = []
ignored = set("""
add_c_converter
add_c_return_converter
add_default_legacy_c_converter
add_legacy_c_converter
""".strip().split())
module = globals()
for name in module:
for suffix, ids in (
("_return_converter", return_converters),
("_converter", converters),
):
if name in ignored:
continue
if name.endswith(suffix):
ids.append((name, name[:-len(suffix)]))
break
print()
print("Legacy converters:")
legacy = sorted(legacy_converters)
print(' ' + ' '.join(c for c in legacy if c[0].isupper()))
print(' ' + ' '.join(c for c in legacy if c[0].islower()))
print()
for title, attribute, ids in (
("Converters", 'converter_init', converters),
("Return converters", 'return_converter_init', return_converters),
):
print(title + ":")
longest = -1
for name, short_name in ids:
longest = max(longest, len(short_name))
for name, short_name in sorted(ids, key=lambda x: x[1].lower()):
cls = module[name]
callable = getattr(cls, attribute, None)
if not callable:
continue
signature = inspect.signature(callable)
parameters = []
for parameter_name, parameter in signature.parameters.items():
if parameter.kind == inspect.Parameter.KEYWORD_ONLY:
if parameter.default != inspect.Parameter.empty:
s = '{}={!r}'.format(parameter_name, parameter.default)
else:
s = parameter_name
parameters.append(s)
print(' {}({})'.format(short_name, ', '.join(parameters)))
print()
print("All converters also accept (c_default=None, py_default=None, annotation=None).")
print("All return converters also accept (py_default=None).")
sys.exit(0)
if ns.make:
if ns.output or ns.filename:
print("Usage error: can't use -o or filenames with --make.")
print()
cmdline.print_usage()
sys.exit(-1)
for root, dirs, files in os.walk('.'):
for rcs_dir in ('.svn', '.git', '.hg', 'build', 'externals'):
if rcs_dir in dirs:
dirs.remove(rcs_dir)
for filename in files:
if not (filename.endswith('.c') or filename.endswith('.h')):
continue
path = os.path.join(root, filename)
if ns.verbose:
print(path)
parse_file(path, force=ns.force, verify=not ns.force)
return
if not ns.filename:
cmdline.print_usage()
sys.exit(-1)
if ns.output and len(ns.filename) > 1:
print("Usage error: can't use -o with multiple filenames.")
print()
cmdline.print_usage()
sys.exit(-1)
for filename in ns.filename:
if ns.verbose:
print(filename)
parse_file(filename, output=ns.output, force=ns.force, verify=not ns.force)
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
| 152,215 | 4,385 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/clinic/clinic_test.py | # Argument Clinic
# Copyright 2012-2013 by Larry Hastings.
# Licensed to the PSF under a contributor agreement.
#
import clinic
from clinic import DSLParser
import collections
import inspect
from test import support
import sys
import unittest
from unittest import TestCase
class FakeConverter:
def __init__(self, name, args):
self.name = name
self.args = args
class FakeConverterFactory:
def __init__(self, name):
self.name = name
def __call__(self, name, default, **kwargs):
return FakeConverter(self.name, kwargs)
class FakeConvertersDict:
def __init__(self):
self.used_converters = {}
def get(self, name, default):
return self.used_converters.setdefault(name, FakeConverterFactory(name))
clinic.Clinic.presets_text = ''
c = clinic.Clinic(language='C')
class FakeClinic:
def __init__(self):
self.converters = FakeConvertersDict()
self.legacy_converters = FakeConvertersDict()
self.language = clinic.CLanguage(None)
self.filename = None
self.block_parser = clinic.BlockParser('', self.language)
self.modules = collections.OrderedDict()
self.classes = collections.OrderedDict()
clinic.clinic = self
self.name = "FakeClinic"
self.line_prefix = self.line_suffix = ''
self.destinations = {}
self.add_destination("block", "buffer")
self.add_destination("file", "buffer")
self.add_destination("suppress", "suppress")
d = self.destinations.get
self.field_destinations = collections.OrderedDict((
('docstring_prototype', d('suppress')),
('docstring_definition', d('block')),
('methoddef_define', d('block')),
('impl_prototype', d('block')),
('parser_prototype', d('suppress')),
('parser_definition', d('block')),
('impl_definition', d('block')),
))
def get_destination(self, name):
d = self.destinations.get(name)
if not d:
sys.exit("Destination does not exist: " + repr(name))
return d
def add_destination(self, name, type, *args):
if name in self.destinations:
sys.exit("Destination already exists: " + repr(name))
self.destinations[name] = clinic.Destination(name, type, self, *args)
def is_directive(self, name):
return name == "module"
def directive(self, name, args):
self.called_directives[name] = args
_module_and_class = clinic.Clinic._module_and_class
class ClinicWholeFileTest(TestCase):
def test_eol(self):
# regression test:
# clinic's block parser didn't recognize
# the "end line" for the block if it
# didn't end in "\n" (as in, the last)
# byte of the file was '/'.
# so it would spit out an end line for you.
# and since you really already had one,
# the last line of the block got corrupted.
c = clinic.Clinic(clinic.CLanguage(None))
raw = "/*[clinic]\nfoo\n[clinic]*/"
cooked = c.parse(raw).splitlines()
end_line = cooked[2].rstrip()
# this test is redundant, it's just here explicitly to catch
# the regression test so we don't forget what it looked like
self.assertNotEqual(end_line, "[clinic]*/[clinic]*/")
self.assertEqual(end_line, "[clinic]*/")
class ClinicGroupPermuterTest(TestCase):
def _test(self, l, m, r, output):
computed = clinic.permute_optional_groups(l, m, r)
self.assertEqual(output, computed)
def test_range(self):
self._test([['start']], ['stop'], [['step']],
(
('stop',),
('start', 'stop',),
('start', 'stop', 'step',),
))
def test_add_window(self):
self._test([['x', 'y']], ['ch'], [['attr']],
(
('ch',),
('ch', 'attr'),
('x', 'y', 'ch',),
('x', 'y', 'ch', 'attr'),
))
def test_ludicrous(self):
self._test([['a1', 'a2', 'a3'], ['b1', 'b2']], ['c1'], [['d1', 'd2'], ['e1', 'e2', 'e3']],
(
('c1',),
('b1', 'b2', 'c1'),
('b1', 'b2', 'c1', 'd1', 'd2'),
('a1', 'a2', 'a3', 'b1', 'b2', 'c1'),
('a1', 'a2', 'a3', 'b1', 'b2', 'c1', 'd1', 'd2'),
('a1', 'a2', 'a3', 'b1', 'b2', 'c1', 'd1', 'd2', 'e1', 'e2', 'e3'),
))
def test_right_only(self):
self._test([], [], [['a'],['b'],['c']],
(
(),
('a',),
('a', 'b'),
('a', 'b', 'c')
))
def test_have_left_options_but_required_is_empty(self):
def fn():
clinic.permute_optional_groups(['a'], [], [])
self.assertRaises(AssertionError, fn)
class ClinicLinearFormatTest(TestCase):
def _test(self, input, output, **kwargs):
computed = clinic.linear_format(input, **kwargs)
self.assertEqual(output, computed)
def test_empty_strings(self):
self._test('', '')
def test_solo_newline(self):
self._test('\n', '\n')
def test_no_substitution(self):
self._test("""
abc
""", """
abc
""")
def test_empty_substitution(self):
self._test("""
abc
{name}
def
""", """
abc
def
""", name='')
def test_single_line_substitution(self):
self._test("""
abc
{name}
def
""", """
abc
GARGLE
def
""", name='GARGLE')
def test_multiline_substitution(self):
self._test("""
abc
{name}
def
""", """
abc
bingle
bungle
def
""", name='bingle\nbungle\n')
class InertParser:
def __init__(self, clinic):
pass
def parse(self, block):
pass
class CopyParser:
def __init__(self, clinic):
pass
def parse(self, block):
block.output = block.input
class ClinicBlockParserTest(TestCase):
def _test(self, input, output):
language = clinic.CLanguage(None)
blocks = list(clinic.BlockParser(input, language))
writer = clinic.BlockPrinter(language)
for block in blocks:
writer.print_block(block)
output = writer.f.getvalue()
assert output == input, "output != input!\n\noutput " + repr(output) + "\n\n input " + repr(input)
def round_trip(self, input):
return self._test(input, input)
def test_round_trip_1(self):
self.round_trip("""
verbatim text here
lah dee dah
""")
def test_round_trip_2(self):
self.round_trip("""
verbatim text here
lah dee dah
/*[inert]
abc
[inert]*/
def
/*[inert checksum: 7b18d017f89f61cf17d47f92749ea6930a3f1deb]*/
xyz
""")
def _test_clinic(self, input, output):
language = clinic.CLanguage(None)
c = clinic.Clinic(language)
c.parsers['inert'] = InertParser(c)
c.parsers['copy'] = CopyParser(c)
computed = c.parse(input)
self.assertEqual(output, computed)
def test_clinic_1(self):
self._test_clinic("""
verbatim text here
lah dee dah
/*[copy input]
def
[copy start generated code]*/
abc
/*[copy end generated code: output=03cfd743661f0797 input=7b18d017f89f61cf]*/
xyz
""", """
verbatim text here
lah dee dah
/*[copy input]
def
[copy start generated code]*/
def
/*[copy end generated code: output=7b18d017f89f61cf input=7b18d017f89f61cf]*/
xyz
""")
class ClinicParserTest(TestCase):
def test_trivial(self):
parser = DSLParser(FakeClinic())
block = clinic.Block("module os\nos.access")
parser.parse(block)
module, function = block.signatures
self.assertEqual("access", function.name)
self.assertEqual("os", module.name)
def test_ignore_line(self):
block = self.parse("#\nmodule os\nos.access")
module, function = block.signatures
self.assertEqual("access", function.name)
self.assertEqual("os", module.name)
def test_param(self):
function = self.parse_function("module os\nos.access\n path: int")
self.assertEqual("access", function.name)
self.assertEqual(2, len(function.parameters))
p = function.parameters['path']
self.assertEqual('path', p.name)
self.assertIsInstance(p.converter, clinic.int_converter)
def test_param_default(self):
function = self.parse_function("module os\nos.access\n follow_symlinks: bool = True")
p = function.parameters['follow_symlinks']
self.assertEqual(True, p.default)
def test_param_with_continuations(self):
function = self.parse_function("module os\nos.access\n follow_symlinks: \\\n bool \\\n =\\\n True")
p = function.parameters['follow_symlinks']
self.assertEqual(True, p.default)
def test_param_default_expression(self):
function = self.parse_function("module os\nos.access\n follow_symlinks: int(c_default='MAXSIZE') = sys.maxsize")
p = function.parameters['follow_symlinks']
self.assertEqual(sys.maxsize, p.default)
self.assertEqual("MAXSIZE", p.converter.c_default)
s = self.parse_function_should_fail("module os\nos.access\n follow_symlinks: int = sys.maxsize")
self.assertEqual(s, "Error on line 0:\nWhen you specify a named constant ('sys.maxsize') as your default value,\nyou MUST specify a valid c_default.\n")
def test_param_no_docstring(self):
function = self.parse_function("""
module os
os.access
follow_symlinks: bool = True
something_else: str = ''""")
p = function.parameters['follow_symlinks']
self.assertEqual(3, len(function.parameters))
self.assertIsInstance(function.parameters['something_else'].converter, clinic.str_converter)
def test_param_default_parameters_out_of_order(self):
s = self.parse_function_should_fail("""
module os
os.access
follow_symlinks: bool = True
something_else: str""")
self.assertEqual(s, """Error on line 0:
Can't have a parameter without a default ('something_else')
after a parameter with a default!
""")
def disabled_test_converter_arguments(self):
function = self.parse_function("module os\nos.access\n path: path_t(allow_fd=1)")
p = function.parameters['path']
self.assertEqual(1, p.converter.args['allow_fd'])
def test_function_docstring(self):
function = self.parse_function("""
module os
os.stat as os_stat_fn
path: str
Path to be examined
Perform a stat system call on the given path.""")
self.assertEqual("""
stat($module, /, path)
--
Perform a stat system call on the given path.
path
Path to be examined
""".strip(), function.docstring)
def test_explicit_parameters_in_docstring(self):
function = self.parse_function("""
module foo
foo.bar
x: int
Documentation for x.
y: int
This is the documentation for foo.
Okay, we're done here.
""")
self.assertEqual("""
bar($module, /, x, y)
--
This is the documentation for foo.
x
Documentation for x.
Okay, we're done here.
""".strip(), function.docstring)
def test_parser_regression_special_character_in_parameter_column_of_docstring_first_line(self):
function = self.parse_function("""
module os
os.stat
path: str
This/used to break Clinic!
""")
self.assertEqual("stat($module, /, path)\n--\n\nThis/used to break Clinic!", function.docstring)
def test_c_name(self):
function = self.parse_function("module os\nos.stat as os_stat_fn")
self.assertEqual("os_stat_fn", function.c_basename)
def test_return_converter(self):
function = self.parse_function("module os\nos.stat -> int")
self.assertIsInstance(function.return_converter, clinic.int_return_converter)
def test_star(self):
function = self.parse_function("module os\nos.access\n *\n follow_symlinks: bool = True")
p = function.parameters['follow_symlinks']
self.assertEqual(inspect.Parameter.KEYWORD_ONLY, p.kind)
self.assertEqual(0, p.group)
def test_group(self):
function = self.parse_function("module window\nwindow.border\n [\n ls : int\n ]\n /\n")
p = function.parameters['ls']
self.assertEqual(1, p.group)
def test_left_group(self):
function = self.parse_function("""
module curses
curses.addch
[
y: int
Y-coordinate.
x: int
X-coordinate.
]
ch: char
Character to add.
[
attr: long
Attributes for the character.
]
/
""")
for name, group in (
('y', -1), ('x', -1),
('ch', 0),
('attr', 1),
):
p = function.parameters[name]
self.assertEqual(p.group, group)
self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)
self.assertEqual(function.docstring.strip(), """
addch([y, x,] ch, [attr])
y
Y-coordinate.
x
X-coordinate.
ch
Character to add.
attr
Attributes for the character.
""".strip())
def test_nested_groups(self):
function = self.parse_function("""
module curses
curses.imaginary
[
[
y1: int
Y-coordinate.
y2: int
Y-coordinate.
]
x1: int
X-coordinate.
x2: int
X-coordinate.
]
ch: char
Character to add.
[
attr1: long
Attributes for the character.
attr2: long
Attributes for the character.
attr3: long
Attributes for the character.
[
attr4: long
Attributes for the character.
attr5: long
Attributes for the character.
attr6: long
Attributes for the character.
]
]
/
""")
for name, group in (
('y1', -2), ('y2', -2),
('x1', -1), ('x2', -1),
('ch', 0),
('attr1', 1), ('attr2', 1), ('attr3', 1),
('attr4', 2), ('attr5', 2), ('attr6', 2),
):
p = function.parameters[name]
self.assertEqual(p.group, group)
self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)
self.assertEqual(function.docstring.strip(), """
imaginary([[y1, y2,] x1, x2,] ch, [attr1, attr2, attr3, [attr4, attr5,
attr6]])
y1
Y-coordinate.
y2
Y-coordinate.
x1
X-coordinate.
x2
X-coordinate.
ch
Character to add.
attr1
Attributes for the character.
attr2
Attributes for the character.
attr3
Attributes for the character.
attr4
Attributes for the character.
attr5
Attributes for the character.
attr6
Attributes for the character.
""".strip())
def parse_function_should_fail(self, s):
with support.captured_stdout() as stdout:
with self.assertRaises(SystemExit):
self.parse_function(s)
return stdout.getvalue()
def test_disallowed_grouping__two_top_groups_on_left(self):
s = self.parse_function_should_fail("""
module foo
foo.two_top_groups_on_left
[
group1 : int
]
[
group2 : int
]
param: int
""")
self.assertEqual(s,
('Error on line 0:\n'
'Function two_top_groups_on_left has an unsupported group configuration. (Unexpected state 2.b)\n'))
def test_disallowed_grouping__two_top_groups_on_right(self):
self.parse_function_should_fail("""
module foo
foo.two_top_groups_on_right
param: int
[
group1 : int
]
[
group2 : int
]
""")
def test_disallowed_grouping__parameter_after_group_on_right(self):
self.parse_function_should_fail("""
module foo
foo.parameter_after_group_on_right
param: int
[
[
group1 : int
]
group2 : int
]
""")
def test_disallowed_grouping__group_after_parameter_on_left(self):
self.parse_function_should_fail("""
module foo
foo.group_after_parameter_on_left
[
group2 : int
[
group1 : int
]
]
param: int
""")
def test_disallowed_grouping__empty_group_on_left(self):
self.parse_function_should_fail("""
module foo
foo.empty_group
[
[
]
group2 : int
]
param: int
""")
def test_disallowed_grouping__empty_group_on_right(self):
self.parse_function_should_fail("""
module foo
foo.empty_group
param: int
[
[
]
group2 : int
]
""")
def test_no_parameters(self):
function = self.parse_function("""
module foo
foo.bar
Docstring
""")
self.assertEqual("bar($module, /)\n--\n\nDocstring", function.docstring)
self.assertEqual(1, len(function.parameters)) # self!
def test_init_with_no_parameters(self):
function = self.parse_function("""
module foo
class foo.Bar "unused" "notneeded"
foo.Bar.__init__
Docstring
""", signatures_in_block=3, function_index=2)
# self is not in the signature
self.assertEqual("Bar()\n--\n\nDocstring", function.docstring)
# but it *is* a parameter
self.assertEqual(1, len(function.parameters))
def test_illegal_module_line(self):
self.parse_function_should_fail("""
module foo
foo.bar => int
/
""")
def test_illegal_c_basename(self):
self.parse_function_should_fail("""
module foo
foo.bar as 935
/
""")
def test_single_star(self):
self.parse_function_should_fail("""
module foo
foo.bar
*
*
""")
def test_parameters_required_after_star_without_initial_parameters_or_docstring(self):
self.parse_function_should_fail("""
module foo
foo.bar
*
""")
def test_parameters_required_after_star_without_initial_parameters_with_docstring(self):
self.parse_function_should_fail("""
module foo
foo.bar
*
Docstring here.
""")
def test_parameters_required_after_star_with_initial_parameters_without_docstring(self):
self.parse_function_should_fail("""
module foo
foo.bar
this: int
*
""")
def test_parameters_required_after_star_with_initial_parameters_and_docstring(self):
self.parse_function_should_fail("""
module foo
foo.bar
this: int
*
Docstring.
""")
def test_single_slash(self):
self.parse_function_should_fail("""
module foo
foo.bar
/
/
""")
def test_mix_star_and_slash(self):
self.parse_function_should_fail("""
module foo
foo.bar
x: int
y: int
*
z: int
/
""")
def test_parameters_not_permitted_after_slash_for_now(self):
self.parse_function_should_fail("""
module foo
foo.bar
/
x: int
""")
def test_function_not_at_column_0(self):
function = self.parse_function("""
module foo
foo.bar
x: int
Nested docstring here, goeth.
*
y: str
Not at column 0!
""")
self.assertEqual("""
bar($module, /, x, *, y)
--
Not at column 0!
x
Nested docstring here, goeth.
""".strip(), function.docstring)
def test_directive(self):
c = FakeClinic()
parser = DSLParser(c)
parser.flag = False
parser.directives['setflag'] = lambda : setattr(parser, 'flag', True)
block = clinic.Block("setflag")
parser.parse(block)
self.assertTrue(parser.flag)
def test_legacy_converters(self):
block = self.parse('module os\nos.access\n path: "s"')
module, function = block.signatures
self.assertIsInstance((function.parameters['path']).converter, clinic.str_converter)
def parse(self, text):
c = FakeClinic()
parser = DSLParser(c)
block = clinic.Block(text)
parser.parse(block)
return block
def parse_function(self, text, signatures_in_block=2, function_index=1):
block = self.parse(text)
s = block.signatures
self.assertEqual(len(s), signatures_in_block)
assert isinstance(s[0], clinic.Module)
assert isinstance(s[function_index], clinic.Function)
return s[function_index]
def test_scaffolding(self):
# test repr on special values
self.assertEqual(repr(clinic.unspecified), '<Unspecified>')
self.assertEqual(repr(clinic.NULL), '<Null>')
# test that fail fails
with support.captured_stdout() as stdout:
with self.assertRaises(SystemExit):
clinic.fail('The igloos are melting!', filename='clown.txt', line_number=69)
self.assertEqual(stdout.getvalue(), 'Error in file "clown.txt" on line 69:\nThe igloos are melting!\n')
if __name__ == "__main__":
unittest.main()
| 20,753 | 792 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/clinic/cpp.py | import re
import sys
def negate(condition):
"""
Returns a CPP conditional that is the opposite of the conditional passed in.
"""
if condition.startswith('!'):
return condition[1:]
return "!" + condition
class Monitor:
"""
A simple C preprocessor that scans C source and computes, line by line,
what the current C preprocessor #if state is.
Doesn't handle everything--for example, if you have /* inside a C string,
without a matching */ (also inside a C string), or with a */ inside a C
string but on another line and with preprocessor macros in between...
the parser will get lost.
Anyway this implementation seems to work well enough for the CPython sources.
"""
is_a_simple_defined = re.compile(r'^defined\s*\(\s*[A-Za-z0-9_]+\s*\)$').match
def __init__(self, filename=None, *, verbose=False):
self.stack = []
self.in_comment = False
self.continuation = None
self.line_number = 0
self.filename = filename
self.verbose = verbose
def __repr__(self):
return ''.join((
'<Monitor ',
str(id(self)),
" line=", str(self.line_number),
" condition=", repr(self.condition()),
">"))
def status(self):
return str(self.line_number).rjust(4) + ": " + self.condition()
def condition(self):
"""
Returns the current preprocessor state, as a single #if condition.
"""
return " && ".join(condition for token, condition in self.stack)
def fail(self, *a):
if self.filename:
filename = " " + self.filename
else:
filename = ''
print("Error at" + filename, "line", self.line_number, ":")
print(" ", ' '.join(str(x) for x in a))
sys.exit(-1)
def close(self):
if self.stack:
self.fail("Ended file while still in a preprocessor conditional block!")
def write(self, s):
for line in s.split("\n"):
self.writeline(line)
def writeline(self, line):
self.line_number += 1
line = line.strip()
def pop_stack():
if not self.stack:
self.fail("#" + token + " without matching #if / #ifdef / #ifndef!")
return self.stack.pop()
if self.continuation:
line = self.continuation + line
self.continuation = None
if not line:
return
if line.endswith('\\'):
self.continuation = line[:-1].rstrip() + " "
return
# we have to ignore preprocessor commands inside comments
#
# we also have to handle this:
# /* start
# ...
# */ /* <-- tricky!
# ...
# */
# and this:
# /* start
# ...
# */ /* also tricky! */
if self.in_comment:
if '*/' in line:
# snip out the comment and continue
#
# GCC allows
# /* comment
# */ #include <stdio.h>
# maybe other compilers too?
_, _, line = line.partition('*/')
self.in_comment = False
while True:
if '/*' in line:
if self.in_comment:
self.fail("Nested block comment!")
before, _, remainder = line.partition('/*')
comment, comment_ends, after = remainder.partition('*/')
if comment_ends:
# snip out the comment
line = before.rstrip() + ' ' + after.lstrip()
continue
# comment continues to eol
self.in_comment = True
line = before.rstrip()
break
# we actually have some // comments
# (but block comments take precedence)
before, line_comment, comment = line.partition('//')
if line_comment:
line = before.rstrip()
if not line.startswith('#'):
return
line = line[1:].lstrip()
assert line
fields = line.split()
token = fields[0].lower()
condition = ' '.join(fields[1:]).strip()
if_tokens = {'if', 'ifdef', 'ifndef'}
all_tokens = if_tokens | {'elif', 'else', 'endif'}
if token not in all_tokens:
return
# cheat a little here, to reuse the implementation of if
if token == 'elif':
pop_stack()
token = 'if'
if token in if_tokens:
if not condition:
self.fail("Invalid format for #" + token + " line: no argument!")
if token == 'if':
if not self.is_a_simple_defined(condition):
condition = "(" + condition + ")"
else:
fields = condition.split()
if len(fields) != 1:
self.fail("Invalid format for #" + token + " line: should be exactly one argument!")
symbol = fields[0]
condition = 'defined(' + symbol + ')'
if token == 'ifndef':
condition = '!' + condition
self.stack.append(("if", condition))
if self.verbose:
print(self.status())
return
previous_token, previous_condition = pop_stack()
if token == 'else':
self.stack.append(('else', negate(previous_condition)))
elif token == 'endif':
pass
if self.verbose:
print(self.status())
if __name__ == '__main__':
for filename in sys.argv[1:]:
with open(filename, "rt") as f:
cpp = Monitor(filename, verbose=True)
print()
print(filename)
for line_number, line in enumerate(f.read().split('\n'), 1):
cpp.writeline(line)
| 5,984 | 192 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/importbench/importbench.py | """Benchmark some basic import use-cases.
The assumption is made that this benchmark is run in a fresh interpreter and
thus has no external changes made to import-related attributes in sys.
"""
from test.test_importlib import util
import decimal
import imp
import importlib
import importlib.machinery
import json
import os
import py_compile
import sys
import tabnanny
import timeit
def bench(name, cleanup=lambda: None, *, seconds=1, repeat=3):
"""Bench the given statement as many times as necessary until total
executions take one second."""
stmt = "__import__({!r})".format(name)
timer = timeit.Timer(stmt)
for x in range(repeat):
total_time = 0
count = 0
while total_time < seconds:
try:
total_time += timer.timeit(1)
finally:
cleanup()
count += 1
else:
# One execution too far
if total_time > seconds:
count -= 1
yield count // seconds
def from_cache(seconds, repeat):
"""sys.modules"""
name = '<benchmark import>'
module = imp.new_module(name)
module.__file__ = '<test>'
module.__package__ = ''
with util.uncache(name):
sys.modules[name] = module
yield from bench(name, repeat=repeat, seconds=seconds)
def builtin_mod(seconds, repeat):
"""Built-in module"""
name = 'errno'
if name in sys.modules:
del sys.modules[name]
# Relying on built-in importer being implicit.
yield from bench(name, lambda: sys.modules.pop(name), repeat=repeat,
seconds=seconds)
def source_wo_bytecode(seconds, repeat):
"""Source w/o bytecode: small"""
sys.dont_write_bytecode = True
try:
name = '__importlib_test_benchmark__'
# Clears out sys.modules and puts an entry at the front of sys.path.
with util.create_modules(name) as mapping:
assert not os.path.exists(imp.cache_from_source(mapping[name]))
sys.meta_path.append(importlib.machinery.PathFinder)
loader = (importlib.machinery.SourceFileLoader,
importlib.machinery.SOURCE_SUFFIXES)
sys.path_hooks.append(importlib.machinery.FileFinder.path_hook(loader))
yield from bench(name, lambda: sys.modules.pop(name), repeat=repeat,
seconds=seconds)
finally:
sys.dont_write_bytecode = False
def _wo_bytecode(module):
name = module.__name__
def benchmark_wo_bytecode(seconds, repeat):
"""Source w/o bytecode: {}"""
bytecode_path = imp.cache_from_source(module.__file__)
if os.path.exists(bytecode_path):
os.unlink(bytecode_path)
sys.dont_write_bytecode = True
try:
yield from bench(name, lambda: sys.modules.pop(name),
repeat=repeat, seconds=seconds)
finally:
sys.dont_write_bytecode = False
benchmark_wo_bytecode.__doc__ = benchmark_wo_bytecode.__doc__.format(name)
return benchmark_wo_bytecode
tabnanny_wo_bytecode = _wo_bytecode(tabnanny)
decimal_wo_bytecode = _wo_bytecode(decimal)
def source_writing_bytecode(seconds, repeat):
"""Source writing bytecode: small"""
assert not sys.dont_write_bytecode
name = '__importlib_test_benchmark__'
with util.create_modules(name) as mapping:
sys.meta_path.append(importlib.machinery.PathFinder)
loader = (importlib.machinery.SourceFileLoader,
importlib.machinery.SOURCE_SUFFIXES)
sys.path_hooks.append(importlib.machinery.FileFinder.path_hook(loader))
def cleanup():
sys.modules.pop(name)
os.unlink(imp.cache_from_source(mapping[name]))
for result in bench(name, cleanup, repeat=repeat, seconds=seconds):
assert not os.path.exists(imp.cache_from_source(mapping[name]))
yield result
def _writing_bytecode(module):
name = module.__name__
def writing_bytecode_benchmark(seconds, repeat):
"""Source writing bytecode: {}"""
assert not sys.dont_write_bytecode
def cleanup():
sys.modules.pop(name)
os.unlink(imp.cache_from_source(module.__file__))
yield from bench(name, cleanup, repeat=repeat, seconds=seconds)
writing_bytecode_benchmark.__doc__ = (
writing_bytecode_benchmark.__doc__.format(name))
return writing_bytecode_benchmark
tabnanny_writing_bytecode = _writing_bytecode(tabnanny)
decimal_writing_bytecode = _writing_bytecode(decimal)
def source_using_bytecode(seconds, repeat):
"""Source w/ bytecode: small"""
name = '__importlib_test_benchmark__'
with util.create_modules(name) as mapping:
sys.meta_path.append(importlib.machinery.PathFinder)
loader = (importlib.machinery.SourceFileLoader,
importlib.machinery.SOURCE_SUFFIXES)
sys.path_hooks.append(importlib.machinery.FileFinder.path_hook(loader))
py_compile.compile(mapping[name])
assert os.path.exists(imp.cache_from_source(mapping[name]))
yield from bench(name, lambda: sys.modules.pop(name), repeat=repeat,
seconds=seconds)
def _using_bytecode(module):
name = module.__name__
def using_bytecode_benchmark(seconds, repeat):
"""Source w/ bytecode: {}"""
py_compile.compile(module.__file__)
yield from bench(name, lambda: sys.modules.pop(name), repeat=repeat,
seconds=seconds)
using_bytecode_benchmark.__doc__ = (
using_bytecode_benchmark.__doc__.format(name))
return using_bytecode_benchmark
tabnanny_using_bytecode = _using_bytecode(tabnanny)
decimal_using_bytecode = _using_bytecode(decimal)
def main(import_, options):
if options.source_file:
with options.source_file:
prev_results = json.load(options.source_file)
else:
prev_results = {}
__builtins__.__import__ = import_
benchmarks = (from_cache, builtin_mod,
source_writing_bytecode,
source_wo_bytecode, source_using_bytecode,
tabnanny_writing_bytecode,
tabnanny_wo_bytecode, tabnanny_using_bytecode,
decimal_writing_bytecode,
decimal_wo_bytecode, decimal_using_bytecode,
)
if options.benchmark:
for b in benchmarks:
if b.__doc__ == options.benchmark:
benchmarks = [b]
break
else:
print('Unknown benchmark: {!r}'.format(options.benchmark,
file=sys.stderr))
sys.exit(1)
seconds = 1
seconds_plural = 's' if seconds > 1 else ''
repeat = 3
header = ('Measuring imports/second over {} second{}, best out of {}\n'
'Entire benchmark run should take about {} seconds\n'
'Using {!r} as __import__\n')
print(header.format(seconds, seconds_plural, repeat,
len(benchmarks) * seconds * repeat, __import__))
new_results = {}
for benchmark in benchmarks:
print(benchmark.__doc__, "[", end=' ')
sys.stdout.flush()
results = []
for result in benchmark(seconds=seconds, repeat=repeat):
results.append(result)
print(result, end=' ')
sys.stdout.flush()
assert not sys.dont_write_bytecode
print("]", "best is", format(max(results), ',d'))
new_results[benchmark.__doc__] = results
if prev_results:
print('\n\nComparing new vs. old\n')
for benchmark in benchmarks:
benchmark_name = benchmark.__doc__
old_result = max(prev_results[benchmark_name])
new_result = max(new_results[benchmark_name])
result = '{:,d} vs. {:,d} ({:%})'.format(new_result,
old_result,
new_result/old_result)
print(benchmark_name, ':', result)
if options.dest_file:
with options.dest_file:
json.dump(new_results, options.dest_file, indent=2)
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-b', '--builtin', dest='builtin', action='store_true',
default=False, help="use the built-in __import__")
parser.add_argument('-r', '--read', dest='source_file',
type=argparse.FileType('r'),
help='file to read benchmark data from to compare '
'against')
parser.add_argument('-w', '--write', dest='dest_file',
type=argparse.FileType('w'),
help='file to write benchmark data to')
parser.add_argument('--benchmark', dest='benchmark',
help='specific benchmark to run')
options = parser.parse_args()
import_ = __import__
if not options.builtin:
import_ = importlib.__import__
main(import_, options)
| 9,140 | 245 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/importbench/README | Importbench is a set of micro-benchmarks for various import scenarios.
It should not be used as an overall benchmark of import performance, but rather
an easy way to measure impact of possible code changes. For a real-world
benchmark of import, use the normal_startup benchmark from
https://github.com/python/performance
| 322 | 7 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/comparecodecs.py | #!/usr/bin/env python3
""" Compare the output of two codecs.
(c) Copyright 2005, Marc-Andre Lemburg ([email protected]).
Licensed to PSF under a Contributor Agreement.
"""
import sys
def compare_codecs(encoding1, encoding2):
print('Comparing encoding/decoding of %r and %r' % (encoding1, encoding2))
mismatch = 0
# Check encoding
for i in range(sys.maxunicode+1):
u = chr(i)
try:
c1 = u.encode(encoding1)
except UnicodeError as reason:
c1 = '<undefined>'
try:
c2 = u.encode(encoding2)
except UnicodeError as reason:
c2 = '<undefined>'
if c1 != c2:
print(' * encoding mismatch for 0x%04X: %-14r != %r' % \
(i, c1, c2))
mismatch += 1
# Check decoding
for i in range(256):
c = bytes([i])
try:
u1 = c.decode(encoding1)
except UnicodeError:
u1 = '<undefined>'
try:
u2 = c.decode(encoding2)
except UnicodeError:
u2 = '<undefined>'
if u1 != u2:
print(' * decoding mismatch for 0x%04X: %-14r != %r' % \
(i, u1, u2))
mismatch += 1
if mismatch:
print()
print('Found %i mismatches' % mismatch)
else:
print('-> Codecs are identical.')
if __name__ == '__main__':
compare_codecs(sys.argv[1], sys.argv[2])
| 1,440 | 54 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/listcodecs.py | """ List all available codec modules.
(c) Copyright 2005, Marc-Andre Lemburg ([email protected]).
Licensed to PSF under a Contributor Agreement.
"""
import os, codecs, encodings
_debug = 0
def listcodecs(dir):
names = []
for filename in os.listdir(dir):
if filename[-3:] != '.py':
continue
name = filename[:-3]
# Check whether we've found a true codec
try:
codecs.lookup(name)
except LookupError:
# Codec not found
continue
except Exception as reason:
# Probably an error from importing the codec; still it's
# a valid code name
if _debug:
print('* problem importing codec %r: %s' % \
(name, reason))
names.append(name)
return names
if __name__ == '__main__':
names = listcodecs(encodings.__path__[0])
names.sort()
print('all_codecs = [')
for name in names:
print(' %r,' % name)
print(']')
| 1,021 | 42 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/gencjkcodecs.py | import os, string
codecs = {
'cn': ('gb2312', 'gbk', 'gb18030', 'hz'),
'tw': ('big5', 'cp950'),
'hk': ('big5hkscs',),
'jp': ('cp932', 'shift_jis', 'euc_jp', 'euc_jisx0213', 'shift_jisx0213',
'euc_jis_2004', 'shift_jis_2004'),
'kr': ('cp949', 'euc_kr', 'johab'),
'iso2022': ('iso2022_jp', 'iso2022_jp_1', 'iso2022_jp_2',
'iso2022_jp_2004', 'iso2022_jp_3', 'iso2022_jp_ext',
'iso2022_kr'),
}
TEMPLATE = string.Template("""\
#
# $encoding.py: Python Unicode Codec for $ENCODING
#
# Written by Hye-Shik Chang <[email protected]>
#
import _codecs_$owner, codecs
import _multibytecodec as mbc
codec = _codecs_$owner.getcodec('$encoding')
class Codec(codecs.Codec):
encode = codec.encode
decode = codec.decode
class IncrementalEncoder(mbc.MultibyteIncrementalEncoder,
codecs.IncrementalEncoder):
codec = codec
class IncrementalDecoder(mbc.MultibyteIncrementalDecoder,
codecs.IncrementalDecoder):
codec = codec
class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):
codec = codec
class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
codec = codec
def getregentry():
return codecs.CodecInfo(
name='$encoding',
encode=Codec().encode,
decode=Codec().decode,
incrementalencoder=IncrementalEncoder,
incrementaldecoder=IncrementalDecoder,
streamreader=StreamReader,
streamwriter=StreamWriter,
)
""")
def gencodecs(prefix):
for loc, encodings in codecs.items():
for enc in encodings:
code = TEMPLATE.substitute(ENCODING=enc.upper(),
encoding=enc.lower(),
owner=loc)
codecpath = os.path.join(prefix, enc + '.py')
open(codecpath, 'w').write(code)
if __name__ == '__main__':
import sys
gencodecs(sys.argv[1]
if len(sys.argv) > 1 else
"third_party/python/Lib/encodings")
| 2,073 | 71 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/gencodec.py | """ Unicode Mapping Parser and Codec Generator.
This script parses Unicode mapping files as available from the Unicode
site (ftp://ftp.unicode.org/Public/MAPPINGS/) and creates Python codec
modules from them. The codecs use the standard character mapping codec
to actually apply the mapping.
Synopsis: gencodec.py dir codec_prefix
All files in dir are scanned and those producing non-empty mappings
will be written to <codec_prefix><mapname>.py with <mapname> being the
first part of the map's filename ('a' in a.b.c.txt) converted to
lowercase with hyphens replaced by underscores.
The tool also writes marshalled versions of the mapping tables to the
same location (with .mapping extension).
Written by Marc-Andre Lemburg ([email protected]).
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
(c) Copyright Guido van Rossum, 2000.
Table generation:
(c) Copyright Marc-Andre Lemburg, 2005.
Licensed to PSF under a Contributor Agreement.
"""#"
import re, os, marshal, codecs
# Maximum allowed size of charmap tables
MAX_TABLE_SIZE = 8192
# Standard undefined Unicode code point
UNI_UNDEFINED = chr(0xFFFE)
# Placeholder for a missing code point
MISSING_CODE = -1
mapRE = re.compile(r'((?:0x[0-9a-fA-F]+\+?)+)'
r'\s+'
r'((?:(?:0x[0-9a-fA-Z]+|<[A-Za-z]+>)\+?)*)'
r'\s*'
r'(#.+)?')
def parsecodes(codes, len=len, range=range):
""" Converts code combinations to either a single code integer
or a tuple of integers.
meta-codes (in angular brackets, e.g. <LR> and <RL>) are
ignored.
Empty codes or illegal ones are returned as None.
"""
if not codes:
return MISSING_CODE
l = codes.split('+')
if len(l) == 1:
return int(l[0],16)
for i in range(len(l)):
try:
l[i] = int(l[i],16)
except ValueError:
l[i] = MISSING_CODE
l = [x for x in l if x != MISSING_CODE]
if len(l) == 1:
return l[0]
else:
return tuple(l)
def readmap(filename):
f = open(filename,'r')
lines = f.readlines()
f.close()
enc2uni = {}
identity = []
unmapped = list(range(256))
# UTC mapping tables per convention don't include the identity
# mappings for code points 0x00 - 0x1F and 0x7F, unless these are
# explicitly mapped to different characters or undefined
for i in list(range(32)) + [127]:
identity.append(i)
unmapped.remove(i)
enc2uni[i] = (i, 'CONTROL CHARACTER')
for line in lines:
line = line.strip()
if not line or line[0] == '#':
continue
m = mapRE.match(line)
if not m:
#print '* not matched: %s' % repr(line)
continue
enc,uni,comment = m.groups()
enc = parsecodes(enc)
uni = parsecodes(uni)
if comment is None:
comment = ''
else:
comment = comment[1:].strip()
if not isinstance(enc, tuple) and enc < 256:
if enc in unmapped:
unmapped.remove(enc)
if enc == uni:
identity.append(enc)
enc2uni[enc] = (uni,comment)
else:
enc2uni[enc] = (uni,comment)
# If there are more identity-mapped entries than unmapped entries,
# it pays to generate an identity dictionary first, and add explicit
# mappings to None for the rest
if len(identity) >= len(unmapped):
for enc in unmapped:
enc2uni[enc] = (MISSING_CODE, "")
enc2uni['IDENTITY'] = 256
return enc2uni
def hexrepr(t, precision=4):
if t is None:
return 'None'
try:
len(t)
except TypeError:
return '0x%0*X' % (precision, t)
try:
return '(' + ', '.join(['0x%0*X' % (precision, item)
for item in t]) + ')'
except TypeError as why:
print('* failed to convert %r: %s' % (t, why))
raise
def python_mapdef_code(varname, map, comments=1, precisions=(2, 4)):
l = []
append = l.append
if "IDENTITY" in map:
append("%s = codecs.make_identity_dict(range(%d))" %
(varname, map["IDENTITY"]))
append("%s.update({" % varname)
splits = 1
del map["IDENTITY"]
identity = 1
else:
append("%s = {" % varname)
splits = 0
identity = 0
mappings = sorted(map.items())
i = 0
key_precision, value_precision = precisions
for mapkey, mapvalue in mappings:
mapcomment = ''
if isinstance(mapkey, tuple):
(mapkey, mapcomment) = mapkey
if isinstance(mapvalue, tuple):
(mapvalue, mapcomment) = mapvalue
if mapkey is None:
continue
if (identity and
mapkey == mapvalue and
mapkey < 256):
# No need to include identity mappings, since these
# are already set for the first 256 code points.
continue
key = hexrepr(mapkey, key_precision)
value = hexrepr(mapvalue, value_precision)
if mapcomment and comments:
append(' %s: %s,\t# %s' % (key, value, mapcomment))
else:
append(' %s: %s,' % (key, value))
i += 1
if i == 4096:
# Split the definition into parts to that the Python
# parser doesn't dump core
if splits == 0:
append('}')
else:
append('})')
append('%s.update({' % varname)
i = 0
splits = splits + 1
if splits == 0:
append('}')
else:
append('})')
return l
def python_tabledef_code(varname, map, comments=1, key_precision=2):
l = []
append = l.append
append('%s = (' % varname)
# Analyze map and create table dict
mappings = sorted(map.items())
table = {}
maxkey = 255
if 'IDENTITY' in map:
for key in range(256):
table[key] = (key, '')
del map['IDENTITY']
for mapkey, mapvalue in mappings:
mapcomment = ''
if isinstance(mapkey, tuple):
(mapkey, mapcomment) = mapkey
if isinstance(mapvalue, tuple):
(mapvalue, mapcomment) = mapvalue
if mapkey == MISSING_CODE:
continue
table[mapkey] = (mapvalue, mapcomment)
if mapkey > maxkey:
maxkey = mapkey
if maxkey > MAX_TABLE_SIZE:
# Table too large
return None
# Create table code
maxchar = 0
for key in range(maxkey + 1):
if key not in table:
mapvalue = MISSING_CODE
mapcomment = 'UNDEFINED'
else:
mapvalue, mapcomment = table[key]
if mapvalue == MISSING_CODE:
mapchar = UNI_UNDEFINED
else:
if isinstance(mapvalue, tuple):
# 1-n mappings not supported
return None
else:
mapchar = chr(mapvalue)
maxchar = max(maxchar, ord(mapchar))
if mapcomment and comments:
append(' %a \t# %s -> %s' % (mapchar,
hexrepr(key, key_precision),
mapcomment))
else:
append(' %a' % mapchar)
if maxchar < 256:
append(' %a \t## Widen to UCS2 for optimization' % UNI_UNDEFINED)
append(')')
return l
def codegen(name, map, encodingname, comments=1):
""" Returns Python source for the given map.
Comments are included in the source, if comments is true (default).
"""
# Generate code
decoding_map_code = python_mapdef_code(
'decoding_map',
map,
comments=comments)
decoding_table_code = python_tabledef_code(
'decoding_table',
map,
comments=comments)
encoding_map_code = python_mapdef_code(
'encoding_map',
codecs.make_encoding_map(map),
comments=comments,
precisions=(4, 2))
if decoding_table_code:
suffix = 'table'
else:
suffix = 'map'
l = [
'''\
""" Python Character Mapping Codec %s generated from '%s' with gencodec.py.
"""#"
import codecs
### Codec APIs
class Codec(codecs.Codec):
def encode(self, input, errors='strict'):
return codecs.charmap_encode(input, errors, encoding_%s)
def decode(self, input, errors='strict'):
return codecs.charmap_decode(input, errors, decoding_%s)
''' % (encodingname, name, suffix, suffix)]
l.append('''\
class IncrementalEncoder(codecs.IncrementalEncoder):
def encode(self, input, final=False):
return codecs.charmap_encode(input, self.errors, encoding_%s)[0]
class IncrementalDecoder(codecs.IncrementalDecoder):
def decode(self, input, final=False):
return codecs.charmap_decode(input, self.errors, decoding_%s)[0]''' %
(suffix, suffix))
l.append('''
class StreamWriter(Codec, codecs.StreamWriter):
pass
class StreamReader(Codec, codecs.StreamReader):
pass
### encodings module API
def getregentry():
return codecs.CodecInfo(
name=%r,
encode=Codec().encode,
decode=Codec().decode,
incrementalencoder=IncrementalEncoder,
incrementaldecoder=IncrementalDecoder,
streamreader=StreamReader,
streamwriter=StreamWriter,
)
''' % encodingname.replace('_', '-'))
# Add decoding table or map (with preference to the table)
if not decoding_table_code:
l.append('''
### Decoding Map
''')
l.extend(decoding_map_code)
else:
l.append('''
### Decoding Table
''')
l.extend(decoding_table_code)
# Add encoding map
if decoding_table_code:
l.append('''
### Encoding table
encoding_table = codecs.charmap_build(decoding_table)
''')
else:
l.append('''
### Encoding Map
''')
l.extend(encoding_map_code)
# Final new-line
l.append('')
return '\n'.join(l).expandtabs()
def pymap(name,map,pyfile,encodingname,comments=1):
code = codegen(name,map,encodingname,comments)
f = open(pyfile,'w')
f.write(code)
f.close()
def marshalmap(name,map,marshalfile):
d = {}
for e,(u,c) in map.items():
d[e] = (u,c)
f = open(marshalfile,'wb')
marshal.dump(d,f)
f.close()
def convertdir(dir, dirprefix='', nameprefix='', comments=1):
mapnames = os.listdir(dir)
for mapname in mapnames:
mappathname = os.path.join(dir, mapname)
if not os.path.isfile(mappathname):
continue
name = os.path.split(mapname)[1]
name = name.replace('-','_')
name = name.split('.')[0]
name = name.lower()
name = nameprefix + name
codefile = name + '.py'
marshalfile = name + '.mapping'
print('converting %s to %s and %s' % (mapname,
dirprefix + codefile,
dirprefix + marshalfile))
try:
map = readmap(os.path.join(dir,mapname))
if not map:
print('* map is empty; skipping')
else:
pymap(mappathname, map, dirprefix + codefile,name,comments)
marshalmap(mappathname, map, dirprefix + marshalfile)
except ValueError as why:
print('* conversion failed: %s' % why)
raise
def rewritepythondir(dir, dirprefix='', comments=1):
mapnames = os.listdir(dir)
for mapname in mapnames:
if not mapname.endswith('.mapping'):
continue
name = mapname[:-len('.mapping')]
codefile = name + '.py'
print('converting %s to %s' % (mapname,
dirprefix + codefile))
try:
map = marshal.load(open(os.path.join(dir,mapname),
'rb'))
if not map:
print('* map is empty; skipping')
else:
pymap(mapname, map, dirprefix + codefile,name,comments)
except ValueError as why:
print('* conversion failed: %s' % why)
if __name__ == '__main__':
import sys
if 1:
convertdir(*sys.argv[1:])
else:
rewritepythondir(*sys.argv[1:])
| 12,337 | 430 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/makecjkcodecs.c | /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-â
âvi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ¡
â Copyright 2021 Justine Alexandra Roberts Tunney â
â â
â Permission to use, copy, modify, and/or distribute this software for â
â any purpose with or without fee is hereby granted, provided that the â
â above copyright notice and this permission notice appear in all copies. â
â â
â THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL â
â WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED â
â WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE â
â AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL â
â DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR â
â PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER â
â TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR â
â PERFORMANCE OF THIS SOFTWARE. â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/assert.h"
#include "libc/fmt/leb128.h"
#include "libc/log/check.h"
#include "libc/nexgen32e/crc32.h"
#include "libc/runtime/runtime.h"
#include "libc/stdio/append.h"
#include "libc/stdio/stdio.h"
#include "libc/x/x.h"
#include "third_party/zlib/zlib.h"
#define MAC(x) m(#x, x, sizeof(x))
#define DZD(x) dzd(#x, x, sizeof(x), sizeof(x[0]))
static void *Deflate(const void *data, size_t size, size_t *out_size) {
void *res;
z_stream zs;
zs.zfree = 0;
zs.zalloc = 0;
CHECK_EQ(Z_OK, deflateInit2(&zs, Z_BEST_COMPRESSION, Z_DEFLATED, -MAX_WBITS,
DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY));
zs.next_in = data;
zs.avail_in = size;
zs.avail_out = compressBound(size);
zs.next_out = res = xmalloc(zs.avail_out);
CHECK_EQ(Z_STREAM_END, deflate(&zs, Z_FINISH));
CHECK_EQ(Z_OK, deflateEnd(&zs));
*out_size = zs.total_out;
return xrealloc(res, zs.total_out);
}
void m(const char *s, void *p, size_t n) {
FILE *f;
size_t i, m;
unsigned char *q;
q = Deflate(p, n, &m);
f = fopen(xstrcat("third_party/python/Modules/cjkcodecs/", s, ".c"), "wb");
fprintf(f, "#include \"libc/x/x.h\"\n");
fprintf(f, "/* clang-format off */\n");
fprintf(f, "\n");
fprintf(f, "static _Atomic(void *) %s_ptr;\n", s);
fprintf(f, "static const unsigned char %s_rodata[] = {", s);
for (i = 0; i < m; ++i) {
if (i % 13 == 0) fprintf(f, "\n ");
fprintf(f, " 0x%02x,", q[i]);
}
fprintf(f, "\n};\n");
fprintf(f, "\n");
fprintf(f, "optimizesize void *%s(void) {\n", s);
fprintf(f, " return xload(&%s_ptr,\n", s);
fprintf(f, " %s_rodata,\n", s);
fprintf(f, " %d, %d); /* %g%% profit */\n", m, n,
(double)m / n * 100);
fprintf(f, "}\n");
fclose(f);
printf("\tthird_party/python/Modules/cjkcodecs/%s.c\t\\\n", s);
}
void dzd(const char *s, void *p, size_t n, size_t z) {
FILE *f;
uint32_t S;
size_t i, m;
int64_t x, y;
char *r, *q, *b, t[19];
S = crc32_z(0, p, n);
for (r = 0, y = i = 0; i < n / z; ++i) {
if (z == 2) {
x = ((const uint16_t *)p)[i];
} else if (z == 4) {
x = ((const uint32_t *)p)[i];
} else {
unreachable;
}
appendd(&r, t, zleb64(t, x - y) - t);
y = x;
}
q = Deflate(r, appendz(r).i, &m);
f = fopen(xstrcat("third_party/python/Modules/cjkcodecs/", s, ".c"), "wb");
fprintf(f, "#include \"libc/x/x.h\"\n");
fprintf(f, "/* clang-format off */\n");
fprintf(f, "\n");
fprintf(f, "static _Atomic(void *) %s_ptr;\n", s);
fprintf(f, "static const unsigned char %s_rodata[%zu] = {", s, m);
for (i = 0; i < m; ++i) {
if (i % 13 == 0) fprintf(f, "\n ");
fprintf(f, " 0x%02x,", q[i] & 255);
}
fprintf(f, "\n};\n");
fprintf(f, "\n");
fprintf(f, "optimizesize void *%s(void) {\n", s);
fprintf(f, " return xloadzd(&%s_ptr,\n", s);
fprintf(f, " %s_rodata,\n", s);
fprintf(f, " %d, %d, %d, %d, 0x%08xu); /* %g%% profit */\n",
m, appendz(r).i, n / z, z, S, (double)m / n * 100);
fprintf(f, "}\n");
fclose(f);
printf("\tthird_party/python/Modules/cjkcodecs/%s.c\t\\\n", s);
}
#define JISX0213_ENCPAIRS 46
#define UNIINV 0xFFFE
#define NOCHAR 0xFFFF
#define MULTIC 0xFFFE
#define DBCINV 0xFFFD
#define U UNIINV
#define N NOCHAR
#define M MULTIC
#define D DBCINV
typedef uint16_t ucs2_t;
typedef uint16_t DBCHAR;
typedef uint32_t Py_UCS4;
struct CjkIndex {
uint16_t map;
unsigned char bottom, top;
};
struct CjkPairEncodeMap {
uint32_t uniseq;
uint16_t code;
};
#include "mappings_cn.inc"
#include "mappings_hk.inc"
#include "mappings_jisx0213_pair.inc"
#include "mappings_jp.inc"
#include "mappings_kr.inc"
#include "mappings_tw.inc"
int main(int argc, char *argv[]) {
MAC(big5_decmap);
MAC(big5_encmap);
MAC(big5hkscs_bmp_encmap);
MAC(big5hkscs_decmap);
MAC(big5hkscs_nonbmp_encmap);
MAC(cp932ext_decmap);
MAC(cp932ext_encmap);
MAC(cp949_encmap);
MAC(cp949ext_decmap);
MAC(cp950ext_decmap);
MAC(cp950ext_encmap);
MAC(gb18030ext_decmap);
MAC(gb18030ext_encmap);
MAC(gb2312_decmap);
MAC(gbcommon_encmap);
MAC(gbkext_decmap);
MAC(jisx0208_decmap);
MAC(jisx0212_decmap);
MAC(jisx0213_1_bmp_decmap);
MAC(jisx0213_1_emp_decmap);
MAC(jisx0213_2_bmp_decmap);
MAC(jisx0213_2_emp_decmap);
MAC(jisx0213_bmp_encmap);
MAC(jisx0213_emp_encmap);
MAC(jisx0213_pair_decmap);
MAC(jisxcommon_encmap);
MAC(ksx1001_decmap);
MAC(jisx0213_pair_encmap);
DZD(__big5_decmap);
MAC(__big5_encmap);
MAC(__big5hkscs_bmp_encmap);
MAC(__big5hkscs_decmap);
MAC(__big5hkscs_nonbmp_encmap);
DZD(__cp932ext_decmap);
MAC(__cp932ext_encmap);
DZD(__cp949_encmap);
DZD(__cp949ext_decmap);
DZD(__cp950ext_decmap);
MAC(__cp950ext_encmap);
DZD(__gb18030ext_decmap);
DZD(__gb18030ext_encmap);
DZD(__gb2312_decmap);
DZD(__gbcommon_encmap);
DZD(__gbkext_decmap);
DZD(__jisx0208_decmap);
DZD(__jisx0212_decmap);
DZD(__jisx0213_1_bmp_decmap);
MAC(__jisx0213_1_emp_decmap);
DZD(__jisx0213_2_bmp_decmap);
MAC(__jisx0213_2_emp_decmap);
MAC(__jisx0213_bmp_encmap);
MAC(__jisx0213_emp_encmap);
DZD(__jisx0213_pair_decmap);
MAC(__jisxcommon_encmap);
DZD(__ksx1001_decmap);
return 0;
}
| 7,067 | 207 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/genwincodecs.bat | @rem Recreate some python charmap codecs from the Windows function
@rem MultiByteToWideChar.
@cd /d %~dp0
@mkdir build
@rem Arabic DOS code page
c:\python30\python genwincodec.py 720 > build/cp720.py
| 201 | 8 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/mkstringprep.py | import re, sys
from unicodedata import ucd_3_2_0 as unicodedata
if sys.maxunicode == 65535:
raise RuntimeError("need UCS-4 Python")
def gen_category(cats):
for i in range(0, 0x110000):
if unicodedata.category(chr(i)) in cats:
yield(i)
def gen_bidirectional(cats):
for i in range(0, 0x110000):
if unicodedata.bidirectional(chr(i)) in cats:
yield(i)
def compact_set(l):
single = []
tuple = []
prev = None
span = 0
for e in l:
if prev is None:
prev = e
span = 0
continue
if prev+span+1 != e:
if span > 2:
tuple.append((prev,prev+span+1))
else:
for i in range(prev, prev+span+1):
single.append(i)
prev = e
span = 0
else:
span += 1
if span:
tuple.append((prev,prev+span+1))
else:
single.append(prev)
if not single and len(tuple) == 1:
tuple = "range(%d,%d)" % tuple[0]
else:
tuple = " + ".join("list(range(%d,%d))" % t for t in tuple)
if not single:
return "set(%s)" % tuple
if not tuple:
return "set(%r)" % (single,)
return "set(%r + %s)" % (single, tuple)
############## Read the tables in the RFC #######################
with open("rfc3454.txt") as f:
data = f.readlines()
tables = []
curname = None
for l in data:
l = l.strip()
if not l:
continue
# Skip RFC page breaks
if l.startswith(("Hoffman & Blanchet", "RFC 3454")):
continue
# Find start/end lines
m = re.match("----- (Start|End) Table ([A-Z](.[0-9])+) -----", l)
if m:
if m.group(1) == "Start":
if curname:
raise RuntimeError("Double Start", (curname, l))
curname = m.group(2)
table = {}
tables.append((curname, table))
continue
else:
if not curname:
raise RuntimeError("End without start", l)
if curname != m.group(2):
raise RuntimeError("Unexpected end", l)
curname = None
continue
if not curname:
continue
# Now we are in a table
fields = l.split(";")
if len(fields) > 1:
# Drop comment field
fields = fields[:-1]
if len(fields) == 1:
fields = fields[0].split("-")
if len(fields) > 1:
# range
try:
start, end = fields
except ValueError:
raise RuntimeError("Unpacking problem", l)
else:
start = end = fields[0]
start = int(start, 16)
end = int(end, 16)
for i in range(start, end+1):
table[i] = i
else:
code, value = fields
value = value.strip()
if value:
value = [int(v, 16) for v in value.split(" ")]
else:
# table B.1
value = None
table[int(code, 16)] = value
########### Generate compact Python versions of the tables #############
print("""# This file is generated by mkstringprep.py. DO NOT EDIT.
\"\"\"Library that exposes various tables found in the StringPrep RFC 3454.
There are two kinds of tables: sets, for which a member test is provided,
and mappings, for which a mapping function is provided.
\"\"\"
from unicodedata import ucd_3_2_0 as unicodedata
""")
print("assert unicodedata.unidata_version == %r" % (unicodedata.unidata_version,))
# A.1 is the table of unassigned characters
# XXX Plane 15 PUA is listed as unassigned in Python.
name, table = tables[0]
del tables[0]
assert name == "A.1"
table = set(table.keys())
Cn = set(gen_category(["Cn"]))
# FDD0..FDEF are process internal codes
Cn -= set(range(0xFDD0, 0xFDF0))
# not a character
Cn -= set(range(0xFFFE, 0x110000, 0x10000))
Cn -= set(range(0xFFFF, 0x110000, 0x10000))
# assert table == Cn
print("""
def in_table_a1(code):
if unicodedata.category(code) != 'Cn': return False
c = ord(code)
if 0xFDD0 <= c < 0xFDF0: return False
return (c & 0xFFFF) not in (0xFFFE, 0xFFFF)
""")
# B.1 cannot easily be derived
name, table = tables[0]
del tables[0]
assert name == "B.1"
table = sorted(table.keys())
print("""
b1_set = """ + compact_set(table) + """
def in_table_b1(code):
return ord(code) in b1_set
""")
# B.2 and B.3 is case folding.
# It takes CaseFolding.txt into account, which is
# not available in the Python database. Since
# B.2 is derived from B.3, we process B.3 first.
# B.3 supposedly *is* CaseFolding-3.2.0.txt.
name, table_b2 = tables[0]
del tables[0]
assert name == "B.2"
name, table_b3 = tables[0]
del tables[0]
assert name == "B.3"
# B.3 is mostly Python's .lower, except for a number
# of special cases, e.g. considering canonical forms.
b3_exceptions = {}
for k,v in table_b2.items():
if list(map(ord, chr(k).lower())) != v:
b3_exceptions[k] = "".join(map(chr,v))
b3 = sorted(b3_exceptions.items())
print("""
b3_exceptions = {""")
for i, kv in enumerate(b3):
print("0x%x:%a," % kv, end=' ')
if i % 4 == 3:
print()
print("}")
print("""
def map_table_b3(code):
r = b3_exceptions.get(ord(code))
if r is not None: return r
return code.lower()
""")
def map_table_b3(code):
r = b3_exceptions.get(ord(code))
if r is not None: return r
return code.lower()
# B.2 is case folding for NFKC. This is the same as B.3,
# except where NormalizeWithKC(Fold(a)) !=
# NormalizeWithKC(Fold(NormalizeWithKC(Fold(a))))
def map_table_b2(a):
al = map_table_b3(a)
b = unicodedata.normalize("NFKC", al)
bl = "".join([map_table_b3(ch) for ch in b])
c = unicodedata.normalize("NFKC", bl)
if b != c:
return c
else:
return al
specials = {}
for k,v in table_b2.items():
if list(map(ord, map_table_b2(chr(k)))) != v:
specials[k] = v
# B.3 should not add any additional special cases
assert specials == {}
print("""
def map_table_b2(a):
al = map_table_b3(a)
b = unicodedata.normalize("NFKC", al)
bl = "".join([map_table_b3(ch) for ch in b])
c = unicodedata.normalize("NFKC", bl)
if b != c:
return c
else:
return al
""")
# C.1.1 is a table with a single character
name, table = tables[0]
del tables[0]
assert name == "C.1.1"
assert table == {0x20:0x20}
print("""
def in_table_c11(code):
return code == " "
""")
# C.1.2 is the rest of all space characters
name, table = tables[0]
del tables[0]
assert name == "C.1.2"
# table = set(table.keys())
# Zs = set(gen_category(["Zs"])) - {0x20}
# assert Zs == table
print("""
def in_table_c12(code):
return unicodedata.category(code) == "Zs" and code != " "
def in_table_c11_c12(code):
return unicodedata.category(code) == "Zs"
""")
# C.2.1 ASCII control characters
name, table_c21 = tables[0]
del tables[0]
assert name == "C.2.1"
Cc = set(gen_category(["Cc"]))
Cc_ascii = Cc & set(range(128))
table_c21 = set(table_c21.keys())
assert Cc_ascii == table_c21
print("""
def in_table_c21(code):
return ord(code) < 128 and unicodedata.category(code) == "Cc"
""")
# C.2.2 Non-ASCII control characters. It also includes
# a number of characters in category Cf.
name, table_c22 = tables[0]
del tables[0]
assert name == "C.2.2"
Cc_nonascii = Cc - Cc_ascii
table_c22 = set(table_c22.keys())
assert len(Cc_nonascii - table_c22) == 0
specials = list(table_c22 - Cc_nonascii)
specials.sort()
print("""c22_specials = """ + compact_set(specials) + """
def in_table_c22(code):
c = ord(code)
if c < 128: return False
if unicodedata.category(code) == "Cc": return True
return c in c22_specials
def in_table_c21_c22(code):
return unicodedata.category(code) == "Cc" or \\
ord(code) in c22_specials
""")
# C.3 Private use
name, table = tables[0]
del tables[0]
assert name == "C.3"
Co = set(gen_category(["Co"]))
assert set(table.keys()) == Co
print("""
def in_table_c3(code):
return unicodedata.category(code) == "Co"
""")
# C.4 Non-character code points, xFFFE, xFFFF
# plus process internal codes
name, table = tables[0]
del tables[0]
assert name == "C.4"
nonchar = set(range(0xFDD0,0xFDF0))
nonchar.update(range(0xFFFE,0x110000,0x10000))
nonchar.update(range(0xFFFF,0x110000,0x10000))
table = set(table.keys())
assert table == nonchar
print("""
def in_table_c4(code):
c = ord(code)
if c < 0xFDD0: return False
if c < 0xFDF0: return True
return (ord(code) & 0xFFFF) in (0xFFFE, 0xFFFF)
""")
# C.5 Surrogate codes
name, table = tables[0]
del tables[0]
assert name == "C.5"
Cs = set(gen_category(["Cs"]))
assert set(table.keys()) == Cs
print("""
def in_table_c5(code):
return unicodedata.category(code) == "Cs"
""")
# C.6 Inappropriate for plain text
name, table = tables[0]
del tables[0]
assert name == "C.6"
table = sorted(table.keys())
print("""
c6_set = """ + compact_set(table) + """
def in_table_c6(code):
return ord(code) in c6_set
""")
# C.7 Inappropriate for canonical representation
name, table = tables[0]
del tables[0]
assert name == "C.7"
table = sorted(table.keys())
print("""
c7_set = """ + compact_set(table) + """
def in_table_c7(code):
return ord(code) in c7_set
""")
# C.8 Change display properties or are deprecated
name, table = tables[0]
del tables[0]
assert name == "C.8"
table = sorted(table.keys())
print("""
c8_set = """ + compact_set(table) + """
def in_table_c8(code):
return ord(code) in c8_set
""")
# C.9 Tagging characters
name, table = tables[0]
del tables[0]
assert name == "C.9"
table = sorted(table.keys())
print("""
c9_set = """ + compact_set(table) + """
def in_table_c9(code):
return ord(code) in c9_set
""")
# D.1 Characters with bidirectional property "R" or "AL"
name, table = tables[0]
del tables[0]
assert name == "D.1"
RandAL = set(gen_bidirectional(["R","AL"]))
assert set(table.keys()) == RandAL
print("""
def in_table_d1(code):
return unicodedata.bidirectional(code) in ("R","AL")
""")
# D.2 Characters with bidirectional property "L"
name, table = tables[0]
del tables[0]
assert name == "D.2"
L = set(gen_bidirectional(["L"]))
assert set(table.keys()) == L
print("""
def in_table_d2(code):
return unicodedata.bidirectional(code) == "L"
""")
| 10,262 | 432 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/makeunicodedata.py | #
# (re)generate unicode property and type databases
#
# this script converts a unicode 3.2 database file to
# Modules/unicodedata_db.h, Modules/unicodename_db.h,
# and Objects/unicodetype_db.h
#
# history:
# 2000-09-24 fl created (based on bits and pieces from unidb)
# 2000-09-25 fl merged tim's splitbin fixes, separate decomposition table
# 2000-09-25 fl added character type table
# 2000-09-26 fl added LINEBREAK, DECIMAL, and DIGIT flags/fields (2.0)
# 2000-11-03 fl expand first/last ranges
# 2001-01-19 fl added character name tables (2.1)
# 2001-01-21 fl added decomp compression; dynamic phrasebook threshold
# 2002-09-11 wd use string methods
# 2002-10-18 mvl update to Unicode 3.2
# 2002-10-22 mvl generate NFC tables
# 2002-11-24 mvl expand all ranges, sort names version-independently
# 2002-11-25 mvl add UNIDATA_VERSION
# 2004-05-29 perky add east asian width information
# 2006-03-10 mvl update to Unicode 4.1; add UCD 3.2 delta
# 2008-06-11 gb add PRINTABLE_MASK for Atsuo Ishimoto's ascii() patch
# 2011-10-21 ezio add support for name aliases and named sequences
# 2012-01 benjamin add full case mappings
#
# written by Fredrik Lundh ([email protected])
#
import os
import sys
import bz2
import zlib
import zipfile
from textwrap import dedent
SCRIPT = sys.argv[0]
VERSION = "3.2"
# The Unicode Database
# --------------------
# When changing UCD version please update
# * Doc/library/stdtypes.rst, and
# * Doc/library/unicodedata.rst
# * Doc/reference/lexical_analysis.rst (two occurrences)
UNIDATA_VERSION = "13.0.0"
UNICODE_DATA = "UnicodeData%s.txt"
COMPOSITION_EXCLUSIONS = "CompositionExclusions%s.txt"
EASTASIAN_WIDTH = "EastAsianWidth%s.txt"
UNIHAN = "Unihan%s.zip"
DERIVED_CORE_PROPERTIES = "DerivedCoreProperties%s.txt"
DERIVEDNORMALIZATION_PROPS = "DerivedNormalizationProps%s.txt"
LINE_BREAK = "LineBreak%s.txt"
NAME_ALIASES = "NameAliases%s.txt"
NAMED_SEQUENCES = "NamedSequences%s.txt"
SPECIAL_CASING = "SpecialCasing%s.txt"
CASE_FOLDING = "CaseFolding%s.txt"
# Private Use Areas -- in planes 1, 15, 16
PUA_1 = range(0xE000, 0xF900)
PUA_15 = range(0xF0000, 0xFFFFE)
PUA_16 = range(0x100000, 0x10FFFE)
# we use this ranges of PUA_15 to store name aliases and named sequences
NAME_ALIASES_START = 0xF0000
NAMED_SEQUENCES_START = 0xF0200
old_versions = ["3.2.0"]
CATEGORY_NAMES = [ "Cn", "Lu", "Ll", "Lt", "Mn", "Mc", "Me", "Nd",
"Nl", "No", "Zs", "Zl", "Zp", "Cc", "Cf", "Cs", "Co", "Cn", "Lm",
"Lo", "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po", "Sm", "Sc", "Sk",
"So" ]
BIDIRECTIONAL_NAMES = [ "", "L", "LRE", "LRO", "R", "AL", "RLE", "RLO",
"PDF", "EN", "ES", "ET", "AN", "CS", "NSM", "BN", "B", "S", "WS",
"ON", "LRI", "RLI", "FSI", "PDI" ]
EASTASIANWIDTH_NAMES = [ "F", "H", "W", "Na", "A", "N" ]
MANDATORY_LINE_BREAKS = [ "BK", "CR", "LF", "NL" ]
# note: should match definitions in Objects/unicodectype.c
ALPHA_MASK = 0x01
DECIMAL_MASK = 0x02
DIGIT_MASK = 0x04
LOWER_MASK = 0x08
LINEBREAK_MASK = 0x10
SPACE_MASK = 0x20
TITLE_MASK = 0x40
UPPER_MASK = 0x80
XID_START_MASK = 0x100
XID_CONTINUE_MASK = 0x200
PRINTABLE_MASK = 0x400
NUMERIC_MASK = 0x800
CASE_IGNORABLE_MASK = 0x1000
CASED_MASK = 0x2000
EXTENDED_CASE_MASK = 0x4000
# these ranges need to match unicodedata.c:is_unified_ideograph
cjk_ranges = [
('3400', '4DB5'),
('4E00', '9FD5'),
('20000', '2A6D6'),
('2A700', '2B734'),
('2B740', '2B81D'),
('2B820', '2CEA1'),
]
def bias(c):
# if c <= 0xffff:
# return True
# if 0x1f600 <= c <= 0x1f64f:
# return True
return True
def maketables(trace=0):
if not os.path.isdir("third_party/python"):
print("please cd to cosmopolitan root")
sys.exit(1)
print("--- Reading", UNICODE_DATA % "", "...")
version = ""
unicode = UnicodeData(UNIDATA_VERSION, select=bias)
print(len(list(filter(None, unicode.table))), "characters")
for version in old_versions:
print("--- Reading", UNICODE_DATA % ("-"+version), "...")
old_unicode = UnicodeData(version, cjk_check=False, select=bias)
print(len(list(filter(None, old_unicode.table))), "characters")
merge_old_version(version, unicode, old_unicode)
with open("third_party/python/Modules/unicodedata_unidata.h", "w") as hdr:
print("""\
#ifndef COSMOPOLITAN_THIRD_PARTY_PYTHON_MODULES_UNICODEDATA_UNIDATA_H_
#define COSMOPOLITAN_THIRD_PARTY_PYTHON_MODULES_UNICODEDATA_UNIDATA_H_
#include "third_party/python/Modules/unicodedata.h"
COSMOPOLITAN_C_START_
/* GENERATED BY %s %s */""" % (SCRIPT, VERSION), file=hdr)
print('#define UNIDATA_VERSION "%s"' % UNIDATA_VERSION, file=hdr)
makeunicodename(hdr, unicode, trace)
makeunicodedata(hdr, unicode, trace)
makeunicodetype(hdr, unicode, trace)
hdr.write("""\
COSMOPOLITAN_C_END_
#endif /* COSMOPOLITAN_THIRD_PARTY_PYTHON_MODULES_UNICODEDATA_UNIDATA_H_ */
""")
def startfile(fp):
print('#include "libc/nexgen32e/kompressor.h"', file=fp)
print('#include "third_party/python/Modules/unicodedata.h"', file=fp)
print("/* clang-format off */", file=fp)
print("/* GENERATED BY %s %s */" % (SCRIPT, VERSION), file=fp)
print(file=fp)
def makestringarray(name, strings, fp, hdr):
ml = max(len(s) for s in strings)
if ml < 8:
print('extern const char %s[%d][%d];' % (name, len(strings), ml+1), file=hdr)
print("const char %s[%d][%d] = {" % (name, len(strings), ml+1), file=fp)
else:
print('extern const char *const %s[%d];' % (name, len(strings)), file=hdr)
print("const char *const %s[%d] = {" % (name, len(strings)), file=fp)
for s in strings:
print(" \"%s\"," % (s), file=fp)
print("};", file=fp)
# --------------------------------------------------------------------
# unicode character properties
def makeunicodedata(hdr, unicode, trace):
dummy = (0, 0, 0, 0, 0, 0)
table = [dummy]
cache = {0: dummy}
index = [0] * len(unicode.chars)
# 1) database properties
for char in unicode.chars:
record = unicode.table[char]
if record:
# extract database properties
category = CATEGORY_NAMES.index(record[2])
combining = int(record[3])
bidirectional = BIDIRECTIONAL_NAMES.index(record[4])
mirrored = record[9] == "Y"
eastasianwidth = EASTASIANWIDTH_NAMES.index(record[15])
normalizationquickcheck = record[17]
item = (
category, combining, bidirectional, mirrored, eastasianwidth,
normalizationquickcheck
)
# add entry to index and item tables
i = cache.get(item)
if i is None:
cache[item] = i = len(table)
table.append(item)
index[char] = i
# 2) decomposition data
decomp_data = [0]
decomp_prefix = [""]
decomp_index = [0] * len(unicode.chars)
decomp_size = 0
comp_pairs = []
comp_first = [None] * len(unicode.chars)
comp_last = [None] * len(unicode.chars)
for char in unicode.chars:
record = unicode.table[char]
if record:
if record[5]:
decomp = record[5].split()
if len(decomp) > 19:
raise Exception("character %x has a decomposition too large for nfd_nfkd" % char)
# prefix
if decomp[0][0] == "<":
prefix = decomp.pop(0)
else:
prefix = ""
try:
i = decomp_prefix.index(prefix)
except ValueError:
i = len(decomp_prefix)
decomp_prefix.append(prefix)
prefix = i
assert prefix < 256
# content
decomp = [prefix + (len(decomp)<<8)] + [int(s, 16) for s in decomp]
# Collect NFC pairs
if not prefix and len(decomp) == 3 and \
char not in unicode.exclusions and \
unicode.table[decomp[1]][3] == "0":
p, l, r = decomp
comp_first[l] = 1
comp_last[r] = 1
comp_pairs.append((l,r,char))
try:
i = decomp_data.index(decomp)
except ValueError:
i = len(decomp_data)
decomp_data.extend(decomp)
decomp_size = decomp_size + len(decomp) * 2
else:
i = 0
decomp_index[char] = i
f = l = 0
comp_first_ranges = []
comp_last_ranges = []
prev_f = prev_l = None
for i in unicode.chars:
if comp_first[i] is not None:
comp_first[i] = f
f += 1
if prev_f is None:
prev_f = (i,i)
elif prev_f[1]+1 == i:
prev_f = prev_f[0],i
else:
comp_first_ranges.append(prev_f)
prev_f = (i,i)
if comp_last[i] is not None:
comp_last[i] = l
l += 1
if prev_l is None:
prev_l = (i,i)
elif prev_l[1]+1 == i:
prev_l = prev_l[0],i
else:
comp_last_ranges.append(prev_l)
prev_l = (i,i)
comp_first_ranges.append(prev_f)
comp_last_ranges.append(prev_l)
total_first = f
total_last = l
comp_data = [0]*(total_first*total_last)
for f,l,char in comp_pairs:
f = comp_first[f]
l = comp_last[l]
comp_data[f*total_last+l] = char
print(len(table), "unique properties")
print(len(decomp_prefix), "unique decomposition prefixes")
print(len(decomp_data), "unique decomposition entries:", end=' ')
print(decomp_size, "bytes")
print(total_first, "first characters in NFC")
print(total_last, "last characters in NFC")
print(len(comp_pairs), "NFC pairs")
# a list of unique records
with open("third_party/python/Modules/unicodedata_records.c", "w") as fp:
startfile(fp)
print("extern const _PyUnicode_Record _PyUnicode_Records[%d];" % (len(table)), file=hdr)
print("const _PyUnicode_Record _PyUnicode_Records[] = {", file=fp)
for item in table:
print(" {%3d, %3d, %3d, %3d, %3d, %3d}," % item, file=fp)
print("};", file=fp)
print(file=fp)
index1, index2, shift = splitbins(index, trace)
print("#define _PyUnicode_RecordsShift", shift, file=hdr)
Array("_PyUnicode_RecordsIndex1", index1, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_RecordsIndex2", index2, rle=True).dump(fp, hdr, trace)
print("#define UNIDATA_TOTAL_FIRST", total_first, file=hdr)
print("#define UNIDATA_TOTAL_LAST", total_last, file=hdr)
with open("third_party/python/Modules/unicodedata_nfcfirst.c", "w") as fp:
startfile(fp)
print("extern const _PyUnicode_Reindex _PyUnicode_NfcFirst[%d];" % (len(comp_first_ranges)), file=hdr)
print("const _PyUnicode_Reindex _PyUnicode_NfcFirst[] = {", file=fp)
for start,end in comp_first_ranges:
print(" {%#07x, %3d, %3d}," % (start,end-start,comp_first[start]), file=fp)
print(" {0}", file=fp)
print("};\n", file=fp)
with open("third_party/python/Modules/unicodedata_nfclast.c", "w") as fp:
startfile(fp)
print("extern const _PyUnicode_Reindex _PyUnicode_NfcLast[%d];" % (len(comp_last_ranges)), file=hdr)
print("const _PyUnicode_Reindex _PyUnicode_NfcLast[] = {", file=fp)
for start,end in comp_last_ranges:
print(" {%#07x, %3d, %3d}," % (start,end-start,comp_last[start]), file=fp)
print(" {0}", file=fp)
print("};\n", file=fp)
with open("third_party/python/Modules/unicodedata_categorynames.c", "w") as fp:
startfile(fp)
makestringarray("_PyUnicode_CategoryNames", CATEGORY_NAMES, fp, hdr)
with open("third_party/python/Modules/unicodedata_bidirectionalnames.c", "w") as fp:
startfile(fp)
makestringarray("_PyUnicode_BidirectionalNames", BIDIRECTIONAL_NAMES, fp, hdr)
with open("third_party/python/Modules/unicodedata_eastasianwidthnames.c", "w") as fp:
startfile(fp)
makestringarray("_PyUnicode_EastAsianWidthNames", EASTASIANWIDTH_NAMES, fp, hdr)
with open("third_party/python/Modules/unicodedata_decompprefix.c", "w") as fp:
startfile(fp)
makestringarray("_PyUnicode_DecompPrefix", decomp_prefix, fp, hdr)
with open("third_party/python/Modules/unicodedata_decomp.c", "w") as fp:
startfile(fp)
index1, index2, shift = splitbins(decomp_index, trace)
print("#define _PyUnicode_DecompShift", shift, file=hdr)
Array("_PyUnicode_Decomp", decomp_data, pack=True).dump(fp, hdr, trace)
Array("_PyUnicode_DecompIndex1", index1, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_DecompIndex2", index2).dump(fp, hdr, trace)
with open("third_party/python/Modules/unicodedata_comp.c", "w") as fp:
startfile(fp)
index, index2, shift = splitbins(comp_data, trace)
print("#define _PyUnicode_CompShift", shift, file=hdr)
Array("_PyUnicode_CompIndex", index, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_CompData", index2, pack=True).dump(fp, hdr, trace)
# Generate delta tables for old versions [because punycode is pinned to 3.2.0]
for version, table, normalization in unicode.changed:
with open("third_party/python/Modules/unicodedata_%s.c" % (version), "w") as fp:
startfile(fp)
cversion = version.replace(".","_")
records = [table[0]]
cache = {table[0]:0}
index = [0] * len(table)
for i, record in enumerate(table):
try:
index[i] = cache[record]
except KeyError:
index[i] = cache[record] = len(records)
records.append(record)
index1, index2, shift = splitbins(index, trace)
print("const _PyUnicode_ChangeRecord _PyUnicode_ChangeRecords_%s[] = {" % cversion, file=fp)
for record in records:
print("\t{ %s }," % ", ".join(map(str,record)), file=fp)
print("};", file=fp)
print(file=fp)
Array("_PyUnicode_ChangeIndex_%s" % cversion, index1, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_ChangeData_%s" % cversion, index2, rle=True).dump(fp, hdr, trace)
print("const _PyUnicode_ChangeRecord *_PyUnicode_GetChange_%s(Py_UCS4);" % cversion, file=hdr)
print("const _PyUnicode_ChangeRecord *_PyUnicode_GetChange_%s(Py_UCS4 n)" % cversion, file=fp)
print("{", file=fp)
print(" int i;", file=fp)
print(" if (n >= 0x110000) {", file=fp)
print(" i = 0;", file=fp)
print(" } else {", file=fp)
print(" i = _PyUnicode_ChangeIndex_%s[n>>%d];" % (cversion, shift), file=fp)
print(" i = _PyUnicode_ChangeData_%s[(i<<%d)+(n & %d)];" % (cversion, shift, ((1<<shift)-1)), file=fp)
print(" }", file=fp)
print(" return _PyUnicode_ChangeRecords_%s + i;" % cversion, file=fp)
print("}", file=fp)
print(file=fp)
print("Py_UCS4 _PyUnicode_Normalization_%s(Py_UCS4);" % (cversion), file=hdr)
print("Py_UCS4 _PyUnicode_Normalization_%s(Py_UCS4 n)" % (cversion), file=fp)
print("{", file=fp)
print(" switch(n) {", file=fp)
for k, v in normalization:
print(" case 0x%04x:" % (k), file=fp)
print(" return 0x%s;" % (v), file=fp)
print(" default:", file=fp)
print(" return 0;", file=fp)
print(" }", file=fp)
print("}", file=fp)
def GenerateToNumeric(db, fp):
dubble=[]
normal=[]
astral=[]
for k,v in db:
dubble.append(k)
i = len(dubble) - 1
for c in v:
if c < 0x10000:
normal.append((c, i))
else:
astral.append((c, i))
if len(dubble) < 255:
t = 'uint8_t'
else:
t = 'uint16_t'
print('static const double kNumeric[] = {', file=fp)
for d in dubble:
print(' %s.,' % (d), file=fp)
print('};', file=fp)
print(file=fp)
normal.sort()
print('static const uint32_t kNumericCodes[] = {', file=fp)
for c,i in normal:
print(' 0x%04x,' % (c), file=fp)
print('};', file=fp)
print(file=fp)
print('static const %s kNumericIndices[] = {' % (t), file=fp)
for c,i in normal:
print(' %d,' % (i), file=fp)
print('};', file=fp)
print(file=fp)
astral.sort()
print('static const uint32_t kNumericAstralCodes[] = {', file=fp)
for c,i in astral:
print(' 0x%05x,' % (c), file=fp)
print('};', file=fp)
print(file=fp)
print('static const %s kNumericAstralIndices[] = {' % (t), file=fp)
for c,i in astral:
print(' %d,' % (i), file=fp)
print('};', file=fp)
print("""
/* Returns the numeric value as double for Unicode characters
* having this property, -1.0 otherwise.
*/
double _PyUnicode_ToNumeric(Py_UCS4 c)
{
int l, m, r;
if (c <= 0xFFFF) {
l = 0;
r = sizeof(kNumericCodes) / sizeof(kNumericCodes[0]) - 1;
while (l <= r) {
m = (l + r) >> 1;
if (kNumericCodes[m] < c) {
l = m + 1;
} else if (kNumericCodes[m] > c) {
r = m - 1;
} else {
return kNumeric[kNumericIndices[m]];
}
}
} else {
l = 0;
r = sizeof(kNumericAstralCodes) / sizeof(kNumericAstralCodes[0]) - 1;
while (l <= r) {
m = (l + r) >> 1;
if (kNumericAstralCodes[m] < c) {
l = m + 1;
} else if (kNumericAstralCodes[m] > c) {
r = m - 1;
} else {
return kNumeric[kNumericAstralIndices[m]];
}
}
}
return -1;
}
""", file=fp)
# --------------------------------------------------------------------
# unicode character type tables
def makeunicodetype(hdr, unicode, trace):
# extract unicode types
dummy = (0, 0, 0, 0, 0, 0)
table = [dummy]
cache = {0: dummy}
index = [0] * len(unicode.chars)
numeric = {}
spaces = []
linebreaks = []
extra_casing = []
for char in unicode.chars:
record = unicode.table[char]
if record:
# extract database properties
category = record[2]
bidirectional = record[4]
properties = record[16]
flags = 0
delta = True
if category in ["Lm", "Lt", "Lu", "Ll", "Lo"]:
flags |= ALPHA_MASK
if "Lowercase" in properties:
flags |= LOWER_MASK
if 'Line_Break' in properties or bidirectional == "B":
flags |= LINEBREAK_MASK
linebreaks.append(char)
if category == "Zs" or bidirectional in ("WS", "B", "S"):
flags |= SPACE_MASK
spaces.append(char)
if category == "Lt":
flags |= TITLE_MASK
if "Uppercase" in properties:
flags |= UPPER_MASK
if char == ord(" ") or category[0] not in ("C", "Z"):
flags |= PRINTABLE_MASK
if "XID_Start" in properties:
flags |= XID_START_MASK
if "XID_Continue" in properties:
flags |= XID_CONTINUE_MASK
if "Cased" in properties:
flags |= CASED_MASK
if "Case_Ignorable" in properties:
flags |= CASE_IGNORABLE_MASK
sc = unicode.special_casing.get(char)
cf = unicode.case_folding.get(char, [char])
if record[12]:
upper = int(record[12], 16)
else:
upper = char
if record[13]:
lower = int(record[13], 16)
else:
lower = char
if record[14]:
title = int(record[14], 16)
else:
title = upper
if sc is None and cf != [lower]:
sc = ([lower], [title], [upper])
if sc is None:
if upper == lower == title:
upper = lower = title = 0
else:
upper = upper - char
lower = lower - char
title = title - char
assert (abs(upper) <= 2147483647 and
abs(lower) <= 2147483647 and
abs(title) <= 2147483647)
else:
# This happens either when some character maps to more than one
# character in uppercase, lowercase, or titlecase or the
# casefolded version of the character is different from the
# lowercase. The extra characters are stored in a different
# array.
flags |= EXTENDED_CASE_MASK
lower = len(extra_casing) | (len(sc[0]) << 24)
extra_casing.extend(sc[0])
if cf != sc[0]:
lower |= len(cf) << 20
extra_casing.extend(cf)
upper = len(extra_casing) | (len(sc[2]) << 24)
extra_casing.extend(sc[2])
# Title is probably equal to upper.
if sc[1] == sc[2]:
title = upper
else:
title = len(extra_casing) | (len(sc[1]) << 24)
extra_casing.extend(sc[1])
# decimal digit, integer digit
decimal = 0
if record[6]:
flags |= DECIMAL_MASK
decimal = int(record[6])
digit = 0
if record[7]:
flags |= DIGIT_MASK
digit = int(record[7])
if record[8]:
flags |= NUMERIC_MASK
numeric.setdefault(record[8], []).append(char)
item = (
upper, lower, title, decimal, digit, flags
)
# add entry to index and item tables
i = cache.get(item)
if i is None:
cache[item] = i = len(table)
table.append(item)
index[char] = i
print(len(table), "unique character type entries")
print(sum(map(len, numeric.values())), "numeric code points")
print(len(spaces), "whitespace code points")
print(len(linebreaks), "linebreak code points")
print(len(extra_casing), "extended case array")
with open("third_party/python/Modules/unicodedata_typerecords.c", "w") as fp:
startfile(fp)
print("extern const _PyUnicode_TypeRecord _PyUnicode_TypeRecords[%d];" % (len(table)), file=hdr)
print("const _PyUnicode_TypeRecord _PyUnicode_TypeRecords[%d] = {" % (len(table)), file=fp)
for item in table:
print(" {%3d, %3d, %3d, %3d, %3d, %3d}," % item, file=fp)
print("};", file=fp)
index1, index2, shift = splitbins(index, trace)
print("#define _PyUnicode_TypeRecordsShift", shift, file=hdr)
Array("_PyUnicode_TypeRecordsIndex1", index1, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_TypeRecordsIndex2", index2, rle=True).dump(fp, hdr, trace)
with open("third_party/python/Modules/unicodedata_extendedcase.c", "w") as fp:
startfile(fp)
type_ = "char16_t"
for c in extra_casing:
if c > 0xffff:
type_ = "Py_UCS4"
break
print("extern const %s _PyUnicode_ExtendedCase[%d];" % (type_, len(extra_casing)), file=hdr)
print("const %s _PyUnicode_ExtendedCase[%d] = {" % (type_, len(extra_casing)), file=fp)
for c in extra_casing:
print(" %d," % c, file=fp)
print("};", file=fp)
with open("third_party/python/Modules/unicodedata_tonumeric.c", "w") as fp:
startfile(fp)
GenerateToNumeric(sorted(numeric.items()), fp)
with open("third_party/python/Modules/unicodedata_iswhitespace.c", "w") as fp:
startfile(fp)
print("/* Returns 1 for Unicode characters having the bidirectional", file=fp)
print(" * type 'WS', 'B' or 'S' or the category 'Zs', 0 otherwise.", file=fp)
print(" */", file=fp)
print('int _PyUnicode_IsWhitespace(Py_UCS4 ch)', file=fp)
print('{', file=fp)
print(' switch (ch) {', file=fp)
for codepoint in sorted(spaces):
print(' case 0x%04X:' % (codepoint,), file=fp)
print(' return 1;', file=fp)
print(' }', file=fp)
print(' return 0;', file=fp)
print('}', file=fp)
with open("third_party/python/Modules/unicodedata_islinebreak.c", "w") as fp:
startfile(fp)
print("/* Returns 1 for Unicode characters having the line break", file=fp)
print(" * property 'BK', 'CR', 'LF' or 'NL' or having bidirectional", file=fp)
print(" * type 'B', 0 otherwise.", file=fp)
print(" */", file=fp)
print('int _PyUnicode_IsLinebreak(Py_UCS4 ch)', file=fp)
print('{', file=fp)
print(' switch (ch) {', file=fp)
for codepoint in sorted(linebreaks):
print(' case 0x%04X:' % (codepoint,), file=fp)
print(' return 1;', file=fp)
print(' }', file=fp)
print(' return 0;', file=fp)
print('}', file=fp)
# --------------------------------------------------------------------
# unicode name database
def makeunicodename(hdr, unicode, trace):
# collect names
names = [None] * len(unicode.chars)
for char in unicode.chars:
record = unicode.table[char]
if record:
name = record[1].strip()
if name and name[0] != "<":
names[char] = name + chr(0)
print(len(list(n for n in names if n is not None)), "distinct names")
# collect unique words from names (note that we differ between
# words inside a sentence, and words ending a sentence. the
# latter includes the trailing null byte.
words = {}
n = b = 0
for char in unicode.chars:
name = names[char]
if name:
w = name.split()
b = b + len(name)
n = n + len(w)
for w in w:
l = words.get(w)
if l:
l.append(None)
else:
words[w] = [len(words)]
print(n, "words in text;", b, "bytes")
wordlist = list(words.items())
# sort on falling frequency, then by name
def word_key(a):
aword, alist = a
return -len(alist), aword
wordlist.sort(key=word_key)
# figure out how many phrasebook escapes we need
escapes = 0
while escapes * 256 < len(wordlist):
escapes = escapes + 1
print(escapes, "escapes")
short = 256 - escapes
assert short > 0
# [jart] is this right?
short = min(short, len(wordlist))
print(short, "short indexes in lexicon")
# statistics
n = 0
for i in range(short):
n = n + len(wordlist[i][1])
print(n, "short indexes in phrasebook")
# pick the most commonly used words, and sort the rest on falling
# length (to maximize overlap)
wordlist, wordtail = wordlist[:short], wordlist[short:]
wordtail.sort(key=lambda a: a[0], reverse=True)
wordlist.extend(wordtail)
# generate lexicon from words
lexicon_offset = [0]
lexicon = ""
words = {}
# build a lexicon string
offset = 0
for w, x in wordlist:
# encoding: bit 7 indicates last character in word (chr(128)
# indicates the last character in an entire string)
ww = w[:-1] + chr(ord(w[-1])+128)
# reuse string tails, when possible
o = lexicon.find(ww)
if o < 0:
o = offset
lexicon = lexicon + ww
offset = offset + len(w)
words[w] = len(lexicon_offset)
lexicon_offset.append(o)
lexicon = list(map(ord, lexicon))
# generate phrasebook from names and lexicon
phrasebook = [0]
phrasebook_offset = [0] * len(unicode.chars)
for char in unicode.chars:
name = names[char]
if name:
w = name.split()
phrasebook_offset[char] = len(phrasebook)
for w in w:
i = words[w]
if i < short:
phrasebook.append(i)
else:
# store as two bytes
phrasebook.append((i>>8) + short)
phrasebook.append(i&255)
assert getsize(phrasebook) == 1
#
# unicode name hash table
# extract names
data = []
for char in unicode.chars:
record = unicode.table[char]
if record:
name = record[1].strip()
if name and name[0] != "<":
data.append((name, char))
# the magic number 47 was chosen to minimize the number of
# collisions on the current data set. if you like, change it
# and see what happens...
codehash = Hash("_PyUnicode_Code", data, 47)
print("#define UNIDATA_NAME_MAXLEN", 256, file=hdr)
with open("third_party/python/Modules/unicodedata_lexicon.c", "w") as fp:
startfile(fp)
Array("_PyUnicode_Lexicon", lexicon).dump(fp, hdr, trace)
Array("_PyUnicode_LexiconOffset", lexicon_offset, pack=True).dump(fp, hdr, trace)
# split decomposition index table
offset1, offset2, shift = splitbins(phrasebook_offset, trace)
print("#define _PyUnicode_PhrasebookShift", shift, file=hdr)
print("#define _PyUnicode_PhrasebookShort", short, file=hdr)
with open("third_party/python/Modules/unicodedata_phrasebook.c", "w") as fp:
startfile(fp)
Array("_PyUnicode_Phrasebook", phrasebook).dump(fp, hdr, trace)
Array("_PyUnicode_PhrasebookOffset1", offset1, rle=True).dump(fp, hdr, trace)
Array("_PyUnicode_PhrasebookOffset2", offset2, pack=True).dump(fp, hdr, trace)
with open("third_party/python/Modules/unicodedata_codehash.c", "w") as fp:
startfile(fp)
codehash.dump(fp, hdr, trace)
print('#define _PyUnicode_AliasesStart %#x' % (NAME_ALIASES_START), file=hdr)
print('#define _PyUnicode_AliasesEnd %#x' % (NAME_ALIASES_START + len(unicode.aliases)), file=hdr)
print('extern const unsigned int _PyUnicode_NameAliases[%d];' % (len(unicode.aliases)), file=hdr)
with open("third_party/python/Modules/unicodedata_aliases.c", "w") as fp:
startfile(fp)
print('const unsigned int _PyUnicode_NameAliases[%d] = {' % (len(unicode.aliases)), file=fp)
for name, codepoint in unicode.aliases:
print(' 0x%04X,' % codepoint, file=fp)
print('};', file=fp)
print('#define _PyUnicode_NamedSequencesStart %#x' % (NAMED_SEQUENCES_START), file=hdr)
print('#define _PyUnicode_NamedSequencesEnd %#x' %
(NAMED_SEQUENCES_START + len(unicode.named_sequences)), file=hdr)
print('extern const _PyUnicode_NamedSequence _PyUnicode_NamedSequences[%d];' % (len(unicode.named_sequences)), file=hdr)
with open("third_party/python/Modules/unicodedata_namedsequences.c", "w") as fp:
startfile(fp)
print('const _PyUnicode_NamedSequence _PyUnicode_NamedSequences[%d] = {' % (len(unicode.named_sequences)), file=fp)
for name, sequence in unicode.named_sequences:
seq_str = ', '.join('0x%04X' % cp for cp in sequence)
print(' {%d, {%s}},' % (len(sequence), seq_str), file=fp)
print('};', file=fp)
def merge_old_version(version, new, old):
# Changes to exclusion file not implemented yet
if old.exclusions != new.exclusions:
raise NotImplementedError("exclusions differ")
# In these change records, 0xFF means "no change"
bidir_changes = [0xFF]*0x110000
category_changes = [0xFF]*0x110000
decimal_changes = [0xFF]*0x110000
mirrored_changes = [0xFF]*0x110000
east_asian_width_changes = [0xFF]*0x110000
# In numeric data, 0 means "no change",
# -1 means "did not have a numeric value
numeric_changes = [0] * 0x110000
# normalization_changes is a list of key-value pairs
normalization_changes = []
for i in range(0x110000):
if new.table[i] is None:
# Characters unassigned in the new version ought to
# be unassigned in the old one
assert old.table[i] is None
continue
# check characters unassigned in the old version
if old.table[i] is None:
# category 0 is "unassigned"
category_changes[i] = 0
continue
# check characters that differ
if old.table[i] != new.table[i]:
for k in range(len(old.table[i])):
if old.table[i][k] != new.table[i][k]:
value = old.table[i][k]
if k == 1 and i in PUA_15:
# the name is not set in the old.table, but in the
# new.table we are using it for aliases and named seq
assert value == ''
elif k == 2:
#print "CATEGORY",hex(i), old.table[i][k], new.table[i][k]
category_changes[i] = CATEGORY_NAMES.index(value)
elif k == 4:
#print "BIDIR",hex(i), old.table[i][k], new.table[i][k]
bidir_changes[i] = BIDIRECTIONAL_NAMES.index(value)
elif k == 5:
#print "DECOMP",hex(i), old.table[i][k], new.table[i][k]
# We assume that all normalization changes are in 1:1 mappings
assert " " not in value
normalization_changes.append((i, value))
elif k == 6:
#print "DECIMAL",hex(i), old.table[i][k], new.table[i][k]
# we only support changes where the old value is a single digit
assert value in "0123456789"
decimal_changes[i] = int(value)
elif k == 8:
# print "NUMERIC",hex(i), `old.table[i][k]`, new.table[i][k]
# Since 0 encodes "no change", the old value is better not 0
if not value:
numeric_changes[i] = -1
else:
numeric_changes[i] = float(value)
assert numeric_changes[i] not in (0, -1)
elif k == 9:
if value == 'Y':
mirrored_changes[i] = '1'
else:
mirrored_changes[i] = '0'
elif k == 11:
# change to ISO comment, ignore
pass
elif k == 12:
# change to simple uppercase mapping; ignore
pass
elif k == 13:
# change to simple lowercase mapping; ignore
pass
elif k == 14:
# change to simple titlecase mapping; ignore
pass
elif k == 15:
# change to east asian width
east_asian_width_changes[i] = EASTASIANWIDTH_NAMES.index(value)
elif k == 16:
# derived property changes; not yet
pass
elif k == 17:
# normalization quickchecks are not performed
# for older versions
pass
else:
class Difference(Exception):pass
raise Difference(hex(i), k, old.table[i], new.table[i])
new.changed.append((version, list(zip(bidir_changes, category_changes,
decimal_changes, mirrored_changes,
east_asian_width_changes,
numeric_changes)),
normalization_changes))
def open_data(template, version):
if not os.path.isdir('o/unicode'):
os.makedirs('o/unicode')
name = template % ('-'+version,)
local = os.path.join('o/unicode', name)
if not os.path.exists(local):
import urllib.request
if version == '3.2.0':
# irregular url structure
url = 'http://www.unicode.org/Public/3.2-Update/' + name
else:
url = ('http://www.unicode.org/Public/%s/ucd/'+template) % (version, '')
print('Downloading %s' % (url))
urllib.request.urlretrieve(url, filename=local)
if local.endswith('.txt'):
return open(local, encoding='utf-8')
else:
# Unihan.zip
return open(local, 'rb')
# --------------------------------------------------------------------
# the following support code is taken from the unidb utilities
# Copyright (c) 1999-2000 by Secret Labs AB
# load a unicode-data file from disk
class UnicodeData:
# Record structure:
# [ID, name, category, combining, bidi, decomp, (6)
# decimal, digit, numeric, bidi-mirrored, Unicode-1-name, (11)
# ISO-comment, uppercase, lowercase, titlecase, ea-width, (16)
# derived-props] (17)
def __init__(self, version,
linebreakprops=False,
expand=1,
cjk_check=True,
select=lambda c: True):
self.changed = []
table = [None] * 0x110000
with open_data(UNICODE_DATA, version) as file:
while 1:
s = file.readline()
if not s:
break
s = s.strip().split(";")
char = int(s[0], 16)
if select(char):
table[char] = s
cjk_ranges_found = []
cjk_ranger = [(a,b) for a,b in cjk_ranges
if select(int(a,16)) and select(int(b,16))]
# expand first-last ranges
if expand:
field = None
for i in range(0, 0x110000):
if not select(i):
continue
s = table[i]
if s:
if s[1][-6:] == "First>":
s[1] = ""
field = s
elif s[1][-5:] == "Last>":
if s[1].startswith("<CJK Ideograph"):
cjk_ranges_found.append((field[0],
s[0]))
s[1] = ""
field = None
elif field:
f2 = field[:]
f2[0] = "%X" % i
table[i] = f2
# if cjk_check and cjk_ranger != cjk_ranges_found:
# raise ValueError("CJK ranges deviate: have %r want %r" %
# (cjk_ranges_found, cjk_ranger))
# public attributes
self.filename = UNICODE_DATA % ''
self.table = table
self.chars = list(range(0x110000)) # unicode 3.2
# check for name aliases and named sequences, see #12753
# aliases and named sequences are not in 3.2.0
if version != '3.2.0':
self.aliases = []
# store aliases in the Private Use Area 15, in range U+F0000..U+F00FF,
# in order to take advantage of the compression and lookup
# algorithms used for the other characters
pua_index = NAME_ALIASES_START
with open_data(NAME_ALIASES, version) as file:
for s in file:
s = s.strip()
if not s or s.startswith('#'):
continue
char, name, abbrev = s.split(';')
char = int(char, 16)
if select(pua_index) and select(char):
self.aliases.append((name, char))
# also store the name in the PUA 1
self.table[pua_index][1] = name
pua_index += 1
assert pua_index - NAME_ALIASES_START == len(self.aliases)
self.named_sequences = []
# store named sequences in the PUA 1, in range U+F0100..,
# in order to take advantage of the compression and lookup
# algorithms used for the other characters.
assert pua_index < NAMED_SEQUENCES_START
pua_index = NAMED_SEQUENCES_START
if select(pua_index):
with open_data(NAMED_SEQUENCES, version) as file:
for s in file:
s = s.strip()
if not s or s.startswith('#'):
continue
name, chars = s.split(';')
chars = tuple(int(char, 16) for char in chars.split())
chars = tuple(c for c in chars if select(c))
# check that the strutcure defined in makeunicodename is OK
assert 2 <= len(chars) <= 4, "change the Py_UCS2 array size"
assert all(c <= 0xFFFF for c in chars), ("use Py_UCS4 in "
"the NamedSequence struct and in unicodedata_lookup")
self.named_sequences.append((name, chars))
# also store these in the PUA 1
self.table[pua_index][1] = name
pua_index += 1
assert pua_index - NAMED_SEQUENCES_START == len(self.named_sequences)
self.exclusions = {}
with open_data(COMPOSITION_EXCLUSIONS, version) as file:
for s in file:
s = s.strip()
if not s:
continue
if s[0] == '#':
continue
char = int(s.split()[0],16)
if select(char):
self.exclusions[char] = 1
widths = [None] * 0x110000
with open_data(EASTASIAN_WIDTH, version) as file:
for s in file:
s = s.strip()
if not s:
continue
if s[0] == '#':
continue
s = s.split()[0].split(';')
if '..' in s[0]:
first, last = [int(c, 16) for c in s[0].split('..')]
chars = list(range(first, last+1))
else:
chars = [int(s[0], 16)]
for char in chars:
if select(char):
widths[char] = s[1]
for i in range(0, 0x110000):
if table[i] is not None:
table[i].append(widths[i])
for i in range(0, 0x110000):
if table[i] is not None:
table[i].append(set())
with open_data(DERIVED_CORE_PROPERTIES, version) as file:
for s in file:
s = s.split('#', 1)[0].strip()
if not s:
continue
r, p = s.split(";")
r = r.strip()
p = p.strip()
if ".." in r:
first, last = [int(c, 16) for c in r.split('..')]
chars = list(range(first, last+1))
else:
chars = [int(r, 16)]
for char in chars:
if table[char]:
# Some properties (e.g. Default_Ignorable_Code_Point)
# apply to unassigned code points; ignore them
table[char][-1].add(p)
with open_data(LINE_BREAK, version) as file:
for s in file:
s = s.partition('#')[0]
s = [i.strip() for i in s.split(';')]
if len(s) < 2 or s[1] not in MANDATORY_LINE_BREAKS:
continue
if '..' not in s[0]:
first = last = int(s[0], 16)
else:
first, last = [int(c, 16) for c in s[0].split('..')]
for char in range(first, last+1):
if select(char):
table[char][-1].add('Line_Break')
# We only want the quickcheck properties
# Format: NF?_QC; Y(es)/N(o)/M(aybe)
# Yes is the default, hence only N and M occur
# In 3.2.0, the format was different (NF?_NO)
# The parsing will incorrectly determine these as
# "yes", however, unicodedata.c will not perform quickchecks
# for older versions, and no delta records will be created.
quickchecks = [0] * 0x110000
qc_order = 'NFD_QC NFKD_QC NFC_QC NFKC_QC'.split()
with open_data(DERIVEDNORMALIZATION_PROPS, version) as file:
for s in file:
if '#' in s:
s = s[:s.index('#')]
s = [i.strip() for i in s.split(';')]
if len(s) < 2 or s[1] not in qc_order:
continue
quickcheck = 'MN'.index(s[2]) + 1 # Maybe or No
quickcheck_shift = qc_order.index(s[1])*2
quickcheck <<= quickcheck_shift
if '..' not in s[0]:
first = last = int(s[0], 16)
else:
first, last = [int(c, 16) for c in s[0].split('..')]
for char in range(first, last+1):
if select(char):
assert not (quickchecks[char]>>quickcheck_shift)&3
quickchecks[char] |= quickcheck
for i in range(0, 0x110000):
if table[i] is not None:
table[i].append(quickchecks[i])
with open_data(UNIHAN, version) as file:
zip = zipfile.ZipFile(file)
if version == '3.2.0':
data = zip.open('Unihan-3.2.0.txt').read()
else:
data = zip.open('Unihan_NumericValues.txt').read()
for line in data.decode("utf-8").splitlines():
if not line.startswith('U+'):
continue
code, tag, value = line.split(None, 3)[:3]
if tag not in ('kAccountingNumeric', 'kPrimaryNumeric',
'kOtherNumeric'):
continue
value = value.strip().replace(',', '')
i = int(code[2:], 16)
# Patch the numeric field
if table[i] is not None:
table[i][8] = value
sc = self.special_casing = {}
with open_data(SPECIAL_CASING, version) as file:
for s in file:
s = s[:-1].split('#', 1)[0]
if not s:
continue
data = s.split("; ")
if data[4]:
# We ignore all conditionals (since they depend on
# languages) except for one, which is hardcoded. See
# handle_capital_sigma in unicodeobject.c.
continue
c = int(data[0], 16)
if select(c):
lower = [int(char, 16) for char in data[1].split() if select(int(char, 16))]
title = [int(char, 16) for char in data[2].split() if select(int(char, 16))]
upper = [int(char, 16) for char in data[3].split() if select(int(char, 16))]
sc[c] = (lower, title, upper)
cf = self.case_folding = {}
if version != '3.2.0':
with open_data(CASE_FOLDING, version) as file:
for s in file:
s = s[:-1].split('#', 1)[0]
if not s:
continue
data = s.split("; ")
if data[1] in "CF":
c = int(data[0], 16)
if select(c):
cf[c] = [int(char, 16) for char in data[2].split()]
def uselatin1(self):
# restrict character range to ISO Latin 1
self.chars = list(range(256))
# hash table tools
# this is a straight-forward reimplementation of Python's built-in
# dictionary type, using a static data structure, and a custom string
# hash algorithm.
def myhash(s, magic):
h = 0
for c in map(ord, s.upper()):
h = (h * magic) + c
ix = h & 0xff000000
if ix:
h = (h ^ ((ix>>24) & 0xff)) & 0x00ffffff
return h
SIZES = [
(4,3), (8,3), (16,3), (32,5), (64,3), (128,3), (256,29), (512,17),
(1024,9), (2048,5), (4096,83), (8192,27), (16384,43), (32768,3),
(65536,45), (131072,9), (262144,39), (524288,39), (1048576,9),
(2097152,5), (4194304,3), (8388608,33), (16777216,27)
]
class Hash:
def __init__(self, name, data, magic):
# turn a (key, value) list into a static hash table structure
# determine table size
for size, poly in SIZES:
if size > len(data):
poly = size + poly
break
else:
raise AssertionError("ran out of polynomials")
print(size, "slots in hash table")
table = [None] * size
mask = size-1
n = 0
hash = myhash
# initialize hash table
for key, value in data:
h = hash(key, magic)
i = (~h) & mask
v = table[i]
if v is None:
table[i] = value
continue
incr = (h ^ (h >> 3)) & mask;
if not incr:
incr = mask
while 1:
n = n + 1
i = (i + incr) & mask
v = table[i]
if v is None:
table[i] = value
break
incr = incr << 1
if incr > mask:
incr = incr ^ poly
print(n, "collisions")
self.collisions = n
for i in range(len(table)):
if table[i] is None:
table[i] = 0
self.data = Array(name + "Hash", table, pack=True)
self.magic = magic
self.name = name
self.size = size
self.poly = poly
def dump(self, file, hdr, trace):
# write data to file, as a C array
self.data.dump(file, hdr, trace)
hdr.write("#define %sMagic %d\n" % (self.name, self.magic))
hdr.write("#define %sSize %d\n" % (self.name, self.size))
hdr.write("#define %sPoly %d\n" % (self.name, self.poly))
# stuff to deal with arrays of unsigned integers
def pack(data, bits, word=32):
assert 0 < bits < word
bitn = (bits * len(data) + word - 1) // word
bita = 0
for x in reversed(data):
bita <<= bits
bita |= x
for i in range(bitn):
yield bita & ((1 << word) - 1)
bita >>= 32
def spack(data, bits, word=32):
assert 0 < bits < word
bitn = (bits * len(data) + word - 1) // word
bita = 0
sign = 1 << (bits - 1)
mask = sign - 1
for x in reversed(data):
assert -sign <= x < sign, "x=%d bits=%d" % (x, bits)
x = (x & mask) | (sign if x < 0 else 0)
bita <<= bits
bita |= x
for i in range(bitn):
yield bita & ((1 << word) - 1)
bita >>= 32
def bzip(data):
return bz2.compress(data)
def deflate(data):
# z = zlib.compressobj(zlib.Z_BEST_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS, zlib.DEF_MEM_LEVEL, zlib.Z_RLE)
z = zlib.compressobj(zlib.Z_BEST_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
b = z.compress(data)
b += z.flush(zlib.Z_FINISH)
return b
def rle(data, maxval):
i = 0
j = 0
for i,x in enumerate(data):
if j == 0:
y = x
j = 1
elif y == x and j < maxval:
j += 1
else:
yield (j, y)
y = x
j = 1
if j:
yield (j, y)
def uleb(a, x):
while True:
b = x & 127
x >>= 7
if x:
a.append(b | 128)
else:
a.append(b)
break
def zig(x):
m = (2 << x.bit_length()) - 1
return ((x & (m >> 1)) << 1) ^ (m if x < 0 else 0)
def zleb(a, x):
return uleb(a, zig(x))
def sleb(a, x):
t = 0
while not t:
b = x & 127
x >>= 7
if (x == 0 and not (b & 64)) or (x == -1 and (b & 64)):
t = 1
else:
b |= 128
a.append(b)
def δleb(data):
i = 0
p = 0
a = bytearray()
for x in data:
sleb(a, x - p)
p = x
return a
def δzd(data):
n = 0;
i = 0
p = 0
a = bytearray()
for x in data:
zleb(a, x - p)
p = x
return deflate(a), len(a)
def com(x):
return '{:,}'.format(x)
class Array:
def __init__(self, name, data, rle=False, pack=False, δzd=False):
self.name = name
self.data = data
self.pack = pack
self.rle = rle # adds 90µs latency to startup
self.δzd = δzd
def to_bytes(self, size, order):
return b''.join(i.to_bytes(size, order) for i in self.data)
def dump(self, file, hdr, trace=0):
# write data to f, as a C array
f = file
bits = max(x.bit_length() for x in self.data)
size = getsize(self.data)
if trace:
print("%s: %d bits" % (self.name, bits))
print("%s: size is %12s bytes" % (self.name, com(size*len(self.data))))
print("%s: packed size is %12s bytes" % (self.name, com((bits*len(self.data)+31)//32*4)))
print("%s: rle size is %12s bytes" % (self.name, com(len(tuple(rle(self.data, (1<<(8*size))-1)))*size*2)))
print("%s: deflate size is %12s bytes" % (self.name, com(len(deflate(self.to_bytes(size, 'little'))))))
print("%s: bz2 size is %12s bytes" % (self.name, com(len(bzip(self.to_bytes(size, 'little'))))))
print("%s: δleb size is %12s bytes" % (self.name, com(len(δleb(self.data)))))
print("%s: δzd size is %12s bytes" % (self.name, com(len(δzd(self.data)[0]))))
if self.pack:
hdr.write("#define %sBits %d\n" % (self.name, bits))
self.data = tuple(pack(self.data, bits))
size = 4
if self.δzd:
m = size
self.data, n = δzd(self.data)
size = 1
if size == 1:
t = "unsigned char"
elif size == 2:
t = "unsigned short"
else:
t = "unsigned int"
hdr.write("extern const %s %s[%d];\n" % (t, self.name, len(self.data)))
if self.rle:
codes = tuple(rle(self.data, (1<<(8*size))-1))
f.write("%s %s[%d];\n" % (t, self.name, len(self.data)))
f.write("static const %s %s_rodata[%d+1][2] = { /* %g%% profit */\n" % (t, self.name, len(codes), len(codes) * size * 2 / float(len(self.data) * size) * 100))
for a,b in codes:
f.write(" {%3d, 0x%02x},\n" % (a, b))
f.write(" {0},\n")
f.write("};\n")
f.write("static textstartup void %s_init(void) {\n" % (self.name));
if size == 1:
f.write(" rldecode2(%s, (void *)%s_rodata);\n" % (self.name, self.name));
else:
f.write(" int i, j, k;\n");
f.write(" for (k = i = 0; i < %d; ++i) {\n" % (len(codes)));
f.write(" for (j = 0; j < %s_rodata[i][0]; ++j) {\n" % (self.name));
f.write(" %s[k++] = %s_rodata[i][1];\n" % (self.name, self.name));
f.write(" }\n");
f.write(" }\n");
f.write("}\n");
f.write("const void *const %s_ctor[] initarray = {\n" % (self.name));
f.write(" %s_init,\n" % (self.name));
f.write("};\n");
f.write("\n");
else:
f.write("const %s %s[%d] = {\n" % (t, self.name, len(self.data)))
if self.data:
s = " "
for item in self.data:
i = str(item) + ", "
if len(s) + len(i) > 78:
f.write(s + "\n")
s = " " + i
else:
s = s + i
if s.strip():
f.write(s + "\n")
f.write("};\n\n")
if self.δzd:
f.write("/* %d %d */\n" % (n, m))
def getsize(data):
# return smallest possible integer size for the given array
maxdata = max(data)
if maxdata < 256:
return 1
elif maxdata < 65536:
return 2
else:
return 4
def splitbins(t, trace=0):
"""t, trace=0 -> (t1, t2, shift). Split a table to save space.
t is a sequence of ints. This function can be useful to save space if
many of the ints are the same. t1 and t2 are lists of ints, and shift
is an int, chosen to minimize the combined size of t1 and t2 (in C
code), and where for each i in range(len(t)),
t[i] == t2[(t1[i >> shift] << shift) + (i & mask)]
where mask is a bitmask isolating the last "shift" bits.
If optional arg trace is non-zero (default zero), progress info
is printed to sys.stderr. The higher the value, the more info
you'll get.
"""
if trace:
def dump(t1, t2, shift, bytes):
print("%d+%d bins at shift %d; %d bytes" % (
len(t1), len(t2), shift, bytes))
print("Size of original table:", len(t)*getsize(t), \
"bytes")
n = len(t)-1 # last valid index
maxshift = 0 # the most we can shift n and still have something left
if n > 0:
while n >> 1:
n >>= 1
maxshift += 1
del n
bytes = sys.maxsize # smallest total size so far
t = tuple(t) # so slices can be dict keys
for shift in range(maxshift + 1):
t1 = []
t2 = []
size = 2**shift
bincache = {}
for i in range(0, len(t), size):
bin = t[i:i+size]
index = bincache.get(bin)
if index is None:
index = len(t2)
bincache[bin] = index
t2.extend(bin)
t1.append(index >> shift)
# determine memory size
b = len(t1)*getsize(t1) + len(t2)*getsize(t2)
if trace > 1:
dump(t1, t2, shift, b)
if b < bytes:
best = t1, t2, shift
bytes = b
t1, t2, shift = best
if trace:
print("Best:", end=' ')
dump(t1, t2, shift, bytes)
if __debug__:
# exhaustively verify that the decomposition is correct
mask = ~((~0) << shift) # i.e., low-bit mask of shift bits
for i in range(len(t)):
assert t[i] == t2[(t1[i >> shift] << shift) + (i & mask)]
return best
if __name__ == "__main__":
maketables(1)
| 59,577 | 1,568 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/python-mappings/CP273.TXT | 0x00 0x0000 #NULL (NUL)
0x01 0x0001 #START OF HEADING (SOH)
0x02 0x0002 #START OF TEXT (STX)
0x03 0x0003 #END OF TEXT (ETX)
0x04 0x009C #STRING TERMINATOR (ST)
0x05 0x0009 #CHARACTER TABULATION (HT)
0x06 0x0086 #START OF SELECTED AREA (SSA)
0x07 0x007F #DELETE (DEL)
0x08 0x0097 #END OF GUARDED AREA (EPA)
0x09 0x008D #REVERSE LINE FEED (RI)
0x0A 0x008E #SINGLE-SHIFT TWO (SS2)
0x0B 0x000B #LINE TABULATION (VT)
0x0C 0x000C #FORM FEED (FF)
0x0D 0x000D #CARRIAGE RETURN (CR)
0x0E 0x000E #SHIFT OUT (SO)
0x0F 0x000F #SHIFT IN (SI)
0x10 0x0010 #DATALINK ESCAPE (DLE)
0x11 0x0011 #DEVICE CONTROL ONE (DC1)
0x12 0x0012 #DEVICE CONTROL TWO (DC2)
0x13 0x0013 #DEVICE CONTROL THREE (DC3)
0x14 0x009D #OPERATING SYSTEM COMMAND (OSC)
0x15 0x0085 #NEXT LINE (NEL)
0x16 0x0008 #BACKSPACE (BS)
0x17 0x0087 #END OF SELECTED AREA (ESA)
0x18 0x0018 #CANCEL (CAN)
0x19 0x0019 #END OF MEDIUM (EM)
0x1A 0x0092 #PRIVATE USE TWO (PU2)
0x1B 0x008F #SINGLE-SHIFT THREE (SS3)
0x1C 0x001C #FILE SEPARATOR (IS4)
0x1D 0x001D #GROUP SEPARATOR (IS3)
0x1E 0x001E #RECORD SEPARATOR (IS2)
0x1F 0x001F #UNIT SEPARATOR (IS1)
0x20 0x0080 #PADDING CHARACTER (PAD)
0x21 0x0081 #HIGH OCTET PRESET (HOP)
0x22 0x0082 #BREAK PERMITTED HERE (BPH)
0x23 0x0083 #NO BREAK HERE (NBH)
0x24 0x0084 #INDEX (IND)
0x25 0x000A #LINE FEED (LF)
0x26 0x0017 #END OF TRANSMISSION BLOCK (ETB)
0x27 0x001B #ESCAPE (ESC)
0x28 0x0088 #CHARACTER TABULATION SET (HTS)
0x29 0x0089 #CHARACTER TABULATION WITH JUSTIFICATION (HTJ)
0x2A 0x008A #LINE TABULATION SET (VTS)
0x2B 0x008B #PARTIAL LINE FORWARD (PLD)
0x2C 0x008C #PARTIAL LINE BACKWARD (PLU)
0x2D 0x0005 #ENQUIRY (ENQ)
0x2E 0x0006 #ACKNOWLEDGE (ACK)
0x2F 0x0007 #BELL (BEL)
0x30 0x0090 #DEVICE CONTROL STRING (DCS)
0x31 0x0091 #PRIVATE USE ONE (PU1)
0x32 0x0016 #SYNCHRONOUS IDLE (SYN)
0x33 0x0093 #SET TRANSMIT STATE (STS)
0x34 0x0094 #CANCEL CHARACTER (CCH)
0x35 0x0095 #MESSAGE WAITING (MW)
0x36 0x0096 #START OF GUARDED AREA (SPA)
0x37 0x0004 #END OF TRANSMISSION (EOT)
0x38 0x0098 #START OF STRING (SOS)
0x39 0x0099 #SINGLE GRAPHIC CHARACTER INTRODUCER (SGCI)
0x3A 0x009A #SINGLE CHARACTER INTRODUCER (SCI)
0x3B 0x009B #CONTROL SEQUENCE INTRODUCER (CSI)
0x3C 0x0014 #DEVICE CONTROL FOUR (DC4)
0x3D 0x0015 #NEGATIVE ACKNOWLEDGE (NAK)
0x3E 0x009E #PRIVACY MESSAGE (PM)
0x3F 0x001A #SUBSTITUTE (SUB)
0x40 0x0020 #SPACE
0x41 0x00A0 #NO-BREAK SPACE
0x42 0x00E2 #LATIN SMALL LETTER A WITH CIRCUMFLEX
0x43 0x007B #LEFT CURLY BRACKET
0x44 0x00E0 #LATIN SMALL LETTER A WITH GRAVE
0x45 0x00E1 #LATIN SMALL LETTER A WITH ACUTE
0x46 0x00E3 #LATIN SMALL LETTER A WITH TILDE
0x47 0x00E5 #LATIN SMALL LETTER A WITH RING ABOVE
0x48 0x00E7 #LATIN SMALL LETTER C WITH CEDILLA
0x49 0x00F1 #LATIN SMALL LETTER N WITH TILDE
0x4A 0x00C4 #LATIN CAPITAL LETTER A WITH DIAERESIS
0x4B 0x002E #FULL STOP
0x4C 0x003C #LESS-THAN SIGN
0x4D 0x0028 #LEFT PARENTHESIS
0x4E 0x002B #PLUS SIGN
0x4F 0x0021 #EXCLAMATION MARK
0x50 0x0026 #AMPERSAND
0x51 0x00E9 #LATIN SMALL LETTER E WITH ACUTE
0x52 0x00EA #LATIN SMALL LETTER E WITH CIRCUMFLEX
0x53 0x00EB #LATIN SMALL LETTER E WITH DIAERESIS
0x54 0x00E8 #LATIN SMALL LETTER E WITH GRAVE
0x55 0x00ED #LATIN SMALL LETTER I WITH ACUTE
0x56 0x00EE #LATIN SMALL LETTER I WITH CIRCUMFLEX
0x57 0x00EF #LATIN SMALL LETTER I WITH DIAERESIS
0x58 0x00EC #LATIN SMALL LETTER I WITH GRAVE
0x59 0x007E #TILDE
0x5A 0x00DC #LATIN CAPITAL LETTER U WITH DIAERESIS
0x5B 0x0024 #DOLLAR SIGN
0x5C 0x002A #ASTERISK
0x5D 0x0029 #RIGHT PARENTHESIS
0x5E 0x003B #SEMICOLON
0x5F 0x005E #CIRCUMFLEX ACCENT
0x60 0x002D #HYPHEN-MINUS
0x61 0x002F #SOLIDUS
0x62 0x00C2 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
0x63 0x005B #LEFT SQUARE BRACKET
0x64 0x00C0 #LATIN CAPITAL LETTER A WITH GRAVE
0x65 0x00C1 #LATIN CAPITAL LETTER A WITH ACUTE
0x66 0x00C3 #LATIN CAPITAL LETTER A WITH TILDE
0x67 0x00C5 #LATIN CAPITAL LETTER A WITH RING ABOVE
0x68 0x00C7 #LATIN CAPITAL LETTER C WITH CEDILLA
0x69 0x00D1 #LATIN CAPITAL LETTER N WITH TILDE
0x6A 0x00F6 #LATIN SMALL LETTER O WITH DIAERESIS
0x6B 0x002C #COMMA
0x6C 0x0025 #PERCENT SIGN
0x6D 0x005F #LOW LINE
0x6E 0x003E #GREATER-THAN SIGN
0x6F 0x003F #QUESTION MARK
0x70 0x00F8 #LATIN SMALL LETTER O WITH STROKE
0x71 0x00C9 #LATIN CAPITAL LETTER E WITH ACUTE
0x72 0x00CA #LATIN CAPITAL LETTER E WITH CIRCUMFLEX
0x73 0x00CB #LATIN CAPITAL LETTER E WITH DIAERESIS
0x74 0x00C8 #LATIN CAPITAL LETTER E WITH GRAVE
0x75 0x00CD #LATIN CAPITAL LETTER I WITH ACUTE
0x76 0x00CE #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
0x77 0x00CF #LATIN CAPITAL LETTER I WITH DIAERESIS
0x78 0x00CC #LATIN CAPITAL LETTER I WITH GRAVE
0x79 0x0060 #GRAVE ACCENT
0x7A 0x003A #COLON
0x7B 0x0023 #NUMBER SIGN
0x7C 0x00A7 #SECTION SIGN
0x7D 0x0027 #APOSTROPHE
0x7E 0x003D #EQUALS SIGN
0x7F 0x0022 #QUOTATION MARK
0x80 0x00D8 #LATIN CAPITAL LETTER O WITH STROKE
0x81 0x0061 #LATIN SMALL LETTER A
0x82 0x0062 #LATIN SMALL LETTER B
0x83 0x0063 #LATIN SMALL LETTER C
0x84 0x0064 #LATIN SMALL LETTER D
0x85 0x0065 #LATIN SMALL LETTER E
0x86 0x0066 #LATIN SMALL LETTER F
0x87 0x0067 #LATIN SMALL LETTER G
0x88 0x0068 #LATIN SMALL LETTER H
0x89 0x0069 #LATIN SMALL LETTER I
0x8A 0x00AB #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
0x8B 0x00BB #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
0x8C 0x00F0 #LATIN SMALL LETTER ETH (Icelandic)
0x8D 0x00FD #LATIN SMALL LETTER Y WITH ACUTE
0x8E 0x00FE #LATIN SMALL LETTER THORN (Icelandic)
0x8F 0x00B1 #PLUS-MINUS SIGN
0x90 0x00B0 #DEGREE SIGN
0x91 0x006A #LATIN SMALL LETTER J
0x92 0x006B #LATIN SMALL LETTER K
0x93 0x006C #LATIN SMALL LETTER L
0x94 0x006D #LATIN SMALL LETTER M
0x95 0x006E #LATIN SMALL LETTER N
0x96 0x006F #LATIN SMALL LETTER O
0x97 0x0070 #LATIN SMALL LETTER P
0x98 0x0071 #LATIN SMALL LETTER Q
0x99 0x0072 #LATIN SMALL LETTER R
0x9A 0x00AA #FEMININE ORDINAL INDICATOR
0x9B 0x00BA #MASCULINE ORDINAL INDICATOR
0x9C 0x00E6 #LATIN SMALL LETTER AE
0x9D 0x00B8 #CEDILLA
0x9E 0x00C6 #LATIN CAPITAL LETTER AE
0x9F 0x00A4 #CURRENCY SIGN
0xA0 0x00B5 #MICRO SIGN
0xA1 0x00DF #LATIN SMALL LETTER SHARP S (German)
0xA2 0x0073 #LATIN SMALL LETTER S
0xA3 0x0074 #LATIN SMALL LETTER T
0xA4 0x0075 #LATIN SMALL LETTER U
0xA5 0x0076 #LATIN SMALL LETTER V
0xA6 0x0077 #LATIN SMALL LETTER W
0xA7 0x0078 #LATIN SMALL LETTER X
0xA8 0x0079 #LATIN SMALL LETTER Y
0xA9 0x007A #LATIN SMALL LETTER Z
0xAA 0x00A1 #INVERTED EXCLAMATION MARK
0xAB 0x00BF #INVERTED QUESTION MARK
0xAC 0x00D0 #LATIN CAPITAL LETTER ETH (Icelandic)
0xAD 0x00DD #LATIN CAPITAL LETTER Y WITH ACUTE
0xAE 0x00DE #LATIN CAPITAL LETTER THORN (Icelandic)
0xAF 0x00AE #REGISTERED SIGN
0xB0 0x00A2 #CENT SIGN
0xB1 0x00A3 #POUND SIGN
0xB2 0x00A5 #YEN SIGN
0xB3 0x00B7 #MIDDLE DOT
0xB4 0x00A9 #COPYRIGHT SIGN
0xB5 0x0040 #COMMERCIAL AT
0xB6 0x00B6 #PILCROW SIGN
0xB7 0x00BC #VULGAR FRACTION ONE QUARTER
0xB8 0x00BD #VULGAR FRACTION ONE HALF
0xB9 0x00BE #VULGAR FRACTION THREE QUARTERS
0xBA 0x00AC #NOT SIGN
0xBB 0x007C #VERTICAL LINE
0xBC 0x203E #OVERLINE
0xBD 0x00A8 #DIAERESIS
0xBE 0x00B4 #ACUTE ACCENT
0xBF 0x00D7 #MULTIPLICATION SIGN
0xC0 0x00E4 #LATIN SMALL LETTER A WITH DIAERESIS
0xC1 0x0041 #LATIN CAPITAL LETTER A
0xC2 0x0042 #LATIN CAPITAL LETTER B
0xC3 0x0043 #LATIN CAPITAL LETTER C
0xC4 0x0044 #LATIN CAPITAL LETTER D
0xC5 0x0045 #LATIN CAPITAL LETTER E
0xC6 0x0046 #LATIN CAPITAL LETTER F
0xC7 0x0047 #LATIN CAPITAL LETTER G
0xC8 0x0048 #LATIN CAPITAL LETTER H
0xC9 0x0049 #LATIN CAPITAL LETTER I
0xCA 0x00AD #SOFT HYPHEN
0xCB 0x00F4 #LATIN SMALL LETTER O WITH CIRCUMFLEX
0xCC 0x00A6 #BROKEN BAR
0xCD 0x00F2 #LATIN SMALL LETTER O WITH GRAVE
0xCE 0x00F3 #LATIN SMALL LETTER O WITH ACUTE
0xCF 0x00F5 #LATIN SMALL LETTER O WITH TILDE
0xD0 0x00FC #LATIN SMALL LETTER U WITH DIAERESIS
0xD1 0x004A #LATIN CAPITAL LETTER J
0xD2 0x004B #LATIN CAPITAL LETTER K
0xD3 0x004C #LATIN CAPITAL LETTER L
0xD4 0x004D #LATIN CAPITAL LETTER M
0xD5 0x004E #LATIN CAPITAL LETTER N
0xD6 0x004F #LATIN CAPITAL LETTER O
0xD7 0x0050 #LATIN CAPITAL LETTER P
0xD8 0x0051 #LATIN CAPITAL LETTER Q
0xD9 0x0052 #LATIN CAPITAL LETTER R
0xDA 0x00B9 #SUPERSCRIPT ONE
0xDB 0x00FB #LATIN SMALL LETTER U WITH CIRCUMFLEX
0xDC 0x007D #RIGHT CURLY BRACKET
0xDD 0x00F9 #LATIN SMALL LETTER U WITH GRAVE
0xDE 0x00FA #LATIN SMALL LETTER U WITH ACUTE
0xDF 0x00FF #LATIN SMALL LETTER Y WITH DIAERESIS
0xE0 0x00D6 #LATIN CAPITAL LETTER O WITH DIAERESIS
0xE1 0x00F7 #DIVISION SIGN
0xE2 0x0053 #LATIN CAPITAL LETTER S
0xE3 0x0054 #LATIN CAPITAL LETTER T
0xE4 0x0055 #LATIN CAPITAL LETTER U
0xE5 0x0056 #LATIN CAPITAL LETTER V
0xE6 0x0057 #LATIN CAPITAL LETTER W
0xE7 0x0058 #LATIN CAPITAL LETTER X
0xE8 0x0059 #LATIN CAPITAL LETTER Y
0xE9 0x005A #LATIN CAPITAL LETTER Z
0xEA 0x00B2 #SUPERSCRIPT TWO
0xEB 0x00D4 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
0xEC 0x005C #REVERSE SOLIDUS
0xED 0x00D2 #LATIN CAPITAL LETTER O WITH GRAVE
0xEE 0x00D3 #LATIN CAPITAL LETTER O WITH ACUTE
0xEF 0x00D5 #LATIN CAPITAL LETTER O WITH TILDE
0xF0 0x0030 #DIGIT ZERO
0xF1 0x0031 #DIGIT ONE
0xF2 0x0032 #DIGIT TWO
0xF3 0x0033 #DIGIT THREE
0xF4 0x0034 #DIGIT FOUR
0xF5 0x0035 #DIGIT FIVE
0xF6 0x0036 #DIGIT SIX
0xF7 0x0037 #DIGIT SEVEN
0xF8 0x0038 #DIGIT EIGHT
0xF9 0x0039 #DIGIT NINE
0xFA 0x00B3 #SUPERSCRIPT THREE
0xFB 0x00DB #LATIN CAPITAL LETTER U WITH CIRCUMFLEX
0xFC 0x005D #RIGHT SQUARE BRACKET
0xFD 0x00D9 #LATIN CAPITAL LETTER U WITH GRAVE
0xFE 0x00DA #LATIN CAPITAL LETTER U WITH ACUTE
0xFF 0x009F #APPLICATION PROGRAM COMMAND (APC)
| 9,268 | 259 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/python-mappings/TIS-620.TXT | #
# Name: TIS-620
# Unicode version: 3.2
# Table version: 1.0
# Table format: Format A
# Date: 2005-10-25
# Authors: Marc-Andre Lemburg <[email protected]>
#
# According to
# ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-11.TXT the
# TIS-620 is the identical to ISO_8859-11 with the 0xA0
# (no-break space) mapping removed.
#
# (c) Copyright Marc-Andre Lemburg, 2005.
# Licensed to PSF under a Contributor Agreement.
#
# Based on the file
# ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-11.TXT
# which is:
#
# Copyright (c) 2002 Unicode, Inc. All Rights reserved.
#
# This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
# No claims are made as to fitness for any particular purpose. No
# warranties of any kind are expressed or implied. The recipient
# agrees to determine applicability of information provided. If this
# file has been provided on optical media by Unicode, Inc., the sole
# remedy for any claim will be exchange of defective media within 90
# days of receipt.
#
# Unicode, Inc. hereby grants the right to freely use the information
# supplied in this file in the creation of products supporting the
# Unicode Standard, and to make copies of this file in any form for
# internal or external distribution as long as this notice remains
# attached.
#
0x00 0x0000 # NULL
0x01 0x0001 # START OF HEADING
0x02 0x0002 # START OF TEXT
0x03 0x0003 # END OF TEXT
0x04 0x0004 # END OF TRANSMISSION
0x05 0x0005 # ENQUIRY
0x06 0x0006 # ACKNOWLEDGE
0x07 0x0007 # BELL
0x08 0x0008 # BACKSPACE
0x09 0x0009 # HORIZONTAL TABULATION
0x0A 0x000A # LINE FEED
0x0B 0x000B # VERTICAL TABULATION
0x0C 0x000C # FORM FEED
0x0D 0x000D # CARRIAGE RETURN
0x0E 0x000E # SHIFT OUT
0x0F 0x000F # SHIFT IN
0x10 0x0010 # DATA LINK ESCAPE
0x11 0x0011 # DEVICE CONTROL ONE
0x12 0x0012 # DEVICE CONTROL TWO
0x13 0x0013 # DEVICE CONTROL THREE
0x14 0x0014 # DEVICE CONTROL FOUR
0x15 0x0015 # NEGATIVE ACKNOWLEDGE
0x16 0x0016 # SYNCHRONOUS IDLE
0x17 0x0017 # END OF TRANSMISSION BLOCK
0x18 0x0018 # CANCEL
0x19 0x0019 # END OF MEDIUM
0x1A 0x001A # SUBSTITUTE
0x1B 0x001B # ESCAPE
0x1C 0x001C # FILE SEPARATOR
0x1D 0x001D # GROUP SEPARATOR
0x1E 0x001E # RECORD SEPARATOR
0x1F 0x001F # UNIT SEPARATOR
0x20 0x0020 # SPACE
0x21 0x0021 # EXCLAMATION MARK
0x22 0x0022 # QUOTATION MARK
0x23 0x0023 # NUMBER SIGN
0x24 0x0024 # DOLLAR SIGN
0x25 0x0025 # PERCENT SIGN
0x26 0x0026 # AMPERSAND
0x27 0x0027 # APOSTROPHE
0x28 0x0028 # LEFT PARENTHESIS
0x29 0x0029 # RIGHT PARENTHESIS
0x2A 0x002A # ASTERISK
0x2B 0x002B # PLUS SIGN
0x2C 0x002C # COMMA
0x2D 0x002D # HYPHEN-MINUS
0x2E 0x002E # FULL STOP
0x2F 0x002F # SOLIDUS
0x30 0x0030 # DIGIT ZERO
0x31 0x0031 # DIGIT ONE
0x32 0x0032 # DIGIT TWO
0x33 0x0033 # DIGIT THREE
0x34 0x0034 # DIGIT FOUR
0x35 0x0035 # DIGIT FIVE
0x36 0x0036 # DIGIT SIX
0x37 0x0037 # DIGIT SEVEN
0x38 0x0038 # DIGIT EIGHT
0x39 0x0039 # DIGIT NINE
0x3A 0x003A # COLON
0x3B 0x003B # SEMICOLON
0x3C 0x003C # LESS-THAN SIGN
0x3D 0x003D # EQUALS SIGN
0x3E 0x003E # GREATER-THAN SIGN
0x3F 0x003F # QUESTION MARK
0x40 0x0040 # COMMERCIAL AT
0x41 0x0041 # LATIN CAPITAL LETTER A
0x42 0x0042 # LATIN CAPITAL LETTER B
0x43 0x0043 # LATIN CAPITAL LETTER C
0x44 0x0044 # LATIN CAPITAL LETTER D
0x45 0x0045 # LATIN CAPITAL LETTER E
0x46 0x0046 # LATIN CAPITAL LETTER F
0x47 0x0047 # LATIN CAPITAL LETTER G
0x48 0x0048 # LATIN CAPITAL LETTER H
0x49 0x0049 # LATIN CAPITAL LETTER I
0x4A 0x004A # LATIN CAPITAL LETTER J
0x4B 0x004B # LATIN CAPITAL LETTER K
0x4C 0x004C # LATIN CAPITAL LETTER L
0x4D 0x004D # LATIN CAPITAL LETTER M
0x4E 0x004E # LATIN CAPITAL LETTER N
0x4F 0x004F # LATIN CAPITAL LETTER O
0x50 0x0050 # LATIN CAPITAL LETTER P
0x51 0x0051 # LATIN CAPITAL LETTER Q
0x52 0x0052 # LATIN CAPITAL LETTER R
0x53 0x0053 # LATIN CAPITAL LETTER S
0x54 0x0054 # LATIN CAPITAL LETTER T
0x55 0x0055 # LATIN CAPITAL LETTER U
0x56 0x0056 # LATIN CAPITAL LETTER V
0x57 0x0057 # LATIN CAPITAL LETTER W
0x58 0x0058 # LATIN CAPITAL LETTER X
0x59 0x0059 # LATIN CAPITAL LETTER Y
0x5A 0x005A # LATIN CAPITAL LETTER Z
0x5B 0x005B # LEFT SQUARE BRACKET
0x5C 0x005C # REVERSE SOLIDUS
0x5D 0x005D # RIGHT SQUARE BRACKET
0x5E 0x005E # CIRCUMFLEX ACCENT
0x5F 0x005F # LOW LINE
0x60 0x0060 # GRAVE ACCENT
0x61 0x0061 # LATIN SMALL LETTER A
0x62 0x0062 # LATIN SMALL LETTER B
0x63 0x0063 # LATIN SMALL LETTER C
0x64 0x0064 # LATIN SMALL LETTER D
0x65 0x0065 # LATIN SMALL LETTER E
0x66 0x0066 # LATIN SMALL LETTER F
0x67 0x0067 # LATIN SMALL LETTER G
0x68 0x0068 # LATIN SMALL LETTER H
0x69 0x0069 # LATIN SMALL LETTER I
0x6A 0x006A # LATIN SMALL LETTER J
0x6B 0x006B # LATIN SMALL LETTER K
0x6C 0x006C # LATIN SMALL LETTER L
0x6D 0x006D # LATIN SMALL LETTER M
0x6E 0x006E # LATIN SMALL LETTER N
0x6F 0x006F # LATIN SMALL LETTER O
0x70 0x0070 # LATIN SMALL LETTER P
0x71 0x0071 # LATIN SMALL LETTER Q
0x72 0x0072 # LATIN SMALL LETTER R
0x73 0x0073 # LATIN SMALL LETTER S
0x74 0x0074 # LATIN SMALL LETTER T
0x75 0x0075 # LATIN SMALL LETTER U
0x76 0x0076 # LATIN SMALL LETTER V
0x77 0x0077 # LATIN SMALL LETTER W
0x78 0x0078 # LATIN SMALL LETTER X
0x79 0x0079 # LATIN SMALL LETTER Y
0x7A 0x007A # LATIN SMALL LETTER Z
0x7B 0x007B # LEFT CURLY BRACKET
0x7C 0x007C # VERTICAL LINE
0x7D 0x007D # RIGHT CURLY BRACKET
0x7E 0x007E # TILDE
0x7F 0x007F # DELETE
0x80 0x0080 # <control>
0x81 0x0081 # <control>
0x82 0x0082 # <control>
0x83 0x0083 # <control>
0x84 0x0084 # <control>
0x85 0x0085 # <control>
0x86 0x0086 # <control>
0x87 0x0087 # <control>
0x88 0x0088 # <control>
0x89 0x0089 # <control>
0x8A 0x008A # <control>
0x8B 0x008B # <control>
0x8C 0x008C # <control>
0x8D 0x008D # <control>
0x8E 0x008E # <control>
0x8F 0x008F # <control>
0x90 0x0090 # <control>
0x91 0x0091 # <control>
0x92 0x0092 # <control>
0x93 0x0093 # <control>
0x94 0x0094 # <control>
0x95 0x0095 # <control>
0x96 0x0096 # <control>
0x97 0x0097 # <control>
0x98 0x0098 # <control>
0x99 0x0099 # <control>
0x9A 0x009A # <control>
0x9B 0x009B # <control>
0x9C 0x009C # <control>
0x9D 0x009D # <control>
0x9E 0x009E # <control>
0x9F 0x009F # <control>
#0xA0 0x00A0 # NO-BREAK SPACE
0xA1 0x0E01 # THAI CHARACTER KO KAI
0xA2 0x0E02 # THAI CHARACTER KHO KHAI
0xA3 0x0E03 # THAI CHARACTER KHO KHUAT
0xA4 0x0E04 # THAI CHARACTER KHO KHWAI
0xA5 0x0E05 # THAI CHARACTER KHO KHON
0xA6 0x0E06 # THAI CHARACTER KHO RAKHANG
0xA7 0x0E07 # THAI CHARACTER NGO NGU
0xA8 0x0E08 # THAI CHARACTER CHO CHAN
0xA9 0x0E09 # THAI CHARACTER CHO CHING
0xAA 0x0E0A # THAI CHARACTER CHO CHANG
0xAB 0x0E0B # THAI CHARACTER SO SO
0xAC 0x0E0C # THAI CHARACTER CHO CHOE
0xAD 0x0E0D # THAI CHARACTER YO YING
0xAE 0x0E0E # THAI CHARACTER DO CHADA
0xAF 0x0E0F # THAI CHARACTER TO PATAK
0xB0 0x0E10 # THAI CHARACTER THO THAN
0xB1 0x0E11 # THAI CHARACTER THO NANGMONTHO
0xB2 0x0E12 # THAI CHARACTER THO PHUTHAO
0xB3 0x0E13 # THAI CHARACTER NO NEN
0xB4 0x0E14 # THAI CHARACTER DO DEK
0xB5 0x0E15 # THAI CHARACTER TO TAO
0xB6 0x0E16 # THAI CHARACTER THO THUNG
0xB7 0x0E17 # THAI CHARACTER THO THAHAN
0xB8 0x0E18 # THAI CHARACTER THO THONG
0xB9 0x0E19 # THAI CHARACTER NO NU
0xBA 0x0E1A # THAI CHARACTER BO BAIMAI
0xBB 0x0E1B # THAI CHARACTER PO PLA
0xBC 0x0E1C # THAI CHARACTER PHO PHUNG
0xBD 0x0E1D # THAI CHARACTER FO FA
0xBE 0x0E1E # THAI CHARACTER PHO PHAN
0xBF 0x0E1F # THAI CHARACTER FO FAN
0xC0 0x0E20 # THAI CHARACTER PHO SAMPHAO
0xC1 0x0E21 # THAI CHARACTER MO MA
0xC2 0x0E22 # THAI CHARACTER YO YAK
0xC3 0x0E23 # THAI CHARACTER RO RUA
0xC4 0x0E24 # THAI CHARACTER RU
0xC5 0x0E25 # THAI CHARACTER LO LING
0xC6 0x0E26 # THAI CHARACTER LU
0xC7 0x0E27 # THAI CHARACTER WO WAEN
0xC8 0x0E28 # THAI CHARACTER SO SALA
0xC9 0x0E29 # THAI CHARACTER SO RUSI
0xCA 0x0E2A # THAI CHARACTER SO SUA
0xCB 0x0E2B # THAI CHARACTER HO HIP
0xCC 0x0E2C # THAI CHARACTER LO CHULA
0xCD 0x0E2D # THAI CHARACTER O ANG
0xCE 0x0E2E # THAI CHARACTER HO NOKHUK
0xCF 0x0E2F # THAI CHARACTER PAIYANNOI
0xD0 0x0E30 # THAI CHARACTER SARA A
0xD1 0x0E31 # THAI CHARACTER MAI HAN-AKAT
0xD2 0x0E32 # THAI CHARACTER SARA AA
0xD3 0x0E33 # THAI CHARACTER SARA AM
0xD4 0x0E34 # THAI CHARACTER SARA I
0xD5 0x0E35 # THAI CHARACTER SARA II
0xD6 0x0E36 # THAI CHARACTER SARA UE
0xD7 0x0E37 # THAI CHARACTER SARA UEE
0xD8 0x0E38 # THAI CHARACTER SARA U
0xD9 0x0E39 # THAI CHARACTER SARA UU
0xDA 0x0E3A # THAI CHARACTER PHINTHU
0xDF 0x0E3F # THAI CURRENCY SYMBOL BAHT
0xE0 0x0E40 # THAI CHARACTER SARA E
0xE1 0x0E41 # THAI CHARACTER SARA AE
0xE2 0x0E42 # THAI CHARACTER SARA O
0xE3 0x0E43 # THAI CHARACTER SARA AI MAIMUAN
0xE4 0x0E44 # THAI CHARACTER SARA AI MAIMALAI
0xE5 0x0E45 # THAI CHARACTER LAKKHANGYAO
0xE6 0x0E46 # THAI CHARACTER MAIYAMOK
0xE7 0x0E47 # THAI CHARACTER MAITAIKHU
0xE8 0x0E48 # THAI CHARACTER MAI EK
0xE9 0x0E49 # THAI CHARACTER MAI THO
0xEA 0x0E4A # THAI CHARACTER MAI TRI
0xEB 0x0E4B # THAI CHARACTER MAI CHATTAWA
0xEC 0x0E4C # THAI CHARACTER THANTHAKHAT
0xED 0x0E4D # THAI CHARACTER NIKHAHIT
0xEE 0x0E4E # THAI CHARACTER YAMAKKAN
0xEF 0x0E4F # THAI CHARACTER FONGMAN
0xF0 0x0E50 # THAI DIGIT ZERO
0xF1 0x0E51 # THAI DIGIT ONE
0xF2 0x0E52 # THAI DIGIT TWO
0xF3 0x0E53 # THAI DIGIT THREE
0xF4 0x0E54 # THAI DIGIT FOUR
0xF5 0x0E55 # THAI DIGIT FIVE
0xF6 0x0E56 # THAI DIGIT SIX
0xF7 0x0E57 # THAI DIGIT SEVEN
0xF8 0x0E58 # THAI DIGIT EIGHT
0xF9 0x0E59 # THAI DIGIT NINE
0xFA 0x0E5A # THAI CHARACTER ANGKHANKHU
0xFB 0x0E5B # THAI CHARACTER KHOMUT
| 9,350 | 285 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/python-mappings/CP1140.TXT | #
# Name: CP1140
# Unicode version: 3.2
# Table version: 1.0
# Table format: Format A
# Date: 2005-10-25
# Authors: Marc-Andre Lemburg <[email protected]>
#
# This encoding is a modified CP037 encoding (with added Euro
# currency sign).
#
# (c) Copyright Marc-Andre Lemburg, 2005.
# Licensed to PSF under a Contributor Agreement.
#
# Based on the file
# ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/EBCDIC/CP037.TXT
# which is:
#
# Copyright (c) 2002 Unicode, Inc. All Rights reserved.
#
# This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
# No claims are made as to fitness for any particular purpose. No
# warranties of any kind are expressed or implied. The recipient
# agrees to determine applicability of information provided. If this
# file has been provided on optical media by Unicode, Inc., the sole
# remedy for any claim will be exchange of defective media within 90
# days of receipt.
#
# Unicode, Inc. hereby grants the right to freely use the information
# supplied in this file in the creation of products supporting the
# Unicode Standard, and to make copies of this file in any form for
# internal or external distribution as long as this notice remains
# attached.
#
0x00 0x0000 #NULL
0x01 0x0001 #START OF HEADING
0x02 0x0002 #START OF TEXT
0x03 0x0003 #END OF TEXT
0x04 0x009C #CONTROL
0x05 0x0009 #HORIZONTAL TABULATION
0x06 0x0086 #CONTROL
0x07 0x007F #DELETE
0x08 0x0097 #CONTROL
0x09 0x008D #CONTROL
0x0A 0x008E #CONTROL
0x0B 0x000B #VERTICAL TABULATION
0x0C 0x000C #FORM FEED
0x0D 0x000D #CARRIAGE RETURN
0x0E 0x000E #SHIFT OUT
0x0F 0x000F #SHIFT IN
0x10 0x0010 #DATA LINK ESCAPE
0x11 0x0011 #DEVICE CONTROL ONE
0x12 0x0012 #DEVICE CONTROL TWO
0x13 0x0013 #DEVICE CONTROL THREE
0x14 0x009D #CONTROL
0x15 0x0085 #CONTROL
0x16 0x0008 #BACKSPACE
0x17 0x0087 #CONTROL
0x18 0x0018 #CANCEL
0x19 0x0019 #END OF MEDIUM
0x1A 0x0092 #CONTROL
0x1B 0x008F #CONTROL
0x1C 0x001C #FILE SEPARATOR
0x1D 0x001D #GROUP SEPARATOR
0x1E 0x001E #RECORD SEPARATOR
0x1F 0x001F #UNIT SEPARATOR
0x20 0x0080 #CONTROL
0x21 0x0081 #CONTROL
0x22 0x0082 #CONTROL
0x23 0x0083 #CONTROL
0x24 0x0084 #CONTROL
0x25 0x000A #LINE FEED
0x26 0x0017 #END OF TRANSMISSION BLOCK
0x27 0x001B #ESCAPE
0x28 0x0088 #CONTROL
0x29 0x0089 #CONTROL
0x2A 0x008A #CONTROL
0x2B 0x008B #CONTROL
0x2C 0x008C #CONTROL
0x2D 0x0005 #ENQUIRY
0x2E 0x0006 #ACKNOWLEDGE
0x2F 0x0007 #BELL
0x30 0x0090 #CONTROL
0x31 0x0091 #CONTROL
0x32 0x0016 #SYNCHRONOUS IDLE
0x33 0x0093 #CONTROL
0x34 0x0094 #CONTROL
0x35 0x0095 #CONTROL
0x36 0x0096 #CONTROL
0x37 0x0004 #END OF TRANSMISSION
0x38 0x0098 #CONTROL
0x39 0x0099 #CONTROL
0x3A 0x009A #CONTROL
0x3B 0x009B #CONTROL
0x3C 0x0014 #DEVICE CONTROL FOUR
0x3D 0x0015 #NEGATIVE ACKNOWLEDGE
0x3E 0x009E #CONTROL
0x3F 0x001A #SUBSTITUTE
0x40 0x0020 #SPACE
0x41 0x00A0 #NO-BREAK SPACE
0x42 0x00E2 #LATIN SMALL LETTER A WITH CIRCUMFLEX
0x43 0x00E4 #LATIN SMALL LETTER A WITH DIAERESIS
0x44 0x00E0 #LATIN SMALL LETTER A WITH GRAVE
0x45 0x00E1 #LATIN SMALL LETTER A WITH ACUTE
0x46 0x00E3 #LATIN SMALL LETTER A WITH TILDE
0x47 0x00E5 #LATIN SMALL LETTER A WITH RING ABOVE
0x48 0x00E7 #LATIN SMALL LETTER C WITH CEDILLA
0x49 0x00F1 #LATIN SMALL LETTER N WITH TILDE
0x4A 0x00A2 #CENT SIGN
0x4B 0x002E #FULL STOP
0x4C 0x003C #LESS-THAN SIGN
0x4D 0x0028 #LEFT PARENTHESIS
0x4E 0x002B #PLUS SIGN
0x4F 0x007C #VERTICAL LINE
0x50 0x0026 #AMPERSAND
0x51 0x00E9 #LATIN SMALL LETTER E WITH ACUTE
0x52 0x00EA #LATIN SMALL LETTER E WITH CIRCUMFLEX
0x53 0x00EB #LATIN SMALL LETTER E WITH DIAERESIS
0x54 0x00E8 #LATIN SMALL LETTER E WITH GRAVE
0x55 0x00ED #LATIN SMALL LETTER I WITH ACUTE
0x56 0x00EE #LATIN SMALL LETTER I WITH CIRCUMFLEX
0x57 0x00EF #LATIN SMALL LETTER I WITH DIAERESIS
0x58 0x00EC #LATIN SMALL LETTER I WITH GRAVE
0x59 0x00DF #LATIN SMALL LETTER SHARP S (GERMAN)
0x5A 0x0021 #EXCLAMATION MARK
0x5B 0x0024 #DOLLAR SIGN
0x5C 0x002A #ASTERISK
0x5D 0x0029 #RIGHT PARENTHESIS
0x5E 0x003B #SEMICOLON
0x5F 0x00AC #NOT SIGN
0x60 0x002D #HYPHEN-MINUS
0x61 0x002F #SOLIDUS
0x62 0x00C2 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
0x63 0x00C4 #LATIN CAPITAL LETTER A WITH DIAERESIS
0x64 0x00C0 #LATIN CAPITAL LETTER A WITH GRAVE
0x65 0x00C1 #LATIN CAPITAL LETTER A WITH ACUTE
0x66 0x00C3 #LATIN CAPITAL LETTER A WITH TILDE
0x67 0x00C5 #LATIN CAPITAL LETTER A WITH RING ABOVE
0x68 0x00C7 #LATIN CAPITAL LETTER C WITH CEDILLA
0x69 0x00D1 #LATIN CAPITAL LETTER N WITH TILDE
0x6A 0x00A6 #BROKEN BAR
0x6B 0x002C #COMMA
0x6C 0x0025 #PERCENT SIGN
0x6D 0x005F #LOW LINE
0x6E 0x003E #GREATER-THAN SIGN
0x6F 0x003F #QUESTION MARK
0x70 0x00F8 #LATIN SMALL LETTER O WITH STROKE
0x71 0x00C9 #LATIN CAPITAL LETTER E WITH ACUTE
0x72 0x00CA #LATIN CAPITAL LETTER E WITH CIRCUMFLEX
0x73 0x00CB #LATIN CAPITAL LETTER E WITH DIAERESIS
0x74 0x00C8 #LATIN CAPITAL LETTER E WITH GRAVE
0x75 0x00CD #LATIN CAPITAL LETTER I WITH ACUTE
0x76 0x00CE #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
0x77 0x00CF #LATIN CAPITAL LETTER I WITH DIAERESIS
0x78 0x00CC #LATIN CAPITAL LETTER I WITH GRAVE
0x79 0x0060 #GRAVE ACCENT
0x7A 0x003A #COLON
0x7B 0x0023 #NUMBER SIGN
0x7C 0x0040 #COMMERCIAL AT
0x7D 0x0027 #APOSTROPHE
0x7E 0x003D #EQUALS SIGN
0x7F 0x0022 #QUOTATION MARK
0x80 0x00D8 #LATIN CAPITAL LETTER O WITH STROKE
0x81 0x0061 #LATIN SMALL LETTER A
0x82 0x0062 #LATIN SMALL LETTER B
0x83 0x0063 #LATIN SMALL LETTER C
0x84 0x0064 #LATIN SMALL LETTER D
0x85 0x0065 #LATIN SMALL LETTER E
0x86 0x0066 #LATIN SMALL LETTER F
0x87 0x0067 #LATIN SMALL LETTER G
0x88 0x0068 #LATIN SMALL LETTER H
0x89 0x0069 #LATIN SMALL LETTER I
0x8A 0x00AB #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
0x8B 0x00BB #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
0x8C 0x00F0 #LATIN SMALL LETTER ETH (ICELANDIC)
0x8D 0x00FD #LATIN SMALL LETTER Y WITH ACUTE
0x8E 0x00FE #LATIN SMALL LETTER THORN (ICELANDIC)
0x8F 0x00B1 #PLUS-MINUS SIGN
0x90 0x00B0 #DEGREE SIGN
0x91 0x006A #LATIN SMALL LETTER J
0x92 0x006B #LATIN SMALL LETTER K
0x93 0x006C #LATIN SMALL LETTER L
0x94 0x006D #LATIN SMALL LETTER M
0x95 0x006E #LATIN SMALL LETTER N
0x96 0x006F #LATIN SMALL LETTER O
0x97 0x0070 #LATIN SMALL LETTER P
0x98 0x0071 #LATIN SMALL LETTER Q
0x99 0x0072 #LATIN SMALL LETTER R
0x9A 0x00AA #FEMININE ORDINAL INDICATOR
0x9B 0x00BA #MASCULINE ORDINAL INDICATOR
0x9C 0x00E6 #LATIN SMALL LIGATURE AE
0x9D 0x00B8 #CEDILLA
0x9E 0x00C6 #LATIN CAPITAL LIGATURE AE
#0x9F 0x00A4 #CURRENCY SIGN
0x9F 0x20AC # EURO SIGN
0xA0 0x00B5 #MICRO SIGN
0xA1 0x007E #TILDE
0xA2 0x0073 #LATIN SMALL LETTER S
0xA3 0x0074 #LATIN SMALL LETTER T
0xA4 0x0075 #LATIN SMALL LETTER U
0xA5 0x0076 #LATIN SMALL LETTER V
0xA6 0x0077 #LATIN SMALL LETTER W
0xA7 0x0078 #LATIN SMALL LETTER X
0xA8 0x0079 #LATIN SMALL LETTER Y
0xA9 0x007A #LATIN SMALL LETTER Z
0xAA 0x00A1 #INVERTED EXCLAMATION MARK
0xAB 0x00BF #INVERTED QUESTION MARK
0xAC 0x00D0 #LATIN CAPITAL LETTER ETH (ICELANDIC)
0xAD 0x00DD #LATIN CAPITAL LETTER Y WITH ACUTE
0xAE 0x00DE #LATIN CAPITAL LETTER THORN (ICELANDIC)
0xAF 0x00AE #REGISTERED SIGN
0xB0 0x005E #CIRCUMFLEX ACCENT
0xB1 0x00A3 #POUND SIGN
0xB2 0x00A5 #YEN SIGN
0xB3 0x00B7 #MIDDLE DOT
0xB4 0x00A9 #COPYRIGHT SIGN
0xB5 0x00A7 #SECTION SIGN
0xB6 0x00B6 #PILCROW SIGN
0xB7 0x00BC #VULGAR FRACTION ONE QUARTER
0xB8 0x00BD #VULGAR FRACTION ONE HALF
0xB9 0x00BE #VULGAR FRACTION THREE QUARTERS
0xBA 0x005B #LEFT SQUARE BRACKET
0xBB 0x005D #RIGHT SQUARE BRACKET
0xBC 0x00AF #MACRON
0xBD 0x00A8 #DIAERESIS
0xBE 0x00B4 #ACUTE ACCENT
0xBF 0x00D7 #MULTIPLICATION SIGN
0xC0 0x007B #LEFT CURLY BRACKET
0xC1 0x0041 #LATIN CAPITAL LETTER A
0xC2 0x0042 #LATIN CAPITAL LETTER B
0xC3 0x0043 #LATIN CAPITAL LETTER C
0xC4 0x0044 #LATIN CAPITAL LETTER D
0xC5 0x0045 #LATIN CAPITAL LETTER E
0xC6 0x0046 #LATIN CAPITAL LETTER F
0xC7 0x0047 #LATIN CAPITAL LETTER G
0xC8 0x0048 #LATIN CAPITAL LETTER H
0xC9 0x0049 #LATIN CAPITAL LETTER I
0xCA 0x00AD #SOFT HYPHEN
0xCB 0x00F4 #LATIN SMALL LETTER O WITH CIRCUMFLEX
0xCC 0x00F6 #LATIN SMALL LETTER O WITH DIAERESIS
0xCD 0x00F2 #LATIN SMALL LETTER O WITH GRAVE
0xCE 0x00F3 #LATIN SMALL LETTER O WITH ACUTE
0xCF 0x00F5 #LATIN SMALL LETTER O WITH TILDE
0xD0 0x007D #RIGHT CURLY BRACKET
0xD1 0x004A #LATIN CAPITAL LETTER J
0xD2 0x004B #LATIN CAPITAL LETTER K
0xD3 0x004C #LATIN CAPITAL LETTER L
0xD4 0x004D #LATIN CAPITAL LETTER M
0xD5 0x004E #LATIN CAPITAL LETTER N
0xD6 0x004F #LATIN CAPITAL LETTER O
0xD7 0x0050 #LATIN CAPITAL LETTER P
0xD8 0x0051 #LATIN CAPITAL LETTER Q
0xD9 0x0052 #LATIN CAPITAL LETTER R
0xDA 0x00B9 #SUPERSCRIPT ONE
0xDB 0x00FB #LATIN SMALL LETTER U WITH CIRCUMFLEX
0xDC 0x00FC #LATIN SMALL LETTER U WITH DIAERESIS
0xDD 0x00F9 #LATIN SMALL LETTER U WITH GRAVE
0xDE 0x00FA #LATIN SMALL LETTER U WITH ACUTE
0xDF 0x00FF #LATIN SMALL LETTER Y WITH DIAERESIS
0xE0 0x005C #REVERSE SOLIDUS
0xE1 0x00F7 #DIVISION SIGN
0xE2 0x0053 #LATIN CAPITAL LETTER S
0xE3 0x0054 #LATIN CAPITAL LETTER T
0xE4 0x0055 #LATIN CAPITAL LETTER U
0xE5 0x0056 #LATIN CAPITAL LETTER V
0xE6 0x0057 #LATIN CAPITAL LETTER W
0xE7 0x0058 #LATIN CAPITAL LETTER X
0xE8 0x0059 #LATIN CAPITAL LETTER Y
0xE9 0x005A #LATIN CAPITAL LETTER Z
0xEA 0x00B2 #SUPERSCRIPT TWO
0xEB 0x00D4 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
0xEC 0x00D6 #LATIN CAPITAL LETTER O WITH DIAERESIS
0xED 0x00D2 #LATIN CAPITAL LETTER O WITH GRAVE
0xEE 0x00D3 #LATIN CAPITAL LETTER O WITH ACUTE
0xEF 0x00D5 #LATIN CAPITAL LETTER O WITH TILDE
0xF0 0x0030 #DIGIT ZERO
0xF1 0x0031 #DIGIT ONE
0xF2 0x0032 #DIGIT TWO
0xF3 0x0033 #DIGIT THREE
0xF4 0x0034 #DIGIT FOUR
0xF5 0x0035 #DIGIT FIVE
0xF6 0x0036 #DIGIT SIX
0xF7 0x0037 #DIGIT SEVEN
0xF8 0x0038 #DIGIT EIGHT
0xF9 0x0039 #DIGIT NINE
0xFA 0x00B3 #SUPERSCRIPT THREE
0xFB 0x00DB #LATIN CAPITAL LETTER U WITH CIRCUMFLEX
0xFC 0x00DC #LATIN CAPITAL LETTER U WITH DIAERESIS
0xFD 0x00D9 #LATIN CAPITAL LETTER U WITH GRAVE
0xFE 0x00DA #LATIN CAPITAL LETTER U WITH ACUTE
0xFF 0x009F #CONTROL
| 9,829 | 292 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/unicode/python-mappings/KOI8-U.TXT | #
# Name: KOI8-U (RFC2319) to Unicode
# Unicode version: 3.2
# Table version: 1.0
# Table format: Format A
# Date: 2005-10-25
# Authors: Marc-Andre Lemburg <[email protected]>
#
# See RFC2319 for details. This encoding is a modified KOI8-R
# encoding.
#
# (c) Copyright Marc-Andre Lemburg, 2005.
# Licensed to PSF under a Contributor Agreement.
#
# Based on the file
# ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MISC/KOI8-R.TXT
# which is:
#
# Copyright (c) 1991-1999 Unicode, Inc. All Rights reserved.
#
# This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
# No claims are made as to fitness for any particular purpose. No
# warranties of any kind are expressed or implied. The recipient
# agrees to determine applicability of information provided. If this
# file has been provided on optical media by Unicode, Inc., the sole
# remedy for any claim will be exchange of defective media within 90
# days of receipt.
#
# Unicode, Inc. hereby grants the right to freely use the information
# supplied in this file in the creation of products supporting the
# Unicode Standard, and to make copies of this file in any form for
# internal or external distribution as long as this notice remains
# attached.
#
0x00 0x0000 # NULL
0x01 0x0001 # START OF HEADING
0x02 0x0002 # START OF TEXT
0x03 0x0003 # END OF TEXT
0x04 0x0004 # END OF TRANSMISSION
0x05 0x0005 # ENQUIRY
0x06 0x0006 # ACKNOWLEDGE
0x07 0x0007 # BELL
0x08 0x0008 # BACKSPACE
0x09 0x0009 # HORIZONTAL TABULATION
0x0A 0x000A # LINE FEED
0x0B 0x000B # VERTICAL TABULATION
0x0C 0x000C # FORM FEED
0x0D 0x000D # CARRIAGE RETURN
0x0E 0x000E # SHIFT OUT
0x0F 0x000F # SHIFT IN
0x10 0x0010 # DATA LINK ESCAPE
0x11 0x0011 # DEVICE CONTROL ONE
0x12 0x0012 # DEVICE CONTROL TWO
0x13 0x0013 # DEVICE CONTROL THREE
0x14 0x0014 # DEVICE CONTROL FOUR
0x15 0x0015 # NEGATIVE ACKNOWLEDGE
0x16 0x0016 # SYNCHRONOUS IDLE
0x17 0x0017 # END OF TRANSMISSION BLOCK
0x18 0x0018 # CANCEL
0x19 0x0019 # END OF MEDIUM
0x1A 0x001A # SUBSTITUTE
0x1B 0x001B # ESCAPE
0x1C 0x001C # FILE SEPARATOR
0x1D 0x001D # GROUP SEPARATOR
0x1E 0x001E # RECORD SEPARATOR
0x1F 0x001F # UNIT SEPARATOR
0x20 0x0020 # SPACE
0x21 0x0021 # EXCLAMATION MARK
0x22 0x0022 # QUOTATION MARK
0x23 0x0023 # NUMBER SIGN
0x24 0x0024 # DOLLAR SIGN
0x25 0x0025 # PERCENT SIGN
0x26 0x0026 # AMPERSAND
0x27 0x0027 # APOSTROPHE
0x28 0x0028 # LEFT PARENTHESIS
0x29 0x0029 # RIGHT PARENTHESIS
0x2A 0x002A # ASTERISK
0x2B 0x002B # PLUS SIGN
0x2C 0x002C # COMMA
0x2D 0x002D # HYPHEN-MINUS
0x2E 0x002E # FULL STOP
0x2F 0x002F # SOLIDUS
0x30 0x0030 # DIGIT ZERO
0x31 0x0031 # DIGIT ONE
0x32 0x0032 # DIGIT TWO
0x33 0x0033 # DIGIT THREE
0x34 0x0034 # DIGIT FOUR
0x35 0x0035 # DIGIT FIVE
0x36 0x0036 # DIGIT SIX
0x37 0x0037 # DIGIT SEVEN
0x38 0x0038 # DIGIT EIGHT
0x39 0x0039 # DIGIT NINE
0x3A 0x003A # COLON
0x3B 0x003B # SEMICOLON
0x3C 0x003C # LESS-THAN SIGN
0x3D 0x003D # EQUALS SIGN
0x3E 0x003E # GREATER-THAN SIGN
0x3F 0x003F # QUESTION MARK
0x40 0x0040 # COMMERCIAL AT
0x41 0x0041 # LATIN CAPITAL LETTER A
0x42 0x0042 # LATIN CAPITAL LETTER B
0x43 0x0043 # LATIN CAPITAL LETTER C
0x44 0x0044 # LATIN CAPITAL LETTER D
0x45 0x0045 # LATIN CAPITAL LETTER E
0x46 0x0046 # LATIN CAPITAL LETTER F
0x47 0x0047 # LATIN CAPITAL LETTER G
0x48 0x0048 # LATIN CAPITAL LETTER H
0x49 0x0049 # LATIN CAPITAL LETTER I
0x4A 0x004A # LATIN CAPITAL LETTER J
0x4B 0x004B # LATIN CAPITAL LETTER K
0x4C 0x004C # LATIN CAPITAL LETTER L
0x4D 0x004D # LATIN CAPITAL LETTER M
0x4E 0x004E # LATIN CAPITAL LETTER N
0x4F 0x004F # LATIN CAPITAL LETTER O
0x50 0x0050 # LATIN CAPITAL LETTER P
0x51 0x0051 # LATIN CAPITAL LETTER Q
0x52 0x0052 # LATIN CAPITAL LETTER R
0x53 0x0053 # LATIN CAPITAL LETTER S
0x54 0x0054 # LATIN CAPITAL LETTER T
0x55 0x0055 # LATIN CAPITAL LETTER U
0x56 0x0056 # LATIN CAPITAL LETTER V
0x57 0x0057 # LATIN CAPITAL LETTER W
0x58 0x0058 # LATIN CAPITAL LETTER X
0x59 0x0059 # LATIN CAPITAL LETTER Y
0x5A 0x005A # LATIN CAPITAL LETTER Z
0x5B 0x005B # LEFT SQUARE BRACKET
0x5C 0x005C # REVERSE SOLIDUS
0x5D 0x005D # RIGHT SQUARE BRACKET
0x5E 0x005E # CIRCUMFLEX ACCENT
0x5F 0x005F # LOW LINE
0x60 0x0060 # GRAVE ACCENT
0x61 0x0061 # LATIN SMALL LETTER A
0x62 0x0062 # LATIN SMALL LETTER B
0x63 0x0063 # LATIN SMALL LETTER C
0x64 0x0064 # LATIN SMALL LETTER D
0x65 0x0065 # LATIN SMALL LETTER E
0x66 0x0066 # LATIN SMALL LETTER F
0x67 0x0067 # LATIN SMALL LETTER G
0x68 0x0068 # LATIN SMALL LETTER H
0x69 0x0069 # LATIN SMALL LETTER I
0x6A 0x006A # LATIN SMALL LETTER J
0x6B 0x006B # LATIN SMALL LETTER K
0x6C 0x006C # LATIN SMALL LETTER L
0x6D 0x006D # LATIN SMALL LETTER M
0x6E 0x006E # LATIN SMALL LETTER N
0x6F 0x006F # LATIN SMALL LETTER O
0x70 0x0070 # LATIN SMALL LETTER P
0x71 0x0071 # LATIN SMALL LETTER Q
0x72 0x0072 # LATIN SMALL LETTER R
0x73 0x0073 # LATIN SMALL LETTER S
0x74 0x0074 # LATIN SMALL LETTER T
0x75 0x0075 # LATIN SMALL LETTER U
0x76 0x0076 # LATIN SMALL LETTER V
0x77 0x0077 # LATIN SMALL LETTER W
0x78 0x0078 # LATIN SMALL LETTER X
0x79 0x0079 # LATIN SMALL LETTER Y
0x7A 0x007A # LATIN SMALL LETTER Z
0x7B 0x007B # LEFT CURLY BRACKET
0x7C 0x007C # VERTICAL LINE
0x7D 0x007D # RIGHT CURLY BRACKET
0x7E 0x007E # TILDE
0x7F 0x007F # DELETE
0x80 0x2500 # BOX DRAWINGS LIGHT HORIZONTAL
0x81 0x2502 # BOX DRAWINGS LIGHT VERTICAL
0x82 0x250C # BOX DRAWINGS LIGHT DOWN AND RIGHT
0x83 0x2510 # BOX DRAWINGS LIGHT DOWN AND LEFT
0x84 0x2514 # BOX DRAWINGS LIGHT UP AND RIGHT
0x85 0x2518 # BOX DRAWINGS LIGHT UP AND LEFT
0x86 0x251C # BOX DRAWINGS LIGHT VERTICAL AND RIGHT
0x87 0x2524 # BOX DRAWINGS LIGHT VERTICAL AND LEFT
0x88 0x252C # BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
0x89 0x2534 # BOX DRAWINGS LIGHT UP AND HORIZONTAL
0x8A 0x253C # BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
0x8B 0x2580 # UPPER HALF BLOCK
0x8C 0x2584 # LOWER HALF BLOCK
0x8D 0x2588 # FULL BLOCK
0x8E 0x258C # LEFT HALF BLOCK
0x8F 0x2590 # RIGHT HALF BLOCK
0x90 0x2591 # LIGHT SHADE
0x91 0x2592 # MEDIUM SHADE
0x92 0x2593 # DARK SHADE
0x93 0x2320 # TOP HALF INTEGRAL
0x94 0x25A0 # BLACK SQUARE
0x95 0x2219 # BULLET OPERATOR
0x96 0x221A # SQUARE ROOT
0x97 0x2248 # ALMOST EQUAL TO
0x98 0x2264 # LESS-THAN OR EQUAL TO
0x99 0x2265 # GREATER-THAN OR EQUAL TO
0x9A 0x00A0 # NO-BREAK SPACE
0x9B 0x2321 # BOTTOM HALF INTEGRAL
0x9C 0x00B0 # DEGREE SIGN
0x9D 0x00B2 # SUPERSCRIPT TWO
0x9E 0x00B7 # MIDDLE DOT
0x9F 0x00F7 # DIVISION SIGN
0xA0 0x2550 # BOX DRAWINGS DOUBLE HORIZONTAL
0xA1 0x2551 # BOX DRAWINGS DOUBLE VERTICAL
0xA2 0x2552 # BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
0xA3 0x0451 # CYRILLIC SMALL LETTER IO
#0xA4 0x2553 # BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
0xA4 0x0454 # CYRILLIC SMALL LETTER UKRAINIAN IE
0xA5 0x2554 # BOX DRAWINGS DOUBLE DOWN AND RIGHT
#0xA6 0x2555 # BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
0xA6 0x0456 # CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
#0xA7 0x2556 # BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
0xA7 0x0457 # CYRILLIC SMALL LETTER YI (UKRAINIAN)
0xA8 0x2557 # BOX DRAWINGS DOUBLE DOWN AND LEFT
0xA9 0x2558 # BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
0xAA 0x2559 # BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
0xAB 0x255A # BOX DRAWINGS DOUBLE UP AND RIGHT
0xAC 0x255B # BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
#0xAD 0x255C # BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
0xAD 0x0491 # CYRILLIC SMALL LETTER UKRAINIAN GHE WITH UPTURN
0xAE 0x255D # BOX DRAWINGS DOUBLE UP AND LEFT
0xAF 0x255E # BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
0xB0 0x255F # BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
0xB1 0x2560 # BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
0xB2 0x2561 # BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
0xB3 0x0401 # CYRILLIC CAPITAL LETTER IO
#0xB4 0x2562 # BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
0xB4 0x0404 # CYRILLIC CAPITAL LETTER UKRAINIAN IE
0xB5 0x2563 # BOX DRAWINGS DOUBLE VERTICAL AND LEFT
#0xB6 0x2564 # BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
0xB6 0x0406 # CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
#0xB7 0x2565 # BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
0xB7 0x0407 # CYRILLIC CAPITAL LETTER YI (UKRAINIAN)
0xB8 0x2566 # BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
0xB9 0x2567 # BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
0xBA 0x2568 # BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
0xBB 0x2569 # BOX DRAWINGS DOUBLE UP AND HORIZONTAL
0xBC 0x256A # BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
#0xBD 0x256B # BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
0xBD 0x0490 # CYRILLIC CAPITAL LETTER UKRAINIAN GHE WITH UPTURN
0xBE 0x256C # BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
0xBF 0x00A9 # COPYRIGHT SIGN
0xC0 0x044E # CYRILLIC SMALL LETTER YU
0xC1 0x0430 # CYRILLIC SMALL LETTER A
0xC2 0x0431 # CYRILLIC SMALL LETTER BE
0xC3 0x0446 # CYRILLIC SMALL LETTER TSE
0xC4 0x0434 # CYRILLIC SMALL LETTER DE
0xC5 0x0435 # CYRILLIC SMALL LETTER IE
0xC6 0x0444 # CYRILLIC SMALL LETTER EF
0xC7 0x0433 # CYRILLIC SMALL LETTER GHE
0xC8 0x0445 # CYRILLIC SMALL LETTER HA
0xC9 0x0438 # CYRILLIC SMALL LETTER I
0xCA 0x0439 # CYRILLIC SMALL LETTER SHORT I
0xCB 0x043A # CYRILLIC SMALL LETTER KA
0xCC 0x043B # CYRILLIC SMALL LETTER EL
0xCD 0x043C # CYRILLIC SMALL LETTER EM
0xCE 0x043D # CYRILLIC SMALL LETTER EN
0xCF 0x043E # CYRILLIC SMALL LETTER O
0xD0 0x043F # CYRILLIC SMALL LETTER PE
0xD1 0x044F # CYRILLIC SMALL LETTER YA
0xD2 0x0440 # CYRILLIC SMALL LETTER ER
0xD3 0x0441 # CYRILLIC SMALL LETTER ES
0xD4 0x0442 # CYRILLIC SMALL LETTER TE
0xD5 0x0443 # CYRILLIC SMALL LETTER U
0xD6 0x0436 # CYRILLIC SMALL LETTER ZHE
0xD7 0x0432 # CYRILLIC SMALL LETTER VE
0xD8 0x044C # CYRILLIC SMALL LETTER SOFT SIGN
0xD9 0x044B # CYRILLIC SMALL LETTER YERU
0xDA 0x0437 # CYRILLIC SMALL LETTER ZE
0xDB 0x0448 # CYRILLIC SMALL LETTER SHA
0xDC 0x044D # CYRILLIC SMALL LETTER E
0xDD 0x0449 # CYRILLIC SMALL LETTER SHCHA
0xDE 0x0447 # CYRILLIC SMALL LETTER CHE
0xDF 0x044A # CYRILLIC SMALL LETTER HARD SIGN
0xE0 0x042E # CYRILLIC CAPITAL LETTER YU
0xE1 0x0410 # CYRILLIC CAPITAL LETTER A
0xE2 0x0411 # CYRILLIC CAPITAL LETTER BE
0xE3 0x0426 # CYRILLIC CAPITAL LETTER TSE
0xE4 0x0414 # CYRILLIC CAPITAL LETTER DE
0xE5 0x0415 # CYRILLIC CAPITAL LETTER IE
0xE6 0x0424 # CYRILLIC CAPITAL LETTER EF
0xE7 0x0413 # CYRILLIC CAPITAL LETTER GHE
0xE8 0x0425 # CYRILLIC CAPITAL LETTER HA
0xE9 0x0418 # CYRILLIC CAPITAL LETTER I
0xEA 0x0419 # CYRILLIC CAPITAL LETTER SHORT I
0xEB 0x041A # CYRILLIC CAPITAL LETTER KA
0xEC 0x041B # CYRILLIC CAPITAL LETTER EL
0xED 0x041C # CYRILLIC CAPITAL LETTER EM
0xEE 0x041D # CYRILLIC CAPITAL LETTER EN
0xEF 0x041E # CYRILLIC CAPITAL LETTER O
0xF0 0x041F # CYRILLIC CAPITAL LETTER PE
0xF1 0x042F # CYRILLIC CAPITAL LETTER YA
0xF2 0x0420 # CYRILLIC CAPITAL LETTER ER
0xF3 0x0421 # CYRILLIC CAPITAL LETTER ES
0xF4 0x0422 # CYRILLIC CAPITAL LETTER TE
0xF5 0x0423 # CYRILLIC CAPITAL LETTER U
0xF6 0x0416 # CYRILLIC CAPITAL LETTER ZHE
0xF7 0x0412 # CYRILLIC CAPITAL LETTER VE
0xF8 0x042C # CYRILLIC CAPITAL LETTER SOFT SIGN
0xF9 0x042B # CYRILLIC CAPITAL LETTER YERU
0xFA 0x0417 # CYRILLIC CAPITAL LETTER ZE
0xFB 0x0428 # CYRILLIC CAPITAL LETTER SHA
0xFC 0x042D # CYRILLIC CAPITAL LETTER E
0xFD 0x0429 # CYRILLIC CAPITAL LETTER SHCHA
0xFE 0x0427 # CYRILLIC CAPITAL LETTER CHE
0xFF 0x042A # CYRILLIC CAPITAL LETTER HARD SIGN
| 11,267 | 299 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/README | This project demonstrates how a distutils package
can support Python 2.x and Python 3.x from a single
source, using lib2to3. | 124 | 3 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/setup.py | # -*- coding: iso-8859-1 -*-
from distutils.core import setup
try:
from distutils.command.build_py import build_py_2to3 as build_py
except ImportError:
from distutils.command.build_py import build_py
try:
from distutils.command.build_scripts import build_scripts_2to3 as build_scripts
except ImportError:
from distutils.command.build_scripts import build_scripts
setup(
name = "test2to3",
version = "1.0",
description = "2to3 distutils test package",
author = "Martin v. Löwis",
author_email = "[email protected]",
license = "PSF license",
packages = ["test2to3"],
scripts = ["maintest.py"],
cmdclass = {'build_py': build_py,
'build_scripts': build_scripts,
}
)
| 753 | 27 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/maintest.py | #!/usr/bin/env python3
# The above line should get replaced with the path to the Python
# interpreter; the block below should get 2to3-converted.
try:
from test2to3.hello import hello
except ImportError, e:
print "Import failed", e
hello()
| 250 | 11 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/test2to3/hello.py | def hello():
try:
print "Hello, world"
except IOError, e:
print e.errno
| 96 | 6 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/test2to3/__init__.py | # empty
| 8 | 2 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/test/runtests.py | # Fictitious test runner for the project
import sys, os
if sys.version_info > (3,):
# copy test suite over to "build/lib" and convert it
from distutils.util import copydir_run_2to3
testroot = os.path.dirname(__file__)
newroot = os.path.join(testroot, '..', 'build/lib/test')
copydir_run_2to3(testroot, newroot)
# in the following imports, pick up the converted modules
sys.path[0] = newroot
# run the tests here...
from test_foo import FooTest
import unittest
unittest.main()
| 509 | 20 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/test2to3/test/test_foo.py | import sys
import unittest
class FooTest(unittest.TestCase):
def test_foo(self):
# use 2.6 syntax to demonstrate conversion
print 'In test_foo, using Python %s...' % (sys.version_info,)
self.assertTrue(False)
| 238 | 9 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/ccbench/ccbench.py | # This file should be kept compatible with both Python 2.6 and Python >= 3.0.
from __future__ import division
from __future__ import print_function
"""
ccbench, a Python concurrency benchmark.
"""
import time
import os
import sys
import itertools
import threading
import subprocess
import socket
from optparse import OptionParser, SUPPRESS_HELP
import platform
# Compatibility
try:
xrange
except NameError:
xrange = range
try:
map = itertools.imap
except AttributeError:
pass
THROUGHPUT_DURATION = 2.0
LATENCY_PING_INTERVAL = 0.1
LATENCY_DURATION = 2.0
BANDWIDTH_PACKET_SIZE = 1024
BANDWIDTH_DURATION = 2.0
def task_pidigits():
"""Pi calculation (Python)"""
_map = map
_count = itertools.count
_islice = itertools.islice
def calc_ndigits(n):
# From http://shootout.alioth.debian.org/
def gen_x():
return _map(lambda k: (k, 4*k + 2, 0, 2*k + 1), _count(1))
def compose(a, b):
aq, ar, as_, at = a
bq, br, bs, bt = b
return (aq * bq,
aq * br + ar * bt,
as_ * bq + at * bs,
as_ * br + at * bt)
def extract(z, j):
q, r, s, t = z
return (q*j + r) // (s*j + t)
def pi_digits():
z = (1, 0, 0, 1)
x = gen_x()
while 1:
y = extract(z, 3)
while y != extract(z, 4):
z = compose(z, next(x))
y = extract(z, 3)
z = compose((10, -10*y, 0, 1), z)
yield y
return list(_islice(pi_digits(), n))
return calc_ndigits, (50, )
def task_regex():
"""regular expression (C)"""
# XXX this task gives horrendous latency results.
import re
# Taken from the `inspect` module
pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)', re.MULTILINE)
with open(__file__, "r") as f:
arg = f.read(2000)
def findall(s):
t = time.time()
try:
return pat.findall(s)
finally:
print(time.time() - t)
return pat.findall, (arg, )
def task_sort():
"""list sorting (C)"""
def list_sort(l):
l = l[::-1]
l.sort()
return list_sort, (list(range(1000)), )
def task_compress_zlib():
"""zlib compression (C)"""
import zlib
with open(__file__, "rb") as f:
arg = f.read(5000) * 3
def compress(s):
zlib.decompress(zlib.compress(s, 5))
return compress, (arg, )
def task_compress_bz2():
"""bz2 compression (C)"""
import bz2
with open(__file__, "rb") as f:
arg = f.read(3000) * 2
def compress(s):
bz2.compress(s)
return compress, (arg, )
def task_hashing():
"""SHA1 hashing (C)"""
import hashlib
with open(__file__, "rb") as f:
arg = f.read(5000) * 30
def compute(s):
hashlib.sha1(s).digest()
return compute, (arg, )
throughput_tasks = [task_pidigits, task_regex]
for mod in 'bz2', 'hashlib':
try:
globals()[mod] = __import__(mod)
except ImportError:
globals()[mod] = None
# For whatever reasons, zlib gives irregular results, so we prefer bz2 or
# hashlib if available.
# (NOTE: hashlib releases the GIL from 2.7 and 3.1 onwards)
if bz2 is not None:
throughput_tasks.append(task_compress_bz2)
elif hashlib is not None:
throughput_tasks.append(task_hashing)
else:
throughput_tasks.append(task_compress_zlib)
latency_tasks = throughput_tasks
bandwidth_tasks = [task_pidigits]
class TimedLoop:
def __init__(self, func, args):
self.func = func
self.args = args
def __call__(self, start_time, min_duration, end_event, do_yield=False):
step = 20
niters = 0
duration = 0.0
_time = time.time
_sleep = time.sleep
_func = self.func
_args = self.args
t1 = start_time
while True:
for i in range(step):
_func(*_args)
t2 = _time()
# If another thread terminated, the current measurement is invalid
# => return the previous one.
if end_event:
return niters, duration
niters += step
duration = t2 - start_time
if duration >= min_duration:
end_event.append(None)
return niters, duration
if t2 - t1 < 0.01:
# Minimize interference of measurement on overall runtime
step = step * 3 // 2
elif do_yield:
# OS scheduling of Python threads is sometimes so bad that we
# have to force thread switching ourselves, otherwise we get
# completely useless results.
_sleep(0.0001)
t1 = t2
def run_throughput_test(func, args, nthreads):
assert nthreads >= 1
# Warm up
func(*args)
results = []
loop = TimedLoop(func, args)
end_event = []
if nthreads == 1:
# Pure single-threaded performance, without any switching or
# synchronization overhead.
start_time = time.time()
results.append(loop(start_time, THROUGHPUT_DURATION,
end_event, do_yield=False))
return results
started = False
ready_cond = threading.Condition()
start_cond = threading.Condition()
ready = []
def run():
with ready_cond:
ready.append(None)
ready_cond.notify()
with start_cond:
while not started:
start_cond.wait()
results.append(loop(start_time, THROUGHPUT_DURATION,
end_event, do_yield=True))
threads = []
for i in range(nthreads):
threads.append(threading.Thread(target=run))
for t in threads:
t.setDaemon(True)
t.start()
# We don't want measurements to include thread startup overhead,
# so we arrange for timing to start after all threads are ready.
with ready_cond:
while len(ready) < nthreads:
ready_cond.wait()
with start_cond:
start_time = time.time()
started = True
start_cond.notify(nthreads)
for t in threads:
t.join()
return results
def run_throughput_tests(max_threads):
for task in throughput_tasks:
print(task.__doc__)
print()
func, args = task()
nthreads = 1
baseline_speed = None
while nthreads <= max_threads:
results = run_throughput_test(func, args, nthreads)
# Taking the max duration rather than average gives pessimistic
# results rather than optimistic.
speed = sum(r[0] for r in results) / max(r[1] for r in results)
print("threads=%d: %d" % (nthreads, speed), end="")
if baseline_speed is None:
print(" iterations/s.")
baseline_speed = speed
else:
print(" ( %d %%)" % (speed / baseline_speed * 100))
nthreads += 1
print()
LAT_END = "END"
def _sendto(sock, s, addr):
sock.sendto(s.encode('ascii'), addr)
def _recv(sock, n):
return sock.recv(n).decode('ascii')
def latency_client(addr, nb_pings, interval):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
_time = time.time
_sleep = time.sleep
def _ping():
_sendto(sock, "%r\n" % _time(), addr)
# The first ping signals the parent process that we are ready.
_ping()
# We give the parent a bit of time to notice.
_sleep(1.0)
for i in range(nb_pings):
_sleep(interval)
_ping()
_sendto(sock, LAT_END + "\n", addr)
finally:
sock.close()
def run_latency_client(**kwargs):
cmd_line = [sys.executable, '-E', os.path.abspath(__file__)]
cmd_line.extend(['--latclient', repr(kwargs)])
return subprocess.Popen(cmd_line) #, stdin=subprocess.PIPE,
#stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
def run_latency_test(func, args, nthreads):
# Create a listening socket to receive the pings. We use UDP which should
# be painlessly cross-platform.
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(("127.0.0.1", 0))
addr = sock.getsockname()
interval = LATENCY_PING_INTERVAL
duration = LATENCY_DURATION
nb_pings = int(duration / interval)
results = []
threads = []
end_event = []
start_cond = threading.Condition()
started = False
if nthreads > 0:
# Warm up
func(*args)
results = []
loop = TimedLoop(func, args)
ready = []
ready_cond = threading.Condition()
def run():
with ready_cond:
ready.append(None)
ready_cond.notify()
with start_cond:
while not started:
start_cond.wait()
loop(start_time, duration * 1.5, end_event, do_yield=False)
for i in range(nthreads):
threads.append(threading.Thread(target=run))
for t in threads:
t.setDaemon(True)
t.start()
# Wait for threads to be ready
with ready_cond:
while len(ready) < nthreads:
ready_cond.wait()
# Run the client and wait for the first ping(s) to arrive before
# unblocking the background threads.
chunks = []
process = run_latency_client(addr=sock.getsockname(),
nb_pings=nb_pings, interval=interval)
s = _recv(sock, 4096)
_time = time.time
with start_cond:
start_time = _time()
started = True
start_cond.notify(nthreads)
while LAT_END not in s:
s = _recv(sock, 4096)
t = _time()
chunks.append((t, s))
# Tell the background threads to stop.
end_event.append(None)
for t in threads:
t.join()
process.wait()
sock.close()
for recv_time, chunk in chunks:
# NOTE: it is assumed that a line sent by a client wasn't received
# in two chunks because the lines are very small.
for line in chunk.splitlines():
line = line.strip()
if line and line != LAT_END:
send_time = eval(line)
assert isinstance(send_time, float)
results.append((send_time, recv_time))
return results
def run_latency_tests(max_threads):
for task in latency_tasks:
print("Background CPU task:", task.__doc__)
print()
func, args = task()
nthreads = 0
while nthreads <= max_threads:
results = run_latency_test(func, args, nthreads)
n = len(results)
# We print out milliseconds
lats = [1000 * (t2 - t1) for (t1, t2) in results]
#print(list(map(int, lats)))
avg = sum(lats) / n
dev = (sum((x - avg) ** 2 for x in lats) / n) ** 0.5
print("CPU threads=%d: %d ms. (std dev: %d ms.)" % (nthreads, avg, dev), end="")
print()
#print(" [... from %d samples]" % n)
nthreads += 1
print()
BW_END = "END"
def bandwidth_client(addr, packet_size, duration):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(("127.0.0.1", 0))
local_addr = sock.getsockname()
_time = time.time
_sleep = time.sleep
def _send_chunk(msg):
_sendto(sock, ("%r#%s\n" % (local_addr, msg)).rjust(packet_size), addr)
# We give the parent some time to be ready.
_sleep(1.0)
try:
start_time = _time()
end_time = start_time + duration * 2.0
i = 0
while _time() < end_time:
_send_chunk(str(i))
s = _recv(sock, packet_size)
assert len(s) == packet_size
i += 1
_send_chunk(BW_END)
finally:
sock.close()
def run_bandwidth_client(**kwargs):
cmd_line = [sys.executable, '-E', os.path.abspath(__file__)]
cmd_line.extend(['--bwclient', repr(kwargs)])
return subprocess.Popen(cmd_line) #, stdin=subprocess.PIPE,
#stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
def run_bandwidth_test(func, args, nthreads):
# Create a listening socket to receive the packets. We use UDP which should
# be painlessly cross-platform.
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
sock.bind(("127.0.0.1", 0))
addr = sock.getsockname()
duration = BANDWIDTH_DURATION
packet_size = BANDWIDTH_PACKET_SIZE
results = []
threads = []
end_event = []
start_cond = threading.Condition()
started = False
if nthreads > 0:
# Warm up
func(*args)
results = []
loop = TimedLoop(func, args)
ready = []
ready_cond = threading.Condition()
def run():
with ready_cond:
ready.append(None)
ready_cond.notify()
with start_cond:
while not started:
start_cond.wait()
loop(start_time, duration * 1.5, end_event, do_yield=False)
for i in range(nthreads):
threads.append(threading.Thread(target=run))
for t in threads:
t.setDaemon(True)
t.start()
# Wait for threads to be ready
with ready_cond:
while len(ready) < nthreads:
ready_cond.wait()
# Run the client and wait for the first packet to arrive before
# unblocking the background threads.
process = run_bandwidth_client(addr=addr,
packet_size=packet_size,
duration=duration)
_time = time.time
# This will also wait for the parent to be ready
s = _recv(sock, packet_size)
remote_addr = eval(s.partition('#')[0])
with start_cond:
start_time = _time()
started = True
start_cond.notify(nthreads)
n = 0
first_time = None
while not end_event and BW_END not in s:
_sendto(sock, s, remote_addr)
s = _recv(sock, packet_size)
if first_time is None:
first_time = _time()
n += 1
end_time = _time()
end_event.append(None)
for t in threads:
t.join()
process.kill()
return (n - 1) / (end_time - first_time)
def run_bandwidth_tests(max_threads):
for task in bandwidth_tasks:
print("Background CPU task:", task.__doc__)
print()
func, args = task()
nthreads = 0
baseline_speed = None
while nthreads <= max_threads:
results = run_bandwidth_test(func, args, nthreads)
speed = results
#speed = len(results) * 1.0 / results[-1][0]
print("CPU threads=%d: %.1f" % (nthreads, speed), end="")
if baseline_speed is None:
print(" packets/s.")
baseline_speed = speed
else:
print(" ( %d %%)" % (speed / baseline_speed * 100))
nthreads += 1
print()
def main():
usage = "usage: %prog [-h|--help] [options]"
parser = OptionParser(usage=usage)
parser.add_option("-t", "--throughput",
action="store_true", dest="throughput", default=False,
help="run throughput tests")
parser.add_option("-l", "--latency",
action="store_true", dest="latency", default=False,
help="run latency tests")
parser.add_option("-b", "--bandwidth",
action="store_true", dest="bandwidth", default=False,
help="run I/O bandwidth tests")
parser.add_option("-i", "--interval",
action="store", type="int", dest="check_interval", default=None,
help="sys.setcheckinterval() value")
parser.add_option("-I", "--switch-interval",
action="store", type="float", dest="switch_interval", default=None,
help="sys.setswitchinterval() value")
parser.add_option("-n", "--num-threads",
action="store", type="int", dest="nthreads", default=4,
help="max number of threads in tests")
# Hidden option to run the pinging and bandwidth clients
parser.add_option("", "--latclient",
action="store", dest="latclient", default=None,
help=SUPPRESS_HELP)
parser.add_option("", "--bwclient",
action="store", dest="bwclient", default=None,
help=SUPPRESS_HELP)
options, args = parser.parse_args()
if args:
parser.error("unexpected arguments")
if options.latclient:
kwargs = eval(options.latclient)
latency_client(**kwargs)
return
if options.bwclient:
kwargs = eval(options.bwclient)
bandwidth_client(**kwargs)
return
if not options.throughput and not options.latency and not options.bandwidth:
options.throughput = options.latency = options.bandwidth = True
if options.check_interval:
sys.setcheckinterval(options.check_interval)
if options.switch_interval:
sys.setswitchinterval(options.switch_interval)
print("== %s %s (%s) ==" % (
platform.python_implementation(),
platform.python_version(),
platform.python_build()[0],
))
# Processor identification often has repeated spaces
cpu = ' '.join(platform.processor().split())
print("== %s %s on '%s' ==" % (
platform.machine(),
platform.system(),
cpu,
))
print()
if options.throughput:
print("--- Throughput ---")
print()
run_throughput_tests(options.nthreads)
if options.latency:
print("--- Latency ---")
print()
run_latency_tests(options.nthreads)
if options.bandwidth:
print("--- I/O bandwidth ---")
print()
run_bandwidth_tests(options.nthreads)
if __name__ == "__main__":
main()
| 18,448 | 612 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/stringbench/README | stringbench is a set of performance tests comparing byte string
operations with unicode operations. The two string implementations
are loosely based on each other and sometimes the algorithm for one is
faster than the other.
These test set was started at the Need For Speed sprint in Reykjavik
to identify which string methods could be sped up quickly and to
identify obvious places for improvement.
Here is an example of a benchmark
@bench('"Andrew".startswith("A")', 'startswith single character', 1000)
def startswith_single(STR):
s1 = STR("Andrew")
s2 = STR("A")
s1_startswith = s1.startswith
for x in _RANGE_1000:
s1_startswith(s2)
The bench decorator takes three parameters. The first is a short
description of how the code works. In most cases this is Python code
snippet. It is not the code which is actually run because the real
code is hand-optimized to focus on the method being tested.
The second parameter is a group title. All benchmarks with the same
group title are listed together. This lets you compare different
implementations of the same algorithm, such as "t in s"
vs. "s.find(t)".
The last is a count. Each benchmark loops over the algorithm either
100 or 1000 times, depending on the algorithm performance. The output
time is the time per benchmark call so the reader needs a way to know
how to scale the performance.
These parameters become function attributes.
Here is an example of the output
========== count newlines
38.54 41.60 92.7 ...text.with.2000.newlines.count("\n") (*100)
========== early match, single character
1.14 1.18 96.8 ("A"*1000).find("A") (*1000)
0.44 0.41 105.6 "A" in "A"*1000 (*1000)
1.15 1.17 98.1 ("A"*1000).index("A") (*1000)
The first column is the run time in milliseconds for byte strings.
The second is the run time for unicode strings. The third is a
percentage; byte time / unicode time. It's the percentage by which
unicode is faster than byte strings.
The last column contains the code snippet and the repeat count for the
internal benchmark loop.
The times are computed with 'timeit.py' which repeats the test more
and more times until the total time takes over 0.2 seconds, returning
the best time for a single iteration.
The final line of the output is the cumulative time for byte and
unicode strings, and the overall performance of unicode relative to
bytes. For example
4079.83 5432.25 75.1 TOTAL
However, this has no meaning as it evenly weights every test.
| 2,516 | 69 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/stringbench/stringbench.py |
# Various microbenchmarks comparing unicode and byte string performance
# Please keep this file both 2.x and 3.x compatible!
import timeit
import itertools
import operator
import re
import sys
import datetime
import optparse
VERSION = '2.0'
def p(*args):
sys.stdout.write(' '.join(str(s) for s in args) + '\n')
if sys.version_info >= (3,):
BYTES = bytes_from_str = lambda x: x.encode('ascii')
UNICODE = unicode_from_str = lambda x: x
else:
BYTES = bytes_from_str = lambda x: x
UNICODE = unicode_from_str = lambda x: x.decode('ascii')
class UnsupportedType(TypeError):
pass
p('stringbench v%s' % VERSION)
p(sys.version)
p(datetime.datetime.now())
REPEAT = 1
REPEAT = 3
#REPEAT = 7
if __name__ != "__main__":
raise SystemExit("Must run as main program")
parser = optparse.OptionParser()
parser.add_option("-R", "--skip-re", dest="skip_re",
action="store_true",
help="skip regular expression tests")
parser.add_option("-8", "--8-bit", dest="bytes_only",
action="store_true",
help="only do 8-bit string benchmarks")
parser.add_option("-u", "--unicode", dest="unicode_only",
action="store_true",
help="only do Unicode string benchmarks")
_RANGE_1000 = list(range(1000))
_RANGE_100 = list(range(100))
_RANGE_10 = list(range(10))
dups = {}
def bench(s, group, repeat_count):
def blah(f):
if f.__name__ in dups:
raise AssertionError("Multiple functions with same name: %r" %
(f.__name__,))
dups[f.__name__] = 1
f.comment = s
f.is_bench = True
f.group = group
f.repeat_count = repeat_count
return f
return blah
def uses_re(f):
f.uses_re = True
####### 'in' comparisons
@bench('"A" in "A"*1000', "early match, single character", 1000)
def in_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
for x in _RANGE_1000:
s2 in s1
@bench('"B" in "A"*1000', "no match, single character", 1000)
def in_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
for x in _RANGE_1000:
s2 in s1
@bench('"AB" in "AB"*1000', "early match, two characters", 1000)
def in_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
for x in _RANGE_1000:
s2 in s1
@bench('"BC" in "AB"*1000', "no match, two characters", 1000)
def in_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
for x in _RANGE_1000:
s2 in s1
@bench('"BC" in ("AB"*300+"C")', "late match, two characters", 1000)
def in_test_slow_match_two_characters(STR):
s1 = STR("AB" * 300+"C")
s2 = STR("BC")
for x in _RANGE_1000:
s2 in s1
@bench('s="ABC"*33; (s+"E") in ((s+"D")*300+s+"E")',
"late match, 100 characters", 100)
def in_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*300 + m+e
s2 = m+e
for x in _RANGE_100:
s2 in s1
# Try with regex
@uses_re
@bench('s="ABC"*33; re.compile(s+"D").search((s+"D")*300+s+"E")',
"late match, 100 characters", 100)
def re_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*300 + m+e
s2 = m+e
pat = re.compile(s2)
search = pat.search
for x in _RANGE_100:
search(s1)
#### same tests as 'in' but use 'find'
@bench('("A"*1000).find("A")', "early match, single character", 1000)
def find_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("A"*1000).find("B")', "no match, single character", 1000)
def find_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("AB"*1000).find("AB")', "early match, two characters", 1000)
def find_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("AB"*1000).find("BC")', "no match, two characters", 1000)
def find_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("AB"*1000).find("CA")', "no match, two characters", 1000)
def find_test_no_match_two_character_bis(STR):
s1 = STR("AB" * 1000)
s2 = STR("CA")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("AB"*300+"C").find("BC")', "late match, two characters", 1000)
def find_test_slow_match_two_characters(STR):
s1 = STR("AB" * 300+"C")
s2 = STR("BC")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('("AB"*300+"CA").find("CA")', "late match, two characters", 1000)
def find_test_slow_match_two_characters_bis(STR):
s1 = STR("AB" * 300+"CA")
s2 = STR("CA")
s1_find = s1.find
for x in _RANGE_1000:
s1_find(s2)
@bench('s="ABC"*33; ((s+"D")*500+s+"E").find(s+"E")',
"late match, 100 characters", 100)
def find_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*500 + m+e
s2 = m+e
s1_find = s1.find
for x in _RANGE_100:
s1_find(s2)
@bench('s="ABC"*33; ((s+"D")*500+"E"+s).find("E"+s)',
"late match, 100 characters", 100)
def find_test_slow_match_100_characters_bis(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*500 + e+m
s2 = e+m
s1_find = s1.find
for x in _RANGE_100:
s1_find(s2)
#### Same tests for 'rfind'
@bench('("A"*1000).rfind("A")', "early match, single character", 1000)
def rfind_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("A"*1000).rfind("B")', "no match, single character", 1000)
def rfind_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("AB"*1000).rfind("AB")', "early match, two characters", 1000)
def rfind_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("AB"*1000).rfind("BC")', "no match, two characters", 1000)
def rfind_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("AB"*1000).rfind("CA")', "no match, two characters", 1000)
def rfind_test_no_match_two_character_bis(STR):
s1 = STR("AB" * 1000)
s2 = STR("CA")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("C"+"AB"*300).rfind("CA")', "late match, two characters", 1000)
def rfind_test_slow_match_two_characters(STR):
s1 = STR("C" + "AB" * 300)
s2 = STR("CA")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('("BC"+"AB"*300).rfind("BC")', "late match, two characters", 1000)
def rfind_test_slow_match_two_characters_bis(STR):
s1 = STR("BC" + "AB" * 300)
s2 = STR("BC")
s1_rfind = s1.rfind
for x in _RANGE_1000:
s1_rfind(s2)
@bench('s="ABC"*33; ("E"+s+("D"+s)*500).rfind("E"+s)',
"late match, 100 characters", 100)
def rfind_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = e+m + (d+m)*500
s2 = e+m
s1_rfind = s1.rfind
for x in _RANGE_100:
s1_rfind(s2)
@bench('s="ABC"*33; (s+"E"+("D"+s)*500).rfind(s+"E")',
"late match, 100 characters", 100)
def rfind_test_slow_match_100_characters_bis(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = m+e + (d+m)*500
s2 = m+e
s1_rfind = s1.rfind
for x in _RANGE_100:
s1_rfind(s2)
#### Now with index.
# Skip the ones which fail because that would include exception overhead.
@bench('("A"*1000).index("A")', "early match, single character", 1000)
def index_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_index = s1.index
for x in _RANGE_1000:
s1_index(s2)
@bench('("AB"*1000).index("AB")', "early match, two characters", 1000)
def index_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_index = s1.index
for x in _RANGE_1000:
s1_index(s2)
@bench('("AB"*300+"C").index("BC")', "late match, two characters", 1000)
def index_test_slow_match_two_characters(STR):
s1 = STR("AB" * 300+"C")
s2 = STR("BC")
s1_index = s1.index
for x in _RANGE_1000:
s1_index(s2)
@bench('s="ABC"*33; ((s+"D")*500+s+"E").index(s+"E")',
"late match, 100 characters", 100)
def index_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*500 + m+e
s2 = m+e
s1_index = s1.index
for x in _RANGE_100:
s1_index(s2)
#### Same for rindex
@bench('("A"*1000).rindex("A")', "early match, single character", 1000)
def rindex_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_rindex = s1.rindex
for x in _RANGE_1000:
s1_rindex(s2)
@bench('("AB"*1000).rindex("AB")', "early match, two characters", 1000)
def rindex_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_rindex = s1.rindex
for x in _RANGE_1000:
s1_rindex(s2)
@bench('("C"+"AB"*300).rindex("CA")', "late match, two characters", 1000)
def rindex_test_slow_match_two_characters(STR):
s1 = STR("C" + "AB" * 300)
s2 = STR("CA")
s1_rindex = s1.rindex
for x in _RANGE_1000:
s1_rindex(s2)
@bench('s="ABC"*33; ("E"+s+("D"+s)*500).rindex("E"+s)',
"late match, 100 characters", 100)
def rindex_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = e + m + (d+m)*500
s2 = e + m
s1_rindex = s1.rindex
for x in _RANGE_100:
s1_rindex(s2)
#### Same for partition
@bench('("A"*1000).partition("A")', "early match, single character", 1000)
def partition_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_partition = s1.partition
for x in _RANGE_1000:
s1_partition(s2)
@bench('("A"*1000).partition("B")', "no match, single character", 1000)
def partition_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_partition = s1.partition
for x in _RANGE_1000:
s1_partition(s2)
@bench('("AB"*1000).partition("AB")', "early match, two characters", 1000)
def partition_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_partition = s1.partition
for x in _RANGE_1000:
s1_partition(s2)
@bench('("AB"*1000).partition("BC")', "no match, two characters", 1000)
def partition_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_partition = s1.partition
for x in _RANGE_1000:
s1_partition(s2)
@bench('("AB"*300+"C").partition("BC")', "late match, two characters", 1000)
def partition_test_slow_match_two_characters(STR):
s1 = STR("AB" * 300+"C")
s2 = STR("BC")
s1_partition = s1.partition
for x in _RANGE_1000:
s1_partition(s2)
@bench('s="ABC"*33; ((s+"D")*500+s+"E").partition(s+"E")',
"late match, 100 characters", 100)
def partition_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*500 + m+e
s2 = m+e
s1_partition = s1.partition
for x in _RANGE_100:
s1_partition(s2)
#### Same for rpartition
@bench('("A"*1000).rpartition("A")', "early match, single character", 1000)
def rpartition_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_rpartition = s1.rpartition
for x in _RANGE_1000:
s1_rpartition(s2)
@bench('("A"*1000).rpartition("B")', "no match, single character", 1000)
def rpartition_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_rpartition = s1.rpartition
for x in _RANGE_1000:
s1_rpartition(s2)
@bench('("AB"*1000).rpartition("AB")', "early match, two characters", 1000)
def rpartition_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_rpartition = s1.rpartition
for x in _RANGE_1000:
s1_rpartition(s2)
@bench('("AB"*1000).rpartition("BC")', "no match, two characters", 1000)
def rpartition_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_rpartition = s1.rpartition
for x in _RANGE_1000:
s1_rpartition(s2)
@bench('("C"+"AB"*300).rpartition("CA")', "late match, two characters", 1000)
def rpartition_test_slow_match_two_characters(STR):
s1 = STR("C" + "AB" * 300)
s2 = STR("CA")
s1_rpartition = s1.rpartition
for x in _RANGE_1000:
s1_rpartition(s2)
@bench('s="ABC"*33; ("E"+s+("D"+s)*500).rpartition("E"+s)',
"late match, 100 characters", 100)
def rpartition_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = e + m + (d+m)*500
s2 = e + m
s1_rpartition = s1.rpartition
for x in _RANGE_100:
s1_rpartition(s2)
#### Same for split(s, 1)
@bench('("A"*1000).split("A", 1)', "early match, single character", 1000)
def split_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_split = s1.split
for x in _RANGE_1000:
s1_split(s2, 1)
@bench('("A"*1000).split("B", 1)', "no match, single character", 1000)
def split_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_split = s1.split
for x in _RANGE_1000:
s1_split(s2, 1)
@bench('("AB"*1000).split("AB", 1)', "early match, two characters", 1000)
def split_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_split = s1.split
for x in _RANGE_1000:
s1_split(s2, 1)
@bench('("AB"*1000).split("BC", 1)', "no match, two characters", 1000)
def split_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_split = s1.split
for x in _RANGE_1000:
s1_split(s2, 1)
@bench('("AB"*300+"C").split("BC", 1)', "late match, two characters", 1000)
def split_test_slow_match_two_characters(STR):
s1 = STR("AB" * 300+"C")
s2 = STR("BC")
s1_split = s1.split
for x in _RANGE_1000:
s1_split(s2, 1)
@bench('s="ABC"*33; ((s+"D")*500+s+"E").split(s+"E", 1)',
"late match, 100 characters", 100)
def split_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = (m+d)*500 + m+e
s2 = m+e
s1_split = s1.split
for x in _RANGE_100:
s1_split(s2, 1)
#### Same for rsplit(s, 1)
@bench('("A"*1000).rsplit("A", 1)', "early match, single character", 1000)
def rsplit_test_quick_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("A")
s1_rsplit = s1.rsplit
for x in _RANGE_1000:
s1_rsplit(s2, 1)
@bench('("A"*1000).rsplit("B", 1)', "no match, single character", 1000)
def rsplit_test_no_match_single_character(STR):
s1 = STR("A" * 1000)
s2 = STR("B")
s1_rsplit = s1.rsplit
for x in _RANGE_1000:
s1_rsplit(s2, 1)
@bench('("AB"*1000).rsplit("AB", 1)', "early match, two characters", 1000)
def rsplit_test_quick_match_two_characters(STR):
s1 = STR("AB" * 1000)
s2 = STR("AB")
s1_rsplit = s1.rsplit
for x in _RANGE_1000:
s1_rsplit(s2, 1)
@bench('("AB"*1000).rsplit("BC", 1)', "no match, two characters", 1000)
def rsplit_test_no_match_two_character(STR):
s1 = STR("AB" * 1000)
s2 = STR("BC")
s1_rsplit = s1.rsplit
for x in _RANGE_1000:
s1_rsplit(s2, 1)
@bench('("C"+"AB"*300).rsplit("CA", 1)', "late match, two characters", 1000)
def rsplit_test_slow_match_two_characters(STR):
s1 = STR("C" + "AB" * 300)
s2 = STR("CA")
s1_rsplit = s1.rsplit
for x in _RANGE_1000:
s1_rsplit(s2, 1)
@bench('s="ABC"*33; ("E"+s+("D"+s)*500).rsplit("E"+s, 1)',
"late match, 100 characters", 100)
def rsplit_test_slow_match_100_characters(STR):
m = STR("ABC"*33)
d = STR("D")
e = STR("E")
s1 = e + m + (d+m)*500
s2 = e + m
s1_rsplit = s1.rsplit
for x in _RANGE_100:
s1_rsplit(s2, 1)
#### Benchmark the operator-based methods
@bench('"A"*10', "repeat 1 character 10 times", 1000)
def repeat_single_10_times(STR):
s = STR("A")
for x in _RANGE_1000:
s * 10
@bench('"A"*1000', "repeat 1 character 1000 times", 1000)
def repeat_single_1000_times(STR):
s = STR("A")
for x in _RANGE_1000:
s * 1000
@bench('"ABCDE"*10', "repeat 5 characters 10 times", 1000)
def repeat_5_10_times(STR):
s = STR("ABCDE")
for x in _RANGE_1000:
s * 10
@bench('"ABCDE"*1000', "repeat 5 characters 1000 times", 1000)
def repeat_5_1000_times(STR):
s = STR("ABCDE")
for x in _RANGE_1000:
s * 1000
# + for concat
@bench('"Andrew"+"Dalke"', "concat two strings", 1000)
def concat_two_strings(STR):
s1 = STR("Andrew")
s2 = STR("Dalke")
for x in _RANGE_1000:
s1+s2
@bench('s1+s2+s3+s4+...+s20', "concat 20 strings of words length 4 to 15",
1000)
def concat_many_strings(STR):
s1=STR('TIXSGYNREDCVBHJ')
s2=STR('PUMTLXBZVDO')
s3=STR('FVZNJ')
s4=STR('OGDXUW')
s5=STR('WEIMRNCOYVGHKB')
s6=STR('FCQTNMXPUZH')
s7=STR('TICZJYRLBNVUEAK')
s8=STR('REYB')
s9=STR('PWUOQ')
s10=STR('EQHCMKBS')
s11=STR('AEVDFOH')
s12=STR('IFHVD')
s13=STR('JGTCNLXWOHQ')
s14=STR('ITSKEPYLROZAWXF')
s15=STR('THEK')
s16=STR('GHPZFBUYCKMNJIT')
s17=STR('JMUZ')
s18=STR('WLZQMTB')
s19=STR('KPADCBW')
s20=STR('TNJHZQAGBU')
for x in _RANGE_1000:
(s1 + s2+ s3+ s4+ s5+ s6+ s7+ s8+ s9+s10+
s11+s12+s13+s14+s15+s16+s17+s18+s19+s20)
#### Benchmark join
def get_bytes_yielding_seq(STR, arg):
if STR is BYTES and sys.version_info >= (3,):
raise UnsupportedType
return STR(arg)
@bench('"A".join("")',
"join empty string, with 1 character sep", 100)
def join_empty_single(STR):
sep = STR("A")
s2 = get_bytes_yielding_seq(STR, "")
sep_join = sep.join
for x in _RANGE_100:
sep_join(s2)
@bench('"ABCDE".join("")',
"join empty string, with 5 character sep", 100)
def join_empty_5(STR):
sep = STR("ABCDE")
s2 = get_bytes_yielding_seq(STR, "")
sep_join = sep.join
for x in _RANGE_100:
sep_join(s2)
@bench('"A".join("ABC..Z")',
"join string with 26 characters, with 1 character sep", 1000)
def join_alphabet_single(STR):
sep = STR("A")
s2 = get_bytes_yielding_seq(STR, "ABCDEFGHIJKLMnOPQRSTUVWXYZ")
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
@bench('"ABCDE".join("ABC..Z")',
"join string with 26 characters, with 5 character sep", 1000)
def join_alphabet_5(STR):
sep = STR("ABCDE")
s2 = get_bytes_yielding_seq(STR, "ABCDEFGHIJKLMnOPQRSTUVWXYZ")
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
@bench('"A".join(list("ABC..Z"))',
"join list of 26 characters, with 1 character sep", 1000)
def join_alphabet_list_single(STR):
sep = STR("A")
s2 = [STR(x) for x in "ABCDEFGHIJKLMnOPQRSTUVWXYZ"]
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
@bench('"ABCDE".join(list("ABC..Z"))',
"join list of 26 characters, with 5 character sep", 1000)
def join_alphabet_list_five(STR):
sep = STR("ABCDE")
s2 = [STR(x) for x in "ABCDEFGHIJKLMnOPQRSTUVWXYZ"]
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
@bench('"A".join(["Bob"]*100))',
"join list of 100 words, with 1 character sep", 1000)
def join_100_words_single(STR):
sep = STR("A")
s2 = [STR("Bob")]*100
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
@bench('"ABCDE".join(["Bob"]*100))',
"join list of 100 words, with 5 character sep", 1000)
def join_100_words_5(STR):
sep = STR("ABCDE")
s2 = [STR("Bob")]*100
sep_join = sep.join
for x in _RANGE_1000:
sep_join(s2)
#### split tests
@bench('("Here are some words. "*2).split()', "split whitespace (small)", 1000)
def whitespace_split(STR):
s = STR("Here are some words. "*2)
s_split = s.split
for x in _RANGE_1000:
s_split()
@bench('("Here are some words. "*2).rsplit()', "split whitespace (small)", 1000)
def whitespace_rsplit(STR):
s = STR("Here are some words. "*2)
s_rsplit = s.rsplit
for x in _RANGE_1000:
s_rsplit()
@bench('("Here are some words. "*2).split(None, 1)',
"split 1 whitespace", 1000)
def whitespace_split_1(STR):
s = STR("Here are some words. "*2)
s_split = s.split
N = None
for x in _RANGE_1000:
s_split(N, 1)
@bench('("Here are some words. "*2).rsplit(None, 1)',
"split 1 whitespace", 1000)
def whitespace_rsplit_1(STR):
s = STR("Here are some words. "*2)
s_rsplit = s.rsplit
N = None
for x in _RANGE_1000:
s_rsplit(N, 1)
@bench('("Here are some words. "*2).partition(" ")',
"split 1 whitespace", 1000)
def whitespace_partition(STR):
sep = STR(" ")
s = STR("Here are some words. "*2)
s_partition = s.partition
for x in _RANGE_1000:
s_partition(sep)
@bench('("Here are some words. "*2).rpartition(" ")',
"split 1 whitespace", 1000)
def whitespace_rpartition(STR):
sep = STR(" ")
s = STR("Here are some words. "*2)
s_rpartition = s.rpartition
for x in _RANGE_1000:
s_rpartition(sep)
human_text = """\
Python is a dynamic object-oriented programming language that can be
used for many kinds of software development. It offers strong support
for integration with other languages and tools, comes with extensive
standard libraries, and can be learned in a few days. Many Python
programmers report substantial productivity gains and feel the language
encourages the development of higher quality, more maintainable code.
Python runs on Windows, Linux/Unix, Mac OS X, Amiga, Palm
Handhelds, and Nokia mobile phones. Python has also been ported to the
Java and .NET virtual machines.
Python is distributed under an OSI-approved open source license that
makes it free to use, even for commercial products.
"""*25
human_text_bytes = bytes_from_str(human_text)
human_text_unicode = unicode_from_str(human_text)
def _get_human_text(STR):
if STR is UNICODE:
return human_text_unicode
if STR is BYTES:
return human_text_bytes
raise AssertionError
@bench('human_text.split()', "split whitespace (huge)", 10)
def whitespace_split_huge(STR):
s = _get_human_text(STR)
s_split = s.split
for x in _RANGE_10:
s_split()
@bench('human_text.rsplit()', "split whitespace (huge)", 10)
def whitespace_rsplit_huge(STR):
s = _get_human_text(STR)
s_rsplit = s.rsplit
for x in _RANGE_10:
s_rsplit()
@bench('"this\\nis\\na\\ntest\\n".split("\\n")', "split newlines", 1000)
def newlines_split(STR):
s = STR("this\nis\na\ntest\n")
s_split = s.split
nl = STR("\n")
for x in _RANGE_1000:
s_split(nl)
@bench('"this\\nis\\na\\ntest\\n".rsplit("\\n")', "split newlines", 1000)
def newlines_rsplit(STR):
s = STR("this\nis\na\ntest\n")
s_rsplit = s.rsplit
nl = STR("\n")
for x in _RANGE_1000:
s_rsplit(nl)
@bench('"this\\nis\\na\\ntest\\n".splitlines()', "split newlines", 1000)
def newlines_splitlines(STR):
s = STR("this\nis\na\ntest\n")
s_splitlines = s.splitlines
for x in _RANGE_1000:
s_splitlines()
## split text with 2000 newlines
def _make_2000_lines():
import random
r = random.Random(100)
chars = list(map(chr, range(32, 128)))
i = 0
while i < len(chars):
chars[i] = " "
i += r.randrange(9)
s = "".join(chars)
s = s*4
words = []
for i in range(2000):
start = r.randrange(96)
n = r.randint(5, 65)
words.append(s[start:start+n])
return "\n".join(words)+"\n"
_text_with_2000_lines = _make_2000_lines()
_text_with_2000_lines_bytes = bytes_from_str(_text_with_2000_lines)
_text_with_2000_lines_unicode = unicode_from_str(_text_with_2000_lines)
def _get_2000_lines(STR):
if STR is UNICODE:
return _text_with_2000_lines_unicode
if STR is BYTES:
return _text_with_2000_lines_bytes
raise AssertionError
@bench('"...text...".split("\\n")', "split 2000 newlines", 10)
def newlines_split_2000(STR):
s = _get_2000_lines(STR)
s_split = s.split
nl = STR("\n")
for x in _RANGE_10:
s_split(nl)
@bench('"...text...".rsplit("\\n")', "split 2000 newlines", 10)
def newlines_rsplit_2000(STR):
s = _get_2000_lines(STR)
s_rsplit = s.rsplit
nl = STR("\n")
for x in _RANGE_10:
s_rsplit(nl)
@bench('"...text...".splitlines()', "split 2000 newlines", 10)
def newlines_splitlines_2000(STR):
s = _get_2000_lines(STR)
s_splitlines = s.splitlines
for x in _RANGE_10:
s_splitlines()
## split text on "--" characters
@bench(
'"this--is--a--test--of--the--emergency--broadcast--system".split("--")',
"split on multicharacter separator (small)", 1000)
def split_multichar_sep_small(STR):
s = STR("this--is--a--test--of--the--emergency--broadcast--system")
s_split = s.split
pat = STR("--")
for x in _RANGE_1000:
s_split(pat)
@bench(
'"this--is--a--test--of--the--emergency--broadcast--system".rsplit("--")',
"split on multicharacter separator (small)", 1000)
def rsplit_multichar_sep_small(STR):
s = STR("this--is--a--test--of--the--emergency--broadcast--system")
s_rsplit = s.rsplit
pat = STR("--")
for x in _RANGE_1000:
s_rsplit(pat)
## split dna text on "ACTAT" characters
@bench('dna.split("ACTAT")',
"split on multicharacter separator (dna)", 10)
def split_multichar_sep_dna(STR):
s = _get_dna(STR)
s_split = s.split
pat = STR("ACTAT")
for x in _RANGE_10:
s_split(pat)
@bench('dna.rsplit("ACTAT")',
"split on multicharacter separator (dna)", 10)
def rsplit_multichar_sep_dna(STR):
s = _get_dna(STR)
s_rsplit = s.rsplit
pat = STR("ACTAT")
for x in _RANGE_10:
s_rsplit(pat)
## split with limits
GFF3_example = "\t".join([
"I", "Genomic_canonical", "region", "357208", "396183", ".", "+", ".",
"ID=Sequence:R119;note=Clone R119%3B Genbank AF063007;Name=R119"])
@bench('GFF3_example.split("\\t")', "tab split", 1000)
def tab_split_no_limit(STR):
sep = STR("\t")
s = STR(GFF3_example)
s_split = s.split
for x in _RANGE_1000:
s_split(sep)
@bench('GFF3_example.split("\\t", 8)', "tab split", 1000)
def tab_split_limit(STR):
sep = STR("\t")
s = STR(GFF3_example)
s_split = s.split
for x in _RANGE_1000:
s_split(sep, 8)
@bench('GFF3_example.rsplit("\\t")', "tab split", 1000)
def tab_rsplit_no_limit(STR):
sep = STR("\t")
s = STR(GFF3_example)
s_rsplit = s.rsplit
for x in _RANGE_1000:
s_rsplit(sep)
@bench('GFF3_example.rsplit("\\t", 8)', "tab split", 1000)
def tab_rsplit_limit(STR):
sep = STR("\t")
s = STR(GFF3_example)
s_rsplit = s.rsplit
for x in _RANGE_1000:
s_rsplit(sep, 8)
#### Count characters
@bench('...text.with.2000.newlines.count("\\n")',
"count newlines", 10)
def count_newlines(STR):
s = _get_2000_lines(STR)
s_count = s.count
nl = STR("\n")
for x in _RANGE_10:
s_count(nl)
# Orchid sequences concatenated, from Biopython
_dna = """
CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGGGTT
AATCTGGAGGATCTGTTTACTTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGAATTGCCATCG
AGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGCAGTTTTGCTCCAAGTCGTT
TGACACATAATTGGTGAAGGGGGTGGCATCCTTCCCTGACCCTCCCCCAACTATTTTTTTAACAACTCTC
AGCAACGGAGACTCAGTCTTCGGCAAATGCGATAAATGGTGTGAATTGCAGAATCCCGTGCACCATCGAG
TCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCATTGCGAGTCATAT
CTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCGGATGTGAGTTTGGCCCCTTGTTCTT
TGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAGGTGGACGAACTAT
GCTACAACAAAATTGTTGTGCAGAGGCCCCGGGTTGTCGTATTAGATGGGCCACCGTAATCTGAAGACCC
TTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGCGACCCCAGGTCAG
GTGAGCAACAGCTGTCGTAACAAGGTTTCCGTAGGGTGAACTGCGGAAGGATCATTGTTGAGATCACATA
ATAATTGATCGAGTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGAC
CTAGATTTGCCATCGAGCCTCCTTGGGAGCATCCTTGTTGGCGATATCTAAACCCTCAATTTTTCCCCCA
ATCAAATTACACAAAATTGGTGGAGGGGGTGGCATTCTTCCCTTACCCTCCCCCAAATATTTTTTTAACA
ACTCTCAGCAACGGATATCTCAGCTCTTGCATCGATGAAGAACCCACCGAAATGCGATAAATGGTGTGAA
TTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACG
CCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCG
GATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGATGCATGGGCTTTTGATGGTCCTAA
ATACGGCAAGAGGTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATAAG
ATGGGCCACCGATATCTGAAGACCCTTTTGGACCCCATTGGAGCCCATCAACCCATGTCAGTTGATGGCC
ATTCGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGA
GTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCA
TCGAGCCTCCTTGGGAGCTTTCTTGTTGGCGATATCTAAACCCTTGCCCGGCAGAGTTTTGGGAATCCCG
TGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCAT
TGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACACACCTGTTCAGCCGGTGCGGATGTGAGTTTG
GCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAG
GTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATTAGATGGGCCACCAT
AATCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGC
GACCCAGTCAGGTGAGGGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGAG
TTAATCTGGAGGATCTGTTTACTTTGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCAT
CGAGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTTGGCGCCAAGTCA
TATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAACAACTC
TCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGAATTGC
AGAATCCCGTGAACCATCGAGTCTTTGGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCT
GCCTGGGCATTGGGAATCATATCTCTCCCCTAACGAGGCTATCCAAACATACTGTTCATCCGGTGCGGAT
GTGAGTTTGGCCCCTTGTTCTTTGGTACCGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTCAAAA
CGGCAAGAGGTGGACGAACTATGCCACAACAAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTAGATG
GGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGACCA
TTTGTTGCGACCCCAGTCAGCTGAGCAACCCGCTGAGTGGAAGGTCATTGCCGATATCACATAATAATTG
ATCGAGTTAATCTGGAGGATCTGTTTACTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGATTT
GCCATCGAGCCTCCTTGGGAGTTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTGTGCGCCA
AGTCATATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAAC
AACTCTCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGA
ATTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCAC
GCCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCATCCGGTGC
GGATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTC
AAAACGGCAAGAGGTGGACGAACTATGCTACAACCAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTA
GATGGGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATG
ACCATGTGTTGCGACCCCAGTCAGCTGAGCAACGCGCTGAGCGTAACAAGGTTTCCGTAGGTGGACCTCC
GGGAGGATCATTGTTGAGATCACATAATAATTGATCGAGGTAATCTGGAGGATCTGCATATTTTGGTCAC
"""
_dna = "".join(_dna.splitlines())
_dna = _dna * 25
_dna_bytes = bytes_from_str(_dna)
_dna_unicode = unicode_from_str(_dna)
def _get_dna(STR):
if STR is UNICODE:
return _dna_unicode
if STR is BYTES:
return _dna_bytes
raise AssertionError
@bench('dna.count("AACT")', "count AACT substrings in DNA example", 10)
def count_aact(STR):
seq = _get_dna(STR)
seq_count = seq.count
needle = STR("AACT")
for x in _RANGE_10:
seq_count(needle)
##### startswith and endswith
@bench('"Andrew".startswith("A")', 'startswith single character', 1000)
def startswith_single(STR):
s1 = STR("Andrew")
s2 = STR("A")
s1_startswith = s1.startswith
for x in _RANGE_1000:
s1_startswith(s2)
@bench('"Andrew".startswith("Andrew")', 'startswith multiple characters',
1000)
def startswith_multiple(STR):
s1 = STR("Andrew")
s2 = STR("Andrew")
s1_startswith = s1.startswith
for x in _RANGE_1000:
s1_startswith(s2)
@bench('"Andrew".startswith("Anders")',
'startswith multiple characters - not!', 1000)
def startswith_multiple_not(STR):
s1 = STR("Andrew")
s2 = STR("Anders")
s1_startswith = s1.startswith
for x in _RANGE_1000:
s1_startswith(s2)
# endswith
@bench('"Andrew".endswith("w")', 'endswith single character', 1000)
def endswith_single(STR):
s1 = STR("Andrew")
s2 = STR("w")
s1_endswith = s1.endswith
for x in _RANGE_1000:
s1_endswith(s2)
@bench('"Andrew".endswith("Andrew")', 'endswith multiple characters', 1000)
def endswith_multiple(STR):
s1 = STR("Andrew")
s2 = STR("Andrew")
s1_endswith = s1.endswith
for x in _RANGE_1000:
s1_endswith(s2)
@bench('"Andrew".endswith("Anders")',
'endswith multiple characters - not!', 1000)
def endswith_multiple_not(STR):
s1 = STR("Andrew")
s2 = STR("Anders")
s1_endswith = s1.endswith
for x in _RANGE_1000:
s1_endswith(s2)
#### Strip
@bench('"Hello!\\n".strip()', 'strip terminal newline', 1000)
def terminal_newline_strip_right(STR):
s = STR("Hello!\n")
s_strip = s.strip
for x in _RANGE_1000:
s_strip()
@bench('"Hello!\\n".rstrip()', 'strip terminal newline', 1000)
def terminal_newline_rstrip(STR):
s = STR("Hello!\n")
s_rstrip = s.rstrip
for x in _RANGE_1000:
s_rstrip()
@bench('"\\nHello!".strip()', 'strip terminal newline', 1000)
def terminal_newline_strip_left(STR):
s = STR("\nHello!")
s_strip = s.strip
for x in _RANGE_1000:
s_strip()
@bench('"\\nHello!\\n".strip()', 'strip terminal newline', 1000)
def terminal_newline_strip_both(STR):
s = STR("\nHello!\n")
s_strip = s.strip
for x in _RANGE_1000:
s_strip()
@bench('"\\nHello!".rstrip()', 'strip terminal newline', 1000)
def terminal_newline_lstrip(STR):
s = STR("\nHello!")
s_lstrip = s.lstrip
for x in _RANGE_1000:
s_lstrip()
@bench('s="Hello!\\n"; s[:-1] if s[-1]=="\\n" else s',
'strip terminal newline', 1000)
def terminal_newline_if_else(STR):
s = STR("Hello!\n")
NL = STR("\n")
for x in _RANGE_1000:
s[:-1] if (s[-1] == NL) else s
# Strip multiple spaces or tabs
@bench('"Hello\\t \\t".strip()', 'strip terminal spaces and tabs', 1000)
def terminal_space_strip(STR):
s = STR("Hello\t \t!")
s_strip = s.strip
for x in _RANGE_1000:
s_strip()
@bench('"Hello\\t \\t".rstrip()', 'strip terminal spaces and tabs', 1000)
def terminal_space_rstrip(STR):
s = STR("Hello!\t \t")
s_rstrip = s.rstrip
for x in _RANGE_1000:
s_rstrip()
@bench('"\\t \\tHello".rstrip()', 'strip terminal spaces and tabs', 1000)
def terminal_space_lstrip(STR):
s = STR("\t \tHello!")
s_lstrip = s.lstrip
for x in _RANGE_1000:
s_lstrip()
#### replace
@bench('"This is a test".replace(" ", "\\t")', 'replace single character',
1000)
def replace_single_character(STR):
s = STR("This is a test!")
from_str = STR(" ")
to_str = STR("\t")
s_replace = s.replace
for x in _RANGE_1000:
s_replace(from_str, to_str)
@uses_re
@bench('re.sub(" ", "\\t", "This is a test"', 'replace single character',
1000)
def replace_single_character_re(STR):
s = STR("This is a test!")
pat = re.compile(STR(" "))
to_str = STR("\t")
pat_sub = pat.sub
for x in _RANGE_1000:
pat_sub(to_str, s)
@bench('"...text.with.2000.lines...replace("\\n", " ")',
'replace single character, big string', 10)
def replace_single_character_big(STR):
s = _get_2000_lines(STR)
from_str = STR("\n")
to_str = STR(" ")
s_replace = s.replace
for x in _RANGE_10:
s_replace(from_str, to_str)
@uses_re
@bench('re.sub("\\n", " ", "...text.with.2000.lines...")',
'replace single character, big string', 10)
def replace_single_character_big_re(STR):
s = _get_2000_lines(STR)
pat = re.compile(STR("\n"))
to_str = STR(" ")
pat_sub = pat.sub
for x in _RANGE_10:
pat_sub(to_str, s)
@bench('dna.replace("ATC", "ATT")',
'replace multiple characters, dna', 10)
def replace_multiple_characters_dna(STR):
seq = _get_dna(STR)
from_str = STR("ATC")
to_str = STR("ATT")
seq_replace = seq.replace
for x in _RANGE_10:
seq_replace(from_str, to_str)
# This increases the character count
@bench('"...text.with.2000.newlines...replace("\\n", "\\r\\n")',
'replace and expand multiple characters, big string', 10)
def replace_multiple_character_big(STR):
s = _get_2000_lines(STR)
from_str = STR("\n")
to_str = STR("\r\n")
s_replace = s.replace
for x in _RANGE_10:
s_replace(from_str, to_str)
# This decreases the character count
@bench('"When shall we three meet again?".replace("ee", "")',
'replace/remove multiple characters', 1000)
def replace_multiple_character_remove(STR):
s = STR("When shall we three meet again?")
from_str = STR("ee")
to_str = STR("")
s_replace = s.replace
for x in _RANGE_1000:
s_replace(from_str, to_str)
big_s = "A" + ("Z"*128*1024)
big_s_bytes = bytes_from_str(big_s)
big_s_unicode = unicode_from_str(big_s)
def _get_big_s(STR):
if STR is UNICODE: return big_s_unicode
if STR is BYTES: return big_s_bytes
raise AssertionError
# The older replace implementation counted all matches in
# the string even when it only needed to make one replacement.
@bench('("A" + ("Z"*128*1024)).replace("A", "BB", 1)',
'quick replace single character match', 10)
def quick_replace_single_match(STR):
s = _get_big_s(STR)
from_str = STR("A")
to_str = STR("BB")
s_replace = s.replace
for x in _RANGE_10:
s_replace(from_str, to_str, 1)
@bench('("A" + ("Z"*128*1024)).replace("AZZ", "BBZZ", 1)',
'quick replace multiple character match', 10)
def quick_replace_multiple_match(STR):
s = _get_big_s(STR)
from_str = STR("AZZ")
to_str = STR("BBZZ")
s_replace = s.replace
for x in _RANGE_10:
s_replace(from_str, to_str, 1)
####
# CCP does a lot of this, for internationalisation of ingame messages.
_format = "The %(thing)s is %(place)s the %(location)s."
_format_dict = { "thing":"THING", "place":"PLACE", "location":"LOCATION", }
_format_bytes = bytes_from_str(_format)
_format_unicode = unicode_from_str(_format)
_format_dict_bytes = dict((bytes_from_str(k), bytes_from_str(v)) for (k,v) in _format_dict.items())
_format_dict_unicode = dict((unicode_from_str(k), unicode_from_str(v)) for (k,v) in _format_dict.items())
def _get_format(STR):
if STR is UNICODE:
return _format_unicode
if STR is BYTES:
if sys.version_info >= (3,):
raise UnsupportedType
return _format_bytes
raise AssertionError
def _get_format_dict(STR):
if STR is UNICODE:
return _format_dict_unicode
if STR is BYTES:
if sys.version_info >= (3,):
raise UnsupportedType
return _format_dict_bytes
raise AssertionError
# Formatting.
@bench('"The %(k1)s is %(k2)s the %(k3)s."%{"k1":"x","k2":"y","k3":"z",}',
'formatting a string type with a dict', 1000)
def format_with_dict(STR):
s = _get_format(STR)
d = _get_format_dict(STR)
for x in _RANGE_1000:
s % d
#### Upper- and lower- case conversion
@bench('("Where in the world is Carmen San Deigo?"*10).lower()',
"case conversion -- rare", 1000)
def lower_conversion_rare(STR):
s = STR("Where in the world is Carmen San Deigo?"*10)
s_lower = s.lower
for x in _RANGE_1000:
s_lower()
@bench('("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10).lower()',
"case conversion -- dense", 1000)
def lower_conversion_dense(STR):
s = STR("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10)
s_lower = s.lower
for x in _RANGE_1000:
s_lower()
@bench('("wHERE IN THE WORLD IS cARMEN sAN dEIGO?"*10).upper()',
"case conversion -- rare", 1000)
def upper_conversion_rare(STR):
s = STR("Where in the world is Carmen San Deigo?"*10)
s_upper = s.upper
for x in _RANGE_1000:
s_upper()
@bench('("where in the world is carmen san deigo?"*10).upper()',
"case conversion -- dense", 1000)
def upper_conversion_dense(STR):
s = STR("where in the world is carmen san deigo?"*10)
s_upper = s.upper
for x in _RANGE_1000:
s_upper()
# end of benchmarks
#################
class BenchTimer(timeit.Timer):
def best(self, repeat=1):
for i in range(1, 10):
number = 10**i
x = self.timeit(number)
if x > 0.02:
break
times = [x]
for i in range(1, repeat):
times.append(self.timeit(number))
return min(times) / number
def main():
(options, test_names) = parser.parse_args()
if options.bytes_only and options.unicode_only:
raise SystemExit("Only one of --8-bit and --unicode are allowed")
bench_functions = []
for (k,v) in globals().items():
if hasattr(v, "is_bench"):
if test_names:
for name in test_names:
if name in v.group:
break
else:
# Not selected, ignore
continue
if options.skip_re and hasattr(v, "uses_re"):
continue
bench_functions.append( (v.group, k, v) )
bench_functions.sort()
p("bytes\tunicode")
p("(in ms)\t(in ms)\t%\tcomment")
bytes_total = uni_total = 0.0
for title, group in itertools.groupby(bench_functions,
operator.itemgetter(0)):
# Flush buffer before each group
sys.stdout.flush()
p("="*10, title)
for (_, k, v) in group:
if hasattr(v, "is_bench"):
bytes_time = 0.0
bytes_time_s = " - "
if not options.unicode_only:
try:
bytes_time = BenchTimer("__main__.%s(__main__.BYTES)" % (k,),
"import __main__").best(REPEAT)
bytes_time_s = "%.2f" % (1000 * bytes_time)
bytes_total += bytes_time
except UnsupportedType:
bytes_time_s = "N/A"
uni_time = 0.0
uni_time_s = " - "
if not options.bytes_only:
try:
uni_time = BenchTimer("__main__.%s(__main__.UNICODE)" % (k,),
"import __main__").best(REPEAT)
uni_time_s = "%.2f" % (1000 * uni_time)
uni_total += uni_time
except UnsupportedType:
uni_time_s = "N/A"
try:
average = bytes_time/uni_time
except (TypeError, ZeroDivisionError):
average = 0.0
p("%s\t%s\t%.1f\t%s (*%d)" % (
bytes_time_s, uni_time_s, 100.*average,
v.comment, v.repeat_count))
if bytes_total == uni_total == 0.0:
p("That was zippy!")
else:
try:
ratio = bytes_total/uni_total
except ZeroDivisionError:
ratio = 0.0
p("%.2f\t%.2f\t%.1f\t%s" % (
1000*bytes_total, 1000*uni_total, 100.*ratio,
"TOTAL"))
if __name__ == "__main__":
main()
| 44,018 | 1,483 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/google.py | #! /usr/bin/env python3
import sys, webbrowser
def main():
args = sys.argv[1:]
if not args:
print("Usage: %s querystring" % sys.argv[0])
return
list = []
for arg in args:
if '+' in arg:
arg = arg.replace('+', '%2B')
if ' ' in arg:
arg = '"%s"' % arg
arg = arg.replace(' ', '+')
list.append(arg)
s = '+'.join(list)
url = "http://www.google.com/search?q=%s" % s
webbrowser.open(url)
if __name__ == '__main__':
main()
| 522 | 24 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/highlight.py | #!/usr/bin/env python3
'''Add syntax highlighting to Python source code'''
__author__ = 'Raymond Hettinger'
import builtins
import functools
import html as html_module
import keyword
import re
import tokenize
#### Analyze Python Source #################################
def is_builtin(s):
'Return True if s is the name of a builtin'
return hasattr(builtins, s)
def combine_range(lines, start, end):
'Join content from a range of lines between start and end'
(srow, scol), (erow, ecol) = start, end
if srow == erow:
return lines[srow-1][scol:ecol], end
rows = [lines[srow-1][scol:]] + lines[srow: erow-1] + [lines[erow-1][:ecol]]
return ''.join(rows), end
def analyze_python(source):
'''Generate and classify chunks of Python for syntax highlighting.
Yields tuples in the form: (category, categorized_text).
'''
lines = source.splitlines(True)
lines.append('')
readline = functools.partial(next, iter(lines), '')
kind = tok_str = ''
tok_type = tokenize.COMMENT
written = (1, 0)
for tok in tokenize.generate_tokens(readline):
prev_tok_type, prev_tok_str = tok_type, tok_str
tok_type, tok_str, (srow, scol), (erow, ecol), logical_lineno = tok
kind = ''
if tok_type == tokenize.COMMENT:
kind = 'comment'
elif tok_type == tokenize.OP and tok_str[:1] not in '{}[](),.:;@':
kind = 'operator'
elif tok_type == tokenize.STRING:
kind = 'string'
if prev_tok_type == tokenize.INDENT or scol==0:
kind = 'docstring'
elif tok_type == tokenize.NAME:
if tok_str in ('def', 'class', 'import', 'from'):
kind = 'definition'
elif prev_tok_str in ('def', 'class'):
kind = 'defname'
elif keyword.iskeyword(tok_str):
kind = 'keyword'
elif is_builtin(tok_str) and prev_tok_str != '.':
kind = 'builtin'
if kind:
text, written = combine_range(lines, written, (srow, scol))
yield '', text
text, written = tok_str, (erow, ecol)
yield kind, text
line_upto_token, written = combine_range(lines, written, (erow, ecol))
yield '', line_upto_token
#### Raw Output ###########################################
def raw_highlight(classified_text):
'Straight text display of text classifications'
result = []
for kind, text in classified_text:
result.append('%15s: %r\n' % (kind or 'plain', text))
return ''.join(result)
#### ANSI Output ###########################################
default_ansi = {
'comment': ('\033[0;31m', '\033[0m'),
'string': ('\033[0;32m', '\033[0m'),
'docstring': ('\033[0;32m', '\033[0m'),
'keyword': ('\033[0;33m', '\033[0m'),
'builtin': ('\033[0;35m', '\033[0m'),
'definition': ('\033[0;33m', '\033[0m'),
'defname': ('\033[0;34m', '\033[0m'),
'operator': ('\033[0;33m', '\033[0m'),
}
def ansi_highlight(classified_text, colors=default_ansi):
'Add syntax highlighting to source code using ANSI escape sequences'
# http://en.wikipedia.org/wiki/ANSI_escape_code
result = []
for kind, text in classified_text:
opener, closer = colors.get(kind, ('', ''))
result += [opener, text, closer]
return ''.join(result)
#### HTML Output ###########################################
def html_highlight(classified_text,opener='<pre class="python">\n', closer='</pre>\n'):
'Convert classified text to an HTML fragment'
result = [opener]
for kind, text in classified_text:
if kind:
result.append('<span class="%s">' % kind)
result.append(html_module.escape(text))
if kind:
result.append('</span>')
result.append(closer)
return ''.join(result)
default_css = {
'.comment': '{color: crimson;}',
'.string': '{color: forestgreen;}',
'.docstring': '{color: forestgreen; font-style:italic;}',
'.keyword': '{color: darkorange;}',
'.builtin': '{color: purple;}',
'.definition': '{color: darkorange; font-weight:bold;}',
'.defname': '{color: blue;}',
'.operator': '{color: brown;}',
}
default_html = '''\
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
<title> {title} </title>
<style type="text/css">
{css}
</style>
</head>
<body>
{body}
</body>
</html>
'''
def build_html_page(classified_text, title='python',
css=default_css, html=default_html):
'Create a complete HTML page with colorized source code'
css_str = '\n'.join(['%s %s' % item for item in css.items()])
result = html_highlight(classified_text)
title = html_module.escape(title)
return html.format(title=title, css=css_str, body=result)
#### LaTeX Output ##########################################
default_latex_commands = {
'comment': r'{\color{red}#1}',
'string': r'{\color{ForestGreen}#1}',
'docstring': r'{\emph{\color{ForestGreen}#1}}',
'keyword': r'{\color{orange}#1}',
'builtin': r'{\color{purple}#1}',
'definition': r'{\color{orange}#1}',
'defname': r'{\color{blue}#1}',
'operator': r'{\color{brown}#1}',
}
default_latex_document = r'''
\documentclass{article}
\usepackage{alltt}
\usepackage{upquote}
\usepackage{color}
\usepackage[usenames,dvipsnames]{xcolor}
\usepackage[cm]{fullpage}
%(macros)s
\begin{document}
\center{\LARGE{%(title)s}}
\begin{alltt}
%(body)s
\end{alltt}
\end{document}
'''
def alltt_escape(s):
'Replace backslash and braces with their escaped equivalents'
xlat = {'{': r'\{', '}': r'\}', '\\': r'\textbackslash{}'}
return re.sub(r'[\\{}]', lambda mo: xlat[mo.group()], s)
def latex_highlight(classified_text, title = 'python',
commands = default_latex_commands,
document = default_latex_document):
'Create a complete LaTeX document with colorized source code'
macros = '\n'.join(r'\newcommand{\py%s}[1]{%s}' % c for c in commands.items())
result = []
for kind, text in classified_text:
if kind:
result.append(r'\py%s{' % kind)
result.append(alltt_escape(text))
if kind:
result.append('}')
return default_latex_document % dict(title=title, macros=macros, body=''.join(result))
if __name__ == '__main__':
import argparse
import os.path
import sys
import textwrap
import webbrowser
parser = argparse.ArgumentParser(
description = 'Add syntax highlighting to Python source code',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog = textwrap.dedent('''
examples:
# Show syntax highlighted code in the terminal window
$ ./highlight.py myfile.py
# Colorize myfile.py and display in a browser
$ ./highlight.py -b myfile.py
# Create an HTML section to embed in an existing webpage
./highlight.py -s myfile.py
# Create a complete HTML file
$ ./highlight.py -c myfile.py > myfile.html
# Create a PDF using LaTeX
$ ./highlight.py -l myfile.py | pdflatex
'''))
parser.add_argument('sourcefile', metavar = 'SOURCEFILE',
help = 'file containing Python sourcecode')
parser.add_argument('-b', '--browser', action = 'store_true',
help = 'launch a browser to show results')
parser.add_argument('-c', '--complete', action = 'store_true',
help = 'build a complete html webpage')
parser.add_argument('-l', '--latex', action = 'store_true',
help = 'build a LaTeX document')
parser.add_argument('-r', '--raw', action = 'store_true',
help = 'raw parse of categorized text')
parser.add_argument('-s', '--section', action = 'store_true',
help = 'show an HTML section rather than a complete webpage')
args = parser.parse_args()
if args.section and (args.browser or args.complete):
parser.error('The -s/--section option is incompatible with '
'the -b/--browser or -c/--complete options')
sourcefile = args.sourcefile
with open(sourcefile) as f:
source = f.read()
classified_text = analyze_python(source)
if args.raw:
encoded = raw_highlight(classified_text)
elif args.complete or args.browser:
encoded = build_html_page(classified_text, title=sourcefile)
elif args.section:
encoded = html_highlight(classified_text)
elif args.latex:
encoded = latex_highlight(classified_text, title=sourcefile)
else:
encoded = ansi_highlight(classified_text)
if args.browser:
htmlfile = os.path.splitext(os.path.basename(sourcefile))[0] + '.html'
with open(htmlfile, 'w') as f:
f.write(encoded)
webbrowser.open('file://' + os.path.abspath(htmlfile))
else:
sys.stdout.write(encoded)
| 9,162 | 266 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/suff.py | #! /usr/bin/env python3
# suff
#
# show different suffixes amongst arguments
import sys
def main():
files = sys.argv[1:]
suffixes = {}
for filename in files:
suff = getsuffix(filename)
suffixes.setdefault(suff, []).append(filename)
for suff, filenames in sorted(suffixes.items()):
print(repr(suff), len(filenames))
def getsuffix(filename):
name, sep, suff = filename.rpartition('.')
return sep + suff if sep else ''
if __name__ == '__main__':
main()
| 510 | 27 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/pindent.py | #! /usr/bin/env python3
# This file contains a class and a main program that perform three
# related (though complimentary) formatting operations on Python
# programs. When called as "pindent -c", it takes a valid Python
# program as input and outputs a version augmented with block-closing
# comments. When called as "pindent -d", it assumes its input is a
# Python program with block-closing comments and outputs a commentless
# version. When called as "pindent -r" it assumes its input is a
# Python program with block-closing comments but with its indentation
# messed up, and outputs a properly indented version.
# A "block-closing comment" is a comment of the form '# end <keyword>'
# where <keyword> is the keyword that opened the block. If the
# opening keyword is 'def' or 'class', the function or class name may
# be repeated in the block-closing comment as well. Here is an
# example of a program fully augmented with block-closing comments:
# def foobar(a, b):
# if a == b:
# a = a+1
# elif a < b:
# b = b-1
# if b > a: a = a-1
# # end if
# else:
# print 'oops!'
# # end if
# # end def foobar
# Note that only the last part of an if...elif...else... block needs a
# block-closing comment; the same is true for other compound
# statements (e.g. try...except). Also note that "short-form" blocks
# like the second 'if' in the example must be closed as well;
# otherwise the 'else' in the example would be ambiguous (remember
# that indentation is not significant when interpreting block-closing
# comments).
# The operations are idempotent (i.e. applied to their own output
# they yield an identical result). Running first "pindent -c" and
# then "pindent -r" on a valid Python program produces a program that
# is semantically identical to the input (though its indentation may
# be different). Running "pindent -e" on that output produces a
# program that only differs from the original in indentation.
# Other options:
# -s stepsize: set the indentation step size (default 8)
# -t tabsize : set the number of spaces a tab character is worth (default 8)
# -e : expand TABs into spaces
# file ... : input file(s) (default standard input)
# The results always go to standard output
# Caveats:
# - comments ending in a backslash will be mistaken for continued lines
# - continuations using backslash are always left unchanged
# - continuations inside parentheses are not extra indented by -r
# but must be indented for -c to work correctly (this breaks
# idempotency!)
# - continued lines inside triple-quoted strings are totally garbled
# Secret feature:
# - On input, a block may also be closed with an "end statement" --
# this is a block-closing comment without the '#' sign.
# Possible improvements:
# - check syntax based on transitions in 'next' table
# - better error reporting
# - better error recovery
# - check identifier after class/def
# The following wishes need a more complete tokenization of the source:
# - Don't get fooled by comments ending in backslash
# - reindent continuation lines indicated by backslash
# - handle continuation lines inside parentheses/braces/brackets
# - handle triple quoted strings spanning lines
# - realign comments
# - optionally do much more thorough reformatting, a la C indent
# Defaults
STEPSIZE = 8
TABSIZE = 8
EXPANDTABS = False
import io
import re
import sys
next = {}
next['if'] = next['elif'] = 'elif', 'else', 'end'
next['while'] = next['for'] = 'else', 'end'
next['try'] = 'except', 'finally'
next['except'] = 'except', 'else', 'finally', 'end'
next['else'] = next['finally'] = next['with'] = \
next['def'] = next['class'] = 'end'
next['end'] = ()
start = 'if', 'while', 'for', 'try', 'with', 'def', 'class'
class PythonIndenter:
def __init__(self, fpi = sys.stdin, fpo = sys.stdout,
indentsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
self.fpi = fpi
self.fpo = fpo
self.indentsize = indentsize
self.tabsize = tabsize
self.lineno = 0
self.expandtabs = expandtabs
self._write = fpo.write
self.kwprog = re.compile(
r'^(?:\s|\\\n)*(?P<kw>[a-z]+)'
r'((?:\s|\\\n)+(?P<id>[a-zA-Z_]\w*))?'
r'[^\w]')
self.endprog = re.compile(
r'^(?:\s|\\\n)*#?\s*end\s+(?P<kw>[a-z]+)'
r'(\s+(?P<id>[a-zA-Z_]\w*))?'
r'[^\w]')
self.wsprog = re.compile(r'^[ \t]*')
# end def __init__
def write(self, line):
if self.expandtabs:
self._write(line.expandtabs(self.tabsize))
else:
self._write(line)
# end if
# end def write
def readline(self):
line = self.fpi.readline()
if line: self.lineno += 1
# end if
return line
# end def readline
def error(self, fmt, *args):
if args: fmt = fmt % args
# end if
sys.stderr.write('Error at line %d: %s\n' % (self.lineno, fmt))
self.write('### %s ###\n' % fmt)
# end def error
def getline(self):
line = self.readline()
while line[-2:] == '\\\n':
line2 = self.readline()
if not line2: break
# end if
line += line2
# end while
return line
# end def getline
def putline(self, line, indent):
tabs, spaces = divmod(indent*self.indentsize, self.tabsize)
i = self.wsprog.match(line).end()
line = line[i:]
if line[:1] not in ('\n', '\r', ''):
line = '\t'*tabs + ' '*spaces + line
# end if
self.write(line)
# end def putline
def reformat(self):
stack = []
while True:
line = self.getline()
if not line: break # EOF
# end if
m = self.endprog.match(line)
if m:
kw = 'end'
kw2 = m.group('kw')
if not stack:
self.error('unexpected end')
elif stack.pop()[0] != kw2:
self.error('unmatched end')
# end if
self.putline(line, len(stack))
continue
# end if
m = self.kwprog.match(line)
if m:
kw = m.group('kw')
if kw in start:
self.putline(line, len(stack))
stack.append((kw, kw))
continue
# end if
if kw in next and stack:
self.putline(line, len(stack)-1)
kwa, kwb = stack[-1]
stack[-1] = kwa, kw
continue
# end if
# end if
self.putline(line, len(stack))
# end while
if stack:
self.error('unterminated keywords')
for kwa, kwb in stack:
self.write('\t%s\n' % kwa)
# end for
# end if
# end def reformat
def delete(self):
begin_counter = 0
end_counter = 0
while True:
line = self.getline()
if not line: break # EOF
# end if
m = self.endprog.match(line)
if m:
end_counter += 1
continue
# end if
m = self.kwprog.match(line)
if m:
kw = m.group('kw')
if kw in start:
begin_counter += 1
# end if
# end if
self.write(line)
# end while
if begin_counter - end_counter < 0:
sys.stderr.write('Warning: input contained more end tags than expected\n')
elif begin_counter - end_counter > 0:
sys.stderr.write('Warning: input contained less end tags than expected\n')
# end if
# end def delete
def complete(self):
stack = []
todo = []
currentws = thisid = firstkw = lastkw = topid = ''
while True:
line = self.getline()
i = self.wsprog.match(line).end()
m = self.endprog.match(line)
if m:
thiskw = 'end'
endkw = m.group('kw')
thisid = m.group('id')
else:
m = self.kwprog.match(line)
if m:
thiskw = m.group('kw')
if thiskw not in next:
thiskw = ''
# end if
if thiskw in ('def', 'class'):
thisid = m.group('id')
else:
thisid = ''
# end if
elif line[i:i+1] in ('\n', '#'):
todo.append(line)
continue
else:
thiskw = ''
# end if
# end if
indentws = line[:i]
indent = len(indentws.expandtabs(self.tabsize))
current = len(currentws.expandtabs(self.tabsize))
while indent < current:
if firstkw:
if topid:
s = '# end %s %s\n' % (
firstkw, topid)
else:
s = '# end %s\n' % firstkw
# end if
self.write(currentws + s)
firstkw = lastkw = ''
# end if
currentws, firstkw, lastkw, topid = stack.pop()
current = len(currentws.expandtabs(self.tabsize))
# end while
if indent == current and firstkw:
if thiskw == 'end':
if endkw != firstkw:
self.error('mismatched end')
# end if
firstkw = lastkw = ''
elif not thiskw or thiskw in start:
if topid:
s = '# end %s %s\n' % (
firstkw, topid)
else:
s = '# end %s\n' % firstkw
# end if
self.write(currentws + s)
firstkw = lastkw = topid = ''
# end if
# end if
if indent > current:
stack.append((currentws, firstkw, lastkw, topid))
if thiskw and thiskw not in start:
# error
thiskw = ''
# end if
currentws, firstkw, lastkw, topid = \
indentws, thiskw, thiskw, thisid
# end if
if thiskw:
if thiskw in start:
firstkw = lastkw = thiskw
topid = thisid
else:
lastkw = thiskw
# end if
# end if
for l in todo: self.write(l)
# end for
todo = []
if not line: break
# end if
self.write(line)
# end while
# end def complete
# end class PythonIndenter
# Simplified user interface
# - xxx_filter(input, output): read and write file objects
# - xxx_string(s): take and return string object
# - xxx_file(filename): process file in place, return true iff changed
def complete_filter(input = sys.stdin, output = sys.stdout,
stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.complete()
# end def complete_filter
def delete_filter(input= sys.stdin, output = sys.stdout,
stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.delete()
# end def delete_filter
def reformat_filter(input = sys.stdin, output = sys.stdout,
stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.reformat()
# end def reformat_filter
def complete_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
input = io.StringIO(source)
output = io.StringIO()
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.complete()
return output.getvalue()
# end def complete_string
def delete_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
input = io.StringIO(source)
output = io.StringIO()
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.delete()
return output.getvalue()
# end def delete_string
def reformat_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
input = io.StringIO(source)
output = io.StringIO()
pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs)
pi.reformat()
return output.getvalue()
# end def reformat_string
def make_backup(filename):
import os, os.path
backup = filename + '~'
if os.path.lexists(backup):
try:
os.remove(backup)
except OSError:
print("Can't remove backup %r" % (backup,), file=sys.stderr)
# end try
# end if
try:
os.rename(filename, backup)
except OSError:
print("Can't rename %r to %r" % (filename, backup), file=sys.stderr)
# end try
# end def make_backup
def complete_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
with open(filename, 'r') as f:
source = f.read()
# end with
result = complete_string(source, stepsize, tabsize, expandtabs)
if source == result: return 0
# end if
make_backup(filename)
with open(filename, 'w') as f:
f.write(result)
# end with
return 1
# end def complete_file
def delete_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
with open(filename, 'r') as f:
source = f.read()
# end with
result = delete_string(source, stepsize, tabsize, expandtabs)
if source == result: return 0
# end if
make_backup(filename)
with open(filename, 'w') as f:
f.write(result)
# end with
return 1
# end def delete_file
def reformat_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS):
with open(filename, 'r') as f:
source = f.read()
# end with
result = reformat_string(source, stepsize, tabsize, expandtabs)
if source == result: return 0
# end if
make_backup(filename)
with open(filename, 'w') as f:
f.write(result)
# end with
return 1
# end def reformat_file
# Test program when called as a script
usage = """
usage: pindent (-c|-d|-r) [-s stepsize] [-t tabsize] [-e] [file] ...
-c : complete a correctly indented program (add #end directives)
-d : delete #end directives
-r : reformat a completed program (use #end directives)
-s stepsize: indentation step (default %(STEPSIZE)d)
-t tabsize : the worth in spaces of a tab (default %(TABSIZE)d)
-e : expand TABs into spaces (default OFF)
[file] ... : files are changed in place, with backups in file~
If no files are specified or a single - is given,
the program acts as a filter (reads stdin, writes stdout).
""" % vars()
def error_both(op1, op2):
sys.stderr.write('Error: You can not specify both '+op1+' and -'+op2[0]+' at the same time\n')
sys.stderr.write(usage)
sys.exit(2)
# end def error_both
def test():
import getopt
try:
opts, args = getopt.getopt(sys.argv[1:], 'cdrs:t:e')
except getopt.error as msg:
sys.stderr.write('Error: %s\n' % msg)
sys.stderr.write(usage)
sys.exit(2)
# end try
action = None
stepsize = STEPSIZE
tabsize = TABSIZE
expandtabs = EXPANDTABS
for o, a in opts:
if o == '-c':
if action: error_both(o, action)
# end if
action = 'complete'
elif o == '-d':
if action: error_both(o, action)
# end if
action = 'delete'
elif o == '-r':
if action: error_both(o, action)
# end if
action = 'reformat'
elif o == '-s':
stepsize = int(a)
elif o == '-t':
tabsize = int(a)
elif o == '-e':
expandtabs = True
# end if
# end for
if not action:
sys.stderr.write(
'You must specify -c(omplete), -d(elete) or -r(eformat)\n')
sys.stderr.write(usage)
sys.exit(2)
# end if
if not args or args == ['-']:
action = eval(action + '_filter')
action(sys.stdin, sys.stdout, stepsize, tabsize, expandtabs)
else:
action = eval(action + '_file')
for filename in args:
action(filename, stepsize, tabsize, expandtabs)
# end for
# end if
# end def test
if __name__ == '__main__':
test()
# end if
| 17,127 | 507 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/lll.py | #! /usr/bin/env python3
# Find symbolic links and show where they point to.
# Arguments are directories to search; default is current directory.
# No recursion.
# (This is a totally different program from "findsymlinks.py"!)
import sys, os
def lll(dirname):
for name in os.listdir(dirname):
if name not in (os.curdir, os.pardir):
full = os.path.join(dirname, name)
if os.path.islink(full):
print(name, '->', os.readlink(full))
def main():
args = sys.argv[1:]
if not args: args = [os.curdir]
first = 1
for arg in args:
if len(args) > 1:
if not first: print()
first = 0
print(arg + ':')
lll(arg)
if __name__ == '__main__':
main()
| 752 | 29 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/untabify.py | #! /usr/bin/env python3
"Replace tabs with spaces in argument files. Print names of changed files."
import os
import sys
import getopt
import tokenize
def main():
tabsize = 8
try:
opts, args = getopt.getopt(sys.argv[1:], "t:")
if not args:
raise getopt.error("At least one file argument required")
except getopt.error as msg:
print(msg)
print("usage:", sys.argv[0], "[-t tabwidth] file ...")
return
for optname, optvalue in opts:
if optname == '-t':
tabsize = int(optvalue)
for filename in args:
process(filename, tabsize)
def process(filename, tabsize, verbose=True):
try:
with tokenize.open(filename) as f:
text = f.read()
encoding = f.encoding
except IOError as msg:
print("%r: I/O error: %s" % (filename, msg))
return
newtext = text.expandtabs(tabsize)
if newtext == text:
return
backup = filename + "~"
try:
os.unlink(backup)
except OSError:
pass
try:
os.rename(filename, backup)
except OSError:
pass
with open(filename, "w", encoding=encoding) as f:
f.write(newtext)
if verbose:
print(filename)
if __name__ == '__main__':
main()
| 1,296 | 56 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/linktree.py | #! /usr/bin/env python3
# linktree
#
# Make a copy of a directory tree with symbolic links to all files in the
# original tree.
# All symbolic links go to a special symbolic link at the top, so you
# can easily fix things if the original source tree moves.
# See also "mkreal".
#
# usage: mklinks oldtree newtree
import sys, os
LINK = '.LINK' # Name of special symlink at the top.
debug = 0
def main():
if not 3 <= len(sys.argv) <= 4:
print('usage:', sys.argv[0], 'oldtree newtree [linkto]')
return 2
oldtree, newtree = sys.argv[1], sys.argv[2]
if len(sys.argv) > 3:
link = sys.argv[3]
link_may_fail = 1
else:
link = LINK
link_may_fail = 0
if not os.path.isdir(oldtree):
print(oldtree + ': not a directory')
return 1
try:
os.mkdir(newtree, 0o777)
except OSError as msg:
print(newtree + ': cannot mkdir:', msg)
return 1
linkname = os.path.join(newtree, link)
try:
os.symlink(os.path.join(os.pardir, oldtree), linkname)
except OSError as msg:
if not link_may_fail:
print(linkname + ': cannot symlink:', msg)
return 1
else:
print(linkname + ': warning: cannot symlink:', msg)
linknames(oldtree, newtree, link)
return 0
def linknames(old, new, link):
if debug: print('linknames', (old, new, link))
try:
names = os.listdir(old)
except OSError as msg:
print(old + ': warning: cannot listdir:', msg)
return
for name in names:
if name not in (os.curdir, os.pardir):
oldname = os.path.join(old, name)
linkname = os.path.join(link, name)
newname = os.path.join(new, name)
if debug > 1: print(oldname, newname, linkname)
if os.path.isdir(oldname) and \
not os.path.islink(oldname):
try:
os.mkdir(newname, 0o777)
ok = 1
except:
print(newname + \
': warning: cannot mkdir:', msg)
ok = 0
if ok:
linkname = os.path.join(os.pardir,
linkname)
linknames(oldname, newname, linkname)
else:
os.symlink(linkname, newname)
if __name__ == '__main__':
sys.exit(main())
| 2,440 | 81 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/fixcid.py | #! /usr/bin/env python3
# Perform massive identifier substitution on C source files.
# This actually tokenizes the files (to some extent) so it can
# avoid making substitutions inside strings or comments.
# Inside strings, substitutions are never made; inside comments,
# it is a user option (off by default).
#
# The substitutions are read from one or more files whose lines,
# when not empty, after stripping comments starting with #,
# must contain exactly two words separated by whitespace: the
# old identifier and its replacement.
#
# The option -r reverses the sense of the substitutions (this may be
# useful to undo a particular substitution).
#
# If the old identifier is prefixed with a '*' (with no intervening
# whitespace), then it will not be substituted inside comments.
#
# Command line arguments are files or directories to be processed.
# Directories are searched recursively for files whose name looks
# like a C file (ends in .h or .c). The special filename '-' means
# operate in filter mode: read stdin, write stdout.
#
# Symbolic links are always ignored (except as explicit directory
# arguments).
#
# The original files are kept as back-up with a "~" suffix.
#
# Changes made are reported to stdout in a diff-like format.
#
# NB: by changing only the function fixline() you can turn this
# into a program for different changes to C source files; by
# changing the function wanted() you can make a different selection of
# files.
import sys
import re
import os
from stat import *
import getopt
err = sys.stderr.write
dbg = err
rep = sys.stdout.write
def usage():
progname = sys.argv[0]
err('Usage: ' + progname +
' [-c] [-r] [-s file] ... file-or-directory ...\n')
err('\n')
err('-c : substitute inside comments\n')
err('-r : reverse direction for following -s options\n')
err('-s substfile : add a file of substitutions\n')
err('\n')
err('Each non-empty non-comment line in a substitution file must\n')
err('contain exactly two words: an identifier and its replacement.\n')
err('Comments start with a # character and end at end of line.\n')
err('If an identifier is preceded with a *, it is not substituted\n')
err('inside a comment even when -c is specified.\n')
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], 'crs:')
except getopt.error as msg:
err('Options error: ' + str(msg) + '\n')
usage()
sys.exit(2)
bad = 0
if not args: # No arguments
usage()
sys.exit(2)
for opt, arg in opts:
if opt == '-c':
setdocomments()
if opt == '-r':
setreverse()
if opt == '-s':
addsubst(arg)
for arg in args:
if os.path.isdir(arg):
if recursedown(arg): bad = 1
elif os.path.islink(arg):
err(arg + ': will not process symbolic links\n')
bad = 1
else:
if fix(arg): bad = 1
sys.exit(bad)
# Change this regular expression to select a different set of files
Wanted = r'^[a-zA-Z0-9_]+\.[ch]$'
def wanted(name):
return re.match(Wanted, name)
def recursedown(dirname):
dbg('recursedown(%r)\n' % (dirname,))
bad = 0
try:
names = os.listdir(dirname)
except OSError as msg:
err(dirname + ': cannot list directory: ' + str(msg) + '\n')
return 1
names.sort()
subdirs = []
for name in names:
if name in (os.curdir, os.pardir): continue
fullname = os.path.join(dirname, name)
if os.path.islink(fullname): pass
elif os.path.isdir(fullname):
subdirs.append(fullname)
elif wanted(name):
if fix(fullname): bad = 1
for fullname in subdirs:
if recursedown(fullname): bad = 1
return bad
def fix(filename):
## dbg('fix(%r)\n' % (filename,))
if filename == '-':
# Filter mode
f = sys.stdin
g = sys.stdout
else:
# File replacement mode
try:
f = open(filename, 'r')
except IOError as msg:
err(filename + ': cannot open: ' + str(msg) + '\n')
return 1
head, tail = os.path.split(filename)
tempname = os.path.join(head, '@' + tail)
g = None
# If we find a match, we rewind the file and start over but
# now copy everything to a temp file.
lineno = 0
initfixline()
while 1:
line = f.readline()
if not line: break
lineno = lineno + 1
while line[-2:] == '\\\n':
nextline = f.readline()
if not nextline: break
line = line + nextline
lineno = lineno + 1
newline = fixline(line)
if newline != line:
if g is None:
try:
g = open(tempname, 'w')
except IOError as msg:
f.close()
err(tempname+': cannot create: '+
str(msg)+'\n')
return 1
f.seek(0)
lineno = 0
initfixline()
rep(filename + ':\n')
continue # restart from the beginning
rep(repr(lineno) + '\n')
rep('< ' + line)
rep('> ' + newline)
if g is not None:
g.write(newline)
# End of file
if filename == '-': return 0 # Done in filter mode
f.close()
if not g: return 0 # No changes
g.close()
# Finishing touch -- move files
# First copy the file's mode to the temp file
try:
statbuf = os.stat(filename)
os.chmod(tempname, statbuf[ST_MODE] & 0o7777)
except OSError as msg:
err(tempname + ': warning: chmod failed (' + str(msg) + ')\n')
# Then make a backup of the original file as filename~
try:
os.rename(filename, filename + '~')
except OSError as msg:
err(filename + ': warning: backup failed (' + str(msg) + ')\n')
# Now move the temp file to the original file
try:
os.rename(tempname, filename)
except OSError as msg:
err(filename + ': rename failed (' + str(msg) + ')\n')
return 1
# Return success
return 0
# Tokenizing ANSI C (partly)
Identifier = '(struct )?[a-zA-Z_][a-zA-Z0-9_]+'
String = r'"([^\n\\"]|\\.)*"'
Char = r"'([^\n\\']|\\.)*'"
CommentStart = r'/\*'
CommentEnd = r'\*/'
Hexnumber = '0[xX][0-9a-fA-F]*[uUlL]*'
Octnumber = '0[0-7]*[uUlL]*'
Decnumber = '[1-9][0-9]*[uUlL]*'
Intnumber = Hexnumber + '|' + Octnumber + '|' + Decnumber
Exponent = '[eE][-+]?[0-9]+'
Pointfloat = r'([0-9]+\.[0-9]*|\.[0-9]+)(' + Exponent + r')?'
Expfloat = '[0-9]+' + Exponent
Floatnumber = Pointfloat + '|' + Expfloat
Number = Floatnumber + '|' + Intnumber
# Anything else is an operator -- don't list this explicitly because of '/*'
OutsideComment = (Identifier, Number, String, Char, CommentStart)
OutsideCommentPattern = '(' + '|'.join(OutsideComment) + ')'
OutsideCommentProgram = re.compile(OutsideCommentPattern)
InsideComment = (Identifier, Number, CommentEnd)
InsideCommentPattern = '(' + '|'.join(InsideComment) + ')'
InsideCommentProgram = re.compile(InsideCommentPattern)
def initfixline():
global Program
Program = OutsideCommentProgram
def fixline(line):
global Program
## print('-->', repr(line))
i = 0
while i < len(line):
match = Program.search(line, i)
if match is None: break
i = match.start()
found = match.group(0)
## if Program is InsideCommentProgram: print(end='... ')
## else: print(end=' ')
## print(found)
if len(found) == 2:
if found == '/*':
Program = InsideCommentProgram
elif found == '*/':
Program = OutsideCommentProgram
n = len(found)
if found in Dict:
subst = Dict[found]
if Program is InsideCommentProgram:
if not Docomments:
print('Found in comment:', found)
i = i + n
continue
if found in NotInComment:
## print(end='Ignored in comment: ')
## print(found, '-->', subst)
## print('Line:', line, end='')
subst = found
## else:
## print(end='Substituting in comment: ')
## print(found, '-->', subst)
## print('Line:', line, end='')
line = line[:i] + subst + line[i+n:]
n = len(subst)
i = i + n
return line
Docomments = 0
def setdocomments():
global Docomments
Docomments = 1
Reverse = 0
def setreverse():
global Reverse
Reverse = (not Reverse)
Dict = {}
NotInComment = {}
def addsubst(substfile):
try:
fp = open(substfile, 'r')
except IOError as msg:
err(substfile + ': cannot read substfile: ' + str(msg) + '\n')
sys.exit(1)
lineno = 0
while 1:
line = fp.readline()
if not line: break
lineno = lineno + 1
try:
i = line.index('#')
except ValueError:
i = -1 # Happens to delete trailing \n
words = line[:i].split()
if not words: continue
if len(words) == 3 and words[0] == 'struct':
words[:2] = [words[0] + ' ' + words[1]]
elif len(words) != 2:
err(substfile + '%s:%r: warning: bad line: %r' % (substfile, lineno, line))
continue
if Reverse:
[value, key] = words
else:
[key, value] = words
if value[0] == '*':
value = value[1:]
if key[0] == '*':
key = key[1:]
NotInComment[key] = value
if key in Dict:
err('%s:%r: warning: overriding: %r %r\n' % (substfile, lineno, key, value))
err('%s:%r: warning: previous: %r\n' % (substfile, lineno, Dict[key]))
Dict[key] = value
fp.close()
if __name__ == '__main__':
main()
| 10,051 | 317 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/run_tests.py | """Run Python's test suite in a fast, rigorous way.
The defaults are meant to be reasonably thorough, while skipping certain
tests that can be time-consuming or resource-intensive (e.g. largefile),
or distracting (e.g. audio and gui). These defaults can be overridden by
simply passing a -u option to this script.
"""
import os
import sys
import test.support
try:
import threading
except ImportError:
threading = None
def is_multiprocess_flag(arg):
return arg.startswith('-j') or arg.startswith('--multiprocess')
def is_resource_use_flag(arg):
return arg.startswith('-u') or arg.startswith('--use')
def main(regrtest_args):
args = [sys.executable,
'-W', 'default', # Warnings set to 'default'
'-bb', # Warnings about bytes/bytearray
'-E', # Ignore environment variables
]
# Allow user-specified interpreter options to override our defaults.
args.extend(test.support.args_from_interpreter_flags())
# Workaround for issue #20361
args.extend(['-W', 'error::BytesWarning'])
args.extend(['-m', 'test', # Run the test suite
'-r', # Randomize test order
'-w', # Re-run failed tests in verbose mode
])
if sys.platform == 'win32':
args.append('-n') # Silence alerts under Windows
if threading and not any(is_multiprocess_flag(arg) for arg in regrtest_args):
args.extend(['-j', '0']) # Use all CPU cores
if not any(is_resource_use_flag(arg) for arg in regrtest_args):
args.extend(['-u', 'all,-largefile,-audio,-gui'])
args.extend(regrtest_args)
print(' '.join(args))
if sys.platform == 'win32':
from subprocess import call
sys.exit(call(args))
else:
os.execv(sys.executable, args)
if __name__ == '__main__':
main(sys.argv[1:])
| 1,919 | 60 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/eptags.py | #! /usr/bin/env python3
"""Create a TAGS file for Python programs, usable with GNU Emacs.
usage: eptags pyfiles...
The output TAGS file is usable with Emacs version 18, 19, 20.
Tagged are:
- functions (even inside other defs or classes)
- classes
eptags warns about files it cannot open.
eptags will not give warnings about duplicate tags.
BUGS:
Because of tag duplication (methods with the same name in different
classes), TAGS files are not very useful for most object-oriented
python projects.
"""
import sys,re
expr = r'^[ \t]*(def|class)[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*[:\(]'
matcher = re.compile(expr)
def treat_file(filename, outfp):
"""Append tags found in file named 'filename' to the open file 'outfp'"""
try:
fp = open(filename, 'r')
except OSError:
sys.stderr.write('Cannot open %s\n'%filename)
return
charno = 0
lineno = 0
tags = []
size = 0
while 1:
line = fp.readline()
if not line:
break
lineno = lineno + 1
m = matcher.search(line)
if m:
tag = m.group(0) + '\177%d,%d\n' % (lineno, charno)
tags.append(tag)
size = size + len(tag)
charno = charno + len(line)
outfp.write('\f\n%s,%d\n' % (filename,size))
for tag in tags:
outfp.write(tag)
def main():
outfp = open('TAGS', 'w')
for filename in sys.argv[1:]:
treat_file(filename, outfp)
if __name__=="__main__":
main()
| 1,493 | 57 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/parse_html5_entities.py | #!/usr/bin/env python3
"""
Utility for parsing HTML5 entity definitions available from:
http://dev.w3.org/html5/spec/entities.json
Written by Ezio Melotti and Iuliia Proskurnia.
"""
import os
import sys
import json
from urllib.request import urlopen
from html.entities import html5
entities_url = 'http://dev.w3.org/html5/spec/entities.json'
def get_json(url):
"""Download the json file from the url and returns a decoded object."""
with urlopen(url) as f:
data = f.read().decode('utf-8')
return json.loads(data)
def create_dict(entities):
"""Create the html5 dict from the decoded json object."""
new_html5 = {}
for name, value in entities.items():
new_html5[name.lstrip('&')] = value['characters']
return new_html5
def compare_dicts(old, new):
"""Compare the old and new dicts and print the differences."""
added = new.keys() - old.keys()
if added:
print('{} entitie(s) have been added:'.format(len(added)))
for name in sorted(added):
print(' {!r}: {!r}'.format(name, new[name]))
removed = old.keys() - new.keys()
if removed:
print('{} entitie(s) have been removed:'.format(len(removed)))
for name in sorted(removed):
print(' {!r}: {!r}'.format(name, old[name]))
changed = set()
for name in (old.keys() & new.keys()):
if old[name] != new[name]:
changed.add((name, old[name], new[name]))
if changed:
print('{} entitie(s) have been modified:'.format(len(changed)))
for item in sorted(changed):
print(' {!r}: {!r} -> {!r}'.format(*item))
def write_items(entities, file=sys.stdout):
"""Write the items of the dictionary in the specified file."""
# The keys in the generated dictionary should be sorted
# in a case-insensitive way, however, when two keys are equal,
# the uppercase version should come first so that the result
# looks like: ['Aacute', 'aacute', 'Aacute;', 'aacute;', ...]
# To do this we first sort in a case-sensitive way (so all the
# uppercase chars come first) and then sort with key=str.lower.
# Since the sorting is stable the uppercase keys will eventually
# be before their equivalent lowercase version.
keys = sorted(entities.keys())
keys = sorted(keys, key=str.lower)
print('html5 = {', file=file)
for name in keys:
print(' {!r}: {!a},'.format(name, entities[name]), file=file)
print('}', file=file)
if __name__ == '__main__':
# without args print a diff between html.entities.html5 and new_html5
# with --create print the new html5 dict
# with --patch patch the Lib/html/entities.py file
new_html5 = create_dict(get_json(entities_url))
if '--create' in sys.argv:
print('# map the HTML5 named character references to the '
'equivalent Unicode character(s)')
print('# Generated by {}. Do not edit manually.'.format(__file__))
write_items(new_html5)
elif '--patch' in sys.argv:
fname = 'Lib/html/entities.py'
temp_fname = fname + '.temp'
with open(fname) as f1, open(temp_fname, 'w') as f2:
skip = False
for line in f1:
if line.startswith('html5 = {'):
write_items(new_html5, file=f2)
skip = True
continue
if skip:
# skip the old items until the }
if line.startswith('}'):
skip = False
continue
f2.write(line)
os.remove(fname)
os.rename(temp_fname, fname)
else:
if html5 == new_html5:
print('The current dictionary is updated.')
else:
compare_dicts(html5, new_html5)
print('Run "./python {0} --patch" to update Lib/html/entities.html '
'or "./python {0} --create" to see the generated ' 'dictionary.'.format(__file__))
| 3,999 | 106 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/reindent.py | #! /usr/bin/env python3
# Released to the public domain, by Tim Peters, 03 October 2000.
"""reindent [-d][-r][-v] [ path ... ]
-d (--dryrun) Dry run. Analyze, but don't make any changes to, files.
-r (--recurse) Recurse. Search for all .py files in subdirectories too.
-n (--nobackup) No backup. Does not make a ".bak" file before reindenting.
-v (--verbose) Verbose. Print informative msgs; else no output.
(--newline) Newline. Specify the newline character to use (CRLF, LF).
Default is the same as the original file.
-h (--help) Help. Print this usage information and exit.
Change Python (.py) files to use 4-space indents and no hard tab characters.
Also trim excess spaces and tabs from ends of lines, and remove empty lines
at the end of files. Also ensure the last line ends with a newline.
If no paths are given on the command line, reindent operates as a filter,
reading a single source file from standard input and writing the transformed
source to standard output. In this case, the -d, -r and -v flags are
ignored.
You can pass one or more file and/or directory paths. When a directory
path, all .py files within the directory will be examined, and, if the -r
option is given, likewise recursively for subdirectories.
If output is not to standard output, reindent overwrites files in place,
renaming the originals with a .bak extension. If it finds nothing to
change, the file is left alone. If reindent does change a file, the changed
file is a fixed-point for future runs (i.e., running reindent on the
resulting .py file won't change it again).
The hard part of reindenting is figuring out what to do with comment
lines. So long as the input files get a clean bill of health from
tabnanny.py, reindent should do a good job.
The backup file is a copy of the one that is being reindented. The ".bak"
file is generated with shutil.copy(), but some corner cases regarding
user/group and permissions could leave the backup file more readable than
you'd prefer. You can always use the --nobackup option to prevent this.
"""
__version__ = "1"
import tokenize
import os
import shutil
import sys
verbose = False
recurse = False
dryrun = False
makebackup = True
# A specified newline to be used in the output (set by --newline option)
spec_newline = None
def usage(msg=None):
if msg is None:
msg = __doc__
print(msg, file=sys.stderr)
def errprint(*args):
sys.stderr.write(" ".join(str(arg) for arg in args))
sys.stderr.write("\n")
def main():
import getopt
global verbose, recurse, dryrun, makebackup, spec_newline
try:
opts, args = getopt.getopt(sys.argv[1:], "drnvh",
["dryrun", "recurse", "nobackup", "verbose", "newline=", "help"])
except getopt.error as msg:
usage(msg)
return
for o, a in opts:
if o in ('-d', '--dryrun'):
dryrun = True
elif o in ('-r', '--recurse'):
recurse = True
elif o in ('-n', '--nobackup'):
makebackup = False
elif o in ('-v', '--verbose'):
verbose = True
elif o in ('--newline',):
if not a.upper() in ('CRLF', 'LF'):
usage()
return
spec_newline = dict(CRLF='\r\n', LF='\n')[a.upper()]
elif o in ('-h', '--help'):
usage()
return
if not args:
r = Reindenter(sys.stdin)
r.run()
r.write(sys.stdout)
return
for arg in args:
check(arg)
def check(file):
if os.path.isdir(file) and not os.path.islink(file):
if verbose:
print("listing directory", file)
names = os.listdir(file)
for name in names:
fullname = os.path.join(file, name)
if ((recurse and os.path.isdir(fullname) and
not os.path.islink(fullname) and
not os.path.split(fullname)[1].startswith("."))
or name.lower().endswith(".py")):
check(fullname)
return
if verbose:
print("checking", file, "...", end=' ')
with open(file, 'rb') as f:
try:
encoding, _ = tokenize.detect_encoding(f.readline)
except SyntaxError as se:
errprint("%s: SyntaxError: %s" % (file, str(se)))
return
try:
with open(file, encoding=encoding) as f:
r = Reindenter(f)
except IOError as msg:
errprint("%s: I/O Error: %s" % (file, str(msg)))
return
newline = spec_newline if spec_newline else r.newlines
if isinstance(newline, tuple):
errprint("%s: mixed newlines detected; cannot continue without --newline" % file)
return
if r.run():
if verbose:
print("changed.")
if dryrun:
print("But this is a dry run, so leaving it alone.")
if not dryrun:
bak = file + ".bak"
if makebackup:
shutil.copyfile(file, bak)
if verbose:
print("backed up", file, "to", bak)
with open(file, "w", encoding=encoding, newline=newline) as f:
r.write(f)
if verbose:
print("wrote new", file)
return True
else:
if verbose:
print("unchanged.")
return False
def _rstrip(line, JUNK='\n \t'):
"""Return line stripped of trailing spaces, tabs, newlines.
Note that line.rstrip() instead also strips sundry control characters,
but at least one known Emacs user expects to keep junk like that, not
mentioning Barry by name or anything <wink>.
"""
i = len(line)
while i > 0 and line[i - 1] in JUNK:
i -= 1
return line[:i]
class Reindenter:
def __init__(self, f):
self.find_stmt = 1 # next token begins a fresh stmt?
self.level = 0 # current indent level
# Raw file lines.
self.raw = f.readlines()
# File lines, rstripped & tab-expanded. Dummy at start is so
# that we can use tokenize's 1-based line numbering easily.
# Note that a line is all-blank iff it's "\n".
self.lines = [_rstrip(line).expandtabs() + "\n"
for line in self.raw]
self.lines.insert(0, None)
self.index = 1 # index into self.lines of next line
# List of (lineno, indentlevel) pairs, one for each stmt and
# comment line. indentlevel is -1 for comment lines, as a
# signal that tokenize doesn't know what to do about them;
# indeed, they're our headache!
self.stats = []
# Save the newlines found in the file so they can be used to
# create output without mutating the newlines.
self.newlines = f.newlines
def run(self):
tokens = tokenize.generate_tokens(self.getline)
for _token in tokens:
self.tokeneater(*_token)
# Remove trailing empty lines.
lines = self.lines
while lines and lines[-1] == "\n":
lines.pop()
# Sentinel.
stats = self.stats
stats.append((len(lines), 0))
# Map count of leading spaces to # we want.
have2want = {}
# Program after transformation.
after = self.after = []
# Copy over initial empty lines -- there's nothing to do until
# we see a line with *something* on it.
i = stats[0][0]
after.extend(lines[1:i])
for i in range(len(stats) - 1):
thisstmt, thislevel = stats[i]
nextstmt = stats[i + 1][0]
have = getlspace(lines[thisstmt])
want = thislevel * 4
if want < 0:
# A comment line.
if have:
# An indented comment line. If we saw the same
# indentation before, reuse what it most recently
# mapped to.
want = have2want.get(have, -1)
if want < 0:
# Then it probably belongs to the next real stmt.
for j in range(i + 1, len(stats) - 1):
jline, jlevel = stats[j]
if jlevel >= 0:
if have == getlspace(lines[jline]):
want = jlevel * 4
break
if want < 0: # Maybe it's a hanging
# comment like this one,
# in which case we should shift it like its base
# line got shifted.
for j in range(i - 1, -1, -1):
jline, jlevel = stats[j]
if jlevel >= 0:
want = have + (getlspace(after[jline - 1]) -
getlspace(lines[jline]))
break
if want < 0:
# Still no luck -- leave it alone.
want = have
else:
want = 0
assert want >= 0
have2want[have] = want
diff = want - have
if diff == 0 or have == 0:
after.extend(lines[thisstmt:nextstmt])
else:
for line in lines[thisstmt:nextstmt]:
if diff > 0:
if line == "\n":
after.append(line)
else:
after.append(" " * diff + line)
else:
remove = min(getlspace(line), -diff)
after.append(line[remove:])
return self.raw != self.after
def write(self, f):
f.writelines(self.after)
# Line-getter for tokenize.
def getline(self):
if self.index >= len(self.lines):
line = ""
else:
line = self.lines[self.index]
self.index += 1
return line
# Line-eater for tokenize.
def tokeneater(self, type, token, slinecol, end, line,
INDENT=tokenize.INDENT,
DEDENT=tokenize.DEDENT,
NEWLINE=tokenize.NEWLINE,
COMMENT=tokenize.COMMENT,
NL=tokenize.NL):
if type == NEWLINE:
# A program statement, or ENDMARKER, will eventually follow,
# after some (possibly empty) run of tokens of the form
# (NL | COMMENT)* (INDENT | DEDENT+)?
self.find_stmt = 1
elif type == INDENT:
self.find_stmt = 1
self.level += 1
elif type == DEDENT:
self.find_stmt = 1
self.level -= 1
elif type == COMMENT:
if self.find_stmt:
self.stats.append((slinecol[0], -1))
# but we're still looking for a new stmt, so leave
# find_stmt alone
elif type == NL:
pass
elif self.find_stmt:
# This is the first "real token" following a NEWLINE, so it
# must be the first token of the next program statement, or an
# ENDMARKER.
self.find_stmt = 0
if line: # not endmarker
self.stats.append((slinecol[0], self.level))
# Count number of leading blanks.
def getlspace(line):
i, n = 0, len(line)
while i < n and line[i] == " ":
i += 1
return i
if __name__ == '__main__':
main()
| 11,647 | 334 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/2to3 | #!/usr/bin/env python
import sys
from lib2to3.main import main
sys.exit(main("lib2to3.fixes"))
| 96 | 6 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/crlf.py | #! /usr/bin/env python3
"Replace CRLF with LF in argument files. Print names of changed files."
import sys, os
def main():
for filename in sys.argv[1:]:
if os.path.isdir(filename):
print(filename, "Directory!")
continue
with open(filename, "rb") as f:
data = f.read()
if b'\0' in data:
print(filename, "Binary!")
continue
newdata = data.replace(b"\r\n", b"\n")
if newdata != data:
print(filename)
with open(filename, "wb") as f:
f.write(newdata)
if __name__ == '__main__':
main()
| 632 | 24 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/treesync.py | #! /usr/bin/env python3
"""Script to synchronize two source trees.
Invoke with two arguments:
python treesync.py slave master
The assumption is that "master" contains CVS administration while
slave doesn't. All files in the slave tree that have a CVS/Entries
entry in the master tree are synchronized. This means:
If the files differ:
if the slave file is newer:
normalize the slave file
if the files still differ:
copy the slave to the master
else (the master is newer):
copy the master to the slave
normalizing the slave means replacing CRLF with LF when the master
doesn't use CRLF
"""
import os, sys, stat, getopt
# Interactivity options
default_answer = "ask"
create_files = "yes"
create_directories = "no"
write_slave = "ask"
write_master = "ask"
def main():
global default_answer, always_no, always_yes, create_files
global create_directories, write_master, write_slave
opts, args = getopt.getopt(sys.argv[1:], "nym:s:d:f:a:")
for o, a in opts:
if o == '-y':
default_answer = "yes"
if o == '-n':
default_answer = "no"
if o == '-s':
write_slave = a
if o == '-m':
write_master = a
if o == '-d':
create_directories = a
if o == '-f':
create_files = a
if o == '-a':
create_files = create_directories = write_slave = write_master = a
try:
[slave, master] = args
except ValueError:
print("usage: python", sys.argv[0] or "treesync.py", end=' ')
print("[-n] [-y] [-m y|n|a] [-s y|n|a] [-d y|n|a] [-f n|y|a]", end=' ')
print("slavedir masterdir")
return
process(slave, master)
def process(slave, master):
cvsdir = os.path.join(master, "CVS")
if not os.path.isdir(cvsdir):
print("skipping master subdirectory", master)
print("-- not under CVS")
return
print("-"*40)
print("slave ", slave)
print("master", master)
if not os.path.isdir(slave):
if not okay("create slave directory %s?" % slave,
answer=create_directories):
print("skipping master subdirectory", master)
print("-- no corresponding slave", slave)
return
print("creating slave directory", slave)
try:
os.mkdir(slave)
except OSError as msg:
print("can't make slave directory", slave, ":", msg)
return
else:
print("made slave directory", slave)
cvsdir = None
subdirs = []
names = os.listdir(master)
for name in names:
mastername = os.path.join(master, name)
slavename = os.path.join(slave, name)
if name == "CVS":
cvsdir = mastername
else:
if os.path.isdir(mastername) and not os.path.islink(mastername):
subdirs.append((slavename, mastername))
if cvsdir:
entries = os.path.join(cvsdir, "Entries")
for e in open(entries).readlines():
words = e.split('/')
if words[0] == '' and words[1:]:
name = words[1]
s = os.path.join(slave, name)
m = os.path.join(master, name)
compare(s, m)
for (s, m) in subdirs:
process(s, m)
def compare(slave, master):
try:
sf = open(slave, 'r')
except IOError:
sf = None
try:
mf = open(master, 'rb')
except IOError:
mf = None
if not sf:
if not mf:
print("Neither master nor slave exists", master)
return
print("Creating missing slave", slave)
copy(master, slave, answer=create_files)
return
if not mf:
print("Not updating missing master", master)
return
if sf and mf:
if identical(sf, mf):
return
sft = mtime(sf)
mft = mtime(mf)
if mft > sft:
# Master is newer -- copy master to slave
sf.close()
mf.close()
print("Master ", master)
print("is newer than slave", slave)
copy(master, slave, answer=write_slave)
return
# Slave is newer -- copy slave to master
print("Slave is", sft-mft, "seconds newer than master")
# But first check what to do about CRLF
mf.seek(0)
fun = funnychars(mf)
mf.close()
sf.close()
if fun:
print("***UPDATING MASTER (BINARY COPY)***")
copy(slave, master, "rb", answer=write_master)
else:
print("***UPDATING MASTER***")
copy(slave, master, "r", answer=write_master)
BUFSIZE = 16*1024
def identical(sf, mf):
while 1:
sd = sf.read(BUFSIZE)
md = mf.read(BUFSIZE)
if sd != md: return 0
if not sd: break
return 1
def mtime(f):
st = os.fstat(f.fileno())
return st[stat.ST_MTIME]
def funnychars(f):
while 1:
buf = f.read(BUFSIZE)
if not buf: break
if '\r' in buf or '\0' in buf: return 1
return 0
def copy(src, dst, rmode="rb", wmode="wb", answer='ask'):
print("copying", src)
print(" to", dst)
if not okay("okay to copy? ", answer):
return
f = open(src, rmode)
g = open(dst, wmode)
while 1:
buf = f.read(BUFSIZE)
if not buf: break
g.write(buf)
f.close()
g.close()
def raw_input(prompt):
sys.stdout.write(prompt)
sys.stdout.flush()
return sys.stdin.readline()
def okay(prompt, answer='ask'):
answer = answer.strip().lower()
if not answer or answer[0] not in 'ny':
answer = input(prompt)
answer = answer.strip().lower()
if not answer:
answer = default_answer
if answer[:1] == 'y':
return 1
if answer[:1] == 'n':
return 0
print("Yes or No please -- try again:")
return okay(prompt)
if __name__ == '__main__':
main()
| 5,960 | 211 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/dutree.py | #! /usr/bin/env python3
# Format du output in a tree shape
import os, sys, errno
def main():
p = os.popen('du ' + ' '.join(sys.argv[1:]), 'r')
total, d = None, {}
for line in p.readlines():
i = 0
while line[i] in '0123456789': i = i+1
size = eval(line[:i])
while line[i] in ' \t': i = i+1
filename = line[i:-1]
comps = filename.split('/')
if comps[0] == '': comps[0] = '/'
if comps[len(comps)-1] == '': del comps[len(comps)-1]
total, d = store(size, comps, total, d)
try:
display(total, d)
except IOError as e:
if e.errno != errno.EPIPE:
raise
def store(size, comps, total, d):
if comps == []:
return size, d
if comps[0] not in d:
d[comps[0]] = None, {}
t1, d1 = d[comps[0]]
d[comps[0]] = store(size, comps[1:], t1, d1)
return total, d
def display(total, d):
show(total, d, '')
def show(total, d, prefix):
if not d: return
list = []
sum = 0
for key in d.keys():
tsub, dsub = d[key]
list.append((tsub, key))
if tsub is not None: sum = sum + tsub
## if sum < total:
## list.append((total - sum, os.curdir))
list.sort()
list.reverse()
width = len(repr(list[0][0]))
for tsub, key in list:
if tsub is None:
psub = prefix
else:
print(prefix + repr(tsub).rjust(width) + ' ' + key)
psub = prefix + ' '*(width-1) + '|' + ' '*(len(key)+1)
if key in d:
show(tsub, d[key][1], psub)
if __name__ == '__main__':
main()
| 1,608 | 61 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/import_diagnostics.py | #!/usr/bin/env python3
"""Miscellaneous diagnostics for the import system"""
import sys
import argparse
from pprint import pprint
def _dump_state(args):
print(sys.version)
for name in args.attributes:
print("sys.{}:".format(name))
pprint(getattr(sys, name))
def _add_dump_args(cmd):
cmd.add_argument("attributes", metavar="ATTR", nargs="+",
help="sys module attribute to display")
COMMANDS = (
("dump", "Dump import state", _dump_state, _add_dump_args),
)
def _make_parser():
parser = argparse.ArgumentParser()
sub = parser.add_subparsers(title="Commands")
for name, description, implementation, add_args in COMMANDS:
cmd = sub.add_parser(name, help=description)
cmd.set_defaults(command=implementation)
add_args(cmd)
return parser
def main(args):
parser = _make_parser()
args = parser.parse_args(args)
return args.command(args)
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
| 999 | 38 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/cleanfuture.py | #! /usr/bin/env python3
"""cleanfuture [-d][-r][-v] path ...
-d Dry run. Analyze, but don't make any changes to, files.
-r Recurse. Search for all .py files in subdirectories too.
-v Verbose. Print informative msgs.
Search Python (.py) files for future statements, and remove the features
from such statements that are already mandatory in the version of Python
you're using.
Pass one or more file and/or directory paths. When a directory path, all
.py files within the directory will be examined, and, if the -r option is
given, likewise recursively for subdirectories.
Overwrites files in place, renaming the originals with a .bak extension. If
cleanfuture finds nothing to change, the file is left alone. If cleanfuture
does change a file, the changed file is a fixed-point (i.e., running
cleanfuture on the resulting .py file won't change it again, at least not
until you try it again with a later Python release).
Limitations: You can do these things, but this tool won't help you then:
+ A future statement cannot be mixed with any other statement on the same
physical line (separated by semicolon).
+ A future statement cannot contain an "as" clause.
Example: Assuming you're using Python 2.2, if a file containing
from __future__ import nested_scopes, generators
is analyzed by cleanfuture, the line is rewritten to
from __future__ import generators
because nested_scopes is no longer optional in 2.2 but generators is.
"""
import __future__
import tokenize
import os
import sys
dryrun = 0
recurse = 0
verbose = 0
def errprint(*args):
strings = map(str, args)
msg = ' '.join(strings)
if msg[-1:] != '\n':
msg += '\n'
sys.stderr.write(msg)
def main():
import getopt
global verbose, recurse, dryrun
try:
opts, args = getopt.getopt(sys.argv[1:], "drv")
except getopt.error as msg:
errprint(msg)
return
for o, a in opts:
if o == '-d':
dryrun += 1
elif o == '-r':
recurse += 1
elif o == '-v':
verbose += 1
if not args:
errprint("Usage:", __doc__)
return
for arg in args:
check(arg)
def check(file):
if os.path.isdir(file) and not os.path.islink(file):
if verbose:
print("listing directory", file)
names = os.listdir(file)
for name in names:
fullname = os.path.join(file, name)
if ((recurse and os.path.isdir(fullname) and
not os.path.islink(fullname))
or name.lower().endswith(".py")):
check(fullname)
return
if verbose:
print("checking", file, "...", end=' ')
try:
f = open(file)
except IOError as msg:
errprint("%r: I/O Error: %s" % (file, str(msg)))
return
ff = FutureFinder(f, file)
changed = ff.run()
if changed:
ff.gettherest()
f.close()
if changed:
if verbose:
print("changed.")
if dryrun:
print("But this is a dry run, so leaving it alone.")
for s, e, line in changed:
print("%r lines %d-%d" % (file, s+1, e+1))
for i in range(s, e+1):
print(ff.lines[i], end=' ')
if line is None:
print("-- deleted")
else:
print("-- change to:")
print(line, end=' ')
if not dryrun:
bak = file + ".bak"
if os.path.exists(bak):
os.remove(bak)
os.rename(file, bak)
if verbose:
print("renamed", file, "to", bak)
g = open(file, "w")
ff.write(g)
g.close()
if verbose:
print("wrote new", file)
else:
if verbose:
print("unchanged.")
class FutureFinder:
def __init__(self, f, fname):
self.f = f
self.fname = fname
self.ateof = 0
self.lines = [] # raw file lines
# List of (start_index, end_index, new_line) triples.
self.changed = []
# Line-getter for tokenize.
def getline(self):
if self.ateof:
return ""
line = self.f.readline()
if line == "":
self.ateof = 1
else:
self.lines.append(line)
return line
def run(self):
STRING = tokenize.STRING
NL = tokenize.NL
NEWLINE = tokenize.NEWLINE
COMMENT = tokenize.COMMENT
NAME = tokenize.NAME
OP = tokenize.OP
changed = self.changed
get = tokenize.generate_tokens(self.getline).__next__
type, token, (srow, scol), (erow, ecol), line = get()
# Chew up initial comments and blank lines (if any).
while type in (COMMENT, NL, NEWLINE):
type, token, (srow, scol), (erow, ecol), line = get()
# Chew up docstring (if any -- and it may be implicitly catenated!).
while type is STRING:
type, token, (srow, scol), (erow, ecol), line = get()
# Analyze the future stmts.
while 1:
# Chew up comments and blank lines (if any).
while type in (COMMENT, NL, NEWLINE):
type, token, (srow, scol), (erow, ecol), line = get()
if not (type is NAME and token == "from"):
break
startline = srow - 1 # tokenize is one-based
type, token, (srow, scol), (erow, ecol), line = get()
if not (type is NAME and token == "__future__"):
break
type, token, (srow, scol), (erow, ecol), line = get()
if not (type is NAME and token == "import"):
break
type, token, (srow, scol), (erow, ecol), line = get()
# Get the list of features.
features = []
while type is NAME:
features.append(token)
type, token, (srow, scol), (erow, ecol), line = get()
if not (type is OP and token == ','):
break
type, token, (srow, scol), (erow, ecol), line = get()
# A trailing comment?
comment = None
if type is COMMENT:
comment = token
type, token, (srow, scol), (erow, ecol), line = get()
if type is not NEWLINE:
errprint("Skipping file %r; can't parse line %d:\n%s" %
(self.fname, srow, line))
return []
endline = srow - 1
# Check for obsolete features.
okfeatures = []
for f in features:
object = getattr(__future__, f, None)
if object is None:
# A feature we don't know about yet -- leave it in.
# They'll get a compile-time error when they compile
# this program, but that's not our job to sort out.
okfeatures.append(f)
else:
released = object.getMandatoryRelease()
if released is None or released <= sys.version_info:
# Withdrawn or obsolete.
pass
else:
okfeatures.append(f)
# Rewrite the line if at least one future-feature is obsolete.
if len(okfeatures) < len(features):
if len(okfeatures) == 0:
line = None
else:
line = "from __future__ import "
line += ', '.join(okfeatures)
if comment is not None:
line += ' ' + comment
line += '\n'
changed.append((startline, endline, line))
# Loop back for more future statements.
return changed
def gettherest(self):
if self.ateof:
self.therest = ''
else:
self.therest = self.f.read()
def write(self, f):
changed = self.changed
assert changed
# Prevent calling this again.
self.changed = []
# Apply changes in reverse order.
changed.reverse()
for s, e, line in changed:
if line is None:
# pure deletion
del self.lines[s:e+1]
else:
self.lines[s:e+1] = [line]
f.writelines(self.lines)
# Copy over the remainder of the file.
if self.therest:
f.write(self.therest)
if __name__ == '__main__':
main()
| 8,623 | 277 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/get-remote-certificate.py | #!/usr/bin/env python3
#
# fetch the certificate that the server(s) are providing in PEM form
#
# args are HOST:PORT [, HOST:PORT...]
#
# By Bill Janssen.
import re
import os
import sys
import tempfile
def fetch_server_certificate (host, port):
def subproc(cmd):
from subprocess import Popen, PIPE, STDOUT
proc = Popen(cmd, stdout=PIPE, stderr=STDOUT, shell=True)
status = proc.wait()
output = proc.stdout.read()
return status, output
def strip_to_x509_cert(certfile_contents, outfile=None):
m = re.search(br"^([-]+BEGIN CERTIFICATE[-]+[\r]*\n"
br".*[\r]*^[-]+END CERTIFICATE[-]+)$",
certfile_contents, re.MULTILINE | re.DOTALL)
if not m:
return None
else:
tn = tempfile.mktemp()
fp = open(tn, "wb")
fp.write(m.group(1) + b"\n")
fp.close()
try:
tn2 = (outfile or tempfile.mktemp())
status, output = subproc(r'openssl x509 -in "%s" -out "%s"' %
(tn, tn2))
if status != 0:
raise RuntimeError('OpenSSL x509 failed with status %s and '
'output: %r' % (status, output))
fp = open(tn2, 'rb')
data = fp.read()
fp.close()
os.unlink(tn2)
return data
finally:
os.unlink(tn)
if sys.platform.startswith("win"):
tfile = tempfile.mktemp()
fp = open(tfile, "w")
fp.write("quit\n")
fp.close()
try:
status, output = subproc(
'openssl s_client -connect "%s:%s" -showcerts < "%s"' %
(host, port, tfile))
finally:
os.unlink(tfile)
else:
status, output = subproc(
'openssl s_client -connect "%s:%s" -showcerts < /dev/null' %
(host, port))
if status != 0:
raise RuntimeError('OpenSSL connect failed with status %s and '
'output: %r' % (status, output))
certtext = strip_to_x509_cert(output)
if not certtext:
raise ValueError("Invalid response received from server at %s:%s" %
(host, port))
return certtext
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.stderr.write(
"Usage: %s HOSTNAME:PORTNUMBER [, HOSTNAME:PORTNUMBER...]\n" %
sys.argv[0])
sys.exit(1)
for arg in sys.argv[1:]:
host, port = arg.split(":")
sys.stdout.buffer.write(fetch_server_certificate(host, int(port)))
sys.exit(0)
| 2,720 | 85 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/objgraph.py | #! /usr/bin/env python3
# objgraph
#
# Read "nm -o" input (on IRIX: "nm -Bo") of a set of libraries or modules
# and print various interesting listings, such as:
#
# - which names are used but not defined in the set (and used where),
# - which names are defined in the set (and where),
# - which modules use which other modules,
# - which modules are used by which other modules.
#
# Usage: objgraph [-cdu] [file] ...
# -c: print callers per objectfile
# -d: print callees per objectfile
# -u: print usage of undefined symbols
# If none of -cdu is specified, all are assumed.
# Use "nm -o" to generate the input (on IRIX: "nm -Bo"),
# e.g.: nm -o /lib/libc.a | objgraph
import sys
import os
import getopt
import re
# Types of symbols.
#
definitions = 'TRGDSBAEC'
externals = 'UV'
ignore = 'Nntrgdsbavuc'
# Regular expression to parse "nm -o" output.
#
matcher = re.compile('(.*):\t?........ (.) (.*)$')
# Store "item" in "dict" under "key".
# The dictionary maps keys to lists of items.
# If there is no list for the key yet, it is created.
#
def store(dict, key, item):
if key in dict:
dict[key].append(item)
else:
dict[key] = [item]
# Return a flattened version of a list of strings: the concatenation
# of its elements with intervening spaces.
#
def flat(list):
s = ''
for item in list:
s = s + ' ' + item
return s[1:]
# Global variables mapping defined/undefined names to files and back.
#
file2undef = {}
def2file = {}
file2def = {}
undef2file = {}
# Read one input file and merge the data into the tables.
# Argument is an open file.
#
def readinput(fp):
while 1:
s = fp.readline()
if not s:
break
# If you get any output from this line,
# it is probably caused by an unexpected input line:
if matcher.search(s) < 0: s; continue # Shouldn't happen
(ra, rb), (r1a, r1b), (r2a, r2b), (r3a, r3b) = matcher.regs[:4]
fn, name, type = s[r1a:r1b], s[r3a:r3b], s[r2a:r2b]
if type in definitions:
store(def2file, name, fn)
store(file2def, fn, name)
elif type in externals:
store(file2undef, fn, name)
store(undef2file, name, fn)
elif not type in ignore:
print(fn + ':' + name + ': unknown type ' + type)
# Print all names that were undefined in some module and where they are
# defined.
#
def printcallee():
flist = sorted(file2undef.keys())
for filename in flist:
print(filename + ':')
elist = file2undef[filename]
elist.sort()
for ext in elist:
if len(ext) >= 8:
tabs = '\t'
else:
tabs = '\t\t'
if ext not in def2file:
print('\t' + ext + tabs + ' *undefined')
else:
print('\t' + ext + tabs + flat(def2file[ext]))
# Print for each module the names of the other modules that use it.
#
def printcaller():
files = sorted(file2def.keys())
for filename in files:
callers = []
for label in file2def[filename]:
if label in undef2file:
callers = callers + undef2file[label]
if callers:
callers.sort()
print(filename + ':')
lastfn = ''
for fn in callers:
if fn != lastfn:
print('\t' + fn)
lastfn = fn
else:
print(filename + ': unused')
# Print undefined names and where they are used.
#
def printundef():
undefs = {}
for filename in list(file2undef.keys()):
for ext in file2undef[filename]:
if ext not in def2file:
store(undefs, ext, filename)
elist = sorted(undefs.keys())
for ext in elist:
print(ext + ':')
flist = sorted(undefs[ext])
for filename in flist:
print('\t' + filename)
# Print warning messages about names defined in more than one file.
#
def warndups():
savestdout = sys.stdout
sys.stdout = sys.stderr
names = sorted(def2file.keys())
for name in names:
if len(def2file[name]) > 1:
print('warning:', name, 'multiply defined:', end=' ')
print(flat(def2file[name]))
sys.stdout = savestdout
# Main program
#
def main():
try:
optlist, args = getopt.getopt(sys.argv[1:], 'cdu')
except getopt.error:
sys.stdout = sys.stderr
print('Usage:', os.path.basename(sys.argv[0]), end=' ')
print('[-cdu] [file] ...')
print('-c: print callers per objectfile')
print('-d: print callees per objectfile')
print('-u: print usage of undefined symbols')
print('If none of -cdu is specified, all are assumed.')
print('Use "nm -o" to generate the input (on IRIX: "nm -Bo"),')
print('e.g.: nm -o /lib/libc.a | objgraph')
return 1
optu = optc = optd = 0
for opt, void in optlist:
if opt == '-u':
optu = 1
elif opt == '-c':
optc = 1
elif opt == '-d':
optd = 1
if optu == optc == optd == 0:
optu = optc = optd = 1
if not args:
args = ['-']
for filename in args:
if filename == '-':
readinput(sys.stdin)
else:
readinput(open(filename, 'r'))
#
warndups()
#
more = (optu + optc + optd > 1)
if optd:
if more:
print('---------------All callees------------------')
printcallee()
if optu:
if more:
print('---------------Undefined callees------------')
printundef()
if optc:
if more:
print('---------------All Callers------------------')
printcaller()
return 0
# Call the main program.
# Use its return value as exit status.
# Catch interrupts to avoid stack trace.
#
if __name__ == '__main__':
try:
sys.exit(main())
except KeyboardInterrupt:
sys.exit(1)
| 5,980 | 211 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/pydoc3 | #!/usr/bin/env python3
import pydoc
if __name__ == '__main__':
pydoc.cli()
| 80 | 6 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/abitype.py | #!/usr/bin/env python3
# This script converts a C file to use the PEP 384 type definition API
# Usage: abitype.py < old_code > new_code
import re, sys
###### Replacement of PyTypeObject static instances ##############
# classify each token, giving it a one-letter code:
# S: static
# T: PyTypeObject
# I: ident
# W: whitespace
# =, {, }, ; : themselves
def classify():
res = []
for t,v in tokens:
if t == 'other' and v in "={};":
res.append(v)
elif t == 'ident':
if v == 'PyTypeObject':
res.append('T')
elif v == 'static':
res.append('S')
else:
res.append('I')
elif t == 'ws':
res.append('W')
else:
res.append('.')
return ''.join(res)
# Obtain a list of fields of a PyTypeObject, in declaration order,
# skipping ob_base
# All comments are dropped from the variable (which are typically
# just the slot names, anyway), and information is discarded whether
# the original type was static.
def get_fields(start, real_end):
pos = start
# static?
if tokens[pos][1] == 'static':
pos += 2
# PyTypeObject
pos += 2
# name
name = tokens[pos][1]
pos += 1
while tokens[pos][1] != '{':
pos += 1
pos += 1
# PyVarObject_HEAD_INIT
while tokens[pos][0] in ('ws', 'comment'):
pos += 1
if tokens[pos][1] != 'PyVarObject_HEAD_INIT':
raise Exception('%s has no PyVarObject_HEAD_INIT' % name)
while tokens[pos][1] != ')':
pos += 1
pos += 1
# field definitions: various tokens, comma-separated
fields = []
while True:
while tokens[pos][0] in ('ws', 'comment'):
pos += 1
end = pos
while tokens[end][1] not in ',}':
if tokens[end][1] == '(':
nesting = 1
while nesting:
end += 1
if tokens[end][1] == '(': nesting+=1
if tokens[end][1] == ')': nesting-=1
end += 1
assert end < real_end
# join field, excluding separator and trailing ws
end1 = end-1
while tokens[end1][0] in ('ws', 'comment'):
end1 -= 1
fields.append(''.join(t[1] for t in tokens[pos:end1+1]))
if tokens[end][1] == '}':
break
pos = end+1
return name, fields
# List of type slots as of Python 3.2, omitting ob_base
typeslots = [
'tp_name',
'tp_basicsize',
'tp_itemsize',
'tp_dealloc',
'tp_print',
'tp_getattr',
'tp_setattr',
'tp_reserved',
'tp_repr',
'tp_as_number',
'tp_as_sequence',
'tp_as_mapping',
'tp_hash',
'tp_call',
'tp_str',
'tp_getattro',
'tp_setattro',
'tp_as_buffer',
'tp_flags',
'tp_doc',
'tp_traverse',
'tp_clear',
'tp_richcompare',
'tp_weaklistoffset',
'tp_iter',
'iternextfunc',
'tp_methods',
'tp_members',
'tp_getset',
'tp_base',
'tp_dict',
'tp_descr_get',
'tp_descr_set',
'tp_dictoffset',
'tp_init',
'tp_alloc',
'tp_new',
'tp_free',
'tp_is_gc',
'tp_bases',
'tp_mro',
'tp_cache',
'tp_subclasses',
'tp_weaklist',
'tp_del',
'tp_version_tag',
]
# Generate a PyType_Spec definition
def make_slots(name, fields):
res = []
res.append('static PyType_Slot %s_slots[] = {' % name)
# defaults for spec
spec = { 'tp_itemsize':'0' }
for i, val in enumerate(fields):
if val.endswith('0'):
continue
if typeslots[i] in ('tp_name', 'tp_doc', 'tp_basicsize',
'tp_itemsize', 'tp_flags'):
spec[typeslots[i]] = val
continue
res.append(' {Py_%s, %s},' % (typeslots[i], val))
res.append('};')
res.append('static PyType_Spec %s_spec = {' % name)
res.append(' %s,' % spec['tp_name'])
res.append(' %s,' % spec['tp_basicsize'])
res.append(' %s,' % spec['tp_itemsize'])
res.append(' %s,' % spec['tp_flags'])
res.append(' %s_slots,' % name)
res.append('};\n')
return '\n'.join(res)
if __name__ == '__main__':
############ Simplistic C scanner ##################################
tokenizer = re.compile(
r"(?P<preproc>#.*\n)"
r"|(?P<comment>/\*.*?\*/)"
r"|(?P<ident>[a-zA-Z_][a-zA-Z0-9_]*)"
r"|(?P<ws>[ \t\n]+)"
r"|(?P<other>.)",
re.MULTILINE)
tokens = []
source = sys.stdin.read()
pos = 0
while pos != len(source):
m = tokenizer.match(source, pos)
tokens.append([m.lastgroup, m.group()])
pos += len(tokens[-1][1])
if tokens[-1][0] == 'preproc':
# continuation lines are considered
# only in preprocess statements
while tokens[-1][1].endswith('\\\n'):
nl = source.find('\n', pos)
if nl == -1:
line = source[pos:]
else:
line = source[pos:nl+1]
tokens[-1][1] += line
pos += len(line)
# Main loop: replace all static PyTypeObjects until
# there are none left.
while 1:
c = classify()
m = re.search('(SW)?TWIW?=W?{.*?};', c)
if not m:
break
start = m.start()
end = m.end()
name, fields = get_fields(start, end)
tokens[start:end] = [('',make_slots(name, fields))]
# Output result to stdout
for t, v in tokens:
sys.stdout.write(v)
| 5,572 | 203 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/README | This directory contains a collection of executable Python scripts that are
useful while building, extending or managing Python. Some (e.g., dutree or lll)
are also generally useful UNIX tools.
2to3 Main script for running the 2to3 conversion tool
abitype.py Converts a C file to use the PEP 384 type definition API
analyze_dxp.py Analyzes the result of sys.getdxp()
byext.py Print lines/words/chars stats of files by extension
byteyears.py Print product of a file's size and age
checkpyc.py Check presence and validity of ".pyc" files
cleanfuture.py Fix redundant Python __future__ statements
combinerefs.py A helper for analyzing PYTHONDUMPREFS output
copytime.py Copy one file's atime and mtime to another
crlf.py Change CRLF line endings to LF (Windows to Unix)
db2pickle.py Dump a database file to a pickle
diff.py Print file diffs in context, unified, or ndiff formats
dutree.py Format du(1) output as a tree sorted by size
eptags.py Create Emacs TAGS file for Python modules
finddiv.py A grep-like tool that looks for division operators
findlinksto.py Recursively find symbolic links to a given path prefix
findnocoding.py Find source files which need an encoding declaration
find_recursionlimit.py Find the maximum recursion limit on this machine
find-uname.py Look for the given arguments in the sets of all Unicode names
fixcid.py Massive identifier substitution on C source files
fixdiv.py Tool to fix division operators.
fixheader.py Add some cpp magic to a C include file
fixnotice.py Fix the copyright notice in source files
fixps.py Fix Python scripts' first line (if #!)
ftpmirror.py FTP mirror script
get-remote-certificate.py Fetch the certificate that the server(s) are providing in PEM form
google.py Open a webbrowser with Google
gprof2html.py Transform gprof(1) output into useful HTML
h2py.py Translate #define's into Python assignments
highlight.py Python syntax highlighting with HTML output
idle3 Main program to start IDLE
ifdef.py Remove #if(n)def groups from C sources
import_diagnostics.py Miscellaneous diagnostics for the import system
lfcr.py Change LF line endings to CRLF (Unix to Windows)
linktree.py Make a copy of a tree with links to original files
lll.py Find and list symbolic links in current directory
mailerdaemon.py Parse error messages from mailer daemons (Sjoerd&Jack)
make_ctype.py Generate ctype.h replacement in stringobject.c
md5sum.py Print MD5 checksums of argument files
mkreal.py Turn a symbolic link into a real file or directory
ndiff.py Intelligent diff between text files (Tim Peters)
nm2def.py Create a template for PC/python_nt.def (Marc Lemburg)
objgraph.py Print object graph from nm output on a library
parseentities.py Utility for parsing HTML entity definitions
parse_html5_entities.py Utility for parsing HTML5 entity definitions
patchcheck.py Perform common checks and cleanup before committing
pathfix.py Change #!/usr/local/bin/python into something else
pdeps.py Print dependencies between Python modules
pickle2db.py Load a pickle generated by db2pickle.py to a database
pindent.py Indent Python code, giving block-closing comments
ptags.py Create vi tags file for Python modules
pydoc3 Python documentation browser
pysource.py Find Python source files
reindent.py Change .py files to use 4-space indents
reindent-rst.py Fix-up reStructuredText file whitespace
rgrep.py Reverse grep through a file (useful for big logfiles)
run_tests.py Run the test suite with more sensible default options
serve.py Small wsgiref-based web server, used in make serve in Doc
suff.py Sort a list of files by suffix
svneol.py Set svn:eol-style on all files in directory
texi2html.py Convert GNU texinfo files into HTML
treesync.py Synchronize source trees (very idiosyncratic)
untabify.py Replace tabs with spaces in argument files
which.py Find a program in $PATH
win_add2path.py Add Python to the search path on Windows
| 4,781 | 70 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/which.py | #! /usr/bin/env python3
# Variant of "which".
# On stderr, near and total misses are reported.
# '-l<flags>' argument adds ls -l<flags> of each file found.
import sys
if sys.path[0] in (".", ""): del sys.path[0]
import sys, os
from stat import *
def msg(str):
sys.stderr.write(str + '\n')
def main():
pathlist = os.environ['PATH'].split(os.pathsep)
sts = 0
longlist = ''
if sys.argv[1:] and sys.argv[1][:2] == '-l':
longlist = sys.argv[1]
del sys.argv[1]
for prog in sys.argv[1:]:
ident = ()
for dir in pathlist:
filename = os.path.join(dir, prog)
try:
st = os.stat(filename)
except OSError:
continue
if not S_ISREG(st[ST_MODE]):
msg(filename + ': not a disk file')
else:
mode = S_IMODE(st[ST_MODE])
if mode & 0o111:
if not ident:
print(filename)
ident = st[:3]
else:
if st[:3] == ident:
s = 'same as: '
else:
s = 'also: '
msg(s + filename)
else:
msg(filename + ': not executable')
if longlist:
sts = os.system('ls ' + longlist + ' ' + filename)
if sts: msg('"ls -l" exit status: ' + repr(sts))
if not ident:
msg(prog + ': not found')
sts = 1
sys.exit(sts)
if __name__ == '__main__':
main()
| 1,633 | 61 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/diff.py | #!/usr/bin/env python3
""" Command line interface to difflib.py providing diffs in four formats:
* ndiff: lists every line and highlights interline changes.
* context: highlights clusters of changes in a before/after format.
* unified: highlights clusters of changes in an inline format.
* html: generates side by side comparison with change highlights.
"""
import sys, os, difflib, argparse
from datetime import datetime, timezone
def file_mtime(path):
t = datetime.fromtimestamp(os.stat(path).st_mtime,
timezone.utc)
return t.astimezone().isoformat()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-c', action='store_true', default=False,
help='Produce a context format diff (default)')
parser.add_argument('-u', action='store_true', default=False,
help='Produce a unified format diff')
parser.add_argument('-m', action='store_true', default=False,
help='Produce HTML side by side diff '
'(can use -c and -l in conjunction)')
parser.add_argument('-n', action='store_true', default=False,
help='Produce a ndiff format diff')
parser.add_argument('-l', '--lines', type=int, default=3,
help='Set number of context lines (default 3)')
parser.add_argument('fromfile')
parser.add_argument('tofile')
options = parser.parse_args()
n = options.lines
fromfile = options.fromfile
tofile = options.tofile
fromdate = file_mtime(fromfile)
todate = file_mtime(tofile)
with open(fromfile) as ff:
fromlines = ff.readlines()
with open(tofile) as tf:
tolines = tf.readlines()
if options.u:
diff = difflib.unified_diff(fromlines, tolines, fromfile, tofile, fromdate, todate, n=n)
elif options.n:
diff = difflib.ndiff(fromlines, tolines)
elif options.m:
diff = difflib.HtmlDiff().make_file(fromlines,tolines,fromfile,tofile,context=options.c,numlines=n)
else:
diff = difflib.context_diff(fromlines, tolines, fromfile, tofile, fromdate, todate, n=n)
sys.stdout.writelines(diff)
if __name__ == '__main__':
main()
| 2,256 | 61 | jart/cosmopolitan | false |
cosmopolitan/third_party/python/Tools/scripts/rgrep.py | #! /usr/bin/env python3
"""Reverse grep.
Usage: rgrep [-i] pattern file
"""
import sys
import re
import getopt
def main():
bufsize = 64 * 1024
reflags = 0
opts, args = getopt.getopt(sys.argv[1:], "i")
for o, a in opts:
if o == '-i':
reflags = reflags | re.IGNORECASE
if len(args) < 2:
usage("not enough arguments")
if len(args) > 2:
usage("exactly one file argument required")
pattern, filename = args
try:
prog = re.compile(pattern, reflags)
except re.error as msg:
usage("error in regular expression: %s" % msg)
try:
f = open(filename)
except IOError as msg:
usage("can't open %r: %s" % (filename, msg), 1)
f.seek(0, 2)
pos = f.tell()
leftover = None
while pos > 0:
size = min(pos, bufsize)
pos = pos - size
f.seek(pos)
buffer = f.read(size)
lines = buffer.split("\n")
del buffer
if leftover is None:
if not lines[-1]:
del lines[-1]
else:
lines[-1] = lines[-1] + leftover
if pos > 0:
leftover = lines[0]
del lines[0]
else:
leftover = None
for line in reversed(lines):
if prog.search(line):
print(line)
def usage(msg, code=2):
sys.stdout = sys.stderr
print(msg)
print(__doc__)
sys.exit(code)
if __name__ == '__main__':
main()
| 1,476 | 67 | jart/cosmopolitan | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.