add srfi-14: charsetchar-sets

21 files changed, 6632 insertions, 1638 deletions

diff --git a/.gitignore b/.gitignore
index a06f183..f7321a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@ unix/debug
 unix/release
 windows/debug
 windows/release
+unidata/*.txt
+unidata/debug
diff --git a/README.md b/README.md
index 07e47d4..bd5eb2d 100644
--- a/README.md
+++ b/README.md
@@ -12,13 +12,14 @@
 * [Package](https://gitlab.com/jpellegrini/openwrt-packages) for OpenWRT.
 * 32 bit and 64 bit.
 * SRFI 1: List Library
+* SRFI 14: Character-set Library
 * SRFI 60: Integers as Bits
-* SRFI 106: Basic socket interface.
-* SRFI 111: Boxes.
-* SRFI 112: Environment Inquiry.
-* SRFI 124: Ephemerons.
-* SRFI 128: Comparators.
-* SRFI 133: Vector Library (R7RS-compatible).
+* SRFI 106: Basic socket interface
+* SRFI 111: Boxes
+* SRFI 112: Environment Inquiry
+* SRFI 124: Ephemerons
+* SRFI 128: Comparators
+* SRFI 133: Vector Library (R7RS-compatible)
 
 See [Foment](https://github.com/leftmike/foment/wiki/Foment) for more details.
 
diff --git a/src/base.scm b/src/base.scm
index ef002b5..55f421d 100644
--- a/src/base.scm
+++ b/src/base.scm
@@ -423,6 +423,35 @@
         vector-swap!
         vector-reverse!
     )
+    (export ;; (scheme charset) and (srfi 14)
+        char-set?
+        char-set=
+        char-set<=
+        char-set-hash
+        char-set-cursor
+        char-set-cursor-next
+        list->char-set
+        string->char-set
+        ucs-range->char-set
+        char-set-contains?
+        char-set-complement
+        char-set-union
+        %char-set-intersection
+        char-set:lower-case
+        char-set:upper-case
+        char-set:title-case
+        char-set:letter
+        char-set:digit
+        char-set:whitespace
+        char-set:iso-control
+        char-set:punctuation
+        char-set:symbol
+        char-set:hex-digit
+        char-set:blank
+        char-set:ascii
+        char-set:empty
+        char-set:full
+    )
     (export
         make-ascii-port
         make-latin1-port
diff --git a/src/chars.cpp b/src/chars.cpp
index 61b1520..24e64a6 100644
--- a/src/chars.cpp
+++ b/src/chars.cpp
@@ -189,10 +189,7 @@ Define("char-numeric?", CharNumericPPrimitive)(long_t argc, FObject argv[])
     OneArgCheck("char-numeric?", argc);
     CharacterArgCheck("char-numeric?", argv[0]);
 
-    long_t dv = DigitValue(AsCharacter(argv[0]));
-    if (dv < 0 || dv > 9)
-        return(FalseObject);
-    return(TrueObject);
+    return(DigitP(AsCharacter(argv[0])) ? TrueObject : FalseObject);
 }
 
 Define("char-whitespace?", CharWhitespacePPrimitive)(long_t argc, FObject argv[])
diff --git a/src/charset.cpp b/src/charset.cpp
new file mode 100644
index 0000000..36079fa
--- /dev/null
+++ b/src/charset.cpp
@@ -0,0 +1,790 @@
+/*
+
+Foment
+
+*/
+
+#include "foment.hpp"
+
+#if !defined(FOMENT_BSD) && !defined(FOMENT_OSX)
+#include <malloc.h>
+#endif // FOMENT_BSD
+#include <stdlib.h>
+#include <string.h>
+#include "unicode.hpp"
+#include "unicrng.hpp"
+
+// ---- Roots ----
+
+static FObject EmptyCharSet = NoValueObject;
+static FObject FullCharSet = NoValueObject;
+
+// ---- CharSets ----
+
+typedef struct
+{
+    FCharRange Ranges[1];
+} FCharSet;
+
+#define AsCharSet(obj) ((FCharSet *) (obj))
+#define CharSetP(obj) (IndirectTag(obj) == CharSetTag)
+
+static FObject MakeCharSet(ulong_t nr, FCharRange * r, const char * who)
+{
+    FCharSet * cset = (FCharSet *) MakeObject(CharSetTag, sizeof(FCharRange) * nr, 0, who);
+    memcpy(cset->Ranges, r, sizeof(FCharRange) * nr);
+    return(cset);
+}
+
+inline ulong_t NumRanges(FObject obj)
+{
+    FAssert(CharSetP(obj));
+    FAssert(ByteLength(obj) % sizeof(FCharRange) == 0);
+
+    return(ByteLength(obj) / sizeof(FCharRange));
+}
+
+inline int InvalidUCSCh(FCh ch)
+{
+    if ((ch > 0xD7FF && ch < 0xE000) || ch > 0x10FFFF)
+        return(1);
+    return(0);
+}
+
+#ifdef FOMENT_DEBUG
+static int ValidCharSet(FObject obj)
+{
+    if (CharSetP(obj) == 0)
+        return(0);
+
+    ulong_t nr = NumRanges(obj);
+    FCharSet * cset = AsCharSet(obj);
+    for (ulong_t rdx = 0; rdx < nr; rdx++)
+    {
+        if (cset->Ranges[rdx].Start > cset->Ranges[rdx].End)
+            return(0);
+        if (rdx > 0 && cset->Ranges[rdx].Start <= cset->Ranges[rdx - 1].End)
+            return(0);
+    }
+
+    return(1);
+}
+#endif // FOMENT_DEBUG
+
+static int RangeCmp(const void * key, const void * datum)
+{
+    FCh ch = *((const FCh *) key);
+    const FCharRange * r = (const FCharRange *) datum;
+
+    if (ch < r->Start)
+        return(-1);
+    else if (ch > r->End)
+        return(1);
+    return(0);
+}
+
+static int CharRangeMemberP(ulong_t nr, FCharRange * r, FCh ch)
+{
+    if (nr > 10)
+        return(bsearch(&ch, r, nr, sizeof(FCharRange), RangeCmp) != 0);
+    else
+    {
+        for (ulong_t ndx = 0; ndx < nr; ndx++)
+        {
+            if (ch >= r[ndx].Start)
+            {
+                if (ch <= r[ndx].End)
+                    return(1);
+            }
+            else // (ch < r[ndx].Start
+                return(0);
+        }
+    }
+
+    return(0);
+}
+
+int WhitespaceP(FCh ch)
+{
+    return(CharRangeMemberP(sizeof(WhitespaceCharRange) / sizeof(FCharRange),
+            WhitespaceCharRange, ch));
+}
+
+unsigned int DigitP(FCh ch)
+{
+    return(CharRangeMemberP(sizeof(DigitCharRange) / sizeof(FCharRange), DigitCharRange, ch));
+}
+
+unsigned int AlphabeticP(FCh ch)
+{
+    return(CharRangeMemberP(sizeof(LetterCharRange) / sizeof(FCharRange), LetterCharRange, ch));
+}
+
+unsigned int UppercaseP(FCh ch)
+{
+    return(CharRangeMemberP(sizeof(UpperCaseCharRange) / sizeof(FCharRange),
+            UpperCaseCharRange, ch));
+}
+
+unsigned int LowercaseP(FCh ch)
+{
+    return(CharRangeMemberP(sizeof(LowerCaseCharRange) / sizeof(FCharRange),
+            LowerCaseCharRange, ch));
+}
+
+inline int CharSetMemberP(FObject cset, FCh ch)
+{
+    return(CharRangeMemberP(NumRanges(cset), AsCharSet(cset)->Ranges, ch));
+}
+
+inline void CharSetArgCheck(const char * who, FObject obj)
+{
+    if (CharSetP(obj) == 0)
+        RaiseExceptionC(Assertion, who, "expected a character set", List(obj));
+}
+
+void WriteCharSet(FWriteContext * wctx, FObject obj)
+{
+    FCh s[16];
+    long_t sl = FixnumAsString((long_t) obj, s, 16);
+
+    wctx->WriteStringC("#<char-set: ");
+    wctx->WriteString(s, sl);
+    wctx->WriteCh('>');
+}
+
+// Test if cset1 is a subset of cset2.
+static int CharSetSubset(FObject cset1, FObject cset2)
+{
+    FAssert(ValidCharSet(cset1));
+    FAssert(ValidCharSet(cset2));
+
+    ulong_t nr1 = NumRanges(cset1);
+
+    if (nr1 == 0)
+        return(1); // empty char set is a subset of everything
+
+    FCharRange * r1 = AsCharSet(cset1)->Ranges;
+    FCharRange * r2 = AsCharSet(cset2)->Ranges;
+    ulong_t nr2 = NumRanges(cset2);
+    ulong_t ndx2 = 0;
+    for (ulong_t ndx1 = 0; ndx1 < nr1; ndx1++)
+    {
+        while (r1[ndx1].Start > r2[ndx2].End)
+        {
+            ndx2 += 1;
+            if (ndx2 == nr2)
+                return(0);
+        }
+
+        if (r1[ndx1].Start < r2[ndx2].Start || r1[ndx1].End > r2[ndx2].End)
+            return(0);
+    }
+
+    return(1);
+}
+
+static FObject CharSetUnion(FObject cset1, FObject cset2, const char * who)
+{
+    FAssert(ValidCharSet(cset1));
+    FAssert(ValidCharSet(cset2));
+
+    ulong_t nr1 = NumRanges(cset1);
+    ulong_t nr2 = NumRanges(cset2);
+
+    if (nr1 == 0)
+        return(cset2);
+    if (nr2 == 0)
+        return(cset1);
+
+    FCharRange * r = (FCharRange *) malloc(sizeof(FCharRange) * (nr1 + nr2));
+    if (r == 0)
+        RaiseExceptionC(Assertion, who, "out of memory", EmptyListObject);
+
+    FCharRange * r1 = AsCharSet(cset1)->Ranges;
+    FCharRange * r2 = AsCharSet(cset2)->Ranges;
+    ulong_t ndx1 = 0;
+    ulong_t ndx2 = 0;
+    ulong_t rl = 0;
+
+    if (r1[0].Start < r2[0].Start)
+    {
+        r[0] = r1[0];
+        ndx1 = 1;
+    }
+    else
+    {
+        r[0] = r2[0];
+        ndx2 = 1;
+    }
+
+    while (ndx1 < nr1 || ndx2 < nr2)
+    {
+        FCharRange chr;
+
+        if (ndx1 == nr1)
+        {
+            chr = r2[ndx2];
+            ndx2 += 1;
+        }
+        else if (ndx2 == nr2)
+        {
+            chr = r1[ndx1];
+            ndx1 += 1;
+        }
+        else if (r1[ndx1].Start < r2[ndx2].Start)
+        {
+            chr = r1[ndx1];
+            ndx1 += 1;
+        }
+        else
+        {
+            chr = r2[ndx2];
+            ndx2 += 1;
+        }
+
+        if (chr.Start <= r[rl].End)
+        {
+            if (chr.End > r[rl].End)
+                r[rl].End = chr.End;
+        }
+        else if (chr.Start > r[rl].End)
+        {
+            rl += 1;
+            r[rl] = chr;
+        }
+    }
+
+    FObject ret = MakeCharSet(rl + 1, r, who);
+    free(r);
+
+    FAssert(ValidCharSet(ret));
+
+    return(ret);
+}
+
+Define("char-set?", CharSetPPrimitive)(long_t argc, FObject argv[])
+{
+    OneArgCheck("char-set?", argc);
+
+    return(CharSetP(argv[0]) ? TrueObject : FalseObject);
+}
+
+Define("char-set=", CharSetEqualPrimitive)(long_t argc, FObject argv[])
+{
+    if (argc == 0)
+        return(TrueObject);
+
+    CharSetArgCheck("char-set=", argv[0]);
+
+    ulong_t nr = NumRanges(argv[0]);
+    for (long_t adx = 1; adx < argc; adx++)
+    {
+        CharSetArgCheck("char-set=", argv[adx]);
+
+        if (nr != NumRanges(argv[adx])
+            || memcmp(AsCharSet(argv[0])->Ranges, AsCharSet(argv[adx])->Ranges,
+                    nr * sizeof(FCharRange)) != 0)
+            return(FalseObject);
+    }
+
+    return(TrueObject);
+}
+
+Define("char-set<=", CharSetSubsetPrimitive)(long_t argc, FObject argv[])
+{
+    if (argc == 0)
+        return(TrueObject);
+
+    CharSetArgCheck("char-set<=", argv[0]);
+
+    for (long_t adx = 1; adx < argc; adx++)
+    {
+        CharSetArgCheck("char-set<=", argv[adx]);
+
+        if (CharSetSubset(argv[adx - 1], argv[adx]) == 0)
+            return(FalseObject);
+    }
+
+    return(TrueObject);
+}
+
+static uint32_t CharSetHash(FCharSet * cset)
+{
+    ulong_t sl = NumRanges(cset) * 2;
+    FCh * s = (FCh *) cset->Ranges;
+    uint32_t h = 0;
+
+    for (; sl > 0; s++, sl--)
+        h = ((h << 5) + h) + *s;
+
+    return(NormalizeHash(h));
+}
+
+Define("char-set-hash", CharSetHashPrimitive)(long_t argc, FObject argv[])
+{
+    OneOrTwoArgsCheck("char-set-hash", argc);
+    CharSetArgCheck("char-set-hash", argv[0]);
+
+    long_t bound = MAXIMUM_FIXNUM;
+    if (argc == 2)
+    {
+        FixnumArgCheck("char-set-hash", argv[1]);
+        if (AsFixnum(argv[1]) > 0)
+            bound = AsFixnum(argv[1]);
+    }
+
+    return(MakeFixnum(CharSetHash(AsCharSet(argv[0])) % bound));
+}
+
+Define("char-set-cursor", CharSetCursorPrimitive)(long_t argc, FObject argv[])
+{
+    OneArgCheck("char-set-cursor", argc);
+    CharSetArgCheck("char-set-cursor", argv[0]);
+
+    if (NumRanges(argv[0]) == 0)
+        return(FalseObject);
+
+    return(MakeCharacter(AsCharSet(argv[0])->Ranges[0].Start));
+}
+
+Define("char-set-cursor-next", CharSetCursorNextPrimitive)(long_t argc, FObject argv[])
+{
+    TwoArgsCheck("char-set-cursor-next", argc);
+    CharSetArgCheck("char-set-cursor-next", argv[0]);
+    CharacterArgCheck("char-set-cursor-next", argv[1]);
+
+    ulong_t nr = NumRanges(argv[0]);
+    FCharRange * r = AsCharSet(argv[0])->Ranges;
+    FCh ch = AsCharacter(argv[1]);
+    ulong_t ndx;
+    for (ndx = 0; ndx < nr; ndx++)
+    {
+        if (ch >= r[ndx].Start && ch <= r[ndx].End)
+        {
+            if (ch < r[ndx].End)
+                return(MakeCharacter(ch + 1));
+            if (ndx + 1 < nr)
+                return(MakeCharacter(r[ndx + 1].Start));
+            break;
+        }
+    }
+
+    return(FalseObject);
+}
+
+static int ChCmp(const void * p1, const void * p2)
+{
+    FCh ch1 = *((const FCh *) p1);
+    FCh ch2 = *((const FCh *) p2);
+
+    if (ch1 == ch2)
+        return(0);
+    if (ch1 < ch2)
+        return(-1);
+    return(1);
+}
+
+// WARNING: s will be modified
+static FObject StringToCharSet(ulong_t sl, FCh * s, const char * who)
+{
+    if (sl == 0)
+        return(EmptyCharSet);
+
+    FCharRange * r = (FCharRange *) malloc(sizeof(FCharRange) * sl);
+    if (r == 0)
+        RaiseExceptionC(Assertion, who, "out of memory", EmptyListObject);
+
+    qsort(s, sl, sizeof(FCh), ChCmp);
+
+    r[0].Start = s[0];
+    r[0].End = s[0];
+
+    ulong_t rl = 0;
+    for (ulong_t sdx = 1; sdx < sl; sdx++)
+    {
+        if (s[sdx] == r[rl].End + 1)
+            r[rl].End += 1;
+        else if (s[sdx] > r[rl].End)
+        {
+            rl += 1;
+            r[rl].Start = s[sdx];
+            r[rl].End = s[sdx];
+        }
+    }
+
+    FObject ret = MakeCharSet(rl + 1, r, who);
+    free(r);
+
+    FAssert(ValidCharSet(ret));
+
+    return(ret);
+}
+
+Define("list->char-set", ListToCharSetPrimitive)(long_t argc, FObject argv[])
+{
+    OneOrTwoArgsCheck("list->char-set", argc);
+
+    if (argc == 2)
+        CharSetArgCheck("list->char-set", argv[1]);
+
+    ulong_t sl = 0;
+    FObject lst = argv[0];
+    while (PairP(lst))
+    {
+        CharacterArgCheck("list->char-set", First(lst));
+
+        sl += 1;
+        lst = Rest(lst);
+    }
+
+    if (lst != EmptyListObject)
+        RaiseExceptionC(Assertion, "list->char-set", "expected a list", List(argv[0]));
+
+    if (sl == 0)
+        return(argc == 2 ? argv[1] : EmptyCharSet);
+
+    FCh * s = (FCh *) malloc(sizeof(FCh) * sl);
+    if (s == 0)
+        RaiseExceptionC(Assertion, "list->char-set", "out of memory", EmptyListObject);
+
+    lst = argv[0];
+    for (ulong_t sdx = 0; sdx < sl; sdx++)
+    {
+        s[sdx] = AsCharacter(First(lst));
+        lst = Rest(lst);
+    }
+
+    FObject ret = StringToCharSet(sl, s, "list->char-set");
+    free(s);
+
+    if (argc == 1)
+        return(ret);
+    return(CharSetUnion(ret, argv[1], "list->char-set"));
+}
+
+Define("string->char-set", StringToCharSetPrimitive)(long_t argc, FObject argv[])
+{
+    OneOrTwoArgsCheck("string->char-set", argc);
+    StringArgCheck("string->char-set", argv[0]);
+
+    if (argc == 2)
+        CharSetArgCheck("string->char-set", argv[1]);
+
+    ulong_t sl = StringLength(argv[0]);
+    if (sl == 0)
+        return(argc == 2 ? argv[1] : EmptyCharSet);
+
+    FCh * s = (FCh *) malloc(sizeof(FCh) * sl);
+    if (s == 0)
+        RaiseExceptionC(Assertion, "string->char-set", "out of memory", EmptyListObject);
+
+    memcpy(s, AsString(argv[0])->String, sizeof(FCh) * sl);
+
+    FObject ret = StringToCharSet(sl, s, "string->char-set");
+    free(s);
+
+    if (argc == 1)
+        return(ret);
+    return(CharSetUnion(ret, argv[1], "string->char-set"));
+}
+
+Define("ucs-range->char-set", UCSRangeToCharSetPrimitive)(long_t argc, FObject argv[])
+{
+    TwoToFourArgsCheck("ucs-range->char-set", argc);
+    FixnumArgCheck("ucs-range->char-set", argv[0]);
+    FixnumArgCheck("ucs-range->char-set", argv[1]);
+
+    FCh lower = AsFixnum(argv[0]);
+    FCh upper = AsFixnum(argv[1]);
+    FObject base = EmptyCharSet;
+
+    if (argc > 2)
+        BooleanArgCheck("ucs-range->char-set", argv[2]);
+
+    if (argc > 3)
+    {
+        CharSetArgCheck("ucs-range->char-set", argv[3]);
+        base = argv[3];
+    }
+
+    if (upper > 0x10FFFF)
+        upper = 0x10FFFF;
+    else
+        upper -= 1;
+    if (lower > upper)
+        lower = upper;
+    FCharRange r = {lower, upper};
+    return(CharSetUnion(MakeCharSet(1, &r, "ucs-range->char-set"), base, "ucs-range->char-set"));
+}
+
+Define("char-set-contains?", CharSetContainsPPrimitive)(long_t argc, FObject argv[])
+{
+    TwoArgsCheck("char-set-contains?", argc);
+    CharSetArgCheck("char-set-contains?", argv[0]);
+    CharacterArgCheck("char-set-contains?", argv[1]);
+
+    return(CharSetMemberP(argv[0], AsCharacter(argv[1])) ? TrueObject : FalseObject);
+}
+
+Define("char-set-complement", CharSetComplementPrimitive)(long_t argc, FObject argv[])
+{
+    OneArgCheck("char-set-complement", argc);
+    CharSetArgCheck("char-set-complement", argv[0]);
+
+    ulong_t nr = NumRanges(argv[0]);
+
+    if (nr == 0)
+        return(FullCharSet);
+
+    FCharRange * rg = (FCharRange *) malloc(sizeof(FCharRange) * (nr + 1));
+    if (rg == 0)
+        RaiseExceptionC(Assertion, "char-set-complement", "out of memory", EmptyListObject);
+
+    FCharRange * r = AsCharSet(argv[0])->Ranges;
+    ulong_t ndx = 0;
+    ulong_t rl = 0;
+    FCh strt = 0;
+
+    if (r[0].Start == 0)
+    {
+        strt = r[0].End + 1;
+        ndx = 1;
+    }
+
+    while (ndx < nr)
+    {
+        rg[rl].Start = strt;
+        rg[rl].End = r[ndx].Start - 1;
+        rl += 1;
+
+        strt = r[ndx].End + 1;
+        ndx += 1;
+    }
+
+    if (strt <= 0x10FFFF)
+    {
+        rg[rl].Start = strt;
+        rg[rl].End = 0x10FFFF;
+        rl += 1;
+    }
+
+    FObject ret = MakeCharSet(rl, rg, "char-set-complement");
+    free(rg);
+
+    FAssert(ValidCharSet(ret));
+
+    return(ret);
+}
+
+Define("char-set-union", CharSetUnionPrimitive)(long_t argc, FObject argv[])
+{
+    if (argc == 0)
+        return(EmptyCharSet);
+
+    FObject cset = EmptyCharSet;
+    for (long_t adx = 0; adx < argc; adx++)
+    {
+        CharSetArgCheck("char-set-union", argv[adx]);
+
+        cset = CharSetUnion(cset, argv[adx], "char-set-union");
+    }
+
+    return(cset);
+}
+
+Define("%char-set-intersection", CharSetIntersectionPrimitive)(long_t argc, FObject argv[])
+{
+    TwoArgsCheck("%char-set-intersection", argc);
+    CharSetArgCheck("%char-set-intersection", argv[0]);
+    CharSetArgCheck("%char-set-intersection", argv[1]);
+
+    ulong_t nr1 = NumRanges(argv[0]);
+    ulong_t nr2 = NumRanges(argv[1]);
+
+    if (nr1 == 0 || nr2 == 0)
+        return(EmptyCharSet);
+
+    FCharRange * r = (FCharRange *) malloc(sizeof(FCharRange) * (nr1 > nr2 ? nr1 : nr2));
+    if (r == 0)
+        RaiseExceptionC(Assertion, "%char-set-intersection", "out of memory", EmptyListObject);
+
+    FCharRange * r1 = AsCharSet(argv[0])->Ranges;
+    FCharRange * r2 = AsCharSet(argv[1])->Ranges;
+    ulong_t ndx1 = 0;
+    ulong_t ndx2 = 0;
+    ulong_t rl = 0;
+
+    while (ndx1 < nr1 && ndx2 < nr2)
+    {
+        if (r1[ndx1].End < r2[ndx2].Start)
+            ndx1 += 1;
+        else if (r1[ndx1].Start > r2[ndx2].End)
+            ndx2 += 1;
+        else if (r1[ndx1].Start < r2[ndx2].Start)
+        {
+            if (r1[ndx1].End < r2[ndx2].End)
+            {
+                FAssert(r1[ndx1].End >= r2[ndx2].Start);
+
+                r[rl].Start = r2[ndx2].Start;
+                r[rl].End = r1[ndx1].End;
+                rl += 1;
+
+                ndx1 += 1;
+            }
+            else
+            {
+                r[rl].Start = r2[ndx2].Start;
+                r[rl].End = r2[ndx2].End;
+                rl += 1;
+
+                ndx2 += 1;
+            }
+        }
+        else
+        {
+            if (r1[ndx1].End > r2[ndx2].End)
+            {
+                FAssert(r1[ndx1].Start <= r2[ndx2].End);
+
+                r[rl].Start = r1[ndx1].Start;
+                r[rl].End = r2[ndx2].End;
+                rl += 1;
+
+                ndx2 += 1;
+            }
+            else
+            {
+                r[rl].Start = r1[ndx1].Start;
+                r[rl].End = r1[ndx1].End;
+                rl += 1;
+
+                ndx1 += 1;
+            }
+        }
+    }
+
+    FObject ret = MakeCharSet(rl, r, "%char-set-intersection");
+    free(r);
+
+    FAssert(ValidCharSet(ret));
+
+    return(ret);
+}
+
+// ---- Standard CharSets ----
+
+static FCharRange AsciiCharRange[1] =
+{
+    {0, 127}
+};
+
+static FCharRange FullCharRange[2] =
+{
+    {0, 0xD7FF},
+    {0xE000, 0x10FFFF}
+};
+
+static FCharRange HexDigitCharRange[3] =
+{
+    {0x30, 0x39}, // 0 to 9
+    {0x41, 0x46}, // A to F
+    {0x61, 0x66}  // a to f
+};
+
+static FCharRange IsoControlCharRange[2] =
+{
+    {0, 0x1F},
+    {0x7F, 0x9F}
+};
+
+// ---- Primitives ----
+
+static FObject Primitives[] =
+{
+    CharSetPPrimitive,
+    CharSetEqualPrimitive,
+    CharSetSubsetPrimitive,
+    CharSetHashPrimitive,
+    CharSetCursorPrimitive,
+    CharSetCursorNextPrimitive,
+    ListToCharSetPrimitive,
+    StringToCharSetPrimitive,
+    UCSRangeToCharSetPrimitive,
+    CharSetContainsPPrimitive,
+    CharSetComplementPrimitive,
+    CharSetUnionPrimitive,
+    CharSetIntersectionPrimitive
+};
+
+static void StandardCharSet(const char * sym, FObject cset)
+{
+    FAssert(CharSetP(cset));
+    FAssert(ValidCharSet(cset));
+
+    LibraryExport(BedrockLibrary, EnvironmentSetC(Bedrock, sym, cset));
+}
+
+void SetupCharSets()
+{
+    RegisterRoot(&EmptyCharSet, "char-set:empty");
+    EmptyCharSet = MakeCharSet(0, 0, "char-set:empty");
+    StandardCharSet("char-set:empty", EmptyCharSet);
+
+    RegisterRoot(&FullCharSet, "char-set:full");
+    FullCharSet = MakeCharSet(sizeof(FullCharRange) / sizeof(FCharRange), FullCharRange,
+            "char-set:full");
+    StandardCharSet("char-set:full", FullCharSet);
+
+    StandardCharSet("char-set:ascii",
+            MakeCharSet(sizeof(AsciiCharRange) / sizeof(FCharRange), AsciiCharRange,
+                    "char-set:ascii"));
+
+    StandardCharSet("char-set:lower-case",
+            MakeCharSet(sizeof(LowerCaseCharRange) / sizeof(FCharRange), LowerCaseCharRange,
+                    "char-set:lower-case"));
+
+    StandardCharSet("char-set:upper-case",
+            MakeCharSet(sizeof(UpperCaseCharRange) / sizeof(FCharRange), UpperCaseCharRange,
+                    "char-set:upper-case"));
+
+    StandardCharSet("char-set:title-case",
+            MakeCharSet(sizeof(TitleCaseCharRange) / sizeof(FCharRange), TitleCaseCharRange,
+                    "char-set:title-case"));
+
+    StandardCharSet("char-set:letter",
+            MakeCharSet(sizeof(LetterCharRange) / sizeof(FCharRange), LetterCharRange,
+                    "char-set:letter"));
+
+    StandardCharSet("char-set:digit",
+            MakeCharSet(sizeof(DigitCharRange) / sizeof(FCharRange), DigitCharRange,
+                    "char-set:digit"));
+
+    StandardCharSet("char-set:hex-digit",
+            MakeCharSet(sizeof(HexDigitCharRange) / sizeof(FCharRange), HexDigitCharRange,
+                    "char-set:hex-digit"));
+
+    StandardCharSet("char-set:whitespace",
+            MakeCharSet(sizeof(WhitespaceCharRange) / sizeof(FCharRange), WhitespaceCharRange,
+                    "char-set:whitespace"));
+
+    StandardCharSet("char-set:iso-control",
+            MakeCharSet(sizeof(IsoControlCharRange) / sizeof(FCharRange), IsoControlCharRange,
+                    "char-set:iso-control"));
+
+    StandardCharSet("char-set:punctuation",
+            MakeCharSet(sizeof(PunctuationCharRange) / sizeof(FCharRange), PunctuationCharRange,
+                    "char-set:punctuation"));
+
+    StandardCharSet("char-set:symbol",
+            MakeCharSet(sizeof(SymbolCharRange) / sizeof(FCharRange), SymbolCharRange,
+                    "char-set:symbol"));
+
+    StandardCharSet("char-set:blank",
+            MakeCharSet(sizeof(BlankCharRange) / sizeof(FCharRange), BlankCharRange,
+                    "char-set:blank"));
+
+    for (ulong_t idx = 0; idx < sizeof(Primitives) / sizeof(FPrimitive *); idx++)
+        DefinePrimitive(Bedrock, BedrockLibrary, Primitives[idx]);
+}
diff --git a/src/foment.cpp b/src/foment.cpp
index c1bfa80..dfe324d 100644
--- a/src/foment.cpp
+++ b/src/foment.cpp
@@ -1396,6 +1396,7 @@ FIndirectType IndirectTypes[] =
     {"ephemeron", WriteEphemeron},
     {"builtin-type", WriteBuiltinType},
     {"builtin", WriteBuiltin},
+    {"char-set", WriteCharSet},
     {"free", 0}
 };
 
@@ -1500,6 +1501,7 @@ long_t SetupFoment(FThreadState * ts)
     SetupCharacters();
     SetupStrings();
     SetupVectors();
+    SetupCharSets();
     SetupIO();
     SetupFileSys();
     SetupCompile();
diff --git a/src/foment.hpp b/src/foment.hpp
index 64a166f..be0ada4 100644
--- a/src/foment.hpp
+++ b/src/foment.hpp
@@ -9,7 +9,6 @@ To Do:
 -- after partial GC, test for objects pointing to Babies
 
 Red Edition:
--- SRFI 14 (scheme charset)
 -- SRFI 41 (scheme stream)
 -- SRFI 101 (scheme rlist)
 -- SRFI 113 (scheme set)
@@ -225,6 +224,7 @@ typedef enum
     EphemeronTag,
     BuiltinTypeTag,
     BuiltinTag,
+    CharSetTag,
     FreeTag, // Only on Adult Generation
     BadDogTag // Invalid Tag
 } FIndirectTag;
@@ -1168,6 +1168,10 @@ inline long_t EphemeronBrokenP(FObject obj)
     return(AsEphemeron(obj)->Next == EPHEMERON_BROKEN);
 }
 
+// ---- Char Sets ----
+
+void WriteCharSet(FWriteContext * wctx, FObject obj);
+
 // ---- Roots ----
 
 void RegisterRoot(FObject * root, const char * name);
@@ -1930,6 +1934,7 @@ void SetupPairs();
 void SetupCharacters();
 void SetupStrings();
 void SetupVectors();
+void SetupCharSets();
 void SetupHashTables();
 void SetupCompare();
 void SetupIO();
diff --git a/src/gc.cpp b/src/gc.cpp
index 203633e..c051162 100644
--- a/src/gc.cpp
+++ b/src/gc.cpp
@@ -619,7 +619,8 @@ FObject MakeObject(ulong_t tag, ulong_t sz, ulong_t sc, const char * who, long_t
         RaiseException(Restriction, MakeObjectSymbol, NoValueObject, MakeStringC("object too big"),
                 EmptyListObject);
     if (sc > OBJHDR_MAXIMUM_SIZE)
-        RaiseException(Restriction, MakeObjectSymbol, NoValueObject, MakeStringC("too many slots"),            EmptyListObject);
+        RaiseException(Restriction, MakeObjectSymbol, NoValueObject, MakeStringC("too many slots"),
+                EmptyListObject);
 
     TagCounts[tag] += 1;
     if (tsz / OBJECT_ALIGNMENT < SIZE_COUNTS)
diff --git a/src/srfi-14.scm b/src/srfi-14.scm
new file mode 100644
index 0000000..6c58f5a
--- /dev/null
+++ b/src/srfi-14.scm
@@ -0,0 +1,198 @@
+(define-library (scheme charset)
+    (aka (srfi 14))
+    (import (foment base))
+    (export
+        char-set?
+        char-set=
+        char-set<=
+        char-set-hash
+        char-set-cursor
+        char-set-ref
+        char-set-cursor-next
+        end-of-char-set?
+        char-set-fold
+        char-set-unfold
+        char-set-unfold!
+        char-set-for-each
+        char-set-map
+        char-set-copy
+        char-set
+        list->char-set
+        string->char-set
+        list->char-set!
+        string->char-set!
+        char-set-filter
+        char-set-filter!
+        ucs-range->char-set
+        ucs-range->char-set!
+        ->char-set
+        char-set-size
+        char-set-count
+        char-set->list
+        char-set->string
+        char-set-contains?
+        char-set-every
+        char-set-any
+        char-set-adjoin
+        char-set-delete
+        (rename char-set-adjoin char-set-adjoin!)
+        (rename char-set-delete char-set-delete!)
+        char-set-complement
+        (rename char-set-complement char-set-complement!)
+        char-set-union
+        char-set-union!
+        char-set-intersection
+        char-set-intersection!
+        char-set-difference
+        (rename char-set-difference char-set-difference!)
+        char-set-xor
+        char-set-xor!
+        char-set-diff+intersection
+        char-set-diff+intersection!
+        char-set:lower-case
+        char-set:upper-case
+        char-set:title-case
+        char-set:letter
+        char-set:digit
+        char-set:letter+digit
+        char-set:graphic
+        char-set:printing
+        char-set:whitespace
+        char-set:iso-control
+        char-set:punctuation
+        char-set:symbol
+        char-set:hex-digit
+        char-set:blank
+        char-set:ascii
+        char-set:empty
+        char-set:full
+        )
+    (begin
+        (define (char-set-ref cset cursor)
+            cursor)
+        (define (end-of-char-set? cursor)
+            (not (char? cursor)))
+        (define (char-set-fold proc seed cset)
+            (define (fold cursor seed)
+                (if (end-of-char-set? cursor)
+                    seed
+                    (let ((ch (char-set-ref cset cursor)))
+                        (fold (char-set-cursor-next cset cursor) (proc ch seed)))))
+            (fold (char-set-cursor cset) seed))
+        (define char-set-unfold
+            (case-lambda
+                ((to-char pred gen seed) (char-set-unfold! to-char pred gen seed (char-set)))
+                ((to-char pred gen seed base) (char-set-unfold! to-char pred gen seed base))))
+        (define (char-set-unfold! to-char pred gen seed base)
+            (define (unfold seed lst)
+                (if (pred seed)
+                    lst
+                    (unfold (gen seed) (cons (to-char seed) lst))))
+            (list->char-set (unfold seed '()) base))
+        (define (char-set-for-each proc cset)
+            (for-each proc (char-set-fold cons '() cset)))
+        (define (char-set-map proc cset)
+            (list->char-set (map proc (char-set-fold cons '() cset))))
+        (define (char-set-copy cset)
+            cset)
+        (define (char-set . char-list)
+            (list->char-set char-list))
+        (define (list->char-set! char-list cset)
+            (list->char-set char-list cset))
+        (define (string->char-set! char-list cset)
+            (string->char-set char-list cset))
+        (define char-set-filter
+            (case-lambda
+                ((pred cset) (char-set-filter! pred cset (char-set)))
+                ((pred cset base) (char-set-filter! pred cset base))))
+        (define (char-set-filter! pred cset base)
+            (list->char-set
+                (char-set-fold (lambda (ch lst) (if (pred ch) (cons ch lst) lst)) '() cset)
+                base))
+        (define (->char-set obj)
+            (cond
+                ((string? obj) (string->char-set obj))
+                ((char? obj) (char-set obj))
+                ((char-set? obj) obj)
+                (else (full-error 'assertion-violation '->char-set #f
+                            "->char-set: expected a character, string, or char-set" obj))))
+        (define (ucs-range->char-set! lower upper error? base)
+            (ucs-range->char-set lower upper error? base))
+        (define (char-set-size cset)
+            (char-set-fold (lambda (ch cnt) (+ cnt 1)) 0 cset))
+        (define (char-set-count pred cset)
+            (char-set-fold (lambda (ch cnt) (if (pred ch) (+ cnt 1) cnt)) 0 cset))
+        (define (char-set->list cset)
+            (char-set-fold (lambda (ch lst) (cons ch lst)) '() cset))
+        (define (char-set->string cset)
+            (list->string (char-set->list cset)))
+        (define (char-set-every pred cset)
+            (define (every cursor)
+                (if (end-of-char-set? cursor)
+                    #t
+                    (if (pred (char-set-ref cset cursor))
+                        (every (char-set-cursor-next cset cursor))
+                        #f)))
+            (every (char-set-cursor cset)))
+        (define (char-set-any pred cset)
+            (define (any cursor)
+                (if (end-of-char-set? cursor)
+                    #f
+                    (or
+                        (pred (char-set-ref cset cursor))
+                        (any (char-set-cursor-next cset cursor)))))
+            (any (char-set-cursor cset)))
+        (define (char-set-adjoin cset . chars)
+            (list->char-set chars cset))
+        (define (char-set-delete cset . chars)
+            (let ((delete (list->char-set chars)))
+                (char-set-filter (lambda (ch) (not (char-set-contains? delete ch))) cset)))
+        (define (char-set-union! cset . csets)
+            (apply char-set-union cset csets))
+        (define char-set-intersection
+            (case-lambda
+                (() char-set:full)
+                ((cset) cset)
+                ((cset1 cset2) (%char-set-intersection cset1 cset2))
+                ((cset . csets) (%char-set-intersection cset (apply char-set-union csets)))))
+        (define char-set-intersection!
+            (case-lambda
+                ((cset) cset)
+                ((cset1 cset2) (%char-set-intersection cset1 cset2))
+                ((cset . csets) (%char-set-intersection cset (apply char-set-union csets)))))
+        (define char-set-difference
+            (case-lambda
+                ((cset) cset)
+                ((cset1 cset2) (%char-set-intersection cset1 (char-set-complement cset2)))
+                ((cset . csets)
+                    (%char-set-intersection cset
+                            (char-set-complement (apply char-set-union csets))))))
+        (define (%char-set-xor cset csets)
+            (if (null? csets)
+                cset
+                (%char-set-xor
+                    (char-set-union
+                        (%char-set-intersection cset (char-set-complement (car csets)))
+                        (%char-set-intersection (car csets) (char-set-complement cset)))
+                    (cdr csets))))
+        (define char-set-xor
+            (case-lambda
+                (() char-set:empty)
+                ((cset . csets) (%char-set-xor cset csets))))
+        (define (char-set-xor! cset . csets)
+            (%char-set-xor cset csets))
+        (define (char-set-diff+intersection cset . csets)
+            (values (%char-set-intersection cset (char-set-complement (apply char-set-union csets)))
+                (%char-set-intersection cset (apply char-set-union csets))))
+        (define (char-set-diff+intersection! cset1 cset2 . csets)
+            (values
+                (%char-set-intersection cset1
+                        (char-set-complement (apply char-set-union cset2 csets)))
+                (%char-set-intersection cset1 (apply char-set-union cset2 csets))))
+        (define char-set:letter+digit
+            (char-set-union char-set:letter char-set:digit))
+        (define char-set:graphic
+            (char-set-union char-set:letter char-set:digit char-set:punctuation char-set:symbol))
+        (define char-set:printing
+            (char-set-union char-set:graphic char-set:whitespace))
+    ))
diff --git a/src/unidata.hpp b/src/unicase.hpp
index 6847870..63a751d 100644
--- a/src/unidata.hpp
+++ b/src/unicase.hpp
@@ -515,12 +515,12 @@ static const FCh Upcase0x0061[] =
     0x018f, // 0x0259
     0x025a, // 0x025a
     0x0190, // 0x025b
-    0x025c, // 0x025c
+    0xa7ab, // 0x025c
     0x025d, // 0x025d
     0x025e, // 0x025e
     0x025f, // 0x025f
     0x0193, // 0x0260
-    0x0261, // 0x0261
+    0xa7ac, // 0x0261
     0x0262, // 0x0262
     0x0194, // 0x0263
     0x0264, // 0x0264
@@ -529,9 +529,9 @@ static const FCh Upcase0x0061[] =
     0x0267, // 0x0267
     0x0197, // 0x0268
     0x0196, // 0x0269
-    0x026a, // 0x026a
+    0xa7ae, // 0x026a
     0x2c62, // 0x026b
-    0x026c, // 0x026c
+    0xa7ad, // 0x026c
     0x026d, // 0x026d
     0x026e, // 0x026e
     0x019c, // 0x026f
@@ -553,12 +553,12 @@ static const FCh Upcase0x0061[] =
     0x027f, // 0x027f
     0x01a6, // 0x0280
     0x0281, // 0x0281
-    0x0282, // 0x0282
+    0xa7c5, // 0x0282
     0x01a9, // 0x0283
     0x0284, // 0x0284
     0x0285, // 0x0285
     0x0286, // 0x0286
-    0x0287, // 0x0287
+    0xa7b1, // 0x0287
     0x01ae, // 0x0288
     0x0244, // 0x0289
     0x01b1, // 0x028a
@@ -569,7 +569,19 @@ static const FCh Upcase0x0061[] =
     0x028f, // 0x028f
     0x0290, // 0x0290
     0x0291, // 0x0291
-    0x01b7  // 0x0292
+    0x01b7, // 0x0292
+    0x0293, // 0x0293
+    0x0294, // 0x0294
+    0x0295, // 0x0295
+    0x0296, // 0x0296
+    0x0297, // 0x0297
+    0x0298, // 0x0298
+    0x0299, // 0x0299
+    0x029a, // 0x029a
+    0x029b, // 0x029b
+    0x029c, // 0x029c
+    0xa7b2, // 0x029d
+    0xa7b0  // 0x029e
 };
 
 static const FCh Upcase0x0345[] =
@@ -748,7 +760,7 @@ static const FCh Upcase0x0345[] =
     0x039a, // 0x03f0
     0x03a1, // 0x03f1
     0x03f9, // 0x03f2
-    0x03f3, // 0x03f3
+    0x037f, // 0x03f3
     0x03f4, // 0x03f4
     0x0395, // 0x03f5
     0x03f6, // 0x03f6
@@ -1058,13 +1070,13 @@ static const FCh Upcase0x0345[] =
     0x0526, // 0x0526
     0x0526, // 0x0527
     0x0528, // 0x0528
-    0x0529, // 0x0529
+    0x0528, // 0x0529
     0x052a, // 0x052a
-    0x052b, // 0x052b
+    0x052a, // 0x052b
     0x052c, // 0x052c
-    0x052d, // 0x052d
+    0x052c, // 0x052d
     0x052e, // 0x052e
-    0x052f, // 0x052f
+    0x052e, // 0x052f
     0x0530, // 0x0530
     0x0531, // 0x0531
     0x0532, // 0x0532
@@ -1154,13 +1166,105 @@ static const FCh Upcase0x0345[] =
     0x0556  // 0x0586
 };
 
+static const FCh Upcase0x10d0[] =
+{
+    0x1c90, // 0x10d0
+    0x1c91, // 0x10d1
+    0x1c92, // 0x10d2
+    0x1c93, // 0x10d3
+    0x1c94, // 0x10d4
+    0x1c95, // 0x10d5
+    0x1c96, // 0x10d6
+    0x1c97, // 0x10d7
+    0x1c98, // 0x10d8
+    0x1c99, // 0x10d9
+    0x1c9a, // 0x10da
+    0x1c9b, // 0x10db
+    0x1c9c, // 0x10dc
+    0x1c9d, // 0x10dd
+    0x1c9e, // 0x10de
+    0x1c9f, // 0x10df
+    0x1ca0, // 0x10e0
+    0x1ca1, // 0x10e1
+    0x1ca2, // 0x10e2
+    0x1ca3, // 0x10e3
+    0x1ca4, // 0x10e4
+    0x1ca5, // 0x10e5
+    0x1ca6, // 0x10e6
+    0x1ca7, // 0x10e7
+    0x1ca8, // 0x10e8
+    0x1ca9, // 0x10e9
+    0x1caa, // 0x10ea
+    0x1cab, // 0x10eb
+    0x1cac, // 0x10ec
+    0x1cad, // 0x10ed
+    0x1cae, // 0x10ee
+    0x1caf, // 0x10ef
+    0x1cb0, // 0x10f0
+    0x1cb1, // 0x10f1
+    0x1cb2, // 0x10f2
+    0x1cb3, // 0x10f3
+    0x1cb4, // 0x10f4
+    0x1cb5, // 0x10f5
+    0x1cb6, // 0x10f6
+    0x1cb7, // 0x10f7
+    0x1cb8, // 0x10f8
+    0x1cb9, // 0x10f9
+    0x1cba, // 0x10fa
+    0x10fb, // 0x10fb
+    0x10fc, // 0x10fc
+    0x1cbd, // 0x10fd
+    0x1cbe, // 0x10fe
+    0x1cbf  // 0x10ff
+};
+
+static const FCh Upcase0x13f8[] =
+{
+    0x13f0, // 0x13f8
+    0x13f1, // 0x13f9
+    0x13f2, // 0x13fa
+    0x13f3, // 0x13fb
+    0x13f4, // 0x13fc
+    0x13f5  // 0x13fd
+};
+
+static const FCh Upcase0x1c80[] =
+{
+    0x0412, // 0x1c80
+    0x0414, // 0x1c81
+    0x041e, // 0x1c82
+    0x0421, // 0x1c83
+    0x0422, // 0x1c84
+    0x0422, // 0x1c85
+    0x042a, // 0x1c86
+    0x0462, // 0x1c87
+    0xa64a  // 0x1c88
+};
+
 static const FCh Upcase0x1d79[] =
 {
     0xa77d, // 0x1d79
     0x1d7a, // 0x1d7a
     0x1d7b, // 0x1d7b
     0x1d7c, // 0x1d7c
-    0x2c63  // 0x1d7d
+    0x2c63, // 0x1d7d
+    0x1d7e, // 0x1d7e
+    0x1d7f, // 0x1d7f
+    0x1d80, // 0x1d80
+    0x1d81, // 0x1d81
+    0x1d82, // 0x1d82
+    0x1d83, // 0x1d83
+    0x1d84, // 0x1d84
+    0x1d85, // 0x1d85
+    0x1d86, // 0x1d86
+    0x1d87, // 0x1d87
+    0x1d88, // 0x1d88
+    0x1d89, // 0x1d89
+    0x1d8a, // 0x1d8a
+    0x1d8b, // 0x1d8b
+    0x1d8c, // 0x1d8c
+    0x1d8d, // 0x1d8d
+    0xa7c6  // 0x1d8e
 };
 
 static const FCh Upcase0x1e01[] =
@@ -2101,7 +2205,11 @@ static const FCh Upcase0xa641[] =
     0xa694, // 0xa694
     0xa694, // 0xa695
     0xa696, // 0xa696
-    0xa696  // 0xa697
+    0xa696, // 0xa697
+    0xa698, // 0xa698
+    0xa698, // 0xa699
+    0xa69a, // 0xa69a
+    0xa69a  // 0xa69b
 };
 
 static const FCh Upcase0xa723[] =
@@ -2219,18 +2327,18 @@ static const FCh Upcase0xa723[] =
     0xa790, // 0xa791
     0xa792, // 0xa792
     0xa792, // 0xa793
-    0xa794, // 0xa794
+    0xa7c4, // 0xa794
     0xa795, // 0xa795
     0xa796, // 0xa796
-    0xa797, // 0xa797
+    0xa796, // 0xa797
     0xa798, // 0xa798
-    0xa799, // 0xa799
+    0xa798, // 0xa799
     0xa79a, // 0xa79a
-    0xa79b, // 0xa79b
+    0xa79a, // 0xa79b
     0xa79c, // 0xa79c
-    0xa79d, // 0xa79d
+    0xa79c, // 0xa79d
     0xa79e, // 0xa79e
-    0xa79f, // 0xa79f
+    0xa79e, // 0xa79f
     0xa7a0, // 0xa7a0
     0xa7a0, // 0xa7a1
     0xa7a2, // 0xa7a2
@@ -2240,7 +2348,146 @@ static const FCh Upcase0xa723[] =
     0xa7a6, // 0xa7a6
     0xa7a6, // 0xa7a7
     0xa7a8, // 0xa7a8
-    0xa7a8  // 0xa7a9
+    0xa7a8, // 0xa7a9
+    0xa7aa, // 0xa7aa
+    0xa7ab, // 0xa7ab
+    0xa7ac, // 0xa7ac
+    0xa7ad, // 0xa7ad
+    0xa7ae, // 0xa7ae
+    0xa7af, // 0xa7af
+    0xa7b0, // 0xa7b0
+    0xa7b1, // 0xa7b1
+    0xa7b2, // 0xa7b2
+    0xa7b3, // 0xa7b3
+    0xa7b4, // 0xa7b4
+    0xa7b4, // 0xa7b5
+    0xa7b6, // 0xa7b6
+    0xa7b6, // 0xa7b7
+    0xa7b8, // 0xa7b8
+    0xa7b8, // 0xa7b9
+    0xa7ba, // 0xa7ba
+    0xa7ba, // 0xa7bb
+    0xa7bc, // 0xa7bc
+    0xa7bc, // 0xa7bd
+    0xa7be, // 0xa7be
+    0xa7be, // 0xa7bf
+    0xa7c0, // 0xa7c0
+    0xa7c1, // 0xa7c1
+    0xa7c2, // 0xa7c2
+    0xa7c2  // 0xa7c3
+};
+
+static const FCh Upcase0xab53[] =
+{
+    0xa7b3, // 0xab53
+    0xab54, // 0xab54
+    0xab55, // 0xab55
+    0xab56, // 0xab56
+    0xab57, // 0xab57
+    0xab58, // 0xab58
+    0xab59, // 0xab59
+    0xab5a, // 0xab5a
+    0xab5b, // 0xab5b
+    0xab5c, // 0xab5c
+    0xab5d, // 0xab5d
+    0xab5e, // 0xab5e
+    0xab5f, // 0xab5f
+    0xab60, // 0xab60
+    0xab61, // 0xab61
+    0xab62, // 0xab62
+    0xab63, // 0xab63
+    0xab64, // 0xab64
+    0xab65, // 0xab65
+    0xab66, // 0xab66
+    0xab67, // 0xab67
+    0xab68, // 0xab68
+    0xab69, // 0xab69
+    0xab6a, // 0xab6a
+    0xab6b, // 0xab6b
+    0xab6c, // 0xab6c
+    0xab6d, // 0xab6d
+    0xab6e, // 0xab6e
+    0xab6f, // 0xab6f
+    0x13a0, // 0xab70
+    0x13a1, // 0xab71
+    0x13a2, // 0xab72
+    0x13a3, // 0xab73
+    0x13a4, // 0xab74
+    0x13a5, // 0xab75
+    0x13a6, // 0xab76
+    0x13a7, // 0xab77
+    0x13a8, // 0xab78
+    0x13a9, // 0xab79
+    0x13aa, // 0xab7a
+    0x13ab, // 0xab7b
+    0x13ac, // 0xab7c
+    0x13ad, // 0xab7d
+    0x13ae, // 0xab7e
+    0x13af, // 0xab7f
+    0x13b0, // 0xab80
+    0x13b1, // 0xab81
+    0x13b2, // 0xab82
+    0x13b3, // 0xab83
+    0x13b4, // 0xab84
+    0x13b5, // 0xab85
+    0x13b6, // 0xab86
+    0x13b7, // 0xab87
+    0x13b8, // 0xab88
+    0x13b9, // 0xab89
+    0x13ba, // 0xab8a
+    0x13bb, // 0xab8b
+    0x13bc, // 0xab8c
+    0x13bd, // 0xab8d
+    0x13be, // 0xab8e
+    0x13bf, // 0xab8f
+    0x13c0, // 0xab90
+    0x13c1, // 0xab91
+    0x13c2, // 0xab92
+    0x13c3, // 0xab93
+    0x13c4, // 0xab94
+    0x13c5, // 0xab95
+    0x13c6, // 0xab96
+    0x13c7, // 0xab97
+    0x13c8, // 0xab98
+    0x13c9, // 0xab99
+    0x13ca, // 0xab9a
+    0x13cb, // 0xab9b
+    0x13cc, // 0xab9c
+    0x13cd, // 0xab9d
+    0x13ce, // 0xab9e
+    0x13cf, // 0xab9f
+    0x13d0, // 0xaba0
+    0x13d1, // 0xaba1
+    0x13d2, // 0xaba2
+    0x13d3, // 0xaba3
+    0x13d4, // 0xaba4
+    0x13d5, // 0xaba5
+    0x13d6, // 0xaba6
+    0x13d7, // 0xaba7
+    0x13d8, // 0xaba8
+    0x13d9, // 0xaba9
+    0x13da, // 0xabaa
+    0x13db, // 0xabab
+    0x13dc, // 0xabac
+    0x13dd, // 0xabad
+    0x13de, // 0xabae
+    0x13df, // 0xabaf
+    0x13e0, // 0xabb0
+    0x13e1, // 0xabb1
+    0x13e2, // 0xabb2
+    0x13e3, // 0xabb3
+    0x13e4, // 0xabb4
+    0x13e5, // 0xabb5
+    0x13e6, // 0xabb6
+    0x13e7, // 0xabb7
+    0x13e8, // 0xabb8
+    0x13e9, // 0xabb9
+    0x13ea, // 0xabba
+    0x13eb, // 0xabbb
+    0x13ec, // 0xabbc
+    0x13ed, // 0xabbd
+    0x13ee, // 0xabbe
+    0x13ef  // 0xabbf
 };
 
 static const FCh Upcase0xff41[] =
@@ -2317,9 +2564,214 @@ static const FCh Upcase0x10428[] =
     0x10427  // 0x1044f
 };
 
+static const FCh Upcase0x104d8[] =
+{
+    0x104b0, // 0x104d8
+    0x104b1, // 0x104d9
+    0x104b2, // 0x104da
+    0x104b3, // 0x104db
+    0x104b4, // 0x104dc
+    0x104b5, // 0x104dd
+    0x104b6, // 0x104de
+    0x104b7, // 0x104df
+    0x104b8, // 0x104e0
+    0x104b9, // 0x104e1
+    0x104ba, // 0x104e2
+    0x104bb, // 0x104e3
+    0x104bc, // 0x104e4
+    0x104bd, // 0x104e5
+    0x104be, // 0x104e6
+    0x104bf, // 0x104e7
+    0x104c0, // 0x104e8
+    0x104c1, // 0x104e9
+    0x104c2, // 0x104ea
+    0x104c3, // 0x104eb
+    0x104c4, // 0x104ec
+    0x104c5, // 0x104ed
+    0x104c6, // 0x104ee
+    0x104c7, // 0x104ef
+    0x104c8, // 0x104f0
+    0x104c9, // 0x104f1
+    0x104ca, // 0x104f2
+    0x104cb, // 0x104f3
+    0x104cc, // 0x104f4
+    0x104cd, // 0x104f5
+    0x104ce, // 0x104f6
+    0x104cf, // 0x104f7
+    0x104d0, // 0x104f8
+    0x104d1, // 0x104f9
+    0x104d2, // 0x104fa
+    0x104d3  // 0x104fb
+};
+
+static const FCh Upcase0x10cc0[] =
+{
+    0x10c80, // 0x10cc0
+    0x10c81, // 0x10cc1
+    0x10c82, // 0x10cc2
+    0x10c83, // 0x10cc3
+    0x10c84, // 0x10cc4
+    0x10c85, // 0x10cc5
+    0x10c86, // 0x10cc6
+    0x10c87, // 0x10cc7
+    0x10c88, // 0x10cc8
+    0x10c89, // 0x10cc9
+    0x10c8a, // 0x10cca
+    0x10c8b, // 0x10ccb
+    0x10c8c, // 0x10ccc
+    0x10c8d, // 0x10ccd
+    0x10c8e, // 0x10cce
+    0x10c8f, // 0x10ccf
+    0x10c90, // 0x10cd0
+    0x10c91, // 0x10cd1
+    0x10c92, // 0x10cd2
+    0x10c93, // 0x10cd3
+    0x10c94, // 0x10cd4
+    0x10c95, // 0x10cd5
+    0x10c96, // 0x10cd6
+    0x10c97, // 0x10cd7
+    0x10c98, // 0x10cd8
+    0x10c99, // 0x10cd9
+    0x10c9a, // 0x10cda
+    0x10c9b, // 0x10cdb
+    0x10c9c, // 0x10cdc
+    0x10c9d, // 0x10cdd
+    0x10c9e, // 0x10cde
+    0x10c9f, // 0x10cdf
+    0x10ca0, // 0x10ce0
+    0x10ca1, // 0x10ce1
+    0x10ca2, // 0x10ce2
+    0x10ca3, // 0x10ce3
+    0x10ca4, // 0x10ce4
+    0x10ca5, // 0x10ce5
+    0x10ca6, // 0x10ce6
+    0x10ca7, // 0x10ce7
+    0x10ca8, // 0x10ce8
+    0x10ca9, // 0x10ce9
+    0x10caa, // 0x10cea
+    0x10cab, // 0x10ceb
+    0x10cac, // 0x10cec
+    0x10cad, // 0x10ced
+    0x10cae, // 0x10cee
+    0x10caf, // 0x10cef
+    0x10cb0, // 0x10cf0
+    0x10cb1, // 0x10cf1
+    0x10cb2  // 0x10cf2
+};
+
+static const FCh Upcase0x118c0[] =
+{
+    0x118a0, // 0x118c0
+    0x118a1, // 0x118c1
+    0x118a2, // 0x118c2
+    0x118a3, // 0x118c3
+    0x118a4, // 0x118c4
+    0x118a5, // 0x118c5
+    0x118a6, // 0x118c6
+    0x118a7, // 0x118c7
+    0x118a8, // 0x118c8
+    0x118a9, // 0x118c9
+    0x118aa, // 0x118ca
+    0x118ab, // 0x118cb
+    0x118ac, // 0x118cc
+    0x118ad, // 0x118cd
+    0x118ae, // 0x118ce
+    0x118af, // 0x118cf
+    0x118b0, // 0x118d0
+    0x118b1, // 0x118d1
+    0x118b2, // 0x118d2
+    0x118b3, // 0x118d3
+    0x118b4, // 0x118d4
+    0x118b5, // 0x118d5
+    0x118b6, // 0x118d6
+    0x118b7, // 0x118d7
+    0x118b8, // 0x118d8
+    0x118b9, // 0x118d9
+    0x118ba, // 0x118da
+    0x118bb, // 0x118db
+    0x118bc, // 0x118dc
+    0x118bd, // 0x118dd
+    0x118be, // 0x118de
+    0x118bf  // 0x118df
+};
+
+static const FCh Upcase0x16e60[] =
+{
+    0x16e40, // 0x16e60
+    0x16e41, // 0x16e61
+    0x16e42, // 0x16e62
+    0x16e43, // 0x16e63
+    0x16e44, // 0x16e64
+    0x16e45, // 0x16e65
+    0x16e46, // 0x16e66
+    0x16e47, // 0x16e67
+    0x16e48, // 0x16e68
+    0x16e49, // 0x16e69
+    0x16e4a, // 0x16e6a
+    0x16e4b, // 0x16e6b
+    0x16e4c, // 0x16e6c
+    0x16e4d, // 0x16e6d
+    0x16e4e, // 0x16e6e
+    0x16e4f, // 0x16e6f
+    0x16e50, // 0x16e70
+    0x16e51, // 0x16e71
+    0x16e52, // 0x16e72
+    0x16e53, // 0x16e73
+    0x16e54, // 0x16e74
+    0x16e55, // 0x16e75
+    0x16e56, // 0x16e76
+    0x16e57, // 0x16e77
+    0x16e58, // 0x16e78
+    0x16e59, // 0x16e79
+    0x16e5a, // 0x16e7a
+    0x16e5b, // 0x16e7b
+    0x16e5c, // 0x16e7c
+    0x16e5d, // 0x16e7d
+    0x16e5e, // 0x16e7e
+    0x16e5f  // 0x16e7f
+};
+
+static const FCh Upcase0x1e922[] =
+{
+    0x1e900, // 0x1e922
+    0x1e901, // 0x1e923
+    0x1e902, // 0x1e924
+    0x1e903, // 0x1e925
+    0x1e904, // 0x1e926
+    0x1e905, // 0x1e927
+    0x1e906, // 0x1e928
+    0x1e907, // 0x1e929
+    0x1e908, // 0x1e92a
+    0x1e909, // 0x1e92b
+    0x1e90a, // 0x1e92c
+    0x1e90b, // 0x1e92d
+    0x1e90c, // 0x1e92e
+    0x1e90d, // 0x1e92f
+    0x1e90e, // 0x1e930
+    0x1e90f, // 0x1e931
+    0x1e910, // 0x1e932
+    0x1e911, // 0x1e933
+    0x1e912, // 0x1e934
+    0x1e913, // 0x1e935
+    0x1e914, // 0x1e936
+    0x1e915, // 0x1e937
+    0x1e916, // 0x1e938
+    0x1e917, // 0x1e939
+    0x1e918, // 0x1e93a
+    0x1e919, // 0x1e93b
+    0x1e91a, // 0x1e93c
+    0x1e91b, // 0x1e93d
+    0x1e91c, // 0x1e93e
+    0x1e91d, // 0x1e93f
+    0x1e91e, // 0x1e940
+    0x1e91f, // 0x1e941
+    0x1e920, // 0x1e942
+    0x1e921  // 0x1e943
+};
+
 FCh CharUpcase(FCh ch)
 {
-    if (ch <= 0x0292)
+    if (ch <= 0x029e)
     {
         if (ch >= 0x0061)
             return(Upcase0x0061[ch - 0x0061]);
@@ -2331,7 +2783,25 @@ FCh CharUpcase(FCh ch)
             return(Upcase0x0345[ch - 0x0345]);
         return(ch);
     }
-    if (ch <= 0x1d7d)
+    if (ch <= 0x10ff)
+    {
+        if (ch >= 0x10d0)
+            return(Upcase0x10d0[ch - 0x10d0]);
+        return(ch);
+    }
+    if (ch <= 0x13fd)
+    {
+        if (ch >= 0x13f8)
+            return(Upcase0x13f8[ch - 0x13f8]);
+        return(ch);
+    }
+    if (ch <= 0x1c88)
+    {
+        if (ch >= 0x1c80)
+            return(Upcase0x1c80[ch - 0x1c80]);
+        return(ch);
+    }
+    if (ch <= 0x1d8e)
     {
         if (ch >= 0x1d79)
             return(Upcase0x1d79[ch - 0x1d79]);
@@ -2361,18 +2831,24 @@ FCh CharUpcase(FCh ch)
             return(Upcase0x2c30[ch - 0x2c30]);
         return(ch);
     }
-    if (ch <= 0xa697)
+    if (ch <= 0xa69b)
     {
         if (ch >= 0xa641)
             return(Upcase0xa641[ch - 0xa641]);
         return(ch);
     }
-    if (ch <= 0xa7a9)
+    if (ch <= 0xa7c3)
     {
         if (ch >= 0xa723)
             return(Upcase0xa723[ch - 0xa723]);
         return(ch);
     }
+    if (ch <= 0xabbf)
+    {
+        if (ch >= 0xab53)
+            return(Upcase0xab53[ch - 0xab53]);
+        return(ch);
+    }
     if (ch <= 0xff5a)
     {
         if (ch >= 0xff41)
@@ -2385,6 +2861,36 @@ FCh CharUpcase(FCh ch)
             return(Upcase0x10428[ch - 0x10428]);
         return(ch);
     }
+    if (ch <= 0x104fb)
+    {
+        if (ch >= 0x104d8)
+            return(Upcase0x104d8[ch - 0x104d8]);
+        return(ch);
+    }
+    if (ch <= 0x10cf2)
+    {
+        if (ch >= 0x10cc0)
+            return(Upcase0x10cc0[ch - 0x10cc0]);
+        return(ch);
+    }
+    if (ch <= 0x118df)
+    {
+        if (ch >= 0x118c0)
+            return(Upcase0x118c0[ch - 0x118c0]);
+        return(ch);
+    }
+    if (ch <= 0x16e7f)
+    {
+        if (ch >= 0x16e60)
+            return(Upcase0x16e60[ch - 0x16e60]);
+        return(ch);
+    }
+    if (ch <= 0x1e943)
+    {
+        if (ch >= 0x1e922)
+            return(Upcase0x1e922[ch - 0x1e922]);
+        return(ch);
+    }
     return(ch);
 }
 
@@ -2838,7 +3344,7 @@ static const FCh Downcase0x0370[] =
     0x037c, // 0x037c
     0x037d, // 0x037d
     0x037e, // 0x037e
-    0x037f, // 0x037f
+    0x03f3, // 0x037f
     0x0380, // 0x0380
     0x0381, // 0x0381
     0x0382, // 0x0382
@@ -3263,13 +3769,13 @@ static const FCh Downcase0x0370[] =
     0x0525, // 0x0525
     0x0527, // 0x0526
     0x0527, // 0x0527
-    0x0528, // 0x0528
+    0x0529, // 0x0528
     0x0529, // 0x0529
-    0x052a, // 0x052a
+    0x052b, // 0x052a
     0x052b, // 0x052b
-    0x052c, // 0x052c
+    0x052d, // 0x052c
     0x052d, // 0x052d
-    0x052e, // 0x052e
+    0x052f, // 0x052e
     0x052f, // 0x052f
     0x0530, // 0x0530
     0x0561, // 0x0531
@@ -3362,6 +3868,148 @@ static const FCh Downcase0x10a0[] =
     0x2d2d  // 0x10cd
 };
 
+static const FCh Downcase0x13a0[] =
+{
+    0xab70, // 0x13a0
+    0xab71, // 0x13a1
+    0xab72, // 0x13a2
+    0xab73, // 0x13a3
+    0xab74, // 0x13a4
+    0xab75, // 0x13a5
+    0xab76, // 0x13a6
+    0xab77, // 0x13a7
+    0xab78, // 0x13a8
+    0xab79, // 0x13a9
+    0xab7a, // 0x13aa
+    0xab7b, // 0x13ab
+    0xab7c, // 0x13ac
+    0xab7d, // 0x13ad
+    0xab7e, // 0x13ae
+    0xab7f, // 0x13af
+    0xab80, // 0x13b0
+    0xab81, // 0x13b1
+    0xab82, // 0x13b2
+    0xab83, // 0x13b3
+    0xab84, // 0x13b4
+    0xab85, // 0x13b5
+    0xab86, // 0x13b6
+    0xab87, // 0x13b7
+    0xab88, // 0x13b8
+    0xab89, // 0x13b9
+    0xab8a, // 0x13ba
+    0xab8b, // 0x13bb
+    0xab8c, // 0x13bc
+    0xab8d, // 0x13bd
+    0xab8e, // 0x13be
+    0xab8f, // 0x13bf
+    0xab90, // 0x13c0
+    0xab91, // 0x13c1
+    0xab92, // 0x13c2
+    0xab93, // 0x13c3
+    0xab94, // 0x13c4
+    0xab95, // 0x13c5
+    0xab96, // 0x13c6
+    0xab97, // 0x13c7
+    0xab98, // 0x13c8
+    0xab99, // 0x13c9
+    0xab9a, // 0x13ca
+    0xab9b, // 0x13cb
+    0xab9c, // 0x13cc
+    0xab9d, // 0x13cd
+    0xab9e, // 0x13ce
+    0xab9f, // 0x13cf
+    0xaba0, // 0x13d0
+    0xaba1, // 0x13d1
+    0xaba2, // 0x13d2
+    0xaba3, // 0x13d3
+    0xaba4, // 0x13d4
+    0xaba5, // 0x13d5
+    0xaba6, // 0x13d6
+    0xaba7, // 0x13d7
+    0xaba8, // 0x13d8
+    0xaba9, // 0x13d9
+    0xabaa, // 0x13da
+    0xabab, // 0x13db
+    0xabac, // 0x13dc
+    0xabad, // 0x13dd
+    0xabae, // 0x13de
+    0xabaf, // 0x13df
+    0xabb0, // 0x13e0
+    0xabb1, // 0x13e1
+    0xabb2, // 0x13e2
+    0xabb3, // 0x13e3
+    0xabb4, // 0x13e4
+    0xabb5, // 0x13e5
+    0xabb6, // 0x13e6
+    0xabb7, // 0x13e7
+    0xabb8, // 0x13e8
+    0xabb9, // 0x13e9
+    0xabba, // 0x13ea
+    0xabbb, // 0x13eb
+    0xabbc, // 0x13ec
+    0xabbd, // 0x13ed
+    0xabbe, // 0x13ee
+    0xabbf, // 0x13ef
+    0x13f8, // 0x13f0
+    0x13f9, // 0x13f1
+    0x13fa, // 0x13f2
+    0x13fb, // 0x13f3
+    0x13fc, // 0x13f4
+    0x13fd  // 0x13f5
+};
+
+static const FCh Downcase0x1c90[] =
+{
+    0x10d0, // 0x1c90
+    0x10d1, // 0x1c91
+    0x10d2, // 0x1c92
+    0x10d3, // 0x1c93
+    0x10d4, // 0x1c94
+    0x10d5, // 0x1c95
+    0x10d6, // 0x1c96
+    0x10d7, // 0x1c97
+    0x10d8, // 0x1c98
+    0x10d9, // 0x1c99
+    0x10da, // 0x1c9a
+    0x10db, // 0x1c9b
+    0x10dc, // 0x1c9c
+    0x10dd, // 0x1c9d
+    0x10de, // 0x1c9e
+    0x10df, // 0x1c9f
+    0x10e0, // 0x1ca0
+    0x10e1, // 0x1ca1
+    0x10e2, // 0x1ca2
+    0x10e3, // 0x1ca3
+    0x10e4, // 0x1ca4
+    0x10e5, // 0x1ca5
+    0x10e6, // 0x1ca6
+    0x10e7, // 0x1ca7
+    0x10e8, // 0x1ca8
+    0x10e9, // 0x1ca9
+    0x10ea, // 0x1caa
+    0x10eb, // 0x1cab
+    0x10ec, // 0x1cac
+    0x10ed, // 0x1cad
+    0x10ee, // 0x1cae
+    0x10ef, // 0x1caf
+    0x10f0, // 0x1cb0
+    0x10f1, // 0x1cb1
+    0x10f2, // 0x1cb2
+    0x10f3, // 0x1cb3
+    0x10f4, // 0x1cb4
+    0x10f5, // 0x1cb5
+    0x10f6, // 0x1cb6
+    0x10f7, // 0x1cb7
+    0x10f8, // 0x1cb8
+    0x10f9, // 0x1cb9
+    0x10fa, // 0x1cba
+    0x1cbb, // 0x1cbb
+    0x1cbc, // 0x1cbc
+    0x10fd, // 0x1cbd
+    0x10fe, // 0x1cbe
+    0x10ff  // 0x1cbf
+};
+
 static const FCh Downcase0x1e00[] =
 {
     0x1e01, // 0x1e00
@@ -4338,7 +4986,11 @@ static const FCh Downcase0xa640[] =
     0xa693, // 0xa693
     0xa695, // 0xa694
     0xa695, // 0xa695
-    0xa697  // 0xa696
+    0xa697, // 0xa696
+    0xa697, // 0xa697
+    0xa699, // 0xa698
+    0xa699, // 0xa699
+    0xa69b  // 0xa69a
 };
 
 static const FCh Downcase0xa722[] =
@@ -4459,15 +5111,15 @@ static const FCh Downcase0xa722[] =
     0xa793, // 0xa793
     0xa794, // 0xa794
     0xa795, // 0xa795
-    0xa796, // 0xa796
+    0xa797, // 0xa796
     0xa797, // 0xa797
-    0xa798, // 0xa798
+    0xa799, // 0xa798
     0xa799, // 0xa799
-    0xa79a, // 0xa79a
+    0xa79b, // 0xa79a
     0xa79b, // 0xa79b
-    0xa79c, // 0xa79c
+    0xa79d, // 0xa79c
     0xa79d, // 0xa79d
-    0xa79e, // 0xa79e
+    0xa79f, // 0xa79e
     0xa79f, // 0xa79f
     0xa7a1, // 0xa7a0
     0xa7a1, // 0xa7a1
@@ -4479,7 +5131,35 @@ static const FCh Downcase0xa722[] =
     0xa7a7, // 0xa7a7
     0xa7a9, // 0xa7a8
     0xa7a9, // 0xa7a9
-    0x0266  // 0xa7aa
+    0x0266, // 0xa7aa
+    0x025c, // 0xa7ab
+    0x0261, // 0xa7ac
+    0x026c, // 0xa7ad
+    0x026a, // 0xa7ae
+    0xa7af, // 0xa7af
+    0x029e, // 0xa7b0
+    0x0287, // 0xa7b1
+    0x029d, // 0xa7b2
+    0xab53, // 0xa7b3
+    0xa7b5, // 0xa7b4
+    0xa7b5, // 0xa7b5
+    0xa7b7, // 0xa7b6
+    0xa7b7, // 0xa7b7
+    0xa7b9, // 0xa7b8
+    0xa7b9, // 0xa7b9
+    0xa7bb, // 0xa7ba
+    0xa7bb, // 0xa7bb
+    0xa7bd, // 0xa7bc
+    0xa7bd, // 0xa7bd
+    0xa7bf, // 0xa7be
+    0xa7bf, // 0xa7bf
+    0xa7c0, // 0xa7c0
+    0xa7c1, // 0xa7c1
+    0xa7c3, // 0xa7c2
+    0xa7c3, // 0xa7c3
+    0xa794, // 0xa7c4
+    0x0282, // 0xa7c5
+    0x1d8e  // 0xa7c6
 };
 
 static const FCh Downcase0xff21[] =
@@ -4556,6 +5236,211 @@ static const FCh Downcase0x10400[] =
     0x1044f  // 0x10427
 };
 
+static const FCh Downcase0x104b0[] =
+{
+    0x104d8, // 0x104b0
+    0x104d9, // 0x104b1
+    0x104da, // 0x104b2
+    0x104db, // 0x104b3
+    0x104dc, // 0x104b4
+    0x104dd, // 0x104b5
+    0x104de, // 0x104b6
+    0x104df, // 0x104b7
+    0x104e0, // 0x104b8
+    0x104e1, // 0x104b9
+    0x104e2, // 0x104ba
+    0x104e3, // 0x104bb
+    0x104e4, // 0x104bc
+    0x104e5, // 0x104bd
+    0x104e6, // 0x104be
+    0x104e7, // 0x104bf
+    0x104e8, // 0x104c0
+    0x104e9, // 0x104c1
+    0x104ea, // 0x104c2
+    0x104eb, // 0x104c3
+    0x104ec, // 0x104c4
+    0x104ed, // 0x104c5
+    0x104ee, // 0x104c6
+    0x104ef, // 0x104c7
+    0x104f0, // 0x104c8
+    0x104f1, // 0x104c9
+    0x104f2, // 0x104ca
+    0x104f3, // 0x104cb
+    0x104f4, // 0x104cc
+    0x104f5, // 0x104cd
+    0x104f6, // 0x104ce
+    0x104f7, // 0x104cf
+    0x104f8, // 0x104d0
+    0x104f9, // 0x104d1
+    0x104fa, // 0x104d2
+    0x104fb  // 0x104d3
+};
+
+static const FCh Downcase0x10c80[] =
+{
+    0x10cc0, // 0x10c80
+    0x10cc1, // 0x10c81
+    0x10cc2, // 0x10c82
+    0x10cc3, // 0x10c83
+    0x10cc4, // 0x10c84
+    0x10cc5, // 0x10c85
+    0x10cc6, // 0x10c86
+    0x10cc7, // 0x10c87
+    0x10cc8, // 0x10c88
+    0x10cc9, // 0x10c89
+    0x10cca, // 0x10c8a
+    0x10ccb, // 0x10c8b
+    0x10ccc, // 0x10c8c
+    0x10ccd, // 0x10c8d
+    0x10cce, // 0x10c8e
+    0x10ccf, // 0x10c8f
+    0x10cd0, // 0x10c90
+    0x10cd1, // 0x10c91
+    0x10cd2, // 0x10c92
+    0x10cd3, // 0x10c93
+    0x10cd4, // 0x10c94
+    0x10cd5, // 0x10c95
+    0x10cd6, // 0x10c96
+    0x10cd7, // 0x10c97
+    0x10cd8, // 0x10c98
+    0x10cd9, // 0x10c99
+    0x10cda, // 0x10c9a
+    0x10cdb, // 0x10c9b
+    0x10cdc, // 0x10c9c
+    0x10cdd, // 0x10c9d
+    0x10cde, // 0x10c9e
+    0x10cdf, // 0x10c9f
+    0x10ce0, // 0x10ca0
+    0x10ce1, // 0x10ca1
+    0x10ce2, // 0x10ca2
+    0x10ce3, // 0x10ca3
+    0x10ce4, // 0x10ca4
+    0x10ce5, // 0x10ca5
+    0x10ce6, // 0x10ca6
+    0x10ce7, // 0x10ca7
+    0x10ce8, // 0x10ca8
+    0x10ce9, // 0x10ca9
+    0x10cea, // 0x10caa
+    0x10ceb, // 0x10cab
+    0x10cec, // 0x10cac
+    0x10ced, // 0x10cad
+    0x10cee, // 0x10cae
+    0x10cef, // 0x10caf
+    0x10cf0, // 0x10cb0
+    0x10cf1, // 0x10cb1
+    0x10cf2  // 0x10cb2
+};
+
+static const FCh Downcase0x118a0[] =
+{
+    0x118c0, // 0x118a0
+    0x118c1, // 0x118a1
+    0x118c2, // 0x118a2
+    0x118c3, // 0x118a3
+    0x118c4, // 0x118a4
+    0x118c5, // 0x118a5
+    0x118c6, // 0x118a6
+    0x118c7, // 0x118a7
+    0x118c8, // 0x118a8
+    0x118c9, // 0x118a9
+    0x118ca, // 0x118aa
+    0x118cb, // 0x118ab
+    0x118cc, // 0x118ac
+    0x118cd, // 0x118ad
+    0x118ce, // 0x118ae
+    0x118cf, // 0x118af
+    0x118d0, // 0x118b0
+    0x118d1, // 0x118b1
+    0x118d2, // 0x118b2
+    0x118d3, // 0x118b3
+    0x118d4, // 0x118b4
+    0x118d5, // 0x118b5
+    0x118d6, // 0x118b6
+    0x118d7, // 0x118b7
+    0x118d8, // 0x118b8
+    0x118d9, // 0x118b9
+    0x118da, // 0x118ba
+    0x118db, // 0x118bb
+    0x118dc, // 0x118bc
+    0x118dd, // 0x118bd
+    0x118de, // 0x118be
+    0x118df  // 0x118bf
+};
+
+static const FCh Downcase0x16e40[] =
+{
+    0x16e60, // 0x16e40
+    0x16e61, // 0x16e41
+    0x16e62, // 0x16e42
+    0x16e63, // 0x16e43
+    0x16e64, // 0x16e44
+    0x16e65, // 0x16e45
+    0x16e66, // 0x16e46
+    0x16e67, // 0x16e47
+    0x16e68, // 0x16e48
+    0x16e69, // 0x16e49
+    0x16e6a, // 0x16e4a
+    0x16e6b, // 0x16e4b
+    0x16e6c, // 0x16e4c
+    0x16e6d, // 0x16e4d
+    0x16e6e, // 0x16e4e
+    0x16e6f, // 0x16e4f
+    0x16e70, // 0x16e50
+    0x16e71, // 0x16e51
+    0x16e72, // 0x16e52
+    0x16e73, // 0x16e53
+    0x16e74, // 0x16e54
+    0x16e75, // 0x16e55
+    0x16e76, // 0x16e56
+    0x16e77, // 0x16e57
+    0x16e78, // 0x16e58
+    0x16e79, // 0x16e59
+    0x16e7a, // 0x16e5a
+    0x16e7b, // 0x16e5b
+    0x16e7c, // 0x16e5c
+    0x16e7d, // 0x16e5d
+    0x16e7e, // 0x16e5e
+    0x16e7f  // 0x16e5f
+};
+
+static const FCh Downcase0x1e900[] =
+{
+    0x1e922, // 0x1e900
+    0x1e923, // 0x1e901
+    0x1e924, // 0x1e902
+    0x1e925, // 0x1e903
+    0x1e926, // 0x1e904
+    0x1e927, // 0x1e905
+    0x1e928, // 0x1e906
+    0x1e929, // 0x1e907
+    0x1e92a, // 0x1e908
+    0x1e92b, // 0x1e909
+    0x1e92c, // 0x1e90a
+    0x1e92d, // 0x1e90b
+    0x1e92e, // 0x1e90c
+    0x1e92f, // 0x1e90d
+    0x1e930, // 0x1e90e
+    0x1e931, // 0x1e90f
+    0x1e932, // 0x1e910
+    0x1e933, // 0x1e911
+    0x1e934, // 0x1e912
+    0x1e935, // 0x1e913
+    0x1e936, // 0x1e914
+    0x1e937, // 0x1e915
+    0x1e938, // 0x1e916
+    0x1e939, // 0x1e917
+    0x1e93a, // 0x1e918
+    0x1e93b, // 0x1e919
+    0x1e93c, // 0x1e91a
+    0x1e93d, // 0x1e91b
+    0x1e93e, // 0x1e91c
+    0x1e93f, // 0x1e91d
+    0x1e940, // 0x1e91e
+    0x1e941, // 0x1e91f
+    0x1e942, // 0x1e920
+    0x1e943  // 0x1e921
+};
+
 FCh CharDowncase(FCh ch)
 {
     if (ch <= 0x005a)
@@ -4582,6 +5467,18 @@ FCh CharDowncase(FCh ch)
             return(Downcase0x10a0[ch - 0x10a0]);
         return(ch);
     }
+    if (ch <= 0x13f5)
+    {
+        if (ch >= 0x13a0)
+            return(Downcase0x13a0[ch - 0x13a0]);
+        return(ch);
+    }
+    if (ch <= 0x1cbf)
+    {
+        if (ch >= 0x1c90)
+            return(Downcase0x1c90[ch - 0x1c90]);
+        return(ch);
+    }
     if (ch <= 0x1ffc)
     {
         if (ch >= 0x1e00)
@@ -4606,13 +5503,13 @@ FCh CharDowncase(FCh ch)
             return(Downcase0x2c00[ch - 0x2c00]);
         return(ch);
     }
-    if (ch <= 0xa696)
+    if (ch <= 0xa69a)
     {
         if (ch >= 0xa640)
             return(Downcase0xa640[ch - 0xa640]);
         return(ch);
     }
-    if (ch <= 0xa7aa)
+    if (ch <= 0xa7c6)
     {
         if (ch >= 0xa722)
             return(Downcase0xa722[ch - 0xa722]);
@@ -4630,6 +5527,36 @@ FCh CharDowncase(FCh ch)
             return(Downcase0x10400[ch - 0x10400]);
         return(ch);
     }
+    if (ch <= 0x104d3)
+    {
+        if (ch >= 0x104b0)
+            return(Downcase0x104b0[ch - 0x104b0]);
+        return(ch);
+    }
+    if (ch <= 0x10cb2)
+    {
+        if (ch >= 0x10c80)
+            return(Downcase0x10c80[ch - 0x10c80]);
+        return(ch);
+    }
+    if (ch <= 0x118bf)
+    {
+        if (ch >= 0x118a0)
+            return(Downcase0x118a0[ch - 0x118a0]);
+        return(ch);
+    }
+    if (ch <= 0x16e5f)
+    {
+        if (ch >= 0x16e40)
+            return(Downcase0x16e40[ch - 0x16e40]);
+        return(ch);
+    }
+    if (ch <= 0x1e921)
+    {
+        if (ch >= 0x1e900)
+            return(Downcase0x1e900[ch - 0x1e900]);
+        return(ch);
+    }
     return(ch);
 }
 
@@ -5137,7 +6064,7 @@ static const FCh Foldcase0x0345[] =
     0x037c, // 0x037c
     0x037d, // 0x037d
     0x037e, // 0x037e
-    0x037f, // 0x037f
+    0x03f3, // 0x037f
     0x0380, // 0x0380
     0x0381, // 0x0381
     0x0382, // 0x0382
@@ -5562,13 +6489,13 @@ static const FCh Foldcase0x0345[] =
     0x0525, // 0x0525
     0x0527, // 0x0526
     0x0527, // 0x0527
-    0x0528, // 0x0528
+    0x0529, // 0x0528
     0x0529, // 0x0529
-    0x052a, // 0x052a
+    0x052b, // 0x052a
     0x052b, // 0x052b
-    0x052c, // 0x052c
+    0x052d, // 0x052c
     0x052d, // 0x052d
-    0x052e, // 0x052e
+    0x052f, // 0x052e
     0x052f, // 0x052f
     0x0530, // 0x0530
     0x0561, // 0x0531
@@ -5661,6 +6588,84 @@ static const FCh Foldcase0x10a0[] =
     0x2d2d  // 0x10cd
 };
 
+static const FCh Foldcase0x13f8[] =
+{
+    0x13f0, // 0x13f8
+    0x13f1, // 0x13f9
+    0x13f2, // 0x13fa
+    0x13f3, // 0x13fb
+    0x13f4, // 0x13fc
+    0x13f5  // 0x13fd
+};
+
+static const FCh Foldcase0x1c80[] =
+{
+    0x0432, // 0x1c80
+    0x0434, // 0x1c81
+    0x043e, // 0x1c82
+    0x0441, // 0x1c83
+    0x0442, // 0x1c84
+    0x0442, // 0x1c85
+    0x044a, // 0x1c86
+    0x0463, // 0x1c87
+    0xa64b, // 0x1c88
+    0x1c89, // 0x1c89
+    0x1c8a, // 0x1c8a
+    0x1c8b, // 0x1c8b
+    0x1c8c, // 0x1c8c
+    0x1c8d, // 0x1c8d
+    0x1c8e, // 0x1c8e
+    0x1c8f, // 0x1c8f
+    0x10d0, // 0x1c90
+    0x10d1, // 0x1c91
+    0x10d2, // 0x1c92
+    0x10d3, // 0x1c93
+    0x10d4, // 0x1c94
+    0x10d5, // 0x1c95
+    0x10d6, // 0x1c96
+    0x10d7, // 0x1c97
+    0x10d8, // 0x1c98
+    0x10d9, // 0x1c99
+    0x10da, // 0x1c9a
+    0x10db, // 0x1c9b
+    0x10dc, // 0x1c9c
+    0x10dd, // 0x1c9d
+    0x10de, // 0x1c9e
+    0x10df, // 0x1c9f
+    0x10e0, // 0x1ca0
+    0x10e1, // 0x1ca1
+    0x10e2, // 0x1ca2
+    0x10e3, // 0x1ca3
+    0x10e4, // 0x1ca4
+    0x10e5, // 0x1ca5
+    0x10e6, // 0x1ca6
+    0x10e7, // 0x1ca7
+    0x10e8, // 0x1ca8
+    0x10e9, // 0x1ca9
+    0x10ea, // 0x1caa
+    0x10eb, // 0x1cab
+    0x10ec, // 0x1cac
+    0x10ed, // 0x1cad
+    0x10ee, // 0x1cae
+    0x10ef, // 0x1caf
+    0x10f0, // 0x1cb0
+    0x10f1, // 0x1cb1
+    0x10f2, // 0x1cb2
+    0x10f3, // 0x1cb3
+    0x10f4, // 0x1cb4
+    0x10f5, // 0x1cb5
+    0x10f6, // 0x1cb6
+    0x10f7, // 0x1cb7
+    0x10f8, // 0x1cb8
+    0x10f9, // 0x1cb9
+    0x10fa, // 0x1cba
+    0x1cbb, // 0x1cbb
+    0x1cbc, // 0x1cbc
+    0x10fd, // 0x1cbd
+    0x10fe, // 0x1cbe
+    0x10ff  // 0x1cbf
+};
+
 static const FCh Foldcase0x1e00[] =
 {
     0x1e01, // 0x1e00
@@ -6637,7 +7642,11 @@ static const FCh Foldcase0xa640[] =
     0xa693, // 0xa693
     0xa695, // 0xa694
     0xa695, // 0xa695
-    0xa697  // 0xa696
+    0xa697, // 0xa696
+    0xa697, // 0xa697
+    0xa699, // 0xa698
+    0xa699, // 0xa699
+    0xa69b  // 0xa69a
 };
 
 static const FCh Foldcase0xa722[] =
@@ -6758,15 +7767,15 @@ static const FCh Foldcase0xa722[] =
     0xa793, // 0xa793
     0xa794, // 0xa794
     0xa795, // 0xa795
-    0xa796, // 0xa796
+    0xa797, // 0xa796
     0xa797, // 0xa797
-    0xa798, // 0xa798
+    0xa799, // 0xa798
     0xa799, // 0xa799
-    0xa79a, // 0xa79a
+    0xa79b, // 0xa79a
     0xa79b, // 0xa79b
-    0xa79c, // 0xa79c
+    0xa79d, // 0xa79c
     0xa79d, // 0xa79d
-    0xa79e, // 0xa79e
+    0xa79f, // 0xa79e
     0xa79f, // 0xa79f
     0xa7a1, // 0xa7a0
     0xa7a1, // 0xa7a1
@@ -6778,7 +7787,119 @@ static const FCh Foldcase0xa722[] =
     0xa7a7, // 0xa7a7
     0xa7a9, // 0xa7a8
     0xa7a9, // 0xa7a9
-    0x0266  // 0xa7aa
+    0x0266, // 0xa7aa
+    0x025c, // 0xa7ab
+    0x0261, // 0xa7ac
+    0x026c, // 0xa7ad
+    0x026a, // 0xa7ae
+    0xa7af, // 0xa7af
+    0x029e, // 0xa7b0
+    0x0287, // 0xa7b1
+    0x029d, // 0xa7b2
+    0xab53, // 0xa7b3
+    0xa7b5, // 0xa7b4
+    0xa7b5, // 0xa7b5
+    0xa7b7, // 0xa7b6
+    0xa7b7, // 0xa7b7
+    0xa7b9, // 0xa7b8
+    0xa7b9, // 0xa7b9
+    0xa7bb, // 0xa7ba
+    0xa7bb, // 0xa7bb
+    0xa7bd, // 0xa7bc
+    0xa7bd, // 0xa7bd
+    0xa7bf, // 0xa7be
+    0xa7bf, // 0xa7bf
+    0xa7c0, // 0xa7c0
+    0xa7c1, // 0xa7c1
+    0xa7c3, // 0xa7c2
+    0xa7c3, // 0xa7c3
+    0xa794, // 0xa7c4
+    0x0282, // 0xa7c5
+    0x1d8e  // 0xa7c6
+};
+
+static const FCh Foldcase0xab70[] =
+{
+    0x13a0, // 0xab70
+    0x13a1, // 0xab71
+    0x13a2, // 0xab72
+    0x13a3, // 0xab73
+    0x13a4, // 0xab74
+    0x13a5, // 0xab75
+    0x13a6, // 0xab76
+    0x13a7, // 0xab77
+    0x13a8, // 0xab78
+    0x13a9, // 0xab79
+    0x13aa, // 0xab7a
+    0x13ab, // 0xab7b
+    0x13ac, // 0xab7c
+    0x13ad, // 0xab7d
+    0x13ae, // 0xab7e
+    0x13af, // 0xab7f
+    0x13b0, // 0xab80
+    0x13b1, // 0xab81
+    0x13b2, // 0xab82
+    0x13b3, // 0xab83
+    0x13b4, // 0xab84
+    0x13b5, // 0xab85
+    0x13b6, // 0xab86
+    0x13b7, // 0xab87
+    0x13b8, // 0xab88
+    0x13b9, // 0xab89
+    0x13ba, // 0xab8a
+    0x13bb, // 0xab8b
+    0x13bc, // 0xab8c
+    0x13bd, // 0xab8d
+    0x13be, // 0xab8e
+    0x13bf, // 0xab8f
+    0x13c0, // 0xab90
+    0x13c1, // 0xab91
+    0x13c2, // 0xab92
+    0x13c3, // 0xab93
+    0x13c4, // 0xab94
+    0x13c5, // 0xab95
+    0x13c6, // 0xab96
+    0x13c7, // 0xab97
+    0x13c8, // 0xab98
+    0x13c9, // 0xab99
+    0x13ca, // 0xab9a
+    0x13cb, // 0xab9b
+    0x13cc, // 0xab9c
+    0x13cd, // 0xab9d
+    0x13ce, // 0xab9e
+    0x13cf, // 0xab9f
+    0x13d0, // 0xaba0
+    0x13d1, // 0xaba1
+    0x13d2, // 0xaba2
+    0x13d3, // 0xaba3
+    0x13d4, // 0xaba4
+    0x13d5, // 0xaba5
+    0x13d6, // 0xaba6
+    0x13d7, // 0xaba7
+    0x13d8, // 0xaba8
+    0x13d9, // 0xaba9
+    0x13da, // 0xabaa
+    0x13db, // 0xabab
+    0x13dc, // 0xabac
+    0x13dd, // 0xabad
+    0x13de, // 0xabae
+    0x13df, // 0xabaf
+    0x13e0, // 0xabb0
+    0x13e1, // 0xabb1
+    0x13e2, // 0xabb2
+    0x13e3, // 0xabb3
+    0x13e4, // 0xabb4
+    0x13e5, // 0xabb5
+    0x13e6, // 0xabb6
+    0x13e7, // 0xabb7
+    0x13e8, // 0xabb8
+    0x13e9, // 0xabb9
+    0x13ea, // 0xabba
+    0x13eb, // 0xabbb
+    0x13ec, // 0xabbc
+    0x13ed, // 0xabbd
+    0x13ee, // 0xabbe
+    0x13ef  // 0xabbf
 };
 
 static const FCh Foldcase0xff21[] =
@@ -6855,6 +7976,211 @@ static const FCh Foldcase0x10400[] =
     0x1044f  // 0x10427
 };
 
+static const FCh Foldcase0x104b0[] =
+{
+    0x104d8, // 0x104b0
+    0x104d9, // 0x104b1
+    0x104da, // 0x104b2
+    0x104db, // 0x104b3
+    0x104dc, // 0x104b4
+    0x104dd, // 0x104b5
+    0x104de, // 0x104b6
+    0x104df, // 0x104b7
+    0x104e0, // 0x104b8
+    0x104e1, // 0x104b9
+    0x104e2, // 0x104ba
+    0x104e3, // 0x104bb
+    0x104e4, // 0x104bc
+    0x104e5, // 0x104bd
+    0x104e6, // 0x104be
+    0x104e7, // 0x104bf
+    0x104e8, // 0x104c0
+    0x104e9, // 0x104c1
+    0x104ea, // 0x104c2
+    0x104eb, // 0x104c3
+    0x104ec, // 0x104c4
+    0x104ed, // 0x104c5
+    0x104ee, // 0x104c6
+    0x104ef, // 0x104c7
+    0x104f0, // 0x104c8
+    0x104f1, // 0x104c9
+    0x104f2, // 0x104ca
+    0x104f3, // 0x104cb
+    0x104f4, // 0x104cc
+    0x104f5, // 0x104cd
+    0x104f6, // 0x104ce
+    0x104f7, // 0x104cf
+    0x104f8, // 0x104d0
+    0x104f9, // 0x104d1
+    0x104fa, // 0x104d2
+    0x104fb  // 0x104d3
+};
+
+static const FCh Foldcase0x10c80[] =
+{
+    0x10cc0, // 0x10c80
+    0x10cc1, // 0x10c81
+    0x10cc2, // 0x10c82
+    0x10cc3, // 0x10c83
+    0x10cc4, // 0x10c84
+    0x10cc5, // 0x10c85
+    0x10cc6, // 0x10c86
+    0x10cc7, // 0x10c87
+    0x10cc8, // 0x10c88
+    0x10cc9, // 0x10c89
+    0x10cca, // 0x10c8a
+    0x10ccb, // 0x10c8b
+    0x10ccc, // 0x10c8c
+    0x10ccd, // 0x10c8d
+    0x10cce, // 0x10c8e
+    0x10ccf, // 0x10c8f
+    0x10cd0, // 0x10c90
+    0x10cd1, // 0x10c91
+    0x10cd2, // 0x10c92
+    0x10cd3, // 0x10c93
+    0x10cd4, // 0x10c94
+    0x10cd5, // 0x10c95
+    0x10cd6, // 0x10c96
+    0x10cd7, // 0x10c97
+    0x10cd8, // 0x10c98
+    0x10cd9, // 0x10c99
+    0x10cda, // 0x10c9a
+    0x10cdb, // 0x10c9b
+    0x10cdc, // 0x10c9c
+    0x10cdd, // 0x10c9d
+    0x10cde, // 0x10c9e
+    0x10cdf, // 0x10c9f
+    0x10ce0, // 0x10ca0
+    0x10ce1, // 0x10ca1
+    0x10ce2, // 0x10ca2
+    0x10ce3, // 0x10ca3
+    0x10ce4, // 0x10ca4
+    0x10ce5, // 0x10ca5
+    0x10ce6, // 0x10ca6
+    0x10ce7, // 0x10ca7
+    0x10ce8, // 0x10ca8
+    0x10ce9, // 0x10ca9
+    0x10cea, // 0x10caa
+    0x10ceb, // 0x10cab
+    0x10cec, // 0x10cac
+    0x10ced, // 0x10cad
+    0x10cee, // 0x10cae
+    0x10cef, // 0x10caf
+    0x10cf0, // 0x10cb0
+    0x10cf1, // 0x10cb1
+    0x10cf2  // 0x10cb2
+};
+
+static const FCh Foldcase0x118a0[] =
+{
+    0x118c0, // 0x118a0
+    0x118c1, // 0x118a1
+    0x118c2, // 0x118a2
+    0x118c3, // 0x118a3
+    0x118c4, // 0x118a4
+    0x118c5, // 0x118a5
+    0x118c6, // 0x118a6
+    0x118c7, // 0x118a7
+    0x118c8, // 0x118a8
+    0x118c9, // 0x118a9
+    0x118ca, // 0x118aa
+    0x118cb, // 0x118ab
+    0x118cc, // 0x118ac
+    0x118cd, // 0x118ad
+    0x118ce, // 0x118ae
+    0x118cf, // 0x118af
+    0x118d0, // 0x118b0
+    0x118d1, // 0x118b1
+    0x118d2, // 0x118b2
+    0x118d3, // 0x118b3
+    0x118d4, // 0x118b4
+    0x118d5, // 0x118b5
+    0x118d6, // 0x118b6
+    0x118d7, // 0x118b7
+    0x118d8, // 0x118b8
+    0x118d9, // 0x118b9
+    0x118da, // 0x118ba
+    0x118db, // 0x118bb
+    0x118dc, // 0x118bc
+    0x118dd, // 0x118bd
+    0x118de, // 0x118be
+    0x118df  // 0x118bf
+};
+
+static const FCh Foldcase0x16e40[] =
+{
+    0x16e60, // 0x16e40
+    0x16e61, // 0x16e41
+    0x16e62, // 0x16e42
+    0x16e63, // 0x16e43
+    0x16e64, // 0x16e44
+    0x16e65, // 0x16e45
+    0x16e66, // 0x16e46
+    0x16e67, // 0x16e47
+    0x16e68, // 0x16e48
+    0x16e69, // 0x16e49
+    0x16e6a, // 0x16e4a
+    0x16e6b, // 0x16e4b
+    0x16e6c, // 0x16e4c
+    0x16e6d, // 0x16e4d
+    0x16e6e, // 0x16e4e
+    0x16e6f, // 0x16e4f
+    0x16e70, // 0x16e50
+    0x16e71, // 0x16e51
+    0x16e72, // 0x16e52
+    0x16e73, // 0x16e53
+    0x16e74, // 0x16e54
+    0x16e75, // 0x16e55
+    0x16e76, // 0x16e56
+    0x16e77, // 0x16e57
+    0x16e78, // 0x16e58
+    0x16e79, // 0x16e59
+    0x16e7a, // 0x16e5a
+    0x16e7b, // 0x16e5b
+    0x16e7c, // 0x16e5c
+    0x16e7d, // 0x16e5d
+    0x16e7e, // 0x16e5e
+    0x16e7f  // 0x16e5f
+};
+
+static const FCh Foldcase0x1e900[] =
+{
+    0x1e922, // 0x1e900
+    0x1e923, // 0x1e901
+    0x1e924, // 0x1e902
+    0x1e925, // 0x1e903
+    0x1e926, // 0x1e904
+    0x1e927, // 0x1e905
+    0x1e928, // 0x1e906
+    0x1e929, // 0x1e907
+    0x1e92a, // 0x1e908
+    0x1e92b, // 0x1e909
+    0x1e92c, // 0x1e90a
+    0x1e92d, // 0x1e90b
+    0x1e92e, // 0x1e90c
+    0x1e92f, // 0x1e90d
+    0x1e930, // 0x1e90e
+    0x1e931, // 0x1e90f
+    0x1e932, // 0x1e910
+    0x1e933, // 0x1e911
+    0x1e934, // 0x1e912
+    0x1e935, // 0x1e913
+    0x1e936, // 0x1e914
+    0x1e937, // 0x1e915
+    0x1e938, // 0x1e916
+    0x1e939, // 0x1e917
+    0x1e93a, // 0x1e918
+    0x1e93b, // 0x1e919
+    0x1e93c, // 0x1e91a
+    0x1e93d, // 0x1e91b
+    0x1e93e, // 0x1e91c
+    0x1e93f, // 0x1e91d
+    0x1e940, // 0x1e91e
+    0x1e941, // 0x1e91f
+    0x1e942, // 0x1e920
+    0x1e943  // 0x1e921
+};
+
 FCh CharFoldcase(FCh ch)
 {
     if (ch <= 0x005a)
@@ -6881,6 +8207,18 @@ FCh CharFoldcase(FCh ch)
             return(Foldcase0x10a0[ch - 0x10a0]);
         return(ch);
     }
+    if (ch <= 0x13fd)
+    {
+        if (ch >= 0x13f8)
+            return(Foldcase0x13f8[ch - 0x13f8]);
+        return(ch);
+    }
+    if (ch <= 0x1cbf)
+    {
+        if (ch >= 0x1c80)
+            return(Foldcase0x1c80[ch - 0x1c80]);
+        return(ch);
+    }
     if (ch <= 0x1ffc)
     {
         if (ch >= 0x1e00)
@@ -6905,18 +8243,24 @@ FCh CharFoldcase(FCh ch)
             return(Foldcase0x2c00[ch - 0x2c00]);
         return(ch);
     }
-    if (ch <= 0xa696)
+    if (ch <= 0xa69a)
     {
         if (ch >= 0xa640)
             return(Foldcase0xa640[ch - 0xa640]);
         return(ch);
     }
-    if (ch <= 0xa7aa)
+    if (ch <= 0xa7c6)
     {
         if (ch >= 0xa722)
             return(Foldcase0xa722[ch - 0xa722]);
         return(ch);
     }
+    if (ch <= 0xabbf)
+    {
+        if (ch >= 0xab70)
+            return(Foldcase0xab70[ch - 0xab70]);
+        return(ch);
+    }
     if (ch <= 0xff3a)
     {
         if (ch >= 0xff21)
@@ -6929,944 +8273,39 @@ FCh CharFoldcase(FCh ch)
             return(Foldcase0x10400[ch - 0x10400]);
         return(ch);
     }
+    if (ch <= 0x104d3)
+    {
+        if (ch >= 0x104b0)
+            return(Foldcase0x104b0[ch - 0x104b0]);
+        return(ch);
+    }
+    if (ch <= 0x10cb2)
+    {
+        if (ch >= 0x10c80)
+            return(Foldcase0x10c80[ch - 0x10c80]);
+        return(ch);
+    }
+    if (ch <= 0x118bf)
+    {
+        if (ch >= 0x118a0)
+            return(Foldcase0x118a0[ch - 0x118a0]);
+        return(ch);
+    }
+    if (ch <= 0x16e5f)
+    {
+        if (ch >= 0x16e40)
+            return(Foldcase0x16e40[ch - 0x16e40]);
+        return(ch);
+    }
+    if (ch <= 0x1e921)
+    {
+        if (ch >= 0x1e900)
+            return(Foldcase0x1e900[ch - 0x1e900]);
+        return(ch);
+    }
     return(ch);
 }
 
-static const unsigned int Alphabetic0x0000To0x1fff[] =
-{
-    0x0, // 0x0000
-    0x0, // 0x0020
-    0x07fffffe, // 0x0040
-    0x07fffffe, // 0x0060
-    0x0, // 0x0080
-    0x04200400, // 0x00a0
-    0xff7fffff, // 0x00c0
-    0xff7fffff, // 0x00e0
-    0xffffffff, // 0x0100
-    0xffffffff, // 0x0120
-    0xffffffff, // 0x0140
-    0xffffffff, // 0x0160
-    0xffffffff, // 0x0180
-    0xffffffff, // 0x01a0
-    0xffffffff, // 0x01c0
-    0xffffffff, // 0x01e0
-    0xffffffff, // 0x0200
-    0xffffffff, // 0x0220
-    0xffffffff, // 0x0240
-    0xffffffff, // 0x0260
-    0xffffffff, // 0x0280
-    0xffffffff, // 0x02a0
-    0x0003ffc3, // 0x02c0
-    0x0000501f, // 0x02e0
-    0x0, // 0x0300
-    0x0, // 0x0320
-    0x00000020, // 0x0340
-    0x3cdf0000, // 0x0360
-    0xffffd740, // 0x0380
-    0xfffffffb, // 0x03a0
-    0xffffffff, // 0x03c0
-    0xffbfffff, // 0x03e0
-    0xffffffff, // 0x0400
-    0xffffffff, // 0x0420
-    0xffffffff, // 0x0440
-    0xffffffff, // 0x0460
-    0xfffffc03, // 0x0480
-    0xffffffff, // 0x04a0
-    0xffffffff, // 0x04c0
-    0xffffffff, // 0x04e0
-    0xffffffff, // 0x0500
-    0xfffe00ff, // 0x0520
-    0x027fffff, // 0x0540
-    0xfffffffe, // 0x0560
-    0x000000ff, // 0x0580
-    0xbfff0000, // 0x05a0
-    0xffff00b6, // 0x05c0
-    0x000707ff, // 0x05e0
-    0x07ff0000, // 0x0600
-    0xffffffff, // 0x0620
-    0xfeffffff, // 0x0640
-    0xffffc000, // 0x0660
-    0xffffffff, // 0x0680
-    0xffffffff, // 0x06a0
-    0x1fefffff, // 0x06c0
-    0x9c00e1fe, // 0x06e0
-    0xffff0000, // 0x0700
-    0xffffffff, // 0x0720
-    0xffffe000, // 0x0740
-    0xffffffff, // 0x0760
-    0xffffffff, // 0x0780
-    0x0003ffff, // 0x07a0
-    0xfffffc00, // 0x07c0
-    0x043007ff, // 0x07e0
-    0xfcffffff, // 0x0800
-    0x00001fff, // 0x0820
-    0x01ffffff, // 0x0840
-    0x0, // 0x0860
-    0x0, // 0x0880
-    0x00001ffd, // 0x08a0
-    0x0, // 0x08c0
-    0x7fff03f0, // 0x08e0
-    0xffffffff, // 0x0900
-    0xefffffff, // 0x0920
-    0xffe1dfff, // 0x0940
-    0xfefe000f, // 0x0960
-    0xfff99fee, // 0x0980
-    0xe3c5fdff, // 0x09a0
-    0xb080599f, // 0x09c0
-    0x0003000f, // 0x09e0
-    0xfff987ee, // 0x0a00
-    0xc36dfdff, // 0x0a20
-    0x5e021987, // 0x0a40
-    0x003f0000, // 0x0a60
-    0xfffbbfee, // 0x0a80
-    0xe3edfdff, // 0x0aa0
-    0x00011bbf, // 0x0ac0
-    0x0000000f, // 0x0ae0
-    0xfff99fee, // 0x0b00
-    0xe3edfdff, // 0x0b20
-    0xb0c0199f, // 0x0b40
-    0x0002000f, // 0x0b60
-    0xd63dc7ec, // 0x0b80
-    0xc3ffc718, // 0x0ba0
-    0x00811dc7, // 0x0bc0
-    0x0, // 0x0be0
-    0xfffddfee, // 0x0c00
-    0xe3effdff, // 0x0c20
-    0x03601ddf, // 0x0c40
-    0x0000000f, // 0x0c60
-    0xfffddfec, // 0x0c80
-    0xe3effdff, // 0x0ca0
-    0x40601ddf, // 0x0cc0
-    0x0006000f, // 0x0ce0
-    0xfffddfec, // 0x0d00
-    0xe7ffffff, // 0x0d20
-    0x00805ddf, // 0x0d40
-    0xfc00000f, // 0x0d60
-    0xfc7fffec, // 0x0d80
-    0x2ffbffff, // 0x0da0
-    0xff5f807f, // 0x0dc0
-    0x000c0000, // 0x0de0
-    0xfffffffe, // 0x0e00
-    0x07ffffff, // 0x0e20
-    0x0000207f, // 0x0e40
-    0x0, // 0x0e60
-    0xfef02596, // 0x0e80
-    0x3bffecae, // 0x0ea0
-    0xf000205f, // 0x0ec0
-    0x0, // 0x0ee0
-    0x00000001, // 0x0f00
-    0x0, // 0x0f20
-    0xfffffeff, // 0x0f40
-    0xfffe1fff, // 0x0f60
-    0xfeffff03, // 0x0f80
-    0x1fffffff, // 0x0fa0
-    0x0, // 0x0fc0
-    0x0, // 0x0fe0
-    0xffffffff, // 0x1000
-    0xf97fffff, // 0x1020
-    0xffff0000, // 0x1040
-    0xffffc1e7, // 0x1060
-    0x3000407f, // 0x1080
-    0xffffffff, // 0x10a0
-    0xffff20bf, // 0x10c0
-    0xf7ffffff, // 0x10e0
-    0xffffffff, // 0x1100
-    0xffffffff, // 0x1120
-    0xffffffff, // 0x1140
-    0xffffffff, // 0x1160
-    0xffffffff, // 0x1180
-    0xffffffff, // 0x11a0
-    0xffffffff, // 0x11c0
-    0xffffffff, // 0x11e0
-    0xffffffff, // 0x1200
-    0xffffffff, // 0x1220
-    0x3d7f3dff, // 0x1240
-    0xffffffff, // 0x1260
-    0xffff3dff, // 0x1280
-    0x7f3dffff, // 0x12a0
-    0xff7fff3d, // 0x12c0
-    0xffffffff, // 0x12e0
-    0xff3dffff, // 0x1300
-    0xffffffff, // 0x1320
-    0x87ffffff, // 0x1340
-    0x0, // 0x1360
-    0x0000ffff, // 0x1380
-    0xffffffff, // 0x13a0
-    0xffffffff, // 0x13c0
-    0x001fffff, // 0x13e0
-    0xfffffffe, // 0x1400
-    0xffffffff, // 0x1420
-    0xffffffff, // 0x1440
-    0xffffffff, // 0x1460
-    0xffffffff, // 0x1480
-    0xffffffff, // 0x14a0
-    0xffffffff, // 0x14c0
-    0xffffffff, // 0x14e0
-    0xffffffff, // 0x1500
-    0xffffffff, // 0x1520
-    0xffffffff, // 0x1540
-    0xffffffff, // 0x1560
-    0xffffffff, // 0x1580
-    0xffffffff, // 0x15a0
-    0xffffffff, // 0x15c0
-    0xffffffff, // 0x15e0
-    0xffffffff, // 0x1600
-    0xffffffff, // 0x1620
-    0xffffffff, // 0x1640
-    0xffff9fff, // 0x1660
-    0x07fffffe, // 0x1680
-    0xffffffff, // 0x16a0
-    0xffffffff, // 0x16c0
-    0x0001c7ff, // 0x16e0
-    0x000fdfff, // 0x1700
-    0x000fffff, // 0x1720
-    0x000fffff, // 0x1740
-    0x000ddfff, // 0x1760
-    0xffffffff, // 0x1780
-    0xffcfffff, // 0x17a0
-    0x108001ff, // 0x17c0
-    0x0, // 0x17e0
-    0x0, // 0x1800
-    0xffffffff, // 0x1820
-    0xffffffff, // 0x1840
-    0x00ffffff, // 0x1860
-    0xffffffff, // 0x1880
-    0xffff07ff, // 0x18a0
-    0xffffffff, // 0x18c0
-    0x003fffff, // 0x18e0
-    0x1fffffff, // 0x1900
-    0x01ff0fff, // 0x1920
-    0xffff0000, // 0x1940
-    0x001f3fff, // 0x1960
-    0xffffffff, // 0x1980
-    0xffff0fff, // 0x19a0
-    0x000003ff, // 0x19c0
-    0x0, // 0x19e0
-    0x0fffffff, // 0x1a00
-    0xffffffff, // 0x1a20
-    0x7fffffff, // 0x1a40
-    0x001ffffe, // 0x1a60
-    0x0, // 0x1a80
-    0x00000080, // 0x1aa0
-    0x0, // 0x1ac0
-    0x0, // 0x1ae0
-    0xffffffff, // 0x1b00
-    0xffefffff, // 0x1b20
-    0x00000fef, // 0x1b40
-    0x0, // 0x1b60
-    0xffffffff, // 0x1b80
-    0xfc00f3ff, // 0x1ba0
-    0xffffffff, // 0x1bc0
-    0x0003ffbf, // 0x1be0
-    0xffffffff, // 0x1c00
-    0x003fffff, // 0x1c20
-    0xfc00e000, // 0x1c40
-    0x3fffffff, // 0x1c60
-    0x0, // 0x1c80
-    0x0, // 0x1ca0
-    0x0, // 0x1cc0
-    0x006fde00, // 0x1ce0
-    0xffffffff, // 0x1d00
-    0xffffffff, // 0x1d20
-    0xffffffff, // 0x1d40
-    0xffffffff, // 0x1d60
-    0xffffffff, // 0x1d80
-    0xffffffff, // 0x1da0
-    0x0, // 0x1dc0
-    0x0, // 0x1de0
-    0xffffffff, // 0x1e00
-    0xffffffff, // 0x1e20
-    0xffffffff, // 0x1e40
-    0xffffffff, // 0x1e60
-    0xffffffff, // 0x1e80
-    0xffffffff, // 0x1ea0
-    0xffffffff, // 0x1ec0
-    0xffffffff, // 0x1ee0
-    0x3f3fffff, // 0x1f00
-    0xffffffff, // 0x1f20
-    0xaaff3f3f, // 0x1f40
-    0x3fffffff, // 0x1f60
-    0xffffffff, // 0x1f80
-    0x5fdfffff, // 0x1fa0
-    0x0fcf1fdc, // 0x1fc0
-    0x1fdc1fff, // 0x1fe0
-    0x0
-};
-
-static const unsigned int Alphabetic0x2060To0x219f[] =
-{
-    0x80020000, // 0x2060
-    0x1fff0000, // 0x2080
-    0x0, // 0x20a0
-    0x0, // 0x20c0
-    0x0, // 0x20e0
-    0x3e2ffc84, // 0x2100
-    0xf3ffbd50, // 0x2120
-    0x000043e0, // 0x2140
-    0xffffffff, // 0x2160
-    0x000001ff, // 0x2180
-    0x0
-};
-
-static const unsigned int Alphabetic0x24a0To0x24ff[] =
-{
-    0xffc00000, // 0x24a0
-    0xffffffff, // 0x24c0
-    0x000003ff, // 0x24e0
-    0x0
-};
-
-static const unsigned int Alphabetic0x2c00To0x2e3f[] =
-{
-    0xffffffff, // 0x2c00
-    0xffff7fff, // 0x2c20
-    0x7fffffff, // 0x2c40
-    0xffffffff, // 0x2c60
-    0xffffffff, // 0x2c80
-    0xffffffff, // 0x2ca0
-    0xffffffff, // 0x2cc0
-    0x000c781f, // 0x2ce0
-    0xffffffff, // 0x2d00
-    0xffff20bf, // 0x2d20
-    0xffffffff, // 0x2d40
-    0x000080ff, // 0x2d60
-    0x007fffff, // 0x2d80
-    0x7f7f7f7f, // 0x2da0
-    0x7f7f7f7f, // 0x2dc0
-    0xffffffff, // 0x2de0
-    0x0, // 0x2e00
-    0x00008000, // 0x2e20
-    0x0
-};
-
-static const unsigned int Alphabetic0x3000To0x31ff[] =
-{
-    0x000000e0, // 0x3000
-    0x1f3e03fe, // 0x3020
-    0xfffffffe, // 0x3040
-    0xffffffff, // 0x3060
-    0xe07fffff, // 0x3080
-    0xfffffffe, // 0x30a0
-    0xffffffff, // 0x30c0
-    0xf7ffffff, // 0x30e0
-    0xffffffe0, // 0x3100
-    0xfffe3fff, // 0x3120
-    0xffffffff, // 0x3140
-    0xffffffff, // 0x3160
-    0x00007fff, // 0x3180
-    0x07ffffff, // 0x31a0
-    0x0, // 0x31c0
-    0xffff0000, // 0x31e0
-    0x0
-};
-
-static const unsigned int Alphabetic0xa480To0xabff[] =
-{
-    0x00001fff, // 0xa480
-    0x0, // 0xa4a0
-    0xffff0000, // 0xa4c0
-    0x3fffffff, // 0xa4e0
-    0xffffffff, // 0xa500
-    0xffffffff, // 0xa520
-    0xffffffff, // 0xa540
-    0xffffffff, // 0xa560
-    0xffffffff, // 0xa580
-    0xffffffff, // 0xa5a0
-    0xffffffff, // 0xa5c0
-    0xffffffff, // 0xa5e0
-    0xffff1fff, // 0xa600
-    0x00000c00, // 0xa620
-    0xffffffff, // 0xa640
-    0x8ff07fff, // 0xa660
-    0x80ffffff, // 0xa680
-    0xffffffff, // 0xa6a0
-    0xffffffff, // 0xa6c0
-    0x0000ffff, // 0xa6e0
-    0xff800000, // 0xa700
-    0xfffffffc, // 0xa720
-    0xffffffff, // 0xa740
-    0xffffffff, // 0xa760
-    0x000f79ff, // 0xa780
-    0x000007ff, // 0xa7a0
-    0x0, // 0xa7c0
-    0xff000000, // 0xa7e0
-    0xfffff7bb, // 0xa800
-    0x000000ff, // 0xa820
-    0xffffffff, // 0xa840
-    0x000fffff, // 0xa860
-    0xffffffff, // 0xa880
-    0xffffffff, // 0xa8a0
-    0x0000000f, // 0xa8c0
-    0x08fc0000, // 0xa8e0
-    0xfffffc00, // 0xa900
-    0xffff07ff, // 0xa920
-    0x0007ffff, // 0xa940
-    0x1fffffff, // 0xa960
-    0xffffffff, // 0xa980
-    0xfff7ffff, // 0xa9a0
-    0x00008000, // 0xa9c0
-    0x0, // 0xa9e0
-    0xffffffff, // 0xaa00
-    0x007fffff, // 0xaa20
-    0x00003fff, // 0xaa40
-    0x047fffff, // 0xaa60
-    0xffffffff, // 0xaa80
-    0x7fffffff, // 0xaaa0
-    0x38000005, // 0xaac0
-    0x003cffff, // 0xaae0
-    0x007e7e7e, // 0xab00
-    0x00007f7f, // 0xab20
-    0x0, // 0xab40
-    0x0, // 0xab60
-    0x0, // 0xab80
-    0x0, // 0xaba0
-    0xffffffff, // 0xabc0
-    0x000007ff, // 0xabe0
-    0x0
-};
-
-static const unsigned int Alphabetic0xd7a0To0xd7ff[] =
-{
-    0xffff000f, // 0xd7a0
-    0xfffff87f, // 0xd7c0
-    0x0fffffff, // 0xd7e0
-    0x0
-};
-
-static const unsigned int Alphabetic0xf900To0x1049f[] =
-{
-    0xffffffff, // 0xf900
-    0xffffffff, // 0xf920
-    0xffffffff, // 0xf940
-    0xffffffff, // 0xf960
-    0xffffffff, // 0xf980
-    0xffffffff, // 0xf9a0
-    0xffffffff, // 0xf9c0
-    0xffffffff, // 0xf9e0
-    0xffffffff, // 0xfa00
-    0xffffffff, // 0xfa20
-    0xffffffff, // 0xfa40
-    0xffff3fff, // 0xfa60
-    0xffffffff, // 0xfa80
-    0xffffffff, // 0xfaa0
-    0x03ffffff, // 0xfac0
-    0x0, // 0xfae0
-    0xe0f8007f, // 0xfb00
-    0x5f7ffdff, // 0xfb20
-    0xffffffdb, // 0xfb40
-    0xffffffff, // 0xfb60
-    0xffffffff, // 0xfb80
-    0x0003ffff, // 0xfba0
-    0xfff80000, // 0xfbc0
-    0xffffffff, // 0xfbe0
-    0xffffffff, // 0xfc00
-    0xffffffff, // 0xfc20
-    0xffffffff, // 0xfc40
-    0xffffffff, // 0xfc60
-    0xffffffff, // 0xfc80
-    0xffffffff, // 0xfca0
-    0xffffffff, // 0xfcc0
-    0xffffffff, // 0xfce0
-    0xffffffff, // 0xfd00
-    0x3fffffff, // 0xfd20
-    0xffff0000, // 0xfd40
-    0xffffffff, // 0xfd60
-    0xfffcffff, // 0xfd80
-    0xffffffff, // 0xfda0
-    0x000000ff, // 0xfdc0
-    0x0fff0000, // 0xfde0
-    0x0, // 0xfe00
-    0x0, // 0xfe20
-    0x0, // 0xfe40
-    0xffdf0000, // 0xfe60
-    0xffffffff, // 0xfe80
-    0xffffffff, // 0xfea0
-    0xffffffff, // 0xfec0
-    0x1fffffff, // 0xfee0
-    0x0, // 0xff00
-    0x07fffffe, // 0xff20
-    0x07fffffe, // 0xff40
-    0xffffffc0, // 0xff60
-    0xffffffff, // 0xff80
-    0x7fffffff, // 0xffa0
-    0x1cfcfcfc, // 0xffc0
-    0x0, // 0xffe0
-    0xffffefff, // 0x10000
-    0xb7ffff7f, // 0x10020
-    0x3fff3fff, // 0x10040
-    0x0, // 0x10060
-    0xffffffff, // 0x10080
-    0xffffffff, // 0x100a0
-    0xffffffff, // 0x100c0
-    0x07ffffff, // 0x100e0
-    0x0, // 0x10100
-    0x0, // 0x10120
-    0xffffffff, // 0x10140
-    0x001fffff, // 0x10160
-    0x0, // 0x10180
-    0x0, // 0x101a0
-    0x0, // 0x101c0
-    0x0, // 0x101e0
-    0x0, // 0x10200
-    0x0, // 0x10220
-    0x0, // 0x10240
-    0x0, // 0x10260
-    0x1fffffff, // 0x10280
-    0xffffffff, // 0x102a0
-    0x0001ffff, // 0x102c0
-    0x0, // 0x102e0
-    0x7fffffff, // 0x10300
-    0xffff0000, // 0x10320
-    0x000007ff, // 0x10340
-    0x0, // 0x10360
-    0x3fffffff, // 0x10380
-    0xffffffff, // 0x103a0
-    0x003eff0f, // 0x103c0
-    0x0, // 0x103e0
-    0xffffffff, // 0x10400
-    0xffffffff, // 0x10420
-    0xffffffff, // 0x10440
-    0xffffffff, // 0x10460
-    0x3fffffff, // 0x10480
-    0x0
-};
-
-static const unsigned int Alphabetic0x10800To0x10c5f[] =
-{
-    0xfffffd3f, // 0x10800
-    0x91bfffff, // 0x10820
-    0x003fffff, // 0x10840
-    0x0, // 0x10860
-    0x0, // 0x10880
-    0x0, // 0x108a0
-    0x0, // 0x108c0
-    0x0, // 0x108e0
-    0x003fffff, // 0x10900
-    0x03ffffff, // 0x10920
-    0x0, // 0x10940
-    0x0, // 0x10960
-    0xffffffff, // 0x10980
-    0xc0ffffff, // 0x109a0
-    0x0, // 0x109c0
-    0x0, // 0x109e0
-    0xfeeff06f, // 0x10a00
-    0x000fffff, // 0x10a20
-    0x0, // 0x10a40
-    0x1fffffff, // 0x10a60
-    0x0, // 0x10a80
-    0x0, // 0x10aa0
-    0x0, // 0x10ac0
-    0x0, // 0x10ae0
-    0xffffffff, // 0x10b00
-    0x003fffff, // 0x10b20
-    0x003fffff, // 0x10b40
-    0x0007ffff, // 0x10b60
-    0x0, // 0x10b80
-    0x0, // 0x10ba0
-    0x0, // 0x10bc0
-    0x0, // 0x10be0
-    0xffffffff, // 0x10c00
-    0xffffffff, // 0x10c20
-    0x000001ff, // 0x10c40
-    0x0
-};
-
-static const unsigned int Alphabetic0x11000To0x111df[] =
-{
-    0xffffffff, // 0x11000
-    0xffffffff, // 0x11020
-    0x0000003f, // 0x11040
-    0x0, // 0x11060
-    0xfffffffc, // 0x11080
-    0x01ffffff, // 0x110a0
-    0xffff0000, // 0x110c0
-    0x000001ff, // 0x110e0
-    0xffffffff, // 0x11100
-    0x0007ffff, // 0x11120
-    0x0, // 0x11140
-    0x0, // 0x11160
-    0xffffffff, // 0x11180
-    0xffffffff, // 0x111a0
-    0x0000001e, // 0x111c0
-    0x0
-};
-
-static const unsigned int Alphabetic0x16f00To0x16f9f[] =
-{
-    0xffffffff, // 0x16f00
-    0xffffffff, // 0x16f20
-    0xffff001f, // 0x16f40
-    0x7fffffff, // 0x16f60
-    0xfff80000, // 0x16f80
-    0x0
-};
-
-static const unsigned int Alphabetic0x1d400To0x1d7df[] =
-{
-    0xffffffff, // 0x1d400
-    0xffffffff, // 0x1d420
-    0xffdfffff, // 0x1d440
-    0xffffffff, // 0x1d460
-    0xdfffffff, // 0x1d480
-    0xebffde64, // 0x1d4a0
-    0xffffffef, // 0x1d4c0
-    0xffffffff, // 0x1d4e0
-    0xdfdfe7bf, // 0x1d500
-    0x7bffffff, // 0x1d520
-    0xfffdfc5f, // 0x1d540
-    0xffffffff, // 0x1d560
-    0xffffffff, // 0x1d580
-    0xffffffff, // 0x1d5a0
-    0xffffffff, // 0x1d5c0
-    0xffffffff, // 0x1d5e0
-    0xffffffff, // 0x1d600
-    0xffffffff, // 0x1d620
-    0xffffffff, // 0x1d640
-    0xffffffff, // 0x1d660
-    0xffffffff, // 0x1d680
-    0xffffff3f, // 0x1d6a0
-    0xf7fffffd, // 0x1d6c0
-    0xf7ffffff, // 0x1d6e0
-    0xffdfffff, // 0x1d700
-    0xffdfffff, // 0x1d720
-    0xffff7fff, // 0x1d740
-    0xffff7fff, // 0x1d760
-    0xfffffdff, // 0x1d780
-    0xfffffdff, // 0x1d7a0
-    0x00000ff7, // 0x1d7c0
-    0x0
-};
-
-static const unsigned int Alphabetic0x1ee00To0x1eebf[] =
-{
-    0xffffffef, // 0x1ee00
-    0x0af7fe96, // 0x1ee20
-    0xaa96ea84, // 0x1ee40
-    0x5ef7f796, // 0x1ee60
-    0x0ffffbff, // 0x1ee80
-    0x0ffffbee, // 0x1eea0
-    0x0
-};
-
-static const unsigned int Uppercase0x0000To0x059f[] =
-{
-    0x0, // 0x0000
-    0x0, // 0x0020
-    0x07fffffe, // 0x0040
-    0x0, // 0x0060
-    0x0, // 0x0080
-    0x0, // 0x00a0
-    0x7f7fffff, // 0x00c0
-    0x0, // 0x00e0
-    0x55555555, // 0x0100
-    0xaa555555, // 0x0120
-    0x555554aa, // 0x0140
-    0x2b555555, // 0x0160
-    0xb1dbced6, // 0x0180
-    0x11aed2d5, // 0x01a0
-    0x4aaaa490, // 0x01c0
-    0x55d25555, // 0x01e0
-    0x55555555, // 0x0200
-    0x6c055555, // 0x0220
-    0x0000557a, // 0x0240
-    0x0, // 0x0260
-    0x0, // 0x0280
-    0x0, // 0x02a0
-    0x0, // 0x02c0
-    0x0, // 0x02e0
-    0x0, // 0x0300
-    0x0, // 0x0320
-    0x0, // 0x0340
-    0x00450000, // 0x0360
-    0xfffed740, // 0x0380
-    0x00000ffb, // 0x03a0
-    0x551c8000, // 0x03c0
-    0xe6905555, // 0x03e0
-    0xffffffff, // 0x0400
-    0x0000ffff, // 0x0420
-    0x0, // 0x0440
-    0x55555555, // 0x0460
-    0x55555401, // 0x0480
-    0x55555555, // 0x04a0
-    0x55552aab, // 0x04c0
-    0x55555555, // 0x04e0
-    0x55555555, // 0x0500
-    0xfffe0055, // 0x0520
-    0x007fffff, // 0x0540
-    0x0, // 0x0560
-    0x0, // 0x0580
-    0x0
-};
-
-static const unsigned int Uppercase0x10a0To0x10df[] =
-{
-    0xffffffff, // 0x10a0
-    0x000020bf, // 0x10c0
-    0x0
-};
-
-static const unsigned int Uppercase0x1e00To0x1fff[] =
-{
-    0x55555555, // 0x1e00
-    0x55555555, // 0x1e20
-    0x55555555, // 0x1e40
-    0x55555555, // 0x1e60
-    0x40155555, // 0x1e80
-    0x55555555, // 0x1ea0
-    0x55555555, // 0x1ec0
-    0x55555555, // 0x1ee0
-    0x3f00ff00, // 0x1f00
-    0xff00ff00, // 0x1f20
-    0xaa003f00, // 0x1f40
-    0x0000ff00, // 0x1f60
-    0x0, // 0x1f80
-    0x0f000000, // 0x1fa0
-    0x0f000f00, // 0x1fc0
-    0x0f001f00, // 0x1fe0
-    0x0
-};
-
-static const unsigned int Uppercase0x2100To0x219f[] =
-{
-    0x3e273884, // 0x2100
-    0xc00f3d50, // 0x2120
-    0x00000020, // 0x2140
-    0x0000ffff, // 0x2160
-    0x00000008, // 0x2180
-    0x0
-};
-
-static const unsigned int Uppercase0x2c00To0x2d3f[] =
-{
-    0xffffffff, // 0x2c00
-    0x00007fff, // 0x2c20
-    0x0, // 0x2c40
-    0xc025ea9d, // 0x2c60
-    0x55555555, // 0x2c80
-    0x55555555, // 0x2ca0
-    0x55555555, // 0x2cc0
-    0x00042805, // 0x2ce0
-    0x0, // 0x2d00
-    0x0, // 0x2d20
-    0x0
-};
-
-static const unsigned int Uppercase0xa640To0xa7bf[] =
-{
-    0x55555555, // 0xa640
-    0x00001555, // 0xa660
-    0x00555555, // 0xa680
-    0x0, // 0xa6a0
-    0x0, // 0xa6c0
-    0x0, // 0xa6e0
-    0x0, // 0xa700
-    0x55545554, // 0xa720
-    0x55555555, // 0xa740
-    0x6a005555, // 0xa760
-    0x00052855, // 0xa780
-    0x00000555, // 0xa7a0
-    0x0
-};
-
-static const unsigned int Uppercase0x1d400To0x1d7df[] =
-{
-    0x03ffffff, // 0x1d400
-    0xfff00000, // 0x1d420
-    0x00003fff, // 0x1d440
-    0xffffff00, // 0x1d460
-    0xd0000003, // 0x1d480
-    0x003fde64, // 0x1d4a0
-    0xffff0000, // 0x1d4c0
-    0x000003ff, // 0x1d4e0
-    0x1fdfe7b0, // 0x1d500
-    0x7b000000, // 0x1d520
-    0x0001fc5f, // 0x1d540
-    0xfffff000, // 0x1d560
-    0x0000003f, // 0x1d580
-    0x03ffffff, // 0x1d5a0
-    0xfff00000, // 0x1d5c0
-    0x00003fff, // 0x1d5e0
-    0xffffff00, // 0x1d600
-    0xf0000003, // 0x1d620
-    0x003fffff, // 0x1d640
-    0xffff0000, // 0x1d660
-    0x000003ff, // 0x1d680
-    0xffffff00, // 0x1d6a0
-    0x00000001, // 0x1d6c0
-    0x07fffffc, // 0x1d6e0
-    0xf0000000, // 0x1d700
-    0x001fffff, // 0x1d720
-    0xffc00000, // 0x1d740
-    0x00007fff, // 0x1d760
-    0xffff0000, // 0x1d780
-    0x000001ff, // 0x1d7a0
-    0x00000400, // 0x1d7c0
-    0x0
-};
-
-static const unsigned int Lowercase0x0000To0x059f[] =
-{
-    0x0, // 0x0000
-    0x0, // 0x0020
-    0x0, // 0x0040
-    0x07fffffe, // 0x0060
-    0x0, // 0x0080
-    0x04200400, // 0x00a0
-    0x80000000, // 0x00c0
-    0xff7fffff, // 0x00e0
-    0xaaaaaaaa, // 0x0100
-    0x55aaaaaa, // 0x0120
-    0xaaaaab55, // 0x0140
-    0xd4aaaaaa, // 0x0160
-    0x4e243129, // 0x0180
-    0xe6512d2a, // 0x01a0
-    0xb5555240, // 0x01c0
-    0xaa29aaaa, // 0x01e0
-    0xaaaaaaaa, // 0x0200
-    0x93faaaaa, // 0x0220
-    0xffffaa85, // 0x0240
-    0xffffffff, // 0x0260
-    0xffefffff, // 0x0280
-    0x01ffffff, // 0x02a0
-    0x00000003, // 0x02c0
-    0x0000001f, // 0x02e0
-    0x0, // 0x0300
-    0x0, // 0x0320
-    0x00000020, // 0x0340
-    0x3c8a0000, // 0x0360
-    0x00010000, // 0x0380
-    0xfffff000, // 0x03a0
-    0xaae37fff, // 0x03c0
-    0x192faaaa, // 0x03e0
-    0x0, // 0x0400
-    0xffff0000, // 0x0420
-    0xffffffff, // 0x0440
-    0xaaaaaaaa, // 0x0460
-    0xaaaaa802, // 0x0480
-    0xaaaaaaaa, // 0x04a0
-    0xaaaad554, // 0x04c0
-    0xaaaaaaaa, // 0x04e0
-    0xaaaaaaaa, // 0x0500
-    0x000000aa, // 0x0520
-    0x0, // 0x0540
-    0xfffffffe, // 0x0560
-    0x000000ff, // 0x0580
-    0x0
-};
-
-static const unsigned int Lowercase0x1d00To0x1fff[] =
-{
-    0xffffffff, // 0x1d00
-    0xffffffff, // 0x1d20
-    0xffffffff, // 0x1d40
-    0xffffffff, // 0x1d60
-    0xffffffff, // 0x1d80
-    0xffffffff, // 0x1da0
-    0x0, // 0x1dc0
-    0x0, // 0x1de0
-    0xaaaaaaaa, // 0x1e00
-    0xaaaaaaaa, // 0x1e20
-    0xaaaaaaaa, // 0x1e40
-    0xaaaaaaaa, // 0x1e60
-    0xbfeaaaaa, // 0x1e80
-    0xaaaaaaaa, // 0x1ea0
-    0xaaaaaaaa, // 0x1ec0
-    0xaaaaaaaa, // 0x1ee0
-    0x003f00ff, // 0x1f00
-    0x00ff00ff, // 0x1f20
-    0x00ff003f, // 0x1f40
-    0x3fff00ff, // 0x1f60
-    0x00ff00ff, // 0x1f80
-    0x40df00ff, // 0x1fa0
-    0x00cf00dc, // 0x1fc0
-    0x00dc00ff, // 0x1fe0
-    0x0
-};
-
-static const unsigned int Lowercase0x2060To0x219f[] =
-{
-    0x80020000, // 0x2060
-    0x1fff0000, // 0x2080
-    0x0, // 0x20a0
-    0x0, // 0x20c0
-    0x0, // 0x20e0
-    0x0008c400, // 0x2100
-    0x32108000, // 0x2120
-    0x000043c0, // 0x2140
-    0xffff0000, // 0x2160
-    0x00000010, // 0x2180
-    0x0
-};
-
-static const unsigned int Lowercase0x2c20To0x2d3f[] =
-{
-    0xffff0000, // 0x2c20
-    0x7fffffff, // 0x2c40
-    0x3fda1562, // 0x2c60
-    0xaaaaaaaa, // 0x2c80
-    0xaaaaaaaa, // 0x2ca0
-    0xaaaaaaaa, // 0x2cc0
-    0x0008501a, // 0x2ce0
-    0xffffffff, // 0x2d00
-    0x000020bf, // 0x2d20
-    0x0
-};
-
-static const unsigned int Lowercase0xa640To0xa7ff[] =
-{
-    0xaaaaaaaa, // 0xa640
-    0x00002aaa, // 0xa660
-    0x00aaaaaa, // 0xa680
-    0x0, // 0xa6a0
-    0x0, // 0xa6c0
-    0x0, // 0xa6e0
-    0x0, // 0xa700
-    0xaaabaaa8, // 0xa720
-    0xaaaaaaaa, // 0xa740
-    0x95ffaaaa, // 0xa760
-    0x000a50aa, // 0xa780
-    0x000002aa, // 0xa7a0
-    0x0, // 0xa7c0
-    0x07000000, // 0xa7e0
-    0x0
-};
-
-static const unsigned int Lowercase0x1d400To0x1d7df[] =
-{
-    0xfc000000, // 0x1d400
-    0x000fffff, // 0x1d420
-    0xffdfc000, // 0x1d440
-    0x000000ff, // 0x1d460
-    0x0ffffffc, // 0x1d480
-    0xebc00000, // 0x1d4a0
-    0x0000ffef, // 0x1d4c0
-    0xfffffc00, // 0x1d4e0
-    0xc000000f, // 0x1d500
-    0x00ffffff, // 0x1d520
-    0xfffc0000, // 0x1d540
-    0x00000fff, // 0x1d560
-    0xffffffc0, // 0x1d580
-    0xfc000000, // 0x1d5a0
-    0x000fffff, // 0x1d5c0
-    0xffffc000, // 0x1d5e0
-    0x000000ff, // 0x1d600
-    0x0ffffffc, // 0x1d620
-    0xffc00000, // 0x1d640
-    0x0000ffff, // 0x1d660
-    0xfffffc00, // 0x1d680
-    0x0000003f, // 0x1d6a0
-    0xf7fffffc, // 0x1d6c0
-    0xf0000003, // 0x1d6e0
-    0x0fdfffff, // 0x1d700
-    0xffc00000, // 0x1d720
-    0x003f7fff, // 0x1d740
-    0xffff0000, // 0x1d760
-    0x0000fdff, // 0x1d780
-    0xfffffc00, // 0x1d7a0
-    0x00000bf7, // 0x1d7c0
-    0x0
-};
-
 #ifndef __FFULLCASE__
 #define __FFULLCASE__
 typedef struct {unsigned int Count; FCh Chars[3];} FFullCase;
diff --git a/src/unicode.cpp b/src/unicode.cpp
index 72cfb48..fa42e8f 100644
--- a/src/unicode.cpp
+++ b/src/unicode.cpp
@@ -8,7 +8,7 @@ Foment
 #include <string.h>
 #include "foment.hpp"
 #include "unicode.hpp"
-#include "unidata.hpp"
+#include "unicase.hpp"
 
 unsigned char Utf8TrailingBytes[256] =
 {
@@ -334,41 +334,11 @@ FObject MakeStringS(FChS * ss, ulong_t ssl)
 }
 #endif // FOMENT_UNIX
 
-int WhitespaceP(FCh ch)
-{
-    // From:
-    // PropList-6.2.0.txt
-    // Date: 2012-05-23, 20:34:59 GMT [MD]
-
-    if (ch >= 0x0009 && ch <= 0x000D)
-        return(1);
-    else if (ch == 0x0020)
-        return(1);
-    else if (ch == 0x0085)
-        return(1);
-    else if (ch == 0x00A0)
-        return(1);
-    else if (ch == 0x1680)
-        return(1);
-    else if (ch == 0x180E)
-        return(1);
-    else if (ch >= 0x2000 && ch <= 0x200A)
-        return(1);
-    else if (ch == 0x2028)
-        return(1);
-    else if (ch == 0x2029)
-        return(1);
-    else if (ch == 0x202F)
-        return(1);
-    else if (ch == 0x205F)
-        return(1);
-    else if (ch == 0x3000)
-        return(1);
-
-    return(0);
-}
-
+#ifdef FOMENT_DEBUG
+static int32_t DigitValueInternal(FCh ch)
+#else // FOMENT_DEBUG
 int32_t DigitValue(FCh ch)
+#endif // FOMENT_DEBUG
 {
     // From:
     // DerivedNumericType-6.2.0.txt
@@ -573,339 +543,24 @@ int32_t DigitValue(FCh ch)
     return(-1);
 }
 
-static inline unsigned int MapCh(const unsigned int * mp, FCh bs, FCh ch)
-{
-    FAssert(ch >= bs);
-
-    ch -= bs;
-    return(mp[ch / 32] & (1 << (ch % 32)));
-}
-
-unsigned int AlphabeticP(FCh ch)
+#ifdef FOMENT_DEBUG
+int32_t DigitValue(FCh ch)
 {
-    // From:
-    // DerivedCoreProperties-6.2.0.txt
-    // Date: 2012-05-20, 00:42:31 GMT [MD]
-
-    switch (ch >> 12)
+    int32_t dv = DigitValueInternal(ch);
+    if (dv >= 0)
     {
-    case 0x00:
-    case 0x01:
-        return(MapCh(Alphabetic0x0000To0x1fff, 0, ch));
-
-    case 0x02:
-        if (ch >= 0x2060 && ch <= 0x219F)
-            return(MapCh(Alphabetic0x2060To0x219f, 0x2060, ch));
-        if (ch >= 0x24A0 && ch <= 0x24FF)
-            return(MapCh(Alphabetic0x24a0To0x24ff, 0x24A0, ch));
-        if (ch >= 0x2C00 && ch <= 0x2E3F)
-            return(MapCh(Alphabetic0x2c00To0x2e3f, 0x2C00, ch));
-        break;
-
-    case 0x03:
-        if (ch >= 0x3000 && ch <= 0x31FF)
-            return(MapCh(Alphabetic0x3000To0x31ff, 0x3000, ch));
-
-        // No break.
-
-    case 0x04:
-        if (ch >= 0x3400 && ch <= 0x4DB5)
-            return(1);
-
-        // No break.
-
-    case 0x05:
-    case 0x06:
-    case 0x07:
-    case 0x08:
-    case 0x09:
-        if (ch >= 0x4E00 && ch <= 0x9FCC)
-            return(1);
-        break;
-
-    case 0x0A:
-        if (ch >= 0xA000 && ch <= 0xA48C)
-            return(1);
-        if (ch >= 0xA480 && ch <= 0xABFF)
-            return(MapCh(Alphabetic0xa480To0xabff, 0xA480, ch));
-
-        // No break.
-
-    case 0x0B:
-    case 0x0C:
-    case 0x0D:
-        if (ch >= 0xAC00 && ch <= 0xD7A3)
-            return(1);
-        if (ch >= 0xD7A0 && ch <= 0xD7FF)
-            return(MapCh(Alphabetic0xd7a0To0xd7ff, 0xD7A0, ch));
-        break;
-
-    case 0x0E:
-        break;
-
-    case 0x0F:
-    case 0x10:
-        if (ch >= 0xF900 && ch <= 0x1049F)
-            return(MapCh(Alphabetic0xf900To0x1049f, 0xF900, ch));
-        if (ch >= 0x10800 && ch <=0x10C5F)
-            return(MapCh(Alphabetic0x10800To0x10c5f, 0x10800, ch));
-        break;
-
-    case 0x11:
-        if (ch >= 0x11000 && ch <= 0x111DF)
-            return(MapCh(Alphabetic0x11000To0x111df, 0x11000, ch));
-        if (ch >= 11680 && ch <= 0x116AF)
-            return(1);
-        break;
-
-    case 0x12:
-        if (ch >= 0x12000 && ch <= 0x1236E)
-            return(1);
-        if (ch >= 0x12400 && ch <= 0x12462)
-            return(1);
-        break;
-
-    case 0x13:
-        if (ch >= 0x13000 && ch <= 0x1342E)
-            return(1);
-
-    case 0x14:
-    case 0x15:
-        break;
-
-    case 0x16:
-        if (ch >= 0x16800 && ch <= 0x16A38)
-            return(1);
-        if (ch >= 0x16F00 && ch <= 0x16F9F)
-            return(MapCh(Alphabetic0x16f00To0x16f9f, 0x16F00, ch));
-        break;
-
-    case 0x17:
-    case 0x18:
-    case 0x19:
-    case 0x1A:
-        break;
-
-    case 0x1B:
-        if (ch >= 0x1B000 && ch <= 0x1B001)
-            return(1);
-        break;
-
-    case 0x1C:
-        break;
-
-    case 0x1D:
-        if (ch >= 0x1D400 && ch <= 0x1D7DF)
-            return(MapCh(Alphabetic0x1d400To0x1d7df, 0x1D400, ch));
-        if (ch >= 0x1EE00 && ch <= 0x1EEBF)
-            return(MapCh(Alphabetic0x1ee00To0x1eebf, 0x1EE00, ch));
-        break;
-
-    case 0x1E:
-    case 0x1F:
-        break;
-
-    case 0x20:
-    case 0x21:
-    case 0x22:
-    case 0x23:
-    case 0x24:
-    case 0x25:
-    case 0x26:
-    case 0x27:
-    case 0x28:
-    case 0x29:
-    case 0x2A:
-        if (ch >= 0x20000 && ch <= 0x2A6D6)
-            return(1);
-
-        // No break.
-
-    case 0x2B:
-        if (ch >= 0x2A700 && ch <= 0x2B734)
-            return(1);
-        if (ch >= 0x2B740 && ch <= 0x2B81D)
-            return(1);
-        break;
-
-    case 0x2C:
-    case 0x2D:
-    case 0x2E:
-        break;
-
-    case 0x2F:
-        if (ch >= 0x2F800 && ch <= 0x2FA1D)
-            return(1);
-        break;
+        FAssert(DigitP(ch));
     }
-
-    return(0);
-}
-
-unsigned int UppercaseP(FCh ch)
-{
-    // From:
-    // DerivedCoreProperties-6.2.0.txt
-    // Date: 2012-05-20, 00:42:31 GMT [MD]
-
-    switch (ch >> 12)
+    else
     {
-    case 0x00:
-        if (ch <= 0x059F)
-            return(MapCh(Uppercase0x0000To0x059f, 0, ch));
-        break;
-
-    case 0x01:
-        if (ch >= 0x10A0 && ch <= 0x10DF)
-            return(MapCh(Uppercase0x10a0To0x10df, 0x10A0, ch));
-        if (ch >= 0x1E00 && ch <= 0x1FFF)
-            return(MapCh(Uppercase0x1e00To0x1fff, 0x1E00, ch));
-        break;
-
-    case 0x02:
-        if (ch >= 0x2100 && ch <= 0x219F)
-            return(MapCh(Uppercase0x2100To0x219f, 0x2100, ch));
-        if (ch >= 0x24B6 && ch <= 0x24CF)
-            return(1);
-        if (ch >= 0x2C00 && ch <= 0x2D3F)
-            return(MapCh(Uppercase0x2c00To0x2d3f, 0x2C00, ch));
-        break;
-
-    case 0x03:
-    case 0x04:
-    case 0x05:
-    case 0x06:
-    case 0x07:
-    case 0x08:
-    case 0x09:
-        break;
-
-    case 0x0A:
-        if (ch >= 0xA640 && ch <= 0xA7BF)
-            return(MapCh(Uppercase0xa640To0xa7bf, 0xA640, ch));
-        break;
-
-    case 0x0B:
-    case 0x0C:
-    case 0x0D:
-    case 0x0E:
-        break;
-
-    case 0x0F:
-        if (ch >= 0xFF21 && ch <= 0xFF3A)
-            return(1);
-        break;
-
-    case 0x10:
-        if (ch >= 0x10400 && ch <= 0x10427)
-            return(1);
-        break;
-
-    case 0x11:
-    case 0x12:
-    case 0x13:
-    case 0x14:
-    case 0x15:
-    case 0x16:
-    case 0x17:
-    case 0x18:
-    case 0x19:
-    case 0x1A:
-    case 0x1B:
-    case 0x1C:
-        break;
-
-    case 0x1D:
-        if (ch >= 0x1D400 && ch <= 0x1D7DF)
-            return(MapCh(Uppercase0x1d400To0x1d7df, 0x1D400, ch));
-        break;
+        if (DigitP(ch) != 0)
+            printf("DigitP != 0: %d %x\n", ch, ch);
+        //FAssert(DigitP(ch) == 0);
     }
-
-    return(0);
+    return(dv);
 }
+#endif // FOMENT_DEBUG
 
-unsigned int LowercaseP(FCh ch)
-{
-    // From:
-    // DerivedCoreProperties-6.2.0.txt
-    // Date: 2012-05-20, 00:42:31 GMT [MD]
-
-    switch (ch >> 12)
-    {
-    case 0x00:
-        if (ch <= 0x059F)
-            return(MapCh(Lowercase0x0000To0x059f, 0, ch));
-        break;
-
-    case 0x01:
-        if (ch >= 0x1D00 && ch <= 0x1FFF)
-            return(MapCh(Lowercase0x1d00To0x1fff, 0x1D00, ch));
-        break;
-
-    case 0x02:
-        if (ch >= 0x2060 && ch <= 0x219F)
-            return(MapCh(Lowercase0x2060To0x219f, 0x2060, ch));
-        if (ch >= 0x24D0 && ch <= 0x24E9)
-            return(1);
-        if (ch >= 0x2C20 && ch <= 0x2D3F)
-            return(MapCh(Lowercase0x2c20To0x2d3f, 0x2C20, ch));
-        break;
-
-    case 0x03:
-    case 0x04:
-    case 0x05:
-    case 0x06:
-    case 0x07:
-    case 0x08:
-    case 0x09:
-        break;
-
-    case 0x0A:
-        if (ch >= 0xA640 && ch <= 0xA7FF)
-            return(MapCh(Lowercase0xa640To0xa7ff, 0xA640, ch));
-        break;
-
-    case 0x0B:
-    case 0x0C:
-    case 0x0D:
-    case 0x0E:
-        break;
-
-    case 0x0F:
-        if (ch >= 0xFB00 && ch <= 0xFB06)
-            return(1);
-        if (ch >= 0xFB13 && ch <= 0xFB17)
-            return(1);
-        if (ch >= 0xFF41 && ch <= 0xFF5A)
-            return(1);
-        break;
-
-    case 0x10:
-        if (ch >= 0x10428 && ch <= 0x1044F)
-            return(1);
-        break;
-
-    case 0x11:
-    case 0x12:
-    case 0x13:
-    case 0x14:
-    case 0x15:
-    case 0x16:
-    case 0x17:
-    case 0x18:
-    case 0x19:
-    case 0x1A:
-    case 0x1B:
-    case 0x1C:
-        break;
-
-    case 0x1D:
-        if (ch >= 0x1D400 && ch <= 0x1D7DF)
-            return(MapCh(Lowercase0x1d400To0x1d7df, 0x1D400, ch));
-    }
-
-    return(0);
-}
 unsigned int CharFullfoldLength(FCh ch)
 {
     // From:
diff --git a/src/unicode.hpp b/src/unicode.hpp
index 0de6edb..9ee3bf3 100644
--- a/src/unicode.hpp
+++ b/src/unicode.hpp
@@ -40,8 +40,16 @@ inline FObject ConvertStringToUtf16(FObject s)
     return(ConvertStringToUtf16(AsString(s)->String, StringLength(s), 1, 0));
 }
 
-int WhitespaceP(FCh ch);
+typedef struct
+{
+    FCh Start;
+    FCh End; // Inclusive
+} FCharRange;
+
 int32_t DigitValue(FCh ch);
+unsigned int DigitP(FCh ch);
+
+int WhitespaceP(FCh ch);
 unsigned int AlphabeticP(FCh ch);
 unsigned int UppercaseP(FCh ch);
 unsigned int LowercaseP(FCh ch);
diff --git a/src/unicrng.hpp b/src/unicrng.hpp
new file mode 100644
index 0000000..8a6894b
--- /dev/null
+++ b/src/unicrng.hpp
@@ -0,0 +1,2898 @@
+/*
+
+Foment
+
+*/
+
+// Automatically generated unicode character ranges included by charsets.cpp.
+
+static FCharRange LowerCaseCharRange[662] =
+{
+    {0x61, 0x7a}, // 26
+    {0xaa, 0xaa}, // 1
+    {0xb5, 0xb5}, // 1
+    {0xba, 0xba}, // 1
+    {0xdf, 0xf6}, // 24
+    {0xf8, 0xff}, // 8
+    {0x101, 0x101}, // 1
+    {0x103, 0x103}, // 1
+    {0x105, 0x105}, // 1
+    {0x107, 0x107}, // 1
+    {0x109, 0x109}, // 1
+    {0x10b, 0x10b}, // 1
+    {0x10d, 0x10d}, // 1
+    {0x10f, 0x10f}, // 1
+    {0x111, 0x111}, // 1
+    {0x113, 0x113}, // 1
+    {0x115, 0x115}, // 1
+    {0x117, 0x117}, // 1
+    {0x119, 0x119}, // 1
+    {0x11b, 0x11b}, // 1
+    {0x11d, 0x11d}, // 1
+    {0x11f, 0x11f}, // 1
+    {0x121, 0x121}, // 1
+    {0x123, 0x123}, // 1
+    {0x125, 0x125}, // 1
+    {0x127, 0x127}, // 1
+    {0x129, 0x129}, // 1
+    {0x12b, 0x12b}, // 1
+    {0x12d, 0x12d}, // 1
+    {0x12f, 0x12f}, // 1
+    {0x131, 0x131}, // 1
+    {0x133, 0x133}, // 1
+    {0x135, 0x135}, // 1
+    {0x137, 0x138}, // 2
+    {0x13a, 0x13a}, // 1
+    {0x13c, 0x13c}, // 1
+    {0x13e, 0x13e}, // 1
+    {0x140, 0x140}, // 1
+    {0x142, 0x142}, // 1
+    {0x144, 0x144}, // 1
+    {0x146, 0x146}, // 1
+    {0x148, 0x149}, // 2
+    {0x14b, 0x14b}, // 1
+    {0x14d, 0x14d}, // 1
+    {0x14f, 0x14f}, // 1
+    {0x151, 0x151}, // 1
+    {0x153, 0x153}, // 1
+    {0x155, 0x155}, // 1
+    {0x157, 0x157}, // 1
+    {0x159, 0x159}, // 1
+    {0x15b, 0x15b}, // 1
+    {0x15d, 0x15d}, // 1
+    {0x15f, 0x15f}, // 1
+    {0x161, 0x161}, // 1
+    {0x163, 0x163}, // 1
+    {0x165, 0x165}, // 1
+    {0x167, 0x167}, // 1
+    {0x169, 0x169}, // 1
+    {0x16b, 0x16b}, // 1
+    {0x16d, 0x16d}, // 1
+    {0x16f, 0x16f}, // 1
+    {0x171, 0x171}, // 1
+    {0x173, 0x173}, // 1
+    {0x175, 0x175}, // 1
+    {0x177, 0x177}, // 1
+    {0x17a, 0x17a}, // 1
+    {0x17c, 0x17c}, // 1
+    {0x17e, 0x180}, // 3
+    {0x183, 0x183}, // 1
+    {0x185, 0x185}, // 1
+    {0x188, 0x188}, // 1
+    {0x18c, 0x18d}, // 2
+    {0x192, 0x192}, // 1
+    {0x195, 0x195}, // 1
+    {0x199, 0x19b}, // 3
+    {0x19e, 0x19e}, // 1
+    {0x1a1, 0x1a1}, // 1
+    {0x1a3, 0x1a3}, // 1
+    {0x1a5, 0x1a5}, // 1
+    {0x1a8, 0x1a8}, // 1
+    {0x1aa, 0x1ab}, // 2
+    {0x1ad, 0x1ad}, // 1
+    {0x1b0, 0x1b0}, // 1
+    {0x1b4, 0x1b4}, // 1
+    {0x1b6, 0x1b6}, // 1
+    {0x1b9, 0x1ba}, // 2
+    {0x1bd, 0x1bf}, // 3
+    {0x1c6, 0x1c6}, // 1
+    {0x1c9, 0x1c9}, // 1
+    {0x1cc, 0x1cc}, // 1
+    {0x1ce, 0x1ce}, // 1
+    {0x1d0, 0x1d0}, // 1
+    {0x1d2, 0x1d2}, // 1
+    {0x1d4, 0x1d4}, // 1
+    {0x1d6, 0x1d6}, // 1
+    {0x1d8, 0x1d8}, // 1
+    {0x1da, 0x1da}, // 1
+    {0x1dc, 0x1dd}, // 2
+    {0x1df, 0x1df}, // 1
+    {0x1e1, 0x1e1}, // 1
+    {0x1e3, 0x1e3}, // 1
+    {0x1e5, 0x1e5}, // 1
+    {0x1e7, 0x1e7}, // 1
+    {0x1e9, 0x1e9}, // 1
+    {0x1eb, 0x1eb}, // 1
+    {0x1ed, 0x1ed}, // 1
+    {0x1ef, 0x1f0}, // 2
+    {0x1f3, 0x1f3}, // 1
+    {0x1f5, 0x1f5}, // 1
+    {0x1f9, 0x1f9}, // 1
+    {0x1fb, 0x1fb}, // 1
+    {0x1fd, 0x1fd}, // 1
+    {0x1ff, 0x1ff}, // 1
+    {0x201, 0x201}, // 1
+    {0x203, 0x203}, // 1
+    {0x205, 0x205}, // 1
+    {0x207, 0x207}, // 1
+    {0x209, 0x209}, // 1
+    {0x20b, 0x20b}, // 1
+    {0x20d, 0x20d}, // 1
+    {0x20f, 0x20f}, // 1
+    {0x211, 0x211}, // 1
+    {0x213, 0x213}, // 1
+    {0x215, 0x215}, // 1
+    {0x217, 0x217}, // 1
+    {0x219, 0x219}, // 1
+    {0x21b, 0x21b}, // 1
+    {0x21d, 0x21d}, // 1
+    {0x21f, 0x21f}, // 1
+    {0x221, 0x221}, // 1
+    {0x223, 0x223}, // 1
+    {0x225, 0x225}, // 1
+    {0x227, 0x227}, // 1
+    {0x229, 0x229}, // 1
+    {0x22b, 0x22b}, // 1
+    {0x22d, 0x22d}, // 1
+    {0x22f, 0x22f}, // 1
+    {0x231, 0x231}, // 1
+    {0x233, 0x239}, // 7
+    {0x23c, 0x23c}, // 1
+    {0x23f, 0x240}, // 2
+    {0x242, 0x242}, // 1
+    {0x247, 0x247}, // 1
+    {0x249, 0x249}, // 1
+    {0x24b, 0x24b}, // 1
+    {0x24d, 0x24d}, // 1
+    {0x24f, 0x293}, // 69
+    {0x295, 0x2af}, // 27
+    {0x2b0, 0x2b8}, // 9
+    {0x2c0, 0x2c1}, // 2
+    {0x2e0, 0x2e4}, // 5
+    {0x345, 0x345}, // 1
+    {0x371, 0x371}, // 1
+    {0x373, 0x373}, // 1
+    {0x377, 0x377}, // 1
+    {0x37a, 0x37a}, // 1
+    {0x37b, 0x37d}, // 3
+    {0x390, 0x390}, // 1
+    {0x3ac, 0x3ce}, // 35
+    {0x3d0, 0x3d1}, // 2
+    {0x3d5, 0x3d7}, // 3
+    {0x3d9, 0x3d9}, // 1
+    {0x3db, 0x3db}, // 1
+    {0x3dd, 0x3dd}, // 1
+    {0x3df, 0x3df}, // 1
+    {0x3e1, 0x3e1}, // 1
+    {0x3e3, 0x3e3}, // 1
+    {0x3e5, 0x3e5}, // 1
+    {0x3e7, 0x3e7}, // 1
+    {0x3e9, 0x3e9}, // 1
+    {0x3eb, 0x3eb}, // 1
+    {0x3ed, 0x3ed}, // 1
+    {0x3ef, 0x3f3}, // 5
+    {0x3f5, 0x3f5}, // 1
+    {0x3f8, 0x3f8}, // 1
+    {0x3fb, 0x3fc}, // 2
+    {0x430, 0x45f}, // 48
+    {0x461, 0x461}, // 1
+    {0x463, 0x463}, // 1
+    {0x465, 0x465}, // 1
+    {0x467, 0x467}, // 1
+    {0x469, 0x469}, // 1
+    {0x46b, 0x46b}, // 1
+    {0x46d, 0x46d}, // 1
+    {0x46f, 0x46f}, // 1
+    {0x471, 0x471}, // 1
+    {0x473, 0x473}, // 1
+    {0x475, 0x475}, // 1
+    {0x477, 0x477}, // 1
+    {0x479, 0x479}, // 1
+    {0x47b, 0x47b}, // 1
+    {0x47d, 0x47d}, // 1
+    {0x47f, 0x47f}, // 1
+    {0x481, 0x481}, // 1
+    {0x48b, 0x48b}, // 1
+    {0x48d, 0x48d}, // 1
+    {0x48f, 0x48f}, // 1
+    {0x491, 0x491}, // 1
+    {0x493, 0x493}, // 1
+    {0x495, 0x495}, // 1
+    {0x497, 0x497}, // 1
+    {0x499, 0x499}, // 1
+    {0x49b, 0x49b}, // 1
+    {0x49d, 0x49d}, // 1
+    {0x49f, 0x49f}, // 1
+    {0x4a1, 0x4a1}, // 1
+    {0x4a3, 0x4a3}, // 1
+    {0x4a5, 0x4a5}, // 1
+    {0x4a7, 0x4a7}, // 1
+    {0x4a9, 0x4a9}, // 1
+    {0x4ab, 0x4ab}, // 1
+    {0x4ad, 0x4ad}, // 1
+    {0x4af, 0x4af}, // 1
+    {0x4b1, 0x4b1}, // 1
+    {0x4b3, 0x4b3}, // 1
+    {0x4b5, 0x4b5}, // 1
+    {0x4b7, 0x4b7}, // 1
+    {0x4b9, 0x4b9}, // 1
+    {0x4bb, 0x4bb}, // 1
+    {0x4bd, 0x4bd}, // 1
+    {0x4bf, 0x4bf}, // 1
+    {0x4c2, 0x4c2}, // 1
+    {0x4c4, 0x4c4}, // 1
+    {0x4c6, 0x4c6}, // 1
+    {0x4c8, 0x4c8}, // 1
+    {0x4ca, 0x4ca}, // 1
+    {0x4cc, 0x4cc}, // 1
+    {0x4ce, 0x4cf}, // 2
+    {0x4d1, 0x4d1}, // 1
+    {0x4d3, 0x4d3}, // 1
+    {0x4d5, 0x4d5}, // 1
+    {0x4d7, 0x4d7}, // 1
+    {0x4d9, 0x4d9}, // 1
+    {0x4db, 0x4db}, // 1
+    {0x4dd, 0x4dd}, // 1
+    {0x4df, 0x4df}, // 1
+    {0x4e1, 0x4e1}, // 1
+    {0x4e3, 0x4e3}, // 1
+    {0x4e5, 0x4e5}, // 1
+    {0x4e7, 0x4e7}, // 1
+    {0x4e9, 0x4e9}, // 1
+    {0x4eb, 0x4eb}, // 1
+    {0x4ed, 0x4ed}, // 1
+    {0x4ef, 0x4ef}, // 1
+    {0x4f1, 0x4f1}, // 1
+    {0x4f3, 0x4f3}, // 1
+    {0x4f5, 0x4f5}, // 1
+    {0x4f7, 0x4f7}, // 1
+    {0x4f9, 0x4f9}, // 1
+    {0x4fb, 0x4fb}, // 1
+    {0x4fd, 0x4fd}, // 1
+    {0x4ff, 0x4ff}, // 1
+    {0x501, 0x501}, // 1
+    {0x503, 0x503}, // 1
+    {0x505, 0x505}, // 1
+    {0x507, 0x507}, // 1
+    {0x509, 0x509}, // 1
+    {0x50b, 0x50b}, // 1
+    {0x50d, 0x50d}, // 1
+    {0x50f, 0x50f}, // 1
+    {0x511, 0x511}, // 1
+    {0x513, 0x513}, // 1
+    {0x515, 0x515}, // 1
+    {0x517, 0x517}, // 1
+    {0x519, 0x519}, // 1
+    {0x51b, 0x51b}, // 1
+    {0x51d, 0x51d}, // 1
+    {0x51f, 0x51f}, // 1
+    {0x521, 0x521}, // 1
+    {0x523, 0x523}, // 1
+    {0x525, 0x525}, // 1
+    {0x527, 0x527}, // 1
+    {0x529, 0x529}, // 1
+    {0x52b, 0x52b}, // 1
+    {0x52d, 0x52d}, // 1
+    {0x52f, 0x52f}, // 1
+    {0x560, 0x588}, // 41
+    {0x10d0, 0x10fa}, // 43
+    {0x10fd, 0x10ff}, // 3
+    {0x13f8, 0x13fd}, // 6
+    {0x1c80, 0x1c88}, // 9
+    {0x1d00, 0x1d2b}, // 44
+    {0x1d2c, 0x1d6a}, // 63
+    {0x1d6b, 0x1d77}, // 13
+    {0x1d78, 0x1d78}, // 1
+    {0x1d79, 0x1d9a}, // 34
+    {0x1d9b, 0x1dbf}, // 37
+    {0x1e01, 0x1e01}, // 1
+    {0x1e03, 0x1e03}, // 1
+    {0x1e05, 0x1e05}, // 1
+    {0x1e07, 0x1e07}, // 1
+    {0x1e09, 0x1e09}, // 1
+    {0x1e0b, 0x1e0b}, // 1
+    {0x1e0d, 0x1e0d}, // 1
+    {0x1e0f, 0x1e0f}, // 1
+    {0x1e11, 0x1e11}, // 1
+    {0x1e13, 0x1e13}, // 1
+    {0x1e15, 0x1e15}, // 1
+    {0x1e17, 0x1e17}, // 1
+    {0x1e19, 0x1e19}, // 1
+    {0x1e1b, 0x1e1b}, // 1
+    {0x1e1d, 0x1e1d}, // 1
+    {0x1e1f, 0x1e1f}, // 1
+    {0x1e21, 0x1e21}, // 1
+    {0x1e23, 0x1e23}, // 1
+    {0x1e25, 0x1e25}, // 1
+    {0x1e27, 0x1e27}, // 1
+    {0x1e29, 0x1e29}, // 1
+    {0x1e2b, 0x1e2b}, // 1
+    {0x1e2d, 0x1e2d}, // 1
+    {0x1e2f, 0x1e2f}, // 1
+    {0x1e31, 0x1e31}, // 1
+    {0x1e33, 0x1e33}, // 1
+    {0x1e35, 0x1e35}, // 1
+    {0x1e37, 0x1e37}, // 1
+    {0x1e39, 0x1e39}, // 1
+    {0x1e3b, 0x1e3b}, // 1
+    {0x1e3d, 0x1e3d}, // 1
+    {0x1e3f, 0x1e3f}, // 1
+    {0x1e41, 0x1e41}, // 1
+    {0x1e43, 0x1e43}, // 1
+    {0x1e45, 0x1e45}, // 1
+    {0x1e47, 0x1e47}, // 1
+    {0x1e49, 0x1e49}, // 1
+    {0x1e4b, 0x1e4b}, // 1
+    {0x1e4d, 0x1e4d}, // 1
+    {0x1e4f, 0x1e4f}, // 1
+    {0x1e51, 0x1e51}, // 1
+    {0x1e53, 0x1e53}, // 1
+    {0x1e55, 0x1e55}, // 1
+    {0x1e57, 0x1e57}, // 1
+    {0x1e59, 0x1e59}, // 1
+    {0x1e5b, 0x1e5b}, // 1
+    {0x1e5d, 0x1e5d}, // 1
+    {0x1e5f, 0x1e5f}, // 1
+    {0x1e61, 0x1e61}, // 1
+    {0x1e63, 0x1e63}, // 1
+    {0x1e65, 0x1e65}, // 1
+    {0x1e67, 0x1e67}, // 1
+    {0x1e69, 0x1e69}, // 1
+    {0x1e6b, 0x1e6b}, // 1
+    {0x1e6d, 0x1e6d}, // 1
+    {0x1e6f, 0x1e6f}, // 1
+    {0x1e71, 0x1e71}, // 1
+    {0x1e73, 0x1e73}, // 1
+    {0x1e75, 0x1e75}, // 1
+    {0x1e77, 0x1e77}, // 1
+    {0x1e79, 0x1e79}, // 1
+    {0x1e7b, 0x1e7b}, // 1
+    {0x1e7d, 0x1e7d}, // 1
+    {0x1e7f, 0x1e7f}, // 1
+    {0x1e81, 0x1e81}, // 1
+    {0x1e83, 0x1e83}, // 1
+    {0x1e85, 0x1e85}, // 1
+    {0x1e87, 0x1e87}, // 1
+    {0x1e89, 0x1e89}, // 1
+    {0x1e8b, 0x1e8b}, // 1
+    {0x1e8d, 0x1e8d}, // 1
+    {0x1e8f, 0x1e8f}, // 1
+    {0x1e91, 0x1e91}, // 1
+    {0x1e93, 0x1e93}, // 1
+    {0x1e95, 0x1e9d}, // 9
+    {0x1e9f, 0x1e9f}, // 1
+    {0x1ea1, 0x1ea1}, // 1
+    {0x1ea3, 0x1ea3}, // 1
+    {0x1ea5, 0x1ea5}, // 1
+    {0x1ea7, 0x1ea7}, // 1
+    {0x1ea9, 0x1ea9}, // 1
+    {0x1eab, 0x1eab}, // 1
+    {0x1ead, 0x1ead}, // 1
+    {0x1eaf, 0x1eaf}, // 1
+    {0x1eb1, 0x1eb1}, // 1
+    {0x1eb3, 0x1eb3}, // 1
+    {0x1eb5, 0x1eb5}, // 1
+    {0x1eb7, 0x1eb7}, // 1
+    {0x1eb9, 0x1eb9}, // 1
+    {0x1ebb, 0x1ebb}, // 1
+    {0x1ebd, 0x1ebd}, // 1
+    {0x1ebf, 0x1ebf}, // 1
+    {0x1ec1, 0x1ec1}, // 1
+    {0x1ec3, 0x1ec3}, // 1
+    {0x1ec5, 0x1ec5}, // 1
+    {0x1ec7, 0x1ec7}, // 1
+    {0x1ec9, 0x1ec9}, // 1
+    {0x1ecb, 0x1ecb}, // 1
+    {0x1ecd, 0x1ecd}, // 1
+    {0x1ecf, 0x1ecf}, // 1
+    {0x1ed1, 0x1ed1}, // 1
+    {0x1ed3, 0x1ed3}, // 1
+    {0x1ed5, 0x1ed5}, // 1
+    {0x1ed7, 0x1ed7}, // 1
+    {0x1ed9, 0x1ed9}, // 1
+    {0x1edb, 0x1edb}, // 1
+    {0x1edd, 0x1edd}, // 1
+    {0x1edf, 0x1edf}, // 1
+    {0x1ee1, 0x1ee1}, // 1
+    {0x1ee3, 0x1ee3}, // 1
+    {0x1ee5, 0x1ee5}, // 1
+    {0x1ee7, 0x1ee7}, // 1
+    {0x1ee9, 0x1ee9}, // 1
+    {0x1eeb, 0x1eeb}, // 1
+    {0x1eed, 0x1eed}, // 1
+    {0x1eef, 0x1eef}, // 1
+    {0x1ef1, 0x1ef1}, // 1
+    {0x1ef3, 0x1ef3}, // 1
+    {0x1ef5, 0x1ef5}, // 1
+    {0x1ef7, 0x1ef7}, // 1
+    {0x1ef9, 0x1ef9}, // 1
+    {0x1efb, 0x1efb}, // 1
+    {0x1efd, 0x1efd}, // 1
+    {0x1eff, 0x1f07}, // 9
+    {0x1f10, 0x1f15}, // 6
+    {0x1f20, 0x1f27}, // 8
+    {0x1f30, 0x1f37}, // 8
+    {0x1f40, 0x1f45}, // 6
+    {0x1f50, 0x1f57}, // 8
+    {0x1f60, 0x1f67}, // 8
+    {0x1f70, 0x1f7d}, // 14
+    {0x1f80, 0x1f87}, // 8
+    {0x1f90, 0x1f97}, // 8
+    {0x1fa0, 0x1fa7}, // 8
+    {0x1fb0, 0x1fb4}, // 5
+    {0x1fb6, 0x1fb7}, // 2
+    {0x1fbe, 0x1fbe}, // 1
+    {0x1fc2, 0x1fc4}, // 3
+    {0x1fc6, 0x1fc7}, // 2
+    {0x1fd0, 0x1fd3}, // 4
+    {0x1fd6, 0x1fd7}, // 2
+    {0x1fe0, 0x1fe7}, // 8
+    {0x1ff2, 0x1ff4}, // 3
+    {0x1ff6, 0x1ff7}, // 2
+    {0x2071, 0x2071}, // 1
+    {0x207f, 0x207f}, // 1
+    {0x2090, 0x209c}, // 13
+    {0x210a, 0x210a}, // 1
+    {0x210e, 0x210f}, // 2
+    {0x2113, 0x2113}, // 1
+    {0x212f, 0x212f}, // 1
+    {0x2134, 0x2134}, // 1
+    {0x2139, 0x2139}, // 1
+    {0x213c, 0x213d}, // 2
+    {0x2146, 0x2149}, // 4
+    {0x214e, 0x214e}, // 1
+    {0x2170, 0x217f}, // 16
+    {0x2184, 0x2184}, // 1
+    {0x24d0, 0x24e9}, // 26
+    {0x2c30, 0x2c5e}, // 47
+    {0x2c61, 0x2c61}, // 1
+    {0x2c65, 0x2c66}, // 2
+    {0x2c68, 0x2c68}, // 1
+    {0x2c6a, 0x2c6a}, // 1
+    {0x2c6c, 0x2c6c}, // 1
+    {0x2c71, 0x2c71}, // 1
+    {0x2c73, 0x2c74}, // 2
+    {0x2c76, 0x2c7b}, // 6
+    {0x2c7c, 0x2c7d}, // 2
+    {0x2c81, 0x2c81}, // 1
+    {0x2c83, 0x2c83}, // 1
+    {0x2c85, 0x2c85}, // 1
+    {0x2c87, 0x2c87}, // 1
+    {0x2c89, 0x2c89}, // 1
+    {0x2c8b, 0x2c8b}, // 1
+    {0x2c8d, 0x2c8d}, // 1
+    {0x2c8f, 0x2c8f}, // 1
+    {0x2c91, 0x2c91}, // 1
+    {0x2c93, 0x2c93}, // 1
+    {0x2c95, 0x2c95}, // 1
+    {0x2c97, 0x2c97}, // 1
+    {0x2c99, 0x2c99}, // 1
+    {0x2c9b, 0x2c9b}, // 1
+    {0x2c9d, 0x2c9d}, // 1
+    {0x2c9f, 0x2c9f}, // 1
+    {0x2ca1, 0x2ca1}, // 1
+    {0x2ca3, 0x2ca3}, // 1
+    {0x2ca5, 0x2ca5}, // 1
+    {0x2ca7, 0x2ca7}, // 1
+    {0x2ca9, 0x2ca9}, // 1
+    {0x2cab, 0x2cab}, // 1
+    {0x2cad, 0x2cad}, // 1
+    {0x2caf, 0x2caf}, // 1
+    {0x2cb1, 0x2cb1}, // 1
+    {0x2cb3, 0x2cb3}, // 1
+    {0x2cb5, 0x2cb5}, // 1
+    {0x2cb7, 0x2cb7}, // 1
+    {0x2cb9, 0x2cb9}, // 1
+    {0x2cbb, 0x2cbb}, // 1
+    {0x2cbd, 0x2cbd}, // 1
+    {0x2cbf, 0x2cbf}, // 1
+    {0x2cc1, 0x2cc1}, // 1
+    {0x2cc3, 0x2cc3}, // 1
+    {0x2cc5, 0x2cc5}, // 1
+    {0x2cc7, 0x2cc7}, // 1
+    {0x2cc9, 0x2cc9}, // 1
+    {0x2ccb, 0x2ccb}, // 1
+    {0x2ccd, 0x2ccd}, // 1
+    {0x2ccf, 0x2ccf}, // 1
+    {0x2cd1, 0x2cd1}, // 1
+    {0x2cd3, 0x2cd3}, // 1
+    {0x2cd5, 0x2cd5}, // 1
+    {0x2cd7, 0x2cd7}, // 1
+    {0x2cd9, 0x2cd9}, // 1
+    {0x2cdb, 0x2cdb}, // 1
+    {0x2cdd, 0x2cdd}, // 1
+    {0x2cdf, 0x2cdf}, // 1
+    {0x2ce1, 0x2ce1}, // 1
+    {0x2ce3, 0x2ce4}, // 2
+    {0x2cec, 0x2cec}, // 1
+    {0x2cee, 0x2cee}, // 1
+    {0x2cf3, 0x2cf3}, // 1
+    {0x2d00, 0x2d25}, // 38
+    {0x2d27, 0x2d27}, // 1
+    {0x2d2d, 0x2d2d}, // 1
+    {0xa641, 0xa641}, // 1
+    {0xa643, 0xa643}, // 1
+    {0xa645, 0xa645}, // 1
+    {0xa647, 0xa647}, // 1
+    {0xa649, 0xa649}, // 1
+    {0xa64b, 0xa64b}, // 1
+    {0xa64d, 0xa64d}, // 1
+    {0xa64f, 0xa64f}, // 1
+    {0xa651, 0xa651}, // 1
+    {0xa653, 0xa653}, // 1
+    {0xa655, 0xa655}, // 1
+    {0xa657, 0xa657}, // 1
+    {0xa659, 0xa659}, // 1
+    {0xa65b, 0xa65b}, // 1
+    {0xa65d, 0xa65d}, // 1
+    {0xa65f, 0xa65f}, // 1
+    {0xa661, 0xa661}, // 1
+    {0xa663, 0xa663}, // 1
+    {0xa665, 0xa665}, // 1
+    {0xa667, 0xa667}, // 1
+    {0xa669, 0xa669}, // 1
+    {0xa66b, 0xa66b}, // 1
+    {0xa66d, 0xa66d}, // 1
+    {0xa681, 0xa681}, // 1
+    {0xa683, 0xa683}, // 1
+    {0xa685, 0xa685}, // 1
+    {0xa687, 0xa687}, // 1
+    {0xa689, 0xa689}, // 1
+    {0xa68b, 0xa68b}, // 1
+    {0xa68d, 0xa68d}, // 1
+    {0xa68f, 0xa68f}, // 1
+    {0xa691, 0xa691}, // 1
+    {0xa693, 0xa693}, // 1
+    {0xa695, 0xa695}, // 1
+    {0xa697, 0xa697}, // 1
+    {0xa699, 0xa699}, // 1
+    {0xa69b, 0xa69b}, // 1
+    {0xa69c, 0xa69d}, // 2
+    {0xa723, 0xa723}, // 1
+    {0xa725, 0xa725}, // 1
+    {0xa727, 0xa727}, // 1
+    {0xa729, 0xa729}, // 1
+    {0xa72b, 0xa72b}, // 1
+    {0xa72d, 0xa72d}, // 1
+    {0xa72f, 0xa731}, // 3
+    {0xa733, 0xa733}, // 1
+    {0xa735, 0xa735}, // 1
+    {0xa737, 0xa737}, // 1
+    {0xa739, 0xa739}, // 1
+    {0xa73b, 0xa73b}, // 1
+    {0xa73d, 0xa73d}, // 1
+    {0xa73f, 0xa73f}, // 1
+    {0xa741, 0xa741}, // 1
+    {0xa743, 0xa743}, // 1
+    {0xa745, 0xa745}, // 1
+    {0xa747, 0xa747}, // 1
+    {0xa749, 0xa749}, // 1
+    {0xa74b, 0xa74b}, // 1
+    {0xa74d, 0xa74d}, // 1
+    {0xa74f, 0xa74f}, // 1
+    {0xa751, 0xa751}, // 1
+    {0xa753, 0xa753}, // 1
+    {0xa755, 0xa755}, // 1
+    {0xa757, 0xa757}, // 1
+    {0xa759, 0xa759}, // 1
+    {0xa75b, 0xa75b}, // 1
+    {0xa75d, 0xa75d}, // 1
+    {0xa75f, 0xa75f}, // 1
+    {0xa761, 0xa761}, // 1
+    {0xa763, 0xa763}, // 1
+    {0xa765, 0xa765}, // 1
+    {0xa767, 0xa767}, // 1
+    {0xa769, 0xa769}, // 1
+    {0xa76b, 0xa76b}, // 1
+    {0xa76d, 0xa76d}, // 1
+    {0xa76f, 0xa76f}, // 1
+    {0xa770, 0xa770}, // 1
+    {0xa771, 0xa778}, // 8
+    {0xa77a, 0xa77a}, // 1
+    {0xa77c, 0xa77c}, // 1
+    {0xa77f, 0xa77f}, // 1
+    {0xa781, 0xa781}, // 1
+    {0xa783, 0xa783}, // 1
+    {0xa785, 0xa785}, // 1
+    {0xa787, 0xa787}, // 1
+    {0xa78c, 0xa78c}, // 1
+    {0xa78e, 0xa78e}, // 1
+    {0xa791, 0xa791}, // 1
+    {0xa793, 0xa795}, // 3
+    {0xa797, 0xa797}, // 1
+    {0xa799, 0xa799}, // 1
+    {0xa79b, 0xa79b}, // 1
+    {0xa79d, 0xa79d}, // 1
+    {0xa79f, 0xa79f}, // 1
+    {0xa7a1, 0xa7a1}, // 1
+    {0xa7a3, 0xa7a3}, // 1
+    {0xa7a5, 0xa7a5}, // 1
+    {0xa7a7, 0xa7a7}, // 1
+    {0xa7a9, 0xa7a9}, // 1
+    {0xa7af, 0xa7af}, // 1
+    {0xa7b5, 0xa7b5}, // 1
+    {0xa7b7, 0xa7b7}, // 1
+    {0xa7b9, 0xa7b9}, // 1
+    {0xa7bb, 0xa7bb}, // 1
+    {0xa7bd, 0xa7bd}, // 1
+    {0xa7bf, 0xa7bf}, // 1
+    {0xa7c3, 0xa7c3}, // 1
+    {0xa7f8, 0xa7f9}, // 2
+    {0xa7fa, 0xa7fa}, // 1
+    {0xab30, 0xab5a}, // 43
+    {0xab5c, 0xab5f}, // 4
+    {0xab60, 0xab67}, // 8
+    {0xab70, 0xabbf}, // 80
+    {0xfb00, 0xfb06}, // 7
+    {0xfb13, 0xfb17}, // 5
+    {0xff41, 0xff5a}, // 26
+    {0x10428, 0x1044f}, // 40
+    {0x104d8, 0x104fb}, // 36
+    {0x10cc0, 0x10cf2}, // 51
+    {0x118c0, 0x118df}, // 32
+    {0x16e60, 0x16e7f}, // 32
+    {0x1d41a, 0x1d433}, // 26
+    {0x1d44e, 0x1d454}, // 7
+    {0x1d456, 0x1d467}, // 18
+    {0x1d482, 0x1d49b}, // 26
+    {0x1d4b6, 0x1d4b9}, // 4
+    {0x1d4bb, 0x1d4bb}, // 1
+    {0x1d4bd, 0x1d4c3}, // 7
+    {0x1d4c5, 0x1d4cf}, // 11
+    {0x1d4ea, 0x1d503}, // 26
+    {0x1d51e, 0x1d537}, // 26
+    {0x1d552, 0x1d56b}, // 26
+    {0x1d586, 0x1d59f}, // 26
+    {0x1d5ba, 0x1d5d3}, // 26
+    {0x1d5ee, 0x1d607}, // 26
+    {0x1d622, 0x1d63b}, // 26
+    {0x1d656, 0x1d66f}, // 26
+    {0x1d68a, 0x1d6a5}, // 28
+    {0x1d6c2, 0x1d6da}, // 25
+    {0x1d6dc, 0x1d6e1}, // 6
+    {0x1d6fc, 0x1d714}, // 25
+    {0x1d716, 0x1d71b}, // 6
+    {0x1d736, 0x1d74e}, // 25
+    {0x1d750, 0x1d755}, // 6
+    {0x1d770, 0x1d788}, // 25
+    {0x1d78a, 0x1d78f}, // 6
+    {0x1d7aa, 0x1d7c2}, // 25
+    {0x1d7c4, 0x1d7c9}, // 6
+    {0x1d7cb, 0x1d7cb}, // 1
+    {0x1e922, 0x1e943}, // 34
+};
+
+static FCharRange UpperCaseCharRange[641] =
+{
+    {0x41, 0x5a}, // 26
+    {0xc0, 0xd6}, // 23
+    {0xd8, 0xde}, // 7
+    {0x100, 0x100}, // 1
+    {0x102, 0x102}, // 1
+    {0x104, 0x104}, // 1
+    {0x106, 0x106}, // 1
+    {0x108, 0x108}, // 1
+    {0x10a, 0x10a}, // 1
+    {0x10c, 0x10c}, // 1
+    {0x10e, 0x10e}, // 1
+    {0x110, 0x110}, // 1
+    {0x112, 0x112}, // 1
+    {0x114, 0x114}, // 1
+    {0x116, 0x116}, // 1
+    {0x118, 0x118}, // 1
+    {0x11a, 0x11a}, // 1
+    {0x11c, 0x11c}, // 1
+    {0x11e, 0x11e}, // 1
+    {0x120, 0x120}, // 1
+    {0x122, 0x122}, // 1
+    {0x124, 0x124}, // 1
+    {0x126, 0x126}, // 1
+    {0x128, 0x128}, // 1
+    {0x12a, 0x12a}, // 1
+    {0x12c, 0x12c}, // 1
+    {0x12e, 0x12e}, // 1
+    {0x130, 0x130}, // 1
+    {0x132, 0x132}, // 1
+    {0x134, 0x134}, // 1
+    {0x136, 0x136}, // 1
+    {0x139, 0x139}, // 1
+    {0x13b, 0x13b}, // 1
+    {0x13d, 0x13d}, // 1
+    {0x13f, 0x13f}, // 1
+    {0x141, 0x141}, // 1
+    {0x143, 0x143}, // 1
+    {0x145, 0x145}, // 1
+    {0x147, 0x147}, // 1
+    {0x14a, 0x14a}, // 1
+    {0x14c, 0x14c}, // 1
+    {0x14e, 0x14e}, // 1
+    {0x150, 0x150}, // 1
+    {0x152, 0x152}, // 1
+    {0x154, 0x154}, // 1
+    {0x156, 0x156}, // 1
+    {0x158, 0x158}, // 1
+    {0x15a, 0x15a}, // 1
+    {0x15c, 0x15c}, // 1
+    {0x15e, 0x15e}, // 1
+    {0x160, 0x160}, // 1
+    {0x162, 0x162}, // 1
+    {0x164, 0x164}, // 1
+    {0x166, 0x166}, // 1
+    {0x168, 0x168}, // 1
+    {0x16a, 0x16a}, // 1
+    {0x16c, 0x16c}, // 1
+    {0x16e, 0x16e}, // 1
+    {0x170, 0x170}, // 1
+    {0x172, 0x172}, // 1
+    {0x174, 0x174}, // 1
+    {0x176, 0x176}, // 1
+    {0x178, 0x179}, // 2
+    {0x17b, 0x17b}, // 1
+    {0x17d, 0x17d}, // 1
+    {0x181, 0x182}, // 2
+    {0x184, 0x184}, // 1
+    {0x186, 0x187}, // 2
+    {0x189, 0x18b}, // 3
+    {0x18e, 0x191}, // 4
+    {0x193, 0x194}, // 2
+    {0x196, 0x198}, // 3
+    {0x19c, 0x19d}, // 2
+    {0x19f, 0x1a0}, // 2
+    {0x1a2, 0x1a2}, // 1
+    {0x1a4, 0x1a4}, // 1
+    {0x1a6, 0x1a7}, // 2
+    {0x1a9, 0x1a9}, // 1
+    {0x1ac, 0x1ac}, // 1
+    {0x1ae, 0x1af}, // 2
+    {0x1b1, 0x1b3}, // 3
+    {0x1b5, 0x1b5}, // 1
+    {0x1b7, 0x1b8}, // 2
+    {0x1bc, 0x1bc}, // 1
+    {0x1c4, 0x1c4}, // 1
+    {0x1c7, 0x1c7}, // 1
+    {0x1ca, 0x1ca}, // 1
+    {0x1cd, 0x1cd}, // 1
+    {0x1cf, 0x1cf}, // 1
+    {0x1d1, 0x1d1}, // 1
+    {0x1d3, 0x1d3}, // 1
+    {0x1d5, 0x1d5}, // 1
+    {0x1d7, 0x1d7}, // 1
+    {0x1d9, 0x1d9}, // 1
+    {0x1db, 0x1db}, // 1
+    {0x1de, 0x1de}, // 1
+    {0x1e0, 0x1e0}, // 1
+    {0x1e2, 0x1e2}, // 1
+    {0x1e4, 0x1e4}, // 1
+    {0x1e6, 0x1e6}, // 1
+    {0x1e8, 0x1e8}, // 1
+    {0x1ea, 0x1ea}, // 1
+    {0x1ec, 0x1ec}, // 1
+    {0x1ee, 0x1ee}, // 1
+    {0x1f1, 0x1f1}, // 1
+    {0x1f4, 0x1f4}, // 1
+    {0x1f6, 0x1f8}, // 3
+    {0x1fa, 0x1fa}, // 1
+    {0x1fc, 0x1fc}, // 1
+    {0x1fe, 0x1fe}, // 1
+    {0x200, 0x200}, // 1
+    {0x202, 0x202}, // 1
+    {0x204, 0x204}, // 1
+    {0x206, 0x206}, // 1
+    {0x208, 0x208}, // 1
+    {0x20a, 0x20a}, // 1
+    {0x20c, 0x20c}, // 1
+    {0x20e, 0x20e}, // 1
+    {0x210, 0x210}, // 1
+    {0x212, 0x212}, // 1
+    {0x214, 0x214}, // 1
+    {0x216, 0x216}, // 1
+    {0x218, 0x218}, // 1
+    {0x21a, 0x21a}, // 1
+    {0x21c, 0x21c}, // 1
+    {0x21e, 0x21e}, // 1
+    {0x220, 0x220}, // 1
+    {0x222, 0x222}, // 1
+    {0x224, 0x224}, // 1
+    {0x226, 0x226}, // 1
+    {0x228, 0x228}, // 1
+    {0x22a, 0x22a}, // 1
+    {0x22c, 0x22c}, // 1
+    {0x22e, 0x22e}, // 1
+    {0x230, 0x230}, // 1
+    {0x232, 0x232}, // 1
+    {0x23a, 0x23b}, // 2
+    {0x23d, 0x23e}, // 2
+    {0x241, 0x241}, // 1
+    {0x243, 0x246}, // 4
+    {0x248, 0x248}, // 1
+    {0x24a, 0x24a}, // 1
+    {0x24c, 0x24c}, // 1
+    {0x24e, 0x24e}, // 1
+    {0x370, 0x370}, // 1
+    {0x372, 0x372}, // 1
+    {0x376, 0x376}, // 1
+    {0x37f, 0x37f}, // 1
+    {0x386, 0x386}, // 1
+    {0x388, 0x38a}, // 3
+    {0x38c, 0x38c}, // 1
+    {0x38e, 0x38f}, // 2
+    {0x391, 0x3a1}, // 17
+    {0x3a3, 0x3ab}, // 9
+    {0x3cf, 0x3cf}, // 1
+    {0x3d2, 0x3d4}, // 3
+    {0x3d8, 0x3d8}, // 1
+    {0x3da, 0x3da}, // 1
+    {0x3dc, 0x3dc}, // 1
+    {0x3de, 0x3de}, // 1
+    {0x3e0, 0x3e0}, // 1
+    {0x3e2, 0x3e2}, // 1
+    {0x3e4, 0x3e4}, // 1
+    {0x3e6, 0x3e6}, // 1
+    {0x3e8, 0x3e8}, // 1
+    {0x3ea, 0x3ea}, // 1
+    {0x3ec, 0x3ec}, // 1
+    {0x3ee, 0x3ee}, // 1
+    {0x3f4, 0x3f4}, // 1
+    {0x3f7, 0x3f7}, // 1
+    {0x3f9, 0x3fa}, // 2
+    {0x3fd, 0x42f}, // 51
+    {0x460, 0x460}, // 1
+    {0x462, 0x462}, // 1
+    {0x464, 0x464}, // 1
+    {0x466, 0x466}, // 1
+    {0x468, 0x468}, // 1
+    {0x46a, 0x46a}, // 1
+    {0x46c, 0x46c}, // 1
+    {0x46e, 0x46e}, // 1
+    {0x470, 0x470}, // 1
+    {0x472, 0x472}, // 1
+    {0x474, 0x474}, // 1
+    {0x476, 0x476}, // 1
+    {0x478, 0x478}, // 1
+    {0x47a, 0x47a}, // 1
+    {0x47c, 0x47c}, // 1
+    {0x47e, 0x47e}, // 1
+    {0x480, 0x480}, // 1
+    {0x48a, 0x48a}, // 1
+    {0x48c, 0x48c}, // 1
+    {0x48e, 0x48e}, // 1
+    {0x490, 0x490}, // 1
+    {0x492, 0x492}, // 1
+    {0x494, 0x494}, // 1
+    {0x496, 0x496}, // 1
+    {0x498, 0x498}, // 1
+    {0x49a, 0x49a}, // 1
+    {0x49c, 0x49c}, // 1
+    {0x49e, 0x49e}, // 1
+    {0x4a0, 0x4a0}, // 1
+    {0x4a2, 0x4a2}, // 1
+    {0x4a4, 0x4a4}, // 1
+    {0x4a6, 0x4a6}, // 1
+    {0x4a8, 0x4a8}, // 1
+    {0x4aa, 0x4aa}, // 1
+    {0x4ac, 0x4ac}, // 1
+    {0x4ae, 0x4ae}, // 1
+    {0x4b0, 0x4b0}, // 1
+    {0x4b2, 0x4b2}, // 1
+    {0x4b4, 0x4b4}, // 1
+    {0x4b6, 0x4b6}, // 1
+    {0x4b8, 0x4b8}, // 1
+    {0x4ba, 0x4ba}, // 1
+    {0x4bc, 0x4bc}, // 1
+    {0x4be, 0x4be}, // 1
+    {0x4c0, 0x4c1}, // 2
+    {0x4c3, 0x4c3}, // 1
+    {0x4c5, 0x4c5}, // 1
+    {0x4c7, 0x4c7}, // 1
+    {0x4c9, 0x4c9}, // 1
+    {0x4cb, 0x4cb}, // 1
+    {0x4cd, 0x4cd}, // 1
+    {0x4d0, 0x4d0}, // 1
+    {0x4d2, 0x4d2}, // 1
+    {0x4d4, 0x4d4}, // 1
+    {0x4d6, 0x4d6}, // 1
+    {0x4d8, 0x4d8}, // 1
+    {0x4da, 0x4da}, // 1
+    {0x4dc, 0x4dc}, // 1
+    {0x4de, 0x4de}, // 1
+    {0x4e0, 0x4e0}, // 1
+    {0x4e2, 0x4e2}, // 1
+    {0x4e4, 0x4e4}, // 1
+    {0x4e6, 0x4e6}, // 1
+    {0x4e8, 0x4e8}, // 1
+    {0x4ea, 0x4ea}, // 1
+    {0x4ec, 0x4ec}, // 1
+    {0x4ee, 0x4ee}, // 1
+    {0x4f0, 0x4f0}, // 1
+    {0x4f2, 0x4f2}, // 1
+    {0x4f4, 0x4f4}, // 1
+    {0x4f6, 0x4f6}, // 1
+    {0x4f8, 0x4f8}, // 1
+    {0x4fa, 0x4fa}, // 1
+    {0x4fc, 0x4fc}, // 1
+    {0x4fe, 0x4fe}, // 1
+    {0x500, 0x500}, // 1
+    {0x502, 0x502}, // 1
+    {0x504, 0x504}, // 1
+    {0x506, 0x506}, // 1
+    {0x508, 0x508}, // 1
+    {0x50a, 0x50a}, // 1
+    {0x50c, 0x50c}, // 1
+    {0x50e, 0x50e}, // 1
+    {0x510, 0x510}, // 1
+    {0x512, 0x512}, // 1
+    {0x514, 0x514}, // 1
+    {0x516, 0x516}, // 1
+    {0x518, 0x518}, // 1
+    {0x51a, 0x51a}, // 1
+    {0x51c, 0x51c}, // 1
+    {0x51e, 0x51e}, // 1
+    {0x520, 0x520}, // 1
+    {0x522, 0x522}, // 1
+    {0x524, 0x524}, // 1
+    {0x526, 0x526}, // 1
+    {0x528, 0x528}, // 1
+    {0x52a, 0x52a}, // 1
+    {0x52c, 0x52c}, // 1
+    {0x52e, 0x52e}, // 1
+    {0x531, 0x556}, // 38
+    {0x10a0, 0x10c5}, // 38
+    {0x10c7, 0x10c7}, // 1
+    {0x10cd, 0x10cd}, // 1
+    {0x13a0, 0x13f5}, // 86
+    {0x1c90, 0x1cba}, // 43
+    {0x1cbd, 0x1cbf}, // 3
+    {0x1e00, 0x1e00}, // 1
+    {0x1e02, 0x1e02}, // 1
+    {0x1e04, 0x1e04}, // 1
+    {0x1e06, 0x1e06}, // 1
+    {0x1e08, 0x1e08}, // 1
+    {0x1e0a, 0x1e0a}, // 1
+    {0x1e0c, 0x1e0c}, // 1
+    {0x1e0e, 0x1e0e}, // 1
+    {0x1e10, 0x1e10}, // 1
+    {0x1e12, 0x1e12}, // 1
+    {0x1e14, 0x1e14}, // 1
+    {0x1e16, 0x1e16}, // 1
+    {0x1e18, 0x1e18}, // 1
+    {0x1e1a, 0x1e1a}, // 1
+    {0x1e1c, 0x1e1c}, // 1
+    {0x1e1e, 0x1e1e}, // 1
+    {0x1e20, 0x1e20}, // 1
+    {0x1e22, 0x1e22}, // 1
+    {0x1e24, 0x1e24}, // 1
+    {0x1e26, 0x1e26}, // 1
+    {0x1e28, 0x1e28}, // 1
+    {0x1e2a, 0x1e2a}, // 1
+    {0x1e2c, 0x1e2c}, // 1
+    {0x1e2e, 0x1e2e}, // 1
+    {0x1e30, 0x1e30}, // 1
+    {0x1e32, 0x1e32}, // 1
+    {0x1e34, 0x1e34}, // 1
+    {0x1e36, 0x1e36}, // 1
+    {0x1e38, 0x1e38}, // 1
+    {0x1e3a, 0x1e3a}, // 1
+    {0x1e3c, 0x1e3c}, // 1
+    {0x1e3e, 0x1e3e}, // 1
+    {0x1e40, 0x1e40}, // 1
+    {0x1e42, 0x1e42}, // 1
+    {0x1e44, 0x1e44}, // 1
+    {0x1e46, 0x1e46}, // 1
+    {0x1e48, 0x1e48}, // 1
+    {0x1e4a, 0x1e4a}, // 1
+    {0x1e4c, 0x1e4c}, // 1
+    {0x1e4e, 0x1e4e}, // 1
+    {0x1e50, 0x1e50}, // 1
+    {0x1e52, 0x1e52}, // 1
+    {0x1e54, 0x1e54}, // 1
+    {0x1e56, 0x1e56}, // 1
+    {0x1e58, 0x1e58}, // 1
+    {0x1e5a, 0x1e5a}, // 1
+    {0x1e5c, 0x1e5c}, // 1
+    {0x1e5e, 0x1e5e}, // 1
+    {0x1e60, 0x1e60}, // 1
+    {0x1e62, 0x1e62}, // 1
+    {0x1e64, 0x1e64}, // 1
+    {0x1e66, 0x1e66}, // 1
+    {0x1e68, 0x1e68}, // 1
+    {0x1e6a, 0x1e6a}, // 1
+    {0x1e6c, 0x1e6c}, // 1
+    {0x1e6e, 0x1e6e}, // 1
+    {0x1e70, 0x1e70}, // 1
+    {0x1e72, 0x1e72}, // 1
+    {0x1e74, 0x1e74}, // 1
+    {0x1e76, 0x1e76}, // 1
+    {0x1e78, 0x1e78}, // 1
+    {0x1e7a, 0x1e7a}, // 1
+    {0x1e7c, 0x1e7c}, // 1
+    {0x1e7e, 0x1e7e}, // 1
+    {0x1e80, 0x1e80}, // 1
+    {0x1e82, 0x1e82}, // 1
+    {0x1e84, 0x1e84}, // 1
+    {0x1e86, 0x1e86}, // 1
+    {0x1e88, 0x1e88}, // 1
+    {0x1e8a, 0x1e8a}, // 1
+    {0x1e8c, 0x1e8c}, // 1
+    {0x1e8e, 0x1e8e}, // 1
+    {0x1e90, 0x1e90}, // 1
+    {0x1e92, 0x1e92}, // 1
+    {0x1e94, 0x1e94}, // 1
+    {0x1e9e, 0x1e9e}, // 1
+    {0x1ea0, 0x1ea0}, // 1
+    {0x1ea2, 0x1ea2}, // 1
+    {0x1ea4, 0x1ea4}, // 1
+    {0x1ea6, 0x1ea6}, // 1
+    {0x1ea8, 0x1ea8}, // 1
+    {0x1eaa, 0x1eaa}, // 1
+    {0x1eac, 0x1eac}, // 1
+    {0x1eae, 0x1eae}, // 1
+    {0x1eb0, 0x1eb0}, // 1
+    {0x1eb2, 0x1eb2}, // 1
+    {0x1eb4, 0x1eb4}, // 1
+    {0x1eb6, 0x1eb6}, // 1
+    {0x1eb8, 0x1eb8}, // 1
+    {0x1eba, 0x1eba}, // 1
+    {0x1ebc, 0x1ebc}, // 1
+    {0x1ebe, 0x1ebe}, // 1
+    {0x1ec0, 0x1ec0}, // 1
+    {0x1ec2, 0x1ec2}, // 1
+    {0x1ec4, 0x1ec4}, // 1
+    {0x1ec6, 0x1ec6}, // 1
+    {0x1ec8, 0x1ec8}, // 1
+    {0x1eca, 0x1eca}, // 1
+    {0x1ecc, 0x1ecc}, // 1
+    {0x1ece, 0x1ece}, // 1
+    {0x1ed0, 0x1ed0}, // 1
+    {0x1ed2, 0x1ed2}, // 1
+    {0x1ed4, 0x1ed4}, // 1
+    {0x1ed6, 0x1ed6}, // 1
+    {0x1ed8, 0x1ed8}, // 1
+    {0x1eda, 0x1eda}, // 1
+    {0x1edc, 0x1edc}, // 1
+    {0x1ede, 0x1ede}, // 1
+    {0x1ee0, 0x1ee0}, // 1
+    {0x1ee2, 0x1ee2}, // 1
+    {0x1ee4, 0x1ee4}, // 1
+    {0x1ee6, 0x1ee6}, // 1
+    {0x1ee8, 0x1ee8}, // 1
+    {0x1eea, 0x1eea}, // 1
+    {0x1eec, 0x1eec}, // 1
+    {0x1eee, 0x1eee}, // 1
+    {0x1ef0, 0x1ef0}, // 1
+    {0x1ef2, 0x1ef2}, // 1
+    {0x1ef4, 0x1ef4}, // 1
+    {0x1ef6, 0x1ef6}, // 1
+    {0x1ef8, 0x1ef8}, // 1
+    {0x1efa, 0x1efa}, // 1
+    {0x1efc, 0x1efc}, // 1
+    {0x1efe, 0x1efe}, // 1
+    {0x1f08, 0x1f0f}, // 8
+    {0x1f18, 0x1f1d}, // 6
+    {0x1f28, 0x1f2f}, // 8
+    {0x1f38, 0x1f3f}, // 8
+    {0x1f48, 0x1f4d}, // 6
+    {0x1f59, 0x1f59}, // 1
+    {0x1f5b, 0x1f5b}, // 1
+    {0x1f5d, 0x1f5d}, // 1
+    {0x1f5f, 0x1f5f}, // 1
+    {0x1f68, 0x1f6f}, // 8
+    {0x1fb8, 0x1fbb}, // 4
+    {0x1fc8, 0x1fcb}, // 4
+    {0x1fd8, 0x1fdb}, // 4
+    {0x1fe8, 0x1fec}, // 5
+    {0x1ff8, 0x1ffb}, // 4
+    {0x2102, 0x2102}, // 1
+    {0x2107, 0x2107}, // 1
+    {0x210b, 0x210d}, // 3
+    {0x2110, 0x2112}, // 3
+    {0x2115, 0x2115}, // 1
+    {0x2119, 0x211d}, // 5
+    {0x2124, 0x2124}, // 1
+    {0x2126, 0x2126}, // 1
+    {0x2128, 0x2128}, // 1
+    {0x212a, 0x212d}, // 4
+    {0x2130, 0x2133}, // 4
+    {0x213e, 0x213f}, // 2
+    {0x2145, 0x2145}, // 1
+    {0x2160, 0x216f}, // 16
+    {0x2183, 0x2183}, // 1
+    {0x24b6, 0x24cf}, // 26
+    {0x2c00, 0x2c2e}, // 47
+    {0x2c60, 0x2c60}, // 1
+    {0x2c62, 0x2c64}, // 3
+    {0x2c67, 0x2c67}, // 1
+    {0x2c69, 0x2c69}, // 1
+    {0x2c6b, 0x2c6b}, // 1
+    {0x2c6d, 0x2c70}, // 4
+    {0x2c72, 0x2c72}, // 1
+    {0x2c75, 0x2c75}, // 1
+    {0x2c7e, 0x2c80}, // 3
+    {0x2c82, 0x2c82}, // 1
+    {0x2c84, 0x2c84}, // 1
+    {0x2c86, 0x2c86}, // 1
+    {0x2c88, 0x2c88}, // 1
+    {0x2c8a, 0x2c8a}, // 1
+    {0x2c8c, 0x2c8c}, // 1
+    {0x2c8e, 0x2c8e}, // 1
+    {0x2c90, 0x2c90}, // 1
+    {0x2c92, 0x2c92}, // 1
+    {0x2c94, 0x2c94}, // 1
+    {0x2c96, 0x2c96}, // 1
+    {0x2c98, 0x2c98}, // 1
+    {0x2c9a, 0x2c9a}, // 1
+    {0x2c9c, 0x2c9c}, // 1
+    {0x2c9e, 0x2c9e}, // 1
+    {0x2ca0, 0x2ca0}, // 1
+    {0x2ca2, 0x2ca2}, // 1
+    {0x2ca4, 0x2ca4}, // 1
+    {0x2ca6, 0x2ca6}, // 1
+    {0x2ca8, 0x2ca8}, // 1
+    {0x2caa, 0x2caa}, // 1
+    {0x2cac, 0x2cac}, // 1
+    {0x2cae, 0x2cae}, // 1
+    {0x2cb0, 0x2cb0}, // 1
+    {0x2cb2, 0x2cb2}, // 1
+    {0x2cb4, 0x2cb4}, // 1
+    {0x2cb6, 0x2cb6}, // 1
+    {0x2cb8, 0x2cb8}, // 1
+    {0x2cba, 0x2cba}, // 1
+    {0x2cbc, 0x2cbc}, // 1
+    {0x2cbe, 0x2cbe}, // 1
+    {0x2cc0, 0x2cc0}, // 1
+    {0x2cc2, 0x2cc2}, // 1
+    {0x2cc4, 0x2cc4}, // 1
+    {0x2cc6, 0x2cc6}, // 1
+    {0x2cc8, 0x2cc8}, // 1
+    {0x2cca, 0x2cca}, // 1
+    {0x2ccc, 0x2ccc}, // 1
+    {0x2cce, 0x2cce}, // 1
+    {0x2cd0, 0x2cd0}, // 1
+    {0x2cd2, 0x2cd2}, // 1
+    {0x2cd4, 0x2cd4}, // 1
+    {0x2cd6, 0x2cd6}, // 1
+    {0x2cd8, 0x2cd8}, // 1
+    {0x2cda, 0x2cda}, // 1
+    {0x2cdc, 0x2cdc}, // 1
+    {0x2cde, 0x2cde}, // 1
+    {0x2ce0, 0x2ce0}, // 1
+    {0x2ce2, 0x2ce2}, // 1
+    {0x2ceb, 0x2ceb}, // 1
+    {0x2ced, 0x2ced}, // 1
+    {0x2cf2, 0x2cf2}, // 1
+    {0xa640, 0xa640}, // 1
+    {0xa642, 0xa642}, // 1
+    {0xa644, 0xa644}, // 1
+    {0xa646, 0xa646}, // 1
+    {0xa648, 0xa648}, // 1
+    {0xa64a, 0xa64a}, // 1
+    {0xa64c, 0xa64c}, // 1
+    {0xa64e, 0xa64e}, // 1
+    {0xa650, 0xa650}, // 1
+    {0xa652, 0xa652}, // 1
+    {0xa654, 0xa654}, // 1
+    {0xa656, 0xa656}, // 1
+    {0xa658, 0xa658}, // 1
+    {0xa65a, 0xa65a}, // 1
+    {0xa65c, 0xa65c}, // 1
+    {0xa65e, 0xa65e}, // 1
+    {0xa660, 0xa660}, // 1
+    {0xa662, 0xa662}, // 1
+    {0xa664, 0xa664}, // 1
+    {0xa666, 0xa666}, // 1
+    {0xa668, 0xa668}, // 1
+    {0xa66a, 0xa66a}, // 1
+    {0xa66c, 0xa66c}, // 1
+    {0xa680, 0xa680}, // 1
+    {0xa682, 0xa682}, // 1
+    {0xa684, 0xa684}, // 1
+    {0xa686, 0xa686}, // 1
+    {0xa688, 0xa688}, // 1
+    {0xa68a, 0xa68a}, // 1
+    {0xa68c, 0xa68c}, // 1
+    {0xa68e, 0xa68e}, // 1
+    {0xa690, 0xa690}, // 1
+    {0xa692, 0xa692}, // 1
+    {0xa694, 0xa694}, // 1
+    {0xa696, 0xa696}, // 1
+    {0xa698, 0xa698}, // 1
+    {0xa69a, 0xa69a}, // 1
+    {0xa722, 0xa722}, // 1
+    {0xa724, 0xa724}, // 1
+    {0xa726, 0xa726}, // 1
+    {0xa728, 0xa728}, // 1
+    {0xa72a, 0xa72a}, // 1
+    {0xa72c, 0xa72c}, // 1
+    {0xa72e, 0xa72e}, // 1
+    {0xa732, 0xa732}, // 1
+    {0xa734, 0xa734}, // 1
+    {0xa736, 0xa736}, // 1
+    {0xa738, 0xa738}, // 1
+    {0xa73a, 0xa73a}, // 1
+    {0xa73c, 0xa73c}, // 1
+    {0xa73e, 0xa73e}, // 1
+    {0xa740, 0xa740}, // 1
+    {0xa742, 0xa742}, // 1
+    {0xa744, 0xa744}, // 1
+    {0xa746, 0xa746}, // 1
+    {0xa748, 0xa748}, // 1
+    {0xa74a, 0xa74a}, // 1
+    {0xa74c, 0xa74c}, // 1
+    {0xa74e, 0xa74e}, // 1
+    {0xa750, 0xa750}, // 1
+    {0xa752, 0xa752}, // 1
+    {0xa754, 0xa754}, // 1
+    {0xa756, 0xa756}, // 1
+    {0xa758, 0xa758}, // 1
+    {0xa75a, 0xa75a}, // 1
+    {0xa75c, 0xa75c}, // 1
+    {0xa75e, 0xa75e}, // 1
+    {0xa760, 0xa760}, // 1
+    {0xa762, 0xa762}, // 1
+    {0xa764, 0xa764}, // 1
+    {0xa766, 0xa766}, // 1
+    {0xa768, 0xa768}, // 1
+    {0xa76a, 0xa76a}, // 1
+    {0xa76c, 0xa76c}, // 1
+    {0xa76e, 0xa76e}, // 1
+    {0xa779, 0xa779}, // 1
+    {0xa77b, 0xa77b}, // 1
+    {0xa77d, 0xa77e}, // 2
+    {0xa780, 0xa780}, // 1
+    {0xa782, 0xa782}, // 1
+    {0xa784, 0xa784}, // 1
+    {0xa786, 0xa786}, // 1
+    {0xa78b, 0xa78b}, // 1
+    {0xa78d, 0xa78d}, // 1
+    {0xa790, 0xa790}, // 1
+    {0xa792, 0xa792}, // 1
+    {0xa796, 0xa796}, // 1
+    {0xa798, 0xa798}, // 1
+    {0xa79a, 0xa79a}, // 1
+    {0xa79c, 0xa79c}, // 1
+    {0xa79e, 0xa79e}, // 1
+    {0xa7a0, 0xa7a0}, // 1
+    {0xa7a2, 0xa7a2}, // 1
+    {0xa7a4, 0xa7a4}, // 1
+    {0xa7a6, 0xa7a6}, // 1
+    {0xa7a8, 0xa7a8}, // 1
+    {0xa7aa, 0xa7ae}, // 5
+    {0xa7b0, 0xa7b4}, // 5
+    {0xa7b6, 0xa7b6}, // 1
+    {0xa7b8, 0xa7b8}, // 1
+    {0xa7ba, 0xa7ba}, // 1
+    {0xa7bc, 0xa7bc}, // 1
+    {0xa7be, 0xa7be}, // 1
+    {0xa7c2, 0xa7c2}, // 1
+    {0xa7c4, 0xa7c6}, // 3
+    {0xff21, 0xff3a}, // 26
+    {0x10400, 0x10427}, // 40
+    {0x104b0, 0x104d3}, // 36
+    {0x10c80, 0x10cb2}, // 51
+    {0x118a0, 0x118bf}, // 32
+    {0x16e40, 0x16e5f}, // 32
+    {0x1d400, 0x1d419}, // 26
+    {0x1d434, 0x1d44d}, // 26
+    {0x1d468, 0x1d481}, // 26
+    {0x1d49c, 0x1d49c}, // 1
+    {0x1d49e, 0x1d49f}, // 2
+    {0x1d4a2, 0x1d4a2}, // 1
+    {0x1d4a5, 0x1d4a6}, // 2
+    {0x1d4a9, 0x1d4ac}, // 4
+    {0x1d4ae, 0x1d4b5}, // 8
+    {0x1d4d0, 0x1d4e9}, // 26
+    {0x1d504, 0x1d505}, // 2
+    {0x1d507, 0x1d50a}, // 4
+    {0x1d50d, 0x1d514}, // 8
+    {0x1d516, 0x1d51c}, // 7
+    {0x1d538, 0x1d539}, // 2
+    {0x1d53b, 0x1d53e}, // 4
+    {0x1d540, 0x1d544}, // 5
+    {0x1d546, 0x1d546}, // 1
+    {0x1d54a, 0x1d550}, // 7
+    {0x1d56c, 0x1d585}, // 26
+    {0x1d5a0, 0x1d5b9}, // 26
+    {0x1d5d4, 0x1d5ed}, // 26
+    {0x1d608, 0x1d621}, // 26
+    {0x1d63c, 0x1d655}, // 26
+    {0x1d670, 0x1d689}, // 26
+    {0x1d6a8, 0x1d6c0}, // 25
+    {0x1d6e2, 0x1d6fa}, // 25
+    {0x1d71c, 0x1d734}, // 25
+    {0x1d756, 0x1d76e}, // 25
+    {0x1d790, 0x1d7a8}, // 25
+    {0x1d7ca, 0x1d7ca}, // 1
+    {0x1e900, 0x1e921}, // 34
+    {0x1f130, 0x1f149}, // 26
+    {0x1f150, 0x1f169}, // 26
+    {0x1f170, 0x1f189}, // 26
+};
+
+static FCharRange TitleCaseCharRange[10] =
+{
+    {0x1c5, 0x1c5}, // 1
+    {0x1c8, 0x1c8}, // 1
+    {0x1cb, 0x1cb}, // 1
+    {0x1f2, 0x1f2}, // 1
+    {0x1f88, 0x1f8f}, // 8
+    {0x1f98, 0x1f9f}, // 8
+    {0x1fa8, 0x1faf}, // 8
+    {0x1fbc, 0x1fbc}, // 1
+    {0x1fcc, 0x1fcc}, // 1
+    {0x1ffc, 0x1ffc}, // 1
+};
+
+static FCharRange LetterCharRange[1058] =
+{
+    {0x41, 0x5a}, // 26
+    {0x61, 0x7a}, // 26
+    {0xaa, 0xaa}, // 1
+    {0xb5, 0xb5}, // 1
+    {0xba, 0xba}, // 1
+    {0xc0, 0xd6}, // 23
+    {0xd8, 0xf6}, // 31
+    {0xf8, 0x1ba}, // 195
+    {0x1bb, 0x1bb}, // 1
+    {0x1bc, 0x1bf}, // 4
+    {0x1c0, 0x1c3}, // 4
+    {0x1c4, 0x293}, // 208
+    {0x294, 0x294}, // 1
+    {0x295, 0x2af}, // 27
+    {0x2b0, 0x2c1}, // 18
+    {0x2c6, 0x2d1}, // 12
+    {0x2e0, 0x2e4}, // 5
+    {0x2ec, 0x2ec}, // 1
+    {0x2ee, 0x2ee}, // 1
+    {0x345, 0x345}, // 1
+    {0x370, 0x373}, // 4
+    {0x374, 0x374}, // 1
+    {0x376, 0x377}, // 2
+    {0x37a, 0x37a}, // 1
+    {0x37b, 0x37d}, // 3
+    {0x37f, 0x37f}, // 1
+    {0x386, 0x386}, // 1
+    {0x388, 0x38a}, // 3
+    {0x38c, 0x38c}, // 1
+    {0x38e, 0x3a1}, // 20
+    {0x3a3, 0x3f5}, // 83
+    {0x3f7, 0x481}, // 139
+    {0x48a, 0x52f}, // 166
+    {0x531, 0x556}, // 38
+    {0x559, 0x559}, // 1
+    {0x560, 0x588}, // 41
+    {0x5b0, 0x5bd}, // 14
+    {0x5bf, 0x5bf}, // 1
+    {0x5c1, 0x5c2}, // 2
+    {0x5c4, 0x5c5}, // 2
+    {0x5c7, 0x5c7}, // 1
+    {0x5d0, 0x5ea}, // 27
+    {0x5ef, 0x5f2}, // 4
+    {0x610, 0x61a}, // 11
+    {0x620, 0x63f}, // 32
+    {0x640, 0x640}, // 1
+    {0x641, 0x64a}, // 10
+    {0x64b, 0x657}, // 13
+    {0x659, 0x65f}, // 7
+    {0x66e, 0x66f}, // 2
+    {0x670, 0x670}, // 1
+    {0x671, 0x6d3}, // 99
+    {0x6d5, 0x6d5}, // 1
+    {0x6d6, 0x6dc}, // 7
+    {0x6e1, 0x6e4}, // 4
+    {0x6e5, 0x6e6}, // 2
+    {0x6e7, 0x6e8}, // 2
+    {0x6ed, 0x6ed}, // 1
+    {0x6ee, 0x6ef}, // 2
+    {0x6fa, 0x6fc}, // 3
+    {0x6ff, 0x6ff}, // 1
+    {0x710, 0x710}, // 1
+    {0x711, 0x711}, // 1
+    {0x712, 0x72f}, // 30
+    {0x730, 0x73f}, // 16
+    {0x74d, 0x7a5}, // 89
+    {0x7a6, 0x7b0}, // 11
+    {0x7b1, 0x7b1}, // 1
+    {0x7ca, 0x7ea}, // 33
+    {0x7f4, 0x7f5}, // 2
+    {0x7fa, 0x7fa}, // 1
+    {0x800, 0x815}, // 22
+    {0x816, 0x817}, // 2
+    {0x81a, 0x81a}, // 1
+    {0x81b, 0x823}, // 9
+    {0x824, 0x824}, // 1
+    {0x825, 0x827}, // 3
+    {0x828, 0x828}, // 1
+    {0x829, 0x82c}, // 4
+    {0x840, 0x858}, // 25
+    {0x860, 0x86a}, // 11
+    {0x8a0, 0x8b4}, // 21
+    {0x8b6, 0x8bd}, // 8
+    {0x8d4, 0x8df}, // 12
+    {0x8e3, 0x8e9}, // 7
+    {0x8f0, 0x902}, // 19
+    {0x903, 0x903}, // 1
+    {0x904, 0x939}, // 54
+    {0x93a, 0x93a}, // 1
+    {0x93b, 0x93b}, // 1
+    {0x93d, 0x93d}, // 1
+    {0x93e, 0x940}, // 3
+    {0x941, 0x948}, // 8
+    {0x949, 0x94c}, // 4
+    {0x94e, 0x94f}, // 2
+    {0x950, 0x950}, // 1
+    {0x955, 0x957}, // 3
+    {0x958, 0x961}, // 10
+    {0x962, 0x963}, // 2
+    {0x971, 0x971}, // 1
+    {0x972, 0x980}, // 15
+    {0x981, 0x981}, // 1
+    {0x982, 0x983}, // 2
+    {0x985, 0x98c}, // 8
+    {0x98f, 0x990}, // 2
+    {0x993, 0x9a8}, // 22
+    {0x9aa, 0x9b0}, // 7
+    {0x9b2, 0x9b2}, // 1
+    {0x9b6, 0x9b9}, // 4
+    {0x9bd, 0x9bd}, // 1
+    {0x9be, 0x9c0}, // 3
+    {0x9c1, 0x9c4}, // 4
+    {0x9c7, 0x9c8}, // 2
+    {0x9cb, 0x9cc}, // 2
+    {0x9ce, 0x9ce}, // 1
+    {0x9d7, 0x9d7}, // 1
+    {0x9dc, 0x9dd}, // 2
+    {0x9df, 0x9e1}, // 3
+    {0x9e2, 0x9e3}, // 2
+    {0x9f0, 0x9f1}, // 2
+    {0x9fc, 0x9fc}, // 1
+    {0xa01, 0xa02}, // 2
+    {0xa03, 0xa03}, // 1
+    {0xa05, 0xa0a}, // 6
+    {0xa0f, 0xa10}, // 2
+    {0xa13, 0xa28}, // 22
+    {0xa2a, 0xa30}, // 7
+    {0xa32, 0xa33}, // 2
+    {0xa35, 0xa36}, // 2
+    {0xa38, 0xa39}, // 2
+    {0xa3e, 0xa40}, // 3
+    {0xa41, 0xa42}, // 2
+    {0xa47, 0xa48}, // 2
+    {0xa4b, 0xa4c}, // 2
+    {0xa51, 0xa51}, // 1
+    {0xa59, 0xa5c}, // 4
+    {0xa5e, 0xa5e}, // 1
+    {0xa70, 0xa71}, // 2
+    {0xa72, 0xa74}, // 3
+    {0xa75, 0xa75}, // 1
+    {0xa81, 0xa82}, // 2
+    {0xa83, 0xa83}, // 1
+    {0xa85, 0xa8d}, // 9
+    {0xa8f, 0xa91}, // 3
+    {0xa93, 0xaa8}, // 22
+    {0xaaa, 0xab0}, // 7
+    {0xab2, 0xab3}, // 2
+    {0xab5, 0xab9}, // 5
+    {0xabd, 0xabd}, // 1
+    {0xabe, 0xac0}, // 3
+    {0xac1, 0xac5}, // 5
+    {0xac7, 0xac8}, // 2
+    {0xac9, 0xac9}, // 1
+    {0xacb, 0xacc}, // 2
+    {0xad0, 0xad0}, // 1
+    {0xae0, 0xae1}, // 2
+    {0xae2, 0xae3}, // 2
+    {0xaf9, 0xaf9}, // 1
+    {0xafa, 0xafc}, // 3
+    {0xb01, 0xb01}, // 1
+    {0xb02, 0xb03}, // 2
+    {0xb05, 0xb0c}, // 8
+    {0xb0f, 0xb10}, // 2
+    {0xb13, 0xb28}, // 22
+    {0xb2a, 0xb30}, // 7
+    {0xb32, 0xb33}, // 2
+    {0xb35, 0xb39}, // 5
+    {0xb3d, 0xb3d}, // 1
+    {0xb3e, 0xb3e}, // 1
+    {0xb3f, 0xb3f}, // 1
+    {0xb40, 0xb40}, // 1
+    {0xb41, 0xb44}, // 4
+    {0xb47, 0xb48}, // 2
+    {0xb4b, 0xb4c}, // 2
+    {0xb56, 0xb56}, // 1
+    {0xb57, 0xb57}, // 1
+    {0xb5c, 0xb5d}, // 2
+    {0xb5f, 0xb61}, // 3
+    {0xb62, 0xb63}, // 2
+    {0xb71, 0xb71}, // 1
+    {0xb82, 0xb82}, // 1
+    {0xb83, 0xb83}, // 1
+    {0xb85, 0xb8a}, // 6
+    {0xb8e, 0xb90}, // 3
+    {0xb92, 0xb95}, // 4
+    {0xb99, 0xb9a}, // 2
+    {0xb9c, 0xb9c}, // 1
+    {0xb9e, 0xb9f}, // 2
+    {0xba3, 0xba4}, // 2
+    {0xba8, 0xbaa}, // 3
+    {0xbae, 0xbb9}, // 12
+    {0xbbe, 0xbbf}, // 2
+    {0xbc0, 0xbc0}, // 1
+    {0xbc1, 0xbc2}, // 2
+    {0xbc6, 0xbc8}, // 3
+    {0xbca, 0xbcc}, // 3
+    {0xbd0, 0xbd0}, // 1
+    {0xbd7, 0xbd7}, // 1
+    {0xc00, 0xc00}, // 1
+    {0xc01, 0xc03}, // 3
+    {0xc05, 0xc0c}, // 8
+    {0xc0e, 0xc10}, // 3
+    {0xc12, 0xc28}, // 23
+    {0xc2a, 0xc39}, // 16
+    {0xc3d, 0xc3d}, // 1
+    {0xc3e, 0xc40}, // 3
+    {0xc41, 0xc44}, // 4
+    {0xc46, 0xc48}, // 3
+    {0xc4a, 0xc4c}, // 3
+    {0xc55, 0xc56}, // 2
+    {0xc58, 0xc5a}, // 3
+    {0xc60, 0xc61}, // 2
+    {0xc62, 0xc63}, // 2
+    {0xc80, 0xc80}, // 1
+    {0xc81, 0xc81}, // 1
+    {0xc82, 0xc83}, // 2
+    {0xc85, 0xc8c}, // 8
+    {0xc8e, 0xc90}, // 3
+    {0xc92, 0xca8}, // 23
+    {0xcaa, 0xcb3}, // 10
+    {0xcb5, 0xcb9}, // 5
+    {0xcbd, 0xcbd}, // 1
+    {0xcbe, 0xcbe}, // 1
+    {0xcbf, 0xcbf}, // 1
+    {0xcc0, 0xcc4}, // 5
+    {0xcc6, 0xcc6}, // 1
+    {0xcc7, 0xcc8}, // 2
+    {0xcca, 0xccb}, // 2
+    {0xccc, 0xccc}, // 1
+    {0xcd5, 0xcd6}, // 2
+    {0xcde, 0xcde}, // 1
+    {0xce0, 0xce1}, // 2
+    {0xce2, 0xce3}, // 2
+    {0xcf1, 0xcf2}, // 2
+    {0xd00, 0xd01}, // 2
+    {0xd02, 0xd03}, // 2
+    {0xd05, 0xd0c}, // 8
+    {0xd0e, 0xd10}, // 3
+    {0xd12, 0xd3a}, // 41
+    {0xd3d, 0xd3d}, // 1
+    {0xd3e, 0xd40}, // 3
+    {0xd41, 0xd44}, // 4
+    {0xd46, 0xd48}, // 3
+    {0xd4a, 0xd4c}, // 3
+    {0xd4e, 0xd4e}, // 1
+    {0xd54, 0xd56}, // 3
+    {0xd57, 0xd57}, // 1
+    {0xd5f, 0xd61}, // 3
+    {0xd62, 0xd63}, // 2
+    {0xd7a, 0xd7f}, // 6
+    {0xd82, 0xd83}, // 2
+    {0xd85, 0xd96}, // 18
+    {0xd9a, 0xdb1}, // 24
+    {0xdb3, 0xdbb}, // 9
+    {0xdbd, 0xdbd}, // 1
+    {0xdc0, 0xdc6}, // 7
+    {0xdcf, 0xdd1}, // 3
+    {0xdd2, 0xdd4}, // 3
+    {0xdd6, 0xdd6}, // 1
+    {0xdd8, 0xddf}, // 8
+    {0xdf2, 0xdf3}, // 2
+    {0xe01, 0xe30}, // 48
+    {0xe31, 0xe31}, // 1
+    {0xe32, 0xe33}, // 2
+    {0xe34, 0xe3a}, // 7
+    {0xe40, 0xe45}, // 6
+    {0xe46, 0xe46}, // 1
+    {0xe4d, 0xe4d}, // 1
+    {0xe81, 0xe82}, // 2
+    {0xe84, 0xe84}, // 1
+    {0xe86, 0xe8a}, // 5
+    {0xe8c, 0xea3}, // 24
+    {0xea5, 0xea5}, // 1
+    {0xea7, 0xeb0}, // 10
+    {0xeb1, 0xeb1}, // 1
+    {0xeb2, 0xeb3}, // 2
+    {0xeb4, 0xeb9}, // 6
+    {0xebb, 0xebc}, // 2
+    {0xebd, 0xebd}, // 1
+    {0xec0, 0xec4}, // 5
+    {0xec6, 0xec6}, // 1
+    {0xecd, 0xecd}, // 1
+    {0xedc, 0xedf}, // 4
+    {0xf00, 0xf00}, // 1
+    {0xf40, 0xf47}, // 8
+    {0xf49, 0xf6c}, // 36
+    {0xf71, 0xf7e}, // 14
+    {0xf7f, 0xf7f}, // 1
+    {0xf80, 0xf81}, // 2
+    {0xf88, 0xf8c}, // 5
+    {0xf8d, 0xf97}, // 11
+    {0xf99, 0xfbc}, // 36
+    {0x1000, 0x102a}, // 43
+    {0x102b, 0x102c}, // 2
+    {0x102d, 0x1030}, // 4
+    {0x1031, 0x1031}, // 1
+    {0x1032, 0x1036}, // 5
+    {0x1038, 0x1038}, // 1
+    {0x103b, 0x103c}, // 2
+    {0x103d, 0x103e}, // 2
+    {0x103f, 0x103f}, // 1
+    {0x1050, 0x1055}, // 6
+    {0x1056, 0x1057}, // 2
+    {0x1058, 0x1059}, // 2
+    {0x105a, 0x105d}, // 4
+    {0x105e, 0x1060}, // 3
+    {0x1061, 0x1061}, // 1
+    {0x1062, 0x1064}, // 3
+    {0x1065, 0x1066}, // 2
+    {0x1067, 0x106d}, // 7
+    {0x106e, 0x1070}, // 3
+    {0x1071, 0x1074}, // 4
+    {0x1075, 0x1081}, // 13
+    {0x1082, 0x1082}, // 1
+    {0x1083, 0x1084}, // 2
+    {0x1085, 0x1086}, // 2
+    {0x1087, 0x108c}, // 6
+    {0x108d, 0x108d}, // 1
+    {0x108e, 0x108e}, // 1
+    {0x108f, 0x108f}, // 1
+    {0x109a, 0x109c}, // 3
+    {0x109d, 0x109d}, // 1
+    {0x10a0, 0x10c5}, // 38
+    {0x10c7, 0x10c7}, // 1
+    {0x10cd, 0x10cd}, // 1
+    {0x10d0, 0x10fa}, // 43
+    {0x10fc, 0x10fc}, // 1
+    {0x10fd, 0x10ff}, // 3
+    {0x1100, 0x1248}, // 329
+    {0x124a, 0x124d}, // 4
+    {0x1250, 0x1256}, // 7
+    {0x1258, 0x1258}, // 1
+    {0x125a, 0x125d}, // 4
+    {0x1260, 0x1288}, // 41
+    {0x128a, 0x128d}, // 4
+    {0x1290, 0x12b0}, // 33
+    {0x12b2, 0x12b5}, // 4
+    {0x12b8, 0x12be}, // 7
+    {0x12c0, 0x12c0}, // 1
+    {0x12c2, 0x12c5}, // 4
+    {0x12c8, 0x12d6}, // 15
+    {0x12d8, 0x1310}, // 57
+    {0x1312, 0x1315}, // 4
+    {0x1318, 0x135a}, // 67
+    {0x1380, 0x138f}, // 16
+    {0x13a0, 0x13f5}, // 86
+    {0x13f8, 0x13fd}, // 6
+    {0x1401, 0x166c}, // 620
+    {0x166f, 0x167f}, // 17
+    {0x1681, 0x169a}, // 26
+    {0x16a0, 0x16ea}, // 75
+    {0x16ee, 0x16f0}, // 3
+    {0x16f1, 0x16f8}, // 8
+    {0x1700, 0x170c}, // 13
+    {0x170e, 0x1711}, // 4
+    {0x1712, 0x1713}, // 2
+    {0x1720, 0x1731}, // 18
+    {0x1732, 0x1733}, // 2
+    {0x1740, 0x1751}, // 18
+    {0x1752, 0x1753}, // 2
+    {0x1760, 0x176c}, // 13
+    {0x176e, 0x1770}, // 3
+    {0x1772, 0x1773}, // 2
+    {0x1780, 0x17b3}, // 52
+    {0x17b6, 0x17b6}, // 1
+    {0x17b7, 0x17bd}, // 7
+    {0x17be, 0x17c5}, // 8
+    {0x17c6, 0x17c6}, // 1
+    {0x17c7, 0x17c8}, // 2
+    {0x17d7, 0x17d7}, // 1
+    {0x17dc, 0x17dc}, // 1
+    {0x1820, 0x1842}, // 35
+    {0x1843, 0x1843}, // 1
+    {0x1844, 0x1878}, // 53
+    {0x1880, 0x1884}, // 5
+    {0x1885, 0x1886}, // 2
+    {0x1887, 0x18a8}, // 34
+    {0x18a9, 0x18a9}, // 1
+    {0x18aa, 0x18aa}, // 1
+    {0x18b0, 0x18f5}, // 70
+    {0x1900, 0x191e}, // 31
+    {0x1920, 0x1922}, // 3
+    {0x1923, 0x1926}, // 4
+    {0x1927, 0x1928}, // 2
+    {0x1929, 0x192b}, // 3
+    {0x1930, 0x1931}, // 2
+    {0x1932, 0x1932}, // 1
+    {0x1933, 0x1938}, // 6
+    {0x1950, 0x196d}, // 30
+    {0x1970, 0x1974}, // 5
+    {0x1980, 0x19ab}, // 44
+    {0x19b0, 0x19c9}, // 26
+    {0x1a00, 0x1a16}, // 23
+    {0x1a17, 0x1a18}, // 2
+    {0x1a19, 0x1a1a}, // 2
+    {0x1a1b, 0x1a1b}, // 1
+    {0x1a20, 0x1a54}, // 53
+    {0x1a55, 0x1a55}, // 1
+    {0x1a56, 0x1a56}, // 1
+    {0x1a57, 0x1a57}, // 1
+    {0x1a58, 0x1a5e}, // 7
+    {0x1a61, 0x1a61}, // 1
+    {0x1a62, 0x1a62}, // 1
+    {0x1a63, 0x1a64}, // 2
+    {0x1a65, 0x1a6c}, // 8
+    {0x1a6d, 0x1a72}, // 6
+    {0x1a73, 0x1a74}, // 2
+    {0x1aa7, 0x1aa7}, // 1
+    {0x1b00, 0x1b03}, // 4
+    {0x1b04, 0x1b04}, // 1
+    {0x1b05, 0x1b33}, // 47
+    {0x1b35, 0x1b35}, // 1
+    {0x1b36, 0x1b3a}, // 5
+    {0x1b3b, 0x1b3b}, // 1
+    {0x1b3c, 0x1b3c}, // 1
+    {0x1b3d, 0x1b41}, // 5
+    {0x1b42, 0x1b42}, // 1
+    {0x1b43, 0x1b43}, // 1
+    {0x1b45, 0x1b4b}, // 7
+    {0x1b80, 0x1b81}, // 2
+    {0x1b82, 0x1b82}, // 1
+    {0x1b83, 0x1ba0}, // 30
+    {0x1ba1, 0x1ba1}, // 1
+    {0x1ba2, 0x1ba5}, // 4
+    {0x1ba6, 0x1ba7}, // 2
+    {0x1ba8, 0x1ba9}, // 2
+    {0x1bac, 0x1bad}, // 2
+    {0x1bae, 0x1baf}, // 2
+    {0x1bba, 0x1be5}, // 44
+    {0x1be7, 0x1be7}, // 1
+    {0x1be8, 0x1be9}, // 2
+    {0x1bea, 0x1bec}, // 3
+    {0x1bed, 0x1bed}, // 1
+    {0x1bee, 0x1bee}, // 1
+    {0x1bef, 0x1bf1}, // 3
+    {0x1c00, 0x1c23}, // 36
+    {0x1c24, 0x1c2b}, // 8
+    {0x1c2c, 0x1c33}, // 8
+    {0x1c34, 0x1c35}, // 2
+    {0x1c36, 0x1c36}, // 1
+    {0x1c4d, 0x1c4f}, // 3
+    {0x1c5a, 0x1c77}, // 30
+    {0x1c78, 0x1c7d}, // 6
+    {0x1c80, 0x1c88}, // 9
+    {0x1c90, 0x1cba}, // 43
+    {0x1cbd, 0x1cbf}, // 3
+    {0x1ce9, 0x1cec}, // 4
+    {0x1cee, 0x1cf3}, // 6
+    {0x1cf5, 0x1cf6}, // 2
+    {0x1cfa, 0x1cfa}, // 1
+    {0x1d00, 0x1d2b}, // 44
+    {0x1d2c, 0x1d6a}, // 63
+    {0x1d6b, 0x1d77}, // 13
+    {0x1d78, 0x1d78}, // 1
+    {0x1d79, 0x1d9a}, // 34
+    {0x1d9b, 0x1dbf}, // 37
+    {0x1de7, 0x1df4}, // 14
+    {0x1e00, 0x1f15}, // 278
+    {0x1f18, 0x1f1d}, // 6
+    {0x1f20, 0x1f45}, // 38
+    {0x1f48, 0x1f4d}, // 6
+    {0x1f50, 0x1f57}, // 8
+    {0x1f59, 0x1f59}, // 1
+    {0x1f5b, 0x1f5b}, // 1
+    {0x1f5d, 0x1f5d}, // 1
+    {0x1f5f, 0x1f7d}, // 31
+    {0x1f80, 0x1fb4}, // 53
+    {0x1fb6, 0x1fbc}, // 7
+    {0x1fbe, 0x1fbe}, // 1
+    {0x1fc2, 0x1fc4}, // 3
+    {0x1fc6, 0x1fcc}, // 7
+    {0x1fd0, 0x1fd3}, // 4
+    {0x1fd6, 0x1fdb}, // 6
+    {0x1fe0, 0x1fec}, // 13
+    {0x1ff2, 0x1ff4}, // 3
+    {0x1ff6, 0x1ffc}, // 7
+    {0x2071, 0x2071}, // 1
+    {0x207f, 0x207f}, // 1
+    {0x2090, 0x209c}, // 13
+    {0x2102, 0x2102}, // 1
+    {0x2107, 0x2107}, // 1
+    {0x210a, 0x2113}, // 10
+    {0x2115, 0x2115}, // 1
+    {0x2119, 0x211d}, // 5
+    {0x2124, 0x2124}, // 1
+    {0x2126, 0x2126}, // 1
+    {0x2128, 0x2128}, // 1
+    {0x212a, 0x212d}, // 4
+    {0x212f, 0x2134}, // 6
+    {0x2135, 0x2138}, // 4
+    {0x2139, 0x2139}, // 1
+    {0x213c, 0x213f}, // 4
+    {0x2145, 0x2149}, // 5
+    {0x214e, 0x214e}, // 1
+    {0x2160, 0x2182}, // 35
+    {0x2183, 0x2184}, // 2
+    {0x2185, 0x2188}, // 4
+    {0x24b6, 0x24e9}, // 52
+    {0x2c00, 0x2c2e}, // 47
+    {0x2c30, 0x2c5e}, // 47
+    {0x2c60, 0x2c7b}, // 28
+    {0x2c7c, 0x2c7d}, // 2
+    {0x2c7e, 0x2ce4}, // 103
+    {0x2ceb, 0x2cee}, // 4
+    {0x2cf2, 0x2cf3}, // 2
+    {0x2d00, 0x2d25}, // 38
+    {0x2d27, 0x2d27}, // 1
+    {0x2d2d, 0x2d2d}, // 1
+    {0x2d30, 0x2d67}, // 56
+    {0x2d6f, 0x2d6f}, // 1
+    {0x2d80, 0x2d96}, // 23
+    {0x2da0, 0x2da6}, // 7
+    {0x2da8, 0x2dae}, // 7
+    {0x2db0, 0x2db6}, // 7
+    {0x2db8, 0x2dbe}, // 7
+    {0x2dc0, 0x2dc6}, // 7
+    {0x2dc8, 0x2dce}, // 7
+    {0x2dd0, 0x2dd6}, // 7
+    {0x2dd8, 0x2dde}, // 7
+    {0x2de0, 0x2dff}, // 32
+    {0x2e2f, 0x2e2f}, // 1
+    {0x3005, 0x3005}, // 1
+    {0x3006, 0x3006}, // 1
+    {0x3007, 0x3007}, // 1
+    {0x3021, 0x3029}, // 9
+    {0x3031, 0x3035}, // 5
+    {0x3038, 0x303a}, // 3
+    {0x303b, 0x303b}, // 1
+    {0x303c, 0x303c}, // 1
+    {0x3041, 0x3096}, // 86
+    {0x309d, 0x309e}, // 2
+    {0x309f, 0x309f}, // 1
+    {0x30a1, 0x30fa}, // 90
+    {0x30fc, 0x30fe}, // 3
+    {0x30ff, 0x30ff}, // 1
+    {0x3105, 0x312f}, // 43
+    {0x3131, 0x318e}, // 94
+    {0x31a0, 0x31ba}, // 27
+    {0x31f0, 0x31ff}, // 16
+    {0x3400, 0x4db5}, // 6582
+    {0x4e00, 0x9fef}, // 20976
+    {0xa000, 0xa014}, // 21
+    {0xa015, 0xa015}, // 1
+    {0xa016, 0xa48c}, // 1143
+    {0xa4d0, 0xa4f7}, // 40
+    {0xa4f8, 0xa4fd}, // 6
+    {0xa500, 0xa60b}, // 268
+    {0xa60c, 0xa60c}, // 1
+    {0xa610, 0xa61f}, // 16
+    {0xa62a, 0xa62b}, // 2
+    {0xa640, 0xa66d}, // 46
+    {0xa66e, 0xa66e}, // 1
+    {0xa674, 0xa67b}, // 8
+    {0xa67f, 0xa67f}, // 1
+    {0xa680, 0xa69b}, // 28
+    {0xa69c, 0xa69d}, // 2
+    {0xa69e, 0xa69f}, // 2
+    {0xa6a0, 0xa6e5}, // 70
+    {0xa6e6, 0xa6ef}, // 10
+    {0xa717, 0xa71f}, // 9
+    {0xa722, 0xa76f}, // 78
+    {0xa770, 0xa770}, // 1
+    {0xa771, 0xa787}, // 23
+    {0xa788, 0xa788}, // 1
+    {0xa78b, 0xa78e}, // 4
+    {0xa78f, 0xa78f}, // 1
+    {0xa790, 0xa7bf}, // 48
+    {0xa7c2, 0xa7c6}, // 5
+    {0xa7f7, 0xa7f7}, // 1
+    {0xa7f8, 0xa7f9}, // 2
+    {0xa7fa, 0xa7fa}, // 1
+    {0xa7fb, 0xa801}, // 7
+    {0xa802, 0xa802}, // 1
+    {0xa803, 0xa805}, // 3
+    {0xa807, 0xa80a}, // 4
+    {0xa80b, 0xa80b}, // 1
+    {0xa80c, 0xa822}, // 23
+    {0xa823, 0xa824}, // 2
+    {0xa825, 0xa826}, // 2
+    {0xa827, 0xa827}, // 1
+    {0xa840, 0xa873}, // 52
+    {0xa880, 0xa881}, // 2
+    {0xa882, 0xa8b3}, // 50
+    {0xa8b4, 0xa8c3}, // 16
+    {0xa8c5, 0xa8c5}, // 1
+    {0xa8f2, 0xa8f7}, // 6
+    {0xa8fb, 0xa8fb}, // 1
+    {0xa8fd, 0xa8fe}, // 2
+    {0xa8ff, 0xa8ff}, // 1
+    {0xa90a, 0xa925}, // 28
+    {0xa926, 0xa92a}, // 5
+    {0xa930, 0xa946}, // 23
+    {0xa947, 0xa951}, // 11
+    {0xa952, 0xa952}, // 1
+    {0xa960, 0xa97c}, // 29
+    {0xa980, 0xa982}, // 3
+    {0xa983, 0xa983}, // 1
+    {0xa984, 0xa9b2}, // 47
+    {0xa9b4, 0xa9b5}, // 2
+    {0xa9b6, 0xa9b9}, // 4
+    {0xa9ba, 0xa9bb}, // 2
+    {0xa9bc, 0xa9bd}, // 2
+    {0xa9be, 0xa9bf}, // 2
+    {0xa9cf, 0xa9cf}, // 1
+    {0xa9e0, 0xa9e4}, // 5
+    {0xa9e5, 0xa9e5}, // 1
+    {0xa9e6, 0xa9e6}, // 1
+    {0xa9e7, 0xa9ef}, // 9
+    {0xa9fa, 0xa9fe}, // 5
+    {0xaa00, 0xaa28}, // 41
+    {0xaa29, 0xaa2e}, // 6
+    {0xaa2f, 0xaa30}, // 2
+    {0xaa31, 0xaa32}, // 2
+    {0xaa33, 0xaa34}, // 2
+    {0xaa35, 0xaa36}, // 2
+    {0xaa40, 0xaa42}, // 3
+    {0xaa43, 0xaa43}, // 1
+    {0xaa44, 0xaa4b}, // 8
+    {0xaa4c, 0xaa4c}, // 1
+    {0xaa4d, 0xaa4d}, // 1
+    {0xaa60, 0xaa6f}, // 16
+    {0xaa70, 0xaa70}, // 1
+    {0xaa71, 0xaa76}, // 6
+    {0xaa7a, 0xaa7a}, // 1
+    {0xaa7b, 0xaa7b}, // 1
+    {0xaa7c, 0xaa7c}, // 1
+    {0xaa7d, 0xaa7d}, // 1
+    {0xaa7e, 0xaaaf}, // 50
+    {0xaab0, 0xaab0}, // 1
+    {0xaab1, 0xaab1}, // 1
+    {0xaab2, 0xaab4}, // 3
+    {0xaab5, 0xaab6}, // 2
+    {0xaab7, 0xaab8}, // 2
+    {0xaab9, 0xaabd}, // 5
+    {0xaabe, 0xaabe}, // 1
+    {0xaac0, 0xaac0}, // 1
+    {0xaac2, 0xaac2}, // 1
+    {0xaadb, 0xaadc}, // 2
+    {0xaadd, 0xaadd}, // 1
+    {0xaae0, 0xaaea}, // 11
+    {0xaaeb, 0xaaeb}, // 1
+    {0xaaec, 0xaaed}, // 2
+    {0xaaee, 0xaaef}, // 2
+    {0xaaf2, 0xaaf2}, // 1
+    {0xaaf3, 0xaaf4}, // 2
+    {0xaaf5, 0xaaf5}, // 1
+    {0xab01, 0xab06}, // 6
+    {0xab09, 0xab0e}, // 6
+    {0xab11, 0xab16}, // 6
+    {0xab20, 0xab26}, // 7
+    {0xab28, 0xab2e}, // 7
+    {0xab30, 0xab5a}, // 43
+    {0xab5c, 0xab5f}, // 4
+    {0xab60, 0xab67}, // 8
+    {0xab70, 0xabbf}, // 80
+    {0xabc0, 0xabe2}, // 35
+    {0xabe3, 0xabe4}, // 2
+    {0xabe5, 0xabe5}, // 1
+    {0xabe6, 0xabe7}, // 2
+    {0xabe8, 0xabe8}, // 1
+    {0xabe9, 0xabea}, // 2
+    {0xac00, 0xd7a3}, // 11172
+    {0xd7b0, 0xd7c6}, // 23
+    {0xd7cb, 0xd7fb}, // 49
+    {0xf900, 0xfa6d}, // 366
+    {0xfa70, 0xfad9}, // 106
+    {0xfb00, 0xfb06}, // 7
+    {0xfb13, 0xfb17}, // 5
+    {0xfb1d, 0xfb1d}, // 1
+    {0xfb1e, 0xfb1e}, // 1
+    {0xfb1f, 0xfb28}, // 10
+    {0xfb2a, 0xfb36}, // 13
+    {0xfb38, 0xfb3c}, // 5
+    {0xfb3e, 0xfb3e}, // 1
+    {0xfb40, 0xfb41}, // 2
+    {0xfb43, 0xfb44}, // 2
+    {0xfb46, 0xfbb1}, // 108
+    {0xfbd3, 0xfd3d}, // 363
+    {0xfd50, 0xfd8f}, // 64
+    {0xfd92, 0xfdc7}, // 54
+    {0xfdf0, 0xfdfb}, // 12
+    {0xfe70, 0xfe74}, // 5
+    {0xfe76, 0xfefc}, // 135
+    {0xff21, 0xff3a}, // 26
+    {0xff41, 0xff5a}, // 26
+    {0xff66, 0xff6f}, // 10
+    {0xff70, 0xff70}, // 1
+    {0xff71, 0xff9d}, // 45
+    {0xff9e, 0xff9f}, // 2
+    {0xffa0, 0xffbe}, // 31
+    {0xffc2, 0xffc7}, // 6
+    {0xffca, 0xffcf}, // 6
+    {0xffd2, 0xffd7}, // 6
+    {0xffda, 0xffdc}, // 3
+    {0x10000, 0x1000b}, // 12
+    {0x1000d, 0x10026}, // 26
+    {0x10028, 0x1003a}, // 19
+    {0x1003c, 0x1003d}, // 2
+    {0x1003f, 0x1004d}, // 15
+    {0x10050, 0x1005d}, // 14
+    {0x10080, 0x100fa}, // 123
+    {0x10140, 0x10174}, // 53
+    {0x10280, 0x1029c}, // 29
+    {0x102a0, 0x102d0}, // 49
+    {0x10300, 0x1031f}, // 32
+    {0x1032d, 0x10340}, // 20
+    {0x10341, 0x10341}, // 1
+    {0x10342, 0x10349}, // 8
+    {0x1034a, 0x1034a}, // 1
+    {0x10350, 0x10375}, // 38
+    {0x10376, 0x1037a}, // 5
+    {0x10380, 0x1039d}, // 30
+    {0x103a0, 0x103c3}, // 36
+    {0x103c8, 0x103cf}, // 8
+    {0x103d1, 0x103d5}, // 5
+    {0x10400, 0x1044f}, // 80
+    {0x10450, 0x1049d}, // 78
+    {0x104b0, 0x104d3}, // 36
+    {0x104d8, 0x104fb}, // 36
+    {0x10500, 0x10527}, // 40
+    {0x10530, 0x10563}, // 52
+    {0x10600, 0x10736}, // 311
+    {0x10740, 0x10755}, // 22
+    {0x10760, 0x10767}, // 8
+    {0x10800, 0x10805}, // 6
+    {0x10808, 0x10808}, // 1
+    {0x1080a, 0x10835}, // 44
+    {0x10837, 0x10838}, // 2
+    {0x1083c, 0x1083c}, // 1
+    {0x1083f, 0x10855}, // 23
+    {0x10860, 0x10876}, // 23
+    {0x10880, 0x1089e}, // 31
+    {0x108e0, 0x108f2}, // 19
+    {0x108f4, 0x108f5}, // 2
+    {0x10900, 0x10915}, // 22
+    {0x10920, 0x10939}, // 26
+    {0x10980, 0x109b7}, // 56
+    {0x109be, 0x109bf}, // 2
+    {0x10a00, 0x10a00}, // 1
+    {0x10a01, 0x10a03}, // 3
+    {0x10a05, 0x10a06}, // 2
+    {0x10a0c, 0x10a0f}, // 4
+    {0x10a10, 0x10a13}, // 4
+    {0x10a15, 0x10a17}, // 3
+    {0x10a19, 0x10a35}, // 29
+    {0x10a60, 0x10a7c}, // 29
+    {0x10a80, 0x10a9c}, // 29
+    {0x10ac0, 0x10ac7}, // 8
+    {0x10ac9, 0x10ae4}, // 28
+    {0x10b00, 0x10b35}, // 54
+    {0x10b40, 0x10b55}, // 22
+    {0x10b60, 0x10b72}, // 19
+    {0x10b80, 0x10b91}, // 18
+    {0x10c00, 0x10c48}, // 73
+    {0x10c80, 0x10cb2}, // 51
+    {0x10cc0, 0x10cf2}, // 51
+    {0x10d00, 0x10d23}, // 36
+    {0x10d24, 0x10d27}, // 4
+    {0x10f00, 0x10f1c}, // 29
+    {0x10f27, 0x10f27}, // 1
+    {0x10f30, 0x10f45}, // 22
+    {0x10fe0, 0x10ff6}, // 23
+    {0x11000, 0x11000}, // 1
+    {0x11001, 0x11001}, // 1
+    {0x11002, 0x11002}, // 1
+    {0x11003, 0x11037}, // 53
+    {0x11038, 0x11045}, // 14
+    {0x11082, 0x11082}, // 1
+    {0x11083, 0x110af}, // 45
+    {0x110b0, 0x110b2}, // 3
+    {0x110b3, 0x110b6}, // 4
+    {0x110b7, 0x110b8}, // 2
+    {0x110d0, 0x110e8}, // 25
+    {0x11100, 0x11102}, // 3
+    {0x11103, 0x11126}, // 36
+    {0x11127, 0x1112b}, // 5
+    {0x1112c, 0x1112c}, // 1
+    {0x1112d, 0x11132}, // 6
+    {0x11144, 0x11144}, // 1
+    {0x11145, 0x11146}, // 2
+    {0x11150, 0x11172}, // 35
+    {0x11176, 0x11176}, // 1
+    {0x11180, 0x11181}, // 2
+    {0x11182, 0x11182}, // 1
+    {0x11183, 0x111b2}, // 48
+    {0x111b3, 0x111b5}, // 3
+    {0x111b6, 0x111be}, // 9
+    {0x111bf, 0x111bf}, // 1
+    {0x111c1, 0x111c4}, // 4
+    {0x111da, 0x111da}, // 1
+    {0x111dc, 0x111dc}, // 1
+    {0x11200, 0x11211}, // 18
+    {0x11213, 0x1122b}, // 25
+    {0x1122c, 0x1122e}, // 3
+    {0x1122f, 0x11231}, // 3
+    {0x11232, 0x11233}, // 2
+    {0x11234, 0x11234}, // 1
+    {0x11237, 0x11237}, // 1
+    {0x1123e, 0x1123e}, // 1
+    {0x11280, 0x11286}, // 7
+    {0x11288, 0x11288}, // 1
+    {0x1128a, 0x1128d}, // 4
+    {0x1128f, 0x1129d}, // 15
+    {0x1129f, 0x112a8}, // 10
+    {0x112b0, 0x112de}, // 47
+    {0x112df, 0x112df}, // 1
+    {0x112e0, 0x112e2}, // 3
+    {0x112e3, 0x112e8}, // 6
+    {0x11300, 0x11301}, // 2
+    {0x11302, 0x11303}, // 2
+    {0x11305, 0x1130c}, // 8
+    {0x1130f, 0x11310}, // 2
+    {0x11313, 0x11328}, // 22
+    {0x1132a, 0x11330}, // 7
+    {0x11332, 0x11333}, // 2
+    {0x11335, 0x11339}, // 5
+    {0x1133d, 0x1133d}, // 1
+    {0x1133e, 0x1133f}, // 2
+    {0x11340, 0x11340}, // 1
+    {0x11341, 0x11344}, // 4
+    {0x11347, 0x11348}, // 2
+    {0x1134b, 0x1134c}, // 2
+    {0x11350, 0x11350}, // 1
+    {0x11357, 0x11357}, // 1
+    {0x1135d, 0x11361}, // 5
+    {0x11362, 0x11363}, // 2
+    {0x11400, 0x11434}, // 53
+    {0x11435, 0x11437}, // 3
+    {0x11438, 0x1143f}, // 8
+    {0x11440, 0x11441}, // 2
+    {0x11443, 0x11444}, // 2
+    {0x11445, 0x11445}, // 1
+    {0x11447, 0x1144a}, // 4
+    {0x1145f, 0x1145f}, // 1
+    {0x11480, 0x114af}, // 48
+    {0x114b0, 0x114b2}, // 3
+    {0x114b3, 0x114b8}, // 6
+    {0x114b9, 0x114b9}, // 1
+    {0x114ba, 0x114ba}, // 1
+    {0x114bb, 0x114be}, // 4
+    {0x114bf, 0x114c0}, // 2
+    {0x114c1, 0x114c1}, // 1
+    {0x114c4, 0x114c5}, // 2
+    {0x114c7, 0x114c7}, // 1
+    {0x11580, 0x115ae}, // 47
+    {0x115af, 0x115b1}, // 3
+    {0x115b2, 0x115b5}, // 4
+    {0x115b8, 0x115bb}, // 4
+    {0x115bc, 0x115bd}, // 2
+    {0x115be, 0x115be}, // 1
+    {0x115d8, 0x115db}, // 4
+    {0x115dc, 0x115dd}, // 2
+    {0x11600, 0x1162f}, // 48
+    {0x11630, 0x11632}, // 3
+    {0x11633, 0x1163a}, // 8
+    {0x1163b, 0x1163c}, // 2
+    {0x1163d, 0x1163d}, // 1
+    {0x1163e, 0x1163e}, // 1
+    {0x11640, 0x11640}, // 1
+    {0x11644, 0x11644}, // 1
+    {0x11680, 0x116aa}, // 43
+    {0x116ab, 0x116ab}, // 1
+    {0x116ac, 0x116ac}, // 1
+    {0x116ad, 0x116ad}, // 1
+    {0x116ae, 0x116af}, // 2
+    {0x116b0, 0x116b5}, // 6
+    {0x116b8, 0x116b8}, // 1
+    {0x11700, 0x1171a}, // 27
+    {0x1171d, 0x1171f}, // 3
+    {0x11720, 0x11721}, // 2
+    {0x11722, 0x11725}, // 4
+    {0x11726, 0x11726}, // 1
+    {0x11727, 0x1172a}, // 4
+    {0x11800, 0x1182b}, // 44
+    {0x1182c, 0x1182e}, // 3
+    {0x1182f, 0x11837}, // 9
+    {0x11838, 0x11838}, // 1
+    {0x118a0, 0x118df}, // 64
+    {0x118ff, 0x118ff}, // 1
+    {0x119a0, 0x119a7}, // 8
+    {0x119aa, 0x119d0}, // 39
+    {0x119d1, 0x119d3}, // 3
+    {0x119d4, 0x119d7}, // 4
+    {0x119da, 0x119db}, // 2
+    {0x119dc, 0x119df}, // 4
+    {0x119e1, 0x119e1}, // 1
+    {0x119e3, 0x119e3}, // 1
+    {0x119e4, 0x119e4}, // 1
+    {0x11a00, 0x11a00}, // 1
+    {0x11a01, 0x11a0a}, // 10
+    {0x11a0b, 0x11a32}, // 40
+    {0x11a35, 0x11a38}, // 4
+    {0x11a39, 0x11a39}, // 1
+    {0x11a3a, 0x11a3a}, // 1
+    {0x11a3b, 0x11a3e}, // 4
+    {0x11a50, 0x11a50}, // 1
+    {0x11a51, 0x11a56}, // 6
+    {0x11a57, 0x11a58}, // 2
+    {0x11a59, 0x11a5b}, // 3
+    {0x11a5c, 0x11a89}, // 46
+    {0x11a8a, 0x11a96}, // 13
+    {0x11a97, 0x11a97}, // 1
+    {0x11a9d, 0x11a9d}, // 1
+    {0x11ac0, 0x11af8}, // 57
+    {0x11c00, 0x11c08}, // 9
+    {0x11c0a, 0x11c2e}, // 37
+    {0x11c2f, 0x11c2f}, // 1
+    {0x11c30, 0x11c36}, // 7
+    {0x11c38, 0x11c3d}, // 6
+    {0x11c3e, 0x11c3e}, // 1
+    {0x11c40, 0x11c40}, // 1
+    {0x11c72, 0x11c8f}, // 30
+    {0x11c92, 0x11ca7}, // 22
+    {0x11ca9, 0x11ca9}, // 1
+    {0x11caa, 0x11cb0}, // 7
+    {0x11cb1, 0x11cb1}, // 1
+    {0x11cb2, 0x11cb3}, // 2
+    {0x11cb4, 0x11cb4}, // 1
+    {0x11cb5, 0x11cb6}, // 2
+    {0x11d00, 0x11d06}, // 7
+    {0x11d08, 0x11d09}, // 2
+    {0x11d0b, 0x11d30}, // 38
+    {0x11d31, 0x11d36}, // 6
+    {0x11d3a, 0x11d3a}, // 1
+    {0x11d3c, 0x11d3d}, // 2
+    {0x11d3f, 0x11d41}, // 3
+    {0x11d43, 0x11d43}, // 1
+    {0x11d46, 0x11d46}, // 1
+    {0x11d47, 0x11d47}, // 1
+    {0x11d60, 0x11d65}, // 6
+    {0x11d67, 0x11d68}, // 2
+    {0x11d6a, 0x11d89}, // 32
+    {0x11d8a, 0x11d8e}, // 5
+    {0x11d90, 0x11d91}, // 2
+    {0x11d93, 0x11d94}, // 2
+    {0x11d95, 0x11d95}, // 1
+    {0x11d96, 0x11d96}, // 1
+    {0x11d98, 0x11d98}, // 1
+    {0x11ee0, 0x11ef2}, // 19
+    {0x11ef3, 0x11ef4}, // 2
+    {0x11ef5, 0x11ef6}, // 2
+    {0x12000, 0x12399}, // 922
+    {0x12400, 0x1246e}, // 111
+    {0x12480, 0x12543}, // 196
+    {0x13000, 0x1342e}, // 1071
+    {0x14400, 0x14646}, // 583
+    {0x16800, 0x16a38}, // 569
+    {0x16a40, 0x16a5e}, // 31
+    {0x16ad0, 0x16aed}, // 30
+    {0x16b00, 0x16b2f}, // 48
+    {0x16b40, 0x16b43}, // 4
+    {0x16b63, 0x16b77}, // 21
+    {0x16b7d, 0x16b8f}, // 19
+    {0x16e40, 0x16e7f}, // 64
+    {0x16f00, 0x16f4a}, // 75
+    {0x16f4f, 0x16f4f}, // 1
+    {0x16f50, 0x16f50}, // 1
+    {0x16f51, 0x16f87}, // 55
+    {0x16f8f, 0x16f92}, // 4
+    {0x16f93, 0x16f9f}, // 13
+    {0x16fe0, 0x16fe1}, // 2
+    {0x16fe3, 0x16fe3}, // 1
+    {0x17000, 0x187f7}, // 6136
+    {0x18800, 0x18af2}, // 755
+    {0x1b000, 0x1b11e}, // 287
+    {0x1b150, 0x1b152}, // 3
+    {0x1b164, 0x1b167}, // 4
+    {0x1b170, 0x1b2fb}, // 396
+    {0x1bc00, 0x1bc6a}, // 107
+    {0x1bc70, 0x1bc7c}, // 13
+    {0x1bc80, 0x1bc88}, // 9
+    {0x1bc90, 0x1bc99}, // 10
+    {0x1bc9e, 0x1bc9e}, // 1
+    {0x1d400, 0x1d454}, // 85
+    {0x1d456, 0x1d49c}, // 71
+    {0x1d49e, 0x1d49f}, // 2
+    {0x1d4a2, 0x1d4a2}, // 1
+    {0x1d4a5, 0x1d4a6}, // 2
+    {0x1d4a9, 0x1d4ac}, // 4
+    {0x1d4ae, 0x1d4b9}, // 12
+    {0x1d4bb, 0x1d4bb}, // 1
+    {0x1d4bd, 0x1d4c3}, // 7
+    {0x1d4c5, 0x1d505}, // 65
+    {0x1d507, 0x1d50a}, // 4
+    {0x1d50d, 0x1d514}, // 8
+    {0x1d516, 0x1d51c}, // 7
+    {0x1d51e, 0x1d539}, // 28
+    {0x1d53b, 0x1d53e}, // 4
+    {0x1d540, 0x1d544}, // 5
+    {0x1d546, 0x1d546}, // 1
+    {0x1d54a, 0x1d550}, // 7
+    {0x1d552, 0x1d6a5}, // 340
+    {0x1d6a8, 0x1d6c0}, // 25
+    {0x1d6c2, 0x1d6da}, // 25
+    {0x1d6dc, 0x1d6fa}, // 31
+    {0x1d6fc, 0x1d714}, // 25
+    {0x1d716, 0x1d734}, // 31
+    {0x1d736, 0x1d74e}, // 25
+    {0x1d750, 0x1d76e}, // 31
+    {0x1d770, 0x1d788}, // 25
+    {0x1d78a, 0x1d7a8}, // 31
+    {0x1d7aa, 0x1d7c2}, // 25
+    {0x1d7c4, 0x1d7cb}, // 8
+    {0x1e000, 0x1e006}, // 7
+    {0x1e008, 0x1e018}, // 17
+    {0x1e01b, 0x1e021}, // 7
+    {0x1e023, 0x1e024}, // 2
+    {0x1e026, 0x1e02a}, // 5
+    {0x1e100, 0x1e12c}, // 45
+    {0x1e137, 0x1e13d}, // 7
+    {0x1e14e, 0x1e14e}, // 1
+    {0x1e2c0, 0x1e2eb}, // 44
+    {0x1e800, 0x1e8c4}, // 197
+    {0x1e900, 0x1e943}, // 68
+    {0x1e947, 0x1e947}, // 1
+    {0x1e94b, 0x1e94b}, // 1
+    {0x1ee00, 0x1ee03}, // 4
+    {0x1ee05, 0x1ee1f}, // 27
+    {0x1ee21, 0x1ee22}, // 2
+    {0x1ee24, 0x1ee24}, // 1
+    {0x1ee27, 0x1ee27}, // 1
+    {0x1ee29, 0x1ee32}, // 10
+    {0x1ee34, 0x1ee37}, // 4
+    {0x1ee39, 0x1ee39}, // 1
+    {0x1ee3b, 0x1ee3b}, // 1
+    {0x1ee42, 0x1ee42}, // 1
+    {0x1ee47, 0x1ee47}, // 1
+    {0x1ee49, 0x1ee49}, // 1
+    {0x1ee4b, 0x1ee4b}, // 1
+    {0x1ee4d, 0x1ee4f}, // 3
+    {0x1ee51, 0x1ee52}, // 2
+    {0x1ee54, 0x1ee54}, // 1
+    {0x1ee57, 0x1ee57}, // 1
+    {0x1ee59, 0x1ee59}, // 1
+    {0x1ee5b, 0x1ee5b}, // 1
+    {0x1ee5d, 0x1ee5d}, // 1
+    {0x1ee5f, 0x1ee5f}, // 1
+    {0x1ee61, 0x1ee62}, // 2
+    {0x1ee64, 0x1ee64}, // 1
+    {0x1ee67, 0x1ee6a}, // 4
+    {0x1ee6c, 0x1ee72}, // 7
+    {0x1ee74, 0x1ee77}, // 4
+    {0x1ee79, 0x1ee7c}, // 4
+    {0x1ee7e, 0x1ee7e}, // 1
+    {0x1ee80, 0x1ee89}, // 10
+    {0x1ee8b, 0x1ee9b}, // 17
+    {0x1eea1, 0x1eea3}, // 3
+    {0x1eea5, 0x1eea9}, // 5
+    {0x1eeab, 0x1eebb}, // 17
+    {0x1f130, 0x1f149}, // 26
+    {0x1f150, 0x1f169}, // 26
+    {0x1f170, 0x1f189}, // 26
+    {0x20000, 0x2a6d6}, // 42711
+    {0x2a700, 0x2b734}, // 4149
+    {0x2b740, 0x2b81d}, // 222
+    {0x2b820, 0x2cea1}, // 5762
+    {0x2ceb0, 0x2ebe0}, // 7473
+    {0x2f800, 0x2fa1d}, // 542
+};
+
+static FCharRange DigitCharRange[59] =
+{
+    {0x30, 0x39}, // 10
+    {0x660, 0x669}, // 10
+    {0x6f0, 0x6f9}, // 10
+    {0x7c0, 0x7c9}, // 10
+    {0x966, 0x96f}, // 10
+    {0x9e6, 0x9ef}, // 10
+    {0xa66, 0xa6f}, // 10
+    {0xae6, 0xaef}, // 10
+    {0xb66, 0xb6f}, // 10
+    {0xbe6, 0xbef}, // 10
+    {0xc66, 0xc6f}, // 10
+    {0xce6, 0xcef}, // 10
+    {0xd66, 0xd6f}, // 10
+    {0xde6, 0xdef}, // 10
+    {0xe50, 0xe59}, // 10
+    {0xed0, 0xed9}, // 10
+    {0xf20, 0xf29}, // 10
+    {0x1040, 0x1049}, // 10
+    {0x1090, 0x1099}, // 10
+    {0x17e0, 0x17e9}, // 10
+    {0x1810, 0x1819}, // 10
+    {0x1946, 0x194f}, // 10
+    {0x19d0, 0x19d9}, // 10
+    {0x1a80, 0x1a89}, // 10
+    {0x1a90, 0x1a99}, // 10
+    {0x1b50, 0x1b59}, // 10
+    {0x1bb0, 0x1bb9}, // 10
+    {0x1c40, 0x1c49}, // 10
+    {0x1c50, 0x1c59}, // 10
+    {0xa620, 0xa629}, // 10
+    {0xa8d0, 0xa8d9}, // 10
+    {0xa900, 0xa909}, // 10
+    {0xa9d0, 0xa9d9}, // 10
+    {0xa9f0, 0xa9f9}, // 10
+    {0xaa50, 0xaa59}, // 10
+    {0xabf0, 0xabf9}, // 10
+    {0xff10, 0xff19}, // 10
+    {0x104a0, 0x104a9}, // 10
+    {0x10d30, 0x10d39}, // 10
+    {0x11066, 0x1106f}, // 10
+    {0x110f0, 0x110f9}, // 10
+    {0x11136, 0x1113f}, // 10
+    {0x111d0, 0x111d9}, // 10
+    {0x112f0, 0x112f9}, // 10
+    {0x11450, 0x11459}, // 10
+    {0x114d0, 0x114d9}, // 10
+    {0x11650, 0x11659}, // 10
+    {0x116c0, 0x116c9}, // 10
+    {0x11730, 0x11739}, // 10
+    {0x118e0, 0x118e9}, // 10
+    {0x11c50, 0x11c59}, // 10
+    {0x11d50, 0x11d59}, // 10
+    {0x11da0, 0x11da9}, // 10
+    {0x16a60, 0x16a69}, // 10
+    {0x16b50, 0x16b59}, // 10
+    {0x1d7ce, 0x1d7ff}, // 50
+    {0x1e140, 0x1e149}, // 10
+    {0x1e2f0, 0x1e2f9}, // 10
+    {0x1e950, 0x1e959}, // 10
+};
+
+static FCharRange WhitespaceCharRange[9] =
+{
+    {0x9, 0xd}, // 5
+    {0x20, 0x20}, // 1
+    {0xa0, 0xa0}, // 1
+    {0x1680, 0x1680}, // 1
+    {0x2000, 0x200a}, // 11
+    {0x2028, 0x2029}, // 2
+    {0x202f, 0x202f}, // 1
+    {0x205f, 0x205f}, // 1
+    {0x3000, 0x3000}, // 1
+};
+
+static FCharRange PunctuationCharRange[182] =
+{
+    {0x21, 0x23}, // 3
+    {0x25, 0x2a}, // 6
+    {0x2c, 0x2f}, // 4
+    {0x3a, 0x3b}, // 2
+    {0x3f, 0x40}, // 2
+    {0x5b, 0x5d}, // 3
+    {0x5f, 0x5f}, // 1
+    {0x7b, 0x7b}, // 1
+    {0x7d, 0x7d}, // 1
+    {0xa1, 0xa1}, // 1
+    {0xa7, 0xa7}, // 1
+    {0xab, 0xab}, // 1
+    {0xb6, 0xb7}, // 2
+    {0xbb, 0xbb}, // 1
+    {0xbf, 0xbf}, // 1
+    {0x37e, 0x37e}, // 1
+    {0x387, 0x387}, // 1
+    {0x55a, 0x55f}, // 6
+    {0x589, 0x58a}, // 2
+    {0x5be, 0x5be}, // 1
+    {0x5c0, 0x5c0}, // 1
+    {0x5c3, 0x5c3}, // 1
+    {0x5c6, 0x5c6}, // 1
+    {0x5f3, 0x5f4}, // 2
+    {0x609, 0x60a}, // 2
+    {0x60c, 0x60d}, // 2
+    {0x61b, 0x61b}, // 1
+    {0x61e, 0x61f}, // 2
+    {0x66a, 0x66d}, // 4
+    {0x6d4, 0x6d4}, // 1
+    {0x700, 0x70d}, // 14
+    {0x7f7, 0x7f9}, // 3
+    {0x830, 0x83e}, // 15
+    {0x85e, 0x85e}, // 1
+    {0x964, 0x965}, // 2
+    {0x970, 0x970}, // 1
+    {0x9fd, 0x9fd}, // 1
+    {0xa76, 0xa76}, // 1
+    {0xaf0, 0xaf0}, // 1
+    {0xc77, 0xc77}, // 1
+    {0xc84, 0xc84}, // 1
+    {0xdf4, 0xdf4}, // 1
+    {0xe4f, 0xe4f}, // 1
+    {0xe5a, 0xe5b}, // 2
+    {0xf04, 0xf12}, // 15
+    {0xf14, 0xf14}, // 1
+    {0xf3a, 0xf3d}, // 4
+    {0xf85, 0xf85}, // 1
+    {0xfd0, 0xfd4}, // 5
+    {0xfd9, 0xfda}, // 2
+    {0x104a, 0x104f}, // 6
+    {0x10fb, 0x10fb}, // 1
+    {0x1360, 0x1368}, // 9
+    {0x1400, 0x1400}, // 1
+    {0x166e, 0x166e}, // 1
+    {0x169b, 0x169c}, // 2
+    {0x16eb, 0x16ed}, // 3
+    {0x1735, 0x1736}, // 2
+    {0x17d4, 0x17d6}, // 3
+    {0x17d8, 0x17da}, // 3
+    {0x1800, 0x180a}, // 11
+    {0x1944, 0x1945}, // 2
+    {0x1a1e, 0x1a1f}, // 2
+    {0x1aa0, 0x1aa6}, // 7
+    {0x1aa8, 0x1aad}, // 6
+    {0x1b5a, 0x1b60}, // 7
+    {0x1bfc, 0x1bff}, // 4
+    {0x1c3b, 0x1c3f}, // 5
+    {0x1c7e, 0x1c7f}, // 2
+    {0x1cc0, 0x1cc7}, // 8
+    {0x1cd3, 0x1cd3}, // 1
+    {0x2010, 0x2027}, // 24
+    {0x2030, 0x2043}, // 20
+    {0x2045, 0x2051}, // 13
+    {0x2053, 0x205e}, // 12
+    {0x207d, 0x207e}, // 2
+    {0x208d, 0x208e}, // 2
+    {0x2308, 0x230b}, // 4
+    {0x2329, 0x232a}, // 2
+    {0x2768, 0x2775}, // 14
+    {0x27c5, 0x27c6}, // 2
+    {0x27e6, 0x27ef}, // 10
+    {0x2983, 0x2998}, // 22
+    {0x29d8, 0x29db}, // 4
+    {0x29fc, 0x29fd}, // 2
+    {0x2cf9, 0x2cfc}, // 4
+    {0x2cfe, 0x2cff}, // 2
+    {0x2d70, 0x2d70}, // 1
+    {0x2e00, 0x2e2e}, // 47
+    {0x2e30, 0x2e4f}, // 32
+    {0x3001, 0x3003}, // 3
+    {0x3008, 0x3011}, // 10
+    {0x3014, 0x301f}, // 12
+    {0x3030, 0x3030}, // 1
+    {0x303d, 0x303d}, // 1
+    {0x30a0, 0x30a0}, // 1
+    {0x30fb, 0x30fb}, // 1
+    {0xa4fe, 0xa4ff}, // 2
+    {0xa60d, 0xa60f}, // 3
+    {0xa673, 0xa673}, // 1
+    {0xa67e, 0xa67e}, // 1
+    {0xa6f2, 0xa6f7}, // 6
+    {0xa874, 0xa877}, // 4
+    {0xa8ce, 0xa8cf}, // 2
+    {0xa8f8, 0xa8fa}, // 3
+    {0xa8fc, 0xa8fc}, // 1
+    {0xa92e, 0xa92f}, // 2
+    {0xa95f, 0xa95f}, // 1
+    {0xa9c1, 0xa9cd}, // 13
+    {0xa9de, 0xa9df}, // 2
+    {0xaa5c, 0xaa5f}, // 4
+    {0xaade, 0xaadf}, // 2
+    {0xaaf0, 0xaaf1}, // 2
+    {0xabeb, 0xabeb}, // 1
+    {0xfd3e, 0xfd3f}, // 2
+    {0xfe10, 0xfe19}, // 10
+    {0xfe30, 0xfe52}, // 35
+    {0xfe54, 0xfe61}, // 14
+    {0xfe63, 0xfe63}, // 1
+    {0xfe68, 0xfe68}, // 1
+    {0xfe6a, 0xfe6b}, // 2
+    {0xff01, 0xff03}, // 3
+    {0xff05, 0xff0a}, // 6
+    {0xff0c, 0xff0f}, // 4
+    {0xff1a, 0xff1b}, // 2
+    {0xff1f, 0xff20}, // 2
+    {0xff3b, 0xff3d}, // 3
+    {0xff3f, 0xff3f}, // 1
+    {0xff5b, 0xff5b}, // 1
+    {0xff5d, 0xff5d}, // 1
+    {0xff5f, 0xff65}, // 7
+    {0x10100, 0x10102}, // 3
+    {0x1039f, 0x1039f}, // 1
+    {0x103d0, 0x103d0}, // 1
+    {0x1056f, 0x1056f}, // 1
+    {0x10857, 0x10857}, // 1
+    {0x1091f, 0x1091f}, // 1
+    {0x1093f, 0x1093f}, // 1
+    {0x10a50, 0x10a58}, // 9
+    {0x10a7f, 0x10a7f}, // 1
+    {0x10af0, 0x10af6}, // 7
+    {0x10b39, 0x10b3f}, // 7
+    {0x10b99, 0x10b9c}, // 4
+    {0x10f55, 0x10f59}, // 5
+    {0x11047, 0x1104d}, // 7
+    {0x110bb, 0x110bc}, // 2
+    {0x110be, 0x110c1}, // 4
+    {0x11140, 0x11143}, // 4
+    {0x11174, 0x11175}, // 2
+    {0x111c5, 0x111c8}, // 4
+    {0x111cd, 0x111cd}, // 1
+    {0x111db, 0x111db}, // 1
+    {0x111dd, 0x111df}, // 3
+    {0x11238, 0x1123d}, // 6
+    {0x112a9, 0x112a9}, // 1
+    {0x1144b, 0x1144f}, // 5
+    {0x1145b, 0x1145b}, // 1
+    {0x1145d, 0x1145d}, // 1
+    {0x114c6, 0x114c6}, // 1
+    {0x115c1, 0x115d7}, // 23
+    {0x11641, 0x11643}, // 3
+    {0x11660, 0x1166c}, // 13
+    {0x1173c, 0x1173e}, // 3
+    {0x1183b, 0x1183b}, // 1
+    {0x119e2, 0x119e2}, // 1
+    {0x11a3f, 0x11a46}, // 8
+    {0x11a9a, 0x11a9c}, // 3
+    {0x11a9e, 0x11aa2}, // 5
+    {0x11c41, 0x11c45}, // 5
+    {0x11c70, 0x11c71}, // 2
+    {0x11ef7, 0x11ef8}, // 2
+    {0x11fff, 0x11fff}, // 1
+    {0x12470, 0x12474}, // 5
+    {0x16a6e, 0x16a6f}, // 2
+    {0x16af5, 0x16af5}, // 1
+    {0x16b37, 0x16b3b}, // 5
+    {0x16b44, 0x16b44}, // 1
+    {0x16e97, 0x16e9a}, // 4
+    {0x16fe2, 0x16fe2}, // 1
+    {0x1bc9f, 0x1bc9f}, // 1
+    {0x1da87, 0x1da8b}, // 5
+    {0x1e95e, 0x1e95f}, // 2
+};
+
+static FCharRange SymbolCharRange[226] =
+{
+    {0x24, 0x24}, // 1
+    {0x2b, 0x2b}, // 1
+    {0x3c, 0x3e}, // 3
+    {0x5e, 0x5e}, // 1
+    {0x60, 0x60}, // 1
+    {0x7c, 0x7c}, // 1
+    {0x7e, 0x7e}, // 1
+    {0xa2, 0xa6}, // 5
+    {0xa8, 0xa9}, // 2
+    {0xac, 0xac}, // 1
+    {0xae, 0xb1}, // 4
+    {0xb4, 0xb4}, // 1
+    {0xb8, 0xb8}, // 1
+    {0xd7, 0xd7}, // 1
+    {0xf7, 0xf7}, // 1
+    {0x2c2, 0x2c5}, // 4
+    {0x2d2, 0x2df}, // 14
+    {0x2e5, 0x2eb}, // 7
+    {0x2ed, 0x2ed}, // 1
+    {0x2ef, 0x2ff}, // 17
+    {0x375, 0x375}, // 1
+    {0x384, 0x385}, // 2
+    {0x3f6, 0x3f6}, // 1
+    {0x482, 0x482}, // 1
+    {0x58d, 0x58f}, // 3
+    {0x606, 0x608}, // 3
+    {0x60b, 0x60b}, // 1
+    {0x60e, 0x60f}, // 2
+    {0x6de, 0x6de}, // 1
+    {0x6e9, 0x6e9}, // 1
+    {0x6fd, 0x6fe}, // 2
+    {0x7f6, 0x7f6}, // 1
+    {0x7fe, 0x7ff}, // 2
+    {0x9f2, 0x9f3}, // 2
+    {0x9fa, 0x9fb}, // 2
+    {0xaf1, 0xaf1}, // 1
+    {0xb70, 0xb70}, // 1
+    {0xbf3, 0xbfa}, // 8
+    {0xc7f, 0xc7f}, // 1
+    {0xd4f, 0xd4f}, // 1
+    {0xd79, 0xd79}, // 1
+    {0xe3f, 0xe3f}, // 1
+    {0xf01, 0xf03}, // 3
+    {0xf13, 0xf13}, // 1
+    {0xf15, 0xf17}, // 3
+    {0xf1a, 0xf1f}, // 6
+    {0xf34, 0xf34}, // 1
+    {0xf36, 0xf36}, // 1
+    {0xf38, 0xf38}, // 1
+    {0xfbe, 0xfc5}, // 8
+    {0xfc7, 0xfcc}, // 6
+    {0xfce, 0xfcf}, // 2
+    {0xfd5, 0xfd8}, // 4
+    {0x109e, 0x109f}, // 2
+    {0x1390, 0x1399}, // 10
+    {0x166d, 0x166d}, // 1
+    {0x17db, 0x17db}, // 1
+    {0x1940, 0x1940}, // 1
+    {0x19de, 0x19ff}, // 34
+    {0x1b61, 0x1b6a}, // 10
+    {0x1b74, 0x1b7c}, // 9
+    {0x1fbd, 0x1fbd}, // 1
+    {0x1fbf, 0x1fc1}, // 3
+    {0x1fcd, 0x1fcf}, // 3
+    {0x1fdd, 0x1fdf}, // 3
+    {0x1fed, 0x1fef}, // 3
+    {0x1ffd, 0x1ffe}, // 2
+    {0x2044, 0x2044}, // 1
+    {0x2052, 0x2052}, // 1
+    {0x207a, 0x207c}, // 3
+    {0x208a, 0x208c}, // 3
+    {0x20a0, 0x20bf}, // 32
+    {0x2100, 0x2101}, // 2
+    {0x2103, 0x2106}, // 4
+    {0x2108, 0x2109}, // 2
+    {0x2114, 0x2114}, // 1
+    {0x2116, 0x2118}, // 3
+    {0x211e, 0x2123}, // 6
+    {0x2125, 0x2125}, // 1
+    {0x2127, 0x2127}, // 1
+    {0x2129, 0x2129}, // 1
+    {0x212e, 0x212e}, // 1
+    {0x213a, 0x213b}, // 2
+    {0x2140, 0x2144}, // 5
+    {0x214a, 0x214d}, // 4
+    {0x214f, 0x214f}, // 1
+    {0x218a, 0x218b}, // 2
+    {0x2190, 0x2307}, // 376
+    {0x230c, 0x2328}, // 29
+    {0x232b, 0x2426}, // 252
+    {0x2440, 0x244a}, // 11
+    {0x249c, 0x24e9}, // 78
+    {0x2500, 0x2767}, // 616
+    {0x2794, 0x27c4}, // 49
+    {0x27c7, 0x27e5}, // 31
+    {0x27f0, 0x2982}, // 403
+    {0x2999, 0x29d7}, // 63
+    {0x29dc, 0x29fb}, // 32
+    {0x29fe, 0x2b73}, // 374
+    {0x2b76, 0x2b95}, // 32
+    {0x2b98, 0x2bff}, // 104
+    {0x2ce5, 0x2cea}, // 6
+    {0x2e80, 0x2e99}, // 26
+    {0x2e9b, 0x2ef3}, // 89
+    {0x2f00, 0x2fd5}, // 214
+    {0x2ff0, 0x2ffb}, // 12
+    {0x3004, 0x3004}, // 1
+    {0x3012, 0x3013}, // 2
+    {0x3020, 0x3020}, // 1
+    {0x3036, 0x3037}, // 2
+    {0x303e, 0x303f}, // 2
+    {0x309b, 0x309c}, // 2
+    {0x3190, 0x3191}, // 2
+    {0x3196, 0x319f}, // 10
+    {0x31c0, 0x31e3}, // 36
+    {0x3200, 0x321e}, // 31
+    {0x322a, 0x3247}, // 30
+    {0x3250, 0x3250}, // 1
+    {0x3260, 0x327f}, // 32
+    {0x328a, 0x32b0}, // 39
+    {0x32c0, 0x33ff}, // 320
+    {0x4dc0, 0x4dff}, // 64
+    {0xa490, 0xa4c6}, // 55
+    {0xa700, 0xa716}, // 23
+    {0xa720, 0xa721}, // 2
+    {0xa789, 0xa78a}, // 2
+    {0xa828, 0xa82b}, // 4
+    {0xa836, 0xa839}, // 4
+    {0xaa77, 0xaa79}, // 3
+    {0xab5b, 0xab5b}, // 1
+    {0xfb29, 0xfb29}, // 1
+    {0xfbb2, 0xfbc1}, // 16
+    {0xfdfc, 0xfdfd}, // 2
+    {0xfe62, 0xfe62}, // 1
+    {0xfe64, 0xfe66}, // 3
+    {0xfe69, 0xfe69}, // 1
+    {0xff04, 0xff04}, // 1
+    {0xff0b, 0xff0b}, // 1
+    {0xff1c, 0xff1e}, // 3
+    {0xff3e, 0xff3e}, // 1
+    {0xff40, 0xff40}, // 1
+    {0xff5c, 0xff5c}, // 1
+    {0xff5e, 0xff5e}, // 1
+    {0xffe0, 0xffe6}, // 7
+    {0xffe8, 0xffee}, // 7
+    {0xfffc, 0xfffd}, // 2
+    {0x10137, 0x1013f}, // 9
+    {0x10179, 0x10189}, // 17
+    {0x1018c, 0x1018e}, // 3
+    {0x10190, 0x1019b}, // 12
+    {0x101a0, 0x101a0}, // 1
+    {0x101d0, 0x101fc}, // 45
+    {0x10877, 0x10878}, // 2
+    {0x10ac8, 0x10ac8}, // 1
+    {0x1173f, 0x1173f}, // 1
+    {0x11fd5, 0x11ff1}, // 29
+    {0x16b3c, 0x16b3f}, // 4
+    {0x16b45, 0x16b45}, // 1
+    {0x1bc9c, 0x1bc9c}, // 1
+    {0x1d000, 0x1d0f5}, // 246
+    {0x1d100, 0x1d126}, // 39
+    {0x1d129, 0x1d164}, // 60
+    {0x1d16a, 0x1d16c}, // 3
+    {0x1d183, 0x1d184}, // 2
+    {0x1d18c, 0x1d1a9}, // 30
+    {0x1d1ae, 0x1d1e8}, // 59
+    {0x1d200, 0x1d241}, // 66
+    {0x1d245, 0x1d245}, // 1
+    {0x1d300, 0x1d356}, // 87
+    {0x1d6c1, 0x1d6c1}, // 1
+    {0x1d6db, 0x1d6db}, // 1
+    {0x1d6fb, 0x1d6fb}, // 1
+    {0x1d715, 0x1d715}, // 1
+    {0x1d735, 0x1d735}, // 1
+    {0x1d74f, 0x1d74f}, // 1
+    {0x1d76f, 0x1d76f}, // 1
+    {0x1d789, 0x1d789}, // 1
+    {0x1d7a9, 0x1d7a9}, // 1
+    {0x1d7c3, 0x1d7c3}, // 1
+    {0x1d800, 0x1d9ff}, // 512
+    {0x1da37, 0x1da3a}, // 4
+    {0x1da6d, 0x1da74}, // 8
+    {0x1da76, 0x1da83}, // 14
+    {0x1da85, 0x1da86}, // 2
+    {0x1e14f, 0x1e14f}, // 1
+    {0x1e2ff, 0x1e2ff}, // 1
+    {0x1ecac, 0x1ecac}, // 1
+    {0x1ecb0, 0x1ecb0}, // 1
+    {0x1ed2e, 0x1ed2e}, // 1
+    {0x1eef0, 0x1eef1}, // 2
+    {0x1f000, 0x1f02b}, // 44
+    {0x1f030, 0x1f093}, // 100
+    {0x1f0a0, 0x1f0ae}, // 15
+    {0x1f0b1, 0x1f0bf}, // 15
+    {0x1f0c1, 0x1f0cf}, // 15
+    {0x1f0d1, 0x1f0f5}, // 37
+    {0x1f110, 0x1f16c}, // 93
+    {0x1f170, 0x1f1ac}, // 61
+    {0x1f1e6, 0x1f202}, // 29
+    {0x1f210, 0x1f23b}, // 44
+    {0x1f240, 0x1f248}, // 9
+    {0x1f250, 0x1f251}, // 2
+    {0x1f260, 0x1f265}, // 6
+    {0x1f300, 0x1f6d5}, // 982
+    {0x1f6e0, 0x1f6ec}, // 13
+    {0x1f6f0, 0x1f6fa}, // 11
+    {0x1f700, 0x1f773}, // 116
+    {0x1f780, 0x1f7d8}, // 89
+    {0x1f7e0, 0x1f7eb}, // 12
+    {0x1f800, 0x1f80b}, // 12
+    {0x1f810, 0x1f847}, // 56
+    {0x1f850, 0x1f859}, // 10
+    {0x1f860, 0x1f887}, // 40
+    {0x1f890, 0x1f8ad}, // 30
+    {0x1f900, 0x1f90b}, // 12
+    {0x1f90d, 0x1f971}, // 101
+    {0x1f973, 0x1f976}, // 4
+    {0x1f97a, 0x1f9a2}, // 41
+    {0x1f9a5, 0x1f9aa}, // 6
+    {0x1f9ae, 0x1f9ca}, // 29
+    {0x1f9cd, 0x1fa53}, // 135
+    {0x1fa60, 0x1fa6d}, // 14
+    {0x1fa70, 0x1fa73}, // 4
+    {0x1fa78, 0x1fa7a}, // 3
+    {0x1fa80, 0x1fa82}, // 3
+    {0x1fa90, 0x1fa95}, // 6
+};
+
+static FCharRange BlankCharRange[8] =
+{
+    {0x9, 0x9}, // 1
+    {0x20, 0x20}, // 1
+    {0xa0, 0xa0}, // 1
+    {0x1680, 0x1680}, // 1
+    {0x2000, 0x200a}, // 11
+    {0x202f, 0x202f}, // 1
+    {0x205f, 0x205f}, // 1
+    {0x3000, 0x3000}, // 1
+};
diff --git a/test/srfi.scm b/test/srfi.scm
index d4f3023..c546222 100644
--- a/test/srfi.scm
+++ b/test/srfi.scm
@@ -1791,3 +1791,860 @@
 (check-equal (3 2) (reverse-vector->list '#(1 2 3) 1))
 (check-equal (2 1) (reverse-vector->list '#(1 2 3) 0 2))
 (check-equal #(3 2 1) (reverse-list->vector '(1 2 3)))
+
+;;
+;; ---- SRFI 14: Character-set Library ----
+;;
+
+(import (scheme charset))
+
+(check-equal #t (char-set? (char-set #\A)))
+(check-equal #f (char-set? "abcd"))
+(check-equal #f (char-set? #\A))
+
+(check-equal #t (char-set=))
+(check-equal #t (char-set= (char-set #\A)))
+(check-equal #t (char-set= (char-set) (char-set)))
+(check-equal #t (char-set= (char-set #\a #\Z) (char-set #\a #\Z)))
+(check-equal #t (char-set= (char-set #\a #\z #\A #\Z) (char-set #\A #\z #\a #\Z)))
+(check-equal #f (char-set= (char-set #\a #\^ #\Z) (char-set #\a #\Z)))
+(check-equal #f (char-set= (char-set #\a #\Z) (char-set #\a #\^ #\Z)))
+(check-equal #f (char-set= (char-set #\A #\Z) (char-set #\a #\Z)))
+(check-equal #f (char-set= (char-set #\a #\Z) (char-set #\A #\Z)))
+(check-equal #f (char-set= (char-set #\a #\z) (char-set #\a #\Z)))
+(check-equal #f (char-set= (char-set #\a #\Z) (char-set #\a #\z)))
+(check-equal #t (char-set= (char-set #\a #\b #\c #\d) (char-set #\a #\b #\c #\d)))
+(check-equal #f (char-set= (char-set #\a #\b #\d) (char-set #\a #\b #\c #\d)))
+(check-equal #t
+    (char-set= (char-set #\a #\A #\B #\C #\D #\E #\Z) (char-set #\a #\A #\B #\C #\D #\E #\Z)))
+(check-equal #t (char-set= (char-set #\a #\b #\c) (char-set #\a #\b #\c) (char-set #\a #\b #\c)))
+(check-equal #f (char-set= (char-set #\a #\b #\c) (char-set #\a #\b #\c) (char-set #\a #\b)))
+
+(check-equal #t (char-set<=))
+(check-equal #t (char-set<= (char-set #\A)))
+(check-equal #t (char-set<= (char-set) (char-set)))
+(check-equal #t (char-set<= (char-set #\a #\Z) (char-set #\a #\Z)))
+(check-equal #t (char-set<= (char-set #\a #\Z) (char-set #\a #\A #\B #\C #\Z)))
+(check-equal #f (char-set<= (char-set #\a #\z #\Z) (char-set #\a #\A #\B #\C #\Z)))
+(check-equal #t (char-set<= (char-set) (char-set #\a)))
+(check-equal #t (char-set<= (char-set) (char-set #\a) (char-set #\a #\b) (char-set #\a #\b #\c)))
+(check-equal #t
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\l #\m #\n #\x #\y #\z)))
+(check-equal #t
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\k #\l #\m #\n #\x #\y #\z)))
+(check-equal #t
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\k #\l #\m #\n #\o #\x #\y #\z)))
+
+(check-equal #f
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\l #\m #\x #\y #\z)))
+(check-equal #f
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\k #\l #\n #\x #\y #\z)))
+(check-equal #f
+    (char-set<=
+        (char-set #\l #\m #\n)
+        (char-set #\a #\b #\c #\k #\l #\m #\o #\x #\y #\z)))
+
+(check-equal #t (>= (char-set-hash (char-set)) 0))
+(check-equal #t (>= (char-set-hash (char-set #\a #\b #\c)) 0))
+(check-equal #t
+    (=
+        (char-set-hash (char-set))
+        (char-set-hash (char-set))))
+(check-equal #t
+    (=
+        (char-set-hash (char-set #\a #\b #\c))
+        (char-set-hash (char-set #\a #\b #\c))))
+(check-equal #f
+    (=
+        (char-set-hash (char-set #\a #\b #\c))
+        (char-set-hash (char-set #\x #\y #\z))))
+(check-equal #f
+    (=
+        (char-set-hash (char-set #\a #\b #\c) 123)
+        (char-set-hash (char-set #\a #\b #\c))))
+
+(check-equal #t (end-of-char-set? (char-set-cursor (char-set))))
+(check-equal #f (end-of-char-set? (char-set-cursor (char-set #\A))))
+(check-equal #\A
+    (let* ((cset (char-set #\A))
+            (cursor (char-set-cursor cset)))
+        (char-set-ref cset cursor)))
+(check-equal (#\A #\B #\C #\Q #\X #\a #\d #\e #\x #\y #\z)
+    (let ((cset (char-set #\Q #\d #\C #\a #\z #\X #\x #\y #\e #\B #\A)))
+        (define (walk cursor)
+            (if (end-of-char-set? cursor)
+                '()
+                (cons (char-set-ref cset cursor) (walk (char-set-cursor-next cset cursor)))))
+        (walk (char-set-cursor cset))))
+
+(check-equal (#\c #\b #\a)
+    (char-set-fold cons '() (char-set #\a #\b #\c)))
+
+(check-equal 5
+    (char-set-fold (lambda (ch cnt) (+ cnt 1)) 0 (char-set #\1 #\2 #\3 #\4 #\5)))
+
+(check-equal 3
+    (char-set-fold
+        (lambda (ch cnt) (if (char-numeric? ch) (+ cnt 1) cnt))
+        0 (char-set #\a #\2 #\b #\4 #\c #\6 #\d)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\y #\z)
+        (char-set-unfold car null? cdr '(#\a #\b #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\y #\z)
+        (char-set-unfold car null? cdr '(#\a #\b) (char-set #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\y #\z)
+        (char-set-unfold! car null? cdr '(#\a #\b) (char-set #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C)
+        (char-set-map char-upcase (char-set #\a #\b #\c))))
+
+(check-equal (#\A #\B #\C #\D)
+    (let ((lst '()))
+        (char-set-for-each
+            (lambda (ch) (set! lst (cons ch lst)))
+            (char-set #\A #\B #\C #\D))
+        lst))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C)
+        (char-set-map char-upcase (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (let ((cset (char-set #\a #\B #\c #\D)))
+        (char-set= cset (char-set-copy cset))))
+
+(check-equal #t
+    (char-set=
+        (list->char-set '(#\1 #\2 #\3 #\a #\b #\c))
+        (string->char-set "abc123")))
+
+(check-equal #t
+    (char-set=
+        (list->char-set '(#\1 #\2 #\3) (char-set #\a #\b #\c))
+        (char-set #\1 #\2 #\3 #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "123" (char-set #\a #\b #\c))
+        (char-set #\1 #\2 #\3 #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (list->char-set '(#\1 #\2 #\3 #\a #\b #\c) (char-set #\x #\y #\z))
+        (char-set #\x #\y #\z #\1 #\2 #\3 #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "xyz123" (char-set #\a #\b #\c))
+        (char-set #\x #\y #\z #\1 #\2 #\3 #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\2 #\4 #\6)
+        (char-set-filter char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\2 #\4 #\6 #\x #\y #\z)
+        (char-set-filter char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\2 #\4 #\6 #\x #\y #\z)
+        (char-set-filter! char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (->char-set "abc")))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a)
+        (->char-set #\a)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (->char-set (char-set #\a #\b #\c))))
+
+(check-equal 0 (char-set-size (char-set)))
+(check-equal 5 (char-set-size (char-set #\a #\b #\c #\d #\e)))
+
+(check-equal 3
+    (char-set-count char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d)))
+
+(check-equal (#\c #\b #\a)
+    (char-set->list (char-set #\a #\b #\c)))
+
+(check-equal "cba"
+    (char-set->string (char-set #\a #\b #\c)))
+
+(check-equal #t (char-set-contains? (char-set #\a #\b #\c) #\b))
+(check-equal #f (char-set-contains? (char-set #\a #\b #\c) #\B))
+
+(check-equal #f
+    (char-set-every char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d)))
+
+(check-equal #t
+    (char-set-every char-numeric? (char-set #\2 #\4 #\6)))
+
+(check-equal #t
+    (char-set-any char-numeric? (char-set #\a #\2 #\b #\4 #\c #\6 #\d)))
+
+(check-equal #\A
+    (char-set-any (lambda (ch) (and (char-upper-case? ch) ch)) (char-set #\a #\b #\A)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-adjoin (char-set #\x #\y #\z) #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-delete (char-set #\a #\b #\c #\x #\y #\z) #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-delete (char-set #\x #\y #\z) #\a #\b #\c)))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-union)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-union (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-union
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-union
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\m #\n #\l #\c #\x #\y #\z)
+        (char-set-union
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z)
+            (char-set #\m #\n #\l))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (char-set-union
+            (char-set #\a #\b #\c)
+            char-set:empty)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\m #\n #\l #\c #\x #\y #\z)
+        (char-set-union
+            char-set:empty
+            (char-set #\a #\b #\c)
+            char-set:empty
+            (char-set #\x #\y #\z)
+            char-set:empty
+            (char-set #\m #\n #\l))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-union! (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-union!
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-union!
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\m #\n #\l #\c #\x #\y #\z)
+        (char-set-union!
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z)
+            (char-set #\m #\n #\l))))
+
+(check-equal #t
+    (char-set=
+        char-set:full
+        (char-set-intersection)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-intersection
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection
+            (char-set #\x #\y #\z)
+            (char-set #\a #\b #\c #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection
+            char-set:ascii
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection
+            char-set:ascii
+            (char-set #\A #\B #\C #\X #\Y #\Z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection
+            (char-set #\A #\B #\C #\X #\Y #\Z)
+            char-set:ascii)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection
+            char-set:ascii
+            (char-set #\A #\B #\C)
+            (char-set #\X #\Y #\Z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection! (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-intersection!
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection!
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection!
+            (char-set #\x #\y #\z)
+            (char-set #\a #\b #\c #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-intersection!
+            char-set:ascii
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection!
+            char-set:ascii
+            (char-set #\A #\B #\C #\X #\Y #\Z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection!
+            (char-set #\A #\B #\C #\X #\Y #\Z)
+            char-set:ascii)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\X #\Y #\Z)
+        (char-set-intersection!
+            char-set:ascii
+            (char-set #\A #\B #\C)
+            (char-set #\X #\Y #\Z))))
+
+(check-equal #t
+    (char-set=
+        (char-set)
+        (char-set-intersection
+            (char-set #\a #\b #\c)
+            (char-set #\d #\f #\g))))
+
+(check-equal #t
+    (char-set=
+        (char-set)
+        (char-set-intersection
+            (char-set #\d #\f #\g)
+            (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\d #\e #\h #\i)
+        (char-set-intersection
+            (char-set #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j)
+            (char-set #\d #\e #\h #\i))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\d #\e #\h #\i #\j)
+        (char-set-intersection
+            (char-set #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j)
+            (char-set #\A #\B #\C #\d #\e #\h #\i #\j #\k #\l))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\d #\e #\h #\i)
+        (char-set-intersection
+            (char-set #\d #\e #\h #\i)
+            (char-set #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\d #\e #\h #\i #\j)
+        (char-set-intersection
+            (char-set #\A #\B #\C #\d #\e #\h #\i #\j #\k #\l)
+            (char-set #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (char-set-difference
+            (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (char-set-difference
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-difference
+            (char-set #\x #\y #\z)
+            (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (char-set-difference
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-difference
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-difference
+            (char-set #\x #\y #\z)
+            (char-set #\a #\b #\c #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-difference
+            (char-set #\a #\b #\c)
+            (char-set #\a #\b #\c #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\l #\m #\n)
+        (char-set-difference
+            (char-set #\a #\b #\c #\l #\m #\n #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\l #\n)
+        (char-set-difference
+            (char-set #\a #\b #\c #\l #\m #\n #\x #\y #\z)
+            (char-set #\m #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\A #\B #\C #\x #\y #\z)
+        (char-set-difference
+            (char-set #\A #\B #\C #\a #\b #\c #\x #\y #\z)
+            (char-set #\a #\b #\c))))
+
+(check-equal #t
+    (char-set=
+        char-set:empty
+        (char-set-xor)))
+
+(check-equal #t
+    (char-set=
+        (char-set #\x #\y #\z)
+        (char-set-xor (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\x #\y #\z)
+        (char-set-xor
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c)
+        (char-set-xor
+            (char-set #\a #\b #\c #\x #\y #\z)
+            (char-set #\x #\y #\z))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\m #\n #\l #\c #\x #\y #\z)
+        (char-set-xor
+            (char-set #\a #\b #\c)
+            (char-set #\x #\y #\z)
+            (char-set #\m #\n #\l))))
+
+(check-equal #t
+    (char-set=
+        (char-set #\a #\b #\c #\n #\l #\y #\z)
+        (char-set-xor
+            (char-set #\a #\b #\c #\m #\x)
+            (char-set #\x #\y #\z)
+            (char-set #\m #\n #\l))))
+
+(check-equal 128 (char-set-size char-set:ascii))
+(check-equal #t (char-set-contains? char-set:ascii #\a))
+(check-equal #f (char-set-contains? char-set:ascii (integer->char 128)))
+
+(check-equal 0 (char-set-size char-set:empty))
+(check-equal #f (char-set-contains? char-set:empty #\a))
+
+;; From Chibi Scheme
+
+(check-equal #f (char-set? 5))
+
+(check-equal #t (char-set? (char-set #\a #\e #\i #\o #\u)))
+
+(check-equal #t (char-set=))
+(check-equal #t (char-set= (char-set)))
+
+(check-equal #t (char-set= (char-set #\a #\e #\i #\o #\u) (string->char-set "ioeauaiii")))
+
+(check-equal #f (char-set= (char-set #\e #\i #\o #\u) (string->char-set "ioeauaiii")))
+
+(check-equal #t (char-set<=))
+(check-equal #t (char-set<= (char-set)))
+
+(check-equal #t (char-set<= (char-set #\a #\e #\i #\o #\u) (string->char-set "ioeauaiii")))
+
+(check-equal #t (char-set<= (char-set #\e #\i #\o #\u) (string->char-set "ioeauaiii")))
+
+(check-equal #t (<= 0 (char-set-hash char-set:ascii 100) 99))
+
+(check-equal 4 (char-set-fold (lambda (c i) (+ i 1)) 0 (char-set #\e #\i #\o #\u #\e #\e)))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "eiaou2468013579999")
+        (char-set-unfold car null? cdr
+            '(#\a #\e #\i #\o #\u #\u #\u)
+            (char-set-intersection char-set:ascii
+                (char-set #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "eiaou246801357999")
+        (char-set-unfold! car null? cdr '(#\a #\e #\i #\o #\u) (string->char-set "0123456789"))))
+
+(check-equal #f
+    (char-set=
+        (string->char-set "eiaou246801357")
+        (char-set-unfold! car null? cdr '(#\a #\e #\i #\o #\u) (string->char-set "0123456789"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "97531")
+        (let ((cs (string->char-set "0123456789")))
+            (char-set-for-each
+                (lambda (c) (set! cs (char-set-delete cs c)))
+                (string->char-set "02468000"))
+            cs)))
+
+(check-equal #f
+    (let ((cs (string->char-set "0123456789")))
+        (char-set-for-each
+            (lambda (c) (set! cs (char-set-delete cs c)))
+            (string->char-set "02468"))
+        (char-set= cs (string->char-set "7531"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "IOUAEEEE")
+        (char-set-map char-upcase (string->char-set "aeiou"))))
+
+(check-equal #f
+    (char-set=
+        (char-set-map char-upcase (string->char-set "aeiou"))
+        (string->char-set "OUAEEEE")))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "aeiou")
+        (char-set-copy (string->char-set "aeiou"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "xy")
+        (char-set #\x #\y)))
+
+(check-equal #f (char-set= (char-set #\x #\y #\z) (string->char-set "xy")))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "xy")
+        (list->char-set '(#\x #\y))))
+
+(check-equal #f (char-set= (string->char-set "axy") (list->char-set '(#\x #\y))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "xy12345")
+        (list->char-set '(#\x #\y) (string->char-set "12345"))))
+
+(check-equal #f
+    (char-set=
+        (string->char-set "y12345")
+        (list->char-set '(#\x #\y) (string->char-set "12345"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "xy12345")
+        (list->char-set! '(#\x #\y) (string->char-set "12345"))))
+
+(check-equal #f
+    (char-set=
+        (string->char-set "y12345")
+        (list->char-set! '(#\x #\y) (string->char-set "12345"))))
+
+(define (vowel? ch)
+    (member ch '(#\a #\e #\i #\o #\u)))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "aeiou12345")
+        (char-set-filter vowel? char-set:ascii (string->char-set "12345"))))
+
+(check-equal #f
+    (char-set=
+        (string->char-set "aeou12345")
+        (char-set-filter vowel? char-set:ascii (string->char-set "12345"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "aeiou12345")
+        (char-set-filter! vowel? char-set:ascii (string->char-set "12345"))))
+
+(check-equal #f
+    (char-set=
+        (string->char-set "aeou12345")
+        (char-set-filter! vowel? char-set:ascii (string->char-set "12345"))))
+
+(check-equal #t
+    (char-set=
+        (string->char-set "abcdef12345")
+        (ucs-range->char-set 97 103 #t (string->char-set "12345"))))
+(check-equal #f
+    (char-set=
+        (string->char-set "abcef12345")
+        (ucs-range->char-set 97 103 #t (string->char-set "12345"))))
+
+(check-equal #t
+    (char-set=
+            (string->char-set "abcdef12345")
+            (ucs-range->char-set! 97 103 #t (string->char-set "12345"))))
+(check-equal #f
+    (char-set=
+        (string->char-set "abcef12345")
+        (ucs-range->char-set! 97 103 #t (string->char-set "12345"))))
+
+(check-equal #t
+    (char-set= (->char-set #\x) (->char-set "x") (->char-set (char-set #\x))))
+
+(check-equal #f
+    (char-set= (->char-set #\x) (->char-set "y") (->char-set (char-set #\x))))
+
+(check-equal 10
+    (char-set-size (char-set-intersection char-set:ascii (string->char-set "0123456789"))))
+
+(check-equal 5 (char-set-count vowel? char-set:ascii))
+
+(check-equal (#\x) (char-set->list (char-set #\x)))
+(check-equal #f (equal? '(#\X) (char-set->list (char-set #\x))))
+
+(check-equal "x" (char-set->string (char-set #\x)))
+(check-equal #f (equal? "X" (char-set->string (char-set #\x))))
+
+(check-equal #t (char-set-contains? (->char-set "xyz") #\x))
+(check-equal #f (char-set-contains? (->char-set "xyz") #\a))
+
+(check-equal #t (char-set-every char-lower-case? (->char-set "abcd")))
+(check-equal #f (char-set-every char-lower-case? (->char-set "abcD")))
+(check-equal #t (char-set-any char-lower-case? (->char-set "abcd")))
+(check-equal #f (char-set-any char-lower-case? (->char-set "ABCD")))
+
+(check-equal #t
+    (char-set=
+        (->char-set "ABCD")
+        (let ((cs (->char-set "abcd")))
+            (let lp ((cur (char-set-cursor cs)) (ans '()))
+                (if (end-of-char-set? cur) (list->char-set ans)
+                    (lp (char-set-cursor-next cs cur)
+                        (cons (char-upcase (char-set-ref cs cur)) ans)))))))
+
+(check-equal #t
+    (char-set=
+        (->char-set "123xa")
+        (char-set-adjoin (->char-set "123") #\x #\a)))
+(check-equal #f (char-set= (char-set-adjoin (->char-set "123") #\x #\a) (->char-set "123x")))
+(check-equal #t
+    (char-set=
+        (->char-set "123xa")
+        (char-set-adjoin! (->char-set "123") #\x #\a)))
+(check-equal #f (char-set= (char-set-adjoin! (->char-set "123") #\x #\a) (->char-set "123x")))
+
+(check-equal #t
+    (char-set=
+        (->char-set "13")
+        (char-set-delete (->char-set "123") #\2 #\a #\2)))
+(check-equal #f (char-set= (char-set-delete (->char-set "123") #\2 #\a #\2) (->char-set "13a")))
+(check-equal #t
+    (char-set=
+        (->char-set "13")
+        (char-set-delete! (->char-set "123") #\2 #\a #\2)))
+(check-equal #f (char-set= (char-set-delete! (->char-set "123") #\2 #\a #\2) (->char-set "13a")))
+
+(define digit (char-set #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9))
+(define hex-digit
+    (char-set #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 #\a #\b #\c #\d #\e #\f
+        #\A #\B #\C #\D #\E #\F))
+
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEF")
+        (char-set-intersection hex-digit (char-set-complement digit))))
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEF")
+        (char-set-intersection! (char-set-complement! (->char-set "0123456789")) hex-digit)))
+
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEFghijkl0123456789")
+        (char-set-union hex-digit (->char-set "abcdefghijkl"))))
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEFghijkl0123456789")
+        (char-set-union! (->char-set "abcdefghijkl") hex-digit)))
+
+(check-equal #t
+    (char-set=
+        (->char-set "ghijklmn")
+        (char-set-difference (->char-set "abcdefghijklmn") hex-digit)))
+(check-equal #t
+    (char-set=
+        (->char-set "ghijklmn")
+        (char-set-difference! (->char-set "abcdefghijklmn") hex-digit)))
+
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEF")
+        (char-set-xor (->char-set "0123456789") hex-digit)))
+(check-equal #t
+    (char-set=
+        (->char-set "abcdefABCDEF")
+        (char-set-xor! (->char-set "0123456789") hex-digit)))
+
+(define letter (string->char-set "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+(check-equal (#t . #t)
+    (call-with-values
+        (lambda ()
+            (char-set-diff+intersection hex-digit letter))
+        (lambda (d i)
+            (cons
+                (char-set= d (->char-set "0123456789"))
+                (char-set= i (->char-set "abcdefABCDEF"))))))
+
+(check-equal (#t . #t)
+    (call-with-values
+        (lambda ()
+            (char-set-diff+intersection! (char-set-copy hex-digit) (char-set-copy letter)))
+        (lambda (d i)
+            (cons
+                (char-set= d (->char-set "0123456789"))
+                (char-set= i (->char-set "abcdefABCDEF"))))))
+
diff --git a/windows/genudf.cpp b/unidata/gencase.cpp
index 242eae7..18db2ee 100644
--- a/windows/genudf.cpp
+++ b/unidata/gencase.cpp
@@ -2,7 +2,7 @@
 
 Generate Upcase, Downcase and Foldcase Unicode Tables
 
-genudf <file> Upcase|Downcase|Foldcase|Fullfold|Fullup|Fulldown <field> <max-gap>
+gencase <file> Upcase|Downcase|Foldcase|Fullfold|Fullup|Fulldown <field> <max-gap>
 
 */
 
@@ -55,7 +55,7 @@ unsigned int ParseCodePoint(char * fld)
             n = n * 16 + *fld - 'A' + 10;
         else
         {
-            fprintf(stderr, "error: genudf: unable to parse field: %s\n", s);
+            fprintf(stderr, "error: gencase: unable to parse field: %s\n", s);
             return(0);
         }
 
@@ -94,7 +94,7 @@ unsigned int ParseSeveralPoints(char * fld, unsigned int chars[MAX_FULL_CHARS])
 void Usage()
 {
     fprintf(stderr,
-            "usage: genudf <file> Upcase|Downcase|Foldcase|Fullfold|Fullup|Fulldown  <field> <max-gap>\n");
+            "usage: gencase <file> Upcase|Downcase|Foldcase|Fullfold|Fullup|Fulldown  <field> <max-gap>\n");
 }
 
 typedef struct
@@ -131,7 +131,7 @@ int main(int argc, char * argv[])
             && strcmp(argv[2], "Fulldown"))
     {
         fprintf(stderr,
-                "error: genudf: expected 'Upcase', 'Downcase', 'Foldcase', 'Fullfold', 'Fullup', or 'Fulldown'\n");
+                "error: gencase: expected 'Upcase', 'Downcase', 'Foldcase', 'Fullfold', 'Fullup', or 'Fulldown'\n");
         return(1);
     }
 
@@ -145,7 +145,7 @@ int main(int argc, char * argv[])
     FILE * fp = fopen(argv[1], "rt");
     if (fp == 0)
     {
-        fprintf(stderr, "error: genudf: unable to open %s\n", argv[1]);
+        fprintf(stderr, "error: gencase: unable to open %s\n", argv[1]);
         return(1);
     }
 
@@ -173,7 +173,7 @@ int main(int argc, char * argv[])
 
             if (fdx >= nflds)
             {
-                fprintf(stderr, "error: genudf: <field> too large: %d\n", fdx);
+                fprintf(stderr, "error: gencase: <field> too large: %d\n", fdx);
                 return(1);
             }
 
@@ -188,7 +188,7 @@ int main(int argc, char * argv[])
 
                     if (FullMap[idx].Count == 0)
                     {
-                        fprintf(stderr, "error: genudf: unexpected full mapping: 0x%04x\n", idx);
+                        fprintf(stderr, "error: gencase: unexpected full mapping: 0x%04x\n", idx);
                         return(1);
                     }
                 }
diff --git a/unidata/gencrng.cpp b/unidata/gencrng.cpp
new file mode 100644
index 0000000..0fed7b0
--- /dev/null
+++ b/unidata/gencrng.cpp
@@ -0,0 +1,143 @@
+/*
+
+Generate character ranges for a char-set
+
+gencrng <file> <name> <letter-category> | +<character-code> ...
+
+*/
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_FULL_CHARS 3
+
+int ParseFields(char * s, char ** flds)
+{
+    int nflds = 0;
+
+    for (;;)
+    {
+        char * f = strchr(s, ';');
+
+        while (*s == ' ')
+            s += 1;
+
+        if (*s == 0)
+            flds[nflds] = 0;
+        else
+            flds[nflds] = s;
+
+        nflds += 1;
+        if (f == 0)
+            break;
+
+        *f = 0;
+        s = f + 1;
+    }
+
+    return(nflds);
+}
+
+unsigned int ParseCodePoint(char * fld)
+{
+    char * s = fld;
+    unsigned int n = 0;
+
+    while (*fld)
+    {
+        if (*fld >= '0' && *fld <= '9')
+            n = n * 16 + *fld - '0';
+        else if (*fld >= 'a' && *fld <= 'f')
+            n = n * 16 + *fld - 'a' + 10;
+        else if (*fld >= 'A' && *fld <= 'F')
+            n = n * 16 + *fld - 'A' + 10;
+        else
+        {
+            fprintf(stderr, "error: gencrng: unable to parse field: %s\n", s);
+            return(0);
+        }
+
+        fld += 1;
+    }
+
+    return(n);
+}
+
+void Usage()
+{
+    fprintf(stderr, "usage: gencrng <file> <name> <letter-category> | <character-code> ...\n");
+}
+
+typedef struct
+{
+    unsigned int Start;
+    unsigned int End; // Inclusive
+} CharRange;
+
+CharRange Ranges[0x110000];
+unsigned int NumRanges = 0;
+
+void AddCh(unsigned int ch)
+{
+    if (NumRanges == 0 || Ranges[NumRanges - 1].End + 1 < ch)
+    {
+        Ranges[NumRanges].Start = ch;
+        Ranges[NumRanges].End = ch;
+        NumRanges += 1;
+    }
+    else
+        Ranges[NumRanges-1].End += 1;
+}
+
+int main(int argc, char * argv[])
+{
+    char s[256];
+
+    if (argc < 4)
+    {
+        Usage();
+        return(1);
+    }
+
+    FILE * fp = fopen(argv[1], "rt");
+    if (fp == 0)
+    {
+        fprintf(stderr, "error: gencrng: unable to open %s\n", argv[1]);
+        return(1);
+    }
+
+    while (fgets(s, sizeof(s), fp))
+    {
+        char * flds[32];
+
+        if (*s != '#' && *s != '\n')
+        {
+            int nflds = ParseFields(s, flds);
+            if (nflds < 3)
+            {
+                fprintf(stderr, "error: gencrng: not enough fields %s\n", flds[0]);
+                return(1);
+            }
+
+            for (int adx = 3; adx < argc; adx++)
+                if (strcmp(argv[adx], flds[2]) == 0 ||
+                    (argv[adx][0] == '+' && strcmp(argv[adx] + 1, flds[0]) == 0))
+                {
+                    AddCh(ParseCodePoint(flds[0]));
+                    break;
+                }
+        }
+    }
+
+    fclose(fp);
+
+    printf("\nstatic FCharRange %s[%d] =\n{\n", argv[2], NumRanges);
+    for (unsigned int ndx = 0; ndx < NumRanges; ndx++)
+        printf("    {0x%x, 0x%x}, // %d\n", Ranges[ndx].Start, Ranges[ndx].End,
+                Ranges[ndx].End - Ranges[ndx].Start + 1);
+    printf("};\n");
+
+    return(0);
+}
diff --git a/unidata/genul.cpp b/unidata/genul.cpp
new file mode 100644
index 0000000..d19157c
--- /dev/null
+++ b/unidata/genul.cpp
@@ -0,0 +1,155 @@
+/*
+
+Generate UpperCase, and LowerCase unicode character ranges
+
+genul <file> <name> <type>
+
+*/
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int ParseFields(char * s, char ** flds)
+{
+    int nflds = 0;
+
+    for (;;)
+    {
+        char * f = strchr(s, ';');
+
+        while (*s == ' ')
+            s += 1;
+
+        if (*s == 0)
+            flds[nflds] = 0;
+        else
+            flds[nflds] = s;
+
+        nflds += 1;
+        if (f == 0)
+            break;
+
+        *f = 0;
+        s = f + 1;
+    }
+
+    return(nflds);
+}
+
+typedef struct
+{
+    unsigned int Start;
+    unsigned int End; // Inclusive
+} CharRange;
+
+CharRange Ranges[0x110000];
+unsigned int NumRanges = 0;
+
+void AddRange(char * fld)
+{
+    unsigned int strt = 0;
+    unsigned int end = 0;
+
+    while (*fld)
+    {
+        if (*fld >= '0' && *fld <= '9')
+            strt = strt * 16 + *fld - '0';
+        else if (*fld >= 'a' && *fld <= 'f')
+            strt = strt * 16 + *fld - 'a' + 10;
+        else if (*fld >= 'A' && *fld <= 'F')
+            strt = strt * 16 + *fld - 'A' + 10;
+        else
+            break;
+
+        fld += 1;
+    }
+
+    if (*fld == '.')
+    {
+        fld += 2;
+
+        while (*fld)
+        {
+            if (*fld >= '0' && *fld <= '9')
+                end = end * 16 + *fld - '0';
+            else if (*fld >= 'a' && *fld <= 'f')
+                end = end * 16 + *fld - 'a' + 10;
+            else if (*fld >= 'A' && *fld <= 'F')
+                end = end * 16 + *fld - 'A' + 10;
+            else
+                break;
+
+            fld += 1;
+        }
+    }
+
+    if (end == 0)
+        end = strt;
+
+    Ranges[NumRanges].Start = strt;
+    Ranges[NumRanges].End = end;
+    NumRanges += 1;
+}
+
+int MatchField(char * fld, char * s)
+{
+    char * r = strstr(fld, s);
+    if (r == 0)
+        return(0);
+
+    if (r > fld && *(r - 1) != ' ')
+        return(0);
+
+    r += strlen(s);
+    if (*r == ' ' || *r == 0)
+        return(1);
+
+    return(0);
+}
+
+void Usage()
+{
+    fprintf(stderr, "usage: genul <file> <name> <type>\n");
+}
+
+int main(int argc, char * argv[])
+{
+    char s[256];
+
+    if (argc != 4)
+    {
+        Usage();
+        return(1);
+    }
+
+    FILE * fp = fopen(argv[1], "rt");
+    if (fp == 0)
+    {
+        fprintf(stderr, "error: genul: unable to open %s\n", argv[1]);
+        return(1);
+    }
+
+    while (fgets(s, sizeof(s), fp))
+    {
+        char * flds[32];
+
+        if (*s != '#' && *s != '\n')
+        {
+            int nflds = ParseFields(s, flds);
+
+            if (nflds == 2 && MatchField(flds[1], argv[3]))
+                AddRange(flds[0]);
+        }
+    }
+    fclose(fp);
+
+    printf("\nstatic FCharRange %s[%d] =\n{\n", argv[2], NumRanges);
+    for (unsigned int ndx = 0; ndx < NumRanges; ndx++)
+        printf("    {0x%x, 0x%x}, // %d\n", Ranges[ndx].Start, Ranges[ndx].End,
+                Ranges[ndx].End - Ranges[ndx].Start + 1);
+    printf("};\n");
+
+    return(0);
+}
diff --git a/unidata/makefile b/unidata/makefile
new file mode 100644
index 0000000..221e8ae
--- /dev/null
+++ b/unidata/makefile
@@ -0,0 +1,58 @@
+#
+# Generate unicode data and code
+#
+
+BUILD_CXX ?= g++
+BUILD_FLAGS := -ggdb -Wall
+
+.PHONY: all
+all: debug unicase unicrng
+
+.PHONY: code
+code: debug/gencase debug/gencrng debug/genul
+
+.PHONY: clean
+clean: debug
+	-rm -R debug/*
+
+unicrng: debug/gencrng debug/genul
+	-rm ../src/unicrng.hpp
+	@echo "/*\n\
+\n\
+Foment\n\
+\n\
+*/\n\
+\n\
+// Automatically generated unicode character ranges included by charsets.cpp."\
+> ../src/unicrng.hpp
+	debug/genul DerivedCoreProperties.txt LowerCaseCharRange Lowercase >> ../src/unicrng.hpp
+	debug/genul DerivedCoreProperties.txt UpperCaseCharRange Uppercase >> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt TitleCaseCharRange Lt >> ../src/unicrng.hpp
+	debug/genul DerivedCoreProperties.txt LetterCharRange Alphabetic >> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt DigitCharRange Nd >> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt WhitespaceCharRange Zs Zl Zp +0009 +000A +000B +000C +000D \
+>> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt PunctuationCharRange Pc Pd Ps Pe Pi Pf Po >> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt SymbolCharRange Sm Sc Sk So >> ../src/unicrng.hpp
+	debug/gencrng UnicodeData.txt BlankCharRange Zs +0009 >> ../src/unicrng.hpp
+
+unicase: debug/gencase
+	-rm ../src/unicase.hpp
+	@echo "/*\n\
+\n\
+Foment\n\
+\n\
+*/\n\
+\n\
+// Automatically generated unicode data and code included by unicode.cpp.\n" > ../src/unicase.hpp
+	debug/gencase UnicodeData.txt Upcase 12 50 >> ../src/unicase.hpp
+	debug/gencase UnicodeData.txt Downcase 13 50 >> ../src/unicase.hpp
+	debug/gencase CaseFolding.txt Foldcase 2 50 >> ../src/unicase.hpp
+	debug/gencase CaseFolding.txt Fullfold 2 20 >> ../src/unicase.hpp
+	debug/gencase SpecialCasing.txt Fullup 3 20 >> ../src/unicase.hpp
+
+debug:
+	-mkdir debug
+
+debug/%: ./%.cpp
+	$(BUILD_CXX) $(BUILD_FLAGS) -o $@ $<
diff --git a/unix/makefile b/unix/makefile
index 73cbaf8..a048ed9 100644
--- a/unix/makefile
+++ b/unix/makefile
@@ -82,16 +82,18 @@ profile:
 	-mkdir profile
 
 debug/base.cpp: debug/txt2cpp makefile ../src/base.scm ../src/srfi-106.scm ../src/srfi-60.scm\
-		../src/srfi-1.scm ../src/srfi-128.scm ../src/srfi-125.scm ../src/srfi-133.scm
+		../src/srfi-1.scm ../src/srfi-128.scm ../src/srfi-125.scm ../src/srfi-133.scm\
+		../src/srfi-14.scm
 	debug/txt2cpp debug/base.cpp ../src/base.scm ../src/srfi-106.scm ../src/srfi-60.scm\
-		../src/srfi-1.scm ../src/srfi-128.scm ../src/srfi-125.scm ../src/srfi-133.scm
+		../src/srfi-1.scm ../src/srfi-128.scm ../src/srfi-125.scm ../src/srfi-133.scm\
+		../src/srfi-14.scm
 
 debug/foment: debug/foment.o debug/gc.o debug/syncthrd.o debug/compile.o debug/io.o\
 		debug/synrules.o debug/synpass.o debug/midpass.o debug/genpass.o\
 		debug/pairs.o debug/unicode.o debug/chars.o debug/strings.o debug/vectors.o\
 		debug/library.o debug/execute.o debug/numbers.o debug/write.o\
 		debug/read.o debug/filesys.o debug/compare.o debug/main.o debug/hashtbl.o\
-		debug/bignums.o debug/base.o
+		debug/bignums.o debug/charset.o debug/base.o
 	$(CXX)  $(LDFLAGS) -o debug/foment $^ -lpthread
 
 release/foment: release/foment.o release/gc.o release/syncthrd.o release/compile.o release/io.o\
@@ -99,7 +101,8 @@ release/foment: release/foment.o release/gc.o release/syncthrd.o release/compile
 		release/pairs.o release/unicode.o release/chars.o release/strings.o\
 		release/vectors.o release/library.o release/execute.o release/numbers.o\
 		release/write.o release/read.o release/filesys.o\
-		release/compare.o release/main.o release/hashtbl.o release/bignums.o release/base.o
+		release/compare.o release/main.o release/hashtbl.o release/bignums.o release/charset.o\
+		release/base.o
 	$(CXX) $(LDFLAGS) -o release/foment $^ -lpthread
 
 profile/foment: profile/foment.o profile/gc.o profile/syncthrd.o profile/compile.o profile/io.o\
@@ -107,7 +110,8 @@ profile/foment: profile/foment.o profile/gc.o profile/syncthrd.o profile/compile
 		profile/pairs.o profile/unicode.o profile/chars.o profile/strings.o\
 		profile/vectors.o profile/library.o profile/execute.o profile/numbers.o\
 		profile/write.o profile/read.o profile/filesys.o\
-		profile/compare.o profile/main.o profile/hashtbl.o profile/bignums.o profile/base.o
+		profile/compare.o profile/main.o profile/hashtbl.o profile/bignums.o profile/charset.o\
+		profile/base.o
 	$(CXX)  $(LDFLAGS) -pg -o profile/foment $^ -lpthread
 
 debug/foment.o: ../src/foment.cpp ../src/foment.hpp ../src/syncthrd.hpp ../src/unicode.hpp
@@ -119,7 +123,7 @@ debug/synpass.o: ../src/synpass.cpp ../src/foment.hpp ../src/compile.hpp
 debug/midpass.o: ../src/midpass.cpp ../src/foment.hpp ../src/compile.hpp
 debug/genpass.o: ../src/genpass.cpp ../src/foment.hpp ../src/compile.hpp ../src/execute.hpp
 debug/pairs.o: ../src/pairs.cpp ../src/foment.hpp
-debug/unicode.o: ../src/unicode.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unidata.hpp
+debug/unicode.o: ../src/unicode.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unicase.hpp
 debug/chars.o: ../src/chars.cpp ../src/foment.hpp ../src/unicode.hpp
 debug/strings.o: ../src/strings.cpp ../src/foment.hpp ../src/unicode.hpp
 debug/vectors.o: ../src/vectors.cpp ../src/foment.hpp ../src/unicode.hpp
@@ -127,6 +131,7 @@ debug/library.o: ../src/library.cpp ../src/foment.hpp ../src/compile.hpp
 debug/execute.o: ../src/execute.cpp ../src/foment.hpp ../src/execute.hpp ../src/syncthrd.hpp
 debug/numbers.o: ../src/numbers.cpp ../src/foment.hpp ../src/unicode.hpp ../src/bignums.hpp
 debug/bignums.o: ../src/bignums.cpp ../src/foment.hpp ../src/unicode.hpp ../src/bignums.hpp
+debug/charset.o: ../src/charset.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unicrng.hpp
 debug/io.o: ../src/io.cpp ../src/foment.hpp ../src/syncthrd.hpp ../src/io.hpp\
 	../src/unicode.hpp
 debug/write.o: ../src/write.cpp ../src/foment.hpp ../src/syncthrd.hpp ../src/io.hpp\
@@ -148,7 +153,7 @@ release/synpass.o: ../src/synpass.cpp ../src/foment.hpp ../src/compile.hpp
 release/midpass.o: ../src/midpass.cpp ../src/foment.hpp ../src/compile.hpp
 release/genpass.o: ../src/genpass.cpp ../src/foment.hpp ../src/compile.hpp ../src/execute.hpp
 release/pairs.o: ../src/pairs.cpp ../src/foment.hpp
-release/unicode.o: ../src/unicode.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unidata.hpp
+release/unicode.o: ../src/unicode.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unicase.hpp
 release/chars.o: ../src/chars.cpp ../src/foment.hpp ../src/unicode.hpp
 release/strings.o: ../src/strings.cpp ../src/foment.hpp ../src/unicode.hpp
 release/vectors.o: ../src/vectors.cpp ../src/foment.hpp ../src/unicode.hpp
@@ -156,6 +161,7 @@ release/library.o: ../src/library.cpp ../src/foment.hpp ../src/compile.hpp
 release/execute.o: ../src/execute.cpp ../src/foment.hpp ../src/execute.hpp ../src/syncthrd.hpp
 release/numbers.o: ../src/numbers.cpp ../src/foment.hpp ../src/unicode.hpp ../src/bignums.hpp
 release/bignums.o: ../src/bignums.cpp ../src/foment.hpp ../src/unicode.hpp ../src/bignums.hpp
+release/charset.o: ../src/charset.cpp ../src/foment.hpp ../src/unicode.hpp ../src/unicrng.hpp
 release/io.o: ../src/io.cpp ../src/foment.hpp ../src/syncthrd.hpp ../src/io.hpp\
 	../src/unicode.hpp
 release/write.o: ../src/write.cpp ../src/foment.hpp ../src/syncthrd.hpp ../src/io.hpp\
diff --git a/windows/genaul.cpp b/windows/genaul.cpp
deleted file mode 100644
index f01f2ea..0000000
--- a/windows/genaul.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
-
-Generate Alphabectic, Uppercase, and Lowercase Unicode Tables
-
-genaul <file> <type> <first> <last>
-
-*/
-
-#define _CRT_SECURE_NO_WARNINGS
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int ParseFields(char * s, char ** flds)
-{
-    int nflds = 0;
-
-    for (;;)
-    {
-        char * f = strchr(s, ';');
-
-        while (*s == ' ')
-            s += 1;
-
-        if (*s == 0)
-            flds[nflds] = 0;
-        else
-            flds[nflds] = s;
-
-        nflds += 1;
-        if (f == 0)
-            break;
-
-        *f = 0;
-        s = f + 1;
-    }
-
-    return(nflds);
-}
-
-void ParseRange(char * fld, unsigned int *mp)
-{
-    char * s = fld;
-    unsigned int n = 0;
-    unsigned int m = 0;
-
-    while (*fld)
-    {
-        if (*fld >= '0' && *fld <= '9')
-            n = n * 16 + *fld - '0';
-        else if (*fld >= 'a' && *fld <= 'f')
-            n = n * 16 + *fld - 'a' + 10;
-        else if (*fld >= 'A' && *fld <= 'F')
-            n = n * 16 + *fld - 'A' + 10;
-        else
-            break;
-
-        fld += 1;
-    }
-
-    if (*fld == '.')
-    {
-        fld += 2;
-
-        while (*fld)
-        {
-            if (*fld >= '0' && *fld <= '9')
-                m = m * 16 + *fld - '0';
-            else if (*fld >= 'a' && *fld <= 'f')
-                m = m * 16 + *fld - 'a' + 10;
-            else if (*fld >= 'A' && *fld <= 'F')
-                m = m * 16 + *fld - 'A' + 10;
-            else
-                break;
-
-            fld += 1;
-        }
-    }
-
-    if (m == 0)
-        mp[n] = 1;
-    else
-    {
-        while (n <= m)
-        {
-            mp[n] = 1;
-            n += 1;
-        }
-    }
-}
-
-unsigned int ParseCodePoint(char * fld)
-{
-    char * s = fld;
-    unsigned int n = 0;
-
-    while (*fld)
-    {
-        if (*fld >= '0' && *fld <= '9')
-            n = n * 16 + *fld - '0';
-        else if (*fld >= 'a' && *fld <= 'f')
-            n = n * 16 + *fld - 'a' + 10;
-        else if (*fld >= 'A' && *fld <= 'F')
-            n = n * 16 + *fld - 'A' + 10;
-        else
-        {
-            fprintf(stderr, "error: genaul: unable to parse field: %s\n", s);
-            return(0);
-        }
-
-        fld += 1;
-    }
-
-    return(n);
-}
-
-int MatchField(char * fld, char * s)
-{
-    char * r = strstr(fld, s);
-    if (r == 0)
-        return(0);
-
-    if (r > fld && *(r - 1) != ' ')
-        return(0);
-
-    r += strlen(s);
-    if (*r == ' ' || *r == 0)
-        return(1);
-
-    return(0);
-}
-
-void Usage()
-{
-    fprintf(stderr, "usage: genaul <file> <type> <first> <last>\n");
-}
-
-unsigned int Map[0x110000];
-
-int main(int argc, char * argv[])
-{
-    char s[256];
-
-    for (int idx = 0; idx < 0x110000; idx++)
-        Map[idx] = 0;
-
-    if (argc != 5)
-    {
-        Usage();
-        return(1);
-    }
-
-    int fst = ParseCodePoint(argv[3]);
-    int lst = ParseCodePoint(argv[4]);
-
-    if (fst % 32 != 0)
-    {
-        fprintf(stderr, "error: genaul: first must be divible by 32\n");
-        return(1);
-    }
-
-    FILE * fp = fopen(argv[1], "rt");
-    if (fp == 0)
-    {
-        fprintf(stderr, "error: genaul: unable to open %s\n", argv[1]);
-        return(1);
-    }
-
-    while (fgets(s, sizeof(s), fp))
-    {
-        char * flds[32];
-
-        if (*s != '#' && *s != '\n')
-        {
-            int nflds = ParseFields(s, flds);
-
-            if (nflds == 2 && MatchField(flds[1], argv[2]))
-                ParseRange(flds[0], Map);
-        }
-    }
-
-    printf("static const unsigned int %s0x%04xTo0x%04x[] =\n{\n", argv[2], fst,
-            (lst / 32) * 32 + 31);
-
-    while (fst <= lst)
-    {
-        unsigned int msk = 0;
-
-        for (int idx = 0; idx < 32; idx++)
-            if (Map[fst + idx])
-                msk |= (1 << idx);
-
-        if (msk == 0)
-            printf("    0x0, // 0x%04x\n", fst);
-        else
-            printf("    0x%08x, // 0x%04x\n", msk, fst);
-        fst += 32;
-    }
-
-    printf("    0x0\n};\n\n");
-
-    fclose(fp);
-    return(0);
-}
diff --git a/windows/makefile b/windows/makefile
index a327dce..0579f7a 100644
--- a/windows/makefile
+++ b/windows/makefile
@@ -62,62 +62,19 @@ release:
 manual:
     -mkdir manual
 
-uni: debug\genudf.exe
-    debug\genudf ..\unidata\CaseFolding.txt Fullfold 2 20
-    debug\genudf ..\unidata\SpecialCasing.txt Fullup 3 20
-
-unicode: debug\genaul.exe debug\genudf.exe
-    type << > ..\src\unidata.hpp
-/*
-
-Foment
-
-*/
-
-// Automatically generated unicode data and code included by unicode.cpp.
-
-<<
-    debug\genudf ..\unidata\UnicodeData.txt Upcase 12 50 >> ..\src\unidata.hpp
-    debug\genudf ..\unidata\UnicodeData.txt Downcase 13 50 >> ..\src\unidata.hpp
-    debug\genudf ..\unidata\CaseFolding.txt Foldcase 2 50 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 0 1FE0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 2060 2180 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 24A0 24E0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 2C00 2E20 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 3000 31E0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic A480 ABE0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic D7A0 D7E0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic F900 10480 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 10800 10C40 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 11000 111C0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 16F00 16F80 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 1D400 1D7C0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Alphabetic 1EE00 1EEA0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 0 0580 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 10A0 10C0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 1E00 1FE0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 2100 2180 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 2C00 2D20 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase A640 A7A0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Uppercase 1D400 1D7C0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase 0 0580 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase 1D00 1FE0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase 2060 2180 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase 2C20 2D20 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase A640 A7E0 >> ..\src\unidata.hpp
-    debug\genaul ..\unidata\DerivedCoreProperties.txt Lowercase 1D400 1D7C0 >> ..\src\unidata.hpp
-    debug\genudf ..\unidata\CaseFolding.txt Fullfold 2 20 >> ..\src\unidata.hpp
-    debug\genudf ..\unidata\SpecialCasing.txt Fullup 3 20 >> ..\src\unidata.hpp
-
-debug\base.cpp: debug\txt2cpp.exe makefile ..\src\base.scm
-    debug\txt2cpp debug\base.cpp ..\src\base.scm
+debug\base.cpp: debug\txt2cpp.exe makefile ..\src\base.scm ..\src\srfi-106.scm ..\src\srfi-60.scm\
+        ..\src\srfi-1.scm ..\src\srfi-128.scm ..\src\srfi-125.scm ..\src\srfi-133.scm\
+        ..\src\srfi-14.scm
+    debug\txt2cpp debug\base.cpp ..\src\base.scm ..\src\srfi-106.scm ..\src\srfi-60.scm\
+        ..\src\srfi-1.scm ..\src\srfi-128.scm ..\src\srfi-125.scm ..\src\srfi-133.scm\
+        ..\src\srfi-14.scm
 
 debug\foment.exe: debug\foment.obj debug\gc.obj debug\syncthrd.obj debug\compile.obj debug\io.obj\
         debug\synrules.obj debug\synpass.obj debug\midpass.obj debug\genpass.obj\
         debug\pairs.obj debug\unicode.obj debug\chars.obj debug\strings.obj debug\vectors.obj\
         debug\library.obj debug\execute.obj debug\numbers.obj debug\write.obj\
         debug\read.obj debug\filesys.obj debug\compare.obj debug\main.obj debug\hashtbl.obj\
-        debug\bignums.obj debug\base.obj
+        debug\bignums.obj debug\charset.obj debug\base.obj
     link /nologo /subsystem:console /out:debug\foment.exe /debug /pdb:debug\foment.pdb\
         /largeaddressaware $** $(LIBS)
 
@@ -127,7 +84,7 @@ release\foment.exe: release\foment.obj release\gc.obj release\syncthrd.obj relea
         release\strings.obj release\vectors.obj release\library.obj release\execute.obj\
         release\numbers.obj release\write.obj release\read.obj\
         release\filesys.obj release\compare.obj release\main.obj release\hashtbl.obj\
-        release\bignums.obj release\base.obj
+        release\bignums.obj release\charset.obj release\base.obj
 #    link /nologo /subsystem:console /out:release\foment.exe $**
     link /nologo /subsystem:console /out:release\foment.exe /debug /pdb:release\foment.pdb\
         /largeaddressaware $** $(LIBS)
@@ -145,7 +102,7 @@ debug\synpass.obj: ..\src\synpass.cpp ..\src\foment.hpp ..\src\compile.hpp
 debug\midpass.obj: ..\src\midpass.cpp ..\src\foment.hpp ..\src\compile.hpp
 debug\genpass.obj: ..\src\genpass.cpp ..\src\foment.hpp ..\src\compile.hpp ..\src\execute.hpp
 debug\pairs.obj: ..\src\pairs.cpp ..\src\foment.hpp
-debug\unicode.obj: ..\src\unicode.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\unidata.hpp
+debug\unicode.obj: ..\src\unicode.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\unicase.hpp
 debug\chars.obj: ..\src\chars.cpp ..\src\foment.hpp ..\src\unicode.hpp
 debug\strings.obj: ..\src\strings.cpp ..\src\foment.hpp ..\src\unicode.hpp
 debug\vectors.obj: ..\src\vectors.cpp ..\src\foment.hpp ..\src\unicode.hpp
@@ -153,6 +110,7 @@ debug\library.obj: ..\src\library.cpp ..\src\foment.hpp ..\src\compile.hpp
 debug\execute.obj: ..\src\execute.cpp ..\src\foment.hpp ..\src\execute.hpp ..\src\syncthrd.hpp
 debug\numbers.obj: ..\src\numbers.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\bignums.hpp
 debug\bignums.obj: ..\src\bignums.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\bignums.hpp
+debug\charset.obj: ..\src\charset.cpp ..\src\foment.hpp ..\src\unicode.hpp  ..\src\unicrng.hpp
 debug\io.obj: ..\src\io.cpp ..\src\foment.hpp ..\src\syncthrd.hpp ..\src\io.hpp ..\src\unicode.hpp
 debug\write.obj: ..\src\write.cpp ..\src\foment.hpp ..\src\syncthrd.hpp ..\src\io.hpp\
     ..\src\compile.hpp
@@ -173,7 +131,7 @@ release\synpass.obj: ..\src\synpass.cpp ..\src\foment.hpp ..\src\compile.hpp
 release\midpass.obj: ..\src\midpass.cpp ..\src\foment.hpp ..\src\compile.hpp
 release\genpass.obj: ..\src\genpass.cpp ..\src\foment.hpp ..\src\compile.hpp ..\src\execute.hpp
 release\pairs.obj: ..\src\pairs.cpp ..\src\foment.hpp
-release\unicode.obj: ..\src\unicode.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\unidata.hpp
+release\unicode.obj: ..\src\unicode.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\unicase.hpp
 release\chars.obj: ..\src\chars.cpp ..\src\foment.hpp ..\src\unicode.hpp
 release\strings.obj: ..\src\strings.cpp ..\src\foment.hpp ..\src\unicode.hpp
 release\vectors.obj: ..\src\vectors.cpp ..\src\foment.hpp ..\src\unicode.hpp
@@ -181,6 +139,7 @@ release\library.obj: ..\src\library.cpp ..\src\foment.hpp ..\src\compile.hpp
 release\execute.obj: ..\src\execute.cpp ..\src\foment.hpp ..\src\execute.hpp ..\src\syncthrd.hpp
 release\numbers.obj: ..\src\numbers.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\bignums.hpp
 release\bignums.obj: ..\src\bignums.cpp ..\src\foment.hpp ..\src\unicode.hpp ..\src\bignums.hpp
+release\charset.obj: ..\src\charset.cpp ..\src\foment.hpp ..\src\unicode.hpp  ..\src\unicrng.hpp
 release\io.obj: ..\src\io.cpp ..\src\foment.hpp ..\src\syncthrd.hpp ..\src\io.hpp\
     ..\src\unicode.hpp
 release\write.obj: ..\src\write.cpp ..\src\foment.hpp ..\src\syncthrd.hpp ..\src\io.hpp\
@@ -219,8 +178,3 @@ debug\txt2cpp.obj: ..\src\txt2cpp.cpp
 {debug\}.cpp.{release}.obj:
     cl $(CLRELEASE) debug\$(*B).cpp
 
-{.}.cpp.{debug}.exe:
-    cl $(CLDEBUG) $(*B).cpp
-    link /nologo /subsystem:console /out:debug\$(*B).exe\
-    debug\$(*B).obj
-