1;AL # ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM
FDA2;AL # ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM
FDA3;AL # ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM
FDA4;AL # ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM
FDA5;AL # ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM
FDA6;AL # ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM
FDA7;AL # ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM
FDA8;AL # ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM
FDA9;AL # ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM
FDAA;AL # ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM
FDAB;AL # ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM
FDAC;AL # ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM
FDAD;AL # ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM
FDAE;AL # ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM
FDAF;AL # ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM
FDB0;AL # ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM
FDB1;AL # ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM
FDB2;AL # ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM
FDB3;AL # ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM
FDB4;AL # ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM
FDB5;AL # ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM
FDB6;AL # ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM
FDB7;AL # ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM
FDB8;AL # ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM
FDB9;AL # ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM
FDBA;AL # ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM
FDBB;AL # ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM
FDBC;AL # ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM
FDBD;AL # ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM
FDBE;AL # ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM
FDBF;AL # ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM
FDC0;AL # ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM
FDC1;AL # ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM
FDC2;AL # ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM
FDC3;AL # ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM
FDC4;AL # ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM
FDC5;AL # ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM
FDC6;AL # ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM
FDC7;AL # ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM
FDF0;AL # ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM
FDF1;AL # ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM
FDF2;AL # ARABIC LIGATURE ALLAH ISOLATED FORM
FDF3;AL # ARABIC LIGATURE AKBAR ISOLATED FORM
FDF4;AL # ARABIC LIGATURE MOHAMMAD ISOLATED FORM
FDF5;AL # ARABIC LIGATURE SALAM ISOLATED FORM
FDF6;AL # ARABIC LIGATURE RASOUL ISOLATED FORM
FDF7;AL # ARABIC LIGATURE ALAYHE ISOLATED FORM
FDF8;AL # ARABIC LIGATURE WASALLAM ISOLATED FORM
FDF9;AL # ARABIC LIGATURE SALLA ISOLATED FORM
FDFA;AL # ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM
FDFB;AL # ARABIC LIGATURE JALLAJALALOUHOU
FDFC;PO # RIAL SIGN
FDFD;AL # ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM
FE00;CM # VARIATION SELECTOR-1
FE01;CM # VARIATION SELECTOR-2
FE02;CM # VARIATION SELECTOR-3
FE03;CM # VARIATION SELECTOR-4
FE04;CM # VARIATION SELECTOR-5
FE05;CM # VARIATION SELECTOR-6
FE06;CM # VARIATION SELECTOR-7
FE07;CM # VARIATION SELECTOR-8
FE08;CM # VARIATION SELECTOR-9
FE09;CM # VARIATION SELECTOR-10
FE0A;CM # VARIATION SELECTOR-11
FE0B;CM # VARIATION SELECTOR-12
FE0C;CM # VARIATION SELECTOR-13
FE0D;CM # VARIATION SELECTOR-14
FE0E;CM # VARIATION SELECTOR-15
FE0F;CM # VARIATION SELECTOR-16
FE10;IS # PRESENTATION FORM FOR VERTICAL COMMA
FE11;CL # PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA
FE12;CL # PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP
FE13;IS # PRESENTATION FORM FOR VERTICAL COLON
FE14;IS # PRESENTATION FORM FOR VERTICAL SEMICOLON
FE15;EX # PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK
FE16;EX # PRESENTATION FORM FOR VERTICAL QUESTION MARK
FE17;OP # PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET
FE18;CL # PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET
FE19;IN # PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
FE20;CM # COMBINING LIGATURE LEFT HALF
FE21;CM # COMBINING LIGATURE RIGHT HALF
FE22;CM # COMBINING DOUBLE TILDE LEFT HALF
FE23;CM # COMBINING DOUBLE TILDE RIGHT HALF
FE30;ID # PRESENTATION FORM FOR VERTICAL TWO DOT LEADER
FE31;ID # PRESENTATION FORM FOR VERTICAL EM DASH
FE32;ID # PRESENTATION FORM FOR VERTICAL EN DASH
FE33;ID # PRESENTATION FORM FOR VERTICAL LOW LINE
FE34;ID # PRESENTATION FORM FOR VERTICAL WAVY LOW LINE
FE35;OP # PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
FE36;CL # PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
FE37;OP # PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
FE38;CL # PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
FE39;OP # PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET
FE3A;CL # PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET
FE3B;OP # PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET
FE3C;CL # PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET
FE3D;OP # PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET
FE3E;CL # PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET
FE3F;OP # PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET
FE40;CL # PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET
FE41;OP # PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET
FE42;CL # PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET
FE43;OP # PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET
FE44;CL # PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
FE45;ID # SESAME DOT
FE46;ID # WHITE SESAME DOT
FE47;OP # PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET
FE48;CL # PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET
FE49;ID # DASHED OVERLINE
FE4A;ID # CENTRELINE OVERLINE
FE4B;ID # WAVY OVERLINE
FE4C;ID # DOUBLE WAVY OVERLINE
FE4D;ID # DASHED LOW LINE
FE4E;ID # CENTRELINE LOW LINE
FE4F;ID # WAVY LOW LINE
FE50;CL # SMALL COMMA
FE51;ID # SMALL IDEOGRAPHIC COMMA
FE52;CL # SMALL FULL STOP
FE54;NS # SMALL SEMICOLON
FE55;NS # SMALL COLON
FE56;EX # SMALL QUESTION MARK
FE57;EX # SMALL EXCLAMATION MARK
FE58;ID # SMALL EM DASH
FE59;OP # SMALL LEFT PARENTHESIS
FE5A;CL # SMALL RIGHT PARENTHESIS
FE5B;OP # SMALL LEFT CURLY BRACKET
FE5C;CL # SMALL RIGHT CURLY BRACKET
FE5D;OP # SMALL LEFT TORTOISE SHELL BRACKET
FE5E;CL # SMALL RIGHT TORTOISE SHELL BRACKET
FE5F;ID # SMALL NUMBER SIGN
FE60;ID # SMALL AMPERSAND
FE61;ID # SMALL ASTERISK
FE62;ID # SMALL PLUS SIGN
FE63;ID # SMALL HYPHEN-MINUS
FE64;ID # SMALL LESS-THAN SIGN
FE65;ID # SMALL GREATER-THAN SIGN
FE66;ID # SMALL EQUALS SIGN
FE68;ID # SMALL REVERSE SOLIDUS
FE69;PR # SMALL DOLLAR SIGN
FE6A;PO # SMALL PERCENT SIGN
FE6B;ID # SMALL COMMERCIAL AT
FE70;AL # ARABIC FATHATAN ISOLATED FORM
FE71;AL # ARABIC TATWEEL WITH FATHATAN ABOVE
FE72;AL # ARABIC DAMMATAN ISOLATED FORM
FE73;AL # ARABIC TAIL FRAGMENT
FE74;AL # ARABIC KASRATAN ISOLATED FORM
FE76;AL # ARABIC FATHA ISOLATED FORM
FE77;AL # ARABIC FATHA MEDIAL FORM
FE78;AL # ARABIC DAMMA ISOLATED FORM
FE79;AL # ARABIC DAMMA MEDIAL FORM
FE7A;AL # ARABIC KASRA ISOLATED FORM
FE7B;AL # ARABIC KASRA MEDIAL FORM
FE7C;AL # ARABIC SHADDA ISOLATED FORM
FE7D;AL # ARABIC SHADDA MEDIAL FORM
FE7E;AL # ARABIC SUKUN ISOLATED FORM
FE7F;AL # ARABIC SUKUN MEDIAL FORM
FE80;AL # ARABIC LETTER HAMZA ISOLATED FORM
FE81;AL # ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM
FE82;AL # ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM
FE83;AL # ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM
FE84;AL # ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM
FE85;AL # ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM
FE86;AL # ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM
FE87;AL # ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM
FE88;AL # ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM
FE89;AL # ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM
FE8A;AL # ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM
FE8B;AL # ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM
FE8C;AL # ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM
FE8D;AL # ARABIC LETTER ALEF ISOLATED FORM
FE8E;AL # ARABIC LETTER ALEF FINAL FORM
FE8F;AL # ARABIC LETTER BEH ISOLATED FORM
FE90;AL # ARABIC LETTER BEH FINAL FORM
FE91;AL # ARABIC LETTER BEH INITIAL FORM
FE92;AL # ARABIC LETTER BEH MEDIAL FORM
FE93;AL # ARABIC LETTER TEH MARBUTA ISOLATED FORM
FE94;AL # ARABIC LETTER TEH MARBUTA FINAL FORM
FE95;AL # ARABIC LETTER TEH ISOLATED FORM
FE96;AL # ARABIC LETTER TEH FINAL FORM
FE97;AL # ARABIC LETTER TEH INITIAL FORM
FE98;AL # ARABIC LETTER TEH MEDIAL FORM
FE99;AL # ARABIC LETTER THEH ISOLATED FORM
FE9A;AL # ARABIC LETTER THEH FINAL FORM
FE9B;AL # ARABIC LETTER THEH INITIAL FORM
FE9C;AL # ARABIC LETTER THEH MEDIAL FORM
FE9D;AL # ARABIC LETTER JEEM ISOLATED FORM
FE9E;AL # ARABIC LETTER JEEM FINAL FORM
FE9F;AL # ARABIC LETTER JEEM INITIAL FORM
FEA0;AL # ARABIC LETTER JEEM MEDIAL FORM
FEA1;AL # ARABIC LETTER HAH ISOLATED FORM
FEA2;AL # ARABIC LETTER HAH FINAL FORM
FEA3;AL # ARABIC LETTER HAH INITIAL FORM
FEA4;AL # ARABIC LETTER HAH MEDIAL FORM
FEA5;AL # ARABIC LETTER KHAH ISOLATED FORM
FEA6;AL # ARABIC LETTER KHAH FINAL FORM
FEA7;AL # ARABIC LETTER KHAH INITIAL FORM
FEA8;AL # ARABIC LETTER KHAH MEDIAL FORM
FEA9;AL # ARABIC LETTER DAL ISOLATED FORM
FEAA;AL # ARABIC LETTER DAL FINAL FORM
FEAB;AL # ARABIC LETTER THAL ISOLATED FORM
FEAC;AL # ARABIC LETTER THAL FINAL FORM
FEAD;AL # ARABIC LETTER REH ISOLATED FORM
FEAE;AL # ARABIC LETTER REH FINAL FORM
FEAF;AL # ARABIC LETTER ZAIN ISOLATED FORM
FEB0;AL # ARABIC LETTER ZAIN FINAL FORM
FEB1;AL # ARABIC LETTER SEEN ISOLATED FORM
FEB2;AL # ARABIC LETTER SEEN FINAL FORM
FEB3;AL # ARABIC LETTER SEEN INITIAL FORM
FEB4;AL # ARABIC LETTER SEEN MEDIAL FORM
FEB5;AL # ARABIC LETTER SHEEN ISOLATED FORM
FEB6;AL # ARABIC LETTER SHEEN FINAL FORM
FEB7;AL # ARABIC LETTER SHEEN INITIAL FORM
FEB8;AL # ARABIC LETTER SHEEN MEDIAL FORM
FEB9;AL # ARABIC LETTER SAD ISOLATED FORM
FEBA;AL # ARABIC LETTER SAD FINAL FORM
FEBB;AL # ARABIC LETTER SAD INITIAL FORM
FEBC;AL # ARABIC LETTER SAD MEDIAL FORM
FEBD;AL # ARABIC LETTER DAD ISOLATED FORM
FEBE;AL # ARABIC LETTER DAD FINAL FORM
FEBF;AL # ARABIC LETTER DAD INITIAL FORM
FEC0;AL # ARABIC LETTER DAD MEDIAL FORM
FEC1;AL # ARABIC LETTER TAH ISOLATED FORM
FEC2;AL # ARABIC LETTER TAH FINAL FORM
FEC3;AL # ARABIC LETTER TAH INITIAL FORM
FEC4;AL # ARABIC LETTER TAH MEDIAL FORM
FEC5;AL # ARABIC LETTER ZAH ISOLATED FORM
FEC6;AL # ARABIC LETTER ZAH FINAL FORM
FEC7;AL # ARABIC LETTER ZAH INITIAL FORM
FEC8;AL # ARABIC LETTER ZAH MEDIAL FORM
FEC9;AL # ARABIC LETTER AIN ISOLATED FORM
FECA;AL # ARABIC LETTER AIN FINAL FORM
FECB;AL # ARABIC LETTER AIN INITIAL FORM
FECC;AL # ARABIC LETTER AIN MEDIAL FORM
FECD;AL # ARABIC LETTER GHAIN ISOLATED FORM
FECE;AL # ARABIC LETTER GHAIN FINAL FORM
FECF;AL # ARABIC LETTER GHAIN INITIAL FORM
FED0;AL # ARABIC LETTER GHAIN MEDIAL FORM
FED1;AL # ARABIC LETTER FEH ISOLATED FORM
FED2;AL # ARABIC LETTER FEH FINAL FORM
FED3;AL # ARABIC LETTER FEH INITIAL FORM
FED4;AL # ARABIC LETTER FEH MEDIAL FORM
FED5;AL # ARABIC LETTER QAF ISOLATED FORM
FED6;AL # ARABIC LETTER QAF FINAL FORM
FED7;AL # ARABIC LETTER QAF INITIAL FORM
FED8;AL # ARABIC LETTER QAF MEDIAL FORM
FED9;AL # ARABIC LETTER KAF ISOLATED FORM
FEDA;AL # ARABIC LETTER KAF FINAL FORM
FEDB;AL # ARABIC LETTER KAF INITIAL FORM
FEDC;AL # ARABIC LETTER KAF MEDIAL FORM
FEDD;AL # ARABIC LETTER LAM ISOLATED FORM
FEDE;AL # ARABIC LETTER LAM FINAL FORM
FEDF;AL # ARABIC LETTER LAM INITIAL FORM
FEE0;AL # ARABIC LETTER LAM MEDIAL FORM
FEE1;AL # ARABIC LETTER MEEM ISOLATED FORM
FEE2;AL # ARABIC LETTER MEEM FINAL FORM
FEE3;AL # ARABIC LETTER MEEM INITIAL FORM
FEE4;AL # ARABIC LETTER MEEM MEDIAL FORM
FEE5;AL # ARABIC LETTER NOON ISOLATED FORM
FEE6;AL # ARABIC LETTER NOON FINAL FORM
FEE7;AL # ARABIC LETTER NOON INITIAL FORM
FEE8;AL # ARABIC LETTER NOON MEDIAL FORM
FEE9;AL # ARABIC LETTER HEH ISOLATED FORM
FEEA;AL # ARABIC LETTER HEH FINAL FORM
FEEB;AL # ARABIC LETTER HEH INITIAL FORM
FEEC;AL # ARABIC LETTER HEH MEDIAL FORM
FEED;AL # ARABIC LETTER WAW ISOLATED FORM
FEEE;AL # ARABIC LETTER WAW FINAL FORM
FEEF;AL # ARABIC LETTER ALEF MAKSURA ISOLATED FORM
FEF0;AL # ARABIC LETTER ALEF MAKSURA FINAL FORM
FEF1;AL # ARABIC LETTER YEH ISOLATED FORM
FEF2;AL # ARABIC LETTER YEH FINAL FORM
FEF3;AL # ARABIC LETTER YEH INITIAL FORM
FEF4;AL # ARABIC LETTER YEH MEDIAL FORM
FEF5;AL # ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM
FEF6;AL # ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM
FEF7;AL # ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM
FEF8;AL # ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM
FEF9;AL # ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM
FEFA;AL # ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM
FEFB;AL # ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM
FEFC;AL # ARABIC LIGATURE LAM WITH ALEF FINAL FORM
FEFF;WJ # ZERO WIDTH NO-BREAK SPACE
FF01;EX # FULLWIDTH EXCLAMATION MARK
FF02;ID # FULLWIDTH QUOTATION MARK
FF03;ID # FULLWIDTH NUMBER SIGN
FF04;PR # FULLWIDTH DOLLAR SIGN
FF05;PO # FULLWIDTH PERCENT SIGN
FF06;ID # FULLWIDTH AMPERSAND
FF07;ID # FULLWIDTH APOSTROPHE
FF08;OP # FULLWIDTH LEFT PARENTHESIS
FF09;CL # FULLWIDTH RIGHT PARENTHESIS
FF0A;ID # FULLWIDTH ASTERISK
FF0B;ID # FULLWIDTH PLUS SIGN
FF0C;CL # FULLWIDTH COMMA
FF0D;ID # FULLWIDTH HYPHEN-MINUS
FF0E;CL # FULLWIDTH FULL STOP
FF0F;ID # FULLWIDTH SOLIDUS
FF10;ID # FULLWIDTH DIGIT ZERO
FF11;ID # FULLWIDTH DIGIT ONE
FF12;ID # FULLWIDTH DIGIT TWO
FF13;ID # FULLWIDTH DIGIT THREE
FF14;ID # FULLWIDTH DIGIT FOUR
FF15;ID # FULLWIDTH DIGIT FIVE
FF16;ID # FULLWIDTH DIGIT SIX
FF17;ID # FULLWIDTH DIGIT SEVEN
FF18;ID # FULLWIDTH DIGIT EIGHT
FF19;ID # FULLWIDTH DIGIT NINE
FF1A;NS # FULLWIDTH COLON
FF1B;NS # FULLWIDTH SEMICOLON
FF1C;ID # FULLWIDTH LESS-THAN SIGN
FF1D;ID # FULLWIDTH EQUALS SIGN
FF1E;ID # FULLWIDTH GREATER-THAN SIGN
FF1F;EX # FULLWIDTH QUESTION MARK
FF20;ID # FULLWIDTH COMMERCIAL AT
FF21;ID # FULLWIDTH LATIN CAPITAL LETTER A
FF22;ID # FULLWIDTH LATIN CAPITAL LETTER B
FF23;ID # FULLWIDTH LATIN CAPITAL LETTER C
FF24;ID # FULLWIDTH LATIN CAPITAL LETTER D
FF25;ID # FULLWIDTH LATIN CAPITAL LETTER E
FF26;ID # FULLWIDTH LATIN CAPITAL LETTER F
FF27;ID # FULLWIDTH LATIN CAPITAL LETTER G
FF28;ID # FULLWIDTH LATIN CAPITAL LETTER H
FF29;ID # FULLWIDTH LATIN CAPITAL LETTER I
FF2A;ID # FULLWIDTH LATIN CAPITAL LETTER J
FF2B;ID # FULLWIDTH LATIN CAPITAL LETTER K
FF2C;ID # FULLWIDTH LATIN CAPITAL LETTER L
FF2D;ID # FULLWIDTH LATIN CAPITAL LETTER M
FF2E;ID # FULLWIDTH LATIN CAPITAL LETTER N
FF2F;ID # FULLWIDTH LATIN CAPITAL LETTER O
FF30;ID # FULLWIDTH LATIN CAPITAL LETTER P
FF31;ID # FULLWIDTH LATIN CAPITAL LETTER Q
FF32;ID # FULLWIDTH LATIN CAPITAL LETTER R
FF33;ID # FULLWIDTH LATIN CAPITAL LETTER S
FF34;ID # FULLWIDTH LATIN CAPITAL LETTER T
FF35;ID # FULLWIDTH LATIN CAPITAL LETTER U
FF36;ID # FULLWIDTH LATIN CAPITAL LETTER V
FF37;ID # FULLWIDTH LATIN CAPITAL LETTER W
FF38;ID # FULLWIDTH LATIN CAPITAL LETTER X
FF39;ID # FULLWIDTH LATIN CAPITAL LETTER Y
FF3A;ID # FULLWIDTH LATIN CAPITAL LETTER Z
FF3B;OP # FULLWIDTH LEFT SQUARE BRACKET
FF3C;ID # FULLWIDTH REVERSE SOLIDUS
FF3D;CL # FULLWIDTH RIGHT SQUARE BRACKET
FF3E;ID # FULLWIDTH CIRCUMFLEX ACCENT
FF3F;ID # FULLWIDTH LOW LINE
FF40;ID # FULLWIDTH GRAVE ACCENT
FF41;ID # FULLWIDTH LATIN SMALL LETTER A
FF42;ID # FULLWIDTH LATIN SMALL LETTER B
FF43;ID # FULLWIDTH LATIN SMALL LETTER C
FF44;ID # FULLWIDTH LATIN SMALL LETTER D
FF45;ID # FULLWIDTH LATIN SMALL LETTER E
FF46;ID # FULLWIDTH LATIN SMALL LETTER F
FF47;ID # FULLWIDTH LATIN SMALL LETTER G
FF48;ID # FULLWIDTH LATIN SMALL LETTER H
FF49;ID # FULLWIDTH LATIN SMALL LETTER I
FF4A;ID # FULLWIDTH LATIN SMALL LETTER J
FF4B;ID # FULLWIDTH LATIN SMALL LETTER K
FF4C;ID # FULLWIDTH LATIN SMALL LETTER L
FF4D;ID # FULLWIDTH LATIN SMALL LETTER M
FF4E;ID # FULLWIDTH LATIN SMALL LETTER N
FF4F;ID # FULLWIDTH LATIN SMALL LETTER O
FF50;ID # FULLWIDTH LATIN SMALL LETTER P
FF51;ID # FULLWIDTH LATIN SMALL LETTER Q
FF52;ID # FULLWIDTH LATIN SMALL LETTER R
FF53;ID # FULLWIDTH LATIN SMALL LETTER S
FF54;ID # FULLWIDTH LATIN SMALL LETTER T
FF55;ID # FULLWIDTH LATIN SMALL LETTER U
FF56;ID # FULLWIDTH LATIN SMALL LETTER V
FF57;ID # FULLWIDTH LATIN SMALL LETTER W
FF58;ID # FULLWIDTH LATIN SMALL LETTER X
FF59;ID # FULLWIDTH LATIN SMALL LETTER Y
FF5A;ID # FULLWIDTH LATIN SMALL LETTER Z
FF5B;OP # FULLWIDTH LEFT CURLY BRACKET
FF5C;ID # FULLWIDTH VERTICAL LINE
FF5D;CL # FULLWIDTH RIGHT CURLY BRACKET
FF5E;ID # FULLWIDTH TILDE
FF5F;OP # FULLWIDTH LEFT WHITE PARENTHESIS
FF60;CL # FULLWIDTH RIGHT WHITE PARENTHESIS
FF61;CL # HALFWIDTH IDEOGRAPHIC FULL STOP
FF62;OP # HALFWIDTH LEFT CORNER BRACKET
FF63;CL # HALFWIDTH RIGHT CORNER BRACKET
FF64;CL # HALFWIDTH IDEOGRAPHIC COMMA
FF65;NS # HALFWIDTH KATAKANA MIDDLE DOT
FF66;AL # HALFWIDTH KATAKANA LETTER WO
FF67;NS # HALFWIDTH KATAKANA LETTER SMALL A
FF68;NS # HALFWIDTH KATAKANA LETTER SMALL I
FF69;NS # HALFWIDTH KATAKANA LETTER SMALL U
FF6A;NS # HALFWIDTH KATAKANA LETTER SMALL E
FF6B;NS # HALFWIDTH KATAKANA LETTER SMALL O
FF6C;NS # HALFWIDTH KATAKANA LETTER SMALL YA
FF6D;NS # HALFWIDTH KATAKANA LETTER SMALL YU
FF6E;NS # HALFWIDTH KATAKANA LETTER SMALL YO
FF6F;NS # HALFWIDTH KATAKANA LETTER SMALL TU
FF70;NS # HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
FF71;AL # HALFWIDTH KATAKANA LETTER A
FF72;AL # HALFWIDTH KATAKANA LETTER I
FF73;AL # HALFWIDTH KATAKANA LETTER U
FF74;AL # HALFWIDTH KATAKANA LETTER E
FF75;AL # HALFWIDTH KATAKANA LETTER O
FF76;AL # HALFWIDTH KATAKANA LETTER KA
FF77;AL # HALFWIDTH KATAKANA LETTER KI
FF78;AL # HALFWIDTH KATAKANA LETTER KU
FF79;AL # HALFWIDTH KATAKANA LETTER KE
FF7A;AL # HALFWIDTH KATAKANA LETTER KO
FF7B;AL # HALFWIDTH KATAKANA LETTER SA
FF7C;AL # HALFWIDTH KATAKANA LETTER SI
FF7D;AL # HALFWIDTH KATAKANA LETTER SU
FF7E;AL # HALFWIDTH KATAKANA LETTER SE
FF7F;AL # HALFWIDTH KATAKANA LETTER SO
FF80;AL # HALFWIDTH KATAKANA LETTER TA
FF81;AL # HALFWIDTH KATAKANA LETTER TI
FF82;AL # HALFWIDTH KATAKANA LETTER TU
FF83;AL # HALFWIDTH KATAKANA LETTER TE
FF84;AL # HALFWIDTH KATAKANA LETTER TO
FF85;AL # HALFWIDTH KATAKANA LETTER NA
FF86;AL # HALFWIDTH KATAKANA LETTER NI
FF87;AL # HALFWIDTH KATAKANA LETTER NU
FF88;AL # HALFWIDTH KATAKANA LETTER NE
FF89;AL # HALFWIDTH KATAKANA LETTER NO
FF8A;AL # HALFWIDTH KATAKANA LETTER HA
FF8B;AL # HALFWIDTH KATAKANA LETTER HI
FF8C;AL # HALFWIDTH KATAKANA LETTER HU
FF8D;AL # HALFWIDTH KATAKANA LETTER HE
FF8E;AL # HALFWIDTH KATAKANA LETTER HO
FF8F;AL # HALFWIDTH KATAKANA LETTER MA
FF90;AL # HALFWIDTH KATAKANA LETTER MI
FF91;AL # HALFWIDTH KATAKANA LETTER MU
FF92;AL # HALFWIDTH KATAKANA LETTER ME
FF93;AL # HALFWIDTH KATAKANA LETTER MO
FF94;AL # HALFWIDTH KATAKANA LETTER YA
FF95;AL # HALFWIDTH KATAKANA LETTER YU
FF96;AL # HALFWIDTH KATAKANA LETTER YO
FF97;AL # HALFWIDTH KATAKANA LETTER RA
FF98;AL # HALFWIDTH KATAKANA LETTER RI
FF99;AL # HALFWIDTH KATAKANA LETTER RU
FF9A;AL # HALFWIDTH KATAKANA LETTER RE
FF9B;AL # HALFWIDTH KATAKANA LETTER RO
FF9C;AL # HALFWIDTH KATAKANA LETTER WA
FF9D;AL # HALFWIDTH KATAKANA LETTER N
FF9E;NS # HALFWIDTH KATAKANA VOICED SOUND MARK
FF9F;NS # HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
FFA0;AL # HALFWIDTH HANGUL FILLER
FFA1;AL # HALFWIDTH HANGUL LETTER KIYEOK
FFA2;AL # HALFWIDTH HANGUL LETTER SSANGKIYEOK
FFA3;AL # HALFWIDTH HANGUL LETTER KIYEOK-SIOS
FFA4;AL # HALFWIDTH HANGUL LETTER NIEUN
FFA5;AL # HALFWIDTH HANGUL LETTER NIEUN-CIEUC
FFA6;AL # HALFWIDTH HANGUL LETTER NIEUN-HIEUH
FFA7;AL # HALFWIDTH HANGUL LETTER TIKEUT
FFA8;AL # HALFWIDTH HANGUL LETTER SSANGTIKEUT
FFA9;AL # HALFWIDTH HANGUL LETTER RIEUL
FFAA;AL # HALFWIDTH HANGUL LETTER RIEUL-KIYEOK
FFAB;AL # HALFWIDTH HANGUL LETTER RIEUL-MIEUM
FFAC;AL # HALFWIDTH HANGUL LETTER RIEUL-PIEUP
FFAD;AL # HALFWIDTH HANGUL LETTER RIEUL-SIOS
FFAE;AL # HALFWIDTH HANGUL LETTER RIEUL-THIEUTH
FFAF;AL # HALFWIDTH HANGUL LETTER RIEUL-PHIEUPH
FFB0;AL # HALFWIDTH HANGUL LETTER RIEUL-HIEUH
FFB1;AL # HALFWIDTH HANGUL LETTER MIEUM
FFB2;AL # HALFWIDTH HANGUL LETTER PIEUP
FFB3;AL # HALFWIDTH HANGUL LETTER SSANGPIEUP
FFB4;AL # HALFWIDTH HANGUL LETTER PIEUP-SIOS
FFB5;AL # HALFWIDTH HANGUL LETTER SIOS
FFB6;AL # HALFWIDTH HANGUL LETTER SSANGSIOS
FFB7;AL # HALFWIDTH HANGUL LETTER IEUNG
FFB8;AL # HALFWIDTH HANGUL LETTER CIEUC
FFB9;AL # HALFWIDTH HANGUL LETTER SSANGCIEUC
FFBA;AL # HALFWIDTH HANGUL LETTER CHIEUCH
FFBB;AL # HALFWIDTH HANGUL LETTER KHIEUKH
FFBC;AL # HALFWIDTH HANGUL LETTER THIEUTH
FFBD;AL # HALFWIDTH HANGUL LETTER PHIEUPH
FFBE;AL # HALFWIDTH HANGUL LETTER HIEUH
FFC2;AL # HALFWIDTH HANGUL LETTER A
FFC3;AL # HALFWIDTH HANGUL LETTER AE
FFC4;AL # HALFWIDTH HANGUL LETTER YA
FFC5;AL # HALFWIDTH HANGUL LETTER YAE
FFC6;AL # HALFWIDTH HANGUL LETTER EO
FFC7;AL # HALFWIDTH HANGUL LETTER E
FFCA;AL # HALFWIDTH HANGUL LETTER YEO
FFCB;AL # HALFWIDTH HANGUL LETTER YE
FFCC;AL # HALFWIDTH HANGUL LETTER O
FFCD;AL # HALFWIDTH HANGUL LETTER WA
FFCE;AL # HALFWIDTH HANGUL LETTER WAE
FFCF;AL # HALFWIDTH HANGUL LETTER OE
FFD2;AL # HALFWIDTH HANGUL LETTER YO
FFD3;AL # HALFWIDTH HANGUL LETTER U
FFD4;AL # HALFWIDTH HANGUL LETTER WEO
FFD5;AL # HALFWIDTH HANGUL LETTER WE
FFD6;AL # HALFWIDTH HANGUL LETTER WI
FFD7;AL # HALFWIDTH HANGUL LETTER YU
FFDA;AL # HALFWIDTH HANGUL LETTER EU
FFDB;AL # HALFWIDTH HANGUL LETTER YI
FFDC;AL # HALFWIDTH HANGUL LETTER I
FFE0;PO # FULLWIDTH CENT SIGN
FFE1;PR # FULLWIDTH POUND SIGN
FFE2;ID # FULLWIDTH NOT SIGN
FFE3;ID # FULLWIDTH MACRON
FFE4;ID # FULLWIDTH BROKEN BAR
FFE5;PR # FULLWIDTH YEN SIGN
FFE6;PR # FULLWIDTH WON SIGN
FFE8;AL # HALFWIDTH FORMS LIGHT VERTICAL
FFE9;AL # HALFWIDTH LEFTWARDS ARROW
FFEA;AL # HALFWIDTH UPWARDS ARROW
FFEB;AL # HALFWIDTH RIGHTWARDS ARROW
FFEC;AL # HALFWIDTH DOWNWARDS ARROW
FFED;AL # HALFWIDTH BLACK SQUARE
FFEE;AL # HALFWIDTH WHITE CIRCLE
FFF9;CM # INTERLINEAR ANNOTATION ANCHOR
FFFA;CM # INTERLINEAR ANNOTATION SEPARATOR
FFFB;CM # INTERLINEAR ANNOTATION TERMINATOR
FFFC;CB # OBJECT REPLACEMENT CHARACTER
FFFD;AI # REPLACEMENT CHARACTER
10000;AL # LINEAR B SYLLABLE B008 A
10001;AL # LINEAR B SYLLABLE B038 E
10002;AL # LINEAR B SYLLABLE B028 I
10003;AL # LINEAR B SYLLABLE B061 O
10004;AL # LINEAR B SYLLABLE B010 U
10005;AL # LINEAR B SYLLABLE B001 DA
10006;AL # LINEAR B SYLLABLE B045 DE
10007;AL # LINEAR B SYLLABLE B007 DI
10008;AL # LINEAR B SYLLABLE B014 DO
10009;AL # LINEAR B SYLLABLE B051 DU
1000A;AL # LINEAR B SYLLABLE B057 JA
1000B;AL # LINEAR B SYLLABLE B046 JE
1000D;AL # LINEAR B SYLLABLE B036 JO
1000E;AL # LINEAR B SYLLABLE B065 JU
1000F;AL # LINEAR B SYLLABLE B077 KA
10010;AL # LINEAR B SYLLABLE B044 KE
10011;AL # LINEAR B SYLLABLE B067 KI
10012;AL # LINEAR B SYLLABLE B070 KO
10013;AL # LINEAR B SYLLABLE B081 KU
10014;AL # LINEAR B SYLLABLE B080 MA
10015;AL # LINEAR B SYLLABLE B013 ME
10016;AL # LINEAR B SYLLABLE B073 MI
10017;AL # LINEAR B SYLLABLE B015 MO
10018;AL # LINEAR B SYLLABLE B023 MU
10019;AL # LINEAR B SYLLABLE B006 NA
1001A;AL # LINEAR B SYLLABLE B024 NE
1001B;AL # LINEAR B SYLLABLE B030 NI
1001C;AL # LINEAR B SYLLABLE B052 NO
1001D;AL # LINEAR B SYLLABLE B055 NU
1001E;AL # LINEAR B SYLLABLE B003 PA
1001F;AL # LINEAR B SYLLABLE B072 PE
10020;AL # LINEAR B SYLLABLE B039 PI
10021;AL # LINEAR B SYLLABLE B011 PO
10022;AL # LINEAR B SYLLABLE B050 PU
10023;AL # LINEAR B SYLLABLE B016 QA
10024;AL # LINEAR B SYLLABLE B078 QE
10025;AL # LINEAR B SYLLABLE B021 QI
10026;AL # LINEAR B SYLLABLE B032 QO
10028;AL # LINEAR B SYLLABLE B060 RA
10029;AL # LINEAR B SYLLABLE B027 RE
1002A;AL # LINEAR B SYLLABLE B053 RI
1002B;AL # LINEAR B SYLLABLE B002 RO
1002C;AL # LINEAR B SYLLABLE B026 RU
1002D;AL # LINEAR B SYLLABLE B031 SA
1002E;AL # LINEAR B SYLLABLE B009 SE
1002F;AL # LINEAR B SYLLABLE B041 SI
10030;AL # LINEAR B SYLLABLE B012 SO
10031;AL # LINEAR B SYLLABLE B058 SU
10032;AL # LINEAR B SYLLABLE B059 TA
10033;AL # LINEAR B SYLLABLE B004 TE
10034;AL # LINEAR B SYLLABLE B037 TI
10035;AL # LINEAR B SYLLABLE B005 TO
10036;AL # LINEAR B SYLLABLE B069 TU
10037;AL # LINEAR B SYLLABLE B054 WA
10038;AL # LINEAR B SYLLABLE B075 WE
10039;AL # LINEAR B SYLLABLE B040 WI
1003A;AL # LINEAR B SYLLABLE B042 WO
1003C;AL # LINEAR B SYLLABLE B017 ZA
1003D;AL # LINEAR B SYLLABLE B074 ZE
1003F;AL # LINEAR B SYLLABLE B020 ZO
10040;AL # LINEAR B SYLLABLE B025 A2
10041;AL # LINEAR B SYLLABLE B043 A3
10042;AL # LINEAR B SYLLABLE B085 AU
10043;AL # LINEAR B SYLLABLE B071 DWE
10044;AL # LINEAR B SYLLABLE B090 DWO
10045;AL # LINEAR B SYLLABLE B048 NWA
10046;AL # LINEAR B SYLLABLE B029 PU2
10047;AL # LINEAR B SYLLABLE B062 PTE
10048;AL # LINEAR B SYLLABLE B076 RA2
10049;AL # LINEAR B SYLLABLE B033 RA3
1004A;AL # LINEAR B SYLLABLE B068 RO2
1004B;AL # LINEAR B SYLLABLE B066 TA2
1004C;AL # LINEAR B SYLLABLE B087 TWE
1004D;AL # LINEAR B SYLLABLE B091 TWO
10050;AL # LINEAR B SYMBOL B018
10051;AL # LINEAR B SYMBOL B019
10052;AL # LINEAR B SYMBOL B022
10053;AL # LINEAR B SYMBOL B034
10054;AL # LINEAR B SYMBOL B047
10055;AL # LINEAR B SYMBOL B049
10056;AL # LINEAR B SYMBOL B056
10057;AL # LINEAR B SYMBOL B063
10058;AL # LINEAR B SYMBOL B064
10059;AL # LINEAR B SYMBOL B079
1005A;AL # LINEAR B SYMBOL B082
1005B;AL # LINEAR B SYMBOL B083
1005C;AL # LINEAR B SYMBOL B086
1005D;AL # LINEAR B SYMBOL B089
10080;AL # LINEAR B IDEOGRAM B100 MAN
10081;AL # LINEAR B IDEOGRAM B102 WOMAN
10082;AL # LINEAR B IDEOGRAM B104 DEER
10083;AL # LINEAR B IDEOGRAM B105 EQUID
10084;AL # LINEAR B IDEOGRAM B105F MARE
10085;AL # LINEAR B IDEOGRAM B105M STALLION
10086;AL # LINEAR B IDEOGRAM B106F EWE
10087;AL # LINEAR B IDEOGRAM B106M RAM
10088;AL # LINEAR B IDEOGRAM B107F SHE-GOAT
10089;AL # LINEAR B IDEOGRAM B107M HE-GOAT
1008A;AL # LINEAR B IDEOGRAM B108F SOW
1008B;AL # LINEAR B IDEOGRAM B108M BOAR
1008C;AL # LINEAR B IDEOGRAM B109F COW
1008D;AL # LINEAR B IDEOGRAM B109M BULL
1008E;AL # LINEAR B IDEOGRAM B120 WHEAT
1008F;AL # LINEAR B IDEOGRAM B121 BARLEY
10090;AL # LINEAR B IDEOGRAM B122 OLIVE
10091;AL # LINEAR B IDEOGRAM B123 SPICE
10092;AL # LINEAR B IDEOGRAM B125 CYPERUS
10093;AL # LINEAR B MONOGRAM B127 KAPO
10094;AL # LINEAR B MONOGRAM B128 KANAKO
10095;AL # LINEAR B IDEOGRAM B130 OIL
10096;AL # LINEAR B IDEOGRAM B131 WINE
10097;AL # LINEAR B IDEOGRAM B132
10098;AL # LINEAR B MONOGRAM B133 AREPA
10099;AL # LINEAR B MONOGRAM B135 MERI
1009A;AL # LINEAR B IDEOGRAM B140 BRONZE
1009B;AL # LINEAR B IDEOGRAM B141 GOLD
1009C;AL # LINEAR B IDEOGRAM B142
1009D;AL # LINEAR B IDEOGRAM B145 WOOL
1009E;AL # LINEAR B IDEOGRAM B146
1009F;AL # LINEAR B IDEOGRAM B150
100A0;AL # LINEAR B IDEOGRAM B151 HORN
100A1;AL # LINEAR B IDEOGRAM B152
100A2;AL # LINEAR B IDEOGRAM B153
100A3;AL # LINEAR B IDEOGRAM B154
100A4;AL # LINEAR B MONOGRAM B156 TURO2
100A5;AL # LINEAR B IDEOGRAM B157
100A6;AL # LINEAR B IDEOGRAM B158
100A7;AL # LINEAR B IDEOGRAM B159 CLOTH
100A8;AL # LINEAR B IDEOGRAM B160
100A9;AL # LINEAR B IDEOGRAM B161
100AA;AL # LINEAR B IDEOGRAM B162 GARMENT
100AB;AL # LINEAR B IDEOGRAM B163 ARMOUR
100AC;AL # LINEAR B IDEOGRAM B164
100AD;AL # LINEAR B IDEOGRAM B165
100AE;AL # LINEAR B IDEOGRAM B166
100AF;AL # LINEAR B IDEOGRAM B167
100B0;AL # LINEAR B IDEOGRAM B168
100B1;AL # LINEAR B IDEOGRAM B169
100B2;AL # LINEAR B IDEOGRAM B170
100B3;AL # LINEAR B IDEOGRAM B171
100B4;AL # LINEAR B IDEOGRAM B172
100B5;AL # LINEAR B IDEOGRAM B173 MONTH
100B6;AL # LINEAR B IDEOGRAM B174
100B7;AL # LINEAR B IDEOGRAM B176 TREE
100B8;AL # LINEAR B IDEOGRAM B177
100B9;AL # LINEAR B IDEOGRAM B178
100BA;AL # LINEAR B IDEOGRAM B179
100BB;AL # LINEAR B IDEOGRAM B180
100BC;AL # LINEAR B IDEOGRAM B181
100BD;AL # LINEAR B IDEOGRAM B182
100BE;AL # LINEAR B IDEOGRAM B183
100BF;AL # LINEAR B IDEOGRAM B184
100C0;AL # LINEAR B IDEOGRAM B185
100C1;AL # LINEAR B IDEOGRAM B189
100C2;AL # LINEAR B IDEOGRAM B190
100C3;AL # LINEAR B IDEOGRAM B191 HELMET
100C4;AL # LINEAR B IDEOGRAM B220 FOOTSTOOL
100C5;AL # LINEAR B IDEOGRAM B225 BATHTUB
100C6;AL # LINEAR B IDEOGRAM B230 SPEAR
100C7;AL # LINEAR B IDEOGRAM B231 ARROW
100C8;AL # LINEAR B IDEOGRAM B232
100C9;AL # LINEAR B IDEOGRAM B233 SWORD
100CA;AL # LINEAR B IDEOGRAM B234
100CB;AL # LINEAR B IDEOGRAM B236
100CC;AL # LINEAR B IDEOGRAM B240 WHEELED CHARIOT
100CD;AL # LINEAR B IDEOGRAM B241 CHARIOT
100CE;AL # LINEAR B IDEOGRAM B242 CHARIOT FRAME
100CF;AL # LINEAR B IDEOGRAM B243 WHEEL
100D0;AL # LINEAR B IDEOGRAM B245
100D1;AL # LINEAR B IDEOGRAM B246
100D2;AL # LINEAR B MONOGRAM B247 DIPTE
100D3;AL # LINEAR B IDEOGRAM B248
100D4;AL # LINEAR B IDEOGRAM B249
100D5;AL # LINEAR B IDEOGRAM B251
100D6;AL # LINEAR B IDEOGRAM B252
100D7;AL # LINEAR B IDEOGRAM B253
100D8;AL # LINEAR B IDEOGRAM B254 DART
100D9;AL # LINEAR B IDEOGRAM B255
100DA;AL # LINEAR B IDEOGRAM B256
100DB;AL # LINEAR B IDEOGRAM B257
100DC;AL # LINEAR B IDEOGRAM B258
100DD;AL # LINEAR B IDEOGRAM B259
100DE;AL # LINEAR B IDEOGRAM VESSEL B155
100DF;AL # LINEAR B IDEOGRAM VESSEL B200
100E0;AL # LINEAR B IDEOGRAM VESSEL B201
100E1;AL # LINEAR B IDEOGRAM VESSEL B202
100E2;AL # LINEAR B IDEOGRAM VESSEL B203
100E3;AL # LINEAR B IDEOGRAM VESSEL B204
100E4;AL # LINEAR B IDEOGRAM VESSEL B205
100E5;AL # LINEAR B IDEOGRAM VESSEL B206
100E6;AL # LINEAR B IDEOGRAM VESSEL B207
100E7;AL # LINEAR B IDEOGRAM VESSEL B208
100E8;AL # LINEAR B IDEOGRAM VESSEL B209
100E9;AL # LINEAR B IDEOGRAM VESSEL B210
100EA;AL # LINEAR B IDEOGRAM VESSEL B211
100EB;AL # LINEAR B IDEOGRAM VESSEL B212
100EC;AL # LINEAR B IDEOGRAM VESSEL B213
100ED;AL # LINEAR B IDEOGRAM VESSEL B214
100EE;AL # LINEAR B IDEOGRAM VESSEL B215
100EF;AL # LINEAR B IDEOGRAM VESSEL B216
100F0;AL # LINEAR B IDEOGRAM VESSEL B217
100F1;AL # LINEAR B IDEOGRAM VESSEL B218
100F2;AL # LINEAR B IDEOGRAM VESSEL B219
100F3;AL # LINEAR B IDEOGRAM VESSEL B221
100F4;AL # LINEAR B IDEOGRAM VESSEL B222
100F5;AL # LINEAR B IDEOGRAM VESSEL B226
100F6;AL # LINEAR B IDEOGRAM VESSEL B227
100F7;AL # LINEAR B IDEOGRAM VESSEL B228
100F8;AL # LINEAR B IDEOGRAM VESSEL B229
100F9;AL # LINEAR B IDEOGRAM VESSEL B250
100FA;AL # LINEAR B IDEOGRAM VESSEL B305
10100;BA # AEGEAN WORD SEPARATOR LINE
10101;BA # AEGEAN WORD SEPARATOR DOT
10102;BA # AEGEAN CHECK MARK
10107;AL # AEGEAN NUMBER ONE
10108;AL # AEGEAN NUMBER TWO
10109;AL # AEGEAN NUMBER THREE
1010A;AL # AEGEAN NUMBER FOUR
1010B;AL # AEGEAN NUMBER FIVE
1010C;AL # AEGEAN NUMBER SIX
1010D;AL # AEGEAN NUMBER SEVEN
1010E;AL # AEGEAN NUMBER EIGHT
1010F;AL # AEGEAN NUMBER NINE
10110;AL # AEGEAN NUMBER TEN
10111;AL # AEGEAN NUMBER TWENTY
10112;AL # AEGEAN NUMBER THIRTY
10113;AL # AEGEAN NUMBER FORTY
10114;AL # AEGEAN NUMBER FIFTY
10115;AL # AEGEAN NUMBER SIXTY
10116;AL # AEGEAN NUMBER SEVENTY
10117;AL # AEGEAN NUMBER EIGHTY
10118;AL # AEGEAN NUMBER NINETY
10119;AL # AEGEAN NUMBER ONE HUNDRED
1011A;AL # AEGEAN NUMBER TWO HUNDRED
1011B;AL # AEGEAN NUMBER THREE HUNDRED
1011C;AL # AEGEAN NUMBER FOUR HUNDRED
1011D;AL # AEGEAN NUMBER FIVE HUNDRED
1011E;AL # AEGEAN NUMBER SIX HUNDRED
1011F;AL # AEGEAN NUMBER SEVEN HUNDRED
10120;AL # AEGEAN NUMBER EIGHT HUNDRED
10121;AL # AEGEAN NUMBER NINE HUNDRED
10122;AL # AEGEAN NUMBER ONE THOUSAND
10123;AL # AEGEAN NUMBER TWO THOUSAND
10124;AL # AEGEAN NUMBER THREE THOUSAND
10125;AL # AEGEAN NUMBER FOUR THOUSAND
10126;AL # AEGEAN NUMBER FIVE THOUSAND
10127;AL # AEGEAN NUMBER SIX THOUSAND
10128;AL # AEGEAN NUMBER SEVEN THOUSAND
10129;AL # AEGEAN NUMBER EIGHT THOUSAND
1012A;AL # AEGEAN NUMBER NINE THOUSAND
1012B;AL # AEGEAN NUMBER TEN THOUSAND
1012C;AL # AEGEAN NUMBER TWENTY THOUSAND
1012D;AL # AEGEAN NUMBER THIRTY THOUSAND
1012E;AL # AEGEAN NUMBER FORTY THOUSAND
1012F;AL # AEGEAN NUMBER FIFTY THOUSAND
10130;AL # AEGEAN NUMBER SIXTY THOUSAND
10131;AL # AEGEAN NUMBER SEVENTY THOUSAND
10132;AL # AEGEAN NUMBER EIGHTY THOUSAND
10133;AL # AEGEAN NUMBER NINETY THOUSAND
10137;AL # AEGEAN WEIGHT BASE UNIT
10138;AL # AEGEAN WEIGHT FIRST SUBUNIT
10139;AL # AEGEAN WEIGHT SECOND SUBUNIT
1013A;AL # AEGEAN WEIGHT THIRD SUBUNIT
1013B;AL # AEGEAN WEIGHT FOURTH SUBUNIT
1013C;AL # AEGEAN DRY MEASURE FIRST SUBUNIT
1013D;AL # AEGEAN LIQUID MEASURE FIRST SUBUNIT
1013E;AL # AEGEAN MEASURE SECOND SUBUNIT
1013F;AL # AEGEAN MEASURE THIRD SUBUNIT
10140;AL # GREEK ACROPHONIC ATTIC ONE QUARTER
10141;AL # GREEK ACROPHONIC ATTIC ONE HALF
10142;AL # GREEK ACROPHONIC ATTIC ONE DRACHMA
10143;AL # GREEK ACROPHONIC ATTIC FIVE
10144;AL # GREEK ACROPHONIC ATTIC FIFTY
10145;AL # GREEK ACROPHONIC ATTIC FIVE HUNDRED
10146;AL # GREEK ACROPHONIC ATTIC FIVE THOUSAND
10147;AL # GREEK ACROPHONIC ATTIC FIFTY THOUSAND
10148;AL # GREEK ACROPHONIC ATTIC FIVE TALENTS
10149;AL # GREEK ACROPHONIC ATTIC TEN TALENTS
1014A;AL # GREEK ACROPHONIC ATTIC FIFTY TALENTS
1014B;AL # GREEK ACROPHONIC ATTIC ONE HUNDRED TALENTS
1014C;AL # GREEK ACROPHONIC ATTIC FIVE HUNDRED TALENTS
1014D;AL # GREEK ACROPHONIC ATTIC ONE THOUSAND TALENTS
1014E;AL # GREEK ACROPHONIC ATTIC FIVE THOUSAND TALENTS
1014F;AL # GREEK ACROPHONIC ATTIC FIVE STATERS
10150;AL # GREEK ACROPHONIC ATTIC TEN STATERS
10151;AL # GREEK ACROPHONIC ATTIC FIFTY STATERS
10152;AL # GREEK ACROPHONIC ATTIC ONE HUNDRED STATERS
10153;AL # GREEK ACROPHONIC ATTIC FIVE HUNDRED STATERS
10154;AL # GREEK ACROPHONIC ATTIC ONE THOUSAND STATERS
10155;AL # GREEK ACROPHONIC ATTIC TEN THOUSAND STATERS
10156;AL # GREEK ACROPHONIC ATTIC FIFTY THOUSAND STATERS
10157;AL # GREEK ACROPHONIC ATTIC TEN MNAS
10158;AL # GREEK ACROPHONIC HERAEUM ONE PLETHRON
10159;AL # GREEK ACROPHONIC THESPIAN ONE
1015A;AL # GREEK ACROPHONIC HERMIONIAN ONE
1015B;AL # GREEK ACROPHONIC EPIDAUREAN TWO
1015C;AL # GREEK ACROPHONIC THESPIAN TWO
1015D;AL # GREEK ACROPHONIC CYRENAIC TWO DRACHMAS
1015E;AL # GREEK ACROPHONIC EPIDAUREAN TWO DRACHMAS
1015F;AL # GREEK ACROPHONIC TROEZENIAN FIVE
10160;AL # GREEK ACROPHONIC TROEZENIAN TEN
10161;AL # GREEK ACROPHONIC TROEZENIAN TEN ALTERNATE FORM
10162;AL # GREEK ACROPHONIC HERMIONIAN TEN
10163;AL # GREEK ACROPHONIC MESSENIAN TEN
10164;AL # GREEK ACROPHONIC THESPIAN TEN
10165;AL # GREEK ACROPHONIC THESPIAN THIRTY
10166;AL # GREEK ACROPHONIC TROEZENIAN FIFTY
10167;AL # GREEK ACROPHONIC TROEZENIAN FIFTY ALTERNATE FORM
10168;AL # GREEK ACROPHONIC HERMIONIAN FIFTY
10169;AL # GREEK ACROPHONIC THESPIAN FIFTY
1016A;AL # GREEK ACROPHONIC THESPIAN ONE HUNDRED
1016B;AL # GREEK ACROPHONIC THESPIAN THREE HUNDRED
1016C;AL # GREEK ACROPHONIC EPIDAUREAN FIVE HUNDRED
1016D;AL # GREEK ACROPHONIC TROEZENIAN FIVE HUNDRED
1016E;AL # GREEK ACROPHONIC THESPIAN FIVE HUNDRED
1016F;AL # GREEK ACROPHONIC CARYSTIAN FIVE HUNDRED
10170;AL # GREEK ACROPHONIC NAXIAN FIVE HUNDRED
10171;AL # GREEK ACROPHONIC THESPIAN ONE THOUSAND
10172;AL # GREEK ACROPHONIC THESPIAN FIVE THOUSAND
10173;AL # GREEK ACROPHONIC DELPHIC FIVE MNAS
10174;AL # GREEK ACROPHONIC STRATIAN FIFTY MNAS
10175;AL # GREEK ONE HALF SIGN
10176;AL # GREEK ONE HALF SIGN ALTERNATE FORM
10177;AL # GREEK TWO THIRDS SIGN
10178;AL # GREEK THREE QUARTERS SIGN
10179;AL # GREEK YEAR SIGN
1017A;AL # GREEK TALENT SIGN
1017B;AL # GREEK DRACHMA SIGN
1017C;AL # GREEK OBOL SIGN
1017D;AL # GREEK TWO OBOLS SIGN
1017E;AL # GREEK THREE OBOLS SIGN
1017F;AL # GREEK FOUR OBOLS SIGN
10180;AL # GREEK FIVE OBOLS SIGN
10181;AL # GREEK METRETES SIGN
10182;AL # GREEK KYATHOS BASE SIGN
10183;AL # GREEK LITRA SIGN
10184;AL # GREEK OUNKIA SIGN
10185;AL # GREEK XESTES SIGN
10186;AL # GREEK ARTABE SIGN
10187;AL # GREEK AROURA SIGN
10188;AL # GREEK GRAMMA SIGN
10189;AL # GREEK TRYBLION BASE SIGN
1018A;AL # GREEK ZERO SIGN
10300;AL # OLD ITALIC LETTER A
10301;AL # OLD ITALIC LETTER BE
10302;AL # OLD ITALIC LETTER KE
10303;AL # OLD ITALIC LETTER DE
10304;AL # OLD ITALIC LETTER E
10305;AL # OLD ITALIC LETTER VE
10306;AL # OLD ITALIC LETTER ZE
10307;AL # OLD ITALIC LETTER HE
10308;AL # OLD ITALIC LETTER THE
10309;AL # OLD ITALIC LETTER I
1030A;AL # OLD ITALIC LETTER KA
1030B;AL # OLD ITALIC LETTER EL
1030C;AL # OLD ITALIC LETTER EM
1030D;AL # OLD ITALIC LETTER EN
1030E;AL # OLD ITALIC LETTER ESH
1030F;AL # OLD ITALIC LETTER O
10310;AL # OLD ITALIC LETTER PE
10311;AL # OLD ITALIC LETTER SHE
10312;AL # OLD ITALIC LETTER KU
10313;AL # OLD ITALIC LETTER ER
10314;AL # OLD ITALIC LETTER ES
10315;AL # OLD ITALIC LETTER TE
10316;AL # OLD ITALIC LETTER U
10317;AL # OLD ITALIC LETTER EKS
10318;AL # OLD ITALIC LETTER PHE
10319;AL # OLD ITALIC LETTER KHE
1031A;AL # OLD ITALIC LETTER EF
1031B;AL # OLD ITALIC LETTER ERS
1031C;AL # OLD ITALIC LETTER CHE
1031D;AL # OLD ITALIC LETTER II
1031E;AL # OLD ITALIC LETTER UU
10320;AL # OLD ITALIC NUMERAL ONE
10321;AL # OLD ITALIC NUMERAL FIVE
10322;AL # OLD ITALIC NUMERAL TEN
10323;AL # OLD ITALIC NUMERAL FIFTY
10330;AL # GOTHIC LETTER AHSA
10331;AL # GOTHIC LETTER BAIRKAN
10332;AL # GOTHIC LETTER GIBA
10333;AL # GOTHIC LETTER DAGS
10334;AL # GOTHIC LETTER AIHVUS
10335;AL # GOTHIC LETTER QAIRTHRA
10336;AL # GOTHIC LETTER IUJA
10337;AL # GOTHIC LETTER HAGL
10338;AL # GOTHIC LETTER THIUTH
10339;AL # GOTHIC LETTER EIS
1033A;AL # GOTHIC LETTER KUSMA
1033B;AL # GOTHIC LETTER LAGUS
1033C;AL # GOTHIC LETTER MANNA
1033D;AL # GOTHIC LETTER NAUTHS
1033E;AL # GOTHIC LETTER JER
1033F;AL # GOTHIC LETTER URUS
10340;AL # GOTHIC LETTER PAIRTHRA
10341;AL # GOTHIC LETTER NINETY
10342;AL # GOTHIC LETTER RAIDA
10343;AL # GOTHIC LETTER SAUIL
10344;AL # GOTHIC LETTER TEIWS
10345;AL # GOTHIC LETTER WINJA
10346;AL # GOTHIC LETTER FAIHU
10347;AL # GOTHIC LETTER IGGWS
10348;AL # GOTHIC LETTER HWAIR
10349;AL # GOTHIC LETTER OTHAL
1034A;AL # GOTHIC LETTER NINE HUNDRED
10380;AL # UGARITIC LETTER ALPA
10381;AL # UGARITIC LETTER BETA
10382;AL # UGARITIC LETTER GAMLA
10383;AL # UGARITIC LETTER KHA
10384;AL # UGARITIC LETTER DELTA
10385;AL # UGARITIC LETTER HO
10386;AL # UGARITIC LETTER WO
10387;AL # UGARITIC LETTER ZETA
10388;AL # UGARITIC LETTER HOTA
10389;AL # UGARITIC LETTER TET
1038A;AL # UGARITIC LETTER YOD
1038B;AL # UGARITIC LETTER KAF
1038C;AL # UGARITIC LETTER SHIN
1038D;AL # UGARITIC LETTER LAMDA
1038E;AL # UGARITIC LETTER MEM
1038F;AL # UGARITIC LETTER DHAL
10390;AL # UGARITIC LETTER NUN
10391;AL # UGARITIC LETTER ZU
10392;AL # UGARITIC LETTER SAMKA
10393;AL # UGARITIC LETTER AIN
10394;AL # UGARITIC LETTER PU
10395;AL # UGARITIC LETTER SADE
10396;AL # UGARITIC LETTER QOPA
10397;AL # UGARITIC LETTER RASHA
10398;AL # UGARITIC LETTER THANNA
10399;AL # UGARITIC LETTER GHAIN
1039A;AL # UGARITIC LETTER TO
1039B;AL # UGARITIC LETTER I
1039C;AL # UGARITIC LETTER U
1039D;AL # UGARITIC LETTER SSU
1039F;BA # UGARITIC WORD DIVIDER
103A0;AL # OLD PERSIAN SIGN A
103A1;AL # OLD PERSIAN SIGN I
103A2;AL # OLD PERSIAN SIGN U
103A3;AL # OLD PERSIAN SIGN KA
103A4;AL # OLD PERSIAN SIGN KU
103A5;AL # OLD PERSIAN SIGN GA
103A6;AL # OLD PERSIAN SIGN GU
103A7;AL # OLD PERSIAN SIGN XA
103A8;AL # OLD PERSIAN SIGN CA
103A9;AL # OLD PERSIAN SIGN JA
103AA;AL # OLD PERSIAN SIGN JI
103AB;AL # OLD PERSIAN SIGN TA
103AC;AL # OLD PERSIAN SIGN TU
103AD;AL # OLD PERSIAN SIGN DA
103AE;AL # OLD PERSIAN SIGN DI
103AF;AL # OLD PERSIAN SIGN DU
103B0;AL # OLD PERSIAN SIGN THA
103B1;AL # OLD PERSIAN SIGN PA
103B2;AL # OLD PERSIAN SIGN BA
103B3;AL # OLD PERSIAN SIGN FA
103B4;AL # OLD PERSIAN SIGN NA
103B5;AL # OLD PERSIAN SIGN NU
103B6;AL # OLD PERSIAN SIGN MA
103B7;AL # OLD PERSIAN SIGN MI
103B8;AL # OLD PERSIAN SIGN MU
103B9;AL # OLD PERSIAN SIGN YA
103BA;AL # OLD PERSIAN SIGN VA
103BB;AL # OLD PERSIAN SIGN VI
103BC;AL # OLD PERSIAN SIGN RA
103BD;AL # OLD PERSIAN SIGN RU
103BE;AL # OLD PERSIAN SIGN LA
103BF;AL # OLD PERSIAN SIGN SA
103C0;AL # OLD PERSIAN SIGN ZA
103C1;AL # OLD PERSIAN SIGN SHA
103C2;AL # OLD PERSIAN SIGN SSA
103C3;AL # OLD PERSIAN SIGN HA
103C8;AL # OLD PERSIAN SIGN AURAMAZDAA
103C9;AL # OLD PERSIAN SIGN AURAMAZDAA-2
103CA;AL # OLD PERSIAN SIGN AURAMAZDAAHA
103CB;AL # OLD PERSIAN SIGN XSHAAYATHIYA
103CC;AL # OLD PERSIAN SIGN DAHYAAUSH
103CD;AL # OLD PERSIAN SIGN DAHYAAUSH-2
103CE;AL # OLD PERSIAN SIGN BAGA
103CF;AL # OLD PERSIAN SIGN BUUMISH
103D0;AL # OLD PERSIAN WORD DIVIDER
103D1;AL # OLD PERSIAN NUMBER ONE
103D2;AL # OLD PERSIAN NUMBER TWO
103D3;AL # OLD PERSIAN NUMBER TEN
103D4;AL # OLD PERSIAN NUMBER TWENTY
103D5;AL # OLD PERSIAN NUMBER HUNDRED
10400;AL # DESERET CAPITAL LETTER LONG I
10401;AL # DESERET CAPITAL LETTER LONG E
10402;AL # DESERET CAPITAL LETTER LONG A
10403;AL # DESERET CAPITAL LETTER LONG AH
10404;AL # DESERET CAPITAL LETTER LONG O
10405;AL # DESERET CAPITAL LETTER LONG OO
10406;AL # DESERET CAPITAL LETTER SHORT I
10407;AL # DESERET CAPITAL LETTER SHORT E
10408;AL # DESERET CAPITAL LETTER SHORT A
10409;AL # DESERET CAPITAL LETTER SHORT AH
1040A;AL # DESERET CAPITAL LETTER SHORT O
1040B;AL # DESERET CAPITAL LETTER SHORT OO
1040C;AL # DESERET CAPITAL LETTER AY
1040D;AL # DESERET CAPITAL LETTER OW
1040E;AL # DESERET CAPITAL LETTER WU
1040F;AL # DESERET CAPITAL LETTER YEE
10410;AL # DESERET CAPITAL LETTER H
10411;AL # DESERET CAPITAL LETTER PEE
10412;AL # DESERET CAPITAL LETTER BEE
10413;AL # DESERET CAPITAL LETTER TEE
10414;AL # DESERET CAPITAL LETTER DEE
10415;AL # DESERET CAPITAL LETTER CHEE
10416;AL # DESERET CAPITAL LETTER JEE
10417;AL # DESERET CAPITAL LETTER KAY
10418;AL # DESERET CAPITAL LETTER GAY
10419;AL # DESERET CAPITAL LETTER EF
1041A;AL # DESERET CAPITAL LETTER VEE
1041B;AL # DESERET CAPITAL LETTER ETH
1041C;AL # DESERET CAPITAL LETTER THEE
1041D;AL # DESERET CAPITAL LETTER ES
1041E;AL # DESERET CAPITAL LETTER ZEE
1041F;AL # DESERET CAPITAL LETTER ESH
10420;AL # DESERET CAPITAL LETTER ZHEE
10421;AL # DESERET CAPITAL LETTER ER
10422;AL # DESERET CAPITAL LETTER EL
10423;AL # DESERET CAPITAL LETTER EM
10424;AL # DESERET CAPITAL LETTER EN
10425;AL # DESERET CAPITAL LETTER ENG
10426;AL # DESERET CAPITAL LETTER OI
10427;AL # DESERET CAPITAL LETTER EW
10428;AL # DESERET SMALL LETTER LONG I
10429;AL # DESERET SMALL LETTER LONG E
1042A;AL # DESERET SMALL LETTER LONG A
1042B;AL # DESERET SMALL LETTER LONG AH
1042C;AL # DESERET SMALL LETTER LONG O
1042D;AL # DESERET SMALL LETTER LONG OO
1042E;AL # DESERET SMALL LETTER SHORT I
1042F;AL # DESERET SMALL LETTER SHORT E
10430;AL # DESERET SMALL LETTER SHORT A
10431;AL # DESERET SMALL LETTER SHORT AH
10432;AL # DESERET SMALL LETTER SHORT O
10433;AL # DESERET SMALL LETTER SHORT OO
10434;AL # DESERET SMALL LETTER AY
10435;AL # DESERET SMALL LETTER OW
10436;AL # DESERET SMALL LETTER WU
10437;AL # DESERET SMALL LETTER YEE
10438;AL # DESERET SMALL LETTER H
10439;AL # DESERET SMALL LETTER PEE
1043A;AL # DESERET SMALL LETTER BEE
1043B;AL # DESERET SMALL LETTER TEE
1043C;AL # DESERET SMALL LETTER DEE
1043D;AL # DESERET SMALL LETTER CHEE
1043E;AL # DESERET SMALL LETTER JEE
1043F;AL # DESERET SMALL LETTER KAY
10440;AL # DESERET SMALL LETTER GAY
10441;AL # DESERET SMALL LETTER EF
10442;AL # DESERET SMALL LETTER VEE
10443;AL # DESERET SMALL LETTER ETH
10444;AL # DESERET SMALL LETTER THEE
10445;AL # DESERET SMALL LETTER ES
10446;AL # DESERET SMALL LETTER ZEE
10447;AL # DESERET SMALL LETTER ESH
10448;AL # DESERET SMALL LETTER ZHEE
10449;AL # DESERET SMALL LETTER ER
1044A;AL # DESERET SMALL LETTER EL
1044B;AL # DESERET SMALL LETTER EM
1044C;AL # DESERET SMALL LETTER EN
1044D;AL # DESERET SMALL LETTER ENG
1044E;AL # DESERET SMALL LETTER OI
1044F;AL # DESERET SMALL LETTER EW
10450;AL # SHAVIAN LETTER PEEP
10451;AL # SHAVIAN LETTER TOT
10452;AL # SHAVIAN LETTER KICK
10453;AL # SHAVIAN LETTER FEE
10454;AL # SHAVIAN LETTER THIGH
10455;AL # SHAVIAN LETTER SO
10456;AL # SHAVIAN LETTER SURE
10457;AL # SHAVIAN LETTER CHURCH
10458;AL # SHAVIAN LETTER YEA
10459;AL # SHAVIAN LETTER HUNG
1045A;AL # SHAVIAN LETTER BIB
1045B;AL # SHAVIAN LETTER DEAD
1045C;AL # SHAVIAN LETTER GAG
1045D;AL # SHAVIAN LETTER VOW
1045E;AL # SHAVIAN LETTER THEY
1045F;AL # SHAVIAN LETTER ZOO
10460;AL # SHAVIAN LETTER MEASURE
10461;AL # SHAVIAN LETTER JUDGE
10462;AL # SHAVIAN LETTER WOE
10463;AL # SHAVIAN LETTER HA-HA
10464;AL # SHAVIAN LETTER LOLL
10465;AL # SHAVIAN LETTER MIME
10466;AL # SHAVIAN LETTER IF
10467;AL # SHAVIAN LETTER EGG
10468;AL # SHAVIAN LETTER ASH
10469;AL # SHAVIAN LETTER ADO
1046A;AL # SHAVIAN LETTER ON
1046B;AL # SHAVIAN LETTER WOOL
1046C;AL # SHAVIAN LETTER OUT
1046D;AL # SHAVIAN LETTER AH
1046E;AL # SHAVIAN LETTER ROAR
1046F;AL # SHAVIAN LETTER NUN
10470;AL # SHAVIAN LETTER EAT
10471;AL # SHAVIAN LETTER AGE
10472;AL # SHAVIAN LETTER ICE
10473;AL # SHAVIAN LETTER UP
10474;AL # SHAVIAN LETTER OAK
10475;AL # SHAVIAN LETTER OOZE
10476;AL # SHAVIAN LETTER OIL
10477;AL # SHAVIAN LETTER AWE
10478;AL # SHAVIAN LETTER ARE
10479;AL # SHAVIAN LETTER OR
1047A;AL # SHAVIAN LETTER AIR
1047B;AL # SHAVIAN LETTER ERR
1047C;AL # SHAVIAN LETTER ARRAY
1047D;AL # SHAVIAN LETTER EAR
1047E;AL # SHAVIAN LETTER IAN
1047F;AL # SHAVIAN LETTER YEW
10480;AL # OSMANYA LETTER ALEF
10481;AL # OSMANYA LETTER BA
10482;AL # OSMANYA LETTER TA
10483;AL # OSMANYA LETTER JA
10484;AL # OSMANYA LETTER XA
10485;AL # OSMANYA LETTER KHA
10486;AL # OSMANYA LETTER DEEL
10487;AL # OSMANYA LETTER RA
10488;AL # OSMANYA LETTER SA
10489;AL # OSMANYA LETTER SHIIN
1048A;AL # OSMANYA LETTER DHA
1048B;AL # OSMANYA LETTER CAYN
1048C;AL # OSMANYA LETTER GA
1048D;AL # OSMANYA LETTER FA
1048E;AL # OSMANYA LETTER QAAF
1048F;AL # OSMANYA LETTER KAAF
10490;AL # OSMANYA LETTER LAAN
10491;AL # OSMANYA LETTER MIIN
10492;AL # OSMANYA LETTER NUUN
10493;AL # OSMANYA LETTER WAW
10494;AL # OSMANYA LETTER HA
10495;AL # OSMANYA LETTER YA
10496;AL # OSMANYA LETTER A
10497;AL # OSMANYA LETTER E
10498;AL # OSMANYA LETTER I
10499;AL # OSMANYA LETTER O
1049A;AL # OSMANYA LETTER U
1049B;AL # OSMANYA LETTER AA
1049C;AL # OSMANYA LETTER EE
1049D;AL # OSMANYA LETTER OO
104A0;NU # OSMANYA DIGIT ZERO
104A1;NU # OSMANYA DIGIT ONE
104A2;NU # OSMANYA DIGIT TWO
104A3;NU # OSMANYA DIGIT THREE
104A4;NU # OSMANYA DIGIT FOUR
104A5;NU # OSMANYA DIGIT FIVE
104A6;NU # OSMANYA DIGIT SIX
104A7;NU # OSMANYA DIGIT SEVEN
104A8;NU # OSMANYA DIGIT EIGHT
104A9;NU # OSMANYA DIGIT NINE
10800;AL # CYPRIOT SYLLABLE A
10801;AL # CYPRIOT SYLLABLE E
10802;AL # CYPRIOT SYLLABLE I
10803;AL # CYPRIOT SYLLABLE O
10804;AL # CYPRIOT SYLLABLE U
10805;AL # CYPRIOT SYLLABLE JA
10808;AL # CYPRIOT SYLLABLE JO
1080A;AL # CYPRIOT SYLLABLE KA
1080B;AL # CYPRIOT SYLLABLE KE
1080C;AL # CYPRIOT SYLLABLE KI
1080D;AL # CYPRIOT SYLLABLE KO
1080E;AL # CYPRIOT SYLLABLE KU
1080F;AL # CYPRIOT SYLLABLE LA
10810;AL # CYPRIOT SYLLABLE LE
10811;AL # CYPRIOT SYLLABLE LI
10812;AL # CYPRIOT SYLLABLE LO
10813;AL # CYPRIOT SYLLABLE LU
10814;AL # CYPRIOT SYLLABLE MA
10815;AL # CYPRIOT SYLLABLE ME
10816;AL # CYPRIOT SYLLABLE MI
10817;AL # CYPRIOT SYLLABLE MO
10818;AL # CYPRIOT SYLLABLE MU
10819;AL # CYPRIOT SYLLABLE NA
1081A;AL # CYPRIOT SYLLABLE NE
1081B;AL # CYPRIOT SYLLABLE NI
1081C;AL # CYPRIOT SYLLABLE NO
1081D;AL # CYPRIOT SYLLABLE NU
1081E;AL # CYPRIOT SYLLABLE PA
1081F;AL # CYPRIOT SYLLABLE PE
10820;AL # CYPRIOT SYLLABLE PI
10821;AL # CYPRIOT SYLLABLE PO
10822;AL # CYPRIOT SYLLABLE PU
10823;AL # CYPRIOT SYLLABLE RA
10824;AL # CYPRIOT SYLLABLE RE
10825;AL # CYPRIOT SYLLABLE RI
10826;AL # CYPRIOT SYLLABLE RO
10827;AL # CYPRIOT SYLLABLE RU
10828;AL # CYPRIOT SYLLABLE SA
10829;AL # CYPRIOT SYLLABLE SE
1082A;AL # CYPRIOT SYLLABLE SI
1082B;AL # CYPRIOT SYLLABLE SO
1082C;AL # CYPRIOT SYLLABLE SU
1082D;AL # CYPRIOT SYLLABLE TA
1082E;AL # CYPRIOT SYLLABLE TE
1082F;AL # CYPRIOT SYLLABLE TI
10830;AL # CYPRIOT SYLLABLE TO
10831;AL # CYPRIOT SYLLABLE TU
10832;AL # CYPRIOT SYLLABLE WA
10833;AL # CYPRIOT SYLLABLE WE
10834;AL # CYPRIOT SYLLABLE WI
10835;AL # CYPRIOT SYLLABLE WO
10837;AL # CYPRIOT SYLLABLE XA
10838;AL # CYPRIOT SYLLABLE XE
1083C;AL # CYPRIOT SYLLABLE ZA
1083F;AL # CYPRIOT SYLLABLE ZO
10A00;AL # KHAROSHTHI LETTER A
10A01;CM # KHAROSHTHI VOWEL SIGN I
10A02;CM # KHAROSHTHI VOWEL SIGN U
10A03;CM # KHAROSHTHI VOWEL SIGN VOCALIC R
10A05;CM # KHAROSHTHI VOWEL SIGN E
10A06;CM # KHAROSHTHI VOWEL SIGN O
10A0C;CM # KHAROSHTHI VOWEL LENGTH MARK
10A0D;CM # KHAROSHTHI SIGN DOUBLE RING BELOW
10A0E;CM # KHAROSHTHI SIGN ANUSVARA
10A0F;CM # KHAROSHTHI SIGN VISARGA
10A10;AL # KHAROSHTHI LETTER KA
10A11;AL # KHAROSHTHI LETTER KHA
10A12;AL # KHAROSHTHI LETTER GA
10A13;AL # KHAROSHTHI LETTER GHA
10A15;AL # KHAROSHTHI LETTER CA
10A16;AL # KHAROSHTHI LETTER CHA
10A17;AL # KHAROSHTHI LETTER JA
10A19;AL # KHAROSHTHI LETTER NYA
10A1A;AL # KHAROSHTHI LETTER TTA
10A1B;AL # KHAROSHTHI LETTER TTHA
10A1C;AL # KHAROSHTHI LETTER DDA
10A1D;AL # KHAROSHTHI LETTER DDHA
10A1E;AL # KHAROSHTHI LETTER NNA
10A1F;AL # KHAROSHTHI LETTER TA
10A20;AL # KHAROSHTHI LETTER THA
10A21;AL # KHAROSHTHI LETTER DA
10A22;AL # KHAROSHTHI LETTER DHA
10A23;AL # KHAROSHTHI LETTER NA
10A24;AL # KHAROSHTHI LETTER PA
10A25;AL # KHAROSHTHI LETTER PHA
10A26;AL # KHAROSHTHI LETTER BA
10A27;AL # KHAROSHTHI LETTER BHA
10A28;AL # KHAROSHTHI LETTER MA
10A29;AL # KHAROSHTHI LETTER YA
10A2A;AL # KHAROSHTHI LETTER RA
10A2B;AL # KHAROSHTHI LETTER LA
10A2C;AL # KHAROSHTHI LETTER VA
10A2D;AL # KHAROSHTHI LETTER SHA
10A2E;AL # KHAROSHTHI LETTER SSA
10A2F;AL # KHAROSHTHI LETTER SA
10A30;AL # KHAROSHTHI LETTER ZA
10A31;AL # KHAROSHTHI LETTER HA
10A32;AL # KHAROSHTHI LETTER KKA
10A33;AL # KHAROSHTHI LETTER TTTHA
10A38;CM # KHAROSHTHI SIGN BAR ABOVE
10A39;CM # KHAROSHTHI SIGN CAUDA
10A3A;CM # KHAROSHTHI SIGN DOT BELOW
10A3F;CM # KHAROSHTHI VIRAMA
10A40;AL # KHAROSHTHI DIGIT ONE
10A41;AL # KHAROSHTHI DIGIT TWO
10A42;AL # KHAROSHTHI DIGIT THREE
10A43;AL # KHAROSHTHI DIGIT FOUR
10A44;AL # KHAROSHTHI NUMBER TEN
10A45;AL # KHAROSHTHI NUMBER TWENTY
10A46;AL # KHAROSHTHI NUMBER ONE HUNDRED
10A47;AL # KHAROSHTHI NUMBER ONE THOUSAND
10A50;BA # KHAROSHTHI PUNCTUATION DOT
10A51;BA # KHAROSHTHI PUNCTUATION SMALL CIRCLE
10A52;BA # KHAROSHTHI PUNCTUATION CIRCLE
10A53;BA # KHAROSHTHI PUNCTUATION CRESCENT BAR
10A54;BA # KHAROSHTHI PUNCTUATION MANGALAM
10A55;BA # KHAROSHTHI PUNCTUATION LOTUS
10A56;BA # KHAROSHTHI PUNCTUATION DANDA
10A57;BA # KHAROSHTHI PUNCTUATION DOUBLE DANDA
10A58;AL # KHAROSHTHI PUNCTUATION LINES
1D000;AL # BYZANTINE MUSICAL SYMBOL PSILI
1D001;AL # BYZANTINE MUSICAL SYMBOL DASEIA
1D002;AL # BYZANTINE MUSICAL SYMBOL PERISPOMENI
1D003;AL # BYZANTINE MUSICAL SYMBOL OXEIA EKFONITIKON
1D004;AL # BYZANTINE MUSICAL SYMBOL OXEIA DIPLI
1D005;AL # BYZANTINE MUSICAL SYMBOL VAREIA EKFONITIKON
1D006;AL # BYZANTINE MUSICAL SYMBOL VAREIA DIPLI
1D007;AL # BYZANTINE MUSICAL SYMBOL KATHISTI
1D008;AL # BYZANTINE MUSICAL SYMBOL SYRMATIKI
1D009;AL # BYZANTINE MUSICAL SYMBOL PARAKLITIKI
1D00A;AL # BYZANTINE MUSICAL SYMBOL YPOKRISIS
1D00B;AL # BYZANTINE MUSICAL SYMBOL YPOKRISIS DIPLI
1D00C;AL # BYZANTINE MUSICAL SYMBOL KREMASTI
1D00D;AL # BYZANTINE MUSICAL SYMBOL APESO EKFONITIKON
1D00E;AL # BYZANTINE MUSICAL SYMBOL EXO EKFONITIKON
1D00F;AL # BYZANTINE MUSICAL SYMBOL TELEIA
1D010;AL # BYZANTINE MUSICAL SYMBOL KENTIMATA
1D011;AL # BYZANTINE MUSICAL SYMBOL APOSTROFOS
1D012;AL # BYZANTINE MUSICAL SYMBOL APOSTROFOS DIPLI
1D013;AL # BYZANTINE MUSICAL SYMBOL SYNEVMA
1D014;AL # BYZANTINE MUSICAL SYMBOL THITA
1D015;AL # BYZANTINE MUSICAL SYMBOL OLIGON ARCHAION
1D016;AL # BYZANTINE MUSICAL SYMBOL GORGON ARCHAION
1D017;AL # BYZANTINE MUSICAL SYMBOL PSILON
1D018;AL # BYZANTINE MUSICAL SYMBOL CHAMILON
1D019;AL # BYZANTINE MUSICAL SYMBOL VATHY
1D01A;AL # BYZANTINE MUSICAL SYMBOL ISON ARCHAION
1D01B;AL # BYZANTINE MUSICAL SYMBOL KENTIMA ARCHAION
1D01C;AL # BYZANTINE MUSICAL SYMBOL KENTIMATA ARCHAION
1D01D;AL # BYZANTINE MUSICAL SYMBOL SAXIMATA
1D01E;AL # BYZANTINE MUSICAL SYMBOL PARICHON
1D01F;AL # BYZANTINE MUSICAL SYMBOL STAVROS APODEXIA
1D020;AL # BYZANTINE MUSICAL SYMBOL OXEIAI ARCHAION
1D021;AL # BYZANTINE MUSICAL SYMBOL VAREIAI ARCHAION
1D022;AL # BYZANTINE MUSICAL SYMBOL APODERMA ARCHAION
1D023;AL # BYZANTINE MUSICAL SYMBOL APOTHEMA
1D024;AL # BYZANTINE MUSICAL SYMBOL KLASMA
1D025;AL # BYZANTINE MUSICAL SYMBOL REVMA
1D026;AL # BYZANTINE MUSICAL SYMBOL PIASMA ARCHAION
1D027;AL # BYZANTINE MUSICAL SYMBOL TINAGMA
1D028;AL # BYZANTINE MUSICAL SYMBOL ANATRICHISMA
1D029;AL # BYZANTINE MUSICAL SYMBOL SEISMA
1D02A;AL # BYZANTINE MUSICAL SYMBOL SYNAGMA ARCHAION
1D02B;AL # BYZANTINE MUSICAL SYMBOL SYNAGMA META STAVROU
1D02C;AL # BYZANTINE MUSICAL SYMBOL OYRANISMA ARCHAION
1D02D;AL # BYZANTINE MUSICAL SYMBOL THEMA
1D02E;AL # BYZANTINE MUSICAL SYMBOL LEMOI
1D02F;AL # BYZANTINE MUSICAL SYMBOL DYO
1D030;AL # BYZANTINE MUSICAL SYMBOL TRIA
1D031;AL # BYZANTINE MUSICAL SYMBOL TESSERA
1D032;AL # BYZANTINE MUSICAL SYMBOL KRATIMATA
1D033;AL # BYZANTINE MUSICAL SYMBOL APESO EXO NEO
1D034;AL # BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION
1D035;AL # BYZANTINE MUSICAL SYMBOL IMIFTHORA
1D036;AL # BYZANTINE MUSICAL SYMBOL TROMIKON ARCHAION
1D037;AL # BYZANTINE MUSICAL SYMBOL KATAVA TROMIKON
1D038;AL # BYZANTINE MUSICAL SYMBOL PELASTON
1D039;AL # BYZANTINE MUSICAL SYMBOL PSIFISTON
1D03A;AL # BYZANTINE MUSICAL SYMBOL KONTEVMA
1D03B;AL # BYZANTINE MUSICAL SYMBOL CHOREVMA ARCHAION
1D03C;AL # BYZANTINE MUSICAL SYMBOL RAPISMA
1D03D;AL # BYZANTINE MUSICAL SYMBOL PARAKALESMA ARCHAION
1D03E;AL # BYZANTINE MUSICAL SYMBOL PARAKLITIKI ARCHAION
1D03F;AL # BYZANTINE MUSICAL SYMBOL ICHADIN
1D040;AL # BYZANTINE MUSICAL SYMBOL NANA
1D041;AL # BYZANTINE MUSICAL SYMBOL PETASMA
1D042;AL # BYZANTINE MUSICAL SYMBOL KONTEVMA ALLO
1D043;AL # BYZANTINE MUSICAL SYMBOL TROMIKON ALLO
1D044;AL # BYZANTINE MUSICAL SYMBOL STRAGGISMATA
1D045;AL # BYZANTINE MUSICAL SYMBOL GRONTHISMATA
1D046;AL # BYZANTINE MUSICAL SYMBOL ISON NEO
1D047;AL # BYZANTINE MUSICAL SYMBOL OLIGON NEO
1D048;AL # BYZANTINE MUSICAL SYMBOL OXEIA NEO
1D049;AL # BYZANTINE MUSICAL SYMBOL PETASTI
1D04A;AL # BYZANTINE MUSICAL SYMBOL KOUFISMA
1D04B;AL # BYZANTINE MUSICAL SYMBOL PETASTOKOUFISMA
1D04C;AL # BYZANTINE MUSICAL SYMBOL KRATIMOKOUFISMA
1D04D;AL # BYZANTINE MUSICAL SYMBOL PELASTON NEO
1D04E;AL # BYZANTINE MUSICAL SYMBOL KENTIMATA NEO ANO
1D04F;AL # BYZANTINE MUSICAL SYMBOL KENTIMA NEO ANO
1D050;AL # BYZANTINE MUSICAL SYMBOL YPSILI
1D051;AL # BYZANTINE MUSICAL SYMBOL APOSTROFOS NEO
1D052;AL # BYZANTINE MUSICAL SYMBOL APOSTROFOI SYNDESMOS NEO
1D053;AL # BYZANTINE MUSICAL SYMBOL YPORROI
1D054;AL # BYZANTINE MUSICAL SYMBOL KRATIMOYPORROON
1D055;AL # BYZANTINE MUSICAL SYMBOL ELAFRON
1D056;AL # BYZANTINE MUSICAL SYMBOL CHAMILI
1D057;AL # BYZANTINE MUSICAL SYMBOL MIKRON ISON
1D058;AL # BYZANTINE MUSICAL SYMBOL VAREIA NEO
1D059;AL # BYZANTINE MUSICAL SYMBOL PIASMA NEO
1D05A;AL # BYZANTINE MUSICAL SYMBOL PSIFISTON NEO
1D05B;AL # BYZANTINE MUSICAL SYMBOL OMALON
1D05C;AL # BYZANTINE MUSICAL SYMBOL ANTIKENOMA
1D05D;AL # BYZANTINE MUSICAL SYMBOL LYGISMA
1D05E;AL # BYZANTINE MUSICAL SYMBOL PARAKLITIKI NEO
1D05F;AL # BYZANTINE MUSICAL SYMBOL PARAKALESMA NEO
1D060;AL # BYZANTINE MUSICAL SYMBOL ETERON PARAKALESMA
1D061;AL # BYZANTINE MUSICAL SYMBOL KYLISMA
1D062;AL # BYZANTINE MUSICAL SYMBOL ANTIKENOKYLISMA
1D063;AL # BYZANTINE MUSICAL SYMBOL TROMIKON NEO
1D064;AL # BYZANTINE MUSICAL SYMBOL EKSTREPTON
1D065;AL # BYZANTINE MUSICAL SYMBOL SYNAGMA NEO
1D066;AL # BYZANTINE MUSICAL SYMBOL SYRMA
1D067;AL # BYZANTINE MUSICAL SYMBOL CHOREVMA NEO
1D068;AL # BYZANTINE MUSICAL SYMBOL EPEGERMA
1D069;AL # BYZANTINE MUSICAL SYMBOL SEISMA NEO
1D06A;AL # BYZANTINE MUSICAL SYMBOL XIRON KLASMA
1D06B;AL # BYZANTINE MUSICAL SYMBOL TROMIKOPSIFISTON
1D06C;AL # BYZANTINE MUSICAL SYMBOL PSIFISTOLYGISMA
1D06D;AL # BYZANTINE MUSICAL SYMBOL TROMIKOLYGISMA
1D06E;AL # BYZANTINE MUSICAL SYMBOL TROMIKOPARAKALESMA
1D06F;AL # BYZANTINE MUSICAL SYMBOL PSIFISTOPARAKALESMA
1D070;AL # BYZANTINE MUSICAL SYMBOL TROMIKOSYNAGMA
1D071;AL # BYZANTINE MUSICAL SYMBOL PSIFISTOSYNAGMA
1D072;AL # BYZANTINE MUSICAL SYMBOL GORGOSYNTHETON
1D073;AL # BYZANTINE MUSICAL SYMBOL ARGOSYNTHETON
1D074;AL # BYZANTINE MUSICAL SYMBOL ETERON ARGOSYNTHETON
1D075;AL # BYZANTINE MUSICAL SYMBOL OYRANISMA NEO
1D076;AL # BYZANTINE MUSICAL SYMBOL THEMATISMOS ESO
1D077;AL # BYZANTINE MUSICAL SYMBOL THEMATISMOS EXO
1D078;AL # BYZANTINE MUSICAL SYMBOL THEMA APLOUN
1D079;AL # BYZANTINE MUSICAL SYMBOL THES KAI APOTHES
1D07A;AL # BYZANTINE MUSICAL SYMBOL KATAVASMA
1D07B;AL # BYZANTINE MUSICAL SYMBOL ENDOFONON
1D07C;AL # BYZANTINE MUSICAL SYMBOL YFEN KATO
1D07D;AL # BYZANTINE MUSICAL SYMBOL YFEN ANO
1D07E;AL # BYZANTINE MUSICAL SYMBOL STAVROS
1D07F;AL # BYZANTINE MUSICAL SYMBOL KLASMA ANO
1D080;AL # BYZANTINE MUSICAL SYMBOL DIPLI ARCHAION
1D081;AL # BYZANTINE MUSICAL SYMBOL KRATIMA ARCHAION
1D082;AL # BYZANTINE MUSICAL SYMBOL KRATIMA ALLO
1D083;AL # BYZANTINE MUSICAL SYMBOL KRATIMA NEO
1D084;AL # BYZANTINE MUSICAL SYMBOL APODERMA NEO
1D085;AL # BYZANTINE MUSICAL SYMBOL APLI
1D086;AL # BYZANTINE MUSICAL SYMBOL DIPLI
1D087;AL # BYZANTINE MUSICAL SYMBOL TRIPLI
1D088;AL # BYZANTINE MUSICAL SYMBOL TETRAPLI
1D089;AL # BYZANTINE MUSICAL SYMBOL KORONIS
1D08A;AL # BYZANTINE MUSICAL SYMBOL LEIMMA ENOS CHRONOU
1D08B;AL # BYZANTINE MUSICAL SYMBOL LEIMMA DYO CHRONON
1D08C;AL # BYZANTINE MUSICAL SYMBOL LEIMMA TRION CHRONON
1D08D;AL # BYZANTINE MUSICAL SYMBOL LEIMMA TESSARON CHRONON
1D08E;AL # BYZANTINE MUSICAL SYMBOL LEIMMA IMISEOS CHRONOU
1D08F;AL # BYZANTINE MUSICAL SYMBOL GORGON NEO ANO
1D090;AL # BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON ARISTERA
1D091;AL # BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON DEXIA
1D092;AL # BYZANTINE MUSICAL SYMBOL DIGORGON
1D093;AL # BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA KATO
1D094;AL # BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA ANO
1D095;AL # BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON DEXIA
1D096;AL # BYZANTINE MUSICAL SYMBOL TRIGORGON
1D097;AL # BYZANTINE MUSICAL SYMBOL ARGON
1D098;AL # BYZANTINE MUSICAL SYMBOL IMIDIARGON
1D099;AL # BYZANTINE MUSICAL SYMBOL DIARGON
1D09A;AL # BYZANTINE MUSICAL SYMBOL AGOGI POLI ARGI
1D09B;AL # BYZANTINE MUSICAL SYMBOL AGOGI ARGOTERI
1D09C;AL # BYZANTINE MUSICAL SYMBOL AGOGI ARGI
1D09D;AL # BYZANTINE MUSICAL SYMBOL AGOGI METRIA
1D09E;AL # BYZANTINE MUSICAL SYMBOL AGOGI MESI
1D09F;AL # BYZANTINE MUSICAL SYMBOL AGOGI GORGI
1D0A0;AL # BYZANTINE MUSICAL SYMBOL AGOGI GORGOTERI
1D0A1;AL # BYZANTINE MUSICAL SYMBOL AGOGI POLI GORGI
1D0A2;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOS ICHOS
1D0A3;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI PROTOS ICHOS
1D0A4;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA DEYTEROS ICHOS
1D0A5;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI DEYTEROS ICHOS
1D0A6;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA TRITOS ICHOS
1D0A7;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA TRIFONIAS
1D0A8;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS ICHOS
1D0A9;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS LEGETOS ICHOS
1D0AA;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA LEGETOS ICHOS
1D0AB;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS ICHOS
1D0AC;AL # BYZANTINE MUSICAL SYMBOL ISAKIA TELOUS ICHIMATOS
1D0AD;AL # BYZANTINE MUSICAL SYMBOL APOSTROFOI TELOUS ICHIMATOS
1D0AE;AL # BYZANTINE MUSICAL SYMBOL FANEROSIS TETRAFONIAS
1D0AF;AL # BYZANTINE MUSICAL SYMBOL FANEROSIS MONOFONIAS
1D0B0;AL # BYZANTINE MUSICAL SYMBOL FANEROSIS DIFONIAS
1D0B1;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA VARYS ICHOS
1D0B2;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOVARYS ICHOS
1D0B3;AL # BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS TETARTOS ICHOS
1D0B4;AL # BYZANTINE MUSICAL SYMBOL GORTHMIKON N APLOUN
1D0B5;AL # BYZANTINE MUSICAL SYMBOL GORTHMIKON N DIPLOUN
1D0B6;AL # BYZANTINE MUSICAL SYMBOL ENARXIS KAI FTHORA VOU
1D0B7;AL # BYZANTINE MUSICAL SYMBOL IMIFONON
1D0B8;AL # BYZANTINE MUSICAL SYMBOL IMIFTHORON
1D0B9;AL # BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION DEYTEROU ICHOU
1D0BA;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI PA
1D0BB;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NANA
1D0BC;AL # BYZANTINE MUSICAL SYMBOL FTHORA NAOS ICHOS
1D0BD;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI DI
1D0BE;AL # BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON DIATONON DI
1D0BF;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI KE
1D0C0;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI ZO
1D0C1;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI KATO
1D0C2;AL # BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI ANO
1D0C3;AL # BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA DIFONIAS
1D0C4;AL # BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA MONOFONIAS
1D0C5;AL # BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS
1D0C6;AL # BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA SYNAFI
1D0C7;AL # BYZANTINE MUSICAL SYMBOL FTHORA NENANO
1D0C8;AL # BYZANTINE MUSICAL SYMBOL CHROA ZYGOS
1D0C9;AL # BYZANTINE MUSICAL SYMBOL CHROA KLITON
1D0CA;AL # BYZANTINE MUSICAL SYMBOL CHROA SPATHI
1D0CB;AL # BYZANTINE MUSICAL SYMBOL FTHORA I YFESIS TETARTIMORION
1D0CC;AL # BYZANTINE MUSICAL SYMBOL FTHORA ENARMONIOS ANTIFONIA
1D0CD;AL # BYZANTINE MUSICAL SYMBOL YFESIS TRITIMORION
1D0CE;AL # BYZANTINE MUSICAL SYMBOL DIESIS TRITIMORION
1D0CF;AL # BYZANTINE MUSICAL SYMBOL DIESIS TETARTIMORION
1D0D0;AL # BYZANTINE MUSICAL SYMBOL DIESIS APLI DYO DODEKATA
1D0D1;AL # BYZANTINE MUSICAL SYMBOL DIESIS MONOGRAMMOS TESSERA DODEKATA
1D0D2;AL # BYZANTINE MUSICAL SYMBOL DIESIS DIGRAMMOS EX DODEKATA
1D0D3;AL # BYZANTINE MUSICAL SYMBOL DIESIS TRIGRAMMOS OKTO DODEKATA
1D0D4;AL # BYZANTINE MUSICAL SYMBOL YFESIS APLI DYO DODEKATA
1D0D5;AL # BYZANTINE MUSICAL SYMBOL YFESIS MONOGRAMMOS TESSERA DODEKATA
1D0D6;AL # BYZANTINE MUSICAL SYMBOL YFESIS DIGRAMMOS EX DODEKATA
1D0D7;AL # BYZANTINE MUSICAL SYMBOL YFESIS TRIGRAMMOS OKTO DODEKATA
1D0D8;AL # BYZANTINE MUSICAL SYMBOL GENIKI DIESIS
1D0D9;AL # BYZANTINE MUSICAL SYMBOL GENIKI YFESIS
1D0DA;AL # BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MIKRI
1D0DB;AL # BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MEGALI
1D0DC;AL # BYZANTINE MUSICAL SYMBOL DIASTOLI DIPLI
1D0DD;AL # BYZANTINE MUSICAL SYMBOL DIASTOLI THESEOS
1D0DE;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS
1D0DF;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS DISIMOU
1D0E0;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TRISIMOU
1D0E1;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TETRASIMOU
1D0E2;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS
1D0E3;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS DISIMOU
1D0E4;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TRISIMOU
1D0E5;AL # BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TETRASIMOU
1D0E6;AL # BYZANTINE MUSICAL SYMBOL DIGRAMMA GG
1D0E7;AL # BYZANTINE MUSICAL SYMBOL DIFTOGGOS OU
1D0E8;AL # BYZANTINE MUSICAL SYMBOL STIGMA
1D0E9;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO PA
1D0EA;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO VOU
1D0EB;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO GA
1D0EC;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO DI
1D0ED;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO KE
1D0EE;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO ZO
1D0EF;AL # BYZANTINE MUSICAL SYMBOL ARKTIKO NI
1D0F0;AL # BYZANTINE MUSICAL SYMBOL KENTIMATA NEO MESO
1D0F1;AL # BYZANTINE MUSICAL SYMBOL KENTIMA NEO MESO
1D0F2;AL # BYZANTINE MUSICAL SYMBOL KENTIMATA NEO KATO
1D0F3;AL # BYZANTINE MUSICAL SYMBOL KENTIMA NEO KATO
1D0F4;AL # BYZANTINE MUSICAL SYMBOL KLASMA KATO
1D0F5;AL # BYZANTINE MUSICAL SYMBOL GORGON NEO KATO
1D100;AL # MUSICAL SYMBOL SINGLE BARLINE
1D101;AL # MUSICAL SYMBOL DOUBLE BARLINE
1D102;AL # MUSICAL SYMBOL FINAL BARLINE
1D103;AL # MUSICAL SYMBOL REVERSE FINAL BARLINE
1D104;AL # MUSICAL SYMBOL DASHED BARLINE
1D105;AL # MUSICAL SYMBOL SHORT BARLINE
1D106;AL # MUSICAL SYMBOL LEFT REPEAT SIGN
1D107;AL # MUSICAL SYMBOL RIGHT REPEAT SIGN
1D108;AL # MUSICAL SYMBOL REPEAT DOTS
1D109;AL # MUSICAL SYMBOL DAL SEGNO
1D10A;AL # MUSICAL SYMBOL DA CAPO
1D10B;AL # MUSICAL SYMBOL SEGNO
1D10C;AL # MUSICAL SYMBOL CODA
1D10D;AL # MUSICAL SYMBOL REPEATED FIGURE-1
1D10E;AL # MUSICAL SYMBOL REPEATED FIGURE-2
1D10F;AL # MUSICAL SYMBOL REPEATED FIGURE-3
1D110;AL # MUSICAL SYMBOL FERMATA
1D111;AL # MUSICAL SYMBOL FERMATA BELOW
1D112;AL # MUSICAL SYMBOL BREATH MARK
1D113;AL # MUSICAL SYMBOL CAESURA
1D114;AL # MUSICAL SYMBOL BRACE
1D115;AL # MUSICAL SYMBOL BRACKET
1D116;AL # MUSICAL SYMBOL ONE-LINE STAFF
1D117;AL # MUSICAL SYMBOL TWO-LINE STAFF
1D118;AL # MUSICAL SYMBOL THREE-LINE STAFF
1D119;AL # MUSICAL SYMBOL FOUR-LINE STAFF
1D11A;AL # MUSICAL SYMBOL FIVE-LINE STAFF
1D11B;AL # MUSICAL SYMBOL SIX-LINE STAFF
1D11C;AL # MUSICAL SYMBOL SIX-STRING FRETBOARD
1D11D;AL # MUSICAL SYMBOL FOUR-STRING FRETBOARD
1D11E;AL # MUSICAL SYMBOL G CLEF
1D11F;AL # MUSICAL SYMBOL G CLEF OTTAVA ALTA
1D120;AL # MUSICAL SYMBOL G CLEF OTTAVA BASSA
1D121;AL # MUSICAL SYMBOL C CLEF
1D122;AL # MUSICAL SYMBOL F CLEF
1D123;AL # MUSICAL SYMBOL F CLEF OTTAVA ALTA
1D124;AL # MUSICAL SYMBOL F CLEF OTTAVA BASSA
1D125;AL # MUSICAL SYMBOL DRUM CLEF-1
1D126;AL # MUSICAL SYMBOL DRUM CLEF-2
1D12A;AL # MUSICAL SYMBOL DOUBLE SHARP
1D12B;AL # MUSICAL SYMBOL DOUBLE FLAT
1D12C;AL # MUSICAL SYMBOL FLAT UP
1D12D;AL # MUSICAL SYMBOL FLAT DOWN
1D12E;AL # MUSICAL SYMBOL NATURAL UP
1D12F;AL # MUSICAL SYMBOL NATURAL DOWN
1D130;AL # MUSICAL SYMBOL SHARP UP
1D131;AL # MUSICAL SYMBOL SHARP DOWN
1D132;AL # MUSICAL SYMBOL QUARTER TONE SHARP
1D133;AL # MUSICAL SYMBOL QUARTER TONE FLAT
1D134;AL # MUSICAL SYMBOL COMMON TIME
1D135;AL # MUSICAL SYMBOL CUT TIME
1D136;AL # MUSICAL SYMBOL OTTAVA ALTA
1D137;AL # MUSICAL SYMBOL OTTAVA BASSA
1D138;AL # MUSICAL SYMBOL QUINDICESIMA ALTA
1D139;AL # MUSICAL SYMBOL QUINDICESIMA BASSA
1D13A;AL # MUSICAL SYMBOL MULTI REST
1D13B;AL # MUSICAL SYMBOL WHOLE REST
1D13C;AL # MUSICAL SYMBOL HALF REST
1D13D;AL # MUSICAL SYMBOL QUARTER REST
1D13E;AL # MUSICAL SYMBOL EIGHTH REST
1D13F;AL # MUSICAL SYMBOL SIXTEENTH REST
1D140;AL # MUSICAL SYMBOL THIRTY-SECOND REST
1D141;AL # MUSICAL SYMBOL SIXTY-FOURTH REST
1D142;AL # MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH REST
1D143;AL # MUSICAL SYMBOL X NOTEHEAD
1D144;AL # MUSICAL SYMBOL PLUS NOTEHEAD
1D145;AL # MUSICAL SYMBOL CIRCLE X NOTEHEAD
1D146;AL # MUSICAL SYMBOL SQUARE NOTEHEAD WHITE
1D147;AL # MUSICAL SYMBOL SQUARE NOTEHEAD BLACK
1D148;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD UP WHITE
1D149;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD UP BLACK
1D14A;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT WHITE
1D14B;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT BLACK
1D14C;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT WHITE
1D14D;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT BLACK
1D14E;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN WHITE
1D14F;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN BLACK
1D150;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT WHITE
1D151;AL # MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT BLACK
1D152;AL # MUSICAL SYMBOL MOON NOTEHEAD WHITE
1D153;AL # MUSICAL SYMBOL MOON NOTEHEAD BLACK
1D154;AL # MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN WHITE
1D155;AL # MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN BLACK
1D156;AL # MUSICAL SYMBOL PARENTHESIS NOTEHEAD
1D157;AL # MUSICAL SYMBOL VOID NOTEHEAD
1D158;AL # MUSICAL SYMBOL NOTEHEAD BLACK
1D159;AL # MUSICAL SYMBOL NULL NOTEHEAD
1D15A;AL # MUSICAL SYMBOL CLUSTER NOTEHEAD WHITE
1D15B;AL # MUSICAL SYMBOL CLUSTER NOTEHEAD BLACK
1D15C;AL # MUSICAL SYMBOL BREVE
1D15D;AL # MUSICAL SYMBOL WHOLE NOTE
1D15E;AL # MUSICAL SYMBOL HALF NOTE
1D15F;AL # MUSICAL SYMBOL QUARTER NOTE
1D160;AL # MUSICAL SYMBOL EIGHTH NOTE
1D161;AL # MUSICAL SYMBOL SIXTEENTH NOTE
1D162;AL # MUSICAL SYMBOL THIRTY-SECOND NOTE
1D163;AL # MUSICAL SYMBOL SIXTY-FOURTH NOTE
1D164;AL # MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
1D165;CM # MUSICAL SYMBOL COMBINING STEM
1D166;CM # MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
1D167;CM # MUSICAL SYMBOL COMBINING TREMOLO-1
1D168;CM # MUSICAL SYMBOL COMBINING TREMOLO-2
1D169;CM # MUSICAL SYMBOL COMBINING TREMOLO-3
1D16A;AL # MUSICAL SYMBOL FINGERED TREMOLO-1
1D16B;AL # MUSICAL SYMBOL FINGERED TREMOLO-2
1D16C;AL # MUSICAL SYMBOL FINGERED TREMOLO-3
1D16D;CM # MUSICAL SYMBOL COMBINING AUGMENTATION DOT
1D16E;CM # MUSICAL SYMBOL COMBINING FLAG-1
1D16F;CM # MUSICAL SYMBOL COMBINING FLAG-2
1D170;CM # MUSICAL SYMBOL COMBINING FLAG-3
1D171;CM # MUSICAL SYMBOL COMBINING FLAG-4
1D172;CM # MUSICAL SYMBOL COMBINING FLAG-5
1D173;CM # MUSICAL SYMBOL BEGIN BEAM
1D174;CM # MUSICAL SYMBOL END BEAM
1D175;CM # MUSICAL SYMBOL BEGIN TIE
1D176;CM # MUSICAL SYMBOL END TIE
1D177;CM # MUSICAL SYMBOL BEGIN SLUR
1D178;CM # MUSICAL SYMBOL END SLUR
1D179;CM # MUSICAL SYMBOL BEGIN PHRASE
1D17A;CM # MUSICAL SYMBOL END PHRASE
1D17B;CM # MUSICAL SYMBOL COMBINING ACCENT
1D17C;CM # MUSICAL SYMBOL COMBINING STACCATO
1D17D;CM # MUSICAL SYMBOL COMBINING TENUTO
1D17E;CM # MUSICAL SYMBOL COMBINING STACCATISSIMO
1D17F;CM # MUSICAL SYMBOL COMBINING MARCATO
1D180;CM # MUSICAL SYMBOL COMBINING MARCATO-STACCATO
1D181;CM # MUSICAL SYMBOL COMBINING ACCENT-STACCATO
1D182;CM # MUSICAL SYMBOL COMBINING LOURE
1D183;AL # MUSICAL SYMBOL ARPEGGIATO UP
1D184;AL # MUSICAL SYMBOL ARPEGGIATO DOWN
1D185;CM # MUSICAL SYMBOL COMBINING DOIT
1D186;CM # MUSICAL SYMBOL COMBINING RIP
1D187;CM # MUSICAL SYMBOL COMBINING FLIP
1D188;CM # MUSICAL SYMBOL COMBINING SMEAR
1D189;CM # MUSICAL SYMBOL COMBINING BEND
1D18A;CM # MUSICAL SYMBOL COMBINING DOUBLE TONGUE
1D18B;CM # MUSICAL SYMBOL COMBINING TRIPLE TONGUE
1D18C;AL # MUSICAL SYMBOL RINFORZANDO
1D18D;AL # MUSICAL SYMBOL SUBITO
1D18E;AL # MUSICAL SYMBOL Z
1D18F;AL # MUSICAL SYMBOL PIANO
1D190;AL # MUSICAL SYMBOL MEZZO
1D191;AL # MUSICAL SYMBOL FORTE
1D192;AL # MUSICAL SYMBOL CRESCENDO
1D193;AL # MUSICAL SYMBOL DECRESCENDO
1D194;AL # MUSICAL SYMBOL GRACE NOTE SLASH
1D195;AL # MUSICAL SYMBOL GRACE NOTE NO SLASH
1D196;AL # MUSICAL SYMBOL TR
1D197;AL # MUSICAL SYMBOL TURN
1D198;AL # MUSICAL SYMBOL INVERTED TURN
1D199;AL # MUSICAL SYMBOL TURN SLASH
1D19A;AL # MUSICAL SYMBOL TURN UP
1D19B;AL # MUSICAL SYMBOL ORNAMENT STROKE-1
1D19C;AL # MUSICAL SYMBOL ORNAMENT STROKE-2
1D19D;AL # MUSICAL SYMBOL ORNAMENT STROKE-3
1D19E;AL # MUSICAL SYMBOL ORNAMENT STROKE-4
1D19F;AL # MUSICAL SYMBOL ORNAMENT STROKE-5
1D1A0;AL # MUSICAL SYMBOL ORNAMENT STROKE-6
1D1A1;AL # MUSICAL SYMBOL ORNAMENT STROKE-7
1D1A2;AL # MUSICAL SYMBOL ORNAMENT STROKE-8
1D1A3;AL # MUSICAL SYMBOL ORNAMENT STROKE-9
1D1A4;AL # MUSICAL SYMBOL ORNAMENT STROKE-10
1D1A5;AL # MUSICAL SYMBOL ORNAMENT STROKE-11
1D1A6;AL # MUSICAL SYMBOL HAUPTSTIMME
1D1A7;AL # MUSICAL SYMBOL NEBENSTIMME
1D1A8;AL # MUSICAL SYMBOL END OF STIMME
1D1A9;AL # MUSICAL SYMBOL DEGREE SLASH
1D1AA;CM # MUSICAL SYMBOL COMBINING DOWN BOW
1D1AB;CM # MUSICAL SYMBOL COMBINING UP BOW
1D1AC;CM # MUSICAL SYMBOL COMBINING HARMONIC
1D1AD;CM # MUSICAL SYMBOL COMBINING SNAP PIZZICATO
1D1AE;AL # MUSICAL SYMBOL PEDAL MARK
1D1AF;AL # MUSICAL SYMBOL PEDAL UP MARK
1D1B0;AL # MUSICAL SYMBOL HALF PEDAL MARK
1D1B1;AL # MUSICAL SYMBOL GLISSANDO UP
1D1B2;AL # MUSICAL SYMBOL GLISSANDO DOWN
1D1B3;AL # MUSICAL SYMBOL WITH FINGERNAILS
1D1B4;AL # MUSICAL SYMBOL DAMP
1D1B5;AL # MUSICAL SYMBOL DAMP ALL
1D1B6;AL # MUSICAL SYMBOL MAXIMA
1D1B7;AL # MUSICAL SYMBOL LONGA
1D1B8;AL # MUSICAL SYMBOL BREVIS
1D1B9;AL # MUSICAL SYMBOL SEMIBREVIS WHITE
1D1BA;AL # MUSICAL SYMBOL SEMIBREVIS BLACK
1D1BB;AL # MUSICAL SYMBOL MINIMA
1D1BC;AL # MUSICAL SYMBOL MINIMA BLACK
1D1BD;AL # MUSICAL SYMBOL SEMIMINIMA WHITE
1D1BE;AL # MUSICAL SYMBOL SEMIMINIMA BLACK
1D1BF;AL # MUSICAL SYMBOL FUSA WHITE
1D1C0;AL # MUSICAL SYMBOL FUSA BLACK
1D1C1;AL # MUSICAL SYMBOL LONGA PERFECTA REST
1D1C2;AL # MUSICAL SYMBOL LONGA IMPERFECTA REST
1D1C3;AL # MUSICAL SYMBOL BREVIS REST
1D1C4;AL # MUSICAL SYMBOL SEMIBREVIS REST
1D1C5;AL # MUSICAL SYMBOL MINIMA REST
1D1C6;AL # MUSICAL SYMBOL SEMIMINIMA REST
1D1C7;AL # MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA
1D1C8;AL # MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE IMPERFECTA
1D1C9;AL # MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA DIMINUTION-1
1D1CA;AL # MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE PERFECTA
1D1CB;AL # MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA
1D1CC;AL # MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-1
1D1CD;AL # MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-2
1D1CE;AL # MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-3
1D1CF;AL # MUSICAL SYMBOL CROIX
1D1D0;AL # MUSICAL SYMBOL GREGORIAN C CLEF
1D1D1;AL # MUSICAL SYMBOL GREGORIAN F CLEF
1D1D2;AL # MUSICAL SYMBOL SQUARE B
1D1D3;AL # MUSICAL SYMBOL VIRGA
1D1D4;AL # MUSICAL SYMBOL PODATUS
1D1D5;AL # MUSICAL SYMBOL CLIVIS
1D1D6;AL # MUSICAL SYMBOL SCANDICUS
1D1D7;AL # MUSICAL SYMBOL CLIMACUS
1D1D8;AL # MUSICAL SYMBOL TORCULUS
1D1D9;AL # MUSICAL SYMBOL PORRECTUS
1D1DA;AL # MUSICAL SYMBOL PORRECTUS FLEXUS
1D1DB;AL # MUSICAL SYMBOL SCANDICUS FLEXUS
1D1DC;AL # MUSICAL SYMBOL TORCULUS RESUPINUS
1D1DD;AL # MUSICAL SYMBOL PES SUBPUNCTIS
1D200;AL # GREEK VOCAL NOTATION SYMBOL-1
1D201;AL # GREEK VOCAL NOTATION SYMBOL-2
1D202;AL # GREEK VOCAL NOTATION SYMBOL-3
1D203;AL # GREEK VOCAL NOTATION SYMBOL-4
1D204;AL # GREEK VOCAL NOTATION SYMBOL-5
1D205;AL # GREEK VOCAL NOTATION SYMBOL-6
1D206;AL # GREEK VOCAL NOTATION SYMBOL-7
1D207;AL # GREEK VOCAL NOTATION SYMBOL-8
1D208;AL # GREEK VOCAL NOTATION SYMBOL-9
1D209;AL # GREEK VOCAL NOTATION SYMBOL-10
1D20A;AL # GREEK VOCAL NOTATION SYMBOL-11
1D20B;AL # GREEK VOCAL NOTATION SYMBOL-12
1D20C;AL # GREEK VOCAL NOTATION SYMBOL-13
1D20D;AL # GREEK VOCAL NOTATION SYMBOL-14
1D20E;AL # GREEK VOCAL NOTATION SYMBOL-15
1D20F;AL # GREEK VOCAL NOTATION SYMBOL-16
1D210;AL # GREEK VOCAL NOTATION SYMBOL-17
1D211;AL # GREEK VOCAL NOTATION SYMBOL-18
1D212;AL # GREEK VOCAL NOTATION SYMBOL-19
1D213;AL # GREEK VOCAL NOTATION SYMBOL-20
1D214;AL # GREEK VOCAL NOTATION SYMBOL-21
1D215;AL # GREEK VOCAL NOTATION SYMBOL-22
1D216;AL # GREEK VOCAL NOTATION SYMBOL-23
1D217;AL # GREEK VOCAL NOTATION SYMBOL-24
1D218;AL # GREEK VOCAL NOTATION SYMBOL-50
1D219;AL # GREEK VOCAL NOTATION SYMBOL-51
1D21A;AL # GREEK VOCAL NOTATION SYMBOL-52
1D21B;AL # GREEK VOCAL NOTATION SYMBOL-53
1D21C;AL # GREEK VOCAL NOTATION SYMBOL-54
1D21D;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-1
1D21E;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-2
1D21F;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-4
1D220;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-5
1D221;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-7
1D222;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-8
1D223;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-11
1D224;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-12
1D225;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-13
1D226;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-14
1D227;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-17
1D228;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-18
1D229;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-19
1D22A;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-23
1D22B;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-24
1D22C;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-25
1D22D;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-26
1D22E;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-27
1D22F;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-29
1D230;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-30
1D231;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-32
1D232;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-36
1D233;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-37
1D234;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-38
1D235;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-39
1D236;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-40
1D237;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-42
1D238;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-43
1D239;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-45
1D23A;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-47
1D23B;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-48
1D23C;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-49
1D23D;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-50
1D23E;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-51
1D23F;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-52
1D240;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-53
1D241;AL # GREEK INSTRUMENTAL NOTATION SYMBOL-54
1D242;CM # COMBINING GREEK MUSICAL TRISEME
1D243;CM # COMBINING GREEK MUSICAL TETRASEME
1D244;CM # COMBINING GREEK MUSICAL PENTASEME
1D245;AL # GREEK MUSICAL LEIMMA
1D300;AL # MONOGRAM FOR EARTH
1D301;AL # DIGRAM FOR HEAVENLY EARTH
1D302;AL # DIGRAM FOR HUMAN EARTH
1D303;AL # DIGRAM FOR EARTHLY HEAVEN
1D304;AL # DIGRAM FOR EARTHLY HUMAN
1D305;AL # DIGRAM FOR EARTH
1D306;AL # TETRAGRAM FOR CENTRE
1D307;AL # TETRAGRAM FOR FULL CIRCLE
1D308;AL # TETRAGRAM FOR MIRED
1D309;AL # TETRAGRAM FOR BARRIER
1D30A;AL # TETRAGRAM FOR KEEPING SMALL
1D30B;AL # TETRAGRAM FOR CONTRARIETY
1D30C;AL # TETRAGRAM FOR ASCENT
1D30D;AL # TETRAGRAM FOR OPPOSITION
1D30E;AL # TETRAGRAM FOR BRANCHING OUT
1D30F;AL # TETRAGRAM FOR DEFECTIVENESS OR DISTORTION
1D310;AL # TETRAGRAM FOR DIVERGENCE
1D311;AL # TETRAGRAM FOR YOUTHFULNESS
1D312;AL # TETRAGRAM FOR INCREASE
1D313;AL # TETRAGRAM FOR PENETRATION
1D314;AL # TETRAGRAM FOR REACH
1D315;AL # TETRAGRAM FOR CONTACT
1D316;AL # TETRAGRAM FOR HOLDING BACK
1D317;AL # TETRAGRAM FOR WAITING
1D318;AL # TETRAGRAM FOR FOLLOWING
1D319;AL # TETRAGRAM FOR ADVANCE
1D31A;AL # TETRAGRAM FOR RELEASE
1D31B;AL # TETRAGRAM FOR RESISTANCE
1D31C;AL # TETRAGRAM FOR EASE
1D31D;AL # TETRAGRAM FOR JOY
1D31E;AL # TETRAGRAM FOR CONTENTION
1D31F;AL # TETRAGRAM FOR ENDEAVOUR
1D320;AL # TETRAGRAM FOR DUTIES
1D321;AL # TETRAGRAM FOR CHANGE
1D322;AL # TETRAGRAM FOR DECISIVENESS
1D323;AL # TETRAGRAM FOR BOLD RESOLUTION
1D324;AL # TETRAGRAM FOR PACKING
1D325;AL # TETRAGRAM FOR LEGION
1D326;AL # TETRAGRAM FOR CLOSENESS
1D327;AL # TETRAGRAM FOR KINSHIP
1D328;AL # TETRAGRAM FOR GATHERING
1D329;AL # TETRAGRAM FOR STRENGTH
1D32A;AL # TETRAGRAM FOR PURITY
1D32B;AL # TETRAGRAM FOR FULLNESS
1D32C;AL # TETRAGRAM FOR RESIDENCE
1D32D;AL # TETRAGRAM FOR LAW OR MODEL
1D32E;AL # TETRAGRAM FOR RESPONSE
1D32F;AL # TETRAGRAM FOR GOING TO MEET
1D330;AL # TETRAGRAM FOR ENCOUNTERS
1D331;AL # TETRAGRAM FOR STOVE
1D332;AL # TETRAGRAM FOR GREATNESS
1D333;AL # TETRAGRAM FOR ENLARGEMENT
1D334;AL # TETRAGRAM FOR PATTERN
1D335;AL # TETRAGRAM FOR RITUAL
1D336;AL # TETRAGRAM FOR FLIGHT
1D337;AL # TETRAGRAM FOR VASTNESS OR WASTING
1D338;AL # TETRAGRAM FOR CONSTANCY
1D339;AL # TETRAGRAM FOR MEASURE
1D33A;AL # TETRAGRAM FOR ETERNITY
1D33B;AL # TETRAGRAM FOR UNITY
1D33C;AL # TETRAGRAM FOR DIMINISHMENT
1D33D;AL # TETRAGRAM FOR CLOSED MOUTH
1D33E;AL # TETRAGRAM FOR GUARDEDNESS
1D33F;AL # TETRAGRAM FOR GATHERING IN
1D340;AL # TETRAGRAM FOR MASSING
1D341;AL # TETRAGRAM FOR ACCUMULATION
1D342;AL # TETRAGRAM FOR EMBELLISHMENT
1D343;AL # TETRAGRAM FOR DOUBT
1D344;AL # TETRAGRAM FOR WATCH
1D345;AL # TETRAGRAM FOR SINKING
1D346;AL # TETRAGRAM FOR INNER
1D347;AL # TETRAGRAM FOR DEPARTURE
1D348;AL # TETRAGRAM FOR DARKENING
1D349;AL # TETRAGRAM FOR DIMMING
1D34A;AL # TETRAGRAM FOR EXHAUSTION
1D34B;AL # TETRAGRAM FOR SEVERANCE
1D34C;AL # TETRAGRAM FOR STOPPAGE
1D34D;AL # TETRAGRAM FOR HARDNESS
1D34E;AL # TETRAGRAM FOR COMPLETION
1D34F;AL # TETRAGRAM FOR CLOSURE
1D350;AL # TETRAGRAM FOR FAILURE
1D351;AL # TETRAGRAM FOR AGGRAVATION
1D352;AL # TETRAGRAM FOR COMPLIANCE
1D353;AL # TETRAGRAM FOR ON THE VERGE
1D354;AL # TETRAGRAM FOR DIFFICULTIES
1D355;AL # TETRAGRAM FOR LABOURING
1D356;AL # TETRAGRAM FOR FOSTERING
1D400;AL # MATHEMATICAL BOLD CAPITAL A
1D401;AL # MATHEMATICAL BOLD CAPITAL B
1D402;AL # MATHEMATICAL BOLD CAPITAL C
1D403;AL # MATHEMATICAL BOLD CAPITAL D
1D404;AL # MATHEMATICAL BOLD CAPITAL E
1D405;AL # MATHEMATICAL BOLD CAPITAL F
1D406;AL # MATHEMATICAL BOLD CAPITAL G
1D407;AL # MATHEMATICAL BOLD CAPITAL H
1D408;AL # MATHEMATICAL BOLD CAPITAL I
1D409;AL # MATHEMATICAL BOLD CAPITAL J
1D40A;AL # MATHEMATICAL BOLD CAPITAL K
1D40B;AL # MATHEMATICAL BOLD CAPITAL L
1D40C;AL # MATHEMATICAL BOLD CAPITAL M
1D40D;AL # MATHEMATICAL BOLD CAPITAL N
1D40E;AL # MATHEMATICAL BOLD CAPITAL O
1D40F;AL # MATHEMATICAL BOLD CAPITAL P
1D410;AL # MATHEMATICAL BOLD CAPITAL Q
1D411;AL # MATHEMATICAL BOLD CAPITAL R
1D412;AL # MATHEMATICAL BOLD CAPITAL S
1D413;AL # MATHEMATICAL BOLD CAPITAL T
1D414;AL # MATHEMATICAL BOLD CAPITAL U
1D415;AL # MATHEMATICAL BOLD CAPITAL V
1D416;AL # MATHEMATICAL BOLD CAPITAL W
1D417;AL # MATHEMATICAL BOLD CAPITAL X
1D418;AL # MATHEMATICAL BOLD CAPITAL Y
1D419;AL # MATHEMATICAL BOLD CAPITAL Z
1D41A;AL # MATHEMATICAL BOLD SMALL A
1D41B;AL # MATHEMATICAL BOLD SMALL B
1D41C;AL # MATHEMATICAL BOLD SMALL C
1D41D;AL # MATHEMATICAL BOLD SMALL D
1D41E;AL # MATHEMATICAL BOLD SMALL E
1D41F;AL # MATHEMATICAL BOLD SMALL F
1D420;AL # MATHEMATICAL BOLD SMALL G
1D421;AL # MATHEMATICAL BOLD SMALL H
1D422;AL # MATHEMATICAL BOLD SMALL I
1D423;AL # MATHEMATICAL BOLD SMALL J
1D424;AL # MATHEMATICAL BOLD SMALL K
1D425;AL # MATHEMATICAL BOLD SMALL L
1D426;AL # MATHEMATICAL BOLD SMALL M
1D427;AL # MATHEMATICAL BOLD SMALL N
1D428;AL # MATHEMATICAL BOLD SMALL O
1D429;AL # MATHEMATICAL BOLD SMALL P
1D42A;AL # MATHEMATICAL BOLD SMALL Q
1D42B;AL # MATHEMATICAL BOLD SMALL R
1D42C;AL # MATHEMATICAL BOLD SMALL S
1D42D;AL # MATHEMATICAL BOLD SMALL T
1D42E;AL # MATHEMATICAL BOLD SMALL U
1D42F;AL # MATHEMATICAL BOLD SMALL V
1D430;AL # MATHEMATICAL BOLD SMALL W
1D431;AL # MATHEMATICAL BOLD SMALL X
1D432;AL # MATHEMATICAL BOLD SMALL Y
1D433;AL # MATHEMATICAL BOLD SMALL Z
1D434;AL # MATHEMATICAL ITALIC CAPITAL A
1D435;AL # MATHEMATICAL ITALIC CAPITAL B
1D436;AL # MATHEMATICAL ITALIC CAPITAL C
1D437;AL # MATHEMATICAL ITALIC CAPITAL D
1D438;AL # MATHEMATICAL ITALIC CAPITAL E
1D439;AL # MATHEMATICAL ITALIC CAPITAL F
1D43A;AL # MATHEMATICAL ITALIC CAPITAL G
1D43B;AL # MATHEMATICAL ITALIC CAPITAL H
1D43C;AL # MATHEMATICAL ITALIC CAPITAL I
1D43D;AL # MATHEMATICAL ITALIC CAPITAL J
1D43E;AL # MATHEMATICAL ITALIC CAPITAL K
1D43F;AL # MATHEMATICAL ITALIC CAPITAL L
1D440;AL # MATHEMATICAL ITALIC CAPITAL M
1D441;AL # MATHEMATICAL ITALIC CAPITAL N
1D442;AL # MATHEMATICAL ITALIC CAPITAL O
1D443;AL # MATHEMATICAL ITALIC CAPITAL P
1D444;AL # MATHEMATICAL ITALIC CAPITAL Q
1D445;AL # MATHEMATICAL ITALIC CAPITAL R
1D446;AL # MATHEMATICAL ITALIC CAPITAL S
1D447;AL # MATHEMATICAL ITALIC CAPITAL T
1D448;AL # MATHEMATICAL ITALIC CAPITAL U
1D449;AL # MATHEMATICAL ITALIC CAPITAL V
1D44A;AL # MATHEMATICAL ITALIC CAPITAL W
1D44B;AL # MATHEMATICAL ITALIC CAPITAL X
1D44C;AL # MATHEMATICAL ITALIC CAPITAL Y
1D44D;AL # MATHEMATICAL ITALIC CAPITAL Z
1D44E;AL # MATHEMATICAL ITALIC SMALL A
1D44F;AL # MATHEMATICAL ITALIC SMALL B
1D450;AL # MATHEMATICAL ITALIC SMALL C
1D451;AL # MATHEMATICAL ITALIC SMALL D
1D452;AL # MATHEMATICAL ITALIC SMALL E
1D453;AL # MATHEMATICAL ITALIC SMALL F
1D454;AL # MATHEMATICAL ITALIC SMALL G
1D456;AL # MATHEMATICAL ITALIC SMALL I
1D457;AL # MATHEMATICAL ITALIC SMALL J
1D458;AL # MATHEMATICAL ITALIC SMALL K
1D459;AL # MATHEMATICAL ITALIC SMALL L
1D45A;AL # MATHEMATICAL ITALIC SMALL M
1D45B;AL # MATHEMATICAL ITALIC SMALL N
1D45C;AL # MATHEMATICAL ITALIC SMALL O
1D45D;AL # MATHEMATICAL ITALIC SMALL P
1D45E;AL # MATHEMATICAL ITALIC SMALL Q
1D45F;AL # MATHEMATICAL ITALIC SMALL R
1D460;AL # MATHEMATICAL ITALIC SMALL S
1D461;AL # MATHEMATICAL ITALIC SMALL T
1D462;AL # MATHEMATICAL ITALIC SMALL U
1D463;AL # MATHEMATICAL ITALIC SMALL V
1D464;AL # MATHEMATICAL ITALIC SMALL W
1D465;AL # MATHEMATICAL ITALIC SMALL X
1D466;AL # MATHEMATICAL ITALIC SMALL Y
1D467;AL # MATHEMATICAL ITALIC SMALL Z
1D468;AL # MATHEMATICAL BOLD ITALIC CAPITAL A
1D469;AL # MATHEMATICAL BOLD ITALIC CAPITAL B
1D46A;AL # MATHEMATICAL BOLD ITALIC CAPITAL C
1D46B;AL # MATHEMATICAL BOLD ITALIC CAPITAL D
1D46C;AL # MATHEMATICAL BOLD ITALIC CAPITAL E
1D46D;AL # MATHEMATICAL BOLD ITALIC CAPITAL F
1D46E;AL # MATHEMATICAL BOLD ITALIC CAPITAL G
1D46F;AL # MATHEMATICAL BOLD ITALIC CAPITAL H
1D470;AL # MATHEMATICAL BOLD ITALIC CAPITAL I
1D471;AL # MATHEMATICAL BOLD ITALIC CAPITAL J
1D472;AL # MATHEMATICAL BOLD ITALIC CAPITAL K
1D473;AL # MATHEMATICAL BOLD ITALIC CAPITAL L
1D474;AL # MATHEMATICAL BOLD ITALIC CAPITAL M
1D475;AL # MATHEMATICAL BOLD ITALIC CAPITAL N
1D476;AL # MATHEMATICAL BOLD ITALIC CAPITAL O
1D477;AL # MATHEMATICAL BOLD ITALIC CAPITAL P
1D478;AL # MATHEMATICAL BOLD ITALIC CAPITAL Q
1D479;AL # MATHEMATICAL BOLD ITALIC CAPITAL R
1D47A;AL # MATHEMATICAL BOLD ITALIC CAPITAL S
1D47B;AL # MATHEMATICAL BOLD ITALIC CAPITAL T
1D47C;AL # MATHEMATICAL BOLD ITALIC CAPITAL U
1D47D;AL # MATHEMATICAL BOLD ITALIC CAPITAL V
1D47E;AL # MATHEMATICAL BOLD ITALIC CAPITAL W
1D47F;AL # MATHEMATICAL BOLD ITALIC CAPITAL X
1D480;AL # MATHEMATICAL BOLD ITALIC CAPITAL Y
1D481;AL # MATHEMATICAL BOLD ITALIC CAPITAL Z
1D482;AL # MATHEMATICAL BOLD ITALIC SMALL A
1D483;AL # MATHEMATICAL BOLD ITALIC SMALL B
1D484;AL # MATHEMATICAL BOLD ITALIC SMALL C
1D485;AL # MATHEMATICAL BOLD ITALIC SMALL D
1D486;AL # MATHEMATICAL BOLD ITALIC SMALL E
1D487;AL # MATHEMATICAL BOLD ITALIC SMALL F
1D488;AL # MATHEMATICAL BOLD ITALIC SMALL G
1D489;AL # MATHEMATICAL BOLD ITALIC SMALL H
1D48A;AL # MATHEMATICAL BOLD ITALIC SMALL I
1D48B;AL # MATHEMATICAL BOLD ITALIC SMALL J
1D48C;AL # MATHEMATICAL BOLD ITALIC SMALL K
1D48D;AL # MATHEMATICAL BOLD ITALIC SMALL L
1D48E;AL # MATHEMATICAL BOLD ITALIC SMALL M
1D48F;AL # MATHEMATICAL BOLD ITALIC SMALL N
1D490;AL # MATHEMATICAL BOLD ITALIC SMALL O
1D491;AL # MATHEMATICAL BOLD ITALIC SMALL P
1D492;AL # MATHEMATICAL BOLD ITALIC SMALL Q
1D493;AL # MATHEMATICAL BOLD ITALIC SMALL R
1D494;AL # MATHEMATICAL BOLD ITALIC SMALL S
1D495;AL # MATHEMATICAL BOLD ITALIC SMALL T
1D496;AL # MATHEMATICAL BOLD ITALIC SMALL U
1D497;AL # MATHEMATICAL BOLD ITALIC SMALL V
1D498;AL # MATHEMATICAL BOLD ITALIC SMALL W
1D499;AL # MATHEMATICAL BOLD ITALIC SMALL X
1D49A;AL # MATHEMATICAL BOLD ITALIC SMALL Y
1D49B;AL # MATHEMATICAL BOLD ITALIC SMALL Z
1D49C;AL # MATHEMATICAL SCRIPT CAPITAL A
1D49E;AL # MATHEMATICAL SCRIPT CAPITAL C
1D49F;AL # MATHEMATICAL SCRIPT CAPITAL D
1D4A2;AL # MATHEMATICAL SCRIPT CAPITAL G
1D4A5;AL # MATHEMATICAL SCRIPT CAPITAL J
1D4A6;AL # MATHEMATICAL SCRIPT CAPITAL K
1D4A9;AL # MATHEMATICAL SCRIPT CAPITAL N
1D4AA;AL # MATHEMATICAL SCRIPT CAPITAL O
1D4AB;AL # MATHEMATICAL SCRIPT CAPITAL P
1D4AC;AL # MATHEMATICAL SCRIPT CAPITAL Q
1D4AE;AL # MATHEMATICAL SCRIPT CAPITAL S
1D4AF;AL # MATHEMATICAL SCRIPT CAPITAL T
1D4B0;AL # MATHEMATICAL SCRIPT CAPITAL U
1D4B1;AL # MATHEMATICAL SCRIPT CAPITAL V
1D4B2;AL # MATHEMATICAL SCRIPT CAPITAL W
1D4B3;AL # MATHEMATICAL SCRIPT CAPITAL X
1D4B4;AL # MATHEMATICAL SCRIPT CAPITAL Y
1D4B5;AL # MATHEMATICAL SCRIPT CAPITAL Z
1D4B6;AL # MATHEMATICAL SCRIPT SMALL A
1D4B7;AL # MATHEMATICAL SCRIPT SMALL B
1D4B8;AL # MATHEMATICAL SCRIPT SMALL C
1D4B9;AL # MATHEMATICAL SCRIPT SMALL D
1D4BB;AL # MATHEMATICAL SCRIPT SMALL F
1D4BD;AL # MATHEMATICAL SCRIPT SMALL H
1D4BE;AL # MATHEMATICAL SCRIPT SMALL I
1D4BF;AL # MATHEMATICAL SCRIPT SMALL J
1D4C0;AL # MATHEMATICAL SCRIPT SMALL K
1D4C1;AL # MATHEMATICAL SCRIPT SMALL L
1D4C2;AL # MATHEMATICAL SCRIPT SMALL M
1D4C3;AL # MATHEMATICAL SCRIPT SMALL N
1D4C5;AL # MATHEMATICAL SCRIPT SMALL P
1D4C6;AL # MATHEMATICAL SCRIPT SMALL Q
1D4C7;AL # MATHEMATICAL SCRIPT SMALL R
1D4C8;AL # MATHEMATICAL SCRIPT SMALL S
1D4C9;AL # MATHEMATICAL SCRIPT SMALL T
1D4CA;AL # MATHEMATICAL SCRIPT SMALL U
1D4CB;AL # MATHEMATICAL SCRIPT SMALL V
1D4CC;AL # MATHEMATICAL SCRIPT SMALL W
1D4CD;AL # MATHEMATICAL SCRIPT SMALL X
1D4CE;AL # MATHEMATICAL SCRIPT SMALL Y
1D4CF;AL # MATHEMATICAL SCRIPT SMALL Z
1D4D0;AL # MATHEMATICAL BOLD SCRIPT CAPITAL A
1D4D1;AL # MATHEMATICAL BOLD SCRIPT CAPITAL B
1D4D2;AL # MATHEMATICAL BOLD SCRIPT CAPITAL C
1D4D3;AL # MATHEMATICAL BOLD SCRIPT CAPITAL D
1D4D4;AL # MATHEMATICAL BOLD SCRIPT CAPITAL E
1D4D5;AL # MATHEMATICAL BOLD SCRIPT CAPITAL F
1D4D6;AL # MATHEMATICAL BOLD SCRIPT CAPITAL G
1D4D7;AL # MATHEMATICAL BOLD SCRIPT CAPITAL H
1D4D8;AL # MATHEMATICAL BOLD SCRIPT CAPITAL I
1D4D9;AL # MATHEMATICAL BOLD SCRIPT CAPITAL J
1D4DA;AL # MATHEMATICAL BOLD SCRIPT CAPITAL K
1D4DB;AL # MATHEMATICAL BOLD SCRIPT CAPITAL L
1D4DC;AL # MATHEMATICAL BOLD SCRIPT CAPITAL M
1D4DD;AL # MATHEMATICAL BOLD SCRIPT CAPITAL N
1D4DE;AL # MATHEMATICAL BOLD SCRIPT CAPITAL O
1D4DF;AL # MATHEMATICAL BOLD SCRIPT CAPITAL P
1D4E0;AL # MATHEMATICAL BOLD SCRIPT CAPITAL Q
1D4E1;AL # MATHEMATICAL BOLD SCRIPT CAPITAL R
1D4E2;AL # MATHEMATICAL BOLD SCRIPT CAPITAL S
1D4E3;AL # MATHEMATICAL BOLD SCRIPT CAPITAL T
1D4E4;AL # MATHEMATICAL BOLD SCRIPT CAPITAL U
1D4E5;AL # MATHEMATICAL BOLD SCRIPT CAPITAL V
1D4E6;AL # MATHEMATICAL BOLD SCRIPT CAPITAL W
1D4E7;AL # MATHEMATICAL BOLD SCRIPT CAPITAL X
1D4E8;AL # MATHEMATICAL BOLD SCRIPT CAPITAL Y
1D4E9;AL # MATHEMATICAL BOLD SCRIPT CAPITAL Z
1D4EA;AL # MATHEMATICAL BOLD SCRIPT SMALL A
1D4EB;AL # MATHEMATICAL BOLD SCRIPT SMALL B
1D4EC;AL # MATHEMATICAL BOLD SCRIPT SMALL C
1D4ED;AL # MATHEMATICAL BOLD SCRIPT SMALL D
1D4EE;AL # MATHEMATICAL BOLD SCRIPT SMALL E
1D4EF;AL # MATHEMATICAL BOLD SCRIPT SMALL F
1D4F0;AL # MATHEMATICAL BOLD SCRIPT SMALL G
1D4F1;AL # MATHEMATICAL BOLD SCRIPT SMALL H
1D4F2;AL # MATHEMATICAL BOLD SCRIPT SMALL I
1D4F3;AL # MATHEMATICAL BOLD SCRIPT SMALL J
1D4F4;AL # MATHEMATICAL BOLD SCRIPT SMALL K
1D4F5;AL # MATHEMATICAL BOLD SCRIPT SMALL L
1D4F6;AL # MATHEMATICAL BOLD SCRIPT SMALL M
1D4F7;AL # MATHEMATICAL BOLD SCRIPT SMALL N
1D4F8;AL # MATHEMATICAL BOLD SCRIPT SMALL O
1D4F9;AL # MATHEMATICAL BOLD SCRIPT SMALL P
1D4FA;AL # MATHEMATICAL BOLD SCRIPT SMALL Q
1D4FB;AL # MATHEMATICAL BOLD SCRIPT SMALL R
1D4FC;AL # MATHEMATICAL BOLD SCRIPT SMALL S
1D4FD;AL # MATHEMATICAL BOLD SCRIPT SMALL T
1D4FE;AL # MATHEMATICAL BOLD SCRIPT SMALL U
1D4FF;AL # MATHEMATICAL BOLD SCRIPT SMALL V
1D500;AL # MATHEMATICAL BOLD SCRIPT SMALL W
1D501;AL # MATHEMATICAL BOLD SCRIPT SMALL X
1D502;AL # MATHEMATICAL BOLD SCRIPT SMALL Y
1D503;AL # MATHEMATICAL BOLD SCRIPT SMALL Z
1D504;AL # MATHEMATICAL FRAKTUR CAPITAL A
1D505;AL # MATHEMATICAL FRAKTUR CAPITAL B
1D507;AL # MATHEMATICAL FRAKTUR CAPITAL D
1D508;AL # MATHEMATICAL FRAKTUR CAPITAL E
1D509;AL # MATHEMATICAL FRAKTUR CAPITAL F
1D50A;AL # MATHEMATICAL FRAKTUR CAPITAL G
1D50D;AL # MATHEMATICAL FRAKTUR CAPITAL J
1D50E;AL # MATHEMATICAL FRAKTUR CAPITAL K
1D50F;AL # MATHEMATICAL FRAKTUR CAPITAL L
1D510;AL # MATHEMATICAL FRAKTUR CAPITAL M
1D511;AL # MATHEMATICAL FRAKTUR CAPITAL N
1D512;AL # MATHEMATICAL FRAKTUR CAPITAL O
1D513;AL # MATHEMATICAL FRAKTUR CAPITAL P
1D514;AL # MATHEMATICAL FRAKTUR CAPITAL Q
1D516;AL # MATHEMATICAL FRAKTUR CAPITAL S
1D517;AL # MATHEMATICAL FRAKTUR CAPITAL T
1D518;AL # MATHEMATICAL FRAKTUR CAPITAL U
1D519;AL # MATHEMATICAL FRAKTUR CAPITAL V
1D51A;AL # MATHEMATICAL FRAKTUR CAPITAL W
1D51B;AL # MATHEMATICAL FRAKTUR CAPITAL X
1D51C;AL # MATHEMATICAL FRAKTUR CAPITAL Y
1D51E;AL # MATHEMATICAL FRAKTUR SMALL A
1D51F;AL # MATHEMATICAL FRAKTUR SMALL B
1D520;AL # MATHEMATICAL FRAKTUR SMALL C
1D521;AL # MATHEMATICAL FRAKTUR SMALL D
1D522;AL # MATHEMATICAL FRAKTUR SMALL E
1D523;AL # MATHEMATICAL FRAKTUR SMALL F
1D524;AL # MATHEMATICAL FRAKTUR SMALL G
1D525;AL # MATHEMATICAL FRAKTUR SMALL H
1D526;AL # MATHEMATICAL FRAKTUR SMALL I
1D527;AL # MATHEMATICAL FRAKTUR SMALL J
1D528;AL # MATHEMATICAL FRAKTUR SMALL K
1D529;AL # MATHEMATICAL FRAKTUR SMALL L
1D52A;AL # MATHEMATICAL FRAKTUR SMALL M
1D52B;AL # MATHEMATICAL FRAKTUR SMALL N
1D52C;AL # MATHEMATICAL FRAKTUR SMALL O
1D52D;AL # MATHEMATICAL FRAKTUR SMALL P
1D52E;AL # MATHEMATICAL FRAKTUR SMALL Q
1D52F;AL # MATHEMATICAL FRAKTUR SMALL R
1D530;AL # MATHEMATICAL FRAKTUR SMALL S
1D531;AL # MATHEMATICAL FRAKTUR SMALL T
1D532;AL # MATHEMATICAL FRAKTUR SMALL U
1D533;AL # MATHEMATICAL FRAKTUR SMALL V
1D534;AL # MATHEMATICAL FRAKTUR SMALL W
1D535;AL # MATHEMATICAL FRAKTUR SMALL X
1D536;AL # MATHEMATICAL FRAKTUR SMALL Y
1D537;AL # MATHEMATICAL FRAKTUR SMALL Z
1D538;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL A
1D539;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL B
1D53B;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL D
1D53C;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL E
1D53D;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL F
1D53E;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL G
1D540;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL I
1D541;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL J
1D542;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL K
1D543;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL L
1D544;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL M
1D546;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL O
1D54A;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL S
1D54B;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL T
1D54C;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL U
1D54D;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL V
1D54E;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL W
1D54F;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL X
1D550;AL # MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
1D552;AL # MATHEMATICAL DOUBLE-STRUCK SMALL A
1D553;AL # MATHEMATICAL DOUBLE-STRUCK SMALL B
1D554;AL # MATHEMATICAL DOUBLE-STRUCK SMALL C
1D555;AL # MATHEMATICAL DOUBLE-STRUCK SMALL D
1D556;AL # MATHEMATICAL DOUBLE-STRUCK SMALL E
1D557;AL # MATHEMATICAL DOUBLE-STRUCK SMALL F
1D558;AL # MATHEMATICAL DOUBLE-STRUCK SMALL G
1D559;AL # MATHEMATICAL DOUBLE-STRUCK SMALL H
1D55A;AL # MATHEMATICAL DOUBLE-STRUCK SMALL I
1D55B;AL # MATHEMATICAL DOUBLE-STRUCK SMALL J
1D55C;AL # MATHEMATICAL DOUBLE-STRUCK SMALL K
1D55D;AL # MATHEMATICAL DOUBLE-STRUCK SMALL L
1D55E;AL # MATHEMATICAL DOUBLE-STRUCK SMALL M
1D55F;AL # MATHEMATICAL DOUBLE-STRUCK SMALL N
1D560;AL # MATHEMATICAL DOUBLE-STRUCK SMALL O
1D561;AL # MATHEMATICAL DOUBLE-STRUCK SMALL P
1D562;AL # MATHEMATICAL DOUBLE-STRUCK SMALL Q
1D563;AL # MATHEMATICAL DOUBLE-STRUCK SMALL R
1D564;AL # MATHEMATICAL DOUBLE-STRUCK SMALL S
1D565;AL # MATHEMATICAL DOUBLE-STRUCK SMALL T
1D566;AL # MATHEMATICAL DOUBLE-STRUCK SMALL U
1D567;AL # MATHEMATICAL DOUBLE-STRUCK SMALL V
1D568;AL # MATHEMATICAL DOUBLE-STRUCK SMALL W
1D569;AL # MATHEMATICAL DOUBLE-STRUCK SMALL X
1D56A;AL # MATHEMATICAL DOUBLE-STRUCK SMALL Y
1D56B;AL # MATHEMATICAL DOUBLE-STRUCK SMALL Z
1D56C;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL A
1D56D;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL B
1D56E;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL C
1D56F;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL D
1D570;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL E
1D571;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL F
1D572;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL G
1D573;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL H
1D574;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL I
1D575;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL J
1D576;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL K
1D577;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL L
1D578;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL M
1D579;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL N
1D57A;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL O
1D57B;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL P
1D57C;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL Q
1D57D;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL R
1D57E;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL S
1D57F;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL T
1D580;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL U
1D581;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL V
1D582;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL W
1D583;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL X
1D584;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL Y
1D585;AL # MATHEMATICAL BOLD FRAKTUR CAPITAL Z
1D586;AL # MATHEMATICAL BOLD FRAKTUR SMALL A
1D587;AL # MATHEMATICAL BOLD FRAKTUR SMALL B
1D588;AL # MATHEMATICAL BOLD FRAKTUR SMALL C
1D589;AL # MATHEMATICAL BOLD FRAKTUR SMALL D
1D58A;AL # MATHEMATICAL BOLD FRAKTUR SMALL E
1D58B;AL # MATHEMATICAL BOLD FRAKTUR SMALL F
1D58C;AL # MATHEMATICAL BOLD FRAKTUR SMALL G
1D58D;AL # MATHEMATICAL BOLD FRAKTUR SMALL H
1D58E;AL # MATHEMATICAL BOLD FRAKTUR SMALL I
1D58F;AL # MATHEMATICAL BOLD FRAKTUR SMALL J
1D590;AL # MATHEMATICAL BOLD FRAKTUR SMALL K
1D591;AL # MATHEMATICAL BOLD FRAKTUR SMALL L
1D592;AL # MATHEMATICAL BOLD FRAKTUR SMALL M
1D593;AL # MATHEMATICAL BOLD FRAKTUR SMALL N
1D594;AL # MATHEMATICAL BOLD FRAKTUR SMALL O
1D595;AL # MATHEMATICAL BOLD FRAKTUR SMALL P
1D596;AL # MATHEMATICAL BOLD FRAKTUR SMALL Q
1D597;AL # MATHEMATICAL BOLD FRAKTUR SMALL R
1D598;AL # MATHEMATICAL BOLD FRAKTUR SMALL S
1D599;AL # MATHEMATICAL BOLD FRAKTUR SMALL T
1D59A;AL # MATHEMATICAL BOLD FRAKTUR SMALL U
1D59B;AL # MATHEMATICAL BOLD FRAKTUR SMALL V
1D59C;AL # MATHEMATICAL BOLD FRAKTUR SMALL W
1D59D;AL # MATHEMATICAL BOLD FRAKTUR SMALL X
1D59E;AL # MATHEMATICAL BOLD FRAKTUR SMALL Y
1D59F;AL # MATHEMATICAL BOLD FRAKTUR SMALL Z
1D5A0;AL # MATHEMATICAL SANS-SERIF CAPITAL A
1D5A1;AL # MATHEMATICAL SANS-SERIF CAPITAL B
1D5A2;AL # MATHEMATICAL SANS-SERIF CAPITAL C
1D5A3;AL # MATHEMATICAL SANS-SERIF CAPITAL D
1D5A4;AL # MATHEMATICAL SANS-SERIF CAPITAL E
1D5A5;AL # MATHEMATICAL SANS-SERIF CAPITAL F
1D5A6;AL # MATHEMATICAL SANS-SERIF CAPITAL G
1D5A7;AL # MATHEMATICAL SANS-SERIF CAPITAL H
1D5A8;AL # MATHEMATICAL SANS-SERIF CAPITAL I
1D5A9;AL # MATHEMATICAL SANS-SERIF CAPITAL J
1D5AA;AL # MATHEMATICAL SANS-SERIF CAPITAL K
1D5AB;AL # MATHEMATICAL SANS-SERIF CAPITAL L
1D5AC;AL # MATHEMATICAL SANS-SERIF CAPITAL M
1D5AD;AL # MATHEMATICAL SANS-SERIF CAPITAL N
1D5AE;AL # MATHEMATICAL SANS-SERIF CAPITAL O
1D5AF;AL # MATHEMATICAL SANS-SERIF CAPITAL P
1D5B0;AL # MATHEMATICAL SANS-SERIF CAPITAL Q
1D5B1;AL # MATHEMATICAL SANS-SERIF CAPITAL R
1D5B2;AL # MATHEMATICAL SANS-SERIF CAPITAL S
1D5B3;AL # MATHEMATICAL SANS-SERIF CAPITAL T
1D5B4;AL # MATHEMATICAL SANS-SERIF CAPITAL U
1D5B5;AL # MATHEMATICAL SANS-SERIF CAPITAL V
1D5B6;AL # MATHEMATICAL SANS-SERIF CAPITAL W
1D5B7;AL # MATHEMATICAL SANS-SERIF CAPITAL X
1D5B8;AL # MATHEMATICAL SANS-SERIF CAPITAL Y
1D5B9;AL # MATHEMATICAL SANS-SERIF CAPITAL Z
1D5BA;AL # MATHEMATICAL SANS-SERIF SMALL A
1D5BB;AL # MATHEMATICAL SANS-SERIF SMALL B
1D5BC;AL # MATHEMATICAL SANS-SERIF SMALL C
1D5BD;AL # MATHEMATICAL SANS-SERIF SMALL D
1D5BE;AL # MATHEMATICAL SANS-SERIF SMALL E
1D5BF;AL # MATHEMATICAL SANS-SERIF SMALL F
1D5C0;AL # MATHEMATICAL SANS-SERIF SMALL G
1D5C1;AL # MATHEMATICAL SANS-SERIF SMALL H
1D5C2;AL # MATHEMATICAL SANS-SERIF SMALL I
1D5C3;AL # MATHEMATICAL SANS-SERIF SMALL J
1D5C4;AL # MATHEMATICAL SANS-SERIF SMALL K
1D5C5;AL # MATHEMATICAL SANS-SERIF SMALL L
1D5C6;AL # MATHEMATICAL SANS-SERIF SMALL M
1D5C7;AL # MATHEMATICAL SANS-SERIF SMALL N
1D5C8;AL # MATHEMATICAL SANS-SERIF SMALL O
1D5C9;AL # MATHEMATICAL SANS-SERIF SMALL P
1D5CA;AL # MATHEMATICAL SANS-SERIF SMALL Q
1D5CB;AL # MATHEMATICAL SANS-SERIF SMALL R
1D5CC;AL # MATHEMATICAL SANS-SERIF SMALL S
1D5CD;AL # MATHEMATICAL SANS-SERIF SMALL T
1D5CE;AL # MATHEMATICAL SANS-SERIF SMALL U
1D5CF;AL # MATHEMATICAL SANS-SERIF SMALL V
1D5D0;AL # MATHEMATICAL SANS-SERIF SMALL W
1D5D1;AL # MATHEMATICAL SANS-SERIF SMALL X
1D5D2;AL # MATHEMATICAL SANS-SERIF SMALL Y
1D5D3;AL # MATHEMATICAL SANS-SERIF SMALL Z
1D5D4;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL A
1D5D5;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL B
1D5D6;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL C
1D5D7;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL D
1D5D8;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL E
1D5D9;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL F
1D5DA;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL G
1D5DB;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL H
1D5DC;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL I
1D5DD;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL J
1D5DE;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL K
1D5DF;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL L
1D5E0;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL M
1D5E1;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL N
1D5E2;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL O
1D5E3;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL P
1D5E4;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL Q
1D5E5;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL R
1D5E6;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL S
1D5E7;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL T
1D5E8;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL U
1D5E9;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL V
1D5EA;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL W
1D5EB;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL X
1D5EC;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL Y
1D5ED;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL Z
1D5EE;AL # MATHEMATICAL SANS-SERIF BOLD SMALL A
1D5EF;AL # MATHEMATICAL SANS-SERIF BOLD SMALL B
1D5F0;AL # MATHEMATICAL SANS-SERIF BOLD SMALL C
1D5F1;AL # MATHEMATICAL SANS-SERIF BOLD SMALL D
1D5F2;AL # MATHEMATICAL SANS-SERIF BOLD SMALL E
1D5F3;AL # MATHEMATICAL SANS-SERIF BOLD SMALL F
1D5F4;AL # MATHEMATICAL SANS-SERIF BOLD SMALL G
1D5F5;AL # MATHEMATICAL SANS-SERIF BOLD SMALL H
1D5F6;AL # MATHEMATICAL SANS-SERIF BOLD SMALL I
1D5F7;AL # MATHEMATICAL SANS-SERIF BOLD SMALL J
1D5F8;AL # MATHEMATICAL SANS-SERIF BOLD SMALL K
1D5F9;AL # MATHEMATICAL SANS-SERIF BOLD SMALL L
1D5FA;AL # MATHEMATICAL SANS-SERIF BOLD SMALL M
1D5FB;AL # MATHEMATICAL SANS-SERIF BOLD SMALL N
1D5FC;AL # MATHEMATICAL SANS-SERIF BOLD SMALL O
1D5FD;AL # MATHEMATICAL SANS-SERIF BOLD SMALL P
1D5FE;AL # MATHEMATICAL SANS-SERIF BOLD SMALL Q
1D5FF;AL # MATHEMATICAL SANS-SERIF BOLD SMALL R
1D600;AL # MATHEMATICAL SANS-SERIF BOLD SMALL S
1D601;AL # MATHEMATICAL SANS-SERIF BOLD SMALL T
1D602;AL # MATHEMATICAL SANS-SERIF BOLD SMALL U
1D603;AL # MATHEMATICAL SANS-SERIF BOLD SMALL V
1D604;AL # MATHEMATICAL SANS-SERIF BOLD SMALL W
1D605;AL # MATHEMATICAL SANS-SERIF BOLD SMALL X
1D606;AL # MATHEMATICAL SANS-SERIF BOLD SMALL Y
1D607;AL # MATHEMATICAL SANS-SERIF BOLD SMALL Z
1D608;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL A
1D609;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL B
1D60A;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL C
1D60B;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL D
1D60C;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL E
1D60D;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL F
1D60E;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL G
1D60F;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL H
1D610;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL I
1D611;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL J
1D612;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL K
1D613;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL L
1D614;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL M
1D615;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL N
1D616;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL O
1D617;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL P
1D618;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL Q
1D619;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL R
1D61A;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL S
1D61B;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL T
1D61C;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL U
1D61D;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL V
1D61E;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL W
1D61F;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL X
1D620;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL Y
1D621;AL # MATHEMATICAL SANS-SERIF ITALIC CAPITAL Z
1D622;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL A
1D623;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL B
1D624;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL C
1D625;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL D
1D626;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL E
1D627;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL F
1D628;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL G
1D629;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL H
1D62A;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL I
1D62B;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL J
1D62C;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL K
1D62D;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL L
1D62E;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL M
1D62F;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL N
1D630;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL O
1D631;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL P
1D632;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL Q
1D633;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL R
1D634;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL S
1D635;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL T
1D636;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL U
1D637;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL V
1D638;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL W
1D639;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL X
1D63A;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL Y
1D63B;AL # MATHEMATICAL SANS-SERIF ITALIC SMALL Z
1D63C;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL A
1D63D;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL B
1D63E;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL C
1D63F;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL D
1D640;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E
1D641;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL F
1D642;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL G
1D643;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL H
1D644;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL I
1D645;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL J
1D646;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL K
1D647;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL L
1D648;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL M
1D649;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL N
1D64A;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL O
1D64B;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL P
1D64C;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Q
1D64D;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL R
1D64E;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL S
1D64F;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL T
1D650;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL U
1D651;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL V
1D652;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL W
1D653;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL X
1D654;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Y
1D655;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Z
1D656;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A
1D657;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL B
1D658;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL C
1D659;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL D
1D65A;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E
1D65B;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL F
1D65C;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL G
1D65D;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL H
1D65E;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I
1D65F;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J
1D660;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL K
1D661;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL L
1D662;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL M
1D663;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL N
1D664;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL O
1D665;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL P
1D666;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Q
1D667;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL R
1D668;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL S
1D669;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL T
1D66A;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL U
1D66B;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL V
1D66C;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL W
1D66D;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL X
1D66E;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Y
1D66F;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z
1D670;AL # MATHEMATICAL MONOSPACE CAPITAL A
1D671;AL # MATHEMATICAL MONOSPACE CAPITAL B
1D672;AL # MATHEMATICAL MONOSPACE CAPITAL C
1D673;AL # MATHEMATICAL MONOSPACE CAPITAL D
1D674;AL # MATHEMATICAL MONOSPACE CAPITAL E
1D675;AL # MATHEMATICAL MONOSPACE CAPITAL F
1D676;AL # MATHEMATICAL MONOSPACE CAPITAL G
1D677;AL # MATHEMATICAL MONOSPACE CAPITAL H
1D678;AL # MATHEMATICAL MONOSPACE CAPITAL I
1D679;AL # MATHEMATICAL MONOSPACE CAPITAL J
1D67A;AL # MATHEMATICAL MONOSPACE CAPITAL K
1D67B;AL # MATHEMATICAL MONOSPACE CAPITAL L
1D67C;AL # MATHEMATICAL MONOSPACE CAPITAL M
1D67D;AL # MATHEMATICAL MONOSPACE CAPITAL N
1D67E;AL # MATHEMATICAL MONOSPACE CAPITAL O
1D67F;AL # MATHEMATICAL MONOSPACE CAPITAL P
1D680;AL # MATHEMATICAL MONOSPACE CAPITAL Q
1D681;AL # MATHEMATICAL MONOSPACE CAPITAL R
1D682;AL # MATHEMATICAL MONOSPACE CAPITAL S
1D683;AL # MATHEMATICAL MONOSPACE CAPITAL T
1D684;AL # MATHEMATICAL MONOSPACE CAPITAL U
1D685;AL # MATHEMATICAL MONOSPACE CAPITAL V
1D686;AL # MATHEMATICAL MONOSPACE CAPITAL W
1D687;AL # MATHEMATICAL MONOSPACE CAPITAL X
1D688;AL # MATHEMATICAL MONOSPACE CAPITAL Y
1D689;AL # MATHEMATICAL MONOSPACE CAPITAL Z
1D68A;AL # MATHEMATICAL MONOSPACE SMALL A
1D68B;AL # MATHEMATICAL MONOSPACE SMALL B
1D68C;AL # MATHEMATICAL MONOSPACE SMALL C
1D68D;AL # MATHEMATICAL MONOSPACE SMALL D
1D68E;AL # MATHEMATICAL MONOSPACE SMALL E
1D68F;AL # MATHEMATICAL MONOSPACE SMALL F
1D690;AL # MATHEMATICAL MONOSPACE SMALL G
1D691;AL # MATHEMATICAL MONOSPACE SMALL H
1D692;AL # MATHEMATICAL MONOSPACE SMALL I
1D693;AL # MATHEMATICAL MONOSPACE SMALL J
1D694;AL # MATHEMATICAL MONOSPACE SMALL K
1D695;AL # MATHEMATICAL MONOSPACE SMALL L
1D696;AL # MATHEMATICAL MONOSPACE SMALL M
1D697;AL # MATHEMATICAL MONOSPACE SMALL N
1D698;AL # MATHEMATICAL MONOSPACE SMALL O
1D699;AL # MATHEMATICAL MONOSPACE SMALL P
1D69A;AL # MATHEMATICAL MONOSPACE SMALL Q
1D69B;AL # MATHEMATICAL MONOSPACE SMALL R
1D69C;AL # MATHEMATICAL MONOSPACE SMALL S
1D69D;AL # MATHEMATICAL MONOSPACE SMALL T
1D69E;AL # MATHEMATICAL MONOSPACE SMALL U
1D69F;AL # MATHEMATICAL MONOSPACE SMALL V
1D6A0;AL # MATHEMATICAL MONOSPACE SMALL W
1D6A1;AL # MATHEMATICAL MONOSPACE SMALL X
1D6A2;AL # MATHEMATICAL MONOSPACE SMALL Y
1D6A3;AL # MATHEMATICAL MONOSPACE SMALL Z
1D6A4;AL # MATHEMATICAL ITALIC SMALL DOTLESS I
1D6A5;AL # MATHEMATICAL ITALIC SMALL DOTLESS J
1D6A8;AL # MATHEMATICAL BOLD CAPITAL ALPHA
1D6A9;AL # MATHEMATICAL BOLD CAPITAL BETA
1D6AA;AL # MATHEMATICAL BOLD CAPITAL GAMMA
1D6AB;AL # MATHEMATICAL BOLD CAPITAL DELTA
1D6AC;AL # MATHEMATICAL BOLD CAPITAL EPSILON
1D6AD;AL # MATHEMATICAL BOLD CAPITAL ZETA
1D6AE;AL # MATHEMATICAL BOLD CAPITAL ETA
1D6AF;AL # MATHEMATICAL BOLD CAPITAL THETA
1D6B0;AL # MATHEMATICAL BOLD CAPITAL IOTA
1D6B1;AL # MATHEMATICAL BOLD CAPITAL KAPPA
1D6B2;AL # MATHEMATICAL BOLD CAPITAL LAMDA
1D6B3;AL # MATHEMATICAL BOLD CAPITAL MU
1D6B4;AL # MATHEMATICAL BOLD CAPITAL NU
1D6B5;AL # MATHEMATICAL BOLD CAPITAL XI
1D6B6;AL # MATHEMATICAL BOLD CAPITAL OMICRON
1D6B7;AL # MATHEMATICAL BOLD CAPITAL PI
1D6B8;AL # MATHEMATICAL BOLD CAPITAL RHO
1D6B9;AL # MATHEMATICAL BOLD CAPITAL THETA SYMBOL
1D6BA;AL # MATHEMATICAL BOLD CAPITAL SIGMA
1D6BB;AL # MATHEMATICAL BOLD CAPITAL TAU
1D6BC;AL # MATHEMATICAL BOLD CAPITAL UPSILON
1D6BD;AL # MATHEMATICAL BOLD CAPITAL PHI
1D6BE;AL # MATHEMATICAL BOLD CAPITAL CHI
1D6BF;AL # MATHEMATICAL BOLD CAPITAL PSI
1D6C0;AL # MATHEMATICAL BOLD CAPITAL OMEGA
1D6C1;AL # MATHEMATICAL BOLD NABLA
1D6C2;AL # MATHEMATICAL BOLD SMALL ALPHA
1D6C3;AL # MATHEMATICAL BOLD SMALL BETA
1D6C4;AL # MATHEMATICAL BOLD SMALL GAMMA
1D6C5;AL # MATHEMATICAL BOLD SMALL DELTA
1D6C6;AL # MATHEMATICAL BOLD SMALL EPSILON
1D6C7;AL # MATHEMATICAL BOLD SMALL ZETA
1D6C8;AL # MATHEMATICAL BOLD SMALL ETA
1D6C9;AL # MATHEMATICAL BOLD SMALL THETA
1D6CA;AL # MATHEMATICAL BOLD SMALL IOTA
1D6CB;AL # MATHEMATICAL BOLD SMALL KAPPA
1D6CC;AL # MATHEMATICAL BOLD SMALL LAMDA
1D6CD;AL # MATHEMATICAL BOLD SMALL MU
1D6CE;AL # MATHEMATICAL BOLD SMALL NU
1D6CF;AL # MATHEMATICAL BOLD SMALL XI
1D6D0;AL # MATHEMATICAL BOLD SMALL OMICRON
1D6D1;AL # MATHEMATICAL BOLD SMALL PI
1D6D2;AL # MATHEMATICAL BOLD SMALL RHO
1D6D3;AL # MATHEMATICAL BOLD SMALL FINAL SIGMA
1D6D4;AL # MATHEMATICAL BOLD SMALL SIGMA
1D6D5;AL # MATHEMATICAL BOLD SMALL TAU
1D6D6;AL # MATHEMATICAL BOLD SMALL UPSILON
1D6D7;AL # MATHEMATICAL BOLD SMALL PHI
1D6D8;AL # MATHEMATICAL BOLD SMALL CHI
1D6D9;AL # MATHEMATICAL BOLD SMALL PSI
1D6DA;AL # MATHEMATICAL BOLD SMALL OMEGA
1D6DB;AL # MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
1D6DC;AL # MATHEMATICAL BOLD EPSILON SYMBOL
1D6DD;AL # MATHEMATICAL BOLD THETA SYMBOL
1D6DE;AL # MATHEMATICAL BOLD KAPPA SYMBOL
1D6DF;AL # MATHEMATICAL BOLD PHI SYMBOL
1D6E0;AL # MATHEMATICAL BOLD RHO SYMBOL
1D6E1;AL # MATHEMATICAL BOLD PI SYMBOL
1D6E2;AL # MATHEMATICAL ITALIC CAPITAL ALPHA
1D6E3;AL # MATHEMATICAL ITALIC CAPITAL BETA
1D6E4;AL # MATHEMATICAL ITALIC CAPITAL GAMMA
1D6E5;AL # MATHEMATICAL ITALIC CAPITAL DELTA
1D6E6;AL # MATHEMATICAL ITALIC CAPITAL EPSILON
1D6E7;AL # MATHEMATICAL ITALIC CAPITAL ZETA
1D6E8;AL # MATHEMATICAL ITALIC CAPITAL ETA
1D6E9;AL # MATHEMATICAL ITALIC CAPITAL THETA
1D6EA;AL # MATHEMATICAL ITALIC CAPITAL IOTA
1D6EB;AL # MATHEMATICAL ITALIC CAPITAL KAPPA
1D6EC;AL # MATHEMATICAL ITALIC CAPITAL LAMDA
1D6ED;AL # MATHEMATICAL ITALIC CAPITAL MU
1D6EE;AL # MATHEMATICAL ITALIC CAPITAL NU
1D6EF;AL # MATHEMATICAL ITALIC CAPITAL XI
1D6F0;AL # MATHEMATICAL ITALIC CAPITAL OMICRON
1D6F1;AL # MATHEMATICAL ITALIC CAPITAL PI
1D6F2;AL # MATHEMATICAL ITALIC CAPITAL RHO
1D6F3;AL # MATHEMATICAL ITALIC CAPITAL THETA SYMBOL
1D6F4;AL # MATHEMATICAL ITALIC CAPITAL SIGMA
1D6F5;AL # MATHEMATICAL ITALIC CAPITAL TAU
1D6F6;AL # MATHEMATICAL ITALIC CAPITAL UPSILON
1D6F7;AL # MATHEMATICAL ITALIC CAPITAL PHI
1D6F8;AL # MATHEMATICAL ITALIC CAPITAL CHI
1D6F9;AL # MATHEMATICAL ITALIC CAPITAL PSI
1D6FA;AL # MATHEMATICAL ITALIC CAPITAL OMEGA
1D6FB;AL # MATHEMATICAL ITALIC NABLA
1D6FC;AL # MATHEMATICAL ITALIC SMALL ALPHA
1D6FD;AL # MATHEMATICAL ITALIC SMALL BETA
1D6FE;AL # MATHEMATICAL ITALIC SMALL GAMMA
1D6FF;AL # MATHEMATICAL ITALIC SMALL DELTA
1D700;AL # MATHEMATICAL ITALIC SMALL EPSILON
1D701;AL # MATHEMATICAL ITALIC SMALL ZETA
1D702;AL # MATHEMATICAL ITALIC SMALL ETA
1D703;AL # MATHEMATICAL ITALIC SMALL THETA
1D704;AL # MATHEMATICAL ITALIC SMALL IOTA
1D705;AL # MATHEMATICAL ITALIC SMALL KAPPA
1D706;AL # MATHEMATICAL ITALIC SMALL LAMDA
1D707;AL # MATHEMATICAL ITALIC SMALL MU
1D708;AL # MATHEMATICAL ITALIC SMALL NU
1D709;AL # MATHEMATICAL ITALIC SMALL XI
1D70A;AL # MATHEMATICAL ITALIC SMALL OMICRON
1D70B;AL # MATHEMATICAL ITALIC SMALL PI
1D70C;AL # MATHEMATICAL ITALIC SMALL RHO
1D70D;AL # MATHEMATICAL ITALIC SMALL FINAL SIGMA
1D70E;AL # MATHEMATICAL ITALIC SMALL SIGMA
1D70F;AL # MATHEMATICAL ITALIC SMALL TAU
1D710;AL # MATHEMATICAL ITALIC SMALL UPSILON
1D711;AL # MATHEMATICAL ITALIC SMALL PHI
1D712;AL # MATHEMATICAL ITALIC SMALL CHI
1D713;AL # MATHEMATICAL ITALIC SMALL PSI
1D714;AL # MATHEMATICAL ITALIC SMALL OMEGA
1D715;AL # MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
1D716;AL # MATHEMATICAL ITALIC EPSILON SYMBOL
1D717;AL # MATHEMATICAL ITALIC THETA SYMBOL
1D718;AL # MATHEMATICAL ITALIC KAPPA SYMBOL
1D719;AL # MATHEMATICAL ITALIC PHI SYMBOL
1D71A;AL # MATHEMATICAL ITALIC RHO SYMBOL
1D71B;AL # MATHEMATICAL ITALIC PI SYMBOL
1D71C;AL # MATHEMATICAL BOLD ITALIC CAPITAL ALPHA
1D71D;AL # MATHEMATICAL BOLD ITALIC CAPITAL BETA
1D71E;AL # MATHEMATICAL BOLD ITALIC CAPITAL GAMMA
1D71F;AL # MATHEMATICAL BOLD ITALIC CAPITAL DELTA
1D720;AL # MATHEMATICAL BOLD ITALIC CAPITAL EPSILON
1D721;AL # MATHEMATICAL BOLD ITALIC CAPITAL ZETA
1D722;AL # MATHEMATICAL BOLD ITALIC CAPITAL ETA
1D723;AL # MATHEMATICAL BOLD ITALIC CAPITAL THETA
1D724;AL # MATHEMATICAL BOLD ITALIC CAPITAL IOTA
1D725;AL # MATHEMATICAL BOLD ITALIC CAPITAL KAPPA
1D726;AL # MATHEMATICAL BOLD ITALIC CAPITAL LAMDA
1D727;AL # MATHEMATICAL BOLD ITALIC CAPITAL MU
1D728;AL # MATHEMATICAL BOLD ITALIC CAPITAL NU
1D729;AL # MATHEMATICAL BOLD ITALIC CAPITAL XI
1D72A;AL # MATHEMATICAL BOLD ITALIC CAPITAL OMICRON
1D72B;AL # MATHEMATICAL BOLD ITALIC CAPITAL PI
1D72C;AL # MATHEMATICAL BOLD ITALIC CAPITAL RHO
1D72D;AL # MATHEMATICAL BOLD ITALIC CAPITAL THETA SYMBOL
1D72E;AL # MATHEMATICAL BOLD ITALIC CAPITAL SIGMA
1D72F;AL # MATHEMATICAL BOLD ITALIC CAPITAL TAU
1D730;AL # MATHEMATICAL BOLD ITALIC CAPITAL UPSILON
1D731;AL # MATHEMATICAL BOLD ITALIC CAPITAL PHI
1D732;AL # MATHEMATICAL BOLD ITALIC CAPITAL CHI
1D733;AL # MATHEMATICAL BOLD ITALIC CAPITAL PSI
1D734;AL # MATHEMATICAL BOLD ITALIC CAPITAL OMEGA
1D735;AL # MATHEMATICAL BOLD ITALIC NABLA
1D736;AL # MATHEMATICAL BOLD ITALIC SMALL ALPHA
1D737;AL # MATHEMATICAL BOLD ITALIC SMALL BETA
1D738;AL # MATHEMATICAL BOLD ITALIC SMALL GAMMA
1D739;AL # MATHEMATICAL BOLD ITALIC SMALL DELTA
1D73A;AL # MATHEMATICAL BOLD ITALIC SMALL EPSILON
1D73B;AL # MATHEMATICAL BOLD ITALIC SMALL ZETA
1D73C;AL # MATHEMATICAL BOLD ITALIC SMALL ETA
1D73D;AL # MATHEMATICAL BOLD ITALIC SMALL THETA
1D73E;AL # MATHEMATICAL BOLD ITALIC SMALL IOTA
1D73F;AL # MATHEMATICAL BOLD ITALIC SMALL KAPPA
1D740;AL # MATHEMATICAL BOLD ITALIC SMALL LAMDA
1D741;AL # MATHEMATICAL BOLD ITALIC SMALL MU
1D742;AL # MATHEMATICAL BOLD ITALIC SMALL NU
1D743;AL # MATHEMATICAL BOLD ITALIC SMALL XI
1D744;AL # MATHEMATICAL BOLD ITALIC SMALL OMICRON
1D745;AL # MATHEMATICAL BOLD ITALIC SMALL PI
1D746;AL # MATHEMATICAL BOLD ITALIC SMALL RHO
1D747;AL # MATHEMATICAL BOLD ITALIC SMALL FINAL SIGMA
1D748;AL # MATHEMATICAL BOLD ITALIC SMALL SIGMA
1D749;AL # MATHEMATICAL BOLD ITALIC SMALL TAU
1D74A;AL # MATHEMATICAL BOLD ITALIC SMALL UPSILON
1D74B;AL # MATHEMATICAL BOLD ITALIC SMALL PHI
1D74C;AL # MATHEMATICAL BOLD ITALIC SMALL CHI
1D74D;AL # MATHEMATICAL BOLD ITALIC SMALL PSI
1D74E;AL # MATHEMATICAL BOLD ITALIC SMALL OMEGA
1D74F;AL # MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
1D750;AL # MATHEMATICAL BOLD ITALIC EPSILON SYMBOL
1D751;AL # MATHEMATICAL BOLD ITALIC THETA SYMBOL
1D752;AL # MATHEMATICAL BOLD ITALIC KAPPA SYMBOL
1D753;AL # MATHEMATICAL BOLD ITALIC PHI SYMBOL
1D754;AL # MATHEMATICAL BOLD ITALIC RHO SYMBOL
1D755;AL # MATHEMATICAL BOLD ITALIC PI SYMBOL
1D756;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA
1D757;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL BETA
1D758;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL GAMMA
1D759;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL DELTA
1D75A;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL EPSILON
1D75B;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL ZETA
1D75C;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL ETA
1D75D;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA
1D75E;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL IOTA
1D75F;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL KAPPA
1D760;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL LAMDA
1D761;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL MU
1D762;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL NU
1D763;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL XI
1D764;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL OMICRON
1D765;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL PI
1D766;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL RHO
1D767;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA SYMBOL
1D768;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL SIGMA
1D769;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL TAU
1D76A;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL UPSILON
1D76B;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL PHI
1D76C;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI
1D76D;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI
1D76E;AL # MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
1D76F;AL # MATHEMATICAL SANS-SERIF BOLD NABLA
1D770;AL # MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA
1D771;AL # MATHEMATICAL SANS-SERIF BOLD SMALL BETA
1D772;AL # MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA
1D773;AL # MATHEMATICAL SANS-SERIF BOLD SMALL DELTA
1D774;AL # MATHEMATICAL SANS-SERIF BOLD SMALL EPSILON
1D775;AL # MATHEMATICAL SANS-SERIF BOLD SMALL ZETA
1D776;AL # MATHEMATICAL SANS-SERIF BOLD SMALL ETA
1D777;AL # MATHEMATICAL SANS-SERIF BOLD SMALL THETA
1D778;AL # MATHEMATICAL SANS-SERIF BOLD SMALL IOTA
1D779;AL # MATHEMATICAL SANS-SERIF BOLD SMALL KAPPA
1D77A;AL # MATHEMATICAL SANS-SERIF BOLD SMALL LAMDA
1D77B;AL # MATHEMATICAL SANS-SERIF BOLD SMALL MU
1D77C;AL # MATHEMATICAL SANS-SERIF BOLD SMALL NU
1D77D;AL # MATHEMATICAL SANS-SERIF BOLD SMALL XI
1D77E;AL # MATHEMATICAL SANS-SERIF BOLD SMALL OMICRON
1D77F;AL # MATHEMATICAL SANS-SERIF BOLD SMALL PI
1D780;AL # MATHEMATICAL SANS-SERIF BOLD SMALL RHO
1D781;AL # MATHEMATICAL SANS-SERIF BOLD SMALL FINAL SIGMA
1D782;AL # MATHEMATICAL SANS-SERIF BOLD SMALL SIGMA
1D783;AL # MATHEMATICAL SANS-SERIF BOLD SMALL TAU
1D784;AL # MATHEMATICAL SANS-SERIF BOLD SMALL UPSILON
1D785;AL # MATHEMATICAL SANS-SERIF BOLD SMALL PHI
1D786;AL # MATHEMATICAL SANS-SERIF BOLD SMALL CHI
1D787;AL # MATHEMATICAL SANS-SERIF BOLD SMALL PSI
1D788;AL # MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
1D789;AL # MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
1D78A;AL # MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL
1D78B;AL # MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL
1D78C;AL # MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL
1D78D;AL # MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL
1D78E;AL # MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL
1D78F;AL # MATHEMATICAL SANS-SERIF BOLD PI SYMBOL
1D790;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA
1D791;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA
1D792;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA
1D793;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL DELTA
1D794;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL EPSILON
1D795;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ZETA
1D796;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ETA
1D797;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA
1D798;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL IOTA
1D799;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL KAPPA
1D79A;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL LAMDA
1D79B;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL MU
1D79C;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL NU
1D79D;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL XI
1D79E;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMICRON
1D79F;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PI
1D7A0;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL RHO
1D7A1;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA SYMBOL
1D7A2;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL SIGMA
1D7A3;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL TAU
1D7A4;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL UPSILON
1D7A5;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PHI
1D7A6;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI
1D7A7;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI
1D7A8;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
1D7A9;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
1D7AA;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA
1D7AB;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA
1D7AC;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA
1D7AD;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL DELTA
1D7AE;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL EPSILON
1D7AF;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ZETA
1D7B0;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ETA
1D7B1;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL THETA
1D7B2;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL IOTA
1D7B3;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL KAPPA
1D7B4;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL LAMDA
1D7B5;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL MU
1D7B6;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL NU
1D7B7;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL XI
1D7B8;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMICRON
1D7B9;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PI
1D7BA;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL RHO
1D7BB;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL FINAL SIGMA
1D7BC;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL SIGMA
1D7BD;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL TAU
1D7BE;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL UPSILON
1D7BF;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PHI
1D7C0;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI
1D7C1;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI
1D7C2;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
1D7C3;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
1D7C4;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL
1D7C5;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL
1D7C6;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL
1D7C7;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL
1D7C8;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL
1D7C9;AL # MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL
1D7CE;NU # MATHEMATICAL BOLD DIGIT ZERO
1D7CF;NU # MATHEMATICAL BOLD DIGIT ONE
1D7D0;NU # MATHEMATICAL BOLD DIGIT TWO
1D7D1;NU # MATHEMATICAL BOLD DIGIT THREE
1D7D2;NU # MATHEMATICAL BOLD DIGIT FOUR
1D7D3;NU # MATHEMATICAL BOLD DIGIT FIVE
1D7D4;NU # MATHEMATICAL BOLD DIGIT SIX
1D7D5;NU # MATHEMATICAL BOLD DIGIT SEVEN
1D7D6;NU # MATHEMATICAL BOLD DIGIT EIGHT
1D7D7;NU # MATHEMATICAL BOLD DIGIT NINE
1D7D8;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO
1D7D9;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT ONE
1D7DA;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT TWO
1D7DB;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT THREE
1D7DC;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR
1D7DD;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE
1D7DE;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT SIX
1D7DF;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN
1D7E0;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT
1D7E1;NU # MATHEMATICAL DOUBLE-STRUCK DIGIT NINE
1D7E2;NU # MATHEMATICAL SANS-SERIF DIGIT ZERO
1D7E3;NU # MATHEMATICAL SANS-SERIF DIGIT ONE
1D7E4;NU # MATHEMATICAL SANS-SERIF DIGIT TWO
1D7E5;NU # MATHEMATICAL SANS-SERIF DIGIT THREE
1D7E6;NU # MATHEMATICAL SANS-SERIF DIGIT FOUR
1D7E7;NU # MATHEMATICAL SANS-SERIF DIGIT FIVE
1D7E8;NU # MATHEMATICAL SANS-SERIF DIGIT SIX
1D7E9;NU # MATHEMATICAL SANS-SERIF DIGIT SEVEN
1D7EA;NU # MATHEMATICAL SANS-SERIF DIGIT EIGHT
1D7EB;NU # MATHEMATICAL SANS-SERIF DIGIT NINE
1D7EC;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO
1D7ED;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT ONE
1D7EE;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT TWO
1D7EF;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT THREE
1D7F0;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR
1D7F1;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE
1D7F2;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT SIX
1D7F3;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN
1D7F4;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT
1D7F5;NU # MATHEMATICAL SANS-SERIF BOLD DIGIT NINE
1D7F6;NU # MATHEMATICAL MONOSPACE DIGIT ZERO
1D7F7;NU # MATHEMATICAL MONOSPACE DIGIT ONE
1D7F8;NU # MATHEMATICAL MONOSPACE DIGIT TWO
1D7F9;NU # MATHEMATICAL MONOSPACE DIGIT THREE
1D7FA;NU # MATHEMATICAL MONOSPACE DIGIT FOUR
1D7FB;NU # MATHEMATICAL MONOSPACE DIGIT FIVE
1D7FC;NU # MATHEMATICAL MONOSPACE DIGIT SIX
1D7FD;NU # MATHEMATICAL MONOSPACE DIGIT SEVEN
1D7FE;NU # MATHEMATICAL MONOSPACE DIGIT EIGHT
1D7FF;NU # MATHEMATICAL MONOSPACE DIGIT NINE
20000..2A6D6;ID # <CJK Ideograph Extension B, First>..<CJK Ideograph Extension B, Last>
2F800;ID # CJK COMPATIBILITY IDEOGRAPH-2F800
2F801;ID # CJK COMPATIBILITY IDEOGRAPH-2F801
2F802;ID # CJK COMPATIBILITY IDEOGRAPH-2F802
2F803;ID # CJK COMPATIBILITY IDEOGRAPH-2F803
2F804;ID # CJK COMPATIBILITY IDEOGRAPH-2F804
2F805;ID # CJK COMPATIBILITY IDEOGRAPH-2F805
2F806;ID # CJK COMPATIBILITY IDEOGRAPH-2F806
2F807;ID # CJK COMPATIBILITY IDEOGRAPH-2F807
2F808;ID # CJK COMPATIBILITY IDEOGRAPH-2F808
2F809;ID # CJK COMPATIBILITY IDEOGRAPH-2F809
2F80A;ID # CJK COMPATIBILITY IDEOGRAPH-2F80A
2F80B;ID # CJK COMPATIBILITY IDEOGRAPH-2F80B
2F80C;ID # CJK COMPATIBILITY IDEOGRAPH-2F80C
2F80D;ID # CJK COMPATIBILITY IDEOGRAPH-2F80D
2F80E;ID # CJK COMPATIBILITY IDEOGRAPH-2F80E
2F80F;ID # CJK COMPATIBILITY IDEOGRAPH-2F80F
2F810;ID # CJK COMPATIBILITY IDEOGRAPH-2F810
2F811;ID # CJK COMPATIBILITY IDEOGRAPH-2F811
2F812;ID # CJK COMPATIBILITY IDEOGRAPH-2F812
2F813;ID # CJK COMPATIBILITY IDEOGRAPH-2F813
2F814;ID # CJK COMPATIBILITY IDEOGRAPH-2F814
2F815;ID # CJK COMPATIBILITY IDEOGRAPH-2F815
2F816;ID # CJK COMPATIBILITY IDEOGRAPH-2F816
2F817;ID # CJK COMPATIBILITY IDEOGRAPH-2F817
2F818;ID # CJK COMPATIBILITY IDEOGRAPH-2F818
2F819;ID # CJK COMPATIBILITY IDEOGRAPH-2F819
2F81A;ID # CJK COMPATIBILITY IDEOGRAPH-2F81A
2F81B;ID # CJK COMPATIBILITY IDEOGRAPH-2F81B
2F81C;ID # CJK COMPATIBILITY IDEOGRAPH-2F81C
2F81D;ID # CJK COMPATIBILITY IDEOGRAPH-2F81D
2F81E;ID # CJK COMPATIBILITY IDEOGRAPH-2F81E
2F81F;ID # CJK COMPATIBILITY IDEOGRAPH-2F81F
2F820;ID # CJK COMPATIBILITY IDEOGRAPH-2F820
2F821;ID # CJK COMPATIBILITY IDEOGRAPH-2F821
2F822;ID # CJK COMPATIBILITY IDEOGRAPH-2F822
2F823;ID # CJK COMPATIBILITY IDEOGRAPH-2F823
2F824;ID # CJK COMPATIBILITY IDEOGRAPH-2F824
2F825;ID # CJK COMPATIBILITY IDEOGRAPH-2F825
2F826;ID # CJK COMPATIBILITY IDEOGRAPH-2F826
2F827;ID # CJK COMPATIBILITY IDEOGRAPH-2F827
2F828;ID # CJK COMPATIBILITY IDEOGRAPH-2F828
2F829;ID # CJK COMPATIBILITY IDEOGRAPH-2F829
2F82A;ID # CJK COMPATIBILITY IDEOGRAPH-2F82A
2F82B;ID # CJK COMPATIBILITY IDEOGRAPH-2F82B
2F82C;ID # CJK COMPATIBILITY IDEOGRAPH-2F82C
2F82D;ID # CJK COMPATIBILITY IDEOGRAPH-2F82D
2F82E;ID # CJK COMPATIBILITY IDEOGRAPH-2F82E
2F82F;ID # CJK COMPATIBILITY IDEOGRAPH-2F82F
2F830;ID # CJK COMPATIBILITY IDEOGRAPH-2F830
2F831;ID # CJK COMPATIBILITY IDEOGRAPH-2F831
2F832;ID # CJK COMPATIBILITY IDEOGRAPH-2F832
2F833;ID # CJK COMPATIBILITY IDEOGRAPH-2F833
2F834;ID # CJK COMPATIBILITY IDEOGRAPH-2F834
2F835;ID # CJK COMPATIBILITY IDEOGRAPH-2F835
2F836;ID # CJK COMPATIBILITY IDEOGRAPH-2F836
2F837;ID # CJK COMPATIBILITY IDEOGRAPH-2F837
2F838;ID # CJK COMPATIBILITY IDEOGRAPH-2F838
2F839;ID # CJK COMPATIBILITY IDEOGRAPH-2F839
2F83A;ID # CJK COMPATIBILITY IDEOGRAPH-2F83A
2F83B;ID # CJK COMPATIBILITY IDEOGRAPH-2F83B
2F83C;ID # CJK COMPATIBILITY IDEOGRAPH-2F83C
2F83D;ID # CJK COMPATIBILITY IDEOGRAPH-2F83D
2F83E;ID # CJK COMPATIBILITY IDEOGRAPH-2F83E
2F83F;ID # CJK COMPATIBILITY IDEOGRAPH-2F83F
2F840;ID # CJK COMPATIBILITY IDEOGRAPH-2F840
2F841;ID # CJK COMPATIBILITY IDEOGRAPH-2F841
2F842;ID # CJK COMPATIBILITY IDEOGRAPH-2F842
2F843;ID # CJK COMPATIBILITY IDEOGRAPH-2F843
2F844;ID # CJK COMPATIBILITY IDEOGRAPH-2F844
2F845;ID # CJK COMPATIBILITY IDEOGRAPH-2F845
2F846;ID # CJK COMPATIBILITY IDEOGRAPH-2F846
2F847;ID # CJK COMPATIBILITY IDEOGRAPH-2F847
2F848;ID # CJK COMPATIBILITY IDEOGRAPH-2F848
2F849;ID # CJK COMPATIBILITY IDEOGRAPH-2F849
2F84A;ID # CJK COMPATIBILITY IDEOGRAPH-2F84A
2F84B;ID # CJK COMPATIBILITY IDEOGRAPH-2F84B
2F84C;ID # CJK COMPATIBILITY IDEOGRAPH-2F84C
2F84D;ID # CJK COMPATIBILITY IDEOGRAPH-2F84D
2F84E;ID # CJK COMPATIBILITY IDEOGRAPH-2F84E
2F84F;ID # CJK COMPATIBILITY IDEOGRAPH-2F84F
2F850;ID # CJK COMPATIBILITY IDEOGRAPH-2F850
2F851;ID # CJK COMPATIBILITY IDEOGRAPH-2F851
2F852;ID # CJK COMPATIBILITY IDEOGRAPH-2F852
2F853;ID # CJK COMPATIBILITY IDEOGRAPH-2F853
2F854;ID # CJK COMPATIBILITY IDEOGRAPH-2F854
2F855;ID # CJK COMPATIBILITY IDEOGRAPH-2F855
2F856;ID # CJK COMPATIBILITY IDEOGRAPH-2F856
2F857;ID # CJK COMPATIBILITY IDEOGRAPH-2F857
2F858;ID # CJK COMPATIBILITY IDEOGRAPH-2F858
2F859;ID # CJK COMPATIBILITY IDEOGRAPH-2F859
2F85A;ID # CJK COMPATIBILITY IDEOGRAPH-2F85A
2F85B;ID # CJK COMPATIBILITY IDEOGRAPH-2F85B
2F85C;ID # CJK COMPATIBILITY IDEOGRAPH-2F85C
2F85D;ID # CJK COMPATIBILITY IDEOGRAPH-2F85D
2F85E;ID # CJK COMPATIBILITY IDEOGRAPH-2F85E
2F85F;ID # CJK COMPATIBILITY IDEOGRAPH-2F85F
2F860;ID # CJK COMPATIBILITY IDEOGRAPH-2F860
2F861;ID # CJK COMPATIBILITY IDEOGRAPH-2F861
2F862;ID # CJK COMPATIBILITY IDEOGRAPH-2F862
2F863;ID # CJK COMPATIBILITY IDEOGRAPH-2F863
2F864;ID # CJK COMPATIBILITY IDEOGRAPH-2F864
2F865;ID # CJK COMPATIBILITY IDEOGRAPH-2F865
2F866;ID # CJK COMPATIBILITY IDEOGRAPH-2F866
2F867;ID # CJK COMPATIBILITY IDEOGRAPH-2F867
2F868;ID # CJK COMPATIBILITY IDEOGRAPH-2F868
2F869;ID # CJK COMPATIBILITY IDEOGRAPH-2F869
2F86A;ID # CJK COMPATIBILITY IDEOGRAPH-2F86A
2F86B;ID # CJK COMPATIBILITY IDEOGRAPH-2F86B
2F86C;ID # CJK COMPATIBILITY IDEOGRAPH-2F86C
2F86D;ID # CJK COMPATIBILITY IDEOGRAPH-2F86D
2F86E;ID # CJK COMPATIBILITY IDEOGRAPH-2F86E
2F86F;ID # CJK COMPATIBILITY IDEOGRAPH-2F86F
2F870;ID # CJK COMPATIBILITY IDEOGRAPH-2F870
2F871;ID # CJK COMPATIBILITY IDEOGRAPH-2F871
2F872;ID # CJK COMPATIBILITY IDEOGRAPH-2F872
2F873;ID # CJK COMPATIBILITY IDEOGRAPH-2F873
2F874;ID # CJK COMPATIBILITY IDEOGRAPH-2F874
2F875;ID # CJK COMPATIBILITY IDEOGRAPH-2F875
2F876;ID # CJK COMPATIBILITY IDEOGRAPH-2F876
2F877;ID # CJK COMPATIBILITY IDEOGRAPH-2F877
2F878;ID # CJK COMPATIBILITY IDEOGRAPH-2F878
2F879;ID # CJK COMPATIBILITY IDEOGRAPH-2F879
2F87A;ID # CJK COMPATIBILITY IDEOGRAPH-2F87A
2F87B;ID # CJK COMPATIBILITY IDEOGRAPH-2F87B
2F87C;ID # CJK COMPATIBILITY IDEOGRAPH-2F87C
2F87D;ID # CJK COMPATIBILITY IDEOGRAPH-2F87D
2F87E;ID # CJK COMPATIBILITY IDEOGRAPH-2F87E
2F87F;ID # CJK COMPATIBILITY IDEOGRAPH-2F87F
2F880;ID # CJK COMPATIBILITY IDEOGRAPH-2F880
2F881;ID # CJK COMPATIBILITY IDEOGRAPH-2F881
2F882;ID # CJK COMPATIBILITY IDEOGRAPH-2F882
2F883;ID # CJK COMPATIBILITY IDEOGRAPH-2F883
2F884;ID # CJK COMPATIBILITY IDEOGRAPH-2F884
2F885;ID # CJK COMPATIBILITY IDEOGRAPH-2F885
2F886;ID # CJK COMPATIBILITY IDEOGRAPH-2F886
2F887;ID # CJK COMPATIBILITY IDEOGRAPH-2F887
2F888;ID # CJK COMPATIBILITY IDEOGRAPH-2F888
2F889;ID # CJK COMPATIBILITY IDEOGRAPH-2F889
2F88A;ID # CJK COMPATIBILITY IDEOGRAPH-2F88A
2F88B;ID # CJK COMPATIBILITY IDEOGRAPH-2F88B
2F88C;ID # CJK COMPATIBILITY IDEOGRAPH-2F88C
2F88D;ID # CJK COMPATIBILITY IDEOGRAPH-2F88D
2F88E;ID # CJK COMPATIBILITY IDEOGRAPH-2F88E
2F88F;ID # CJK COMPATIBILITY IDEOGRAPH-2F88F
2F890;ID # CJK COMPATIBILITY IDEOGRAPH-2F890
2F891;ID # CJK COMPATIBILITY IDEOGRAPH-2F891
2F892;ID # CJK COMPATIBILITY IDEOGRAPH-2F892
2F893;ID # CJK COMPATIBILITY IDEOGRAPH-2F893
2F894;ID # CJK COMPATIBILITY IDEOGRAPH-2F894
2F895;ID # CJK COMPATIBILITY IDEOGRAPH-2F895
2F896;ID # CJK COMPATIBILITY IDEOGRAPH-2F896
2F897;ID # CJK COMPATIBILITY IDEOGRAPH-2F897
2F898;ID # CJK COMPATIBILITY IDEOGRAPH-2F898
2F899;ID # CJK COMPATIBILITY IDEOGRAPH-2F899
2F89A;ID # CJK COMPATIBILITY IDEOGRAPH-2F89A
2F89B;ID # CJK COMPATIBILITY IDEOGRAPH-2F89B
2F89C;ID # CJK COMPATIBILITY IDEOGRAPH-2F89C
2F89D;ID # CJK COMPATIBILITY IDEOGRAPH-2F89D
2F89E;ID # CJK COMPATIBILITY IDEOGRAPH-2F89E
2F89F;ID # CJK COMPATIBILITY IDEOGRAPH-2F89F
2F8A0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A0
2F8A1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A1
2F8A2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A2
2F8A3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A3
2F8A4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A4
2F8A5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A5
2F8A6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A6
2F8A7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A7
2F8A8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A8
2F8A9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8A9
2F8AA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AA
2F8AB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AB
2F8AC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AC
2F8AD;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AD
2F8AE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AE
2F8AF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8AF
2F8B0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B0
2F8B1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B1
2F8B2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B2
2F8B3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B3
2F8B4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B4
2F8B5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B5
2F8B6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B6
2F8B7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B7
2F8B8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B8
2F8B9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8B9
2F8BA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BA
2F8BB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BB
2F8BC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BC
2F8BD;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BD
2F8BE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BE
2F8BF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8BF
2F8C0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C0
2F8C1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C1
2F8C2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C2
2F8C3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C3
2F8C4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C4
2F8C5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C5
2F8C6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C6
2F8C7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C7
2F8C8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C8
2F8C9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8C9
2F8CA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CA
2F8CB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CB
2F8CC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CC
2F8CD;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CD
2F8CE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CE
2F8CF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8CF
2F8D0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D0
2F8D1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D1
2F8D2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D2
2F8D3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D3
2F8D4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D4
2F8D5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D5
2F8D6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D6
2F8D7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D7
2F8D8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D8
2F8D9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8D9
2F8DA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DA
2F8DB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DB
2F8DC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DC
2F8DD;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DD
2F8DE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DE
2F8DF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8DF
2F8E0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E0
2F8E1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E1
2F8E2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E2
2F8E3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E3
2F8E4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E4
2F8E5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E5
2F8E6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E6
2F8E7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E7
2F8E8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E8
2F8E9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8E9
2F8EA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8EA
2F8EB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8EB
2F8EC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8EC
2F8ED;ID # CJK COMPATIBILITY IDEOGRAPH-2F8ED
2F8EE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8EE
2F8EF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8EF
2F8F0;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F0
2F8F1;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F1
2F8F2;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F2
2F8F3;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F3
2F8F4;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F4
2F8F5;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F5
2F8F6;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F6
2F8F7;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F7
2F8F8;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F8
2F8F9;ID # CJK COMPATIBILITY IDEOGRAPH-2F8F9
2F8FA;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FA
2F8FB;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FB
2F8FC;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FC
2F8FD;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FD
2F8FE;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FE
2F8FF;ID # CJK COMPATIBILITY IDEOGRAPH-2F8FF
2F900;ID # CJK COMPATIBILITY IDEOGRAPH-2F900
2F901;ID # CJK COMPATIBILITY IDEOGRAPH-2F901
2F902;ID # CJK COMPATIBILITY IDEOGRAPH-2F902
2F903;ID # CJK COMPATIBILITY IDEOGRAPH-2F903
2F904;ID # CJK COMPATIBILITY IDEOGRAPH-2F904
2F905;ID # CJK COMPATIBILITY IDEOGRAPH-2F905
2F906;ID # CJK COMPATIBILITY IDEOGRAPH-2F906
2F907;ID # CJK COMPATIBILITY IDEOGRAPH-2F907
2F908;ID # CJK COMPATIBILITY IDEOGRAPH-2F908
2F909;ID # CJK COMPATIBILITY IDEOGRAPH-2F909
2F90A;ID # CJK COMPATIBILITY IDEOGRAPH-2F90A
2F90B;ID # CJK COMPATIBILITY IDEOGRAPH-2F90B
2F90C;ID # CJK COMPATIBILITY IDEOGRAPH-2F90C
2F90D;ID # CJK COMPATIBILITY IDEOGRAPH-2F90D
2F90E;ID # CJK COMPATIBILITY IDEOGRAPH-2F90E
2F90F;ID # CJK COMPATIBILITY IDEOGRAPH-2F90F
2F910;ID # CJK COMPATIBILITY IDEOGRAPH-2F910
2F911;ID # CJK COMPATIBILITY IDEOGRAPH-2F911
2F912;ID # CJK COMPATIBILITY IDEOGRAPH-2F912
2F913;ID # CJK COMPATIBILITY IDEOGRAPH-2F913
2F914;ID # CJK COMPATIBILITY IDEOGRAPH-2F914
2F915;ID # CJK COMPATIBILITY IDEOGRAPH-2F915
2F916;ID # CJK COMPATIBILITY IDEOGRAPH-2F916
2F917;ID # CJK COMPATIBILITY IDEOGRAPH-2F917
2F918;ID # CJK COMPATIBILITY IDEOGRAPH-2F918
2F919;ID # CJK COMPATIBILITY IDEOGRAPH-2F919
2F91A;ID # CJK COMPATIBILITY IDEOGRAPH-2F91A
2F91B;ID # CJK COMPATIBILITY IDEOGRAPH-2F91B
2F91C;ID # CJK COMPATIBILITY IDEOGRAPH-2F91C
2F91D;ID # CJK COMPATIBILITY IDEOGRAPH-2F91D
2F91E;ID # CJK COMPATIBILITY IDEOGRAPH-2F91E
2F91F;ID # CJK COMPATIBILITY IDEOGRAPH-2F91F
2F920;ID # CJK COMPATIBILITY IDEOGRAPH-2F920
2F921;ID # CJK COMPATIBILITY IDEOGRAPH-2F921
2F922;ID # CJK COMPATIBILITY IDEOGRAPH-2F922
2F923;ID # CJK COMPATIBILITY IDEOGRAPH-2F923
2F924;ID # CJK COMPATIBILITY IDEOGRAPH-2F924
2F925;ID # CJK COMPATIBILITY IDEOGRAPH-2F925
2F926;ID # CJK COMPATIBILITY IDEOGRAPH-2F926
2F927;ID # CJK COMPATIBILITY IDEOGRAPH-2F927
2F928;ID # CJK COMPATIBILITY IDEOGRAPH-2F928
2F929;ID # CJK COMPATIBILITY IDEOGRAPH-2F929
2F92A;ID # CJK COMPATIBILITY IDEOGRAPH-2F92A
2F92B;ID # CJK COMPATIBILITY IDEOGRAPH-2F92B
2F92C;ID # CJK COMPATIBILITY IDEOGRAPH-2F92C
2F92D;ID # CJK COMPATIBILITY IDEOGRAPH-2F92D
2F92E;ID # CJK COMPATIBILITY IDEOGRAPH-2F92E
2F92F;ID # CJK COMPATIBILITY IDEOGRAPH-2F92F
2F930;ID # CJK COMPATIBILITY IDEOGRAPH-2F930
2F931;ID # CJK COMPATIBILITY IDEOGRAPH-2F931
2F932;ID # CJK COMPATIBILITY IDEOGRAPH-2F932
2F933;ID # CJK COMPATIBILITY IDEOGRAPH-2F933
2F934;ID # CJK COMPATIBILITY IDEOGRAPH-2F934
2F935;ID # CJK COMPATIBILITY IDEOGRAPH-2F935
2F936;ID # CJK COMPATIBILITY IDEOGRAPH-2F936
2F937;ID # CJK COMPATIBILITY IDEOGRAPH-2F937
2F938;ID # CJK COMPATIBILITY IDEOGRAPH-2F938
2F939;ID # CJK COMPATIBILITY IDEOGRAPH-2F939
2F93A;ID # CJK COMPATIBILITY IDEOGRAPH-2F93A
2F93B;ID # CJK COMPATIBILITY IDEOGRAPH-2F93B
2F93C;ID # CJK COMPATIBILITY IDEOGRAPH-2F93C
2F93D;ID # CJK COMPATIBILITY IDEOGRAPH-2F93D
2F93E;ID # CJK COMPATIBILITY IDEOGRAPH-2F93E
2F93F;ID # CJK COMPATIBILITY IDEOGRAPH-2F93F
2F940;ID # CJK COMPATIBILITY IDEOGRAPH-2F940
2F941;ID # CJK COMPATIBILITY IDEOGRAPH-2F941
2F942;ID # CJK COMPATIBILITY IDEOGRAPH-2F942
2F943;ID # CJK COMPATIBILITY IDEOGRAPH-2F943
2F944;ID # CJK COMPATIBILITY IDEOGRAPH-2F944
2F945;ID # CJK COMPATIBILITY IDEOGRAPH-2F945
2F946;ID # CJK COMPATIBILITY IDEOGRAPH-2F946
2F947;ID # CJK COMPATIBILITY IDEOGRAPH-2F947
2F948;ID # CJK COMPATIBILITY IDEOGRAPH-2F948
2F949;ID # CJK COMPATIBILITY IDEOGRAPH-2F949
2F94A;ID # CJK COMPATIBILITY IDEOGRAPH-2F94A
2F94B;ID # CJK COMPATIBILITY IDEOGRAPH-2F94B
2F94C;ID # CJK COMPATIBILITY IDEOGRAPH-2F94C
2F94D;ID # CJK COMPATIBILITY IDEOGRAPH-2F94D
2F94E;ID # CJK COMPATIBILITY IDEOGRAPH-2F94E
2F94F;ID # CJK COMPATIBILITY IDEOGRAPH-2F94F
2F950;ID # CJK COMPATIBILITY IDEOGRAPH-2F950
2F951;ID # CJK COMPATIBILITY IDEOGRAPH-2F951
2F952;ID # CJK COMPATIBILITY IDEOGRAPH-2F952
2F953;ID # CJK COMPATIBILITY IDEOGRAPH-2F953
2F954;ID # CJK COMPATIBILITY IDEOGRAPH-2F954
2F955;ID # CJK COMPATIBILITY IDEOGRAPH-2F955
2F956;ID # CJK COMPATIBILITY IDEOGRAPH-2F956
2F957;ID # CJK COMPATIBILITY IDEOGRAPH-2F957
2F958;ID # CJK COMPATIBILITY IDEOGRAPH-2F958
2F959;ID # CJK COMPATIBILITY IDEOGRAPH-2F959
2F95A;ID # CJK COMPATIBILITY IDEOGRAPH-2F95A
2F95B;ID # CJK COMPATIBILITY IDEOGRAPH-2F95B
2F95C;ID # CJK COMPATIBILITY IDEOGRAPH-2F95C
2F95D;ID # CJK COMPATIBILITY IDEOGRAPH-2F95D
2F95E;ID # CJK COMPATIBILITY IDEOGRAPH-2F95E
2F95F;ID # CJK COMPATIBILITY IDEOGRAPH-2F95F
2F960;ID # CJK COMPATIBILITY IDEOGRAPH-2F960
2F961;ID # CJK COMPATIBILITY IDEOGRAPH-2F961
2F962;ID # CJK COMPATIBILITY IDEOGRAPH-2F962
2F963;ID # CJK COMPATIBILITY IDEOGRAPH-2F963
2F964;ID # CJK COMPATIBILITY IDEOGRAPH-2F964
2F965;ID # CJK COMPATIBILITY IDEOGRAPH-2F965
2F966;ID # CJK COMPATIBILITY IDEOGRAPH-2F966
2F967;ID # CJK COMPATIBILITY IDEOGRAPH-2F967
2F968;ID # CJK COMPATIBILITY IDEOGRAPH-2F968
2F969;ID # CJK COMPATIBILITY IDEOGRAPH-2F969
2F96A;ID # CJK COMPATIBILITY IDEOGRAPH-2F96A
2F96B;ID # CJK COMPATIBILITY IDEOGRAPH-2F96B
2F96C;ID # CJK COMPATIBILITY IDEOGRAPH-2F96C
2F96D;ID # CJK COMPATIBILITY IDEOGRAPH-2F96D
2F96E;ID # CJK COMPATIBILITY IDEOGRAPH-2F96E
2F96F;ID # CJK COMPATIBILITY IDEOGRAPH-2F96F
2F970;ID # CJK COMPATIBILITY IDEOGRAPH-2F970
2F971;ID # CJK COMPATIBILITY IDEOGRAPH-2F971
2F972;ID # CJK COMPATIBILITY IDEOGRAPH-2F972
2F973;ID # CJK COMPATIBILITY IDEOGRAPH-2F973
2F974;ID # CJK COMPATIBILITY IDEOGRAPH-2F974
2F975;ID # CJK COMPATIBILITY IDEOGRAPH-2F975
2F976;ID # CJK COMPATIBILITY IDEOGRAPH-2F976
2F977;ID # CJK COMPATIBILITY IDEOGRAPH-2F977
2F978;ID # CJK COMPATIBILITY IDEOGRAPH-2F978
2F979;ID # CJK COMPATIBILITY IDEOGRAPH-2F979
2F97A;ID # CJK COMPATIBILITY IDEOGRAPH-2F97A
2F97B;ID # CJK COMPATIBILITY IDEOGRAPH-2F97B
2F97C;ID # CJK COMPATIBILITY IDEOGRAPH-2F97C
2F97D;ID # CJK COMPATIBILITY IDEOGRAPH-2F97D
2F97E;ID # CJK COMPATIBILITY IDEOGRAPH-2F97E
2F97F;ID # CJK COMPATIBILITY IDEOGRAPH-2F97F
2F980;ID # CJK COMPATIBILITY IDEOGRAPH-2F980
2F981;ID # CJK COMPATIBILITY IDEOGRAPH-2F981
2F982;ID # CJK COMPATIBILITY IDEOGRAPH-2F982
2F983;ID # CJK COMPATIBILITY IDEOGRAPH-2F983
2F984;ID # CJK COMPATIBILITY IDEOGRAPH-2F984
2F985;ID # CJK COMPATIBILITY IDEOGRAPH-2F985
2F986;ID # CJK COMPATIBILITY IDEOGRAPH-2F986
2F987;ID # CJK COMPATIBILITY IDEOGRAPH-2F987
2F988;ID # CJK COMPATIBILITY IDEOGRAPH-2F988
2F989;ID # CJK COMPATIBILITY IDEOGRAPH-2F989
2F98A;ID # CJK COMPATIBILITY IDEOGRAPH-2F98A
2F98B;ID # CJK COMPATIBILITY IDEOGRAPH-2F98B
2F98C;ID # CJK COMPATIBILITY IDEOGRAPH-2F98C
2F98D;ID # CJK COMPATIBILITY IDEOGRAPH-2F98D
2F98E;ID # CJK COMPATIBILITY IDEOGRAPH-2F98E
2F98F;ID # CJK COMPATIBILITY IDEOGRAPH-2F98F
2F990;ID # CJK COMPATIBILITY IDEOGRAPH-2F990
2F991;ID # CJK COMPATIBILITY IDEOGRAPH-2F991
2F992;ID # CJK COMPATIBILITY IDEOGRAPH-2F992
2F993;ID # CJK COMPATIBILITY IDEOGRAPH-2F993
2F994;ID # CJK COMPATIBILITY IDEOGRAPH-2F994
2F995;ID # CJK COMPATIBILITY IDEOGRAPH-2F995
2F996;ID # CJK COMPATIBILITY IDEOGRAPH-2F996
2F997;ID # CJK COMPATIBILITY IDEOGRAPH-2F997
2F998;ID # CJK COMPATIBILITY IDEOGRAPH-2F998
2F999;ID # CJK COMPATIBILITY IDEOGRAPH-2F999
2F99A;ID # CJK COMPATIBILITY IDEOGRAPH-2F99A
2F99B;ID # CJK COMPATIBILITY IDEOGRAPH-2F99B
2F99C;ID # CJK COMPATIBILITY IDEOGRAPH-2F99C
2F99D;ID # CJK COMPATIBILITY IDEOGRAPH-2F99D
2F99E;ID # CJK COMPATIBILITY IDEOGRAPH-2F99E
2F99F;ID # CJK COMPATIBILITY IDEOGRAPH-2F99F
2F9A0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A0
2F9A1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A1
2F9A2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A2
2F9A3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A3
2F9A4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A4
2F9A5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A5
2F9A6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A6
2F9A7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A7
2F9A8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A8
2F9A9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9A9
2F9AA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AA
2F9AB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AB
2F9AC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AC
2F9AD;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AD
2F9AE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AE
2F9AF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9AF
2F9B0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B0
2F9B1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B1
2F9B2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B2
2F9B3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B3
2F9B4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B4
2F9B5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B5
2F9B6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B6
2F9B7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B7
2F9B8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B8
2F9B9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9B9
2F9BA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BA
2F9BB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BB
2F9BC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BC
2F9BD;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BD
2F9BE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BE
2F9BF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9BF
2F9C0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C0
2F9C1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C1
2F9C2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C2
2F9C3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C3
2F9C4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C4
2F9C5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C5
2F9C6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C6
2F9C7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C7
2F9C8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C8
2F9C9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9C9
2F9CA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CA
2F9CB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CB
2F9CC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CC
2F9CD;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CD
2F9CE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CE
2F9CF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9CF
2F9D0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D0
2F9D1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D1
2F9D2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D2
2F9D3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D3
2F9D4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D4
2F9D5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D5
2F9D6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D6
2F9D7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D7
2F9D8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D8
2F9D9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9D9
2F9DA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DA
2F9DB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DB
2F9DC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DC
2F9DD;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DD
2F9DE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DE
2F9DF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9DF
2F9E0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E0
2F9E1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E1
2F9E2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E2
2F9E3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E3
2F9E4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E4
2F9E5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E5
2F9E6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E6
2F9E7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E7
2F9E8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E8
2F9E9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9E9
2F9EA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9EA
2F9EB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9EB
2F9EC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9EC
2F9ED;ID # CJK COMPATIBILITY IDEOGRAPH-2F9ED
2F9EE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9EE
2F9EF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9EF
2F9F0;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F0
2F9F1;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F1
2F9F2;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F2
2F9F3;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F3
2F9F4;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F4
2F9F5;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F5
2F9F6;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F6
2F9F7;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F7
2F9F8;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F8
2F9F9;ID # CJK COMPATIBILITY IDEOGRAPH-2F9F9
2F9FA;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FA
2F9FB;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FB
2F9FC;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FC
2F9FD;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FD
2F9FE;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FE
2F9FF;ID # CJK COMPATIBILITY IDEOGRAPH-2F9FF
2FA00;ID # CJK COMPATIBILITY IDEOGRAPH-2FA00
2FA01;ID # CJK COMPATIBILITY IDEOGRAPH-2FA01
2FA02;ID # CJK COMPATIBILITY IDEOGRAPH-2FA02
2FA03;ID # CJK COMPATIBILITY IDEOGRAPH-2FA03
2FA04;ID # CJK COMPATIBILITY IDEOGRAPH-2FA04
2FA05;ID # CJK COMPATIBILITY IDEOGRAPH-2FA05
2FA06;ID # CJK COMPATIBILITY IDEOGRAPH-2FA06
2FA07;ID # CJK COMPATIBILITY IDEOGRAPH-2FA07
2FA08;ID # CJK COMPATIBILITY IDEOGRAPH-2FA08
2FA09;ID # CJK COMPATIBILITY IDEOGRAPH-2FA09
2FA0A;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0A
2FA0B;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0B
2FA0C;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0C
2FA0D;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0D
2FA0E;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0E
2FA0F;ID # CJK COMPATIBILITY IDEOGRAPH-2FA0F
2FA10;ID # CJK COMPATIBILITY IDEOGRAPH-2FA10
2FA11;ID # CJK COMPATIBILITY IDEOGRAPH-2FA11
2FA12;ID # CJK COMPATIBILITY IDEOGRAPH-2FA12
2FA13;ID # CJK COMPATIBILITY IDEOGRAPH-2FA13
2FA14;ID # CJK COMPATIBILITY IDEOGRAPH-2FA14
2FA15;ID # CJK COMPATIBILITY IDEOGRAPH-2FA15
2FA16;ID # CJK COMPATIBILITY IDEOGRAPH-2FA16
2FA17;ID # CJK COMPATIBILITY IDEOGRAPH-2FA17
2FA18;ID # CJK COMPATIBILITY IDEOGRAPH-2FA18
2FA19;ID # CJK COMPATIBILITY IDEOGRAPH-2FA19
2FA1A;ID # CJK COMPATIBILITY IDEOGRAPH-2FA1A
2FA1B;ID # CJK COMPATIBILITY IDEOGRAPH-2FA1B
2FA1C;ID # CJK COMPATIBILITY IDEOGRAPH-2FA1C
2FA1D;ID # CJK COMPATIBILITY IDEOGRAPH-2FA1D
E0001;CM # LANGUAGE TAG
E0020;CM # TAG SPACE
E0021;CM # TAG EXCLAMATION MARK
E0022;CM # TAG QUOTATION MARK
E0023;CM # TAG NUMBER SIGN
E0024;CM # TAG DOLLAR SIGN
E0025;CM # TAG PERCENT SIGN
E0026;CM # TAG AMPERSAND
E0027;CM # TAG APOSTROPHE
E0028;CM # TAG LEFT PARENTHESIS
E0029;CM # TAG RIGHT PARENTHESIS
E002A;CM # TAG ASTERISK
E002B;CM # TAG PLUS SIGN
E002C;CM # TAG COMMA
E002D;CM # TAG HYPHEN-MINUS
E002E;CM # TAG FULL STOP
E002F;CM # TAG SOLIDUS
E0030;CM # TAG DIGIT ZERO
E0031;CM # TAG DIGIT ONE
E0032;CM # TAG DIGIT TWO
E0033;CM # TAG DIGIT THREE
E0034;CM # TAG DIGIT FOUR
E0035;CM # TAG DIGIT FIVE
E0036;CM # TAG DIGIT SIX
E0037;CM # TAG DIGIT SEVEN
E0038;CM # TAG DIGIT EIGHT
E0039;CM # TAG DIGIT NINE
E003A;CM # TAG COLON
E003B;CM # TAG SEMICOLON
E003C;CM # TAG LESS-THAN SIGN
E003D;CM # TAG EQUALS SIGN
E003E;CM # TAG GREATER-THAN SIGN
E003F;CM # TAG QUESTION MARK
E0040;CM # TAG COMMERCIAL AT
E0041;CM # TAG LATIN CAPITAL LETTER A
E0042;CM # TAG LATIN CAPITAL LETTER B
E0043;CM # TAG LATIN CAPITAL LETTER C
E0044;CM # TAG LATIN CAPITAL LETTER D
E0045;CM # TAG LATIN CAPITAL LETTER E
E0046;CM # TAG LATIN CAPITAL LETTER F
E0047;CM # TAG LATIN CAPITAL LETTER G
E0048;CM # TAG LATIN CAPITAL LETTER H
E0049;CM # TAG LATIN CAPITAL LETTER I
E004A;CM # TAG LATIN CAPITAL LETTER J
E004B;CM # TAG LATIN CAPITAL LETTER K
E004C;CM # TAG LATIN CAPITAL LETTER L
E004D;CM # TAG LATIN CAPITAL LETTER M
E004E;CM # TAG LATIN CAPITAL LETTER N
E004F;CM # TAG LATIN CAPITAL LETTER O
E0050;CM # TAG LATIN CAPITAL LETTER P
E0051;CM # TAG LATIN CAPITAL LETTER Q
E0052;CM # TAG LATIN CAPITAL LETTER R
E0053;CM # TAG LATIN CAPITAL LETTER S
E0054;CM # TAG LATIN CAPITAL LETTER T
E0055;CM # TAG LATIN CAPITAL LETTER U
E0056;CM # TAG LATIN CAPITAL LETTER V
E0057;CM # TAG LATIN CAPITAL LETTER W
E0058;CM # TAG LATIN CAPITAL LETTER X
E0059;CM # TAG LATIN CAPITAL LETTER Y
E005A;CM # TAG LATIN CAPITAL LETTER Z
E005B;CM # TAG LEFT SQUARE BRACKET
E005C;CM # TAG REVERSE SOLIDUS
E005D;CM # TAG RIGHT SQUARE BRACKET
E005E;CM # TAG CIRCUMFLEX ACCENT
E005F;CM # TAG LOW LINE
E0060;CM # TAG GRAVE ACCENT
E0061;CM # TAG LATIN SMALL LETTER A
E0062;CM # TAG LATIN SMALL LETTER B
E0063;CM # TAG LATIN SMALL LETTER C
E0064;CM # TAG LATIN SMALL LETTER D
E0065;CM # TAG LATIN SMALL LETTER E
E0066;CM # TAG LATIN SMALL LETTER F
E0067;CM # TAG LATIN SMALL LETTER G
E0068;CM # TAG LATIN SMALL LETTER H
E0069;CM # TAG LATIN SMALL LETTER I
E006A;CM # TAG LATIN SMALL LETTER J
E006B;CM # TAG LATIN SMALL LETTER K
E006C;CM # TAG LATIN SMALL LETTER L
E006D;CM # TAG LATIN SMALL LETTER M
E006E;CM # TAG LATIN SMALL LETTER N
E006F;CM # TAG LATIN SMALL LETTER O
E0070;CM # TAG LATIN SMALL LETTER P
E0071;CM # TAG LATIN SMALL LETTER Q
E0072;CM # TAG LATIN SMALL LETTER R
E0073;CM # TAG LATIN SMALL LETTER S
E0074;CM # TAG LATIN SMALL LETTER T
E0075;CM # TAG LATIN SMALL LETTER U
E0076;CM # TAG LATIN SMALL LETTER V
E0077;CM # TAG LATIN SMALL LETTER W
E0078;CM # TAG LATIN SMALL LETTER X
E0079;CM # TAG LATIN SMALL LETTER Y
E007A;CM # TAG LATIN SMALL LETTER Z
E007B;CM # TAG LEFT CURLY BRACKET
E007C;CM # TAG VERTICAL LINE
E007D;CM # TAG RIGHT CURLY BRACKET
E007E;CM # TAG TILDE
E007F;CM # CANCEL TAG
E0100;CM # VARIATION SELECTOR-17
E0101;CM # VARIATION SELECTOR-18
E0102;CM # VARIATION SELECTOR-19
E0103;CM # VARIATION SELECTOR-20
E0104;CM # VARIATION SELECTOR-21
E0105;CM # VARIATION SELECTOR-22
E0106;CM # VARIATION SELECTOR-23
E0107;CM # VARIATION SELECTOR-24
E0108;CM # VARIATION SELECTOR-25
E0109;CM # VARIATION SELECTOR-26
E010A;CM # VARIATION SELECTOR-27
E010B;CM # VARIATION SELECTOR-28
E010C;CM # VARIATION SELECTOR-29
E010D;CM # VARIATION SELECTOR-30
E010E;CM # VARIATION SELECTOR-31
E010F;CM # VARIATION SELECTOR-32
E0110;CM # VARIATION SELECTOR-33
E0111;CM # VARIATION SELECTOR-34
E0112;CM # VARIATION SELECTOR-35
E0113;CM # VARIATION SELECTOR-36
E0114;CM # VARIATION SELECTOR-37
E0115;CM # VARIATION SELECTOR-38
E0116;CM # VARIATION SELECTOR-39
E0117;CM # VARIATION SELECTOR-40
E0118;CM # VARIATION SELECTOR-41
E0119;CM # VARIATION SELECTOR-42
E011A;CM # VARIATION SELECTOR-43
E011B;CM # VARIATION SELECTOR-44
E011C;CM # VARIATION SELECTOR-45
E011D;CM # VARIATION SELECTOR-46
E011E;CM # VARIATION SELECTOR-47
E011F;CM # VARIATION SELECTOR-48
E0120;CM # VARIATION SELECTOR-49
E0121;CM # VARIATION SELECTOR-50
E0122;CM # VARIATION SELECTOR-51
E0123;CM # VARIATION SELECTOR-52
E0124;CM # VARIATION SELECTOR-53
E0125;CM # VARIATION SELECTOR-54
E0126;CM # VARIATION SELECTOR-55
E0127;CM # VARIATION SELECTOR-56
E0128;CM # VARIATION SELECTOR-57
E0129;CM # VARIATION SELECTOR-58
E012A;CM # VARIATION SELECTOR-59
E012B;CM # VARIATION SELECTOR-60
E012C;CM # VARIATION SELECTOR-61
E012D;CM # VARIATION SELECTOR-62
E012E;CM # VARIATION SELECTOR-63
E012F;CM # VARIATION SELECTOR-64
E0130;CM # VARIATION SELECTOR-65
E0131;CM # VARIATION SELECTOR-66
E0132;CM # VARIATION SELECTOR-67
E0133;CM # VARIATION SELECTOR-68
E0134;CM # VARIATION SELECTOR-69
E0135;CM # VARIATION SELECTOR-70
E0136;CM # VARIATION SELECTOR-71
E0137;CM # VARIATION SELECTOR-72
E0138;CM # VARIATION SELECTOR-73
E0139;CM # VARIATION SELECTOR-74
E013A;CM # VARIATION SELECTOR-75
E013B;CM # VARIATION SELECTOR-76
E013C;CM # VARIATION SELECTOR-77
E013D;CM # VARIATION SELECTOR-78
E013E;CM # VARIATION SELECTOR-79
E013F;CM # VARIATION SELECTOR-80
E0140;CM # VARIATION SELECTOR-81
E0141;CM # VARIATION SELECTOR-82
E0142;CM # VARIATION SELECTOR-83
E0143;CM # VARIATION SELECTOR-84
E0144;CM # VARIATION SELECTOR-85
E0145;CM # VARIATION SELECTOR-86
E0146;CM # VARIATION SELECTOR-87
E0147;CM # VARIATION SELECTOR-88
E0148;CM # VARIATION SELECTOR-89
E0149;CM # VARIATION SELECTOR-90
E014A;CM # VARIATION SELECTOR-91
E014B;CM # VARIATION SELECTOR-92
E014C;CM # VARIATION SELECTOR-93
E014D;CM # VARIATION SELECTOR-94
E014E;CM # VARIATION SELECTOR-95
E014F;CM # VARIATION SELECTOR-96
E0150;CM # VARIATION SELECTOR-97
E0151;CM # VARIATION SELECTOR-98
E0152;CM # VARIATION SELECTOR-99
E0153;CM # VARIATION SELECTOR-100
E0154;CM # VARIATION SELECTOR-101
E0155;CM # VARIATION SELECTOR-102
E0156;CM # VARIATION SELECTOR-103
E0157;CM # VARIATION SELECTOR-104
E0158;CM # VARIATION SELECTOR-105
E0159;CM # VARIATION SELECTOR-106
E015A;CM # VARIATION SELECTOR-107
E015B;CM # VARIATION SELECTOR-108
E015C;CM # VARIATION SELECTOR-109
E015D;CM # VARIATION SELECTOR-110
E015E;CM # VARIATION SELECTOR-111
E015F;CM # VARIATION SELECTOR-112
E0160;CM # VARIATION SELECTOR-113
E0161;CM # VARIATION SELECTOR-114
E0162;CM # VARIATION SELECTOR-115
E0163;CM # VARIATION SELECTOR-116
E0164;CM # VARIATION SELECTOR-117
E0165;CM # VARIATION SELECTOR-118
E0166;CM # VARIATION SELECTOR-119
E0167;CM # VARIATION SELECTOR-120
E0168;CM # VARIATION SELECTOR-121
E0169;CM # VARIATION SELECTOR-122
E016A;CM # VARIATION SELECTOR-123
E016B;CM # VARIATION SELECTOR-124
E016C;CM # VARIATION SELECTOR-125
E016D;CM # VARIATION SELECTOR-126
E016E;CM # VARIATION SELECTOR-127
E016F;CM # VARIATION SELECTOR-128
E0170;CM # VARIATION SELECTOR-129
E0171;CM # VARIATION SELECTOR-130
E0172;CM # VARIATION SELECTOR-131
E0173;CM # VARIATION SELECTOR-132
E0174;CM # VARIATION SELECTOR-133
E0175;CM # VARIATION SELECTOR-134
E0176;CM # VARIATION SELECTOR-135
E0177;CM # VARIATION SELECTOR-136
E0178;CM # VARIATION SELECTOR-137
E0179;CM # VARIATION SELECTOR-138
E017A;CM # VARIATION SELECTOR-139
E017B;CM # VARIATION SELECTOR-140
E017C;CM # VARIATION SELECTOR-141
E017D;CM # VARIATION SELECTOR-142
E017E;CM # VARIATION SELECTOR-143
E017F;CM # VARIATION SELECTOR-144
E0180;CM # VARIATION SELECTOR-145
E0181;CM # VARIATION SELECTOR-146
E0182;CM # VARIATION SELECTOR-147
E0183;CM # VARIATION SELECTOR-148
E0184;CM # VARIATION SELECTOR-149
E0185;CM # VARIATION SELECTOR-150
E0186;CM # VARIATION SELECTOR-151
E0187;CM # VARIATION SELECTOR-152
E0188;CM # VARIATION SELECTOR-153
E0189;CM # VARIATION SELECTOR-154
E018A;CM # VARIATION SELECTOR-155
E018B;CM # VARIATION SELECTOR-156
E018C;CM # VARIATION SELECTOR-157
E018D;CM # VARIATION SELECTOR-158
E018E;CM # VARIATION SELECTOR-159
E018F;CM # VARIATION SELECTOR-160
E0190;CM # VARIATION SELECTOR-161
E0191;CM # VARIATION SELECTOR-162
E0192;CM # VARIATION SELECTOR-163
E0193;CM # VARIATION SELECTOR-164
E0194;CM # VARIATION SELECTOR-165
E0195;CM # VARIATION SELECTOR-166
E0196;CM # VARIATION SELECTOR-167
E0197;CM # VARIATION SELECTOR-168
E0198;CM # VARIATION SELECTOR-169
E0199;CM # VARIATION SELECTOR-170
E019A;CM # VARIATION SELECTOR-171
E019B;CM # VARIATION SELECTOR-172
E019C;CM # VARIATION SELECTOR-173
E019D;CM # VARIATION SELECTOR-174
E019E;CM # VARIATION SELECTOR-175
E019F;CM # VARIATION SELECTOR-176
E01A0;CM # VARIATION SELECTOR-177
E01A1;CM # VARIATION SELECTOR-178
E01A2;CM # VARIATION SELECTOR-179
E01A3;CM # VARIATION SELECTOR-180
E01A4;CM # VARIATION SELECTOR-181
E01A5;CM # VARIATION SELECTOR-182
E01A6;CM # VARIATION SELECTOR-183
E01A7;CM # VARIATION SELECTOR-184
E01A8;CM # VARIATION SELECTOR-185
E01A9;CM # VARIATION SELECTOR-186
E01AA;CM # VARIATION SELECTOR-187
E01AB;CM # VARIATION SELECTOR-188
E01AC;CM # VARIATION SELECTOR-189
E01AD;CM # VARIATION SELECTOR-190
E01AE;CM # VARIATION SELECTOR-191
E01AF;CM # VARIATION SELECTOR-192
E01B0;CM # VARIATION SELECTOR-193
E01B1;CM # VARIATION SELECTOR-194
E01B2;CM # VARIATION SELECTOR-195
E01B3;CM # VARIATION SELECTOR-196
E01B4;CM # VARIATION SELECTOR-197
E01B5;CM # VARIATION SELECTOR-198
E01B6;CM # VARIATION SELECTOR-199
E01B7;CM # VARIATION SELECTOR-200
E01B8;CM # VARIATION SELECTOR-201
E01B9;CM # VARIATION SELECTOR-202
E01BA;CM # VARIATION SELECTOR-203
E01BB;CM # VARIATION SELECTOR-204
E01BC;CM # VARIATION SELECTOR-205
E01BD;CM # VARIATION SELECTOR-206
E01BE;CM # VARIATION SELECTOR-207
E01BF;CM # VARIATION SELECTOR-208
E01C0;CM # VARIATION SELECTOR-209
E01C1;CM # VARIATION SELECTOR-210
E01C2;CM # VARIATION SELECTOR-211
E01C3;CM # VARIATION SELECTOR-212
E01C4;CM # VARIATION SELECTOR-213
E01C5;CM # VARIATION SELECTOR-214
E01C6;CM # VARIATION SELECTOR-215
E01C7;CM # VARIATION SELECTOR-216
E01C8;CM # VARIATION SELECTOR-217
E01C9;CM # VARIATION SELECTOR-218
E01CA;CM # VARIATION SELECTOR-219
E01CB;CM # VARIATION SELECTOR-220
E01CC;CM # VARIATION SELECTOR-221
E01CD;CM # VARIATION SELECTOR-222
E01CE;CM # VARIATION SELECTOR-223
E01CF;CM # VARIATION SELECTOR-224
E01D0;CM # VARIATION SELECTOR-225
E01D1;CM # VARIATION SELECTOR-226
E01D2;CM # VARIATION SELECTOR-227
E01D3;CM # VARIATION SELECTOR-228
E01D4;CM # VARIATION SELECTOR-229
E01D5;CM # VARIATION SELECTOR-230
E01D6;CM # VARIATION SELECTOR-231
E01D7;CM # VARIATION SELECTOR-232
E01D8;CM # VARIATION SELECTOR-233
E01D9;CM # VARIATION SELECTOR-234
E01DA;CM # VARIATION SELECTOR-235
E01DB;CM # VARIATION SELECTOR-236
E01DC;CM # VARIATION SELECTOR-237
E01DD;CM # VARIATION SELECTOR-238
E01DE;CM # VARIATION SELECTOR-239
E01DF;CM # VARIATION SELECTOR-240
E01E0;CM # VARIATION SELECTOR-241
E01E1;CM # VARIATION SELECTOR-242
E01E2;CM # VARIATION SELECTOR-243
E01E3;CM # VARIATION SELECTOR-244
E01E4;CM # VARIATION SELECTOR-245
E01E5;CM # VARIATION SELECTOR-246
E01E6;CM # VARIATION SELECTOR-247
E01E7;CM # VARIATION SELECTOR-248
E01E8;CM # VARIATION SELECTOR-249
E01E9;CM # VARIATION SELECTOR-250
E01EA;CM # VARIATION SELECTOR-251
E01EB;CM # VARIATION SELECTOR-252
E01EC;CM # VARIATION SELECTOR-253
E01ED;CM # VARIATION SELECTOR-254
E01EE;CM # VARIATION SELECTOR-255
E01EF;CM # VARIATION SELECTOR-256
F0000..FFFFD;XX # <Plane 15 Private Use, First>..<Plane 15 Private Use, Last>
100000..10FFFD;XX # <Plane 16 Private Use, First>..<Plane 16 Private Use, Last>
                                                                                                                            # StandardizedVariants-4.1.0.txt
# Date: 2005-03-17, 15:21:00 PST [KW]
#
# Specification of the variant sequences that are defined in the
# Unicode Standard.
#
# This file is a normative contributory data file in the
# Unicode Character Database.
#
# Copyright (c) 1991-2005 Unicode, Inc.
# For terms of use, see http://www.unicode.org/terms_of_use.html
#
# Warning: Only the variation sequences specifically defined in this file
# are sanctioned for standard use. In all other cases the variation selector
# cannot change the visual appearance of the preceding base character from 
# what it would have had in the absence of the variation selector.
#
# For more information, see Section 15.6, Variation Selectors, 
# in The Unicode Standard, Version 4.0.
#
# Format:
#   Field 0: the variation sequence
#   Field 1: the description of the desired appearance
#   Field 2: where the appearance is only different in in particular shaping environments
#	this field lists them. The possible values are: isolate, initial, medial, final.
#	If more than one is present, there are spaces between them.
# =============================

# Mathematical

2229 FE00; with serifs; # INTERSECTION 
222A FE00; with serifs; # UNION
2268 FE00; with vertical stroke; # LESS-THAN BUT NOT EQUAL TO
2269 FE00; with vertical stroke; # GREATER-THAN AND NOT DOUBLE EQUAL
2272 FE00; following the slant of the lower leg; # LESS-THAN OR EQUIVALENT TO
2273 FE00; following the slant of the lower leg; # GREATER-THAN OR EQUIVALENT TO
#2278 FE00; with vertical stroke; # NEITHER LESS-THAN NOR GREATER-THAN
#2279 FE00; with vertical stroke; # NEITHER GREATER-THAN NOR LESS-THAN
228A FE00; with stroke through bottom members; # SUBSET OF WITH NOT EQUAL TO
228B FE00; with stroke through bottom members; # SUPERSET OF WITH NOT EQUAL TO
2293 FE00; with serifs; # SQUARE CAP
2294 FE00; with serifs; # SQUARE CUP
2295 FE00; with white rim; # CIRCLED PLUS
2297 FE00; with white rim; # CIRCLED TIMES
229C FE00; with equal sign touching the circle; # CIRCLED EQUALS
22DA FE00; with slanted equal; # LESS-THAN EQUAL TO OR GREATER-THAN
22DB FE00; with slanted equal; # GREATER-THAN EQUAL TO OR LESS-THAN
2A3C FE00; tall variant with narrow foot; # INTERIOR PRODUCT
2A3D FE00; tall variant with narrow foot; # RIGHTHAND INTERIOR PRODUCT
2A9D FE00; with similar following the slant of the upper leg; # SIMILAR OR LESS-THAN
2A9E FE00; with similar following the slant of the upper leg; # SIMILAR OR GREATER-THAN
2AAC FE00; with slanted equal; # SMALLER THAN OR EQUAL TO
2AAD FE00; with slanted equal; # LARGER THAN OR EQUAL TO
2ACB FE00; with stroke through bottom members; # SUBSET OF ABOVE NOT EQUAL TO
2ACC FE00; with stroke through bottom members; # SUPERSET OF ABOVE NOT EQUAL TO

#Mongolian

1820 180B; second form; isolate medial final # MONGOLIAN LETTER A
1820 180C; third form; medial # MONGOLIAN LETTER A 
1821 180B; second form; initial final # MONGOLIAN LETTER E
1822 180B; second form; medial # MONGOLIAN LETTER I
1823 180B; second form; medial final # MONGOLIAN LETTER O 
1824 180B; second form; medial # MONGOLIAN LETTER U 
1825 180B; second form; medial final # MONGOLIAN LETTER OE 
1825 180C; third form; medial # MONGOLIAN LETTER OE 
1826 180B; second form; isolate medial final # MONGOLIAN LETTER UE 
1826 180C; third form; medial # MONGOLIAN LETTER UE 
1828 180B; second form; initial medial # MONGOLIAN LETTER NA
1828 180C; third form; medial # MONGOLIAN LETTER NA
1828 180D; separate form; medial # MONGOLIAN LETTER NA
182A 180B; alternative form; final # MONGOLIAN LETTER BA
182C 180B; second form; initial medial # MONGOLIAN LETTER QA
182C 180B; feminine second form; isolate # MONGOLIAN LETTER QA 
182C 180C; third form; medial # MONGOLIAN LETTER QA
182C 180D; fourth form; medial # MONGOLIAN LETTER QA
182D 180B; second form; initial medial # MONGOLIAN LETTER GA
182D 180B; feminine form; final # MONGOLIAN LETTER GA
182D 180C; third form; medial # MONGOLIAN LETTER GA
182D 180D; feminine form; medial # MONGOLIAN LETTER GA
1830 180B; second form; final # MONGOLIAN LETTER SA
1830 180C; third form; final # MONGOLIAN LETTER SA
1832 180B; second form; medial # MONGOLIAN LETTER TA 
1833 180B; second form; initial medial final # MONGOLIAN LETTER DA
1835 180B; second form; medial # MONGOLIAN LETTER JA
1836 180B; second form; initial medial # # MONGOLIAN LETTER YA
1836 180C; third form; medial # MONGOLIAN LETTER YA
1838 180B; second form; final # MONGOLIAN LETTER WA
1844 180B; second form; medial # MONGOLIAN LETTER TODO E
1845 180B; second form; medial # MONGOLIAN LETTER TODO I 
1846 180B; second form; medial # MONGOLIAN LETTER TODO O
1847 180B; second form; isolate medial final # MONGOLIAN LETTER TODO U
1847 180C; third form; medial # MONGOLIAN LETTER TODO U
1848 180B; second form; medial # MONGOLIAN LETTER TODO OE
1849 180B; second form; isolate medial # MONGOLIAN LETTER TODO UE
184D 180B; feminine form; initial medial # MONGOLIAN LETTER TODO QA
184E 180B; second form; medial # MONGOLIAN LETTER TODO GA
185D 180B; second form; medial final # MONGOLIAN LETTER SIBE E
185E 180B; second form; medial final # MONGOLIAN LETTER SIBE I
185E 180C; third form; medial final # MONGOLIAN LETTER SIBE I
1860 180B; second form; medial final # MONGOLIAN LETTER SIBE UE
1863 180B; second form; medial # MONGOLIAN LETTER SIBE KA
1868 180B; second form; initial medial # MONGOLIAN LETTER SIBE TA
1868 180C; third form; medial # MONGOLIAN LETTER SIBE TA
1869 180B; second form; initial medial # MONGOLIAN LETTER SIBE DA
186F 180B; second form; initial medial # MONGOLIAN LETTER SIBE ZA
1873 180B; second form; medial final # MONGOLIAN LETTER MANCHU I
1873 180C; third form; medial final # MONGOLIAN LETTER MANCHU I
1873 180D; fourth form; medial # MONGOLIAN LETTER MANCHU I
1874 180B; second form; medial # MONGOLIAN LETTER MANCHU KA
1874 180B; feminine first final form; final # MONGOLIAN LETTER MANCHU KA
1874 180C; feminine first medial form; medial # MONGOLIAN LETTER MANCHU KA
1874 180C; feminine second final form; final # MONGOLIAN LETTER MANCHU KA 
1874 180D; feminine second medial form; medial # MONGOLIAN LETTER MANCHU KA
1876 180B; second form; initial medial # MONGOLIAN LETTER MANCHU FA
1880 180B; second form; # MONGOLIAN LETTER ALI GALI ANUSVARA ONE
1881 180B; second form; # MONGOLIAN LETTER ALI GALI VISARGA ONE
1887 180B; second form; isolate final # MONGOLIAN LETTER ALI GALI A
1887 180C; third form; final # MONGOLIAN LETTER ALI GALI A
1887 180D; fourth form; final # MONGOLIAN LETTER ALI GALI A
1888 180B; second form; final # MONGOLIAN LETTER ALI GALI I 
188A 180B; second form; initial medial # MONGOLIAN LETTER ALI GALI NGA
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!

return <<'END';
0300	0314	230
0315		232
0316	0319	220
031A		232
031B		216
031C	0320	220
0321	0322	202
0323	0326	220
0327	0328	202
0329	0333	220
0334	0338	1
0339	033C	220
033D	0344	230
0345		240
0346		230
0347	0349	220
034A	034C	230
034D	034E	220
0350	0352	230
0353	0356	220
0357		230
0358		232
0359	035A	220
035B		230
035C		233
035D	035E	234
035F		233
0360	0361	234
0362		233
0363	036F	230
0483	0486	230
0591		220
0592	0595	230
0596		220
0597	0599	230
059A		222
059B		220
059C	05A1	230
05A2	05A7	220
05A8	05A9	230
05AA		220
05AB	05AC	230
05AD		222
05AE		228
05AF		230
05B0		10
05B1		11
05B2		12
05B3		13
05B4		14
05B5		15
05B6		16
05B7		17
05B8		18
05B9		19
05BB		20
05BC		21
05BD		22
05BF		23
05C1		24
05C2		25
05C4		230
05C5		220
05C7		18
0610	0615	230
064B		27
064C		28
064D		29
064E		30
064F		31
0650		32
0651		33
0652		34
0653	0654	230
0655	0656	220
0657	065B	230
065C		220
065D	065E	230
0670		35
06D6	06DC	230
06DF	06E2	230
06E3		220
06E4		230
06E7	06E8	230
06EA		220
06EB	06EC	230
06ED		220
0711		36
0730		230
0731		220
0732	0733	230
0734		220
0735	0736	230
0737	0739	220
073A		230
073B	073C	220
073D		230
073E		220
073F	0741	230
0742		220
0743		230
0744		220
0745		230
0746		220
0747		230
0748		220
0749	074A	230
093C		7
094D		9
0951		230
0952		220
0953	0954	230
09BC		7
09CD		9
0A3C		7
0A4D		9
0ABC		7
0ACD		9
0B3C		7
0B4D		9
0BCD		9
0C4D		9
0C55		84
0C56		91
0CBC		7
0CCD		9
0D4D		9
0DCA		9
0E38	0E39	103
0E3A		9
0E48	0E4B	107
0EB8	0EB9	118
0EC8	0ECB	122
0F18	0F19	220
0F35		220
0F37		220
0F39		216
0F71		129
0F72		130
0F74		132
0F7A	0F7D	130
0F80		130
0F82	0F83	230
0F84		9
0F86	0F87	230
0FC6		220
1037		7
1039		9
135F		230
1714		9
1734		9
17D2		9
17DD		230
18A9		228
1939		222
193A		230
193B		220
1A17		230
1A18		220
1DC0	1DC1	230
1DC2		220
1DC3		230
20D0	20D1	230
20D2	20D3	1
20D4	20D7	230
20D8	20DA	1
20DB	20DC	230
20E1		230
20E5	20E6	1
20E7		230
20E8		220
20E9		230
20EA	20EB	1
302A		218
302B		228
302C		232
302D		222
302E	302F	224
3099	309A	8
A806		9
FB1E		26
FE20	FE23	230
10A0D		220
10A0F		230
10A38		230
10A39		1
10A3A		220
10A3F		9
1D165	1D166	216
1D167	1D169	1
1D16D		226
1D16E	1D172	216
1D17B	1D182	220
1D185	1D189	230
1D18A	1D18B	220
1D1AA	1D1AD	230
1D242	1D244	230
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # BidiMirroring-4.1.0.txt
# Date: 2005-03-17, 15:21:00 PST [KW]
#
# Bidi_Mirroring_Glyph Property
# 
# This file is an informative contributory data file in the
# Unicode Character Database.
#
# Copyright (c) 1991-2005 Unicode, Inc.
# For terms of use, see http://www.unicode.org/terms_of_use.html
#
# This data file lists characters that have the mirrored property
# where there is another Unicode character that typically has a glyph
# that is the mirror image of the original character's glyph.
# The repertoire covered by the file is Unicode 4.1.0.
# 
# The file contains a list of lines with mappings from one code point
# to another one for character-based mirroring.
# Note that for "real" mirroring, a rendering engine needs to select
# appropriate alternative glyphs, and that many Unicode characters do not
# have a mirror-image Unicode character.
# 
# Each mapping line contains two fields, separated by a semicolon (';').
# Each of the two fields contains a code point represented as a
# variable-length hexadecimal value with 4 to 6 digits.
# A comment indicates where the characters are "BEST FIT" mirroring.
# 
# Code points with the "mirrored" property but no appropriate mirrors are
# listed as comments at the end of the file.
# 
# For information on bidi mirroring, see UAX #9: Bidirectional Algorithm,
# at http://www.unicode.org/unicode/reports/tr9/
# 
# This file was originally created by Markus Scherer.
# Extended for Unicode 3.2, 4.0, and 4.1 by Ken Whistler.
# 
# ############################################################

0028; 0029 # LEFT PARENTHESIS
0029; 0028 # RIGHT PARENTHESIS
003C; 003E # LESS-THAN SIGN
003E; 003C # GREATER-THAN SIGN
005B; 005D # LEFT SQUARE BRACKET
005D; 005B # RIGHT SQUARE BRACKET
007B; 007D # LEFT CURLY BRACKET
007D; 007B # RIGHT CURLY BRACKET
00AB; 00BB # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
00BB; 00AB # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
2039; 203A # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
203A; 2039 # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
2045; 2046 # LEFT SQUARE BRACKET WITH QUILL
2046; 2045 # RIGHT SQUARE BRACKET WITH QUILL
207D; 207E # SUPERSCRIPT LEFT PARENTHESIS
207E; 207D # SUPERSCRIPT RIGHT PARENTHESIS
208D; 208E # SUBSCRIPT LEFT PARENTHESIS
208E; 208D # SUBSCRIPT RIGHT PARENTHESIS
2208; 220B # ELEMENT OF
2209; 220C # NOT AN ELEMENT OF
220A; 220D # SMALL ELEMENT OF
220B; 2208 # CONTAINS AS MEMBER
220C; 2209 # DOES NOT CONTAIN AS MEMBER
220D; 220A # SMALL CONTAINS AS MEMBER
2215; 29F5 # DIVISION SLASH
223C; 223D # TILDE OPERATOR
223D; 223C # REVERSED TILDE
2243; 22CD # ASYMPTOTICALLY EQUAL TO
2252; 2253 # APPROXIMATELY EQUAL TO OR THE IMAGE OF
2253; 2252 # IMAGE OF OR APPROXIMATELY EQUAL TO
2254; 2255 # COLON EQUALS
2255; 2254 # EQUALS COLON
2264; 2265 # LESS-THAN OR EQUAL TO
2265; 2264 # GREATER-THAN OR EQUAL TO
2266; 2267 # LESS-THAN OVER EQUAL TO
2267; 2266 # GREATER-THAN OVER EQUAL TO
2268; 2269 # [BEST FIT] LESS-THAN BUT NOT EQUAL TO
2269; 2268 # [BEST FIT] GREATER-THAN BUT NOT EQUAL TO
226A; 226B # MUCH LESS-THAN
226B; 226A # MUCH GREATER-THAN
226E; 226F # [BEST FIT] NOT LESS-THAN
226F; 226E # [BEST FIT] NOT GREATER-THAN
2270; 2271 # [BEST FIT] NEITHER LESS-THAN NOR EQUAL TO
2271; 2270 # [BEST FIT] NEITHER GREATER-THAN NOR EQUAL TO
2272; 2273 # [BEST FIT] LESS-THAN OR EQUIVALENT TO
2273; 2272 # [BEST FIT] GREATER-THAN OR EQUIVALENT TO
2274; 2275 # [BEST FIT] NEITHER LESS-THAN NOR EQUIVALENT TO
2275; 2274 # [BEST FIT] NEITHER GREATER-THAN NOR EQUIVALENT TO
2276; 2277 # LESS-THAN OR GREATER-THAN
2277; 2276 # GREATER-THAN OR LESS-THAN
2278; 2279 # NEITHER LESS-THAN NOR GREATER-THAN
2279; 2278 # NEITHER GREATER-THAN NOR LESS-THAN
227A; 227B # PRECEDES
227B; 227A # SUCCEEDS
227C; 227D # PRECEDES OR EQUAL TO
227D; 227C # SUCCEEDS OR EQUAL TO
227E; 227F # [BEST FIT] PRECEDES OR EQUIVALENT TO
227F; 227E # [BEST FIT] SUCCEEDS OR EQUIVALENT TO
2280; 2281 # [BEST FIT] DOES NOT PRECEDE
2281; 2280 # [BEST FIT] DOES NOT SUCCEED
2282; 2283 # SUBSET OF
2283; 2282 # SUPERSET OF
2284; 2285 # [BEST FIT] NOT A SUBSET OF
2285; 2284 # [BEST FIT] NOT A SUPERSET OF
2286; 2287 # SUBSET OF OR EQUAL TO
2287; 2286 # SUPERSET OF OR EQUAL TO
2288; 2289 # [BEST FIT] NEITHER A SUBSET OF NOR EQUAL TO
2289; 2288 # [BEST FIT] NEITHER A SUPERSET OF NOR EQUAL TO
228A; 228B # [BEST FIT] SUBSET OF WITH NOT EQUAL TO
228B; 228A # [BEST FIT] SUPERSET OF WITH NOT EQUAL TO
228F; 2290 # SQUARE IMAGE OF
2290; 228F # SQUARE ORIGINAL OF
2291; 2292 # SQUARE IMAGE OF OR EQUAL TO
2292; 2291 # SQUARE ORIGINAL OF OR EQUAL TO
2298; 29B8 # CIRCLED DIVISION SLASH
22A2; 22A3 # RIGHT TACK
22A3; 22A2 # LEFT TACK
22A6; 2ADE # ASSERTION
22A8; 2AE4 # TRUE
22A9; 2AE3 # FORCES
22AB; 2AE5 # DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
22B0; 22B1 # PRECEDES UNDER RELATION
22B1; 22B0 # SUCCEEDS UNDER RELATION
22B2; 22B3 # NORMAL SUBGROUP OF
22B3; 22B2 # CONTAINS AS NORMAL SUBGROUP
22B4; 22B5 # NORMAL SUBGROUP OF OR EQUAL TO
22B5; 22B4 # CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
22B6; 22B7 # ORIGINAL OF
22B7; 22B6 # IMAGE OF
22C9; 22CA # LEFT NORMAL FACTOR SEMIDIRECT PRODUCT
22CA; 22C9 # RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT
22CB; 22CC # LEFT SEMIDIRECT PRODUCT
22CC; 22CB # RIGHT SEMIDIRECT PRODUCT
22CD; 2243 # REVERSED TILDE EQUALS
22D0; 22D1 # DOUBLE SUBSET
22D1; 22D0 # DOUBLE SUPERSET
22D6; 22D7 # LESS-THAN WITH DOT
22D7; 22D6 # GREATER-THAN WITH DOT
22D8; 22D9 # VERY MUCH LESS-THAN
22D9; 22D8 # VERY MUCH GREATER-THAN
22DA; 22DB # LESS-THAN EQUAL TO OR GREATER-THAN
22DB; 22DA # GREATER-THAN EQUAL TO OR LESS-THAN
22DC; 22DD # EQUAL TO OR LESS-THAN
22DD; 22DC # EQUAL TO OR GREATER-THAN
22DE; 22DF # EQUAL TO OR PRECEDES
22DF; 22DE # EQUAL TO OR SUCCEEDS
22E0; 22E1 # [BEST FIT] DOES NOT PRECEDE OR EQUAL
22E1; 22E0 # [BEST FIT] DOES NOT SUCCEED OR EQUAL
22E2; 22E3 # [BEST FIT] NOT SQUARE IMAGE OF OR EQUAL TO
22E3; 22E2 # [BEST FIT] NOT SQUARE ORIGINAL OF OR EQUAL TO
22E4; 22E5 # [BEST FIT] SQUARE IMAGE OF OR NOT EQUAL TO
22E5; 22E4 # [BEST FIT] SQUARE ORIGINAL OF OR NOT EQUAL TO
22E6; 22E7 # [BEST FIT] LESS-THAN BUT NOT EQUIVALENT TO
22E7; 22E6 # [BEST FIT] GREATER-THAN BUT NOT EQUIVALENT TO
22E8; 22E9 # [BEST FIT] PRECEDES BUT NOT EQUIVALENT TO
22E9; 22E8 # [BEST FIT] SUCCEEDS BUT NOT EQUIVALENT TO
22EA; 22EB # [BEST FIT] NOT NORMAL SUBGROUP OF
22EB; 22EA # [BEST FIT] DOES NOT CONTAIN AS NORMAL SUBGROUP
22EC; 22ED # [BEST FIT] NOT NORMAL SUBGROUP OF OR EQUAL TO
22ED; 22EC # [BEST FIT] DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
22F0; 22F1 # UP RIGHT DIAGONAL ELLIPSIS
22F1; 22F0 # DOWN RIGHT DIAGONAL ELLIPSIS
22F2; 22FA # ELEMENT OF WITH LONG HORIZONTAL STROKE
22F3; 22FB # ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
22F4; 22FC # SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
22F6; 22FD # ELEMENT OF WITH OVERBAR
22F7; 22FE # SMALL ELEMENT OF WITH OVERBAR
22FA; 22F2 # CONTAINS WITH LONG HORIZONTAL STROKE
22FB; 22F3 # CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
22FC; 22F4 # SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
22FD; 22F6 # CONTAINS WITH OVERBAR
22FE; 22F7 # SMALL CONTAINS WITH OVERBAR
2308; 2309 # LEFT CEILING
2309; 2308 # RIGHT CEILING
230A; 230B # LEFT FLOOR
230B; 230A # RIGHT FLOOR
2329; 232A # LEFT-POINTING ANGLE BRACKET
232A; 2329 # RIGHT-POINTING ANGLE BRACKET
2768; 2769 # MEDIUM LEFT PARENTHESIS ORNAMENT
2769; 2768 # MEDIUM RIGHT PARENTHESIS ORNAMENT
276A; 276B # MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT
276B; 276A # MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT
276C; 276D # MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT
276D; 276C # MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT
276E; 276F # HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT
276F; 276E # HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT
2770; 2771 # HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT
2771; 2770 # HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT
2772; 2773 # LIGHT LEFT TORTOISE SHELL BRACKET
2773; 2772 # LIGHT RIGHT TORTOISE SHELL BRACKET
2774; 2775 # MEDIUM LEFT CURLY BRACKET ORNAMENT
2775; 2774 # MEDIUM RIGHT CURLY BRACKET ORNAMENT
27C3; 27C4 # OPEN SUBSET
27C4; 27C3 # OPEN SUPERSET
27C5; 27C6 # LEFT S-SHAPED BAG DELIMITER
27C6; 27C5 # RIGHT S-SHAPED BAG DELIMITER
27D5; 27D6 # LEFT OUTER JOIN
27D6; 27D5 # RIGHT OUTER JOIN
27DD; 27DE # LONG RIGHT TACK
27DE; 27DD # LONG LEFT TACK
27E2; 27E3 # WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK
27E3; 27E2 # WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK
27E4; 27E5 # WHITE SQUARE WITH LEFTWARDS TICK
27E5; 27E4 # WHITE SQUARE WITH RIGHTWARDS TICK
27E6; 27E7 # MATHEMATICAL LEFT WHITE SQUARE BRACKET
27E7; 27E6 # MATHEMATICAL RIGHT WHITE SQUARE BRACKET
27E8; 27E9 # MATHEMATICAL LEFT ANGLE BRACKET
27E9; 27E8 # MATHEMATICAL RIGHT ANGLE BRACKET
27EA; 27EB # MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
27EB; 27EA # MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
2983; 2984 # LEFT WHITE CURLY BRACKET
2984; 2983 # RIGHT WHITE CURLY BRACKET
2985; 2986 # LEFT WHITE PARENTHESIS
2986; 2985 # RIGHT WHITE PARENTHESIS
2987; 2988 # Z NOTATION LEFT IMAGE BRACKET
2988; 2987 # Z NOTATION RIGHT IMAGE BRACKET
2989; 298A # Z NOTATION LEFT BINDING BRACKET
298A; 2989 # Z NOTATION RIGHT BINDING BRACKET
298B; 298C # LEFT SQUARE BRACKET WITH UNDERBAR
298C; 298B # RIGHT SQUARE BRACKET WITH UNDERBAR
298D; 2990 # LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
298E; 298F # RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
298F; 298E # LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
2990; 298D # RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
2991; 2992 # LEFT ANGLE BRACKET WITH DOT
2992; 2991 # RIGHT ANGLE BRACKET WITH DOT
2993; 2994 # LEFT ARC LESS-THAN BRACKET
2994; 2993 # RIGHT ARC GREATER-THAN BRACKET
2995; 2996 # DOUBLE LEFT ARC GREATER-THAN BRACKET
2996; 2995 # DOUBLE RIGHT ARC LESS-THAN BRACKET
2997; 2998 # LEFT BLACK TORTOISE SHELL BRACKET
2998; 2997 # RIGHT BLACK TORTOISE SHELL BRACKET
29B8; 2298 # CIRCLED REVERSE SOLIDUS
29C0; 29C1 # CIRCLED LESS-THAN
29C1; 29C0 # CIRCLED GREATER-THAN
29C4; 29C5 # SQUARED RISING DIAGONAL SLASH
29C5; 29C4 # SQUARED FALLING DIAGONAL SLASH
29CF; 29D0 # LEFT TRIANGLE BESIDE VERTICAL BAR
29D0; 29CF # VERTICAL BAR BESIDE RIGHT TRIANGLE
29D1; 29D2 # BOWTIE WITH LEFT HALF BLACK
29D2; 29D1 # BOWTIE WITH RIGHT HALF BLACK
29D4; 29D5 # TIMES WITH LEFT HALF BLACK
29D5; 29D4 # TIMES WITH RIGHT HALF BLACK
29D8; 29D9 # LEFT WIGGLY FENCE
29D9; 29D8 # RIGHT WIGGLY FENCE
29DA; 29DB # LEFT DOUBLE WIGGLY FENCE
29DB; 29DA # RIGHT DOUBLE WIGGLY FENCE
29F5; 2215 # REVERSE SOLIDUS OPERATOR
29F8; 29F9 # BIG SOLIDUS
29F9; 29F8 # BIG REVERSE SOLIDUS
29FC; 29FD # LEFT-POINTING CURVED ANGLE BRACKET
29FD; 29FC # RIGHT-POINTING CURVED ANGLE BRACKET
2A2B; 2A2C # MINUS SIGN WITH FALLING DOTS
2A2C; 2A2B # MINUS SIGN WITH RISING DOTS
2A2D; 2A2E # PLUS SIGN IN LEFT HALF CIRCLE
2A2E; 2A2D # PLUS SIGN IN RIGHT HALF CIRCLE
2A34; 2A35 # MULTIPLICATION SIGN IN LEFT HALF CIRCLE
2A35; 2A34 # MULTIPLICATION SIGN IN RIGHT HALF CIRCLE
2A3C; 2A3D # INTERIOR PRODUCT
2A3D; 2A3C # RIGHTHAND INTERIOR PRODUCT
2A64; 2A65 # Z NOTATION DOMAIN ANTIRESTRICTION
2A65; 2A64 # Z NOTATION RANGE ANTIRESTRICTION
2A79; 2A7A # LESS-THAN WITH CIRCLE INSIDE
2A7A; 2A79 # GREATER-THAN WITH CIRCLE INSIDE
2A7D; 2A7E # LESS-THAN OR SLANTED EQUAL TO
2A7E; 2A7D # GREATER-THAN OR SLANTED EQUAL TO
2A7F; 2A80 # LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE
2A80; 2A7F # GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE
2A81; 2A82 # LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE
2A82; 2A81 # GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE
2A83; 2A84 # LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT
2A84; 2A83 # GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT
2A8B; 2A8C # LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN
2A8C; 2A8B # GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN
2A91; 2A92 # LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL
2A92; 2A91 # GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL
2A93; 2A94 # LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL
2A94; 2A93 # GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL
2A95; 2A96 # SLANTED EQUAL TO OR LESS-THAN
2A96; 2A95 # SLANTED EQUAL TO OR GREATER-THAN
2A97; 2A98 # SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE
2A98; 2A97 # SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE
2A99; 2A9A # DOUBLE-LINE EQUAL TO OR LESS-THAN
2A9A; 2A99 # DOUBLE-LINE EQUAL TO OR GREATER-THAN
2A9B; 2A9C # DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN
2A9C; 2A9B # DOUBLE-LINE SLANTED EQUAL TO OR GREATER-THAN
2AA1; 2AA2 # DOUBLE NESTED LESS-THAN
2AA2; 2AA1 # DOUBLE NESTED GREATER-THAN
2AA6; 2AA7 # LESS-THAN CLOSED BY CURVE
2AA7; 2AA6 # GREATER-THAN CLOSED BY CURVE
2AA8; 2AA9 # LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL
2AA9; 2AA8 # GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL
2AAA; 2AAB # SMALLER THAN
2AAB; 2AAA # LARGER THAN
2AAC; 2AAD # SMALLER THAN OR EQUAL TO
2AAD; 2AAC # LARGER THAN OR EQUAL TO
2AAF; 2AB0 # PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
2AB0; 2AAF # SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
2AB3; 2AB4 # PRECEDES ABOVE EQUALS SIGN
2AB4; 2AB3 # SUCCEEDS ABOVE EQUALS SIGN
2ABB; 2ABC # DOUBLE PRECEDES
2ABC; 2ABB # DOUBLE SUCCEEDS
2ABD; 2ABE # SUBSET WITH DOT
2ABE; 2ABD # SUPERSET WITH DOT
2ABF; 2AC0 # SUBSET WITH PLUS SIGN BELOW
2AC0; 2ABF # SUPERSET WITH PLUS SIGN BELOW
2AC1; 2AC2 # SUBSET WITH MULTIPLICATION SIGN BELOW
2AC2; 2AC1 # SUPERSET WITH MULTIPLICATION SIGN BELOW
2AC3; 2AC4 # SUBSET OF OR EQUAL TO WITH DOT ABOVE
2AC4; 2AC3 # SUPERSET OF OR EQUAL TO WITH DOT ABOVE
2AC5; 2AC6 # SUBSET OF ABOVE EQUALS SIGN
2AC6; 2AC5 # SUPERSET OF ABOVE EQUALS SIGN
2ACD; 2ACE # SQUARE LEFT OPEN BOX OPERATOR
2ACE; 2ACD # SQUARE RIGHT OPEN BOX OPERATOR
2ACF; 2AD0 # CLOSED SUBSET
2AD0; 2ACF # CLOSED SUPERSET
2AD1; 2AD2 # CLOSED SUBSET OR EQUAL TO
2AD2; 2AD1 # CLOSED SUPERSET OR EQUAL TO
2AD3; 2AD4 # SUBSET ABOVE SUPERSET
2AD4; 2AD3 # SUPERSET ABOVE SUBSET
2AD5; 2AD6 # SUBSET ABOVE SUBSET
2AD6; 2AD5 # SUPERSET ABOVE SUPERSET
2ADE; 22A6 # SHORT LEFT TACK
2AE3; 22A9 # DOUBLE VERTICAL BAR LEFT TURNSTILE
2AE4; 22A8 # VERTICAL BAR DOUBLE LEFT TURNSTILE
2AE5; 22AB # DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE
2AEC; 2AED # DOUBLE STROKE NOT SIGN
2AED; 2AEC # REVERSED DOUBLE STROKE NOT SIGN
2AF7; 2AF8 # TRIPLE NESTED LESS-THAN
2AF8; 2AF7 # TRIPLE NESTED GREATER-THAN
2AF9; 2AFA # DOUBLE-LINE SLANTED LESS-THAN OR EQUAL TO
2AFA; 2AF9 # DOUBLE-LINE SLANTED GREATER-THAN OR EQUAL TO
2E02; 2E03 # LEFT SUBSTITUTION BRACKET
2E03; 2E02 # RIGHT SUBSTITUTION BRACKET
2E04; 2E05 # LEFT DOTTED SUBSTITUTION BRACKET
2E05; 2E04 # RIGHT DOTTED SUBSTITUTION BRACKET
2E09; 2E0A # LEFT TRANSPOSITION BRACKET
2E0A; 2E09 # RIGHT TRANSPOSITION BRACKET
2E0C; 2E0D # LEFT RAISED OMISSION BRACKET
2E0D; 2E0C # RIGHT RAISED OMISSION BRACKET
2E1C; 2E1D # LEFT LOW PARAPHRASE BRACKET
2E1D; 2E1C # RIGHT LOW PARAPHRASE BRACKET
3008; 3009 # LEFT ANGLE BRACKET
3009; 3008 # RIGHT ANGLE BRACKET
300A; 300B # LEFT DOUBLE ANGLE BRACKET
300B; 300A # RIGHT DOUBLE ANGLE BRACKET
300C; 300D # [BEST FIT] LEFT CORNER BRACKET
300D; 300C # [BEST FIT] RIGHT CORNER BRACKET
300E; 300F # [BEST FIT] LEFT WHITE CORNER BRACKET
300F; 300E # [BEST FIT] RIGHT WHITE CORNER BRACKET
3010; 3011 # LEFT BLACK LENTICULAR BRACKET
3011; 3010 # RIGHT BLACK LENTICULAR BRACKET
3014; 3015 # LEFT TORTOISE SHELL BRACKET
3015; 3014 # RIGHT TORTOISE SHELL BRACKET
3016; 3017 # LEFT WHITE LENTICULAR BRACKET
3017; 3016 # RIGHT WHITE LENTICULAR BRACKET
3018; 3019 # LEFT WHITE TORTOISE SHELL BRACKET
3019; 3018 # RIGHT WHITE TORTOISE SHELL BRACKET
301A; 301B # LEFT WHITE SQUARE BRACKET
301B; 301A # RIGHT WHITE SQUARE BRACKET
FF08; FF09 # FULLWIDTH LEFT PARENTHESIS
FF09; FF08 # FULLWIDTH RIGHT PARENTHESIS
FF1C; FF1E # FULLWIDTH LESS-THAN SIGN
FF1E; FF1C # FULLWIDTH GREATER-THAN SIGN
FF3B; FF3D # FULLWIDTH LEFT SQUARE BRACKET
FF3D; FF3B # FULLWIDTH RIGHT SQUARE BRACKET
FF5B; FF5D # FULLWIDTH LEFT CURLY BRACKET
FF5D; FF5B # FULLWIDTH RIGHT CURLY BRACKET
FF5F; FF60 # FULLWIDTH LEFT WHITE PARENTHESIS
FF60; FF5F # FULLWIDTH RIGHT WHITE PARENTHESIS
FF62; FF63 # [BEST FIT] HALFWIDTH LEFT CORNER BRACKET
FF63; FF62 # [BEST FIT] HALFWIDTH RIGHT CORNER BRACKET

# The following characters have no appropriate mirroring character.
# For these characters it is up to the rendering system
#   to provide mirrored glyphs.

# 2140; DOUBLE-STRUCK N-ARY SUMMATION
# 2201; COMPLEMENT
# 2202; PARTIAL DIFFERENTIAL
# 2203; THERE EXISTS
# 2204; THERE DOES NOT EXIST
# 2211; N-ARY SUMMATION
# 2216; SET MINUS
# 221A; SQUARE ROOT
# 221B; CUBE ROOT
# 221C; FOURTH ROOT
# 221D; PROPORTIONAL TO
# 221F; RIGHT ANGLE
# 2220; ANGLE
# 2221; MEASURED ANGLE
# 2222; SPHERICAL ANGLE
# 2224; DOES NOT DIVIDE
# 2226; NOT PARALLEL TO
# 222B; INTEGRAL
# 222C; DOUBLE INTEGRAL
# 222D; TRIPLE INTEGRAL
# 222E; CONTOUR INTEGRAL
# 222F; SURFACE INTEGRAL
# 2230; VOLUME INTEGRAL
# 2231; CLOCKWISE INTEGRAL
# 2232; CLOCKWISE CONTOUR INTEGRAL
# 2233; ANTICLOCKWISE CONTOUR INTEGRAL
# 2239; EXCESS
# 223B; HOMOTHETIC
# 223E; INVERTED LAZY S
# 223F; SINE WAVE
# 2240; WREATH PRODUCT
# 2241; NOT TILDE
# 2242; MINUS TILDE
# 2244; NOT ASYMPTOTICALLY EQUAL TO
# 2245; APPROXIMATELY EQUAL TO
# 2246; APPROXIMATELY BUT NOT ACTUALLY EQUAL TO
# 2247; NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
# 2248; ALMOST EQUAL TO
# 2249; NOT ALMOST EQUAL TO
# 224A; ALMOST EQUAL OR EQUAL TO
# 224B; TRIPLE TILDE
# 224C; ALL EQUAL TO
# 225F; QUESTIONED EQUAL TO
# 2260; NOT EQUAL TO
# 2262; NOT IDENTICAL TO
# 228C; MULTISET
# 22A7; MODELS
# 22AA; TRIPLE VERTICAL BAR RIGHT TURNSTILE
# 22AC; DOES NOT PROVE
# 22AD; NOT TRUE
# 22AE; DOES NOT FORCE
# 22AF; NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
# 22B8; MULTIMAP
# 22BE; RIGHT ANGLE WITH ARC
# 22BF; RIGHT TRIANGLE
# 22F5; ELEMENT OF WITH DOT ABOVE
# 22F8; ELEMENT OF WITH UNDERBAR
# 22F9; ELEMENT OF WITH TWO HORIZONTAL STROKES
# 22FF; Z NOTATION BAG MEMBERSHIP
# 2320; TOP HALF INTEGRAL
# 2321; BOTTOM HALF INTEGRAL
# 27C0; THREE DIMENSIONAL ANGLE
# 27D3; LOWER RIGHT CORNER WITH DOT
# 27D4; UPPER LEFT CORNER WITH DOT
# 27DC; LEFT MULTIMAP
# 299B; MEASURED ANGLE OPENING LEFT
# 299C; RIGHT ANGLE VARIANT WITH SQUARE
# 299D; MEASURED RIGHT ANGLE WITH DOT
# 299E; ANGLE WITH S INSIDE
# 299F; ACUTE ANGLE
# 29A0; SPHERICAL ANGLE OPENING LEFT
# 29A1; SPHERICAL ANGLE OPENING UP
# 29A2; TURNED ANGLE
# 29A3; REVERSED ANGLE
# 29A4; ANGLE WITH UNDERBAR
# 29A5; REVERSED ANGLE WITH UNDERBAR
# 29A6; OBLIQUE ANGLE OPENING UP
# 29A7; OBLIQUE ANGLE OPENING DOWN
# 29A8; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT
# 29A9; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT
# 29AA; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT
# 29AB; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT
# 29AC; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP
# 29AD; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP
# 29AE; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN
# 29AF; MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN
# 29C2; CIRCLE WITH SMALL CIRCLE TO THE RIGHT
# 29C3; CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT
# 29C9; TWO JOINED SQUARES
# 29CE; RIGHT TRIANGLE ABOVE LEFT TRIANGLE
# 29DC; INCOMPLETE INFINITY
# 29E1; INCREASES AS
# 29E3; EQUALS SIGN AND SLANTED PARALLEL
# 29E4; EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE
# 29E5; IDENTICAL TO AND SLANTED PARALLEL
# 29E8; DOWN-POINTING TRIANGLE WITH LEFT HALF BLACK
# 29E9; DOWN-POINTING TRIANGLE WITH RIGHT HALF BLACK
# 29F4; RULE-DELAYED
# 29F6; SOLIDUS WITH OVERBAR
# 29F7; REVERSE SOLIDUS WITH HORIZONTAL STROKE
# 2A0A; MODULO TWO SUM
# 2A0B; SUMMATION WITH INTEGRAL
# 2A0C; QUADRUPLE INTEGRAL OPERATOR
# 2A0D; FINITE PART INTEGRAL
# 2A0E; INTEGRAL WITH DOUBLE STROKE
# 2A0F; INTEGRAL AVERAGE WITH SLASH
# 2A10; CIRCULATION FUNCTION
# 2A11; ANTICLOCKWISE INTEGRATION
# 2A12; LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE
# 2A13; LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE
# 2A14; LINE INTEGRATION NOT INCLUDING THE POLE
# 2A15; INTEGRAL AROUND A POINT OPERATOR
# 2A16; QUATERNION INTEGRAL OPERATOR
# 2A17; INTEGRAL WITH LEFTWARDS ARROW WITH HOOK
# 2A18; INTEGRAL WITH TIMES SIGN
# 2A19; INTEGRAL WITH INTERSECTION
# 2A1A; INTEGRAL WITH UNION
# 2A1B; INTEGRAL WITH OVERBAR
# 2A1C; INTEGRAL WITH UNDERBAR
# 2A1E; LARGE LEFT TRIANGLE OPERATOR
# 2A1F; Z NOTATION SCHEMA COMPOSITION
# 2A20; Z NOTATION SCHEMA PIPING
# 2A21; Z NOTATION SCHEMA PROJECTION
# 2A24; PLUS SIGN WITH TILDE ABOVE
# 2A26; PLUS SIGN WITH TILDE BELOW
# 2A29; MINUS SIGN WITH COMMA ABOVE
# 2A3E; Z NOTATION RELATIONAL COMPOSITION
# 2A57; SLOPING LARGE OR
# 2A58; SLOPING LARGE AND
# 2A6A; TILDE OPERATOR WITH DOT ABOVE
# 2A6B; TILDE OPERATOR WITH RISING DOTS
# 2A6C; SIMILAR MINUS SIMILAR
# 2A6D; CONGRUENT WITH DOT ABOVE
# 2A6F; ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT
# 2A70; APPROXIMATELY EQUAL OR EQUAL TO
# 2A73; EQUALS SIGN ABOVE TILDE OPERATOR
# 2A74; DOUBLE COLON EQUAL
# 2A7B; LESS-THAN WITH QUESTION MARK ABOVE
# 2A7C; GREATER-THAN WITH QUESTION MARK ABOVE
# 2A85; LESS-THAN OR APPROXIMATE
# 2A86; GREATER-THAN OR APPROXIMATE
# 2A87; LESS-THAN AND SINGLE-LINE NOT EQUAL TO
# 2A88; GREATER-THAN AND SINGLE-LINE NOT EQUAL TO
# 2A89; LESS-THAN AND NOT APPROXIMATE
# 2A8A; GREATER-THAN AND NOT APPROXIMATE
# 2A8D; LESS-THAN ABOVE SIMILAR OR EQUAL
# 2A8E; GREATER-THAN ABOVE SIMILAR OR EQUAL
# 2A8F; LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN
# 2A90; GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN
# 2A9D; SIMILAR OR LESS-THAN
# 2A9E; SIMILAR OR GREATER-THAN
# 2A9F; SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN
# 2AA0; SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN
# 2AA3; DOUBLE NESTED LESS-THAN WITH UNDERBAR
# 2AB1; PRECEDES ABOVE SINGLE-LINE NOT EQUAL TO
# 2AB2; SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO
# 2AB5; PRECEDES ABOVE NOT EQUAL TO
# 2AB6; SUCCEEDS ABOVE NOT EQUAL TO
# 2AB7; PRECEDES ABOVE ALMOST EQUAL TO
# 2AB8; SUCCEEDS ABOVE ALMOST EQUAL TO
# 2AB9; PRECEDES ABOVE NOT ALMOST EQUAL TO
# 2ABA; SUCCEEDS ABOVE NOT ALMOST EQUAL TO
# 2AC7; SUBSET OF ABOVE TILDE OPERATOR
# 2AC8; SUPERSET OF ABOVE TILDE OPERATOR
# 2AC9; SUBSET OF ABOVE ALMOST EQUAL TO
# 2ACA; SUPERSET OF ABOVE ALMOST EQUAL TO
# 2ACB; SUBSET OF ABOVE NOT EQUAL TO
# 2ACC; SUPERSET OF ABOVE NOT EQUAL TO
# 2ADC; FORKING
# 2AE2; VERTICAL BAR TRIPLE RIGHT TURNSTILE
# 2AE6; LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL
# 2AEE; DOES NOT DIVIDE WITH REVERSED NEGATION SLASH
# 2AF3; PARALLEL WITH TILDE OPERATOR
# 2AFB; TRIPLE SOLIDUS BINARY RELATION
# 2AFD; DOUBLE SOLIDUS OPERATOR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 2005 March 30

Welcome to the Unicode Character Database

This directory contains contributory data files
for the Unicode Character Database of the Unicode Standard. 

Copyright (c) 1991-2005 Unicode, Inc.
For terms of use, see http://www.unicode.org/terms_of_use.html

For an overview of how to access a specific version of 
the Unicode Character Database (UCD) and other information, see:

http://www.unicode.org/ucd/

If you accessed this file via the URL:

http://www.unicode.org/Public/UNIDATA/ReadMe.txt

then you are looking at the most current version of the UCD. 
Otherwise the version number of the UCD is part of the path name. 

The file UCD.html in this directory, as well as any file 
headers, where present, also identify the version of the UCD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       D  .   C  ..  D  Digit.plD  Lower.plD  Upper.plD  Fold.pl  E Title.pl                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!

return <<'END';
0030		0
0031		1
0032		2
0033		3
0034		4
0035		5
0036		6
0037		7
0038		8
0039		9
0660		0
0661		1
0662		2
0663		3
0664		4
0665		5
0666		6
0667		7
0668		8
0669		9
06F0		0
06F1		1
06F2		2
06F3		3
06F4		4
06F5		5
06F6		6
06F7		7
06F8		8
06F9		9
0966		0
0967		1
0968		2
0969		3
096A		4
096B		5
096C		6
096D		7
096E		8
096F		9
09E6		0
09E7		1
09E8		2
09E9		3
09EA		4
09EB		5
09EC		6
09ED		7
09EE		8
09EF		9
0A66		0
0A67		1
0A68		2
0A69		3
0A6A		4
0A6B		5
0A6C		6
0A6D		7
0A6E		8
0A6F		9
0AE6		0
0AE7		1
0AE8		2
0AE9		3
0AEA		4
0AEB		5
0AEC		6
0AED		7
0AEE		8
0AEF		9
0B66		0
0B67		1
0B68		2
0B69		3
0B6A		4
0B6B		5
0B6C		6
0B6D		7
0B6E		8
0B6F		9
0BE6		0
0BE7		1
0BE8		2
0BE9		3
0BEA		4
0BEB		5
0BEC		6
0BED		7
0BEE		8
0BEF		9
0C66		0
0C67		1
0C68		2
0C69		3
0C6A		4
0C6B		5
0C6C		6
0C6D		7
0C6E		8
0C6F		9
0CE6		0
0CE7		1
0CE8		2
0CE9		3
0CEA		4
0CEB		5
0CEC		6
0CED		7
0CEE		8
0CEF		9
0D66		0
0D67		1
0D68		2
0D69		3
0D6A		4
0D6B		5
0D6C		6
0D6D		7
0D6E		8
0D6F		9
0E50		0
0E51		1
0E52		2
0E53		3
0E54		4
0E55		5
0E56		6
0E57		7
0E58		8
0E59		9
0ED0		0
0ED1		1
0ED2		2
0ED3		3
0ED4		4
0ED5		5
0ED6		6
0ED7		7
0ED8		8
0ED9		9
0F20		0
0F21		1
0F22		2
0F23		3
0F24		4
0F25		5
0F26		6
0F27		7
0F28		8
0F29		9
1040		0
1041		1
1042		2
1043		3
1044		4
1045		5
1046		6
1047		7
1048		8
1049		9
17E0		0
17E1		1
17E2		2
17E3		3
17E4		4
17E5		5
17E6		6
17E7		7
17E8		8
17E9		9
1810		0
1811		1
1812		2
1813		3
1814		4
1815		5
1816		6
1817		7
1818		8
1819		9
1946		0
1947		1
1948		2
1949		3
194A		4
194B		5
194C		6
194D		7
194E		8
194F		9
19D0		0
19D1		1
19D2		2
19D3		3
19D4		4
19D5		5
19D6		6
19D7		7
19D8		8
19D9		9
FF10		0
FF11		1
FF12		2
FF13		3
FF14		4
FF15		5
FF16		6
FF17		7
FF18		8
FF19		9
104A0		0
104A1		1
104A2		2
104A3		3
104A4		4
104A5		5
104A6		6
104A7		7
104A8		8
104A9		9
1D7CE		0
1D7CF		1
1D7D0		2
1D7D1		3
1D7D2		4
1D7D3		5
1D7D4		6
1D7D5		7
1D7D6		8
1D7D7		9
1D7D8		0
1D7D9		1
1D7DA		2
1D7DB		3
1D7DC		4
1D7DD		5
1D7DE		6
1D7DF		7
1D7E0		8
1D7E1		9
1D7E2		0
1D7E3		1
1D7E4		2
1D7E5		3
1D7E6		4
1D7E7		5
1D7E8		6
1D7E9		7
1D7EA		8
1D7EB		9
1D7EC		0
1D7ED		1
1D7EE		2
1D7EF		3
1D7F0		4
1D7F1		5
1D7F2		6
1D7F3		7
1D7F4		8
1D7F5		9
1D7F6		0
1D7F7		1
1D7F8		2
1D7F9		3
1D7FA		4
1D7FB		5
1D7FC		6
1D7FD		7
1D7FE		8
1D7FF		9
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!


# The key UTF-8 _bytes_, the value UTF-8 (speed hack)
%utf8::ToSpecLower =
(
"\xC4\xB0" => "\x{0069}\x{0307}",
"\xE1\xBE\x88" => "\x{1F80}",
"\xE1\xBE\x89" => "\x{1F81}",
"\xE1\xBE\x8A" => "\x{1F82}",
"\xE1\xBE\x8B" => "\x{1F83}",
"\xE1\xBE\x8C" => "\x{1F84}",
"\xE1\xBE\x8D" => "\x{1F85}",
"\xE1\xBE\x8E" => "\x{1F86}",
"\xE1\xBE\x8F" => "\x{1F87}",
"\xE1\xBE\x98" => "\x{1F90}",
"\xE1\xBE\x99" => "\x{1F91}",
"\xE1\xBE\x9A" => "\x{1F92}",
"\xE1\xBE\x9B" => "\x{1F93}",
"\xE1\xBE\x9C" => "\x{1F94}",
"\xE1\xBE\x9D" => "\x{1F95}",
"\xE1\xBE\x9E" => "\x{1F96}",
"\xE1\xBE\x9F" => "\x{1F97}",
"\xE1\xBE\xA8" => "\x{1FA0}",
"\xE1\xBE\xA9" => "\x{1FA1}",
"\xE1\xBE\xAA" => "\x{1FA2}",
"\xE1\xBE\xAB" => "\x{1FA3}",
"\xE1\xBE\xAC" => "\x{1FA4}",
"\xE1\xBE\xAD" => "\x{1FA5}",
"\xE1\xBE\xAE" => "\x{1FA6}",
"\xE1\xBE\xAF" => "\x{1FA7}",
"\xE1\xBE\xBC" => "\x{1FB3}",
"\xE1\xBF\x8C" => "\x{1FC3}",
"\xE1\xBF\xBC" => "\x{1FF3}",
);

return <<'END';
0041		0061
0042		0062
0043		0063
0044		0064
0045		0065
0046		0066
0047		0067
0048		0068
0049		0069
004A		006A
004B		006B
004C		006C
004D		006D
004E		006E
004F		006F
0050		0070
0051		0071
0052		0072
0053		0073
0054		0074
0055		0075
0056		0076
0057		0077
0058		0078
0059		0079
005A		007A
00C0		00E0
00C1		00E1
00C2		00E2
00C3		00E3
00C4		00E4
00C5		00E5
00C6		00E6
00C7		00E7
00C8		00E8
00C9		00E9
00CA		00EA
00CB		00EB
00CC		00EC
00CD		00ED
00CE		00EE
00CF		00EF
00D0		00F0
00D1		00F1
00D2		00F2
00D3		00F3
00D4		00F4
00D5		00F5
00D6		00F6
00D8		00F8
00D9		00F9
00DA		00FA
00DB		00FB
00DC		00FC
00DD		00FD
00DE		00FE
0100		0101
0102		0103
0104		0105
0106		0107
0108		0109
010A		010B
010C		010D
010E		010F
0110		0111
0112		0113
0114		0115
0116		0117
0118		0119
011A		011B
011C		011D
011E		011F
0120		0121
0122		0123
0124		0125
0126		0127
0128		0129
012A		012B
012C		012D
012E		012F
0132		0133
0134		0135
0136		0137
0139		013A
013B		013C
013D		013E
013F		0140
0141		0142
0143		0144
0145		0146
0147		0148
014A		014B
014C		014D
014E		014F
0150		0151
0152		0153
0154		0155
0156		0157
0158		0159
015A		015B
015C		015D
015E		015F
0160		0161
0162		0163
0164		0165
0166		0167
0168		0169
016A		016B
016C		016D
016E		016F
0170		0171
0172		0173
0174		0175
0176		0177
0178		00FF
0179		017A
017B		017C
017D		017E
0181		0253
0182		0183
0184		0185
0186		0254
0187		0188
0189		0256
018A		0257
018B		018C
018E		01DD
018F		0259
0190		025B
0191		0192
0193		0260
0194		0263
0196		0269
0197		0268
0198		0199
019C		026F
019D		0272
019F		0275
01A0		01A1
01A2		01A3
01A4		01A5
01A6		0280
01A7		01A8
01A9		0283
01AC		01AD
01AE		0288
01AF		01B0
01B1		028A
01B2		028B
01B3		01B4
01B5		01B6
01B7		0292
01B8		01B9
01BC		01BD
01C4		01C6
01C5		01C6
01C7		01C9
01C8		01C9
01CA		01CC
01CB		01CC
01CD		01CE
01CF		01D0
01D1		01D2
01D3		01D4
01D5		01D6
01D7		01D8
01D9		01DA
01DB		01DC
01DE		01DF
01E0		01E1
01E2		01E3
01E4		01E5
01E6		01E7
01E8		01E9
01EA		01EB
01EC		01ED
01EE		01EF
01F1		01F3
01F2		01F3
01F4		01F5
01F6		0195
01F7		01BF
01F8		01F9
01FA		01FB
01FC		01FD
01FE		01FF
0200		0201
0202		0203
0204		0205
0206		0207
0208		0209
020A		020B
020C		020D
020E		020F
0210		0211
0212		0213
0214		0215
0216		0217
0218		0219
021A		021B
021C		021D
021E		021F
0220		019E
0222		0223
0224		0225
0226		0227
0228		0229
022A		022B
022C		022D
022E		022F
0230		0231
0232		0233
023B		023C
023D		019A
0241		0294
0386		03AC
0388		03AD
0389		03AE
038A		03AF
038C		03CC
038E		03CD
038F		03CE
0391		03B1
0392		03B2
0393		03B3
0394		03B4
0395		03B5
0396		03B6
0397		03B7
0398		03B8
0399		03B9
039A		03BA
039B		03BB
039C		03BC
039D		03BD
039E		03BE
039F		03BF
03A0		03C0
03A1		03C1
03A3		03C3
03A4		03C4
03A5		03C5
03A6		03C6
03A7		03C7
03A8		03C8
03A9		03C9
03AA		03CA
03AB		03CB
03D8		03D9
03DA		03DB
03DC		03DD
03DE		03DF
03E0		03E1
03E2		03E3
03E4		03E5
03E6		03E7
03E8		03E9
03EA		03EB
03EC		03ED
03EE		03EF
03F4		03B8
03F7		03F8
03F9		03F2
03FA		03FB
0400		0450
0401		0451
0402		0452
0403		0453
0404		0454
0405		0455
0406		0456
0407		0457
0408		0458
0409		0459
040A		045A
040B		045B
040C		045C
040D		045D
040E		045E
040F		045F
0410		0430
0411		0431
0412		0432
0413		0433
0414		0434
0415		0435
0416		0436
0417		0437
0418		0438
0419		0439
041A		043A
041B		043B
041C		043C
041D		043D
041E		043E
041F		043F
0420		0440
0421		0441
0422		0442
0423		0443
0424		0444
0425		0445
0426		0446
0427		0447
0428		0448
0429		0449
042A		044A
042B		044B
042C		044C
042D		044D
042E		044E
042F		044F
0460		0461
0462		0463
0464		0465
0466		0467
0468		0469
046A		046B
046C		046D
046E		046F
0470		0471
0472		0473
0474		0475
0476		0477
0478		0479
047A		047B
047C		047D
047E		047F
0480		0481
048A		048B
048C		048D
048E		048F
0490		0491
0492		0493
0494		0495
0496		0497
0498		0499
049A		049B
049C		049D
049E		049F
04A0		04A1
04A2		04A3
04A4		04A5
04A6		04A7
04A8		04A9
04AA		04AB
04AC		04AD
04AE		04AF
04B0		04B1
04B2		04B3
04B4		04B5
04B6		04B7
04B8		04B9
04BA		04BB
04BC		04BD
04BE		04BF
04C1		04C2
04C3		04C4
04C5		04C6
04C7		04C8
04C9		04CA
04CB		04CC
04CD		04CE
04D0		04D1
04D2		04D3
04D4		04D5
04D6		04D7
04D8		04D9
04DA		04DB
04DC		04DD
04DE		04DF
04E0		04E1
04E2		04E3
04E4		04E5
04E6		04E7
04E8		04E9
04EA		04EB
04EC		04ED
04EE		04EF
04F0		04F1
04F2		04F3
04F4		04F5
04F6		04F7
04F8		04F9
0500		0501
0502		0503
0504		0505
0506		0507
0508		0509
050A		050B
050C		050D
050E		050F
0531		0561
0532		0562
0533		0563
0534		0564
0535		0565
0536		0566
0537		0567
0538		0568
0539		0569
053A		056A
053B		056B
053C		056C
053D		056D
053E		056E
053F		056F
0540		0570
0541		0571
0542		0572
0543		0573
0544		0574
0545		0575
0546		0576
0547		0577
0548		0578
0549		0579
054A		057A
054B		057B
054C		057C
054D		057D
054E		057E
054F		057F
0550		0580
0551		0581
0552		0582
0553		0583
0554		0584
0555		0585
0556		0586
10A0		2D00
10A1		2D01
10A2		2D02
10A3		2D03
10A4		2D04
10A5		2D05
10A6		2D06
10A7		2D07
10A8		2D08
10A9		2D09
10AA		2D0A
10AB		2D0B
10AC		2D0C
10AD		2D0D
10AE		2D0E
10AF		2D0F
10B0		2D10
10B1		2D11
10B2		2D12
10B3		2D13
10B4		2D14
10B5		2D15
10B6		2D16
10B7		2D17
10B8		2D18
10B9		2D19
10BA		2D1A
10BB		2D1B
10BC		2D1C
10BD		2D1D
10BE		2D1E
10BF		2D1F
10C0		2D20
10C1		2D21
10C2		2D22
10C3		2D23
10C4		2D24
10C5		2D25
1E00		1E01
1E02		1E03
1E04		1E05
1E06		1E07
1E08		1E09
1E0A		1E0B
1E0C		1E0D
1E0E		1E0F
1E10		1E11
1E12		1E13
1E14		1E15
1E16		1E17
1E18		1E19
1E1A		1E1B
1E1C		1E1D
1E1E		1E1F
1E20		1E21
1E22		1E23
1E24		1E25
1E26		1E27
1E28		1E29
1E2A		1E2B
1E2C		1E2D
1E2E		1E2F
1E30		1E31
1E32		1E33
1E34		1E35
1E36		1E37
1E38		1E39
1E3A		1E3B
1E3C		1E3D
1E3E		1E3F
1E40		1E41
1E42		1E43
1E44		1E45
1E46		1E47
1E48		1E49
1E4A		1E4B
1E4C		1E4D
1E4E		1E4F
1E50		1E51
1E52		1E53
1E54		1E55
1E56		1E57
1E58		1E59
1E5A		1E5B
1E5C		1E5D
1E5E		1E5F
1E60		1E61
1E62		1E63
1E64		1E65
1E66		1E67
1E68		1E69
1E6A		1E6B
1E6C		1E6D
1E6E		1E6F
1E70		1E71
1E72		1E73
1E74		1E75
1E76		1E77
1E78		1E79
1E7A		1E7B
1E7C		1E7D
1E7E		1E7F
1E80		1E81
1E82		1E83
1E84		1E85
1E86		1E87
1E88		1E89
1E8A		1E8B
1E8C		1E8D
1E8E		1E8F
1E90		1E91
1E92		1E93
1E94		1E95
1EA0		1EA1
1EA2		1EA3
1EA4		1EA5
1EA6		1EA7
1EA8		1EA9
1EAA		1EAB
1EAC		1EAD
1EAE		1EAF
1EB0		1EB1
1EB2		1EB3
1EB4		1EB5
1EB6		1EB7
1EB8		1EB9
1EBA		1EBB
1EBC		1EBD
1EBE		1EBF
1EC0		1EC1
1EC2		1EC3
1EC4		1EC5
1EC6		1EC7
1EC8		1EC9
1ECA		1ECB
1ECC		1ECD
1ECE		1ECF
1ED0		1ED1
1ED2		1ED3
1ED4		1ED5
1ED6		1ED7
1ED8		1ED9
1EDA		1EDB
1EDC		1EDD
1EDE		1EDF
1EE0		1EE1
1EE2		1EE3
1EE4		1EE5
1EE6		1EE7
1EE8		1EE9
1EEA		1EEB
1EEC		1EED
1EEE		1EEF
1EF0		1EF1
1EF2		1EF3
1EF4		1EF5
1EF6		1EF7
1EF8		1EF9
1F08		1F00
1F09		1F01
1F0A		1F02
1F0B		1F03
1F0C		1F04
1F0D		1F05
1F0E		1F06
1F0F		1F07
1F18		1F10
1F19		1F11
1F1A		1F12
1F1B		1F13
1F1C		1F14
1F1D		1F15
1F28		1F20
1F29		1F21
1F2A		1F22
1F2B		1F23
1F2C		1F24
1F2D		1F25
1F2E		1F26
1F2F		1F27
1F38		1F30
1F39		1F31
1F3A		1F32
1F3B		1F33
1F3C		1F34
1F3D		1F35
1F3E		1F36
1F3F		1F37
1F48		1F40
1F49		1F41
1F4A		1F42
1F4B		1F43
1F4C		1F44
1F4D		1F45
1F59		1F51
1F5B		1F53
1F5D		1F55
1F5F		1F57
1F68		1F60
1F69		1F61
1F6A		1F62
1F6B		1F63
1F6C		1F64
1F6D		1F65
1F6E		1F66
1F6F		1F67
1FB8		1FB0
1FB9		1FB1
1FBA		1F70
1FBB		1F71
1FC8		1F72
1FC9		1F73
1FCA		1F74
1FCB		1F75
1FD8		1FD0
1FD9		1FD1
1FDA		1F76
1FDB		1F77
1FE8		1FE0
1FE9		1FE1
1FEA		1F7A
1FEB		1F7B
1FEC		1FE5
1FF8		1F78
1FF9		1F79
1FFA		1F7C
1FFB		1F7D
2126		03C9
212A		006B
212B		00E5
2160		2170
2161		2171
2162		2172
2163		2173
2164		2174
2165		2175
2166		2176
2167		2177
2168		2178
2169		2179
216A		217A
216B		217B
216C		217C
216D		217D
216E		217E
216F		217F
24B6		24D0
24B7		24D1
24B8		24D2
24B9		24D3
24BA		24D4
24BB		24D5
24BC		24D6
24BD		24D7
24BE		24D8
24BF		24D9
24C0		24DA
24C1		24DB
24C2		24DC
24C3		24DD
24C4		24DE
24C5		24DF
24C6		24E0
24C7		24E1
24C8		24E2
24C9		24E3
24CA		24E4
24CB		24E5
24CC		24E6
24CD		24E7
24CE		24E8
24CF		24E9
2C00		2C30
2C01		2C31
2C02		2C32
2C03		2C33
2C04		2C34
2C05		2C35
2C06		2C36
2C07		2C37
2C08		2C38
2C09		2C39
2C0A		2C3A
2C0B		2C3B
2C0C		2C3C
2C0D		2C3D
2C0E		2C3E
2C0F		2C3F
2C10		2C40
2C11		2C41
2C12		2C42
2C13		2C43
2C14		2C44
2C15		2C45
2C16		2C46
2C17		2C47
2C18		2C48
2C19		2C49
2C1A		2C4A
2C1B		2C4B
2C1C		2C4C
2C1D		2C4D
2C1E		2C4E
2C1F		2C4F
2C20		2C50
2C21		2C51
2C22		2C52
2C23		2C53
2C24		2C54
2C25		2C55
2C26		2C56
2C27		2C57
2C28		2C58
2C29		2C59
2C2A		2C5A
2C2B		2C5B
2C2C		2C5C
2C2D		2C5D
2C2E		2C5E
2C80		2C81
2C82		2C83
2C84		2C85
2C86		2C87
2C88		2C89
2C8A		2C8B
2C8C		2C8D
2C8E		2C8F
2C90		2C91
2C92		2C93
2C94		2C95
2C96		2C97
2C98		2C99
2C9A		2C9B
2C9C		2C9D
2C9E		2C9F
2CA0		2CA1
2CA2		2CA3
2CA4		2CA5
2CA6		2CA7
2CA8		2CA9
2CAA		2CAB
2CAC		2CAD
2CAE		2CAF
2CB0		2CB1
2CB2		2CB3
2CB4		2CB5
2CB6		2CB7
2CB8		2CB9
2CBA		2CBB
2CBC		2CBD
2CBE		2CBF
2CC0		2CC1
2CC2		2CC3
2CC4		2CC5
2CC6		2CC7
2CC8		2CC9
2CCA		2CCB
2CCC		2CCD
2CCE		2CCF
2CD0		2CD1
2CD2		2CD3
2CD4		2CD5
2CD6		2CD7
2CD8		2CD9
2CDA		2CDB
2CDC		2CDD
2CDE		2CDF
2CE0		2CE1
2CE2		2CE3
FF21		FF41
FF22		FF42
FF23		FF43
FF24		FF44
FF25		FF45
FF26		FF46
FF27		FF47
FF28		FF48
FF29		FF49
FF2A		FF4A
FF2B		FF4B
FF2C		FF4C
FF2D		FF4D
FF2E		FF4E
FF2F		FF4F
FF30		FF50
FF31		FF51
FF32		FF52
FF33		FF53
FF34		FF54
FF35		FF55
FF36		FF56
FF37		FF57
FF38		FF58
FF39		FF59
FF3A		FF5A
10400		10428
10401		10429
10402		1042A
10403		1042B
10404		1042C
10405		1042D
10406		1042E
10407		1042F
10408		10430
10409		10431
1040A		10432
1040B		10433
1040C		10434
1040D		10435
1040E		10436
1040F		10437
10410		10438
10411		10439
10412		1043A
10413		1043B
10414		1043C
10415		1043D
10416		1043E
10417		1043F
10418		10440
10419		10441
1041A		10442
1041B		10443
1041C		10444
1041D		10445
1041E		10446
1041F		10447
10420		10448
10421		10449
10422		1044A
10423		1044B
10424		1044C
10425		1044D
10426		1044E
10427		1044F
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!


# The key UTF-8 _bytes_, the value UTF-8 (speed hack)
%utf8::ToSpecUpper =
(
"\xC3\x9F" => "\x{0053}\x{0053}",
"\xC5\x89" => "\x{02BC}\x{004E}",
"\xC7\xB0" => "\x{004A}\x{030C}",
"\xCE\x90" => "\x{0399}\x{0308}\x{0301}",
"\xCE\xB0" => "\x{03A5}\x{0308}\x{0301}",
"\xD6\x87" => "\x{0535}\x{0552}",
"\xE1\xBA\x96" => "\x{0048}\x{0331}",
"\xE1\xBA\x97" => "\x{0054}\x{0308}",
"\xE1\xBA\x98" => "\x{0057}\x{030A}",
"\xE1\xBA\x99" => "\x{0059}\x{030A}",
"\xE1\xBA\x9A" => "\x{0041}\x{02BE}",
"\xE1\xBD\x90" => "\x{03A5}\x{0313}",
"\xE1\xBD\x92" => "\x{03A5}\x{0313}\x{0300}",
"\xE1\xBD\x94" => "\x{03A5}\x{0313}\x{0301}",
"\xE1\xBD\x96" => "\x{03A5}\x{0313}\x{0342}",
"\xE1\xBE\x80" => "\x{1F08}\x{0399}",
"\xE1\xBE\x81" => "\x{1F09}\x{0399}",
"\xE1\xBE\x82" => "\x{1F0A}\x{0399}",
"\xE1\xBE\x83" => "\x{1F0B}\x{0399}",
"\xE1\xBE\x84" => "\x{1F0C}\x{0399}",
"\xE1\xBE\x85" => "\x{1F0D}\x{0399}",
"\xE1\xBE\x86" => "\x{1F0E}\x{0399}",
"\xE1\xBE\x87" => "\x{1F0F}\x{0399}",
"\xE1\xBE\x88" => "\x{1F08}\x{0399}",
"\xE1\xBE\x89" => "\x{1F09}\x{0399}",
"\xE1\xBE\x8A" => "\x{1F0A}\x{0399}",
"\xE1\xBE\x8B" => "\x{1F0B}\x{0399}",
"\xE1\xBE\x8C" => "\x{1F0C}\x{0399}",
"\xE1\xBE\x8D" => "\x{1F0D}\x{0399}",
"\xE1\xBE\x8E" => "\x{1F0E}\x{0399}",
"\xE1\xBE\x8F" => "\x{1F0F}\x{0399}",
"\xE1\xBE\x90" => "\x{1F28}\x{0399}",
"\xE1\xBE\x91" => "\x{1F29}\x{0399}",
"\xE1\xBE\x92" => "\x{1F2A}\x{0399}",
"\xE1\xBE\x93" => "\x{1F2B}\x{0399}",
"\xE1\xBE\x94" => "\x{1F2C}\x{0399}",
"\xE1\xBE\x95" => "\x{1F2D}\x{0399}",
"\xE1\xBE\x96" => "\x{1F2E}\x{0399}",
"\xE1\xBE\x97" => "\x{1F2F}\x{0399}",
"\xE1\xBE\x98" => "\x{1F28}\x{0399}",
"\xE1\xBE\x99" => "\x{1F29}\x{0399}",
"\xE1\xBE\x9A" => "\x{1F2A}\x{0399}",
"\xE1\xBE\x9B" => "\x{1F2B}\x{0399}",
"\xE1\xBE\x9C" => "\x{1F2C}\x{0399}",
"\xE1\xBE\x9D" => "\x{1F2D}\x{0399}",
"\xE1\xBE\x9E" => "\x{1F2E}\x{0399}",
"\xE1\xBE\x9F" => "\x{1F2F}\x{0399}",
"\xE1\xBE\xA0" => "\x{1F68}\x{0399}",
"\xE1\xBE\xA1" => "\x{1F69}\x{0399}",
"\xE1\xBE\xA2" => "\x{1F6A}\x{0399}",
"\xE1\xBE\xA3" => "\x{1F6B}\x{0399}",
"\xE1\xBE\xA4" => "\x{1F6C}\x{0399}",
"\xE1\xBE\xA5" => "\x{1F6D}\x{0399}",
"\xE1\xBE\xA6" => "\x{1F6E}\x{0399}",
"\xE1\xBE\xA7" => "\x{1F6F}\x{0399}",
"\xE1\xBE\xA8" => "\x{1F68}\x{0399}",
"\xE1\xBE\xA9" => "\x{1F69}\x{0399}",
"\xE1\xBE\xAA" => "\x{1F6A}\x{0399}",
"\xE1\xBE\xAB" => "\x{1F6B}\x{0399}",
"\xE1\xBE\xAC" => "\x{1F6C}\x{0399}",
"\xE1\xBE\xAD" => "\x{1F6D}\x{0399}",
"\xE1\xBE\xAE" => "\x{1F6E}\x{0399}",
"\xE1\xBE\xAF" => "\x{1F6F}\x{0399}",
"\xE1\xBE\xB2" => "\x{1FBA}\x{0399}",
"\xE1\xBE\xB3" => "\x{0391}\x{0399}",
"\xE1\xBE\xB4" => "\x{0386}\x{0399}",
"\xE1\xBE\xB6" => "\x{0391}\x{0342}",
"\xE1\xBE\xB7" => "\x{0391}\x{0342}\x{0399}",
"\xE1\xBE\xBC" => "\x{0391}\x{0399}",
"\xE1\xBF\x82" => "\x{1FCA}\x{0399}",
"\xE1\xBF\x83" => "\x{0397}\x{0399}",
"\xE1\xBF\x84" => "\x{0389}\x{0399}",
"\xE1\xBF\x86" => "\x{0397}\x{0342}",
"\xE1\xBF\x87" => "\x{0397}\x{0342}\x{0399}",
"\xE1\xBF\x8C" => "\x{0397}\x{0399}",
"\xE1\xBF\x92" => "\x{0399}\x{0308}\x{0300}",
"\xE1\xBF\x93" => "\x{0399}\x{0308}\x{0301}",
"\xE1\xBF\x96" => "\x{0399}\x{0342}",
"\xE1\xBF\x97" => "\x{0399}\x{0308}\x{0342}",
"\xE1\xBF\xA2" => "\x{03A5}\x{0308}\x{0300}",
"\xE1\xBF\xA3" => "\x{03A5}\x{0308}\x{0301}",
"\xE1\xBF\xA4" => "\x{03A1}\x{0313}",
"\xE1\xBF\xA6" => "\x{03A5}\x{0342}",
"\xE1\xBF\xA7" => "\x{03A5}\x{0308}\x{0342}",
"\xE1\xBF\xB2" => "\x{1FFA}\x{0399}",
"\xE1\xBF\xB3" => "\x{03A9}\x{0399}",
"\xE1\xBF\xB4" => "\x{038F}\x{0399}",
"\xE1\xBF\xB6" => "\x{03A9}\x{0342}",
"\xE1\xBF\xB7" => "\x{03A9}\x{0342}\x{0399}",
"\xE1\xBF\xBC" => "\x{03A9}\x{0399}",
"\xEF\xAC\x80" => "\x{0046}\x{0046}",
"\xEF\xAC\x81" => "\x{0046}\x{0049}",
"\xEF\xAC\x82" => "\x{0046}\x{004C}",
"\xEF\xAC\x83" => "\x{0046}\x{0046}\x{0049}",
"\xEF\xAC\x84" => "\x{0046}\x{0046}\x{004C}",
"\xEF\xAC\x85" => "\x{0053}\x{0054}",
"\xEF\xAC\x86" => "\x{0053}\x{0054}",
"\xEF\xAC\x93" => "\x{0544}\x{0546}",
"\xEF\xAC\x94" => "\x{0544}\x{0535}",
"\xEF\xAC\x95" => "\x{0544}\x{053B}",
"\xEF\xAC\x96" => "\x{054E}\x{0546}",
"\xEF\xAC\x97" => "\x{0544}\x{053D}",
);

return <<'END';
0061		0041
0062		0042
0063		0043
0064		0044
0065		0045
0066		0046
0067		0047
0068		0048
0069		0049
006A		004A
006B		004B
006C		004C
006D		004D
006E		004E
006F		004F
0070		0050
0071		0051
0072		0052
0073		0053
0074		0054
0075		0055
0076		0056
0077		0057
0078		0058
0079		0059
007A		005A
00B5		039C
00E0		00C0
00E1		00C1
00E2		00C2
00E3		00C3
00E4		00C4
00E5		00C5
00E6		00C6
00E7		00C7
00E8		00C8
00E9		00C9
00EA		00CA
00EB		00CB
00EC		00CC
00ED		00CD
00EE		00CE
00EF		00CF
00F0		00D0
00F1		00D1
00F2		00D2
00F3		00D3
00F4		00D4
00F5		00D5
00F6		00D6
00F8		00D8
00F9		00D9
00FA		00DA
00FB		00DB
00FC		00DC
00FD		00DD
00FE		00DE
00FF		0178
0101		0100
0103		0102
0105		0104
0107		0106
0109		0108
010B		010A
010D		010C
010F		010E
0111		0110
0113		0112
0115		0114
0117		0116
0119		0118
011B		011A
011D		011C
011F		011E
0121		0120
0123		0122
0125		0124
0127		0126
0129		0128
012B		012A
012D		012C
012F		012E
0131		0049
0133		0132
0135		0134
0137		0136
013A		0139
013C		013B
013E		013D
0140		013F
0142		0141
0144		0143
0146		0145
0148		0147
014B		014A
014D		014C
014F		014E
0151		0150
0153		0152
0155		0154
0157		0156
0159		0158
015B		015A
015D		015C
015F		015E
0161		0160
0163		0162
0165		0164
0167		0166
0169		0168
016B		016A
016D		016C
016F		016E
0171		0170
0173		0172
0175		0174
0177		0176
017A		0179
017C		017B
017E		017D
017F		0053
0183		0182
0185		0184
0188		0187
018C		018B
0192		0191
0195		01F6
0199		0198
019A		023D
019E		0220
01A1		01A0
01A3		01A2
01A5		01A4
01A8		01A7
01AD		01AC
01B0		01AF
01B4		01B3
01B6		01B5
01B9		01B8
01BD		01BC
01BF		01F7
01C5		01C4
01C6		01C4
01C8		01C7
01C9		01C7
01CB		01CA
01CC		01CA
01CE		01CD
01D0		01CF
01D2		01D1
01D4		01D3
01D6		01D5
01D8		01D7
01DA		01D9
01DC		01DB
01DD		018E
01DF		01DE
01E1		01E0
01E3		01E2
01E5		01E4
01E7		01E6
01E9		01E8
01EB		01EA
01ED		01EC
01EF		01EE
01F2		01F1
01F3		01F1
01F5		01F4
01F9		01F8
01FB		01FA
01FD		01FC
01FF		01FE
0201		0200
0203		0202
0205		0204
0207		0206
0209		0208
020B		020A
020D		020C
020F		020E
0211		0210
0213		0212
0215		0214
0217		0216
0219		0218
021B		021A
021D		021C
021F		021E
0223		0222
0225		0224
0227		0226
0229		0228
022B		022A
022D		022C
022F		022E
0231		0230
0233		0232
023C		023B
0253		0181
0254		0186
0256		0189
0257		018A
0259		018F
025B		0190
0260		0193
0263		0194
0268		0197
0269		0196
026F		019C
0272		019D
0275		019F
0280		01A6
0283		01A9
0288		01AE
028A		01B1
028B		01B2
0292		01B7
0294		0241
0345		0399
03AC		0386
03AD		0388
03AE		0389
03AF		038A
03B1		0391
03B2		0392
03B3		0393
03B4		0394
03B5		0395
03B6		0396
03B7		0397
03B8		0398
03B9		0399
03BA		039A
03BB		039B
03BC		039C
03BD		039D
03BE		039E
03BF		039F
03C0		03A0
03C1		03A1
03C2		03A3
03C3		03A3
03C4		03A4
03C5		03A5
03C6		03A6
03C7		03A7
03C8		03A8
03C9		03A9
03CA		03AA
03CB		03AB
03CC		038C
03CD		038E
03CE		038F
03D0		0392
03D1		0398
03D5		03A6
03D6		03A0
03D9		03D8
03DB		03DA
03DD		03DC
03DF		03DE
03E1		03E0
03E3		03E2
03E5		03E4
03E7		03E6
03E9		03E8
03EB		03EA
03ED		03EC
03EF		03EE
03F0		039A
03F1		03A1
03F2		03F9
03F5		0395
03F8		03F7
03FB		03FA
0430		0410
0431		0411
0432		0412
0433		0413
0434		0414
0435		0415
0436		0416
0437		0417
0438		0418
0439		0419
043A		041A
043B		041B
043C		041C
043D		041D
043E		041E
043F		041F
0440		0420
0441		0421
0442		0422
0443		0423
0444		0424
0445		0425
0446		0426
0447		0427
0448		0428
0449		0429
044A		042A
044B		042B
044C		042C
044D		042D
044E		042E
044F		042F
0450		0400
0451		0401
0452		0402
0453		0403
0454		0404
0455		0405
0456		0406
0457		0407
0458		0408
0459		0409
045A		040A
045B		040B
045C		040C
045D		040D
045E		040E
045F		040F
0461		0460
0463		0462
0465		0464
0467		0466
0469		0468
046B		046A
046D		046C
046F		046E
0471		0470
0473		0472
0475		0474
0477		0476
0479		0478
047B		047A
047D		047C
047F		047E
0481		0480
048B		048A
048D		048C
048F		048E
0491		0490
0493		0492
0495		0494
0497		0496
0499		0498
049B		049A
049D		049C
049F		049E
04A1		04A0
04A3		04A2
04A5		04A4
04A7		04A6
04A9		04A8
04AB		04AA
04AD		04AC
04AF		04AE
04B1		04B0
04B3		04B2
04B5		04B4
04B7		04B6
04B9		04B8
04BB		04BA
04BD		04BC
04BF		04BE
04C2		04C1
04C4		04C3
04C6		04C5
04C8		04C7
04CA		04C9
04CC		04CB
04CE		04CD
04D1		04D0
04D3		04D2
04D5		04D4
04D7		04D6
04D9		04D8
04DB		04DA
04DD		04DC
04DF		04DE
04E1		04E0
04E3		04E2
04E5		04E4
04E7		04E6
04E9		04E8
04EB		04EA
04ED		04EC
04EF		04EE
04F1		04F0
04F3		04F2
04F5		04F4
04F7		04F6
04F9		04F8
0501		0500
0503		0502
0505		0504
0507		0506
0509		0508
050B		050A
050D		050C
050F		050E
0561		0531
0562		0532
0563		0533
0564		0534
0565		0535
0566		0536
0567		0537
0568		0538
0569		0539
056A		053A
056B		053B
056C		053C
056D		053D
056E		053E
056F		053F
0570		0540
0571		0541
0572		0542
0573		0543
0574		0544
0575		0545
0576		0546
0577		0547
0578		0548
0579		0549
057A		054A
057B		054B
057C		054C
057D		054D
057E		054E
057F		054F
0580		0550
0581		0551
0582		0552
0583		0553
0584		0554
0585		0555
0586		0556
1E01		1E00
1E03		1E02
1E05		1E04
1E07		1E06
1E09		1E08
1E0B		1E0A
1E0D		1E0C
1E0F		1E0E
1E11		1E10
1E13		1E12
1E15		1E14
1E17		1E16
1E19		1E18
1E1B		1E1A
1E1D		1E1C
1E1F		1E1E
1E21		1E20
1E23		1E22
1E25		1E24
1E27		1E26
1E29		1E28
1E2B		1E2A
1E2D		1E2C
1E2F		1E2E
1E31		1E30
1E33		1E32
1E35		1E34
1E37		1E36
1E39		1E38
1E3B		1E3A
1E3D		1E3C
1E3F		1E3E
1E41		1E40
1E43		1E42
1E45		1E44
1E47		1E46
1E49		1E48
1E4B		1E4A
1E4D		1E4C
1E4F		1E4E
1E51		1E50
1E53		1E52
1E55		1E54
1E57		1E56
1E59		1E58
1E5B		1E5A
1E5D		1E5C
1E5F		1E5E
1E61		1E60
1E63		1E62
1E65		1E64
1E67		1E66
1E69		1E68
1E6B		1E6A
1E6D		1E6C
1E6F		1E6E
1E71		1E70
1E73		1E72
1E75		1E74
1E77		1E76
1E79		1E78
1E7B		1E7A
1E7D		1E7C
1E7F		1E7E
1E81		1E80
1E83		1E82
1E85		1E84
1E87		1E86
1E89		1E88
1E8B		1E8A
1E8D		1E8C
1E8F		1E8E
1E91		1E90
1E93		1E92
1E95		1E94
1E9B		1E60
1EA1		1EA0
1EA3		1EA2
1EA5		1EA4
1EA7		1EA6
1EA9		1EA8
1EAB		1EAA
1EAD		1EAC
1EAF		1EAE
1EB1		1EB0
1EB3		1EB2
1EB5		1EB4
1EB7		1EB6
1EB9		1EB8
1EBB		1EBA
1EBD		1EBC
1EBF		1EBE
1EC1		1EC0
1EC3		1EC2
1EC5		1EC4
1EC7		1EC6
1EC9		1EC8
1ECB		1ECA
1ECD		1ECC
1ECF		1ECE
1ED1		1ED0
1ED3		1ED2
1ED5		1ED4
1ED7		1ED6
1ED9		1ED8
1EDB		1EDA
1EDD		1EDC
1EDF		1EDE
1EE1		1EE0
1EE3		1EE2
1EE5		1EE4
1EE7		1EE6
1EE9		1EE8
1EEB		1EEA
1EED		1EEC
1EEF		1EEE
1EF1		1EF0
1EF3		1EF2
1EF5		1EF4
1EF7		1EF6
1EF9		1EF8
1F00		1F08
1F01		1F09
1F02		1F0A
1F03		1F0B
1F04		1F0C
1F05		1F0D
1F06		1F0E
1F07		1F0F
1F10		1F18
1F11		1F19
1F12		1F1A
1F13		1F1B
1F14		1F1C
1F15		1F1D
1F20		1F28
1F21		1F29
1F22		1F2A
1F23		1F2B
1F24		1F2C
1F25		1F2D
1F26		1F2E
1F27		1F2F
1F30		1F38
1F31		1F39
1F32		1F3A
1F33		1F3B
1F34		1F3C
1F35		1F3D
1F36		1F3E
1F37		1F3F
1F40		1F48
1F41		1F49
1F42		1F4A
1F43		1F4B
1F44		1F4C
1F45		1F4D
1F51		1F59
1F53		1F5B
1F55		1F5D
1F57		1F5F
1F60		1F68
1F61		1F69
1F62		1F6A
1F63		1F6B
1F64		1F6C
1F65		1F6D
1F66		1F6E
1F67		1F6F
1F70		1FBA
1F71		1FBB
1F72		1FC8
1F73		1FC9
1F74		1FCA
1F75		1FCB
1F76		1FDA
1F77		1FDB
1F78		1FF8
1F79		1FF9
1F7A		1FEA
1F7B		1FEB
1F7C		1FFA
1F7D		1FFB
1FB0		1FB8
1FB1		1FB9
1FBE		0399
1FD0		1FD8
1FD1		1FD9
1FE0		1FE8
1FE1		1FE9
1FE5		1FEC
2170		2160
2171		2161
2172		2162
2173		2163
2174		2164
2175		2165
2176		2166
2177		2167
2178		2168
2179		2169
217A		216A
217B		216B
217C		216C
217D		216D
217E		216E
217F		216F
24D0		24B6
24D1		24B7
24D2		24B8
24D3		24B9
24D4		24BA
24D5		24BB
24D6		24BC
24D7		24BD
24D8		24BE
24D9		24BF
24DA		24C0
24DB		24C1
24DC		24C2
24DD		24C3
24DE		24C4
24DF		24C5
24E0		24C6
24E1		24C7
24E2		24C8
24E3		24C9
24E4		24CA
24E5		24CB
24E6		24CC
24E7		24CD
24E8		24CE
24E9		24CF
2C30		2C00
2C31		2C01
2C32		2C02
2C33		2C03
2C34		2C04
2C35		2C05
2C36		2C06
2C37		2C07
2C38		2C08
2C39		2C09
2C3A		2C0A
2C3B		2C0B
2C3C		2C0C
2C3D		2C0D
2C3E		2C0E
2C3F		2C0F
2C40		2C10
2C41		2C11
2C42		2C12
2C43		2C13
2C44		2C14
2C45		2C15
2C46		2C16
2C47		2C17
2C48		2C18
2C49		2C19
2C4A		2C1A
2C4B		2C1B
2C4C		2C1C
2C4D		2C1D
2C4E		2C1E
2C4F		2C1F
2C50		2C20
2C51		2C21
2C52		2C22
2C53		2C23
2C54		2C24
2C55		2C25
2C56		2C26
2C57		2C27
2C58		2C28
2C59		2C29
2C5A		2C2A
2C5B		2C2B
2C5C		2C2C
2C5D		2C2D
2C5E		2C2E
2C81		2C80
2C83		2C82
2C85		2C84
2C87		2C86
2C89		2C88
2C8B		2C8A
2C8D		2C8C
2C8F		2C8E
2C91		2C90
2C93		2C92
2C95		2C94
2C97		2C96
2C99		2C98
2C9B		2C9A
2C9D		2C9C
2C9F		2C9E
2CA1		2CA0
2CA3		2CA2
2CA5		2CA4
2CA7		2CA6
2CA9		2CA8
2CAB		2CAA
2CAD		2CAC
2CAF		2CAE
2CB1		2CB0
2CB3		2CB2
2CB5		2CB4
2CB7		2CB6
2CB9		2CB8
2CBB		2CBA
2CBD		2CBC
2CBF		2CBE
2CC1		2CC0
2CC3		2CC2
2CC5		2CC4
2CC7		2CC6
2CC9		2CC8
2CCB		2CCA
2CCD		2CCC
2CCF		2CCE
2CD1		2CD0
2CD3		2CD2
2CD5		2CD4
2CD7		2CD6
2CD9		2CD8
2CDB		2CDA
2CDD		2CDC
2CDF		2CDE
2CE1		2CE0
2CE3		2CE2
2D00		10A0
2D01		10A1
2D02		10A2
2D03		10A3
2D04		10A4
2D05		10A5
2D06		10A6
2D07		10A7
2D08		10A8
2D09		10A9
2D0A		10AA
2D0B		10AB
2D0C		10AC
2D0D		10AD
2D0E		10AE
2D0F		10AF
2D10		10B0
2D11		10B1
2D12		10B2
2D13		10B3
2D14		10B4
2D15		10B5
2D16		10B6
2D17		10B7
2D18		10B8
2D19		10B9
2D1A		10BA
2D1B		10BB
2D1C		10BC
2D1D		10BD
2D1E		10BE
2D1F		10BF
2D20		10C0
2D21		10C1
2D22		10C2
2D23		10C3
2D24		10C4
2D25		10C5
FF41		FF21
FF42		FF22
FF43		FF23
FF44		FF24
FF45		FF25
FF46		FF26
FF47		FF27
FF48		FF28
FF49		FF29
FF4A		FF2A
FF4B		FF2B
FF4C		FF2C
FF4D		FF2D
FF4E		FF2E
FF4F		FF2F
FF50		FF30
FF51		FF31
FF52		FF32
FF53		FF33
FF54		FF34
FF55		FF35
FF56		FF36
FF57		FF37
FF58		FF38
FF59		FF39
FF5A		FF3A
10428		10400
10429		10401
1042A		10402
1042B		10403
1042C		10404
1042D		10405
1042E		10406
1042F		10407
10430		10408
10431		10409
10432		1040A
10433		1040B
10434		1040C
10435		1040D
10436		1040E
10437		1040F
10438		10410
10439		10411
1043A		10412
1043B		10413
1043C		10414
1043D		10415
1043E		10416
1043F		10417
10440		10418
10441		10419
10442		1041A
10443		1041B
10444		1041C
10445		1041D
10446		1041E
10447		1041F
10448		10420
10449		10421
1044A		10422
1044B		10423
1044C		10424
1044D		10425
1044E		10426
1044F		10427
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!


#  The ke UTF-8 _bytes_, the value UTF-8 (speed hack)
%utf8::ToSpecFold =
(
"\xC3\x9F" => "\x{0073}\x{0073}",
"\xC4\xB0" => "\x{0069}\x{0307}",
"\xC5\x89" => "\x{02BC}\x{006E}",
"\xC7\xB0" => "\x{006A}\x{030C}",
"\xCE\x90" => "\x{03B9}\x{0308}\x{0301}",
"\xCE\xB0" => "\x{03C5}\x{0308}\x{0301}",
"\xD6\x87" => "\x{0565}\x{0582}",
"\xE1\xBA\x96" => "\x{0068}\x{0331}",
"\xE1\xBA\x97" => "\x{0074}\x{0308}",
"\xE1\xBA\x98" => "\x{0077}\x{030A}",
"\xE1\xBA\x99" => "\x{0079}\x{030A}",
"\xE1\xBA\x9A" => "\x{0061}\x{02BE}",
"\xE1\xBD\x90" => "\x{03C5}\x{0313}",
"\xE1\xBD\x92" => "\x{03C5}\x{0313}\x{0300}",
"\xE1\xBD\x94" => "\x{03C5}\x{0313}\x{0301}",
"\xE1\xBD\x96" => "\x{03C5}\x{0313}\x{0342}",
"\xE1\xBE\x80" => "\x{1F00}\x{03B9}",
"\xE1\xBE\x81" => "\x{1F01}\x{03B9}",
"\xE1\xBE\x82" => "\x{1F02}\x{03B9}",
"\xE1\xBE\x83" => "\x{1F03}\x{03B9}",
"\xE1\xBE\x84" => "\x{1F04}\x{03B9}",
"\xE1\xBE\x85" => "\x{1F05}\x{03B9}",
"\xE1\xBE\x86" => "\x{1F06}\x{03B9}",
"\xE1\xBE\x87" => "\x{1F07}\x{03B9}",
"\xE1\xBE\x88" => "\x{1F00}\x{03B9}",
"\xE1\xBE\x89" => "\x{1F01}\x{03B9}",
"\xE1\xBE\x8A" => "\x{1F02}\x{03B9}",
"\xE1\xBE\x8B" => "\x{1F03}\x{03B9}",
"\xE1\xBE\x8C" => "\x{1F04}\x{03B9}",
"\xE1\xBE\x8D" => "\x{1F05}\x{03B9}",
"\xE1\xBE\x8E" => "\x{1F06}\x{03B9}",
"\xE1\xBE\x8F" => "\x{1F07}\x{03B9}",
"\xE1\xBE\x90" => "\x{1F20}\x{03B9}",
"\xE1\xBE\x91" => "\x{1F21}\x{03B9}",
"\xE1\xBE\x92" => "\x{1F22}\x{03B9}",
"\xE1\xBE\x93" => "\x{1F23}\x{03B9}",
"\xE1\xBE\x94" => "\x{1F24}\x{03B9}",
"\xE1\xBE\x95" => "\x{1F25}\x{03B9}",
"\xE1\xBE\x96" => "\x{1F26}\x{03B9}",
"\xE1\xBE\x97" => "\x{1F27}\x{03B9}",
"\xE1\xBE\x98" => "\x{1F20}\x{03B9}",
"\xE1\xBE\x99" => "\x{1F21}\x{03B9}",
"\xE1\xBE\x9A" => "\x{1F22}\x{03B9}",
"\xE1\xBE\x9B" => "\x{1F23}\x{03B9}",
"\xE1\xBE\x9C" => "\x{1F24}\x{03B9}",
"\xE1\xBE\x9D" => "\x{1F25}\x{03B9}",
"\xE1\xBE\x9E" => "\x{1F26}\x{03B9}",
"\xE1\xBE\x9F" => "\x{1F27}\x{03B9}",
"\xE1\xBE\xA0" => "\x{1F60}\x{03B9}",
"\xE1\xBE\xA1" => "\x{1F61}\x{03B9}",
"\xE1\xBE\xA2" => "\x{1F62}\x{03B9}",
"\xE1\xBE\xA3" => "\x{1F63}\x{03B9}",
"\xE1\xBE\xA4" => "\x{1F64}\x{03B9}",
"\xE1\xBE\xA5" => "\x{1F65}\x{03B9}",
"\xE1\xBE\xA6" => "\x{1F66}\x{03B9}",
"\xE1\xBE\xA7" => "\x{1F67}\x{03B9}",
"\xE1\xBE\xA8" => "\x{1F60}\x{03B9}",
"\xE1\xBE\xA9" => "\x{1F61}\x{03B9}",
"\xE1\xBE\xAA" => "\x{1F62}\x{03B9}",
"\xE1\xBE\xAB" => "\x{1F63}\x{03B9}",
"\xE1\xBE\xAC" => "\x{1F64}\x{03B9}",
"\xE1\xBE\xAD" => "\x{1F65}\x{03B9}",
"\xE1\xBE\xAE" => "\x{1F66}\x{03B9}",
"\xE1\xBE\xAF" => "\x{1F67}\x{03B9}",
"\xE1\xBE\xB2" => "\x{1F70}\x{03B9}",
"\xE1\xBE\xB3" => "\x{03B1}\x{03B9}",
"\xE1\xBE\xB4" => "\x{03AC}\x{03B9}",
"\xE1\xBE\xB6" => "\x{03B1}\x{0342}",
"\xE1\xBE\xB7" => "\x{03B1}\x{0342}\x{03B9}",
"\xE1\xBE\xBC" => "\x{03B1}\x{03B9}",
"\xE1\xBF\x82" => "\x{1F74}\x{03B9}",
"\xE1\xBF\x83" => "\x{03B7}\x{03B9}",
"\xE1\xBF\x84" => "\x{03AE}\x{03B9}",
"\xE1\xBF\x86" => "\x{03B7}\x{0342}",
"\xE1\xBF\x87" => "\x{03B7}\x{0342}\x{03B9}",
"\xE1\xBF\x8C" => "\x{03B7}\x{03B9}",
"\xE1\xBF\x92" => "\x{03B9}\x{0308}\x{0300}",
"\xE1\xBF\x93" => "\x{03B9}\x{0308}\x{0301}",
"\xE1\xBF\x96" => "\x{03B9}\x{0342}",
"\xE1\xBF\x97" => "\x{03B9}\x{0308}\x{0342}",
"\xE1\xBF\xA2" => "\x{03C5}\x{0308}\x{0300}",
"\xE1\xBF\xA3" => "\x{03C5}\x{0308}\x{0301}",
"\xE1\xBF\xA4" => "\x{03C1}\x{0313}",
"\xE1\xBF\xA6" => "\x{03C5}\x{0342}",
"\xE1\xBF\xA7" => "\x{03C5}\x{0308}\x{0342}",
"\xE1\xBF\xB2" => "\x{1F7C}\x{03B9}",
"\xE1\xBF\xB3" => "\x{03C9}\x{03B9}",
"\xE1\xBF\xB4" => "\x{03CE}\x{03B9}",
"\xE1\xBF\xB6" => "\x{03C9}\x{0342}",
"\xE1\xBF\xB7" => "\x{03C9}\x{0342}\x{03B9}",
"\xE1\xBF\xBC" => "\x{03C9}\x{03B9}",
"\xEF\xAC\x80" => "\x{0066}\x{0066}",
"\xEF\xAC\x81" => "\x{0066}\x{0069}",
"\xEF\xAC\x82" => "\x{0066}\x{006C}",
"\xEF\xAC\x83" => "\x{0066}\x{0066}\x{0069}",
"\xEF\xAC\x84" => "\x{0066}\x{0066}\x{006C}",
"\xEF\xAC\x85" => "\x{0073}\x{0074}",
"\xEF\xAC\x86" => "\x{0073}\x{0074}",
"\xEF\xAC\x93" => "\x{0574}\x{0576}",
"\xEF\xAC\x94" => "\x{0574}\x{0565}",
"\xEF\xAC\x95" => "\x{0574}\x{056B}",
"\xEF\xAC\x96" => "\x{057E}\x{0576}",
"\xEF\xAC\x97" => "\x{0574}\x{056D}",
);

return <<'END';
0041		0061
0042		0062
0043		0063
0044		0064
0045		0065
0046		0066
0047		0067
0048		0068
0049		0069
004A		006A
004B		006B
004C		006C
004D		006D
004E		006E
004F		006F
0050		0070
0051		0071
0052		0072
0053		0073
0054		0074
0055		0075
0056		0076
0057		0077
0058		0078
0059		0079
005A		007A
00B5		03BC
00C0		00E0
00C1		00E1
00C2		00E2
00C3		00E3
00C4		00E4
00C5		00E5
00C6		00E6
00C7		00E7
00C8		00E8
00C9		00E9
00CA		00EA
00CB		00EB
00CC		00EC
00CD		00ED
00CE		00EE
00CF		00EF
00D0		00F0
00D1		00F1
00D2		00F2
00D3		00F3
00D4		00F4
00D5		00F5
00D6		00F6
00D8		00F8
00D9		00F9
00DA		00FA
00DB		00FB
00DC		00FC
00DD		00FD
00DE		00FE
0100		0101
0102		0103
0104		0105
0106		0107
0108		0109
010A		010B
010C		010D
010E		010F
0110		0111
0112		0113
0114		0115
0116		0117
0118		0119
011A		011B
011C		011D
011E		011F
0120		0121
0122		0123
0124		0125
0126		0127
0128		0129
012A		012B
012C		012D
012E		012F
0132		0133
0134		0135
0136		0137
0139		013A
013B		013C
013D		013E
013F		0140
0141		0142
0143		0144
0145		0146
0147		0148
014A		014B
014C		014D
014E		014F
0150		0151
0152		0153
0154		0155
0156		0157
0158		0159
015A		015B
015C		015D
015E		015F
0160		0161
0162		0163
0164		0165
0166		0167
0168		0169
016A		016B
016C		016D
016E		016F
0170		0171
0172		0173
0174		0175
0176		0177
0178		00FF
0179		017A
017B		017C
017D		017E
017F		0073
0181		0253
0182		0183
0184		0185
0186		0254
0187		0188
0189		0256
018A		0257
018B		018C
018E		01DD
018F		0259
0190		025B
0191		0192
0193		0260
0194		0263
0196		0269
0197		0268
0198		0199
019C		026F
019D		0272
019F		0275
01A0		01A1
01A2		01A3
01A4		01A5
01A6		0280
01A7		01A8
01A9		0283
01AC		01AD
01AE		0288
01AF		01B0
01B1		028A
01B2		028B
01B3		01B4
01B5		01B6
01B7		0292
01B8		01B9
01BC		01BD
01C4		01C6
01C5		01C6
01C7		01C9
01C8		01C9
01CA		01CC
01CB		01CC
01CD		01CE
01CF		01D0
01D1		01D2
01D3		01D4
01D5		01D6
01D7		01D8
01D9		01DA
01DB		01DC
01DE		01DF
01E0		01E1
01E2		01E3
01E4		01E5
01E6		01E7
01E8		01E9
01EA		01EB
01EC		01ED
01EE		01EF
01F1		01F3
01F2		01F3
01F4		01F5
01F6		0195
01F7		01BF
01F8		01F9
01FA		01FB
01FC		01FD
01FE		01FF
0200		0201
0202		0203
0204		0205
0206		0207
0208		0209
020A		020B
020C		020D
020E		020F
0210		0211
0212		0213
0214		0215
0216		0217
0218		0219
021A		021B
021C		021D
021E		021F
0220		019E
0222		0223
0224		0225
0226		0227
0228		0229
022A		022B
022C		022D
022E		022F
0230		0231
0232		0233
023B		023C
023D		019A
0241		0294
0345		03B9
0386		03AC
0388		03AD
0389		03AE
038A		03AF
038C		03CC
038E		03CD
038F		03CE
0391		03B1
0392		03B2
0393		03B3
0394		03B4
0395		03B5
0396		03B6
0397		03B7
0398		03B8
0399		03B9
039A		03BA
039B		03BB
039C		03BC
039D		03BD
039E		03BE
039F		03BF
03A0		03C0
03A1		03C1
03A3		03C3
03A4		03C4
03A5		03C5
03A6		03C6
03A7		03C7
03A8		03C8
03A9		03C9
03AA		03CA
03AB		03CB
03C2		03C3
03D0		03B2
03D1		03B8
03D5		03C6
03D6		03C0
03D8		03D9
03DA		03DB
03DC		03DD
03DE		03DF
03E0		03E1
03E2		03E3
03E4		03E5
03E6		03E7
03E8		03E9
03EA		03EB
03EC		03ED
03EE		03EF
03F0		03BA
03F1		03C1
03F4		03B8
03F5		03B5
03F7		03F8
03F9		03F2
03FA		03FB
0400		0450
0401		0451
0402		0452
0403		0453
0404		0454
0405		0455
0406		0456
0407		0457
0408		0458
0409		0459
040A		045A
040B		045B
040C		045C
040D		045D
040E		045E
040F		045F
0410		0430
0411		0431
0412		0432
0413		0433
0414		0434
0415		0435
0416		0436
0417		0437
0418		0438
0419		0439
041A		043A
041B		043B
041C		043C
041D		043D
041E		043E
041F		043F
0420		0440
0421		0441
0422		0442
0423		0443
0424		0444
0425		0445
0426		0446
0427		0447
0428		0448
0429		0449
042A		044A
042B		044B
042C		044C
042D		044D
042E		044E
042F		044F
0460		0461
0462		0463
0464		0465
0466		0467
0468		0469
046A		046B
046C		046D
046E		046F
0470		0471
0472		0473
0474		0475
0476		0477
0478		0479
047A		047B
047C		047D
047E		047F
0480		0481
048A		048B
048C		048D
048E		048F
0490		0491
0492		0493
0494		0495
0496		0497
0498		0499
049A		049B
049C		049D
049E		049F
04A0		04A1
04A2		04A3
04A4		04A5
04A6		04A7
04A8		04A9
04AA		04AB
04AC		04AD
04AE		04AF
04B0		04B1
04B2		04B3
04B4		04B5
04B6		04B7
04B8		04B9
04BA		04BB
04BC		04BD
04BE		04BF
04C1		04C2
04C3		04C4
04C5		04C6
04C7		04C8
04C9		04CA
04CB		04CC
04CD		04CE
04D0		04D1
04D2		04D3
04D4		04D5
04D6		04D7
04D8		04D9
04DA		04DB
04DC		04DD
04DE		04DF
04E0		04E1
04E2		04E3
04E4		04E5
04E6		04E7
04E8		04E9
04EA		04EB
04EC		04ED
04EE		04EF
04F0		04F1
04F2		04F3
04F4		04F5
04F6		04F7
04F8		04F9
0500		0501
0502		0503
0504		0505
0506		0507
0508		0509
050A		050B
050C		050D
050E		050F
0531		0561
0532		0562
0533		0563
0534		0564
0535		0565
0536		0566
0537		0567
0538		0568
0539		0569
053A		056A
053B		056B
053C		056C
053D		056D
053E		056E
053F		056F
0540		0570
0541		0571
0542		0572
0543		0573
0544		0574
0545		0575
0546		0576
0547		0577
0548		0578
0549		0579
054A		057A
054B		057B
054C		057C
054D		057D
054E		057E
054F		057F
0550		0580
0551		0581
0552		0582
0553		0583
0554		0584
0555		0585
0556		0586
10A0		2D00
10A1		2D01
10A2		2D02
10A3		2D03
10A4		2D04
10A5		2D05
10A6		2D06
10A7		2D07
10A8		2D08
10A9		2D09
10AA		2D0A
10AB		2D0B
10AC		2D0C
10AD		2D0D
10AE		2D0E
10AF		2D0F
10B0		2D10
10B1		2D11
10B2		2D12
10B3		2D13
10B4		2D14
10B5		2D15
10B6		2D16
10B7		2D17
10B8		2D18
10B9		2D19
10BA		2D1A
10BB		2D1B
10BC		2D1C
10BD		2D1D
10BE		2D1E
10BF		2D1F
10C0		2D20
10C1		2D21
10C2		2D22
10C3		2D23
10C4		2D24
10C5		2D25
1E00		1E01
1E02		1E03
1E04		1E05
1E06		1E07
1E08		1E09
1E0A		1E0B
1E0C		1E0D
1E0E		1E0F
1E10		1E11
1E12		1E13
1E14		1E15
1E16		1E17
1E18		1E19
1E1A		1E1B
1E1C		1E1D
1E1E		1E1F
1E20		1E21
1E22		1E23
1E24		1E25
1E26		1E27
1E28		1E29
1E2A		1E2B
1E2C		1E2D
1E2E		1E2F
1E30		1E31
1E32		1E33
1E34		1E35
1E36		1E37
1E38		1E39
1E3A		1E3B
1E3C		1E3D
1E3E		1E3F
1E40		1E41
1E42		1E43
1E44		1E45
1E46		1E47
1E48		1E49
1E4A		1E4B
1E4C		1E4D
1E4E		1E4F
1E50		1E51
1E52		1E53
1E54		1E55
1E56		1E57
1E58		1E59
1E5A		1E5B
1E5C		1E5D
1E5E		1E5F
1E60		1E61
1E62		1E63
1E64		1E65
1E66		1E67
1E68		1E69
1E6A		1E6B
1E6C		1E6D
1E6E		1E6F
1E70		1E71
1E72		1E73
1E74		1E75
1E76		1E77
1E78		1E79
1E7A		1E7B
1E7C		1E7D
1E7E		1E7F
1E80		1E81
1E82		1E83
1E84		1E85
1E86		1E87
1E88		1E89
1E8A		1E8B
1E8C		1E8D
1E8E		1E8F
1E90		1E91
1E92		1E93
1E94		1E95
1E9B		1E61
1EA0		1EA1
1EA2		1EA3
1EA4		1EA5
1EA6		1EA7
1EA8		1EA9
1EAA		1EAB
1EAC		1EAD
1EAE		1EAF
1EB0		1EB1
1EB2		1EB3
1EB4		1EB5
1EB6		1EB7
1EB8		1EB9
1EBA		1EBB
1EBC		1EBD
1EBE		1EBF
1EC0		1EC1
1EC2		1EC3
1EC4		1EC5
1EC6		1EC7
1EC8		1EC9
1ECA		1ECB
1ECC		1ECD
1ECE		1ECF
1ED0		1ED1
1ED2		1ED3
1ED4		1ED5
1ED6		1ED7
1ED8		1ED9
1EDA		1EDB
1EDC		1EDD
1EDE		1EDF
1EE0		1EE1
1EE2		1EE3
1EE4		1EE5
1EE6		1EE7
1EE8		1EE9
1EEA		1EEB
1EEC		1EED
1EEE		1EEF
1EF0		1EF1
1EF2		1EF3
1EF4		1EF5
1EF6		1EF7
1EF8		1EF9
1F08		1F00
1F09		1F01
1F0A		1F02
1F0B		1F03
1F0C		1F04
1F0D		1F05
1F0E		1F06
1F0F		1F07
1F18		1F10
1F19		1F11
1F1A		1F12
1F1B		1F13
1F1C		1F14
1F1D		1F15
1F28		1F20
1F29		1F21
1F2A		1F22
1F2B		1F23
1F2C		1F24
1F2D		1F25
1F2E		1F26
1F2F		1F27
1F38		1F30
1F39		1F31
1F3A		1F32
1F3B		1F33
1F3C		1F34
1F3D		1F35
1F3E		1F36
1F3F		1F37
1F48		1F40
1F49		1F41
1F4A		1F42
1F4B		1F43
1F4C		1F44
1F4D		1F45
1F59		1F51
1F5B		1F53
1F5D		1F55
1F5F		1F57
1F68		1F60
1F69		1F61
1F6A		1F62
1F6B		1F63
1F6C		1F64
1F6D		1F65
1F6E		1F66
1F6F		1F67
1FB8		1FB0
1FB9		1FB1
1FBA		1F70
1FBB		1F71
1FBE		03B9
1FC8		1F72
1FC9		1F73
1FCA		1F74
1FCB		1F75
1FD8		1FD0
1FD9		1FD1
1FDA		1F76
1FDB		1F77
1FE8		1FE0
1FE9		1FE1
1FEA		1F7A
1FEB		1F7B
1FEC		1FE5
1FF8		1F78
1FF9		1F79
1FFA		1F7C
1FFB		1F7D
2126		03C9
212A		006B
212B		00E5
2160		2170
2161		2171
2162		2172
2163		2173
2164		2174
2165		2175
2166		2176
2167		2177
2168		2178
2169		2179
216A		217A
216B		217B
216C		217C
216D		217D
216E		217E
216F		217F
24B6		24D0
24B7		24D1
24B8		24D2
24B9		24D3
24BA		24D4
24BB		24D5
24BC		24D6
24BD		24D7
24BE		24D8
24BF		24D9
24C0		24DA
24C1		24DB
24C2		24DC
24C3		24DD
24C4		24DE
24C5		24DF
24C6		24E0
24C7		24E1
24C8		24E2
24C9		24E3
24CA		24E4
24CB		24E5
24CC		24E6
24CD		24E7
24CE		24E8
24CF		24E9
2C00		2C30
2C01		2C31
2C02		2C32
2C03		2C33
2C04		2C34
2C05		2C35
2C06		2C36
2C07		2C37
2C08		2C38
2C09		2C39
2C0A		2C3A
2C0B		2C3B
2C0C		2C3C
2C0D		2C3D
2C0E		2C3E
2C0F		2C3F
2C10		2C40
2C11		2C41
2C12		2C42
2C13		2C43
2C14		2C44
2C15		2C45
2C16		2C46
2C17		2C47
2C18		2C48
2C19		2C49
2C1A		2C4A
2C1B		2C4B
2C1C		2C4C
2C1D		2C4D
2C1E		2C4E
2C1F		2C4F
2C20		2C50
2C21		2C51
2C22		2C52
2C23		2C53
2C24		2C54
2C25		2C55
2C26		2C56
2C27		2C57
2C28		2C58
2C29		2C59
2C2A		2C5A
2C2B		2C5B
2C2C		2C5C
2C2D		2C5D
2C2E		2C5E
2C80		2C81
2C82		2C83
2C84		2C85
2C86		2C87
2C88		2C89
2C8A		2C8B
2C8C		2C8D
2C8E		2C8F
2C90		2C91
2C92		2C93
2C94		2C95
2C96		2C97
2C98		2C99
2C9A		2C9B
2C9C		2C9D
2C9E		2C9F
2CA0		2CA1
2CA2		2CA3
2CA4		2CA5
2CA6		2CA7
2CA8		2CA9
2CAA		2CAB
2CAC		2CAD
2CAE		2CAF
2CB0		2CB1
2CB2		2CB3
2CB4		2CB5
2CB6		2CB7
2CB8		2CB9
2CBA		2CBB
2CBC		2CBD
2CBE		2CBF
2CC0		2CC1
2CC2		2CC3
2CC4		2CC5
2CC6		2CC7
2CC8		2CC9
2CCA		2CCB
2CCC		2CCD
2CCE		2CCF
2CD0		2CD1
2CD2		2CD3
2CD4		2CD5
2CD6		2CD7
2CD8		2CD9
2CDA		2CDB
2CDC		2CDD
2CDE		2CDF
2CE0		2CE1
2CE2		2CE3
FF21		FF41
FF22		FF42
FF23		FF43
FF24		FF44
FF25		FF45
FF26		FF46
FF27		FF47
FF28		FF48
FF29		FF49
FF2A		FF4A
FF2B		FF4B
FF2C		FF4C
FF2D		FF4D
FF2E		FF4E
FF2F		FF4F
FF30		FF50
FF31		FF51
FF32		FF52
FF33		FF53
FF34		FF54
FF35		FF55
FF36		FF56
FF37		FF57
FF38		FF58
FF39		FF59
FF3A		FF5A
10400		10428
10401		10429
10402		1042A
10403		1042B
10404		1042C
10405		1042D
10406		1042E
10407		1042F
10408		10430
10409		10431
1040A		10432
1040B		10433
1040C		10434
1040D		10435
1040E		10436
1040F		10437
10410		10438
10411		10439
10412		1043A
10413		1043B
10414		1043C
10415		1043D
10416		1043E
10417		1043F
10418		10440
10419		10441
1041A		10442
1041B		10443
1041C		10444
1041D		10445
1041E		10446
1041F		10447
10420		10448
10421		10449
10422		1044A
10423		1044B
10424		1044C
10425		1044D
10426		1044E
10427		1044F
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
# This file is built by mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!


# The key UTF-8 _bytes_, the value UTF-8 (speed hack)
%utf8::ToSpecTitle =
(
"\xC3\x9F" => "\x{0053}\x{0073}",
"\xC5\x89" => "\x{02BC}\x{004E}",
"\xC7\xB0" => "\x{004A}\x{030C}",
"\xCE\x90" => "\x{0399}\x{0308}\x{0301}",
"\xCE\xB0" => "\x{03A5}\x{0308}\x{0301}",
"\xD6\x87" => "\x{0535}\x{0582}",
"\xE1\xBA\x96" => "\x{0048}\x{0331}",
"\xE1\xBA\x97" => "\x{0054}\x{0308}",
"\xE1\xBA\x98" => "\x{0057}\x{030A}",
"\xE1\xBA\x99" => "\x{0059}\x{030A}",
"\xE1\xBA\x9A" => "\x{0041}\x{02BE}",
"\xE1\xBD\x90" => "\x{03A5}\x{0313}",
"\xE1\xBD\x92" => "\x{03A5}\x{0313}\x{0300}",
"\xE1\xBD\x94" => "\x{03A5}\x{0313}\x{0301}",
"\xE1\xBD\x96" => "\x{03A5}\x{0313}\x{0342}",
"\xE1\xBE\x80" => "\x{1F88}",
"\xE1\xBE\x81" => "\x{1F89}",
"\xE1\xBE\x82" => "\x{1F8A}",
"\xE1\xBE\x83" => "\x{1F8B}",
"\xE1\xBE\x84" => "\x{1F8C}",
"\xE1\xBE\x85" => "\x{1F8D}",
"\xE1\xBE\x86" => "\x{1F8E}",
"\xE1\xBE\x87" => "\x{1F8F}",
"\xE1\xBE\x90" => "\x{1F98}",
"\xE1\xBE\x91" => "\x{1F99}",
"\xE1\xBE\x92" => "\x{1F9A}",
"\xE1\xBE\x93" => "\x{1F9B}",
"\xE1\xBE\x94" => "\x{1F9C}",
"\xE1\xBE\x95" => "\x{1F9D}",
"\xE1\xBE\x96" => "\x{1F9E}",
"\xE1\xBE\x97" => "\x{1F9F}",
"\xE1\xBE\xA0" => "\x{1FA8}",
"\xE1\xBE\xA1" => "\x{1FA9}",
"\xE1\xBE\xA2" => "\x{1FAA}",
"\xE1\xBE\xA3" => "\x{1FAB}",
"\xE1\xBE\xA4" => "\x{1FAC}",
"\xE1\xBE\xA5" => "\x{1FAD}",
"\xE1\xBE\xA6" => "\x{1FAE}",
"\xE1\xBE\xA7" => "\x{1FAF}",
"\xE1\xBE\xB2" => "\x{1FBA}\x{0345}",
"\xE1\xBE\xB3" => "\x{1FBC}",
"\xE1\xBE\xB4" => "\x{0386}\x{0345}",
"\xE1\xBE\xB6" => "\x{0391}\x{0342}",
"\xE1\xBE\xB7" => "\x{0391}\x{0342}\x{0345}",
"\xE1\xBF\x82" => "\x{1FCA}\x{0345}",
"\xE1\xBF\x83" => "\x{1FCC}",
"\xE1\xBF\x84" => "\x{0389}\x{0345}",
"\xE1\xBF\x86" => "\x{0397}\x{0342}",
"\xE1\xBF\x87" => "\x{0397}\x{0342}\x{0345}",
"\xE1\xBF\x92" => "\x{0399}\x{0308}\x{0300}",
"\xE1\xBF\x93" => "\x{0399}\x{0308}\x{0301}",
"\xE1\xBF\x96" => "\x{0399}\x{0342}",
"\xE1\xBF\x97" => "\x{0399}\x{0308}\x{0342}",
"\xE1\xBF\xA2" => "\x{03A5}\x{0308}\x{0300}",
"\xE1\xBF\xA3" => "\x{03A5}\x{0308}\x{0301}",
"\xE1\xBF\xA4" => "\x{03A1}\x{0313}",
"\xE1\xBF\xA6" => "\x{03A5}\x{0342}",
"\xE1\xBF\xA7" => "\x{03A5}\x{0308}\x{0342}",
"\xE1\xBF\xB2" => "\x{1FFA}\x{0345}",
"\xE1\xBF\xB3" => "\x{1FFC}",
"\xE1\xBF\xB4" => "\x{038F}\x{0345}",
"\xE1\xBF\xB6" => "\x{03A9}\x{0342}",
"\xE1\xBF\xB7" => "\x{03A9}\x{0342}\x{0345}",
"\xEF\xAC\x80" => "\x{0046}\x{0066}",
"\xEF\xAC\x81" => "\x{0046}\x{0069}",
"\xEF\xAC\x82" => "\x{0046}\x{006C}",
"\xEF\xAC\x83" => "\x{0046}\x{0066}\x{0069}",
"\xEF\xAC\x84" => "\x{0046}\x{0066}\x{006C}",
"\xEF\xAC\x85" => "\x{0053}\x{0074}",
"\xEF\xAC\x86" => "\x{0053}\x{0074}",
"\xEF\xAC\x93" => "\x{0544}\x{0576}",
"\xEF\xAC\x94" => "\x{0544}\x{0565}",
"\xEF\xAC\x95" => "\x{0544}\x{056B}",
"\xEF\xAC\x96" => "\x{054E}\x{0576}",
"\xEF\xAC\x97" => "\x{0544}\x{056D}",
);

return <<'END';
0061		0041
0062		0042
0063		0043
0064		0044
0065		0045
0066		0046
0067		0047
0068		0048
0069		0049
006A		004A
006B		004B
006C		004C
006D		004D
006E		004E
006F		004F
0070		0050
0071		0051
0072		0052
0073		0053
0074		0054
0075		0055
0076		0056
0077		0057
0078		0058
0079		0059
007A		005A
00B5		039C
00E0		00C0
00E1		00C1
00E2		00C2
00E3		00C3
00E4		00C4
00E5		00C5
00E6		00C6
00E7		00C7
00E8		00C8
00E9		00C9
00EA		00CA
00EB		00CB
00EC		00CC
00ED		00CD
00EE		00CE
00EF		00CF
00F0		00D0
00F1		00D1
00F2		00D2
00F3		00D3
00F4		00D4
00F5		00D5
00F6		00D6
00F8		00D8
00F9		00D9
00FA		00DA
00FB		00DB
00FC		00DC
00FD		00DD
00FE		00DE
00FF		0178
0101		0100
0103		0102
0105		0104
0107		0106
0109		0108
010B		010A
010D		010C
010F		010E
0111		0110
0113		0112
0115		0114
0117		0116
0119		0118
011B		011A
011D		011C
011F		011E
0121		0120
0123		0122
0125		0124
0127		0126
0129		0128
012B		012A
012D		012C
012F		012E
0131		0049
0133		0132
0135		0134
0137		0136
013A		0139
013C		013B
013E		013D
0140		013F
0142		0141
0144		0143
0146		0145
0148		0147
014B		014A
014D		014C
014F		014E
0151		0150
0153		0152
0155		0154
0157		0156
0159		0158
015B		015A
015D		015C
015F		015E
0161		0160
0163		0162
0165		0164
0167		0166
0169		0168
016B		016A
016D		016C
016F		016E
0171		0170
0173		0172
0175		0174
0177		0176
017A		0179
017C		017B
017E		017D
017F		0053
0183		0182
0185		0184
0188		0187
018C		018B
0192		0191
0195		01F6
0199		0198
019A		023D
019E		0220
01A1		01A0
01A3		01A2
01A5		01A4
01A8		01A7
01AD		01AC
01B0		01AF
01B4		01B3
01B6		01B5
01B9		01B8
01BD		01BC
01BF		01F7
01C4		01C5
01C5		01C5
01C6		01C5
01C7		01C8
01C8		01C8
01C9		01C8
01CA		01CB
01CB		01CB
01CC		01CB
01CE		01CD
01D0		01CF
01D2		01D1
01D4		01D3
01D6		01D5
01D8		01D7
01DA		01D9
01DC		01DB
01DD		018E
01DF		01DE
01E1		01E0
01E3		01E2
01E5		01E4
01E7		01E6
01E9		01E8
01EB		01EA
01ED		01EC
01EF		01EE
01F1		01F2
01F2		01F2
01F3		01F2
01F5		01F4
01F9		01F8
01FB		01FA
01FD		01FC
01FF		01FE
0201		0200
0203		0202
0205		0204
0207		0206
0209		0208
020B		020A
020D		020C
020F		020E
0211		0210
0213		0212
0215		0214
0217		0216
0219		0218
021B		021A
021D		021C
021F		021E
0223		0222
0225		0224
0227		0226
0229		0228
022B		022A
022D		022C
022F		022E
0231		0230
0233		0232
023C		023B
0253		0181
0254		0186
0256		0189
0257		018A
0259		018F
025B		0190
0260		0193
0263		0194
0268		0197
0269		0196
026F		019C
0272		019D
0275		019F
0280		01A6
0283		01A9
0288		01AE
028A		01B1
028B		01B2
0292		01B7
0294		0241
0345		0399
03AC		0386
03AD		0388
03AE		0389
03AF		038A
03B1		0391
03B2		0392
03B3		0393
03B4		0394
03B5		0395
03B6		0396
03B7		0397
03B8		0398
03B9		0399
03BA		039A
03BB		039B
03BC		039C
03BD		039D
03BE		039E
03BF		039F
03C0		03A0
03C1		03A1
03C2		03A3
03C3		03A3
03C4		03A4
03C5		03A5
03C6		03A6
03C7		03A7
03C8		03A8
03C9		03A9
03CA		03AA
03CB		03AB
03CC		038C
03CD		038E
03CE		038F
03D0		0392
03D1		0398
03D5		03A6
03D6		03A0
03D9		03D8
03DB		03DA
03DD		03DC
03DF		03DE
03E1		03E0
03E3		03E2
03E5		03E4
03E7		03E6
03E9		03E8
03EB		03EA
03ED		03EC
03EF		03EE
03F0		039A
03F1		03A1
03F2		03F9
03F5		0395
03F8		03F7
03FB		03FA
0430		0410
0431		0411
0432		0412
0433		0413
0434		0414
0435		0415
0436		0416
0437		0417
0438		0418
0439		0419
043A		041A
043B		041B
043C		041C
043D		041D
043E		041E
043F		041F
0440		0420
0441		0421
0442		0422
0443		0423
0444		0424
0445		0425
0446		0426
0447		0427
0448		0428
0449		0429
044A		042A
044B		042B
044C		042C
044D		042D
044E		042E
044F		042F
0450		0400
0451		0401
0452		0402
0453		0403
0454		0404
0455		0405
0456		0406
0457		0407
0458		0408
0459		0409
045A		040A
045B		040B
045C		040C
045D		040D
045E		040E
045F		040F
0461		0460
0463		0462
0465		0464
0467		0466
0469		0468
046B		046A
046D		046C
046F		046E
0471		0470
0473		0472
0475		0474
0477		0476
0479		0478
047B		047A
047D		047C
047F		047E
0481		0480
048B		048A
048D		048C
048F		048E
0491		0490
0493		0492
0495		0494
0497		0496
0499		0498
049B		049A
049D		049C
049F		049E
04A1		04A0
04A3		04A2
04A5		04A4
04A7		04A6
04A9		04A8
04AB		04AA
04AD		04AC
04AF		04AE
04B1		04B0
04B3		04B2
04B5		04B4
04B7		04B6
04B9		04B8
04BB		04BA
04BD		04BC
04BF		04BE
04C2		04C1
04C4		04C3
04C6		04C5
04C8		04C7
04CA		04C9
04CC		04CB
04CE		04CD
04D1		04D0
04D3		04D2
04D5		04D4
04D7		04D6
04D9		04D8
04DB		04DA
04DD		04DC
04DF		04DE
04E1		04E0
04E3		04E2
04E5		04E4
04E7		04E6
04E9		04E8
04EB		04EA
04ED		04EC
04EF		04EE
04F1		04F0
04F3		04F2
04F5		04F4
04F7		04F6
04F9		04F8
0501		0500
0503		0502
0505		0504
0507		0506
0509		0508
050B		050A
050D		050C
050F		050E
0561		0531
0562		0532
0563		0533
0564		0534
0565		0535
0566		0536
0567		0537
0568		0538
0569		0539
056A		053A
056B		053B
056C		053C
056D		053D
056E		053E
056F		053F
0570		0540
0571		0541
0572		0542
0573		0543
0574		0544
0575		0545
0576		0546
0577		0547
0578		0548
0579		0549
057A		054A
057B		054B
057C		054C
057D		054D
057E		054E
057F		054F
0580		0550
0581		0551
0582		0552
0583		0553
0584		0554
0585		0555
0586		0556
1E01		1E00
1E03		1E02
1E05		1E04
1E07		1E06
1E09		1E08
1E0B		1E0A
1E0D		1E0C
1E0F		1E0E
1E11		1E10
1E13		1E12
1E15		1E14
1E17		1E16
1E19		1E18
1E1B		1E1A
1E1D		1E1C
1E1F		1E1E
1E21		1E20
1E23		1E22
1E25		1E24
1E27		1E26
1E29		1E28
1E2B		1E2A
1E2D		1E2C
1E2F		1E2E
1E31		1E30
1E33		1E32
1E35		1E34
1E37		1E36
1E39		1E38
1E3B		1E3A
1E3D		1E3C
1E3F		1E3E
1E41		1E40
1E43		1E42
1E45		1E44
1E47		1E46
1E49		1E48
1E4B		1E4A
1E4D		1E4C
1E4F		1E4E
1E51		1E50
1E53		1E52
1E55		1E54
1E57		1E56
1E59		1E58
1E5B		1E5A
1E5D		1E5C
1E5F		1E5E
1E61		1E60
1E63		1E62
1E65		1E64
1E67		1E66
1E69		1E68
1E6B		1E6A
1E6D		1E6C
1E6F		1E6E
1E71		1E70
1E73		1E72
1E75		1E74
1E77		1E76
1E79		1E78
1E7B		1E7A
1E7D		1E7C
1E7F		1E7E
1E81		1E80
1E83		1E82
1E85		1E84
1E87		1E86
1E89		1E88
1E8B		1E8A
1E8D		1E8C
1E8F		1E8E
1E91		1E90
1E93		1E92
1E95		1E94
1E9B		1E60
1EA1		1EA0
1EA3		1EA2
1EA5		1EA4
1EA7		1EA6
1EA9		1EA8
1EAB		1EAA
1EAD		1EAC
1EAF		1EAE
1EB1		1EB0
1EB3		1EB2
1EB5		1EB4
1EB7		1EB6
1EB9		1EB8
1EBB		1EBA
1EBD		1EBC
1EBF		1EBE
1EC1		1EC0
1EC3		1EC2
1EC5		1EC4
1EC7		1EC6
1EC9		1EC8
1ECB		1ECA
1ECD		1ECC
1ECF		1ECE
1ED1		1ED0
1ED3		1ED2
1ED5		1ED4
1ED7		1ED6
1ED9		1ED8
1EDB		1EDA
1EDD		1EDC
1EDF		1EDE
1EE1		1EE0
1EE3		1EE2
1EE5		1EE4
1EE7		1EE6
1EE9		1EE8
1EEB		1EEA
1EED		1EEC
1EEF		1EEE
1EF1		1EF0
1EF3		1EF2
1EF5		1EF4
1EF7		1EF6
1EF9		1EF8
1F00		1F08
1F01		1F09
1F02		1F0A
1F03		1F0B
1F04		1F0C
1F05		1F0D
1F06		1F0E
1F07		1F0F
1F10		1F18
1F11		1F19
1F12		1F1A
1F13		1F1B
1F14		1F1C
1F15		1F1D
1F20		1F28
1F21		1F29
1F22		1F2A
1F23		1F2B
1F24		1F2C
1F25		1F2D
1F26		1F2E
1F27		1F2F
1F30		1F38
1F31		1F39
1F32		1F3A
1F33		1F3B
1F34		1F3C
1F35		1F3D
1F36		1F3E
1F37		1F3F
1F40		1F48
1F41		1F49
1F42		1F4A
1F43		1F4B
1F44		1F4C
1F45		1F4D
1F51		1F59
1F53		1F5B
1F55		1F5D
1F57		1F5F
1F60		1F68
1F61		1F69
1F62		1F6A
1F63		1F6B
1F64		1F6C
1F65		1F6D
1F66		1F6E
1F67		1F6F
1F70		1FBA
1F71		1FBB
1F72		1FC8
1F73		1FC9
1F74		1FCA
1F75		1FCB
1F76		1FDA
1F77		1FDB
1F78		1FF8
1F79		1FF9
1F7A		1FEA
1F7B		1FEB
1F7C		1FFA
1F7D		1FFB
1FB0		1FB8
1FB1		1FB9
1FBE		0399
1FD0		1FD8
1FD1		1FD9
1FE0		1FE8
1FE1		1FE9
1FE5		1FEC
2170		2160
2171		2161
2172		2162
2173		2163
2174		2164
2175		2165
2176		2166
2177		2167
2178		2168
2179		2169
217A		216A
217B		216B
217C		216C
217D		216D
217E		216E
217F		216F
24D0		24B6
24D1		24B7
24D2		24B8
24D3		24B9
24D4		24BA
24D5		24BB
24D6		24BC
24D7		24BD
24D8		24BE
24D9		24BF
24DA		24C0
24DB		24C1
24DC		24C2
24DD		24C3
24DE		24C4
24DF		24C5
24E0		24C6
24E1		24C7
24E2		24C8
24E3		24C9
24E4		24CA
24E5		24CB
24E6		24CC
24E7		24CD
24E8		24CE
24E9		24CF
2C30		2C00
2C31		2C01
2C32		2C02
2C33		2C03
2C34		2C04
2C35		2C05
2C36		2C06
2C37		2C07
2C38		2C08
2C39		2C09
2C3A		2C0A
2C3B		2C0B
2C3C		2C0C
2C3D		2C0D
2C3E		2C0E
2C3F		2C0F
2C40		2C10
2C41		2C11
2C42		2C12
2C43		2C13
2C44		2C14
2C45		2C15
2C46		2C16
2C47		2C17
2C48		2C18
2C49		2C19
2C4A		2C1A
2C4B		2C1B
2C4C		2C1C
2C4D		2C1D
2C4E		2C1E
2C4F		2C1F
2C50		2C20
2C51		2C21
2C52		2C22
2C53		2C23
2C54		2C24
2C55		2C25
2C56		2C26
2C57		2C27
2C58		2C28
2C59		2C29
2C5A		2C2A
2C5B		2C2B
2C5C		2C2C
2C5D		2C2D
2C5E		2C2E
2C81		2C80
2C83		2C82
2C85		2C84
2C87		2C86
2C89		2C88
2C8B		2C8A
2C8D		2C8C
2C8F		2C8E
2C91		2C90
2C93		2C92
2C95		2C94
2C97		2C96
2C99		2C98
2C9B		2C9A
2C9D		2C9C
2C9F		2C9E
2CA1		2CA0
2CA3		2CA2
2CA5		2CA4
2CA7		2CA6
2CA9		2CA8
2CAB		2CAA
2CAD		2CAC
2CAF		2CAE
2CB1		2CB0
2CB3		2CB2
2CB5		2CB4
2CB7		2CB6
2CB9		2CB8
2CBB		2CBA
2CBD		2CBC
2CBF		2CBE
2CC1		2CC0
2CC3		2CC2
2CC5		2CC4
2CC7		2CC6
2CC9		2CC8
2CCB		2CCA
2CCD		2CCC
2CCF		2CCE
2CD1		2CD0
2CD3		2CD2
2CD5		2CD4
2CD7		2CD6
2CD9		2CD8
2CDB		2CDA
2CDD		2CDC
2CDF		2CDE
2CE1		2CE0
2CE3		2CE2
2D00		10A0
2D01		10A1
2D02		10A2
2D03		10A3
2D04		10A4
2D05		10A5
2D06		10A6
2D07		10A7
2D08		10A8
2D09		10A9
2D0A		10AA
2D0B		10AB
2D0C		10AC
2D0D		10AD
2D0E		10AE
2D0F		10AF
2D10		10B0
2D11		10B1
2D12		10B2
2D13		10B3
2D14		10B4
2D15		10B5
2D16		10B6
2D17		10B7
2D18		10B8
2D19		10B9
2D1A		10BA
2D1B		10BB
2D1C		10BC
2D1D		10BD
2D1E		10BE
2D1F		10BF
2D20		10C0
2D21		10C1
2D22		10C2
2D23		10C3
2D24		10C4
2D25		10C5
FF41		FF21
FF42		FF22
FF43		FF23
FF44		FF24
FF45		FF25
FF46		FF26
FF47		FF27
FF48		FF28
FF49		FF29
FF4A		FF2A
FF4B		FF2B
FF4C		FF2C
FF4D		FF2D
FF4E		FF2E
FF4F		FF2F
FF50		FF30
FF51		FF31
FF52		FF32
FF53		FF33
FF54		FF34
FF55		FF35
FF56		FF36
FF57		FF37
FF58		FF38
FF59		FF39
FF5A		FF3A
10428		10400
10429		10401
1042A		10402
1042B		10403
1042C		10404
1042D		10405
1042E		10406
1042F		10407
10430		10408
10431		10409
10432		1040A
10433		1040B
10434		1040C
10435		1040D
10436		1040E
10437		1040F
10438		10410
10439		10411
1043A		10412
1043B		10413
1043C		10414
1043D		10415
1043E		10416
1043F		10417
10440		10418
10441		10419
10442		1041A
10443		1041B
10444		1041C
10445		1041D
10446		1041E
10447		1041F
10448		10420
10449		10421
1044A		10422
1044B		10423
1044C		10424
1044D		10425
1044E		10426
1044F		10427
END
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ##
## This file created by mktables
## List of built-in \p{...}/\P{...} properties.
##
## '*' means name may be 'fuzzy'
##

  \p{ASCII}                                  [[:ASCII:]]
  \p{Alnum}                                  [[:Alnum:]]
* \p{Alphabetic}                             [\p{L}\p{OtherAlphabetic}]
  \p{Alpha}                                  [[:Alpha:]]
  \p{Any}                                    Alias for \p{Any} ([\x{0000}-\x{10FFFF}])
  \p{Any}                                    [\x{0000}-\x{10FFFF}]
* \p{Arabic}                                 Script 'Arabic'
* \p{Armenian}                               Script 'Armenian'
* \p{AsciiHexDigit}                          Extended property 'ASCII_Hex_Digit'
  \p{Assigned}                               All assigned code points
* \p{Bengali}                                Script 'Bengali'
* \p{BidiControl}                            Extended property 'Bidi_Control'
  \p{Blank}                                  [[:Blank:]]
* \p{Bopomofo}                               Script 'Bopomofo'
* \p{Braille}                                Script 'Braille'
* \p{Buginese}                               Script 'Buginese'
* \p{Buhid}                                  Script 'Buhid'
* \p{CanadianAboriginal}                     Script 'Canadian_Aboriginal'
* \p{Cc}                                     Alias for \p{Cc} (General Category 'Cc')
  \p{Cc}                                     General Category 'Cc'
* \p{Cf}                                     Alias for \p{Cf} (General Category 'Cf')
  \p{Cf}                                     General Category 'Cf'
* \p{Cherokee}                               Script 'Cherokee'
  \p{Cntrl}                                  [[:Cntrl:]]
* \p{Cn}                                     Alias for \p{Cn} (General Category 'Cn' [not functional in Perl])
  \p{Cn}                                     General Category 'Cn' [not functional in Perl]
* \p{Common}                                 Script 'Common'
* \p{Coptic}                                 Script 'Coptic'
* \p{Co}                                     Alias for \p{Co} (General Category 'Co')
  \p{Co}                                     General Category 'Co'
* \p{Cs}                                     Alias for \p{Cs} (General Category 'Cs')
  \p{Cs}                                     General Category 'Cs'
* \p{Cypriot}                                Script 'Cypriot'
* \p{Cyrillic}                               Script 'Cyrillic'
* \p{C}                                      Alias for \p{C} (Major Category 'C')
  \p{C}                                      Major Category 'C'
* \p{Dash}                                   Extended property 'Dash'
* \p{Deprecated}                             Extended property 'Deprecated'
* \p{Deseret}                                Script 'Deseret'
* \p{Devanagari}                             Script 'Devanagari'
* \p{Diacritic}                              Extended property 'Diacritic'
  \p{Digit}                                  [[:Digit:]]
* \p{Ethiopic}                               Script 'Ethiopic'
* \p{Extender}                               Extended property 'Extender'
* \p{Georgian}                               Script 'Georgian'
* \p{Glagolitic}                             Script 'Glagolitic'
* \p{Gothic}                                 Script 'Gothic'
* \p{GraphemeLink}                           Extended property 'Grapheme_Link'
  \p{Graph}                                  [[:Graph:]]
* \p{Greek}                                  Script 'Greek'
* \p{Gujarati}                               Script 'Gujarati'
* \p{Gurmukhi}                               Script 'Gurmukhi'
* \p{Hangul}                                 Script 'Hangul'
* \p{Hanunoo}                                Script 'Hanunoo'
* \p{Han}                                    Script 'Han'
* \p{Hebrew}                                 Script 'Hebrew'
* \p{HexDigit}                               Extended property 'Hex_Digit'
* \p{Hiragana}                               Script 'Hiragana'
* \p{Hyphen}                                 Extended property 'Hyphen'
* \p{IdContinue}                             [\p{ID_Start}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]
* \p{IdStart}                                [\p{Ll}\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{Nl}]
* \p{Ideographic}                            Extended property 'Ideographic'
* \p{IdsBinaryOperator}                      Extended property 'IDS_Binary_Operator'
* \p{IdsTrinaryOperator}                     Extended property 'IDS_Trinary_Operator'
* \p{InAegeanNumbers}                        Block 'Aegean Numbers'
* \p{InAlphabeticPresentationForms}          Block 'Alphabetic Presentation Forms'
* \p{InAncientGreekMusicalNotation}          Block 'Ancient Greek Musical Notation'
* \p{InAncientGreekNumbers}                  Block 'Ancient Greek Numbers'
* \p{InArabicPresentationFormsA}             Block 'Arabic Presentation Forms-A'
* \p{InArabicPresentationFormsB}             Block 'Arabic Presentation Forms-B'
* \p{InArabicSupplement}                     Block 'Arabic Supplement'
* \p{InArabic}                               Block 'Arabic'
* \p{InArmenian}                             Block 'Armenian'
* \p{InArrows}                               Block 'Arrows'
* \p{InBasicLatin}                           Block 'Basic Latin'
* \p{InBengali}                              Block 'Bengali'
* \p{InBlockElements}                        Block 'Block Elements'
* \p{InBopomofoExtended}                     Block 'Bopomofo Extended'
* \p{InBopomofo}                             Block 'Bopomofo'
* \p{InBoxDrawing}                           Block 'Box Drawing'
* \p{InBraillePatterns}                      Block 'Braille Patterns'
* \p{InBuginese}                             Block 'Buginese'
* \p{InBuhid}                                Block 'Buhid'
* \p{InByzantineMusicalSymbols}              Block 'Byzantine Musical Symbols'
* \p{InCherokee}                             Block 'Cherokee'
* \p{InCjkCompatibilityForms}                Block 'CJK Compatibility Forms'
* \p{InCjkCompatibilityIdeographsSupplement} Block 'CJK Compatibility Ideographs Supplement'
* \p{InCjkCompatibilityIdeographs}           Block 'CJK Compatibility Ideographs'
* \p{InCjkCompatibility}                     Block 'CJK Compatibility'
* \p{InCjkRadicalsSupplement}                Block 'CJK Radicals Supplement'
* \p{InCjkStrokes}                           Block 'CJK Strokes'
* \p{InCjkSymbolsAndPunctuation}             Block 'CJK Symbols and Punctuation'
* \p{InCjkUnifiedIdeographsExtensionA}       Block 'CJK Unified Ideographs Extension A'
* \p{InCjkUnifiedIdeographsExtensionB}       Block 'CJK Unified Ideographs Extension B'
* \p{InCjkUnifiedIdeographs}                 Block 'CJK Unified Ideographs'
* \p{InCombiningDiacriticalMarksForSymbols}  Block 'Combining Diacritical Marks for Symbols'
* \p{InCombiningDiacriticalMarksSupplement}  Block 'Combining Diacritical Marks Supplement'
* \p{InCombiningDiacriticalMarks}            Block 'Combining Diacritical Marks'
* \p{InCombiningHalfMarks}                   Block 'Combining Half Marks'
* \p{InControlPictures}                      Block 'Control Pictures'
* \p{InCoptic}                               Block 'Coptic'
* \p{InCurrencySymbols}                      Block 'Currency Symbols'
* \p{InCypriotSyllabary}                     Block 'Cypriot Syllabary'
* \p{InCyrillicSupplement}                   Block 'Cyrillic Supplement'
* \p{InCyrillic}                             Block 'Cyrillic'
* \p{InDeseret}                              Block 'Deseret'
* \p{InDevanagari}                           Block 'Devanagari'
* \p{InDingbats}                             Block 'Dingbats'
* \p{InEnclosedAlphanumerics}                Block 'Enclosed Alphanumerics'
* \p{InEnclosedCjkLettersAndMonths}          Block 'Enclosed CJK Letters and Months'
* \p{InEthiopicExtended}                     Block 'Ethiopic Extended'
* \p{InEthiopicSupplement}                   Block 'Ethiopic Supplement'
* \p{InEthiopic}                             Block 'Ethiopic'
* \p{InGeneralPunctuation}                   Block 'General Punctuation'
* \p{InGeometricShapes}                      Block 'Geometric Shapes'
* \p{InGeorgianSupplement}                   Block 'Georgian Supplement'
* \p{InGeorgian}                             Block 'Georgian'
* \p{InGlagolitic}                           Block 'Glagolitic'
* \p{InGothic}                               Block 'Gothic'
* \p{InGreekAndCoptic}                       Block 'Greek and Coptic'
* \p{InGreekExtended}                        Block 'Greek Extended'
* \p{InGujarati}                             Block 'Gujarati'
* \p{InGurmukhi}                             Block 'Gurmukhi'
* \p{InHalfwidthAndFullwidthForms}           Block 'Halfwidth and Fullwidth Forms'
* \p{InHangulCompatibilityJamo}              Block 'Hangul Compatibility Jamo'
* \p{InHangulJamo}                           Block 'Hangul Jamo'
* \p{InHangulSyllables}                      Block 'Hangul Syllables'
* \p{InHanunoo}                              Block 'Hanunoo'
* \p{InHebrew}                               Block 'Hebrew'
* \p{InHighPrivateUseSurrogates}             Block 'High Private Use Surrogates'
* \p{InHighSurrogates}                       Block 'High Surrogates'
* \p{InHiragana}                             Block 'Hiragana'
* \p{InIdeographicDescriptionCharacters}     Block 'Ideographic Description Characters'
* \p{InIpaExtensions}                        Block 'IPA Extensions'
* \p{InKanbun}                               Block 'Kanbun'
* \p{InKangxiRadicals}                       Block 'Kangxi Radicals'
* \p{InKannada}                              Block 'Kannada'
* \p{InKatakanaPhoneticExtensions}           Block 'Katakana Phonetic Extensions'
* \p{InKatakana}                             Block 'Katakana'
* \p{InKharoshthi}                           Block 'Kharoshthi'
* \p{InKhmerSymbols}                         Block 'Khmer Symbols'
* \p{InKhmer}                                Block 'Khmer'
* \p{InLao}                                  Block 'Lao'
* \p{InLatin1Supplement}                     Block 'Latin-1 Supplement'
* \p{InLatinExtendedAdditional}              Block 'Latin Extended Additional'
* \p{InLatinExtendedA}                       Block 'Latin Extended-A'
* \p{InLatinExtendedB}                       Block 'Latin Extended-B'
* \p{InLetterlikeSymbols}                    Block 'Letterlike Symbols'
* \p{InLimbu}                                Block 'Limbu'
* \p{InLinearBIdeograms}                     Block 'Linear B Ideograms'
* \p{InLinearBSyllabary}                     Block 'Linear B Syllabary'
* \p{InLowSurrogates}                        Block 'Low Surrogates'
* \p{InMalayalam}                            Block 'Malayalam'
* \p{InMathematicalAlphanumericSymbols}      Block 'Mathematical Alphanumeric Symbols'
* \p{InMathematicalOperators}                Block 'Mathematical Operators'
* \p{InMiscellaneousMathematicalSymbolsA}    Block 'Miscellaneous Mathematical Symbols-A'
* \p{InMiscellaneousMathematicalSymbolsB}    Block 'Miscellaneous Mathematical Symbols-B'
* \p{InMiscellaneousSymbolsAndArrows}        Block 'Miscellaneous Symbols and Arrows'
* \p{InMiscellaneousSymbols}                 Block 'Miscellaneous Symbols'
* \p{InMiscellaneousTechnical}               Block 'Miscellaneous Technical'
* \p{InModifierToneLetters}                  Block 'Modifier Tone Letters'
* \p{InMongolian}                            Block 'Mongolian'
* \p{InMusicalSymbols}                       Block 'Musical Symbols'
* \p{InMyanmar}                              Block 'Myanmar'
* \p{InNewTaiLue}                            Block 'New Tai Lue'
* \p{InNumberForms}                          Block 'Number Forms'
* \p{InOgham}                                Block 'Ogham'
* \p{InOldItalic}                            Block 'Old Italic'
* \p{InOldPersian}                           Block 'Old Persian'
* \p{InOpticalCharacterRecognition}          Block 'Optical Character Recognition'
* \p{InOriya}                                Block 'Oriya'
* \p{InOsmanya}                              Block 'Osmanya'
* \p{InPhoneticExtensionsSupplement}         Block 'Phonetic Extensions Supplement'
* \p{InPhoneticExtensions}                   Block 'Phonetic Extensions'
* \p{InPrivateUseArea}                       Block 'Private Use Area'
* \p{InRunic}                                Block 'Runic'
* \p{InShavian}                              Block 'Shavian'
* \p{InSinhala}                              Block 'Sinhala'
* \p{InSmallFormVariants}                    Block 'Small Form Variants'
* \p{InSpacingModifierLetters}               Block 'Spacing Modifier Letters'
* \p{InSpecials}                             Block 'Specials'
* \p{InSuperscriptsAndSubscripts}            Block 'Superscripts and Subscripts'
* \p{InSupplementalArrowsA}                  Block 'Supplemental Arrows-A'
* \p{InSupplementalArrowsB}                  Block 'Supplemental Arrows-B'
* \p{InSupplementalMathematicalOperators}    Block 'Supplemental Mathematical Operators'
* \p{InSupplementalPunctuation}              Block 'Supplemental Punctuation'
* \p{InSupplementaryPrivateUseAreaA}         Block 'Supplementary Private Use Area-A'
* \p{InSupplementaryPrivateUseAreaB}         Block 'Supplementary Private Use Area-B'
* \p{InSylotiNagri}                          Block 'Syloti Nagri'
* \p{InSyriac}                               Block 'Syriac'
* \p{InTagalog}                              Block 'Tagalog'
* \p{InTagbanwa}                             Block 'Tagbanwa'
* \p{InTags}                                 Block 'Tags'
* \p{InTaiLe}                                Block 'Tai Le'
* \p{InTaiXuanJingSymbols}                   Block 'Tai Xuan Jing Symbols'
* \p{InTamil}                                Block 'Tamil'
* \p{InTelugu}                               Block 'Telugu'
* \p{InThaana}                               Block 'Thaana'
* \p{InThai}                                 Block 'Thai'
* \p{InTibetan}                              Block 'Tibetan'
* \p{InTifinagh}                             Block 'Tifinagh'
* \p{InUgaritic}                             Block 'Ugaritic'
* \p{InUnifiedCanadianAboriginalSyllabics}   Block 'Unified Canadian Aboriginal Syllabics'
* \p{InVariationSelectorsSupplement}         Block 'Variation Selectors Supplement'
* \p{InVariationSelectors}                   Block 'Variation Selectors'
* \p{InVerticalForms}                        Block 'Vertical Forms'
* \p{InYiRadicals}                           Block 'Yi Radicals'
* \p{InYiSyllables}                          Block 'Yi Syllables'
* \p{InYijingHexagramSymbols}                Block 'Yijing Hexagram Symbols'
* \p{Inherited}                              Script 'Inherited'
* \p{JoinControl}                            Extended property 'Join_Control'
* \p{Kannada}                                Script 'Kannada'
* \p{Katakana}                               Script 'Katakana'
* \p{Kharoshthi}                             Script 'Kharoshthi'
* \p{Khmer}                                  Script 'Khmer'
* \p{LC}                                     Alias for \p{LC} ([\p{Ll}\p{Lu}\p{Lt}])
  \p{LC}                                     [\p{Ll}\p{Lu}\p{Lt}]
* \p{Lao}                                    Script 'Lao'
* \p{Latin}                                  Script 'Latin'
* \p{Limbu}                                  Script 'Limbu'
* \p{LinearB}                                Script 'Linear_B'
* \p{Ll}                                     Alias for \p{Ll} (General Category 'Ll')
  \p{Ll}                                     General Category 'Ll'
* \p{Lm}                                     Alias for \p{Lm} (General Category 'Lm')
  \p{Lm}                                     General Category 'Lm'
* \p{LogicalOrderException}                  Extended property 'Logical_Order_Exception'
* \p{Lowercase}                              [\p{Ll}\p{OtherLowercase}]
  \p{Lower}                                  [[:Lower:]]
* \p{Lo}                                     Alias for \p{Lo} (General Category 'Lo')
  \p{Lo}                                     General Category 'Lo'
* \p{Lt}                                     Alias for \p{Lt} (General Category 'Lt')
  \p{Lt}                                     General Category 'Lt'
* \p{Lu}                                     Alias for \p{Lu} (General Category 'Lu')
  \p{Lu}                                     General Category 'Lu'
* \p{L}                                      Alias for \p{L} (Major Category 'L')
  \p{L}                                      Major Category 'L'
* \p{Malayalam}                              Script 'Malayalam'
* \p{Math}                                   [\p{Sm}\p{OtherMath}]
* \p{Mc}                                     Alias for \p{Mc} (General Category 'Mc')
  \p{Mc}                                     General Category 'Mc'
* \p{Me}                                     Alias for \p{Me} (General Category 'Me')
  \p{Me}                                     General Category 'Me'
* \p{Mn}                                     Alias for \p{Mn} (General Category 'Mn')
  \p{Mn}                                     General Category 'Mn'
* \p{Mongolian}                              Script 'Mongolian'
* \p{Myanmar}                                Script 'Myanmar'
* \p{M}                                      Alias for \p{M} (Major Category 'M')
  \p{M}                                      Major Category 'M'
* \p{Nd}                                     Alias for \p{Nd} (General Category 'Nd')
  \p{Nd}                                     General Category 'Nd'
* \p{NewTaiLue}                              Script 'New_Tai_Lue'
* \p{Nl}                                     Alias for \p{Nl} (General Category 'Nl')
  \p{Nl}                                     General Category 'Nl'
* \p{NoncharacterCodePoint}                  Extended property 'Noncharacter_Code_Point'
* \p{No}                                     Alias for \p{No} (General Category 'No')
  \p{No}                                     General Category 'No'
* \p{N}                                      Alias for \p{N} (Major Category 'N')
  \p{N}                                      Major Category 'N'
* \p{Ogham}                                  Script 'Ogham'
* \p{OldItalic}                              Script 'Old_Italic'
* \p{OldPersian}                             Script 'Old_Persian'
* \p{Oriya}                                  Script 'Oriya'
* \p{Osmanya}                                Script 'Osmanya'
* \p{OtherAlphabetic}                        Extended property 'Other_Alphabetic'
* \p{OtherDefaultIgnorableCodePoint}         Extended property 'Other_Default_Ignorable_Code_Point'
* \p{OtherGraphemeExtend}                    Extended property 'Other_Grapheme_Extend'
* \p{OtherIdContinue}                        Extended property 'Other_ID_Continue'
* \p{OtherIdStart}                           Extended property 'Other_ID_Start'
* \p{OtherLowercase}                         Extended property 'Other_Lowercase'
* \p{OtherMath}                              Extended property 'Other_Math'
* \p{OtherUppercase}                         Extended property 'Other_Uppercase'
* \p{PatternSyntax}                          Extended property 'Pattern_Syntax'
* \p{PatternWhiteSpace}                      Extended property 'Pattern_White_Space'
* \p{Pc}                                     Alias for \p{Pc} (General Category 'Pc')
  \p{Pc}                                     General Category 'Pc'
* \p{Pd}                                     Alias for \p{Pd} (General Category 'Pd')
  \p{Pd}                                     General Category 'Pd'
* \p{Pe}                                     Alias for \p{Pe} (General Category 'Pe')
  \p{Pe}                                     General Category 'Pe'
* \p{Pf}                                     Alias for \p{Pf} (General Category 'Pf')
  \p{Pf}                                     General Category 'Pf'
* \p{Pi}                                     Alias for \p{Pi} (General Category 'Pi')
  \p{Pi}                                     General Category 'Pi'
* \p{Po}                                     Alias for \p{Po} (General Category 'Po')
  \p{Po}                                     General Category 'Po'
  \p{Print}                                  [[:Print:]]
* \p{Ps}                                     Alias for \p{Ps} (General Category 'Ps')
  \p{Ps}                                     General Category 'Ps'
  \p{Punct}                                  [[:Punct:]]
* \p{P}                                      Alias for \p{P} (Major Category 'P')
  \p{P}                                      Major Category 'P'
* \p{QuotationMark}                          Extended property 'Quotation_Mark'
* \p{Radical}                                Extended property 'Radical'
* \p{Runic}                                  Script 'Runic'
* \p{Sc}                                     Alias for \p{Sc} (General Category 'Sc')
  \p{Sc}                                     General Category 'Sc'
* \p{Shavian}                                Script 'Shavian'
* \p{Sinhala}                                Script 'Sinhala'
* \p{Sk}                                     Alias for \p{Sk} (General Category 'Sk')
  \p{Sk}                                     General Category 'Sk'
* \p{Sm}                                     Alias for \p{Sm} (General Category 'Sm')
  \p{Sm}                                     General Category 'Sm'
* \p{SoftDotted}                             Extended property 'Soft_Dotted'
* \p{So}                                     Alias for \p{So} (General Category 'So')
  \p{So}                                     General Category 'So'
  \p{SpacePerl}                              \s
  \p{Space}                                  [[:Space:]]
* \p{Sterm}                                  Extended property 'STerm'
* \p{SylotiNagri}                            Script 'Syloti_Nagri'
* \p{Syriac}                                 Script 'Syriac'
* \p{S}                                      Alias for \p{S} (Major Category 'S')
  \p{S}                                      Major Category 'S'
* \p{Tagalog}                                Script 'Tagalog'
* \p{Tagbanwa}                               Script 'Tagbanwa'
* \p{TaiLe}                                  Script 'Tai_Le'
* \p{Tamil}                                  Script 'Tamil'
* \p{Telugu}                                 Script 'Telugu'
* \p{TerminalPunctuation}                    Extended property 'Terminal_Punctuation'
* \p{Thaana}                                 Script 'Thaana'
* \p{Thai}                                   Script 'Thai'
* \p{Tibetan}                                Script 'Tibetan'
* \p{Tifinagh}                               Script 'Tifinagh'
  \p{Title}                                  [[:Title:]]
* \p{Ugaritic}                               Script 'Ugaritic'
* \p{UnifiedIdeograph}                       Extended property 'Unified_Ideograph'
* \p{Uppercase}                              [\p{Lu}\p{Other_Uppercase}]
  \p{Upper}                                  [[:Upper:]]
* \p{VariationSelector}                      Extended property 'Variation_Selector'
* \p{WhiteSpace}                             Extended property 'White_Space'
  \p{Word}                                   [[:Word:]]
  \p{XDigit}                                 [[:XDigit:]]
* \p{Yi}                                     Script 'Yi'
* \p{Zl}                                     Alias for \p{Zl} (General Category 'Zl')
  \p{Zl}                                     General Category 'Zl'
* \p{Zp}                                     Alias for \p{Zp} (General Category 'Zp')
  \p{Zp}                                     General Category 'Zp'
* \p{Zs}                                     Alias for \p{Zs} (General Category 'Zs')
  \p{Zs}                                     General Category 'Zs'
* \p{Z}                                      Alias for \p{Z} (Major Category 'Z')
  \p{Z}                                      Major Category 'Z'
  \p{_CanonDCIJ}                             (for internal casefolding use)
  \p{_CaseIgnorable}                         (for internal casefolding use)
  \p{_CombAbove}                             (for internal casefolding use)
                                                                                                                                                                 package Exporter;

require 5.006;

# Be lean.
#use strict;
#no strict 'refs';

our $Debug = 0;
our $ExportLevel = 0;
our $Verbose ||= 0;
our $VERSION = '5.58';
our (%Cache);
$Carp::Internal{Exporter} = 1;

sub as_heavy {
  require Exporter::Heavy;
  # Unfortunately, this does not work if the caller is aliased as *name = \&foo
  # Thus the need to create a lot of identical subroutines
  my $c = (caller(1))[3];
  $c =~ s/.*:://;
  \&{"Exporter::Heavy::heavy_$c"};
}

sub export {
  goto &{as_heavy()};
}

sub import {
  my $pkg = shift;
  my $callpkg = caller($ExportLevel);

  if ($pkg eq "Exporter" and @_ and $_[0] eq "import") {
    *{$callpkg."::import"} = \&import;
    return;
  }

  # We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-(
  my($exports, $fail) = (\@{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"});
  return export $pkg, $callpkg, @_
    if $Verbose or $Debug or @$fail > 1;
  my $export_cache = ($Cache{$pkg} ||= {});
  my $args = @_ or @_ = @$exports;

  local $_;
  if ($args and not %$export_cache) {
    s/^&//, $export_cache->{$_} = 1
      foreach (@$exports, @{"$pkg\::EXPORT_OK"});
  }
  my $heavy;
  # Try very hard not to use {} and hence have to  enter scope on the foreach
  # We bomb out of the loop with last as soon as heavy is set.
  if ($args or $fail) {
    ($heavy = (/\W/ or $args and not exists $export_cache->{$_}
               or @$fail and $_ eq $fail->[0])) and last
                 foreach (@_);
  } else {
    ($heavy = /\W/) and last
      foreach (@_);
  }
  return export $pkg, $callpkg, ($args ? @_ : ()) if $heavy;
  local $SIG{__WARN__} = 
	sub {require Carp; &Carp::carp};
  # shortcut for the common case of no type character
  *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_;
}

# Default methods

sub export_fail {
    my $self = shift;
    @_;
}

# Unfortunately, caller(1)[3] "does not work" if the caller is aliased as
# *name = \&foo.  Thus the need to create a lot of identical subroutines
# Otherwise we could have aliased them to export().

sub export_to_level {
  goto &{as_heavy()};
}

sub export_tags {
  goto &{as_heavy()};
}

sub export_ok_tags {
  goto &{as_heavy()};
}

sub require_version {
  goto &{as_heavy()};
}

1;
__END__

=head1 NAME

Exporter - Implements default import method for modules

=head1 SYNOPSIS

In module YourModule.pm:

  package YourModule;
  require Exporter;
  @ISA = qw(Exporter);
  @EXPORT_OK = qw(munge frobnicate);  # symbols to export on request

or

  package YourModule;
  use Exporter 'import'; # gives you Exporter's import() method directly
  @EXPORT_OK = qw(munge frobnicate);  # symbols to export on request

In other files which wish to use YourModule:

  use ModuleName qw(frobnicate);      # import listed symbols
  frobnicate ($left, $right)          # calls YourModule::frobnicate

=head1 DESCRIPTION

The Exporter module implements an C<import> method which allows a module
to export functions and variables to its users' namespaces. Many modules
use Exporter rather than implementing their own C<import> method because
Exporter provides a highly flexible interface, with an implementation optimised
for the common case.

Perl automatically calls the C<import> method when processing a
C<use> statement for a module. Modules and C<use> are documented
in L<perlfunc> and L<perlmod>. Understanding the concept of
modules and how the C<use> statement operates is important to
understanding the Exporter.

=head2 How to Export

The arrays C<@EXPORT> and C<@EXPORT_OK> in a module hold lists of
symbols that are going to be exported into the users name space by
default, or which they can request to be exported, respectively.  The
symbols can represent functions, scalars, arrays, hashes, or typeglobs.
The symbols must be given by full name with the exception that the
ampersand in front of a function is optional, e.g.

    @EXPORT    = qw(afunc $scalar @array);   # afunc is a function
    @EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc

If you are only exporting function names it is recommended to omit the
ampersand, as the implementation is faster this way.

=head2 Selecting What To Export

Do B<not> export method names!

Do B<not> export anything else by default without a good reason!

Exports pollute the namespace of the module user.  If you must export
try to use @EXPORT_OK in preference to @EXPORT and avoid short or
common symbol names to reduce the risk of name clashes.

Generally anything not exported is still accessible from outside the
module using the ModuleName::item_name (or $blessed_ref-E<gt>method)
syntax.  By convention you can use a leading underscore on names to
informally indicate that they are 'internal' and not for public use.

(It is actually possible to get private functions by saying:

  my $subref = sub { ... };
  $subref->(@args);            # Call it as a function
  $obj->$subref(@args);        # Use it as a method

However if you use them for methods it is up to you to figure out
how to make inheritance work.)

As a general rule, if the module is trying to be object oriented
then export nothing. If it's just a collection of functions then
@EXPORT_OK anything but use @EXPORT with caution. For function and
method names use barewords in preference to names prefixed with
ampersands for the export lists.

Other module design guidelines can be found in L<perlmod>.

=head2 How to Import

In other files which wish to use your module there are three basic ways for
them to load your module and import its symbols:

=over 4

=item C<use ModuleName;>

This imports all the symbols from ModuleName's @EXPORT into the namespace
of the C<use> statement.

=item C<use ModuleName ();>

This causes perl to load your module but does not import any symbols.

=item C<use ModuleName qw(...);>

This imports only the symbols listed by the caller into their namespace.
All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error
occurs. The advanced export features of Exporter are accessed like this,
but with list entries that are syntactically distinct from symbol names.

=back

Unless you want to use its advanced features, this is probably all you
need to know to use Exporter.

=head1 Advanced features

=head2 Specialised Import Lists

If any of the entries in an import list begins with !, : or / then
the list is treated as a series of specifications which either add to
or delete from the list of names to import. They are processed left to
right. Specifications are in the form:

    [!]name         This name only
    [!]:DEFAULT     All names in @EXPORT
    [!]:tag         All names in $EXPORT_TAGS{tag} anonymous list
    [!]/pattern/    All names in @EXPORT and @EXPORT_OK which match

A leading ! indicates that matching names should be deleted from the
list of names to import.  If the first specification is a deletion it
is treated as though preceded by :DEFAULT. If you just want to import
extra names in addition to the default set you will still need to
include :DEFAULT explicitly.

e.g., Module.pm defines:

    @EXPORT      = qw(A1 A2 A3 A4 A5);
    @EXPORT_OK   = qw(B1 B2 B3 B4 B5);
    %EXPORT_TAGS = (T1 => [qw(A1 A2 B1 B2)], T2 => [qw(A1 A2 B3 B4)]);

    Note that you cannot use tags in @EXPORT or @EXPORT_OK.
    Names in EXPORT_TAGS must also appear in @EXPORT or @EXPORT_OK.

An application using Module can say something like:

    use Module qw(:DEFAULT :T2 !B3 A3);

Other examples include:

    use Socket qw(!/^[AP]F_/ !SOMAXCONN !SOL_SOCKET);
    use POSIX  qw(:errno_h :termios_h !TCSADRAIN !/^EXIT/);

Remember that most patterns (using //) will need to be anchored
with a leading ^, e.g., C</^EXIT/> rather than C</EXIT/>.

You can say C<BEGIN { $Exporter::Verbose=1 }> to see how the
specifications are being processed and what is actually being imported
into modules.

=head2 Exporting without using Exporter's import method

Exporter has a special method, 'export_to_level' which is used in situations
where you can't directly call Exporter's import method. The export_to_level
method looks like:

    MyPackage->export_to_level($where_to_export, $package, @what_to_export);

where $where_to_export is an integer telling how far up the calling stack
to export your symbols, and @what_to_export is an array telling what
symbols *to* export (usually this is @_).  The $package argument is
currently unused.

For example, suppose that you have a module, A, which already has an
import function:

    package A;

    @ISA = qw(Exporter);
    @EXPORT_OK = qw ($b);

    sub import
    {
	$A::b = 1;     # not a very useful import method
    }

and you want to Export symbol $A::b back to the module that called 
package A. Since Exporter relies on the import method to work, via 
inheritance, as it stands Exporter::import() will never get called. 
Instead, say the following:

    package A;
    @ISA = qw(Exporter);
    @EXPORT_OK = qw ($b);

    sub import
    {
	$A::b = 1;
	A->export_to_level(1, @_);
    }

This will export the symbols one level 'above' the current package - ie: to 
the program or module that used package A. 

Note: Be careful not to modify C<@_> at all before you call export_to_level
- or people using your package will get very unexplained results!

=head2 Exporting without inheriting from Exporter

By including Exporter in your @ISA you inherit an Exporter's import() method
but you also inherit several other helper methods which you probably don't
want. To avoid this you can do

  package YourModule;
  use Exporter qw( import );

which will export Exporter's own import() method into YourModule.
Everything will work as before but you won't need to include Exporter in
@YourModule::ISA.

=head2 Module Version Checking

The Exporter module will convert an attempt to import a number from a
module into a call to $module_name-E<gt>require_version($value). This can
be used to validate that the version of the module being used is
greater than or equal to the required version.

The Exporter module supplies a default require_version method which
checks the value of $VERSION in the exporting module.

Since the default require_version method treats the $VERSION number as
a simple numeric value it will regard version 1.10 as lower than
1.9. For this reason it is strongly recommended that you use numbers
with at least two decimal places, e.g., 1.09.

=head2 Managing Unknown Symbols

In some situations you may want to prevent certain symbols from being
exported. Typically this applies to extensions which have functions
or constants that may not exist on some systems.

The names of any symbols that cannot be exported should be listed
in the C<@EXPORT_FAIL> array.

If a module attempts to import any of these symbols the Exporter
will give the module an opportunity to handle the situation before
generating an error. The Exporter will call an export_fail method
with a list of the failed symbols:

  @failed_symbols = $module_name->export_fail(@failed_symbols);

If the export_fail method returns an empty list then no error is
recorded and all the requested symbols are exported. If the returned
list is not empty then an error is generated for each symbol and the
export fails. The Exporter provides a default export_fail method which
simply returns the list unchanged.

Uses for the export_fail method include giving better error messages
for some symbols and performing lazy architectural checks (put more
symbols into @EXPORT_FAIL by default and then take them out if someone
actually tries to use them and an expensive check shows that they are
usable on that platform).

=head2 Tag Handling Utility Functions

Since the symbols listed within %EXPORT_TAGS must also appear in either
@EXPORT or @EXPORT_OK, two utility functions are provided which allow
you to easily add tagged sets of symbols to @EXPORT or @EXPORT_OK:

  %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);

  Exporter::export_tags('foo');     # add aa, bb and cc to @EXPORT
  Exporter::export_ok_tags('bar');  # add aa, cc and dd to @EXPORT_OK

Any names which are not tags are added to @EXPORT or @EXPORT_OK
unchanged but will trigger a warning (with C<-w>) to avoid misspelt tags
names being silently added to @EXPORT or @EXPORT_OK. Future versions
may make this a fatal error.

=head2 Generating combined tags

If several symbol categories exist in %EXPORT_TAGS, it's usually
useful to create the utility ":all" to simplify "use" statements.

The simplest way to do this is:

  %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);

  # add all the other ":class" tags to the ":all" class,
  # deleting duplicates
  {
    my %seen;

    push @{$EXPORT_TAGS{all}},
      grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS;
  }

CGI.pm creates an ":all" tag which contains some (but not really
all) of its categories.  That could be done with one small
change:

  # add some of the other ":class" tags to the ":all" class,
  # deleting duplicates
  {
    my %seen;

    push @{$EXPORT_TAGS{all}},
      grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}}
        foreach qw/html2 html3 netscape form cgi internal/;
  }

Note that the tag names in %EXPORT_TAGS don't have the leading ':'.

=head2 C<AUTOLOAD>ed Constants

Many modules make use of C<AUTOLOAD>ing for constant subroutines to
avoid having to compile and waste memory on rarely used values (see
L<perlsub> for details on constant subroutines).  Calls to such
constant subroutines are not optimized away at compile time because
they can't be checked at compile time for constancy.

Even if a prototype is available at compile time, the body of the
subroutine is not (it hasn't been C<AUTOLOAD>ed yet). perl needs to
examine both the C<()> prototype and the body of a subroutine at
compile time to detect that it can safely replace calls to that
subroutine with the constant value.

A workaround for this is to call the constants once in a C<BEGIN> block:

   package My ;

   use Socket ;

   foo( SO_LINGER );     ## SO_LINGER NOT optimized away; called at runtime
   BEGIN { SO_LINGER }
   foo( SO_LINGER );     ## SO_LINGER optimized away at compile time.

This forces the C<AUTOLOAD> for C<SO_LINGER> to take place before
SO_LINGER is encountered later in C<My> package.

If you are writing a package that C<AUTOLOAD>s, consider forcing
an C<AUTOLOAD> for any constants explicitly imported by other packages
or which are usually used when your package is C<use>d.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             E  .   B  ..  E  file.pm E base.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         package Digest::file;

use strict;

use Exporter ();
use Carp qw(croak);
use Digest ();

use vars qw($VERSION @ISA @EXPORT_OK);

$VERSION = "1.00";
@ISA = qw(Exporter);
@EXPORT_OK = qw(digest_file_ctx digest_file digest_file_hex digest_file_base64);

sub digest_file_ctx {
    my $file = shift;
    croak("No digest algorithm specified") unless @_;
    local *F;
    open(F, $file) || croak("Can't open '$file': $!");
    binmode(F);
    my $ctx = Digest->new(@_);
    $ctx->addfile(*F);
    close(F);
    return $ctx;
}

sub digest_file {
    digest_file_ctx(@_)->digest;
}

sub digest_file_hex {
    digest_file_ctx(@_)->hexdigest;
}

sub digest_file_base64 {
    digest_file_ctx(@_)->b64digest;
}

1;

__END__

=head1 NAME

Digest::file - Calculate digests of files

=head1 SYNOPSIS

  # Poor mans "md5sum" command
  use Digest::file qw(digest_file_hex);
  for (@ARGV) {
      print digest_file_hex($_, "MD5"), "  $_\n";
  }

=head1 DESCRIPTION

This module provide 3 convenience functions to calculate the digest
of files.  The following functions are provided:

=over

=item digest_file( $file, $algorithm, [$arg,...] )

This function will calculate and return the binary digest of the bytes
of the given file.  The function will croak if it fails to open or
read the file.

The $algorithm is a string like "MD2", "MD5", "SHA-1", "SHA-512".
Additional arguments are passed to the constructor for the
implementation of the given algorithm.

=item digest_file_hex( $file, $algorithm, [$arg,...] )

Same as digest_file(), but return the digest in hex form.

=item digest_file_base64( $file, $algorithm, [$arg,...] )

Same as digest_file(), but return the digest as a base64 encoded
string.

=back

=head1 SEE ALSO

L<Digest>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 package Digest::base;

use strict;
use vars qw($VERSION);
$VERSION = "1.00";

# subclass is supposed to implement at least these
sub new;
sub clone;
sub add;
sub digest;

sub reset {
    my $self = shift;
    $self->new(@_);  # ugly
}

sub addfile {
    my ($self, $handle) = @_;

    my $n;
    my $buf = "";

    while (($n = read($handle, $buf, 4*1024))) {
        $self->add($buf);
    }
    unless (defined $n) {
	require Carp;
	Carp::croak("Read failed: $!");
    }

    $self;
}

sub add_bits {
    my $self = shift;
    my $bits;
    my $nbits;
    if (@_ == 1) {
	my $arg = shift;
	$bits = pack("B*", $arg);
	$nbits = length($arg);
    }
    else {
	($bits, $nbits) = @_;
    }
    if (($nbits % 8) != 0) {
	require Carp;
	Carp::croak("Number of bits must be multiple of 8 for this algorithm");
    }
    return $self->add(substr($bits, 0, $nbits/8));
}

sub hexdigest {
    my $self = shift;
    return unpack("H*", $self->digest(@_));
}

sub b64digest {
    my $self = shift;
    require MIME::Base64;
    my $b64 = MIME::Base64::encode($self->digest(@_), "");
    $b64 =~ s/=+$//;
    return $b64;
}

1;

__END__

=head1 NAME

Digest::base - Digest base class

=head1 SYNOPSIS

  package Digest::Foo;
  use base 'Digest::base';

=head1 DESCRIPTION

The C<Digest::base> class provide implementations of the methods
C<addfile> and C<add_bits> in terms of C<add>, and of the methods
C<hexdigest> and C<b64digest> in terms of C<digest>.

Digest implementations might want to inherit from this class to get
this implementations of the alternative I<add> and I<digest> methods.
A minimal subclass needs to implement the following methods by itself:

    new
    clone
    add
    digest

The arguments and expected behaviour of these methods are described in
L<Digest>.

=head1 SEE ALSO

L<Digest>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    E  .   B  ..  E  Open3.pmE Open2.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        package IPC::Open3;

use strict;
no strict 'refs'; # because users pass me bareword filehandles
our ($VERSION, @ISA, @EXPORT);

require Exporter;

use Carp;
use Symbol qw(gensym qualify);

$VERSION	= 1.02;
@ISA		= qw(Exporter);
@EXPORT		= qw(open3);

=head1 NAME

IPC::Open3, open3 - open a process for reading, writing, and error handling

=head1 SYNOPSIS

    $pid = open3(\*CHLD_IN, \*CHLD_OUT, \*CHLD_ERR,
		    'some cmd and args', 'optarg', ...);

    my($wtr, $rdr, $err);
    $pid = open3($wtr, $rdr, $err,
		    'some cmd and args', 'optarg', ...);

=head1 DESCRIPTION

Extremely similar to open2(), open3() spawns the given $cmd and
connects CHLD_OUT for reading from the child, CHLD_IN for writing to
the child, and CHLD_ERR for errors.  If CHLD_ERR is false, or the
same file descriptor as CHLD_OUT, then STDOUT and STDERR of the child
are on the same filehandle.  The CHLD_IN will have autoflush turned
on.

If CHLD_IN begins with C<< <& >>, then CHLD_IN will be closed in the
parent, and the child will read from it directly.  If CHLD_OUT or
CHLD_ERR begins with C<< >& >>, then the child will send output
directly to that filehandle.  In both cases, there will be a dup(2)
instead of a pipe(2) made.

If either reader or writer is the null string, this will be replaced
by an autogenerated filehandle.  If so, you must pass a valid lvalue
in the parameter slot so it can be overwritten in the caller, or 
an exception will be raised.

The filehandles may also be integers, in which case they are understood
as file descriptors.

open3() returns the process ID of the child process.  It doesn't return on
failure: it just raises an exception matching C</^open3:/>.  However,
C<exec> failures in the child are not detected.  You'll have to 
trap SIGPIPE yourself.

Note if you specify C<-> as the command, in an analogous fashion to
C<open(FOO, "-|")> the child process will just be the forked Perl
process rather than an external command.  This feature isn't yet
supported on Win32 platforms.

open3() does not wait for and reap the child process after it exits.  
Except for short programs where it's acceptable to let the operating system
take care of this, you need to do this yourself.  This is normally as 
simple as calling C<waitpid $pid, 0> when you're done with the process.
Failing to do this can result in an accumulation of defunct or "zombie"
processes.  See L<perlfunc/waitpid> for more information.

If you try to read from the child's stdout writer and their stderr
writer, you'll have problems with blocking, which means you'll want
to use select() or the IO::Select, which means you'd best use
sysread() instead of readline() for normal stuff.

This is very dangerous, as you may block forever.  It assumes it's
going to talk to something like B<bc>, both writing to it and reading
from it.  This is presumably safe because you "know" that commands
like B<bc> will read a line at a time and output a line at a time.
Programs like B<sort> that read their entire input stream first,
however, are quite apt to cause deadlock.

The big problem with this approach is that if you don't have control
over source code being run in the child process, you can't control
what it does with pipe buffering.  Thus you can't just open a pipe to
C<cat -v> and continually read and write a line from it.

=head1 WARNING

The order of arguments differs from that of open2().

=cut

# &open3: Marc Horowitz <marc@mit.edu>
# derived mostly from &open2 by tom christiansen, <tchrist@convex.com>
# fixed for 5.001 by Ulrich Kunitz <kunitz@mai-koeln.com>
# ported to Win32 by Ron Schmidt, Merrill Lynch almost ended my career
# fixed for autovivving FHs, tchrist again
# allow fd numbers to be used, by Frank Tobin
# allow '-' as command (c.f. open "-|"), by Adam Spiers <perl@adamspiers.org>
#
# $Id: open3.pl,v 1.1 1993/11/23 06:26:15 marc Exp $
#
# usage: $pid = open3('wtr', 'rdr', 'err' 'some cmd and args', 'optarg', ...);
#
# spawn the given $cmd and connect rdr for
# reading, wtr for writing, and err for errors.
# if err is '', or the same as rdr, then stdout and
# stderr of the child are on the same fh.  returns pid
# of child (or dies on failure).


# if wtr begins with '<&', then wtr will be closed in the parent, and
# the child will read from it directly.  if rdr or err begins with
# '>&', then the child will send output directly to that fd.  In both
# cases, there will be a dup() instead of a pipe() made.


# WARNING: this is dangerous, as you may block forever
# unless you are very careful.
#
# $wtr is left unbuffered.
#
# abort program if
#   rdr or wtr are null
#   a system call fails

our $Me = 'open3 (bug)';	# you should never see this, it's always localized

# Fatal.pm needs to be fixed WRT prototypes.

sub xfork {
    my $pid = fork;
    defined $pid or croak "$Me: fork failed: $!";
    return $pid;
}

sub xpipe {
    pipe $_[0], $_[1] or croak "$Me: pipe($_[0], $_[1]) failed: $!";
}

# I tried using a * prototype character for the filehandle but it still
# disallows a bearword while compiling under strict subs.

sub xopen {
    open $_[0], $_[1] or croak "$Me: open($_[0], $_[1]) failed: $!";
}

sub xclose {
    close $_[0] or croak "$Me: close($_[0]) failed: $!";
}

sub fh_is_fd {
    return $_[0] =~ /\A=?(\d+)\z/;
}

sub xfileno {
    return $1 if $_[0] =~ /\A=?(\d+)\z/;  # deal with fh just being an fd
    return fileno $_[0];
}

my $do_spawn = $^O eq 'os2' || $^O eq 'MSWin32';

sub _open3 {
    local $Me = shift;
    my($package, $dad_wtr, $dad_rdr, $dad_err, @cmd) = @_;
    my($dup_wtr, $dup_rdr, $dup_err, $kidpid);

    # simulate autovivification of filehandles because
    # it's too ugly to use @_ throughout to make perl do it for us
    # tchrist 5-Mar-00

    unless (eval  {
	$dad_wtr = $_[1] = gensym unless defined $dad_wtr && length $dad_wtr;
	$dad_rdr = $_[2] = gensym unless defined $dad_rdr && length $dad_rdr;
	1; }) 
    {
	# must strip crud for croak to add back, or looks ugly
	$@ =~ s/(?<=value attempted) at .*//s;
	croak "$Me: $@";
    } 

    $dad_err ||= $dad_rdr;

    $dup_wtr = ($dad_wtr =~ s/^[<>]&//);
    $dup_rdr = ($dad_rdr =~ s/^[<>]&//);
    $dup_err = ($dad_err =~ s/^[<>]&//);

    # force unqualified filehandles into caller's package
    $dad_wtr = qualify $dad_wtr, $package unless fh_is_fd($dad_wtr);
    $dad_rdr = qualify $dad_rdr, $package unless fh_is_fd($dad_rdr);
    $dad_err = qualify $dad_err, $package unless fh_is_fd($dad_err);

    my $kid_rdr = gensym;
    my $kid_wtr = gensym;
    my $kid_err = gensym;

    xpipe $kid_rdr, $dad_wtr if !$dup_wtr;
    xpipe $dad_rdr, $kid_wtr if !$dup_rdr;
    xpipe $dad_err, $kid_err if !$dup_err && $dad_err ne $dad_rdr;

    $kidpid = $do_spawn ? -1 : xfork;
    if ($kidpid == 0) {		# Kid
	# A tie in the parent should not be allowed to cause problems.
	untie *STDIN;
	untie *STDOUT;
	# If she wants to dup the kid's stderr onto her stdout I need to
	# save a copy of her stdout before I put something else there.
	if ($dad_rdr ne $dad_err && $dup_err
		&& xfileno($dad_err) == fileno(STDOUT)) {
	    my $tmp = gensym;
	    xopen($tmp, ">&$dad_err");
	    $dad_err = $tmp;
	}

	if ($dup_wtr) {
	    xopen \*STDIN,  "<&$dad_wtr" if fileno(STDIN) != xfileno($dad_wtr);
	} else {
	    xclose $dad_wtr;
	    xopen \*STDIN,  "<&=" . fileno $kid_rdr;
	}
	if ($dup_rdr) {
	    xopen \*STDOUT, ">&$dad_rdr" if fileno(STDOUT) != xfileno($dad_rdr);
	} else {
	    xclose $dad_rdr;
	    xopen \*STDOUT, ">&=" . fileno $kid_wtr;
	}
	if ($dad_rdr ne $dad_err) {
	    if ($dup_err) {
		# I have to use a fileno here because in this one case
		# I'm doing a dup but the filehandle might be a reference
		# (from the special case above).
		xopen \*STDERR, ">&" . xfileno($dad_err)
		    if fileno(STDERR) != xfileno($dad_err);
	    } else {
		xclose $dad_err;
		xopen \*STDERR, ">&=" . fileno $kid_err;
	    }
	} else {
	    xopen \*STDERR, ">&STDOUT" if fileno(STDERR) != fileno(STDOUT);
	}
	if ($cmd[0] eq '-') {
	    croak "Arguments don't make sense when the command is '-'"
	      if @cmd > 1;
	    return 0;
	}
	local($")=(" ");
	exec @cmd # XXX: wrong process to croak from
	    or croak "$Me: exec of @cmd failed";
    } elsif ($do_spawn) {
	# All the bookkeeping of coincidence between handles is
	# handled in spawn_with_handles.

	my @close;
	if ($dup_wtr) {
	  $kid_rdr = \*{$dad_wtr};
	  push @close, $kid_rdr;
	} else {
	  push @close, \*{$dad_wtr}, $kid_rdr;
	}
	if ($dup_rdr) {
	  $kid_wtr = \*{$dad_rdr};
	  push @close, $kid_wtr;
	} else {
	  push @close, \*{$dad_rdr}, $kid_wtr;
	}
	if ($dad_rdr ne $dad_err) {
	    if ($dup_err) {
	      $kid_err = \*{$dad_err};
	      push @close, $kid_err;
	    } else {
	      push @close, \*{$dad_err}, $kid_err;
	    }
	} else {
	  $kid_err = $kid_wtr;
	}
	require IO::Pipe;
	$kidpid = eval {
	    spawn_with_handles( [ { mode => 'r',
				    open_as => $kid_rdr,
				    handle => \*STDIN },
				  { mode => 'w',
				    open_as => $kid_wtr,
				    handle => \*STDOUT },
				  { mode => 'w',
				    open_as => $kid_err,
				    handle => \*STDERR },
				], \@close, @cmd);
	};
	die "$Me: $@" if $@;
    }

    xclose $kid_rdr if !$dup_wtr;
    xclose $kid_wtr if !$dup_rdr;
    xclose $kid_err if !$dup_err && $dad_rdr ne $dad_err;
    # If the write handle is a dup give it away entirely, close my copy
    # of it.
    xclose $dad_wtr if $dup_wtr;

    select((select($dad_wtr), $| = 1)[0]); # unbuffer pipe
    $kidpid;
}

sub open3 {
    if (@_ < 4) {
	local $" = ', ';
	croak "open3(@_): not enough arguments";
    }
    return _open3 'open3', scalar caller, @_
}

sub spawn_with_handles {
    my $fds = shift;		# Fields: handle, mode, open_as
    my $close_in_child = shift;
    my ($fd, $pid, @saved_fh, $saved, %saved, @errs);
    require Fcntl;

    foreach $fd (@$fds) {
	$fd->{tmp_copy} = IO::Handle->new_from_fd($fd->{handle}, $fd->{mode});
	$saved{fileno $fd->{handle}} = $fd->{tmp_copy};
    }
    foreach $fd (@$fds) {
	bless $fd->{handle}, 'IO::Handle'
	    unless eval { $fd->{handle}->isa('IO::Handle') } ;
	# If some of handles to redirect-to coincide with handles to
	# redirect, we need to use saved variants:
	$fd->{handle}->fdopen($saved{fileno $fd->{open_as}} || $fd->{open_as},
			      $fd->{mode});
    }
    unless ($^O eq 'MSWin32') {
	# Stderr may be redirected below, so we save the err text:
	foreach $fd (@$close_in_child) {
	    fcntl($fd, Fcntl::F_SETFD(), 1) or push @errs, "fcntl $fd: $!"
		unless $saved{fileno $fd}; # Do not close what we redirect!
	}
    }

    unless (@errs) {
	$pid = eval { system 1, @_ }; # 1 == P_NOWAIT
	push @errs, "IO::Pipe: Can't spawn-NOWAIT: $!" if !$pid || $pid < 0;
    }

    foreach $fd (@$fds) {
	$fd->{handle}->fdopen($fd->{tmp_copy}, $fd->{mode});
	$fd->{tmp_copy}->close or croak "Can't close: $!";
    }
    croak join "\n", @errs if @errs;
    return $pid;
}

1; # so require is happy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             package IPC::Open2;

use strict;
our ($VERSION, @ISA, @EXPORT);

require 5.000;
require Exporter;

$VERSION	= 1.02;
@ISA		= qw(Exporter);
@EXPORT		= qw(open2);

=head1 NAME

IPC::Open2, open2 - open a process for both reading and writing

=head1 SYNOPSIS

    use IPC::Open2;

    $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'some cmd and args');
      # or without using the shell
    $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'some', 'cmd', 'and', 'args');

    # or with handle autovivification
    my($chld_out, $chld_in);
    $pid = open2($chld_out, $chld_in, 'some cmd and args');
      # or without using the shell
    $pid = open2($chld_out, $chld_in, 'some', 'cmd', 'and', 'args');

=head1 DESCRIPTION

The open2() function runs the given $cmd and connects $chld_out for
reading and $chld_in for writing.  It's what you think should work 
when you try

    $pid = open(HANDLE, "|cmd args|");

The write filehandle will have autoflush turned on.

If $chld_out is a string (that is, a bareword filehandle rather than a glob
or a reference) and it begins with C<< >& >>, then the child will send output
directly to that file handle.  If $chld_in is a string that begins with
C<< <& >>, then $chld_in will be closed in the parent, and the child will
read from it directly.  In both cases, there will be a dup(2) instead of a
pipe(2) made.

If either reader or writer is the null string, this will be replaced
by an autogenerated filehandle.  If so, you must pass a valid lvalue
in the parameter slot so it can be overwritten in the caller, or
an exception will be raised.

open2() returns the process ID of the child process.  It doesn't return on
failure: it just raises an exception matching C</^open2:/>.  However,
C<exec> failures in the child are not detected.  You'll have to
trap SIGPIPE yourself.

open2() does not wait for and reap the child process after it exits.
Except for short programs where it's acceptable to let the operating system
take care of this, you need to do this yourself.  This is normally as
simple as calling C<waitpid $pid, 0> when you're done with the process.
Failing to do this can result in an accumulation of defunct or "zombie"
processes.  See L<perlfunc/waitpid> for more information.

This whole affair is quite dangerous, as you may block forever.  It
assumes it's going to talk to something like B<bc>, both writing
to it and reading from it.  This is presumably safe because you
"know" that commands like B<bc> will read a line at a time and
output a line at a time.  Programs like B<sort> that read their
entire input stream first, however, are quite apt to cause deadlock.

The big problem with this approach is that if you don't have control 
over source code being run in the child process, you can't control
what it does with pipe buffering.  Thus you can't just open a pipe to
C<cat -v> and continually read and write a line from it.

The IO::Pty and Expect modules from CPAN can help with this, as they
provide a real tty (well, a pseudo-tty, actually), which gets you
back to line buffering in the invoked command again.

=head1 WARNING 

The order of arguments differs from that of open3().

=head1 SEE ALSO

See L<IPC::Open3> for an alternative that handles STDERR as well.  This
function is really just a wrapper around open3().

=cut

# &open2: tom christiansen, <tchrist@convex.com>
#
# usage: $pid = open2('rdr', 'wtr', 'some cmd and args');
#    or  $pid = open2('rdr', 'wtr', 'some', 'cmd', 'and', 'args');
#
# spawn the given $cmd and connect $rdr for
# reading and $wtr for writing.  return pid
# of child, or 0 on failure.  
# 
# WARNING: this is dangerous, as you may block forever
# unless you are very careful.  
# 
# $wtr is left unbuffered.
# 
# abort program if
#	rdr or wtr are null
# 	a system call fails

require IPC::Open3;

sub open2 {
    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
    return IPC::Open3::_open3('open2', scalar caller,
				$_[1], $_[0], '>&STDERR', @_[2 .. $#_]);
}

1
                                                                                                                                              package bigfloat;
require "bigint.pl";
#
# This library is no longer being maintained, and is included for backward
# compatibility with Perl 4 programs which may require it.
#
# In particular, this should not be used as an example of modern Perl
# programming techniques.
#
# Suggested alternative: Math::BigFloat
#
# Arbitrary length float math package
#
# by Mark Biggar
#
# number format
#   canonical strings have the form /[+-]\d+E[+-]\d+/
#   Input values can have embedded whitespace
# Error returns
#   'NaN'           An input parameter was "Not a Number" or 
#                       divide by zero or sqrt of negative number
# Division is computed to 
#   max($div_scale,length(dividend)+length(divisor)) 
#   digits by default.
# Also used for default sqrt scale

$div_scale = 40;

# Rounding modes one of 'even', 'odd', '+inf', '-inf', 'zero' or 'trunc'.

$rnd_mode = 'even';

#   bigfloat routines
#
#   fadd(NSTR, NSTR) return NSTR            addition
#   fsub(NSTR, NSTR) return NSTR            subtraction
#   fmul(NSTR, NSTR) return NSTR            multiplication
#   fdiv(NSTR, NSTR[,SCALE]) returns NSTR   division to SCALE places
#   fneg(NSTR) return NSTR                  negation
#   fabs(NSTR) return NSTR                  absolute value
#   fcmp(NSTR,NSTR) return CODE             compare undef,<0,=0,>0
#   fround(NSTR, SCALE) return NSTR         round to SCALE digits
#   ffround(NSTR, SCALE) return NSTR        round at SCALEth place
#   fnorm(NSTR) return (NSTR)               normalize
#   fsqrt(NSTR[, SCALE]) return NSTR        sqrt to SCALE places

# Convert a number to canonical string form.
#   Takes something that looks like a number and converts it to
#   the form /^[+-]\d+E[+-]\d+$/.
sub main'fnorm { #(string) return fnum_str
    local($_) = @_;
    s/\s+//g;                               # strip white space
    if (/^([+-]?)(\d*)(\.(\d*))?([Ee]([+-]?\d+))?$/
	  && ($2 ne '' || defined($4))) {
	my $x = defined($4) ? $4 : '';
	&norm(($1 ? "$1$2$x" : "+$2$x"), (($x ne '') ? $6-length($x) : $6));
    } else {
	'NaN';
    }
}

# normalize number -- for internal use
sub norm { #(mantissa, exponent) return fnum_str
    local($_, $exp) = @_;
    if ($_ eq 'NaN') {
	'NaN';
    } else {
	s/^([+-])0+/$1/;                        # strip leading zeros
	if (length($_) == 1) {
	    '+0E+0';
	} else {
	    $exp += length($1) if (s/(0+)$//);  # strip trailing zeros
	    sprintf("%sE%+ld", $_, $exp);
	}
    }
}

# negation
sub main'fneg { #(fnum_str) return fnum_str
    local($_) = &'fnorm($_[$[]);
    vec($_,0,8) ^= ord('+') ^ ord('-') unless $_ eq '+0E+0'; # flip sign
    if ( ord("\t") == 9 ) { # ascii
        s/^H/N/;
    }
    else { # ebcdic character set
        s/\373/N/;
    }
    $_;
}

# absolute value
sub main'fabs { #(fnum_str) return fnum_str
    local($_) = &'fnorm($_[$[]);
    s/^-/+/;		                       # mash sign
    $_;
}

# multiplication
sub main'fmul { #(fnum_str, fnum_str) return fnum_str
    local($x,$y) = (&'fnorm($_[$[]),&'fnorm($_[$[+1]));
    if ($x eq 'NaN' || $y eq 'NaN') {
	'NaN';
    } else {
	local($xm,$xe) = split('E',$x);
	local($ym,$ye) = split('E',$y);
	&norm(&'bmul($xm,$ym),$xe+$ye);
    }
}

# addition
sub main'fadd { #(fnum_str, fnum_str) return fnum_str
    local($x,$y) = (&'fnorm($_[$[]),&'fnorm($_[$[+1]));
    if ($x eq 'NaN' || $y eq 'NaN') {
	'NaN';
    } else {
	local($xm,$xe) = split('E',$x);
	local($ym,$ye) = split('E',$y);
	($xm,$xe,$ym,$ye) = ($ym,$ye,$xm,$xe) if ($xe < $ye);
	&norm(&'badd($ym,$xm.('0' x ($xe-$ye))),$ye);
    }
}

# subtraction
sub main'fsub { #(fnum_str, fnum_str) return fnum_str
    &'fadd($_[$[],&'fneg($_[$[+1]));    
}

# division
#   args are dividend, divisor, scale (optional)
#   result has at most max(scale, length(dividend), length(divisor)) digits
sub main'fdiv #(fnum_str, fnum_str[,scale]) return fnum_str
{
    local($x,$y,$scale) = (&'fnorm($_[$[]),&'fnorm($_[$[+1]),$_[$[+2]);
    if ($x eq 'NaN' || $y eq 'NaN' || $y eq '+0E+0') {
	'NaN';
    } else {
	local($xm,$xe) = split('E',$x);
	local($ym,$ye) = split('E',$y);
	$scale = $div_scale if (!$scale);
	$scale = length($xm)-1 if (length($xm)-1 > $scale);
	$scale = length($ym)-1 if (length($ym)-1 > $scale);
	$scale = $scale + length($ym) - length($xm);
	&norm(&round(&'bdiv($xm.('0' x $scale),$ym),&'babs($ym)),
	    $xe-$ye-$scale);
    }
}

# round int $q based on fraction $r/$base using $rnd_mode
sub round { #(int_str, int_str, int_str) return int_str
    local($q,$r,$base) = @_;
    if ($q eq 'NaN' || $r eq 'NaN') {
	'NaN';
    } elsif ($rnd_mode eq 'trunc') {
	$q;                         # just truncate
    } else {
	local($cmp) = &'bcmp(&'bmul($r,'+2'),$base);
	if ( $cmp < 0 ||
		 ($cmp == 0 &&
		  ( $rnd_mode eq 'zero'                             ||
		   ($rnd_mode eq '-inf' && (substr($q,$[,1) eq '+')) ||
		   ($rnd_mode eq '+inf' && (substr($q,$[,1) eq '-')) ||
		   ($rnd_mode eq 'even' && $q =~ /[24680]$/)        ||
		   ($rnd_mode eq 'odd'  && $q =~ /[13579]$/)        )) ) {
	    $q;                     # round down
	} else {
	    &'badd($q, ((substr($q,$[,1) eq '-') ? '-1' : '+1'));
				    # round up
	}
    }
}

# round the mantissa of $x to $scale digits
sub main'fround { #(fnum_str, scale) return fnum_str
    local($x,$scale) = (&'fnorm($_[$[]),$_[$[+1]);
    if ($x eq 'NaN' || $scale <= 0) {
	$x;
    } else {
	local($xm,$xe) = split('E',$x);
	if (length($xm)-1 <= $scale) {
	    $x;
	} else {
	    &norm(&round(substr($xm,$[,$scale+1),
			 "+0".substr($xm,$[+$scale+1,1),"+10"),
		  $xe+length($xm)-$scale-1);
	}
    }
}

# round $x at the 10 to the $scale digit place
sub main'ffround { #(fnum_str, scale) return fnum_str
    local($x,$scale) = (&'fnorm($_[$[]),$_[$[+1]);
    if ($x eq 'NaN') {
	'NaN';
    } else {
	local($xm,$xe) = split('E',$x);
	if ($xe >= $scale) {
	    $x;
	} else {
	    $xe = length($xm)+$xe-$scale;
	    if ($xe < 1) {
		'+0E+0';
	    } elsif ($xe == 1) {
		# The first substr preserves the sign, which means that
		# we'll pass a non-normalized "-0" to &round when rounding
		# -0.006 (for example), purely so that &round won't lose
		# the sign.
		&norm(&round(substr($xm,$[,1).'0',
		      "+0".substr($xm,$[+1,1),"+10"), $scale);
	    } else {
		&norm(&round(substr($xm,$[,$xe),
		      "+0".substr($xm,$[+$xe,1),"+10"), $scale);
	    }
	}
    }
}
    
# compare 2 values returns one of undef, <0, =0, >0
#   returns undef if either or both input value are not numbers
sub main'fcmp #(fnum_str, fnum_str) return cond_code
{
    local($x, $y) = (&'fnorm($_[$[]),&'fnorm($_[$[+1]));
    if ($x eq "NaN" || $y eq "NaN") {
	undef;
    } else {
	ord($y) <=> ord($x)
	||
	(  local($xm,$xe,$ym,$ye) = split('E', $x."E$y"),
	     (($xe <=> $ye) * (substr($x,$[,1).'1')
             || &bigint'cmp($xm,$ym))
	);
    }
}

# square root by Newtons method.
sub main'fsqrt { #(fnum_str[, scale]) return fnum_str
    local($x, $scale) = (&'fnorm($_[$[]), $_[$[+1]);
    if ($x eq 'NaN' || $x =~ /^-/) {
	'NaN';
    } elsif ($x eq '+0E+0') {
	'+0E+0';
    } else {
	local($xm, $xe) = split('E',$x);
	$scale = $div_scale if (!$scale);
	$scale = length($xm)-1 if ($scale < length($xm)-1);
	local($gs, $guess) = (1, sprintf("1E%+d", (length($xm)+$xe-1)/2));
	while ($gs < 2*$scale) {
	    $guess = &'fmul(&'fadd($guess,&'fdiv($x,$guess,$gs*2)),".5");
	    $gs *= 2;
	}
	&'fround($guess, $scale);
    }
}

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        package DBM_Filter ;

use strict;
use warnings;
our $VERSION = '0.01';

package Tie::Hash ;

use strict;
use warnings;

use Carp;


our %LayerStack = ();
our %origDESTROY = ();

our %Filters = map { $_, undef } qw(
            Fetch_Key
            Fetch_Value
            Store_Key
            Store_Value
	);

our %Options = map { $_, 1 } qw(
            fetch
            store
	);

#sub Filter_Enable
#{
#}
#
#sub Filter_Disable
#{
#}

sub Filtered
{
    my $this = shift;
    return defined $LayerStack{$this} ;
}

sub Filter_Pop
{
    my $this = shift;
    my $stack = $LayerStack{$this} || return undef ;
    my $filter = pop @{ $stack };

    # remove the filter hooks if this is the last filter to pop
    if ( @{ $stack } == 0 ) {
        $this->filter_store_key  ( undef );
        $this->filter_store_value( undef );
        $this->filter_fetch_key  ( undef );
        $this->filter_fetch_value( undef );
        delete $LayerStack{$this};
    }

    return $filter;
}

sub Filter_Key_Push
{
    &_do_Filter_Push;
}

sub Filter_Value_Push
{
    &_do_Filter_Push;
}


sub Filter_Push
{
    &_do_Filter_Push;
}

sub _do_Filter_Push
{
    my $this = shift;
    my %callbacks = ();
    my $caller = (caller(1))[3];
    $caller =~ s/^.*:://;
 
    croak "$caller: no parameters present" unless @_ ;

    if ( ! $Options{lc $_[0]} ) {
        my $class = shift;
        my @params = @_;

        # if $class already contains "::", don't prefix "DBM_Filter::"
        $class = "DBM_Filter::$class" unless $class =~ /::/;
    
        # does the "DBM_Filter::$class" exist?
	if ( ! defined %{ "${class}::"} ) {
	    # Nope, so try to load it.
            eval " require $class ; " ;
            croak "$caller: Cannot Load DBM Filter '$class': $@" if $@;
        }
    
        no strict 'refs';
        my $fetch  = *{ "${class}::Fetch"  }{CODE};
        my $store  = *{ "${class}::Store"  }{CODE};
        my $filter = *{ "${class}::Filter" }{CODE};
        use strict 'refs';

        my $count = defined($filter) + defined($store) + defined($fetch) ;

        if ( $count == 0 )
          { croak "$caller: No methods (Filter, Fetch or Store) found in class '$class'" }
        elsif ( $count == 1 && ! defined $filter) {
           my $need = defined($fetch) ? 'Store' : 'Fetch';
           croak "$caller: Missing method '$need' in class '$class'" ;
        }
        elsif ( $count >= 2 && defined $filter)
          { croak "$caller: Can't mix Filter with Store and Fetch in class '$class'" }

        if (defined $filter) {
            my $callbacks = &{ $filter }(@params);
            croak "$caller: '${class}::Filter' did not return a hash reference" 
                unless ref $callbacks && ref $callbacks eq 'HASH';
            %callbacks = %{ $callbacks } ;
        }
        else {
            $callbacks{Fetch} = $fetch;
            $callbacks{Store} = $store;
        }
    }
    else {
        croak "$caller: not even params" unless @_ % 2 == 0;
        %callbacks = @_;
    }
    
    my %filters = %Filters ;
    my @got = ();
    while (my ($k, $v) = each %callbacks )
    {
        my $key = $k;
        $k = lc $k;
        if ($k eq 'fetch') {
            push @got, 'Fetch';
            if ($caller eq 'Filter_Push')
              { $filters{Fetch_Key} = $filters{Fetch_Value} = $v }
            elsif ($caller eq 'Filter_Key_Push')
              { $filters{Fetch_Key} = $v }
            elsif ($caller eq 'Filter_Value_Push')
              { $filters{Fetch_Value} = $v }
        }
        elsif ($k eq 'store') {
            push @got, 'Store';
            if ($caller eq 'Filter_Push')
              { $filters{Store_Key} = $filters{Store_Value} = $v }
            elsif ($caller eq 'Filter_Key_Push')
              { $filters{Store_Key} = $v }
            elsif ($caller eq 'Filter_Value_Push')
              { $filters{Store_Value} = $v }
        }
        else
          { croak "$caller: Unknown key '$key'" }

        croak "$caller: value associated with key '$key' is not a code reference"
            unless ref $v && ref $v eq 'CODE';
    }

    if ( @got != 2 ) {
        push @got, 'neither' if @got == 0 ;
        croak "$caller: expected both Store & Fetch - got @got";
    }

    # remember the class
    push @{ $LayerStack{$this} }, \%filters ;

    my $str_this = "$this" ; # Avoid a closure with $this in the subs below

    $this->filter_store_key  ( sub { store_hook($str_this, 'Store_Key')   });
    $this->filter_store_value( sub { store_hook($str_this, 'Store_Value') });
    $this->filter_fetch_key  ( sub { fetch_hook($str_this, 'Fetch_Key')   });
    $this->filter_fetch_value( sub { fetch_hook($str_this, 'Fetch_Value') });

    # Hijack the callers DESTROY method
    $this =~ /^(.*)=/;
    my $type = $1 ;
    no strict 'refs';
    if ( *{ "${type}::DESTROY" }{CODE} ne \&MyDESTROY )
    {
        $origDESTROY{$type} = *{ "${type}::DESTROY" }{CODE};
        no warnings 'redefine';
        *{ "${type}::DESTROY" } = \&MyDESTROY ;
    }
}

sub store_hook
{
    my $this = shift ;
    my $type = shift ;
    foreach my $layer (@{ $LayerStack{$this} })
    {
        &{ $layer->{$type} }() if defined $layer->{$type} ;
    }
}

sub fetch_hook
{
    my $this = shift ;
    my $type = shift ;
    foreach my $layer (reverse @{ $LayerStack{$this} })
    {
        &{ $layer->{$type} }() if defined $layer->{$type} ;
    }
}

sub MyDESTROY
{
    my $this = shift ;
    delete $LayerStack{$this} ;

    # call real DESTROY
    $this =~ /^(.*)=/;
    &{ $origDESTROY{$1} }($this);
}

1;

__END__

=head1 NAME

DBM_Filter -- Filter DBM keys/values 

=head1 SYNOPSIS

    use DBM_Filter ;
    use SDBM_File; # or DB_File, or GDBM_File, or NDBM_File, or ODBM_File

    $db = tie %hash, ...

    $db->Filter_Push(Fetch => sub {...},
                     Store => sub {...});

    $db->Filter_Push('my_filter1');
    $db->Filter_Push('my_filter2', params...);

    $db->Filter_Key_Push(...) ;
    $db->Filter_Value_Push(...) ;

    $db->Filter_Pop();
    $db->Filtered();

    package DBM_Filter::my_filter1;
    
    sub Store { ... }
    sub Fetch { ... }

    1;

    package DBM_Filter::my_filter2;

    sub Filter
    {
        my @opts = @_;
        ...
        return (
            sub Store { ... },
            sub Fetch { ... } );
    }

    1;

=head1 DESCRIPTION

This module provides an interface that allows filters to be applied
to tied Hashes associated with DBM files. It builds on the DBM Filter
hooks that are present in all the *DB*_File modules included with the
standard Perl source distribution from version 5.6.1 onwards. In addition
to the *DB*_File modules distributed with Perl, the BerkeleyDB module,
available on CPAN, supports the DBM Filter hooks. See L<perldbmfilter>
for more details on the DBM Filter hooks.

=head1 What is a DBM Filter?

A DBM Filter allows the keys and/or values in a tied hash to be modified
by some user-defined code just before it is written to the DBM file and
just after it is read back from the DBM file. For example, this snippet
of code

    $some_hash{"abc"} = 42;

could potentially trigger two filters, one for the writing of the key
"abc" and another for writing the value 42.  Similarly, this snippet

    my ($key, $value) = each %some_hash

will trigger two filters, one for the reading of the key and one for
the reading of the value.

Like the existing DBM Filter functionality, this module arranges for the
C<$_> variable to be populated with the key or value that a filter will
check. This usually means that most DBM filters tend to be very short.

=head2 So what's new?

The main enhancements over the standard DBM Filter hooks are:

=over 4

=item *

A cleaner interface.

=item *

The ability to easily apply multiple filters to a single DBM file.

=item *

The ability to create "canned" filters. These allow commonly used filters
to be packaged into a stand-alone module.

=back

=head1 METHODS

This module will arrange for the following methods to be available via
the object returned from the C<tie> call.

=head2 $db->Filter_Push()

=head2 $db->Filter_Key_Push()

=head2 $db->Filter_Value_Push()

Add a filter to filter stack for the database, C<$db>. The three formats
vary only in whether they apply to the DBM key, the DBM value or both.

=over 5

=item Filter_Push

The filter is applied to I<both> keys and values.

=item Filter_Key_Push

The filter is applied to the key I<only>.

=item Filter_Value_Push

The filter is applied to the value I<only>.

=back


=head2 $db->Filter_Pop()

Removes the last filter that was applied to the DBM file associated with
C<$db>, if present.

=head2 $db->Filtered()

Returns TRUE if there are any filters applied to the DBM associated
with C<$db>.  Otherwise returns FALSE.



=head1 Writing a Filter

Filters can be created in two main ways

=head2 Immediate Filters

An immediate filter allows you to specify the filter code to be used
at the point where the filter is applied to a dbm. In this mode the
Filter_*_Push methods expects to receive exactly two parameters.

    my $db = tie %hash, 'SDBM_File', ...
    $db->Filter_Push( Store => sub { },
                      Fetch => sub { });

The code reference associated with C<Store> will be called before any
key/value is written to the database and the code reference associated
with C<Fetch> will be called after any key/value is read from the
database.

For example, here is a sample filter that adds a trailing NULL character
to all strings before they are written to the DBM file, and removes the
trailing NULL when they are read from the DBM file

    my $db = tie %hash, 'SDBM_File', ...
    $db->Filter_Push( Store => sub { $_ .= "\x00" ; },
                      Fetch => sub { s/\x00$// ;    });


Points to note:

=over 5

=item 1.

Both the Store and Fetch filters manipulate C<$_>.

=back

=head2 Canned Filters

Immediate filters are useful for one-off situations. For more generic
problems it can be useful to package the filter up in its own module.

The usage is for a canned filter is:

    $db->Filter_Push("name", params)

where

=over 5

=item "name"

is the name of the module to load. If the string specified does not
contain the package separator characters "::", it is assumed to refer to
the full module name "DBM_Filter::name". This means that the full names
for canned filters, "null" and "utf8", included with this module are:

    DBM_Filter::null
    DBM_Filter::utf8

=item params

any optional parameters that need to be sent to the filter. See the
encode filter for an example of a module that uses parameters.

=back

The module that implements the canned filter can take one of two
forms. Here is a template for the first

    package DBM_Filter::null ;

    use strict;
    use warnings;

    sub Store 
    {
        # store code here    
    }

    sub Fetch
    {
        # fetch code here
    }

    1;


Notes:

=over 5

=item 1.

The package name uses the C<DBM_Filter::> prefix.

=item 2.

The module I<must> have both a Store and a Fetch method. If only one is
present, or neither are present, a fatal error will be thrown.

=back

The second form allows the filter to hold state information using a
closure, thus:

    package DBM_Filter::encoding ;

    use strict;
    use warnings;

    sub Filter
    {
        my @params = @_ ;

        ...
        return {
            Store   => sub { $_ = $encoding->encode($_) },
            Fetch   => sub { $_ = $encoding->decode($_) }
            } ;
    }

    1;


In this instance the "Store" and "Fetch" methods are encapsulated inside a
"Filter" method.


=head1 Filters Included

A number of canned filers are provided with this module. They cover a
number of the main areas that filters are needed when interfacing with
DBM files. They also act as templates for your own filters.

The filter included are:

=over 5

=item * utf8

This module will ensure that all data written to the DBM will be encoded
in UTF-8.

This module needs the Encode module.

=item * encode

Allows you to choose the character encoding will be store in the DBM file.

=item * compress

This filter will compress all data before it is written to the database
and uncompressed it on reading.

This module needs Compress::Zlib. 

=item * int32

This module is used when interoperating with a C/C++ application that
uses a C int as either the key and/or value in the DBM file.

=item * null

This module ensures that all data written to the DBM file is null
terminated. This is useful when you have a perl script that needs
to interoperate with a DBM file that a C program also uses. A fairly
common issue is for the C application to include the terminating null
in a string when it writes to the DBM file. This filter will ensure that
all data written to the DBM file can be read by the C application.

=back

=head1 NOTES

=head2 Maintain Round Trip Integrity

When writing a DBM filter it is I<very> important to ensure that it is
possible to retrieve all data that you have written when the DBM filter
is in place. In practice, this means that whatever transformation is
applied to the data in the Store method, the I<exact> inverse operation
should be applied in the Fetch method.

If you don't provide an exact inverse transformation, you will find that
code like this will not behave as you expect.

     while (my ($k, $v) = each %hash)
     {
         ...
     }

Depending on the transformation, you will find that one or more of the
following will happen

=over 5

=item 1

The loop will never terminate.

=item 2

Too few records will be retrieved.

=item 3

Too many will be retrieved.

=item 4

The loop will do the right thing for a while, but it will unexpectedly fail. 

=back

=head2 Don't mix filtered & non-filtered data in the same database file. 

This is just a restatement of the previous section. Unless you are
completely certain you know what you are doing, avoid mixing filtered &
non-filtered data.

=head1 EXAMPLE

Say you need to interoperate with a legacy C application that stores
keys as C ints and the values and null terminated UTF-8 strings. Here
is how you would set that up

    my $db = tie %hash, 'SDBM_File', ...

    $db->Filter_Key_Push('int32') ;

    $db->Filter_Value_Push('utf8');
    $db->Filter_Value_Push('null');

=head1 SEE ALSO

<DB_File>,  L<GDBM_File>, L<NDBM_File>, L<ODBM_File>, L<SDBM_File>, L<perldbmfilter>

=head1 AUTHOR

Paul Marquess <pmqs@cpan.org>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 package bigint;
#
# This library is no longer being maintained, and is included for backward
# compatibility with Perl 4 programs which may require it.
#
# In particular, this should not be used as an example of modern Perl
# programming techniques.
#
# Suggested alternative:  Math::BigInt
#
# arbitrary size integer math package
#
# by Mark Biggar
#
# Canonical Big integer value are strings of the form
#       /^[+-]\d+$/ with leading zeros suppressed
# Input values to these routines may be strings of the form
#       /^\s*[+-]?[\d\s]+$/.
# Examples:
#   '+0'                            canonical zero value
#   '   -123 123 123'               canonical value '-123123123'
#   '1 23 456 7890'                 canonical value '+1234567890'
# Output values always in canonical form
#
# Actual math is done in an internal format consisting of an array
#   whose first element is the sign (/^[+-]$/) and whose remaining 
#   elements are base 100000 digits with the least significant digit first.
# The string 'NaN' is used to represent the result when input arguments 
#   are not numbers, as well as the result of dividing by zero
#
# routines provided are:
#
#   bneg(BINT) return BINT              negation
#   babs(BINT) return BINT              absolute value
#   bcmp(BINT,BINT) return CODE         compare numbers (undef,<0,=0,>0)
#   badd(BINT,BINT) return BINT         addition
#   bsub(BINT,BINT) return BINT         subtraction
#   bmul(BINT,BINT) return BINT         multiplication
#   bdiv(BINT,BINT) return (BINT,BINT)  division (quo,rem) just quo if scalar
#   bmod(BINT,BINT) return BINT         modulus
#   bgcd(BINT,BINT) return BINT         greatest common divisor
#   bnorm(BINT) return BINT             normalization
#

# overcome a floating point problem on certain osnames (posix-bc, os390)
BEGIN {
    my $x = 100000.0;
    my $use_mult = int($x*1e-5)*1e5 == $x ? 1 : 0;
}

$zero = 0;


# normalize string form of number.   Strip leading zeros.  Strip any
#   white space and add a sign, if missing.
# Strings that are not numbers result the value 'NaN'.

sub main'bnorm { #(num_str) return num_str
    local($_) = @_;
    s/\s+//g;                           # strip white space
    if (s/^([+-]?)0*(\d+)$/$1$2/) {     # test if number
	substr($_,$[,0) = '+' unless $1; # Add missing sign
	s/^-0/+0/;
	$_;
    } else {
	'NaN';
    }
}

# Convert a number from string format to internal base 100000 format.
#   Assumes normalized value as input.
sub internal { #(num_str) return int_num_array
    local($d) = @_;
    ($is,$il) = (substr($d,$[,1),length($d)-2);
    substr($d,$[,1) = '';
    ($is, reverse(unpack("a" . ($il%5+1) . ("a5" x ($il/5)), $d)));
}

# Convert a number from internal base 100000 format to string format.
#   This routine scribbles all over input array.
sub external { #(int_num_array) return num_str
    $es = shift;
    grep($_ > 9999 || ($_ = substr('0000'.$_,-5)), @_);   # zero pad
    &'bnorm(join('', $es, reverse(@_)));    # reverse concat and normalize
}

# Negate input value.
sub main'bneg { #(num_str) return num_str
    local($_) = &'bnorm(@_);
    vec($_,0,8) ^= ord('+') ^ ord('-') unless $_ eq '+0';
    s/^./N/ unless /^[-+]/; # works both in ASCII and EBCDIC
    $_;
}

# Returns the absolute value of the input.
sub main'babs { #(num_str) return num_str
    &abs(&'bnorm(@_));
}

sub abs { # post-normalized abs for internal use
    local($_) = @_;
    s/^-/+/;
    $_;
}

# Compares 2 values.  Returns one of undef, <0, =0, >0. (suitable for sort)
sub main'bcmp { #(num_str, num_str) return cond_code
    local($x,$y) = (&'bnorm($_[$[]),&'bnorm($_[$[+1]));
    if ($x eq 'NaN') {
	undef;
    } elsif ($y eq 'NaN') {
	undef;
    } else {
	&cmp($x,$y);
    }
}

sub cmp { # post-normalized compare for internal use
    local($cx, $cy) = @_;
    return 0 if ($cx eq $cy);

    local($sx, $sy) = (substr($cx, 0, 1), substr($cy, 0, 1));
    local($ld);

    if ($sx eq '+') {
      return  1 if ($sy eq '-' || $cy eq '+0');
      $ld = length($cx) - length($cy);
      return $ld if ($ld);
      return $cx cmp $cy;
    } else { # $sx eq '-'
      return -1 if ($sy eq '+');
      $ld = length($cy) - length($cx);
      return $ld if ($ld);
      return $cy cmp $cx;
    }

}

sub main'badd { #(num_str, num_str) return num_str
    local(*x, *y); ($x, $y) = (&'bnorm($_[$[]),&'bnorm($_[$[+1]));
    if ($x eq 'NaN') {
	'NaN';
    } elsif ($y eq 'NaN') {
	'NaN';
    } else {
	@x = &internal($x);             # convert to internal form
	@y = &internal($y);
	local($sx, $sy) = (shift @x, shift @y); # get signs
	if ($sx eq $sy) {
	    &external($sx, &add(*x, *y)); # if same sign add
	} else {
	    ($x, $y) = (&abs($x),&abs($y)); # make abs
	    if (&cmp($y,$x) > 0) {
		&external($sy, &sub(*y, *x));
	    } else {
		&external($sx, &sub(*x, *y));
	    }
	}
    }
}

sub main'bsub { #(num_str, num_str) return num_str
    &'badd($_[$[],&'bneg($_[$[+1]));    
}

# GCD -- Euclids algorithm Knuth Vol 2 pg 296
sub main'bgcd { #(num_str, num_str) return num_str
    local($x,$y) = (&'bnorm($_[$[]),&'bnorm($_[$[+1]));
    if ($x eq 'NaN' || $y eq 'NaN') {
	'NaN';
    } else {
	($x, $y) = ($y,&'bmod($x,$y)) while $y ne '+0';
	$x;
    }
}

# routine to add two base 1e5 numbers
#   stolen from Knuth Vol 2 Algorithm A pg 231
#   there are separate routines to add and sub as per Kunth pg 233
sub add { #(int_num_array, int_num_array) return int_num_array
    local(*x, *y) = @_;
    $car = 0;
    for $x (@x) {
	last unless @y || $car;
	$x -= 1e5 if $car = (($x += shift(@y) + $car) >= 1e5) ? 1 : 0;
    }
    for $y (@y) {
	last unless $car;
	$y -= 1e5 if $car = (($y += $car) >= 1e5) ? 1 : 0;
    }
    (@x, @y, $car);
}

# subtract base 1e5 numbers -- stolen from Knuth Vol 2 pg 232, $x > $y
sub sub { #(int_num_array, int_num_array) return int_num_array
    local(*sx, *sy) = @_;
    $bar = 0;
    for $sx (@sx) {
	last unless @y || $bar;
	$sx += 1e5 if $bar = (($sx -= shift(@sy) + $bar) < 0);
    }
    @sx;
}

# multiply two numbers -- stolen from Knuth Vol 2 pg 233
sub main'bmul { #(num_str, num_str) return num_str
    local(*x, *y); ($x, $y) = (&'bnorm($_[$[]), &'bnorm($_[$[+1]));
    if ($x eq 'NaN') {
	'NaN';
    } elsif ($y eq 'NaN') {
	'NaN';
    } else {
	@x = &internal($x);
	@y = &internal($y);
	local($signr) = (shift @x ne shift @y) ? '-' : '+';
	@prod = ();
	for $x (@x) {
	    ($car, $cty) = (0, $[);
	    for $y (@y) {
		$prod = $x * $y + $prod[$cty] + $car;
                if ($use_mult) {
		    $prod[$cty++] =
		        $prod - ($car = int($prod * 1e-5)) * 1e5;
                }
                else {
		    $prod[$cty++] =
		        $prod - ($car = int($prod / 1e5)) * 1e5;
                }
	    }
	    $prod[$cty] += $car if $car;
	    $x = shift @prod;
	}
	&external($signr, @x, @prod);
    }
}

# modulus
sub main'bmod { #(num_str, num_str) return num_str
    (&'bdiv(@_))[$[+1];
}

sub main'bdiv { #(dividend: num_str, divisor: num_str) return num_str
    local (*x, *y); ($x, $y) = (&'bnorm($_[$[]), &'bnorm($_[$[+1]));
    return wantarray ? ('NaN','NaN') : 'NaN'
	if ($x eq 'NaN' || $y eq 'NaN' || $y eq '+0');
    return wantarray ? ('+0',$x) : '+0' if (&cmp(&abs($x),&abs($y)) < 0);
    @x = &internal($x); @y = &internal($y);
    $srem = $y[$[];
    $sr = (shift @x ne shift @y) ? '-' : '+';
    $car = $bar = $prd = 0;
    if (($dd = int(1e5/($y[$#y]+1))) != 1) {
	for $x (@x) {
	    $x = $x * $dd + $car;
            if ($use_mult) {
	    $x -= ($car = int($x * 1e-5)) * 1e5;
            }
            else {
	    $x -= ($car = int($x / 1e5)) * 1e5;
            }
	}
	push(@x, $car); $car = 0;
	for $y (@y) {
	    $y = $y * $dd + $car;
            if ($use_mult) {
	    $y -= ($car = int($y * 1e-5)) * 1e5;
            }
            else {
	    $y -= ($car = int($y / 1e5)) * 1e5;
            }
	}
    }
    else {
	push(@x, 0);
    }
    @q = (); ($v2,$v1) = @y[-2,-1];
    while ($#x > $#y) {
	($u2,$u1,$u0) = @x[-3..-1];
	$q = (($u0 == $v1) ? 99999 : int(($u0*1e5+$u1)/$v1));
	--$q while ($v2*$q > ($u0*1e5+$u1-$q*$v1)*1e5+$u2);
	if ($q) {
	    ($car, $bar) = (0,0);
	    for ($y = $[, $x = $#x-$#y+$[-1; $y <= $#y; ++$y,++$x) {
		$prd = $q * $y[$y] + $car;
                if ($use_mult) {
		$prd -= ($car = int($prd * 1e-5)) * 1e5;
                }
                else {
		$prd -= ($car = int($prd / 1e5)) * 1e5;
                }
		$x[$x] += 1e5 if ($bar = (($x[$x] -= $prd + $bar) < 0));
	    }
	    if ($x[$#x] < $car + $bar) {
		$car = 0; --$q;
		for ($y = $[, $x = $#x-$#y+$[-1; $y <= $#y; ++$y,++$x) {
		    $x[$x] -= 1e5
			if ($car = (($x[$x] += $y[$y] + $car) > 1e5));
		}
	    }   
	}
	pop(@x); unshift(@q, $q);
    }
    if (wantarray) {
	@d = ();
	if ($dd != 1) {
	    $car = 0;
	    for $x (reverse @x) {
		$prd = $car * 1e5 + $x;
		$car = $prd - ($tmp = int($prd / $dd)) * $dd;
		unshift(@d, $tmp);
	    }
	}
	else {
	    @d = @x;
	}
	(&external($sr, @q), &external($srem, @d, $zero));
    } else {
	&external($sr, @q);
    }
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 package blib;

=head1 NAME

blib - Use MakeMaker's uninstalled version of a package

=head1 SYNOPSIS

 perl -Mblib script [args...]

 perl -Mblib=dir script [args...]

=head1 DESCRIPTION

Looks for MakeMaker-like I<'blib'> directory structure starting in 
I<dir> (or current directory) and working back up to five levels of '..'.

Intended for use on command line with B<-M> option as a way of testing
arbitrary scripts against an uninstalled version of a package.

However it is possible to : 

 use blib; 
 or 
 use blib '..';

etc. if you really must.

=head1 BUGS

Pollutes global name space for development only task.

=head1 AUTHOR

Nick Ing-Simmons nik@tiuk.ti.com

=cut

use Cwd;
use File::Spec;

use vars qw($VERSION $Verbose);
$VERSION = '1.03';
$Verbose = 0;

sub import
{
 my $package = shift;
 my $dir = getcwd;
 if ($^O eq 'VMS') { ($dir = VMS::Filespec::unixify($dir)) =~ s-/\z--; }
 if (@_)
  {
   $dir = shift;
   $dir =~ s/blib\z//;
   $dir =~ s,/+\z,,;
   $dir = File::Spec->curdir unless ($dir);
   die "$dir is not a directory\n" unless (-d $dir);
  }
 my $i = 5;
 my($blib, $blib_lib, $blib_arch);
 while ($i--)
  {
   $blib = File::Spec->catdir($dir, "blib");
   $blib_lib = File::Spec->catdir($blib, "lib");

   if ($^O eq 'MacOS')
    {
     $blib_arch = File::Spec->catdir($blib_lib, $MacPerl::Architecture);
    }
   else
    {
     $blib_arch = File::Spec->catdir($blib, "arch");
    }

   if (-d $blib && -d $blib_arch && -d $blib_lib)
    {
     unshift(@INC,$blib_arch,$blib_lib);
     warn "Using $blib\n" if $Verbose;
     return;
    }
   $dir = File::Spec->catdir($dir, File::Spec->updir);
  }
 die "Cannot find blib even in $dir\n";
}

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     package utf8;

$utf8::hint_bits = 0x00800000;

our $VERSION = '1.06';

sub import {
    $^H |= $utf8::hint_bits;
    $enc{caller()} = $_[1] if $_[1];
}

sub unimport {
    $^H &= ~$utf8::hint_bits;
}

sub AUTOLOAD {
    require "utf8_heavy.pl";
    goto &$AUTOLOAD if defined &$AUTOLOAD;
    require Carp;
    Carp::croak("Undefined subroutine $AUTOLOAD called");
}

1;
__END__

=head1 NAME

utf8 - Perl pragma to enable/disable UTF-8 (or UTF-EBCDIC) in source code

=head1 SYNOPSIS

    use utf8;
    no utf8;

    # Convert a Perl scalar to/from UTF-8.
    $num_octets = utf8::upgrade($string);
    $success    = utf8::downgrade($string[, FAIL_OK]);

    # Change the native bytes of a Perl scalar to/from UTF-8 bytes.
    utf8::encode($string);
    utf8::decode($string);

    $flag = utf8::is_utf8(STRING); # since Perl 5.8.1
    $flag = utf8::valid(STRING);

=head1 DESCRIPTION

The C<use utf8> pragma tells the Perl parser to allow UTF-8 in the
program text in the current lexical scope (allow UTF-EBCDIC on EBCDIC based
platforms).  The C<no utf8> pragma tells Perl to switch back to treating
the source text as literal bytes in the current lexical scope.

This pragma is primarily a compatibility device.  Perl versions
earlier than 5.6 allowed arbitrary bytes in source code, whereas
in future we would like to standardize on the UTF-8 encoding for
source text.

B<Do not use this pragma for anything else than telling Perl that your
script is written in UTF-8.> The utility functions described below are
useful for their own purposes, but they are not really part of the
"pragmatic" effect.

Until UTF-8 becomes the default format for source text, either this
pragma or the L<encoding> pragma should be used to recognize UTF-8
in the source.  When UTF-8 becomes the standard source format, this
pragma will effectively become a no-op.  For convenience in what
follows the term I<UTF-X> is used to refer to UTF-8 on ASCII and ISO
Latin based platforms and UTF-EBCDIC on EBCDIC based platforms.

See also the effects of the C<-C> switch and its cousin, the
C<$ENV{PERL_UNICODE}>, in L<perlrun>.

Enabling the C<utf8> pragma has the following effect:

=over 4

=item *

Bytes in the source text that have their high-bit set will be treated
as being part of a literal UTF-8 character.  This includes most
literals such as identifier names, string constants, and constant
regular expression patterns.

On EBCDIC platforms characters in the Latin 1 character set are
treated as being part of a literal UTF-EBCDIC character.

=back

Note that if you have bytes with the eighth bit on in your script
(for example embedded Latin-1 in your string literals), C<use utf8>
will be unhappy since the bytes are most probably not well-formed
UTF-8.  If you want to have such bytes and use utf8, you can disable
utf8 until the end the block (or file, if at top level) by C<no utf8;>.

If you want to automatically upgrade your 8-bit legacy bytes to UTF-8,
use the L<encoding> pragma instead of this pragma.  For example, if
you want to implicitly upgrade your ISO 8859-1 (Latin-1) bytes to UTF-8
as used in e.g. C<chr()> and C<\x{...}>, try this:

    use encoding "latin-1";
    my $c = chr(0xc4);
    my $x = "\x{c5}";

In case you are wondering: yes, C<use encoding 'utf8';> works much
the same as C<use utf8;>.

=head2 Utility functions

The following functions are defined in the C<utf8::> package by the
Perl core.  You do not need to say C<use utf8> to use these and in fact
you should not say that  unless you really want to have UTF-8 source code.

=over 4

=item * $num_octets = utf8::upgrade($string)

Converts in-place the octet sequence in the native encoding
(Latin-1 or EBCDIC) to the equivalent character sequence in I<UTF-X>.
I<$string> already encoded as characters does no harm.
Returns the number of octets necessary to represent the string as I<UTF-X>.
Can be used to make sure that the UTF-8 flag is on,
so that C<\w> or C<lc()> work as Unicode on strings
containing characters in the range 0x80-0xFF (on ASCII and
derivatives).

B<Note that this function does not handle arbitrary encodings.>
Therefore I<Encode.pm> is recommended for the general purposes.

Affected by the encoding pragma.

=item * $success = utf8::downgrade($string[, FAIL_OK])

Converts in-place the character sequence in I<UTF-X>
to the equivalent octet sequence in the native encoding (Latin-1 or EBCDIC).
I<$string> already encoded as octets does no harm.
Returns true on success. On failure dies or, if the value of
C<FAIL_OK> is true, returns false.
Can be used to make sure that the UTF-8 flag is off,
e.g. when you want to make sure that the substr() or length() function
works with the usually faster byte algorithm.

B<Note that this function does not handle arbitrary encodings.>
Therefore I<Encode.pm> is recommended for the general purposes.

B<Not> affected by the encoding pragma.

B<NOTE:> this function is experimental and may change
or be removed without notice.

=item * utf8::encode($string)

Converts in-place the character sequence to the corresponding octet sequence
in I<UTF-X>.  The UTF-8 flag is turned off.  Returns nothing.

B<Note that this function does not handle arbitrary encodings.>
Therefore I<Encode.pm> is recommended for the general purposes.

=item * utf8::decode($string)

Attempts to convert in-place the octet sequence in I<UTF-X>
to the corresponding character sequence.  The UTF-8 flag is turned on
only if the source string contains multiple-byte I<UTF-X> characters.
If I<$string> is invalid as I<UTF-X>, returns false; otherwise returns true.

B<Note that this function does not handle arbitrary encodings.>
Therefore I<Encode.pm> is recommended for the general purposes.

B<NOTE:> this function is experimental and may change
or be removed without notice.

=item * $flag = utf8::is_utf8(STRING)

(Since Perl 5.8.1)  Test whether STRING is in UTF-8.  Functionally
the same as Encode::is_utf8().

=item * $flag = utf8::valid(STRING)

[INTERNAL] Test whether STRING is in a consistent state regarding
UTF-8.  Will return true is well-formed UTF-8 and has the UTF-8 flag
on B<or> if string is held as bytes (both these states are 'consistent').
Main reason for this routine is to allow Perl's testsuite to check
that operations have left strings in a consistent state.  You most
probably want to use utf8::is_utf8() instead.

=back

C<utf8::encode> is like C<utf8::upgrade>, but the UTF8 flag is
cleared.  See L<perlunicode> for more on the UTF8 flag and the C API
functions C<sv_utf8_upgrade>, C<sv_utf8_downgrade>, C<sv_utf8_encode>,
and C<sv_utf8_decode>, which are wrapped by the Perl functions
C<utf8::upgrade>, C<utf8::downgrade>, C<utf8::encode> and
C<utf8::decode>.  Note that in the Perl 5.8.0 and 5.8.1 implementation
the functions utf8::is_utf8, utf8::valid, utf8::encode, utf8::decode,
utf8::upgrade, and utf8::downgrade are always available, without a
C<require utf8> statement-- this may change in future releases.

=head1 BUGS

One can have Unicode in identifier names, but not in package/class or
subroutine names.  While some limited functionality towards this does
exist as of Perl 5.8.0, that is more accidental than designed; use of
Unicode for the said purposes is unsupported.

One reason of this unfinishedness is its (currently) inherent
unportability: since both package names and subroutine names may need
to be mapped to file and directory names, the Unicode capability of
the filesystem becomes important-- and there unfortunately aren't
portable answers.

=head1 SEE ALSO

L<perluniintro>, L<encoding>, L<perlrun>, L<bytes>, L<perlunicode>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            package AnyDBM_File;

use 5.006_001;
our $VERSION = '1.00';
our @ISA = qw(NDBM_File DB_File GDBM_File SDBM_File ODBM_File) unless @ISA;

my $mod;
for $mod (@ISA) {
    if (eval "require $mod") {
	@ISA = ($mod);	# if we leave @ISA alone, warnings abound
	return 1;
    }
}

die "No DBM package was successfully found or installed";
#return 0;

=head1 NAME

AnyDBM_File - provide framework for multiple DBMs

NDBM_File, DB_File, GDBM_File, SDBM_File, ODBM_File - various DBM implementations

=head1 SYNOPSIS

    use AnyDBM_File;

=head1 DESCRIPTION

This module is a "pure virtual base class"--it has nothing of its own.
It's just there to inherit from one of the various DBM packages.  It
prefers ndbm for compatibility reasons with Perl 4, then Berkeley DB (See
L<DB_File>), GDBM, SDBM (which is always there--it comes with Perl), and
finally ODBM.   This way old programs that used to use NDBM via dbmopen()
can still do so, but new ones can reorder @ISA:

    BEGIN { @AnyDBM_File::ISA = qw(DB_File GDBM_File NDBM_File) }
    use AnyDBM_File;

Having multiple DBM implementations makes it trivial to copy database formats:

    use POSIX; use NDBM_File; use DB_File;
    tie %newhash,  'DB_File', $new_filename, O_CREAT|O_RDWR;
    tie %oldhash,  'NDBM_File', $old_filename, 1, 0;
    %newhash = %oldhash;

=head2 DBM Comparisons

Here's a partial table of features the different packages offer:

                         odbm    ndbm    sdbm    gdbm    bsd-db
			 ----	 ----    ----    ----    ------
 Linkage comes w/ perl   yes     yes     yes     yes     yes
 Src comes w/ perl       no      no      yes     no      no
 Comes w/ many unix os   yes     yes[0]  no      no      no
 Builds ok on !unix      ?       ?       yes     yes     ?
 Code Size               ?       ?       small   big     big
 Database Size           ?       ?       small   big?    ok[1]
 Speed                   ?       ?       slow    ok      fast
 FTPable                 no      no      yes     yes     yes
 Easy to build          N/A     N/A      yes     yes     ok[2]
 Size limits             1k      4k      1k[3]   none    none
 Byte-order independent  no      no      no      no      yes
 Licensing restrictions  ?       ?       no      yes     no


=over 4

=item [0] 

on mixed universe machines, may be in the bsd compat library,
which is often shunned.

=item [1] 

Can be trimmed if you compile for one access method.

=item [2] 

See L<DB_File>. 
Requires symbolic links.  

=item [3] 

By default, but can be redefined.

=back

=head1 SEE ALSO

dbm(3), ndbm(3), DB_File(3), L<perldbmfilter>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              E  .   B  ..  E  
Collate.pm  E  LangTagsE LangTags.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 package I18N::Collate;

use strict;
our $VERSION = '1.00';

=head1 NAME

I18N::Collate - compare 8-bit scalar data according to the current locale

=head1 SYNOPSIS

    use I18N::Collate;
    setlocale(LC_COLLATE, 'locale-of-your-choice'); 
    $s1 = new I18N::Collate "scalar_data_1";
    $s2 = new I18N::Collate "scalar_data_2";

=head1 DESCRIPTION

  ***

  WARNING: starting from the Perl version 5.003_06
  the I18N::Collate interface for comparing 8-bit scalar data
  according to the current locale

	HAS BEEN DEPRECATED

  That is, please do not use it anymore for any new applications
  and please migrate the old applications away from it because its
  functionality was integrated into the Perl core language in the
  release 5.003_06.

  See the perllocale manual page for further information.

  ***

This module provides you with objects that will collate 
according to your national character set, provided that the 
POSIX setlocale() function is supported on your system.

You can compare $s1 and $s2 above with

    $s1 le $s2

to extract the data itself, you'll need a dereference: $$s1

This module uses POSIX::setlocale(). The basic collation conversion is
done by strxfrm() which terminates at NUL characters being a decent C
routine.  collate_xfrm() handles embedded NUL characters gracefully.

The available locales depend on your operating system; try whether
C<locale -a> shows them or man pages for "locale" or "nlsinfo" or the
direct approach C<ls /usr/lib/nls/loc> or C<ls /usr/lib/nls> or
C<ls /usr/lib/locale>.  Not all the locales that your vendor supports
are necessarily installed: please consult your operating system's
documentation and possibly your local system administration.  The
locale names are probably something like C<xx_XX.(ISO)?8859-N> or
C<xx_XX.(ISO)?8859N>, for example C<fr_CH.ISO8859-1> is the Swiss (CH)
variant of French (fr), ISO Latin (8859) 1 (-1) which is the Western
European character set.

=cut

# I18N::Collate.pm
#
# Author:	Jarkko Hietaniemi <F<jhi@iki.fi>>
#		Helsinki University of Technology, Finland
#
# Acks:		Guy Decoux <F<decoux@moulon.inra.fr>> understood
#		overloading magic much deeper than I and told
#		how to cut the size of this code by more than half.
#		(my first version did overload all of lt gt eq le ge cmp)
#
# Purpose:      compare 8-bit scalar data according to the current locale
#
# Requirements:	Perl5 POSIX::setlocale() and POSIX::strxfrm()
#
# Exports:	setlocale 1)
#		collate_xfrm 2)
#
# Overloads:	cmp # 3)
#
# Usage:	use I18N::Collate;
#	        setlocale(LC_COLLATE, 'locale-of-your-choice'); # 4)
#		$s1 = new I18N::Collate "scalar_data_1";
#		$s2 = new I18N::Collate "scalar_data_2";
#		
#		now you can compare $s1 and $s2: $s1 le $s2
#		to extract the data itself, you need to deref: $$s1
#		
# Notes:	
#		1) this uses POSIX::setlocale
#		2) the basic collation conversion is done by strxfrm() which
#		   terminates at NUL characters being a decent C routine.
#		   collate_xfrm handles embedded NUL characters gracefully.
#		3) due to cmp and overload magic, lt le eq ge gt work also
#		4) the available locales depend on your operating system;
#		   try whether "locale -a" shows them or man pages for
#		   "locale" or "nlsinfo" work or the more direct
#		   approach "ls /usr/lib/nls/loc" or "ls /usr/lib/nls".
#		   Not all the locales that your vendor supports
#		   are necessarily installed: please consult your
#		   operating system's documentation.
#		   The locale names are probably something like
#		   'xx_XX.(ISO)?8859-N' or 'xx_XX.(ISO)?8859N',
#		   for example 'fr_CH.ISO8859-1' is the Swiss (CH)
#		   variant of French (fr), ISO Latin (8859) 1 (-1)
#		   which is the Western European character set.
#
# Updated:	19961005
#
# ---

use POSIX qw(strxfrm LC_COLLATE);
use warnings::register;

require Exporter;

our @ISA = qw(Exporter);
our @EXPORT = qw(collate_xfrm setlocale LC_COLLATE);
our @EXPORT_OK = qw();

use overload qw(
fallback	1
cmp		collate_cmp
);

our($LOCALE, $C);

our $please_use_I18N_Collate_even_if_deprecated = 0;
sub new {
  my $new = $_[1];

  if (warnings::enabled() && $] >= 5.003_06) {
    unless ($please_use_I18N_Collate_even_if_deprecated) {
      warnings::warn <<___EOD___;
***

  WARNING: starting from the Perl version 5.003_06
  the I18N::Collate interface for comparing 8-bit scalar data
  according to the current locale

	HAS BEEN DEPRECATED

  That is, please do not use it anymore for any new applications
  and please migrate the old applications away from it because its
  functionality was integrated into the Perl core language in the
  release 5.003_06.

  See the perllocale manual page for further information.

***
___EOD___
      $please_use_I18N_Collate_even_if_deprecated++;
    }
  }

  bless \$new;
}

sub setlocale {
 my ($category, $locale) = @_[0,1];

 POSIX::setlocale($category, $locale) if (defined $category);
 # the current $LOCALE 
 $LOCALE = $locale || $ENV{'LC_COLLATE'} || $ENV{'LC_ALL'} || '';
}

sub C {
  my $s = ${$_[0]};

  $C->{$LOCALE}->{$s} = collate_xfrm($s)
    unless (defined $C->{$LOCALE}->{$s}); # cache when met

  $C->{$LOCALE}->{$s};
}

sub collate_xfrm {
  my $s = $_[0];
  my $x = '';
  
  for (split(/(\000+)/, $s)) {
    $x .= (/^\000/) ? $_ : strxfrm("$_\000");
  }

  $x;
}

sub collate_cmp {
  &C($_[0]) cmp &C($_[1]);
}

# init $LOCALE

&I18N::Collate::setlocale();

1; # keep require happy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         E  .   E  ..  E  List.pm E 	Detect.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
require 5;
package I18N::LangTags::List;
#  Time-stamp: "2004-10-06 23:26:21 ADT"
use strict;
use vars qw(%Name %Is_Disrec $Debug $VERSION);
$VERSION = '0.35';
# POD at the end.

#----------------------------------------------------------------------
{
# read the table out of our own POD!
  my $seeking = 1;
  my $count = 0;
  my($disrec,$tag,$name);
  my $last_name = '';
  while(<I18N::LangTags::List::DATA>) {
    if($seeking) {
      $seeking = 0 if m/=for woohah/;
    } elsif( ($disrec, $tag, $name) =
          m/(\[?)\{([-0-9a-zA-Z]+)\}(?:\s*:)?\s*([^\[\]]+)/
    ) {
      $name =~ s/\s*[;\.]*\s*$//g;
      next unless $name;
      ++$count;
      print "<$tag> <$name>\n" if $Debug;
      $last_name = $Name{$tag} = $name;
      $Is_Disrec{$tag} = 1 if $disrec;
    } elsif (m/[Ff]ormerly \"([-a-z0-9]+)\"/) {
      $Name{$1} = "$last_name (old tag)" if $last_name;
      $Is_Disrec{$1} = 1;
    }
  }
  die "No tags read??" unless $count;
}
#----------------------------------------------------------------------

sub name {
  my $tag = lc($_[0] || return);
  $tag =~ s/^\s+//s;
  $tag =~ s/\s+$//s;
  
  my $alt;
  if($tag =~ m/^x-(.+)/) {
    $alt = "i-$1";
  } elsif($tag =~ m/^i-(.+)/) {
    $alt = "x-$1";
  } else {
    $alt = '';
  }
  
  my $subform = '';
  my $name = '';
  print "Input: {$tag}\n" if $Debug;
  while(length $tag) {
    last if $name = $Name{$tag};
    last if $name = $Name{$alt};
    if($tag =~ s/(-[a-z0-9]+)$//s) {
      print "Shaving off: $1 leaving $tag\n" if $Debug;
      $subform = "$1$subform";
       # and loop around again
       
      $alt =~ s/(-[a-z0-9]+)$//s && $Debug && print " alt -> $alt\n";
    } else {
      # we're trying to pull a subform off a primary tag. TILT!
      print "Aborting on: {$name}{$subform}\n" if $Debug;
      last;
    }
  }
  print "Output: {$name}{$subform}\n" if $Debug;
  
  return unless $name;   # Failure
  return $name unless $subform;   # Exact match
  $subform =~ s/^-//s;
  $subform =~ s/-$//s;
  return "$name (Subform \"$subform\")";
}

#--------------------------------------------------------------------------

sub is_decent {
  my $tag = lc($_[0] || return 0);
  #require I18N::LangTags;

  return 0 unless
    $tag =~ 
    /^(?:  # First subtag
         [xi] | [a-z]{2,3}
      )
      (?:  # Subtags thereafter
         -           # separator
         [a-z0-9]{1,8}  # subtag  
      )*
    $/xs;

  my @supers = ();
  foreach my $bit (split('-', $tag)) {
    push @supers, 
      scalar(@supers) ? ($supers[-1] . '-' . $bit) : $bit;
  }
  return 0 unless @supers;
  shift @supers if $supers[0] =~ m<^(i|x|sgn)$>s;
  return 0 unless @supers;

  foreach my $f ($tag, @supers) {
    return 0 if $Is_Disrec{$f};
    return 2 if $Name{$f};
     # so that decent subforms of indecent tags are decent
  }
  return 2 if $Name{$tag}; # not only is it decent, it's known!
  return 1;
}

#--------------------------------------------------------------------------
1;

__DATA__

=head1 NAME

I18N::LangTags::List -- tags and names for human languages

=head1 SYNOPSIS

  use I18N::LangTags::List;
  print "Parlez-vous... ", join(', ',
      I18N::LangTags::List::name('elx') || 'unknown_language',
      I18N::LangTags::List::name('ar-Kw') || 'unknown_language',
      I18N::LangTags::List::name('en') || 'unknown_language',
      I18N::LangTags::List::name('en-CA') || 'unknown_language',
    ), "?\n";

prints:

  Parlez-vous... Elamite, Kuwait Arabic, English, Canadian English?

=head1 DESCRIPTION

This module provides a function 
C<I18N::LangTags::List::name( I<langtag> ) > that takes
a language tag (see L<I18N::LangTags|I18N::LangTags>)
and returns the best attempt at an English name for it, or
undef if it can't make sense of the tag.

The function I18N::LangTags::List::name(...) is not exported.

This module also provides a function
C<I18N::LangTags::List::is_decent( I<langtag> )> that returns true iff
the language tag is syntactically valid and is for general use (like
"fr" or "fr-ca", below).  That is, it returns false for tags that are
syntactically invalid and for tags, like "aus", that are listed in
brackets below.  This function is not exported.

The map of tags-to-names that it uses is accessable as
%I18N::LangTags::List::Name, and it's the same as the list
that follows in this documentation, which should be useful
to you even if you don't use this module.

=head1 ABOUT LANGUAGE TAGS

Internet language tags, as defined in RFC 3066, are a formalism
for denoting human languages.  The two-letter ISO 639-1 language
codes are well known (as "en" for English), as are their forms
when qualified by a country code ("en-US").  Less well-known are the
arbitrary-length non-ISO codes (like "i-mingo"), and the 
recently (in 2001) introduced three-letter ISO-639-2 codes.

Remember these important facts:

=over

=item *

Language tags are not locale IDs.  A locale ID is written with a "_"
instead of a "-", (almost?) always matches C<m/^\w\w_\w\w\b/>, and
I<means> something different than a language tag.  A language tag
denotes a language.  A locale ID denotes a language I<as used in>
a particular place, in combination with non-linguistic
location-specific information such as what currency is used
there.  Locales I<also> often denote character set information,
as in "en_US.ISO8859-1".

=item *

Language tags are not for computer languages.

=item *

"Dialect" is not a useful term, since there is no objective
criterion for establishing when two language-forms are
dialects of eachother, or are separate languages.

=item *

Language tags are not case-sensitive.  en-US, en-us, En-Us, etc.,
are all the same tag, and denote the same language.

=item *

Not every language tag really refers to a single language.  Some
language tags refer to conditions: i-default (system-message text
in English plus maybe other languages), und (undetermined
language).  Others (notably lots of the three-letter codes) are
bibliographic tags that classify whole groups of languages, as
with cus "Cushitic (Other)" (i.e., a
language that has been classed as Cushtic, but which has no more
specific code) or the even less linguistically coherent
sai for "South American Indian (Other)".  Though useful in
bibliography, B<SUCH TAGS ARE NOT
FOR GENERAL USE>.  For further guidance, email me.

=item *

Language tags are not country codes.  In fact, they are often
distinct codes, as with language tag ja for Japanese, and
ISO 3166 country code C<.jp> for Japan.

=back

=head1 LIST OF LANGUAGES

The first part of each item is the language tag, between
{...}.  It
is followed by an English name for the language or language-group.
Language tags that I judge to be not for general use, are bracketed.

This list is in alphabetical order by English name of the language.

=for reminder
 The name in the =item line MUST NOT have E<...>'s in it!!

=for woohah START

=over

=item {ab} : Abkhazian

eq Abkhaz

=item {ace} : Achinese

=item {ach} : Acoli

=item {ada} : Adangme

=item {ady} : Adyghe

eq Adygei

=item {aa} : Afar

=item {afh} : Afrihili

(Artificial)

=item {af} : Afrikaans

=item [{afa} : Afro-Asiatic (Other)]

=item {ak} : Akan

(Formerly "aka".)

=item {akk} : Akkadian

(Historical)

=item {sq} : Albanian

=item {ale} : Aleut

=item [{alg} : Algonquian languages]

NOT Algonquin!

=item [{tut} : Altaic (Other)]

=item {am} : Amharic

NOT Aramaic!

=item {i-ami} : Ami

eq Amis.  eq 'Amis.  eq Pangca.

=item [{apa} : Apache languages]

=item {ar} : Arabic

Many forms are mutually un-intelligible in spoken media.
Notable forms:
{ar-ae} UAE Arabic;
{ar-bh} Bahrain Arabic;
{ar-dz} Algerian Arabic;
{ar-eg} Egyptian Arabic;
{ar-iq} Iraqi Arabic;
{ar-jo} Jordanian Arabic;
{ar-kw} Kuwait Arabic;
{ar-lb} Lebanese Arabic;
{ar-ly} Libyan Arabic;
{ar-ma} Moroccan Arabic;
{ar-om} Omani Arabic;
{ar-qa} Qatari Arabic;
{ar-sa} Sauda Arabic;
{ar-sy} Syrian Arabic;
{ar-tn} Tunisian Arabic;
{ar-ye} Yemen Arabic.

=item {arc} : Aramaic

NOT Amharic!  NOT Samaritan Aramaic!

=item {arp} : Arapaho

=item {arn} : Araucanian

=item {arw} : Arawak

=item {hy} : Armenian

=item {an} : Aragonese

=item [{art} : Artificial (Other)]

=item {ast} : Asturian

eq Bable.

=item {as} : Assamese

=item [{ath} : Athapascan languages]

eq Athabaskan.  eq Athapaskan.  eq Athabascan.

=item [{aus} : Australian languages]

=item [{map} : Austronesian (Other)]

=item {av} : Avaric

(Formerly "ava".)

=item {ae} : Avestan

eq Zend

=item {awa} : Awadhi

=item {ay} : Aymara

=item {az} : Azerbaijani

eq Azeri

Notable forms:
{az-Arab} Azerbaijani in Arabic script;
{az-Cyrl} Azerbaijani in Cyrillic script;
{az-Latn} Azerbaijani in Latin script.

=item {ban} : Balinese

=item [{bat} : Baltic (Other)]

=item {bal} : Baluchi

=item {bm} : Bambara

(Formerly "bam".)

=item [{bai} : Bamileke languages]

=item {bad} : Banda

=item [{bnt} : Bantu (Other)]

=item {bas} : Basa

=item {ba} : Bashkir

=item {eu} : Basque

=item {btk} : Batak (Indonesia)

=item {bej} : Beja

=item {be} : Belarusian

eq Belarussian.  eq Byelarussian.
eq Belorussian.  eq Byelorussian.
eq White Russian.  eq White Ruthenian.
NOT Ruthenian!

=item {bem} : Bemba

=item {bn} : Bengali

eq Bangla.

=item [{ber} : Berber (Other)]

=item {bho} : Bhojpuri

=item {bh} : Bihari

=item {bik} : Bikol

=item {bin} : Bini

=item {bi} : Bislama

eq Bichelamar.

=item {bs} : Bosnian

=item {bra} : Braj

=item {br} : Breton

=item {bug} : Buginese

=item {bg} : Bulgarian

=item {i-bnn} : Bunun

=item {bua} : Buriat

=item {my} : Burmese

=item {cad} : Caddo

=item {car} : Carib

=item {ca} : Catalan

eq CatalE<aacute>n.  eq Catalonian.

=item [{cau} : Caucasian (Other)]

=item {ceb} : Cebuano

=item [{cel} : Celtic (Other)]

Notable forms:
{cel-gaulish} Gaulish (Historical)

=item [{cai} : Central American Indian (Other)]

=item {chg} : Chagatai

(Historical?)

=item [{cmc} : Chamic languages]

=item {ch} : Chamorro

=item {ce} : Chechen

=item {chr} : Cherokee

eq Tsalagi

=item {chy} : Cheyenne

=item {chb} : Chibcha

(Historical)  NOT Chibchan (which is a language family).

=item {ny} : Chichewa

eq Nyanja.  eq Chinyanja.

=item {zh} : Chinese

Many forms are mutually un-intelligible in spoken media.
Notable forms:
{zh-Hans} Chinese, in simplified script;
{zh-Hant} Chinese, in traditional script;
{zh-tw} Taiwan Chinese;
{zh-cn} PRC Chinese;
{zh-sg} Singapore Chinese;
{zh-mo} Macau Chinese;
{zh-hk} Hong Kong Chinese;
{zh-guoyu} Mandarin [Putonghua/Guoyu];
{zh-hakka} Hakka [formerly "i-hakka"];
{zh-min} Hokkien;
{zh-min-nan} Southern Hokkien;
{zh-wuu} Shanghaiese;
{zh-xiang} Hunanese;
{zh-gan} Gan;
{zh-yue} Cantonese.

=for etc
{i-hakka} Hakka (old tag)

=item {chn} : Chinook Jargon

eq Chinook Wawa.

=item {chp} : Chipewyan

=item {cho} : Choctaw

=item {cu} : Church Slavic

eq Old Church Slavonic.

=item {chk} : Chuukese

eq Trukese.  eq Chuuk.  eq Truk.  eq Ruk.

=item {cv} : Chuvash

=item {cop} : Coptic

=item {kw} : Cornish

=item {co} : Corsican

eq Corse.

=item {cr} : Cree

NOT Creek!  (Formerly "cre".)

=item {mus} : Creek

NOT Cree!

=item [{cpe} : English-based Creoles and pidgins (Other)]

=item [{cpf} : French-based Creoles and pidgins (Other)]

=item [{cpp} : Portuguese-based Creoles and pidgins (Other)]

=item [{crp} : Creoles and pidgins (Other)]

=item {hr} : Croatian

eq Croat.

=item [{cus} : Cushitic (Other)]

=item {cs} : Czech

=item {dak} : Dakota

eq Nakota.  eq Latoka.

=item {da} : Danish

=item {dar} : Dargwa

=item {day} : Dayak

=item {i-default} : Default (Fallthru) Language

Defined in RFC 2277, this is for tagging text
(which must include English text, and might/should include text
in other appropriate languages) that is emitted in a context
where language-negotiation wasn't possible -- in SMTP mail failure
messages, for example.

=item {del} : Delaware

=item {din} : Dinka

=item {dv} : Divehi

eq Maldivian.  (Formerly "div".)

=item {doi} : Dogri

NOT Dogrib!

=item {dgr} : Dogrib

NOT Dogri!

=item [{dra} : Dravidian (Other)]

=item {dua} : Duala

=item {nl} : Dutch

eq Netherlander.  Notable forms:
{nl-nl} Netherlands Dutch;
{nl-be} Belgian Dutch.

=item {dum} : Middle Dutch (ca.1050-1350)

(Historical)

=item {dyu} : Dyula

=item {dz} : Dzongkha

=item {efi} : Efik

=item {egy} : Ancient Egyptian

(Historical)

=item {eka} : Ekajuk

=item {elx} : Elamite

(Historical)

=item {en} : English

Notable forms:
{en-au} Australian English;
{en-bz} Belize English;
{en-ca} Canadian English;
{en-gb} UK English;
{en-ie} Irish English;
{en-jm} Jamaican English;
{en-nz} New Zealand English;
{en-ph} Philippine English;
{en-tt} Trinidad English;
{en-us} US English;
{en-za} South African English;
{en-zw} Zimbabwe English.

=item {enm} : Old English (1100-1500)

(Historical)

=item {ang} : Old English (ca.450-1100)

eq Anglo-Saxon.  (Historical)

=item {i-enochian} : Enochian (Artificial)

=item {myv} : Erzya

=item {eo} : Esperanto

(Artificial)

=item {et} : Estonian

=item {ee} : Ewe

(Formerly "ewe".)

=item {ewo} : Ewondo

=item {fan} : Fang

=item {fat} : Fanti

=item {fo} : Faroese

=item {fj} : Fijian

=item {fi} : Finnish

=item [{fiu} : Finno-Ugrian (Other)]

eq Finno-Ugric.  NOT Ugaritic!

=item {fon} : Fon

=item {fr} : French

Notable forms:
{fr-fr} France French;
{fr-be} Belgian French;
{fr-ca} Canadian French;
{fr-ch} Swiss French;
{fr-lu} Luxembourg French;
{fr-mc} Monaco French.

=item {frm} : Middle French (ca.1400-1600)

(Historical)

=item {fro} : Old French (842-ca.1400)

(Historical)

=item {fy} : Frisian

=item {fur} : Friulian

=item {ff} : Fulah

(Formerly "ful".)

=item {gaa} : Ga

=item {gd} : Scots Gaelic

NOT Scots!

=item {gl} : Gallegan

eq Galician

=item {lg} : Ganda

(Formerly "lug".)

=item {gay} : Gayo

=item {gba} : Gbaya

=item {gez} : Geez

eq Ge'ez

=item {ka} : Georgian

=item {de} : German

Notable forms:
{de-at} Austrian German;
{de-be} Belgian German;
{de-ch} Swiss German;
{de-de} Germany German;
{de-li} Liechtenstein German;
{de-lu} Luxembourg German.

=item {gmh} : Middle High German (ca.1050-1500)

(Historical)

=item {goh} : Old High German (ca.750-1050)

(Historical)

=item [{gem} : Germanic (Other)]

=item {gil} : Gilbertese

=item {gon} : Gondi

=item {gor} : Gorontalo

=item {got} : Gothic

(Historical)

=item {grb} : Grebo

=item {grc} : Ancient Greek

(Historical)  (Until 15th century or so.)

=item {el} : Modern Greek

(Since 15th century or so.)

=item {gn} : Guarani

GuaranE<iacute>

=item {gu} : Gujarati

=item {gwi} : Gwich'in

eq Gwichin

=item {hai} : Haida

=item {ht} : Haitian

eq Haitian Creole

=item {ha} : Hausa

=item {haw} : Hawaiian

Hawai'ian

=item {he} : Hebrew

(Formerly "iw".)

=for etc
{iw} Hebrew (old tag)

=item {hz} : Herero

=item {hil} : Hiligaynon

=item {him} : Himachali

=item {hi} : Hindi

=item {ho} : Hiri Motu

=item {hit} : Hittite

(Historical)

=item {hmn} : Hmong

=item {hu} : Hungarian

=item {hup} : Hupa

=item {iba} : Iban

=item {is} : Icelandic

=item {io} : Ido

(Artificial)

=item {ig} : Igbo

(Formerly "ibo".)

=item {ijo} : Ijo

=item {ilo} : Iloko

=item [{inc} : Indic (Other)]

=item [{ine} : Indo-European (Other)]

=item {id} : Indonesian

(Formerly "in".)

=for etc
{in} Indonesian (old tag)

=item {inh} : Ingush

=item {ia} : Interlingua (International Auxiliary Language Association)

(Artificial)  NOT Interlingue!

=item {ie} : Interlingue

(Artificial)  NOT Interlingua!

=item {iu} : Inuktitut

A subform of "Eskimo".

=item {ik} : Inupiaq

A subform of "Eskimo".

=item [{ira} : Iranian (Other)]

=item {ga} : Irish

=item {mga} : Middle Irish (900-1200)

(Historical)

=item {sga} : Old Irish (to 900)

(Historical)

=item [{iro} : Iroquoian languages]

=item {it} : Italian

Notable forms:
{it-it} Italy Italian;
{it-ch} Swiss Italian.

=item {ja} : Japanese

(NOT "jp"!)

=item {jv} : Javanese

(Formerly "jw" because of a typo.)

=item {jrb} : Judeo-Arabic

=item {jpr} : Judeo-Persian

=item {kbd} : Kabardian

=item {kab} : Kabyle

=item {kac} : Kachin

=item {kl} : Kalaallisut

eq Greenlandic "Eskimo"

=item {xal} : Kalmyk

=item {kam} : Kamba

=item {kn} : Kannada

eq Kanarese.  NOT Canadian!

=item {kr} : Kanuri

(Formerly "kau".)

=item {krc} : Karachay-Balkar

=item {kaa} : Kara-Kalpak

=item {kar} : Karen

=item {ks} : Kashmiri

=item {csb} : Kashubian

eq Kashub

=item {kaw} : Kawi

=item {kk} : Kazakh

=item {kha} : Khasi

=item {km} : Khmer

eq Cambodian.  eq Kampuchean.

=item [{khi} : Khoisan (Other)]

=item {kho} : Khotanese

=item {ki} : Kikuyu

eq Gikuyu.

=item {kmb} : Kimbundu

=item {rw} : Kinyarwanda

=item {ky} : Kirghiz

=item {i-klingon} : Klingon

=item {kv} : Komi

=item {kg} : Kongo

(Formerly "kon".)

=item {kok} : Konkani

=item {ko} : Korean

=item {kos} : Kosraean

=item {kpe} : Kpelle

=item {kro} : Kru

=item {kj} : Kuanyama

=item {kum} : Kumyk

=item {ku} : Kurdish

=item {kru} : Kurukh

=item {kut} : Kutenai

=item {lad} : Ladino

eq Judeo-Spanish.  NOT Ladin (a minority language in Italy).

=item {lah} : Lahnda

NOT Lamba!

=item {lam} : Lamba

NOT Lahnda!

=item {lo} : Lao

eq Laotian.

=item {la} : Latin

(Historical)  NOT Ladin!  NOT Ladino!

=item {lv} : Latvian

eq Lettish.

=item {lb} : Letzeburgesch

eq Luxemburgian, eq Luxemburger.  (Formerly "i-lux".)

=for etc
{i-lux} Letzeburgesch (old tag)

=item {lez} : Lezghian

=item {li} : Limburgish

eq Limburger, eq Limburgan.  NOT Letzeburgesch!

=item {ln} : Lingala

=item {lt} : Lithuanian

=item {nds} : Low German

eq Low Saxon.  eq Low German.  eq Low Saxon.

=item {art-lojban} : Lojban (Artificial)

=item {loz} : Lozi

=item {lu} : Luba-Katanga

(Formerly "lub".)

=item {lua} : Luba-Lulua

=item {lui} : Luiseno

eq LuiseE<ntilde>o.

=item {lun} : Lunda

=item {luo} : Luo (Kenya and Tanzania)

=item {lus} : Lushai

=item {mk} : Macedonian

eq the modern Slavic language spoken in what was Yugoslavia.
NOT the form of Greek spoken in Greek Macedonia!

=item {mad} : Madurese

=item {mag} : Magahi

=item {mai} : Maithili

=item {mak} : Makasar

=item {mg} : Malagasy

=item {ms} : Malay

NOT Malayalam!

=item {ml} : Malayalam

NOT Malay!

=item {mt} : Maltese

=item {mnc} : Manchu

=item {mdr} : Mandar

NOT Mandarin!

=item {man} : Mandingo

=item {mni} : Manipuri

eq Meithei.

=item [{mno} : Manobo languages]

=item {gv} : Manx

=item {mi} : Maori

NOT Mari!

=item {mr} : Marathi

=item {chm} : Mari

NOT Maori!

=item {mh} : Marshall

eq Marshallese.

=item {mwr} : Marwari

=item {mas} : Masai

=item [{myn} : Mayan languages]

=item {men} : Mende

=item {mic} : Micmac

=item {min} : Minangkabau

=item {i-mingo} : Mingo

eq the Irquoian language West Virginia Seneca.  NOT New York Seneca!

=item [{mis} : Miscellaneous languages]

Don't use this.

=item {moh} : Mohawk

=item {mdf} : Moksha

=item {mo} : Moldavian

eq Moldovan.

=item [{mkh} : Mon-Khmer (Other)]

=item {lol} : Mongo

=item {mn} : Mongolian

eq Mongol.

=item {mos} : Mossi

=item [{mul} : Multiple languages]

Not for normal use.

=item [{mun} : Munda languages]

=item {nah} : Nahuatl

=item {nap} : Neapolitan

=item {na} : Nauru

=item {nv} : Navajo

eq Navaho.  (Formerly "i-navajo".)

=for etc
{i-navajo} Navajo (old tag)

=item {nd} : North Ndebele

=item {nr} : South Ndebele

=item {ng} : Ndonga

=item {ne} : Nepali

eq Nepalese.  Notable forms:
{ne-np} Nepal Nepali;
{ne-in} India Nepali.

=item {new} : Newari

=item {nia} : Nias

=item [{nic} : Niger-Kordofanian (Other)]

=item [{ssa} : Nilo-Saharan (Other)]

=item {niu} : Niuean

=item {nog} : Nogai

=item {non} : Old Norse

(Historical)

=item [{nai} : North American Indian]

Do not use this.

=item {no} : Norwegian

Note the two following forms:

=item {nb} : Norwegian Bokmal

eq BokmE<aring>l, (A form of Norwegian.)  (Formerly "no-bok".)

=for etc
{no-bok} Norwegian Bokmal (old tag)

=item {nn} : Norwegian Nynorsk

(A form of Norwegian.)  (Formerly "no-nyn".)

=for etc
{no-nyn} Norwegian Nynorsk (old tag)

=item [{nub} : Nubian languages]

=item {nym} : Nyamwezi

=item {nyn} : Nyankole

=item {nyo} : Nyoro

=item {nzi} : Nzima

=item {oc} : Occitan (post 1500)

eq ProvenE<ccedil>al, eq Provencal

=item {oj} : Ojibwa

eq Ojibwe.  (Formerly "oji".)

=item {or} : Oriya

=item {om} : Oromo

=item {osa} : Osage

=item {os} : Ossetian; Ossetic

=item [{oto} : Otomian languages]

Group of languages collectively called "OtomE<iacute>".

=item {pal} : Pahlavi

eq Pahlevi

=item {i-pwn} : Paiwan

eq Pariwan

=item {pau} : Palauan

=item {pi} : Pali

(Historical?)

=item {pam} : Pampanga

=item {pag} : Pangasinan

=item {pa} : Panjabi

eq Punjabi

=item {pap} : Papiamento

eq Papiamentu.

=item [{paa} : Papuan (Other)]

=item {fa} : Persian

eq Farsi.  eq Iranian.

=item {peo} : Old Persian (ca.600-400 B.C.)

=item [{phi} : Philippine (Other)]

=item {phn} : Phoenician

(Historical)

=item {pon} : Pohnpeian

NOT Pompeiian!

=item {pl} : Polish

=item {pt} : Portuguese

eq Portugese.  Notable forms:
{pt-pt} Portugal Portuguese;
{pt-br} Brazilian Portuguese.

=item [{pra} : Prakrit languages]

=item {pro} : Old Provencal (to 1500)

eq Old ProvenE<ccedil>al.  (Historical.)

=item {ps} : Pushto

eq Pashto.  eq Pushtu.

=item {qu} : Quechua

eq Quecha.

=item {rm} : Raeto-Romance

eq Romansh.

=item {raj} : Rajasthani

=item {rap} : Rapanui

=item {rar} : Rarotongan

=item [{qaa - qtz} : Reserved for local use.]

=item [{roa} : Romance (Other)]

NOT Romanian!  NOT Romany!  NOT Romansh!

=item {ro} : Romanian

eq Rumanian.  NOT Romany!

=item {rom} : Romany

eq Rom.  NOT Romanian!

=item {rn} : Rundi

=item {ru} : Russian

NOT White Russian!  NOT Rusyn!

=item [{sal} : Salishan languages]

Large language group.

=item {sam} : Samaritan Aramaic

NOT Aramaic!

=item {se} : Northern Sami

eq Lappish.  eq Lapp.  eq (Northern) Saami.

=item {sma} : Southern Sami

=item {smn} : Inari Sami

=item {smj} : Lule Sami

=item {sms} : Skolt Sami

=item [{smi} : Sami languages (Other)]

=item {sm} : Samoan

=item {sad} : Sandawe

=item {sg} : Sango

=item {sa} : Sanskrit

(Historical)

=item {sat} : Santali

=item {sc} : Sardinian

eq Sard.

=item {sas} : Sasak

=item {sco} : Scots

NOT Scots Gaelic!

=item {sel} : Selkup

=item [{sem} : Semitic (Other)]

=item {sr} : Serbian

eq Serb.  NOT Sorbian.

Notable forms:
{sr-Cyrl} : Serbian in Cyrillic script;
{sr-Latn} : Serbian in Latin script.

=item {srr} : Serer

=item {shn} : Shan

=item {sn} : Shona

=item {sid} : Sidamo

=item {sgn-...} : Sign Languages

Always use with a subtag.  Notable forms:
{sgn-gb} British Sign Language (BSL);
{sgn-ie} Irish Sign Language (ESL);
{sgn-ni} Nicaraguan Sign Language (ISN);
{sgn-us} American Sign Language (ASL).

(And so on with other country codes as the subtag.)

=item {bla} : Siksika

eq Blackfoot.  eq Pikanii.

=item {sd} : Sindhi

=item {si} : Sinhalese

eq Sinhala.

=item [{sit} : Sino-Tibetan (Other)]

=item [{sio} : Siouan languages]

=item {den} : Slave (Athapascan)

("Slavey" is a subform.)

=item [{sla} : Slavic (Other)]

=item {sk} : Slovak

eq Slovakian.

=item {sl} : Slovenian

eq Slovene.

=item {sog} : Sogdian

=item {so} : Somali

=item {son} : Songhai

=item {snk} : Soninke

=item {wen} : Sorbian languages

eq Wendish.  eq Sorb.  eq Lusatian.  eq Wend.  NOT Venda!  NOT Serbian!

=item {nso} : Northern Sotho

=item {st} : Southern Sotho

eq Sutu.  eq Sesotho.

=item [{sai} : South American Indian (Other)]

=item {es} : Spanish

Notable forms:
{es-ar} Argentine Spanish;
{es-bo} Bolivian Spanish;
{es-cl} Chilean Spanish;
{es-co} Colombian Spanish;
{es-do} Dominican Spanish;
{es-ec} Ecuadorian Spanish;
{es-es} Spain Spanish;
{es-gt} Guatemalan Spanish;
{es-hn} Honduran Spanish;
{es-mx} Mexican Spanish;
{es-pa} Panamanian Spanish;
{es-pe} Peruvian Spanish;
{es-pr} Puerto Rican Spanish;
{es-py} Paraguay Spanish;
{es-sv} Salvadoran Spanish;
{es-us} US Spanish;
{es-uy} Uruguayan Spanish;
{es-ve} Venezuelan Spanish.

=item {suk} : Sukuma

=item {sux} : Sumerian

(Historical)

=item {su} : Sundanese

=item {sus} : Susu

=item {sw} : Swahili

eq Kiswahili

=item {ss} : Swati

=item {sv} : Swedish

Notable forms:
{sv-se} Sweden Swedish;
{sv-fi} Finland Swedish.

=item {syr} : Syriac

=item {tl} : Tagalog

=item {ty} : Tahitian

=item [{tai} : Tai (Other)]

NOT Thai!

=item {tg} : Tajik

=item {tmh} : Tamashek

=item {ta} : Tamil

=item {i-tao} : Tao

eq Yami.

=item {tt} : Tatar

=item {i-tay} : Tayal

eq Atayal.  eq Atayan.

=item {te} : Telugu

=item {ter} : Tereno

=item {tet} : Tetum

=item {th} : Thai

NOT Tai!

=item {bo} : Tibetan

=item {tig} : Tigre

=item {ti} : Tigrinya

=item {tem} : Timne

eq Themne.  eq Timene.

=item {tiv} : Tiv

=item {tli} : Tlingit

=item {tpi} : Tok Pisin

=item {tkl} : Tokelau

=item {tog} : Tonga (Nyasa)

NOT Tsonga!

=item {to} : Tonga (Tonga Islands)

(Pronounced "Tong-a", not "Tong-ga")

NOT Tsonga!

=item {tsi} : Tsimshian

eq Sm'algyax

=item {ts} : Tsonga

NOT Tonga!

=item {i-tsu} : Tsou

=item {tn} : Tswana

Same as Setswana.

=item {tum} : Tumbuka

=item [{tup} : Tupi languages]

=item {tr} : Turkish

(Typically in Roman script)

=item {ota} : Ottoman Turkish (1500-1928)

(Typically in Arabic script)  (Historical)

=item {crh} : Crimean Turkish

eq Crimean Tatar

=item {tk} : Turkmen

eq Turkmeni.

=item {tvl} : Tuvalu

=item {tyv} : Tuvinian

eq Tuvan.  eq Tuvin.

=item {tw} : Twi

=item {udm} : Udmurt

=item {uga} : Ugaritic

NOT Ugric!

=item {ug} : Uighur

=item {uk} : Ukrainian

=item {umb} : Umbundu

=item {und} : Undetermined

Not a tag for normal use.

=item {ur} : Urdu

=item {uz} : Uzbek

eq E<Ouml>zbek

Notable forms:
{uz-Cyrl} Uzbek in Cyrillic script;
{uz-Latn} Uzbek in Latin script.

=item {vai} : Vai

=item {ve} : Venda

NOT Wendish!  NOT Wend!  NOT Avestan!  (Formerly "ven".)

=item {vi} : Vietnamese

eq Viet.

=item {vo} : Volapuk

eq VolapE<uuml>k.  (Artificial)

=item {vot} : Votic

eq Votian.  eq Vod.

=item [{wak} : Wakashan languages]

=item {wa} : Walloon

=item {wal} : Walamo

eq Wolaytta.

=item {war} : Waray

Presumably the Philippine language Waray-Waray (SamareE<ntilde>o),
not the smaller Philippine language Waray Sorsogon, nor the extinct
Australian language Waray.

=item {was} : Washo

eq Washoe

=item {cy} : Welsh

=item {wo} : Wolof

=item {x-...} : Unregistered (Semi-Private Use)

"x-" is a prefix for language tags that are not registered with ISO
or IANA.  Example, x-double-dutch

=item {xh} : Xhosa

=item {sah} : Yakut

=item {yao} : Yao

(The Yao in Malawi?)

=item {yap} : Yapese

eq Yap

=item {ii} : Sichuan Yi

=item {yi} : Yiddish

Formerly "ji".  Usually in Hebrew script.

Notable forms:
{yi-latn} Yiddish in Latin script

=item {yo} : Yoruba

=item [{ypk} : Yupik languages]

Several "Eskimo" languages.

=item {znd} : Zande

=item [{zap} : Zapotec]

(A group of languages.)

=item {zen} : Zenaga

NOT Zend.

=item {za} : Zhuang

=item {zu} : Zulu

=item {zun} : Zuni

eq ZuE<ntilde>i

=back

=for woohah END

=head1 SEE ALSO

L<I18N::LangTags|I18N::LangTags> and its "See Also" section.

=head1 COPYRIGHT AND DISCLAIMER

Copyright (c) 2001+ Sean M. Burke. All rights reserved.

You can redistribute and/or
modify this document under the same terms as Perl itself.

This document is provided in the hope that it will be
useful, but without any warranty;
without even the implied warranty of accuracy, authoritativeness,
completeness, merchantability, or fitness for a particular purpose.

Email any corrections or questions to me.

=head1 AUTHOR

Sean M. Burke, sburkeE<64>cpan.org

=cut


# To generate a list of just the two and three-letter codes:

#!/usr/local/bin/perl -w

require 5; # Time-stamp: "2001-03-13 21:53:39 MST"
 # Sean M. Burke, sburke@cpan.org
 # This program is for generating the language_codes.txt file
use strict;
use LWP::Simple;
use HTML::TreeBuilder 3.10;
my $root = HTML::TreeBuilder->new();
my $url = 'http://lcweb.loc.gov/standards/iso639-2/bibcodes.html';
$root->parse(get($url) || die "Can't get $url");
$root->eof();

my @codes;

foreach my $tr ($root->find_by_tag_name('tr')) {
  my @f = map $_->as_text(), $tr->content_list();
  #print map("<$_> ", @f), "\n";
  next unless @f == 5;
  pop @f; # nix the French name
  next if $f[-1] eq 'Language Name (English)'; # it's a header line
  my $xx = splice(@f, 2,1); # pull out the two-letter code
  $f[-1] =~ s/^\s+//;
  $f[-1] =~ s/\s+$//;
  if($xx =~ m/[a-zA-Z]/) {   # there's a two-letter code for it
    push   @codes, [ lc($f[-1]),   "$xx\t$f[-1]\n" ];
  } else { # print the three-letter codes.
    if($f[0] eq $f[1]) {
      push @codes, [ lc($f[-1]), "$f[1]\t$f[2]\n" ];
    } else { # shouldn't happen
      push @codes, [ lc($f[-1]), "@f !!!!!!!!!!\n" ]; 
    }
  }
}

print map $_->[1], sort {; $a->[0] cmp $b->[0] } @codes;
print "[ based on $url\n at ", scalar(localtime), "]\n",
  "[Note: doesn't include IANA-registered codes.]\n";
exit;
__END__

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
# Time-stamp: "2004-06-20 21:47:55 ADT"

require 5;
package I18N::LangTags::Detect;
use strict;

use vars qw( @ISA $VERSION $MATCH_SUPERS $USING_LANGUAGE_TAGS
             $USE_LITERALS $MATCH_SUPERS_TIGHTLY);

BEGIN { unless(defined &DEBUG) { *DEBUG = sub () {0} } }
 # define the constant 'DEBUG' at compile-time

$VERSION = "1.03";
@ISA = ();
use I18N::LangTags qw(alternate_language_tags locale2language_tag);

sub _uniq { my %seen; return grep(!($seen{$_}++), @_); }
sub _normalize {
  my(@languages) =
    map lc($_),
    grep $_,
    map {; $_, alternate_language_tags($_) } @_;
  return _uniq(@languages) if wantarray;
  return $languages[0];
}

#---------------------------------------------------------------------------
# The extent of our functional interface:

sub detect () { return __PACKAGE__->ambient_langprefs; }

#===========================================================================

sub ambient_langprefs { # always returns things untainted
  my $base_class = $_[0];
  
  return $base_class->http_accept_langs
   if length( $ENV{'REQUEST_METHOD'} || '' ); # I'm a CGI
       # it's off in its own routine because it's complicated

  # Not running as a CGI: try to puzzle out from the environment
  my @languages;

  foreach my $envname (qw( LANGUAGE LC_ALL LC_MESSAGES LANG )) {
    next unless $ENV{$envname};
    DEBUG and print "Noting \$$envname: $ENV{$envname}\n";
    push @languages,
      map locale2language_tag($_),
        # if it's a lg tag, fine, pass thru (untainted)
        # if it's a locale ID, try converting to a lg tag (untainted),
        # otherwise nix it.

      split m/[,:]/,
      $ENV{$envname}
    ;
    last; # first one wins
  }
  
  if($ENV{'IGNORE_WIN32_LOCALE'}) {
    # no-op
  } elsif(&_try_use('Win32::Locale')) {
    # If we have that module installed...
    push @languages, Win32::Locale::get_language() || ''
     if defined &Win32::Locale::get_language;
  }
  return _normalize @languages;
}

#---------------------------------------------------------------------------

sub http_accept_langs {
  # Deal with HTTP "Accept-Language:" stuff.  Hassle.
  # This code is more lenient than RFC 3282, which you must read.
  # Hm.  Should I just move this into I18N::LangTags at some point?
  no integer;

  my $in = (@_ > 1) ? $_[1] : $ENV{'HTTP_ACCEPT_LANGUAGE'};
  # (always ends up untainting)

  return() unless defined $in and length $in;

  $in =~ s/\([^\)]*\)//g; # nix just about any comment
  
  if( $in =~ m/^\s*([a-zA-Z][-a-zA-Z]+)\s*$/s ) {
    # Very common case: just one language tag
    return _normalize $1;
  } elsif( $in =~ m/^\s*[a-zA-Z][-a-zA-Z]+(?:\s*,\s*[a-zA-Z][-a-zA-Z]+)*\s*$/s ) {
    # Common case these days: just "foo, bar, baz"
    return _normalize( $in =~ m/([a-zA-Z][-a-zA-Z]+)/g );
  }

  # Else it's complicated...

  $in =~ s/\s+//g;  # Yes, we can just do without the WS!
  my @in = $in =~ m/([^,]+)/g;
  my %pref;
  
  my $q;
  foreach my $tag (@in) {
    next unless $tag =~
     m/^([a-zA-Z][-a-zA-Z]+)
        (?:
         ;q=
         (
          \d*   # a bit too broad of a RE, but so what.
          (?:
            \.\d+
          )?
         )
        )?
       $
      /sx
    ;
    $q = (defined $2 and length $2) ? $2 : 1;
    #print "$1 with q=$q\n";
    push @{ $pref{$q} }, lc $1;
  }

  return _normalize(
    # Read off %pref, in descending key order...
    map @{$pref{$_}},
    sort {$b <=> $a}
    keys %pref
  );
}

#===========================================================================

my %tried = ();
  # memoization of whether we've used this module, or found it unusable.

sub _try_use {   # Basically a wrapper around "require Modulename"
  # "Many men have tried..."  "They tried and failed?"  "They tried and died."
  return $tried{$_[0]} if exists $tried{$_[0]};  # memoization

  my $module = $_[0];   # ASSUME sane module name!
  { no strict 'refs';
    return($tried{$module} = 1)
     if defined(%{$module . "::Lexicon"}) or defined(@{$module . "::ISA"});
    # weird case: we never use'd it, but there it is!
  }

  print " About to use $module ...\n" if DEBUG;
  {
    local $SIG{'__DIE__'};
    eval "require $module"; # used to be "use $module", but no point in that.
  }
  if($@) {
    print "Error using $module \: $@\n" if DEBUG > 1;
    return $tried{$module} = 0;
  } else {
    print " OK, $module is used\n" if DEBUG;
    return $tried{$module} = 1;
  }
}

#---------------------------------------------------------------------------
1;
__END__


=head1 NAME

I18N::LangTags::Detect - detect the user's language preferences

=head1 SYNOPSIS

  use I18N::LangTags::Detect;
  my @user_wants = I18N::LangTags::Detect::detect();

=head1 DESCRIPTION

It is a common problem to want to detect what language(s) the user would
prefer output in.

=head1 FUNCTIONS

This module defines one public function,
C<I18N::LangTags::Detect::detect()>.  This function is not exported
(nor is even exportable), and it takes no parameters.

In scalar context, the function returns the most preferred language
tag (or undef if no preference was seen).

In list context (which is usually what you want),
the function returns a
(possibly empty) list of language tags representing (best first) what
languages the user apparently would accept output in.  You will
probably want to pass the output of this through
C<I18N::LangTags::implicate_supers_tightly(...)>
or
C<I18N::LangTags::implicate_supers(...)>, like so:

  my @languages =
    I18N::LangTags::implicate_supers_tightly(
      I18N::LangTags::Detect::detect()
    );


=head1 ENVIRONMENT

This module looks for several environment variables, including
REQUEST_METHOD, HTTP_ACCEPT_LANGUAGE,
LANGUAGE, LC_ALL, LC_MESSAGES, and LANG.

It will also use the L<Win32::Locale> module, if it's installed.


=head1 SEE ALSO

L<I18N::LangTags>, L<Win32::Locale>, L<Locale::Maketext>.

(This module's core code started out as a routine in Locale::Maketext;
but I moved it here once I realized it was more generally useful.)


=head1 COPYRIGHT

Copyright (c) 1998-2004 Sean M. Burke. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

The programs and documentation in this dist are distributed in
the hope that they will be useful, but without any warranty; without
even the implied warranty of merchantability or fitness for a
particular purpose.


=head1 AUTHOR

Sean M. Burke C<sburke@cpan.org>

=cut

# a tip: Put a bit of chopped up pickled ginger in your salad. It's tasty!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
# Time-stamp: "2004-10-06 23:26:33 ADT"
# Sean M. Burke <sburke@cpan.org>

require 5.000;
package I18N::LangTags;
use strict;
use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION %Panic);
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw();
@EXPORT_OK = qw(is_language_tag same_language_tag
                extract_language_tags super_languages
                similarity_language_tag is_dialect_of
                locale2language_tag alternate_language_tags
                encode_language_tag panic_languages
                implicate_supers
                implicate_supers_strictly
               );
%EXPORT_TAGS = ('ALL' => \@EXPORT_OK);

$VERSION = "0.35";

sub uniq { my %seen; return grep(!($seen{$_}++), @_); } # a util function


=head1 NAME

I18N::LangTags - functions for dealing with RFC3066-style language tags

=head1 SYNOPSIS

  use I18N::LangTags();

...or specify whichever of those functions you want to import, like so:

  use I18N::LangTags qw(implicate_supers similarity_language_tag);

All the exportable functions are listed below -- you're free to import
only some, or none at all.  By default, none are imported.  If you
say:

    use I18N::LangTags qw(:ALL)

...then all are exported.  (This saves you from having to use
something less obvious like C<use I18N::LangTags qw(/./)>.)

If you don't import any of these functions, assume a C<&I18N::LangTags::>
in front of all the function names in the following examples.

=head1 DESCRIPTION

Language tags are a formalism, described in RFC 3066 (obsoleting
1766), for declaring what language form (language and possibly
dialect) a given chunk of information is in.

This library provides functions for common tasks involving language
tags as they are needed in a variety of protocols and applications.

Please see the "See Also" references for a thorough explanation
of how to correctly use language tags.

=over

=cut

###########################################################################

=item * the function is_language_tag($lang1)

Returns true iff $lang1 is a formally valid language tag.

   is_language_tag("fr")            is TRUE
   is_language_tag("x-jicarilla")   is FALSE
       (Subtags can be 8 chars long at most -- 'jicarilla' is 9)

   is_language_tag("sgn-US")    is TRUE
       (That's American Sign Language)

   is_language_tag("i-Klikitat")    is TRUE
       (True without regard to the fact noone has actually
        registered Klikitat -- it's a formally valid tag)

   is_language_tag("fr-patois")     is TRUE
       (Formally valid -- altho descriptively weak!)

   is_language_tag("Spanish")       is FALSE
   is_language_tag("french-patois") is FALSE
       (No good -- first subtag has to match
        /^([xXiI]|[a-zA-Z]{2,3})$/ -- see RFC3066)

   is_language_tag("x-borg-prot2532") is TRUE
       (Yes, subtags can contain digits, as of RFC3066)

=cut

sub is_language_tag {

  ## Changes in the language tagging standards may have to be reflected here.

  my($tag) = lc($_[0]);

  return 0 if $tag eq "i" or $tag eq "x";
  # Bad degenerate cases that the following
  #  regexp would erroneously let pass

  return $tag =~ 
    /^(?:  # First subtag
         [xi] | [a-z]{2,3}
      )
      (?:  # Subtags thereafter
         -           # separator
         [a-z0-9]{1,8}  # subtag  
      )*
    $/xs ? 1 : 0;
}

###########################################################################

=item * the function extract_language_tags($whatever)

Returns a list of whatever looks like formally valid language tags
in $whatever.  Not very smart, so don't get too creative with
what you want to feed it.

  extract_language_tags("fr, fr-ca, i-mingo")
    returns:   ('fr', 'fr-ca', 'i-mingo')

  extract_language_tags("It's like this: I'm in fr -- French!")
    returns:   ('It', 'in', 'fr')
  (So don't just feed it any old thing.)

The output is untainted.  If you don't know what tainting is,
don't worry about it.

=cut

sub extract_language_tags {

  ## Changes in the language tagging standards may have to be reflected here.

  my($text) =
    $_[0] =~ m/(.+)/  # to make for an untainted result
    ? $1 : ''
  ;
  
  return grep(!m/^[ixIX]$/s, # 'i' and 'x' aren't good tags
    $text =~ 
    m/
      \b
      (?:  # First subtag
         [iIxX] | [a-zA-Z]{2,3}
      )
      (?:  # Subtags thereafter
         -           # separator
         [a-zA-Z0-9]{1,8}  # subtag  
      )*
      \b
    /xsg
  );
}

###########################################################################

=item * the function same_language_tag($lang1, $lang2)

Returns true iff $lang1 and $lang2 are acceptable variant tags
representing the same language-form.

   same_language_tag('x-kadara', 'i-kadara')  is TRUE
      (The x/i- alternation doesn't matter)
   same_language_tag('X-KADARA', 'i-kadara')  is TRUE
      (...and neither does case)
   same_language_tag('en',       'en-US')     is FALSE
      (all-English is not the SAME as US English)
   same_language_tag('x-kadara', 'x-kadar')   is FALSE
      (these are totally unrelated tags)
   same_language_tag('no-bok',    'nb')       is TRUE
      (no-bok is a legacy tag for nb (Norwegian Bokmal))

C<same_language_tag> works by just seeing whether
C<encode_language_tag($lang1)> is the same as
C<encode_language_tag($lang2)>.

(Yes, I know this function is named a bit oddly.  Call it historic
reasons.)

=cut

sub same_language_tag {
  my $el1 = &encode_language_tag($_[0]);
  return 0 unless defined $el1;
   # this avoids the problem of
   # encode_language_tag($lang1) eq and encode_language_tag($lang2)
   # being true if $lang1 and $lang2 are both undef

  return $el1 eq &encode_language_tag($_[1]) ? 1 : 0;
}

###########################################################################

=item * the function similarity_language_tag($lang1, $lang2)

Returns an integer representing the degree of similarity between
tags $lang1 and $lang2 (the order of which does not matter), where
similarity is the number of common elements on the left,
without regard to case and to x/i- alternation.

   similarity_language_tag('fr', 'fr-ca')           is 1
      (one element in common)
   similarity_language_tag('fr-ca', 'fr-FR')        is 1
      (one element in common)

   similarity_language_tag('fr-CA-joual',
                           'fr-CA-PEI')             is 2
   similarity_language_tag('fr-CA-joual', 'fr-CA')  is 2
      (two elements in common)

   similarity_language_tag('x-kadara', 'i-kadara')  is 1
      (x/i- doesn't matter)

   similarity_language_tag('en',       'x-kadar')   is 0
   similarity_language_tag('x-kadara', 'x-kadar')   is 0
      (unrelated tags -- no similarity)

   similarity_language_tag('i-cree-syllabic',
                           'i-cherokee-syllabic')   is 0
      (no B<leftmost> elements in common!)

=cut

sub similarity_language_tag {
  my $lang1 = &encode_language_tag($_[0]);
  my $lang2 = &encode_language_tag($_[1]);
   # And encode_language_tag takes care of the whole
   #  no-nyn==nn, i-hakka==zh-hakka, etc, things
   
  # NB: (i-sil-...)?  (i-sgn-...)?

  return undef if !defined($lang1) and !defined($lang2);
  return 0 if !defined($lang1) or !defined($lang2);

  my @l1_subtags = split('-', $lang1);
  my @l2_subtags = split('-', $lang2);
  my $similarity = 0;

  while(@l1_subtags and @l2_subtags) {
    if(shift(@l1_subtags) eq shift(@l2_subtags)) {
      ++$similarity;
    } else {
      last;
    } 
  }
  return $similarity;
}

###########################################################################

=item * the function is_dialect_of($lang1, $lang2)

Returns true iff language tag $lang1 represents a subform of
language tag $lang2.

B<Get the order right!  It doesn't work the other way around!>

   is_dialect_of('en-US', 'en')            is TRUE
     (American English IS a dialect of all-English)

   is_dialect_of('fr-CA-joual', 'fr-CA')   is TRUE
   is_dialect_of('fr-CA-joual', 'fr')      is TRUE
     (Joual is a dialect of (a dialect of) French)

   is_dialect_of('en', 'en-US')            is FALSE
     (all-English is a NOT dialect of American English)

   is_dialect_of('fr', 'en-CA')            is FALSE

   is_dialect_of('en',    'en'   )         is TRUE
   is_dialect_of('en-US', 'en-US')         is TRUE
     (B<Note:> these are degenerate cases)

   is_dialect_of('i-mingo-tom', 'x-Mingo') is TRUE
     (the x/i thing doesn't matter, nor does case)

   is_dialect_of('nn', 'no')               is TRUE
     (because 'nn' (New Norse) is aliased to 'no-nyn',
      as a special legacy case, and 'no-nyn' is a
      subform of 'no' (Norwegian))

=cut

sub is_dialect_of {

  my $lang1 = &encode_language_tag($_[0]);
  my $lang2 = &encode_language_tag($_[1]);

  return undef if !defined($lang1) and !defined($lang2);
  return 0 if !defined($lang1) or !defined($lang2);

  return 1 if $lang1 eq $lang2;
  return 0 if length($lang1) < length($lang2);

  $lang1 .= '-';
  $lang2 .= '-';
  return
    (substr($lang1, 0, length($lang2)) eq $lang2) ? 1 : 0;
}

###########################################################################

=item * the function super_languages($lang1)

Returns a list of language tags that are superordinate tags to $lang1
-- it gets this by removing subtags from the end of $lang1 until
nothing (or just "i" or "x") is left.

   super_languages("fr-CA-joual")  is  ("fr-CA", "fr")

   super_languages("en-AU")  is  ("en")

   super_languages("en")  is  empty-list, ()

   super_languages("i-cherokee")  is  empty-list, ()
    ...not ("i"), which would be illegal as well as pointless.

If $lang1 is not a valid language tag, returns empty-list in
a list context, undef in a scalar context.

A notable and rather unavoidable problem with this method:
"x-mingo-tom" has an "x" because the whole tag isn't an
IANA-registered tag -- but super_languages('x-mingo-tom') is
('x-mingo') -- which isn't really right, since 'i-mingo' is
registered.  But this module has no way of knowing that.  (But note
that same_language_tag('x-mingo', 'i-mingo') is TRUE.)

More importantly, you assume I<at your peril> that superordinates of
$lang1 are mutually intelligible with $lang1.  Consider this
carefully.

=cut 

sub super_languages {
  my $lang1 = $_[0];
  return() unless defined($lang1) && &is_language_tag($lang1);

  # a hack for those annoying new (2001) tags:
  $lang1 =~ s/^nb\b/no-bok/i; # yes, backwards
  $lang1 =~ s/^nn\b/no-nyn/i; # yes, backwards
  $lang1 =~ s/^[ix](-hakka\b)/zh$1/i; # goes the right way
   # i-hakka-bork-bjork-bjark => zh-hakka-bork-bjork-bjark

  my @l1_subtags = split('-', $lang1);

  ## Changes in the language tagging standards may have to be reflected here.

  # NB: (i-sil-...)?

  my @supers = ();
  foreach my $bit (@l1_subtags) {
    push @supers, 
      scalar(@supers) ? ($supers[-1] . '-' . $bit) : $bit;
  }
  pop @supers if @supers;
  shift @supers if @supers && $supers[0] =~ m<^[iIxX]$>s;
  return reverse @supers;
}

###########################################################################

=item * the function locale2language_tag($locale_identifier)

This takes a locale name (like "en", "en_US", or "en_US.ISO8859-1")
and maps it to a language tag.  If it's not mappable (as with,
notably, "C" and "POSIX"), this returns empty-list in a list context,
or undef in a scalar context.

   locale2language_tag("en") is "en"

   locale2language_tag("en_US") is "en-US"

   locale2language_tag("en_US.ISO8859-1") is "en-US"

   locale2language_tag("C") is undef or ()

   locale2language_tag("POSIX") is undef or ()

   locale2language_tag("POSIX") is undef or ()

I'm not totally sure that locale names map satisfactorily to language
tags.  Think REAL hard about how you use this.  YOU HAVE BEEN WARNED.

The output is untainted.  If you don't know what tainting is,
don't worry about it.

=cut 

sub locale2language_tag {
  my $lang =
    $_[0] =~ m/(.+)/  # to make for an untainted result
    ? $1 : ''
  ;

  return $lang if &is_language_tag($lang); # like "en"

  $lang =~ tr<_><->;  # "en_US" -> en-US
  $lang =~ s<(?:[\.\@][-_a-zA-Z0-9]+)+$><>s;  # "en_US.ISO8859-1" -> en-US
   # it_IT.utf8@euro => it-IT

  return $lang if &is_language_tag($lang);

  return;
}

###########################################################################

=item * the function encode_language_tag($lang1)

This function, if given a language tag, returns an encoding of it such
that:

* tags representing different languages never get the same encoding.

* tags representing the same language always get the same encoding.

* an encoding of a formally valid language tag always is a string
value that is defined, has length, and is true if considered as a
boolean.

Note that the encoding itself is B<not> a formally valid language tag.
Note also that you cannot, currently, go from an encoding back to a
language tag that it's an encoding of.

Note also that you B<must> consider the encoded value as atomic; i.e.,
you should not consider it as anything but an opaque, unanalysable
string value.  (The internals of the encoding method may change in
future versions, as the language tagging standard changes over time.)

C<encode_language_tag> returns undef if given anything other than a
formally valid language tag.

The reason C<encode_language_tag> exists is because different language
tags may represent the same language; this is normally treatable with
C<same_language_tag>, but consider this situation:

You have a data file that expresses greetings in different languages.
Its format is "[language tag]=[how to say 'Hello']", like:

          en-US=Hiho
          fr=Bonjour
          i-mingo=Hau'

And suppose you write a program that reads that file and then runs as
a daemon, answering client requests that specify a language tag and
then expect the string that says how to greet in that language.  So an
interaction looks like:

          greeting-client asks:    fr
          greeting-server answers: Bonjour

So far so good.  But suppose the way you're implementing this is:

          my %greetings;
          die unless open(IN, "<in.dat");
          while(<IN>) {
            chomp;
            next unless /^([^=]+)=(.+)/s;
            my($lang, $expr) = ($1, $2);
            $greetings{$lang} = $expr;
          }
          close(IN);

at which point %greetings has the contents:

          "en-US"   => "Hiho"
          "fr"      => "Bonjour"
          "i-mingo" => "Hau'"

And suppose then that you answer client requests for language $wanted
by just looking up $greetings{$wanted}.

If the client asks for "fr", that will look up successfully in
%greetings, to the value "Bonjour".  And if the client asks for
"i-mingo", that will look up successfully in %greetings, to the value
"Hau'".

But if the client asks for "i-Mingo" or "x-mingo", or "Fr", then the
lookup in %greetings fails.  That's the Wrong Thing.

You could instead do lookups on $wanted with:

          use I18N::LangTags qw(same_language_tag);
          my $repsonse = '';
          foreach my $l2 (keys %greetings) {
            if(same_language_tag($wanted, $l2)) {
              $response = $greetings{$l2};
              last;
            }
          }

But that's rather inefficient.  A better way to do it is to start your
program with:

          use I18N::LangTags qw(encode_language_tag);
          my %greetings;
          die unless open(IN, "<in.dat");
          while(<IN>) {
            chomp;
            next unless /^([^=]+)=(.+)/s;
            my($lang, $expr) = ($1, $2);
            $greetings{
                        encode_language_tag($lang)
                      } = $expr;
          }
          close(IN);

and then just answer client requests for language $wanted by just
looking up

          $greetings{encode_language_tag($wanted)}

And that does the Right Thing.

=cut

sub encode_language_tag {
  # Only similarity_language_tag() is allowed to analyse encodings!

  ## Changes in the language tagging standards may have to be reflected here.

  my($tag) = $_[0] || return undef;
  return undef unless &is_language_tag($tag);

  # For the moment, these legacy variances are few enough that
  #  we can just handle them here with regexps.
  $tag =~ s/^iw\b/he/i; # Hebrew
  $tag =~ s/^in\b/id/i; # Indonesian
  $tag =~ s/^cre\b/cr/i; # Cree
  $tag =~ s/^jw\b/jv/i; # Javanese
  $tag =~ s/^[ix]-lux\b/lb/i;  # Luxemburger
  $tag =~ s/^[ix]-navajo\b/nv/i;  # Navajo
  $tag =~ s/^ji\b/yi/i;  # Yiddish
  # SMB 2003 -- Hm.  There's a bunch of new XXX->YY variances now,
  #  but maybe they're all so obscure I can ignore them.   "Obscure"
  #  meaning either that the language is obscure, and/or that the
  #  XXX form was extant so briefly that it's unlikely it was ever
  #  used.  I hope.
  #
  # These go FROM the simplex to complex form, to get
  #  similarity-comparison right.  And that's okay, since
  #  similarity_language_tag is the only thing that
  #  analyzes our output.
  $tag =~ s/^[ix]-hakka\b/zh-hakka/i;  # Hakka
  $tag =~ s/^nb\b/no-bok/i;  # BACKWARDS for Bokmal
  $tag =~ s/^nn\b/no-nyn/i;  # BACKWARDS for Nynorsk

  $tag =~ s/^[xiXI]-//s;
   # Just lop off any leading "x/i-"

  return "~" . uc($tag);
}

#--------------------------------------------------------------------------

=item * the function alternate_language_tags($lang1)

This function, if given a language tag, returns all language tags that
are alternate forms of this language tag.  (I.e., tags which refer to
the same language.)  This is meant to handle legacy tags caused by
the minor changes in language tag standards over the years; and
the x-/i- alternation is also dealt with.

Note that this function does I<not> try to equate new (and never-used,
and unusable)
ISO639-2 three-letter tags to old (and still in use) ISO639-1
two-letter equivalents -- like "ara" -> "ar" -- because
"ara" has I<never> been in use as an Internet language tag,
and RFC 3066 stipulates that it never should be, since a shorter
tag ("ar") exists.

Examples:

          alternate_language_tags('no-bok')       is ('nb')
          alternate_language_tags('nb')           is ('no-bok')
          alternate_language_tags('he')           is ('iw')
          alternate_language_tags('iw')           is ('he')
          alternate_language_tags('i-hakka')      is ('zh-hakka', 'x-hakka')
          alternate_language_tags('zh-hakka')     is ('i-hakka', 'x-hakka')
          alternate_language_tags('en')           is ()
          alternate_language_tags('x-mingo-tom')  is ('i-mingo-tom')
          alternate_language_tags('x-klikitat')   is ('i-klikitat')
          alternate_language_tags('i-klikitat')   is ('x-klikitat')

This function returns empty-list if given anything other than a formally
valid language tag.

=cut

my %alt = qw( i x   x i   I X   X I );
sub alternate_language_tags {
  my $tag = $_[0];
  return() unless &is_language_tag($tag);

  my @em; # push 'em real goood!

  # For the moment, these legacy variances are few enough that
  #  we can just handle them here with regexps.
  
  if(     $tag =~ m/^[ix]-hakka\b(.*)/i) {push @em, "zh-hakka$1";
  } elsif($tag =~ m/^zh-hakka\b(.*)/i) {  push @em, "x-hakka$1", "i-hakka$1";

  } elsif($tag =~ m/^he\b(.*)/i) { push @em, "iw$1";
  } elsif($tag =~ m/^iw\b(.*)/i) { push @em, "he$1";

  } elsif($tag =~ m/^in\b(.*)/i) { push @em, "id$1";
  } elsif($tag =~ m/^id\b(.*)/i) { push @em, "in$1";

  } elsif($tag =~ m/^[ix]-lux\b(.*)/i) { push @em, "lb$1";
  } elsif($tag =~ m/^lb\b(.*)/i) {       push @em, "i-lux$1", "x-lux$1";

  } elsif($tag =~ m/^[ix]-navajo\b(.*)/i) { push @em, "nv$1";
  } elsif($tag =~ m/^nv\b(.*)/i) {          push @em, "i-navajo$1", "x-navajo$1";

  } elsif($tag =~ m/^yi\b(.*)/i) { push @em, "ji$1";
  } elsif($tag =~ m/^ji\b(.*)/i) { push @em, "yi$1";

  } elsif($tag =~ m/^nb\b(.*)/i) {     push @em, "no-bok$1";
  } elsif($tag =~ m/^no-bok\b(.*)/i) { push @em, "nb$1";
  
  } elsif($tag =~ m/^nn\b(.*)/i) {     push @em, "no-nyn$1";
  } elsif($tag =~ m/^no-nyn\b(.*)/i) { push @em, "nn$1";
  }

  push @em, $alt{$1} . $2 if $tag =~ /^([XIxi])(-.+)/;
  return @em;
}

###########################################################################

{
  # Init %Panic...
  
  my @panic = (  # MUST all be lowercase!
   # Only large ("national") languages make it in this list.
   #  If you, as a user, are so bizarre that the /only/ language
   #  you claim to accept is Galician, then no, we won't do you
   #  the favor of providing Catalan as a panic-fallback for
   #  you.  Because if I start trying to add "little languages" in
   #  here, I'll just go crazy.

   # Scandinavian lgs.  All based on opinion and hearsay.
   'sv' => [qw(nb no da nn)],
   'da' => [qw(nb no sv nn)], # I guess
   [qw(no nn nb)], [qw(no nn nb sv da)],
   'is' => [qw(da sv no nb nn)],
   'fo' => [qw(da is no nb nn sv)], # I guess
   
   # I think this is about the extent of tolerable intelligibility
   #  among large modern Romance languages.
   'pt' => [qw(es ca it fr)], # Portuguese, Spanish, Catalan, Italian, French
   'ca' => [qw(es pt it fr)],
   'es' => [qw(ca it fr pt)],
   'it' => [qw(es fr ca pt)],
   'fr' => [qw(es it ca pt)],
   
   # Also assume that speakers of the main Indian languages prefer
   #  to read/hear Hindi over English
   [qw(
     as bn gu kn ks kok ml mni mr ne or pa sa sd te ta ur
   )] => 'hi',
    # Assamese, Bengali, Gujarati, [Hindi,] Kannada (Kanarese), Kashmiri,
    # Konkani, Malayalam, Meithei (Manipuri), Marathi, Nepali, Oriya,
    # Punjabi, Sanskrit, Sindhi, Telugu, Tamil, and Urdu.
   'hi' => [qw(bn pa as or)],
   # I welcome finer data for the other Indian languages.
   #  E.g., what should Oriya's list be, besides just Hindi?
   
   # And the panic languages for English is, of course, nil!

   # My guesses at Slavic intelligibility:
   ([qw(ru be uk)]) x 2,  # Russian, Belarusian, Ukranian
   'sr' => 'hr', 'hr' => 'sr', # Serb + Croat
   'cs' => 'sk', 'sk' => 'cs', # Czech + Slovak

   'ms' => 'id', 'id' => 'ms', # Malay + Indonesian

   'et' => 'fi', 'fi' => 'et', # Estonian + Finnish

   #?? 'lo' => 'th', 'th' => 'lo', # Lao + Thai

  );
  my($k,$v);
  while(@panic) {
    ($k,$v) = splice(@panic,0,2);
    foreach my $k (ref($k) ? @$k : $k) {
      foreach my $v (ref($v) ? @$v : $v) {
        push @{$Panic{$k} ||= []}, $v unless $k eq $v;
      }
    }
  }
}

=item * the function @langs = panic_languages(@accept_languages)

This function takes a list of 0 or more language
tags that constitute a given user's Accept-Language list, and
returns a list of tags for I<other> (non-super)
languages that are probably acceptable to the user, to be
used I<if all else fails>.

For example, if a user accepts only 'ca' (Catalan) and
'es' (Spanish), and the documents/interfaces you have
available are just in German, Italian, and Chinese, then
the user will most likely want the Italian one (and not
the Chinese or German one!), instead of getting
nothing.  So C<panic_languages('ca', 'es')> returns
a list containing 'it' (Italian).

English ('en') is I<always> in the return list, but
whether it's at the very end or not depends
on the input languages.  This function works by consulting
an internal table that stipulates what common
languages are "close" to each other.

A useful construct you might consider using is:

  @fallbacks = super_languages(@accept_languages);
  push @fallbacks, panic_languages(
    @accept_languages, @fallbacks,
  );

=cut

sub panic_languages {
  # When in panic or in doubt, run in circles, scream, and shout!
  my(@out, %seen);
  foreach my $t (@_) {
    next unless $t;
    next if $seen{$t}++; # so we don't return it or hit it again
    # push @out, super_languages($t); # nah, keep that separate
    push @out, @{ $Panic{lc $t} || next };
  }
  return grep !$seen{$_}++,  @out, 'en';
}

#---------------------------------------------------------------------------
#---------------------------------------------------------------------------

=item * the function implicate_supers( ...languages... )

This takes a list of strings (which are presumed to be language-tags;
strings that aren't, are ignored); and after each one, this function
inserts super-ordinate forms that don't already appear in the list.
The original list, plus these insertions, is returned.

In other words, it takes this:

  pt-br de-DE en-US fr pt-br-janeiro

and returns this:

  pt-br pt de-DE de en-US en fr pt-br-janeiro

This function is most useful in the idiom

  implicate_supers( I18N::LangTags::Detect::detect() );

(See L<I18N::LangTags::Detect>.)


=item * the function implicate_supers_strictly( ...languages... )

This works like C<implicate_supers> except that the implicated
forms are added to the end of the return list.

In other words, implicate_supers_strictly takes a list of strings
(which are presumed to be language-tags; strings that aren't, are
ignored) and after the whole given list, it inserts the super-ordinate forms 
of all given tags, minus any tags that already appear in the input list.

In other words, it takes this:

  pt-br de-DE en-US fr pt-br-janeiro

and returns this:

  pt-br de-DE en-US fr pt-br-janeiro pt de en

The reason this function has "_strictly" in its name is that when
you're processing an Accept-Language list according to the RFCs, if
you interpret the RFCs quite strictly, then you would use
implicate_supers_strictly, but for normal use (i.e., common-sense use,
as far as I'm concerned) you'd use implicate_supers.

=cut

sub implicate_supers {
  my @languages = grep is_language_tag($_), @_;
  my %seen_encoded;
  foreach my $lang (@languages) {
    $seen_encoded{ I18N::LangTags::encode_language_tag($lang) } = 1
  }

  my(@output_languages);
  foreach my $lang (@languages) {
    push @output_languages, $lang;
    foreach my $s ( I18N::LangTags::super_languages($lang) ) {
      # Note that super_languages returns the longest first.
      last if $seen_encoded{ I18N::LangTags::encode_language_tag($s) };
      push @output_languages, $s;
    }
  }
  return uniq( @output_languages );

}

sub implicate_supers_strictly {
  my @tags = grep is_language_tag($_), @_;
  return uniq( @_,   map super_languages($_), @_ );
}



###########################################################################
1;
__END__

=back

=head1 ABOUT LOWERCASING

I've considered making all the above functions that output language
tags return all those tags strictly in lowercase.  Having all your
language tags in lowercase does make some things easier.  But you
might as well just lowercase as you like, or call
C<encode_language_tag($lang1)> where appropriate.

=head1 ABOUT UNICODE PLAINTEXT LANGUAGE TAGS

In some future version of I18N::LangTags, I plan to include support
for RFC2482-style language tags -- which are basically just normal
language tags with their ASCII characters shifted into Plane 14.

=head1 SEE ALSO

* L<I18N::LangTags::List|I18N::LangTags::List>

* RFC 3066, C<ftp://ftp.isi.edu/in-notes/rfc3066.txt>, "Tags for the
Identification of Languages".  (Obsoletes RFC 1766)

* RFC 2277, C<ftp://ftp.isi.edu/in-notes/rfc2277.txt>, "IETF Policy on
Character Sets and Languages".

* RFC 2231, C<ftp://ftp.isi.edu/in-notes/rfc2231.txt>, "MIME Parameter
Value and Encoded Word Extensions: Character Sets, Languages, and
Continuations".

* RFC 2482, C<ftp://ftp.isi.edu/in-notes/rfc2482.txt>, 
"Language Tagging in Unicode Plain Text".

* Locale::Codes, in
C<http://www.perl.com/CPAN/modules/by-module/Locale/>

* ISO 639-2, "Codes for the representation of names of languages",
including two-letter and three-letter codes,
C<http://www.loc.gov/standards/iso639-2/langcodes.html>

* The IANA list of registered languages (hopefully up-to-date),
C<http://www.iana.org/assignments/language-tags>

=head1 COPYRIGHT

Copyright (c) 1998+ Sean M. Burke. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

The programs and documentation in this dist are distributed in
the hope that they will be useful, but without any warranty; without
even the implied warranty of merchantability or fitness for a
particular purpose.

=head1 AUTHOR

Sean M. Burke C<sburke@cpan.org>

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             package sigtrap;

=head1 NAME

sigtrap - Perl pragma to enable simple signal handling

=cut

use Carp;

$VERSION = 1.02;
$Verbose ||= 0;

sub import {
    my $pkg = shift;
    my $handler = \&handler_traceback;
    my $saw_sig = 0;
    my $untrapped = 0;
    local $_;

  Arg_loop:
    while (@_) {
	$_ = shift;
	if (/^[A-Z][A-Z0-9]*$/) {
	    $saw_sig++;
	    unless ($untrapped and $SIG{$_} and $SIG{$_} ne 'DEFAULT') {
		print "Installing handler $handler for $_\n" if $Verbose;
		$SIG{$_} = $handler;
	    }
	}
	elsif ($_ eq 'normal-signals') {
	    unshift @_, grep(exists $SIG{$_}, qw(HUP INT PIPE TERM));
	}
	elsif ($_ eq 'error-signals') {
	    unshift @_, grep(exists $SIG{$_},
			     qw(ABRT BUS EMT FPE ILL QUIT SEGV SYS TRAP));
	}
	elsif ($_ eq 'old-interface-signals') {
	    unshift @_,
	    grep(exists $SIG{$_},
		 qw(ABRT BUS EMT FPE ILL PIPE QUIT SEGV SYS TERM TRAP));
	}
    	elsif ($_ eq 'stack-trace') {
	    $handler = \&handler_traceback;
	}
	elsif ($_ eq 'die') {
	    $handler = \&handler_die;
	}
	elsif ($_ eq 'handler') {
	    @_ or croak "No argument specified after 'handler'";
	    $handler = shift;
	    unless (ref $handler or $handler eq 'IGNORE'
			or $handler eq 'DEFAULT') {
    	    	require Symbol;
		$handler = Symbol::qualify($handler, (caller)[0]);
	    }
	}
	elsif ($_ eq 'untrapped') {
	    $untrapped = 1;
	}
	elsif ($_ eq 'any') {
	    $untrapped = 0;
	}
	elsif ($_ =~ /^\d/) {
	    $VERSION >= $_ or croak "sigtrap.pm version $_ required,"
		    	    	    	. " but this is only version $VERSION";
	}
	else {
	    croak "Unrecognized argument $_";
	}
    }
    unless ($saw_sig) {
	@_ = qw(old-interface-signals);
	goto Arg_loop;
    }
}

sub handler_die {
    croak "Caught a SIG$_[0]";
}

sub handler_traceback {
    package DB;		# To get subroutine args.
    $SIG{'ABRT'} = DEFAULT;
    kill 'ABRT', $$ if $panic++;
    syswrite(STDERR, 'Caught a SIG', 12);
    syswrite(STDERR, $_[0], length($_[0]));
    syswrite(STDERR, ' at ', 4);
    ($pack,$file,$line) = caller;
    syswrite(STDERR, $file, length($file));
    syswrite(STDERR, ' line ', 6);
    syswrite(STDERR, $line, length($line));
    syswrite(STDERR, "\n", 1);

    # Now go for broke.
    for ($i = 1; ($p,$f,$l,$s,$h,$w,$e,$r) = caller($i); $i++) {
        @a = ();
	for $arg (@args) {
	    $_ = "$arg";
	    s/([\'\\])/\\$1/g;
	    s/([^\0]*)/'$1'/
	      unless /^(?: -?[\d.]+ | \*[\w:]* )$/x;
	    s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
	    s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
	    push(@a, $_);
	}
	$w = $w ? '@ = ' : '$ = ';
	$a = $h ? '(' . join(', ', @a) . ')' : '';
	$e =~ s/\n\s*\;\s*\Z// if $e;
	$e =~ s/[\\\']/\\$1/g if $e;
	if ($r) {
	    $s = "require '$e'";
	} elsif (defined $r) {
	    $s = "eval '$e'";
	} elsif ($s eq '(eval)') {
	    $s = "eval {...}";
	}
	$f = "file `$f'" unless $f eq '-e';
	$mess = "$w$s$a called from $f line $l\n";
	syswrite(STDERR, $mess, length($mess));
    }
    kill 'ABRT', $$;
}

1;

__END__

=head1 SYNOPSIS

    use sigtrap;
    use sigtrap qw(stack-trace old-interface-signals);	# equivalent
    use sigtrap qw(BUS SEGV PIPE ABRT);
    use sigtrap qw(die INT QUIT);
    use sigtrap qw(die normal-signals);
    use sigtrap qw(die untrapped normal-signals);
    use sigtrap qw(die untrapped normal-signals
		    stack-trace any error-signals);
    use sigtrap 'handler' => \&my_handler, 'normal-signals';
    use sigtrap qw(handler my_handler normal-signals
    	    	    stack-trace error-signals);

=head1 DESCRIPTION

The B<sigtrap> pragma is a simple interface to installing signal
handlers.  You can have it install one of two handlers supplied by
B<sigtrap> itself (one which provides a Perl stack trace and one which
simply C<die()>s), or alternately you can supply your own handler for it
to install.  It can be told only to install a handler for signals which
are either untrapped or ignored.  It has a couple of lists of signals to
trap, plus you can supply your own list of signals.

The arguments passed to the C<use> statement which invokes B<sigtrap>
are processed in order.  When a signal name or the name of one of
B<sigtrap>'s signal lists is encountered a handler is immediately
installed, when an option is encountered it affects subsequently
installed handlers.

=head1 OPTIONS

=head2 SIGNAL HANDLERS

These options affect which handler will be used for subsequently
installed signals.

=over 4

=item B<stack-trace>

The handler used for subsequently installed signals outputs a Perl stack
trace to STDERR and then tries to dump core.  This is the default signal
handler.

=item B<die>

The handler used for subsequently installed signals calls C<die>
(actually C<croak>) with a message indicating which signal was caught.

=item B<handler> I<your-handler>

I<your-handler> will be used as the handler for subsequently installed
signals.  I<your-handler> can be any value which is valid as an
assignment to an element of C<%SIG>.

=back

=head2 SIGNAL LISTS

B<sigtrap> has a few built-in lists of signals to trap.  They are:

=over 4

=item B<normal-signals>

These are the signals which a program might normally expect to encounter
and which by default cause it to terminate.  They are HUP, INT, PIPE and
TERM.

=item B<error-signals>

These signals usually indicate a serious problem with the Perl
interpreter or with your script.  They are ABRT, BUS, EMT, FPE, ILL,
QUIT, SEGV, SYS and TRAP.

=item B<old-interface-signals>

These are the signals which were trapped by default by the old
B<sigtrap> interface, they are ABRT, BUS, EMT, FPE, ILL, PIPE, QUIT,
SEGV, SYS, TERM, and TRAP.  If no signals or signals lists are passed to
B<sigtrap>, this list is used.

=back

For each of these three lists, the collection of signals set to be
trapped is checked before trapping; if your architecture does not
implement a particular signal, it will not be trapped but rather
silently ignored.

=head2 OTHER

=over 4

=item B<untrapped>

This token tells B<sigtrap> to install handlers only for subsequently
listed signals which aren't already trapped or ignored.

=item B<any>

This token tells B<sigtrap> to install handlers for all subsequently
listed signals.  This is the default behavior.

=item I<signal>

Any argument which looks like a signal name (that is,
C</^[A-Z][A-Z0-9]*$/>) indicates that B<sigtrap> should install a
handler for that name.

=item I<number>

Require that at least version I<number> of B<sigtrap> is being used.

=back

=head1 EXAMPLES

Provide a stack trace for the old-interface-signals:

    use sigtrap;

Ditto:

    use sigtrap qw(stack-trace old-interface-signals);

Provide a stack trace on the 4 listed signals only:

    use sigtrap qw(BUS SEGV PIPE ABRT);

Die on INT or QUIT:

    use sigtrap qw(die INT QUIT);

Die on HUP, INT, PIPE or TERM:

    use sigtrap qw(die normal-signals);

Die on HUP, INT, PIPE or TERM, except don't change the behavior for
signals which are already trapped or ignored:

    use sigtrap qw(die untrapped normal-signals);

Die on receipt one of an of the B<normal-signals> which is currently
B<untrapped>, provide a stack trace on receipt of B<any> of the
B<error-signals>:

    use sigtrap qw(die untrapped normal-signals
		    stack-trace any error-signals);

Install my_handler() as the handler for the B<normal-signals>:

    use sigtrap 'handler', \&my_handler, 'normal-signals';

Install my_handler() as the handler for the normal-signals, provide a
Perl stack trace on receipt of one of the error-signals:

    use sigtrap qw(handler my_handler normal-signals
    	    	    stack-trace error-signals);

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                package Digest;

use strict;
use vars qw($VERSION %MMAP $AUTOLOAD);

$VERSION = "1.14";

%MMAP = (
  "SHA-1"      => ["Digest::SHA1", ["Digest::SHA", 1], ["Digest::SHA2", 1]],
  "SHA-224"    => [["Digest::SHA", 224]],
  "SHA-256"    => [["Digest::SHA", 256], ["Digest::SHA2", 256]],
  "SHA-384"    => [["Digest::SHA", 384], ["Digest::SHA2", 384]],
  "SHA-512"    => [["Digest::SHA", 512], ["Digest::SHA2", 512]],
  "HMAC-MD5"   => "Digest::HMAC_MD5",
  "HMAC-SHA-1" => "Digest::HMAC_SHA1",
  "CRC-16"     => [["Digest::CRC", type => "crc16"]],
  "CRC-32"     => [["Digest::CRC", type => "crc32"]],
  "CRC-CCITT"  => [["Digest::CRC", type => "crcccitt"]],
);

sub new
{
    shift;  # class ignored
    my $algorithm = shift;
    my $impl = $MMAP{$algorithm} || do {
	$algorithm =~ s/\W+//;
	"Digest::$algorithm";
    };
    $impl = [$impl] unless ref($impl);
    my $err;
    for  (@$impl) {
	my $class = $_;
	my @args;
	($class, @args) = @$class if ref($class);
	no strict 'refs';
	unless (exists ${"$class\::"}{"VERSION"}) {
	    eval "require $class";
	    if ($@) {
		$err ||= $@;
		next;
	    }
	}
	return $class->new(@args, @_);
    }
    die $err;
}

sub AUTOLOAD
{
    my $class = shift;
    my $algorithm = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
    $class->new($algorithm, @_);
}

1;

__END__

=head1 NAME

Digest - Modules that calculate message digests

=head1 SYNOPSIS

  $md5  = Digest->new("MD5");
  $sha1 = Digest->new("SHA-1");
  $sha256 = Digest->new("SHA-256");
  $sha384 = Digest->new("SHA-384");
  $sha512 = Digest->new("SHA-512");

  $hmac = Digest->HMAC_MD5($key);

=head1 DESCRIPTION

The C<Digest::> modules calculate digests, also called "fingerprints"
or "hashes", of some data, called a message.  The digest is (usually)
some small/fixed size string.  The actual size of the digest depend of
the algorithm used.  The message is simply a sequence of arbitrary
bytes or bits.

An important property of the digest algorithms is that the digest is
I<likely> to change if the message change in some way.  Another
property is that digest functions are one-way functions, that is it
should be I<hard> to find a message that correspond to some given
digest.  Algorithms differ in how "likely" and how "hard", as well as
how efficient they are to compute.

Note that the properties of the algorithms change over time, as the
algorithms are analyzed and machines grow faster.  If your application
for instance depends on it being "impossible" to generate the same
digest for a different message it is wise to make it easy to plug in
stronger algorithms as the one used grow weaker.  Using the interface
documented here should make it easy to change algorithms later.

All C<Digest::> modules provide the same programming interface.  A
functional interface for simple use, as well as an object oriented
interface that can handle messages of arbitrary length and which can
read files directly.

The digest can be delivered in three formats:

=over 8

=item I<binary>

This is the most compact form, but it is not well suited for printing
or embedding in places that can't handle arbitrary data.

=item I<hex>

A twice as long string of lowercase hexadecimal digits.

=item I<base64>

A string of portable printable characters.  This is the base64 encoded
representation of the digest with any trailing padding removed.  The
string will be about 30% longer than the binary version.
L<MIME::Base64> tells you more about this encoding.

=back


The functional interface is simply importable functions with the same
name as the algorithm.  The functions take the message as argument and
return the digest.  Example:

  use Digest::MD5 qw(md5);
  $digest = md5($message);

There are also versions of the functions with "_hex" or "_base64"
appended to the name, which returns the digest in the indicated form.

=head1 OO INTERFACE

The following methods are available for all C<Digest::> modules:

=over 4

=item $ctx = Digest->XXX($arg,...)

=item $ctx = Digest->new(XXX => $arg,...)

=item $ctx = Digest::XXX->new($arg,...)

The constructor returns some object that encapsulate the state of the
message-digest algorithm.  You can add data to the object and finally
ask for the digest.  The "XXX" should of course be replaced by the proper
name of the digest algorithm you want to use.

The two first forms are simply syntactic sugar which automatically
load the right module on first use.  The second form allow you to use
algorithm names which contains letters which are not legal perl
identifiers, e.g. "SHA-1".  If no implementation for the given algorithm
can be found, then an exception is raised.

If new() is called as an instance method (i.e. $ctx->new) it will just
reset the state the object to the state of a newly created object.  No
new object is created in this case, and the return value is the
reference to the object (i.e. $ctx).

=item $other_ctx = $ctx->clone

The clone method creates a copy of the digest state object and returns
a reference to the copy.

=item $ctx->reset

This is just an alias for $ctx->new.

=item $ctx->add( $data, ... )

The $data provided as argument are appended to the message we
calculate the digest for.  The return value is the $ctx object itself.

=item $ctx->addfile( $io_handle )

The $io_handle is read until EOF and the content is appended to the
message we calculate the digest for.  The return value is the $ctx
object itself.

=item $ctx->add_bits( $data, $nbits )

=item $ctx->add_bits( $bitstring )

The bits provided are appended to the message we calculate the digest
for.  The return value is the $ctx object itself.

The two argument form of add_bits() will add the first $nbits bits
from data.  For the last potentially partial byte only the high order
C<< $nbits % 8 >> bits are used.  If $nbits is greater than C<<
length($data) * 8 >>, then this method would do the same as C<<
$ctx->add($data) >>, that is $nbits is silently ignored.

The one argument form of add_bits() takes a $bitstring of "1" and "0"
chars as argument.  It's a shorthand for C<< $ctx->add_bits(pack("B*",
$bitstring), length($bitstring)) >>.

This example shows two calls that should have the same effect:

   $ctx->add_bits("111100001010");
   $ctx->add_bits("\xF0\xA0", 12);

Most digest algorithms are byte based.  For those it is not possible
to add bits that are not a multiple of 8, and the add_bits() method
will croak if you try.

=item $ctx->digest

Return the binary digest for the message.

Note that the C<digest> operation is effectively a destructive,
read-once operation. Once it has been performed, the $ctx object is
automatically C<reset> and can be used to calculate another digest
value.  Call $ctx->clone->digest if you want to calculate the digest
without reseting the digest state.

=item $ctx->hexdigest

Same as $ctx->digest, but will return the digest in hexadecimal form.

=item $ctx->b64digest

Same as $ctx->digest, but will return the digest as a base64 encoded
string.

=back

=head1 Digest speed

This table should give some indication on the relative speed of
different algorithms.  It is sorted by throughput based on a benchmark
done with of some implementations of this API:

 Algorithm      Size    Implementation                  MB/s

 MD4            128     Digest::MD4 v1.3               165.0
 MD5            128     Digest::MD5 v2.33               98.8
 SHA-256        256     Digest::SHA2 v1.1.0             66.7
 SHA-1          160     Digest::SHA v4.3.1              58.9
 SHA-1          160     Digest::SHA1 v2.10              48.8
 SHA-256        256     Digest::SHA v4.3.1              41.3
 Haval-256      256     Digest::Haval256 v1.0.4         39.8
 SHA-384        384     Digest::SHA2 v1.1.0             19.6
 SHA-512        512     Digest::SHA2 v1.1.0             19.3
 SHA-384        384     Digest::SHA v4.3.1              19.2
 SHA-512        512     Digest::SHA v4.3.1              19.2
 Whirlpool      512     Digest::Whirlpool v1.0.2        13.0
 MD2            128     Digest::MD2 v2.03                9.5

 Adler-32        32     Digest::Adler32 v0.03            1.3
 CRC-16          16     Digest::CRC v0.05                1.1
 CRC-32          32     Digest::CRC v0.05                1.1
 MD5            128     Digest::Perl::MD5 v1.5           1.0
 CRC-CCITT       16     Digest::CRC v0.05                0.8

These numbers was achieved Apr 2004 with ActivePerl-5.8.3 running
under Linux on a P4 2.8 GHz CPU.  The last 5 entries differ by being
pure perl implementations of the algorithms, which explains why they
are so slow.

=head1 SEE ALSO

L<Digest::Adler32>, L<Digest::CRC>, L<Digest::Haval256>,
L<Digest::HMAC>, L<Digest::MD2>, L<Digest::MD4>, L<Digest::MD5>,
L<Digest::SHA>, L<Digest::SHA1>, L<Digest::SHA2>, L<Digest::Whirlpool>

New digest implementations should consider subclassing from L<Digest::base>.

L<MIME::Base64>

=head1 AUTHOR

Gisle Aas <gisle@aas.no>

The C<Digest::> interface is based on the interface originally
developed by Neil Winton for his C<MD5> module.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

    Copyright 1998-2001,2003-2004 Gisle Aas.
    Copyright 1995-1996 Neil Winton.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ;# getopts.pl - a better getopt.pl
#
# This library is no longer being maintained, and is included for backward
# compatibility with Perl 4 programs which may require it.
#
# In particular, this should not be used as an example of modern Perl
# programming techniques.
#
# Suggested alternatives: Getopt::Long  or  Getopt::Std
#
;# Usage:
;#      do Getopts('a:bc');  # -a takes arg. -b & -c not. Sets opt_* as a
;#                           #  side effect.

sub Getopts {
    local($argumentative) = @_;
    local(@args,$_,$first,$rest);
    local($errs) = 0;
    local($[) = 0;

    @args = split( / */, $argumentative );
    while(@ARGV && ($_ = $ARGV[0]) =~ /^-(.)(.*)/) {
		($first,$rest) = ($1,$2);
		$pos = index($argumentative,$first);
		if($pos >= $[) {
			if($args[$pos+1] eq ':') {
				shift(@ARGV);
				if($rest eq '') {
					++$errs unless(@ARGV);
					$rest = shift(@ARGV);
				}
				eval "
				push(\@opt_$first, \$rest);
				if (!defined \$opt_$first or \$opt_$first eq '') {
					\$opt_$first = \$rest;
				}
				else {
					\$opt_$first .= ' ' . \$rest;
				}
				";
			}
			else {
				eval "\$opt_$first = 1";
				if($rest eq '') {
					shift(@ARGV);
				}
				else {
					$ARGV[0] = "-$rest";
				}
			}
		}
		else {
			print STDERR "Unknown option: $first\n";
			++$errs;
			if($rest ne '') {
				$ARGV[0] = "-$rest";
			}
			else {
				shift(@ARGV);
			}
		}
	}
    $errs == 0;
}

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  E  .   B  ..  E POSIX                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           E  .   E  ..  E 	SigAction                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       E  .   E  ..  E  safe.al E  
handler.al  E  mask.al E flags.al                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # NOTE: Derived from ../../lib/POSIX.pm.
# Changes made here will be lost when autosplit is run again.
# See AutoSplit.pm.
package POSIX::SigAction;

#line 965 "../../lib/POSIX.pm (autosplit into ../../lib/auto/POSIX/SigAction/safe.al)"
sub safe    { $_[0]->{SAFE}    = $_[1] if @_ > 1; $_[0]->{SAFE} };
1;
# end of POSIX::SigAction::safe
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             # NOTE: Derived from ../../lib/POSIX.pm.
# Changes made here will be lost when autosplit is run again.
# See AutoSplit.pm.
package POSIX::SigAction;

#line 960 "../../lib/POSIX.pm (autosplit into ../../lib/auto/POSIX/SigAction/handler.al)"
package POSIX::SigAction;

sub handler { $_[0]->{HANDLER} = $_[1] if @_ > 1; $_[0]->{HANDLER} };
# end of POSIX::SigAction::handler
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         # NOTE: Derived from ../../lib/POSIX.pm.
# Changes made here will be lost when autosplit is run again.
# See AutoSplit.pm.
package POSIX::SigAction;

#line 963 "../../lib/POSIX.pm (autosplit into ../../lib/auto/POSIX/SigAction/mask.al)"
sub mask    { $_[0]->{MASK}    = $_[1] if @_ > 1; $_[0]->{MASK} };
# end of POSIX::SigAction::mask
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             # NOTE: Derived from ../../lib/POSIX.pm.
# Changes made here will be lost when autosplit is run again.
# See AutoSplit.pm.
package POSIX::SigAction;

#line 964 "../../lib/POSIX.pm (autosplit into ../../lib/auto/POSIX/SigAction/flags.al)"
sub flags   { $_[0]->{FLAGS}   = $_[1] if @_ > 1; $_[0]->{FLAGS} };
# end of POSIX::SigAction::flags
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ;# timelocal.pl
;#
;# Usage:
;#	$time = timelocal($sec,$min,$hours,$mday,$mon,$year);
;#	$time = timegm($sec,$min,$hours,$mday,$mon,$year);

;# This file has been superseded by the Time::Local library module.
;# It is implemented as a call to that module for backwards compatibility
;# with code written for perl4; new code should use Time::Local directly.

;# The current implementation shares with the original the questionable
;# behavior of defining the timelocal() and timegm() functions in the
;# namespace of whatever package was current when the first instance of
;# C<require 'timelocal.pl';> was executed in a program.

use Time::Local;

*timelocal::cheat = \&Time::Local::cheat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               E  .   B  ..  !E  Util.pm "E Util                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # Scalar::Util.pm
#
# Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.

package Scalar::Util;

use strict;
use vars qw(@ISA @EXPORT_OK $VERSION @EXPORT_FAIL);
require Exporter;
require List::Util; # List::Util loads the XS

@ISA       = qw(Exporter);
@EXPORT_OK = qw(blessed dualvar reftype weaken isweak tainted readonly openhandle refaddr isvstring looks_like_number set_prototype);
$VERSION    = "1.21";
$VERSION   = eval $VERSION;

unless (defined &dualvar) {
  # Load Pure Perl version if XS not loaded
  require Scalar::Util::PP;
  Scalar::Util::PP->import;
  push @EXPORT_FAIL, qw(weaken isweak dualvar isvstring set_prototype);
}

sub export_fail {
  if (grep { /dualvar/ } @EXPORT_FAIL) { # no XS loaded
    my $pat = join("|", @EXPORT_FAIL);
    if (my ($err) = grep { /^($pat)$/ } @_ ) {
      require Carp;
      Carp::croak("$err is only available with the XS version of Scalar::Util");
    }
  }

  if (grep { /^(weaken|isweak)$/ } @_ ) {
    require Carp;
    Carp::croak("Weak references are not implemented in the version of perl");
  }

  if (grep { /^(isvstring)$/ } @_ ) {
    require Carp;
    Carp::croak("Vstrings are not implemented in the version of perl");
  }

  @_;
}

sub openhandle ($) {
  my $fh = shift;
  my $rt = reftype($fh) || '';

  return defined(fileno($fh)) ? $fh : undef
    if $rt eq 'IO';

  if (reftype(\$fh) eq 'GLOB') { # handle  openhandle(*DATA)
    $fh = \(my $tmp=$fh);
  }
  elsif ($rt ne 'GLOB') {
    return undef;
  }

  (tied(*$fh) or defined(fileno($fh)))
    ? $fh : undef;
}

1;

__END__

=head1 NAME

Scalar::Util - A selection of general-utility scalar subroutines

=head1 SYNOPSIS

    use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
                        weaken isvstring looks_like_number set_prototype);
                        # and other useful utils appearing below

=head1 DESCRIPTION

C<Scalar::Util> contains a selection of subroutines that people have
expressed would be nice to have in the perl core, but the usage would
not really be high enough to warrant the use of a keyword, and the size
so small such that being individual extensions would be wasteful.

By default C<Scalar::Util> does not export any subroutines. The
subroutines defined are

=over 4

=item blessed EXPR

If EXPR evaluates to a blessed reference the name of the package
that it is blessed into is returned. Otherwise C<undef> is returned.

   $scalar = "foo";
   $class  = blessed $scalar;           # undef

   $ref    = [];
   $class  = blessed $ref;              # undef

   $obj    = bless [], "Foo";
   $class  = blessed $obj;              # "Foo"

=item dualvar NUM, STRING

Returns a scalar that has the value NUM in a numeric context and the
value STRING in a string context.

    $foo = dualvar 10, "Hello";
    $num = $foo + 2;                    # 12
    $str = $foo . " world";             # Hello world

=item isvstring EXPR

If EXPR is a scalar which was coded as a vstring the result is true.

    $vs   = v49.46.48;
    $fmt  = isvstring($vs) ? "%vd" : "%s"; #true
    printf($fmt,$vs);

=item isweak EXPR

If EXPR is a scalar which is a weak reference the result is true.

    $ref  = \$foo;
    $weak = isweak($ref);               # false
    weaken($ref);
    $weak = isweak($ref);               # true

B<NOTE>: Copying a weak reference creates a normal, strong, reference.

    $copy = $ref;
    $weak = isweak($copy);              # false

=item looks_like_number EXPR

Returns true if perl thinks EXPR is a number. See
L<perlapi/looks_like_number>.

=item openhandle FH

Returns FH if FH may be used as a filehandle and is open, or FH is a tied
handle. Otherwise C<undef> is returned.

    $fh = openhandle(*STDIN);		# \*STDIN
    $fh = openhandle(\*STDIN);		# \*STDIN
    $fh = openhandle(*NOTOPEN);		# undef
    $fh = openhandle("scalar");		# undef
    
=item readonly SCALAR

Returns true if SCALAR is readonly.

    sub foo { readonly($_[0]) }

    $readonly = foo($bar);              # false
    $readonly = foo(0);                 # true

=item refaddr EXPR

If EXPR evaluates to a reference the internal memory address of
the referenced value is returned. Otherwise C<undef> is returned.

    $addr = refaddr "string";           # undef
    $addr = refaddr \$var;              # eg 12345678
    $addr = refaddr [];                 # eg 23456784

    $obj  = bless {}, "Foo";
    $addr = refaddr $obj;               # eg 88123488

=item reftype EXPR

If EXPR evaluates to a reference the type of the variable referenced
is returned. Otherwise C<undef> is returned.

    $type = reftype "string";           # undef
    $type = reftype \$var;              # SCALAR
    $type = reftype [];                 # ARRAY

    $obj  = bless {}, "Foo";
    $type = reftype $obj;               # HASH

=item set_prototype CODEREF, PROTOTYPE

Sets the prototype of the given function, or deletes it if PROTOTYPE is
undef. Returns the CODEREF.

    set_prototype \&foo, '$$';

=item tainted EXPR

Return true if the result of EXPR is tainted

    $taint = tainted("constant");       # false
    $taint = tainted($ENV{PWD});        # true if running under -T

=item weaken REF

REF will be turned into a weak reference. This means that it will not
hold a reference count on the object it references. Also when the reference
count on that object reaches zero, REF will be set to undef.

This is useful for keeping copies of references , but you don't want to
prevent the object being DESTROY-ed at its usual time.

    {
      my $var;
      $ref = \$var;
      weaken($ref);                     # Make $ref a weak reference
    }
    # $ref is now undef

Note that if you take a copy of a scalar with a weakened reference,
the copy will be a strong reference.

    my $var;
    my $foo = \$var;
    weaken($foo);                       # Make $foo a weak reference
    my $bar = $foo;                     # $bar is now a strong reference

This may be less obvious in other situations, such as C<grep()>, for instance
when grepping through a list of weakened references to objects that may have
been destroyed already:

    @object = grep { defined } @object;

This will indeed remove all references to destroyed objects, but the remaining
references to objects will be strong, causing the remaining objects to never
be destroyed because there is now always a strong reference to them in the
@object array.

=back

=head1 DIAGNOSTICS

Module use may give one of the following errors during import.

=over

=item Weak references are not implemented in the version of perl

The version of perl that you are using does not implement weak references, to use
C<isweak> or C<weaken> you will need to use a newer release of perl.

=item Vstrings are not implemented in the version of perl

The version of perl that you are using does not implement Vstrings, to use
C<isvstring> you will need to use a newer release of perl.

=item C<NAME> is only available with the XS version of Scalar::Util

C<Scalar::Util> contains both perl and C implementations of many of its functions
so that those without access to a C compiler may still use it. However some of the functions
are only available when a C compiler was available to compile the XS version of the extension.

At present that list is: weaken, isweak, dualvar, isvstring, set_prototype

=back

=head1 KNOWN BUGS

There is a bug in perl5.6.0 with UV's that are >= 1<<31. This will
show up as tests 8 and 9 of dualvar.t failing

=head1 SEE ALSO

L<List::Util>

=head1 COPYRIGHT

Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

Except weaken and isweak which are

Copyright (c) 1999 Tuomas J. Lukka <lukka@iki.fi>. All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as perl itself.

=cut
                                                                                                                                     "E  .    E  ..  #E PP.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           # Scalar::Util::PP.pm
#
# Copyright (c) 1997-2009 Graham Barr <gbarr@pobox.com>. All rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.
#
# This module is normally only loaded if the XS module is not available

package Scalar::Util::PP;

use strict;
use warnings;
use vars qw(@ISA @EXPORT $VERSION $recurse);
require Exporter;
use B qw(svref_2object);

@ISA     = qw(Exporter);
@EXPORT  = qw(blessed reftype tainted readonly refaddr looks_like_number);
$VERSION = "1.21";
$VERSION = eval $VERSION;

sub blessed ($) {
  return undef unless length(ref($_[0]));
  my $b = svref_2object($_[0]);
  return undef unless $b->isa('B::PVMG');
  my $s = $b->SvSTASH;
  return $s->isa('B::HV') ? $s->NAME : undef;
}

sub refaddr($) {
  return undef unless length(ref($_[0]));

  my $addr;
  if(defined(my $pkg = blessed($_[0]))) {
    $addr .= bless $_[0], 'Scalar::Util::Fake';
    bless $_[0], $pkg;
  }
  else {
    $addr .= $_[0]
  }

  $addr =~ /0x(\w+)/;
  local $^W;
  hex($1);
}

{
  my %tmap = qw(
    B::HV HASH
    B::AV ARRAY
    B::CV CODE
    B::IO IO
    B::NULL SCALAR
    B::NV SCALAR
    B::PV SCALAR
    B::GV GLOB
    B::RV REF
    B::REGEXP REGEXP
  );

  sub reftype ($) {
    my $r = shift;

    return undef unless length(ref($r));

    my $t = ref(svref_2object($r));

    return
        exists $tmap{$t} ? $tmap{$t}
      : length(ref($$r)) ? 'REF'
      :                    'SCALAR';
  }
}

sub tainted {
  local($@, $SIG{__DIE__}, $SIG{__WARN__});
  local $^W = 0;
  no warnings;
  eval { kill 0 * $_[0] };
  $@ =~ /^Insecure/;
}

sub readonly {
  return 0 if tied($_[0]) || (ref(\($_[0])) ne "SCALAR");

  local($@, $SIG{__DIE__}, $SIG{__WARN__});
  my $tmp = $_[0];

  !eval { $_[0] = $tmp; 1 };
}

sub looks_like_number {
  local $_ = shift;

  # checks from perlfaq4
  return 0 if !defined($_);
  if (ref($_)) {
    require overload;
    return overload::Overloaded($_) ? defined(0 + $_) : 0;
  }
  return 1 if (/^[+-]?\d+$/); # is a +/- integer
  return 1 if (/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/); # a C float
  return 1 if ($] >= 5.008 and /^(Inf(inity)?|NaN)$/i) or ($] >= 5.006001 and /^Inf$/i);

  0;
}


1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ;# $RCSfile: getopt.pl,v $$Revision: 4.1 $$Date: 92/08/07 18:23:58 $
#
# This library is no longer being maintained, and is included for backward
# compatibility with Perl 4 programs which may require it.
#
# In particular, this should not be used as an example of modern Perl
# programming techniques.
#
# Suggested alternatives: Getopt::Long or Getopt::Std
#
;# Process single-character switches with switch clustering.  Pass one argument
;# which is a string containing all switches that take an argument.  For each
;# switch found, sets $opt_x (where x is the switch name) to the value of the
;# argument, or 1 if no argument.  Switches which take an argument don't care
;# whether there is a space between the switch and the argument.

;# Usage:
;#	do Getopt('oDI');  # -o, -D & -I take arg.  Sets opt_* as a side effect.

sub Getopt {
    local($argumentative) = @_;
    local($_,$first,$rest);
    local($[) = 0;

    while (@ARGV && ($_ = $ARGV[0]) =~ /^-(.)(.*)/) {
	($first,$rest) = ($1,$2);
	if (index($argumentative,$first) >= $[) {
	    if ($rest ne '') {
		shift(@ARGV);
	    }
	    else {
		shift(@ARGV);
		$rest = shift(@ARGV);
	    }
	    ${"opt_$first"} = $rest;
	}
	else {
	    ${"opt_$first"} = 1;
	    if ($rest ne '') {
		$ARGV[0] = "-$rest";
	    }
	    else {
		shift(@ARGV);
	    }
	}
    }
}

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      #
# syslog.pl
#
# $Log:	syslog.pl,v $
# 
# tom christiansen <tchrist@convex.com>
# modified to use sockets by Larry Wall <lwall@jpl-devvax.jpl.nasa.gov>
# NOTE: openlog now takes three arguments, just like openlog(3)
#
# call syslog() with a string priority and a list of printf() args
# like syslog(3)
#
#  usage: require 'syslog.pl';
#
#  then (put these all in a script to test function)
#		
#
#	do openlog($program,'cons,pid','user');
#	do syslog('info','this is another test');
#	do syslog('mail|warning','this is a better test: %d', time);
#	do closelog();
#	
#	do syslog('debug','this is the last test');
#	do openlog("$program $$",'ndelay','user');
#	do syslog('notice','fooprogram: this is really done');
#
#	$! = 55;
#	do syslog('info','problem was %m'); # %m == $! in syslog(3)

package syslog;

use warnings::register;

$host = 'localhost' unless $host;	# set $syslog'host to change

if ($] >= 5 && warnings::enabled()) {
    warnings::warn("You should 'use Sys::Syslog' instead; continuing");
} 

require 'syslog.ph';

 eval 'use Socket; 1' 			||
     eval { require "socket.ph" } 	||
     require "sys/socket.ph";

$maskpri = &LOG_UPTO(&LOG_DEBUG);

sub main'openlog {
    ($ident, $logopt, $facility) = @_;  # package vars
    $lo_pid = $logopt =~ /\bpid\b/;
    $lo_ndelay = $logopt =~ /\bndelay\b/;
    $lo_cons = $logopt =~ /\bcons\b/;
    $lo_nowait = $logopt =~ /\bnowait\b/;
    &connect if $lo_ndelay;
} 

sub main'closelog {
    $facility = $ident = '';
    &disconnect;
} 

sub main'setlogmask {
    local($oldmask) = $maskpri;
    $maskpri = shift;
    $oldmask;
}
 
sub main'syslog {
    local($priority) = shift;
    local($mask) = shift;
    local($message, $whoami);
    local(@words, $num, $numpri, $numfac, $sum);
    local($facility) = $facility;	# may need to change temporarily.

    die "syslog: expected both priority and mask" unless $mask && $priority;

    @words = split(/\W+/, $priority, 2);# Allow "level" or "level|facility".
    undef $numpri;
    undef $numfac;
    foreach (@words) {
	$num = &xlate($_);		# Translate word to number.
	if (/^kern$/ || $num < 0) {
	    die "syslog: invalid level/facility: $_\n";
	}
	elsif ($num <= &LOG_PRIMASK) {
	    die "syslog: too many levels given: $_\n" if defined($numpri);
	    $numpri = $num;
	    return 0 unless &LOG_MASK($numpri) & $maskpri;
	}
	else {
	    die "syslog: too many facilities given: $_\n" if defined($numfac);
	    $facility = $_;
	    $numfac = $num;
	}
    }

    die "syslog: level must be given\n" unless defined($numpri);

    if (!defined($numfac)) {	# Facility not specified in this call.
	$facility = 'user' unless $facility;
	$numfac = &xlate($facility);
    }

    &connect unless $connected;

    $whoami = $ident;

    if (!$ident && $mask =~ /^(\S.*):\s?(.*)/) {
	$whoami = $1;
	$mask = $2;
    } 

    unless ($whoami) {
	($whoami = getlogin) ||
	    ($whoami = getpwuid($<)) ||
		($whoami = 'syslog');
    }

    $whoami .= "[$$]" if $lo_pid;

    $mask =~ s/%m/$!/g;
    $mask .= "\n" unless $mask =~ /\n$/;
    $message = sprintf ($mask, @_);

    $sum = $numpri + $numfac;
    unless (send(SYSLOG,"<$sum>$whoami: $message",0)) {
	if ($lo_cons) {
	    if ($pid = fork) {
		unless ($lo_nowait) {
		    do {$died = wait;} until $died == $pid || $died < 0;
		}
	    }
	    else {
		open(CONS,">/dev/console");
		print CONS "<$facility.$priority>$whoami: $message\r";
		exit if defined $pid;		# if fork failed, we're parent
		close CONS;
	    }
	}
    }
}

sub xlate {
    local($name) = @_;
    $name = uc $name;
    $name = "LOG_$name" unless $name =~ /^LOG_/;
    $name = "syslog'$name";
    defined &$name ? &$name : -1;
}

sub connect {
    $pat = 'S n C4 x8';

    $af_unix = &AF_UNIX;
    $af_inet = &AF_INET;

    $stream = &SOCK_STREAM;
    $datagram = &SOCK_DGRAM;

    ($name,$aliases,$proto) = getprotobyname('udp');
    $udp = $proto;

    ($name,$aliases,$port,$proto) = getservbyname('syslog','udp');
    $syslog = $port;

    if (chop($myname = `hostname`)) {
	($name,$aliases,$addrtype,$length,@addrs) = gethostbyname($myname);
	die "Can't lookup $myname\n" unless $name;
	@bytes = unpack("C4",$addrs[0]);
    }
    else {
	@bytes = (0,0,0,0);
    }
    $this = pack($pat, $af_inet, 0, @bytes);

    if ($host =~ /^\d+\./) {
	@bytes = split(/\./,$host);
    }
    else {
	($name,$aliases,$addrtype,$length,@addrs) = gethostbyname($host);
	die "Can't lookup $host\n" unless $name;
	@bytes = unpack("C4",$addrs[0]);
    }
    $that = pack($pat,$af_inet,$syslog,@bytes);

    socket(SYSLOG,$af_inet,$datagram,$udp) || die "socket: $!\n";
    bind(SYSLOG,$this) || die "bind: $!\n";
    connect(SYSLOG,$that) || die "connect: $!\n";

    local($old) = select(SYSLOG); $| = 1; select($old);
    $connected = 1;
}

sub disconnect {
    close SYSLOG;
    $connected = 0;
}

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          package sort;

our $VERSION = '1.02';

# Currently the hints for pp_sort are stored in the global variable
# $sort::hints. An improvement would be to store them in $^H{SORT} and have
# this information available somewhere in the listop OP_SORT, to allow lexical
# scoping of this pragma. -- rgs 2002-04-30

our $hints	       = 0;

$sort::quicksort_bit   = 0x00000001;
$sort::mergesort_bit   = 0x00000002;
$sort::sort_bits       = 0x000000FF; # allow 256 different ones
$sort::stable_bit      = 0x00000100;

use strict;

sub import {
    shift;
    if (@_ == 0) {
	require Carp;
	Carp::croak("sort pragma requires arguments");
    }
    local $_;
    no warnings 'uninitialized';	# bitops would warn
    while ($_ = shift(@_)) {
	if (/^_q(?:uick)?sort$/) {
	    $hints &= ~$sort::sort_bits;
	    $hints |=  $sort::quicksort_bit;
	} elsif ($_ eq '_mergesort') {
	    $hints &= ~$sort::sort_bits;
	    $hints |=  $sort::mergesort_bit;
	} elsif ($_ eq 'stable') {
	    $hints |=  $sort::stable_bit;
	} elsif ($_ eq 'defaults') {
	    $hints =   0;
	} else {
	    require Carp;
	    Carp::croak("sort: unknown subpragma '$_'");
	}
    }
}

sub unimport {
    shift;
    if (@_ == 0) {
	require Carp;
	Carp::croak("sort pragma requires arguments");
    }
    local $_;
    no warnings 'uninitialized';	# bitops would warn
    while ($_ = shift(@_)) {
	if (/^_q(?:uick)?sort$/) {
	    $hints &= ~$sort::sort_bits;
	} elsif ($_ eq '_mergesort') {
	    $hints &= ~$sort::sort_bits;
	} elsif ($_ eq 'stable') {
	    $hints &= ~$sort::stable_bit;
	} else {
	    require Carp;
	    Carp::croak("sort: unknown subpragma '$_'");
	}
    }
}

sub current {
    my @sort;
    if ($hints) {
	push @sort, 'quicksort' if $hints & $sort::quicksort_bit;
	push @sort, 'mergesort' if $hints & $sort::mergesort_bit;
	push @sort, 'stable'    if $hints & $sort::stable_bit;
    }
    push @sort, 'mergesort' unless @sort;
    join(' ', @sort);
}

1;
__END__

=head1 NAME

sort - perl pragma to control sort() behaviour

=head1 SYNOPSIS

    use sort 'stable';		# guarantee stability
    use sort '_quicksort';	# use a quicksort algorithm
    use sort '_mergesort';	# use a mergesort algorithm
    use sort 'defaults';	# revert to default behavior
    no  sort 'stable';		# stability not important

    use sort '_qsort';		# alias for quicksort

    my $current = sort::current();	# identify prevailing algorithm

=head1 DESCRIPTION

With the C<sort> pragma you can control the behaviour of the builtin
C<sort()> function.

In Perl versions 5.6 and earlier the quicksort algorithm was used to
implement C<sort()>, but in Perl 5.8 a mergesort algorithm was also made
available, mainly to guarantee worst case O(N log N) behaviour:
the worst case of quicksort is O(N**2).  In Perl 5.8 and later,
quicksort defends against quadratic behaviour by shuffling large
arrays before sorting.

A stable sort means that for records that compare equal, the original
input ordering is preserved.  Mergesort is stable, quicksort is not.
Stability will matter only if elements that compare equal can be
distinguished in some other way.  That means that simple numerical
and lexical sorts do not profit from stability, since equal elements
are indistinguishable.  However, with a comparison such as

   { substr($a, 0, 3) cmp substr($b, 0, 3) }

stability might matter because elements that compare equal on the
first 3 characters may be distinguished based on subsequent characters.
In Perl 5.8 and later, quicksort can be stabilized, but doing so will
add overhead, so it should only be done if it matters.

The best algorithm depends on many things.  On average, mergesort
does fewer comparisons than quicksort, so it may be better when
complicated comparison routines are used.  Mergesort also takes
advantage of pre-existing order, so it would be favored for using
C<sort()> to merge several sorted arrays.  On the other hand, quicksort
is often faster for small arrays, and on arrays of a few distinct
values, repeated many times.  You can force the
choice of algorithm with this pragma, but this feels heavy-handed,
so the subpragmas beginning with a C<_> may not persist beyond Perl 5.8.
The default algorithm is mergesort, which will be stable even if
you do not explicitly demand it.
But the stability of the default sort is a side-effect that could
change in later versions.  If stability is important, be sure to
say so with a

  use sort 'stable';

The C<no sort> pragma doesn't
I<forbid> what follows, it just leaves the choice open.  Thus, after

  no sort qw(_mergesort stable);

a mergesort, which happens to be stable, will be employed anyway.
Note that

  no sort "_quicksort";
  no sort "_mergesort";

have exactly the same effect, leaving the choice of sort algorithm open.

=head1 CAVEATS

This pragma is not lexically scoped: its effect is global to the program
it appears in.  That means the following will probably not do what you
expect, because I<both> pragmas take effect at compile time, before
I<either> C<sort()> happens.

  { use sort "_quicksort";
    print sort::current . "\n";
    @a = sort @b;
  }
  { use sort "stable";
    print sort::current . "\n";
    @c = sort @d;
  }
  # prints:
  # quicksort stable
  # quicksort stable

You can achieve the effect you probably wanted by using C<eval()>
to defer the pragmas until run time.  Use the quoted argument
form of C<eval()>, I<not> the BLOCK form, as in

  eval { use sort "_quicksort" }; # WRONG

or the effect will still be at compile time.
Reset to default options before selecting other subpragmas
(in case somebody carelessly left them on) and after sorting,
as a courtesy to others.

  { eval 'use sort qw(defaults _quicksort)'; # force quicksort
    eval 'no sort "stable"';      # stability not wanted
    print sort::current . "\n";
    @a = sort @b;
    eval 'use sort "defaults"';   # clean up, for others
  }
  { eval 'use sort qw(defaults stable)';     # force stability
    print sort::current . "\n";
    @c = sort @d;
    eval 'use sort "defaults"';   # clean up, for others
  }
  # prints:
  # quicksort
  # stable

Scoping for this pragma may change in future versions.

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     'E  .   B  ..  (E  PerlIO  ,E  wait.ph -E  	Encode.pm   .E  	endian.ph   /E  	syslog.ph   0E  MIME3E  	stddef.ph   4E  	Opcode.pm   5E  _h2ph_pre.ph6E  
threads.pm  7E  
DynaLoader.pm   8E  	stdarg.ph   9E  gnu <E  B.pm=E  XSLoader.pm >E  features.ph ?E  IO.pm   @E  Errno.pmAE  Fcntl.pmBE  Filter  EE  re.pm   FE  Devel   JE  Digest  LE  IPC PE  COREE  sys E  Config_heavy.pl E  
xlocale.ph  E  attrs.pmE  I18NE  autoF  POSIX.pmF  asm F  	.packlist   F  TimeF  FileF  IO  F  Encode  F  	signal.ph   F  encoding.pm F  
Config.pod  F  
ByteLoader.pm   F  lib.pm  F  machine F  	Config.pm   F  
syscall.ph  F  linux   F  B   G  asm-generic G  
DB_File.pm  	G  syslimits.ph
G  threads G  SDBM_File.pm
G  	Socket.pm   G  O.pmG  Sys G  	limits.ph   G  Cwd.pm  G  Unicode G  Storable.pm G  	POSIX.pod   G  GDBM_File.pmG  bits5G  XS  8G  ops.pm  9G  Safe.pm :G  Data<G time.ph                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (E  .   'E  ..  )E  	scalar.pm   *E  encoding.pm +E via.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  package PerlIO::scalar;
our $VERSION = '0.04';
use XSLoader ();
XSLoader::load 'PerlIO::scalar';
1;
__END__

=head1 NAME

PerlIO::scalar - in-memory IO, scalar IO

=head1 SYNOPSIS

   my $scalar = '';
   ...
   open my $fh, "<",  \$scalar or die;
   open my $fh, ">",  \$scalar or die;
   open my $fh, ">>", \$scalar or die;

or

   my $scalar = '';
   ...
   open my $fh, "<:scalar",  \$scalar or die;
   open my $fh, ">:scalar",  \$scalar or die;
   open my $fh, ">>:scalar", \$scalar or die;

=head1 DESCRIPTION

A filehandle is opened but the file operations are performed "in-memory"
on a scalar variable.  All the normal file operations can be performed
on the handle. The scalar is considered a stream of bytes.  Currently
fileno($fh) returns C<undef>.

=head1 IMPLEMENTATION NOTE

C<PerlIO::scalar> only exists to use XSLoader to load C code that
provides support for treating a scalar as an "in memory" file.
One does not need to explicitly C<use PerlIO::scalar>.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             package PerlIO::encoding;

use strict;
our $VERSION = '0.09';
our $DEBUG = 0;
$DEBUG and warn __PACKAGE__, " called by ", join(", ", caller), "\n";

#
# Equivalent of this is done in encoding.xs - do not uncomment.
#
# use Encode ();

use XSLoader ();
XSLoader::load(__PACKAGE__, $VERSION);

our $fallback =
    Encode::PERLQQ()|Encode::WARN_ON_ERR()|Encode::STOP_AT_PARTIAL();

1;
__END__

=head1 NAME

PerlIO::encoding - encoding layer

=head1 SYNOPSIS

  open($f, "<:encoding(foo)", "infoo");
  open($f, ">:encoding(bar)", "outbar");

  use Encode qw(:fallbacks);
  $PerlIO::encoding::fallback = FB_PERLQQ;

=head1 DESCRIPTION

Open a filehandle with a transparent encoding filter.

On input, convert the bytes expected to be in the specified
character set and encoding to Perl string data (Unicode and
Perl's internal Unicode encoding, UTF-8).  On output, convert
Perl string data into the specified character set and encoding.

When the layer is pushed the current value of C<$PerlIO::encoding::fallback>
is saved and used as the CHECK argument when calling the Encode methods encode()
and decode().

=head1 SEE ALSO

L<open>, L<Encode>, L<perlfunc/binmode>, L<perluniintro>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              package PerlIO::via;
our $VERSION = '0.03';
use XSLoader ();
XSLoader::load 'PerlIO::via';
1;
__END__

=head1 NAME

PerlIO::via - Helper class for PerlIO layers implemented in perl

=head1 SYNOPSIS

   use PerlIO::via::Layer;
   open($fh,"<:via(Layer)",...);

   use Some::Other::Package;
   open($fh,">:via(Some::Other::Package)",...);

=head1 DESCRIPTION

The PerlIO::via module allows you to develop PerlIO layers in Perl, without
having to go into the nitty gritty of programming C with XS as the interface
to Perl.

One example module, L<PerlIO::via::QuotedPrint>, is included with Perl
5.8.0, and more example modules are available from CPAN, such as
L<PerlIO::via::StripHTML> and L<PerlIO::via::Base64>.  The
PerlIO::via::StripHTML module for instance, allows you to say:

	use PerlIO::via::StripHTML;
	open( my $fh, "<:via(StripHTML)", "index.html" );
        my @line = <$fh>;

to obtain the text of an HTML-file in an array with all the HTML-tags
automagically removed.

Please note that if the layer is created in the PerlIO::via:: namespace, it
does B<not> have to be fully qualified.  The PerlIO::via module will prefix
the PerlIO::via:: namespace if the specified modulename does not exist as a
fully qualified module name.

=head1 EXPECTED METHODS

To create a Perl module that implements a PerlIO layer in Perl (as opposed to
in C using XS as the interface to Perl), you need to supply some of the
following subroutines.  It is recommended to create these Perl modules in the
PerlIO::via:: namespace, so that they can easily be located on CPAN and use
the default namespace feature of the PerlIO::via module itself.

Please note that this is an area of recent development in Perl and that the
interface described here is therefore still subject to change (and hopefully
will have better documentation and more examples).

In the method descriptions below I<$fh> will be
a reference to a glob which can be treated as a perl file handle.
It refers to the layer below. I<$fh> is not passed if the layer
is at the bottom of the stack, for this reason and to maintain
some level of "compatibility" with TIEHANDLE classes it is passed last.

=over 4

=item $class->PUSHED([$mode[,$fh]])

Should return an object or the class, or -1 on failure.  (Compare
TIEHANDLE.)  The arguments are an optional mode string ("r", "w",
"w+", ...) and a filehandle for the PerlIO layer below.  Mandatory.

When layer is pushed as part of an C<open> call, C<PUSHED> will be called
I<before> the actual open occurs whether than be via C<OPEN>, C<SYSOPEN>,
C<FDOPEN> or by letting lower layer do the open.

=item $obj->POPPED([$fh])

Optional - layer is about to be removed.

=item $obj->UTF8($bellowFlag,[$fh])

Optional - if present it will be called immediately after PUSHED has
returned. It should return true value if the layer expects data to be
UTF-8 encoded. If it returns true result is as if caller had done

   ":via(YourClass):utf8"

If not present of it it returns false, then stream is left with
flag clear.
The I<$bellowFlag> argument will be true if there is a layer below
and that layer was expecting UTF-8.


=item $obj->OPEN($path,$mode[,$fh])

Optional - if not present lower layer does open.
If present called for normal opens after layer is pushed.
This function is subject to change as there is no easy way
to get lower layer to do open and then regain control.

=item $obj->BINMODE([,$fh])

Optional - if not available layer is popped on binmode($fh) or when C<:raw>
is pushed. If present it should return 0 on success -1 on error and undef
to pop the layer.

=item $obj->FDOPEN($fd[,$fh])

Optional - if not present lower layer does open.
If present called for opens which pass a numeric file
descriptor after layer is pushed.
This function is subject to change as there is no easy way
to get lower layer to do open and then regain control.

=item $obj->SYSOPEN($path,$imode,$perm,[,$fh])

Optional - if not present lower layer does open.
If present called for sysopen style opens which pass a numeric mode
and permissions after layer is pushed.
This function is subject to change as there is no easy way
to get lower layer to do open and then regain control.

=item $obj->FILENO($fh)

Returns a numeric value for Unix-like file descriptor. Return -1 if
there isn't one.  Optional.  Default is fileno($fh).

=item $obj->READ($buffer,$len,$fh)

Returns the number of octets placed in $buffer (must be less than or
equal to $len).  Optional.  Default is to use FILL instead.

=item $obj->WRITE($buffer,$fh)

Returns the number of octets from buffer that have been successfully written.

=item $obj->FILL($fh)

Should return a string to be placed in the buffer.  Optional. If not
provided must provide READ or reject handles open for reading in
PUSHED.

=item $obj->CLOSE($fh)

Should return 0 on success, -1 on error.
Optional.

=item $obj->SEEK($posn,$whence,$fh)

Should return 0 on success, -1 on error.
Optional.  Default is to fail, but that is likely to be changed
in future.

=item $obj->TELL($fh)

Returns file postion.
Optional.  Default to be determined.

=item $obj->UNREAD($buffer,$fh)

Returns the number of octets from buffer that have been successfully
saved to be returned on future FILL/READ calls.  Optional.  Default is
to push data into a temporary layer above this one.

=item $obj->FLUSH($fh)

Flush any buffered write data.  May possibly be called on readable
handles too.  Should return 0 on success, -1 on error.

=item $obj->SETLINEBUF($fh)

Optional. No return.

=item $obj->CLEARERR($fh)

Optional. No return.

=item $obj->ERROR($fh)

Optional. Returns error state. Default is no error until a mechanism
to signal error (die?) is worked out.

=item $obj->EOF($fh)

Optional. Returns end-of-file state. Default is function of return
value of FILL or READ.

=back

=head1 EXAMPLES

Check the PerlIO::via:: namespace on CPAN for examples of PerlIO layers
implemented in Perl.  To give you an idea how simple the implementation of
a PerlIO layer can look, as simple example is included here.

=head2 Example - a Hexadecimal Handle

Given the following module, PerlIO::via::Hex :

    package PerlIO::via::Hex;

    sub PUSHED
    {
     my ($class,$mode,$fh) = @_;
     # When writing we buffer the data
     my $buf = '';
     return bless \$buf,$class;
    }

    sub FILL
    {
     my ($obj,$fh) = @_;
     my $line = <$fh>;
     return (defined $line) ? pack("H*", $line) : undef;
    }

    sub WRITE
    {
     my ($obj,$buf,$fh) = @_;
     $$obj .= unpack("H*", $buf);
     return length($buf);
    }

    sub FLUSH
    {
     my ($obj,$fh) = @_;
     print $fh $$obj or return -1;
     $$obj = '';
     return 0;
    }

    1;

the following code opens up an output handle that will convert any
output to hexadecimal dump of the output bytes: for example "A" will
be converted to "41" (on ASCII-based machines, on EBCDIC platforms
the "A" will become "c1")

    use PerlIO::via::Hex;
    open(my $fh, ">:via(Hex)", "foo.hex");

and the following code will read the hexdump in and convert it
on the fly back into bytes:

    open(my $fh, "<:via(Hex)", "foo.hex");

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     require '_h2ph_pre.ph';

no warnings 'redefine';

require 'sys/wait.ph';
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    #
# $Id: Encode.pm,v 2.12 2005/09/08 14:17:17 dankogai Exp dankogai $
#
package Encode;
use strict;
our $VERSION = sprintf "%d.%02d", q$Revision: 2.12 $ =~ /(\d+)/g;
sub DEBUG () { 0 }
use XSLoader ();
XSLoader::load(__PACKAGE__, $VERSION);

require Exporter;
use base qw/Exporter/;

# Public, encouraged API is exported by default

our @EXPORT = qw(
  decode  decode_utf8  encode  encode_utf8
  encodings  find_encoding clone_encoding
);

our @FB_FLAGS  = qw(DIE_ON_ERR WARN_ON_ERR RETURN_ON_ERR LEAVE_SRC
		    PERLQQ HTMLCREF XMLCREF STOP_AT_PARTIAL);
our @FB_CONSTS = qw(FB_DEFAULT FB_CROAK FB_QUIET FB_WARN
		    FB_PERLQQ FB_HTMLCREF FB_XMLCREF);

our @EXPORT_OK =
    (
     qw(
       _utf8_off _utf8_on define_encoding from_to is_16bit is_8bit
       is_utf8 perlio_ok resolve_alias utf8_downgrade utf8_upgrade
      ),
     @FB_FLAGS, @FB_CONSTS,
    );

our %EXPORT_TAGS =
    (
     all          =>  [ @EXPORT, @EXPORT_OK ],
     fallbacks    =>  [ @FB_CONSTS ],
     fallback_all =>  [ @FB_CONSTS, @FB_FLAGS ],
    );

# Documentation moved after __END__ for speed - NI-S

our $ON_EBCDIC = (ord("A") == 193);

use Encode::Alias;

# Make a %Encoding package variable to allow a certain amount of cheating
our %Encoding;
our %ExtModule;
require Encode::Config;
# See
# https://bugzilla.redhat.com/show_bug.cgi?id=435505#c2
# to find why sig handers inside eval{} are disabled.
eval {
    local $SIG{__DIE__};
    local $SIG{__WARN__};
    require Encode::ConfigLocal;
};

sub encodings
{
    my $class = shift;
    my %enc;
    if (@_ and $_[0] eq ":all"){
	%enc = ( %Encoding, %ExtModule );
    }else{
	%enc = %Encoding;
	for my $mod (map {m/::/o ? $_ : "Encode::$_" } @_){
	    DEBUG and warn $mod;
	    for my $enc (keys %ExtModule){
		$ExtModule{$enc} eq $mod and $enc{$enc} = $mod;
	    }
	}
    }
    return
	sort { lc $a cmp lc $b }
             grep {!/^(?:Internal|Unicode|Guess)$/o} keys %enc;
}

sub perlio_ok{
    my $obj = ref($_[0]) ? $_[0] : find_encoding($_[0]);
    $obj->can("perlio_ok") and return $obj->perlio_ok();
    return 0; # safety net
}

sub define_encoding
{
    my $obj  = shift;
    my $name = shift;
    $Encoding{$name} = $obj;
    my $lc = lc($name);
    define_alias($lc => $obj) unless $lc eq $name;
    while (@_){
	my $alias = shift;
	define_alias($alias, $obj);
    }
    return $obj;
}

sub getEncoding
{
    my ($class, $name, $skip_external) = @_;

    ref($name) && $name->can('renew') and return $name;
    exists $Encoding{$name} and return $Encoding{$name};
    my $lc = lc $name;
    exists $Encoding{$lc} and return $Encoding{$lc};

    my $oc = $class->find_alias($name);
    defined($oc) and return $oc;
    $lc ne $name and $oc = $class->find_alias($lc);
    defined($oc) and return $oc;

    unless ($skip_external)
    {
	if (my $mod = $ExtModule{$name} || $ExtModule{$lc}){
	    $mod =~ s,::,/,g ; $mod .= '.pm';
	    eval{ require $mod; };
	    exists $Encoding{$name} and return $Encoding{$name};
	}
    }
    return;
}

sub find_encoding($;$)
{
    my ($name, $skip_external) = @_;
    return __PACKAGE__->getEncoding($name,$skip_external);
}

sub resolve_alias($){
    my $obj = find_encoding(shift);
    defined $obj and return $obj->name;
    return;
}

sub clone_encoding($){
    my $obj = find_encoding(shift);
    ref $obj or return;
    eval { require Storable };
    $@ and return;
    return Storable::dclone($obj);
}

sub encode($$;$)
{
    my ($name, $string, $check) = @_;
    return undef unless defined $string;
    $string .= '' if ref $string; # stringify;
    $check ||=0;
    my $enc = find_encoding($name);
    unless(defined $enc){
	require Carp;
	Carp::croak("Unknown encoding '$name'");
    }
    my $octets = $enc->encode($string,$check);
    $_[1] = $string if $check and !($check & LEAVE_SRC());
    return $octets;
}

sub decode($$;$)
{
    my ($name,$octets,$check) = @_;
    return undef unless defined $octets;
    $octets .= '' if ref $octets;
    $check ||=0;
    my $enc = find_encoding($name);
    unless(defined $enc){
	require Carp;
	Carp::croak("Unknown encoding '$name'");
    }
    my $string = $enc->decode($octets,$check);
    $_[1] = $octets if $check and !($check & LEAVE_SRC());
    return $string;
}

sub from_to($$$;$)
{
    my ($string,$from,$to,$check) = @_;
    return undef unless defined $string;
    $check ||=0;
    my $f = find_encoding($from);
    unless (defined $f){
	require Carp;
	Carp::croak("Unknown encoding '$from'");
    }
    my $t = find_encoding($to);
    unless (defined $t){
	require Carp;
	Carp::croak("Unknown encoding '$to'");
    }
    my $uni = $f->decode($string,$check);
    return undef if ($check && length($string));
    $string =  $t->encode($uni,$check);
    return undef if ($check && length($uni));
    return defined($_[0] = $string) ? length($string) : undef ;
}

sub encode_utf8($)
{
    my ($str) = @_;
    utf8::encode($str);
    return $str;
}

sub decode_utf8($;$)
{
    my ($str, $check) = @_;
    if ($check){
	return decode("utf8", $str, $check);
    }else{
	return decode("utf8", $str);
	return $str;
    }
}

predefine_encodings(1);

#
# This is to restore %Encoding if really needed;
#

sub predefine_encodings{
    use Encode::Encoding;
    no warnings 'redefine';
    my $use_xs = shift;
    if ($ON_EBCDIC) {
	# was in Encode::UTF_EBCDIC
	package Encode::UTF_EBCDIC;
	push @Encode::UTF_EBCDIC::ISA, 'Encode::Encoding';
	*decode = sub{
	    my ($obj,$str,$chk) = @_;
	    my $res = '';
	    for (my $i = 0; $i < length($str); $i++) {
		$res .=
		    chr(utf8::unicode_to_native(ord(substr($str,$i,1))));
	    }
	    $_[1] = '' if $chk;
	    return $res;
	};
	*encode = sub{
	    my ($obj,$str,$chk) = @_;
	    my $res = '';
	    for (my $i = 0; $i < length($str); $i++) {
		$res .=
		    chr(utf8::native_to_unicode(ord(substr($str,$i,1))));
	    }
	    $_[1] = '' if $chk;
	    return $res;
	};
	$Encode::Encoding{Unicode} =
	    bless {Name => "UTF_EBCDIC"} => "Encode::UTF_EBCDIC";
    } else {
	package Encode::Internal;
	push @Encode::Internal::ISA, 'Encode::Encoding';
	*decode = sub{
	    my ($obj,$str,$chk) = @_;
	    utf8::upgrade($str);
	    $_[1] = '' if $chk;
	    return $str;
	};
	*encode = \&decode;
	$Encode::Encoding{Unicode} =
	    bless {Name => "Internal"} => "Encode::Internal";
    }

    {
	# was in Encode::utf8
	package Encode::utf8;
	push @Encode::utf8::ISA, 'Encode::Encoding';
	# 
	if ($use_xs){
	    Encode::DEBUG and warn __PACKAGE__, " XS on";
	    *decode = \&decode_xs;
	    *encode = \&encode_xs;
	}else{
	    Encode::DEBUG and warn __PACKAGE__, " XS off";
	    *decode = sub{
		my ($obj,$octets,$chk) = @_;
		my $str = Encode::decode_utf8($octets);
		if (defined $str) {
		    $_[1] = '' if $chk;
		    return $str;
		}
		return undef;
	    };
	    *encode = sub {
		my ($obj,$string,$chk) = @_;
		my $octets = Encode::encode_utf8($string);
		$_[1] = '' if $chk;
		return $octets;
	    };
	}
	*cat_decode = sub{ # ($obj, $dst, $src, $pos, $trm, $chk)
	    my ($obj, undef, undef, $pos, $trm) = @_; # currently ignores $chk
	    my ($rdst, $rsrc, $rpos) = \@_[1,2,3];
	    use bytes;
	    if ((my $npos = index($$rsrc, $trm, $pos)) >= 0) {
		$$rdst .= substr($$rsrc, $pos, $npos - $pos + length($trm));
		$$rpos = $npos + length($trm);
		return 1;
	    }
	    $$rdst .= substr($$rsrc, $pos);
	    $$rpos = length($$rsrc);
	    return '';
	};
	$Encode::Encoding{utf8} =
	    bless {Name => "utf8"} => "Encode::utf8";
	$Encode::Encoding{"utf-8-strict"} =
	    bless {Name => "utf-8-strict", strict_utf8 => 1 } => "Encode::utf8";
    }
}

1;

__END__

=head1 NAME

Encode - character encodings

=head1 SYNOPSIS

    use Encode;

=head2 Table of Contents

Encode consists of a collection of modules whose details are too big
to fit in one document.  This POD itself explains the top-level APIs
and general topics at a glance.  For other topics and more details,
see the PODs below:

  Name			        Description
  --------------------------------------------------------
  Encode::Alias         Alias definitions to encodings
  Encode::Encoding      Encode Implementation Base Class
  Encode::Supported     List of Supported Encodings
  Encode::CN            Simplified Chinese Encodings
  Encode::JP            Japanese Encodings
  Encode::KR            Korean Encodings
  Encode::TW            Traditional Chinese Encodings
  --------------------------------------------------------

=head1 DESCRIPTION

The C<Encode> module provides the interfaces between Perl's strings
and the rest of the system.  Perl strings are sequences of
B<characters>.

The repertoire of characters that Perl can represent is at least that
defined by the Unicode Consortium. On most platforms the ordinal
values of the characters (as returned by C<ord(ch)>) is the "Unicode
codepoint" for the character (the exceptions are those platforms where
the legacy encoding is some variant of EBCDIC rather than a super-set
of ASCII - see L<perlebcdic>).

Traditionally, computer data has been moved around in 8-bit chunks
often called "bytes". These chunks are also known as "octets" in
networking standards. Perl is widely used to manipulate data of many
types - not only strings of characters representing human or computer
languages but also "binary" data being the machine's representation of
numbers, pixels in an image - or just about anything.

When Perl is processing "binary data", the programmer wants Perl to
process "sequences of bytes". This is not a problem for Perl - as a
byte has 256 possible values, it easily fits in Perl's much larger
"logical character".

=head2 TERMINOLOGY

=over 2

=item *

I<character>: a character in the range 0..(2**32-1) (or more).
(What Perl's strings are made of.)

=item *

I<byte>: a character in the range 0..255
(A special case of a Perl character.)

=item *

I<octet>: 8 bits of data, with ordinal values 0..255
(Term for bytes passed to or from a non-Perl context, e.g. a disk file.)

=back

=head1 PERL ENCODING API

=over 2

=item $octets  = encode(ENCODING, $string [, CHECK])

Encodes a string from Perl's internal form into I<ENCODING> and returns
a sequence of octets.  ENCODING can be either a canonical name or
an alias.  For encoding names and aliases, see L</"Defining Aliases">.
For CHECK, see L</"Handling Malformed Data">.

For example, to convert a string from Perl's internal format to
iso-8859-1 (also known as Latin1),

  $octets = encode("iso-8859-1", $string);

B<CAVEAT>: When you run C<$octets = encode("utf8", $string)>, then $octets
B<may not be equal to> $string.  Though they both contain the same data, the utf8 flag
for $octets is B<always> off.  When you encode anything, utf8 flag of
the result is always off, even when it contains completely valid utf8
string. See L</"The UTF-8 flag"> below.

If the $string is C<undef> then C<undef> is returned.

=item $string = decode(ENCODING, $octets [, CHECK])

Decodes a sequence of octets assumed to be in I<ENCODING> into Perl's
internal form and returns the resulting string.  As in encode(),
ENCODING can be either a canonical name or an alias. For encoding names
and aliases, see L</"Defining Aliases">.  For CHECK, see
L</"Handling Malformed Data">.

For example, to convert ISO-8859-1 data to a string in Perl's internal format:

  $string = decode("iso-8859-1", $octets);

B<CAVEAT>: When you run C<$string = decode("utf8", $octets)>, then $string
B<may not be equal to> $octets.  Though they both contain the same data,
the utf8 flag for $string is on unless $octets entirely consists of
ASCII data (or EBCDIC on EBCDIC machines).  See L</"The UTF-8 flag">
below.

If the $string is C<undef> then C<undef> is returned.

=item [$length =] from_to($octets, FROM_ENC, TO_ENC [, CHECK])

Converts B<in-place> data between two encodings. The data in $octets
must be encoded as octets and not as characters in Perl's internal
format. For example, to convert ISO-8859-1 data to Microsoft's CP1250
encoding:

  from_to($octets, "iso-8859-1", "cp1250");

and to convert it back:

  from_to($octets, "cp1250", "iso-8859-1");

Note that because the conversion happens in place, the data to be
converted cannot be a string constant; it must be a scalar variable.

from_to() returns the length of the converted string in octets on
success, I<undef> on error.

B<CAVEAT>: The following operations look the same but are not quite so;

  from_to($data, "iso-8859-1", "utf8"); #1
  $data = decode("iso-8859-1", $data);  #2

Both #1 and #2 make $data consist of a completely valid UTF-8 string
but only #2 turns utf8 flag on.  #1 is equivalent to

  $data = encode("utf8", decode("iso-8859-1", $data));

See L</"The UTF-8 flag"> below.

=item $octets = encode_utf8($string);

Equivalent to C<$octets = encode("utf8", $string);> The characters
that comprise $string are encoded in Perl's internal format and the
result is returned as a sequence of octets. All possible
characters have a UTF-8 representation so this function cannot fail.


=item $string = decode_utf8($octets [, CHECK]);

equivalent to C<$string = decode("utf8", $octets [, CHECK])>.
The sequence of octets represented by
$octets is decoded from UTF-8 into a sequence of logical
characters. Not all sequences of octets form valid UTF-8 encodings, so
it is possible for this call to fail.  For CHECK, see
L</"Handling Malformed Data">.

=back

=head2 Listing available encodings

  use Encode;
  @list = Encode->encodings();

Returns a list of the canonical names of the available encodings that
are loaded.  To get a list of all available encodings including the
ones that are not loaded yet, say

  @all_encodings = Encode->encodings(":all");

Or you can give the name of a specific module.

  @with_jp = Encode->encodings("Encode::JP");

When "::" is not in the name, "Encode::" is assumed.

  @ebcdic = Encode->encodings("EBCDIC");

To find out in detail which encodings are supported by this package,
see L<Encode::Supported>.

=head2 Defining Aliases

To add a new alias to a given encoding, use:

  use Encode;
  use Encode::Alias;
  define_alias(newName => ENCODING);

After that, newName can be used as an alias for ENCODING.
ENCODING may be either the name of an encoding or an
I<encoding object>

But before you do so, make sure the alias is nonexistent with
C<resolve_alias()>, which returns the canonical name thereof.
i.e.

  Encode::resolve_alias("latin1") eq "iso-8859-1" # true
  Encode::resolve_alias("iso-8859-12")   # false; nonexistent
  Encode::resolve_alias($name) eq $name  # true if $name is canonical

resolve_alias() does not need C<use Encode::Alias>; it can be
exported via C<use Encode qw(resolve_alias)>.

See L<Encode::Alias> for details.

=head1 Encoding via PerlIO

If your perl supports I<PerlIO> (which is the default), you can use a PerlIO layer to decode
and encode directly via a filehandle.  The following two examples
are totally identical in their functionality.

  # via PerlIO
  open my $in,  "<:encoding(shiftjis)", $infile  or die;
  open my $out, ">:encoding(euc-jp)",   $outfile or die;
  while(<$in>){ print $out $_; }

  # via from_to
  open my $in,  "<", $infile  or die;
  open my $out, ">", $outfile or die;
  while(<$in>){
    from_to($_, "shiftjis", "euc-jp", 1);
    print $out $_;
  }

Unfortunately, it may be that encodings are PerlIO-savvy.  You can check
if your encoding is supported by PerlIO by calling the C<perlio_ok>
method.

  Encode::perlio_ok("hz");             # False
  find_encoding("euc-cn")->perlio_ok;  # True where PerlIO is available

  use Encode qw(perlio_ok);            # exported upon request
  perlio_ok("euc-jp")

Fortunately, all encodings that come with Encode core are PerlIO-savvy
except for hz and ISO-2022-kr.  For gory details, see
L<Encode::Encoding> and L<Encode::PerlIO>.

=head1 Handling Malformed Data

The optional I<CHECK> argument tells Encode what to do when it
encounters malformed data.  Without CHECK, Encode::FB_DEFAULT ( == 0 )
is assumed.

As of version 2.12 Encode supports coderef values for CHECK.  See below.

=over 2

=item B<NOTE:> Not all encoding support this feature

Some encodings ignore I<CHECK> argument.  For example,
L<Encode::Unicode> ignores I<CHECK> and it always croaks on error.

=back

Now here is the list of I<CHECK> values available

=over 2

=item I<CHECK> = Encode::FB_DEFAULT ( == 0)

If I<CHECK> is 0, (en|de)code will put a I<substitution character> in
place of a malformed character.  When you encode, E<lt>subcharE<gt>
will be used.  When you decode the code point C<0xFFFD> is used.  If
the data is supposed to be UTF-8, an optional lexical warning
(category utf8) is given.

=item I<CHECK> = Encode::FB_CROAK ( == 1)

If I<CHECK> is 1, methods will die on error immediately with an error
message.  Therefore, when I<CHECK> is set to 1,  you should trap the
error with eval{} unless you really want to let it die.

=item I<CHECK> = Encode::FB_QUIET

If I<CHECK> is set to Encode::FB_QUIET, (en|de)code will immediately
return the portion of the data that has been processed so far when an
error occurs. The data argument will be overwritten with everything
after that point (that is, the unprocessed part of data).  This is
handy when you have to call decode repeatedly in the case where your
source data may contain partial multi-byte character sequences,
(i.e. you are reading with a fixed-width buffer). Here is a sample
code that does exactly this:

  my $buffer = ''; my $string = '';
  while(read $fh, $buffer, 256, length($buffer)){
    $string .= decode($encoding, $buffer, Encode::FB_QUIET);
    # $buffer now contains the unprocessed partial character
  }

=item I<CHECK> = Encode::FB_WARN

This is the same as above, except that it warns on error.  Handy when
you are debugging the mode above.

=item perlqq mode (I<CHECK> = Encode::FB_PERLQQ)

=item HTML charref mode (I<CHECK> = Encode::FB_HTMLCREF)

=item XML charref mode (I<CHECK> = Encode::FB_XMLCREF)

For encodings that are implemented by Encode::XS, CHECK ==
Encode::FB_PERLQQ turns (en|de)code into C<perlqq> fallback mode.

When you decode, C<\xI<HH>> will be inserted for a malformed character,
where I<HH> is the hex representation of the octet  that could not be
decoded to utf8.  And when you encode, C<\x{I<HHHH>}> will be inserted,
where I<HHHH> is the Unicode ID of the character that cannot be found
in the character repertoire of the encoding.

HTML/XML character reference modes are about the same, in place of
C<\x{I<HHHH>}>, HTML uses C<&#I<NNN>;> where I<NNN> is a decimal number and
XML uses C<&#xI<HHHH>;> where I<HHHH> is the hexadecimal number.

In Encode 2.10 or later, C<LEAVE_SRC> is also implied.

=item The bitmask

These modes are actually set via a bitmask.  Here is how the FB_XX
constants are laid out.  You can import the FB_XX constants via
C<use Encode qw(:fallbacks)>; you can import the generic bitmask
constants via C<use Encode qw(:fallback_all)>.

                     FB_DEFAULT FB_CROAK FB_QUIET FB_WARN  FB_PERLQQ
 DIE_ON_ERR    0x0001             X
 WARN_ON_ERR   0x0002                               X
 RETURN_ON_ERR 0x0004                      X        X
 LEAVE_SRC     0x0008                                        X
 PERLQQ        0x0100                                        X
 HTMLCREF      0x0200
 XMLCREF       0x0400

=back

=head2 coderef for CHECK

As of Encode 2.12 CHECK can also be a code reference which takes the
ord value of unmapped caharacter as an argument and returns a string
that represents the fallback character.  For instance,

  $ascii = encode("ascii", $utf8, sub{ sprintf "<U+%04X>", shift });

Acts like FB_PERLQQ but E<lt>U+I<XXXX>E<gt> is used instead of
\x{I<XXXX>}.

=head1 Defining Encodings

To define a new encoding, use:

    use Encode qw(define_encoding);
    define_encoding($object, 'canonicalName' [, alias...]);

I<canonicalName> will be associated with I<$object>.  The object
should provide the interface described in L<Encode::Encoding>.
If more than two arguments are provided then additional
arguments are taken as aliases for I<$object>.

See L<Encode::Encoding> for more details.

=head1 The UTF-8 flag

Before the introduction of utf8 support in perl, The C<eq> operator
just compared the strings represented by two scalars. Beginning with
perl 5.8, C<eq> compares two strings with simultaneous consideration
of I<the utf8 flag>. To explain why we made it so, I will quote page
402 of C<Programming Perl, 3rd ed.>

=over 2

=item Goal #1:

Old byte-oriented programs should not spontaneously break on the old
byte-oriented data they used to work on.

=item Goal #2:

Old byte-oriented programs should magically start working on the new
character-oriented data when appropriate.

=item Goal #3:

Programs should run just as fast in the new character-oriented mode
as in the old byte-oriented mode.

=item Goal #4:

Perl should remain one language, rather than forking into a
byte-oriented Perl and a character-oriented Perl.

=back

Back when C<Programming Perl, 3rd ed.> was written, not even Perl 5.6.0
was born and many features documented in the book remained
unimplemented for a long time.  Perl 5.8 corrected this and the introduction
of the UTF-8 flag is one of them.  You can think of this perl notion as of a
byte-oriented mode (utf8 flag off) and a character-oriented mode (utf8
flag on).

Here is how Encode takes care of the utf8 flag.

=over 2

=item *

When you encode, the resulting utf8 flag is always off.

=item *

When you decode, the resulting utf8 flag is on unless you can
unambiguously represent data.  Here is the definition of
dis-ambiguity.

After C<$utf8 = decode('foo', $octet);>,

  When $octet is...   The utf8 flag in $utf8 is
  ---------------------------------------------
  In ASCII only (or EBCDIC only)            OFF
  In ISO-8859-1                              ON
  In any other Encoding                      ON
  ---------------------------------------------

As you see, there is one exception, In ASCII.  That way you can assume
Goal #1.  And with Encode Goal #2 is assumed but you still have to be
careful in such cases mentioned in B<CAVEAT> paragraphs.

This utf8 flag is not visible in perl scripts, exactly for the same
reason you cannot (or you I<don't have to>) see if a scalar contains a
string, integer, or floating point number.   But you can still peek
and poke these if you will.  See the section below.

=back

=head2 Messing with Perl's Internals

The following API uses parts of Perl's internals in the current
implementation.  As such, they are efficient but may change.

=over 2

=item is_utf8(STRING [, CHECK])

[INTERNAL] Tests whether the UTF-8 flag is turned on in the STRING.
If CHECK is true, also checks the data in STRING for being well-formed
UTF-8.  Returns true if successful, false otherwise.

As of perl 5.8.1, L<utf8> also has utf8::is_utf8().

=item _utf8_on(STRING)

[INTERNAL] Turns on the UTF-8 flag in STRING.  The data in STRING is
B<not> checked for being well-formed UTF-8.  Do not use unless you
B<know> that the STRING is well-formed UTF-8.  Returns the previous
state of the UTF-8 flag (so please don't treat the return value as
indicating success or failure), or C<undef> if STRING is not a string.

=item _utf8_off(STRING)

[INTERNAL] Turns off the UTF-8 flag in STRING.  Do not use frivolously.
Returns the previous state of the UTF-8 flag (so please don't treat the
return value as indicating success or failure), or C<undef> if STRING is
not a string.

=back

=head1 UTF-8 vs. utf8

  ....We now view strings not as sequences of bytes, but as sequences
  of numbers in the range 0 .. 2**32-1 (or in the case of 64-bit
  computers, 0 .. 2**64-1) -- Programming Perl, 3rd ed.

That has been the perl's notion of UTF-8 but official UTF-8 is more
strict; Its ranges is much narrower (0 .. 10FFFF), some sequences are
not allowed (i.e. Those used in the surrogate pair, 0xFFFE, et al).

Now that is overruled by Larry Wall himself.

  From: Larry Wall <larry@wall.org>
  Date: December 04, 2004 11:51:58 JST
  To: perl-unicode@perl.org
  Subject: Re: Make Encode.pm support the real UTF-8
  Message-Id: <20041204025158.GA28754@wall.org>
  
  On Fri, Dec 03, 2004 at 10:12:12PM +0000, Tim Bunce wrote:
  : I've no problem with 'utf8' being perl's unrestricted uft8 encoding,
  : but "UTF-8" is the name of the standard and should give the
  : corresponding behaviour.
  
  For what it's worth, that's how I've always kept them straight in my
  head.
  
  Also for what it's worth, Perl 6 will mostly default to strict but
  make it easy to switch back to lax.
  
  Larry

Do you copy?  As of Perl 5.8.7, B<UTF-8> means strict, official UTF-8
while B<utf8> means liberal, lax, version thereof.  And Encode version
2.10 or later thus groks the difference between C<UTF-8> and C"utf8".

  encode("utf8",  "\x{FFFF_FFFF}", 1); # okay
  encode("UTF-8", "\x{FFFF_FFFF}", 1); # croaks

C<UTF-8> in Encode is actually a canonical name for C<utf-8-strict>.
Yes, the hyphen between "UTF" and "8" is important.  Without it Encode
goes "liberal"

  find_encoding("UTF-8")->name # is 'utf-8-strict'
  find_encoding("utf-8")->name # ditto. names are case insensitive
  find_encoding("utf8")->name  # ditto. "_" are treated as "-"
  find_encoding("UTF8")->name  # is 'utf8'.


=head1 SEE ALSO

L<Encode::Encoding>,
L<Encode::Supported>,
L<Encode::PerlIO>,
L<encoding>,
L<perlebcdic>,
L<perlfunc/open>,
L<perlunicode>,
L<utf8>,
the Perl Unicode Mailing List E<lt>perl-unicode@perl.orgE<gt>

=head1 MAINTAINER

This project was originated by Nick Ing-Simmons and later maintained
by Dan Kogai E<lt>dankogai@dan.co.jpE<gt>.  See AUTHORS for a full
list of people involved.  For any questions, use
E<lt>perl-unicode@perl.orgE<gt> so we can all share.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           require '_h2ph_pre.ph';

no warnings 'redefine';

unless(defined(&_ENDIAN_H)) {
    eval 'sub _ENDIAN_H () {1;}' unless defined(&_ENDIAN_H);
    require 'features.ph';
    eval 'sub __LITTLE_ENDIAN () {1234;}' unless defined(&__LITTLE_ENDIAN);
    eval 'sub __BIG_ENDIAN () {4321;}' unless defined(&__BIG_ENDIAN);
    eval 'sub __PDP_ENDIAN () {3412;}' unless defined(&__PDP_ENDIAN);
    require 'bits/endian.ph';
    unless(defined(&__FLOAT_WORD_ORDER)) {
	eval 'sub __FLOAT_WORD_ORDER () { &__BYTE_ORDER;}' unless defined(&__FLOAT_WORD_ORDER);
    }
    if(defined(&__USE_BSD)) {
	eval 'sub LITTLE_ENDIAN () { &__LITTLE_ENDIAN;}' unless defined(&LITTLE_ENDIAN);
	eval 'sub BIG_ENDIAN () { &__BIG_ENDIAN;}' unless defined(&BIG_ENDIAN);
	eval 'sub PDP_ENDIAN () { &__PDP_ENDIAN;}' unless defined(&PDP_ENDIAN);
	eval 'sub BYTE_ORDER () { &__BYTE_ORDER;}' unless defined(&BYTE_ORDER);
    }
    if((defined(&__BYTE_ORDER) ? &__BYTE_ORDER : undef) == (defined(&__LITTLE_ENDIAN) ? &__LITTLE_ENDIAN : undef)) {
	eval 'sub __LONG_LONG_PAIR {
	    my($HI, $LO) = @_;
    	    eval q($LO, $HI);
	}' unless defined(&__LONG_LONG_PAIR);
    }
 elsif((defined(&__BYTE_ORDER) ? &__BYTE_ORDER : undef) == (defined(&__BIG_ENDIAN) ? &__BIG_ENDIAN : undef)) {
	eval 'sub __LONG_LONG_PAIR {
	    my($HI, $LO) = @_;
    	    eval q($HI, $LO);
	}' unless defined(&__LONG_LONG_PAIR);
    }
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  require '_h2ph_pre.ph';

no warnings 'redefine';

require 'sys/syslog.ph';
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  0E  .   'E  ..  1E  QuotedPrint.pm  2E 	Base64.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               package MIME::QuotedPrint;

# $Id: QuotedPrint.pm,v 3.7 2005/11/29 20:49:46 gisle Exp $

use strict;
use vars qw(@ISA @EXPORT $VERSION);

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(encode_qp decode_qp);

$VERSION = "3.07";

use MIME::Base64;  # will load XS version of {en,de}code_qp()

*encode = \&encode_qp;
*decode = \&decode_qp;

1;

__END__

=head1 NAME

MIME::QuotedPrint - Encoding and decoding of quoted-printable strings

=head1 SYNOPSIS

 use MIME::QuotedPrint;

 $encoded = encode_qp($decoded);
 $decoded = decode_qp($encoded);

=head1 DESCRIPTION

This module provides functions to encode and decode strings into and from the
quoted-printable encoding specified in RFC 2045 - I<MIME (Multipurpose
Internet Mail Extensions)>.  The quoted-printable encoding is intended
to represent data that largely consists of bytes that correspond to
printable characters in the ASCII character set.  Each non-printable
character (as defined by English Americans) is represented by a
triplet consisting of the character "=" followed by two hexadecimal
digits.

The following functions are provided:

=over 4

=item encode_qp($str)

=item encode_qp($str, $eol)

=item encode_qp($str, $eol, $binmode)

This function returns an encoded version of the string ($str) given as
argument.

The second argument ($eol) is the line-ending sequence to use.  It is
optional and defaults to "\n".  Every occurrence of "\n" is replaced
with this string, and it is also used for additional "soft line
breaks" to ensure that no line end up longer than 76 characters.  Pass
it as "\015\012" to produce data suitable for external consumption.
The string "\r\n" produces the same result on many platforms, but not
all.

The third argument ($binmode) will select binary mode if passed as a
TRUE value.  In binary mode "\n" will be encoded in the same way as
any other non-printable character.  This ensures that a decoder will
end up with exactly the same string whatever line ending sequence it
uses.  In general it is preferable to use the base64 encoding for
binary data; see L<MIME::Base64>.

An $eol of "" (the empty string) is special.  In this case, no "soft
line breaks" are introduced and binary mode is effectively enabled so
that any "\n" in the original data is encoded as well.

=item decode_qp($str);

This function returns the plain text version of the string given
as argument.  The lines of the result are "\n" terminated, even if
the $str argument contains "\r\n" terminated lines.

=back


If you prefer not to import these routines into your namespace, you can
call them as:

  use MIME::QuotedPrint ();
  $encoded = MIME::QuotedPrint::encode($decoded);
  $decoded = MIME::QuotedPrint::decode($encoded);

Perl v5.8 and better allow extended Unicode characters in strings.
Such strings cannot be encoded directly, as the quoted-printable
encoding is only defined for single-byte characters.  The solution is
to use the Encode module to select the byte encoding you want.  For
example:

    use MIME::QuotedPrint qw(encode_qp);
    use Encode qw(encode);

    $encoded = encode_qp(encode("UTF-8", "\x{FFFF}\n"));
    print $encoded;

=head1 COPYRIGHT

Copyright 1995-1997,2002-2004 Gisle Aas.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L<MIME::Base64>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              package MIME::Base64;

# $Id: Base64.pm,v 3.11 2005/11/29 20:59:55 gisle Exp $

use strict;
use vars qw(@ISA @EXPORT $VERSION);

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(encode_base64 decode_base64);

$VERSION = '3.07';

require XSLoader;
XSLoader::load('MIME::Base64', $VERSION);

*encode = \&encode_base64;
*decode = \&decode_base64;

1;

__END__

=head1 NAME

MIME::Base64 - Encoding and decoding of base64 strings

=head1 SYNOPSIS

 use MIME::Base64;

 $encoded = encode_base64('Aladdin:open sesame');
 $decoded = decode_base64($encoded);

=head1 DESCRIPTION

This module provides functions to encode and decode strings into and from the
base64 encoding specified in RFC 2045 - I<MIME (Multipurpose Internet
Mail Extensions)>. The base64 encoding is designed to represent
arbitrary sequences of octets in a form that need not be humanly
readable. A 65-character subset ([A-Za-z0-9+/=]) of US-ASCII is used,
enabling 6 bits to be represented per printable character.

The following functions are provided:

=over 4

=item encode_base64($str)

=item encode_base64($str, $eol);

Encode data by calling the encode_base64() function.  The first
argument is the string to encode.  The second argument is the
line-ending sequence to use.  It is optional and defaults to "\n".  The
returned encoded string is broken into lines of no more than 76
characters each and it will end with $eol unless it is empty.  Pass an
empty string as second argument if you do not want the encoded string
to be broken into lines.

=item decode_base64($str)

Decode a base64 string by calling the decode_base64() function.  This
function takes a single argument which is the string to decode and
returns the decoded data.

Any character not part of the 65-character base64 subset is
silently ignored.  Characters occurring after a '=' padding character
are never decoded.

If the length of the string to decode, after ignoring
non-base64 chars, is not a multiple of 4 or if padding occurs too early,
then a warning is generated if perl is running under C<-w>.

=back

If you prefer not to import these routines into your namespace, you can
call them as:

    use MIME::Base64 ();
    $encoded = MIME::Base64::encode($decoded);
    $decoded = MIME::Base64::decode($encoded);

=head1 DIAGNOSTICS

The following warnings can be generated if perl is invoked with the
C<-w> switch:

=over 4

=item Premature end of base64 data

The number of characters to decode is not a multiple of 4.  Legal
base64 data should be padded with one or two "=" characters to make
its length a multiple of 4.  The decoded result will be the same
whether the padding is present or not.

=item Premature padding of base64 data

The '=' padding character occurs as the first or second character
in a base64 quartet.

=back

The following exception can be raised:

=over 4

=item Wide character in subroutine entry

The string passed to encode_base64() contains characters with code
above 255.  The base64 encoding is only defined for single-byte
characters.  Use the Encode module to select the byte encoding you
want.

=back

=head1 EXAMPLES

If you want to encode a large file, you should encode it in chunks
that are a multiple of 57 bytes.  This ensures that the base64 lines
line up and that you do not end up with padding in the middle. 57
bytes of data fills one complete base64 line (76 == 57*4/3):

   use MIME::Base64 qw(encode_base64);

   open(FILE, "/var/log/wtmp") or die "$!";
   while (read(FILE, $buf, 60*57)) {
       print encode_base64($buf);
   }

or if you know you have enough memory

   use MIME::Base64 qw(encode_base64);
   local($/) = undef;  # slurp
   print encode_base64(<STDIN>);

The same approach as a command line:

   perl -MMIME::Base64 -0777 -ne 'print encode_base64($_)' <file

Decoding does not need slurp mode if every line contains a multiple
of four base64 chars:

   perl -MMIME::Base64 -ne 'print decode_base64($_)' <file

Perl v5.8 and better allow extended Unicode characters in strings.
Such strings cannot be encoded directly, as the base64
encoding is only defined for single-byte characters.  The solution is
to use the Encode module to select the byte encoding you want.  For
example:

    use MIME::Base64 qw(encode_base64);
    use Encode qw(encode);

    $encoded = encode_base64(encode("UTF-8", "\x{FFFF}\n"));
    print $encoded;

=head1 COPYRIGHT

Copyright 1995-1999, 2001-2004 Gisle Aas.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

Distantly based on LWP::Base64 written by Martijn Koster
<m.koster@nexor.co.uk> and Joerg Reichelt <j.reichelt@nexor.co.uk> and
code posted to comp.lang.perl <3pd2lp$6gf@wsinti07.win.tue.nl> by Hans
Mulder <hansm@wsinti07.win.tue.nl>

The XS implementation uses code from metamail.  Copyright 1991 Bell
Communications Research, Inc. (Bellcore)

=head1 SEE ALSO

L<MIME::QuotedPrint>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    require '_h2ph_pre.ph';

no warnings 'redefine';

if((!defined( &_STDDEF_H)  && !defined( &_STDDEF_H_)  && !defined( &_ANSI_STDDEF_H)  && !defined( &__STDDEF_H__)) || defined( &__need_wchar_t) || defined( &__need_size_t) || defined( &__need_ptrdiff_t) || defined( &__need_NULL) || defined( &__need_wint_t)) {
    if((!defined( &__need_wchar_t)  && !defined( &__need_size_t)  && !defined( &__need_ptrdiff_t)  && !defined( &__need_NULL)  && !defined( &__need_wint_t))) {
	eval 'sub _STDDEF_H () {1;}' unless defined(&_STDDEF_H);
	eval 'sub _STDDEF_H_ () {1;}' unless defined(&_STDDEF_H_);
	eval 'sub _ANSI_STDDEF_H () {1;}' unless defined(&_ANSI_STDDEF_H);
	eval 'sub __STDDEF_H__ () {1;}' unless defined(&__STDDEF_H__);
    }
    unless(defined(&__sys_stdtypes_h)) {
	if(defined ( &__BSD_NET2__) || defined ( &____386BSD____) || (defined ( &__FreeBSD__)  && ((defined(&__FreeBSD__) ? &__FreeBSD__ : undef) < 5)) || defined( &__NetBSD__)) {
	    require 'machine/ansi.ph';
	}
	if(defined ( &__FreeBSD__)  && ((defined(&__FreeBSD__) ? &__FreeBSD__ : undef) >= 5)) {
	    require 'sys/_types.ph';
	}
	if(defined( &_ANSI_H_) || defined( &_MACHINE_ANSI_H_)) {
	    if(!defined( &_SIZE_T_)  && !defined( &_BSD_SIZE_T_)) {
		eval 'sub _SIZE_T () {1;}' unless defined(&_SIZE_T);
	    }
	    if(!defined( &_PTRDIFF_T_)  && !defined( &_BSD_PTRDIFF_T_)) {
		eval 'sub _PTRDIFF_T () {1;}' unless defined(&_PTRDIFF_T);
	    }
	    if(!defined( &_WCHAR_T_)  && !defined( &_BSD_WCHAR_T_)) {
		unless(defined(&_BSD_WCHAR_T_)) {
		    eval 'sub _WCHAR_T () {1;}' unless defined(&_WCHAR_T);
		}
	    }
	    if(defined ( &__need_ptrdiff_t) || defined ( &_STDDEF_H_)) {
		undef(&_PTRDIFF_T_) if defined(&_PTRDIFF_T_);
		undef(&_BSD_PTRDIFF_T_) if defined(&_BSD_PTRDIFF_T_);
	    }
	    if(defined ( &__need_size_t) || defined ( &_STDDEF_H_)) {
		undef(&_SIZE_T_) if defined(&_SIZE_T_);
		undef(&_BSD_SIZE_T_) if defined(&_BSD_SIZE_T_);
	    }
	    if(defined ( &__need_wchar_t) || defined ( &_STDDEF_H_)) {
		undef(&_WCHAR_T_) if defined(&_WCHAR_T_);
		undef(&_BSD_WCHAR_T_) if defined(&_BSD_WCHAR_T_);
	    }
	}
	if(defined ( &__sequent__)  && defined ( &_PTRDIFF_T_)) {
	    undef(&_PTRDIFF_T_) if defined(&_PTRDIFF_T_);
	}
	if(defined ( &_TYPE_ptrdiff_t)  && (defined ( &__need_ptrdiff_t) || defined ( &_STDDEF_H_))) {
	    undef(&_TYPE_ptrdiff_t) if defined(&_TYPE_ptrdiff_t);
	}
	if(defined ( &_TYPE_size_t)  && (defined ( &__need_size_t) || defined ( &_STDDEF_H_))) {
	    undef(&_TYPE_size_t) if defined(&_TYPE_size_t);
	}
	if(defined ( &_TYPE_wchar_t)  && (defined ( &__need_wchar_t) || defined ( &_STDDEF_H_))) {
	    undef(&_TYPE_wchar_t) if defined(&_TYPE_wchar_t);
	}
	if(defined ( &_STDDEF_H) || defined ( &__need_ptrdiff_t)) {
	    unless(defined(&_PTRDIFF_T)) {
		unless(defined(&_T_PTRDIFF_)) {
		    unless(defined(&_T_PTRDIFF)) {
			unless(defined(&__PTRDIFF_T)) {
			    unless(defined(&_PTRDIFF_T_)) {
				unless(defined(&_BSD_PTRDIFF_T_)) {
				    unless(defined(&___int_ptrdiff_t_h)) {
					unless(defined(&_GCC_PTRDIFF_T)) {
					    eval 'sub _PTRDIFF_T () {1;}' unless defined(&_PTRDIFF_T);
					    eval 'sub _T_PTRDIFF_ () {1;}' unless defined(&_T_PTRDIFF_);
					    eval 'sub _T_PTRDIFF () {1;}' unless defined(&_T_PTRDIFF);
					    eval 'sub __PTRDIFF_T () {1;}' unless defined(&__PTRDIFF_T);
					    eval 'sub _PTRDIFF_T_ () {1;}' unless defined(&_PTRDIFF_T_);
					    eval 'sub _BSD_PTRDIFF_T_ () {1;}' unless defined(&_BSD_PTRDIFF_T_);
					    eval 'sub ___int_ptrdiff_t_h () {1;}' unless defined(&___int_ptrdiff_t_h);
					    eval 'sub _GCC_PTRDIFF_T () {1;}' unless defined(&_GCC_PTRDIFF_T);
					    unless(defined(&__PTRDIFF_TYPE__)) {
						eval 'sub __PTRDIFF_TYPE__ () {\'long int\';}' unless defined(&__PTRDIFF_TYPE__);
					    }
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	    undef(&__need_ptrdiff_t) if defined(&__need_ptrdiff_t);
	}
	if(defined ( &_STDDEF_H) || defined ( &__need_size_t)) {
	    unless(defined(&__size_t__)) {
		unless(defined(&__SIZE_T__)) {
		    unless(defined(&_SIZE_T)) {
			unless(defined(&_SYS_SIZE_T_H)) {
			    unless(defined(&_T_SIZE_)) {
				unless(defined(&_T_SIZE)) {
				    unless(defined(&__SIZE_T)) {
					unless(defined(&_SIZE_T_)) {
					    unless(defined(&_BSD_SIZE_T_)) {
						unless(defined(&_SIZE_T_DEFINED_)) {
						    unless(defined(&_SIZE_T_DEFINED)) {
							unless(defined(&_BSD_SIZE_T_DEFINED_)) {
							    unless(defined(&_SIZE_T_DECLARED)) {
								unless(defined(&___int_size_t_h)) {
								    unless(defined(&_GCC_SIZE_T)) {
									unless(defined(&_SIZET_)) {
									    unless(defined(&__size_t)) {
										eval 'sub __size_t__ () {1;}' unless defined(&__size_t__);
										eval 'sub __SIZE_T__ () {1;}' unless defined(&__SIZE_T__);
										eval 'sub _SIZE_T () {1;}' unless defined(&_SIZE_T);
										eval 'sub _SYS_SIZE_T_H () {1;}' unless defined(&_SYS_SIZE_T_H);
										eval 'sub _T_SIZE_ () {1;}' unless defined(&_T_SIZE_);
										eval 'sub _T_SIZE () {1;}' unless defined(&_T_SIZE);
										eval 'sub __SIZE_T () {1;}' unless defined(&__SIZE_T);
										eval 'sub _SIZE_T_ () {1;}' unless defined(&_SIZE_T_);
										eval 'sub _BSD_SIZE_T_ () {1;}' unless defined(&_BSD_SIZE_T_);
										eval 'sub _SIZE_T_DEFINED_ () {1;}' unless defined(&_SIZE_T_DEFINED_);
										eval 'sub _SIZE_T_DEFINED () {1;}' unless defined(&_SIZE_T_DEFINED);
										eval 'sub _BSD_SIZE_T_DEFINED_ () {1;}' unless defined(&_BSD_SIZE_T_DEFINED_);
										eval 'sub _SIZE_T_DECLARED () {1;}' unless defined(&_SIZE_T_DECLARED);
										eval 'sub ___int_size_t_h () {1;}' unless defined(&___int_size_t_h);
										eval 'sub _GCC_SIZE_T () {1;}' unless defined(&_GCC_SIZE_T);
										eval 'sub _SIZET_ () {1;}' unless defined(&_SIZET_);
										if(defined ( &__FreeBSD__)  && ((defined(&__FreeBSD__) ? &__FreeBSD__ : undef) >= 5)) {
										} else {
										    eval 'sub __size_t () {1;}' unless defined(&__size_t);
										}
										unless(defined(&__SIZE_TYPE__)) {
										    eval 'sub __SIZE_TYPE__ () {\'long unsigned int\';}' unless defined(&__SIZE_TYPE__);
										}
										if(!(defined ( &__GNUG__)  && defined )) {
										    if(defined(&__BEOS__)) {
										    }
										}
									    }
									}
								    }
								}
							    }
							}
						    }
						}
					    }
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	    undef(&__need_size_t) if defined(&__need_size_t);
	}
	if(defined ( &_STDDEF_H) || defined ( &__need_wchar_t)) {
	    unless(defined(&__wchar_t__)) {
		unless(defined(&__WCHAR_T__)) {
		    unless(defined(&_WCHAR_T)) {
			unless(defined(&_T_WCHAR_)) {
			    unless(defined(&_T_WCHAR)) {
				unless(defined(&__WCHAR_T)) {
				    unless(defined(&_WCHAR_T_)) {
					unless(defined(&_BSD_WCHAR_T_)) {
					    unless(defined(&_BSD_WCHAR_T_DEFINED_)) {
						unless(defined(&_BSD_RUNE_T_DEFINED_)) {
						    unless(defined(&_WCHAR_T_DECLARED)) {
							unless(defined(&_WCHAR_T_DEFINED_)) {
							    unless(defined(&_WCHAR_T_DEFINED)) {
								unless(defined(&_WCHAR_T_H)) {
								    unless(defined(&___int_wchar_t_h)) {
									unless(defined(&__INT_WCHAR_T_H)) {
									    unless(defined(&_GCC_WCHAR_T)) {
										eval 'sub __wchar_t__ () {1;}' unless defined(&__wchar_t__);
										eval 'sub __WCHAR_T__ () {1;}' unless defined(&__WCHAR_T__);
										eval 'sub _WCHAR_T () {1;}' unless defined(&_WCHAR_T);
										eval 'sub _T_WCHAR_ () {1;}' unless defined(&_T_WCHAR_);
										eval 'sub _T_WCHAR () {1;}' unless defined(&_T_WCHAR);
										eval 'sub __WCHAR_T () {1;}' unless defined(&__WCHAR_T);
										eval 'sub _WCHAR_T_ () {1;}' unless defined(&_WCHAR_T_);
										eval 'sub _BSD_WCHAR_T_ () {1;}' unless defined(&_BSD_WCHAR_T_);
										eval 'sub _WCHAR_T_DEFINED_ () {1;}' unless defined(&_WCHAR_T_DEFINED_);
										eval 'sub _WCHAR_T_DEFINED () {1;}' unless defined(&_WCHAR_T_DEFINED);
										eval 'sub _WCHAR_T_H () {1;}' unless defined(&_WCHAR_T_H);
										eval 'sub ___int_wchar_t_h () {1;}' unless defined(&___int_wchar_t_h);
										eval 'sub __INT_WCHAR_T_H () {1;}' unless defined(&__INT_WCHAR_T_H);
										eval 'sub _GCC_WCHAR_T () {1;}' unless defined(&_GCC_WCHAR_T);
										eval 'sub _WCHAR_T_DECLARED () {1;}' unless defined(&_WCHAR_T_DECLARED);
										if(defined(&_BSD_WCHAR_T_)) {
										    undef(&_BSD_WCHAR_T_) if defined(&_BSD_WCHAR_T_);
										    if(defined(&_BSD_RUNE_T_)) {
											if(!defined ( &_ANSI_SOURCE)  && !defined ( &_POSIX_SOURCE)) {
											    eval 'sub _BSD_WCHAR_T_DEFINED_ () {1;}' unless defined(&_BSD_WCHAR_T_DEFINED_);
											    eval 'sub _BSD_RUNE_T_DEFINED_ () {1;}' unless defined(&_BSD_RUNE_T_DEFINED_);
											    if(defined ( &__FreeBSD__)  && ((defined(&__FreeBSD__) ? &__FreeBSD__ : undef) < 5)) {
												undef(&_BSD_RUNE_T_) if defined(&_BSD_RUNE_T_);
											    }
											}
										    }
										}
										if(defined ( &__FreeBSD__)  && ((defined(&__FreeBSD__) ? &__FreeBSD__ : undef) >= 5)) {
										    if(!defined ( &_ANSI_SOURCE)  && !defined ( &_POSIX_SOURCE)) {
											if((defined(&__BSD_VISIBLE) ? &__BSD_VISIBLE : undef)) {
											    unless(defined(&_RUNE_T_DECLARED)) {
												eval 'sub _RUNE_T_DECLARED () {1;}' unless defined(&_RUNE_T_DECLARED);
											    }
											}
										    }
										}
										unless(defined(&__WCHAR_TYPE__)) {
										    eval 'sub __WCHAR_TYPE__ () {\'int\';}' unless defined(&__WCHAR_TYPE__);
										}
										unless(defined(&__cplusplus)) {
										}
									    }
									}
								    }
								}
							    }
							}
						    }
						}
					    }
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	    undef(&__need_wchar_t) if defined(&__need_wchar_t);
	}
	if(defined ( &__need_wint_t)) {
	    unless(defined(&_WINT_T)) {
		eval 'sub _WINT_T () {1;}' unless defined(&_WINT_T);
		unless(defined(&__WINT_TYPE__)) {
		    eval 'sub __WINT_TYPE__ () {\'unsigned int\';}' unless defined(&__WINT_TYPE__);
		}
	    }
	    undef(&__need_wint_t) if defined(&__need_wint_t);
	}
	if(defined( &_ANSI_H_) || defined( &_MACHINE_ANSI_H_)) {
	    if(defined(&_GCC_PTRDIFF_T_)) {
		undef(&_PTRDIFF_T_) if defined(&_PTRDIFF_T_);
		undef(&_BSD_PTRDIFF_T_) if defined(&_BSD_PTRDIFF_T_);
	    }
	    if(defined(&_GCC_SIZE_T_)) {
		undef(&_SIZE_T_) if defined(&_SIZE_T_);
		undef(&_BSD_SIZE_T_) if defined(&_BSD_SIZE_T_);
	    }
	    if(defined(&_GCC_WCHAR_T_)) {
		undef(&_WCHAR_T_) if defined(&_WCHAR_T_);
		undef(&_BSD_WCHAR_T_) if defined(&_BSD_WCHAR_T_);
	    }
	    if(defined(&_GCC_PTRDIFF_T)) {
		undef(&_PTRDIFF_T_) if defined(&_PTRDIFF_T_);
		undef(&_BSD_PTRDIFF_T_) if defined(&_BSD_PTRDIFF_T_);
	    }
	    if(defined(&_GCC_SIZE_T)) {
		undef(&_SIZE_T_) if defined(&_SIZE_T_);
		undef(&_BSD_SIZE_T_) if defined(&_BSD_SIZE_T_);
	    }
	    if(defined(&_GCC_WCHAR_T)) {
		undef(&_WCHAR_T_) if defined(&_WCHAR_T_);
		undef(&_BSD_WCHAR_T_) if defined(&_BSD_WCHAR_T_);
	    }
	}
    }
    if(defined ( &_STDDEF_H) || defined ( &__need_NULL)) {
	undef(&NULL) if defined(&NULL);
	if(defined(&__GNUG__)) {
	    eval 'sub NULL () { &__null;}' unless defined(&NULL);
	} else {
	    unless(defined(&__cplusplus)) {
		eval 'sub NULL () {(( &void *)0);}' unless defined(&NULL);
	    } else {
		eval 'sub NULL () {0;}' unless defined(&NULL);
	    }
	}
    }
    undef(&__need_NULL) if defined(&__need_NULL);
    if(defined(&_STDDEF_H)) {
	eval 'sub offsetof {
	    my($TYPE, $MEMBER) = @_;
    	    eval q( &__builtin_offsetof ($TYPE, $MEMBER));
	}' unless defined(&offsetof);
    }
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                package Opcode;

use 5.006_001;

use strict;

our($VERSION, $XS_VERSION, @ISA, @EXPORT_OK);

$VERSION = "1.06";
$XS_VERSION = "1.03";

use Carp;
use Exporter ();
use XSLoader ();

BEGIN {
    @ISA = qw(Exporter);
    @EXPORT_OK = qw(
	opset ops_to_opset
	opset_to_ops opset_to_hex invert_opset
	empty_opset full_opset
	opdesc opcodes opmask define_optag
	opmask_add verify_opset opdump
    );
}

sub opset (;@);
sub opset_to_hex ($);
sub opdump (;$);
use subs @EXPORT_OK;

XSLoader::load 'Opcode', $XS_VERSION;

_init_optags();

sub ops_to_opset { opset @_ }	# alias for old name

sub opset_to_hex ($) {
    return "(invalid opset)" unless verify_opset($_[0]);
    unpack("h*",$_[0]);
}

sub opdump (;$) {
	my $pat = shift;
    # handy utility: perl -MOpcode=opdump -e 'opdump File'
    foreach(opset_to_ops(full_opset)) {
        my $op = sprintf "  %12s  %s\n", $_, opdesc($_);
		next if defined $pat and $op !~ m/$pat/i;
		print $op;
    }
}



sub _init_optags {
    my(%all, %seen);
    @all{opset_to_ops(full_opset)} = (); # keys only

    local($_);
    local($/) = "\n=cut"; # skip to optags definition section
    <DATA>;
    $/ = "\n=";		# now read in 'pod section' chunks
    while(<DATA>) {
	next unless m/^item\s+(:\w+)/;
	my $tag = $1;

	# Split into lines, keep only indented lines
	my @lines = grep { m/^\s/    } split(/\n/);
	foreach (@lines) { s/--.*//  } # delete comments
	my @ops   = map  { split ' ' } @lines; # get op words

	foreach(@ops) {
	    warn "$tag - $_ already tagged in $seen{$_}\n" if $seen{$_};
	    $seen{$_} = $tag;
	    delete $all{$_};
	}
	# opset will croak on invalid names
	define_optag($tag, opset(@ops));
    }
    close(DATA);
    warn "Untagged opnames: ".join(' ',keys %all)."\n" if %all;
}


1;

__DATA__

=head1 NAME

Opcode - Disable named opcodes when compiling perl code

=head1 SYNOPSIS

  use Opcode;


=head1 DESCRIPTION

Perl code is always compiled into an internal format before execution.

Evaluating perl code (e.g. via "eval" or "do 'file'") causes
the code to be compiled into an internal format and then,
provided there was no error in the compilation, executed.
The internal format is based on many distinct I<opcodes>.

By default no opmask is in effect and any code can be compiled.

The Opcode module allow you to define an I<operator mask> to be in
effect when perl I<next> compiles any code.  Attempting to compile code
which contains a masked opcode will cause the compilation to fail
with an error. The code will not be executed.

=head1 NOTE

The Opcode module is not usually used directly. See the ops pragma and
Safe modules for more typical uses.

=head1 WARNING

The authors make B<no warranty>, implied or otherwise, about the
suitability of this software for safety or security purposes.

The authors shall not in any case be liable for special, incidental,
consequential, indirect or other similar damages arising from the use
of this software.

Your mileage will vary. If in any doubt B<do not use it>.


=head1 Operator Names and Operator Lists

The canonical list of operator names is the contents of the array
PL_op_name defined and initialised in file F<opcode.h> of the Perl
source distribution (and installed into the perl library).

Each operator has both a terse name (its opname) and a more verbose or
recognisable descriptive name. The opdesc function can be used to
return a list of descriptions for a list of operators.

Many of the functions and methods listed below take a list of
operators as parameters. Most operator lists can be made up of several
types of element. Each element can be one of

=over 8

=item an operator name (opname)

Operator names are typically small lowercase words like enterloop,
leaveloop, last, next, redo etc. Sometimes they are rather cryptic
like gv2cv, i_ncmp and ftsvtx.

=item an operator tag name (optag)

Operator tags can be used to refer to groups (or sets) of operators.
Tag names always begin with a colon. The Opcode module defines several
optags and the user can define others using the define_optag function.

=item a negated opname or optag

An opname or optag can be prefixed with an exclamation mark, e.g., !mkdir.
Negating an opname or optag means remove the corresponding ops from the
accumulated set of ops at that point.

=item an operator set (opset)

An I<opset> as a binary string of approximately 44 bytes which holds a
set or zero or more operators.

The opset and opset_to_ops functions can be used to convert from
a list of operators to an opset and I<vice versa>.

Wherever a list of operators can be given you can use one or more opsets.
See also Manipulating Opsets below.

=back


=head1 Opcode Functions

The Opcode package contains functions for manipulating operator names
tags and sets. All are available for export by the package.

=over 8

=item opcodes

In a scalar context opcodes returns the number of opcodes in this
version of perl (around 350 for perl-5.7.0).

In a list context it returns a list of all the operator names.
(Not yet implemented, use @names = opset_to_ops(full_opset).)

=item opset (OP, ...)

Returns an opset containing the listed operators.

=item opset_to_ops (OPSET)

Returns a list of operator names corresponding to those operators in
the set.

=item opset_to_hex (OPSET)

Returns a string representation of an opset. Can be handy for debugging.

=item full_opset

Returns an opset which includes all operators.

=item empty_opset

Returns an opset which contains no operators.

=item invert_opset (OPSET)

Returns an opset which is the inverse set of the one supplied.

=item verify_opset (OPSET, ...)

Returns true if the supplied opset looks like a valid opset (is the
right length etc) otherwise it returns false. If an optional second
parameter is true then verify_opset will croak on an invalid opset
instead of returning false.

Most of the other Opcode functions call verify_opset automatically
and will croak if given an invalid opset.

=item define_optag (OPTAG, OPSET)

Define OPTAG as a symbolic name for OPSET. Optag names always start
with a colon C<:>.

The optag name used must not be defined already (define_optag will
croak if it is already defined). Optag names are global to the perl
process and optag definitions cannot be altered or deleted once
defined.

It is strongly recommended that applications using Opcode should use a
leading capital letter on their tag names since lowercase names are
reserved for use by the Opcode module. If using Opcode within a module
you should prefix your tags names with the name of your module to
ensure uniqueness and thus avoid clashes with other modules.

=item opmask_add (OPSET)

Adds the supplied opset to the current opmask. Note that there is
currently I<no> mechanism for unmasking ops once they have been masked.
This is intentional.

=item opmask

Returns an opset corresponding to the current opmask.

=item opdesc (OP, ...)

This takes a list of operator names and returns the corresponding list
of operator descriptions.

=item opdump (PAT)

Dumps to STDOUT a two column list of op names and op descriptions.
If an optional pattern is given then only lines which match the
(case insensitive) pattern will be output.

It's designed to be used as a handy command line utility:

	perl -MOpcode=opdump -e opdump
	perl -MOpcode=opdump -e 'opdump Eval'

=back

=head1 Manipulating Opsets

Opsets may be manipulated using the perl bit vector operators & (and), | (or),
^ (xor) and ~ (negate/invert).

However you should never rely on the numerical position of any opcode
within the opset. In other words both sides of a bit vector operator
should be opsets returned from Opcode functions.

Also, since the number of opcodes in your current version of perl might
not be an exact multiple of eight, there may be unused bits in the last
byte of an upset. This should not cause any problems (Opcode functions
ignore those extra bits) but it does mean that using the ~ operator
will typically not produce the same 'physical' opset 'string' as the
invert_opset function.


=head1 TO DO (maybe)

    $bool = opset_eq($opset1, $opset2)	true if opsets are logically eqiv

    $yes = opset_can($opset, @ops)	true if $opset has all @ops set

    @diff = opset_diff($opset1, $opset2) => ('foo', '!bar', ...)

=cut

# the =cut above is used by _init_optags() to get here quickly

=head1 Predefined Opcode Tags

=over 5

=item :base_core

    null stub scalar pushmark wantarray const defined undef

    rv2sv sassign

    rv2av aassign aelem aelemfast aslice av2arylen

    rv2hv helem hslice each values keys exists delete

    preinc i_preinc predec i_predec postinc i_postinc postdec i_postdec
    int hex oct abs pow multiply i_multiply divide i_divide
    modulo i_modulo add i_add subtract i_subtract

    left_shift right_shift bit_and bit_xor bit_or negate i_negate
    not complement

    lt i_lt gt i_gt le i_le ge i_ge eq i_eq ne i_ne ncmp i_ncmp
    slt sgt sle sge seq sne scmp

    substr vec stringify study pos length index rindex ord chr

    ucfirst lcfirst uc lc quotemeta trans chop schop chomp schomp

    match split qr

    list lslice splice push pop shift unshift reverse

    cond_expr flip flop andassign orassign and or xor

    warn die lineseq nextstate scope enter leave setstate

    rv2cv anoncode prototype

    entersub leavesub leavesublv return method method_named -- XXX loops via recursion?

    leaveeval -- needed for Safe to operate, is safe without entereval

=item :base_mem

These memory related ops are not included in :base_core because they
can easily be used to implement a resource attack (e.g., consume all
available memory).

    concat repeat join range

    anonlist anonhash

Note that despite the existence of this optag a memory resource attack
may still be possible using only :base_core ops.

Disabling these ops is a I<very> heavy handed way to attempt to prevent
a memory resource attack. It's probable that a specific memory limit
mechanism will be added to perl in the near future.

=item :base_loop

These loop ops are not included in :base_core because they can easily be
used to implement a resource attack (e.g., consume all available CPU time).

    grepstart grepwhile
    mapstart mapwhile
    enteriter iter
    enterloop leaveloop unstack
    last next redo
    goto

=item :base_io

These ops enable I<filehandle> (rather than filename) based input and
output. These are safe on the assumption that only pre-existing
filehandles are available for use.  To create new filehandles other ops
such as open would need to be enabled.

    readline rcatline getc read

    formline enterwrite leavewrite

    print sysread syswrite send recv

    eof tell seek sysseek

    readdir telldir seekdir rewinddir

=item :base_orig

These are a hotchpotch of opcodes still waiting to be considered

    gvsv gv gelem

    padsv padav padhv padany

    rv2gv refgen srefgen ref

    bless -- could be used to change ownership of objects (reblessing)

    pushre regcmaybe regcreset regcomp subst substcont

    sprintf prtf -- can core dump

    crypt

    tie untie

    dbmopen dbmclose
    sselect select
    pipe_op sockpair

    getppid getpgrp setpgrp getpriority setpriority localtime gmtime

    entertry leavetry -- can be used to 'hide' fatal errors

    custom -- where should this go

=item :base_math

These ops are not included in :base_core because of the risk of them being
used to generate floating point exceptions (which would have to be caught
using a $SIG{FPE} handler).

    atan2 sin cos exp log sqrt

These ops are not included in :base_core because they have an effect
beyond the scope of the compartment.

    rand srand

=item :base_thread

These ops are related to multi-threading.

    lock threadsv

=item :default

A handy tag name for a I<reasonable> default set of ops.  (The current ops
allowed are unstable while development continues. It will change.)

    :base_core :base_mem :base_loop :base_io :base_orig :base_thread

If safety matters to you (and why else would you be using the Opcode module?)
then you should not rely on the definition of this, or indeed any other, optag!


=item :filesys_read

    stat lstat readlink

    ftatime ftblk ftchr ftctime ftdir fteexec fteowned fteread
    ftewrite ftfile ftis ftlink ftmtime ftpipe ftrexec ftrowned
    ftrread ftsgid ftsize ftsock ftsuid fttty ftzero ftrwrite ftsvtx

    fttext ftbinary

    fileno

=item :sys_db

    ghbyname ghbyaddr ghostent shostent ehostent      -- hosts
    gnbyname gnbyaddr gnetent snetent enetent         -- networks
    gpbyname gpbynumber gprotoent sprotoent eprotoent -- protocols
    gsbyname gsbyport gservent sservent eservent      -- services

    gpwnam gpwuid gpwent spwent epwent getlogin       -- users
    ggrnam ggrgid ggrent sgrent egrent                -- groups

=item :browse

A handy tag name for a I<reasonable> default set of ops beyond the
:default optag.  Like :default (and indeed all the other optags) its
current definition is unstable while development continues. It will change.

The :browse tag represents the next step beyond :default. It it a
superset of the :default ops and adds :filesys_read the :sys_db.
The intent being that scripts can access more (possibly sensitive)
information about your system but not be able to change it.

    :default :filesys_read :sys_db

=item :filesys_open

    sysopen open close
    umask binmode

    open_dir closedir -- other dir ops are in :base_io

=item :filesys_write

    link unlink rename symlink truncate

    mkdir rmdir

    utime chmod chown

    fcntl -- not strictly filesys related, but possibly as dangerous?

=item :subprocess

    backtick system

    fork

    wait waitpid

    glob -- access to Cshell via <`rm *`>

=item :ownprocess

    exec exit kill

    time tms -- could be used for timing attacks (paranoid?)

=item :others

This tag holds groups of assorted specialist opcodes that don't warrant
having optags defined for them.

SystemV Interprocess Communications:

    msgctl msgget msgrcv msgsnd

    semctl semget semop

    shmctl shmget shmread shmwrite

=item :still_to_be_decided

    chdir
    flock ioctl

    socket getpeername ssockopt
    bind connect listen accept shutdown gsockopt getsockname

    sleep alarm -- changes global timer state and signal handling
    sort -- assorted problems including core dumps
    tied -- can be used to access object implementing a tie
    pack unpack -- can be used to create/use memory pointers

    entereval -- can be used to hide code from initial compile
    require dofile 

    caller -- get info about calling environment and args

    reset

    dbstate -- perl -d version of nextstate(ment) opcode

=item :dangerous

This tag is simply a bucket for opcodes that are unlikely to be used via
a tag name but need to be tagged for completeness and documentation.

    syscall dump chroot


=back

=head1 SEE ALSO

ops(3) -- perl pragma interface to Opcode module.

Safe(3) -- Opcode and namespace limited execution compartments

=head1 AUTHORS

Originally designed and implemented by Malcolm Beattie,
mbeattie@sable.ox.ac.uk as part of Safe version 1.

Split out from Safe module version 1, named opcode tags and other
changes added by Tim Bunce.

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # This file was created by h2ph version 2
unless (defined &_FILE_OFFSET_BITS) { sub _FILE_OFFSET_BITS() { 64 } }

unless (defined &_GNU_SOURCE) { sub _GNU_SOURCE() { 1 } }

unless (defined &_LARGEFILE64_SOURCE) { sub _LARGEFILE64_SOURCE() { 1 } }

unless (defined &_LARGEFILE_SOURCE) { sub _LARGEFILE_SOURCE() { 1 } }

unless (defined &_POSIX_C_SOURCE) { sub _POSIX_C_SOURCE() { 200112 } }

unless (defined &_POSIX_SOURCE) { sub _POSIX_SOURCE() { 1 } }

unless (defined &_REENTRANT) { sub _REENTRANT() { 1 } }

unless (defined &_XOPEN_SOURCE) { sub _XOPEN_SOURCE() { 600 } }

unless (defined &_XOPEN_SOURCE_EXTENDED) { sub _XOPEN_SOURCE_EXTENDED() { 1 } }

unless (defined &__CHAR_BIT__) { sub __CHAR_BIT__() { 8 } }

unless (defined &__DBL_DENORM_MIN__) { sub __DBL_DENORM_MIN__() { 4.9406564584124654e-324 } }

unless (defined &__DBL_DIG__) { sub __DBL_DIG__() { 15 } }

unless (defined &__DBL_EPSILON__) { sub __DBL_EPSILON__() { 2.2204460492503131e-16 } }

unless (defined &__DBL_HAS_INFINITY__) { sub __DBL_HAS_INFINITY__() { 1 } }

unless (defined &__DBL_HAS_QUIET_NAN__) { sub __DBL_HAS_QUIET_NAN__() { 1 } }

unless (defined &__DBL_MANT_DIG__) { sub __DBL_MANT_DIG__() { 53 } }

unless (defined &__DBL_MAX_10_EXP__) { sub __DBL_MAX_10_EXP__() { 308 } }

unless (defined &__DBL_MAX_EXP__) { sub __DBL_MAX_EXP__() { 1024 } }

unless (defined &__DBL_MAX__) { sub __DBL_MAX__() { 1.7976931348623157e+308 } }

unless (defined &__DBL_MIN_10_EXP__) { sub __DBL_MIN_10_EXP__() { -307 } }

unless (defined &__DBL_MIN_EXP__) { sub __DBL_MIN_EXP__() { -1021 } }

unless (defined &__DBL_MIN__) { sub __DBL_MIN__() { 2.2250738585072014e-308 } }

unless (defined &__DECIMAL_DIG__) { sub __DECIMAL_DIG__() { 21 } }

unless (defined &__ELF__) { sub __ELF__() { 1 } }

unless (defined &__FINITE_MATH_ONLY__) { sub __FINITE_MATH_ONLY__() { 0 } }

unless (defined &__FLT_DENORM_MIN__) { sub __FLT_DENORM_MIN__() { 1.40129846e-45 } }

unless (defined &__FLT_DIG__) { sub __FLT_DIG__() { 6 } }

unless (defined &__FLT_EPSILON__) { sub __FLT_EPSILON__() { 1.19209290e-7 } }

unless (defined &__FLT_EVAL_METHOD__) { sub __FLT_EVAL_METHOD__() { 2 } }

unless (defined &__FLT_HAS_INFINITY__) { sub __FLT_HAS_INFINITY__() { 1 } }

unless (defined &__FLT_HAS_QUIET_NAN__) { sub __FLT_HAS_QUIET_NAN__() { 1 } }

unless (defined &__FLT_MANT_DIG__) { sub __FLT_MANT_DIG__() { 24 } }

unless (defined &__FLT_MAX_10_EXP__) { sub __FLT_MAX_10_EXP__() { 38 } }

unless (defined &__FLT_MAX_EXP__) { sub __FLT_MAX_EXP__() { 128 } }

unless (defined &__FLT_MAX__) { sub __FLT_MAX__() { 3.40282347e+38 } }

unless (defined &__FLT_MIN_10_EXP__) { sub __FLT_MIN_10_EXP__() { -37 } }

unless (defined &__FLT_MIN_EXP__) { sub __FLT_MIN_EXP__() { -125 } }

unless (defined &__FLT_MIN__) { sub __FLT_MIN__() { 1.17549435e-38 } }

unless (defined &__FLT_RADIX__) { sub __FLT_RADIX__() { 2 } }

unless (defined &__GLIBC_MINOR__) { sub __GLIBC_MINOR__() { 5 } }

unless (defined &__GLIBC__) { sub __GLIBC__() { 2 } }

unless (defined &__GNUC_GNU_INLINE__) { sub __GNUC_GNU_INLINE__() { 1 } }

unless (defined &__GNUC_MINOR__) { sub __GNUC_MINOR__() { 1 } }

unless (defined &__GNUC_PATCHLEVEL__) { sub __GNUC_PATCHLEVEL__() { 2 } }

unless (defined &__GNUC_RH_RELEASE__) { sub __GNUC_RH_RELEASE__() { 48 } }

unless (defined &__GNUC__) { sub __GNUC__() { 4 } }

unless (defined &__GNU_LIBRARY__) { sub __GNU_LIBRARY__() { 6 } }

unless (defined &__GXX_ABI_VERSION) { sub __GXX_ABI_VERSION() { 1002 } }

unless (defined &__INTMAX_MAX__) { sub __INTMAX_MAX__() { 9223372036854775807 } }

unless (defined &__INTMAX_TYPE__) { sub __INTMAX_TYPE__() { "long\\\ long\\\ int" } }

unless (defined &__INT_MAX__) { sub __INT_MAX__() { 2147483647 } }

unless (defined &__LDBL_DENORM_MIN__) { sub __LDBL_DENORM_MIN__() { 3.64519953188247460253e-4951 } }

unless (defined &__LDBL_DIG__) { sub __LDBL_DIG__() { 18 } }

unless (defined &__LDBL_EPSILON__) { sub __LDBL_EPSILON__() { 1.08420217248550443401e-19 } }

unless (defined &__LDBL_HAS_INFINITY__) { sub __LDBL_HAS_INFINITY__() { 1 } }

unless (defined &__LDBL_HAS_QUIET_NAN__) { sub __LDBL_HAS_QUIET_NAN__() { 1 } }

unless (defined &__LDBL_MANT_DIG__) { sub __LDBL_MANT_DIG__() { 64 } }

unless (defined &__LDBL_MAX_10_EXP__) { sub __LDBL_MAX_10_EXP__() { 4932 } }

unless (defined &__LDBL_MAX_EXP__) { sub __LDBL_MAX_EXP__() { 16384 } }

unless (defined &__LDBL_MAX__) { sub __LDBL_MAX__() { 1.18973149535723176502e+4932 } }

unless (defined &__LDBL_MIN_10_EXP__) { sub __LDBL_MIN_10_EXP__() { -4931 } }

unless (defined &__LDBL_MIN_EXP__) { sub __LDBL_MIN_EXP__() { -16381 } }

unless (defined &__LDBL_MIN__) { sub __LDBL_MIN__() { 3.36210314311209350626e-4932 } }

unless (defined &__LONG_LONG_MAX__) { sub __LONG_LONG_MAX__() { 9223372036854775807 } }

unless (defined &__LONG_MAX__) { sub __LONG_MAX__() { 2147483647 } }

unless (defined &__PTRDIFF_TYPE__) { sub __PTRDIFF_TYPE__() { &int } }

unless (defined &__SCHAR_MAX__) { sub __SCHAR_MAX__() { 127 } }

unless (defined &__SHRT_MAX__) { sub __SHRT_MAX__() { 32767 } }

unless (defined &__SIZE_TYPE__) { sub __SIZE_TYPE__() { "unsigned\\\ int" } }

unless (defined &__STDC_HOSTED__) { sub __STDC_HOSTED__() { 1 } }

unless (defined &__STDC__) { sub __STDC__() { 1 } }

unless (defined &__UINTMAX_TYPE__) { sub __UINTMAX_TYPE__() { "long\\\ long\\\ unsigned\\\ int" } }

unless (defined &__USE_BSD) { sub __USE_BSD() { 1 } }

unless (defined &__USE_FILE_OFFSET64) { sub __USE_FILE_OFFSET64() { 1 } }

unless (defined &__USE_GNU) { sub __USE_GNU() { 1 } }

unless (defined &__USE_LARGEFILE) { sub __USE_LARGEFILE() { 1 } }

unless (defined &__USE_LARGEFILE64) { sub __USE_LARGEFILE64() { 1 } }

unless (defined &__USE_MISC) { sub __USE_MISC() { 1 } }

unless (defined &__USE_POSIX) { sub __USE_POSIX() { 1 } }

unless (defined &__USE_POSIX199309) { sub __USE_POSIX199309() { 1 } }

unless (defined &__USE_POSIX199506) { sub __USE_POSIX199506() { 1 } }

unless (defined &__USE_POSIX2) { sub __USE_POSIX2() { 1 } }

unless (defined &__USE_REENTRANT) { sub __USE_REENTRANT() { 1 } }

unless (defined &__USE_SVID) { sub __USE_SVID() { 1 } }

unless (defined &__USE_UNIX98) { sub __USE_UNIX98() { 1 } }

unless (defined &__USE_XOPEN) { sub __USE_XOPEN() { 1 } }

unless (defined &__USE_XOPEN_EXTENDED) { sub __USE_XOPEN_EXTENDED() { 1 } }

unless (defined &__VERSION__) { sub __VERSION__() { "\"4\.1\.2\\\ 20080704\\\ \(Red\\\ Hat\\\ 4\.1\.2\-48\)\"" } }

unless (defined &__WCHAR_MAX__) { sub __WCHAR_MAX__() { 2147483647 } }

unless (defined &__WCHAR_TYPE__) { sub __WCHAR_TYPE__() { "long\\\ int" } }

unless (defined &__WINT_TYPE__) { sub __WINT_TYPE__() { "unsigned\\\ int" } }

unless (defined &__gnu_linux__) { sub __gnu_linux__() { 1 } }

unless (defined &__i386) { sub __i386() { 1 } }

unless (defined &__i386__) { sub __i386__() { 1 } }

unless (defined &__linux) { sub __linux() { 1 } }

unless (defined &__linux__) { sub __linux__() { 1 } }

unless (defined &__unix) { sub __unix() { 1 } }

unless (defined &__unix__) { sub __unix__() { 1 } }

unless (defined &i386) { sub i386() { 1 } }

unless (defined &linux) { sub linux() { 1 } }

unless (defined &unix) { sub unix() { 1 } }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  package threads;

use 5.008;
use strict;
use warnings;
use Config;

BEGIN {
    unless ($Config{useithreads}) {
	my @caller = caller(2);
        die <<EOF;
$caller[1] line $caller[2]:

This Perl hasn't been configured and built properly for the threads
module to work.  (The 'useithreads' configuration option hasn't been used.)

Having threads support requires all of Perl and all of the XS modules in
the Perl installation to be rebuilt, it is not just a question of adding
the threads module.  (In other words, threaded and non-threaded Perls
are binary incompatible.)

If you want to the use the threads module, please contact the people
who built your Perl.

Cannot continue, aborting.
EOF
    }
}

use overload
    '==' => \&equal,
    'fallback' => 1;

BEGIN {
    warn "Warning, threads::shared has already been loaded. ".
       "To enable shared variables for these modules 'use threads' ".
       "must be called before any of those modules are loaded\n"
               if($threads::shared::threads_shared);
}

require Exporter;
require DynaLoader;

our @ISA = qw(Exporter DynaLoader);

our %EXPORT_TAGS = ( all => [qw(yield)]);

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw(
async	
);
our $VERSION = '1.07';


# || 0 to ensure compatibility with previous versions
sub equal { ($_[0]->tid == $_[1]->tid) || 0 }

# use "goto" trick to avoid pad problems from 5.8.1 (fixed in 5.8.2)
# should also be faster
sub async (&;@) { unshift @_,'threads'; goto &new }

sub object {
    return undef unless @_ > 1;
    foreach (threads->list) {
        return $_ if $_->tid == $_[1];
    }
    return undef;
}

$threads::threads = 1;

bootstrap threads $VERSION;

# why document 'new' then use 'create' in the tests!
*create = \&new;

# Preloaded methods go here.

1;
__END__

=head1 NAME

threads - Perl extension allowing use of interpreter based threads from perl

=head1 SYNOPSIS

    use threads;

    sub start_thread {
	print "Thread started\n";
    }

    my $thread  = threads->create("start_thread","argument");
    my $thread2 = $thread->create(sub { print "I am a thread"},"argument");
    my $thread3 = async { foreach (@files) { ... } };

    $thread->join();
    $thread->detach();

    $thread = threads->self();
    $thread = threads->object( $tid );

    $thread->tid();
    threads->tid();
    threads->self->tid();

    threads->yield();

    threads->list();

=head1 DESCRIPTION

Perl 5.6 introduced something called interpreter threads.  Interpreter
threads are different from "5005threads" (the thread model of Perl
5.005) by creating a new perl interpreter per thread and not sharing
any data or state between threads by default.

Prior to perl 5.8 this has only been available to people embedding
perl and for emulating fork() on windows.

The threads API is loosely based on the old Thread.pm API. It is very
important to note that variables are not shared between threads, all
variables are per default thread local.  To use shared variables one
must use threads::shared.

It is also important to note that you must enable threads by doing
C<use threads> as early as possible in the script itself and that it
is not possible to enable threading inside an C<eval "">, C<do>,
C<require>, or C<use>.  In particular, if you are intending to share
variables with threads::shared, you must C<use threads> before you
C<use threads::shared> and C<threads> will emit a warning if you do
it the other way around.

=over

=item $thread = threads->create(function, LIST)

This will create a new thread with the entry point function and give
it LIST as parameters.  It will return the corresponding threads
object, or C<undef> if thread creation failed. The new() method is an
alias for create().

=item $thread->join

This will wait for the corresponding thread to join. When the thread
finishes, join() will return the return values of the entry point
function. If the thread has been detached, an error will be thrown.

The context (void, scalar or list) of the thread creation is also the
context for join().  This means that if you intend to return an array
from a thread, you must use C<my ($thread) = threads->new(...)>, and
that if you intend to return a scalar, you must use C<my $thread = ...>.

If the program exits without all other threads having been either
joined or detached, then a warning will be issued. (A program exits
either because one of its threads explicitly calls exit(), or in the
case of the main thread, reaches the end of the main program file.)


=item $thread->detach

Will make the thread unjoinable, and cause any eventual return value
to be discarded.

=item threads->self

This will return the thread object for the current thread.

=item $thread->tid

This will return the id of the thread.  Thread IDs are integers, with
the main thread in a program being 0.  Currently Perl assigns a unique
tid to every thread ever created in your program, assigning the first
thread to be created a tid of 1, and increasing the tid by 1 for each
new thread that's created.

NB the class method C<< threads->tid() >> is a quick way to get the
current thread id if you don't have your thread object handy.

=item threads->object( tid )

This will return the thread object for the thread associated with the
specified tid.  Returns undef if there is no thread associated with the tid
or no tid is specified or the specified tid is undef.

=item threads->yield();

This is a suggestion to the OS to let this thread yield CPU time to other
threads.  What actually happens is highly dependent upon the underlying
thread implementation.

You may do C<use threads qw(yield)> then use just a bare C<yield> in your
code.

=item threads->list();

This will return a list of all non joined, non detached threads.

=item async BLOCK;

C<async> creates a thread to execute the block immediately following
it.  This block is treated as an anonymous sub, and so must have a
semi-colon after the closing brace. Like C<< threads->new >>, C<async>
returns a thread object.

=back

=head1 WARNINGS

=over 4

=item A thread exited while %d other threads were still running

A thread (not necessarily the main thread) exited while there were
still other threads running.  Usually it's a good idea to first collect
the return values of the created threads by joining them, and only then
exit from the main thread.

=back

=head1 TODO

The current implementation of threads has been an attempt to get
a correct threading system working that could be built on, 
and optimized, in newer versions of perl.

Currently the overhead of creating a thread is rather large,
also the cost of returning values can be large. These are areas
were there most likely will be work done to optimize what data
that needs to be cloned.

=head1 BUGS

=over

=item Parent-Child threads.

On some platforms it might not be possible to destroy "parent"
threads while there are still existing child "threads".

This will possibly be fixed in later versions of perl.

=item tid is I32

The thread id is a 32 bit integer, it can potentially overflow.
This might be fixed in a later version of perl.

=item Returning objects

When you return an object the entire stash that the object is blessed
as well.  This will lead to a large memory usage.  The ideal situation
would be to detect the original stash if it existed.

=item Creating threads inside BEGIN blocks

Creating threads inside BEGIN blocks (or during the compilation phase
in general) does not work.  (In Windows, trying to use fork() inside
BEGIN blocks is an equally losing proposition, since it has been
implemented in very much the same way as threads.)

=item PERL_OLD_SIGNALS are not threadsafe, will not be.

If your Perl has been built with PERL_OLD_SIGNALS (one has
to explicitly add that symbol to ccflags, see C<perl -V>),
signal handling is not threadsafe.

=back

=head1 AUTHOR and COPYRIGHT

Arthur Bergman E<lt>sky at nanisky.comE<gt>

threads is released under the same license as Perl.

Thanks to

Richard Soderberg E<lt>perl at crystalflame.netE<gt>
Helping me out tons, trying to find reasons for races and other weird bugs!

Simon Cozens E<lt>simon at brecon.co.ukE<gt>
Being there to answer zillions of annoying questions

Rocco Caputo E<lt>troc at netrus.netE<gt>

Vipul Ved Prakash E<lt>mail at vipul.netE<gt>
Helping with debugging.

please join perl-ithreads@perl.org for more information

=head1 SEE ALSO

L<threads::shared>, L<perlthrtut>, 
L<http://www.perl.com/pub/a/2002/06/11/threads.html>,
L<perlcall>, L<perlembed>, L<perlguts>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
# Generated from DynaLoader.pm.PL

package DynaLoader;

#   And Gandalf said: 'Many folk like to know beforehand what is to
#   be set on the table; but those who have laboured to prepare the
#   feast like to keep their secret; for wonder makes the words of
#   praise louder.'

#   (Quote from Tolkien suggested by Anno Siegel.)
#
# See pod text at end of file for documentation.
# See also ext/DynaLoader/README in source tree for other information.
#
# Tim.Bunce@ig.co.uk, August 1994

use vars qw($VERSION *AUTOLOAD);

$VERSION = '1.05';	# avoid typo warning

require AutoLoader;
*AUTOLOAD = \&AutoLoader::AUTOLOAD;

use Config;

# The following require can't be removed during maintenance
# releases, sadly, because of the risk of buggy code that does 
# require Carp; Carp::croak "..."; without brackets dying 
# if Carp hasn't been loaded in earlier compile time. :-( 
# We'll let those bugs get found on the development track.
require Carp if $] < 5.00450; 

# enable debug/trace messages from DynaLoader perl code
$dl_debug = $ENV{PERL_DL_DEBUG} || 0 unless defined $dl_debug;

#
# Flags to alter dl_load_file behaviour.  Assigned bits:
#   0x01  make symbols available for linking later dl_load_file's.
#         (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL))
#         (ignored under VMS; effect is built-in to image linking)
#
# This is called as a class method $module->dl_load_flags.  The
# definition here will be inherited and result on "default" loading
# behaviour unless a sub-class of DynaLoader defines its own version.
#

sub dl_load_flags { 0x00 }

# ($dl_dlext, $dlsrc)
#         = @Config::Config{'dlext', 'dlsrc'};
  ($dl_dlext, $dlsrc) = ('so','dl_dlopen.xs')
;
# Some systems need special handling to expand file specifications
# (VMS support by Charles Bailey <bailey@HMIVAX.HUMGEN.UPENN.EDU>)
# See dl_expandspec() for more details. Should be harmless but
# inefficient to define on systems that don't need it.
$Is_VMS    = $^O eq 'VMS';
$do_expand = $Is_VMS;
$Is_MacOS  = $^O eq 'MacOS';

my $Mac_FS;
$Mac_FS = eval { require Mac::FileSpec::Unixish } if $Is_MacOS;

@dl_require_symbols = ();       # names of symbols we need
@dl_resolve_using   = ();       # names of files to link with
@dl_library_path    = ();       # path to look for files

#XSLoader.pm may have added elements before we were required
#@dl_shared_objects  = ();       # shared objects for symbols we have 
#@dl_librefs         = ();       # things we have loaded
#@dl_modules         = ();       # Modules we have loaded

# This is a fix to support DLD's unfortunate desire to relink -lc
@dl_resolve_using = dl_findfile('-lc') if $dlsrc eq "dl_dld.xs";

# Initialise @dl_library_path with the 'standard' library path
# for this platform as determined by Configure.

push(@dl_library_path, split(' ', $Config::Config{libpth}));


my $ldlibpthname         = $Config::Config{ldlibpthname};
my $ldlibpthname_defined = defined $Config::Config{ldlibpthname};
my $pthsep               = $Config::Config{path_sep};

# Add to @dl_library_path any extra directories we can gather from environment
# during runtime.

if ($ldlibpthname_defined &&
    exists $ENV{$ldlibpthname}) {
    push(@dl_library_path, split(/$pthsep/, $ENV{$ldlibpthname}));
}

# E.g. HP-UX supports both its native SHLIB_PATH *and* LD_LIBRARY_PATH.

if ($ldlibpthname_defined &&
    $ldlibpthname ne 'LD_LIBRARY_PATH' &&
    exists $ENV{LD_LIBRARY_PATH}) {
    push(@dl_library_path, split(/$pthsep/, $ENV{LD_LIBRARY_PATH}));
}


# No prizes for guessing why we don't say 'bootstrap DynaLoader;' here.
# NOTE: All dl_*.xs (including dl_none.xs) define a dl_error() XSUB
boot_DynaLoader('DynaLoader') if defined(&boot_DynaLoader) &&
                                !defined(&dl_error);

if ($dl_debug) {
    print STDERR "DynaLoader.pm loaded (@INC, @dl_library_path)\n";
    print STDERR "DynaLoader not linked into this perl\n"
	    unless defined(&boot_DynaLoader);
}

1; # End of main code


sub croak   { require Carp; Carp::croak(@_)   }

sub bootstrap_inherit {
    my $module = $_[0];
    local *isa = *{"$module\::ISA"};
    local @isa = (@isa, 'DynaLoader');
    # Cannot goto due to delocalization.  Will report errors on a wrong line?
    bootstrap(@_);
}

# The bootstrap function cannot be autoloaded (without complications)
# so we define it here:

sub bootstrap {
    # use local vars to enable $module.bs script to edit values
    local(@args) = @_;
    local($module) = $args[0];
    local(@dirs, $file);

    unless ($module) {
	require Carp;
	Carp::confess("Usage: DynaLoader::bootstrap(module)");
    }

    # A common error on platforms which don't support dynamic loading.
    # Since it's fatal and potentially confusing we give a detailed message.
    croak("Can't load module $module, dynamic loading not available in this perl.\n".
	"  (You may need to build a new perl executable which either supports\n".
	"  dynamic loading or has the $module module statically linked into it.)\n")
	unless defined(&dl_load_file);

    my @modparts = split(/::/,$module);
    my $modfname = $modparts[-1];

    # Some systems have restrictions on files names for DLL's etc.
    # mod2fname returns appropriate file base name (typically truncated)
    # It may also edit @modparts if required.
    $modfname = &mod2fname(\@modparts) if defined &mod2fname;

    # Truncate the module name to 8.3 format for NetWare
	if (($^O eq 'NetWare') && (length($modfname) > 8)) {
		$modfname = substr($modfname, 0, 8);
	}

    my $modpname = join(($Is_MacOS ? ':' : '/'),@modparts);

    print STDERR "DynaLoader::bootstrap for $module ",
		($Is_MacOS
		       ? "(:auto:$modpname:$modfname.$dl_dlext)\n" :
		       "(auto/$modpname/$modfname.$dl_dlext)\n")
	if $dl_debug;

    foreach (@INC) {
	chop($_ = VMS::Filespec::unixpath($_)) if $Is_VMS;
	my $dir;
	if ($Is_MacOS) {
	    my $path = $_;
	    if ($Mac_FS && ! -d $path) {
		$path = Mac::FileSpec::Unixish::nativize($path);
	    }
	    $path .= ":"  unless /:$/;
	    $dir = "${path}auto:$modpname";
	} else {
	    $dir = "$_/auto/$modpname";
	}
	
	next unless -d $dir; # skip over uninteresting directories
	
	# check for common cases to avoid autoload of dl_findfile
	my $try = $Is_MacOS ? "$dir:$modfname.$dl_dlext" : "$dir/$modfname.$dl_dlext";
	last if $file = ($do_expand) ? dl_expandspec($try) : ((-f $try) && $try);
	
	# no luck here, save dir for possible later dl_findfile search
	push @dirs, $dir;
    }
    # last resort, let dl_findfile have a go in all known locations
    $file = dl_findfile(map("-L$_",@dirs,@INC), $modfname) unless $file;

    croak("Can't locate loadable object for module $module in \@INC (\@INC contains: @INC)")
	unless $file;	# wording similar to error from 'require'

    $file = uc($file) if $Is_VMS && $Config::Config{d_vms_case_sensitive_symbols};
    my $bootname = "boot_$module";
    $bootname =~ s/\W/_/g;
    @dl_require_symbols = ($bootname);

    # Execute optional '.bootstrap' perl script for this module.
    # The .bs file can be used to configure @dl_resolve_using etc to
    # match the needs of the individual module on this architecture.
    my $bs = $file;
    $bs =~ s/(\.\w+)?(;\d*)?$/\.bs/; # look for .bs 'beside' the library
    if (-s $bs) { # only read file if it's not empty
        print STDERR "BS: $bs ($^O, $dlsrc)\n" if $dl_debug;
        eval { do $bs; };
        warn "$bs: $@\n" if $@;
    }

    my $boot_symbol_ref;

    if ($^O eq 'darwin') {
        if ($boot_symbol_ref = dl_find_symbol(0, $bootname)) {
            goto boot; #extension library has already been loaded, e.g. darwin
        }
    }

    # Many dynamic extension loading problems will appear to come from
    # this section of code: XYZ failed at line 123 of DynaLoader.pm.
    # Often these errors are actually occurring in the initialisation
    # C code of the extension XS file. Perl reports the error as being
    # in this perl code simply because this was the last perl code
    # it executed.

    my $libref = dl_load_file($file, $module->dl_load_flags) or
	croak("Can't load '$file' for module $module: ".dl_error());

    push(@dl_librefs,$libref);  # record loaded object

    my @unresolved = dl_undef_symbols();
    if (@unresolved) {
	require Carp;
	Carp::carp("Undefined symbols present after loading $file: @unresolved\n");
    }

    $boot_symbol_ref = dl_find_symbol($libref, $bootname) or
         croak("Can't find '$bootname' symbol in $file\n");

    push(@dl_modules, $module); # record loaded module

  boot:
    my $xs = dl_install_xsub("${module}::bootstrap", $boot_symbol_ref, $file);

    # See comment block above

	push(@dl_shared_objects, $file); # record files loaded

    &$xs(@args);
}


#sub _check_file {   # private utility to handle dl_expandspec vs -f tests
#    my($file) = @_;
#    return $file if (!$do_expand && -f $file); # the common case
#    return $file if ( $do_expand && ($file=dl_expandspec($file)));
#    return undef;
#}


# Let autosplit and the autoloader deal with these functions:
__END__


sub dl_findfile {
    # Read ext/DynaLoader/DynaLoader.doc for detailed information.
    # This function does not automatically consider the architecture
    # or the perl library auto directories.
    my (@args) = @_;
    my (@dirs,  $dir);   # which directories to search
    my (@found);         # full paths to real files we have found
    my $dl_ext= 'so'; # $Config::Config{'dlext'} suffix for perl extensions
    my $dl_so = 'so'; # $Config::Config{'so'} suffix for shared libraries

    print STDERR "dl_findfile(@args)\n" if $dl_debug;

    # accumulate directories but process files as they appear
    arg: foreach(@args) {
        #  Special fast case: full filepath requires no search
        if ($Is_VMS && m%[:>/\]]% && -f $_) {
	    push(@found,dl_expandspec(VMS::Filespec::vmsify($_)));
	    last arg unless wantarray;
	    next;
        }
	elsif ($Is_MacOS) {
	    if (m/:/ && -f $_) {
	    	push(@found,$_);
	    	last arg unless wantarray;
	    }
	}
        elsif (m:/: && -f $_ && !$do_expand) {
	    push(@found,$_);
	    last arg unless wantarray;
	    next;
	}

        # Deal with directories first:
        #  Using a -L prefix is the preferred option (faster and more robust)
        if (m:^-L:) { s/^-L//; push(@dirs, $_); next; }

	if ($Is_MacOS) {
            #  Otherwise we try to try to spot directories by a heuristic
            #  (this is a more complicated issue than it first appears)
	    if (m/:/ && -d $_) {   push(@dirs, $_); next; }
            #  Only files should get this far...
            my(@names, $name);    # what filenames to look for
	    s/^-l//;
	    push(@names, $_);
            foreach $dir (@dirs, @dl_library_path) {
            	next unless -d $dir;
		$dir =~ s/^([^:]+)$/:$1/;
		$dir =~ s/:$//;
            	foreach $name (@names) {
	    	    my($file) = "$dir:$name";
                    print STDERR " checking in $dir for $name\n" if $dl_debug;
		    if (-f $file) {
                    	push(@found, $file);
                    	next arg; # no need to look any further
                    }
                }
	    }
	    next;
	}
	
        #  Otherwise we try to try to spot directories by a heuristic
        #  (this is a more complicated issue than it first appears)
        if (m:/: && -d $_) {   push(@dirs, $_); next; }

        # VMS: we may be using native VMS directory syntax instead of
        # Unix emulation, so check this as well
        if ($Is_VMS && /[:>\]]/ && -d $_) {   push(@dirs, $_); next; }

        #  Only files should get this far...
        my(@names, $name);    # what filenames to look for
        if (m:-l: ) {          # convert -lname to appropriate library name
            s/-l//;
            push(@names,"lib$_.$dl_so");
            push(@names,"lib$_.a");
        } else {                # Umm, a bare name. Try various alternatives:
            # these should be ordered with the most likely first
            push(@names,"$_.$dl_ext")    unless m/\.$dl_ext$/o;
            push(@names,"$_.$dl_so")     unless m/\.$dl_so$/o;
            push(@names,"lib$_.$dl_so")  unless m:/:;
            push(@names,"$_.a")          if !m/\.a$/ and $dlsrc eq "dl_dld.xs";
            push(@names, $_);
        }
        foreach $dir (@dirs, @dl_library_path) {
            next unless -d $dir;
            chop($dir = VMS::Filespec::unixpath($dir)) if $Is_VMS;
            foreach $name (@names) {
		my($file) = "$dir/$name";
                print STDERR " checking in $dir for $name\n" if $dl_debug;
		$file = ($do_expand) ? dl_expandspec($file) : (-f $file && $file);
		#$file = _check_file($file);
		if ($file) {
                    push(@found, $file);
                    next arg; # no need to look any further
                }
            }
        }
    }
    if ($dl_debug) {
        foreach(@dirs) {
            print STDERR " dl_findfile ignored non-existent directory: $_\n" unless -d $_;
        }
        print STDERR "dl_findfile found: @found\n";
    }
    return $found[0] unless wantarray;
    @found;
}


sub dl_expandspec {
    my($spec) = @_;
    # Optional function invoked if DynaLoader.pm sets $do_expand.
    # Most systems do not require or use this function.
    # Some systems may implement it in the dl_*.xs file in which case
    # this autoload version will not be called but is harmless.

    # This function is designed to deal with systems which treat some
    # 'filenames' in a special way. For example VMS 'Logical Names'
    # (something like unix environment variables - but different).
    # This function should recognise such names and expand them into
    # full file paths.
    # Must return undef if $spec is invalid or file does not exist.

    my $file = $spec; # default output to input

    if ($Is_VMS) { # dl_expandspec should be defined in dl_vms.xs
	require Carp;
	Carp::croak("dl_expandspec: should be defined in XS file!\n");
    } else {
	return undef unless -f $file;
    }
    print STDERR "dl_expandspec($spec) => $file\n" if $dl_debug;
    $file;
}

sub dl_find_symbol_anywhere
{
    my $sym = shift;
    my $libref;
    foreach $libref (@dl_librefs) {
	my $symref = dl_find_symbol($libref,$sym);
	return $symref if $symref;
    }
    return undef;
}

=head1 NAME

DynaLoader - Dynamically load C libraries into Perl code

=head1 SYNOPSIS

    package YourPackage;
    require DynaLoader;
    @ISA = qw(... DynaLoader ...);
    bootstrap YourPackage;

    # optional method for 'global' loading
    sub dl_load_flags { 0x01 }     


=head1 DESCRIPTION

This document defines a standard generic interface to the dynamic
linking mechanisms available on many platforms.  Its primary purpose is
to implement automatic dynamic loading of Perl modules.

This document serves as both a specification for anyone wishing to
implement the DynaLoader for a new platform and as a guide for
anyone wishing to use the DynaLoader directly in an application.

The DynaLoader is designed to be a very simple high-level
interface that is sufficiently general to cover the requirements
of SunOS, HP-UX, NeXT, Linux, VMS and other platforms.

It is also hoped that the interface will cover the needs of OS/2, NT
etc and also allow pseudo-dynamic linking (using C<ld -A> at runtime).

It must be stressed that the DynaLoader, by itself, is practically
useless for accessing non-Perl libraries because it provides almost no
Perl-to-C 'glue'.  There is, for example, no mechanism for calling a C
library function or supplying arguments.  A C::DynaLib module
is available from CPAN sites which performs that function for some
common system types.  And since the year 2000, there's also Inline::C,
a module that allows you to write Perl subroutines in C.  Also available
from your local CPAN site.

DynaLoader Interface Summary

  @dl_library_path
  @dl_resolve_using
  @dl_require_symbols
  $dl_debug
  @dl_librefs
  @dl_modules
  @dl_shared_objects
                                                  Implemented in:
  bootstrap($modulename)                               Perl
  @filepaths = dl_findfile(@names)                     Perl
  $flags = $modulename->dl_load_flags                  Perl
  $symref  = dl_find_symbol_anywhere($symbol)          Perl

  $libref  = dl_load_file($filename, $flags)           C
  $status  = dl_unload_file($libref)                   C
  $symref  = dl_find_symbol($libref, $symbol)          C
  @symbols = dl_undef_symbols()                        C
  dl_install_xsub($name, $symref [, $filename])        C
  $message = dl_error                                  C

=over 4

=item @dl_library_path

The standard/default list of directories in which dl_findfile() will
search for libraries etc.  Directories are searched in order:
$dl_library_path[0], [1], ... etc

@dl_library_path is initialised to hold the list of 'normal' directories
(F</usr/lib>, etc) determined by B<Configure> (C<$Config{'libpth'}>).  This should
ensure portability across a wide range of platforms.

@dl_library_path should also be initialised with any other directories
that can be determined from the environment at runtime (such as
LD_LIBRARY_PATH for SunOS).

After initialisation @dl_library_path can be manipulated by an
application using push and unshift before calling dl_findfile().
Unshift can be used to add directories to the front of the search order
either to save search time or to override libraries with the same name
in the 'normal' directories.

The load function that dl_load_file() calls may require an absolute
pathname.  The dl_findfile() function and @dl_library_path can be
used to search for and return the absolute pathname for the
library/object that you wish to load.

=item @dl_resolve_using

A list of additional libraries or other shared objects which can be
used to resolve any undefined symbols that might be generated by a
later call to load_file().

This is only required on some platforms which do not handle dependent
libraries automatically.  For example the Socket Perl extension
library (F<auto/Socket/Socket.so>) contains references to many socket
functions which need to be resolved when it's loaded.  Most platforms
will automatically know where to find the 'dependent' library (e.g.,
F</usr/lib/libsocket.so>).  A few platforms need to be told the
location of the dependent library explicitly.  Use @dl_resolve_using
for this.

Example usage:

    @dl_resolve_using = dl_findfile('-lsocket');

=item @dl_require_symbols

A list of one or more symbol names that are in the library/object file
to be dynamically loaded.  This is only required on some platforms.

=item @dl_librefs

An array of the handles returned by successful calls to dl_load_file(),
made by bootstrap, in the order in which they were loaded.
Can be used with dl_find_symbol() to look for a symbol in any of
the loaded files.

=item @dl_modules

An array of module (package) names that have been bootstrap'ed.

=item @dl_shared_objects

An array of file names for the shared objects that were loaded.

=item dl_error()

Syntax:

    $message = dl_error();

Error message text from the last failed DynaLoader function.  Note
that, similar to errno in unix, a successful function call does not
reset this message.

Implementations should detect the error as soon as it occurs in any of
the other functions and save the corresponding message for later
retrieval.  This will avoid problems on some platforms (such as SunOS)
where the error message is very temporary (e.g., dlerror()).

=item $dl_debug

Internal debugging messages are enabled when $dl_debug is set true.
Currently setting $dl_debug only affects the Perl side of the
DynaLoader.  These messages should help an application developer to
resolve any DynaLoader usage problems.

$dl_debug is set to C<$ENV{'PERL_DL_DEBUG'}> if defined.

For the DynaLoader developer/porter there is a similar debugging
variable added to the C code (see dlutils.c) and enabled if Perl was
built with the B<-DDEBUGGING> flag.  This can also be set via the
PERL_DL_DEBUG environment variable.  Set to 1 for minimal information or
higher for more.

=item dl_findfile()

Syntax:

    @filepaths = dl_findfile(@names)

Determine the full paths (including file suffix) of one or more
loadable files given their generic names and optionally one or more
directories.  Searches directories in @dl_library_path by default and
returns an empty list if no files were found.

Names can be specified in a variety of platform independent forms.  Any
names in the form B<-lname> are converted into F<libname.*>, where F<.*> is
an appropriate suffix for the platform.

If a name does not already have a suitable prefix and/or suffix then
the corresponding file will be searched for by trying combinations of
prefix and suffix appropriate to the platform: "$name.o", "lib$name.*"
and "$name".

If any directories are included in @names they are searched before
@dl_library_path.  Directories may be specified as B<-Ldir>.  Any other
names are treated as filenames to be searched for.

Using arguments of the form C<-Ldir> and C<-lname> is recommended.

Example: 

    @dl_resolve_using = dl_findfile(qw(-L/usr/5lib -lposix));


=item dl_expandspec()

Syntax:

    $filepath = dl_expandspec($spec)

Some unusual systems, such as VMS, require special filename handling in
order to deal with symbolic names for files (i.e., VMS's Logical Names).

To support these systems a dl_expandspec() function can be implemented
either in the F<dl_*.xs> file or code can be added to the autoloadable
dl_expandspec() function in F<DynaLoader.pm>.  See F<DynaLoader.pm> for
more information.

=item dl_load_file()

Syntax:

    $libref = dl_load_file($filename, $flags)

Dynamically load $filename, which must be the path to a shared object
or library.  An opaque 'library reference' is returned as a handle for
the loaded object.  Returns undef on error.

The $flags argument to alters dl_load_file behaviour.  
Assigned bits:

 0x01  make symbols available for linking later dl_load_file's.
       (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL))
       (ignored under VMS; this is a normal part of image linking)

(On systems that provide a handle for the loaded object such as SunOS
and HPUX, $libref will be that handle.  On other systems $libref will
typically be $filename or a pointer to a buffer containing $filename.
The application should not examine or alter $libref in any way.)

This is the function that does the real work.  It should use the
current values of @dl_require_symbols and @dl_resolve_using if required.

    SunOS: dlopen($filename)
    HP-UX: shl_load($filename)
    Linux: dld_create_reference(@dl_require_symbols); dld_link($filename)
    NeXT:  rld_load($filename, @dl_resolve_using)
    VMS:   lib$find_image_symbol($filename,$dl_require_symbols[0])

(The dlopen() function is also used by Solaris and some versions of
Linux, and is a common choice when providing a "wrapper" on other
mechanisms as is done in the OS/2 port.)

=item dl_unload_file()

Syntax:

    $status = dl_unload_file($libref)

Dynamically unload $libref, which must be an opaque 'library reference' as
returned from dl_load_file.  Returns one on success and zero on failure.

This function is optional and may not necessarily be provided on all platforms.
If it is defined, it is called automatically when the interpreter exits for
every shared object or library loaded by DynaLoader::bootstrap.  All such
library references are stored in @dl_librefs by DynaLoader::Bootstrap as it
loads the libraries.  The files are unloaded in last-in, first-out order.

This unloading is usually necessary when embedding a shared-object perl (e.g.
one configured with -Duseshrplib) within a larger application, and the perl
interpreter is created and destroyed several times within the lifetime of the
application.  In this case it is possible that the system dynamic linker will
unload and then subsequently reload the shared libperl without relocating any
references to it from any files DynaLoaded by the previous incarnation of the
interpreter.  As a result, any shared objects opened by DynaLoader may point to
a now invalid 'ghost' of the libperl shared object, causing apparently random
memory corruption and crashes.  This behaviour is most commonly seen when using
Apache and mod_perl built with the APXS mechanism.

    SunOS: dlclose($libref)
    HP-UX: ???
    Linux: ???
    NeXT:  ???
    VMS:   ???

(The dlclose() function is also used by Solaris and some versions of
Linux, and is a common choice when providing a "wrapper" on other
mechanisms as is done in the OS/2 port.)

=item dl_load_flags()

Syntax:

    $flags = dl_load_flags $modulename;

Designed to be a method call, and to be overridden by a derived class
(i.e. a class which has DynaLoader in its @ISA).  The definition in
DynaLoader itself returns 0, which produces standard behavior from
dl_load_file().

=item dl_find_symbol()

Syntax:

    $symref = dl_find_symbol($libref, $symbol)

Return the address of the symbol $symbol or C<undef> if not found.  If the
target system has separate functions to search for symbols of different
types then dl_find_symbol() should search for function symbols first and
then other types.

The exact manner in which the address is returned in $symref is not
currently defined.  The only initial requirement is that $symref can
be passed to, and understood by, dl_install_xsub().

    SunOS: dlsym($libref, $symbol)
    HP-UX: shl_findsym($libref, $symbol)
    Linux: dld_get_func($symbol) and/or dld_get_symbol($symbol)
    NeXT:  rld_lookup("_$symbol")
    VMS:   lib$find_image_symbol($libref,$symbol)


=item dl_find_symbol_anywhere()

Syntax:

    $symref = dl_find_symbol_anywhere($symbol)

Applies dl_find_symbol() to the members of @dl_librefs and returns
the first match found.

=item dl_undef_symbols()

Example

    @symbols = dl_undef_symbols()

Return a list of symbol names which remain undefined after load_file().
Returns C<()> if not known.  Don't worry if your platform does not provide
a mechanism for this.  Most do not need it and hence do not provide it,
they just return an empty list.


=item dl_install_xsub()

Syntax:

    dl_install_xsub($perl_name, $symref [, $filename])

Create a new Perl external subroutine named $perl_name using $symref as
a pointer to the function which implements the routine.  This is simply
a direct call to newXSUB().  Returns a reference to the installed
function.

The $filename parameter is used by Perl to identify the source file for
the function if required by die(), caller() or the debugger.  If
$filename is not defined then "DynaLoader" will be used.


=item bootstrap()

Syntax:

bootstrap($module)

This is the normal entry point for automatic dynamic loading in Perl.

It performs the following actions:

=over 8

=item *

locates an auto/$module directory by searching @INC

=item *

uses dl_findfile() to determine the filename to load

=item *

sets @dl_require_symbols to C<("boot_$module")>

=item *

executes an F<auto/$module/$module.bs> file if it exists
(typically used to add to @dl_resolve_using any files which
are required to load the module on the current platform)

=item *

calls dl_load_flags() to determine how to load the file.

=item *

calls dl_load_file() to load the file

=item *

calls dl_undef_symbols() and warns if any symbols are undefined

=item *

calls dl_find_symbol() for "boot_$module"

=item *

calls dl_install_xsub() to install it as "${module}::bootstrap"

=item *

calls &{"${module}::bootstrap"} to bootstrap the module (actually
it uses the function reference returned by dl_install_xsub for speed)

=back

=back


=head1 AUTHOR

Tim Bunce, 11 August 1994.

This interface is based on the work and comments of (in no particular
order): Larry Wall, Robert Sanders, Dean Roehrich, Jeff Okamoto, Anno
Siegel, Thomas Neumann, Paul Marquess, Charles Bailey, myself and others.

Larry Wall designed the elegant inherited bootstrap mechanism and
implemented the first Perl 5 dynamic loader using it.

Solaris global loading added by Nick Ing-Simmons with design/coding
assistance from Tim Bunce, January 1996.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   require '_h2ph_pre.ph';

no warnings 'redefine';

unless(defined(&_STDARG_H)) {
    unless(defined(&_ANSI_STDARG_H_)) {
	unless(defined(&__need___va_list)) {
	    eval 'sub _STDARG_H () {1;}' unless defined(&_STDARG_H);
	    eval 'sub _ANSI_STDARG_H_ () {1;}' unless defined(&_ANSI_STDARG_H_);
	}
	undef(&__need___va_list) if defined(&__need___va_list);
	unless(defined(&__GNUC_VA_LIST)) {
	    eval 'sub __GNUC_VA_LIST () {1;}' unless defined(&__GNUC_VA_LIST);
	}
	if(defined(&_STDARG_H)) {
	    eval 'sub va_start {
	        my($v,$l) = @_;
    		eval q( &__builtin_va_start($v,$l));
	    }' unless defined(&va_start);
	    eval 'sub va_end {
	        my($v) = @_;
    		eval q( &__builtin_va_end($v));
	    }' unless defined(&va_end);
	    eval 'sub va_arg {
	        my($v,$l) = @_;
    		eval q( &__builtin_va_arg($v,$l));
	    }' unless defined(&va_arg);
	    if(!defined( &__STRICT_ANSI__) || (defined(&__STDC_VERSION__) ? &__STDC_VERSION__ : undef) + 0>= 199900) {
		eval 'sub va_copy {
		    my($d,$s) = @_;
    		    eval q( &__builtin_va_copy($d,$s));
		}' unless defined(&va_copy);
	    }
	    eval 'sub __va_copy {
	        my($d,$s) = @_;
    		eval q( &__builtin_va_copy($d,$s));
	    }' unless defined(&__va_copy);
	    if(defined(&_HIDDEN_VA_LIST)) {
		undef(&_VA_LIST) if defined(&_VA_LIST);
	    }
	    if(defined(&_BSD_VA_LIST)) {
		undef(&_BSD_VA_LIST) if defined(&_BSD_VA_LIST);
	    }
	    if(defined( &__svr4__) || (defined( &_SCO_DS)  && !defined( &__VA_LIST))) {
		unless(defined(&_VA_LIST_)) {
		    eval 'sub _VA_LIST_ () {1;}' unless defined(&_VA_LIST_);
		    if(defined(&__i860__)) {
			unless(defined(&_VA_LIST)) {
			    eval 'sub _VA_LIST () { &va_list;}' unless defined(&_VA_LIST);
			}
		    }
		    if(defined(&_SCO_DS)) {
			eval 'sub __VA_LIST () {1;}' unless defined(&__VA_LIST);
		    }
		}
	    } else {
		if(!defined ( &_VA_LIST_) || defined ( &__BSD_NET2__) || defined ( &____386BSD____) || defined ( &__bsdi__) || defined ( &__sequent__) || defined ( &__FreeBSD__) || defined( &WINNT)) {
		    unless(defined(&_VA_LIST_DEFINED)) {
			unless(defined(&_VA_LIST)) {
			    unless(defined(&_VA_LIST_T_H)) {
				unless(defined(&__va_list__)) {
				}
			    }
			}
		    }
		    if(!(defined ( &__BSD_NET2__) || defined ( &____386BSD____) || defined ( &__bsdi__) || defined ( &__sequent__) || defined ( &__FreeBSD__))) {
			eval 'sub _VA_LIST_ () {1;}' unless defined(&_VA_LIST_);
		    }
		    unless(defined(&_VA_LIST)) {
			eval 'sub _VA_LIST () {1;}' unless defined(&_VA_LIST);
		    }
		    unless(defined(&_VA_LIST_DEFINED)) {
			eval 'sub _VA_LIST_DEFINED () {1;}' unless defined(&_VA_LIST_DEFINED);
		    }
		    unless(defined(&_VA_LIST_T_H)) {
			eval 'sub _VA_LIST_T_H () {1;}' unless defined(&_VA_LIST_T_H);
		    }
		    unless(defined(&__va_list__)) {
			eval 'sub __va_list__ () {1;}' unless defined(&__va_list__);
		    }
		}
	    }
	}
    }
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          9E  .   'E  ..  :E  stubs-32.ph ;E stubs.ph                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    require '_h2ph_pre.ph';

no warnings 'redefine';

if(defined(&_LIBC)) {
    die("Applications\ may\ not\ define\ the\ macro\ _LIBC");
}
unless(defined(&__stub___kernel_cosl)) {
    sub __stub___kernel_cosl () {	1;}
}
unless(defined(&__stub___kernel_sinl)) {
    sub __stub___kernel_sinl () {	1;}
}
unless(defined(&__stub___kernel_tanl)) {
    sub __stub___kernel_tanl () {	1;}
}
unless(defined(&__stub_chflags)) {
    sub __stub_chflags () {	1;}
}
unless(defined(&__stub_fattach)) {
    sub __stub_fattach () {	1;}
}
unless(defined(&__stub_fchflags)) {
    sub __stub_fchflags () {	1;}
}
unless(defined(&__stub_fdetach)) {
    sub __stub_fdetach () {	1;}
}
unless(defined(&__stub_gtty)) {
    sub __stub_gtty () {	1;}
}
unless(defined(&__stub_lchmod)) {
    sub __stub_lchmod () {	1;}
}
unless(defined(&__stub_lutimes)) {
    sub __stub_lutimes () {	1;}
}
unless(defined(&__stub_revoke)) {
    sub __stub_revoke () {	1;}
}
unless(defined(&__stub_setlogin)) {
    sub __stub_setlogin () {	1;}
}
unless(defined(&__stub_sigreturn)) {
    sub __stub_sigreturn () {	1;}
}
unless(defined(&__stub_sstk)) {
    sub __stub_sstk () {	1;}
}
unless(defined(&__stub_stty)) {
    sub __stub_stty () {	1;}
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    require '_h2ph_pre.ph';

no warnings 'redefine';

require 'bits/wordsize.ph';
if((defined(&__WORDSIZE) ? &__WORDSIZE : undef) == 32) {
    require 'gnu/stubs-32.ph';
}
 elsif((defined(&__WORDSIZE) ? &__WORDSIZE : undef) == 64) {
    require 'gnu/stubs-64.ph';
} else {
    die("unexpected value for __WORDSIZE macro");
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            #      B.pm
#
#      Copyright (c) 1996, 1997, 1998 Malcolm Beattie
#
#      You may distribute under the terms of either the GNU General Public
#      License or the Artistic License, as specified in the README file.
#
package B;

our $VERSION = '1.09_01';

use XSLoader ();
require Exporter;
@ISA = qw(Exporter);

# walkoptree_slow comes from B.pm (you are there),
# walkoptree comes from B.xs
@EXPORT_OK = qw(minus_c ppname save_BEGINs
		class peekop cast_I32 cstring cchar hash threadsv_names
		main_root main_start main_cv svref_2object opnumber
		amagic_generation perlstring
		walkoptree_slow walkoptree walkoptree_exec walksymtable
		parents comppadlist sv_undef compile_stats timing_info
		begin_av init_av check_av end_av regex_padav dowarn
		defstash curstash warnhook diehook inc_gv
		);

sub OPf_KIDS ();
use strict;
@B::SV::ISA = 'B::OBJECT';
@B::NULL::ISA = 'B::SV';
@B::PV::ISA = 'B::SV';
@B::IV::ISA = 'B::SV';
@B::NV::ISA = 'B::SV';
@B::RV::ISA = 'B::SV';
@B::PVIV::ISA = qw(B::PV B::IV);
@B::PVNV::ISA = qw(B::PVIV B::NV);
@B::PVMG::ISA = 'B::PVNV';
# Change in the inheritance hierarchy post 5.9.0
@B::PVLV::ISA = $] > 5.009 ? 'B::GV' : 'B::PVMG';
@B::BM::ISA = 'B::PVMG';
@B::AV::ISA = 'B::PVMG';
@B::GV::ISA = 'B::PVMG';
@B::HV::ISA = 'B::PVMG';
@B::CV::ISA = 'B::PVMG';
@B::IO::ISA = 'B::PVMG';
@B::FM::ISA = 'B::CV';

@B::OP::ISA = 'B::OBJECT';
@B::UNOP::ISA = 'B::OP';
@B::BINOP::ISA = 'B::UNOP';
@B::LOGOP::ISA = 'B::UNOP';
@B::LISTOP::ISA = 'B::BINOP';
@B::SVOP::ISA = 'B::OP';
@B::PADOP::ISA = 'B::OP';
@B::PVOP::ISA = 'B::OP';
@B::LOOP::ISA = 'B::LISTOP';
@B::PMOP::ISA = 'B::LISTOP';
@B::COP::ISA = 'B::OP';

@B::SPECIAL::ISA = 'B::OBJECT';

{
    # Stop "-w" from complaining about the lack of a real B::OBJECT class
    package B::OBJECT;
}

sub B::GV::SAFENAME {
  my $name = (shift())->NAME;

  # The regex below corresponds to the isCONTROLVAR macro
  # from toke.c

  $name =~ s/^([\cA-\cZ\c\\c[\c]\c?\c_\c^])/"^".
	chr( utf8::unicode_to_native( 64 ^ ord($1) ))/e;

  # When we say unicode_to_native we really mean ascii_to_native,
  # which matters iff this is a non-ASCII platform (EBCDIC).

  return $name;
}

sub B::IV::int_value {
  my ($self) = @_;
  return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV);
}

sub B::NULL::as_string() {""}
sub B::IV::as_string()   {goto &B::IV::int_value}
sub B::PV::as_string()   {goto &B::PV::PV}

my $debug;
my $op_count = 0;
my @parents = ();

sub debug {
    my ($class, $value) = @_;
    $debug = $value;
    walkoptree_debug($value);
}

sub class {
    my $obj = shift;
    my $name = ref $obj;
    $name =~ s/^.*:://;
    return $name;
}

sub parents { \@parents }

# For debugging
sub peekop {
    my $op = shift;
    return sprintf("%s (0x%x) %s", class($op), $$op, $op->name);
}

sub walkoptree_slow {
    my($op, $method, $level) = @_;
    $op_count++; # just for statistics
    $level ||= 0;
    warn(sprintf("walkoptree: %d. %s\n", $level, peekop($op))) if $debug;
    $op->$method($level);
    if ($$op && ($op->flags & OPf_KIDS)) {
	my $kid;
	unshift(@parents, $op);
	for ($kid = $op->first; $$kid; $kid = $kid->sibling) {
	    walkoptree_slow($kid, $method, $level + 1);
	}
	shift @parents;
    }
    if (class($op) eq 'PMOP' && ref($op->pmreplroot) && ${$op->pmreplroot}) {
	unshift(@parents, $op);
	walkoptree_slow($op->pmreplroot, $method, $level + 1);
	shift @parents;
    }
}

sub compile_stats {
    return "Total number of OPs processed: $op_count\n";
}

sub timing_info {
    my ($sec, $min, $hr) = localtime;
    my ($user, $sys) = times;
    sprintf("%02d:%02d:%02d user=$user sys=$sys",
	    $hr, $min, $sec, $user, $sys);
}

my %symtable;

sub clearsym {
    %symtable = ();
}

sub savesym {
    my ($obj, $value) = @_;
#    warn(sprintf("savesym: sym_%x => %s\n", $$obj, $value)); # debug
    $symtable{sprintf("sym_%x", $$obj)} = $value;
}

sub objsym {
    my $obj = shift;
    return $symtable{sprintf("sym_%x", $$obj)};
}

sub walkoptree_exec {
    my ($op, $method, $level) = @_;
    $level ||= 0;
    my ($sym, $ppname);
    my $prefix = "    " x $level;
    for (; $$op; $op = $op->next) {
	$sym = objsym($op);
	if (defined($sym)) {
	    print $prefix, "goto $sym\n";
	    return;
	}
	savesym($op, sprintf("%s (0x%lx)", class($op), $$op));
	$op->$method($level);
	$ppname = $op->name;
	if ($ppname =~
	    /^(d?or(assign)?|and(assign)?|mapwhile|grepwhile|entertry|range|cond_expr)$/)
	{
	    print $prefix, uc($1), " => {\n";
	    walkoptree_exec($op->other, $method, $level + 1);
	    print $prefix, "}\n";
	} elsif ($ppname eq "match" || $ppname eq "subst") {
	    my $pmreplstart = $op->pmreplstart;
	    if ($$pmreplstart) {
		print $prefix, "PMREPLSTART => {\n";
		walkoptree_exec($pmreplstart, $method, $level + 1);
		print $prefix, "}\n";
	    }
	} elsif ($ppname eq "substcont") {
	    print $prefix, "SUBSTCONT => {\n";
	    walkoptree_exec($op->other->pmreplstart, $method, $level + 1);
	    print $prefix, "}\n";
	    $op = $op->other;
	} elsif ($ppname eq "enterloop") {
	    print $prefix, "REDO => {\n";
	    walkoptree_exec($op->redoop, $method, $level + 1);
	    print $prefix, "}\n", $prefix, "NEXT => {\n";
	    walkoptree_exec($op->nextop, $method, $level + 1);
	    print $prefix, "}\n", $prefix, "LAST => {\n";
	    walkoptree_exec($op->lastop,  $method, $level + 1);
	    print $prefix, "}\n";
	} elsif ($ppname eq "subst") {
	    my $replstart = $op->pmreplstart;
	    if ($$replstart) {
		print $prefix, "SUBST => {\n";
		walkoptree_exec($replstart, $method, $level + 1);
		print $prefix, "}\n";
	    }
	}
    }
}

sub walksymtable {
    my ($symref, $method, $recurse, $prefix) = @_;
    my $sym;
    my $ref;
    my $fullname;
    no strict 'refs';
    $prefix = '' unless defined $prefix;
    while (($sym, $ref) = each %$symref) {
        $fullname = "*main::".$prefix.$sym;
	if ($sym =~ /::$/) {
	    $sym = $prefix . $sym;
	    if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
               walksymtable(\%$fullname, $method, $recurse, $sym);
	    }
	} else {
           svref_2object(\*$fullname)->$method();
	}
    }
}

{
    package B::Section;
    my $output_fh;
    my %sections;

    sub new {
	my ($class, $section, $symtable, $default) = @_;
	$output_fh ||= FileHandle->new_tmpfile;
	my $obj = bless [-1, $section, $symtable, $default], $class;
	$sections{$section} = $obj;
	return $obj;
    }

    sub get {
	my ($class, $section) = @_;
	return $sections{$section};
    }

    sub add {
	my $section = shift;
	while (defined($_ = shift)) {
	    print $output_fh "$section->[1]\t$_\n";
	    $section->[0]++;
	}
    }

    sub index {
	my $section = shift;
	return $section->[0];
    }

    sub name {
	my $section = shift;
	return $section->[1];
    }

    sub symtable {
	my $section = shift;
	return $section->[2];
    }

    sub default {
	my $section = shift;
	return $section->[3];
    }

    sub output {
	my ($section, $fh, $format) = @_;
	my $name = $section->name;
	my $sym = $section->symtable || {};
	my $default = $section->default;

	seek($output_fh, 0, 0);
	while (<$output_fh>) {
	    chomp;
	    s/^(.*?)\t//;
	    if ($1 eq $name) {
		s{(s\\_[0-9a-f]+)} {
		    exists($sym->{$1}) ? $sym->{$1} : $default;
		}ge;
		printf $fh $format, $_;
	    }
	}
    }
}

XSLoader::load 'B';

1;

__END__

=head1 NAME

B - The Perl Compiler

=head1 SYNOPSIS

	use B;

=head1 DESCRIPTION

The C<B> module supplies classes which allow a Perl program to delve
into its own innards. It is the module used to implement the
"backends" of the Perl compiler. Usage of the compiler does not
require knowledge of this module: see the F<O> module for the
user-visible part. The C<B> module is of use to those who want to
write new compiler backends. This documentation assumes that the
reader knows a fair amount about perl's internals including such
things as SVs, OPs and the internal symbol table and syntax tree
of a program.

=head1 OVERVIEW

The C<B> module contains a set of utility functions for querying the
current state of the Perl interpreter; typically these functions
return objects from the B::SV and B::OP classes, or their derived
classes.  These classes in turn define methods for querying the
resulting objects about their own internal state.

=head1 Utility Functions

The C<B> module exports a variety of functions: some are simple
utility functions, others provide a Perl program with a way to
get an initial "handle" on an internal object.

=head2 Functions Returning C<B::SV>, C<B::AV>, C<B::HV>, and C<B::CV> objects

For descriptions of the class hierarchy of these objects and the
methods that can be called on them, see below, L<"OVERVIEW OF
CLASSES"> and L<"SV-RELATED CLASSES">.

=over 4

=item sv_undef

Returns the SV object corresponding to the C variable C<sv_undef>.

=item sv_yes

Returns the SV object corresponding to the C variable C<sv_yes>.

=item sv_no

Returns the SV object corresponding to the C variable C<sv_no>.

=item svref_2object(SVREF)

Takes a reference to any Perl value, and turns the referred-to value
into an object in the appropriate B::OP-derived or B::SV-derived
class. Apart from functions such as C<main_root>, this is the primary
way to get an initial "handle" on an internal perl data structure
which can then be followed with the other access methods.

The returned object will only be valid as long as the underlying OPs
and SVs continue to exist. Do not attempt to use the object after the
underlying structures are freed.

=item amagic_generation

Returns the SV object corresponding to the C variable C<amagic_generation>.

=item init_av

Returns the AV object (i.e. in class B::AV) representing INIT blocks.

=item check_av

Returns the AV object (i.e. in class B::AV) representing CHECK blocks.

=item begin_av

Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.

=item end_av

Returns the AV object (i.e. in class B::AV) representing END blocks.

=item comppadlist

Returns the AV object (i.e. in class B::AV) of the global comppadlist.

=item regex_padav

Only when perl was compiled with ithreads.

=item main_cv

Return the (faked) CV corresponding to the main part of the Perl
program.

=back

=head2 Functions for Examining the Symbol Table

=over 4

=item walksymtable(SYMREF, METHOD, RECURSE, PREFIX)

Walk the symbol table starting at SYMREF and call METHOD on each
symbol (a B::GV object) visited.  When the walk reaches package
symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
name, and only recurses into the package if that sub returns true.

PREFIX is the name of the SYMREF you're walking.

For example:

  # Walk CGI's symbol table calling print_subs on each symbol.
  # Recurse only into CGI::Util::
  walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' },
               'CGI::');

print_subs() is a B::GV method you have declared. Also see L<"B::GV
Methods">, below.

=back

=head2 Functions Returning C<B::OP> objects or for walking op trees

For descriptions of the class hierarchy of these objects and the
methods that can be called on them, see below, L<"OVERVIEW OF
CLASSES"> and L<"OP-RELATED CLASSES">.

=over 4

=item main_root

Returns the root op (i.e. an object in the appropriate B::OP-derived
class) of the main part of the Perl program.

=item main_start

Returns the starting op of the main part of the Perl program.

=item walkoptree(OP, METHOD)

Does a tree-walk of the syntax tree based at OP and calls METHOD on
each op it visits. Each node is visited before its children. If
C<walkoptree_debug> (see below) has been called to turn debugging on then
the method C<walkoptree_debug> is called on each op before METHOD is
called.

=item walkoptree_debug(DEBUG)

Returns the current debugging flag for C<walkoptree>. If the optional
DEBUG argument is non-zero, it sets the debugging flag to that. See
the description of C<walkoptree> above for what the debugging flag
does.

=back

=head2 Miscellaneous Utility Functions

=over 4

=item ppname(OPNUM)

Return the PP function name (e.g. "pp_add") of op number OPNUM.

=item hash(STR)

Returns a string in the form "0x..." representing the value of the
internal hash function used by perl on string STR.

=item cast_I32(I)

Casts I to the internal I32 type used by that perl.

=item minus_c

Does the equivalent of the C<-c> command-line option. Obviously, this
is only useful in a BEGIN block or else the flag is set too late.

=item cstring(STR)

Returns a double-quote-surrounded escaped version of STR which can
be used as a string in C source code.

=item perlstring(STR)

Returns a double-quote-surrounded escaped version of STR which can
be used as a string in Perl source code.

=item class(OBJ)

Returns the class of an object without the part of the classname
preceding the first C<"::">. This is used to turn C<"B::UNOP"> into
C<"UNOP"> for example.

=item threadsv_names

In a perl compiled for threads, this returns a list of the special
per-thread threadsv variables.

=back




=head1 OVERVIEW OF CLASSES

The C structures used by Perl's internals to hold SV and OP
information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
class hierarchy and the C<B> module gives access to them via a true
object hierarchy. Structure fields which point to other objects
(whether types of SV or types of OP) are represented by the C<B>
module as Perl objects of the appropriate class.

The bulk of the C<B> module is the methods for accessing fields of
these structures.

Note that all access is read-only.  You cannot modify the internals by
using this module. Also, note that the B::OP and B::SV objects created
by this module are only valid for as long as the underlying objects
exist; their creation doesn't increase the reference counts of the
underlying objects. Trying to access the fields of a freed object will
give incomprehensible results, or worse.

=head2 SV-RELATED CLASSES

B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
the obvious way to the underlying C structures of similar names. The
inheritance hierarchy mimics the underlying C "inheritance". For 5.9.1
and later this is:

                             B::SV
                               |
                +--------------+----------+------------+
                |              |          |            |
              B::PV          B::IV      B::NV        B::RV
                   \         /          /
                    \       /          /
                     B::PVIV          /
                         \           /
                          \         /
                           \       /
                            B::PVNV
                               |
                               |
                            B::PVMG
                               |
                    +-----+----+------+-----+-----+
                    |     |    |      |     |     |
                  B::BM B::AV B::GV B::HV B::CV B::IO
                               |            |
                            B::PVLV         |
                                          B::FM


For 5.9.0 and earlier, PVLV is a direct subclass of PVMG, so the base
of this diagram is

                           |
                        B::PVMG
                           |
         +------+-----+----+------+-----+-----+
         |      |     |    |      |     |     |
      B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO
                                        |
                                        |
                                      B::FM


Access methods correspond to the underlying C macros for field access,
usually with the leading "class indication" prefix removed (Sv, Av,
Hv, ...). The leading prefix is only left in cases where its removal
would cause a clash in method name. For example, C<GvREFCNT> stays
as-is since its abbreviation would clash with the "superclass" method
C<REFCNT> (corresponding to the C function C<SvREFCNT>).

=head2 B::SV Methods

=over 4

=item REFCNT

=item FLAGS

=item object_2svref

Returns a reference to the regular scalar corresponding to this
B::SV object. In other words, this method is the inverse operation
to the svref_2object() subroutine. This scalar and other data it points
at should be considered read-only: modifying them is neither safe nor
guaranteed to have a sensible effect.

=back

=head2 B::IV Methods

=over 4

=item IV

Returns the value of the IV, I<interpreted as
a signed integer>. This will be misleading
if C<FLAGS & SVf_IVisUV>. Perhaps you want the
C<int_value> method instead?

=item IVX

=item UVX

=item int_value

This method returns the value of the IV as an integer.
It differs from C<IV> in that it returns the correct
value regardless of whether it's stored signed or
unsigned.

=item needs64bits

=item packiv

=back

=head2 B::NV Methods

=over 4

=item NV

=item NVX

=back

=head2 B::RV Methods

=over 4

=item RV

=back

=head2 B::PV Methods

=over 4

=item PV

This method is the one you usually want. It constructs a
string using the length and offset information in the struct:
for ordinary scalars it will return the string that you'd see
from Perl, even if it contains null characters.

=item RV

Same as B::RV::RV, except that it will die() if the PV isn't
a reference.

=item PVX

This method is less often useful. It assumes that the string
stored in the struct is null-terminated, and disregards the
length information.

It is the appropriate method to use if you need to get the name
of a lexical variable from a padname array. Lexical variable names
are always stored with a null terminator, and the length field
(SvCUR) is overloaded for other purposes and can't be relied on here.

=back

=head2 B::PVMG Methods

=over 4

=item MAGIC

=item SvSTASH

=back

=head2 B::MAGIC Methods

=over 4

=item MOREMAGIC

=item precomp

Only valid on r-magic, returns the string that generated the regexp.

=item PRIVATE

=item TYPE

=item FLAGS

=item OBJ

Will die() if called on r-magic.

=item PTR

=item REGEX

Only valid on r-magic, returns the integer value of the REGEX stored
in the MAGIC.

=back

=head2 B::PVLV Methods

=over 4

=item TARGOFF

=item TARGLEN

=item TYPE

=item TARG

=back

=head2 B::BM Methods

=over 4

=item USEFUL

=item PREVIOUS

=item RARE

=item TABLE

=back

=head2 B::GV Methods

=over 4

=item is_empty

This method returns TRUE if the GP field of the GV is NULL.

=item NAME

=item SAFENAME

This method returns the name of the glob, but if the first
character of the name is a control character, then it converts
it to ^X first, so that *^G would return "^G" rather than "\cG".

It's useful if you want to print out the name of a variable.
If you restrict yourself to globs which exist at compile-time
then the result ought to be unambiguous, because code like
C<${"^G"} = 1> is compiled as two ops - a constant string and
a dereference (rv2gv) - so that the glob is created at runtime.

If you're working with globs at runtime, and need to disambiguate
*^G from *{"^G"}, then you should use the raw NAME method.

=item STASH

=item SV

=item IO

=item FORM

=item AV

=item HV

=item EGV

=item CV

=item CVGEN

=item LINE

=item FILE

=item FILEGV

=item GvREFCNT

=item FLAGS

=back

=head2 B::IO Methods

=over 4

=item LINES

=item PAGE

=item PAGE_LEN

=item LINES_LEFT

=item TOP_NAME

=item TOP_GV

=item FMT_NAME

=item FMT_GV

=item BOTTOM_NAME

=item BOTTOM_GV

=item SUBPROCESS

=item IoTYPE

=item IoFLAGS

=item IsSTD

Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
if the IoIFP of the object is equal to the handle whose name was
passed as argument ( i.e. $io->IsSTD('stderr') is true if
IoIFP($io) == PerlIO_stdin() ).

=back

=head2 B::AV Methods

=over 4

=item FILL

=item MAX

=item OFF

=item ARRAY

=item ARRAYelt

Like C<ARRAY>, but takes an index as an argument to get only one element,
rather than a list of all of them.

=item AvFLAGS

=back

=head2 B::CV Methods

=over 4

=item STASH

=item START

=item ROOT

=item GV

=item FILE

=item DEPTH

=item PADLIST

=item OUTSIDE

=item OUTSIDE_SEQ

=item XSUB

=item XSUBANY

For constant subroutines, returns the constant SV returned by the subroutine.

=item CvFLAGS

=item const_sv

=back

=head2 B::HV Methods

=over 4

=item FILL

=item MAX

=item KEYS

=item RITER

=item NAME

=item PMROOT

=item ARRAY

=back

=head2 OP-RELATED CLASSES

C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>.

These classes correspond in the obvious way to the underlying C
structures of similar names. The inheritance hierarchy mimics the
underlying C "inheritance":

                                 B::OP
                                   |
                   +---------------+--------+--------+
                   |               |        |        |
                B::UNOP          B::SVOP B::PADOP  B::COP
                 ,'  `-.
                /       `--.
           B::BINOP     B::LOGOP
               |
               |
           B::LISTOP
             ,' `.
            /     \
        B::LOOP B::PMOP

Access methods correspond to the underlying C structre field names,
with the leading "class indication" prefix (C<"op_">) removed.

=head2 B::OP Methods

These methods get the values of similarly named fields within the OP
data structure.  See top of C<op.h> for more info.

=over 4

=item next

=item sibling

=item name

This returns the op name as a string (e.g. "add", "rv2av").

=item ppaddr

This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
"PL_ppaddr[OP_RV2AV]").

=item desc

This returns the op description from the global C PL_op_desc array
(e.g. "addition" "array deref").

=item targ

=item type

=item opt

=item static

=item flags

=item private

=item spare

=back

=head2 B::UNOP METHOD

=over 4

=item first

=back

=head2 B::BINOP METHOD

=over 4

=item last

=back

=head2 B::LOGOP METHOD

=over 4

=item other

=back

=head2 B::LISTOP METHOD

=over 4

=item children

=back

=head2 B::PMOP Methods

=over 4

=item pmreplroot

=item pmreplstart

=item pmnext

=item pmregexp

=item pmflags

=item pmdynflags

=item pmpermflags

=item precomp

=item pmoffset

Only when perl was compiled with ithreads.

=back

=head2 B::SVOP METHOD

=over 4

=item sv

=item gv

=back

=head2 B::PADOP METHOD

=over 4

=item padix

=back

=head2 B::PVOP METHOD

=over 4

=item pv

=back

=head2 B::LOOP Methods

=over 4

=item redoop

=item nextop

=item lastop

=back

=head2 B::COP Methods

=over 4

=item label

=item stash

=item stashpv

=item file

=item cop_seq

=item arybase

=item line

=item warnings

=item io

=back


=head1 AUTHOR

Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # Generated from XSLoader.pm.PL (resolved %Config::Config value)

package XSLoader;

$VERSION = "0.06";

#use strict;

# enable debug/trace messages from DynaLoader perl code
# $dl_debug = $ENV{PERL_DL_DEBUG} || 0 unless defined $dl_debug;

  my $dl_dlext = 'so';

package DynaLoader;

# No prizes for guessing why we don't say 'bootstrap DynaLoader;' here.
# NOTE: All dl_*.xs (including dl_none.xs) define a dl_error() XSUB
boot_DynaLoader('DynaLoader') if defined(&boot_DynaLoader) &&
                                !defined(&dl_error);
package XSLoader;

sub load {
    package DynaLoader;

    die q{XSLoader::load('Your::Module', $Your::Module::VERSION)} unless @_;

    my($module) = $_[0];

    # work with static linking too
    my $b = "$module\::bootstrap";
    goto &$b if defined &$b;

    goto retry unless $module and defined &dl_load_file;

    my @modparts = split(/::/,$module);
    my $modfname = $modparts[-1];

    my $modpname = join('/',@modparts);
    my $modlibname = (caller())[1];
    my $c = @modparts;
    $modlibname =~ s,[\\/][^\\/]+$,, while $c--;	# Q&D basename
    my $file = "$modlibname/auto/$modpname/$modfname.$dl_dlext";

#   print STDERR "XSLoader::load for $module ($file)\n" if $dl_debug;

    my $bs = $file;
    $bs =~ s/(\.\w+)?(;\d*)?$/\.bs/; # look for .bs 'beside' the library

    goto retry if not -f $file or -s $bs;

    my $bootname = "boot_$module";
    $bootname =~ s/\W/_/g;
    @DynaLoader::dl_require_symbols = ($bootname);

    my $boot_symbol_ref;

    if ($^O eq 'darwin') {
        if ($boot_symbol_ref = dl_find_symbol(0, $bootname)) {
            goto boot; #extension library has already been loaded, e.g. darwin
        }
    }

    # Many dynamic extension loading problems will appear to come from
    # this section of code: XYZ failed at line 123 of DynaLoader.pm.
    # Often these errors are actually occurring in the initialisation
    # C code of the extension XS file. Perl reports the error as being
    # in this perl code simply because this was the last perl code
    # it executed.

    my $libref = dl_load_file($file, 0) or do { 
        require Carp;
        Carp::croak("Can't load '$file' for module $module: " . dl_error());
    };
    push(@DynaLoader::dl_librefs,$libref);  # record loaded object

    my @unresolved = dl_undef_symbols();
    if (@unresolved) {
        require Carp;
        Carp::carp("Undefined symbols present after loading $file: @unresolved\n");
    }

    $boot_symbol_ref = dl_find_symbol($libref, $bootname) or do {
        require Carp;
        Carp::croak("Can't find '$bootname' symbol in $file\n");
    };

    push(@DynaLoader::dl_modules, $module); # record loaded module

  boot:
    my $xs = dl_install_xsub("${module}::bootstrap", $boot_symbol_ref, $file);

    # See comment block above
    push(@DynaLoader::dl_shared_objects, $file); # record files loaded
    return &$xs(@_);

  retry:
    my $bootstrap_inherit = DynaLoader->can('bootstrap_inherit') || 
                            XSLoader->can('bootstrap_inherit');
    goto &$bootstrap_inherit;
}

# Versions of DynaLoader prior to 5.6.0 don't have this function.
sub bootstrap_inherit {
    package DynaLoader;

    my $module = $_[0];
    local *DynaLoader::isa = *{"$module\::ISA"};
    local @DynaLoader::isa = (@DynaLoader::isa, 'DynaLoader');
    # Cannot goto due to delocalization.  Will report errors on a wrong line?
    require DynaLoader;
    DynaLoader::bootstrap(@_);
}

1;


__END__

=head1 NAME

XSLoader - Dynamically load C libraries into Perl code

=head1 VERSION

Version 0.06

=head1 SYNOPSIS

    package YourPackage;
    use XSLoader;

    XSLoader::load 'YourPackage', $YourPackage::VERSION;

=head1 DESCRIPTION

This module defines a standard I<simplified> interface to the dynamic
linking mechanisms available on many platforms.  Its primary purpose is
to implement cheap automatic dynamic loading of Perl modules.

For a more complicated interface, see L<DynaLoader>.  Many (most)
features of C<DynaLoader> are not implemented in C<XSLoader>, like for
example the C<dl_load_flags>, not honored by C<XSLoader>.

=head2 Migration from C<DynaLoader>

A typical module using L<DynaLoader|DynaLoader> starts like this:

    package YourPackage;
    require DynaLoader;

    our @ISA = qw( OnePackage OtherPackage DynaLoader );
    our $VERSION = '0.01';
    bootstrap YourPackage $VERSION;

Change this to

    package YourPackage;
    use XSLoader;

    our @ISA = qw( OnePackage OtherPackage );
    our $VERSION = '0.01';
    XSLoader::load 'YourPackage', $VERSION;

In other words: replace C<require DynaLoader> by C<use XSLoader>, remove
C<DynaLoader> from C<@ISA>, change C<bootstrap> by C<XSLoader::load>.  Do not
forget to quote the name of your package on the C<XSLoader::load> line,
and add comma (C<,>) before the arguments (C<$VERSION> above).

Of course, if C<@ISA> contained only C<DynaLoader>, there is no need to have
the C<@ISA> assignment at all; moreover, if instead of C<our> one uses the
more backward-compatible

    use vars qw($VERSION @ISA);

one can remove this reference to C<@ISA> together with the C<@ISA> assignment.

If no C<$VERSION> was specified on the C<bootstrap> line, the last line becomes

    XSLoader::load 'YourPackage';

=head2 Backward compatible boilerplate

If you want to have your cake and eat it too, you need a more complicated
boilerplate.

    package YourPackage;
    use vars qw($VERSION @ISA);

    @ISA = qw( OnePackage OtherPackage );
    $VERSION = '0.01';
    eval {
       require XSLoader;
       XSLoader::load('YourPackage', $VERSION);
       1;
    } or do {
       require DynaLoader;
       push @ISA, 'DynaLoader';
       bootstrap YourPackage $VERSION;
    };

The parentheses about C<XSLoader::load()> arguments are needed since we replaced
C<use XSLoader> by C<require>, so the compiler does not know that a function
C<XSLoader::load()> is present.

This boilerplate uses the low-overhead C<XSLoader> if present; if used with
an antic Perl which has no C<XSLoader>, it falls back to using C<DynaLoader>.

=head1 Order of initialization: early load()

I<Skip this section if the XSUB functions are supposed to be called from other
modules only; read it only if you call your XSUBs from the code in your module,
or have a C<BOOT:> section in your XS file (see L<perlxs/"The BOOT: Keyword">).
What is described here is equally applicable to the L<DynaLoader|DynaLoader>
interface.>

A sufficiently complicated module using XS would have both Perl code (defined
in F<YourPackage.pm>) and XS code (defined in F<YourPackage.xs>).  If this
Perl code makes calls into this XS code, and/or this XS code makes calls to
the Perl code, one should be careful with the order of initialization.

The call to C<XSLoader::load()> (or C<bootstrap()>) has three side effects:

=over

=item *

if C<$VERSION> was specified, a sanity check is done to ensure that the
versions of the F<.pm> and the (compiled) F<.xs> parts are compatible;

=item *

the XSUBs are made accessible from Perl;

=item *

if a C<BOOT:> section was present in the F<.xs> file, the code there is called.

=back

Consequently, if the code in the F<.pm> file makes calls to these XSUBs, it is
convenient to have XSUBs installed before the Perl code is defined; for
example, this makes prototypes for XSUBs visible to this Perl code.
Alternatively, if the C<BOOT:> section makes calls to Perl functions (or
uses Perl variables) defined in the F<.pm> file, they must be defined prior to
the call to C<XSLoader::load()> (or C<bootstrap()>).

The first situation being much more frequent, it makes sense to rewrite the
boilerplate as

    package YourPackage;
    use XSLoader;
    use vars qw($VERSION @ISA);

    BEGIN {
       @ISA = qw( OnePackage OtherPackage );
       $VERSION = '0.01';

       # Put Perl code used in the BOOT: section here

       XSLoader::load 'YourPackage', $VERSION;
    }

    # Put Perl code making calls into XSUBs here

=head2 The most hairy case

If the interdependence of your C<BOOT:> section and Perl code is
more complicated than this (e.g., the C<BOOT:> section makes calls to Perl
functions which make calls to XSUBs with prototypes), get rid of the C<BOOT:>
section altogether.  Replace it with a function C<onBOOT()>, and call it like
this:

    package YourPackage;
    use XSLoader;
    use vars qw($VERSION @ISA);

    BEGIN {
       @ISA = qw( OnePackage OtherPackage );
       $VERSION = '0.01';
       XSLoader::load 'YourPackage', $VERSION;
    }

    # Put Perl code used in onBOOT() function here; calls to XSUBs are
    # prototype-checked.

    onBOOT;

    # Put Perl initialization code assuming that XS is initialized here


=head1 DIAGNOSTICS

=over 4

=item Can't find '%s' symbol in %s

B<(F)> The bootstrap symbol could not be found in the extension module.

=item Can't load '%s' for module %s: %s

B<(F)> The loading or initialisation of the extension module failed.
The detailed error follows.

=item Undefined symbols present after loading %s: %s

B<(W)> As the message says, some symbols stay undefined although the
extension module was correctly loaded and initialised. The list of undefined
symbols follows.

=item XSLoader::load('Your::Module', $Your::Module::VERSION)

B<(F)> You tried to invoke C<load()> without any argument. You must supply
a module name, and optionally its version.

=back


=head1 LIMITATIONS

To reduce the overhead as much as possible, only one possible location
is checked to find the extension DLL (this location is where C<make install>
would put the DLL).  If not found, the search for the DLL is transparently
delegated to C<DynaLoader>, which looks for the DLL along the C<@INC> list.

In particular, this is applicable to the structure of C<@INC> used for testing
not-yet-installed extensions.  This means that running uninstalled extensions
may have much more overhead than running the same extensions after
C<make install>.


=head1 BUGS

Please report any bugs or feature requests via the perlbug(1) utility.


=head1 SEE ALSO

L<DynaLoader>


=head1 AUTHORS

Ilya Zakharevich originally extracted C<XSLoader> from C<DynaLoader>.

CPAN version is currently maintained by SE<eacute>bastien Aperghis-Tramoni
E<lt>sebastien@aperghis.netE<gt>

Previous maintainer was Michael G Schwern <schwern@pobox.com>


=head1 COPYRIGHT

This program is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   require '_h2ph_pre.ph';

no warnings 'redefine';

unless(defined(&_FEATURES_H)) {
    eval 'sub _FEATURES_H () {1;}' unless defined(&_FEATURES_H);
    undef(&__USE_ISOC99) if defined(&__USE_ISOC99);
    undef(&__USE_POSIX) if defined(&__USE_POSIX);
    undef(&__USE_POSIX2) if defined(&__USE_POSIX2);
    undef(&__USE_POSIX199309) if defined(&__USE_POSIX199309);
    undef(&__USE_POSIX199506) if defined(&__USE_POSIX199506);
    undef(&__USE_XOPEN) if defined(&__USE_XOPEN);
    undef(&__USE_XOPEN_EXTENDED) if defined(&__USE_XOPEN_EXTENDED);
    undef(&__USE_UNIX98) if defined(&__USE_UNIX98);
    undef(&__USE_XOPEN2K) if defined(&__USE_XOPEN2K);
    undef(&__USE_LARGEFILE) if defined(&__USE_LARGEFILE);
    undef(&__USE_LARGEFILE64) if defined(&__USE_LARGEFILE64);
    undef(&__USE_FILE_OFFSET64) if defined(&__USE_FILE_OFFSET64);
    undef(&__USE_BSD) if defined(&__USE_BSD);
    undef(&__USE_SVID) if defined(&__USE_SVID);
    undef(&__USE_MISC) if defined(&__USE_MISC);
    undef(&__USE_ATFILE) if defined(&__USE_ATFILE);
    undef(&__USE_GNU) if defined(&__USE_GNU);
    undef(&__USE_REENTRANT) if defined(&__USE_REENTRANT);
    undef(&__USE_FORTIFY_LEVEL) if defined(&__USE_FORTIFY_LEVEL);
    undef(&__FAVOR_BSD) if defined(&__FAVOR_BSD);
    undef(&__KERNEL_STRICT_NAMES) if defined(&__KERNEL_STRICT_NAMES);
    unless(defined(&_LOOSE_KERNEL_NAMES)) {
	eval 'sub __KERNEL_STRICT_NAMES () {1;}' unless defined(&__KERNEL_STRICT_NAMES);
    }
    eval 'sub __USE_ANSI () {1;}' unless defined(&__USE_ANSI);
    if(defined (defined(&__GNUC__) ? &__GNUC__ : undef)  && defined (defined(&__GNUC_MINOR__) ? &__GNUC_MINOR__ : undef)) {
	eval 'sub __GNUC_PREREQ {
	    my($maj, $min) = @_;
    	    eval q((( &__GNUC__ << 16) +  &__GNUC_MINOR__ >= (($maj) << 16) + ($min)));
	}' unless defined(&__GNUC_PREREQ);
    } else {
	eval 'sub __GNUC_PREREQ {
	    my($maj, $min) = @_;
    	    eval q(0);
	}' unless defined(&__GNUC_PREREQ);
    }
    if(defined (defined(&_BSD_SOURCE) ? &_BSD_SOURCE : undef)  && !(defined (defined(&_POSIX_SOURCE) ? &_POSIX_SOURCE : undef) || defined (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) || defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) || defined (defined(&_XOPEN_SOURCE_EXTENDED) ? &_XOPEN_SOURCE_EXTENDED : undef) || defined (defined(&_GNU_SOURCE) ? &_GNU_SOURCE : undef) || defined (defined(&_SVID_SOURCE) ? &_SVID_SOURCE : undef))) {
	eval 'sub __FAVOR_BSD () {1;}' unless defined(&__FAVOR_BSD);
    }
    if(defined(&_GNU_SOURCE)) {
	undef(&_ISOC99_SOURCE) if defined(&_ISOC99_SOURCE);
	eval 'sub _ISOC99_SOURCE () {1;}' unless defined(&_ISOC99_SOURCE);
	undef(&_POSIX_SOURCE) if defined(&_POSIX_SOURCE);
	eval 'sub _POSIX_SOURCE () {1;}' unless defined(&_POSIX_SOURCE);
	undef(&_POSIX_C_SOURCE) if defined(&_POSIX_C_SOURCE);
	eval 'sub _POSIX_C_SOURCE () {200112;}' unless defined(&_POSIX_C_SOURCE);
	undef(&_XOPEN_SOURCE) if defined(&_XOPEN_SOURCE);
	eval 'sub _XOPEN_SOURCE () {600;}' unless defined(&_XOPEN_SOURCE);
	undef(&_XOPEN_SOURCE_EXTENDED) if defined(&_XOPEN_SOURCE_EXTENDED);
	eval 'sub _XOPEN_SOURCE_EXTENDED () {1;}' unless defined(&_XOPEN_SOURCE_EXTENDED);
	undef(&_LARGEFILE64_SOURCE) if defined(&_LARGEFILE64_SOURCE);
	eval 'sub _LARGEFILE64_SOURCE () {1;}' unless defined(&_LARGEFILE64_SOURCE);
	undef(&_BSD_SOURCE) if defined(&_BSD_SOURCE);
	eval 'sub _BSD_SOURCE () {1;}' unless defined(&_BSD_SOURCE);
	undef(&_SVID_SOURCE) if defined(&_SVID_SOURCE);
	eval 'sub _SVID_SOURCE () {1;}' unless defined(&_SVID_SOURCE);
	undef(&_ATFILE_SOURCE) if defined(&_ATFILE_SOURCE);
	eval 'sub _ATFILE_SOURCE () {1;}' unless defined(&_ATFILE_SOURCE);
    }
    if((!defined (defined(&__STRICT_ANSI__) ? &__STRICT_ANSI__ : undef)  && !defined (defined(&_ISOC99_SOURCE) ? &_ISOC99_SOURCE : undef)  && !defined (defined(&_POSIX_SOURCE) ? &_POSIX_SOURCE : undef)  && !defined (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef)  && !defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef)  && !defined (defined(&_XOPEN_SOURCE_EXTENDED) ? &_XOPEN_SOURCE_EXTENDED : undef)  && !defined (defined(&_BSD_SOURCE) ? &_BSD_SOURCE : undef)  && !defined (defined(&_SVID_SOURCE) ? &_SVID_SOURCE : undef))) {
	eval 'sub _BSD_SOURCE () {1;}' unless defined(&_BSD_SOURCE);
	eval 'sub _SVID_SOURCE () {1;}' unless defined(&_SVID_SOURCE);
    }
    if((defined (defined(&_ISOC99_SOURCE) ? &_ISOC99_SOURCE : undef) || defined (defined(&_ISOC9X_SOURCE) ? &_ISOC9X_SOURCE : undef) || (defined (defined(&__STDC_VERSION__) ? &__STDC_VERSION__ : undef)  && (defined(&__STDC_VERSION__) ? &__STDC_VERSION__ : undef) >= 199901))) {
	eval 'sub __USE_ISOC99 () {1;}' unless defined(&__USE_ISOC99);
    }
    if(((!defined (defined(&__STRICT_ANSI__) ? &__STRICT_ANSI__ : undef) || ((defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) - 0) >= 500)  && !defined (defined(&_POSIX_SOURCE) ? &_POSIX_SOURCE : undef)  && !defined (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef))) {
	eval 'sub _POSIX_SOURCE () {1;}' unless defined(&_POSIX_SOURCE);
	if(defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef)  && ((defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) - 0) < 500) {
	    eval 'sub _POSIX_C_SOURCE () {2;}' unless defined(&_POSIX_C_SOURCE);
	}
 elsif(defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef)  && ((defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) - 0) < 600) {
	    eval 'sub _POSIX_C_SOURCE () {199506;}' unless defined(&_POSIX_C_SOURCE);
	} else {
	    eval 'sub _POSIX_C_SOURCE () {200112;}' unless defined(&_POSIX_C_SOURCE);
	}
    }
    if(defined (defined(&_POSIX_SOURCE) ? &_POSIX_SOURCE : undef) || (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) >= 1|| defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef)) {
	eval 'sub __USE_POSIX () {1;}' unless defined(&__USE_POSIX);
    }
    if(defined (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef)  && (defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) >= 2|| defined (defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef)) {
	eval 'sub __USE_POSIX2 () {1;}' unless defined(&__USE_POSIX2);
    }
    if(((defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) - 0) >= 199309) {
	eval 'sub __USE_POSIX199309 () {1;}' unless defined(&__USE_POSIX199309);
    }
    if(((defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) - 0) >= 199506) {
	eval 'sub __USE_POSIX199506 () {1;}' unless defined(&__USE_POSIX199506);
    }
    if(((defined(&_POSIX_C_SOURCE) ? &_POSIX_C_SOURCE : undef) - 0) >= 200112) {
	eval 'sub __USE_XOPEN2K () {1;}' unless defined(&__USE_XOPEN2K);
    }
    if(defined(&_XOPEN_SOURCE)) {
	eval 'sub __USE_XOPEN () {1;}' unless defined(&__USE_XOPEN);
	if(((defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) - 0) >= 500) {
	    eval 'sub __USE_XOPEN_EXTENDED () {1;}' unless defined(&__USE_XOPEN_EXTENDED);
	    eval 'sub __USE_UNIX98 () {1;}' unless defined(&__USE_UNIX98);
	    undef(&_LARGEFILE_SOURCE) if defined(&_LARGEFILE_SOURCE);
	    eval 'sub _LARGEFILE_SOURCE () {1;}' unless defined(&_LARGEFILE_SOURCE);
	    if(((defined(&_XOPEN_SOURCE) ? &_XOPEN_SOURCE : undef) - 0) >= 600) {
		eval 'sub __USE_XOPEN2K () {1;}' unless defined(&__USE_XOPEN2K);
		undef(&__USE_ISOC99) if defined(&__USE_ISOC99);
		eval 'sub __USE_ISOC99 () {1;}' unless defined(&__USE_ISOC99);
	    }
	} else {
	    if(defined(&_XOPEN_SOURCE_EXTENDED)) {
		eval 'sub __USE_XOPEN_EXTENDED () {1;}' unless defined(&__USE_XOPEN_EXTENDED);
	    }
	}
    }
    if(defined(&_LARGEFILE_SOURCE)) {
	eval 'sub __USE_LARGEFILE () {1;}' unless defined(&__USE_LARGEFILE);
    }
    if(defined(&_LARGEFILE64_SOURCE)) {
	eval 'sub __USE_LARGEFILE64 () {1;}' unless defined(&__USE_LARGEFILE64);
    }
    if(defined (defined(&_FILE_OFFSET_BITS) ? &_FILE_OFFSET_BITS : undef)  && (defined(&_FILE_OFFSET_BITS) ? &_FILE_OFFSET_BITS : undef) == 64) {
	eval 'sub __USE_FILE_OFFSET64 () {1;}' unless defined(&__USE_FILE_OFFSET64);
    }
    if(defined (defined(&_BSD_SOURCE) ? &_BSD_SOURCE : undef) || defined (defined(&_SVID_SOURCE) ? &_SVID_SOURCE : undef)) {
	eval 'sub __USE_MISC () {1;}' unless defined(&__USE_MISC);
    }
    if(defined(&_BSD_SOURCE)) {
	eval 'sub __USE_BSD () {1;}' unless defined(&__USE_BSD);
    }
    if(defined(&_SVID_SOURCE)) {
	eval 'sub __USE_SVID () {1;}' unless defined(&__USE_SVID);
    }
    if(defined(&_ATFILE_SOURCE)) {
	eval 'sub __USE_ATFILE () {1;}' unless defined(&__USE_ATFILE);
    }
    if(defined(&_GNU_SOURCE)) {
	eval 'sub __USE_GNU () {1;}' unless defined(&__USE_GNU);
    }
    if(defined (defined(&_REENTRANT) ? &_REENTRANT : undef) || defined (defined(&_THREAD_SAFE) ? &_THREAD_SAFE : undef)) {
	eval 'sub __USE_REENTRANT () {1;}' unless defined(&__USE_REENTRANT);
    }
    if(defined (defined(&_FORTIFY_SOURCE) ? &_FORTIFY_SOURCE : undef)  && (defined(&_FORTIFY_SOURCE) ? &_FORTIFY_SOURCE : undef) > 0 && defined (defined(&__OPTIMIZE__) ? &__OPTIMIZE__ : undef)  && (defined(&__OPTIMIZE__) ? &__OPTIMIZE__ : undef) > 0 && ( &__GNUC_PREREQ (4, 1) || (defined (defined(&__GNUC_RH_RELEASE__) ? &__GNUC_RH_RELEASE__ : undef)  &&  &__GNUC_PREREQ (4, 0)) || (defined (defined(&__GNUC_RH_RELEASE__) ? &__GNUC_RH_RELEASE__ : undef)  &&  &__GNUC_PREREQ (3, 4)  && (defined(&__GNUC_MINOR__) ? &__GNUC_MINOR__ : undef) == 4 && ((defined(&__GNUC_PATCHLEVEL__) ? &__GNUC_PATCHLEVEL__ : undef) > 2|| ((defined(&__GNUC_PATCHLEVEL__) ? &__GNUC_PATCHLEVEL__ : undef) == 2 && (defined(&__GNUC_RH_RELEASE__) ? &__GNUC_RH_RELEASE__ : undef) >= 8))))) {
	if((defined(&_FORTIFY_SOURCE) ? &_FORTIFY_SOURCE : undef) > 1) {
	    eval 'sub __USE_FORTIFY_LEVEL () {2;}' unless defined(&__USE_FORTIFY_LEVEL);
	} else {
	    eval 'sub __USE_FORTIFY_LEVEL () {1;}' unless defined(&__USE_FORTIFY_LEVEL);
	}
    } else {
	eval 'sub __USE_FORTIFY_LEVEL () {0;}' unless defined(&__USE_FORTIFY_LEVEL);
    }
    eval 'sub __STDC_IEC_559__ () {1;}' unless defined(&__STDC_IEC_559__);
    eval 'sub __STDC_IEC_559_COMPLEX__ () {1;}' unless defined(&__STDC_IEC_559_COMPLEX__);
    eval 'sub __STDC_ISO_10646__ () {200009;}' unless defined(&__STDC_ISO_10646__);
    undef(&__GNU_LIBRARY__) if defined(&__GNU_LIBRARY__);
    eval 'sub __GNU_LIBRARY__ () {6;}' unless defined(&__GNU_LIBRARY__);
    eval 'sub __GLIBC__ () {2;}' unless defined(&__GLIBC__);
    eval 'sub __GLIBC_MINOR__ () {5;}' unless defined(&__GLIBC_MINOR__);
    eval 'sub __GLIBC_PREREQ {
        my($maj, $min) = @_;
	    eval q((( &__GLIBC__ << 16) +  &__GLIBC_MINOR__ >= (($maj) << 16) + ($min)));
    }' unless defined(&__GLIBC_PREREQ);
    if(defined (defined(&__GNUC__) ? &__GNUC__ : undef) || (defined (defined(&__PGI) ? &__PGI : undef)  && defined (defined(&__i386__) ? &__i386__ : undef) ) || (defined (defined(&__INTEL_COMPILER) ? &__INTEL_COMPILER : undef)  && (defined (defined(&__i386__) ? &__i386__ : undef) || defined (defined(&__ia64__) ? &__ia64__ : undef))) || (defined (defined(&__STDC_VERSION__) ? &__STDC_VERSION__ : undef)  && (defined(&__STDC_VERSION__) ? &__STDC_VERSION__ : undef) >= 199901)) {
	eval 'sub __GLIBC_HAVE_LONG_LONG () {1;}' unless defined(&__GLIBC_HAVE_LONG_LONG);
    }
    unless(defined(&__ASSEMBLER__)) {
	unless(defined(&_SYS_CDEFS_H)) {
	    require 'sys/cdefs.ph';
	}
	if(defined (defined(&__USE_FILE_OFFSET64) ? &__USE_FILE_OFFSET64 : undef)  && !defined (defined(&__REDIRECT) ? &__REDIRECT : undef)) {
	    eval 'sub __USE_LARGEFILE () {1;}' unless defined(&__USE_LARGEFILE);
	    eval 'sub __USE_LARGEFILE64 () {1;}' unless defined(&__USE_LARGEFILE64);
	}
    }
    if( &__GNUC_PREREQ (2, 7)  && defined (defined(&__OPTIMIZE__) ? &__OPTIMIZE__ : undef)  && !defined (defined(&__OPTIMIZE_SIZE__) ? &__OPTIMIZE_SIZE__ : undef)  && !defined (defined(&__NO_INLINE__) ? &__NO_INLINE__ : undef)) {
	eval 'sub __USE_EXTERN_INLINES () {1;}' unless defined(&__USE_EXTERN_INLINES);
    }
    require 'gnu/stubs.ph';
}
1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           #

package IO;

use XSLoader ();
use Carp;
use strict;
use warnings;

our $VERSION = "1.22";
XSLoader::load 'IO', $VERSION;

sub import {
    shift;

    warnings::warnif('deprecated', qq{Parameterless "use IO" deprecated})
        if @_ == 0 ;
    
    my @l = @_ ? @_ : qw(Handle Seekable File Pipe Socket Dir);

    eval join("", map { "require IO::" . (/(\w+)/)[0] . ";\n" } @l)
	or croak $@;
}

1;

__END__

=head1 NAME

IO - load various IO modules

=head1 SYNOPSIS

    use IO qw(Handle File);  # loads IO modules, here IO::Handle, IO::File
    use IO;                  # DEPRECATED

=head1 DESCRIPTION

C<IO> provides a simple mechanism to load several of the IO modules
in one go.  The IO modules belonging to the core are:

      IO::Handle
      IO::Seekable
      IO::File
      IO::Pipe
      IO::Socket
      IO::Dir
      IO::Select
      IO::Poll

Some other IO modules don't belong to the perl core but can be loaded
as well if they have been installed from CPAN.  You can discover which
ones exist by searching for "^IO::" on http://search.cpan.org.

For more information on any of these modules, please see its respective
documentation.

=head1 DEPRECATED

    use IO;                # loads all the modules listed below

The loaded modules are IO::Handle, IO::Seekable, IO::File, IO::Pipe,
IO::Socket, IO::Dir.  You should instead explicitly import the IO
modules you want.

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       #
# This file is auto-generated. ***ANY*** changes here will be lost
#

package Errno;
our (@EXPORT_OK,%EXPORT_TAGS,@ISA,$VERSION,%errno,$AUTOLOAD);
use Exporter ();
use Config;
use strict;

"$Config{'archname'}-$Config{'osvers'}" eq
"i386-linux-thread-multi-2.6.18-53.el5" or
	die "Errno architecture (i386-linux-thread-multi-2.6.18-53.el5) does not match executable architecture ($Config{'archname'}-$Config{'osvers'})";

$VERSION = "1.09_01";
$VERSION = eval $VERSION;
@ISA = qw(Exporter);

@EXPORT_OK = qw(EBADR ENOMSG ENOTSUP ESTRPIPE EADDRINUSE EL3HLT EBADF
	ENOTBLK ENAVAIL ECHRNG ENOTNAM ELNRNG ENOKEY EXDEV EBADE EBADSLT
	ECONNREFUSED ENOSTR ENONET EOVERFLOW EISCONN EFBIG EKEYREVOKED
	ECONNRESET EWOULDBLOCK ELIBMAX EREMOTEIO ERFKILL ENOPKG ELIBSCN
	EDESTADDRREQ ENOTSOCK EIO EMEDIUMTYPE EINPROGRESS ERANGE EAFNOSUPPORT
	EADDRNOTAVAIL EINTR EREMOTE EILSEQ ENOMEM EPIPE ENETUNREACH ENODATA
	EUSERS EOPNOTSUPP EPROTO EISNAM ESPIPE EALREADY ENAMETOOLONG ENOEXEC
	EISDIR EBADRQC EEXIST EDOTDOT ELIBBAD EOWNERDEAD ESRCH EFAULT EXFULL
	EDEADLOCK EAGAIN ENOPROTOOPT ENETDOWN EPROTOTYPE EL2NSYNC ENETRESET
	EUCLEAN EADV EROFS ESHUTDOWN EMULTIHOP EPROTONOSUPPORT ENFILE ENOLCK
	ECONNABORTED ECANCELED EDEADLK ESRMNT ENOLINK ETIME ENOTDIR EINVAL
	ENOTTY ENOANO ELOOP ENOENT EPFNOSUPPORT EBADMSG ENOMEDIUM EL2HLT EDOM
	EBFONT EKEYEXPIRED EMSGSIZE ENOCSI EL3RST ENOSPC EIDRM ENOBUFS ENOSYS
	EHOSTDOWN EBADFD ENOSR ENOTCONN ESTALE EDQUOT EKEYREJECTED EMFILE
	ENOTRECOVERABLE EACCES EBUSY E2BIG EPERM ELIBEXEC ETOOMANYREFS ELIBACC
	ENOTUNIQ ECOMM ERESTART ESOCKTNOSUPPORT EUNATCH ETIMEDOUT ENXIO ENODEV
	ETXTBSY EMLINK ECHILD EHOSTUNREACH EREMCHG ENOTEMPTY);
	
%EXPORT_TAGS = (
    POSIX => [qw(
	E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY
	EBADF EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK
	EDESTADDRREQ EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH
	EINPROGRESS EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK
	EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS
	ENODEV ENOENT ENOEXEC ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK
	ENOTCONN ENOTDIR ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM
	EPFNOSUPPORT EPIPE EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART
	EROFS ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT
	ETOOMANYREFS ETXTBSY EUSERS EWOULDBLOCK EXDEV
    )]
);

sub EPERM () { 1 }
sub ENOENT () { 2 }
sub ESRCH () { 3 }
sub EINTR () { 4 }
sub EIO () { 5 }
sub ENXIO () { 6 }
sub E2BIG () { 7 }
sub ENOEXEC () { 8 }
sub EBADF () { 9 }
sub ECHILD () { 10 }
sub EWOULDBLOCK () { 11 }
sub EAGAIN () { 11 }
sub ENOMEM () { 12 }
sub EACCES () { 13 }
sub EFAULT () { 14 }
sub ENOTBLK () { 15 }
sub EBUSY () { 16 }
sub EEXIST () { 17 }
sub EXDEV () { 18 }
sub ENODEV () { 19 }
sub ENOTDIR () { 20 }
sub EISDIR () { 21 }
sub EINVAL () { 22 }
sub ENFILE () { 23 }
sub EMFILE () { 24 }
sub ENOTTY () { 25 }
sub ETXTBSY () { 26 }
sub EFBIG () { 27 }
sub ENOSPC () { 28 }
sub ESPIPE () { 29 }
sub EROFS () { 30 }
sub EMLINK () { 31 }
sub EPIPE () { 32 }
sub EDOM () { 33 }
sub ERANGE () { 34 }
sub EDEADLOCK () { 35 }
sub EDEADLK () { 35 }
sub ENAMETOOLONG () { 36 }
sub ENOLCK () { 37 }
sub ENOSYS () { 38 }
sub ENOTEMPTY () { 39 }
sub ELOOP () { 40 }
sub ENOMSG () { 42 }
sub EIDRM () { 43 }
sub ECHRNG () { 44 }
sub EL2NSYNC () { 45 }
sub EL3HLT () { 46 }
sub EL3RST () { 47 }
sub ELNRNG () { 48 }
sub EUNATCH () { 49 }
sub ENOCSI () { 50 }
sub EL2HLT () { 51 }
sub EBADE () { 52 }
sub EBADR () { 53 }
sub EXFULL () { 54 }
sub ENOANO () { 55 }
sub EBADRQC () { 56 }
sub EBADSLT () { 57 }
sub EBFONT () { 59 }
sub ENOSTR () { 60 }
sub ENODATA () { 61 }
sub ETIME () { 62 }
sub ENOSR () { 63 }
sub ENONET () { 64 }
sub ENOPKG () { 65 }
sub EREMOTE () { 66 }
sub ENOLINK () { 67 }
sub EADV () { 68 }
sub ESRMNT () { 69 }
sub ECOMM () { 70 }
sub EPROTO () { 71 }
sub EMULTIHOP () { 72 }
sub EDOTDOT () { 73 }
sub EBADMSG () { 74 }
sub EOVERFLOW () { 75 }
sub ENOTUNIQ () { 76 }
sub EBADFD () { 77 }
sub EREMCHG () { 78 }
sub ELIBACC () { 79 }
sub ELIBBAD () { 80 }
sub ELIBSCN () { 81 }
sub ELIBMAX () { 82 }
sub ELIBEXEC () { 83 }
sub EILSEQ () { 84 }
sub ERESTART () { 85 }
sub ESTRPIPE () { 86 }
sub EUSERS () { 87 }
sub ENOTSOCK () { 88 }
sub EDESTADDRREQ () { 89 }
sub EMSGSIZE () { 90 }
sub EPROTOTYPE () { 91 }
sub ENOPROTOOPT () { 92 }
sub EPROTONOSUPPORT () { 93 }
sub ESOCKTNOSUPPORT () { 94 }
sub ENOTSUP () { 95 }
sub EOPNOTSUPP () { 95 }
sub EPFNOSUPPORT () { 96 }
sub EAFNOSUPPORT () { 97 }
sub EADDRINUSE () { 98 }
sub EADDRNOTAVAIL () { 99 }
sub ENETDOWN () { 100 }
sub ENETUNREACH () { 101 }
sub ENETRESET () { 102 }
sub ECONNABORTED () { 103 }
sub ECONNRESET () { 104 }
sub ENOBUFS () { 105 }
sub EISCONN () { 106 }
sub ENOTCONN () { 107 }
sub ESHUTDOWN () { 108 }
sub ETOOMANYREFS () { 109 }
sub ETIMEDOUT () { 110 }
sub ECONNREFUSED () { 111 }
sub EHOSTDOWN () { 112 }
sub EHOSTUNREACH () { 113 }
sub EALREADY () { 114 }
sub EINPROGRESS () { 115 }
sub ESTALE () { 116 }
sub EUCLEAN () { 117 }
sub ENOTNAM () { 118 }
sub ENAVAIL () { 119 }
sub EISNAM () { 120 }
sub EREMOTEIO () { 121 }
sub EDQUOT () { 122 }
sub ENOMEDIUM () { 123 }
sub EMEDIUMTYPE () { 124 }
sub ECANCELED () { 125 }
sub ENOKEY () { 126 }
sub EKEYEXPIRED () { 127 }
sub EKEYREVOKED () { 128 }
sub EKEYREJECTED () { 129 }
sub EOWNERDEAD () { 130 }
sub ENOTRECOVERABLE () { 131 }
sub ERFKILL () { 132 }

sub TIEHASH { bless [] }

sub FETCH {
    my ($self, $errname) = @_;
    my $proto = prototype("Errno::$errname");
    my $errno = "";
    if (defined($proto) && $proto eq "") {
	no strict 'refs';
	$errno = &$errname;
        $errno = 0 unless $! == $errno;
    }
    return $errno;
}

sub STORE {
    require Carp;
    Carp::confess("ERRNO hash is read only!");
}

*CLEAR = \&STORE;
*DELETE = \&STORE;

sub NEXTKEY {
    my($k,$v);
    while(($k,$v) = each %Errno::) {
	my $proto = prototype("Errno::$k");
	last if (defined($proto) && $proto eq "");
    }
    $k
}

sub FIRSTKEY {
    my $s = scalar keys %Errno::;	# initialize iterator
    goto &NEXTKEY;
}

sub EXISTS {
    my ($self, $errname) = @_;
    my $r = ref $errname;
    my $proto = !$r || $r eq 'CODE' ? prototype($errname) : undef;
    defined($proto) && $proto eq "";
}

tie %!, __PACKAGE__;

1;
__END__

=head1 NAME

Errno - System errno constants

=head1 SYNOPSIS

    use Errno qw(EINTR EIO :POSIX);

=head1 DESCRIPTION

C<Errno> defines and conditionally exports all the error constants
defined in your system C<errno.h> include file. It has a single export
tag, C<:POSIX>, which will export all POSIX defined error numbers.

C<Errno> also makes C<%!> magic such that each element of C<%!> has a
non-zero value only if C<$!> is set to that value. For example:

    use Errno;

    unless (open(FH, "/fangorn/spouse")) {
        if ($!{ENOENT}) {
            warn "Get a wife!\n";
        } else {
            warn "This path is barred: $!";
        } 
    } 

If a specified constant C<EFOO> does not exist on the system, C<$!{EFOO}>
returns C<"">.  You may use C<exists $!{EFOO}> to check whether the
constant is available on the system.

=head1 CAVEATS

Importing a particular constant may not be very portable, because the
import will fail on platforms that do not have that constant.  A more
portable way to set C<$!> to a valid value is to use:

    if (exists &Errno::EFOO) {
        $! = &Errno::EFOO;
    }

=head1 AUTHOR

Graham Barr <gbarr@pobox.com>

=head1 COPYRIGHT

Copyright (c) 1997-8 Graham Barr. All rights reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       package Fcntl;

=head1 NAME

Fcntl - load the C Fcntl.h defines

=head1 SYNOPSIS

    use Fcntl;
    use Fcntl qw(:DEFAULT :flock);

=head1 DESCRIPTION

This module is just a translation of the C F<fcntl.h> file.
Unlike the old mechanism of requiring a translated F<fcntl.ph>
file, this uses the B<h2xs> program (see the Perl source distribution)
and your native C compiler.  This means that it has a 
far more likely chance of getting the numbers right.

=head1 NOTE

Only C<#define> symbols get translated; you must still correctly
pack up your own arguments to pass as args for locking functions, etc.

=head1 EXPORTED SYMBOLS

By default your system's F_* and O_* constants (eg, F_DUPFD and
O_CREAT) and the FD_CLOEXEC constant are exported into your namespace.

You can request that the flock() constants (LOCK_SH, LOCK_EX, LOCK_NB
and LOCK_UN) be provided by using the tag C<:flock>.  See L<Exporter>.

You can request that the old constants (FAPPEND, FASYNC, FCREAT,
FDEFER, FEXCL, FNDELAY, FNONBLOCK, FSYNC, FTRUNC) be provided for
compatibility reasons by using the tag C<:Fcompat>.  For new
applications the newer versions of these constants are suggested
(O_APPEND, O_ASYNC, O_CREAT, O_DEFER, O_EXCL, O_NDELAY, O_NONBLOCK,
O_SYNC, O_TRUNC).

For ease of use also the SEEK_* constants (for seek() and sysseek(),
e.g. SEEK_END) and the S_I* constants (for chmod() and stat()) are
available for import.  They can be imported either separately or using
the tags C<:seek> and C<:mode>.

Please refer to your native fcntl(2), open(2), fseek(3), lseek(2)
(equal to Perl's seek() and sysseek(), respectively), and chmod(2)
documentation to see what constants are implemented in your system.

See L<perlopentut> to learn about the uses of the O_* constants
with sysopen().

See L<perlfunc/seek> and L<perlfunc/sysseek> about the SEEK_* constants.

See L<perlfunc/stat> about the S_I* constants.

=cut

our($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS, $AUTOLOAD);

require Exporter;
use XSLoader ();
@ISA = qw(Exporter);
$VERSION = "1.05";
# Items to export into callers namespace by default
# (move infrequently used names to @EXPORT_OK below)
@EXPORT =
  qw(
	FD_CLOEXEC
	F_ALLOCSP
	F_ALLOCSP64
	F_COMPAT
	F_DUP2FD
	F_DUPFD
	F_EXLCK
	F_FREESP
	F_FREESP64
	F_FSYNC
	F_FSYNC64
	F_GETFD
	F_GETFL
	F_GETLK
	F_GETLK64
	F_GETOWN
	F_NODNY
	F_POSIX
	F_RDACC
	F_RDDNY
	F_RDLCK
	F_RWACC
	F_RWDNY
	F_SETFD
	F_SETFL
	F_SETLK
	F_SETLK64
	F_SETLKW
	F_SETLKW64
	F_SETOWN
	F_SHARE
	F_SHLCK
	F_UNLCK
	F_UNSHARE
	F_WRACC
	F_WRDNY
	F_WRLCK
	O_ACCMODE
	O_ALIAS
	O_APPEND
	O_ASYNC
	O_BINARY
	O_CREAT
	O_DEFER
	O_DIRECT
	O_DIRECTORY
	O_DSYNC
	O_EXCL
	O_EXLOCK
	O_LARGEFILE
	O_NDELAY
	O_NOCTTY
	O_NOFOLLOW
	O_NOINHERIT
	O_NONBLOCK
	O_RANDOM
	O_RAW
	O_RDONLY
	O_RDWR
	O_RSRC
	O_RSYNC
	O_SEQUENTIAL
	O_SHLOCK
	O_SYNC
	O_TEMPORARY
	O_TEXT
	O_TRUNC
	O_WRONLY
     );

# Other items we are prepared to export if requested
@EXPORT_OK = qw(
	DN_ACCESS
	DN_ATTRIB
	DN_CREATE
	DN_DELETE
	DN_MODIFY
	DN_MULTISHOT
	DN_RENAME
	FAPPEND
	FASYNC
	FCREAT
	FDEFER
	FDSYNC
	FEXCL
	FLARGEFILE
	FNDELAY
	FNONBLOCK
	FRSYNC
	FSYNC
	FTRUNC
	F_GETLEASE
	F_GETSIG
	F_NOTIFY
	F_SETLEASE
	F_SETSIG
	LOCK_EX
	LOCK_MAND
	LOCK_NB
	LOCK_READ
	LOCK_RW
	LOCK_SH
	LOCK_UN
	LOCK_WRITE
	O_IGNORE_CTTY
	O_NOATIME
	O_NOLINK
	O_NOTRANS
	SEEK_CUR
	SEEK_END
	SEEK_SET
	S_IFSOCK S_IFBLK S_IFCHR S_IFIFO S_IFWHT S_ENFMT
	S_IREAD S_IWRITE S_IEXEC
	S_IRGRP S_IWGRP S_IXGRP S_IRWXG
	S_IROTH S_IWOTH S_IXOTH S_IRWXO
	S_IRUSR S_IWUSR S_IXUSR S_IRWXU
	S_ISUID S_ISGID S_ISVTX S_ISTXT
	_S_IFMT S_IFREG S_IFDIR S_IFLNK
	&S_ISREG &S_ISDIR &S_ISLNK &S_ISSOCK &S_ISBLK &S_ISCHR &S_ISFIFO
	&S_ISWHT &S_ISENFMT &S_IFMT &S_IMODE
);
# Named groups of exports
%EXPORT_TAGS = (
    'flock'   => [qw(LOCK_SH LOCK_EX LOCK_NB LOCK_UN)],
    'Fcompat' => [qw(FAPPEND FASYNC FCREAT FDEFER FDSYNC FEXCL FLARGEFILE
		     FNDELAY FNONBLOCK FRSYNC FSYNC FTRUNC)],
    'seek'    => [qw(SEEK_SET SEEK_CUR SEEK_END)],
    'mode'    => [qw(S_ISUID S_ISGID S_ISVTX S_ISTXT
		     _S_IFMT S_IFREG S_IFDIR S_IFLNK
		     S_IFSOCK S_IFBLK S_IFCHR S_IFIFO S_IFWHT S_ENFMT
		     S_IRUSR S_IWUSR S_IXUSR S_IRWXU
		     S_IRGRP S_IWGRP S_IXGRP S_IRWXG
		     S_IROTH S_IWOTH S_IXOTH S_IRWXO
		     S_IREAD S_IWRITE S_IEXEC
		     S_ISREG S_ISDIR S_ISLNK S_ISSOCK
		     S_ISBLK S_ISCHR S_ISFIFO
		     S_ISWHT S_ISENFMT		
		     S_IFMT S_IMODE
                  )],
);

sub S_IFMT  { @_ ? ( $_[0] & _S_IFMT() ) : _S_IFMT()  }
sub S_IMODE { $_[0] & 07777 }

sub S_ISREG    { ( $_[0] & _S_IFMT() ) == S_IFREG()   }
sub S_ISDIR    { ( $_[0] & _S_IFMT() ) == S_IFDIR()   }
sub S_ISLNK    { ( $_[0] & _S_IFMT() ) == S_IFLNK()   }
sub S_ISSOCK   { ( $_[0] & _S_IFMT() ) == S_IFSOCK()  }
sub S_ISBLK    { ( $_[0] & _S_IFMT() ) == S_IFBLK()   }
sub S_ISCHR    { ( $_[0] & _S_IFMT() ) == S_IFCHR()   }
sub S_ISFIFO   { ( $_[0] & _S_IFMT() ) == S_IFIFO()   }
sub S_ISWHT    { ( $_[0] & _S_IFMT() ) == S_IFWHT()   }
sub S_ISENFMT  { ( $_[0] & _S_IFMT() ) == S_IFENFMT() }

sub AUTOLOAD {
    (my $constname = $AUTOLOAD) =~ s/.*:://;
    die "&Fcntl::constant not defined" if $constname eq 'constant';
    my ($error, $val) = constant($constname);
    if ($error) {
        my (undef,$file,$line) = caller;
        die "$error at $file line $line.\n";
    }
    *$AUTOLOAD = sub { $val };
    goto &$AUTOLOAD;
}

XSLoader::load 'Fcntl', $VERSION;

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BE  .   'E  ..  CE Util                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CE  .   BE  ..  DE Call.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
# Call.pm
#
# Copyright (c) 1995-2001 Paul Marquess. All rights reserved.
#
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.
 
package Filter::Util::Call ;

require 5.002 ;
require DynaLoader;
require Exporter;
use Carp ;
use strict;
use warnings;
use vars qw($VERSION @ISA @EXPORT) ;

@ISA = qw(Exporter DynaLoader);
@EXPORT = qw( filter_add filter_del filter_read filter_read_exact) ;
$VERSION = "1.0601" ;

sub filter_read_exact($)
{
    my ($size)   = @_ ;
    my ($left)   = $size ;
    my ($status) ;

    croak ("filter_read_exact: size parameter must be > 0")
	unless $size > 0 ;

    # try to read a block which is exactly $size bytes long
    while ($left and ($status = filter_read($left)) > 0) {
        $left = $size - length $_ ;
    }

    # EOF with pending data is a special case
    return 1 if $status == 0 and length $_ ;

    return $status ;
}

sub filter_add($)
{
    my($obj) = @_ ;

    # Did we get a code reference?
    my $coderef = (ref $obj eq 'CODE') ;

    # If the parameter isn't already a reference, make it one.
    $obj = \$obj unless ref $obj ;

    $obj = bless ($obj, (caller)[0]) unless $coderef ;

    # finish off the installation of the filter in C.
    Filter::Util::Call::real_import($obj, (caller)[0], $coderef) ;
}

bootstrap Filter::Util::Call ;

1;
__END__

=head1 NAME

Filter::Util::Call - Perl Source Filter Utility Module

=head1 SYNOPSIS

    use Filter::Util::Call ;

=head1 DESCRIPTION

This module provides you with the framework to write I<Source Filters>
in Perl. 

An alternate interface to Filter::Util::Call is now available. See
L<Filter::Simple> for more details.

A I<Perl Source Filter> is implemented as a Perl module. The structure
of the module can take one of two broadly similar formats. To
distinguish between them, the first will be referred to as I<method
filter> and the second as I<closure filter>.

Here is a skeleton for the I<method filter>:

    package MyFilter ;

    use Filter::Util::Call ;

    sub import
    {
        my($type, @arguments) = @_ ;
        filter_add([]) ;
    }

    sub filter
    {
        my($self) = @_ ;
        my($status) ;

        $status = filter_read() ;
        $status ;
    }

    1 ;

and this is the equivalent skeleton for the I<closure filter>:

    package MyFilter ;

    use Filter::Util::Call ;

    sub import
    {
        my($type, @arguments) = @_ ;

        filter_add(
            sub 
            {
                my($status) ;
                $status = filter_read() ;
                $status ;
            } )
    }

    1 ;

To make use of either of the two filter modules above, place the line
below in a Perl source file.

    use MyFilter; 

In fact, the skeleton modules shown above are fully functional I<Source
Filters>, albeit fairly useless ones. All they does is filter the
source stream without modifying it at all.

As you can see both modules have a broadly similar structure. They both
make use of the C<Filter::Util::Call> module and both have an C<import>
method. The difference between them is that the I<method filter>
requires a I<filter> method, whereas the I<closure filter> gets the
equivalent of a I<filter> method with the anonymous sub passed to
I<filter_add>.

To make proper use of the I<closure filter> shown above you need to
have a good understanding of the concept of a I<closure>. See
L<perlref> for more details on the mechanics of I<closures>.

=head2 B<use Filter::Util::Call>

The following functions are exported by C<Filter::Util::Call>:

    filter_add()
    filter_read()
    filter_read_exact()
    filter_del()

=head2 B<import()>

The C<import> method is used to create an instance of the filter. It is
called indirectly by Perl when it encounters the C<use MyFilter> line
in a source file (See L<perlfunc/import> for more details on
C<import>).

It will always have at least one parameter automatically passed by Perl
- this corresponds to the name of the package. In the example above it
will be C<"MyFilter">.

Apart from the first parameter, import can accept an optional list of
parameters. These can be used to pass parameters to the filter. For
example:

    use MyFilter qw(a b c) ;

will result in the C<@_> array having the following values:

    @_ [0] => "MyFilter"
    @_ [1] => "a"
    @_ [2] => "b"
    @_ [3] => "c"

Before terminating, the C<import> function must explicitly install the
filter by calling C<filter_add>.

B<filter_add()>

The function, C<filter_add>, actually installs the filter. It takes one
parameter which should be a reference. The kind of reference used will
dictate which of the two filter types will be used.

If a CODE reference is used then a I<closure filter> will be assumed.

If a CODE reference is not used, a I<method filter> will be assumed.
In a I<method filter>, the reference can be used to store context
information. The reference will be I<blessed> into the package by
C<filter_add>.

See the filters at the end of this documents for examples of using
context information using both I<method filters> and I<closure
filters>.

=head2 B<filter() and anonymous sub>

Both the C<filter> method used with a I<method filter> and the
anonymous sub used with a I<closure filter> is where the main
processing for the filter is done.

The big difference between the two types of filter is that the I<method
filter> uses the object passed to the method to store any context data,
whereas the I<closure filter> uses the lexical variables that are
maintained by the closure.

Note that the single parameter passed to the I<method filter>,
C<$self>, is the same reference that was passed to C<filter_add>
blessed into the filter's package. See the example filters later on for
details of using C<$self>.

Here is a list of the common features of the anonymous sub and the
C<filter()> method.

=over 5

=item B<$_>

Although C<$_> doesn't actually appear explicitly in the sample filters
above, it is implicitly used in a number of places.

Firstly, when either C<filter> or the anonymous sub are called, a local
copy of C<$_> will automatically be created. It will always contain the
empty string at this point.

Next, both C<filter_read> and C<filter_read_exact> will append any
source data that is read to the end of C<$_>.

Finally, when C<filter> or the anonymous sub are finished processing,
they are expected to return the filtered source using C<$_>.

This implicit use of C<$_> greatly simplifies the filter.

=item B<$status>

The status value that is returned by the user's C<filter> method or
anonymous sub and the C<filter_read> and C<read_exact> functions take
the same set of values, namely:

    < 0  Error
    = 0  EOF
    > 0  OK

=item B<filter_read> and B<filter_read_exact>

These functions are used by the filter to obtain either a line or block
from the next filter in the chain or the actual source file if there
aren't any other filters.

The function C<filter_read> takes two forms:

    $status = filter_read() ;
    $status = filter_read($size) ;

The first form is used to request a I<line>, the second requests a
I<block>.

In line mode, C<filter_read> will append the next source line to the
end of the C<$_> scalar.

In block mode, C<filter_read> will append a block of data which is <=
C<$size> to the end of the C<$_> scalar. It is important to emphasise
the that C<filter_read> will not necessarily read a block which is
I<precisely> C<$size> bytes.

If you need to be able to read a block which has an exact size, you can
use the function C<filter_read_exact>. It works identically to
C<filter_read> in block mode, except it will try to read a block which
is exactly C<$size> bytes in length. The only circumstances when it
will not return a block which is C<$size> bytes long is on EOF or
error.

It is I<very> important to check the value of C<$status> after I<every>
call to C<filter_read> or C<filter_read_exact>.

=item B<filter_del>

The function, C<filter_del>, is used to disable the current filter. It
does not affect the running of the filter. All it does is tell Perl not
to call filter any more.

See L<Example 4: Using filter_del> for details.

=back

=head1 EXAMPLES

Here are a few examples which illustrate the key concepts - as such
most of them are of little practical use.

The C<examples> sub-directory has copies of all these filters
implemented both as I<method filters> and as I<closure filters>.

=head2 Example 1: A simple filter.

Below is a I<method filter> which is hard-wired to replace all
occurrences of the string C<"Joe"> to C<"Jim">. Not particularly
Useful, but it is the first example and I wanted to keep it simple.

    package Joe2Jim ;

    use Filter::Util::Call ;

    sub import
    {
        my($type) = @_ ;

        filter_add(bless []) ;
    }

    sub filter
    {
        my($self) = @_ ;
        my($status) ;

        s/Joe/Jim/g
            if ($status = filter_read()) > 0 ;
        $status ;
    }

    1 ;

Here is an example of using the filter:

    use Joe2Jim ;
    print "Where is Joe?\n" ;

And this is what the script above will print:

    Where is Jim?

=head2 Example 2: Using the context

The previous example was not particularly useful. To make it more
general purpose we will make use of the context data and allow any
arbitrary I<from> and I<to> strings to be used. This time we will use a
I<closure filter>. To reflect its enhanced role, the filter is called
C<Subst>.

    package Subst ;

    use Filter::Util::Call ;
    use Carp ;

    sub import
    {
        croak("usage: use Subst qw(from to)")
            unless @_ == 3 ;
        my ($self, $from, $to) = @_ ;
        filter_add(
            sub 
            {
                my ($status) ;
                s/$from/$to/
                    if ($status = filter_read()) > 0 ;
                $status ;
            })
    }
    1 ;

and is used like this:

    use Subst qw(Joe Jim) ;
    print "Where is Joe?\n" ;


=head2 Example 3: Using the context within the filter

Here is a filter which a variation of the C<Joe2Jim> filter. As well as
substituting all occurrences of C<"Joe"> to C<"Jim"> it keeps a count
of the number of substitutions made in the context object.

Once EOF is detected (C<$status> is zero) the filter will insert an
extra line into the source stream. When this extra line is executed it
will print a count of the number of substitutions actually made.
Note that C<$status> is set to C<1> in this case.

    package Count ;

    use Filter::Util::Call ;

    sub filter
    {
        my ($self) = @_ ;
        my ($status) ;

        if (($status = filter_read()) > 0 ) {
            s/Joe/Jim/g ;
	    ++ $$self ;
        }
	elsif ($$self >= 0) { # EOF
            $_ = "print q[Made ${$self} substitutions\n]" ;
            $status = 1 ;
	    $$self = -1 ;
        }

        $status ;
    }

    sub import
    {
        my ($self) = @_ ;
        my ($count) = 0 ;
        filter_add(\$count) ;
    }

    1 ;

Here is a script which uses it:

    use Count ;
    print "Hello Joe\n" ;
    print "Where is Joe\n" ;

Outputs:

    Hello Jim
    Where is Jim
    Made 2 substitutions

=head2 Example 4: Using filter_del

Another variation on a theme. This time we will modify the C<Subst>
filter to allow a starting and stopping pattern to be specified as well
as the I<from> and I<to> patterns. If you know the I<vi> editor, it is
the equivalent of this command:

    :/start/,/stop/s/from/to/

When used as a filter we want to invoke it like this:

    use NewSubst qw(start stop from to) ;

Here is the module.

    package NewSubst ;

    use Filter::Util::Call ;
    use Carp ;

    sub import
    {
        my ($self, $start, $stop, $from, $to) = @_ ;
        my ($found) = 0 ;
        croak("usage: use Subst qw(start stop from to)")
            unless @_ == 5 ;

        filter_add( 
            sub 
            {
                my ($status) ;

                if (($status = filter_read()) > 0) {

                    $found = 1
                        if $found == 0 and /$start/ ;

                    if ($found) {
                        s/$from/$to/ ;
                        filter_del() if /$stop/ ;
                    }

                }
                $status ;
            } )

    }

    1 ;

=head1 Filter::Simple

If you intend using the Filter::Call functionality, I would strongly
recommend that you check out Damian Conway's excellent Filter::Simple
module. Damian's module provides a much cleaner interface than
Filter::Util::Call. Although it doesn't allow the fine control that
Filter::Util::Call does, it should be adequate for the majority of
applications. It's available at

   http://www.cpan.org/modules/by-author/Damian_Conway/Filter-Simple.tar.gz
   http://www.csse.monash.edu.au/~damian/CPAN/Filter-Simple.tar.gz

=head1 AUTHOR

Paul Marquess 

=head1 DATE

26th January 1996

=cut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             package re;

our $VERSION = 0.05;

=head1 NAME

re - Perl pragma to alter regular expression behaviour

=head1 SYNOPSIS

    use re 'taint';
    ($x) = ($^X =~ /^(.*)$/s);     # $x is tainted here

    $pat = '(?{ $foo = 1 })';
    use re 'eval';
    /foo${pat}bar/;		   # won't fail (when not under -T switch)

    {
	no re 'taint';		   # the default
	($x) = ($^X =~ /^(.*)$/s); # $x is not tainted here

	no re 'eval';		   # the default
	/foo${pat}bar/;		   # disallowed (with or without -T switch)
    }

    use re 'debug';		   # NOT lexically scoped (as others are)
    /^(.*)$/s;			   # output debugging info during
    				   #     compile and run time

    use re 'debugcolor';	   # same as 'debug', but with colored output
    ...

(We use $^X in these examples because it's tainted by default.)

=head1 DESCRIPTION

When C<use re 'taint'> is in effect, and a tainted string is the target
of a regex, the regex memories (or values returned by the m// operator
in list context) are tainted.  This feature is useful when regex operations
on tainted data aren't meant to extract safe substrings, but to perform
other transformations.

When C<use re 'eval'> is in effect, a regex is allowed to contain
C<(?{ ... })> zero-width assertions even if regular expression contains
variable interpolation.  That is normally disallowed, since it is a
potential security risk.  Note that this pragma is ignored when the regular
expression is obtained from tainted data, i.e.  evaluation is always
disallowed with tainted regular expressions.  See L<perlre/(?{ code })>.

For the purpose of this pragma, interpolation of precompiled regular
expressions (i.e., the result of C<qr//>) is I<not> considered variable
interpolation.  Thus:

    /foo${pat}bar/

I<is> allowed if $pat is a precompiled regular expression, even
if $pat contains C<(?{ ... })> assertions.

When C<use re 'debug'> is in effect, perl emits debugging messages when
compiling and using regular expressions.  The output is the same as that
obtained by running a C<-DDEBUGGING>-enabled perl interpreter with the
B<-Dr> switch. It may be quite voluminous depending on the complexity
of the match.  Using C<debugcolor> instead of C<debug> enables a
form of output that can be used to get a colorful display on terminals
that understand termcap color sequences.  Set C<$ENV{PERL_RE_TC}> to a
comma-separated list of C<termcap> properties to use for highlighting
strings on/off, pre-point part on/off.
See L<perldebug/"Debugging regular expressions"> for additional info.

The directive C<use re 'debug'> is I<not lexically scoped>, as the
other directives are.  It has both compile-time and run-time effects.

See L<perlmodlib/Pragmatic Modules>.

=cut

# N.B. File::Basename contains a literal for 'taint' as a fallback.  If
# taint is changed here, File::Basename must be updated as well.
my %bitmask = (
taint		=> 0x00100000, # HINT_RE_TAINT
eval		=> 0x00200000, # HINT_RE_EVAL
);

sub setcolor {
 eval {				# Ignore errors
  require Term::Cap;

  my $terminal = Tgetent Term::Cap ({OSPEED => 9600}); # Avoid warning.
  my $props = $ENV{PERL_RE_TC} || 'md,me,so,se,us,ue';
  my @props = split /,/, $props;
  my $colors = join "\t", map {$terminal->Tputs($_,1)} @props;

  $colors =~ s/\0//g;
  $ENV{PERL_RE_COLORS} = $colors;
 };
}

sub bits {
    my $on = shift;
    my $bits = 0;
    unless (@_) {
	require Carp;
	Carp::carp("Useless use of \"re\" pragma");
    }
    foreach my $s (@_){
      if ($s eq 'debug' or $s eq 'debugcolor') {
 	  setcolor() if $s eq 'debugcolor';
	  require XSLoader;
	  XSLoader::load('re');
	  install() if $on;
	  uninstall() unless $on;
	  next;
      }
      if (exists $bitmask{$s}) {
	  $bits |= $bitmask{$s};
      } else {
	  require Carp;
	  Carp::carp("Unknown \"re\" subpragma '$s' (known ones are: @{[join(', ', map {qq('$_')} 'debug', 'debugcolor', sort keys %bitmask)]})");
      }
    }
    $bits;
}

sub import {
    shift;
    $^H |= bits(1, @_);
}

sub unimport {
    shift;
    $^H &= ~ bits(0, @_);
}

1;
                                                                              FE  .   'E  ..  GE  	PPPort.pm   HE  DProf.pmIE Peek.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ################################################################################
#
#  !!!!! Do NOT edit this file directly! -- Edit PPPort_pm.PL instead. !!!!!
#
################################################################################
#
#  Perl/Pollution/Portability
#
################################################################################
#
#  $Revision: 36 $
#  $Author: mhx $
#  $Date: 2005/06/25 17:56:28 +0200 $
#
################################################################################
#
#  Version 3.x, Copyright (C) 2004-2005, Marcus Holland-Moritz.
#  Version 2.x, Copyright (C) 2001, Paul Marquess.
#  Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
#
#  This program is free software; you can redistribute it and/or
#  modify it under the same terms as Perl itself.
#
################################################################################

=head1 NAME

Devel::PPPort - Perl/Pollution/Portability

=head1 SYNOPSIS

    Devel::PPPort::WriteFile();   # defaults to ./ppport.h
    Devel::PPPort::WriteFile('someheader.h');

=head1 DESCRIPTION

Perl's API has changed over time, gaining new features, new functions,
increasing its flexibility, and reducing the impact on the C namespace
environment (reduced pollution). The header file written by this module,
typically F<ppport.h>, attempts to bring some of the newer Perl API
features to older versions of Perl, so that you can worry less about
keeping track of old releases, but users can still reap the benefit.

C<Devel::PPPort> contains a single function, called C<WriteFile>. Its
only purpose is to write the F<ppport.h> C header file. This file
contains a series of macros and, if explicitly requested, functions that
allow XS modules to be built using older versions of Perl. Currently,
Perl versions from 5.003 to 5.9.3 are supported.

This module is used by C<h2xs> to write the file F<ppport.h>.

=head2 Why use ppport.h?

You should use F<ppport.h> in modern code so that your code will work
with the widest range of Perl interpreters possible, without significant
additional work.

You should attempt older code to fully use F<ppport.h>, because the
reduced pollution of newer Perl versions is an important thing. It's so
important that the old polluting ways of original Perl modules will not be
supported very far into the future, and your module will almost certainly
break! By adapting to it now, you'll gain compatibility and a sense of
having done the electronic ecology some good.

=head2 How to use ppport.h

Don't direct the users of your module to download C<Devel::PPPort>.
They are most probably no XS writers. Also, don't make F<ppport.h>
optional. Rather, just take the most recent copy of F<ppport.h> that
you can find (e.g. by generating it with the latest C<Devel::PPPort>
release from CPAN), copy it into your project, adjust your project to
use it, and distribute the header along with your module.

=head2 Running ppport.h

But F<ppport.h> is more than just a C header. It's also a Perl script
that can check your source code. It will suggest hints and portability
notes, and can even make suggestions on how to change your code. You
can run it like any other Perl program:

    perl ppport.h [options] [files]

It also has embedded documentation, so you can use

    perldoc ppport.h

to find out more about how to use it.

=head1 FUNCTIONS

=head2 WriteFile

C<WriteFile> takes one optional argument. When called with one
argument, it expects to be passed a filename. When called with
no arguments, it defaults to the filename F<ppport.h>.

The function returns a true value if the file was written successfully.
Otherwise it returns a false value.

=head1 COMPATIBILITY

F<ppport.h> supports Perl versions from 5.003 to 5.9.3
in threaded and non-threaded configurations.

=head2 Provided Perl compatibility API

The header file written by this module, typically F<ppport.h>, provides
access to the following elements of the Perl API that is not available
in older Perl releases:

    _aMY_CXT
    _pMY_CXT
    aMY_CXT
    aMY_CXT_
    aTHX
    aTHX_
    AvFILLp
    boolSV
    call_argv
    call_method
    call_pv
    call_sv
    CopFILE
    CopFILE_set
    CopFILEAV
    CopFILEGV
    CopFILEGV_set
    CopFILESV
    CopSTASH
    CopSTASH_eq
    CopSTASH_set
    CopSTASHPV
    CopSTASHPV_set
    CopyD
    dAX
    DEFSV
    dITEMS
    dMY_CXT
    dMY_CXT_SV
    dNOOP
    dTHR
    dTHX
    dTHXa
    dTHXoa
    dUNDERBAR
    dXCPT
    dXSTARG
    END_EXTERN_C
    ERRSV
    eval_pv
    eval_sv
    EXTERN_C
    get_av
    get_cv
    get_hv
    get_sv
    grok_bin
    grok_hex
    grok_number
    GROK_NUMERIC_RADIX
    grok_numeric_radix
    grok_oct
    gv_stashpvn
    IN_LOCALE
    IN_LOCALE_COMPILETIME
    IN_LOCALE_RUNTIME
    IN_PERL_COMPILETIME
    INT2PTR
    IS_NUMBER_GREATER_THAN_UV_MAX
    IS_NUMBER_IN_UV
    IS_NUMBER_INFINITY
    IS_NUMBER_NAN
    IS_NUMBER_NEG
    IS_NUMBER_NOT_INT
    IVdf
    IVSIZE
    IVTYPE
    memEQ
    memNE
    MoveD
    mPUSHi
    mPUSHn
    mPUSHp
    mPUSHu
    mXPUSHi
    mXPUSHn
    mXPUSHp
    mXPUSHu
    MY_CXT
    MY_CXT_CLONE
    MY_CXT_INIT
    newCONSTSUB
    newRV_inc
    newRV_noinc
    newSVpvn
    newSVuv
    NOOP
    NUM2PTR
    NVef
    NVff
    NVgf
    NVTYPE
    PERL_BCDVERSION
    PERL_GCC_BRACE_GROUPS_FORBIDDEN
    PERL_INT_MAX
    PERL_INT_MIN
    PERL_LONG_MAX
    PERL_LONG_MIN
    PERL_MAGIC_arylen
    PERL_MAGIC_backref
    PERL_MAGIC_bm
    PERL_MAGIC_collxfrm
    PERL_MAGIC_dbfile
    PERL_MAGIC_dbline
    PERL_MAGIC_defelem
    PERL_MAGIC_env
    PERL_MAGIC_envelem
    PERL_MAGIC_ext
    PERL_MAGIC_fm
    PERL_MAGIC_glob
    PERL_MAGIC_isa
    PERL_MAGIC_isaelem
    PERL_MAGIC_mutex
    PERL_MAGIC_nkeys
    PERL_MAGIC_overload
    PERL_MAGIC_overload_elem
    PERL_MAGIC_overload_table
    PERL_MAGIC_pos
    PERL_MAGIC_qr
    PERL_MAGIC_regdata
    PERL_MAGIC_regdatum
    PERL_MAGIC_regex_global
    PERL_MAGIC_shared
    PERL_MAGIC_shared_scalar
    PERL_MAGIC_sig
    PERL_MAGIC_sigelem
    PERL_MAGIC_substr
    PERL_MAGIC_sv
    PERL_MAGIC_taint
    PERL_MAGIC_tied
    PERL_MAGIC_tiedelem
    PERL_MAGIC_tiedscalar
    PERL_MAGIC_utf8
    PERL_MAGIC_uvar
    PERL_MAGIC_uvar_elem
    PERL_MAGIC_vec
    PERL_MAGIC_vstring
    PERL_QUAD_MAX
    PERL_QUAD_MIN
    PERL_REVISION
    PERL_SCAN_ALLOW_UNDERSCORES
    PERL_SCAN_DISALLOW_PREFIX
    PERL_SCAN_GREATER_THAN_UV_MAX
    PERL_SCAN_SILENT_ILLDIGIT
    PERL_SHORT_MAX
    PERL_SHORT_MIN
    PERL_SUBVERSION
    PERL_UCHAR_MAX
    PERL_UCHAR_MIN
    PERL_UINT_MAX
    PERL_UINT_MIN
    PERL_ULONG_MAX
    PERL_ULONG_MIN
    PERL_UNUSED_DECL
    PERL_UQUAD_MAX
    PERL_UQUAD_MIN
    PERL_USHORT_MAX
    PERL_USHORT_MIN
    PERL_VERSION
    PL_compiling
    PL_copline
    PL_curcop
    PL_curstash
    PL_DBsingle
    PL_DBsub
    PL_debstash
    PL_defgv
    PL_diehook
    PL_dirty
    PL_dowarn
    PL_errgv
    PL_hexdigit
    PL_hints
    PL_na
    PL_no_modify
    PL_perl_destruct_level
    PL_perldb
    PL_ppaddr
    PL_rsfp
    PL_rsfp_filters
    PL_stack_base
    PL_stack_sp
    PL_stdingv
    PL_Sv
    PL_sv_arenaroot
    PL_sv_no
    PL_sv_undef
    PL_sv_yes
    PL_tainted
    PL_tainting
    pMY_CXT
    pMY_CXT_
    Poison
    pTHX
    pTHX_
    PTR2IV
    PTR2NV
    PTR2ul
    PTR2UV
    PTRV
    PUSHmortal
    PUSHu
    SAVE_DEFSV
    START_EXTERN_C
    START_MY_CXT
    STMT_END
    STMT_START
    sv_2pv_nolen
    sv_2pvbyte
    sv_2uv
    sv_catpv_mg
    sv_catpvf_mg
    sv_catpvf_mg_nocontext
    sv_catpvn_mg
    sv_catpvn_nomg
    sv_catsv_mg
    sv_catsv_nomg
    sv_pvn
    sv_pvn_force
    sv_pvn_nomg
    sv_setiv_mg
    sv_setnv_mg
    sv_setpv_mg
    sv_setpvf_mg
    sv_setpvf_mg_nocontext
    sv_setpvn_mg
    sv_setsv_mg
    sv_setsv_nomg
    sv_setuv
    sv_setuv_mg
    sv_usepvn_mg
    sv_uv
    sv_vcatpvf
    sv_vcatpvf_mg
    sv_vsetpvf
    sv_vsetpvf_mg
    SvGETMAGIC
    SvIV_nomg
    SvPV_force_nomg
    SvPV_nolen
    SvPV_nomg
    SvPVbyte
    SvUV
    SvUV_nomg
    SvUVX
    SvUVx
    SvUVXx
    UNDERBAR
    UVof
    UVSIZE
    UVTYPE
    UVuf
    UVXf
    UVxf
    vnewSVpvf
    XCPT_CATCH
    XCPT_RETHROW
    XCPT_TRY_END
    XCPT_TRY_START
    XPUSHmortal
    XPUSHu
    XSRETURN_UV
    XST_mUV
    ZeroD

=head2 Perl API not supported by ppport.h

There is still a big part of the API not supported by F<ppport.h>.
Either because it doesn't make sense to back-port that part of the API,
or simply because it hasn't been implemented yet. Patches welcome!

Here's a list of the currently unsupported API, and also the version of
Perl below which it is unsupported:

=over 4

=item perl 5.9.3

  SvMAGIC_set
  SvRV_set
  SvSTASH_set
  SvUV_set
  av_arylen_p
  dAXMARK
  hv_eiter_p
  hv_eiter_set
  hv_name_set
  hv_placeholders_get
  hv_placeholders_p
  hv_placeholders_set
  hv_riter_p
  hv_riter_set
  is_utf8_string_loclen
  newSVhek
  newWHILEOP
  stashpv_hvname_match

=item perl 5.9.2

  SvPVbyte_force
  find_rundefsvoffset
  gv_fetchpvn_flags
  gv_fetchsv
  op_refcnt_lock
  op_refcnt_unlock
  savesvpv
  vnormal

=item perl 5.9.1

  hv_assert
  hv_clear_placeholders
  hv_scalar
  scan_version
  sv_2iv_flags
  sv_2uv_flags

=item perl 5.9.0

  new_version
  save_set_svflags
  upg_version
  vcmp
  vnumify
  vstringify

=item perl 5.8.3

  SvIsCOW
  SvIsCOW_shared_hash

=item perl 5.8.1

  SvVOK
  doing_taint
  is_utf8_string_loc
  packlist
  save_bool
  savestack_grow_cnt
  scan_vstring
  sv_cat_decode
  sv_compile_2op
  sv_setpviv
  sv_setpviv_mg
  unpackstring

=item perl 5.8.0

  hv_iternext_flags
  hv_store_flags
  is_utf8_idcont
  nothreadhook

=item perl 5.7.3

  PerlIO_clearerr
  PerlIO_close
  PerlIO_eof
  PerlIO_error
  PerlIO_fileno
  PerlIO_fill
  PerlIO_flush
  PerlIO_get_base
  PerlIO_get_bufsiz
  PerlIO_get_cnt
  PerlIO_get_ptr
  PerlIO_read
  PerlIO_seek
  PerlIO_set_cnt
  PerlIO_set_ptrcnt
  PerlIO_setlinebuf
  PerlIO_stderr
  PerlIO_stdin
  PerlIO_stdout
  PerlIO_tell
  PerlIO_unread
  PerlIO_write
  SvLOCK
  SvSHARE
  SvUNLOCK
  atfork_lock
  atfork_unlock
  custom_op_desc
  custom_op_name
  deb
  debstack
  debstackptrs
  gv_fetchmeth_autoload
  ibcmp_utf8
  my_fork
  my_socketpair
  pack_cat
  perl_destruct
  pv_uni_display
  regclass_swash
  save_shared_pvref
  savesharedpv
  sortsv
  sv_copypv
  sv_magicext
  sv_nolocking
  sv_nosharing
  sv_nounlocking
  sv_recode_to_utf8
  sv_uni_display
  to_uni_fold
  to_uni_lower
  to_uni_title
  to_uni_upper
  to_utf8_case
  to_utf8_fold
  to_utf8_lower
  to_utf8_title
  to_utf8_upper
  unpack_str
  uvchr_to_utf8_flags
  uvuni_to_utf8_flags
  vdeb

=item perl 5.7.2

  calloc
  getcwd_sv
  init_tm
  malloc
  mfree
  mini_mktime
  my_atof2
  my_strftime
  op_null
  realloc
  sv_2pv_flags
  sv_catpvn_flags
  sv_catsv_flags
  sv_pvn_force_flags
  sv_setsv_flags
  sv_utf8_upgrade_flags
  swash_fetch

=item perl 5.7.1

  POPpbytex
  SvUOK
  bytes_from_utf8
  csighandler
  despatch_signals
  do_openn
  gv_handler
  is_lvalue_sub
  my_popen_list
  newSVpvn_share
  save_mortalizesv
  save_padsv
  scan_num
  sv_force_normal_flags
  sv_setref_uv
  sv_unref_flags
  sv_utf8_upgrade
  utf8_length
  utf8_to_uvchr
  utf8_to_uvuni
  utf8n_to_uvchr
  utf8n_to_uvuni
  uvchr_to_utf8
  uvuni_to_utf8

=item perl 5.6.1

  apply_attrs_string
  bytes_to_utf8
  gv_efullname4
  gv_fullname4
  is_utf8_string
  save_generic_pvref
  utf16_to_utf8
  utf16_to_utf8_reversed
  utf8_to_bytes

=item perl 5.6.0

  SvIOK_UV
  SvIOK_notUV
  SvIOK_only_UV
  SvPOK_only_UTF8
  SvPVbyte_nolen
  SvPVbytex
  SvPVbytex_force
  SvPVutf8
  SvPVutf8_force
  SvPVutf8_nolen
  SvPVutf8x
  SvPVutf8x_force
  SvUTF8
  SvUTF8_off
  SvUTF8_on
  av_delete
  av_exists
  call_atexit
  cast_i32
  cast_iv
  cast_ulong
  cast_uv
  do_gv_dump
  do_gvgv_dump
  do_hv_dump
  do_magic_dump
  do_op_dump
  do_open9
  do_pmop_dump
  do_sv_dump
  dump_all
  dump_eval
  dump_form
  dump_indent
  dump_packsubs
  dump_sub
  dump_vindent
  get_context
  get_ppaddr
  gv_dump
  init_i18nl10n
  init_i18nl14n
  is_uni_alnum
  is_uni_alnum_lc
  is_uni_alnumc
  is_uni_alnumc_lc
  is_uni_alpha
  is_uni_alpha_lc
  is_uni_ascii
  is_uni_ascii_lc
  is_uni_cntrl
  is_uni_cntrl_lc
  is_uni_digit
  is_uni_digit_lc
  is_uni_graph
  is_uni_graph_lc
  is_uni_idfirst
  is_uni_idfirst_lc
  is_uni_lower
  is_uni_lower_lc
  is_uni_print
  is_uni_print_lc
  is_uni_punct
  is_uni_punct_lc
  is_uni_space
  is_uni_space_lc
  is_uni_upper
  is_uni_upper_lc
  is_uni_xdigit
  is_uni_xdigit_lc
  is_utf8_alnum
  is_utf8_alnumc
  is_utf8_alpha
  is_utf8_ascii
  is_utf8_char
  is_utf8_cntrl
  is_utf8_digit
  is_utf8_graph
  is_utf8_idfirst
  is_utf8_lower
  is_utf8_mark
  is_utf8_print
  is_utf8_punct
  is_utf8_space
  is_utf8_upper
  is_utf8_xdigit
  load_module
  magic_dump
  mess
  my_atof
  my_fflush_all
  newANONATTRSUB
  newATTRSUB
  newMYSUB
  newPADOP
  newXS
  newXSproto
  new_collate
  new_ctype
  new_numeric
  op_dump
  perl_parse
  pmop_dump
  pv_display
  re_intuit_start
  re_intuit_string
  reginitcolors
  require_pv
  safesyscalloc
  safesysfree
  safesysmalloc
  safesysrealloc
  save_I8
  save_alloc
  save_destructor
  save_destructor_x
  save_re_context
  save_vptr
  scan_bin
  set_context
  set_numeric_local
  set_numeric_radix
  set_numeric_standard
  str_to_version
  sv_2pvutf8
  sv_2pvutf8_nolen
  sv_force_normal
  sv_len_utf8
  sv_pos_b2u
  sv_pos_u2b
  sv_pv
  sv_pvbyte
  sv_pvbyten
  sv_pvbyten_force
  sv_pvutf8
  sv_pvutf8n
  sv_pvutf8n_force
  sv_rvweaken
  sv_utf8_decode
  sv_utf8_downgrade
  sv_utf8_encode
  swash_init
  tmps_grow
  to_uni_lower_lc
  to_uni_title_lc
  to_uni_upper_lc
  utf8_distance
  utf8_hop
  vcroak
  vform
  vload_module
  vmess
  vwarn
  vwarner
  warner

=item perl 5.005_03

  POPpx
  get_vtbl
  save_generic_svref

=item perl 5.005

  PL_modglobal
  cx_dump
  debop
  debprofdump
  fbm_compile
  fbm_instr
  get_op_descs
  get_op_names
  init_stacks
  mg_length
  mg_size
  newHVhv
  new_stackinfo
  regdump
  regexec_flags
  regnext
  runops_debug
  runops_standard
  save_hints
  save_iv
  save_threadsv
  screaminstr
  sv_iv
  sv_nv
  sv_peek
  sv_true

=item perl 5.004_05

  do_binmode
  save_aelem
  save_helem

=item perl 5.004

  GIMME_V
  G_VOID
  HEf_SVKEY
  HeHASH
  HeKEY
  HeKLEN
  HePV
  HeSVKEY
  HeSVKEY_force
  HeSVKEY_set
  HeVAL
  SvSetMagicSV
  SvSetMagicSV_nosteal
  SvSetSV_nosteal
  SvTAINTED
  SvTAINTED_off
  SvTAINTED_on
  block_gimme
  call_list
  cv_const_sv
  delimcpy
  do_open
  form
  gv_autoload4
  gv_efullname3
  gv_fetchmethod_autoload
  gv_fullname3
  hv_delayfree_ent
  hv_delete_ent
  hv_exists_ent
  hv_fetch_ent
  hv_free_ent
  hv_iterkeysv
  hv_ksplit
  hv_store_ent
  ibcmp_locale
  my_failure_exit
  my_memcmp
  my_pclose
  my_popen
  newSVpvf
  rsignal
  rsignal_state
  save_I16
  save_gp
  start_subparse
  sv_catpvf
  sv_catpvf_mg
  sv_cmp_locale
  sv_derived_from
  sv_gets
  sv_setpvf
  sv_setpvf_mg
  sv_taint
  sv_tainted
  sv_untaint
  sv_vcatpvf
  sv_vcatpvf_mg
  sv_vcatpvfn
  sv_vsetpvf
  sv_vsetpvf_mg
  sv_vsetpvfn
  unsharepvn
  vnewSVpvf

=back

=head1 BUGS

If you find any bugs, C<Devel::PPPort> doesn't seem to build on your
system or any of its tests fail, please use the CPAN Request Tracker
at L<http://rt.cpan.org/> to create a ticket for the module.

=head1 AUTHORS

=over 2

=item *

Version 1.x of Devel::PPPort was written by Kenneth Albanowski.

=item *

Version 2.x was ported to the Perl core by Paul Marquess.

=item *

Version 3.x was ported back to CPAN by Marcus Holland-Moritz.

=back

=head1 COPYRIGHT

Version 3.x, Copyright (C) 2004-2005, Marcus Holland-Moritz.

Version 2.x, Copyright (C) 2001, Paul Marquess.

Version 1.x, Copyright (C) 1999, Kenneth Albanowski.

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

See L<h2xs>, L<ppport.h>.

=cut

package Devel::PPPort;

require DynaLoader;
use strict;
use vars qw($VERSION @ISA $data);

$VERSION = do { my @r = '$Snapshot: /Devel-PPPort/3.06_01 $' =~ /(\d+\.\d+(?:_\d+)?)/; @r ? $r[0] : '9.99' };

@ISA = qw(DynaLoader);

bootstrap Devel::PPPort;

sub _init_data
{
  $data = do { local $/; <DATA> };
  my $now = localtime;
  my $pkg = 'Devel::PPPort';
  $data =~ s/__PERL_VERSION__/$]/g;
  $data =~ s/__VERSION__/$VERSION/g;
  $data =~ s/__DATE__/$now/g;
  $data =~ s/__PKG__/$pkg/g;
  $data =~ s/^\|>//gm;
}

sub WriteFile
{
  my $file = shift || 'ppport.h';
  defined $data or _init_data();
  my $copy = $data;
  $copy =~ s/\bppport\.h\b/$file/g;

  open F, ">$file" or return undef;
  print F $copy;
  close F;

  return 1;
}

1;

__DATA__
#if 0
<<'SKIP';
#endif
/*
----------------------------------------------------------------------

    ppport.h -- Perl/Pollution/Portability Version __VERSION__

    Automatically created by __PKG__ running under
    perl __PERL_VERSION__ on __DATE__.

    Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
    includes in parts/inc/ instead.

    Use 'perldoc ppport.h' to view the documentation below.

----------------------------------------------------------------------

SKIP

|>=pod
|>
|>=head1 NAME
|>
|>ppport.h - Perl/Pollution/Portability version __VERSION__
|>
|>=head1 SYNOPSIS
|>
|>  perl ppport.h [options] [source files]
|>
|>  Searches current directory for files if no [source files] are given
|>
|>  --help                      show short help
|>
|>  --patch=file                write one patch file with changes
|>  --copy=suffix               write changed copies with suffix
|>  --diff=program              use diff program and options
|>
|>  --compat-version=version    provide compatibility with Perl version
|>  --cplusplus                 accept C++ comments
|>
|>  --quiet                     don't output anything except fatal errors
|>  --nodiag                    don't show diagnostics
|>  --nohints                   don't show hints
|>  --nochanges                 don't suggest changes
|>  --nofilter                  don't filter input files
|>
|>  --list-provided             list provided API
|>  --list-unsupported          list unsupported API
|>  --api-info=name             show Perl API portability information
|>
|>=head1 COMPATIBILITY
|>
|>This version of F<ppport.h> is designed to support operation with Perl
|>installations back to 5.003, and has been tested up to 5.9.3.
|>
|>=head1 OPTIONS
|>
|>=head2 --help
|>
|>Display a brief usage summary.
|>
|>=head2 --patch=I<file>
|>
|>If this option is given, a single patch file will be created if
|>any changes are suggested. This requires a working diff program
|>to be installed on your system.
|>
|>=head2 --copy=I<suffix>
|>
|>If this option is given, a copy of each file will be saved with
|>the given suffix that contains the suggested changes. This does
|>not require any external programs.
|>
|>If neither C<--patch> or C<--copy> are given, the default is to
|>simply print the diffs for each file. This requires either
|>C<Text::Diff> or a C<diff> program to be installed.
|>
|>=head2 --diff=I<program>
|>
|>Manually set the diff program and options to use. The default
|>is to use C<Text::Diff>, when installed, and output unified
|>context diffs.
|>
|>=head2 --compat-version=I<version>
|>
|>Tell F<ppport.h> to check for compatibility with the given
|>Perl version. The default is to check for compatibility with Perl
|>version 5.003. You can use this option to reduce the output
|>of F<ppport.h> if you intend to be backward compatible only
|>up to a certain Perl version.
|>
|>=head2 --cplusplus
|>
|>Usually, F<ppport.h> will detect C++ style comments and
|>replace them with C style comments for portability reasons.
|>Using this option instructs F<ppport.h> to leave C++
|>comments untouched.
|>
|>=head2 --quiet
|>
|>Be quiet. Don't print anything except fatal errors.
|>
|>=head2 --nodiag
|>
|>Don't output any diagnostic messages. Only portability
|>alerts will be printed.
|>
|>=head2 --nohints
|>
|>Don't output any hints. Hints often contain useful portability
|>notes.
|>
|>=head2 --nochanges
|>
|>Don't suggest any changes. Only give diagnostic output and hints
|>unless these are also deactivated.
|>
|>=head2 --nofilter
|>
|>Don't filter the list of input files. By default, files not looking
|>like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.
|>
|>=head2 --list-provided
|>
|>Lists the API elements for which compatibility is provided by
|>F<ppport.h>. Also lists if it must be explicitly requested,
|>if it has dependencies, and if there are hints for it.
|>
|>=head2 --list-unsupported
|>
|>Lists the API elements that are known not to be supported by
|>F<ppport.h> and below which version of Perl they probably
|>won't be available or work.
|>
|>=head2 --api-info=I<name>
|>
|>Show portability information for API elements matching I<name>.
|>If I<name> is surrounded by slashes, it is interpreted as a regular
|>expression.
|>
|>=head1 DESCRIPTION
|>
|>In order for a Perl extension (XS) module to be as portable as possible
|>across differing versions of Perl itself, certain steps need to be taken.
|>
|>=over 4
|>
|>=item *
|>
|>Including this header is the first major one. This alone will give you
|>access to a large part of the Perl API that hasn't been available in
|>earlier Perl releases. Use
|>
|>    perl ppport.h --list-provided
|>
|>to see which API elements are provided by ppport.h.
|>
|>=item *
|>
|>You should avoid using deprecated parts of the API. For example, using
|>global Perl variables without the C<PL_> prefix is deprecated. Also,
|>some API functions used to have a C<perl_> prefix. Using this form is
|>also deprecated. You can safely use the supported API, as F<ppport.h>
|>will provide wrappers for older Perl versions.
|>
|>=item *
|>
|>If you use one of a few functions that were not present in earlier
|>versions of Perl, and that can't be provided using a macro, you have
|>to explicitly request support for these functions by adding one or
|>more C<#define>s in your source code before the inclusion of F<ppport.h>.
|>
|>These functions will be marked C<explicit> in the list shown by
|>C<--list-provided>.
|>
|>Depending on whether you module has a single or multiple files that
|>use such functions, you want either C<static> or global variants.
|>
|>For a C<static> function, use:
|>
|>    #define NEED_function
|>
|>For a global function, use:
|>
|>    #define NEED_function_GLOBAL
|>
|>Note that you mustn't have more than one global request for one
|>function in your project.
|>
|>    Function                  Static Request               Global Request
|>    -----------------------------------------------------------------------------------------
|>    eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL
|>    grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL
|>    grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL
|>    grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
|>    grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
|>    grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
|>    newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
|>    newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL
|>    sv_2pv_nolen()            NEED_sv_2pv_nolen            NEED_sv_2pv_nolen_GLOBAL
|>    sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL
|>    sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
|>    sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
|>    sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
|>    sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
|>    vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL
|>
|>To avoid namespace conflicts, you can change the namespace of the
|>explicitly exported functions using the C<DPPP_NAMESPACE> macro.
|>Just C<#define> the macro before including C<ppport.h>:
|>
|>    #define DPPP_NAMESPACE MyOwnNamespace_
|>    #include "ppport.h"
|>
|>The default namespace is C<DPPP_>.
|>
|>=back
|>
|>The good thing is that most of the above can be checked by running
|>F<ppport.h> on your source code. See the next section for
|>details.
|>
|>=head1 EXAMPLES
|>
|>To verify whether F<ppport.h> is needed for your module, whether you
|>should make any changes to your code, and whether any special defines
|>should be used, F<ppport.h> can be run as a Perl script to check your
|>source code. Simply say:
|>
|>    perl ppport.h
|>
|>The result will usually be a list of patches suggesting changes
|>that should at least be acceptable, if not necessarily the most
|>efficient solution, or a fix for all possible problems.
|>
|>If you know that your XS module uses features only available in
|>newer Perl releases, if you're aware that it uses C++ comments,
|>and if you want all suggestions as a single patch file, you could
|>use something like this:
|>
|>    perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
|>
|>If you only want your code to be scanned without any suggestions
|>for changes, use:
|>
|>    perl ppport.h --nochanges
|>
|>You can specify a different C<diff> program or options, using
|>the C<--diff> option:
|>
|>    perl ppport.h --diff='diff -C 10'
|>
|>This would output context diffs with 10 lines of context.
|>
|>To display portability information for the C<newSVpvn> function,
|>use:
|>
|>    perl ppport.h --api-info=newSVpvn
|>
|>Since the argument to C<--api-info> can be a regular expression,
|>you can use
|>
|>    perl ppport.h --api-info=/_nomg$/
|>
|>to display portability information for all C<_nomg> functions or
|>
|>    perl ppport.h --api-info=/./
|>
|>to display information for all known API elements.
|>
|>=head1 BUGS
|>
|>If this version of F<ppport.h> is causing failure during
|>the compilation of this module, please check if newer versions
|>of either this module or C<Devel::PPPort> are available on CPAN
|>before sending a bug report.
|>
|>If F<ppport.h> was generated using the latest version of
|>C<Devel::PPPort> and is causing failure of this module, please
|>file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
|>
|>Please include the following information:
|>
|>=over 4
|>
|>=item 1.
|>
|>The complete output from running "perl -V"
|>
|>=item 2.
|>
|>This file.
|>
|>=item 3.
|>
|>The name and version of the module you were trying to build.
|>
|>=item 4.
|>
|>A full log of the build that failed.
|>
|>=item 5.
|>
|>Any other information that you think could be relevant.
|>
|>=back
|>
|>For the latest version of this code, please get the C<Devel::PPPort>
|>module from CPAN.
|>
|>=head1 COPYRIGHT
|>
|>Version 3.x, Copyright (c) 2004-2005, Marcus Holland-Moritz.
|>
|>Version 2.x, Copyright (C) 2001, Paul Marquess.
|>
|>Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
|>
|>This program is free software; you can redistribute it and/or
|>modify it under the same terms as Perl itself.
|>
|>=head1 SEE ALSO
|>
|>See L<Devel::PPPort>.

=cut

use strict;

my %opt = (
  quiet     => 0,
  diag      => 1,
  hints     => 1,
  changes   => 1,
  cplusplus => 0,
  filter    => 1,
);

my($ppport) = $0 =~ /([\w.]+)$/;
my $LF = '(?:\r\n|[\r\n])';   # line feed
my $HS = "[ \t]";             # horizontal whitespace

eval {
  require Getopt::Long;
  Getopt::Long::GetOptions(\%opt, qw(
    help quiet diag! filter! hints! changes! cplusplus
    patch=s copy=s diff=s compat-version=s
    list-provided list-unsupported api-info=s
  )) or usage();
};

if ($@ and grep /^-/, @ARGV) {
  usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
  die "Getopt::Long not found. Please don't use any options.\n";
}

usage() if $opt{help};

if (exists $opt{'compat-version'}) {
  my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
  if ($@) {
    die "Invalid version number format: '$opt{'compat-version'}'\n";
  }
  die "Only Perl 5 is supported\n" if $r != 5;
  die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
  $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
}
else {
  $opt{'compat-version'} = 5;
}

# Never use C comments in this file!!!!!
my $ccs  = '/'.'*';
my $cce  = '*'.'/';
my $rccs = quotemeta $ccs;
my $rcce = quotemeta $cce;

my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
                ? ( $1 => {
                      ($2                  ? ( base     => $2 ) : ()),
                      ($3                  ? ( todo     => $3 ) : ()),
                      (index($4, 'v') >= 0 ? ( varargs  => 1  ) : ()),
                      (index($4, 'p') >= 0 ? ( provided => 1  ) : ()),
                      (index($4, 'n') >= 0 ? ( nothxarg => 1  ) : ()),
                    } )
                : die "invalid spec: $_" } qw(
AvFILLp|5.004050||p
AvFILL|||
CLASS|||n
CX_CURPAD_SAVE|||
CX_CURPAD_SV|||
CopFILEAV|5.006000||p
CopFILEGV_set|5.006000||p
CopFILEGV|5.006000||p
CopFILESV|5.006000||p
CopFILE_set|5.006000||p
CopFILE|5.006000||p
CopSTASHPV_set|5.006000||p
CopSTASHPV|5.006000||p
CopSTASH_eq|5.006000||p
CopSTASH_set|5.006000||p
CopSTASH|5.006000||p
CopyD|5.009002||p
Copy|||
CvPADLIST|||
CvSTASH|||
CvWEAKOUTSIDE|||
DEFSV|5.004050||p
END_EXTERN_C|5.005000||p
ENTER|||
ERRSV|5.004050||p
EXTEND|||
EXTERN_C|5.005000||p
FREETMPS|||
GIMME_V||5.004000|n
GIMME|||n
GROK_NUMERIC_RADIX|5.007002||p
G_ARRAY|||
G_DISCARD|||
G_EVAL|||
G_NOARGS|||
G_SCALAR|||
G_VOID||5.004000|
GetVars|||
GvSV|||
Gv_AMupdate|||
HEf_SVKEY||5.004000|
HeHASH||5.004000|
HeKEY||5.004000|
HeKLEN||5.004000|
HePV||5.004000|
HeSVKEY_force||5.004000|
HeSVKEY_set||5.004000|
HeSVKEY||5.004000|
HeVAL||5.004000|
HvNAME|||
INT2PTR|5.006000||p
IN_LOCALE_COMPILETIME|5.007002||p
IN_LOCALE_RUNTIME|5.007002||p
IN_LOCALE|5.007002||p
IN_PERL_COMPILETIME|5.008001||p
IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p
IS_NUMBER_INFINITY|5.007002||p
IS_NUMBER_IN_UV|5.007002||p
IS_NUMBER_NAN|5.007003||p
IS_NUMBER_NEG|5.007002||p
IS_NUMBER_NOT_INT|5.007002||p
IVSIZE|5.006000||p
IVTYPE|5.006000||p
IVdf|5.006000||p
LEAVE|||
LVRET|||
MARK|||
MY_CXT_CLONE|5.009002||p
MY_CXT_INIT|5.007003||p
MY_CXT|5.007003||p
MoveD|5.009002||p
Move|||
NEWSV|||
NOOP|5.005000||p
NUM2PTR|5.006000||p
NVTYPE|5.006000||p
NVef|5.006001||p
NVff|5.006001||p
NVgf|5.006001||p
Newc|||
Newz|||
New|||
Nullav|||
Nullch|||
Nullcv|||
Nullhv|||
Nullsv|||
ORIGMARK|||
PAD_BASE_SV|||
PAD_CLONE_VARS|||
PAD_COMPNAME_FLAGS|||
PAD_COMPNAME_GEN_set|||
PAD_COMPNAME_GEN|||
PAD_COMPNAME_OURSTASH|||
PAD_COMPNAME_PV|||
PAD_COMPNAME_TYPE|||
PAD_RESTORE_LOCAL|||
PAD_SAVE_LOCAL|||
PAD_SAVE_SETNULLPAD|||
PAD_SETSV|||
PAD_SET_CUR_NOSAVE|||
PAD_SET_CUR|||
PAD_SVl|||
PAD_SV|||
PERL_BCDVERSION|5.009003||p
PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
PERL_INT_MAX|5.004000||p
PERL_INT_MIN|5.004000||p
PERL_LONG_MAX|5.004000||p
PERL_LONG_MIN|5.004000||p
PERL_MAGIC_arylen|5.007002||p
PERL_MAGIC_backref|5.007002||p
PERL_MAGIC_bm|5.007002||p
PERL_MAGIC_collxfrm|5.007002||p
PERL_MAGIC_dbfile|5.007002||p
PERL_MAGIC_dbline|5.007002||p
PERL_MAGIC_defelem|5.007002||p
PERL_MAGIC_envelem|5.007002||p
PERL_MAGIC_env|5.007002||p
PERL_MAGIC_ext|5.007002||p
PERL_MAGIC_fm|5.007002||p
PERL_MAGIC_glob|5.007002||p
PERL_MAGIC_isaelem|5.007002||p
PERL_MAGIC_isa|5.007002||p
PERL_MAGIC_mutex|5.007002||p
PERL_MAGIC_nkeys|5.007002||p
PERL_MAGIC_overload_elem|5.007002||p
PERL_MAGIC_overload_table|5.007002||p
PERL_MAGIC_overload|5.007002||p
PERL_MAGIC_pos|5.007002||p
PERL_MAGIC_qr|5.007002||p
PERL_MAGIC_regdata|5.007002||p
PERL_MAGIC_regdatum|5.007002||p
PERL_MAGIC_regex_global|5.007002||p
PERL_MAGIC_shared_scalar|5.007003||p
PERL_MAGIC_shared|5.007003||p
PERL_MAGIC_sigelem|5.007002||p
PERL_MAGIC_sig|5.007002||p
PERL_MAGIC_substr|5.007002||p
PERL_MAGIC_sv|5.007002||p
PERL_MAGIC_taint|5.007002||p
PERL_MAGIC_tiedelem|5.007002||p
PERL_MAGIC_tiedscalar|5.007002||p
PERL_MAGIC_tied|5.007002||p
PERL_MAGIC_utf8|5.008001||p
PERL_MAGIC_uvar_elem|5.007003||p
PERL_MAGIC_uvar|5.007002||p
PERL_MAGIC_vec|5.007002||p
PERL_MAGIC_vstring|5.008001||p
PERL_QUAD_MAX|5.004000||p
PERL_QUAD_MIN|5.004000||p
PERL_REVISION|5.006000||p
PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p
PERL_SCAN_DISALLOW_PREFIX|5.007003||p
PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p
PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
PERL_SHORT_MAX|5.004000||p
PERL_SHORT_MIN|5.004000||p
PERL_SUBVERSION|5.006000||p
PERL_UCHAR_MAX|5.004000||p
PERL_UCHAR_MIN|5.004000||p
PERL_UINT_MAX|5.004000||p
PERL_UINT_MIN|5.004000||p
PERL_ULONG_MAX|5.004000||p
PERL_ULONG_MIN|5.004000||p
PERL_UNUSED_DECL|5.007002||p
PERL_UQUAD_MAX|5.004000||p
PERL_UQUAD_MIN|5.004000||p
PERL_USHORT_MAX|5.004000||p
PERL_USHORT_MIN|5.004000||p
PERL_VERSION|5.006000||p
PL_DBsingle|||pn
PL_DBsub|||pn
PL_DBtrace|||n
PL_Sv|5.005000||p
PL_compiling|5.004050||p
PL_copline|5.005000||p
PL_curcop|5.004050||p
PL_curstash|5.004050||p
PL_debstash|5.004050||p
PL_defgv|5.004050||p
PL_diehook|5.004050||p
PL_dirty|5.004050||p
PL_dowarn|||pn
PL_errgv|5.004050||p
PL_hexdigit|5.005000||p
PL_hints|5.005000||p
PL_last_in_gv|||n
PL_modglobal||5.005000|n
PL_na|5.004050||pn
PL_no_modify|5.006000||p
PL_ofs_sv|||n
PL_perl_destruct_level|5.004050||p
PL_perldb|5.004050||p
PL_ppaddr|5.006000||p
PL_rsfp_filters|5.004050||p
PL_rsfp|5.004050||p
PL_rs|||n
PL_stack_base|5.004050||p
PL_stack_sp|5.004050||p
PL_stdingv|5.004050||p
PL_sv_arenaroot|5.004050||p
PL_sv_no|5.004050||pn
PL_sv_undef|5.004050||pn
PL_sv_yes|5.004050||pn
PL_tainted|5.004050||p
PL_tainting|5.004050||p
POPi|||n
POPl|||n
POPn|||n
POPpbytex||5.007001|n
POPpx||5.005030|n
POPp|||n
POPs|||n
PTR2IV|5.006000||p
PTR2NV|5.006000||p
PTR2UV|5.006000||p
PTR2ul|5.007001||p
PTRV|5.006000||p
PUSHMARK|||
PUSHi|||
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PerlIO_clearerr||5.007003|
PerlIO_close||5.007003|
PerlIO_eof||5.007003|
PerlIO_error||5.007003|
PerlIO_fileno||5.007003|
PerlIO_fill||5.007003|
PerlIO_flush||5.007003|
PerlIO_get_base||5.007003|
PerlIO_get_bufsiz||5.007003|
PerlIO_get_cnt||5.007003|
PerlIO_get_ptr||5.007003|
PerlIO_read||5.007003|
PerlIO_seek||5.007003|
PerlIO_set_cnt||5.007003|
PerlIO_set_ptrcnt||5.007003|
PerlIO_setlinebuf||5.007003|
PerlIO_stderr||5.007003|
PerlIO_stdin||5.007003|
PerlIO_stdout||5.007003|
PerlIO_tell||5.007003|
PerlIO_unread||5.007003|
PerlIO_write||5.007003|
Poison|5.008000||p
RETVAL|||n
Renewc|||
Renew|||
SAVECLEARSV|||
SAVECOMPPAD|||
SAVEPADSV|||
SAVETMPS|||
SAVE_DEFSV|5.004050||p
SPAGAIN|||
SP|||
START_EXTERN_C|5.005000||p
START_MY_CXT|5.007003||p
STMT_END|||p
STMT_START|||p
ST|||
SVt_IV|||
SVt_NV|||
SVt_PVAV|||
SVt_PVCV|||
SVt_PVHV|||
SVt_PVMG|||
SVt_PV|||
Safefree|||
Slab_Alloc|||
Slab_Free|||
StructCopy|||
SvCUR_set|||
SvCUR|||
SvEND|||
SvGETMAGIC|5.004050||p
SvGROW|||
SvIOK_UV||5.006000|
SvIOK_notUV||5.006000|
SvIOK_off|||
SvIOK_only_UV||5.006000|
SvIOK_only|||
SvIOK_on|||
SvIOKp|||
SvIOK|||
SvIVX|||
SvIV_nomg|5.009001||p
SvIV_set|||
SvIVx|||
SvIV|||
SvIsCOW_shared_hash||5.008003|
SvIsCOW||5.008003|
SvLEN_set|||
SvLEN|||
SvLOCK||5.007003|
SvMAGIC_set||5.009003|
SvNIOK_off|||
SvNIOKp|||
SvNIOK|||
SvNOK_off|||
SvNOK_only|||
SvNOK_on|||
SvNOKp|||
SvNOK|||
SvNVX|||
SvNV_set|||
SvNVx|||
SvNV|||
SvOK|||
SvOOK|||
SvPOK_off|||
SvPOK_only_UTF8||5.006000|
SvPOK_only|||
SvPOK_on|||
SvPOKp|||
SvPOK|||
SvPVX|||
SvPV_force_nomg|5.007002||p
SvPV_force|||
SvPV_nolen|5.006000||p
SvPV_nomg|5.007002||p
SvPV_set|||
SvPVbyte_force||5.009002|
SvPVbyte_nolen||5.006000|
SvPVbytex_force||5.006000|
SvPVbytex||5.006000|
SvPVbyte|5.006000||p
SvPVutf8_force||5.006000|
SvPVutf8_nolen||5.006000|
SvPVutf8x_force||5.006000|
SvPVutf8x||5.006000|
SvPVutf8||5.006000|
SvPVx|||
SvPV|||
SvREFCNT_dec|||
SvREFCNT_inc|||
SvREFCNT|||
SvROK_off|||
SvROK_on|||
SvROK|||
SvRV_set||5.009003|
SvRV|||
SvSETMAGIC|||
SvSHARE||5.007003|
SvSTASH_set||5.009003|
SvSTASH|||
SvSetMagicSV_nosteal||5.004000|
SvSetMagicSV||5.004000|
SvSetSV_nosteal||5.004000|
SvSetSV|||
SvTAINTED_off||5.004000|
SvTAINTED_on||5.004000|
SvTAINTED||5.004000|
SvTAINT|||
SvTRUE|||
SvTYPE|||
SvUNLOCK||5.007003|
SvUOK||5.007001|
SvUPGRADE|||
SvUTF8_off||5.006000|
SvUTF8_on||5.006000|
SvUTF8||5.006000|
SvUVXx|5.004000||p
SvUVX|5.004000||p
SvUV_nomg|5.009001||p
SvUV_set||5.009003|
SvUVx|5.004000||p
SvUV|5.004000||p
SvVOK||5.008001|
THIS|||n
UNDERBAR|5.009002||p
UVSIZE|5.006000||p
UVTYPE|5.006000||p
UVXf|5.007001||p
UVof|5.006000||p
UVuf|5.006000||p
UVxf|5.006000||p
XCPT_CATCH|5.009002||p
XCPT_RETHROW|5.009002||p
XCPT_TRY_END|5.009002||p
XCPT_TRY_START|5.009002||p
XPUSHi|||
XPUSHmortal|5.009002||p
XPUSHn|||
XPUSHp|||
XPUSHs|||
XPUSHu|5.004000||p
XSRETURN_EMPTY|||
XSRETURN_IV|||
XSRETURN_NO|||
XSRETURN_NV|||
XSRETURN_PV|||
XSRETURN_UNDEF|||
XSRETURN_UV|5.008001||p
XSRETURN_YES|||
XSRETURN|||
XST_mIV|||
XST_mNO|||
XST_mNV|||
XST_mPV|||
XST_mUNDEF|||
XST_mUV|5.008001||p
XST_mYES|||
XS_VERSION_BOOTCHECK|||
XS_VERSION|||
XS|||
ZeroD|5.009002||p
Zero|||
_aMY_CXT|5.007003||p
_pMY_CXT|5.007003||p
aMY_CXT_|5.007003||p
aMY_CXT|5.007003||p
aTHX_|5.006000||p
aTHX|5.006000||p
add_data|||
allocmy|||
amagic_call|||
any_dup|||
ao|||
append_elem|||
append_list|||
apply_attrs_my|||
apply_attrs_string||5.006001|
apply_attrs|||
apply|||
asIV|||
asUV|||
atfork_lock||5.007003|n
atfork_unlock||5.007003|n
av_arylen_p||5.009003|
av_clear|||
av_delete||5.006000|
av_exists||5.006000|
av_extend|||
av_fake|||
av_fetch|||
av_fill|||
av_len|||
av_make|||
av_pop|||
av_push|||
av_reify|||
av_shift|||
av_store|||
av_undef|||
av_unshift|||
ax|||n
bad_type|||
bind_match|||
block_end|||
block_gimme||5.004000|
block_start|||
boolSV|5.004000||p
boot_core_PerlIO|||
boot_core_UNIVERSAL|||
boot_core_xsutils|||
bytes_from_utf8||5.007001|
bytes_to_utf8||5.006001|
cache_re|||
call_argv|5.006000||p
call_atexit||5.006000|
call_body|||
call_list_body|||
call_list||5.004000|
call_method|5.006000||p
call_pv|5.006000||p
call_sv|5.006000||p
calloc||5.007002|n
cando|||
cast_i32||5.006000|
cast_iv||5.006000|
cast_ulong||5.006000|
cast_uv||5.006000|
check_uni|||
checkcomma|||
checkposixcc|||
ck_anoncode|||
ck_bitop|||
ck_concat|||
ck_defined|||
ck_delete|||
ck_die|||
ck_eof|||
ck_eval|||
ck_exec|||
ck_exists|||
ck_exit|||
ck_ftst|||
ck_fun|||
ck_glob|||
ck_grep|||
ck_index|||
ck_join|||
ck_lengthconst|||
ck_lfun|||
ck_listiob|||
ck_match|||
ck_method|||
ck_null|||
ck_open|||
ck_repeat|||
ck_require|||
ck_retarget|||
ck_return|||
ck_rfun|||
ck_rvconst|||
ck_sassign|||
ck_select|||
ck_shift|||
ck_sort|||
ck_spair|||
ck_split|||
ck_subr|||
ck_substr|||
ck_svconst|||
ck_trunc|||
ck_unpack|||
cl_and|||
cl_anything|||
cl_init_zero|||
cl_init|||
cl_is_anything|||
cl_or|||
closest_cop|||
convert|||
cop_free|||
cr_textfilter|||
croak_nocontext|||vn
croak|||v
csighandler||5.007001|n
custom_op_desc||5.007003|
custom_op_name||5.007003|
cv_ckproto|||
cv_clone|||
cv_const_sv||5.004000|
cv_dump|||
cv_undef|||
cx_dump||5.005000|
cx_dup|||
cxinc|||
dAXMARK||5.009003|
dAX|5.007002||p
dITEMS|5.007002||p
dMARK|||
dMY_CXT_SV|5.007003||p
dMY_CXT|5.007003||p
dNOOP|5.006000||p
dORIGMARK|||
dSP|||
dTHR|5.004050||p
dTHXa|5.006000||p
dTHXoa|5.006000||p
dTHX|5.006000||p
dUNDERBAR|5.009002||p
dXCPT|5.009002||p
dXSARGS|||
dXSI32|||
dXSTARG|5.006000||p
deb_curcv|||
deb_nocontext|||vn
deb_stack_all|||
deb_stack_n|||
debop||5.005000|
debprofdump||5.005000|
debprof|||
debstackptrs||5.007003|
debstack||5.007003|
deb||5.007003|v
del_he|||
del_sv|||
delimcpy||5.004000|
depcom|||
deprecate_old|||
deprecate|||
despatch_signals||5.007001|
die_nocontext|||vn
die_where|||
die|||v
dirp_dup|||
div128|||
djSP|||
do_aexec5|||
do_aexec|||
do_aspawn|||
do_binmode||5.004050|
do_chomp|||
do_chop|||
do_close|||
do_dump_pad|||
do_eof|||
do_exec3|||
do_execfree|||
do_exec|||
do_gv_dump||5.006000|
do_gvgv_dump||5.006000|
do_hv_dump||5.006000|
do_ipcctl|||
do_ipcget|||
do_join|||
do_kv|||
do_magic_dump||5.006000|
do_msgrcv|||
do_msgsnd|||
do_oddball|||
do_op_dump||5.006000|
do_open9||5.006000|
do_openn||5.007001|
do_open||5.004000|
do_pipe|||
do_pmop_dump||5.006000|
do_print|||
do_readline|||
do_seek|||
do_semop|||
do_shmio|||
do_spawn_nowait|||
do_spawn|||
do_sprintf|||
do_sv_dump||5.006000|
do_sysseek|||
do_tell|||
do_trans_complex_utf8|||
do_trans_complex|||
do_trans_count_utf8|||
do_trans_count|||
do_trans_simple_utf8|||
do_trans_simple|||
do_trans|||
do_vecget|||
do_vecset|||
do_vop|||
docatch_body|||
docatch|||
doeval|||
dofile|||
dofindlabel|||
doform|||
doing_taint||5.008001|n
dooneliner|||
doopen_pm|||
doparseform|||
dopoptoeval|||
dopoptolabel|||
dopoptoloop|||
dopoptosub_at|||
dopoptosub|||
dounwind|||
dowantarray|||
dump_all||5.006000|
dump_eval||5.006000|
dump_fds|||
dump_form||5.006000|
dump_indent||5.006000|v
dump_mstats|||
dump_packsubs||5.006000|
dump_sub||5.006000|
dump_vindent||5.006000|
dumpuntil|||
dup_attrlist|||
emulate_eaccess|||
eval_pv|5.006000||p
eval_sv|5.006000||p
expect_number|||
fbm_compile||5.005000|
fbm_instr||5.005000|
fd_on_nosuid_fs|||
filter_add|||
filter_del|||
filter_gets|||
filter_read|||
find_beginning|||
find_byclass|||
find_in_my_stash|||
find_runcv|||
find_rundefsvoffset||5.009002|
find_script|||
find_uninit_var|||
fold_constants|||
forbid_setid|||
force_ident|||
force_list|||
force_next|||
force_version|||
force_word|||
form_nocontext|||vn
form||5.004000|v
fp_dup|||
fprintf_nocontext|||vn
free_global_struct|||
free_tied_hv_pool|||
free_tmps|||
gen_constant_list|||
get_av|5.006000||p
get_context||5.006000|n
get_cv|5.006000||p
get_db_sub|||
get_debug_opts|||
get_hash_seed|||
get_hv|5.006000||p
get_mstats|||
get_no_modify|||
get_num|||
get_op_descs||5.005000|
get_op_names||5.005000|
get_opargs|||
get_ppaddr||5.006000|
get_sv|5.006000||p
get_vtbl||5.005030|
getcwd_sv||5.007002|
getenv_len|||
gp_dup|||
gp_free|||
gp_ref|||
grok_bin|5.007003||p
grok_hex|5.007003||p
grok_number|5.007002||p
grok_numeric_radix|5.007002||p
grok_oct|5.007003||p
group_end|||
gv_AVadd|||
gv_HVadd|||
gv_IOadd|||
gv_autoload4||5.004000|
gv_check|||
gv_dump||5.006000|
gv_efullname3||5.004000|
gv_efullname4||5.006001|
gv_efullname|||
gv_ename|||
gv_fetchfile|||
gv_fetchmeth_autoload||5.007003|
gv_fetchmethod_autoload||5.004000|
gv_fetchmethod|||
gv_fetchmeth|||
gv_fetchpvn_flags||5.009002|
gv_fetchpv|||
gv_fetchsv||5.009002|
gv_fullname3||5.004000|
gv_fullname4||5.006001|
gv_fullname|||
gv_handler||5.007001|
gv_init_sv|||
gv_init|||
gv_share|||
gv_stashpvn|5.006000||p
gv_stashpv|||
gv_stashsv|||
he_dup|||
hek_dup|||
hfreeentries|||
hsplit|||
hv_assert||5.009001|
hv_auxinit|||
hv_clear_placeholders||5.009001|
hv_clear|||
hv_delayfree_ent||5.004000|
hv_delete_common|||
hv_delete_ent||5.004000|
hv_delete|||
hv_eiter_p||5.009003|
hv_eiter_set||5.009003|
hv_exists_ent||5.004000|
hv_exists|||
hv_fetch_common|||
hv_fetch_ent||5.004000|
hv_fetch|||
hv_free_ent||5.004000|
hv_iterinit|||
hv_iterkeysv||5.004000|
hv_iterkey|||
hv_iternext_flags||5.008000|
hv_iternextsv|||
hv_iternext|||
hv_iterval|||
hv_ksplit||5.004000|
hv_magic_check|||
hv_magic|||
hv_name_set||5.009003|
hv_notallowed|||
hv_placeholders_get||5.009003|
hv_placeholders_p||5.009003|
hv_placeholders_set||5.009003|
hv_riter_p||5.009003|
hv_riter_set||5.009003|
hv_scalar||5.009001|
hv_store_ent||5.004000|
hv_store_flags||5.008000|
hv_store|||
hv_undef|||
ibcmp_locale||5.004000|
ibcmp_utf8||5.007003|
ibcmp|||
incl_perldb|||
incline|||
incpush|||
ingroup|||
init_argv_symbols|||
init_debugger|||
init_global_struct|||
init_i18nl10n||5.006000|
init_i18nl14n||5.006000|
init_ids|||
init_interp|||
init_lexer|||
init_main_stash|||
init_perllib|||
init_postdump_symbols|||
init_predump_symbols|||
init_stacks||5.005000|
init_tm||5.007002|
instr|||
intro_my|||
intuit_method|||
intuit_more|||
invert|||
io_close|||
isALNUM|||
isALPHA|||
isDIGIT|||
isLOWER|||
isSPACE|||
isUPPER|||
is_an_int|||
is_gv_magical_sv|||
is_gv_magical|||
is_handle_constructor|||
is_list_assignment|||
is_lvalue_sub||5.007001|
is_uni_alnum_lc||5.006000|
is_uni_alnumc_lc||5.006000|
is_uni_alnumc||5.006000|
is_uni_alnum||5.006000|
is_uni_alpha_lc||5.006000|
is_uni_alpha||5.006000|
is_uni_ascii_lc||5.006000|
is_uni_ascii||5.006000|
is_uni_cntrl_lc||5.006000|
is_uni_cntrl||5.006000|
is_uni_digit_lc||5.006000|
is_uni_digit||5.006000|
is_uni_graph_lc||5.006000|
is_uni_graph||5.006000|
is_uni_idfirst_lc||5.006000|
is_uni_idfirst||5.006000|
is_uni_lower_lc||5.006000|
is_uni_lower||5.006000|
is_uni_print_lc||5.006000|
is_uni_print||5.006000|
is_uni_punct_lc||5.006000|
is_uni_punct||5.006000|
is_uni_space_lc||5.006000|
is_uni_space||5.006000|
is_uni_upper_lc||5.006000|
is_uni_upper||5.006000|
is_uni_xdigit_lc||5.006000|
is_uni_xdigit||5.006000|
is_utf8_alnumc||5.006000|
is_utf8_alnum||5.006000|
is_utf8_alpha||5.006000|
is_utf8_ascii||5.006000|
is_utf8_char_slow|||
is_utf8_char||5.006000|
is_utf8_cntrl||5.006000|
is_utf8_digit||5.006000|
is_utf8_graph||5.006000|
is_utf8_idcont||5.008000|
is_utf8_idfirst||5.006000|
is_utf8_lower||5.006000|
is_utf8_mark||5.006000|
is_utf8_print||5.006000|
is_utf8_punct||5.006000|
is_utf8_space||5.006000|
is_utf8_string_loclen||5.009003|
is_utf8_string_loc||5.008001|
is_utf8_string||5.006001|
is_utf8_upper||5.006000|
is_utf8_xdigit||5.006000|
isa_lookup|||
items|||n
ix|||n
jmaybe|||
keyword|||
leave_scope|||
lex_end|||
lex_start|||
linklist|||
listkids|||
list|||
load_module_nocontext|||vn
load_module||5.006000|v
localize|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHu|5.009002||p
mXPUSHi|5.009002||p
mXPUSHn|5.009002||p
mXPUSHp|5.009002||p
mXPUSHu|5.009002||p
magic_clear_all_env|||
magic_clearenv|||
magic_clearpack|||
magic_clearsig|||
magic_dump||5.006000|
magic_existspack|||
magic_freearylen_p|||
magic_freeovrld|||
magic_freeregexp|||
magic_getarylen|||
magic_getdefelem|||
magic_getglob|||
magic_getnkeys|||
magic_getpack|||
magic_getpos|||
magic_getsig|||
magic_getsubstr|||
magic_gettaint|||
magic_getuvar|||
magic_getvec|||
magic_get|||
magic_killbackrefs|||
magic_len|||
magic_methcall|||
magic_methpack|||
magic_nextpack|||
magic_regdata_cnt|||
magic_regdatum_get|||
magic_regdatum_set|||
magic_scalarpack|||
magic_set_all_env|||
magic_setamagic|||
magic_setarylen|||
magic_setbm|||
magic_setcollxfrm|||
magic_setdbline|||
magic_setdefelem|||
magic_setenv|||
magic_setfm|||
magic_setglob|||
magic_setisa|||
magic_setmglob|||
magic_setnkeys|||
magic_setpack|||
magic_setpos|||
magic_setregexp|||
magic_setsig|||
magic_setsubstr|||
magic_settaint|||
magic_setutf8|||
magic_setuvar|||
magic_setvec|||
magic_set|||
magic_sizepack|||
magic_wipepack|||
magicname|||
make_trie|||
malloced_size|||n
malloc||5.007002|n
markstack_grow|||
measure_struct|||
memEQ|5.004000||p
memNE|5.004000||p
mem_collxfrm|||
mess_alloc|||
mess_nocontext|||vn
mess||5.006000|v
method_common|||
mfree||5.007002|n
mg_clear|||
mg_copy|||
mg_dup|||
mg_find|||
mg_free|||
mg_get|||
mg_length||5.005000|
mg_localize|||
mg_magical|||
mg_set|||
mg_size||5.005000|
mini_mktime||5.007002|
missingterm|||
mode_from_discipline|||
modkids|||
mod|||
moreswitches|||
mul128|||
mulexp10|||n
my_atof2||5.007002|
my_atof||5.006000|
my_attrs|||
my_bcopy|||n
my_betoh16|||n
my_betoh32|||n
my_betoh64|||n
my_betohi|||n
my_betohl|||n
my_betohs|||n
my_bzero|||n
my_chsize|||
my_exit_jump|||
my_exit|||
my_failure_exit||5.004000|
my_fflush_all||5.006000|
my_fork||5.007003|n
my_htobe16|||n
my_htobe32|||n
my_htobe64|||n
my_htobei|||n
my_htobel|||n
my_htobes|||n
my_htole16|||n
my_htole32|||n
my_htole64|||n
my_htolei|||n
my_htolel|||n
my_htoles|||n
my_htonl|||
my_kid|||
my_letoh16|||n
my_letoh32|||n
my_letoh64|||n
my_letohi|||n
my_letohl|||n
my_letohs|||n
my_lstat|||
my_memcmp||5.004000|n
my_memset|||n
my_ntohl|||
my_pclose||5.004000|
my_popen_list||5.007001|
my_popen||5.004000|
my_setenv|||
my_socketpair||5.007003|n
my_stat|||
my_strftime||5.007002|
my_swabn|||n
my_swap|||
my_unexec|||
my|||
newANONATTRSUB||5.006000|
newANONHASH|||
newANONLIST|||
newANONSUB|||
newASSIGNOP|||
newATTRSUB||5.006000|
newAVREF|||
newAV|||
newBINOP|||
newCONDOP|||
newCONSTSUB|5.006000||p
newCVREF|||
newDEFSVOP|||
newFORM|||
newFOROP|||
newGVOP|||
newGVREF|||
newGVgen|||
newHVREF|||
newHVhv||5.005000|
newHV|||
newIO|||
newLISTOP|||
newLOGOP|||
newLOOPEX|||
newLOOPOP|||
newMYSUB||5.006000|
newNULLLIST|||
newOP|||
newPADOP||5.006000|
newPMOP|||
newPROG|||
newPVOP|||
newRANGE|||
newRV_inc|5.004000||p
newRV_noinc|5.006000||p
newRV|||
newSLICEOP|||
newSTATEOP|||
newSUB|||
newSVOP|||
newSVREF|||
newSVhek||5.009003|
newSViv|||
newSVnv|||
newSVpvf_nocontext|||vn
newSVpvf||5.004000|v
newSVpvn_share||5.007001|
newSVpvn|5.006000||p
newSVpv|||
newSVrv|||
newSVsv|||
newSVuv|5.006000||p
newSV|||
newUNOP|||
newWHILEOP||5.009003|
newXSproto||5.006000|
newXS||5.006000|
new_collate||5.006000|
new_constant|||
new_ctype||5.006000|
new_he|||
new_logop|||
new_numeric||5.006000|
new_stackinfo||5.005000|
new_version||5.009000|
next_symbol|||
nextargv|||
nextchar|||
ninstr|||
no_bareword_allowed|||
no_fh_allowed|||
no_op|||
not_a_number|||
nothreadhook||5.008000|
nuke_stacks|||
num_overflow|||n
oopsAV|||
oopsCV|||
oopsHV|||
op_clear|||
op_const_sv|||
op_dump||5.006000|
op_free|||
op_null||5.007002|
op_refcnt_lock||5.009002|
op_refcnt_unlo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ck||5.009002|
open_script|||
pMY_CXT_|5.007003||p
pMY_CXT|5.007003||p
pTHX_|5.006000||p
pTHX|5.006000||p
pack_cat||5.007003|
pack_rec|||
package|||
packlist||5.008001|
pad_add_anon|||
pad_add_name|||
pad_alloc|||
pad_block_start|||
pad_check_dup|||
pad_compname_type|||
pad_findlex|||
pad_findmy|||
pad_fixup_inner_anons|||
pad_free|||
pad_leavemy|||
pad_new|||
pad_push|||
pad_reset|||
pad_setsv|||
pad_sv|||
pad_swipe|||
pad_tidy|||
pad_undef|||
parse_body|||
parse_unicode_opts|||
path_is_absolute|||
peep|||
pending_ident|||
perl_alloc_using|||n
perl_alloc|||n
perl_clone_using|||n
perl_clone|||n
perl_construct|||n
perl_destruct||5.007003|n
perl_free|||n
perl_parse||5.006000|n
perl_run|||n
pidgone|||
pmflag|||
pmop_dump||5.006000|
pmruntime|||
pmtrans|||
pop_scope|||
pregcomp|||
pregexec|||
pregfree|||
prepend_elem|||
printf_nocontext|||vn
ptr_table_clear|||
ptr_table_fetch|||
ptr_table_free|||
ptr_table_new|||
ptr_table_split|||
ptr_table_store|||
push_scope|||
put_byte|||
pv_display||5.006000|
pv_uni_display||5.007003|
qerror|||
re_croak2|||
re_dup|||
re_intuit_start||5.006000|
re_intuit_string||5.006000|
realloc||5.007002|n
reentrant_free|||
reentrant_init|||
reentrant_retry|||vn
reentrant_size|||
refkids|||
refto|||
ref|||
reg_node|||
reganode|||
regatom|||
regbranch|||
regclass_swash||5.007003|
regclass|||
regcp_set_to|||
regcppop|||
regcppush|||
regcurly|||
regdump||5.005000|
regexec_flags||5.005000|
reghop3|||
reghopmaybe3|||
reghopmaybe|||
reghop|||
reginclass|||
reginitcolors||5.006000|
reginsert|||
regmatch|||
regnext||5.005000|
regoptail|||
regpiece|||
regpposixcc|||
regprop|||
regrepeat_hard|||
regrepeat|||
regtail|||
regtry|||
reguni|||
regwhite|||
reg|||
repeatcpy|||
report_evil_fh|||
report_uninit|||
require_errno|||
require_pv||5.006000|
rninstr|||
rsignal_restore|||
rsignal_save|||
rsignal_state||5.004000|
rsignal||5.004000|
run_body|||
runops_debug||5.005000|
runops_standard||5.005000|
rvpv_dup|||
rxres_free|||
rxres_restore|||
rxres_save|||
safesyscalloc||5.006000|n
safesysfree||5.006000|n
safesysmalloc||5.006000|n
safesysrealloc||5.006000|n
same_dirent|||
save_I16||5.004000|
save_I32|||
save_I8||5.006000|
save_aelem||5.004050|
save_alloc||5.006000|
save_aptr|||
save_ary|||
save_bool||5.008001|
save_clearsv|||
save_delete|||
save_destructor_x||5.006000|
save_destructor||5.006000|
save_freeop|||
save_freepv|||
save_freesv|||
save_generic_pvref||5.006001|
save_generic_svref||5.005030|
save_gp||5.004000|
save_hash|||
save_hek_flags|||
save_helem||5.004050|
save_hints||5.005000|
save_hptr|||
save_int|||
save_item|||
save_iv||5.005000|
save_lines|||
save_list|||
save_long|||
save_magic|||
save_mortalizesv||5.007001|
save_nogv|||
save_op|||
save_padsv||5.007001|
save_pptr|||
save_re_context||5.006000|
save_scalar_at|||
save_scalar|||
save_set_svflags||5.009000|
save_shared_pvref||5.007003|
save_sptr|||
save_svref|||
save_threadsv||5.005000|
save_vptr||5.006000|
savepvn|||
savepv|||
savesharedpv||5.007003|
savestack_grow_cnt||5.008001|
savestack_grow|||
savesvpv||5.009002|
sawparens|||
scalar_mod_type|||
scalarboolean|||
scalarkids|||
scalarseq|||
scalarvoid|||
scalar|||
scan_bin||5.006000|
scan_commit|||
scan_const|||
scan_formline|||
scan_heredoc|||
scan_hex|||
scan_ident|||
scan_inputsymbol|||
scan_num||5.007001|
scan_oct|||
scan_pat|||
scan_str|||
scan_subst|||
scan_trans|||
scan_version||5.009001|
scan_vstring||5.008001|
scan_word|||
scope|||
screaminstr||5.005000|
seed|||
set_context||5.006000|n
set_csh|||
set_numeric_local||5.006000|
set_numeric_radix||5.006000|
set_numeric_standard||5.006000|
setdefout|||
setenv_getix|||
share_hek_flags|||
share_hek|||
si_dup|||
sighandler|||n
simplify_sort|||
skipspace|||
sortsv||5.007003|
ss_dup|||
stack_grow|||
start_glob|||
start_subparse||5.004000|
stashpv_hvname_match||5.009003|
stdize_locale|||
strEQ|||
strGE|||
strGT|||
strLE|||
strLT|||
strNE|||
str_to_version||5.006000|
strnEQ|||
strnNE|||
study_chunk|||
sub_crush_depth|||
sublex_done|||
sublex_push|||
sublex_start|||
sv_2bool|||
sv_2cv|||
sv_2io|||
sv_2iuv_non_preserve|||
sv_2iv_flags||5.009001|
sv_2iv|||
sv_2mortal|||
sv_2nv|||
sv_2pv_flags||5.007002|
sv_2pv_nolen|5.006000||p
sv_2pvbyte_nolen|||
sv_2pvbyte|5.006000||p
sv_2pvutf8_nolen||5.006000|
sv_2pvutf8||5.006000|
sv_2pv|||
sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
sv_add_arena|||
sv_add_backref|||
sv_backoff|||
sv_bless|||
sv_cat_decode||5.008001|
sv_catpv_mg|5.006000||p
sv_catpvf_mg_nocontext|||pvn
sv_catpvf_mg|5.006000|5.004000|pv
sv_catpvf_nocontext|||vn
sv_catpvf||5.004000|v
sv_catpvn_flags||5.007002|
sv_catpvn_mg|5.006000||p
sv_catpvn_nomg|5.007002||p
sv_catpvn|||
sv_catpv|||
sv_catsv_flags||5.007002|
sv_catsv_mg|5.006000||p
sv_catsv_nomg|5.007002||p
sv_catsv|||
sv_chop|||
sv_clean_all|||
sv_clean_objs|||
sv_clear|||
sv_cmp_locale||5.004000|
sv_cmp|||
sv_collxfrm|||
sv_compile_2op||5.008001|
sv_copypv||5.007003|
sv_dec|||
sv_del_backref|||
sv_derived_from||5.004000|
sv_dump|||
sv_dup|||
sv_eq|||
sv_force_normal_flags||5.007001|
sv_force_normal||5.006000|
sv_free2|||
sv_free_arenas|||
sv_free|||
sv_gets||5.004000|
sv_grow|||
sv_inc|||
sv_insert|||
sv_isa|||
sv_isobject|||
sv_iv||5.005000|
sv_len_utf8||5.006000|
sv_len|||
sv_magicext||5.007003|
sv_magic|||
sv_mortalcopy|||
sv_newmortal|||
sv_newref|||
sv_nolocking||5.007003|
sv_nosharing||5.007003|
sv_nounlocking||5.007003|
sv_nv||5.005000|
sv_peek||5.005000|
sv_pos_b2u||5.006000|
sv_pos_u2b||5.006000|
sv_pvbyten_force||5.006000|
sv_pvbyten||5.006000|
sv_pvbyte||5.006000|
sv_pvn_force_flags||5.007002|
sv_pvn_force|||p
sv_pvn_nomg|5.007003||p
sv_pvn|5.006000||p
sv_pvutf8n_force||5.006000|
sv_pvutf8n||5.006000|
sv_pvutf8||5.006000|
sv_pv||5.006000|
sv_recode_to_utf8||5.007003|
sv_reftype|||
sv_release_COW|||
sv_release_IVX|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.006000||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.006000||p
sv_setpvf_mg_nocontext|||pvn
sv_setpvf_mg|5.006000|5.004000|pv
sv_setpvf_nocontext|||vn
sv_setpvf||5.004000|v
sv_setpviv_mg||5.008001|
sv_setpviv||5.008001|
sv_setpvn_mg|5.006000||p
sv_setpvn|||
sv_setpv|||
sv_setref_iv|||
sv_setref_nv|||
sv_setref_pvn|||
sv_setref_pv|||
sv_setref_uv||5.007001|
sv_setsv_cow|||
sv_setsv_flags||5.007002|
sv_setsv_mg|5.006000||p
sv_setsv_nomg|5.007002||p
sv_setsv|||
sv_setuv_mg|5.006000||p
sv_setuv|5.006000||p
sv_tainted||5.004000|
sv_taint||5.004000|
sv_true||5.005000|
sv_unglob|||
sv_uni_display||5.007003|
sv_unmagic|||
sv_unref_flags||5.007001|
sv_unref|||
sv_untaint||5.004000|
sv_upgrade|||
sv_usepvn_mg|5.006000||p
sv_usepvn|||
sv_utf8_decode||5.006000|
sv_utf8_downgrade||5.006000|
sv_utf8_encode||5.006000|
sv_utf8_upgrade_flags||5.007002|
sv_utf8_upgrade||5.007001|
sv_uv|5.006000||p
sv_vcatpvf_mg|5.006000|5.004000|p
sv_vcatpvfn||5.004000|
sv_vcatpvf|5.006000|5.004000|p
sv_vsetpvf_mg|5.006000|5.004000|p
sv_vsetpvfn||5.004000|
sv_vsetpvf|5.006000|5.004000|p
svtype|||
swallow_bom|||
swash_fetch||5.007002|
swash_init||5.006000|
sys_intern_clear|||
sys_intern_dup|||
sys_intern_init|||
taint_env|||
taint_proper|||
tmps_grow||5.006000|
toLOWER|||
toUPPER|||
to_byte_substr|||
to_uni_fold||5.007003|
to_uni_lower_lc||5.006000|
to_uni_lower||5.007003|
to_uni_title_lc||5.006000|
to_uni_title||5.007003|
to_uni_upper_lc||5.006000|
to_uni_upper||5.007003|
to_utf8_case||5.007003|
to_utf8_fold||5.007003|
to_utf8_lower||5.007003|
to_utf8_substr|||
to_utf8_title||5.007003|
to_utf8_upper||5.007003|
tokeq|||
tokereport|||
too_few_arguments|||
too_many_arguments|||
unlnk|||
unpack_rec|||
unpack_str||5.007003|
unpackstring||5.008001|
unshare_hek_or_pvn|||
unshare_hek|||
unsharepvn||5.004000|
upg_version||5.009000|
usage|||
utf16_textfilter|||
utf16_to_utf8_reversed||5.006001|
utf16_to_utf8||5.006001|
utf16rev_textfilter|||
utf8_distance||5.006000|
utf8_hop||5.006000|
utf8_length||5.007001|
utf8_mg_pos_init|||
utf8_mg_pos|||
utf8_to_bytes||5.006001|
utf8_to_uvchr||5.007001|
utf8_to_uvuni||5.007001|
utf8n_to_uvchr||5.007001|
utf8n_to_uvuni||5.007001|
utilize|||
uvchr_to_utf8_flags||5.007003|
uvchr_to_utf8||5.007001|
uvuni_to_utf8_flags||5.007003|
uvuni_to_utf8||5.007001|
validate_suid|||
varname|||
vcmp||5.009000|
vcroak||5.006000|
vdeb||5.007003|
vdie|||
vform||5.006000|
visit|||
vivify_defelem|||
vivify_ref|||
vload_module||5.006000|
vmess||5.006000|
vnewSVpvf|5.006000|5.004000|p
vnormal||5.009002|
vnumify||5.009000|
vstringify||5.009000|
vwarner||5.006000|
vwarn||5.006000|
wait4pid|||
warn_nocontext|||vn
warner_nocontext|||vn
warner||5.006000|v
warn|||v
watch|||
whichsig|||
write_to_stderr|||
yyerror|||
yylex|||
yyparse|||
yywarn|||
);

if (exists $opt{'list-unsupported'}) {
  my $f;
  for $f (sort { lc $a cmp lc $b } keys %API) {
    next unless $API{$f}{todo};
    print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
  }
  exit 0;
}

# Scan for possible replacement candidates

my(%replace, %need, %hints, %depends);
my $replace = 0;
my $hint = '';

while (<DATA>) {
  if ($hint) {
    if (m{^\s*\*\s(.*?)\s*$}) {
      $hints{$hint} ||= '';  # suppress warning with older perls
      $hints{$hint} .= "$1\n";
    }
    else {
      $hint = '';
    }
  }
  $hint = $1 if m{^\s*$rccs\sHint:\s+(\w+)\s*$};

  $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
  $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
  $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
  $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};

  if (m{^\s*$rccs\s+(\w+)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
    push @{$depends{$1}}, map { s/\s+//g; $_ } split /,/, $2;
  }

  $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
}

if (exists $opt{'api-info'}) {
  my $f;
  my $count = 0;
  my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
  for $f (sort { lc $a cmp lc $b } keys %API) {
    next unless $f =~ /$match/;
    print "\n=== $f ===\n\n";
    my $info = 0;
    if ($API{$f}{base} || $API{$f}{todo}) {
      my $base = format_version($API{$f}{base} || $API{$f}{todo});
      print "Supported at least starting from perl-$base.\n";
      $info++;
    }
    if ($API{$f}{provided}) {
      my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";
      print "Support by $ppport provided back to perl-$todo.\n";
      print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
      print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
      print "$hints{$f}" if exists $hints{$f};
      $info++;
    }
    unless ($info) {
      print "No portability information available.\n";
    }
    $count++;
  }
  if ($count > 0) {
    print "\n";
  }
  else {
    print "Found no API matching '$opt{'api-info'}'.\n";
  }
  exit 0;
}

if (exists $opt{'list-provided'}) {
  my $f;
  for $f (sort { lc $a cmp lc $b } keys %API) {
    next unless $API{$f}{provided};
    my @flags;
    push @flags, 'explicit' if exists $need{$f};
    push @flags, 'depend'   if exists $depends{$f};
    push @flags, 'hint'     if exists $hints{$f};
    my $flags = @flags ? '  ['.join(', ', @flags).']' : '';
    print "$f$flags\n";
  }
  exit 0;
}

my @files;
my @srcext = qw( xs c h cc cpp );
my $srcext = join '|', @srcext;

if (@ARGV) {
  my %seen;
  @files = grep { -f && !exists $seen{$_} } map { glob $_ } @ARGV;
}
else {
  eval {
    require File::Find;
    File::Find::find(sub {
      $File::Find::name =~ /\.($srcext)$/i
          and push @files, $File::Find::name;
    }, '.');
  };
  if ($@) {
    @files = map { glob "*.$_" } @srcext;
  }
}

if (!@ARGV || $opt{filter}) {
  my(@in, @out);
  my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
  for (@files) {
    my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/\.($srcext)$/i;
    push @{ $out ? \@out : \@in }, $_;
  }
  if (@ARGV && @out) {
    warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
  }
  @files = @in;
}

unless (@files) {
  die "No input files given!\n";
}

my(%files, %global, %revreplace);
%revreplace = reverse %replace;
my $filename;
my $patch_opened = 0;

for $filename (@files) {
  unless (open IN, "<$filename") {
    warn "Unable to read from $filename: $!\n";
    next;
  }

  info("Scanning $filename ...");

  my $c = do { local $/; <IN> };
  close IN;

  my %file = (orig => $c, changes => 0);

  # temporarily remove C comments from the code
  my @ccom;
  $c =~ s{
    (
        [^"'/]+
      |
        (?:"[^"\\]*(?:\\.[^"\\]*)*" [^"'/]*)+
      |
        (?:'[^'\\]*(?:\\.[^'\\]*)*' [^"'/]*)+
    )
  |
    (/ (?:
        \*[^*]*\*+(?:[^$ccs][^*]*\*+)* /
        |
        /[^\r\n]*
      ))
  }{
    defined $2 and push @ccom, $2;
    defined $1 ? $1 : "$ccs$#ccom$cce";
  }egsx;

  $file{ccom} = \@ccom;
  $file{code} = $c;
  $file{has_inc_ppport} = ($c =~ /#.*include.*\Q$ppport\E/);

  my $func;

  for $func (keys %API) {
    my $match = $func;
    $match .= "|$revreplace{$func}" if exists $revreplace{$func};
    if ($c =~ /\b(?:Perl_)?($match)\b/) {
      $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
      $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
      if (exists $API{$func}{provided}) {
        if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
          $file{uses}{$func}++;
          my @deps = rec_depend($func);
          if (@deps) {
            $file{uses_deps}{$func} = \@deps;
            for (@deps) {
              $file{uses}{$_} = 0 unless exists $file{uses}{$_};
            }
          }
          for ($func, @deps) {
            if (exists $need{$_}) {
              $file{needs}{$_} = 'static';
            }
          }
        }
      }
      if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {
        if ($c =~ /\b$func\b/) {
          $file{uses_todo}{$func}++;
        }
      }
    }
  }

  while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
    if (exists $need{$2}) {
      $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
    }
    else {
      warning("Possibly wrong #define $1 in $filename");
    }
  }

  for (qw(uses needs uses_todo needed_global needed_static)) {
    for $func (keys %{$file{$_}}) {
      push @{$global{$_}{$func}}, $filename;
    }
  }

  $files{$filename} = \%file;
}

# Globally resolve NEED_'s
my $need;
for $need (keys %{$global{needs}}) {
  if (@{$global{needs}{$need}} > 1) {
    my @targets = @{$global{needs}{$need}};
    my @t = grep $files{$_}{needed_global}{$need}, @targets;
    @targets = @t if @t;
    @t = grep /\.xs$/i, @targets;
    @targets = @t if @t;
    my $target = shift @targets;
    $files{$target}{needs}{$need} = 'global';
    for (@{$global{needs}{$need}}) {
      $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
    }
  }
}

for $filename (@files) {
  exists $files{$filename} or next;

  info("=== Analyzing $filename ===");

  my %file = %{$files{$filename}};
  my $func;
  my $c = $file{code};

  for $func (sort keys %{$file{uses_Perl}}) {
    if ($API{$func}{varargs}) {
      my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
                            { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
      if ($changes) {
        warning("Doesn't pass interpreter argument aTHX to Perl_$func");
        $file{changes} += $changes;
      }
    }
    else {
      warning("Uses Perl_$func instead of $func");
      $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
                                {$func$1(}g);
    }
  }

  for $func (sort keys %{$file{uses_replace}}) {
    warning("Uses $func instead of $replace{$func}");
    $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
  }

  for $func (sort keys %{$file{uses}}) {
    next unless $file{uses}{$func};   # if it's only a dependency
    if (exists $file{uses_deps}{$func}) {
      diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
    }
    elsif (exists $replace{$func}) {
      warning("Uses $func instead of $replace{$func}");
      $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
    }
    else {
      diag("Uses $func");
    }
    hint($func);
  }

  for $func (sort keys %{$file{uses_todo}}) {
    warning("Uses $func, which may not be portable below perl ",
            format_version($API{$func}{todo}));
  }

  for $func (sort keys %{$file{needed_static}}) {
    my $message = '';
    if (not exists $file{uses}{$func}) {
      $message = "No need to define NEED_$func if $func is never used";
    }
    elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
      $message = "No need to define NEED_$func when already needed globally";
    }
    if ($message) {
      diag($message);
      $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
    }
  }

  for $func (sort keys %{$file{needed_global}}) {
    my $message = '';
    if (not exists $global{uses}{$func}) {
      $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
    }
    elsif (exists $file{needs}{$func}) {
      if ($file{needs}{$func} eq 'extern') {
        $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
      }
      elsif ($file{needs}{$func} eq 'static') {
        $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
      }
    }
    if ($message) {
      diag($message);
      $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
    }
  }

  $file{needs_inc_ppport} = keys %{$file{uses}};

  if ($file{needs_inc_ppport}) {
    my $pp = '';

    for $func (sort keys %{$file{needs}}) {
      my $type = $file{needs}{$func};
      next if $type eq 'extern';
      my $suffix = $type eq 'global' ? '_GLOBAL' : '';
      unless (exists $file{"needed_$type"}{$func}) {
        if ($type eq 'global') {
          diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
        }
        else {
          diag("File needs $func, adding static request");
        }
        $pp .= "#define NEED_$func$suffix\n";
      }
    }

    if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
      $pp = '';
      $file{changes}++;
    }

    unless ($file{has_inc_ppport}) {
      diag("Needs to include '$ppport'");
      $pp .= qq(#include "$ppport"\n)
    }

    if ($pp) {
      $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
                     || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
                     || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
                     || ($c =~ s/^/$pp/);
    }
  }
  else {
    if ($file{has_inc_ppport}) {
      diag("No need to include '$ppport'");
      $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
    }
  }

  # put back in our C comments
  my $ix;
  my $cppc = 0;
  my @ccom = @{$file{ccom}};
  for $ix (0 .. $#ccom) {
    if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
      $cppc++;
      $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
    }
    else {
      $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
    }
  }

  if ($cppc) {
    my $s = $cppc != 1 ? 's' : '';
    warning("Uses $cppc C++ style comment$s, which is not portable");
  }

  if ($file{changes}) {
    if (exists $opt{copy}) {
      my $newfile = "$filename$opt{copy}";
      if (-e $newfile) {
        error("'$newfile' already exists, refusing to write copy of '$filename'");
      }
      else {
        local *F;
        if (open F, ">$newfile") {
          info("Writing copy of '$filename' with changes to '$newfile'");
          print F $c;
          close F;
        }
        else {
          error("Cannot open '$newfile' for writing: $!");
        }
      }
    }
    elsif (exists $opt{patch} || $opt{changes}) {
      if (exists $opt{patch}) {
        unless ($patch_opened) {
          if (open PATCH, ">$opt{patch}") {
            $patch_opened = 1;
          }
          else {
            error("Cannot open '$opt{patch}' for writing: $!");
            delete $opt{patch};
            $opt{changes} = 1;
            goto fallback;
          }
        }
        mydiff(\*PATCH, $filename, $c);
      }
      else {
fallback:
        info("Suggested changes:");
        mydiff(\*STDOUT, $filename, $c);
      }
    }
    else {
      my $s = $file{changes} == 1 ? '' : 's';
      info("$file{changes} potentially required change$s detected");
    }
  }
  else {
    info("Looks good");
  }
}

close PATCH if $patch_opened;

exit 0;


sub mydiff
{
  local *F = shift;
  my($file, $str) = @_;
  my $diff;

  if (exists $opt{diff}) {
    $diff = run_diff($opt{diff}, $file, $str);
  }

  if (!defined $diff and can_use('Text::Diff')) {
    $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
    $diff = <<HEADER . $diff;
--- $file
+++ $file.patched
HEADER
  }

  if (!defined $diff) {
    $diff = run_diff('diff -u', $file, $str);
  }

  if (!defined $diff) {
    $diff = run_diff('diff', $file, $str);
  }

  if (!defined $diff) {
    error("Cannot generate a diff. Please install Text::Diff or use --copy.");
    return;
  }

  print F $diff;

}

sub run_diff
{
  my($prog, $file, $str) = @_;
  my $tmp = 'dppptemp';
  my $suf = 'aaa';
  my $diff = '';
  local *F;

  while (-e "$tmp.$suf") { $suf++ }
  $tmp = "$tmp.$suf";

  if (open F, ">$tmp") {
    print F $str;
    close F;

    if (open F, "$prog $file $tmp |") {
      while (<F>) {
        s/\Q$tmp\E/$file.patched/;
        $diff .= $_;
      }
      close F;
      unlink $tmp;
      return $diff;
    }

    unlink $tmp;
  }
  else {
    error("Cannot open '$tmp' for writing: $!");
  }

  return undef;
}

sub can_use
{
  eval "use @_;";
  return $@ eq '';
}

sub rec_depend
{
  my $func = shift;
  my %seen;
  return () unless exists $depends{$func};
  grep !$seen{$_}++, map { ($_, rec_depend($_)) } @{$depends{$func}};
}

sub parse_version
{
  my $ver = shift;

  if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
    return ($1, $2, $3);
  }
  elsif ($ver !~ /^\d+\.[\d_]+$/) {
    die "cannot parse version '$ver'\n";
  }

  $ver =~ s/_//g;
  $ver =~ s/$/000000/;

  my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;

  $v = int $v;
  $s = int $s;

  if ($r < 5 || ($r == 5 && $v < 6)) {
    if ($s % 10) {
      die "cannot parse version '$ver'\n";
    }
  }

  return ($r, $v, $s);
}

sub format_version
{
  my $ver = shift;

  $ver =~ s/$/000000/;
  my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;

  $v = int $v;
  $s = int $s;

  if ($r < 5 || ($r == 5 && $v < 6)) {
    if ($s % 10) {
      die "invalid version '$ver'\n";
    }
    $s /= 10;

    $ver = sprintf "%d.%03d", $r, $v;
    $s > 0 and $ver .= sprintf "_%02d", $s;

    return $ver;
  }

  return sprintf "%d.%d.%d", $r, $v, $s;
}

sub info
{
  $opt{quiet} and return;
  print @_, "\n";
}

sub diag
{
  $opt{quiet} and return;
  $opt{diag} and print @_, "\n";
}

sub warning
{
  $opt{quiet} and return;
  print "*** ", @_, "\n";
}

sub error
{
  print "*** ERROR: ", @_, "\n";
}

my %given_hints;
sub hint
{
  $opt{quiet} and return;
  $opt{hints} or return;
  my $func = shift;
  exists $hints{$func} or return;
  $given_hints{$func}++ and return;
  my $hint = $hints{$func};
  $hint =~ s/^/   /mg;
  print "   --- hint for $func ---\n", $hint;
}

sub usage
{
  my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
  my %M = ( 'I' => '*' );
  $usage =~ s/^\s*perl\s+\S+/$^X $0/;
  $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;

  print <<ENDUSAGE;

Usage: $usage

See perldoc $0 for details.

ENDUSAGE

  exit 2;
}

__DATA__
*/

#ifndef _P_P_PORTABILITY_H_
#define _P_P_PORTABILITY_H_

#ifndef DPPP_NAMESPACE
#  define DPPP_NAMESPACE DPPP_
#endif

#define DPPP_CAT2(x,y) CAT2(x,y)
#define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)

#ifndef PERL_REVISION
#  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
#    define PERL_PATCHLEVEL_H_IMPLICIT
#    include <patchlevel.h>
#  endif
#  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
#    include <could_not_find_Perl_patchlevel.h>
#  endif
#  ifndef PERL_REVISION
#    define PERL_REVISION       (5)
     /* Replace: 1 */
#    define PERL_VERSION        PATCHLEVEL
#    define PERL_SUBVERSION     SUBVERSION
     /* Replace PERL_PATCHLEVEL with PERL_VERSION */
     /* Replace: 0 */
#  endif
#endif

#define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)

/* It is very unlikely that anyone will try to use this with Perl 6
   (or greater), but who knows.
 */
#if PERL_REVISION != 5
#  error ppport.h only works with Perl version 5
#endif /* PERL_REVISION != 5 */

#ifdef I_LIMITS
#  include <limits.h>
#endif

#ifndef PERL_UCHAR_MIN
#  define PERL_UCHAR_MIN ((unsigned char)0)
#endif

#ifndef PERL_UCHAR_MAX
#  ifdef UCHAR_MAX
#    define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
#  else
#    ifdef MAXUCHAR
#      define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
#    else
#      define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
#    endif
#  endif
#endif

#ifndef PERL_USHORT_MIN
#  define PERL_USHORT_MIN ((unsigned short)0)
#endif

#ifndef PERL_USHORT_MAX
#  ifdef USHORT_MAX
#    define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
#  else
#    ifdef MAXUSHORT
#      define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
#    else
#      ifdef USHRT_MAX
#        define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
#      else
#        define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
#      endif
#    endif
#  endif
#endif

#ifndef PERL_SHORT_MAX
#  ifdef SHORT_MAX
#    define PERL_SHORT_MAX ((short)SHORT_MAX)
#  else
#    ifdef MAXSHORT    /* Often used in <values.h> */
#      define PERL_SHORT_MAX ((short)MAXSHORT)
#    else
#      ifdef SHRT_MAX
#        define PERL_SHORT_MAX ((short)SHRT_MAX)
#      else
#        define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
#      endif
#    endif
#  endif
#endif

#ifndef PERL_SHORT_MIN
#  ifdef SHORT_MIN
#    define PERL_SHORT_MIN ((short)SHORT_MIN)
#  else
#    ifdef MINSHORT
#      define PERL_SHORT_MIN ((short)MINSHORT)
#    else
#      ifdef SHRT_MIN
#        define PERL_SHORT_MIN ((short)SHRT_MIN)
#      else
#        define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
#      endif
#    endif
#  endif
#endif

#ifndef PERL_UINT_MAX
#  ifdef UINT_MAX
#    define PERL_UINT_MAX ((unsigned int)UINT_MAX)
#  else
#    ifdef MAXUINT
#      define PERL_UINT_MAX ((unsigned int)MAXUINT)
#    else
#      define PERL_UINT_MAX (~(unsigned int)0)
#    endif
#  endif
#endif

#ifndef PERL_UINT_MIN
#  define PERL_UINT_MIN ((unsigned int)0)
#endif

#ifndef PERL_INT_MAX
#  ifdef INT_MAX
#    define PERL_INT_MAX ((int)INT_MAX)
#  else
#    ifdef MAXINT    /* Often used in <values.h> */
#      define PERL_INT_MAX ((int)MAXINT)
#    else
#      define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
#    endif
#  endif
#endif

#ifndef PERL_INT_MIN
#  ifdef INT_MIN
#    define PERL_INT_MIN ((int)INT_MIN)
#  else
#    ifdef MININT
#      define PERL_INT_MIN ((int)MININT)
#    else
#      define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
#    endif
#  endif
#endif

#ifndef PERL_ULONG_MAX
#  ifdef ULONG_MAX
#    define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
#  else
#    ifdef MAXULONG
#      define PERL_ULONG_MAX ((unsigned long)MAXULONG)
#    else
#      define PERL_ULONG_MAX (~(unsigned long)0)
#    endif
#  endif
#endif

#ifndef PERL_ULONG_MIN
#  define PERL_ULONG_MIN ((unsigned long)0L)
#endif

#ifndef PERL_LONG_MAX
#  ifdef LONG_MAX
#    define PERL_LONG_MAX ((long)LONG_MAX)
#  else
#    ifdef MAXLONG
#      define PERL_LONG_MAX ((long)MAXLONG)
#    else
#      define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
#    endif
#  endif
#endif

#ifndef PERL_LONG_MIN
#  ifdef LONG_MIN
#    define PERL_LONG_MIN ((long)LONG_MIN)
#  else
#    ifdef MINLONG
#      define PERL_LONG_MIN ((long)MINLONG)
#    else
#      define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
#    endif
#  endif
#endif

#if defined(HAS_QUAD) && (defined(convex) || defined(uts))
#  ifndef PERL_UQUAD_MAX
#    ifdef ULONGLONG_MAX
#      define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
#    else
#      ifdef MAXULONGLONG
#        define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
#      else
#        define PERL_UQUAD_MAX (~(unsigned long long)0)
#      endif
#    endif
#  endif

#  ifndef PERL_UQUAD_MIN
#    define PERL_UQUAD_MIN ((unsigned long long)0L)
#  endif

#  ifndef PERL_QUAD_MAX
#    ifdef LONGLONG_MAX
#      define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
#    else
#      ifdef MAXLONGLONG
#        define PERL_QUAD_MAX ((long long)MAXLONGLONG)
#      else
#        define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
#      endif
#    endif
#  endif

#  ifndef PERL_QUAD_MIN
#    ifdef LONGLONG_MIN
#      define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
#    else
#      ifdef MINLONGLONG
#        define PERL_QUAD_MIN ((long long)MINLONGLONG)
#      else
#        define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
#      endif
#    endif
#  endif
#endif

/* This is based on code from 5.003 perl.h */
#ifdef HAS_QUAD
#  ifdef cray
#ifndef IVTYPE
#  define IVTYPE                         int
#endif

#ifndef IV_MIN
#  define IV_MIN                         PERL_INT_MIN
#endif

#ifndef IV_MAX
#  define IV_MAX                         PERL_INT_MAX
#endif

#ifndef UV_MIN
#  define UV_MIN                         PERL_UINT_MIN
#endif

#ifndef UV_MAX
#  define UV_MAX                         PERL_UINT_MAX
#endif

#    ifdef INTSIZE
#ifndef IVSIZE
#  define IVSIZE                         INTSIZE
#endif

#    endif
#  else
#    if defined(convex) || defined(uts)
#ifndef IVTYPE
#  define IVTYPE                         long long
#endif

#ifndef IV_MIN
#  define IV_MIN                         PERL_QUAD_MIN
#endif

#ifndef IV_MAX
#  define IV_MAX                         PERL_QUAD_MAX
#endif

#ifndef UV_MIN
#  define UV_MIN                         PERL_UQUAD_MIN
#endif

#ifndef UV_MAX
#  define UV_MAX                         PERL_UQUAD_MAX
#endif

#      ifdef LONGLONGSIZE
#ifndef IVSIZE
#  define IVSIZE                         LONGLONGSIZE
#endif

#      endif
#    else
#ifndef IVTYPE
#  define IVTYPE                         long
#endif

#ifndef IV_MIN
#  define IV_MIN                         PERL_LONG_MIN
#endif

#ifndef IV_MAX
#  define IV_MAX                         PERL_LONG_MAX
#endif

#ifndef UV_MIN
#  define UV_MIN                         PERL_ULONG_MIN
#endif

#ifndef UV_MAX
#  define UV_MAX                         PERL_ULONG_MAX
#endif

#      ifdef LONGSIZE
#ifndef IVSIZE
#  define IVSIZE                         LONGSIZE
#endif

#      endif
#    endif
#  endif
#ifndef IVSIZE
#  define IVSIZE                         8
#endif

#ifndef PERL_QUAD_MIN
#  define PERL_QUAD_MIN                  IV_MIN
#endif

#ifndef PERL_QUAD_MAX
#  define PERL_QUAD_MAX                  IV_MAX
#endif

#ifndef PERL_UQUAD_MIN
#  define PERL_UQUAD_MIN                 UV_MIN
#endif

#ifndef PERL_UQUAD_MAX
#  define PERL_UQUAD_MAX                 UV_MAX
#endif

#else
#ifndef IVTYPE
#  define IVTYPE                         long
#endif

#ifndef IV_MIN
#  define IV_MIN                         PERL_LONG_MIN
#endif

#ifndef IV_MAX
#  define IV_MAX                         PERL_LONG_MAX
#endif

#ifndef UV_MIN
#  define UV_MIN                         PERL_ULONG_MIN
#endif

#ifndef UV_MAX
#  define UV_MAX                         PERL_ULONG_MAX
#endif

#endif

#ifndef IVSIZE
#  ifdef LONGSIZE
#    define IVSIZE LONGSIZE
#  else
#    define IVSIZE 4 /* A bold guess, but the best we can make. */
#  endif
#endif
#ifndef UVTYPE
#  define UVTYPE                         unsigned IVTYPE
#endif

#ifndef UVSIZE
#  define UVSIZE                         IVSIZE
#endif

#ifndef sv_setuv
#  define sv_setuv(sv, uv)                  \
   STMT_START {                             \
       UV TeMpUv = uv;                      \
       if (TeMpUv <= IV_MAX)                \
           sv_setiv(sv, TeMpUv);            \
       else                                 \
           sv_setnv(sv, (double)TeMpUv);    \
   } STMT_END
#endif

#ifndef newSVuv
#  define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
#endif
#ifndef sv_2uv
#  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
#endif

#ifndef SvUVX
#  define SvUVX(sv)                      ((UV)SvIVX(sv))
#endif

#ifndef SvUVXx
#  define SvUVXx(sv)                     SvUVX(sv)
#endif

#ifndef SvUV
#  define SvUV(sv)                       (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
#endif

#ifndef SvUVx
#  define SvUVx(sv)                      ((PL_Sv = (sv)), SvUV(PL_Sv))
#endif

/* Hint: sv_uv
 * Always use the SvUVx() macro instead of sv_uv().
 */
#ifndef sv_uv
#  define sv_uv(sv)                      SvUVx(sv)
#endif
#ifndef XST_mUV
#  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
#endif

#ifndef XSRETURN_UV
#  define XSRETURN_UV(v)                 STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END
#endif
#ifndef PUSHu
#  define PUSHu(u)                       STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
#endif

#ifndef XPUSHu
#  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
#endif

#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5))
/* Replace: 1 */
#  define PL_DBsingle               DBsingle
#  define PL_DBsub                  DBsub
#  define PL_Sv                     Sv
#  define PL_compiling              compiling
#  define PL_copline                copline
#  define PL_curcop                 curcop
#  define PL_curstash               curstash
#  define PL_debstash               debstash
#  define PL_defgv                  defgv
#  define PL_diehook                diehook
#  define PL_dirty                  dirty
#  define PL_dowarn                 dowarn
#  define PL_errgv                  errgv
#  define PL_hexdigit               hexdigit
#  define PL_hints                  hints
#  define PL_na	                    na
#  define PL_no_modify              no_modify
#  define PL_perl_destruct_level    perl_destruct_level
#  define PL_perldb                 perldb
#  define PL_ppaddr                 ppaddr
#  define PL_rsfp_filters           rsfp_filters
#  define PL_rsfp                   rsfp
#  define PL_stack_base             stack_base
#  define PL_stack_sp               stack_sp
#  define PL_stdingv                stdingv
#  define PL_sv_arenaroot           sv_arenaroot
#  define PL_sv_no                  sv_no
#  define PL_sv_undef               sv_undef
#  define PL_sv_yes                 sv_yes
#  define PL_tainted                tainted
#  define PL_tainting               tainting
/* Replace: 0 */
#endif

#ifndef PERL_UNUSED_DECL
#  ifdef HASATTRIBUTE
#    if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
#      define PERL_UNUSED_DECL
#    else
#      define PERL_UNUSED_DECL __attribute__((unused))
#    endif
#  else
#    define PERL_UNUSED_DECL
#  endif
#endif
#ifndef NOOP
#  define NOOP                           (void)0
#endif

#ifndef dNOOP
#  define dNOOP                          extern int Perl___notused PERL_UNUSED_DECL
#endif

#ifndef NVTYPE
#  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
#    define NVTYPE long double
#  else
#    define NVTYPE double
#  endif
typedef NVTYPE NV;
#endif

#ifndef INT2PTR

#  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
#    define PTRV                  UV
#    define INT2PTR(any,d)        (any)(d)
#  else
#    if PTRSIZE == LONGSIZE
#      define PTRV                unsigned long
#    else
#      define PTRV                unsigned
#    endif
#    define INT2PTR(any,d)        (any)(PTRV)(d)
#  endif

#  define NUM2PTR(any,d)  (any)(PTRV)(d)
#  define PTR2IV(p)       INT2PTR(IV,p)
#  define PTR2UV(p)       INT2PTR(UV,p)
#  define PTR2NV(p)       NUM2PTR(NV,p)

#  if PTRSIZE == LONGSIZE
#    define PTR2ul(p)     (unsigned long)(p)
#  else
#    define PTR2ul(p)     INT2PTR(unsigned long,p)
#  endif

#endif /* !INT2PTR */

#undef START_EXTERN_C
#undef END_EXTERN_C
#undef EXTERN_C
#ifdef __cplusplus
#  define START_EXTERN_C extern "C" {
#  define END_EXTERN_C }
#  define EXTERN_C extern "C"
#else
#  define START_EXTERN_C
#  define END_EXTERN_C
#  define EXTERN_C extern
#endif

#ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
#  if defined(__STRICT_ANSI__) && defined(PERL_GCC_PEDANTIC)
#    define PERL_GCC_BRACE_GROUPS_FORBIDDEN
#  endif
#endif

#undef STMT_START
#undef STMT_END
#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
#  define STMT_START	(void)(	/* gcc supports ``({ STATEMENTS; })'' */
#  define STMT_END	)
#else
#  if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
#    define STMT_START	if (1)
#    define STMT_END	else (void)0
#  else
#    define STMT_START	do
#    define STMT_END	while (0)
#  endif
#endif
#ifndef boolSV
#  define boolSV(b)                      ((b) ? &PL_sv_yes : &PL_sv_no)
#endif

/* DEFSV appears first in 5.004_56 */
#ifndef DEFSV
#  define DEFSV                          GvSV(PL_defgv)
#endif

#ifndef SAVE_DEFSV
#  define SAVE_DEFSV                     SAVESPTR(GvSV(PL_defgv))
#endif

/* Older perls (<=5.003) lack AvFILLp */
#ifndef AvFILLp
#  define AvFILLp                        AvFILL
#endif
#ifndef ERRSV
#  define ERRSV                          get_sv("@",FALSE)
#endif
#ifndef newSVpvn
#  define newSVpvn(data,len)             ((data)                                              \
                                    ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
                                    : newSV(0))
#endif

/* Hint: gv_stashpvn
 * This function's backport doesn't support the length parameter, but
 * rather ignores it. Portability can only be ensured if the length
 * parameter is used for speed reasons, but the length can always be
 * correctly computed from the string argument.
 */
#ifndef gv_stashpvn
#  define gv_stashpvn(str,len,create)    gv_stashpv(str,create)
#endif

/* Replace: 1 */
#ifndef get_cv
#  define get_cv                         perl_get_cv
#endif

#ifndef get_sv
#  define get_sv                         perl_get_sv
#endif

#ifndef get_av
#  define get_av                         perl_get_av
#endif

#ifndef get_hv
#  define get_hv                         perl_get_hv
#endif

/* Replace: 0 */

#ifdef HAS_MEMCMP
#ifndef memNE
#  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
#endif

#ifndef memEQ
#  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
#endif

#else
#ifndef memNE
#  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
#endif

#ifndef memEQ
#  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
#endif

#endif
#ifndef MoveD
#  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
#endif

#ifndef CopyD
#  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
#endif

#ifdef HAS_MEMSET
#ifndef ZeroD
#  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
#endif

#else
#ifndef ZeroD
#  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)),d)
#endif

#endif
#ifndef Poison
#  define Poison(d,n,t)                  (void)memset((char*)(d), 0xAB, (n) * sizeof(t))
#endif
#ifndef dUNDERBAR
#  define dUNDERBAR                      dNOOP
#endif

#ifndef UNDERBAR
#  define UNDERBAR                       DEFSV
#endif
#ifndef dAX
#  define dAX                            I32 ax = MARK - PL_stack_base + 1
#endif

#ifndef dITEMS
#  define dITEMS                         I32 items = SP - MARK
#endif
#ifndef dXSTARG
#  define dXSTARG                        SV * targ = sv_newmortal()
#endif
#ifndef dTHR
#  define dTHR                           dNOOP
#endif
#ifndef dTHX
#  define dTHX                           dNOOP
#endif

#ifndef dTHXa
#  define dTHXa(x)                       dNOOP
#endif
#ifndef pTHX
#  define pTHX                           void
#endif

#ifndef pTHX_
#  define pTHX_
#endif

#ifndef aTHX
#  define aTHX
#endif

#ifndef aTHX_
#  define aTHX_
#endif
#ifndef dTHXoa
#  define dTHXoa(x)                      dTHXa(x)
#endif
#ifndef PUSHmortal
#  define PUSHmortal                     PUSHs(sv_newmortal())
#endif

#ifndef mPUSHp
#  define mPUSHp(p,l)                    sv_setpvn_mg(PUSHmortal, (p), (l))
#endif

#ifndef mPUSHn
#  define mPUSHn(n)                      sv_setnv_mg(PUSHmortal, (NV)(n))
#endif

#ifndef mPUSHi
#  define mPUSHi(i)                      sv_setiv_mg(PUSHmortal, (IV)(i))
#endif

#ifndef mPUSHu
#  define mPUSHu(u)                      sv_setuv_mg(PUSHmortal, (UV)(u))
#endif
#ifndef XPUSHmortal
#  define XPUSHmortal                    XPUSHs(sv_newmortal())
#endif

#ifndef mXPUSHp
#  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END
#endif

#ifndef mXPUSHn
#  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END
#endif

#ifndef mXPUSHi
#  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END
#endif

#ifndef mXPUSHu
#  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END
#endif

/* Replace: 1 */
#ifndef call_sv
#  define call_sv                        perl_call_sv
#endif

#ifndef call_pv
#  define call_pv                        perl_call_pv
#endif

#ifndef call_argv
#  define call_argv                      perl_call_argv
#endif

#ifndef call_method
#  define call_method                    perl_call_method
#endif
#ifndef eval_sv
#  define eval_sv                        perl_eval_sv
#endif

/* Replace: 0 */

/* Replace perl_eval_pv with eval_pv */
/* eval_pv depends on eval_sv */

#ifndef eval_pv
#if defined(NEED_eval_pv)
static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
static
#else
extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
#endif

#ifdef eval_pv
#  undef eval_pv
#endif
#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
#define Perl_eval_pv DPPP_(my_eval_pv)

#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)

SV*
DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
{
    dSP;
    SV* sv = newSVpv(p, 0);

    PUSHMARK(sp);
    eval_sv(sv, G_SCALAR);
    SvREFCNT_dec(sv);

    SPAGAIN;
    sv = POPs;
    PUTBACK;

    if (croak_on_error && SvTRUE(GvSV(errgv)))
	croak(SvPVx(GvSV(errgv), na));

    return sv;
}

#endif
#endif
#ifndef newRV_inc
#  define newRV_inc(sv)                  newRV(sv)   /* Replace */
#endif

#ifndef newRV_noinc
#if defined(NEED_newRV_noinc)
static SV * DPPP_(my_newRV_noinc)(SV *sv);
static
#else
extern SV * DPPP_(my_newRV_noinc)(SV *sv);
#endif

#ifdef newRV_noinc
#  undef newRV_noinc
#endif
#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
#define Perl_newRV_noinc DPPP_(my_newRV_noinc)

#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
SV *
DPPP_(my_newRV_noinc)(SV *sv)
{
  SV *rv = (SV *)newRV(sv);
  SvREFCNT_dec(sv);
  return rv;
}
#endif
#endif

/* Hint: newCONSTSUB
 * Returns a CV* as of perl-5.7.1. This return value is not supported
 * by Devel::PPPort.
 */

/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))) && ((PERL_VERSION != 4) || (PERL_SUBVERSION != 5))
#if defined(NEED_newCONSTSUB)
static void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);
static
#else
extern void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);
#endif

#ifdef newCONSTSUB
#  undef newCONSTSUB
#endif
#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)

#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)

void
DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv)
{
	U32 oldhints = PL_hints;
	HV *old_cop_stash = PL_curcop->cop_stash;
	HV *old_curstash = PL_curstash;
	line_t oldline = PL_curcop->cop_line;
	PL_curcop->cop_line = PL_copline;

	PL_hints &= ~HINT_BLOCK_SCOPE;
	if (stash)
		PL_curstash = PL_curcop->cop_stash = stash;

	newSUB(

#if   ((PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22)))
		start_subparse(),
#elif ((PERL_VERSION == 3) && (PERL_SUBVERSION == 22))
     		start_subparse(0),
#else  /* 5.003_23  onwards */
     		start_subparse(FALSE, 0),
#endif

		newSVOP(OP_CONST, 0, newSVpv(name,0)),
		newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
		newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
	);

	PL_hints = oldhints;
	PL_curcop->cop_stash = old_cop_stash;
	PL_curstash = old_curstash;
	PL_curcop->cop_line = oldline;
}
#endif
#endif

/*
 * Boilerplate macros for initializing and accessing interpreter-local
 * data from C.  All statics in extensions should be reworked to use
 * this, if you want to make the extension thread-safe.  See ext/re/re.xs
 * for an example of the use of these macros.
 *
 * Code that uses these macros is responsible for the following:
 * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
 * 2. Declare a typedef named my_cxt_t that is a structure that contains
 *    all the data that needs to be interpreter-local.
 * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
 * 4. Use the MY_CXT_INIT macro such that it is called exactly once
 *    (typically put in the BOOT: section).
 * 5. Use the members of the my_cxt_t structure everywhere as
 *    MY_CXT.member.
 * 6. Use the dMY_CXT macro (a declaration) in all the functions that
 *    access MY_CXT.
 */

#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
    defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)

#ifndef START_MY_CXT

/* This must appear in all extensions that define a my_cxt_t structure,
 * right after the definition (i.e. at file scope).  The non-threads
 * case below uses it to declare the data as static. */
#define START_MY_CXT

#if (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION < 68 ))
/* Fetches the SV that keeps the per-interpreter data. */
#define dMY_CXT_SV \
	SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
#else /* >= perl5.004_68 */
#define dMY_CXT_SV \
	SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,		\
				  sizeof(MY_CXT_KEY)-1, TRUE)
#endif /* < perl5.004_68 */

/* This declaration should be used within all functions that use the
 * interpreter-local data. */
#define dMY_CXT	\
	dMY_CXT_SV;							\
	my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))

/* Creates and zeroes the per-interpreter data.
 * (We allocate my_cxtp in a Perl SV so that it will be released when
 * the interpreter goes away.) */
#define MY_CXT_INIT \
	dMY_CXT_SV;							\
	/* newSV() allocates one more than needed */			\
	my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
	Zero(my_cxtp, 1, my_cxt_t);					\
	sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))

/* This macro must be used to access members of the my_cxt_t structure.
 * e.g. MYCXT.some_data */
#define MY_CXT		(*my_cxtp)

/* Judicious use of these macros can reduce the number of times dMY_CXT
 * is used.  Use is similar to pTHX, aTHX etc. */
#define pMY_CXT		my_cxt_t *my_cxtp
#define pMY_CXT_	pMY_CXT,
#define _pMY_CXT	,pMY_CXT
#define aMY_CXT		my_cxtp
#define aMY_CXT_	aMY_CXT,
#define _aMY_CXT	,aMY_CXT

#endif /* START_MY_CXT */

#ifndef MY_CXT_CLONE
/* Clones the per-interpreter data. */
#define MY_CXT_CLONE \
	dMY_CXT_SV;							\
	my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
	Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
	sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
#endif

#else /* single interpreter */

#ifndef START_MY_CXT

#define START_MY_CXT	static my_cxt_t my_cxt;
#define dMY_CXT_SV	dNOOP
#define dMY_CXT		dNOOP
#define MY_CXT_INIT	NOOP
#define MY_CXT		my_cxt

#define pMY_CXT		void
#define pMY_CXT_
#define _pMY_CXT
#define aMY_CXT
#define aMY_CXT_
#define _aMY_CXT

#endif /* START_MY_CXT */

#ifndef MY_CXT_CLONE
#define MY_CXT_CLONE	NOOP
#endif

#endif

#ifndef IVdf
#  if IVSIZE == LONGSIZE
#    define	IVdf      "ld"
#    define	UVuf      "lu"
#    define	UVof      "lo"
#    define	UVxf      "lx"
#    define	UVXf      "lX"
#  else
#    if IVSIZE == INTSIZE
#      define	IVdf      "d"
#      define	UVuf      "u"
#      define	UVof      "o"
#      define	UVxf      "x"
#      define	UVXf      "X"
#    endif
#  endif
#endif

#ifndef NVef
#  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
      defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */
#    define NVef          PERL_PRIeldbl
#    define NVff          PERL_PRIfldbl
#    define NVgf          PERL_PRIgldbl
#  else
#    define NVef          "e"
#    define NVff          "f"
#    define NVgf          "g"
#  endif
#endif

#ifndef SvPV_nolen

#if defined(NEED_sv_2pv_nolen)
static char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
static
#else
extern char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
#endif

#ifdef sv_2pv_nolen
#  undef sv_2pv_nolen
#endif
#define sv_2pv_nolen(a) DPPP_(my_sv_2pv_nolen)(aTHX_ a)
#define Perl_sv_2pv_nolen DPPP_(my_sv_2pv_nolen)

#if defined(NEED_sv_2pv_nolen) || defined(NEED_sv_2pv_nolen_GLOBAL)

char *
DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv)
{
  STRLEN n_a;
  return sv_2pv(sv, &n_a);
}

#endif

/* Hint: sv_2pv_nolen
 * Use the SvPV_nolen() macro instead of sv_2pv_nolen().
 */

/* SvPV_nolen depends on sv_2pv_nolen */
#define SvPV_nolen(sv) \
          ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
           ? SvPVX(sv) : sv_2pv_nolen(sv))

#endif

#ifdef SvPVbyte

/* Hint: SvPVbyte
 * Does not work in perl-5.6.1, ppport.h implements a version
 * borrowed from perl-5.7.3.
 */

#if ((PERL_VERSION < 7) || ((PERL_VERSION == 7) && (PERL_SUBVERSION < 0)))

#if defined(NEED_sv_2pvbyte)
static char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);
static
#else
extern char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);
#endif

#ifdef sv_2pvbyte
#  undef sv_2pvbyte
#endif
#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)

#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)

char *
DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp)
{
  sv_utf8_downgrade(sv,0);
  return SvPV(sv,*lp);
}

#endif

/* Hint: sv_2pvbyte
 * Use the SvPVbyte() macro instead of sv_2pvbyte().
 */

#undef SvPVbyte

/* SvPVbyte depends on sv_2pvbyte */
#define SvPVbyte(sv, lp)                                                \
        ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \
         ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))

#endif

#else

#  define SvPVbyte          SvPV
#  define sv_2pvbyte        sv_2pv

#endif

/* sv_2pvbyte_nolen depends on sv_2pv_nolen */
#ifndef sv_2pvbyte_nolen
#  define sv_2pvbyte_nolen               sv_2pv_nolen
#endif

/* Hint: sv_pvn
 * Always use the SvPV() macro instead of sv_pvn().
 */
#ifndef sv_pvn
#  define sv_pvn(sv, len)                SvPV(sv, len)
#endif

/* Hint: sv_pvn_force
 * Always use the SvPV_force() macro instead of sv_pvn_force().
 */
#ifndef sv_pvn_force
#  define sv_pvn_force(sv, len)          SvPV_force(sv, len)
#endif

#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(vnewSVpvf)
#if defined(NEED_vnewSVpvf)
static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
static
#else
extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
#endif

#ifdef vnewSVpvf
#  undef vnewSVpvf
#endif
#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)

#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)

SV *
DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
{
  register SV *sv = newSV(0);
  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
  return sv;
}

#endif
#endif

/* sv_vcatpvf depends on sv_vcatpvfn */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf)
#  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
#endif

/* sv_vsetpvf depends on sv_vsetpvfn */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf)
#  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
#endif

/* sv_catpvf_mg depends on sv_vcatpvfn, sv_catpvf_mg_nocontext */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg)
#if defined(NEED_sv_catpvf_mg)
static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
static
#else
extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
#endif

#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)

#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)

void
DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
{
  va_list args;
  va_start(args, pat);
  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
  SvSETMAGIC(sv);
  va_end(args);
}

#endif
#endif

/* sv_catpvf_mg_nocontext depends on sv_vcatpvfn */
#ifdef PERL_IMPLICIT_CONTEXT
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg_nocontext)
#if defined(NEED_sv_catpvf_mg_nocontext)
static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
static
#else
extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
#endif

#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)

#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)

void
DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
{
  dTHX;
  va_list args;
  va_start(args, pat);
  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
  SvSETMAGIC(sv);
  va_end(args);
}

#endif
#endif
#endif

#ifndef sv_catpvf_mg
#  ifdef PERL_IMPLICIT_CONTEXT
#    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext
#  else
#    define sv_catpvf_mg   Perl_sv_catpvf_mg
#  endif
#endif

/* sv_vcatpvf_mg depends on sv_vcatpvfn */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf_mg)
#  define sv_vcatpvf_mg(sv, pat, args)                                     \
   STMT_START {                                                            \
     sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
     SvSETMAGIC(sv);                                                       \
   } STMT_END
#endif

/* sv_setpvf_mg depends on sv_vsetpvfn, sv_setpvf_mg_nocontext */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg)
#if defined(NEED_sv_setpvf_mg)
static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
static
#else
extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
#endif

#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)

#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)

void
DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
{
  va_list args;
  va_start(args, pat);
  sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
  SvSETMAGIC(sv);
  va_end(args);
}

#endif
#endif

/* sv_setpvf_mg_nocontext depends on sv_vsetpvfn */
#ifdef PERL_IMPLICIT_CONTEXT
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg_nocontext)
#if defined(NEED_sv_setpvf_mg_nocontext)
static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
static
#else
extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
#endif

#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)

#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)

void
DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
{
  dTHX;
  va_list args;
  va_start(args, pat);
  sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
  SvSETMAGIC(sv);
  va_end(args);
}

#endif
#endif
#endif

#ifndef sv_setpvf_mg
#  ifdef PERL_IMPLICIT_CONTEXT
#    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext
#  else
#    define sv_setpvf_mg   Perl_sv_setpvf_mg
#  endif
#endif

/* sv_vsetpvf_mg depends on sv_vsetpvfn */
#if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf_mg)
#  define sv_vsetpvf_mg(sv, pat, args)                                     \
   STMT_START {                                                            \
     sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
     SvSETMAGIC(sv);                                                       \
   } STMT_END
#endif
#ifndef SvGETMAGIC
#  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
#endif
#ifndef PERL_MAGIC_sv
#  define PERL_MAGIC_sv                  '\0'
#endif

#ifndef PERL_MAGIC_overload
#  define PERL_MAGIC_overload            'A'
#endif

#ifndef PERL_MAGIC_overload_elem
#  define PERL_MAGIC_overload_elem       'a'
#endif

#ifndef PERL_MAGIC_overload_table
#  define PERL_MAGIC_overload_table      'c'
#endif

#ifndef PERL_MAGIC_bm
#  define PERL_MAGIC_bm                  'B'
#endif

#ifndef PERL_MAGIC_regdata
#  define PERL_MAGIC_regdata             'D'
#endif

#ifndef PERL_MAGIC_regdatum
#  define PERL_MAGIC_regdatum            'd'
#endif

#ifndef PERL_MAGIC_env
#  define PERL_MAGIC_env                 'E'
#endif

#ifndef PERL_MAGIC_envelem
#  define PERL_MAGIC_envelem             'e'
#endif

#ifndef PERL_MAGIC_fm
#  define PERL_MAGIC_fm                  'f'
#endif

#ifndef PERL_MAGIC_regex_global
#  define PERL_MAGIC_regex_global        'g'
#endif

#ifndef PERL_MAGIC_isa
#  define PERL_MAGIC_isa                 'I'
#endif

#ifndef PERL_MAGIC_isaelem
#  define PERL_MAGIC_isaelem             'i'
#endif

#ifndef PERL_MAGIC_nkeys
#  define PERL_MAGIC_nkeys               'k'
#endif

#ifndef PERL_MAGIC_dbfile
#  define PERL_MAGIC_dbfile              'L'
#endif

#ifndef PERL_MAGIC_dbline
#  define PERL_MAGIC_dbline              'l'
#endif

#ifndef PERL_MAGIC_mutex
#  define PERL_MAGIC_mutex               'm'
#endif

#ifndef PERL_MAGIC_shared
#  define PERL_MAGIC_shared              'N'
#endif

#ifndef PERL_MAGIC_shared_scalar
#  define PERL_MAGIC_shared_scalar       'n'
#endif

#ifndef PERL_MAGIC_collxfrm
#  define PERL_MAGIC_collxfrm            'o'
#endif

#ifndef PERL_MAGIC_tied
#  define PERL_MAGIC_tied                'P'
#endif

#ifndef PERL_MAGIC_tiedelem
#  define PERL_MAGIC_tiedelem            'p'
#endif

#ifndef PERL_MAGIC_tiedscalar
#  define PERL_MAGIC_tiedscalar          'q'
#endif

#ifndef PERL_MAGIC_qr
#  define PERL_MAGIC_qr                  'r'
#endif

#ifndef PERL_MAGIC_sig
#  define PERL_MAGIC_sig                 'S'
#endif

#ifndef PERL_MAGIC_sigelem
#  define PERL_MAGIC_sigelem             's'
#endif

#ifndef PERL_MAGIC_taint
#  define PERL_MAGIC_taint               't'
#endif

#ifndef PERL_MAGIC_uvar
#  define PERL_MAGIC_uvar                'U'
#endif

#ifndef PERL_MAGIC_uvar_elem
#  define PERL_MAGIC_uvar_elem           'u'
#endif

#ifndef PERL_MAGIC_vstring
#  define PERL_MAGIC_vstring             'V'
#endif

#ifndef PERL_MAGIC_vec
#  define PERL_MAGIC_vec                 'v'
#endif

#ifndef PERL_MAGIC_utf8
#  define PERL_MAGIC_utf8                'w'
#endif

#ifndef PERL_MAGIC_substr
#  define PERL_MAGIC_substr              'x'
#endif

#ifndef PERL_MAGIC_defelem
#  define PERL_MAGIC_defelem             'y'
#endif

#ifndef PERL_MAGIC_glob
#  define PERL_MAGIC_glob                '*'
#endif

#ifndef PERL_MAGIC_arylen
#  define PERL_MAGIC_arylen              '#'
#endif

#ifndef PERL_MAGIC_pos
#  define PERL_MAGIC_pos                 '.'
#endif

#ifndef PERL_MAGIC_backref
#  define PERL_MAGIC_backref             '<'
#endif

#ifndef PERL_MAGIC_ext
#  define PERL_MAGIC_ext                 '~'
#endif

/* That's the best we can do... */
#ifndef SvPV_force_nomg
#  define SvPV_force_nomg                SvPV_force
#endif

#ifndef SvPV_nomg
#  define SvPV_nomg                      SvPV
#endif

#ifndef sv_catpvn_nomg
#  define sv_catpvn_nomg                 sv_catpvn
#endif

#ifndef sv_catsv_nomg
#  define sv_catsv_nomg                  sv_catsv
#endif

#ifndef sv_setsv_nomg
#  define sv_setsv_nomg                  sv_setsv
#endif

#ifndef sv_pvn_nomg
#  define sv_pvn_nomg                    sv_pvn
#endif

#ifndef SvIV_nomg
#  define SvIV_nomg                      SvIV
#endif

#ifndef SvUV_nomg
#  define SvUV_nomg                      SvUV
#endif

#ifndef sv_catpv_mg
#  define sv_catpv_mg(sv, ptr)          \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_catpv(TeMpSv,ptr);              \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_catpvn_mg
#  define sv_catpvn_mg(sv, ptr, len)    \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_catpvn(TeMpSv,ptr,len);         \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_catsv_mg
#  define sv_catsv_mg(dsv, ssv)         \
   STMT_START {                         \
     SV *TeMpSv = dsv;                  \
     sv_catsv(TeMpSv,ssv);              \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setiv_mg
#  define sv_setiv_mg(sv, i)            \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_setiv(TeMpSv,i);                \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setnv_mg
#  define sv_setnv_mg(sv, num)          \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_setnv(TeMpSv,num);              \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setpv_mg
#  define sv_setpv_mg(sv, ptr)          \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_setpv(TeMpSv,ptr);              \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setpvn_mg
#  define sv_setpvn_mg(sv, ptr, len)    \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_setpvn(TeMpSv,ptr,len);         \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setsv_mg
#  define sv_setsv_mg(dsv, ssv)         \
   STMT_START {                         \
     SV *TeMpSv = dsv;                  \
     sv_setsv(TeMpSv,ssv);              \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_setuv_mg
#  define sv_setuv_mg(sv, i)            \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_setuv(TeMpSv,i);                \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifndef sv_usepvn_mg
#  define sv_usepvn_mg(sv, ptr, len)    \
   STMT_START {                         \
     SV *TeMpSv = sv;                   \
     sv_usepvn(TeMpSv,ptr,len);         \
     SvSETMAGIC(TeMpSv);                \
   } STMT_END
#endif

#ifdef USE_ITHREADS
#ifndef CopFILE
#  define CopFILE(c)                     ((c)->cop_file)
#endif

#ifndef CopFILEGV
#  define CopFILEGV(c)                   (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
#endif

#ifndef CopFILE_set
#  define CopFILE_set(c,pv)              ((c)->cop_file = savepv(pv))
#endif

#ifndef CopFILESV
#  define CopFILESV(c)                   (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
#endif

#ifndef CopFILEAV
#  define CopFILEAV(c)                   (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
#endif

#ifndef CopSTASHPV
#  define CopSTASHPV(c)                  ((c)->cop_stashpv)
#endif

#ifndef CopSTASHPV_set
#  define CopSTASHPV_set(c,pv)           ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
#endif

#ifndef CopSTASH
#  define CopSTASH(c)                    (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
#endif

#ifndef CopSTASH_set
#  define CopSTASH_set(c,hv)             CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
#endif

#ifndef CopSTASH_eq
#  define CopSTASH_eq(c,hv)              ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
					|| (CopSTASHPV(c) && HvNAME(hv) \
					&& strEQ(CopSTASHPV(c), HvNAME(hv)))))
#endif

#else
#ifndef CopFILEGV
#  define CopFILEGV(c)                   ((c)->cop_filegv)
#endif

#ifndef CopFILEGV_set
#  define CopFILEGV_set(c,gv)            ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
#endif

#ifndef CopFILE_set
#  define CopFILE_set(c,pv)              CopFILEGV_set((c), gv_fetchfile(pv))
#endif

#ifndef CopFILESV
#  define CopFILESV(c)                   (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
#endif

#ifndef CopFILEAV
#  define CopFILEAV(c)                   (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
#endif

#ifndef CopFILE
#  define CopFILE(c)                     (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
#endif

#ifndef CopSTASH
#  define CopSTASH(c)                    ((c)->cop_stash)
#endif

#ifndef CopSTASH_set
#  define CopSTASH_set(c,hv)             ((c)->cop_stash = (hv))
#endif

#ifndef CopSTASHPV
#  define CopSTASHPV(c)                  (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
#endif

#ifndef CopSTASHPV_set
#  define CopSTASHPV_set(c,pv)           CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
#endif

#ifndef CopSTASH_eq
#  define CopSTASH_eq(c,hv)              (CopSTASH(c) == (hv))
#endif

#endif /* USE_ITHREADS */
#ifndef IN_PERL_COMPILETIME
#  define IN_PERL_COMPILETIME            (PL_curcop == &PL_compiling)
#endif

#ifndef IN_LOCALE_RUNTIME
#  define IN_LOCALE_RUNTIME              (PL_curcop->op_private & HINT_LOCALE)
#endif

#ifndef IN_LOCALE_COMPILETIME
#  define IN_LOCALE_COMPILETIME          (PL_hints & HINT_LOCALE)
#endif

#ifndef IN_LOCALE
#  define IN_LOCALE                      (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)
#endif
#ifndef IS_NUMBER_IN_UV
#  define IS_NUMBER_IN_UV                0x01
#endif

#ifndef IS_NUMBER_GREATER_THAN_UV_MAX
#  define IS_NUMBER_GREATER_THAN_UV_MAX  0x02
#endif

#ifndef IS_NUMBER_NOT_INT
#  define IS_NUMBER_NOT_INT              0x04
#endif

#ifndef IS_NUMBER_NEG
#  define IS_NUMBER_NEG                  0x08
#endif

#ifndef IS_NUMBER_INFINITY
#  define IS_NUMBER_INFINITY             0x10
#endif

#ifndef IS_NUMBER_NAN
#  define IS_NUMBER_NAN                  0x20
#endif

/* GROK_NUMERIC_RADIX depends on grok_numeric_radix */
#ifndef GROK_NUMERIC_RADIX
#  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)
#endif
#ifndef PERL_SCAN_GREATER_THAN_UV_MAX
#  define PERL_SCAN_GREATER_THAN_UV_MAX  0x02
#endif

#ifndef PERL_SCAN_SILENT_ILLDIGIT
#  define PERL_SCAN_SILENT_ILLDIGIT      0x04
#endif

#ifndef PERL_SCAN_ALLOW_UNDERSCORES
#  define PERL_SCAN_ALLOW_UNDERSCORES    0x01
#endif

#ifndef PERL_SCAN_DISALLOW_PREFIX
#  define PERL_SCAN_DISALLOW_PREFIX      0x02
#endif

#ifndef grok_numeric_radix
#if defined(NEED_grok_numeric_radix)
static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
static
#else
extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
#endif

#ifdef grok_numeric_radix
#  undef grok_numeric_radix
#endif
#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)

#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
bool
DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
{
#ifdef USE_LOCALE_NUMERIC
#ifdef PL_numeric_radix_sv
    if (PL_numeric_radix_sv && IN_LOCALE) {
        STRLEN len;
        char* radix = SvPV(PL_numeric_radix_sv, len);
        if (*sp + len <= send && memEQ(*sp, radix, len)) {
            *sp += len;
            return TRUE;
        }
    }
#else
    /* older perls don't have PL_numeric_radix_sv so the radix
     * must manually be requested from locale.h
     */
#include <locale.h>
    dTHR;  /* needed for older threaded perls */
    struct lconv *lc = localeconv();
    char *radix = lc->decimal_point;
    if (radix && IN_LOCALE) {
        STRLEN len = strlen(radix);
        if (*sp + len <= send && memEQ(*sp, radix, len)) {
            *sp += len;
            return TRUE;
        }
    }
#endif /* PERL_VERSION */
#endif /* USE_LOCALE_NUMERIC */
    /* always try "." if numeric radix didn't match because
     * we may have data from different locales mixed */
    if (*sp < send && **sp == '.') {
        ++*sp;
        return TRUE;
    }
    return FALSE;
}
#endif
#endif

/* grok_number depends on grok_numeric_radix */

#ifndef grok_number
#if defined(NEED_grok_number)
static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
static
#else
extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
#endif

#ifdef grok_number
#  undef grok_number
#endif
#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
#define Perl_grok_number DPPP_(my_grok_number)

#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
int
DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
{
  const char *s = pv;
  const char *send = pv + len;
  const UV max_div_10 = UV_MAX / 10;
  const char max_mod_10 = UV_MAX % 10;
  int numtype = 0;
  int sawinf = 0;
  int sawnan = 0;

  while (s < send && isSPACE(*s))
    s++;
  if (s == send) {
    return 0;
  } else if (*s == '-') {
    s++;
    numtype = IS_NUMBER_NEG;
  }
  else if (*s == '+')
  s++;

  if (s == send)
    return 0;

  /* next must be digit or the radix separator or beginning of infinity */
  if (isDIGIT(*s)) {
    /* UVs are at least 32 bits, so the first 9 decimal digits cannot
       overflow.  */
    UV value = *s - '0';
    /* This construction seems to be more optimiser friendly.
       (without it gcc does the isDIGIT test and the *s - '0' separately)
       With it gcc on arm is managing 6 instructions (6 cycles) per digit.
       In theory the optimiser could deduce how far to unroll the loop
       before checking for overflow.  */
    if (++s < send) {
      int digit = *s - '0';
      if (digit >= 0 && digit <= 9) {
        value = value * 10 + digit;
        if (++s < send) {
          digit = *s - '0';
          if (digit >= 0 && digit <= 9) {
            value = value * 10 + digit;
            if (++s < send) {
              digit = *s - '0';
              if (digit >= 0 && digit <= 9) {
                value = value * 10 + digit;
		if (++s < send) {
                  digit = *s - '0';
                  if (digit >= 0 && digit <= 9) {
                    value = value * 10 + digit;
                    if (++s < send) {
                      digit = *s - '0';
                      if (digit >= 0 && digit <= 9) {
                        value = value * 10 + digit;
                        if (++s < send) {
                          digit = *s - '0';
                          if (digit >= 0 && digit <= 9) {
                            value = value * 10 + digit;
                            if (++s < send) {
                              digit = *s - '0';
                              if (digit >= 0 && digit <= 9) {
                                value = value * 10 + digit;
                                if (++s < send) {
                                  digit = *s - '0';
                                  if (digit >= 0 && digit <= 9) {
                                    value = value * 10 + digit;
                                    if (++s < send) {
                                      /* Now got 9 digits, so need to check
                                         each time for overflow.  */
                                      digit = *s - '0';
                                      while (digit >= 0 && digit <= 9
                                             && (value < max_div_10
                                                 || (value == max_div_10
                                                     && digit <= max_mod_10))) {
                                        value = value * 10 + digit;
                                        if (++s < send)
                                          digit = *s - '0';
                                        else
                                          break;
                                      }
                                      if (digit >= 0 && digit <= 9
                                          && (s < send)) {
                                        /* value overflowed.
                                           skip the remaining digits, don't
                                           worry about setting *valuep.  */
                                        do {
                                          s++;
                                        } while (s < send && isDIGIT(*s));
                                        numtype |=
                                          IS_NUMBER_GREATER_THAN_UV_MAX;
                                        goto skip_value;
                                      }
                                    }
                                  }
				}
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
	}
      }
    }
    numtype |= IS_NUMBER_IN_UV;
    if (valuep)
      *valuep = value;

  skip_value:
    if (GROK_NUMERIC_RADIX(&s, send)) {
      numtype |= IS_NUMBER_NOT_INT;
      while (s < send && isDIGIT(*s))  /* optional digits after the radix */
        s++;
    }
  }
  else if (GROK_NUMERIC_RADIX(&s, send)) {
    numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */
    /* no digits before the radix means we need digits after it */
    if (s < send && isDIGIT(*s)) {
      do {
        s++;
      } while (s < send && isDIGIT(*s));
      if (valuep) {
        /* integer approximation is valid - it's 0.  */
        *valuep = 0;
      }
    }
    else
      return 0;
  } else if (*s == 'I' || *s == 'i') {
    s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
    s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
    s++; if (s < send && (*s == 'I' || *s == 'i')) {
      s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
      s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
      s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
      s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
      s++;
    }
    sawinf = 1;
  } else if (*s == 'N' || *s == 'n') {
    /* XXX TODO: There are signaling NaNs and quiet NaNs. */
    s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
    s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
    s++;
    sawnan = 1;
  } else
    return 0;

  if (sawinf) {
    numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
    numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
  } else if (sawnan) {
    numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
    numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;
  } else if (s < send) {
    /* we can have an optional exponent part */
    if (*s == 'e' || *s == 'E') {
      /* The only flag we keep is sign.  Blow away any "it's UV"  */
      numtype &= IS_NUMBER_NEG;
      numtype |= IS_NUMBER_NOT_INT;
      s++;
      if (s < send && (*s == '-' || *s == '+'))
        s++;
      if (s < send && isDIGIT(*s)) {
        do {
          s++;
        } while (s < send && isDIGIT(*s));
      }
      else
      return 0;
    }
  }
  while (s < send && isSPACE(*s))
    s++;
  if (s >= send)
    return numtype;
  if (len == 10 && memEQ(pv, "0 but true", 10)) {
    if (valuep)
      *valuep = 0;
    return IS_NUMBER_IN_UV;
  }
  return 0;
}
#endif
#endif

/*
 * The grok_* routines have been modified to use warn() instead of
 * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,
 * which is why the stack variable has been renamed to 'xdigit'.
 */

#ifndef grok_bin
#if defined(NEED_grok_bin)
static UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
static
#else
extern UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
#endif

#ifdef grok_bin
#  undef grok_bin
#endif
#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
#define Perl_grok_bin DPPP_(my_grok_bin)

#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
UV
DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
{
    const char *s = start;
    STRLEN len = *len_p;
    UV value = 0;
    NV value_nv = 0;

    const UV max_div_2 = UV_MAX / 2;
    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
    bool overflowed = FALSE;

    if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
        /* strip off leading b or 0b.
           for compatibility silently suffer "b" and "0b" as valid binary
           numbers. */
        if (len >= 1) {
            if (s[0] == 'b') {
                s++;
                len--;
            }
            else if (len >= 2 && s[0] == '0' && s[1] == 'b') {
                s+=2;
                len-=2;
            }
        }
    }

    for (; len-- && *s; s++) {
        char bit = *s;
        if (bit == '0' || bit == '1') {
            /* Write it in this wonky order with a goto to attempt to get the
               compiler to make the common case integer-only loop pretty tight.
               With gcc seems to be much straighter code than old scan_bin.  */
          redo:
            if (!overflowed) {
                if (value <= max_div_2) {
                    value = (value << 1) | (bit - '0');
                    continue;
                }
                /* Bah. We're just overflowed.  */
                warn("Integer overflow in binary number");
                overflowed = TRUE;
                value_nv = (NV) value;
            }
            value_nv *= 2.0;
	    /* If an NV has not enough bits in its mantissa to
	     * represent a UV this summing of small low-order numbers
	     * is a waste of time (because the NV cannot preserve
	     * the low-order bits anyway): we could just remember when
	     * did we overflow and in the end just multiply value_nv by the
	     * right amount. */
            value_nv += (NV)(bit - '0');
            continue;
        }
        if (bit == '_' && len && allow_underscores && (bit = s[1])
            && (bit == '0' || bit == '1'))
	    {
		--len;
		++s;
                goto redo;
	    }
        if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
            warn("Illegal binary digit '%c' ignored", *s);
        break;
    }

    if (   ( overflowed && value_nv > 4294967295.0)
#if UVSIZE > 4
	|| (!overflowed && value > 0xffffffff  )
#endif
	) {
	warn("Binary number > 0b11111111111111111111111111111111 non-portable");
    }
    *len_p = s - start;
    if (!overflowed) {
        *flags = 0;
        return value;
    }
    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
    if (result)
        *result = value_nv;
    return UV_MAX;
}
#endif
#endif

#ifndef grok_hex
#if defined(NEED_grok_hex)
static UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
static
#else
extern UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
#endif

#ifdef grok_hex
#  undef grok_hex
#endif
#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
#define Perl_grok_hex DPPP_(my_grok_hex)

#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
UV
DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
{
    const char *s = start;
    STRLEN len = *len_p;
    UV value = 0;
    NV value_nv = 0;

    const UV max_div_16 = UV_MAX / 16;
    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
    bool overflowed = FALSE;
    const char *xdigit;

    if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
        /* strip off leading x or 0x.
           for compatibility silently suffer "x" and "0x" as valid hex numbers.
        */
        if (len >= 1) {
            if (s[0] == 'x') {
                s++;
                len--;
            }
            else if (len >= 2 && s[0] == '0' && s[1] == 'x') {
                s+=2;
                len-=2;
            }
        }
    }

    for (; len-- && *s; s++) {
	xdigit = strchr((char *) PL_hexdigit, *s);
        if (xdigit) {
            /* Write it in this wonky order with a goto to attempt to get the
               compiler to make the common case integer-only loop pretty tight.
               With gcc seems to be much straighter code than old scan_hex.  */
          redo:
            if (!overflowed) {
                if (value <= max_div_16) {
                    value = (value << 4) | ((xdigit - PL_hexdigit) & 15);
                    continue;
                }
                warn("Integer overflow in hexadecimal number");
                overflowed = TRUE;
                value_nv = (NV) value;
            }
            value_nv *= 16.0;
	    /* If an NV has not enough bits in its mantissa to
	     * represent a UV this summing of small low-order numbers
	     * is a waste of time (because the NV cannot preserve
	     * the low-order bits anyway): we could just remember when
	     * did we overflow and in the end just multiply value_nv by the
	     * right amount of 16-tuples. */
            value_nv += (NV)((xdigit - PL_hexdigit) & 15);
            continue;
        }
        if (*s == '_' && len && allow_underscores && s[1]
		&& (xdigit = strchr((char *) PL_hexdigit, s[1])))
	    {
		--len;
		++s;
                goto redo;
	    }
        if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
            warn("Illegal hexadecimal digit '%c' ignored", *s);
        break;
    }

    if (   ( overflowed && value_nv > 4294967295.0)
#if UVSIZE > 4
	|| (!overflowed && value > 0xffffffff  )
#endif
	) {
	warn("Hexadecimal number > 0xffffffff non-portable");
    }
    *len_p = s - start;
    if (!overflowed) {
        *flags = 0;
        return value;
    }
    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
    if (result)
        *result = value_nv;
    return UV_MAX;
}
#endif
#endif

#ifndef grok_oct
#if defined(NEED_grok_oct)
static UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
static
#else
extern UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
#endif

#ifdef grok_oct
#  undef grok_oct
#endif
#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
#define Perl_grok_oct DPPP_(my_grok_oct)

#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
UV
DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
{
    const char *s = start;
    STRLEN len = *len_p;
    UV value = 0;
    NV value_nv = 0;

    const UV max_div_8 = UV_MAX / 8;
    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
    bool overflowed = FALSE;

    for (; len-- && *s; s++) {
         /* gcc 2.95 optimiser not smart enough to figure that this subtraction
            out front allows slicker code.  */
        int digit = *s - '0';
        if (digit >= 0 && digit <= 7) {
            /* Write it in this wonky order with a goto to attempt to get the
               compiler to make the common case integer-only loop pretty tight.
            */
          redo:
            if (!overflowed) {
                if (value <= max_div_8) {
                    value = (value << 3) | digit;
                    continue;
                }
                /* Bah. We're just overflowed.  */
                warn("Integer overflow in octal number");
                overflowed = TRUE;
                value_nv = (NV) value;
            }
            value_nv *= 8.0;
	    /* If an NV has not enough bits in its mantissa to
	     * represent a UV this summing of small low-order numbers
	     * is a waste of time (because the NV cannot preserve
	     * the low-order bits anyway): we could just remember when
	     * did we overflow and in the end just multiply value_nv by the
	     * right amount of 8-tuples. */
            value_nv += (NV)digit;
            continue;
        }
        if (digit == ('_' - '0') && len && allow_underscores
            && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
	    {
		--len;
		++s;
                goto redo;
	    }
        /* Allow \octal to work the DWIM way (that is, stop scanning
         * as soon as non-octal characters are seen, complain only iff
         * someone seems to want to use the digits eight and nine). */
        if (digit == 8 || digit == 9) {
            if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
                warn("Illegal octal digit '%c' ignored", *s);
        }
        break;
    }

    if (   ( overflowed && value_nv > 4294967295.0)
#if UVSIZE > 4
	|| (!overflowed && value > 0xffffffff  )
#endif
	) {
	warn("Octal number > 037777777777 non-portable");
    }
    *len_p = s - start;
    if (!overflowed) {
        *flags = 0;
        return value;
    }
    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
    if (result)
        *result = value_nv;
    return UV_MAX;
}
#endif
#endif

#ifdef NO_XSLOCKS
#  ifdef dJMPENV
#    define dXCPT             dJMPENV; int rEtV = 0
#    define XCPT_TRY_START    JMPENV_PUSH(rEtV); if (rEtV == 0)
#    define XCPT_TRY_END      JMPENV_POP;
#    define XCPT_CATCH        if (rEtV != 0)
#    define XCPT_RETHROW      JMPENV_JUMP(rEtV)
#  else
#    define dXCPT             Sigjmp_buf oldTOP; int rEtV = 0
#    define XCPT_TRY_START    Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)
#    define XCPT_TRY_END      Copy(oldTOP, top_env, 1, Sigjmp_buf);
#    define XCPT_CATCH        if (rEtV != 0)
#    define XCPT_RETHROW      Siglongjmp(top_env, rEtV)
#  endif
#endif

#endif /* _P_P_PORTABILITY_H_ */

/* End of File ppport.h */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           use 5.006_001;

=head1 NAME

Devel::DProf - a Perl code profiler

=head1 SYNOPSIS

	perl -d:DProf test.pl

=head1 DESCRIPTION

The Devel::DProf package is a Perl code profiler.  This will collect
information on the execution time of a Perl script and of the subs in that
script.  This information can be used to determine which subroutines are
using the most time and which subroutines are being called most often.  This
information can also be used to create an execution graph of the script,
showing subroutine relationships.

To profile a Perl script run the perl interpreter with the B<-d> debugging
switch.  The profiler uses the debugging hooks.  So to profile script
F<test.pl> the following command should be used:

	perl -d:DProf test.pl

When the script terminates (or when the output buffer is filled) the
profiler will dump the profile information to a file called
F<tmon.out>.  A tool like I<dprofpp> can be used to interpret the
information which is in that profile.  The following command will
print the top 15 subroutines which used the most time:

	dprofpp

To print an execution graph of the subroutines in the script use the
following command:

	dprofpp -T

Consult L<dprofpp> for other options.

=head1 PROFILE FORMAT

The old profile is a text file which looks like this:

	#fOrTyTwO
	$hz=100;
	$XS_VERSION='DProf 19970606';
	# All values are given in HZ
	$rrun_utime=2; $rrun_stime=0; $rrun_rtime=7
	PART2
	+ 26 28 566822884 DynaLoader::import
	- 26 28 566822884 DynaLoader::import
	+ 27 28 566822885 main::bar
	- 27 28 566822886 main::bar
	+ 27 28 566822886 main::baz
	+ 27 28 566822887 main::bar
	- 27 28 566822888 main::bar
	[....]

The first line is the magic number.  The second line is the hertz value, or
clock ticks, of the machine where the profile was collected.  The third line
is the name and version identifier of the tool which created the profile.
The fourth line is a comment.  The fifth line contains three variables
holding the user time, system time, and realtime of the process while it was
being profiled.  The sixth line indicates the beginning of the sub
entry/exit profile section.

The columns in B<PART2> are:

	sub entry(+)/exit(-) mark
	app's user time at sub entry/exit mark, in ticks
	app's system time at sub entry/exit mark, in ticks
	app's realtime at sub entry/exit mark, in ticks
	fully-qualified sub name, when possible

With newer perls another format is used, which may look like this:

        #fOrTyTwO
        $hz=10000;
        $XS_VERSION='DProf 19971213';
        # All values are given in HZ
        $over_utime=5917; $over_stime=0; $over_rtime=5917;
        $over_tests=10000;
        $rrun_utime=1284; $rrun_stime=0; $rrun_rtime=1284;
        $total_marks=6;

        PART2
        @ 406 0 406
        & 2 main bar
        + 2
        @ 456 0 456
        - 2
        @ 1 0 1
        & 3 main baz
        + 3
        @ 141 0 141
        + 2
        @ 141 0 141
        - 2
        @ 1 0 1
        & 4 main foo
        + 4
        @ 142 0 142
        + & Devel::DProf::write
        @ 5 0 5
        - & Devel::DProf::write

(with high value of $ENV{PERL_DPROF_TICKS}).  

New C<$over_*> values show the measured overhead of making $over_tests
calls to the profiler These values are used by the profiler to
subtract the overhead from the runtimes.

The lines starting with C<@> mark time passed from the previous C<@>
line.  The lines starting with C<&> introduce new subroutine I<id> and
show the package and the subroutine name of this id.  Lines starting
with C<+>, C<-> and C<*> mark entering and exit of subroutines by
I<id>s, and C<goto &subr>.

The I<old-style> C<+>- and C<->-lines are used to mark the overhead
related to writing to profiler-output file.

=head1 AUTOLOAD

When Devel::DProf finds a call to an C<&AUTOLOAD> subroutine it looks at the
C<$AUTOLOAD> variable to find the real name of the sub being called.  See
L<perlsub/"Autoloading">.

=head1 ENVIRONMENT

C<PERL_DPROF_BUFFER> sets size of output buffer in words.  Defaults to 2**14.

C<PERL_DPROF_TICKS> sets number of ticks per second on some systems where
a replacement for times() is used.  Defaults to the value of C<HZ> macro.

C<PERL_DPROF_OUT_FILE_NAME> sets the name of the output file.  If not set,
defaults to tmon.out.

=head1 BUGS

Builtin functions cannot be measured by Devel::DProf.

With a newer Perl DProf relies on the fact that the numeric slot of
$DB::sub contains an address of a subroutine.  Excessive manipulation
of this variable may overwrite this slot, as in

  $DB::sub = 'current_sub';
  ...
  $addr = $DB::sub + 0;

will set this numeric slot to numeric value of the string
C<current_sub>, i.e., to C<0>.  This will cause a segfault on the exit
from this subroutine.  Note that the first assignment above does not
change the numeric slot (it will I<mark> it as invalid, but will not
write over it).

Another problem is that if a subroutine exits using goto(LABEL),
last(LABEL) or next(LABEL) then perl may crash or Devel::DProf will die
with the error:

   panic: Devel::DProf inconsistent subroutine return

For example, this code will break under Devel::DProf:

   sub foo {
     last FOO;
   }
   FOO: {
     foo();
   }

A pattern like this is used by Test::More's skip() function, for
example.  See L<perldiag> for more details.

Mail bug reports and feature requests to the perl5-porters mailing list at
F<E<lt>perl5-porters@perl.orgE<gt>>.

=head1 SEE ALSO

L<perl>, L<dprofpp>, times(2)

=cut

# This sub is needed for calibration.
package Devel::DProf;

sub NONESUCH_noxs {
	return $Devel::DProf::VERSION;
}

package DB;

#
# As of perl5.003_20, &DB::sub stub is not needed (some versions
# even had problems if stub was redefined with XS version).
#

# disable DB single-stepping
BEGIN { $single = 0; }

# This sub is needed during startup.
sub DB { 
#	print "nonXS DBDB\n";
}

use XSLoader ();

$Devel::DProf::VERSION = '20050603.00';  # this version not authorized by
				         # Dean Roehrich. See "Changes" file.

XSLoader::load 'Devel::DProf', $Devel::DProf::VERSION;

1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # Devel::Peek - A data debugging tool for the XS programmer
# The documentation is after the __END__

package Devel::Peek;

$VERSION = '1.03';
$XS_VERSION = $VERSION;
$VERSION = eval $VERSION;

require Exporter;
use XSLoader ();

@ISA = qw(Exporter);
@EXPORT = qw(Dump mstat DeadCode DumpArray DumpWithOP DumpProg
	     fill_mstats mstats_fillhash mstats2hash runops_debug debug_flags);
@EXPORT_OK = qw(SvREFCNT SvREFCNT_inc SvREFCNT_dec CvGV);
%EXPORT_TAGS = ('ALL' => [@EXPORT, @EXPORT_OK]);

XSLoader::load 'Devel::Peek';

sub import {
  my $c = shift;
  my $ops_rx = qr/^:opd(=[stP]*)?\b/;
  my @db = grep m/$ops_rx/, @_;
  @_ = grep !m/$ops_rx/, @_;
  if (@db) {
    die "Too many :opd options" if @db > 1;
    runops_debug(1);
    my $flags = ($db[0] =~ m/$ops_rx/ and $1);
    $flags = 'st' unless defined $flags;
    my $f = 0;
    $f |= 2  if $flags =~ /s/;
    $f |= 8  if $flags =~ /t/;
    $f |= 64 if $flags =~ /P/;
    $^D |= $f if $f;
  }
  unshift @_, $c;
  goto &Exporter::import;
}

sub DumpWithOP ($;$) {
   local($Devel::Peek::dump_ops)=1;
   my $depth = @_ > 1 ? $_[1] : 4 ;
   Dump($_[0],$depth);
}

$D_flags = 'psltocPmfrxuLHXDSTR';

sub debug_flags (;$) {
  my $out = "";
  for my $i (0 .. length($D_flags)-1) {
    $out .= substr $D_flags, $i, 1 if $^D & (1<<$i);
  }
  my $arg = shift;
  my $num = $arg;
  if (defined $arg and $arg =~ /\D/) {
    die "unknown flags in debug_flags()" if $arg =~ /[^-$D_flags]/;
    my ($on,$off) = split /-/, "$arg-";
    $num = $^D;
    $num |=  (1<<index($D_flags, $_)) for split //, $on;
    $num &= ~(1<<index($D_flags, $_)) for split //, $off;
  }
  $^D = $num if defined $arg;
  $out
}

1;
__END__

=head1 NAME

Devel::Peek - A data debugging tool for the XS programmer

=head1 SYNOPSIS

        use Devel::Peek;
        Dump( $a );
        Dump( $a, 5 );
        DumpArray( 5, $a, $b, ... );
	mstat "Point 5";

        use Devel::Peek ':opd=st';

=head1 DESCRIPTION

Devel::Peek contains functions which allows raw Perl datatypes to be
manipulated from a Perl script.  This is used by those who do XS programming
to check that the data they are sending from C to Perl looks as they think
it should look.  The trick, then, is to know what the raw datatype is
supposed to look like when it gets to Perl.  This document offers some tips
and hints to describe good and bad raw data.

It is very possible that this document will fall far short of being useful
to the casual reader.  The reader is expected to understand the material in
the first few sections of L<perlguts>.

Devel::Peek supplies a C<Dump()> function which can dump a raw Perl
datatype, and C<mstat("marker")> function to report on memory usage
(if perl is compiled with corresponding option).  The function
DeadCode() provides statistics on the data "frozen" into inactive
C<CV>.  Devel::Peek also supplies C<SvREFCNT()>, C<SvREFCNT_inc()>, and
C<SvREFCNT_dec()> which can query, increment, and decrement reference
counts on SVs.  This document will take a passive, and safe, approach
to data debugging and for that it will describe only the C<Dump()>
function.

Function C<DumpArray()> allows dumping of multiple values (useful when you
need to analyze returns of functions).

The global variable $Devel::Peek::pv_limit can be set to limit the
number of character printed in various string values.  Setting it to 0
means no limit.

If C<use Devel::Peek> directive has a C<:opd=FLAGS> argument,
this switches on debugging of opcode dispatch.  C<FLAGS> should be a
combination of C<s>, C<t>, and C<P> (see B<-D> flags in L<perlrun>).
C<:opd> is a shortcut for C<:opd=st>.

=head2 Runtime debugging

C<CvGV($cv)> return one of the globs associated to a subroutine reference $cv.

debug_flags() returns a string representation of C<$^D> (similar to
what is allowed for B<-D> flag).  When called with a numeric argument,
sets $^D to the corresponding value.  When called with an argument of
the form C<"flags-flags">, set on/off bits of C<$^D> corresponding to
letters before/after C<->.  (The returned value is for C<$^D> before
the modification.)

runops_debug() returns true if the current I<opcode dispatcher> is the
debugging one.  When called with an argument, switches to debugging or
non-debugging dispatcher depending on the argument (active for
newly-entered subs/etc only).  (The returned value is for the dispatcher before the modification.)

=head2 Memory footprint debugging

When perl is compiled with support for memory footprint debugging
(default with Perl's malloc()), Devel::Peek provides an access to this API.

Use mstat() function to emit a memory state statistic to the terminal.
For more information on the format of output of mstat() see
L<perldebguts/Using C<$ENV{PERL_DEBUG_MSTATS}>>.

Three additional functions allow access to this statistic from Perl.
First, use C<mstats_fillhash(%hash)> to get the information contained
in the output of mstat() into %hash. The field of this hash are

  minbucket nbuckets sbrk_good sbrk_slack sbrked_remains sbrks start_slack
  topbucket topbucket_ev topbucket_odd total total_chain total_sbrk totfree

Two additional fields C<free>, C<used> contain array references which
provide per-bucket count of free and used chunks.  Two other fields
C<mem_size>, C<available_size> contain array references which provide
the information about the allocated size and usable size of chunks in
each bucket.  Again, see L<perldebguts/Using C<$ENV{PERL_DEBUG_MSTATS}>>
for details.

Keep in mind that only the first several "odd-numbered" buckets are
used, so the information on size of the "odd-numbered" buckets which are
not used is probably meaningless.

The information in

 mem_size available_size minbucket nbuckets

is the property of a particular build of perl, and does not depend on
the current process.  If you do not provide the optional argument to
the functions mstats_fillhash(), fill_mstats(), mstats2hash(), then
the information in fields C<mem_size>, C<available_size> is not
updated.

C<fill_mstats($buf)> is a much cheaper call (both speedwise and
memory-wise) which collects the statistic into $buf in
machine-readable form.  At a later moment you may need to call
C<mstats2hash($buf, %hash)> to use this information to fill %hash.

All three APIs C<fill_mstats($buf)>, C<mstats_fillhash(%hash)>, and
C<mstats2hash($buf, %hash)> are designed to allocate no memory if used
I<the second time> on the same $buf and/or %hash.

So, if you want to collect memory info in a cycle, you may call

  $#buf = 999;
  fill_mstats($_) for @buf;
  mstats_fillhash(%report, 1);		# Static info too

  foreach (@buf) {
    # Do something...
    fill_mstats $_;			# Collect statistic
  }
  foreach (@buf) {
    mstats2hash($_, %report);		# Preserve static info
    # Do something with %report
  }

=head1 EXAMPLES

The following examples don't attempt to show everything as that would be a
monumental task, and, frankly, we don't want this manpage to be an internals
document for Perl.  The examples do demonstrate some basics of the raw Perl
datatypes, and should suffice to get most determined people on their way.
There are no guidewires or safety nets, nor blazed trails, so be prepared to
travel alone from this point and on and, if at all possible, don't fall into
the quicksand (it's bad for business).

Oh, one final bit of advice: take L<perlguts> with you.  When you return we
expect to see it well-thumbed.

=head2 A simple scalar string

Let's begin by looking a simple scalar which is holding a string.

        use Devel::Peek;
        $a = "hello";
        Dump $a;

The output:

        SV = PVIV(0xbc288)
          REFCNT = 1
          FLAGS = (POK,pPOK)
          IV = 0
          PV = 0xb2048 "hello"\0
          CUR = 5
          LEN = 6

This says C<$a> is an SV, a scalar.  The scalar is a PVIV, a string.
Its reference count is 1.  It has the C<POK> flag set, meaning its
current PV field is valid.  Because POK is set we look at the PV item
to see what is in the scalar.  The \0 at the end indicate that this
PV is properly NUL-terminated.
If the FLAGS had been IOK we would look
at the IV item.  CUR indicates the number of characters in the PV.
LEN indicates the number of bytes requested for the PV (one more than
CUR, in this case, because LEN includes an extra byte for the
end-of-string marker).

=head2 A simple scalar number

If the scalar contains a number the raw SV will be leaner.

        use Devel::Peek;
        $a = 42;
        Dump $a;

The output:

        SV = IV(0xbc818)
          REFCNT = 1
          FLAGS = (IOK,pIOK)
          IV = 42

This says C<$a> is an SV, a scalar.  The scalar is an IV, a number.  Its
reference count is 1.  It has the C<IOK> flag set, meaning it is currently
being evaluated as a number.  Because IOK is set we look at the IV item to
see what is in the scalar.

=head2 A simple scalar with an extra reference

If the scalar from the previous example had an extra reference:

        use Devel::Peek;
        $a = 42;
        $b = \$a;
        Dump $a;

The output:

        SV = IV(0xbe860)
          REFCNT = 2
          FLAGS = (IOK,pIOK)
          IV = 42

Notice that this example differs from the previous example only in its
reference count.  Compare this to the next example, where we dump C<$b>
instead of C<$a>.

=head2 A reference to a simple scalar

This shows what a reference looks like when it references a simple scalar.

        use Devel::Peek;
        $a = 42;
        $b = \$a;
        Dump $b;

The output:

        SV = RV(0xf041c)
          REFCNT = 1
          FLAGS = (ROK)
          RV = 0xbab08
        SV = IV(0xbe860)
          REFCNT = 2
          FLAGS = (IOK,pIOK)
          IV = 42

Starting from the top, this says C<$b> is an SV.  The scalar is an RV, a
reference.  It has the C<ROK> flag set, meaning it is a reference.  Because
ROK is set we have an RV item rather than an IV or PV.  Notice that Dump
follows the reference and shows us what C<$b> was referencing.  We see the
same C<$a> that we found in the previous example.

Note that the value of C<RV> coincides with the numbers we see when we
stringify $b. The addresses inside RV() and IV() are addresses of
C<X***> structure which holds the current state of an C<SV>. This
address may change during lifetime of an SV.

=head2 A reference to an array

This shows what a reference to an array looks like.

        use Devel::Peek;
        $a = [42];
        Dump $a;

The output:

        SV = RV(0xf041c)
          REFCNT = 1
          FLAGS = (ROK)
          RV = 0xb2850
        SV = PVAV(0xbd448)
          REFCNT = 1
          FLAGS = ()
          IV = 0
          NV = 0
          ARRAY = 0xb2048
          ALLOC = 0xb2048
          FILL = 0
          MAX = 0
          ARYLEN = 0x0
          FLAGS = (REAL)
        Elt No. 0 0xb5658
        SV = IV(0xbe860)
          REFCNT = 1
          FLAGS = (IOK,pIOK)
          IV = 42

This says C<$a> is an SV and that it is an RV.  That RV points to
another SV which is a PVAV, an array.  The array has one element,
element zero, which is another SV. The field C<FILL> above indicates
the last element in the array, similar to C<$#$a>.

If C<$a> pointed to an array of two elements then we would see the
following.

        use Devel::Peek 'Dump';
        $a = [42,24];
        Dump $a;

The output:

        SV = RV(0xf041c)
          REFCNT = 1
          FLAGS = (ROK)
          RV = 0xb2850
        SV = PVAV(0xbd448)
          REFCNT = 1
          FLAGS = ()
          IV = 0
          NV = 0
          ARRAY = 0xb2048
          ALLOC = 0xb2048
          FILL = 0
          MAX = 0
          ARYLEN = 0x0
          FLAGS = (REAL)
        Elt No. 0  0xb5658
        SV = IV(0xbe860)
          REFCNT = 1
          FLAGS = (IOK,pIOK)
          IV = 42
        Elt No. 1  0xb5680
        SV = IV(0xbe818)
          REFCNT = 1
          FLAGS = (IOK,pIOK)
          IV = 24

Note that C<Dump> will not report I<all> the elements in the array,
only several first (depending on how deep it already went into the
report tree).

=head2 A reference to a hash

The following shows the raw form of a reference to a hash.

        use Devel::Peek;
        $a = {hello=>42};
        Dump $a;

The output:

	SV = RV(0x8177858) at 0x816a618
	  REFCNT = 1
	  FLAGS = (ROK)
	  RV = 0x814fc10
	  SV = PVHV(0x8167768) at 0x814fc10
	    REFCNT = 1
	    FLAGS = (SHAREKEYS)
	    IV = 1
	    NV = 0
	    ARRAY = 0x816c5b8  (0:7, 1:1)
	    hash quality = 100.0%
	    KEYS = 1
	    FILL = 1
	    MAX = 7
	    RITER = -1
	    EITER = 0x0
	    Elt "hello" HASH = 0xc8fd181b
	    SV = IV(0x816c030) at 0x814fcf4
	      REFCNT = 1
	      FLAGS = (IOK,pIOK)
	      IV = 42

This shows C<$a> is a reference pointing to an SV.  That SV is a PVHV, a
hash. Fields RITER and EITER are used by C<L<each>>.

The "quality" of a hash is defined as the total number of comparisons needed
to access every element once, relative to the expected number needed for a
random hash. The value can go over 100%.

The total number of comparisons is equal to the sum of the squares of the
number of entries in each bucket.  For a random hash of C<<n>> keys into
C<<k>> buckets, the expected value is:

		n + n(n-1)/2k

=head2 Dumping a large array or hash

The C<Dump()> function, by default, dumps up to 4 elements from a
toplevel array or hash.  This number can be increased by supplying a
second argument to the function.

        use Devel::Peek;
        $a = [10,11,12,13,14];
        Dump $a;

Notice that C<Dump()> prints only elements 10 through 13 in the above code.
The following code will print all of the elements.

        use Devel::Peek 'Dump';
        $a = [10,11,12,13,14];
        Dump $a, 5;

=head2 A reference to an SV which holds a C pointer

This is what you really need to know as an XS programmer, of course.  When
an XSUB returns a pointer to a C structure that pointer is stored in an SV
and a reference to that SV is placed on the XSUB stack.  So the output from
an XSUB which uses something like the T_PTROBJ map might look something like
this:

        SV = RV(0xf381c)
          REFCNT = 1
          FLAGS = (ROK)
          RV = 0xb8ad8
        SV = PVMG(0xbb3c8)
          REFCNT = 1
          FLAGS = (OBJECT,IOK,pIOK)
          IV = 729160
          NV = 0
          PV = 0
          STASH = 0xc1d10       "CookBookB::Opaque"

This shows that we have an SV which is an RV.  That RV points at another
SV.  In this case that second SV is a PVMG, a blessed scalar.  Because it is
blessed it has the C<OBJECT> flag set.  Note that an SV which holds a C
pointer also has the C<IOK> flag set.  The C<STASH> is set to the package
name which this SV was blessed into.

The output from an XSUB which uses something like the T_PTRREF map, which
doesn't bless the object, might look something like this:

        SV = RV(0xf381c)
          REFCNT = 1
          FLAGS = (ROK)
          RV = 0xb8ad8
        SV = PVMG(0xbb3c8)
          REFCNT = 1
          FLAGS = (IOK,pIOK)
          IV = 729160
          NV = 0
          PV = 0

=head2 A reference to a subroutine

Looks like this:

	SV = RV(0x798ec)
	  REFCNT = 1
	  FLAGS = (TEMP,ROK)
	  RV = 0x1d453c
	SV = PVCV(0x1c768c)
	  REFCNT = 2
	  FLAGS = ()
	  IV = 0
	  NV = 0
	  COMP_STASH = 0x31068  "main"
	  START = 0xb20e0
	  ROOT = 0xbece0
	  XSUB = 0x0
	  XSUBANY = 0
	  GVGV::GV = 0x1d44e8   "MY" :: "top_targets"
	  FILE = "(eval 5)"
	  DEPTH = 0
	  PADLIST = 0x1c9338

This shows that 

=over 4

=item *

the subroutine is not an XSUB (since C<START> and C<ROOT> are
non-zero, and C<XSUB> is zero);

=item *

that it was compiled in the package C<main>;

=item *

under the name C<MY::top_targets>; 

=item *

inside a 5th eval in the program;

=item *

it is not currently executed (see C<DEPTH>);

=item *

it has no prototype (C<PROTOTYPE> field is missing).

=back

=head1 EXPORTS

C<Dump>, C<mstat>, C<DeadCode>, C<DumpArray>, C<DumpWithOP> and
C<DumpProg>, C<fill_mstats>, C<mstats_fillhash>, C<mstats2hash> by
default. Additionally available C<SvREFCNT>, C<SvREFCNT_inc> and
C<SvREFCNT_dec>.

=head1 BUGS

Readers have been known to skip important parts of L<perlguts>, causing much
frustration for all.

=head1 AUTHOR

Ilya Zakharevich	ilya@math.ohio-state.edu

Copyright (c) 1995-98 Ilya Zakharevich. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

Author of this software makes no claim whatsoever about suitability,
reliability, edability, editability or usability of this product, and
should not be kept liable for any damage resulting from the use of
it. If you can use it, you are in luck, if not, I should not be kept
responsible. Keep a handy copy of your backup tape at hand.

=head1 SEE ALSO

L<perlguts>, and L<perlguts>, again.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               JE  .   'E  ..  KE MD5.pm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          package Digest::MD5;

use strict;
use vars qw($VERSION @ISA @EXPORT_OK);

$VERSION = '2.36';  # $Date: 2005/11/30 13:46:47 $

require Exporter;
*import = \&Exporter::import;
@EXPORT_OK = qw(md5 md5_hex md5_base64);

eval {
    require Digest::base;
    push(@ISA, 'Digest::base');
};
if ($@) {
    my $err = $@;
    *add_bits = sub { die $err };
}


eval {
    require XSLoader;
    XSLoader::load('Digest::MD5', $VERSION);
};
if ($@) {
    my $olderr = $@;
    eval {
	# Try to load the pure perl version
	require Digest::Perl::MD5;

	Digest::Perl::MD5->import(qw(md5 md5_hex md5_base64));
	push(@ISA, "Digest::Perl::MD5");  # make OO interface work
    };
    if ($@) {
	# restore the original error
	die $olderr;
    }
}
else {
    *reset = \&new;
}

1;
__END__

=head1 NAME

Digest::MD5 - Perl interface to the MD5 Algorithm

=head1 SYNOPSIS

 # Functional style
 use Digest::MD5 qw(md5 md5_hex md5_base64);

 $digest = md5($data);
 $digest = md5_hex($data);
 $digest = md5_base64($data);

 # OO style
 use Digest::MD5;

 $ctx = Digest::MD5->new;

 $ctx->add($data);
 $ctx->addfile(*FILE);

 $digest = $ctx->digest;
 $digest = $ctx->hexdigest;
 $digest = $ctx->b64digest;

=head1 DESCRIPTION

The C<Digest::MD5> module allows you to use the RSA Data Security
Inc. MD5 Message Digest algorithm from within Perl programs.  The
algorithm takes as input a message of arbitrary length and produces as
output a 128-bit "fingerprint" or "message digest" of the input.

Note that the MD5 algorithm is not as strong as it used to be.  It has
since 2005 been easy to generate different messages that produce the
same MD5 digest.  It still seems hard to generate messages that
produce a given digest, but it is probably wise to move to stronger
algorithms for applications that depend on the digest to uniquely identify
a message.

The C<Digest::MD5> module provide a procedural interface for simple
use, as well as an object oriented interface that can handle messages
of arbitrary length and which can read files directly.

=head1 FUNCTIONS

The following functions are provided by the C<Digest::MD5> module.
None of these functions are exported by default.

=over 4

=item md5($data,...)

This function will concatenate all arguments, calculate the MD5 digest
of this "message", and return it in binary form.  The returned string
will be 16 bytes long.

The result of md5("a", "b", "c") will be exactly the same as the
result of md5("abc").

=item md5_hex($data,...)

Same as md5(), but will return the digest in hexadecimal form. The
length of the returned string will be 32 and it will only contain
characters from this set: '0'..'9' and 'a'..'f'.

=item md5_base64($data,...)

Same as md5(), but will return the digest as a base64 encoded string.
The length of the returned string will be 22 and it will only contain
characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+' and
'/'.

Note that the base64 encoded string returned is not padded to be a
multiple of 4 bytes long.  If you want interoperability with other
base64 encoded md5 digests you might want to append the redundant
string "==" to the result.

=back

=head1 METHODS

The object oriented interface to C<Digest::MD5> is described in this
section.  After a C<Digest::MD5> object has been created, you will add
data to it and finally ask for the digest in a suitable format.  A
single object can be used to calculate multiple digests.

The following methods are provided:

=over 4

=item $md5 = Digest::MD5->new

The constructor returns a new C<Digest::MD5> object which encapsulate
the state of the MD5 message-digest algorithm.

If called as an instance method (i.e. $md5->new) it will just reset the
state the object to the state of a newly created object.  No new
object is created in this case.

=item $md5->reset

This is just an alias for $md5->new.

=item $md5->clone

This a copy of the $md5 object. It is useful when you do not want to
destroy the digests state, but need an intermediate value of the
digest, e.g. when calculating digests iteratively on a continuous data
stream.  Example:

    my $md5 = Digest::MD5->new;
    while (<>) {
	$md5->add($_);
	print "Line $.: ", $md5->clone->hexdigest, "\n";
    }

=item $md5->add($data,...)

The $data provided as argument are appended to the message we
calculate the digest for.  The return value is the $md5 object itself.

All these lines will have the same effect on the state of the $md5
object:

    $md5->add("a"); $md5->add("b"); $md5->add("c");
    $md5->add("a")->add("b")->add("c");
    $md5->add("a", "b", "c");
    $md5->add("abc");

=item $md5->addfile($io_handle)

The $io_handle will be read until EOF and its content appended to the
message we calculate the digest for.  The return value is the $md5
object itself.

The addfile() method will croak() if it fails reading data for some
reason.  If it croaks it is unpredictable what the state of the $md5
object will be in. The addfile() method might have been able to read
the file partially before it failed.  It is probably wise to discard
or reset the $md5 object if this occurs.

In most cases you want to make sure that the $io_handle is in
C<binmode> before you pass it as argument to the addfile() method.

=item $md5->add_bits($data, $nbits)

=item $md5->add_bits($bitstring)

Since the MD5 algorithm is byte oriented you might only add bits as
multiples of 8, so you probably want to just use add() instead.  The
add_bits() method is provided for compatibility with other digest
implementations.  See L<Digest> for description of the arguments
that add_bits() take.

=item $md5->digest

Return the binary digest for the message.  The returned string will be
16 bytes long.

Note that the C<digest> operation is effectively a destructive,
read-once operation. Once it has been performed, the C<Digest::MD5>
object is automatically C<reset> and can be used to calculate another
digest value.  Call $md5->clone->digest if you want to calculate the
digest without resetting the digest state.

=item $md5->hexdigest

Same as $md5->digest, but will return the digest in hexadecimal
form. The length of the returned string will be 32 and it will only
contain characters from this set: '0'..'9' and 'a'..'f'.

=item $md5->b64digest

Same as $md5->digest, but will return the digest as a base64 encoded
string.  The length of the returned string will be 22 and it will only
contain characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+'
and '/'.


The base64 encoded string returned is not padded to be a multiple of 4
bytes long.  If you want interoperability with other base64 encoded
md5 digests you might want to append the string "==" to the result.

=back


=head1 EXAMPLES

The simplest way to use this library is to import the md5_hex()
function (or one of its cousins):

    use Digest::MD5 qw(md5_hex);
    print "Digest is ", md5_hex("foobarbaz"), "\n";

The above example would print out the message:

    Digest is 6df23dc03f9b54cc38a0fc1483df6e21

The same checksum can also be calculated in OO style:

    use Digest::MD5;
    
    $md5 = Digest::MD5->new;
    $md5->add('foo', 'bar');
    $md5->add('baz');
    $digest = $md5->hexdigest;
    
    print "Digest is $digest\n";

With OO style you can break the message arbitrary.  This means that we
are no longer limited to have space for the whole message in memory, i.e.
we can handle messages of any size.

This is useful when calculating checksum for files:

    use Digest::MD5;

    my $file = shift || "/etc/passwd";
    open(FILE, $file) or die "Can't open '$file': $!";
    binmode(FILE);

    $md5 = Digest::MD5->new;
    while (<FILE>) {
        $md5->add($_);
    }
    close(FILE);
    print $md5->b64digest, " $file\n";

Or we can use the addfile method for more efficient reading of
the file:

    use Digest::MD5;

    my $file = shift || "/etc/passwd";
    open(FILE, $file) or die "Can't open '$file': $!";
    binmode(FILE);

    print Digest::MD5->new->addfile(*FILE)->hexdigest, " $file\n";

Perl 5.8 support Unicode characters in strings.  Since the MD5
algorithm is only defined for strings of bytes, it can not be used on
strings that contains chars with ordinal number above 255.  The MD5
functions and methods will croak if you try to feed them such input
data:

    use Digest::MD5 qw(md5_hex);

    my $str = "abc\x{300}";
    print md5_hex($str), "\n";  # croaks
    # Wide character in subroutine entry

What you can do is calculate the MD5 checksum of the UTF-8
representation of such strings.  This is achieved by filtering the
string through encode_utf8() function:

    use Digest::MD5 qw(md5_hex);
    use Encode qw(encode_utf8);

    my $str = "abc\x{300}";
    print md5_hex(encode_utf8($str)), "\n";
    # 8c2d46911f3f5a326455f0ed7a8ed3b3

=head1 SEE ALSO

L<Digest>,
L<Digest::MD2>,
L<Digest::SHA1>,
L<Digest::HMAC>

L<md5sum(1)>

RFC 1321

http://en.wikipedia.org/wiki/MD5

The paper "How to Break MD5 and Other Hash Functions" by Xiaoyun Wang
and Hongbo Yu.

=head1 COPYRIGHT

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

 Copyright 1998-2003 Gisle Aas.
 Copyright 1995-1996 Neil Winton.
 Copyright 1991-1992 RSA Data Security, Inc.

The MD5 algorithm is defined in RFC 1321. This implementation is
derived from the reference C code in RFC 1321 which is covered by
the following copyright statement:

=over 4

=item

Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.

License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.

License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.

RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.

These notices must be retained in any copies of any part of this
documentation and/or software.

=back

This copyright does not prohibit distribution of any version of Perl
containing this extension under the terms of the GNU or Artistic
licenses.

=head1 AUTHORS

The original C<MD5> interface was written by Neil Winton
(C<N.Winton@axion.bt.co.uk>).

The C<Digest::MD5> module is written by Gisle Aas <gisle@ActiveState.com>.

=cut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 