aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJeff Johnston <jjohnstn@redhat.com>2002-09-20 20:13:11 +0000
committerJeff Johnston <jjohnstn@redhat.com>2002-09-20 20:13:11 +0000
commit1525d127da1d0f5eb197805e6c8e0c27eda9d520 (patch)
treebc47b5ede8ddcfc65d84aa39bfdc5b5f3dd43c89
parentda25e61f5998b4ec3e72486cdcd84f6220253ac8 (diff)
downloadnewlib-1525d127da1d0f5eb197805e6c8e0c27eda9d520.zip
newlib-1525d127da1d0f5eb197805e6c8e0c27eda9d520.tar.gz
newlib-1525d127da1d0f5eb197805e6c8e0c27eda9d520.tar.bz2
2002-09-20 Jeff Johnston <jjohnstn@redhat.com>
* libc/ctype/Makefile.am: Add new files. * libc/ctype/Makefile.in: Regenerated. * libc/ctype/ctype.tex: Add new iswxxxx, towxxxx, wctype, and wctrans functions to documentation index. * libc/ctype/iswalnum.c: New file. * libc/ctype/iswalpha.c: Ditto. * libc/ctype/iswblank.c: Ditto. * libc/ctype/iswcntrl.c: Ditto. * libc/ctype/iswctype.c: Ditto. * libc/ctype/iswdigit.c: Ditto. * libc/ctype/iswgraph.c: Ditto. * libc/ctype/iswlower.c: Ditto. * libc/ctype/iswprint.c: Ditto. * libc/ctype/iswpunct.c: Ditto. * libc/ctype/iswspace.c: Ditto. * libc/ctype/iswupper.c: Ditto. * libc/ctype/iswxdigit.c: Ditto. * libc/ctype/jp2uc.c: Ditto. * libc/ctype/jp2uc.h: Ditto. * libc/ctype/local.h: Ditto. * libc/ctype/towctrans.c: Ditto. * libc/ctype/towlower.c: Ditto. * libc/ctype/towupper.c: Ditto. * libc/ctype/utf8alpha.h: Ditto. * libc/ctype/utf8print.h: Ditto. * libc/ctype/utf8punct.h: Ditto. * libc/ctype/wctrans.c: Ditto. * libc/ctype/wctype.c: Ditto. * libc/locale/locale.c (__lc_ctype): New external array to replace static lc_ctype array. * libc/stdlib/mbtowc_r.c: Use __lc_ctype to check current lc_ctype rather than reentrancy structure's _current_locale field. * libc/stdlib/wctomb_r.c: Ditto.
-rw-r--r--newlib/ChangeLog36
-rw-r--r--newlib/libc/ctype/Makefile.am41
-rw-r--r--newlib/libc/ctype/Makefile.in41
-rw-r--r--newlib/libc/ctype/ctype.tex68
-rw-r--r--newlib/libc/ctype/iswalnum.c37
-rw-r--r--newlib/libc/ctype/iswalpha.c342
-rw-r--r--newlib/libc/ctype/iswblank.c105
-rw-r--r--newlib/libc/ctype/iswcntrl.c104
-rw-r--r--newlib/libc/ctype/iswctype.c70
-rw-r--r--newlib/libc/ctype/iswdigit.c37
-rw-r--r--newlib/libc/ctype/iswgraph.c66
-rw-r--r--newlib/libc/ctype/iswlower.c38
-rw-r--r--newlib/libc/ctype/iswprint.c397
-rw-r--r--newlib/libc/ctype/iswpunct.c332
-rw-r--r--newlib/libc/ctype/iswspace.c106
-rw-r--r--newlib/libc/ctype/iswupper.c38
-rw-r--r--newlib/libc/ctype/iswxdigit.c39
-rw-r--r--newlib/libc/ctype/jp2uc.c86
-rw-r--r--newlib/libc/ctype/jp2uc.h6883
-rw-r--r--newlib/libc/ctype/local.h32
-rw-r--r--newlib/libc/ctype/towctrans.c97
-rw-r--r--newlib/libc/ctype/towlower.c478
-rw-r--r--newlib/libc/ctype/towupper.c505
-rw-r--r--newlib/libc/ctype/utf8alpha.h235
-rw-r--r--newlib/libc/ctype/utf8print.h282
-rw-r--r--newlib/libc/ctype/utf8punct.h201
-rw-r--r--newlib/libc/ctype/wctrans.c94
-rw-r--r--newlib/libc/ctype/wctype.c138
-rw-r--r--newlib/libc/locale/locale.c12
-rw-r--r--newlib/libc/stdlib/mbtowc_r.c14
-rw-r--r--newlib/libc/stdlib/wctomb_r.c12
31 files changed, 10945 insertions, 21 deletions
diff --git a/newlib/ChangeLog b/newlib/ChangeLog
index 19243b2..1da5734 100644
--- a/newlib/ChangeLog
+++ b/newlib/ChangeLog
@@ -1,5 +1,41 @@
2002-09-20 Jeff Johnston <jjohnstn@redhat.com>
+ * libc/ctype/Makefile.am: Add new files.
+ * libc/ctype/Makefile.in: Regenerated.
+ * libc/ctype/ctype.tex: Add new iswxxxx, towxxxx, wctype,
+ and wctrans functions to documentation index.
+ * libc/ctype/iswalnum.c: New file.
+ * libc/ctype/iswalpha.c: Ditto.
+ * libc/ctype/iswblank.c: Ditto.
+ * libc/ctype/iswcntrl.c: Ditto.
+ * libc/ctype/iswctype.c: Ditto.
+ * libc/ctype/iswdigit.c: Ditto.
+ * libc/ctype/iswgraph.c: Ditto.
+ * libc/ctype/iswlower.c: Ditto.
+ * libc/ctype/iswprint.c: Ditto.
+ * libc/ctype/iswpunct.c: Ditto.
+ * libc/ctype/iswspace.c: Ditto.
+ * libc/ctype/iswupper.c: Ditto.
+ * libc/ctype/iswxdigit.c: Ditto.
+ * libc/ctype/jp2uc.c: Ditto.
+ * libc/ctype/jp2uc.h: Ditto.
+ * libc/ctype/local.h: Ditto.
+ * libc/ctype/towctrans.c: Ditto.
+ * libc/ctype/towlower.c: Ditto.
+ * libc/ctype/towupper.c: Ditto.
+ * libc/ctype/utf8alpha.h: Ditto.
+ * libc/ctype/utf8print.h: Ditto.
+ * libc/ctype/utf8punct.h: Ditto.
+ * libc/ctype/wctrans.c: Ditto.
+ * libc/ctype/wctype.c: Ditto.
+ * libc/locale/locale.c (__lc_ctype): New external array to
+ replace static lc_ctype array.
+ * libc/stdlib/mbtowc_r.c: Use __lc_ctype to check current lc_ctype
+ rather than reentrancy structure's _current_locale field.
+ * libc/stdlib/wctomb_r.c: Ditto.
+
+2002-09-20 Jeff Johnston <jjohnstn@redhat.com>
+
* configure.host: Minor comment and formatting changes.
* libc/Makefile.am: Add libc_la_DEPENDENCIES.
* libc/Makefile.in: Regenerated.
diff --git a/newlib/libc/ctype/Makefile.am b/newlib/libc/ctype/Makefile.am
index 1572aa6..4a85b72 100644
--- a/newlib/libc/ctype/Makefile.am
+++ b/newlib/libc/ctype/Makefile.am
@@ -26,9 +26,28 @@ else
LIB_OBJS = \
isascii.$(oext) \
isblank.$(oext) \
+ iswalnum.$(oext) \
+ iswalpha.$(oext) \
+ iswblank.$(oext) \
+ iswcntrl.$(oext) \
+ iswctype.$(oext) \
+ iswdigit.$(oext) \
+ iswgraph.$(oext) \
+ iswlower.$(oext) \
+ iswprint.$(oext) \
+ iswpunct.$(oext) \
+ iswspace.$(oext) \
+ iswupper.$(oext) \
+ iswxdigit.$(oext) \
+ jp2uc.$(oext) \
toascii.$(oext) \
_tolower.$(oext) \
- _toupper.$(oext)
+ _toupper.$(oext) \
+ towctrans.$(oext) \
+ towlower.$(oext) \
+ towupper.$(oext) \
+ wctrans.$(oext) \
+ wctype.$(oext)
endif
libctype_la_LDFLAGS = -Xcompiler -nostdlib
@@ -60,10 +79,28 @@ CHEWOUT_FILES= \
ispunct.def \
isspace.def \
isupper.def \
+ iswalnum.def \
+ iswalpha.def \
+ iswblank.def \
+ iswcntrl.def \
+ iswctype.def \
+ iswdigit.def \
+ iswgraph.def \
+ iswlower.def \
+ iswprint.def \
+ iswpunct.def \
+ iswspace.def \
+ iswupper.def \
+ iswxdigit.def \
isxdigit.def \
toascii.def \
tolower.def \
- toupper.def
+ toupper.def \
+ towctrans.def \
+ towlower.def \
+ towupper.def \
+ wctrans.def \
+ wctype.def
SUFFIXES = .def
diff --git a/newlib/libc/ctype/Makefile.in b/newlib/libc/ctype/Makefile.in
index 38358d7..0104df3 100644
--- a/newlib/libc/ctype/Makefile.in
+++ b/newlib/libc/ctype/Makefile.in
@@ -129,9 +129,28 @@ GENERAL_SOURCES = \
@ELIX_LEVEL_1_FALSE@LIB_OBJS = @ELIX_LEVEL_1_FALSE@\
@ELIX_LEVEL_1_FALSE@ isascii.$(oext) \
@ELIX_LEVEL_1_FALSE@ isblank.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswalnum.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswalpha.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswblank.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswcntrl.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswctype.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswdigit.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswgraph.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswlower.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswprint.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswpunct.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswspace.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswupper.$(oext) \
+@ELIX_LEVEL_1_FALSE@ iswxdigit.$(oext) \
+@ELIX_LEVEL_1_FALSE@ jp2uc.$(oext) \
@ELIX_LEVEL_1_FALSE@ toascii.$(oext) \
@ELIX_LEVEL_1_FALSE@ _tolower.$(oext) \
-@ELIX_LEVEL_1_FALSE@ _toupper.$(oext)
+@ELIX_LEVEL_1_FALSE@ _toupper.$(oext) \
+@ELIX_LEVEL_1_FALSE@ towctrans.$(oext) \
+@ELIX_LEVEL_1_FALSE@ towlower.$(oext) \
+@ELIX_LEVEL_1_FALSE@ towupper.$(oext) \
+@ELIX_LEVEL_1_FALSE@ wctrans.$(oext) \
+@ELIX_LEVEL_1_FALSE@ wctype.$(oext)
libctype_la_LDFLAGS = -Xcompiler -nostdlib
@@ -157,10 +176,28 @@ CHEWOUT_FILES = \
ispunct.def \
isspace.def \
isupper.def \
+ iswalnum.def \
+ iswalpha.def \
+ iswblank.def \
+ iswcntrl.def \
+ iswctype.def \
+ iswdigit.def \
+ iswgraph.def \
+ iswlower.def \
+ iswprint.def \
+ iswpunct.def \
+ iswspace.def \
+ iswupper.def \
+ iswxdigit.def \
isxdigit.def \
toascii.def \
tolower.def \
- toupper.def
+ toupper.def \
+ towctrans.def \
+ towlower.def \
+ towupper.def \
+ wctrans.def \
+ wctype.def
SUFFIXES = .def
diff --git a/newlib/libc/ctype/ctype.tex b/newlib/libc/ctype/ctype.tex
index a0971d8..df398f6 100644
--- a/newlib/libc/ctype/ctype.tex
+++ b/newlib/libc/ctype/ctype.tex
@@ -21,6 +21,23 @@ The header file @file{ctype.h} defines the macros.
* toascii:: Force integers to ASCII range
* tolower:: Translate characters to lower case
* toupper:: Translate characters to upper case
+* iswalnum:: Alphanumeric wide-character predicate
+* iswalpha:: Alphabetic wide-character predicate
+* iswcntrl:: Control wide-character predicate
+* iswdigit:: Decimal digit wide-character predicate
+* iswgraph:: Graphic wide-character predicate
+* iswlower:: Lower-case wide-character predicate
+* iswprint:: Printable wide-character predicate
+* iswpunct:: Punctuation wide-character predicate
+* iswspace:: Whitespace wide-character predicate
+* iswupper:: Uppercase wide-character predicate
+* iswxdigit:: Hexadecimal digit wide-character predicate
+* iswctype:: Extensible wide-character test
+* wctype:: Compute wide-character test type
+* towlower:: Translate wide-characters to lower case
+* towupper:: Translate wide-characters to upper case
+* towctrans:: Extensible wide-character case mapping
+* wctrans:: Compute wide-character translation type
@end menu
@page
@@ -65,4 +82,55 @@ The header file @file{ctype.h} defines the macros.
@page
@include ctype/toupper.def
+@page
+@include ctype/iswalnum.def
+
+@page
+@include ctype/iswalpha.def
+
+@page
+@include ctype/iswcntrl.def
+
+@page
+@include ctype/iswdigit.def
+
+@page
+@include ctype/iswgraph.def
+
+@page
+@include ctype/iswlower.def
+
+@page
+@include ctype/iswprint.def
+
+@page
+@include ctype/iswpunct.def
+
+@page
+@include ctype/iswspace.def
+
+@page
+@include ctype/iswupper.def
+
+@page
+@include ctype/iswxdigit.def
+
+@page
+@include ctype/iswctype.def
+
+@page
+@include ctype/wctype.def
+
+@page
+@include ctype/towlower.def
+
+@page
+@include ctype/towupper.def
+
+@page
+@include ctype/towctrans.def
+
+@page
+@include ctype/wctrans.def
+
diff --git a/newlib/libc/ctype/iswalnum.c b/newlib/libc/ctype/iswalnum.c
new file mode 100644
index 0000000..12613c7
--- /dev/null
+++ b/newlib/libc/ctype/iswalnum.c
@@ -0,0 +1,37 @@
+/*
+FUNCTION
+ <<iswalnum>>---alpha-numeric wide-character test
+
+INDEX
+ iswalnum
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswalnum(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswalnum(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswalnum>> is a function which classifies wide-character values that
+are alpha-numeric.
+
+RETURNS
+<<iswalnum>> returns non-zero if <[c]> is a alpha-numeric wide-character.
+
+PORTABILITY
+<<iswalnum>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswalnum,(c),wint_t c)
+{
+ return (iswalpha (c) || iswdigit (c));
+}
+
diff --git a/newlib/libc/ctype/iswalpha.c b/newlib/libc/ctype/iswalpha.c
new file mode 100644
index 0000000..4fed96c
--- /dev/null
+++ b/newlib/libc/ctype/iswalpha.c
@@ -0,0 +1,342 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswalpha>>---alphabetic wide-character test
+
+INDEX
+ iswalpha
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswalpha(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswalpha(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswalpha>> is a function which classifies wide-character values that
+are alphabetic.
+
+RETURNS
+<<iswalpha>> returns non-zero if <[c]> is an alphabetic wide-character.
+
+PORTABILITY
+<<iswalpha>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <string.h>
+#include <ctype.h>
+#include "local.h"
+
+#ifdef MB_CAPABLE
+#include "utf8alpha.h"
+#endif /* MB_CAPABLE */
+
+int
+_DEFUN(iswalpha,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ unsigned const char *table;
+ unsigned char *ptr;
+ unsigned char ctmp;
+ int size;
+ wint_t x = (c >> 8);
+
+ /* for some large sections, all characters are alphabetic so handle them here */
+ if ((x >= 0x34 && x <= 0x4c) ||
+ (x >= 0x4e && x <= 0x9e) ||
+ (x >= 0xac && x <= 0xd6) ||
+ (x >= 0x200 && x <= 0x2a5))
+ return 1;
+
+ switch (x)
+ {
+ case 0x00:
+ table = u0;
+ size = sizeof(u0);
+ break;
+ case 0x01:
+ case 0x15:
+ case 0xa0:
+ case 0xa1:
+ case 0xa2:
+ case 0xa3:
+ case 0xf9:
+ case 0xfc:
+ case 0x2f8:
+ case 0x2f9:
+ return 1;
+ case 0x02:
+ table = u2;
+ size = sizeof(u2);
+ break;
+ case 0x03:
+ table = u3;
+ size = sizeof(u3);
+ break;
+ case 0x04:
+ table = u4;
+ size = sizeof(u4);
+ break;
+ case 0x05:
+ table = u5;
+ size = sizeof(u5);
+ break;
+ case 0x06:
+ table = u6;
+ size = sizeof(u6);
+ break;
+ case 0x07:
+ table = u7;
+ size = sizeof(u7);
+ break;
+ case 0x09:
+ table = u9;
+ size = sizeof(u9);
+ break;
+ case 0x0a:
+ table = ua;
+ size = sizeof(ua);
+ break;
+ case 0x0b:
+ table = ub;
+ size = sizeof(ub);
+ break;
+ case 0x0c:
+ table = uc;
+ size = sizeof(uc);
+ break;
+ case 0x0d:
+ table = ud;
+ size = sizeof(ud);
+ break;
+ case 0x0e:
+ table = ue;
+ size = sizeof(ue);
+ break;
+ case 0x0f:
+ table = uf;
+ size = sizeof(uf);
+ break;
+ case 0x10:
+ table = u10;
+ size = sizeof(u10);
+ break;
+ case 0x11:
+ table = u11;
+ size = sizeof(u11);
+ break;
+ case 0x12:
+ table = u12;
+ size = sizeof(u12);
+ break;
+ case 0x13:
+ table = u13;
+ size = sizeof(u13);
+ break;
+ case 0x14:
+ table = u14;
+ size = sizeof(u14);
+ break;
+ case 0x16:
+ table = u16;
+ size = sizeof(u16);
+ break;
+ case 0x17:
+ table = u17;
+ size = sizeof(u17);
+ break;
+ case 0x18:
+ table = u18;
+ size = sizeof(u18);
+ break;
+ case 0x1e:
+ table = u1e;
+ size = sizeof(u1e);
+ break;
+ case 0x1f:
+ table = u1f;
+ size = sizeof(u1f);
+ break;
+ case 0x20:
+ table = u20;
+ size = sizeof(u20);
+ break;
+ case 0x21:
+ table = u21;
+ size = sizeof(u21);
+ break;
+ case 0x24:
+ table = u24;
+ size = sizeof(u24);
+ break;
+ case 0x30:
+ table = u30;
+ size = sizeof(u30);
+ break;
+ case 0x31:
+ table = u31;
+ size = sizeof(u31);
+ break;
+ case 0x4d:
+ table = u4d;
+ size = sizeof(u4d);
+ break;
+ case 0x9f:
+ table = u9f;
+ size = sizeof(u9f);
+ break;
+ case 0xa4:
+ table = ua4;
+ size = sizeof(ua4);
+ break;
+ case 0xd7:
+ table = ud7;
+ size = sizeof(ud7);
+ break;
+ case 0xfa:
+ table = ufa;
+ size = sizeof(ufa);
+ break;
+ case 0xfb:
+ table = ufb;
+ size = sizeof(ufb);
+ break;
+ case 0xfd:
+ table = ufd;
+ size = sizeof(ufd);
+ break;
+ case 0xfe:
+ table = ufe;
+ size = sizeof(ufe);
+ break;
+ case 0xff:
+ table = uff;
+ size = sizeof(uff);
+ break;
+ case 0x103:
+ table = u103;
+ size = sizeof(u103);
+ break;
+ case 0x104:
+ table = u104;
+ size = sizeof(u104);
+ break;
+ case 0x1d4:
+ table = u1d4;
+ size = sizeof(u1d4);
+ break;
+ case 0x1d5:
+ table = u1d5;
+ size = sizeof(u1d5);
+ break;
+ case 0x1d6:
+ table = u1d6;
+ size = sizeof(u1d6);
+ break;
+ case 0x1d7:
+ table = u1d7;
+ size = sizeof(u1d7);
+ break;
+ case 0x2a6:
+ table = u2a6;
+ size = sizeof(u2a6);
+ break;
+ case 0x2fa:
+ table = u2fa;
+ size = sizeof(u2fa);
+ break;
+ default:
+ return 0;
+ }
+ /* we have narrowed down to a section of 256 characters to check */
+ /* now check if c matches the alphabetic wide-chars within that section */
+ ptr = (unsigned char *)table;
+ ctmp = (unsigned char)c;
+ while (ptr < table + size)
+ {
+ if (ctmp == *ptr)
+ return 1;
+ if (ctmp < *ptr)
+ return 0;
+ /* otherwise c > *ptr */
+ /* look for 0x0 as next element which indicates a range */
+ ++ptr;
+ if (*ptr == 0x0)
+ {
+ /* we have a range..see if c falls within range */
+ ++ptr;
+ if (ctmp <= *ptr)
+ return 1;
+ ++ptr;
+ }
+ }
+ /* not in table */
+ return 0;
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < (wint_t)0x100 ? isalpha (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswblank.c b/newlib/libc/ctype/iswblank.c
new file mode 100644
index 0000000..069b737
--- /dev/null
+++ b/newlib/libc/ctype/iswblank.c
@@ -0,0 +1,105 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswblank>>---wide-character blank test
+
+INDEX
+ iswblank
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswblank(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswblank(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswblank>> is a function which classifies wide-character values that
+are categorized as blank.
+
+RETURNS
+<<iswblank>> returns non-zero if <[c]> is a blank wide-character.
+
+PORTABILITY
+<<iswblank>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <ctype.h>
+#include <string.h>
+#include "local.h"
+
+int
+_DEFUN(iswblank,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ return (c == 0x0009 || c == 0x0020 || c == 0x1680 ||
+ (c >= 0x2000 && c <= 0x2006) ||
+ (c >= 0x2008 && c <= 0x200b) ||
+ c == 0x205f || c == 0x3000);
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < 0x100 ? isblank (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswcntrl.c b/newlib/libc/ctype/iswcntrl.c
new file mode 100644
index 0000000..5935431
--- /dev/null
+++ b/newlib/libc/ctype/iswcntrl.c
@@ -0,0 +1,104 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswcntrl>>---wide-character cntrl test
+
+INDEX
+ iswcntrl
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswcntrl(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswcntrl(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswcntrl>> is a function which classifies wide-character values that
+are categorized as a control character.
+
+RETURNS
+<<iswcntrl>> returns non-zero if <[c]> is a control wide-character.
+
+PORTABILITY
+<<iswcntrl>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <ctype.h>
+#include <string.h>
+#include "local.h"
+
+int
+_DEFUN(iswcntrl,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ return ((c >= 0x0000 && c <= 0x001f) ||
+ (c >= 0x007f && c <= 0x009f) ||
+ c == 0x2028 || c == 0x2029);
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < 0x100 ? iscntrl (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswctype.c b/newlib/libc/ctype/iswctype.c
new file mode 100644
index 0000000..fbf5da7
--- /dev/null
+++ b/newlib/libc/ctype/iswctype.c
@@ -0,0 +1,70 @@
+/*
+FUNCTION
+ <<iswctype>>---extensible wide-character test
+
+INDEX
+ iswctype
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswctype(wint_t <[c]>, wctype_t <[desc]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswctype(<[c]>, <[desc]>)
+ wint_t <[c]>;
+ wctype_t <[desc]>;
+
+DESCRIPTION
+<<iswctype>> is a function which classifies wide-character values using the
+wide-character test specified by <[desc]>.
+
+RETURNS
+<<iswctype>> returns non-zero if and only if <[c]> matches the test specified by <[desc]>.
+If <[desc]> is unknown, zero is returned.
+
+PORTABILITY
+<<iswctype>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include "local.h"
+
+int
+_DEFUN(iswctype,(c, desc), wint_t c _AND wctype_t desc)
+{
+ switch (desc)
+ {
+ case WC_ALNUM:
+ return iswalnum (c);
+ case WC_ALPHA:
+ return iswalpha (c);
+ case WC_BLANK:
+ return iswblank (c);
+ case WC_CNTRL:
+ return iswcntrl (c);
+ case WC_DIGIT:
+ return iswdigit (c);
+ case WC_GRAPH:
+ return iswgraph (c);
+ case WC_LOWER:
+ return iswlower (c);
+ case WC_PRINT:
+ return iswprint (c);
+ case WC_PUNCT:
+ return iswpunct (c);
+ case WC_SPACE:
+ return iswspace (c);
+ case WC_UPPER:
+ return iswupper (c);
+ case WC_XDIGIT:
+ return iswxdigit (c);
+ default:
+ }
+
+ /* otherwise unknown */
+ return 0;
+}
+
diff --git a/newlib/libc/ctype/iswdigit.c b/newlib/libc/ctype/iswdigit.c
new file mode 100644
index 0000000..94c74ae
--- /dev/null
+++ b/newlib/libc/ctype/iswdigit.c
@@ -0,0 +1,37 @@
+/*
+FUNCTION
+ <<iswdigit>>---decimal digit wide-character test
+
+INDEX
+ iswdigit
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswdigit(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswdigit(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswdigit>> is a function which classifies wide-character values that
+are decimal digits.
+
+RETURNS
+<<iswdigit>> returns non-zero if <[c]> is a decimal digit wide-character.
+
+PORTABILITY
+<<iswdigit>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswdigit,(c), wint_t c)
+{
+ return (c >= (wint_t)'0' && c <= (wint_t)'9');
+}
+
diff --git a/newlib/libc/ctype/iswgraph.c b/newlib/libc/ctype/iswgraph.c
new file mode 100644
index 0000000..880c664
--- /dev/null
+++ b/newlib/libc/ctype/iswgraph.c
@@ -0,0 +1,66 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswgraph>>---graphic wide-character test
+
+INDEX
+ iswgraph
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswgraph(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswgraph(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswgraph>> is a function which classifies wide-character values that
+are graphic.
+
+RETURNS
+<<iswgraph>> returns non-zero if <[c]> is a graphic wide-character.
+
+PORTABILITY
+<<iswgraph>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswgraph,(c),wint_t c)
+{
+ return (iswprint (c) && !iswspace (c));
+}
+
diff --git a/newlib/libc/ctype/iswlower.c b/newlib/libc/ctype/iswlower.c
new file mode 100644
index 0000000..d320486
--- /dev/null
+++ b/newlib/libc/ctype/iswlower.c
@@ -0,0 +1,38 @@
+
+/*
+FUNCTION
+ <<iswlower>>---lower-case wide-character test
+
+INDEX
+ iswlower
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswlower(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswlower(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswlower>> is a function which classifies wide-character values that
+have an upper-case translation.
+
+RETURNS
+<<iswlower>> returns non-zero if <[c]> is a lower-case wide-character.
+
+PORTABILITY
+<<iswlower>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswlower,(c),wint_t c)
+{
+ return (towupper (c) != c);
+}
+
diff --git a/newlib/libc/ctype/iswprint.c b/newlib/libc/ctype/iswprint.c
new file mode 100644
index 0000000..c30938f
--- /dev/null
+++ b/newlib/libc/ctype/iswprint.c
@@ -0,0 +1,397 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswprint>>---printable wide-character test
+
+INDEX
+ iswprint
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswprint(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswprint(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswprint>> is a function which classifies wide-character values that
+are printable.
+
+RETURNS
+<<iswprint>> returns non-zero if <[c]> is a printable wide-character.
+
+PORTABILITY
+<<iswprint>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <string.h>
+#include <ctype.h>
+#include "local.h"
+
+#ifdef MB_CAPABLE
+#include "utf8print.h"
+#endif /* MB_CAPABLE */
+
+int
+_DEFUN(iswprint,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ unsigned const char *table;
+ unsigned char *ptr;
+ unsigned char ctmp;
+ int size;
+ wint_t x = (c >> 8);
+
+ /* for some large sections, all characters are printuation so handle them here */
+ if ((x >= 0x34 && x <= 0x4c) ||
+ (x >= 0x4e && x <= 0x9e) ||
+ (x >= 0xac && x <= 0xd6) ||
+ (x >= 0xe0 && x <= 0xf9) ||
+ (x >= 0x200 && x <= 0x2a5) ||
+ (x >= 0xf00 && x <= 0xffe) ||
+ (x >= 0x1000 && x <= 0x10fe))
+ return 1;
+
+ switch (x)
+ {
+ case 0x01:
+ case 0x15:
+ case 0x22:
+ case 0x25:
+ case 0x28:
+ case 0x29:
+ case 0x2a:
+ case 0xa0:
+ case 0xa1:
+ case 0xa2:
+ case 0xa3:
+ case 0xfc:
+ case 0x2f8:
+ case 0x2f9:
+ return 1;
+ case 0x00:
+ table = u0;
+ size = sizeof(u0);
+ break;
+ case 0x02:
+ table = u2;
+ size = sizeof(u2);
+ break;
+ case 0x03:
+ table = u3;
+ size = sizeof(u3);
+ break;
+ case 0x04:
+ table = u4;
+ size = sizeof(u4);
+ break;
+ case 0x05:
+ table = u5;
+ size = sizeof(u5);
+ break;
+ case 0x06:
+ table = u6;
+ size = sizeof(u6);
+ break;
+ case 0x07:
+ table = u7;
+ size = sizeof(u7);
+ break;
+ case 0x09:
+ table = u9;
+ size = sizeof(u9);
+ break;
+ case 0x0a:
+ table = ua;
+ size = sizeof(ua);
+ break;
+ case 0x0b:
+ table = ub;
+ size = sizeof(ub);
+ break;
+ case 0x0c:
+ table = uc;
+ size = sizeof(uc);
+ break;
+ case 0x0d:
+ table = ud;
+ size = sizeof(ud);
+ break;
+ case 0x0e:
+ table = ue;
+ size = sizeof(ue);
+ break;
+ case 0x0f:
+ table = uf;
+ size = sizeof(uf);
+ break;
+ case 0x10:
+ table = u10;
+ size = sizeof(u10);
+ break;
+ case 0x11:
+ table = u11;
+ size = sizeof(u11);
+ break;
+ case 0x12:
+ table = u12;
+ size = sizeof(u12);
+ break;
+ case 0x13:
+ table = u13;
+ size = sizeof(u13);
+ break;
+ case 0x14:
+ table = u14;
+ size = sizeof(u14);
+ break;
+ case 0x16:
+ table = u16;
+ size = sizeof(u16);
+ break;
+ case 0x17:
+ table = u17;
+ size = sizeof(u17);
+ break;
+ case 0x18:
+ table = u18;
+ size = sizeof(u18);
+ break;
+ case 0x1e:
+ table = u1e;
+ size = sizeof(u1e);
+ break;
+ case 0x1f:
+ table = u1f;
+ size = sizeof(u1f);
+ break;
+ case 0x20:
+ table = u20;
+ size = sizeof(u20);
+ break;
+ case 0x21:
+ table = u21;
+ size = sizeof(u21);
+ break;
+ case 0x23:
+ table = u23;
+ size = sizeof(u23);
+ break;
+ case 0x24:
+ table = u24;
+ size = sizeof(u24);
+ break;
+ case 0x26:
+ table = u26;
+ size = sizeof(u26);
+ break;
+ case 0x27:
+ table = u27;
+ size = sizeof(u27);
+ break;
+ case 0x2e:
+ table = u2e;
+ size = sizeof(u2e);
+ break;
+ case 0x2f:
+ table = u2f;
+ size = sizeof(u2f);
+ break;
+ case 0x30:
+ table = u30;
+ size = sizeof(u30);
+ break;
+ case 0x31:
+ table = u31;
+ size = sizeof(u31);
+ break;
+ case 0x32:
+ table = u32;
+ size = sizeof(u32);
+ break;
+ case 0x33:
+ table = u33;
+ size = sizeof(u33);
+ break;
+ case 0x4d:
+ table = u4d;
+ size = sizeof(u4d);
+ break;
+ case 0x9f:
+ table = u9f;
+ size = sizeof(u9f);
+ break;
+ case 0xa4:
+ table = ua4;
+ size = sizeof(ua4);
+ break;
+ case 0xd7:
+ table = ud7;
+ size = sizeof(ud7);
+ break;
+ case 0xfa:
+ table = ufa;
+ size = sizeof(ufa);
+ break;
+ case 0xfb:
+ table = ufb;
+ size = sizeof(ufb);
+ break;
+ case 0xfd:
+ table = ufd;
+ size = sizeof(ufd);
+ break;
+ case 0xfe:
+ table = ufe;
+ size = sizeof(ufe);
+ break;
+ case 0xff:
+ table = uff;
+ size = sizeof(uff);
+ break;
+ case 0x103:
+ table = u103;
+ size = sizeof(u103);
+ break;
+ case 0x104:
+ table = u104;
+ size = sizeof(u104);
+ break;
+ case 0x1d0:
+ table = u1d0;
+ size = sizeof(u1d0);
+ break;
+ case 0x1d1:
+ table = u1d1;
+ size = sizeof(u1d1);
+ break;
+ case 0x1d4:
+ table = u1d4;
+ size = sizeof(u1d4);
+ break;
+ case 0x1d5:
+ table = u1d5;
+ size = sizeof(u1d5);
+ break;
+ case 0x1d6:
+ table = u1d6;
+ size = sizeof(u1d6);
+ break;
+ case 0x1d7:
+ table = u1d7;
+ size = sizeof(u1d7);
+ break;
+ case 0x2a6:
+ table = u2a6;
+ size = sizeof(u2a6);
+ break;
+ case 0x2fa:
+ table = u2fa;
+ size = sizeof(u2fa);
+ break;
+ case 0xe00:
+ table = ue00;
+ size = sizeof(ue00);
+ break;
+ case 0xfff:
+ table = ufff;
+ size = sizeof(ufff);
+ break;
+ case 0x10ff:
+ table = u10ff;
+ size = sizeof(u10ff);
+ break;
+ default:
+ return 0;
+ }
+ /* we have narrowed down to a section of 256 characters to check */
+ /* now check if c matches the printuation wide-chars within that section */
+ ptr = (unsigned char *)table;
+ ctmp = (unsigned char)c;
+ while (ptr < table + size)
+ {
+ if (ctmp == *ptr)
+ return 1;
+ if (ctmp < *ptr)
+ return 0;
+ /* otherwise c > *ptr */
+ /* look for 0x0 as next element which indicates a range */
+ ++ptr;
+ if (*ptr == 0x0)
+ {
+ /* we have a range..see if c falls within range */
+ ++ptr;
+ if (ctmp <= *ptr)
+ return 1;
+ ++ptr;
+ }
+ }
+ /* not in table */
+ return 0;
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < (wint_t)0x100 ? isprint (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswpunct.c b/newlib/libc/ctype/iswpunct.c
new file mode 100644
index 0000000..3e577d6
--- /dev/null
+++ b/newlib/libc/ctype/iswpunct.c
@@ -0,0 +1,332 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswpunct>>---punctuation wide-character test
+
+INDEX
+ iswpunct
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswpunct(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswpunct(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswpunct>> is a function which classifies wide-character values that
+are punctuation.
+
+RETURNS
+<<iswpunct>> returns non-zero if <[c]> is a punctuation wide-character.
+
+PORTABILITY
+<<iswpunct>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <string.h>
+#include <ctype.h>
+#include "local.h"
+
+#ifdef MB_CAPABLE
+#include "utf8punct.h"
+#endif /* MB_CAPABLE */
+
+int
+_DEFUN(iswpunct,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ unsigned const char *table;
+ unsigned char *ptr;
+ unsigned char ctmp;
+ int size;
+ wint_t x = (c >> 8);
+
+ /* for some large sections, all characters are punctuation so handle them here */
+ if ((x >= 0xe0 && x <= 0xf8) ||
+ (x >= 0xf00 && x <= 0xffe) ||
+ (x >= 0x1000 && x <= 0x10fe))
+ return 1;
+
+ switch (x)
+ {
+ case 0x22:
+ case 0x25:
+ case 0x28:
+ case 0x29:
+ case 0x2a:
+ return 1;
+ case 0x00:
+ table = u0;
+ size = sizeof(u0);
+ break;
+ case 0x02:
+ table = u2;
+ size = sizeof(u2);
+ break;
+ case 0x03:
+ table = u3;
+ size = sizeof(u3);
+ break;
+ case 0x04:
+ table = u4;
+ size = sizeof(u4);
+ break;
+ case 0x05:
+ table = u5;
+ size = sizeof(u5);
+ break;
+ case 0x06:
+ table = u6;
+ size = sizeof(u6);
+ break;
+ case 0x07:
+ table = u7;
+ size = sizeof(u7);
+ break;
+ case 0x09:
+ table = u9;
+ size = sizeof(u9);
+ break;
+ case 0x0a:
+ table = ua;
+ size = sizeof(ua);
+ break;
+ case 0x0b:
+ table = ub;
+ size = sizeof(ub);
+ break;
+ case 0x0c:
+ table = uc;
+ size = sizeof(uc);
+ break;
+ case 0x0d:
+ table = ud;
+ size = sizeof(ud);
+ break;
+ case 0x0e:
+ table = ue;
+ size = sizeof(ue);
+ break;
+ case 0x0f:
+ table = uf;
+ size = sizeof(uf);
+ break;
+ case 0x10:
+ table = u10;
+ size = sizeof(u10);
+ break;
+ case 0x13:
+ table = u13;
+ size = sizeof(u13);
+ break;
+ case 0x16:
+ table = u16;
+ size = sizeof(u16);
+ break;
+ case 0x17:
+ table = u17;
+ size = sizeof(u17);
+ break;
+ case 0x18:
+ table = u18;
+ size = sizeof(u18);
+ break;
+ case 0x1f:
+ table = u1f;
+ size = sizeof(u1f);
+ break;
+ case 0x20:
+ table = u20;
+ size = sizeof(u20);
+ break;
+ case 0x21:
+ table = u21;
+ size = sizeof(u21);
+ break;
+ case 0x23:
+ table = u23;
+ size = sizeof(u23);
+ break;
+ case 0x24:
+ table = u24;
+ size = sizeof(u24);
+ break;
+ case 0x26:
+ table = u26;
+ size = sizeof(u26);
+ break;
+ case 0x27:
+ table = u27;
+ size = sizeof(u27);
+ break;
+ case 0x2e:
+ table = u2e;
+ size = sizeof(u2e);
+ break;
+ case 0x2f:
+ table = u2f;
+ size = sizeof(u2f);
+ break;
+ case 0x30:
+ table = u30;
+ size = sizeof(u30);
+ break;
+ case 0x31:
+ table = u31;
+ size = sizeof(u31);
+ break;
+ case 0x32:
+ table = u32;
+ size = sizeof(u32);
+ break;
+ case 0x33:
+ table = u33;
+ size = sizeof(u33);
+ break;
+ case 0xa4:
+ table = ua4;
+ size = sizeof(ua4);
+ break;
+ case 0xfb:
+ table = ufb;
+ size = sizeof(ufb);
+ break;
+ case 0xfd:
+ table = ufd;
+ size = sizeof(ufd);
+ break;
+ case 0xfe:
+ table = ufe;
+ size = sizeof(ufe);
+ break;
+ case 0xff:
+ table = uff;
+ size = sizeof(uff);
+ break;
+ case 0x103:
+ table = u103;
+ size = sizeof(u103);
+ break;
+ case 0x1d0:
+ table = u1d0;
+ size = sizeof(u1d0);
+ break;
+ case 0x1d1:
+ table = u1d1;
+ size = sizeof(u1d1);
+ break;
+ case 0x1d6:
+ table = u1d6;
+ size = sizeof(u1d6);
+ break;
+ case 0x1d7:
+ table = u1d7;
+ size = sizeof(u1d7);
+ break;
+ case 0xe00:
+ table = ue00;
+ size = sizeof(ue00);
+ break;
+ case 0xfff:
+ table = ufff;
+ size = sizeof(ufff);
+ break;
+ case 0x10ff:
+ table = u10ff;
+ size = sizeof(u10ff);
+ break;
+ default:
+ return 0;
+ }
+ /* we have narrowed down to a section of 256 characters to check */
+ /* now check if c matches the punctuation wide-chars within that section */
+ ptr = (unsigned char *)table;
+ ctmp = (unsigned char)c;
+ while (ptr < table + size)
+ {
+ if (ctmp == *ptr)
+ return 1;
+ if (ctmp < *ptr)
+ return 0;
+ /* otherwise c > *ptr */
+ /* look for 0x0 as next element which indicates a range */
+ ++ptr;
+ if (*ptr == 0x0)
+ {
+ /* we have a range..see if c falls within range */
+ ++ptr;
+ if (ctmp <= *ptr)
+ return 1;
+ ++ptr;
+ }
+ }
+ /* not in table */
+ return 0;
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < (wint_t)0x100 ? ispunct (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswspace.c b/newlib/libc/ctype/iswspace.c
new file mode 100644
index 0000000..d8f6b58
--- /dev/null
+++ b/newlib/libc/ctype/iswspace.c
@@ -0,0 +1,106 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<iswspace>>---wide-character space test
+
+INDEX
+ iswspace
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswspace(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswspace(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswspace>> is a function which classifies wide-character values that
+are categorized as white-space.
+
+RETURNS
+<<iswspace>> returns non-zero if <[c]> is a white-space wide-character.
+
+PORTABILITY
+<<iswspace>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+#include <ctype.h>
+#include <string.h>
+#include "local.h"
+
+int
+_DEFUN(iswspace,(c), wint_t c)
+{
+ int unicode = 0;
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ return ((c >= 0x0009 && c <= 0x000d) || c == 0x0020 || c == 0x1680 ||
+ (c >= 0x2000 && c <= 0x2006) ||
+ (c >= 0x2008 && c <= 0x200b) ||
+ c == 0x2028 || c == 0x2029 ||
+ c == 0x205f || c == 0x3000);
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < 0x100 ? isspace (c) : 0);
+}
+
diff --git a/newlib/libc/ctype/iswupper.c b/newlib/libc/ctype/iswupper.c
new file mode 100644
index 0000000..872475d
--- /dev/null
+++ b/newlib/libc/ctype/iswupper.c
@@ -0,0 +1,38 @@
+
+/*
+FUNCTION
+ <<iswupper>>---upper-case wide-character test
+
+INDEX
+ iswupper
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswupper(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswupper(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswupper>> is a function which classifies wide-character values that
+have an upper-case translation.
+
+RETURNS
+<<iswupper>> returns non-zero if <[c]> is a upper-case wide-character.
+
+PORTABILITY
+<<iswupper>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswupper,(c),wint_t c)
+{
+ return (towlower (c) != c);
+}
+
diff --git a/newlib/libc/ctype/iswxdigit.c b/newlib/libc/ctype/iswxdigit.c
new file mode 100644
index 0000000..73d8fa4
--- /dev/null
+++ b/newlib/libc/ctype/iswxdigit.c
@@ -0,0 +1,39 @@
+/*
+FUNCTION
+ <<iswxdigit>>---hexadecimal digit wide-character test
+
+INDEX
+ iswxdigit
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ int iswxdigit(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ int iswxdigit(<[c]>)
+ wint_t <[c]>;
+
+DESCRIPTION
+<<iswxdigit>> is a function which classifies wide-character values that
+are hexadecimal digits.
+
+RETURNS
+<<iswxdigit>> returns non-zero if <[c]> is a hexadecimal digit wide-character.
+
+PORTABILITY
+<<iswxdigit>> is C99.
+
+No supporting OS subroutines are required.
+*/
+#include <_ansi.h>
+#include <wctype.h>
+
+int
+_DEFUN(iswxdigit,(c), wint_t c)
+{
+ return ((c >= (wint_t)'0' && c <= (wint_t)'9') ||
+ (c >= (wint_t)'a' && c <= (wint_t)'f') ||
+ (c >= (wint_t)'A' && c <= (wint_t)'F'));
+}
+
diff --git a/newlib/libc/ctype/jp2uc.c b/newlib/libc/ctype/jp2uc.c
new file mode 100644
index 0000000..1e64b69
--- /dev/null
+++ b/newlib/libc/ctype/jp2uc.c
@@ -0,0 +1,86 @@
+/* Routine to translate from Japanese characters to Unicode */
+
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifdef MB_CAPABLE
+
+#include <_ansi.h>
+#include <wctype.h>
+#include "local.h"
+#include "jp2uc.h"
+
+wint_t
+_DEFUN (__jp2uc, (c, type), wint_t c _AND int type)
+{
+ int index, adj;
+ unsigned char byte1, byte2, adj_byte1, adj_byte2;
+
+ /* we actually use a table of JIS to Unicode. For SJIS, we simply
+ note that SJIS is essentially JIS with the top bits on in each
+ byte. For EUCJP, we essentially do a translation to JIS before
+ accessing the table. */
+ switch (type)
+ {
+ case JP_JIS:
+ index = ((c >> 8) - 0x21) * 0xfe + ((c & 0xff) - 0x21);
+ break;
+ case JP_SJIS:
+ index = ((c >> 8) - 0xa1) * 0xfe + ((c & 0xff) - 0xa1);
+ break;
+ case JP_EUCJP:
+ byte1 = c >> 8;
+ byte2 = c & 0xff;
+ if (byte2 <= 0x7e || (byte2 & 0x1))
+ {
+ adj = -0x22;
+ adj_byte2 = (byte2 & 0xfe) - 31;
+ }
+ else
+ {
+ adj = -0x21;
+ adj_byte2 = byte2 - (0x7e + 0x21);
+ }
+ if (byte1 <= 0x9f)
+ adj_byte1 = ((byte1 - 112) >> 1) + adj;
+ else
+ adj_byte1 = ((byte1 - 112) >> 1) + adj;
+ index = adj_byte1 * 0xfe + adj_byte2;
+ break;
+ default:
+ return WEOF;
+ }
+
+ if (index < 0 || index > (sizeof(jp2uc) / sizeof(unsigned short)))
+ return WEOF;
+
+ return (wint_t)jp2uc[index];
+}
+
+#endif /* MB_CAPABLE */
diff --git a/newlib/libc/ctype/jp2uc.h b/newlib/libc/ctype/jp2uc.h
new file mode 100644
index 0000000..a38009d
--- /dev/null
+++ b/newlib/libc/ctype/jp2uc.h
@@ -0,0 +1,6883 @@
+/* based on eucjp-208A.txt */
+
+static unsigned short jp2uc[] = {
+ 0x3000,
+ 0x3001,
+ 0x3002,
+ 0xFF0C,
+ 0xFF0E,
+ 0x30FB,
+ 0xFF1A,
+ 0xFF1B,
+ 0xFF1F,
+ 0xFF01,
+ 0x309B,
+ 0x309C,
+ 0x00B4,
+ 0xFF40,
+ 0x00A8,
+ 0xFF3E,
+ 0x203E,
+ 0xFF3F,
+ 0x30FD,
+ 0x30FE,
+ 0x309D,
+ 0x309E,
+ 0x3003,
+ 0x4EDD,
+ 0x3005,
+ 0x3006,
+ 0x3007,
+ 0x30FC,
+ 0x2014,
+ 0x2010,
+ 0xFF0F,
+ 0xFF3C,
+ 0x301C,
+ 0x2016,
+ 0xFF5C,
+ 0x2026,
+ 0x2025,
+ 0x2018,
+ 0x2019,
+ 0x201C,
+ 0x201D,
+ 0xFF08,
+ 0xFF09,
+ 0x3014,
+ 0x3015,
+ 0xFF3B,
+ 0xFF3D,
+ 0xFF5B,
+ 0xFF5D,
+ 0x3008,
+ 0x3009,
+ 0x300A,
+ 0x300B,
+ 0x300C,
+ 0x300D,
+ 0x300E,
+ 0x300F,
+ 0x3010,
+ 0x3011,
+ 0xFF0B,
+ 0x2212,
+ 0x00B1,
+ 0x00D7,
+ 0x00F7,
+ 0xFF1D,
+ 0x2260,
+ 0xFF1C,
+ 0xFF1E,
+ 0x2266,
+ 0x2267,
+ 0x221E,
+ 0x2234,
+ 0x2642,
+ 0x2640,
+ 0x00B0,
+ 0x2032,
+ 0x2033,
+ 0x2103,
+ 0x00A5,
+ 0xFF04,
+ 0x00A2,
+ 0x00A3,
+ 0xFF05,
+ 0xFF03,
+ 0xFF06,
+ 0xFF0A,
+ 0xFF20,
+ 0x00A7,
+ 0x2606,
+ 0x2605,
+ 0x25CB,
+ 0x25CF,
+ 0x25CE,
+ 0x25C7,
+ 0x25C6,
+ 0x25A1,
+ 0x25A0,
+ 0x25B3,
+ 0x25B2,
+ 0x25BD,
+ 0x25BC,
+ 0x203B,
+ 0x3012,
+ 0x2192,
+ 0x2190,
+ 0x2191,
+ 0x2193,
+ 0x3013,
+ 0x2208,
+ 0x220B,
+ 0x2286,
+ 0x2287,
+ 0x2282,
+ 0x2283,
+ 0x222A,
+ 0x2229,
+ 0x2227,
+ 0x2228,
+ 0x00AC,
+ 0x21D2,
+ 0x21D4,
+ 0x2200,
+ 0x2203,
+ 0x2220,
+ 0x22A5,
+ 0x2312,
+ 0x2202,
+ 0x2207,
+ 0x2261,
+ 0x2252,
+ 0x226A,
+ 0x226B,
+ 0x221A,
+ 0x223D,
+ 0x221D,
+ 0x2235,
+ 0x222B,
+ 0x222C,
+ 0x212B,
+ 0x2030,
+ 0x266F,
+ 0x266D,
+ 0x266A,
+ 0x2020,
+ 0x2021,
+ 0x00B6,
+ 0x25EF,
+ 0xFF10,
+ 0xFF11,
+ 0xFF12,
+ 0xFF13,
+ 0xFF14,
+ 0xFF15,
+ 0xFF16,
+ 0xFF17,
+ 0xFF18,
+ 0xFF19,
+ 0xFF21,
+ 0xFF22,
+ 0xFF23,
+ 0xFF24,
+ 0xFF25,
+ 0xFF26,
+ 0xFF27,
+ 0xFF28,
+ 0xFF29,
+ 0xFF2A,
+ 0xFF2B,
+ 0xFF2C,
+ 0xFF2D,
+ 0xFF2E,
+ 0xFF2F,
+ 0xFF30,
+ 0xFF31,
+ 0xFF32,
+ 0xFF33,
+ 0xFF34,
+ 0xFF35,
+ 0xFF36,
+ 0xFF37,
+ 0xFF38,
+ 0xFF39,
+ 0xFF3A,
+ 0xFF41,
+ 0xFF42,
+ 0xFF43,
+ 0xFF44,
+ 0xFF45,
+ 0xFF46,
+ 0xFF47,
+ 0xFF48,
+ 0xFF49,
+ 0xFF4A,
+ 0xFF4B,
+ 0xFF4C,
+ 0xFF4D,
+ 0xFF4E,
+ 0xFF4F,
+ 0xFF50,
+ 0xFF51,
+ 0xFF52,
+ 0xFF53,
+ 0xFF54,
+ 0xFF55,
+ 0xFF56,
+ 0xFF57,
+ 0xFF58,
+ 0xFF59,
+ 0xFF5A,
+ 0x3041,
+ 0x3042,
+ 0x3043,
+ 0x3044,
+ 0x3045,
+ 0x3046,
+ 0x3047,
+ 0x3048,
+ 0x3049,
+ 0x304A,
+ 0x304B,
+ 0x304C,
+ 0x304D,
+ 0x304E,
+ 0x304F,
+ 0x3050,
+ 0x3051,
+ 0x3052,
+ 0x3053,
+ 0x3054,
+ 0x3055,
+ 0x3056,
+ 0x3057,
+ 0x3058,
+ 0x3059,
+ 0x305A,
+ 0x305B,
+ 0x305C,
+ 0x305D,
+ 0x305E,
+ 0x305F,
+ 0x3060,
+ 0x3061,
+ 0x3062,
+ 0x3063,
+ 0x3064,
+ 0x3065,
+ 0x3066,
+ 0x3067,
+ 0x3068,
+ 0x3069,
+ 0x306A,
+ 0x306B,
+ 0x306C,
+ 0x306D,
+ 0x306E,
+ 0x306F,
+ 0x3070,
+ 0x3071,
+ 0x3072,
+ 0x3073,
+ 0x3074,
+ 0x3075,
+ 0x3076,
+ 0x3077,
+ 0x3078,
+ 0x3079,
+ 0x307A,
+ 0x307B,
+ 0x307C,
+ 0x307D,
+ 0x307E,
+ 0x307F,
+ 0x3080,
+ 0x3081,
+ 0x3082,
+ 0x3083,
+ 0x3084,
+ 0x3085,
+ 0x3086,
+ 0x3087,
+ 0x3088,
+ 0x3089,
+ 0x308A,
+ 0x308B,
+ 0x308C,
+ 0x308D,
+ 0x308E,
+ 0x308F,
+ 0x3090,
+ 0x3091,
+ 0x3092,
+ 0x3093,
+ 0x30A1,
+ 0x30A2,
+ 0x30A3,
+ 0x30A4,
+ 0x30A5,
+ 0x30A6,
+ 0x30A7,
+ 0x30A8,
+ 0x30A9,
+ 0x30AA,
+ 0x30AB,
+ 0x30AC,
+ 0x30AD,
+ 0x30AE,
+ 0x30AF,
+ 0x30B0,
+ 0x30B1,
+ 0x30B2,
+ 0x30B3,
+ 0x30B4,
+ 0x30B5,
+ 0x30B6,
+ 0x30B7,
+ 0x30B8,
+ 0x30B9,
+ 0x30BA,
+ 0x30BB,
+ 0x30BC,
+ 0x30BD,
+ 0x30BE,
+ 0x30BF,
+ 0x30C0,
+ 0x30C1,
+ 0x30C2,
+ 0x30C3,
+ 0x30C4,
+ 0x30C5,
+ 0x30C6,
+ 0x30C7,
+ 0x30C8,
+ 0x30C9,
+ 0x30CA,
+ 0x30CB,
+ 0x30CC,
+ 0x30CD,
+ 0x30CE,
+ 0x30CF,
+ 0x30D0,
+ 0x30D1,
+ 0x30D2,
+ 0x30D3,
+ 0x30D4,
+ 0x30D5,
+ 0x30D6,
+ 0x30D7,
+ 0x30D8,
+ 0x30D9,
+ 0x30DA,
+ 0x30DB,
+ 0x30DC,
+ 0x30DD,
+ 0x30DE,
+ 0x30DF,
+ 0x30E0,
+ 0x30E1,
+ 0x30E2,
+ 0x30E3,
+ 0x30E4,
+ 0x30E5,
+ 0x30E6,
+ 0x30E7,
+ 0x30E8,
+ 0x30E9,
+ 0x30EA,
+ 0x30EB,
+ 0x30EC,
+ 0x30ED,
+ 0x30EE,
+ 0x30EF,
+ 0x30F0,
+ 0x30F1,
+ 0x30F2,
+ 0x30F3,
+ 0x30F4,
+ 0x30F5,
+ 0x30F6,
+ 0x0391,
+ 0x0392,
+ 0x0393,
+ 0x0394,
+ 0x0395,
+ 0x0396,
+ 0x0397,
+ 0x0398,
+ 0x0399,
+ 0x039A,
+ 0x039B,
+ 0x039C,
+ 0x039D,
+ 0x039E,
+ 0x039F,
+ 0x03A0,
+ 0x03A1,
+ 0x03A3,
+ 0x03A4,
+ 0x03A5,
+ 0x03A6,
+ 0x03A7,
+ 0x03A8,
+ 0x03A9,
+ 0x03B1,
+ 0x03B2,
+ 0x03B3,
+ 0x03B4,
+ 0x03B5,
+ 0x03B6,
+ 0x03B7,
+ 0x03B8,
+ 0x03B9,
+ 0x03BA,
+ 0x03BB,
+ 0x03BC,
+ 0x03BD,
+ 0x03BE,
+ 0x03BF,
+ 0x03C0,
+ 0x03C1,
+ 0x03C3,
+ 0x03C4,
+ 0x03C5,
+ 0x03C6,
+ 0x03C7,
+ 0x03C8,
+ 0x03C9,
+ 0x0410,
+ 0x0411,
+ 0x0412,
+ 0x0413,
+ 0x0414,
+ 0x0415,
+ 0x0401,
+ 0x0416,
+ 0x0417,
+ 0x0418,
+ 0x0419,
+ 0x041A,
+ 0x041B,
+ 0x041C,
+ 0x041D,
+ 0x041E,
+ 0x041F,
+ 0x0420,
+ 0x0421,
+ 0x0422,
+ 0x0423,
+ 0x0424,
+ 0x0425,
+ 0x0426,
+ 0x0427,
+ 0x0428,
+ 0x0429,
+ 0x042A,
+ 0x042B,
+ 0x042C,
+ 0x042D,
+ 0x042E,
+ 0x042F,
+ 0x0430,
+ 0x0431,
+ 0x0432,
+ 0x0433,
+ 0x0434,
+ 0x0435,
+ 0x0451,
+ 0x0436,
+ 0x0437,
+ 0x0438,
+ 0x0439,
+ 0x043A,
+ 0x043B,
+ 0x043C,
+ 0x043D,
+ 0x043E,
+ 0x043F,
+ 0x0440,
+ 0x0441,
+ 0x0442,
+ 0x0443,
+ 0x0444,
+ 0x0445,
+ 0x0446,
+ 0x0447,
+ 0x0448,
+ 0x0449,
+ 0x044A,
+ 0x044B,
+ 0x044C,
+ 0x044D,
+ 0x044E,
+ 0x044F,
+ 0x2500,
+ 0x2502,
+ 0x250C,
+ 0x2510,
+ 0x2518,
+ 0x2514,
+ 0x251C,
+ 0x252C,
+ 0x2524,
+ 0x2534,
+ 0x253C,
+ 0x2501,
+ 0x2503,
+ 0x250F,
+ 0x2513,
+ 0x251B,
+ 0x2517,
+ 0x2523,
+ 0x2533,
+ 0x252B,
+ 0x253B,
+ 0x254B,
+ 0x2520,
+ 0x252F,
+ 0x2528,
+ 0x2537,
+ 0x253F,
+ 0x251D,
+ 0x2530,
+ 0x2525,
+ 0x2538,
+ 0x2542,
+ 0x4E9C,
+ 0x5516,
+ 0x5A03,
+ 0x963F,
+ 0x54C0,
+ 0x611B,
+ 0x6328,
+ 0x59F6,
+ 0x9022,
+ 0x8475,
+ 0x831C,
+ 0x7A50,
+ 0x60AA,
+ 0x63E1,
+ 0x6E25,
+ 0x65ED,
+ 0x8466,
+ 0x82A6,
+ 0x9BF5,
+ 0x6893,
+ 0x5727,
+ 0x65A1,
+ 0x6271,
+ 0x5B9B,
+ 0x59D0,
+ 0x867B,
+ 0x98F4,
+ 0x7D62,
+ 0x7DBE,
+ 0x9B8E,
+ 0x6216,
+ 0x7C9F,
+ 0x88B7,
+ 0x5B89,
+ 0x5EB5,
+ 0x6309,
+ 0x6697,
+ 0x6848,
+ 0x95C7,
+ 0x978D,
+ 0x674F,
+ 0x4EE5,
+ 0x4F0A,
+ 0x4F4D,
+ 0x4F9D,
+ 0x5049,
+ 0x56F2,
+ 0x5937,
+ 0x59D4,
+ 0x5A01,
+ 0x5C09,
+ 0x60DF,
+ 0x610F,
+ 0x6170,
+ 0x6613,
+ 0x6905,
+ 0x70BA,
+ 0x754F,
+ 0x7570,
+ 0x79FB,
+ 0x7DAD,
+ 0x7DEF,
+ 0x80C3,
+ 0x840E,
+ 0x8863,
+ 0x8B02,
+ 0x9055,
+ 0x907A,
+ 0x533B,
+ 0x4E95,
+ 0x4EA5,
+ 0x57DF,
+ 0x80B2,
+ 0x90C1,
+ 0x78EF,
+ 0x4E00,
+ 0x58F1,
+ 0x6EA2,
+ 0x9038,
+ 0x7A32,
+ 0x8328,
+ 0x828B,
+ 0x9C2F,
+ 0x5141,
+ 0x5370,
+ 0x54BD,
+ 0x54E1,
+ 0x56E0,
+ 0x59FB,
+ 0x5F15,
+ 0x98F2,
+ 0x6DEB,
+ 0x80E4,
+ 0x852D,
+ 0x9662,
+ 0x9670,
+ 0x96A0,
+ 0x97FB,
+ 0x540B,
+ 0x53F3,
+ 0x5B87,
+ 0x70CF,
+ 0x7FBD,
+ 0x8FC2,
+ 0x96E8,
+ 0x536F,
+ 0x9D5C,
+ 0x7ABA,
+ 0x4E11,
+ 0x7893,
+ 0x81FC,
+ 0x6E26,
+ 0x5618,
+ 0x5504,
+ 0x6B1D,
+ 0x851A,
+ 0x9C3B,
+ 0x59E5,
+ 0x53A9,
+ 0x6D66,
+ 0x74DC,
+ 0x958F,
+ 0x5642,
+ 0x4E91,
+ 0x904B,
+ 0x96F2,
+ 0x834F,
+ 0x990C,
+ 0x53E1,
+ 0x55B6,
+ 0x5B30,
+ 0x5F71,
+ 0x6620,
+ 0x66F3,
+ 0x6804,
+ 0x6C38,
+ 0x6CF3,
+ 0x6D29,
+ 0x745B,
+ 0x76C8,
+ 0x7A4E,
+ 0x9834,
+ 0x82F1,
+ 0x885B,
+ 0x8A60,
+ 0x92ED,
+ 0x6DB2,
+ 0x75AB,
+ 0x76CA,
+ 0x99C5,
+ 0x60A6,
+ 0x8B01,
+ 0x8D8A,
+ 0x95B2,
+ 0x698E,
+ 0x53AD,
+ 0x5186,
+ 0x5712,
+ 0x5830,
+ 0x5944,
+ 0x5BB4,
+ 0x5EF6,
+ 0x6028,
+ 0x63A9,
+ 0x63F4,
+ 0x6CBF,
+ 0x6F14,
+ 0x708E,
+ 0x7114,
+ 0x7159,
+ 0x71D5,
+ 0x733F,
+ 0x7E01,
+ 0x8276,
+ 0x82D1,
+ 0x8597,
+ 0x9060,
+ 0x925B,
+ 0x9D1B,
+ 0x5869,
+ 0x65BC,
+ 0x6C5A,
+ 0x7525,
+ 0x51F9,
+ 0x592E,
+ 0x5965,
+ 0x5F80,
+ 0x5FDC,
+ 0x62BC,
+ 0x65FA,
+ 0x6A2A,
+ 0x6B27,
+ 0x6BB4,
+ 0x738B,
+ 0x7FC1,
+ 0x8956,
+ 0x9D2C,
+ 0x9D0E,
+ 0x9EC4,
+ 0x5CA1,
+ 0x6C96,
+ 0x837B,
+ 0x5104,
+ 0x5C4B,
+ 0x61B6,
+ 0x81C6,
+ 0x6876,
+ 0x7261,
+ 0x4E59,
+ 0x4FFA,
+ 0x5378,
+ 0x6069,
+ 0x6E29,
+ 0x7A4F,
+ 0x97F3,
+ 0x4E0B,
+ 0x5316,
+ 0x4EEE,
+ 0x4F55,
+ 0x4F3D,
+ 0x4FA1,
+ 0x4F73,
+ 0x52A0,
+ 0x53EF,
+ 0x5609,
+ 0x590F,
+ 0x5AC1,
+ 0x5BB6,
+ 0x5BE1,
+ 0x79D1,
+ 0x6687,
+ 0x679C,
+ 0x67B6,
+ 0x6B4C,
+ 0x6CB3,
+ 0x706B,
+ 0x73C2,
+ 0x798D,
+ 0x79BE,
+ 0x7A3C,
+ 0x7B87,
+ 0x82B1,
+ 0x82DB,
+ 0x8304,
+ 0x8377,
+ 0x83EF,
+ 0x83D3,
+ 0x8766,
+ 0x8AB2,
+ 0x5629,
+ 0x8CA8,
+ 0x8FE6,
+ 0x904E,
+ 0x971E,
+ 0x868A,
+ 0x4FC4,
+ 0x5CE8,
+ 0x6211,
+ 0x7259,
+ 0x753B,
+ 0x81E5,
+ 0x82BD,
+ 0x86FE,
+ 0x8CC0,
+ 0x96C5,
+ 0x9913,
+ 0x99D5,
+ 0x4ECB,
+ 0x4F1A,
+ 0x89E3,
+ 0x56DE,
+ 0x584A,
+ 0x58CA,
+ 0x5EFB,
+ 0x5FEB,
+ 0x602A,
+ 0x6094,
+ 0x6062,
+ 0x61D0,
+ 0x6212,
+ 0x62D0,
+ 0x6539,
+ 0x9B41,
+ 0x6666,
+ 0x68B0,
+ 0x6D77,
+ 0x7070,
+ 0x754C,
+ 0x7686,
+ 0x7D75,
+ 0x82A5,
+ 0x87F9,
+ 0x958B,
+ 0x968E,
+ 0x8C9D,
+ 0x51F1,
+ 0x52BE,
+ 0x5916,
+ 0x54B3,
+ 0x5BB3,
+ 0x5D16,
+ 0x6168,
+ 0x6982,
+ 0x6DAF,
+ 0x788D,
+ 0x84CB,
+ 0x8857,
+ 0x8A72,
+ 0x93A7,
+ 0x9AB8,
+ 0x6D6C,
+ 0x99A8,
+ 0x86D9,
+ 0x57A3,
+ 0x67FF,
+ 0x86CE,
+ 0x920E,
+ 0x5283,
+ 0x5687,
+ 0x5404,
+ 0x5ED3,
+ 0x62E1,
+ 0x64B9,
+ 0x683C,
+ 0x6838,
+ 0x6BBB,
+ 0x7372,
+ 0x78BA,
+ 0x7A6B,
+ 0x899A,
+ 0x89D2,
+ 0x8D6B,
+ 0x8F03,
+ 0x90ED,
+ 0x95A3,
+ 0x9694,
+ 0x9769,
+ 0x5B66,
+ 0x5CB3,
+ 0x697D,
+ 0x984D,
+ 0x984E,
+ 0x639B,
+ 0x7B20,
+ 0x6A2B,
+ 0x6A7F,
+ 0x68B6,
+ 0x9C0D,
+ 0x6F5F,
+ 0x5272,
+ 0x559D,
+ 0x6070,
+ 0x62EC,
+ 0x6D3B,
+ 0x6E07,
+ 0x6ED1,
+ 0x845B,
+ 0x8910,
+ 0x8F44,
+ 0x4E14,
+ 0x9C39,
+ 0x53F6,
+ 0x691B,
+ 0x6A3A,
+ 0x9784,
+ 0x682A,
+ 0x515C,
+ 0x7AC3,
+ 0x84B2,
+ 0x91DC,
+ 0x938C,
+ 0x565B,
+ 0x9D28,
+ 0x6822,
+ 0x8305,
+ 0x8431,
+ 0x7CA5,
+ 0x5208,
+ 0x82C5,
+ 0x74E6,
+ 0x4E7E,
+ 0x4F83,
+ 0x51A0,
+ 0x5BD2,
+ 0x520A,
+ 0x52D8,
+ 0x52E7,
+ 0x5DFB,
+ 0x559A,
+ 0x582A,
+ 0x59E6,
+ 0x5B8C,
+ 0x5B98,
+ 0x5BDB,
+ 0x5E72,
+ 0x5E79,
+ 0x60A3,
+ 0x611F,
+ 0x6163,
+ 0x61BE,
+ 0x63DB,
+ 0x6562,
+ 0x67D1,
+ 0x6853,
+ 0x68FA,
+ 0x6B3E,
+ 0x6B53,
+ 0x6C57,
+ 0x6F22,
+ 0x6F97,
+ 0x6F45,
+ 0x74B0,
+ 0x7518,
+ 0x76E3,
+ 0x770B,
+ 0x7AFF,
+ 0x7BA1,
+ 0x7C21,
+ 0x7DE9,
+ 0x7F36,
+ 0x7FF0,
+ 0x809D,
+ 0x8266,
+ 0x839E,
+ 0x89B3,
+ 0x8ACC,
+ 0x8CAB,
+ 0x9084,
+ 0x9451,
+ 0x9593,
+ 0x9591,
+ 0x95A2,
+ 0x9665,
+ 0x97D3,
+ 0x9928,
+ 0x8218,
+ 0x4E38,
+ 0x542B,
+ 0x5CB8,
+ 0x5DCC,
+ 0x73A9,
+ 0x764C,
+ 0x773C,
+ 0x5CA9,
+ 0x7FEB,
+ 0x8D0B,
+ 0x96C1,
+ 0x9811,
+ 0x9854,
+ 0x9858,
+ 0x4F01,
+ 0x4F0E,
+ 0x5371,
+ 0x559C,
+ 0x5668,
+ 0x57FA,
+ 0x5947,
+ 0x5B09,
+ 0x5BC4,
+ 0x5C90,
+ 0x5E0C,
+ 0x5E7E,
+ 0x5FCC,
+ 0x63EE,
+ 0x673A,
+ 0x65D7,
+ 0x65E2,
+ 0x671F,
+ 0x68CB,
+ 0x68C4,
+ 0x6A5F,
+ 0x5E30,
+ 0x6BC5,
+ 0x6C17,
+ 0x6C7D,
+ 0x757F,
+ 0x7948,
+ 0x5B63,
+ 0x7A00,
+ 0x7D00,
+ 0x5FBD,
+ 0x898F,
+ 0x8A18,
+ 0x8CB4,
+ 0x8D77,
+ 0x8ECC,
+ 0x8F1D,
+ 0x98E2,
+ 0x9A0E,
+ 0x9B3C,
+ 0x4E80,
+ 0x507D,
+ 0x5100,
+ 0x5993,
+ 0x5B9C,
+ 0x622F,
+ 0x6280,
+ 0x64EC,
+ 0x6B3A,
+ 0x72A0,
+ 0x7591,
+ 0x7947,
+ 0x7FA9,
+ 0x87FB,
+ 0x8ABC,
+ 0x8B70,
+ 0x63AC,
+ 0x83CA,
+ 0x97A0,
+ 0x5409,
+ 0x5403,
+ 0x55AB,
+ 0x6854,
+ 0x6A58,
+ 0x8A70,
+ 0x7827,
+ 0x6775,
+ 0x9ECD,
+ 0x5374,
+ 0x5BA2,
+ 0x811A,
+ 0x8650,
+ 0x9006,
+ 0x4E18,
+ 0x4E45,
+ 0x4EC7,
+ 0x4F11,
+ 0x53CA,
+ 0x5438,
+ 0x5BAE,
+ 0x5F13,
+ 0x6025,
+ 0x6551,
+ 0x673D,
+ 0x6C42,
+ 0x6C72,
+ 0x6CE3,
+ 0x7078,
+ 0x7403,
+ 0x7A76,
+ 0x7AAE,
+ 0x7B08,
+ 0x7D1A,
+ 0x7CFE,
+ 0x7D66,
+ 0x65E7,
+ 0x725B,
+ 0x53BB,
+ 0x5C45,
+ 0x5DE8,
+ 0x62D2,
+ 0x62E0,
+ 0x6319,
+ 0x6E20,
+ 0x865A,
+ 0x8A31,
+ 0x8DDD,
+ 0x92F8,
+ 0x6F01,
+ 0x79A6,
+ 0x9B5A,
+ 0x4EA8,
+ 0x4EAB,
+ 0x4EAC,
+ 0x4F9B,
+ 0x4FA0,
+ 0x50D1,
+ 0x5147,
+ 0x7AF6,
+ 0x5171,
+ 0x51F6,
+ 0x5354,
+ 0x5321,
+ 0x537F,
+ 0x53EB,
+ 0x55AC,
+ 0x5883,
+ 0x5CE1,
+ 0x5F37,
+ 0x5F4A,
+ 0x602F,
+ 0x6050,
+ 0x606D,
+ 0x631F,
+ 0x6559,
+ 0x6A4B,
+ 0x6CC1,
+ 0x72C2,
+ 0x72ED,
+ 0x77EF,
+ 0x80F8,
+ 0x8105,
+ 0x8208,
+ 0x854E,
+ 0x90F7,
+ 0x93E1,
+ 0x97FF,
+ 0x9957,
+ 0x9A5A,
+ 0x4EF0,
+ 0x51DD,
+ 0x5C2D,
+ 0x6681,
+ 0x696D,
+ 0x5C40,
+ 0x66F2,
+ 0x6975,
+ 0x7389,
+ 0x6850,
+ 0x7C81,
+ 0x50C5,
+ 0x52E4,
+ 0x5747,
+ 0x5DFE,
+ 0x9326,
+ 0x65A4,
+ 0x6B23,
+ 0x6B3D,
+ 0x7434,
+ 0x7981,
+ 0x79BD,
+ 0x7B4B,
+ 0x7DCA,
+ 0x82B9,
+ 0x83CC,
+ 0x887F,
+ 0x895F,
+ 0x8B39,
+ 0x8FD1,
+ 0x91D1,
+ 0x541F,
+ 0x9280,
+ 0x4E5D,
+ 0x5036,
+ 0x53E5,
+ 0x533A,
+ 0x72D7,
+ 0x7396,
+ 0x77E9,
+ 0x82E6,
+ 0x8EAF,
+ 0x99C6,
+ 0x99C8,
+ 0x99D2,
+ 0x5177,
+ 0x611A,
+ 0x865E,
+ 0x55B0,
+ 0x7A7A,
+ 0x5076,
+ 0x5BD3,
+ 0x9047,
+ 0x9685,
+ 0x4E32,
+ 0x6ADB,
+ 0x91E7,
+ 0x5C51,
+ 0x5C48,
+ 0x6398,
+ 0x7A9F,
+ 0x6C93,
+ 0x9774,
+ 0x8F61,
+ 0x7AAA,
+ 0x718A,
+ 0x9688,
+ 0x7C82,
+ 0x6817,
+ 0x7E70,
+ 0x6851,
+ 0x936C,
+ 0x52F2,
+ 0x541B,
+ 0x85AB,
+ 0x8A13,
+ 0x7FA4,
+ 0x8ECD,
+ 0x90E1,
+ 0x5366,
+ 0x8888,
+ 0x7941,
+ 0x4FC2,
+ 0x50BE,
+ 0x5211,
+ 0x5144,
+ 0x5553,
+ 0x572D,
+ 0x73EA,
+ 0x578B,
+ 0x5951,
+ 0x5F62,
+ 0x5F84,
+ 0x6075,
+ 0x6176,
+ 0x6167,
+ 0x61A9,
+ 0x63B2,
+ 0x643A,
+ 0x656C,
+ 0x666F,
+ 0x6842,
+ 0x6E13,
+ 0x7566,
+ 0x7A3D,
+ 0x7CFB,
+ 0x7D4C,
+ 0x7D99,
+ 0x7E4B,
+ 0x7F6B,
+ 0x830E,
+ 0x834A,
+ 0x86CD,
+ 0x8A08,
+ 0x8A63,
+ 0x8B66,
+ 0x8EFD,
+ 0x981A,
+ 0x9D8F,
+ 0x82B8,
+ 0x8FCE,
+ 0x9BE8,
+ 0x5287,
+ 0x621F,
+ 0x6483,
+ 0x6FC0,
+ 0x9699,
+ 0x6841,
+ 0x5091,
+ 0x6B20,
+ 0x6C7A,
+ 0x6F54,
+ 0x7A74,
+ 0x7D50,
+ 0x8840,
+ 0x8A23,
+ 0x6708,
+ 0x4EF6,
+ 0x5039,
+ 0x5026,
+ 0x5065,
+ 0x517C,
+ 0x5238,
+ 0x5263,
+ 0x55A7,
+ 0x570F,
+ 0x5805,
+ 0x5ACC,
+ 0x5EFA,
+ 0x61B2,
+ 0x61F8,
+ 0x62F3,
+ 0x6372,
+ 0x691C,
+ 0x6A29,
+ 0x727D,
+ 0x72AC,
+ 0x732E,
+ 0x7814,
+ 0x786F,
+ 0x7D79,
+ 0x770C,
+ 0x80A9,
+ 0x898B,
+ 0x8B19,
+ 0x8CE2,
+ 0x8ED2,
+ 0x9063,
+ 0x9375,
+ 0x967A,
+ 0x9855,
+ 0x9A13,
+ 0x9E78,
+ 0x5143,
+ 0x539F,
+ 0x53B3,
+ 0x5E7B,
+ 0x5F26,
+ 0x6E1B,
+ 0x6E90,
+ 0x7384,
+ 0x73FE,
+ 0x7D43,
+ 0x8237,
+ 0x8A00,
+ 0x8AFA,
+ 0x9650,
+ 0x4E4E,
+ 0x500B,
+ 0x53E4,
+ 0x547C,
+ 0x56FA,
+ 0x59D1,
+ 0x5B64,
+ 0x5DF1,
+ 0x5EAB,
+ 0x5F27,
+ 0x6238,
+ 0x6545,
+ 0x67AF,
+ 0x6E56,
+ 0x72D0,
+ 0x7CCA,
+ 0x88B4,
+ 0x80A1,
+ 0x80E1,
+ 0x83F0,
+ 0x864E,
+ 0x8A87,
+ 0x8DE8,
+ 0x9237,
+ 0x96C7,
+ 0x9867,
+ 0x9F13,
+ 0x4E94,
+ 0x4E92,
+ 0x4F0D,
+ 0x5348,
+ 0x5449,
+ 0x543E,
+ 0x5A2F,
+ 0x5F8C,
+ 0x5FA1,
+ 0x609F,
+ 0x68A7,
+ 0x6A8E,
+ 0x745A,
+ 0x7881,
+ 0x8A9E,
+ 0x8AA4,
+ 0x8B77,
+ 0x9190,
+ 0x4E5E,
+ 0x9BC9,
+ 0x4EA4,
+ 0x4F7C,
+ 0x4FAF,
+ 0x5019,
+ 0x5016,
+ 0x5149,
+ 0x516C,
+ 0x529F,
+ 0x52B9,
+ 0x52FE,
+ 0x539A,
+ 0x53E3,
+ 0x5411,
+ 0x540E,
+ 0x5589,
+ 0x5751,
+ 0x57A2,
+ 0x597D,
+ 0x5B54,
+ 0x5B5D,
+ 0x5B8F,
+ 0x5DE5,
+ 0x5DE7,
+ 0x5DF7,
+ 0x5E78,
+ 0x5E83,
+ 0x5E9A,
+ 0x5EB7,
+ 0x5F18,
+ 0x6052,
+ 0x614C,
+ 0x6297,
+ 0x62D8,
+ 0x63A7,
+ 0x653B,
+ 0x6602,
+ 0x6643,
+ 0x66F4,
+ 0x676D,
+ 0x6821,
+ 0x6897,
+ 0x69CB,
+ 0x6C5F,
+ 0x6D2A,
+ 0x6D69,
+ 0x6E2F,
+ 0x6E9D,
+ 0x7532,
+ 0x7687,
+ 0x786C,
+ 0x7A3F,
+ 0x7CE0,
+ 0x7D05,
+ 0x7D18,
+ 0x7D5E,
+ 0x7DB1,
+ 0x8015,
+ 0x8003,
+ 0x80AF,
+ 0x80B1,
+ 0x8154,
+ 0x818F,
+ 0x822A,
+ 0x8352,
+ 0x884C,
+ 0x8861,
+ 0x8B1B,
+ 0x8CA2,
+ 0x8CFC,
+ 0x90CA,
+ 0x9175,
+ 0x9271,
+ 0x783F,
+ 0x92FC,
+ 0x95A4,
+ 0x964D,
+ 0x9805,
+ 0x9999,
+ 0x9AD8,
+ 0x9D3B,
+ 0x525B,
+ 0x52AB,
+ 0x53F7,
+ 0x5408,
+ 0x58D5,
+ 0x62F7,
+ 0x6FE0,
+ 0x8C6A,
+ 0x8F5F,
+ 0x9EB9,
+ 0x514B,
+ 0x523B,
+ 0x544A,
+ 0x56FD,
+ 0x7A40,
+ 0x9177,
+ 0x9D60,
+ 0x9ED2,
+ 0x7344,
+ 0x6F09,
+ 0x8170,
+ 0x7511,
+ 0x5FFD,
+ 0x60DA,
+ 0x9AA8,
+ 0x72DB,
+ 0x8FBC,
+ 0x6B64,
+ 0x9803,
+ 0x4ECA,
+ 0x56F0,
+ 0x5764,
+ 0x58BE,
+ 0x5A5A,
+ 0x6068,
+ 0x61C7,
+ 0x660F,
+ 0x6606,
+ 0x6839,
+ 0x68B1,
+ 0x6DF7,
+ 0x75D5,
+ 0x7D3A,
+ 0x826E,
+ 0x9B42,
+ 0x4E9B,
+ 0x4F50,
+ 0x53C9,
+ 0x5506,
+ 0x5D6F,
+ 0x5DE6,
+ 0x5DEE,
+ 0x67FB,
+ 0x6C99,
+ 0x7473,
+ 0x7802,
+ 0x8A50,
+ 0x9396,
+ 0x88DF,
+ 0x5750,
+ 0x5EA7,
+ 0x632B,
+ 0x50B5,
+ 0x50AC,
+ 0x518D,
+ 0x6700,
+ 0x54C9,
+ 0x585E,
+ 0x59BB,
+ 0x5BB0,
+ 0x5F69,
+ 0x624D,
+ 0x63A1,
+ 0x683D,
+ 0x6B73,
+ 0x6E08,
+ 0x707D,
+ 0x91C7,
+ 0x7280,
+ 0x7815,
+ 0x7826,
+ 0x796D,
+ 0x658E,
+ 0x7D30,
+ 0x83DC,
+ 0x88C1,
+ 0x8F09,
+ 0x969B,
+ 0x5264,
+ 0x5728,
+ 0x6750,
+ 0x7F6A,
+ 0x8CA1,
+ 0x51B4,
+ 0x5742,
+ 0x962A,
+ 0x583A,
+ 0x698A,
+ 0x80B4,
+ 0x54B2,
+ 0x5D0E,
+ 0x57FC,
+ 0x7895,
+ 0x9DFA,
+ 0x4F5C,
+ 0x524A,
+ 0x548B,
+ 0x643E,
+ 0x6628,
+ 0x6714,
+ 0x67F5,
+ 0x7A84,
+ 0x7B56,
+ 0x7D22,
+ 0x932F,
+ 0x685C,
+ 0x9BAD,
+ 0x7B39,
+ 0x5319,
+ 0x518A,
+ 0x5237,
+ 0x5BDF,
+ 0x62F6,
+ 0x64AE,
+ 0x64E6,
+ 0x672D,
+ 0x6BBA,
+ 0x85A9,
+ 0x96D1,
+ 0x7690,
+ 0x9BD6,
+ 0x634C,
+ 0x9306,
+ 0x9BAB,
+ 0x76BF,
+ 0x6652,
+ 0x4E09,
+ 0x5098,
+ 0x53C2,
+ 0x5C71,
+ 0x60E8,
+ 0x6492,
+ 0x6563,
+ 0x685F,
+ 0x71E6,
+ 0x73CA,
+ 0x7523,
+ 0x7B97,
+ 0x7E82,
+ 0x8695,
+ 0x8B83,
+ 0x8CDB,
+ 0x9178,
+ 0x9910,
+ 0x65AC,
+ 0x66AB,
+ 0x6B8B,
+ 0x4ED5,
+ 0x4ED4,
+ 0x4F3A,
+ 0x4F7F,
+ 0x523A,
+ 0x53F8,
+ 0x53F2,
+ 0x55E3,
+ 0x56DB,
+ 0x58EB,
+ 0x59CB,
+ 0x59C9,
+ 0x59FF,
+ 0x5B50,
+ 0x5C4D,
+ 0x5E02,
+ 0x5E2B,
+ 0x5FD7,
+ 0x601D,
+ 0x6307,
+ 0x652F,
+ 0x5B5C,
+ 0x65AF,
+ 0x65BD,
+ 0x65E8,
+ 0x679D,
+ 0x6B62,
+ 0x6B7B,
+ 0x6C0F,
+ 0x7345,
+ 0x7949,
+ 0x79C1,
+ 0x7CF8,
+ 0x7D19,
+ 0x7D2B,
+ 0x80A2,
+ 0x8102,
+ 0x81F3,
+ 0x8996,
+ 0x8A5E,
+ 0x8A69,
+ 0x8A66,
+ 0x8A8C,
+ 0x8AEE,
+ 0x8CC7,
+ 0x8CDC,
+ 0x96CC,
+ 0x98FC,
+ 0x6B6F,
+ 0x4E8B,
+ 0x4F3C,
+ 0x4F8D,
+ 0x5150,
+ 0x5B57,
+ 0x5BFA,
+ 0x6148,
+ 0x6301,
+ 0x6642,
+ 0x6B21,
+ 0x6ECB,
+ 0x6CBB,
+ 0x723E,
+ 0x74BD,
+ 0x75D4,
+ 0x78C1,
+ 0x793A,
+ 0x800C,
+ 0x8033,
+ 0x81EA,
+ 0x8494,
+ 0x8F9E,
+ 0x6C50,
+ 0x9E7F,
+ 0x5F0F,
+ 0x8B58,
+ 0x9D2B,
+ 0x7AFA,
+ 0x8EF8,
+ 0x5B8D,
+ 0x96EB,
+ 0x4E03,
+ 0x53F1,
+ 0x57F7,
+ 0x5931,
+ 0x5AC9,
+ 0x5BA4,
+ 0x6089,
+ 0x6E7F,
+ 0x6F06,
+ 0x75BE,
+ 0x8CEA,
+ 0x5B9F,
+ 0x8500,
+ 0x7BE0,
+ 0x5072,
+ 0x67F4,
+ 0x829D,
+ 0x5C61,
+ 0x854A,
+ 0x7E1E,
+ 0x820E,
+ 0x5199,
+ 0x5C04,
+ 0x6368,
+ 0x8D66,
+ 0x659C,
+ 0x716E,
+ 0x793E,
+ 0x7D17,
+ 0x8005,
+ 0x8B1D,
+ 0x8ECA,
+ 0x906E,
+ 0x86C7,
+ 0x90AA,
+ 0x501F,
+ 0x52FA,
+ 0x5C3A,
+ 0x6753,
+ 0x707C,
+ 0x7235,
+ 0x914C,
+ 0x91C8,
+ 0x932B,
+ 0x82E5,
+ 0x5BC2,
+ 0x5F31,
+ 0x60F9,
+ 0x4E3B,
+ 0x53D6,
+ 0x5B88,
+ 0x624B,
+ 0x6731,
+ 0x6B8A,
+ 0x72E9,
+ 0x73E0,
+ 0x7A2E,
+ 0x816B,
+ 0x8DA3,
+ 0x9152,
+ 0x9996,
+ 0x5112,
+ 0x53D7,
+ 0x546A,
+ 0x5BFF,
+ 0x6388,
+ 0x6A39,
+ 0x7DAC,
+ 0x9700,
+ 0x56DA,
+ 0x53CE,
+ 0x5468,
+ 0x5B97,
+ 0x5C31,
+ 0x5DDE,
+ 0x4FEE,
+ 0x6101,
+ 0x62FE,
+ 0x6D32,
+ 0x79C0,
+ 0x79CB,
+ 0x7D42,
+ 0x7E4D,
+ 0x7FD2,
+ 0x81ED,
+ 0x821F,
+ 0x8490,
+ 0x8846,
+ 0x8972,
+ 0x8B90,
+ 0x8E74,
+ 0x8F2F,
+ 0x9031,
+ 0x914B,
+ 0x916C,
+ 0x96C6,
+ 0x919C,
+ 0x4EC0,
+ 0x4F4F,
+ 0x5145,
+ 0x5341,
+ 0x5F93,
+ 0x620E,
+ 0x67D4,
+ 0x6C41,
+ 0x6E0B,
+ 0x7363,
+ 0x7E26,
+ 0x91CD,
+ 0x9283,
+ 0x53D4,
+ 0x5919,
+ 0x5BBF,
+ 0x6DD1,
+ 0x795D,
+ 0x7E2E,
+ 0x7C9B,
+ 0x587E,
+ 0x719F,
+ 0x51FA,
+ 0x8853,
+ 0x8FF0,
+ 0x4FCA,
+ 0x5CFB,
+ 0x6625,
+ 0x77AC,
+ 0x7AE3,
+ 0x821C,
+ 0x99FF,
+ 0x51C6,
+ 0x5FAA,
+ 0x65EC,
+ 0x696F,
+ 0x6B89,
+ 0x6DF3,
+ 0x6E96,
+ 0x6F64,
+ 0x76FE,
+ 0x7D14,
+ 0x5DE1,
+ 0x9075,
+ 0x9187,
+ 0x9806,
+ 0x51E6,
+ 0x521D,
+ 0x6240,
+ 0x6691,
+ 0x66D9,
+ 0x6E1A,
+ 0x5EB6,
+ 0x7DD2,
+ 0x7F72,
+ 0x66F8,
+ 0x85AF,
+ 0x85F7,
+ 0x8AF8,
+ 0x52A9,
+ 0x53D9,
+ 0x5973,
+ 0x5E8F,
+ 0x5F90,
+ 0x6055,
+ 0x92E4,
+ 0x9664,
+ 0x50B7,
+ 0x511F,
+ 0x52DD,
+ 0x5320,
+ 0x5347,
+ 0x53EC,
+ 0x54E8,
+ 0x5546,
+ 0x5531,
+ 0x5617,
+ 0x5968,
+ 0x59BE,
+ 0x5A3C,
+ 0x5BB5,
+ 0x5C06,
+ 0x5C0F,
+ 0x5C11,
+ 0x5C1A,
+ 0x5E84,
+ 0x5E8A,
+ 0x5EE0,
+ 0x5F70,
+ 0x627F,
+ 0x6284,
+ 0x62DB,
+ 0x638C,
+ 0x6377,
+ 0x6607,
+ 0x660C,
+ 0x662D,
+ 0x6676,
+ 0x677E,
+ 0x68A2,
+ 0x6A1F,
+ 0x6A35,
+ 0x6CBC,
+ 0x6D88,
+ 0x6E09,
+ 0x6E58,
+ 0x713C,
+ 0x7126,
+ 0x7167,
+ 0x75C7,
+ 0x7701,
+ 0x785D,
+ 0x7901,
+ 0x7965,
+ 0x79F0,
+ 0x7AE0,
+ 0x7B11,
+ 0x7CA7,
+ 0x7D39,
+ 0x8096,
+ 0x83D6,
+ 0x848B,
+ 0x8549,
+ 0x885D,
+ 0x88F3,
+ 0x8A1F,
+ 0x8A3C,
+ 0x8A54,
+ 0x8A73,
+ 0x8C61,
+ 0x8CDE,
+ 0x91A4,
+ 0x9266,
+ 0x937E,
+ 0x9418,
+ 0x969C,
+ 0x9798,
+ 0x4E0A,
+ 0x4E08,
+ 0x4E1E,
+ 0x4E57,
+ 0x5197,
+ 0x5270,
+ 0x57CE,
+ 0x5834,
+ 0x58CC,
+ 0x5B22,
+ 0x5E38,
+ 0x60C5,
+ 0x64FE,
+ 0x6761,
+ 0x6756,
+ 0x6D44,
+ 0x72B6,
+ 0x7573,
+ 0x7A63,
+ 0x84B8,
+ 0x8B72,
+ 0x91B8,
+ 0x9320,
+ 0x5631,
+ 0x57F4,
+ 0x98FE,
+ 0x62ED,
+ 0x690D,
+ 0x6B96,
+ 0x71ED,
+ 0x7E54,
+ 0x8077,
+ 0x8272,
+ 0x89E6,
+ 0x98DF,
+ 0x8755,
+ 0x8FB1,
+ 0x5C3B,
+ 0x4F38,
+ 0x4FE1,
+ 0x4FB5,
+ 0x5507,
+ 0x5A20,
+ 0x5BDD,
+ 0x5BE9,
+ 0x5FC3,
+ 0x614E,
+ 0x632F,
+ 0x65B0,
+ 0x664B,
+ 0x68EE,
+ 0x699B,
+ 0x6D78,
+ 0x6DF1,
+ 0x7533,
+ 0x75B9,
+ 0x771F,
+ 0x795E,
+ 0x79E6,
+ 0x7D33,
+ 0x81E3,
+ 0x82AF,
+ 0x85AA,
+ 0x89AA,
+ 0x8A3A,
+ 0x8EAB,
+ 0x8F9B,
+ 0x9032,
+ 0x91DD,
+ 0x9707,
+ 0x4EBA,
+ 0x4EC1,
+ 0x5203,
+ 0x5875,
+ 0x58EC,
+ 0x5C0B,
+ 0x751A,
+ 0x5C3D,
+ 0x814E,
+ 0x8A0A,
+ 0x8FC5,
+ 0x9663,
+ 0x976D,
+ 0x7B25,
+ 0x8ACF,
+ 0x9808,
+ 0x9162,
+ 0x56F3,
+ 0x53A8,
+ 0x9017,
+ 0x5439,
+ 0x5782,
+ 0x5E25,
+ 0x63A8,
+ 0x6C34,
+ 0x708A,
+ 0x7761,
+ 0x7C8B,
+ 0x7FE0,
+ 0x8870,
+ 0x9042,
+ 0x9154,
+ 0x9310,
+ 0x9318,
+ 0x968F,
+ 0x745E,
+ 0x9AC4,
+ 0x5D07,
+ 0x5D69,
+ 0x6570,
+ 0x67A2,
+ 0x8DA8,
+ 0x96DB,
+ 0x636E,
+ 0x6749,
+ 0x6919,
+ 0x83C5,
+ 0x9817,
+ 0x96C0,
+ 0x88FE,
+ 0x6F84,
+ 0x647A,
+ 0x5BF8,
+ 0x4E16,
+ 0x702C,
+ 0x755D,
+ 0x662F,
+ 0x51C4,
+ 0x5236,
+ 0x52E2,
+ 0x59D3,
+ 0x5F81,
+ 0x6027,
+ 0x6210,
+ 0x653F,
+ 0x6574,
+ 0x661F,
+ 0x6674,
+ 0x68F2,
+ 0x6816,
+ 0x6B63,
+ 0x6E05,
+ 0x7272,
+ 0x751F,
+ 0x76DB,
+ 0x7CBE,
+ 0x8056,
+ 0x58F0,
+ 0x88FD,
+ 0x897F,
+ 0x8AA0,
+ 0x8A93,
+ 0x8ACB,
+ 0x901D,
+ 0x9192,
+ 0x9752,
+ 0x9759,
+ 0x6589,
+ 0x7A0E,
+ 0x8106,
+ 0x96BB,
+ 0x5E2D,
+ 0x60DC,
+ 0x621A,
+ 0x65A5,
+ 0x6614,
+ 0x6790,
+ 0x77F3,
+ 0x7A4D,
+ 0x7C4D,
+ 0x7E3E,
+ 0x810A,
+ 0x8CAC,
+ 0x8D64,
+ 0x8DE1,
+ 0x8E5F,
+ 0x78A9,
+ 0x5207,
+ 0x62D9,
+ 0x63A5,
+ 0x6442,
+ 0x6298,
+ 0x8A2D,
+ 0x7A83,
+ 0x7BC0,
+ 0x8AAC,
+ 0x96EA,
+ 0x7D76,
+ 0x820C,
+ 0x8749,
+ 0x4ED9,
+ 0x5148,
+ 0x5343,
+ 0x5360,
+ 0x5BA3,
+ 0x5C02,
+ 0x5C16,
+ 0x5DDD,
+ 0x6226,
+ 0x6247,
+ 0x64B0,
+ 0x6813,
+ 0x6834,
+ 0x6CC9,
+ 0x6D45,
+ 0x6D17,
+ 0x67D3,
+ 0x6F5C,
+ 0x714E,
+ 0x717D,
+ 0x65CB,
+ 0x7A7F,
+ 0x7BAD,
+ 0x7DDA,
+ 0x7E4A,
+ 0x7FA8,
+ 0x817A,
+ 0x821B,
+ 0x8239,
+ 0x85A6,
+ 0x8A6E,
+ 0x8CCE,
+ 0x8DF5,
+ 0x9078,
+ 0x9077,
+ 0x92AD,
+ 0x9291,
+ 0x9583,
+ 0x9BAE,
+ 0x524D,
+ 0x5584,
+ 0x6F38,
+ 0x7136,
+ 0x5168,
+ 0x7985,
+ 0x7E55,
+ 0x81B3,
+ 0x7CCE,
+ 0x564C,
+ 0x5851,
+ 0x5CA8,
+ 0x63AA,
+ 0x66FE,
+ 0x66FD,
+ 0x695A,
+ 0x72D9,
+ 0x758F,
+ 0x758E,
+ 0x790E,
+ 0x7956,
+ 0x79DF,
+ 0x7C97,
+ 0x7D20,
+ 0x7D44,
+ 0x8607,
+ 0x8A34,
+ 0x963B,
+ 0x9061,
+ 0x9F20,
+ 0x50E7,
+ 0x5275,
+ 0x53CC,
+ 0x53E2,
+ 0x5009,
+ 0x55AA,
+ 0x58EE,
+ 0x594F,
+ 0x723D,
+ 0x5B8B,
+ 0x5C64,
+ 0x531D,
+ 0x60E3,
+ 0x60F3,
+ 0x635C,
+ 0x6383,
+ 0x633F,
+ 0x63BB,
+ 0x64CD,
+ 0x65E9,
+ 0x66F9,
+ 0x5DE3,
+ 0x69CD,
+ 0x69FD,
+ 0x6F15,
+ 0x71E5,
+ 0x4E89,
+ 0x75E9,
+ 0x76F8,
+ 0x7A93,
+ 0x7CDF,
+ 0x7DCF,
+ 0x7D9C,
+ 0x8061,
+ 0x8349,
+ 0x8358,
+ 0x846C,
+ 0x84BC,
+ 0x85FB,
+ 0x88C5,
+ 0x8D70,
+ 0x9001,
+ 0x906D,
+ 0x9397,
+ 0x971C,
+ 0x9A12,
+ 0x50CF,
+ 0x5897,
+ 0x618E,
+ 0x81D3,
+ 0x8535,
+ 0x8D08,
+ 0x9020,
+ 0x4FC3,
+ 0x5074,
+ 0x5247,
+ 0x5373,
+ 0x606F,
+ 0x6349,
+ 0x675F,
+ 0x6E2C,
+ 0x8DB3,
+ 0x901F,
+ 0x4FD7,
+ 0x5C5E,
+ 0x8CCA,
+ 0x65CF,
+ 0x7D9A,
+ 0x5352,
+ 0x8896,
+ 0x5176,
+ 0x63C3,
+ 0x5B58,
+ 0x5B6B,
+ 0x5C0A,
+ 0x640D,
+ 0x6751,
+ 0x905C,
+ 0x4ED6,
+ 0x591A,
+ 0x592A,
+ 0x6C70,
+ 0x8A51,
+ 0x553E,
+ 0x5815,
+ 0x59A5,
+ 0x60F0,
+ 0x6253,
+ 0x67C1,
+ 0x8235,
+ 0x6955,
+ 0x9640,
+ 0x99C4,
+ 0x9A28,
+ 0x4F53,
+ 0x5806,
+ 0x5BFE,
+ 0x8010,
+ 0x5CB1,
+ 0x5E2F,
+ 0x5F85,
+ 0x6020,
+ 0x614B,
+ 0x6234,
+ 0x66FF,
+ 0x6CF0,
+ 0x6EDE,
+ 0x80CE,
+ 0x817F,
+ 0x82D4,
+ 0x888B,
+ 0x8CB8,
+ 0x9000,
+ 0x902E,
+ 0x968A,
+ 0x9EDB,
+ 0x9BDB,
+ 0x4EE3,
+ 0x53F0,
+ 0x5927,
+ 0x7B2C,
+ 0x918D,
+ 0x984C,
+ 0x9DF9,
+ 0x6EDD,
+ 0x7027,
+ 0x5353,
+ 0x5544,
+ 0x5B85,
+ 0x6258,
+ 0x629E,
+ 0x62D3,
+ 0x6CA2,
+ 0x6FEF,
+ 0x7422,
+ 0x8A17,
+ 0x9438,
+ 0x6FC1,
+ 0x8AFE,
+ 0x8338,
+ 0x51E7,
+ 0x86F8,
+ 0x53EA,
+ 0x53E9,
+ 0x4F46,
+ 0x9054,
+ 0x8FB0,
+ 0x596A,
+ 0x8131,
+ 0x5DFD,
+ 0x7AEA,
+ 0x8FBF,
+ 0x68DA,
+ 0x8C37,
+ 0x72F8,
+ 0x9C48,
+ 0x6A3D,
+ 0x8AB0,
+ 0x4E39,
+ 0x5358,
+ 0x5606,
+ 0x5766,
+ 0x62C5,
+ 0x63A2,
+ 0x65E6,
+ 0x6B4E,
+ 0x6DE1,
+ 0x6E5B,
+ 0x70AD,
+ 0x77ED,
+ 0x7AEF,
+ 0x7BAA,
+ 0x7DBB,
+ 0x803D,
+ 0x80C6,
+ 0x86CB,
+ 0x8A95,
+ 0x935B,
+ 0x56E3,
+ 0x58C7,
+ 0x5F3E,
+ 0x65AD,
+ 0x6696,
+ 0x6A80,
+ 0x6BB5,
+ 0x7537,
+ 0x8AC7,
+ 0x5024,
+ 0x77E5,
+ 0x5730,
+ 0x5F1B,
+ 0x6065,
+ 0x667A,
+ 0x6C60,
+ 0x75F4,
+ 0x7A1A,
+ 0x7F6E,
+ 0x81F4,
+ 0x8718,
+ 0x9045,
+ 0x99B3,
+ 0x7BC9,
+ 0x755C,
+ 0x7AF9,
+ 0x7B51,
+ 0x84C4,
+ 0x9010,
+ 0x79E9,
+ 0x7A92,
+ 0x8336,
+ 0x5AE1,
+ 0x7740,
+ 0x4E2D,
+ 0x4EF2,
+ 0x5B99,
+ 0x5FE0,
+ 0x62BD,
+ 0x663C,
+ 0x67F1,
+ 0x6CE8,
+ 0x866B,
+ 0x8877,
+ 0x8A3B,
+ 0x914E,
+ 0x92F3,
+ 0x99D0,
+ 0x6A17,
+ 0x7026,
+ 0x732A,
+ 0x82E7,
+ 0x8457,
+ 0x8CAF,
+ 0x4E01,
+ 0x5146,
+ 0x51CB,
+ 0x558B,
+ 0x5BF5,
+ 0x5E16,
+ 0x5E33,
+ 0x5E81,
+ 0x5F14,
+ 0x5F35,
+ 0x5F6B,
+ 0x5FB4,
+ 0x61F2,
+ 0x6311,
+ 0x66A2,
+ 0x671D,
+ 0x6F6E,
+ 0x7252,
+ 0x753A,
+ 0x773A,
+ 0x8074,
+ 0x8139,
+ 0x8178,
+ 0x8776,
+ 0x8ABF,
+ 0x8ADC,
+ 0x8D85,
+ 0x8DF3,
+ 0x929A,
+ 0x9577,
+ 0x9802,
+ 0x9CE5,
+ 0x52C5,
+ 0x6357,
+ 0x76F4,
+ 0x6715,
+ 0x6C88,
+ 0x73CD,
+ 0x8CC3,
+ 0x93AE,
+ 0x9673,
+ 0x6D25,
+ 0x589C,
+ 0x690E,
+ 0x69CC,
+ 0x8FFD,
+ 0x939A,
+ 0x75DB,
+ 0x901A,
+ 0x585A,
+ 0x6802,
+ 0x63B4,
+ 0x69FB,
+ 0x4F43,
+ 0x6F2C,
+ 0x67D8,
+ 0x8FBB,
+ 0x8526,
+ 0x7DB4,
+ 0x9354,
+ 0x693F,
+ 0x6F70,
+ 0x576A,
+ 0x58F7,
+ 0x5B2C,
+ 0x7D2C,
+ 0x722A,
+ 0x540A,
+ 0x91E3,
+ 0x9DB4,
+ 0x4EAD,
+ 0x4F4E,
+ 0x505C,
+ 0x5075,
+ 0x5243,
+ 0x8C9E,
+ 0x5448,
+ 0x5824,
+ 0x5B9A,
+ 0x5E1D,
+ 0x5E95,
+ 0x5EAD,
+ 0x5EF7,
+ 0x5F1F,
+ 0x608C,
+ 0x62B5,
+ 0x633A,
+ 0x63D0,
+ 0x68AF,
+ 0x6C40,
+ 0x7887,
+ 0x798E,
+ 0x7A0B,
+ 0x7DE0,
+ 0x8247,
+ 0x8A02,
+ 0x8AE6,
+ 0x8E44,
+ 0x9013,
+ 0x90B8,
+ 0x912D,
+ 0x91D8,
+ 0x9F0E,
+ 0x6CE5,
+ 0x6458,
+ 0x64E2,
+ 0x6575,
+ 0x6EF4,
+ 0x7684,
+ 0x7B1B,
+ 0x9069,
+ 0x93D1,
+ 0x6EBA,
+ 0x54F2,
+ 0x5FB9,
+ 0x64A4,
+ 0x8F4D,
+ 0x8FED,
+ 0x9244,
+ 0x5178,
+ 0x586B,
+ 0x5929,
+ 0x5C55,
+ 0x5E97,
+ 0x6DFB,
+ 0x7E8F,
+ 0x751C,
+ 0x8CBC,
+ 0x8EE2,
+ 0x985B,
+ 0x70B9,
+ 0x4F1D,
+ 0x6BBF,
+ 0x6FB1,
+ 0x7530,
+ 0x96FB,
+ 0x514E,
+ 0x5410,
+ 0x5835,
+ 0x5857,
+ 0x59AC,
+ 0x5C60,
+ 0x5F92,
+ 0x6597,
+ 0x675C,
+ 0x6E21,
+ 0x767B,
+ 0x83DF,
+ 0x8CED,
+ 0x9014,
+ 0x90FD,
+ 0x934D,
+ 0x7825,
+ 0x783A,
+ 0x52AA,
+ 0x5EA6,
+ 0x571F,
+ 0x5974,
+ 0x6012,
+ 0x5012,
+ 0x515A,
+ 0x51AC,
+ 0x51CD,
+ 0x5200,
+ 0x5510,
+ 0x5854,
+ 0x5858,
+ 0x5957,
+ 0x5B95,
+ 0x5CF6,
+ 0x5D8B,
+ 0x60BC,
+ 0x6295,
+ 0x642D,
+ 0x6771,
+ 0x6843,
+ 0x68BC,
+ 0x68DF,
+ 0x76D7,
+ 0x6DD8,
+ 0x6E6F,
+ 0x6D9B,
+ 0x706F,
+ 0x71C8,
+ 0x5F53,
+ 0x75D8,
+ 0x7977,
+ 0x7B49,
+ 0x7B54,
+ 0x7B52,
+ 0x7CD6,
+ 0x7D71,
+ 0x5230,
+ 0x8463,
+ 0x8569,
+ 0x85E4,
+ 0x8A0E,
+ 0x8B04,
+ 0x8C46,
+ 0x8E0F,
+ 0x9003,
+ 0x900F,
+ 0x9419,
+ 0x9676,
+ 0x982D,
+ 0x9A30,
+ 0x95D8,
+ 0x50CD,
+ 0x52D5,
+ 0x540C,
+ 0x5802,
+ 0x5C0E,
+ 0x61A7,
+ 0x649E,
+ 0x6D1E,
+ 0x77B3,
+ 0x7AE5,
+ 0x80F4,
+ 0x8404,
+ 0x9053,
+ 0x9285,
+ 0x5CE0,
+ 0x9D07,
+ 0x533F,
+ 0x5F97,
+ 0x5FB3,
+ 0x6D9C,
+ 0x7279,
+ 0x7763,
+ 0x79BF,
+ 0x7BE4,
+ 0x6BD2,
+ 0x72EC,
+ 0x8AAD,
+ 0x6803,
+ 0x6A61,
+ 0x51F8,
+ 0x7A81,
+ 0x6934,
+ 0x5C4A,
+ 0x9CF6,
+ 0x82EB,
+ 0x5BC5,
+ 0x9149,
+ 0x701E,
+ 0x5678,
+ 0x5C6F,
+ 0x60C7,
+ 0x6566,
+ 0x6C8C,
+ 0x8C5A,
+ 0x9041,
+ 0x9813,
+ 0x5451,
+ 0x66C7,
+ 0x920D,
+ 0x5948,
+ 0x90A3,
+ 0x5185,
+ 0x4E4D,
+ 0x51EA,
+ 0x8599,
+ 0x8B0E,
+ 0x7058,
+ 0x637A,
+ 0x934B,
+ 0x6962,
+ 0x99B4,
+ 0x7E04,
+ 0x7577,
+ 0x5357,
+ 0x6960,
+ 0x8EDF,
+ 0x96E3,
+ 0x6C5D,
+ 0x4E8C,
+ 0x5C3C,
+ 0x5F10,
+ 0x8FE9,
+ 0x5302,
+ 0x8CD1,
+ 0x8089,
+ 0x8679,
+ 0x5EFF,
+ 0x65E5,
+ 0x4E73,
+ 0x5165,
+ 0x5982,
+ 0x5C3F,
+ 0x97EE,
+ 0x4EFB,
+ 0x598A,
+ 0x5FCD,
+ 0x8A8D,
+ 0x6FE1,
+ 0x79B0,
+ 0x7962,
+ 0x5BE7,
+ 0x8471,
+ 0x732B,
+ 0x71B1,
+ 0x5E74,
+ 0x5FF5,
+ 0x637B,
+ 0x649A,
+ 0x71C3,
+ 0x7C98,
+ 0x4E43,
+ 0x5EFC,
+ 0x4E4B,
+ 0x57DC,
+ 0x56A2,
+ 0x60A9,
+ 0x6FC3,
+ 0x7D0D,
+ 0x80FD,
+ 0x8133,
+ 0x81BF,
+ 0x8FB2,
+ 0x8997,
+ 0x86A4,
+ 0x5DF4,
+ 0x628A,
+ 0x64AD,
+ 0x8987,
+ 0x6777,
+ 0x6CE2,
+ 0x6D3E,
+ 0x7436,
+ 0x7834,
+ 0x5A46,
+ 0x7F75,
+ 0x82AD,
+ 0x99AC,
+ 0x4FF3,
+ 0x5EC3,
+ 0x62DD,
+ 0x6392,
+ 0x6557,
+ 0x676F,
+ 0x76C3,
+ 0x724C,
+ 0x80CC,
+ 0x80BA,
+ 0x8F29,
+ 0x914D,
+ 0x500D,
+ 0x57F9,
+ 0x5A92,
+ 0x6885,
+ 0x6973,
+ 0x7164,
+ 0x72FD,
+ 0x8CB7,
+ 0x58F2,
+ 0x8CE0,
+ 0x966A,
+ 0x9019,
+ 0x877F,
+ 0x79E4,
+ 0x77E7,
+ 0x8429,
+ 0x4F2F,
+ 0x5265,
+ 0x535A,
+ 0x62CD,
+ 0x67CF,
+ 0x6CCA,
+ 0x767D,
+ 0x7B94,
+ 0x7C95,
+ 0x8236,
+ 0x8584,
+ 0x8FEB,
+ 0x66DD,
+ 0x6F20,
+ 0x7206,
+ 0x7E1B,
+ 0x83AB,
+ 0x99C1,
+ 0x9EA6,
+ 0x51FD,
+ 0x7BB1,
+ 0x7872,
+ 0x7BB8,
+ 0x8087,
+ 0x7B48,
+ 0x6AE8,
+ 0x5E61,
+ 0x808C,
+ 0x7551,
+ 0x7560,
+ 0x516B,
+ 0x9262,
+ 0x6E8C,
+ 0x767A,
+ 0x9197,
+ 0x9AEA,
+ 0x4F10,
+ 0x7F70,
+ 0x629C,
+ 0x7B4F,
+ 0x95A5,
+ 0x9CE9,
+ 0x567A,
+ 0x5859,
+ 0x86E4,
+ 0x96BC,
+ 0x4F34,
+ 0x5224,
+ 0x534A,
+ 0x53CD,
+ 0x53DB,
+ 0x5E06,
+ 0x642C,
+ 0x6591,
+ 0x677F,
+ 0x6C3E,
+ 0x6C4E,
+ 0x7248,
+ 0x72AF,
+ 0x73ED,
+ 0x7554,
+ 0x7E41,
+ 0x822C,
+ 0x85E9,
+ 0x8CA9,
+ 0x7BC4,
+ 0x91C6,
+ 0x7169,
+ 0x9812,
+ 0x98EF,
+ 0x633D,
+ 0x6669,
+ 0x756A,
+ 0x76E4,
+ 0x78D0,
+ 0x8543,
+ 0x86EE,
+ 0x532A,
+ 0x5351,
+ 0x5426,
+ 0x5983,
+ 0x5E87,
+ 0x5F7C,
+ 0x60B2,
+ 0x6249,
+ 0x6279,
+ 0x62AB,
+ 0x6590,
+ 0x6BD4,
+ 0x6CCC,
+ 0x75B2,
+ 0x76AE,
+ 0x7891,
+ 0x79D8,
+ 0x7DCB,
+ 0x7F77,
+ 0x80A5,
+ 0x88AB,
+ 0x8AB9,
+ 0x8CBB,
+ 0x907F,
+ 0x975E,
+ 0x98DB,
+ 0x6A0B,
+ 0x7C38,
+ 0x5099,
+ 0x5C3E,
+ 0x5FAE,
+ 0x6787,
+ 0x6BD8,
+ 0x7435,
+ 0x7709,
+ 0x7F8E,
+ 0x9F3B,
+ 0x67CA,
+ 0x7A17,
+ 0x5339,
+ 0x758B,
+ 0x9AED,
+ 0x5F66,
+ 0x819D,
+ 0x83F1,
+ 0x8098,
+ 0x5F3C,
+ 0x5FC5,
+ 0x7562,
+ 0x7B46,
+ 0x903C,
+ 0x6867,
+ 0x59EB,
+ 0x5A9B,
+ 0x7D10,
+ 0x767E,
+ 0x8B2C,
+ 0x4FF5,
+ 0x5F6A,
+ 0x6A19,
+ 0x6C37,
+ 0x6F02,
+ 0x74E2,
+ 0x7968,
+ 0x8868,
+ 0x8A55,
+ 0x8C79,
+ 0x5EDF,
+ 0x63CF,
+ 0x75C5,
+ 0x79D2,
+ 0x82D7,
+ 0x9328,
+ 0x92F2,
+ 0x849C,
+ 0x86ED,
+ 0x9C2D,
+ 0x54C1,
+ 0x5F6C,
+ 0x658C,
+ 0x6D5C,
+ 0x7015,
+ 0x8CA7,
+ 0x8CD3,
+ 0x983B,
+ 0x654F,
+ 0x74F6,
+ 0x4E0D,
+ 0x4ED8,
+ 0x57E0,
+ 0x592B,
+ 0x5A66,
+ 0x5BCC,
+ 0x51A8,
+ 0x5E03,
+ 0x5E9C,
+ 0x6016,
+ 0x6276,
+ 0x6577,
+ 0x65A7,
+ 0x666E,
+ 0x6D6E,
+ 0x7236,
+ 0x7B26,
+ 0x8150,
+ 0x819A,
+ 0x8299,
+ 0x8B5C,
+ 0x8CA0,
+ 0x8CE6,
+ 0x8D74,
+ 0x961C,
+ 0x9644,
+ 0x4FAE,
+ 0x64AB,
+ 0x6B66,
+ 0x821E,
+ 0x8461,
+ 0x856A,
+ 0x90E8,
+ 0x5C01,
+ 0x6953,
+ 0x98A8,
+ 0x847A,
+ 0x8557,
+ 0x4F0F,
+ 0x526F,
+ 0x5FA9,
+ 0x5E45,
+ 0x670D,
+ 0x798F,
+ 0x8179,
+ 0x8907,
+ 0x8986,
+ 0x6DF5,
+ 0x5F17,
+ 0x6255,
+ 0x6CB8,
+ 0x4ECF,
+ 0x7269,
+ 0x9B92,
+ 0x5206,
+ 0x543B,
+ 0x5674,
+ 0x58B3,
+ 0x61A4,
+ 0x626E,
+ 0x711A,
+ 0x596E,
+ 0x7C89,
+ 0x7CDE,
+ 0x7D1B,
+ 0x96F0,
+ 0x6587,
+ 0x805E,
+ 0x4E19,
+ 0x4F75,
+ 0x5175,
+ 0x5840,
+ 0x5E63,
+ 0x5E73,
+ 0x5F0A,
+ 0x67C4,
+ 0x4E26,
+ 0x853D,
+ 0x9589,
+ 0x965B,
+ 0x7C73,
+ 0x9801,
+ 0x50FB,
+ 0x58C1,
+ 0x7656,
+ 0x78A7,
+ 0x5225,
+ 0x77A5,
+ 0x8511,
+ 0x7B86,
+ 0x504F,
+ 0x5909,
+ 0x7247,
+ 0x7BC7,
+ 0x7DE8,
+ 0x8FBA,
+ 0x8FD4,
+ 0x904D,
+ 0x4FBF,
+ 0x52C9,
+ 0x5A29,
+ 0x5F01,
+ 0x97AD,
+ 0x4FDD,
+ 0x8217,
+ 0x92EA,
+ 0x5703,
+ 0x6355,
+ 0x6B69,
+ 0x752B,
+ 0x88DC,
+ 0x8F14,
+ 0x7A42,
+ 0x52DF,
+ 0x5893,
+ 0x6155,
+ 0x620A,
+ 0x66AE,
+ 0x6BCD,
+ 0x7C3F,
+ 0x83E9,
+ 0x5023,
+ 0x4FF8,
+ 0x5305,
+ 0x5446,
+ 0x5831,
+ 0x5949,
+ 0x5B9D,
+ 0x5CF0,
+ 0x5CEF,
+ 0x5D29,
+ 0x5E96,
+ 0x62B1,
+ 0x6367,
+ 0x653E,
+ 0x65B9,
+ 0x670B,
+ 0x6CD5,
+ 0x6CE1,
+ 0x70F9,
+ 0x7832,
+ 0x7E2B,
+ 0x80DE,
+ 0x82B3,
+ 0x840C,
+ 0x84EC,
+ 0x8702,
+ 0x8912,
+ 0x8A2A,
+ 0x8C4A,
+ 0x90A6,
+ 0x92D2,
+ 0x98FD,
+ 0x9CF3,
+ 0x9D6C,
+ 0x4E4F,
+ 0x4EA1,
+ 0x508D,
+ 0x5256,
+ 0x574A,
+ 0x59A8,
+ 0x5E3D,
+ 0x5FD8,
+ 0x5FD9,
+ 0x623F,
+ 0x66B4,
+ 0x671B,
+ 0x67D0,
+ 0x68D2,
+ 0x5192,
+ 0x7D21,
+ 0x80AA,
+ 0x81A8,
+ 0x8B00,
+ 0x8C8C,
+ 0x8CBF,
+ 0x927E,
+ 0x9632,
+ 0x5420,
+ 0x982C,
+ 0x5317,
+ 0x50D5,
+ 0x535C,
+ 0x58A8,
+ 0x64B2,
+ 0x6734,
+ 0x7267,
+ 0x7766,
+ 0x7A46,
+ 0x91E6,
+ 0x52C3,
+ 0x6CA1,
+ 0x6B86,
+ 0x5800,
+ 0x5E4C,
+ 0x5954,
+ 0x672C,
+ 0x7FFB,
+ 0x51E1,
+ 0x76C6,
+ 0x6469,
+ 0x78E8,
+ 0x9B54,
+ 0x9EBB,
+ 0x57CB,
+ 0x59B9,
+ 0x6627,
+ 0x679A,
+ 0x6BCE,
+ 0x54E9,
+ 0x69D9,
+ 0x5E55,
+ 0x819C,
+ 0x6795,
+ 0x9BAA,
+ 0x67FE,
+ 0x9C52,
+ 0x685D,
+ 0x4EA6,
+ 0x4FE3,
+ 0x53C8,
+ 0x62B9,
+ 0x672B,
+ 0x6CAB,
+ 0x8FC4,
+ 0x4FAD,
+ 0x7E6D,
+ 0x9EBF,
+ 0x4E07,
+ 0x6162,
+ 0x6E80,
+ 0x6F2B,
+ 0x8513,
+ 0x5473,
+ 0x672A,
+ 0x9B45,
+ 0x5DF3,
+ 0x7B95,
+ 0x5CAC,
+ 0x5BC6,
+ 0x871C,
+ 0x6E4A,
+ 0x84D1,
+ 0x7A14,
+ 0x8108,
+ 0x5999,
+ 0x7C8D,
+ 0x6C11,
+ 0x7720,
+ 0x52D9,
+ 0x5922,
+ 0x7121,
+ 0x725F,
+ 0x77DB,
+ 0x9727,
+ 0x9D61,
+ 0x690B,
+ 0x5A7F,
+ 0x5A18,
+ 0x51A5,
+ 0x540D,
+ 0x547D,
+ 0x660E,
+ 0x76DF,
+ 0x8FF7,
+ 0x9298,
+ 0x9CF4,
+ 0x59EA,
+ 0x725D,
+ 0x6EC5,
+ 0x514D,
+ 0x68C9,
+ 0x7DBF,
+ 0x7DEC,
+ 0x9762,
+ 0x9EBA,
+ 0x6478,
+ 0x6A21,
+ 0x8302,
+ 0x5984,
+ 0x5B5F,
+ 0x6BDB,
+ 0x731B,
+ 0x76F2,
+ 0x7DB2,
+ 0x8017,
+ 0x8499,
+ 0x5132,
+ 0x6728,
+ 0x9ED9,
+ 0x76EE,
+ 0x6762,
+ 0x52FF,
+ 0x9905,
+ 0x5C24,
+ 0x623B,
+ 0x7C7E,
+ 0x8CB0,
+ 0x554F,
+ 0x60B6,
+ 0x7D0B,
+ 0x9580,
+ 0x5301,
+ 0x4E5F,
+ 0x51B6,
+ 0x591C,
+ 0x723A,
+ 0x8036,
+ 0x91CE,
+ 0x5F25,
+ 0x77E2,
+ 0x5384,
+ 0x5F79,
+ 0x7D04,
+ 0x85AC,
+ 0x8A33,
+ 0x8E8D,
+ 0x9756,
+ 0x67F3,
+ 0x85AE,
+ 0x9453,
+ 0x6109,
+ 0x6108,
+ 0x6CB9,
+ 0x7652,
+ 0x8AED,
+ 0x8F38,
+ 0x552F,
+ 0x4F51,
+ 0x512A,
+ 0x52C7,
+ 0x53CB,
+ 0x5BA5,
+ 0x5E7D,
+ 0x60A0,
+ 0x6182,
+ 0x63D6,
+ 0x6709,
+ 0x67DA,
+ 0x6E67,
+ 0x6D8C,
+ 0x7336,
+ 0x7337,
+ 0x7531,
+ 0x7950,
+ 0x88D5,
+ 0x8A98,
+ 0x904A,
+ 0x9091,
+ 0x90F5,
+ 0x96C4,
+ 0x878D,
+ 0x5915,
+ 0x4E88,
+ 0x4F59,
+ 0x4E0E,
+ 0x8A89,
+ 0x8F3F,
+ 0x9810,
+ 0x50AD,
+ 0x5E7C,
+ 0x5996,
+ 0x5BB9,
+ 0x5EB8,
+ 0x63DA,
+ 0x63FA,
+ 0x64C1,
+ 0x66DC,
+ 0x694A,
+ 0x69D8,
+ 0x6D0B,
+ 0x6EB6,
+ 0x7194,
+ 0x7528,
+ 0x7AAF,
+ 0x7F8A,
+ 0x8000,
+ 0x8449,
+ 0x84C9,
+ 0x8981,
+ 0x8B21,
+ 0x8E0A,
+ 0x9065,
+ 0x967D,
+ 0x990A,
+ 0x617E,
+ 0x6291,
+ 0x6B32,
+ 0x6C83,
+ 0x6D74,
+ 0x7FCC,
+ 0x7FFC,
+ 0x6DC0,
+ 0x7F85,
+ 0x87BA,
+ 0x88F8,
+ 0x6765,
+ 0x83B1,
+ 0x983C,
+ 0x96F7,
+ 0x6D1B,
+ 0x7D61,
+ 0x843D,
+ 0x916A,
+ 0x4E71,
+ 0x5375,
+ 0x5D50,
+ 0x6B04,
+ 0x6FEB,
+ 0x85CD,
+ 0x862D,
+ 0x89A7,
+ 0x5229,
+ 0x540F,
+ 0x5C65,
+ 0x674E,
+ 0x68A8,
+ 0x7406,
+ 0x7483,
+ 0x75E2,
+ 0x88CF,
+ 0x88E1,
+ 0x91CC,
+ 0x96E2,
+ 0x9678,
+ 0x5F8B,
+ 0x7387,
+ 0x7ACB,
+ 0x844E,
+ 0x63A0,
+ 0x7565,
+ 0x5289,
+ 0x6D41,
+ 0x6E9C,
+ 0x7409,
+ 0x7559,
+ 0x786B,
+ 0x7C92,
+ 0x9686,
+ 0x7ADC,
+ 0x9F8D,
+ 0x4FB6,
+ 0x616E,
+ 0x65C5,
+ 0x865C,
+ 0x4E86,
+ 0x4EAE,
+ 0x50DA,
+ 0x4E21,
+ 0x51CC,
+ 0x5BEE,
+ 0x6599,
+ 0x6881,
+ 0x6DBC,
+ 0x731F,
+ 0x7642,
+ 0x77AD,
+ 0x7A1C,
+ 0x7CE7,
+ 0x826F,
+ 0x8AD2,
+ 0x907C,
+ 0x91CF,
+ 0x9675,
+ 0x9818,
+ 0x529B,
+ 0x7DD1,
+ 0x502B,
+ 0x5398,
+ 0x6797,
+ 0x6DCB,
+ 0x71D0,
+ 0x7433,
+ 0x81E8,
+ 0x8F2A,
+ 0x96A3,
+ 0x9C57,
+ 0x9E9F,
+ 0x7460,
+ 0x5841,
+ 0x6D99,
+ 0x7D2F,
+ 0x985E,
+ 0x4EE4,
+ 0x4F36,
+ 0x4F8B,
+ 0x51B7,
+ 0x52B1,
+ 0x5DBA,
+ 0x601C,
+ 0x73B2,
+ 0x793C,
+ 0x82D3,
+ 0x9234,
+ 0x96B7,
+ 0x96F6,
+ 0x970A,
+ 0x9E97,
+ 0x9F62,
+ 0x66A6,
+ 0x6B74,
+ 0x5217,
+ 0x52A3,
+ 0x70C8,
+ 0x88C2,
+ 0x5EC9,
+ 0x604B,
+ 0x6190,
+ 0x6F23,
+ 0x7149,
+ 0x7C3E,
+ 0x7DF4,
+ 0x806F,
+ 0x84EE,
+ 0x9023,
+ 0x932C,
+ 0x5442,
+ 0x9B6F,
+ 0x6AD3,
+ 0x7089,
+ 0x8CC2,
+ 0x8DEF,
+ 0x9732,
+ 0x52B4,
+ 0x5A41,
+ 0x5ECA,
+ 0x5F04,
+ 0x6717,
+ 0x697C,
+ 0x6994,
+ 0x6D6A,
+ 0x6F0F,
+ 0x7262,
+ 0x72FC,
+ 0x7BED,
+ 0x8001,
+ 0x807E,
+ 0x874B,
+ 0x90CE,
+ 0x516D,
+ 0x9E93,
+ 0x7984,
+ 0x808B,
+ 0x9332,
+ 0x8AD6,
+ 0x502D,
+ 0x548C,
+ 0x8A71,
+ 0x6B6A,
+ 0x8CC4,
+ 0x8107,
+ 0x60D1,
+ 0x67A0,
+ 0x9DF2,
+ 0x4E99,
+ 0x4E98,
+ 0x9C10,
+ 0x8A6B,
+ 0x85C1,
+ 0x8568,
+ 0x6900,
+ 0x6E7E,
+ 0x7897,
+ 0x8155,
+ 0x5F0C,
+ 0x4E10,
+ 0x4E15,
+ 0x4E2A,
+ 0x4E31,
+ 0x4E36,
+ 0x4E3C,
+ 0x4E3F,
+ 0x4E42,
+ 0x4E56,
+ 0x4E58,
+ 0x4E82,
+ 0x4E85,
+ 0x8C6B,
+ 0x4E8A,
+ 0x8212,
+ 0x5F0D,
+ 0x4E8E,
+ 0x4E9E,
+ 0x4E9F,
+ 0x4EA0,
+ 0x4EA2,
+ 0x4EB0,
+ 0x4EB3,
+ 0x4EB6,
+ 0x4ECE,
+ 0x4ECD,
+ 0x4EC4,
+ 0x4EC6,
+ 0x4EC2,
+ 0x4ED7,
+ 0x4EDE,
+ 0x4EED,
+ 0x4EDF,
+ 0x4EF7,
+ 0x4F09,
+ 0x4F5A,
+ 0x4F30,
+ 0x4F5B,
+ 0x4F5D,
+ 0x4F57,
+ 0x4F47,
+ 0x4F76,
+ 0x4F88,
+ 0x4F8F,
+ 0x4F98,
+ 0x4F7B,
+ 0x4F69,
+ 0x4F70,
+ 0x4F91,
+ 0x4F6F,
+ 0x4F86,
+ 0x4F96,
+ 0x5118,
+ 0x4FD4,
+ 0x4FDF,
+ 0x4FCE,
+ 0x4FD8,
+ 0x4FDB,
+ 0x4FD1,
+ 0x4FDA,
+ 0x4FD0,
+ 0x4FE4,
+ 0x4FE5,
+ 0x501A,
+ 0x5028,
+ 0x5014,
+ 0x502A,
+ 0x5025,
+ 0x5005,
+ 0x4F1C,
+ 0x4FF6,
+ 0x5021,
+ 0x5029,
+ 0x502C,
+ 0x4FFE,
+ 0x4FEF,
+ 0x5011,
+ 0x5006,
+ 0x5043,
+ 0x5047,
+ 0x6703,
+ 0x5055,
+ 0x5050,
+ 0x5048,
+ 0x505A,
+ 0x5056,
+ 0x506C,
+ 0x5078,
+ 0x5080,
+ 0x509A,
+ 0x5085,
+ 0x50B4,
+ 0x50B2,
+ 0x50C9,
+ 0x50CA,
+ 0x50B3,
+ 0x50C2,
+ 0x50D6,
+ 0x50DE,
+ 0x50E5,
+ 0x50ED,
+ 0x50E3,
+ 0x50EE,
+ 0x50F9,
+ 0x50F5,
+ 0x5109,
+ 0x5101,
+ 0x5102,
+ 0x5116,
+ 0x5115,
+ 0x5114,
+ 0x511A,
+ 0x5121,
+ 0x513A,
+ 0x5137,
+ 0x513C,
+ 0x513B,
+ 0x513F,
+ 0x5140,
+ 0x5152,
+ 0x514C,
+ 0x5154,
+ 0x5162,
+ 0x7AF8,
+ 0x5169,
+ 0x516A,
+ 0x516E,
+ 0x5180,
+ 0x5182,
+ 0x56D8,
+ 0x518C,
+ 0x5189,
+ 0x518F,
+ 0x5191,
+ 0x5193,
+ 0x5195,
+ 0x5196,
+ 0x51A4,
+ 0x51A6,
+ 0x51A2,
+ 0x51A9,
+ 0x51AA,
+ 0x51AB,
+ 0x51B3,
+ 0x51B1,
+ 0x51B2,
+ 0x51B0,
+ 0x51B5,
+ 0x51BD,
+ 0x51C5,
+ 0x51C9,
+ 0x51DB,
+ 0x51E0,
+ 0x8655,
+ 0x51E9,
+ 0x51ED,
+ 0x51F0,
+ 0x51F5,
+ 0x51FE,
+ 0x5204,
+ 0x520B,
+ 0x5214,
+ 0x520E,
+ 0x5227,
+ 0x522A,
+ 0x522E,
+ 0x5233,
+ 0x5239,
+ 0x524F,
+ 0x5244,
+ 0x524B,
+ 0x524C,
+ 0x525E,
+ 0x5254,
+ 0x526A,
+ 0x5274,
+ 0x5269,
+ 0x5273,
+ 0x527F,
+ 0x527D,
+ 0x528D,
+ 0x5294,
+ 0x5292,
+ 0x5271,
+ 0x5288,
+ 0x5291,
+ 0x8FA8,
+ 0x8FA7,
+ 0x52AC,
+ 0x52AD,
+ 0x52BC,
+ 0x52B5,
+ 0x52C1,
+ 0x52CD,
+ 0x52D7,
+ 0x52DE,
+ 0x52E3,
+ 0x52E6,
+ 0x98ED,
+ 0x52E0,
+ 0x52F3,
+ 0x52F5,
+ 0x52F8,
+ 0x52F9,
+ 0x5306,
+ 0x5308,
+ 0x7538,
+ 0x530D,
+ 0x5310,
+ 0x530F,
+ 0x5315,
+ 0x531A,
+ 0x5323,
+ 0x532F,
+ 0x5331,
+ 0x5333,
+ 0x5338,
+ 0x5340,
+ 0x5346,
+ 0x5345,
+ 0x4E17,
+ 0x5349,
+ 0x534D,
+ 0x51D6,
+ 0x535E,
+ 0x5369,
+ 0x536E,
+ 0x5918,
+ 0x537B,
+ 0x5377,
+ 0x5382,
+ 0x5396,
+ 0x53A0,
+ 0x53A6,
+ 0x53A5,
+ 0x53AE,
+ 0x53B0,
+ 0x53B6,
+ 0x53C3,
+ 0x7C12,
+ 0x96D9,
+ 0x53DF,
+ 0x66FC,
+ 0x71EE,
+ 0x53EE,
+ 0x53E8,
+ 0x53ED,
+ 0x53FA,
+ 0x5401,
+ 0x543D,
+ 0x5440,
+ 0x542C,
+ 0x542D,
+ 0x543C,
+ 0x542E,
+ 0x5436,
+ 0x5429,
+ 0x541D,
+ 0x544E,
+ 0x548F,
+ 0x5475,
+ 0x548E,
+ 0x545F,
+ 0x5471,
+ 0x5477,
+ 0x5470,
+ 0x5492,
+ 0x547B,
+ 0x5480,
+ 0x5476,
+ 0x5484,
+ 0x5490,
+ 0x5486,
+ 0x54C7,
+ 0x54A2,
+ 0x54B8,
+ 0x54A5,
+ 0x54AC,
+ 0x54C4,
+ 0x54C8,
+ 0x54A8,
+ 0x54AB,
+ 0x54C2,
+ 0x54A4,
+ 0x54BE,
+ 0x54BC,
+ 0x54D8,
+ 0x54E5,
+ 0x54E6,
+ 0x550F,
+ 0x5514,
+ 0x54FD,
+ 0x54EE,
+ 0x54ED,
+ 0x54FA,
+ 0x54E2,
+ 0x5539,
+ 0x5540,
+ 0x5563,
+ 0x554C,
+ 0x552E,
+ 0x555C,
+ 0x5545,
+ 0x5556,
+ 0x5557,
+ 0x5538,
+ 0x5533,
+ 0x555D,
+ 0x5599,
+ 0x5580,
+ 0x54AF,
+ 0x558A,
+ 0x559F,
+ 0x557B,
+ 0x557E,
+ 0x5598,
+ 0x559E,
+ 0x55AE,
+ 0x557C,
+ 0x5583,
+ 0x55A9,
+ 0x5587,
+ 0x55A8,
+ 0x55DA,
+ 0x55C5,
+ 0x55DF,
+ 0x55C4,
+ 0x55DC,
+ 0x55E4,
+ 0x55D4,
+ 0x5614,
+ 0x55F7,
+ 0x5616,
+ 0x55FE,
+ 0x55FD,
+ 0x561B,
+ 0x55F9,
+ 0x564E,
+ 0x5650,
+ 0x71DF,
+ 0x5634,
+ 0x5636,
+ 0x5632,
+ 0x5638,
+ 0x566B,
+ 0x5664,
+ 0x562F,
+ 0x566C,
+ 0x566A,
+ 0x5686,
+ 0x5680,
+ 0x568A,
+ 0x56A0,
+ 0x5694,
+ 0x568F,
+ 0x56A5,
+ 0x56AE,
+ 0x56B6,
+ 0x56B4,
+ 0x56C2,
+ 0x56BC,
+ 0x56C1,
+ 0x56C3,
+ 0x56C0,
+ 0x56C8,
+ 0x56CE,
+ 0x56D1,
+ 0x56D3,
+ 0x56D7,
+ 0x56EE,
+ 0x56F9,
+ 0x5700,
+ 0x56FF,
+ 0x5704,
+ 0x5709,
+ 0x5708,
+ 0x570B,
+ 0x570D,
+ 0x5713,
+ 0x5718,
+ 0x5716,
+ 0x55C7,
+ 0x571C,
+ 0x5726,
+ 0x5737,
+ 0x5738,
+ 0x574E,
+ 0x573B,
+ 0x5740,
+ 0x574F,
+ 0x5769,
+ 0x57C0,
+ 0x5788,
+ 0x5761,
+ 0x577F,
+ 0x5789,
+ 0x5793,
+ 0x57A0,
+ 0x57B3,
+ 0x57A4,
+ 0x57AA,
+ 0x57B0,
+ 0x57C3,
+ 0x57C6,
+ 0x57D4,
+ 0x57D2,
+ 0x57D3,
+ 0x580A,
+ 0x57D6,
+ 0x57E3,
+ 0x580B,
+ 0x5819,
+ 0x581D,
+ 0x5872,
+ 0x5821,
+ 0x5862,
+ 0x584B,
+ 0x5870,
+ 0x6BC0,
+ 0x5852,
+ 0x583D,
+ 0x5879,
+ 0x5885,
+ 0x58B9,
+ 0x589F,
+ 0x58AB,
+ 0x58BA,
+ 0x58DE,
+ 0x58BB,
+ 0x58B8,
+ 0x58AE,
+ 0x58C5,
+ 0x58D3,
+ 0x58D1,
+ 0x58D7,
+ 0x58D9,
+ 0x58D8,
+ 0x58E5,
+ 0x58DC,
+ 0x58E4,
+ 0x58DF,
+ 0x58EF,
+ 0x58FA,
+ 0x58F9,
+ 0x58FB,
+ 0x58FC,
+ 0x58FD,
+ 0x5902,
+ 0x590A,
+ 0x5910,
+ 0x591B,
+ 0x68A6,
+ 0x5925,
+ 0x592C,
+ 0x592D,
+ 0x5932,
+ 0x5938,
+ 0x593E,
+ 0x7AD2,
+ 0x5955,
+ 0x5950,
+ 0x594E,
+ 0x595A,
+ 0x5958,
+ 0x5962,
+ 0x5960,
+ 0x5967,
+ 0x596C,
+ 0x5969,
+ 0x5978,
+ 0x5981,
+ 0x599D,
+ 0x4F5E,
+ 0x4FAB,
+ 0x59A3,
+ 0x59B2,
+ 0x59C6,
+ 0x59E8,
+ 0x59DC,
+ 0x598D,
+ 0x59D9,
+ 0x59DA,
+ 0x5A25,
+ 0x5A1F,
+ 0x5A11,
+ 0x5A1C,
+ 0x5A09,
+ 0x5A1A,
+ 0x5A40,
+ 0x5A6C,
+ 0x5A49,
+ 0x5A35,
+ 0x5A36,
+ 0x5A62,
+ 0x5A6A,
+ 0x5A9A,
+ 0x5ABC,
+ 0x5ABE,
+ 0x5ACB,
+ 0x5AC2,
+ 0x5ABD,
+ 0x5AE3,
+ 0x5AD7,
+ 0x5AE6,
+ 0x5AE9,
+ 0x5AD6,
+ 0x5AFA,
+ 0x5AFB,
+ 0x5B0C,
+ 0x5B0B,
+ 0x5B16,
+ 0x5B32,
+ 0x5AD0,
+ 0x5B2A,
+ 0x5B36,
+ 0x5B3E,
+ 0x5B43,
+ 0x5B45,
+ 0x5B40,
+ 0x5B51,
+ 0x5B55,
+ 0x5B5A,
+ 0x5B5B,
+ 0x5B65,
+ 0x5B69,
+ 0x5B70,
+ 0x5B73,
+ 0x5B75,
+ 0x5B78,
+ 0x6588,
+ 0x5B7A,
+ 0x5B80,
+ 0x5B83,
+ 0x5BA6,
+ 0x5BB8,
+ 0x5BC3,
+ 0x5BC7,
+ 0x5BC9,
+ 0x5BD4,
+ 0x5BD0,
+ 0x5BE4,
+ 0x5BE6,
+ 0x5BE2,
+ 0x5BDE,
+ 0x5BE5,
+ 0x5BEB,
+ 0x5BF0,
+ 0x5BF6,
+ 0x5BF3,
+ 0x5C05,
+ 0x5C07,
+ 0x5C08,
+ 0x5C0D,
+ 0x5C13,
+ 0x5C20,
+ 0x5C22,
+ 0x5C28,
+ 0x5C38,
+ 0x5C39,
+ 0x5C41,
+ 0x5C46,
+ 0x5C4E,
+ 0x5C53,
+ 0x5C50,
+ 0x5C4F,
+ 0x5B71,
+ 0x5C6C,
+ 0x5C6E,
+ 0x4E62,
+ 0x5C76,
+ 0x5C79,
+ 0x5C8C,
+ 0x5C91,
+ 0x5C94,
+ 0x599B,
+ 0x5CAB,
+ 0x5CBB,
+ 0x5CB6,
+ 0x5CBC,
+ 0x5CB7,
+ 0x5CC5,
+ 0x5CBE,
+ 0x5CC7,
+ 0x5CD9,
+ 0x5CE9,
+ 0x5CFD,
+ 0x5CFA,
+ 0x5CED,
+ 0x5D8C,
+ 0x5CEA,
+ 0x5D0B,
+ 0x5D15,
+ 0x5D17,
+ 0x5D5C,
+ 0x5D1F,
+ 0x5D1B,
+ 0x5D11,
+ 0x5D14,
+ 0x5D22,
+ 0x5D1A,
+ 0x5D19,
+ 0x5D18,
+ 0x5D4C,
+ 0x5D52,
+ 0x5D4E,
+ 0x5D4B,
+ 0x5D6C,
+ 0x5D73,
+ 0x5D76,
+ 0x5D87,
+ 0x5D84,
+ 0x5D82,
+ 0x5DA2,
+ 0x5D9D,
+ 0x5DAC,
+ 0x5DAE,
+ 0x5DBD,
+ 0x5D90,
+ 0x5DB7,
+ 0x5DBC,
+ 0x5DC9,
+ 0x5DCD,
+ 0x5DD3,
+ 0x5DD2,
+ 0x5DD6,
+ 0x5DDB,
+ 0x5DEB,
+ 0x5DF2,
+ 0x5DF5,
+ 0x5E0B,
+ 0x5E1A,
+ 0x5E19,
+ 0x5E11,
+ 0x5E1B,
+ 0x5E36,
+ 0x5E37,
+ 0x5E44,
+ 0x5E43,
+ 0x5E40,
+ 0x5E4E,
+ 0x5E57,
+ 0x5E54,
+ 0x5E5F,
+ 0x5E62,
+ 0x5E64,
+ 0x5E47,
+ 0x5E75,
+ 0x5E76,
+ 0x5E7A,
+ 0x9EBC,
+ 0x5E7F,
+ 0x5EA0,
+ 0x5EC1,
+ 0x5EC2,
+ 0x5EC8,
+ 0x5ED0,
+ 0x5ECF,
+ 0x5ED6,
+ 0x5EE3,
+ 0x5EDD,
+ 0x5EDA,
+ 0x5EDB,
+ 0x5EE2,
+ 0x5EE1,
+ 0x5EE8,
+ 0x5EE9,
+ 0x5EEC,
+ 0x5EF1,
+ 0x5EF3,
+ 0x5EF0,
+ 0x5EF4,
+ 0x5EF8,
+ 0x5EFE,
+ 0x5F03,
+ 0x5F09,
+ 0x5F5D,
+ 0x5F5C,
+ 0x5F0B,
+ 0x5F11,
+ 0x5F16,
+ 0x5F29,
+ 0x5F2D,
+ 0x5F38,
+ 0x5F41,
+ 0x5F48,
+ 0x5F4C,
+ 0x5F4E,
+ 0x5F2F,
+ 0x5F51,
+ 0x5F56,
+ 0x5F57,
+ 0x5F59,
+ 0x5F61,
+ 0x5F6D,
+ 0x5F73,
+ 0x5F77,
+ 0x5F83,
+ 0x5F82,
+ 0x5F7F,
+ 0x5F8A,
+ 0x5F88,
+ 0x5F91,
+ 0x5F87,
+ 0x5F9E,
+ 0x5F99,
+ 0x5F98,
+ 0x5FA0,
+ 0x5FA8,
+ 0x5FAD,
+ 0x5FBC,
+ 0x5FD6,
+ 0x5FFB,
+ 0x5FE4,
+ 0x5FF8,
+ 0x5FF1,
+ 0x5FDD,
+ 0x60B3,
+ 0x5FFF,
+ 0x6021,
+ 0x6060,
+ 0x6019,
+ 0x6010,
+ 0x6029,
+ 0x600E,
+ 0x6031,
+ 0x601B,
+ 0x6015,
+ 0x602B,
+ 0x6026,
+ 0x600F,
+ 0x603A,
+ 0x605A,
+ 0x6041,
+ 0x606A,
+ 0x6077,
+ 0x605F,
+ 0x604A,
+ 0x6046,
+ 0x604D,
+ 0x6063,
+ 0x6043,
+ 0x6064,
+ 0x6042,
+ 0x606C,
+ 0x606B,
+ 0x6059,
+ 0x6081,
+ 0x608D,
+ 0x60E7,
+ 0x6083,
+ 0x609A,
+ 0x6084,
+ 0x609B,
+ 0x6096,
+ 0x6097,
+ 0x6092,
+ 0x60A7,
+ 0x608B,
+ 0x60E1,
+ 0x60B8,
+ 0x60E0,
+ 0x60D3,
+ 0x60B4,
+ 0x5FF0,
+ 0x60BD,
+ 0x60C6,
+ 0x60B5,
+ 0x60D8,
+ 0x614D,
+ 0x6115,
+ 0x6106,
+ 0x60F6,
+ 0x60F7,
+ 0x6100,
+ 0x60F4,
+ 0x60FA,
+ 0x6103,
+ 0x6121,
+ 0x60FB,
+ 0x60F1,
+ 0x610D,
+ 0x610E,
+ 0x6147,
+ 0x613E,
+ 0x6128,
+ 0x6127,
+ 0x614A,
+ 0x613F,
+ 0x613C,
+ 0x612C,
+ 0x6134,
+ 0x613D,
+ 0x6142,
+ 0x6144,
+ 0x6173,
+ 0x6177,
+ 0x6158,
+ 0x6159,
+ 0x615A,
+ 0x616B,
+ 0x6174,
+ 0x616F,
+ 0x6165,
+ 0x6171,
+ 0x615F,
+ 0x615D,
+ 0x6153,
+ 0x6175,
+ 0x6199,
+ 0x6196,
+ 0x6187,
+ 0x61AC,
+ 0x6194,
+ 0x619A,
+ 0x618A,
+ 0x6191,
+ 0x61AB,
+ 0x61AE,
+ 0x61CC,
+ 0x61CA,
+ 0x61C9,
+ 0x61F7,
+ 0x61C8,
+ 0x61C3,
+ 0x61C6,
+ 0x61BA,
+ 0x61CB,
+ 0x7F79,
+ 0x61CD,
+ 0x61E6,
+ 0x61E3,
+ 0x61F6,
+ 0x61FA,
+ 0x61F4,
+ 0x61FF,
+ 0x61FD,
+ 0x61FC,
+ 0x61FE,
+ 0x6200,
+ 0x6208,
+ 0x6209,
+ 0x620D,
+ 0x620C,
+ 0x6214,
+ 0x621B,
+ 0x621E,
+ 0x6221,
+ 0x622A,
+ 0x622E,
+ 0x6230,
+ 0x6232,
+ 0x6233,
+ 0x6241,
+ 0x624E,
+ 0x625E,
+ 0x6263,
+ 0x625B,
+ 0x6260,
+ 0x6268,
+ 0x627C,
+ 0x6282,
+ 0x6289,
+ 0x627E,
+ 0x6292,
+ 0x6293,
+ 0x6296,
+ 0x62D4,
+ 0x6283,
+ 0x6294,
+ 0x62D7,
+ 0x62D1,
+ 0x62BB,
+ 0x62CF,
+ 0x62FF,
+ 0x62C6,
+ 0x64D4,
+ 0x62C8,
+ 0x62DC,
+ 0x62CC,
+ 0x62CA,
+ 0x62C2,
+ 0x62C7,
+ 0x629B,
+ 0x62C9,
+ 0x630C,
+ 0x62EE,
+ 0x62F1,
+ 0x6327,
+ 0x6302,
+ 0x6308,
+ 0x62EF,
+ 0x62F5,
+ 0x6350,
+ 0x633E,
+ 0x634D,
+ 0x641C,
+ 0x634F,
+ 0x6396,
+ 0x638E,
+ 0x6380,
+ 0x63AB,
+ 0x6376,
+ 0x63A3,
+ 0x638F,
+ 0x6389,
+ 0x639F,
+ 0x63B5,
+ 0x636B,
+ 0x6369,
+ 0x63BE,
+ 0x63E9,
+ 0x63C0,
+ 0x63C6,
+ 0x63E3,
+ 0x63C9,
+ 0x63D2,
+ 0x63F6,
+ 0x63C4,
+ 0x6416,
+ 0x6434,
+ 0x6406,
+ 0x6413,
+ 0x6426,
+ 0x6436,
+ 0x651D,
+ 0x6417,
+ 0x6428,
+ 0x640F,
+ 0x6467,
+ 0x646F,
+ 0x6476,
+ 0x644E,
+ 0x652A,
+ 0x6495,
+ 0x6493,
+ 0x64A5,
+ 0x64A9,
+ 0x6488,
+ 0x64BC,
+ 0x64DA,
+ 0x64D2,
+ 0x64C5,
+ 0x64C7,
+ 0x64BB,
+ 0x64D8,
+ 0x64C2,
+ 0x64F1,
+ 0x64E7,
+ 0x8209,
+ 0x64E0,
+ 0x64E1,
+ 0x62AC,
+ 0x64E3,
+ 0x64EF,
+ 0x652C,
+ 0x64F6,
+ 0x64F4,
+ 0x64F2,
+ 0x64FA,
+ 0x6500,
+ 0x64FD,
+ 0x6518,
+ 0x651C,
+ 0x6505,
+ 0x6524,
+ 0x6523,
+ 0x652B,
+ 0x6534,
+ 0x6535,
+ 0x6537,
+ 0x6536,
+ 0x6538,
+ 0x754B,
+ 0x6548,
+ 0x6556,
+ 0x6555,
+ 0x654D,
+ 0x6558,
+ 0x655E,
+ 0x655D,
+ 0x6572,
+ 0x6578,
+ 0x6582,
+ 0x6583,
+ 0x8B8A,
+ 0x659B,
+ 0x659F,
+ 0x65AB,
+ 0x65B7,
+ 0x65C3,
+ 0x65C6,
+ 0x65C1,
+ 0x65C4,
+ 0x65CC,
+ 0x65D2,
+ 0x65DB,
+ 0x65D9,
+ 0x65E0,
+ 0x65E1,
+ 0x65F1,
+ 0x6772,
+ 0x660A,
+ 0x6603,
+ 0x65FB,
+ 0x6773,
+ 0x6635,
+ 0x6636,
+ 0x6634,
+ 0x661C,
+ 0x664F,
+ 0x6644,
+ 0x6649,
+ 0x6641,
+ 0x665E,
+ 0x665D,
+ 0x6664,
+ 0x6667,
+ 0x6668,
+ 0x665F,
+ 0x6662,
+ 0x6670,
+ 0x6683,
+ 0x6688,
+ 0x668E,
+ 0x6689,
+ 0x6684,
+ 0x6698,
+ 0x669D,
+ 0x66C1,
+ 0x66B9,
+ 0x66C9,
+ 0x66BE,
+ 0x66BC,
+ 0x66C4,
+ 0x66B8,
+ 0x66D6,
+ 0x66DA,
+ 0x66E0,
+ 0x663F,
+ 0x66E6,
+ 0x66E9,
+ 0x66F0,
+ 0x66F5,
+ 0x66F7,
+ 0x670F,
+ 0x6716,
+ 0x671E,
+ 0x6726,
+ 0x6727,
+ 0x9738,
+ 0x672E,
+ 0x673F,
+ 0x6736,
+ 0x6741,
+ 0x6738,
+ 0x6737,
+ 0x6746,
+ 0x675E,
+ 0x6760,
+ 0x6759,
+ 0x6763,
+ 0x6764,
+ 0x6789,
+ 0x6770,
+ 0x67A9,
+ 0x677C,
+ 0x676A,
+ 0x678C,
+ 0x678B,
+ 0x67A6,
+ 0x67A1,
+ 0x6785,
+ 0x67B7,
+ 0x67EF,
+ 0x67B4,
+ 0x67EC,
+ 0x67B3,
+ 0x67E9,
+ 0x67B8,
+ 0x67E4,
+ 0x67DE,
+ 0x67DD,
+ 0x67E2,
+ 0x67EE,
+ 0x67B9,
+ 0x67CE,
+ 0x67C6,
+ 0x67E7,
+ 0x6A9C,
+ 0x681E,
+ 0x6846,
+ 0x6829,
+ 0x6840,
+ 0x684D,
+ 0x6832,
+ 0x684E,
+ 0x68B3,
+ 0x682B,
+ 0x6859,
+ 0x6863,
+ 0x6877,
+ 0x687F,
+ 0x689F,
+ 0x688F,
+ 0x68AD,
+ 0x6894,
+ 0x689D,
+ 0x689B,
+ 0x6883,
+ 0x6AAE,
+ 0x68B9,
+ 0x6874,
+ 0x68B5,
+ 0x68A0,
+ 0x68BA,
+ 0x690F,
+ 0x688D,
+ 0x687E,
+ 0x6901,
+ 0x68CA,
+ 0x6908,
+ 0x68D8,
+ 0x6922,
+ 0x6926,
+ 0x68E1,
+ 0x690C,
+ 0x68CD,
+ 0x68D4,
+ 0x68E7,
+ 0x68D5,
+ 0x6936,
+ 0x6912,
+ 0x6904,
+ 0x68D7,
+ 0x68E3,
+ 0x6925,
+ 0x68F9,
+ 0x68E0,
+ 0x68EF,
+ 0x6928,
+ 0x692A,
+ 0x691A,
+ 0x6923,
+ 0x6921,
+ 0x68C6,
+ 0x6979,
+ 0x6977,
+ 0x695C,
+ 0x6978,
+ 0x696B,
+ 0x6954,
+ 0x697E,
+ 0x696E,
+ 0x6939,
+ 0x6974,
+ 0x693D,
+ 0x6959,
+ 0x6930,
+ 0x6961,
+ 0x695E,
+ 0x695D,
+ 0x6981,
+ 0x696A,
+ 0x69B2,
+ 0x69AE,
+ 0x69D0,
+ 0x69BF,
+ 0x69C1,
+ 0x69D3,
+ 0x69BE,
+ 0x69CE,
+ 0x5BE8,
+ 0x69CA,
+ 0x69DD,
+ 0x69BB,
+ 0x69C3,
+ 0x69A7,
+ 0x6A2E,
+ 0x6991,
+ 0x69A0,
+ 0x699C,
+ 0x6995,
+ 0x69B4,
+ 0x69DE,
+ 0x69E8,
+ 0x6A02,
+ 0x6A1B,
+ 0x69FF,
+ 0x6B0A,
+ 0x69F9,
+ 0x69F2,
+ 0x69E7,
+ 0x6A05,
+ 0x69B1,
+ 0x6A1E,
+ 0x69ED,
+ 0x6A14,
+ 0x69EB,
+ 0x6A0A,
+ 0x6A12,
+ 0x6AC1,
+ 0x6A23,
+ 0x6A13,
+ 0x6A44,
+ 0x6A0C,
+ 0x6A72,
+ 0x6A36,
+ 0x6A78,
+ 0x6A47,
+ 0x6A62,
+ 0x6A59,
+ 0x6A66,
+ 0x6A48,
+ 0x6A38,
+ 0x6A22,
+ 0x6A90,
+ 0x6A8D,
+ 0x6AA0,
+ 0x6A84,
+ 0x6AA2,
+ 0x6AA3,
+ 0x6A97,
+ 0x8617,
+ 0x6ABB,
+ 0x6AC3,
+ 0x6AC2,
+ 0x6AB8,
+ 0x6AB3,
+ 0x6AAC,
+ 0x6ADE,
+ 0x6AD1,
+ 0x6ADF,
+ 0x6AAA,
+ 0x6ADA,
+ 0x6AEA,
+ 0x6AFB,
+ 0x6B05,
+ 0x8616,
+ 0x6AFA,
+ 0x6B12,
+ 0x6B16,
+ 0x9B31,
+ 0x6B1F,
+ 0x6B38,
+ 0x6B37,
+ 0x76DC,
+ 0x6B39,
+ 0x98EE,
+ 0x6B47,
+ 0x6B43,
+ 0x6B49,
+ 0x6B50,
+ 0x6B59,
+ 0x6B54,
+ 0x6B5B,
+ 0x6B5F,
+ 0x6B61,
+ 0x6B78,
+ 0x6B79,
+ 0x6B7F,
+ 0x6B80,
+ 0x6B84,
+ 0x6B83,
+ 0x6B8D,
+ 0x6B98,
+ 0x6B95,
+ 0x6B9E,
+ 0x6BA4,
+ 0x6BAA,
+ 0x6BAB,
+ 0x6BAF,
+ 0x6BB2,
+ 0x6BB1,
+ 0x6BB3,
+ 0x6BB7,
+ 0x6BBC,
+ 0x6BC6,
+ 0x6BCB,
+ 0x6BD3,
+ 0x6BDF,
+ 0x6BEC,
+ 0x6BEB,
+ 0x6BF3,
+ 0x6BEF,
+ 0x9EBE,
+ 0x6C08,
+ 0x6C13,
+ 0x6C14,
+ 0x6C1B,
+ 0x6C24,
+ 0x6C23,
+ 0x6C5E,
+ 0x6C55,
+ 0x6C62,
+ 0x6C6A,
+ 0x6C82,
+ 0x6C8D,
+ 0x6C9A,
+ 0x6C81,
+ 0x6C9B,
+ 0x6C7E,
+ 0x6C68,
+ 0x6C73,
+ 0x6C92,
+ 0x6C90,
+ 0x6CC4,
+ 0x6CF1,
+ 0x6CD3,
+ 0x6CBD,
+ 0x6CD7,
+ 0x6CC5,
+ 0x6CDD,
+ 0x6CAE,
+ 0x6CB1,
+ 0x6CBE,
+ 0x6CBA,
+ 0x6CDB,
+ 0x6CEF,
+ 0x6CD9,
+ 0x6CEA,
+ 0x6D1F,
+ 0x884D,
+ 0x6D36,
+ 0x6D2B,
+ 0x6D3D,
+ 0x6D38,
+ 0x6D19,
+ 0x6D35,
+ 0x6D33,
+ 0x6D12,
+ 0x6D0C,
+ 0x6D63,
+ 0x6D93,
+ 0x6D64,
+ 0x6D5A,
+ 0x6D79,
+ 0x6D59,
+ 0x6D8E,
+ 0x6D95,
+ 0x6FE4,
+ 0x6D85,
+ 0x6DF9,
+ 0x6E15,
+ 0x6E0A,
+ 0x6DB5,
+ 0x6DC7,
+ 0x6DE6,
+ 0x6DB8,
+ 0x6DC6,
+ 0x6DEC,
+ 0x6DDE,
+ 0x6DCC,
+ 0x6DE8,
+ 0x6DD2,
+ 0x6DC5,
+ 0x6DFA,
+ 0x6DD9,
+ 0x6DE4,
+ 0x6DD5,
+ 0x6DEA,
+ 0x6DEE,
+ 0x6E2D,
+ 0x6E6E,
+ 0x6E2E,
+ 0x6E19,
+ 0x6E72,
+ 0x6E5F,
+ 0x6E3E,
+ 0x6E23,
+ 0x6E6B,
+ 0x6E2B,
+ 0x6E76,
+ 0x6E4D,
+ 0x6E1F,
+ 0x6E43,
+ 0x6E3A,
+ 0x6E4E,
+ 0x6E24,
+ 0x6EFF,
+ 0x6E1D,
+ 0x6E38,
+ 0x6E82,
+ 0x6EAA,
+ 0x6E98,
+ 0x6EC9,
+ 0x6EB7,
+ 0x6ED3,
+ 0x6EBD,
+ 0x6EAF,
+ 0x6EC4,
+ 0x6EB2,
+ 0x6ED4,
+ 0x6ED5,
+ 0x6E8F,
+ 0x6EA5,
+ 0x6EC2,
+ 0x6E9F,
+ 0x6F41,
+ 0x6F11,
+ 0x704C,
+ 0x6EEC,
+ 0x6EF8,
+ 0x6EFE,
+ 0x6F3F,
+ 0x6EF2,
+ 0x6F31,
+ 0x6EEF,
+ 0x6F32,
+ 0x6ECC,
+ 0x6F3E,
+ 0x6F13,
+ 0x6EF7,
+ 0x6F86,
+ 0x6F7A,
+ 0x6F78,
+ 0x6F81,
+ 0x6F80,
+ 0x6F6F,
+ 0x6F5B,
+ 0x6FF3,
+ 0x6F6D,
+ 0x6F82,
+ 0x6F7C,
+ 0x6F58,
+ 0x6F8E,
+ 0x6F91,
+ 0x6FC2,
+ 0x6F66,
+ 0x6FB3,
+ 0x6FA3,
+ 0x6FA1,
+ 0x6FA4,
+ 0x6FB9,
+ 0x6FC6,
+ 0x6FAA,
+ 0x6FDF,
+ 0x6FD5,
+ 0x6FEC,
+ 0x6FD4,
+ 0x6FD8,
+ 0x6FF1,
+ 0x6FEE,
+ 0x6FDB,
+ 0x7009,
+ 0x700B,
+ 0x6FFA,
+ 0x7011,
+ 0x7001,
+ 0x700F,
+ 0x6FFE,
+ 0x701B,
+ 0x701A,
+ 0x6F74,
+ 0x701D,
+ 0x7018,
+ 0x701F,
+ 0x7030,
+ 0x703E,
+ 0x7032,
+ 0x7051,
+ 0x7063,
+ 0x7099,
+ 0x7092,
+ 0x70AF,
+ 0x70F1,
+ 0x70AC,
+ 0x70B8,
+ 0x70B3,
+ 0x70AE,
+ 0x70DF,
+ 0x70CB,
+ 0x70DD,
+ 0x70D9,
+ 0x7109,
+ 0x70FD,
+ 0x711C,
+ 0x7119,
+ 0x7165,
+ 0x7155,
+ 0x7188,
+ 0x7166,
+ 0x7162,
+ 0x714C,
+ 0x7156,
+ 0x716C,
+ 0x718F,
+ 0x71FB,
+ 0x7184,
+ 0x7195,
+ 0x71A8,
+ 0x71AC,
+ 0x71D7,
+ 0x71B9,
+ 0x71BE,
+ 0x71D2,
+ 0x71C9,
+ 0x71D4,
+ 0x71CE,
+ 0x71E0,
+ 0x71EC,
+ 0x71E7,
+ 0x71F5,
+ 0x71FC,
+ 0x71F9,
+ 0x71FF,
+ 0x720D,
+ 0x7210,
+ 0x721B,
+ 0x7228,
+ 0x722D,
+ 0x722C,
+ 0x7230,
+ 0x7232,
+ 0x723B,
+ 0x723C,
+ 0x723F,
+ 0x7240,
+ 0x7246,
+ 0x724B,
+ 0x7258,
+ 0x7274,
+ 0x727E,
+ 0x7282,
+ 0x7281,
+ 0x7287,
+ 0x7292,
+ 0x7296,
+ 0x72A2,
+ 0x72A7,
+ 0x72B9,
+ 0x72B2,
+ 0x72C3,
+ 0x72C6,
+ 0x72C4,
+ 0x72CE,
+ 0x72D2,
+ 0x72E2,
+ 0x72E0,
+ 0x72E1,
+ 0x72F9,
+ 0x72F7,
+ 0x500F,
+ 0x7317,
+ 0x730A,
+ 0x731C,
+ 0x7316,
+ 0x731D,
+ 0x7334,
+ 0x732F,
+ 0x7329,
+ 0x7325,
+ 0x733E,
+ 0x734E,
+ 0x734F,
+ 0x9ED8,
+ 0x7357,
+ 0x736A,
+ 0x7368,
+ 0x7370,
+ 0x7378,
+ 0x7375,
+ 0x737B,
+ 0x737A,
+ 0x73C8,
+ 0x73B3,
+ 0x73CE,
+ 0x73BB,
+ 0x73C0,
+ 0x73E5,
+ 0x73EE,
+ 0x73DE,
+ 0x74A2,
+ 0x7405,
+ 0x746F,
+ 0x7425,
+ 0x73F8,
+ 0x7432,
+ 0x743A,
+ 0x7455,
+ 0x743F,
+ 0x745F,
+ 0x7459,
+ 0x7441,
+ 0x745C,
+ 0x7469,
+ 0x7470,
+ 0x7463,
+ 0x746A,
+ 0x7476,
+ 0x747E,
+ 0x748B,
+ 0x749E,
+ 0x74A7,
+ 0x74CA,
+ 0x74CF,
+ 0x74D4,
+ 0x73F1,
+ 0x74E0,
+ 0x74E3,
+ 0x74E7,
+ 0x74E9,
+ 0x74EE,
+ 0x74F2,
+ 0x74F0,
+ 0x74F1,
+ 0x74F8,
+ 0x74F7,
+ 0x7504,
+ 0x7503,
+ 0x7505,
+ 0x750C,
+ 0x750E,
+ 0x750D,
+ 0x7515,
+ 0x7513,
+ 0x751E,
+ 0x7526,
+ 0x752C,
+ 0x753C,
+ 0x7544,
+ 0x754D,
+ 0x754A,
+ 0x7549,
+ 0x755B,
+ 0x7546,
+ 0x755A,
+ 0x7569,
+ 0x7564,
+ 0x7567,
+ 0x756B,
+ 0x756D,
+ 0x7578,
+ 0x7576,
+ 0x7586,
+ 0x7587,
+ 0x7574,
+ 0x758A,
+ 0x7589,
+ 0x7582,
+ 0x7594,
+ 0x759A,
+ 0x759D,
+ 0x75A5,
+ 0x75A3,
+ 0x75C2,
+ 0x75B3,
+ 0x75C3,
+ 0x75B5,
+ 0x75BD,
+ 0x75B8,
+ 0x75BC,
+ 0x75B1,
+ 0x75CD,
+ 0x75CA,
+ 0x75D2,
+ 0x75D9,
+ 0x75E3,
+ 0x75DE,
+ 0x75FE,
+ 0x75FF,
+ 0x75FC,
+ 0x7601,
+ 0x75F0,
+ 0x75FA,
+ 0x75F2,
+ 0x75F3,
+ 0x760B,
+ 0x760D,
+ 0x7609,
+ 0x761F,
+ 0x7627,
+ 0x7620,
+ 0x7621,
+ 0x7622,
+ 0x7624,
+ 0x7634,
+ 0x7630,
+ 0x763B,
+ 0x7647,
+ 0x7648,
+ 0x7646,
+ 0x765C,
+ 0x7658,
+ 0x7661,
+ 0x7662,
+ 0x7668,
+ 0x7669,
+ 0x766A,
+ 0x7667,
+ 0x766C,
+ 0x7670,
+ 0x7672,
+ 0x7676,
+ 0x7678,
+ 0x767C,
+ 0x7680,
+ 0x7683,
+ 0x7688,
+ 0x768B,
+ 0x768E,
+ 0x7696,
+ 0x7693,
+ 0x7699,
+ 0x769A,
+ 0x76B0,
+ 0x76B4,
+ 0x76B8,
+ 0x76B9,
+ 0x76BA,
+ 0x76C2,
+ 0x76CD,
+ 0x76D6,
+ 0x76D2,
+ 0x76DE,
+ 0x76E1,
+ 0x76E5,
+ 0x76E7,
+ 0x76EA,
+ 0x862F,
+ 0x76FB,
+ 0x7708,
+ 0x7707,
+ 0x7704,
+ 0x7729,
+ 0x7724,
+ 0x771E,
+ 0x7725,
+ 0x7726,
+ 0x771B,
+ 0x7737,
+ 0x7738,
+ 0x7747,
+ 0x775A,
+ 0x7768,
+ 0x776B,
+ 0x775B,
+ 0x7765,
+ 0x777F,
+ 0x777E,
+ 0x7779,
+ 0x778E,
+ 0x778B,
+ 0x7791,
+ 0x77A0,
+ 0x779E,
+ 0x77B0,
+ 0x77B6,
+ 0x77B9,
+ 0x77BF,
+ 0x77BC,
+ 0x77BD,
+ 0x77BB,
+ 0x77C7,
+ 0x77CD,
+ 0x77D7,
+ 0x77DA,
+ 0x77DC,
+ 0x77E3,
+ 0x77EE,
+ 0x77FC,
+ 0x780C,
+ 0x7812,
+ 0x7926,
+ 0x7820,
+ 0x792A,
+ 0x7845,
+ 0x788E,
+ 0x7874,
+ 0x7886,
+ 0x787C,
+ 0x789A,
+ 0x788C,
+ 0x78A3,
+ 0x78B5,
+ 0x78AA,
+ 0x78AF,
+ 0x78D1,
+ 0x78C6,
+ 0x78CB,
+ 0x78D4,
+ 0x78BE,
+ 0x78BC,
+ 0x78C5,
+ 0x78CA,
+ 0x78EC,
+ 0x78E7,
+ 0x78DA,
+ 0x78FD,
+ 0x78F4,
+ 0x7907,
+ 0x7912,
+ 0x7911,
+ 0x7919,
+ 0x792C,
+ 0x792B,
+ 0x7940,
+ 0x7960,
+ 0x7957,
+ 0x795F,
+ 0x795A,
+ 0x7955,
+ 0x7953,
+ 0x797A,
+ 0x797F,
+ 0x798A,
+ 0x799D,
+ 0x79A7,
+ 0x9F4B,
+ 0x79AA,
+ 0x79AE,
+ 0x79B3,
+ 0x79B9,
+ 0x79BA,
+ 0x79C9,
+ 0x79D5,
+ 0x79E7,
+ 0x79EC,
+ 0x79E1,
+ 0x79E3,
+ 0x7A08,
+ 0x7A0D,
+ 0x7A18,
+ 0x7A19,
+ 0x7A20,
+ 0x7A1F,
+ 0x7980,
+ 0x7A31,
+ 0x7A3B,
+ 0x7A3E,
+ 0x7A37,
+ 0x7A43,
+ 0x7A57,
+ 0x7A49,
+ 0x7A61,
+ 0x7A62,
+ 0x7A69,
+ 0x9F9D,
+ 0x7A70,
+ 0x7A79,
+ 0x7A7D,
+ 0x7A88,
+ 0x7A97,
+ 0x7A95,
+ 0x7A98,
+ 0x7A96,
+ 0x7AA9,
+ 0x7AC8,
+ 0x7AB0,
+ 0x7AB6,
+ 0x7AC5,
+ 0x7AC4,
+ 0x7ABF,
+ 0x9083,
+ 0x7AC7,
+ 0x7ACA,
+ 0x7ACD,
+ 0x7ACF,
+ 0x7AD5,
+ 0x7AD3,
+ 0x7AD9,
+ 0x7ADA,
+ 0x7ADD,
+ 0x7AE1,
+ 0x7AE2,
+ 0x7AE6,
+ 0x7AED,
+ 0x7AF0,
+ 0x7B02,
+ 0x7B0F,
+ 0x7B0A,
+ 0x7B06,
+ 0x7B33,
+ 0x7B18,
+ 0x7B19,
+ 0x7B1E,
+ 0x7B35,
+ 0x7B28,
+ 0x7B36,
+ 0x7B50,
+ 0x7B7A,
+ 0x7B04,
+ 0x7B4D,
+ 0x7B0B,
+ 0x7B4C,
+ 0x7B45,
+ 0x7B75,
+ 0x7B65,
+ 0x7B74,
+ 0x7B67,
+ 0x7B70,
+ 0x7B71,
+ 0x7B6C,
+ 0x7B6E,
+ 0x7B9D,
+ 0x7B98,
+ 0x7B9F,
+ 0x7B8D,
+ 0x7B9C,
+ 0x7B9A,
+ 0x7B8B,
+ 0x7B92,
+ 0x7B8F,
+ 0x7B5D,
+ 0x7B99,
+ 0x7BCB,
+ 0x7BC1,
+ 0x7BCC,
+ 0x7BCF,
+ 0x7BB4,
+ 0x7BC6,
+ 0x7BDD,
+ 0x7BE9,
+ 0x7C11,
+ 0x7C14,
+ 0x7BE6,
+ 0x7BE5,
+ 0x7C60,
+ 0x7C00,
+ 0x7C07,
+ 0x7C13,
+ 0x7BF3,
+ 0x7BF7,
+ 0x7C17,
+ 0x7C0D,
+ 0x7BF6,
+ 0x7C23,
+ 0x7C27,
+ 0x7C2A,
+ 0x7C1F,
+ 0x7C37,
+ 0x7C2B,
+ 0x7C3D,
+ 0x7C4C,
+ 0x7C43,
+ 0x7C54,
+ 0x7C4F,
+ 0x7C40,
+ 0x7C50,
+ 0x7C58,
+ 0x7C5F,
+ 0x7C64,
+ 0x7C56,
+ 0x7C65,
+ 0x7C6C,
+ 0x7C75,
+ 0x7C83,
+ 0x7C90,
+ 0x7CA4,
+ 0x7CAD,
+ 0x7CA2,
+ 0x7CAB,
+ 0x7CA1,
+ 0x7CA8,
+ 0x7CB3,
+ 0x7CB2,
+ 0x7CB1,
+ 0x7CAE,
+ 0x7CB9,
+ 0x7CBD,
+ 0x7CC0,
+ 0x7CC5,
+ 0x7CC2,
+ 0x7CD8,
+ 0x7CD2,
+ 0x7CDC,
+ 0x7CE2,
+ 0x9B3B,
+ 0x7CEF,
+ 0x7CF2,
+ 0x7CF4,
+ 0x7CF6,
+ 0x7CFA,
+ 0x7D06,
+ 0x7D02,
+ 0x7D1C,
+ 0x7D15,
+ 0x7D0A,
+ 0x7D45,
+ 0x7D4B,
+ 0x7D2E,
+ 0x7D32,
+ 0x7D3F,
+ 0x7D35,
+ 0x7D46,
+ 0x7D73,
+ 0x7D56,
+ 0x7D4E,
+ 0x7D72,
+ 0x7D68,
+ 0x7D6E,
+ 0x7D4F,
+ 0x7D63,
+ 0x7D93,
+ 0x7D89,
+ 0x7D5B,
+ 0x7D8F,
+ 0x7D7D,
+ 0x7D9B,
+ 0x7DBA,
+ 0x7DAE,
+ 0x7DA3,
+ 0x7DB5,
+ 0x7DC7,
+ 0x7DBD,
+ 0x7DAB,
+ 0x7E3D,
+ 0x7DA2,
+ 0x7DAF,
+ 0x7DDC,
+ 0x7DB8,
+ 0x7D9F,
+ 0x7DB0,
+ 0x7DD8,
+ 0x7DDD,
+ 0x7DE4,
+ 0x7DDE,
+ 0x7DFB,
+ 0x7DF2,
+ 0x7DE1,
+ 0x7E05,
+ 0x7E0A,
+ 0x7E23,
+ 0x7E21,
+ 0x7E12,
+ 0x7E31,
+ 0x7E1F,
+ 0x7E09,
+ 0x7E0B,
+ 0x7E22,
+ 0x7E46,
+ 0x7E66,
+ 0x7E3B,
+ 0x7E35,
+ 0x7E39,
+ 0x7E43,
+ 0x7E37,
+ 0x7E32,
+ 0x7E3A,
+ 0x7E67,
+ 0x7E5D,
+ 0x7E56,
+ 0x7E5E,
+ 0x7E59,
+ 0x7E5A,
+ 0x7E79,
+ 0x7E6A,
+ 0x7E69,
+ 0x7E7C,
+ 0x7E7B,
+ 0x7E83,
+ 0x7DD5,
+ 0x7E7D,
+ 0x8FAE,
+ 0x7E7F,
+ 0x7E88,
+ 0x7E89,
+ 0x7E8C,
+ 0x7E92,
+ 0x7E90,
+ 0x7E93,
+ 0x7E94,
+ 0x7E96,
+ 0x7E8E,
+ 0x7E9B,
+ 0x7E9C,
+ 0x7F38,
+ 0x7F3A,
+ 0x7F45,
+ 0x7F4C,
+ 0x7F4D,
+ 0x7F4E,
+ 0x7F50,
+ 0x7F51,
+ 0x7F55,
+ 0x7F54,
+ 0x7F58,
+ 0x7F5F,
+ 0x7F60,
+ 0x7F68,
+ 0x7F69,
+ 0x7F67,
+ 0x7F78,
+ 0x7F82,
+ 0x7F86,
+ 0x7F83,
+ 0x7F88,
+ 0x7F87,
+ 0x7F8C,
+ 0x7F94,
+ 0x7F9E,
+ 0x7F9D,
+ 0x7F9A,
+ 0x7FA3,
+ 0x7FAF,
+ 0x7FB2,
+ 0x7FB9,
+ 0x7FAE,
+ 0x7FB6,
+ 0x7FB8,
+ 0x8B71,
+ 0x7FC5,
+ 0x7FC6,
+ 0x7FCA,
+ 0x7FD5,
+ 0x7FD4,
+ 0x7FE1,
+ 0x7FE6,
+ 0x7FE9,
+ 0x7FF3,
+ 0x7FF9,
+ 0x98DC,
+ 0x8006,
+ 0x8004,
+ 0x800B,
+ 0x8012,
+ 0x8018,
+ 0x8019,
+ 0x801C,
+ 0x8021,
+ 0x8028,
+ 0x803F,
+ 0x803B,
+ 0x804A,
+ 0x8046,
+ 0x8052,
+ 0x8058,
+ 0x805A,
+ 0x805F,
+ 0x8062,
+ 0x8068,
+ 0x8073,
+ 0x8072,
+ 0x8070,
+ 0x8076,
+ 0x8079,
+ 0x807D,
+ 0x807F,
+ 0x8084,
+ 0x8086,
+ 0x8085,
+ 0x809B,
+ 0x8093,
+ 0x809A,
+ 0x80AD,
+ 0x5190,
+ 0x80AC,
+ 0x80DB,
+ 0x80E5,
+ 0x80D9,
+ 0x80DD,
+ 0x80C4,
+ 0x80DA,
+ 0x80D6,
+ 0x8109,
+ 0x80EF,
+ 0x80F1,
+ 0x811B,
+ 0x8129,
+ 0x8123,
+ 0x812F,
+ 0x814B,
+ 0x968B,
+ 0x8146,
+ 0x813E,
+ 0x8153,
+ 0x8151,
+ 0x80FC,
+ 0x8171,
+ 0x816E,
+ 0x8165,
+ 0x8166,
+ 0x8174,
+ 0x8183,
+ 0x8188,
+ 0x818A,
+ 0x8180,
+ 0x8182,
+ 0x81A0,
+ 0x8195,
+ 0x81A4,
+ 0x81A3,
+ 0x815F,
+ 0x8193,
+ 0x81A9,
+ 0x81B0,
+ 0x81B5,
+ 0x81BE,
+ 0x81B8,
+ 0x81BD,
+ 0x81C0,
+ 0x81C2,
+ 0x81BA,
+ 0x81C9,
+ 0x81CD,
+ 0x81D1,
+ 0x81D9,
+ 0x81D8,
+ 0x81C8,
+ 0x81DA,
+ 0x81DF,
+ 0x81E0,
+ 0x81E7,
+ 0x81FA,
+ 0x81FB,
+ 0x81FE,
+ 0x8201,
+ 0x8202,
+ 0x8205,
+ 0x8207,
+ 0x820A,
+ 0x820D,
+ 0x8210,
+ 0x8216,
+ 0x8229,
+ 0x822B,
+ 0x8238,
+ 0x8233,
+ 0x8240,
+ 0x8259,
+ 0x8258,
+ 0x825D,
+ 0x825A,
+ 0x825F,
+ 0x8264,
+ 0x8262,
+ 0x8268,
+ 0x826A,
+ 0x826B,
+ 0x822E,
+ 0x8271,
+ 0x8277,
+ 0x8278,
+ 0x827E,
+ 0x828D,
+ 0x8292,
+ 0x82AB,
+ 0x829F,
+ 0x82BB,
+ 0x82AC,
+ 0x82E1,
+ 0x82E3,
+ 0x82DF,
+ 0x82D2,
+ 0x82F4,
+ 0x82F3,
+ 0x82FA,
+ 0x8393,
+ 0x8303,
+ 0x82FB,
+ 0x82F9,
+ 0x82DE,
+ 0x8306,
+ 0x82DC,
+ 0x8309,
+ 0x82D9,
+ 0x8335,
+ 0x8334,
+ 0x8316,
+ 0x8332,
+ 0x8331,
+ 0x8340,
+ 0x8339,
+ 0x8350,
+ 0x8345,
+ 0x832F,
+ 0x832B,
+ 0x8317,
+ 0x8318,
+ 0x8385,
+ 0x839A,
+ 0x83AA,
+ 0x839F,
+ 0x83A2,
+ 0x8396,
+ 0x8323,
+ 0x838E,
+ 0x8387,
+ 0x838A,
+ 0x837C,
+ 0x83B5,
+ 0x8373,
+ 0x8375,
+ 0x83A0,
+ 0x8389,
+ 0x83A8,
+ 0x83F4,
+ 0x8413,
+ 0x83EB,
+ 0x83CE,
+ 0x83FD,
+ 0x8403,
+ 0x83D8,
+ 0x840B,
+ 0x83C1,
+ 0x83F7,
+ 0x8407,
+ 0x83E0,
+ 0x83F2,
+ 0x840D,
+ 0x8422,
+ 0x8420,
+ 0x83BD,
+ 0x8438,
+ 0x8506,
+ 0x83FB,
+ 0x846D,
+ 0x842A,
+ 0x843C,
+ 0x855A,
+ 0x8484,
+ 0x8477,
+ 0x846B,
+ 0x84AD,
+ 0x846E,
+ 0x8482,
+ 0x8469,
+ 0x8446,
+ 0x842C,
+ 0x846F,
+ 0x8479,
+ 0x8435,
+ 0x84CA,
+ 0x8462,
+ 0x84B9,
+ 0x84BF,
+ 0x849F,
+ 0x84D9,
+ 0x84CD,
+ 0x84BB,
+ 0x84DA,
+ 0x84D0,
+ 0x84C1,
+ 0x84C6,
+ 0x84D6,
+ 0x84A1,
+ 0x8521,
+ 0x84FF,
+ 0x84F4,
+ 0x8517,
+ 0x8518,
+ 0x852C,
+ 0x851F,
+ 0x8515,
+ 0x8514,
+ 0x84FC,
+ 0x8540,
+ 0x8563,
+ 0x8558,
+ 0x8548,
+ 0x8541,
+ 0x8602,
+ 0x854B,
+ 0x8555,
+ 0x8580,
+ 0x85A4,
+ 0x8588,
+ 0x8591,
+ 0x858A,
+ 0x85A8,
+ 0x856D,
+ 0x8594,
+ 0x859B,
+ 0x85EA,
+ 0x8587,
+ 0x859C,
+ 0x8577,
+ 0x857E,
+ 0x8590,
+ 0x85C9,
+ 0x85BA,
+ 0x85CF,
+ 0x85B9,
+ 0x85D0,
+ 0x85D5,
+ 0x85DD,
+ 0x85E5,
+ 0x85DC,
+ 0x85F9,
+ 0x860A,
+ 0x8613,
+ 0x860B,
+ 0x85FE,
+ 0x85FA,
+ 0x8606,
+ 0x8622,
+ 0x861A,
+ 0x8630,
+ 0x863F,
+ 0x864D,
+ 0x4E55,
+ 0x8654,
+ 0x865F,
+ 0x8667,
+ 0x8671,
+ 0x8693,
+ 0x86A3,
+ 0x86A9,
+ 0x86AA,
+ 0x868B,
+ 0x868C,
+ 0x86B6,
+ 0x86AF,
+ 0x86C4,
+ 0x86C6,
+ 0x86B0,
+ 0x86C9,
+ 0x8823,
+ 0x86AB,
+ 0x86D4,
+ 0x86DE,
+ 0x86E9,
+ 0x86EC,
+ 0x86DF,
+ 0x86DB,
+ 0x86EF,
+ 0x8712,
+ 0x8706,
+ 0x8708,
+ 0x8700,
+ 0x8703,
+ 0x86FB,
+ 0x8711,
+ 0x8709,
+ 0x870D,
+ 0x86F9,
+ 0x870A,
+ 0x8734,
+ 0x873F,
+ 0x8737,
+ 0x873B,
+ 0x8725,
+ 0x8729,
+ 0x871A,
+ 0x8760,
+ 0x875F,
+ 0x8778,
+ 0x874C,
+ 0x874E,
+ 0x8774,
+ 0x8757,
+ 0x8768,
+ 0x876E,
+ 0x8759,
+ 0x8753,
+ 0x8763,
+ 0x876A,
+ 0x8805,
+ 0x87A2,
+ 0x879F,
+ 0x8782,
+ 0x87AF,
+ 0x87CB,
+ 0x87BD,
+ 0x87C0,
+ 0x87D0,
+ 0x96D6,
+ 0x87AB,
+ 0x87C4,
+ 0x87B3,
+ 0x87C7,
+ 0x87C6,
+ 0x87BB,
+ 0x87EF,
+ 0x87F2,
+ 0x87E0,
+ 0x880F,
+ 0x880D,
+ 0x87FE,
+ 0x87F6,
+ 0x87F7,
+ 0x880E,
+ 0x87D2,
+ 0x8811,
+ 0x8816,
+ 0x8815,
+ 0x8822,
+ 0x8821,
+ 0x8831,
+ 0x8836,
+ 0x8839,
+ 0x8827,
+ 0x883B,
+ 0x8844,
+ 0x8842,
+ 0x8852,
+ 0x8859,
+ 0x885E,
+ 0x8862,
+ 0x886B,
+ 0x8881,
+ 0x887E,
+ 0x889E,
+ 0x8875,
+ 0x887D,
+ 0x88B5,
+ 0x8872,
+ 0x8882,
+ 0x8897,
+ 0x8892,
+ 0x88AE,
+ 0x8899,
+ 0x88A2,
+ 0x888D,
+ 0x88A4,
+ 0x88B0,
+ 0x88BF,
+ 0x88B1,
+ 0x88C3,
+ 0x88C4,
+ 0x88D4,
+ 0x88D8,
+ 0x88D9,
+ 0x88DD,
+ 0x88F9,
+ 0x8902,
+ 0x88FC,
+ 0x88F4,
+ 0x88E8,
+ 0x88F2,
+ 0x8904,
+ 0x890C,
+ 0x890A,
+ 0x8913,
+ 0x8943,
+ 0x891E,
+ 0x8925,
+ 0x892A,
+ 0x892B,
+ 0x8941,
+ 0x8944,
+ 0x893B,
+ 0x8936,
+ 0x8938,
+ 0x894C,
+ 0x891D,
+ 0x8960,
+ 0x895E,
+ 0x8966,
+ 0x8964,
+ 0x896D,
+ 0x896A,
+ 0x896F,
+ 0x8974,
+ 0x8977,
+ 0x897E,
+ 0x8983,
+ 0x8988,
+ 0x898A,
+ 0x8993,
+ 0x8998,
+ 0x89A1,
+ 0x89A9,
+ 0x89A6,
+ 0x89AC,
+ 0x89AF,
+ 0x89B2,
+ 0x89BA,
+ 0x89BD,
+ 0x89BF,
+ 0x89C0,
+ 0x89DA,
+ 0x89DC,
+ 0x89DD,
+ 0x89E7,
+ 0x89F4,
+ 0x89F8,
+ 0x8A03,
+ 0x8A16,
+ 0x8A10,
+ 0x8A0C,
+ 0x8A1B,
+ 0x8A1D,
+ 0x8A25,
+ 0x8A36,
+ 0x8A41,
+ 0x8A5B,
+ 0x8A52,
+ 0x8A46,
+ 0x8A48,
+ 0x8A7C,
+ 0x8A6D,
+ 0x8A6C,
+ 0x8A62,
+ 0x8A85,
+ 0x8A82,
+ 0x8A84,
+ 0x8AA8,
+ 0x8AA1,
+ 0x8A91,
+ 0x8AA5,
+ 0x8AA6,
+ 0x8A9A,
+ 0x8AA3,
+ 0x8AC4,
+ 0x8ACD,
+ 0x8AC2,
+ 0x8ADA,
+ 0x8AEB,
+ 0x8AF3,
+ 0x8AE7,
+ 0x8AE4,
+ 0x8AF1,
+ 0x8B14,
+ 0x8AE0,
+ 0x8AE2,
+ 0x8AF7,
+ 0x8ADE,
+ 0x8ADB,
+ 0x8B0C,
+ 0x8B07,
+ 0x8B1A,
+ 0x8AE1,
+ 0x8B16,
+ 0x8B10,
+ 0x8B17,
+ 0x8B20,
+ 0x8B33,
+ 0x97AB,
+ 0x8B26,
+ 0x8B2B,
+ 0x8B3E,
+ 0x8B28,
+ 0x8B41,
+ 0x8B4C,
+ 0x8B4F,
+ 0x8B4E,
+ 0x8B49,
+ 0x8B56,
+ 0x8B5B,
+ 0x8B5A,
+ 0x8B6B,
+ 0x8B5F,
+ 0x8B6C,
+ 0x8B6F,
+ 0x8B74,
+ 0x8B7D,
+ 0x8B80,
+ 0x8B8C,
+ 0x8B8E,
+ 0x8B92,
+ 0x8B93,
+ 0x8B96,
+ 0x8B99,
+ 0x8B9A,
+ 0x8C3A,
+ 0x8C41,
+ 0x8C3F,
+ 0x8C48,
+ 0x8C4C,
+ 0x8C4E,
+ 0x8C50,
+ 0x8C55,
+ 0x8C62,
+ 0x8C6C,
+ 0x8C78,
+ 0x8C7A,
+ 0x8C82,
+ 0x8C89,
+ 0x8C85,
+ 0x8C8A,
+ 0x8C8D,
+ 0x8C8E,
+ 0x8C94,
+ 0x8C7C,
+ 0x8C98,
+ 0x621D,
+ 0x8CAD,
+ 0x8CAA,
+ 0x8CBD,
+ 0x8CB2,
+ 0x8CB3,
+ 0x8CAE,
+ 0x8CB6,
+ 0x8CC8,
+ 0x8CC1,
+ 0x8CE4,
+ 0x8CE3,
+ 0x8CDA,
+ 0x8CFD,
+ 0x8CFA,
+ 0x8CFB,
+ 0x8D04,
+ 0x8D05,
+ 0x8D0A,
+ 0x8D07,
+ 0x8D0F,
+ 0x8D0D,
+ 0x8D10,
+ 0x9F4E,
+ 0x8D13,
+ 0x8CCD,
+ 0x8D14,
+ 0x8D16,
+ 0x8D67,
+ 0x8D6D,
+ 0x8D71,
+ 0x8D73,
+ 0x8D81,
+ 0x8D99,
+ 0x8DC2,
+ 0x8DBE,
+ 0x8DBA,
+ 0x8DCF,
+ 0x8DDA,
+ 0x8DD6,
+ 0x8DCC,
+ 0x8DDB,
+ 0x8DCB,
+ 0x8DEA,
+ 0x8DEB,
+ 0x8DDF,
+ 0x8DE3,
+ 0x8DFC,
+ 0x8E08,
+ 0x8E09,
+ 0x8DFF,
+ 0x8E1D,
+ 0x8E1E,
+ 0x8E10,
+ 0x8E1F,
+ 0x8E42,
+ 0x8E35,
+ 0x8E30,
+ 0x8E34,
+ 0x8E4A,
+ 0x8E47,
+ 0x8E49,
+ 0x8E4C,
+ 0x8E50,
+ 0x8E48,
+ 0x8E59,
+ 0x8E64,
+ 0x8E60,
+ 0x8E2A,
+ 0x8E63,
+ 0x8E55,
+ 0x8E76,
+ 0x8E72,
+ 0x8E7C,
+ 0x8E81,
+ 0x8E87,
+ 0x8E85,
+ 0x8E84,
+ 0x8E8B,
+ 0x8E8A,
+ 0x8E93,
+ 0x8E91,
+ 0x8E94,
+ 0x8E99,
+ 0x8EAA,
+ 0x8EA1,
+ 0x8EAC,
+ 0x8EB0,
+ 0x8EC6,
+ 0x8EB1,
+ 0x8EBE,
+ 0x8EC5,
+ 0x8EC8,
+ 0x8ECB,
+ 0x8EDB,
+ 0x8EE3,
+ 0x8EFC,
+ 0x8EFB,
+ 0x8EEB,
+ 0x8EFE,
+ 0x8F0A,
+ 0x8F05,
+ 0x8F15,
+ 0x8F12,
+ 0x8F19,
+ 0x8F13,
+ 0x8F1C,
+ 0x8F1F,
+ 0x8F1B,
+ 0x8F0C,
+ 0x8F26,
+ 0x8F33,
+ 0x8F3B,
+ 0x8F39,
+ 0x8F45,
+ 0x8F42,
+ 0x8F3E,
+ 0x8F4C,
+ 0x8F49,
+ 0x8F46,
+ 0x8F4E,
+ 0x8F57,
+ 0x8F5C,
+ 0x8F62,
+ 0x8F63,
+ 0x8F64,
+ 0x8F9C,
+ 0x8F9F,
+ 0x8FA3,
+ 0x8FAD,
+ 0x8FAF,
+ 0x8FB7,
+ 0x8FDA,
+ 0x8FE5,
+ 0x8FE2,
+ 0x8FEA,
+ 0x8FEF,
+ 0x9087,
+ 0x8FF4,
+ 0x9005,
+ 0x8FF9,
+ 0x8FFA,
+ 0x9011,
+ 0x9015,
+ 0x9021,
+ 0x900D,
+ 0x901E,
+ 0x9016,
+ 0x900B,
+ 0x9027,
+ 0x9036,
+ 0x9035,
+ 0x9039,
+ 0x8FF8,
+ 0x904F,
+ 0x9050,
+ 0x9051,
+ 0x9052,
+ 0x900E,
+ 0x9049,
+ 0x903E,
+ 0x9056,
+ 0x9058,
+ 0x905E,
+ 0x9068,
+ 0x906F,
+ 0x9076,
+ 0x96A8,
+ 0x9072,
+ 0x9082,
+ 0x907D,
+ 0x9081,
+ 0x9080,
+ 0x908A,
+ 0x9089,
+ 0x908F,
+ 0x90A8,
+ 0x90AF,
+ 0x90B1,
+ 0x90B5,
+ 0x90E2,
+ 0x90E4,
+ 0x6248,
+ 0x90DB,
+ 0x9102,
+ 0x9112,
+ 0x9119,
+ 0x9132,
+ 0x9130,
+ 0x914A,
+ 0x9156,
+ 0x9158,
+ 0x9163,
+ 0x9165,
+ 0x9169,
+ 0x9173,
+ 0x9172,
+ 0x918B,
+ 0x9189,
+ 0x9182,
+ 0x91A2,
+ 0x91AB,
+ 0x91AF,
+ 0x91AA,
+ 0x91B5,
+ 0x91B4,
+ 0x91BA,
+ 0x91C0,
+ 0x91C1,
+ 0x91C9,
+ 0x91CB,
+ 0x91D0,
+ 0x91D6,
+ 0x91DF,
+ 0x91E1,
+ 0x91DB,
+ 0x91FC,
+ 0x91F5,
+ 0x91F6,
+ 0x921E,
+ 0x91FF,
+ 0x9214,
+ 0x922C,
+ 0x9215,
+ 0x9211,
+ 0x925E,
+ 0x9257,
+ 0x9245,
+ 0x9249,
+ 0x9264,
+ 0x9248,
+ 0x9295,
+ 0x923F,
+ 0x924B,
+ 0x9250,
+ 0x929C,
+ 0x9296,
+ 0x9293,
+ 0x929B,
+ 0x925A,
+ 0x92CF,
+ 0x92B9,
+ 0x92B7,
+ 0x92E9,
+ 0x930F,
+ 0x92FA,
+ 0x9344,
+ 0x932E,
+ 0x9319,
+ 0x9322,
+ 0x931A,
+ 0x9323,
+ 0x933A,
+ 0x9335,
+ 0x933B,
+ 0x935C,
+ 0x9360,
+ 0x937C,
+ 0x936E,
+ 0x9356,
+ 0x93B0,
+ 0x93AC,
+ 0x93AD,
+ 0x9394,
+ 0x93B9,
+ 0x93D6,
+ 0x93D7,
+ 0x93E8,
+ 0x93E5,
+ 0x93D8,
+ 0x93C3,
+ 0x93DD,
+ 0x93D0,
+ 0x93C8,
+ 0x93E4,
+ 0x941A,
+ 0x9414,
+ 0x9413,
+ 0x9403,
+ 0x9407,
+ 0x9410,
+ 0x9436,
+ 0x942B,
+ 0x9435,
+ 0x9421,
+ 0x943A,
+ 0x9441,
+ 0x9452,
+ 0x9444,
+ 0x945B,
+ 0x9460,
+ 0x9462,
+ 0x945E,
+ 0x946A,
+ 0x9229,
+ 0x9470,
+ 0x9475,
+ 0x9477,
+ 0x947D,
+ 0x945A,
+ 0x947C,
+ 0x947E,
+ 0x9481,
+ 0x947F,
+ 0x9582,
+ 0x9587,
+ 0x958A,
+ 0x9594,
+ 0x9596,
+ 0x9598,
+ 0x9599,
+ 0x95A0,
+ 0x95A8,
+ 0x95A7,
+ 0x95AD,
+ 0x95BC,
+ 0x95BB,
+ 0x95B9,
+ 0x95BE,
+ 0x95CA,
+ 0x6FF6,
+ 0x95C3,
+ 0x95CD,
+ 0x95CC,
+ 0x95D5,
+ 0x95D4,
+ 0x95D6,
+ 0x95DC,
+ 0x95E1,
+ 0x95E5,
+ 0x95E2,
+ 0x9621,
+ 0x9628,
+ 0x962E,
+ 0x962F,
+ 0x9642,
+ 0x964C,
+ 0x964F,
+ 0x964B,
+ 0x9677,
+ 0x965C,
+ 0x965E,
+ 0x965D,
+ 0x965F,
+ 0x9666,
+ 0x9672,
+ 0x966C,
+ 0x968D,
+ 0x9698,
+ 0x9695,
+ 0x9697,
+ 0x96AA,
+ 0x96A7,
+ 0x96B1,
+ 0x96B2,
+ 0x96B0,
+ 0x96B4,
+ 0x96B6,
+ 0x96B8,
+ 0x96B9,
+ 0x96CE,
+ 0x96CB,
+ 0x96C9,
+ 0x96CD,
+ 0x894D,
+ 0x96DC,
+ 0x970D,
+ 0x96D5,
+ 0x96F9,
+ 0x9704,
+ 0x9706,
+ 0x9708,
+ 0x9713,
+ 0x970E,
+ 0x9711,
+ 0x970F,
+ 0x9716,
+ 0x9719,
+ 0x9724,
+ 0x972A,
+ 0x9730,
+ 0x9739,
+ 0x973D,
+ 0x973E,
+ 0x9744,
+ 0x9746,
+ 0x9748,
+ 0x9742,
+ 0x9749,
+ 0x975C,
+ 0x9760,
+ 0x9764,
+ 0x9766,
+ 0x9768,
+ 0x52D2,
+ 0x976B,
+ 0x9771,
+ 0x9779,
+ 0x9785,
+ 0x977C,
+ 0x9781,
+ 0x977A,
+ 0x9786,
+ 0x978B,
+ 0x978F,
+ 0x9790,
+ 0x979C,
+ 0x97A8,
+ 0x97A6,
+ 0x97A3,
+ 0x97B3,
+ 0x97B4,
+ 0x97C3,
+ 0x97C6,
+ 0x97C8,
+ 0x97CB,
+ 0x97DC,
+ 0x97ED,
+ 0x9F4F,
+ 0x97F2,
+ 0x7ADF,
+ 0x97F6,
+ 0x97F5,
+ 0x980F,
+ 0x980C,
+ 0x9838,
+ 0x9824,
+ 0x9821,
+ 0x9837,
+ 0x983D,
+ 0x9846,
+ 0x984F,
+ 0x984B,
+ 0x986B,
+ 0x986F,
+ 0x9870,
+ 0x9871,
+ 0x9874,
+ 0x9873,
+ 0x98AA,
+ 0x98AF,
+ 0x98B1,
+ 0x98B6,
+ 0x98C4,
+ 0x98C3,
+ 0x98C6,
+ 0x98E9,
+ 0x98EB,
+ 0x9903,
+ 0x9909,
+ 0x9912,
+ 0x9914,
+ 0x9918,
+ 0x9921,
+ 0x991D,
+ 0x991E,
+ 0x9924,
+ 0x9920,
+ 0x992C,
+ 0x992E,
+ 0x993D,
+ 0x993E,
+ 0x9942,
+ 0x9949,
+ 0x9945,
+ 0x9950,
+ 0x994B,
+ 0x9951,
+ 0x9952,
+ 0x994C,
+ 0x9955,
+ 0x9997,
+ 0x9998,
+ 0x99A5,
+ 0x99AD,
+ 0x99AE,
+ 0x99BC,
+ 0x99DF,
+ 0x99DB,
+ 0x99DD,
+ 0x99D8,
+ 0x99D1,
+ 0x99ED,
+ 0x99EE,
+ 0x99F1,
+ 0x99F2,
+ 0x99FB,
+ 0x99F8,
+ 0x9A01,
+ 0x9A0F,
+ 0x9A05,
+ 0x99E2,
+ 0x9A19,
+ 0x9A2B,
+ 0x9A37,
+ 0x9A45,
+ 0x9A42,
+ 0x9A40,
+ 0x9A43,
+ 0x9A3E,
+ 0x9A55,
+ 0x9A4D,
+ 0x9A5B,
+ 0x9A57,
+ 0x9A5F,
+ 0x9A62,
+ 0x9A65,
+ 0x9A64,
+ 0x9A69,
+ 0x9A6B,
+ 0x9A6A,
+ 0x9AAD,
+ 0x9AB0,
+ 0x9ABC,
+ 0x9AC0,
+ 0x9ACF,
+ 0x9AD1,
+ 0x9AD3,
+ 0x9AD4,
+ 0x9ADE,
+ 0x9ADF,
+ 0x9AE2,
+ 0x9AE3,
+ 0x9AE6,
+ 0x9AEF,
+ 0x9AEB,
+ 0x9AEE,
+ 0x9AF4,
+ 0x9AF1,
+ 0x9AF7,
+ 0x9AFB,
+ 0x9B06,
+ 0x9B18,
+ 0x9B1A,
+ 0x9B1F,
+ 0x9B22,
+ 0x9B23,
+ 0x9B25,
+ 0x9B27,
+ 0x9B28,
+ 0x9B29,
+ 0x9B2A,
+ 0x9B2E,
+ 0x9B2F,
+ 0x9B32,
+ 0x9B44,
+ 0x9B43,
+ 0x9B4F,
+ 0x9B4D,
+ 0x9B4E,
+ 0x9B51,
+ 0x9B58,
+ 0x9B74,
+ 0x9B93,
+ 0x9B83,
+ 0x9B91,
+ 0x9B96,
+ 0x9B97,
+ 0x9B9F,
+ 0x9BA0,
+ 0x9BA8,
+ 0x9BB4,
+ 0x9BC0,
+ 0x9BCA,
+ 0x9BB9,
+ 0x9BC6,
+ 0x9BCF,
+ 0x9BD1,
+ 0x9BD2,
+ 0x9BE3,
+ 0x9BE2,
+ 0x9BE4,
+ 0x9BD4,
+ 0x9BE1,
+ 0x9C3A,
+ 0x9BF2,
+ 0x9BF1,
+ 0x9BF0,
+ 0x9C15,
+ 0x9C14,
+ 0x9C09,
+ 0x9C13,
+ 0x9C0C,
+ 0x9C06,
+ 0x9C08,
+ 0x9C12,
+ 0x9C0A,
+ 0x9C04,
+ 0x9C2E,
+ 0x9C1B,
+ 0x9C25,
+ 0x9C24,
+ 0x9C21,
+ 0x9C30,
+ 0x9C47,
+ 0x9C32,
+ 0x9C46,
+ 0x9C3E,
+ 0x9C5A,
+ 0x9C60,
+ 0x9C67,
+ 0x9C76,
+ 0x9C78,
+ 0x9CE7,
+ 0x9CEC,
+ 0x9CF0,
+ 0x9D09,
+ 0x9D08,
+ 0x9CEB,
+ 0x9D03,
+ 0x9D06,
+ 0x9D2A,
+ 0x9D26,
+ 0x9DAF,
+ 0x9D23,
+ 0x9D1F,
+ 0x9D44,
+ 0x9D15,
+ 0x9D12,
+ 0x9D41,
+ 0x9D3F,
+ 0x9D3E,
+ 0x9D46,
+ 0x9D48,
+ 0x9D5D,
+ 0x9D5E,
+ 0x9D64,
+ 0x9D51,
+ 0x9D50,
+ 0x9D59,
+ 0x9D72,
+ 0x9D89,
+ 0x9D87,
+ 0x9DAB,
+ 0x9D6F,
+ 0x9D7A,
+ 0x9D9A,
+ 0x9DA4,
+ 0x9DA9,
+ 0x9DB2,
+ 0x9DC4,
+ 0x9DC1,
+ 0x9DBB,
+ 0x9DB8,
+ 0x9DBA,
+ 0x9DC6,
+ 0x9DCF,
+ 0x9DC2,
+ 0x9DD9,
+ 0x9DD3,
+ 0x9DF8,
+ 0x9DE6,
+ 0x9DED,
+ 0x9DEF,
+ 0x9DFD,
+ 0x9E1A,
+ 0x9E1B,
+ 0x9E1E,
+ 0x9E75,
+ 0x9E79,
+ 0x9E7D,
+ 0x9E81,
+ 0x9E88,
+ 0x9E8B,
+ 0x9E8C,
+ 0x9E92,
+ 0x9E95,
+ 0x9E91,
+ 0x9E9D,
+ 0x9EA5,
+ 0x9EA9,
+ 0x9EB8,
+ 0x9EAA,
+ 0x9EAD,
+ 0x9761,
+ 0x9ECC,
+ 0x9ECE,
+ 0x9ECF,
+ 0x9ED0,
+ 0x9ED4,
+ 0x9EDC,
+ 0x9EDE,
+ 0x9EDD,
+ 0x9EE0,
+ 0x9EE5,
+ 0x9EE8,
+ 0x9EEF,
+ 0x9EF4,
+ 0x9EF6,
+ 0x9EF7,
+ 0x9EF9,
+ 0x9EFB,
+ 0x9EFC,
+ 0x9EFD,
+ 0x9F07,
+ 0x9F08,
+ 0x76B7,
+ 0x9F15,
+ 0x9F21,
+ 0x9F2C,
+ 0x9F3E,
+ 0x9F4A,
+ 0x9F52,
+ 0x9F54,
+ 0x9F63,
+ 0x9F5F,
+ 0x9F60,
+ 0x9F61,
+ 0x9F66,
+ 0x9F67,
+ 0x9F6C,
+ 0x9F6A,
+ 0x9F77,
+ 0x9F72,
+ 0x9F76,
+ 0x9F95,
+ 0x9F9C,
+ 0x9FA0,
+ 0x582F,
+ 0x69C7,
+ 0x9059,
+ 0x7464,
+ 0x51DC,
+ 0x7199
+};
diff --git a/newlib/libc/ctype/local.h b/newlib/libc/ctype/local.h
new file mode 100644
index 0000000..b1eca42
--- /dev/null
+++ b/newlib/libc/ctype/local.h
@@ -0,0 +1,32 @@
+/* wctrans constants */
+
+#include <_ansi.h>
+
+/* valid values for wctrans_t */
+#define WCT_TOLOWER 1
+#define WCT_TOUPPER 2
+
+/* valid values for wctype_t */
+#define WC_ALNUM 1
+#define WC_ALPHA 2
+#define WC_BLANK 3
+#define WC_CNTRL 4
+#define WC_DIGIT 5
+#define WC_GRAPH 6
+#define WC_LOWER 7
+#define WC_PRINT 8
+#define WC_PUNCT 9
+#define WC_SPACE 10
+#define WC_UPPER 11
+#define WC_XDIGIT 12
+
+extern char __lc_ctype[12];
+
+/* Japanese encoding types supported */
+#define JP_JIS 1
+#define JP_SJIS 2
+#define JP_EUCJP 3
+
+/* internal function to translate JP to Unicode */
+wint_t _EXFUN (__jp2uc, (wint_t, int));
+
diff --git a/newlib/libc/ctype/towctrans.c b/newlib/libc/ctype/towctrans.c
new file mode 100644
index 0000000..cf21626
--- /dev/null
+++ b/newlib/libc/ctype/towctrans.c
@@ -0,0 +1,97 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<towctrans>>---extensible wide-character case mapping
+
+INDEX
+ towctrans
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ wint_t towctrans(wint_t <[c]>, wctrans_t <[w]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ wint_t towctrans(<[c]>, <[w]>)
+ wint_t <[c]>;
+ wctrans_t <[w]>;
+
+
+DESCRIPTION
+<<towctrans>> is a function which converts wide-characters based on
+a specified translation type <[w]>. If the translation type is
+invalid or cannot be applied to the current character, no change
+to the character is made.
+
+RETURNS
+<<towctrans>> returns the translated equivalent of <[c]> when it is a
+valid for the given translation, otherwise, it returns the input character.
+When the translation type is invalid, <<errno>> is set <<EINVAL>>.
+
+PORTABILITY
+<<towctrans>> is C99.
+
+No supporting OS subroutines are required.
+*/
+
+#include <_ansi.h>
+#include <string.h>
+#include <reent.h>
+#include <wctype.h>
+#include <errno.h>
+#include "local.h"
+
+wint_t
+_DEFUN (_towctrans_r, (r, c, w),
+ struct _reent *r _AND
+ wint_t c _AND
+ wctrans_t w)
+{
+ if (w == WCT_TOLOWER)
+ return towlower (c);
+ else if (w == WCT_TOUPPER)
+ return towupper (c);
+ else
+ {
+ r->_errno = EINVAL;
+ return c;
+ }
+}
+
+#ifndef _REENT_ONLY
+wint_t
+_DEFUN (towctrans, (c, w),
+ wint_t c _AND
+ wctrans_t w)
+{
+ return _towctrans_r (_REENT, c, w);
+}
+#endif /* !_REENT_ONLY */
diff --git a/newlib/libc/ctype/towlower.c b/newlib/libc/ctype/towlower.c
new file mode 100644
index 0000000..5520e37
--- /dev/null
+++ b/newlib/libc/ctype/towlower.c
@@ -0,0 +1,478 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<towlower>>---translate wide-characters to lower case
+
+INDEX
+ towlower
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ wint_t towlower(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ wint_t towlower(<[c]>)
+ wint_t <[c]>;
+
+
+DESCRIPTION
+<<towlower>> is a function which converts upper-case wide-characters to lower
+case, leaving all other characters unchanged.
+
+RETURNS
+<<towlower>> returns the lower-case equivalent of <[c]> when it is a
+upper-case wide-character, otherwise, it returns the input character.
+
+PORTABILITY
+<<towlower>> is C99.
+
+No supporting OS subroutines are required.
+*/
+
+#include <_ansi.h>
+#include <string.h>
+#include <reent.h>
+#include <ctype.h>
+#include <wctype.h>
+#include "local.h"
+
+wint_t
+_DEFUN(towlower,(c), wint_t c)
+{
+ int unicode = 0;
+
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ if (c < 0x100)
+ {
+ if ((c >= 0x0041 && c <= 0x005a) ||
+ (c >= 0x00c0 && c <= 0x00de))
+ return (c + 0x20);
+
+ if (c == 0x00b5)
+ return 0x03bc;
+
+ return c;
+ }
+ else if (c < 0x300)
+ {
+ if ((c >= 0x0100 && c <= 0x012e) ||
+ (c >= 0x0132 && c <= 0x0136) ||
+ (c >= 0x014a && c <= 0x0176) ||
+ (c >= 0x01de && c <= 0x01ee) ||
+ (c >= 0x01f8 && c <= 0x021e) ||
+ (c >= 0x0222 && c <= 0x0232))
+ {
+ if (!(c & 0x01))
+ return (c + 1);
+ return c;
+ }
+
+ if ((c >= 0x0139 && c <= 0x0147) ||
+ (c >= 0x01cd && c <= 0x91db))
+ {
+ if (c & 0x01)
+ return (c + 1);
+ return c;
+ }
+
+ if (c >= 0x178 && c <= 0x01f7)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x0178:
+ k = 0x00ff;
+ break;
+ case 0x0179:
+ case 0x017b:
+ case 0x017d:
+ case 0x0182:
+ case 0x0184:
+ case 0x0187:
+ case 0x018b:
+ case 0x0191:
+ case 0x0198:
+ case 0x01a0:
+ case 0x01a2:
+ case 0x01a4:
+ case 0x01a7:
+ case 0x01ac:
+ case 0x01af:
+ case 0x01b3:
+ case 0x01b5:
+ case 0x01b8:
+ case 0x01bc:
+ case 0x01c5:
+ case 0x01c8:
+ case 0x01cb:
+ case 0x01cd:
+ case 0x01cf:
+ case 0x01d1:
+ case 0x01d3:
+ case 0x01d5:
+ case 0x01d7:
+ case 0x01d9:
+ case 0x01db:
+ case 0x01f2:
+ case 0x01f4:
+ k = c + 1;
+ break;
+ case 0x017f:
+ k = 0x0073;
+ break;
+ case 0x0181:
+ k = 0x0253;
+ break;
+ case 0x0186:
+ k = 0x0254;
+ break;
+ case 0x0189:
+ k = 0x0256;
+ break;
+ case 0x018a:
+ k = 0x0257;
+ break;
+ case 0x018e:
+ k = 0x01dd;
+ break;
+ case 0x018f:
+ k = 0x0259;
+ break;
+ case 0x0190:
+ k = 0x025b;
+ break;
+ case 0x0193:
+ k = 0x0260;
+ break;
+ case 0x0194:
+ k = 0x0263;
+ break;
+ case 0x0196:
+ k = 0x0269;
+ break;
+ case 0x0197:
+ k = 0x0268;
+ break;
+ case 0x019c:
+ k = 0x026f;
+ break;
+ case 0x019d:
+ k = 0x0272;
+ break;
+ case 0x019f:
+ k = 0x0275;
+ break;
+ case 0x01a6:
+ k = 0x0280;
+ break;
+ case 0x01a9:
+ k = 0x0283;
+ break;
+ case 0x01ae:
+ k = 0x0288;
+ break;
+ case 0x01b1:
+ k = 0x028a;
+ break;
+ case 0x01b2:
+ k = 0x028b;
+ break;
+ case 0x01b7:
+ k = 0x0292;
+ break;
+ case 0x01c4:
+ case 0x01c7:
+ case 0x01ca:
+ case 0x01f1:
+ k = c + 2;
+ break;
+ case 0x01f6:
+ k = 0x0195;
+ break;
+ case 0x01f7:
+ k = 0x01bf;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+
+ if (c == 0x0220)
+ return 0x019e;
+ }
+ else if (c < 0x0400)
+ {
+ if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)
+ return (c + 0x20);
+ if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))
+ return (c + 1);
+ if (c >= 0x0386 && c <= 0x03f5)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x0386:
+ k = 0x03ac;
+ break;
+ case 0x0388:
+ k = 0x03ad;
+ break;
+ case 0x0389:
+ k = 0x03ae;
+ break;
+ case 0x038a:
+ k = 0x03af;
+ break;
+ case 0x038c:
+ k = 0x03cc;
+ break;
+ case 0x038e:
+ k = 0x03cd;
+ break;
+ case 0x038f:
+ k = 0x038f;
+ break;
+ case 0x03c2:
+ k = 0x03c3;
+ break;
+ case 0x03d0:
+ k = 0x03b2;
+ break;
+ case 0x03d1:
+ k = 0x03b8;
+ break;
+ case 0x03d5:
+ k = 0x03c6;
+ break;
+ case 0x03d6:
+ k = 0x03c0;
+ break;
+ case 0x03f0:
+ k = 0x03ba;
+ break;
+ case 0x03f1:
+ k = 0x03c1;
+ break;
+ case 0x03f2:
+ k = 0x03c3;
+ break;
+ case 0x03f4:
+ k = 0x03b8;
+ break;
+ case 0x03f5:
+ k = 0x03b5;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+
+ if (c == 0x0345)
+ return 0x03b9;
+ }
+ else if (c < 0x500)
+ {
+ if (c >= 0x0400 && c <= 0x040f)
+ return (c + 0x50);
+
+ if (c >= 0x0410 && c <= 0x042f)
+ return (c + 0x20);
+
+ if ((c >= 0x0460 && c <= 0x0480) ||
+ (c >= 0x048a && c <= 0x04be) ||
+ (c >= 0x04d0 && c <= 0x04f4) ||
+ (c == 0x04f8))
+ {
+ if (!(c & 0x01))
+ return (c + 1);
+ return c;
+ }
+
+ if (c >= 0x04c1 && c <= 0x04cd)
+ {
+ if (c & 0x01)
+ return (c + 1);
+ return c;
+ }
+ }
+ else if (c < 0x1f00)
+ {
+ if ((c >= 0x0500 && c <= 0x050e) ||
+ (c >= 0x1e00 && c <= 0x1e94) ||
+ (c >= 0x1ea0 && c <= 0x1ef8))
+ {
+ if (!(c & 0x01))
+ return (c + 1);
+ return c;
+ }
+
+ if (c >= 0x0531 && c <= 0x0556)
+ return (c + 0x30);
+
+ if (c == 0x1e9b)
+ return 0x1e61;
+ }
+ else if (c < 0x2000)
+ {
+ if ((c >= 0x1f08 && c <= 0x1f0f) ||
+ (c >= 0x1f18 && c <= 0x1f1d) ||
+ (c >= 0x1f28 && c <= 0x1f2f) ||
+ (c >= 0x1f38 && c <= 0x1f3f) ||
+ (c >= 0x1f48 && c <= 0x1f4d) ||
+ (c >= 0x1f68 && c <= 0x1f6f) ||
+ (c >= 0x1f88 && c <= 0x1f8f) ||
+ (c >= 0x1f98 && c <= 0x1f9f) ||
+ (c >= 0x1fa8 && c <= 0x1faf))
+ return (c - 0x08);
+
+ if (c >= 0x1f59 && c <= 0x1f5f)
+ {
+ if (c & 0x01)
+ return (c - 0x08);
+ return c;
+ }
+
+ if (c >= 0x1fb8 && c <= 0x1ffc)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x1fb8:
+ case 0x1fb9:
+ case 0x1fd8:
+ case 0x1fd9:
+ case 0x1fe8:
+ case 0x1fe9:
+ k = c - 0x08;
+ break;
+ case 0x1fba:
+ case 0x1fbb:
+ k = c - 0x4a;
+ break;
+ case 0x1fbc:
+ k = 0x1fb3;
+ break;
+ case 0x1fbe:
+ k = 0x03b9;
+ break;
+ case 0x1fc8:
+ case 0x1fc9:
+ case 0x1fca:
+ case 0x1fcb:
+ k = c - 0x56;
+ break;
+ case 0x1fcc:
+ k = 0x1fc3;
+ break;
+ case 0x1fda:
+ case 0x1fdb:
+ k = c - 0x64;
+ break;
+ case 0x1fea:
+ case 0x1feb:
+ k = c - 0x70;
+ break;
+ case 0x1fec:
+ k = 0x1fe5;
+ break;
+ case 0x1ffa:
+ case 0x1ffb:
+ k = c - 0x7e;
+ break;
+ case 0x1ffc:
+ k = 0x1ff3;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+ }
+ else
+ {
+ if (c >= 0x2160 && c <= 0x216f)
+ return (c + 0x10);
+
+ if (c >= 0x24b6 && c <= 0x24cf)
+ return (c + 0x1a);
+
+ if (c >= 0xff21 && c <= 0xff3a)
+ return (c + 0x20);
+
+ if (c >= 0x10400 && c <= 0x10425)
+ return (c + 0x28);
+
+ if (c == 0x2126)
+ return 0x03c9;
+ if (c == 0x212a)
+ return 0x006b;
+ if (c == 0x212b)
+ return 0x00e5;
+ }
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < 0x00ff ? (wint_t)(tolower ((int)c)) : c);
+}
+
diff --git a/newlib/libc/ctype/towupper.c b/newlib/libc/ctype/towupper.c
new file mode 100644
index 0000000..8fc2848
--- /dev/null
+++ b/newlib/libc/ctype/towupper.c
@@ -0,0 +1,505 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<towupper>>---translate wide-characters to upper case
+
+INDEX
+ towupper
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ wint_t towupper(wint_t <[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ wint_t towupper(<[c]>)
+ wint_t <[c]>;
+
+
+DESCRIPTION
+<<towupper>> is a function which converts lower-case wide-characters to upper
+case, leaving all other characters unchanged.
+
+RETURNS
+<<towupper>> returns the upper-case equivalent of <[c]> when it is a
+lower-case wide-character, otherwise, it returns the input character.
+
+PORTABILITY
+<<towupper>> is C99.
+
+No supporting OS subroutines are required.
+*/
+
+#include <_ansi.h>
+#include <string.h>
+#include <reent.h>
+#include <ctype.h>
+#include <wctype.h>
+#include "local.h"
+
+wint_t
+_DEFUN(towupper,(c), wint_t c)
+{
+ int unicode = 0;
+
+ if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
+ {
+ unicode = 0;
+ /* fall-through */
+ }
+#ifdef MB_CAPABLE
+ else if (!strcmp (__lc_ctype, "C-JIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
+ {
+ c = __jp2uc (c, JP_JIS);
+ unicode = 1;
+ }
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
+ {
+ unicode = 1;
+ }
+
+ if (unicode)
+ {
+ if (c < 0x100)
+ {
+ if (c == 0x00b5)
+ return 0x039c;
+
+ if ((c >= 0x00e0 && c <= 0x00fe) ||
+ (c >= 0x0061 && c <= 0x007a))
+ return (c - 0x20);
+
+ if (c == 0xff)
+ return 0x0178;
+
+ return c;
+ }
+ else if (c < 0x300)
+ {
+ if ((c >= 0x0101 && c <= 0x012f) ||
+ (c >= 0x0133 && c <= 0x0137) ||
+ (c >= 0x014b && c <= 0x0177) ||
+ (c >= 0x01df && c <= 0x01ef) ||
+ (c >= 0x01f9 && c <= 0x021f) ||
+ (c >= 0x0223 && c <= 0x0233))
+ {
+ if (c & 0x01)
+ return (c - 1);
+ return c;
+ }
+
+ if ((c >= 0x013a && c <= 0x0148) ||
+ (c >= 0x01ce && c <= 0x1dc))
+ {
+ if (!(c & 0x01))
+ return (c - 1);
+ return c;
+ }
+
+ if (c == 0x0131)
+ return 0x0049;
+
+ if (c == 0x017a || c == 0x017c || c == 0x017e)
+ return (c - 1);
+
+ if (c >= 0x017f && c <= 0x0292)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x017f:
+ k = 0x0053;
+ break;
+ case 0x0183:
+ k = 0x0182;
+ break;
+ case 0x0185:
+ k = 0x0184;
+ break;
+ case 0x0188:
+ k = 0x0187;
+ break;
+ case 0x018c:
+ k = 0x018b;
+ break;
+ case 0x0192:
+ k = 0x0191;
+ break;
+ case 0x0195:
+ k = 0x01f6;
+ break;
+ case 0x0199:
+ k = 0x0198;
+ break;
+ case 0x019e:
+ k = 0x0220;
+ break;
+ case 0x01a1:
+ case 0x01a3:
+ case 0x01a5:
+ case 0x01a8:
+ case 0x01ad:
+ case 0x01b0:
+ case 0x01b4:
+ case 0x01b6:
+ case 0x01b9:
+ case 0x01bd:
+ case 0x01c5:
+ case 0x01c8:
+ case 0x01cb:
+ case 0x01f2:
+ case 0x01f5:
+ k = c - 1;
+ break;
+ case 0x01bf:
+ k = 0x01f7;
+ break;
+ case 0x01c6:
+ case 0x01c9:
+ case 0x01cc:
+ k = c - 2;
+ break;
+ case 0x01dd:
+ k = 0x018e;
+ break;
+ case 0x01f3:
+ k = 0x01f1;
+ break;
+ case 0x0253:
+ k = 0x0181;
+ break;
+ case 0x0254:
+ k = 0x0186;
+ break;
+ case 0x0256:
+ k = 0x0189;
+ break;
+ case 0x0257:
+ k = 0x018a;
+ break;
+ case 0x0259:
+ k = 0x018f;
+ break;
+ case 0x025b:
+ k = 0x0190;
+ break;
+ case 0x0260:
+ k = 0x0193;
+ break;
+ case 0x0263:
+ k = 0x0194;
+ break;
+ case 0x0268:
+ k = 0x0197;
+ break;
+ case 0x0269:
+ k = 0x0196;
+ break;
+ case 0x026f:
+ k = 0x019c;
+ break;
+ case 0x0272:
+ k = 0x019d;
+ break;
+ case 0x0275:
+ k = 0x019f;
+ break;
+ case 0x0280:
+ k = 0x01a6;
+ break;
+ case 0x0283:
+ k = 0x01a9;
+ break;
+ case 0x0288:
+ k = 0x01ae;
+ break;
+ case 0x028a:
+ k = 0x01b1;
+ break;
+ case 0x028b:
+ k = 0x01b2;
+ break;
+ case 0x0292:
+ k = 0x01b7;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+ }
+ else if (c < 0x0400)
+ {
+ if (c == 0x03ac)
+ return 0x0386;
+
+ if ((c & 0xfff0) == 0x03a0 && c >= 0x03ad)
+ return (c - 0x15);
+
+ if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
+ return (c - 0x20);
+
+ if (c == 0x03c2)
+ return 0x03a3;
+
+ if (c >= 0x03cc && c <= 0x03f5)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x03cc:
+ k = 0x038c;
+ break;
+ case 0x03cd:
+ case 0x03ce:
+ k = c - 0x3f;
+ break;
+ case 0x03d0:
+ k = 0x0392;
+ break;
+ case 0x03d1:
+ k = 0x0398;
+ break;
+ case 0x03d5:
+ k = 0x03a6;
+ break;
+ case 0x03d6:
+ k = 0x03a0;
+ break;
+ case 0x03d9:
+ case 0x03db:
+ case 0x03dd:
+ case 0x03df:
+ case 0x03e1:
+ case 0x03e3:
+ case 0x03e5:
+ case 0x03e7:
+ case 0x03e9:
+ case 0x03eb:
+ case 0x03ed:
+ case 0x03ef:
+ k = c - 1;
+ break;
+ case 0x03f0:
+ k = 0x039a;
+ break;
+ case 0x03f1:
+ k = 0x03a1;
+ break;
+ case 0x03f2:
+ k = 0x03a3;
+ break;
+ case 0x03f5:
+ k = 0x0395;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+ }
+ else if (c < 0x500)
+ {
+ if (c >= 0x0450 && c <= 0x045f)
+ return (c - 0x50);
+
+ if (c >= 0x0430 && c <= 0x044f)
+ return (c - 0x20);
+
+ if ((c >= 0x0461 && c <= 0x0481) ||
+ (c >= 0x048b && c <= 0x04bf) ||
+ (c >= 0x04d1 && c <= 0x04f5))
+ {
+ if (c & 0x01)
+ return (c - 1);
+ return c;
+ }
+
+ if (c >= 0x04c2 && c <= 0x04ce)
+ {
+ if (!(c & 0x01))
+ return (c - 1);
+ return c;
+ }
+
+ if (c == 0x04f9)
+ return 0x04f8;
+ }
+ else if (c < 0x1f00)
+ {
+ if ((c >= 0x0501 && c <= 0x050f) ||
+ (c >= 0x1e01 && c <= 0x1e95) ||
+ (c >= 0x1ea1 && c <= 0x1ef9))
+ {
+ if (c & 0x01)
+ return (c - 1);
+ return c;
+ }
+
+ if (c >= 0x0561 && c <= 0x0586)
+ return (c - 0x30);
+
+ if (c == 0x1e9b)
+ return 0x1e60;
+ }
+ else if (c < 0x2000)
+ {
+
+ if ((c >= 0x1f00 && c <= 0x1f07) ||
+ (c >= 0x1f10 && c <= 0x1f15) ||
+ (c >= 0x1f20 && c <= 0x1f27) ||
+ (c >= 0x1f30 && c <= 0x1f37) ||
+ (c >= 0x1f40 && c <= 0x1f45) ||
+ (c >= 0x1f60 && c <= 0x1f67) ||
+ (c >= 0x1f80 && c <= 0x1f87) ||
+ (c >= 0x1f90 && c <= 0x1f97) ||
+ (c >= 0x1fa0 && c <= 0x1fa7))
+ return (c + 0x08);
+
+ if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
+ return (c + 0x08);
+
+ if (c >= 0x1f70 && c <= 0x1ff3)
+ {
+ wint_t k;
+ switch (c)
+ {
+ case 0x1fb0:
+ k = 0x1fb8;
+ break;
+ case 0x1fb1:
+ k = 0x1fb9;
+ break;
+ case 0x1f70:
+ k = 0x1fba;
+ break;
+ case 0x1f71:
+ k = 0x1fbb;
+ break;
+ case 0x1fb3:
+ k = 0x1fbc;
+ break;
+ case 0x1fbe:
+ k = 0x0399;
+ break;
+ case 0x1f72:
+ k = 0x1fc8;
+ break;
+ case 0x1f73:
+ k = 0x1fc9;
+ break;
+ case 0x1f74:
+ k = 0x1fca;
+ break;
+ case 0x1f75:
+ k = 0x1fcb;
+ break;
+ case 0x1fd0:
+ k = 0x1fd8;
+ break;
+ case 0x1fd1:
+ k = 0x1fd9;
+ break;
+ case 0x1f76:
+ k = 0x1fda;
+ break;
+ case 0x1f77:
+ k = 0x1fdb;
+ break;
+ case 0x1fe0:
+ k = 0x1fe8;
+ break;
+ case 0x1fe1:
+ k = 0x1fe9;
+ break;
+ case 0x1f7a:
+ k = 0x1fea;
+ break;
+ case 0x1f7b:
+ k = 0x1feb;
+ break;
+ case 0x1fe5:
+ k = 0x1fec;
+ break;
+ case 0x1f78:
+ k = 0x1ff8;
+ break;
+ case 0x1f79:
+ k = 0x1ff9;
+ break;
+ case 0x1f7c:
+ k = 0x1ffa;
+ break;
+ case 0x1f7d:
+ k = 0x1ffb;
+ break;
+ case 0x1ff3:
+ k = 0x1ffc;
+ break;
+ default:
+ k = 0;
+ }
+ if (k != 0)
+ return k;
+ }
+ }
+ else
+ {
+ if (c >= 0x2170 && c <= 0x217f)
+ return (c - 0x10);
+
+ if (c >= 0x24d0 && c <= 0x24e9)
+ return (c - 0x1a);
+
+ if (c >= 0xff41 && c <= 0xff5a)
+ return (c - 0x20);
+
+ if (c >= 0x10428 && c <= 0x1044d)
+ return (c - 0x28);
+ }
+ }
+#endif /* MB_CAPABLE */
+
+ return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);
+}
+
diff --git a/newlib/libc/ctype/utf8alpha.h b/newlib/libc/ctype/utf8alpha.h
new file mode 100644
index 0000000..c7ee160
--- /dev/null
+++ b/newlib/libc/ctype/utf8alpha.h
@@ -0,0 +1,235 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* Generated using unicode.txt 3.2 */
+
+static const unsigned char u0[] = {
+ 0x41, 0x0, 0x5a, 0x61, 0x0, 0x7a, 0xaa, 0xb5,
+ 0xba, 0xc0, 0x0, 0xd6, 0xd8, 0x0, 0xf6, 0xf8,
+ 0x0, 0xff };
+/* u1 all alphabetic */
+static const unsigned char u2[] = {
+ 0x00, 0x0, 0x20, 0x22, 0x0, 0x33, 0x50, 0x0, 0xad,
+ 0xb0, 0x0, 0xb8, 0xbb, 0x0, 0xc1, 0xd0, 0x0,
+ 0xd1, 0xe0, 0x0, 0xe4, 0xee };
+static const unsigned char u3[] = {
+ 0x45, 0x7a, 0x86,
+ 0x88, 0x0, 0x8a, 0x8c, 0x8e, 0x0, 0xa1, 0xa3,
+ 0x0, 0xce, 0xd0, 0x0, 0xf5 };
+static const unsigned char u4[] = {
+ 0x00, 0x0, 0x81,
+ 0x8a, 0x0, 0xce, 0xd0, 0x0, 0xf5, 0xf8, 0x0,
+ 0xf9 };
+static const unsigned char u5[] = {
+ 0x00, 0x0, 0x0f, 0x31, 0x0, 0x56, 0x59,
+ 0x61, 0x0, 0x87, 0xd0, 0x0, 0xea, 0xf0, 0x0,
+ 0xf2 };
+static const unsigned char u6[] = {
+ 0x21, 0x0, 0x3a,
+ 0x40, 0x0, 0x4a, 0x60,
+ 0x0, 0x69, 0x6e, 0x0, 0x6f, 0x71, 0x0, 0xd3,
+ 0xd5, 0xe5, 0x0, 0xe6, 0xf0, 0x0, 0xfc };
+static const unsigned char u7[] = {
+ 0x10,
+ 0x12, 0x0, 0x2c, 0x80, 0x0, 0xa5, 0xb1 };
+static const unsigned char u9[] = {
+ 0x05,
+ 0x0, 0x39, 0x3d, 0x50, 0x58, 0x0, 0x61, 0x66,
+ 0x0, 0x6f, 0x85, 0x0, 0x8c, 0x8f, 0x0, 0x90,
+ 0x93, 0x0, 0xa8, 0xaa, 0x0, 0xb0, 0xb2, 0xb6,
+ 0x0, 0xb9, 0xdc, 0x0, 0xdd, 0xdf, 0x0, 0xe1,
+ 0xe6, 0x0, 0xf1 };
+static const unsigned char ua[] = {
+ 0x05, 0x0, 0x0a, 0x0f, 0x0,
+ 0x10, 0x13, 0x0, 0x28, 0x2a, 0x0, 0x30, 0x32,
+ 0x0, 0x33, 0x35, 0x0, 0x36, 0x38, 0x0, 0x39,
+ 0x59, 0x0, 0x5c, 0x5e, 0x66, 0x0, 0x6f, 0x72,
+ 0x0, 0x74, 0x85, 0x0, 0x8b, 0x8d, 0x8f, 0x0,
+ 0x91, 0x93, 0x0, 0xa8, 0xaa, 0x0, 0xb0, 0xb2,
+ 0x0, 0xb3, 0xb5, 0x0, 0xb9, 0xbd, 0xd0, 0xe0,
+ 0xe6, 0x0, 0xef };
+static const unsigned char ub[] = {
+ 0x05, 0x0, 0x0c, 0x0f, 0x0,
+ 0x10, 0x13, 0x0, 0x28, 0x2a, 0x0, 0x30, 0x32,
+ 0x0, 0x33, 0x36, 0x0, 0x39, 0x3d, 0x5c, 0x0,
+ 0x5d, 0x5f, 0x0, 0x61, 0x66, 0x0, 0x6f, 0x83,
+ 0x85, 0x0, 0x8a, 0x8e, 0x0, 0x90, 0x92, 0x0,
+ 0x95, 0x99, 0x0, 0x9a, 0x9c, 0x9e, 0x0, 0x9f,
+ 0xa3, 0x0, 0xa4, 0xa8, 0x0, 0xaa, 0xae, 0x0,
+ 0xb5, 0xb7, 0x0, 0xb9, 0xe7, 0x0, 0xef };
+static const unsigned char uc[] = {
+ 0x05,
+ 0x0, 0x0c, 0x0e, 0x0, 0x10, 0x12, 0x0, 0x28,
+ 0x2a, 0x0, 0x33, 0x35, 0x0, 0x39, 0x60, 0x0,
+ 0x61, 0x66, 0x0, 0x6f, 0x85, 0x0, 0x8c, 0x8e,
+ 0x0, 0x90, 0x92, 0x0, 0xa8, 0xaa, 0x0, 0xb3,
+ 0xb5, 0x0, 0xb9, 0xde, 0xe0, 0x0, 0xe1, 0xe6,
+ 0x0, 0xef };
+static const unsigned char ud[] = {
+ 0x05, 0x0, 0x0c, 0x0e, 0x0, 0x10,
+ 0x12, 0x0, 0x28, 0x2a, 0x0, 0x39, 0x60, 0x0,
+ 0x61, 0x66, 0x0, 0x6f, 0x85, 0x0, 0x96, 0x9a,
+ 0x0, 0xb1, 0xb3, 0x0, 0xbb, 0xbd, 0xc0, 0x0,
+ 0xc6 };
+static const unsigned char ue[] = {
+ 0x01, 0x0, 0x2e, 0x30, 0x0, 0x3a, 0x40,
+ 0x0, 0x45, 0x47, 0x0, 0x4e, 0x50, 0x0, 0x59,
+ 0x81, 0x0, 0x82, 0x84, 0x87, 0x0, 0x88, 0x8a,
+ 0x8d, 0x94, 0x0, 0x97, 0x99, 0x0, 0x9f, 0xa1,
+ 0x0, 0xa3, 0xa5, 0xa7, 0xaa, 0x0, 0xab, 0xad,
+ 0x0, 0xb0, 0xb2, 0x0, 0xb3, 0xbd, 0xc0, 0x0,
+ 0xc4, 0xc6, 0xd0, 0x0, 0xd9, 0xdc, 0x0, 0xdd };
+static const unsigned char uf[] = {
+ 0x00, 0x20, 0x0, 0x29, 0x40, 0x0, 0x47, 0x49,
+ 0x0, 0x6a, 0x88, 0x0, 0x8b };
+static const unsigned char u10[] = {
+ 0x00, 0x0, 0x21,
+ 0x23, 0x0, 0x27, 0x29, 0x0, 0x2a, 0x40, 0x0,
+ 0x49, 0x50, 0x0, 0x55, 0xa0, 0x0, 0xc5, 0xd0,
+ 0x0, 0xf8 };
+static const unsigned char u11[] = {
+ 0x00, 0x0, 0x59, 0x5f, 0x0, 0xa2,
+ 0xa8, 0x0, 0xf9 };
+static const unsigned char u12[] = {
+ 0x00, 0x0, 0x06, 0x08, 0x0,
+ 0x46, 0x48, 0x4a, 0x0, 0x4d, 0x50, 0x0, 0x56,
+ 0x58, 0x5a, 0x0, 0x5d, 0x60, 0x0, 0x86, 0x88,
+ 0x8a, 0x0, 0x8d, 0x90, 0x0, 0xae, 0xb0, 0xb2,
+ 0x0, 0xb5, 0xb8, 0x0, 0xbe, 0xc0, 0xc2, 0x0,
+ 0xc5, 0xc8, 0x0, 0xce, 0xd0, 0x0, 0xd6, 0xd8,
+ 0x0, 0xee, 0xf0, 0x0, 0xff };
+static const unsigned char u13[] = {
+ 0x00, 0x0, 0x0e, 0x10, 0x12, 0x0,
+ 0x15, 0x18, 0x0, 0x1e, 0x20, 0x0, 0x46, 0x48,
+ 0x0, 0x5a, 0x69, 0x0, 0x71, 0xa0, 0x0, 0xf4 };
+static const unsigned char u14[] = {
+ 0x01, 0x0, 0xff };
+/* u15 all alphabetic */
+static const unsigned char u16[] = {
+ 0x00, 0x0, 0x6c, 0x6f, 0x0, 0x76,
+ 0x81, 0x0, 0x9a, 0xa0, 0x0, 0xea, 0xee, 0x0, 0xf0 };
+static const unsigned char u17[] = {
+ 0x00,
+ 0x0, 0x0c, 0x0e, 0x0, 0x11, 0x20, 0x0, 0x31,
+ 0x40, 0x0, 0x51, 0x60, 0x0, 0x6c, 0x6e, 0x0,
+ 0x70, 0x80, 0x0, 0xb3, 0xd7, 0xdc, 0xe0, 0x0,
+ 0xe9 };
+static const unsigned char u18[] = {
+ 0x10, 0x0, 0x19, 0x20, 0x0, 0x77, 0x80,
+ 0x0, 0xa8 };
+static const unsigned char u1e[] = {
+ 0x00, 0x0, 0x9b, 0xa0, 0x0, 0xf9 };
+static const unsigned char u1f[] = {
+ 0x00, 0x0, 0x15, 0x18, 0x0, 0x1d,
+ 0x20, 0x0, 0x45, 0x48, 0x0, 0x4d, 0x50, 0x0, 0x57, 0x59,
+ 0x5b, 0x5d, 0x5f, 0x0, 0x7d, 0x80, 0x0, 0xb4,
+ 0xb6, 0x0, 0xbc, 0xbe, 0xc2, 0x0, 0xc4, 0xc6,
+ 0x0, 0xcc, 0xd0, 0x0, 0xd3, 0xd6, 0x0, 0xdb,
+ 0xe0, 0x0, 0xec, 0xf2, 0x0, 0xf4, 0xf6, 0x0,
+ 0xfc };
+static const unsigned char u20[] = {
+ 0x71, 0x7f };
+static const unsigned char u21[] = {
+ 0x02, 0x07, 0x0a, 0x0, 0x13,
+ 0x15, 0x19, 0x0, 0x1d, 0x24, 0x26, 0x28, 0x0,
+ 0x2d, 0x2f, 0x0, 0x31, 0x33, 0x0, 0x39, 0x3d,
+ 0x0, 0x3f, 0x45, 0x0, 0x49, 0x60, 0x0, 0x83 };
+static const unsigned char u24[] = {
+ 0x9c, 0x0, 0xe9 };
+static const unsigned char u30[] = {
+ 0x05, 0x0, 0x07, 0x21, 0x0,
+ 0x29, 0x31, 0x0, 0x35, 0x38, 0x0, 0x3c, 0x41,
+ 0x0, 0x96, 0x9d, 0x0, 0x9f, 0xa1, 0x0, 0xfa,
+ 0xfc, 0x0, 0xff };
+static const unsigned char u31[] = {
+ 0x05, 0x0, 0x2c, 0x31, 0x0,
+ 0x8e, 0xa0, 0x0, 0xb7, 0xf0, 0x0, 0xff };
+/* u34 to u4c all alphabetic */
+static const unsigned char u4d[] = {
+ 0x00, 0x0, 0xb5 };
+/* u4e to u9e all alphabetic */
+static const unsigned char u9f[] = {
+ 0x00, 0x0, 0xa5 };
+/* ua0 to ua3 all alphabetic */
+static const unsigned char ua4[] = {
+ 0x00, 0x0, 0x8c };
+/* uac to ud6 all alphabetic */
+static const unsigned char ud7[] = {
+ 0xa3 };
+/* uf9 all alphabetic */
+static const unsigned char ufa[] = {
+ 0x00, 0x0, 0x2d, 0x30, 0x0, 0x6a };
+static const unsigned char ufb[] = {
+ 0x00, 0x0, 0x06, 0x13, 0x0, 0x17, 0x1d,
+ 0x1f, 0x0, 0x28, 0x2a, 0x0, 0x36, 0x38, 0x0,
+ 0x3c, 0x3e, 0x40, 0x0, 0x41, 0x43, 0x0, 0x44,
+ 0x46, 0x0, 0xb1, 0xd3, 0x0, 0xff };
+/* ufc all alphabetic */
+static const unsigned char ufd[] = {
+ 0x00, 0x0, 0x3d, 0x50, 0x0,
+ 0x8f, 0x92, 0x0, 0xc7, 0xf0, 0x0, 0xfb };
+static const unsigned char ufe[] = {
+ 0x70,
+ 0x0, 0x74, 0x76, 0x0, 0xfc };
+static const unsigned char uff[] = {
+ 0x10, 0x0, 0x19,
+ 0x21, 0x0, 0x3a, 0x41, 0x0, 0x5a, 0x66, 0x0,
+ 0xbe, 0xc2, 0x0, 0xc7, 0xca, 0x0, 0xcf, 0xd2,
+ 0x0, 0xd7, 0xda, 0x0, 0xdc };
+static const unsigned char u103[] = {
+ 0x00, 0x0, 0x1e,
+ 0x30, 0x0, 0x4a };
+static const unsigned char u104[] = {
+ 0x00, 0x0, 0x25, 0x28, 0x0,
+ 0x4d };
+static const unsigned char u1d4[] = {
+ 0x00, 0x0, 0x54, 0x56, 0x0, 0x9c, 0x9e,
+ 0x0, 0x9f, 0xa2, 0xa5, 0x0, 0xa6, 0xa9, 0x0,
+ 0xac, 0xae, 0x0, 0xb9, 0xbb, 0xbd, 0x0, 0xc0,
+ 0xc2, 0x0, 0xc3, 0xc5, 0x0, 0xff };
+static const unsigned char u1d5[] = {
+ 0x00, 0x0, 0x05, 0x07, 0x0,
+ 0x0a, 0x0d, 0x0, 0x14, 0x16, 0x0, 0x1c, 0x1e,
+ 0x0, 0x39, 0x3b, 0x0, 0x3e, 0x40, 0x0, 0x44,
+ 0x46, 0x4a, 0x0, 0x50, 0x52, 0x0, 0xff };
+static const unsigned char u1d6[] = {
+ 0x00, 0x0, 0xa3, 0xa8,
+ 0x0, 0xc0, 0xc2, 0x0, 0xda, 0xdc, 0x0, 0xfa,
+ 0xfc, 0x0, 0xff };
+static const unsigned char u1d7[] = {
+ 0x00, 0x0, 0x14, 0x16, 0x0,
+ 0x34, 0x36, 0x0, 0x4e, 0x50, 0x0, 0x6e,
+ 0x70, 0x0, 0x88, 0x8a, 0x0, 0xa8, 0xaa, 0x0, 0xc2,
+ 0xc4, 0x0, 0xc9, 0xce, 0x0, 0xff };
+/* u200 to u2a5 all alphabetic */
+static const unsigned char u2a6[] = {
+ 0x00, 0x0, 0xd6 };
+/* u2f8 to u2f9 all alphabetic */
+static const unsigned char u2fa[] = {
+ 0x00, 0x0, 0x1d };
diff --git a/newlib/libc/ctype/utf8print.h b/newlib/libc/ctype/utf8print.h
new file mode 100644
index 0000000..c895a3c
--- /dev/null
+++ b/newlib/libc/ctype/utf8print.h
@@ -0,0 +1,282 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* Generated using unicode.txt 3.2 */
+
+static const unsigned char u0[] = {
+ 0x20, 0x0, 0x7e, 0xa0, 0x0, 0xff };
+/* u1 is all-print */
+static const unsigned char u2[] = {
+ 0x00, 0x0, 0x20, 0x22, 0x0,
+ 0x33, 0x50, 0x0, 0xad, 0xb0, 0x0, 0xee };
+static const unsigned char u3[] = {
+ 0x00, 0x0, 0x4f, 0x60, 0x0, 0x6f, 0x74, 0x0, 0x75,
+ 0x7a, 0x7e, 0x84, 0x0, 0x8a, 0x8c, 0x8e, 0x0,
+ 0xa1, 0xa3, 0x0, 0xce, 0xd0, 0x0, 0xf6 };
+static const unsigned char u4[] = {
+ 0x00, 0x0, 0x86, 0x88, 0x0, 0xce, 0xd0, 0x0, 0xf5,
+ 0xf8, 0x0, 0xf9 };
+static const unsigned char u5[] = {
+ 0x00, 0x0, 0x0f, 0x31, 0x0,
+ 0x56, 0x59, 0x0, 0x5f, 0x61, 0x0, 0x87, 0x89,
+ 0x0, 0x8a, 0x91, 0x0, 0xa1, 0xa3, 0x0, 0xb9,
+ 0xbb, 0x0, 0xc4, 0xd0, 0x0, 0xea, 0xf0, 0x0,
+ 0xf4 };
+static const unsigned char u6[] = {
+ 0x0c, 0x1b, 0x1f, 0x21, 0x0, 0x3a, 0x40,
+ 0x0, 0x55, 0x60, 0x0, 0xed, 0xf0, 0x0, 0xfe };
+static const unsigned char u7[] = {
+ 0x00, 0x0, 0x0d, 0x0f, 0x0, 0x2c, 0x30, 0x0,
+ 0x4a, 0x80, 0x0, 0xb1 };
+static const unsigned char u9[] = {
+ 0x01, 0x0, 0x03, 0x05,
+ 0x0, 0x39, 0x3c, 0x0, 0x4d, 0x50, 0x0, 0x54,
+ 0x58, 0x0, 0x70, 0x81, 0x0, 0x83, 0x85, 0x0,
+ 0x8c, 0x8f, 0x0, 0x90, 0x93, 0x0, 0xa8, 0xaa,
+ 0x0, 0xb0, 0xb2, 0xb6, 0x0, 0xb9, 0xbc, 0xbe,
+ 0x0, 0xc4, 0xc7, 0x0, 0xc8, 0xcb, 0x0, 0xcd,
+ 0xd7, 0xdc, 0x0, 0xdd, 0xdf, 0x0, 0xe3, 0xe6,
+ 0x0, 0xfa };
+static const unsigned char ua[] = {
+ 0x02, 0x05, 0x0, 0x0a, 0x0f, 0x0,
+ 0x10, 0x13, 0x0, 0x28, 0x2a, 0x0, 0x30, 0x32,
+ 0x0, 0x33, 0x35, 0x0, 0x36, 0x38, 0x0, 0x39,
+ 0x3c, 0x3e, 0x0, 0x42, 0x47, 0x0, 0x48, 0x4b,
+ 0x0, 0x4d, 0x59, 0x0, 0x5c, 0x5e, 0x66, 0x0,
+ 0x74, 0x81, 0x0, 0x83, 0x85, 0x0, 0x8b, 0x8d,
+ 0x8f, 0x0, 0x91, 0x93, 0x0, 0xa8, 0xaa, 0x0,
+ 0xb0, 0xb2, 0x0, 0xb3, 0xb5, 0x0, 0xb9, 0xbc,
+ 0x0, 0xc5, 0xc7, 0x0, 0xc9, 0xcb, 0x0, 0xcd,
+ 0xd0, 0xe0, 0xe6, 0x0, 0xef };
+static const unsigned char ub[] = {
+ 0x01, 0x0, 0x03,
+ 0x05, 0x0, 0x0c, 0x0f, 0x0, 0x10, 0x13, 0x0,
+ 0x28, 0x2a, 0x0, 0x30, 0x32, 0x0, 0x33, 0x36,
+ 0x0, 0x39, 0x3c, 0x0, 0x43, 0x47, 0x0, 0x48,
+ 0x4b, 0x0, 0x4d, 0x56, 0x0, 0x57, 0x5c, 0x0,
+ 0x5d, 0x5f, 0x0, 0x61, 0x66, 0x0, 0x70, 0x82,
+ 0x0, 0x83, 0x85, 0x0, 0x8a, 0x8e, 0x0, 0x90,
+ 0x92, 0x0, 0x95, 0x99, 0x0, 0x9a, 0x9c, 0x9e,
+ 0x0, 0x9f, 0xa3, 0x0, 0xa4, 0xa8, 0x0, 0xaa,
+ 0xae, 0x0, 0xb5, 0xb7, 0x0, 0xb9, 0xbe, 0x0,
+ 0xc2, 0xc6, 0x0, 0xc8, 0xca, 0x0, 0xcd, 0xd7,
+ 0xe7, 0x0, 0xf2 };
+static const unsigned char uc[] = {
+ 0x01, 0x0, 0x03, 0x05, 0x0,
+ 0x0c, 0x0e, 0x0, 0x10, 0x12, 0x0, 0x28, 0x2a,
+ 0x0, 0x33, 0x35, 0x0, 0x39, 0x3e, 0x0, 0x44,
+ 0x46, 0x0, 0x48, 0x4a, 0x0, 0x4d, 0x55, 0x0,
+ 0x56, 0x60, 0x0, 0x61, 0x66, 0x0, 0x6f, 0x82,
+ 0x0, 0x83, 0x85, 0x0, 0x8c, 0x8e, 0x0, 0x90,
+ 0x92, 0x0, 0xa8, 0xaa, 0x0, 0xb3, 0xb5, 0x0,
+ 0xb9, 0xbe, 0x0, 0xc4, 0xc6, 0x0, 0xc8, 0xca,
+ 0x0, 0xcd, 0xd5, 0x0, 0xd6, 0xde, 0xe0, 0x0,
+ 0xe1, 0xe6, 0x0, 0xef };
+static const unsigned char ud[] = {
+ 0x02, 0x0, 0x03, 0x05,
+ 0x0, 0x0c, 0x0e, 0x0, 0x10, 0x12, 0x0, 0x28,
+ 0x2a, 0x0, 0x39, 0x3e, 0x0, 0x43, 0x46, 0x0,
+ 0x48, 0x4a, 0x0, 0x4d, 0x57, 0x60, 0x0, 0x61,
+ 0x66, 0x0, 0x6f, 0x82, 0x0, 0x83, 0x85, 0x0,
+ 0x96, 0x9a, 0x0, 0xb1, 0xb3, 0x0, 0xbb, 0xbd,
+ 0xc0, 0x0, 0xc6, 0xca, 0xcf, 0x0, 0xd4, 0xd6,
+ 0xd8, 0x0, 0xdf, 0xf2, 0x0, 0xf4 };
+static const unsigned char ue[] = {
+ 0x01, 0x0,
+ 0x3a, 0x3f, 0x0, 0x5b, 0x81, 0x0, 0x82, 0x84,
+ 0x87, 0x0, 0x88, 0x8a, 0x8d, 0x94, 0x0, 0x97,
+ 0x99, 0x0, 0x9f, 0xa1, 0x0, 0xa3, 0xa5, 0xa7,
+ 0xaa, 0x0, 0xab, 0xad, 0x0, 0xb9, 0xbb, 0x0,
+ 0xbd, 0xc0, 0x0, 0xc4, 0xc6, 0xc8, 0x0, 0xcd,
+ 0xd0, 0x0, 0xd9, 0xdc, 0x0, 0xdd };
+static const unsigned char uf[] = {
+ 0x00, 0x0,
+ 0x47, 0x49, 0x0, 0x6a, 0x71, 0x0, 0x8b, 0x90,
+ 0x0, 0x97, 0x99, 0x0, 0xbc, 0xbe, 0x0, 0xcc,
+ 0xcf };
+static const unsigned char u10[] = {
+ 0x00, 0x0, 0x21, 0x23, 0x0, 0x27, 0x29,
+ 0x0, 0x2a, 0x2c, 0x0, 0x32, 0x36, 0x0, 0x39,
+ 0x40, 0x0, 0x59, 0xa0, 0x0, 0xc5, 0xd0, 0x0,
+ 0xf8, 0xfb };
+static const unsigned char u11[] = {
+ 0x00, 0x0, 0x59, 0x5f, 0x0, 0xa2,
+ 0xa8, 0x0, 0xf9 };
+static const unsigned char u12[] = {
+ 0x00, 0x0, 0x06, 0x08, 0x0,
+ 0x46, 0x48, 0x4a, 0x0, 0x4d, 0x50, 0x0, 0x56,
+ 0x58, 0x5a, 0x0, 0x5d, 0x60, 0x0, 0x86, 0x88,
+ 0x8a, 0x0, 0x8d, 0x90, 0x0, 0xae, 0xb0, 0xb2,
+ 0x0, 0xb5, 0xb8, 0x0, 0xbe, 0xc0, 0xc2, 0x0,
+ 0xc5, 0xc8, 0x0, 0xce, 0xd0, 0x0, 0xd6, 0xd8,
+ 0x0, 0xee, 0xf0, 0x0, 0xff };
+static const unsigned char u13[] = {
+ 0x00, 0x0, 0x0e, 0x10, 0x12, 0x0,
+ 0x15, 0x18, 0x0, 0x1e, 0x20, 0x0, 0x46, 0x48,
+ 0x0, 0x5a, 0x61, 0x0, 0x7c, 0xa0, 0x0, 0xf4 };
+static const unsigned char u14[] = {
+ 0x01, 0x0, 0xff };
+/* u15 is all-print */
+static const unsigned char u16[] = {
+ 0x00, 0x0, 0x76, 0x80, 0x0, 0x9c, 0xa0, 0x0,
+ 0xf0 };
+static const unsigned char u17[] = {
+ 0x00, 0x0, 0x0c, 0x0e, 0x0, 0x14, 0x20,
+ 0x0, 0x36, 0x40, 0x0, 0x53, 0x60, 0x0, 0x6c,
+ 0x6e, 0x0, 0x70, 0x72, 0x0, 0x73, 0x80, 0x0,
+ 0xdc, 0xe0, 0x0, 0xe9 };
+static const unsigned char u18[] = {
+ 0x00, 0x0, 0x0e, 0x10,
+ 0x0, 0x19, 0x20, 0x0, 0x77, 0x80, 0x0, 0xa9 };
+static const unsigned char u1e[] = {
+ 0x00, 0x0, 0x9b, 0xa0, 0x0, 0xf9 };
+static const unsigned char u1f[] = {
+ 0x00, 0x0,
+ 0x15, 0x18, 0x0, 0x1d, 0x20, 0x0, 0x45, 0x48,
+ 0x0, 0x4d, 0x50, 0x0, 0x57, 0x59, 0x5b, 0x5d,
+ 0x5f, 0x0, 0x7d, 0x80, 0x0, 0xb4, 0xb6, 0x0,
+ 0xc4, 0xc6, 0x0, 0xd3, 0xd6, 0x0, 0xdb, 0xdd,
+ 0x0, 0xef, 0xf2, 0x0, 0xf4, 0xf6, 0x0, 0xfe };
+static const unsigned char u20[] = {
+ 0x00, 0x0, 0x27, 0x2a, 0x0, 0x52, 0x57, 0x5f,
+ 0x0, 0x63, 0x6a, 0x0, 0x71, 0x74, 0x0, 0x8e,
+ 0xa0, 0x0, 0xb1, 0xd0, 0x0, 0xea };
+static const unsigned char u21[] = {
+ 0x00, 0x0,
+ 0x3a, 0x3d, 0x0, 0x4b, 0x53, 0x0, 0x83, 0x90,
+ 0x0, 0xff };
+/* u22 is all-print */
+static const unsigned char u23[] = {
+ 0x00, 0x0, 0xce };
+static const unsigned char u24[] = {
+ 0x00, 0x0, 0x26, 0x40, 0x0, 0x4a,
+ 0x60, 0x0, 0xfe };
+/* u25 is all-print */
+static const unsigned char u26[] = {
+ 0x00, 0x0, 0x13, 0x16, 0x0,
+ 0x17, 0x19, 0x0, 0x7d, 0x80, 0x0, 0x89 };
+static const unsigned char u27[] = {
+ 0x01,
+ 0x0, 0x04, 0x06, 0x0, 0x09, 0x0c, 0x0, 0x27,
+ 0x29, 0x0, 0x4b, 0x4d, 0x4f, 0x0, 0x52, 0x56,
+ 0x58, 0x0, 0x5e, 0x61, 0x0, 0x94, 0x98, 0x0,
+ 0xaf, 0xb1, 0x0, 0xbe, 0xd0, 0x0, 0xeb, 0xf0,
+ 0x0, 0xff };
+/* u28 to u2a are all-print */
+static const unsigned char u2e[] = {
+ 0x80, 0x0, 0x99, 0x9b, 0x0, 0xf3 };
+static const unsigned char u2f[] = {
+ 0x00, 0x0, 0xd5, 0xf0, 0x0, 0xfb };
+static const unsigned char u30[] = {
+ 0x00, 0x0,
+ 0x3f, 0x41, 0x0, 0x96, 0x99, 0x0, 0xff };
+static const unsigned char u31[] = {
+ 0x05,
+ 0x0, 0x2c, 0x31, 0x0, 0x8e, 0x90, 0x0, 0xb7,
+ 0xf0, 0x0, 0xff };
+static const unsigned char u32[] = {
+ 0x00, 0x0, 0x1c, 0x20, 0x0, 0x43, 0x51, 0x0,
+ 0x7b, 0x7f, 0x0, 0xcb, 0xd0, 0x0, 0xfe };
+static const unsigned char u33[] = {
+ 0x00,
+ 0x0, 0x76, 0x7b, 0x0, 0xdd, 0xe0, 0x0, 0xfe };
+/* u34 to u4c is all-print */
+static const unsigned char u4d[] = {
+ 0x00, 0x0, 0xb5 };
+/* u4e to u9e is all-print */
+static const unsigned char u9f[] = {
+ 0x00, 0x0, 0xa5 };
+/* ua0 to ua3 is all-print */
+static const unsigned char ua4[] = {
+ 0x00, 0x0,
+ 0x8c, 0x90, 0x0, 0xc6 };
+/* uac to ud6 is all-print */
+static const unsigned char ud7[] = {
+ 0x00, 0x0, 0xa3 };
+/* ue0 to uf9 is all-print */
+static const unsigned char ufa[] = {
+ 0x00, 0x0, 0x2d, 0x30, 0x0, 0x6a };
+static const unsigned char ufb[] = {
+ 0x00, 0x0, 0x06,
+ 0x13, 0x0, 0x17, 0x1d, 0x0, 0x36, 0x38, 0x0,
+ 0x3c, 0x3e, 0x40, 0x0, 0x41, 0x43, 0x0, 0x44,
+ 0x46, 0x0, 0xb1, 0xd3, 0x0, 0xff };
+/* ufc is all-print */
+static const unsigned char ufd[] = {
+ 0x00, 0x0, 0x3f, 0x50, 0x0,
+ 0x8f, 0x92, 0x0, 0xc7, 0xf0, 0x0, 0xfc };
+static const unsigned char ufe[] = {
+ 0x00,
+ 0x0, 0x0f, 0x20, 0x0, 0x23, 0x30, 0x0, 0x46,
+ 0x49, 0x0, 0x52, 0x54, 0x0, 0x66, 0x68, 0x0,
+ 0x6b, 0x70, 0x0, 0x74, 0x76, 0x0, 0xfc, 0xff };
+static const unsigned char uff[] = {
+ 0x01, 0x0, 0xbe, 0xc2, 0x0, 0xc7, 0xca, 0x0,
+ 0xcf, 0xd2, 0x0, 0xd7, 0xda, 0x0, 0xdc, 0xe0,
+ 0x0, 0xe6, 0xe8, 0x0, 0xee, 0xf9, 0x0, 0xfd };
+static const unsigned char u103[] = {
+ 0x00, 0x0, 0x1e, 0x20, 0x0, 0x23, 0x30, 0x0,
+ 0x4a };
+static const unsigned char u104[] = {
+ 0x00, 0x0, 0x25, 0x28, 0x0, 0x4d };
+static const unsigned char u1d0[] = {
+ 0x00,
+ 0x0, 0xf5 };
+static const unsigned char u1d1[] = {
+ 0x00, 0x0, 0x26, 0x2a, 0x0, 0xdd };
+static const unsigned char u1d4[] = {
+ 0x00, 0x0, 0x54, 0x56, 0x0, 0x9c, 0x9e, 0x0,
+ 0x9f, 0xa2, 0xa5, 0x0, 0xa6, 0xa9, 0x0, 0xac,
+ 0xae, 0x0, 0xb9, 0xbb, 0xbd, 0x0, 0xc0, 0xc2,
+ 0x0, 0xc3, 0xc5, 0x0, 0xff };
+static const unsigned char u1d5[] = {
+ 0x00, 0x0, 0x05, 0x07, 0x0, 0x0a,
+ 0x0d, 0x0, 0x14, 0x16, 0x0, 0x1c, 0x1e, 0x0,
+ 0x39, 0x3b, 0x0, 0x3e, 0x40, 0x0, 0x44, 0x46,
+ 0x4a, 0x0, 0x50, 0x52, 0x0, 0xff };
+static const unsigned char u1d6[] = {
+ 0x00, 0x0, 0xa3, 0xa8, 0x0, 0xff };
+static const unsigned char u1d7[] = {
+ 0x00, 0x0, 0xc9, 0xce, 0x0, 0xff };
+/* u200 to u2a5 is all-print */
+static const unsigned char u2a6[] = {
+ 0x00, 0x0, 0xd6 };
+/* u2f8 to u2f9 is all-print */
+static const unsigned char u2fa[] = {
+ 0x00,
+ 0x0, 0x1d };
+static const unsigned char ue00[] = {
+ 0x01, 0x20, 0x0, 0x7f };
+/* uf00 to uffe is all-print */
+static const unsigned char ufff[] = {
+ 0x00, 0x0,
+ 0xfd };
+/* u1000 to u10fe is all-print */
+static const unsigned char u10ff[] = {
+ 0x00, 0x0, 0xfd };
diff --git a/newlib/libc/ctype/utf8punct.h b/newlib/libc/ctype/utf8punct.h
new file mode 100644
index 0000000..55c31f9
--- /dev/null
+++ b/newlib/libc/ctype/utf8punct.h
@@ -0,0 +1,201 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* Generated using unicode.txt 3.2 */
+
+static const unsigned char u0[] = {
+ 0x21, 0x0, 0x2f, 0x3a, 0x0, 0x40, 0x5b, 0x0,
+ 0x60, 0x7b, 0x0, 0x7e, 0xa0, 0x0, 0xa9, 0xab,
+ 0x0, 0xb4, 0xb6, 0x0, 0xb9, 0xbb, 0x0, 0xbf,
+ 0xd7, 0xf7 };
+static const unsigned char u2[] = {
+ 0xb9, 0x0, 0xba, 0xc2, 0x0, 0xcf,
+ 0xd2, 0x0, 0xdf, 0xe5, 0x0, 0xed };
+static const unsigned char u3[] = {
+ 0x00, 0x0,
+ 0x44, 0x46, 0x0, 0x4f, 0x60, 0x0, 0x6f, 0x74,
+ 0x0, 0x75, 0x7e, 0x84, 0x0, 0x85, 0x87, 0xf6 };
+static const unsigned char u4[] = {
+ 0x82, 0x0, 0x86, 0x88, 0x0, 0x89 };
+static const unsigned char u5[] = {
+ 0x5a, 0x0,
+ 0x5f, 0x89, 0x0, 0x8a, 0x91, 0x0, 0xa1, 0xa3,
+ 0x0, 0xb9, 0xbb, 0x0, 0xc4, 0xf3, 0x0, 0xf4 };
+static const unsigned char u6[] = {
+ 0x0c, 0x1b, 0x1f, 0x4b, 0x0, 0x55, 0x6a, 0x0,
+ 0x6d, 0x70, 0xd4, 0xd6, 0x0, 0xe4, 0xe7, 0x0,
+ 0xed, 0xfd, 0x0, 0xfe };
+static const unsigned char u7[] = {
+ 0x00, 0x0, 0x0d, 0x0f,
+ 0x11, 0x30, 0x0, 0x4a, 0xa6, 0x0, 0xb0 };
+static const unsigned char u9[] = {
+ 0x01,
+ 0x0, 0x03, 0x3c, 0x3e, 0x0, 0x4d, 0x51, 0x0,
+ 0x54, 0x62, 0x0, 0x65, 0x70, 0x81, 0x0, 0x83,
+ 0xbc, 0xbe, 0x0, 0xc4, 0xc7, 0x0, 0xc8, 0xcb,
+ 0x0, 0xcd, 0xd7, 0xe2, 0x0, 0xe3, 0xf2, 0x0,
+ 0xfa };
+static const unsigned char ua[] = {
+ 0x02, 0x3c, 0x3e, 0x0, 0x42, 0x47, 0x0,
+ 0x48, 0x4b, 0x0, 0x4d, 0x70, 0x0, 0x71, 0x81,
+ 0x0, 0x83, 0xbc, 0xbe, 0x0, 0xc5, 0xc7, 0x0,
+ 0xc9, 0xcb, 0x0, 0xcd };
+static const unsigned char ub[] = {
+ 0x01, 0x0, 0x03, 0x3c,
+ 0x3e, 0x0, 0x43, 0x47, 0x0, 0x48, 0x4b, 0x0,
+ 0x4d, 0x56, 0x0, 0x57, 0x70, 0x82, 0xbe, 0x0,
+ 0xc2, 0xc6, 0x0, 0xc8, 0xca, 0x0, 0xcd, 0xd7,
+ 0xf0, 0x0, 0xf2 };
+static const unsigned char uc[] = {
+ 0x01, 0x0, 0x03, 0x3e, 0x0,
+ 0x44, 0x46, 0x0, 0x48, 0x4a, 0x0, 0x4d, 0x55,
+ 0x0, 0x56, 0x82, 0x0, 0x83, 0xbe, 0x0, 0xc4,
+ 0xc6, 0x0, 0xc8, 0xca, 0x0, 0xcd, 0xd5, 0x0,
+ 0xd6 };
+static const unsigned char ud[] = {
+ 0x02, 0x0, 0x03,
+ 0x3e, 0x0, 0x43, 0x46,
+ 0x0, 0x48, 0x4a, 0x0, 0x4d, 0x57, 0x82, 0x0,
+ 0x83, 0xca, 0xcf, 0x0, 0xd4, 0xd6, 0xd8, 0x0,
+ 0xdf, 0xf2, 0x0, 0xf4 };
+static const unsigned char ue[] = {
+ 0x2f, 0x3f, 0x46, 0x4f,
+ 0x5a, 0x0, 0x5b, 0xb1, 0xb4, 0x0, 0xb9, 0xbb,
+ 0x0, 0xbc, 0xc8, 0x0, 0xcd };
+static const unsigned char uf[] = {
+ 0x01, 0x0, 0x1f,
+ 0x2a, 0x0, 0x3f, 0x71, 0x0, 0x87, 0x90, 0x0,
+ 0x97, 0x99, 0x0, 0xbc, 0xbe, 0x0, 0xcc, 0xcf };
+static const unsigned char u10[] = {
+ 0x2c, 0x0, 0x32, 0x36, 0x0, 0x39, 0x4a, 0x0,
+ 0x4f, 0x56, 0x0, 0x59, 0xfb };
+static const unsigned char u13[] = {
+ 0x61, 0x0, 0x68,
+ 0x72, 0x0, 0x7c };
+static const unsigned char u16[] = {
+ 0x6d, 0x0, 0x6e, 0x9b, 0x0,
+ 0x9c, 0xeb, 0x0, 0xed };
+static const unsigned char u17[] = {
+ 0x12, 0x0, 0x14, 0x32,
+ 0x0, 0x36, 0x52, 0x0, 0x53, 0x72, 0x0, 0x73,
+ 0xb4, 0x0, 0xd6, 0xd8, 0x0, 0xdb };
+static const unsigned char u18[] = {
+ 0x00, 0x0,
+ 0x0e, 0xa9 };
+static const unsigned char u1f[] = {
+ 0xbd, 0xbf, 0x0, 0xc1,
+ 0xcd, 0x0, 0xcf, 0xdd, 0x0, 0xdf, 0xed, 0x0, 0xef, 0xfd,
+ 0x0, 0xfe };
+static const unsigned char u20[] = {
+ 0x07, 0x0c, 0x0, 0x27, 0x2a, 0x0,
+ 0x52, 0x57, 0x60, 0x0, 0x63, 0x6a, 0x0, 0x70,
+ 0x74, 0x0, 0x7e, 0x80, 0x0, 0x8e, 0xa0, 0x0,
+ 0xb1, 0xd0, 0x0, 0xea };
+static const unsigned char u21[] = {
+ 0x00, 0x0, 0x01, 0x03,
+ 0x0, 0x06, 0x08, 0x0, 0x09, 0x14, 0x16, 0x0,
+ 0x18, 0x1e, 0x0, 0x23, 0x25, 0x27, 0x2e, 0x32,
+ 0x3a, 0x40, 0x0, 0x44, 0x4a, 0x0, 0x4b, 0x53,
+ 0x0, 0x5f, 0x90, 0x0, 0xff };
+/* u22 is all-punctuation */
+static const unsigned char u23[] = {
+ 0x00, 0x0, 0xce };
+static const unsigned char u24[] = {
+ 0x00, 0x0, 0x26,
+ 0x40, 0x0, 0x4a, 0x60, 0x0, 0x9b, 0xea, 0x0,
+ 0xfe };
+/* u25 is all-punctuation */
+static const unsigned char u26[] = {
+ 0x00, 0x0, 0x13,
+ 0x16, 0x0, 0x17, 0x19,
+ 0x0, 0x7d, 0x80, 0x0, 0x89 };
+static const unsigned char u27[] = {
+ 0x01, 0x0, 0x04,
+ 0x06, 0x0, 0x09, 0x0c, 0x0, 0x27, 0x29, 0x0,
+ 0x4b, 0x4d, 0x4f, 0x0, 0x52, 0x56, 0x58, 0x0,
+ 0x5e, 0x61, 0x0, 0x94, 0x98, 0x0, 0xaf, 0xb1,
+ 0x0, 0xbe, 0xd0, 0x0, 0xeb, 0xf0, 0x0, 0xff };
+/* u28 to u2a is all-punctuation */
+static const unsigned char u2e[] = {
+ 0x80, 0x0, 0x99,
+ 0x9b, 0x0, 0xf3 };
+static const unsigned char u2f[] = {
+ 0x00, 0x0,
+ 0xd5, 0xf0, 0x0, 0xfb };
+static const unsigned char u30[] = {
+ 0x01, 0x0, 0x04, 0x08,
+ 0x0, 0x20, 0x2a, 0x0, 0x30, 0x36, 0x0, 0x37,
+ 0x3d, 0x0, 0x3f, 0x99, 0x0, 0x9c, 0xa0, 0xfb };
+static const unsigned char u31[] = {
+ 0x90, 0x0, 0x9f };
+static const unsigned char u32[] = {
+ 0x00, 0x0, 0x1c, 0x20, 0x0,
+ 0x43, 0x51, 0x0, 0x7b, 0x7f, 0x0, 0xcb, 0xd0,
+ 0x0, 0xfe };
+static const unsigned char u33[] = {
+ 0x00, 0x0, 0x76, 0x7b, 0x0, 0xdd,
+ 0xe0, 0x0, 0xfe };
+static const unsigned char ua4[] = {
+ 0x90, 0x0, 0xc6 };
+/* ue0 to uf8 are all-punctuation */
+static const unsigned char ufb[] = {
+ 0x1e, 0x29 };
+static const unsigned char ufd[] = {
+ 0x3e, 0x0, 0x3f, 0xfc };
+static const unsigned char ufe[] = {
+ 0x00,
+ 0x0, 0x0f, 0x20, 0x0, 0x23, 0x30, 0x0, 0x46,
+ 0x49, 0x0, 0x52, 0x54, 0x0, 0x66, 0x68, 0x0,
+ 0x6b, 0xff };
+static const unsigned char uff[] = {
+ 0x01, 0x0, 0x0f, 0x1a, 0x0, 0x20,
+ 0x3b, 0x0, 0x40, 0x5b, 0x0, 0x65, 0xe0, 0x0,
+ 0xe6, 0xe8, 0x0, 0xee, 0xf9, 0x0, 0xfd };
+static const unsigned char u103[] = {
+ 0x20,
+ 0x0, 0x23 };
+static const unsigned char u1d0[] = {
+ 0x00, 0x0, 0xf5 };
+static const unsigned char u1d1[] = {
+ 0x00, 0x0, 0x26,
+ 0x2a, 0x0, 0xdd };
+static const unsigned char u1d6[] = {
+ 0xc1, 0xdb, 0xfb };
+static const unsigned char u1d7[] = {
+ 0x15, 0x35,
+ 0x4f, 0x6f, 0x89, 0xa9, 0xc3 };
+static const unsigned char ue00[] = {
+ 0x01, 0x20, 0x0,
+ 0x7f };
+/* uf00 to uffe are all punctuation */
+static const unsigned char ufff[] = {
+ 0x00, 0x0, 0xfd };
+/* u1000 to u10fe are all punctuation */
+static const unsigned char u10ff[] = {
+ 0x00, 0x0, 0xfd };
diff --git a/newlib/libc/ctype/wctrans.c b/newlib/libc/ctype/wctrans.c
new file mode 100644
index 0000000..7506983
--- /dev/null
+++ b/newlib/libc/ctype/wctrans.c
@@ -0,0 +1,94 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<wctrans>>---get wide-character translation type
+
+INDEX
+ wctrans
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ wctrans_t wctrans(const char *<[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ wctrans_t wctrans(<[c]>)
+ const char * <[c]>;
+
+
+DESCRIPTION
+<<wctrans>> is a function which takes a string <[c]> and gives back
+the appropriate wctrans_t type value associated with the string,
+if one exists. The following values are guaranteed to be recognized:
+"tolower" and "toupper".
+
+RETURNS
+<<wctrans>> returns 0 and sets <<errno>> to <<EINVAL>> if the
+given name is invalid. Otherwise, it returns a valid non-zero wctrans_t
+value.
+
+PORTABILITY
+<<wctrans>> is C99.
+
+No supporting OS subroutines are required.
+*/
+
+#include <_ansi.h>
+#include <string.h>
+#include <reent.h>
+#include <wctype.h>
+#include <errno.h>
+#include "local.h"
+
+wctrans_t
+_DEFUN (_wctrans_r, (r, c),
+ struct _reent *r _AND
+ const char *c)
+{
+ if (!strcmp (c, "tolower"))
+ return WCT_TOLOWER;
+ else if (!strcmp (c, "toupper"))
+ return WCT_TOUPPER;
+ else
+ {
+ r->_errno = EINVAL;
+ return 0;
+ }
+}
+
+#ifndef _REENT_ONLY
+wctrans_t
+_DEFUN (wctrans, (c),
+ const char *c)
+{
+ return _wctrans_r (_REENT, c);
+}
+#endif /* !_REENT_ONLY */
diff --git a/newlib/libc/ctype/wctype.c b/newlib/libc/ctype/wctype.c
new file mode 100644
index 0000000..f2c9d02
--- /dev/null
+++ b/newlib/libc/ctype/wctype.c
@@ -0,0 +1,138 @@
+/* Copyright (c) 2002 Red Hat Incorporated.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ The name of Red Hat Incorporated may not be used to endorse
+ or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+FUNCTION
+ <<wctype>>---get wide-character classification type
+
+INDEX
+ wctype
+
+ANSI_SYNOPSIS
+ #include <wctype.h>
+ wctype_t wctype(const char *<[c]>);
+
+TRAD_SYNOPSIS
+ #include <wctype.h>
+ wctype_t wctype(<[c]>)
+ const char * <[c]>;
+
+
+DESCRIPTION
+<<wctype>> is a function which takes a string <[c]> and gives back
+the appropriate wctype_t type value associated with the string,
+if one exists. The following values are guaranteed to be recognized:
+"alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print",
+"punct", "space", "upper", and "xdigit".
+
+RETURNS
+<<wctype>> returns 0 and sets <<errno>> to <<EINVAL>> if the
+given name is invalid. Otherwise, it returns a valid non-zero wctype_t
+value.
+
+PORTABILITY
+<<wctype>> is C99.
+
+No supporting OS subroutines are required.
+*/
+
+#include <_ansi.h>
+#include <string.h>
+#include <reent.h>
+#include <wctype.h>
+#include <errno.h>
+#include "local.h"
+
+wctype_t
+_DEFUN (_wctype_r, (r, c),
+ struct _reent *r _AND
+ const char *c)
+{
+ switch (*c)
+ {
+ case 'a':
+ if (!strcmp (c, "alnum"))
+ return WC_ALNUM;
+ else if (!strcmp (c, "alpha"))
+ return WC_ALPHA;
+ break;
+ case 'b':
+ if (!strcmp (c, "blank"))
+ return WC_BLANK;
+ break;
+ case 'c':
+ if (!strcmp (c, "cntrl"))
+ return WC_CNTRL;
+ break;
+ case 'd':
+ if (!strcmp (c, "digit"))
+ return WC_DIGIT;
+ break;
+ case 'g':
+ if (!strcmp (c, "graph"))
+ return WC_GRAPH;
+ break;
+ case 'l':
+ if (!strcmp (c, "lower"))
+ return WC_LOWER;
+ break;
+ case 'p':
+ if (!strcmp (c, "print"))
+ return WC_PRINT;
+ else if (!strcmp (c, "punct"))
+ return WC_PUNCT;
+ break;
+ case 's':
+ if (!strcmp (c, "space"))
+ return WC_SPACE;
+ break;
+ case 'u':
+ if (!strcmp (c, "upper"))
+ return WC_UPPER;
+ break;
+ case 'x':
+ if (!strcmp (c, "xdigit"))
+ return WC_XDIGIT;
+ break;
+ default:
+ }
+
+ /* otherwise invalid */
+ r->_errno = EINVAL;
+ return 0;
+}
+
+#ifndef _REENT_ONLY
+wctype_t
+_DEFUN (wctype, (c),
+ const char *c)
+{
+ return _wctype_r (_REENT, c);
+}
+#endif /* !_REENT_ONLY */
diff --git a/newlib/libc/locale/locale.c b/newlib/libc/locale/locale.c
index 691ff9f..772f150 100644
--- a/newlib/libc/locale/locale.c
+++ b/newlib/libc/locale/locale.c
@@ -112,6 +112,7 @@ static _CONST struct lconv lconv =
char * _EXFUN(__locale_charset,(_VOID));
static char *charset = "ISO-8859-1";
+char __lc_ctype[12] = "C";
char *
_DEFUN(_setlocale_r, (p, category, locale),
@@ -129,7 +130,6 @@ _DEFUN(_setlocale_r, (p, category, locale),
}
return "C";
#else
- static char lc_ctype[12] = "C";
static char last_lc_ctype[12] = "C";
static char lc_messages[12] = "C";
static char last_lc_messages[12] = "C";
@@ -143,8 +143,8 @@ _DEFUN(_setlocale_r, (p, category, locale),
return 0;
if (category == LC_ALL)
{
- strcpy (last_lc_ctype, lc_ctype);
- strcpy (lc_ctype, "C");
+ strcpy (last_lc_ctype, __lc_ctype);
+ strcpy (__lc_ctype, "C");
strcpy (last_lc_messages, lc_messages);
strcpy (lc_messages, "C");
__mb_cur_max = 1;
@@ -189,8 +189,8 @@ _DEFUN(_setlocale_r, (p, category, locale),
if (category == LC_CTYPE)
{
- strcpy (last_lc_ctype, lc_ctype);
- strcpy (lc_ctype, locale_name);
+ strcpy (last_lc_ctype, __lc_ctype);
+ strcpy (__lc_ctype, locale_name);
__mb_cur_max = 1;
if (locale[1] == '-')
@@ -257,7 +257,7 @@ _DEFUN(_setlocale_r, (p, category, locale),
else
{
if (category == LC_CTYPE)
- return lc_ctype;
+ return __lc_ctype;
else if (category == LC_MESSAGES)
return lc_messages;
}
diff --git a/newlib/libc/stdlib/mbtowc_r.c b/newlib/libc/stdlib/mbtowc_r.c
index 26141b4..c7c7eff 100644
--- a/newlib/libc/stdlib/mbtowc_r.c
+++ b/newlib/libc/stdlib/mbtowc_r.c
@@ -44,6 +44,8 @@ static JIS_ACTION JIS_action_table[JIS_S_NUM][JIS_C_NUM] = {
/* we override the mbstate_t __count field for more complex encodings and use it store a state value */
#define __state __count
+extern char __lc_ctype[12];
+
int
_DEFUN (_mbtowc_r, (r, pwc, s, n, state),
struct _reent *r _AND
@@ -62,10 +64,10 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
return -2;
#ifdef MB_CAPABLE
- if (r->_current_locale == NULL ||
- (strlen (r->_current_locale) <= 1))
+ if (__lc_ctype == NULL ||
+ (strlen (__lc_ctype) <= 1))
{ /* fall-through */ }
- else if (!strcmp (r->_current_locale, "C-UTF-8"))
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
{
int ch;
int i = 0;
@@ -307,7 +309,7 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
else
return -1;
}
- else if (!strcmp (r->_current_locale, "C-SJIS"))
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
{
int ch;
int i = 0;
@@ -337,7 +339,7 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
return -1;
}
}
- else if (!strcmp (r->_current_locale, "C-EUCJP"))
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
{
int ch;
int i = 0;
@@ -367,7 +369,7 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
return -1;
}
}
- else if (!strcmp (r->_current_locale, "C-JIS"))
+ else if (!strcmp (__lc_ctype, "C-JIS"))
{
JIS_STATE curr_state;
JIS_ACTION action;
diff --git a/newlib/libc/stdlib/wctomb_r.c b/newlib/libc/stdlib/wctomb_r.c
index 4bcabee..a018632 100644
--- a/newlib/libc/stdlib/wctomb_r.c
+++ b/newlib/libc/stdlib/wctomb_r.c
@@ -7,6 +7,8 @@
/* for some conversions, we use the __count field as a place to store a state value */
#define __state __count
+extern char __lc_ctype[12];
+
int
_DEFUN (_wctomb_r, (r, s, wchar, state),
struct _reent *r _AND
@@ -14,9 +16,9 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
wchar_t wchar _AND
mbstate_t *state)
{
- if (strlen (r->_current_locale) <= 1)
+ if (strlen (__lc_ctype) <= 1)
{ /* fall-through */ }
- else if (!strcmp (r->_current_locale, "C-UTF-8"))
+ else if (!strcmp (__lc_ctype, "C-UTF-8"))
{
if (s == NULL)
return 0; /* UTF-8 encoding is not state-dependent */
@@ -73,7 +75,7 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
else
return -1;
}
- else if (!strcmp (r->_current_locale, "C-SJIS"))
+ else if (!strcmp (__lc_ctype, "C-SJIS"))
{
unsigned char char2 = (unsigned char)wchar;
unsigned char char1 = (unsigned char)(wchar >> 8);
@@ -94,7 +96,7 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
return -1;
}
}
- else if (!strcmp (r->_current_locale, "C-EUCJP"))
+ else if (!strcmp (__lc_ctype, "C-EUCJP"))
{
unsigned char char2 = (unsigned char)wchar;
unsigned char char1 = (unsigned char)(wchar >> 8);
@@ -115,7 +117,7 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
return -1;
}
}
- else if (!strcmp (r->_current_locale, "C-JIS"))
+ else if (!strcmp (__lc_ctype, "C-JIS"))
{
int cnt = 0;
unsigned char char2 = (unsigned char)wchar;