7 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_SC__ZYYY_invlist[] = {  /* for EBCDIC 037 */
	370,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2B9,
	0x2E0,
	0x2E5,
	0x2EA,
	0x2EC,
	0x300,
	0x374,
	0x375,
	0x37E,
	0x37F,
	0x385,
	0x386,
	0x387,
	0x388,
	0x605,
	0x606,
	0x60C,
	0x60D,
	0x61B,
	0x61C,
	0x61F,
	0x620,
	0x640,
	0x641,
	0x6DD,
	0x6DE,
	0x8E2,
	0x8E3,
	0x964,
	0x966,
	0xE3F,
	0xE40,
	0xFD5,
	0xFD9,
	0x10FB,
	0x10FC,
	0x16EB,
	0x16EE,
	0x1735,
	0x1737,
	0x1802,
	0x1804,
	0x1805,
	0x1806,
	0x1CD3,
	0x1CD4,
	0x1CE1,
	0x1CE2,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF8,
	0x1CFA,
	0x1CFB,
	0x2000,
	0x200C,
	0x200E,
	0x2065,
	0x2066,
	0x2071,
	0x2074,
	0x207F,
	0x2080,
	0x208F,
	0x20A0,
	0x20C1,
	0x2100,
	0x2126,
	0x2127,
	0x212A,
	0x212C,
	0x2132,
	0x2133,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x218C,
	0x2190,
	0x2427,
	0x2440,
	0x244B,
	0x2460,
	0x2800,
	0x2900,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2E00,
	0x2E5E,
	0x2FF0,
	0x2FFC,
	0x3000,
	0x3005,
	0x3006,
	0x3007,
	0x3008,
	0x3021,
	0x3030,
	0x3038,
	0x303C,
	0x3040,
	0x309B,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FD,
	0x3190,
	0x31A0,
	0x31C0,
	0x31E4,
	0x3220,
	0x3260,
	0x327F,
	0x32D0,
	0x32FF,
	0x3300,
	0x3358,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA700,
	0xA722,
	0xA788,
	0xA78B,
	0xA830,
	0xA83A,
	0xA92E,
	0xA92F,
	0xA9CF,
	0xA9D0,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFD3E,
	0xFD40,
	0xFE10,
	0xFE1A,
	0xFE30,
	0xFE53,
	0xFE54,
	0xFE67,
	0xFE68,
	0xFE6C,
	0xFEFF,
	0xFF00,
	0xFF01,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFF70,
	0xFF71,
	0xFF9E,
	0xFFA0,
	0xFFE0,
	0xFFE7,
	0xFFE8,
	0xFFEF,
	0xFFF9,
	0xFFFE,
	0x10100,
	0x10103,
	0x10107,
	0x10134,
	0x10137,
	0x10140,
	0x10190,
	0x1019D,
	0x101D0,
	0x101FD,
	0x102E1,
	0x102FC,
	0x1BCA0,
	0x1BCA4,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D167,
	0x1D16A,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D2E0,
	0x1D2F4,
	0x1D300,
	0x1D357,
	0x1D360,
	0x1D379,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1EC71,
	0x1ECB5,
	0x1ED01,
	0x1ED3E,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F100,
	0x1F1AE,
	0x1F1E6,
	0x1F200,
	0x1F201,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F250,
	0x1F252,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_SD_invlist[] = {  /* for ASCII/Latin1 */
	65,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x69,
	0x6B,
	0x12F,
	0x130,
	0x249,
	0x24A,
	0x268,
	0x269,
	0x29D,
	0x29E,
	0x2B2,
	0x2B3,
	0x3F3,
	0x3F4,
	0x456,
	0x457,
	0x458,
	0x459,
	0x1D62,
	0x1D63,
	0x1D96,
	0x1D97,
	0x1DA4,
	0x1DA5,
	0x1DA8,
	0x1DA9,
	0x1E2D,
	0x1E2E,
	0x1ECB,
	0x1ECC,
	0x2071,
	0x2072,
	0x2148,
	0x214A,
	0x2C7C,
	0x2C7D,
	0x1D422,
	0x1D424,
	0x1D456,
	0x1D458,
	0x1D48A,
	0x1D48C,
	0x1D4BE,
	0x1D4C0,
	0x1D4F2,
	0x1D4F4,
	0x1D526,
	0x1D528,
	0x1D55A,
	0x1D55C,
	0x1D58E,
	0x1D590,
	0x1D5C2,
	0x1D5C4,
	0x1D5F6,
	0x1D5F8,
	0x1D62A,
	0x1D62C,
	0x1D65E,
	0x1D660,
	0x1D692,
	0x1D694,
	0x1DF1A,
	0x1DF1B
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_SD_invlist[] = {  /* for EBCDIC 1047 */
	67,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x89,
	0x8A,
	0x91,
	0x92,
	0x12F,
	0x130,
	0x249,
	0x24A,
	0x268,
	0x269,
	0x29D,
	0x29E,
	0x2B2,
	0x2B3,
	0x3F3,
	0x3F4,
	0x456,
	0x457,
	0x458,
	0x459,
	0x1D62,
	0x1D63,
	0x1D96,
	0x1D97,
	0x1DA4,
	0x1DA5,
	0x1DA8,
	0x1DA9,
	0x1E2D,
	0x1E2E,
	0x1ECB,
	0x1ECC,
	0x2071,
	0x2072,
	0x2148,
	0x214A,
	0x2C7C,
	0x2C7D,
	0x1D422,
	0x1D424,
	0x1D456,
	0x1D458,
	0x1D48A,
	0x1D48C,
	0x1D4BE,
	0x1D4C0,
	0x1D4F2,
	0x1D4F4,
	0x1D526,
	0x1D528,
	0x1D55A,
	0x1D55C,
	0x1D58E,
	0x1D590,
	0x1D5C2,
	0x1D5C4,
	0x1D5F6,
	0x1D5F8,
	0x1D62A,
	0x1D62C,
	0x1D65E,
	0x1D660,
	0x1D692,
	0x1D694,
	0x1DF1A,
	0x1DF1B
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_SD_invlist[] = {  /* for EBCDIC 037 */
	67,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x89,
	0x8A,
	0x91,
	0x92,
	0x12F,
	0x130,
	0x249,
	0x24A,
	0x268,
	0x269,
	0x29D,
	0x29E,
	0x2B2,
	0x2B3,
	0x3F3,
	0x3F4,
	0x456,
	0x457,
	0x458,
	0x459,
	0x1D62,
	0x1D63,
	0x1D96,
	0x1D97,
	0x1DA4,
	0x1DA5,
	0x1DA8,
	0x1DA9,
	0x1E2D,
	0x1E2E,
	0x1ECB,
	0x1ECC,
	0x2071,
	0x2072,
	0x2148,
	0x214A,
	0x2C7C,
	0x2C7D,
	0x1D422,
	0x1D424,
	0x1D456,
	0x1D458,
	0x1D48A,
	0x1D48C,
	0x1D4BE,
	0x1D4C0,
	0x1D4F2,
	0x1D4F4,
	0x1D526,
	0x1D528,
	0x1D55A,
	0x1D55C,
	0x1D58E,
	0x1D590,
	0x1D5C2,
	0x1D5C4,
	0x1D5F6,
	0x1D5F8,
	0x1D62A,
	0x1D62C,
	0x1D65E,
	0x1D660,
	0x1D692,
	0x1D694,
	0x1DF1A,
	0x1DF1B
};

#  endif	/* EBCDIC 037 */

static const UV UNI_SGNW_invlist[] = {  /* for all charsets */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1D800,
	0x1DA8C,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0
};

static const UV UNI_SHAW_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x10450,
	0x10480
};

static const UV UNI_SHORTHANDFORMATCONTROLS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1BCA0,
	0x1BCB0
};

static const UV UNI_SHRD_invlist[] = {  /* for all charsets */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x951,
	0x952,
	0x1CD7,
	0x1CD8,
	0x1CD9,
	0x1CDA,
	0x1CDC,
	0x1CDE,
	0x1CE0,
	0x1CE1,
	0x11180,
	0x111E0
};

static const UV UNI_SIDD_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x11580,
	0x115B6,
	0x115B8,
	0x115DE
};

static const UV UNI_SIND_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x964,
	0x966,
	0xA830,
	0xA83A,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA
};

static const UV UNI_SINH_invlist[] = {  /* for all charsets */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x964,
	0x966,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF5,
	0x111E1,
	0x111F5
};

static const UV UNI_SINHALAARCHAICNUMBERS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x111E0,
	0x11200
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_SK_invlist[] = {  /* for ASCII/Latin1 */
	63,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5E,
	0x5F,
	0x60,
	0x61,
	0xA8,
	0xA9,
	0xAF,
	0xB0,
	0xB4,
	0xB5,
	0xB8,
	0xB9,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x384,
	0x386,
	0x888,
	0x889,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FCD,
	0x1FD0,
	0x1FDD,
	0x1FE0,
	0x1FED,
	0x1FF0,
	0x1FFD,
	0x1FFF,
	0x309B,
	0x309D,
	0xA700,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFBB2,
	0xFBC3,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFFE3,
	0xFFE4,
	0x1F3FB,
	0x1F400
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_SK_invlist[] = {  /* for EBCDIC 1047 */
	61,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5F,
	0x60,
	0x79,
	0x7A,
	0x9D,
	0x9E,
	0xBB,
	0xBD,
	0xBE,
	0xBF,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x384,
	0x386,
	0x888,
	0x889,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FCD,
	0x1FD0,
	0x1FDD,
	0x1FE0,
	0x1FED,
	0x1FF0,
	0x1FFD,
	0x1FFF,
	0x309B,
	0x309D,
	0xA700,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFBB2,
	0xFBC3,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFFE3,
	0xFFE4,
	0x1F3FB,
	0x1F400
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_SK_invlist[] = {  /* for EBCDIC 037 */
	59,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x79,
	0x7A,
	0x9D,
	0x9E,
	0xB0,
	0xB1,
	0xBC,
	0xBF,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x384,
	0x386,
	0x888,
	0x889,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FCD,
	0x1FD0,
	0x1FDD,
	0x1FE0,
	0x1FED,
	0x1FF0,
	0x1FFD,
	0x1FFF,
	0x309B,
	0x309D,
	0xA700,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFBB2,
	0xFBC3,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFFE3,
	0xFFE4,
	0x1F3FB,
	0x1F400
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_SM_invlist[] = {  /* for ASCII/Latin1 */
	129,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2B,
	0x2C,
	0x3C,
	0x3F,
	0x7C,
	0x7D,
	0x7E,
	0x7F,
	0xAC,
	0xAD,
	0xB1,
	0xB2,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x3F6,
	0x3F7,
	0x606,
	0x609,
	0x2044,
	0x2045,
	0x2052,
	0x2053,
	0x207A,
	0x207D,
	0x208A,
	0x208D,
	0x2118,
	0x2119,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x2190,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2320,
	0x2322,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x27C0,
	0x27C5,
	0x27C7,
	0x27E6,
	0x27F0,
	0x2800,
	0x2900,
	0x2983,
	0x2999,
	0x29D8,
	0x29DC,
	0x29FC,
	0x29FE,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0xFB29,
	0xFB2A,
	0xFE62,
	0xFE63,
	0xFE64,
	0xFE67,
	0xFF0B,
	0xFF0C,
	0xFF1C,
	0xFF1F,
	0xFF5C,
	0xFF5D,
	0xFF5E,
	0xFF5F,
	0xFFE2,
	0xFFE3,
	0xFFE9,
	0xFFED,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1EEF0,
	0x1EEF2
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_SM_invlist[] = {  /* for EBCDIC 1047 */
	131,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4C,
	0x4D,
	0x4E,
	0x50,
	0x6E,
	0x6F,
	0x7E,
	0x7F,
	0x8F,
	0x90,
	0xA1,
	0xA2,
	0xB0,
	0xB1,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x3F6,
	0x3F7,
	0x606,
	0x609,
	0x2044,
	0x2045,
	0x2052,
	0x2053,
	0x207A,
	0x207D,
	0x208A,
	0x208D,
	0x2118,
	0x2119,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x2190,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2320,
	0x2322,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x27C0,
	0x27C5,
	0x27C7,
	0x27E6,
	0x27F0,
	0x2800,
	0x2900,
	0x2983,
	0x2999,
	0x29D8,
	0x29DC,
	0x29FC,
	0x29FE,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0xFB29,
	0xFB2A,
	0xFE62,
	0xFE63,
	0xFE64,
	0xFE67,
	0xFF0B,
	0xFF0C,
	0xFF1C,
	0xFF1F,
	0xFF5C,
	0xFF5D,
	0xFF5E,
	0xFF5F,
	0xFFE2,
	0xFFE3,
	0xFFE9,
	0xFFED,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1EEF0,
	0x1EEF2
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_SM_invlist[] = {  /* for EBCDIC 037 */
	131,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4C,
	0x4D,
	0x4E,
	0x50,
	0x5F,
	0x60,
	0x6E,
	0x6F,
	0x7E,
	0x7F,
	0x8F,
	0x90,
	0xA1,
	0xA2,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x3F6,
	0x3F7,
	0x606,
	0x609,
	0x2044,
	0x2045,
	0x2052,
	0x2053,
	0x207A,
	0x207D,
	0x208A,
	0x208D,
	0x2118,
	0x2119,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x2190,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2320,
	0x2322,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x27C0,
	0x27C5,
	0x27C7,
	0x27E6,
	0x27F0,
	0x2800,
	0x2900,
	0x2983,
	0x2999,
	0x29D8,
	0x29DC,
	0x29FC,
	0x29FE,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0xFB29,
	0xFB2A,
	0xFE62,
	0xFE63,
	0xFE64,
	0xFE67,
	0xFF0B,
	0xFF0C,
	0xFF1C,
	0xFF1F,
	0xFF5C,
	0xFF5D,
	0xFF5E,
	0xFF5F,
	0xFFE2,
	0xFFE3,
	0xFFE9,
	0xFFED,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1EEF0,
	0x1EEF2
};

#  endif	/* EBCDIC 037 */

static const UV UNI_SMALLFORMS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xFE50,
	0xFE70
};

static const UV UNI_SMALLKANAEXT_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1B130,
	0x1B170
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_SO_invlist[] = {  /* for ASCII/Latin1 */
	373,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA6,
	0xA7,
	0xA9,
	0xAA,
	0xAE,
	0xAF,
	0xB0,
	0xB1,
	0x482,
	0x483,
	0x58D,
	0x58F,
	0x60E,
	0x610,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x7F6,
	0x7F7,
	0x9FA,
	0x9FB,
	0xB70,
	0xB71,
	0xBF3,
	0xBF9,
	0xBFA,
	0xBFB,
	0xC7F,
	0xC80,
	0xD4F,
	0xD50,
	0xD79,
	0xD7A,
	0xF01,
	0xF04,
	0xF13,
	0xF14,
	0xF15,
	0xF18,
	0xF1A,
	0xF20,
	0xF34,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xFBE,
	0xFC6,
	0xFC7,
	0xFCD,
	0xFCE,
	0xFD0,
	0xFD5,
	0xFD9,
	0x109E,
	0x10A0,
	0x1390,
	0x139A,
	0x166D,
	0x166E,
	0x1940,
	0x1941,
	0x19DE,
	0x1A00,
	0x1B61,
	0x1B6B,
	0x1B74,
	0x1B7D,
	0x2100,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x214A,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x2150,
	0x218A,
	0x218C,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2322,
	0x2329,
	0x232B,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x2427,
	0x2440,
	0x244B,
	0x249C,
	0x24EA,
	0x2500,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x2768,
	0x2794,
	0x27C0,
	0x2800,
	0x2900,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2E50,
	0x2E52,
	0x2E80,
	0x2E9A,
	0x2E9B,
	0x2EF4,
	0x2F00,
	0x2FD6,
	0x2FF0,
	0x2FFC,
	0x3004,
	0x3005,
	0x3012,
	0x3014,
	0x3020,
	0x3021,
	0x3036,
	0x3038,
	0x303E,
	0x3040,
	0x3190,
	0x3192,
	0x3196,
	0x31A0,
	0x31C0,
	0x31E4,
	0x3200,
	0x321F,
	0x322A,
	0x3248,
	0x3250,
	0x3251,
	0x3260,
	0x3280,
	0x328A,
	0x32B1,
	0x32C0,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA490,
	0xA4C7,
	0xA828,
	0xA82C,
	0xA836,
	0xA838,
	0xA839,
	0xA83A,
	0xAA77,
	0xAA7A,
	0xFD40,
	0xFD50,
	0xFDCF,
	0xFDD0,
	0xFDFD,
	0xFE00,
	0xFFE4,
	0xFFE5,
	0xFFE8,
	0xFFE9,
	0xFFED,
	0xFFEF,
	0xFFFC,
	0xFFFE,
	0x10137,
	0x10140,
	0x10179,
	0x1018A,
	0x1018C,
	0x1018F,
	0x10190,
	0x1019D,
	0x101A0,
	0x101A1,
	0x101D0,
	0x101FD,
	0x10877,
	0x10879,
	0x10AC8,
	0x10AC9,
	0x1173F,
	0x11740,
	0x11FD5,
	0x11FDD,
	0x11FE1,
	0x11FF2,
	0x16B3C,
	0x16B40,
	0x16B45,
	0x16B46,
	0x1BC9C,
	0x1BC9D,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D200,
	0x1D242,
	0x1D245,
	0x1D246,
	0x1D300,
	0x1D357,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA87,
	0x1E14F,
	0x1E150,
	0x1ECAC,
	0x1ECAD,
	0x1ED2E,
	0x1ED2F,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F10D,
	0x1F1AE,
	0x1F1E6,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F250,
	0x1F252,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F3FB,
	0x1F400,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_SO_invlist[] = {  /* for EBCDIC 1047 */
	373,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x6A,
	0x6B,
	0x90,
	0x91,
	0xAF,
	0xB0,
	0xB4,
	0xB5,
	0x482,
	0x483,
	0x58D,
	0x58F,
	0x60E,
	0x610,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x7F6,
	0x7F7,
	0x9FA,
	0x9FB,
	0xB70,
	0xB71,
	0xBF3,
	0xBF9,
	0xBFA,
	0xBFB,
	0xC7F,
	0xC80,
	0xD4F,
	0xD50,
	0xD79,
	0xD7A,
	0xF01,
	0xF04,
	0xF13,
	0xF14,
	0xF15,
	0xF18,
	0xF1A,
	0xF20,
	0xF34,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xFBE,
	0xFC6,
	0xFC7,
	0xFCD,
	0xFCE,
	0xFD0,
	0xFD5,
	0xFD9,
	0x109E,
	0x10A0,
	0x1390,
	0x139A,
	0x166D,
	0x166E,
	0x1940,
	0x1941,
	0x19DE,
	0x1A00,
	0x1B61,
	0x1B6B,
	0x1B74,
	0x1B7D,
	0x2100,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x214A,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x2150,
	0x218A,
	0x218C,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2322,
	0x2329,
	0x232B,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x2427,
	0x2440,
	0x244B,
	0x249C,
	0x24EA,
	0x2500,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x2768,
	0x2794,
	0x27C0,
	0x2800,
	0x2900,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2E50,
	0x2E52,
	0x2E80,
	0x2E9A,
	0x2E9B,
	0x2EF4,
	0x2F00,
	0x2FD6,
	0x2FF0,
	0x2FFC,
	0x3004,
	0x3005,
	0x3012,
	0x3014,
	0x3020,
	0x3021,
	0x3036,
	0x3038,
	0x303E,
	0x3040,
	0x3190,
	0x3192,
	0x3196,
	0x31A0,
	0x31C0,
	0x31E4,
	0x3200,
	0x321F,
	0x322A,
	0x3248,
	0x3250,
	0x3251,
	0x3260,
	0x3280,
	0x328A,
	0x32B1,
	0x32C0,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA490,
	0xA4C7,
	0xA828,
	0xA82C,
	0xA836,
	0xA838,
	0xA839,
	0xA83A,
	0xAA77,
	0xAA7A,
	0xFD40,
	0xFD50,
	0xFDCF,
	0xFDD0,
	0xFDFD,
	0xFE00,
	0xFFE4,
	0xFFE5,
	0xFFE8,
	0xFFE9,
	0xFFED,
	0xFFEF,
	0xFFFC,
	0xFFFE,
	0x10137,
	0x10140,
	0x10179,
	0x1018A,
	0x1018C,
	0x1018F,
	0x10190,
	0x1019D,
	0x101A0,
	0x101A1,
	0x101D0,
	0x101FD,
	0x10877,
	0x10879,
	0x10AC8,
	0x10AC9,
	0x1173F,
	0x11740,
	0x11FD5,
	0x11FDD,
	0x11FE1,
	0x11FF2,
	0x16B3C,
	0x16B40,
	0x16B45,
	0x16B46,
	0x1BC9C,
	0x1BC9D,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D200,
	0x1D242,
	0x1D245,
	0x1D246,
	0x1D300,
	0x1D357,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA87,
	0x1E14F,
	0x1E150,
	0x1ECAC,
	0x1ECAD,
	0x1ED2E,
	0x1ED2F,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F10D,
	0x1F1AE,
	0x1F1E6,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F250,
	0x1F252,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F3FB,
	0x1F400,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_SO_invlist[] = {  /* for EBCDIC 037 */
	373,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x6A,
	0x6B,
	0x90,
	0x91,
	0xAF,
	0xB0,
	0xB4,
	0xB5,
	0x482,
	0x483,
	0x58D,
	0x58F,
	0x60E,
	0x610,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x7F6,
	0x7F7,
	0x9FA,
	0x9FB,
	0xB70,
	0xB71,
	0xBF3,
	0xBF9,
	0xBFA,
	0xBFB,
	0xC7F,
	0xC80,
	0xD4F,
	0xD50,
	0xD79,
	0xD7A,
	0xF01,
	0xF04,
	0xF13,
	0xF14,
	0xF15,
	0xF18,
	0xF1A,
	0xF20,
	0xF34,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xFBE,
	0xFC6,
	0xFC7,
	0xFCD,
	0xFCE,
	0xFD0,
	0xFD5,
	0xFD9,
	0x109E,
	0x10A0,
	0x1390,
	0x139A,
	0x166D,
	0x166E,
	0x1940,
	0x1941,
	0x19DE,
	0x1A00,
	0x1B61,
	0x1B6B,
	0x1B74,
	0x1B7D,
	0x2100,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x214A,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x2150,
	0x218A,
	0x218C,
	0x2195,
	0x219A,
	0x219C,
	0x21A0,
	0x21A1,
	0x21A3,
	0x21A4,
	0x21A6,
	0x21A7,
	0x21AE,
	0x21AF,
	0x21CE,
	0x21D0,
	0x21D2,
	0x21D3,
	0x21D4,
	0x21D5,
	0x21F4,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2322,
	0x2329,
	0x232B,
	0x237C,
	0x237D,
	0x239B,
	0x23B4,
	0x23DC,
	0x23E2,
	0x2427,
	0x2440,
	0x244B,
	0x249C,
	0x24EA,
	0x2500,
	0x25B7,
	0x25B8,
	0x25C1,
	0x25C2,
	0x25F8,
	0x2600,
	0x266F,
	0x2670,
	0x2768,
	0x2794,
	0x27C0,
	0x2800,
	0x2900,
	0x2B00,
	0x2B30,
	0x2B45,
	0x2B47,
	0x2B4D,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2E50,
	0x2E52,
	0x2E80,
	0x2E9A,
	0x2E9B,
	0x2EF4,
	0x2F00,
	0x2FD6,
	0x2FF0,
	0x2FFC,
	0x3004,
	0x3005,
	0x3012,
	0x3014,
	0x3020,
	0x3021,
	0x3036,
	0x3038,
	0x303E,
	0x3040,
	0x3190,
	0x3192,
	0x3196,
	0x31A0,
	0x31C0,
	0x31E4,
	0x3200,
	0x321F,
	0x322A,
	0x3248,
	0x3250,
	0x3251,
	0x3260,
	0x3280,
	0x328A,
	0x32B1,
	0x32C0,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA490,
	0xA4C7,
	0xA828,
	0xA82C,
	0xA836,
	0xA838,
	0xA839,
	0xA83A,
	0xAA77,
	0xAA7A,
	0xFD40,
	0xFD50,
	0xFDCF,
	0xFDD0,
	0xFDFD,
	0xFE00,
	0xFFE4,
	0xFFE5,
	0xFFE8,
	0xFFE9,
	0xFFED,
	0xFFEF,
	0xFFFC,
	0xFFFE,
	0x10137,
	0x10140,
	0x10179,
	0x1018A,
	0x1018C,
	0x1018F,
	0x10190,
	0x1019D,
	0x101A0,
	0x101A1,
	0x101D0,
	0x101FD,
	0x10877,
	0x10879,
	0x10AC8,
	0x10AC9,
	0x1173F,
	0x11740,
	0x11FD5,
	0x11FDD,
	0x11FE1,
	0x11FF2,
	0x16B3C,
	0x16B40,
	0x16B45,
	0x16B46,
	0x1BC9C,
	0x1BC9D,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D200,
	0x1D242,
	0x1D245,
	0x1D246,
	0x1D300,
	0x1D357,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA87,
	0x1E14F,
	0x1E150,
	0x1ECAC,
	0x1ECAD,
	0x1ED2E,
	0x1ED2F,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F10D,
	0x1F1AE,
	0x1F1E6,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F250,
	0x1F252,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F3FB,
	0x1F400,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB
};

#  endif	/* EBCDIC 037 */

static const UV UNI_SOGD_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x640,
	0x641,
	0x10F30,
	0x10F5A
};

static const UV UNI_SOGO_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x10F00,
	0x10F28
};

static const UV UNI_SORA_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA
};

static const UV UNI_SOYO_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x11A50,
	0x11AA3
};

static const UV UNI_SPECIALS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xFFF0,
	0x10000
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_STERM_invlist[] = {  /* for ASCII/Latin1 */
	159,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x21,
	0x22,
	0x2E,
	0x2F,
	0x3F,
	0x40,
	0x589,
	0x58A,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x703,
	0x7F9,
	0x7FA,
	0x837,
	0x838,
	0x839,
	0x83A,
	0x83D,
	0x83F,
	0x964,
	0x966,
	0x104A,
	0x104C,
	0x1362,
	0x1363,
	0x1367,
	0x1369,
	0x166E,
	0x166F,
	0x1735,
	0x1737,
	0x1803,
	0x1804,
	0x1809,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5E,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C3D,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E53,
	0x2E55,
	0x3002,
	0x3003,
	0xA4FF,
	0xA500,
	0xA60E,
	0xA610,
	0xA6F3,
	0xA6F4,
	0xA6F7,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C8,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE52,
	0xFE53,
	0xFE56,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0E,
	0xFF0F,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0x10A56,
	0x10A58,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x11049,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123A,
	0x1123B,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144D,
	0x115C2,
	0x115C4,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11C41,
	0x11C43,
	0x11EF7,
	0x11EF9,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B39,
	0x16B44,
	0x16B45,
	0x16E98,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA88,
	0x1DA89
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_STERM_invlist[] = {  /* for EBCDIC 1047 */
	159,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x5A,
	0x5B,
	0x6F,
	0x70,
	0x589,
	0x58A,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x703,
	0x7F9,
	0x7FA,
	0x837,
	0x838,
	0x839,
	0x83A,
	0x83D,
	0x83F,
	0x964,
	0x966,
	0x104A,
	0x104C,
	0x1362,
	0x1363,
	0x1367,
	0x1369,
	0x166E,
	0x166F,
	0x1735,
	0x1737,
	0x1803,
	0x1804,
	0x1809,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5E,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C3D,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E53,
	0x2E55,
	0x3002,
	0x3003,
	0xA4FF,
	0xA500,
	0xA60E,
	0xA610,
	0xA6F3,
	0xA6F4,
	0xA6F7,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C8,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE52,
	0xFE53,
	0xFE56,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0E,
	0xFF0F,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0x10A56,
	0x10A58,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x11049,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123A,
	0x1123B,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144D,
	0x115C2,
	0x115C4,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11C41,
	0x11C43,
	0x11EF7,
	0x11EF9,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B39,
	0x16B44,
	0x16B45,
	0x16E98,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA88,
	0x1DA89
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_STERM_invlist[] = {  /* for EBCDIC 037 */
	159,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x5A,
	0x5B,
	0x6F,
	0x70,
	0x589,
	0x58A,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x703,
	0x7F9,
	0x7FA,
	0x837,
	0x838,
	0x839,
	0x83A,
	0x83D,
	0x83F,
	0x964,
	0x966,
	0x104A,
	0x104C,
	0x1362,
	0x1363,
	0x1367,
	0x1369,
	0x166E,
	0x166F,
	0x1735,
	0x1737,
	0x1803,
	0x1804,
	0x1809,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5E,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C3D,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E53,
	0x2E55,
	0x3002,
	0x3003,
	0xA4FF,
	0xA500,
	0xA60E,
	0xA610,
	0xA6F3,
	0xA6F4,
	0xA6F7,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C8,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE52,
	0xFE53,
	0xFE56,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0E,
	0xFF0F,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0x10A56,
	0x10A58,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x11049,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123A,
	0x1123B,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144D,
	0x115C2,
	0x115C4,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11C41,
	0x11C43,
	0x11EF7,
	0x11EF9,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B39,
	0x16B44,
	0x16B45,
	0x16E98,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA88,
	0x1DA89
};

#  endif	/* EBCDIC 037 */

static const UV UNI_SUND_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1B80,
	0x1BC0,
	0x1CC0,
	0x1CC8
};

static const UV UNI_SUNDANESESUP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1CC0,
	0x1CD0
};

static const UV UNI_SUPARROWSA_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x27F0,
	0x2800
};

static const UV UNI_SUPARROWSB_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2900,
	0x2980
};

static const UV UNI_SUPARROWSC_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1F800,
	0x1F900
};

static const UV UNI_SUPERANDSUB_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2070,
	0x20A0
};

static const UV UNI_SUPMATHOPERATORS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2A00,
	0x2B00
};

static const UV UNI_SUPPUAA_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xF0000,
	0x100000
};

static const UV UNI_SUPPUAB_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x100000,
	0x110000
};

static const UV UNI_SUPPUNCTUATION_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2E00,
	0x2E80
};

static const UV UNI_SUPSYMBOLSANDPICTOGRAPHS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1F900,
	0x1FA00
};

static const UV UNI_SUTTONSIGNWRITING_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1D800,
	0x1DAB0
};

static const UV UNI_SYLO_invlist[] = {  /* for all charsets */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x964,
	0x966,
	0x9E6,
	0x9F0,
	0xA800,
	0xA82D
};

static const UV UNI_SYMBOLSANDPICTOGRAPHSEXTA_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1FA70,
	0x1FB00
};

static const UV UNI_SYMBOLSFORLEGACYCOMPUTING_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1FB00,
	0x1FC00
};

static const UV UNI_SYRC_invlist[] = {  /* for all charsets */
	25,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x60C,
	0x60D,
	0x61B,
	0x61D,
	0x61F,
	0x620,
	0x640,
	0x641,
	0x64B,
	0x656,
	0x670,
	0x671,
	0x700,
	0x70E,
	0x70F,
	0x74B,
	0x74D,
	0x750,
	0x860,
	0x86B,
	0x1DF8,
	0x1DF9,
	0x1DFA,
	0x1DFB
};

static const UV UNI_SYRIACSUP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x860,
	0x870
};

static const UV UNI_TAGB_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1735,
	0x1737,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774
};

static const UV UNI_TAGS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xE0000,
	0xE0080
};

static const UV UNI_TAIXUANJING_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1D300,
	0x1D360
};

static const UV UNI_TAKR_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x964,
	0x966,
	0xA830,
	0xA83A,
	0x11680,
	0x116BA,
	0x116C0,
	0x116CA
};

static const UV UNI_TALE_invlist[] = {  /* for all charsets */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1040,
	0x104A,
	0x1950,
	0x196E,
	0x1970,
	0x1975
};

static const UV UNI_TALU_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x19D0,
	0x19DB,
	0x19DE,
	0x19E0
};

static const UV UNI_TAMILSUP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x11FC0,
	0x12000
};

static const UV UNI_TAML_invlist[] = {  /* for all charsets */
	51,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x951,
	0x953,
	0x964,
	0x966,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBFB,
	0x1CDA,
	0x1CDB,
	0xA8F3,
	0xA8F4,
	0x11301,
	0x11302,
	0x11303,
	0x11304,
	0x1133B,
	0x1133D,
	0x11FC0,
	0x11FF2,
	0x11FFF,
	0x12000
};

static const UV UNI_TANG_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x16FE0,
	0x16FE1,
	0x17000,
	0x187F8,
	0x18800,
	0x18B00,
	0x18D00,
	0x18D09
};

static const UV UNI_TANGUTCOMPONENTS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x18800,
	0x18B00
};

static const UV UNI_TANGUTSUP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x18D00,
	0x18D80
};

static const UV UNI_TAVT_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xAA80,
	0xAAC3,
	0xAADB,
	0xAAE0
};

static const UV UNI_TELU_invlist[] = {  /* for all charsets */
	35,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x951,
	0x953,
	0x964,
	0x966,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC77,
	0xC80,
	0x1CDA,
	0x1CDB,
	0x1CF2,
	0x1CF3
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_TERM_invlist[] = {  /* for ASCII/Latin1 */
	215,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x21,
	0x22,
	0x2C,
	0x2D,
	0x2E,
	0x2F,
	0x3A,
	0x3C,
	0x3F,
	0x40,
	0x37E,
	0x37F,
	0x387,
	0x388,
	0x589,
	0x58A,
	0x5C3,
	0x5C4,
	0x60C,
	0x60D,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x70B,
	0x70C,
	0x70D,
	0x7F8,
	0x7FA,
	0x830,
	0x83F,
	0x85E,
	0x85F,
	0x964,
	0x966,
	0xE5A,
	0xE5C,
	0xF08,
	0xF09,
	0xF0D,
	0xF13,
	0x104A,
	0x104C,
	0x1361,
	0x1369,
	0x166E,
	0x166F,
	0x16EB,
	0x16EE,
	0x1735,
	0x1737,
	0x17D4,
	0x17D7,
	0x17DA,
	0x17DB,
	0x1802,
	0x1806,
	0x1808,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5D,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C40,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E41,
	0x2E42,
	0x2E4C,
	0x2E4D,
	0x2E4E,
	0x2E50,
	0x2E53,
	0x2E55,
	0x3001,
	0x3003,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA6F3,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C7,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAADF,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE50,
	0xFE53,
	0xFE54,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF1A,
	0xFF1C,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0xFF64,
	0xFF65,
	0x1039F,
	0x103A0,
	0x103D0,
	0x103D1,
	0x10857,
	0x10858,
	0x1091F,
	0x10920,
	0x10A56,
	0x10A58,
	0x10AF0,
	0x10AF6,
	0x10B3A,
	0x10B40,
	0x10B99,
	0x10B9D,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x1104E,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144E,
	0x1145A,
	0x1145C,
	0x115C2,
	0x115C6,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11AA1,
	0x11AA3,
	0x11C41,
	0x11C44,
	0x11C71,
	0x11C72,
	0x11EF7,
	0x11EF9,
	0x12470,
	0x12475,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B3A,
	0x16B44,
	0x16B45,
	0x16E97,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA87,
	0x1DA8B
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_TERM_invlist[] = {  /* for EBCDIC 1047 */
	217,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x5A,
	0x5B,
	0x5E,
	0x5F,
	0x6B,
	0x6C,
	0x6F,
	0x70,
	0x7A,
	0x7B,
	0x37E,
	0x37F,
	0x387,
	0x388,
	0x589,
	0x58A,
	0x5C3,
	0x5C4,
	0x60C,
	0x60D,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x70B,
	0x70C,
	0x70D,
	0x7F8,
	0x7FA,
	0x830,
	0x83F,
	0x85E,
	0x85F,
	0x964,
	0x966,
	0xE5A,
	0xE5C,
	0xF08,
	0xF09,
	0xF0D,
	0xF13,
	0x104A,
	0x104C,
	0x1361,
	0x1369,
	0x166E,
	0x166F,
	0x16EB,
	0x16EE,
	0x1735,
	0x1737,
	0x17D4,
	0x17D7,
	0x17DA,
	0x17DB,
	0x1802,
	0x1806,
	0x1808,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5D,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C40,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E41,
	0x2E42,
	0x2E4C,
	0x2E4D,
	0x2E4E,
	0x2E50,
	0x2E53,
	0x2E55,
	0x3001,
	0x3003,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA6F3,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C7,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAADF,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE50,
	0xFE53,
	0xFE54,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF1A,
	0xFF1C,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0xFF64,
	0xFF65,
	0x1039F,
	0x103A0,
	0x103D0,
	0x103D1,
	0x10857,
	0x10858,
	0x1091F,
	0x10920,
	0x10A56,
	0x10A58,
	0x10AF0,
	0x10AF6,
	0x10B3A,
	0x10B40,
	0x10B99,
	0x10B9D,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x1104E,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144E,
	0x1145A,
	0x1145C,
	0x115C2,
	0x115C6,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11AA1,
	0x11AA3,
	0x11C41,
	0x11C44,
	0x11C71,
	0x11C72,
	0x11EF7,
	0x11EF9,
	0x12470,
	0x12475,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B3A,
	0x16B44,
	0x16B45,
	0x16E97,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA87,
	0x1DA8B
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_TERM_invlist[] = {  /* for EBCDIC 037 */
	217,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x5A,
	0x5B,
	0x5E,
	0x5F,
	0x6B,
	0x6C,
	0x6F,
	0x70,
	0x7A,
	0x7B,
	0x37E,
	0x37F,
	0x387,
	0x388,
	0x589,
	0x58A,
	0x5C3,
	0x5C4,
	0x60C,
	0x60D,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x6D4,
	0x6D5,
	0x700,
	0x70B,
	0x70C,
	0x70D,
	0x7F8,
	0x7FA,
	0x830,
	0x83F,
	0x85E,
	0x85F,
	0x964,
	0x966,
	0xE5A,
	0xE5C,
	0xF08,
	0xF09,
	0xF0D,
	0xF13,
	0x104A,
	0x104C,
	0x1361,
	0x1369,
	0x166E,
	0x166F,
	0x16EB,
	0x16EE,
	0x1735,
	0x1737,
	0x17D4,
	0x17D7,
	0x17DA,
	0x17DB,
	0x1802,
	0x1806,
	0x1808,
	0x180A,
	0x1944,
	0x1946,
	0x1AA8,
	0x1AAC,
	0x1B5A,
	0x1B5C,
	0x1B5D,
	0x1B60,
	0x1B7D,
	0x1B7F,
	0x1C3B,
	0x1C40,
	0x1C7E,
	0x1C80,
	0x203C,
	0x203E,
	0x2047,
	0x204A,
	0x2E2E,
	0x2E2F,
	0x2E3C,
	0x2E3D,
	0x2E41,
	0x2E42,
	0x2E4C,
	0x2E4D,
	0x2E4E,
	0x2E50,
	0x2E53,
	0x2E55,
	0x3001,
	0x3003,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA6F3,
	0xA6F8,
	0xA876,
	0xA878,
	0xA8CE,
	0xA8D0,
	0xA92F,
	0xA930,
	0xA9C7,
	0xA9CA,
	0xAA5D,
	0xAA60,
	0xAADF,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xABEB,
	0xABEC,
	0xFE50,
	0xFE53,
	0xFE54,
	0xFE58,
	0xFF01,
	0xFF02,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF1A,
	0xFF1C,
	0xFF1F,
	0xFF20,
	0xFF61,
	0xFF62,
	0xFF64,
	0xFF65,
	0x1039F,
	0x103A0,
	0x103D0,
	0x103D1,
	0x10857,
	0x10858,
	0x1091F,
	0x10920,
	0x10A56,
	0x10A58,
	0x10AF0,
	0x10AF6,
	0x10B3A,
	0x10B40,
	0x10B99,
	0x10B9D,
	0x10F55,
	0x10F5A,
	0x10F86,
	0x10F8A,
	0x11047,
	0x1104E,
	0x110BE,
	0x110C2,
	0x11141,
	0x11144,
	0x111C5,
	0x111C7,
	0x111CD,
	0x111CE,
	0x111DE,
	0x111E0,
	0x11238,
	0x1123D,
	0x112A9,
	0x112AA,
	0x1144B,
	0x1144E,
	0x1145A,
	0x1145C,
	0x115C2,
	0x115C6,
	0x115C9,
	0x115D8,
	0x11641,
	0x11643,
	0x1173C,
	0x1173F,
	0x11944,
	0x11945,
	0x11946,
	0x11947,
	0x11A42,
	0x11A44,
	0x11A9B,
	0x11A9D,
	0x11AA1,
	0x11AA3,
	0x11C41,
	0x11C44,
	0x11C71,
	0x11C72,
	0x11EF7,
	0x11EF9,
	0x12470,
	0x12475,
	0x16A6E,
	0x16A70,
	0x16AF5,
	0x16AF6,
	0x16B37,
	0x16B3A,
	0x16B44,
	0x16B45,
	0x16E97,
	0x16E99,
	0x1BC9F,
	0x1BCA0,
	0x1DA87,
	0x1DA8B
};

#  endif	/* EBCDIC 037 */

static const UV UNI_TFNG_invlist[] = {  /* for all charsets */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D71,
	0x2D7F,
	0x2D80
};

static const UV UNI_TGLG_invlist[] = {  /* for all charsets */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1700,
	0x1716,
	0x171F,
	0x1720,
	0x1735,
	0x1737
};

static const UV UNI_THAA_invlist[] = {  /* for all charsets */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x60C,
	0x60D,
	0x61B,
	0x61D,
	0x61F,
	0x620,
	0x660,
	0x66A,
	0x780,
	0x7B2,
	0xFDF2,
	0xFDF3,
	0xFDFD,
	0xFDFE
};

static const UV UNI_THAI_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xE01,
	0xE3B,
	0xE40,
	0xE5C
};

static const UV UNI_TIBT_invlist[] = {  /* for all charsets */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xF00,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF98,
	0xF99,
	0xFBD,
	0xFBE,
	0xFCD,
	0xFCE,
	0xFD5,
	0xFD9,
	0xFDB
};

static const UV UNI_TIRH_invlist[] = {  /* for all charsets */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x951,
	0x953,
	0x964,
	0x966,
	0x1CF2,
	0x1CF3,
	0xA830,
	0xA83A,
	0x11480,
	0x114C8,
	0x114D0,
	0x114DA
};

static const UV UNI_TNSA_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA
};

static const UV UNI_TOTO_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1E290,
	0x1E2AF
};

static const UV UNI_TRANSPORTANDMAP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1F680,
	0x1F700
};

static const UV UNI_UCAS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1400,
	0x1680
};

static const UV UNI_UCASEXT_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x18B0,
	0x1900
};

static const UV UNI_UCASEXTA_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x11AB0,
	0x11AC0
};

static const UV UNI_UGAR_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x10380,
	0x1039E,
	0x1039F,
	0x103A0
};

static const UV UNI_UIDEO_invlist[] = {  /* for all charsets */
	31,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA000,
	0xFA0E,
	0xFA10,
	0xFA11,
	0xFA12,
	0xFA13,
	0xFA15,
	0xFA1F,
	0xFA20,
	0xFA21,
	0xFA22,
	0xFA23,
	0xFA25,
	0xFA27,
	0xFA2A,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x30000,
	0x3134B
};

static const UV UNI_VAI_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA500,
	0xA62C
};

static const UV UNI_VEDICEXT_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1CD0,
	0x1D00
};

static const UV UNI_VERTICALFORMS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xFE10,
	0xFE20
};

static const UV UNI_VITH_invlist[] = {  /* for all charsets */
	17,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_VO__R_invlist[] = {  /* for ASCII/Latin1 */
	179,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA7,
	0xA8,
	0xA9,
	0xAA,
	0xAE,
	0xAF,
	0xB1,
	0xB2,
	0xBC,
	0xBF,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE50,
	0xFE58,
	0xFE59,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF01,
	0xFF0D,
	0xFF0E,
	0xFF1C,
	0xFF1F,
	0xFF61,
	0xFFE0,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_VO__R_invlist[] = {  /* for EBCDIC 1047 */
	177,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x8F,
	0x90,
	0xAF,
	0xB0,
	0xB4,
	0xB6,
	0xB7,
	0xBA,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE50,
	0xFE58,
	0xFE59,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF01,
	0xFF0D,
	0xFF0E,
	0xFF1C,
	0xFF1F,
	0xFF61,
	0xFFE0,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_VO__R_invlist[] = {  /* for EBCDIC 037 */
	177,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x8F,
	0x90,
	0xAF,
	0xB0,
	0xB4,
	0xB6,
	0xB7,
	0xBA,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE50,
	0xFE58,
	0xFE59,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF01,
	0xFF0D,
	0xFF0E,
	0xFF1C,
	0xFF1F,
	0xFF61,
	0xFFE0,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* EBCDIC 037 */

static const UV UNI_VO__TR_invlist[] = {  /* for all charsets */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2329,
	0x232B,
	0x3008,
	0x3012,
	0x3014,
	0x3020,
	0x3030,
	0x3031,
	0x30A0,
	0x30A1,
	0x30FC,
	0x30FD,
	0xFE59,
	0xFE5F,
	0xFF08,
	0xFF0A,
	0xFF1A,
	0xFF1C,
	0xFF3B,
	0xFF3C,
	0xFF3D,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF5B,
	0xFF61,
	0xFFE3,
	0xFFE4
};

static const UV UNI_VO__TU_invlist[] = {  /* for all charsets */
	69,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x3001,
	0x3003,
	0x3041,
	0x3042,
	0x3043,
	0x3044,
	0x3045,
	0x3046,
	0x3047,
	0x3048,
	0x3049,
	0x304A,
	0x3063,
	0x3064,
	0x3083,
	0x3084,
	0x3085,
	0x3086,
	0x3087,
	0x3088,
	0x308E,
	0x308F,
	0x3095,
	0x3097,
	0x309B,
	0x309D,
	0x30A1,
	0x30A2,
	0x30A3,
	0x30A4,
	0x30A5,
	0x30A6,
	0x30A7,
	0x30A8,
	0x30A9,
	0x30AA,
	0x30C3,
	0x30C4,
	0x30E3,
	0x30E4,
	0x30E5,
	0x30E6,
	0x30E7,
	0x30E8,
	0x30EE,
	0x30EF,
	0x30F5,
	0x30F7,
	0x3127,
	0x3128,
	0x31F0,
	0x3200,
	0x32FF,
	0x3358,
	0x337B,
	0x3380,
	0xFE50,
	0xFE53,
	0xFF01,
	0xFF02,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF1F,
	0xFF20,
	0x1F200,
	0x1F202
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_VO__U_invlist[] = {  /* for ASCII/Latin1 */
	257,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA7,
	0xA8,
	0xA9,
	0xAA,
	0xAE,
	0xAF,
	0xB1,
	0xB2,
	0xBC,
	0xBF,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x2329,
	0x232B,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0x3001,
	0x3003,
	0x3008,
	0x3012,
	0x3014,
	0x3020,
	0x3030,
	0x3031,
	0x3041,
	0x3042,
	0x3043,
	0x3044,
	0x3045,
	0x3046,
	0x3047,
	0x3048,
	0x3049,
	0x304A,
	0x3063,
	0x3064,
	0x3083,
	0x3084,
	0x3085,
	0x3086,
	0x3087,
	0x3088,
	0x308E,
	0x308F,
	0x3095,
	0x3097,
	0x309B,
	0x309D,
	0x30A0,
	0x30A2,
	0x30A3,
	0x30A4,
	0x30A5,
	0x30A6,
	0x30A7,
	0x30A8,
	0x30A9,
	0x30AA,
	0x30C3,
	0x30C4,
	0x30E3,
	0x30E4,
	0x30E5,
	0x30E6,
	0x30E7,
	0x30E8,
	0x30EE,
	0x30EF,
	0x30F5,
	0x30F7,
	0x30FC,
	0x30FD,
	0x3127,
	0x3128,
	0x31F0,
	0x3200,
	0x32FF,
	0x3358,
	0x337B,
	0x3380,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE53,
	0xFE58,
	0xFE5F,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF02,
	0xFF08,
	0xFF0A,
	0xFF0C,
	0xFF0F,
	0xFF1A,
	0xFF20,
	0xFF3B,
	0xFF3C,
	0xFF3D,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF5B,
	0xFFE0,
	0xFFE3,
	0xFFE4,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F200,
	0x1F202,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_VO__U_invlist[] = {  /* for EBCDIC 1047 */
	255,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x8F,
	0x90,
	0xAF,
	0xB0,
	0xB4,
	0xB6,
	0xB7,
	0xBA,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x2329,
	0x232B,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0x3001,
	0x3003,
	0x3008,
	0x3012,
	0x3014,
	0x3020,
	0x3030,
	0x3031,
	0x3041,
	0x3042,
	0x3043,
	0x3044,
	0x3045,
	0x3046,
	0x3047,
	0x3048,
	0x3049,
	0x304A,
	0x3063,
	0x3064,
	0x3083,
	0x3084,
	0x3085,
	0x3086,
	0x3087,
	0x3088,
	0x308E,
	0x308F,
	0x3095,
	0x3097,
	0x309B,
	0x309D,
	0x30A0,
	0x30A2,
	0x30A3,
	0x30A4,
	0x30A5,
	0x30A6,
	0x30A7,
	0x30A8,
	0x30A9,
	0x30AA,
	0x30C3,
	0x30C4,
	0x30E3,
	0x30E4,
	0x30E5,
	0x30E6,
	0x30E7,
	0x30E8,
	0x30EE,
	0x30EF,
	0x30F5,
	0x30F7,
	0x30FC,
	0x30FD,
	0x3127,
	0x3128,
	0x31F0,
	0x3200,
	0x32FF,
	0x3358,
	0x337B,
	0x3380,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE53,
	0xFE58,
	0xFE5F,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF02,
	0xFF08,
	0xFF0A,
	0xFF0C,
	0xFF0F,
	0xFF1A,
	0xFF20,
	0xFF3B,
	0xFF3C,
	0xFF3D,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF5B,
	0xFFE0,
	0xFFE3,
	0xFFE4,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F200,
	0x1F202,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_VO__U_invlist[] = {  /* for EBCDIC 037 */
	255,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x8F,
	0x90,
	0xAF,
	0xB0,
	0xB4,
	0xB6,
	0xB7,
	0xBA,
	0xBF,
	0xC0,
	0xE1,
	0xE2,
	0x2EA,
	0x2EC,
	0x1100,
	0x1200,
	0x1401,
	0x1680,
	0x18B0,
	0x1900,
	0x2016,
	0x2017,
	0x2020,
	0x2022,
	0x2030,
	0x2032,
	0x203B,
	0x203D,
	0x2042,
	0x2043,
	0x2047,
	0x204A,
	0x2051,
	0x2052,
	0x2065,
	0x2066,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x2100,
	0x2102,
	0x2103,
	0x210A,
	0x210F,
	0x2110,
	0x2113,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x2135,
	0x2140,
	0x2145,
	0x214B,
	0x214C,
	0x214E,
	0x214F,
	0x218A,
	0x218C,
	0x2190,
	0x221E,
	0x221F,
	0x2234,
	0x2236,
	0x2300,
	0x2308,
	0x230C,
	0x2320,
	0x2324,
	0x2329,
	0x232B,
	0x232C,
	0x237D,
	0x239B,
	0x23BE,
	0x23CE,
	0x23CF,
	0x23D0,
	0x23D1,
	0x23DC,
	0x23E2,
	0x2423,
	0x2424,
	0x2500,
	0x25A0,
	0x261A,
	0x2620,
	0x2768,
	0x2776,
	0x2794,
	0x2B12,
	0x2B30,
	0x2B50,
	0x2B5A,
	0x2B97,
	0x2B98,
	0x2BB8,
	0x2BD2,
	0x2BD3,
	0x2BEC,
	0x2BF0,
	0x2C00,
	0x2E50,
	0x2E52,
	0x2E80,
	0x3001,
	0x3003,
	0x3008,
	0x3012,
	0x3014,
	0x3020,
	0x3030,
	0x3031,
	0x3041,
	0x3042,
	0x3043,
	0x3044,
	0x3045,
	0x3046,
	0x3047,
	0x3048,
	0x3049,
	0x304A,
	0x3063,
	0x3064,
	0x3083,
	0x3084,
	0x3085,
	0x3086,
	0x3087,
	0x3088,
	0x308E,
	0x308F,
	0x3095,
	0x3097,
	0x309B,
	0x309D,
	0x30A0,
	0x30A2,
	0x30A3,
	0x30A4,
	0x30A5,
	0x30A6,
	0x30A7,
	0x30A8,
	0x30A9,
	0x30AA,
	0x30C3,
	0x30C4,
	0x30E3,
	0x30E4,
	0x30E5,
	0x30E6,
	0x30E7,
	0x30E8,
	0x30EE,
	0x30EF,
	0x30F5,
	0x30F7,
	0x30FC,
	0x30FD,
	0x3127,
	0x3128,
	0x31F0,
	0x3200,
	0x32FF,
	0x3358,
	0x337B,
	0x3380,
	0xA4D0,
	0xA960,
	0xA980,
	0xAC00,
	0xD800,
	0xE000,
	0xFB00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE49,
	0xFE53,
	0xFE58,
	0xFE5F,
	0xFE63,
	0xFE67,
	0xFE70,
	0xFF02,
	0xFF08,
	0xFF0A,
	0xFF0C,
	0xFF0F,
	0xFF1A,
	0xFF20,
	0xFF3B,
	0xFF3C,
	0xFF3D,
	0xFF3E,
	0xFF3F,
	0xFF40,
	0xFF5B,
	0xFFE0,
	0xFFE3,
	0xFFE4,
	0xFFE8,
	0xFFF0,
	0xFFF9,
	0xFFFC,
	0xFFFE,
	0x10980,
	0x109A0,
	0x11580,
	0x11600,
	0x11A00,
	0x11AC0,
	0x13000,
	0x13440,
	0x14400,
	0x14680,
	0x16FE0,
	0x18D80,
	0x1AFF0,
	0x1B300,
	0x1CF00,
	0x1CFD0,
	0x1D000,
	0x1D200,
	0x1D2E0,
	0x1D380,
	0x1D800,
	0x1DAB0,
	0x1F000,
	0x1F200,
	0x1F202,
	0x1F800,
	0x1F900,
	0x1FB00,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE
};

#  endif	/* EBCDIC 037 */

static const UV UNI_VS_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x180B,
	0x180E,
	0x180F,
	0x1810,
	0xFE00,
	0xFE10,
	0xE0100,
	0xE01F0
};

static const UV UNI_VSSUP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xE0100,
	0xE01F0
};

static const UV UNI_WARA_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x118A0,
	0x118F3,
	0x118FF,
	0x11900
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__DQ_invlist[] = {  /* for ASCII/Latin1 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x22,
	0x23
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__DQ_invlist[] = {  /* for EBCDIC 1047 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7F,
	0x80
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__DQ_invlist[] = {  /* for EBCDIC 037 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7F,
	0x80
};

#  endif	/* EBCDIC 037 */

static const UV UNI_WB__EB_invlist[] = {  /* for ASCII/Latin1 */
	0,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__EX_invlist[] = {  /* for ASCII/Latin1 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5F,
	0x60,
	0x202F,
	0x2030,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFF3F,
	0xFF40
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__EX_invlist[] = {  /* for EBCDIC 1047 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x6D,
	0x6E,
	0x202F,
	0x2030,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFF3F,
	0xFF40
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__EX_invlist[] = {  /* for EBCDIC 037 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x6D,
	0x6E,
	0x202F,
	0x2030,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFF3F,
	0xFF40
};

#  endif	/* EBCDIC 037 */

static const UV UNI_WB__EXTEND_invlist[] = {  /* for all charsets */
	607,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x300,
	0x370,
	0x483,
	0x48A,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x610,
	0x61B,
	0x64B,
	0x660,
	0x670,
	0x671,
	0x6D6,
	0x6DD,
	0x6DF,
	0x6E5,
	0x6E7,
	0x6E9,
	0x6EA,
	0x6EE,
	0x711,
	0x712,
	0x730,
	0x74B,
	0x7A6,
	0x7B1,
	0x7EB,
	0x7F4,
	0x7FD,
	0x7FE,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x82E,
	0x859,
	0x85C,
	0x898,
	0x8A0,
	0x8CA,
	0x8E2,
	0x8E3,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x964,
	0x981,
	0x984,
	0x9BC,
	0x9BD,
	0x9BE,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CE,
	0x9D7,
	0x9D8,
	0x9E2,
	0x9E4,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA70,
	0xA72,
	0xA75,
	0xA76,
	0xA81,
	0xA84,
	0xABC,
	0xABD,
	0xABE,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAE2,
	0xAE4,
	0xAFA,
	0xB00,
	0xB01,
	0xB04,
	0xB3C,
	0xB3D,
	0xB3E,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB62,
	0xB64,
	0xB82,
	0xB83,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD7,
	0xBD8,
	0xC00,
	0xC05,
	0xC3C,
	0xC3D,
	0xC3E,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC62,
	0xC64,
	0xC81,
	0xC84,
	0xCBC,
	0xCBD,
	0xCBE,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCE2,
	0xCE4,
	0xD00,
	0xD04,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4E,
	0xD57,
	0xD58,
	0xD62,
	0xD64,
	0xD81,
	0xD84,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDF2,
	0xDF4,
	0xE31,
	0xE32,
	0xE34,
	0xE3B,
	0xE47,
	0xE4F,
	0xEB1,
	0xEB2,
	0xEB4,
	0xEBD,
	0xEC8,
	0xECE,
	0xF18,
	0xF1A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF40,
	0xF71,
	0xF85,
	0xF86,
	0xF88,
	0xF8D,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x102B,
	0x103F,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x1090,
	0x109A,
	0x109E,
	0x135D,
	0x1360,
	0x1712,
	0x1716,
	0x1732,
	0x1735,
	0x1752,
	0x1754,
	0x1772,
	0x1774,
	0x17B4,
	0x17D4,
	0x17DD,
	0x17DE,
	0x180B,
	0x180E,
	0x180F,
	0x1810,
	0x1885,
	0x1887,
	0x18A9,
	0x18AA,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1A17,
	0x1A1C,
	0x1A55,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A80,
	0x1AB0,
	0x1ACF,
	0x1B00,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BE6,
	0x1BF4,
	0x1C24,
	0x1C38,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1DC0,
	0x1E00,
	0x200C,
	0x200D,
	0x20D0,
	0x20F1,
	0x2CEF,
	0x2CF2,
	0x2D7F,
	0x2D80,
	0x2DE0,
	0x2E00,
	0x302A,
	0x3030,
	0x3099,
	0x309B,
	0xA66F,
	0xA673,
	0xA674,
	0xA67E,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA6F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA828,
	0xA82C,
	0xA82D,
	0xA880,
	0xA882,
	0xA8B4,
	0xA8C6,
	0xA8E0,
	0xA8F2,
	0xA8FF,
	0xA900,
	0xA926,
	0xA92E,
	0xA947,
	0xA954,
	0xA980,
	0xA984,
	0xA9B3,
	0xA9C1,
	0xA9E5,
	0xA9E6,
	0xAA29,
	0xAA37,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAA4E,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAEB,
	0xAAF0,
	0xAAF5,
	0xAAF7,
	0xABE3,
	0xABEB,
	0xABEC,
	0xABEE,
	0xFB1E,
	0xFB1F,
	0xFE00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFF9E,
	0xFFA0,
	0x101FD,
	0x101FE,
	0x102E0,
	0x102E1,
	0x10376,
	0x1037B,
	0x10A01,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A10,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10AE5,
	0x10AE7,
	0x10D24,
	0x10D28,
	0x10EAB,
	0x10EAD,
	0x10F46,
	0x10F51,
	0x10F82,
	0x10F86,
	0x11000,
	0x11003,
	0x11038,
	0x11047,
	0x11070,
	0x11071,
	0x11073,
	0x11075,
	0x1107F,
	0x11083,
	0x110B0,
	0x110BB,
	0x110C2,
	0x110C3,
	0x11100,
	0x11103,
	0x11127,
	0x11135,
	0x11145,
	0x11147,
	0x11173,
	0x11174,
	0x11180,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111D0,
	0x1122C,
	0x11238,
	0x1123E,
	0x1123F,
	0x112DF,
	0x112EB,
	0x11300,
	0x11304,
	0x1133B,
	0x1133D,
	0x1133E,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11357,
	0x11358,
	0x11362,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11435,
	0x11447,
	0x1145E,
	0x1145F,
	0x114B0,
	0x114C4,
	0x115AF,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115DC,
	0x115DE,
	0x11630,
	0x11641,
	0x116AB,
	0x116B8,
	0x1171D,
	0x1172C,
	0x1182C,
	0x1183B,
	0x11930,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x11944,
	0x119D1,
	0x119D8,
	0x119DA,
	0x119E1,
	0x119E4,
	0x119E5,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9A,
	0x11C2F,
	0x11C37,
	0x11C38,
	0x11C40,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D31,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D46,
	0x11D47,
	0x11D48,
	0x11D8A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D98,
	0x11EF3,
	0x11EF7,
	0x16AF0,
	0x16AF5,
	0x16B30,
	0x16B37,
	0x16F4F,
	0x16F50,
	0x16F51,
	0x16F88,
	0x16F8F,
	0x16F93,
	0x16FE4,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x1BC9D,
	0x1BC9F,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D173,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E130,
	0x1E137,
	0x1E2AE,
	0x1E2AF,
	0x1E2EC,
	0x1E2F0,
	0x1E8D0,
	0x1E8D7,
	0x1E944,
	0x1E94B,
	0x1F3FB,
	0x1F400,
	0xE0020,
	0xE0080,
	0xE0100,
	0xE01F0
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__FO_invlist[] = {  /* for ASCII/Latin1 */
	41,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xAD,
	0xAE,
	0x600,
	0x606,
	0x61C,
	0x61D,
	0x6DD,
	0x6DE,
	0x70F,
	0x710,
	0x890,
	0x892,
	0x8E2,
	0x8E3,
	0x180E,
	0x180F,
	0x200E,
	0x2010,
	0x202A,
	0x202F,
	0x2060,
	0x2065,
	0x2066,
	0x2070,
	0xFEFF,
	0xFF00,
	0xFFF9,
	0xFFFC,
	0x110BD,
	0x110BE,
	0x110CD,
	0x110CE,
	0x13430,
	0x13439,
	0x1BCA0,
	0x1BCA4,
	0x1D173,
	0x1D17B,
	0xE0001,
	0xE0002
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__FO_invlist[] = {  /* for EBCDIC 1047 */
	41,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xCA,
	0xCB,
	0x600,
	0x606,
	0x61C,
	0x61D,
	0x6DD,
	0x6DE,
	0x70F,
	0x710,
	0x890,
	0x892,
	0x8E2,
	0x8E3,
	0x180E,
	0x180F,
	0x200E,
	0x2010,
	0x202A,
	0x202F,
	0x2060,
	0x2065,
	0x2066,
	0x2070,
	0xFEFF,
	0xFF00,
	0xFFF9,
	0xFFFC,
	0x110BD,
	0x110BE,
	0x110CD,
	0x110CE,
	0x13430,
	0x13439,
	0x1BCA0,
	0x1BCA4,
	0x1D173,
	0x1D17B,
	0xE0001,
	0xE0002
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__FO_invlist[] = {  /* for EBCDIC 037 */
	41,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xCA,
	0xCB,
	0x600,
	0x606,
	0x61C,
	0x61D,
	0x6DD,
	0x6DE,
	0x70F,
	0x710,
	0x890,
	0x892,
	0x8E2,
	0x8E3,
	0x180E,
	0x180F,
	0x200E,
	0x2010,
	0x202A,
	0x202F,
	0x2060,
	0x2065,
	0x2066,
	0x2070,
	0xFEFF,
	0xFF00,
	0xFFF9,
	0xFFFC,
	0x110BD,
	0x110BE,
	0x110CD,
	0x110CE,
	0x13430,
	0x13439,
	0x1BCA0,
	0x1BCA4,
	0x1D173,
	0x1D17B,
	0xE0001,
	0xE0002
};

#  endif	/* EBCDIC 037 */

static const UV UNI_WB__KA_invlist[] = {  /* for all charsets */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x3031,
	0x3036,
	0x309B,
	0x309D,
	0x30A0,
	0x30FB,
	0x30FC,
	0x3100,
	0x31F0,
	0x3200,
	0x32D0,
	0x32FF,
	0x3300,
	0x3358,
	0xFF66,
	0xFF9E,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B001,
	0x1B120,
	0x1B123,
	0x1B164,
	0x1B168
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__LE_invlist[] = {  /* for ASCII/Latin1 */
	1141,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x41,
	0x5B,
	0x61,
	0x7B,
	0xAA,
	0xAB,
	0xB5,
	0xB6,
	0xBA,
	0xBB,
	0xC0,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2D8,
	0x2DE,
	0x300,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x55F,
	0x560,
	0x589,
	0x58A,
	0x58B,
	0x5F3,
	0x5F4,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1820,
	0x1879,
	0x1880,
	0x1885,
	0x1887,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1A00,
	0x1A17,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2E2F,
	0x2E30,
	0x3005,
	0x3006,
	0x303B,
	0x303D,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB50,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__LE_invlist[] = {  /* for EBCDIC 1047 */
	1167,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAD,
	0xAE,
	0xAF,
	0xBA,
	0xBB,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2D8,
	0x2DE,
	0x300,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x55F,
	0x560,
	0x589,
	0x58A,
	0x58B,
	0x5F3,
	0x5F4,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1820,
	0x1879,
	0x1880,
	0x1885,
	0x1887,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1A00,
	0x1A17,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2E2F,
	0x2E30,
	0x3005,
	0x3006,
	0x303B,
	0x303D,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB50,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__LE_invlist[] = {  /* for EBCDIC 037 */
	1163,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2D8,
	0x2DE,
	0x300,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x55F,
	0x560,
	0x589,
	0x58A,
	0x58B,
	0x5F3,
	0x5F4,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1820,
	0x1879,
	0x1880,
	0x1885,
	0x1887,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1A00,
	0x1A17,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2E2F,
	0x2E30,
	0x3005,
	0x3006,
	0x303B,
	0x303D,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB50,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__MB_invlist[] = {  /* for ASCII/Latin1 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2E,
	0x2F,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0xFE52,
	0xFE53,
	0xFF07,
	0xFF08,
	0xFF0E,
	0xFF0F
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__MB_invlist[] = {  /* for EBCDIC 1047 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0xFE52,
	0xFE53,
	0xFF07,
	0xFF08,
	0xFF0E,
	0xFF0F
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__MB_invlist[] = {  /* for EBCDIC 037 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4B,
	0x4C,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0xFE52,
	0xFE53,
	0xFF07,
	0xFF08,
	0xFF0E,
	0xFF0F
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__ML_invlist[] = {  /* for ASCII/Latin1 */
	19,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x3A,
	0x3B,
	0xB7,
	0xB8,
	0x387,
	0x388,
	0x55F,
	0x560,
	0x5F4,
	0x5F5,
	0x2027,
	0x2028,
	0xFE13,
	0xFE14,
	0xFE55,
	0xFE56,
	0xFF1A,
	0xFF1B
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__ML_invlist[] = {  /* for EBCDIC 1047 */
	19,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7A,
	0x7B,
	0xB3,
	0xB4,
	0x387,
	0x388,
	0x55F,
	0x560,
	0x5F4,
	0x5F5,
	0x2027,
	0x2028,
	0xFE13,
	0xFE14,
	0xFE55,
	0xFE56,
	0xFF1A,
	0xFF1B
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__ML_invlist[] = {  /* for EBCDIC 037 */
	19,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7A,
	0x7B,
	0xB3,
	0xB4,
	0x387,
	0x388,
	0x55F,
	0x560,
	0x5F4,
	0x5F5,
	0x2027,
	0x2028,
	0xFE13,
	0xFE14,
	0xFE55,
	0xFE56,
	0xFF1A,
	0xFF1B
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__MN_invlist[] = {  /* for ASCII/Latin1 */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2C,
	0x2D,
	0x3B,
	0x3C,
	0x37E,
	0x37F,
	0x589,
	0x58A,
	0x60C,
	0x60E,
	0x66C,
	0x66D,
	0x7F8,
	0x7F9,
	0x2044,
	0x2045,
	0xFE10,
	0xFE11,
	0xFE14,
	0xFE15,
	0xFE50,
	0xFE51,
	0xFE54,
	0xFE55,
	0xFF0C,
	0xFF0D,
	0xFF1B,
	0xFF1C
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__MN_invlist[] = {  /* for EBCDIC 1047 */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5E,
	0x5F,
	0x6B,
	0x6C,
	0x37E,
	0x37F,
	0x589,
	0x58A,
	0x60C,
	0x60E,
	0x66C,
	0x66D,
	0x7F8,
	0x7F9,
	0x2044,
	0x2045,
	0xFE10,
	0xFE11,
	0xFE14,
	0xFE15,
	0xFE50,
	0xFE51,
	0xFE54,
	0xFE55,
	0xFF0C,
	0xFF0D,
	0xFF1B,
	0xFF1C
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__MN_invlist[] = {  /* for EBCDIC 037 */
	29,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5E,
	0x5F,
	0x6B,
	0x6C,
	0x37E,
	0x37F,
	0x589,
	0x58A,
	0x60C,
	0x60E,
	0x66C,
	0x66D,
	0x7F8,
	0x7F9,
	0x2044,
	0x2045,
	0xFE10,
	0xFE11,
	0xFE14,
	0xFE15,
	0xFE50,
	0xFE51,
	0xFE54,
	0xFE55,
	0xFF0C,
	0xFF0D,
	0xFF1B,
	0xFF1C
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__NL_invlist[] = {  /* for ASCII/Latin1 */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xB,
	0xD,
	0x85,
	0x86,
	0x2028,
	0x202A
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__NL_invlist[] = {  /* for EBCDIC 1047 */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xB,
	0xD,
	0x25,
	0x26,
	0x2028,
	0x202A
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__NL_invlist[] = {  /* for EBCDIC 037 */
	7,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xB,
	0xD,
	0x15,
	0x16,
	0x2028,
	0x202A
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__NU_invlist[] = {  /* for ASCII/Latin1 */
	127,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x30,
	0x3A,
	0x660,
	0x66A,
	0x66B,
	0x66C,
	0x6F0,
	0x6FA,
	0x7C0,
	0x7CA,
	0x966,
	0x970,
	0x9E6,
	0x9F0,
	0xA66,
	0xA70,
	0xAE6,
	0xAF0,
	0xB66,
	0xB70,
	0xBE6,
	0xBF0,
	0xC66,
	0xC70,
	0xCE6,
	0xCF0,
	0xD66,
	0xD70,
	0xDE6,
	0xDF0,
	0xE50,
	0xE5A,
	0xED0,
	0xEDA,
	0xF20,
	0xF2A,
	0x1040,
	0x104A,
	0x1090,
	0x109A,
	0x17E0,
	0x17EA,
	0x1810,
	0x181A,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A80,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1B50,
	0x1B5A,
	0x1BB0,
	0x1BBA,
	0x1C40,
	0x1C4A,
	0x1C50,
	0x1C5A,
	0xA620,
	0xA62A,
	0xA8D0,
	0xA8DA,
	0xA900,
	0xA90A,
	0xA9D0,
	0xA9DA,
	0xA9F0,
	0xA9FA,
	0xAA50,
	0xAA5A,
	0xABF0,
	0xABFA,
	0xFF10,
	0xFF1A,
	0x104A0,
	0x104AA,
	0x10D30,
	0x10D3A,
	0x11066,
	0x11070,
	0x110F0,
	0x110FA,
	0x11136,
	0x11140,
	0x111D0,
	0x111DA,
	0x112F0,
	0x112FA,
	0x11450,
	0x1145A,
	0x114D0,
	0x114DA,
	0x11650,
	0x1165A,
	0x116C0,
	0x116CA,
	0x11730,
	0x1173A,
	0x118E0,
	0x118EA,
	0x11950,
	0x1195A,
	0x11C50,
	0x11C5A,
	0x11D50,
	0x11D5A,
	0x11DA0,
	0x11DAA,
	0x16A60,
	0x16A6A,
	0x16AC0,
	0x16ACA,
	0x16B50,
	0x16B5A,
	0x1D7CE,
	0x1D800,
	0x1E140,
	0x1E14A,
	0x1E2F0,
	0x1E2FA,
	0x1E950,
	0x1E95A,
	0x1FBF0,
	0x1FBFA
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__NU_invlist[] = {  /* for EBCDIC 1047 */
	127,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xF0,
	0xFA,
	0x660,
	0x66A,
	0x66B,
	0x66C,
	0x6F0,
	0x6FA,
	0x7C0,
	0x7CA,
	0x966,
	0x970,
	0x9E6,
	0x9F0,
	0xA66,
	0xA70,
	0xAE6,
	0xAF0,
	0xB66,
	0xB70,
	0xBE6,
	0xBF0,
	0xC66,
	0xC70,
	0xCE6,
	0xCF0,
	0xD66,
	0xD70,
	0xDE6,
	0xDF0,
	0xE50,
	0xE5A,
	0xED0,
	0xEDA,
	0xF20,
	0xF2A,
	0x1040,
	0x104A,
	0x1090,
	0x109A,
	0x17E0,
	0x17EA,
	0x1810,
	0x181A,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A80,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1B50,
	0x1B5A,
	0x1BB0,
	0x1BBA,
	0x1C40,
	0x1C4A,
	0x1C50,
	0x1C5A,
	0xA620,
	0xA62A,
	0xA8D0,
	0xA8DA,
	0xA900,
	0xA90A,
	0xA9D0,
	0xA9DA,
	0xA9F0,
	0xA9FA,
	0xAA50,
	0xAA5A,
	0xABF0,
	0xABFA,
	0xFF10,
	0xFF1A,
	0x104A0,
	0x104AA,
	0x10D30,
	0x10D3A,
	0x11066,
	0x11070,
	0x110F0,
	0x110FA,
	0x11136,
	0x11140,
	0x111D0,
	0x111DA,
	0x112F0,
	0x112FA,
	0x11450,
	0x1145A,
	0x114D0,
	0x114DA,
	0x11650,
	0x1165A,
	0x116C0,
	0x116CA,
	0x11730,
	0x1173A,
	0x118E0,
	0x118EA,
	0x11950,
	0x1195A,
	0x11C50,
	0x11C5A,
	0x11D50,
	0x11D5A,
	0x11DA0,
	0x11DAA,
	0x16A60,
	0x16A6A,
	0x16AC0,
	0x16ACA,
	0x16B50,
	0x16B5A,
	0x1D7CE,
	0x1D800,
	0x1E140,
	0x1E14A,
	0x1E2F0,
	0x1E2FA,
	0x1E950,
	0x1E95A,
	0x1FBF0,
	0x1FBFA
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__NU_invlist[] = {  /* for EBCDIC 037 */
	127,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xF0,
	0xFA,
	0x660,
	0x66A,
	0x66B,
	0x66C,
	0x6F0,
	0x6FA,
	0x7C0,
	0x7CA,
	0x966,
	0x970,
	0x9E6,
	0x9F0,
	0xA66,
	0xA70,
	0xAE6,
	0xAF0,
	0xB66,
	0xB70,
	0xBE6,
	0xBF0,
	0xC66,
	0xC70,
	0xCE6,
	0xCF0,
	0xD66,
	0xD70,
	0xDE6,
	0xDF0,
	0xE50,
	0xE5A,
	0xED0,
	0xEDA,
	0xF20,
	0xF2A,
	0x1040,
	0x104A,
	0x1090,
	0x109A,
	0x17E0,
	0x17EA,
	0x1810,
	0x181A,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A80,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1B50,
	0x1B5A,
	0x1BB0,
	0x1BBA,
	0x1C40,
	0x1C4A,
	0x1C50,
	0x1C5A,
	0xA620,
	0xA62A,
	0xA8D0,
	0xA8DA,
	0xA900,
	0xA90A,
	0xA9D0,
	0xA9DA,
	0xA9F0,
	0xA9FA,
	0xAA50,
	0xAA5A,
	0xABF0,
	0xABFA,
	0xFF10,
	0xFF1A,
	0x104A0,
	0x104AA,
	0x10D30,
	0x10D3A,
	0x11066,
	0x11070,
	0x110F0,
	0x110FA,
	0x11136,
	0x11140,
	0x111D0,
	0x111DA,
	0x112F0,
	0x112FA,
	0x11450,
	0x1145A,
	0x114D0,
	0x114DA,
	0x11650,
	0x1165A,
	0x116C0,
	0x116CA,
	0x11730,
	0x1173A,
	0x118E0,
	0x118EA,
	0x11950,
	0x1195A,
	0x11C50,
	0x11C5A,
	0x11D50,
	0x11D5A,
	0x11DA0,
	0x11DAA,
	0x16A60,
	0x16A6A,
	0x16AC0,
	0x16ACA,
	0x16B50,
	0x16B5A,
	0x1D7CE,
	0x1D800,
	0x1E140,
	0x1E14A,
	0x1E2F0,
	0x1E2FA,
	0x1E950,
	0x1E95A,
	0x1FBF0,
	0x1FBFA
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__SQ_invlist[] = {  /* for ASCII/Latin1 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x27,
	0x28
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__SQ_invlist[] = {  /* for EBCDIC 1047 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7D,
	0x7E
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__SQ_invlist[] = {  /* for EBCDIC 037 */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x7D,
	0x7E
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__WSEGSPACE_invlist[] = {  /* for ASCII/Latin1 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x20,
	0x21,
	0x1680,
	0x1681,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__WSEGSPACE_invlist[] = {  /* for EBCDIC 1047 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x41,
	0x1680,
	0x1681,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__WSEGSPACE_invlist[] = {  /* for EBCDIC 037 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x41,
	0x1680,
	0x1681,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_WB__XX_invlist[] = {  /* for ASCII/Latin1 */
	1541,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA,
	0xE,
	0x20,
	0x21,
	0x22,
	0x23,
	0x27,
	0x28,
	0x2C,
	0x2D,
	0x2E,
	0x2F,
	0x30,
	0x3C,
	0x41,
	0x5B,
	0x5F,
	0x60,
	0x61,
	0x7B,
	0x85,
	0x86,
	0xAA,
	0xAB,
	0xAD,
	0xAE,
	0xB5,
	0xB6,
	0xB7,
	0xB8,
	0xBA,
	0xBB,
	0xC0,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2D8,
	0x2DE,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x58B,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F5,
	0x600,
	0x606,
	0x60C,
	0x60E,
	0x610,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x66A,
	0x66B,
	0x66D,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x70F,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7F8,
	0x7F9,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x890,
	0x892,
	0x898,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE31,
	0xE32,
	0xE34,
	0xE3B,
	0xE47,
	0xE4F,
	0xE50,
	0xE5A,
	0xEB1,
	0xEB2,
	0xEB4,
	0xEBD,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x102B,
	0x103F,
	0x1040,
	0x104A,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x17B4,
	0x17D4,
	0x17DD,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A00,
	0x1A1C,
	0x1A55,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AB0,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x200C,
	0x2010,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0x2027,
	0x2030,
	0x203F,
	0x2041,
	0x2044,
	0x2045,
	0x2054,
	0x2055,
	0x205F,
	0x2065,
	0x2066,
	0x2070,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x2E2F,
	0x2E30,
	0x3000,
	0x3001,
	0x3005,
	0x3006,
	0x302A,
	0x3030,
	0x3031,
	0x3036,
	0x303B,
	0x303D,
	0x3099,
	0x309D,
	0x30A0,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x32D0,
	0x32FF,
	0x3300,
	0x3358,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA673,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE00,
	0xFE11,
	0xFE13,
	0xFE15,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE51,
	0xFE52,
	0xFE53,
	0xFE54,
	0xFE56,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFEFF,
	0xFF00,
	0xFF07,
	0xFF08,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF10,
	0xFF1C,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0xFFF9,
	0xFFFC,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110BD,
	0x110BE,
	0x110C2,
	0x110C3,
	0x110CD,
	0x110CE,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x13430,
	0x13439,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B001,
	0x1B120,
	0x1B123,
	0x1B164,
	0x1B168,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1BCA0,
	0x1BCA4,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A,
	0x1F1E6,
	0x1F200,
	0x1F3FB,
	0x1F400,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080,
	0xE0100,
	0xE01F0
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_WB__XX_invlist[] = {  /* for EBCDIC 1047 */
	1565,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xB,
	0xE,
	0x15,
	0x16,
	0x25,
	0x26,
	0x40,
	0x41,
	0x42,
	0x4A,
	0x4B,
	0x4C,
	0x51,
	0x5A,
	0x5E,
	0x5F,
	0x62,
	0x6A,
	0x6B,
	0x6C,
	0x6D,
	0x6E,
	0x70,
	0x79,
	0x7A,
	0x7B,
	0x7D,
	0x7E,
	0x7F,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAD,
	0xAE,
	0xAF,
	0xB3,
	0xB4,
	0xBA,
	0xBB,
	0xC1,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xFA,
	0xFB,
	0xFF,
	0x100,
	0x2D8,
	0x2DE,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x58B,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F5,
	0x600,
	0x606,
	0x60C,
	0x60E,
	0x610,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x66A,
	0x66B,
	0x66D,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x70F,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7F8,
	0x7F9,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x890,
	0x892,
	0x898,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE31,
	0xE32,
	0xE34,
	0xE3B,
	0xE47,
	0xE4F,
	0xE50,
	0xE5A,
	0xEB1,
	0xEB2,
	0xEB4,
	0xEBD,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x102B,
	0x103F,
	0x1040,
	0x104A,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x17B4,
	0x17D4,
	0x17DD,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A00,
	0x1A1C,
	0x1A55,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AB0,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x200C,
	0x2010,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0x2027,
	0x2030,
	0x203F,
	0x2041,
	0x2044,
	0x2045,
	0x2054,
	0x2055,
	0x205F,
	0x2065,
	0x2066,
	0x2070,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x2E2F,
	0x2E30,
	0x3000,
	0x3001,
	0x3005,
	0x3006,
	0x302A,
	0x3030,
	0x3031,
	0x3036,
	0x303B,
	0x303D,
	0x3099,
	0x309D,
	0x30A0,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x32D0,
	0x32FF,
	0x3300,
	0x3358,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA673,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE00,
	0xFE11,
	0xFE13,
	0xFE15,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE51,
	0xFE52,
	0xFE53,
	0xFE54,
	0xFE56,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFEFF,
	0xFF00,
	0xFF07,
	0xFF08,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF10,
	0xFF1C,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0xFFF9,
	0xFFFC,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110BD,
	0x110BE,
	0x110C2,
	0x110C3,
	0x110CD,
	0x110CE,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x13430,
	0x13439,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B001,
	0x1B120,
	0x1B123,
	0x1B164,
	0x1B168,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1BCA0,
	0x1BCA4,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A,
	0x1F1E6,
	0x1F200,
	0x1F3FB,
	0x1F400,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080,
	0xE0100,
	0xE01F0
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_WB__XX_invlist[] = {  /* for EBCDIC 037 */
	1561,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xB,
	0xE,
	0x15,
	0x16,
	0x25,
	0x26,
	0x40,
	0x41,
	0x42,
	0x4A,
	0x4B,
	0x4C,
	0x51,
	0x5A,
	0x5E,
	0x5F,
	0x62,
	0x6A,
	0x6B,
	0x6C,
	0x6D,
	0x6E,
	0x70,
	0x79,
	0x7A,
	0x7B,
	0x7D,
	0x7E,
	0x7F,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xB3,
	0xB4,
	0xC1,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xFA,
	0xFB,
	0xFF,
	0x100,
	0x2D8,
	0x2DE,
	0x375,
	0x376,
	0x378,
	0x37A,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55D,
	0x55E,
	0x58B,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F5,
	0x600,
	0x606,
	0x60C,
	0x60E,
	0x610,
	0x61B,
	0x61C,
	0x61D,
	0x620,
	0x66A,
	0x66B,
	0x66D,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DE,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x70F,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7F8,
	0x7F9,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x890,
	0x892,
	0x898,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE31,
	0xE32,
	0xE34,
	0xE3B,
	0xE47,
	0xE4F,
	0xE50,
	0xE5A,
	0xEB1,
	0xEB2,
	0xEB4,
	0xEBD,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x102B,
	0x103F,
	0x1040,
	0x104A,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x17B4,
	0x17D4,
	0x17DD,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x1950,
	0x19D0,
	0x19DA,
	0x1A00,
	0x1A1C,
	0x1A55,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AB0,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2000,
	0x2007,
	0x2008,
	0x200B,
	0x200C,
	0x2010,
	0x2018,
	0x201A,
	0x2024,
	0x2025,
	0x2027,
	0x2030,
	0x203F,
	0x2041,
	0x2044,
	0x2045,
	0x2054,
	0x2055,
	0x205F,
	0x2065,
	0x2066,
	0x2070,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2119,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x212E,
	0x212F,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x24B6,
	0x24EA,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x2E2F,
	0x2E30,
	0x3000,
	0x3001,
	0x3005,
	0x3006,
	0x302A,
	0x3030,
	0x3031,
	0x3036,
	0x303B,
	0x303D,
	0x3099,
	0x309D,
	0x30A0,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x32D0,
	0x32FF,
	0x3300,
	0x3358,
	0xA000,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA673,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA708,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFC,
	0xFE00,
	0xFE11,
	0xFE13,
	0xFE15,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE51,
	0xFE52,
	0xFE53,
	0xFE54,
	0xFE56,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFEFF,
	0xFF00,
	0xFF07,
	0xFF08,
	0xFF0C,
	0xFF0D,
	0xFF0E,
	0xFF0F,
	0xFF10,
	0xFF1C,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0xFFF9,
	0xFFFC,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110BD,
	0x110BE,
	0x110C2,
	0x110C3,
	0x110CD,
	0x110CE,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x13430,
	0x13439,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B001,
	0x1B120,
	0x1B123,
	0x1B164,
	0x1B168,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1BCA0,
	0x1BCA4,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1F130,
	0x1F14A,
	0x1F150,
	0x1F16A,
	0x1F170,
	0x1F18A,
	0x1F1E6,
	0x1F200,
	0x1F3FB,
	0x1F400,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080,
	0xE0100,
	0xE01F0
};

#  endif	/* EBCDIC 037 */

static const UV UNI_WCHO_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1E2C0,
	0x1E2FA,
	0x1E2FF,
	0x1E300
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_XIDC_invlist[] = {  /* for ASCII/Latin1 */
	1527,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x30,
	0x3A,
	0x41,
	0x5B,
	0x5F,
	0x60,
	0x61,
	0x7B,
	0xAA,
	0xAB,
	0xB5,
	0xB6,
	0xB7,
	0xB8,
	0xBA,
	0xBB,
	0xC0,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x488,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x610,
	0x61B,
	0x620,
	0x66A,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DD,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x898,
	0x8E2,
	0x8E3,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE01,
	0xE3B,
	0xE40,
	0xE4F,
	0xE50,
	0xE5A,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x1000,
	0x104A,
	0x1050,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1369,
	0x1372,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x1780,
	0x17D4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x180E,
	0x180F,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x19D0,
	0x19DB,
	0x1A00,
	0x1A1C,
	0x1A20,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AA7,
	0x1AA8,
	0x1AB0,
	0x1ABE,
	0x1ABF,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x3005,
	0x3008,
	0x3021,
	0x3030,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x3099,
	0x309B,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA670,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E0,
	0xA9FF,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF10,
	0xFF1A,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110C2,
	0x110C3,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x11700,
	0x1171B,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11740,
	0x11747,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D173,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1FBF0,
	0x1FBFA,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B,
	0xE0100,
	0xE01F0
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_XIDC_invlist[] = {  /* for EBCDIC 1047 */
	1551,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x6D,
	0x6E,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAD,
	0xAE,
	0xAF,
	0xB3,
	0xB4,
	0xBA,
	0xBB,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xFA,
	0xFB,
	0xFF,
	0x100,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x488,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x610,
	0x61B,
	0x620,
	0x66A,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DD,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x898,
	0x8E2,
	0x8E3,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE01,
	0xE3B,
	0xE40,
	0xE4F,
	0xE50,
	0xE5A,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x1000,
	0x104A,
	0x1050,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1369,
	0x1372,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x1780,
	0x17D4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x180E,
	0x180F,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x19D0,
	0x19DB,
	0x1A00,
	0x1A1C,
	0x1A20,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AA7,
	0x1AA8,
	0x1AB0,
	0x1ABE,
	0x1ABF,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x3005,
	0x3008,
	0x3021,
	0x3030,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x3099,
	0x309B,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA670,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E0,
	0xA9FF,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF10,
	0xFF1A,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110C2,
	0x110C3,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x11700,
	0x1171B,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11740,
	0x11747,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D173,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1FBF0,
	0x1FBFA,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B,
	0xE0100,
	0xE01F0
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_XIDC_invlist[] = {  /* for EBCDIC 037 */
	1547,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x6D,
	0x6E,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xB3,
	0xB4,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xFA,
	0xFB,
	0xFF,
	0x100,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x300,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x483,
	0x488,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x591,
	0x5BE,
	0x5BF,
	0x5C0,
	0x5C1,
	0x5C3,
	0x5C4,
	0x5C6,
	0x5C7,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x610,
	0x61B,
	0x620,
	0x66A,
	0x66E,
	0x6D4,
	0x6D5,
	0x6DD,
	0x6DF,
	0x6E9,
	0x6EA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7F6,
	0x7FA,
	0x7FB,
	0x7FD,
	0x7FE,
	0x800,
	0x82E,
	0x840,
	0x85C,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x898,
	0x8E2,
	0x8E3,
	0x964,
	0x966,
	0x970,
	0x971,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9F2,
	0x9FC,
	0x9FD,
	0x9FE,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA76,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF0,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB70,
	0xB71,
	0xB72,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBF0,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC80,
	0xC84,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD4F,
	0xD54,
	0xD58,
	0xD5F,
	0xD64,
	0xD66,
	0xD70,
	0xD7A,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF4,
	0xE01,
	0xE3B,
	0xE40,
	0xE4F,
	0xE50,
	0xE5A,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF18,
	0xF1A,
	0xF20,
	0xF2A,
	0xF35,
	0xF36,
	0xF37,
	0xF38,
	0xF39,
	0xF3A,
	0xF3E,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF85,
	0xF86,
	0xF98,
	0xF99,
	0xFBD,
	0xFC6,
	0xFC7,
	0x1000,
	0x104A,
	0x1050,
	0x109E,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x1360,
	0x1369,
	0x1372,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1735,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x1780,
	0x17D4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DE,
	0x17E0,
	0x17EA,
	0x180B,
	0x180E,
	0x180F,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1946,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x19D0,
	0x19DB,
	0x1A00,
	0x1A1C,
	0x1A20,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AA7,
	0x1AA8,
	0x1AB0,
	0x1ABE,
	0x1ABF,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B5A,
	0x1B6B,
	0x1B74,
	0x1B80,
	0x1BF4,
	0x1C00,
	0x1C38,
	0x1C40,
	0x1C4A,
	0x1C4D,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CD0,
	0x1CD3,
	0x1CD4,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x203F,
	0x2041,
	0x2054,
	0x2055,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x20D0,
	0x20DD,
	0x20E1,
	0x20E2,
	0x20E5,
	0x20F1,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E00,
	0x3005,
	0x3008,
	0x3021,
	0x3030,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x3099,
	0x309B,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA62C,
	0xA640,
	0xA670,
	0xA674,
	0xA67E,
	0xA67F,
	0xA6F2,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA828,
	0xA82C,
	0xA82D,
	0xA840,
	0xA874,
	0xA880,
	0xA8C6,
	0xA8D0,
	0xA8DA,
	0xA8E0,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA92E,
	0xA930,
	0xA954,
	0xA960,
	0xA97D,
	0xA980,
	0xA9C1,
	0xA9CF,
	0xA9DA,
	0xA9E0,
	0xA9FF,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAF0,
	0xAAF2,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABEB,
	0xABEC,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE00,
	0xFE10,
	0xFE20,
	0xFE30,
	0xFE33,
	0xFE35,
	0xFE4D,
	0xFE50,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF10,
	0xFF1A,
	0xFF21,
	0xFF3B,
	0xFF3F,
	0xFF40,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x101FD,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102E1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A40,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE7,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAD,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F51,
	0x10F70,
	0x10F86,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x11047,
	0x11066,
	0x11076,
	0x1107F,
	0x110BB,
	0x110C2,
	0x110C3,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11140,
	0x11144,
	0x11148,
	0x11150,
	0x11174,
	0x11176,
	0x11177,
	0x11180,
	0x111C5,
	0x111C9,
	0x111CD,
	0x111CE,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x11238,
	0x1123E,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1144B,
	0x11450,
	0x1145A,
	0x1145E,
	0x11462,
	0x11480,
	0x114C6,
	0x114C7,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115C1,
	0x115D8,
	0x115DE,
	0x11600,
	0x11641,
	0x11644,
	0x11645,
	0x11650,
	0x1165A,
	0x11680,
	0x116B9,
	0x116C0,
	0x116CA,
	0x11700,
	0x1171B,
	0x1171D,
	0x1172C,
	0x11730,
	0x1173A,
	0x11740,
	0x11747,
	0x11800,
	0x1183B,
	0x118A0,
	0x118EA,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11944,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E2,
	0x119E3,
	0x119E5,
	0x11A00,
	0x11A3F,
	0x11A47,
	0x11A48,
	0x11A50,
	0x11A9A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C41,
	0x11C50,
	0x11C5A,
	0x11C72,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF7,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A70,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF5,
	0x16B00,
	0x16B37,
	0x16B40,
	0x16B44,
	0x16B50,
	0x16B5A,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9D,
	0x1BC9F,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1D165,
	0x1D16A,
	0x1D16D,
	0x1D173,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D242,
	0x1D245,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1DA00,
	0x1DA37,
	0x1DA3B,
	0x1DA6D,
	0x1DA75,
	0x1DA76,
	0x1DA84,
	0x1DA85,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8D0,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1FBF0,
	0x1FBFA,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B,
	0xE0100,
	0xE01F0
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_XIDS_invlist[] = {  /* for ASCII/Latin1 */
	1311,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x41,
	0x5B,
	0x61,
	0x7B,
	0xAA,
	0xAB,
	0xB5,
	0xB6,
	0xBA,
	0xBB,
	0xC0,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xE01,
	0xE31,
	0xE32,
	0xE33,
	0xE40,
	0xE47,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEB1,
	0xEB2,
	0xEB3,
	0xEBD,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x1000,
	0x102B,
	0x103F,
	0x1040,
	0x1050,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1780,
	0x17B4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DD,
	0x1820,
	0x1879,
	0x1880,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1950,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x1A00,
	0x1A17,
	0x1A20,
	0x1A55,
	0x1AA7,
	0x1AA8,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x3005,
	0x3008,
	0x3021,
	0x302A,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xA9E0,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xA9FF,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB1E,
	0xFB1F,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFF9E,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11700,
	0x1171B,
	0x11740,
	0x11747,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_XIDS_invlist[] = {  /* for EBCDIC 1047 */
	1337,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAD,
	0xAE,
	0xAF,
	0xBA,
	0xBB,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xE01,
	0xE31,
	0xE32,
	0xE33,
	0xE40,
	0xE47,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEB1,
	0xEB2,
	0xEB3,
	0xEBD,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x1000,
	0x102B,
	0x103F,
	0x1040,
	0x1050,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1780,
	0x17B4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DD,
	0x1820,
	0x1879,
	0x1880,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1950,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x1A00,
	0x1A17,
	0x1A20,
	0x1A55,
	0x1AA7,
	0x1AA8,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x3005,
	0x3008,
	0x3021,
	0x302A,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xA9E0,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xA9FF,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB1E,
	0xFB1F,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFF9E,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11700,
	0x1171B,
	0x11740,
	0x11747,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_XIDS_invlist[] = {  /* for EBCDIC 037 */
	1333,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA0,
	0xA1,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2C2,
	0x2C6,
	0x2D2,
	0x2E0,
	0x2E5,
	0x2EC,
	0x2ED,
	0x2EE,
	0x2EF,
	0x370,
	0x375,
	0x376,
	0x378,
	0x37B,
	0x37E,
	0x37F,
	0x380,
	0x386,
	0x387,
	0x388,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x3F6,
	0x3F7,
	0x482,
	0x48A,
	0x530,
	0x531,
	0x557,
	0x559,
	0x55A,
	0x560,
	0x589,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F3,
	0x620,
	0x64B,
	0x66E,
	0x670,
	0x671,
	0x6D4,
	0x6D5,
	0x6D6,
	0x6E5,
	0x6E7,
	0x6EE,
	0x6F0,
	0x6FA,
	0x6FD,
	0x6FF,
	0x700,
	0x710,
	0x711,
	0x712,
	0x730,
	0x74D,
	0x7A6,
	0x7B1,
	0x7B2,
	0x7CA,
	0x7EB,
	0x7F4,
	0x7F6,
	0x7FA,
	0x7FB,
	0x800,
	0x816,
	0x81A,
	0x81B,
	0x824,
	0x825,
	0x828,
	0x829,
	0x840,
	0x859,
	0x860,
	0x86B,
	0x870,
	0x888,
	0x889,
	0x88F,
	0x8A0,
	0x8CA,
	0x904,
	0x93A,
	0x93D,
	0x93E,
	0x950,
	0x951,
	0x958,
	0x962,
	0x971,
	0x981,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BD,
	0x9BE,
	0x9CE,
	0x9CF,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E2,
	0x9F0,
	0x9F2,
	0x9FC,
	0x9FD,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA72,
	0xA75,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABD,
	0xABE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE2,
	0xAF9,
	0xAFA,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3D,
	0xB3E,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB62,
	0xB71,
	0xB72,
	0xB83,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBD0,
	0xBD1,
	0xC05,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3D,
	0xC3E,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC62,
	0xC80,
	0xC81,
	0xC85,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBD,
	0xCBE,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE2,
	0xCF1,
	0xCF3,
	0xD04,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD3B,
	0xD3D,
	0xD3E,
	0xD4E,
	0xD4F,
	0xD54,
	0xD57,
	0xD5F,
	0xD62,
	0xD7A,
	0xD80,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xE01,
	0xE31,
	0xE32,
	0xE33,
	0xE40,
	0xE47,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEB1,
	0xEB2,
	0xEB3,
	0xEBD,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEDC,
	0xEE0,
	0xF00,
	0xF01,
	0xF40,
	0xF48,
	0xF49,
	0xF6D,
	0xF88,
	0xF8D,
	0x1000,
	0x102B,
	0x103F,
	0x1040,
	0x1050,
	0x1056,
	0x105A,
	0x105E,
	0x1061,
	0x1062,
	0x1065,
	0x1067,
	0x106E,
	0x1071,
	0x1075,
	0x1082,
	0x108E,
	0x108F,
	0x10A0,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x10FB,
	0x10FC,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x1380,
	0x1390,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1401,
	0x166D,
	0x166F,
	0x1680,
	0x1681,
	0x169B,
	0x16A0,
	0x16EB,
	0x16EE,
	0x16F9,
	0x1700,
	0x1712,
	0x171F,
	0x1732,
	0x1740,
	0x1752,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1780,
	0x17B4,
	0x17D7,
	0x17D8,
	0x17DC,
	0x17DD,
	0x1820,
	0x1879,
	0x1880,
	0x18A9,
	0x18AA,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1950,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x1A00,
	0x1A17,
	0x1A20,
	0x1A55,
	0x1AA7,
	0x1AA8,
	0x1B05,
	0x1B34,
	0x1B45,
	0x1B4D,
	0x1B83,
	0x1BA1,
	0x1BAE,
	0x1BB0,
	0x1BBA,
	0x1BE6,
	0x1C00,
	0x1C24,
	0x1C4D,
	0x1C50,
	0x1C5A,
	0x1C7E,
	0x1C80,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC0,
	0x1CE9,
	0x1CED,
	0x1CEE,
	0x1CF4,
	0x1CF5,
	0x1CF7,
	0x1CFA,
	0x1CFB,
	0x1D00,
	0x1DC0,
	0x1E00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FBD,
	0x1FBE,
	0x1FBF,
	0x1FC2,
	0x1FC5,
	0x1FC6,
	0x1FCD,
	0x1FD0,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FE0,
	0x1FED,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFD,
	0x2071,
	0x2072,
	0x207F,
	0x2080,
	0x2090,
	0x209D,
	0x2102,
	0x2103,
	0x2107,
	0x2108,
	0x210A,
	0x2114,
	0x2115,
	0x2116,
	0x2118,
	0x211E,
	0x2124,
	0x2125,
	0x2126,
	0x2127,
	0x2128,
	0x2129,
	0x212A,
	0x213A,
	0x213C,
	0x2140,
	0x2145,
	0x214A,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x2C00,
	0x2CE5,
	0x2CEB,
	0x2CEF,
	0x2CF2,
	0x2CF4,
	0x2D00,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D70,
	0x2D80,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x3005,
	0x3008,
	0x3021,
	0x302A,
	0x3031,
	0x3036,
	0x3038,
	0x303D,
	0x3041,
	0x3097,
	0x309D,
	0x30A0,
	0x30A1,
	0x30FB,
	0x30FC,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x31A0,
	0x31C0,
	0x31F0,
	0x3200,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA48D,
	0xA4D0,
	0xA4FE,
	0xA500,
	0xA60D,
	0xA610,
	0xA620,
	0xA62A,
	0xA62C,
	0xA640,
	0xA66F,
	0xA67F,
	0xA69E,
	0xA6A0,
	0xA6F0,
	0xA717,
	0xA720,
	0xA722,
	0xA789,
	0xA78B,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA802,
	0xA803,
	0xA806,
	0xA807,
	0xA80B,
	0xA80C,
	0xA823,
	0xA840,
	0xA874,
	0xA882,
	0xA8B4,
	0xA8F2,
	0xA8F8,
	0xA8FB,
	0xA8FC,
	0xA8FD,
	0xA8FF,
	0xA90A,
	0xA926,
	0xA930,
	0xA947,
	0xA960,
	0xA97D,
	0xA984,
	0xA9B3,
	0xA9CF,
	0xA9D0,
	0xA9E0,
	0xA9E5,
	0xA9E6,
	0xA9F0,
	0xA9FA,
	0xA9FF,
	0xAA00,
	0xAA29,
	0xAA40,
	0xAA43,
	0xAA44,
	0xAA4C,
	0xAA60,
	0xAA77,
	0xAA7A,
	0xAA7B,
	0xAA7E,
	0xAAB0,
	0xAAB1,
	0xAAB2,
	0xAAB5,
	0xAAB7,
	0xAAB9,
	0xAABE,
	0xAAC0,
	0xAAC1,
	0xAAC2,
	0xAAC3,
	0xAADB,
	0xAADE,
	0xAAE0,
	0xAAEB,
	0xAAF2,
	0xAAF5,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB70,
	0xABE3,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB1E,
	0xFB1F,
	0xFB29,
	0xFB2A,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBB2,
	0xFBD3,
	0xFC5E,
	0xFC64,
	0xFD3E,
	0xFD50,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDF0,
	0xFDFA,
	0xFE71,
	0xFE72,
	0xFE73,
	0xFE74,
	0xFE77,
	0xFE78,
	0xFE79,
	0xFE7A,
	0xFE7B,
	0xFE7C,
	0xFE7D,
	0xFE7E,
	0xFE7F,
	0xFEFD,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF66,
	0xFF9E,
	0xFFA0,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10140,
	0x10175,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x10300,
	0x10320,
	0x1032D,
	0x1034B,
	0x10350,
	0x10376,
	0x10380,
	0x1039E,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D0,
	0x103D1,
	0x103D6,
	0x10400,
	0x1049E,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x10570,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10860,
	0x10877,
	0x10880,
	0x1089F,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x10900,
	0x10916,
	0x10920,
	0x1093A,
	0x10980,
	0x109B8,
	0x109BE,
	0x109C0,
	0x10A00,
	0x10A01,
	0x10A10,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A60,
	0x10A7D,
	0x10A80,
	0x10A9D,
	0x10AC0,
	0x10AC8,
	0x10AC9,
	0x10AE5,
	0x10B00,
	0x10B36,
	0x10B40,
	0x10B56,
	0x10B60,
	0x10B73,
	0x10B80,
	0x10B92,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10D00,
	0x10D24,
	0x10E80,
	0x10EAA,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F1D,
	0x10F27,
	0x10F28,
	0x10F30,
	0x10F46,
	0x10F70,
	0x10F82,
	0x10FB0,
	0x10FC5,
	0x10FE0,
	0x10FF7,
	0x11003,
	0x11038,
	0x11071,
	0x11073,
	0x11075,
	0x11076,
	0x11083,
	0x110B0,
	0x110D0,
	0x110E9,
	0x11103,
	0x11127,
	0x11144,
	0x11145,
	0x11147,
	0x11148,
	0x11150,
	0x11173,
	0x11176,
	0x11177,
	0x11183,
	0x111B3,
	0x111C1,
	0x111C5,
	0x111DA,
	0x111DB,
	0x111DC,
	0x111DD,
	0x11200,
	0x11212,
	0x11213,
	0x1122C,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112A9,
	0x112B0,
	0x112DF,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133D,
	0x1133E,
	0x11350,
	0x11351,
	0x1135D,
	0x11362,
	0x11400,
	0x11435,
	0x11447,
	0x1144B,
	0x1145F,
	0x11462,
	0x11480,
	0x114B0,
	0x114C4,
	0x114C6,
	0x114C7,
	0x114C8,
	0x11580,
	0x115AF,
	0x115D8,
	0x115DC,
	0x11600,
	0x11630,
	0x11644,
	0x11645,
	0x11680,
	0x116AB,
	0x116B8,
	0x116B9,
	0x11700,
	0x1171B,
	0x11740,
	0x11747,
	0x11800,
	0x1182C,
	0x118A0,
	0x118E0,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11930,
	0x1193F,
	0x11940,
	0x11941,
	0x11942,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D1,
	0x119E1,
	0x119E2,
	0x119E3,
	0x119E4,
	0x11A00,
	0x11A01,
	0x11A0B,
	0x11A33,
	0x11A3A,
	0x11A3B,
	0x11A50,
	0x11A51,
	0x11A5C,
	0x11A8A,
	0x11A9D,
	0x11A9E,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C2F,
	0x11C40,
	0x11C41,
	0x11C72,
	0x11C90,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D31,
	0x11D46,
	0x11D47,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8A,
	0x11D98,
	0x11D99,
	0x11EE0,
	0x11EF3,
	0x11FB0,
	0x11FB1,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF1,
	0x13000,
	0x1342F,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A70,
	0x16ABF,
	0x16AD0,
	0x16AEE,
	0x16B00,
	0x16B30,
	0x16B40,
	0x16B44,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E80,
	0x16F00,
	0x16F4B,
	0x16F50,
	0x16F51,
	0x16F93,
	0x16FA0,
	0x16FE0,
	0x16FE2,
	0x16FE3,
	0x16FE4,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D6C1,
	0x1D6C2,
	0x1D6DB,
	0x1D6DC,
	0x1D6FB,
	0x1D6FC,
	0x1D715,
	0x1D716,
	0x1D735,
	0x1D736,
	0x1D74F,
	0x1D750,
	0x1D76F,
	0x1D770,
	0x1D789,
	0x1D78A,
	0x1D7A9,
	0x1D7AA,
	0x1D7C3,
	0x1D7C4,
	0x1D7CC,
	0x1DF00,
	0x1DF1F,
	0x1E100,
	0x1E12D,
	0x1E137,
	0x1E13E,
	0x1E14E,
	0x1E14F,
	0x1E290,
	0x1E2AE,
	0x1E2C0,
	0x1E2EC,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E900,
	0x1E944,
	0x1E94B,
	0x1E94C,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B
};

#  endif	/* EBCDIC 037 */

static const UV UNI_XPEO_invlist[] = {  /* for all charsets */
	5,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x103A0,
	0x103C4,
	0x103C8,
	0x103D6
};

static const UV UNI_XSUX_invlist[] = {  /* for all charsets */
	9,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x12000,
	0x1239A,
	0x12400,
	0x1246F,
	0x12470,
	0x12475,
	0x12480,
	0x12544
};

static const UV UNI_YEZI_invlist[] = {  /* for all charsets */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x60C,
	0x60D,
	0x61B,
	0x61C,
	0x61F,
	0x620,
	0x660,
	0x66A,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAE,
	0x10EB0,
	0x10EB2
};

static const UV UNI_YI_invlist[] = {  /* for all charsets */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x3001,
	0x3003,
	0x3008,
	0x3012,
	0x3014,
	0x301C,
	0x30FB,
	0x30FC,
	0xA000,
	0xA48D,
	0xA490,
	0xA4C7,
	0xFF61,
	0xFF66
};

static const UV UNI_YIJING_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x4DC0,
	0x4E00
};

static const UV UNI_YIRADICALS_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA490,
	0xA4D0
};

static const UV UNI_YISYLLABLES_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xA000,
	0xA490
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_Z_invlist[] = {  /* for ASCII/Latin1 */
	17,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x20,
	0x21,
	0xA0,
	0xA1,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x2028,
	0x202A,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_Z_invlist[] = {  /* for EBCDIC 1047 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x42,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x2028,
	0x202A,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_Z_invlist[] = {  /* for EBCDIC 037 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x42,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x2028,
	0x202A,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 037 */

static const UV UNI_ZANB_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x11A00,
	0x11A48
};

static const UV UNI_ZL_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2028,
	0x2029
};

static const UV UNI_ZNAMENNYMUSIC_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x1CF00,
	0x1CFD0
};

static const UV UNI_ZP_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x2029,
	0x202A
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_ZS_invlist[] = {  /* for ASCII/Latin1 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x20,
	0x21,
	0xA0,
	0xA1,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_ZS_invlist[] = {  /* for EBCDIC 1047 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x42,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_ZS_invlist[] = {  /* for EBCDIC 037 */
	13,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x40,
	0x42,
	0x1680,
	0x1681,
	0x2000,
	0x200B,
	0x202F,
	0x2030,
	0x205F,
	0x2060,
	0x3000,
	0x3001
};

#  endif	/* EBCDIC 037 */

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI_ZYYY_invlist[] = {  /* for ASCII/Latin1 */
	296,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x41,
	0x5B,
	0x61,
	0x7B,
	0xAA,
	0xAB,
	0xBA,
	0xBB,
	0xC0,
	0xD7,
	0xD8,
	0xF7,
	0xF8,
	0x2B9,
	0x2E0,
	0x2E5,
	0x2EA,
	0x2EC,
	0x300,
	0x374,
	0x375,
	0x37E,
	0x37F,
	0x385,
	0x386,
	0x387,
	0x388,
	0x605,
	0x606,
	0x6DD,
	0x6DE,
	0x8E2,
	0x8E3,
	0xE3F,
	0xE40,
	0xFD5,
	0xFD9,
	0x16EB,
	0x16EE,
	0x2000,
	0x200C,
	0x200E,
	0x202F,
	0x2030,
	0x2065,
	0x2066,
	0x2071,
	0x2074,
	0x207F,
	0x2080,
	0x208F,
	0x20A0,
	0x20C1,
	0x2100,
	0x2126,
	0x2127,
	0x212A,
	0x212C,
	0x2132,
	0x2133,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x218C,
	0x2190,
	0x2427,
	0x2440,
	0x244B,
	0x2460,
	0x2800,
	0x2900,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2E00,
	0x2E43,
	0x2E44,
	0x2E5E,
	0x2FF0,
	0x2FFC,
	0x3000,
	0x3001,
	0x3004,
	0x3005,
	0x3012,
	0x3013,
	0x3020,
	0x3021,
	0x3036,
	0x3037,
	0x3248,
	0x3260,
	0x327F,
	0x3280,
	0x32B1,
	0x32C0,
	0x32CC,
	0x32D0,
	0x3371,
	0x337B,
	0x3380,
	0x33E0,
	0x33FF,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA708,
	0xA722,
	0xA788,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFE10,
	0xFE1A,
	0xFE30,
	0xFE45,
	0xFE47,
	0xFE53,
	0xFE54,
	0xFE67,
	0xFE68,
	0xFE6C,
	0xFEFF,
	0xFF00,
	0xFF01,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF61,
	0xFFE0,
	0xFFE7,
	0xFFE8,
	0xFFEF,
	0xFFF9,
	0xFFFE,
	0x10190,
	0x1019D,
	0x101D0,
	0x101FD,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D167,
	0x1D16A,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D2E0,
	0x1D2F4,
	0x1D300,
	0x1D357,
	0x1D372,
	0x1D379,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1EC71,
	0x1ECB5,
	0x1ED01,
	0x1ED3E,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F100,
	0x1F1AE,
	0x1F1E6,
	0x1F200,
	0x1F201,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI_ZYYY_invlist[] = {  /* for EBCDIC 1047 */
	322,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA2,
	0xAA,
	0xAC,
	0xAD,
	0xAE,
	0xAF,
	0xBA,
	0xBB,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2B9,
	0x2E0,
	0x2E5,
	0x2EA,
	0x2EC,
	0x300,
	0x374,
	0x375,
	0x37E,
	0x37F,
	0x385,
	0x386,
	0x387,
	0x388,
	0x605,
	0x606,
	0x6DD,
	0x6DE,
	0x8E2,
	0x8E3,
	0xE3F,
	0xE40,
	0xFD5,
	0xFD9,
	0x16EB,
	0x16EE,
	0x2000,
	0x200C,
	0x200E,
	0x202F,
	0x2030,
	0x2065,
	0x2066,
	0x2071,
	0x2074,
	0x207F,
	0x2080,
	0x208F,
	0x20A0,
	0x20C1,
	0x2100,
	0x2126,
	0x2127,
	0x212A,
	0x212C,
	0x2132,
	0x2133,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x218C,
	0x2190,
	0x2427,
	0x2440,
	0x244B,
	0x2460,
	0x2800,
	0x2900,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2E00,
	0x2E43,
	0x2E44,
	0x2E5E,
	0x2FF0,
	0x2FFC,
	0x3000,
	0x3001,
	0x3004,
	0x3005,
	0x3012,
	0x3013,
	0x3020,
	0x3021,
	0x3036,
	0x3037,
	0x3248,
	0x3260,
	0x327F,
	0x3280,
	0x32B1,
	0x32C0,
	0x32CC,
	0x32D0,
	0x3371,
	0x337B,
	0x3380,
	0x33E0,
	0x33FF,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA708,
	0xA722,
	0xA788,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFE10,
	0xFE1A,
	0xFE30,
	0xFE45,
	0xFE47,
	0xFE53,
	0xFE54,
	0xFE67,
	0xFE68,
	0xFE6C,
	0xFEFF,
	0xFF00,
	0xFF01,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF61,
	0xFFE0,
	0xFFE7,
	0xFFE8,
	0xFFEF,
	0xFFF9,
	0xFFFE,
	0x10190,
	0x1019D,
	0x101D0,
	0x101FD,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D167,
	0x1D16A,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D2E0,
	0x1D2F4,
	0x1D300,
	0x1D357,
	0x1D372,
	0x1D379,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1EC71,
	0x1ECB5,
	0x1ED01,
	0x1ED3E,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F100,
	0x1F1AE,
	0x1F1E6,
	0x1F200,
	0x1F201,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI_ZYYY_invlist[] = {  /* for EBCDIC 037 */
	318,	/* Number of elements */
	148565664, /* Version and data structure type */
	0,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x42,
	0x4A,
	0x51,
	0x5A,
	0x62,
	0x6A,
	0x70,
	0x79,
	0x80,
	0x8A,
	0x8C,
	0x8F,
	0x91,
	0x9D,
	0x9E,
	0x9F,
	0xA2,
	0xAA,
	0xAC,
	0xAF,
	0xC1,
	0xCA,
	0xCB,
	0xD0,
	0xD1,
	0xDA,
	0xDB,
	0xE0,
	0xE2,
	0xEA,
	0xEB,
	0xF0,
	0xFB,
	0xFF,
	0x100,
	0x2B9,
	0x2E0,
	0x2E5,
	0x2EA,
	0x2EC,
	0x300,
	0x374,
	0x375,
	0x37E,
	0x37F,
	0x385,
	0x386,
	0x387,
	0x388,
	0x605,
	0x606,
	0x6DD,
	0x6DE,
	0x8E2,
	0x8E3,
	0xE3F,
	0xE40,
	0xFD5,
	0xFD9,
	0x16EB,
	0x16EE,
	0x2000,
	0x200C,
	0x200E,
	0x202F,
	0x2030,
	0x2065,
	0x2066,
	0x2071,
	0x2074,
	0x207F,
	0x2080,
	0x208F,
	0x20A0,
	0x20C1,
	0x2100,
	0x2126,
	0x2127,
	0x212A,
	0x212C,
	0x2132,
	0x2133,
	0x214E,
	0x214F,
	0x2160,
	0x2189,
	0x218C,
	0x2190,
	0x2427,
	0x2440,
	0x244B,
	0x2460,
	0x2800,
	0x2900,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2C00,
	0x2E00,
	0x2E43,
	0x2E44,
	0x2E5E,
	0x2FF0,
	0x2FFC,
	0x3000,
	0x3001,
	0x3004,
	0x3005,
	0x3012,
	0x3013,
	0x3020,
	0x3021,
	0x3036,
	0x3037,
	0x3248,
	0x3260,
	0x327F,
	0x3280,
	0x32B1,
	0x32C0,
	0x32CC,
	0x32D0,
	0x3371,
	0x337B,
	0x3380,
	0x33E0,
	0x33FF,
	0x3400,
	0x4DC0,
	0x4E00,
	0xA708,
	0xA722,
	0xA788,
	0xA78B,
	0xAB5B,
	0xAB5C,
	0xAB6A,
	0xAB6C,
	0xFE10,
	0xFE1A,
	0xFE30,
	0xFE45,
	0xFE47,
	0xFE53,
	0xFE54,
	0xFE67,
	0xFE68,
	0xFE6C,
	0xFEFF,
	0xFF00,
	0xFF01,
	0xFF21,
	0xFF3B,
	0xFF41,
	0xFF5B,
	0xFF61,
	0xFFE0,
	0xFFE7,
	0xFFE8,
	0xFFEF,
	0xFFF9,
	0xFFFE,
	0x10190,
	0x1019D,
	0x101D0,
	0x101FD,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D167,
	0x1D16A,
	0x1D17B,
	0x1D183,
	0x1D185,
	0x1D18C,
	0x1D1AA,
	0x1D1AE,
	0x1D1EB,
	0x1D2E0,
	0x1D2F4,
	0x1D300,
	0x1D357,
	0x1D372,
	0x1D379,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D7CC,
	0x1D7CE,
	0x1D800,
	0x1EC71,
	0x1ECB5,
	0x1ED01,
	0x1ED3E,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F100,
	0x1F1AE,
	0x1F1E6,
	0x1F200,
	0x1F201,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB,
	0x1FBF0,
	0x1FBFA,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080
};

#  endif	/* EBCDIC 037 */

static const UV UNI_ZZZZ_invlist[] = {  /* for all charsets */
	1392,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x378,
	0x37A,
	0x380,
	0x384,
	0x38B,
	0x38C,
	0x38D,
	0x38E,
	0x3A2,
	0x3A3,
	0x530,
	0x531,
	0x557,
	0x559,
	0x58B,
	0x58D,
	0x590,
	0x591,
	0x5C8,
	0x5D0,
	0x5EB,
	0x5EF,
	0x5F5,
	0x600,
	0x70E,
	0x70F,
	0x74B,
	0x74D,
	0x7B2,
	0x7C0,
	0x7FB,
	0x7FD,
	0x82E,
	0x830,
	0x83F,
	0x840,
	0x85C,
	0x85E,
	0x85F,
	0x860,
	0x86B,
	0x870,
	0x88F,
	0x890,
	0x892,
	0x898,
	0x984,
	0x985,
	0x98D,
	0x98F,
	0x991,
	0x993,
	0x9A9,
	0x9AA,
	0x9B1,
	0x9B2,
	0x9B3,
	0x9B6,
	0x9BA,
	0x9BC,
	0x9C5,
	0x9C7,
	0x9C9,
	0x9CB,
	0x9CF,
	0x9D7,
	0x9D8,
	0x9DC,
	0x9DE,
	0x9DF,
	0x9E4,
	0x9E6,
	0x9FF,
	0xA01,
	0xA04,
	0xA05,
	0xA0B,
	0xA0F,
	0xA11,
	0xA13,
	0xA29,
	0xA2A,
	0xA31,
	0xA32,
	0xA34,
	0xA35,
	0xA37,
	0xA38,
	0xA3A,
	0xA3C,
	0xA3D,
	0xA3E,
	0xA43,
	0xA47,
	0xA49,
	0xA4B,
	0xA4E,
	0xA51,
	0xA52,
	0xA59,
	0xA5D,
	0xA5E,
	0xA5F,
	0xA66,
	0xA77,
	0xA81,
	0xA84,
	0xA85,
	0xA8E,
	0xA8F,
	0xA92,
	0xA93,
	0xAA9,
	0xAAA,
	0xAB1,
	0xAB2,
	0xAB4,
	0xAB5,
	0xABA,
	0xABC,
	0xAC6,
	0xAC7,
	0xACA,
	0xACB,
	0xACE,
	0xAD0,
	0xAD1,
	0xAE0,
	0xAE4,
	0xAE6,
	0xAF2,
	0xAF9,
	0xB00,
	0xB01,
	0xB04,
	0xB05,
	0xB0D,
	0xB0F,
	0xB11,
	0xB13,
	0xB29,
	0xB2A,
	0xB31,
	0xB32,
	0xB34,
	0xB35,
	0xB3A,
	0xB3C,
	0xB45,
	0xB47,
	0xB49,
	0xB4B,
	0xB4E,
	0xB55,
	0xB58,
	0xB5C,
	0xB5E,
	0xB5F,
	0xB64,
	0xB66,
	0xB78,
	0xB82,
	0xB84,
	0xB85,
	0xB8B,
	0xB8E,
	0xB91,
	0xB92,
	0xB96,
	0xB99,
	0xB9B,
	0xB9C,
	0xB9D,
	0xB9E,
	0xBA0,
	0xBA3,
	0xBA5,
	0xBA8,
	0xBAB,
	0xBAE,
	0xBBA,
	0xBBE,
	0xBC3,
	0xBC6,
	0xBC9,
	0xBCA,
	0xBCE,
	0xBD0,
	0xBD1,
	0xBD7,
	0xBD8,
	0xBE6,
	0xBFB,
	0xC00,
	0xC0D,
	0xC0E,
	0xC11,
	0xC12,
	0xC29,
	0xC2A,
	0xC3A,
	0xC3C,
	0xC45,
	0xC46,
	0xC49,
	0xC4A,
	0xC4E,
	0xC55,
	0xC57,
	0xC58,
	0xC5B,
	0xC5D,
	0xC5E,
	0xC60,
	0xC64,
	0xC66,
	0xC70,
	0xC77,
	0xC8D,
	0xC8E,
	0xC91,
	0xC92,
	0xCA9,
	0xCAA,
	0xCB4,
	0xCB5,
	0xCBA,
	0xCBC,
	0xCC5,
	0xCC6,
	0xCC9,
	0xCCA,
	0xCCE,
	0xCD5,
	0xCD7,
	0xCDD,
	0xCDF,
	0xCE0,
	0xCE4,
	0xCE6,
	0xCF0,
	0xCF1,
	0xCF3,
	0xD00,
	0xD0D,
	0xD0E,
	0xD11,
	0xD12,
	0xD45,
	0xD46,
	0xD49,
	0xD4A,
	0xD50,
	0xD54,
	0xD64,
	0xD66,
	0xD80,
	0xD81,
	0xD84,
	0xD85,
	0xD97,
	0xD9A,
	0xDB2,
	0xDB3,
	0xDBC,
	0xDBD,
	0xDBE,
	0xDC0,
	0xDC7,
	0xDCA,
	0xDCB,
	0xDCF,
	0xDD5,
	0xDD6,
	0xDD7,
	0xDD8,
	0xDE0,
	0xDE6,
	0xDF0,
	0xDF2,
	0xDF5,
	0xE01,
	0xE3B,
	0xE3F,
	0xE5C,
	0xE81,
	0xE83,
	0xE84,
	0xE85,
	0xE86,
	0xE8B,
	0xE8C,
	0xEA4,
	0xEA5,
	0xEA6,
	0xEA7,
	0xEBE,
	0xEC0,
	0xEC5,
	0xEC6,
	0xEC7,
	0xEC8,
	0xECE,
	0xED0,
	0xEDA,
	0xEDC,
	0xEE0,
	0xF00,
	0xF48,
	0xF49,
	0xF6D,
	0xF71,
	0xF98,
	0xF99,
	0xFBD,
	0xFBE,
	0xFCD,
	0xFCE,
	0xFDB,
	0x1000,
	0x10C6,
	0x10C7,
	0x10C8,
	0x10CD,
	0x10CE,
	0x10D0,
	0x1249,
	0x124A,
	0x124E,
	0x1250,
	0x1257,
	0x1258,
	0x1259,
	0x125A,
	0x125E,
	0x1260,
	0x1289,
	0x128A,
	0x128E,
	0x1290,
	0x12B1,
	0x12B2,
	0x12B6,
	0x12B8,
	0x12BF,
	0x12C0,
	0x12C1,
	0x12C2,
	0x12C6,
	0x12C8,
	0x12D7,
	0x12D8,
	0x1311,
	0x1312,
	0x1316,
	0x1318,
	0x135B,
	0x135D,
	0x137D,
	0x1380,
	0x139A,
	0x13A0,
	0x13F6,
	0x13F8,
	0x13FE,
	0x1400,
	0x169D,
	0x16A0,
	0x16F9,
	0x1700,
	0x1716,
	0x171F,
	0x1737,
	0x1740,
	0x1754,
	0x1760,
	0x176D,
	0x176E,
	0x1771,
	0x1772,
	0x1774,
	0x1780,
	0x17DE,
	0x17E0,
	0x17EA,
	0x17F0,
	0x17FA,
	0x1800,
	0x181A,
	0x1820,
	0x1879,
	0x1880,
	0x18AB,
	0x18B0,
	0x18F6,
	0x1900,
	0x191F,
	0x1920,
	0x192C,
	0x1930,
	0x193C,
	0x1940,
	0x1941,
	0x1944,
	0x196E,
	0x1970,
	0x1975,
	0x1980,
	0x19AC,
	0x19B0,
	0x19CA,
	0x19D0,
	0x19DB,
	0x19DE,
	0x1A1C,
	0x1A1E,
	0x1A5F,
	0x1A60,
	0x1A7D,
	0x1A7F,
	0x1A8A,
	0x1A90,
	0x1A9A,
	0x1AA0,
	0x1AAE,
	0x1AB0,
	0x1ACF,
	0x1B00,
	0x1B4D,
	0x1B50,
	0x1B7F,
	0x1B80,
	0x1BF4,
	0x1BFC,
	0x1C38,
	0x1C3B,
	0x1C4A,
	0x1C4D,
	0x1C89,
	0x1C90,
	0x1CBB,
	0x1CBD,
	0x1CC8,
	0x1CD0,
	0x1CFB,
	0x1D00,
	0x1F16,
	0x1F18,
	0x1F1E,
	0x1F20,
	0x1F46,
	0x1F48,
	0x1F4E,
	0x1F50,
	0x1F58,
	0x1F59,
	0x1F5A,
	0x1F5B,
	0x1F5C,
	0x1F5D,
	0x1F5E,
	0x1F5F,
	0x1F7E,
	0x1F80,
	0x1FB5,
	0x1FB6,
	0x1FC5,
	0x1FC6,
	0x1FD4,
	0x1FD6,
	0x1FDC,
	0x1FDD,
	0x1FF0,
	0x1FF2,
	0x1FF5,
	0x1FF6,
	0x1FFF,
	0x2000,
	0x2065,
	0x2066,
	0x2072,
	0x2074,
	0x208F,
	0x2090,
	0x209D,
	0x20A0,
	0x20C1,
	0x20D0,
	0x20F1,
	0x2100,
	0x218C,
	0x2190,
	0x2427,
	0x2440,
	0x244B,
	0x2460,
	0x2B74,
	0x2B76,
	0x2B96,
	0x2B97,
	0x2CF4,
	0x2CF9,
	0x2D26,
	0x2D27,
	0x2D28,
	0x2D2D,
	0x2D2E,
	0x2D30,
	0x2D68,
	0x2D6F,
	0x2D71,
	0x2D7F,
	0x2D97,
	0x2DA0,
	0x2DA7,
	0x2DA8,
	0x2DAF,
	0x2DB0,
	0x2DB7,
	0x2DB8,
	0x2DBF,
	0x2DC0,
	0x2DC7,
	0x2DC8,
	0x2DCF,
	0x2DD0,
	0x2DD7,
	0x2DD8,
	0x2DDF,
	0x2DE0,
	0x2E5E,
	0x2E80,
	0x2E9A,
	0x2E9B,
	0x2EF4,
	0x2F00,
	0x2FD6,
	0x2FF0,
	0x2FFC,
	0x3000,
	0x3040,
	0x3041,
	0x3097,
	0x3099,
	0x3100,
	0x3105,
	0x3130,
	0x3131,
	0x318F,
	0x3190,
	0x31E4,
	0x31F0,
	0x321F,
	0x3220,
	0xA48D,
	0xA490,
	0xA4C7,
	0xA4D0,
	0xA62C,
	0xA640,
	0xA6F8,
	0xA700,
	0xA7CB,
	0xA7D0,
	0xA7D2,
	0xA7D3,
	0xA7D4,
	0xA7D5,
	0xA7DA,
	0xA7F2,
	0xA82D,
	0xA830,
	0xA83A,
	0xA840,
	0xA878,
	0xA880,
	0xA8C6,
	0xA8CE,
	0xA8DA,
	0xA8E0,
	0xA954,
	0xA95F,
	0xA97D,
	0xA980,
	0xA9CE,
	0xA9CF,
	0xA9DA,
	0xA9DE,
	0xA9FF,
	0xAA00,
	0xAA37,
	0xAA40,
	0xAA4E,
	0xAA50,
	0xAA5A,
	0xAA5C,
	0xAAC3,
	0xAADB,
	0xAAF7,
	0xAB01,
	0xAB07,
	0xAB09,
	0xAB0F,
	0xAB11,
	0xAB17,
	0xAB20,
	0xAB27,
	0xAB28,
	0xAB2F,
	0xAB30,
	0xAB6C,
	0xAB70,
	0xABEE,
	0xABF0,
	0xABFA,
	0xAC00,
	0xD7A4,
	0xD7B0,
	0xD7C7,
	0xD7CB,
	0xD7FC,
	0xF900,
	0xFA6E,
	0xFA70,
	0xFADA,
	0xFB00,
	0xFB07,
	0xFB13,
	0xFB18,
	0xFB1D,
	0xFB37,
	0xFB38,
	0xFB3D,
	0xFB3E,
	0xFB3F,
	0xFB40,
	0xFB42,
	0xFB43,
	0xFB45,
	0xFB46,
	0xFBC3,
	0xFBD3,
	0xFD90,
	0xFD92,
	0xFDC8,
	0xFDCF,
	0xFDD0,
	0xFDF0,
	0xFE1A,
	0xFE20,
	0xFE53,
	0xFE54,
	0xFE67,
	0xFE68,
	0xFE6C,
	0xFE70,
	0xFE75,
	0xFE76,
	0xFEFD,
	0xFEFF,
	0xFF00,
	0xFF01,
	0xFFBF,
	0xFFC2,
	0xFFC8,
	0xFFCA,
	0xFFD0,
	0xFFD2,
	0xFFD8,
	0xFFDA,
	0xFFDD,
	0xFFE0,
	0xFFE7,
	0xFFE8,
	0xFFEF,
	0xFFF9,
	0xFFFE,
	0x10000,
	0x1000C,
	0x1000D,
	0x10027,
	0x10028,
	0x1003B,
	0x1003C,
	0x1003E,
	0x1003F,
	0x1004E,
	0x10050,
	0x1005E,
	0x10080,
	0x100FB,
	0x10100,
	0x10103,
	0x10107,
	0x10134,
	0x10137,
	0x1018F,
	0x10190,
	0x1019D,
	0x101A0,
	0x101A1,
	0x101D0,
	0x101FE,
	0x10280,
	0x1029D,
	0x102A0,
	0x102D1,
	0x102E0,
	0x102FC,
	0x10300,
	0x10324,
	0x1032D,
	0x1034B,
	0x10350,
	0x1037B,
	0x10380,
	0x1039E,
	0x1039F,
	0x103C4,
	0x103C8,
	0x103D6,
	0x10400,
	0x1049E,
	0x104A0,
	0x104AA,
	0x104B0,
	0x104D4,
	0x104D8,
	0x104FC,
	0x10500,
	0x10528,
	0x10530,
	0x10564,
	0x1056F,
	0x1057B,
	0x1057C,
	0x1058B,
	0x1058C,
	0x10593,
	0x10594,
	0x10596,
	0x10597,
	0x105A2,
	0x105A3,
	0x105B2,
	0x105B3,
	0x105BA,
	0x105BB,
	0x105BD,
	0x10600,
	0x10737,
	0x10740,
	0x10756,
	0x10760,
	0x10768,
	0x10780,
	0x10786,
	0x10787,
	0x107B1,
	0x107B2,
	0x107BB,
	0x10800,
	0x10806,
	0x10808,
	0x10809,
	0x1080A,
	0x10836,
	0x10837,
	0x10839,
	0x1083C,
	0x1083D,
	0x1083F,
	0x10856,
	0x10857,
	0x1089F,
	0x108A7,
	0x108B0,
	0x108E0,
	0x108F3,
	0x108F4,
	0x108F6,
	0x108FB,
	0x1091C,
	0x1091F,
	0x1093A,
	0x1093F,
	0x10940,
	0x10980,
	0x109B8,
	0x109BC,
	0x109D0,
	0x109D2,
	0x10A04,
	0x10A05,
	0x10A07,
	0x10A0C,
	0x10A14,
	0x10A15,
	0x10A18,
	0x10A19,
	0x10A36,
	0x10A38,
	0x10A3B,
	0x10A3F,
	0x10A49,
	0x10A50,
	0x10A59,
	0x10A60,
	0x10AA0,
	0x10AC0,
	0x10AE7,
	0x10AEB,
	0x10AF7,
	0x10B00,
	0x10B36,
	0x10B39,
	0x10B56,
	0x10B58,
	0x10B73,
	0x10B78,
	0x10B92,
	0x10B99,
	0x10B9D,
	0x10BA9,
	0x10BB0,
	0x10C00,
	0x10C49,
	0x10C80,
	0x10CB3,
	0x10CC0,
	0x10CF3,
	0x10CFA,
	0x10D28,
	0x10D30,
	0x10D3A,
	0x10E60,
	0x10E7F,
	0x10E80,
	0x10EAA,
	0x10EAB,
	0x10EAE,
	0x10EB0,
	0x10EB2,
	0x10F00,
	0x10F28,
	0x10F30,
	0x10F5A,
	0x10F70,
	0x10F8A,
	0x10FB0,
	0x10FCC,
	0x10FE0,
	0x10FF7,
	0x11000,
	0x1104E,
	0x11052,
	0x11076,
	0x1107F,
	0x110C3,
	0x110CD,
	0x110CE,
	0x110D0,
	0x110E9,
	0x110F0,
	0x110FA,
	0x11100,
	0x11135,
	0x11136,
	0x11148,
	0x11150,
	0x11177,
	0x11180,
	0x111E0,
	0x111E1,
	0x111F5,
	0x11200,
	0x11212,
	0x11213,
	0x1123F,
	0x11280,
	0x11287,
	0x11288,
	0x11289,
	0x1128A,
	0x1128E,
	0x1128F,
	0x1129E,
	0x1129F,
	0x112AA,
	0x112B0,
	0x112EB,
	0x112F0,
	0x112FA,
	0x11300,
	0x11304,
	0x11305,
	0x1130D,
	0x1130F,
	0x11311,
	0x11313,
	0x11329,
	0x1132A,
	0x11331,
	0x11332,
	0x11334,
	0x11335,
	0x1133A,
	0x1133B,
	0x11345,
	0x11347,
	0x11349,
	0x1134B,
	0x1134E,
	0x11350,
	0x11351,
	0x11357,
	0x11358,
	0x1135D,
	0x11364,
	0x11366,
	0x1136D,
	0x11370,
	0x11375,
	0x11400,
	0x1145C,
	0x1145D,
	0x11462,
	0x11480,
	0x114C8,
	0x114D0,
	0x114DA,
	0x11580,
	0x115B6,
	0x115B8,
	0x115DE,
	0x11600,
	0x11645,
	0x11650,
	0x1165A,
	0x11660,
	0x1166D,
	0x11680,
	0x116BA,
	0x116C0,
	0x116CA,
	0x11700,
	0x1171B,
	0x1171D,
	0x1172C,
	0x11730,
	0x11747,
	0x11800,
	0x1183C,
	0x118A0,
	0x118F3,
	0x118FF,
	0x11907,
	0x11909,
	0x1190A,
	0x1190C,
	0x11914,
	0x11915,
	0x11917,
	0x11918,
	0x11936,
	0x11937,
	0x11939,
	0x1193B,
	0x11947,
	0x11950,
	0x1195A,
	0x119A0,
	0x119A8,
	0x119AA,
	0x119D8,
	0x119DA,
	0x119E5,
	0x11A00,
	0x11A48,
	0x11A50,
	0x11AA3,
	0x11AB0,
	0x11AF9,
	0x11C00,
	0x11C09,
	0x11C0A,
	0x11C37,
	0x11C38,
	0x11C46,
	0x11C50,
	0x11C6D,
	0x11C70,
	0x11C90,
	0x11C92,
	0x11CA8,
	0x11CA9,
	0x11CB7,
	0x11D00,
	0x11D07,
	0x11D08,
	0x11D0A,
	0x11D0B,
	0x11D37,
	0x11D3A,
	0x11D3B,
	0x11D3C,
	0x11D3E,
	0x11D3F,
	0x11D48,
	0x11D50,
	0x11D5A,
	0x11D60,
	0x11D66,
	0x11D67,
	0x11D69,
	0x11D6A,
	0x11D8F,
	0x11D90,
	0x11D92,
	0x11D93,
	0x11D99,
	0x11DA0,
	0x11DAA,
	0x11EE0,
	0x11EF9,
	0x11FB0,
	0x11FB1,
	0x11FC0,
	0x11FF2,
	0x11FFF,
	0x1239A,
	0x12400,
	0x1246F,
	0x12470,
	0x12475,
	0x12480,
	0x12544,
	0x12F90,
	0x12FF3,
	0x13000,
	0x1342F,
	0x13430,
	0x13439,
	0x14400,
	0x14647,
	0x16800,
	0x16A39,
	0x16A40,
	0x16A5F,
	0x16A60,
	0x16A6A,
	0x16A6E,
	0x16ABF,
	0x16AC0,
	0x16ACA,
	0x16AD0,
	0x16AEE,
	0x16AF0,
	0x16AF6,
	0x16B00,
	0x16B46,
	0x16B50,
	0x16B5A,
	0x16B5B,
	0x16B62,
	0x16B63,
	0x16B78,
	0x16B7D,
	0x16B90,
	0x16E40,
	0x16E9B,
	0x16F00,
	0x16F4B,
	0x16F4F,
	0x16F88,
	0x16F8F,
	0x16FA0,
	0x16FE0,
	0x16FE5,
	0x16FF0,
	0x16FF2,
	0x17000,
	0x187F8,
	0x18800,
	0x18CD6,
	0x18D00,
	0x18D09,
	0x1AFF0,
	0x1AFF4,
	0x1AFF5,
	0x1AFFC,
	0x1AFFD,
	0x1AFFF,
	0x1B000,
	0x1B123,
	0x1B150,
	0x1B153,
	0x1B164,
	0x1B168,
	0x1B170,
	0x1B2FC,
	0x1BC00,
	0x1BC6B,
	0x1BC70,
	0x1BC7D,
	0x1BC80,
	0x1BC89,
	0x1BC90,
	0x1BC9A,
	0x1BC9C,
	0x1BCA4,
	0x1CF00,
	0x1CF2E,
	0x1CF30,
	0x1CF47,
	0x1CF50,
	0x1CFC4,
	0x1D000,
	0x1D0F6,
	0x1D100,
	0x1D127,
	0x1D129,
	0x1D1EB,
	0x1D200,
	0x1D246,
	0x1D2E0,
	0x1D2F4,
	0x1D300,
	0x1D357,
	0x1D360,
	0x1D379,
	0x1D400,
	0x1D455,
	0x1D456,
	0x1D49D,
	0x1D49E,
	0x1D4A0,
	0x1D4A2,
	0x1D4A3,
	0x1D4A5,
	0x1D4A7,
	0x1D4A9,
	0x1D4AD,
	0x1D4AE,
	0x1D4BA,
	0x1D4BB,
	0x1D4BC,
	0x1D4BD,
	0x1D4C4,
	0x1D4C5,
	0x1D506,
	0x1D507,
	0x1D50B,
	0x1D50D,
	0x1D515,
	0x1D516,
	0x1D51D,
	0x1D51E,
	0x1D53A,
	0x1D53B,
	0x1D53F,
	0x1D540,
	0x1D545,
	0x1D546,
	0x1D547,
	0x1D54A,
	0x1D551,
	0x1D552,
	0x1D6A6,
	0x1D6A8,
	0x1D7CC,
	0x1D7CE,
	0x1DA8C,
	0x1DA9B,
	0x1DAA0,
	0x1DAA1,
	0x1DAB0,
	0x1DF00,
	0x1DF1F,
	0x1E000,
	0x1E007,
	0x1E008,
	0x1E019,
	0x1E01B,
	0x1E022,
	0x1E023,
	0x1E025,
	0x1E026,
	0x1E02B,
	0x1E100,
	0x1E12D,
	0x1E130,
	0x1E13E,
	0x1E140,
	0x1E14A,
	0x1E14E,
	0x1E150,
	0x1E290,
	0x1E2AF,
	0x1E2C0,
	0x1E2FA,
	0x1E2FF,
	0x1E300,
	0x1E7E0,
	0x1E7E7,
	0x1E7E8,
	0x1E7EC,
	0x1E7ED,
	0x1E7EF,
	0x1E7F0,
	0x1E7FF,
	0x1E800,
	0x1E8C5,
	0x1E8C7,
	0x1E8D7,
	0x1E900,
	0x1E94C,
	0x1E950,
	0x1E95A,
	0x1E95E,
	0x1E960,
	0x1EC71,
	0x1ECB5,
	0x1ED01,
	0x1ED3E,
	0x1EE00,
	0x1EE04,
	0x1EE05,
	0x1EE20,
	0x1EE21,
	0x1EE23,
	0x1EE24,
	0x1EE25,
	0x1EE27,
	0x1EE28,
	0x1EE29,
	0x1EE33,
	0x1EE34,
	0x1EE38,
	0x1EE39,
	0x1EE3A,
	0x1EE3B,
	0x1EE3C,
	0x1EE42,
	0x1EE43,
	0x1EE47,
	0x1EE48,
	0x1EE49,
	0x1EE4A,
	0x1EE4B,
	0x1EE4C,
	0x1EE4D,
	0x1EE50,
	0x1EE51,
	0x1EE53,
	0x1EE54,
	0x1EE55,
	0x1EE57,
	0x1EE58,
	0x1EE59,
	0x1EE5A,
	0x1EE5B,
	0x1EE5C,
	0x1EE5D,
	0x1EE5E,
	0x1EE5F,
	0x1EE60,
	0x1EE61,
	0x1EE63,
	0x1EE64,
	0x1EE65,
	0x1EE67,
	0x1EE6B,
	0x1EE6C,
	0x1EE73,
	0x1EE74,
	0x1EE78,
	0x1EE79,
	0x1EE7D,
	0x1EE7E,
	0x1EE7F,
	0x1EE80,
	0x1EE8A,
	0x1EE8B,
	0x1EE9C,
	0x1EEA1,
	0x1EEA4,
	0x1EEA5,
	0x1EEAA,
	0x1EEAB,
	0x1EEBC,
	0x1EEF0,
	0x1EEF2,
	0x1F000,
	0x1F02C,
	0x1F030,
	0x1F094,
	0x1F0A0,
	0x1F0AF,
	0x1F0B1,
	0x1F0C0,
	0x1F0C1,
	0x1F0D0,
	0x1F0D1,
	0x1F0F6,
	0x1F100,
	0x1F1AE,
	0x1F1E6,
	0x1F203,
	0x1F210,
	0x1F23C,
	0x1F240,
	0x1F249,
	0x1F250,
	0x1F252,
	0x1F260,
	0x1F266,
	0x1F300,
	0x1F6D8,
	0x1F6DD,
	0x1F6ED,
	0x1F6F0,
	0x1F6FD,
	0x1F700,
	0x1F774,
	0x1F780,
	0x1F7D9,
	0x1F7E0,
	0x1F7EC,
	0x1F7F0,
	0x1F7F1,
	0x1F800,
	0x1F80C,
	0x1F810,
	0x1F848,
	0x1F850,
	0x1F85A,
	0x1F860,
	0x1F888,
	0x1F890,
	0x1F8AE,
	0x1F8B0,
	0x1F8B2,
	0x1F900,
	0x1FA54,
	0x1FA60,
	0x1FA6E,
	0x1FA70,
	0x1FA75,
	0x1FA78,
	0x1FA7D,
	0x1FA80,
	0x1FA87,
	0x1FA90,
	0x1FAAD,
	0x1FAB0,
	0x1FABB,
	0x1FAC0,
	0x1FAC6,
	0x1FAD0,
	0x1FADA,
	0x1FAE0,
	0x1FAE8,
	0x1FAF0,
	0x1FAF7,
	0x1FB00,
	0x1FB93,
	0x1FB94,
	0x1FBCB,
	0x1FBF0,
	0x1FBFA,
	0x20000,
	0x2A6E0,
	0x2A700,
	0x2B739,
	0x2B740,
	0x2B81E,
	0x2B820,
	0x2CEA2,
	0x2CEB0,
	0x2EBE1,
	0x2F800,
	0x2FA1E,
	0x30000,
	0x3134B,
	0xE0001,
	0xE0002,
	0xE0020,
	0xE0080,
	0xE0100,
	0xE01F0
};

static const UV UNI__PERL_NCHAR_invlist[] = {  /* for all charsets */
	37,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xFDD0,
	0xFDF0,
	0xFFFE,
	0x10000,
	0x1FFFE,
	0x20000,
	0x2FFFE,
	0x30000,
	0x3FFFE,
	0x40000,
	0x4FFFE,
	0x50000,
	0x5FFFE,
	0x60000,
	0x6FFFE,
	0x70000,
	0x7FFFE,
	0x80000,
	0x8FFFE,
	0x90000,
	0x9FFFE,
	0xA0000,
	0xAFFFE,
	0xB0000,
	0xBFFFE,
	0xC0000,
	0xCFFFE,
	0xD0000,
	0xDFFFE,
	0xE0000,
	0xEFFFE,
	0xF0000,
	0xFFFFE,
	0x100000,
	0x10FFFE,
	0x110000
};

#  if 'A' == 65 /* ASCII/Latin1 */

static const UV UNI__PERL_PATWS_invlist[] = {  /* for ASCII/Latin1 */
	11,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x9,
	0xE,
	0x20,
	0x21,
	0x85,
	0x86,
	0x200E,
	0x2010,
	0x2028,
	0x202A
};

#  endif	/* ASCII/Latin1 */

#  if 'A' == 193 /* EBCDIC 1047 */ \
     && '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
     && '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21

static const UV UNI__PERL_PATWS_invlist[] = {  /* for EBCDIC 1047 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5,
	0x6,
	0xB,
	0xE,
	0x15,
	0x16,
	0x25,
	0x26,
	0x40,
	0x41,
	0x200E,
	0x2010,
	0x2028,
	0x202A
};

#  endif	/* EBCDIC 1047 */

#  if 'A' == 193 /* EBCDIC 037 */ \
     && '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
     && '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
     && '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37

static const UV UNI__PERL_PATWS_invlist[] = {  /* for EBCDIC 037 */
	15,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0x5,
	0x6,
	0xB,
	0xE,
	0x15,
	0x16,
	0x25,
	0x26,
	0x40,
	0x41,
	0x200E,
	0x2010,
	0x2028,
	0x202A
};

#  endif	/* EBCDIC 037 */

static const UV UNI__PERL_SURROGATE_invlist[] = {  /* for all charsets */
	3,	/* Number of elements */
	148565664, /* Version and data structure type */
	1,	/* 0 if the list starts at 0;
		   1 if it starts at the element beyond 0 */
	0x0,
	0xD800,
	0xE000
};

const char * const deprecated_property_msgs[] = {
	"",
	"Surrogates should never appear in well-formed text, and therefore shouldn't be the basis for line breaking",
	"Supplanted by Line_Break property values; see www.unicode.org/reports/tr14"
};

#endif	/* (defined(PERL_IN_REGCOMP_C) && ! defined(PERL_IN_XSUB_RE)) */

#if defined(PERL_IN_REGCOMP_C)

#define UNI_HYPHEN (UNI_HYPHEN_perl_aux + (MAX_UNI_KEYWORD_INDEX * 2))
#define UNI_LB__SG (UNI_LB__SG_perl_aux + (MAX_UNI_KEYWORD_INDEX * 1))

typedef enum {
	PERL_BIN_PLACEHOLDER = 0, /* So no real value is zero */
	UNI_ADLM,
	UNI_AEGEANNUMBERS,
	UNI_AGE__10,
	UNI_AGE__11,
	UNI_AGE__12,
	UNI_AGE__12_DOT_1,
	UNI_AGE__13,
	UNI_AGE__14,
	UNI_AGE__2,
	UNI_AGE__2_DOT_1,
	UNI_AGE__3,
	UNI_AGE__3_DOT_1,
	UNI_AGE__3_DOT_2,
	UNI_AGE__4,
	UNI_AGE__4_DOT_1,
	UNI_AGE__5,
	UNI_AGE__5_DOT_1,
	UNI_AGE__5_DOT_2,
	UNI_AGE__6,
	UNI_AGE__6_DOT_1,
	UNI_AGE__6_DOT_2,
	UNI_AGE__6_DOT_3,
	UNI_AGE__7,
	UNI_AGE__8,
	UNI_AGE__9,
	UNI_AGHB,
	UNI_AHOM,
	UNI_ALCHEMICAL,
	UNI_ALL,
	UNI_ALPHABETICPF,
	UNI_ANCIENTGREEKMUSIC,
	UNI_ANCIENTGREEKNUMBERS,
	UNI_ANCIENTSYMBOLS,
	UNI_ANY,
	UNI_ARAB,
	UNI_ARABICEXTA,
	UNI_ARABICEXTB,
	UNI_ARABICMATH,
	UNI_ARABICPFA,
	UNI_ARABICPFB,
	UNI_ARABICSUP,
	UNI_ARMI,
	UNI_ARMN,
	UNI_ARROWS,
	UNI_ASCII,
	UNI_ASSIGNED,
	UNI_AVST,
	UNI_BALI,
	UNI_BAMU,
	UNI_BAMUMSUP,
	UNI_BASS,
	UNI_BATK,
	UNI_BC__AL,
	UNI_BC__AN,
	UNI_BC__B,
	UNI_BC__BN,
	UNI_BC__CS,
	UNI_BC__EN,
	UNI_BC__ES,
	UNI_BC__ET,
	UNI_BC__FSI,
	UNI_BC__L,
	UNI_BC__LRE,
	UNI_BC__LRI,
	UNI_BC__LRO,
	UNI_BC__NSM,
	UNI_BC__ON,
	UNI_BC__PDF,
	UNI_BC__PDI,
	UNI_BC__R,
	UNI_BC__RLE,
	UNI_BC__RLI,
	UNI_BC__RLO,
	UNI_BC__S,
	UNI_BC__WS,
	UNI_BENG,
	UNI_BHKS,
	UNI_BIDIC,
	UNI_BIDIM,
	UNI_BLOCKELEMENTS,
	UNI_BOPO,
	UNI_BOPOMOFOEXT,
	UNI_BOXDRAWING,
	UNI_BPT__C,
	UNI_BPT__N,
	UNI_BPT__O,
	UNI_BRAH,
	UNI_BRAI,
	UNI_BUGI,
	UNI_BUHD,
	UNI_BYZANTINEMUSIC,
	UNI_C,
	UNI_CAKM,
	UNI_CANS,
	UNI_CARI,
	UNI_CASED,
	UNI_CASEDLETTER,
	UNI_CCC__0,
	UNI_CCC__1,
	UNI_CCC__10,
	UNI_CCC__103,
	UNI_CCC__107,
	UNI_CCC__11,
	UNI_CCC__118,
	UNI_CCC__12,
	UNI_CCC__122,
	UNI_CCC__129,
	UNI_CCC__13,
	UNI_CCC__130,
	UNI_CCC__132,
	UNI_CCC__14,
	UNI_CCC__15,
	UNI_CCC__16,
	UNI_CCC__17,
	UNI_CCC__18,
	UNI_CCC__19,
	UNI_CCC__20,
	UNI_CCC__202,
	UNI_CCC__21,
	UNI_CCC__214,
	UNI_CCC__216,
	UNI_CCC__22,
	UNI_CCC__23,
	UNI_CCC__24,
	UNI_CCC__25,
	UNI_CCC__26,
	UNI_CCC__27,
	UNI_CCC__28,
	UNI_CCC__29,
	UNI_CCC__30,
	UNI_CCC__31,
	UNI_CCC__32,
	UNI_CCC__33,
	UNI_CCC__34,
	UNI_CCC__35,
	UNI_CCC__36,
	UNI_CCC__6,
	UNI_CCC__7,
	UNI_CCC__8,
	UNI_CCC__84,
	UNI_CCC__9,
	UNI_CCC__91,
	UNI_CCC__A,
	UNI_CCC__AL,
	UNI_CCC__AR,
	UNI_CCC__B,
	UNI_CCC__BL,
	UNI_CCC__BR,
	UNI_CCC__DA,
	UNI_CCC__DB,
	UNI_CCC__IS,
	UNI_CCC__L,
	UNI_CCC__R,
	UNI_CE,
	UNI_CF,
	UNI_CHAM,
	UNI_CHER,
	UNI_CHEROKEESUP,
	UNI_CHESSSYMBOLS,
	UNI_CHRS,
	UNI_CI,
	UNI_CJK,
	UNI_CJKCOMPAT,
	UNI_CJKCOMPATFORMS,
	UNI_CJKCOMPATIDEOGRAPHS,
	UNI_CJKCOMPATIDEOGRAPHSSUP,
	UNI_CJKEXTA,
	UNI_CJKEXTB,
	UNI_CJKEXTC,
	UNI_CJKEXTD,
	UNI_CJKEXTE,
	UNI_CJKEXTF,
	UNI_CJKEXTG,
	UNI_CJKRADICALSSUP,
	UNI_CJKSTROKES,
	UNI_CJKSYMBOLS,
	UNI_CN,
	UNI_CO,
	UNI_COMPATJAMO,
	UNI_COMPEX,
	UNI_CONTROLPICTURES,
	UNI_COPT,
	UNI_COPTICEPACTNUMBERS,
	UNI_COUNTINGROD,
	UNI_CPMN,
	UNI_CPRT,
	UNI_CUNEIFORMNUMBERS,
	UNI_CURRENCYSYMBOLS,
	UNI_CWCF,
	UNI_CWCM,
	UNI_CWKCF,
	UNI_CWL,
	UNI_CWT,
	UNI_CWU,
	UNI_CYPRIOTSYLLABARY,
	UNI_CYRILLICEXTA,
	UNI_CYRILLICEXTB,
	UNI_CYRILLICEXTC,
	UNI_CYRILLICSUP,
	UNI_CYRL,
	UNI_DASH,
	UNI_DEP,
	UNI_DEVA,
	UNI_DEVANAGARIEXT,
	UNI_DI,
	UNI_DIA,
	UNI_DIACRITICALS,
	UNI_DIACRITICALSEXT,
	UNI_DIACRITICALSFORSYMBOLS,
	UNI_DIACRITICALSSUP,
	UNI_DIAK,
	UNI_DINGBATS,
	UNI_DOGR,
	UNI_DOMINO,
	UNI_DSRT,
	UNI_DT__CAN,
	UNI_DT__COM,
	UNI_DT__ENC,
	UNI_DT__FIN,
	UNI_DT__FONT,
	UNI_DT__FRA,
	UNI_DT__INIT,
	UNI_DT__ISO,
	UNI_DT__MED,
	UNI_DT__NAR,
	UNI_DT__NB,
	UNI_DT__NONCANON,
	UNI_DT__NONE,
	UNI_DT__SML,
	UNI_DT__SQR,
	UNI_DT__SUB,
	UNI_DT__SUP,
	UNI_DT__VERT,
	UNI_DUPL,
	UNI_EARLYDYNASTICCUNEIFORM,
	UNI_EA__A,
	UNI_EA__F,
	UNI_EA__H,
	UNI_EA__N,
	UNI_EA__NA,
	UNI_EA__W,
	UNI_EBASE,
	UNI_ECOMP,
	UNI_EGYP,
	UNI_EGYPTIANHIEROGLYPHFORMATCONTROLS,
	UNI_ELBA,
	UNI_ELYM,
	UNI_EMOD,
	UNI_EMOJI,
	UNI_EMOTICONS,
	UNI_ENCLOSEDALPHANUM,
	UNI_ENCLOSEDALPHANUMSUP,
	UNI_ENCLOSEDCJK,
	UNI_ENCLOSEDIDEOGRAPHICSUP,
	UNI_EPRES,
	UNI_ETHI,
	UNI_ETHIOPICEXT,
	UNI_ETHIOPICEXTA,
	UNI_ETHIOPICEXTB,
	UNI_ETHIOPICSUP,
	UNI_EXT,
	UNI_EXTPICT,
	UNI_GCB__CN,
	UNI_GCB__EX,
	UNI_GCB__L,
	UNI_GCB__PP,
	UNI_GCB__SM,
	UNI_GCB__T,
	UNI_GCB__V,
	UNI_GCB__XX,
	UNI_GEOMETRICSHAPES,
	UNI_GEOMETRICSHAPESEXT,
	UNI_GEOR,
	UNI_GEORGIANEXT,
	UNI_GEORGIANSUP,
	UNI_GLAG,
	UNI_GLAGOLITICSUP,
	UNI_GONG,
	UNI_GONM,
	UNI_GOTH,
	UNI_GRAN,
	UNI_GRBASE,
	UNI_GREEKEXT,
	UNI_GREK,
	UNI_GREXT,
	UNI_GUJR,
	UNI_GURU,
	UNI_HALFANDFULLFORMS,
	UNI_HALFMARKS,
	UNI_HAN,
	UNI_HANG,
	UNI_HANO,
	UNI_HATR,
	UNI_HEBR,
	UNI_HIGHPUSURROGATES,
	UNI_HIGHSURROGATES,
	UNI_HIRA,
	UNI_HLUW,
	UNI_HMNG,
	UNI_HMNP,
	UNI_HST__NA,
	UNI_HUNG,
	UNI_HYPHEN_perl_aux,
	UNI_IDC,
	UNI_IDENTIFIERSTATUS__ALLOWED,
	UNI_IDENTIFIERSTATUS__RESTRICTED,
	UNI_IDENTIFIERTYPE__DEFAULTIGNORABLE,
	UNI_IDENTIFIERTYPE__EXCLUSION,
	UNI_IDENTIFIERTYPE__INCLUSION,
	UNI_IDENTIFIERTYPE__LIMITEDUSE,
	UNI_IDENTIFIERTYPE__NOTCHARACTER,
	UNI_IDENTIFIERTYPE__NOTNFKC,
	UNI_IDENTIFIERTYPE__NOTXID,
	UNI_IDENTIFIERTYPE__OBSOLETE,
	UNI_IDENTIFIERTYPE__RECOMMENDED,
	UNI_IDENTIFIERTYPE__TECHNICAL,
	UNI_IDENTIFIERTYPE__UNCOMMONUSE,
	UNI_IDEO,
	UNI_IDEOGRAPHICSYMBOLS,
	UNI_IDS,
	UNI_IDSB,
	UNI_IDST,
	UNI_INADLAM,
	UNI_INAHOM,
	UNI_INANATOLIANHIEROGLYPHS,
	UNI_INARABIC,
	UNI_INARMENIAN,
	UNI_INAVESTAN,
	UNI_INBALINESE,
	UNI_INBAMUM,
	UNI_INBASSAVAH,
	UNI_INBATAK,
	UNI_INBENGALI,
	UNI_INBHAIKSUKI,
	UNI_INBOPOMOFO,
	UNI_INBRAHMI,
	UNI_INBUGINESE,
	UNI_INBUHID,
	UNI_INCARIAN,
	UNI_INCAUCASIANALBANIAN,
	UNI_INCHAKMA,
	UNI_INCHAM,
	UNI_INCHEROKEE,
	UNI_INCHORASMIAN,
	UNI_INCOPTIC,
	UNI_INCUNEIFORM,
	UNI_INCYPROMINOAN,
	UNI_INCYRILLIC,
	UNI_INDEVANAGARI,
	UNI_INDICNUMBERFORMS,
	UNI_INDICSIYAQNUMBERS,
	UNI_INDIVESAKURU,
	UNI_INDOGRA,
	UNI_INDUPLOYAN,
	UNI_INEGYPTIANHIEROGLYPHS,
	UNI_INELBASAN,
	UNI_INELYMAIC,
	UNI_INETHIOPIC,
	UNI_INGEORGIAN,
	UNI_INGLAGOLITIC,
	UNI_INGOTHIC,
	UNI_INGRANTHA,
	UNI_INGREEK,
	UNI_INGUJARATI,
	UNI_INGUNJALAGONDI,
	UNI_INGURMUKHI,
	UNI_INHANGUL,
	UNI_INHANIFIROHINGYA,
	UNI_INHANUNOO,
	UNI_INHATRAN,
	UNI_INHEBREW,
	UNI_INHIRAGANA,
	UNI_INIDC,
	UNI_INIMPERIALARAMAIC,
	UNI_ININSCRIPTIONALPAHLAVI,
	UNI_ININSCRIPTIONALPARTHIAN,
	UNI_INJAVANESE,
	UNI_INKAITHI,
	UNI_INKANNADA,
	UNI_INKATAKANA,
	UNI_INKHAROSHTHI,
	UNI_INKHITANSMALLSCRIPT,
	UNI_INKHMER,
	UNI_INKHOJKI,
	UNI_INKHUDAWADI,
	UNI_INLAO,
	UNI_INLEPCHA,
	UNI_INLIMBU,
	UNI_INLINEARA,
	UNI_INLISU,
	UNI_INLYCIAN,
	UNI_INLYDIAN,
	UNI_INMAHAJANI,
	UNI_INMAKASAR,
	UNI_INMALAYALAM,
	UNI_INMANDAIC,
	UNI_INMANICHAEAN,
	UNI_INMARCHEN,
	UNI_INMASARAMGONDI,
	UNI_INMEDEFAIDRIN,
	UNI_INMEETEIMAYEK,
	UNI_INMENDEKIKAKUI,
	UNI_INMEROITICCURSIVE,
	UNI_INMIAO,
	UNI_INMODI,
	UNI_INMONGOLIAN,
	UNI_INMRO,
	UNI_INMULTANI,
	UNI_INMYANMAR,
	UNI_INNABATAEAN,
	UNI_INNANDINAGARI,
	UNI_INNEWA,
	UNI_INNEWTAILUE,
	UNI_INNKO,
	UNI_INNUSHU,
	UNI_INNYIAKENGPUACHUEHMONG,
	UNI_INOGHAM,
	UNI_INOLDHUNGARIAN,
	UNI_INOLDITALIC,
	UNI_INOLDPERMIC,
	UNI_INOLDPERSIAN,
	UNI_INOLDSOGDIAN,
	UNI_INOLDTURKIC,
	UNI_INOLDUYGHUR,
	UNI_INORIYA,
	UNI_INOSAGE,
	UNI_INOSMANYA,
	UNI_INPAHAWHHMONG,
	UNI_INPAUCINHAU,
	UNI_INPC__BOTTOM,
	UNI_INPC__BOTTOMANDLEFT,
	UNI_INPC__BOTTOMANDRIGHT,
	UNI_INPC__LEFT,
	UNI_INPC__LEFTANDRIGHT,
	UNI_INPC__NA,
	UNI_INPC__OVERSTRUCK,
	UNI_INPC__RIGHT,
	UNI_INPC__TOP,
	UNI_INPC__TOPANDBOTTOM,
	UNI_INPC__TOPANDBOTTOMANDLEFT,
	UNI_INPC__TOPANDBOTTOMANDRIGHT,
	UNI_INPC__TOPANDLEFT,
	UNI_INPC__TOPANDLEFTANDRIGHT,
	UNI_INPC__TOPANDRIGHT,
	UNI_INPHAGSPA,
	UNI_INPHOENICIAN,
	UNI_INPSALTERPAHLAVI,
	UNI_INPUNCTUATION,
	UNI_INREJANG,
	UNI_INRUNIC,
	UNI_INSAMARITAN,
	UNI_INSAURASHTRA,
	UNI_INSC__AVAGRAHA,
	UNI_INSC__BINDU,
	UNI_INSC__BRAHMIJOININGNUMBER,
	UNI_INSC__CANTILLATIONMARK,
	UNI_INSC__CONSONANT,
	UNI_INSC__CONSONANTDEAD,
	UNI_INSC__CONSONANTFINAL,
	UNI_INSC__CONSONANTHEADLETTER,
	UNI_INSC__CONSONANTINITIALPOSTFIXED,
	UNI_INSC__CONSONANTKILLER,
	UNI_INSC__CONSONANTMEDIAL,
	UNI_INSC__CONSONANTPLACEHOLDER,
	UNI_INSC__CONSONANTPRECEDINGREPHA,
	UNI_INSC__CONSONANTPREFIXED,
	UNI_INSC__CONSONANTSUBJOINED,
	UNI_INSC__CONSONANTSUCCEEDINGREPHA,
	UNI_INSC__CONSONANTWITHSTACKER,
	UNI_INSC__GEMINATIONMARK,
	UNI_INSC__INVISIBLESTACKER,
	UNI_INSC__MODIFYINGLETTER,
	UNI_INSC__NONJOINER,
	UNI_INSC__NUKTA,
	UNI_INSC__NUMBER,
	UNI_INSC__NUMBERJOINER,
	UNI_INSC__OTHER,
	UNI_INSC__PUREKILLER,
	UNI_INSC__REGISTERSHIFTER,
	UNI_INSC__SYLLABLEMODIFIER,
	UNI_INSC__TONELETTER,
	UNI_INSC__TONEMARK,
	UNI_INSC__VIRAMA,
	UNI_INSC__VISARGA,
	UNI_INSC__VOWEL,
	UNI_INSC__VOWELDEPENDENT,
	UNI_INSC__VOWELINDEPENDENT,
	UNI_INSIDDHAM,
	UNI_INSINHALA,
	UNI_INSOGDIAN,
	UNI_INSORASOMPENG,
	UNI_INSOYOMBO,
	UNI_INSUNDANESE,
	UNI_INSYLOTINAGRI,
	UNI_INSYRIAC,
	UNI_INTAGALOG,
	UNI_INTAGBANWA,
	UNI_INTAILE,
	UNI_INTAITHAM,
	UNI_INTAIVIET,
	UNI_INTAKRI,
	UNI_INTAMIL,
	UNI_INTANGSA,
	UNI_INTANGUT,
	UNI_INTELUGU,
	UNI_INTHAANA,
	UNI_INTHAI,
	UNI_INTIBETAN,
	UNI_INTIFINAGH,
	UNI_INTIRHUTA,
	UNI_INTOTO,
	UNI_INUGARITIC,
	UNI_INVAI,
	UNI_INVITHKUQI,
	UNI_INVS,
	UNI_INWANCHO,
	UNI_INWARANGCITI,
	UNI_INYEZIDI,
	UNI_INZANABAZARSQUARE,
	UNI_IN__10,
	UNI_IN__11,
	UNI_IN__12,
	UNI_IN__12_DOT_1,
	UNI_IN__13,
	UNI_IN__14,
	UNI_IN__1_DOT_1,
	UNI_IN__2,
	UNI_IN__2_DOT_1,
	UNI_IN__3,
	UNI_IN__3_DOT_1,
	UNI_IN__3_DOT_2,
	UNI_IN__4,
	UNI_IN__4_DOT_1,
	UNI_IN__5,
	UNI_IN__5_DOT_1,
	UNI_IN__5_DOT_2,
	UNI_IN__6,
	UNI_IN__6_DOT_1,
	UNI_IN__6_DOT_2,
	UNI_IN__6_DOT_3,
	UNI_IN__7,
	UNI_IN__8,
	UNI_IN__9,
	UNI_IN__NA,
	UNI_IPAEXT,
	UNI_ITAL,
	UNI_JAMO,
	UNI_JAMOEXTA,
	UNI_JAMOEXTB,
	UNI_JAVA,
	UNI_JG__AFRICANFEH,
	UNI_JG__AFRICANNOON,
	UNI_JG__AFRICANQAF,
	UNI_JG__AIN,
	UNI_JG__ALAPH,
	UNI_JG__ALEF,
	UNI_JG__BEH,
	UNI_JG__BETH,
	UNI_JG__BURUSHASKIYEHBARREE,
	UNI_JG__DAL,
	UNI_JG__DALATHRISH,
	UNI_JG__E,
	UNI_JG__FARSIYEH,
	UNI_JG__FE,
	UNI_JG__FEH,
	UNI_JG__FINALSEMKATH,
	UNI_JG__GAF,
	UNI_JG__GAMAL,
	UNI_JG__HAH,
	UNI_JG__HAMZAONHEHGOAL,
	UNI_JG__HANIFIROHINGYAKINNAYA,
	UNI_JG__HANIFIROHINGYAPA,
	UNI_JG__HE,
	UNI_JG__HEH,
	UNI_JG__HEHGOAL,
	UNI_JG__HETH,
	UNI_JG__KAF,
	UNI_JG__KAPH,
	UNI_JG__KHAPH,
	UNI_JG__KNOTTEDHEH,
	UNI_JG__LAM,
	UNI_JG__LAMADH,
	UNI_JG__MALAYALAMBHA,
	UNI_JG__MALAYALAMJA,
	UNI_JG__MALAYALAMLLA,
	UNI_JG__MALAYALAMLLLA,
	UNI_JG__MALAYALAMNGA,
	UNI_JG__MALAYALAMNNA,
	UNI_JG__MALAYALAMNNNA,
	UNI_JG__MALAYALAMNYA,
	UNI_JG__MALAYALAMRA,
	UNI_JG__MALAYALAMSSA,
	UNI_JG__MALAYALAMTTA,
	UNI_JG__MANICHAEANALEPH,
	UNI_JG__MANICHAEANAYIN,
	UNI_JG__MANICHAEANBETH,
	UNI_JG__MANICHAEANDALETH,
	UNI_JG__MANICHAEANDHAMEDH,
	UNI_JG__MANICHAEANFIVE,
	UNI_JG__MANICHAEANGIMEL,
	UNI_JG__MANICHAEANHETH,
	UNI_JG__MANICHAEANHUNDRED,
	UNI_JG__MANICHAEANKAPH,
	UNI_JG__MANICHAEANLAMEDH,
	UNI_JG__MANICHAEANMEM,
	UNI_JG__MANICHAEANNUN,
	UNI_JG__MANICHAEANONE,
	UNI_JG__MANICHAEANPE,
	UNI_JG__MANICHAEANQOPH,
	UNI_JG__MANICHAEANRESH,
	UNI_JG__MANICHAEANSADHE,
	UNI_JG__MANICHAEANSAMEKH,
	UNI_JG__MANICHAEANTAW,
	UNI_JG__MANICHAEANTEN,
	UNI_JG__MANICHAEANTETH,
	UNI_JG__MANICHAEANTHAMEDH,
	UNI_JG__MANICHAEANTWENTY,
	UNI_JG__MANICHAEANWAW,
	UNI_JG__MANICHAEANYODH,
	UNI_JG__MANICHAEANZAYIN,
	UNI_JG__MEEM,
	UNI_JG__MIM,
	UNI_JG__NOJOININGGROUP,
	UNI_JG__NOON,
	UNI_JG__NUN,
	UNI_JG__NYA,
	UNI_JG__PE,
	UNI_JG__QAF,
	UNI_JG__QAPH,
	UNI_JG__REH,
	UNI_JG__REVERSEDPE,
	UNI_JG__ROHINGYAYEH,
	UNI_JG__SAD,
	UNI_JG__SADHE,
	UNI_JG__SEEN,
	UNI_JG__SEMKATH,
	UNI_JG__SHIN,
	UNI_JG__STRAIGHTWAW,
	UNI_JG__SWASHKAF,
	UNI_JG__SYRIACWAW,
	UNI_JG__TAH,
	UNI_JG__TAW,
	UNI_JG__TEHMARBUTA,
	UNI_JG__TETH,
	UNI_JG__THINYEH,
	UNI_JG__VERTICALTAIL,
	UNI_JG__WAW,
	UNI_JG__YEH,
	UNI_JG__YEHBARREE,
	UNI_JG__YEHWITHTAIL,
	UNI_JG__YUDH,
	UNI_JG__YUDHHE,
	UNI_JG__ZAIN,
	UNI_JG__ZHAIN,
	UNI_JOINC,
	UNI_JT__C,
	UNI_JT__D,
	UNI_JT__L,
	UNI_JT__R,
	UNI_JT__T,
	UNI_JT__U,
	UNI_KALI,
	UNI_KANA,
	UNI_KANAEXTA,
	UNI_KANAEXTB,
	UNI_KANASUP,
	UNI_KANBUN,
	UNI_KANGXI,
	UNI_KATAKANAEXT,
	UNI_KHAR,
	UNI_KHMERSYMBOLS,
	UNI_KHMR,
	UNI_KHOJ,
	UNI_KITS,
	UNI_KNDA,
	UNI_KTHI,
	UNI_L,
	UNI_LANA,
	UNI_LAO,
	UNI_LATIN1,
	UNI_LATINEXTA,
	UNI_LATINEXTADDITIONAL,
	UNI_LATINEXTB,
	UNI_LATINEXTC,
	UNI_LATINEXTD,
	UNI_LATINEXTE,
	UNI_LATINEXTF,
	UNI_LATINEXTG,
	UNI_LATN,
	UNI_LB__AI,
	UNI_LB__AL,
	UNI_LB__B2,
	UNI_LB__BA,
	UNI_LB__BB,
	UNI_LB__BK,
	UNI_LB__CB,
	UNI_LB__CJ,
	UNI_LB__CL,
	UNI_LB__CM,
	UNI_LB__CP,
	UNI_LB__CR,
	UNI_LB__EX,
	UNI_LB__GL,
	UNI_LB__H2,
	UNI_LB__H3,
	UNI_LB__HL,
	UNI_LB__HY,
	UNI_LB__ID,
	UNI_LB__IN,
	UNI_LB__IS,
	UNI_LB__LF,
	UNI_LB__NL,
	UNI_LB__NS,
	UNI_LB__NU,
	UNI_LB__OP,
	UNI_LB__PO,
	UNI_LB__PR,
	UNI_LB__QU,
	UNI_LB__SA,
	UNI_LB__SG_perl_aux,
	UNI_LB__SP,
	UNI_LB__SY,
	UNI_LB__WJ,
	UNI_LB__XX,
	UNI_LB__ZW,
	UNI_LB__ZWJ,
	UNI_LEPC,
	UNI_LETTERLIKESYMBOLS,
	UNI_LIMB,
	UNI_LINA,
	UNI_LINB,
	UNI_LINEARBIDEOGRAMS,
	UNI_LINEARBSYLLABARY,
	UNI_LISU,
	UNI_LISUSUP,
	UNI_LM,
	UNI_LO,
	UNI_LOE,
	UNI_LOWERCASELETTER,
	UNI_LOWSURROGATES,
	UNI_LYCI,
	UNI_LYDI,
	UNI_M,
	UNI_MAHJ,
	UNI_MAHJONG,
	UNI_MAKA,
	UNI_MAND,
	UNI_MANI,
	UNI_MARC,
	UNI_MATH,
	UNI_MATHALPHANUM,
	UNI_MATHOPERATORS,
	UNI_MAYANNUMERALS,
	UNI_MC,
	UNI_ME,
	UNI_MEDF,
	UNI_MEETEIMAYEKEXT,
	UNI_MEND,
	UNI_MERC,
	UNI_MERO,
	UNI_MIAO,
	UNI_MISCARROWS,
	UNI_MISCMATHSYMBOLSA,
	UNI_MISCMATHSYMBOLSB,
	UNI_MISCPICTOGRAPHS,
	UNI_MISCSYMBOLS,
	UNI_MISCTECHNICAL,
	UNI_MLYM,
	UNI_MN,
	UNI_MODI,
	UNI_MODIFIERLETTERS,
	UNI_MODIFIERTONELETTERS,
	UNI_MONG,
	UNI_MONGOLIANSUP,
	UNI_MRO,
	UNI_MTEI,
	UNI_MULT,
	UNI_MUSIC,
	UNI_MYANMAREXTA,
	UNI_MYANMAREXTB,
	UNI_MYMR,
	UNI_N,
	UNI_NAND,
	UNI_NARB,
	UNI_NB,
	UNI_NBAT,
	UNI_NEWA,
	UNI_NFCQC__M,
	UNI_NFCQC__Y,
	UNI_NFDQC__Y,
	UNI_NFKCQC__N,
	UNI_NFKCQC__Y,
	UNI_NFKDQC__N,
	UNI_NKO,
	UNI_NL,
	UNI_NO,
	UNI_NSHU,
	UNI_NT__DI,
	UNI_NT__NU,
	UNI_NUMBERFORMS,
	UNI_NV__0,
	UNI_NV__1,
	UNI_NV__10,
	UNI_NV__100,
	UNI_NV__1000,
	UNI_NV__10000,
	UNI_NV__100000,
	UNI_NV__1000000,
	UNI_NV__10000000,
	UNI_NV__100000000,
	UNI_NV__10000000000,
	UNI_NV__1000000000000,
	UNI_NV__11,
	UNI_NV__11_SLASH_12,
	UNI_NV__11_SLASH_2,
	UNI_NV__12,
	UNI_NV__13,
	UNI_NV__13_SLASH_2,
	UNI_NV__14,
	UNI_NV__15,
	UNI_NV__15_SLASH_2,
	UNI_NV__16,
	UNI_NV__17,
	UNI_NV__17_SLASH_2,
	UNI_NV__18,
	UNI_NV__19,
	UNI_NV__1_SLASH_10,
	UNI_NV__1_SLASH_12,
	UNI_NV__1_SLASH_16,
	UNI_NV__1_SLASH_160,
	UNI_NV__1_SLASH_2,
	UNI_NV__1_SLASH_20,
	UNI_NV__1_SLASH_3,
	UNI_NV__1_SLASH_32,
	UNI_NV__1_SLASH_320,
	UNI_NV__1_SLASH_4,
	UNI_NV__1_SLASH_40,
	UNI_NV__1_SLASH_5,
	UNI_NV__1_SLASH_6,
	UNI_NV__1_SLASH_64,
	UNI_NV__1_SLASH_7,
	UNI_NV__1_SLASH_8,
	UNI_NV__1_SLASH_80,
	UNI_NV__1_SLASH_9,
	UNI_NV__2,
	UNI_NV__20,
	UNI_NV__200,
	UNI_NV__2000,
	UNI_NV__20000,
	UNI_NV__200000,
	UNI_NV__20000000,
	UNI_NV__21,
	UNI_NV__216000,
	UNI_NV__22,
	UNI_NV__23,
	UNI_NV__24,
	UNI_NV__25,
	UNI_NV__26,
	UNI_NV__27,
	UNI_NV__28,
	UNI_NV__29,
	UNI_NV__2_SLASH_3,
	UNI_NV__2_SLASH_5,
	UNI_NV__3,
	UNI_NV__30,
	UNI_NV__300,
	UNI_NV__3000,
	UNI_NV__30000,
	UNI_NV__300000,
	UNI_NV__31,
	UNI_NV__32,
	UNI_NV__33,
	UNI_NV__34,
	UNI_NV__35,
	UNI_NV__36,
	UNI_NV__37,
	UNI_NV__38,
	UNI_NV__39,
	UNI_NV__3_SLASH_16,
	UNI_NV__3_SLASH_2,
	UNI_NV__3_SLASH_20,
	UNI_NV__3_SLASH_4,
	UNI_NV__3_SLASH_5,
	UNI_NV__3_SLASH_64,
	UNI_NV__3_SLASH_8,
	UNI_NV__3_SLASH_80,
	UNI_NV__4,
	UNI_NV__40,
	UNI_NV__400,
	UNI_NV__4000,
	UNI_NV__40000,
	UNI_NV__400000,
	UNI_NV__41,
	UNI_NV__42,
	UNI_NV__43,
	UNI_NV__432000,
	UNI_NV__44,
	UNI_NV__45,
	UNI_NV__46,
	UNI_NV__47,
	UNI_NV__48,
	UNI_NV__49,
	UNI_NV__4_SLASH_5,
	UNI_NV__5,
	UNI_NV__50,
	UNI_NV__500,
	UNI_NV__5000,
	UNI_NV__50000,
	UNI_NV__500000,
	UNI_NV__5_SLASH_12,
	UNI_NV__5_SLASH_2,
	UNI_NV__5_SLASH_6,
	UNI_NV__5_SLASH_8,
	UNI_NV__6,
	UNI_NV__60,
	UNI_NV__600,
	UNI_NV__6000,
	UNI_NV__60000,
	UNI_NV__600000,
	UNI_NV__7,
	UNI_NV__70,
	UNI_NV__700,
	UNI_NV__7000,
	UNI_NV__70000,
	UNI_NV__700000,
	UNI_NV__7_SLASH_12,
	UNI_NV__7_SLASH_2,
	UNI_NV__7_SLASH_8,
	UNI_NV__8,
	UNI_NV__80,
	UNI_NV__800,
	UNI_NV__8000,
	UNI_NV__80000,
	UNI_NV__800000,
	UNI_NV__9,
	UNI_NV__90,
	UNI_NV__900,
	UNI_NV__9000,
	UNI_NV__90000,
	UNI_NV__900000,
	UNI_NV__9_SLASH_2,
	UNI_NV__NAN,
	UNI_NV___MINUS_1_SLASH_2,
	UNI_OCR,
	UNI_OGAM,
	UNI_OLCK,
	UNI_ORKH,
	UNI_ORNAMENTALDINGBATS,
	UNI_ORYA,
	UNI_OSGE,
	UNI_OSMA,
	UNI_OTTOMANSIYAQNUMBERS,
	UNI_OUGR,
	UNI_P,
	UNI_PALM,
	UNI_PATSYN,
	UNI_PAUC,
	UNI_PC,
	UNI_PCM,
	UNI_PD,
	UNI_PE,
	UNI_PERM,
	UNI_PF,
	UNI_PHAG,
	UNI_PHAISTOS,
	UNI_PHLI,
	UNI_PHLP,
	UNI_PHNX,
	UNI_PHONETICEXT,
	UNI_PHONETICEXTSUP,
	UNI_PI,
	UNI_PLAYINGCARDS,
	UNI_PO,
	UNI_POSIXALNUM,
	UNI_POSIXALPHA,
	UNI_POSIXBLANK,
	UNI_POSIXCNTRL,
	UNI_POSIXDIGIT,
	UNI_POSIXGRAPH,
	UNI_POSIXLOWER,
	UNI_POSIXPRINT,
	UNI_POSIXPUNCT,
	UNI_POSIXSPACE,
	UNI_POSIXUPPER,
	UNI_POSIXWORD,
	UNI_POSIXXDIGIT,
	UNI_PRTI,
	UNI_PS,
	UNI_PUA,
	UNI_QAAI,
	UNI_QMARK,
	UNI_RADICAL,
	UNI_RI,
	UNI_RJNG,
	UNI_ROHG,
	UNI_RUMI,
	UNI_RUNR,
	UNI_S,
	UNI_SAMR,
	UNI_SARB,
	UNI_SAUR,
	UNI_SB__AT,
	UNI_SB__CL,
	UNI_SB__EX,
	UNI_SB__FO,
	UNI_SB__LE,
	UNI_SB__LO,
	UNI_SB__NU,
	UNI_SB__SC,
	UNI_SB__SE,
	UNI_SB__SP,
	UNI_SB__ST,
	UNI_SB__UP,
	UNI_SB__XX,
	UNI_SC,
	UNI_SC__ADLM,
	UNI_SC__ARAB,
	UNI_SC__BENG,
	UNI_SC__BOPO,
	UNI_SC__BUGI,
	UNI_SC__BUHD,
	UNI_SC__CAKM,
	UNI_SC__COPT,
	UNI_SC__CPMN,
	UNI_SC__CPRT,
	UNI_SC__CYRL,
	UNI_SC__DEVA,
	UNI_SC__DOGR,
	UNI_SC__DUPL,
	UNI_SC__GEOR,
	UNI_SC__GLAG,
	UNI_SC__GONG,
	UNI_SC__GONM,
	UNI_SC__GRAN,
	UNI_SC__GREK,
	UNI_SC__GUJR,
	UNI_SC__GURU,
	UNI_SC__HAN,
	UNI_SC__HANG,
	UNI_SC__HANO,
	UNI_SC__HIRA,
	UNI_SC__JAVA,
	UNI_SC__KALI,
	UNI_SC__KANA,
	UNI_SC__KHOJ,
	UNI_SC__KNDA,
	UNI_SC__KTHI,
	UNI_SC__LATN,
	UNI_SC__LIMB,
	UNI_SC__LINA,
	UNI_SC__LINB,
	UNI_SC__MAHJ,
	UNI_SC__MAND,
	UNI_SC__MANI,
	UNI_SC__MLYM,
	UNI_SC__MODI,
	UNI_SC__MONG,
	UNI_SC__MULT,
	UNI_SC__MYMR,
	UNI_SC__NAND,
	UNI_SC__NKO,
	UNI_SC__ORYA,
	UNI_SC__OUGR,
	UNI_SC__PERM,
	UNI_SC__PHAG,
	UNI_SC__PHLP,
	UNI_SC__QAAI,
	UNI_SC__ROHG,
	UNI_SC__SHRD,
	UNI_SC__SIND,
	UNI_SC__SINH,
	UNI_SC__SOGD,
	UNI_SC__SYLO,
	UNI_SC__SYRC,
	UNI_SC__TAGB,
	UNI_SC__TAKR,
	UNI_SC__TALE,
	UNI_SC__TAML,
	UNI_SC__TELU,
	UNI_SC__TGLG,
	UNI_SC__THAA,
	UNI_SC__TIRH,
	UNI_SC__YEZI,
	UNI_SC__YI,
	UNI_SC__ZYYY,
	UNI_SD,
	UNI_SGNW,
	UNI_SHAW,
	UNI_SHORTHANDFORMATCONTROLS,
	UNI_SHRD,
	UNI_SIDD,
	UNI_SIND,
	UNI_SINH,
	UNI_SINHALAARCHAICNUMBERS,
	UNI_SK,
	UNI_SM,
	UNI_SMALLFORMS,
	UNI_SMALLKANAEXT,
	UNI_SO,
	UNI_SOGD,
	UNI_SOGO,
	UNI_SORA,
	UNI_SOYO,
	UNI_SPECIALS,
	UNI_STERM,
	UNI_SUND,
	UNI_SUNDANESESUP,
	UNI_SUPARROWSA,
	UNI_SUPARROWSB,
	UNI_SUPARROWSC,
	UNI_SUPERANDSUB,
	UNI_SUPMATHOPERATORS,
	UNI_SUPPUAA,
	UNI_SUPPUAB,
	UNI_SUPPUNCTUATION,
	UNI_SUPSYMBOLSANDPICTOGRAPHS,
	UNI_SUTTONSIGNWRITING,
	UNI_SYLO,
	UNI_SYMBOLSANDPICTOGRAPHSEXTA,
	UNI_SYMBOLSFORLEGACYCOMPUTING,
	UNI_SYRC,
	UNI_SYRIACSUP,
	UNI_TAGB,
	UNI_TAGS,
	UNI_TAIXUANJING,
	UNI_TAKR,
	UNI_TALE,
	UNI_TALU,
	UNI_TAMILSUP,
	UNI_TAML,
	UNI_TANG,
	UNI_TANGUTCOMPONENTS,
	UNI_TANGUTSUP,
	UNI_TAVT,
	UNI_TELU,
	UNI_TERM,
	UNI_TFNG,
	UNI_TGLG,
	UNI_THAA,
	UNI_THAI,
	UNI_TIBT,
	UNI_TIRH,
	UNI_TITLE,
	UNI_TNSA,
	UNI_TOTO,
	UNI_TRANSPORTANDMAP,
	UNI_UCAS,
	UNI_UCASEXT,
	UNI_UCASEXTA,
	UNI_UGAR,
	UNI_UIDEO,
	UNI_UPPERCASELETTER,
	UNI_VAI,
	UNI_VEDICEXT,
	UNI_VERTICALFORMS,
	UNI_VERTSPACE,
	UNI_VITH,
	UNI_VO__R,
	UNI_VO__TR,
	UNI_VO__TU,
	UNI_VO__U,
	UNI_VS,
	UNI_VSSUP,
	UNI_WARA,
	UNI_WB__DQ,
	UNI_WB__EB,
	UNI_WB__EX,
	UNI_WB__EXTEND,
	UNI_WB__FO,
	UNI_WB__KA,
	UNI_WB__LE,
	UNI_WB__MB,
	UNI_WB__ML,
	UNI_WB__MN,
	UNI_WB__NL,
	UNI_WB__NU,
	UNI_WB__SQ,
	UNI_WB__WSEGSPACE,
	UNI_WB__XX,
	UNI_WCHO,
	UNI_XIDC,
	UNI_XIDS,
	UNI_XPEO,
	UNI_XPOSIXALNUM,
	UNI_XPOSIXALPHA,
	UNI_XPOSIXBLANK,
	UNI_XPOSIXCNTRL,
	UNI_XPOSIXDIGIT,
	UNI_XPOSIXGRAPH,
	UNI_XPOSIXLOWER,
	UNI_XPOSIXPRINT,
	UNI_XPOSIXPUNCT,
	UNI_XPOSIXSPACE,
	UNI_XPOSIXUPPER,
	UNI_XPOSIXWORD,
	UNI_XPOSIXXDIGIT,
	UNI_XSUX,
	UNI_YEZI,
	UNI_YI,
	UNI_YIJING,
	UNI_YIRADICALS,
	UNI_YISYLLABLES,
	UNI_Z,
	UNI_ZANB,
	UNI_ZL,
	UNI_ZNAMENNYMUSIC,
	UNI_ZP,
	UNI_ZS,
	UNI_ZYYY,
	UNI_ZZZZ,
	UNI__PERL_ANY_FOLDS,
	UNI__PERL_CHARNAME_BEGIN,
	UNI__PERL_CHARNAME_CONTINUE,
	UNI__PERL_FOLDS_TO_MULTI_CHAR,
	UNI__PERL_IDCONT,
	UNI__PERL_IDSTART,
	UNI__PERL_IS_IN_MULTI_CHAR_FOLD,
	UNI__PERL_NCHAR,
	UNI__PERL_PATWS,
	UNI__PERL_PROBLEMATIC_LOCALE_FOLDEDS_START,
	UNI__PERL_PROBLEMATIC_LOCALE_FOLDS,
	UNI__PERL_QUOTEMETA,
	UNI__PERL_SURROGATE
} binary_invlist_enum;

#define MAX_UNI_KEYWORD_INDEX UNI__PERL_SURROGATE

#endif	/* defined(PERL_IN_REGCOMP_C) */

#if (defined(PERL_IN_REGCOMP_C) && ! defined(PERL_IN_XSUB_RE))

static const UV * const uni_prop_ptrs[] = {
	NULL,	/* Placeholder */
	UNI_ADLM_invlist,
	UNI_AEGEANNUMBERS_invlist,
	UNI_AGE__10_invlist,
	UNI_AGE__11_invlist,
	UNI_AGE__12_invlist,
	UNI_AGE__12_DOT_1_invlist,
	UNI_AGE__13_invlist,
	UNI_AGE__14_invlist,
	UNI_AGE__2_invlist,
	UNI_AGE__2_DOT_1_invlist,
	UNI_AGE__3_invlist,
	UNI_AGE__3_DOT_1_invlist,
	UNI_AGE__3_DOT_2_invlist,
	UNI_AGE__4_invlist,
	UNI_AGE__4_DOT_1_invlist,
	UNI_AGE__5_invlist,
	UNI_AGE__5_DOT_1_invlist,
	UNI_AGE__5_DOT_2_invlist,
	UNI_AGE__6_invlist,
	UNI_AGE__6_DOT_1_invlist,
	UNI_AGE__6_DOT_2_invlist,
	UNI_AGE__6_DOT_3_invlist,
	UNI_AGE__7_invlist,
	UNI_AGE__8_invlist,
	UNI_AGE__9_invlist,
	UNI_AGHB_invlist,
	UNI_AHOM_invlist,
	UNI_ALCHEMICAL_invlist,
	UNI_ALL_invlist,
	UNI_ALPHABETICPF_invlist,
	UNI_ANCIENTGREEKMUSIC_invlist,
	UNI_ANCIENTGREEKNUMBERS_invlist,
	UNI_ANCIENTSYMBOLS_invlist,
	UNI_ANY_invlist,
	UNI_ARAB_invlist,
	UNI_ARABICEXTA_invlist,
	UNI_ARABICEXTB_invlist,
	UNI_ARABICMATH_invlist,
	UNI_ARABICPFA_invlist,
	UNI_ARABICPFB_invlist,
	UNI_ARABICSUP_invlist,
	UNI_ARMI_invlist,
	UNI_ARMN_invlist,
	UNI_ARROWS_invlist,
	UNI_ASCII_invlist,
	UNI_ASSIGNED_invlist,
	UNI_AVST_invlist,
	UNI_BALI_invlist,
	UNI_BAMU_invlist,
	UNI_BAMUMSUP_invlist,
	UNI_BASS_invlist,
	UNI_BATK_invlist,
	UNI_BC__AL_invlist,
	UNI_BC__AN_invlist,
	UNI_BC__B_invlist,
	UNI_BC__BN_invlist,
	UNI_BC__CS_invlist,
	UNI_BC__EN_invlist,
	UNI_BC__ES_invlist,
	UNI_BC__ET_invlist,
	UNI_BC__FSI_invlist,
	UNI_BC__L_invlist,
	UNI_BC__LRE_invlist,
	UNI_BC__LRI_invlist,
	UNI_BC__LRO_invlist,
	UNI_BC__NSM_invlist,
	UNI_BC__ON_invlist,
	UNI_BC__PDF_invlist,
	UNI_BC__PDI_invlist,
	UNI_BC__R_invlist,
	UNI_BC__RLE_invlist,
	UNI_BC__RLI_invlist,
	UNI_BC__RLO_invlist,
	UNI_BC__S_invlist,
	UNI_BC__WS_invlist,
	UNI_BENG_invlist,
	UNI_BHKS_invlist,
	UNI_BIDIC_invlist,
	UNI_BIDIM_invlist,
	UNI_BLOCKELEMENTS_invlist,
	UNI_BOPO_invlist,
	UNI_BOPOMOFOEXT_invlist,
	UNI_BOXDRAWING_invlist,
	UNI_BPT__C_invlist,
	UNI_BPT__N_invlist,
	UNI_BPT__O_invlist,
	UNI_BRAH_invlist,
	UNI_BRAI_invlist,
	UNI_BUGI_invlist,
	UNI_BUHD_invlist,
	UNI_BYZANTINEMUSIC_invlist,
	UNI_C_invlist,
	UNI_CAKM_invlist,
	UNI_CANS_invlist,
	UNI_CARI_invlist,
	UNI_CASED_invlist,
	UNI_CASEDLETTER_invlist,
	UNI_CCC__0_invlist,
	UNI_CCC__1_invlist,
	UNI_CCC__10_invlist,
	UNI_CCC__103_invlist,
	UNI_CCC__107_invlist,
	UNI_CCC__11_invlist,
	UNI_CCC__118_invlist,
	UNI_CCC__12_invlist,
	UNI_CCC__122_invlist,
	UNI_CCC__129_invlist,
	UNI_CCC__13_invlist,
	UNI_CCC__130_invlist,
	UNI_CCC__132_invlist,
	UNI_CCC__14_invlist,
	UNI_CCC__15_invlist,
	UNI_CCC__16_invlist,
	UNI_CCC__17_invlist,
	UNI_CCC__18_invlist,
	UNI_CCC__19_invlist,
	UNI_CCC__20_invlist,
	UNI_CCC__202_invlist,
	UNI_CCC__21_invlist,
	UNI_CCC__214_invlist,
	UNI_CCC__216_invlist,
	UNI_CCC__22_invlist,
	UNI_CCC__23_invlist,
	UNI_CCC__24_invlist,
	UNI_CCC__25_invlist,
	UNI_CCC__26_invlist,
	UNI_CCC__27_invlist,
	UNI_CCC__28_invlist,
	UNI_CCC__29_invlist,
	UNI_CCC__30_invlist,
	UNI_CCC__31_invlist,
	UNI_CCC__32_invlist,
	UNI_CCC__33_invlist,
	UNI_CCC__34_invlist,
	UNI_CCC__35_invlist,
	UNI_CCC__36_invlist,
	UNI_CCC__6_invlist,
	UNI_CCC__7_invlist,
	UNI_CCC__8_invlist,
	UNI_CCC__84_invlist,
	UNI_CCC__9_invlist,
	UNI_CCC__91_invlist,
	UNI_CCC__A_invlist,
	UNI_CCC__AL_invlist,
	UNI_CCC__AR_invlist,
	UNI_CCC__B_invlist,
	UNI_CCC__BL_invlist,
	UNI_CCC__BR_invlist,
	UNI_CCC__DA_invlist,
	UNI_CCC__DB_invlist,
	UNI_CCC__IS_invlist,
	UNI_CCC__L_invlist,
	UNI_CCC__R_invlist,
	UNI_CE_invlist,
	UNI_CF_invlist,
	UNI_CHAM_invlist,
	UNI_CHER_invlist,
	UNI_CHEROKEESUP_invlist,
	UNI_CHESSSYMBOLS_invlist,
	UNI_CHRS_invlist,
	UNI_CI_invlist,
	UNI_CJK_invlist,
	UNI_CJKCOMPAT_invlist,
	UNI_CJKCOMPATFORMS_invlist,
	UNI_CJKCOMPATIDEOGRAPHS_invlist,
	UNI_CJKCOMPATIDEOGRAPHSSUP_invlist,
	UNI_CJKEXTA_invlist,
	UNI_CJKEXTB_invlist,
	UNI_CJKEXTC_invlist,
	UNI_CJKEXTD_invlist,
	UNI_CJKEXTE_invlist,
	UNI_CJKEXTF_invlist,
	UNI_CJKEXTG_invlist,
	UNI_CJKRADICALSSUP_invlist,
	UNI_CJKSTROKES_invlist,
	UNI_CJKSYMBOLS_invlist,
	UNI_CN_invlist,
	UNI_CO_invlist,
	UNI_COMPATJAMO_invlist,
	UNI_COMPEX_invlist,
	UNI_CONTROLPICTURES_invlist,
	UNI_COPT_invlist,
	UNI_COPTICEPACTNUMBERS_invlist,
	UNI_COUNTINGROD_invlist,
	UNI_CPMN_invlist,
	UNI_CPRT_invlist,
	UNI_CUNEIFORMNUMBERS_invlist,
	UNI_CURRENCYSYMBOLS_invlist,
	UNI_CWCF_invlist,
	UNI_CWCM_invlist,
	UNI_CWKCF_invlist,
	UNI_CWL_invlist,
	UNI_CWT_invlist,
	UNI_CWU_invlist,
	UNI_CYPRIOTSYLLABARY_invlist,
	UNI_CYRILLICEXTA_invlist,
	UNI_CYRILLICEXTB_invlist,
	UNI_CYRILLICEXTC_invlist,
	UNI_CYRILLICSUP_invlist,
	UNI_CYRL_invlist,
	UNI_DASH_invlist,
	UNI_DEP_invlist,
	UNI_DEVA_invlist,
	UNI_DEVANAGARIEXT_invlist,
	UNI_DI_invlist,
	UNI_DIA_invlist,
	UNI_DIACRITICALS_invlist,
	UNI_DIACRITICALSEXT_invlist,
	UNI_DIACRITICALSFORSYMBOLS_invlist,
	UNI_DIACRITICALSSUP_invlist,
	UNI_DIAK_invlist,
	UNI_DINGBATS_invlist,
	UNI_DOGR_invlist,
	UNI_DOMINO_invlist,
	UNI_DSRT_invlist,
	UNI_DT__CAN_invlist,
	UNI_DT__COM_invlist,
	UNI_DT__ENC_invlist,
	UNI_DT__FIN_invlist,
	UNI_DT__FONT_invlist,
	UNI_DT__FRA_invlist,
	UNI_DT__INIT_invlist,
	UNI_DT__ISO_invlist,
	UNI_DT__MED_invlist,
	UNI_DT__NAR_invlist,
	UNI_DT__NB_invlist,
	UNI_DT__NONCANON_invlist,
	UNI_DT__NONE_invlist,
	UNI_DT__SML_invlist,
	UNI_DT__SQR_invlist,
	UNI_DT__SUB_invlist,
	UNI_DT__SUP_invlist,
	UNI_DT__VERT_invlist,
	UNI_DUPL_invlist,
	UNI_EARLYDYNASTICCUNEIFORM_invlist,
	UNI_EA__A_invlist,
	UNI_EA__F_invlist,
	UNI_EA__H_invlist,
	UNI_EA__N_invlist,
	UNI_EA__NA_invlist,
	UNI_EA__W_invlist,
	UNI_EBASE_invlist,
	UNI_ECOMP_invlist,
	UNI_EGYP_invlist,
	UNI_EGYPTIANHIEROGLYPHFORMATCONTROLS_invlist,
	UNI_ELBA_invlist,
	UNI_ELYM_invlist,
	UNI_EMOD_invlist,
	UNI_EMOJI_invlist,
	UNI_EMOTICONS_invlist,
	UNI_ENCLOSEDALPHANUM_invlist,
	UNI_ENCLOSEDALPHANUMSUP_invlist,
	UNI_ENCLOSEDCJK_invlist,
	UNI_ENCLOSEDIDEOGRAPHICSUP_invlist,
	UNI_EPRES_invlist,
	UNI_ETHI_invlist,
	UNI_ETHIOPICEXT_invlist,
	UNI_ETHIOPICEXTA_invlist,
	UNI_ETHIOPICEXTB_invlist,
	UNI_ETHIOPICSUP_invlist,
	UNI_EXT_invlist,
	UNI_EXTPICT_invlist,
	UNI_GCB__CN_invlist,
	UNI_GCB__EX_invlist,
	UNI_GCB__L_invlist,
	UNI_GCB__PP_invlist,
	UNI_GCB__SM_invlist,
	UNI_GCB__T_invlist,
	UNI_GCB__V_invlist,
	UNI_GCB__XX_invlist,
	UNI_GEOMETRICSHAPES_invlist,
	UNI_GEOMETRICSHAPESEXT_invlist,
	UNI_GEOR_invlist,
	UNI_GEORGIANEXT_invlist,
	UNI_GEORGIANSUP_invlist,
	UNI_GLAG_invlist,
	UNI_GLAGOLITICSUP_invlist,
	UNI_GONG_invlist,
	UNI_GONM_invlist,
	UNI_GOTH_invlist,
	UNI_GRAN_invlist,
	UNI_GRBASE_invlist,
	UNI_GREEKEXT_invlist,
	UNI_GREK_invlist,
	UNI_GREXT_invlist,
	UNI_GUJR_invlist,
	UNI_GURU_invlist,
	UNI_HALFANDFULLFORMS_invlist,
	UNI_HALFMARKS_invlist,
	UNI_HAN_invlist,
	UNI_HANG_invlist,
	UNI_HANO_invlist,
	UNI_HATR_invlist,
	UNI_HEBR_invlist,
	UNI_HIGHPUSURROGATES_invlist,
	UNI_HIGHSURROGATES_invlist,
	UNI_HIRA_invlist,
	UNI_HLUW_invlist,
	UNI_HMNG_invlist,
	UNI_HMNP_invlist,
	UNI_HST__NA_invlist,
	UNI_HUNG_invlist,
	UNI_HYPHEN_invlist,
	UNI_IDC_invlist,
	UNI_IDENTIFIERSTATUS__ALLOWED_invlist,
	UNI_IDENTIFIERSTATUS__RESTRICTED_invlist,
	UNI_IDENTIFIERTYPE__DEFAULTIGNORABLE_invlist,
	UNI_IDENTIFIERTYPE__EXCLUSION_invlist,
	UNI_IDENTIFIERTYPE__INCLUSION_invlist,
	UNI_IDENTIFIERTYPE__LIMITEDUSE_invlist,
	UNI_IDENTIFIERTYPE__NOTCHARACTER_invlist,
	UNI_IDENTIFIERTYPE__NOTNFKC_invlist,
	UNI_IDENTIFIERTYPE__NOTXID_invlist,
	UNI_IDENTIFIERTYPE__OBSOLETE_invlist,
	UNI_IDENTIFIERTYPE__RECOMMENDED_invlist,
	UNI_IDENTIFIERTYPE__TECHNICAL_invlist,
	UNI_IDENTIFIERTYPE__UNCOMMONUSE_invlist,
	UNI_IDEO_invlist,
	UNI_IDEOGRAPHICSYMBOLS_invlist,
	UNI_IDS_invlist,
	UNI_IDSB_invlist,
	UNI_IDST_invlist,
	UNI_INADLAM_invlist,
	UNI_INAHOM_invlist,
	UNI_INANATOLIANHIEROGLYPHS_invlist,
	UNI_INARABIC_invlist,
	UNI_INARMENIAN_invlist,
	UNI_INAVESTAN_invlist,
	UNI_INBALINESE_invlist,
	UNI_INBAMUM_invlist,
	UNI_INBASSAVAH_invlist,
	UNI_INBATAK_invlist,
	UNI_INBENGALI_invlist,
	UNI_INBHAIKSUKI_invlist,
	UNI_INBOPOMOFO_invlist,
	UNI_INBRAHMI_invlist,
	UNI_INBUGINESE_invlist,
	UNI_INBUHID_invlist,
	UNI_INCARIAN_invlist,
	UNI_INCAUCASIANALBANIAN_invlist,
	UNI_INCHAKMA_invlist,
	UNI_INCHAM_invlist,
	UNI_INCHEROKEE_invlist,
	UNI_INCHORASMIAN_invlist,
	UNI_INCOPTIC_invlist,
	UNI_INCUNEIFORM_invlist,
	UNI_INCYPROMINOAN_invlist,
	UNI_INCYRILLIC_invlist,
	UNI_INDEVANAGARI_invlist,
	UNI_INDICNUMBERFORMS_invlist,
	UNI_INDICSIYAQNUMBERS_invlist,
	UNI_INDIVESAKURU_invlist,
	UNI_INDOGRA_invlist,
	UNI_INDUPLOYAN_invlist,
	UNI_INEGYPTIANHIEROGLYPHS_invlist,
	UNI_INELBASAN_invlist,
	UNI_INELYMAIC_invlist,
	UNI_INETHIOPIC_invlist,
	UNI_INGEORGIAN_invlist,
	UNI_INGLAGOLITIC_invlist,
	UNI_INGOTHIC_invlist,
	UNI_INGRANTHA_invlist,
	UNI_INGREEK_invlist,
	UNI_INGUJARATI_invlist,
	UNI_INGUNJALAGONDI_invlist,
	UNI_INGURMUKHI_invlist,
	UNI_INHANGUL_invlist,
	UNI_INHANIFIROHINGYA_invlist,
	UNI_INHANUNOO_invlist,
	UNI_INHATRAN_invlist,
	UNI_INHEBREW_invlist,
	UNI_INHIRAGANA_invlist,
	UNI_INIDC_invlist,
	UNI_INIMPERIALARAMAIC_invlist,
	UNI_ININSCRIPTIONALPAHLAVI_invlist,
	UNI_ININSCRIPTIONALPARTHIAN_invlist,
	UNI_INJAVANESE_invlist,
	UNI_INKAITHI_invlist,
	UNI_INKANNADA_invlist,
	UNI_INKATAKANA_invlist,
	UNI_INKHAROSHTHI_invlist,
	UNI_INKHITANSMALLSCRIPT_invlist,
	UNI_INKHMER_invlist,
	UNI_INKHOJKI_invlist,
	UNI_INKHUDAWADI_invlist,
	UNI_INLAO_invlist,
	UNI_INLEPCHA_invlist,
	UNI_INLIMBU_invlist,
	UNI_INLINEARA_invlist,
	UNI_INLISU_invlist,
	UNI_INLYCIAN_invlist,
	UNI_INLYDIAN_invlist,
	UNI_INMAHAJANI_invlist,
	UNI_INMAKASAR_invlist,
	UNI_INMALAYALAM_invlist,
	UNI_INMANDAIC_invlist,
	UNI_INMANICHAEAN_invlist,
	UNI_INMARCHEN_invlist,
	UNI_INMASARAMGONDI_invlist,
	UNI_INMEDEFAIDRIN_invlist,
	UNI_INMEETEIMAYEK_invlist,
	UNI_INMENDEKIKAKUI_invlist,
	UNI_INMEROITICCURSIVE_invlist,
	UNI_INMIAO_invlist,
	UNI_INMODI_invlist,
	UNI_INMONGOLIAN_invlist,
	UNI_INMRO_invlist,
	UNI_INMULTANI_invlist,
	UNI_INMYANMAR_invlist,
	UNI_INNABATAEAN_invlist,
	UNI_INNANDINAGARI_invlist,
	UNI_INNEWA_invlist,
	UNI_INNEWTAILUE_invlist,
	UNI_INNKO_invlist,
	UNI_INNUSHU_invlist,
	UNI_INNYIAKENGPUACHUEHMONG_invlist,
	UNI_INOGHAM_invlist,
	UNI_INOLDHUNGARIAN_invlist,
	UNI_INOLDITALIC_invlist,
	UNI_INOLDPERMIC_invlist,
	UNI_INOLDPERSIAN_invlist,
	UNI_INOLDSOGDIAN_invlist,
	UNI_INOLDTURKIC_invlist,
	UNI_INOLDUYGHUR_invlist,
	UNI_INORIYA_invlist,
	UNI_INOSAGE_invlist,
	UNI_INOSMANYA_invlist,
	UNI_INPAHAWHHMONG_invlist,
	UNI_INPAUCINHAU_invlist,
	UNI_INPC__BOTTOM_invlist,
	UNI_INPC__BOTTOMANDLEFT_invlist,
	UNI_INPC__BOTTOMANDRIGHT_invlist,
	UNI_INPC__LEFT_invlist,
	UNI_INPC__LEFTANDRIGHT_invlist,
	UNI_INPC__NA_invlist,
	UNI_INPC__OVERSTRUCK_invlist,
	UNI_INPC__RIGHT_invlist,
	UNI_INPC__TOP_invlist,
	UNI_INPC__TOPANDBOTTOM_invlist,
	UNI_INPC__TOPANDBOTTOMANDLEFT_invlist,
	UNI_INPC__TOPANDBOTTOMANDRIGHT_invlist,
	UNI_INPC__TOPANDLEFT_invlist,
	UNI_INPC__TOPANDLEFTANDRIGHT_invlist,
	UNI_INPC__TOPANDRIGHT_invlist,
	UNI_INPHAGSPA_invlist,
	UNI_INPHOENICIAN_invlist,
	UNI_INPSALTERPAHLAVI_invlist,
	UNI_INPUNCTUATION_invlist,
	UNI_INREJANG_invlist,
	UNI_INRUNIC_invlist,
	UNI_INSAMARITAN_invlist,
	UNI_INSAURASHTRA_invlist,
	UNI_INSC__AVAGRAHA_invlist,
	UNI_INSC__BINDU_invlist,
	UNI_INSC__BRAHMIJOININGNUMBER_invlist,
	UNI_INSC__CANTILLATIONMARK_invlist,
	UNI_INSC__CONSONANT_invlist,
	UNI_INSC__CONSONANTDEAD_invlist,
	UNI_INSC__CONSONANTFINAL_invlist,
	UNI_INSC__CONSONANTHEADLETTER_invlist,
	UNI_INSC__CONSONANTINITIALPOSTFIXED_invlist,
	UNI_INSC__CONSONANTKILLER_invlist,
	UNI_INSC__CONSONANTMEDIAL_invlist,
	UNI_INSC__CONSONANTPLACEHOLDER_invlist,
	UNI_INSC__CONSONANTPRECEDINGREPHA_invlist,
	UNI_INSC__CONSONANTPREFIXED_invlist,
	UNI_INSC__CONSONANTSUBJOINED_invlist,
	UNI_INSC__CONSONANTSUCCEEDINGREPHA_invlist,
	UNI_INSC__CONSONANTWITHSTACKER_invlist,
	UNI_INSC__GEMINATIONMARK_invlist,
	UNI_INSC__INVISIBLESTACKER_invlist,
	UNI_INSC__MODIFYINGLETTER_invlist,
	UNI_INSC__NONJOINER_invlist,
	UNI_INSC__NUKTA_invlist,
	UNI_INSC__NUMBER_invlist,
	UNI_INSC__NUMBERJOINER_invlist,
	UNI_INSC__OTHER_invlist,
	UNI_INSC__PUREKILLER_invlist,
	UNI_INSC__REGISTERSHIFTER_invlist,
	UNI_INSC__SYLLABLEMODIFIER_invlist,
	UNI_INSC__TONELETTER_invlist,
	UNI_INSC__TONEMARK_invlist,
	UNI_INSC__VIRAMA_invlist,
	UNI_INSC__VISARGA_invlist,
	UNI_INSC__VOWEL_invlist,
	UNI_INSC__VOWELDEPENDENT_invlist,
	UNI_INSC__VOWELINDEPENDENT_invlist,
	UNI_INSIDDHAM_invlist,
	UNI_INSINHALA_invlist,
	UNI_INSOGDIAN_invlist,
	UNI_INSORASOMPENG_invlist,
	UNI_INSOYOMBO_invlist,
	UNI_INSUNDANESE_invlist,
	UNI_INSYLOTINAGRI_invlist,
	UNI_INSYRIAC_invlist,
	UNI_INTAGALOG_invlist,
	UNI_INTAGBANWA_invlist,
	UNI_INTAILE_invlist,
	UNI_INTAITHAM_invlist,
	UNI_INTAIVIET_invlist,
	UNI_INTAKRI_invlist,
	UNI_INTAMIL_invlist,
	UNI_INTANGSA_invlist,
	UNI_INTANGUT_invlist,
	UNI_INTELUGU_invlist,
	UNI_INTHAANA_invlist,
	UNI_INTHAI_invlist,
	UNI_INTIBETAN_invlist,
	UNI_INTIFINAGH_invlist,
	UNI_INTIRHUTA_invlist,
	UNI_INTOTO_invlist,
	UNI_INUGARITIC_invlist,
	UNI_INVAI_invlist,
	UNI_INVITHKUQI_invlist,
	UNI_INVS_invlist,
	UNI_INWANCHO_invlist,
	UNI_INWARANGCITI_invlist,
	UNI_INYEZIDI_invlist,
	UNI_INZANABAZARSQUARE_invlist,
	UNI_IN__10_invlist,
	UNI_IN__11_invlist,
	UNI_IN__12_invlist,
	UNI_IN__12_DOT_1_invlist,
	UNI_IN__13_invlist,
	UNI_IN__14_invlist,
	UNI_IN__1_DOT_1_invlist,
	UNI_IN__2_invlist,
	UNI_IN__2_DOT_1_invlist,
	UNI_IN__3_invlist,
	UNI_IN__3_DOT_1_invlist,
	UNI_IN__3_DOT_2_invlist,
	UNI_IN__4_invlist,
	UNI_IN__4_DOT_1_invlist,
	UNI_IN__5_invlist,
	UNI_IN__5_DOT_1_invlist,
	UNI_IN__5_DOT_2_invlist,
	UNI_IN__6_invlist,
	UNI_IN__6_DOT_1_invlist,
	UNI_IN__6_DOT_2_invlist,
	UNI_IN__6_DOT_3_invlist,
	UNI_IN__7_invlist,
	UNI_IN__8_invlist,
	UNI_IN__9_invlist,
	UNI_IN__NA_invlist,
	UNI_IPAEXT_invlist,
	UNI_ITAL_invlist,
	UNI_JAMO_invlist,
	UNI_JAMOEXTA_invlist,
	UNI_JAMOEXTB_invlist,
	UNI_JAVA_invlist,
	UNI_JG__AFRICANFEH_invlist,
	UNI_JG__AFRICANNOON_invlist,
	UNI_JG__AFRICANQAF_invlist,
	UNI_JG__AIN_invlist,
	UNI_JG__ALAPH_invlist,
	UNI_JG__ALEF_invlist,
	UNI_JG__BEH_invlist,
	UNI_JG__BETH_invlist,
	UNI_JG__BURUSHASKIYEHBARREE_invlist,
	UNI_JG__DAL_invlist,
	UNI_JG__DALATHRISH_invlist,
	UNI_JG__E_invlist,
	UNI_JG__FARSIYEH_invlist,
	UNI_JG__FE_invlist,
	UNI_JG__FEH_invlist,
	UNI_JG__FINALSEMKATH_invlist,
	UNI_JG__GAF_invlist,
	UNI_JG__GAMAL_invlist,
	UNI_JG__HAH_invlist,
	UNI_JG__HAMZAONHEHGOAL_invlist,
	UNI_JG__HANIFIROHINGYAKINNAYA_invlist,
	UNI_JG__HANIFIROHINGYAPA_invlist,
	UNI_JG__HE_invlist,
	UNI_JG__HEH_invlist,
	UNI_JG__HEHGOAL_invlist,
	UNI_JG__HETH_invlist,
	UNI_JG__KAF_invlist,
	UNI_JG__KAPH_invlist,
	UNI_JG__KHAPH_invlist,
	UNI_JG__KNOTTEDHEH_invlist,
	UNI_JG__LAM_invlist,
	UNI_JG__LAMADH_invlist,
	UNI_JG__MALAYALAMBHA_invlist,
	UNI_JG__MALAYALAMJA_invlist,
	UNI_JG__MALAYALAMLLA_invlist,
	UNI_JG__MALAYALAMLLLA_invlist,
	UNI_JG__MALAYALAMNGA_invlist,
	UNI_JG__MALAYALAMNNA_invlist,
	UNI_JG__MALAYALAMNNNA_invlist,
	UNI_JG__MALAYALAMNYA_invlist,
	UNI_JG__MALAYALAMRA_invlist,
	UNI_JG__MALAYALAMSSA_invlist,
	UNI_JG__MALAYALAMTTA_invlist,
	UNI_JG__MANICHAEANALEPH_invlist,
	UNI_JG__MANICHAEANAYIN_invlist,
	UNI_JG__MANICHAEANBETH_invlist,
	UNI_JG__MANICHAEANDALETH_invlist,
	UNI_JG__MANICHAEANDHAMEDH_invlist,
	UNI_JG__MANICHAEANFIVE_invlist,
	UNI_JG__MANICHAEANGIMEL_invlist,
	UNI_JG__MANICHAEANHETH_invlist,
	UNI_JG__MANICHAEANHUNDRED_invlist,
	UNI_JG__MANICHAEANKAPH_invlist,
	UNI_JG__MANICHAEANLAMEDH_invlist,
	UNI_JG__MANICHAEANMEM_invlist,
	UNI_JG__MANICHAEANNUN_invlist,
	UNI_JG__MANICHAEANONE_invlist,
	UNI_JG__MANICHAEANPE_invlist,
	UNI_JG__MANICHAEANQOPH_invlist,
	UNI_JG__MANICHAEANRESH_invlist,
	UNI_JG__MANICHAEANSADHE_invlist,
	UNI_JG__MANICHAEANSAMEKH_invlist,
	UNI_JG__MANICHAEANTAW_invlist,
	UNI_JG__MANICHAEANTEN_invlist,
	UNI_JG__MANICHAEANTETH_invlist,
	UNI_JG__MANICHAEANTHAMEDH_invlist,
	UNI_JG__MANICHAEANTWENTY_invlist,
	UNI_JG__MANICHAEANWAW_invlist,
	UNI_JG__MANICHAEANYODH_invlist,
	UNI_JG__MANICHAEANZAYIN_invlist,
	UNI_JG__MEEM_invlist,
	UNI_JG__MIM_invlist,
	UNI_JG__NOJOININGGROUP_invlist,
	UNI_JG__NOON_invlist,
	UNI_JG__NUN_invlist,
	UNI_JG__NYA_invlist,
	UNI_JG__PE_invlist,
	UNI_JG__QAF_invlist,
	UNI_JG__QAPH_invlist,
	UNI_JG__REH_invlist,
	UNI_JG__REVERSEDPE_invlist,
	UNI_JG__ROHINGYAYEH_invlist,
	UNI_JG__SAD_invlist,
	UNI_JG__SADHE_invlist,
	UNI_JG__SEEN_invlist,
	UNI_JG__SEMKATH_invlist,
	UNI_JG__SHIN_invlist,
	UNI_JG__STRAIGHTWAW_invlist,
	UNI_JG__SWASHKAF_invlist,
	UNI_JG__SYRIACWAW_invlist,
	UNI_JG__TAH_invlist,
	UNI_JG__TAW_invlist,
	UNI_JG__TEHMARBUTA_invlist,
	UNI_JG__TETH_invlist,
	UNI_JG__THINYEH_invlist,
	UNI_JG__VERTICALTAIL_invlist,
	UNI_JG__WAW_invlist,
	UNI_JG__YEH_invlist,
	UNI_JG__YEHBARREE_invlist,
	UNI_JG__YEHWITHTAIL_invlist,
	UNI_JG__YUDH_invlist,
	UNI_JG__YUDHHE_invlist,
	UNI_JG__ZAIN_invlist,
	UNI_JG__ZHAIN_invlist,
	UNI_JOINC_invlist,
	UNI_JT__C_invlist,
	UNI_JT__D_invlist,
	UNI_JT__L_invlist,
	UNI_JT__R_invlist,
	UNI_JT__T_invlist,
	UNI_JT__U_invlist,
	UNI_KALI_invlist,
	UNI_KANA_invlist,
	UNI_KANAEXTA_invlist,
	UNI_KANAEXTB_invlist,
	UNI_KANASUP_invlist,
	UNI_KANBUN_invlist,
	UNI_KANGXI_invlist,
	UNI_KATAKANAEXT_invlist,
	UNI_KHAR_invlist,
	UNI_KHMERSYMBOLS_invlist,
	UNI_KHMR_invlist,
	UNI_KHOJ_invlist,
	UNI_KITS_invlist,
	UNI_KNDA_invlist,
	UNI_KTHI_invlist,
	UNI_L_invlist,
	UNI_LANA_invlist,
	UNI_LAO_invlist,
	UNI_LATIN1_invlist,
	UNI_LATINEXTA_invlist,
	UNI_LATINEXTADDITIONAL_invlist,
	UNI_LATINEXTB_invlist,
	UNI_LATINEXTC_invlist,
	UNI_LATINEXTD_invlist,
	UNI_LATINEXTE_invlist,
	UNI_LATINEXTF_invlist,
	UNI_LATINEXTG_invlist,
	UNI_LATN_invlist,
	UNI_LB__AI_invlist,
	UNI_LB__AL_invlist,
	UNI_LB__B2_invlist,
	UNI_LB__BA_invlist,
	UNI_LB__BB_invlist,
	UNI_LB__BK_invlist,
	UNI_LB__CB_invlist,
	UNI_LB__CJ_invlist,
	UNI_LB__CL_invlist,
	UNI_LB__CM_invlist,
	UNI_LB__CP_invlist,
	UNI_LB__CR_invlist,
	UNI_LB__EX_invlist,
	UNI_LB__GL_invlist,
	UNI_LB__H2_invlist,
	UNI_LB__H3_invlist,
	UNI_LB__HL_invlist,
	UNI_LB__HY_invlist,
	UNI_LB__ID_invlist,
	UNI_LB__IN_invlist,
	UNI_LB__IS_invlist,
	UNI_LB__LF_invlist,
	UNI_LB__NL_invlist,
	UNI_LB__NS_invlist,
	UNI_LB__NU_invlist,
	UNI_LB__OP_invlist,
	UNI_LB__PO_invlist,
	UNI_LB__PR_invlist,
	UNI_LB__QU_invlist,
	UNI_LB__SA_invlist,
	UNI_LB__SG_invlist,
	UNI_LB__SP_invlist,
	UNI_LB__SY_invlist,
	UNI_LB__WJ_invlist,
	UNI_LB__XX_invlist,
	UNI_LB__ZW_invlist,
	UNI_LB__ZWJ_invlist,
	UNI_LEPC_invlist,
	UNI_LETTERLIKESYMBOLS_invlist,
	UNI_LIMB_invlist,
	UNI_LINA_invlist,
	UNI_LINB_invlist,
	UNI_LINEARBIDEOGRAMS_invlist,
	UNI_LINEARBSYLLABARY_invlist,
	UNI_LISU_invlist,
	UNI_LISUSUP_invlist,
	UNI_LM_invlist,
	UNI_LO_invlist,
	UNI_LOE_invlist,
	UNI_LOWERCASELETTER_invlist,
	UNI_LOWSURROGATES_invlist,
	UNI_LYCI_invlist,
	UNI_LYDI_invlist,
	UNI_M_invlist,
	UNI_MAHJ_invlist,
	UNI_MAHJONG_invlist,
	UNI_MAKA_invlist,
	UNI_MAND_invlist,
	UNI_MANI_invlist,
	UNI_MARC_invlist,
	UNI_MATH_invlist,
	UNI_MATHALPHANUM_invlist,
	UNI_MATHOPERATORS_invlist,
	UNI_MAYANNUMERALS_invlist,
	UNI_MC_invlist,
	UNI_ME_invlist,
	UNI_MEDF_invlist,
	UNI_MEETEIMAYEKEXT_invlist,
	UNI_MEND_invlist,
	UNI_MERC_invlist,
	UNI_MERO_invlist,
	UNI_MIAO_invlist,
	UNI_MISCARROWS_invlist,
	UNI_MISCMATHSYMBOLSA_invlist,
	UNI_MISCMATHSYMBOLSB_invlist,
	UNI_MISCPICTOGRAPHS_invlist,
	UNI_MISCSYMBOLS_invlist,
	UNI_MISCTECHNICAL_invlist,
	UNI_MLYM_invlist,
	UNI_MN_invlist,
	UNI_MODI_invlist,
	UNI_MODIFIERLETTERS_invlist,
	UNI_MODIFIERTONELETTERS_invlist,
	UNI_MONG_invlist,
	UNI_MONGOLIANSUP_invlist,
	UNI_MRO_invlist,
	UNI_MTEI_invlist,
	UNI_MULT_invlist,
	UNI_MUSIC_invlist,
	UNI_MYANMAREXTA_invlist,
	UNI_MYANMAREXTB_invlist,
	UNI_MYMR_invlist,
	UNI_N_invlist,
	UNI_NAND_invlist,
	UNI_NARB_invlist,
	UNI_NB_invlist,
	UNI_NBAT_invlist,
	UNI_NEWA_invlist,
	UNI_NFCQC__M_invlist,
	UNI_NFCQC__Y_invlist,
	UNI_NFDQC__Y_invlist,
	UNI_NFKCQC__N_invlist,
	UNI_NFKCQC__Y_invlist,
	UNI_NFKDQC__N_invlist,
	UNI_NKO_invlist,
	UNI_NL_invlist,
	UNI_NO_invlist,
	UNI_NSHU_invlist,
	UNI_NT__DI_invlist,
	UNI_NT__NU_invlist,
	UNI_NUMBERFORMS_invlist,
	UNI_NV__0_invlist,
	UNI_NV__1_invlist,
	UNI_NV__10_invlist,
	UNI_NV__100_invlist,
	UNI_NV__1000_invlist,
	UNI_NV__10000_invlist,
	UNI_NV__100000_invlist,
	UNI_NV__1000000_invlist,
	UNI_NV__10000000_invlist,
	UNI_NV__100000000_invlist,
	UNI_NV__10000000000_invlist,
	UNI_NV__1000000000000_invlist,
	UNI_NV__11_invlist,
	UNI_NV__11_SLASH_12_invlist,
	UNI_NV__11_SLASH_2_invlist,
	UNI_NV__12_invlist,
	UNI_NV__13_invlist,
	UNI_NV__13_SLASH_2_invlist,
	UNI_NV__14_invlist,
	UNI_NV__15_invlist,
	UNI_NV__15_SLASH_2_invlist,
	UNI_NV__16_invlist,
	UNI_NV__17_invlist,
	UNI_NV__17_SLASH_2_invlist,
	UNI_NV__18_invlist,
	UNI_NV__19_invlist,
	UNI_NV__1_SLASH_10_invlist,
	UNI_NV__1_SLASH_12_invlist,
	UNI_NV__1_SLASH_16_invlist,
	UNI_NV__1_SLASH_160_invlist,
	UNI_NV__1_SLASH_2_invlist,
	UNI_NV__1_SLASH_20_invlist,
	UNI_NV__1_SLASH_3_invlist,
	UNI_NV__1_SLASH_32_invlist,
	UNI_NV__1_SLASH_320_invlist,
	UNI_NV__1_SLASH_4_invlist,
	UNI_NV__1_SLASH_40_invlist,
	UNI_NV__1_SLASH_5_invlist,
	UNI_NV__1_SLASH_6_invlist,
	UNI_NV__1_SLASH_64_invlist,
	UNI_NV__1_SLASH_7_invlist,
	UNI_NV__1_SLASH_8_invlist,
	UNI_NV__1_SLASH_80_invlist,
	UNI_NV__1_SLASH_9_invlist,
	UNI_NV__2_invlist,
	UNI_NV__20_invlist,
	UNI_NV__200_invlist,
	UNI_NV__2000_invlist,
	UNI_NV__20000_invlist,
	UNI_NV__200000_invlist,
	UNI_NV__20000000_invlist,
	UNI_NV__21_invlist,
	UNI_NV__216000_invlist,
	UNI_NV__22_invlist,
	UNI_NV__23_invlist,
	UNI_NV__24_invlist,
	UNI_NV__25_invlist,
	UNI_NV__26_invlist,
	UNI_NV__27_invlist,
	UNI_NV__28_invlist,
	UNI_NV__29_invlist,
	UNI_NV__2_SLASH_3_invlist,
	UNI_NV__2_SLASH_5_invlist,
	UNI_NV__3_invlist,
	UNI_NV__30_invlist,
	UNI_NV__300_invlist,
	UNI_NV__3000_invlist,
	UNI_NV__30000_invlist,
	UNI_NV__300000_invlist,
	UNI_NV__31_invlist,
	UNI_NV__32_invlist,
	UNI_NV__33_invlist,
	UNI_NV__34_invlist,
	UNI_NV__35_invlist,
	UNI_NV__36_invlist,
	UNI_NV__37_invlist,
	UNI_NV__38_invlist,
	UNI_NV__39_invlist,
	UNI_NV__3_SLASH_16_invlist,
	UNI_NV__3_SLASH_2_invlist,
	UNI_NV__3_SLASH_20_invlist,
	UNI_NV__3_SLASH_4_invlist,
	UNI_NV__3_SLASH_5_invlist,
	UNI_NV__3_SLASH_64_invlist,
	UNI_NV__3_SLASH_8_invlist,
	UNI_NV__3_SLASH_80_invlist,
	UNI_NV__4_invlist,
	UNI_NV__40_invlist,
	UNI_NV__400_invlist,
	UNI_NV__4000_invlist,
	UNI_NV__40000_invlist,
	UNI_NV__400000_invlist,
	UNI_NV__41_invlist,
	UNI_NV__42_invlist,
	UNI_NV__43_invlist,
	UNI_NV__432000_invlist,
	UNI_NV__44_invlist,
	UNI_NV__45_invlist,
	UNI_NV__46_invlist,
	UNI_NV__47_invlist,
	UNI_NV__48_invlist,
	UNI_NV__49_invlist,
	UNI_NV__4_SLASH_5_invlist,
	UNI_NV__5_invlist,
	UNI_NV__50_invlist,
	UNI_NV__500_invlist,
	UNI_NV__5000_invlist,
	UNI_NV__50000_invlist,
	UNI_NV__500000_invlist,
	UNI_NV__5_SLASH_12_invlist,
	UNI_NV__5_SLASH_2_invlist,
	UNI_NV__5_SLASH_6_invlist,
	UNI_NV__5_SLASH_8_invlist,
	UNI_NV__6_invlist,
	UNI_NV__60_invlist,
	UNI_NV__600_invlist,
	UNI_NV__6000_invlist,
	UNI_NV__60000_invlist,
	UNI_NV__600000_invlist,
	UNI_NV__7_invlist,
	UNI_NV__70_invlist,
	UNI_NV__700_invlist,
	UNI_NV__7000_invlist,
	UNI_NV__70000_invlist,
	UNI_NV__700000_invlist,
	UNI_NV__7_SLASH_12_invlist,
	UNI_NV__7_SLASH_2_invlist,
	UNI_NV__7_SLASH_8_invlist,
	UNI_NV__8_invlist,
	UNI_NV__80_invlist,
	UNI_NV__800_invlist,
	UNI_NV__8000_invlist,
	UNI_NV__80000_invlist,
	UNI_NV__800000_invlist,
	UNI_NV__9_invlist,
	UNI_NV__90_invlist,
	UNI_NV__900_invlist,
	UNI_NV__9000_invlist,
	UNI_NV__90000_invlist,
	UNI_NV__900000_invlist,
	UNI_NV__9_SLASH_2_invlist,
	UNI_NV__NAN_invlist,
	UNI_NV___MINUS_1_SLASH_2_invlist,
	UNI_OCR_invlist,
	UNI_OGAM_invlist,
	UNI_OLCK_invlist,
	UNI_ORKH_invlist,
	UNI_ORNAMENTALDINGBATS_invlist,
	UNI_ORYA_invlist,
	UNI_OSGE_invlist,
	UNI_OSMA_invlist,
	UNI_OTTOMANSIYAQNUMBERS_invlist,
	UNI_OUGR_invlist,
	UNI_P_invlist,
	UNI_PALM_invlist,
	UNI_PATSYN_invlist,
	UNI_PAUC_invlist,
	UNI_PC_invlist,
	UNI_PCM_invlist,
	UNI_PD_invlist,
	UNI_PE_invlist,
	UNI_PERM_invlist,
	UNI_PF_invlist,
	UNI_PHAG_invlist,
	UNI_PHAISTOS_invlist,
	UNI_PHLI_invlist,
	UNI_PHLP_invlist,
	UNI_PHNX_invlist,
	UNI_PHONETICEXT_invlist,
	UNI_PHONETICEXTSUP_invlist,
	UNI_PI_invlist,
	UNI_PLAYINGCARDS_invlist,
	UNI_PO_invlist,
	UNI_POSIXALNUM_invlist,
	UNI_POSIXALPHA_invlist,
	UNI_POSIXBLANK_invlist,
	UNI_POSIXCNTRL_invlist,
	UNI_POSIXDIGIT_invlist,
	UNI_POSIXGRAPH_invlist,
	UNI_POSIXLOWER_invlist,
	UNI_POSIXPRINT_invlist,
	UNI_POSIXPUNCT_invlist,
	UNI_POSIXSPACE_invlist,
	UNI_POSIXUPPER_invlist,
	UNI_POSIXWORD_invlist,
	UNI_POSIXXDIGIT_invlist,
	UNI_PRTI_invlist,
	UNI_PS_invlist,
	UNI_PUA_invlist,
	UNI_QAAI_invlist,
	UNI_QMARK_invlist,
	UNI_RADICAL_invlist,
	UNI_RI_invlist,
	UNI_RJNG_invlist,
	UNI_ROHG_invlist,
	UNI_RUMI_invlist,
	UNI_RUNR_invlist,
	UNI_S_invlist,
	UNI_SAMR_invlist,
	UNI_SARB_invlist,
	UNI_SAUR_invlist,
	UNI_SB__AT_invlist,
	UNI_SB__CL_invlist,
	UNI_SB__EX_invlist,
	UNI_SB__FO_invlist,
	UNI_SB__LE_invlist,
	UNI_SB__LO_invlist,
	UNI_SB__NU_invlist,
	UNI_SB__SC_invlist,
	UNI_SB__SE_invlist,
	UNI_SB__SP_invlist,
	UNI_SB__ST_invlist,
	UNI_SB__UP_invlist,
	UNI_SB__XX_invlist,
	UNI_SC_invlist,
	UNI_SC__ADLM_invlist,
	UNI_SC__ARAB_invlist,
	UNI_SC__BENG_invlist,
	UNI_SC__BOPO_invlist,
	UNI_SC__BUGI_invlist,
	UNI_SC__BUHD_invlist,
	UNI_SC__CAKM_invlist,
	UNI_SC__COPT_invlist,
	UNI_SC__CPMN_invlist,
	UNI_SC__CPRT_invlist,
	UNI_SC__CYRL_invlist,
	UNI_SC__DEVA_invlist,
	UNI_SC__DOGR_invlist,
	UNI_SC__DUPL_invlist,
	UNI_SC__GEOR_invlist,
	UNI_SC__GLAG_invlist,
	UNI_SC__GONG_invlist,
	UNI_SC__GONM_invlist,
	UNI_SC__GRAN_invlist,
	UNI_SC__GREK_invlist,
	UNI_SC__GUJR_invlist,
	UNI_SC__GURU_invlist,
	UNI_SC__HAN_invlist,
	UNI_SC__HANG_invlist,
	UNI_SC__HANO_invlist,
	UNI_SC__HIRA_invlist,
	UNI_SC__JAVA_invlist,
	UNI_SC__KALI_invlist,
	UNI_SC__KANA_invlist,
	UNI_SC__KHOJ_invlist,
	UNI_SC__KNDA_invlist,
	UNI_SC__KTHI_invlist,
	UNI_SC__LATN_invlist,
	UNI_SC__LIMB_invlist,
	UNI_SC__LINA_invlist,
	UNI_SC__LINB_invlist,
	UNI_SC__MAHJ_invlist,
	UNI_SC__MAND_invlist,
	UNI_SC__MANI_invlist,
	UNI_SC__MLYM_invlist,
	UNI_SC__MODI_invlist,
	UNI_SC__MONG_invlist,
	UNI_SC__MULT_invlist,
	UNI_SC__MYMR_invlist,
	UNI_SC__NAND_invlist,
	UNI_SC__NKO_invlist,
	UNI_SC__ORYA_invlist,
	UNI_SC__OUGR_invlist,
	UNI_SC__PERM_invlist,
	UNI_SC__PHAG_invlist,
	UNI_SC__PHLP_invlist,
	UNI_SC__QAAI_invlist,
	UNI_SC__ROHG_invlist,
	UNI_SC__SHRD_invlist,
	UNI_SC__SIND_invlist,
	UNI_SC__SINH_invlist,
	UNI_SC__SOGD_invlist,
	UNI_SC__SYLO_invlist,
	UNI_SC__SYRC_invlist,
	UNI_SC__TAGB_invlist,
	UNI_SC__TAKR_invlist,
	UNI_SC__TALE_invlist,
	UNI_SC__TAML_invlist,
	UNI_SC__TELU_invlist,
	UNI_SC__TGLG_invlist,
	UNI_SC__THAA_invlist,
	UNI_SC__TIRH_invlist,
	UNI_SC__YEZI_invlist,
	UNI_SC__YI_invlist,
	UNI_SC__ZYYY_invlist,
	UNI_SD_invlist,
	UNI_SGNW_invlist,
	UNI_SHAW_invlist,
	UNI_SHORTHANDFORMATCONTROLS_invlist,
	UNI_SHRD_invlist,
	UNI_SIDD_invlist,
	UNI_SIND_invlist,
	UNI_SINH_invlist,
	UNI_SINHALAARCHAICNUMBERS_invlist,
	UNI_SK_invlist,
	UNI_SM_invlist,
	UNI_SMALLFORMS_invlist,
	UNI_SMALLKANAEXT_invlist,
	UNI_SO_invlist,
	UNI_SOGD_invlist,
	UNI_SOGO_invlist,
	UNI_SORA_invlist,
	UNI_SOYO_invlist,
	UNI_SPECIALS_invlist,
	UNI_STERM_invlist,
	UNI_SUND_invlist,
	UNI_SUNDANESESUP_invlist,
	UNI_SUPARROWSA_invlist,
	UNI_SUPARROWSB_invlist,
	UNI_SUPARROWSC_invlist,
	UNI_SUPERANDSUB_invlist,
	UNI_SUPMATHOPERATORS_invlist,
	UNI_SUPPUAA_invlist,
	UNI_SUPPUAB_invlist,
	UNI_SUPPUNCTUATION_invlist,
	UNI_SUPSYMBOLSANDPICTOGRAPHS_invlist,
	UNI_SUTTONSIGNWRITING_invlist,
	UNI_SYLO_invlist,
	UNI_SYMBOLSANDPICTOGRAPHSEXTA_invlist,
	UNI_SYMBOLSFORLEGACYCOMPUTING_invlist,
	UNI_SYRC_invlist,
	UNI_SYRIACSUP_invlist,
	UNI_TAGB_invlist,
	UNI_TAGS_invlist,
	UNI_TAIXUANJING_invlist,
	UNI_TAKR_invlist,
	UNI_TALE_invlist,
	UNI_TALU_invlist,
	UNI_TAMILSUP_invlist,
	UNI_TAML_invlist,
	UNI_TANG_invlist,
	UNI_TANGUTCOMPONENTS_invlist,
	UNI_TANGUTSUP_invlist,
	UNI_TAVT_invlist,
	UNI_TELU_invlist,
	UNI_TERM_invlist,
	UNI_TFNG_invlist,
	UNI_TGLG_invlist,
	UNI_THAA_invlist,
	UNI_THAI_invlist,
	UNI_TIBT_invlist,
	UNI_TIRH_invlist,
	UNI_TITLE_invlist,
	UNI_TNSA_invlist,
	UNI_TOTO_invlist,
	UNI_TRANSPORTANDMAP_invlist,
	UNI_UCAS_invlist,
	UNI_UCASEXT_invlist,
	UNI_UCASEXTA_invlist,
	UNI_UGAR_invlist,
	UNI_UIDEO_invlist,
	UNI_UPPERCASELETTER_invlist,
	UNI_VAI_invlist,
	UNI_VEDICEXT_invlist,
	UNI_VERTICALFORMS_invlist,
	UNI_VERTSPACE_invlist,
	UNI_VITH_invlist,
	UNI_VO__R_invlist,
	UNI_VO__TR_invlist,
	UNI_VO__TU_invlist,
	UNI_VO__U_invlist,
	UNI_VS_invlist,
	UNI_VSSUP_invlist,
	UNI_WARA_invlist,
	UNI_WB__DQ_invlist,
	UNI_WB__EB_invlist,
	UNI_WB__EX_invlist,
	UNI_WB__EXTEND_invlist,
	UNI_WB__FO_invlist,
	UNI_WB__KA_invlist,
	UNI_WB__LE_invlist,
	UNI_WB__MB_invlist,
	UNI_WB__ML_invlist,
	UNI_WB__MN_invlist,
	UNI_WB__NL_invlist,
	UNI_WB__NU_invlist,
	UNI_WB__SQ_invlist,
	UNI_WB__WSEGSPACE_invlist,
	UNI_WB__XX_invlist,
	UNI_WCHO_invlist,
	UNI_XIDC_invlist,
	UNI_XIDS_invlist,
	UNI_XPEO_invlist,
	UNI_XPOSIXALNUM_invlist,
	UNI_XPOSIXALPHA_invlist,
	UNI_XPOSIXBLANK_invlist,
	UNI_XPOSIXCNTRL_invlist,
	UNI_XPOSIXDIGIT_invlist,
	UNI_XPOSIXGRAPH_invlist,
	UNI_XPOSIXLOWER_invlist,
	UNI_XPOSIXPRINT_invlist,
	UNI_XPOSIXPUNCT_invlist,
	UNI_XPOSIXSPACE_invlist,
	UNI_XPOSIXUPPER_invlist,
	UNI_XPOSIXWORD_invlist,
	UNI_XPOSIXXDIGIT_invlist,
	UNI_XSUX_invlist,
	UNI_YEZI_invlist,
	UNI_YI_invlist,
	UNI_YIJING_invlist,
	UNI_YIRADICALS_invlist,
	UNI_YISYLLABLES_invlist,
	UNI_Z_invlist,
	UNI_ZANB_invlist,
	UNI_ZL_invlist,
	UNI_ZNAMENNYMUSIC_invlist,
	UNI_ZP_invlist,
	UNI_ZS_invlist,
	UNI_ZYYY_invlist,
	UNI_ZZZZ_invlist,
	UNI__PERL_ANY_FOLDS_invlist,
	UNI__PERL_CHARNAME_BEGIN_invlist,
	UNI__PERL_CHARNAME_CONTINUE_invlist,
	UNI__PERL_FOLDS_TO_MULTI_CHAR_invlist,
	UNI__PERL_IDCONT_invlist,
	UNI__PERL_IDSTART_invlist,
	UNI__PERL_IS_IN_MULTI_CHAR_FOLD_invlist,
	UNI__PERL_NCHAR_invlist,
	UNI__PERL_PATWS_invlist,
	UNI__PERL_PROBLEMATIC_LOCALE_FOLDEDS_START_invlist,
	UNI__PERL_PROBLEMATIC_LOCALE_FOLDS_invlist,
	UNI__PERL_QUOTEMETA_invlist,
	UNI__PERL_SURROGATE_invlist
};

#endif	/* (defined(PERL_IN_REGCOMP_C) && ! defined(PERL_IN_XSUB_RE)) */

#if defined(PERL_IN_REGCOMP_C)


/* Synonyms for perl properties */
#define UNI_AHEX   UNI_POSIXXDIGIT
#define UNI_ALNUM   UNI_XPOSIXALNUM
#define UNI_ALPHA   UNI_XPOSIXALPHA
#define UNI_ALPHABETIC   UNI_XPOSIXALPHA
#define UNI_ASCIIHEXDIGIT   UNI_POSIXXDIGIT
#define UNI_BASICLATIN   UNI_ASCII
#define UNI_BLANK   UNI_XPOSIXBLANK
#define UNI_CC   UNI_XPOSIXCNTRL
#define UNI_CNTRL   UNI_XPOSIXCNTRL
#define UNI_CONTROL   UNI_XPOSIXCNTRL
#define UNI_DECIMALNUMBER   UNI_XPOSIXDIGIT
#define UNI_DIGIT   UNI_XPOSIXDIGIT
#define UNI_GRAPH   UNI_XPOSIXGRAPH
#define UNI_HEX   UNI_XPOSIXXDIGIT
#define UNI_HEXDIGIT   UNI_XPOSIXXDIGIT
#define UNI_HORIZSPACE   UNI_XPOSIXBLANK
#define UNI_LC   UNI_CASEDLETTER
#define UNI_LL   UNI_LOWERCASELETTER
#define UNI_LOWER   UNI_XPOSIXLOWER
#define UNI_LOWERCASE   UNI_XPOSIXLOWER
#define UNI_LT   UNI_TITLE
#define UNI_LU   UNI_UPPERCASELETTER
#define UNI_L_   UNI_CASEDLETTER
#define UNI_L_AMP_   UNI_CASEDLETTER
#define UNI_ND   UNI_XPOSIXDIGIT
#define UNI_PERLSPACE   UNI_POSIXSPACE
#define UNI_PERLWORD   UNI_POSIXWORD
#define UNI_PRINT   UNI_XPOSIXPRINT
#define UNI_SPACE   UNI_XPOSIXSPACE
#define UNI_SPACEPERL   UNI_XPOSIXSPACE
#define UNI_TITLECASE   UNI_TITLE
#define UNI_TITLECASELETTER   UNI_TITLE
#define UNI_UPPER   UNI_XPOSIXUPPER
#define UNI_UPPERCASE   UNI_XPOSIXUPPER
#define UNI_WHITESPACE   UNI_XPOSIXSPACE
#define UNI_WORD   UNI_XPOSIXWORD
#define UNI_WSPACE   UNI_XPOSIXSPACE
#define UNI_XDIGIT   UNI_XPOSIXXDIGIT
#define UNI_XPERLSPACE   UNI_XPOSIXSPACE


#endif	/* defined(PERL_IN_REGCOMP_C) */

#if (defined(PERL_IN_REGCOMP_C) && ! defined(PERL_IN_XSUB_RE))

static const char * const UNI_age_values[] = {
	"1.1",
	"2.0",
	"2.1",
	"3.0",
	"3.1",
	"3.2",
	"4.0",
	"4.1",
	"5.0",
	"5.1",
	"5.2",
	"6.0",
	"6.1",
	"6.2",
	"6.3",
	"7.0",
	"8.0",
	"9.0",
	"10.0",
	"11.0",
	"12.0",
	"12.1",
	"13.0",
	"14.0",
	"NA",
	"na",
	"Unassigned",
	"unassigned",
	"V10_0",
	"V11_0",
	"V12_0",
	"V12_1",
	"V13_0",
	"V14_0",
	"V1_1",
	"V2_0",
	"V2_1",
	"V3_0",
	"V3_1",
	"V3_2",
	"V4_0",
	"V4_1",
	"V5_0",
	"V5_1",
	"V5_2",
	"V6_0",
	"V6_1",
	"V6_2",
	"V6_3",
	"V7_0",
	"V8_0",
	"V9_0",
	"v100",
	"v11",
	"v110",
	"v120",
	"v121",
	"v130",
	"v140",
	"v20",
	"v21",
	"v30",
	"v31",
	"v32",
	"v40",
	"v41",
	"v50",
	"v51",
	"v52",
	"v60",
	"v61",
	"v62",
	"v63",
	"v70",
	"v80",
	"v90",
	NULL
};

static const char * const UNI_ahex_values[] = {
	"F",
	"f",
	"False",
	"false",
	"N",
	"n",
	"No",
	"no",
	"T",
	"t",
	"True",
	"true",
	"Y",
	"y",
	"Yes",
	"yes",
	NULL
};

static const char * const UNI_bc_values[] = {
	"AL",
	"al",
	"AN",
	"an",
	"Arabic_Letter",
	"arabicletter",
	"Arabic_Number",
	"arabicnumber",
	"B",
	"b",
	"BN",
	"bn",
	"Boundary_Neutral",
	"boundaryneutral",
	"Common_Separator",
	"commonseparator",
	"CS",
	"cs",
	"EN",
	"en",
	"ES",
	"es",
	"ET",
	"et",
	"European_Number",
	"europeannumber",
	"European_Separator",
	"europeanseparator",
	"European_Terminator",
	"europeanterminator",
	"First_Strong_Isolate",
	"firststrongisolate",
	"FSI",
	"fsi",
	"L",
	"l",
	"Left_To_Right",
	"lefttoright",
	"Left_To_Right_Embedding",
	"lefttorightembedding",
	"Left_To_Right_Isolate",
	"lefttorightisolate",
	"Left_To_Right_Override",
	"lefttorightoverride",
	"LRE",
	"lre",
	"LRI",
	"lri",
	"LRO",
	"lro",
	"Nonspacing_Mark",
	"nonspacingmark",
	"NSM",
	"nsm",
	"ON",
	"on",
	"Other_Neutral",
	"otherneutral",
	"Paragraph_Separator",
	"paragraphseparator",
	"PDF",
	"pdf",
	"PDI",
	"pdi",
	"Pop_Directional_Format",
	"popdirectionalformat",
	"Pop_Directional_Isolate",
	"popdirectionalisolate",
	"R",
	"r",
	"Right_To_Left",
	"righttoleft",
	"Right_To_Left_Embedding",
	"righttoleftembedding",
	"Right_To_Left_Isolate",
	"righttoleftisolate",
	"Right_To_Left_Override",
	"righttoleftoverride",
	"RLE",
	"rle",
	"RLI",
	"rli",
	"RLO",
	"rlo",
	"S",
	"s",
	"Segment_Separator",
	"segmentseparator",
	"White_Space",
	"whitespace",
	"WS",
	"ws",
	NULL
};

static const char * const UNI_blk_values[] = {
	"Adlam",
	"adlam",
	"Aegean Numbers",
	"Aegean_Numbers",
	"aegeannumbers",
	"Ahom",
	"ahom",
	"Alchemical",
	"alchemical",
	"Alchemical Symbols",
	"Alchemical_Symbols",
	"alchemicalsymbols",
	"Alphabetic_PF",
	"alphabeticpf",
	"Alphabetic Presentation Forms",
	"Alphabetic_Presentation_Forms",
	"alphabeticpresentationforms",
	"Anatolian Hieroglyphs",
	"Anatolian_Hieroglyphs",
	"anatolianhieroglyphs",
	"Ancient_Greek_Music",
	"ancientgreekmusic",
	"Ancient Greek Musical Notation",
	"Ancient_Greek_Musical_Notation",
	"ancientgreekmusicalnotation",
	"Ancient Greek Numbers",
	"Ancient_Greek_Numbers",
	"ancientgreeknumbers",
	"Ancient Symbols",
	"Ancient_Symbols",
	"ancientsymbols",
	"Arabic",
	"arabic",
	"Arabic_Ext_A",
	"arabicexta",
	"Arabic_Ext_B",
	"arabicextb",
	"Arabic Extended-A",
	"Arabic_Extended_A",
	"arabicextendeda",
	"Arabic Extended-B",
	"Arabic_Extended_B",
	"arabicextendedb",
	"Arabic_Math",
	"arabicmath",
	"Arabic Mathematical Alphabetic Symbols",
	"Arabic_Mathematical_Alphabetic_Symbols",
	"arabicmathematicalalphabeticsymbols",
	"Arabic_PF_A",
	"arabicpfa",
	"Arabic_PF_B",
	"arabicpfb",
	"Arabic Presentation Forms-A",
	"Arabic_Presentation_Forms_A",
	"arabicpresentationformsa",
	"Arabic Presentation Forms-B",
	"Arabic_Presentation_Forms_B",
	"arabicpresentationformsb",
	"Arabic_Sup",
	"arabicsup",
	"Arabic Supplement",
	"Arabic_Supplement",
	"arabicsupplement",
	"Armenian",
	"armenian",
	"Arrows",
	"arrows",
	"ASCII",
	"ascii",
	"Avestan",
	"avestan",
	"Balinese",
	"balinese",
	"Bamum",
	"bamum",
	"Bamum_Sup",
	"bamumsup",
	"Bamum Supplement",
	"Bamum_Supplement",
	"bamumsupplement",
	"Basic Latin",
	"Basic_Latin",
	"basiclatin",
	"Bassa Vah",
	"Bassa_Vah",
	"bassavah",
	"Batak",
	"batak",
	"Bengali",
	"bengali",
	"Bhaiksuki",
	"bhaiksuki",
	"Block Elements",
	"Block_Elements",
	"blockelements",
	"Bopomofo",
	"bopomofo",
	"Bopomofo_Ext",
	"bopomofoext",
	"Bopomofo Extended",
	"Bopomofo_Extended",
	"bopomofoextended",
	"Box Drawing",
	"Box_Drawing",
	"boxdrawing",
	"Brahmi",
	"brahmi",
	"Braille",
	"braille",
	"Braille Patterns",
	"Braille_Patterns",
	"braillepatterns",
	"Buginese",
	"buginese",
	"Buhid",
	"buhid",
	"Byzantine_Music",
	"byzantinemusic",
	"Byzantine Musical Symbols",
	"Byzantine_Musical_Symbols",
	"byzantinemusicalsymbols",
	"Canadian_Syllabics",
	"canadiansyllabics",
	"Carian",
	"carian",
	"Caucasian Albanian",
	"Caucasian_Albanian",
	"caucasianalbanian",
	"Chakma",
	"chakma",
	"Cham",
	"cham",
	"Cherokee",
	"cherokee",
	"Cherokee_Sup",
	"cherokeesup",
	"Cherokee Supplement",
	"Cherokee_Supplement",
	"cherokeesupplement",
	"Chess Symbols",
	"Chess_Symbols",
	"chesssymbols",
	"Chorasmian",
	"chorasmian",
	"CJK",
	"cjk",
	"CJK_Compat",
	"cjkcompat",
	"CJK_Compat_Forms",
	"cjkcompatforms",
	"CJK Compatibility",
	"CJK_Compatibility",
	"cjkcompatibility",
	"CJK Compatibility Forms",
	"CJK_Compatibility_Forms",
	"cjkcompatibilityforms",
	"CJK Compatibility Ideographs",
	"CJK_Compatibility_Ideographs",
	"cjkcompatibilityideographs",
	"CJK Compatibility Ideographs Supplement",
	"CJK_Compatibility_Ideographs_Supplement",
	"cjkcompatibilityideographssupplement",
	"CJK_Compat_Ideographs",
	"cjkcompatideographs",
	"CJK_Compat_Ideographs_Sup",
	"cjkcompatideographssup",
	"CJK_Ext_A",
	"cjkexta",
	"CJK_Ext_B",
	"cjkextb",
	"CJK_Ext_C",
	"cjkextc",
	"CJK_Ext_D",
	"cjkextd",
	"CJK_Ext_E",
	"cjkexte",
	"CJK_Ext_F",
	"cjkextf",
	"CJK_Ext_G",
	"cjkextg",
	"CJK_Radicals_Sup",
	"cjkradicalssup",
	"CJK Radicals Supplement",
	"CJK_Radicals_Supplement",
	"cjkradicalssupplement",
	"CJK Strokes",
	"CJK_Strokes",
	"cjkstrokes",
	"CJK_Symbols",
	"cjksymbols",
	"CJK Symbols and Punctuation",
	"CJK_Symbols_And_Punctuation",
	"cjksymbolsandpunctuation",
	"CJK Unified Ideographs",
	"CJK_Unified_Ideographs",
	"cjkunifiedideographs",
	"CJK Unified Ideographs Extension A",
	"CJK_Unified_Ideographs_Extension_A",
	"cjkunifiedideographsextensiona",
	"CJK Unified Ideographs Extension B",
	"CJK_Unified_Ideographs_Extension_B",
	"cjkunifiedideographsextensionb",
	"CJK Unified Ideographs Extension C",
	"CJK_Unified_Ideographs_Extension_C",
	"cjkunifiedideographsextensionc",
	"CJK Unified Ideographs Extension D",
	"CJK_Unified_Ideographs_Extension_D",
	"cjkunifiedideographsextensiond",
	"CJK Unified Ideographs Extension E",
	"CJK_Unified_Ideographs_Extension_E",
	"cjkunifiedideographsextensione",
	"CJK Unified Ideographs Extension F",
	"CJK_Unified_Ideographs_Extension_F",
	"cjkunifiedideographsextensionf",
	"CJK Unified Ideographs Extension G",
	"CJK_Unified_Ideographs_Extension_G",
	"cjkunifiedideographsextensiong",
	"Combining Diacritical Marks",
	"Combining_Diacritical_Marks",
	"combiningdiacriticalmarks",
	"Combining Diacritical Marks Extended",
	"Combining_Diacritical_Marks_Extended",
	"combiningdiacriticalmarksextended",
	"Combining Diacritical Marks for Symbols",
	"Combining_Diacritical_Marks_For_Symbols",
	"combiningdiacriticalmarksforsymbols",
	"Combining Diacritical Marks Supplement",
	"Combining_Diacritical_Marks_Supplement",
	"combiningdiacriticalmarkssupplement",
	"Combining Half Marks",
	"Combining_Half_Marks",
	"combininghalfmarks",
	"Combining_Marks_For_Symbols",
	"combiningmarksforsymbols",
	"Common Indic Number Forms",
	"Common_Indic_Number_Forms",
	"commonindicnumberforms",
	"Compat_Jamo",
	"compatjamo",
	"Control Pictures",
	"Control_Pictures",
	"controlpictures",
	"Coptic",
	"coptic",
	"Coptic Epact Numbers",
	"Coptic_Epact_Numbers",
	"copticepactnumbers",
	"Counting_Rod",
	"countingrod",
	"Counting Rod Numerals",
	"Counting_Rod_Numerals",
	"countingrodnumerals",
	"Cuneiform",
	"cuneiform",
	"Cuneiform_Numbers",
	"cuneiformnumbers",
	"Cuneiform Numbers and Punctuation",
	"Cuneiform_Numbers_And_Punctuation",
	"cuneiformnumbersandpunctuation",
	"Currency Symbols",
	"Currency_Symbols",
	"currencysymbols",
	"Cypriot Syllabary",
	"Cypriot_Syllabary",
	"cypriotsyllabary",
	"Cypro-Minoan",
	"Cypro_Minoan",
	"cyprominoan",
	"Cyrillic",
	"cyrillic",
	"Cyrillic_Ext_A",
	"cyrillicexta",
	"Cyrillic_Ext_B",
	"cyrillicextb",
	"Cyrillic_Ext_C",
	"cyrillicextc",
	"Cyrillic Extended-A",
	"Cyrillic_Extended_A",
	"cyrillicextendeda",
	"Cyrillic Extended-B",
	"Cyrillic_Extended_B",
	"cyrillicextendedb",
	"Cyrillic Extended-C",
	"Cyrillic_Extended_C",
	"cyrillicextendedc",
	"Cyrillic_Sup",
	"cyrillicsup",
	"Cyrillic Supplement",
	"Cyrillic_Supplement",
	"cyrillicsupplement",
	"Cyrillic_Supplementary",
	"cyrillicsupplementary",
	"Deseret",
	"deseret",
	"Devanagari",
	"devanagari",
	"Devanagari_Ext",
	"devanagariext",
	"Devanagari Extended",
	"Devanagari_Extended",
	"devanagariextended",
	"Diacriticals",
	"diacriticals",
	"Diacriticals_Ext",
	"diacriticalsext",
	"Diacriticals_For_Symbols",
	"diacriticalsforsymbols",
	"Diacriticals_Sup",
	"diacriticalssup",
	"Dingbats",
	"dingbats",
	"Dives Akuru",
	"Dives_Akuru",
	"divesakuru",
	"Dogra",
	"dogra",
	"Domino",
	"domino",
	"Domino Tiles",
	"Domino_Tiles",
	"dominotiles",
	"Duployan",
	"duployan",
	"Early Dynastic Cuneiform",
	"Early_Dynastic_Cuneiform",
	"earlydynasticcuneiform",
	"Egyptian Hieroglyph Format Controls",
	"Egyptian_Hieroglyph_Format_Controls",
	"egyptianhieroglyphformatcontrols",
	"Egyptian Hieroglyphs",
	"Egyptian_Hieroglyphs",
	"egyptianhieroglyphs",
	"Elbasan",
	"elbasan",
	"Elymaic",
	"elymaic",
	"Emoticons",
	"emoticons",
	"Enclosed_Alphanum",
	"enclosedalphanum",
	"Enclosed Alphanumerics",
	"Enclosed_Alphanumerics",
	"enclosedalphanumerics",
	"Enclosed Alphanumeric Supplement",
	"Enclosed_Alphanumeric_Supplement",
	"enclosedalphanumericsupplement",
	"Enclosed_Alphanum_Sup",
	"enclosedalphanumsup",
	"Enclosed_CJK",
	"enclosedcjk",
	"Enclosed CJK Letters and Months",
	"Enclosed_CJK_Letters_And_Months",
	"enclosedcjklettersandmonths",
	"Enclosed_Ideographic_Sup",
	"enclosedideographicsup",
	"Enclosed Ideographic Supplement",
	"Enclosed_Ideographic_Supplement",
	"enclosedideographicsupplement",
	"Ethiopic",
	"ethiopic",
	"Ethiopic_Ext",
	"ethiopicext",
	"Ethiopic_Ext_A",
	"ethiopicexta",
	"Ethiopic_Ext_B",
	"ethiopicextb",
	"Ethiopic Extended",
	"Ethiopic_Extended",
	"ethiopicextended",
	"Ethiopic Extended-A",
	"Ethiopic_Extended_A",
	"ethiopicextendeda",
	"Ethiopic Extended-B",
	"Ethiopic_Extended_B",
	"ethiopicextendedb",
	"Ethiopic_Sup",
	"ethiopicsup",
	"Ethiopic Supplement",
	"Ethiopic_Supplement",
	"ethiopicsupplement",
	"General Punctuation",
	"General_Punctuation",
	"generalpunctuation",
	"Geometric Shapes",
	"Geometric_Shapes",
	"geometricshapes",
	"Geometric_Shapes_Ext",
	"geometricshapesext",
	"Geometric Shapes Extended",
	"Geometric_Shapes_Extended",
	"geometricshapesextended",
	"Georgian",
	"georgian",
	"Georgian_Ext",
	"georgianext",
	"Georgian Extended",
	"Georgian_Extended",
	"georgianextended",
	"Georgian_Sup",
	"georgiansup",
	"Georgian Supplement",
	"Georgian_Supplement",
	"georgiansupplement",
	"Glagolitic",
	"glagolitic",
	"Glagolitic_Sup",
	"glagoliticsup",
	"Glagolitic Supplement",
	"Glagolitic_Supplement",
	"glagoliticsupplement",
	"Gothic",
	"gothic",
	"Grantha",
	"grantha",
	"Greek",
	"greek",
	"Greek and Coptic",
	"Greek_And_Coptic",
	"greekandcoptic",
	"Greek_Ext",
	"greekext",
	"Greek Extended",
	"Greek_Extended",
	"greekextended",
	"Gujarati",
	"gujarati",
	"Gunjala Gondi",
	"Gunjala_Gondi",
	"gunjalagondi",
	"Gurmukhi",
	"gurmukhi",
	"Half_And_Full_Forms",
	"halfandfullforms",
	"Half_Marks",
	"halfmarks",
	"Halfwidth and Fullwidth Forms",
	"Halfwidth_And_Fullwidth_Forms",
	"halfwidthandfullwidthforms",
	"Hangul",
	"hangul",
	"Hangul Compatibility Jamo",
	"Hangul_Compatibility_Jamo",
	"hangulcompatibilityjamo",
	"Hangul Jamo",
	"Hangul_Jamo",
	"hanguljamo",
	"Hangul Jamo Extended-A",
	"Hangul_Jamo_Extended_A",
	"hanguljamoextendeda",
	"Hangul Jamo Extended-B",
	"Hangul_Jamo_Extended_B",
	"hanguljamoextendedb",
	"Hangul Syllables",
	"Hangul_Syllables",
	"hangulsyllables",
	"Hanifi Rohingya",
	"Hanifi_Rohingya",
	"hanifirohingya",
	"Hanunoo",
	"hanunoo",
	"Hatran",
	"hatran",
	"Hebrew",
	"hebrew",
	"High Private Use Surrogates",
	"High_Private_Use_Surrogates",
	"highprivateusesurrogates",
	"High_PU_Surrogates",
	"highpusurrogates",
	"High Surrogates",
	"High_Surrogates",
	"highsurrogates",
	"Hiragana",
	"hiragana",
	"IDC",
	"idc",
	"Ideographic Description Characters",
	"Ideographic_Description_Characters",
	"ideographicdescriptioncharacters",
	"Ideographic_Symbols",
	"ideographicsymbols",
	"Ideographic Symbols and Punctuation",
	"Ideographic_Symbols_And_Punctuation",
	"ideographicsymbolsandpunctuation",
	"Imperial Aramaic",
	"Imperial_Aramaic",
	"imperialaramaic",
	"Indic_Number_Forms",
	"indicnumberforms",
	"Indic Siyaq Numbers",
	"Indic_Siyaq_Numbers",
	"indicsiyaqnumbers",
	"Inscriptional Pahlavi",
	"Inscriptional_Pahlavi",
	"inscriptionalpahlavi",
	"Inscriptional Parthian",
	"Inscriptional_Parthian",
	"inscriptionalparthian",
	"IPA_Ext",
	"ipaext",
	"IPA Extensions",
	"IPA_Extensions",
	"ipaextensions",
	"Jamo",
	"jamo",
	"Jamo_Ext_A",
	"jamoexta",
	"Jamo_Ext_B",
	"jamoextb",
	"Javanese",
	"javanese",
	"Kaithi",
	"kaithi",
	"Kana_Ext_A",
	"kanaexta",
	"Kana_Ext_B",
	"kanaextb",
	"Kana Extended-A",
	"Kana_Extended_A",
	"kanaextendeda",
	"Kana Extended-B",
	"Kana_Extended_B",
	"kanaextendedb",
	"Kana_Sup",
	"kanasup",
	"Kana Supplement",
	"Kana_Supplement",
	"kanasupplement",
	"Kanbun",
	"kanbun",
	"Kangxi",
	"kangxi",
	"Kangxi Radicals",
	"Kangxi_Radicals",
	"kangxiradicals",
	"Kannada",
	"kannada",
	"Katakana",
	"katakana",
	"Katakana_Ext",
	"katakanaext",
	"Katakana Phonetic Extensions",
	"Katakana_Phonetic_Extensions",
	"katakanaphoneticextensions",
	"Kayah Li",
	"Kayah_Li",
	"kayahli",
	"Kharoshthi",
	"kharoshthi",
	"Khitan Small Script",
	"Khitan_Small_Script",
	"khitansmallscript",
	"Khmer",
	"khmer",
	"Khmer Symbols",
	"Khmer_Symbols",
	"khmersymbols",
	"Khojki",
	"khojki",
	"Khudawadi",
	"khudawadi",
	"Lao",
	"lao",
	"Latin_1",
	"latin1",
	"Latin_Ext_A",
	"latinexta",
	"Latin_Ext_Additional",
	"latinextadditional",
	"Latin_Ext_B",
	"latinextb",
	"Latin_Ext_C",
	"latinextc",
	"Latin_Ext_D",
	"latinextd",
	"Latin_Ext_E",
	"latinexte",
	"Latin Extended-A",
	"Latin_Extended_A",
	"latinextendeda",
	"Latin Extended Additional",
	"Latin_Extended_Additional",
	"latinextendedadditional",
	"Latin Extended-B",
	"Latin_Extended_B",
	"latinextendedb",
	"Latin Extended-C",
	"Latin_Extended_C",
	"latinextendedc",
	"Latin Extended-D",
	"Latin_Extended_D",
	"latinextendedd",
	"Latin Extended-E",
	"Latin_Extended_E",
	"latinextendede",
	"Latin Extended-F",
	"Latin_Extended_F",
	"latinextendedf",
	"Latin Extended-G",
	"Latin_Extended_G",
	"latinextendedg",
	"Latin_Ext_F",
	"latinextf",
	"Latin_Ext_G",
	"latinextg",
	"Latin_1_Sup",
	"latin1sup",
	"Latin-1 Supplement",
	"Latin_1_Supplement",
	"latin1supplement",
	"Lepcha",
	"lepcha",
	"Letterlike Symbols",
	"Letterlike_Symbols",
	"letterlikesymbols",
	"Limbu",
	"limbu",
	"Linear A",
	"Linear_A",
	"lineara",
	"Linear B Ideograms",
	"Linear_B_Ideograms",
	"linearbideograms",
	"Linear B Syllabary",
	"Linear_B_Syllabary",
	"linearbsyllabary",
	"Lisu",
	"lisu",
	"Lisu_Sup",
	"lisusup",
	"Lisu Supplement",
	"Lisu_Supplement",
	"lisusupplement",
	"Low Surrogates",
	"Low_Surrogates",
	"lowsurrogates",
	"Lycian",
	"lycian",
	"Lydian",
	"lydian",
	"Mahajani",
	"mahajani",
	"Mahjong",
	"mahjong",
	"Mahjong Tiles",
	"Mahjong_Tiles",
	"mahjongtiles",
	"Makasar",
	"makasar",
	"Malayalam",
	"malayalam",
	"Mandaic",
	"mandaic",
	"Manichaean",
	"manichaean",
	"Marchen",
	"marchen",
	"Masaram Gondi",
	"Masaram_Gondi",
	"masaramgondi",
	"Math_Alphanum",
	"mathalphanum",
	"Mathematical Alphanumeric Symbols",
	"Mathematical_Alphanumeric_Symbols",
	"mathematicalalphanumericsymbols",
	"Mathematical Operators",
	"Mathematical_Operators",
	"mathematicaloperators",
	"Math_Operators",
	"mathoperators",
	"Mayan Numerals",
	"Mayan_Numerals",
	"mayannumerals",
	"Medefaidrin",
	"medefaidrin",
	"Meetei Mayek",
	"Meetei_Mayek",
	"meeteimayek",
	"Meetei_Mayek_Ext",
	"meeteimayekext",
	"Meetei Mayek Extensions",
	"Meetei_Mayek_Extensions",
	"meeteimayekextensions",
	"Mende Kikakui",
	"Mende_Kikakui",
	"mendekikakui",
	"Meroitic Cursive",
	"Meroitic_Cursive",
	"meroiticcursive",
	"Meroitic Hieroglyphs",
	"Meroitic_Hieroglyphs",
	"meroitichieroglyphs",
	"Miao",
	"miao",
	"Misc_Arrows",
	"miscarrows",
	"Miscellaneous Mathematical Symbols-A",
	"Miscellaneous_Mathematical_Symbols_A",
	"miscellaneousmathematicalsymbolsa",
	"Miscellaneous Mathematical Symbols-B",
	"Miscellaneous_Mathematical_Symbols_B",
	"miscellaneousmathematicalsymbolsb",
	"Miscellaneous Symbols",
	"Miscellaneous_Symbols",
	"miscellaneoussymbols",
	"Miscellaneous Symbols and Arrows",
	"Miscellaneous_Symbols_And_Arrows",
	"miscellaneoussymbolsandarrows",
	"Miscellaneous Symbols and Pictographs",
	"Miscellaneous_Symbols_And_Pictographs",
	"miscellaneoussymbolsandpictographs",
	"Miscellaneous Technical",
	"Miscellaneous_Technical",
	"miscellaneoustechnical",
	"Misc_Math_Symbols_A",
	"miscmathsymbolsa",
	"Misc_Math_Symbols_B",
	"miscmathsymbolsb",
	"Misc_Pictographs",
	"miscpictographs",
	"Misc_Symbols",
	"miscsymbols",
	"Misc_Technical",
	"misctechnical",
	"Modi",
	"modi",
	"Modifier_Letters",
	"modifierletters",
	"Modifier Tone Letters",
	"Modifier_Tone_Letters",
	"modifiertoneletters",
	"Mongolian",
	"mongolian",
	"Mongolian_Sup",
	"mongoliansup",
	"Mongolian Supplement",
	"Mongolian_Supplement",
	"mongoliansupplement",
	"Mro",
	"mro",
	"Multani",
	"multani",
	"Music",
	"music",
	"Musical Symbols",
	"Musical_Symbols",
	"musicalsymbols",
	"Myanmar",
	"myanmar",
	"Myanmar_Ext_A",
	"myanmarexta",
	"Myanmar_Ext_B",
	"myanmarextb",
	"Myanmar Extended-A",
	"Myanmar_Extended_A",
	"myanmarextendeda",
	"Myanmar Extended-B",
	"Myanmar_Extended_B",
	"myanmarextendedb",
	"Nabataean",
	"nabataean",
	"Nandinagari",
	"nandinagari",
	"NB",
	"nb",
	"Newa",
	"newa",
	"New Tai Lue",
	"New_Tai_Lue",
	"newtailue",
	"NKo",
	"nko",
	"No_Block",
	"noblock",
	"Number Forms",
	"Number_Forms",
	"numberforms",
	"Nushu",
	"nushu",
	"Nyiakeng Puachue Hmong",
	"Nyiakeng_Puachue_Hmong",
	"nyiakengpuachuehmong",
	"OCR",
	"ocr",
	"Ogham",
	"ogham",
	"Ol Chiki",
	"Ol_Chiki",
	"olchiki",
	"Old Hungarian",
	"Old_Hungarian",
	"oldhungarian",
	"Old Italic",
	"Old_Italic",
	"olditalic",
	"Old North Arabian",
	"Old_North_Arabian",
	"oldnortharabian",
	"Old Permic",
	"Old_Permic",
	"oldpermic",
	"Old Persian",
	"Old_Persian",
	"oldpersian",
	"Old Sogdian",
	"Old_Sogdian",
	"oldsogdian",
	"Old South Arabian",
	"Old_South_Arabian",
	"oldsoutharabian",
	"Old Turkic",
	"Old_Turkic",
	"oldturkic",
	"Old Uyghur",
	"Old_Uyghur",
	"olduyghur",
	"Optical Character Recognition",
	"Optical_Character_Recognition",
	"opticalcharacterrecognition",
	"Oriya",
	"oriya",
	"Ornamental Dingbats",
	"Ornamental_Dingbats",
	"ornamentaldingbats",
	"Osage",
	"osage",
	"Osmanya",
	"osmanya",
	"Ottoman Siyaq Numbers",
	"Ottoman_Siyaq_Numbers",
	"ottomansiyaqnumbers",
	"Pahawh Hmong",
	"Pahawh_Hmong",
	"pahawhhmong",
	"Palmyrene",
	"palmyrene",
	"Pau Cin Hau",
	"Pau_Cin_Hau",
	"paucinhau",
	"Phags-pa",
	"Phags_Pa",
	"phagspa",
	"Phaistos",
	"phaistos",
	"Phaistos Disc",
	"Phaistos_Disc",
	"phaistosdisc",
	"Phoenician",
	"phoenician",
	"Phonetic_Ext",
	"phoneticext",
	"Phonetic Extensions",
	"Phonetic_Extensions",
	"phoneticextensions",
	"Phonetic Extensions Supplement",
	"Phonetic_Extensions_Supplement",
	"phoneticextensionssupplement",
	"Phonetic_Ext_Sup",
	"phoneticextsup",
	"Playing Cards",
	"Playing_Cards",
	"playingcards",
	"Private_Use",
	"privateuse",
	"Private Use Area",
	"Private_Use_Area",
	"privateusearea",
	"Psalter Pahlavi",
	"Psalter_Pahlavi",
	"psalterpahlavi",
	"PUA",
	"pua",
	"Punctuation",
	"punctuation",
	"Rejang",
	"rejang",
	"Rumi",
	"rumi",
	"Rumi Numeral Symbols",
	"Rumi_Numeral_Symbols",
	"ruminumeralsymbols",
	"Runic",
	"runic",
	"Samaritan",
	"samaritan",
	"Saurashtra",
	"saurashtra",
	"Sharada",
	"sharada",
	"Shavian",
	"shavian",
	"Shorthand Format Controls",
	"Shorthand_Format_Controls",
	"shorthandformatcontrols",
	"Siddham",
	"siddham",
	"Sinhala",
	"sinhala",
	"Sinhala Archaic Numbers",
	"Sinhala_Archaic_Numbers",
	"sinhalaarchaicnumbers",
	"Small_Forms",
	"smallforms",
	"Small Form Variants",
	"Small_Form_Variants",
	"smallformvariants",
	"Small_Kana_Ext",
	"smallkanaext",
	"Small Kana Extension",
	"Small_Kana_Extension",
	"smallkanaextension",
	"Sogdian",
	"sogdian",
	"Sora Sompeng",
	"Sora_Sompeng",
	"sorasompeng",
	"Soyombo",
	"soyombo",
	"Spacing Modifier Letters",
	"Spacing_Modifier_Letters",
	"spacingmodifierletters",
	"Specials",
	"specials",
	"Sundanese",
	"sundanese",
	"Sundanese_Sup",
	"sundanesesup",
	"Sundanese Supplement",
	"Sundanese_Supplement",
	"sundanesesupplement",
	"Sup_Arrows_A",
	"suparrowsa",
	"Sup_Arrows_B",
	"suparrowsb",
	"Sup_Arrows_C",
	"suparrowsc",
	"Super_And_Sub",
	"superandsub",
	"Superscripts and Subscripts",
	"Superscripts_And_Subscripts",
	"superscriptsandsubscripts",
	"Sup_Math_Operators",
	"supmathoperators",
	"Supplemental Arrows-A",
	"Supplemental_Arrows_A",
	"supplementalarrowsa",
	"Supplemental Arrows-B",
	"Supplemental_Arrows_B",
	"supplementalarrowsb",
	"Supplemental Arrows-C",
	"Supplemental_Arrows_C",
	"supplementalarrowsc",
	"Supplemental Mathematical Operators",
	"Supplemental_Mathematical_Operators",
	"supplementalmathematicaloperators",
	"Supplemental Punctuation",
	"Supplemental_Punctuation",
	"supplementalpunctuation",
	"Supplemental Symbols and Pictographs",
	"Supplemental_Symbols_And_Pictographs",
	"supplementalsymbolsandpictographs",
	"Supplementary Private Use Area-A",
	"Supplementary_Private_Use_Area_A",
	"supplementaryprivateuseareaa",
	"Supplementary Private Use Area-B",
	"Supplementary_Private_Use_Area_B",
	"supplementaryprivateuseareab",
	"Sup_PUA_A",
	"suppuaa",
	"Sup_PUA_B",
	"suppuab",
	"Sup_Punctuation",
	"suppunctuation",
	"Sup_Symbols_And_Pictographs",
	"supsymbolsandpictographs",
	"Sutton SignWriting",
	"Sutton_SignWriting",
	"suttonsignwriting",
	"Syloti Nagri",
	"Syloti_Nagri",
	"sylotinagri",
	"Symbols_And_Pictographs_Ext_A",
	"symbolsandpictographsexta",
	"Symbols and Pictographs Extended-A",
	"Symbols_And_Pictographs_Extended_A",
	"symbolsandpictographsextendeda",
	"Symbols for Legacy Computing",
	"Symbols_For_Legacy_Computing",
	"symbolsforlegacycomputing",
	"Syriac",
	"syriac",
	"Syriac_Sup",
	"syriacsup",
	"Syriac Supplement",
	"Syriac_Supplement",
	"syriacsupplement",
	"Tagalog",
	"tagalog",
	"Tagbanwa",
	"tagbanwa",
	"Tags",
	"tags",
	"Tai Le",
	"Tai_Le",
	"taile",
	"Tai Tham",
	"Tai_Tham",
	"taitham",
	"Tai Viet",
	"Tai_Viet",
	"taiviet",
	"Tai_Xuan_Jing",
	"taixuanjing",
	"Tai Xuan Jing Symbols",
	"Tai_Xuan_Jing_Symbols",
	"taixuanjingsymbols",
	"Takri",
	"takri",
	"Tamil",
	"tamil",
	"Tamil_Sup",
	"tamilsup",
	"Tamil Supplement",
	"Tamil_Supplement",
	"tamilsupplement",
	"Tangsa",
	"tangsa",
	"Tangut",
	"tangut",
	"Tangut Components",
	"Tangut_Components",
	"tangutcomponents",
	"Tangut_Sup",
	"tangutsup",
	"Tangut Supplement",
	"Tangut_Supplement",
	"tangutsupplement",
	"Telugu",
	"telugu",
	"Thaana",
	"thaana",
	"Thai",
	"thai",
	"Tibetan",
	"tibetan",
	"Tifinagh",
	"tifinagh",
	"Tirhuta",
	"tirhuta",
	"Toto",
	"toto",
	"Transport_And_Map",
	"transportandmap",
	"Transport and Map Symbols",
	"Transport_And_Map_Symbols",
	"transportandmapsymbols",
	"UCAS",
	"ucas",
	"UCAS_Ext",
	"ucasext",
	"UCAS_Ext_A",
	"ucasexta",
	"Ugaritic",
	"ugaritic",
	"Unified Canadian Aboriginal Syllabics",
	"Unified_Canadian_Aboriginal_Syllabics",
	"unifiedcanadianaboriginalsyllabics",
	"Unified Canadian Aboriginal Syllabics Extended",
	"Unified_Canadian_Aboriginal_Syllabics_Extended",
	"unifiedcanadianaboriginalsyllabicsextended",
	"Unified Canadian Aboriginal Syllabics Extended-A",
	"Unified_Canadian_Aboriginal_Syllabics_Extended_A",
	"unifiedcanadianaboriginalsyllabicsextendeda",
	"Vai",
	"vai",
	"Variation Selectors",
	"Variation_Selectors",
	"variationselectors",
	"Variation Selectors Supplement",
	"Variation_Selectors_Supplement",
	"variationselectorssupplement",
	"Vedic_Ext",
	"vedicext",
	"Vedic Extensions",
	"Vedic_Extensions",
	"vedicextensions",
	"Vertical Forms",
	"Vertical_Forms",
	"verticalforms",
	"Vithkuqi",
	"vithkuqi",
	"VS",
	"vs",
	"VS_Sup",
	"vssup",
	"Wancho",
	"wancho",
	"Warang Citi",
	"Warang_Citi",
	"warangciti",
	"Yezidi",
	"yezidi",
	"Yijing",
	"yijing",
	"Yijing Hexagram Symbols",
	"Yijing_Hexagram_Symbols",
	"yijinghexagramsymbols",
	"Yi Radicals",
	"Yi_Radicals",
	"yiradicals",
	"Yi Syllables",
	"Yi_Syllables",
	"yisyllables",
	"Zanabazar Square",
	"Zanabazar_Square",
	"zanabazarsquare",
	"Znamenny_Music",
	"znamennymusic",
	"Znamenny Musical Notation",
	"Znamenny_Musical_Notation",
	"znamennymusicalnotation",
	NULL
};

static const char * const UNI_bpt_values[] = {
	"c",
	"Close",
	"close",
	"n",
	"None",
	"none",
	"o",
	"Open",
	"open",
	NULL
};

static const char * const UNI_ccc_values[] = {
	"0",
	"1",
	"6",
	"7",
	"8",
	"9",
	"10",
	"11",
	"12",
	"13",
	"14",
	"15",
	"16",
	"17",
	"18",
	"19",
	"20",
	"21",
	"22",
	"23",
	"24",
	"25",
	"26",
	"27",
	"28",
	"29",
	"30",
	"31",
	"32",
	"33",
	"34",
	"35",
	"36",
	"84",
	"91",
	"103",
	"107",
	"118",
	"122",
	"129",
	"130",
	"132",
	"133",
	"200",
	"202",
	"214",
	"216",
	"218",
	"220",
	"222",
	"224",
	"226",
	"228",
	"230",
	"232",
	"233",
	"234",
	"240",
	"A",
	"a",
	"Above",
	"above",
	"Above_Left",
	"aboveleft",
	"Above_Right",
	"aboveright",
	"AL",
	"al",
	"AR",
	"ar",
	"ATA",
	"ata",
	"ATAR",
	"atar",
	"ATB",
	"atb",
	"ATBL",
	"atbl",
	"Attached_Above",
	"attachedabove",
	"Attached_Above_Right",
	"attachedaboveright",
	"Attached_Below",
	"attachedbelow",
	"Attached_Below_Left",
	"attachedbelowleft",
	"B",
	"b",
	"Below",
	"below",
	"Below_Left",
	"belowleft",
	"Below_Right",
	"belowright",
	"BL",
	"bl",
	"BR",
	"br",
	"CCC10",
	"CCC103",
	"CCC107",
	"CCC11",
	"CCC118",
	"CCC12",
	"CCC122",
	"CCC129",
	"CCC13",
	"CCC130",
	"CCC132",
	"CCC133",
	"CCC14",
	"CCC15",
	"CCC16",
	"CCC17",
	"CCC18",
	"CCC19",
	"CCC20",
	"CCC21",
	"CCC22",
	"CCC23",
	"CCC24",
	"CCC25",
	"CCC26",
	"CCC27",
	"CCC28",
	"CCC29",
	"CCC30",
	"CCC31",
	"CCC32",
	"CCC33",
	"CCC34",
	"CCC35",
	"CCC36",
	"CCC84",
	"CCC91",
	"ccc10",
	"ccc103",
	"ccc107",
	"ccc11",
	"ccc118",
	"ccc12",
	"ccc122",
	"ccc129",
	"ccc13",
	"ccc130",
	"ccc132",
	"ccc133",
	"ccc14",
	"ccc15",
	"ccc16",
	"ccc17",
	"ccc18",
	"ccc19",
	"ccc20",
	"ccc21",
	"ccc22",
	"ccc23",
	"ccc24",
	"ccc25",
	"ccc26",
	"ccc27",
	"ccc28",
	"ccc29",
	"ccc30",
	"ccc31",
	"ccc32",
	"ccc33",
	"ccc34",
	"ccc35",
	"ccc36",
	"ccc84",
	"ccc91",
	"DA",
	"da",
	"DB",
	"db",
	"Double_Above",
	"doubleabove",
	"Double_Below",
	"doublebelow",
	"HANR",
	"hanr",
	"Han_Reading",
	"hanreading",
	"Iota_Subscript",
	"iotasubscript",
	"IS",
	"is",
	"Kana_Voicing",
	"kanavoicing",
	"KV",
	"kv",
	"L",
	"l",
	"Left",
	"left",
	"NK",
	"nk",
	"Not_Reordered",
	"notreordered",
	"NR",
	"nr",
	"Nukta",
	"nukta",
	"OV",
	"ov",
	"Overlay",
	"overlay",
	"R",
	"r",
	"Right",
	"right",
	"Virama",
	"virama",
	"VR",
	"vr",
	NULL
};

static const char * const UNI_dt_values[] = {
	"Can",
	"can",
	"Canonical",
	"canonical",
	"Circle",
	"circle",
	"Com",
	"com",
	"Compat",
	"compat",
	"Enc",
	"enc",
	"Fin",
	"fin",
	"Final",
	"final",
	"Font",
	"font",
	"Fra",
	"fra",
	"Fraction",
	"fraction",
	"Init",
	"init",
	"Initial",
	"initial",
	"Iso",
	"iso",
	"Isolated",
	"isolated",
	"Med",
	"med",
	"Medial",
	"medial",
	"Nar",
	"nar",
	"Narrow",
	"narrow",
	"Nb",
	"nb",
	"Nobreak",
	"nobreak",
	"Non_Canon",
	"noncanon",
	"Non_Canonical",
	"noncanonical",
	"None",
	"none",
	"Small",
	"small",
	"Sml",
	"sml",
	"Sqr",
	"sqr",
	"Square",
	"square",
	"Sub",
	"sub",
	"Sup",
	"sup",
	"Super",
	"super",
	"Vert",
	"vert",
	"Vertical",
	"vertical",
	"Wide",
	"wide",
	NULL
};

static const char * const UNI_ea_values[] = {
	"A",
	"a",
	"Ambiguous",
	"ambiguous",
	"F",
	"f",
	"Fullwidth",
	"fullwidth",
	"H",
	"h",
	"Halfwidth",
	"halfwidth",
	"N",
	"n",
	"Na",
	"na",
	"Narrow",
	"narrow",
	"Neutral",
	"neutral",
	"W",
	"w",
	"Wide",
	"wide",
	NULL
};

static const char * const UNI_gc_values[] = {
	"C",
	"c",
	"Cased_Letter",
	"casedletter",
	"Cc",
	"cc",
	"Cf",
	"cf",
	"Close_Punctuation",
	"closepunctuation",
	"Cn",
	"cn",
	"Cntrl",
	"cntrl",
	"Co",
	"co",
	"Combining_Mark",
	"combiningmark",
	"Connector_Punctuation",
	"connectorpunctuation",
	"Control",
	"control",
	"Cs",
	"cs",
	"Currency_Symbol",
	"currencysymbol",
	"Dash_Punctuation",
	"dashpunctuation",
	"Decimal_Number",
	"decimalnumber",
	"Digit",
	"digit",
	"Enclosing_Mark",
	"enclosingmark",
	"Final_Punctuation",
	"finalpunctuation",
	"Format",
	"format",
	"Initial_Punctuation",
	"initialpunctuation",
	"L",
	"l",
	"LC",
	"lc",
	"Letter",
	"letter",
	"Letter_Number",
	"letternumber",
	"Line_Separator",
	"lineseparator",
	"Ll",
	"ll",
	"Lm",
	"lm",
	"Lo",
	"lo",
	"Lowercase_Letter",
	"lowercaseletter",
	"Lt",
	"lt",
	"Lu",
	"lu",
	"M",
	"m",
	"Mark",
	"mark",
	"Math_Symbol",
	"mathsymbol",
	"Mc",
	"mc",
	"Me",
	"me",
	"Mn",
	"mn",
	"Modifier_Letter",
	"modifierletter",
	"Modifier_Symbol",
	"modifiersymbol",
	"N",
	"n",
	"Nd",
	"nd",
	"Nl",
	"nl",
	"No",
	"no",
	"Nonspacing_Mark",
	"nonspacingmark",
	"Number",
	"number",
	"Open_Punctuation",
	"openpunctuation",
	"Other",
	"other",
	"Other_Letter",
	"otherletter",
	"Other_Number",
	"othernumber",
	"Other_Punctuation",
	"otherpunctuation",
	"Other_Symbol",
	"othersymbol",
	"P",
	"p",
	"Paragraph_Separator",
	"paragraphseparator",
	"Pc",
	"pc",
	"Pd",
	"pd",
	"Pe",
	"pe",
	"Pf",
	"pf",
	"Pi",
	"pi",
	"Po",
	"po",
	"Private_Use",
	"privateuse",
	"Ps",
	"ps",
	"Punct",
	"punct",
	"Punctuation",
	"punctuation",
	"S",
	"s",
	"Sc",
	"sc",
	"Separator",
	"separator",
	"Sk",
	"sk",
	"Sm",
	"sm",
	"So",
	"so",
	"Space_Separator",
	"spaceseparator",
	"Spacing_Mark",
	"spacingmark",
	"Surrogate",
	"surrogate",
	"Symbol",
	"symbol",
	"Titlecase_Letter",
	"titlecaseletter",
	"Unassigned",
	"unassigned",
	"Uppercase_Letter",
	"uppercaseletter",
	"Z",
	"z",
	"Zl",
	"zl",
	"Zp",
	"zp",
	"Zs",
	"zs",
	NULL
};

static const char * const UNI_gcb_values[] = {
	"CN",
	"cn",
	"Control",
	"control",
	"CR",
	"cr",
	"EB",
	"eb",
	"E_Base",
	"ebase",
	"E_Base_GAZ",
	"ebasegaz",
	"EBG",
	"ebg",
	"EM",
	"em",
	"E_Modifier",
	"emodifier",
	"EX",
	"ex",
	"Extend",
	"extend",
	"GAZ",
	"gaz",
	"Glue_After_Zwj",
	"glueafterzwj",
	"L",
	"l",
	"LF",
	"lf",
	"LV",
	"lv",
	"LVT",
	"lvt",
	"Other",
	"other",
	"PP",
	"pp",
	"Prepend",
	"prepend",
	"Regional_Indicator",
	"regionalindicator",
	"RI",
	"ri",
	"SM",
	"sm",
	"SpacingMark",
	"spacingmark",
	"T",
	"t",
	"V",
	"v",
	"XX",
	"xx",
	"ZWJ",
	"zwj",
	NULL
};

static const char * const UNI_hst_values[] = {
	"L",
	"l",
	"Leading_Jamo",
	"leadingjamo",
	"LV",
	"lv",
	"LV_Syllable",
	"lvsyllable",
	"LVT",
	"lvt",
	"LVT_Syllable",
	"lvtsyllable",
	"NA",
	"na",
	"Not_Applicable",
	"notapplicable",
	"T",
	"t",
	"Trailing_Jamo",
	"trailingjamo",
	"V",
	"v",
	"Vowel_Jamo",
	"voweljamo",
	NULL
};

static const char * const UNI_identifierstatus_values[] = {
	"Allowed",
	"allowed",
	"Restricted",
	"restricted",
	NULL
};

static const char * const UNI_identifiertype_values[] = {
	"Default_Ignorable",
	"defaultignorable",
	"Deprecated",
	"deprecated",
	"Exclusion",
	"exclusion",
	"Inclusion",
	"inclusion",
	"Limited_Use",
	"limiteduse",
	"Not_Character",
	"notcharacter",
	"Not_NFKC",
	"notnfkc",
	"Not_XID",
	"notxid",
	"Obsolete",
	"obsolete",
	"Recommended",
	"recommended",
	"Technical",
	"technical",
	"Uncommon_Use",
	"uncommonuse",
	NULL
};

static const char * const UNI_inpc_values[] = {
	"Bottom",
	"bottom",
	"Bottom_And_Left",
	"bottomandleft",
	"Bottom_And_Right",
	"bottomandright",
	"Left",
	"left",
	"Left_And_Right",
	"leftandright",
	"NA",
	"na",
	"Overstruck",
	"overstruck",
	"Right",
	"right",
	"Top",
	"top",
	"Top_And_Bottom",
	"topandbottom",
	"Top_And_Bottom_And_Left",
	"topandbottomandleft",
	"Top_And_Bottom_And_Right",
	"topandbottomandright",
	"Top_And_Left",
	"topandleft",
	"Top_And_Left_And_Right",
	"topandleftandright",
	"Top_And_Right",
	"topandright",
	"Visual_Order_Left",
	"visualorderleft",
	NULL
};

static const char * const UNI_insc_values[] = {
	"Avagraha",
	"avagraha",
	"Bindu",
	"bindu",
	"Brahmi_Joining_Number",
	"brahmijoiningnumber",
	"Cantillation_Mark",
	"cantillationmark",
	"Consonant",
	"consonant",
	"Consonant_Dead",
	"consonantdead",
	"Consonant_Final",
	"consonantfinal",
	"Consonant_Head_Letter",
	"consonantheadletter",
	"Consonant_Initial_Postfixed",
	"consonantinitialpostfixed",
	"Consonant_Killer",
	"consonantkiller",
	"Consonant_Medial",
	"consonantmedial",
	"Consonant_Placeholder",
	"consonantplaceholder",
	"Consonant_Preceding_Repha",
	"consonantprecedingrepha",
	"Consonant_Prefixed",
	"consonantprefixed",
	"Consonant_Subjoined",
	"consonantsubjoined",
	"Consonant_Succeeding_Repha",
	"consonantsucceedingrepha",
	"Consonant_With_Stacker",
	"consonantwithstacker",
	"Gemination_Mark",
	"geminationmark",
	"Invisible_Stacker",
	"invisiblestacker",
	"Joiner",
	"joiner",
	"Modifying_Letter",
	"modifyingletter",
	"Non_Joiner",
	"nonjoiner",
	"Nukta",
	"nukta",
	"Number",
	"number",
	"Number_Joiner",
	"numberjoiner",
	"Other",
	"other",
	"Pure_Killer",
	"purekiller",
	"Register_Shifter",
	"registershifter",
	"Syllable_Modifier",
	"syllablemodifier",
	"Tone_Letter",
	"toneletter",
	"Tone_Mark",
	"tonemark",
	"Virama",
	"virama",
	"Visarga",
	"visarga",
	"Vowel",
	"vowel",
	"Vowel_Dependent",
	"voweldependent",
	"Vowel_Independent",
	"vowelindependent",
	NULL
};

static const char * const UNI_jg_values[] = {
	"African_Feh",
	"africanfeh",
	"African_Noon",
	"africannoon",
	"African_Qaf",
	"africanqaf",
	"Ain",
	"ain",
	"Alaph",
	"alaph",
	"Alef",
	"alef",
	"Beh",
	"beh",
	"Beth",
	"beth",
	"Burushaski_Yeh_Barree",
	"burushaskiyehbarree",
	"Dal",
	"dal",
	"Dalath_Rish",
	"dalathrish",
	"E",
	"e",
	"Farsi_Yeh",
	"farsiyeh",
	"Fe",
	"fe",
	"Feh",
	"feh",
	"Final_Semkath",
	"finalsemkath",
	"Gaf",
	"gaf",
	"Gamal",
	"gamal",
	"Hah",
	"hah",
	"Hamza_On_Heh_Goal",
	"hamzaonhehgoal",
	"Hanifi_Rohingya_Kinna_Ya",
	"hanifirohingyakinnaya",
	"Hanifi_Rohingya_Pa",
	"hanifirohingyapa",
	"He",
	"he",
	"Heh",
	"heh",
	"Heh_Goal",
	"hehgoal",
	"Heth",
	"heth",
	"Kaf",
	"kaf",
	"Kaph",
	"kaph",
	"Khaph",
	"khaph",
	"Knotted_Heh",
	"knottedheh",
	"Lam",
	"lam",
	"Lamadh",
	"lamadh",
	"Malayalam_Bha",
	"malayalambha",
	"Malayalam_Ja",
	"malayalamja",
	"Malayalam_Lla",
	"malayalamlla",
	"Malayalam_Llla",
	"malayalamllla",
	"Malayalam_Nga",
	"malayalamnga",
	"Malayalam_Nna",
	"malayalamnna",
	"Malayalam_Nnna",
	"malayalamnnna",
	"Malayalam_Nya",
	"malayalamnya",
	"Malayalam_Ra",
	"malayalamra",
	"Malayalam_Ssa",
	"malayalamssa",
	"Malayalam_Tta",
	"malayalamtta",
	"Manichaean_Aleph",
	"manichaeanaleph",
	"Manichaean_Ayin",
	"manichaeanayin",
	"Manichaean_Beth",
	"manichaeanbeth",
	"Manichaean_Daleth",
	"manichaeandaleth",
	"Manichaean_Dhamedh",
	"manichaeandhamedh",
	"Manichaean_Five",
	"manichaeanfive",
	"Manichaean_Gimel",
	"manichaeangimel",
	"Manichaean_Heth",
	"manichaeanheth",
	"Manichaean_Hundred",
	"manichaeanhundred",
	"Manichaean_Kaph",
	"manichaeankaph",
	"Manichaean_Lamedh",
	"manichaeanlamedh",
	"Manichaean_Mem",
	"manichaeanmem",
	"Manichaean_Nun",
	"manichaeannun",
	"Manichaean_One",
	"manichaeanone",
	"Manichaean_Pe",
	"manichaeanpe",
	"Manichaean_Qoph",
	"manichaeanqoph",
	"Manichaean_Resh",
	"manichaeanresh",
	"Manichaean_Sadhe",
	"manichaeansadhe",
	"Manichaean_Samekh",
	"manichaeansamekh",
	"Manichaean_Taw",
	"manichaeantaw",
	"Manichaean_Ten",
	"manichaeanten",
	"Manichaean_Teth",
	"manichaeanteth",
	"Manichaean_Thamedh",
	"manichaeanthamedh",
	"Manichaean_Twenty",
	"manichaeantwenty",
	"Manichaean_Waw",
	"manichaeanwaw",
	"Manichaean_Yodh",
	"manichaeanyodh",
	"Manichaean_Zayin",
	"manichaeanzayin",
	"Meem",
	"meem",
	"Mim",
	"mim",
	"No_Joining_Group",
	"nojoininggroup",
	"Noon",
	"noon",
	"Nun",
	"nun",
	"Nya",
	"nya",
	"Pe",
	"pe",
	"Qaf",
	"qaf",
	"Qaph",
	"qaph",
	"Reh",
	"reh",
	"Reversed_Pe",
	"reversedpe",
	"Rohingya_Yeh",
	"rohingyayeh",
	"Sad",
	"sad",
	"Sadhe",
	"sadhe",
	"Seen",
	"seen",
	"Semkath",
	"semkath",
	"Shin",
	"shin",
	"Straight_Waw",
	"straightwaw",
	"Swash_Kaf",
	"swashkaf",
	"Syriac_Waw",
	"syriacwaw",
	"Tah",
	"tah",
	"Taw",
	"taw",
	"Teh_Marbuta",
	"tehmarbuta",
	"Teh_Marbuta_Goal",
	"tehmarbutagoal",
	"Teth",
	"teth",
	"Thin_Yeh",
	"thinyeh",
	"Vertical_Tail",
	"verticaltail",
	"Waw",
	"waw",
	"Yeh",
	"yeh",
	"Yeh_Barree",
	"yehbarree",
	"Yeh_With_Tail",
	"yehwithtail",
	"Yudh",
	"yudh",
	"Yudh_He",
	"yudhhe",
	"Zain",
	"zain",
	"Zhain",
	"zhain",
	NULL
};

static const char * const UNI_jt_values[] = {
	"C",
	"c",
	"D",
	"d",
	"Dual_Joining",
	"dualjoining",
	"Join_Causing",
	"joincausing",
	"L",
	"l",
	"Left_Joining",
	"leftjoining",
	"Non_Joining",
	"nonjoining",
	"R",
	"r",
	"Right_Joining",
	"rightjoining",
	"T",
	"t",
	"Transparent",
	"transparent",
	"U",
	"u",
	NULL
};

static const char * const UNI_lb_values[] = {
	"AI",
	"ai",
	"AL",
	"al",
	"Alphabetic",
	"alphabetic",
	"Ambiguous",
	"ambiguous",
	"B2",
	"b2",
	"BA",
	"ba",
	"BB",
	"bb",
	"BK",
	"bk",
	"Break_After",
	"breakafter",
	"Break_Before",
	"breakbefore",
	"Break_Both",
	"breakboth",
	"Break_Symbols",
	"breaksymbols",
	"Carriage_Return",
	"carriagereturn",
	"CB",
	"cb",
	"CJ",
	"cj",
	"CL",
	"cl",
	"Close_Parenthesis",
	"closeparenthesis",
	"Close_Punctuation",
	"closepunctuation",
	"CM",
	"cm",
	"Combining_Mark",
	"combiningmark",
	"Complex_Context",
	"complexcontext",
	"Conditional_Japanese_Starter",
	"conditionaljapanesestarter",
	"Contingent_Break",
	"contingentbreak",
	"CP",
	"cp",
	"CR",
	"cr",
	"EB",
	"eb",
	"E_Base",
	"ebase",
	"EM",
	"em",
	"E_Modifier",
	"emodifier",
	"EX",
	"ex",
	"Exclamation",
	"exclamation",
	"GL",
	"gl",
	"Glue",
	"glue",
	"H2",
	"H3",
	"h2",
	"h3",
	"Hebrew_Letter",
	"hebrewletter",
	"HL",
	"hl",
	"HY",
	"hy",
	"Hyphen",
	"hyphen",
	"ID",
	"id",
	"Ideographic",
	"ideographic",
	"IN",
	"in",
	"Infix_Numeric",
	"infixnumeric",
	"Inseparable",
	"inseparable",
	"Inseperable",
	"inseperable",
	"IS",
	"is",
	"JL",
	"jl",
	"JT",
	"jt",
	"JV",
	"jv",
	"LF",
	"lf",
	"Line_Feed",
	"linefeed",
	"Mandatory_Break",
	"mandatorybreak",
	"Next_Line",
	"nextline",
	"NL",
	"nl",
	"Nonstarter",
	"nonstarter",
	"NS",
	"ns",
	"NU",
	"nu",
	"Numeric",
	"numeric",
	"OP",
	"op",
	"Open_Punctuation",
	"openpunctuation",
	"PO",
	"po",
	"Postfix_Numeric",
	"postfixnumeric",
	"PR",
	"pr",
	"Prefix_Numeric",
	"prefixnumeric",
	"QU",
	"qu",
	"Quotation",
	"quotation",
	"Regional_Indicator",
	"regionalindicator",
	"RI",
	"ri",
	"SA",
	"sa",
	"SG",
	"sg",
	"SP",
	"sp",
	"Space",
	"space",
	"Surrogate",
	"surrogate",
	"SY",
	"sy",
	"Unknown",
	"unknown",
	"WJ",
	"wj",
	"Word_Joiner",
	"wordjoiner",
	"XX",
	"xx",
	"ZW",
	"zw",
	"ZWJ",
	"zwj",
	"ZWSpace",
	"zwspace",
	NULL
};

static const char * const UNI_nfcqc_values[] = {
	"M",
	"m",
	"Maybe",
	"maybe",
	"N",
	"n",
	"No",
	"no",
	"Y",
	"y",
	"Yes",
	"yes",
	NULL
};

static const char * const UNI_nfdqc_values[] = {
	"N",
	"n",
	"No",
	"no",
	"Y",
	"y",
	"Yes",
	"yes",
	NULL
};

static const char * const UNI_nt_values[] = {
	"De",
	"de",
	"Decimal",
	"decimal",
	"Di",
	"di",
	"Digit",
	"digit",
	"None",
	"none",
	"Nu",
	"nu",
	"Numeric",
	"numeric",
	NULL
};

static const char * const UNI_nv_values[] = {
	"-1/2",
	"0",
	"1/320",
	"1/160",
	"1/80",
	"1/64",
	"1/40",
	"1/32",
	"3/80",
	"3/64",
	"1/20",
	"1/16",
	"1/12",
	"1/10",
	"1/9",
	"1/8",
	"1/7",
	"3/20",
	"1/6",
	"3/16",
	"1/5",
	"1/4",
	"1/3",
	"3/8",
	"2/5",
	"5/12",
	"1/2",
	"7/12",
	"3/5",
	"5/8",
	"2/3",
	"3/4",
	"4/5",
	"5/6",
	"7/8",
	"11/12",
	"1",
	"3/2",
	"2",
	"5/2",
	"3",
	"7/2",
	"4",
	"9/2",
	"5",
	"11/2",
	"6",
	"13/2",
	"7",
	"15/2",
	"8",
	"17/2",
	"9",
	"10",
	"11",
	"12",
	"13",
	"14",
	"15",
	"16",
	"17",
	"18",
	"19",
	"20",
	"21",
	"22",
	"23",
	"24",
	"25",
	"26",
	"27",
	"28",
	"29",
	"30",
	"31",
	"32",
	"33",
	"34",
	"35",
	"36",
	"37",
	"38",
	"39",
	"40",
	"41",
	"42",
	"43",
	"44",
	"45",
	"46",
	"47",
	"48",
	"49",
	"50",
	"60",
	"70",
	"80",
	"90",
	"100",
	"200",
	"300",
	"400",
	"500",
	"600",
	"700",
	"800",
	"900",
	"1000",
	"2000",
	"3000",
	"4000",
	"5000",
	"6000",
	"7000",
	"8000",
	"9000",
	"10000",
	"20000",
	"30000",
	"40000",
	"50000",
	"60000",
	"70000",
	"80000",
	"90000",
	"100000",
	"200000",
	"216000",
	"300000",
	"400000",
	"432000",
	"500000",
	"600000",
	"700000",
	"800000",
	"900000",
	"1000000",
	"10000000",
	"20000000",
	"100000000",
	"10000000000",
	"1000000000000",
	"NaN",
	"nan",
	NULL
};

static const char * const UNI_sb_values[] = {
	"AT",
	"at",
	"ATerm",
	"aterm",
	"CL",
	"cl",
	"Close",
	"close",
	"CR",
	"cr",
	"EX",
	"ex",
	"Extend",
	"extend",
	"FO",
	"fo",
	"Format",
	"format",
	"LE",
	"le",
	"LF",
	"lf",
	"LO",
	"lo",
	"Lower",
	"lower",
	"NU",
	"nu",
	"Numeric",
	"numeric",
	"OLetter",
	"oletter",
	"Other",
	"other",
	"SC",
	"sc",
	"SContinue",
	"scontinue",
	"SE",
	"se",
	"Sep",
	"sep",
	"SP",
	"Sp",
	"sp",
	"ST",
	"st",
	"STerm",
	"sterm",
	"UP",
	"up",
	"Upper",
	"upper",
	"XX",
	"xx",
	NULL
};

static const char * const UNI_sc_values[] = {
	"Adlam",
	"adlam",
	"Adlm",
	"adlm",
	"Aghb",
	"aghb",
	"Ahom",
	"ahom",
	"Anatolian_Hieroglyphs",
	"anatolianhieroglyphs",
	"Arab",
	"arab",
	"Arabic",
	"arabic",
	"Armenian",
	"armenian",
	"Armi",
	"armi",
	"Armn",
	"armn",
	"Avestan",
	"avestan",
	"Avst",
	"avst",
	"Bali",
	"bali",
	"Balinese",
	"balinese",
	"Bamu",
	"bamu",
	"Bamum",
	"bamum",
	"Bass",
	"bass",
	"Bassa_Vah",
	"bassavah",
	"Batak",
	"batak",
	"Batk",
	"batk",
	"Beng",
	"beng",
	"Bengali",
	"bengali",
	"Bhaiksuki",
	"bhaiksuki",
	"Bhks",
	"bhks",
	"Bopo",
	"bopo",
	"Bopomofo",
	"bopomofo",
	"Brah",
	"brah",
	"Brahmi",
	"brahmi",
	"Brai",
	"brai",
	"Braille",
	"braille",
	"Bugi",
	"bugi",
	"Buginese",
	"buginese",
	"Buhd",
	"buhd",
	"Buhid",
	"buhid",
	"Cakm",
	"cakm",
	"Canadian_Aboriginal",
	"canadianaboriginal",
	"Cans",
	"cans",
	"Cari",
	"cari",
	"Carian",
	"carian",
	"Caucasian_Albanian",
	"caucasianalbanian",
	"Chakma",
	"chakma",
	"Cham",
	"cham",
	"Cher",
	"cher",
	"Cherokee",
	"cherokee",
	"Chorasmian",
	"chorasmian",
	"Chrs",
	"chrs",
	"Common",
	"common",
	"Copt",
	"copt",
	"Coptic",
	"coptic",
	"Cpmn",
	"cpmn",
	"Cprt",
	"cprt",
	"Cuneiform",
	"cuneiform",
	"Cypriot",
	"cypriot",
	"Cypro_Minoan",
	"cyprominoan",
	"Cyrillic",
	"cyrillic",
	"Cyrl",
	"cyrl",
	"Deseret",
	"deseret",
	"Deva",
	"deva",
	"Devanagari",
	"devanagari",
	"Diak",
	"diak",
	"Dives_Akuru",
	"divesakuru",
	"Dogr",
	"dogr",
	"Dogra",
	"dogra",
	"Dsrt",
	"dsrt",
	"Dupl",
	"dupl",
	"Duployan",
	"duployan",
	"Egyp",
	"egyp",
	"Egyptian_Hieroglyphs",
	"egyptianhieroglyphs",
	"Elba",
	"elba",
	"Elbasan",
	"elbasan",
	"Elym",
	"elym",
	"Elymaic",
	"elymaic",
	"Ethi",
	"ethi",
	"Ethiopic",
	"ethiopic",
	"Geor",
	"geor",
	"Georgian",
	"georgian",
	"Glag",
	"glag",
	"Glagolitic",
	"glagolitic",
	"Gong",
	"gong",
	"Gonm",
	"gonm",
	"Goth",
	"goth",
	"Gothic",
	"gothic",
	"Gran",
	"gran",
	"Grantha",
	"grantha",
	"Greek",
	"greek",
	"Grek",
	"grek",
	"Gujarati",
	"gujarati",
	"Gujr",
	"gujr",
	"Gunjala_Gondi",
	"gunjalagondi",
	"Gurmukhi",
	"gurmukhi",
	"Guru",
	"guru",
	"Han",
	"han",
	"Hang",
	"hang",
	"Hangul",
	"hangul",
	"Hani",
	"hani",
	"Hanifi_Rohingya",
	"hanifirohingya",
	"Hano",
	"hano",
	"Hanunoo",
	"hanunoo",
	"Hatr",
	"hatr",
	"Hatran",
	"hatran",
	"Hebr",
	"hebr",
	"Hebrew",
	"hebrew",
	"Hira",
	"hira",
	"Hiragana",
	"hiragana",
	"Hluw",
	"hluw",
	"Hmng",
	"hmng",
	"Hmnp",
	"hmnp",
	"Hung",
	"hung",
	"Imperial_Aramaic",
	"imperialaramaic",
	"Inherited",
	"inherited",
	"Inscriptional_Pahlavi",
	"inscriptionalpahlavi",
	"Inscriptional_Parthian",
	"inscriptionalparthian",
	"Ital",
	"ital",
	"Java",
	"java",
	"Javanese",
	"javanese",
	"Kaithi",
	"kaithi",
	"Kali",
	"kali",
	"Kana",
	"kana",
	"Kannada",
	"kannada",
	"Katakana",
	"katakana",
	"Kayah_Li",
	"kayahli",
	"Khar",
	"khar",
	"Kharoshthi",
	"kharoshthi",
	"Khitan_Small_Script",
	"khitansmallscript",
	"Khmer",
	"khmer",
	"Khmr",
	"khmr",
	"Khoj",
	"khoj",
	"Khojki",
	"khojki",
	"Khudawadi",
	"khudawadi",
	"Kits",
	"kits",
	"Knda",
	"knda",
	"Kthi",
	"kthi",
	"Lana",
	"lana",
	"Lao",
	"lao",
	"Laoo",
	"laoo",
	"Latin",
	"latin",
	"Latn",
	"latn",
	"Lepc",
	"lepc",
	"Lepcha",
	"lepcha",
	"Limb",
	"limb",
	"Limbu",
	"limbu",
	"Lina",
	"lina",
	"Linb",
	"linb",
	"Linear_A",
	"lineara",
	"Linear_B",
	"linearb",
	"Lisu",
	"lisu",
	"Lyci",
	"lyci",
	"Lycian",
	"lycian",
	"Lydi",
	"lydi",
	"Lydian",
	"lydian",
	"Mahajani",
	"mahajani",
	"Mahj",
	"mahj",
	"Maka",
	"maka",
	"Makasar",
	"makasar",
	"Malayalam",
	"malayalam",
	"Mand",
	"mand",
	"Mandaic",
	"mandaic",
	"Mani",
	"mani",
	"Manichaean",
	"manichaean",
	"Marc",
	"marc",
	"Marchen",
	"marchen",
	"Masaram_Gondi",
	"masaramgondi",
	"Medefaidrin",
	"medefaidrin",
	"Medf",
	"medf",
	"Meetei_Mayek",
	"meeteimayek",
	"Mend",
	"mend",
	"Mende_Kikakui",
	"mendekikakui",
	"Merc",
	"merc",
	"Mero",
	"mero",
	"Meroitic_Cursive",
	"meroiticcursive",
	"Meroitic_Hieroglyphs",
	"meroitichieroglyphs",
	"Miao",
	"miao",
	"Mlym",
	"mlym",
	"Modi",
	"modi",
	"Mong",
	"mong",
	"Mongolian",
	"mongolian",
	"Mro",
	"mro",
	"Mroo",
	"mroo",
	"Mtei",
	"mtei",
	"Mult",
	"mult",
	"Multani",
	"multani",
	"Myanmar",
	"myanmar",
	"Mymr",
	"mymr",
	"Nabataean",
	"nabataean",
	"Nand",
	"nand",
	"Nandinagari",
	"nandinagari",
	"Narb",
	"narb",
	"Nbat",
	"nbat",
	"Newa",
	"newa",
	"New_Tai_Lue",
	"newtailue",
	"Nko",
	"nko",
	"Nkoo",
	"nkoo",
	"Nshu",
	"nshu",
	"Nushu",
	"nushu",
	"Nyiakeng_Puachue_Hmong",
	"nyiakengpuachuehmong",
	"Ogam",
	"ogam",
	"Ogham",
	"ogham",
	"Ol_Chiki",
	"olchiki",
	"Olck",
	"olck",
	"Old_Hungarian",
	"oldhungarian",
	"Old_Italic",
	"olditalic",
	"Old_North_Arabian",
	"oldnortharabian",
	"Old_Permic",
	"oldpermic",
	"Old_Persian",
	"oldpersian",
	"Old_Sogdian",
	"oldsogdian",
	"Old_South_Arabian",
	"oldsoutharabian",
	"Old_Turkic",
	"oldturkic",
	"Old_Uyghur",
	"olduyghur",
	"Oriya",
	"oriya",
	"Orkh",
	"orkh",
	"Orya",
	"orya",
	"Osage",
	"osage",
	"Osge",
	"osge",
	"Osma",
	"osma",
	"Osmanya",
	"osmanya",
	"Ougr",
	"ougr",
	"Pahawh_Hmong",
	"pahawhhmong",
	"Palm",
	"palm",
	"Palmyrene",
	"palmyrene",
	"Pauc",
	"pauc",
	"Pau_Cin_Hau",
	"paucinhau",
	"Perm",
	"perm",
	"Phag",
	"phag",
	"Phags_Pa",
	"phagspa",
	"Phli",
	"phli",
	"Phlp",
	"phlp",
	"Phnx",
	"phnx",
	"Phoenician",
	"phoenician",
	"Plrd",
	"plrd",
	"Prti",
	"prti",
	"Psalter_Pahlavi",
	"psalterpahlavi",
	"Qaac",
	"qaac",
	"Qaai",
	"qaai",
	"Rejang",
	"rejang",
	"Rjng",
	"rjng",
	"Rohg",
	"rohg",
	"Runic",
	"runic",
	"Runr",
	"runr",
	"Samaritan",
	"samaritan",
	"Samr",
	"samr",
	"Sarb",
	"sarb",
	"Saur",
	"saur",
	"Saurashtra",
	"saurashtra",
	"Sgnw",
	"sgnw",
	"Sharada",
	"sharada",
	"Shavian",
	"shavian",
	"Shaw",
	"shaw",
	"Shrd",
	"shrd",
	"Sidd",
	"sidd",
	"Siddham",
	"siddham",
	"SignWriting",
	"signwriting",
	"Sind",
	"sind",
	"Sinh",
	"sinh",
	"Sinhala",
	"sinhala",
	"Sogd",
	"sogd",
	"Sogdian",
	"sogdian",
	"Sogo",
	"sogo",
	"Sora",
	"sora",
	"Sora_Sompeng",
	"sorasompeng",
	"Soyo",
	"soyo",
	"Soyombo",
	"soyombo",
	"Sund",
	"sund",
	"Sundanese",
	"sundanese",
	"Sylo",
	"sylo",
	"Syloti_Nagri",
	"sylotinagri",
	"Syrc",
	"syrc",
	"Syriac",
	"syriac",
	"Tagalog",
	"tagalog",
	"Tagb",
	"tagb",
	"Tagbanwa",
	"tagbanwa",
	"Tai_Le",
	"taile",
	"Tai_Tham",
	"taitham",
	"Tai_Viet",
	"taiviet",
	"Takr",
	"takr",
	"Takri",
	"takri",
	"Tale",
	"tale",
	"Talu",
	"talu",
	"Tamil",
	"tamil",
	"Taml",
	"taml",
	"Tang",
	"tang",
	"Tangsa",
	"tangsa",
	"Tangut",
	"tangut",
	"Tavt",
	"tavt",
	"Telu",
	"telu",
	"Telugu",
	"telugu",
	"Tfng",
	"tfng",
	"Tglg",
	"tglg",
	"Thaa",
	"thaa",
	"Thaana",
	"thaana",
	"Thai",
	"thai",
	"Tibetan",
	"tibetan",
	"Tibt",
	"tibt",
	"Tifinagh",
	"tifinagh",
	"Tirh",
	"tirh",
	"Tirhuta",
	"tirhuta",
	"Tnsa",
	"tnsa",
	"Toto",
	"toto",
	"Ugar",
	"ugar",
	"Ugaritic",
	"ugaritic",
	"Unknown",
	"unknown",
	"Vai",
	"vai",
	"Vaii",
	"vaii",
	"Vith",
	"vith",
	"Vithkuqi",
	"vithkuqi",
	"Wancho",
	"wancho",
	"Wara",
	"wara",
	"Warang_Citi",
	"warangciti",
	"Wcho",
	"wcho",
	"Xpeo",
	"xpeo",
	"Xsux",
	"xsux",
	"Yezi",
	"yezi",
	"Yezidi",
	"yezidi",
	"Yi",
	"yi",
	"Yiii",
	"yiii",
	"Zanabazar_Square",
	"zanabazarsquare",
	"Zanb",
	"zanb",
	"Zinh",
	"zinh",
	"Zyyy",
	"zyyy",
	"Zzzz",
	"zzzz",
	NULL
};

static const char * const UNI_vo_values[] = {
	"R",
	"r",
	"Rotated",
	"rotated",
	"Tr",
	"tr",
	"Transformed_Rotated",
	"transformedrotated",
	"Transformed_Upright",
	"transformedupright",
	"Tu",
	"tu",
	"U",
	"u",
	"Upright",
	"upright",
	NULL
};

static const char * const UNI_wb_values[] = {
	"ALetter",
	"aletter",
	"CR",
	"cr",
	"Double_Quote",
	"doublequote",
	"DQ",
	"dq",
	"EB",
	"eb",
	"E_Base",
	"ebase",
	"E_Base_GAZ",
	"ebasegaz",
	"EBG",
	"ebg",
	"EM",
	"em",
	"E_Modifier",
	"emodifier",
	"EX",
	"ex",
	"Extend",
	"extend",
	"ExtendNumLet",
	"extendnumlet",
	"FO",
	"fo",
	"Format",
	"format",
	"GAZ",
	"gaz",
	"Glue_After_Zwj",
	"glueafterzwj",
	"Hebrew_Letter",
	"hebrewletter",
	"HL",
	"hl",
	"KA",
	"ka",
	"Katakana",
	"katakana",
	"LE",
	"le",
	"LF",
	"lf",
	"MB",
	"mb",
	"MidLetter",
	"midletter",
	"MidNum",
	"midnum",
	"MidNumLet",
	"midnumlet",
	"ML",
	"ml",
	"MN",
	"mn",
	"Newline",
	"newline",
	"NL",
	"nl",
	"NU",
	"nu",
	"Numeric",
	"numeric",
	"Other",
	"other",
	"Regional_Indicator",
	"regionalindicator",
	"RI",
	"ri",
	"Single_Quote",
	"singlequote",
	"SQ",
	"sq",
	"WSegSpace",
	"wsegspace",
	"XX",
	"xx",
	"ZWJ",
	"zwj",
	NULL
};

static const char * const * const UNI_prop_value_ptrs[] = {
NULL /* Placeholder so zero index is an error */,
UNI_age_values,
UNI_ahex_values,
UNI_bc_values,
UNI_blk_values,
UNI_bpt_values,
UNI_ccc_values,
UNI_dt_values,
UNI_ea_values,
UNI_gc_values,
UNI_gcb_values,
UNI_hst_values,
UNI_identifierstatus_values,
UNI_identifiertype_values,
UNI_inpc_values,
UNI_insc_values,
UNI_jg_values,
UNI_jt_values,
UNI_lb_values,
UNI_nfcqc_values,
UNI_nfdqc_values,
UNI_nt_values,
UNI_nv_values,
UNI_sb_values,
UNI_sc_values,
UNI_vo_values,
UNI_wb_values
};


#define UNI_age_values_index  1
#define UNI_ahex_values_index  2
#define UNI_alpha_values_index  UNI_ahex_values_index
#define UNI_bc_values_index  3
#define UNI_bidic_values_index  UNI_ahex_values_index
#define UNI_bidim_values_index  UNI_ahex_values_index
#define UNI_blk_values_index  4
#define UNI_bpt_values_index  5
#define UNI_cased_values_index  UNI_ahex_values_index
#define UNI_ccc_values_index  6
#define UNI_ce_values_index  UNI_ahex_values_index
#define UNI_ci_values_index  UNI_ahex_values_index
#define UNI_compex_values_index  UNI_ahex_values_index
#define UNI_cwcf_values_index  UNI_ahex_values_index
#define UNI_cwcm_values_index  UNI_ahex_values_index
#define UNI_cwkcf_values_index  UNI_ahex_values_index
#define UNI_cwl_values_index  UNI_ahex_values_index
#define UNI_cwt_values_index  UNI_ahex_values_index
#define UNI_cwu_values_index  UNI_ahex_values_index
#define UNI_dash_values_index  UNI_ahex_values_index
#define UNI_dep_values_index  UNI_ahex_values_index
#define UNI_di_values_index  UNI_ahex_values_index
#define UNI_dia_values_index  UNI_ahex_values_index
#define UNI_dt_values_index  7
#define UNI_ea_values_index  8
#define UNI_ebase_values_index  UNI_ahex_values_index
#define UNI_ecomp_values_index  UNI_ahex_values_index
#define UNI_emod_values_index  UNI_ahex_values_index
#define UNI_emoji_values_index  UNI_ahex_values_index
#define UNI_epres_values_index  UNI_ahex_values_index
#define UNI_ext_values_index  UNI_ahex_values_index
#define UNI_extpict_values_index  UNI_ahex_values_index
#define UNI_gc_values_index  9
#define UNI_gcb_values_index  10
#define UNI_grbase_values_index  UNI_ahex_values_index
#define UNI_grext_values_index  UNI_ahex_values_index
#define UNI_hex_values_index  UNI_ahex_values_index
#define UNI_hst_values_index  11
#define UNI_hyphen_values_index  UNI_ahex_values_index
#define UNI_idc_values_index  UNI_ahex_values_index
#define UNI_identifierstatus_values_index  12
#define UNI_identifiertype_values_index  13
#define UNI_ideo_values_index  UNI_ahex_values_index
#define UNI_ids_values_index  UNI_ahex_values_index
#define UNI_idsb_values_index  UNI_ahex_values_index
#define UNI_idst_values_index  UNI_ahex_values_index
#define UNI_in_values_index  UNI_age_values_index
#define UNI_inpc_values_index  14
#define UNI_insc_values_index  15
#define UNI_jg_values_index  16
#define UNI_joinc_values_index  UNI_ahex_values_index
#define UNI_jt_values_index  17
#define UNI_lb_values_index  18
#define UNI_loe_values_index  UNI_ahex_values_index
#define UNI_lower_values_index  UNI_ahex_values_index
#define UNI_math_values_index  UNI_ahex_values_index
#define UNI_nchar_values_index  UNI_ahex_values_index
#define UNI_nfcqc_values_index  19
#define UNI_nfdqc_values_index  20
#define UNI_nfkcqc_values_index  UNI_nfcqc_values_index
#define UNI_nfkdqc_values_index  UNI_nfdqc_values_index
#define UNI_nt_values_index  21
#define UNI_nv_values_index  22
#define UNI_patsyn_values_index  UNI_ahex_values_index
#define UNI_patws_values_index  UNI_ahex_values_index
#define UNI_pcm_values_index  UNI_ahex_values_index
#define UNI_qmark_values_index  UNI_ahex_values_index
#define UNI_radical_values_index  UNI_ahex_values_index
#define UNI_ri_values_index  UNI_ahex_values_index
#define UNI_sb_values_index  23
#define UNI_sc_values_index  24
#define UNI_scx_values_index  UNI_sc_values_index
#define UNI_sd_values_index  UNI_ahex_values_index
#define UNI_sterm_values_index  UNI_ahex_values_index
#define UNI_term_values_index  UNI_ahex_values_index
#define UNI_uideo_values_index  UNI_ahex_values_index
#define UNI_upper_values_index  UNI_ahex_values_index
#define UNI_vo_values_index  25
#define UNI_vs_values_index  UNI_ahex_values_index
#define UNI_wb_values_index  26
#define UNI_wspace_values_index  UNI_ahex_values_index
#define UNI_xidc_values_index  UNI_ahex_values_index
#define UNI_xids_values_index  UNI_ahex_values_index

#endif	/* (defined(PERL_IN_REGCOMP_C) && ! defined(PERL_IN_XSUB_RE)) */

#if defined(PERL_IN_REGEXEC_C)

#define GCB_NOBREAK                0
#define GCB_BREAKABLE              1
#define GCB_RI_then_RI             2
#define GCB_EX_then_EM             3
#define GCB_Maybe_Emoji_NonBreak   4

static const U8 GCB_table[17][17] = {
   /* 'edg' stands for 'EDGE'; 'EPX' stands for 'ExtPict_XX'; u
    * stands for 'unused in this Unicode release (and the data in
    * its row and column are garbage) */
/*        XX CN CR edg EPX EX  L LF LV LVT PP RI SM  T  V ZWJ  u */
/* XX */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 1 },
/* CN */ { 1, 1, 1,  1,  1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1,  1, 1 },
/* CR */ { 1, 1, 1,  1,  1, 1, 1, 0, 1,  1, 1, 1, 1, 1, 1,  1, 1 },
/* edg*/ { 1, 1, 1,  0,  1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1,  1, 1 },
/* EPX*/ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 1 },
/* EX */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 3 },
/* L  */ { 1, 1, 1,  1,  1, 0, 0, 1, 0,  0, 1, 1, 0, 1, 0,  0, 1 },
/* LF */ { 1, 1, 1,  1,  1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1,  1, 1 },
/* LV */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 0, 0,  0, 1 },
/* LVT*/ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 0, 1,  0, 1 },
/* PP */ { 0, 1, 1,  1,  0, 0, 0, 1, 0,  0, 0, 0, 0, 0, 0,  0, 0 },
/* RI */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 2, 0, 1, 1,  0, 1 },
/* SM */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 1 },
/* T  */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 0, 1,  0, 1 },
/* V  */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 0, 0,  0, 1 },
/* ZWJ*/ { 1, 1, 1,  1,  4, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 0 },
/* u  */ { 1, 1, 1,  1,  1, 0, 1, 1, 1,  1, 1, 1, 0, 1, 1,  0, 0 }
};

#define LB_NOBREAK                        0
#define LB_BREAKABLE                      1
#define LB_NOBREAK_EVEN_WITH_SP_BETWEEN   2
#define LB_CM_ZWJ_foo                     3
#define LB_SP_foo                         6
#define LB_PR_or_PO_then_OP_or_HY         9
#define LB_SY_or_IS_then_various         11
#define LB_HY_or_BA_then_foo             13
#define LB_RI_then_RI                    15
#define LB_various_then_PO_or_PR         32

static const U8 LB_table[42][42] = {
   /* 'EAO' stands for 'East_Asian_OP'; 'edg' stands for 'EDGE'; 'UEP' stands for 'Unassigned_Extended_Pictographic_Ideographic'; u stands for
    * 'unused in this Unicode release (and the data in its row and column are garbage) */
/*        AL B2 BA BB BK CB CL CM CP CR EAO EB edg EM EX GL H2 H3 HL HY ID IN IS JL JT JV LF NL NS NU OP PO PR QU RI SP SY UEP WJ ZW ZWJ  u */
/* AL */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* B2 */ { 1, 2, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* BA */ {14,14, 0,14, 0, 1, 2, 0, 2, 0, 14,14,  1,14, 2,14,14,14,14, 0,14,13, 2,14,14,14, 0, 0, 0,14,14,14,14, 0,14, 0, 2, 14, 0, 0,  0, 2 },
/* BB */ { 0, 0, 0, 0, 0, 1, 2, 0, 2, 0,  0, 0,  1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,  0, 0, 0,  0, 2 },
/* BK */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1,  1, 1 },
/* CB */ { 1, 1, 1, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* CL */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 2, 1, 1,33,33, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* CM */ { 3, 3, 3, 3, 0, 3, 3, 0, 3, 0,  3, 3,  1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 3, 3, 3, 3, 3, 3, 3, 0, 3,  3, 3, 0,  3, 3 },
/* CP */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 2, 0, 1,33,33, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* CR */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1,  1, 1 },
/* EAO*/ { 2, 2, 2, 2, 0, 2, 2, 2, 2, 0,  2, 2,  1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2,  2, 2, 0,  2, 2 },
/* EB */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 0, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* edg*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0,  0, 0 },
/* EM */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* EX */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* GL */ { 0, 0, 0, 0, 0, 0, 2, 0, 2, 0,  0, 0,  1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,  0, 0, 0,  0, 2 },
/* H2 */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* H3 */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* HL */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* HY */ {14,14, 0,14, 0, 1, 2, 0, 2, 0, 14,14,  1,14, 2,14,14,14,14, 0,14,13, 2,14,14,14, 0, 0, 0,13,14,14,14, 0,14, 0, 2, 14, 0, 0,  0, 2 },
/* ID */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* IN */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* IS */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0,12, 1,33,33, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* JL */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 0, 0, 1, 0, 1, 0, 2, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* JT */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* JV */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* LF */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1,  1, 1 },
/* NL */ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1,  1, 1 },
/* NS */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* NU */ { 0, 1, 0, 1, 0, 1, 0, 0, 0, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,  1, 0, 0,  0, 0 },
/* OP */ { 2, 2, 2, 2, 0, 2, 2, 2, 2, 0,  2, 2,  1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2,  2, 2, 0,  2, 2 },
/* PO */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 0,10, 1, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* PR */ { 0, 1, 0, 1, 0, 1, 2, 0, 2, 0, 10, 0,  1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,10, 1, 1, 0, 1, 0, 2,  0, 0, 0,  0, 2 },
/* QU */ { 0, 0, 0, 0, 0, 0, 2, 0, 2, 0,  2, 0,  1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2,  0, 0, 0,  0, 2 },
/* RI */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,15, 0, 2,  1, 0, 0,  0, 2 },
/* SP */ { 7, 7, 7, 7, 0, 7, 8, 7, 8, 0,  7, 7,  1, 7, 8, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 0, 0, 7, 7, 7, 7, 7, 7, 7, 0, 8,  7, 8, 0,  7, 8 },
/* SY */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0,12, 1,33,33, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* UEP*/ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 0, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 2,  1, 0, 0,  0, 2 },
/* WJ */ { 0, 0, 0, 0, 0, 0, 2, 0, 2, 0,  0, 0,  1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,  0, 0, 0,  0, 2 },
/* ZW */ { 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,  1, 1, 0,  1, 1 },
/* ZWJ*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0,  0, 0 },
/* u  */ { 1, 1, 0, 1, 0, 1, 2, 0, 2, 0,  1, 1,  1, 1, 2, 0, 1, 1, 1, 0, 1, 0, 2, 1, 1, 1, 0, 0, 2, 1, 1,33,33, 0, 1, 0, 2,  1, 0, 0,  0, 2 }
};

#define WB_NOBREAK                        0
#define WB_BREAKABLE                      1
#define WB_hs_then_hs                     2
#define WB_Ex_or_FO_or_ZWJ_then_foo       3
#define WB_DQ_then_HL                     4
#define WB_HL_then_DQ                     6
#define WB_LE_or_HL_then_MB_or_ML_or_SQ   8
#define WB_MB_or_ML_or_SQ_then_LE_or_HL  10
#define WB_MB_or_MN_or_SQ_then_NU        12
#define WB_NU_then_MB_or_MN_or_SQ        14
#define WB_RI_then_RI                    16

static const U8 WB_table[23][23] = {
   /* 'edg' stands for 'EDGE'; 'EPL' stands for 'ExtPict_LE'; 'EPX' stands for
    * 'ExtPict_XX'; 'Ext' stands for 'Extend'; 'hs' stands for 'Perl_Tailored_HSpace';
    * u stands for 'unused in this Unicode release (and the data in its row and column
    * are garbage) */
/*        XX CR DQ edg EPL EPX EX Ext FO HL hs KA LE LF MB ML MN NL NU RI SQ ZWJ  u */
/* XX */ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  0, 1 },
/* CR */ { 1, 0, 1,  1,  1,  1, 1,  1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,  1, 1 },
/* DQ */ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  0, 1 },
/* edg*/ { 1, 1, 1,  0,  1,  1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1, 1 },
/* EPL*/ { 1, 1, 1,  1,  0,  1, 0,  0, 0, 0, 1, 1, 0, 1, 9, 9, 1, 1, 0, 1, 9,  0, 1 },
/* EPX*/ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  0, 1 },
/* EX */ { 1, 1, 1,  1,  0,  1, 0,  0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1,  0, 1 },
/* Ext*/ { 3, 1, 3,  1,  3,  3, 3,  0, 0, 3, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3,  0, 3 },
/* FO */ { 3, 1, 3,  1,  3,  3, 3,  0, 0, 3, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3,  0, 3 },
/* HL */ { 1, 1, 7,  1,  0,  1, 0,  0, 0, 0, 1, 1, 0, 1, 9, 9, 1, 1, 0, 1, 8,  0, 1 },
/* hs */ { 1, 0, 1,  1,  1,  1, 1,  0, 0, 1, 2, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,  0, 1 },
/* KA */ { 1, 1, 1,  1,  1,  1, 0,  0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,  0, 1 },
/* LE */ { 1, 1, 1,  1,  1,  1, 0,  0, 0, 0, 1, 1, 0, 1, 9, 9, 1, 1, 0, 1, 9,  0, 1 },
/* LF */ { 1, 0, 1,  1,  1,  1, 1,  1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,  1, 1 },
/* MB */ { 1, 1, 1,  1, 11,  1, 1,  0, 0,11, 1, 1,11, 1, 1, 1, 1, 1,13, 1, 1,  0, 1 },
/* ML */ { 1, 1, 1,  1, 11,  1, 1,  0, 0,11, 1, 1,11, 1, 1, 1, 1, 1, 1, 1, 1,  0, 1 },
/* MN */ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,13, 1, 1,  0, 1 },
/* NL */ { 1, 0, 1,  1,  1,  1, 1,  1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,  1, 1 },
/* NU */ { 1, 1, 1,  1,  0,  1, 0,  0, 0, 0, 1, 1, 0, 1,15, 1,15, 1, 0, 1,15,  0, 1 },
/* RI */ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,16, 1,  0, 1 },
/* SQ */ { 1, 1, 1,  1, 11,  1, 1,  0, 0,11, 1, 1,11, 1, 1, 1, 1, 1,13, 1, 1,  0, 1 },
/* ZWJ*/ { 3, 1, 3,  1,  0,  0, 3,  0, 0, 3, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3,  0, 0 },
/* u  */ { 1, 1, 1,  1,  1,  1, 1,  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  0, 0 }
};

#endif	/* defined(PERL_IN_REGEXEC_C) */

/* More than one code point may have the same code point as their fold.  This
 * gives the maximum number in the current Unicode release.  (The folded-to
 * code point is not included in this count.)  For example, both 'S' and
 * \x{17F} fold to 's', so the number for that fold is 2.  Another way to
 * look at it is the maximum length of all the IVCF_AUX_TABLE's */
#define MAX_FOLD_FROMS 3

/* Generated from:
 * 688d673ec947f7ccf898b4eae9848139d4d33676b688dee54f449f8bf9d3bbd2 lib/Unicode/UCD.pm
 * c7698811e9adb6cc98fb996a7de4be2b6532f2ac67e76055cc8afdbf6ee18af3 lib/unicore/ArabicShaping.txt
 * 24a74555f918bbe99f5b3f1b83cf36fc0e205bb8a600a6a3aa539c710a3dcf27 lib/unicore/BidiBrackets.txt
 * 7a5c74cedc1616a9af0a9d22e108ae592d86fe93649c144ae6ba49f193a44122 lib/unicore/BidiMirroring.txt
 * 598870dddef7b34b5a972916528c456aff2765b79cd4f9647fb58ceb767e7f17 lib/unicore/Blocks.txt
 * a566cd48687b2cd897e02501118b2413c14ae86d318f9abbbba97feb84189f0f lib/unicore/CaseFolding.txt
 * 3360762fc3295cea54ab251c31df621d05ba4b94d46c60eaac29aa16d70ad1e0 lib/unicore/CompositionExclusions.txt
 * 7e058dec02147098bc9c28d86209f0f251bba0538f3b5a705ad02ea3bb709fe0 lib/unicore/DAge.txt
 * e3eddd7d469cd1b0feed7528defad1a1cc7c6a9ceb0ae4446a6d10921ed2e7bc lib/unicore/DCoreProperties.txt
 * b2c444c20730b097787fdf50bd7d6dd3fc5256ab8084f5b35b11c8776eca674c lib/unicore/DNormalizationProps.txt
 * f901ac011aa32a09224d6555da71e2532c59c1d3381322829de0e3b880507250 lib/unicore/EastAsianWidth.txt
 * 5995522f01633073911dad1edb74d13aa832f42862c0392a79627b85d52f2391 lib/unicore/EquivalentUnifiedIdeograph.txt
 * cd1c9367cba438afa965fcb5edc6ed3ec6e685fd5dd21c0cc20c026f04beb0e5 lib/unicore/HangulSyllableType.txt
 * 3f3f368fccdb37f350ecedc20b37fa71ab31c04e847884c77780d34283539f73 lib/unicore/IdStatus.txt
 * 45a150c23961b58d7784704af6c4daccd6517d97b6489e53d13bbdbf9e4f065f lib/unicore/IdType.txt
 * d8704c8725568813a947ff2ef38bcf1f05e2a6fbea6876ba384890f187a8bf61 lib/unicore/IndicPositionalCategory.txt
 * c7b969b653dc278fb66ab4136223d320e30ad19367eb791ae60dcc6d92071b16 lib/unicore/IndicSyllabicCategory.txt
 * 39ff89e0a329e1ccce6d54fad8cf82e90926901928c0ca9b9a2ad5681f330dd9 lib/unicore/Jamo.txt
 * 9e06e9f35c6959fb91dcc7993f90d58523c3079bc62c6b25f828b4cdebc5d70c lib/unicore/LineBreak.txt
 * 14b3b677d33f95c51423dce6eef4a6a28b4b160451ecedee4b91edb6745cf4a3 lib/unicore/NameAliases.txt
 * db5745688affcdc0c3927a1ee0667018a96a7b24513f866d5235e98fef6c2436 lib/unicore/NamedSequences.txt
 * 6bddfdb850417a5bee6deff19290fd1b138589909afb50f5a049f343bf2c6722 lib/unicore/PropList.txt
 * eb755757e20b72b330b2948df3cf2ff7adb0e31bb060140dc09dafb132ace2cd lib/unicore/PropValueAliases.txt
 * 859d7225f2d2a460b3ccb1d61a7945f8cc219acdf5aa53b66b7a1e4bf6ebfc87 lib/unicore/PropertyAliases.txt
 * d37eedf63ff9c48bac863d5f76862373d6cf5269fd21253d499e2430d638c01d lib/unicore/ScriptExtensions.txt
 * 52db475c4ec445e73b0b16915448c357614946ad7062843c563e00d7535c6510 lib/unicore/Scripts.txt
 * c667b45908fd269af25fd55d2fc5bbc157fb1b77675936e25c513ce32e080334 lib/unicore/SpecialCasing.txt
 * 36018e68657fdcb3485f636630ffe8c8532e01c977703d2803f5b89d6c5feafb lib/unicore/UnicodeData.txt
 * 869ff43dd012f924d03c89fc268c88f0e7eea72f0228b91ca30455afdb84f8fd lib/unicore/VerticalOrientation.txt
 * ddc7d4d1f3838573b94fc5d83ff7217e63c47b22ae1cd40c5fe1a54efc15589b lib/unicore/auxiliary/GCBTest.txt
 * 97e79f1f8d9cd76d120f2420381a01abc00a7c78a2aa583fa3f9627264a99742 lib/unicore/auxiliary/GraphemeBreakProperty.txt
 * 488dbb6a7e1d0070d4aa7c175352c818ff6425172850d1b40c6177726658cb05 lib/unicore/auxiliary/LBTest.txt
 * 7e42dd749dbb94aa44b13faf9df6319d9a16ce2ea09a3a094fcfbb5962168040 lib/unicore/auxiliary/SBTest.txt
 * 7092ca4117cec891c25c7724132efc519e1dece01ae9fd6068035a9db04d526e lib/unicore/auxiliary/SentenceBreakProperty.txt
 * 8094b544ec1580c7e41ac0187805cc1aeb330a90301ec7505563e1a59318284e lib/unicore/auxiliary/WBTest.txt
 * 7716752aad296d4ab23ff4ed0a2746fc5328750ff84e9e7d6f3828ee9eaef742 lib/unicore/auxiliary/WordBreakProperty.txt
 * b597836124298b8f7fa076273802840cfc3271a25f5c397a082e120954b82c3c lib/unicore/emoji/emoji.txt
 * e5fe51acc74e3e83b4fb4c7b25f3c34491d6eb8095c9955d0712dafbca7b3c2b lib/unicore/extracted/DBidiClass.txt
 * cd0a14176d93bf440b77a582a0d678190fc0688b15442d4cfb250bf2e27956af lib/unicore/extracted/DBinaryProperties.txt
 * 12b0c3af9b600b49488d66545a3e7844ea980809627201bf9afeebe1c9f16f4e lib/unicore/extracted/DCombiningClass.txt
 * f76064b298cfbd715ba542e7894f7a507d32da2f011070d1d01df95cad9817d6 lib/unicore/extracted/DDecompositionType.txt
 * f9bef074cc916db57fece99d54a4505f8e7c7b17481619e3f0005211f7717d4b lib/unicore/extracted/DEastAsianWidth.txt
 * cde679c8461976ed40d7edf61ae98cbb947540831f06f5bc7da7decbf91a1420 lib/unicore/extracted/DGeneralCategory.txt
 * 9bb891831328713603a486a4a03df7f7987c3e1e8144a6d1ac71fd061ef3f732 lib/unicore/extracted/DJoinGroup.txt
 * e97c65bbea0a69d2fae6ec4182b09e519e13232e20bd804b3004edc0f36bb0d4 lib/unicore/extracted/DJoinType.txt
 * 43f6df50e4878f501b417e366b0ee097ae5ccb2d4ce942026bed3d62d78e7887 lib/unicore/extracted/DLineBreak.txt
 * a04502ebb36a45d83cbe48a7d8132ea8143edb7b3d34d0aa6afe4a9685049741 lib/unicore/extracted/DNumType.txt
 * 11075771b112e8e7ccf6ffa637c4c91eadc3ef3db0517b24e605df8fd3624239 lib/unicore/extracted/DNumValues.txt
 * 1e514199c3fa46f5df6148d272db7bddbfd5e89c9710e39773ef9d734f344a2f lib/unicore/mktables
 * c72bbdeda99714db1c8024d3311da4aef3c0db3b9b9f11455a7cfe10d5e9aba3 lib/unicore/version
 * 0a6b5ab33bb1026531f816efe81aea1a8ffcd34a27cbea37dd6a70a63d73c844 regen/charset_translations.pl
 * 5f8520d3a17ade6317fc0c423f5091470924b1ef425bca0c41ce8e4a9f8460fe regen/mk_PL_charclass.pl
 * 1c73795f9150bd556573e7ae982789377289e22b6a7f3db0a05c36852e8d749f regen/mk_invlists.pl
 * ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /*    hv.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999,
 *    2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/* These control hash traversal randomization and the environment variable PERL_PERTURB_KEYS.
 * Currently disabling this functionality will break a few tests, but should otherwise work fine.
 * See perlrun for more details. */

#if defined(PERL_PERTURB_KEYS_DISABLED)
#   define PL_HASH_RAND_BITS_ENABLED        0
#   define PERL_HASH_ITER_BUCKET(iter)      ((iter)->xhv_riter)
#else
#   define PERL_HASH_RANDOMIZE_KEYS         1
#   if defined(PERL_PERTURB_KEYS_RANDOM)
#       define PL_HASH_RAND_BITS_ENABLED    1
#   elif defined(PERL_PERTURB_KEYS_DETERMINISTIC)
#       define PL_HASH_RAND_BITS_ENABLED    2
#   else
#       define USE_PERL_PERTURB_KEYS        1
#       define PL_HASH_RAND_BITS_ENABLED    PL_hash_rand_bits_enabled
#   endif
#   define PERL_HASH_ITER_BUCKET(iter)      (((iter)->xhv_riter) ^ ((iter)->xhv_rand))
#endif

#ifdef PERL_USE_UNSHARED_KEYS_IN_LARGE_HASHES
#define LARGE_HASH_HEURISTIC(hv,new_max) S_large_hash_heuristic(aTHX_ (hv), (new_max))
#else
#define LARGE_HASH_HEURISTIC(hv,new_max) 0
#endif


/* entry in hash value chain */
struct he {
    /* Keep hent_next first in this structure, because sv_free_arenas take
       advantage of this to share code between the he arenas and the SV
       body arenas  */
    HE		*hent_next;	/* next entry in chain */
    HEK		*hent_hek;	/* hash key */
    union {
        SV	*hent_val;	/* scalar value that was hashed */
        Size_t	hent_refcount;	/* references for this shared hash key */
    } he_valu;
};

/* hash key -- defined separately for use as shared pointer */
struct hek {
    U32         hek_hash;        /* computed hash of key */
    I32         hek_len;        /* length of the hash key */
    /* Be careful! Sometimes we store a pointer in the hek_key
     * buffer, which means it must be 8 byte aligned or things
     * dont work on aligned platforms like HPUX
     * Also beware, the last byte of the hek_key buffer is a
     * hidden flags byte about the key. */
     char       hek_key[1];        /* variable-length hash key */
    /* the hash-key is \0-terminated */
    /* after the \0 there is a byte for flags, such as whether the key
       is UTF-8 or WAS-UTF-8, or an SV */
};

struct shared_he {
    struct he shared_he_he;
    struct hek shared_he_hek;
};

/* Subject to change.
   Don't access this directly.
   Use the funcs in mro_core.c
*/

struct mro_alg {
    AV *(*resolve)(pTHX_ HV* stash, U32 level);
    const char *name;
    U16 length;
    U16	kflags;	/* For the hash API - set HVhek_UTF8 if name is UTF-8 */
    U32 hash; /* or 0 */
};

struct mro_meta {
    /* a hash holding the different MROs private data.  */
    HV      *mro_linear_all;
    /* a pointer directly to the current MROs private data.  If mro_linear_all
       is NULL, this owns the SV reference, else it is just a pointer to a
       value stored in and owned by mro_linear_all.  */
    SV      *mro_linear_current;
    HV      *mro_nextmethod; /* next::method caching */
    U32     cache_gen;       /* Bumping this invalidates our method cache */
    U32     pkg_gen;         /* Bumps when local methods/@ISA change */
    const struct mro_alg *mro_which; /* which mro alg is in use? */
    HV      *isa;            /* Everything this class @ISA */
    HV      *super;          /* SUPER method cache */
    CV      *destroy;        /* DESTROY method if destroy_gen non-zero */
    U32     destroy_gen;     /* Generation number of DESTROY cache */
};

#define MRO_GET_PRIVATE_DATA(smeta, which)		   \
    (((smeta)->mro_which && (which) == (smeta)->mro_which) \
     ? (smeta)->mro_linear_current			   \
     : Perl_mro_get_private_data(aTHX_ (smeta), (which)))

/* Subject to change.
   Don't access this directly.
*/

union _xhvnameu {
    HEK *xhvnameu_name;		/* When xhv_name_count is 0 */
    HEK **xhvnameu_names;	/* When xhv_name_count is non-0 */
};

struct xpvhv_aux {
    union _xhvnameu xhv_name_u;	/* name, if a symbol table */
    AV		*xhv_backreferences; /* back references for weak references */
    HE		*xhv_eiter;	/* current entry of iterator */
    I32		xhv_riter;	/* current root of iterator */

/* Concerning xhv_name_count: When non-zero, xhv_name_u contains a pointer 
 * to an array of HEK pointers, this being the length. The first element is
 * the name of the stash, which may be NULL. If xhv_name_count is positive,
 * then *xhv_name is one of the effective names. If xhv_name_count is nega-
 * tive, then xhv_name_u.xhvnameu_names[1] is the first effective name.
 */
    I32		xhv_name_count;
    struct mro_meta *xhv_mro_meta;
#ifdef PERL_HASH_RANDOMIZE_KEYS
    U32         xhv_rand;       /* random value for hash traversal */
    U32         xhv_last_rand;  /* last random value for hash traversal,
                                   used to detect each() after insert for warnings */
#endif
    U32         xhv_aux_flags;      /* assorted extra flags */
};

#define HvAUXf_SCAN_STASH   0x1   /* stash is being scanned by gv_check */
#define HvAUXf_NO_DEREF     0x2   /* @{}, %{} etc (and nomethod) not present */

/* hash structure: */
/* This structure must match the beginning of struct xpvmg in sv.h. */
struct xpvhv {
    HV*		xmg_stash;	/* class package */
    union _xmgu	xmg_u;
    STRLEN      xhv_keys;       /* total keys, including placeholders */
    STRLEN      xhv_max;        /* subscript of last element of xhv_array */
};

struct xpvhv_with_aux {
    HV         *xmg_stash;      /* class package */
    union _xmgu xmg_u;
    STRLEN      xhv_keys;       /* total keys, including placeholders */
    STRLEN      xhv_max;        /* subscript of last element of xhv_array */
    struct xpvhv_aux xhv_aux;
};

/*
=for apidoc AmnU||HEf_SVKEY
This flag, used in the length slot of hash entries and magic structures,
specifies the structure contains an C<SV*> pointer where a C<char*> pointer
is to be expected.  (For information only--not to be used).

=for apidoc ADmnU||Nullhv
Null HV pointer.

(deprecated - use C<(HV *)NULL> instead)

=for apidoc Am|char*|HvNAME|HV* stash
Returns the package name of a stash, or C<NULL> if C<stash> isn't a stash.
See C<L</SvSTASH>>, C<L</CvSTASH>>.

=for apidoc Am|STRLEN|HvNAMELEN|HV *stash
Returns the length of the stash's name.

Disfavored forms of HvNAME and HvNAMELEN; suppress mention of them
=for apidoc Cmh|char*|HvNAME_get|HV* stash
=for apidoc Amh|I32|HvNAMELEN_get|HV* stash

=for apidoc Am|unsigned char|HvNAMEUTF8|HV *stash
Returns true if the name is in UTF-8 encoding.

=for apidoc Am|char*|HvENAME|HV* stash
Returns the effective name of a stash, or NULL if there is none.  The
effective name represents a location in the symbol table where this stash
resides.  It is updated automatically when packages are aliased or deleted.
A stash that is no longer in the symbol table has no effective name.  This
name is preferable to C<HvNAME> for use in MRO linearisations and isa
caches.

=for apidoc Am|STRLEN|HvENAMELEN|HV *stash
Returns the length of the stash's effective name.

=for apidoc Am|unsigned char|HvENAMEUTF8|HV *stash
Returns true if the effective name is in UTF-8 encoding.

=for apidoc Am|void*|HeKEY|HE* he
Returns the actual pointer stored in the key slot of the hash entry.  The
pointer may be either C<char*> or C<SV*>, depending on the value of
C<HeKLEN()>.  Can be assigned to.  The C<HePV()> or C<HeSVKEY()> macros are
usually preferable for finding the value of a key.

=for apidoc Am|STRLEN|HeKLEN|HE* he
If this is negative, and amounts to C<HEf_SVKEY>, it indicates the entry
holds an C<SV*> key.  Otherwise, holds the actual length of the key.  Can
be assigned to.  The C<HePV()> macro is usually preferable for finding key
lengths.

=for apidoc Am|SV*|HeVAL|HE* he
Returns the value slot (type C<SV*>)
stored in the hash entry.  Can be assigned
to.

  SV *foo= HeVAL(hv);
  HeVAL(hv)= sv;


=for apidoc Am|U32|HeHASH|HE* he
Returns the computed hash stored in the hash entry.

=for apidoc Am|char*|HePV|HE* he|STRLEN len
Returns the key slot of the hash entry as a C<char*> value, doing any
necessary dereferencing of possibly C<SV*> keys.  The length of the string
is placed in C<len> (this is a macro, so do I<not> use C<&len>).  If you do
not care about what the length of the key is, you may use the global
variable C<PL_na>, though this is rather less efficient than using a local
variable.  Remember though, that hash keys in perl are free to contain
embedded nulls, so using C<strlen()> or similar is not a good way to find
the length of hash keys.  This is very similar to the C<SvPV()> macro
described elsewhere in this document.  See also C<L</HeUTF8>>.

If you are using C<HePV> to get values to pass to C<newSVpvn()> to create a
new SV, you should consider using C<newSVhek(HeKEY_hek(he))> as it is more
efficient.

=for apidoc Am|U32|HeUTF8|HE* he
Returns whether the C<char *> value returned by C<HePV> is encoded in UTF-8,
doing any necessary dereferencing of possibly C<SV*> keys.  The value returned
will be 0 or non-0, not necessarily 1 (or even a value with any low bits set),
so B<do not> blindly assign this to a C<bool> variable, as C<bool> may be a
typedef for C<char>.

=for apidoc Am|SV*|HeSVKEY|HE* he
Returns the key as an C<SV*>, or C<NULL> if the hash entry does not
contain an C<SV*> key.

=for apidoc Am|SV*|HeSVKEY_force|HE* he
Returns the key as an C<SV*>.  Will create and return a temporary mortal
C<SV*> if the hash entry contains only a C<char*> key.

=for apidoc Am|SV*|HeSVKEY_set|HE* he|SV* sv
Sets the key to a given C<SV*>, taking care to set the appropriate flags to
indicate the presence of an C<SV*> key, and returns the same
C<SV*>.

=cut
*/

#define PERL_HASH_DEFAULT_HvMAX 7

/* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */
#define HEf_SVKEY	-2	/* hent_key is an SV* */

#ifndef PERL_CORE
#  define Nullhv Null(HV*)
#endif
#define HvARRAY(hv)	((hv)->sv_u.svu_hash)

/*

=for apidoc Am|STRLEN|HvFILL|HV *const hv

Returns the number of hash buckets that happen to be in use.

As of perl 5.25 this function is used only for debugging
purposes, and the number of used hash buckets is not
in any way cached, thus this function can be costly
to execute as it must iterate over all the buckets in the
hash.

=cut

*/
#define HvFILL(hv)	Perl_hv_fill(aTHX_ MUTABLE_HV(hv))
#define HvMAX(hv)	((XPVHV*)  SvANY(hv))->xhv_max
/* This quite intentionally does no flag checking first. That's your
   responsibility.  */
#define HvAUX(hv)       (&(((struct xpvhv_with_aux*)  SvANY(hv))->xhv_aux))
#define HvRITER(hv)	(*Perl_hv_riter_p(aTHX_ MUTABLE_HV(hv)))
#define HvEITER(hv)	(*Perl_hv_eiter_p(aTHX_ MUTABLE_HV(hv)))
#define HvRITER_set(hv,r)	Perl_hv_riter_set(aTHX_ MUTABLE_HV(hv), r)
#define HvEITER_set(hv,e)	Perl_hv_eiter_set(aTHX_ MUTABLE_HV(hv), e)
#define HvRITER_get(hv)	(SvOOK(hv) ? HvAUX(hv)->xhv_riter : -1)
#define HvEITER_get(hv)	(SvOOK(hv) ? HvAUX(hv)->xhv_eiter : NULL)
#define HvRAND_get(hv)	(SvOOK(hv) ? HvAUX(hv)->xhv_rand : 0)
#define HvLASTRAND_get(hv)	(SvOOK(hv) ? HvAUX(hv)->xhv_last_rand : 0)

#define HvNAME(hv)	HvNAME_get(hv)
#define HvNAMELEN(hv)   HvNAMELEN_get(hv)
#define HvENAME(hv)	HvENAME_get(hv)
#define HvENAMELEN(hv)  HvENAMELEN_get(hv)

/* Checking that hv is a valid package stash is the
   caller's responsibility */
#define HvMROMETA(hv) (HvAUX(hv)->xhv_mro_meta \
                       ? HvAUX(hv)->xhv_mro_meta \
                       : Perl_mro_meta_init(aTHX_ hv))

#define HvNAME_HEK_NN(hv)			  \
 (						  \
  HvAUX(hv)->xhv_name_count			  \
  ? *HvAUX(hv)->xhv_name_u.xhvnameu_names	  \
  : HvAUX(hv)->xhv_name_u.xhvnameu_name		  \
 )
/* This macro may go away without notice.  */
#define HvNAME_HEK(hv) \
        (SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvNAME_HEK_NN(hv) : NULL)
#define HvNAME_get(hv) \
        ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
                         ? HEK_KEY(HvNAME_HEK_NN(hv)) : NULL)
#define HvNAMELEN_get(hv) \
        ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
                                 ? HEK_LEN(HvNAME_HEK_NN(hv)) : 0)
#define HvNAMEUTF8(hv) \
        ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
                                 ? HEK_UTF8(HvNAME_HEK_NN(hv)) : 0)
#define HvENAME_HEK_NN(hv)                                             \
 (                                                                      \
  HvAUX(hv)->xhv_name_count > 0   ? HvAUX(hv)->xhv_name_u.xhvnameu_names[0] : \
  HvAUX(hv)->xhv_name_count < -1  ? HvAUX(hv)->xhv_name_u.xhvnameu_names[1] : \
  HvAUX(hv)->xhv_name_count == -1 ? NULL                              : \
                                    HvAUX(hv)->xhv_name_u.xhvnameu_name \
 )
#define HvENAME_HEK(hv) \
        (SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvENAME_HEK_NN(hv) : NULL)
#define HvENAME_get(hv) \
   ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \
                         ? HEK_KEY(HvENAME_HEK_NN(hv)) : NULL)
#define HvENAMELEN_get(hv) \
   ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \
                                 ? HEK_LEN(HvENAME_HEK_NN(hv)) : 0)
#define HvENAMEUTF8(hv) \
   ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \
                                 ? HEK_UTF8(HvENAME_HEK_NN(hv)) : 0)

/*
 * HvKEYS gets the number of keys that actually exist(), and is provided
 * for backwards compatibility with old XS code. The core uses HvUSEDKEYS
 * (keys, excluding placeholders) and HvTOTALKEYS (including placeholders)
 */
#define HvKEYS(hv)		HvUSEDKEYS(hv)
#define HvUSEDKEYS(hv)		(HvTOTALKEYS(hv) - HvPLACEHOLDERS_get(hv))
#define HvTOTALKEYS(hv)         (((XPVHV*) SvANY(hv))->xhv_keys)
#define HvPLACEHOLDERS(hv)	(*Perl_hv_placeholders_p(aTHX_ MUTABLE_HV(hv)))
#define HvPLACEHOLDERS_get(hv)	(SvMAGIC(hv) ? Perl_hv_placeholders_get(aTHX_ (const HV *)hv) : 0)
#define HvPLACEHOLDERS_set(hv,p)	Perl_hv_placeholders_set(aTHX_ MUTABLE_HV(hv), p)

/* This (now) flags whether *new* keys in the hash will be allocated from the
 * shared string table. We have a heuristic to call HvSHAREKEYS_off() if a hash
 * is "getting large". After which, the first keys in that hash will be from
 * the shared string table, but subsequent keys will not be.
 *
 * If we didn't do this, we'd have to reallocate all keys when we switched this
 * flag, which would be work for no real gain. */
#define HvSHAREKEYS(hv)		(SvFLAGS(hv) & SVphv_SHAREKEYS)
#define HvSHAREKEYS_on(hv)	(SvFLAGS(hv) |= SVphv_SHAREKEYS)
#define HvSHAREKEYS_off(hv)	(SvFLAGS(hv) &= ~SVphv_SHAREKEYS)

/* This is an optimisation flag. It won't be set if all hash keys have a 0
 * flag. Currently the only flags relate to utf8.
 * Hence it won't be set if all keys are 8 bit only. It will be set if any key
 * is utf8 (including 8 bit keys that were entered as utf8, and need upgrading
 * when retrieved during iteration. It may still be set when there are no longer
 * any utf8 keys.
 * See HVhek_ENABLEHVKFLAGS for the trigger.
 */
#define HvHASKFLAGS(hv)		(SvFLAGS(hv) & SVphv_HASKFLAGS)
#define HvHASKFLAGS_on(hv)	(SvFLAGS(hv) |= SVphv_HASKFLAGS)
#define HvHASKFLAGS_off(hv)	(SvFLAGS(hv) &= ~SVphv_HASKFLAGS)

#define HvLAZYDEL(hv)		(SvFLAGS(hv) & SVphv_LAZYDEL)
#define HvLAZYDEL_on(hv)	(SvFLAGS(hv) |= SVphv_LAZYDEL)
#define HvLAZYDEL_off(hv)	(SvFLAGS(hv) &= ~SVphv_LAZYDEL)

#ifndef PERL_CORE
#  define Nullhe Null(HE*)
#endif
#define HeNEXT(he)		(he)->hent_next
#define HeKEY_hek(he)		(he)->hent_hek
#define HeKEY(he)		HEK_KEY(HeKEY_hek(he))
#define HeKEY_sv(he)		(*(SV**)HeKEY(he))
#define HeKLEN(he)		HEK_LEN(HeKEY_hek(he))
#define HeKUTF8(he)  HEK_UTF8(HeKEY_hek(he))
#define HeKWASUTF8(he)  HEK_WASUTF8(HeKEY_hek(he))
#define HeKLEN_UTF8(he)  (HeKUTF8(he) ? -HeKLEN(he) : HeKLEN(he))
#define HeKFLAGS(he)  HEK_FLAGS(HeKEY_hek(he))
#define HeVAL(he)		(he)->he_valu.hent_val
#define HeHASH(he)		HEK_HASH(HeKEY_hek(he))
#define HePV(he,lp)		((HeKLEN(he) == HEf_SVKEY) ?		\
                                 SvPV(HeKEY_sv(he),lp) :		\
                                 ((lp = HeKLEN(he)), HeKEY(he)))
#define HeUTF8(he)		((HeKLEN(he) == HEf_SVKEY) ?		\
                                 SvUTF8(HeKEY_sv(he)) :			\
                                 (U32)HeKUTF8(he))

#define HeSVKEY(he)		((HeKEY(he) && 				\
                                  HeKLEN(he) == HEf_SVKEY) ?		\
                                 HeKEY_sv(he) : NULL)

#define HeSVKEY_force(he)	(HeKEY(he) ?				\
                                 ((HeKLEN(he) == HEf_SVKEY) ?		\
                                  HeKEY_sv(he) :			\
                                  newSVpvn_flags(HeKEY(he),		\
                                                 HeKLEN(he),            \
                                                 SVs_TEMP |             \
                                      ( HeKUTF8(he) ? SVf_UTF8 : 0 ))) : \
                                 &PL_sv_undef)
#define HeSVKEY_set(he,sv)	((HeKLEN(he) = HEf_SVKEY), (HeKEY_sv(he) = sv))

#ifndef PERL_CORE
#  define Nullhek Null(HEK*)
#endif
#define HEK_BASESIZE		STRUCT_OFFSET(HEK, hek_key[0])
#define HEK_HASH(hek)		(hek)->hek_hash
#define HEK_LEN(hek)		(hek)->hek_len
#define HEK_KEY(hek)		(hek)->hek_key
#define HEK_FLAGS(hek)	(*((unsigned char *)(HEK_KEY(hek))+HEK_LEN(hek)+1))

#define HVhek_UTF8	0x01 /* Key is utf8 encoded. */
#define HVhek_WASUTF8	0x02 /* Key is bytes here, but was supplied as utf8. */
#define HVhek_NOTSHARED 0x04 /* This key isn't a shared hash key. */
/* the following flags are options for functions, they are not stored in heks */
#define HVhek_FREEKEY	0x100 /* Internal flag to say key is Newx()ed.  */
#define HVhek_PLACEHOLD	0x200 /* Internal flag to create placeholder.
                               * (may change, but Storable is a core module) */
#define HVhek_KEYCANONICAL 0x400 /* Internal flag - key is in canonical form.
                                    If the string is UTF-8, it cannot be
                                    converted to bytes. */
#define HVhek_ENABLEHVKFLAGS        (HVhek_UTF8|HVhek_WASUTF8)

#define HEK_UTF8(hek)		(HEK_FLAGS(hek) & HVhek_UTF8)
#define HEK_UTF8_on(hek)	(HEK_FLAGS(hek) |= HVhek_UTF8)
#define HEK_UTF8_off(hek)	(HEK_FLAGS(hek) &= ~HVhek_UTF8)
#define HEK_WASUTF8(hek)	(HEK_FLAGS(hek) & HVhek_WASUTF8)
#define HEK_WASUTF8_on(hek)	(HEK_FLAGS(hek) |= HVhek_WASUTF8)
#define HEK_WASUTF8_off(hek)	(HEK_FLAGS(hek) &= ~HVhek_WASUTF8)

/* calculate HV array allocation */
#ifndef PERL_USE_LARGE_HV_ALLOC
/* Default to allocating the correct size - default to assuming that malloc()
   is not broken and is efficient at allocating blocks sized at powers-of-two.
*/   
#  define PERL_HV_ARRAY_ALLOC_BYTES(size) ((size) * sizeof(HE*))
#else
#  define MALLOC_OVERHEAD 16
#  define PERL_HV_ARRAY_ALLOC_BYTES(size) \
                        (((size) < 64)					\
                         ? (size) * sizeof(HE*)				\
                         : (size) * sizeof(HE*) * 2 - MALLOC_OVERHEAD)
#endif

/* Flags for hv_iternext_flags.  */
#define HV_ITERNEXT_WANTPLACEHOLDERS	0x01	/* Don't skip placeholders.  */

#define hv_iternext(hv)	hv_iternext_flags(hv, 0)
#define hv_magic(hv, gv, how) sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0)
#define hv_undef(hv) Perl_hv_undef_flags(aTHX_ hv, 0)

#define Perl_sharepvn(pv, len, hash) HEK_KEY(share_hek(pv, len, hash))
#define sharepvn(pv, len, hash)	     Perl_sharepvn(pv, len, hash)

#define share_hek_hek(hek)						\
    (++(((struct shared_he *)(((char *)hek)				\
                              - STRUCT_OFFSET(struct shared_he,		\
                                              shared_he_hek)))		\
        ->shared_he_he.he_valu.hent_refcount),				\
     hek)

#define hv_store_ent(hv, keysv, val, hash)				\
    ((HE *) hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISSTORE,	\
                      (val), (hash)))

#define hv_exists_ent(hv, keysv, hash)					\
    cBOOL(hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash)))
#define hv_fetch_ent(hv, keysv, lval, hash)				\
    ((HE *) hv_common((hv), (keysv), NULL, 0, 0,			\
                      ((lval) ? HV_FETCH_LVALUE : 0), NULL, (hash)))
#define hv_delete_ent(hv, key, flags, hash)				\
    (MUTABLE_SV(hv_common((hv), (key), NULL, 0, 0, (flags) | HV_DELETE,	\
                          NULL, (hash))))

#define hv_store_flags(hv, key, klen, val, hash, flags)			\
    ((SV**) hv_common((hv), NULL, (key), (klen), (flags),		\
                      (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), (val),	\
                      (hash)))

#define hv_store(hv, key, klen, val, hash)				\
    ((SV**) hv_common_key_len((hv), (key), (klen),			\
                              (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV),	\
                              (val), (hash)))



#define hv_exists(hv, key, klen)					\
    cBOOL(hv_common_key_len((hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0))

#define hv_fetch(hv, key, klen, lval)					\
    ((SV**) hv_common_key_len((hv), (key), (klen), (lval)		\
                              ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)	\
                              : HV_FETCH_JUST_SV, NULL, 0))

#define hv_delete(hv, key, klen, flags)					\
    (MUTABLE_SV(hv_common_key_len((hv), (key), (klen),			\
                                  (flags) | HV_DELETE, NULL, 0)))

/* Provide 's' suffix subs for constant strings (and avoid needing to count
 * chars). See STR_WITH_LEN in handy.h - because these are macros we cant use
 * STR_WITH_LEN to do the work, we have to unroll it. */
#define hv_existss(hv, key) \
    hv_exists((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1))

#define hv_fetchs(hv, key, lval) \
    hv_fetch((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (lval))

#define hv_deletes(hv, key, flags) \
    hv_delete((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (flags))

#define hv_name_sets(hv, name, flags) \
    hv_name_set((hv),ASSERT_IS_LITERAL(name),(sizeof(name)-1), flags)

#define hv_stores(hv, key, val) \
    hv_store((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (val), 0)

#ifdef PERL_CORE
# define hv_storehek(hv, hek, val) \
    hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek),	\
              HV_FETCH_ISSTORE|HV_FETCH_JUST_SV, (val), HEK_HASH(hek))
# define hv_fetchhek(hv, hek, lval) \
    ((SV **)								\
     hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek),	\
               (lval)							\
                ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)			\
                : HV_FETCH_JUST_SV,					\
               NULL, HEK_HASH(hek)))
# define hv_deletehek(hv, hek, flags) \
    hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
              (flags)|HV_DELETE, NULL, HEK_HASH(hek))
#define hv_existshek(hv, hek)                                           \
    cBOOL(hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
                    HV_FETCH_ISEXISTS, NULL, HEK_HASH(hek)))
#endif

/* This refcounted he structure is used for storing the hints used for lexical
   pragmas. Without threads, it's basically struct he + refcount.
   With threads, life gets more complex as the structure needs to be shared
   between threads (because it hangs from OPs, which are shared), hence the
   alternate definition and mutex.  */

struct refcounted_he;

/* flags for the refcounted_he API */
#define REFCOUNTED_HE_KEY_UTF8		0x00000001
#define REFCOUNTED_HE_EXISTS		0x00000002

#ifdef PERL_CORE

/* Gosh. This really isn't a good name any longer.  */
struct refcounted_he {
    struct refcounted_he *refcounted_he_next;	/* next entry in chain */
#ifdef USE_ITHREADS
    U32                   refcounted_he_hash;
    U32                   refcounted_he_keylen;
#else
    HEK                  *refcounted_he_hek;	/* hint key */
#endif
    union {
        IV                refcounted_he_u_iv;
        UV                refcounted_he_u_uv;
        STRLEN            refcounted_he_u_len;
        void		 *refcounted_he_u_ptr;	/* Might be useful in future */
    } refcounted_he_val;
    U32	                  refcounted_he_refcnt;	/* reference count */
    /* First byte is flags. Then NUL-terminated value. Then for ithreads,
       non-NUL terminated key.  */
    char                  refcounted_he_data[1];
};

/*
=for apidoc m|SV *|refcounted_he_fetch_pvs|const struct refcounted_he *chain|"key"|U32 flags

Like L</refcounted_he_fetch_pvn>, but takes a literal string
instead of a string/length pair, and no precomputed hash.

=cut
*/

#define refcounted_he_fetch_pvs(chain, key, flags) \
    Perl_refcounted_he_fetch_pvn(aTHX_ chain, STR_WITH_LEN(key), 0, flags)

/*
=for apidoc m|struct refcounted_he *|refcounted_he_new_pvs|struct refcounted_he *parent|"key"|SV *value|U32 flags

Like L</refcounted_he_new_pvn>, but takes a literal string
instead of a string/length pair, and no precomputed hash.

=cut
*/

#define refcounted_he_new_pvs(parent, key, value, flags) \
    Perl_refcounted_he_new_pvn(aTHX_ parent, STR_WITH_LEN(key), 0, value, flags)

/* Flag bits are HVhek_UTF8, HVhek_WASUTF8, then */
#define HVrhek_undef	0x00 /* Value is undef. */
#define HVrhek_delete	0x10 /* Value is placeholder - signifies delete. */
#define HVrhek_IV	0x20 /* Value is IV. */
#define HVrhek_UV	0x30 /* Value is UV. */
#define HVrhek_PV	0x40 /* Value is a (byte) string. */
#define HVrhek_PV_UTF8	0x50 /* Value is a (utf8) string. */
/* Two spare. As these have to live in the optree, you can't store anything
   interpreter specific, such as SVs. :-( */
#define HVrhek_typemask 0x70

#ifdef USE_ITHREADS
/* A big expression to find the key offset */
#define REF_HE_KEY(chain)						\
        ((((chain->refcounted_he_data[0] & 0x60) == 0x40)		\
            ? chain->refcounted_he_val.refcounted_he_u_len + 1 : 0)	\
         + 1 + chain->refcounted_he_data)
#endif

#  ifdef USE_ITHREADS
#    define HINTS_REFCNT_LOCK		MUTEX_LOCK(&PL_hints_mutex)
#    define HINTS_REFCNT_UNLOCK		MUTEX_UNLOCK(&PL_hints_mutex)
#  else
#    define HINTS_REFCNT_LOCK		NOOP
#    define HINTS_REFCNT_UNLOCK		NOOP
#  endif
#endif

#ifdef USE_ITHREADS
#  define HINTS_REFCNT_INIT		MUTEX_INIT(&PL_hints_mutex)
#  define HINTS_REFCNT_TERM		MUTEX_DESTROY(&PL_hints_mutex)
#else
#  define HINTS_REFCNT_INIT		NOOP
#  define HINTS_REFCNT_TERM		NOOP
#endif

/* Hash actions
 * Passed in PERL_MAGIC_uvar calls
 */
#define HV_DISABLE_UVAR_XKEY	0x01
/* We need to ensure that these don't clash with G_DISCARD, which is 2, as it
   is documented as being passed to hv_delete().  */
#define HV_FETCH_ISSTORE	0x04
#define HV_FETCH_ISEXISTS	0x08
#define HV_FETCH_LVALUE		0x10
#define HV_FETCH_JUST_SV	0x20
#define HV_DELETE		0x40
#define HV_FETCH_EMPTY_HE	0x80 /* Leave HeVAL null. */

/* Must not conflict with HVhek_UTF8 */
#define HV_NAME_SETALL		0x02

/*
=for apidoc newHV

Creates a new HV.  The reference count is set to 1.

=cut
*/

#define newHV()	MUTABLE_HV(newSV_type(SVt_PVHV))

#include "hv_func.h"

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /*   intrpvar.h 
 *
 *    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
 *    2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

#include "handy.h"

/* These variables are per-interpreter in threaded/multiplicity builds,
 * global otherwise.

 * Don't forget to re-run regen/embed.pl to propagate changes! */

/* New variables must be added to the very end for binary compatibility. */

/* DON'T FORGET to add your variable also to perl_clone()! (in sv.c) */

/* The 'I' prefix is only needed for vars that need appropriate #defines
 * generated when built with or without MULTIPLICITY.  It is also used
 * to generate the appropriate export list for win32.  If the variable
 * needs to be initialized, use PERLVARI.
 *
 * When building without MULTIPLICITY, these variables will be truly global.
 *
 * Important ones in the first cache line (if alignment is done right) */

PERLVAR(I, stack_sp,	SV **)		/* top of the stack */
PERLVAR(I, op,		OP *)		/* currently executing op */
PERLVAR(I, curpad,	SV **)		/* active pad (lexicals+tmps) */

PERLVAR(I, stack_base,	SV **)
PERLVAR(I, stack_max,	SV **)

PERLVAR(I, savestack,	ANY *)		/* items that need to be restored when
                                           LEAVEing scopes we've ENTERed */
PERLVAR(I, savestack_ix, I32)
PERLVAR(I, savestack_max, I32)

PERLVAR(I, scopestack,	I32 *)		/* scopes we've ENTERed */
PERLVAR(I, scopestack_ix, I32)
PERLVAR(I, scopestack_max, I32)

PERLVAR(I, tmps_stack,	SV **)		/* mortals we've made */
PERLVARI(I, tmps_ix,	SSize_t,	-1)
PERLVARI(I, tmps_floor,	SSize_t,	-1)
PERLVAR(I, tmps_max,	SSize_t)        /* first unalloced slot in tmps stack */

PERLVAR(I, markstack,	I32 *)		/* stack_sp locations we're
                                           remembering */
PERLVAR(I, markstack_ptr, I32 *)
PERLVAR(I, markstack_max, I32 *)

PERLVARI(I, sub_generation, U32, 1)	/* incr to invalidate method cache */

#ifdef PERL_HASH_RANDOMIZE_KEYS
#ifdef USE_PERL_PERTURB_KEYS
PERLVARI(I, hash_rand_bits_enabled, U8, 1) /* used to randomize hash stuff 0 == no-random, 1 == random, 2 == determinsitic */
#endif
PERLVARI(I, hash_rand_bits, UV, 0)      /* used to randomize hash stuff */
#endif
PERLVAR(I, strtab,	HV *)		/* shared string table */
/* prog counter for the currently executing OP_MULTIDEREF Used to signal
 * to S_find_uninit_var() where we are */
PERLVAR(I, multideref_pc, UNOP_AUX_item *)

/* Fields used by magic variables such as $@, $/ and so on */
PERLVAR(I, curpm,	PMOP *)		/* what to do \ interps in REs from */
PERLVAR(I, curpm_under,        PMOP *)                /* what to do \ interps in REs from */

PERLVAR(I, tainting,	bool)		/* ? doing taint checks */
PERLVARI(I, tainted,	bool, FALSE)	/* using variables controlled by $< */

/* PL_delaymagic is currently used for two purposes: to assure simultaneous
 * updates in ($<,$>) = ..., and to assure atomic update in push/unshift
 * @ISA, It works like this: a few places such as pp_push set the DM_DELAY
 * flag; then various places such as av_store() skip mg_set(ary) if this
 * flag is set, and various magic vtable methods set flags like
 * DM_ARRAY_ISA if they've seen something of that ilk. Finally when
 * control returns to pp_push or whatever, it sees if any of those flags
 * have been set, and if so finally calls mg_set().
 *
 * NB: PL_delaymagic is automatically saved and restored by JUMPENV_PUSH
 * / POP. This removes the need to do ENTER/SAVEI16(PL_delaymagic)/LEAVE
 * in hot code like pp_push.
 */
PERLVAR(I, delaymagic,	U16)		/* ($<,$>) = ... */

/*
=for apidoc_section $warning
=for apidoc mn|U8|PL_dowarn

The C variable that roughly corresponds to Perl's C<$^W> warning variable.
However, C<$^W> is treated as a boolean, whereas C<PL_dowarn> is a
collection of flag bits.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, dowarn,	U8)

#if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING)
#  define PERL___I -1
#else
#  define PERL___I 1
#endif
PERLVARI(I, utf8cache, I8, PERL___I)	/* Is the utf8 caching code enabled? */
#undef PERL___I

/*
=for apidoc_section $GV
=for apidoc Amn|GV *|PL_defgv

The GV representing C<*_>.  Useful for access to C<$_>.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, localizing,	U8)		/* are we processing a local() list? */
PERLVAR(I, in_eval,	U8)		/* trap "fatal" errors? */
PERLVAR(I, defgv,	GV *)           /* the *_ glob */

/*
=for apidoc_section $GV
=for apidoc Amn|HV*|PL_curstash

The stash for the package code will be compiled into.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

/* Stashes */
PERLVAR(I, defstash,	HV *)		/* main symbol table */
PERLVAR(I, curstash,	HV *)		/* symbol table for current package */

/*
=for apidoc_section $COP
=for apidoc Amn|COP*|PL_curcop

The currently active COP (control op) roughly representing the current
statement in the source.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, curcop,	COP *)
PERLVAR(I, curstack,	AV *)		/* THE STACK */
PERLVAR(I, curstackinfo, PERL_SI *)	/* current stack + context */
PERLVAR(I, mainstack,	AV *)		/* the stack when nothing funny is
                                           happening */

/* memory management */
PERLVAR(I, sv_count,	IV)		/* how many SV* are currently allocated */

PERLVAR(I, sv_root,	SV *)		/* storage for SVs belonging to interp */
PERLVAR(I, sv_arenaroot, SV *)		/* list of areas for garbage collection */

/* fake PMOP that PL_curpm points to while in (?{}) so $1 et al are visible */
PERLVARI(I, reg_curpm, PMOP*, NULL)

/* the currently active slab in a chain of slabs of regmatch states,
 * and the currently active state within that slab. This stack of states
 * is shared amongst re-entrant calls to the regex engine */

PERLVARI(I, regmatch_slab, regmatch_slab *,	NULL)
PERLVAR(I, regmatch_state, regmatch_state *)

PERLVAR(I, comppad,	PAD *)		/* storage for lexically scoped temporaries */

/*
=for apidoc_section $SV
=for apidoc Amn|SV|PL_sv_undef
This is the C<undef> SV.  It is readonly.  Always refer to this as
C<&PL_sv_undef>.

=for apidoc Amn|SV|PL_sv_no
This is the C<false> SV.  It is readonly.  See C<L</PL_sv_yes>>.  Always refer
to this as C<&PL_sv_no>.

=for apidoc Amn|SV|PL_sv_yes
This is the C<true> SV.  It is readonly.  See C<L</PL_sv_no>>.  Always refer to
this as C<&PL_sv_yes>.

=for apidoc Amn|SV|PL_sv_zero
This readonly SV has a zero numeric value and a C<"0"> string value. It's
similar to C<L</PL_sv_no>> except for its string value. Can be used as a
cheap alternative to C<mXPUSHi(0)> for example.  Always refer to this as
C<&PL_sv_zero>. Introduced in 5.28.

=cut
*/

#ifdef MULTIPLICITY
PERLVAR(I, sv_yes,	SV)
PERLVAR(I, sv_undef,	SV)
PERLVAR(I, sv_no,	SV)
PERLVAR(I, sv_zero,	SV)
#else
/* store the immortals as an array to ensure they are contiguous in
 * memory: makes SvIMMORTAL_INTERP(sv) possible */
PERLVARA(I, sv_immortals, 4, SV)
#endif

PERLVAR(I, padname_undef,	PADNAME)
PERLVAR(I, padname_const,	PADNAME)

/*
=for apidoc_section $SV
=for apidoc Cmn||PL_Sv

A scratch pad SV for whatever temporary use you need.  Chiefly used as a
fallback by macros on platforms where L<perlapi/PERL_USE_GCC_BRACE_GROUPS>> is
unavailable, and which would otherwise evaluate their SV parameter more than
once.

=cut
*/
PERLVAR(I, Sv,		SV *)

PERLVAR(I, parser,	yy_parser *)	/* current parser state */

PERLVAR(I, stashcache,	HV *)		/* Cache to speed up S_method_common */


/*
=for apidoc_section $string
=for apidoc Amn|STRLEN|PL_na

A scratch pad variable in which to store a C<STRLEN> value.  If would have been
better named something like C<PL_temp_strlen>.

It is is typically used with C<SvPV> when one is actually planning to discard
the returned length, (hence the length is "Not Applicable", which is how this
variable got its name).

It is usually more efficient to either declare a local variable and use that
instead, or to use the C<SvPV_nolen> macro.

=cut
*/

PERLVAR(I, na,		STRLEN)		/* for use in SvPV when length is
                                           Not Applicable */

/* stat stuff */
PERLVAR(I, statcache,	Stat_t)		/* _ */
PERLVAR(I, statgv,	GV *)
PERLVARI(I, statname,	SV *,	NULL)

/*
=for apidoc_section $io
=for apidoc mn|SV*|PL_rs

The input record separator - C<$/> in Perl space.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=for apidoc_section $io
=for apidoc mn|GV*|PL_last_in_gv

The GV which was last used for a filehandle input operation.  (C<< <FH> >>)

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=for apidoc_section $io
=for apidoc mn|GV*|PL_ofsgv

The glob containing the output field separator - C<*,> in Perl space.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, rs,		SV *)		/* input record separator $/ */
PERLVAR(I, last_in_gv,	GV *)		/* GV used in last <FH> */
PERLVAR(I, ofsgv,	GV *)		/* GV of output field separator *, */
PERLVAR(I, defoutgv,	GV *)		/* default FH for output */
PERLVARI(I, chopset,	const char *, " \n-")	/* $: */
PERLVAR(I, formtarget,	SV *)
PERLVAR(I, bodytarget,	SV *)
PERLVAR(I, toptarget,	SV *)


PERLVAR(I, restartop,	OP *)		/* propagating an error from croak? */
PERLVAR(I, restartjmpenv, JMPENV *)	/* target frame for longjmp in die */

PERLVAR(I, top_env,	JMPENV *)	/* ptr to current sigjmp environment */
PERLVAR(I, start_env,	JMPENV)		/* empty startup sigjmp environment */
PERLVARI(I, errors,	SV *,	NULL)	/* outstanding queued errors */

/* statics "owned" by various functions */
PERLVAR(I, hv_fetch_ent_mh, HE*)	/* owned by hv_fetch_ent() */

PERLVAR(I, lastgotoprobe, OP*)		/* from pp_ctl.c */

/* sort stuff */
PERLVAR(I, sortcop,	OP *)		/* user defined sort routine */
PERLVAR(I, sortstash,	HV *)		/* which is in some package or other */
PERLVAR(I, firstgv,	GV *)		/* $a */
PERLVAR(I, secondgv,	GV *)		/* $b */

/* float buffer */
PERLVAR(I, efloatbuf,	char *)
PERLVAR(I, efloatsize,	STRLEN)

PERLVARI(I, dumpindent,	U16,	4)	/* number of blanks per dump
                                           indentation level */

/*
=for apidoc_section $embedding
=for apidoc Amn|U8|PL_exit_flags

Contains flags controlling perl's behaviour on exit():

=over

=item * C<PERL_EXIT_DESTRUCT_END>

If set, END blocks are executed when the interpreter is destroyed.
This is normally set by perl itself after the interpreter is
constructed.

=item * C<PERL_EXIT_ABORT>

Call C<abort()> on exit.  This is used internally by perl itself to
abort if exit is called while processing exit.

=item * C<PERL_EXIT_WARN>

Warn on exit.

=item * C<PERL_EXIT_EXPECTED>

Set by the L<perlfunc/exit> operator.

=back

=for apidoc Amnh||PERL_EXIT_EXPECTED
=for apidoc Amnh||PERL_EXIT_ABORT
=for apidoc Amnh||PERL_EXIT_DESTRUCT_END
=for apidoc Amnh||PERL_EXIT_WARN

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, exit_flags,	U8)		/* was exit() unexpected, etc. */

PERLVAR(I, utf8locale,	bool)		/* utf8 locale detected */
PERLVAR(I, in_utf8_CTYPE_locale, bool)
PERLVAR(I, in_utf8_COLLATE_locale, bool)
PERLVAR(I, in_utf8_turkic_locale, bool)
#if defined(USE_ITHREADS) && ! defined(USE_THREAD_SAFE_LOCALE)
PERLVARI(I, lc_numeric_mutex_depth, int, 0)   /* Emulate general semaphore */
#endif
PERLVARA(I, locale_utf8ness, 256, char)

#ifdef USE_LOCALE_CTYPE
    PERLVAR(I, warn_locale, SV *)
#endif

PERLVARA(I, colors,6,	char *)		/* values from PERL_RE_COLORS env var */

/*
=for apidoc_section $optree_construction
=for apidoc Amn|peep_t|PL_peepp

Pointer to the per-subroutine peephole optimiser.  This is a function
that gets called at the end of compilation of a Perl subroutine (or
equivalently independent piece of Perl code) to perform fixups of
some ops and to perform small-scale optimisations.  The function is
called once for each subroutine that is compiled, and is passed, as sole
parameter, a pointer to the op that is the entry point to the subroutine.
It modifies the op tree in place.

The peephole optimiser should never be completely replaced.  Rather,
add code to it by wrapping the existing optimiser.  The basic way to do
this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
If the new code wishes to operate on ops throughout the subroutine's
structure, rather than just at the top level, it is likely to be more
convenient to wrap the L</PL_rpeepp> hook.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVARI(I, peepp,	peep_t, Perl_peep)

/*
=for apidoc_section $optree_construction
=for apidoc Amn|peep_t|PL_rpeepp

Pointer to the recursive peephole optimiser.  This is a function
that gets called at the end of compilation of a Perl subroutine (or
equivalently independent piece of Perl code) to perform fixups of some
ops and to perform small-scale optimisations.  The function is called
once for each chain of ops linked through their C<op_next> fields;
it is recursively called to handle each side chain.  It is passed, as
sole parameter, a pointer to the op that is at the head of the chain.
It modifies the op tree in place.

The peephole optimiser should never be completely replaced.  Rather,
add code to it by wrapping the existing optimiser.  The basic way to do
this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
If the new code wishes to operate only on ops at a subroutine's top level,
rather than throughout the structure, it is likely to be more convenient
to wrap the L</PL_peepp> hook.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVARI(I, rpeepp,	peep_t, Perl_rpeep)

/*
=for apidoc_section $optrees
=for apidoc Amn|Perl_ophook_t|PL_opfreehook

When non-C<NULL>, the function pointed by this variable will be called each time an OP is freed with the corresponding OP as the argument.
This allows extensions to free any extra attribute they have locally attached to an OP.
It is also assured to first fire for the parent OP and then for its kids.

When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVARI(I, opfreehook,	Perl_ophook_t, 0) /* op_free() hook */

PERLVARI(I, watchaddr,	char **, 0)
PERLVAR(I, watchok,	char *)

PERLVAR(I, perldb,	U32)

PERLVAR(I, signals,	U32)	/* Using which pre-5.8 signals */

PERLVAR(I, reentrant_retint, int)	/* Integer return value from reentrant functions */

/* pseudo environmental stuff */
PERLVAR(I, origargc,	int)
PERLVAR(I, origargv,	char **)
PERLVAR(I, envgv,	GV *)
PERLVAR(I, incgv,	GV *)
PERLVAR(I, hintgv,	GV *)
PERLVAR(I, origfilename, char *)
PERLVARI(I, xsubfilename, const char *, NULL)
PERLVAR(I, diehook,	SV *)
PERLVAR(I, warnhook,	SV *)

/* switches */
PERLVAR(I, patchlevel,	SV *)
PERLVAR(I, localpatches, const char * const *)
PERLVARI(I, splitstr,	const char *, " ")

PERLVAR(I, minus_c,	bool)
PERLVAR(I, minus_n,	bool)
PERLVAR(I, minus_p,	bool)
PERLVAR(I, minus_l,	bool)
PERLVAR(I, minus_a,	bool)
PERLVAR(I, minus_F,	bool)
PERLVAR(I, doswitches,	bool)
PERLVAR(I, minus_E,	bool)

PERLVAR(I, inplace,	char *)
PERLVAR(I, e_script,	SV *)

PERLVAR(I, basetime,	Time_t)		/* $^T */

PERLVARI(I, maxsysfd,	I32,	MAXSYSFD)
                                        /* top fd to pass to subprocesses */
PERLVAR(I, statusvalue,	I32)		/* $? */
#ifdef VMS
PERLVAR(I, statusvalue_vms, U32)
#else
PERLVAR(I, statusvalue_posix, I32)
#endif

PERLVARI(I, sig_pending, int, 0)	/* Number if highest signal pending */
PERLVAR(I, psig_pend, int *)		/* per-signal "count" of pending */

/* shortcuts to various I/O objects */
PERLVAR(I, stdingv,	GV *)		/*  *STDIN      */
PERLVAR(I, stderrgv,	GV *)		/*  *STDERR     */
PERLVAR(I, argvgv,	GV *)		/*  *ARGV       */
PERLVAR(I, argvoutgv,	GV *)		/*  *ARGVOUT    */
PERLVAR(I, argvout_stack, AV *)

/* shortcuts to regexp stuff */
PERLVAR(I, replgv,	GV *)		/*  *^R         */

/* shortcuts to misc objects */
PERLVAR(I, errgv,	GV *)		/*  *@          */

/* shortcuts to debugging objects */
PERLVAR(I, DBgv,	GV *)		/*  *DB::DB     */
PERLVAR(I, DBline,	GV *)		/*  *DB::line   */

/*
=for apidoc_section $debugging
=for apidoc mn|GV *|PL_DBsub
When Perl is run in debugging mode, with the B<-d> switch, this GV contains
the SV which holds the name of the sub being debugged.  This is the C
variable which corresponds to Perl's $DB::sub variable.  See
C<L</PL_DBsingle>>.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=for apidoc mn|SV *|PL_DBsingle
When Perl is run in debugging mode, with the B<-d> switch, this SV is a
boolean which indicates whether subs are being single-stepped.
Single-stepping is automatically turned on after every step.  This is the C
variable which corresponds to Perl's $DB::single variable.  See
C<L</PL_DBsub>>.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=for apidoc mn|SV *|PL_DBtrace
Trace variable used when Perl is run in debugging mode, with the B<-d>
switch.  This is the C variable which corresponds to Perl's $DB::trace
variable.  See C<L</PL_DBsingle>>.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, DBsub,	GV *)		/*  *DB::sub    */
PERLVAR(I, DBsingle,	SV *)		/*  $DB::single */
PERLVAR(I, DBtrace,	SV *)		/*  $DB::trace  */
PERLVAR(I, DBsignal,	SV *)		/*  $DB::signal */
PERLVAR(I, dbargs,	AV *)		/* args to call listed by caller function */

PERLVARA(I, DBcontrol,    DBVARMG_COUNT, IV) /* IV versions of $DB::single, trace, signal */

/* symbol tables */
PERLVAR(I, debstash,	HV *)		/* symbol table for perldb package */
PERLVAR(I, globalstash,	HV *)		/* global keyword overrides imported here */
PERLVAR(I, curstname,	SV *)		/* name of current package */
PERLVAR(I, beginav,	AV *)		/* names of BEGIN subroutines */
PERLVAR(I, endav,	AV *)		/* names of END subroutines */
PERLVAR(I, unitcheckav,	AV *)		/* names of UNITCHECK subroutines */
PERLVAR(I, checkav,	AV *)		/* names of CHECK subroutines */
PERLVAR(I, initav,	AV *)		/* names of INIT subroutines */

/* subprocess state */
PERLVAR(I, fdpid,	AV *)		/* keep fd-to-pid mappings for my_popen */

/* internal state */
PERLVARI(I, op_mask,	char *,	NULL)	/* masked operations for safe evals */

/* current interpreter roots */
PERLVAR(I, main_cv,	CV *)
PERLVAR(I, main_root,	OP *)
PERLVAR(I, main_start,	OP *)
PERLVAR(I, eval_root,	OP *)
PERLVAR(I, eval_start,	OP *)

/* runtime control stuff */
PERLVARI(I, curcopdb,	COP *,	NULL)

PERLVAR(I, filemode,	int)		/* so nextargv() can preserve mode */
PERLVAR(I, lastfd,	int)		/* what to preserve mode on */
PERLVAR(I, oldname,	char *)		/* what to preserve mode on */
/* Elements in this array have ';' appended and are injected as a single line
   into the tokeniser. You can't put any (literal) newlines into any program
   you stuff in into this array, as the point where it's injected is expecting
   a single physical line. */
PERLVAR(I, preambleav,	AV *)
PERLVAR(I, mess_sv,	SV *)
PERLVAR(I, ors_sv,	SV *)		/* output record separator $\ */

/* funky return mechanisms */
PERLVAR(I, forkprocess,	int)		/* so do_open |- can return proc# */

/* statics moved here for shared library purposes */
PERLVARI(I, gensym,	I32,	0)	/* next symbol for getsym() to define */
PERLVARI(I, cv_has_eval, bool, FALSE)	/* PL_compcv includes an entereval or similar */
PERLVAR(I, taint_warn,	bool)		/* taint warns instead of dying */
PERLVARI(I, laststype,	U16,	OP_STAT)

PERLVARI(I, laststatval, int,	-1)

PERLVAR(I, modcount,	I32)		/* how much op_lvalue()ification in
                                           assignment? */

/* interpreter atexit processing */
PERLVARI(I, exitlistlen, I32, 0)	/* length of same */
PERLVARI(I, exitlist,	PerlExitListEntry *, NULL)
                                        /* list of exit functions */

/*
=for apidoc_section $HV
=for apidoc Amn|HV*|PL_modglobal

C<PL_modglobal> is a general purpose, interpreter global HV for use by
extensions that need to keep information on a per-interpreter basis.
In a pinch, it can also be used as a symbol table for extensions
to share data among each other.  It is a good idea to use keys
prefixed by the package name of the extension that owns the data.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/

PERLVAR(I, modglobal,	HV *)		/* per-interp module data */

/* these used to be in global before 5.004_68 */
PERLVARI(I, profiledata, U32 *,	NULL)	/* table of ops, counts */

PERLVAR(I, compiling,	COP)		/* compiling/done executing marker */

PERLVAR(I, compcv,	CV *)		/* currently compiling subroutine */
PERLVAR(I, comppad_name, PADNAMELIST *)	/* variable names for "my" variables */
PERLVAR(I, comppad_name_fill,	PADOFFSET)/* last "introduced" variable offset */
PERLVAR(I, comppad_name_floor,	PADOFFSET)/* start of vars in innermost block */

#ifdef HAVE_INTERP_INTERN
PERLVAR(I, sys_intern,	struct interp_intern)
                                        /* platform internals */
#endif

/* more statics moved here */
PERLVAR(I, DBcv,	CV *)		/* from perl.c */
PERLVARI(I, generation,	int,	100)	/* scan sequence# for OP_AASSIGN
                                           compile-time common elem detection */

PERLVAR(I, unicode, U32)	/* Unicode features: $ENV{PERL_UNICODE} or -C */

PERLVARI(I, in_clean_objs,bool,    FALSE)	/* from sv.c */
PERLVARI(I, in_clean_all, bool,    FALSE)	/* ptrs to freed SVs now legal */
PERLVAR(I, nomemok,	bool)		/* let malloc context handle nomem */
PERLVARI(I, savebegin,	bool,	FALSE)	/* save BEGINs for compiler	*/


PERLVAR(I, delaymagic_uid,	Uid_t)	/* current real user id, only for delaymagic */
PERLVAR(I, delaymagic_euid,	Uid_t)	/* current effective user id, only for delaymagic */
PERLVAR(I, delaymagic_gid,	Gid_t)	/* current real group id, only for delaymagic */
PERLVAR(I, delaymagic_egid,	Gid_t)	/* current effective group id, only for delaymagic */
PERLVARI(I, an,		U32,	0)	/* malloc sequence number */

/* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen"  */
PERLVARI(I, breakable_sub_gen, U32, 0)

#ifdef DEBUGGING
    /* exercise wrap-around */
    #define PERL_COP_SEQMAX (U32_MAX-50)
#else
    #define PERL_COP_SEQMAX 0
#endif
PERLVARI(I, cop_seqmax,	U32,	PERL_COP_SEQMAX) /* statement sequence number */
#undef PERL_COP_SEQMAX

PERLVARI(I, evalseq,	U32,	0)	/* eval sequence number */
PERLVAR(I, origalen,	U32)
PERLVAR(I, origenviron,	char **)
#ifdef PERL_USES_PL_PIDSTATUS
PERLVAR(I, pidstatus,	HV *)		/* pid-to-status mappings for waitpid */
#endif
PERLVAR(I, osname,	char *)		/* operating system */

PERLVAR(I, sighandlerp,	 Sighandler_t)
/* these two are provided only to solve library linkage issues; they
 * should not be hooked by user code */
PERLVAR(I, sighandler1p, Sighandler1_t)
PERLVAR(I, sighandler3p, Sighandler3_t)

PERLVARA(I, body_roots,	PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */

PERLVAR(I, debug,	volatile U32)	/* flags given to -D switch */

PERLVARI(I, padlist_generation, U32, 1)	/* id to identify padlist clones */

PERLVARI(I, runops,	runops_proc_t, RUNOPS_DEFAULT)

PERLVAR(I, subname,	SV *)		/* name of current subroutine */

PERLVAR(I, subline,	I32)		/* line this subroutine began on */
PERLVAR(I, min_intro_pending, PADOFFSET)/* start of vars to introduce */

PERLVAR(I, max_intro_pending, PADOFFSET)/* end of vars to introduce */
PERLVAR(I, padix,	PADOFFSET)	/* lowest unused index - 1
                                           in current "register" pad */
PERLVAR(I, constpadix,	PADOFFSET)	/* lowest unused for constants */

PERLVAR(I, padix_floor,	PADOFFSET)	/* how low may inner block reset padix */

#if defined(USE_POSIX_2008_LOCALE)          \
 && defined(USE_THREAD_SAFE_LOCALE)         \
 && ! defined(HAS_QUERYLOCALE)

/* This is the most number of categories we've encountered so far on any
 * platform */
PERLVARA(I, curlocales, 12, char *)

#endif
#ifdef USE_LOCALE_COLLATE

PERLVAR(I, collation_name, char *)	/* Name of current collation */
PERLVAR(I, collxfrm_base, Size_t)	/* Basic overhead in *xfrm() */
PERLVARI(I, collxfrm_mult,Size_t, 2)	/* Expansion factor in *xfrm() */
PERLVARI(I, collation_ix, U32,	0)	/* Collation generation index */
PERLVARI(I, strxfrm_NUL_replacement, U8, 0)  /* Code point to replace NULs */
PERLVARI(I, strxfrm_is_behaved, bool, TRUE)
                            /* Assume until proven otherwise that it works */
PERLVARI(I, strxfrm_max_cp, U8, 0)      /* Highest collating cp in locale */
PERLVARI(I, collation_standard, bool, TRUE)
                                        /* Assume simple collation */
#endif /* USE_LOCALE_COLLATE */

PERLVARI(I, langinfo_buf, char *, NULL)
PERLVARI(I, langinfo_bufsize, Size_t, 0)
PERLVARI(I, setlocale_buf, char *, NULL)
PERLVARI(I, setlocale_bufsize, Size_t, 0)

#ifdef PERL_SAWAMPERSAND
PERLVAR(I, sawampersand, U8)		/* must save all match strings */
#endif

/* current phase the interpreter is in
   for ordering this structure to remove holes, we're assuming that this is 4
   bytes.  */
PERLVARI(I, phase,	enum perl_phase, PERL_PHASE_CONSTRUCT)

PERLVARI(I, in_load_module, bool, FALSE)	/* to prevent recursions in PerlIO_find_layer */

PERLVAR(I, unsafe,	bool)
PERLVAR(I, colorset,	bool)		/* PERL_RE_COLORS env var is in use */

/*
=for apidoc_section $embedding
=for apidoc Amn|signed char|PL_perl_destruct_level

This value may be set when embedding for full cleanup.

Possible values:

=over

=item * 0 - none

=item * 1 - full

=item * 2 or greater - full with checks.

=back

If C<$ENV{PERL_DESTRUCT_LEVEL}> is set to an integer greater than the
value of C<PL_perl_destruct_level> its value is used instead.

On threaded perls, each thread has an independent copy of this variable;
each initialized at creation time with the current value of the creating
thread's copy.

=cut
*/
/* mod_perl is special, and also assigns a meaning -1 */
PERLVARI(I, perl_destruct_level, signed char,	0)

PERLVAR(I, pad_reset_pending, bool)	/* reset pad on next attempted alloc */

PERLVAR(I, srand_called, bool)

#ifdef USE_LOCALE_NUMERIC

PERLVARI(I, numeric_underlying, bool, TRUE)
                                        /* Assume underlying locale numerics */
PERLVARI(I, numeric_underlying_is_standard, bool, TRUE)

PERLVARI(I, numeric_standard, int, TRUE)
                                        /* Assume C locale numerics */
PERLVAR(I, numeric_name, char *)	/* Name of current numeric locale */
PERLVAR(I, numeric_radix_sv, SV *)	/* The radix separator if not '.' */

#  ifdef HAS_POSIX_2008_LOCALE

PERLVARI(I, underlying_numeric_obj, locale_t, NULL)

#  endif
#endif /* !USE_LOCALE_NUMERIC */

/* Array of signal handlers, indexed by signal number, through which the C
   signal handler dispatches.  */
PERLVAR(I, psig_ptr,	SV **)
/* Array of names of signals, indexed by signal number, for (re)use as the first
   argument to a signal handler.   Only one block of memory is allocated for
   both psig_name and psig_ptr.  */
PERLVAR(I, psig_name,	SV **)

#if defined(PERL_IMPLICIT_SYS)
PERLVAR(I, Mem,		struct IPerlMem *)
PERLVAR(I, MemShared,	struct IPerlMem *)
PERLVAR(I, MemParse,	struct IPerlMem *)
PERLVAR(I, Env,		struct IPerlEnv *)
PERLVAR(I, StdIO,	struct IPerlStdIO *)
PERLVAR(I, LIO,		struct IPerlLIO *)
PERLVAR(I, Dir,		struct IPerlDir *)
PERLVAR(I, Sock,	struct IPerlSock *)
PERLVAR(I, Proc,	struct IPerlProc *)
#endif

PERLVAR(I, ptr_table,	PTR_TBL_t *)
PERLVARI(I, beginav_save, AV *, NULL)	/* save BEGIN{}s when compiling */

PERLVAR(I, body_arenas, void *)		/* pointer to list of body-arenas */


#if defined(USE_ITHREADS)
PERLVAR(I, regex_pad,     SV **)	/* Shortcut into the array of
                                           regex_padav */
PERLVAR(I, regex_padav,   AV *)		/* All regex objects, indexed via the
                                           values in op_pmoffset of pmop.
                                           Entry 0 is an SV whose PV is a
                                           "packed" list of IVs listing
                                           the now-free slots in the array */
PERLVAR(I, stashpad,    HV **)		/* for CopSTASH */
PERLVARI(I, stashpadmax, PADOFFSET, 64)
PERLVARI(I, stashpadix, PADOFFSET, 0)
#endif

#ifdef USE_REENTRANT_API
PERLVAR(I, reentrant_buffer, REENTR *)	/* here we store the _r buffers */
#endif

PERLVAR(I, custom_op_names, HV *)	/* Names of user defined ops */
PERLVAR(I, custom_op_descs, HV *)	/* Descriptions of user defined ops */

#ifdef PERLIO_LAYERS
PERLVARI(I, perlio,	PerlIOl *, NULL)
PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
#endif

PERLVARI(I, checkav_save, AV *, NULL)	/* save CHECK{}s when compiling */
PERLVARI(I, unitcheckav_save, AV *, NULL)
                                        /* save UNITCHECK{}s when compiling */

PERLVARI(I, clocktick,	long,	0)	/* this many times() ticks in a second */

/* Hooks to shared SVs and locks. */
PERLVARI(I, sharehook,	share_proc_t, Perl_sv_nosharing)
PERLVARI(I, lockhook,	share_proc_t, Perl_sv_nosharing)

GCC_DIAG_IGNORE(-Wdeprecated-declarations)
#ifdef NO_MATHOMS
#  define PERL_UNLOCK_HOOK Perl_sv_nosharing
#else
/* This reference ensures that the mathoms are linked with perl */
#  define PERL_UNLOCK_HOOK Perl_sv_nounlocking
#endif
PERLVARI(I, unlockhook,	share_proc_t, PERL_UNLOCK_HOOK)

GCC_DIAG_RESTORE

PERLVARI(I, threadhook,	thrhook_proc_t,	Perl_nothreadhook)

/* Can shared object be destroyed */
PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable)

#ifndef PERL_MICRO
PERLVARI(I, signalhook,	despatch_signals_proc_t, Perl_despatch_signals)
#endif

PERLVARI(I, isarev, HV *, NULL)		/* Reverse map of @ISA dependencies */

/* Register of known Method Resolution Orders.
   What this actually points to is an implementation detail (it may change to
   a structure incorporating a reference count - use mro_get_from_name to
   retrieve a C<struct mro_alg *>  */
PERLVAR(I, registered_mros, HV *)

/* Compile-time block start/end hooks */
PERLVAR(I, blockhooks,	AV *)

PERLVAR(I, custom_ops,	HV *)		/* custom op registrations */

PERLVAR(I, Xpv,		XPV *)		/* (unused) held temporary value */

/* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be
   present always, as -DDEBUGGING must be binary compatible with non.  */
PERLVARI(I, scopestack_name, const char * *, NULL)

PERLVAR(I, debug_pad,	struct perl_debug_pad)	/* always needed because of the re extension */

/* Hook for File::Glob */
PERLVARI(I, globhook,	globhook_t, NULL)

#if defined(MULTIPLICITY)
/* The last unconditional member of the interpreter structure when 5.18.0 was
   released. The offset of the end of this is baked into a global variable in 
   any shared perl library which will allow a sanity test in future perl
   releases.  */
#  define PERL_LAST_5_18_0_INTERP_MEMBER	Iglobhook
#endif

#ifdef MULTIPLICITY
PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */
PERLVARI(I, my_cxt_size, int,	0)	/* size of PL_my_cxt_list */
#endif

#if defined(MULTIPLICITY) || defined(PERL_DEBUG_READONLY_COW)
/* For use with the memory debugging code in util.c. This is used only in
 * DEBUGGING builds (as long as the relevant structure is defined), but
 * defining it in non-debug builds too means that we retain binary
 * compatibility between otherwise-compatible plain and debug builds. */
PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
#endif

#ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
/* File descriptor to talk to the child which dumps scalars.  */
PERLVARI(I, dumper_fd,	int,	-1)
#endif


#ifdef DEBUG_LEAKING_SCALARS
PERLVARI(I, sv_serial,	U32,	0)	/* SV serial number, used in sv.c */
#endif

PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*)	/* constant SVs with precomputed hash value */

#ifdef PERL_TRACE_OPS
PERLVARA(I, op_exec_cnt, OP_max+2, UV)	/* Counts of executed OPs of the given type.
                                           If PERL_TRACE_OPS is enabled, we'll dump
                                           a summary count of all ops executed in the
                                           program at perl_destruct time. For
                                           profiling/debugging only. Works only if
                                           DEBUGGING is enabled, too. */
#endif

PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE)

PERLVARI(I, dump_re_max_len, STRLEN, 60)

/* For internal uses of randomness, this ensures the sequence of
 * random numbers returned by rand() isn't modified by perl's internal
 * use of randomness.
 * This is important if the user has called srand() with a seed.
 */

PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE)

PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char)

PERLVAR(I, AboveLatin1,	SV *)
PERLVAR(I, Assigned_invlist, SV *)
PERLVAR(I, GCB_invlist, SV *)
PERLVAR(I, HasMultiCharFold,   SV *)
PERLVAR(I, InMultiCharFold,   SV *)
PERLVAR(I, Latin1,	SV *)
PERLVAR(I, LB_invlist, SV *)
PERLVAR(I, SB_invlist, SV *)
PERLVAR(I, SCX_invlist, SV *)
PERLVAR(I, UpperLatin1,	SV *)   /* Code points 128 - 255 */

/* List of characters that participate in any fold defined by Unicode */
PERLVAR(I, in_some_fold, SV *)

/* Everything that folds to a given character, for case insensitivity regex
 * matching */
PERLVAR(I, utf8_foldclosures, SV *)

PERLVAR(I, utf8_idcont,	SV *)
PERLVAR(I, utf8_idstart, SV *)
PERLVAR(I, utf8_perl_idcont, SV *)
PERLVAR(I, utf8_perl_idstart, SV *)
PERLVAR(I, utf8_xidcont, SV *)
PERLVAR(I, utf8_xidstart, SV *)
PERLVAR(I, WB_invlist, SV *)
PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV *)
PERLVARA(I,  Posix_ptrs, POSIX_CC_COUNT, SV *)
PERLVAR(I, utf8_toupper, SV *)
PERLVAR(I, utf8_totitle, SV *)
PERLVAR(I, utf8_tolower, SV *)
PERLVAR(I, utf8_tofold,	SV *)
PERLVAR(I, utf8_tosimplefold,	SV *)
PERLVAR(I, utf8_charname_begin, SV *)
PERLVAR(I, utf8_charname_continue, SV *)
PERLVAR(I, utf8_mark,	SV *)
PERLVARI(I, InBitmap,	SV *, NULL)
PERLVAR(I, CCC_non0_non230,	SV *)
PERLVAR(I, Private_Use,	SV *)

#ifdef HAS_MBRLEN
PERLVAR(I, mbrlen_ps, mbstate_t)
#endif
#ifdef HAS_MBRTOWC
PERLVAR(I, mbrtowc_ps, mbstate_t)
#endif
#ifdef HAS_WCRTOMB
PERLVAR(I, wcrtomb_ps, mbstate_t)
#endif
#ifdef PERL_MEM_LOG
/* Enough space for the reserved byte, 1 for a potential leading 0, then enough
 * for the longest representable integer plus an extra, the 3 flag characters,
 * and NUL */
PERLVARA(I, mem_log, 1 + 1 + TYPE_DIGITS(UV) + 1 + 3 + 1, char)
#endif

/* The most recently seen `use VERSION` declaration, encoded in a single
 * U16 as (major << 8) | minor. We do this rather than store an entire SV
 * version object so we can fit the U16 into the uv of a SAVEHINTS and not
 * have to worry about SV refcounts during scope enter/exit. */
PERLVAR(I, prevailing_version, U16)

/* If you are adding a U8 or U16, check to see if there are 'Space' comments
 * above on where there are gaps which currently will be structure padding.  */

/* Within a stable branch, new variables must be added to the very end, before
 * this comment, for binary compatibility (the offsets of the old members must
 *  not change).
 * (Don't forget to add your variable also to perl_clone()!)
 */
                                                                                                                                                /*    invlist_inline.h
 *
 *    Copyright (C) 2012 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 */

#ifndef PERL_INVLIST_INLINE_H_
#define PERL_INVLIST_INLINE_H_

#if defined(PERL_IN_UTF8_C)             \
 || defined(PERL_IN_REGCOMP_C)          \
 || defined(PERL_IN_REGEXEC_C)          \
 || defined(PERL_IN_TOKE_C)             \
 || defined(PERL_IN_PP_C)               \
 || defined(PERL_IN_OP_C)               \
 || defined(PERL_IN_DOOP_C)

/* An element is in an inversion list iff its index is even numbered: 0, 2, 4,
 * etc */
#define ELEMENT_RANGE_MATCHES_INVLIST(i) (! ((i) & 1))
#define PREV_RANGE_MATCHES_INVLIST(i) (! ELEMENT_RANGE_MATCHES_INVLIST(i))

/* This converts to/from our UVs to what the SV code is expecting: bytes. */
#define TO_INTERNAL_SIZE(x) ((x) * sizeof(UV))
#define FROM_INTERNAL_SIZE(x) ((x)/ sizeof(UV))

PERL_STATIC_INLINE bool
S_is_invlist(const SV* const invlist)
{
    return invlist != NULL && SvTYPE(invlist) == SVt_INVLIST;
}

PERL_STATIC_INLINE bool*
S_get_invlist_offset_addr(SV* invlist)
{
    /* Return the address of the field that says whether the inversion list is
     * offset (it contains 1) or not (contains 0) */
    PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR;

    assert(is_invlist(invlist));

    return &(((XINVLIST*) SvANY(invlist))->is_offset);
}

PERL_STATIC_INLINE UV
S__invlist_len(SV* const invlist)
{
    /* Returns the current number of elements stored in the inversion list's
     * array */

    PERL_ARGS_ASSERT__INVLIST_LEN;

    assert(is_invlist(invlist));

    return (SvCUR(invlist) == 0)
           ? 0
           : FROM_INTERNAL_SIZE(SvCUR(invlist)) - *get_invlist_offset_addr(invlist);
}

PERL_STATIC_INLINE bool
S__invlist_contains_cp(SV* const invlist, const UV cp)
{
    /* Does <invlist> contain code point <cp> as part of the set? */

    IV index = _invlist_search(invlist, cp);

    PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP;

    return index >= 0 && ELEMENT_RANGE_MATCHES_INVLIST(index);
}

PERL_STATIC_INLINE UV*
S_invlist_array(SV* const invlist)
{
    /* Returns the pointer to the inversion list's array.  Every time the
     * length changes, this needs to be called in case malloc or realloc moved
     * it */

    PERL_ARGS_ASSERT_INVLIST_ARRAY;

    /* Must not be empty.  If these fail, you probably didn't check for <len>
     * being non-zero before trying to get the array */
    assert(_invlist_len(invlist));

    /* The very first element always contains zero, The array begins either
     * there, or if the inversion list is offset, at the element after it.
     * The offset header field determines which; it contains 0 or 1 to indicate
     * how much additionally to add */
    assert(0 == *(SvPVX(invlist)));
    return ((UV *) SvPVX(invlist) + *get_invlist_offset_addr(invlist));
}

#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C)

PERL_STATIC_INLINE void
S_invlist_extend(pTHX_ SV* const invlist, const UV new_max)
{
    /* Grow the maximum size of an inversion list */

    PERL_ARGS_ASSERT_INVLIST_EXTEND;

    assert(SvTYPE(invlist) == SVt_INVLIST);

    /* Add one to account for the zero element at the beginning which may not
     * be counted by the calling parameters */
    SvGROW((SV *)invlist, TO_INTERNAL_SIZE(new_max + 1));
}

PERL_STATIC_INLINE void
S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
{
    /* Sets the current number of elements stored in the inversion list.
     * Updates SvCUR correspondingly */
    PERL_UNUSED_CONTEXT;
    PERL_ARGS_ASSERT_INVLIST_SET_LEN;

    assert(SvTYPE(invlist) == SVt_INVLIST);

    SvCUR_set(invlist,
              (len == 0)
               ? 0
               : TO_INTERNAL_SIZE(len + offset));
    assert(SvLEN(invlist) == 0 || SvCUR(invlist) <= SvLEN(invlist));
}

PERL_STATIC_INLINE SV*
S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) {
    return _add_range_to_invlist(invlist, cp, cp);
}

PERL_STATIC_INLINE UV
S_invlist_highest(SV* const invlist)
{
    /* Returns the highest code point that matches an inversion list.  This API
     * has an ambiguity, as it returns 0 under either the highest is actually
     * 0, or if the list is empty.  If this distinction matters to you, check
     * for emptiness before calling this function */

    UV len = _invlist_len(invlist);
    UV *array;

    PERL_ARGS_ASSERT_INVLIST_HIGHEST;

    if (len == 0) {
        return 0;
    }

    array = invlist_array(invlist);

    /* The last element in the array in the inversion list always starts a
     * range that goes to infinity.  That range may be for code points that are
     * matched in the inversion list, or it may be for ones that aren't
     * matched.  In the latter case, the highest code point in the set is one
     * less than the beginning of this range; otherwise it is the final element
     * of this range: infinity */
    return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
           ? UV_MAX
           : array[len - 1] - 1;
}

#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C)

PERL_STATIC_INLINE STRLEN*
S_get_invlist_iter_addr(SV* invlist)
{
    /* Return the address of the UV that contains the current iteration
     * position */

    PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR;

    assert(is_invlist(invlist));

    return &(((XINVLIST*) SvANY(invlist))->iterator);
}

PERL_STATIC_INLINE void
S_invlist_iterinit(SV* invlist)	/* Initialize iterator for invlist */
{
    PERL_ARGS_ASSERT_INVLIST_ITERINIT;

    *get_invlist_iter_addr(invlist) = 0;
}

PERL_STATIC_INLINE void
S_invlist_iterfinish(SV* invlist)
{
    /* Terminate iterator for invlist.  This is to catch development errors.
     * Any iteration that is interrupted before completed should call this
     * function.  Functions that add code points anywhere else but to the end
     * of an inversion list assert that they are not in the middle of an
     * iteration.  If they were, the addition would make the iteration
     * problematical: if the iteration hadn't reached the place where things
     * were being added, it would be ok */

    PERL_ARGS_ASSERT_INVLIST_ITERFINISH;

    *get_invlist_iter_addr(invlist) = (STRLEN) UV_MAX;
}

STATIC bool
S_invlist_iternext(SV* invlist, UV* start, UV* end)
{
    /* An C<invlist_iterinit> call on <invlist> must be used to set this up.
     * This call sets in <*start> and <*end>, the next range in <invlist>.
     * Returns <TRUE> if successful and the next call will return the next
     * range; <FALSE> if was already at the end of the list.  If the latter,
     * <*start> and <*end> are unchanged, and the next call to this function
     * will start over at the beginning of the list */

    STRLEN* pos = get_invlist_iter_addr(invlist);
    UV len = _invlist_len(invlist);
    UV *array;

    PERL_ARGS_ASSERT_INVLIST_ITERNEXT;

    if (*pos >= len) {
        *pos = (STRLEN) UV_MAX;	/* Force iterinit() to be required next time */
        return FALSE;
    }

    array = invlist_array(invlist);

    *start = array[(*pos)++];

    if (*pos >= len) {
        *end = UV_MAX;
    }
    else {
        *end = array[(*pos)++] - 1;
    }

    return TRUE;
}

#endif

#ifndef PERL_IN_REGCOMP_C

/* These symbols are only needed later in regcomp.c */
#       undef TO_INTERNAL_SIZE
#       undef FROM_INTERNAL_SIZE
#endif

#endif /* PERL_INVLIST_INLINE_H_ */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /*
 * iperlsys.h - Perl's interface to the system
 *
 * This file defines the system level functionality that perl needs.
 *
 * When using C, this definition is in the form of a set of macros that can be
 * #defined to the system-level function (or a wrapper provided elsewhere).
 *
 * GSAR 21-JUN-98
 */

#ifndef __Inc__IPerl___
#define __Inc__IPerl___

/*
 *      PerlXXX_YYY explained - DickH and DougL @ ActiveState.com
 *
 * XXX := functional group
 * YYY := stdlib/OS function name
 *
 * Continuing with the theme of PerlIO, all OS functionality was encapsulated
 * into one of several interfaces.
 *
 * PerlIO - stdio
 * PerlLIO - low level I/O
 * PerlMem - malloc, realloc, free
 * PerlDir - directory related
 * PerlEnv - process environment handling
 * PerlProc - process control
 * PerlSock - socket functions
 *
 *
 * The features of this are:
 * 1. All OS dependant code is in the Perl Host and not the Perl Core.
 *    (At least this is the holy grail goal of this work)
 * 2. The Perl Host (see perl.h for description) can provide a new and
 *    improved interface to OS functionality if required.
 * 3. Developers can easily hook into the OS calls for instrumentation
 *    or diagnostic purposes.
 *
 * What was changed to do this:
 * 1. All calls to OS functions were replaced with PerlXXX_YYY
 *
 */

/*
    Interface for perl stdio functions, or whatever we are Configure-d
    to use.
*/
#include "perlio.h"


typedef Signal_t (*Sighandler1_t) (int);
typedef Signal_t (*Sighandler3_t) (int, Siginfo_t*, void*);

#ifndef Sighandler_t
#  ifdef PERL_USE_3ARG_SIGHANDLER
typedef Sighandler3_t Sighandler_t;
#  else
typedef Sighandler1_t Sighandler_t;
#  endif
#endif

#if defined(PERL_IMPLICIT_SYS)

/* IPerlStdIO           */
struct IPerlStdIO;
struct IPerlStdIOInfo;
typedef FILE*           (*LPStdin)(struct IPerlStdIO*);
typedef FILE*           (*LPStdout)(struct IPerlStdIO*);
typedef FILE*           (*LPStderr)(struct IPerlStdIO*);
typedef FILE*           (*LPOpen)(struct IPerlStdIO*, const char*,
                            const char*);
typedef int             (*LPClose)(struct IPerlStdIO*, FILE*);
typedef int             (*LPEof)(struct IPerlStdIO*, FILE*);
typedef int             (*LPError)(struct IPerlStdIO*, FILE*);
typedef void            (*LPClearerr)(struct IPerlStdIO*, FILE*);
typedef int             (*LPGetc)(struct IPerlStdIO*, FILE*);
typedef STDCHAR*        (*LPGetBase)(struct IPerlStdIO*, FILE*);
typedef int             (*LPGetBufsiz)(struct IPerlStdIO*, FILE*);
typedef int             (*LPGetCnt)(struct IPerlStdIO*, FILE*);
typedef STDCHAR*        (*LPGetPtr)(struct IPerlStdIO*, FILE*);
typedef char*           (*LPGets)(struct IPerlStdIO*, char*, int, FILE*);
typedef int             (*LPPutc)(struct IPerlStdIO*, int, FILE*);
typedef int             (*LPPuts)(struct IPerlStdIO*, const char *, FILE*);
typedef int             (*LPFlush)(struct IPerlStdIO*, FILE*);
typedef int             (*LPUngetc)(struct IPerlStdIO*, int,FILE*);
typedef int             (*LPFileno)(struct IPerlStdIO*, FILE*);
typedef FILE*           (*LPFdopen)(struct IPerlStdIO*, int, const char*);
typedef FILE*           (*LPReopen)(struct IPerlStdIO*, const char*,
                            const char*, FILE*);
typedef SSize_t         (*LPRead)(struct IPerlStdIO*, void*, Size_t, Size_t, FILE *);
typedef SSize_t         (*LPWrite)(struct IPerlStdIO*, const void*, Size_t, Size_t, FILE *);
typedef void            (*LPSetBuf)(struct IPerlStdIO*, FILE*, char*);
typedef int             (*LPSetVBuf)(struct IPerlStdIO*, FILE*, char*, int,
                            Size_t);
typedef void            (*LPSetCnt)(struct IPerlStdIO*, FILE*, int);

typedef void            (*LPSetPtr)(struct IPerlStdIO*, FILE*, STDCHAR*);

typedef void            (*LPSetlinebuf)(struct IPerlStdIO*, FILE*);
typedef int             (*LPPrintf)(struct IPerlStdIO*, FILE*, const char*,
                            ...);
typedef int             (*LPVprintf)(struct IPerlStdIO*, FILE*, const char*,
                            va_list);
typedef Off_t           (*LPTell)(struct IPerlStdIO*, FILE*);
typedef int             (*LPSeek)(struct IPerlStdIO*, FILE*, Off_t, int);
typedef void            (*LPRewind)(struct IPerlStdIO*, FILE*);
typedef FILE*           (*LPTmpfile)(struct IPerlStdIO*);
typedef int             (*LPGetpos)(struct IPerlStdIO*, FILE*, Fpos_t*);
typedef int             (*LPSetpos)(struct IPerlStdIO*, FILE*,
                            const Fpos_t*);
typedef void            (*LPInit)(struct IPerlStdIO*);
typedef void            (*LPInitOSExtras)(struct IPerlStdIO*);
typedef FILE*           (*LPFdupopen)(struct IPerlStdIO*, FILE*);

struct IPerlStdIO
{
    LPStdin             pStdin;
    LPStdout            pStdout;
    LPStderr            pStderr;
    LPOpen              pOpen;
    LPClose             pClose;
    LPEof               pEof;
    LPError             pError;
    LPClearerr          pClearerr;
    LPGetc              pGetc;
    LPGetBase           pGetBase;
    LPGetBufsiz         pGetBufsiz;
    LPGetCnt            pGetCnt;
    LPGetPtr            pGetPtr;
    LPGets              pGets;
    LPPutc              pPutc;
    LPPuts              pPuts;
    LPFlush             pFlush;
    LPUngetc            pUngetc;
    LPFileno            pFileno;
    LPFdopen            pFdopen;
    LPReopen            pReopen;
    LPRead              pRead;
    LPWrite             pWrite;
    LPSetBuf            pSetBuf;
    LPSetVBuf           pSetVBuf;
    LPSetCnt            pSetCnt;
    LPSetPtr            pSetPtr;
    LPSetlinebuf        pSetlinebuf;
    LPPrintf            pPrintf;
    LPVprintf           pVprintf;
    LPTell              pTell;
    LPSeek              pSeek;
    LPRewind            pRewind;
    LPTmpfile           pTmpfile;
    LPGetpos            pGetpos;
    LPSetpos            pSetpos;
    LPInit              pInit;
    LPInitOSExtras      pInitOSExtras;
    LPFdupopen          pFdupopen;
};

struct IPerlStdIOInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlStdIO   perlStdIOList;
};

/* These do not belong here ... NI-S, 14 Nov 2000 */

#  ifdef USE_STDIO_PTR
#    define PerlSIO_has_cntptr(f)       1
#    ifdef STDIO_PTR_LVALUE
#      ifdef  STDIO_CNT_LVALUE
#        define PerlSIO_canset_cnt(f)   1
#        ifdef STDIO_PTR_LVAL_NOCHANGE_CNT
#          define PerlSIO_fast_gets(f)  1
#        endif
#      else /* STDIO_CNT_LVALUE */
#        define PerlSIO_canset_cnt(f)   0
#      endif
#    else /* STDIO_PTR_LVALUE */
#      ifdef STDIO_PTR_LVAL_SETS_CNT
#        define PerlSIO_fast_gets(f)    1
#      endif
#    endif
#  else  /* USE_STDIO_PTR */
#    define PerlSIO_has_cntptr(f)       0
#    define PerlSIO_canset_cnt(f)       0
#  endif /* USE_STDIO_PTR */

#  ifndef PerlSIO_fast_gets
#  define PerlSIO_fast_gets(f)          0
#  endif

#  ifdef FILE_base
#    define PerlSIO_has_base(f)         1
#  else
#    define PerlSIO_has_base(f)         0
#  endif

/* Now take FILE * via function table */

#  define PerlSIO_stdin                                                 \
        (*PL_StdIO->pStdin)(PL_StdIO)
#  define PerlSIO_stdout                                                \
        (*PL_StdIO->pStdout)(PL_StdIO)
#  define PerlSIO_stderr                                                \
        (*PL_StdIO->pStderr)(PL_StdIO)
#  define PerlSIO_fopen(x,y)                                            \
        (*PL_StdIO->pOpen)(PL_StdIO, (x),(y))
#  define PerlSIO_fclose(f)                                             \
        (*PL_StdIO->pClose)(PL_StdIO, (f))
#  define PerlSIO_feof(f)                                               \
        (*PL_StdIO->pEof)(PL_StdIO, (f))
#  define PerlSIO_ferror(f)                                             \
        (*PL_StdIO->pError)(PL_StdIO, (f))
#  define PerlSIO_clearerr(f)                                           \
        (*PL_StdIO->pClearerr)(PL_StdIO, (f))
#  define PerlSIO_fgetc(f)                                              \
        (*PL_StdIO->pGetc)(PL_StdIO, (f))
#  define PerlSIO_get_base(f)                                           \
        (*PL_StdIO->pGetBase)(PL_StdIO, (f))
#  define PerlSIO_get_bufsiz(f)                                         \
        (*PL_StdIO->pGetBufsiz)(PL_StdIO, (f))
#  define PerlSIO_get_cnt(f)                                            \
        (*PL_StdIO->pGetCnt)(PL_StdIO, (f))
#  define PerlSIO_get_ptr(f)                                            \
        (*PL_StdIO->pGetPtr)(PL_StdIO, (f))
#  define PerlSIO_fputc(c,f)                                            \
        (*PL_StdIO->pPutc)(PL_StdIO, (c),(f))
#  define PerlSIO_fputs(s,f)                                            \
        (*PL_StdIO->pPuts)(PL_StdIO, (s),(f))
#  define PerlSIO_fflush(f)                                             \
        (*PL_StdIO->pFlush)(PL_StdIO, (f))
#  define PerlSIO_fgets(s, n, f)                                        \
        (*PL_StdIO->pGets)(PL_StdIO, s, n, (f))
#  define PerlSIO_ungetc(c,f)                                           \
        (*PL_StdIO->pUngetc)(PL_StdIO, (c),(f))
#  define PerlSIO_fileno(f)                                             \
        (*PL_StdIO->pFileno)(PL_StdIO, (f))
#  define PerlSIO_fdopen(f, s)                                          \
        (*PL_StdIO->pFdopen)(PL_StdIO, (f),(s))
#  define PerlSIO_freopen(p, m, f)                                      \
        (*PL_StdIO->pReopen)(PL_StdIO, (p), (m), (f))
#  define PerlSIO_fread(buf,sz,count,f)                                 \
        (*PL_StdIO->pRead)(PL_StdIO, (buf), (sz), (count), (f))
#  define PerlSIO_fwrite(buf,sz,count,f)                                \
        (*PL_StdIO->pWrite)(PL_StdIO, (buf), (sz), (count), (f))
#  define PerlSIO_setbuf(f,b)                                           \
        (*PL_StdIO->pSetBuf)(PL_StdIO, (f), (b))
#  define PerlSIO_setvbuf(f,b,t,s)                                      \
        (*PL_StdIO->pSetVBuf)(PL_StdIO, (f),(b),(t),(s))
#  define PerlSIO_set_cnt(f,c)                                          \
        (*PL_StdIO->pSetCnt)(PL_StdIO, (f), (c))
#  define PerlSIO_set_ptr(f,p)                                          \
        (*PL_StdIO->pSetPtr)(PL_StdIO, (f), (p))
#  define PerlSIO_setlinebuf(f)                                         \
        (*PL_StdIO->pSetlinebuf)(PL_StdIO, (f))
#  define PerlSIO_printf                Perl_fprintf_nocontext
#  define PerlSIO_stdoutf               Perl_printf_nocontext
#  define PerlSIO_vprintf(f,fmt,a)                                      \
        (*PL_StdIO->pVprintf)(PL_StdIO, (f),(fmt),a)
#  define PerlSIO_ftell(f)                                              \
        (*PL_StdIO->pTell)(PL_StdIO, (f))
#  define PerlSIO_fseek(f,o,w)                                          \
        (*PL_StdIO->pSeek)(PL_StdIO, (f),(o),(w))
#  define PerlSIO_fgetpos(f,p)                                          \
        (*PL_StdIO->pGetpos)(PL_StdIO, (f),(p))
#  define PerlSIO_fsetpos(f,p)                                          \
        (*PL_StdIO->pSetpos)(PL_StdIO, (f),(p))
#  define PerlSIO_rewind(f)                                             \
        (*PL_StdIO->pRewind)(PL_StdIO, (f))
#  define PerlSIO_tmpfile()                                             \
        (*PL_StdIO->pTmpfile)(PL_StdIO)
#  define PerlSIO_init()                                                \
        (*PL_StdIO->pInit)(PL_StdIO)
#  undef        init_os_extras
#  define init_os_extras()                                              \
        (*PL_StdIO->pInitOSExtras)(PL_StdIO)
#  define PerlSIO_fdupopen(f)                                           \
        (*PL_StdIO->pFdupopen)(PL_StdIO, (f))

#else   /* ! PERL_IMPLICIT_SYS */

#  define PerlSIO_stdin                 stdin
#  define PerlSIO_stdout                        stdout
#  define PerlSIO_stderr                        stderr
#  define PerlSIO_fopen(x,y)            fopen(x,y)
#  ifdef __VOS__
   /* Work around VOS bug posix-979, wrongly setting errno when at end of file. */
#    define PerlSIO_fclose(f)           (((errno==1025)?errno=0:0),fclose(f))
#    define PerlSIO_feof(f)                     (((errno==1025)?errno=0:0),feof(f))
#    define PerlSIO_ferror(f)           (((errno==1025)?errno=0:0),ferror(f))
#  else
#    define PerlSIO_fclose(f)           fclose(f)
#    define PerlSIO_feof(f)                     feof(f)
#    define PerlSIO_ferror(f)           ferror(f)
#  endif
#  define PerlSIO_clearerr(f)           clearerr(f)
#  define PerlSIO_fgetc(f)                      fgetc(f)
#  ifdef FILE_base
#    define PerlSIO_get_base(f)         FILE_base(f)
#    define PerlSIO_get_bufsiz(f)               FILE_bufsiz(f)
#  else
#    define PerlSIO_get_base(f)         NULL
#    define PerlSIO_get_bufsiz(f)               0
#  endif
#  ifdef USE_STDIO_PTR
#    define PerlSIO_get_cnt(f)          FILE_cnt(f)
#    define PerlSIO_get_ptr(f)          FILE_ptr(f)
#  else
#    define PerlSIO_get_cnt(f)          0
#    define PerlSIO_get_ptr(f)          NULL
#  endif
#  define PerlSIO_fputc(c,f)            fputc(c,f)
#  define PerlSIO_fputs(s,f)            fputs(s,f)
#  define PerlSIO_fflush(f)             Fflush(f)
#  define PerlSIO_fgets(s, n, f)                fgets(s,n,f)
#  if defined(__VMS)
     /* Unusual definition of ungetc() here to accommodate fast_sv_gets()'
      * belief that it can mix getc/ungetc with reads from stdio buffer */
START_EXTERN_C
     int decc$ungetc(int __c, FILE *__stream);
END_EXTERN_C
#      define PerlSIO_ungetc(c,f) ((c) == EOF ? EOF :   \
            ((*(f) && !((*(f))->_flag & _IONBF) &&      \
            ((*(f))->_ptr > (*(f))->_base)) ?           \
            ((*(f))->_cnt++, *(--(*(f))->_ptr) = (c)) : decc$ungetc(c,f)))
#  else
#    define PerlSIO_ungetc(c,f)          ungetc(c,f)
#  endif
#  define PerlSIO_fileno(f)             fileno(f)
#  define PerlSIO_fdopen(f, s)          fdopen(f,s)
#  define PerlSIO_freopen(p, m, f)      freopen(p,m,f)
#  define PerlSIO_fread(buf,sz,count,f) fread(buf,sz,count,f)
#  define PerlSIO_fwrite(buf,sz,count,f)        fwrite(buf,sz,count,f)
#  define PerlSIO_setbuf(f,b)           setbuf(f,b)
#  define PerlSIO_setvbuf(f,b,t,s)      setvbuf(f,b,t,s)
#  if defined(USE_STDIO_PTR) && defined(STDIO_CNT_LVALUE)
#    define PerlSIO_set_cnt(f,c)                FILE_cnt(f) = (c)
#  else
#    define PerlSIO_set_cnt(f,c)                PerlIOProc_abort()
#  endif
#  if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE)
#    define PerlSIO_set_ptr(f,p)                (FILE_ptr(f) = (p))
#  else
#    define PerlSIO_set_ptr(f,p)                PerlIOProc_abort()
#  endif
#  define PerlSIO_setlinebuf(f)         setlinebuf(f)
#  define PerlSIO_printf                        fprintf
#  define PerlSIO_stdoutf                       printf
#  define PerlSIO_vprintf(f,fmt,a)      vfprintf(f,fmt,a)
#  define PerlSIO_ftell(f)              ftell(f)
#  define PerlSIO_fseek(f,o,w)          fseek(f,o,w)
#  define PerlSIO_fgetpos(f,p)          fgetpos(f,p)
#  define PerlSIO_fsetpos(f,p)          fsetpos(f,p)
#  define PerlSIO_rewind(f)             rewind(f)
#  define PerlSIO_tmpfile()             tmpfile()
#  define PerlSIO_fdupopen(f)           (f)

#endif  /* PERL_IMPLICIT_SYS */

/*
 *   Interface for directory functions
 */

#if defined(PERL_IMPLICIT_SYS)

/* IPerlDir             */
struct IPerlDir;
struct IPerlDirInfo;
typedef int             (*LPMakedir)(struct IPerlDir*, const char*, int);
typedef int             (*LPChdir)(struct IPerlDir*, const char*);
typedef int             (*LPRmdir)(struct IPerlDir*, const char*);
typedef int             (*LPDirClose)(struct IPerlDir*, DIR*);
typedef DIR*            (*LPDirOpen)(struct IPerlDir*, const char*);
typedef struct direct*  (*LPDirRead)(struct IPerlDir*, DIR*);
typedef void            (*LPDirRewind)(struct IPerlDir*, DIR*);
typedef void            (*LPDirSeek)(struct IPerlDir*, DIR*, long);
typedef long            (*LPDirTell)(struct IPerlDir*, DIR*);
#  ifdef WIN32
typedef char*           (*LPDirMapPathA)(struct IPerlDir*, const char*);
typedef WCHAR*          (*LPDirMapPathW)(struct IPerlDir*, const WCHAR*);
#  endif

struct IPerlDir
{
    LPMakedir           pMakedir;
    LPChdir             pChdir;
    LPRmdir             pRmdir;
    LPDirClose          pClose;
    LPDirOpen           pOpen;
    LPDirRead           pRead;
    LPDirRewind         pRewind;
    LPDirSeek           pSeek;
    LPDirTell           pTell;
#  ifdef WIN32
    LPDirMapPathA       pMapPathA;
    LPDirMapPathW       pMapPathW;
#  endif
};

struct IPerlDirInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlDir     perlDirList;
};

#  define PerlDir_mkdir(name, mode)                             \
        (*PL_Dir->pMakedir)(PL_Dir, (name), (mode))
#  define PerlDir_chdir(name)                                   \
        (*PL_Dir->pChdir)(PL_Dir, (name))
#  define PerlDir_rmdir(name)                                   \
        (*PL_Dir->pRmdir)(PL_Dir, (name))
#  define PerlDir_close(dir)                                    \
        (*PL_Dir->pClose)(PL_Dir, (dir))
#  define PerlDir_open(name)                                    \
        (*PL_Dir->pOpen)(PL_Dir, (name))
#  define PerlDir_read(dir)                                     \
        (*PL_Dir->pRead)(PL_Dir, (dir))
#  define PerlDir_rewind(dir)                                   \
        (*PL_Dir->pRewind)(PL_Dir, (dir))
#  define PerlDir_seek(dir, loc)                                \
        (*PL_Dir->pSeek)(PL_Dir, (dir), (loc))
#  define PerlDir_tell(dir)                                     \
        (*PL_Dir->pTell)(PL_Dir, (dir))
#  ifdef WIN32
#    define PerlDir_mapA(dir)                                   \
        (*PL_Dir->pMapPathA)(PL_Dir, (dir))
#    define PerlDir_mapW(dir)                                   \
        (*PL_Dir->pMapPathW)(PL_Dir, (dir))
#    endif

#  else /* ! PERL_IMPLICIT_SYS */

#  define PerlDir_mkdir(name, mode)     Mkdir((name), (mode))
#  ifdef VMS
#    define PerlDir_chdir(n)            Chdir((n))
#  else
#    define PerlDir_chdir(name)         chdir((name))
#  endif
#  define PerlDir_rmdir(name)           rmdir((name))
#  define PerlDir_close(dir)            closedir((dir))
#  define PerlDir_open(name)            opendir((name))
#  define PerlDir_read(dir)             readdir((dir))
#  define PerlDir_rewind(dir)           rewinddir((dir))
#  define PerlDir_seek(dir, loc)                seekdir((dir), (loc))
#  define PerlDir_tell(dir)             telldir((dir))
#  ifdef WIN32
#    define PerlDir_mapA(dir)           dir
#    define PerlDir_mapW(dir)           dir
#  endif

#endif  /* PERL_IMPLICIT_SYS */

/*
    Interface for perl environment functions
*/

#if defined(PERL_IMPLICIT_SYS)

/* IPerlEnv             */
struct IPerlEnv;
struct IPerlEnvInfo;
typedef char*           (*LPEnvGetenv)(struct IPerlEnv*, const char*);
typedef int             (*LPEnvPutenv)(struct IPerlEnv*, const char*);
typedef char*           (*LPEnvGetenv_len)(struct IPerlEnv*,
                                    const char *varname, unsigned long *len);
typedef int             (*LPEnvUname)(struct IPerlEnv*, struct utsname *name);
typedef void            (*LPEnvClearenv)(struct IPerlEnv*);
typedef void*           (*LPEnvGetChildenv)(struct IPerlEnv*);
typedef void            (*LPEnvFreeChildenv)(struct IPerlEnv*, void* env);
typedef char*           (*LPEnvGetChilddir)(struct IPerlEnv*);
typedef void            (*LPEnvFreeChilddir)(struct IPerlEnv*, char* dir);
#  ifdef HAS_ENVGETENV
typedef char*           (*LPENVGetenv)(struct IPerlEnv*, const char *varname);
typedef char*           (*LPENVGetenv_len)(struct IPerlEnv*,
                                    const char *varname, unsigned long *len);
#  endif
#  ifdef WIN32
typedef unsigned long   (*LPEnvOsID)(struct IPerlEnv*);
typedef char*           (*LPEnvLibPath)(struct IPerlEnv*, WIN32_NO_REGISTRY_M_(const char*)
                                        STRLEN *const len);
typedef char*           (*LPEnvSiteLibPath)(struct IPerlEnv*, const char*,
                                            STRLEN *const len);
typedef char*           (*LPEnvVendorLibPath)(struct IPerlEnv*, const char*,
                                              STRLEN *const len);
typedef void            (*LPEnvGetChildIO)(struct IPerlEnv*, child_IO_table*);
#  endif

struct IPerlEnv
{
    LPEnvGetenv         pGetenv;
    LPEnvPutenv         pPutenv;
    LPEnvGetenv_len     pGetenv_len;
    LPEnvUname          pEnvUname;
    LPEnvClearenv       pClearenv;
    LPEnvGetChildenv    pGetChildenv;
    LPEnvFreeChildenv   pFreeChildenv;
    LPEnvGetChilddir    pGetChilddir;
    LPEnvFreeChilddir   pFreeChilddir;
#  ifdef HAS_ENVGETENV
    LPENVGetenv         pENVGetenv;
    LPENVGetenv_len     pENVGetenv_len;
#  endif
#  ifdef WIN32
    LPEnvOsID           pEnvOsID;
    LPEnvLibPath        pLibPath;
    LPEnvSiteLibPath    pSiteLibPath;
    LPEnvVendorLibPath  pVendorLibPath;
    LPEnvGetChildIO     pGetChildIO;
#  endif
};

struct IPerlEnvInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlEnv     perlEnvList;
};

#  define PerlEnv_putenv(str)                                   \
        (*PL_Env->pPutenv)(PL_Env,(str))
#  define PerlEnv_getenv(str)                                   \
        (*PL_Env->pGetenv)(PL_Env,(str))
#  define PerlEnv_getenv_len(str,l)                             \
        (*PL_Env->pGetenv_len)(PL_Env,(str), (l))
#  define PerlEnv_clearenv()                                    \
        (*PL_Env->pClearenv)(PL_Env)
#  define PerlEnv_get_childenv()                                \
        (*PL_Env->pGetChildenv)(PL_Env)
#  define PerlEnv_free_childenv(e)                              \
        (*PL_Env->pFreeChildenv)(PL_Env, (e))
#  define PerlEnv_get_childdir()                                \
        (*PL_Env->pGetChilddir)(PL_Env)
#  define PerlEnv_free_childdir(d)                              \
        (*PL_Env->pFreeChilddir)(PL_Env, (d))
#  ifdef HAS_ENVGETENV
#    define PerlEnv_ENVgetenv(str)                              \
        (*PL_Env->pENVGetenv)(PL_Env,(str))
#    define PerlEnv_ENVgetenv_len(str,l)                        \
        (*PL_Env->pENVGetenv_len)(PL_Env,(str), (l))
#  else
#    define PerlEnv_ENVgetenv(str)                              \
        PerlEnv_getenv((str))
#    define PerlEnv_ENVgetenv_len(str,l)                        \
        PerlEnv_getenv_len((str),(l))
#  endif
#  define PerlEnv_uname(name)                                   \
        (*PL_Env->pEnvUname)(PL_Env,(name))
#  ifdef WIN32
#    define PerlEnv_os_id()                                     \
        (*PL_Env->pEnvOsID)(PL_Env)
#    define PerlEnv_lib_path(str, lenp)                         \
        (*PL_Env->pLibPath)(PL_Env,WIN32_NO_REGISTRY_M_(str)(lenp))
#    define PerlEnv_sitelib_path(str, lenp)                     \
        (*PL_Env->pSiteLibPath)(PL_Env,(str),(lenp))
#    define PerlEnv_vendorlib_path(str, lenp)                   \
        (*PL_Env->pVendorLibPath)(PL_Env,(str),(lenp))
#    define PerlEnv_get_child_IO(ptr)                           \
        (*PL_Env->pGetChildIO)(PL_Env, ptr)
#  endif

#else   /* below is ! PERL_IMPLICIT_SYS */
#  ifdef USE_ITHREADS

     /* Use the comma operator to return 0/non-zero, while avoiding putting
      * this in an inline function */
#    define PerlEnv_putenv(str) (ENV_LOCK, (putenv(str)         \
                                            ? (ENV_UNLOCK, 1)   \
                                            : (ENV_UNLOCK, 0)))
#  else
#    define PerlEnv_putenv(str)         putenv(str)
#  endif
#  define PerlEnv_getenv(str)           mortal_getenv(str)
#  define PerlEnv_getenv_len(str,l)     getenv_len((str), (l))
#  ifdef HAS_ENVGETENV
#    define PerlEnv_ENVgetenv(str)      ENVgetenv((str))
#    define PerlEnv_ENVgetenv_len(str,l)        ENVgetenv_len((str), (l))
#  else
#    define PerlEnv_ENVgetenv(str)      PerlEnv_getenv((str))
#    define PerlEnv_ENVgetenv_len(str,l)        PerlEnv_getenv_len((str), (l))
#  endif
#  define PerlEnv_uname(name)           uname((name))

#  ifdef WIN32
#    define PerlEnv_os_id()                     win32_os_id()
#    define PerlEnv_lib_path(str, lenp) win32_get_privlib(WIN32_NO_REGISTRY_M_(str) lenp)
#    define PerlEnv_sitelib_path(str, lenp)     win32_get_sitelib(str, lenp)
#    define PerlEnv_vendorlib_path(str, lenp)   win32_get_vendorlib(str, lenp)
#  define PerlEnv_get_child_IO(ptr)     win32_get_child_IO(ptr)
#  define PerlEnv_clearenv()            win32_clearenv()
#  define PerlEnv_get_childenv()                win32_get_childenv()
#  define PerlEnv_free_childenv(e)      win32_free_childenv((e))
#  define PerlEnv_get_childdir()                win32_get_childdir()
#  define PerlEnv_free_childdir(d)      win32_free_childdir((d))
#  else
#    define PerlEnv_clearenv(str)               (ENV_LOCK, (clearenv(str)   \
                                                    ? (ENV_UNLOCK, 1)       \
                                                    : (ENV_UNLOCK, 0)))
#    define PerlEnv_get_childenv()              get_childenv()
#    define PerlEnv_free_childenv(e)    free_childenv((e))
#    define PerlEnv_get_childdir()              get_childdir()
#    define PerlEnv_free_childdir(d)    free_childdir((d))
#  endif

#endif  /* PERL_IMPLICIT_SYS */

/*
    Interface for perl low-level IO functions
*/

#if defined(PERL_IMPLICIT_SYS)

struct utimbuf; /* prevent gcc warning about the use below */

/* IPerlLIO             */
struct IPerlLIO;
struct IPerlLIOInfo;
typedef int             (*LPLIOAccess)(struct IPerlLIO*, const char*, int);
typedef int             (*LPLIOChmod)(struct IPerlLIO*, const char*, int);
typedef int             (*LPLIOChown)(struct IPerlLIO*, const char*, uid_t,
                            gid_t);
typedef int             (*LPLIOChsize)(struct IPerlLIO*, int, Off_t);
typedef int             (*LPLIOClose)(struct IPerlLIO*, int);
typedef int             (*LPLIODup)(struct IPerlLIO*, int);
typedef int             (*LPLIODup2)(struct IPerlLIO*, int, int);
typedef int             (*LPLIOFlock)(struct IPerlLIO*, int, int);
typedef int             (*LPLIOFileStat)(struct IPerlLIO*, int, Stat_t*);
typedef int             (*LPLIOIOCtl)(struct IPerlLIO*, int, unsigned int,
                            char*);
typedef int             (*LPLIOIsatty)(struct IPerlLIO*, int);
typedef int             (*LPLIOLink)(struct IPerlLIO*, const char*,
                                     const char *);
typedef Off_t           (*LPLIOLseek)(struct IPerlLIO*, int, Off_t, int);
typedef int             (*LPLIOLstat)(struct IPerlLIO*, const char*,
                            Stat_t*);
typedef char*           (*LPLIOMktemp)(struct IPerlLIO*, char*);
typedef int             (*LPLIOOpen)(struct IPerlLIO*, const char*, int);       
typedef int             (*LPLIOOpen3)(struct IPerlLIO*, const char*, int, int); 
typedef int             (*LPLIORead)(struct IPerlLIO*, int, void*, unsigned int);
typedef int             (*LPLIORename)(struct IPerlLIO*, const char*,
                            const char*);
typedef int             (*LPLIOSetmode)(struct IPerlLIO*, int, int);
typedef int             (*LPLIONameStat)(struct IPerlLIO*, const char*,
                            Stat_t*);
typedef char*           (*LPLIOTmpnam)(struct IPerlLIO*, char*);
typedef int             (*LPLIOUmask)(struct IPerlLIO*, int);
typedef int             (*LPLIOUnlink)(struct IPerlLIO*, const char*);
typedef int             (*LPLIOUtime)(struct IPerlLIO*, const char*, struct utimbuf*);
typedef int             (*LPLIOWrite)(struct IPerlLIO*, int, const void*,
                            unsigned int);
typedef int             (*LPLIOSymLink)(struct IPerlLIO*, const char*,
                                     const char *);
typedef int             (*LPLIOReadLink)(struct IPerlLIO*, const char*,
                                         char *, size_t);

struct IPerlLIO
{
    LPLIOAccess         pAccess;
    LPLIOChmod          pChmod;
    LPLIOChown          pChown;
    LPLIOChsize         pChsize;
    LPLIOClose          pClose;
    LPLIODup            pDup;
    LPLIODup2           pDup2;
    LPLIOFlock          pFlock;
    LPLIOFileStat       pFileStat;
    LPLIOIOCtl          pIOCtl;
    LPLIOIsatty         pIsatty;
    LPLIOLink           pLink;
    LPLIOLseek          pLseek;
    LPLIOLstat          pLstat;
    LPLIOMktemp         pMktemp;
    LPLIOOpen           pOpen;
    LPLIOOpen3          pOpen3;
    LPLIORead           pRead;
    LPLIORename         pRename;
    LPLIOSetmode        pSetmode;
    LPLIONameStat       pNameStat;
    LPLIOTmpnam         pTmpnam;
    LPLIOUmask          pUmask;
    LPLIOUnlink         pUnlink;
    LPLIOUtime          pUtime;
    LPLIOWrite          pWrite;
    LPLIOSymLink        pSymLink;
    LPLIOReadLink       pReadLink;
};

struct IPerlLIOInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlLIO     perlLIOList;
};

#  define PerlLIO_access(file, mode)                                    \
        (*PL_LIO->pAccess)(PL_LIO, (file), (mode))
#  define PerlLIO_chmod(file, mode)                                     \
        (*PL_LIO->pChmod)(PL_LIO, (file), (mode))
#  define PerlLIO_chown(file, owner, group)                             \
        (*PL_LIO->pChown)(PL_LIO, (file), (owner), (group))
#  define PerlLIO_chsize(fd, size)                                      \
        (*PL_LIO->pChsize)(PL_LIO, (fd), (size))
#  define PerlLIO_close(fd)                                             \
        (*PL_LIO->pClose)(PL_LIO, (fd))
#  define PerlLIO_dup(fd)                                               \
        (*PL_LIO->pDup)(PL_LIO, (fd))
#  define PerlLIO_dup2(fd1, fd2)                                        \
        (*PL_LIO->pDup2)(PL_LIO, (fd1), (fd2))
#  define PerlLIO_flock(fd, op)                                         \
        (*PL_LIO->pFlock)(PL_LIO, (fd), (op))
#  define PerlLIO_fstat(fd, buf)                                        \
        (*PL_LIO->pFileStat)(PL_LIO, (fd), (buf))
#  define PerlLIO_ioctl(fd, u, buf)                                     \
        (*PL_LIO->pIOCtl)(PL_LIO, (fd), (u), (buf))
#  define PerlLIO_isatty(fd)                                            \
        (*PL_LIO->pIsatty)(PL_LIO, (fd))
#  define PerlLIO_link(oldname, newname)                                \
        (*PL_LIO->pLink)(PL_LIO, (oldname), (newname))
#  define PerlLIO_symlink(oldname, newname)                             \
        (*PL_LIO->pSymLink)(PL_LIO, (oldname), (newname))
#  define PerlLIO_readlink(path, buf, bufsiz)                           \
        (*PL_LIO->pReadLink)(PL_LIO, (path), (buf), (bufsiz))
#  define PerlLIO_lseek(fd, offset, mode)                               \
        (*PL_LIO->pLseek)(PL_LIO, (fd), (offset), (mode))
#  define PerlLIO_lstat(name, buf)                                      \
        (*PL_LIO->pLstat)(PL_LIO, (name), (buf))
#  define PerlLIO_mktemp(file)                                          \
        (*PL_LIO->pMktemp)(PL_LIO, (file))
#  define PerlLIO_open(file, flag)                                      \
        (*PL_LIO->pOpen)(PL_LIO, (file), (flag))
#  define PerlLIO_open3(file, flag, perm)                               \
        (*PL_LIO->pOpen3)(PL_LIO, (file), (flag), (perm))
#  define PerlLIO_read(fd, buf, count)                                  \
        (*PL_LIO->pRead)(PL_LIO, (fd), (buf), (count))
#  define PerlLIO_rename(oname, newname)                                \
        (*PL_LIO->pRename)(PL_LIO, (oname), (newname))
#  define PerlLIO_setmode(fd, mode)                                     \
        (*PL_LIO->pSetmode)(PL_LIO, (fd), (mode))
#  define PerlLIO_stat(name, buf)                                       \
        (*PL_LIO->pNameStat)(PL_LIO, (name), (buf))
#  define PerlLIO_tmpnam(str)                                           \
        (*PL_LIO->pTmpnam)(PL_LIO, (str))
#  define PerlLIO_umask(mode)                                           \
        (*PL_LIO->pUmask)(PL_LIO, (mode))
#  define PerlLIO_unlink(file)                                          \
        (*PL_LIO->pUnlink)(PL_LIO, (file))
#  define PerlLIO_utime(file, time)                                     \
        (*PL_LIO->pUtime)(PL_LIO, (file), (time))
#  define PerlLIO_write(fd, buf, count)                                 \
        (*PL_LIO->pWrite)(PL_LIO, (fd), (buf), (count))

#else   /* ! PERL_IMPLICIT_SYS */

#  define PerlLIO_access(file, mode)    access((file), (mode))
#  define PerlLIO_chmod(file, mode)     chmod((file), (mode))
#  define PerlLIO_chown(file, owner, grp)       chown((file), (owner), (grp))
#  if defined(HAS_TRUNCATE)
#    define PerlLIO_chsize(fd, size)    ftruncate((fd), (size))
#  elif defined(HAS_CHSIZE)
#    define PerlLIO_chsize(fd, size)    chsize((fd), (size))
#  else
#    define PerlLIO_chsize(fd, size)    my_chsize((fd), (size))
#  endif
#  define PerlLIO_close(fd)             close((fd))
#  define PerlLIO_dup(fd)                       dup((fd))
#  define PerlLIO_dup2(fd1, fd2)                dup2((fd1), (fd2))
#  define PerlLIO_flock(fd, op)         FLOCK((fd), (op))
#  define PerlLIO_fstat(fd, buf)                Fstat((fd), (buf))
#  define PerlLIO_ioctl(fd, u, buf)     ioctl((fd), (u), (buf))
#  define PerlLIO_isatty(fd)            isatty((fd))
#  define PerlLIO_link(oldname, newname)        link((oldname), (newname))
#  define PerlLIO_symlink(oldname, newname)     symlink((oldname), (newname))
#  define PerlLIO_readlink(path, buf, bufsiz)   readlink((path), (buf), (bufsiz))
#  define PerlLIO_lseek(fd, offset, mode)       lseek((fd), (offset), (mode))
#  define PerlLIO_stat(name, buf)               Stat((name), (buf))
#  ifdef HAS_LSTAT
#    define PerlLIO_lstat(name, buf)    lstat((name), (buf))
#  else
#    define PerlLIO_lstat(name, buf)    PerlLIO_stat((name), (buf))
#  endif
#  define PerlLIO_mktemp(file)          mktemp((file))
#  if defined(OEMVS)
#    if (__CHARSET_LIB == 1)
    int asciiopen(const char* path, int oflag);
    int asciiopen3(const char* path, int oflag, int perm);

#      define PerlLIO_open(file, flag)          asciiopen((file), (flag))
#      define PerlLIO_open3(file, flag, perm)   asciiopen3((file), (flag), (perm))
#    else
#      define PerlLIO_open(file, flag)          open((file), (flag))
#      define PerlLIO_open3(file, flag, perm)   open((file), (flag), (perm))
#    endif
#  else
#    define PerlLIO_open(file, flag)            open((file), (flag))
#    define PerlLIO_open3(file, flag, perm)     open((file), (flag), (perm))
#  endif
#  define PerlLIO_read(fd, buf, count)  read((fd), (buf), (count))
#  define PerlLIO_rename(old, new)      rename((old), (new))
#  define PerlLIO_setmode(fd, mode)     setmode((fd), (mode))
#  define PerlLIO_tmpnam(str)           tmpnam((str))
#  define PerlLIO_umask(mode)           umask((mode))
#  define PerlLIO_unlink(file)          unlink((file))
#  define PerlLIO_utime(file, time)     utime((file), (time))
#  define PerlLIO_write(fd, buf, count) write((fd), (buf), (count))

#endif  /* PERL_IMPLICIT_SYS */

/*
    Interface for perl memory allocation
*/

#if defined(PERL_IMPLICIT_SYS)

/* IPerlMem             */
struct IPerlMem;
struct IPerlMemInfo;
typedef void*           (*LPMemMalloc)(struct IPerlMem*, size_t);
typedef void*           (*LPMemRealloc)(struct IPerlMem*, void*, size_t);
typedef void            (*LPMemFree)(struct IPerlMem*, void*);
typedef void*           (*LPMemCalloc)(struct IPerlMem*, size_t, size_t);
typedef void            (*LPMemGetLock)(struct IPerlMem*);
typedef void            (*LPMemFreeLock)(struct IPerlMem*);
typedef int             (*LPMemIsLocked)(struct IPerlMem*);

struct IPerlMem
{
    LPMemMalloc         pMalloc;
    LPMemRealloc        pRealloc;
    LPMemFree           pFree;
    LPMemCalloc         pCalloc;
    LPMemGetLock        pGetLock;
    LPMemFreeLock       pFreeLock;
    LPMemIsLocked       pIsLocked;
};

struct IPerlMemInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlMem     perlMemList;
};

/* Interpreter specific memory macros */
#  define PerlMem_malloc(size)                              \
        (*PL_Mem->pMalloc)(PL_Mem, (size))
#  define PerlMem_realloc(buf, size)                        \
        (*PL_Mem->pRealloc)(PL_Mem, (buf), (size))
#  define PerlMem_free(buf)                                 \
        (*PL_Mem->pFree)(PL_Mem, (buf))
#  define PerlMem_calloc(num, size)                         \
        (*PL_Mem->pCalloc)(PL_Mem, (num), (size))
#  define PerlMem_get_lock()                                \
        (*PL_Mem->pGetLock)(PL_Mem)
#  define PerlMem_free_lock()                               \
        (*PL_Mem->pFreeLock)(PL_Mem)
#  define PerlMem_is_locked()                               \
        (*PL_Mem->pIsLocked)(PL_Mem)

/* Shared memory macros */
#  define PerlMemShared_malloc(size)                        \
        (*PL_MemShared->pMalloc)(PL_MemShared, (size))
#  define PerlMemShared_realloc(buf, size)                  \
        (*PL_MemShared->pRealloc)(PL_MemShared, (buf), (size))
#  define PerlMemShared_free(buf)                           \
        (*PL_MemShared->pFree)(PL_MemShared, (buf))
#  define PerlMemShared_calloc(num, size)                   \
        (*PL_MemShared->pCalloc)(PL_MemShared, (num), (size))
#  define PerlMemShared_get_lock()                          \
        (*PL_MemShared->pGetLock)(PL_MemShared)
#  define PerlMemShared_free_lock()                         \
        (*PL_MemShared->pFreeLock)(PL_MemShared)
#  define PerlMemShared_is_locked()                         \
        (*PL_MemShared->pIsLocked)(PL_MemShared)

/* Parse tree memory macros */
#  define PerlMemParse_malloc(size)                         \
        (*PL_MemParse->pMalloc)(PL_MemParse, (size))
#  define PerlMemParse_realloc(buf, size)                   \
        (*PL_MemParse->pRealloc)(PL_MemParse, (buf), (size))
#  define PerlMemParse_free(buf)                            \
        (*PL_MemParse->pFree)(PL_MemParse, (buf))
#  define PerlMemParse_calloc(num, size)                    \
        (*PL_MemParse->pCalloc)(PL_MemParse, (num), (size))
#  define PerlMemParse_get_lock()                           \
        (*PL_MemParse->pGetLock)(PL_MemParse)
#  define PerlMemParse_free_lock()                          \
        (*PL_MemParse->pFreeLock)(PL_MemParse)
#  define PerlMemParse_is_locked()                          \
        (*PL_MemParse->pIsLocked)(PL_MemParse)


#else   /* ! PERL_IMPLICIT_SYS */

/* Interpreter specific memory macros */
#  define PerlMem_malloc(size)          malloc((size))
#  define PerlMem_realloc(buf, size)    realloc((buf), (size))
#  define PerlMem_free(buf)             free((buf))
#  define PerlMem_calloc(num, size)     calloc((num), (size))
#  define PerlMem_get_lock()            
#  define PerlMem_free_lock()
#  define PerlMem_is_locked()           0

/* Shared memory macros */
#  define PerlMemShared_malloc(size)            malloc((size))
#  define PerlMemShared_realloc(buf, size)      realloc((buf), (size))
#  define PerlMemShared_free(buf)               free((buf))
#  define PerlMemShared_calloc(num, size)       calloc((num), (size))
#  define PerlMemShared_get_lock()              
#  define PerlMemShared_free_lock()
#  define PerlMemShared_is_locked()             0

/* Parse tree memory macros */
#  define PerlMemParse_malloc(size)             malloc((size))
#  define PerlMemParse_realloc(buf, size)       realloc((buf), (size))
#  define PerlMemParse_free(buf)                free((buf))
#  define PerlMemParse_calloc(num, size)        calloc((num), (size))
#  define PerlMemParse_get_lock()               
#  define PerlMemParse_free_lock()
#  define PerlMemParse_is_locked()              0

#endif  /* PERL_IMPLICIT_SYS */

/*
    Interface for perl process functions
*/


#if defined(PERL_IMPLICIT_SYS)

#  ifndef jmp_buf
#    include <setjmp.h>
#  endif

/* IPerlProc            */
struct IPerlProc;
struct IPerlProcInfo;
typedef void            (*LPProcAbort)(struct IPerlProc*);
typedef char*           (*LPProcCrypt)(struct IPerlProc*, const char*,
                            const char*);
typedef void            (*LPProcExit)(struct IPerlProc*, int)
                            __attribute__noreturn__;
typedef void            (*LPProc_Exit)(struct IPerlProc*, int)
                            __attribute__noreturn__;
typedef int             (*LPProcExecl)(struct IPerlProc*, const char*,
                            const char*, const char*, const char*,
                            const char*);
typedef int             (*LPProcExecv)(struct IPerlProc*, const char*,
                            const char*const*);
typedef int             (*LPProcExecvp)(struct IPerlProc*, const char*,
                            const char*const*);
typedef Uid_t           (*LPProcGetuid)(struct IPerlProc*);
typedef Uid_t           (*LPProcGeteuid)(struct IPerlProc*);
typedef Gid_t           (*LPProcGetgid)(struct IPerlProc*);
typedef Gid_t           (*LPProcGetegid)(struct IPerlProc*);
typedef char*           (*LPProcGetlogin)(struct IPerlProc*);
typedef int             (*LPProcKill)(struct IPerlProc*, int, int);
typedef int             (*LPProcKillpg)(struct IPerlProc*, int, int);
typedef int             (*LPProcPauseProc)(struct IPerlProc*);
typedef PerlIO*         (*LPProcPopen)(struct IPerlProc*, const char*,
                            const char*);
typedef PerlIO*         (*LPProcPopenList)(struct IPerlProc*, const char*,
                            IV narg, SV **args);
typedef int             (*LPProcPclose)(struct IPerlProc*, PerlIO*);
typedef int             (*LPProcPipe)(struct IPerlProc*, int*);
typedef int             (*LPProcSetuid)(struct IPerlProc*, uid_t);
typedef int             (*LPProcSetgid)(struct IPerlProc*, gid_t);
typedef int             (*LPProcSleep)(struct IPerlProc*, unsigned int);
typedef int             (*LPProcTimes)(struct IPerlProc*, struct tms*);
typedef int             (*LPProcWait)(struct IPerlProc*, int*);
typedef int             (*LPProcWaitpid)(struct IPerlProc*, int, int*, int);
typedef Sighandler_t    (*LPProcSignal)(struct IPerlProc*, int, Sighandler_t);
typedef int             (*LPProcFork)(struct IPerlProc*);
typedef int             (*LPProcGetpid)(struct IPerlProc*);
#  ifdef WIN32
typedef void*           (*LPProcDynaLoader)(struct IPerlProc*, const char*);
typedef void            (*LPProcGetOSError)(struct IPerlProc*,
                            SV* sv, DWORD dwErr);
typedef int             (*LPProcSpawnvp)(struct IPerlProc*, int, const char*,
                            const char*const*);
#  endif
typedef int             (*LPProcLastHost)(struct IPerlProc*);
typedef int             (*LPProcGetTimeOfDay)(struct IPerlProc*,
                                              struct timeval*, void*);

struct IPerlProc
{
    LPProcAbort         pAbort;
    LPProcCrypt         pCrypt;
    LPProcExit          pExit;
    LPProc_Exit         p_Exit;
    LPProcExecl         pExecl;
    LPProcExecv         pExecv;
    LPProcExecvp        pExecvp;
    LPProcGetuid        pGetuid;
    LPProcGeteuid       pGeteuid;
    LPProcGetgid        pGetgid;
    LPProcGetegid       pGetegid;
    LPProcGetlogin      pGetlogin;
    LPProcKill          pKill;
    LPProcKillpg        pKillpg;
    LPProcPauseProc     pPauseProc;
    LPProcPopen         pPopen;
    LPProcPclose        pPclose;
    LPProcPipe          pPipe;
    LPProcSetuid        pSetuid;
    LPProcSetgid        pSetgid;
    LPProcSleep         pSleep;
    LPProcTimes         pTimes;
    LPProcWait          pWait;
    LPProcWaitpid       pWaitpid;
    LPProcSignal        pSignal;
    LPProcFork          pFork;
    LPProcGetpid        pGetpid;
#  ifdef WIN32
    LPProcDynaLoader    pDynaLoader;
    LPProcGetOSError    pGetOSError;
    LPProcSpawnvp       pSpawnvp;
#  endif
    LPProcLastHost      pLastHost;
    LPProcPopenList     pPopenList;
    LPProcGetTimeOfDay  pGetTimeOfDay;
};

struct IPerlProcInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlProc    perlProcList;
};

#  define PerlProc_abort()                                              \
        (*PL_Proc->pAbort)(PL_Proc)
#  define PerlProc_crypt(c,s)                                           \
        (*PL_Proc->pCrypt)(PL_Proc, (c), (s))
#  define PerlProc_exit(s)                                              \
        (*PL_Proc->pExit)(PL_Proc, (s))
#  define PerlProc__exit(s)                                             \
        (*PL_Proc->p_Exit)(PL_Proc, (s))
#  define PerlProc_execl(c, w, x, y, z)                                 \
        (*PL_Proc->pExecl)(PL_Proc, (c), (w), (x), (y), (z))
#  define PerlProc_execv(c, a)                                          \
        (*PL_Proc->pExecv)(PL_Proc, (c), (a))
#  define PerlProc_execvp(c, a)                                         \
        (*PL_Proc->pExecvp)(PL_Proc, (c), (a))
#  define PerlProc_getuid()                                             \
        (*PL_Proc->pGetuid)(PL_Proc)
#  define PerlProc_geteuid()                                            \
        (*PL_Proc->pGeteuid)(PL_Proc)
#  define PerlProc_getgid()                                             \
        (*PL_Proc->pGetgid)(PL_Proc)
#  define PerlProc_getegid()                                            \
        (*PL_Proc->pGetegid)(PL_Proc)
#  define PerlProc_getlogin()                                           \
        (*PL_Proc->pGetlogin)(PL_Proc)
#  define PerlProc_kill(i, a)                                           \
        (*PL_Proc->pKill)(PL_Proc, (i), (a))
#  define PerlProc_killpg(i, a)                                         \
        (*PL_Proc->pKillpg)(PL_Proc, (i), (a))
#  define PerlProc_pause()                                              \
        (*PL_Proc->pPauseProc)(PL_Proc)
#  define PerlProc_popen(c, m)                                          \
        (*PL_Proc->pPopen)(PL_Proc, (c), (m))
#  define PerlProc_popen_list(m, n, a)                                  \
        (*PL_Proc->pPopenList)(PL_Proc, (m), (n), (a))
#  define PerlProc_pclose(f)                                            \
        (*PL_Proc->pPclose)(PL_Proc, (f))
#  define PerlProc_pipe(fd)                                             \
        (*PL_Proc->pPipe)(PL_Proc, (fd))
#  define PerlProc_setuid(u)                                            \
        (*PL_Proc->pSetuid)(PL_Proc, (u))
#  define PerlProc_setgid(g)                                            \
        (*PL_Proc->pSetgid)(PL_Proc, (g))
#  define PerlProc_sleep(t)                                             \
        (*PL_Proc->pSleep)(PL_Proc, (t))
#  define PerlProc_times(t)                                             \
        (*PL_Proc->pTimes)(PL_Proc, (t))
#  define PerlProc_wait(t)                                              \
        (*PL_Proc->pWait)(PL_Proc, (t))
#  define PerlProc_waitpid(p,s,f)                                       \
        (*PL_Proc->pWaitpid)(PL_Proc, (p), (s), (f))
#  define PerlProc_signal(n, h)                                         \
        (*PL_Proc->pSignal)(PL_Proc, (n), (h))
#  define PerlProc_fork()                                               \
        (*PL_Proc->pFork)(PL_Proc)
#  define PerlProc_getpid()                                             \
        (*PL_Proc->pGetpid)(PL_Proc)
#  define PerlProc_setjmp(b, n) Sigsetjmp((b), (n))
#  define PerlProc_longjmp(b, n) Siglongjmp((b), (n))

#  ifdef WIN32
#    define PerlProc_DynaLoad(f)                                        \
        (*PL_Proc->pDynaLoader)(PL_Proc, (f))
#    define PerlProc_GetOSError(s,e)                                    \
        (*PL_Proc->pGetOSError)(PL_Proc, (s), (e))
#    define PerlProc_spawnvp(m, c, a)                                   \
        (*PL_Proc->pSpawnvp)(PL_Proc, (m), (c), (a))
#  endif
#  define PerlProc_lasthost()                                           \
        (*PL_Proc->pLastHost)(PL_Proc)
#  define PerlProc_gettimeofday(t,z)                                    \
        (*PL_Proc->pGetTimeOfDay)(PL_Proc,(t),(z))

#else   /* ! PERL_IMPLICIT_SYS */

#  define PerlProc_abort()      abort()
#  define PerlProc_crypt(c,s)   crypt((c), (s))
#  define PerlProc_exit(s)      exit((s))
#  define PerlProc__exit(s)     _exit((s))
#  define PerlProc_execl(c,w,x,y,z)                                     \
        execl((c), (w), (x), (y), (z))
#  define PerlProc_execv(c, a)  execv((c), (a))
#  define PerlProc_execvp(c, a) execvp((c), (a))
#  define PerlProc_getuid()     getuid()
#  define PerlProc_geteuid()    geteuid()
#  define PerlProc_getgid()     getgid()
#  define PerlProc_getegid()    getegid()
#  define PerlProc_getlogin()   getlogin()
#  define PerlProc_kill(i, a)   kill((i), (a))
#  define PerlProc_killpg(i, a) killpg((i), (a))
#  define PerlProc_pause()      Pause()
#  define PerlProc_popen(c, m)  my_popen((c), (m))
#  define PerlProc_popen_list(m,n,a)    my_popen_list((m),(n),(a))
#  define PerlProc_pclose(f)    my_pclose((f))
#  define PerlProc_pipe(fd)     pipe((fd))
#  define PerlProc_setuid(u)    setuid((u))
#  define PerlProc_setgid(g)    setgid((g))
#  define PerlProc_sleep(t)     sleep((t))
#  define PerlProc_times(t)     times((t))
#  define PerlProc_wait(t)      wait((t))
#  define PerlProc_waitpid(p,s,f) waitpid((p), (s), (f))
#  define PerlProc_setjmp(b, n) Sigsetjmp((b), (n))
#  define PerlProc_longjmp(b, n)Siglongjmp((b), (n))
#  define PerlProc_signal(n, h) signal((n), (h))
#  define PerlProc_fork()       my_fork()
#  define PerlProc_getpid()     getpid()
#  define PerlProc_gettimeofday(t,z)    gettimeofday((t),(z))

#  ifdef WIN32
#    define PerlProc_DynaLoad(f)                                        \
        win32_dynaload((f))
#    define PerlProc_GetOSError(s,e)                                    \
        win32_str_os_error((s), (e))
#    define PerlProc_spawnvp(m, c, a)                                   \
        win32_spawnvp((m), (c), (a))
#    undef PerlProc_signal
#    define PerlProc_signal(n, h) win32_signal((n), (h))
#  endif
#endif  /* PERL_IMPLICIT_SYS */

/*
    Interface for perl socket functions
*/

#if defined(PERL_IMPLICIT_SYS)

/* PerlSock             */
struct IPerlSock;
struct IPerlSockInfo;
typedef u_long          (*LPHtonl)(struct IPerlSock*, u_long);
typedef u_short         (*LPHtons)(struct IPerlSock*, u_short);
typedef u_long          (*LPNtohl)(struct IPerlSock*, u_long);
typedef u_short         (*LPNtohs)(struct IPerlSock*, u_short);
typedef SOCKET          (*LPAccept)(struct IPerlSock*, SOCKET,
                            struct sockaddr*, int*);
typedef int             (*LPBind)(struct IPerlSock*, SOCKET,
                            const struct sockaddr*, int);
typedef int             (*LPConnect)(struct IPerlSock*, SOCKET,
                            const struct sockaddr*, int);
typedef void            (*LPEndhostent)(struct IPerlSock*);
typedef void            (*LPEndnetent)(struct IPerlSock*);
typedef void            (*LPEndprotoent)(struct IPerlSock*);
typedef void            (*LPEndservent)(struct IPerlSock*);
typedef int             (*LPGethostname)(struct IPerlSock*, char*, int);
typedef int             (*LPGetpeername)(struct IPerlSock*, SOCKET,
                            struct sockaddr*, int*);
typedef struct hostent* (*LPGethostbyaddr)(struct IPerlSock*, const char*,
                            int, int);
typedef struct hostent* (*LPGethostbyname)(struct IPerlSock*, const char*);
typedef struct hostent* (*LPGethostent)(struct IPerlSock*);
typedef struct netent*  (*LPGetnetbyaddr)(struct IPerlSock*, long, int);
typedef struct netent*  (*LPGetnetbyname)(struct IPerlSock*, const char*);
typedef struct netent*  (*LPGetnetent)(struct IPerlSock*);
typedef struct protoent*(*LPGetprotobyname)(struct IPerlSock*, const char*);
typedef struct protoent*(*LPGetprotobynumber)(struct IPerlSock*, int);
typedef struct protoent*(*LPGetprotoent)(struct IPerlSock*);
typedef struct servent* (*LPGetservbyname)(struct IPerlSock*, const char*,
                            const char*);
typedef struct servent* (*LPGetservbyport)(struct IPerlSock*, int,
                            const char*);
typedef struct servent* (*LPGetservent)(struct IPerlSock*);
typedef int             (*LPGetsockname)(struct IPerlSock*, SOCKET,
                            struct sockaddr*, int*);
typedef int             (*LPGetsockopt)(struct IPerlSock*, SOCKET, int, int,
                            char*, int*);
typedef unsigned long   (*LPInetAddr)(struct IPerlSock*, const char*);
typedef char*           (*LPInetNtoa)(struct IPerlSock*, struct in_addr);
typedef int             (*LPListen)(struct IPerlSock*, SOCKET, int);
typedef int             (*LPRecv)(struct IPerlSock*, SOCKET, char*, int, int);
typedef int             (*LPRecvfrom)(struct IPerlSock*, SOCKET, char*, int,
                            int, struct sockaddr*, int*);
typedef int             (*LPSelect)(struct IPerlSock*, int, char*, char*,
                            char*, const struct timeval*);
typedef int             (*LPSend)(struct IPerlSock*, SOCKET, const char*, int,
                            int);
typedef int             (*LPSendto)(struct IPerlSock*, SOCKET, const char*,
                            int, int, const struct sockaddr*, int);
typedef void            (*LPSethostent)(struct IPerlSock*, int);
typedef void            (*LPSetnetent)(struct IPerlSock*, int);
typedef void            (*LPSetprotoent)(struct IPerlSock*, int);
typedef void            (*LPSetservent)(struct IPerlSock*, int);
typedef int             (*LPSetsockopt)(struct IPerlSock*, SOCKET, int, int,
                            const char*, int);
typedef int             (*LPShutdown)(struct IPerlSock*, SOCKET, int);
typedef SOCKET          (*LPSocket)(struct IPerlSock*, int, int, int);
typedef int             (*LPSocketpair)(struct IPerlSock*, int, int, int,
                            int*);
#  ifdef WIN32
typedef int             (*LPClosesocket)(struct IPerlSock*, SOCKET s);
#  endif

struct IPerlSock
{
    LPHtonl             pHtonl;
    LPHtons             pHtons;
    LPNtohl             pNtohl;
    LPNtohs             pNtohs;
    LPAccept            pAccept;
    LPBind              pBind;
    LPConnect           pConnect;
    LPEndhostent        pEndhostent;
    LPEndnetent         pEndnetent;
    LPEndprotoent       pEndprotoent;
    LPEndservent        pEndservent;
    LPGethostname       pGethostname;
    LPGetpeername       pGetpeername;
    LPGethostbyaddr     pGethostbyaddr;
    LPGethostbyname     pGethostbyname;
    LPGethostent        pGethostent;
    LPGetnetbyaddr      pGetnetbyaddr;
    LPGetnetbyname      pGetnetbyname;
    LPGetnetent         pGetnetent;
    LPGetprotobyname    pGetprotobyname;
    LPGetprotobynumber  pGetprotobynumber;
    LPGetprotoent       pGetprotoent;
    LPGetservbyname     pGetservbyname;
    LPGetservbyport     pGetservbyport;
    LPGetservent        pGetservent;
    LPGetsockname       pGetsockname;
    LPGetsockopt        pGetsockopt;
    LPInetAddr          pInetAddr;
    LPInetNtoa          pInetNtoa;
    LPListen            pListen;
    LPRecv              pRecv;
    LPRecvfrom          pRecvfrom;
    LPSelect            pSelect;
    LPSend              pSend;
    LPSendto            pSendto;
    LPSethostent        pSethostent;
    LPSetnetent         pSetnetent;
    LPSetprotoent       pSetprotoent;
    LPSetservent        pSetservent;
    LPSetsockopt        pSetsockopt;
    LPShutdown          pShutdown;
    LPSocket            pSocket;
    LPSocketpair        pSocketpair;
#  ifdef WIN32
    LPClosesocket       pClosesocket;
#  endif
};

struct IPerlSockInfo
{
    unsigned long       nCount;     /* number of entries expected */
    struct IPerlSock    perlSockList;
};

#  define PerlSock_htonl(x)                                             \
        (*PL_Sock->pHtonl)(PL_Sock, x)
#  define PerlSock_htons(x)                                             \
        (*PL_Sock->pHtons)(PL_Sock, x)
#  define PerlSock_ntohl(x)                                             \
        (*PL_Sock->pNtohl)(PL_Sock, x)
#  define PerlSock_ntohs(x)                                             \
        (*PL_Sock->pNtohs)(PL_Sock, x)
#  define PerlSock_accept(s, a, l)                                      \
        (*PL_Sock->pAccept)(PL_Sock, s, a, l)
#  define PerlSock_bind(s, n, l)                                        \
        (*PL_Sock->pBind)(PL_Sock, s, n, l)
#  define PerlSock_connect(s, n, l)                                     \
        (*PL_Sock->pConnect)(PL_Sock, s, n, l)
#  define PerlSock_endhostent()                                         \
        (*PL_Sock->pEndhostent)(PL_Sock)
#  define PerlSock_endnetent()                                          \
        (*PL_Sock->pEndnetent)(PL_Sock)
#  define PerlSock_endprotoent()                                        \
        (*PL_Sock->pEndprotoent)(PL_Sock)
#  define PerlSock_endservent()                                         \
        (*PL_Sock->pEndservent)(PL_Sock)
#  define PerlSock_gethostbyaddr(a, l, t)                               \
        (*PL_Sock->pGethostbyaddr)(PL_Sock, a, l, t)
#  define PerlSock_gethostbyname(n)                                     \
        (*PL_Sock->pGethostbyname)(PL_Sock, n)
#  define PerlSock_gethostent()                                         \
        (*PL_Sock->pGethostent)(PL_Sock)
#  define PerlSock_gethostname(n, l)                                    \
        (*PL_Sock->pGethostname)(PL_Sock, n, l)
#  define PerlSock_getnetbyaddr(n, t)                                   \
        (*PL_Sock->pGetnetbyaddr)(PL_Sock, n, t)
#  define PerlSock_getnetbyname(c)                                      \
        (*PL_Sock->pGetnetbyname)(PL_Sock, c)
#  define PerlSock_getnetent()                                          \
        (*PL_Sock->pGetnetent)(PL_Sock)
#  define PerlSock_getpeername(s, n, l)                                 \
        (*PL_Sock->pGetpeername)(PL_Sock, s, n, l)
#  define PerlSock_getprotobyname(n)                                    \
        (*PL_Sock->pGetprotobyname)(PL_Sock, n)
#  define PerlSock_getprotobynumber(n)                                  \
        (*PL_Sock->pGetprotobynumber)(PL_Sock, n)
#  define PerlSock_getprotoent()                                        \
        (*PL_Sock->pGetprotoent)(PL_Sock)
#  define PerlSock_getservbyname(n, p)                                  \
        (*PL_Sock->pGetservbyname)(PL_Sock, n, p)
#  define PerlSock_getservbyport(port, p)                               \
        (*PL_Sock->pGetservbyport)(PL_Sock, port, p)
#  define PerlSock_getservent()                                         \
        (*PL_Sock->pGetservent)(PL_Sock)
#  define PerlSock_getsockname(s, n, l)                                 \
        (*PL_Sock->pGetsockname)(PL_Sock, s, n, l)
#  define PerlSock_getsockopt(s,l,n,v,i)                                \
        (*PL_Sock->pGetsockopt)(PL_Sock, s, l, n, v, i)
#  define PerlSock_inet_addr(c)                                         \
        (*PL_Sock->pInetAddr)(PL_Sock, c)
#  define PerlSock_inet_ntoa(i)                                         \
        (*PL_Sock->pInetNtoa)(PL_Sock, i)
#  define PerlSock_listen(s, b)                                         \
        (*PL_Sock->pListen)(PL_Sock, s, b)
#  define PerlSock_recv(s, b, l, f)                                     \
        (*PL_Sock->pRecv)(PL_Sock, s, b, l, f)
#  define PerlSock_recvfrom(s,b,l,f,from,fromlen)                       \
        (*PL_Sock->pRecvfrom)(PL_Sock, s, b, l, f, from, fromlen)
#  define PerlSock_select(n, r, w, e, t)                                \
        (*PL_Sock->pSelect)(PL_Sock, n, (char*)r, (char*)w, (char*)e, t)
#  define PerlSock_send(s, b, l, f)                                     \
        (*PL_Sock->pSend)(PL_Sock, s, b, l, f)
#  define PerlSock_sendto(s, b, l, f, t, tlen)                          \
        (*PL_Sock->pSendto)(PL_Sock, s, b, l, f, t, tlen)
#  define PerlSock_sethostent(f)                                        \
        (*PL_Sock->pSethostent)(PL_Sock, f)
#  define PerlSock_setnetent(f)                                         \
        (*PL_Sock->pSetnetent)(PL_Sock, f)
#  define PerlSock_setprotoent(f)                                       \
        (*PL_Sock->pSetprotoent)(PL_Sock, f)
#  define PerlSock_setservent(f)                                        \
        (*PL_Sock->pSetservent)(PL_Sock, f)
#  define PerlSock_setsockopt(s, l, n, v, len)                          \
        (*PL_Sock->pSetsockopt)(PL_Sock, s, l, n, v, len)
#  define PerlSock_shutdown(s, h)                                       \
        (*PL_Sock->pShutdown)(PL_Sock, s, h)
#  define PerlSock_socket(a, t, p)                                      \
        (*PL_Sock->pSocket)(PL_Sock, a, t, p)
#  define PerlSock_socketpair(a, t, p, f)                               \
        (*PL_Sock->pSocketpair)(PL_Sock, a, t, p, f)

#  ifdef WIN32
#    define     PerlSock_closesocket(s)                                 \
        (*PL_Sock->pClosesocket)(PL_Sock, s)
#  endif

#else   /* ! PERL_IMPLICIT_SYS below */

#  define PerlSock_htonl(x)             htonl(x)
#  define PerlSock_htons(x)             htons(x)
#  define PerlSock_ntohl(x)             ntohl(x)
#  define PerlSock_ntohs(x)             ntohs(x)
#  define PerlSock_accept(s, a, l)      accept(s, a, l)
#  define PerlSock_bind(s, n, l)        bind(s, n, l)
#  define PerlSock_connect(s, n, l)     connect(s, n, l)

#  define PerlSock_gethostbyaddr(a, l, t) gethostbyaddr(a, l, t)
#  define PerlSock_gethostbyname(n)     gethostbyname(n)
#  define PerlSock_gethostent           gethostent
#  define PerlSock_endhostent           endhostent
#  define PerlSock_gethostname(n, l)    gethostname(n, l)

#  define PerlSock_getnetbyaddr(n, t)   getnetbyaddr(n, t)
#  define PerlSock_getnetbyname(n)      getnetbyname(n)
#  define PerlSock_getnetent            getnetent
#  define PerlSock_endnetent            endnetent
#  define PerlSock_getpeername(s, n, l) getpeername(s, n, l)

#  define PerlSock_getprotobyname(n)    getprotobyname(n)
#  define PerlSock_getprotobynumber(n)  getprotobynumber(n)
#  define PerlSock_getprotoent          getprotoent
#  define PerlSock_endprotoent          endprotoent

#  define PerlSock_getservbyname(n, p)  getservbyname(n, p)
#  define PerlSock_getservbyport(port, p) getservbyport(port, p)
#  define PerlSock_getservent           getservent
#  define PerlSock_endservent           endservent

#  define PerlSock_getsockname(s, n, l) getsockname(s, n, l)
#  define PerlSock_getsockopt(s,l,n,v,i)  getsockopt(s, l, n, v, i)
#  define PerlSock_inet_addr(c)         inet_addr(c)
#  define PerlSock_inet_ntoa(i)         inet_ntoa(i)
#  define PerlSock_listen(s, b)         listen(s, b)
#  define PerlSock_recv(s, b, l, f)     recv(s, b, l, f)
#  define PerlSock_recvfrom(s, b, l, f, from, fromlen)                  \
        recvfrom(s, b, l, f, from, fromlen)
#  define PerlSock_select(n, r, w, e, t) select(n, r, w, e, t)
#  define PerlSock_send(s, b, l, f)     send(s, b, l, f)
#  define PerlSock_sendto(s, b, l, f, t, tlen)                          \
        sendto(s, b, l, f, t, tlen)
#  define PerlSock_sethostent(f)        sethostent(f)
#  define PerlSock_setnetent(f)         setnetent(f)
#  define PerlSock_setprotoent(f)       setprotoent(f)
#  define PerlSock_setservent(f)        setservent(f)
#  define PerlSock_setsockopt(s, l, n, v, len)                          \
        setsockopt(s, l, n, v, len)
#  define PerlSock_shutdown(s, h)       shutdown(s, h)
#  define PerlSock_socket(a, t, p)      socket(a, t, p)
#  define PerlSock_socketpair(a, t, p, f) socketpair(a, t, p, f)

#  ifdef WIN32
#    define PerlSock_closesocket(s)     closesocket(s)
#  endif

#endif  /* PERL_IMPLICIT_SYS */

#endif  /* __Inc__IPerl___ */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /* -*- buffer-read-only: t -*-
 *
 *    keywords.h
 *
 *    Copyright (C) 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2005,
 *    2006, 2007 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/keywords.pl from its data.
 * Any changes made here will be lost!
 */

#define KEY_NULL		0
#define KEY___FILE__		1
#define KEY___LINE__		2
#define KEY___PACKAGE__		3
#define KEY___DATA__		4
#define KEY___END__		5
#define KEY___SUB__		6
#define KEY_AUTOLOAD		7
#define KEY_BEGIN		8
#define KEY_UNITCHECK		9
#define KEY_DESTROY		10
#define KEY_END			11
#define KEY_INIT		12
#define KEY_CHECK		13
#define KEY_abs			14
#define KEY_accept		15
#define KEY_alarm		16
#define KEY_and			17
#define KEY_atan2		18
#define KEY_bind		19
#define KEY_binmode		20
#define KEY_bless		21
#define KEY_break		22
#define KEY_caller		23
#define KEY_catch		24
#define KEY_chdir		25
#define KEY_chmod		26
#define KEY_chomp		27
#define KEY_chop		28
#define KEY_chown		29
#define KEY_chr			30
#define KEY_chroot		31
#define KEY_close		32
#define KEY_closedir		33
#define KEY_cmp			34
#define KEY_connect		35
#define KEY_continue		36
#define KEY_cos			37
#define KEY_crypt		38
#define KEY_dbmclose		39
#define KEY_dbmopen		40
#define KEY_default		41
#define KEY_defer		42
#define KEY_defined		43
#define KEY_delete		44
#define KEY_die			45
#define KEY_do			46
#define KEY_dump		47
#define KEY_each		48
#define KEY_else		49
#define KEY_elsif		50
#define KEY_endgrent		51
#define KEY_endhostent		52
#define KEY_endnetent		53
#define KEY_endprotoent		54
#define KEY_endpwent		55
#define KEY_endservent		56
#define KEY_eof			57
#define KEY_eq			58
#define KEY_eval		59
#define KEY_evalbytes		60
#define KEY_exec		61
#define KEY_exists		62
#define KEY_exit		63
#define KEY_exp			64
#define KEY_fc			65
#define KEY_fcntl		66
#define KEY_fileno		67
#define KEY_finally		68
#define KEY_flock		69
#define KEY_for			70
#define KEY_foreach		71
#define KEY_fork		72
#define KEY_format		73
#define KEY_formline		74
#define KEY_ge			75
#define KEY_getc		76
#define KEY_getgrent		77
#define KEY_getgrgid		78
#define KEY_getgrnam		79
#define KEY_gethostbyaddr	80
#define KEY_gethostbyname	81
#define KEY_gethostent		82
#define KEY_getlogin		83
#define KEY_getnetbyaddr	84
#define KEY_getnetbyname	85
#define KEY_getnetent		86
#define KEY_getpeername		87
#define KEY_getpgrp		88
#define KEY_getppid		89
#define KEY_getpriority		90
#define KEY_getprotobyname	91
#define KEY_getprotobynumber	92
#define KEY_getprotoent		93
#define KEY_getpwent		94
#define KEY_getpwnam		95
#define KEY_getpwuid		96
#define KEY_getservbyname	97
#define KEY_getservbyport	98
#define KEY_getservent		99
#define KEY_getsockname		100
#define KEY_getsockopt		101
#define KEY_given		102
#define KEY_glob		103
#define KEY_gmtime		104
#define KEY_goto		105
#define KEY_grep		106
#define KEY_gt			107
#define KEY_hex			108
#define KEY_if			109
#define KEY_index		110
#define KEY_int			111
#define KEY_ioctl		112
#define KEY_isa			113
#define KEY_join		114
#define KEY_keys		115
#define KEY_kill		116
#define KEY_last		117
#define KEY_lc			118
#define KEY_lcfirst		119
#define KEY_le			120
#define KEY_length		121
#define KEY_link		122
#define KEY_listen		123
#define KEY_local		124
#define KEY_localtime		125
#define KEY_lock		126
#define KEY_log			127
#define KEY_lstat		128
#define KEY_lt			129
#define KEY_m			130
#define KEY_map			131
#define KEY_mkdir		132
#define KEY_msgctl		133
#define KEY_msgget		134
#define KEY_msgrcv		135
#define KEY_msgsnd		136
#define KEY_my			137
#define KEY_ne			138
#define KEY_next		139
#define KEY_no			140
#define KEY_not			141
#define KEY_oct			142
#define KEY_open		143
#define KEY_opendir		144
#define KEY_or			145
#define KEY_ord			146
#define KEY_our			147
#define KEY_pack		148
#define KEY_package		149
#define KEY_pipe		150
#define KEY_pop			151
#define KEY_pos			152
#define KEY_print		153
#define KEY_printf		154
#define KEY_prototype		155
#define KEY_push		156
#define KEY_q			157
#define KEY_qq			158
#define KEY_qr			159
#define KEY_quotemeta		160
#define KEY_qw			161
#define KEY_qx			162
#define KEY_rand		163
#define KEY_read		164
#define KEY_readdir		165
#define KEY_readline		166
#define KEY_readlink		167
#define KEY_readpipe		168
#define KEY_recv		169
#define KEY_redo		170
#define KEY_ref			171
#define KEY_rename		172
#define KEY_require		173
#define KEY_reset		174
#define KEY_return		175
#define KEY_reverse		176
#define KEY_rewinddir		177
#define KEY_rindex		178
#define KEY_rmdir		179
#define KEY_s			180
#define KEY_say			181
#define KEY_scalar		182
#define KEY_seek		183
#define KEY_seekdir		184
#define KEY_select		185
#define KEY_semctl		186
#define KEY_semget		187
#define KEY_semop		188
#define KEY_send		189
#define KEY_setgrent		190
#define KEY_sethostent		191
#define KEY_setnetent		192
#define KEY_setpgrp		193
#define KEY_setpriority		194
#define KEY_setprotoent		195
#define KEY_setpwent		196
#define KEY_setservent		197
#define KEY_setsockopt		198
#define KEY_shift		199
#define KEY_shmctl		200
#define KEY_shmget		201
#define KEY_shmread		202
#define KEY_shmwrite		203
#define KEY_shutdown		204
#define KEY_sin			205
#define KEY_sleep		206
#define KEY_socket		207
#define KEY_socketpair		208
#define KEY_sort		209
#define KEY_splice		210
#define KEY_split		211
#define KEY_sprintf		212
#define KEY_sqrt		213
#define KEY_srand		214
#define KEY_stat		215
#define KEY_state		216
#define KEY_study		217
#define KEY_sub			218
#define KEY_substr		219
#define KEY_symlink		220
#define KEY_syscall		221
#define KEY_sysopen		222
#define KEY_sysread		223
#define KEY_sysseek		224
#define KEY_system		225
#define KEY_syswrite		226
#define KEY_tell		227
#define KEY_telldir		228
#define KEY_tie			229
#define KEY_tied		230
#define KEY_time		231
#define KEY_times		232
#define KEY_tr			233
#define KEY_try			234
#define KEY_truncate		235
#define KEY_uc			236
#define KEY_ucfirst		237
#define KEY_umask		238
#define KEY_undef		239
#define KEY_unless		240
#define KEY_unlink		241
#define KEY_unpack		242
#define KEY_unshift		243
#define KEY_untie		244
#define KEY_until		245
#define KEY_use			246
#define KEY_utime		247
#define KEY_values		248
#define KEY_vec			249
#define KEY_wait		250
#define KEY_waitpid		251
#define KEY_wantarray		252
#define KEY_warn		253
#define KEY_when		254
#define KEY_while		255
#define KEY_write		256
#define KEY_x			257
#define KEY_xor			258
#define KEY_y			259

/* Generated from:
 * b680fb3a27b173b65d9c4e534ad92897c925e336476879a6be1da18ac55cbe8b regen/keywords.pl
 * ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  #ifndef PERL_MALLOC_CTL_H_
#  define PERL_MALLOC_CTL_H_

struct perl_mstats {
    UV *nfree;
    UV *ntotal;
    IV topbucket, topbucket_ev, topbucket_odd, totfree, total, total_chain;
    IV total_sbrk, sbrks, sbrk_good, sbrk_slack, start_slack, sbrked_remains;
    IV minbucket;
    /* Level 1 info */
    UV *bucket_mem_size;
    UV *bucket_available_size;
    UV nbuckets;
};
typedef struct perl_mstats perl_mstats_t;

PERL_CALLCONV Malloc_t Perl_malloc (MEM_SIZE nbytes);
PERL_CALLCONV Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size);
PERL_CALLCONV Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes);
/* 'mfree' rather than 'free', since there is already a 'perl_free'
 * that causes clashes with case-insensitive linkers */
PERL_CALLCONV Free_t   Perl_mfree (Malloc_t where);

#ifndef NO_MALLOC_DYNAMIC_CFG

/* IV configuration data */
enum {
  MallocCfg_FIRST_SBRK,
  MallocCfg_MIN_SBRK,
  MallocCfg_MIN_SBRK_FRAC1000,
  MallocCfg_SBRK_ALLOW_FAILURES,
  MallocCfg_SBRK_FAILURE_PRICE,
  MallocCfg_sbrk_goodness,

  MallocCfg_filldead,
  MallocCfg_fillalive,
  MallocCfg_fillcheck,

  MallocCfg_skip_cfg_env,
  MallocCfg_cfg_env_read,

  MallocCfg_emergency_buffer_size,
  MallocCfg_emergency_buffer_last_req,

  MallocCfg_emergency_buffer_prepared_size,

  MallocCfg_last
};
/* char* configuration data */
enum {
  MallocCfgP_emergency_buffer,
  MallocCfgP_emergency_buffer_prepared,
  MallocCfgP_last
};
START_EXTERN_C
extern IV *MallocCfg_ptr;
extern char **MallocCfgP_ptr;
END_EXTERN_C

#endif

#endif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /* This is a placeholder file for symbols that should be exported
 * into config_h.SH and Porting/Glossary. See also metaconfig.SH
 *
 * First version was created from the part in handy.h
 * H.Merijn Brand 21 Dec 2010 (Tux)
 *
 * Mentioned variables are forced to be included into config_h.SH
 * as they are only included if meta finds them referenced. That
 * implies that noone can use them unless they are available and
 * they won't be available unless used. When new symbols are probed
 * in Configure, this is the way to force them into availability.
 *
 * Symbols should only be here temporarily. Once they are actually used,
 * they should be removed from here.
 *
 * HAS_NON_INT_BITFIELDS
 * HAS_STRXFRM_L
 * HAS_NL_LANGINFO_L
 * HAS_FFS
 * HAS_FFSL
 *
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /*    mg.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
 *    2000, 2002, 2005, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

struct mgvtbl {
    int		(*svt_get)	(pTHX_ SV *sv, MAGIC* mg);
    int		(*svt_set)	(pTHX_ SV *sv, MAGIC* mg);
    U32		(*svt_len)	(pTHX_ SV *sv, MAGIC* mg);
    int		(*svt_clear)    (pTHX_ SV *sv, MAGIC* mg);
    int		(*svt_free)	(pTHX_ SV *sv, MAGIC* mg);
    int		(*svt_copy)	(pTHX_ SV *sv, MAGIC* mg,
                                        SV *nsv, const char *name, I32 namlen);
    int		(*svt_dup)	(pTHX_ MAGIC *mg, CLONE_PARAMS *param);
    int		(*svt_local)(pTHX_ SV *nsv, MAGIC *mg);
};

struct magic {
    MAGIC*	mg_moremagic;
    MGVTBL*	mg_virtual;	/* pointer to magic functions */
    U16		mg_private;
    char	mg_type;
    U8		mg_flags;
    SSize_t	mg_len;
    SV*		mg_obj;
    char*	mg_ptr;
};

#define MGf_TAINTEDDIR 1        /* PERL_MAGIC_envelem only */
#define MGf_MINMATCH   1        /* PERL_MAGIC_regex_global only */
#define MGf_REQUIRE_GV 1        /* PERL_MAGIC_checkcall only */
#define MGf_REFCOUNTED 2
#define MGf_GSKIP      4	/* skip further GETs until after next SET */
#define MGf_COPY       8	/* has an svt_copy  MGVTBL entry */
#define MGf_DUP     0x10 	/* has an svt_dup   MGVTBL entry */
#define MGf_LOCAL   0x20	/* has an svt_local MGVTBL entry */
#define MGf_BYTES   0x40        /* PERL_MAGIC_regex_global only */
#define MGf_PERSIST    0x80     /* PERL_MAGIC_lvref only */

#define MgTAINTEDDIR(mg)	(mg->mg_flags & MGf_TAINTEDDIR)
#define MgTAINTEDDIR_on(mg)	(mg->mg_flags |= MGf_TAINTEDDIR)
#define MgTAINTEDDIR_off(mg)	(mg->mg_flags &= ~MGf_TAINTEDDIR)

/* Extracts the SV stored in mg, or NULL. */
#define MgSV(mg)		(((int)((mg)->mg_len) == HEf_SVKEY) ?   \
                                 MUTABLE_SV((mg)->mg_ptr) :	\
                                 NULL)

/* If mg contains an SV, these extract the PV stored in that SV;
   otherwise, these extract the mg's mg_ptr/mg_len.
   These do NOT account for the SV's UTF8 flag, so handle with care.
*/
#define MgPV(mg,lp)		((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ?   \
                                 SvPV(MUTABLE_SV((mg)->mg_ptr),lp) :	\
                                 (mg)->mg_ptr)
#define MgPV_const(mg,lp)	((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ? \
                                 SvPV_const(MUTABLE_SV((mg)->mg_ptr),lp) :   \
                                 (const char*)(mg)->mg_ptr)
#define MgPV_nolen_const(mg)	(((((int)(mg)->mg_len)) == HEf_SVKEY) ?	\
                                 SvPV_nolen_const(MUTABLE_SV((mg)->mg_ptr)) : \
                                 (const char*)(mg)->mg_ptr)

#define SvTIED_mg(sv,how) (SvRMAGICAL(sv) ? mg_find((sv),(how)) : NULL)
#define SvTIED_obj(sv,mg) \
    ((mg)->mg_obj ? (mg)->mg_obj : sv_2mortal(newRV(sv)))

#if defined(PERL_CORE) || defined(PERL_EXT)
# define MgBYTEPOS(mg,sv,pv,len) S_MgBYTEPOS(aTHX_ mg,sv,pv,len)
/* assumes get-magic and stringification have already occurred */
# define MgBYTEPOS_set(mg,sv,pv,off) (			 \
    assert_((mg)->mg_type == PERL_MAGIC_regex_global)	  \
    SvPOK(sv) && (!SvGMAGICAL(sv) || sv_only_taint_gmagic(sv))  \
        ? (mg)->mg_len = (off), (mg)->mg_flags |= MGf_BYTES \
        : ((mg)->mg_len = DO_UTF8(sv)			     \
            ? (SSize_t)utf8_length((U8 *)(pv), (U8 *)(pv)+(off)) \
            : (SSize_t)(off),					  \
           (mg)->mg_flags &= ~MGf_BYTES))
#endif

#define whichsig(pv) whichsig_pv(pv)

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /* mg_data.h:
 * THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
 *
 * These values will populate PL_magic_data[]: this is an array of
 * per-magic U8 values containing an index into PL_magic_vtables[]
 * plus two flags:
 *    PERL_MAGIC_READONLY_ACCEPTABLE
 *    PERL_MAGIC_VALUE_MAGIC
*/
{
    /* sv '\0' Special scalar variable */
    want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    /* arylen '#' Array length ($#ary) */
    want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC,
    0,
    /* rhash '%' Extra data for restricted hashes */
    magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    0,
    0,
    /* debugvar '*' $DB::single, signal, trace vars */
    want_vtbl_debugvar,
    0,
    0,
    0,
    /* pos '.' pos() lvalue */
    want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    /* symtab ':' Extra data for symbol tables */
    magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
    0,
    /* backref '<' For weak ref data */
    want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    0,
    /* arylen_p '@' To move arylen out of XPVAV */
    magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
    0,
    /* bm 'B' Boyer-Moore (fast string search) */
    want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
    0,
    /* regdata 'D' Regex match position data (@+ and @- vars) */
    want_vtbl_regdata,
    /* env 'E' %ENV hash */
    want_vtbl_env,
    0,
    0,
    /* hints 'H' %^H hash */
    want_vtbl_hints,
    /* isa 'I' @ISA array */
    want_vtbl_isa,
    0,
    0,
    /* dbfile 'L' Debugger %_<filename */
    magic_vtable_max,
    0,
    0,
    0,
    /* tied 'P' Tied array or hash */
    want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    /* sig 'S' %SIG hash */
    want_vtbl_sig,
    0,
    /* uvar 'U' Available for use by extensions */
    want_vtbl_uvar,
    /* vstring 'V' SV was vstring literal */
    magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    /* nonelem 'Y' Array element that does not exist */
    want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    /* lvref '\' Lvalue reference constructor */
    want_vtbl_lvref,
    /* checkcall ']' Inlining/mutation of call to this CV */
    want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    0,
    0,
    0,
    /* overload_table 'c' Holds overload table (AMT) on stash */
    want_vtbl_ovrld,
    /* regdatum 'd' Regex match position data element */
    want_vtbl_regdatum,
    /* envelem 'e' %ENV hash element */
    want_vtbl_envelem,
    /* fm 'f' Formline ('compiled' format) */
    want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
    /* regex_global 'g' m//g target */
    want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
    /* hintselem 'h' %^H hash element */
    want_vtbl_hintselem,
    /* isaelem 'i' @ISA array element */
    want_vtbl_isaelem,
    0,
    /* nkeys 'k' scalar(keys()) lvalue */
    want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC,
    /* dbline 'l' Debugger %_<filename element */
    want_vtbl_dbline,
    0,
    0,
    /* collxfrm 'o' Locale transformation */
    want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC,
    /* tiedelem 'p' Tied array or hash element */
    want_vtbl_packelem,
    /* tiedscalar 'q' Tied scalar or handle */
    want_vtbl_packelem,
    /* qr 'r' Precompiled qr// regex */
    want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
    /* sigelem 's' %SIG hash element */
    want_vtbl_sigelem,
    /* taint 't' Taintedness */
    want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC,
    0,
    /* vec 'v' vec() lvalue */
    want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC,
    /* utf8 'w' Cached UTF-8 information */
    want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC,
    /* substr 'x' substr() lvalue */
    want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC,
    /* defelem 'y' Shadow "foreach" iterator variable / smart parameter vivification */
    want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC,
    0,
    0,
    0,
    0,
    /* ext '~' Available for use by extensions */
    magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /* -*- buffer-read-only: t -*-
 *
 *    mg_raw.h
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/mg_vtable.pl.
 * Any changes made here will be lost!
 */

    { '\0', "want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE",
      "/* sv '\\0' Special scalar variable */" },
    { '#', "want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC",
      "/* arylen '#' Array length ($#ary) */" },
    { '%', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
      "/* rhash '%' Extra data for restricted hashes */" },
    { '*', "want_vtbl_debugvar",
      "/* debugvar '*' $DB::single, signal, trace vars */" },
    { '.', "want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC",
      "/* pos '.' pos() lvalue */" },
    { ':', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
      "/* symtab ':' Extra data for symbol tables */" },
    { '<', "want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
      "/* backref '<' For weak ref data */" },
    { '@', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
      "/* arylen_p '@' To move arylen out of XPVAV */" },
    { 'B', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
      "/* bm 'B' Boyer-Moore (fast string search) */" },
    { 'c', "want_vtbl_ovrld",
      "/* overload_table 'c' Holds overload table (AMT) on stash */" },
    { 'D', "want_vtbl_regdata",
      "/* regdata 'D' Regex match position data (@+ and @- vars) */" },
    { 'd', "want_vtbl_regdatum",
      "/* regdatum 'd' Regex match position data element */" },
    { 'E', "want_vtbl_env",
      "/* env 'E' %ENV hash */" },
    { 'e', "want_vtbl_envelem",
      "/* envelem 'e' %ENV hash element */" },
    { 'f', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
      "/* fm 'f' Formline ('compiled' format) */" },
    { 'g', "want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
      "/* regex_global 'g' m//g target */" },
    { 'H', "want_vtbl_hints",
      "/* hints 'H' %^H hash */" },
    { 'h', "want_vtbl_hintselem",
      "/* hintselem 'h' %^H hash element */" },
    { 'I', "want_vtbl_isa",
      "/* isa 'I' @ISA array */" },
    { 'i', "want_vtbl_isaelem",
      "/* isaelem 'i' @ISA array element */" },
    { 'k', "want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC",
      "/* nkeys 'k' scalar(keys()) lvalue */" },
    { 'L', "magic_vtable_max",
      "/* dbfile 'L' Debugger %_<filename */" },
    { 'l', "want_vtbl_dbline",
      "/* dbline 'l' Debugger %_<filename element */" },
    { 'o', "want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC",
      "/* collxfrm 'o' Locale transformation */" },
    { 'P', "want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC",
      "/* tied 'P' Tied array or hash */" },
    { 'p', "want_vtbl_packelem",
      "/* tiedelem 'p' Tied array or hash element */" },
    { 'q', "want_vtbl_packelem",
      "/* tiedscalar 'q' Tied scalar or handle */" },
    { 'r', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
      "/* qr 'r' Precompiled qr// regex */" },
    { 'S', "want_vtbl_sig",
      "/* sig 'S' %SIG hash */" },
    { 's', "want_vtbl_sigelem",
      "/* sigelem 's' %SIG hash element */" },
    { 't', "want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC",
      "/* taint 't' Taintedness */" },
    { 'U', "want_vtbl_uvar",
      "/* uvar 'U' Available for use by extensions */" },
    { 'V', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
      "/* vstring 'V' SV was vstring literal */" },
    { 'v', "want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC",
      "/* vec 'v' vec() lvalue */" },
    { 'w', "want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC",
      "/* utf8 'w' Cached UTF-8 information */" },
    { 'x', "want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC",
      "/* substr 'x' substr() lvalue */" },
    { 'Y', "want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC",
      "/* nonelem 'Y' Array element that does not exist */" },
    { 'y', "want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC",
      "/* defelem 'y' Shadow \"foreach\" iterator variable / smart parameter vivification */" },
    { '\\', "want_vtbl_lvref",
      "/* lvref '\\' Lvalue reference constructor */" },
    { ']', "want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC",
      "/* checkcall ']' Inlining/mutation of call to this CV */" },
    { '~', "magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE",
      "/* ext '~' Available for use by extensions */" },

/* ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /* -*- buffer-read-only: t -*-
 *
 *    mg_vtable.h
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/mg_vtable.pl.
 * Any changes made here will be lost!
 */

/* These constants should be used in preference to raw characters
 * when using magic. Note that some perl guts still assume
 * certain character properties of these constants, namely that
 * isUPPER() and toLOWER() may do useful mappings.
 */

#define PERL_MAGIC_sv             '\0' /* Special scalar variable */
#define PERL_MAGIC_arylen         '#' /* Array length ($#ary) */
#define PERL_MAGIC_rhash          '%' /* Extra data for restricted hashes */
#define PERL_MAGIC_debugvar       '*' /* $DB::single, signal, trace vars */
#define PERL_MAGIC_pos            '.' /* pos() lvalue */
#define PERL_MAGIC_symtab         ':' /* Extra data for symbol tables */
#define PERL_MAGIC_backref        '<' /* For weak ref data */
#define PERL_MAGIC_arylen_p       '@' /* To move arylen out of XPVAV */
#define PERL_MAGIC_bm             'B' /* Boyer-Moore (fast string search) */
#define PERL_MAGIC_overload_table 'c' /* Holds overload table (AMT) on stash */
#define PERL_MAGIC_regdata        'D' /* Regex match position data
                                         (@+ and @- vars) */
#define PERL_MAGIC_regdatum       'd' /* Regex match position data element */
#define PERL_MAGIC_env            'E' /* %ENV hash */
#define PERL_MAGIC_envelem        'e' /* %ENV hash element */
#define PERL_MAGIC_fm             'f' /* Formline ('compiled' format) */
#define PERL_MAGIC_regex_global   'g' /* m//g target */
#define PERL_MAGIC_hints          'H' /* %^H hash */
#define PERL_MAGIC_hintselem      'h' /* %^H hash element */
#define PERL_MAGIC_isa            'I' /* @ISA array */
#define PERL_MAGIC_isaelem        'i' /* @ISA array element */
#define PERL_MAGIC_nkeys          'k' /* scalar(keys()) lvalue */
#define PERL_MAGIC_dbfile         'L' /* Debugger %_<filename */
#define PERL_MAGIC_dbline         'l' /* Debugger %_<filename element */
#define PERL_MAGIC_shared         'N' /* Shared between threads */
#define PERL_MAGIC_shared_scalar  'n' /* Shared between threads */
#define PERL_MAGIC_collxfrm       'o' /* Locale transformation */
#define PERL_MAGIC_tied           'P' /* Tied array or hash */
#define PERL_MAGIC_tiedelem       'p' /* Tied array or hash element */
#define PERL_MAGIC_tiedscalar     'q' /* Tied scalar or handle */
#define PERL_MAGIC_qr             'r' /* Precompiled qr// regex */
#define PERL_MAGIC_sig            'S' /* %SIG hash */
#define PERL_MAGIC_sigelem        's' /* %SIG hash element */
#define PERL_MAGIC_taint          't' /* Taintedness */
#define PERL_MAGIC_uvar           'U' /* Available for use by extensions */
#define PERL_MAGIC_uvar_elem      'u' /* Reserved for use by extensions */
#define PERL_MAGIC_vstring        'V' /* SV was vstring literal */
#define PERL_MAGIC_vec            'v' /* vec() lvalue */
#define PERL_MAGIC_utf8           'w' /* Cached UTF-8 information */
#define PERL_MAGIC_substr         'x' /* substr() lvalue */
#define PERL_MAGIC_nonelem        'Y' /* Array element that does not exist */
#define PERL_MAGIC_defelem        'y' /* Shadow "foreach" iterator variable /
                                         smart parameter vivification */
#define PERL_MAGIC_lvref          '\\' /* Lvalue reference constructor */
#define PERL_MAGIC_checkcall      ']' /* Inlining/mutation of call to this CV */
#define PERL_MAGIC_ext            '~' /* Available for use by extensions */

enum {		/* pass one of these to get_vtbl */
    want_vtbl_arylen,
    want_vtbl_arylen_p,
    want_vtbl_backref,
    want_vtbl_checkcall,
    want_vtbl_collxfrm,
    want_vtbl_dbline,
    want_vtbl_debugvar,
    want_vtbl_defelem,
    want_vtbl_env,
    want_vtbl_envelem,
    want_vtbl_hints,
    want_vtbl_hintselem,
    want_vtbl_isa,
    want_vtbl_isaelem,
    want_vtbl_lvref,
    want_vtbl_mglob,
    want_vtbl_nkeys,
    want_vtbl_nonelem,
    want_vtbl_ovrld,
    want_vtbl_pack,
    want_vtbl_packelem,
    want_vtbl_pos,
    want_vtbl_regdata,
    want_vtbl_regdatum,
    want_vtbl_regexp,
    want_vtbl_sig,
    want_vtbl_sigelem,
    want_vtbl_substr,
    want_vtbl_sv,
    want_vtbl_taint,
    want_vtbl_utf8,
    want_vtbl_uvar,
    want_vtbl_vec,
    magic_vtable_max
};

#ifdef DOINIT
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max] = {
    "arylen",
    "arylen_p",
    "backref",
    "checkcall",
    "collxfrm",
    "dbline",
    "debugvar",
    "defelem",
    "env",
    "envelem",
    "hints",
    "hintselem",
    "isa",
    "isaelem",
    "lvref",
    "mglob",
    "nkeys",
    "nonelem",
    "ovrld",
    "pack",
    "packelem",
    "pos",
    "regdata",
    "regdatum",
    "regexp",
    "sig",
    "sigelem",
    "substr",
    "sv",
    "taint",
    "utf8",
    "uvar",
    "vec"
};
#else
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max];
#endif

/* These all need to be 0, not NULL, as NULL can be (void*)0, which is a
 * pointer to data, whereas we're assigning pointers to functions, which are
 * not the same beast. ANSI doesn't allow the assignment from one to the other.
 * (although most, but not all, compilers are prepared to do it)
 */

/* order is:
    get
    set
    len
    clear
    free
    copy
    dup
    local
*/

#ifdef DOINIT
EXT_MGVTBL PL_magic_vtables[magic_vtable_max] = {
  { (int (*)(pTHX_ SV *, MAGIC *))Perl_magic_getarylen, Perl_magic_setarylen, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, Perl_magic_cleararylen_p, Perl_magic_freearylen_p, 0, 0, 0 },
  { 0, 0, 0, 0, Perl_magic_killbackrefs, 0, 0, 0 },
  { 0, 0, 0, 0, 0, Perl_magic_copycallchecker, 0, 0 },
#ifdef USE_LOCALE_COLLATE
  { 0, Perl_magic_setcollxfrm, 0, 0, Perl_magic_freecollxfrm, 0, 0, 0 },
#else
  { 0, 0, 0, 0, 0, 0, 0, 0 },
#endif
  { 0, Perl_magic_setdbline, 0, 0, 0, 0, 0, 0 },
  { Perl_magic_getdebugvar, Perl_magic_setdebugvar, 0, 0, 0, 0, 0, 0 },
  { Perl_magic_getdefelem, Perl_magic_setdefelem, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_set_all_env, 0, Perl_magic_clear_all_env, 0, 0, 0, 0 },
  { 0, Perl_magic_setenv, 0, Perl_magic_clearenv, 0, 0, 0, 0 },
  { 0, 0, 0, Perl_magic_clearhints, 0, 0, 0, 0 },
  { 0, Perl_magic_sethint, 0, Perl_magic_clearhint, 0, 0, 0, 0 },
  { 0, Perl_magic_setisa, 0, Perl_magic_clearisa, 0, 0, 0, 0 },
  { 0, Perl_magic_setisa, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setlvref, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setmglob, 0, 0, Perl_magic_freemglob, 0, 0, 0 },
  { Perl_magic_getnkeys, Perl_magic_setnkeys, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setnonelem, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, Perl_magic_freeovrld, 0, 0, 0 },
  { 0, 0, Perl_magic_sizepack, Perl_magic_wipepack, 0, 0, 0, 0 },
  { Perl_magic_getpack, Perl_magic_setpack, 0, Perl_magic_clearpack, 0, 0, 0, 0 },
  { Perl_magic_getpos, Perl_magic_setpos, 0, 0, 0, 0, 0, 0 },
  { 0, 0, Perl_magic_regdata_cnt, 0, 0, 0, 0, 0 },
  { Perl_magic_regdatum_get, Perl_magic_regdatum_set, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setregexp, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setsigall, 0, 0, 0, 0, 0, 0 },
#ifndef PERL_MICRO
  { Perl_magic_getsig, Perl_magic_setsig, 0, Perl_magic_clearsig, 0, 0, 0, 0 },
#else
  { 0, 0, 0, 0, 0, 0, 0, 0 },
#endif
  { Perl_magic_getsubstr, Perl_magic_setsubstr, 0, 0, 0, 0, 0, 0 },
  { Perl_magic_get, Perl_magic_set, 0, 0, 0, 0, 0, 0 },
  { Perl_magic_gettaint, Perl_magic_settaint, 0, 0, 0, 0, 0, 0 },
  { 0, Perl_magic_setutf8, 0, 0, Perl_magic_freeutf8, 0, 0, 0 },
  { Perl_magic_getuvar, Perl_magic_setuvar, 0, 0, 0, 0, 0, 0 },
  { Perl_magic_getvec, Perl_magic_setvec, 0, 0, 0, 0, 0, 0 }
};
#else
EXT_MGVTBL PL_magic_vtables[magic_vtable_max];
#endif

#define want_vtbl_bm want_vtbl_regexp
#define want_vtbl_fm want_vtbl_regexp

#define PL_vtbl_arylen PL_magic_vtables[want_vtbl_arylen]
#define PL_vtbl_arylen_p PL_magic_vtables[want_vtbl_arylen_p]
#define PL_vtbl_backref PL_magic_vtables[want_vtbl_backref]
#define PL_vtbl_bm PL_magic_vtables[want_vtbl_bm]
#define PL_vtbl_checkcall PL_magic_vtables[want_vtbl_checkcall]
#define PL_vtbl_collxfrm PL_magic_vtables[want_vtbl_collxfrm]
#define PL_vtbl_dbline PL_magic_vtables[want_vtbl_dbline]
#define PL_vtbl_debugvar PL_magic_vtables[want_vtbl_debugvar]
#define PL_vtbl_defelem PL_magic_vtables[want_vtbl_defelem]
#define PL_vtbl_env PL_magic_vtables[want_vtbl_env]
#define PL_vtbl_envelem PL_magic_vtables[want_vtbl_envelem]
#define PL_vtbl_fm PL_magic_vtables[want_vtbl_fm]
#define PL_vtbl_hints PL_magic_vtables[want_vtbl_hints]
#define PL_vtbl_hintselem PL_magic_vtables[want_vtbl_hintselem]
#define PL_vtbl_isa PL_magic_vtables[want_vtbl_isa]
#define PL_vtbl_isaelem PL_magic_vtables[want_vtbl_isaelem]
#define PL_vtbl_lvref PL_magic_vtables[want_vtbl_lvref]
#define PL_vtbl_mglob PL_magic_vtables[want_vtbl_mglob]
#define PL_vtbl_nkeys PL_magic_vtables[want_vtbl_nkeys]
#define PL_vtbl_nonelem PL_magic_vtables[want_vtbl_nonelem]
#define PL_vtbl_ovrld PL_magic_vtables[want_vtbl_ovrld]
#define PL_vtbl_pack PL_magic_vtables[want_vtbl_pack]
#define PL_vtbl_packelem PL_magic_vtables[want_vtbl_packelem]
#define PL_vtbl_pos PL_magic_vtables[want_vtbl_pos]
#define PL_vtbl_regdata PL_magic_vtables[want_vtbl_regdata]
#define PL_vtbl_regdatum PL_magic_vtables[want_vtbl_regdatum]
#define PL_vtbl_regexp PL_magic_vtables[want_vtbl_regexp]
#define PL_vtbl_sig PL_magic_vtables[want_vtbl_sig]
#define PL_vtbl_sigelem PL_magic_vtables[want_vtbl_sigelem]
#define PL_vtbl_substr PL_magic_vtables[want_vtbl_substr]
#define PL_vtbl_sv PL_magic_vtables[want_vtbl_sv]
#define PL_vtbl_taint PL_magic_vtables[want_vtbl_taint]
#define PL_vtbl_utf8 PL_magic_vtables[want_vtbl_utf8]
#define PL_vtbl_uvar PL_magic_vtables[want_vtbl_uvar]
#define PL_vtbl_vec PL_magic_vtables[want_vtbl_vec]

/* ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /*    mydtrace.h
 *
 *    Copyright (C) 2008, 2010, 2011 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 *	Provides macros that wrap the various DTrace probes we use. We add
 *	an extra level of wrapping to encapsulate the _ENABLED tests.
 */

#if defined(USE_DTRACE) && defined(PERL_CORE)

#  include "perldtrace.h"

#  define PERL_DTRACE_PROBE_ENTRY(cv)               \
    if (PERL_SUB_ENTRY_ENABLED())                   \
        Perl_dtrace_probe_call(aTHX_ cv, TRUE);

#  define PERL_DTRACE_PROBE_RETURN(cv)              \
    if (PERL_SUB_ENTRY_ENABLED())                   \
        Perl_dtrace_probe_call(aTHX_ cv, FALSE);

#  define PERL_DTRACE_PROBE_FILE_LOADING(name)      \
    if (PERL_SUB_ENTRY_ENABLED())                   \
        Perl_dtrace_probe_load(aTHX_ name, TRUE);

#  define PERL_DTRACE_PROBE_FILE_LOADED(name)       \
    if (PERL_SUB_ENTRY_ENABLED())                   \
        Perl_dtrace_probe_load(aTHX_ name, FALSE);

#  define PERL_DTRACE_PROBE_OP(op)                  \
    if (PERL_OP_ENTRY_ENABLED())                    \
        Perl_dtrace_probe_op(aTHX_ op);

#  define PERL_DTRACE_PROBE_PHASE(phase)            \
    if (PERL_OP_ENTRY_ENABLED())                    \
        Perl_dtrace_probe_phase(aTHX_ phase);

#else

/* NOPs */
#  define PERL_DTRACE_PROBE_ENTRY(cv)
#  define PERL_DTRACE_PROBE_RETURN(cv)
#  define PERL_DTRACE_PROBE_FILE_LOADING(cv)
#  define PERL_DTRACE_PROBE_FILE_LOADED(cv)
#  define PERL_DTRACE_PROBE_OP(op)
#  define PERL_DTRACE_PROBE_PHASE(phase)

#endif

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /*    nostdio.h
 *
 *    Copyright (C) 1996, 2000, 2001, 2005, by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
 * Strong denial of stdio - make all stdio calls (we can think of) errors
 */
/* This is a 1st attempt to stop other include files pulling
   in real <stdio.h>.
   A more ambitious set of possible symbols can be found in
   sfio.h (inside an _cplusplus gard).
   It is completely pointless as we have already included it ourselves.
*/

#if !defined(_STDIO_H) && !defined(FILE) && !defined(_STDIO_INCLUDED) && !defined(__STDIO_LOADED)
#define _STDIO_H
#define _STDIO_INCLUDED
#define __STDIO_LOADED
struct _FILE;
#define FILE struct _FILE
#endif

#if !defined(OEMVS)

#define _CANNOT "CANNOT"

#undef clearerr
#undef fclose
#undef fdopen
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fileno
#undef flockfile
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef ftrylockfile
#undef funlockfile
#undef fwrite
#undef getc
#undef getc_unlocked
#undef getw
#undef pclose
#undef popen
#undef putc
#undef putc_unlocked
#undef putw
#undef rewind
#undef setbuf
#undef setvbuf
#undef stderr
#undef stdin
#undef stdout
#undef tmpfile
#undef ungetc
#undef vfprintf
#undef printf

#define fprintf    _CANNOT _fprintf_
#define printf     _CANNOT _printf_
#define stdin      _CANNOT _stdin_
#define stdout     _CANNOT _stdout_
#define stderr     _CANNOT _stderr_
#ifndef OS2
#define tmpfile()  _CANNOT _tmpfile_
#endif
#define fclose(f)  _CANNOT _fclose_
#define fflush(f)  _CANNOT _fflush_
#define fopen(p,m)  _CANNOT _fopen_
#define freopen(p,m,f)  _CANNOT _freopen_
#define setbuf(f,b)  _CANNOT _setbuf_
#define setvbuf(f,b,x,s)  _CANNOT _setvbuf_
#define fscanf  _CANNOT _fscanf_
#define vfprintf(f,fmt,a)  _CANNOT _vfprintf_
#define fgetc(f)  _CANNOT _fgetc_
#define fgets(s,n,f)  _CANNOT _fgets_
#define fputc(c,f)  _CANNOT _fputc_
#define fputs(s,f)  _CANNOT _fputs_
#define getc(f)  _CANNOT _getc_
#define putc(c,f)  _CANNOT _putc_
#ifndef OS2
#define ungetc(c,f)  _CANNOT _ungetc_
#endif
#define fread(b,s,c,f)  _CANNOT _fread_
#define fwrite(b,s,c,f)  _CANNOT _fwrite_
#define fgetpos(f,p)  _CANNOT _fgetpos_
#define fseek(f,o,w)  _CANNOT _fseek_
#define fsetpos(f,p)  _CANNOT _fsetpos_
#define ftell(f)  _CANNOT _ftell_
#define rewind(f)  _CANNOT _rewind_
#define clearerr(f)  _CANNOT _clearerr_
#define feof(f)  _CANNOT _feof_
#define ferror(f)  _CANNOT _ferror_
#define __filbuf(f)  _CANNOT __filbuf_
#define __flsbuf(c,f)  _CANNOT __flsbuf_
#define _filbuf(f)  _CANNOT _filbuf_
#define _flsbuf(c,f)  _CANNOT _flsbuf_
#define fdopen(fd,p)  _CANNOT _fdopen_
#define fileno(f)  _CANNOT _fileno_
#if defined(SFIO_VERSION) && SFIO_VERSION < 20000101L
#define flockfile(f)  _CANNOT _flockfile_
#define ftrylockfile(f)  _CANNOT _ftrylockfile_
#define funlockfile(f)  _CANNOT _funlockfile_
#endif
#define getc_unlocked(f)  _CANNOT _getc_unlocked_
#define putc_unlocked(c,f)  _CANNOT _putc_unlocked_
#define popen(c,m)  _CANNOT _popen_
#define getw(f)  _CANNOT _getw_
#define putw(v,f)  _CANNOT _putw_
#ifndef OS2
#define pclose(f)  _CANNOT _pclose_
#endif

#endif /*not define EBCDIC */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           /*    op.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
 * The fields of BASEOP are:
 *	op_next		Pointer to next ppcode to execute after this one.
 *			(Top level pre-grafted op points to first op,
 *			but this is replaced when op is grafted in, when
 *			this op will point to the real next op, and the new
 *			parent takes over role of remembering starting op.)
 * 	op_sibparent    Pointer to the op's next sibling, or to the parent
 *			if there are no more siblings.
 *	op_ppaddr	Pointer to current ppcode's function.
 * 	op_targ		An index into the current pad, identifying an SV
 *			that is typically used to store the OP's result
 *			(such as a lexical variable, or a SVs_PADTMP
 *			temporary intermediate value).
 *	op_type		The type of the operation.
 *	op_opt		Whether or not the op has been optimised by the
 *			peephole optimiser.
 *	op_slabbed	allocated via opslab
 *	op_static	tell op_free() to skip PerlMemShared_free(), when
 *                      !op_slabbed.
 *	op_savefree	on savestack via SAVEFREEOP
 *	op_folded	Result/remainder of a constant fold operation.
 *	op_moresib	this op is not the last sibling
 *	op_spare	One spare bit
 *	op_flags	Flags common to all operations.  See OPf_* below.
 *	op_private	Flags peculiar to a particular operation (BUT,
 *			by default, set to the number of children until
 *			the operation is privatized by a check routine,
 *			which may or may not check number of children).
 */
#include "op_reg_common.h"

#define OPCODE U16

typedef PERL_BITFIELD16 Optype;

#ifdef BASEOP_DEFINITION
#define BASEOP BASEOP_DEFINITION
#else
#define BASEOP				\
    OP*		op_next;		\
    OP*		op_sibparent;		\
    OP*		(*op_ppaddr)(pTHX);	\
    PADOFFSET	op_targ;		\
    PERL_BITFIELD16 op_type:9;		\
    PERL_BITFIELD16 op_opt:1;		\
    PERL_BITFIELD16 op_slabbed:1;	\
    PERL_BITFIELD16 op_savefree:1;	\
    PERL_BITFIELD16 op_static:1;	\
    PERL_BITFIELD16 op_folded:1;	\
    PERL_BITFIELD16 op_moresib:1;       \
    PERL_BITFIELD16 op_spare:1;		\
    U8		op_flags;		\
    U8		op_private;
#endif

/* If op_type:9 is changed to :10, also change cx_pusheval()
   Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32)
   then all the other bit-fields before/after it should change their
   types too to let VC pack them into the same 4 byte integer.*/

/* for efficiency, requires OPf_WANT_VOID == G_VOID etc */
#define OP_GIMME(op,dfl) \
        (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl)

#define OP_GIMME_REVERSE(flags)	((flags) & G_WANT)

/*
=for apidoc_section $callback

=for apidoc Amn|U32|GIMME_V
The XSUB-writer's equivalent to Perl's C<wantarray>.  Returns C<G_VOID>,
C<G_SCALAR> or C<G_LIST> for void, scalar or list context,
respectively.  See L<perlcall> for a usage example.

=for apidoc AmnD|U32|GIMME
A backward-compatible version of C<GIMME_V> which can only return
C<G_SCALAR> or C<G_LIST>; in a void context, it returns C<G_SCALAR>.
Deprecated.  Use C<GIMME_V> instead.

=cut
*/

#define GIMME_V		Perl_gimme_V(aTHX)

/* Public flags */

#define OPf_WANT	3	/* Mask for "want" bits: */
#define  OPf_WANT_VOID	 1	/*   Want nothing */
#define  OPf_WANT_SCALAR 2	/*   Want single value */
#define  OPf_WANT_LIST	 3	/*   Want list of any length */
#define OPf_KIDS	4	/* There is a firstborn child. */
#define OPf_PARENS	8	/* This operator was parenthesized. */
                                /*  (Or block needs explicit scope entry.) */
#define OPf_REF		16	/* Certified reference. */
                                /*  (Return container, not containee). */
#define OPf_MOD		32	/* Will modify (lvalue). */

#define OPf_STACKED	64	/* Some arg is arriving on the stack. */
                                /*   Indicates mutator-variant of op for those
                                 *     ops which support them, e.g. $x += 1
                                 */

#define OPf_SPECIAL	128	/* Do something weird for this op: */
                                /*  On local LVAL, don't init local value. */
                                /*  On OP_SORT, subroutine is inlined. */
                                /*  On OP_NOT, inversion was implicit. */
                                /*  On OP_LEAVE, don't restore curpm, e.g.
                                 *      /(...)/ while ...>;  */
                                /*  On truncate, we truncate filehandle */
                                /*  On control verbs, we saw no label */
                                /*  On flipflop, we saw ... instead of .. */
                                /*  On UNOPs, saw bare parens, e.g. eof(). */
                                /*  On OP_CHDIR, handle (or bare parens) */
                                /*  On OP_NULL, saw a "do". */
                                /*  On OP_EXISTS, treat av as av, not avhv.  */
                                /*  On OP_(ENTER|LEAVE)EVAL, don't clear $@ */
                                /*  On regcomp, "use re 'eval'" was in scope */
                                /*  On RV2[ACGHS]V, don't create GV--in
                                    defined()*/
                                /*  On OP_DBSTATE, indicates breakpoint
                                 *    (runtime property) */
                                /*  On OP_REQUIRE, was seen as CORE::require */
                                /*  On OP_(ENTER|LEAVE)WHEN, there's
                                    no condition */
                                /*  On OP_SMARTMATCH, an implicit smartmatch */
                                /*  On OP_ANONHASH and OP_ANONLIST, create a
                                    reference to the new anon hash or array */
                                /*  On OP_HELEM, OP_MULTIDEREF and OP_HSLICE,
                                    localization will be followed by assignment,
                                    so do not wipe the target if it is special
                                    (e.g. a glob or a magic SV) */
                                /*  On OP_MATCH, OP_SUBST & OP_TRANS, the
                                    operand of a logical or conditional
                                    that was optimised away, so it should
                                    not be bound via =~ */
                                /*  On OP_CONST, from a constant CV */
                                /*  On OP_GLOB, two meanings:
                                    - Before ck_glob, called as CORE::glob
                                    - After ck_glob, use Perl glob function
                                 */
                                /*  On OP_PADRANGE, push @_ */
                                /*  On OP_DUMP, has no label */
                                /*  On OP_UNSTACK, in a C-style for loop */
                                /*  On OP_READLINE, it's for <<>>, not <> */
/* There is no room in op_flags for this one, so it has its own bit-
   field member (op_folded) instead.  The flag is only used to tell
   op_convert_list to set op_folded.  */
#define OPf_FOLDED      (1<<16)

/* old names; don't use in new code, but don't break them, either */
#define OPf_LIST	OPf_WANT_LIST
#define OPf_KNOW	OPf_WANT

#if !defined(PERL_CORE) && !defined(PERL_EXT)
#  define GIMME \
          (PL_op->op_flags & OPf_WANT					\
           ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST		\
              ? G_LIST							\
              : G_SCALAR)						\
           : dowantarray())
#endif


/* NOTE: OPp* flags are now auto-generated and defined in opcode.h,
 *       from data in regen/op_private */


#define OPpTRANS_ALL	(OPpTRANS_USE_SVOP|OPpTRANS_CAN_FORCE_UTF8|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE)
#define OPpTRANS_FROM_UTF   OPpTRANS_USE_SVOP
#define OPpTRANS_TO_UTF     OPpTRANS_CAN_FORCE_UTF8


/* Mask for OP_ENTERSUB flags, the absence of which must be propagated
 in dynamic context */
#define OPpENTERSUB_LVAL_MASK (OPpLVAL_INTRO|OPpENTERSUB_INARGS)


/* things that can be elements of op_aux */
typedef union {
    PADOFFSET pad_offset;
    SV        *sv;
    IV        iv;
    UV        uv;
    char      *pv;
    SSize_t   ssize;
} UNOP_AUX_item;

#ifdef USE_ITHREADS
#  define UNOP_AUX_item_sv(item) PAD_SVl((item)->pad_offset);
#else
#  define UNOP_AUX_item_sv(item) ((item)->sv);
#endif




struct op {
    BASEOP
};

struct unop {
    BASEOP
    OP *	op_first;
};

struct unop_aux {
    BASEOP
    OP  	  *op_first;
    UNOP_AUX_item *op_aux;
};

struct binop {
    BASEOP
    OP *	op_first;
    OP *	op_last;
};

struct logop {
    BASEOP
    OP *	op_first;

    /* Note that op->op_other is the *next* op in execution order of the
     * alternate branch, not the root of the subtree. I.e. imagine it being
     * called ->op_otherfirst.
     * To find the structural subtree root (what could be called
     * ->op_otherroot), use OpSIBLING of ->op_first  */
    OP *	op_other;
};

struct listop {
    BASEOP
    OP *	op_first;
    OP *	op_last;
};

struct methop {
    BASEOP
    union {
        /* op_u.op_first *must* be aligned the same as the op_first
         * field of the other op types, and op_u.op_meth_sv *must*
         * be aligned with op_sv */
        OP* op_first;   /* optree for method name */
        SV* op_meth_sv; /* static method name */
    } op_u;
#ifdef USE_ITHREADS
    PADOFFSET op_rclass_targ; /* pad index for redirect class */
#else
    SV*       op_rclass_sv;   /* static redirect class $o->A::meth() */
#endif
};

struct pmop {
    BASEOP
    OP *	op_first;
    OP *	op_last;
#ifdef USE_ITHREADS
    PADOFFSET   op_pmoffset;
#else
    REGEXP *    op_pmregexp;            /* compiled expression */
#endif
    U32         op_pmflags;
    union {
        OP *	op_pmreplroot;		/* For OP_SUBST */
        PADOFFSET op_pmtargetoff;	/* For OP_SPLIT lex ary or thr GV */
        GV *	op_pmtargetgv;	        /* For OP_SPLIT non-threaded GV */
    }	op_pmreplrootu;
    union {
        OP *	op_pmreplstart;	/* Only used in OP_SUBST */
#ifdef USE_ITHREADS
        PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */
#else
        HV *	op_pmstash;
#endif
    }		op_pmstashstartu;
    OP *	op_code_list;	/* list of (?{}) code blocks */
};

#ifdef USE_ITHREADS
#define PM_GETRE(o)	(SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \
                         ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL)
/* The assignment is just to enforce type safety (or at least get a warning).
 */
/* With first class regexps not via a reference one needs to assign
   &PL_sv_undef under ithreads. (This would probably work unthreaded, but NULL
   is cheaper. I guess we could allow NULL, but the check above would get
   more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */
/* BEWARE - something that calls this macro passes (r) which has a side
   effect.  */
#define PM_SETRE(o,r)	STMT_START {					\
                            REGEXP *const _pm_setre = (r);		\
                            assert(_pm_setre);				\
                            PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \
                        } STMT_END
#else
#define PM_GETRE(o)     ((o)->op_pmregexp)
#define PM_SETRE(o,r)   ((o)->op_pmregexp = (r))
#endif

/* Currently these PMf flags occupy a single 32-bit word.  Not all bits are
 * currently used.  The lower bits are shared with their corresponding RXf flag
 * bits, up to but not including _RXf_PMf_SHIFT_NEXT.  The unused bits
 * immediately follow; finally the used Pmf-only (unshared) bits, so that the
 * highest bit in the word is used.  This gathers all the unused bits as a pool
 * in the middle, like so: 11111111111111110000001111111111
 * where the '1's represent used bits, and the '0's unused.  This design allows
 * us to allocate off one end of the pool if we need to add a shared bit, and
 * off the other end if we need a non-shared bit, without disturbing the other
 * bits.  This maximizes the likelihood of being able to change things without
 * breaking binary compatibility.
 *
 * To add shared bits, do so in op_reg_common.h.  This should change
 * _RXf_PMf_SHIFT_NEXT so that things won't compile.  Then come to regexp.h and
 * op.h and adjust the constant adders in the definitions of PMf_BASE_SHIFT and
 * Pmf_BASE_SHIFT down by the number of shared bits you added.  That's it.
 * Things should be binary compatible.  But if either of these gets to having
 * to subtract rather than add, leave at 0 and adjust all the entries below
 * that are in terms of this according.  But if the first one of those is
 * already PMf_BASE_SHIFT+0, there are no bits left, and a redesign is in
 * order.
 *
 * To remove unshared bits, just delete its entry.  If you're where breaking
 * binary compatibility is ok to do, you might want to adjust things to move
 * the newly opened space so that it gets absorbed into the common pool.
 *
 * To add unshared bits, first use up any gaps in the middle.  Otherwise,
 * allocate off the low end until you get to PMf_BASE_SHIFT+0.  If that isn't
 * enough, move PMf_BASE_SHIFT down (if possible) and add the new bit at the
 * other end instead; this preserves binary compatibility. */
#define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+2)

/* Set by the parser if it discovers an error, so the regex shouldn't be
 * compiled */
#define PMf_HAS_ERROR	(1U<<(PMf_BASE_SHIFT+3))

/* 'use re "taint"' in scope: taint $1 etc. if target tainted */
#define PMf_RETAINT	(1U<<(PMf_BASE_SHIFT+4))

/* match successfully only once per reset, with related flag RXf_USED in
 * re->extflags holding state.  This is used only for ?? matches, and only on
 * OP_MATCH and OP_QR */
#define PMf_ONCE	(1U<<(PMf_BASE_SHIFT+5))

/* PMf_ONCE, i.e. ?pat?, has matched successfully.  Not used under threading. */
#define PMf_USED        (1U<<(PMf_BASE_SHIFT+6))

/* subst replacement is constant */
#define PMf_CONST	(1U<<(PMf_BASE_SHIFT+7))

/* keep 1st runtime pattern forever */
#define PMf_KEEP	(1U<<(PMf_BASE_SHIFT+8))

#define PMf_GLOBAL	(1U<<(PMf_BASE_SHIFT+9)) /* pattern had a g modifier */

/* don't reset pos() if //g fails */
#define PMf_CONTINUE	(1U<<(PMf_BASE_SHIFT+10))

/* evaluating replacement as expr */
#define PMf_EVAL	(1U<<(PMf_BASE_SHIFT+11))

/* Return substituted string instead of modifying it. */
#define PMf_NONDESTRUCT	(1U<<(PMf_BASE_SHIFT+12))

/* the pattern has a CV attached (currently only under qr/...(?{}).../) */
#define PMf_HAS_CV	(1U<<(PMf_BASE_SHIFT+13))

/* op_code_list is private; don't free it etc. It may well point to
 * code within another sub, with different pad etc */
#define PMf_CODELIST_PRIVATE	(1U<<(PMf_BASE_SHIFT+14))

/* the PMOP is a QR (we should be able to detect that from the op type,
 * but the regex compilation API passes just the pm flags, not the op
 * itself */
#define PMf_IS_QR	(1U<<(PMf_BASE_SHIFT+15))
#define PMf_USE_RE_EVAL	(1U<<(PMf_BASE_SHIFT+16)) /* use re'eval' in scope */

/* Means that this is a subpattern being compiled while processing a \p{}
 * wildcard.  This isn't called from op.c, but it is passed as a pm flag. */
#define PMf_WILDCARD    (1U<<(PMf_BASE_SHIFT+17))

/* See comments at the beginning of these defines about adding bits.  The
 * highest bit position should be used, so that if PMf_BASE_SHIFT gets
 * increased, the #error below will be triggered so that you will be reminded
 * to adjust things at the other end to keep the bit positions unchanged */
#if PMf_BASE_SHIFT+17 > 31
#   error Too many PMf_ bits used.  See above and regnodes.h for any spare in middle
#endif

#ifdef USE_ITHREADS

#  define PmopSTASH(o)         ((o)->op_pmflags & PMf_ONCE                         \
                                ? PL_stashpad[(o)->op_pmstashstartu.op_pmstashoff]   \
                                : NULL)
#  define PmopSTASH_set(o,hv)	\
        (assert_((o)->op_pmflags & PMf_ONCE)				\
         (o)->op_pmstashstartu.op_pmstashoff =				\
            (hv) ? alloccopstash(hv) : 0)
#else
#  define PmopSTASH(o)							\
    (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL)
#  if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS)
#    define PmopSTASH_set(o,hv)		({				\
        assert((o)->op_pmflags & PMf_ONCE);				\
        ((o)->op_pmstashstartu.op_pmstash = (hv));			\
    })
#  else
#    define PmopSTASH_set(o,hv)	((o)->op_pmstashstartu.op_pmstash = (hv))
#  endif
#endif
#define PmopSTASHPV(o)	(PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL)
   /* op_pmstashstartu.op_pmstash is not refcounted */
#define PmopSTASHPV_set(o,pv)	PmopSTASH_set((o), gv_stashpv(pv,GV_ADD))

struct svop {
    BASEOP
    SV *	op_sv;
};

struct padop {
    BASEOP
    PADOFFSET	op_padix;
};

struct pvop {
    BASEOP
    char *	op_pv;
};

struct loop {
    BASEOP
    OP *	op_first;
    OP *	op_last;
    OP *	op_redoop;
    OP *	op_nextop;
    OP *	op_lastop;
};

#define cUNOPx(o)	((UNOP*)(o))
#define cUNOP_AUXx(o)	((UNOP_AUX*)(o))
#define cBINOPx(o)	((BINOP*)(o))
#define cLISTOPx(o)	((LISTOP*)(o))
#define cLOGOPx(o)	((LOGOP*)(o))
#define cPMOPx(o)	((PMOP*)(o))
#define cSVOPx(o)	((SVOP*)(o))
#define cPADOPx(o)	((PADOP*)(o))
#define cPVOPx(o)	((PVOP*)(o))
#define cCOPx(o)	((COP*)(o))
#define cLOOPx(o)	((LOOP*)(o))
#define cMETHOPx(o)	((METHOP*)(o))

#define cUNOP		cUNOPx(PL_op)
#define cUNOP_AUX	cUNOP_AUXx(PL_op)
#define cBINOP		cBINOPx(PL_op)
#define cLISTOP		cLISTOPx(PL_op)
#define cLOGOP		cLOGOPx(PL_op)
#define cPMOP		cPMOPx(PL_op)
#define cSVOP		cSVOPx(PL_op)
#define cPADOP		cPADOPx(PL_op)
#define cPVOP		cPVOPx(PL_op)
#define cCOP		cCOPx(PL_op)
#define cLOOP		cLOOPx(PL_op)

#define cUNOPo		cUNOPx(o)
#define cUNOP_AUXo	cUNOP_AUXx(o)
#define cBINOPo		cBINOPx(o)
#define cLISTOPo	cLISTOPx(o)
#define cLOGOPo		cLOGOPx(o)
#define cPMOPo		cPMOPx(o)
#define cSVOPo		cSVOPx(o)
#define cPADOPo		cPADOPx(o)
#define cPVOPo		cPVOPx(o)
#define cCOPo		cCOPx(o)
#define cLOOPo		cLOOPx(o)

#define kUNOP		cUNOPx(kid)
#define kUNOP_AUX	cUNOP_AUXx(kid)
#define kBINOP		cBINOPx(kid)
#define kLISTOP		cLISTOPx(kid)
#define kLOGOP		cLOGOPx(kid)
#define kPMOP		cPMOPx(kid)
#define kSVOP		cSVOPx(kid)
#define kPADOP		cPADOPx(kid)
#define kPVOP		cPVOPx(kid)
#define kCOP		cCOPx(kid)
#define kLOOP		cLOOPx(kid)


typedef enum {
    OPclass_NULL,     /*  0 */
    OPclass_BASEOP,   /*  1 */
    OPclass_UNOP,     /*  2 */
    OPclass_BINOP,    /*  3 */
    OPclass_LOGOP,    /*  4 */
    OPclass_LISTOP,   /*  5 */
    OPclass_PMOP,     /*  6 */
    OPclass_SVOP,     /*  7 */
    OPclass_PADOP,    /*  8 */
    OPclass_PVOP,     /*  9 */
    OPclass_LOOP,     /* 10 */
    OPclass_COP,      /* 11 */
    OPclass_METHOP,   /* 12 */
    OPclass_UNOP_AUX  /* 13 */
} OPclass;


#ifdef USE_ITHREADS
#  define	cGVOPx_gv(o)	((GV*)PAD_SVl(cPADOPx(o)->op_padix))
#  ifndef PERL_CORE
#    define	IS_PADGV(v)	(v && isGV(v))
#    define	IS_PADCONST(v) \
        (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v))))
#  endif
#  define	cSVOPx_sv(v)	(cSVOPx(v)->op_sv \
                                 ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ))
#  define	cSVOPx_svp(v)	(cSVOPx(v)->op_sv \
                                 ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ))
#  define	cMETHOPx_rclass(v) PAD_SVl(cMETHOPx(v)->op_rclass_targ)
#else
#  define	cGVOPx_gv(o)	((GV*)cSVOPx(o)->op_sv)
#  ifndef PERL_CORE
#    define	IS_PADGV(v)	FALSE
#    define	IS_PADCONST(v)	FALSE
#  endif
#  define	cSVOPx_sv(v)	(cSVOPx(v)->op_sv)
#  define	cSVOPx_svp(v)	(&cSVOPx(v)->op_sv)
#  define	cMETHOPx_rclass(v) (cMETHOPx(v)->op_rclass_sv)
#endif

#define	cMETHOPx_meth(v)	cSVOPx_sv(v)

#define	cGVOP_gv		cGVOPx_gv(PL_op)
#define	cGVOPo_gv		cGVOPx_gv(o)
#define	kGVOP_gv		cGVOPx_gv(kid)
#define cSVOP_sv		cSVOPx_sv(PL_op)
#define cSVOPo_sv		cSVOPx_sv(o)
#define kSVOP_sv		cSVOPx_sv(kid)

#ifndef PERL_CORE
#  define Nullop ((OP*)NULL)
#endif

/* Lowest byte of PL_opargs */
#define OA_MARK 1
#define OA_FOLDCONST 2
#define OA_RETSCALAR 4
#define OA_TARGET 8
#define OA_TARGLEX 16
#define OA_OTHERINT 32
#define OA_DANGEROUS 64
#define OA_DEFGV 128

/* The next 4 bits (8..11) encode op class information */
#define OCSHIFT 8

#define OA_CLASS_MASK (15 << OCSHIFT)

#define OA_BASEOP (0 << OCSHIFT)
#define OA_UNOP (1 << OCSHIFT)
#define OA_BINOP (2 << OCSHIFT)
#define OA_LOGOP (3 << OCSHIFT)
#define OA_LISTOP (4 << OCSHIFT)
#define OA_PMOP (5 << OCSHIFT)
#define OA_SVOP (6 << OCSHIFT)
#define OA_PADOP (7 << OCSHIFT)
#define OA_PVOP_OR_SVOP (8 << OCSHIFT)
#define OA_LOOP (9 << OCSHIFT)
#define OA_COP (10 << OCSHIFT)
#define OA_BASEOP_OR_UNOP (11 << OCSHIFT)
#define OA_FILESTATOP (12 << OCSHIFT)
#define OA_LOOPEXOP (13 << OCSHIFT)
#define OA_METHOP (14 << OCSHIFT)
#define OA_UNOP_AUX (15 << OCSHIFT)

/* Each remaining nybble of PL_opargs (i.e. bits 12..15, 16..19 etc)
 * encode the type for each arg */
#define OASHIFT 12

#define OA_SCALAR 1
#define OA_LIST 2
#define OA_AVREF 3
#define OA_HVREF 4
#define OA_CVREF 5
#define OA_FILEREF 6
#define OA_SCALARREF 7
#define OA_OPTIONAL 8

/* Op_REFCNT is a reference count at the head of each op tree: needed
 * since the tree is shared between threads, and between cloned closure
 * copies in the same thread. OP_REFCNT_LOCK/UNLOCK is used when modifying
 * this count.
 * The same mutex is used to protect the refcounts of the reg_trie_data
 * and reg_ac_data structures, which are shared between duplicated
 * regexes.
 */

#ifdef USE_ITHREADS
#  define OP_REFCNT_INIT		MUTEX_INIT(&PL_op_mutex)
#  ifdef PERL_CORE
#    define OP_REFCNT_LOCK		MUTEX_LOCK(&PL_op_mutex)
#    define OP_REFCNT_UNLOCK		MUTEX_UNLOCK(&PL_op_mutex)
#  else     /* Subject non-core uses to clang thread safety analysis */
#    define OP_REFCNT_LOCK		op_refcnt_lock()
#    define OP_REFCNT_UNLOCK		op_refcnt_unlock()
#  endif
#  define OP_REFCNT_TERM		MUTEX_DESTROY(&PL_op_mutex)
#else
#  define OP_REFCNT_INIT		NOOP
#  define OP_REFCNT_LOCK		NOOP
#  define OP_REFCNT_UNLOCK		NOOP
#  define OP_REFCNT_TERM		NOOP
#endif

#define OpREFCNT_set(o,n)		((o)->op_targ = (n))
#ifdef PERL_DEBUG_READONLY_OPS
#  define OpREFCNT_inc(o)		Perl_op_refcnt_inc(aTHX_ o)
#  define OpREFCNT_dec(o)		Perl_op_refcnt_dec(aTHX_ o)
#else
#  define OpREFCNT_inc(o)		((o) ? (++(o)->op_targ, (o)) : NULL)
#  define OpREFCNT_dec(o)		(--(o)->op_targ)
#endif

/* flags used by Perl_load_module() */
#define PERL_LOADMOD_DENY		0x1	/* no Module */
#define PERL_LOADMOD_NOIMPORT		0x2	/* use Module () */
#define PERL_LOADMOD_IMPORT_OPS		0x4	/* import arguments
                                                   are passed as a sin-
                                                   gle op tree, not a
                                                   list of SVs */

#if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
#define ref(o, type) doref(o, type, TRUE)
#endif


/* translation table attached to OP_TRANS/OP_TRANSR ops */

typedef struct {
    Size_t size; /* number of entries in map[], not including final slot */
    short map[1]; /* Unwarranted chumminess */
} OPtrans_map;


/*
=for apidoc_section $optree_manipulation

=for apidoc Am|OP*|LINKLIST|OP *o
Given the root of an optree, link the tree in execution order using the
C<op_next> pointers and return the first op executed.  If this has
already been done, it will not be redone, and C<< o->op_next >> will be
returned.  If C<< o->op_next >> is not already set, C<o> should be at
least an C<UNOP>.

=cut
*/

#define LINKLIST(o) ((o)->op_next ? (o)->op_next : op_linklist((OP*)o))

/* no longer used anywhere in core */
#ifndef PERL_CORE
#define cv_ckproto(cv, gv, p) \
   cv_ckproto_len_flags((cv), (gv), (p), (p) ? strlen(p) : 0, 0)
#endif

#ifdef PERL_CORE
#  define my(o)	my_attrs((o), NULL)
#endif

#ifdef USE_REENTRANT_API
#include "reentr.h"
#endif

#define NewOp(m,var,c,type)	\
        (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type)))
#define NewOpSz(m,var,size)	\
        (var = (OP *) Perl_Slab_Alloc(aTHX_ size))
#define FreeOp(p) Perl_Slab_Free(aTHX_ p)

/*
 * The per-CV op slabs consist of a header (the opslab struct) and a bunch
 * of space for allocating op slots, each of which consists of two pointers
 * followed by an op.  The first pointer points to the next op slot.  The
 * second points to the slab.  At the end of the slab is a null pointer,
 * so that slot->opslot_next - slot can be used to determine the size
 * of the op.
 *
 * Each CV can have multiple slabs; opslab_next points to the next slab, to
 * form a chain.  All bookkeeping is done on the first slab, which is where
 * all the op slots point.
 *
 * Freed ops are marked as freed and attached to the freed chain
 * via op_next pointers.
 *
 * When there is more than one slab, the second slab in the slab chain is
 * assumed to be the one with free space available.  It is used when allo-
 * cating an op if there are no freed ops available or big enough.
 */

#ifdef PERL_CORE
struct opslot {
    U16         opslot_size;        /* size of this slot (in pointers) */
    U16         opslot_offset;      /* offset from start of slab (in ptr units) */
    OP		opslot_op;		/* the op itself */
};

struct opslab {
    OPSLAB *	opslab_next;		/* next slab */
    OPSLAB *	opslab_head;		/* first slab in chain */
    OP **	opslab_freed;		/* array of sized chains of freed ops (head only)*/
    size_t	opslab_refcnt;		/* number of ops (head slab only) */
    U16         opslab_freed_size;      /* allocated size of opslab_freed */
    U16		opslab_size;		/* size of slab in pointers,
                                           including header */
    U16         opslab_free_space;	/* space available in this slab
                                           for allocating new ops (in ptr
                                           units) */
# ifdef PERL_DEBUG_READONLY_OPS
    bool	opslab_readonly;
# endif
    OPSLOT	opslab_slots;		/* slots begin here */
};

# define OPSLOT_HEADER		STRUCT_OFFSET(OPSLOT, opslot_op)
# define OpSLOT(o)		(assert_(o->op_slabbed) \
                                 (OPSLOT *)(((char *)o)-OPSLOT_HEADER))

/* the slab that owns this op */
# define OpMySLAB(o) \
    ((OPSLAB*)((char *)((I32**)OpSLOT(o) - OpSLOT(o)->opslot_offset)-STRUCT_OFFSET(struct opslab, opslab_slots)))
/* the first (head) opslab of the chain in which this op is allocated */
# define OpSLAB(o) \
    (OpMySLAB(o)->opslab_head)
/* calculate the slot given the owner slab and an offset */
#define OpSLOToff(slab, offset) \
    ((OPSLOT*)(((I32 **)&(slab)->opslab_slots)+(offset)))

# define OpslabREFCNT_dec(slab)      \
        (((slab)->opslab_refcnt == 1) \
         ? opslab_free_nopad(slab)     \
         : (void)--(slab)->opslab_refcnt)
  /* Variant that does not null out the pads */
# define OpslabREFCNT_dec_padok(slab) \
        (((slab)->opslab_refcnt == 1)  \
         ? opslab_free(slab)		\
         : (void)--(slab)->opslab_refcnt)
#endif

struct block_hooks {
    U32	    bhk_flags;
    void    (*bhk_start)	(pTHX_ int full);
    void    (*bhk_pre_end)	(pTHX_ OP **seq);
    void    (*bhk_post_end)	(pTHX_ OP **seq);
    void    (*bhk_eval)		(pTHX_ OP *const saveop);
};

/*
=for apidoc_section $scope

=for apidoc mx|U32|BhkFLAGS|BHK *hk
Return the BHK's flags.

=for apidoc mxu|void *|BhkENTRY|BHK *hk|which
Return an entry from the BHK structure.  C<which> is a preprocessor token
indicating which entry to return.  If the appropriate flag is not set
this will return C<NULL>.  The type of the return value depends on which
entry you ask for.

=for apidoc Amxu|void|BhkENTRY_set|BHK *hk|which|void *ptr
Set an entry in the BHK structure, and set the flags to indicate it is
valid.  C<which> is a preprocessing token indicating which entry to set.
The type of C<ptr> depends on the entry.

=for apidoc Amxu|void|BhkDISABLE|BHK *hk|which
Temporarily disable an entry in this BHK structure, by clearing the
appropriate flag.  C<which> is a preprocessor token indicating which
entry to disable.

=for apidoc Amxu|void|BhkENABLE|BHK *hk|which
Re-enable an entry in this BHK structure, by setting the appropriate
flag.  C<which> is a preprocessor token indicating which entry to enable.
This will assert (under -DDEBUGGING) if the entry doesn't contain a valid
pointer.

=for apidoc mxu|void|CALL_BLOCK_HOOKS|which|arg
Call all the registered block hooks for type C<which>.  C<which> is a
preprocessing token; the type of C<arg> depends on C<which>.

=cut
*/

#define BhkFLAGS(hk)		((hk)->bhk_flags)

#define BHKf_bhk_start	    0x01
#define BHKf_bhk_pre_end    0x02
#define BHKf_bhk_post_end   0x04
#define BHKf_bhk_eval	    0x08

#define BhkENTRY(hk, which) \
    ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->which) : NULL)

#define BhkENABLE(hk, which) \
    STMT_START { \
        BhkFLAGS(hk) |= BHKf_ ## which; \
        assert(BhkENTRY(hk, which)); \
    } STMT_END

#define BhkDISABLE(hk, which) \
    STMT_START { \
        BhkFLAGS(hk) &= ~(BHKf_ ## which); \
    } STMT_END

#define BhkENTRY_set(hk, which, ptr) \
    STMT_START { \
        (hk)->which = ptr; \
        BhkENABLE(hk, which); \
    } STMT_END

#define CALL_BLOCK_HOOKS(which, arg) \
    STMT_START { \
        if (PL_blockhooks) { \
            SSize_t i; \
            for (i = av_top_index(PL_blockhooks); i >= 0; i--) { \
                SV *sv = AvARRAY(PL_blockhooks)[i]; \
                BHK *hk; \
                \
                assert(SvIOK(sv)); \
                if (SvUOK(sv)) \
                    hk = INT2PTR(BHK *, SvUVX(sv)); \
                else \
                    hk = INT2PTR(BHK *, SvIVX(sv)); \
                \
                if (BhkENTRY(hk, which)) \
                    BhkENTRY(hk, which)(aTHX_ arg); \
            } \
        } \
    } STMT_END

/* flags for rv2cv_op_cv */

#define RV2CVOPCV_MARK_EARLY     0x00000001
#define RV2CVOPCV_RETURN_NAME_GV 0x00000002
#define RV2CVOPCV_RETURN_STUB    0x00000004
#if defined(PERL_CORE) || defined(PERL_EXT) /* behaviour of this flag is subject to change: */
# define RV2CVOPCV_MAYBE_NAME_GV  0x00000008
#endif
#define RV2CVOPCV_FLAG_MASK      0x0000000f /* all of the above */

#define op_lvalue(op,t) Perl_op_lvalue_flags(aTHX_ op,t,0)

/* flags for op_lvalue_flags */

#define OP_LVALUE_NO_CROAK 1

/*
=for apidoc_section $custom

=for apidoc Am|U32|XopFLAGS|XOP *xop
Return the XOP's flags.

=for apidoc Am||XopENTRY|XOP *xop|which
Return a member of the XOP structure.  C<which> is a cpp token
indicating which entry to return.  If the member is not set
this will return a default value.  The return type depends
on C<which>.  This macro evaluates its arguments more than
once.  If you are using C<Perl_custom_op_xop> to retrieve a
C<XOP *> from a C<OP *>, use the more efficient L</XopENTRYCUSTOM> instead.

=for apidoc Am||XopENTRYCUSTOM|const OP *o|which
Exactly like C<XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), which)> but more
efficient.  The C<which> parameter is identical to L</XopENTRY>.

=for apidoc Am|void|XopENTRY_set|XOP *xop|which|value
Set a member of the XOP structure.  C<which> is a cpp token
indicating which entry to set.  See L<perlguts/"Custom Operators">
for details about the available members and how
they are used.  This macro evaluates its argument
more than once.

=for apidoc Am|void|XopDISABLE|XOP *xop|which
Temporarily disable a member of the XOP, by clearing the appropriate flag.

=for apidoc Am|void|XopENABLE|XOP *xop|which
Reenable a member of the XOP which has been disabled.

=cut
*/

struct custom_op {
    U32		    xop_flags;    
    const char	   *xop_name;
    const char	   *xop_desc;
    U32		    xop_class;
    void	  (*xop_peep)(pTHX_ OP *o, OP *oldop);
};

/* return value of Perl_custom_op_get_field, similar to void * then casting but
   the U32 doesn't need truncation on 64 bit platforms in the caller, also
   for easier macro writing */
typedef union {
    const char	   *xop_name;
    const char	   *xop_desc;
    U32		    xop_class;
    void	  (*xop_peep)(pTHX_ OP *o, OP *oldop);
    XOP            *xop_ptr;
} XOPRETANY;

#define XopFLAGS(xop) ((xop)->xop_flags)

#define XOPf_xop_name	0x01
#define XOPf_xop_desc	0x02
#define XOPf_xop_class	0x04
#define XOPf_xop_peep	0x08

/* used by Perl_custom_op_get_field for option checking */
typedef enum {
    XOPe_xop_ptr = 0, /* just get the XOP *, don't look inside it */
    XOPe_xop_name = XOPf_xop_name,
    XOPe_xop_desc = XOPf_xop_desc,
    XOPe_xop_class = XOPf_xop_class,
    XOPe_xop_peep = XOPf_xop_peep
} xop_flags_enum;

#define XOPd_xop_name	PL_op_name[OP_CUSTOM]
#define XOPd_xop_desc	PL_op_desc[OP_CUSTOM]
#define XOPd_xop_class	OA_BASEOP
#define XOPd_xop_peep	((Perl_cpeep_t)0)

#define XopENTRY_set(xop, which, to) \
    STMT_START { \
        (xop)->which = (to); \
        (xop)->xop_flags |= XOPf_ ## which; \
    } STMT_END

#define XopENTRY(xop, which) \
    ((XopFLAGS(xop) & XOPf_ ## which) ? (xop)->which : XOPd_ ## which)

#define XopENTRYCUSTOM(o, which) \
    (Perl_custom_op_get_field(aTHX_ o, XOPe_ ## which).which)

#define XopDISABLE(xop, which) ((xop)->xop_flags &= ~XOPf_ ## which)
#define XopENABLE(xop, which) \
    STMT_START { \
        (xop)->xop_flags |= XOPf_ ## which; \
        assert(XopENTRY(xop, which)); \
    } STMT_END

#define Perl_custom_op_xop(x) \
    (Perl_custom_op_get_field(x, XOPe_xop_ptr).xop_ptr)

/*
=for apidoc_section $optree_manipulation

=for apidoc Am|const char *|OP_NAME|OP *o
Return the name of the provided OP.  For core ops this looks up the name
from the op_type; for custom ops from the op_ppaddr.

=for apidoc Am|const char *|OP_DESC|OP *o
Return a short description of the provided OP.

=for apidoc Am|U32|OP_CLASS|OP *o
Return the class of the provided OP: that is, which of the *OP
structures it uses.  For core ops this currently gets the information out
of C<PL_opargs>, which does not always accurately reflect the type used;
in v5.26 onwards, see also the function C<L</op_class>> which can do a better
job of determining the used type.

For custom ops the type is returned from the registration, and it is up
to the registree to ensure it is accurate.  The value returned will be
one of the C<OA_>* constants from F<op.h>.

=for apidoc Am|bool|OP_TYPE_IS|OP *o|Optype type
Returns true if the given OP is not a C<NULL> pointer
and if it is of the given type.

The negation of this macro, C<OP_TYPE_ISNT> is also available
as well as C<OP_TYPE_IS_NN> and C<OP_TYPE_ISNT_NN> which elide
the NULL pointer check.

=for apidoc Am|bool|OP_TYPE_IS_OR_WAS|OP *o|Optype type
Returns true if the given OP is not a NULL pointer and
if it is of the given type or used to be before being
replaced by an OP of type OP_NULL.

The negation of this macro, C<OP_TYPE_ISNT_AND_WASNT>
is also available as well as C<OP_TYPE_IS_OR_WAS_NN>
and C<OP_TYPE_ISNT_AND_WASNT_NN> which elide
the C<NULL> pointer check.

=for apidoc Am|bool|OpHAS_SIBLING|OP *o
Returns true if C<o> has a sibling

=for apidoc Am|OP*|OpSIBLING|OP *o
Returns the sibling of C<o>, or C<NULL> if there is no sibling

=for apidoc Am|void|OpMORESIB_set|OP *o|OP *sib
Sets the sibling of C<o> to the non-zero value C<sib>. See also C<L</OpLASTSIB_set>>
and C<L</OpMAYBESIB_set>>. For a higher-level interface, see
C<L</op_sibling_splice>>.

=for apidoc Am|void|OpLASTSIB_set|OP *o|OP *parent
Marks C<o> as having no further siblings and marks
o as having the specified parent. See also C<L</OpMORESIB_set>> and
C<OpMAYBESIB_set>. For a higher-level interface, see
C<L</op_sibling_splice>>.

=for apidoc Am|void|OpMAYBESIB_set|OP *o|OP *sib|OP *parent
Conditionally does C<OpMORESIB_set> or C<OpLASTSIB_set> depending on whether
C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.

=cut
*/

#define OP_NAME(o) ((o)->op_type == OP_CUSTOM \
                    ? XopENTRYCUSTOM(o, xop_name) \
                    : PL_op_name[(o)->op_type])
#define OP_DESC(o) ((o)->op_type == OP_CUSTOM \
                    ? XopENTRYCUSTOM(o, xop_desc) \
                    : PL_op_desc[(o)->op_type])
#define OP_CLASS(o) ((o)->op_type == OP_CUSTOM \
                     ? XopENTRYCUSTOM(o, xop_class) \
                     : (PL_opargs[(o)->op_type] & OA_CLASS_MASK))

#define OP_TYPE_IS(o, type) ((o) && (o)->op_type == (type))
#define OP_TYPE_IS_NN(o, type) ((o)->op_type == (type))
#define OP_TYPE_ISNT(o, type) ((o) && (o)->op_type != (type))
#define OP_TYPE_ISNT_NN(o, type) ((o)->op_type != (type))

#define OP_TYPE_IS_OR_WAS_NN(o, type) \
    ( ((o)->op_type == OP_NULL \
       ? (o)->op_targ \
       : (o)->op_type) \
      == (type) )

#define OP_TYPE_IS_OR_WAS(o, type) \
    ( (o) && OP_TYPE_IS_OR_WAS_NN(o, type) )

#define OP_TYPE_ISNT_AND_WASNT_NN(o, type) \
    ( ((o)->op_type == OP_NULL \
       ? (o)->op_targ \
       : (o)->op_type) \
      != (type) )

#define OP_TYPE_ISNT_AND_WASNT(o, type) \
    ( (o) && OP_TYPE_ISNT_AND_WASNT_NN(o, type) )

/* should match anything that uses ck_ftst in regen/opcodes */
#define OP_IS_STAT(op) (OP_IS_FILETEST(op) || (op) == OP_LSTAT || (op) == OP_STAT)

#define OpHAS_SIBLING(o)	(cBOOL((o)->op_moresib))
#define OpSIBLING(o)		(0 + (o)->op_moresib ? (o)->op_sibparent : NULL)
#define OpMORESIB_set(o, sib) ((o)->op_moresib = 1, (o)->op_sibparent = (sib))
#define OpLASTSIB_set(o, parent) \
    ((o)->op_moresib = 0, (o)->op_sibparent = (parent))
#define OpMAYBESIB_set(o, sib, parent) \
    ((o)->op_sibparent = ((o)->op_moresib = cBOOL(sib)) ? (sib) : (parent))

#if !defined(PERL_CORE) && !defined(PERL_EXT)
/* for backwards compatibility only */
#  define OP_SIBLING(o)		OpSIBLING(o)
#endif

#define newATTRSUB(f, o, p, a, b) Perl_newATTRSUB_x(aTHX_  f, o, p, a, b, FALSE)
#define newSUB(f, o, p, b)	newATTRSUB((f), (o), (p), NULL, (b))

#ifdef USE_ITHREADS
#  define OP_CHECK_MUTEX_INIT		MUTEX_INIT(&PL_check_mutex)
#  define OP_CHECK_MUTEX_LOCK		MUTEX_LOCK(&PL_check_mutex)
#  define OP_CHECK_MUTEX_UNLOCK		MUTEX_UNLOCK(&PL_check_mutex)
#  define OP_CHECK_MUTEX_TERM		MUTEX_DESTROY(&PL_check_mutex)
#else
#  define OP_CHECK_MUTEX_INIT		NOOP
#  define OP_CHECK_MUTEX_LOCK		NOOP
#  define OP_CHECK_MUTEX_UNLOCK		NOOP
#  define OP_CHECK_MUTEX_TERM		NOOP
#endif


/* Stuff for OP_MULTDEREF/pp_multideref. */

/* actions */

/* Load another word of actions/flag bits. Must be 0 */
#define MDEREF_reload                       0

#define MDEREF_AV_pop_rv2av_aelem           1
#define MDEREF_AV_gvsv_vivify_rv2av_aelem   2
#define MDEREF_AV_padsv_vivify_rv2av_aelem  3
#define MDEREF_AV_vivify_rv2av_aelem        4
#define MDEREF_AV_padav_aelem               5
#define MDEREF_AV_gvav_aelem                6

#define MDEREF_HV_pop_rv2hv_helem           8
#define MDEREF_HV_gvsv_vivify_rv2hv_helem   9
#define MDEREF_HV_padsv_vivify_rv2hv_helem 10
#define MDEREF_HV_vivify_rv2hv_helem       11
#define MDEREF_HV_padhv_helem              12
#define MDEREF_HV_gvhv_helem               13

#define MDEREF_ACTION_MASK                0xf

/* key / index type */

#define MDEREF_INDEX_none   0x00 /* run external ops to generate index */
#define MDEREF_INDEX_const  0x10 /* index is const PV/UV */
#define MDEREF_INDEX_padsv  0x20 /* index is lexical var */
#define MDEREF_INDEX_gvsv   0x30 /* index is GV */

#define MDEREF_INDEX_MASK   0x30

/* bit flags */

#define MDEREF_FLAG_last    0x40 /* the last [ah]elem; PL_op flags apply */

#define MDEREF_MASK         0x7F
#define MDEREF_SHIFT           7

#if defined(PERL_IN_DOOP_C) || defined(PERL_IN_PP_C)
#   define FATAL_ABOVE_FF_MSG                                       \
      "Use of strings with code points over 0xFF as arguments to "  \
      "%s operator is not allowed"
#endif
#if defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_PERL_C)
#  define TR_UNMAPPED           (UV)-1
#  define TR_DELETE             (UV)-2
#  define TR_R_EMPTY            (UV)-3  /* rhs (replacement) is empty */
#  define TR_OOB                (UV)-4  /* Something that isn't one of the others */
#  define TR_SPECIAL_HANDLING   TR_DELETE /* Can occupy same value */
#  define TR_UNLISTED           TR_UNMAPPED /* A synonym whose name is clearer
                                               at times */
#endif
#if defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
#define RANGE_INDICATOR  ILLEGAL_UTF8_BYTE
#endif

/* stuff for OP_ARGCHECK */

struct op_argcheck_aux {
    UV   params;     /* number of positional parameters */
    UV   opt_params; /* number of optional positional parameters */
    char slurpy;     /* presence of slurpy: may be '\0', '@' or '%' */
};


/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                    /*    op_reg_common.h
 *
 *    Definitions common to by op.h and regexp.h
 *
 *    Copyright (C) 2010, 2011 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/* These defines are used in both op.h and regexp.h  The definitions use the
 * shift form so that ext/B/Makefile.PL will pick them up.
 *
 * Data structures used in the two headers have common fields, and in fact one
 * is copied onto the other.  This makes it easy to keep them in sync */

/* This tells where the first of these bits is.  Setting it to 0 saved cycles
 * and memory.  I (khw) think the code will work if changed back, but haven't
 * tested it */
/* Make sure to update ext/re/re.pm when changing this! */
#ifndef RXf_PMf_STD_PMMOD_SHIFT /* Only expand #include of this file once */

#define RXf_PMf_STD_PMMOD_SHIFT 0

/* The bits need to be ordered so that the msixn are contiguous starting at bit
 * RXf_PMf_STD_PMMOD_SHIFT, followed by the p.  See STD_PAT_MODS and
 * INT_PAT_MODS in regexp.h for the reason contiguity is needed */
/* Make sure to update lib/re.pm when changing these! */
/* Make sure you keep the pure PMf_ versions below in sync */
#define RXf_PMf_MULTILINE      (1U << (RXf_PMf_STD_PMMOD_SHIFT+0))    /* /m */
#define RXf_PMf_SINGLELINE     (1U << (RXf_PMf_STD_PMMOD_SHIFT+1))    /* /s */
#define RXf_PMf_FOLD           (1U << (RXf_PMf_STD_PMMOD_SHIFT+2))    /* /i */
#define RXf_PMf_EXTENDED       (1U << (RXf_PMf_STD_PMMOD_SHIFT+3))    /* /x */
#define RXf_PMf_EXTENDED_MORE  (1U << (RXf_PMf_STD_PMMOD_SHIFT+4))    /* /xx */
#define RXf_PMf_NOCAPTURE      (1U << (RXf_PMf_STD_PMMOD_SHIFT+5))    /* /n */

#define RXf_PMf_KEEPCOPY       (1U << (RXf_PMf_STD_PMMOD_SHIFT+6))    /* /p */

/* The character set for the regex is stored in a field of more than one bit
 * using an enum, for reasons of compactness and to ensure that the options are
 * mutually exclusive */
/* Make sure to update ext/re/re.pm and regcomp.sym (as these are used as
 * offsets for various node types, like POSIXD vs POSIXL, etc) when changing
 * this! */
typedef enum {
    REGEX_DEPENDS_CHARSET = 0,
    REGEX_LOCALE_CHARSET,
    REGEX_UNICODE_CHARSET,
    REGEX_ASCII_RESTRICTED_CHARSET,
    REGEX_ASCII_MORE_RESTRICTED_CHARSET
} regex_charset;

#define _RXf_PMf_CHARSET_SHIFT ((RXf_PMf_STD_PMMOD_SHIFT)+7)
#define RXf_PMf_CHARSET (7U << (_RXf_PMf_CHARSET_SHIFT)) /* 3 bits */

/* Manually decorate these functions here with gcc-style attributes just to
 * avoid making the regex_charset typedef global, which it would need to be for
 * proto.h to understand it */
PERL_STATIC_INLINE void
set_regex_charset(U32 * const flags, const regex_charset cs)
    __attribute__nonnull__(1);

PERL_STATIC_INLINE void
set_regex_charset(U32 * const flags, const regex_charset cs)
{
    /* Sets the character set portion of 'flags' to 'cs', which is a member of
     * the above enum */

    *flags &= ~RXf_PMf_CHARSET;
    *flags |= (cs << _RXf_PMf_CHARSET_SHIFT);
}

PERL_STATIC_INLINE regex_charset
get_regex_charset(const U32 flags)
    __attribute__warn_unused_result__;

PERL_STATIC_INLINE regex_charset
get_regex_charset(const U32 flags)
{
    /* Returns the enum corresponding to the character set in 'flags' */

    return (regex_charset) ((flags & RXf_PMf_CHARSET) >> _RXf_PMf_CHARSET_SHIFT);
}

#define RXf_PMf_STRICT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+10))

#define _RXf_PMf_SHIFT_COMPILETIME (RXf_PMf_STD_PMMOD_SHIFT+11)


/*
  Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will
  be used by regex engines to check whether they should set
  RXf_SKIPWHITE
*/
#define RXf_PMf_SPLIT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+11))

/* Next available bit after the above.  Name begins with '_' so won't be
 * exported by B */
#define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+12)

/* Mask of the above bits.  These need to be transferred from op_pmflags to
 * re->extflags during compilation */
#define RXf_PMf_COMPILETIME    (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE|RXf_PMf_KEEPCOPY|RXf_PMf_NOCAPTURE|RXf_PMf_CHARSET|RXf_PMf_STRICT)
#define RXf_PMf_FLAGCOPYMASK   (RXf_PMf_COMPILETIME|RXf_PMf_SPLIT)

/* Temporary to get Jenkins happy again
 * See thread starting at http://nntp.perl.org/group/perl.perl5.porters/220710
 */
#if 0
    /* Exclude win32 because it can't cope with I32_MAX definition */
#ifndef WIN32
#   if RXf_PMf_COMPILETIME > I32_MAX
#     error RXf_PMf_COMPILETIME wont fit in arg2 field of eval node
#   endif
#endif
#endif

/* These copies need to be numerical or ext/B/Makefile.PL won't think they are
 * constants */
#define PMf_MULTILINE     (1U<<0)
#define PMf_SINGLELINE    (1U<<1)
#define PMf_FOLD          (1U<<2)
#define PMf_EXTENDED      (1U<<3)
#define PMf_EXTENDED_MORE (1U<<4)
#define PMf_NOCAPTURE     (1U<<5)
#define PMf_KEEPCOPY      (1U<<6)
#define PMf_CHARSET       (7U<<7)
#define PMf_STRICT        (1U<<10)
#define PMf_SPLIT         (1U<<11)

#if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_EXTENDED_MORE != RXf_PMf_EXTENDED_MORE || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY || PMf_SPLIT != RXf_PMf_SPLIT || PMf_CHARSET != RXf_PMf_CHARSET || PMf_NOCAPTURE != RXf_PMf_NOCAPTURE || PMf_STRICT != RXf_PMf_STRICT
#   error RXf_PMf defines are wrong
#endif

/*  Error check that haven't left something out of this.  This isn't done
 *  directly in the #define because doing so confuses regcomp.pl.
 *  (2**n - 1) is n 1 bits, so the below gets the contiguous bits between the
 *  beginning and ending shifts */
#if RXf_PMf_COMPILETIME != ((nBIT_MASK(_RXf_PMf_SHIFT_COMPILETIME)) \
                        & (~(nBIT_MASK( RXf_PMf_STD_PMMOD_SHIFT))))
#   error RXf_PMf_COMPILETIME is invalid
#endif

#endif /* Include only once */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /* -*- buffer-read-only: t -*-
 *
 *    opnames.h
 *
 *    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
 *    2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/opcode.pl from its data.
 * Any changes made here will be lost!
 */

typedef enum opcode {
	OP_NULL		 = 0,
	OP_STUB		 = 1,
	OP_SCALAR	 = 2,
	OP_PUSHMARK	 = 3,
	OP_WANTARRAY	 = 4,
	OP_CONST	 = 5,
	OP_GVSV		 = 6,
	OP_GV		 = 7,
	OP_GELEM	 = 8,
	OP_PADSV	 = 9,
	OP_PADAV	 = 10,
	OP_PADHV	 = 11,
	OP_PADANY	 = 12,
	OP_RV2GV	 = 13,
	OP_RV2SV	 = 14,
	OP_AV2ARYLEN	 = 15,
	OP_RV2CV	 = 16,
	OP_ANONCODE	 = 17,
	OP_PROTOTYPE	 = 18,
	OP_REFGEN	 = 19,
	OP_SREFGEN	 = 20,
	OP_REF		 = 21,
	OP_BLESS	 = 22,
	OP_BACKTICK	 = 23,
	OP_GLOB		 = 24,
	OP_READLINE	 = 25,
	OP_RCATLINE	 = 26,
	OP_REGCMAYBE	 = 27,
	OP_REGCRESET	 = 28,
	OP_REGCOMP	 = 29,
	OP_MATCH	 = 30,
	OP_QR		 = 31,
	OP_SUBST	 = 32,
	OP_SUBSTCONT	 = 33,
	OP_TRANS	 = 34,
	OP_TRANSR	 = 35,
	OP_SASSIGN	 = 36,
	OP_AASSIGN	 = 37,
	OP_CHOP		 = 38,
	OP_SCHOP	 = 39,
	OP_CHOMP	 = 40,
	OP_SCHOMP	 = 41,
	OP_DEFINED	 = 42,
	OP_UNDEF	 = 43,
	OP_STUDY	 = 44,
	OP_POS		 = 45,
	OP_PREINC	 = 46,
	OP_I_PREINC	 = 47,
	OP_PREDEC	 = 48,
	OP_I_PREDEC	 = 49,
	OP_POSTINC	 = 50,
	OP_I_POSTINC	 = 51,
	OP_POSTDEC	 = 52,
	OP_I_POSTDEC	 = 53,
	OP_POW		 = 54,
	OP_MULTIPLY	 = 55,
	OP_I_MULTIPLY	 = 56,
	OP_DIVIDE	 = 57,
	OP_I_DIVIDE	 = 58,
	OP_MODULO	 = 59,
	OP_I_MODULO	 = 60,
	OP_REPEAT	 = 61,
	OP_ADD		 = 62,
	OP_I_ADD	 = 63,
	OP_SUBTRACT	 = 64,
	OP_I_SUBTRACT	 = 65,
	OP_CONCAT	 = 66,
	OP_MULTICONCAT	 = 67,
	OP_STRINGIFY	 = 68,
	OP_LEFT_SHIFT	 = 69,
	OP_RIGHT_SHIFT	 = 70,
	OP_LT		 = 71,
	OP_I_LT		 = 72,
	OP_GT		 = 73,
	OP_I_GT		 = 74,
	OP_LE		 = 75,
	OP_I_LE		 = 76,
	OP_GE		 = 77,
	OP_I_GE		 = 78,
	OP_EQ		 = 79,
	OP_I_EQ		 = 80,
	OP_NE		 = 81,
	OP_I_NE		 = 82,
	OP_NCMP		 = 83,
	OP_I_NCMP	 = 84,
	OP_SLT		 = 85,
	OP_SGT		 = 86,
	OP_SLE		 = 87,
	OP_SGE		 = 88,
	OP_SEQ		 = 89,
	OP_SNE		 = 90,
	OP_SCMP		 = 91,
	OP_BIT_AND	 = 92,
	OP_BIT_XOR	 = 93,
	OP_BIT_OR	 = 94,
	OP_NBIT_AND	 = 95,
	OP_NBIT_XOR	 = 96,
	OP_NBIT_OR	 = 97,
	OP_SBIT_AND	 = 98,
	OP_SBIT_XOR	 = 99,
	OP_SBIT_OR	 = 100,
	OP_NEGATE	 = 101,
	OP_I_NEGATE	 = 102,
	OP_NOT		 = 103,
	OP_COMPLEMENT	 = 104,
	OP_NCOMPLEMENT	 = 105,
	OP_SCOMPLEMENT	 = 106,
	OP_SMARTMATCH	 = 107,
	OP_ATAN2	 = 108,
	OP_SIN		 = 109,
	OP_COS		 = 110,
	OP_RAND		 = 111,
	OP_SRAND	 = 112,
	OP_EXP		 = 113,
	OP_LOG		 = 114,
	OP_SQRT		 = 115,
	OP_INT		 = 116,
	OP_HEX		 = 117,
	OP_OCT		 = 118,
	OP_ABS		 = 119,
	OP_LENGTH	 = 120,
	OP_SUBSTR	 = 121,
	OP_VEC		 = 122,
	OP_INDEX	 = 123,
	OP_RINDEX	 = 124,
	OP_SPRINTF	 = 125,
	OP_FORMLINE	 = 126,
	OP_ORD		 = 127,
	OP_CHR		 = 128,
	OP_CRYPT	 = 129,
	OP_UCFIRST	 = 130,
	OP_LCFIRST	 = 131,
	OP_UC		 = 132,
	OP_LC		 = 133,
	OP_QUOTEMETA	 = 134,
	OP_RV2AV	 = 135,
	OP_AELEMFAST	 = 136,
	OP_AELEMFAST_LEX = 137,
	OP_AELEM	 = 138,
	OP_ASLICE	 = 139,
	OP_KVASLICE	 = 140,
	OP_AEACH	 = 141,
	OP_AVALUES	 = 142,
	OP_AKEYS	 = 143,
	OP_EACH		 = 144,
	OP_VALUES	 = 145,
	OP_KEYS		 = 146,
	OP_DELETE	 = 147,
	OP_EXISTS	 = 148,
	OP_RV2HV	 = 149,
	OP_HELEM	 = 150,
	OP_HSLICE	 = 151,
	OP_KVHSLICE	 = 152,
	OP_MULTIDEREF	 = 153,
	OP_UNPACK	 = 154,
	OP_PACK		 = 155,
	OP_SPLIT	 = 156,
	OP_JOIN		 = 157,
	OP_LIST		 = 158,
	OP_LSLICE	 = 159,
	OP_ANONLIST	 = 160,
	OP_ANONHASH	 = 161,
	OP_SPLICE	 = 162,
	OP_PUSH		 = 163,
	OP_POP		 = 164,
	OP_SHIFT	 = 165,
	OP_UNSHIFT	 = 166,
	OP_SORT		 = 167,
	OP_REVERSE	 = 168,
	OP_GREPSTART	 = 169,
	OP_GREPWHILE	 = 170,
	OP_MAPSTART	 = 171,
	OP_MAPWHILE	 = 172,
	OP_RANGE	 = 173,
	OP_FLIP		 = 174,
	OP_FLOP		 = 175,
	OP_AND		 = 176,
	OP_OR		 = 177,
	OP_XOR		 = 178,
	OP_DOR		 = 179,
	OP_COND_EXPR	 = 180,
	OP_ANDASSIGN	 = 181,
	OP_ORASSIGN	 = 182,
	OP_DORASSIGN	 = 183,
	OP_ENTERSUB	 = 184,
	OP_LEAVESUB	 = 185,
	OP_LEAVESUBLV	 = 186,
	OP_ARGCHECK	 = 187,
	OP_ARGELEM	 = 188,
	OP_ARGDEFELEM	 = 189,
	OP_CALLER	 = 190,
	OP_WARN		 = 191,
	OP_DIE		 = 192,
	OP_RESET	 = 193,
	OP_LINESEQ	 = 194,
	OP_NEXTSTATE	 = 195,
	OP_DBSTATE	 = 196,
	OP_UNSTACK	 = 197,
	OP_ENTER	 = 198,
	OP_LEAVE	 = 199,
	OP_SCOPE	 = 200,
	OP_ENTERITER	 = 201,
	OP_ITER		 = 202,
	OP_ENTERLOOP	 = 203,
	OP_LEAVELOOP	 = 204,
	OP_RETURN	 = 205,
	OP_LAST		 = 206,
	OP_NEXT		 = 207,
	OP_REDO		 = 208,
	OP_DUMP		 = 209,
	OP_GOTO		 = 210,
	OP_EXIT		 = 211,
	OP_METHOD	 = 212,
	OP_METHOD_NAMED	 = 213,
	OP_METHOD_SUPER	 = 214,
	OP_METHOD_REDIR	 = 215,
	OP_METHOD_REDIR_SUPER = 216,
	OP_ENTERGIVEN	 = 217,
	OP_LEAVEGIVEN	 = 218,
	OP_ENTERWHEN	 = 219,
	OP_LEAVEWHEN	 = 220,
	OP_BREAK	 = 221,
	OP_CONTINUE	 = 222,
	OP_OPEN		 = 223,
	OP_CLOSE	 = 224,
	OP_PIPE_OP	 = 225,
	OP_FILENO	 = 226,
	OP_UMASK	 = 227,
	OP_BINMODE	 = 228,
	OP_TIE		 = 229,
	OP_UNTIE	 = 230,
	OP_TIED		 = 231,
	OP_DBMOPEN	 = 232,
	OP_DBMCLOSE	 = 233,
	OP_SSELECT	 = 234,
	OP_SELECT	 = 235,
	OP_GETC		 = 236,
	OP_READ		 = 237,
	OP_ENTERWRITE	 = 238,
	OP_LEAVEWRITE	 = 239,
	OP_PRTF		 = 240,
	OP_PRINT	 = 241,
	OP_SAY		 = 242,
	OP_SYSOPEN	 = 243,
	OP_SYSSEEK	 = 244,
	OP_SYSREAD	 = 245,
	OP_SYSWRITE	 = 246,
	OP_EOF		 = 247,
	OP_TELL		 = 248,
	OP_SEEK		 = 249,
	OP_TRUNCATE	 = 250,
	OP_FCNTL	 = 251,
	OP_IOCTL	 = 252,
	OP_FLOCK	 = 253,
	OP_SEND		 = 254,
	OP_RECV		 = 255,
	OP_SOCKET	 = 256,
	OP_SOCKPAIR	 = 257,
	OP_BIND		 = 258,
	OP_CONNECT	 = 259,
	OP_LISTEN	 = 260,
	OP_ACCEPT	 = 261,
	OP_SHUTDOWN	 = 262,
	OP_GSOCKOPT	 = 263,
	OP_SSOCKOPT	 = 264,
	OP_GETSOCKNAME	 = 265,
	OP_GETPEERNAME	 = 266,
	OP_LSTAT	 = 267,
	OP_STAT		 = 268,
	OP_FTRREAD	 = 269,
	OP_FTRWRITE	 = 270,
	OP_FTREXEC	 = 271,
	OP_FTEREAD	 = 272,
	OP_FTEWRITE	 = 273,
	OP_FTEEXEC	 = 274,
	OP_FTIS		 = 275,
	OP_FTSIZE	 = 276,
	OP_FTMTIME	 = 277,
	OP_FTATIME	 = 278,
	OP_FTCTIME	 = 279,
	OP_FTROWNED	 = 280,
	OP_FTEOWNED	 = 281,
	OP_FTZERO	 = 282,
	OP_FTSOCK	 = 283,
	OP_FTCHR	 = 284,
	OP_FTBLK	 = 285,
	OP_FTFILE	 = 286,
	OP_FTDIR	 = 287,
	OP_FTPIPE	 = 288,
	OP_FTSUID	 = 289,
	OP_FTSGID	 = 290,
	OP_FTSVTX	 = 291,
	OP_FTLINK	 = 292,
	OP_FTTTY	 = 293,
	OP_FTTEXT	 = 294,
	OP_FTBINARY	 = 295,
	OP_CHDIR	 = 296,
	OP_CHOWN	 = 297,
	OP_CHROOT	 = 298,
	OP_UNLINK	 = 299,
	OP_CHMOD	 = 300,
	OP_UTIME	 = 301,
	OP_RENAME	 = 302,
	OP_LINK		 = 303,
	OP_SYMLINK	 = 304,
	OP_READLINK	 = 305,
	OP_MKDIR	 = 306,
	OP_RMDIR	 = 307,
	OP_OPEN_DIR	 = 308,
	OP_READDIR	 = 309,
	OP_TELLDIR	 = 310,
	OP_SEEKDIR	 = 311,
	OP_REWINDDIR	 = 312,
	OP_CLOSEDIR	 = 313,
	OP_FORK		 = 314,
	OP_WAIT		 = 315,
	OP_WAITPID	 = 316,
	OP_SYSTEM	 = 317,
	OP_EXEC		 = 318,
	OP_KILL		 = 319,
	OP_GETPPID	 = 320,
	OP_GETPGRP	 = 321,
	OP_SETPGRP	 = 322,
	OP_GETPRIORITY	 = 323,
	OP_SETPRIORITY	 = 324,
	OP_TIME		 = 325,
	OP_TMS		 = 326,
	OP_LOCALTIME	 = 327,
	OP_GMTIME	 = 328,
	OP_ALARM	 = 329,
	OP_SLEEP	 = 330,
	OP_SHMGET	 = 331,
	OP_SHMCTL	 = 332,
	OP_SHMREAD	 = 333,
	OP_SHMWRITE	 = 334,
	OP_MSGGET	 = 335,
	OP_MSGCTL	 = 336,
	OP_MSGSND	 = 337,
	OP_MSGRCV	 = 338,
	OP_SEMOP	 = 339,
	OP_SEMGET	 = 340,
	OP_SEMCTL	 = 341,
	OP_REQUIRE	 = 342,
	OP_DOFILE	 = 343,
	OP_HINTSEVAL	 = 344,
	OP_ENTEREVAL	 = 345,
	OP_LEAVEEVAL	 = 346,
	OP_ENTERTRY	 = 347,
	OP_LEAVETRY	 = 348,
	OP_GHBYNAME	 = 349,
	OP_GHBYADDR	 = 350,
	OP_GHOSTENT	 = 351,
	OP_GNBYNAME	 = 352,
	OP_GNBYADDR	 = 353,
	OP_GNETENT	 = 354,
	OP_GPBYNAME	 = 355,
	OP_GPBYNUMBER	 = 356,
	OP_GPROTOENT	 = 357,
	OP_GSBYNAME	 = 358,
	OP_GSBYPORT	 = 359,
	OP_GSERVENT	 = 360,
	OP_SHOSTENT	 = 361,
	OP_SNETENT	 = 362,
	OP_SPROTOENT	 = 363,
	OP_SSERVENT	 = 364,
	OP_EHOSTENT	 = 365,
	OP_ENETENT	 = 366,
	OP_EPROTOENT	 = 367,
	OP_ESERVENT	 = 368,
	OP_GPWNAM	 = 369,
	OP_GPWUID	 = 370,
	OP_GPWENT	 = 371,
	OP_SPWENT	 = 372,
	OP_EPWENT	 = 373,
	OP_GGRNAM	 = 374,
	OP_GGRGID	 = 375,
	OP_GGRENT	 = 376,
	OP_SGRENT	 = 377,
	OP_EGRENT	 = 378,
	OP_GETLOGIN	 = 379,
	OP_SYSCALL	 = 380,
	OP_LOCK		 = 381,
	OP_ONCE		 = 382,
	OP_CUSTOM	 = 383,
	OP_COREARGS	 = 384,
	OP_AVHVSWITCH	 = 385,
	OP_RUNCV	 = 386,
	OP_FC		 = 387,
	OP_PADCV	 = 388,
	OP_INTROCV	 = 389,
	OP_CLONECV	 = 390,
	OP_PADRANGE	 = 391,
	OP_REFASSIGN	 = 392,
	OP_LVREF	 = 393,
	OP_LVREFSLICE	 = 394,
	OP_LVAVREF	 = 395,
	OP_ANONCONST	 = 396,
	OP_ISA		 = 397,
	OP_CMPCHAIN_AND	 = 398,
	OP_CMPCHAIN_DUP	 = 399,
	OP_ENTERTRYCATCH = 400,
	OP_LEAVETRYCATCH = 401,
	OP_POPTRY	 = 402,
	OP_CATCH	 = 403,
	OP_PUSHDEFER	 = 404,
	OP_IS_BOOL	 = 405,
	OP_IS_WEAK	 = 406,
	OP_WEAKEN	 = 407,
	OP_UNWEAKEN	 = 408,
	OP_BLESSED	 = 409,
	OP_REFADDR	 = 410,
	OP_REFTYPE	 = 411,
	OP_CEIL		 = 412,
	OP_FLOOR	 = 413,
	OP_max		
} opcode;

#define MAXO 414
#define OP_FREED MAXO

/* the OP_IS_* macros are optimized to a simple range check because
    all the member OPs are contiguous in regen/opcodes table.
    opcode.pl verifies the range contiguity, or generates an OR-equals
    expression */

#define OP_IS_SOCKET(op)	\
	((op) >= OP_SEND && (op) <= OP_GETPEERNAME)

#define OP_IS_FILETEST(op)	\
	((op) >= OP_FTRREAD && (op) <= OP_FTBINARY)

#define OP_IS_FILETEST_ACCESS(op)	\
	((op) >= OP_FTRREAD && (op) <= OP_FTEEXEC)

#define OP_IS_NUMCOMPARE(op)	\
	((op) >= OP_LT && (op) <= OP_I_NCMP)

#define OP_IS_DIRHOP(op)	\
	((op) >= OP_READDIR && (op) <= OP_CLOSEDIR)

#define OP_IS_INFIX_BIT(op)	\
	((op) >= OP_BIT_AND && (op) <= OP_SBIT_OR)

/* ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /* -*- buffer-read-only: t -*-
 *
 *    overload.h
 *
 *    Copyright (C) 1997, 1998, 2000, 2001, 2005, 2006, 2007, 2011
 *    by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/overload.pl.
 * Any changes made here will be lost!
 */

enum {
    fallback_amg,	/* 0x00 fallback */
    to_sv_amg,		/* 0x01 ${}      */
    to_av_amg,		/* 0x02 @{}      */
    to_hv_amg,		/* 0x03 %{}      */
    to_gv_amg,		/* 0x04 *{}      */
    to_cv_amg,		/* 0x05 &{}      */
    inc_amg,		/* 0x06 ++       */
    dec_amg,		/* 0x07 --       */
    bool__amg,		/* 0x08 bool     */
    numer_amg,		/* 0x09 0+       */
    string_amg,		/* 0x0a ""       */
    not_amg,		/* 0x0b !        */
    copy_amg,		/* 0x0c =        */
    abs_amg,		/* 0x0d abs      */
    neg_amg,		/* 0x0e neg      */
    iter_amg,		/* 0x0f <>       */
    int_amg,		/* 0x10 int      */
    lt_amg,		/* 0x11 <        */
    le_amg,		/* 0x12 <=       */
    gt_amg,		/* 0x13 >        */
    ge_amg,		/* 0x14 >=       */
    eq_amg,		/* 0x15 ==       */
    ne_amg,		/* 0x16 !=       */
    slt_amg,		/* 0x17 lt       */
    sle_amg,		/* 0x18 le       */
    sgt_amg,		/* 0x19 gt       */
    sge_amg,		/* 0x1a ge       */
    seq_amg,		/* 0x1b eq       */
    sne_amg,		/* 0x1c ne       */
    nomethod_amg,	/* 0x1d nomethod */
    add_amg,		/* 0x1e +        */
    add_ass_amg,	/* 0x1f +=       */
    subtr_amg,		/* 0x20 -        */
    subtr_ass_amg,	/* 0x21 -=       */
    mult_amg,		/* 0x22 *        */
    mult_ass_amg,	/* 0x23 *=       */
    div_amg,		/* 0x24 /        */
    div_ass_amg,	/* 0x25 /=       */
    modulo_amg,		/* 0x26 %        */
    modulo_ass_amg,	/* 0x27 %=       */
    pow_amg,		/* 0x28 **       */
    pow_ass_amg,	/* 0x29 **=      */
    lshift_amg,		/* 0x2a <<       */
    lshift_ass_amg,	/* 0x2b <<=      */
    rshift_amg,		/* 0x2c >>       */
    rshift_ass_amg,	/* 0x2d >>=      */
    band_amg,		/* 0x2e &        */
    band_ass_amg,	/* 0x2f &=       */
    sband_amg,		/* 0x30 &.       */
    sband_ass_amg,	/* 0x31 &.=      */
    bor_amg,		/* 0x32 |        */
    bor_ass_amg,	/* 0x33 |=       */
    sbor_amg,		/* 0x34 |.       */
    sbor_ass_amg,	/* 0x35 |.=      */
    bxor_amg,		/* 0x36 ^        */
    bxor_ass_amg,	/* 0x37 ^=       */
    sbxor_amg,		/* 0x38 ^.       */
    sbxor_ass_amg,	/* 0x39 ^.=      */
    ncmp_amg,		/* 0x3a <=>      */
    scmp_amg,		/* 0x3b cmp      */
    compl_amg,		/* 0x3c ~        */
    scompl_amg,		/* 0x3d ~.       */
    atan2_amg,		/* 0x3e atan2    */
    cos_amg,		/* 0x3f cos      */
    sin_amg,		/* 0x40 sin      */
    exp_amg,		/* 0x41 exp      */
    log_amg,		/* 0x42 log      */
    sqrt_amg,		/* 0x43 sqrt     */
    repeat_amg,		/* 0x44 x        */
    repeat_ass_amg,	/* 0x45 x=       */
    concat_amg,		/* 0x46 .        */
    concat_ass_amg,	/* 0x47 .=       */
    smart_amg,		/* 0x48 ~~       */
    ftest_amg,		/* 0x49 -X       */
    regexp_amg,		/* 0x4a qr       */
    max_amg_code
    /* Do not leave a trailing comma here.  C9X allows it, C89 doesn't. */
};

#define NofAMmeth max_amg_code

/* ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /*    pad.h
 *
 *    Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
 *    2009, 2010, 2011 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * This file defines the types and macros associated with the API for
 * manipulating scratchpads, which are used by perl to store lexical
 * variables, op targets and constants.
 */

/* offsets within a pad */

typedef SSize_t PADOFFSET; /* signed so that -1 is a valid value */
#define NOT_IN_PAD ((PADOFFSET) -1)

/* B.xs expects the first members of these two structs to line up
   (xpadl_max with xpadnl_fill).
 */

struct padlist {
    SSize_t	xpadl_max;	/* max index for which array has space */
    union {
        PAD **	xpadlarr_alloc; /* Pointer to beginning of array of AVs.
                                   index 0 is a padnamelist *          */
        struct {
            PADNAMELIST * padnl;
            PAD * pad_1;        /* this slice of PAD * array always alloced */
            PAD * pad_2;        /* maybe unalloced */
        } * xpadlarr_dbg;       /* for use with a C debugger only */
    } xpadl_arr;
    U32		xpadl_id;	/* Semi-unique ID, shared between clones */
    U32		xpadl_outid;	/* ID of outer pad */
};

struct padnamelist {
    SSize_t	xpadnl_fill;	/* max index in use */
    PADNAME **	xpadnl_alloc;	/* pointer to beginning of array */
    SSize_t	xpadnl_max;	/* max index for which array has space */
    PADOFFSET	xpadnl_max_named; /* highest index with len > 0 */
    U32		xpadnl_refcnt;
};

/* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
   PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
   define one or the other.  */
#if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
#  error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
#endif

#if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
#  define PERL_PADNAME_MINIMAL
#endif

#define _PADNAME_BASE \
    char *	xpadn_pv;		\
    HV *	xpadn_ourstash;		\
    union {				\
        HV *	xpadn_typestash;	\
        CV *	xpadn_protocv;		\
    } xpadn_type_u;			\
    U32		xpadn_low;		\
    U32		xpadn_high;		\
    U32		xpadn_refcnt;		\
    int		xpadn_gen;		\
    U8		xpadn_len;		\
    U8		xpadn_flags

struct padname {
    _PADNAME_BASE;
};

struct padname_with_str {
#ifdef PERL_PADNAME_MINIMAL
    _PADNAME_BASE;
#else
    struct padname	xpadn_padname;
#endif
    char		xpadn_str[1];
};

#undef _PADNAME_BASE

#define PADNAME_FROM_PV(s) \
    ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))


/* a value that PL_cop_seqmax is guaranteed never to be,
 * flagging that a lexical is being introduced, or has not yet left scope
 */
#define PERL_PADSEQ_INTRO  U32_MAX
#define COP_SEQMAX_INC \
        (PL_cop_seqmax++, \
         (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))


/* B.xs needs these for the benefit of B::Deparse */
/* Low range end is exclusive (valid from the cop seq after this one) */
/* High range end is inclusive (valid up to this cop seq) */

#define COP_SEQ_RANGE_LOW(pn)		(pn)->xpadn_low
#define COP_SEQ_RANGE_HIGH(pn)		(pn)->xpadn_high
#define PARENT_PAD_INDEX(pn)		(pn)->xpadn_low
#define PARENT_FAKELEX_FLAGS(pn)	(pn)->xpadn_high

/* Flags set in the SvIVX field of FAKE namesvs */

#define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
#define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */

/* flags for the pad_new() function */

#define padnew_CLONE	1	/* this pad is for a cloned CV */
#define padnew_SAVE	2	/* save old globals */
#define padnew_SAVESUB	4	/* also save extra stuff for start of sub */

/* values for the pad_tidy() function */

typedef enum {
        padtidy_SUB,		/* tidy up a pad for a sub, */
        padtidy_SUBCLONE,	/* a cloned sub, */
        padtidy_FORMAT		/* or a format */
} padtidy_type;

/* flags for pad_add_name_pvn. */

#define padadd_OUR		0x01	   /* our declaration. */
#define padadd_STATE		0x02	   /* state declaration. */
#define padadd_NO_DUP_CHECK	0x04	   /* skip warning on dups. */
#define padadd_STALEOK		0x08	   /* allow stale lexical in active
                                            * sub, but only one level up */

/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
 * whether PL_comppad and PL_curpad are consistent and whether they have
 * active values */

#  define pad_peg(label)

#ifdef DEBUGGING
#  define ASSERT_CURPAD_LEGAL(label) \
    pad_peg(label); \
    if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0))  \
        Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
            label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));


#  define ASSERT_CURPAD_ACTIVE(label) \
    pad_peg(label); \
    if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad))		  \
        Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
            label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
#else
#  define ASSERT_CURPAD_LEGAL(label)
#  define ASSERT_CURPAD_ACTIVE(label)
#endif



/* Note: the following three macros are actually defined in scope.h, but
 * they are documented here for completeness, since they directly or
 * indirectly affect pads.

=for apidoc m|void|SAVEPADSV	|PADOFFSET po
Save a pad slot (used to restore after an iteration)

=cut

XXX DAPM it would make more sense to make the arg a PADOFFSET

=for apidoc m|void|SAVECLEARSV	|SV **svp
Clear the pointed to pad value on scope exit.  (i.e. the runtime action of
C<my>)

=for apidoc m|void|SAVECOMPPAD
save C<PL_comppad> and C<PL_curpad>


=for apidoc Amx|PAD **|PadlistARRAY|PADLIST * padlist
The C array of a padlist, containing the pads.  Only subscript it with
numbers >= 1, as the 0th entry is not guaranteed to remain usable.

=for apidoc Amx|SSize_t|PadlistMAX|PADLIST * padlist
The index of the last allocated space in the padlist.  Note that the last
pad may be in an earlier slot.  Any entries following it will be C<NULL> in
that case.

=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST * padlist
The names associated with pad entries.

=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST * padlist
The C array of pad names.

=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST * padlist
The index of the last pad name.

=for apidoc Amx|U32|PadlistREFCNT|PADLIST * padlist
The reference count of the padlist.  Currently this is always 1.

=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST * pnl
The C array of pad names.

=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST * pnl
The index of the last pad name.

=for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST * pnl
The reference count of the pad name list.

=for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST * pnl
Lowers the reference count of the pad name list.

=for apidoc Amx|SV **|PadARRAY|PAD * pad
The C array of pad entries.

=for apidoc Amx|SSize_t|PadMAX|PAD * pad
The index of the last pad entry.

=for apidoc Amx|char *|PadnamePV|PADNAME * pn
The name stored in the pad name struct.  This returns C<NULL> for a target
slot.

=for apidoc Amx|STRLEN|PadnameLEN|PADNAME * pn
The length of the name.

=for apidoc Amx|bool|PadnameUTF8|PADNAME * pn
Whether PadnamePV is in UTF-8.  Currently, this is always true.

=for apidoc Amx|SV *|PadnameSV|PADNAME * pn
Returns the pad name as a mortal SV.

=for apidoc m|bool|PadnameIsOUR|PADNAME * pn
Whether this is an "our" variable.

=for apidoc m|HV *|PadnameOURSTASH|PADNAME * pn
The stash in which this "our" variable was declared.

=for apidoc m|bool|PadnameOUTER|PADNAME * pn
Whether this entry belongs to an outer pad.  Entries for which this is true
are often referred to as 'fake'.

=for apidoc m|bool|PadnameIsSTATE|PADNAME * pn
Whether this is a "state" variable.

=for apidoc m|HV *|PadnameTYPE|PADNAME * pn
The stash associated with a typed lexical.  This returns the C<%Foo::> hash
for C<my Foo $bar>.

=for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME * pn
The reference count of the pad name.

=for apidoc Amx|void|PadnameREFCNT_dec|PADNAME * pn
Lowers the reference count of the pad name.


=for apidoc m|SV *|PAD_SETSV	|PADOFFSET po|SV* sv
Set the slot at offset C<po> in the current pad to C<sv>

=for apidoc m|SV *|PAD_SV	|PADOFFSET po
Get the value at offset C<po> in the current pad

=for apidoc m|SV *|PAD_SVl	|PADOFFSET po
Lightweight and lvalue version of C<PAD_SV>.
Get or set the value at offset C<po> in the current pad.
Unlike C<PAD_SV>, does not print diagnostics with -DX.
For internal use only.

=for apidoc m|SV *|PAD_BASE_SV	|PADLIST padlist|PADOFFSET po
Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist

=for apidoc m|void|PAD_SET_CUR	|PADLIST padlist|I32 n
Set the current pad to be pad C<n> in the padlist, saving
the previous current pad.  NB currently this macro expands to a string too
long for some compilers, so it's best to replace it with

    SAVECOMPPAD();
    PAD_SET_CUR_NOSAVE(padlist,n);


=for apidoc m|void|PAD_SET_CUR_NOSAVE	|PADLIST padlist|I32 n
like PAD_SET_CUR, but without the save

=for apidoc m|void|PAD_SAVE_SETNULLPAD
Save the current pad then set it to null.

=for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
Save the current pad to the local variable C<opad>, then make the
current pad equal to C<npad>

=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
Restore the old pad saved into the local variable C<opad> by C<PAD_SAVE_LOCAL()>

=cut
*/

#define PadlistARRAY(pl)	(pl)->xpadl_arr.xpadlarr_alloc
#define PadlistMAX(pl)		(pl)->xpadl_max
#define PadlistNAMES(pl)	*((PADNAMELIST **)PadlistARRAY(pl))
#define PadlistNAMESARRAY(pl)	PadnamelistARRAY(PadlistNAMES(pl))
#define PadlistNAMESMAX(pl)	PadnamelistMAX(PadlistNAMES(pl))
#define PadlistREFCNT(pl)	1	/* reserved for future use */

#define PadnamelistARRAY(pnl)		(pnl)->xpadnl_alloc
#define PadnamelistMAX(pnl)		(pnl)->xpadnl_fill
#define PadnamelistMAXNAMED(pnl)	(pnl)->xpadnl_max_named
#define PadnamelistREFCNT(pnl)		(pnl)->xpadnl_refcnt
#define PadnamelistREFCNT_dec(pnl)	Perl_padnamelist_free(aTHX_ pnl)

#define PadARRAY(pad)		AvARRAY(pad)
#define PadMAX(pad)		AvFILLp(pad)

#define PadnamePV(pn)		(pn)->xpadn_pv
#define PadnameLEN(pn)		(pn)->xpadn_len
#define PadnameUTF8(pn)		1
#define PadnameSV(pn) \
        newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
#define PadnameFLAGS(pn)	(pn)->xpadn_flags
#define PadnameIsOUR(pn)	(!!(pn)->xpadn_ourstash)
#define PadnameOURSTASH(pn)	(pn)->xpadn_ourstash
#define PadnameTYPE(pn)		(pn)->xpadn_type_u.xpadn_typestash
#define PadnamePROTOCV(pn)	(pn)->xpadn_type_u.xpadn_protocv
#define PadnameREFCNT(pn)	(pn)->xpadn_refcnt
#define PadnameREFCNT_dec(pn)	Perl_padname_free(aTHX_ pn)
#define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
#define PadnameTYPE_set(pn,s)	  (PadnameTYPE(pn) = (s))
#define PadnameOUTER(pn)	(PadnameFLAGS(pn) & PADNAMEt_OUTER)
#define PadnameIsSTATE(pn)	(PadnameFLAGS(pn) & PADNAMEt_STATE)
#define PadnameLVALUE(pn)	(PadnameFLAGS(pn) & PADNAMEt_LVALUE)

#define PadnameLVALUE_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_LVALUE)
#define PadnameIsSTATE_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_STATE)

#define PADNAMEt_OUTER	1	/* outer lexical var */
#define PADNAMEt_STATE	2	/* state var */
#define PADNAMEt_LVALUE	4	/* used as lvalue */
#define PADNAMEt_TYPED	8	/* for B; unused by core */
#define PADNAMEt_OUR	16	/* for B; unused by core */

/* backward compatibility */
#define SvPAD_STATE		PadnameIsSTATE
#define SvPAD_TYPED(pn)		(!!PadnameTYPE(pn))
#define SvPAD_OUR(pn)		(!!PadnameOURSTASH(pn))
#define SvPAD_STATE_on		PadnameIsSTATE_on
#define SvPAD_TYPED_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_TYPED)
#define SvPAD_OUR_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_OUR)
#define SvOURSTASH		PadnameOURSTASH
#define SvOURSTASH_set		PadnameOURSTASH_set
#define SVpad_STATE		PADNAMEt_STATE
#define SVpad_TYPED		PADNAMEt_TYPED
#define SVpad_OUR		PADNAMEt_OUR

#ifdef DEBUGGING
#  define PAD_SV(po)	   pad_sv(po)
#  define PAD_SETSV(po,sv) pad_setsv(po,sv)
#else
#  define PAD_SV(po)       (PL_curpad[po])
#  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
#endif

#define PAD_SVl(po)       (PL_curpad[po])

#define PAD_BASE_SV(padlist, po) \
        (PadlistARRAY(padlist)[1])					\
            ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
            : NULL;


#define PAD_SET_CUR_NOSAVE(padlist,nth) \
        PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]);	\
        PL_curpad = AvARRAY(PL_comppad);			\
        DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
              "Pad 0x%" UVxf "[0x%" UVxf "] set_cur    depth=%d\n",	\
              PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));


#define PAD_SET_CUR(padlist,nth) \
        SAVECOMPPAD();						\
        PAD_SET_CUR_NOSAVE(padlist,nth);


#define PAD_SAVE_SETNULLPAD()	SAVECOMPPAD(); \
        PL_comppad = NULL; PL_curpad = NULL;	\
        DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));

#define PAD_SAVE_LOCAL(opad,npad) \
        opad = PL_comppad;					\
        PL_comppad = (npad);					\
        PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;	\
        DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
              "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n",		\
              PTR2UV(PL_comppad), PTR2UV(PL_curpad)));

#define PAD_RESTORE_LOCAL(opad) \
        assert(!opad || !SvIS_FREED(opad));					\
        PL_comppad = opad;						\
        PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;	\
        DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
              "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n",	\
              PTR2UV(PL_comppad), PTR2UV(PL_curpad)));


/*
=for apidoc m|void|CX_CURPAD_SAVE|struct context
Save the current pad in the given context block structure.

=for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
Access the SV at offset C<po> in the saved current pad in the given
context block structure (can be used as an lvalue).

=cut
*/

#define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
#define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])


/*
=for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
Return the flags for the current compiling pad name
at offset C<po>.  Assumes a valid slot entry.

=for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
Return the name of the current compiling pad name
at offset C<po>.  Assumes a valid slot entry.

=for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
Return the type (stash) of the current compiling pad name at offset
C<po>.  Must be a valid name.  Returns null if not typed.

=for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
Return the stash associated with an C<our> variable.
Assumes the slot entry is a valid C<our> lexical.

=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
The generation number of the name at offset C<po> in the current
compiling pad (lvalue).

=for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
Sets the generation number of the name at offset C<po> in the current
ling pad (lvalue) to C<gen>.
=cut

*/

#define PAD_COMPNAME(po)	PAD_COMPNAME_SV(po)
#define PAD_COMPNAME_SV(po)	(PadnamelistARRAY(PL_comppad_name)[(po)])
#define PAD_COMPNAME_FLAGS(po)	PadnameFLAGS(PAD_COMPNAME(po))
#define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_PV(po)	PadnamePV(PAD_COMPNAME(po))

#define PAD_COMPNAME_TYPE(po)	PadnameTYPE(PAD_COMPNAME(po))

#define PAD_COMPNAME_OURSTASH(po) \
    (SvOURSTASH(PAD_COMPNAME_SV(po)))

#define PAD_COMPNAME_GEN(po) \
    ((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)

#define PAD_COMPNAME_GEN_set(po, gen) \
    (PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))


/*
=for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
Clone the state variables associated with running and compiling pads.

=cut
*/

/* NB - we set PL_comppad to null unless it points at a value that
 * has already been dup'ed, ie it points to part of an active padlist.
 * Otherwise PL_comppad ends up being a leaked scalar in code like
 * the following:
 *     threads->create(sub { threads->create(sub {...} ) } );
 * where the second thread dups the outer sub's comppad but not the
 * sub's CV or padlist. */

#define PAD_CLONE_VARS(proto_perl, param)				\
    PL_comppad			= av_dup(proto_perl->Icomppad, param);	\
    PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;		\
    PL_comppad_name		=					\
                  padnamelist_dup(proto_perl->Icomppad_name, param);	\
    PL_comppad_name_fill	= proto_perl->Icomppad_name_fill;	\
    PL_comppad_name_floor	= proto_perl->Icomppad_name_floor;	\
    PL_min_intro_pending	= proto_perl->Imin_intro_pending;	\
    PL_max_intro_pending	= proto_perl->Imax_intro_pending;	\
    PL_padix			= proto_perl->Ipadix;			\
    PL_padix_floor		= proto_perl->Ipadix_floor;		\
    PL_pad_reset_pending	= proto_perl->Ipad_reset_pending;	\
    PL_cop_seqmax		= proto_perl->Icop_seqmax;

/*
=for apidoc Am|PADOFFSET|pad_add_name_pvs|"name"|U32 flags|HV *typestash|HV *ourstash

Exactly like L</pad_add_name_pvn>, but takes a literal string
instead of a string/length pair.

=cut
*/

#define pad_add_name_pvs(name,flags,typestash,ourstash) \
    Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)

/*
=for apidoc Am|PADOFFSET|pad_findmy_pvs|"name"|U32 flags

Exactly like L</pad_findmy_pvn>, but takes a literal string
instead of a string/length pair.

=cut
*/

#define pad_findmy_pvs(name,flags) \
    Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /*    parser.h
 *
 *    Copyright (c) 2006, 2007, 2009, 2010, 2011 Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 * 
 * This file defines the layout of the parser object used by the parser
 * and lexer (perly.c, toke.c).
 */

#define YYEMPTY		(-2)

typedef struct {
    YYSTYPE val;    /* semantic value */
    short   state;
    I32     savestack_ix;	/* size of savestack at this state */
    CV	    *compcv; /* value of PL_compcv when this value was created */
#ifdef DEBUGGING
    const char  *name; /* token/rule name for -Dpv */
#endif
} yy_stack_frame;

/* Fields that need to be shared with (i.e., visible to) inner lex-
   ing scopes. */
typedef struct yy_lexshared {
    struct yy_lexshared	*ls_prev;
    SV			*ls_linestr;	/* mirrors PL_parser->linestr */
    char		*ls_bufptr;	/* mirrors PL_parser->bufptr */
    char		*re_eval_start;	/* start of "(?{..." text */
    SV			*re_eval_str;	/* "(?{...})" text */
} LEXSHARED;

typedef struct yy_parser {

    /* parser state */

    struct yy_parser *old_parser; /* previous value of PL_parser */
    YYSTYPE	    yylval;	/* value of lookahead symbol, set by yylex() */
    int		    yychar;	/* The lookahead symbol.  */

    /* Number of tokens to shift before error messages enabled.  */
    int		    yyerrstatus;

    yy_stack_frame  *stack;	/* base of stack */
    yy_stack_frame  *stack_max1;/* (top-1)th element of allocated stack */
    yy_stack_frame  *ps;	/* current stack frame */
    int		    yylen;	/* length of active reduction */

    /* lexer state */

    I32		lex_formbrack;	/* bracket count at outer format level */
    I32		lex_brackets;	/* square and curly bracket count */
    I32		lex_casemods;	/* casemod count */
    char	*lex_brackstack;/* what kind of brackets to pop */
    char	*lex_casestack;	/* what kind of case mods in effect */
    U8		lex_defer;	/* state after determined token */
    U8		lex_dojoin;	/* doing an array interpolation
                                   1 = @{...}  2 = ->@ */
    U8		expect;		/* how to interpret ambiguous tokens */
    bool	preambled;
    bool        sub_no_recover; /* can't recover from a sublex error */
    U8		sub_error_count; /* the number of errors before sublexing */
    OP		*lex_inpat;	/* in pattern $) and $| are special */
    OP		*lex_op;	/* extra info to pass back on op */
    SV		*lex_repl;	/* runtime replacement from s/// */
    U16		lex_inwhat;	/* what kind of quoting are we in */
    OPCODE	last_lop_op;	/* last named list or unary operator */
    I32		lex_starts;	/* how many interps done on level */
    SV		*lex_stuff;	/* runtime pattern from m// or s/// */
    I32		multi_start;	/* 1st line of multi-line string */
    I32		multi_end;	/* last line of multi-line string */
    UV		multi_open;	/* delimiter code point of said string */
    UV		multi_close;	/* delimiter code point of said string */
    bool        lex_re_reparsing; /* we're doing G_RE_REPARSING */
    U8		lex_super_state;/* lexer state to save */
    U16		lex_sub_inwhat;	/* "lex_inwhat" to use in sublex_push */
    I32		lex_allbrackets;/* (), [], {}, ?: bracket count */
    OP		*lex_sub_op;	/* current op in y/// or pattern */
    SV		*lex_sub_repl;	/* repl of s/// used in sublex_push */
    LEXSHARED	*lex_shared;
    SV		*linestr;	/* current chunk of src text */
    char	*bufptr;	/* carries the cursor (current parsing
                                   position) from one invocation of yylex
                                   to the next */
    char	*oldbufptr;	/* in yylex, beginning of current token */
    char	*oldoldbufptr;	/* in yylex, beginning of previous token */
    char	*bufend;	
    char	*linestart;	/* beginning of most recently read line */
    char	*last_uni;	/* position of last named-unary op */
    char	*last_lop;	/* position of last list operator */
    /* copline is used to pass a specific line number to newSTATEOP.  It
       is a one-time line number, as newSTATEOP invalidates it (sets it to
       NOLINE) after using it.  The purpose of this is to report line num-
       bers in multiline constructs using the number of the first line. */
    line_t	copline;
    U16		in_my;		/* we're compiling a "my"/"our" declaration */
    U8		lex_state;	/* next token is determined */
    U8		error_count;	/* how many compile errors so far, max 10 */
    HV		*in_my_stash;	/* declared class of this "my" declaration */
    PerlIO	*rsfp;		/* current source file pointer */
    AV		*rsfp_filters;	/* holds chain of active source filters */

    YYSTYPE	nextval[5];	/* value of next token, if any */
    I32		nexttype[5];	/* type of next token */
    U8		nexttoke;
    U8		form_lex_state;	/* remember lex_state when parsing fmt */
    U8		lex_fakeeof;	/* precedence at which to fake EOF */
    U8		lex_flags;
    COP		*saved_curcop;	/* the previous PL_curcop */
    char	tokenbuf[256];
    line_t	herelines;	/* number of lines in here-doc */
    line_t	preambling;	/* line # when processing $ENV{PERL5DB} */

    /* these are valid while parsing a subroutine signature */
    UV          sig_elems;      /* number of signature elements seen so far */
    UV          sig_optelems;   /* number of optional signature elems seen */
    char        sig_slurpy;     /* the sigil of the slurpy var (or null) */
    bool        sig_seen;       /* the currently parsing sub has a signature */

    bool        recheck_utf8_validity;

    PERL_BITFIELD16	in_pod:1;      /* lexer is within a =pod section */
    PERL_BITFIELD16	filtered:1;    /* source filters in evalbytes */
    PERL_BITFIELD16	saw_infix_sigil:1; /* saw & or * or % operator */
    PERL_BITFIELD16	parsed_sub:1;  /* last thing parsed was a sub */
} yy_parser;

/* flags for lexer API */
#define LEX_STUFF_UTF8		0x00000001
#define LEX_KEEP_PREVIOUS	0x00000002

#ifdef PERL_CORE
# define LEX_START_SAME_FILTER	0x00000001
# define LEX_IGNORE_UTF8_HINTS	0x00000002
# define LEX_EVALBYTES		0x00000004
# define LEX_START_COPIED	0x00000008
# define LEX_DONT_CLOSE_RSFP	0x00000010
# define LEX_START_FLAGS \
        (LEX_START_SAME_FILTER|LEX_START_COPIED \
        |LEX_IGNORE_UTF8_HINTS|LEX_EVALBYTES|LEX_DONT_CLOSE_RSFP)
#endif

/* flags for parser API */
#define PARSE_OPTIONAL          0x00000001

/* values for lex_fakeeof */
enum {
    LEX_FAKEEOF_NEVER,      /* don't fake EOF */
    LEX_FAKEEOF_CLOSING,    /* fake EOF at unmatched closing punctuation */
    LEX_FAKEEOF_NONEXPR,    /* ... and at token that can't be in expression */
    LEX_FAKEEOF_LOWLOGIC,   /* ... and at low-precedence logic operator */
    LEX_FAKEEOF_COMMA,      /* ... and at comma */
    LEX_FAKEEOF_ASSIGN,     /* ... and at assignment operator */
    LEX_FAKEEOF_IFELSE,     /* ... and at ?: operator */
    LEX_FAKEEOF_RANGE,      /* ... and at range operator */
    LEX_FAKEEOF_LOGIC,      /* ... and at logic operator */
    LEX_FAKEEOF_BITWISE,    /* ... and at bitwise operator */
    LEX_FAKEEOF_COMPARE,    /* ... and at comparison operator */
    LEX_FAKEEOF_MAX
};

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       	,"DEBPKG:debian/cpan_definstalldirs - Provide a sensible INSTALLDIRS default for modules installed from CPAN."
	,"DEBPKG:debian/db_file_ver - https://bugs.debian.org/340047 Remove overly restrictive DB_File version check."
	,"DEBPKG:debian/doc_info - Replace generic man(1) instructions with Debian-specific information."
	,"DEBPKG:debian/enc2xs_inc - https://bugs.debian.org/290336 Tweak enc2xs to follow symlinks and ignore missing @INC directories."
	,"DEBPKG:debian/errno_ver - https://bugs.debian.org/343351 Remove Errno version check due to upgrade problems with long-running processes."
	,"DEBPKG:debian/libperl_embed_doc - https://bugs.debian.org/186778 Note that libperl-dev package is required for embedded linking"
	,"DEBPKG:fixes/respect_umask - Respect umask during installation"
	,"DEBPKG:debian/writable_site_dirs - Set umask approproately for site install directories"
	,"DEBPKG:debian/extutils_set_libperl_path - EU:MM: set location of libperl.a under /usr/lib"
	,"DEBPKG:debian/no_packlist_perllocal - Don't install .packlist or perllocal.pod for perl or vendor"
	,"DEBPKG:debian/fakeroot - Postpone LD_LIBRARY_PATH evaluation to the binary targets."
	,"DEBPKG:debian/instmodsh_doc - Debian policy doesn't install .packlist files for core or vendor."
	,"DEBPKG:debian/ld_run_path - Remove standard libs from LD_RUN_PATH as per Debian policy."
	,"DEBPKG:debian/libnet_config_path - Set location of libnet.cfg to /etc/perl/Net as /usr may not be writable."
	,"DEBPKG:debian/perlivp - https://bugs.debian.org/510895 Make perlivp skip include directories in /usr/local"
	,"DEBPKG:debian/squelch-locale-warnings - https://bugs.debian.org/508764 Squelch locale warnings in Debian package maintainer scripts"
	,"DEBPKG:debian/patchlevel - https://bugs.debian.org/567489 List packaged patches for 5.36.0-7+deb12u3 in patchlevel.h"
	,"DEBPKG:fixes/document_makemaker_ccflags - https://bugs.debian.org/628522 [rt.cpan.org #68613] Document that CCFLAGS should include $Config{ccflags}"
	,"DEBPKG:debian/find_html2text - https://bugs.debian.org/640479 Configure CPAN::Distribution with correct name of html2text"
	,"DEBPKG:debian/perl5db-x-terminal-emulator.patch - https://bugs.debian.org/668490 Invoke x-terminal-emulator rather than xterm in perl5db.pl"
	,"DEBPKG:debian/cpan-missing-site-dirs - https://bugs.debian.org/688842 Fix CPAN::FirstTime defaults with nonexisting site dirs if a parent is writable"
	,"DEBPKG:fixes/memoize_storable_nstore - [rt.cpan.org #77790] https://bugs.debian.org/587650 Memoize::Storable: respect 'nstore' option not respected"
	,"DEBPKG:debian/makemaker-pasthru - https://bugs.debian.org/758471 Pass LD settings through to subdirectories"
	,"DEBPKG:debian/makemaker-manext - https://bugs.debian.org/247370 Make EU::MakeMaker honour MANnEXT settings in generated manpage headers"
	,"DEBPKG:debian/kfreebsd-softupdates - https://bugs.debian.org/796798 Work around Debian Bug#796798"
	,"DEBPKG:fixes/memoize-pod - [rt.cpan.org #89441] Fix POD errors in Memoize"
	,"DEBPKG:debian/hurd-softupdates - https://bugs.debian.org/822735 Fix t/op/stat.t failures on hurd"
	,"DEBPKG:fixes/math_complex_doc_great_circle - https://bugs.debian.org/697567 [rt.cpan.org #114104] Math::Trig: clarify definition of great_circle_midpoint"
	,"DEBPKG:fixes/math_complex_doc_see_also - https://bugs.debian.org/697568 [rt.cpan.org #114105] Math::Trig: add missing SEE ALSO"
	,"DEBPKG:fixes/math_complex_doc_angle_units - https://bugs.debian.org/731505 [rt.cpan.org #114106] Math::Trig: document angle units"
	,"DEBPKG:fixes/cpan_web_link - https://bugs.debian.org/367291 CPAN: Add link to main CPAN web site"
	,"DEBPKG:debian/hppa_op_optimize_workaround - https://bugs.debian.org/838613 Temporarily lower the optimization of op.c on hppa due to gcc-6 problems"
	,"DEBPKG:debian/installman-utf8 - https://bugs.debian.org/840211 Generate man pages with UTF-8 characters"
	,"DEBPKG:debian/hppa_opmini_optimize_workaround - https://bugs.debian.org/869122 Lower the optimization level of opmini.c on hppa"
	,"DEBPKG:debian/sh4_op_optimize_workaround - https://bugs.debian.org/869373 Also lower the optimization level of op.c and opmini.c on sh4"
	,"DEBPKG:debian/perldoc-pager - https://bugs.debian.org/870340 [rt.cpan.org #120229] Fix perldoc terminal escapes when sensible-pager is less"
	,"DEBPKG:debian/prune_libs - https://bugs.debian.org/128355 Prune the list of libraries wanted to what we actually need."
	,"DEBPKG:debian/mod_paths - Tweak @INC ordering for Debian"
	,"DEBPKG:debian/deprecate-with-apt - https://bugs.debian.org/747628 Point users to Debian packages of deprecated core modules"
	,"DEBPKG:debian/disable-stack-check - https://bugs.debian.org/902779 [GH #16607] Disable debugperl stack extension checks for binary compatibility with perl"
	,"DEBPKG:debian/perlbug-editor - https://bugs.debian.org/922609 Use \"editor\" as the default perlbug editor, as per Debian policy"
	,"DEBPKG:debian/eu-mm-perl-base - https://bugs.debian.org/962138 Suppress an ExtUtils::MakeMaker warning about our non-default @INC"
	,"DEBPKG:fixes/io_socket_ip_ipv6 - Disable getaddrinfo(3) AI_ADDRCONFIG for localhost and IPv4 numeric addresses"
	,"DEBPKG:debian/usrmerge-lib64 - https://bugs.debian.org/914128 Configure / libpth.U: Do not adjust glibpth when /usr/lib64 is present."
	,"DEBPKG:debian/usrmerge-realpath - https://bugs.debian.org/914128 Configure / libpth.U: use realpath --no-symlinks on Debian"
	,"DEBPKG:debian/configure-regen - https://bugs.debian.org/762638 Regenerate Configure et al. after probe unit changes"
	,"DEBPKG:fixes/x32-io-msg-skip - https://bugs.debian.org/922609 Skip io/msg.t on x32 due to broken System V message queues"
	,"DEBPKG:debian/hurd-eumm-workaround - https://bugs.debian.org/1018289 Work around a MakeMaker regression breaking GNU/Hurd hint files"
	,"DEBPKG:fixes/json-pp-warnings - https://bugs.debian.org/1019757 Call unimport first to silence warnings"
	,"DEBPKG:fixes/readline-stream-errors - [80c1f1e] [GH #6799] https://bugs.debian.org/1016369 only clear the stream error state in readline() for glob()"
	,"DEBPKG:fixes/readline-stream-errors-test - [0b60216] [GH #6799] https://bugs.debian.org/1016369 test that <> doesn't clear the stream error state"
	,"DEBPKG:fixes/lto-test-fix - [69b4fa3] [GH #20518] https://bugs.debian.org/1015579 skip checking categorization of libperl symbols for LTO builds"
	,"DEBPKG:fixes/CVE-2023-47038 - [7047915] https://bugs.debian.org/1056746 Fix read/write past buffer end: perl-security#140"
	,"DEBPKG:fixes/CVE-2024-56406 - CVE-2024-56406: Heap-buffer-overflow with tr//"
	,"DEBPKG:fixes/CVE-2023-31484 - https://bugs.debian.org/1035109 Add verify_SSL=>1 to HTTP::Tiny to verify https server identity"
	,"DEBPKG:fixes/CVE-2025-40909-metaconfig - https://bugs.debian.org/1098226 [GH #23010] Check for fdopendir"
	,"DEBPKG:fixes/CVE-2025-40909-1 - https://bugs.debian.org/1098226 [GH #23010] [84be063] CVE-2025-40909: Clone dirhandles without fchdir"
	,"DEBPKG:fixes/CVE-2025-40909-2 - https://bugs.debian.org/1098226 [GH #23010] [b088e97] Minor corrections to 1f9097b342e0e37d619dfab6ea82ea99611b30bf"
	,"DEBPKG:fixes/CVE-2025-40909-3 - https://bugs.debian.org/1098226 [GH #23010] [08dffa0] Use PerlLIO_dup_cloexec in Perl_dirp_dup to set O_CLOEXEC"
	,"DEBPKG:fixes/CVE-2025-40909-metaconfig-update - Update generated files for fdopendir"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /*    patchlevel.h
 *
 *    Copyright (C) 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
 *    2003, 2004, 2005, 2006, 2007, 2008, 2009, by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
=for apidoc AmDnU|U8|PERL_REVISION
The major number component of the perl interpreter currently being compiled or
executing.  This has been C<5> from 1993 into 2020.

Instead use one of the version comparison macros.  See C<L</PERL_VERSION_EQ>>.

=for apidoc AmDnU|U8|PERL_VERSION
The minor number component of the perl interpreter currently being compiled or
executing.  Between 1993 into 2020, this has ranged from 0 to 33.

Instead use one of the version comparison macros.  See C<L</PERL_VERSION_EQ>>.

=for apidoc AmDnU|U8|PERL_SUBVERSION
The micro number component of the perl interpreter currently being compiled or
executing.  In stable releases this gives the dot release number for
maintenance updates.  In development releases this gives a tag for a snapshot
of the status at various points in the development cycle.

Instead use one of the version comparison macros.  See C<L</PERL_VERSION_EQ>>.

=cut
*/

#ifndef __PATCHLEVEL_H_INCLUDED__

/* do not adjust the whitespace! Configure expects the numbers to be
 * exactly on the third column */

#define PERL_REVISION	5		/* age */
#define PERL_VERSION	36		/* epoch */
#define PERL_SUBVERSION	0		/* generation */

/* The following numbers describe the earliest compatible version of
   Perl ("compatibility" here being defined as sufficient binary/API
   compatibility to run XS code built with the older version).
   Normally this should not change across maintenance releases.

   Note that this only refers to an out-of-the-box build.  Many non-default
   options such as usemultiplicity tend to break binary compatibility
   more often.

   This is used by Configure et al to figure out
   PERL_INC_VERSION_LIST, which lists version libraries
   to include in @INC.  See INSTALL for how this works.

   Porting/bump-perl-version will automatically set these to the version of perl
   to be released for blead releases, and to 5.X.0 for maint releases. Manually
   changing them should not be necessary.
*/
#define PERL_API_REVISION	5
#define PERL_API_VERSION	36
#define PERL_API_SUBVERSION	0
/*
   XXX Note:  The selection of non-default Configure options, such
   as -Duselonglong may invalidate these settings.  Currently, Configure
   does not adequately test for this.   A.D.  Jan 13, 2000
*/

#define __PATCHLEVEL_H_INCLUDED__
#endif

/*
        local_patches -- list of locally applied less-than-subversion patches.
        If you're distributing such a patch, please give it a name and a
        one-line description, placed just before the last NULL in the array
        below.  If your patch fixes a bug in the perlbug database, please
        mention the bugid.  If your patch *IS* dependent on a prior patch,
        please place your applied patch line after its dependencies. This
        will help tracking of patch dependencies.

        Please either use 'diff --unified=0' if your diff supports
        that or edit the hunk of the diff output which adds your patch
        to this list, to remove context lines which would give patch
        problems. For instance, if the original context diff is

           *** patchlevel.h.orig	<date here>
           --- patchlevel.h	<date here>
           *** 38,43 ***
           --- 38,44 ---
                ,"FOO1235 - some patch"
                ,"BAR3141 - another patch"
                ,"BAZ2718 - and another patch"
           + 	,"MINE001 - my new patch"
                ,NULL
             };

        please change it to
           *** patchlevel.h.orig	<date here>
           --- patchlevel.h	<date here>
           *** 41,43 ***
           --- 41,44 ---
           + 	,"MINE001 - my new patch"
                ,NULL
             };

        (Note changes to line numbers as well as removal of context lines.)
        This will prevent patch from choking if someone has previously
        applied different patches than you.

        History has shown that nobody distributes patches that also
        modify patchlevel.h. Do it yourself. The following perl
        program can be used to add a comment to patchlevel.h:

#!perl
die "Usage: perl -x patchlevel.h comment ..." unless @ARGV;
open PLIN, "<", "patchlevel.h" or die "Couldn't open patchlevel.h : $!";
open PLOUT, ">", "patchlevel.new" or die "Couldn't write on patchlevel.new : $!";
my $seen=0;
while (<PLIN>) {
    if (/\t,NULL/ and $seen) {
       while (my $c = shift @ARGV){
            $c =~ s|\\|\\\\|g;
            $c =~ s|"|\\"|g;
            print PLOUT qq{\t,"$c"\n};
       }
    }
    $seen++ if /local_patches\[\]/;
    print PLOUT;
}
close PLOUT or die "Couldn't close filehandle writing to patchlevel.new : $!";
close PLIN or die "Couldn't close filehandle reading from patchlevel.h : $!";
close DATA; # needed to allow unlink to work win32.
unlink "patchlevel.bak" or warn "Couldn't unlink patchlevel.bak : $!"
  if -e "patchlevel.bak";
rename "patchlevel.h", "patchlevel.bak" or
  die "Couldn't rename patchlevel.h to patchlevel.bak : $!";
rename "patchlevel.new", "patchlevel.h" or
  die "Couldn't rename patchlevel.new to patchlevel.h : $!";
__END__

Please keep empty lines below so that context diffs of this file do
not ever collect the lines belonging to local_patches() into the same
hunk.

 */

#if !defined(PERL_PATCHLEVEL_H_IMPLICIT) && !defined(LOCAL_PATCH_COUNT)
#  if defined(PERL_IS_MINIPERL)
#    define PERL_PATCHNUM "UNKNOWN-miniperl"
#    define PERL_GIT_UNPUSHED_COMMITS /*leave-this-comment*/
#  elif defined(PERL_MICRO)
#    define PERL_PATCHNUM "UNKNOWN-microperl"
#    define PERL_GIT_UNPUSHED_COMMITS /*leave-this-comment*/
#  else
#include "git_version.h"
#  endif
static const char * const local_patches[] = {
        NULL
#ifdef PERL_GIT_UNCOMMITTED_CHANGES
        ,"uncommitted-changes"
#endif
        PERL_GIT_UNPUSHED_COMMITS    	/* do not remove this line */
#ifdef DEBIAN
#include "patchlevel-debian.h"
#endif
        ,NULL
};



/* Initial space prevents this variable from being inserted in config.sh  */
#  define	LOCAL_PATCH_COUNT	\
        ((int)(C_ARRAY_LENGTH(local_patches)-2))

/* the old terms of reference, add them only when explicitly included */
#define PATCHLEVEL		PERL_VERSION
#undef  SUBVERSION		/* OS/390 has a SUBVERSION in a system header */
#define SUBVERSION		PERL_SUBVERSION
#endif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* just define a list of macros to push elements in INC
*  so we can easily use them and change order on demand
*
* list of available INCPUSH macros
* - INCPUSH_APPLLIB_EXP
* - INCPUSH_SITEARCH_EXP
* - INCPUSH_SITELIB_EXP
* - INCPUSH_PERL_VENDORARCH_EXP
* - INCPUSH_PERL_VENDORLIB_EXP
* - INCPUSH_ARCHLIB_EXP
* - INCPUSH_PRIVLIB_EXP
* - INCPUSH_PERL_OTHERLIBDIRS
* - INCPUSH_PERL5LIB
* - INCPUSH_APPLLIB_OLD_EXP
* - INCPUSH_SITELIB_STEM
* - INCPUSH_PERL_VENDORLIB_STEM
* - INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
*/

#ifndef DEFINE_INC_MACROS

/* protect against multiple inclusions */
#define DEFINE_INC_MACROS 1

#ifdef APPLLIB_EXP
#	define INCPUSH_APPLLIB_EXP  S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
                      INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#endif

#ifdef SITEARCH_EXP
    /* sitearch is always relative to sitelib on Windows for
     * DLL-based path intuition to work correctly */
#  if !defined(WIN32)
#	define INCPUSH_SITEARCH_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITEARCH_EXP), \
                          INCPUSH_CAN_RELOCATE);
#  endif
#endif

#ifdef SITELIB_EXP
#  if defined(WIN32)
    /* this picks up sitearch as well */
#	  define INCPUSH_SITELIB_EXP s = PerlEnv_sitelib_path(PERL_FS_VERSION, &len); \
                if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#  else
#	  define INCPUSH_SITELIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_EXP), \
                INCPUSH_CAN_RELOCATE);
#  endif
#endif

#ifdef PERL_VENDORARCH_EXP
    /* vendorarch is always relative to vendorlib on Windows for
     * DLL-based path intuition to work correctly */
#  if !defined(WIN32)
#		define INCPUSH_PERL_VENDORARCH_EXP  S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORARCH_EXP), INCPUSH_CAN_RELOCATE);
#  endif
#endif

#ifdef PERL_VENDORLIB_EXP
#  if defined(WIN32)
    /* this picks up vendorarch as well */
#		define INCPUSH_PERL_VENDORLIB_EXP s = PerlEnv_vendorlib_path(PERL_FS_VERSION, &len); \
                        if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#  else
#		define INCPUSH_PERL_VENDORLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_EXP), INCPUSH_CAN_RELOCATE);
#  endif
#endif

#ifdef ARCHLIB_EXP
#	define INCPUSH_ARCHLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(ARCHLIB_EXP), INCPUSH_CAN_RELOCATE);
#endif

/* used by INCPUSH_PRIVLIB_EXP */
#ifndef PRIVLIB_EXP
#  define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
#endif

#if defined(WIN32)
#	define INCPUSH_PRIVLIB_EXP s = PerlEnv_lib_path(PERL_FS_VERSION, &len); \
    if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#else
#	define INCPUSH_PRIVLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PRIVLIB_EXP), INCPUSH_CAN_RELOCATE);
#endif

#ifdef PERL_OTHERLIBDIRS
#	define INCPUSH_PERL_OTHERLIBDIRS S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
                      INCPUSH_ADD_VERSIONED_SUB_DIRS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
#endif


/* submacros for INCPUSH_PERL5LIB */

#if defined(PERL_USE_SAFE_PUTENV) && ! defined(HAS_UNSETENV)
# 	define _INCPUSH_PERL5LIB_IF	if (perl5lib && *perl5lib != '\0')
#else
# 	define _INCPUSH_PERL5LIB_IF	if (perl5lib)
#endif

#ifndef VMS
/*
 * It isn't possible to delete an environment variable with
 * PERL_USE_SAFE_PUTENV set unless unsetenv() is also available, so in that
 * case we treat PERL5LIB as undefined if it has a zero-length value.
 */
# define _INCPUSH_PERL5LIB_ADD _INCPUSH_PERL5LIB_IF incpush_use_sep(perl5lib, 0, INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR);
#else
/* VMS */
        /* Treat PERL5?LIB as a possible search list logical name -- the
         * "natural" VMS idiom for a Unix path string.  We allow each
         * element to be a set of |-separated directories for compatibility.
         */
# define _INCPUSH_PERL5LIB_ADD char buf[256]; \
        int idx = 0; \
        if (vmstrnenv("PERL5LIB",buf,0,NULL,0)) \
            do { \
                incpush_use_sep(buf, 0, \
                                INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR); \
            } while (vmstrnenv("PERL5LIB",buf,++idx,NULL,0));
#endif

/* this macro is special and use submacros from above */
#define INCPUSH_PERL5LIB if (!TAINTING_get) { _INCPUSH_PERL5LIB_ADD }

/* Use the ~-expanded versions of APPLLIB (undocumented),
    SITELIB and VENDORLIB for older versions
*/
#ifdef APPLLIB_EXP
#	define INCPUSH_APPLLIB_OLD_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
            INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
#endif

#if defined(SITELIB_STEM) && defined(PERL_INC_VERSION_LIST)
    /* Search for version-specific dirs below here */
#	define INCPUSH_SITELIB_STEM   S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_STEM), \
                      INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
#endif


#if defined(PERL_VENDORLIB_STEM) && defined(PERL_INC_VERSION_LIST)
    /* Search for version-specific dirs below here */
#	define INCPUSH_PERL_VENDORLIB_STEM    S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_STEM), \
                      INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
#endif

#ifdef PERL_OTHERLIBDIRS
#	define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY  S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
                      INCPUSH_ADD_OLD_VERS|INCPUSH_ADD_ARCHONLY_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#endif


/* define all undefined macros... */
#ifndef INCPUSH_APPLLIB_EXP
#define INCPUSH_APPLLIB_EXP
#endif
#ifndef INCPUSH_SITEARCH_EXP
#define INCPUSH_SITEARCH_EXP
#endif
#ifndef INCPUSH_SITELIB_EXP
#define INCPUSH_SITELIB_EXP
#endif
#ifndef INCPUSH_PERL_VENDORARCH_EXP
#define INCPUSH_PERL_VENDORARCH_EXP
#endif
#ifndef INCPUSH_PERL_VENDORLIB_EXP
#define INCPUSH_PERL_VENDORLIB_EXP
#endif
#ifndef INCPUSH_ARCHLIB_EXP
#define INCPUSH_ARCHLIB_EXP
#endif
#ifndef INCPUSH_PRIVLIB_EXP
#define INCPUSH_PRIVLIB_EXP
#endif
#ifndef INCPUSH_PERL_OTHERLIBDIRS
#define INCPUSH_PERL_OTHERLIBDIRS
#endif
#ifndef INCPUSH_PERL5LIB
#define INCPUSH_PERL5LIB
#endif
#ifndef INCPUSH_APPLLIB_OLD_EXP
#define INCPUSH_APPLLIB_OLD_EXP
#endif
#ifndef INCPUSH_SITELIB_STEM
#define INCPUSH_SITELIB_STEM
#endif
#ifndef INCPUSH_PERL_VENDORLIB_STEM
#define INCPUSH_PERL_VENDORLIB_STEM
#endif
#ifndef INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
#define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
#endif

#endif /* DEFINE_INC_MACROS */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* Replaces <langinfo.h>, and allows our code to work on systems that don't
 * have that. */

#ifndef PERL_LANGINFO_H
#define PERL_LANGINFO_H 1

#include "config.h"

#if defined(HAS_NL_LANGINFO) && defined(I_LANGINFO)
#   include <langinfo.h>
#endif

/* NOTE that this file is parsed by ext/XS-APItest/t/locale.t, so be careful
 * with changes */

/* If foo doesn't exist define it to a negative number. */

#ifndef CODESET
#  define CODESET -1
#endif
#ifndef D_T_FMT
#  define D_T_FMT -2
#endif
#ifndef D_FMT
#  define D_FMT -3
#endif
#ifndef T_FMT
#  define T_FMT -4
#endif
#ifndef T_FMT_AMPM
#  define T_FMT_AMPM -5
#endif
#ifndef AM_STR
#  define AM_STR -6
#endif
#ifndef PM_STR
#  define PM_STR -7
#endif
#ifndef DAY_1
#  define DAY_1 -8
#endif
#ifndef DAY_2
#  define DAY_2 -9
#endif
#ifndef DAY_3
#  define DAY_3 -10
#endif
#ifndef DAY_4
#  define DAY_4 -11
#endif
#ifndef DAY_5
#  define DAY_5 -12
#endif
#ifndef DAY_6
#  define DAY_6 -13
#endif
#ifndef DAY_7
#  define DAY_7 -14
#endif
#ifndef ABDAY_1
#  define ABDAY_1 -15
#endif
#ifndef ABDAY_2
#  define ABDAY_2 -16
#endif
#ifndef ABDAY_3
#  define ABDAY_3 -17
#endif
#ifndef ABDAY_4
#  define ABDAY_4 -18
#endif
#ifndef ABDAY_5
#  define ABDAY_5 -19
#endif
#ifndef ABDAY_6
#  define ABDAY_6 -20
#endif
#ifndef ABDAY_7
#  define ABDAY_7 -21
#endif
#ifndef MON_1
#  define MON_1 -22
#endif
#ifndef MON_2
#  define MON_2 -23
#endif
#ifndef MON_3
#  define MON_3 -24
#endif
#ifndef MON_4
#  define MON_4 -25
#endif
#ifndef MON_5
#  define MON_5 -26
#endif
#ifndef MON_6
#  define MON_6 -27
#endif
#ifndef MON_7
#  define MON_7 -28
#endif
#ifndef MON_8
#  define MON_8 -29
#endif
#ifndef MON_9
#  define MON_9 -30
#endif
#ifndef MON_10
#  define MON_10 -31
#endif
#ifndef MON_11
#  define MON_11 -32
#endif
#ifndef MON_12
#  define MON_12 -33
#endif
#ifndef ABMON_1
#  define ABMON_1 -34
#endif
#ifndef ABMON_2
#  define ABMON_2 -35
#endif
#ifndef ABMON_3
#  define ABMON_3 -36
#endif
#ifndef ABMON_4
#  define ABMON_4 -37
#endif
#ifndef ABMON_5
#  define ABMON_5 -38
#endif
#ifndef ABMON_6
#  define ABMON_6 -39
#endif
#ifndef ABMON_7
#  define ABMON_7 -40
#endif
#ifndef ABMON_8
#  define ABMON_8 -41
#endif
#ifndef ABMON_9
#  define ABMON_9 -42
#endif
#ifndef ABMON_10
#  define ABMON_10 -43
#endif
#ifndef ABMON_11
#  define ABMON_11 -44
#endif
#ifndef ABMON_12
#  define ABMON_12 -45
#endif
#ifndef ERA
#  define ERA -46
#endif
#ifndef ERA_D_FMT
#  define ERA_D_FMT -47
#endif
#ifndef ERA_D_T_FMT
#  define ERA_D_T_FMT -48
#endif
#ifndef ERA_T_FMT
#  define ERA_T_FMT -49
#endif
#ifndef ALT_DIGITS
#  define ALT_DIGITS -50
#endif
#ifndef RADIXCHAR
#  define RADIXCHAR -51
#endif
#ifndef THOUSEP
#  define THOUSEP -52
#endif
#ifndef YESEXPR
#  define YESEXPR -53
#endif
#ifndef YESSTR
#  define YESSTR -54
#endif
#ifndef NOEXPR
#  define NOEXPR -55
#endif
#ifndef NOSTR
#  define NOSTR -56
#endif
#ifndef CRNCYSTR
#  define CRNCYSTR -57
#endif

#endif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /* This is SipHash by Jean-Philippe Aumasson and Daniel J. Bernstein.
 * The authors claim it is relatively secure compared to the alternatives
 * and that performance wise it is a suitable hash for languages like Perl.
 * See:
 *
 * https://www.131002.net/siphash/
 *
 * This implementation seems to perform slightly slower than one-at-a-time for
 * short keys, but degrades slower for longer keys. Murmur Hash outperforms it
 * regardless of keys size.
 *
 * It is 64 bit only.
 */

#ifdef CAN64BITHASH

#define SIPROUND            \
  STMT_START {              \
    v0 += v1; v1=ROTL64(v1,13); v1 ^= v0; v0=ROTL64(v0,32); \
    v2 += v3; v3=ROTL64(v3,16); v3 ^= v2;     \
    v0 += v3; v3=ROTL64(v3,21); v3 ^= v0;     \
    v2 += v1; v1=ROTL64(v1,17); v1 ^= v2; v2=ROTL64(v2,32); \
  } STMT_END

#define SIPHASH_SEED_STATE(key,v0,v1,v2,v3) \
do {                                    \
    v0 = v2 = U8TO64_LE(key + 0);       \
    v1 = v3 = U8TO64_LE(key + 8);       \
  /* "somepseudorandomlygeneratedbytes" */  \
    v0 ^= UINT64_C(0x736f6d6570736575);  \
    v1 ^= UINT64_C(0x646f72616e646f6d);      \
    v2 ^= UINT64_C(0x6c7967656e657261);      \
    v3 ^= UINT64_C(0x7465646279746573);      \
} while (0)

PERL_STATIC_INLINE
void S_perl_siphash_seed_state(const unsigned char * const seed_buf, unsigned char * state_buf) {
    U64 *v= (U64*) state_buf;
    SIPHASH_SEED_STATE(seed_buf, v[0],v[1],v[2],v[3]);
}

#define PERL_SIPHASH_FNC(FNC,SIP_ROUNDS,SIP_FINAL_ROUNDS) \
PERL_STATIC_INLINE U64 \
FNC ## _with_state_64 \
  (const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
{                                           \
  const int left = inlen & 7;               \
  const U8 *end = in + inlen - left;        \
                                            \
  U64 b = ( ( U64 )(inlen) ) << 56;         \
  U64 m;                                    \
  U64 v0 = U8TO64_LE(state);                \
  U64 v1 = U8TO64_LE(state+8);              \
  U64 v2 = U8TO64_LE(state+16);             \
  U64 v3 = U8TO64_LE(state+24);             \
                                            \
  for ( ; in != end; in += 8 )              \
  {                                         \
    m = U8TO64_LE( in );                    \
    v3 ^= m;                                \
                                            \
    SIP_ROUNDS;                             \
                                            \
    v0 ^= m;                                \
  }                                         \
                                            \
  switch( left )                            \
  {                                         \
  case 7: b |= ( ( U64 )in[ 6] )  << 48; /*FALLTHROUGH*/    \
  case 6: b |= ( ( U64 )in[ 5] )  << 40; /*FALLTHROUGH*/    \
  case 5: b |= ( ( U64 )in[ 4] )  << 32; /*FALLTHROUGH*/    \
  case 4: b |= ( ( U64 )in[ 3] )  << 24; /*FALLTHROUGH*/    \
  case 3: b |= ( ( U64 )in[ 2] )  << 16; /*FALLTHROUGH*/    \
  case 2: b |= ( ( U64 )in[ 1] )  <<  8; /*FALLTHROUGH*/    \
  case 1: b |= ( ( U64 )in[ 0] ); break;    \
  case 0: break;                            \
  }                                         \
                                            \
  v3 ^= b;                                  \
                                            \
  SIP_ROUNDS;                               \
                                            \
  v0 ^= b;                                  \
                                            \
  v2 ^= 0xff;                               \
                                            \
  SIP_FINAL_ROUNDS                          \
                                            \
  b = v0 ^ v1 ^ v2  ^ v3;                   \
  return b;                                 \
}                                           \
                                            \
PERL_STATIC_INLINE U32                      \
FNC ## _with_state                          \
  (const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
{                                           \
    union {                                 \
        U64 h64;                            \
        U32 h32[2];                         \
    } h;                                    \
    h.h64= FNC ## _with_state_64(state,in,inlen); \
    return h.h32[0] ^ h.h32[1];             \
}                                           \
                                            \
                                            \
PERL_STATIC_INLINE U32                      \
FNC (const unsigned char * const seed, const unsigned char *in, const STRLEN inlen) \
{                                                                   \
    U64 state[4];                                                   \
    SIPHASH_SEED_STATE(seed,state[0],state[1],state[2],state[3]);   \
    return FNC ## _with_state((U8*)state,in,inlen);                 \
}


PERL_SIPHASH_FNC(
    S_perl_hash_siphash_1_3
    ,SIPROUND;
    ,SIPROUND;SIPROUND;SIPROUND;
)

PERL_SIPHASH_FNC(
    S_perl_hash_siphash_2_4
    ,SIPROUND;SIPROUND;
    ,SIPROUND;SIPROUND;SIPROUND;SIPROUND;
)

#endif /* defined(CAN64BITHASH) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /*
 *
 *    perlapi.h
 *
 *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
 *    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
 * This file used to declare accessor functions for Perl variables
 * when PERL_GLOBAL_STRUCT was enabled, but that no longer exists.
 * This file is kept for backwards compatiblity with XS code that
 * might include it.
 */
#ifndef __perlapi_h__
#define __perlapi_h__

#endif /* __perlapi_h__ */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /*    perlio.h
 *
 *    Copyright (C) 1996, 1997, 1999, 2000, 2001, 2002, 2003,
 *    2004, 2005, 2006, 2007, by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

#ifndef PERLIO_H_
#define PERLIO_H_
/*
  Interface for perl to IO functions.
  There is a hierarchy of Configure determined #define controls:
   USE_STDIO   - No longer available via Configure.  Formerly forced
                 PerlIO_xxx() to be #define-d onto stdio functions.
                 Now generates compile-time error.

   USE_PERLIO  - The primary Configure variable that enables PerlIO.
                 PerlIO_xxx() are real functions
                 defined in perlio.c which implement extra functionality
                 required for utf8 support.

*/

#ifndef USE_PERLIO
# define USE_STDIO
#endif

#ifdef USE_STDIO
#  error "stdio is no longer supported as the default base layer -- use perlio."
#endif

/* --------------------  End of Configure controls ---------------------------- */

/*
 * Although we may not want stdio to be used including <stdio.h> here
 * avoids issues where stdio.h has strange side effects
 */
#include <stdio.h>

#if defined(USE_64_BIT_STDIO) && defined(HAS_FTELLO) && !defined(USE_FTELL64)
#define ftell ftello
#endif

#if defined(USE_64_BIT_STDIO) && defined(HAS_FSEEKO) && !defined(USE_FSEEK64)
#define fseek fseeko
#endif

/* BS2000 includes are sometimes a bit non standard :-( */
#if defined(POSIX_BC) && defined(O_BINARY) && !defined(O_TEXT)
#undef O_BINARY
#endif

#ifndef PerlIO
/* ----------- PerlIO implementation ---------- */
/* PerlIO not #define-d to something else - define the implementation */

typedef struct _PerlIO PerlIOl;
typedef struct _PerlIO_funcs PerlIO_funcs;
typedef PerlIOl *PerlIO;
#define PerlIO PerlIO
#define PERLIO_LAYERS 1

/*
=for apidoc_section $io
=for apidoc Amu||PERLIO_FUNCS_DECL|PerlIO * ftab
Declare C<ftab> to be a PerlIO function table, that is, of type
C<PerlIO_funcs>.

=for apidoc Ay|PerlIO_funcs *|PERLIO_FUNCS_CAST|PerlIO * func
Cast the pointer C<func> to be of type S<C<PerlIO_funcs *>>.

=cut
*/
#define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
#define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)

PERL_CALLCONV void PerlIO_define_layer(pTHX_ PerlIO_funcs *tab);
PERL_CALLCONV PerlIO_funcs *PerlIO_find_layer(pTHX_ const char *name,
                                              STRLEN len,
                                              int load);
PERL_CALLCONV PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab),
                                  const char *mode, SV *arg);
PERL_CALLCONV void PerlIO_pop(pTHX_ PerlIO *f);
PERL_CALLCONV AV* PerlIO_get_layers(pTHX_ PerlIO *f);
PERL_CALLCONV void PerlIO_clone(pTHX_ PerlInterpreter *proto,
                                CLONE_PARAMS *param);

#endif				/* PerlIO */

/* ----------- End of implementation choices  ---------- */

/* We now need to determine  what happens if source trys to use stdio.
 * There are three cases based on PERLIO_NOT_STDIO which XS code
 * can set how it wants.
 */

#ifdef PERL_CORE
/* Make a choice for perl core code
   - currently this is set to try and catch lingering raw stdio calls.
     This is a known issue with some non UNIX ports which still use
     "native" stdio features.
*/
#  ifndef PERLIO_NOT_STDIO
#    define PERLIO_NOT_STDIO 1
#  endif
#else
#  ifndef PERLIO_NOT_STDIO
#    define PERLIO_NOT_STDIO 0
#  endif
#endif

#ifdef PERLIO_NOT_STDIO
#if PERLIO_NOT_STDIO
/*
 * PERLIO_NOT_STDIO #define'd as 1
 * Case 1: Strong denial of stdio - make all stdio calls (we can think of) errors
 */
#include "nostdio.h"
#else				/* if PERLIO_NOT_STDIO */
/*
 * PERLIO_NOT_STDIO #define'd as 0
 * Case 2: Declares that both PerlIO and stdio can be used
 */
#endif				/* if PERLIO_NOT_STDIO */
#else				/* ifdef PERLIO_NOT_STDIO */
/*
 * PERLIO_NOT_STDIO not defined
 * Case 3: Try and fake stdio calls as PerlIO calls
 */
#include "fakesdio.h"
#endif				/* ifndef PERLIO_NOT_STDIO */

/* ----------- fill in things that have not got #define'd  ---------- */

#ifndef Fpos_t
#define Fpos_t Off_t
#endif

#ifndef EOF
#define EOF (-1)
#endif

/* This is to catch case with no stdio */
#ifndef BUFSIZ
#define BUFSIZ 1024
#endif

/* The default buffer size for the perlio buffering layer */
#ifndef PERLIOBUF_DEFAULT_BUFSIZ
#define PERLIOBUF_DEFAULT_BUFSIZ (BUFSIZ > 8192 ? BUFSIZ : 8192)
#endif

#ifndef SEEK_SET
#define SEEK_SET 0
#endif

#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif

#ifndef SEEK_END
#define SEEK_END 2
#endif

#define PERLIO_DUP_CLONE	1
#define PERLIO_DUP_FD		2

/* --------------------- Now prototypes for functions --------------- */

START_EXTERN_C
#ifndef __attribute__format__
#  ifdef HASATTRIBUTE_FORMAT
#    define __attribute__format__(x,y,z) __attribute__((format(x,y,z)))
#  else
#    define __attribute__format__(x,y,z)
#  endif
#endif
#ifndef PerlIO_init
PERL_CALLCONV void PerlIO_init(pTHX);
#endif
#ifndef PerlIO_stdoutf
PERL_CALLCONV int PerlIO_stdoutf(const char *, ...)
    __attribute__format__(__printf__, 1, 2);
#endif
#ifndef PerlIO_puts
PERL_CALLCONV int PerlIO_puts(PerlIO *, const char *);
#endif
#ifndef PerlIO_open
PERL_CALLCONV PerlIO *PerlIO_open(const char *, const char *);
#endif
#ifndef PerlIO_openn
PERL_CALLCONV PerlIO *PerlIO_openn(pTHX_ const char *layers, const char *mode,
                                   int fd, int imode, int perm, PerlIO *old,
                                   int narg, SV **arg);
#endif
#ifndef PerlIO_eof
PERL_CALLCONV int PerlIO_eof(PerlIO *);
#endif
#ifndef PerlIO_error
PERL_CALLCONV int PerlIO_error(PerlIO *);
#endif
#ifndef PerlIO_clearerr
PERL_CALLCONV void PerlIO_clearerr(PerlIO *);
#endif
#ifndef PerlIO_getc
PERL_CALLCONV int PerlIO_getc(PerlIO *);
#endif
#ifndef PerlIO_putc
PERL_CALLCONV int PerlIO_putc(PerlIO *, int);
#endif
#ifndef PerlIO_ungetc
PERL_CALLCONV int PerlIO_ungetc(PerlIO *, int);
#endif
#ifndef PerlIO_fdopen
PERL_CALLCONV PerlIO *PerlIO_fdopen(int, const char *);
#endif
#ifndef PerlIO_importFILE
PERL_CALLCONV PerlIO *PerlIO_importFILE(FILE *, const char *);
#endif
#ifndef PerlIO_exportFILE
PERL_CALLCONV FILE *PerlIO_exportFILE(PerlIO *, const char *);
#endif
#ifndef PerlIO_findFILE
PERL_CALLCONV FILE *PerlIO_findFILE(PerlIO *);
#endif
#ifndef PerlIO_releaseFILE
PERL_CALLCONV void PerlIO_releaseFILE(PerlIO *, FILE *);
#endif
#ifndef PerlIO_read
PERL_CALLCONV SSize_t PerlIO_read(PerlIO *, void *, Size_t);
#endif
#ifndef PerlIO_unread
PERL_CALLCONV SSize_t PerlIO_unread(PerlIO *, const void *, Size_t);
#endif
#ifndef PerlIO_write
PERL_CALLCONV SSize_t PerlIO_write(PerlIO *, const void *, Size_t);
#endif
#ifndef PerlIO_setlinebuf
PERL_CALLCONV void PerlIO_setlinebuf(PerlIO *);
#endif
#ifndef PerlIO_printf
PERL_CALLCONV int PerlIO_printf(PerlIO *, const char *, ...)
    __attribute__format__(__printf__, 2, 3);
#endif
#ifndef PerlIO_vprintf
PERL_CALLCONV int PerlIO_vprintf(PerlIO *, const char *, va_list);
#endif
#ifndef PerlIO_tell
PERL_CALLCONV Off_t PerlIO_tell(PerlIO *);
#endif
#ifndef PerlIO_seek
PERL_CALLCONV int PerlIO_seek(PerlIO *, Off_t, int);
#endif
#ifndef PerlIO_rewind
PERL_CALLCONV void PerlIO_rewind(PerlIO *);
#endif
#ifndef PerlIO_has_base
PERL_CALLCONV int PerlIO_has_base(PerlIO *);
#endif
#ifndef PerlIO_has_cntptr
PERL_CALLCONV int PerlIO_has_cntptr(PerlIO *);
#endif
#ifndef PerlIO_fast_gets
PERL_CALLCONV int PerlIO_fast_gets(PerlIO *);
#endif
#ifndef PerlIO_canset_cnt
PERL_CALLCONV int PerlIO_canset_cnt(PerlIO *);
#endif
#ifndef PerlIO_get_ptr
PERL_CALLCONV STDCHAR *PerlIO_get_ptr(PerlIO *);
#endif
#ifndef PerlIO_get_cnt
PERL_CALLCONV SSize_t PerlIO_get_cnt(PerlIO *);
#endif
#ifndef PerlIO_set_cnt
PERL_CALLCONV void PerlIO_set_cnt(PerlIO *, SSize_t);
#endif
#ifndef PerlIO_set_ptrcnt
PERL_CALLCONV void PerlIO_set_ptrcnt(PerlIO *, STDCHAR *, SSize_t);
#endif
#ifndef PerlIO_get_base
PERL_CALLCONV STDCHAR *PerlIO_get_base(PerlIO *);
#endif
#ifndef PerlIO_get_bufsiz
PERL_CALLCONV SSize_t PerlIO_get_bufsiz(PerlIO *);
#endif
#ifndef PerlIO_tmpfile
PERL_CALLCONV PerlIO *PerlIO_tmpfile(void);
#endif
#ifndef PerlIO_tmpfile_flags
PERL_CALLCONV PerlIO *PerlIO_tmpfile_flags(int flags);
#endif
#ifndef PerlIO_stdin
PERL_CALLCONV PerlIO *PerlIO_stdin(void);
#endif
#ifndef PerlIO_stdout
PERL_CALLCONV PerlIO *PerlIO_stdout(void);
#endif
#ifndef PerlIO_stderr
PERL_CALLCONV PerlIO *PerlIO_stderr(void);
#endif
#ifndef PerlIO_getpos
PERL_CALLCONV int PerlIO_getpos(PerlIO *, SV *);
#endif
#ifndef PerlIO_setpos
PERL_CALLCONV int PerlIO_setpos(PerlIO *, SV *);
#endif
#ifndef PerlIO_fdupopen
PERL_CALLCONV PerlIO *PerlIO_fdupopen(pTHX_ PerlIO *, CLONE_PARAMS *, int);
#endif
#if !defined(PerlIO_modestr)
PERL_CALLCONV char *PerlIO_modestr(PerlIO *, char *buf);
#endif
#ifndef PerlIO_isutf8
PERL_CALLCONV int PerlIO_isutf8(PerlIO *);
#endif
#ifndef PerlIO_apply_layers
PERL_CALLCONV int PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode,
                                      const char *names);
#endif
#ifndef PerlIO_binmode
PERL_CALLCONV int PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int omode,
                                 const char *names);
#endif
#ifndef PerlIO_getname
PERL_CALLCONV char *PerlIO_getname(PerlIO *, char *);
#endif

PERL_CALLCONV void PerlIO_destruct(pTHX);

PERL_CALLCONV int PerlIO_intmode2str(int rawmode, char *mode, int *writing);

#ifdef PERLIO_LAYERS
PERL_CALLCONV void PerlIO_cleanup(pTHX);

PERL_CALLCONV void PerlIO_debug(const char *fmt, ...)
    __attribute__format__(__printf__, 1, 2);
typedef struct PerlIO_list_s PerlIO_list_t;

#endif

END_EXTERN_C
#endif				/* PERLIO_H_ */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              #ifndef PERLIOL_H_
#define PERLIOL_H_

typedef struct {
    PerlIO_funcs *funcs;
    SV *arg;
} PerlIO_pair_t;

struct PerlIO_list_s {
    IV refcnt;
    IV cur;
    IV len;
    PerlIO_pair_t *array;
};

struct _PerlIO_funcs {
    Size_t fsize;
    const char *name;
    Size_t size;
    U32 kind;
    IV (*Pushed) (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
    IV (*Popped) (pTHX_ PerlIO *f);
    PerlIO *(*Open) (pTHX_ PerlIO_funcs *tab,
                     PerlIO_list_t *layers, IV n,
                     const char *mode,
                     int fd, int imode, int perm,
                     PerlIO *old, int narg, SV **args);
    IV (*Binmode)(pTHX_ PerlIO *f);
    SV *(*Getarg) (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags);
    IV (*Fileno) (pTHX_ PerlIO *f);
    PerlIO *(*Dup) (pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
    /* Unix-like functions - cf sfio line disciplines */
     SSize_t(*Read) (pTHX_ PerlIO *f, void *vbuf, Size_t count);
     SSize_t(*Unread) (pTHX_ PerlIO *f, const void *vbuf, Size_t count);
     SSize_t(*Write) (pTHX_ PerlIO *f, const void *vbuf, Size_t count);
    IV (*Seek) (pTHX_ PerlIO *f, Off_t offset, int whence);
     Off_t(*Tell) (pTHX_ PerlIO *f);
    IV (*Close) (pTHX_ PerlIO *f);
    /* Stdio-like buffered IO functions */
    IV (*Flush) (pTHX_ PerlIO *f);
    IV (*Fill) (pTHX_ PerlIO *f);
    IV (*Eof) (pTHX_ PerlIO *f);
    IV (*Error) (pTHX_ PerlIO *f);
    void (*Clearerr) (pTHX_ PerlIO *f);
    void (*Setlinebuf) (pTHX_ PerlIO *f);
    /* Perl's snooping functions */
    STDCHAR *(*Get_base) (pTHX_ PerlIO *f);
     Size_t(*Get_bufsiz) (pTHX_ PerlIO *f);
    STDCHAR *(*Get_ptr) (pTHX_ PerlIO *f);
     SSize_t(*Get_cnt) (pTHX_ PerlIO *f);
    void (*Set_ptrcnt) (pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
};

/*--------------------------------------------------------------------------------------*/
/* Kind values */
#define PERLIO_K_RAW		0x00000001
#define PERLIO_K_BUFFERED	0x00000002
#define PERLIO_K_CANCRLF	0x00000004
#define PERLIO_K_FASTGETS	0x00000008
#define PERLIO_K_DUMMY		0x00000010
#define PERLIO_K_UTF8		0x00008000
#define PERLIO_K_DESTRUCT	0x00010000
#define PERLIO_K_MULTIARG	0x00020000

/*--------------------------------------------------------------------------------------*/
struct _PerlIO {
    PerlIOl *next;		/* Lower layer */
    PerlIO_funcs *tab;		/* Functions for this layer */
    U32 flags;			/* Various flags for state */
    int err;			/* Saved errno value */
#ifdef VMS
    unsigned os_err;		/* Saved vaxc$errno value */
#elif defined (OS2)
    unsigned long os_err;
#elif defined (WIN32)
    DWORD os_err;		/* Saved GetLastError() value */
#endif
    PerlIOl *head;		/* our ultimate parent pointer */
};

/*--------------------------------------------------------------------------------------*/

/* Flag values */
#define PERLIO_F_EOF		0x00000100
#define PERLIO_F_CANWRITE	0x00000200
#define PERLIO_F_CANREAD	0x00000400
#define PERLIO_F_ERROR		0x00000800
#define PERLIO_F_TRUNCATE	0x00001000
#define PERLIO_F_APPEND		0x00002000
#define PERLIO_F_CRLF		0x00004000
#define PERLIO_F_UTF8		0x00008000
#define PERLIO_F_UNBUF		0x00010000
#define PERLIO_F_WRBUF		0x00020000
#define PERLIO_F_RDBUF		0x00040000
#define PERLIO_F_LINEBUF	0x00080000
#define PERLIO_F_TEMP		0x00100000
#define PERLIO_F_OPEN		0x00200000
#define PERLIO_F_FASTGETS	0x00400000
#define PERLIO_F_TTY		0x00800000
#define PERLIO_F_NOTREG         0x01000000   
#define PERLIO_F_CLEARED        0x02000000 /* layer cleared but not freed */

#define PerlIOBase(f)      (*(f))
#define PerlIOSelf(f,type) ((type *)PerlIOBase(f))
#define PerlIONext(f)      (&(PerlIOBase(f)->next))
#define PerlIOValid(f)     ((f) && *(f))

/*--------------------------------------------------------------------------------------*/
EXTCONST PerlIO_funcs PerlIO_unix;
EXTCONST PerlIO_funcs PerlIO_perlio;
EXTCONST PerlIO_funcs PerlIO_stdio;
EXTCONST PerlIO_funcs PerlIO_crlf;
EXTCONST PerlIO_funcs PerlIO_utf8;
EXTCONST PerlIO_funcs PerlIO_byte;
EXTCONST PerlIO_funcs PerlIO_raw;
EXTCONST PerlIO_funcs PerlIO_pending;
PERL_CALLCONV PerlIO *PerlIO_allocate(pTHX);
PERL_CALLCONV SV *PerlIO_arg_fetch(PerlIO_list_t *av, IV n);
#define PerlIOArg PerlIO_arg_fetch(layers,n)

#ifdef PERLIO_USING_CRLF
#define PERLIO_STDTEXT "t"
#else
#define PERLIO_STDTEXT ""
#endif

/*--------------------------------------------------------------------------------------*/
/* perlio buffer layer
   As this is reasonably generic its struct and "methods" are declared here
   so they can be used to "inherit" from it.
*/

typedef struct {
    struct _PerlIO base;	/* Base "class" info */
    STDCHAR *buf;		/* Start of buffer */
    STDCHAR *end;		/* End of valid part of buffer */
    STDCHAR *ptr;		/* Current position in buffer */
    Off_t posn;			/* Offset of buf into the file */
    Size_t bufsiz;		/* Real size of buffer */
    IV oneword;			/* Emergency buffer */
} PerlIOBuf;

PERL_CALLCONV int PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
                    PerlIO_list_t *layers, IV n, IV max);
PERL_CALLCONV int PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names);
PERL_CALLCONV PerlIO_funcs *PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def);


PERL_CALLCONV SV *PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param);
PERL_CALLCONV void PerlIO_cleantable(pTHX_ PerlIOl **tablep);
PERL_CALLCONV SV * PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab);
PERL_CALLCONV void PerlIO_default_buffer(pTHX_ PerlIO_list_t *av);
PERL_CALLCONV void PerlIO_stdstreams(pTHX);
PERL_CALLCONV int PerlIO__close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO_list_t * PerlIO_resolve_layers(pTHX_ const char *layers, const char *mode, int narg, SV **args);
PERL_CALLCONV PerlIO_funcs * PerlIO_default_layer(pTHX_ I32 n);
PERL_CALLCONV PerlIO_list_t * PerlIO_default_layers(pTHX);
PERL_CALLCONV PerlIO * PerlIO_reopen(const char *path, const char *mode, PerlIO *f);

PERL_CALLCONV PerlIO_list_t *PerlIO_list_alloc(pTHX);
PERL_CALLCONV PerlIO_list_t *PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param);
PERL_CALLCONV void PerlIO_list_free(pTHX_ PerlIO_list_t *list);
PERL_CALLCONV void PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg);
PERL_CALLCONV void PerlIO_list_free(pTHX_ PerlIO_list_t *list);

/* PerlIO_teardown doesn't need exporting, but the EXTERN_C is needed
 * for compiling as C++.  Must also match with what perl.h says. */
EXTERN_C void PerlIO_teardown(void);

/*--------------------------------------------------------------------------------------*/
/* Generic, or stub layer functions */

PERL_CALLCONV IV        PerlIOBase_binmode(pTHX_ PerlIO *f);
PERL_CALLCONV void      PerlIOBase_clearerr(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO *  PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV        PerlIOBase_eof(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_error(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_fileno(pTHX_ PerlIO *f);
PERL_CALLCONV void      PerlIOBase_flush_linebuf(pTHX);
PERL_CALLCONV IV        PerlIOBase_noop_fail(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_noop_ok(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_popped(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV PerlIO *  PerlIOBase_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args);
PERL_CALLCONV SSize_t   PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV void      PerlIOBase_setlinebuf(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);

/* Buf */
PERL_CALLCONV Size_t    PerlIOBuf_bufsiz(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBuf_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO *  PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV        PerlIOBuf_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBuf_flush(pTHX_ PerlIO *f);
PERL_CALLCONV STDCHAR * PerlIOBuf_get_base(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOBuf_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV STDCHAR * PerlIOBuf_get_ptr(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO *  PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args);
PERL_CALLCONV IV        PerlIOBuf_popped(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t   PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV        PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void      PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
PERL_CALLCONV Off_t     PerlIOBuf_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t   PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);

/* Crlf */
PERL_CALLCONV IV        PerlIOCrlf_binmode(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOCrlf_flush(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOCrlf_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV void      PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
PERL_CALLCONV SSize_t   PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t   PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);

/* Pending */
PERL_CALLCONV IV        PerlIOPending_close(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOPending_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOPending_flush(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t   PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV        PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void      PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);

/* Pop */
PERL_CALLCONV IV        PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);

/* Raw */
PERL_CALLCONV IV        PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);

/* Stdio */
PERL_CALLCONV void      PerlIOStdio_clearerr(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOStdio_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO *  PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV        PerlIOStdio_eof(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOStdio_error(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOStdio_fileno(pTHX_ PerlIO *f);
#ifdef USE_STDIO_PTR
PERL_CALLCONV STDCHAR * PerlIOStdio_get_ptr(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOStdio_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV void      PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
#endif
PERL_CALLCONV IV        PerlIOStdio_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV        PerlIOStdio_flush(pTHX_ PerlIO *f);
#ifdef FILE_base
PERL_CALLCONV STDCHAR * PerlIOStdio_get_base(pTHX_ PerlIO *f);
PERL_CALLCONV Size_t    PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f);
#endif
PERL_CALLCONV char *    PerlIOStdio_mode(const char *mode, char *tmode);
PERL_CALLCONV PerlIO *  PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args);
PERL_CALLCONV IV        PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t   PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV        PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void      PerlIOStdio_setlinebuf(pTHX_ PerlIO *f);
PERL_CALLCONV Off_t     PerlIOStdio_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t   PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);

/* Unix */
PERL_CALLCONV IV        PerlIOUnix_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO *  PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV        PerlIOUnix_fileno(pTHX_ PerlIO *f);
PERL_CALLCONV int       PerlIOUnix_oflags(const char *mode);
PERL_CALLCONV PerlIO *  PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args);
PERL_CALLCONV IV        PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t   PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV int       PerlIOUnix_refcnt_dec(int fd);
PERL_CALLCONV void      PerlIOUnix_refcnt_inc(int fd);
PERL_CALLCONV int       PerlIOUnix_refcnt(int fd);
PERL_CALLCONV IV        PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV Off_t     PerlIOUnix_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t   PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);

/* Utf8 */
PERL_CALLCONV IV        PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);

#endif				/* PERLIOL_H_ */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /*    perlsdio.h
 *
 *    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001,
 *    2002, 2003, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/* Shouldn't be possible to get here, but if we did ... */

#ifdef PERLIO_IS_STDIO

#  error "stdio is no longer supported as the default base layer -- use perlio."

#endif /* PERLIO_IS_STDIO */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /*    perlvars.h
 *
 *    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
 *    by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
=head1 Global Variables
These variables are global to an entire process.  They are shared between
all interpreters and all threads in a process.  Any variables not documented
here may be changed or removed without notice, so don't use them!
If you feel you really do need to use an unlisted variable, first send email to
L<perl5-porters@perl.org|mailto:perl5-porters@perl.org>.  It may be that
someone there will point out a way to accomplish what you need without using an
internal variable.  But if not, you should get a go-ahead to document and then
use the variable.

=cut
*/

/* Don't forget to re-run regen/embed.pl to propagate changes! */

/* This file describes the "global" variables used by perl
 * This used to be in perl.h directly but we want to abstract out into
 * distinct files which are per-thread, per-interpreter or really global,
 * and how they're initialized.
 *
 * The 'G' prefix is only needed for vars that need appropriate #defines
 * generated in embed*.h.  Such symbols are also used to generate
 * the appropriate export list for win32. */

/* global state */
#if defined(USE_ITHREADS)
PERLVAR(G, op_mutex,	perl_mutex)	/* Mutex for op refcounting */
#endif
PERLVARI(G, curinterp,	PerlInterpreter *, NULL)
                                        /* currently running interpreter
                                         * (initial parent interpreter under
                                         * useithreads) */
#if defined(USE_ITHREADS)
PERLVAR(G, thr_key,	perl_key)	/* key to retrieve per-thread struct */
#endif

/* XXX does anyone even use this? */
PERLVARI(G, do_undump,	bool,	FALSE)	/* -u or dump seen? */

#ifndef PERL_USE_SAFE_PUTENV
PERLVARI(G, use_safe_putenv, bool, TRUE)
#endif

#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
PERLVARI(G, sig_handlers_initted, int, 0)
#endif
#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
PERLVARA(G, sig_ignoring, SIG_SIZE, int)
                                        /* which signals we are ignoring */
#endif
#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
PERLVARA(G, sig_defaulting, SIG_SIZE, int)
#endif

/* XXX signals are process-wide anyway, so we
 * ignore the implications of this for threading */
#ifndef HAS_SIGACTION
PERLVARI(G, sig_trapped, int,	0)
#endif

#ifndef PERL_MICRO
/* If Perl has to ignore SIGPFE, this is its saved state.
 * See perl.h macros PERL_FPU_INIT and PERL_FPU_{PRE,POST}_EXEC. */
PERLVAR(G, sigfpe_saved, Sighandler_t)

/* these ptrs to functions are to avoid linkage problems; see
 * perl-5.8.0-2193-g5c1546dc48
 */
PERLVARI(G, csighandlerp,  Sighandler_t,  Perl_csighandler)
PERLVARI(G, csighandler1p, Sighandler1_t, Perl_csighandler1)
PERLVARI(G, csighandler3p, Sighandler3_t, Perl_csighandler3)
#endif

/* This is constant on most architectures, a global on OS/2 */
#ifdef OS2
PERLVARI(G, sh_path,	char *, SH_PATH) /* full path of shell */
#endif

#ifdef USE_PERLIO

#  if defined(USE_ITHREADS)
PERLVAR(G, perlio_mutex, perl_mutex)    /* Mutex for perlio fd refcounts */
#  endif

PERLVARI(G, perlio_fd_refcnt, int *, 0) /* Pointer to array of fd refcounts.  */
PERLVARI(G, perlio_fd_refcnt_size, int, 0) /* Size of the array */
PERLVARI(G, perlio_debug_fd, int, 0)	/* the fd to write perlio debug into, 0 means not set yet */
#endif

#ifdef HAS_MMAP
PERLVARI(G, mmap_page_size, IV, 0)
#endif

#if defined(USE_ITHREADS)
PERLVAR(G, hints_mutex, perl_mutex)    /* Mutex for refcounted he refcounting */
PERLVAR(G, env_mutex, perl_RnW1_mutex_t)      /* Mutex for accessing ENV */
PERLVAR(G, locale_mutex, perl_mutex)   /* Mutex related to locale handling */
#  ifndef USE_THREAD_SAFE_LOCALE
PERLVAR(G, lc_numeric_mutex, perl_mutex)   /* Mutex for switching LC_NUMERIC */
#  endif
#endif

#ifdef USE_POSIX_2008_LOCALE
PERLVAR(G, C_locale_obj, locale_t)
#endif

PERLVARI(G, watch_pvx,	char *, NULL)

/*
=for apidoc AmnU|Perl_check_t *|PL_check

Array, indexed by opcode, of functions that will be called for the "check"
phase of optree building during compilation of Perl code.  For most (but
not all) types of op, once the op has been initially built and populated
with child ops it will be filtered through the check function referenced
by the appropriate element of this array.  The new op is passed in as the
sole argument to the check function, and the check function returns the
completed op.  The check function may (as the name suggests) check the op
for validity and signal errors.  It may also initialise or modify parts of
the ops, or perform more radical surgery such as adding or removing child
ops, or even throw the op away and return a different op in its place.

This array of function pointers is a convenient place to hook into the
compilation process.  An XS module can put its own custom check function
in place of any of the standard ones, to influence the compilation of a
particular type of op.  However, a custom check function must never fully
replace a standard check function (or even a custom check function from
another module).  A module modifying checking must instead B<wrap> the
preexisting check function.  A custom check function must be selective
about when to apply its custom behaviour.  In the usual case where
it decides not to do anything special with an op, it must chain the
preexisting op function.  Check functions are thus linked in a chain,
with the core's base checker at the end.

For thread safety, modules should not write directly to this array.
Instead, use the function L</wrap_op_checker>.

=for apidoc Amn|enum perl_phase|PL_phase

A value that indicates the current Perl interpreter's phase. Possible values
include C<PERL_PHASE_CONSTRUCT>, C<PERL_PHASE_START>, C<PERL_PHASE_CHECK>,
C<PERL_PHASE_INIT>, C<PERL_PHASE_RUN>, C<PERL_PHASE_END>, and
C<PERL_PHASE_DESTRUCT>.

For example, the following determines whether the interpreter is in
global destruction:

    if (PL_phase == PERL_PHASE_DESTRUCT) {
        // we are in global destruction
    }

C<PL_phase> was introduced in Perl 5.14; in prior perls you can use
C<PL_dirty> (boolean) to determine whether the interpreter is in global
destruction. (Use of C<PL_dirty> is discouraged since 5.14.)

=cut
*/

#if defined(USE_ITHREADS)
PERLVAR(G, check_mutex,	perl_mutex)	/* Mutex for PL_check */
#endif

/* allocate a unique index to every module that calls MY_CXT_INIT */

#ifdef MULTIPLICITY
# ifdef USE_ITHREADS
PERLVAR(G, my_ctx_mutex, perl_mutex)
# endif
PERLVARI(G, my_cxt_index, int,	0)
#endif

/* this is currently set without MUTEX protection, so keep it a type which
 * can be set atomically (ie not a bit field) */
PERLVARI(G, veto_cleanup, int, FALSE)	/* exit without cleanup */

/*
=for apidoc AmnUx|Perl_keyword_plugin_t|PL_keyword_plugin

Function pointer, pointing at a function used to handle extended keywords.
The function should be declared as

        int keyword_plugin_function(pTHX_
                char *keyword_ptr, STRLEN keyword_len,
                OP **op_ptr)

The function is called from the tokeniser, whenever a possible keyword
is seen.  C<keyword_ptr> points at the word in the parser's input
buffer, and C<keyword_len> gives its length; it is not null-terminated.
The function is expected to examine the word, and possibly other state
such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it
as an extended keyword.  If it does not, the function should return
C<KEYWORD_PLUGIN_DECLINE>, and the normal parser process will continue.

If the function wants to handle the keyword, it first must
parse anything following the keyword that is part of the syntax
introduced by the keyword.  See L</Lexer interface> for details.

When a keyword is being handled, the plugin function must build
a tree of C<OP> structures, representing the code that was parsed.
The root of the tree must be stored in C<*op_ptr>.  The function then
returns a constant indicating the syntactic role of the construct that
it has parsed: C<KEYWORD_PLUGIN_STMT> if it is a complete statement, or
C<KEYWORD_PLUGIN_EXPR> if it is an expression.  Note that a statement
construct cannot be used inside an expression (except via C<do BLOCK>
and similar), and an expression is not a complete statement (it requires
at least a terminating semicolon).

When a keyword is handled, the plugin function may also have
(compile-time) side effects.  It may modify C<%^H>, define functions, and
so on.  Typically, if side effects are the main purpose of a handler,
it does not wish to generate any ops to be included in the normal
compilation.  In this case it is still required to supply an op tree,
but it suffices to generate a single null op.

That's how the C<*PL_keyword_plugin> function needs to behave overall.
Conventionally, however, one does not completely replace the existing
handler function.  Instead, take a copy of C<PL_keyword_plugin> before
assigning your own function pointer to it.  Your handler function should
look for keywords that it is interested in and handle those.  Where it
is not interested, it should call the saved plugin function, passing on
the arguments it received.  Thus C<PL_keyword_plugin> actually points
at a chain of handler functions, all of which have an opportunity to
handle keywords, and only the last function in the chain (built into
the Perl core) will normally return C<KEYWORD_PLUGIN_DECLINE>.

For thread safety, modules should not set this variable directly.
Instead, use the function L</wrap_keyword_plugin>.

=cut
*/

#if defined(USE_ITHREADS)
PERLVAR(G, keyword_plugin_mutex, perl_mutex)   /* Mutex for PL_keyword_plugin */
#endif
PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard)

PERLVARI(G, op_sequence, HV *, NULL)	/* dump.c */
PERLVARI(G, op_seq,	UV,	0)	/* dump.c */

#ifdef USE_ITHREADS
PERLVAR(G, dollarzero_mutex, perl_mutex) /* Modifying $0 */
#endif

/* Restricted hashes placeholder value.
   In theory, the contents are never used, only the address.
   In practice, &PL_sv_placeholder is returned by some APIs, and the calling
   code is checking SvOK().  */

PERLVAR(G, sv_placeholder, SV)

#if defined(MYMALLOC) && defined(USE_ITHREADS)
PERLVAR(G, malloc_mutex, perl_mutex)	/* Mutex for malloc */
#endif

PERLVARI(G, hash_seed_set, bool, FALSE)	/* perl.c */
PERLVARA(G, hash_seed_w, PERL_HASH_SEED_WORDS, __PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
#if defined(PERL_HASH_STATE_BYTES)
PERLVARA(G, hash_state_w, PERL_HASH_STATE_WORDS, __PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
#endif
#if defined(PERL_USE_SINGLE_CHAR_HASH_CACHE)
PERLVARA(G, hash_chars, (1+256) * sizeof(U32), unsigned char) /* perl.c and hv.h */
#endif

/* The path separator can vary depending on whether we're running under DCL or
 * a Unix shell.
 */
#ifdef __VMS
PERLVAR(G, perllib_sep, char)
#endif

/* Definitions of user-defined \p{} properties, as the subs that define them
 * are only called once */
PERLVARI(G, user_def_props,	HV *, NULL)

#if defined(USE_ITHREADS)
PERLVAR(G, user_def_props_aTHX, PerlInterpreter *)  /* aTHX that user_def_props
                                                       was defined in */
PERLVAR(G, user_prop_mutex, perl_mutex)    /* Mutex for manipulating
                                              PL_user_defined_properties */
#endif

/* these record the best way to perform certain IO operations while
 * atomically setting FD_CLOEXEC. On the first call, a probe is done
 * and the result recorded for use by subsequent calls.
 * In theory these variables aren't thread-safe, but the worst that can
 * happen is that two treads will both do an initial probe
 */
PERLVARI(G, strategy_dup,        int, 0)	/* doio.c */
PERLVARI(G, strategy_dup2,       int, 0)	/* doio.c */
PERLVARI(G, strategy_open,       int, 0)	/* doio.c */
PERLVARI(G, strategy_open3,      int, 0)	/* doio.c */
PERLVARI(G, strategy_mkstemp,    int, 0)	/* doio.c */
PERLVARI(G, strategy_socket,     int, 0)	/* doio.c */
PERLVARI(G, strategy_accept,     int, 0)	/* doio.c */
PERLVARI(G, strategy_pipe,       int, 0)	/* doio.c */
PERLVARI(G, strategy_socketpair, int, 0)	/* doio.c */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       /* -*- buffer-read-only: t -*-
   !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   This file is built by regen_perly.pl from perly.y.
   Any changes made here will be lost!
 */

#define PERL_BISON_VERSION  30006

#ifdef PERL_CORE
/* A Bison parser, made by GNU Bison 3.6.4.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
   especially those whose name start with YY_ or yy_.  They are
   private implementation details that can be changed or removed.  */

/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif

/* Token kinds.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    YYEMPTY = -2,
    YYEOF = 0,                     /* "end of file"  */
    YYerror = 256,                 /* error  */
    YYUNDEF = 257,                 /* "invalid token"  */
    GRAMPROG = 258,                /* GRAMPROG  */
    GRAMEXPR = 259,                /* GRAMEXPR  */
    GRAMBLOCK = 260,               /* GRAMBLOCK  */
    GRAMBARESTMT = 261,            /* GRAMBARESTMT  */
    GRAMFULLSTMT = 262,            /* GRAMFULLSTMT  */
    GRAMSTMTSEQ = 263,             /* GRAMSTMTSEQ  */
    GRAMSUBSIGNATURE = 264,        /* GRAMSUBSIGNATURE  */
    PERLY_AMPERSAND = 265,         /* PERLY_AMPERSAND  */
    PERLY_BRACE_OPEN = 266,        /* PERLY_BRACE_OPEN  */
    PERLY_BRACE_CLOSE = 267,       /* PERLY_BRACE_CLOSE  */
    PERLY_BRACKET_OPEN = 268,      /* PERLY_BRACKET_OPEN  */
    PERLY_BRACKET_CLOSE = 269,     /* PERLY_BRACKET_CLOSE  */
    PERLY_COMMA = 270,             /* PERLY_COMMA  */
    PERLY_DOLLAR = 271,            /* PERLY_DOLLAR  */
    PERLY_DOT = 272,               /* PERLY_DOT  */
    PERLY_EQUAL_SIGN = 273,        /* PERLY_EQUAL_SIGN  */
    PERLY_MINUS = 274,             /* PERLY_MINUS  */
    PERLY_PERCENT_SIGN = 275,      /* PERLY_PERCENT_SIGN  */
    PERLY_PLUS = 276,              /* PERLY_PLUS  */
    PERLY_SEMICOLON = 277,         /* PERLY_SEMICOLON  */
    PERLY_SLASH = 278,             /* PERLY_SLASH  */
    PERLY_SNAIL = 279,             /* PERLY_SNAIL  */
    PERLY_STAR = 280,              /* PERLY_STAR  */
    BAREWORD = 281,                /* BAREWORD  */
    METHOD = 282,                  /* METHOD  */
    FUNCMETH = 283,                /* FUNCMETH  */
    THING = 284,                   /* THING  */
    PMFUNC = 285,                  /* PMFUNC  */
    PRIVATEREF = 286,              /* PRIVATEREF  */
    QWLIST = 287,                  /* QWLIST  */
    FUNC0OP = 288,                 /* FUNC0OP  */
    FUNC0SUB = 289,                /* FUNC0SUB  */
    UNIOPSUB = 290,                /* UNIOPSUB  */
    LSTOPSUB = 291,                /* LSTOPSUB  */
    PLUGEXPR = 292,                /* PLUGEXPR  */
    PLUGSTMT = 293,                /* PLUGSTMT  */
    LABEL = 294,                   /* LABEL  */
    FORMAT = 295,                  /* FORMAT  */
    SUB = 296,                     /* SUB  */
    SIGSUB = 297,                  /* SIGSUB  */
    ANONSUB = 298,                 /* ANONSUB  */
    ANON_SIGSUB = 299,             /* ANON_SIGSUB  */
    PACKAGE = 300,                 /* PACKAGE  */
    USE = 301,                     /* USE  */
    WHILE = 302,                   /* WHILE  */
    UNTIL = 303,                   /* UNTIL  */
    IF = 304,                      /* IF  */
    UNLESS = 305,                  /* UNLESS  */
    ELSE = 306,                    /* ELSE  */
    ELSIF = 307,                   /* ELSIF  */
    CONTINUE = 308,                /* CONTINUE  */
    FOR = 309,                     /* FOR  */
    GIVEN = 310,                   /* GIVEN  */
    WHEN = 311,                    /* WHEN  */
    DEFAULT = 312,                 /* DEFAULT  */
    TRY = 313,                     /* TRY  */
    CATCH = 314,                   /* CATCH  */
    FINALLY = 315,                 /* FINALLY  */
    LOOPEX = 316,                  /* LOOPEX  */
    DOTDOT = 317,                  /* DOTDOT  */
    YADAYADA = 318,                /* YADAYADA  */
    FUNC0 = 319,                   /* FUNC0  */
    FUNC1 = 320,                   /* FUNC1  */
    FUNC = 321,                    /* FUNC  */
    UNIOP = 322,                   /* UNIOP  */
    LSTOP = 323,                   /* LSTOP  */
    MULOP = 324,                   /* MULOP  */
    ADDOP = 325,                   /* ADDOP  */
    DOLSHARP = 326,                /* DOLSHARP  */
    DO = 327,                      /* DO  */
    HASHBRACK = 328,               /* HASHBRACK  */
    NOAMP = 329,                   /* NOAMP  */
    LOCAL = 330,                   /* LOCAL  */
    MY = 331,                      /* MY  */
    REQUIRE = 332,                 /* REQUIRE  */
    COLONATTR = 333,               /* COLONATTR  */
    FORMLBRACK = 334,              /* FORMLBRACK  */
    FORMRBRACK = 335,              /* FORMRBRACK  */
    SUBLEXSTART = 336,             /* SUBLEXSTART  */
    SUBLEXEND = 337,               /* SUBLEXEND  */
    DEFER = 338,                   /* DEFER  */
    PREC_LOW = 339,                /* PREC_LOW  */
    OROP = 340,                    /* OROP  */
    ANDOP = 341,                   /* ANDOP  */
    NOTOP = 342,                   /* NOTOP  */
    ASSIGNOP = 343,                /* ASSIGNOP  */
    PERLY_QUESTION_MARK = 344,     /* PERLY_QUESTION_MARK  */
    PERLY_COLON = 345,             /* PERLY_COLON  */
    OROR = 346,                    /* OROR  */
    DORDOR = 347,                  /* DORDOR  */
    ANDAND = 348,                  /* ANDAND  */
    BITOROP = 349,                 /* BITOROP  */
    BITANDOP = 350,                /* BITANDOP  */
    CHEQOP = 351,                  /* CHEQOP  */
    NCEQOP = 352,                  /* NCEQOP  */
    CHRELOP = 353,                 /* CHRELOP  */
    NCRELOP = 354,                 /* NCRELOP  */
    SHIFTOP = 355,                 /* SHIFTOP  */
    MATCHOP = 356,                 /* MATCHOP  */
    PERLY_EXCLAMATION_MARK = 357,  /* PERLY_EXCLAMATION_MARK  */
    PERLY_TILDE = 358,             /* PERLY_TILDE  */
    UMINUS = 359,                  /* UMINUS  */
    REFGEN = 360,                  /* REFGEN  */
    POWOP = 361,                   /* POWOP  */
    PREINC = 362,                  /* PREINC  */
    PREDEC = 363,                  /* PREDEC  */
    POSTINC = 364,                 /* POSTINC  */
    POSTDEC = 365,                 /* POSTDEC  */
    POSTJOIN = 366,                /* POSTJOIN  */
    ARROW = 367,                   /* ARROW  */
    PERLY_PAREN_CLOSE = 368,       /* PERLY_PAREN_CLOSE  */
    PERLY_PAREN_OPEN = 369         /* PERLY_PAREN_OPEN  */
  };
  typedef enum yytokentype yytoken_kind_t;
#endif

/* Value type.  */
#ifdef PERL_IN_TOKE_C
static bool
S_is_opval_token(int type) {
    switch (type) {
    case BAREWORD:
    case FUNC0OP:
    case FUNC0SUB:
    case FUNCMETH:
    case LABEL:
    case LSTOPSUB:
    case METHOD:
    case PLUGEXPR:
    case PLUGSTMT:
    case PMFUNC:
    case PRIVATEREF:
    case QWLIST:
    case THING:
    case UNIOPSUB:
	return 1;
    }
    return 0;
}
#endif /* PERL_IN_TOKE_C */
#endif /* PERL_CORE */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

    I32	ival; /* __DEFAULT__ (marker for regen_perly.pl;
				must always be 1st union member) */
    char *pval;
    OP *opval;
    GV *gvval;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif



int yyparse (void);


/* Generated from:
 * 0caf1eb1cc4750131dc71e3a22ead383ed9a123dec61ccd23408ff13441fafde perly.y
 * acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
 * ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /*    pp.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
 *    2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

#define PP(s) OP * Perl_##s(pTHX)

/*
=for apidoc_section $stack

=for apidoc AmnU||SP
Stack pointer.  This is usually handled by C<xsubpp>.  See C<L</dSP>> and
C<SPAGAIN>.

=for apidoc AmnU||MARK
Stack marker variable for the XSUB.  See C<L</dMARK>>.

=for apidoc Am|void|PUSHMARK|SP
Opening bracket for arguments on a callback.  See C<L</PUTBACK>> and
L<perlcall>.

=for apidoc Amns||dSP
Declares a local copy of perl's stack pointer for the XSUB, available via
the C<SP> macro.  See C<L</SP>>.

=for apidoc ms||djSP

Declare Just C<SP>.  This is actually identical to C<dSP>, and declares
a local copy of perl's stack pointer, available via the C<SP> macro.
See C<L<perlapi/SP>>.  (Available for backward source code compatibility with
the old (Perl 5.005) thread model.)

=for apidoc Amns||dMARK
Declare a stack marker variable, C<mark>, for the XSUB.  See C<L</MARK>> and
C<L</dORIGMARK>>.

=for apidoc Amns||dORIGMARK
Saves the original stack mark for the XSUB.  See C<L</ORIGMARK>>.

=for apidoc AmnU||ORIGMARK
The original stack mark for the XSUB.  See C<L</dORIGMARK>>.

=for apidoc Amns||SPAGAIN
Refetch the stack pointer.  Used after a callback.  See L<perlcall>.

=cut */

#undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
#define SP sp
#define MARK mark

/*
=for apidoc Amns||TARG

C<TARG> is short for "target".  It is an entry in the pad that an OPs
C<op_targ> refers to.  It is scratchpad space, often used as a return
value for the OP, but some use it for other purposes.

=cut
*/
#define TARG targ

#define PUSHMARK(p) \
    STMT_START {                                                      \
        I32 * mark_stack_entry;                                       \
        if (UNLIKELY((mark_stack_entry = ++PL_markstack_ptr)          \
                                           == PL_markstack_max))      \
            mark_stack_entry = markstack_grow();                      \
        *mark_stack_entry  = (I32)((p) - PL_stack_base);              \
        DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,                 \
                "MARK push %p %" IVdf "\n",                           \
                PL_markstack_ptr, (IV)*mark_stack_entry)));           \
    } STMT_END

#define TOPMARK Perl_TOPMARK(aTHX)
#define POPMARK Perl_POPMARK(aTHX)

#define INCMARK \
    STMT_START {                                                      \
        DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,                 \
                "MARK inc  %p %" IVdf "\n",                           \
                (PL_markstack_ptr+1), (IV)*(PL_markstack_ptr+1))));   \
        PL_markstack_ptr++;                                           \
    } STMT_END

#define dSP		SV **sp = PL_stack_sp
#define djSP		dSP
#define dMARK		SV **mark = PL_stack_base + POPMARK
#define dORIGMARK	const I32 origmark = (I32)(mark - PL_stack_base)
#define ORIGMARK	(PL_stack_base + origmark)

#define SPAGAIN		sp = PL_stack_sp
#define MSPAGAIN	STMT_START { sp = PL_stack_sp; mark = ORIGMARK; } STMT_END

#define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
#define dTARGETSTACKED SV * GETTARGETSTACKED

#define GETTARGET targ = PAD_SV(PL_op->op_targ)

/*
=for apidoc Amns||dTARGET
Declare that this function uses C<TARG>

=cut
*/
#define dTARGET SV * GETTARGET

#define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
#define dATARGET SV * GETATARGET

#define dTARG SV *targ

#define NORMAL PL_op->op_next
#define DIE return Perl_die

/*
=for apidoc Amns||PUTBACK
Closing bracket for XSUB arguments.  This is usually handled by C<xsubpp>.
See C<L</PUSHMARK>> and L<perlcall> for other uses.

=for apidoc Amn|SV*|POPs
Pops an SV off the stack.

=for apidoc Amn|char*|POPp
Pops a string off the stack.

=for apidoc Amn|char*|POPpx
Pops a string off the stack.  Identical to POPp.  There are two names for
historical reasons.

=for apidoc Amn|char*|POPpbytex
Pops a string off the stack which must consist of bytes i.e. characters < 256.

=for apidoc Amn|NV|POPn
Pops a double off the stack.

=for apidoc Amn|IV|POPi
Pops an integer off the stack.

=for apidoc Amn|UV|POPu
Pops an unsigned integer off the stack.

=for apidoc Amn|long|POPl
Pops a long off the stack.

=for apidoc Amn|long|POPul
Pops an unsigned long off the stack.

=cut
*/

#define PUTBACK		PL_stack_sp = sp
#define RETURN		return (PUTBACK, NORMAL)
#define RETURNOP(o)	return (PUTBACK, o)
#define RETURNX(x)	return (x, PUTBACK, NORMAL)

#define POPs		(*sp--)
#define POPp		POPpx
#define POPpx		(SvPVx_nolen(POPs))
#define POPpconstx	(SvPVx_nolen_const(POPs))
#define POPpbytex	(SvPVbytex_nolen(POPs))
#define POPn		(SvNVx(POPs))
#define POPi		((IV)SvIVx(POPs))
#define POPu		((UV)SvUVx(POPs))
#define POPl		((long)SvIVx(POPs))
#define POPul		((unsigned long)SvIVx(POPs))

#define TOPs		(*sp)
#define TOPm1s		(*(sp-1))
#define TOPp1s		(*(sp+1))
#define TOPp		TOPpx
#define TOPpx		(SvPV_nolen(TOPs))
#define TOPn		(SvNV(TOPs))
#define TOPi		((IV)SvIV(TOPs))
#define TOPu		((UV)SvUV(TOPs))
#define TOPl		((long)SvIV(TOPs))
#define TOPul		((unsigned long)SvUV(TOPs))

/* Go to some pains in the rare event that we must extend the stack. */

/*
=for apidoc Am|void|EXTEND|SP|SSize_t nitems
Used to extend the argument stack for an XSUB's return values.  Once
used, guarantees that there is room for at least C<nitems> to be pushed
onto the stack.

=for apidoc Am|void|PUSHs|SV* sv
Push an SV onto the stack.  The stack must have room for this element.
Does not handle 'set' magic.  Does not use C<TARG>.  See also
C<L</PUSHmortal>>, C<L</XPUSHs>>, and C<L</XPUSHmortal>>.

=for apidoc Am|void|PUSHp|char* str|STRLEN len
Push a string onto the stack.  The stack must have room for this element.
The C<len> indicates the length of the string.  Handles 'set' magic.  Uses
C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not
call multiple C<TARG>-oriented macros to return lists from XSUB's - see
C<L</mPUSHp>> instead.  See also C<L</XPUSHp>> and C<L</mXPUSHp>>.

=for apidoc Am|void|PUSHn|NV nv
Push a double onto the stack.  The stack must have room for this element.
Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it.  Do not call multiple C<TARG>-oriented macros to
return lists from XSUB's - see C<L</mPUSHn>> instead.  See also C<L</XPUSHn>>
and C<L</mXPUSHn>>.

=for apidoc Am|void|PUSHi|IV iv
Push an integer onto the stack.  The stack must have room for this element.
Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it.  Do not call multiple C<TARG>-oriented macros to 
return lists from XSUB's - see C<L</mPUSHi>> instead.  See also C<L</XPUSHi>>
and C<L</mXPUSHi>>.

=for apidoc Am|void|PUSHu|UV uv
Push an unsigned integer onto the stack.  The stack must have room for this
element.  Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG>
should be called to declare it.  Do not call multiple C<TARG>-oriented
macros to return lists from XSUB's - see C<L</mPUSHu>> instead.  See also
C<L</XPUSHu>> and C<L</mXPUSHu>>.

=for apidoc Am|void|XPUSHs|SV* sv
Push an SV onto the stack, extending the stack if necessary.  Does not
handle 'set' magic.  Does not use C<TARG>.  See also C<L</XPUSHmortal>>,
C<PUSHs> and C<PUSHmortal>.

=for apidoc Am|void|XPUSHp|char* str|STRLEN len
Push a string onto the stack, extending the stack if necessary.  The C<len>
indicates the length of the string.  Handles 'set' magic.  Uses C<TARG>, so
C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not call
multiple C<TARG>-oriented macros to return lists from XSUB's - see
C<L</mXPUSHp>> instead.  See also C<L</PUSHp>> and C<L</mPUSHp>>.

=for apidoc Am|void|XPUSHn|NV nv
Push a double onto the stack, extending the stack if necessary.  Handles
'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
declare it.  Do not call multiple C<TARG>-oriented macros to return lists
from XSUB's - see C<L</mXPUSHn>> instead.  See also C<L</PUSHn>> and
C<L</mPUSHn>>.

=for apidoc Am|void|XPUSHi|IV iv
Push an integer onto the stack, extending the stack if necessary.  Handles
'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
declare it.  Do not call multiple C<TARG>-oriented macros to return lists
from XSUB's - see C<L</mXPUSHi>> instead.  See also C<L</PUSHi>> and
C<L</mPUSHi>>.

=for apidoc Am|void|XPUSHu|UV uv
Push an unsigned integer onto the stack, extending the stack if necessary.
Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it.  Do not call multiple C<TARG>-oriented macros to
return lists from XSUB's - see C<L</mXPUSHu>> instead.  See also C<L</PUSHu>> and
C<L</mPUSHu>>.

=for apidoc Am|void|mPUSHs|SV* sv
Push an SV onto the stack and mortalizes the SV.  The stack must have room
for this element.  Does not use C<TARG>.  See also C<L</PUSHs>> and
C<L</mXPUSHs>>.

=for apidoc Amn|void|PUSHmortal
Push a new mortal SV onto the stack.  The stack must have room for this
element.  Does not use C<TARG>.  See also C<L</PUSHs>>, C<L</XPUSHmortal>> and
C<L</XPUSHs>>.

=for apidoc Am|void|mPUSHp|char* str|STRLEN len
Push a string onto the stack.  The stack must have room for this element.
The C<len> indicates the length of the string.  Does not use C<TARG>.
See also C<L</PUSHp>>, C<L</mXPUSHp>> and C<L</XPUSHp>>.

=for apidoc Am|void|mPUSHn|NV nv
Push a double onto the stack.  The stack must have room for this element.
Does not use C<TARG>.  See also C<L</PUSHn>>, C<L</mXPUSHn>> and C<L</XPUSHn>>.

=for apidoc Am|void|mPUSHi|IV iv
Push an integer onto the stack.  The stack must have room for this element.
Does not use C<TARG>.  See also C<L</PUSHi>>, C<L</mXPUSHi>> and C<L</XPUSHi>>.

=for apidoc Am|void|mPUSHu|UV uv
Push an unsigned integer onto the stack.  The stack must have room for this
element.  Does not use C<TARG>.  See also C<L</PUSHu>>, C<L</mXPUSHu>> and
C<L</XPUSHu>>.

=for apidoc Am|void|mXPUSHs|SV* sv
Push an SV onto the stack, extending the stack if necessary and mortalizes
the SV.  Does not use C<TARG>.  See also C<L</XPUSHs>> and C<L</mPUSHs>>.

=for apidoc Amn|void|XPUSHmortal
Push a new mortal SV onto the stack, extending the stack if necessary.
Does not use C<TARG>.  See also C<L</XPUSHs>>, C<L</PUSHmortal>> and
C<L</PUSHs>>.

=for apidoc Am|void|mXPUSHp|char* str|STRLEN len
Push a string onto the stack, extending the stack if necessary.  The C<len>
indicates the length of the string.  Does not use C<TARG>.  See also
C<L</XPUSHp>>, C<mPUSHp> and C<PUSHp>.

=for apidoc Am|void|mXPUSHn|NV nv
Push a double onto the stack, extending the stack if necessary.
Does not use C<TARG>.  See also C<L</XPUSHn>>, C<L</mPUSHn>> and C<L</PUSHn>>.

=for apidoc Am|void|mXPUSHi|IV iv
Push an integer onto the stack, extending the stack if necessary.
Does not use C<TARG>.  See also C<L</XPUSHi>>, C<L</mPUSHi>> and C<L</PUSHi>>.

=for apidoc Am|void|mXPUSHu|UV uv
Push an unsigned integer onto the stack, extending the stack if necessary.
Does not use C<TARG>.  See also C<L</XPUSHu>>, C<L</mPUSHu>> and C<L</PUSHu>>.

=cut
*/

/* EXTEND_HWM_SET: note the high-water-mark to which the stack has been
 * requested to be extended (which is likely to be less than PL_stack_max)
 */
#if defined DEBUGGING && !defined DEBUGGING_RE_ONLY
#  define EXTEND_HWM_SET(p, n)                      \
        STMT_START {                                \
            SSize_t ix = (p) - PL_stack_base + (n); \
            if (ix > PL_curstackinfo->si_stack_hwm) \
                PL_curstackinfo->si_stack_hwm = ix; \
        } STMT_END
#else
#  define EXTEND_HWM_SET(p, n) NOOP
#endif

/* _EXTEND_SAFE_N(n): private helper macro for EXTEND().
 * Tests whether the value of n would be truncated when implicitly cast to
 * SSize_t as an arg to stack_grow(). If so, sets it to -1 instead to
 * trigger a panic. It will be constant folded on platforms where this
 * can't happen.
 */

#define _EXTEND_SAFE_N(n) \
        (sizeof(n) > sizeof(SSize_t) && ((SSize_t)(n) != (n)) ? -1 : (n))

#ifdef STRESS_REALLOC
# define EXTEND_SKIP(p, n) EXTEND_HWM_SET(p, n)

# define EXTEND(p,n)   STMT_START {                                     \
                           sp = stack_grow(sp,p,_EXTEND_SAFE_N(n));     \
                           PERL_UNUSED_VAR(sp);                         \
                       } STMT_END
/* Same thing, but update mark register too. */
# define MEXTEND(p,n)   STMT_START {                                    \
                            const SSize_t markoff = mark - PL_stack_base; \
                            sp = stack_grow(sp,p,_EXTEND_SAFE_N(n));    \
                            mark = PL_stack_base + markoff;             \
                            PERL_UNUSED_VAR(sp);                        \
                        } STMT_END
#else

/* _EXTEND_NEEDS_GROW(p,n): private helper macro for EXTEND().
 * Tests to see whether n is too big and we need to grow the stack. Be
 * very careful if modifying this. There are many ways to get things wrong
 * (wrapping, truncating etc) that could cause a false negative and cause
 * the call to stack_grow() to be skipped. On the other hand, false
 * positives are safe.
 * Bear in mind that sizeof(p) may be less than, equal to, or greater
 * than sizeof(n), and while n is documented to be signed, someone might
 * pass an unsigned value or expression. In general don't use casts to
 * avoid warnings; instead expect the caller to fix their code.
 * It is legal for p to be greater than PL_stack_max.
 * If the allocated stack is already very large but current usage is
 * small, then PL_stack_max - p might wrap round to a negative value, but
 * this just gives a safe false positive
 */

#  define _EXTEND_NEEDS_GROW(p,n) ((n) < 0 || PL_stack_max - (p) < (n))


/* EXTEND_SKIP(): used for where you would normally call EXTEND(), but
 * you know for sure that a previous op will have already extended the
 * stack sufficiently.  For example pp_enteriter ensures that there
 * is always at least 1 free slot, so pp_iter can return &PL_sv_yes/no
 * without checking each time. Calling EXTEND_SKIP() defeats the HWM
 * debugging mechanism which would otherwise whine
 */

#  define EXTEND_SKIP(p, n) STMT_START {                                \
                                EXTEND_HWM_SET(p, n);                   \
                                assert(!_EXTEND_NEEDS_GROW(p,n));       \
                          } STMT_END


#  define EXTEND(p,n)   STMT_START {                                    \
                         EXTEND_HWM_SET(p, n);                          \
                         if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) {       \
                           sp = stack_grow(sp,p,_EXTEND_SAFE_N(n));     \
                           PERL_UNUSED_VAR(sp);                         \
                         } } STMT_END
/* Same thing, but update mark register too. */
#  define MEXTEND(p,n)  STMT_START {                                    \
                         EXTEND_HWM_SET(p, n);                          \
                         if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) {       \
                           const SSize_t markoff = mark - PL_stack_base;\
                           sp = stack_grow(sp,p,_EXTEND_SAFE_N(n));     \
                           mark = PL_stack_base + markoff;              \
                           PERL_UNUSED_VAR(sp);                         \
                         } } STMT_END
#endif


/* set TARG to the IV value i. If do_taint is false,
 * assume that PL_tainted can never be true */
#define TARGi(i, do_taint) \
    STMT_START {                                                        \
        IV TARGi_iv = i;                                                \
        if (LIKELY(                                                     \
              ((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
            & (do_taint ? !TAINT_get : 1)))                             \
        {                                                               \
            /* Cheap SvIOK_only().                                      \
             * Assert that flags which SvIOK_only() would test or       \
             * clear can't be set, because we're SVt_IV */              \
            assert(!(SvFLAGS(TARG) &                                    \
                (SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK)))));     \
            SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK);                         \
            /* SvIV_set() where sv_any points to head */                \
            TARG->sv_u.svu_iv = TARGi_iv;                               \
        }                                                               \
        else                                                            \
            sv_setiv_mg(targ, TARGi_iv);                                \
    } STMT_END

/* set TARG to the UV value u. If do_taint is false,
 * assume that PL_tainted can never be true */
#define TARGu(u, do_taint) \
    STMT_START {                                                        \
        UV TARGu_uv = u;                                                \
        if (LIKELY(                                                     \
              ((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
            & (do_taint ? !TAINT_get : 1)                               \
            & (TARGu_uv <= (UV)IV_MAX)))                                \
        {                                                               \
            /* Cheap SvIOK_only().                                      \
             * Assert that flags which SvIOK_only() would test or       \
             * clear can't be set, because we're SVt_IV */              \
            assert(!(SvFLAGS(TARG) &                                    \
                (SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK)))));     \
            SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK);                         \
            /* SvIV_set() where sv_any points to head */                \
            TARG->sv_u.svu_iv = TARGu_uv;                               \
        }                                                               \
        else                                                            \
            sv_setuv_mg(targ, TARGu_uv);                                \
    } STMT_END

/* set TARG to the NV value n. If do_taint is false,
 * assume that PL_tainted can never be true */
#define TARGn(n, do_taint) \
    STMT_START {                                                        \
        NV TARGn_nv = n;                                                \
        if (LIKELY(                                                     \
              ((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST)) == SVt_NV) \
            & (do_taint ? !TAINT_get : 1)))                             \
        {                                                               \
            /* Cheap SvNOK_only().                                      \
             * Assert that flags which SvNOK_only() would test or       \
             * clear can't be set, because we're SVt_NV */              \
            assert(!(SvFLAGS(TARG) &                                    \
                (SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_NOK|SVp_NOK)))));     \
            SvFLAGS(TARG) |= (SVf_NOK|SVp_NOK);                         \
            SvNV_set(TARG, TARGn_nv);                                   \
        }                                                               \
        else                                                            \
            sv_setnv_mg(targ, TARGn_nv);                                \
    } STMT_END

#define PUSHs(s)	(*++sp = (s))
#define PUSHTARG	STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
#define PUSHp(p,l)	STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
#define PUSHn(n)	STMT_START { TARGn(n,1); PUSHs(TARG); } STMT_END
#define PUSHi(i)	STMT_START { TARGi(i,1); PUSHs(TARG); } STMT_END
#define PUSHu(u)	STMT_START { TARGu(u,1); PUSHs(TARG); } STMT_END

#define XPUSHs(s)	STMT_START { EXTEND(sp,1); *++sp = (s); } STMT_END
#define XPUSHTARG	STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
#define XPUSHp(p,l)	STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
#define XPUSHn(n)	STMT_START { TARGn(n,1); XPUSHs(TARG); } STMT_END
#define XPUSHi(i)	STMT_START { TARGi(i,1); XPUSHs(TARG); } STMT_END
#define XPUSHu(u)	STMT_START { TARGu(u,1); XPUSHs(TARG); } STMT_END
#define XPUSHundef	STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END

#define mPUSHs(s)	PUSHs(sv_2mortal(s))
#define PUSHmortal	PUSHs(sv_newmortal())
#define mPUSHp(p,l)	PUSHs(newSVpvn_flags((p), (l), SVs_TEMP))
#define mPUSHn(n)	sv_setnv(PUSHmortal, (NV)(n))
#define mPUSHi(i)	sv_setiv(PUSHmortal, (IV)(i))
#define mPUSHu(u)	sv_setuv(PUSHmortal, (UV)(u))

#define mXPUSHs(s)	XPUSHs(sv_2mortal(s))
#define XPUSHmortal	XPUSHs(sv_newmortal())
#define mXPUSHp(p,l)	STMT_START { EXTEND(sp,1); mPUSHp((p), (l)); } STMT_END
#define mXPUSHn(n)	STMT_START { EXTEND(sp,1); mPUSHn(n); } STMT_END
#define mXPUSHi(i)	STMT_START { EXTEND(sp,1); mPUSHi(i); } STMT_END
#define mXPUSHu(u)	STMT_START { EXTEND(sp,1); mPUSHu(u); } STMT_END

#define SETs(s)		(*sp = s)
#define SETTARG		STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
#define SETp(p,l)	STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
#define SETn(n)		STMT_START { TARGn(n,1); SETs(TARG); } STMT_END
#define SETi(i)		STMT_START { TARGi(i,1); SETs(TARG); } STMT_END
#define SETu(u)		STMT_START { TARGu(u,1); SETs(TARG); } STMT_END

#define dTOPss		SV *sv = TOPs
#define dPOPss		SV *sv = POPs
#define dTOPnv		NV value = TOPn
#define dPOPnv		NV value = POPn
#define dPOPnv_nomg	NV value = (sp--, SvNV_nomg(TOPp1s))
#define dTOPiv		IV value = TOPi
#define dPOPiv		IV value = POPi
#define dTOPuv		UV value = TOPu
#define dPOPuv		UV value = POPu

#define dPOPXssrl(X)	SV *right = POPs; SV *left = CAT2(X,s)
#define dPOPXnnrl(X)	NV right = POPn; NV left = CAT2(X,n)
#define dPOPXiirl(X)	IV right = POPi; IV left = CAT2(X,i)

#define USE_LEFT(sv) \
        (SvOK(sv) || !(PL_op->op_flags & OPf_STACKED))
#define dPOPXiirl_ul_nomg(X) \
    IV right = (sp--, SvIV_nomg(TOPp1s));		\
    SV *leftsv = CAT2(X,s);				\
    IV left = USE_LEFT(leftsv) ? SvIV_nomg(leftsv) : 0

#define dPOPPOPssrl	dPOPXssrl(POP)
#define dPOPPOPnnrl	dPOPXnnrl(POP)
#define dPOPPOPiirl	dPOPXiirl(POP)

#define dPOPTOPssrl	dPOPXssrl(TOP)
#define dPOPTOPnnrl	dPOPXnnrl(TOP)
#define dPOPTOPnnrl_nomg \
    NV right = SvNV_nomg(TOPs); NV left = (sp--, SvNV_nomg(TOPs))
#define dPOPTOPiirl	dPOPXiirl(TOP)
#define dPOPTOPiirl_ul_nomg dPOPXiirl_ul_nomg(TOP)
#define dPOPTOPiirl_nomg \
    IV right = SvIV_nomg(TOPs); IV left = (sp--, SvIV_nomg(TOPs))

#define RETPUSHYES	RETURNX(PUSHs(&PL_sv_yes))
#define RETPUSHNO	RETURNX(PUSHs(&PL_sv_no))
#define RETPUSHUNDEF	RETURNX(PUSHs(&PL_sv_undef))

#define RETSETYES	RETURNX(SETs(&PL_sv_yes))
#define RETSETNO	RETURNX(SETs(&PL_sv_no))
#define RETSETUNDEF	RETURNX(SETs(&PL_sv_undef))
#define RETSETTARG	STMT_START { SETTARG; RETURN; } STMT_END

#define ARGTARG		PL_op->op_targ

#define MAXARG		(PL_op->op_private & OPpARG4_MASK)

#define SWITCHSTACK(f,t) \
    STMT_START {							\
        AvFILLp(f) = sp - PL_stack_base;				\
        PL_stack_base = AvARRAY(t);					\
        PL_stack_max = PL_stack_base + AvMAX(t);			\
        sp = PL_stack_sp = PL_stack_base + AvFILLp(t);			\
        PL_curstack = t;						\
    } STMT_END

#define EXTEND_MORTAL(n) \
    STMT_START {						\
        SSize_t eMiX = PL_tmps_ix + (n);			\
        if (UNLIKELY(eMiX >= PL_tmps_max))			\
            (void)Perl_tmps_grow_p(aTHX_ eMiX);			\
    } STMT_END

#define AMGf_noright	1
#define AMGf_noleft	2
#define AMGf_assign	4       /* op supports mutator variant, e.g. $x += 1 */
#define AMGf_unary	8
#define AMGf_numeric	0x10	/* for Perl_try_amagic_bin */

#define AMGf_want_list	0x40
#define AMGf_numarg	0x80


/* do SvGETMAGIC on the stack args before checking for overload */

#define tryAMAGICun_MG(method, flags) STMT_START { \
        if ( UNLIKELY((SvFLAGS(TOPs) & (SVf_ROK|SVs_GMG))) \
                && Perl_try_amagic_un(aTHX_ method, flags)) \
            return NORMAL; \
    } STMT_END
#define tryAMAGICbin_MG(method, flags) STMT_START { \
        if ( UNLIKELY(((SvFLAGS(TOPm1s)|SvFLAGS(TOPs)) & (SVf_ROK|SVs_GMG))) \
                && Perl_try_amagic_bin(aTHX_ method, flags)) \
            return NORMAL; \
    } STMT_END

#define AMG_CALLunary(sv,meth) \
    amagic_call(sv,&PL_sv_undef, meth, AMGf_noright | AMGf_unary)

/* No longer used in core. Use AMG_CALLunary instead */
#define AMG_CALLun(sv,meth) AMG_CALLunary(sv, CAT2(meth,_amg))

#define tryAMAGICunTARGETlist(meth, jump)			\
    STMT_START {						\
        dSP;							\
        SV *tmpsv;						\
        SV *arg= *sp;						\
        U8 gimme = GIMME_V;                                    \
        if (UNLIKELY(SvAMAGIC(arg) &&				\
            (tmpsv = amagic_call(arg, &PL_sv_undef, meth,	\
                                 AMGf_want_list | AMGf_noright	\
                                |AMGf_unary))))                 \
        {                                       		\
            SPAGAIN;						\
            if (gimme == G_VOID) {                              \
                NOOP;                                           \
            }                                                   \
            else if (gimme == G_LIST) {				\
                SSize_t i;                                      \
                SSize_t len;                                    \
                assert(SvTYPE(tmpsv) == SVt_PVAV);              \
                len = av_count((AV *)tmpsv);                    \
                (void)POPs; /* get rid of the arg */            \
                EXTEND(sp, len);                                \
                for (i = 0; i < len; ++i)                       \
                    PUSHs(av_shift((AV *)tmpsv));               \
            }                                                   \
            else { /* AMGf_want_scalar */                       \
                dATARGET; /* just use the arg's location */     \
                sv_setsv(TARG, tmpsv);                          \
                if (PL_op->op_flags & OPf_STACKED)              \
                    sp--;                                       \
                SETTARG;                                        \
            }                                                   \
            PUTBACK;						\
            if (jump) {						\
                OP *jump_o = NORMAL->op_next;                   \
                while (jump_o->op_type == OP_NULL)		\
                    jump_o = jump_o->op_next;			\
                assert(jump_o->op_type == OP_ENTERSUB);		\
                (void)POPMARK;                                        \
                return jump_o->op_next;				\
            }							\
            return NORMAL;					\
        }							\
    } STMT_END

/* This is no longer used anywhere in the core. You might wish to consider
   calling amagic_deref_call() directly, as it has a cleaner interface.  */
#define tryAMAGICunDEREF(meth)						\
    STMT_START {							\
        sv = amagic_deref_call(*sp, CAT2(meth,_amg));			\
        SPAGAIN;							\
    } STMT_END


/* 2019: no longer used in core */
#define opASSIGN (PL_op->op_flags & OPf_STACKED)

/*
=for apidoc mnU||LVRET
True if this op will be the return value of an lvalue subroutine

=cut */
#define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub())

#define SvCANEXISTDELETE(sv) \
 (!SvRMAGICAL(sv)            \
  || !(mg = mg_find((const SV *) sv, PERL_MAGIC_tied))           \
  || (   (stash = SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(sv), mg)))) \
      && gv_fetchmethod_autoload(stash, "EXISTS", TRUE)          \
      && gv_fetchmethod_autoload(stash, "DELETE", TRUE)          \
     )                       \
  )

#ifdef PERL_CORE

/* These are just for Perl_tied_method(), which is not part of the public API.
   Use 0x04 rather than the next available bit, to help the compiler if the
   architecture can generate more efficient instructions.  */
#  define TIED_METHOD_MORTALIZE_NOT_NEEDED	0x04
#  define TIED_METHOD_ARGUMENTS_ON_STACK	0x08
#  define TIED_METHOD_SAY			0x10

/* Used in various places that need to dereference a glob or globref */
#  define MAYBE_DEREF_GV_flags(sv,phlags)                          \
    (                                                               \
        (void)(phlags & SV_GMAGIC && (SvGETMAGIC(sv),0)),            \
        isGV_with_GP(sv)                                              \
          ? (GV *)(sv)                                                \
          : SvROK(sv) && SvTYPE(SvRV(sv)) <= SVt_PVLV &&               \
            (SvGETMAGIC(SvRV(sv)), isGV_with_GP(SvRV(sv)))              \
             ? (GV *)SvRV(sv)                                            \
             : NULL                                                       \
    )
#  define MAYBE_DEREF_GV(sv)      MAYBE_DEREF_GV_flags(sv,SV_GMAGIC)
#  define MAYBE_DEREF_GV_nomg(sv) MAYBE_DEREF_GV_flags(sv,0)

#  define FIND_RUNCV_padid_eq	1
#  define FIND_RUNCV_level_eq	2

#endif

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /* -*- buffer-read-only: t -*-
   !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   This file is built by opcode.pl from its data.
   Any changes made here will be lost!
 */

PERL_CALLCONV OP *Perl_do_kv(pTHX);
PERL_CALLCONV OP *Perl_pp_aassign(pTHX);
PERL_CALLCONV OP *Perl_pp_abs(pTHX);
PERL_CALLCONV OP *Perl_pp_accept(pTHX);
PERL_CALLCONV OP *Perl_pp_add(pTHX);
PERL_CALLCONV OP *Perl_pp_aeach(pTHX);
PERL_CALLCONV OP *Perl_pp_aelem(pTHX);
PERL_CALLCONV OP *Perl_pp_aelemfast(pTHX);
PERL_CALLCONV OP *Perl_pp_akeys(pTHX);
PERL_CALLCONV OP *Perl_pp_alarm(pTHX);
PERL_CALLCONV OP *Perl_pp_and(pTHX);
PERL_CALLCONV OP *Perl_pp_anoncode(pTHX);
PERL_CALLCONV OP *Perl_pp_anonconst(pTHX);
PERL_CALLCONV OP *Perl_pp_anonhash(pTHX);
PERL_CALLCONV OP *Perl_pp_anonlist(pTHX);
PERL_CALLCONV OP *Perl_pp_argcheck(pTHX);
PERL_CALLCONV OP *Perl_pp_argdefelem(pTHX);
PERL_CALLCONV OP *Perl_pp_argelem(pTHX);
PERL_CALLCONV OP *Perl_pp_aslice(pTHX);
PERL_CALLCONV OP *Perl_pp_atan2(pTHX);
PERL_CALLCONV OP *Perl_pp_av2arylen(pTHX);
PERL_CALLCONV OP *Perl_pp_avhvswitch(pTHX);
PERL_CALLCONV OP *Perl_pp_backtick(pTHX);
PERL_CALLCONV OP *Perl_pp_bind(pTHX);
PERL_CALLCONV OP *Perl_pp_binmode(pTHX);
PERL_CALLCONV OP *Perl_pp_bit_and(pTHX);
PERL_CALLCONV OP *Perl_pp_bit_or(pTHX);
PERL_CALLCONV OP *Perl_pp_bless(pTHX);
PERL_CALLCONV OP *Perl_pp_blessed(pTHX);
PERL_CALLCONV OP *Perl_pp_break(pTHX);
PERL_CALLCONV OP *Perl_pp_caller(pTHX);
PERL_CALLCONV OP *Perl_pp_catch(pTHX);
PERL_CALLCONV OP *Perl_pp_ceil(pTHX);
PERL_CALLCONV OP *Perl_pp_chdir(pTHX);
PERL_CALLCONV OP *Perl_pp_chop(pTHX);
PERL_CALLCONV OP *Perl_pp_chown(pTHX);
PERL_CALLCONV OP *Perl_pp_chr(pTHX);
PERL_CALLCONV OP *Perl_pp_chroot(pTHX);
PERL_CALLCONV OP *Perl_pp_clonecv(pTHX);
PERL_CALLCONV OP *Perl_pp_close(pTHX);
PERL_CALLCONV OP *Perl_pp_closedir(pTHX);
PERL_CALLCONV OP *Perl_pp_cmpchain_and(pTHX);
PERL_CALLCONV OP *Perl_pp_cmpchain_dup(pTHX);
PERL_CALLCONV OP *Perl_pp_complement(pTHX);
PERL_CALLCONV OP *Perl_pp_concat(pTHX);
PERL_CALLCONV OP *Perl_pp_cond_expr(pTHX);
PERL_CALLCONV OP *Perl_pp_const(pTHX);
PERL_CALLCONV OP *Perl_pp_continue(pTHX);
PERL_CALLCONV OP *Perl_pp_coreargs(pTHX);
PERL_CALLCONV OP *Perl_pp_crypt(pTHX);
PERL_CALLCONV OP *Perl_pp_dbmopen(pTHX);
PERL_CALLCONV OP *Perl_pp_dbstate(pTHX);
PERL_CALLCONV OP *Perl_pp_defined(pTHX);
PERL_CALLCONV OP *Perl_pp_delete(pTHX);
PERL_CALLCONV OP *Perl_pp_die(pTHX);
PERL_CALLCONV OP *Perl_pp_divide(pTHX);
PERL_CALLCONV OP *Perl_pp_each(pTHX);
PERL_CALLCONV OP *Perl_pp_ehostent(pTHX);
PERL_CALLCONV OP *Perl_pp_enter(pTHX);
PERL_CALLCONV OP *Perl_pp_entereval(pTHX);
PERL_CALLCONV OP *Perl_pp_entergiven(pTHX);
PERL_CALLCONV OP *Perl_pp_enteriter(pTHX);
PERL_CALLCONV OP *Perl_pp_enterloop(pTHX);
PERL_CALLCONV OP *Perl_pp_entersub(pTHX);
PERL_CALLCONV OP *Perl_pp_entertry(pTHX);
PERL_CALLCONV OP *Perl_pp_entertrycatch(pTHX);
PERL_CALLCONV OP *Perl_pp_enterwhen(pTHX);
PERL_CALLCONV OP *Perl_pp_enterwrite(pTHX);
PERL_CALLCONV OP *Perl_pp_eof(pTHX);
PERL_CALLCONV OP *Perl_pp_eq(pTHX);
PERL_CALLCONV OP *Perl_pp_exec(pTHX);
PERL_CALLCONV OP *Perl_pp_exists(pTHX);
PERL_CALLCONV OP *Perl_pp_exit(pTHX);
PERL_CALLCONV OP *Perl_pp_fc(pTHX);
PERL_CALLCONV OP *Perl_pp_fileno(pTHX);
PERL_CALLCONV OP *Perl_pp_flip(pTHX);
PERL_CALLCONV OP *Perl_pp_flock(pTHX);
PERL_CALLCONV OP *Perl_pp_floor(pTHX);
PERL_CALLCONV OP *Perl_pp_flop(pTHX);
PERL_CALLCONV OP *Perl_pp_fork(pTHX);
PERL_CALLCONV OP *Perl_pp_formline(pTHX);
PERL_CALLCONV OP *Perl_pp_ftis(pTHX);
PERL_CALLCONV OP *Perl_pp_ftlink(pTHX);
PERL_CALLCONV OP *Perl_pp_ftrowned(pTHX);
PERL_CALLCONV OP *Perl_pp_ftrread(pTHX);
PERL_CALLCONV OP *Perl_pp_fttext(pTHX);
PERL_CALLCONV OP *Perl_pp_fttty(pTHX);
PERL_CALLCONV OP *Perl_pp_ge(pTHX);
PERL_CALLCONV OP *Perl_pp_gelem(pTHX);
PERL_CALLCONV OP *Perl_pp_getc(pTHX);
PERL_CALLCONV OP *Perl_pp_getlogin(pTHX);
PERL_CALLCONV OP *Perl_pp_getpeername(pTHX);
PERL_CALLCONV OP *Perl_pp_getpgrp(pTHX);
PERL_CALLCONV OP *Perl_pp_getppid(pTHX);
PERL_CALLCONV OP *Perl_pp_getpriority(pTHX);
PERL_CALLCONV OP *Perl_pp_ggrent(pTHX);
PERL_CALLCONV OP *Perl_pp_ghostent(pTHX);
PERL_CALLCONV OP *Perl_pp_glob(pTHX);
PERL_CALLCONV OP *Perl_pp_gmtime(pTHX);
PERL_CALLCONV OP *Perl_pp_gnetent(pTHX);
PERL_CALLCONV OP *Perl_pp_goto(pTHX);
PERL_CALLCONV OP *Perl_pp_gprotoent(pTHX);
PERL_CALLCONV OP *Perl_pp_gpwent(pTHX);
PERL_CALLCONV OP *Perl_pp_grepstart(pTHX);
PERL_CALLCONV OP *Perl_pp_grepwhile(pTHX);
PERL_CALLCONV OP *Perl_pp_gservent(pTHX);
PERL_CALLCONV OP *Perl_pp_gt(pTHX);
PERL_CALLCONV OP *Perl_pp_gv(pTHX);
PERL_CALLCONV OP *Perl_pp_gvsv(pTHX);
PERL_CALLCONV OP *Perl_pp_helem(pTHX);
PERL_CALLCONV OP *Perl_pp_hintseval(pTHX);
PERL_CALLCONV OP *Perl_pp_hslice(pTHX);
PERL_CALLCONV OP *Perl_pp_i_add(pTHX);
PERL_CALLCONV OP *Perl_pp_i_divide(pTHX);
PERL_CALLCONV OP *Perl_pp_i_eq(pTHX);
PERL_CALLCONV OP *Perl_pp_i_ge(pTHX);
PERL_CALLCONV OP *Perl_pp_i_gt(pTHX);
PERL_CALLCONV OP *Perl_pp_i_le(pTHX);
PERL_CALLCONV OP *Perl_pp_i_lt(pTHX);
PERL_CALLCONV OP *Perl_pp_i_modulo(pTHX);
PERL_CALLCONV OP *Perl_pp_i_multiply(pTHX);
PERL_CALLCONV OP *Perl_pp_i_ncmp(pTHX);
PERL_CALLCONV OP *Perl_pp_i_ne(pTHX);
PERL_CALLCONV OP *Perl_pp_i_negate(pTHX);
PERL_CALLCONV OP *Perl_pp_i_subtract(pTHX);
PERL_CALLCONV OP *Perl_pp_index(pTHX);
PERL_CALLCONV OP *Perl_pp_int(pTHX);
PERL_CALLCONV OP *Perl_pp_introcv(pTHX);
PERL_CALLCONV OP *Perl_pp_ioctl(pTHX);
PERL_CALLCONV OP *Perl_pp_is_bool(pTHX);
PERL_CALLCONV OP *Perl_pp_is_weak(pTHX);
PERL_CALLCONV OP *Perl_pp_isa(pTHX);
PERL_CALLCONV OP *Perl_pp_iter(pTHX);
PERL_CALLCONV OP *Perl_pp_join(pTHX);
PERL_CALLCONV OP *Perl_pp_kvaslice(pTHX);
PERL_CALLCONV OP *Perl_pp_kvhslice(pTHX);
PERL_CALLCONV OP *Perl_pp_last(pTHX);
PERL_CALLCONV OP *Perl_pp_lc(pTHX);
PERL_CALLCONV OP *Perl_pp_le(pTHX);
PERL_CALLCONV OP *Perl_pp_leave(pTHX);
PERL_CALLCONV OP *Perl_pp_leaveeval(pTHX);
PERL_CALLCONV OP *Perl_pp_leavegiven(pTHX);
PERL_CALLCONV OP *Perl_pp_leaveloop(pTHX);
PERL_CALLCONV OP *Perl_pp_leavesub(pTHX);
PERL_CALLCONV OP *Perl_pp_leavesublv(pTHX);
PERL_CALLCONV OP *Perl_pp_leavetry(pTHX);
PERL_CALLCONV OP *Perl_pp_leavetrycatch(pTHX);
PERL_CALLCONV OP *Perl_pp_leavewhen(pTHX);
PERL_CALLCONV OP *Perl_pp_leavewrite(pTHX);
PERL_CALLCONV OP *Perl_pp_left_shift(pTHX);
PERL_CALLCONV OP *Perl_pp_length(pTHX);
PERL_CALLCONV OP *Perl_pp_link(pTHX);
PERL_CALLCONV OP *Perl_pp_list(pTHX);
PERL_CALLCONV OP *Perl_pp_listen(pTHX);
PERL_CALLCONV OP *Perl_pp_lock(pTHX);
PERL_CALLCONV OP *Perl_pp_lslice(pTHX);
PERL_CALLCONV OP *Perl_pp_lt(pTHX);
PERL_CALLCONV OP *Perl_pp_lvavref(pTHX);
PERL_CALLCONV OP *Perl_pp_lvref(pTHX);
PERL_CALLCONV OP *Perl_pp_lvrefslice(pTHX);
PERL_CALLCONV OP *Perl_pp_mapwhile(pTHX);
PERL_CALLCONV OP *Perl_pp_match(pTHX);
PERL_CALLCONV OP *Perl_pp_method(pTHX);
PERL_CALLCONV OP *Perl_pp_method_named(pTHX);
PERL_CALLCONV OP *Perl_pp_method_redir(pTHX);
PERL_CALLCONV OP *Perl_pp_method_redir_super(pTHX);
PERL_CALLCONV OP *Perl_pp_method_super(pTHX);
PERL_CALLCONV OP *Perl_pp_mkdir(pTHX);
PERL_CALLCONV OP *Perl_pp_modulo(pTHX);
PERL_CALLCONV OP *Perl_pp_multiconcat(pTHX);
PERL_CALLCONV OP *Perl_pp_multideref(pTHX);
PERL_CALLCONV OP *Perl_pp_multiply(pTHX);
PERL_CALLCONV OP *Perl_pp_nbit_and(pTHX);
PERL_CALLCONV OP *Perl_pp_nbit_or(pTHX);
PERL_CALLCONV OP *Perl_pp_ncmp(pTHX);
PERL_CALLCONV OP *Perl_pp_ncomplement(pTHX);
PERL_CALLCONV OP *Perl_pp_ne(pTHX);
PERL_CALLCONV OP *Perl_pp_negate(pTHX);
PERL_CALLCONV OP *Perl_pp_next(pTHX);
PERL_CALLCONV OP *Perl_pp_nextstate(pTHX);
PERL_CALLCONV OP *Perl_pp_not(pTHX);
PERL_CALLCONV OP *Perl_pp_null(pTHX);
PERL_CALLCONV OP *Perl_pp_oct(pTHX);
PERL_CALLCONV OP *Perl_pp_once(pTHX);
PERL_CALLCONV OP *Perl_pp_open(pTHX);
PERL_CALLCONV OP *Perl_pp_open_dir(pTHX);
PERL_CALLCONV OP *Perl_pp_or(pTHX);
PERL_CALLCONV OP *Perl_pp_ord(pTHX);
PERL_CALLCONV OP *Perl_pp_pack(pTHX);
PERL_CALLCONV OP *Perl_pp_padav(pTHX);
PERL_CALLCONV OP *Perl_pp_padcv(pTHX);
PERL_CALLCONV OP *Perl_pp_padhv(pTHX);
PERL_CALLCONV OP *Perl_pp_padrange(pTHX);
PERL_CALLCONV OP *Perl_pp_padsv(pTHX);
PERL_CALLCONV OP *Perl_pp_pipe_op(pTHX);
PERL_CALLCONV OP *Perl_pp_poptry(pTHX);
PERL_CALLCONV OP *Perl_pp_pos(pTHX);
PERL_CALLCONV OP *Perl_pp_postdec(pTHX);
PERL_CALLCONV OP *Perl_pp_postinc(pTHX);
PERL_CALLCONV OP *Perl_pp_pow(pTHX);
PERL_CALLCONV OP *Perl_pp_predec(pTHX);
PERL_CALLCONV OP *Perl_pp_preinc(pTHX);
PERL_CALLCONV OP *Perl_pp_print(pTHX);
PERL_CALLCONV OP *Perl_pp_prototype(pTHX);
PERL_CALLCONV OP *Perl_pp_prtf(pTHX);
PERL_CALLCONV OP *Perl_pp_push(pTHX);
PERL_CALLCONV OP *Perl_pp_pushdefer(pTHX);
PERL_CALLCONV OP *Perl_pp_pushmark(pTHX);
PERL_CALLCONV OP *Perl_pp_qr(pTHX);
PERL_CALLCONV OP *Perl_pp_quotemeta(pTHX);
PERL_CALLCONV OP *Perl_pp_rand(pTHX);
PERL_CALLCONV OP *Perl_pp_range(pTHX);
PERL_CALLCONV OP *Perl_pp_rcatline(pTHX);
PERL_CALLCONV OP *Perl_pp_readdir(pTHX);
PERL_CALLCONV OP *Perl_pp_readline(pTHX);
PERL_CALLCONV OP *Perl_pp_readlink(pTHX);
PERL_CALLCONV OP *Perl_pp_redo(pTHX);
PERL_CALLCONV OP *Perl_pp_ref(pTHX);
PERL_CALLCONV OP *Perl_pp_refaddr(pTHX);
PERL_CALLCONV OP *Perl_pp_refassign(pTHX);
PERL_CALLCONV OP *Perl_pp_refgen(pTHX);
PERL_CALLCONV OP *Perl_pp_reftype(pTHX);
PERL_CALLCONV OP *Perl_pp_regcomp(pTHX);
PERL_CALLCONV OP *Perl_pp_regcreset(pTHX);
PERL_CALLCONV OP *Perl_pp_rename(pTHX);
PERL_CALLCONV OP *Perl_pp_repeat(pTHX);
PERL_CALLCONV OP *Perl_pp_require(pTHX);
PERL_CALLCONV OP *Perl_pp_reset(pTHX);
PERL_CALLCONV OP *Perl_pp_return(pTHX);
PERL_CALLCONV OP *Perl_pp_reverse(pTHX);
PERL_CALLCONV OP *Perl_pp_rewinddir(pTHX);
PERL_CALLCONV OP *Perl_pp_right_shift(pTHX);
PERL_CALLCONV OP *Perl_pp_rmdir(pTHX);
PERL_CALLCONV OP *Perl_pp_runcv(pTHX);
PERL_CALLCONV OP *Perl_pp_rv2av(pTHX);
PERL_CALLCONV OP *Perl_pp_rv2cv(pTHX);
PERL_CALLCONV OP *Perl_pp_rv2gv(pTHX);
PERL_CALLCONV OP *Perl_pp_rv2sv(pTHX);
PERL_CALLCONV OP *Perl_pp_sassign(pTHX);
PERL_CALLCONV OP *Perl_pp_sbit_and(pTHX);
PERL_CALLCONV OP *Perl_pp_sbit_or(pTHX);
PERL_CALLCONV OP *Perl_pp_schop(pTHX);
PERL_CALLCONV OP *Perl_pp_scmp(pTHX);
PERL_CALLCONV OP *Perl_pp_scomplement(pTHX);
PERL_CALLCONV OP *Perl_pp_seekdir(pTHX);
PERL_CALLCONV OP *Perl_pp_select(pTHX);
PERL_CALLCONV OP *Perl_pp_semctl(pTHX);
PERL_CALLCONV OP *Perl_pp_semget(pTHX);
PERL_CALLCONV OP *Perl_pp_seq(pTHX);
PERL_CALLCONV OP *Perl_pp_setpgrp(pTHX);
PERL_CALLCONV OP *Perl_pp_setpriority(pTHX);
PERL_CALLCONV OP *Perl_pp_shift(pTHX);
PERL_CALLCONV OP *Perl_pp_shmwrite(pTHX);
PERL_CALLCONV OP *Perl_pp_shostent(pTHX);
PERL_CALLCONV OP *Perl_pp_shutdown(pTHX);
PERL_CALLCONV OP *Perl_pp_sin(pTHX);
PERL_CALLCONV OP *Perl_pp_sle(pTHX);
PERL_CALLCONV OP *Perl_pp_sleep(pTHX);
PERL_CALLCONV OP *Perl_pp_smartmatch(pTHX);
PERL_CALLCONV OP *Perl_pp_sne(pTHX);
PERL_CALLCONV OP *Perl_pp_socket(pTHX);
PERL_CALLCONV OP *Perl_pp_sockpair(pTHX);
PERL_CALLCONV OP *Perl_pp_sort(pTHX);
PERL_CALLCONV OP *Perl_pp_splice(pTHX);
PERL_CALLCONV OP *Perl_pp_split(pTHX);
PERL_CALLCONV OP *Perl_pp_sprintf(pTHX);
PERL_CALLCONV OP *Perl_pp_srand(pTHX);
PERL_CALLCONV OP *Perl_pp_srefgen(pTHX);
PERL_CALLCONV OP *Perl_pp_sselect(pTHX);
PERL_CALLCONV OP *Perl_pp_ssockopt(pTHX);
PERL_CALLCONV OP *Perl_pp_stat(pTHX);
PERL_CALLCONV OP *Perl_pp_stringify(pTHX);
PERL_CALLCONV OP *Perl_pp_stub(pTHX);
PERL_CALLCONV OP *Perl_pp_study(pTHX);
PERL_CALLCONV OP *Perl_pp_subst(pTHX);
PERL_CALLCONV OP *Perl_pp_substcont(pTHX);
PERL_CALLCONV OP *Perl_pp_substr(pTHX);
PERL_CALLCONV OP *Perl_pp_subtract(pTHX);
PERL_CALLCONV OP *Perl_pp_syscall(pTHX);
PERL_CALLCONV OP *Perl_pp_sysopen(pTHX);
PERL_CALLCONV OP *Perl_pp_sysread(pTHX);
PERL_CALLCONV OP *Perl_pp_sysseek(pTHX);
PERL_CALLCONV OP *Perl_pp_system(pTHX);
PERL_CALLCONV OP *Perl_pp_syswrite(pTHX);
PERL_CALLCONV OP *Perl_pp_tell(pTHX);
PERL_CALLCONV OP *Perl_pp_telldir(pTHX);
PERL_CALLCONV OP *Perl_pp_tie(pTHX);
PERL_CALLCONV OP *Perl_pp_tied(pTHX);
PERL_CALLCONV OP *Perl_pp_time(pTHX);
PERL_CALLCONV OP *Perl_pp_tms(pTHX);
PERL_CALLCONV OP *Perl_pp_trans(pTHX);
PERL_CALLCONV OP *Perl_pp_truncate(pTHX);
PERL_CALLCONV OP *Perl_pp_uc(pTHX);
PERL_CALLCONV OP *Perl_pp_ucfirst(pTHX);
PERL_CALLCONV OP *Perl_pp_umask(pTHX);
PERL_CALLCONV OP *Perl_pp_undef(pTHX);
PERL_CALLCONV OP *Perl_pp_unpack(pTHX);
PERL_CALLCONV OP *Perl_pp_unshift(pTHX);
PERL_CALLCONV OP *Perl_pp_unstack(pTHX);
PERL_CALLCONV OP *Perl_pp_untie(pTHX);
PERL_CALLCONV OP *Perl_pp_unweaken(pTHX);
PERL_CALLCONV OP *Perl_pp_vec(pTHX);
PERL_CALLCONV OP *Perl_pp_wait(pTHX);
PERL_CALLCONV OP *Perl_pp_waitpid(pTHX);
PERL_CALLCONV OP *Perl_pp_wantarray(pTHX);
PERL_CALLCONV OP *Perl_pp_warn(pTHX);
PERL_CALLCONV OP *Perl_pp_weaken(pTHX);
PERL_CALLCONV OP *Perl_pp_xor(pTHX);
PERL_CALLCONV OP *Perl_unimplemented_op(pTHX);

/* ex: set ro: */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /*    regcomp.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
 *    2000, 2001, 2002, 2003, 2005, 2006, 2007, by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

#if ! defined(PERL_REGCOMP_H_) && (   defined(PERL_CORE)            \
                                   || defined(PERL_EXT_RE_BUILD))
#define PERL_REGCOMP_H_

#include "regcharclass.h"

/* Convert branch sequences to more efficient trie ops? */
#define PERL_ENABLE_TRIE_OPTIMISATION 1

/* Be really aggressive about optimising patterns with trie sequences? */
#define PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION 1

/* Should the optimiser take positive assertions into account? */
#define PERL_ENABLE_POSITIVE_ASSERTION_STUDY 0

/* Not for production use: */
#define PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS 0

/*
 * Structure for regexp "program".  This is essentially a linear encoding
 * of a nondeterministic finite-state machine (aka syntax charts or
 * "railroad normal form" in parsing technology).  Each node is an opcode
 * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
 * all nodes except BRANCH implement concatenation; a "next" pointer with
 * a BRANCH on both ends of it is connecting two alternatives.  (Here we
 * have one of the subtle syntax dependencies:  an individual BRANCH (as
 * opposed to a collection of them) is never concatenated with anything
 * because of operator precedence.)  The operand of some types of node is
 * a literal string; for others, it is a node leading into a sub-FSM.  In
 * particular, the operand of a BRANCH node is the first node of the branch.
 * (NB this is *not* a tree structure:  the tail of the branch connects
 * to the thing following the set of BRANCHes.)  The opcodes are defined
 * in regnodes.h which is generated from regcomp.sym by regcomp.pl.
 */

/*
 * A node is one char of opcode followed by two chars of "next" pointer.
 * "Next" pointers are stored as two 8-bit pieces, high order first.  The
 * value is a positive offset from the opcode of the node containing it.
 * An operand, if any, simply follows the node.  (Note that much of the
 * code generation knows about this implicit relationship.)
 *
 * Using two bytes for the "next" pointer is vast overkill for most things,
 * but allows patterns to get big without disasters.
 *
 * [The "next" pointer is always aligned on an even
 * boundary, and reads the offset directly as a short.]
 */

/* This is the stuff that used to live in regexp.h that was truly
   private to the engine itself. It now lives here. */

typedef struct regexp_internal {
        regnode *regstclass;    /* Optional startclass as identified or constructed
                                   by the optimiser */
        struct reg_data *data;	/* Additional miscellaneous data used by the program.
                                   Used to make it easier to clone and free arbitrary
                                   data that the regops need. Often the ARG field of
                                   a regop is an index into this structure. NOTE the
                                   0th element of this structure is NEVER used and is
                                   strictly reserved for internal purposes. */
        struct reg_code_blocks *code_blocks;/* positions of literal (?{}) */
        U32 proglen;            /* size of the compiled program in regnodes */
        U32 name_list_idx;      /* Optional data index of an array of paren names,
                                   only valid when RXp_PAREN_NAMES(prog) is true,
                                   0 means "no value" like any other index into the
                                   data array.*/
        regnode program[1];	/* Unwarranted chumminess with compiler. */
} regexp_internal;

#define RXi_SET(x,y) (x)->pprivate = (void*)(y)   
#define RXi_GET(x)   ((regexp_internal *)((x)->pprivate))
#define RXi_GET_DECL(r,ri) regexp_internal *ri = RXi_GET(r)
/*
 * Flags stored in regexp->intflags
 * These are used only internally to the regexp engine
 *
 * See regexp.h for flags used externally to the regexp engine
 */
#define RXp_INTFLAGS(rx)        ((rx)->intflags)
#define RX_INTFLAGS(prog)        RXp_INTFLAGS(ReANY(prog))

#define PREGf_SKIP		0x00000001
#define PREGf_IMPLICIT		0x00000002 /* Converted .* to ^.* */
#define PREGf_NAUGHTY		0x00000004 /* how exponential is this pattern? */
#define PREGf_VERBARG_SEEN	0x00000008
#define PREGf_CUTGROUP_SEEN	0x00000010
#define PREGf_USE_RE_EVAL	0x00000020 /* compiled with "use re 'eval'" */
/* these used to be extflags, but are now intflags */
#define PREGf_NOSCAN            0x00000040
                                /* spare */
#define PREGf_GPOS_SEEN         0x00000100
#define PREGf_GPOS_FLOAT        0x00000200

#define PREGf_ANCH_MBOL         0x00000400
#define PREGf_ANCH_SBOL         0x00000800
#define PREGf_ANCH_GPOS         0x00001000
#define PREGf_RECURSE_SEEN      0x00002000

#define PREGf_ANCH              \
    ( PREGf_ANCH_SBOL | PREGf_ANCH_GPOS | PREGf_ANCH_MBOL )

/* this is where the old regcomp.h started */

struct regnode_string {
    U8	str_len;
    U8  type;
    U16 next_off;
    char string[1];
};

struct regnode_lstring { /* Constructed this way to keep the string aligned. */
    U8	flags;
    U8  type;
    U16 next_off;
    U32 str_len;    /* Only 18 bits allowed before would overflow 'next_off' */
    char string[1];
};

struct regnode_anyofhs { /* Constructed this way to keep the string aligned. */
    U8	str_len;
    U8  type;
    U16 next_off;
    U32 arg1;                           /* set by set_ANYOF_arg() */
    char string[1];
};

/* Argument bearing node - workhorse, 
   arg1 is often for the data field */
struct regnode_1 {
    U8	flags;
    U8  type;
    U16 next_off;
    U32 arg1;
};

/* Node whose argument is 'SV *'.  This needs to be used very carefully in
 * situations where pointers won't become invalid because of, say re-mallocs */
struct regnode_p {
    U8	flags;
    U8  type;
    U16 next_off;
    SV * arg1;
};

/* Similar to a regnode_1 but with an extra signed argument */
struct regnode_2L {
    U8	flags;
    U8  type;
    U16 next_off;
    U32 arg1;
    I32 arg2;
};

/* 'Two field' -- Two 16 bit unsigned args */
struct regnode_2 {
    U8	flags;
    U8  type;
    U16 next_off;
    U16 arg1;
    U16 arg2;
};

#define ANYOF_BITMAP_SIZE	(NUM_ANYOF_CODE_POINTS / 8)   /* 8 bits/Byte */

/* Note that these form structs which are supersets of the next smaller one, by
 * appending fields.  Alignment problems can occur if one of those optional
 * fields requires stricter alignment than the base struct.  And formal
 * parameters that can really be two or more of the structs should be
 * declared as the smallest one it could be.  See commit message for
 * 7dcac5f6a5195002b55c935ee1d67f67e1df280b.  Regnode allocation is done
 * without regard to alignment, and changing it to would also require changing
 * the code that inserts and deletes regnodes.  The basic single-argument
 * regnode has a U32, which is what reganode() allocates as a unit.  Therefore
 * no field can require stricter alignment than U32. */

/* also used by trie */
struct regnode_charclass {
    U8	flags;
    U8  type;
    U16 next_off;
    U32 arg1;                           /* set by set_ANYOF_arg() */
    char bitmap[ANYOF_BITMAP_SIZE];	/* only compile-time */
};

/* has runtime (locale) \d, \w, ..., [:posix:] classes */
struct regnode_charclass_posixl {
    U8	flags;                      /* ANYOF_MATCHES_POSIXL bit must go here */
    U8  type;
    U16 next_off;
    U32 arg1;
    char bitmap[ANYOF_BITMAP_SIZE];		/* both compile-time ... */
    U32 classflags;	                        /* and run-time */
};

/* A synthetic start class (SSC); is a regnode_charclass_posixl_fold, plus an
 * extra SV*, used only during its construction and which is not used by
 * regexec.c.  Note that the 'next_off' field is unused, as the SSC stands
 * alone, so there is never a next node.  Also, there is no alignment issue,
 * because these are declared or allocated as a complete unit so the compiler
 * takes care of alignment.  This is unlike the other regnodes which are
 * allocated in terms of multiples of a single-argument regnode.  SSC nodes can
 * have a pointer field because there is no alignment issue, and because it is
 * set to NULL after construction, before any cloning of the pattern */
struct regnode_ssc {
    U8	flags;                      /* ANYOF_MATCHES_POSIXL bit must go here */
    U8  type;
    U16 next_off;
    U32 arg1;
    char bitmap[ANYOF_BITMAP_SIZE];	/* both compile-time ... */
    U32 classflags;	                /* ... and run-time */

    /* Auxiliary, only used during construction; NULL afterwards: list of code
     * points matched */
    SV* invlist;
};

/*  We take advantage of 'next_off' not otherwise being used in the SSC by
 *  actually using it: by setting it to 1.  This allows us to test and
 *  distinguish between an SSC and other ANYOF node types, as 'next_off' cannot
 *  otherwise be 1, because it is the offset to the next regnode expressed in
 *  units of regnodes.  Since an ANYOF node contains extra fields, it adds up
 *  to 12 regnode units on 32-bit systems, (hence the minimum this can be (if
 *  not 0) is 11 there.  Even if things get tightly packed on a 64-bit system,
 *  it still would be more than 1. */
#define set_ANYOF_SYNTHETIC(n) STMT_START{ OP(n) = ANYOF;              \
                                           NEXT_OFF(n) = 1;            \
                               } STMT_END
#define is_ANYOF_SYNTHETIC(n) (PL_regkind[OP(n)] == ANYOF && NEXT_OFF(n) == 1)

/* XXX fix this description.
   Impose a limit of REG_INFTY on various pattern matching operations
   to limit stack growth and to avoid "infinite" recursions.
*/
/* The default size for REG_INFTY is U16_MAX, which is the same as
   USHORT_MAX (see perl.h).  Unfortunately U16 isn't necessarily 16 bits
   (see handy.h).  On the Cray C90, sizeof(short)==4 and hence U16_MAX is
   ((1<<32)-1), while on the Cray T90, sizeof(short)==8 and U16_MAX is
   ((1<<64)-1).  To limit stack growth to reasonable sizes, supply a
   smaller default.
        --Andy Dougherty  11 June 1998
*/
#if SHORTSIZE > 2
#  ifndef REG_INFTY
#    define REG_INFTY  nBIT_UMAX(16)
#  endif
#endif

#ifndef REG_INFTY
#  define REG_INFTY U16_MAX
#endif

#define ARG_VALUE(arg) (arg)
#define ARG__SET(arg,val) ((arg) = (val))

#undef ARG
#undef ARG1
#undef ARG2

#define ARG(p) ARG_VALUE(ARG_LOC(p))
#define ARGp(p) ARG_VALUE(ARGp_LOC(p))
#define ARG1(p) ARG_VALUE(ARG1_LOC(p))
#define ARG2(p) ARG_VALUE(ARG2_LOC(p))
#define ARG2L(p) ARG_VALUE(ARG2L_LOC(p))

#define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val))
#define ARGp_SET(p, val) ARG__SET(ARGp_LOC(p), (val))
#define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val))
#define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val))
#define ARG2L_SET(p, val) ARG__SET(ARG2L_LOC(p), (val))

#undef NEXT_OFF
#undef NODE_ALIGN

#define NEXT_OFF(p) ((p)->next_off)
#define NODE_ALIGN(node)
/* the following define was set to 0xde in 075abff3
 * as part of some linting logic. I have set it to 0
 * as otherwise in every place where we /might/ set flags
 * we have to set it 0 explicitly, which duplicates
 * assignments and IMO adds an unacceptable level of
 * surprise to working in the regex engine. If this
 * is changed from 0 then at the very least make sure
 * that SBOL for /^/ sets the flags to 0 explicitly.
 * -- Yves */
#define NODE_ALIGN_FILL(node) ((node)->flags = 0)

#define SIZE_ALIGN NODE_ALIGN

#undef OP
#undef OPERAND
#undef STRING

#define	OP(p)		((p)->type)
#define FLAGS(p)	((p)->flags)	/* Caution: Doesn't apply to all      \
                                           regnode types.  For some, it's the \
                                           character set of the regnode */
#define	STR_LENs(p)	(__ASSERT_(OP(p) != LEXACT && OP(p) != LEXACT_REQ8)  \
                                    ((struct regnode_string *)p)->str_len)
#define	STRINGs(p)	(__ASSERT_(OP(p) != LEXACT && OP(p) != LEXACT_REQ8)  \
                                    ((struct regnode_string *)p)->string)
#define	OPERANDs(p)	STRINGs(p)

/* Long strings.  Currently limited to length 18 bits, which handles a 262000
 * byte string.  The limiting factor is the 16 bit 'next_off' field, which
 * points to the next regnode, so the furthest away it can be is 2**16.  On
 * most architectures, regnodes are 2**2 bytes long, so that yields 2**18
 * bytes.  Should a longer string be desired, we could increase it to 26 bits
 * fairly easily, by changing this node to have longj type which causes the ARG
 * field to be used for the link to the next regnode (although code would have
 * to be changed to account for this), and then use a combination of the flags
 * and next_off fields for the length.  To get 34 bit length, also change the
 * node to be an ARG2L, using the second 32 bit field for the length, and not
 * using the flags nor next_off fields at all.  One could have an llstring node
 * and even an lllstring type. */
#define	STR_LENl(p)	(__ASSERT_(OP(p) == LEXACT || OP(p) == LEXACT_REQ8)  \
                                    (((struct regnode_lstring *)p)->str_len))
#define	STRINGl(p)	(__ASSERT_(OP(p) == LEXACT || OP(p) == LEXACT_REQ8)  \
                                    (((struct regnode_lstring *)p)->string))
#define	OPERANDl(p)	STRINGl(p)

#define	STR_LEN(p)	((OP(p) == LEXACT || OP(p) == LEXACT_REQ8)           \
                                               ? STR_LENl(p) : STR_LENs(p))
#define	STRING(p)	((OP(p) == LEXACT || OP(p) == LEXACT_REQ8)           \
                                               ? STRINGl(p)  : STRINGs(p))
#define	OPERAND(p)	STRING(p)

/* The number of (smallest) regnode equivalents that a string of length l bytes
 * occupies */
#define STR_SZ(l)	(((l) + sizeof(regnode) - 1) / sizeof(regnode))

/* The number of (smallest) regnode equivalents that the EXACTISH node 'p'
 * occupies */
#define NODE_SZ_STR(p)	(STR_SZ(STR_LEN(p)) + 1 + regarglen[(p)->type])

#define setSTR_LEN(p,v)                                                     \
    STMT_START{                                                             \
        if (OP(p) == LEXACT || OP(p) == LEXACT_REQ8)                        \
            ((struct regnode_lstring *)(p))->str_len = (v);                 \
        else                                                                \
            ((struct regnode_string *)(p))->str_len = (v);                  \
    } STMT_END

#define ANYOFR_BASE_BITS    20
#define ANYOFRbase(p)   (ARG(p) & nBIT_MASK(ANYOFR_BASE_BITS))
#define ANYOFRdelta(p)  (ARG(p) >> ANYOFR_BASE_BITS)

#undef NODE_ALIGN
#undef ARG_LOC
#undef NEXTOPER
#undef PREVOPER

#define	NODE_ALIGN(node)
#define	ARG_LOC(p)	(((struct regnode_1 *)p)->arg1)
#define ARGp_LOC(p)	(((struct regnode_p *)p)->arg1)
#define	ARG1_LOC(p)	(((struct regnode_2 *)p)->arg1)
#define	ARG2_LOC(p)	(((struct regnode_2 *)p)->arg2)
#define ARG2L_LOC(p)	(((struct regnode_2L *)p)->arg2)

#define NODE_STEP_REGNODE	1	/* sizeof(regnode)/sizeof(regnode) */
#define EXTRA_STEP_2ARGS	EXTRA_SIZE(struct regnode_2)

#define	NEXTOPER(p)	((p) + NODE_STEP_REGNODE)
#define	PREVOPER(p)	((p) - NODE_STEP_REGNODE)

#define FILL_NODE(offset, op)                                           \
    STMT_START {                                                        \
                    OP(REGNODE_p(offset)) = op;                         \
                    NEXT_OFF(REGNODE_p(offset)) = 0;                    \
    } STMT_END
#define FILL_ADVANCE_NODE(offset, op)                                   \
    STMT_START {                                                        \
                    FILL_NODE(offset, op);                              \
                    (offset)++;                                         \
    } STMT_END
#define FILL_ADVANCE_NODE_ARG(offset, op, arg)                          \
    STMT_START {                                                        \
                    ARG_SET(REGNODE_p(offset), arg);                    \
                    FILL_ADVANCE_NODE(offset, op);                      \
                    /* This is used generically for other operations    \
                     * that have a longer argument */                   \
                    (offset) += regarglen[op];                          \
    } STMT_END
#define FILL_ADVANCE_NODE_ARGp(offset, op, arg)                          \
    STMT_START {                                                        \
                    ARGp_SET(REGNODE_p(offset), arg);                    \
                    FILL_ADVANCE_NODE(offset, op);                      \
                    (offset) += regarglen[op];                          \
    } STMT_END
#define FILL_ADVANCE_NODE_2L_ARG(offset, op, arg1, arg2)                \
    STMT_START {                                                        \
                    ARG_SET(REGNODE_p(offset), arg1);                   \
                    ARG2L_SET(REGNODE_p(offset), arg2);                 \
                    FILL_ADVANCE_NODE(offset, op);                      \
                    (offset) += 2;                                      \
    } STMT_END

#define REG_MAGIC 0234

/* An ANYOF node is basically a bitmap with the index being a code point.  If
 * the bit for that code point is 1, the code point matches;  if 0, it doesn't
 * match (complemented if inverted).  There is an additional mechanism to deal
 * with cases where the bitmap is insufficient in and of itself.  This #define
 * indicates if the bitmap does fully represent what this ANYOF node can match.
 * The ARG is set to this special value (since 0, 1, ... are legal, but will
 * never reach this high). */
#define ANYOF_ONLY_HAS_BITMAP	((U32) -1)

/* When the bitmap isn't completely sufficient for handling the ANYOF node,
 * flags (in node->flags of the ANYOF node) get set to indicate this.  These
 * are perennially in short supply.  Beyond several cases where warnings need
 * to be raised under certain circumstances, currently, there are six cases
 * where the bitmap alone isn't sufficient.  We could use six flags to
 * represent the 6 cases, but to save flags bits, we play some games.  The
 * cases are:
 *
 *  1)  The bitmap has a compiled-in very finite size.  So something else needs
 *      to be used to specify if a code point that is too large for the bitmap
 *      actually matches.  The mechanism currently is an inversion
 *      list.  ANYOF_ONLY_HAS_BITMAP, described above, being TRUE indicates
 *      there are no matches of too-large code points.  But if it is FALSE,
 *      then almost certainly there are matches too large for the bitmap.  (The
 *      other cases, described below, either imply this one or are extremely
 *      rare in practice.)  So we can just assume that a too-large code point
 *      will need something beyond the bitmap if ANYOF_ONLY_HAS_BITMAP is
 *      FALSE, instead of having a separate flag for this.
 *  2)  A subset of item 1) is if all possible code points outside the bitmap
 *      match.  This is a common occurrence when the class is complemented,
 *      like /[^ij]/.  Therefore a bit is reserved to indicate this,
 *      rather than having an inversion list created,
 *      ANYOF_MATCHES_ALL_ABOVE_BITMAP.
 *  3)  Under /d rules, it can happen that code points that are in the upper
 *      latin1 range (\x80-\xFF or their equivalents on EBCDIC platforms) match
 *      only if the runtime target string being matched against is UTF-8.  For
 *      example /[\w[:punct:]]/d.  This happens only for posix classes (with a
 *      couple of exceptions, like \d where it doesn't happen), and all such
 *      ones also have above-bitmap matches.  Thus, 3) implies 1) as well.
 *      Note that /d rules are no longer encouraged; 'use 5.14' or higher
 *      deselects them.  But a flag is required so that they can be properly
 *      handled.  But it can be a shared flag: see 5) below.
 *  4)  Also under /d rules, something like /[\Wfoo]/ will match everything in
 *      the \x80-\xFF range, unless the string being matched against is UTF-8.
 *      An inversion list could be created for this case, but this is
 *      relatively common, and it turns out that it's all or nothing:  if any
 *      one of these code points matches, they all do.  Hence a single bit
 *      suffices.  We use a shared flag that doesn't take up space by itself:
 *      ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER.  This
 *      also implies 1), with one exception: [:^cntrl:].
 *  5)  A user-defined \p{} property may not have been defined by the time the
 *      regex is compiled.  In this case, we don't know until runtime what it
 *      will match, so we have to assume it could match anything, including
 *      code points that ordinarily would be in the bitmap.  A flag bit is
 *      necessary to indicate this, though it can be shared with the item 3)
 *      flag, as that only occurs under /d, and this only occurs under non-d.
 *      This case is quite uncommon in the field, and the /(?[ ...])/ construct
 *      is a better way to accomplish what this feature does.  This case also
 *      implies 1).
 *      ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP
 *      is the shared flag.
 *  6)  /[foo]/il may have folds that are only valid if the runtime locale is a
 *      UTF-8 one.  These are quite rare, so it would be good to avoid the
 *      expense of looking for them.  But /l matching is slow anyway, and we've
 *      traditionally not worried too much about its performance.  And this
 *      condition requires the ANYOFL_FOLD flag to be set, so testing for
 *      that flag would be sufficient to rule out most cases of this.  So it is
 *      unclear if this should have a flag or not.  But, this flag can be
 *      shared with another, so it doesn't occupy extra space.
 *
 * At the moment, there is one spare bit, but this could be increased by
 * various tricks:
 *
 * If just one more bit is needed, as of this writing it seems to khw that the
 * best choice would be to make ANYOF_MATCHES_ALL_ABOVE_BITMAP not a flag, but
 * something like
 *
 *      #define ANYOF_MATCHES_ALL_ABOVE_BITMAP      ((U32) -2)
 *
 * and access it through the ARG like ANYOF_ONLY_HAS_BITMAP is.  This flag is
 * used by all ANYOF node types, and it could be used to avoid calling the
 * handler function, as the macro REGINCLASS in regexec.c does now for other
 * cases.
 *
 * Another possibility is based on the fact that ANYOF_MATCHES_POSIXL is
 * redundant with the node type ANYOFPOSIXL.  That flag could be removed, but
 * at the expense of extra code in regexec.c.  The flag has been retained
 * because it allows us to see if we need to call reginclass, or just use the
 * bitmap in one test.
 *
 * If this is done, an extension would be to make all ANYOFL nodes contain the
 * extra 32 bits that ANYOFPOSIXL ones do.  The posix flags only occupy 30
 * bits, so the ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD flags
 * and ANYOFL_FOLD could be moved to that extra space, but it would mean extra
 * instructions, as there are currently places in the code that assume those
 * two bits are zero.
 *
 * All told, 5 bits could be available for other uses if all of the above were
 * done.
 *
 * Some flags are not used in synthetic start class (SSC) nodes, so could be
 * shared should new flags be needed for SSCs, like SSC_MATCHES_EMPTY_STRING
 * now. */

/* If this is set, the result of the match should be complemented.  regexec.c
 * is expecting this to be in the low bit.  Never in an SSC */
#define ANYOF_INVERT		                0x01

/* For the SSC node only, which cannot be inverted, so is shared with that bit.
 * This is used only during regex compilation. */
#define SSC_MATCHES_EMPTY_STRING                ANYOF_INVERT

/* Set if this is a regnode_charclass_posixl vs a regnode_charclass.  This
 * is used for runtime \d, \w, [:posix:], ..., which are used only in locale
 * and the optimizer's synthetic start class.  Non-locale \d, etc are resolved
 * at compile-time.  Only set under /l; can be in SSC */
#define ANYOF_MATCHES_POSIXL                    0x02

/* The fold is calculated and stored in the bitmap where possible at compile
 * time.  However under locale, the actual folding varies depending on
 * what the locale is at the time of execution, so it has to be deferred until
 * then.  Only set under /l; never in an SSC  */
#define ANYOFL_FOLD                             0x04

/* Shared bit set only with ANYOFL and SSC nodes:
 *    If ANYOFL_FOLD is set, this flag indicates there are potential matches
 *      valid only if the locale is a UTF-8 one.
 *    If ANYOFL_FOLD is NOT set, this flag means to warn if the runtime locale
 *       isn't a UTF-8 one (and the generated node assumes a UTF-8 locale).
 *       None of INVERT, POSIXL,
 *       ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP
 *       can be set.  */
#define ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD        0x08

/* Convenience macros for teasing apart the meanings when reading the above bit
 * */
#define ANYOFL_SOME_FOLDS_ONLY_IN_UTF8_LOCALE(flags)                        \
    ((flags & ( ANYOFL_FOLD /* Both bits are set */                         \
               |ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD))   \
             == ( ANYOFL_FOLD                                               \
                 |ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD))

#define  ANYOFL_UTF8_LOCALE_REQD(flags)                                     \
    ((flags & ( ANYOFL_FOLD /* Only REQD bit is set */                      \
               |ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD))   \
             == ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD)

/* Spare: Be sure to change ANYOF_FLAGS_ALL if this gets used  0x10 */

/* If set, the node matches every code point NUM_ANYOF_CODE_POINTS and above.
 * Can be in an SSC */
#define ANYOF_MATCHES_ALL_ABOVE_BITMAP          0x20

/* Shared bit:
 *      Under /d it means the ANYOFD node matches more things if the target
 *          string is encoded in UTF-8; any such things will be non-ASCII,
 *          characters that are < 256, and can be accessed via the inversion
 *          list.
 *      When not under /d, it means the ANYOF node contains a user-defined
 *      property that wasn't yet defined at the time the regex was compiled,
 *      and so must be looked up at runtime, by creating an inversion list.
 * (These uses are mutually exclusive because a user-defined property is
 * specified by \p{}, and \p{} implies /u which deselects /d).  The long macro
 * name is to make sure that you are cautioned about its shared nature.  Only
 * the non-/d meaning can be in an SSC */
#define ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP  0x40

/* Shared bit:
 *      Under /d it means the ANYOFD node matches all non-ASCII Latin1
 *          characters when the target string is not in utf8.
 *      When not under /d, it means the ANYOF node should raise a warning if
 *          matching against an above-Unicode code point.
 * (These uses are mutually exclusive because the warning requires a \p{}, and
 * \p{} implies /u which deselects /d).  An SSC node only has this bit set if
 * what is meant is the warning.  The long macro name is to make sure that you
 * are cautioned about its shared nature */
#define ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER 0x80

#define ANYOF_FLAGS_ALL		((U8) ~0x10)

#define ANYOF_LOCALE_FLAGS (ANYOFL_FOLD | ANYOF_MATCHES_POSIXL)

/* These are the flags that apply to both regular ANYOF nodes and synthetic
 * start class nodes during construction of the SSC.  During finalization of
 * the SSC, other of the flags may get added to it */
#define ANYOF_COMMON_FLAGS      0

/* Character classes for node->classflags of ANYOF */
/* Should be synchronized with a table in regprop() */
/* 2n should be the normal one, paired with its complement at 2n+1 */

#define ANYOF_ALPHA    ((_CC_ALPHA) * 2)
#define ANYOF_NALPHA   ((ANYOF_ALPHA) + 1)
#define ANYOF_ALPHANUMERIC   ((_CC_ALPHANUMERIC) * 2)    /* [[:alnum:]] isalnum(3), utf8::IsAlnum */
#define ANYOF_NALPHANUMERIC  ((ANYOF_ALPHANUMERIC) + 1)
#define ANYOF_ASCII    ((_CC_ASCII) * 2)
#define ANYOF_NASCII   ((ANYOF_ASCII) + 1)
#define ANYOF_BLANK    ((_CC_BLANK) * 2)     /* GNU extension: space and tab: non-vertical space */
#define ANYOF_NBLANK   ((ANYOF_BLANK) + 1)
#define ANYOF_CASED    ((_CC_CASED) * 2)    /* Pseudo class for [:lower:] or
                                               [:upper:] under /i */
#define ANYOF_NCASED   ((ANYOF_CASED) + 1)
#define ANYOF_CNTRL    ((_CC_CNTRL) * 2)
#define ANYOF_NCNTRL   ((ANYOF_CNTRL) + 1)
#define ANYOF_DIGIT    ((_CC_DIGIT) * 2)     /* \d */
#define ANYOF_NDIGIT   ((ANYOF_DIGIT) + 1)
#define ANYOF_GRAPH    ((_CC_GRAPH) * 2)
#define ANYOF_NGRAPH   ((ANYOF_GRAPH) + 1)
#define ANYOF_LOWER    ((_CC_LOWER) * 2)
#define ANYOF_NLOWER   ((ANYOF_LOWER) + 1)
#define ANYOF_PRINT    ((_CC_PRINT) * 2)
#define ANYOF_NPRINT   ((ANYOF_PRINT) + 1)
#define ANYOF_PUNCT    ((_CC_PUNCT) * 2)
#define ANYOF_NPUNCT   ((ANYOF_PUNCT) + 1)
#define ANYOF_SPACE    ((_CC_SPACE) * 2)     /* \s */
#define ANYOF_NSPACE   ((ANYOF_SPACE) + 1)
#define ANYOF_UPPER    ((_CC_UPPER) * 2)
#define ANYOF_NUPPER   ((ANYOF_UPPER) + 1)
#define ANYOF_WORDCHAR ((_CC_WORDCHAR) * 2)  /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */
#define ANYOF_NWORDCHAR   ((ANYOF_WORDCHAR) + 1)
#define ANYOF_XDIGIT   ((_CC_XDIGIT) * 2)
#define ANYOF_NXDIGIT  ((ANYOF_XDIGIT) + 1)

/* pseudo classes below this, not stored in the class bitmap, but used as flags
   during compilation of char classes */

#define ANYOF_VERTWS    ((_CC_VERTSPACE) * 2)
#define ANYOF_NVERTWS   ((ANYOF_VERTWS)+1)

/* It is best if this is the last one, as all above it are stored as bits in a
 * bitmap, and it isn't part of that bitmap */
#if _CC_VERTSPACE != _HIGHEST_REGCOMP_DOT_H_SYNC
#   error Problem with handy.h _HIGHEST_REGCOMP_DOT_H_SYNC #define
#endif

#define ANYOF_POSIXL_MAX (ANYOF_VERTWS) /* So upper loop limit is written:
                                         *       '< ANYOF_MAX'
                                         * Hence doesn't include VERTWS, as that
                                         * is a pseudo class */
#define ANYOF_MAX      ANYOF_POSIXL_MAX

#if (ANYOF_POSIXL_MAX > 32)   /* Must fit in 32-bit word */
#   error Problem with handy.h _CC_foo #defines
#endif

#define ANYOF_HORIZWS	((ANYOF_POSIXL_MAX)+2) /* = (ANYOF_NVERTWS + 1) */
#define ANYOF_NHORIZWS	((ANYOF_POSIXL_MAX)+3)

#define ANYOF_UNIPROP   ((ANYOF_POSIXL_MAX)+4)  /* Used to indicate a Unicode
                                                   property: \p{} or \P{} */

/* Backward source code compatibility. */

#define ANYOF_ALNUML	 ANYOF_ALNUM
#define ANYOF_NALNUML	 ANYOF_NALNUM
#define ANYOF_SPACEL	 ANYOF_SPACE
#define ANYOF_NSPACEL	 ANYOF_NSPACE
#define ANYOF_ALNUM ANYOF_WORDCHAR
#define ANYOF_NALNUM ANYOF_NWORDCHAR

/* Utility macros for the bitmap and classes of ANYOF */

#define ANYOF_FLAGS(p)		((p)->flags)

#define ANYOF_BIT(c)		(1U << ((c) & 7))

#define ANYOF_POSIXL_BITMAP(p)  (((regnode_charclass_posixl*) (p))->classflags)

#define POSIXL_SET(field, c)	((field) |= (1U << (c)))
#define ANYOF_POSIXL_SET(p, c)	POSIXL_SET(ANYOF_POSIXL_BITMAP(p), (c))

#define POSIXL_CLEAR(field, c) ((field) &= ~ (1U <<(c)))
#define ANYOF_POSIXL_CLEAR(p, c) POSIXL_CLEAR(ANYOF_POSIXL_BITMAP(p), (c))

#define POSIXL_TEST(field, c)	((field) & (1U << (c)))
#define ANYOF_POSIXL_TEST(p, c)	POSIXL_TEST(ANYOF_POSIXL_BITMAP(p), (c))

#define POSIXL_ZERO(field)	STMT_START { (field) = 0; } STMT_END
#define ANYOF_POSIXL_ZERO(ret)	POSIXL_ZERO(ANYOF_POSIXL_BITMAP(ret))

#define ANYOF_POSIXL_SET_TO_BITMAP(p, bits)                                 \
                STMT_START { ANYOF_POSIXL_BITMAP(p) = (bits); } STMT_END

/* Shifts a bit to get, eg. 0x4000_0000, then subtracts 1 to get 0x3FFF_FFFF */
#define ANYOF_POSIXL_SETALL(ret)                                            \
                STMT_START {                                                \
                    ANYOF_POSIXL_BITMAP(ret) = nBIT_MASK(ANYOF_POSIXL_MAX); \
                } STMT_END
#define ANYOF_CLASS_SETALL(ret) ANYOF_POSIXL_SETALL(ret)

#define ANYOF_POSIXL_TEST_ANY_SET(p)                               \
        ((ANYOF_FLAGS(p) & ANYOF_MATCHES_POSIXL) && ANYOF_POSIXL_BITMAP(p))
#define ANYOF_CLASS_TEST_ANY_SET(p) ANYOF_POSIXL_TEST_ANY_SET(p)

/* Since an SSC always has this field, we don't have to test for that; nor do
 * we want to because the bit isn't set for SSC during its construction */
#define ANYOF_POSIXL_SSC_TEST_ANY_SET(p)                               \
                            cBOOL(((regnode_ssc*)(p))->classflags)
#define ANYOF_POSIXL_SSC_TEST_ALL_SET(p) /* Are all bits set? */       \
        (((regnode_ssc*) (p))->classflags                              \
                                        == nBIT_MASK(ANYOF_POSIXL_MAX))

#define ANYOF_POSIXL_TEST_ALL_SET(p)                                   \
        ((ANYOF_FLAGS(p) & ANYOF_MATCHES_POSIXL)                       \
         && ANYOF_POSIXL_BITMAP(p) == nBIT_MASK(ANYOF_POSIXL_MAX))

#define ANYOF_POSIXL_OR(source, dest) STMT_START { (dest)->classflags |= (source)->classflags ; } STMT_END
#define ANYOF_CLASS_OR(source, dest) ANYOF_POSIXL_OR((source), (dest))

#define ANYOF_POSIXL_AND(source, dest) STMT_START { (dest)->classflags &= (source)->classflags ; } STMT_END

#define ANYOF_BITMAP_ZERO(ret)	Zero(((regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char)
#define ANYOF_BITMAP(p)		((regnode_charclass*)(p))->bitmap
#define ANYOF_BITMAP_BYTE(p, c)	BITMAP_BYTE(ANYOF_BITMAP(p), c)
#define ANYOF_BITMAP_SET(p, c)	(ANYOF_BITMAP_BYTE(p, c) |=  ANYOF_BIT(c))
#define ANYOF_BITMAP_CLEAR(p,c)	(ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c))
#define ANYOF_BITMAP_TEST(p, c)	cBOOL(ANYOF_BITMAP_BYTE(p, c) &   ANYOF_BIT(c))

#define ANYOF_BITMAP_SETALL(p)		\
        memset (ANYOF_BITMAP(p), 255, ANYOF_BITMAP_SIZE)
#define ANYOF_BITMAP_CLEARALL(p)	\
        Zero (ANYOF_BITMAP(p), ANYOF_BITMAP_SIZE)

/*
 * Utility definitions.
 */
#ifndef CHARMASK
#  define UCHARAT(p)	((int)*(const U8*)(p))
#else
#  define UCHARAT(p)	((int)*(p)&CHARMASK)
#endif

/* Number of regnode equivalents that 'guy' occupies beyond the size of the
 * smallest regnode. */
#define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))

#define REG_ZERO_LEN_SEEN                   0x00000001
#define REG_LOOKBEHIND_SEEN                 0x00000002
/* add a short form alias to keep the line length police happy */
#define REG_LB_SEEN                         REG_LOOKBEHIND_SEEN
#define REG_GPOS_SEEN                       0x00000004
/* spare */
#define REG_RECURSE_SEEN                    0x00000020
#define REG_TOP_LEVEL_BRANCHES_SEEN         0x00000040
#define REG_VERBARG_SEEN                    0x00000080
#define REG_CUTGROUP_SEEN                   0x00000100
#define REG_RUN_ON_COMMENT_SEEN             0x00000200
#define REG_UNFOLDED_MULTI_SEEN             0x00000400
/* spare */
#define REG_UNBOUNDED_QUANTIFIER_SEEN       0x00001000


START_EXTERN_C

#ifdef PLUGGABLE_RE_EXTENSION
#include "re_nodes.h"
#else
#include "regnodes.h"
#endif

#ifndef PLUGGABLE_RE_EXTENSION
#ifndef DOINIT
EXTCONST regexp_engine PL_core_reg_engine;
#else /* DOINIT */
EXTCONST regexp_engine PL_core_reg_engine = { 
        Perl_re_compile,
        Perl_regexec_flags,
        Perl_re_intuit_start,
        Perl_re_intuit_string, 
        Perl_regfree_internal,
        Perl_reg_numbered_buff_fetch,
        Perl_reg_numbered_buff_store,
        Perl_reg_numbered_buff_length,
        Perl_reg_named_buff,
        Perl_reg_named_buff_iter,
        Perl_reg_qr_package,
#if defined(USE_ITHREADS)        
        Perl_regdupe_internal,
#endif        
        Perl_re_op_compile
};
#endif /* DOINIT */
#endif /* PLUGGABLE_RE_EXTENSION */


END_EXTERN_C


/* .what is a character array with one character for each member of .data
 * The character describes the function of the corresponding .data item:
 *   a - AV for paren_name_list under DEBUGGING
 *   f - start-class data for regstclass optimization
 *   l - start op for literal (?{EVAL}) item
 *   L - start op for literal (?{EVAL}) item, with separate CV (qr//)
 *   r - pointer to an embedded code-containing qr, e.g. /ab$qr/
 *   s - inversion list for Unicode-style character class, and the
 *       multicharacter strings resulting from casefolding the single-character
 *       entries in the character class
 *   t - trie struct
 *   u - trie struct's widecharmap (a HV, so can't share, must dup)
 *       also used for revcharmap and words under DEBUGGING
 *   T - aho-trie struct
 *   S - sv for named capture lookup
 * 20010712 mjd@plover.com
 * (Remember to update re_dup() and pregfree() if you add any items.)
 */
struct reg_data {
    U32 count;
    U8 *what;
    void* data[1];
};

/* Code in S_to_utf8_substr() and S_to_byte_substr() in regexec.c accesses
   anchored* and float* via array indexes 0 and 1.  */
#define anchored_substr substrs->data[0].substr
#define anchored_utf8 substrs->data[0].utf8_substr
#define anchored_offset substrs->data[0].min_offset
#define anchored_end_shift substrs->data[0].end_shift

#define float_substr substrs->data[1].substr
#define float_utf8 substrs->data[1].utf8_substr
#define float_min_offset substrs->data[1].min_offset
#define float_max_offset substrs->data[1].max_offset
#define float_end_shift substrs->data[1].end_shift

#define check_substr substrs->data[2].substr
#define check_utf8 substrs->data[2].utf8_substr
#define check_offset_min substrs->data[2].min_offset
#define check_offset_max substrs->data[2].max_offset
#define check_end_shift substrs->data[2].end_shift

#define RX_ANCHORED_SUBSTR(rx)	(ReANY(rx)->anchored_substr)
#define RX_ANCHORED_UTF8(rx)	(ReANY(rx)->anchored_utf8)
#define RX_FLOAT_SUBSTR(rx)	(ReANY(rx)->float_substr)
#define RX_FLOAT_UTF8(rx)	(ReANY(rx)->float_utf8)

/* trie related stuff */

/* a transition record for the state machine. the
   check field determines which state "owns" the
   transition. the char the transition is for is
   determined by offset from the owning states base
   field.  the next field determines which state
   is to be transitioned to if any.
*/
struct _reg_trie_trans {
  U32 next;
  U32 check;
};

/* a transition list element for the list based representation */
struct _reg_trie_trans_list_elem {
    U16 forid;
    U32 newstate;
};
typedef struct _reg_trie_trans_list_elem reg_trie_trans_le;

/* a state for compressed nodes. base is an offset
  into an array of reg_trie_trans array. If wordnum is
  nonzero the state is accepting. if base is zero then
  the state has no children (and will be accepting)
*/
struct _reg_trie_state {
  U16 wordnum;
  union {
    U32                base;
    reg_trie_trans_le* list;
  } trans;
};

/* info per word; indexed by wordnum */
typedef struct {
    U16  prev;	/* previous word in acceptance chain; eg in
                 * zzz|abc|ab/ after matching the chars abc, the
                 * accepted word is #2, and the previous accepted
                 * word is #3 */
    U32 len;	/* how many chars long is this word? */
    U32 accept;	/* accept state for this word */
} reg_trie_wordinfo;


typedef struct _reg_trie_state    reg_trie_state;
typedef struct _reg_trie_trans    reg_trie_trans;


/* anything in here that needs to be freed later
   should be dealt with in pregfree.
   refcount is first in both this and _reg_ac_data to allow a space
   optimisation in Perl_regdupe.  */
struct _reg_trie_data {
    U32             refcount;        /* number of times this trie is referenced */
    U32             lasttrans;       /* last valid transition element */
    U16             *charmap;        /* byte to charid lookup array */
    reg_trie_state  *states;         /* state data */
    reg_trie_trans  *trans;          /* array of transition elements */
    char            *bitmap;         /* stclass bitmap */
    U16 	    *jump;           /* optional 1 indexed array of offsets before tail 
                                        for the node following a given word. */
    reg_trie_wordinfo *wordinfo;     /* array of info per word */
    U16             uniquecharcount; /* unique chars in trie (width of trans table) */
    U32             startstate;      /* initial state - used for common prefix optimisation */
    STRLEN          minlen;          /* minimum length of words in trie - build/opt only? */
    STRLEN          maxlen;          /* maximum length of words in trie - build/opt only? */
    U32             prefixlen;       /* #chars in common prefix */
    U32             statecount;      /* Build only - number of states in the states array 
                                        (including the unused zero state) */
    U32             wordcount;       /* Build only */
#ifdef DEBUGGING
    STRLEN          charcount;       /* Build only */
#endif
};
/* There is one (3 under DEBUGGING) pointers that logically belong in this
   structure, but are held outside as they need duplication on thread cloning,
   whereas the rest of the structure can be read only:
    HV              *widecharmap;    code points > 255 to charid
#ifdef DEBUGGING
    AV              *words;          Array of words contained in trie, for dumping
    AV              *revcharmap;     Map of each charid back to its character representation
#endif
*/

#define TRIE_WORDS_OFFSET 2

typedef struct _reg_trie_data reg_trie_data;

/* refcount is first in both this and _reg_trie_data to allow a space
   optimisation in Perl_regdupe.  */
struct _reg_ac_data {
    U32              refcount;
    U32              trie;
    U32              *fail;
    reg_trie_state   *states;
};
typedef struct _reg_ac_data reg_ac_data;

/* ANY_BIT doesn't use the structure, so we can borrow it here.
   This is simpler than refactoring all of it as wed end up with
   three different sets... */

#define TRIE_BITMAP(p)		(((reg_trie_data *)(p))->bitmap)
#define TRIE_BITMAP_BYTE(p, c)	BITMAP_BYTE(TRIE_BITMAP(p), c)
#define TRIE_BITMAP_SET(p, c)	(TRIE_BITMAP_BYTE(p, c) |=  ANYOF_BIT((U8)c))
#define TRIE_BITMAP_CLEAR(p,c)	(TRIE_BITMAP_BYTE(p, c) &= ~ANYOF_BIT((U8)c))
#define TRIE_BITMAP_TEST(p, c)	(TRIE_BITMAP_BYTE(p, c) &   ANYOF_BIT((U8)c))

#define IS_ANYOF_TRIE(op) ((op)==TRIEC || (op)==AHOCORASICKC)
#define IS_TRIE_AC(op) ((op)>=AHOCORASICK)


#define BITMAP_BYTE(p, c)	(( (U8*) p) [ ( ( (UV) (c)) >> 3) ] )
#define BITMAP_TEST(p, c)	(BITMAP_BYTE(p, c) &   ANYOF_BIT((U8)c))

/* these defines assume uniquecharcount is the correct variable, and state may be evaluated twice */
#define TRIE_NODENUM(state) (((state)-1)/(trie->uniquecharcount)+1)
#define SAFE_TRIE_NODENUM(state) ((state) ? (((state)-1)/(trie->uniquecharcount)+1) : (state))
#define TRIE_NODEIDX(state) ((state) ? (((state)-1)*(trie->uniquecharcount)+1) : (state))

#ifdef DEBUGGING
#define TRIE_CHARCOUNT(trie) ((trie)->charcount)
#else
#define TRIE_CHARCOUNT(trie) (trie_charcount)
#endif

#define RE_TRIE_MAXBUF_INIT 65536
#define RE_TRIE_MAXBUF_NAME "\022E_TRIE_MAXBUF"
#define RE_DEBUG_FLAGS "\022E_DEBUG_FLAGS"

#define RE_COMPILE_RECURSION_INIT 1000
#define RE_COMPILE_RECURSION_LIMIT "\022E_COMPILE_RECURSION_LIMIT"

/*

RE_DEBUG_FLAGS is used to control what debug output is emitted
its divided into three groups of options, some of which interact.
The three groups are: Compile, Execute, Extra. There is room for a
further group, as currently only the low three bytes are used.

    Compile Options:
    
    PARSE
    PEEP
    TRIE
    PROGRAM

    Execute Options:

    INTUIT
    MATCH
    TRIE

    Extra Options

    TRIE

If you modify any of these make sure you make corresponding changes to
re.pm, especially to the documentation.

*/


/* Compile */
#define RE_DEBUG_COMPILE_MASK      0x0000FF
#define RE_DEBUG_COMPILE_PARSE     0x000001
#define RE_DEBUG_COMPILE_OPTIMISE  0x000002
#define RE_DEBUG_COMPILE_TRIE      0x000004
#define RE_DEBUG_COMPILE_DUMP      0x000008
#define RE_DEBUG_COMPILE_FLAGS     0x000010
#define RE_DEBUG_COMPILE_TEST      0x000020

/* Execute */
#define RE_DEBUG_EXECUTE_MASK      0x00FF00
#define RE_DEBUG_EXECUTE_INTUIT    0x000100
#define RE_DEBUG_EXECUTE_MATCH     0x000200
#define RE_DEBUG_EXECUTE_TRIE      0x000400

/* Extra */
#define RE_DEBUG_EXTRA_MASK              0x3FF0000
#define RE_DEBUG_EXTRA_TRIE              0x0010000
#define RE_DEBUG_EXTRA_STATE             0x0080000
#define RE_DEBUG_EXTRA_OPTIMISE          0x0100000
#define RE_DEBUG_EXTRA_BUFFERS           0x0400000
#define RE_DEBUG_EXTRA_GPOS              0x0800000
#define RE_DEBUG_EXTRA_DUMP_PRE_OPTIMIZE 0x1000000
#define RE_DEBUG_EXTRA_WILDCARD          0x2000000
/* combined */
#define RE_DEBUG_EXTRA_STACK             0x0280000

#define RE_DEBUG_FLAG(x) (re_debug_flags & (x))
/* Compile */
#define DEBUG_COMPILE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_MASK)) x  )
#define DEBUG_PARSE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_PARSE)) x  )
#define DEBUG_OPTIMISE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_OPTIMISE)) x  )
#define DEBUG_DUMP_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_DUMP)) x  )
#define DEBUG_TRIE_COMPILE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_TRIE)) x )
#define DEBUG_FLAGS_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_FLAGS)) x )
#define DEBUG_TEST_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_TEST)) x )
/* Execute */
#define DEBUG_EXECUTE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXECUTE_MASK)) x  )
#define DEBUG_INTUIT_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXECUTE_INTUIT)) x  )
#define DEBUG_MATCH_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXECUTE_MATCH)) x  )
#define DEBUG_TRIE_EXECUTE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXECUTE_TRIE)) x )

/* Extra */
#define DEBUG_EXTRA_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_MASK)) x  )
#define DEBUG_STATE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_STATE)) x )
#define DEBUG_STACK_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_STACK)) x )
#define DEBUG_BUFFERS_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_BUFFERS)) x )

#define DEBUG_OPTIMISE_MORE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || ((RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE) == \
         RE_DEBUG_FLAG(RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE))) x )
#define DEBUG_TRIE_COMPILE_MORE_r(x) DEBUG_TRIE_COMPILE_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_TRIE)) x )
#define DEBUG_TRIE_EXECUTE_MORE_r(x) DEBUG_TRIE_EXECUTE_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_TRIE)) x )

#define DEBUG_TRIE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_COMPILE_TRIE \
        | RE_DEBUG_EXECUTE_TRIE )) x )
#define DEBUG_GPOS_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_GPOS)) x )

#define DEBUG_DUMP_PRE_OPTIMIZE_r(x) DEBUG_r( \
    if (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_DUMP_PRE_OPTIMIZE)) x )

/* initialization */
/* Get the debug flags for code not in regcomp.c nor regexec.c.  This doesn't
 * initialize the variable if it isn't already there, instead it just assumes
 * the flags are 0 */
#define DECLARE_AND_GET_RE_DEBUG_FLAGS_NON_REGEX                               \
    volatile IV re_debug_flags = 0;  PERL_UNUSED_VAR(re_debug_flags);          \
    STMT_START {                                                               \
        SV * re_debug_flags_sv = NULL;                                         \
                     /* get_sv() can return NULL during global destruction. */ \
        re_debug_flags_sv = PL_curcop ? get_sv(RE_DEBUG_FLAGS, GV_ADD) : NULL; \
        if (re_debug_flags_sv && SvIOK(re_debug_flags_sv))                     \
            re_debug_flags=SvIV(re_debug_flags_sv);                            \
    } STMT_END


#ifdef DEBUGGING

/* For use in regcomp.c and regexec.c,  Get the debug flags, and initialize to
 * the defaults if not done already */
#define DECLARE_AND_GET_RE_DEBUG_FLAGS                                         \
    volatile IV re_debug_flags = 0;  PERL_UNUSED_VAR(re_debug_flags);          \
    DEBUG_r({                              \
        SV * re_debug_flags_sv = NULL;                                         \
                     /* get_sv() can return NULL during global destruction. */ \
        re_debug_flags_sv = PL_curcop ? get_sv(RE_DEBUG_FLAGS, GV_ADD) : NULL; \
        if (re_debug_flags_sv) {                                               \
            if (!SvIOK(re_debug_flags_sv)) /* If doesnt exist set to default */\
                sv_setuv(re_debug_flags_sv,                                    \
                        /* These defaults should be kept in sync with re.pm */ \
                            RE_DEBUG_COMPILE_DUMP | RE_DEBUG_EXECUTE_MASK );   \
            re_debug_flags=SvIV(re_debug_flags_sv);                            \
        }                                                                      \
    })

#define isDEBUG_WILDCARD (DEBUG_v_TEST || RE_DEBUG_FLAG(RE_DEBUG_EXTRA_WILDCARD))

#define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2)   \
    const char * const rpv =                                \
        pv_pretty((dsv), (pv), (l), (m),                    \
            PL_colors[(c1)],PL_colors[(c2)],                \
            PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) );         \
    const int rlen = SvCUR(dsv)

/* This is currently unsed in the core */
#define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m)                            \
    const char * const rpv =                                        \
        pv_pretty((dsv), (SvPV_nolen_const(sv)), (SvCUR(sv)), (m),  \
            PL_colors[(c1)],PL_colors[(c2)],                        \
            PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) )

#define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m)                     \
    const char * const rpv =                                        \
        pv_pretty((dsv), (pv), (l), (m),                            \
            PL_colors[0], PL_colors[1],                             \
            ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_ESCAPE_NONASCII | PERL_PV_PRETTY_ELLIPSES | \
              ((isuni) ? PERL_PV_ESCAPE_UNI : 0))                  \
        )

#define RE_SV_DUMPLEN(ItEm) (SvCUR(ItEm) - (SvTAIL(ItEm)!=0))
#define RE_SV_TAIL(ItEm) (SvTAIL(ItEm) ? "$" : "")
    
#else /* if not DEBUGGING */

#define DECLARE_AND_GET_RE_DEBUG_FLAGS  dNOOP
#define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2)  dNOOP
#define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m)
#define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m)  dNOOP
#define RE_SV_DUMPLEN(ItEm)
#define RE_SV_TAIL(ItEm)
#define isDEBUG_WILDCARD 0

#endif /* DEBUG RELATED DEFINES */

#define FIRST_NON_ASCII_DECIMAL_DIGIT 0x660  /* ARABIC_INDIC_DIGIT_ZERO */

typedef enum {
        TRADITIONAL_BOUND = _CC_WORDCHAR,
        GCB_BOUND,
        LB_BOUND,
        SB_BOUND,
        WB_BOUND
} bound_type;

/* This unpacks the FLAGS field of ANYOF[HR]x nodes.  The value it contains
 * gives the strict lower bound for the UTF-8 start byte of any code point
 * matchable by the node, and a loose upper bound as well.
 *
 * The low bound is stored as 0xC0 + ((the upper 6 bits) >> 2)
 * The loose upper bound is determined from the lowest 2 bits and the low bound
 * (called x) as follows:
 *
 * 11  The upper limit of the range can be as much as (EF - x) / 8
 * 10  The upper limit of the range can be as much as (EF - x) / 4
 * 01  The upper limit of the range can be as much as (EF - x) / 2
 * 00  The upper limit of the range can be as much as  EF
 *
 * For motivation of this design, see commit message in
 * 3146c00a633e9cbed741e10146662fbcedfdb8d3 */
#ifdef EBCDIC
#  define MAX_ANYOF_HRx_BYTE  0xF4
#else
#  define MAX_ANYOF_HRx_BYTE  0xEF
#endif
#define LOWEST_ANYOF_HRx_BYTE(b) (((b) >> 2) + 0xC0)
#define HIGHEST_ANYOF_HRx_BYTE(b)                                           \
                                  (LOWEST_ANYOF_HRx_BYTE(b)                 \
          + ((MAX_ANYOF_HRx_BYTE - LOWEST_ANYOF_HRx_BYTE(b)) >> ((b) & 3)))

#endif /* PERL_REGCOMP_H_ */

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                         /*    regexp.h
 *
 *    Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003,
 *    2005, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/*
 * Definitions etc. for regexp(3) routines.
 *
 * Caveat:  this is V8 regexp(3) [actually, a reimplementation thereof],
 * not the System V one.
 */
#ifndef PLUGGABLE_RE_EXTENSION
/* we don't want to include this stuff if we are inside of
   an external regex engine based on the core one - like re 'debug'*/

#  include "utf8.h"

typedef SSize_t regnode_offset;

struct regnode {
    U8	flags;
    U8  type;
    U16 next_off;
};

typedef struct regnode regnode;

struct reg_substr_data;

struct reg_data;

struct regexp_engine;
struct regexp;

struct reg_substr_datum {
    SSize_t min_offset; /* min pos (in chars) that substr must appear */
    SSize_t max_offset  /* max pos (in chars) that substr must appear */;
    SV *substr;		/* non-utf8 variant */
    SV *utf8_substr;	/* utf8 variant */
    SSize_t end_shift;  /* how many fixed chars must end the string */
};
struct reg_substr_data {
    U8      check_ix;   /* index into data[] of check substr */
    struct reg_substr_datum data[3];	/* Actual array */
};

#  ifdef PERL_ANY_COW
#    define SV_SAVED_COPY   SV *saved_copy; /* If non-NULL, SV which is COW from original */
#  else
#    define SV_SAVED_COPY
#  endif

/* offsets within a string of a particular /(.)/ capture */

typedef struct regexp_paren_pair {
    SSize_t start;
    SSize_t end;
    /* 'start_tmp' records a new opening position before the matching end
     * has been found, so that the old start and end values are still
     * valid, e.g.
     *	  "abc" =~ /(.(?{print "[$1]"}))+/
     *outputs [][a][b]
     * This field is not part of the API.  */
    SSize_t start_tmp;
} regexp_paren_pair;

#  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
#    define _invlist_union(a, b, output) _invlist_union_maybe_complement_2nd(a, b, FALSE, output)
#    define _invlist_intersection(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, FALSE, output)

/* Subtracting b from a leaves in a everything that was there that isn't in b,
 * that is the intersection of a with b's complement */
#    define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output)
#  endif

/* record the position of a (?{...}) within a pattern */

struct reg_code_block {
    STRLEN start;
    STRLEN end;
    OP     *block;
    REGEXP *src_regex;
};

/* array of reg_code_block's plus header info */

struct reg_code_blocks {
    int refcnt; /* we may be pointed to from a regex and from the savestack */
    int  count;    /* how many code blocks */
    struct reg_code_block *cb; /* array of reg_code_block's */
};


/*
= for apidoc AyT||regexp
  The regexp/REGEXP struct, see L<perlreapi> for further documentation
  on the individual fields. The struct is ordered so that the most
  commonly used fields are placed at the start.

  Any patch that adds items to this struct will need to include
  changes to F<sv.c> (C<Perl_re_dup()>) and F<regcomp.c>
  (C<pregfree()>). This involves freeing or cloning items in the
  regexp's data array based on the data item's type.
*/

typedef struct regexp {
    _XPV_HEAD;
    const struct regexp_engine* engine; /* what engine created this regexp? */
    REGEXP *mother_re; /* what re is this a lightweight copy of? */
    HV *paren_names;   /* Optional hash of paren names */

    /*----------------------------------------------------------------------
     * Information about the match that the perl core uses to manage things
     */

    U32 extflags;      /* Flags used both externally and internally */
    U32 nparens;       /* number of capture buffers */
    SSize_t minlen;    /* minimum possible number of chars in string to match */
    SSize_t minlenret; /* mininum possible number of chars in $& */
    STRLEN gofs;       /* chars left of pos that we search from */
                       /* substring data about strings that must appear in
                        * the final match, used for optimisations */
    struct reg_substr_data *substrs;

    /* private engine specific data */

    void *pprivate;    /* Data private to the regex engine which
                        * created this object. */
    U32 intflags;      /* Engine Specific Internal flags */

    /*----------------------------------------------------------------------
     * Data about the last/current match. These are modified during matching
     */

    U32 lastparen;           /* highest close paren matched ($+) */
    regexp_paren_pair *offs; /* Array of offsets for (@-) and (@+) */
    char **recurse_locinput; /* used to detect infinite recursion, XXX: move to internal */
    U32 lastcloseparen;      /* last close paren matched ($^N) */

    /*---------------------------------------------------------------------- */

    /* offset from wrapped to the start of precomp */
    PERL_BITFIELD32 pre_prefix:4;

    /* original flags used to compile the pattern, may differ from
     * extflags in various ways */
    PERL_BITFIELD32 compflags:9;

    /*---------------------------------------------------------------------- */

    char *subbeg;       /* saved or original string so \digit works forever. */
    SV_SAVED_COPY       /* If non-NULL, SV which is COW from original */
    SSize_t sublen;     /* Length of string pointed by subbeg */
    SSize_t suboffset;  /* byte offset of subbeg from logical start of str */
    SSize_t subcoffset; /* suboffset equiv, but in chars (for @-/@+) */
    SSize_t maxlen;  /* minimum possible number of chars in string to match */

    /*---------------------------------------------------------------------- */


    CV *qr_anoncv;      /* the anon sub wrapped round qr/(?{..})/ */
} regexp;


#  define RXp_PAREN_NAMES(rx)	((rx)->paren_names)

/* used for high speed searches */
typedef struct re_scream_pos_data_s
{
    char **scream_olds;		/* match pos */
    SSize_t *scream_pos;	/* Internal iterator of scream. */
} re_scream_pos_data;

/* regexp_engine structure. This is the dispatch table for regexes.
 * Any regex engine implementation must be able to build one of these.
 */
typedef struct regexp_engine {
    REGEXP* (*comp) (pTHX_ SV * const pattern, U32 flags);
    I32     (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend,
                     char* strbeg, SSize_t minend, SV* sv,
                     void* data, U32 flags);
    char*   (*intuit) (pTHX_
                        REGEXP * const rx,
                        SV *sv,
                        const char * const strbeg,
                        char *strpos,
                        char *strend,
                        const U32 flags,
                       re_scream_pos_data *data);
    SV*     (*checkstr) (pTHX_ REGEXP * const rx);
    void    (*rxfree) (pTHX_ REGEXP * const rx);
    void    (*numbered_buff_FETCH) (pTHX_ REGEXP * const rx, const I32 paren,
                                    SV * const sv);
    void    (*numbered_buff_STORE) (pTHX_ REGEXP * const rx, const I32 paren,
                                   SV const * const value);
    I32     (*numbered_buff_LENGTH) (pTHX_ REGEXP * const rx, const SV * const sv,
                                    const I32 paren);
    SV*     (*named_buff) (pTHX_ REGEXP * const rx, SV * const key,
                           SV * const value, const U32 flags);
    SV*     (*named_buff_iter) (pTHX_ REGEXP * const rx, const SV * const lastkey,
                                const U32 flags);
    SV*     (*qr_package)(pTHX_ REGEXP * const rx);
#  ifdef USE_ITHREADS
    void*   (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param);
#  endif
    REGEXP* (*op_comp) (pTHX_ SV ** const patternp, int pat_count,
                    OP *expr, const struct regexp_engine* eng,
                    REGEXP *old_re,
                    bool *is_bare_re, U32 orig_rx_flags, U32 pm_flags);
} regexp_engine;

/*
  These are passed to the numbered capture variable callbacks as the
  paren name. >= 1 is reserved for actual numbered captures, i.e. $1,
  $2 etc.
*/
#  define RX_BUFF_IDX_CARET_PREMATCH  -5 /* ${^PREMATCH}  */
#  define RX_BUFF_IDX_CARET_POSTMATCH -4 /* ${^POSTMATCH} */
#  define RX_BUFF_IDX_CARET_FULLMATCH -3 /* ${^MATCH}     */
#  define RX_BUFF_IDX_PREMATCH        -2 /* $` */
#  define RX_BUFF_IDX_POSTMATCH       -1 /* $' */
#  define RX_BUFF_IDX_FULLMATCH        0 /* $& */

/*
  Flags that are passed to the named_buff and named_buff_iter
  callbacks above. Those routines are called from universal.c via the
  Tie::Hash::NamedCapture interface for %+ and %- and the re::
  functions in the same file.
*/

/* The Tie::Hash::NamedCapture operation this is part of, if any */
#  define RXapif_FETCH     0x0001
#  define RXapif_STORE     0x0002
#  define RXapif_DELETE    0x0004
#  define RXapif_CLEAR     0x0008
#  define RXapif_EXISTS    0x0010
#  define RXapif_SCALAR    0x0020
#  define RXapif_FIRSTKEY  0x0040
#  define RXapif_NEXTKEY   0x0080

/* Whether %+ or %- is being operated on */
#  define RXapif_ONE       0x0100 /* %+ */
#  define RXapif_ALL       0x0200 /* %- */

/* Whether this is being called from a re:: function */
#  define RXapif_REGNAME         0x0400
#  define RXapif_REGNAMES        0x0800
#  define RXapif_REGNAMES_COUNT  0x1000

/*
=for apidoc Am|REGEXP *|SvRX|SV *sv

Convenience macro to get the REGEXP from a SV.  This is approximately
equivalent to the following snippet:

    if (SvMAGICAL(sv))
        mg_get(sv);
    if (SvROK(sv))
        sv = MUTABLE_SV(SvRV(sv));
    if (SvTYPE(sv) == SVt_REGEXP)
        return (REGEXP*) sv;

C<NULL> will be returned if a REGEXP* is not found.

=for apidoc Am|bool|SvRXOK|SV* sv

Returns a boolean indicating whether the SV (or the one it references)
is a REGEXP.

If you want to do something with the REGEXP* later use SvRX instead
and check for NULL.

=cut
*/

#  define SvRX(sv)   (Perl_get_re_arg(aTHX_ sv))
#  define SvRXOK(sv) cBOOL(Perl_get_re_arg(aTHX_ sv))


/* Flags stored in regexp->extflags
 * These are used by code external to the regexp engine
 *
 * Note that the flags whose names start with RXf_PMf_ are defined in
 * op_reg_common.h, being copied from the parallel flags of op_pmflags
 *
 * NOTE: if you modify any RXf flags you should run regen.pl or
 * regen/regcomp.pl so that regnodes.h is updated with the changes.
 *
 */

#  include "op_reg_common.h"

#  define RXf_PMf_STD_PMMOD	(RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE|RXf_PMf_NOCAPTURE)

#  define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl, x_count)                       \
    case IGNORE_PAT_MOD:    *(pmfl) |= RXf_PMf_FOLD;       break;           \
    case MULTILINE_PAT_MOD: *(pmfl) |= RXf_PMf_MULTILINE;  break;           \
    case SINGLE_PAT_MOD:    *(pmfl) |= RXf_PMf_SINGLELINE; break;           \
    case XTENDED_PAT_MOD:   if (x_count == 0) {                             \
                                *(pmfl) |= RXf_PMf_EXTENDED;                \
                                *(pmfl) &= ~RXf_PMf_EXTENDED_MORE;          \
                            }                                               \
                            else {                                          \
                                *(pmfl) |= RXf_PMf_EXTENDED                 \
                                          |RXf_PMf_EXTENDED_MORE;           \
                            }                                               \
                            (x_count)++; break;                             \
    case NOCAPTURE_PAT_MOD: *(pmfl) |= RXf_PMf_NOCAPTURE; break;

/* Note, includes charset ones, assumes 0 is the default for them */
#  define STD_PMMOD_FLAGS_CLEAR(pmfl)                        \
    *(pmfl) &= ~(RXf_PMf_FOLD|RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE|RXf_PMf_CHARSET|RXf_PMf_NOCAPTURE)

/* chars and strings used as regex pattern modifiers
 * Singular is a 'c'har, plural is a "string"
 *
 * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve
 * for compatibility reasons with Regexp::Common which highjacked (?k:...)
 * for its own uses. So 'k' is out as well.
 */
#  define DEFAULT_PAT_MOD      '^'    /* Short for all the default modifiers */
#  define EXEC_PAT_MOD         'e'
#  define KEEPCOPY_PAT_MOD     'p'
#  define NOCAPTURE_PAT_MOD    'n'
#  define ONCE_PAT_MOD         'o'
#  define GLOBAL_PAT_MOD       'g'
#  define CONTINUE_PAT_MOD     'c'
#  define MULTILINE_PAT_MOD    'm'
#  define SINGLE_PAT_MOD       's'
#  define IGNORE_PAT_MOD       'i'
#  define XTENDED_PAT_MOD      'x'
#  define NONDESTRUCT_PAT_MOD  'r'
#  define LOCALE_PAT_MOD       'l'
#  define UNICODE_PAT_MOD      'u'
#  define DEPENDS_PAT_MOD      'd'
#  define ASCII_RESTRICT_PAT_MOD 'a'

#  define ONCE_PAT_MODS        "o"
#  define KEEPCOPY_PAT_MODS    "p"
#  define NOCAPTURE_PAT_MODS   "n"
#  define EXEC_PAT_MODS        "e"
#  define LOOP_PAT_MODS        "gc"
#  define NONDESTRUCT_PAT_MODS "r"
#  define LOCALE_PAT_MODS      "l"
#  define UNICODE_PAT_MODS     "u"
#  define DEPENDS_PAT_MODS     "d"
#  define ASCII_RESTRICT_PAT_MODS "a"
#  define ASCII_MORE_RESTRICT_PAT_MODS "aa"

/* This string is expected by regcomp.c to be ordered so that the first
 * character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of extflags; the next
 * character is bit +1, etc. */
#  define STD_PAT_MODS        "msixxn"

#  define CHARSET_PAT_MODS    ASCII_RESTRICT_PAT_MODS DEPENDS_PAT_MODS LOCALE_PAT_MODS UNICODE_PAT_MODS

/* This string is expected by XS_re_regexp_pattern() in universal.c to be ordered
 * so that the first character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of
 * extflags; the next character is in bit +1, etc. */
#  define INT_PAT_MODS    STD_PAT_MODS    KEEPCOPY_PAT_MODS

#  define EXT_PAT_MODS    ONCE_PAT_MODS   KEEPCOPY_PAT_MODS  NOCAPTURE_PAT_MODS
#  define QR_PAT_MODS     STD_PAT_MODS    EXT_PAT_MODS	   CHARSET_PAT_MODS
#  define M_PAT_MODS      QR_PAT_MODS     LOOP_PAT_MODS
#  define S_PAT_MODS      M_PAT_MODS      EXEC_PAT_MODS      NONDESTRUCT_PAT_MODS

/*
 * NOTE: if you modify any RXf flags you should run regen.pl or
 * regen/regcomp.pl so that regnodes.h is updated with the changes.
 *
 */

/*
  Set in Perl_pmruntime for a split. Will be used by regex engines to
  check whether they should set RXf_SKIPWHITE
*/
#  define RXf_SPLIT   RXf_PMf_SPLIT

/* Currently the regex flags occupy a single 32-bit word.  Not all bits are
 * currently used.  The lower bits are shared with their corresponding PMf flag
 * bits, up to but not including _RXf_PMf_SHIFT_NEXT.  The unused bits
 * immediately follow; finally the used RXf-only (unshared) bits, so that the
 * highest bit in the word is used.  This gathers all the unused bits as a pool
 * in the middle, like so: 11111111111111110000001111111111
 * where the '1's represent used bits, and the '0's unused.  This design allows
 * us to allocate off one end of the pool if we need to add a shared bit, and
 * off the other end if we need a non-shared bit, without disturbing the other
 * bits.  This maximizes the likelihood of being able to change things without
 * breaking binary compatibility.
 *
 * To add shared bits, do so in op_reg_common.h.  This should change
 * _RXf_PMf_SHIFT_NEXT so that things won't compile.  Then come to regexp.h and
 * op.h and adjust the constant adders in the definitions of RXf_BASE_SHIFT and
 * Pmf_BASE_SHIFT down by the number of shared bits you added.  That's it.
 * Things should be binary compatible.  But if either of these gets to having
 * to subtract rather than add, leave at 0 and instead adjust all the entries
 * that are in terms of it.  But if the first one of those is already
 * RXf_BASE_SHIFT+0, there are no bits left, and a redesign is in order.
 *
 * To remove unshared bits, just delete its entry.  If you're where breaking
 * binary compatibility is ok to do, you might want to adjust things to move
 * the newly opened space so that it gets absorbed into the common pool.
 *
 * To add unshared bits, first use up any gaps in the middle.  Otherwise,
 * allocate off the low end until you get to RXf_BASE_SHIFT+0.  If that isn't
 * enough, move RXf_BASE_SHIFT down (if possible) and add the new bit at the
 * other end instead; this preserves binary compatibility.
 *
 * For the regexp bits, PL_reg_extflags_name[] in regnodes.h has a comment
 * giving which bits are used/unused */

#  define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT + 2)

/* What we have seen */
#  define RXf_NO_INPLACE_SUBST  (1U<<(RXf_BASE_SHIFT+2))
#  define RXf_EVAL_SEEN   	(1U<<(RXf_BASE_SHIFT+3))

/* Special */
#  define RXf_UNBOUNDED_QUANTIFIER_SEEN   (1U<<(RXf_BASE_SHIFT+4))
#  define RXf_CHECK_ALL   	(1U<<(RXf_BASE_SHIFT+5))

/* UTF8 related */
#  define RXf_MATCH_UTF8  	(1U<<(RXf_BASE_SHIFT+6)) /* $1 etc are utf8 */

/* Intuit related */
#  define RXf_USE_INTUIT_NOML	(1U<<(RXf_BASE_SHIFT+7))
#  define RXf_USE_INTUIT_ML	(1U<<(RXf_BASE_SHIFT+8))
#  define RXf_INTUIT_TAIL 	(1U<<(RXf_BASE_SHIFT+9))
#  define RXf_USE_INTUIT        (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML)

/* Do we have some sort of anchor? */
#  define RXf_IS_ANCHORED       (1U<<(RXf_BASE_SHIFT+10))

/* Copy and tainted info */
#  define RXf_COPY_DONE   	(1U<<(RXf_BASE_SHIFT+11))

/* post-execution: $1 et al are tainted */
#  define RXf_TAINTED_SEEN	(1U<<(RXf_BASE_SHIFT+12))
/* this pattern was tainted during compilation */
#  define RXf_TAINTED		(1U<<(RXf_BASE_SHIFT+13))

/* Flags indicating special patterns */
#  define RXf_START_ONLY        (1U<<(RXf_BASE_SHIFT+14)) /* Pattern is /^/ */
#  define RXf_SKIPWHITE         (1U<<(RXf_BASE_SHIFT+15)) /* Pattern is for a */
                                                          /* split " " */
#  define RXf_WHITE		(1U<<(RXf_BASE_SHIFT+16)) /* Pattern is /\s+/ */
#  define RXf_NULL		(1U<<(RXf_BASE_SHIFT+17)) /* Pattern is // */

/* See comments at the beginning of these defines about adding bits.  The
 * highest bit position should be used, so that if RXf_BASE_SHIFT gets
 * increased, the #error below will be triggered so that you will be reminded
 * to adjust things at the other end to keep the bit positions unchanged */
#  if RXf_BASE_SHIFT+17 > 31
#     error Too many RXf_PMf bits used.  See comments at beginning of these for what to do
#  endif

/*
 * NOTE: if you modify any RXf flags you should run regen.pl or
 * regen/regcomp.pl so that regnodes.h is updated with the changes.
 *
 */

#  ifdef NO_TAINT_SUPPORT
#    define RX_ISTAINTED(rx_sv)           0
#    define RXp_ISTAINTED(prog)           0
#    define RX_TAINT_on(rx_sv)            NOOP
#    define RXp_MATCH_TAINTED(prog)       0
#    define RX_MATCH_TAINTED(rx_sv)       0
#    define RXp_MATCH_TAINTED_on(prog)    NOOP
#    define RX_MATCH_TAINTED_on(rx_sv)    NOOP
#    define RXp_MATCH_TAINTED_off(prog)   NOOP
#    define RX_MATCH_TAINTED_off(rx_sv)   NOOP
#  else
#    define RX_ISTAINTED(rx_sv)           (RX_EXTFLAGS(rx_sv) & RXf_TAINTED)
#    define RXp_ISTAINTED(prog)           (RXp_EXTFLAGS(prog) & RXf_TAINTED)
#    define RX_TAINT_on(rx_sv)            (RX_EXTFLAGS(rx_sv) |= RXf_TAINTED)
#    define RXp_MATCH_TAINTED(prog)       (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN)
#    define RX_MATCH_TAINTED(rx_sv)       (RX_EXTFLAGS(rx_sv) & RXf_TAINTED_SEEN)
#    define RXp_MATCH_TAINTED_on(prog)    (RXp_EXTFLAGS(prog) |= RXf_TAINTED_SEEN)
#    define RX_MATCH_TAINTED_on(rx_sv)    (RX_EXTFLAGS(rx_sv) |= RXf_TAINTED_SEEN)
#    define RXp_MATCH_TAINTED_off(prog)   (RXp_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN)
#    define RX_MATCH_TAINTED_off(rx_sv)   (RX_EXTFLAGS(rx_sv) &= ~RXf_TAINTED_SEEN)
#  endif

#  define RXp_HAS_CUTGROUP(prog)          ((prog)->intflags & PREGf_CUTGROUP_SEEN)

#  define RX_MATCH_TAINTED_set(rx_sv, t)  ((t) \
                                        ? RX_MATCH_TAINTED_on(rx_sv) \
                                        : RX_MATCH_TAINTED_off(rx_sv))

#  define RXp_MATCH_COPIED(prog)          (RXp_EXTFLAGS(prog) & RXf_COPY_DONE)
#  define RX_MATCH_COPIED(rx_sv)          (RX_EXTFLAGS(rx_sv) & RXf_COPY_DONE)
#  define RXp_MATCH_COPIED_on(prog)       (RXp_EXTFLAGS(prog) |= RXf_COPY_DONE)
#  define RX_MATCH_COPIED_on(rx_sv)       (RX_EXTFLAGS(rx_sv) |= RXf_COPY_DONE)
#  define RXp_MATCH_COPIED_off(prog)      (RXp_EXTFLAGS(prog) &= ~RXf_COPY_DONE)
#  define RX_MATCH_COPIED_off(rx_sv)      (RX_EXTFLAGS(rx_sv) &= ~RXf_COPY_DONE)
#  define RX_MATCH_COPIED_set(rx_sv,t)    ((t) \
                                         ? RX_MATCH_COPIED_on(rx_sv) \
                                         : RX_MATCH_COPIED_off(rx_sv))

#  define RXp_EXTFLAGS(rx)                ((rx)->extflags)
#  define RXp_COMPFLAGS(rx)               ((rx)->compflags)

/* For source compatibility. We used to store these explicitly.  */
#  define RX_PRECOMP(rx_sv)              (RX_WRAPPED(rx_sv) \
                                            + ReANY(rx_sv)->pre_prefix)
#  define RX_PRECOMP_const(rx_sv)        (RX_WRAPPED_const(rx_sv) \
                                            + ReANY(rx_sv)->pre_prefix)
/* FIXME? Are we hardcoding too much here and constraining plugin extension
   writers? Specifically, the value 1 assumes that the wrapped version always
   has exactly one character at the end, a ')'. Will that always be true?  */
#  define RX_PRELEN(rx_sv)                (RX_WRAPLEN(rx_sv) \
                                            - ReANY(rx_sv)->pre_prefix - 1)

#  define RX_WRAPPED(rx_sv)               SvPVX(rx_sv)
#  define RX_WRAPPED_const(rx_sv)         SvPVX_const(rx_sv)
#  define RX_WRAPLEN(rx_sv)               SvCUR(rx_sv)
#  define RX_CHECK_SUBSTR(rx_sv)          (ReANY(rx_sv)->check_substr)
#  define RX_REFCNT(rx_sv)                SvREFCNT(rx_sv)
#  define RX_EXTFLAGS(rx_sv)              RXp_EXTFLAGS(ReANY(rx_sv))
#  define RX_COMPFLAGS(rx_sv)             RXp_COMPFLAGS(ReANY(rx_sv))
#  define RXp_ENGINE(prog)                ((prog)->engine)
#  define RX_ENGINE(rx_sv)                (RXp_ENGINE(ReANY(rx_sv)))
#  define RXp_SUBBEG(prog)                (prog->subbeg)
#  define RX_SUBBEG(rx_sv)                (RXp_SUBBEG(ReANY(rx_sv)))
#  define RXp_SUBOFFSET(prog)             (prog->suboffset)
#  define RX_SUBOFFSET(rx_sv)             (RXp_SUBOFFSET(ReANY(rx_sv)))
#  define RX_SUBCOFFSET(rx_sv)            (ReANY(rx_sv)->subcoffset)
#  define RXp_OFFS(prog)                  (prog->offs)
#  define RX_OFFS(rx_sv)                  (RXp_OFFS(ReANY(rx_sv)))
#  define RXp_NPARENS(prog)               (prog->nparens)
#  define RX_NPARENS(rx_sv)               (RXp_NPARENS(ReANY(rx_sv)))
#  define RX_SUBLEN(rx_sv)                (ReANY(rx_sv)->sublen)
#  define RXp_MINLEN(prog)                (prog->minlen)
#  define RX_MINLEN(rx_sv)                (RXp_MINLEN(ReANY(rx_sv)))
#  define RXp_MINLENRET(prog)             (prog->minlenret)
#  define RX_MINLENRET(rx_sv)             (RXp_MINLENRET(ReANY(rx_sv)))
#  define RXp_GOFS(prog)                  (prog->gofs)
#  define RX_GOFS(rx_sv)                  (RXp_GOFS(ReANY(rx_sv)))
#  define RX_LASTPAREN(rx_sv)             (ReANY(rx_sv)->lastparen)
#  define RX_LASTCLOSEPAREN(rx_sv)        (ReANY(rx_sv)->lastcloseparen)
#  define RXp_SAVED_COPY(prog)            (prog->saved_copy)
#  define RX_SAVED_COPY(rx_sv)            (RXp_SAVED_COPY(ReANY(rx_sv)))
/* last match was zero-length */
#  define RXp_ZERO_LEN(prog) \
        (RXp_OFFS(prog)[0].start + (SSize_t)RXp_GOFS(prog) \
          == RXp_OFFS(prog)[0].end)
#  define RX_ZERO_LEN(rx_sv)              (RXp_ZERO_LEN(ReANY(rx_sv)))

#endif /* PLUGGABLE_RE_EXTENSION */

/* Stuff that needs to be included in the pluggable extension goes below here */

#ifdef PERL_ANY_COW
#  define RXp_MATCH_COPY_FREE(prog) \
        STMT_START {if (RXp_SAVED_COPY(prog)) { \
            SV_CHECK_THINKFIRST_COW_DROP(RXp_SAVED_COPY(prog)); \
        } \
        if (RXp_MATCH_COPIED(prog)) { \
            Safefree(RXp_SUBBEG(prog)); \
            RXp_MATCH_COPIED_off(prog); \
        }} STMT_END
#else
#  define RXp_MATCH_COPY_FREE(prog) \
        STMT_START {if (RXp_MATCH_COPIED(prog)) { \
            Safefree(RXp_SUBBEG(prog)); \
            RXp_MATCH_COPIED_off(prog); \
        }} STMT_END
#endif
#define RX_MATCH_COPY_FREE(rx_sv)       RXp_MATCH_COPY_FREE(ReANY(rx_sv))

#define RXp_MATCH_UTF8(prog)            (RXp_EXTFLAGS(prog) & RXf_MATCH_UTF8)
#define RX_MATCH_UTF8(rx_sv)            (RX_EXTFLAGS(rx_sv) & RXf_MATCH_UTF8)
#define RXp_MATCH_UTF8_on(prog)         (RXp_EXTFLAGS(prog) |= RXf_MATCH_UTF8)
#define RX_MATCH_UTF8_on(rx_sv)         (RXp_MATCH_UTF8_on(ReANY(rx_sv)))
#define RXp_MATCH_UTF8_off(prog)        (RXp_EXTFLAGS(prog) &= ~RXf_MATCH_UTF8)
#define RX_MATCH_UTF8_off(rx_sv)        (RXp_MATCH_UTF8_off(ReANY(rx_sv))
#define RXp_MATCH_UTF8_set(prog, t)     ((t) \
                                        ? RXp_MATCH_UTF8_on(prog) \
                                        : RXp_MATCH_UTF8_off(prog))
#define RX_MATCH_UTF8_set(rx_sv, t)     (RXp_MATCH_UTF8_set(ReANY(rx_sv), t))

/* Whether the pattern stored at RX_WRAPPED is in UTF-8  */
#define RX_UTF8(rx_sv)                  SvUTF8(rx_sv)


/* bits in flags arg of Perl_regexec_flags() */

#define REXEC_COPY_STR  0x01    /* Need to copy the string for captures. */
#define REXEC_CHECKED   0x02    /* re_intuit_start() already called. */
#define REXEC_SCREAM    0x04    /* currently unused. */
#define REXEC_IGNOREPOS 0x08    /* use stringarg, not pos(), for \G match */
#define REXEC_NOT_FIRST 0x10    /* This is another iteration of //g:
                                   no need to copy string again */

                                     /* under REXEC_COPY_STR, it's ok for the
                                        engine (modulo PL_sawamperand etc)
                                        to skip copying: ... */
#define REXEC_COPY_SKIP_PRE  0x20    /* ...the $` part of the string, or */
#define REXEC_COPY_SKIP_POST 0x40    /* ...the $' part of the string */
#define REXEC_FAIL_ON_UNDERFLOW 0x80 /* fail the match if $& would start before
                                        the start pos (so s/.\G// would fail
                                        on second iteration */

#if defined(PERL_USE_GCC_BRACE_GROUPS)
#  define ReREFCNT_inc(re)						\
    ({									\
        /* This is here to generate a casting warning if incorrect.  */	\
        REGEXP *const _rerefcnt_inc = (re);				\
        assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP);			\
        SvREFCNT_inc(_rerefcnt_inc);					\
        _rerefcnt_inc;							\
    })
#  define ReREFCNT_dec(re)						\
    ({									\
        /* This is here to generate a casting warning if incorrect.  */	\
        REGEXP *const _rerefcnt_dec = (re);				\
        SvREFCNT_dec(_rerefcnt_dec);					\
    })
#else
#  define ReREFCNT_dec(re)	SvREFCNT_dec(re)
#  define ReREFCNT_inc(re)	((REGEXP *) SvREFCNT_inc(re))
#endif
#define ReANY(re)		Perl_ReANY((const REGEXP *)(re))

/* FIXME for plugins. */

#define FBMcf_TAIL_DOLLAR	1
#define FBMcf_TAIL_DOLLARM	2
#define FBMcf_TAIL_Z		4
#define FBMcf_TAIL_z		8
#define FBMcf_TAIL		(FBMcf_TAIL_DOLLAR|FBMcf_TAIL_DOLLARM|FBMcf_TAIL_Z|FBMcf_TAIL_z)

#define FBMrf_MULTILINE	1

struct regmatch_state;
struct regmatch_slab;

/* like regmatch_info_aux, but contains extra fields only needed if the
 * pattern contains (?{}). If used, is snuck into the second slot in the
 * regmatch_state stack at the start of execution */

typedef struct {
    regexp *rex;
    PMOP    *curpm;     /* saved PL_curpm */
#ifdef PERL_ANY_COW
    SV      *saved_copy; /* saved saved_copy field from rex */
#endif
    char    *subbeg;    /* saved subbeg     field from rex */
    STRLEN  sublen;     /* saved sublen     field from rex */
    STRLEN  suboffset;  /* saved suboffset  field from rex */
    STRLEN  subcoffset; /* saved subcoffset field from rex */
    SV      *sv;        /* $_  during (?{}) */
    MAGIC   *pos_magic; /* pos() magic attached to $_ */
    SSize_t pos;        /* the original value of pos() in pos_magic */
    U8      pos_flags;  /* flags to be restored; currently only MGf_BYTES*/
} regmatch_info_aux_eval;


/* fields that logically  live in regmatch_info, but which need cleaning
 * up on croak(), and so are instead are snuck into the first slot in
 * the regmatch_state stack at the start of execution */

typedef struct {
    regmatch_info_aux_eval *info_aux_eval;
    struct regmatch_state *old_regmatch_state; /* saved PL_regmatch_state */
    struct regmatch_slab  *old_regmatch_slab;  /* saved PL_regmatch_slab */
    char *poscache;	/* S-L cache of fail positions of WHILEMs */
} regmatch_info_aux;


/*
=for apidoc Ay||regmatch_info
Some basic information about the current match that is created by
Perl_regexec_flags and then passed to regtry(), regmatch() etc.
It is allocated as a local var on the stack, so nothing should be
stored in it that needs preserving or clearing up on croak().
For that, see the aux_info and aux_info_eval members of the
regmatch_state union.

=cut
*/

typedef struct {
    REGEXP *prog;        /* the regex being executed */
    const char * strbeg; /* real start of string */
    char *strend;        /* one byte beyond last char of match string */
    char *till;          /* matches shorter than this fail (see minlen arg) */
    SV *sv;              /* the SV string currently being matched */
    char *ganch;         /* position of \G anchor */
    char *cutpoint;      /* (*COMMIT) position (if any) */
    regmatch_info_aux      *info_aux; /* extra fields that need cleanup */
    regmatch_info_aux_eval *info_aux_eval; /* extra saved state for (?{}) */
    I32  poscache_maxiter; /* how many whilems todo before S-L cache kicks in */
    I32  poscache_iter;    /* current countdown from _maxiter to zero */
    STRLEN poscache_size;  /* size of regmatch_info_aux.poscache */
    bool intuit;    /* re_intuit_start() is the top-level caller */
    bool is_utf8_pat;    /* regex is utf8 */
    bool is_utf8_target; /* string being matched is utf8 */
    bool warned; /* we have issued a recursion warning; no need for more */
} regmatch_info;


/* structures for holding and saving the state maintained by regmatch() */

#ifndef MAX_RECURSE_EVAL_NOCHANGE_DEPTH
#  define MAX_RECURSE_EVAL_NOCHANGE_DEPTH 10
#endif

/* The +1 is because everything matches itself, which isn't included in
 * MAX_FOLD_FROMS; the +2 is based on the current Unicode standards needs, and
 * is unlikely to change.  An assertion should fail in regexec.c if it is too
 * low.  It is needed for certain edge cases involving multi-character folds
 * when the first component also participates in a fold individually. */
#define MAX_MATCHES (MAX_FOLD_FROMS + 1 + 2)

struct next_matchable_info {
    U8     first_byte_mask;
    U8     first_byte_anded;
    U32    mask32;
    U32    anded32;
    PERL_INT_FAST8_T count; /* Negative means not initialized */
    PERL_UINT_FAST8_T min_length;
    PERL_UINT_FAST8_T max_length;
    PERL_UINT_FAST8_T initial_definitive;
    PERL_UINT_FAST8_T initial_exact;
    PERL_UINT_FAST8_T lengths[MAX_MATCHES];

    /* The size is from trial and error, and could change with new Unicode
     * standards, in which case there is an assertion that should start
     * failing.  This size could be calculated in one of the regen scripts
     * dealing with Unicode, but khw thinks the likelihood of it changing is
     * low enough that it isn't worth the effort. */
    U8 matches[18];
};

typedef I32 CHECKPOINT;

typedef struct regmatch_state {
    int resume_state;		/* where to jump to on return */
    char *locinput;		/* where to backtrack in string on failure */
    char *loceol;
    U8 *sr0;                    /* position of start of script run, or NULL */

    union {

        /* the 'info_aux' and 'info_aux_eval' union members are cuckoos in
         * the nest. They aren't saved backtrack state; rather they
         * represent one or two extra chunks of data that need allocating
         * at the start of a match. These fields would logically live in
         * the regmatch_info struct, except that is allocated on the
         * C stack, and these fields are all things that require cleanup
         * after a croak(), when the stack is lost.
         * As a convenience, we just use the first 1 or 2 regmatch_state
         * slots to store this info, as we will be allocating a slab of
         * these anyway. Otherwise we'd have to malloc and then free them,
         * or allocate them on the save stack (where they will get
         * realloced if the save stack grows).
         * info_aux contains the extra fields that are always needed;
         * info_aux_eval contains extra fields that only needed if
         * the pattern contains code blocks
         * We split them into two separate structs to avoid increasing
         * the size of the union.
         */

        regmatch_info_aux info_aux;

        regmatch_info_aux_eval info_aux_eval;

        /* this is a fake union member that matches the first element
         * of each member that needs to store positive backtrack
         * information */
        struct {
            struct regmatch_state *prev_yes_state;
        } yes;

        /* branchlike members */
        /* this is a fake union member that matches the first elements
         * of each member that needs to behave like a branch */
        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            U32 lastparen;
            U32 lastcloseparen;
            CHECKPOINT cp;

        } branchlike;

        struct {
            /* the first elements must match u.branchlike */
            struct regmatch_state *prev_yes_state;
            U32 lastparen;
            U32 lastcloseparen;
            CHECKPOINT cp;

            regnode *next_branch; /* next branch node */
        } branch;

        struct {
            /* the first elements must match u.branchlike */
            struct regmatch_state *prev_yes_state;
            U32 lastparen;
            U32 lastcloseparen;
            CHECKPOINT cp;

            U32		accepted; /* how many accepting states left */
            bool	longfold;/* saw a fold with a 1->n char mapping */
            U16         *jump;  /* positive offsets from me */
            regnode	*me;	/* Which node am I - needed for jump tries*/
            U8		*firstpos;/* pos in string of first trie match */
            U32		firstchars;/* len in chars of firstpos from start */
            U16		nextword;/* next word to try */
            U16		topword; /* longest accepted word */
        } trie;

        /* special types - these members are used to store state for special
           regops like eval, if/then, lookaround and the markpoint state */
        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            struct regmatch_state *prev_curlyx;
            struct regmatch_state *prev_eval;
            REGEXP	*prev_rex;
            CHECKPOINT	cp;	/* remember current savestack indexes */
            CHECKPOINT	lastcp;
            U32         close_paren; /* which close bracket is our end (+1) */
            regnode	*B;	/* the node following us  */
            char        *prev_recurse_locinput;
        } eval;

        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            I32 wanted;
            I32 logical;	/* saved copy of 'logical' var */
            U8  count;          /* number of beginning positions */
            char *start;
            char *end;
            regnode  *me; /* the IFMATCH/SUSPEND/UNLESSM node  */
            char *prev_match_end;
        } ifmatch; /* and SUSPEND/UNLESSM */

        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            struct regmatch_state *prev_mark;
            SV* mark_name;
            char *mark_loc;
        } mark;

        struct {
            int val;
        } keeper;

        /* quantifiers - these members are used for storing state for
           the regops used to implement quantifiers */
        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            struct regmatch_state *prev_curlyx; /* previous cur_curlyx */
            regnode	*me;	/* the CURLYX node  */
            regnode	*B;	/* the B node in /A*B/  */
            CHECKPOINT	cp;	/* remember current savestack index */
            bool	minmod;
            int		parenfloor;/* how far back to strip paren data */

            /* these two are modified by WHILEM */
            int		count;	/* how many instances of A we've matched */
            char	*lastloc;/* where previous A matched (0-len detect) */
        } curlyx;

        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            struct regmatch_state *save_curlyx;
            CHECKPOINT	cp;	/* remember current savestack indexes */
            CHECKPOINT	lastcp;
            char	*save_lastloc;	/* previous curlyx.lastloc */
            I32		cache_offset;
            I32		cache_mask;
        } whilem;

        struct {
            /* this first element must match u.yes */
            struct regmatch_state *prev_yes_state;
            CHECKPOINT cp;
            U32 lastparen;
            U32 lastcloseparen;
            I32 alen;		/* length of first-matched A string */
            I32 count;
            bool minmod;
            regnode *A, *B;	/* the nodes corresponding to /A*B/  */
            regnode *me;	/* the curlym node */
            struct next_matchable_info Binfo;
        } curlym;

        struct {
            U32 paren;
            CHECKPOINT cp;
            U32 lastparen;
            U32 lastcloseparen;
            char *maxpos;	/* highest possible point in string to match */
            char *oldloc;	/* the previous locinput */
            int count;
            int min, max;	/* {m,n} */
            regnode *A, *B;	/* the nodes corresponding to /A*B/  */
            struct next_matchable_info Binfo;
        } curly; /* and CURLYN/PLUS/STAR */

    } u;
} regmatch_state;



/* how many regmatch_state structs to allocate as a single slab.
 * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
 * pointers, plus 1 for any mythical malloc overhead. */

#define PERL_REGMATCH_SLAB_SLOTS \
    ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))

typedef struct regmatch_slab {
    regmatch_state states[PERL_REGMATCH_SLAB_SLOTS];
    struct regmatch_slab *prev, *next;
} regmatch_slab;



/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           #ifndef DEBUG_SBOX32_HASH
#define DEBUG_SBOX32_HASH 0

#include "zaphod32_hash.h"

#if DEBUG_SBOX32_HASH == 1
#include <stdio.h>
#define SBOX32_WARN6(pat,v0,v1,v2,v3,v4,v5)    printf(pat, v0, v1, v2, v3, v4, v5)
#define SBOX32_WARN5(pat,v0,v1,v2,v3,v4)       printf(pat, v0, v1, v2, v3, v4)
#define SBOX32_WARN4(pat,v0,v1,v2,v3)          printf(pat, v0, v1, v2, v3)
#define SBOX32_WARN3(pat,v0,v1,v2)             printf(pat, v0, v1, v2)
#define SBOX32_WARN2(pat,v0,v1)                printf(pat, v0, v1)
#define NOTE3(pat,v0,v1,v2)             printf(pat, v0, v1, v2)
#elif DEBUG_SBOX32_HASH == 2
#define SBOX32_WARN6(pat,v0,v1,v2,v3,v4,v5)
#define SBOX32_WARN5(pat,v0,v1,v2,v3,v4)
#define SBOX32_WARN4(pat,v0,v1,v2,v3)
#define SBOX32_WARN3(pat,v0,v1,v2)
#define SBOX32_WARN2(pat,v0,v1)
#define NOTE3(pat,v0,v1,v2)             printf(pat, v0, v1, v2)
#else
#define SBOX32_WARN6(pat,v0,v1,v2,v3,v4,v5)
#define SBOX32_WARN5(pat,v0,v1,v2,v3,v4)
#define SBOX32_WARN4(pat,v0,v1,v2,v3)
#define SBOX32_WARN3(pat,v0,v1,v2)
#define NOTE3(pat,v0,v1,v2)
#define SBOX32_WARN2(pat,v0,v1)
#endif

#ifndef PERL_SEEN_HV_FUNC_H_
#if !defined(U32) 
#include <stdint.h>
#define U32 uint32_t
#endif

#if !defined(U8)
#define U8 unsigned char
#endif

#if !defined(U16)
#define U16 uint16_t
#endif

#ifndef STRLEN
#define STRLEN int
#endif
#endif

#ifndef SBOX32_STATIC_INLINE
#ifdef PERL_STATIC_INLINE
#define SBOX32_STATIC_INLINE PERL_STATIC_INLINE
#else
#define SBOX32_STATIC_INLINE static inline
#endif
#endif

#ifndef STMT_START
#define STMT_START do
#define STMT_END while(0)
#endif

/* Find best way to ROTL32/ROTL64 */
#ifndef ROTL32
#if defined(_MSC_VER)
#include <stdlib.h>  /* Microsoft put _rotl declaration in here */
#define ROTL32(x,r)  _rotl(x,r)
#define ROTR32(x,r)  _rotr(x,r)
#else
/* gcc recognises this code and generates a rotate instruction for CPUs with one */
#define ROTL32(x,r)  (((U32)(x) << (r)) | ((U32)(x) >> (32 - (r))))
#define ROTR32(x,r)  (((U32)(x) << (32 - (r))) | ((U32)(x) >> (r)))
#endif
#endif

#ifndef SBOX32_MAX_LEN
#define SBOX32_MAX_LEN 256
#endif

#ifndef SBOX32_STATE_WORDS
#define SBOX32_STATE_WORDS (1 + (SBOX32_MAX_LEN * 256))
#define SBOX32_STATE_BYTES (SBOX32_STATE_WORDS * sizeof(U32))
#define SBOX32_STATE_BITS (SBOX32_STATE_BYTES * 8)
#endif

#define SBOX32_MIX4(v0,v1,v2,v3,text) STMT_START { \
        SBOX32_WARN5("v0=%08x v1=%08x v2=%08x v3=%08x - SBOX32_MIX4 %s\n", \
                            (unsigned int)v0, (unsigned int)v1,    \
                            (unsigned int)v2, (unsigned int)v3, text);   \
        v0 = ROTL32(v0,13) - v3;    \
        v1 ^= v2;                   \
        v3 = ROTL32(v3, 9) + v1;    \
        v2 ^= v0;                   \
        v0 = ROTL32(v0,14) ^ v3;    \
        v1 = ROTL32(v1,25) - v2;    \
        v3 ^= v1;                   \
        v2 = ROTL32(v2, 4) - v0;    \
} STMT_END

#define SBOX32_MIX3(v0,v1,v2,text) STMT_START {                               \
    SBOX32_WARN4("v0=%08x v1=%08x v2=%08x - SBOX32_MIX3 %s\n",              \
            (unsigned int)v0,(unsigned int)v1,(unsigned int)v2, text );     \
    v0 = ROTL32(v0,16) - v2;   \
    v1 = ROTR32(v1,13) ^ v2;   \
    v2 = ROTL32(v2,17) + v1;   \
    v0 = ROTR32(v0, 2) + v1;   \
    v1 = ROTR32(v1,17) - v0;   \
    v2 = ROTR32(v2, 7) ^ v0;   \
} STMT_END

#if SBOX32_MAX_LEN > 256
#error "SBOX32_MAX_LEN is set too high!"
#elif SBOX32_MAX_LEN == 256
#define case_256_SBOX32(hash,state,key) _SBOX32_CASE(256,hash,state,key)
#else
#define case_256_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 255
#define case_255_SBOX32(hash,state,key) _SBOX32_CASE(255,hash,state,key)
#else
#define case_255_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 254
#define case_254_SBOX32(hash,state,key) _SBOX32_CASE(254,hash,state,key)
#else
#define case_254_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 253
#define case_253_SBOX32(hash,state,key) _SBOX32_CASE(253,hash,state,key)
#else
#define case_253_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 252
#define case_252_SBOX32(hash,state,key) _SBOX32_CASE(252,hash,state,key)
#else
#define case_252_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 251
#define case_251_SBOX32(hash,state,key) _SBOX32_CASE(251,hash,state,key)
#else
#define case_251_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 250
#define case_250_SBOX32(hash,state,key) _SBOX32_CASE(250,hash,state,key)
#else
#define case_250_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 249
#define case_249_SBOX32(hash,state,key) _SBOX32_CASE(249,hash,state,key)
#else
#define case_249_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 248
#define case_248_SBOX32(hash,state,key) _SBOX32_CASE(248,hash,state,key)
#else
#define case_248_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 247
#define case_247_SBOX32(hash,state,key) _SBOX32_CASE(247,hash,state,key)
#else
#define case_247_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 246
#define case_246_SBOX32(hash,state,key) _SBOX32_CASE(246,hash,state,key)
#else
#define case_246_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 245
#define case_245_SBOX32(hash,state,key) _SBOX32_CASE(245,hash,state,key)
#else
#define case_245_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 244
#define case_244_SBOX32(hash,state,key) _SBOX32_CASE(244,hash,state,key)
#else
#define case_244_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 243
#define case_243_SBOX32(hash,state,key) _SBOX32_CASE(243,hash,state,key)
#else
#define case_243_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 242
#define case_242_SBOX32(hash,state,key) _SBOX32_CASE(242,hash,state,key)
#else
#define case_242_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 241
#define case_241_SBOX32(hash,state,key) _SBOX32_CASE(241,hash,state,key)
#else
#define case_241_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 240
#define case_240_SBOX32(hash,state,key) _SBOX32_CASE(240,hash,state,key)
#else
#define case_240_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 239
#define case_239_SBOX32(hash,state,key) _SBOX32_CASE(239,hash,state,key)
#else
#define case_239_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 238
#define case_238_SBOX32(hash,state,key) _SBOX32_CASE(238,hash,state,key)
#else
#define case_238_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 237
#define case_237_SBOX32(hash,state,key) _SBOX32_CASE(237,hash,state,key)
#else
#define case_237_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 236
#define case_236_SBOX32(hash,state,key) _SBOX32_CASE(236,hash,state,key)
#else
#define case_236_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 235
#define case_235_SBOX32(hash,state,key) _SBOX32_CASE(235,hash,state,key)
#else
#define case_235_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 234
#define case_234_SBOX32(hash,state,key) _SBOX32_CASE(234,hash,state,key)
#else
#define case_234_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 233
#define case_233_SBOX32(hash,state,key) _SBOX32_CASE(233,hash,state,key)
#else
#define case_233_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 232
#define case_232_SBOX32(hash,state,key) _SBOX32_CASE(232,hash,state,key)
#else
#define case_232_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 231
#define case_231_SBOX32(hash,state,key) _SBOX32_CASE(231,hash,state,key)
#else
#define case_231_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 230
#define case_230_SBOX32(hash,state,key) _SBOX32_CASE(230,hash,state,key)
#else
#define case_230_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 229
#define case_229_SBOX32(hash,state,key) _SBOX32_CASE(229,hash,state,key)
#else
#define case_229_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 228
#define case_228_SBOX32(hash,state,key) _SBOX32_CASE(228,hash,state,key)
#else
#define case_228_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 227
#define case_227_SBOX32(hash,state,key) _SBOX32_CASE(227,hash,state,key)
#else
#define case_227_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 226
#define case_226_SBOX32(hash,state,key) _SBOX32_CASE(226,hash,state,key)
#else
#define case_226_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 225
#define case_225_SBOX32(hash,state,key) _SBOX32_CASE(225,hash,state,key)
#else
#define case_225_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 224
#define case_224_SBOX32(hash,state,key) _SBOX32_CASE(224,hash,state,key)
#else
#define case_224_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 223
#define case_223_SBOX32(hash,state,key) _SBOX32_CASE(223,hash,state,key)
#else
#define case_223_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 222
#define case_222_SBOX32(hash,state,key) _SBOX32_CASE(222,hash,state,key)
#else
#define case_222_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 221
#define case_221_SBOX32(hash,state,key) _SBOX32_CASE(221,hash,state,key)
#else
#define case_221_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 220
#define case_220_SBOX32(hash,state,key) _SBOX32_CASE(220,hash,state,key)
#else
#define case_220_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 219
#define case_219_SBOX32(hash,state,key) _SBOX32_CASE(219,hash,state,key)
#else
#define case_219_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 218
#define case_218_SBOX32(hash,state,key) _SBOX32_CASE(218,hash,state,key)
#else
#define case_218_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 217
#define case_217_SBOX32(hash,state,key) _SBOX32_CASE(217,hash,state,key)
#else
#define case_217_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 216
#define case_216_SBOX32(hash,state,key) _SBOX32_CASE(216,hash,state,key)
#else
#define case_216_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 215
#define case_215_SBOX32(hash,state,key) _SBOX32_CASE(215,hash,state,key)
#else
#define case_215_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 214
#define case_214_SBOX32(hash,state,key) _SBOX32_CASE(214,hash,state,key)
#else
#define case_214_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 213
#define case_213_SBOX32(hash,state,key) _SBOX32_CASE(213,hash,state,key)
#else
#define case_213_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 212
#define case_212_SBOX32(hash,state,key) _SBOX32_CASE(212,hash,state,key)
#else
#define case_212_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 211
#define case_211_SBOX32(hash,state,key) _SBOX32_CASE(211,hash,state,key)
#else
#define case_211_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 210
#define case_210_SBOX32(hash,state,key) _SBOX32_CASE(210,hash,state,key)
#else
#define case_210_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 209
#define case_209_SBOX32(hash,state,key) _SBOX32_CASE(209,hash,state,key)
#else
#define case_209_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 208
#define case_208_SBOX32(hash,state,key) _SBOX32_CASE(208,hash,state,key)
#else
#define case_208_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 207
#define case_207_SBOX32(hash,state,key) _SBOX32_CASE(207,hash,state,key)
#else
#define case_207_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 206
#define case_206_SBOX32(hash,state,key) _SBOX32_CASE(206,hash,state,key)
#else
#define case_206_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 205
#define case_205_SBOX32(hash,state,key) _SBOX32_CASE(205,hash,state,key)
#else
#define case_205_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 204
#define case_204_SBOX32(hash,state,key) _SBOX32_CASE(204,hash,state,key)
#else
#define case_204_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 203
#define case_203_SBOX32(hash,state,key) _SBOX32_CASE(203,hash,state,key)
#else
#define case_203_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 202
#define case_202_SBOX32(hash,state,key) _SBOX32_CASE(202,hash,state,key)
#else
#define case_202_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 201
#define case_201_SBOX32(hash,state,key) _SBOX32_CASE(201,hash,state,key)
#else
#define case_201_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 200
#define case_200_SBOX32(hash,state,key) _SBOX32_CASE(200,hash,state,key)
#else
#define case_200_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 199
#define case_199_SBOX32(hash,state,key) _SBOX32_CASE(199,hash,state,key)
#else
#define case_199_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 198
#define case_198_SBOX32(hash,state,key) _SBOX32_CASE(198,hash,state,key)
#else
#define case_198_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 197
#define case_197_SBOX32(hash,state,key) _SBOX32_CASE(197,hash,state,key)
#else
#define case_197_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 196
#define case_196_SBOX32(hash,state,key) _SBOX32_CASE(196,hash,state,key)
#else
#define case_196_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 195
#define case_195_SBOX32(hash,state,key) _SBOX32_CASE(195,hash,state,key)
#else
#define case_195_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 194
#define case_194_SBOX32(hash,state,key) _SBOX32_CASE(194,hash,state,key)
#else
#define case_194_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 193
#define case_193_SBOX32(hash,state,key) _SBOX32_CASE(193,hash,state,key)
#else
#define case_193_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 192
#define case_192_SBOX32(hash,state,key) _SBOX32_CASE(192,hash,state,key)
#else
#define case_192_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 191
#define case_191_SBOX32(hash,state,key) _SBOX32_CASE(191,hash,state,key)
#else
#define case_191_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 190
#define case_190_SBOX32(hash,state,key) _SBOX32_CASE(190,hash,state,key)
#else
#define case_190_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 189
#define case_189_SBOX32(hash,state,key) _SBOX32_CASE(189,hash,state,key)
#else
#define case_189_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 188
#define case_188_SBOX32(hash,state,key) _SBOX32_CASE(188,hash,state,key)
#else
#define case_188_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 187
#define case_187_SBOX32(hash,state,key) _SBOX32_CASE(187,hash,state,key)
#else
#define case_187_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 186
#define case_186_SBOX32(hash,state,key) _SBOX32_CASE(186,hash,state,key)
#else
#define case_186_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 185
#define case_185_SBOX32(hash,state,key) _SBOX32_CASE(185,hash,state,key)
#else
#define case_185_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 184
#define case_184_SBOX32(hash,state,key) _SBOX32_CASE(184,hash,state,key)
#else
#define case_184_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 183
#define case_183_SBOX32(hash,state,key) _SBOX32_CASE(183,hash,state,key)
#else
#define case_183_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 182
#define case_182_SBOX32(hash,state,key) _SBOX32_CASE(182,hash,state,key)
#else
#define case_182_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 181
#define case_181_SBOX32(hash,state,key) _SBOX32_CASE(181,hash,state,key)
#else
#define case_181_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 180
#define case_180_SBOX32(hash,state,key) _SBOX32_CASE(180,hash,state,key)
#else
#define case_180_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 179
#define case_179_SBOX32(hash,state,key) _SBOX32_CASE(179,hash,state,key)
#else
#define case_179_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 178
#define case_178_SBOX32(hash,state,key) _SBOX32_CASE(178,hash,state,key)
#else
#define case_178_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 177
#define case_177_SBOX32(hash,state,key) _SBOX32_CASE(177,hash,state,key)
#else
#define case_177_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 176
#define case_176_SBOX32(hash,state,key) _SBOX32_CASE(176,hash,state,key)
#else
#define case_176_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 175
#define case_175_SBOX32(hash,state,key) _SBOX32_CASE(175,hash,state,key)
#else
#define case_175_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 174
#define case_174_SBOX32(hash,state,key) _SBOX32_CASE(174,hash,state,key)
#else
#define case_174_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 173
#define case_173_SBOX32(hash,state,key) _SBOX32_CASE(173,hash,state,key)
#else
#define case_173_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 172
#define case_172_SBOX32(hash,state,key) _SBOX32_CASE(172,hash,state,key)
#else
#define case_172_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 171
#define case_171_SBOX32(hash,state,key) _SBOX32_CASE(171,hash,state,key)
#else
#define case_171_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 170
#define case_170_SBOX32(hash,state,key) _SBOX32_CASE(170,hash,state,key)
#else
#define case_170_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 169
#define case_169_SBOX32(hash,state,key) _SBOX32_CASE(169,hash,state,key)
#else
#define case_169_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 168
#define case_168_SBOX32(hash,state,key) _SBOX32_CASE(168,hash,state,key)
#else
#define case_168_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 167
#define case_167_SBOX32(hash,state,key) _SBOX32_CASE(167,hash,state,key)
#else
#define case_167_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 166
#define case_166_SBOX32(hash,state,key) _SBOX32_CASE(166,hash,state,key)
#else
#define case_166_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 165
#define case_165_SBOX32(hash,state,key) _SBOX32_CASE(165,hash,state,key)
#else
#define case_165_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 164
#define case_164_SBOX32(hash,state,key) _SBOX32_CASE(164,hash,state,key)
#else
#define case_164_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 163
#define case_163_SBOX32(hash,state,key) _SBOX32_CASE(163,hash,state,key)
#else
#define case_163_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 162
#define case_162_SBOX32(hash,state,key) _SBOX32_CASE(162,hash,state,key)
#else
#define case_162_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 161
#define case_161_SBOX32(hash,state,key) _SBOX32_CASE(161,hash,state,key)
#else
#define case_161_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 160
#define case_160_SBOX32(hash,state,key) _SBOX32_CASE(160,hash,state,key)
#else
#define case_160_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 159
#define case_159_SBOX32(hash,state,key) _SBOX32_CASE(159,hash,state,key)
#else
#define case_159_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 158
#define case_158_SBOX32(hash,state,key) _SBOX32_CASE(158,hash,state,key)
#else
#define case_158_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 157
#define case_157_SBOX32(hash,state,key) _SBOX32_CASE(157,hash,state,key)
#else
#define case_157_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 156
#define case_156_SBOX32(hash,state,key) _SBOX32_CASE(156,hash,state,key)
#else
#define case_156_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 155
#define case_155_SBOX32(hash,state,key) _SBOX32_CASE(155,hash,state,key)
#else
#define case_155_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 154
#define case_154_SBOX32(hash,state,key) _SBOX32_CASE(154,hash,state,key)
#else
#define case_154_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 153
#define case_153_SBOX32(hash,state,key) _SBOX32_CASE(153,hash,state,key)
#else
#define case_153_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 152
#define case_152_SBOX32(hash,state,key) _SBOX32_CASE(152,hash,state,key)
#else
#define case_152_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 151
#define case_151_SBOX32(hash,state,key) _SBOX32_CASE(151,hash,state,key)
#else
#define case_151_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 150
#define case_150_SBOX32(hash,state,key) _SBOX32_CASE(150,hash,state,key)
#else
#define case_150_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 149
#define case_149_SBOX32(hash,state,key) _SBOX32_CASE(149,hash,state,key)
#else
#define case_149_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 148
#define case_148_SBOX32(hash,state,key) _SBOX32_CASE(148,hash,state,key)
#else
#define case_148_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 147
#define case_147_SBOX32(hash,state,key) _SBOX32_CASE(147,hash,state,key)
#else
#define case_147_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 146
#define case_146_SBOX32(hash,state,key) _SBOX32_CASE(146,hash,state,key)
#else
#define case_146_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 145
#define case_145_SBOX32(hash,state,key) _SBOX32_CASE(145,hash,state,key)
#else
#define case_145_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 144
#define case_144_SBOX32(hash,state,key) _SBOX32_CASE(144,hash,state,key)
#else
#define case_144_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 143
#define case_143_SBOX32(hash,state,key) _SBOX32_CASE(143,hash,state,key)
#else
#define case_143_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 142
#define case_142_SBOX32(hash,state,key) _SBOX32_CASE(142,hash,state,key)
#else
#define case_142_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 141
#define case_141_SBOX32(hash,state,key) _SBOX32_CASE(141,hash,state,key)
#else
#define case_141_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 140
#define case_140_SBOX32(hash,state,key) _SBOX32_CASE(140,hash,state,key)
#else
#define case_140_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 139
#define case_139_SBOX32(hash,state,key) _SBOX32_CASE(139,hash,state,key)
#else
#define case_139_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 138
#define case_138_SBOX32(hash,state,key) _SBOX32_CASE(138,hash,state,key)
#else
#define case_138_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 137
#define case_137_SBOX32(hash,state,key) _SBOX32_CASE(137,hash,state,key)
#else
#define case_137_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 136
#define case_136_SBOX32(hash,state,key) _SBOX32_CASE(136,hash,state,key)
#else
#define case_136_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 135
#define case_135_SBOX32(hash,state,key) _SBOX32_CASE(135,hash,state,key)
#else
#define case_135_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 134
#define case_134_SBOX32(hash,state,key) _SBOX32_CASE(134,hash,state,key)
#else
#define case_134_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 133
#define case_133_SBOX32(hash,state,key) _SBOX32_CASE(133,hash,state,key)
#else
#define case_133_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 132
#define case_132_SBOX32(hash,state,key) _SBOX32_CASE(132,hash,state,key)
#else
#define case_132_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 131
#define case_131_SBOX32(hash,state,key) _SBOX32_CASE(131,hash,state,key)
#else
#define case_131_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 130
#define case_130_SBOX32(hash,state,key) _SBOX32_CASE(130,hash,state,key)
#else
#define case_130_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 129
#define case_129_SBOX32(hash,state,key) _SBOX32_CASE(129,hash,state,key)
#else
#define case_129_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 128
#define case_128_SBOX32(hash,state,key) _SBOX32_CASE(128,hash,state,key)
#else
#define case_128_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 127
#define case_127_SBOX32(hash,state,key) _SBOX32_CASE(127,hash,state,key)
#else
#define case_127_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 126
#define case_126_SBOX32(hash,state,key) _SBOX32_CASE(126,hash,state,key)
#else
#define case_126_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 125
#define case_125_SBOX32(hash,state,key) _SBOX32_CASE(125,hash,state,key)
#else
#define case_125_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 124
#define case_124_SBOX32(hash,state,key) _SBOX32_CASE(124,hash,state,key)
#else
#define case_124_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 123
#define case_123_SBOX32(hash,state,key) _SBOX32_CASE(123,hash,state,key)
#else
#define case_123_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 122
#define case_122_SBOX32(hash,state,key) _SBOX32_CASE(122,hash,state,key)
#else
#define case_122_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 121
#define case_121_SBOX32(hash,state,key) _SBOX32_CASE(121,hash,state,key)
#else
#define case_121_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 120
#define case_120_SBOX32(hash,state,key) _SBOX32_CASE(120,hash,state,key)
#else
#define case_120_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 119
#define case_119_SBOX32(hash,state,key) _SBOX32_CASE(119,hash,state,key)
#else
#define case_119_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 118
#define case_118_SBOX32(hash,state,key) _SBOX32_CASE(118,hash,state,key)
#else
#define case_118_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 117
#define case_117_SBOX32(hash,state,key) _SBOX32_CASE(117,hash,state,key)
#else
#define case_117_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 116
#define case_116_SBOX32(hash,state,key) _SBOX32_CASE(116,hash,state,key)
#else
#define case_116_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 115
#define case_115_SBOX32(hash,state,key) _SBOX32_CASE(115,hash,state,key)
#else
#define case_115_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 114
#define case_114_SBOX32(hash,state,key) _SBOX32_CASE(114,hash,state,key)
#else
#define case_114_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 113
#define case_113_SBOX32(hash,state,key) _SBOX32_CASE(113,hash,state,key)
#else
#define case_113_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 112
#define case_112_SBOX32(hash,state,key) _SBOX32_CASE(112,hash,state,key)
#else
#define case_112_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 111
#define case_111_SBOX32(hash,state,key) _SBOX32_CASE(111,hash,state,key)
#else
#define case_111_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 110
#define case_110_SBOX32(hash,state,key) _SBOX32_CASE(110,hash,state,key)
#else
#define case_110_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 109
#define case_109_SBOX32(hash,state,key) _SBOX32_CASE(109,hash,state,key)
#else
#define case_109_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 108
#define case_108_SBOX32(hash,state,key) _SBOX32_CASE(108,hash,state,key)
#else
#define case_108_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 107
#define case_107_SBOX32(hash,state,key) _SBOX32_CASE(107,hash,state,key)
#else
#define case_107_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 106
#define case_106_SBOX32(hash,state,key) _SBOX32_CASE(106,hash,state,key)
#else
#define case_106_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 105
#define case_105_SBOX32(hash,state,key) _SBOX32_CASE(105,hash,state,key)
#else
#define case_105_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 104
#define case_104_SBOX32(hash,state,key) _SBOX32_CASE(104,hash,state,key)
#else
#define case_104_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 103
#define case_103_SBOX32(hash,state,key) _SBOX32_CASE(103,hash,state,key)
#else
#define case_103_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 102
#define case_102_SBOX32(hash,state,key) _SBOX32_CASE(102,hash,state,key)
#else
#define case_102_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 101
#define case_101_SBOX32(hash,state,key) _SBOX32_CASE(101,hash,state,key)
#else
#define case_101_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 100
#define case_100_SBOX32(hash,state,key) _SBOX32_CASE(100,hash,state,key)
#else
#define case_100_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 99
#define case_99_SBOX32(hash,state,key) _SBOX32_CASE(99,hash,state,key)
#else
#define case_99_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 98
#define case_98_SBOX32(hash,state,key) _SBOX32_CASE(98,hash,state,key)
#else
#define case_98_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 97
#define case_97_SBOX32(hash,state,key) _SBOX32_CASE(97,hash,state,key)
#else
#define case_97_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 96
#define case_96_SBOX32(hash,state,key) _SBOX32_CASE(96,hash,state,key)
#else
#define case_96_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 95
#define case_95_SBOX32(hash,state,key) _SBOX32_CASE(95,hash,state,key)
#else
#define case_95_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 94
#define case_94_SBOX32(hash,state,key) _SBOX32_CASE(94,hash,state,key)
#else
#define case_94_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 93
#define case_93_SBOX32(hash,state,key) _SBOX32_CASE(93,hash,state,key)
#else
#define case_93_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 92
#define case_92_SBOX32(hash,state,key) _SBOX32_CASE(92,hash,state,key)
#else
#define case_92_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 91
#define case_91_SBOX32(hash,state,key) _SBOX32_CASE(91,hash,state,key)
#else
#define case_91_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 90
#define case_90_SBOX32(hash,state,key) _SBOX32_CASE(90,hash,state,key)
#else
#define case_90_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 89
#define case_89_SBOX32(hash,state,key) _SBOX32_CASE(89,hash,state,key)
#else
#define case_89_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 88
#define case_88_SBOX32(hash,state,key) _SBOX32_CASE(88,hash,state,key)
#else
#define case_88_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 87
#define case_87_SBOX32(hash,state,key) _SBOX32_CASE(87,hash,state,key)
#else
#define case_87_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 86
#define case_86_SBOX32(hash,state,key) _SBOX32_CASE(86,hash,state,key)
#else
#define case_86_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 85
#define case_85_SBOX32(hash,state,key) _SBOX32_CASE(85,hash,state,key)
#else
#define case_85_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 84
#define case_84_SBOX32(hash,state,key) _SBOX32_CASE(84,hash,state,key)
#else
#define case_84_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 83
#define case_83_SBOX32(hash,state,key) _SBOX32_CASE(83,hash,state,key)
#else
#define case_83_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 82
#define case_82_SBOX32(hash,state,key) _SBOX32_CASE(82,hash,state,key)
#else
#define case_82_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 81
#define case_81_SBOX32(hash,state,key) _SBOX32_CASE(81,hash,state,key)
#else
#define case_81_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 80
#define case_80_SBOX32(hash,state,key) _SBOX32_CASE(80,hash,state,key)
#else
#define case_80_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 79
#define case_79_SBOX32(hash,state,key) _SBOX32_CASE(79,hash,state,key)
#else
#define case_79_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 78
#define case_78_SBOX32(hash,state,key) _SBOX32_CASE(78,hash,state,key)
#else
#define case_78_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 77
#define case_77_SBOX32(hash,state,key) _SBOX32_CASE(77,hash,state,key)
#else
#define case_77_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 76
#define case_76_SBOX32(hash,state,key) _SBOX32_CASE(76,hash,state,key)
#else
#define case_76_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 75
#define case_75_SBOX32(hash,state,key) _SBOX32_CASE(75,hash,state,key)
#else
#define case_75_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 74
#define case_74_SBOX32(hash,state,key) _SBOX32_CASE(74,hash,state,key)
#else
#define case_74_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 73
#define case_73_SBOX32(hash,state,key) _SBOX32_CASE(73,hash,state,key)
#else
#define case_73_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 72
#define case_72_SBOX32(hash,state,key) _SBOX32_CASE(72,hash,state,key)
#else
#define case_72_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 71
#define case_71_SBOX32(hash,state,key) _SBOX32_CASE(71,hash,state,key)
#else
#define case_71_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 70
#define case_70_SBOX32(hash,state,key) _SBOX32_CASE(70,hash,state,key)
#else
#define case_70_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 69
#define case_69_SBOX32(hash,state,key) _SBOX32_CASE(69,hash,state,key)
#else
#define case_69_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 68
#define case_68_SBOX32(hash,state,key) _SBOX32_CASE(68,hash,state,key)
#else
#define case_68_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 67
#define case_67_SBOX32(hash,state,key) _SBOX32_CASE(67,hash,state,key)
#else
#define case_67_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 66
#define case_66_SBOX32(hash,state,key) _SBOX32_CASE(66,hash,state,key)
#else
#define case_66_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 65
#define case_65_SBOX32(hash,state,key) _SBOX32_CASE(65,hash,state,key)
#else
#define case_65_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 64
#define case_64_SBOX32(hash,state,key) _SBOX32_CASE(64,hash,state,key)
#else
#define case_64_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 63
#define case_63_SBOX32(hash,state,key) _SBOX32_CASE(63,hash,state,key)
#else
#define case_63_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 62
#define case_62_SBOX32(hash,state,key) _SBOX32_CASE(62,hash,state,key)
#else
#define case_62_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 61
#define case_61_SBOX32(hash,state,key) _SBOX32_CASE(61,hash,state,key)
#else
#define case_61_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 60
#define case_60_SBOX32(hash,state,key) _SBOX32_CASE(60,hash,state,key)
#else
#define case_60_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 59
#define case_59_SBOX32(hash,state,key) _SBOX32_CASE(59,hash,state,key)
#else
#define case_59_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 58
#define case_58_SBOX32(hash,state,key) _SBOX32_CASE(58,hash,state,key)
#else
#define case_58_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 57
#define case_57_SBOX32(hash,state,key) _SBOX32_CASE(57,hash,state,key)
#else
#define case_57_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 56
#define case_56_SBOX32(hash,state,key) _SBOX32_CASE(56,hash,state,key)
#else
#define case_56_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 55
#define case_55_SBOX32(hash,state,key) _SBOX32_CASE(55,hash,state,key)
#else
#define case_55_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 54
#define case_54_SBOX32(hash,state,key) _SBOX32_CASE(54,hash,state,key)
#else
#define case_54_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 53
#define case_53_SBOX32(hash,state,key) _SBOX32_CASE(53,hash,state,key)
#else
#define case_53_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 52
#define case_52_SBOX32(hash,state,key) _SBOX32_CASE(52,hash,state,key)
#else
#define case_52_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 51
#define case_51_SBOX32(hash,state,key) _SBOX32_CASE(51,hash,state,key)
#else
#define case_51_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 50
#define case_50_SBOX32(hash,state,key) _SBOX32_CASE(50,hash,state,key)
#else
#define case_50_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 49
#define case_49_SBOX32(hash,state,key) _SBOX32_CASE(49,hash,state,key)
#else
#define case_49_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 48
#define case_48_SBOX32(hash,state,key) _SBOX32_CASE(48,hash,state,key)
#else
#define case_48_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 47
#define case_47_SBOX32(hash,state,key) _SBOX32_CASE(47,hash,state,key)
#else
#define case_47_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 46
#define case_46_SBOX32(hash,state,key) _SBOX32_CASE(46,hash,state,key)
#else
#define case_46_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 45
#define case_45_SBOX32(hash,state,key) _SBOX32_CASE(45,hash,state,key)
#else
#define case_45_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 44
#define case_44_SBOX32(hash,state,key) _SBOX32_CASE(44,hash,state,key)
#else
#define case_44_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 43
#define case_43_SBOX32(hash,state,key) _SBOX32_CASE(43,hash,state,key)
#else
#define case_43_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 42
#define case_42_SBOX32(hash,state,key) _SBOX32_CASE(42,hash,state,key)
#else
#define case_42_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 41
#define case_41_SBOX32(hash,state,key) _SBOX32_CASE(41,hash,state,key)
#else
#define case_41_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 40
#define case_40_SBOX32(hash,state,key) _SBOX32_CASE(40,hash,state,key)
#else
#define case_40_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 39
#define case_39_SBOX32(hash,state,key) _SBOX32_CASE(39,hash,state,key)
#else
#define case_39_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 38
#define case_38_SBOX32(hash,state,key) _SBOX32_CASE(38,hash,state,key)
#else
#define case_38_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 37
#define case_37_SBOX32(hash,state,key) _SBOX32_CASE(37,hash,state,key)
#else
#define case_37_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 36
#define case_36_SBOX32(hash,state,key) _SBOX32_CASE(36,hash,state,key)
#else
#define case_36_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 35
#define case_35_SBOX32(hash,state,key) _SBOX32_CASE(35,hash,state,key)
#else
#define case_35_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 34
#define case_34_SBOX32(hash,state,key) _SBOX32_CASE(34,hash,state,key)
#else
#define case_34_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 33
#define case_33_SBOX32(hash,state,key) _SBOX32_CASE(33,hash,state,key)
#else
#define case_33_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 32
#define case_32_SBOX32(hash,state,key) _SBOX32_CASE(32,hash,state,key)
#else
#define case_32_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 31
#define case_31_SBOX32(hash,state,key) _SBOX32_CASE(31,hash,state,key)
#else
#define case_31_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 30
#define case_30_SBOX32(hash,state,key) _SBOX32_CASE(30,hash,state,key)
#else
#define case_30_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 29
#define case_29_SBOX32(hash,state,key) _SBOX32_CASE(29,hash,state,key)
#else
#define case_29_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 28
#define case_28_SBOX32(hash,state,key) _SBOX32_CASE(28,hash,state,key)
#else
#define case_28_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 27
#define case_27_SBOX32(hash,state,key) _SBOX32_CASE(27,hash,state,key)
#else
#define case_27_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 26
#define case_26_SBOX32(hash,state,key) _SBOX32_CASE(26,hash,state,key)
#else
#define case_26_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 25
#define case_25_SBOX32(hash,state,key) _SBOX32_CASE(25,hash,state,key)
#else
#define case_25_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 24
#define case_24_SBOX32(hash,state,key) _SBOX32_CASE(24,hash,state,key)
#else
#define case_24_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 23
#define case_23_SBOX32(hash,state,key) _SBOX32_CASE(23,hash,state,key)
#else
#define case_23_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 22
#define case_22_SBOX32(hash,state,key) _SBOX32_CASE(22,hash,state,key)
#else
#define case_22_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 21
#define case_21_SBOX32(hash,state,key) _SBOX32_CASE(21,hash,state,key)
#else
#define case_21_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 20
#define case_20_SBOX32(hash,state,key) _SBOX32_CASE(20,hash,state,key)
#else
#define case_20_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 19
#define case_19_SBOX32(hash,state,key) _SBOX32_CASE(19,hash,state,key)
#else
#define case_19_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 18
#define case_18_SBOX32(hash,state,key) _SBOX32_CASE(18,hash,state,key)
#else
#define case_18_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 17
#define case_17_SBOX32(hash,state,key) _SBOX32_CASE(17,hash,state,key)
#else
#define case_17_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 16
#define case_16_SBOX32(hash,state,key) _SBOX32_CASE(16,hash,state,key)
#else
#define case_16_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 15
#define case_15_SBOX32(hash,state,key) _SBOX32_CASE(15,hash,state,key)
#else
#define case_15_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 14
#define case_14_SBOX32(hash,state,key) _SBOX32_CASE(14,hash,state,key)
#else
#define case_14_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 13
#define case_13_SBOX32(hash,state,key) _SBOX32_CASE(13,hash,state,key)
#else
#define case_13_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 12
#define case_12_SBOX32(hash,state,key) _SBOX32_CASE(12,hash,state,key)
#else
#define case_12_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 11
#define case_11_SBOX32(hash,state,key) _SBOX32_CASE(11,hash,state,key)
#else
#define case_11_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 10
#define case_10_SBOX32(hash,state,key) _SBOX32_CASE(10,hash,state,key)
#else
#define case_10_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 9
#define case_9_SBOX32(hash,state,key) _SBOX32_CASE(9,hash,state,key)
#else
#define case_9_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 8
#define case_8_SBOX32(hash,state,key) _SBOX32_CASE(8,hash,state,key)
#else
#define case_8_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 7
#define case_7_SBOX32(hash,state,key) _SBOX32_CASE(7,hash,state,key)
#else
#define case_7_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 6
#define case_6_SBOX32(hash,state,key) _SBOX32_CASE(6,hash,state,key)
#else
#define case_6_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 5
#define case_5_SBOX32(hash,state,key) _SBOX32_CASE(5,hash,state,key)
#else
#define case_5_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 4
#define case_4_SBOX32(hash,state,key) _SBOX32_CASE(4,hash,state,key)
#else
#define case_4_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 3
#define case_3_SBOX32(hash,state,key) _SBOX32_CASE(3,hash,state,key)
#else
#define case_3_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 2
#define case_2_SBOX32(hash,state,key) _SBOX32_CASE(2,hash,state,key)
#else
#define case_2_SBOX32(hash,state,key) /**/
#endif
#if SBOX32_MAX_LEN >= 1
#define case_1_SBOX32(hash,state,key) _SBOX32_CASE(1,hash,state,key)
#else
#define case_1_SBOX32(hash,state,key) /**/
#endif

#define XORSHIFT128_set(r,x,y,z,w,t) STMT_START {       \
    t = ( x ^ ( x << 5 ) );                             \
    x = y; y = z; z = w;                                \
    r = w = ( w ^ ( w >> 29 ) ) ^ ( t ^ ( t >> 12 ) );  \
} STMT_END

#ifndef SBOX32_CHURN_ROUNDS 
#define SBOX32_CHURN_ROUNDS 128
#endif

#define _SBOX32_CASE(len,hash,state,key) \
    /* FALLTHROUGH */ \
    case len: hash ^= state[ 1 + ( 256 * ( len - 1 ) ) + key[ len - 1 ] ];


SBOX32_STATIC_INLINE void sbox32_seed_state128 (
    const U8 *seed_ch,
    U8 *state_ch
) {
    U32 *seed= (U32 *)seed_ch;
    U32 *state= (U32 *)state_ch;
    U32 *state_cursor = state + 1;
    U32 *sbox32_end = state + 1 + (256 * SBOX32_MAX_LEN);
    U32 s0 = seed[1] ^ 0x786f6273; /* sbox */
    U32 s1 = seed[0] ^ 0x68736168; /* hash */
    U32 s2 = seed[2] ^ 0x646f6f67; /* good */
    U32 s3 = seed[3] ^ 0x74736166; /* fast */
    U32 t1,t2,i;

    /* make sure we have all non-zero state elements */
    if (!s0) s0 = 1;
    if (!s1) s1 = 2;
    if (!s2) s2 = 4;
    if (!s3) s3 = 8;

    /* Do a bunch of mix rounds to avalanche the seedbits
     * before we use them for the XORSHIFT rng. */
    for ( i = 0; i < SBOX32_CHURN_ROUNDS; i++ )
        SBOX32_MIX4(s0,s1,s2,s3,"SEED STATE");

    s0 ^= ~seed[3];
    s1 ^= ~seed[2];
    s2 ^= ~seed[1];
    s3 ^= ~seed[0];

    /* make sure we have all non-zero state elements, again */
    if (!s0) s0 = 8;
    if (!s1) s1 = 4;
    if (!s2) s2 = 2;
    if (!s3) s3 = 1;
    
    for ( i = 0; i < SBOX32_CHURN_ROUNDS; i++ )
        SBOX32_MIX4(s0,s1,s2,s3,"SEED STATE");

    while ( state_cursor < sbox32_end ) {
        U32 *row_end = state_cursor + 256; 
        for ( ; state_cursor < row_end; state_cursor++ ) {
            XORSHIFT128_set(*state_cursor,s0,s1,s2,s3,t1);
        }
    }
    XORSHIFT128_set(*state,s0,s1,s2,s3,t2);
}

SBOX32_STATIC_INLINE U32 sbox32_hash_with_state(
    const U8 *state_ch,
    const U8 *key,
    const STRLEN key_len
) {
    U32 *state= (U32 *)state_ch;
    U32 hash = *state;
    switch (key_len) {
        default: return zaphod32_hash_with_state(state_ch, key, key_len);
        case_256_SBOX32(hash,state,key)
        case_255_SBOX32(hash,state,key)
        case_254_SBOX32(hash,state,key)
        case_253_SBOX32(hash,state,key)
        case_252_SBOX32(hash,state,key)
        case_251_SBOX32(hash,state,key)
        case_250_SBOX32(hash,state,key)
        case_249_SBOX32(hash,state,key)
        case_248_SBOX32(hash,state,key)
        case_247_SBOX32(hash,state,key)
        case_246_SBOX32(hash,state,key)
        case_245_SBOX32(hash,state,key)
        case_244_SBOX32(hash,state,key)
        case_243_SBOX32(hash,state,key)
        case_242_SBOX32(hash,state,key)
        case_241_SBOX32(hash,state,key)
        case_240_SBOX32(hash,state,key)
        case_239_SBOX32(hash,state,key)
        case_238_SBOX32(hash,state,key)
        case_237_SBOX32(hash,state,key)
        case_236_SBOX32(hash,state,key)
        case_235_SBOX32(hash,state,key)
        case_234_SBOX32(hash,state,key)
        case_233_SBOX32(hash,state,key)
        case_232_SBOX32(hash,state,key)
        case_231_SBOX32(hash,state,key)
        case_230_SBOX32(hash,state,key)
        case_229_SBOX32(hash,state,key)
        case_228_SBOX32(hash,state,key)
        case_227_SBOX32(hash,state,key)
        case_226_SBOX32(hash,state,key)
        case_225_SBOX32(hash,state,key)
        case_224_SBOX32(hash,state,key)
        case_223_SBOX32(hash,state,key)
        case_222_SBOX32(hash,state,key)
        case_221_SBOX32(hash,state,key)
        case_220_SBOX32(hash,state,key)
        case_219_SBOX32(hash,state,key)
        case_218_SBOX32(hash,state,key)
        case_217_SBOX32(hash,state,key)
        case_216_SBOX32(hash,state,key)
        case_215_SBOX32(hash,state,key)
        case_214_SBOX32(hash,state,key)
        case_213_SBOX32(hash,state,key)
        case_212_SBOX32(hash,state,key)
        case_211_SBOX32(hash,state,key)
        case_210_SBOX32(hash,state,key)
        case_209_SBOX32(hash,state,key)
        case_208_SBOX32(hash,state,key)
        case_207_SBOX32(hash,state,key)
        case_206_SBOX32(hash,state,key)
        case_205_SBOX32(hash,state,key)
        case_204_SBOX32(hash,state,key)
        case_203_SBOX32(hash,state,key)
        case_202_SBOX32(hash,state,key)
        case_201_SBOX32(hash,state,key)
        case_200_SBOX32(hash,state,key)
        case_199_SBOX32(hash,state,key)
        case_198_SBOX32(hash,state,key)
        case_197_SBOX32(hash,state,key)
        case_196_SBOX32(hash,state,key)
        case_195_SBOX32(hash,state,key)
        case_194_SBOX32(hash,state,key)
        case_193_SBOX32(hash,state,key)
        case_192_SBOX32(hash,state,key)
        case_191_SBOX32(hash,state,key)
        case_190_SBOX32(hash,state,key)
        case_189_SBOX32(hash,state,key)
        case_188_SBOX32(hash,state,key)
        case_187_SBOX32(hash,state,key)
        case_186_SBOX32(hash,state,key)
        case_185_SBOX32(hash,state,key)
        case_184_SBOX32(hash,state,key)
        case_183_SBOX32(hash,state,key)
        case_182_SBOX32(hash,state,key)
        case_181_SBOX32(hash,state,key)
        case_180_SBOX32(hash,state,key)
        case_179_SBOX32(hash,state,key)
        case_178_SBOX32(hash,state,key)
        case_177_SBOX32(hash,state,key)
        case_176_SBOX32(hash,state,key)
        case_175_SBOX32(hash,state,key)
        case_174_SBOX32(hash,state,key)
        case_173_SBOX32(hash,state,key)
        case_172_SBOX32(hash,state,key)
        case_171_SBOX32(hash,state,key)
        case_170_SBOX32(hash,state,key)
        case_169_SBOX32(hash,state,key)
        case_168_SBOX32(hash,state,key)
        case_167_SBOX32(hash,state,key)
        case_166_SBOX32(hash,state,key)
        case_165_SBOX32(hash,state,key)
        case_164_SBOX32(hash,state,key)
        case_163_SBOX32(hash,state,key)
        case_162_SBOX32(hash,state,key)
        case_161_SBOX32(hash,state,key)
        case_160_SBOX32(hash,state,key)
        case_159_SBOX32(hash,state,key)
        case_158_SBOX32(hash,state,key)
        case_157_SBOX32(hash,state,key)
        case_156_SBOX32(hash,state,key)
        case_155_SBOX32(hash,state,key)
        case_154_SBOX32(hash,state,key)
        case_153_SBOX32(hash,state,key)
        case_152_SBOX32(hash,state,key)
        case_151_SBOX32(hash,state,key)
        case_150_SBOX32(hash,state,key)
        case_149_SBOX32(hash,state,key)
        case_148_SBOX32(hash,state,key)
        case_147_SBOX32(hash,state,key)
        case_146_SBOX32(hash,state,key)
        case_145_SBOX32(hash,state,key)
        case_144_SBOX32(hash,state,key)
        case_143_SBOX32(hash,state,key)
        case_142_SBOX32(hash,state,key)
        case_141_SBOX32(hash,state,key)
        case_140_SBOX32(hash,state,key)
        case_139_SBOX32(hash,state,key)
        case_138_SBOX32(hash,state,key)
        case_137_SBOX32(hash,state,key)
        case_136_SBOX32(hash,state,key)
        case_135_SBOX32(hash,state,key)
        case_134_SBOX32(hash,state,key)
        case_133_SBOX32(hash,state,key)
        case_132_SBOX32(hash,state,key)
        case_131_SBOX32(hash,state,key)
        case_130_SBOX32(hash,state,key)
        case_129_SBOX32(hash,state,key)
        case_128_SBOX32(hash,state,key)
        case_127_SBOX32(hash,state,key)
        case_126_SBOX32(hash,state,key)
        case_125_SBOX32(hash,state,key)
        case_124_SBOX32(hash,state,key)
        case_123_SBOX32(hash,state,key)
        case_122_SBOX32(hash,state,key)
        case_121_SBOX32(hash,state,key)
        case_120_SBOX32(hash,state,key)
        case_119_SBOX32(hash,state,key)
        case_118_SBOX32(hash,state,key)
        case_117_SBOX32(hash,state,key)
        case_116_SBOX32(hash,state,key)
        case_115_SBOX32(hash,state,key)
        case_114_SBOX32(hash,state,key)
        case_113_SBOX32(hash,state,key)
        case_112_SBOX32(hash,state,key)
        case_111_SBOX32(hash,state,key)
        case_110_SBOX32(hash,state,key)
        case_109_SBOX32(hash,state,key)
        case_108_SBOX32(hash,state,key)
        case_107_SBOX32(hash,state,key)
        case_106_SBOX32(hash,state,key)
        case_105_SBOX32(hash,state,key)
        case_104_SBOX32(hash,state,key)
        case_103_SBOX32(hash,state,key)
        case_102_SBOX32(hash,state,key)
        case_101_SBOX32(hash,state,key)
        case_100_SBOX32(hash,state,key)
        case_99_SBOX32(hash,state,key)
        case_98_SBOX32(hash,state,key)
        case_97_SBOX32(hash,state,key)
        case_96_SBOX32(hash,state,key)
        case_95_SBOX32(hash,state,key)
        case_94_SBOX32(hash,state,key)
        case_93_SBOX32(hash,state,key)
        case_92_SBOX32(hash,state,key)
        case_91_SBOX32(hash,state,key)
        case_90_SBOX32(hash,state,key)
        case_89_SBOX32(hash,state,key)
        case_88_SBOX32(hash,state,key)
        case_87_SBOX32(hash,state,key)
        case_86_SBOX32(hash,state,key)
        case_85_SBOX32(hash,state,key)
        case_84_SBOX32(hash,state,key)
        case_83_SBOX32(hash,state,key)
        case_82_SBOX32(hash,state,key)
        case_81_SBOX32(hash,state,key)
        case_80_SBOX32(hash,state,key)
        case_79_SBOX32(hash,state,key)
        case_78_SBOX32(hash,state,key)
        case_77_SBOX32(hash,state,key)
        case_76_SBOX32(hash,state,key)
        case_75_SBOX32(hash,state,key)
        case_74_SBOX32(hash,state,key)
        case_73_SBOX32(hash,state,key)
        case_72_SBOX32(hash,state,key)
        case_71_SBOX32(hash,state,key)
        case_70_SBOX32(hash,state,key)
        case_69_SBOX32(hash,state,key)
        case_68_SBOX32(hash,state,key)
        case_67_SBOX32(hash,state,key)
        case_66_SBOX32(hash,state,key)
        case_65_SBOX32(hash,state,key)
        case_64_SBOX32(hash,state,key)
        case_63_SBOX32(hash,state,key)
        case_62_SBOX32(hash,state,key)
        case_61_SBOX32(hash,state,key)
        case_60_SBOX32(hash,state,key)
        case_59_SBOX32(hash,state,key)
        case_58_SBOX32(hash,state,key)
        case_57_SBOX32(hash,state,key)
        case_56_SBOX32(hash,state,key)
        case_55_SBOX32(hash,state,key)
        case_54_SBOX32(hash,state,key)
        case_53_SBOX32(hash,state,key)
        case_52_SBOX32(hash,state,key)
        case_51_SBOX32(hash,state,key)
        case_50_SBOX32(hash,state,key)
        case_49_SBOX32(hash,state,key)
        case_48_SBOX32(hash,state,key)
        case_47_SBOX32(hash,state,key)
        case_46_SBOX32(hash,state,key)
        case_45_SBOX32(hash,state,key)
        case_44_SBOX32(hash,state,key)
        case_43_SBOX32(hash,state,key)
        case_42_SBOX32(hash,state,key)
        case_41_SBOX32(hash,state,key)
        case_40_SBOX32(hash,state,key)
        case_39_SBOX32(hash,state,key)
        case_38_SBOX32(hash,state,key)
        case_37_SBOX32(hash,state,key)
        case_36_SBOX32(hash,state,key)
        case_35_SBOX32(hash,state,key)
        case_34_SBOX32(hash,state,key)
        case_33_SBOX32(hash,state,key)
        case_32_SBOX32(hash,state,key)
        case_31_SBOX32(hash,state,key)
        case_30_SBOX32(hash,state,key)
        case_29_SBOX32(hash,state,key)
        case_28_SBOX32(hash,state,key)
        case_27_SBOX32(hash,state,key)
        case_26_SBOX32(hash,state,key)
        case_25_SBOX32(hash,state,key)
        case_24_SBOX32(hash,state,key)
        case_23_SBOX32(hash,state,key)
        case_22_SBOX32(hash,state,key)
        case_21_SBOX32(hash,state,key)
        case_20_SBOX32(hash,state,key)
        case_19_SBOX32(hash,state,key)
        case_18_SBOX32(hash,state,key)
        case_17_SBOX32(hash,state,key)
        case_16_SBOX32(hash,state,key)
        case_15_SBOX32(hash,state,key)
        case_14_SBOX32(hash,state,key)
        case_13_SBOX32(hash,state,key)
        case_12_SBOX32(hash,state,key)
        case_11_SBOX32(hash,state,key)
        case_10_SBOX32(hash,state,key)
        case_9_SBOX32(hash,state,key)
        case_8_SBOX32(hash,state,key)
        case_7_SBOX32(hash,state,key)
        case_6_SBOX32(hash,state,key)
        case_5_SBOX32(hash,state,key)
        case_4_SBOX32(hash,state,key)
        case_3_SBOX32(hash,state,key)
        case_2_SBOX32(hash,state,key)
        case_1_SBOX32(hash,state,key)
        case 0: break;
    }
    return hash;
}

SBOX32_STATIC_INLINE U32 sbox32_hash128(
    const U8 *seed_ch,
    const U8 *key,
    const STRLEN key_len
) {
    U32 state[SBOX32_STATE_WORDS];
    sbox32_seed_state128(seed_ch,(U8*)state);
    return sbox32_hash_with_state((U8*)state,key,key_len);
}

#endif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /*    scope.h
 *
 *    Copyright (C) 1993, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
 *    2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/* *** Update arg_counts[] in scope.c if you modify these */

/* zero args */

#define SAVEt_ALLOC		0
#define SAVEt_CLEARPADRANGE	1
#define SAVEt_CLEARSV		2
#define SAVEt_REGCONTEXT	3

/* one arg */

#define SAVEt_TMPSFLOOR		4
#define SAVEt_BOOL		5
#define SAVEt_COMPILE_WARNINGS	6
#define SAVEt_COMPPAD		7
#define SAVEt_FREECOPHH		8
#define SAVEt_FREEOP		9
#define SAVEt_FREEPV		10
#define SAVEt_FREESV		11
#define SAVEt_I16		12
#define SAVEt_I32_SMALL		13
#define SAVEt_I8		14
#define SAVEt_INT_SMALL		15
#define SAVEt_MORTALIZESV	16
#define SAVEt_NSTAB		17
#define SAVEt_OP		18
#define SAVEt_PARSER		19
#define SAVEt_STACK_POS		20
#define SAVEt_READONLY_OFF	21
#define SAVEt_FREEPADNAME	22
#define SAVEt_STRLEN_SMALL      23

/* two args */

#define SAVEt_AV		24
#define SAVEt_DESTRUCTOR	25
#define SAVEt_DESTRUCTOR_X	26
#define SAVEt_GENERIC_PVREF	27
#define SAVEt_GENERIC_SVREF	28
#define SAVEt_GP		29
#define SAVEt_GVSV		30
#define SAVEt_HINTS		31
#define SAVEt_HPTR		32
#define SAVEt_HV		33
#define SAVEt_I32		34
#define SAVEt_INT		35
#define SAVEt_ITEM		36
#define SAVEt_IV		37
#define SAVEt_LONG		38
#define SAVEt_PPTR		39
#define SAVEt_SAVESWITCHSTACK	40
#define SAVEt_SHARED_PVREF	41
#define SAVEt_SPTR		42
#define SAVEt_STRLEN		43
#define SAVEt_SV		44
#define SAVEt_SVREF		45
#define SAVEt_VPTR		46
#define SAVEt_ADELETE		47
#define SAVEt_APTR		48

/* three args */

#define SAVEt_HELEM		49
#define SAVEt_PADSV_AND_MORTALIZE 50
#define SAVEt_SET_SVFLAGS	51
#define SAVEt_GVSLOT		52
#define SAVEt_AELEM		53
#define SAVEt_DELETE		54
#define SAVEt_HINTS_HH		55


#define SAVEf_SETMAGIC		1
#define SAVEf_KEEPOLDELEM	2

#define SAVE_TIGHT_SHIFT	6
#define SAVE_MASK		0x3F

#define save_aelem(av,idx,sptr)	save_aelem_flags(av,idx,sptr,SAVEf_SETMAGIC)
#define save_helem(hv,key,sptr)	save_helem_flags(hv,key,sptr,SAVEf_SETMAGIC)

#ifndef SCOPE_SAVES_SIGNAL_MASK
#define SCOPE_SAVES_SIGNAL_MASK 0
#endif

/* the maximum number of entries that might be pushed using the SS_ADD*
 * macros */
#define SS_MAXPUSH 4

#define SSCHECK(need) if (UNLIKELY(PL_savestack_ix + (I32)(need) > PL_savestack_max)) savestack_grow()
#define SSGROW(need) if (UNLIKELY(PL_savestack_ix + (I32)(need) > PL_savestack_max)) savestack_grow_cnt(need)
#define SSPUSHINT(i) (PL_savestack[PL_savestack_ix++].any_i32 = (I32)(i))
#define SSPUSHLONG(i) (PL_savestack[PL_savestack_ix++].any_long = (long)(i))
#define SSPUSHBOOL(p) (PL_savestack[PL_savestack_ix++].any_bool = (p))
#define SSPUSHIV(i) (PL_savestack[PL_savestack_ix++].any_iv = (IV)(i))
#define SSPUSHUV(u) (PL_savestack[PL_savestack_ix++].any_uv = (UV)(u))
#define SSPUSHPTR(p) (PL_savestack[PL_savestack_ix++].any_ptr = (void*)(p))
#define SSPUSHDPTR(p) (PL_savestack[PL_savestack_ix++].any_dptr = (p))
#define SSPUSHDXPTR(p) (PL_savestack[PL_savestack_ix++].any_dxptr = (p))

/* SS_ADD*: newer, faster versions of the above. Don't mix the two sets of
 * macros. These are fast because they save reduce accesses to the PL_
 * vars and move the size check to the end. Doing the check last means
 * that values in registers will have been pushed and no longer needed, so
 * don't need saving around the call to grow. Also, tail-call elimination
 * of the grow() can be done. These changes reduce the code of something
 * like save_pushptrptr() to half its former size.
 * Of course, doing the size check *after* pushing means we must always
 * ensure there are SS_MAXPUSH free slots on the savestack. This is ensured by
 * savestack_grow() and savestack_grow_cnt always allocating SS_MAXPUSH slots
 * more than asked for, or that it sets PL_savestack_max to
 *
 * These are for internal core use only and are subject to change */

#define dSS_ADD \
    I32 ix = PL_savestack_ix;     \
    ANY *ssp = &PL_savestack[ix]

#define SS_ADD_END(need) \
    assert((need) <= SS_MAXPUSH);                               \
    ix += (need);                                               \
    PL_savestack_ix = ix;                                       \
    assert(ix <= PL_savestack_max + SS_MAXPUSH);                \
    if (UNLIKELY(ix > PL_savestack_max)) savestack_grow();      \
    assert(PL_savestack_ix <= PL_savestack_max);

#define SS_ADD_INT(i)   ((ssp++)->any_i32 = (I32)(i))
#define SS_ADD_LONG(i)  ((ssp++)->any_long = (long)(i))
#define SS_ADD_BOOL(p)  ((ssp++)->any_bool = (p))
#define SS_ADD_IV(i)    ((ssp++)->any_iv = (IV)(i))
#define SS_ADD_UV(u)    ((ssp++)->any_uv = (UV)(u))
#define SS_ADD_PTR(p)   ((ssp++)->any_ptr = (void*)(p))
#define SS_ADD_DPTR(p)  ((ssp++)->any_dptr = (p))
#define SS_ADD_DXPTR(p) ((ssp++)->any_dxptr = (p))

#define SSPOPINT (PL_savestack[--PL_savestack_ix].any_i32)
#define SSPOPLONG (PL_savestack[--PL_savestack_ix].any_long)
#define SSPOPBOOL (PL_savestack[--PL_savestack_ix].any_bool)
#define SSPOPIV (PL_savestack[--PL_savestack_ix].any_iv)
#define SSPOPUV (PL_savestack[--PL_savestack_ix].any_uv)
#define SSPOPPTR (PL_savestack[--PL_savestack_ix].any_ptr)
#define SSPOPDPTR (PL_savestack[--PL_savestack_ix].any_dptr)
#define SSPOPDXPTR (PL_savestack[--PL_savestack_ix].any_dxptr)


/*
=for apidoc_section $callback

=for apidoc Amns||SAVETMPS
Opening bracket for temporaries on a callback.  See C<L</FREETMPS>> and
L<perlcall>.

=for apidoc Amns||FREETMPS
Closing bracket for temporaries on a callback.  See C<L</SAVETMPS>> and
L<perlcall>.

=for apidoc Amns||ENTER
Opening bracket on a callback.  See C<L</LEAVE>> and L<perlcall>.

=for apidoc Amns||LEAVE
Closing bracket on a callback.  See C<L</ENTER>> and L<perlcall>.

=for apidoc Ams||ENTER_with_name|"name"

Same as C<L</ENTER>>, but when debugging is enabled it also associates the
given literal string with the new scope.

=for apidoc Ams||LEAVE_with_name|"name"

Same as C<L</LEAVE>>, but when debugging is enabled it first checks that the
scope has the given name. C<name> must be a literal string.

=cut
*/

#define SAVETMPS Perl_savetmps(aTHX)

#define FREETMPS if (PL_tmps_ix > PL_tmps_floor) free_tmps()

#ifdef DEBUGGING
#define ENTER							\
    STMT_START {						\
        push_scope();						\
        DEBUG_SCOPE("ENTER")					\
    } STMT_END
#define LEAVE							\
    STMT_START {						\
        DEBUG_SCOPE("LEAVE")					\
        pop_scope();						\
    } STMT_END
#define ENTER_with_name(name)						\
    STMT_START {							\
        push_scope();							\
        if (PL_scopestack_name)						\
            PL_scopestack_name[PL_scopestack_ix-1] = ASSERT_IS_LITERAL(name);\
        DEBUG_SCOPE("ENTER \"" name "\"")				\
    } STMT_END
#define LEAVE_with_name(name)						\
    STMT_START {							\
        DEBUG_SCOPE("LEAVE \"" name "\"")				\
        if (PL_scopestack_name)	{					\
            CLANG_DIAG_IGNORE_STMT(-Wstring-compare);			\
            assert(((char*)PL_scopestack_name[PL_scopestack_ix-1]	\
                        == (char*)ASSERT_IS_LITERAL(name))              \
                    || strEQ(PL_scopestack_name[PL_scopestack_ix-1], name));        \
            CLANG_DIAG_RESTORE_STMT;					\
        }								\
        pop_scope();							\
    } STMT_END
#else
#define ENTER push_scope()
#define LEAVE pop_scope()
#define ENTER_with_name(name) ENTER
#define LEAVE_with_name(name) LEAVE
#endif
#define LEAVE_SCOPE(old) STMT_START { \
        if (PL_savestack_ix > old) leave_scope(old); \
    } STMT_END

#define SAVEI8(i)                   save_I8((I8*)&(i))
#define SAVEI16(i)                  save_I16((I16*)&(i))
#define SAVEI32(i)                  save_I32((I32*)&(i))
#define SAVEINT(i)                  save_int((int*)&(i))
#define SAVEIV(i)                   save_iv((IV*)&(i))
#define SAVELONG(l)                 save_long((long*)&(l))
#define SAVESTRLEN(l)               Perl_save_strlen(aTHX_ (STRLEN*)&(l))
#define SAVEBOOL(b)                 save_bool(&(b))
#define SAVESPTR(s)                 save_sptr((SV**)&(s))
#define SAVEPPTR(s)                 save_pptr((char**)&(s))
#define SAVEVPTR(s)                 save_vptr((void*)&(s))
#define SAVEPADSVANDMORTALIZE(s)    save_padsv_and_mortalize(s)
#define SAVEFREESV(s)               save_freesv(MUTABLE_SV(s))
#define SAVEFREEPADNAME(s)          save_pushptr((void *)(s), SAVEt_FREEPADNAME)
#define SAVEMORTALIZESV(s)          save_mortalizesv(MUTABLE_SV(s))
#define SAVEFREEOP(o)               save_freeop((OP*)(o))
#define SAVEFREEPV(p)               save_freepv((char*)(p))
#define SAVECLEARSV(sv)             save_clearsv((SV**)&(sv))
#define SAVEGENERICSV(s)            save_generic_svref((SV**)&(s))
#define SAVEGENERICPV(s)            save_generic_pvref((char**)&(s))
#define SAVESHAREDPV(s)             save_shared_pvref((char**)&(s))
#define SAVESETSVFLAGS(sv,mask,val) save_set_svflags(sv,mask,val)
#define SAVEFREECOPHH(h)            save_pushptr((void *)(h), SAVEt_FREECOPHH)

#define SAVEDELETE(h,k,l) \
          save_delete(MUTABLE_HV(h), (char*)(k), (I32)(l))
#define SAVEHDELETE(h,s) \
          save_hdelete(MUTABLE_HV(h), (s))
#define SAVEADELETE(a,k) \
          save_adelete(MUTABLE_AV(a), (SSize_t)(k))
#define SAVEDESTRUCTOR(f,p) \
          save_destructor((DESTRUCTORFUNC_NOCONTEXT_t)(f), (void*)(p))

#define SAVEDESTRUCTOR_X(f,p) \
          save_destructor_x((DESTRUCTORFUNC_t)(f), (void*)(p))

#define SAVESTACK_POS() \
    STMT_START {				   \
        dSS_ADD;                                   \
        SS_ADD_INT(PL_stack_sp - PL_stack_base);   \
        SS_ADD_UV(SAVEt_STACK_POS);                \
        SS_ADD_END(2);                             \
    } STMT_END

#define SAVEOP()	save_op()

#define SAVEHINTS()	save_hints()

#define SAVECOMPPAD() save_pushptr(MUTABLE_SV(PL_comppad), SAVEt_COMPPAD)

#define SAVESWITCHSTACK(f,t) \
    STMT_START {					\
        save_pushptrptr(MUTABLE_SV(f), MUTABLE_SV(t), SAVEt_SAVESWITCHSTACK); \
        SWITCHSTACK((f),(t));				\
        PL_curstackinfo->si_stack = (t);		\
    } STMT_END

/* Need to do the cop warnings like this, rather than a "SAVEFREESHAREDPV",
   because realloc() means that the value can actually change. Possibly
   could have done savefreesharedpvREF, but this way actually seems cleaner,
   as it simplifies the code that does the saves, and reduces the load on the
   save stack.  */
#define SAVECOMPILEWARNINGS() save_pushptr(PL_compiling.cop_warnings, SAVEt_COMPILE_WARNINGS)

#define SAVEPARSER(p) save_pushptr((p), SAVEt_PARSER)

#ifdef USE_ITHREADS
#  define SAVECOPSTASH_FREE(c)	SAVEIV((c)->cop_stashoff)
#  define SAVECOPFILE(c)	SAVEPPTR(CopFILE(c))
#  define SAVECOPFILE_FREE(c)	SAVESHAREDPV(CopFILE(c))
#else
#  /* XXX not refcounted */
#  define SAVECOPSTASH_FREE(c)	SAVESPTR(CopSTASH(c))
#  define SAVECOPFILE(c)	SAVESPTR(CopFILEGV(c))
#  define SAVECOPFILE_FREE(c)	SAVEGENERICSV(CopFILEGV(c))
#endif

#define SAVECOPLINE(c)		SAVEI32(CopLINE(c))

/*
=for apidoc_section $stack
=for apidoc    Am|I32|SSNEW  |Size_t size
=for apidoc_item |   |SSNEWa |Size_t_size|Size_t align
=for apidoc_item |   |SSNEWt |Size_t size|type
=for apidoc_item |   |SSNEWat|Size_t_size|type|Size_t align

These temporarily allocates data on the savestack, returning an I32 index into
the savestack, because a pointer would get broken if the savestack is moved on
reallocation.  Use L</C<SSPTR>> to convert the returned index into a pointer.

The forms differ in that plain C<SSNEW> allocates C<size> bytes;
C<SSNEWt> and C<SSNEWat> allocate C<size> objects, each of which is type
C<type>;
and <SSNEWa> and C<SSNEWat> make sure to align the new data to an C<align>
boundary.  The most useful value for the alignment is likely to be
L</C<MEM_ALIGNBYTES>>.  The alignment will be preserved through savestack
reallocation B<only> if realloc returns data aligned to a size divisible by
"align"!

=for apidoc   Am|type  |SSPTR |I32 index|type
=for apidoc_item|type *|SSPTRt|I32 index|type

These convert the C<index> returned by L/<C<SSNEW>> and kin into actual pointers.

The difference is that C<SSPTR> casts the result to C<type>, and C<SSPTRt>
casts it to a pointer of that C<type>.

=cut
 */

#define SSNEW(size)             Perl_save_alloc(aTHX_ (size), 0)
#define SSNEWt(n,t)             SSNEW((n)*sizeof(t))
#define SSNEWa(size,align)	Perl_save_alloc(aTHX_ (size), \
    (I32)(align - ((size_t)((caddr_t)&PL_savestack[PL_savestack_ix]) % align)) % align)
#define SSNEWat(n,t,align)	SSNEWa((n)*sizeof(t), align)

#define SSPTR(off,type)         ((type)  ((char*)PL_savestack + off))
#define SSPTRt(off,type)        ((type*) ((char*)PL_savestack + off))

#define save_freesv(op)		save_pushptr((void *)(op), SAVEt_FREESV)
#define save_mortalizesv(op)	save_pushptr((void *)(op), SAVEt_MORTALIZESV)

# define save_freeop(op)                    \
STMT_START {                                 \
      OP * const _o = (OP *)(op);             \
      assert(!_o->op_savefree);               \
      _o->op_savefree = 1;                     \
      save_pushptr((void *)(_o), SAVEt_FREEOP); \
    } STMT_END
#define save_freepv(pv)		save_pushptr((void *)(pv), SAVEt_FREEPV)

/*
=for apidoc_section $callback
=for apidoc save_op

Implements C<SAVEOP>.

=cut
 */

#define save_op()		save_pushptr((void *)(PL_op), SAVEt_OP)

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /*    sv_inline.h
 *
 *    Copyright (C) 2022 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

/* This file contains the newSV_type and newSV_type_mortal functions, as well as
 * the various struct and macro definitions they require. In the main, these
 * definitions were moved from sv.c, where many of them continue to also be used.
 * (In Perl_more_bodies, Perl_sv_upgrade and Perl_sv_clear, for example.) Code
 * comments associated with definitions and functions were also copied across
 * verbatim.
 *
 * The rationale for having these as inline functions, rather than in sv.c, is
 * that the target type is very often known at compile time, and therefore
 * optimum code can be emitted by the compiler, rather than having all calls
 * traverse the many branches of Perl_sv_upgrade at runtime.
 */

/* This definition came from perl.h*/

/* The old value was hard coded at 1008. (4096-16) seems to be a bit faster,
   at least on FreeBSD.  YMMV, so experiment.  */
#ifndef PERL_ARENA_SIZE
#define PERL_ARENA_SIZE 4080
#endif

/* All other pre-existing definitions and functions that were moved into this
 * file originally came from sv.c. */

#ifdef PERL_POISON
#  define SvARENA_CHAIN(sv)     ((sv)->sv_u.svu_rv)
#  define SvARENA_CHAIN_SET(sv,val)     (sv)->sv_u.svu_rv = MUTABLE_SV((val))
/* Whilst I'd love to do this, it seems that things like to check on
   unreferenced scalars
#  define POISON_SV_HEAD(sv)    PoisonNew(sv, 1, struct STRUCT_SV)
*/
#  define POISON_SV_HEAD(sv)    PoisonNew(&SvANY(sv), 1, void *), \
                                PoisonNew(&SvREFCNT(sv), 1, U32)
#else
#  define SvARENA_CHAIN(sv)     SvANY(sv)
#  define SvARENA_CHAIN_SET(sv,val)     SvANY(sv) = (void *)(val)
#  define POISON_SV_HEAD(sv)
#endif

#ifdef PERL_MEM_LOG
#  define MEM_LOG_NEW_SV(sv, file, line, func)  \
            Perl_mem_log_new_sv(sv, file, line, func)
#  define MEM_LOG_DEL_SV(sv, file, line, func)  \
            Perl_mem_log_del_sv(sv, file, line, func)
#else
#  define MEM_LOG_NEW_SV(sv, file, line, func)  NOOP
#  define MEM_LOG_DEL_SV(sv, file, line, func)  NOOP
#endif

#define uproot_SV(p) \
    STMT_START {                                        \
        (p) = PL_sv_root;                               \
        PL_sv_root = MUTABLE_SV(SvARENA_CHAIN(p));              \
        ++PL_sv_count;                                  \
    } STMT_END

/* Perl_more_sv lives in sv.c, we don't want to inline it.
 * but the function declaration seems to be needed. */
SV* Perl_more_sv(pTHX);

/* new_SV(): return a new, empty SV head */

#ifdef DEBUG_LEAKING_SCALARS
/* provide a real function for a debugger to play with */
STATIC SV*
S_new_SV(pTHX_ const char *file, int line, const char *func)
{
    SV* sv;

    if (PL_sv_root)
        uproot_SV(sv);
    else
        sv = Perl_more_sv(aTHX);
    SvANY(sv) = 0;
    SvREFCNT(sv) = 1;
    SvFLAGS(sv) = 0;
    sv->sv_debug_optype = PL_op ? PL_op->op_type : 0;
    sv->sv_debug_line = (U16) (PL_parser && PL_parser->copline != NOLINE
                ? PL_parser->copline
                :  PL_curcop
                    ? CopLINE(PL_curcop)
                    : 0
            );
    sv->sv_debug_inpad = 0;
    sv->sv_debug_parent = NULL;
    sv->sv_debug_file = PL_curcop ? savesharedpv(CopFILE(PL_curcop)): NULL;

    sv->sv_debug_serial = PL_sv_serial++;

    MEM_LOG_NEW_SV(sv, file, line, func);
    DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%" UVxf ": (%05ld) new_SV (from %s:%d [%s])\n",
            PTR2UV(sv), (long)sv->sv_debug_serial, file, line, func));

    return sv;
}
#  define new_SV(p) (p)=S_new_SV(aTHX_ __FILE__, __LINE__, FUNCTION__)

#else
#  define new_SV(p) \
    STMT_START {                                       \
        if (PL_sv_root)                                        \
            uproot_SV(p);                              \
        else                                           \
            (p) = Perl_more_sv(aTHX);                     \
        SvANY(p) = 0;                                  \
        SvREFCNT(p) = 1;                               \
        SvFLAGS(p) = 0;                                        \
        MEM_LOG_NEW_SV(p, __FILE__, __LINE__, FUNCTION__);  \
    } STMT_END
#endif


typedef struct xpvhv_with_aux XPVHV_WITH_AUX;

struct body_details {
    U8 body_size;      /* Size to allocate  */
    U8 copy;           /* Size of structure to copy (may be shorter)  */
    U8 offset;         /* Size of unalloced ghost fields to first alloced field*/
    PERL_BITFIELD8 type : 4;        /* We have space for a sanity check. */
    PERL_BITFIELD8 cant_upgrade : 1;/* Cannot upgrade this type */
    PERL_BITFIELD8 zero_nv : 1;     /* zero the NV when upgrading from this */
    PERL_BITFIELD8 arena : 1;       /* Allocated from an arena */
    U32 arena_size;                 /* Size of arena to allocate */
};

#define ALIGNED_TYPE_NAME(name) name##_aligned
#define ALIGNED_TYPE(name)             \
    typedef union {    \
        name align_me;                         \
        NV nv;                         \
        IV iv;                         \
    } ALIGNED_TYPE_NAME(name)

ALIGNED_TYPE(regexp);
ALIGNED_TYPE(XPVGV);
ALIGNED_TYPE(XPVLV);
ALIGNED_TYPE(XPVAV);
ALIGNED_TYPE(XPVHV);
ALIGNED_TYPE(XPVHV_WITH_AUX);
ALIGNED_TYPE(XPVCV);
ALIGNED_TYPE(XPVFM);
ALIGNED_TYPE(XPVIO);

#define HADNV FALSE
#define NONV TRUE


#ifdef PURIFY
/* With -DPURFIY we allocate everything directly, and don't use arenas.
   This seems a rather elegant way to simplify some of the code below.  */
#define HASARENA FALSE
#else
#define HASARENA TRUE
#endif
#define NOARENA FALSE

/* Size the arenas to exactly fit a given number of bodies.  A count
   of 0 fits the max number bodies into a PERL_ARENA_SIZE.block,
   simplifying the default.  If count > 0, the arena is sized to fit
   only that many bodies, allowing arenas to be used for large, rare
   bodies (XPVFM, XPVIO) without undue waste.  The arena size is
   limited by PERL_ARENA_SIZE, so we can safely oversize the
   declarations.
 */
#define FIT_ARENA0(body_size)                          \
    ((size_t)(PERL_ARENA_SIZE / body_size) * body_size)
#define FIT_ARENAn(count,body_size)                    \
    ( count * body_size <= PERL_ARENA_SIZE)            \
    ? count * body_size                                        \
    : FIT_ARENA0 (body_size)
#define FIT_ARENA(count,body_size)                     \
   (U32)(count                                                 \
    ? FIT_ARENAn (count, body_size)                    \
    : FIT_ARENA0 (body_size))

/* Calculate the length to copy. Specifically work out the length less any
   final padding the compiler needed to add.  See the comment in sv_upgrade
   for why copying the padding proved to be a bug.  */

#define copy_length(type, last_member) \
        STRUCT_OFFSET(type, last_member) \
        + sizeof (((type*)SvANY((const SV *)0))->last_member)

static const struct body_details bodies_by_type[] = {
    /* HEs use this offset for their arena.  */
    { 0, 0, 0, SVt_NULL, FALSE, NONV, NOARENA, 0 },

    /* IVs are in the head, so the allocation size is 0.  */
    { 0,
      sizeof(IV), /* This is used to copy out the IV body.  */
      STRUCT_OFFSET(XPVIV, xiv_iv), SVt_IV, FALSE, NONV,
      NOARENA /* IVS don't need an arena  */, 0
    },

#if NVSIZE <= IVSIZE
    { 0, sizeof(NV),
      STRUCT_OFFSET(XPVNV, xnv_u),
      SVt_NV, FALSE, HADNV, NOARENA, 0 },
#else
    { sizeof(NV), sizeof(NV),
      STRUCT_OFFSET(XPVNV, xnv_u),
      SVt_NV, FALSE, HADNV, HASARENA, FIT_ARENA(0, sizeof(NV)) },
#endif

    { sizeof(XPV) - STRUCT_OFFSET(XPV, xpv_cur),
      copy_length(XPV, xpv_len) - STRUCT_OFFSET(XPV, xpv_cur),
      + STRUCT_OFFSET(XPV, xpv_cur),
      SVt_PV, FALSE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(XPV) - STRUCT_OFFSET(XPV, xpv_cur)) },

    { sizeof(XINVLIST) - STRUCT_OFFSET(XPV, xpv_cur),
      copy_length(XINVLIST, is_offset) - STRUCT_OFFSET(XPV, xpv_cur),
      + STRUCT_OFFSET(XPV, xpv_cur),
      SVt_INVLIST, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(XINVLIST) - STRUCT_OFFSET(XPV, xpv_cur)) },

    { sizeof(XPVIV) - STRUCT_OFFSET(XPV, xpv_cur),
      copy_length(XPVIV, xiv_u) - STRUCT_OFFSET(XPV, xpv_cur),
      + STRUCT_OFFSET(XPV, xpv_cur),
      SVt_PVIV, FALSE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(XPVIV) - STRUCT_OFFSET(XPV, xpv_cur)) },

    { sizeof(XPVNV) - STRUCT_OFFSET(XPV, xpv_cur),
      copy_length(XPVNV, xnv_u) - STRUCT_OFFSET(XPV, xpv_cur),
      + STRUCT_OFFSET(XPV, xpv_cur),
      SVt_PVNV, FALSE, HADNV, HASARENA,
      FIT_ARENA(0, sizeof(XPVNV) - STRUCT_OFFSET(XPV, xpv_cur)) },

    { sizeof(XPVMG), copy_length(XPVMG, xnv_u), 0, SVt_PVMG, FALSE, HADNV,
      HASARENA, FIT_ARENA(0, sizeof(XPVMG)) },

    { sizeof(ALIGNED_TYPE_NAME(regexp)),
      sizeof(regexp),
      0,
      SVt_REGEXP, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(regexp)))
    },

    { sizeof(ALIGNED_TYPE_NAME(XPVGV)), sizeof(XPVGV), 0, SVt_PVGV, TRUE, HADNV,
      HASARENA, FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVGV))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVLV)), sizeof(XPVLV), 0, SVt_PVLV, TRUE, HADNV,
      HASARENA, FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVLV))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVAV)),
      copy_length(XPVAV, xav_alloc),
      0,
      SVt_PVAV, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVAV))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVHV)),
      copy_length(XPVHV, xhv_max),
      0,
      SVt_PVHV, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVHV))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVCV)),
      sizeof(XPVCV),
      0,
      SVt_PVCV, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVCV))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVFM)),
      sizeof(XPVFM),
      0,
      SVt_PVFM, TRUE, NONV, NOARENA,
      FIT_ARENA(20, sizeof(ALIGNED_TYPE_NAME(XPVFM))) },

    { sizeof(ALIGNED_TYPE_NAME(XPVIO)),
      sizeof(XPVIO),
      0,
      SVt_PVIO, TRUE, NONV, HASARENA,
      FIT_ARENA(24, sizeof(ALIGNED_TYPE_NAME(XPVIO))) },
};

#define new_body_allocated(sv_type)            \
    (void *)((char *)S_new_body(aTHX_ sv_type) \
             - bodies_by_type[sv_type].offset)

#ifdef PURIFY
#if !(NVSIZE <= IVSIZE)
#  define new_XNV()    safemalloc(sizeof(XPVNV))
#endif
#define new_XPVNV()    safemalloc(sizeof(XPVNV))
#define new_XPVMG()    safemalloc(sizeof(XPVMG))

#define del_body_by_type(p, type)       safefree(p)

#else /* !PURIFY */

#if !(NVSIZE <= IVSIZE)
#  define new_XNV()    new_body_allocated(SVt_NV)
#endif
#define new_XPVNV()    new_body_allocated(SVt_PVNV)
#define new_XPVMG()    new_body_allocated(SVt_PVMG)

#define del_body_by_type(p, type)                               \
    del_body(p + bodies_by_type[(type)].offset,                 \
             &PL_body_roots[(type)])

#endif /* PURIFY */

/* no arena for you! */

#define new_NOARENA(details) \
        safemalloc((details)->body_size + (details)->offset)
#define new_NOARENAZ(details) \
        safecalloc((details)->body_size + (details)->offset, 1)

#ifndef PURIFY

/* grab a new thing from the arena's free list, allocating more if necessary. */
#define new_body_from_arena(xpv, root_index, type_meta) \
    STMT_START { \
        void ** const r3wt = &PL_body_roots[root_index]; \
        xpv = (PTR_TBL_ENT_t*) (*((void **)(r3wt))      \
          ? *((void **)(r3wt)) : Perl_more_bodies(aTHX_ root_index, \
                                             type_meta.body_size,\
                                             type_meta.arena_size)); \
        *(r3wt) = *(void**)(xpv); \
    } STMT_END

PERL_STATIC_INLINE void *
S_new_body(pTHX_ const svtype sv_type)
{
    void *xpv;
    new_body_from_arena(xpv, sv_type, bodies_by_type[sv_type]);
    return xpv;
}

#endif

static const struct body_details fake_rv =
    { 0, 0, 0, SVt_IV, FALSE, NONV, NOARENA, 0 };

static const struct body_details fake_hv_with_aux =
    /* The SVt_IV arena is used for (larger) PVHV bodies.  */
    { sizeof(ALIGNED_TYPE_NAME(XPVHV_WITH_AUX)),
      copy_length(XPVHV, xhv_max),
      0,
      SVt_PVHV, TRUE, NONV, HASARENA,
      FIT_ARENA(0, sizeof(ALIGNED_TYPE_NAME(XPVHV_WITH_AUX))) };

/*
=for apidoc newSV_type

Creates a new SV, of the type specified.  The reference count for the new SV
is set to 1.

=cut
*/

PERL_STATIC_INLINE SV *
Perl_newSV_type(pTHX_ const svtype type)
{
    SV *sv;
    void*      new_body;
    const struct body_details *type_details;

    new_SV(sv);

    type_details = bodies_by_type + type;

    SvFLAGS(sv) &= ~SVTYPEMASK;
    SvFLAGS(sv) |= type;

    switch (type) {
    case SVt_NULL:
        break;
    case SVt_IV:
        SET_SVANY_FOR_BODYLESS_IV(sv);
        SvIV_set(sv, 0);
        break;
    case SVt_NV:
#if NVSIZE <= IVSIZE
        SET_SVANY_FOR_BODYLESS_NV(sv);
#else
        SvANY(sv) = new_XNV();
#endif
        SvNV_set(sv, 0);
        break;
    case SVt_PVHV:
    case SVt_PVAV:
        assert(type_details->body_size);

#ifndef PURIFY
        assert(type_details->arena);
        assert(type_details->arena_size);
        /* This points to the start of the allocated area.  */
        new_body = S_new_body(aTHX_ type);
        /* xpvav and xpvhv have no offset, so no need to adjust new_body */
        assert(!(type_details->offset));
#else
        /* We always allocated the full length item with PURIFY. To do this
           we fake things so that arena is false for all 16 types..  */
        new_body = new_NOARENAZ(type_details);
#endif
        SvANY(sv) = new_body;

        SvSTASH_set(sv, NULL);
        SvMAGIC_set(sv, NULL);

        if (type == SVt_PVAV) {
            AvFILLp(sv) = -1;
            AvMAX(sv) = -1;
            AvALLOC(sv) = NULL;

            AvREAL_only(sv);
        } else {
            HvTOTALKEYS(sv) = 0;
            /* start with PERL_HASH_DEFAULT_HvMAX+1 buckets: */
            HvMAX(sv) = PERL_HASH_DEFAULT_HvMAX;

            assert(!SvOK(sv));
            SvOK_off(sv);
#ifndef NODEFAULT_SHAREKEYS
            HvSHAREKEYS_on(sv);         /* key-sharing on by default */
#endif
            /* start with PERL_HASH_DEFAULT_HvMAX+1 buckets: */
            HvMAX(sv) = PERL_HASH_DEFAULT_HvMAX;
        }

        sv->sv_u.svu_array = NULL; /* or svu_hash  */
        break;

    case SVt_PVIV:
    case SVt_PVIO:
    case SVt_PVGV:
    case SVt_PVCV:
    case SVt_PVLV:
    case SVt_INVLIST:
    case SVt_REGEXP:
    case SVt_PVMG:
    case SVt_PVNV:
    case SVt_PV:
        /* For a type known at compile time, it should be possible for the
         * compiler to deduce the value of (type_details->arena), resolve
         * that branch below, and inline the relevant values from
         * bodies_by_type. Except, at least for gcc, it seems not to do that.
         * We help it out here with two deviations from sv_upgrade:
         * (1) Minor rearrangement here, so that PVFM - the only type at this
         *     point not to be allocated from an array appears last, not PV.
         * (2) The ASSUME() statement here for everything that isn't PVFM.
         * Obviously this all only holds as long as it's a true reflection of
         * the bodies_by_type lookup table. */
#ifndef PURIFY
         ASSUME(type_details->arena);
#endif
         /* FALLTHROUGH */
    case SVt_PVFM:

        assert(type_details->body_size);
        /* We always allocated the full length item with PURIFY. To do this
           we fake things so that arena is false for all 16 types..  */
#ifndef PURIFY
        if(type_details->arena) {
            /* This points to the start of the allocated area.  */
            new_body = S_new_body(aTHX_ type);
            Zero(new_body, type_details->body_size, char);
            new_body = ((char *)new_body) - type_details->offset;
        } else
#endif
        {
            new_body = new_NOARENAZ(type_details);
        }
        SvANY(sv) = new_body;

        if (UNLIKELY(type == SVt_PVIO)) {
            IO * const io = MUTABLE_IO(sv);
            GV *iogv = gv_fetchpvs("IO::File::", GV_ADD, SVt_PVHV);

            SvOBJECT_on(io);
            /* Clear the stashcache because a new IO could overrule a package
               name */
            DEBUG_o(Perl_deb(aTHX_ "sv_upgrade clearing PL_stashcache\n"));
            hv_clear(PL_stashcache);

            SvSTASH_set(io, MUTABLE_HV(SvREFCNT_inc(GvHV(iogv))));
            IoPAGE_LEN(sv) = 60;
        }

        sv->sv_u.svu_rv = NULL;
        break;
    default:
        Perl_croak(aTHX_ "panic: sv_upgrade to unknown type %lu",
                   (unsigned long)type);
    }

    return sv;
}

/*
=for apidoc newSV_type_mortal

Creates a new mortal SV, of the type specified.  The reference count for the
new SV is set to 1.

This is equivalent to
    SV* sv = sv_2mortal(newSV_type(<some type>))
and
    SV* sv = sv_newmortal();
    sv_upgrade(sv, <some_type>)
but should be more efficient than both of them. (Unless sv_2mortal is inlined
at some point in the future.)

=cut
*/

PERL_STATIC_INLINE SV *
Perl_newSV_type_mortal(pTHX_ const svtype type)
{
    SV *sv = newSV_type(type);
    SSize_t ix = ++PL_tmps_ix;
    if (UNLIKELY(ix >= PL_tmps_max))
        ix = Perl_tmps_grow_p(aTHX_ ix);
    PL_tmps_stack[ix] = (sv);
    SvTEMP_on(sv);
    return sv;
}

/*
 * ex: set ts=8 sts=4 sw=4 et:
 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     