~ chicken-core (master) ec0c9662ffbba310bd802c6001ae82091b97d637
commit ec0c9662ffbba310bd802c6001ae82091b97d637
Author: Stanislav Kljuhhin <stanislav.kljuhhin@me.com>
AuthorDate: Thu Sep 3 16:15:44 2026 +0200
Commit: Felix Winkelmann <felix.winkelmann@bevuta.com>
CommitDate: Sat Sep 19 00:19:57 2026 +0200
Refactor Unicode processing in the core
- Simplify rune lookup and case folding tables and move them to __TEXT
- Replace awk rune lookup table generator with Scheme one
- Fix multiple issues caused by the old awk script
- Bring membership predicates in agreement with R7RS and SRFI-14
- Update Unicode standard to 17
Signed-off-by: Felix Winkelmann <felix.winkelmann@bevuta.com>
diff --git a/distribution/manifest b/distribution/manifest
index 1355f136..00fcbc5b 100644
--- a/distribution/manifest
+++ b/distribution/manifest
@@ -102,6 +102,7 @@ read-syntax.scm
repl.scm
runtime.c
utf.c
+utf-tables.c
scheduler.scm
srfi-4.scm
stub.scm
@@ -413,6 +414,7 @@ scripts/compile-all
scripts/compare-documentation-exports.scm
scripts/make-wrapper.scm
scripts/makedist.scm
+scripts/mkunicodetables.scm
scripts/smoke-test.sh
manual-html/Accessing external objects.html
manual-html/Acknowledgements.html
diff --git a/rules.make b/rules.make
index 05f80c38..501032f3 100644
--- a/rules.make
+++ b/rules.make
@@ -192,6 +192,9 @@ endef
$(foreach obj, $(UTILITY_PROGRAM_OBJECTS_1),\
$(eval $(call declare-utility-program-object,$(obj))))
+# generated Unicode tables
+
+utf$(O) utf-static$(O): utf-tables.c
# resource objects
diff --git a/scripts/foldcase.awk b/scripts/foldcase.awk
deleted file mode 100644
index 027b4f6b..00000000
--- a/scripts/foldcase.awk
+++ /dev/null
@@ -1,27 +0,0 @@
-function num(x) {
- return substr(x, 1, length(x) - 1)
-}
-BEGIN {
- print "static int fold1[][ 2 ] = {"
- i = 0
-}
-/ S;/ {print " {0x" num($1) ", 0x" num($3) "},"}
-/ C;/ {print " {0x" num($1) ", 0x" num($3) "},"}
-/ F;/ {
- if(match($5, /;$/)) {
- c[ i ] = $4
- d[ i ] = num($5)
- } else {
- c[ i ] = num($4)
- d[ i ] = 0
- }
- a[ i ] = num($1); b[ i++ ] = $3
-}
-END {
- print "};"
- print "static int fold2[][ 4 ] = {"
- for(j = 0; j < i; ++j) {
- print " {0x" a[ j ] ", 0x" b[ j ] ", 0x" c[ j ] ", 0x" d[ j ] "},"
- }
- print "};"
-}
diff --git a/scripts/mkrunetype.awk b/scripts/mkrunetype.awk
deleted file mode 100644
index 32a08638..00000000
--- a/scripts/mkrunetype.awk
+++ /dev/null
@@ -1,242 +0,0 @@
-# See LICENSE file for copyright and license details.
-# invoke as:
-# curl http://unicode.org/Public/UCD/latest/ucd/UnicodeData.txt | awk -f scripts/mkrunetype.awk
-
-BEGIN {
- FS = ";"
- # set up hexadecimal lookup table
- for(i = 0; i < 16; i++)
- hex[sprintf("%X",i)] = i;
- HEADER = "/* Automatically generated by mkrunetype.awk */\n#include <stdlib.h>\n\n#include \"../utf.h\"\n#include \"runetype.h\"\n"
- HEADER_OTHER = "/* Automatically generated by mkrunetype.awk */\n#include \"../utf.h\"\n#include \"runetype.h\"\n"
-}
-
-$3 ~ /^L/ { alphav[alphac++] = $1; }
-($3 ~ /^Z/) || ($5 == "WS") || ($5 == "S") || ($5 == "B") { spacev[spacec++] = $1; }
-$3 == "Cc" { cntrlv[cntrlc++] = $1; }
-$3 == "Lu" { upperv[upperc++] = $1; tolowerv[uppercc++] = ($14 == "") ? $1 : $14; }
-$3 == "Ll" { lowerv[lowerc++] = $1; toupperv[lowercc++] = ($13 == "") ? $1 : $13; }
-$3 == "Lt" { titlev[titlec++] = $1; }
-$3 == "Nd" { digitv[digitc++] = $1; }
-
-END {
- system("rm -f isalpharune.c isspacerune.c iscntrlrune.c upperrune.c lowerrune.c istitlerune.c isdigitrune.c");
-
- mkis("alpha", alphav, alphac, "isalpharune.c", q, "");
- mkis("space", spacev, spacec, "isspacerune.c", q, "");
- mkis("cntrl", cntrlv, cntrlc, "iscntrlrune.c", q, "");
- mkis("upper", upperv, upperc, "upperrune.c", tolowerv, "lower");
- mkis("lower", lowerv, lowerc, "lowerrune.c", toupperv, "upper");
- mkis("title", titlev, titlec, "istitlerune.c", q, "");
- mkis("digit", digitv, digitc, "isdigitrune.c", q, "");
-
- system("rm -f isalnumrune.c isblankrune.c isprintrune.c isgraphrune.c ispunctrune.c isxdigitrune.c");
-
- otheris();
-}
-
-# parse hexadecimal rune index to int
-function code(s) {
- x = 0;
- for(i = 1; i <= length(s); i++) {
- c = substr(s, i, 1);
- x = (x*16) + hex[c];
- }
- return x;
-}
-
-# generate 'is<name>rune' unicode lookup function
-function mkis(name, runev, runec, file, casev, casename) {
- rune1c = 0;
- rune2c = 0;
- rune3c = 0;
- rune4c = 0;
- mode = 1;
-
- #sort rune groups into singletons, ranges and laces
- for(j = 0; j < runec; j++) {
- # range
- if(code(runev[j+1]) == code(runev[j])+1 && ((length(casev) == 0) ||
- code(casev[j+1]) == code(casev[j])+1) && j+1 < runec) {
- if (mode == 2) {
- continue;
- } else if (mode == 3) {
- rune3v1[rune3c] = runev[j];
- rune3c++;
- } else if (mode == 4) {
- rune4v1[rune4c] = runev[j];
- rune4c++;
- }
- mode = 2;
- rune2v0[rune2c] = runev[j];
- if(length(casev) > 0) {
- case2v[rune2c] = casev[j];
- }
- continue;
- }
- # lace 1
- if(code(runev[j+1]) == code(runev[j])+2 && ((length(casev) == 0) ||
- (code(casev[j+1]) == code(runev[j+1])+1 && code(casev[j]) == code(runev[j])+1)) &&
- j+1 < runec) {
- if (mode == 3) {
- continue;
- } else if (mode == 2) {
- rune2v1[rune2c] = runev[j];
- rune2c++;
- } else if (mode == 4) {
- rune4v1[rune2c] = runev[j];
- rune4c++;
- }
- mode = 3;
- rune3v0[rune3c] = runev[j];
- continue;
- }
- # lace 2
- if(code(runev[j+1]) == code(runev[j])+2 && ((length(casev) == 0) ||
- (code(casev[j+1]) == code(runev[j+1])-1 && code(casev[j]) == code(runev[j])-1)) &&
- j+1 < runec) {
- if (mode == 4) {
- continue;
- } else if (mode == 2) {
- rune2v1[rune2c] = runev[j];
- rune2c++;
- } else if (mode == 3) {
- rune3v1[rune2c] = runev[j];
- rune3c++;
- }
- mode = 4;
- rune4v0[rune4c] = runev[j];
- continue;
- }
- # terminating case
- if (mode == 1) {
- rune1v[rune1c] = runev[j];
- if (length(casev) > 0) {
- case1v[rune1c] = casev[j];
- }
- rune1c++;
- } else if (mode == 2) {
- rune2v1[rune2c] = runev[j];
- rune2c++;
- } else if (mode == 3) {
- rune3v1[rune3c] = runev[j];
- rune3c++;
- } else { #lace 2
- rune4v1[rune4c] = runev[j];
- rune4c++;
- }
- mode = 1;
- }
- print HEADER > file;
-
- #generate list of laces 1
- if(rune3c > 0) {
- print "static Rune "name"3[][2] = {" > file;
- for(j = 0; j < rune3c; j++) {
- print "\t{ 0x"rune3v0[j]", 0x"rune3v1[j]" }," > file;
- }
- print "};\n" > file;
- }
-
- #generate list of laces 2
- if(rune4c > 0) {
- print "static Rune "name"4[][2] = {" > file;
- for(j = 0; j < rune4c; j++) {
- print "\t{ 0x"rune4v0[j]", 0x"rune4v1[j]" }," > file;
- }
- print "};\n" > file;
- }
-
- # generate list of ranges
- if(rune2c > 0) {
- if(length(casev) > 0) {
- print "static Rune "name"2[][3] = {" > file;
- for(j = 0; j < rune2c; j++) {
- print "\t{ 0x"rune2v0[j]", 0x"rune2v1[j]", 0x"case2v[j]" }," > file;
- }
- } else {
- print "static Rune "name"2[][2] = {" > file
- for(j = 0; j < rune2c; j++) {
- print "\t{ 0x"rune2v0[j]", 0x"rune2v1[j]" }," > file;
- }
- }
- print "};\n" > file;
- }
-
- # generate list of singletons
- if(rune1c > 0) {
- if(length(casev) > 0) {
- print "static Rune "name"1[][2] = {" > file;
- for(j = 0; j < rune1c; j++) {
- print "\t{ 0x"rune1v[j]", 0x"case1v[j]" }," > file;
- }
- } else {
- print "static Rune "name"1[] = {" > file;
- for(j = 0; j < rune1c; j++) {
- print "\t0x"rune1v[j]"," > file;
- }
- }
- print "};\n" > file;
- }
- # generate lookup function
- print "int\nis"name"rune(Rune r)\n{" > file;
- if(rune4c > 0 || rune3c > 0)
- print "\tRune *match;\n" > file;
- if(rune4c > 0) {
- print "\tif((match = bsearch(&r, "name"4, nelem("name"4), sizeof *"name"4, &rune2cmp)))" > file;
- print "\t\treturn !((r - match[0]) % 2);" > file;
- }
- if(rune3c > 0) {
- print "\tif((match = bsearch(&r, "name"3, nelem("name"3), sizeof *"name"3, &rune2cmp)))" > file;
- print "\t\treturn !((r - match[0]) % 2);" > file;
- }
- if(rune2c > 0) {
- print "\tif(bsearch(&r, "name"2, nelem("name"2), sizeof *"name"2, &rune2cmp))\n\t\treturn 1;" > file;
- }
- if(rune1c > 0) {
- print "\tif(bsearch(&r, "name"1, nelem("name"1), sizeof *"name"1, &rune1cmp))\n\t\treturn 1;" > file;
- }
- print "\treturn 0;\n}" > file;
-
- # generate case conversion function
- if(length(casev) > 0) {
- print "\nint\nto"casename"rune(Rune r)\n{\n\tRune *match;\n" > file;
- if(rune4c > 0) {
- print "\tmatch = bsearch(&r, "name"4, nelem("name"4), sizeof *"name"4, &rune2cmp);" > file;
- print "\tif (match)" > file;
- print "\t\treturn ((r - match[0]) % 2) ? r : r - 1;" > file;
- }
- if(rune3c > 0) {
- print "\tmatch = bsearch(&r, "name"3, nelem("name"3), sizeof *"name"3, &rune2cmp);" > file;
- print "\tif (match)" > file;
- print "\t\treturn ((r - match[0]) % 2) ? r : r + 1;" > file;
- }
- if(rune2c > 0) {
- print "\tmatch = bsearch(&r, "name"2, nelem("name"2), sizeof *"name"2, &rune2cmp);" > file;
- print "\tif (match)" > file;
- print "\t\treturn match[2] + (r - match[0]);" > file;
- }
- if(rune1c > 0) {
- print "\tmatch = bsearch(&r, "name"1, nelem("name"1), sizeof *"name"1, &rune1cmp);" > file;
- print "\tif (match)" > file;
- print "\t\treturn match[1];" > file;
- }
- print "\treturn r;\n}" > file;
- }
-}
-
-function otheris() {
- print HEADER_OTHER > "isalnumrune.c";
- print "int\nisalnumrune(Rune r)\n{\n\treturn isalpharune(r) || isdigitrune(r);\n}" > "isalnumrune.c";
- print HEADER_OTHER > "isblankrune.c";
- print "int\nisblankrune(Rune r)\n{\n\treturn r == ' ' || r == '\\t';\n}" > "isblankrune.c";
- print HEADER_OTHER > "isprintrune.c";
- print "int\nisprintrune(Rune r)\n{\n\treturn !iscntrlrune(r) && (r != 0x2028) && (r != 0x2029) &&" > "isprintrune.c";
- print "\t ((r < 0xFFF9) || (r > 0xFFFB));\n}" > "isprintrune.c";
- print HEADER_OTHER > "isgraphrune.c";
- print "int\nisgraphrune(Rune r)\n{\n\treturn !isspacerune(r) && isprintrune(r);\n}" > "isgraphrune.c";
- print HEADER_OTHER > "ispunctrune.c";
- print "int\nispunctrune(Rune r)\n{\n\treturn isgraphrune(r) && !isalnumrune(r);\n}" > "ispunctrune.c";
- print HEADER_OTHER > "isxdigitrune.c";
- print "int\nisxdigitrune(Rune r)\n{\n\treturn (r >= '0' && (r - '0') < 10) || (r >= 'a' && (r - 'a') < 6);\n}" > "isxdigitrune.c";
-}
diff --git a/scripts/mkunicodetables.scm b/scripts/mkunicodetables.scm
new file mode 100644
index 00000000..c9d63de6
--- /dev/null
+++ b/scripts/mkunicodetables.scm
@@ -0,0 +1,328 @@
+;;;; mkunicodetables.scm - generate utf-tables.c from the Unicode character database
+;
+; Populate the UCD directory first:
+;
+; mkdir ucd && cd ucd
+; curl -O https://www.unicode.org/Public/UNIDATA/UnicodeData.txt
+; curl -O https://www.unicode.org/Public/UNIDATA/PropList.txt
+; curl -O https://www.unicode.org/Public/UNIDATA/DerivedCoreProperties.txt
+; curl -O https://www.unicode.org/Public/UNIDATA/CaseFolding.txt
+;
+; Then, from the CHICKEN source directory:
+;
+; csi -s scripts/mkunicodetables.scm ucd > utf-tables.c
+
+(import (chicken base)
+ (chicken fixnum)
+ (chicken io)
+ (chicken pathname)
+ (chicken process-context)
+ (chicken string))
+
+(include "mini-srfi-1.scm")
+
+
+;;;
+;;; Miscellaneous
+;;;
+
+(define (fields line) (string-split line ";" #t))
+
+(define (words s) (string-split s " "))
+
+(define (fromhex s) (and (not (string=? s "")) (string->number s 16)))
+
+(define (suffix? s p)
+ (and (>= (string-length s) (string-length p))
+ (string=? (substring s (- (string-length s) (string-length p))) p)))
+
+;;;
+;;; UnicodeData.txt parsing
+;;;
+
+;; Singleton:
+;; 0041;LATIN CAPITAL LETTER A;Lu;0;L;;;;;N;;;;0061;
+;;
+;; Range:
+;; 4E00;<CJK Ideograph, First>;Lo;0;L;;;;;N;;;;;
+;; 9FFF;<CJK Ideograph, Last>;Lo;0;L;;;;;N;;;;;
+(define (lines->entries lines)
+ (let loop ((es (map fields lines)) (start #f) (out '()))
+ (if (null? es)
+ (reverse out)
+ (let ((e (car es)) (rest (cdr es)))
+ (cond ((suffix? (second e) ", First>")
+ (loop rest (fromhex (first e)) out))
+ ((suffix? (second e) ", Last>")
+ (loop rest #f (append (reverse (expand-range start e)) out)))
+ (else (loop rest start (cons e out))))))))
+
+;; One entry per codepoint from START to E inclusive
+(define (expand-range start e)
+ (list-tabulate (add1 (- (fromhex (first e)) start))
+ (lambda (i) (cons (number->string (+ start i) 16) (cdr e)))))
+
+;; Fields of an entry by position:
+;; - 2 category,
+;; - 6 decimal value,
+;; - 12 simple uppercase mapping,
+;; - 13 simple lowercase mapping.
+;;
+;; 0041;LATIN CAPITAL LETTER A;Lu;0;L;;;;;N;;;;0061;
+;; ^^ 2 ^^^^ 13
+;;
+;; 0061;LATIN SMALL LETTER A;Ll;0;L;;;;;N;;;0041;;0041
+;; ^^ 2 ^^^^ 12
+;;
+;; 0660;ARABIC-INDIC DIGIT ZERO;Nd;0;AN;;0;0;0;N;;;;;
+;; ^^ 2 ^ 6
+(define (category e) (list-ref e 2))
+(define (decimal e) (list-ref e 6))
+(define (upper-map e) (list-ref e 12))
+(define (lower-map e) (list-ref e 13))
+
+;; A codepoint and what FIELD maps it to.
+;; 0130;LATIN CAPITAL LETTER I WITH DOT ABOVE;Lu;0;L;0049 0307;;;;N;LATIN CAPITAL LETTER I DOT;;;0069;
+;; ^^^^ ^^^^
+;; with lower-map => (304 105)
+(define (mapping->columns e field) (list (fromhex (first e)) (fromhex (field e))))
+
+;; A digit's codepoint and its decimal value.
+;; 0663;ARABIC-INDIC DIGIT THREE;Nd;0;AN;;3;3;3;N;;;;; => (1635 3)
+(define (digit->columns e) (list (fromhex (first e)) (string->number (decimal e))))
+
+;;;
+;;; CaseFolding.txt parsing
+;;;
+
+;; FB02; F; 0066 006C; # LATIN SMALL LIGATURE FL
+(define (lines->folds lines)
+ (map
+ (lambda (line)
+ (let ((f (fields line)))
+ (cons* (first (words (first f)))
+ (first (words (second f)))
+ (words (third f)))))
+ lines))
+
+;; There may be one to three fold targets, depending on class.
+;; ABBF; C; 13EF; # CHEROKEE SMALL LETTER YA
+;; with n=1 => (43967 5103)
+;; FB02; F; 0066 006C; # LATIN SMALL LIGATURE FL
+;; with n=3 => (64258 102 108 0)
+;; FB03; F; 0066 0066 0069; # LATIN SMALL LIGATURE FFI
+;; with n=3 => (64259 102 102 105)
+(define (folds->columns f n)
+ (map fromhex (cons (first f) (take (append (drop f 2) '("0" "0")) n))))
+
+;;;
+;;; PropList.txt parsing
+;;;
+
+;; One row per codepoint the line covers, so a range line yields many.
+;;
+;; Singleton:
+;; 0085 ; White_Space # Cc <control-0085> => ((133))
+;;
+;; Range:
+;; 0009..000D ; White_Space # Cc [5] ... => ((9) (10) (11) (12) (13))
+(define (property->columns line)
+ (let* ((bounds (string-split (first (words (first (fields line)))) "."))
+ (lo (fromhex (first bounds)))
+ (hi (if (pair? (cdr bounds)) (fromhex (second bounds)) lo)))
+ (list-tabulate (add1 (- hi lo)) (lambda (i) (list (+ lo i))))))
+
+;;;
+;;; Selecting codepoints
+;;;
+
+(define (of-category e c) (string=? (category e) c))
+
+;; Entries with non-empty FIELD.
+;; 24B6;CIRCLED LATIN CAPITAL LETTER A;So;0;L;<circle> 0041;;;;N;;;;24D0;
+;; 01C5;LATIN CAPITAL ... Z WITH CARON;Lt;0;L;<compat> 0044 017E;;;;N;...;01C4;01C6;01C5
+(define (has-mapping e field) (not (string=? (field e) "")))
+
+;; Folds of a given status; C and S together make the simple folding, F the
+;; full one, and T the Turkic variant we do not emit.
+;; 1E9E; F; 0073 0073; # LATIN CAPITAL LETTER SHARP S
+;; ^^^^^^^^^
+;; 1E9E; S; 00DF; # LATIN CAPITAL LETTER SHARP S
+;; ^^^^
+(define (has-status f statuses) (member (second f) statuses))
+
+;; Lines carrying a given property.
+;; 0085 ; White_Space # Cc <control-0085>
+;; ^^^^^^^^^^^
+(define (has-property line name)
+ (string=? (first (words (second (fields line)))) name))
+
+;;;
+;;; Compressing flat codepoint list into spans
+;;;
+
+;; A span keeps running as long as all inputs keep monotonously increasing.
+;; Singletons are encoded as a span of length 1. A row is the first and last
+;; codepoint, then whatever extra columns held at the start of the span.
+;;
+;; (compress '((65) (66) (67) (90))) => ((65 67) (90 90))
+;; (compress '((120791 9) (120792 0))) => ((120791 120791 9) (120792 120792 0))
+(define (compress rows)
+ (let* ((v (list->vector rows))
+ (n (vector-length v))
+ (at (lambda (i) (vector-ref v i)))
+ (span-continues? (lambda (i)
+ (and (< (add1 i) n)
+ (equal? (at (add1 i)) (map add1 (at i)))))))
+ (let loop ((i 0) (start 0) (rows '()))
+ (cond ((= i n) (reverse rows))
+ ((span-continues? i) (loop (add1 i) start rows))
+ (else (loop (add1 i) (add1 i)
+ (cons (cons* (first (at start)) (first (at i))
+ (cdr (at start)))
+ rows)))))))
+
+
+;; The Nd ranges.
+;;
+;; ...
+;; 0660;ARABIC-INDIC DIGIT ZERO;Nd;0;AN;;0;0;0;N;;;;;
+;; 0661;ARABIC-INDIC DIGIT ONE;Nd;0;AN;;1;1;1;N;;;;;
+;; 0662;ARABIC-INDIC DIGIT TWO;Nd;0;AN;;2;2;2;N;;;;;
+;; 0663;ARABIC-INDIC DIGIT THREE;Nd;0;AN;;3;3;3;N;;;;;
+;; 0664;ARABIC-INDIC DIGIT FOUR;Nd;0;AN;;4;4;4;N;;;;;
+;; 0665;ARABIC-INDIC DIGIT FIVE;Nd;0;AN;;5;5;5;N;;;;;
+;; 0666;ARABIC-INDIC DIGIT SIX;Nd;0;AN;;6;6;6;N;;;;;
+;; 0667;ARABIC-INDIC DIGIT SEVEN;Nd;0;AN;;7;7;7;N;;;;;
+;; 0668;ARABIC-INDIC DIGIT EIGHT;Nd;0;AN;;8;8;8;N;;;;;
+;; 0669;ARABIC-INDIC DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;
+;; ...
+;;
+;; => (... (1632 1641) ...)
+(define (digit-ranges data)
+ (map (cut take <> 2)
+ (compress (map digit->columns (filter (cut of-category <> "Nd") data)))))
+
+;;;
+;;; Read the ground truth and generate C tables
+;;;
+
+(define (read-file dir name)
+ (with-input-from-file (make-pathname dir name) read-lines))
+
+(define (uncomment line)
+ (let ((s (first (string-split line "#" #t))))
+ (and (not (string=? s "")) s)))
+
+(define (columns->row xs)
+ (let ((xs (map (lambda (n) (conc "0x" (number->string n 16))) xs)))
+ (conc "\t{ " (string-intersperse xs ", ") " },\n")))
+
+;; Format ROWS (a list of lists) into a 2-dimensional C array NAME.
+(define (emit-table name rows)
+ (display #<#EOF
+static const int #{name}[][#{(length (first rows))}] = {
+#{(apply conc (map columns->row rows))}};
+
+EOF
+))
+
+(define (emit dir)
+ (let* ((unicode-data (filter-map uncomment (read-file dir "UnicodeData.txt")))
+ (prop-list (filter-map uncomment (read-file dir "PropList.txt")))
+ (derived-core (filter-map uncomment (read-file dir "DerivedCoreProperties.txt")))
+ (case-folding (filter-map uncomment (read-file dir "CaseFolding.txt")))
+ (data (lines->entries unicode-data))
+ (folds (lines->folds case-folding)))
+ (display #<<EOF
+/* utf-tables.c - Unicode character tables for utf.c.
+ Generated by scripts/mkunicodetables.scm; do not edit. */
+
+
+EOF
+)
+ ;; R7RS 6.6
+ ;;
+ ;; (char-alphabetic? char)
+ ;; (char-numeric? char)
+ ;; (char-whitespace? char)
+ ;; (char-upper-case? letter)
+ ;; (char-lower-case? letter)
+ ;;
+ ;; These procedures return #t if their arguments are alphabetic, numeric,
+ ;; whitespace, upper case, or lower case characters, respectively,
+ ;; otherwise they return #f.
+ ;;
+ ;; Specifically, they must return #t when applied to characters with the
+ ;; Unicode properties Alphabetic, Numeric Digit, White Space, Uppercase,
+ ;; and Lowercase respectively, and #f when applied to any other Unicode
+ ;; characters. Note that many Unicode characters are alphabetic but
+ ;; neither upper nor lower case.
+ (emit-table "alpha"
+ (compress (append-map property->columns
+ (filter (cut has-property <> "Alphabetic") derived-core))))
+ (emit-table "upper"
+ (compress (append-map property->columns
+ (filter (cut has-property <> "Uppercase") derived-core))))
+ (emit-table "lower"
+ (compress (append-map property->columns
+ (filter (cut has-property <> "Lowercase") derived-core))))
+ (emit-table "space"
+ (compress (append-map property->columns
+ (filter (cut has-property <> "White_Space") prop-list))))
+ (emit-table "digit" (digit-ranges data))
+
+ ;; (char-downcase char)
+ ;;
+ ;; The char-downcase procedure, given an argument that is the uppercase
+ ;; part of a Unicode casing pair, returns the lowercase member of the pair,
+ ;; provided that both characters are supported by the Scheme
+ ;; implementation. Note that language-sensitive casing pairs are not used.
+ ;; If the argument is not the uppercase member of such a pair, it is
+ ;; returned.
+ (emit-table "lowermap"
+ (compress (map (cut mapping->columns <> lower-map)
+ (filter (cut has-mapping <> lower-map) data))))
+
+ ;; (char-upcase char)
+ ;;
+ ;; The char-upcase procedure, given an argument that is the lowercase part
+ ;; of a Unicode casing pair, returns the uppercase member of the pair,
+ ;; provided that both characters are supported by the Scheme
+ ;; implementation. Note that language-sensitive casing pairs are not used.
+ ;; If the argument is not the lowercase member of such a pair, it is
+ ;; returned.
+ ;;
+ ;; Note that many Unicode lowercase characters do not have uppercase
+ ;; equivalents.
+ (emit-table "uppermap"
+ (compress (map (cut mapping->columns <> upper-map)
+ (filter (cut has-mapping <> upper-map) data))))
+
+ ;; (char-foldcase char)
+ ;;
+ ;; The char-foldcase procedure applies the Unicode simple case-folding
+ ;; algorithm to its argument and returns the result. Note that
+ ;; language-sensitive folding is not used. If the argument is an uppercase
+ ;; letter, the result will be either a lowercase letter or the same as the
+ ;; argument if the lowercase letter does not exist or is not supported by
+ ;; the implementation. See UAX #29 [11] (part of the Unicode Standard) for
+ ;; details.
+ (emit-table "fold1" (map (cut folds->columns <> 1)
+ (filter (cut has-status <> '("C" "S")) folds)))
+
+ ;; R7RS 6.7
+ ;;
+ ;; (string-foldcase string)
+ ;;
+ ;; These procedures apply the Unicode full string uppercasing,
+ ;; lowercasing, and case-folding algorithms to their arguments and return
+ ;; the result. In certain cases, the result differs in length from the
+ ;; argument. If the result is equal to the argument in the sense of
+ ;; string=?, the argument may be returned. Note that language-sensitive
+ ;; mappings and foldings are not used.
+ (emit-table "fold2" (map (cut folds->columns <> 3)
+ (filter (cut has-status <> '("F")) folds)))))
+
+(when (pair? (command-line-arguments))
+ (emit (first (command-line-arguments))))
diff --git a/tests/unicode-tests.scm b/tests/unicode-tests.scm
index 8ac5925f..5ddf8471 100644
--- a/tests/unicode-tests.scm
+++ b/tests/unicode-tests.scm
@@ -225,6 +225,76 @@
(test-error (string-fill "Hello" 4 #\x))
+
+;; Confirm that compressed ranges in UnicodeData.txt are expanded correctly.
+
+(define (count-if pred lo hi)
+ (let loop ((i lo) (n 0))
+ (if (> i hi)
+ n
+ (loop (add1 i)
+ (if (pred (integer->char i))
+ (add1 n)
+ n)))))
+
+(test-equal 20992 (count-if char-alphabetic? #x4E00 #x9FFF)) ; CJK
+(test-equal 11172 (count-if char-alphabetic? #xAC00 #xD7A3)) ; Hangul
+(test-assert (> (count-if char-alphabetic? 0 #x10FFFF) 100000))
+
+
+;; Confirm that consecutive decimal digit runs are not folded together.
+
+(test-equal 0 (digit-value (integer->char #x1D7CE))) ; bold zero
+(test-equal 0 (digit-value (integer->char #x1D7D8))) ; double-struck zero
+(test-equal 0 (digit-value (integer->char #x1D7E2))) ; sans-serif zero
+(test-equal 0 (digit-value (integer->char #x1D7EC))) ; sans-serif bold zero
+(test-equal 0 (digit-value (integer->char #x1D7F6))) ; monospace zero
+(test-equal 9 (digit-value (integer->char #x1D7FF))) ; monospace nine
+
+;; Confirm that decimal digits are all in 0 to 9 range.
+
+(test-assert (let loop ((i 0))
+ (cond ((> i #x10FFFF) #t)
+ ((let ((v (digit-value (integer->char i))))
+ (or (not v) (and (>= v 0) (<= v 9))))
+ (loop (+ i 1)))
+ (else #f))))
+
+
+;; Confirm predicate compliance to R7RS.
+
+(test-assert (char-upper-case? (integer->char #x2160))) ; ROMAN NUMERAL ONE
+(test-assert (char-upper-case? (integer->char #x24B6))) ; CIRCLED CAPITAL A
+(test-assert (char-lower-case? (integer->char #x2170))) ; SMALL ROMAN NUMERAL ONE
+(test-assert (char-lower-case? (integer->char #x24D0))) ; CIRCLED SMALL A
+(test-assert (char-lower-case? (integer->char #x02B0))) ; MODIFIER SMALL H
+(test-assert (char-alphabetic? (integer->char #x0345))) ; COMBINING YPOGEGRAMMENI
+(test-assert (char-alphabetic? (integer->char #x093E))) ; DEVANAGARI VOWEL SIGN AA
+(test-assert (char-alphabetic? (integer->char #x2160))) ; Nl is Alphabetic
+
+(test-assert (char-whitespace? (integer->char #x0085))) ; NEL
+(test-assert (char-whitespace? (integer->char #x2029))) ; PARAGRAPH SEPARATOR
+(test-assert (char-whitespace? (integer->char #x202F))) ; NARROW NO-BREAK SPACE
+(test-assert (not (char-whitespace? (integer->char #x001C))))
+(test-assert (not (char-whitespace? (integer->char #x001F))))
+(test-assert (not (char-whitespace? (integer->char #x180E))))
+
+;; Confirm title case folding.
+
+(test-equal #\x01C4 (char-upcase (integer->char #x01C5))) ; LATIN CAPITAL DZ
+(test-equal #\x01C6 (char-downcase (integer->char #x01C5))) ; latin small dz
+
+;; As per R7RS 7.1.1
+;;
+;; <intraline whitespace> -> <space or tab>
+;; <line ending> -> <newline> | <return> <newline> | <return>.
+;; <whitespace> -> <intraline whitespace> | <line ending>
+
+(test-equal (list (string->symbol "1\x1c;2"))
+ (with-input-from-string "(1\x1c;2)" read))
+(test-equal '(1 2) (with-input-from-string "(1 2)" read))
+(test-equal '(1 2) (with-input-from-string "(1\n2)" read))
+
(test-end)
(test-exit)
diff --git a/utf-tables.c b/utf-tables.c
new file mode 100644
index 00000000..c312fbf8
--- /dev/null
+++ b/utf-tables.c
@@ -0,0 +1,5194 @@
+/* utf-tables.c - Unicode character tables for utf.c.
+ Generated by scripts/mkunicodetables.scm; do not edit. */
+
+static const int alpha[][2] = {
+ { 0x41, 0x5a },
+ { 0x61, 0x7a },
+ { 0xaa, 0xaa },
+ { 0xb5, 0xb5 },
+ { 0xba, 0xba },
+ { 0xc0, 0xd6 },
+ { 0xd8, 0xf6 },
+ { 0xf8, 0x2c1 },
+ { 0x2c6, 0x2d1 },
+ { 0x2e0, 0x2e4 },
+ { 0x2ec, 0x2ec },
+ { 0x2ee, 0x2ee },
+ { 0x345, 0x345 },
+ { 0x363, 0x374 },
+ { 0x376, 0x377 },
+ { 0x37a, 0x37d },
+ { 0x37f, 0x37f },
+ { 0x386, 0x386 },
+ { 0x388, 0x38a },
+ { 0x38c, 0x38c },
+ { 0x38e, 0x3a1 },
+ { 0x3a3, 0x3f5 },
+ { 0x3f7, 0x481 },
+ { 0x48a, 0x52f },
+ { 0x531, 0x556 },
+ { 0x559, 0x559 },
+ { 0x560, 0x588 },
+ { 0x5b0, 0x5bd },
+ { 0x5bf, 0x5bf },
+ { 0x5c1, 0x5c2 },
+ { 0x5c4, 0x5c5 },
+ { 0x5c7, 0x5c7 },
+ { 0x5d0, 0x5ea },
+ { 0x5ef, 0x5f2 },
+ { 0x610, 0x61a },
+ { 0x620, 0x657 },
+ { 0x659, 0x65f },
+ { 0x66e, 0x6d3 },
+ { 0x6d5, 0x6dc },
+ { 0x6e1, 0x6e8 },
+ { 0x6ed, 0x6ef },
+ { 0x6fa, 0x6fc },
+ { 0x6ff, 0x6ff },
+ { 0x710, 0x73f },
+ { 0x74d, 0x7b1 },
+ { 0x7ca, 0x7ea },
+ { 0x7f4, 0x7f5 },
+ { 0x7fa, 0x7fa },
+ { 0x800, 0x817 },
+ { 0x81a, 0x82c },
+ { 0x840, 0x858 },
+ { 0x860, 0x86a },
+ { 0x870, 0x887 },
+ { 0x889, 0x88f },
+ { 0x897, 0x897 },
+ { 0x8a0, 0x8c9 },
+ { 0x8d4, 0x8df },
+ { 0x8e3, 0x8e9 },
+ { 0x8f0, 0x93b },
+ { 0x93d, 0x94c },
+ { 0x94e, 0x950 },
+ { 0x955, 0x963 },
+ { 0x971, 0x983 },
+ { 0x985, 0x98c },
+ { 0x98f, 0x990 },
+ { 0x993, 0x9a8 },
+ { 0x9aa, 0x9b0 },
+ { 0x9b2, 0x9b2 },
+ { 0x9b6, 0x9b9 },
+ { 0x9bd, 0x9c4 },
+ { 0x9c7, 0x9c8 },
+ { 0x9cb, 0x9cc },
+ { 0x9ce, 0x9ce },
+ { 0x9d7, 0x9d7 },
+ { 0x9dc, 0x9dd },
+ { 0x9df, 0x9e3 },
+ { 0x9f0, 0x9f1 },
+ { 0x9fc, 0x9fc },
+ { 0xa01, 0xa03 },
+ { 0xa05, 0xa0a },
+ { 0xa0f, 0xa10 },
+ { 0xa13, 0xa28 },
+ { 0xa2a, 0xa30 },
+ { 0xa32, 0xa33 },
+ { 0xa35, 0xa36 },
+ { 0xa38, 0xa39 },
+ { 0xa3e, 0xa42 },
+ { 0xa47, 0xa48 },
+ { 0xa4b, 0xa4c },
+ { 0xa51, 0xa51 },
+ { 0xa59, 0xa5c },
+ { 0xa5e, 0xa5e },
+ { 0xa70, 0xa75 },
+ { 0xa81, 0xa83 },
+ { 0xa85, 0xa8d },
+ { 0xa8f, 0xa91 },
+ { 0xa93, 0xaa8 },
+ { 0xaaa, 0xab0 },
+ { 0xab2, 0xab3 },
+ { 0xab5, 0xab9 },
+ { 0xabd, 0xac5 },
+ { 0xac7, 0xac9 },
+ { 0xacb, 0xacc },
+ { 0xad0, 0xad0 },
+ { 0xae0, 0xae3 },
+ { 0xaf9, 0xafc },
+ { 0xb01, 0xb03 },
+ { 0xb05, 0xb0c },
+ { 0xb0f, 0xb10 },
+ { 0xb13, 0xb28 },
+ { 0xb2a, 0xb30 },
+ { 0xb32, 0xb33 },
+ { 0xb35, 0xb39 },
+ { 0xb3d, 0xb44 },
+ { 0xb47, 0xb48 },
+ { 0xb4b, 0xb4c },
+ { 0xb56, 0xb57 },
+ { 0xb5c, 0xb5d },
+ { 0xb5f, 0xb63 },
+ { 0xb71, 0xb71 },
+ { 0xb82, 0xb83 },
+ { 0xb85, 0xb8a },
+ { 0xb8e, 0xb90 },
+ { 0xb92, 0xb95 },
+ { 0xb99, 0xb9a },
+ { 0xb9c, 0xb9c },
+ { 0xb9e, 0xb9f },
+ { 0xba3, 0xba4 },
+ { 0xba8, 0xbaa },
+ { 0xbae, 0xbb9 },
+ { 0xbbe, 0xbc2 },
+ { 0xbc6, 0xbc8 },
+ { 0xbca, 0xbcc },
+ { 0xbd0, 0xbd0 },
+ { 0xbd7, 0xbd7 },
+ { 0xc00, 0xc0c },
+ { 0xc0e, 0xc10 },
+ { 0xc12, 0xc28 },
+ { 0xc2a, 0xc39 },
+ { 0xc3d, 0xc44 },
+ { 0xc46, 0xc48 },
+ { 0xc4a, 0xc4c },
+ { 0xc55, 0xc56 },
+ { 0xc58, 0xc5a },
+ { 0xc5c, 0xc5d },
+ { 0xc60, 0xc63 },
+ { 0xc80, 0xc83 },
+ { 0xc85, 0xc8c },
+ { 0xc8e, 0xc90 },
+ { 0xc92, 0xca8 },
+ { 0xcaa, 0xcb3 },
+ { 0xcb5, 0xcb9 },
+ { 0xcbd, 0xcc4 },
+ { 0xcc6, 0xcc8 },
+ { 0xcca, 0xccc },
+ { 0xcd5, 0xcd6 },
+ { 0xcdc, 0xcde },
+ { 0xce0, 0xce3 },
+ { 0xcf1, 0xcf3 },
+ { 0xd00, 0xd0c },
+ { 0xd0e, 0xd10 },
+ { 0xd12, 0xd3a },
+ { 0xd3d, 0xd44 },
+ { 0xd46, 0xd48 },
+ { 0xd4a, 0xd4c },
+ { 0xd4e, 0xd4e },
+ { 0xd54, 0xd57 },
+ { 0xd5f, 0xd63 },
+ { 0xd7a, 0xd7f },
+ { 0xd81, 0xd83 },
+ { 0xd85, 0xd96 },
+ { 0xd9a, 0xdb1 },
+ { 0xdb3, 0xdbb },
+ { 0xdbd, 0xdbd },
+ { 0xdc0, 0xdc6 },
+ { 0xdcf, 0xdd4 },
+ { 0xdd6, 0xdd6 },
+ { 0xdd8, 0xddf },
+ { 0xdf2, 0xdf3 },
+ { 0xe01, 0xe3a },
+ { 0xe40, 0xe46 },
+ { 0xe4d, 0xe4d },
+ { 0xe81, 0xe82 },
+ { 0xe84, 0xe84 },
+ { 0xe86, 0xe8a },
+ { 0xe8c, 0xea3 },
+ { 0xea5, 0xea5 },
+ { 0xea7, 0xeb9 },
+ { 0xebb, 0xebd },
+ { 0xec0, 0xec4 },
+ { 0xec6, 0xec6 },
+ { 0xecd, 0xecd },
+ { 0xedc, 0xedf },
+ { 0xf00, 0xf00 },
+ { 0xf40, 0xf47 },
+ { 0xf49, 0xf6c },
+ { 0xf71, 0xf83 },
+ { 0xf88, 0xf97 },
+ { 0xf99, 0xfbc },
+ { 0x1000, 0x1036 },
+ { 0x1038, 0x1038 },
+ { 0x103b, 0x103f },
+ { 0x1050, 0x108f },
+ { 0x109a, 0x109d },
+ { 0x10a0, 0x10c5 },
+ { 0x10c7, 0x10c7 },
+ { 0x10cd, 0x10cd },
+ { 0x10d0, 0x10fa },
+ { 0x10fc, 0x1248 },
+ { 0x124a, 0x124d },
+ { 0x1250, 0x1256 },
+ { 0x1258, 0x1258 },
+ { 0x125a, 0x125d },
+ { 0x1260, 0x1288 },
+ { 0x128a, 0x128d },
+ { 0x1290, 0x12b0 },
+ { 0x12b2, 0x12b5 },
+ { 0x12b8, 0x12be },
+ { 0x12c0, 0x12c0 },
+ { 0x12c2, 0x12c5 },
+ { 0x12c8, 0x12d6 },
+ { 0x12d8, 0x1310 },
+ { 0x1312, 0x1315 },
+ { 0x1318, 0x135a },
+ { 0x1380, 0x138f },
+ { 0x13a0, 0x13f5 },
+ { 0x13f8, 0x13fd },
+ { 0x1401, 0x166c },
+ { 0x166f, 0x167f },
+ { 0x1681, 0x169a },
+ { 0x16a0, 0x16ea },
+ { 0x16ee, 0x16f8 },
+ { 0x1700, 0x1713 },
+ { 0x171f, 0x1733 },
+ { 0x1740, 0x1753 },
+ { 0x1760, 0x176c },
+ { 0x176e, 0x1770 },
+ { 0x1772, 0x1773 },
+ { 0x1780, 0x17b3 },
+ { 0x17b6, 0x17c8 },
+ { 0x17d7, 0x17d7 },
+ { 0x17dc, 0x17dc },
+ { 0x1820, 0x1878 },
+ { 0x1880, 0x18aa },
+ { 0x18b0, 0x18f5 },
+ { 0x1900, 0x191e },
+ { 0x1920, 0x192b },
+ { 0x1930, 0x1938 },
+ { 0x1950, 0x196d },
+ { 0x1970, 0x1974 },
+ { 0x1980, 0x19ab },
+ { 0x19b0, 0x19c9 },
+ { 0x1a00, 0x1a1b },
+ { 0x1a20, 0x1a5e },
+ { 0x1a61, 0x1a74 },
+ { 0x1aa7, 0x1aa7 },
+ { 0x1abf, 0x1ac0 },
+ { 0x1acc, 0x1ace },
+ { 0x1b00, 0x1b33 },
+ { 0x1b35, 0x1b43 },
+ { 0x1b45, 0x1b4c },
+ { 0x1b80, 0x1ba9 },
+ { 0x1bac, 0x1baf },
+ { 0x1bba, 0x1be5 },
+ { 0x1be7, 0x1bf1 },
+ { 0x1c00, 0x1c36 },
+ { 0x1c4d, 0x1c4f },
+ { 0x1c5a, 0x1c7d },
+ { 0x1c80, 0x1c8a },
+ { 0x1c90, 0x1cba },
+ { 0x1cbd, 0x1cbf },
+ { 0x1ce9, 0x1cec },
+ { 0x1cee, 0x1cf3 },
+ { 0x1cf5, 0x1cf6 },
+ { 0x1cfa, 0x1cfa },
+ { 0x1d00, 0x1dbf },
+ { 0x1dd3, 0x1df4 },
+ { 0x1e00, 0x1f15 },
+ { 0x1f18, 0x1f1d },
+ { 0x1f20, 0x1f45 },
+ { 0x1f48, 0x1f4d },
+ { 0x1f50, 0x1f57 },
+ { 0x1f59, 0x1f59 },
+ { 0x1f5b, 0x1f5b },
+ { 0x1f5d, 0x1f5d },
+ { 0x1f5f, 0x1f7d },
+ { 0x1f80, 0x1fb4 },
+ { 0x1fb6, 0x1fbc },
+ { 0x1fbe, 0x1fbe },
+ { 0x1fc2, 0x1fc4 },
+ { 0x1fc6, 0x1fcc },
+ { 0x1fd0, 0x1fd3 },
+ { 0x1fd6, 0x1fdb },
+ { 0x1fe0, 0x1fec },
+ { 0x1ff2, 0x1ff4 },
+ { 0x1ff6, 0x1ffc },
+ { 0x2071, 0x2071 },
+ { 0x207f, 0x207f },
+ { 0x2090, 0x209c },
+ { 0x2102, 0x2102 },
+ { 0x2107, 0x2107 },
+ { 0x210a, 0x2113 },
+ { 0x2115, 0x2115 },
+ { 0x2119, 0x211d },
+ { 0x2124, 0x2124 },
+ { 0x2126, 0x2126 },
+ { 0x2128, 0x2128 },
+ { 0x212a, 0x212d },
+ { 0x212f, 0x2139 },
+ { 0x213c, 0x213f },
+ { 0x2145, 0x2149 },
+ { 0x214e, 0x214e },
+ { 0x2160, 0x2188 },
+ { 0x24b6, 0x24e9 },
+ { 0x2c00, 0x2ce4 },
+ { 0x2ceb, 0x2cee },
+ { 0x2cf2, 0x2cf3 },
+ { 0x2d00, 0x2d25 },
+ { 0x2d27, 0x2d27 },
+ { 0x2d2d, 0x2d2d },
+ { 0x2d30, 0x2d67 },
+ { 0x2d6f, 0x2d6f },
+ { 0x2d80, 0x2d96 },
+ { 0x2da0, 0x2da6 },
+ { 0x2da8, 0x2dae },
+ { 0x2db0, 0x2db6 },
+ { 0x2db8, 0x2dbe },
+ { 0x2dc0, 0x2dc6 },
+ { 0x2dc8, 0x2dce },
+ { 0x2dd0, 0x2dd6 },
+ { 0x2dd8, 0x2dde },
+ { 0x2de0, 0x2dff },
+ { 0x2e2f, 0x2e2f },
+ { 0x3005, 0x3007 },
+ { 0x3021, 0x3029 },
+ { 0x3031, 0x3035 },
+ { 0x3038, 0x303c },
+ { 0x3041, 0x3096 },
+ { 0x309d, 0x309f },
+ { 0x30a1, 0x30fa },
+ { 0x30fc, 0x30ff },
+ { 0x3105, 0x312f },
+ { 0x3131, 0x318e },
+ { 0x31a0, 0x31bf },
+ { 0x31f0, 0x31ff },
+ { 0x3400, 0x4dbf },
+ { 0x4e00, 0xa48c },
+ { 0xa4d0, 0xa4fd },
+ { 0xa500, 0xa60c },
+ { 0xa610, 0xa61f },
+ { 0xa62a, 0xa62b },
+ { 0xa640, 0xa66e },
+ { 0xa674, 0xa67b },
+ { 0xa67f, 0xa6ef },
+ { 0xa717, 0xa71f },
+ { 0xa722, 0xa788 },
+ { 0xa78b, 0xa7dc },
+ { 0xa7f1, 0xa805 },
+ { 0xa807, 0xa827 },
+ { 0xa840, 0xa873 },
+ { 0xa880, 0xa8c3 },
+ { 0xa8c5, 0xa8c5 },
+ { 0xa8f2, 0xa8f7 },
+ { 0xa8fb, 0xa8fb },
+ { 0xa8fd, 0xa8ff },
+ { 0xa90a, 0xa92a },
+ { 0xa930, 0xa952 },
+ { 0xa960, 0xa97c },
+ { 0xa980, 0xa9b2 },
+ { 0xa9b4, 0xa9bf },
+ { 0xa9cf, 0xa9cf },
+ { 0xa9e0, 0xa9ef },
+ { 0xa9fa, 0xa9fe },
+ { 0xaa00, 0xaa36 },
+ { 0xaa40, 0xaa4d },
+ { 0xaa60, 0xaa76 },
+ { 0xaa7a, 0xaabe },
+ { 0xaac0, 0xaac0 },
+ { 0xaac2, 0xaac2 },
+ { 0xaadb, 0xaadd },
+ { 0xaae0, 0xaaef },
+ { 0xaaf2, 0xaaf5 },
+ { 0xab01, 0xab06 },
+ { 0xab09, 0xab0e },
+ { 0xab11, 0xab16 },
+ { 0xab20, 0xab26 },
+ { 0xab28, 0xab2e },
+ { 0xab30, 0xab5a },
+ { 0xab5c, 0xab69 },
+ { 0xab70, 0xabea },
+ { 0xac00, 0xd7a3 },
+ { 0xd7b0, 0xd7c6 },
+ { 0xd7cb, 0xd7fb },
+ { 0xf900, 0xfa6d },
+ { 0xfa70, 0xfad9 },
+ { 0xfb00, 0xfb06 },
+ { 0xfb13, 0xfb17 },
+ { 0xfb1d, 0xfb28 },
+ { 0xfb2a, 0xfb36 },
+ { 0xfb38, 0xfb3c },
+ { 0xfb3e, 0xfb3e },
+ { 0xfb40, 0xfb41 },
+ { 0xfb43, 0xfb44 },
+ { 0xfb46, 0xfbb1 },
+ { 0xfbd3, 0xfd3d },
+ { 0xfd50, 0xfd8f },
+ { 0xfd92, 0xfdc7 },
+ { 0xfdf0, 0xfdfb },
+ { 0xfe70, 0xfe74 },
+ { 0xfe76, 0xfefc },
+ { 0xff21, 0xff3a },
+ { 0xff41, 0xff5a },
+ { 0xff66, 0xffbe },
+ { 0xffc2, 0xffc7 },
+ { 0xffca, 0xffcf },
+ { 0xffd2, 0xffd7 },
+ { 0xffda, 0xffdc },
+ { 0x10000, 0x1000b },
+ { 0x1000d, 0x10026 },
+ { 0x10028, 0x1003a },
+ { 0x1003c, 0x1003d },
+ { 0x1003f, 0x1004d },
+ { 0x10050, 0x1005d },
+ { 0x10080, 0x100fa },
+ { 0x10140, 0x10174 },
+ { 0x10280, 0x1029c },
+ { 0x102a0, 0x102d0 },
+ { 0x10300, 0x1031f },
+ { 0x1032d, 0x1034a },
+ { 0x10350, 0x1037a },
+ { 0x10380, 0x1039d },
+ { 0x103a0, 0x103c3 },
+ { 0x103c8, 0x103cf },
+ { 0x103d1, 0x103d5 },
+ { 0x10400, 0x1049d },
+ { 0x104b0, 0x104d3 },
+ { 0x104d8, 0x104fb },
+ { 0x10500, 0x10527 },
+ { 0x10530, 0x10563 },
+ { 0x10570, 0x1057a },
+ { 0x1057c, 0x1058a },
+ { 0x1058c, 0x10592 },
+ { 0x10594, 0x10595 },
+ { 0x10597, 0x105a1 },
+ { 0x105a3, 0x105b1 },
+ { 0x105b3, 0x105b9 },
+ { 0x105bb, 0x105bc },
+ { 0x105c0, 0x105f3 },
+ { 0x10600, 0x10736 },
+ { 0x10740, 0x10755 },
+ { 0x10760, 0x10767 },
+ { 0x10780, 0x10785 },
+ { 0x10787, 0x107b0 },
+ { 0x107b2, 0x107ba },
+ { 0x10800, 0x10805 },
+ { 0x10808, 0x10808 },
+ { 0x1080a, 0x10835 },
+ { 0x10837, 0x10838 },
+ { 0x1083c, 0x1083c },
+ { 0x1083f, 0x10855 },
+ { 0x10860, 0x10876 },
+ { 0x10880, 0x1089e },
+ { 0x108e0, 0x108f2 },
+ { 0x108f4, 0x108f5 },
+ { 0x10900, 0x10915 },
+ { 0x10920, 0x10939 },
+ { 0x10940, 0x10959 },
+ { 0x10980, 0x109b7 },
+ { 0x109be, 0x109bf },
+ { 0x10a00, 0x10a03 },
+ { 0x10a05, 0x10a06 },
+ { 0x10a0c, 0x10a13 },
+ { 0x10a15, 0x10a17 },
+ { 0x10a19, 0x10a35 },
+ { 0x10a60, 0x10a7c },
+ { 0x10a80, 0x10a9c },
+ { 0x10ac0, 0x10ac7 },
+ { 0x10ac9, 0x10ae4 },
+ { 0x10b00, 0x10b35 },
+ { 0x10b40, 0x10b55 },
+ { 0x10b60, 0x10b72 },
+ { 0x10b80, 0x10b91 },
+ { 0x10c00, 0x10c48 },
+ { 0x10c80, 0x10cb2 },
+ { 0x10cc0, 0x10cf2 },
+ { 0x10d00, 0x10d27 },
+ { 0x10d4a, 0x10d65 },
+ { 0x10d69, 0x10d69 },
+ { 0x10d6f, 0x10d85 },
+ { 0x10e80, 0x10ea9 },
+ { 0x10eab, 0x10eac },
+ { 0x10eb0, 0x10eb1 },
+ { 0x10ec2, 0x10ec7 },
+ { 0x10efa, 0x10efc },
+ { 0x10f00, 0x10f1c },
+ { 0x10f27, 0x10f27 },
+ { 0x10f30, 0x10f45 },
+ { 0x10f70, 0x10f81 },
+ { 0x10fb0, 0x10fc4 },
+ { 0x10fe0, 0x10ff6 },
+ { 0x11000, 0x11045 },
+ { 0x11071, 0x11075 },
+ { 0x11080, 0x110b8 },
+ { 0x110c2, 0x110c2 },
+ { 0x110d0, 0x110e8 },
+ { 0x11100, 0x11132 },
+ { 0x11144, 0x11147 },
+ { 0x11150, 0x11172 },
+ { 0x11176, 0x11176 },
+ { 0x11180, 0x111bf },
+ { 0x111c1, 0x111c4 },
+ { 0x111ce, 0x111cf },
+ { 0x111da, 0x111da },
+ { 0x111dc, 0x111dc },
+ { 0x11200, 0x11211 },
+ { 0x11213, 0x11234 },
+ { 0x11237, 0x11237 },
+ { 0x1123e, 0x11241 },
+ { 0x11280, 0x11286 },
+ { 0x11288, 0x11288 },
+ { 0x1128a, 0x1128d },
+ { 0x1128f, 0x1129d },
+ { 0x1129f, 0x112a8 },
+ { 0x112b0, 0x112e8 },
+ { 0x11300, 0x11303 },
+ { 0x11305, 0x1130c },
+ { 0x1130f, 0x11310 },
+ { 0x11313, 0x11328 },
+ { 0x1132a, 0x11330 },
+ { 0x11332, 0x11333 },
+ { 0x11335, 0x11339 },
+ { 0x1133d, 0x11344 },
+ { 0x11347, 0x11348 },
+ { 0x1134b, 0x1134c },
+ { 0x11350, 0x11350 },
+ { 0x11357, 0x11357 },
+ { 0x1135d, 0x11363 },
+ { 0x11380, 0x11389 },
+ { 0x1138b, 0x1138b },
+ { 0x1138e, 0x1138e },
+ { 0x11390, 0x113b5 },
+ { 0x113b7, 0x113c0 },
+ { 0x113c2, 0x113c2 },
+ { 0x113c5, 0x113c5 },
+ { 0x113c7, 0x113ca },
+ { 0x113cc, 0x113cd },
+ { 0x113d1, 0x113d1 },
+ { 0x113d3, 0x113d3 },
+ { 0x11400, 0x11441 },
+ { 0x11443, 0x11445 },
+ { 0x11447, 0x1144a },
+ { 0x1145f, 0x11461 },
+ { 0x11480, 0x114c1 },
+ { 0x114c4, 0x114c5 },
+ { 0x114c7, 0x114c7 },
+ { 0x11580, 0x115b5 },
+ { 0x115b8, 0x115be },
+ { 0x115d8, 0x115dd },
+ { 0x11600, 0x1163e },
+ { 0x11640, 0x11640 },
+ { 0x11644, 0x11644 },
+ { 0x11680, 0x116b5 },
+ { 0x116b8, 0x116b8 },
+ { 0x11700, 0x1171a },
+ { 0x1171d, 0x1172a },
+ { 0x11740, 0x11746 },
+ { 0x11800, 0x11838 },
+ { 0x118a0, 0x118df },
+ { 0x118ff, 0x11906 },
+ { 0x11909, 0x11909 },
+ { 0x1190c, 0x11913 },
+ { 0x11915, 0x11916 },
+ { 0x11918, 0x11935 },
+ { 0x11937, 0x11938 },
+ { 0x1193b, 0x1193c },
+ { 0x1193f, 0x11942 },
+ { 0x119a0, 0x119a7 },
+ { 0x119aa, 0x119d7 },
+ { 0x119da, 0x119df },
+ { 0x119e1, 0x119e1 },
+ { 0x119e3, 0x119e4 },
+ { 0x11a00, 0x11a32 },
+ { 0x11a35, 0x11a3e },
+ { 0x11a50, 0x11a97 },
+ { 0x11a9d, 0x11a9d },
+ { 0x11ab0, 0x11af8 },
+ { 0x11b60, 0x11b67 },
+ { 0x11bc0, 0x11be0 },
+ { 0x11c00, 0x11c08 },
+ { 0x11c0a, 0x11c36 },
+ { 0x11c38, 0x11c3e },
+ { 0x11c40, 0x11c40 },
+ { 0x11c72, 0x11c8f },
+ { 0x11c92, 0x11ca7 },
+ { 0x11ca9, 0x11cb6 },
+ { 0x11d00, 0x11d06 },
+ { 0x11d08, 0x11d09 },
+ { 0x11d0b, 0x11d36 },
+ { 0x11d3a, 0x11d3a },
+ { 0x11d3c, 0x11d3d },
+ { 0x11d3f, 0x11d41 },
+ { 0x11d43, 0x11d43 },
+ { 0x11d46, 0x11d47 },
+ { 0x11d60, 0x11d65 },
+ { 0x11d67, 0x11d68 },
+ { 0x11d6a, 0x11d8e },
+ { 0x11d90, 0x11d91 },
+ { 0x11d93, 0x11d96 },
+ { 0x11d98, 0x11d98 },
+ { 0x11db0, 0x11ddb },
+ { 0x11ee0, 0x11ef6 },
+ { 0x11f00, 0x11f10 },
+ { 0x11f12, 0x11f3a },
+ { 0x11f3e, 0x11f40 },
+ { 0x11fb0, 0x11fb0 },
+ { 0x12000, 0x12399 },
+ { 0x12400, 0x1246e },
+ { 0x12480, 0x12543 },
+ { 0x12f90, 0x12ff0 },
+ { 0x13000, 0x1342f },
+ { 0x13441, 0x13446 },
+ { 0x13460, 0x143fa },
+ { 0x14400, 0x14646 },
+ { 0x16100, 0x1612e },
+ { 0x16800, 0x16a38 },
+ { 0x16a40, 0x16a5e },
+ { 0x16a70, 0x16abe },
+ { 0x16ad0, 0x16aed },
+ { 0x16b00, 0x16b2f },
+ { 0x16b40, 0x16b43 },
+ { 0x16b63, 0x16b77 },
+ { 0x16b7d, 0x16b8f },
+ { 0x16d40, 0x16d6c },
+ { 0x16e40, 0x16e7f },
+ { 0x16ea0, 0x16eb8 },
+ { 0x16ebb, 0x16ed3 },
+ { 0x16f00, 0x16f4a },
+ { 0x16f4f, 0x16f87 },
+ { 0x16f8f, 0x16f9f },
+ { 0x16fe0, 0x16fe1 },
+ { 0x16fe3, 0x16fe3 },
+ { 0x16ff0, 0x16ff6 },
+ { 0x17000, 0x18cd5 },
+ { 0x18cff, 0x18d1e },
+ { 0x18d80, 0x18df2 },
+ { 0x1aff0, 0x1aff3 },
+ { 0x1aff5, 0x1affb },
+ { 0x1affd, 0x1affe },
+ { 0x1b000, 0x1b122 },
+ { 0x1b132, 0x1b132 },
+ { 0x1b150, 0x1b152 },
+ { 0x1b155, 0x1b155 },
+ { 0x1b164, 0x1b167 },
+ { 0x1b170, 0x1b2fb },
+ { 0x1bc00, 0x1bc6a },
+ { 0x1bc70, 0x1bc7c },
+ { 0x1bc80, 0x1bc88 },
+ { 0x1bc90, 0x1bc99 },
+ { 0x1bc9e, 0x1bc9e },
+ { 0x1d400, 0x1d454 },
+ { 0x1d456, 0x1d49c },
+ { 0x1d49e, 0x1d49f },
+ { 0x1d4a2, 0x1d4a2 },
+ { 0x1d4a5, 0x1d4a6 },
+ { 0x1d4a9, 0x1d4ac },
+ { 0x1d4ae, 0x1d4b9 },
+ { 0x1d4bb, 0x1d4bb },
+ { 0x1d4bd, 0x1d4c3 },
+ { 0x1d4c5, 0x1d505 },
+ { 0x1d507, 0x1d50a },
+ { 0x1d50d, 0x1d514 },
+ { 0x1d516, 0x1d51c },
+ { 0x1d51e, 0x1d539 },
+ { 0x1d53b, 0x1d53e },
+ { 0x1d540, 0x1d544 },
+ { 0x1d546, 0x1d546 },
+ { 0x1d54a, 0x1d550 },
+ { 0x1d552, 0x1d6a5 },
+ { 0x1d6a8, 0x1d6c0 },
+ { 0x1d6c2, 0x1d6da },
+ { 0x1d6dc, 0x1d6fa },
+ { 0x1d6fc, 0x1d714 },
+ { 0x1d716, 0x1d734 },
+ { 0x1d736, 0x1d74e },
+ { 0x1d750, 0x1d76e },
+ { 0x1d770, 0x1d788 },
+ { 0x1d78a, 0x1d7a8 },
+ { 0x1d7aa, 0x1d7c2 },
+ { 0x1d7c4, 0x1d7cb },
+ { 0x1df00, 0x1df1e },
+ { 0x1df25, 0x1df2a },
+ { 0x1e000, 0x1e006 },
+ { 0x1e008, 0x1e018 },
+ { 0x1e01b, 0x1e021 },
+ { 0x1e023, 0x1e024 },
+ { 0x1e026, 0x1e02a },
+ { 0x1e030, 0x1e06d },
+ { 0x1e08f, 0x1e08f },
+ { 0x1e100, 0x1e12c },
+ { 0x1e137, 0x1e13d },
+ { 0x1e14e, 0x1e14e },
+ { 0x1e290, 0x1e2ad },
+ { 0x1e2c0, 0x1e2eb },
+ { 0x1e4d0, 0x1e4eb },
+ { 0x1e5d0, 0x1e5ed },
+ { 0x1e5f0, 0x1e5f0 },
+ { 0x1e6c0, 0x1e6de },
+ { 0x1e6e0, 0x1e6f5 },
+ { 0x1e6fe, 0x1e6ff },
+ { 0x1e7e0, 0x1e7e6 },
+ { 0x1e7e8, 0x1e7eb },
+ { 0x1e7ed, 0x1e7ee },
+ { 0x1e7f0, 0x1e7fe },
+ { 0x1e800, 0x1e8c4 },
+ { 0x1e900, 0x1e943 },
+ { 0x1e947, 0x1e947 },
+ { 0x1e94b, 0x1e94b },
+ { 0x1ee00, 0x1ee03 },
+ { 0x1ee05, 0x1ee1f },
+ { 0x1ee21, 0x1ee22 },
+ { 0x1ee24, 0x1ee24 },
+ { 0x1ee27, 0x1ee27 },
+ { 0x1ee29, 0x1ee32 },
+ { 0x1ee34, 0x1ee37 },
+ { 0x1ee39, 0x1ee39 },
+ { 0x1ee3b, 0x1ee3b },
+ { 0x1ee42, 0x1ee42 },
+ { 0x1ee47, 0x1ee47 },
+ { 0x1ee49, 0x1ee49 },
+ { 0x1ee4b, 0x1ee4b },
+ { 0x1ee4d, 0x1ee4f },
+ { 0x1ee51, 0x1ee52 },
+ { 0x1ee54, 0x1ee54 },
+ { 0x1ee57, 0x1ee57 },
+ { 0x1ee59, 0x1ee59 },
+ { 0x1ee5b, 0x1ee5b },
+ { 0x1ee5d, 0x1ee5d },
+ { 0x1ee5f, 0x1ee5f },
+ { 0x1ee61, 0x1ee62 },
+ { 0x1ee64, 0x1ee64 },
+ { 0x1ee67, 0x1ee6a },
+ { 0x1ee6c, 0x1ee72 },
+ { 0x1ee74, 0x1ee77 },
+ { 0x1ee79, 0x1ee7c },
+ { 0x1ee7e, 0x1ee7e },
+ { 0x1ee80, 0x1ee89 },
+ { 0x1ee8b, 0x1ee9b },
+ { 0x1eea1, 0x1eea3 },
+ { 0x1eea5, 0x1eea9 },
+ { 0x1eeab, 0x1eebb },
+ { 0x1f130, 0x1f149 },
+ { 0x1f150, 0x1f169 },
+ { 0x1f170, 0x1f189 },
+ { 0x20000, 0x2a6df },
+ { 0x2a700, 0x2b81d },
+ { 0x2b820, 0x2cead },
+ { 0x2ceb0, 0x2ebe0 },
+ { 0x2ebf0, 0x2ee5d },
+ { 0x2f800, 0x2fa1d },
+ { 0x30000, 0x3134a },
+ { 0x31350, 0x33479 },
+};
+static const int upper[][2] = {
+ { 0x41, 0x5a },
+ { 0xc0, 0xd6 },
+ { 0xd8, 0xde },
+ { 0x100, 0x100 },
+ { 0x102, 0x102 },
+ { 0x104, 0x104 },
+ { 0x106, 0x106 },
+ { 0x108, 0x108 },
+ { 0x10a, 0x10a },
+ { 0x10c, 0x10c },
+ { 0x10e, 0x10e },
+ { 0x110, 0x110 },
+ { 0x112, 0x112 },
+ { 0x114, 0x114 },
+ { 0x116, 0x116 },
+ { 0x118, 0x118 },
+ { 0x11a, 0x11a },
+ { 0x11c, 0x11c },
+ { 0x11e, 0x11e },
+ { 0x120, 0x120 },
+ { 0x122, 0x122 },
+ { 0x124, 0x124 },
+ { 0x126, 0x126 },
+ { 0x128, 0x128 },
+ { 0x12a, 0x12a },
+ { 0x12c, 0x12c },
+ { 0x12e, 0x12e },
+ { 0x130, 0x130 },
+ { 0x132, 0x132 },
+ { 0x134, 0x134 },
+ { 0x136, 0x136 },
+ { 0x139, 0x139 },
+ { 0x13b, 0x13b },
+ { 0x13d, 0x13d },
+ { 0x13f, 0x13f },
+ { 0x141, 0x141 },
+ { 0x143, 0x143 },
+ { 0x145, 0x145 },
+ { 0x147, 0x147 },
+ { 0x14a, 0x14a },
+ { 0x14c, 0x14c },
+ { 0x14e, 0x14e },
+ { 0x150, 0x150 },
+ { 0x152, 0x152 },
+ { 0x154, 0x154 },
+ { 0x156, 0x156 },
+ { 0x158, 0x158 },
+ { 0x15a, 0x15a },
+ { 0x15c, 0x15c },
+ { 0x15e, 0x15e },
+ { 0x160, 0x160 },
+ { 0x162, 0x162 },
+ { 0x164, 0x164 },
+ { 0x166, 0x166 },
+ { 0x168, 0x168 },
+ { 0x16a, 0x16a },
+ { 0x16c, 0x16c },
+ { 0x16e, 0x16e },
+ { 0x170, 0x170 },
+ { 0x172, 0x172 },
+ { 0x174, 0x174 },
+ { 0x176, 0x176 },
+ { 0x178, 0x179 },
+ { 0x17b, 0x17b },
+ { 0x17d, 0x17d },
+ { 0x181, 0x182 },
+ { 0x184, 0x184 },
+ { 0x186, 0x187 },
+ { 0x189, 0x18b },
+ { 0x18e, 0x191 },
+ { 0x193, 0x194 },
+ { 0x196, 0x198 },
+ { 0x19c, 0x19d },
+ { 0x19f, 0x1a0 },
+ { 0x1a2, 0x1a2 },
+ { 0x1a4, 0x1a4 },
+ { 0x1a6, 0x1a7 },
+ { 0x1a9, 0x1a9 },
+ { 0x1ac, 0x1ac },
+ { 0x1ae, 0x1af },
+ { 0x1b1, 0x1b3 },
+ { 0x1b5, 0x1b5 },
+ { 0x1b7, 0x1b8 },
+ { 0x1bc, 0x1bc },
+ { 0x1c4, 0x1c4 },
+ { 0x1c7, 0x1c7 },
+ { 0x1ca, 0x1ca },
+ { 0x1cd, 0x1cd },
+ { 0x1cf, 0x1cf },
+ { 0x1d1, 0x1d1 },
+ { 0x1d3, 0x1d3 },
+ { 0x1d5, 0x1d5 },
+ { 0x1d7, 0x1d7 },
+ { 0x1d9, 0x1d9 },
+ { 0x1db, 0x1db },
+ { 0x1de, 0x1de },
+ { 0x1e0, 0x1e0 },
+ { 0x1e2, 0x1e2 },
+ { 0x1e4, 0x1e4 },
+ { 0x1e6, 0x1e6 },
+ { 0x1e8, 0x1e8 },
+ { 0x1ea, 0x1ea },
+ { 0x1ec, 0x1ec },
+ { 0x1ee, 0x1ee },
+ { 0x1f1, 0x1f1 },
+ { 0x1f4, 0x1f4 },
+ { 0x1f6, 0x1f8 },
+ { 0x1fa, 0x1fa },
+ { 0x1fc, 0x1fc },
+ { 0x1fe, 0x1fe },
+ { 0x200, 0x200 },
+ { 0x202, 0x202 },
+ { 0x204, 0x204 },
+ { 0x206, 0x206 },
+ { 0x208, 0x208 },
+ { 0x20a, 0x20a },
+ { 0x20c, 0x20c },
+ { 0x20e, 0x20e },
+ { 0x210, 0x210 },
+ { 0x212, 0x212 },
+ { 0x214, 0x214 },
+ { 0x216, 0x216 },
+ { 0x218, 0x218 },
+ { 0x21a, 0x21a },
+ { 0x21c, 0x21c },
+ { 0x21e, 0x21e },
+ { 0x220, 0x220 },
+ { 0x222, 0x222 },
+ { 0x224, 0x224 },
+ { 0x226, 0x226 },
+ { 0x228, 0x228 },
+ { 0x22a, 0x22a },
+ { 0x22c, 0x22c },
+ { 0x22e, 0x22e },
+ { 0x230, 0x230 },
+ { 0x232, 0x232 },
+ { 0x23a, 0x23b },
+ { 0x23d, 0x23e },
+ { 0x241, 0x241 },
+ { 0x243, 0x246 },
+ { 0x248, 0x248 },
+ { 0x24a, 0x24a },
+ { 0x24c, 0x24c },
+ { 0x24e, 0x24e },
+ { 0x370, 0x370 },
+ { 0x372, 0x372 },
+ { 0x376, 0x376 },
+ { 0x37f, 0x37f },
+ { 0x386, 0x386 },
+ { 0x388, 0x38a },
+ { 0x38c, 0x38c },
+ { 0x38e, 0x38f },
+ { 0x391, 0x3a1 },
+ { 0x3a3, 0x3ab },
+ { 0x3cf, 0x3cf },
+ { 0x3d2, 0x3d4 },
+ { 0x3d8, 0x3d8 },
+ { 0x3da, 0x3da },
+ { 0x3dc, 0x3dc },
+ { 0x3de, 0x3de },
+ { 0x3e0, 0x3e0 },
+ { 0x3e2, 0x3e2 },
+ { 0x3e4, 0x3e4 },
+ { 0x3e6, 0x3e6 },
+ { 0x3e8, 0x3e8 },
+ { 0x3ea, 0x3ea },
+ { 0x3ec, 0x3ec },
+ { 0x3ee, 0x3ee },
+ { 0x3f4, 0x3f4 },
+ { 0x3f7, 0x3f7 },
+ { 0x3f9, 0x3fa },
+ { 0x3fd, 0x42f },
+ { 0x460, 0x460 },
+ { 0x462, 0x462 },
+ { 0x464, 0x464 },
+ { 0x466, 0x466 },
+ { 0x468, 0x468 },
+ { 0x46a, 0x46a },
+ { 0x46c, 0x46c },
+ { 0x46e, 0x46e },
+ { 0x470, 0x470 },
+ { 0x472, 0x472 },
+ { 0x474, 0x474 },
+ { 0x476, 0x476 },
+ { 0x478, 0x478 },
+ { 0x47a, 0x47a },
+ { 0x47c, 0x47c },
+ { 0x47e, 0x47e },
+ { 0x480, 0x480 },
+ { 0x48a, 0x48a },
+ { 0x48c, 0x48c },
+ { 0x48e, 0x48e },
+ { 0x490, 0x490 },
+ { 0x492, 0x492 },
+ { 0x494, 0x494 },
+ { 0x496, 0x496 },
+ { 0x498, 0x498 },
+ { 0x49a, 0x49a },
+ { 0x49c, 0x49c },
+ { 0x49e, 0x49e },
+ { 0x4a0, 0x4a0 },
+ { 0x4a2, 0x4a2 },
+ { 0x4a4, 0x4a4 },
+ { 0x4a6, 0x4a6 },
+ { 0x4a8, 0x4a8 },
+ { 0x4aa, 0x4aa },
+ { 0x4ac, 0x4ac },
+ { 0x4ae, 0x4ae },
+ { 0x4b0, 0x4b0 },
+ { 0x4b2, 0x4b2 },
+ { 0x4b4, 0x4b4 },
+ { 0x4b6, 0x4b6 },
+ { 0x4b8, 0x4b8 },
+ { 0x4ba, 0x4ba },
+ { 0x4bc, 0x4bc },
+ { 0x4be, 0x4be },
+ { 0x4c0, 0x4c1 },
+ { 0x4c3, 0x4c3 },
+ { 0x4c5, 0x4c5 },
+ { 0x4c7, 0x4c7 },
+ { 0x4c9, 0x4c9 },
+ { 0x4cb, 0x4cb },
+ { 0x4cd, 0x4cd },
+ { 0x4d0, 0x4d0 },
+ { 0x4d2, 0x4d2 },
+ { 0x4d4, 0x4d4 },
+ { 0x4d6, 0x4d6 },
+ { 0x4d8, 0x4d8 },
+ { 0x4da, 0x4da },
+ { 0x4dc, 0x4dc },
+ { 0x4de, 0x4de },
+ { 0x4e0, 0x4e0 },
+ { 0x4e2, 0x4e2 },
+ { 0x4e4, 0x4e4 },
+ { 0x4e6, 0x4e6 },
+ { 0x4e8, 0x4e8 },
+ { 0x4ea, 0x4ea },
+ { 0x4ec, 0x4ec },
+ { 0x4ee, 0x4ee },
+ { 0x4f0, 0x4f0 },
+ { 0x4f2, 0x4f2 },
+ { 0x4f4, 0x4f4 },
+ { 0x4f6, 0x4f6 },
+ { 0x4f8, 0x4f8 },
+ { 0x4fa, 0x4fa },
+ { 0x4fc, 0x4fc },
+ { 0x4fe, 0x4fe },
+ { 0x500, 0x500 },
+ { 0x502, 0x502 },
+ { 0x504, 0x504 },
+ { 0x506, 0x506 },
+ { 0x508, 0x508 },
+ { 0x50a, 0x50a },
+ { 0x50c, 0x50c },
+ { 0x50e, 0x50e },
+ { 0x510, 0x510 },
+ { 0x512, 0x512 },
+ { 0x514, 0x514 },
+ { 0x516, 0x516 },
+ { 0x518, 0x518 },
+ { 0x51a, 0x51a },
+ { 0x51c, 0x51c },
+ { 0x51e, 0x51e },
+ { 0x520, 0x520 },
+ { 0x522, 0x522 },
+ { 0x524, 0x524 },
+ { 0x526, 0x526 },
+ { 0x528, 0x528 },
+ { 0x52a, 0x52a },
+ { 0x52c, 0x52c },
+ { 0x52e, 0x52e },
+ { 0x531, 0x556 },
+ { 0x10a0, 0x10c5 },
+ { 0x10c7, 0x10c7 },
+ { 0x10cd, 0x10cd },
+ { 0x13a0, 0x13f5 },
+ { 0x1c89, 0x1c89 },
+ { 0x1c90, 0x1cba },
+ { 0x1cbd, 0x1cbf },
+ { 0x1e00, 0x1e00 },
+ { 0x1e02, 0x1e02 },
+ { 0x1e04, 0x1e04 },
+ { 0x1e06, 0x1e06 },
+ { 0x1e08, 0x1e08 },
+ { 0x1e0a, 0x1e0a },
+ { 0x1e0c, 0x1e0c },
+ { 0x1e0e, 0x1e0e },
+ { 0x1e10, 0x1e10 },
+ { 0x1e12, 0x1e12 },
+ { 0x1e14, 0x1e14 },
+ { 0x1e16, 0x1e16 },
+ { 0x1e18, 0x1e18 },
+ { 0x1e1a, 0x1e1a },
+ { 0x1e1c, 0x1e1c },
+ { 0x1e1e, 0x1e1e },
+ { 0x1e20, 0x1e20 },
+ { 0x1e22, 0x1e22 },
+ { 0x1e24, 0x1e24 },
+ { 0x1e26, 0x1e26 },
+ { 0x1e28, 0x1e28 },
+ { 0x1e2a, 0x1e2a },
+ { 0x1e2c, 0x1e2c },
+ { 0x1e2e, 0x1e2e },
+ { 0x1e30, 0x1e30 },
+ { 0x1e32, 0x1e32 },
+ { 0x1e34, 0x1e34 },
+ { 0x1e36, 0x1e36 },
+ { 0x1e38, 0x1e38 },
+ { 0x1e3a, 0x1e3a },
+ { 0x1e3c, 0x1e3c },
+ { 0x1e3e, 0x1e3e },
+ { 0x1e40, 0x1e40 },
+ { 0x1e42, 0x1e42 },
+ { 0x1e44, 0x1e44 },
+ { 0x1e46, 0x1e46 },
+ { 0x1e48, 0x1e48 },
+ { 0x1e4a, 0x1e4a },
+ { 0x1e4c, 0x1e4c },
+ { 0x1e4e, 0x1e4e },
+ { 0x1e50, 0x1e50 },
+ { 0x1e52, 0x1e52 },
+ { 0x1e54, 0x1e54 },
+ { 0x1e56, 0x1e56 },
+ { 0x1e58, 0x1e58 },
+ { 0x1e5a, 0x1e5a },
+ { 0x1e5c, 0x1e5c },
+ { 0x1e5e, 0x1e5e },
+ { 0x1e60, 0x1e60 },
+ { 0x1e62, 0x1e62 },
+ { 0x1e64, 0x1e64 },
+ { 0x1e66, 0x1e66 },
+ { 0x1e68, 0x1e68 },
+ { 0x1e6a, 0x1e6a },
+ { 0x1e6c, 0x1e6c },
+ { 0x1e6e, 0x1e6e },
+ { 0x1e70, 0x1e70 },
+ { 0x1e72, 0x1e72 },
+ { 0x1e74, 0x1e74 },
+ { 0x1e76, 0x1e76 },
+ { 0x1e78, 0x1e78 },
+ { 0x1e7a, 0x1e7a },
+ { 0x1e7c, 0x1e7c },
+ { 0x1e7e, 0x1e7e },
+ { 0x1e80, 0x1e80 },
+ { 0x1e82, 0x1e82 },
+ { 0x1e84, 0x1e84 },
+ { 0x1e86, 0x1e86 },
+ { 0x1e88, 0x1e88 },
+ { 0x1e8a, 0x1e8a },
+ { 0x1e8c, 0x1e8c },
+ { 0x1e8e, 0x1e8e },
+ { 0x1e90, 0x1e90 },
+ { 0x1e92, 0x1e92 },
+ { 0x1e94, 0x1e94 },
+ { 0x1e9e, 0x1e9e },
+ { 0x1ea0, 0x1ea0 },
+ { 0x1ea2, 0x1ea2 },
+ { 0x1ea4, 0x1ea4 },
+ { 0x1ea6, 0x1ea6 },
+ { 0x1ea8, 0x1ea8 },
+ { 0x1eaa, 0x1eaa },
+ { 0x1eac, 0x1eac },
+ { 0x1eae, 0x1eae },
+ { 0x1eb0, 0x1eb0 },
+ { 0x1eb2, 0x1eb2 },
+ { 0x1eb4, 0x1eb4 },
+ { 0x1eb6, 0x1eb6 },
+ { 0x1eb8, 0x1eb8 },
+ { 0x1eba, 0x1eba },
+ { 0x1ebc, 0x1ebc },
+ { 0x1ebe, 0x1ebe },
+ { 0x1ec0, 0x1ec0 },
+ { 0x1ec2, 0x1ec2 },
+ { 0x1ec4, 0x1ec4 },
+ { 0x1ec6, 0x1ec6 },
+ { 0x1ec8, 0x1ec8 },
+ { 0x1eca, 0x1eca },
+ { 0x1ecc, 0x1ecc },
+ { 0x1ece, 0x1ece },
+ { 0x1ed0, 0x1ed0 },
+ { 0x1ed2, 0x1ed2 },
+ { 0x1ed4, 0x1ed4 },
+ { 0x1ed6, 0x1ed6 },
+ { 0x1ed8, 0x1ed8 },
+ { 0x1eda, 0x1eda },
+ { 0x1edc, 0x1edc },
+ { 0x1ede, 0x1ede },
+ { 0x1ee0, 0x1ee0 },
+ { 0x1ee2, 0x1ee2 },
+ { 0x1ee4, 0x1ee4 },
+ { 0x1ee6, 0x1ee6 },
+ { 0x1ee8, 0x1ee8 },
+ { 0x1eea, 0x1eea },
+ { 0x1eec, 0x1eec },
+ { 0x1eee, 0x1eee },
+ { 0x1ef0, 0x1ef0 },
+ { 0x1ef2, 0x1ef2 },
+ { 0x1ef4, 0x1ef4 },
+ { 0x1ef6, 0x1ef6 },
+ { 0x1ef8, 0x1ef8 },
+ { 0x1efa, 0x1efa },
+ { 0x1efc, 0x1efc },
+ { 0x1efe, 0x1efe },
+ { 0x1f08, 0x1f0f },
+ { 0x1f18, 0x1f1d },
+ { 0x1f28, 0x1f2f },
+ { 0x1f38, 0x1f3f },
+ { 0x1f48, 0x1f4d },
+ { 0x1f59, 0x1f59 },
+ { 0x1f5b, 0x1f5b },
+ { 0x1f5d, 0x1f5d },
+ { 0x1f5f, 0x1f5f },
+ { 0x1f68, 0x1f6f },
+ { 0x1fb8, 0x1fbb },
+ { 0x1fc8, 0x1fcb },
+ { 0x1fd8, 0x1fdb },
+ { 0x1fe8, 0x1fec },
+ { 0x1ff8, 0x1ffb },
+ { 0x2102, 0x2102 },
+ { 0x2107, 0x2107 },
+ { 0x210b, 0x210d },
+ { 0x2110, 0x2112 },
+ { 0x2115, 0x2115 },
+ { 0x2119, 0x211d },
+ { 0x2124, 0x2124 },
+ { 0x2126, 0x2126 },
+ { 0x2128, 0x2128 },
+ { 0x212a, 0x212d },
+ { 0x2130, 0x2133 },
+ { 0x213e, 0x213f },
+ { 0x2145, 0x2145 },
+ { 0x2160, 0x216f },
+ { 0x2183, 0x2183 },
+ { 0x24b6, 0x24cf },
+ { 0x2c00, 0x2c2f },
+ { 0x2c60, 0x2c60 },
+ { 0x2c62, 0x2c64 },
+ { 0x2c67, 0x2c67 },
+ { 0x2c69, 0x2c69 },
+ { 0x2c6b, 0x2c6b },
+ { 0x2c6d, 0x2c70 },
+ { 0x2c72, 0x2c72 },
+ { 0x2c75, 0x2c75 },
+ { 0x2c7e, 0x2c80 },
+ { 0x2c82, 0x2c82 },
+ { 0x2c84, 0x2c84 },
+ { 0x2c86, 0x2c86 },
+ { 0x2c88, 0x2c88 },
+ { 0x2c8a, 0x2c8a },
+ { 0x2c8c, 0x2c8c },
+ { 0x2c8e, 0x2c8e },
+ { 0x2c90, 0x2c90 },
+ { 0x2c92, 0x2c92 },
+ { 0x2c94, 0x2c94 },
+ { 0x2c96, 0x2c96 },
+ { 0x2c98, 0x2c98 },
+ { 0x2c9a, 0x2c9a },
+ { 0x2c9c, 0x2c9c },
+ { 0x2c9e, 0x2c9e },
+ { 0x2ca0, 0x2ca0 },
+ { 0x2ca2, 0x2ca2 },
+ { 0x2ca4, 0x2ca4 },
+ { 0x2ca6, 0x2ca6 },
+ { 0x2ca8, 0x2ca8 },
+ { 0x2caa, 0x2caa },
+ { 0x2cac, 0x2cac },
+ { 0x2cae, 0x2cae },
+ { 0x2cb0, 0x2cb0 },
+ { 0x2cb2, 0x2cb2 },
+ { 0x2cb4, 0x2cb4 },
+ { 0x2cb6, 0x2cb6 },
+ { 0x2cb8, 0x2cb8 },
+ { 0x2cba, 0x2cba },
+ { 0x2cbc, 0x2cbc },
+ { 0x2cbe, 0x2cbe },
+ { 0x2cc0, 0x2cc0 },
+ { 0x2cc2, 0x2cc2 },
+ { 0x2cc4, 0x2cc4 },
+ { 0x2cc6, 0x2cc6 },
+ { 0x2cc8, 0x2cc8 },
+ { 0x2cca, 0x2cca },
+ { 0x2ccc, 0x2ccc },
+ { 0x2cce, 0x2cce },
+ { 0x2cd0, 0x2cd0 },
+ { 0x2cd2, 0x2cd2 },
+ { 0x2cd4, 0x2cd4 },
+ { 0x2cd6, 0x2cd6 },
+ { 0x2cd8, 0x2cd8 },
+ { 0x2cda, 0x2cda },
+ { 0x2cdc, 0x2cdc },
+ { 0x2cde, 0x2cde },
+ { 0x2ce0, 0x2ce0 },
+ { 0x2ce2, 0x2ce2 },
+ { 0x2ceb, 0x2ceb },
+ { 0x2ced, 0x2ced },
+ { 0x2cf2, 0x2cf2 },
+ { 0xa640, 0xa640 },
+ { 0xa642, 0xa642 },
+ { 0xa644, 0xa644 },
+ { 0xa646, 0xa646 },
+ { 0xa648, 0xa648 },
+ { 0xa64a, 0xa64a },
+ { 0xa64c, 0xa64c },
+ { 0xa64e, 0xa64e },
+ { 0xa650, 0xa650 },
+ { 0xa652, 0xa652 },
+ { 0xa654, 0xa654 },
+ { 0xa656, 0xa656 },
+ { 0xa658, 0xa658 },
+ { 0xa65a, 0xa65a },
+ { 0xa65c, 0xa65c },
+ { 0xa65e, 0xa65e },
+ { 0xa660, 0xa660 },
+ { 0xa662, 0xa662 },
+ { 0xa664, 0xa664 },
+ { 0xa666, 0xa666 },
+ { 0xa668, 0xa668 },
+ { 0xa66a, 0xa66a },
+ { 0xa66c, 0xa66c },
+ { 0xa680, 0xa680 },
+ { 0xa682, 0xa682 },
+ { 0xa684, 0xa684 },
+ { 0xa686, 0xa686 },
+ { 0xa688, 0xa688 },
+ { 0xa68a, 0xa68a },
+ { 0xa68c, 0xa68c },
+ { 0xa68e, 0xa68e },
+ { 0xa690, 0xa690 },
+ { 0xa692, 0xa692 },
+ { 0xa694, 0xa694 },
+ { 0xa696, 0xa696 },
+ { 0xa698, 0xa698 },
+ { 0xa69a, 0xa69a },
+ { 0xa722, 0xa722 },
+ { 0xa724, 0xa724 },
+ { 0xa726, 0xa726 },
+ { 0xa728, 0xa728 },
+ { 0xa72a, 0xa72a },
+ { 0xa72c, 0xa72c },
+ { 0xa72e, 0xa72e },
+ { 0xa732, 0xa732 },
+ { 0xa734, 0xa734 },
+ { 0xa736, 0xa736 },
+ { 0xa738, 0xa738 },
+ { 0xa73a, 0xa73a },
+ { 0xa73c, 0xa73c },
+ { 0xa73e, 0xa73e },
+ { 0xa740, 0xa740 },
+ { 0xa742, 0xa742 },
+ { 0xa744, 0xa744 },
+ { 0xa746, 0xa746 },
+ { 0xa748, 0xa748 },
+ { 0xa74a, 0xa74a },
+ { 0xa74c, 0xa74c },
+ { 0xa74e, 0xa74e },
+ { 0xa750, 0xa750 },
+ { 0xa752, 0xa752 },
+ { 0xa754, 0xa754 },
+ { 0xa756, 0xa756 },
+ { 0xa758, 0xa758 },
+ { 0xa75a, 0xa75a },
+ { 0xa75c, 0xa75c },
+ { 0xa75e, 0xa75e },
+ { 0xa760, 0xa760 },
+ { 0xa762, 0xa762 },
+ { 0xa764, 0xa764 },
+ { 0xa766, 0xa766 },
+ { 0xa768, 0xa768 },
+ { 0xa76a, 0xa76a },
+ { 0xa76c, 0xa76c },
+ { 0xa76e, 0xa76e },
+ { 0xa779, 0xa779 },
+ { 0xa77b, 0xa77b },
+ { 0xa77d, 0xa77e },
+ { 0xa780, 0xa780 },
+ { 0xa782, 0xa782 },
+ { 0xa784, 0xa784 },
+ { 0xa786, 0xa786 },
+ { 0xa78b, 0xa78b },
+ { 0xa78d, 0xa78d },
+ { 0xa790, 0xa790 },
+ { 0xa792, 0xa792 },
+ { 0xa796, 0xa796 },
+ { 0xa798, 0xa798 },
+ { 0xa79a, 0xa79a },
+ { 0xa79c, 0xa79c },
+ { 0xa79e, 0xa79e },
+ { 0xa7a0, 0xa7a0 },
+ { 0xa7a2, 0xa7a2 },
+ { 0xa7a4, 0xa7a4 },
+ { 0xa7a6, 0xa7a6 },
+ { 0xa7a8, 0xa7a8 },
+ { 0xa7aa, 0xa7ae },
+ { 0xa7b0, 0xa7b4 },
+ { 0xa7b6, 0xa7b6 },
+ { 0xa7b8, 0xa7b8 },
+ { 0xa7ba, 0xa7ba },
+ { 0xa7bc, 0xa7bc },
+ { 0xa7be, 0xa7be },
+ { 0xa7c0, 0xa7c0 },
+ { 0xa7c2, 0xa7c2 },
+ { 0xa7c4, 0xa7c7 },
+ { 0xa7c9, 0xa7c9 },
+ { 0xa7cb, 0xa7cc },
+ { 0xa7ce, 0xa7ce },
+ { 0xa7d0, 0xa7d0 },
+ { 0xa7d2, 0xa7d2 },
+ { 0xa7d4, 0xa7d4 },
+ { 0xa7d6, 0xa7d6 },
+ { 0xa7d8, 0xa7d8 },
+ { 0xa7da, 0xa7da },
+ { 0xa7dc, 0xa7dc },
+ { 0xa7f5, 0xa7f5 },
+ { 0xff21, 0xff3a },
+ { 0x10400, 0x10427 },
+ { 0x104b0, 0x104d3 },
+ { 0x10570, 0x1057a },
+ { 0x1057c, 0x1058a },
+ { 0x1058c, 0x10592 },
+ { 0x10594, 0x10595 },
+ { 0x10c80, 0x10cb2 },
+ { 0x10d50, 0x10d65 },
+ { 0x118a0, 0x118bf },
+ { 0x16e40, 0x16e5f },
+ { 0x16ea0, 0x16eb8 },
+ { 0x1d400, 0x1d419 },
+ { 0x1d434, 0x1d44d },
+ { 0x1d468, 0x1d481 },
+ { 0x1d49c, 0x1d49c },
+ { 0x1d49e, 0x1d49f },
+ { 0x1d4a2, 0x1d4a2 },
+ { 0x1d4a5, 0x1d4a6 },
+ { 0x1d4a9, 0x1d4ac },
+ { 0x1d4ae, 0x1d4b5 },
+ { 0x1d4d0, 0x1d4e9 },
+ { 0x1d504, 0x1d505 },
+ { 0x1d507, 0x1d50a },
+ { 0x1d50d, 0x1d514 },
+ { 0x1d516, 0x1d51c },
+ { 0x1d538, 0x1d539 },
+ { 0x1d53b, 0x1d53e },
+ { 0x1d540, 0x1d544 },
+ { 0x1d546, 0x1d546 },
+ { 0x1d54a, 0x1d550 },
+ { 0x1d56c, 0x1d585 },
+ { 0x1d5a0, 0x1d5b9 },
+ { 0x1d5d4, 0x1d5ed },
+ { 0x1d608, 0x1d621 },
+ { 0x1d63c, 0x1d655 },
+ { 0x1d670, 0x1d689 },
+ { 0x1d6a8, 0x1d6c0 },
+ { 0x1d6e2, 0x1d6fa },
+ { 0x1d71c, 0x1d734 },
+ { 0x1d756, 0x1d76e },
+ { 0x1d790, 0x1d7a8 },
+ { 0x1d7ca, 0x1d7ca },
+ { 0x1e900, 0x1e921 },
+ { 0x1f130, 0x1f149 },
+ { 0x1f150, 0x1f169 },
+ { 0x1f170, 0x1f189 },
+};
+static const int lower[][2] = {
+ { 0x61, 0x7a },
+ { 0xaa, 0xaa },
+ { 0xb5, 0xb5 },
+ { 0xba, 0xba },
+ { 0xdf, 0xf6 },
+ { 0xf8, 0xff },
+ { 0x101, 0x101 },
+ { 0x103, 0x103 },
+ { 0x105, 0x105 },
+ { 0x107, 0x107 },
+ { 0x109, 0x109 },
+ { 0x10b, 0x10b },
+ { 0x10d, 0x10d },
+ { 0x10f, 0x10f },
+ { 0x111, 0x111 },
+ { 0x113, 0x113 },
+ { 0x115, 0x115 },
+ { 0x117, 0x117 },
+ { 0x119, 0x119 },
+ { 0x11b, 0x11b },
+ { 0x11d, 0x11d },
+ { 0x11f, 0x11f },
+ { 0x121, 0x121 },
+ { 0x123, 0x123 },
+ { 0x125, 0x125 },
+ { 0x127, 0x127 },
+ { 0x129, 0x129 },
+ { 0x12b, 0x12b },
+ { 0x12d, 0x12d },
+ { 0x12f, 0x12f },
+ { 0x131, 0x131 },
+ { 0x133, 0x133 },
+ { 0x135, 0x135 },
+ { 0x137, 0x138 },
+ { 0x13a, 0x13a },
+ { 0x13c, 0x13c },
+ { 0x13e, 0x13e },
+ { 0x140, 0x140 },
+ { 0x142, 0x142 },
+ { 0x144, 0x144 },
+ { 0x146, 0x146 },
+ { 0x148, 0x149 },
+ { 0x14b, 0x14b },
+ { 0x14d, 0x14d },
+ { 0x14f, 0x14f },
+ { 0x151, 0x151 },
+ { 0x153, 0x153 },
+ { 0x155, 0x155 },
+ { 0x157, 0x157 },
+ { 0x159, 0x159 },
+ { 0x15b, 0x15b },
+ { 0x15d, 0x15d },
+ { 0x15f, 0x15f },
+ { 0x161, 0x161 },
+ { 0x163, 0x163 },
+ { 0x165, 0x165 },
+ { 0x167, 0x167 },
+ { 0x169, 0x169 },
+ { 0x16b, 0x16b },
+ { 0x16d, 0x16d },
+ { 0x16f, 0x16f },
+ { 0x171, 0x171 },
+ { 0x173, 0x173 },
+ { 0x175, 0x175 },
+ { 0x177, 0x177 },
+ { 0x17a, 0x17a },
+ { 0x17c, 0x17c },
+ { 0x17e, 0x180 },
+ { 0x183, 0x183 },
+ { 0x185, 0x185 },
+ { 0x188, 0x188 },
+ { 0x18c, 0x18d },
+ { 0x192, 0x192 },
+ { 0x195, 0x195 },
+ { 0x199, 0x19b },
+ { 0x19e, 0x19e },
+ { 0x1a1, 0x1a1 },
+ { 0x1a3, 0x1a3 },
+ { 0x1a5, 0x1a5 },
+ { 0x1a8, 0x1a8 },
+ { 0x1aa, 0x1ab },
+ { 0x1ad, 0x1ad },
+ { 0x1b0, 0x1b0 },
+ { 0x1b4, 0x1b4 },
+ { 0x1b6, 0x1b6 },
+ { 0x1b9, 0x1ba },
+ { 0x1bd, 0x1bf },
+ { 0x1c6, 0x1c6 },
+ { 0x1c9, 0x1c9 },
+ { 0x1cc, 0x1cc },
+ { 0x1ce, 0x1ce },
+ { 0x1d0, 0x1d0 },
+ { 0x1d2, 0x1d2 },
+ { 0x1d4, 0x1d4 },
+ { 0x1d6, 0x1d6 },
+ { 0x1d8, 0x1d8 },
+ { 0x1da, 0x1da },
+ { 0x1dc, 0x1dd },
+ { 0x1df, 0x1df },
+ { 0x1e1, 0x1e1 },
+ { 0x1e3, 0x1e3 },
+ { 0x1e5, 0x1e5 },
+ { 0x1e7, 0x1e7 },
+ { 0x1e9, 0x1e9 },
+ { 0x1eb, 0x1eb },
+ { 0x1ed, 0x1ed },
+ { 0x1ef, 0x1f0 },
+ { 0x1f3, 0x1f3 },
+ { 0x1f5, 0x1f5 },
+ { 0x1f9, 0x1f9 },
+ { 0x1fb, 0x1fb },
+ { 0x1fd, 0x1fd },
+ { 0x1ff, 0x1ff },
+ { 0x201, 0x201 },
+ { 0x203, 0x203 },
+ { 0x205, 0x205 },
+ { 0x207, 0x207 },
+ { 0x209, 0x209 },
+ { 0x20b, 0x20b },
+ { 0x20d, 0x20d },
+ { 0x20f, 0x20f },
+ { 0x211, 0x211 },
+ { 0x213, 0x213 },
+ { 0x215, 0x215 },
+ { 0x217, 0x217 },
+ { 0x219, 0x219 },
+ { 0x21b, 0x21b },
+ { 0x21d, 0x21d },
+ { 0x21f, 0x21f },
+ { 0x221, 0x221 },
+ { 0x223, 0x223 },
+ { 0x225, 0x225 },
+ { 0x227, 0x227 },
+ { 0x229, 0x229 },
+ { 0x22b, 0x22b },
+ { 0x22d, 0x22d },
+ { 0x22f, 0x22f },
+ { 0x231, 0x231 },
+ { 0x233, 0x239 },
+ { 0x23c, 0x23c },
+ { 0x23f, 0x240 },
+ { 0x242, 0x242 },
+ { 0x247, 0x247 },
+ { 0x249, 0x249 },
+ { 0x24b, 0x24b },
+ { 0x24d, 0x24d },
+ { 0x24f, 0x293 },
+ { 0x296, 0x2b8 },
+ { 0x2c0, 0x2c1 },
+ { 0x2e0, 0x2e4 },
+ { 0x345, 0x345 },
+ { 0x371, 0x371 },
+ { 0x373, 0x373 },
+ { 0x377, 0x377 },
+ { 0x37a, 0x37d },
+ { 0x390, 0x390 },
+ { 0x3ac, 0x3ce },
+ { 0x3d0, 0x3d1 },
+ { 0x3d5, 0x3d7 },
+ { 0x3d9, 0x3d9 },
+ { 0x3db, 0x3db },
+ { 0x3dd, 0x3dd },
+ { 0x3df, 0x3df },
+ { 0x3e1, 0x3e1 },
+ { 0x3e3, 0x3e3 },
+ { 0x3e5, 0x3e5 },
+ { 0x3e7, 0x3e7 },
+ { 0x3e9, 0x3e9 },
+ { 0x3eb, 0x3eb },
+ { 0x3ed, 0x3ed },
+ { 0x3ef, 0x3f3 },
+ { 0x3f5, 0x3f5 },
+ { 0x3f8, 0x3f8 },
+ { 0x3fb, 0x3fc },
+ { 0x430, 0x45f },
+ { 0x461, 0x461 },
+ { 0x463, 0x463 },
+ { 0x465, 0x465 },
+ { 0x467, 0x467 },
+ { 0x469, 0x469 },
+ { 0x46b, 0x46b },
+ { 0x46d, 0x46d },
+ { 0x46f, 0x46f },
+ { 0x471, 0x471 },
+ { 0x473, 0x473 },
+ { 0x475, 0x475 },
+ { 0x477, 0x477 },
+ { 0x479, 0x479 },
+ { 0x47b, 0x47b },
+ { 0x47d, 0x47d },
+ { 0x47f, 0x47f },
+ { 0x481, 0x481 },
+ { 0x48b, 0x48b },
+ { 0x48d, 0x48d },
+ { 0x48f, 0x48f },
+ { 0x491, 0x491 },
+ { 0x493, 0x493 },
+ { 0x495, 0x495 },
+ { 0x497, 0x497 },
+ { 0x499, 0x499 },
+ { 0x49b, 0x49b },
+ { 0x49d, 0x49d },
+ { 0x49f, 0x49f },
+ { 0x4a1, 0x4a1 },
+ { 0x4a3, 0x4a3 },
+ { 0x4a5, 0x4a5 },
+ { 0x4a7, 0x4a7 },
+ { 0x4a9, 0x4a9 },
+ { 0x4ab, 0x4ab },
+ { 0x4ad, 0x4ad },
+ { 0x4af, 0x4af },
+ { 0x4b1, 0x4b1 },
+ { 0x4b3, 0x4b3 },
+ { 0x4b5, 0x4b5 },
+ { 0x4b7, 0x4b7 },
+ { 0x4b9, 0x4b9 },
+ { 0x4bb, 0x4bb },
+ { 0x4bd, 0x4bd },
+ { 0x4bf, 0x4bf },
+ { 0x4c2, 0x4c2 },
+ { 0x4c4, 0x4c4 },
+ { 0x4c6, 0x4c6 },
+ { 0x4c8, 0x4c8 },
+ { 0x4ca, 0x4ca },
+ { 0x4cc, 0x4cc },
+ { 0x4ce, 0x4cf },
+ { 0x4d1, 0x4d1 },
+ { 0x4d3, 0x4d3 },
+ { 0x4d5, 0x4d5 },
+ { 0x4d7, 0x4d7 },
+ { 0x4d9, 0x4d9 },
+ { 0x4db, 0x4db },
+ { 0x4dd, 0x4dd },
+ { 0x4df, 0x4df },
+ { 0x4e1, 0x4e1 },
+ { 0x4e3, 0x4e3 },
+ { 0x4e5, 0x4e5 },
+ { 0x4e7, 0x4e7 },
+ { 0x4e9, 0x4e9 },
+ { 0x4eb, 0x4eb },
+ { 0x4ed, 0x4ed },
+ { 0x4ef, 0x4ef },
+ { 0x4f1, 0x4f1 },
+ { 0x4f3, 0x4f3 },
+ { 0x4f5, 0x4f5 },
+ { 0x4f7, 0x4f7 },
+ { 0x4f9, 0x4f9 },
+ { 0x4fb, 0x4fb },
+ { 0x4fd, 0x4fd },
+ { 0x4ff, 0x4ff },
+ { 0x501, 0x501 },
+ { 0x503, 0x503 },
+ { 0x505, 0x505 },
+ { 0x507, 0x507 },
+ { 0x509, 0x509 },
+ { 0x50b, 0x50b },
+ { 0x50d, 0x50d },
+ { 0x50f, 0x50f },
+ { 0x511, 0x511 },
+ { 0x513, 0x513 },
+ { 0x515, 0x515 },
+ { 0x517, 0x517 },
+ { 0x519, 0x519 },
+ { 0x51b, 0x51b },
+ { 0x51d, 0x51d },
+ { 0x51f, 0x51f },
+ { 0x521, 0x521 },
+ { 0x523, 0x523 },
+ { 0x525, 0x525 },
+ { 0x527, 0x527 },
+ { 0x529, 0x529 },
+ { 0x52b, 0x52b },
+ { 0x52d, 0x52d },
+ { 0x52f, 0x52f },
+ { 0x560, 0x588 },
+ { 0x10d0, 0x10fa },
+ { 0x10fc, 0x10ff },
+ { 0x13f8, 0x13fd },
+ { 0x1c80, 0x1c88 },
+ { 0x1c8a, 0x1c8a },
+ { 0x1d00, 0x1dbf },
+ { 0x1e01, 0x1e01 },
+ { 0x1e03, 0x1e03 },
+ { 0x1e05, 0x1e05 },
+ { 0x1e07, 0x1e07 },
+ { 0x1e09, 0x1e09 },
+ { 0x1e0b, 0x1e0b },
+ { 0x1e0d, 0x1e0d },
+ { 0x1e0f, 0x1e0f },
+ { 0x1e11, 0x1e11 },
+ { 0x1e13, 0x1e13 },
+ { 0x1e15, 0x1e15 },
+ { 0x1e17, 0x1e17 },
+ { 0x1e19, 0x1e19 },
+ { 0x1e1b, 0x1e1b },
+ { 0x1e1d, 0x1e1d },
+ { 0x1e1f, 0x1e1f },
+ { 0x1e21, 0x1e21 },
+ { 0x1e23, 0x1e23 },
+ { 0x1e25, 0x1e25 },
+ { 0x1e27, 0x1e27 },
+ { 0x1e29, 0x1e29 },
+ { 0x1e2b, 0x1e2b },
+ { 0x1e2d, 0x1e2d },
+ { 0x1e2f, 0x1e2f },
+ { 0x1e31, 0x1e31 },
+ { 0x1e33, 0x1e33 },
+ { 0x1e35, 0x1e35 },
+ { 0x1e37, 0x1e37 },
+ { 0x1e39, 0x1e39 },
+ { 0x1e3b, 0x1e3b },
+ { 0x1e3d, 0x1e3d },
+ { 0x1e3f, 0x1e3f },
+ { 0x1e41, 0x1e41 },
+ { 0x1e43, 0x1e43 },
+ { 0x1e45, 0x1e45 },
+ { 0x1e47, 0x1e47 },
+ { 0x1e49, 0x1e49 },
+ { 0x1e4b, 0x1e4b },
+ { 0x1e4d, 0x1e4d },
+ { 0x1e4f, 0x1e4f },
+ { 0x1e51, 0x1e51 },
+ { 0x1e53, 0x1e53 },
+ { 0x1e55, 0x1e55 },
+ { 0x1e57, 0x1e57 },
+ { 0x1e59, 0x1e59 },
+ { 0x1e5b, 0x1e5b },
+ { 0x1e5d, 0x1e5d },
+ { 0x1e5f, 0x1e5f },
+ { 0x1e61, 0x1e61 },
+ { 0x1e63, 0x1e63 },
+ { 0x1e65, 0x1e65 },
+ { 0x1e67, 0x1e67 },
+ { 0x1e69, 0x1e69 },
+ { 0x1e6b, 0x1e6b },
+ { 0x1e6d, 0x1e6d },
+ { 0x1e6f, 0x1e6f },
+ { 0x1e71, 0x1e71 },
+ { 0x1e73, 0x1e73 },
+ { 0x1e75, 0x1e75 },
+ { 0x1e77, 0x1e77 },
+ { 0x1e79, 0x1e79 },
+ { 0x1e7b, 0x1e7b },
+ { 0x1e7d, 0x1e7d },
+ { 0x1e7f, 0x1e7f },
+ { 0x1e81, 0x1e81 },
+ { 0x1e83, 0x1e83 },
+ { 0x1e85, 0x1e85 },
+ { 0x1e87, 0x1e87 },
+ { 0x1e89, 0x1e89 },
+ { 0x1e8b, 0x1e8b },
+ { 0x1e8d, 0x1e8d },
+ { 0x1e8f, 0x1e8f },
+ { 0x1e91, 0x1e91 },
+ { 0x1e93, 0x1e93 },
+ { 0x1e95, 0x1e9d },
+ { 0x1e9f, 0x1e9f },
+ { 0x1ea1, 0x1ea1 },
+ { 0x1ea3, 0x1ea3 },
+ { 0x1ea5, 0x1ea5 },
+ { 0x1ea7, 0x1ea7 },
+ { 0x1ea9, 0x1ea9 },
+ { 0x1eab, 0x1eab },
+ { 0x1ead, 0x1ead },
+ { 0x1eaf, 0x1eaf },
+ { 0x1eb1, 0x1eb1 },
+ { 0x1eb3, 0x1eb3 },
+ { 0x1eb5, 0x1eb5 },
+ { 0x1eb7, 0x1eb7 },
+ { 0x1eb9, 0x1eb9 },
+ { 0x1ebb, 0x1ebb },
+ { 0x1ebd, 0x1ebd },
+ { 0x1ebf, 0x1ebf },
+ { 0x1ec1, 0x1ec1 },
+ { 0x1ec3, 0x1ec3 },
+ { 0x1ec5, 0x1ec5 },
+ { 0x1ec7, 0x1ec7 },
+ { 0x1ec9, 0x1ec9 },
+ { 0x1ecb, 0x1ecb },
+ { 0x1ecd, 0x1ecd },
+ { 0x1ecf, 0x1ecf },
+ { 0x1ed1, 0x1ed1 },
+ { 0x1ed3, 0x1ed3 },
+ { 0x1ed5, 0x1ed5 },
+ { 0x1ed7, 0x1ed7 },
+ { 0x1ed9, 0x1ed9 },
+ { 0x1edb, 0x1edb },
+ { 0x1edd, 0x1edd },
+ { 0x1edf, 0x1edf },
+ { 0x1ee1, 0x1ee1 },
+ { 0x1ee3, 0x1ee3 },
+ { 0x1ee5, 0x1ee5 },
+ { 0x1ee7, 0x1ee7 },
+ { 0x1ee9, 0x1ee9 },
+ { 0x1eeb, 0x1eeb },
+ { 0x1eed, 0x1eed },
+ { 0x1eef, 0x1eef },
+ { 0x1ef1, 0x1ef1 },
+ { 0x1ef3, 0x1ef3 },
+ { 0x1ef5, 0x1ef5 },
+ { 0x1ef7, 0x1ef7 },
+ { 0x1ef9, 0x1ef9 },
+ { 0x1efb, 0x1efb },
+ { 0x1efd, 0x1efd },
+ { 0x1eff, 0x1f07 },
+ { 0x1f10, 0x1f15 },
+ { 0x1f20, 0x1f27 },
+ { 0x1f30, 0x1f37 },
+ { 0x1f40, 0x1f45 },
+ { 0x1f50, 0x1f57 },
+ { 0x1f60, 0x1f67 },
+ { 0x1f70, 0x1f7d },
+ { 0x1f80, 0x1f87 },
+ { 0x1f90, 0x1f97 },
+ { 0x1fa0, 0x1fa7 },
+ { 0x1fb0, 0x1fb4 },
+ { 0x1fb6, 0x1fb7 },
+ { 0x1fbe, 0x1fbe },
+ { 0x1fc2, 0x1fc4 },
+ { 0x1fc6, 0x1fc7 },
+ { 0x1fd0, 0x1fd3 },
+ { 0x1fd6, 0x1fd7 },
+ { 0x1fe0, 0x1fe7 },
+ { 0x1ff2, 0x1ff4 },
+ { 0x1ff6, 0x1ff7 },
+ { 0x2071, 0x2071 },
+ { 0x207f, 0x207f },
+ { 0x2090, 0x209c },
+ { 0x210a, 0x210a },
+ { 0x210e, 0x210f },
+ { 0x2113, 0x2113 },
+ { 0x212f, 0x212f },
+ { 0x2134, 0x2134 },
+ { 0x2139, 0x2139 },
+ { 0x213c, 0x213d },
+ { 0x2146, 0x2149 },
+ { 0x214e, 0x214e },
+ { 0x2170, 0x217f },
+ { 0x2184, 0x2184 },
+ { 0x24d0, 0x24e9 },
+ { 0x2c30, 0x2c5f },
+ { 0x2c61, 0x2c61 },
+ { 0x2c65, 0x2c66 },
+ { 0x2c68, 0x2c68 },
+ { 0x2c6a, 0x2c6a },
+ { 0x2c6c, 0x2c6c },
+ { 0x2c71, 0x2c71 },
+ { 0x2c73, 0x2c74 },
+ { 0x2c76, 0x2c7d },
+ { 0x2c81, 0x2c81 },
+ { 0x2c83, 0x2c83 },
+ { 0x2c85, 0x2c85 },
+ { 0x2c87, 0x2c87 },
+ { 0x2c89, 0x2c89 },
+ { 0x2c8b, 0x2c8b },
+ { 0x2c8d, 0x2c8d },
+ { 0x2c8f, 0x2c8f },
+ { 0x2c91, 0x2c91 },
+ { 0x2c93, 0x2c93 },
+ { 0x2c95, 0x2c95 },
+ { 0x2c97, 0x2c97 },
+ { 0x2c99, 0x2c99 },
+ { 0x2c9b, 0x2c9b },
+ { 0x2c9d, 0x2c9d },
+ { 0x2c9f, 0x2c9f },
+ { 0x2ca1, 0x2ca1 },
+ { 0x2ca3, 0x2ca3 },
+ { 0x2ca5, 0x2ca5 },
+ { 0x2ca7, 0x2ca7 },
+ { 0x2ca9, 0x2ca9 },
+ { 0x2cab, 0x2cab },
+ { 0x2cad, 0x2cad },
+ { 0x2caf, 0x2caf },
+ { 0x2cb1, 0x2cb1 },
+ { 0x2cb3, 0x2cb3 },
+ { 0x2cb5, 0x2cb5 },
+ { 0x2cb7, 0x2cb7 },
+ { 0x2cb9, 0x2cb9 },
+ { 0x2cbb, 0x2cbb },
+ { 0x2cbd, 0x2cbd },
+ { 0x2cbf, 0x2cbf },
+ { 0x2cc1, 0x2cc1 },
+ { 0x2cc3, 0x2cc3 },
+ { 0x2cc5, 0x2cc5 },
+ { 0x2cc7, 0x2cc7 },
+ { 0x2cc9, 0x2cc9 },
+ { 0x2ccb, 0x2ccb },
+ { 0x2ccd, 0x2ccd },
+ { 0x2ccf, 0x2ccf },
+ { 0x2cd1, 0x2cd1 },
+ { 0x2cd3, 0x2cd3 },
+ { 0x2cd5, 0x2cd5 },
+ { 0x2cd7, 0x2cd7 },
+ { 0x2cd9, 0x2cd9 },
+ { 0x2cdb, 0x2cdb },
+ { 0x2cdd, 0x2cdd },
+ { 0x2cdf, 0x2cdf },
+ { 0x2ce1, 0x2ce1 },
+ { 0x2ce3, 0x2ce4 },
+ { 0x2cec, 0x2cec },
+ { 0x2cee, 0x2cee },
+ { 0x2cf3, 0x2cf3 },
+ { 0x2d00, 0x2d25 },
+ { 0x2d27, 0x2d27 },
+ { 0x2d2d, 0x2d2d },
+ { 0xa641, 0xa641 },
+ { 0xa643, 0xa643 },
+ { 0xa645, 0xa645 },
+ { 0xa647, 0xa647 },
+ { 0xa649, 0xa649 },
+ { 0xa64b, 0xa64b },
+ { 0xa64d, 0xa64d },
+ { 0xa64f, 0xa64f },
+ { 0xa651, 0xa651 },
+ { 0xa653, 0xa653 },
+ { 0xa655, 0xa655 },
+ { 0xa657, 0xa657 },
+ { 0xa659, 0xa659 },
+ { 0xa65b, 0xa65b },
+ { 0xa65d, 0xa65d },
+ { 0xa65f, 0xa65f },
+ { 0xa661, 0xa661 },
+ { 0xa663, 0xa663 },
+ { 0xa665, 0xa665 },
+ { 0xa667, 0xa667 },
+ { 0xa669, 0xa669 },
+ { 0xa66b, 0xa66b },
+ { 0xa66d, 0xa66d },
+ { 0xa681, 0xa681 },
+ { 0xa683, 0xa683 },
+ { 0xa685, 0xa685 },
+ { 0xa687, 0xa687 },
+ { 0xa689, 0xa689 },
+ { 0xa68b, 0xa68b },
+ { 0xa68d, 0xa68d },
+ { 0xa68f, 0xa68f },
+ { 0xa691, 0xa691 },
+ { 0xa693, 0xa693 },
+ { 0xa695, 0xa695 },
+ { 0xa697, 0xa697 },
+ { 0xa699, 0xa699 },
+ { 0xa69b, 0xa69d },
+ { 0xa723, 0xa723 },
+ { 0xa725, 0xa725 },
+ { 0xa727, 0xa727 },
+ { 0xa729, 0xa729 },
+ { 0xa72b, 0xa72b },
+ { 0xa72d, 0xa72d },
+ { 0xa72f, 0xa731 },
+ { 0xa733, 0xa733 },
+ { 0xa735, 0xa735 },
+ { 0xa737, 0xa737 },
+ { 0xa739, 0xa739 },
+ { 0xa73b, 0xa73b },
+ { 0xa73d, 0xa73d },
+ { 0xa73f, 0xa73f },
+ { 0xa741, 0xa741 },
+ { 0xa743, 0xa743 },
+ { 0xa745, 0xa745 },
+ { 0xa747, 0xa747 },
+ { 0xa749, 0xa749 },
+ { 0xa74b, 0xa74b },
+ { 0xa74d, 0xa74d },
+ { 0xa74f, 0xa74f },
+ { 0xa751, 0xa751 },
+ { 0xa753, 0xa753 },
+ { 0xa755, 0xa755 },
+ { 0xa757, 0xa757 },
+ { 0xa759, 0xa759 },
+ { 0xa75b, 0xa75b },
+ { 0xa75d, 0xa75d },
+ { 0xa75f, 0xa75f },
+ { 0xa761, 0xa761 },
+ { 0xa763, 0xa763 },
+ { 0xa765, 0xa765 },
+ { 0xa767, 0xa767 },
+ { 0xa769, 0xa769 },
+ { 0xa76b, 0xa76b },
+ { 0xa76d, 0xa76d },
+ { 0xa76f, 0xa778 },
+ { 0xa77a, 0xa77a },
+ { 0xa77c, 0xa77c },
+ { 0xa77f, 0xa77f },
+ { 0xa781, 0xa781 },
+ { 0xa783, 0xa783 },
+ { 0xa785, 0xa785 },
+ { 0xa787, 0xa787 },
+ { 0xa78c, 0xa78c },
+ { 0xa78e, 0xa78e },
+ { 0xa791, 0xa791 },
+ { 0xa793, 0xa795 },
+ { 0xa797, 0xa797 },
+ { 0xa799, 0xa799 },
+ { 0xa79b, 0xa79b },
+ { 0xa79d, 0xa79d },
+ { 0xa79f, 0xa79f },
+ { 0xa7a1, 0xa7a1 },
+ { 0xa7a3, 0xa7a3 },
+ { 0xa7a5, 0xa7a5 },
+ { 0xa7a7, 0xa7a7 },
+ { 0xa7a9, 0xa7a9 },
+ { 0xa7af, 0xa7af },
+ { 0xa7b5, 0xa7b5 },
+ { 0xa7b7, 0xa7b7 },
+ { 0xa7b9, 0xa7b9 },
+ { 0xa7bb, 0xa7bb },
+ { 0xa7bd, 0xa7bd },
+ { 0xa7bf, 0xa7bf },
+ { 0xa7c1, 0xa7c1 },
+ { 0xa7c3, 0xa7c3 },
+ { 0xa7c8, 0xa7c8 },
+ { 0xa7ca, 0xa7ca },
+ { 0xa7cd, 0xa7cd },
+ { 0xa7cf, 0xa7cf },
+ { 0xa7d1, 0xa7d1 },
+ { 0xa7d3, 0xa7d3 },
+ { 0xa7d5, 0xa7d5 },
+ { 0xa7d7, 0xa7d7 },
+ { 0xa7d9, 0xa7d9 },
+ { 0xa7db, 0xa7db },
+ { 0xa7f1, 0xa7f4 },
+ { 0xa7f6, 0xa7f6 },
+ { 0xa7f8, 0xa7fa },
+ { 0xab30, 0xab5a },
+ { 0xab5c, 0xab69 },
+ { 0xab70, 0xabbf },
+ { 0xfb00, 0xfb06 },
+ { 0xfb13, 0xfb17 },
+ { 0xff41, 0xff5a },
+ { 0x10428, 0x1044f },
+ { 0x104d8, 0x104fb },
+ { 0x10597, 0x105a1 },
+ { 0x105a3, 0x105b1 },
+ { 0x105b3, 0x105b9 },
+ { 0x105bb, 0x105bc },
+ { 0x10780, 0x10780 },
+ { 0x10783, 0x10785 },
+ { 0x10787, 0x107b0 },
+ { 0x107b2, 0x107ba },
+ { 0x10cc0, 0x10cf2 },
+ { 0x10d70, 0x10d85 },
+ { 0x118c0, 0x118df },
+ { 0x16e60, 0x16e7f },
+ { 0x16ebb, 0x16ed3 },
+ { 0x1d41a, 0x1d433 },
+ { 0x1d44e, 0x1d454 },
+ { 0x1d456, 0x1d467 },
+ { 0x1d482, 0x1d49b },
+ { 0x1d4b6, 0x1d4b9 },
+ { 0x1d4bb, 0x1d4bb },
+ { 0x1d4bd, 0x1d4c3 },
+ { 0x1d4c5, 0x1d4cf },
+ { 0x1d4ea, 0x1d503 },
+ { 0x1d51e, 0x1d537 },
+ { 0x1d552, 0x1d56b },
+ { 0x1d586, 0x1d59f },
+ { 0x1d5ba, 0x1d5d3 },
+ { 0x1d5ee, 0x1d607 },
+ { 0x1d622, 0x1d63b },
+ { 0x1d656, 0x1d66f },
+ { 0x1d68a, 0x1d6a5 },
+ { 0x1d6c2, 0x1d6da },
+ { 0x1d6dc, 0x1d6e1 },
+ { 0x1d6fc, 0x1d714 },
+ { 0x1d716, 0x1d71b },
+ { 0x1d736, 0x1d74e },
+ { 0x1d750, 0x1d755 },
+ { 0x1d770, 0x1d788 },
+ { 0x1d78a, 0x1d78f },
+ { 0x1d7aa, 0x1d7c2 },
+ { 0x1d7c4, 0x1d7c9 },
+ { 0x1d7cb, 0x1d7cb },
+ { 0x1df00, 0x1df09 },
+ { 0x1df0b, 0x1df1e },
+ { 0x1df25, 0x1df2a },
+ { 0x1e030, 0x1e06d },
+ { 0x1e922, 0x1e943 },
+};
+static const int space[][2] = {
+ { 0x9, 0xd },
+ { 0x20, 0x20 },
+ { 0x85, 0x85 },
+ { 0xa0, 0xa0 },
+ { 0x1680, 0x1680 },
+ { 0x2000, 0x200a },
+ { 0x2028, 0x2029 },
+ { 0x202f, 0x202f },
+ { 0x205f, 0x205f },
+ { 0x3000, 0x3000 },
+};
+static const int digit[][2] = {
+ { 0x30, 0x39 },
+ { 0x660, 0x669 },
+ { 0x6f0, 0x6f9 },
+ { 0x7c0, 0x7c9 },
+ { 0x966, 0x96f },
+ { 0x9e6, 0x9ef },
+ { 0xa66, 0xa6f },
+ { 0xae6, 0xaef },
+ { 0xb66, 0xb6f },
+ { 0xbe6, 0xbef },
+ { 0xc66, 0xc6f },
+ { 0xce6, 0xcef },
+ { 0xd66, 0xd6f },
+ { 0xde6, 0xdef },
+ { 0xe50, 0xe59 },
+ { 0xed0, 0xed9 },
+ { 0xf20, 0xf29 },
+ { 0x1040, 0x1049 },
+ { 0x1090, 0x1099 },
+ { 0x17e0, 0x17e9 },
+ { 0x1810, 0x1819 },
+ { 0x1946, 0x194f },
+ { 0x19d0, 0x19d9 },
+ { 0x1a80, 0x1a89 },
+ { 0x1a90, 0x1a99 },
+ { 0x1b50, 0x1b59 },
+ { 0x1bb0, 0x1bb9 },
+ { 0x1c40, 0x1c49 },
+ { 0x1c50, 0x1c59 },
+ { 0xa620, 0xa629 },
+ { 0xa8d0, 0xa8d9 },
+ { 0xa900, 0xa909 },
+ { 0xa9d0, 0xa9d9 },
+ { 0xa9f0, 0xa9f9 },
+ { 0xaa50, 0xaa59 },
+ { 0xabf0, 0xabf9 },
+ { 0xff10, 0xff19 },
+ { 0x104a0, 0x104a9 },
+ { 0x10d30, 0x10d39 },
+ { 0x10d40, 0x10d49 },
+ { 0x11066, 0x1106f },
+ { 0x110f0, 0x110f9 },
+ { 0x11136, 0x1113f },
+ { 0x111d0, 0x111d9 },
+ { 0x112f0, 0x112f9 },
+ { 0x11450, 0x11459 },
+ { 0x114d0, 0x114d9 },
+ { 0x11650, 0x11659 },
+ { 0x116c0, 0x116c9 },
+ { 0x116d0, 0x116d9 },
+ { 0x116da, 0x116e3 },
+ { 0x11730, 0x11739 },
+ { 0x118e0, 0x118e9 },
+ { 0x11950, 0x11959 },
+ { 0x11bf0, 0x11bf9 },
+ { 0x11c50, 0x11c59 },
+ { 0x11d50, 0x11d59 },
+ { 0x11da0, 0x11da9 },
+ { 0x11de0, 0x11de9 },
+ { 0x11f50, 0x11f59 },
+ { 0x16130, 0x16139 },
+ { 0x16a60, 0x16a69 },
+ { 0x16ac0, 0x16ac9 },
+ { 0x16b50, 0x16b59 },
+ { 0x16d70, 0x16d79 },
+ { 0x1ccf0, 0x1ccf9 },
+ { 0x1d7ce, 0x1d7d7 },
+ { 0x1d7d8, 0x1d7e1 },
+ { 0x1d7e2, 0x1d7eb },
+ { 0x1d7ec, 0x1d7f5 },
+ { 0x1d7f6, 0x1d7ff },
+ { 0x1e140, 0x1e149 },
+ { 0x1e2f0, 0x1e2f9 },
+ { 0x1e4f0, 0x1e4f9 },
+ { 0x1e5f1, 0x1e5fa },
+ { 0x1e950, 0x1e959 },
+ { 0x1fbf0, 0x1fbf9 },
+};
+static const int lowermap[][3] = {
+ { 0x41, 0x5a, 0x61 },
+ { 0xc0, 0xd6, 0xe0 },
+ { 0xd8, 0xde, 0xf8 },
+ { 0x100, 0x100, 0x101 },
+ { 0x102, 0x102, 0x103 },
+ { 0x104, 0x104, 0x105 },
+ { 0x106, 0x106, 0x107 },
+ { 0x108, 0x108, 0x109 },
+ { 0x10a, 0x10a, 0x10b },
+ { 0x10c, 0x10c, 0x10d },
+ { 0x10e, 0x10e, 0x10f },
+ { 0x110, 0x110, 0x111 },
+ { 0x112, 0x112, 0x113 },
+ { 0x114, 0x114, 0x115 },
+ { 0x116, 0x116, 0x117 },
+ { 0x118, 0x118, 0x119 },
+ { 0x11a, 0x11a, 0x11b },
+ { 0x11c, 0x11c, 0x11d },
+ { 0x11e, 0x11e, 0x11f },
+ { 0x120, 0x120, 0x121 },
+ { 0x122, 0x122, 0x123 },
+ { 0x124, 0x124, 0x125 },
+ { 0x126, 0x126, 0x127 },
+ { 0x128, 0x128, 0x129 },
+ { 0x12a, 0x12a, 0x12b },
+ { 0x12c, 0x12c, 0x12d },
+ { 0x12e, 0x12e, 0x12f },
+ { 0x130, 0x130, 0x69 },
+ { 0x132, 0x132, 0x133 },
+ { 0x134, 0x134, 0x135 },
+ { 0x136, 0x136, 0x137 },
+ { 0x139, 0x139, 0x13a },
+ { 0x13b, 0x13b, 0x13c },
+ { 0x13d, 0x13d, 0x13e },
+ { 0x13f, 0x13f, 0x140 },
+ { 0x141, 0x141, 0x142 },
+ { 0x143, 0x143, 0x144 },
+ { 0x145, 0x145, 0x146 },
+ { 0x147, 0x147, 0x148 },
+ { 0x14a, 0x14a, 0x14b },
+ { 0x14c, 0x14c, 0x14d },
+ { 0x14e, 0x14e, 0x14f },
+ { 0x150, 0x150, 0x151 },
+ { 0x152, 0x152, 0x153 },
+ { 0x154, 0x154, 0x155 },
+ { 0x156, 0x156, 0x157 },
+ { 0x158, 0x158, 0x159 },
+ { 0x15a, 0x15a, 0x15b },
+ { 0x15c, 0x15c, 0x15d },
+ { 0x15e, 0x15e, 0x15f },
+ { 0x160, 0x160, 0x161 },
+ { 0x162, 0x162, 0x163 },
+ { 0x164, 0x164, 0x165 },
+ { 0x166, 0x166, 0x167 },
+ { 0x168, 0x168, 0x169 },
+ { 0x16a, 0x16a, 0x16b },
+ { 0x16c, 0x16c, 0x16d },
+ { 0x16e, 0x16e, 0x16f },
+ { 0x170, 0x170, 0x171 },
+ { 0x172, 0x172, 0x173 },
+ { 0x174, 0x174, 0x175 },
+ { 0x176, 0x176, 0x177 },
+ { 0x178, 0x178, 0xff },
+ { 0x179, 0x179, 0x17a },
+ { 0x17b, 0x17b, 0x17c },
+ { 0x17d, 0x17d, 0x17e },
+ { 0x181, 0x181, 0x253 },
+ { 0x182, 0x182, 0x183 },
+ { 0x184, 0x184, 0x185 },
+ { 0x186, 0x186, 0x254 },
+ { 0x187, 0x187, 0x188 },
+ { 0x189, 0x18a, 0x256 },
+ { 0x18b, 0x18b, 0x18c },
+ { 0x18e, 0x18e, 0x1dd },
+ { 0x18f, 0x18f, 0x259 },
+ { 0x190, 0x190, 0x25b },
+ { 0x191, 0x191, 0x192 },
+ { 0x193, 0x193, 0x260 },
+ { 0x194, 0x194, 0x263 },
+ { 0x196, 0x196, 0x269 },
+ { 0x197, 0x197, 0x268 },
+ { 0x198, 0x198, 0x199 },
+ { 0x19c, 0x19c, 0x26f },
+ { 0x19d, 0x19d, 0x272 },
+ { 0x19f, 0x19f, 0x275 },
+ { 0x1a0, 0x1a0, 0x1a1 },
+ { 0x1a2, 0x1a2, 0x1a3 },
+ { 0x1a4, 0x1a4, 0x1a5 },
+ { 0x1a6, 0x1a6, 0x280 },
+ { 0x1a7, 0x1a7, 0x1a8 },
+ { 0x1a9, 0x1a9, 0x283 },
+ { 0x1ac, 0x1ac, 0x1ad },
+ { 0x1ae, 0x1ae, 0x288 },
+ { 0x1af, 0x1af, 0x1b0 },
+ { 0x1b1, 0x1b2, 0x28a },
+ { 0x1b3, 0x1b3, 0x1b4 },
+ { 0x1b5, 0x1b5, 0x1b6 },
+ { 0x1b7, 0x1b7, 0x292 },
+ { 0x1b8, 0x1b8, 0x1b9 },
+ { 0x1bc, 0x1bc, 0x1bd },
+ { 0x1c4, 0x1c4, 0x1c6 },
+ { 0x1c5, 0x1c5, 0x1c6 },
+ { 0x1c7, 0x1c7, 0x1c9 },
+ { 0x1c8, 0x1c8, 0x1c9 },
+ { 0x1ca, 0x1ca, 0x1cc },
+ { 0x1cb, 0x1cb, 0x1cc },
+ { 0x1cd, 0x1cd, 0x1ce },
+ { 0x1cf, 0x1cf, 0x1d0 },
+ { 0x1d1, 0x1d1, 0x1d2 },
+ { 0x1d3, 0x1d3, 0x1d4 },
+ { 0x1d5, 0x1d5, 0x1d6 },
+ { 0x1d7, 0x1d7, 0x1d8 },
+ { 0x1d9, 0x1d9, 0x1da },
+ { 0x1db, 0x1db, 0x1dc },
+ { 0x1de, 0x1de, 0x1df },
+ { 0x1e0, 0x1e0, 0x1e1 },
+ { 0x1e2, 0x1e2, 0x1e3 },
+ { 0x1e4, 0x1e4, 0x1e5 },
+ { 0x1e6, 0x1e6, 0x1e7 },
+ { 0x1e8, 0x1e8, 0x1e9 },
+ { 0x1ea, 0x1ea, 0x1eb },
+ { 0x1ec, 0x1ec, 0x1ed },
+ { 0x1ee, 0x1ee, 0x1ef },
+ { 0x1f1, 0x1f1, 0x1f3 },
+ { 0x1f2, 0x1f2, 0x1f3 },
+ { 0x1f4, 0x1f4, 0x1f5 },
+ { 0x1f6, 0x1f6, 0x195 },
+ { 0x1f7, 0x1f7, 0x1bf },
+ { 0x1f8, 0x1f8, 0x1f9 },
+ { 0x1fa, 0x1fa, 0x1fb },
+ { 0x1fc, 0x1fc, 0x1fd },
+ { 0x1fe, 0x1fe, 0x1ff },
+ { 0x200, 0x200, 0x201 },
+ { 0x202, 0x202, 0x203 },
+ { 0x204, 0x204, 0x205 },
+ { 0x206, 0x206, 0x207 },
+ { 0x208, 0x208, 0x209 },
+ { 0x20a, 0x20a, 0x20b },
+ { 0x20c, 0x20c, 0x20d },
+ { 0x20e, 0x20e, 0x20f },
+ { 0x210, 0x210, 0x211 },
+ { 0x212, 0x212, 0x213 },
+ { 0x214, 0x214, 0x215 },
+ { 0x216, 0x216, 0x217 },
+ { 0x218, 0x218, 0x219 },
+ { 0x21a, 0x21a, 0x21b },
+ { 0x21c, 0x21c, 0x21d },
+ { 0x21e, 0x21e, 0x21f },
+ { 0x220, 0x220, 0x19e },
+ { 0x222, 0x222, 0x223 },
+ { 0x224, 0x224, 0x225 },
+ { 0x226, 0x226, 0x227 },
+ { 0x228, 0x228, 0x229 },
+ { 0x22a, 0x22a, 0x22b },
+ { 0x22c, 0x22c, 0x22d },
+ { 0x22e, 0x22e, 0x22f },
+ { 0x230, 0x230, 0x231 },
+ { 0x232, 0x232, 0x233 },
+ { 0x23a, 0x23a, 0x2c65 },
+ { 0x23b, 0x23b, 0x23c },
+ { 0x23d, 0x23d, 0x19a },
+ { 0x23e, 0x23e, 0x2c66 },
+ { 0x241, 0x241, 0x242 },
+ { 0x243, 0x243, 0x180 },
+ { 0x244, 0x244, 0x289 },
+ { 0x245, 0x245, 0x28c },
+ { 0x246, 0x246, 0x247 },
+ { 0x248, 0x248, 0x249 },
+ { 0x24a, 0x24a, 0x24b },
+ { 0x24c, 0x24c, 0x24d },
+ { 0x24e, 0x24e, 0x24f },
+ { 0x370, 0x370, 0x371 },
+ { 0x372, 0x372, 0x373 },
+ { 0x376, 0x376, 0x377 },
+ { 0x37f, 0x37f, 0x3f3 },
+ { 0x386, 0x386, 0x3ac },
+ { 0x388, 0x38a, 0x3ad },
+ { 0x38c, 0x38c, 0x3cc },
+ { 0x38e, 0x38f, 0x3cd },
+ { 0x391, 0x3a1, 0x3b1 },
+ { 0x3a3, 0x3ab, 0x3c3 },
+ { 0x3cf, 0x3cf, 0x3d7 },
+ { 0x3d8, 0x3d8, 0x3d9 },
+ { 0x3da, 0x3da, 0x3db },
+ { 0x3dc, 0x3dc, 0x3dd },
+ { 0x3de, 0x3de, 0x3df },
+ { 0x3e0, 0x3e0, 0x3e1 },
+ { 0x3e2, 0x3e2, 0x3e3 },
+ { 0x3e4, 0x3e4, 0x3e5 },
+ { 0x3e6, 0x3e6, 0x3e7 },
+ { 0x3e8, 0x3e8, 0x3e9 },
+ { 0x3ea, 0x3ea, 0x3eb },
+ { 0x3ec, 0x3ec, 0x3ed },
+ { 0x3ee, 0x3ee, 0x3ef },
+ { 0x3f4, 0x3f4, 0x3b8 },
+ { 0x3f7, 0x3f7, 0x3f8 },
+ { 0x3f9, 0x3f9, 0x3f2 },
+ { 0x3fa, 0x3fa, 0x3fb },
+ { 0x3fd, 0x3ff, 0x37b },
+ { 0x400, 0x40f, 0x450 },
+ { 0x410, 0x42f, 0x430 },
+ { 0x460, 0x460, 0x461 },
+ { 0x462, 0x462, 0x463 },
+ { 0x464, 0x464, 0x465 },
+ { 0x466, 0x466, 0x467 },
+ { 0x468, 0x468, 0x469 },
+ { 0x46a, 0x46a, 0x46b },
+ { 0x46c, 0x46c, 0x46d },
+ { 0x46e, 0x46e, 0x46f },
+ { 0x470, 0x470, 0x471 },
+ { 0x472, 0x472, 0x473 },
+ { 0x474, 0x474, 0x475 },
+ { 0x476, 0x476, 0x477 },
+ { 0x478, 0x478, 0x479 },
+ { 0x47a, 0x47a, 0x47b },
+ { 0x47c, 0x47c, 0x47d },
+ { 0x47e, 0x47e, 0x47f },
+ { 0x480, 0x480, 0x481 },
+ { 0x48a, 0x48a, 0x48b },
+ { 0x48c, 0x48c, 0x48d },
+ { 0x48e, 0x48e, 0x48f },
+ { 0x490, 0x490, 0x491 },
+ { 0x492, 0x492, 0x493 },
+ { 0x494, 0x494, 0x495 },
+ { 0x496, 0x496, 0x497 },
+ { 0x498, 0x498, 0x499 },
+ { 0x49a, 0x49a, 0x49b },
+ { 0x49c, 0x49c, 0x49d },
+ { 0x49e, 0x49e, 0x49f },
+ { 0x4a0, 0x4a0, 0x4a1 },
+ { 0x4a2, 0x4a2, 0x4a3 },
+ { 0x4a4, 0x4a4, 0x4a5 },
+ { 0x4a6, 0x4a6, 0x4a7 },
+ { 0x4a8, 0x4a8, 0x4a9 },
+ { 0x4aa, 0x4aa, 0x4ab },
+ { 0x4ac, 0x4ac, 0x4ad },
+ { 0x4ae, 0x4ae, 0x4af },
+ { 0x4b0, 0x4b0, 0x4b1 },
+ { 0x4b2, 0x4b2, 0x4b3 },
+ { 0x4b4, 0x4b4, 0x4b5 },
+ { 0x4b6, 0x4b6, 0x4b7 },
+ { 0x4b8, 0x4b8, 0x4b9 },
+ { 0x4ba, 0x4ba, 0x4bb },
+ { 0x4bc, 0x4bc, 0x4bd },
+ { 0x4be, 0x4be, 0x4bf },
+ { 0x4c0, 0x4c0, 0x4cf },
+ { 0x4c1, 0x4c1, 0x4c2 },
+ { 0x4c3, 0x4c3, 0x4c4 },
+ { 0x4c5, 0x4c5, 0x4c6 },
+ { 0x4c7, 0x4c7, 0x4c8 },
+ { 0x4c9, 0x4c9, 0x4ca },
+ { 0x4cb, 0x4cb, 0x4cc },
+ { 0x4cd, 0x4cd, 0x4ce },
+ { 0x4d0, 0x4d0, 0x4d1 },
+ { 0x4d2, 0x4d2, 0x4d3 },
+ { 0x4d4, 0x4d4, 0x4d5 },
+ { 0x4d6, 0x4d6, 0x4d7 },
+ { 0x4d8, 0x4d8, 0x4d9 },
+ { 0x4da, 0x4da, 0x4db },
+ { 0x4dc, 0x4dc, 0x4dd },
+ { 0x4de, 0x4de, 0x4df },
+ { 0x4e0, 0x4e0, 0x4e1 },
+ { 0x4e2, 0x4e2, 0x4e3 },
+ { 0x4e4, 0x4e4, 0x4e5 },
+ { 0x4e6, 0x4e6, 0x4e7 },
+ { 0x4e8, 0x4e8, 0x4e9 },
+ { 0x4ea, 0x4ea, 0x4eb },
+ { 0x4ec, 0x4ec, 0x4ed },
+ { 0x4ee, 0x4ee, 0x4ef },
+ { 0x4f0, 0x4f0, 0x4f1 },
+ { 0x4f2, 0x4f2, 0x4f3 },
+ { 0x4f4, 0x4f4, 0x4f5 },
+ { 0x4f6, 0x4f6, 0x4f7 },
+ { 0x4f8, 0x4f8, 0x4f9 },
+ { 0x4fa, 0x4fa, 0x4fb },
+ { 0x4fc, 0x4fc, 0x4fd },
+ { 0x4fe, 0x4fe, 0x4ff },
+ { 0x500, 0x500, 0x501 },
+ { 0x502, 0x502, 0x503 },
+ { 0x504, 0x504, 0x505 },
+ { 0x506, 0x506, 0x507 },
+ { 0x508, 0x508, 0x509 },
+ { 0x50a, 0x50a, 0x50b },
+ { 0x50c, 0x50c, 0x50d },
+ { 0x50e, 0x50e, 0x50f },
+ { 0x510, 0x510, 0x511 },
+ { 0x512, 0x512, 0x513 },
+ { 0x514, 0x514, 0x515 },
+ { 0x516, 0x516, 0x517 },
+ { 0x518, 0x518, 0x519 },
+ { 0x51a, 0x51a, 0x51b },
+ { 0x51c, 0x51c, 0x51d },
+ { 0x51e, 0x51e, 0x51f },
+ { 0x520, 0x520, 0x521 },
+ { 0x522, 0x522, 0x523 },
+ { 0x524, 0x524, 0x525 },
+ { 0x526, 0x526, 0x527 },
+ { 0x528, 0x528, 0x529 },
+ { 0x52a, 0x52a, 0x52b },
+ { 0x52c, 0x52c, 0x52d },
+ { 0x52e, 0x52e, 0x52f },
+ { 0x531, 0x556, 0x561 },
+ { 0x10a0, 0x10c5, 0x2d00 },
+ { 0x10c7, 0x10c7, 0x2d27 },
+ { 0x10cd, 0x10cd, 0x2d2d },
+ { 0x13a0, 0x13ef, 0xab70 },
+ { 0x13f0, 0x13f5, 0x13f8 },
+ { 0x1c89, 0x1c89, 0x1c8a },
+ { 0x1c90, 0x1cba, 0x10d0 },
+ { 0x1cbd, 0x1cbf, 0x10fd },
+ { 0x1e00, 0x1e00, 0x1e01 },
+ { 0x1e02, 0x1e02, 0x1e03 },
+ { 0x1e04, 0x1e04, 0x1e05 },
+ { 0x1e06, 0x1e06, 0x1e07 },
+ { 0x1e08, 0x1e08, 0x1e09 },
+ { 0x1e0a, 0x1e0a, 0x1e0b },
+ { 0x1e0c, 0x1e0c, 0x1e0d },
+ { 0x1e0e, 0x1e0e, 0x1e0f },
+ { 0x1e10, 0x1e10, 0x1e11 },
+ { 0x1e12, 0x1e12, 0x1e13 },
+ { 0x1e14, 0x1e14, 0x1e15 },
+ { 0x1e16, 0x1e16, 0x1e17 },
+ { 0x1e18, 0x1e18, 0x1e19 },
+ { 0x1e1a, 0x1e1a, 0x1e1b },
+ { 0x1e1c, 0x1e1c, 0x1e1d },
+ { 0x1e1e, 0x1e1e, 0x1e1f },
+ { 0x1e20, 0x1e20, 0x1e21 },
+ { 0x1e22, 0x1e22, 0x1e23 },
+ { 0x1e24, 0x1e24, 0x1e25 },
+ { 0x1e26, 0x1e26, 0x1e27 },
+ { 0x1e28, 0x1e28, 0x1e29 },
+ { 0x1e2a, 0x1e2a, 0x1e2b },
+ { 0x1e2c, 0x1e2c, 0x1e2d },
+ { 0x1e2e, 0x1e2e, 0x1e2f },
+ { 0x1e30, 0x1e30, 0x1e31 },
+ { 0x1e32, 0x1e32, 0x1e33 },
+ { 0x1e34, 0x1e34, 0x1e35 },
+ { 0x1e36, 0x1e36, 0x1e37 },
+ { 0x1e38, 0x1e38, 0x1e39 },
+ { 0x1e3a, 0x1e3a, 0x1e3b },
+ { 0x1e3c, 0x1e3c, 0x1e3d },
+ { 0x1e3e, 0x1e3e, 0x1e3f },
+ { 0x1e40, 0x1e40, 0x1e41 },
+ { 0x1e42, 0x1e42, 0x1e43 },
+ { 0x1e44, 0x1e44, 0x1e45 },
+ { 0x1e46, 0x1e46, 0x1e47 },
+ { 0x1e48, 0x1e48, 0x1e49 },
+ { 0x1e4a, 0x1e4a, 0x1e4b },
+ { 0x1e4c, 0x1e4c, 0x1e4d },
+ { 0x1e4e, 0x1e4e, 0x1e4f },
+ { 0x1e50, 0x1e50, 0x1e51 },
+ { 0x1e52, 0x1e52, 0x1e53 },
+ { 0x1e54, 0x1e54, 0x1e55 },
+ { 0x1e56, 0x1e56, 0x1e57 },
+ { 0x1e58, 0x1e58, 0x1e59 },
+ { 0x1e5a, 0x1e5a, 0x1e5b },
+ { 0x1e5c, 0x1e5c, 0x1e5d },
+ { 0x1e5e, 0x1e5e, 0x1e5f },
+ { 0x1e60, 0x1e60, 0x1e61 },
+ { 0x1e62, 0x1e62, 0x1e63 },
+ { 0x1e64, 0x1e64, 0x1e65 },
+ { 0x1e66, 0x1e66, 0x1e67 },
+ { 0x1e68, 0x1e68, 0x1e69 },
+ { 0x1e6a, 0x1e6a, 0x1e6b },
+ { 0x1e6c, 0x1e6c, 0x1e6d },
+ { 0x1e6e, 0x1e6e, 0x1e6f },
+ { 0x1e70, 0x1e70, 0x1e71 },
+ { 0x1e72, 0x1e72, 0x1e73 },
+ { 0x1e74, 0x1e74, 0x1e75 },
+ { 0x1e76, 0x1e76, 0x1e77 },
+ { 0x1e78, 0x1e78, 0x1e79 },
+ { 0x1e7a, 0x1e7a, 0x1e7b },
+ { 0x1e7c, 0x1e7c, 0x1e7d },
+ { 0x1e7e, 0x1e7e, 0x1e7f },
+ { 0x1e80, 0x1e80, 0x1e81 },
+ { 0x1e82, 0x1e82, 0x1e83 },
+ { 0x1e84, 0x1e84, 0x1e85 },
+ { 0x1e86, 0x1e86, 0x1e87 },
+ { 0x1e88, 0x1e88, 0x1e89 },
+ { 0x1e8a, 0x1e8a, 0x1e8b },
+ { 0x1e8c, 0x1e8c, 0x1e8d },
+ { 0x1e8e, 0x1e8e, 0x1e8f },
+ { 0x1e90, 0x1e90, 0x1e91 },
+ { 0x1e92, 0x1e92, 0x1e93 },
+ { 0x1e94, 0x1e94, 0x1e95 },
+ { 0x1e9e, 0x1e9e, 0xdf },
+ { 0x1ea0, 0x1ea0, 0x1ea1 },
+ { 0x1ea2, 0x1ea2, 0x1ea3 },
+ { 0x1ea4, 0x1ea4, 0x1ea5 },
+ { 0x1ea6, 0x1ea6, 0x1ea7 },
+ { 0x1ea8, 0x1ea8, 0x1ea9 },
+ { 0x1eaa, 0x1eaa, 0x1eab },
+ { 0x1eac, 0x1eac, 0x1ead },
+ { 0x1eae, 0x1eae, 0x1eaf },
+ { 0x1eb0, 0x1eb0, 0x1eb1 },
+ { 0x1eb2, 0x1eb2, 0x1eb3 },
+ { 0x1eb4, 0x1eb4, 0x1eb5 },
+ { 0x1eb6, 0x1eb6, 0x1eb7 },
+ { 0x1eb8, 0x1eb8, 0x1eb9 },
+ { 0x1eba, 0x1eba, 0x1ebb },
+ { 0x1ebc, 0x1ebc, 0x1ebd },
+ { 0x1ebe, 0x1ebe, 0x1ebf },
+ { 0x1ec0, 0x1ec0, 0x1ec1 },
+ { 0x1ec2, 0x1ec2, 0x1ec3 },
+ { 0x1ec4, 0x1ec4, 0x1ec5 },
+ { 0x1ec6, 0x1ec6, 0x1ec7 },
+ { 0x1ec8, 0x1ec8, 0x1ec9 },
+ { 0x1eca, 0x1eca, 0x1ecb },
+ { 0x1ecc, 0x1ecc, 0x1ecd },
+ { 0x1ece, 0x1ece, 0x1ecf },
+ { 0x1ed0, 0x1ed0, 0x1ed1 },
+ { 0x1ed2, 0x1ed2, 0x1ed3 },
+ { 0x1ed4, 0x1ed4, 0x1ed5 },
+ { 0x1ed6, 0x1ed6, 0x1ed7 },
+ { 0x1ed8, 0x1ed8, 0x1ed9 },
+ { 0x1eda, 0x1eda, 0x1edb },
+ { 0x1edc, 0x1edc, 0x1edd },
+ { 0x1ede, 0x1ede, 0x1edf },
+ { 0x1ee0, 0x1ee0, 0x1ee1 },
+ { 0x1ee2, 0x1ee2, 0x1ee3 },
+ { 0x1ee4, 0x1ee4, 0x1ee5 },
+ { 0x1ee6, 0x1ee6, 0x1ee7 },
+ { 0x1ee8, 0x1ee8, 0x1ee9 },
+ { 0x1eea, 0x1eea, 0x1eeb },
+ { 0x1eec, 0x1eec, 0x1eed },
+ { 0x1eee, 0x1eee, 0x1eef },
+ { 0x1ef0, 0x1ef0, 0x1ef1 },
+ { 0x1ef2, 0x1ef2, 0x1ef3 },
+ { 0x1ef4, 0x1ef4, 0x1ef5 },
+ { 0x1ef6, 0x1ef6, 0x1ef7 },
+ { 0x1ef8, 0x1ef8, 0x1ef9 },
+ { 0x1efa, 0x1efa, 0x1efb },
+ { 0x1efc, 0x1efc, 0x1efd },
+ { 0x1efe, 0x1efe, 0x1eff },
+ { 0x1f08, 0x1f0f, 0x1f00 },
+ { 0x1f18, 0x1f1d, 0x1f10 },
+ { 0x1f28, 0x1f2f, 0x1f20 },
+ { 0x1f38, 0x1f3f, 0x1f30 },
+ { 0x1f48, 0x1f4d, 0x1f40 },
+ { 0x1f59, 0x1f59, 0x1f51 },
+ { 0x1f5b, 0x1f5b, 0x1f53 },
+ { 0x1f5d, 0x1f5d, 0x1f55 },
+ { 0x1f5f, 0x1f5f, 0x1f57 },
+ { 0x1f68, 0x1f6f, 0x1f60 },
+ { 0x1f88, 0x1f8f, 0x1f80 },
+ { 0x1f98, 0x1f9f, 0x1f90 },
+ { 0x1fa8, 0x1faf, 0x1fa0 },
+ { 0x1fb8, 0x1fb9, 0x1fb0 },
+ { 0x1fba, 0x1fbb, 0x1f70 },
+ { 0x1fbc, 0x1fbc, 0x1fb3 },
+ { 0x1fc8, 0x1fcb, 0x1f72 },
+ { 0x1fcc, 0x1fcc, 0x1fc3 },
+ { 0x1fd8, 0x1fd9, 0x1fd0 },
+ { 0x1fda, 0x1fdb, 0x1f76 },
+ { 0x1fe8, 0x1fe9, 0x1fe0 },
+ { 0x1fea, 0x1feb, 0x1f7a },
+ { 0x1fec, 0x1fec, 0x1fe5 },
+ { 0x1ff8, 0x1ff9, 0x1f78 },
+ { 0x1ffa, 0x1ffb, 0x1f7c },
+ { 0x1ffc, 0x1ffc, 0x1ff3 },
+ { 0x2126, 0x2126, 0x3c9 },
+ { 0x212a, 0x212a, 0x6b },
+ { 0x212b, 0x212b, 0xe5 },
+ { 0x2132, 0x2132, 0x214e },
+ { 0x2160, 0x216f, 0x2170 },
+ { 0x2183, 0x2183, 0x2184 },
+ { 0x24b6, 0x24cf, 0x24d0 },
+ { 0x2c00, 0x2c2f, 0x2c30 },
+ { 0x2c60, 0x2c60, 0x2c61 },
+ { 0x2c62, 0x2c62, 0x26b },
+ { 0x2c63, 0x2c63, 0x1d7d },
+ { 0x2c64, 0x2c64, 0x27d },
+ { 0x2c67, 0x2c67, 0x2c68 },
+ { 0x2c69, 0x2c69, 0x2c6a },
+ { 0x2c6b, 0x2c6b, 0x2c6c },
+ { 0x2c6d, 0x2c6d, 0x251 },
+ { 0x2c6e, 0x2c6e, 0x271 },
+ { 0x2c6f, 0x2c6f, 0x250 },
+ { 0x2c70, 0x2c70, 0x252 },
+ { 0x2c72, 0x2c72, 0x2c73 },
+ { 0x2c75, 0x2c75, 0x2c76 },
+ { 0x2c7e, 0x2c7f, 0x23f },
+ { 0x2c80, 0x2c80, 0x2c81 },
+ { 0x2c82, 0x2c82, 0x2c83 },
+ { 0x2c84, 0x2c84, 0x2c85 },
+ { 0x2c86, 0x2c86, 0x2c87 },
+ { 0x2c88, 0x2c88, 0x2c89 },
+ { 0x2c8a, 0x2c8a, 0x2c8b },
+ { 0x2c8c, 0x2c8c, 0x2c8d },
+ { 0x2c8e, 0x2c8e, 0x2c8f },
+ { 0x2c90, 0x2c90, 0x2c91 },
+ { 0x2c92, 0x2c92, 0x2c93 },
+ { 0x2c94, 0x2c94, 0x2c95 },
+ { 0x2c96, 0x2c96, 0x2c97 },
+ { 0x2c98, 0x2c98, 0x2c99 },
+ { 0x2c9a, 0x2c9a, 0x2c9b },
+ { 0x2c9c, 0x2c9c, 0x2c9d },
+ { 0x2c9e, 0x2c9e, 0x2c9f },
+ { 0x2ca0, 0x2ca0, 0x2ca1 },
+ { 0x2ca2, 0x2ca2, 0x2ca3 },
+ { 0x2ca4, 0x2ca4, 0x2ca5 },
+ { 0x2ca6, 0x2ca6, 0x2ca7 },
+ { 0x2ca8, 0x2ca8, 0x2ca9 },
+ { 0x2caa, 0x2caa, 0x2cab },
+ { 0x2cac, 0x2cac, 0x2cad },
+ { 0x2cae, 0x2cae, 0x2caf },
+ { 0x2cb0, 0x2cb0, 0x2cb1 },
+ { 0x2cb2, 0x2cb2, 0x2cb3 },
+ { 0x2cb4, 0x2cb4, 0x2cb5 },
+ { 0x2cb6, 0x2cb6, 0x2cb7 },
+ { 0x2cb8, 0x2cb8, 0x2cb9 },
+ { 0x2cba, 0x2cba, 0x2cbb },
+ { 0x2cbc, 0x2cbc, 0x2cbd },
+ { 0x2cbe, 0x2cbe, 0x2cbf },
+ { 0x2cc0, 0x2cc0, 0x2cc1 },
+ { 0x2cc2, 0x2cc2, 0x2cc3 },
+ { 0x2cc4, 0x2cc4, 0x2cc5 },
+ { 0x2cc6, 0x2cc6, 0x2cc7 },
+ { 0x2cc8, 0x2cc8, 0x2cc9 },
+ { 0x2cca, 0x2cca, 0x2ccb },
+ { 0x2ccc, 0x2ccc, 0x2ccd },
+ { 0x2cce, 0x2cce, 0x2ccf },
+ { 0x2cd0, 0x2cd0, 0x2cd1 },
+ { 0x2cd2, 0x2cd2, 0x2cd3 },
+ { 0x2cd4, 0x2cd4, 0x2cd5 },
+ { 0x2cd6, 0x2cd6, 0x2cd7 },
+ { 0x2cd8, 0x2cd8, 0x2cd9 },
+ { 0x2cda, 0x2cda, 0x2cdb },
+ { 0x2cdc, 0x2cdc, 0x2cdd },
+ { 0x2cde, 0x2cde, 0x2cdf },
+ { 0x2ce0, 0x2ce0, 0x2ce1 },
+ { 0x2ce2, 0x2ce2, 0x2ce3 },
+ { 0x2ceb, 0x2ceb, 0x2cec },
+ { 0x2ced, 0x2ced, 0x2cee },
+ { 0x2cf2, 0x2cf2, 0x2cf3 },
+ { 0xa640, 0xa640, 0xa641 },
+ { 0xa642, 0xa642, 0xa643 },
+ { 0xa644, 0xa644, 0xa645 },
+ { 0xa646, 0xa646, 0xa647 },
+ { 0xa648, 0xa648, 0xa649 },
+ { 0xa64a, 0xa64a, 0xa64b },
+ { 0xa64c, 0xa64c, 0xa64d },
+ { 0xa64e, 0xa64e, 0xa64f },
+ { 0xa650, 0xa650, 0xa651 },
+ { 0xa652, 0xa652, 0xa653 },
+ { 0xa654, 0xa654, 0xa655 },
+ { 0xa656, 0xa656, 0xa657 },
+ { 0xa658, 0xa658, 0xa659 },
+ { 0xa65a, 0xa65a, 0xa65b },
+ { 0xa65c, 0xa65c, 0xa65d },
+ { 0xa65e, 0xa65e, 0xa65f },
+ { 0xa660, 0xa660, 0xa661 },
+ { 0xa662, 0xa662, 0xa663 },
+ { 0xa664, 0xa664, 0xa665 },
+ { 0xa666, 0xa666, 0xa667 },
+ { 0xa668, 0xa668, 0xa669 },
+ { 0xa66a, 0xa66a, 0xa66b },
+ { 0xa66c, 0xa66c, 0xa66d },
+ { 0xa680, 0xa680, 0xa681 },
+ { 0xa682, 0xa682, 0xa683 },
+ { 0xa684, 0xa684, 0xa685 },
+ { 0xa686, 0xa686, 0xa687 },
+ { 0xa688, 0xa688, 0xa689 },
+ { 0xa68a, 0xa68a, 0xa68b },
+ { 0xa68c, 0xa68c, 0xa68d },
+ { 0xa68e, 0xa68e, 0xa68f },
+ { 0xa690, 0xa690, 0xa691 },
+ { 0xa692, 0xa692, 0xa693 },
+ { 0xa694, 0xa694, 0xa695 },
+ { 0xa696, 0xa696, 0xa697 },
+ { 0xa698, 0xa698, 0xa699 },
+ { 0xa69a, 0xa69a, 0xa69b },
+ { 0xa722, 0xa722, 0xa723 },
+ { 0xa724, 0xa724, 0xa725 },
+ { 0xa726, 0xa726, 0xa727 },
+ { 0xa728, 0xa728, 0xa729 },
+ { 0xa72a, 0xa72a, 0xa72b },
+ { 0xa72c, 0xa72c, 0xa72d },
+ { 0xa72e, 0xa72e, 0xa72f },
+ { 0xa732, 0xa732, 0xa733 },
+ { 0xa734, 0xa734, 0xa735 },
+ { 0xa736, 0xa736, 0xa737 },
+ { 0xa738, 0xa738, 0xa739 },
+ { 0xa73a, 0xa73a, 0xa73b },
+ { 0xa73c, 0xa73c, 0xa73d },
+ { 0xa73e, 0xa73e, 0xa73f },
+ { 0xa740, 0xa740, 0xa741 },
+ { 0xa742, 0xa742, 0xa743 },
+ { 0xa744, 0xa744, 0xa745 },
+ { 0xa746, 0xa746, 0xa747 },
+ { 0xa748, 0xa748, 0xa749 },
+ { 0xa74a, 0xa74a, 0xa74b },
+ { 0xa74c, 0xa74c, 0xa74d },
+ { 0xa74e, 0xa74e, 0xa74f },
+ { 0xa750, 0xa750, 0xa751 },
+ { 0xa752, 0xa752, 0xa753 },
+ { 0xa754, 0xa754, 0xa755 },
+ { 0xa756, 0xa756, 0xa757 },
+ { 0xa758, 0xa758, 0xa759 },
+ { 0xa75a, 0xa75a, 0xa75b },
+ { 0xa75c, 0xa75c, 0xa75d },
+ { 0xa75e, 0xa75e, 0xa75f },
+ { 0xa760, 0xa760, 0xa761 },
+ { 0xa762, 0xa762, 0xa763 },
+ { 0xa764, 0xa764, 0xa765 },
+ { 0xa766, 0xa766, 0xa767 },
+ { 0xa768, 0xa768, 0xa769 },
+ { 0xa76a, 0xa76a, 0xa76b },
+ { 0xa76c, 0xa76c, 0xa76d },
+ { 0xa76e, 0xa76e, 0xa76f },
+ { 0xa779, 0xa779, 0xa77a },
+ { 0xa77b, 0xa77b, 0xa77c },
+ { 0xa77d, 0xa77d, 0x1d79 },
+ { 0xa77e, 0xa77e, 0xa77f },
+ { 0xa780, 0xa780, 0xa781 },
+ { 0xa782, 0xa782, 0xa783 },
+ { 0xa784, 0xa784, 0xa785 },
+ { 0xa786, 0xa786, 0xa787 },
+ { 0xa78b, 0xa78b, 0xa78c },
+ { 0xa78d, 0xa78d, 0x265 },
+ { 0xa790, 0xa790, 0xa791 },
+ { 0xa792, 0xa792, 0xa793 },
+ { 0xa796, 0xa796, 0xa797 },
+ { 0xa798, 0xa798, 0xa799 },
+ { 0xa79a, 0xa79a, 0xa79b },
+ { 0xa79c, 0xa79c, 0xa79d },
+ { 0xa79e, 0xa79e, 0xa79f },
+ { 0xa7a0, 0xa7a0, 0xa7a1 },
+ { 0xa7a2, 0xa7a2, 0xa7a3 },
+ { 0xa7a4, 0xa7a4, 0xa7a5 },
+ { 0xa7a6, 0xa7a6, 0xa7a7 },
+ { 0xa7a8, 0xa7a8, 0xa7a9 },
+ { 0xa7aa, 0xa7aa, 0x266 },
+ { 0xa7ab, 0xa7ab, 0x25c },
+ { 0xa7ac, 0xa7ac, 0x261 },
+ { 0xa7ad, 0xa7ad, 0x26c },
+ { 0xa7ae, 0xa7ae, 0x26a },
+ { 0xa7b0, 0xa7b0, 0x29e },
+ { 0xa7b1, 0xa7b1, 0x287 },
+ { 0xa7b2, 0xa7b2, 0x29d },
+ { 0xa7b3, 0xa7b3, 0xab53 },
+ { 0xa7b4, 0xa7b4, 0xa7b5 },
+ { 0xa7b6, 0xa7b6, 0xa7b7 },
+ { 0xa7b8, 0xa7b8, 0xa7b9 },
+ { 0xa7ba, 0xa7ba, 0xa7bb },
+ { 0xa7bc, 0xa7bc, 0xa7bd },
+ { 0xa7be, 0xa7be, 0xa7bf },
+ { 0xa7c0, 0xa7c0, 0xa7c1 },
+ { 0xa7c2, 0xa7c2, 0xa7c3 },
+ { 0xa7c4, 0xa7c4, 0xa794 },
+ { 0xa7c5, 0xa7c5, 0x282 },
+ { 0xa7c6, 0xa7c6, 0x1d8e },
+ { 0xa7c7, 0xa7c7, 0xa7c8 },
+ { 0xa7c9, 0xa7c9, 0xa7ca },
+ { 0xa7cb, 0xa7cb, 0x264 },
+ { 0xa7cc, 0xa7cc, 0xa7cd },
+ { 0xa7ce, 0xa7ce, 0xa7cf },
+ { 0xa7d0, 0xa7d0, 0xa7d1 },
+ { 0xa7d2, 0xa7d2, 0xa7d3 },
+ { 0xa7d4, 0xa7d4, 0xa7d5 },
+ { 0xa7d6, 0xa7d6, 0xa7d7 },
+ { 0xa7d8, 0xa7d8, 0xa7d9 },
+ { 0xa7da, 0xa7da, 0xa7db },
+ { 0xa7dc, 0xa7dc, 0x19b },
+ { 0xa7f5, 0xa7f5, 0xa7f6 },
+ { 0xff21, 0xff3a, 0xff41 },
+ { 0x10400, 0x10427, 0x10428 },
+ { 0x104b0, 0x104d3, 0x104d8 },
+ { 0x10570, 0x1057a, 0x10597 },
+ { 0x1057c, 0x1058a, 0x105a3 },
+ { 0x1058c, 0x10592, 0x105b3 },
+ { 0x10594, 0x10595, 0x105bb },
+ { 0x10c80, 0x10cb2, 0x10cc0 },
+ { 0x10d50, 0x10d65, 0x10d70 },
+ { 0x118a0, 0x118bf, 0x118c0 },
+ { 0x16e40, 0x16e5f, 0x16e60 },
+ { 0x16ea0, 0x16eb8, 0x16ebb },
+ { 0x1e900, 0x1e921, 0x1e922 },
+};
+static const int uppermap[][3] = {
+ { 0x61, 0x7a, 0x41 },
+ { 0xb5, 0xb5, 0x39c },
+ { 0xe0, 0xf6, 0xc0 },
+ { 0xf8, 0xfe, 0xd8 },
+ { 0xff, 0xff, 0x178 },
+ { 0x101, 0x101, 0x100 },
+ { 0x103, 0x103, 0x102 },
+ { 0x105, 0x105, 0x104 },
+ { 0x107, 0x107, 0x106 },
+ { 0x109, 0x109, 0x108 },
+ { 0x10b, 0x10b, 0x10a },
+ { 0x10d, 0x10d, 0x10c },
+ { 0x10f, 0x10f, 0x10e },
+ { 0x111, 0x111, 0x110 },
+ { 0x113, 0x113, 0x112 },
+ { 0x115, 0x115, 0x114 },
+ { 0x117, 0x117, 0x116 },
+ { 0x119, 0x119, 0x118 },
+ { 0x11b, 0x11b, 0x11a },
+ { 0x11d, 0x11d, 0x11c },
+ { 0x11f, 0x11f, 0x11e },
+ { 0x121, 0x121, 0x120 },
+ { 0x123, 0x123, 0x122 },
+ { 0x125, 0x125, 0x124 },
+ { 0x127, 0x127, 0x126 },
+ { 0x129, 0x129, 0x128 },
+ { 0x12b, 0x12b, 0x12a },
+ { 0x12d, 0x12d, 0x12c },
+ { 0x12f, 0x12f, 0x12e },
+ { 0x131, 0x131, 0x49 },
+ { 0x133, 0x133, 0x132 },
+ { 0x135, 0x135, 0x134 },
+ { 0x137, 0x137, 0x136 },
+ { 0x13a, 0x13a, 0x139 },
+ { 0x13c, 0x13c, 0x13b },
+ { 0x13e, 0x13e, 0x13d },
+ { 0x140, 0x140, 0x13f },
+ { 0x142, 0x142, 0x141 },
+ { 0x144, 0x144, 0x143 },
+ { 0x146, 0x146, 0x145 },
+ { 0x148, 0x148, 0x147 },
+ { 0x14b, 0x14b, 0x14a },
+ { 0x14d, 0x14d, 0x14c },
+ { 0x14f, 0x14f, 0x14e },
+ { 0x151, 0x151, 0x150 },
+ { 0x153, 0x153, 0x152 },
+ { 0x155, 0x155, 0x154 },
+ { 0x157, 0x157, 0x156 },
+ { 0x159, 0x159, 0x158 },
+ { 0x15b, 0x15b, 0x15a },
+ { 0x15d, 0x15d, 0x15c },
+ { 0x15f, 0x15f, 0x15e },
+ { 0x161, 0x161, 0x160 },
+ { 0x163, 0x163, 0x162 },
+ { 0x165, 0x165, 0x164 },
+ { 0x167, 0x167, 0x166 },
+ { 0x169, 0x169, 0x168 },
+ { 0x16b, 0x16b, 0x16a },
+ { 0x16d, 0x16d, 0x16c },
+ { 0x16f, 0x16f, 0x16e },
+ { 0x171, 0x171, 0x170 },
+ { 0x173, 0x173, 0x172 },
+ { 0x175, 0x175, 0x174 },
+ { 0x177, 0x177, 0x176 },
+ { 0x17a, 0x17a, 0x179 },
+ { 0x17c, 0x17c, 0x17b },
+ { 0x17e, 0x17e, 0x17d },
+ { 0x17f, 0x17f, 0x53 },
+ { 0x180, 0x180, 0x243 },
+ { 0x183, 0x183, 0x182 },
+ { 0x185, 0x185, 0x184 },
+ { 0x188, 0x188, 0x187 },
+ { 0x18c, 0x18c, 0x18b },
+ { 0x192, 0x192, 0x191 },
+ { 0x195, 0x195, 0x1f6 },
+ { 0x199, 0x199, 0x198 },
+ { 0x19a, 0x19a, 0x23d },
+ { 0x19b, 0x19b, 0xa7dc },
+ { 0x19e, 0x19e, 0x220 },
+ { 0x1a1, 0x1a1, 0x1a0 },
+ { 0x1a3, 0x1a3, 0x1a2 },
+ { 0x1a5, 0x1a5, 0x1a4 },
+ { 0x1a8, 0x1a8, 0x1a7 },
+ { 0x1ad, 0x1ad, 0x1ac },
+ { 0x1b0, 0x1b0, 0x1af },
+ { 0x1b4, 0x1b4, 0x1b3 },
+ { 0x1b6, 0x1b6, 0x1b5 },
+ { 0x1b9, 0x1b9, 0x1b8 },
+ { 0x1bd, 0x1bd, 0x1bc },
+ { 0x1bf, 0x1bf, 0x1f7 },
+ { 0x1c5, 0x1c5, 0x1c4 },
+ { 0x1c6, 0x1c6, 0x1c4 },
+ { 0x1c8, 0x1c8, 0x1c7 },
+ { 0x1c9, 0x1c9, 0x1c7 },
+ { 0x1cb, 0x1cb, 0x1ca },
+ { 0x1cc, 0x1cc, 0x1ca },
+ { 0x1ce, 0x1ce, 0x1cd },
+ { 0x1d0, 0x1d0, 0x1cf },
+ { 0x1d2, 0x1d2, 0x1d1 },
+ { 0x1d4, 0x1d4, 0x1d3 },
+ { 0x1d6, 0x1d6, 0x1d5 },
+ { 0x1d8, 0x1d8, 0x1d7 },
+ { 0x1da, 0x1da, 0x1d9 },
+ { 0x1dc, 0x1dc, 0x1db },
+ { 0x1dd, 0x1dd, 0x18e },
+ { 0x1df, 0x1df, 0x1de },
+ { 0x1e1, 0x1e1, 0x1e0 },
+ { 0x1e3, 0x1e3, 0x1e2 },
+ { 0x1e5, 0x1e5, 0x1e4 },
+ { 0x1e7, 0x1e7, 0x1e6 },
+ { 0x1e9, 0x1e9, 0x1e8 },
+ { 0x1eb, 0x1eb, 0x1ea },
+ { 0x1ed, 0x1ed, 0x1ec },
+ { 0x1ef, 0x1ef, 0x1ee },
+ { 0x1f2, 0x1f2, 0x1f1 },
+ { 0x1f3, 0x1f3, 0x1f1 },
+ { 0x1f5, 0x1f5, 0x1f4 },
+ { 0x1f9, 0x1f9, 0x1f8 },
+ { 0x1fb, 0x1fb, 0x1fa },
+ { 0x1fd, 0x1fd, 0x1fc },
+ { 0x1ff, 0x1ff, 0x1fe },
+ { 0x201, 0x201, 0x200 },
+ { 0x203, 0x203, 0x202 },
+ { 0x205, 0x205, 0x204 },
+ { 0x207, 0x207, 0x206 },
+ { 0x209, 0x209, 0x208 },
+ { 0x20b, 0x20b, 0x20a },
+ { 0x20d, 0x20d, 0x20c },
+ { 0x20f, 0x20f, 0x20e },
+ { 0x211, 0x211, 0x210 },
+ { 0x213, 0x213, 0x212 },
+ { 0x215, 0x215, 0x214 },
+ { 0x217, 0x217, 0x216 },
+ { 0x219, 0x219, 0x218 },
+ { 0x21b, 0x21b, 0x21a },
+ { 0x21d, 0x21d, 0x21c },
+ { 0x21f, 0x21f, 0x21e },
+ { 0x223, 0x223, 0x222 },
+ { 0x225, 0x225, 0x224 },
+ { 0x227, 0x227, 0x226 },
+ { 0x229, 0x229, 0x228 },
+ { 0x22b, 0x22b, 0x22a },
+ { 0x22d, 0x22d, 0x22c },
+ { 0x22f, 0x22f, 0x22e },
+ { 0x231, 0x231, 0x230 },
+ { 0x233, 0x233, 0x232 },
+ { 0x23c, 0x23c, 0x23b },
+ { 0x23f, 0x240, 0x2c7e },
+ { 0x242, 0x242, 0x241 },
+ { 0x247, 0x247, 0x246 },
+ { 0x249, 0x249, 0x248 },
+ { 0x24b, 0x24b, 0x24a },
+ { 0x24d, 0x24d, 0x24c },
+ { 0x24f, 0x24f, 0x24e },
+ { 0x250, 0x250, 0x2c6f },
+ { 0x251, 0x251, 0x2c6d },
+ { 0x252, 0x252, 0x2c70 },
+ { 0x253, 0x253, 0x181 },
+ { 0x254, 0x254, 0x186 },
+ { 0x256, 0x257, 0x189 },
+ { 0x259, 0x259, 0x18f },
+ { 0x25b, 0x25b, 0x190 },
+ { 0x25c, 0x25c, 0xa7ab },
+ { 0x260, 0x260, 0x193 },
+ { 0x261, 0x261, 0xa7ac },
+ { 0x263, 0x263, 0x194 },
+ { 0x264, 0x264, 0xa7cb },
+ { 0x265, 0x265, 0xa78d },
+ { 0x266, 0x266, 0xa7aa },
+ { 0x268, 0x268, 0x197 },
+ { 0x269, 0x269, 0x196 },
+ { 0x26a, 0x26a, 0xa7ae },
+ { 0x26b, 0x26b, 0x2c62 },
+ { 0x26c, 0x26c, 0xa7ad },
+ { 0x26f, 0x26f, 0x19c },
+ { 0x271, 0x271, 0x2c6e },
+ { 0x272, 0x272, 0x19d },
+ { 0x275, 0x275, 0x19f },
+ { 0x27d, 0x27d, 0x2c64 },
+ { 0x280, 0x280, 0x1a6 },
+ { 0x282, 0x282, 0xa7c5 },
+ { 0x283, 0x283, 0x1a9 },
+ { 0x287, 0x287, 0xa7b1 },
+ { 0x288, 0x288, 0x1ae },
+ { 0x289, 0x289, 0x244 },
+ { 0x28a, 0x28b, 0x1b1 },
+ { 0x28c, 0x28c, 0x245 },
+ { 0x292, 0x292, 0x1b7 },
+ { 0x29d, 0x29d, 0xa7b2 },
+ { 0x29e, 0x29e, 0xa7b0 },
+ { 0x345, 0x345, 0x399 },
+ { 0x371, 0x371, 0x370 },
+ { 0x373, 0x373, 0x372 },
+ { 0x377, 0x377, 0x376 },
+ { 0x37b, 0x37d, 0x3fd },
+ { 0x3ac, 0x3ac, 0x386 },
+ { 0x3ad, 0x3af, 0x388 },
+ { 0x3b1, 0x3c1, 0x391 },
+ { 0x3c2, 0x3c2, 0x3a3 },
+ { 0x3c3, 0x3cb, 0x3a3 },
+ { 0x3cc, 0x3cc, 0x38c },
+ { 0x3cd, 0x3ce, 0x38e },
+ { 0x3d0, 0x3d0, 0x392 },
+ { 0x3d1, 0x3d1, 0x398 },
+ { 0x3d5, 0x3d5, 0x3a6 },
+ { 0x3d6, 0x3d6, 0x3a0 },
+ { 0x3d7, 0x3d7, 0x3cf },
+ { 0x3d9, 0x3d9, 0x3d8 },
+ { 0x3db, 0x3db, 0x3da },
+ { 0x3dd, 0x3dd, 0x3dc },
+ { 0x3df, 0x3df, 0x3de },
+ { 0x3e1, 0x3e1, 0x3e0 },
+ { 0x3e3, 0x3e3, 0x3e2 },
+ { 0x3e5, 0x3e5, 0x3e4 },
+ { 0x3e7, 0x3e7, 0x3e6 },
+ { 0x3e9, 0x3e9, 0x3e8 },
+ { 0x3eb, 0x3eb, 0x3ea },
+ { 0x3ed, 0x3ed, 0x3ec },
+ { 0x3ef, 0x3ef, 0x3ee },
+ { 0x3f0, 0x3f0, 0x39a },
+ { 0x3f1, 0x3f1, 0x3a1 },
+ { 0x3f2, 0x3f2, 0x3f9 },
+ { 0x3f3, 0x3f3, 0x37f },
+ { 0x3f5, 0x3f5, 0x395 },
+ { 0x3f8, 0x3f8, 0x3f7 },
+ { 0x3fb, 0x3fb, 0x3fa },
+ { 0x430, 0x44f, 0x410 },
+ { 0x450, 0x45f, 0x400 },
+ { 0x461, 0x461, 0x460 },
+ { 0x463, 0x463, 0x462 },
+ { 0x465, 0x465, 0x464 },
+ { 0x467, 0x467, 0x466 },
+ { 0x469, 0x469, 0x468 },
+ { 0x46b, 0x46b, 0x46a },
+ { 0x46d, 0x46d, 0x46c },
+ { 0x46f, 0x46f, 0x46e },
+ { 0x471, 0x471, 0x470 },
+ { 0x473, 0x473, 0x472 },
+ { 0x475, 0x475, 0x474 },
+ { 0x477, 0x477, 0x476 },
+ { 0x479, 0x479, 0x478 },
+ { 0x47b, 0x47b, 0x47a },
+ { 0x47d, 0x47d, 0x47c },
+ { 0x47f, 0x47f, 0x47e },
+ { 0x481, 0x481, 0x480 },
+ { 0x48b, 0x48b, 0x48a },
+ { 0x48d, 0x48d, 0x48c },
+ { 0x48f, 0x48f, 0x48e },
+ { 0x491, 0x491, 0x490 },
+ { 0x493, 0x493, 0x492 },
+ { 0x495, 0x495, 0x494 },
+ { 0x497, 0x497, 0x496 },
+ { 0x499, 0x499, 0x498 },
+ { 0x49b, 0x49b, 0x49a },
+ { 0x49d, 0x49d, 0x49c },
+ { 0x49f, 0x49f, 0x49e },
+ { 0x4a1, 0x4a1, 0x4a0 },
+ { 0x4a3, 0x4a3, 0x4a2 },
+ { 0x4a5, 0x4a5, 0x4a4 },
+ { 0x4a7, 0x4a7, 0x4a6 },
+ { 0x4a9, 0x4a9, 0x4a8 },
+ { 0x4ab, 0x4ab, 0x4aa },
+ { 0x4ad, 0x4ad, 0x4ac },
+ { 0x4af, 0x4af, 0x4ae },
+ { 0x4b1, 0x4b1, 0x4b0 },
+ { 0x4b3, 0x4b3, 0x4b2 },
+ { 0x4b5, 0x4b5, 0x4b4 },
+ { 0x4b7, 0x4b7, 0x4b6 },
+ { 0x4b9, 0x4b9, 0x4b8 },
+ { 0x4bb, 0x4bb, 0x4ba },
+ { 0x4bd, 0x4bd, 0x4bc },
+ { 0x4bf, 0x4bf, 0x4be },
+ { 0x4c2, 0x4c2, 0x4c1 },
+ { 0x4c4, 0x4c4, 0x4c3 },
+ { 0x4c6, 0x4c6, 0x4c5 },
+ { 0x4c8, 0x4c8, 0x4c7 },
+ { 0x4ca, 0x4ca, 0x4c9 },
+ { 0x4cc, 0x4cc, 0x4cb },
+ { 0x4ce, 0x4ce, 0x4cd },
+ { 0x4cf, 0x4cf, 0x4c0 },
+ { 0x4d1, 0x4d1, 0x4d0 },
+ { 0x4d3, 0x4d3, 0x4d2 },
+ { 0x4d5, 0x4d5, 0x4d4 },
+ { 0x4d7, 0x4d7, 0x4d6 },
+ { 0x4d9, 0x4d9, 0x4d8 },
+ { 0x4db, 0x4db, 0x4da },
+ { 0x4dd, 0x4dd, 0x4dc },
+ { 0x4df, 0x4df, 0x4de },
+ { 0x4e1, 0x4e1, 0x4e0 },
+ { 0x4e3, 0x4e3, 0x4e2 },
+ { 0x4e5, 0x4e5, 0x4e4 },
+ { 0x4e7, 0x4e7, 0x4e6 },
+ { 0x4e9, 0x4e9, 0x4e8 },
+ { 0x4eb, 0x4eb, 0x4ea },
+ { 0x4ed, 0x4ed, 0x4ec },
+ { 0x4ef, 0x4ef, 0x4ee },
+ { 0x4f1, 0x4f1, 0x4f0 },
+ { 0x4f3, 0x4f3, 0x4f2 },
+ { 0x4f5, 0x4f5, 0x4f4 },
+ { 0x4f7, 0x4f7, 0x4f6 },
+ { 0x4f9, 0x4f9, 0x4f8 },
+ { 0x4fb, 0x4fb, 0x4fa },
+ { 0x4fd, 0x4fd, 0x4fc },
+ { 0x4ff, 0x4ff, 0x4fe },
+ { 0x501, 0x501, 0x500 },
+ { 0x503, 0x503, 0x502 },
+ { 0x505, 0x505, 0x504 },
+ { 0x507, 0x507, 0x506 },
+ { 0x509, 0x509, 0x508 },
+ { 0x50b, 0x50b, 0x50a },
+ { 0x50d, 0x50d, 0x50c },
+ { 0x50f, 0x50f, 0x50e },
+ { 0x511, 0x511, 0x510 },
+ { 0x513, 0x513, 0x512 },
+ { 0x515, 0x515, 0x514 },
+ { 0x517, 0x517, 0x516 },
+ { 0x519, 0x519, 0x518 },
+ { 0x51b, 0x51b, 0x51a },
+ { 0x51d, 0x51d, 0x51c },
+ { 0x51f, 0x51f, 0x51e },
+ { 0x521, 0x521, 0x520 },
+ { 0x523, 0x523, 0x522 },
+ { 0x525, 0x525, 0x524 },
+ { 0x527, 0x527, 0x526 },
+ { 0x529, 0x529, 0x528 },
+ { 0x52b, 0x52b, 0x52a },
+ { 0x52d, 0x52d, 0x52c },
+ { 0x52f, 0x52f, 0x52e },
+ { 0x561, 0x586, 0x531 },
+ { 0x10d0, 0x10fa, 0x1c90 },
+ { 0x10fd, 0x10ff, 0x1cbd },
+ { 0x13f8, 0x13fd, 0x13f0 },
+ { 0x1c80, 0x1c80, 0x412 },
+ { 0x1c81, 0x1c81, 0x414 },
+ { 0x1c82, 0x1c82, 0x41e },
+ { 0x1c83, 0x1c84, 0x421 },
+ { 0x1c85, 0x1c85, 0x422 },
+ { 0x1c86, 0x1c86, 0x42a },
+ { 0x1c87, 0x1c87, 0x462 },
+ { 0x1c88, 0x1c88, 0xa64a },
+ { 0x1c8a, 0x1c8a, 0x1c89 },
+ { 0x1d79, 0x1d79, 0xa77d },
+ { 0x1d7d, 0x1d7d, 0x2c63 },
+ { 0x1d8e, 0x1d8e, 0xa7c6 },
+ { 0x1e01, 0x1e01, 0x1e00 },
+ { 0x1e03, 0x1e03, 0x1e02 },
+ { 0x1e05, 0x1e05, 0x1e04 },
+ { 0x1e07, 0x1e07, 0x1e06 },
+ { 0x1e09, 0x1e09, 0x1e08 },
+ { 0x1e0b, 0x1e0b, 0x1e0a },
+ { 0x1e0d, 0x1e0d, 0x1e0c },
+ { 0x1e0f, 0x1e0f, 0x1e0e },
+ { 0x1e11, 0x1e11, 0x1e10 },
+ { 0x1e13, 0x1e13, 0x1e12 },
+ { 0x1e15, 0x1e15, 0x1e14 },
+ { 0x1e17, 0x1e17, 0x1e16 },
+ { 0x1e19, 0x1e19, 0x1e18 },
+ { 0x1e1b, 0x1e1b, 0x1e1a },
+ { 0x1e1d, 0x1e1d, 0x1e1c },
+ { 0x1e1f, 0x1e1f, 0x1e1e },
+ { 0x1e21, 0x1e21, 0x1e20 },
+ { 0x1e23, 0x1e23, 0x1e22 },
+ { 0x1e25, 0x1e25, 0x1e24 },
+ { 0x1e27, 0x1e27, 0x1e26 },
+ { 0x1e29, 0x1e29, 0x1e28 },
+ { 0x1e2b, 0x1e2b, 0x1e2a },
+ { 0x1e2d, 0x1e2d, 0x1e2c },
+ { 0x1e2f, 0x1e2f, 0x1e2e },
+ { 0x1e31, 0x1e31, 0x1e30 },
+ { 0x1e33, 0x1e33, 0x1e32 },
+ { 0x1e35, 0x1e35, 0x1e34 },
+ { 0x1e37, 0x1e37, 0x1e36 },
+ { 0x1e39, 0x1e39, 0x1e38 },
+ { 0x1e3b, 0x1e3b, 0x1e3a },
+ { 0x1e3d, 0x1e3d, 0x1e3c },
+ { 0x1e3f, 0x1e3f, 0x1e3e },
+ { 0x1e41, 0x1e41, 0x1e40 },
+ { 0x1e43, 0x1e43, 0x1e42 },
+ { 0x1e45, 0x1e45, 0x1e44 },
+ { 0x1e47, 0x1e47, 0x1e46 },
+ { 0x1e49, 0x1e49, 0x1e48 },
+ { 0x1e4b, 0x1e4b, 0x1e4a },
+ { 0x1e4d, 0x1e4d, 0x1e4c },
+ { 0x1e4f, 0x1e4f, 0x1e4e },
+ { 0x1e51, 0x1e51, 0x1e50 },
+ { 0x1e53, 0x1e53, 0x1e52 },
+ { 0x1e55, 0x1e55, 0x1e54 },
+ { 0x1e57, 0x1e57, 0x1e56 },
+ { 0x1e59, 0x1e59, 0x1e58 },
+ { 0x1e5b, 0x1e5b, 0x1e5a },
+ { 0x1e5d, 0x1e5d, 0x1e5c },
+ { 0x1e5f, 0x1e5f, 0x1e5e },
+ { 0x1e61, 0x1e61, 0x1e60 },
+ { 0x1e63, 0x1e63, 0x1e62 },
+ { 0x1e65, 0x1e65, 0x1e64 },
+ { 0x1e67, 0x1e67, 0x1e66 },
+ { 0x1e69, 0x1e69, 0x1e68 },
+ { 0x1e6b, 0x1e6b, 0x1e6a },
+ { 0x1e6d, 0x1e6d, 0x1e6c },
+ { 0x1e6f, 0x1e6f, 0x1e6e },
+ { 0x1e71, 0x1e71, 0x1e70 },
+ { 0x1e73, 0x1e73, 0x1e72 },
+ { 0x1e75, 0x1e75, 0x1e74 },
+ { 0x1e77, 0x1e77, 0x1e76 },
+ { 0x1e79, 0x1e79, 0x1e78 },
+ { 0x1e7b, 0x1e7b, 0x1e7a },
+ { 0x1e7d, 0x1e7d, 0x1e7c },
+ { 0x1e7f, 0x1e7f, 0x1e7e },
+ { 0x1e81, 0x1e81, 0x1e80 },
+ { 0x1e83, 0x1e83, 0x1e82 },
+ { 0x1e85, 0x1e85, 0x1e84 },
+ { 0x1e87, 0x1e87, 0x1e86 },
+ { 0x1e89, 0x1e89, 0x1e88 },
+ { 0x1e8b, 0x1e8b, 0x1e8a },
+ { 0x1e8d, 0x1e8d, 0x1e8c },
+ { 0x1e8f, 0x1e8f, 0x1e8e },
+ { 0x1e91, 0x1e91, 0x1e90 },
+ { 0x1e93, 0x1e93, 0x1e92 },
+ { 0x1e95, 0x1e95, 0x1e94 },
+ { 0x1e9b, 0x1e9b, 0x1e60 },
+ { 0x1ea1, 0x1ea1, 0x1ea0 },
+ { 0x1ea3, 0x1ea3, 0x1ea2 },
+ { 0x1ea5, 0x1ea5, 0x1ea4 },
+ { 0x1ea7, 0x1ea7, 0x1ea6 },
+ { 0x1ea9, 0x1ea9, 0x1ea8 },
+ { 0x1eab, 0x1eab, 0x1eaa },
+ { 0x1ead, 0x1ead, 0x1eac },
+ { 0x1eaf, 0x1eaf, 0x1eae },
+ { 0x1eb1, 0x1eb1, 0x1eb0 },
+ { 0x1eb3, 0x1eb3, 0x1eb2 },
+ { 0x1eb5, 0x1eb5, 0x1eb4 },
+ { 0x1eb7, 0x1eb7, 0x1eb6 },
+ { 0x1eb9, 0x1eb9, 0x1eb8 },
+ { 0x1ebb, 0x1ebb, 0x1eba },
+ { 0x1ebd, 0x1ebd, 0x1ebc },
+ { 0x1ebf, 0x1ebf, 0x1ebe },
+ { 0x1ec1, 0x1ec1, 0x1ec0 },
+ { 0x1ec3, 0x1ec3, 0x1ec2 },
+ { 0x1ec5, 0x1ec5, 0x1ec4 },
+ { 0x1ec7, 0x1ec7, 0x1ec6 },
+ { 0x1ec9, 0x1ec9, 0x1ec8 },
+ { 0x1ecb, 0x1ecb, 0x1eca },
+ { 0x1ecd, 0x1ecd, 0x1ecc },
+ { 0x1ecf, 0x1ecf, 0x1ece },
+ { 0x1ed1, 0x1ed1, 0x1ed0 },
+ { 0x1ed3, 0x1ed3, 0x1ed2 },
+ { 0x1ed5, 0x1ed5, 0x1ed4 },
+ { 0x1ed7, 0x1ed7, 0x1ed6 },
+ { 0x1ed9, 0x1ed9, 0x1ed8 },
+ { 0x1edb, 0x1edb, 0x1eda },
+ { 0x1edd, 0x1edd, 0x1edc },
+ { 0x1edf, 0x1edf, 0x1ede },
+ { 0x1ee1, 0x1ee1, 0x1ee0 },
+ { 0x1ee3, 0x1ee3, 0x1ee2 },
+ { 0x1ee5, 0x1ee5, 0x1ee4 },
+ { 0x1ee7, 0x1ee7, 0x1ee6 },
+ { 0x1ee9, 0x1ee9, 0x1ee8 },
+ { 0x1eeb, 0x1eeb, 0x1eea },
+ { 0x1eed, 0x1eed, 0x1eec },
+ { 0x1eef, 0x1eef, 0x1eee },
+ { 0x1ef1, 0x1ef1, 0x1ef0 },
+ { 0x1ef3, 0x1ef3, 0x1ef2 },
+ { 0x1ef5, 0x1ef5, 0x1ef4 },
+ { 0x1ef7, 0x1ef7, 0x1ef6 },
+ { 0x1ef9, 0x1ef9, 0x1ef8 },
+ { 0x1efb, 0x1efb, 0x1efa },
+ { 0x1efd, 0x1efd, 0x1efc },
+ { 0x1eff, 0x1eff, 0x1efe },
+ { 0x1f00, 0x1f07, 0x1f08 },
+ { 0x1f10, 0x1f15, 0x1f18 },
+ { 0x1f20, 0x1f27, 0x1f28 },
+ { 0x1f30, 0x1f37, 0x1f38 },
+ { 0x1f40, 0x1f45, 0x1f48 },
+ { 0x1f51, 0x1f51, 0x1f59 },
+ { 0x1f53, 0x1f53, 0x1f5b },
+ { 0x1f55, 0x1f55, 0x1f5d },
+ { 0x1f57, 0x1f57, 0x1f5f },
+ { 0x1f60, 0x1f67, 0x1f68 },
+ { 0x1f70, 0x1f71, 0x1fba },
+ { 0x1f72, 0x1f75, 0x1fc8 },
+ { 0x1f76, 0x1f77, 0x1fda },
+ { 0x1f78, 0x1f79, 0x1ff8 },
+ { 0x1f7a, 0x1f7b, 0x1fea },
+ { 0x1f7c, 0x1f7d, 0x1ffa },
+ { 0x1f80, 0x1f87, 0x1f88 },
+ { 0x1f90, 0x1f97, 0x1f98 },
+ { 0x1fa0, 0x1fa7, 0x1fa8 },
+ { 0x1fb0, 0x1fb1, 0x1fb8 },
+ { 0x1fb3, 0x1fb3, 0x1fbc },
+ { 0x1fbe, 0x1fbe, 0x399 },
+ { 0x1fc3, 0x1fc3, 0x1fcc },
+ { 0x1fd0, 0x1fd1, 0x1fd8 },
+ { 0x1fe0, 0x1fe1, 0x1fe8 },
+ { 0x1fe5, 0x1fe5, 0x1fec },
+ { 0x1ff3, 0x1ff3, 0x1ffc },
+ { 0x214e, 0x214e, 0x2132 },
+ { 0x2170, 0x217f, 0x2160 },
+ { 0x2184, 0x2184, 0x2183 },
+ { 0x24d0, 0x24e9, 0x24b6 },
+ { 0x2c30, 0x2c5f, 0x2c00 },
+ { 0x2c61, 0x2c61, 0x2c60 },
+ { 0x2c65, 0x2c65, 0x23a },
+ { 0x2c66, 0x2c66, 0x23e },
+ { 0x2c68, 0x2c68, 0x2c67 },
+ { 0x2c6a, 0x2c6a, 0x2c69 },
+ { 0x2c6c, 0x2c6c, 0x2c6b },
+ { 0x2c73, 0x2c73, 0x2c72 },
+ { 0x2c76, 0x2c76, 0x2c75 },
+ { 0x2c81, 0x2c81, 0x2c80 },
+ { 0x2c83, 0x2c83, 0x2c82 },
+ { 0x2c85, 0x2c85, 0x2c84 },
+ { 0x2c87, 0x2c87, 0x2c86 },
+ { 0x2c89, 0x2c89, 0x2c88 },
+ { 0x2c8b, 0x2c8b, 0x2c8a },
+ { 0x2c8d, 0x2c8d, 0x2c8c },
+ { 0x2c8f, 0x2c8f, 0x2c8e },
+ { 0x2c91, 0x2c91, 0x2c90 },
+ { 0x2c93, 0x2c93, 0x2c92 },
+ { 0x2c95, 0x2c95, 0x2c94 },
+ { 0x2c97, 0x2c97, 0x2c96 },
+ { 0x2c99, 0x2c99, 0x2c98 },
+ { 0x2c9b, 0x2c9b, 0x2c9a },
+ { 0x2c9d, 0x2c9d, 0x2c9c },
+ { 0x2c9f, 0x2c9f, 0x2c9e },
+ { 0x2ca1, 0x2ca1, 0x2ca0 },
+ { 0x2ca3, 0x2ca3, 0x2ca2 },
+ { 0x2ca5, 0x2ca5, 0x2ca4 },
+ { 0x2ca7, 0x2ca7, 0x2ca6 },
+ { 0x2ca9, 0x2ca9, 0x2ca8 },
+ { 0x2cab, 0x2cab, 0x2caa },
+ { 0x2cad, 0x2cad, 0x2cac },
+ { 0x2caf, 0x2caf, 0x2cae },
+ { 0x2cb1, 0x2cb1, 0x2cb0 },
+ { 0x2cb3, 0x2cb3, 0x2cb2 },
+ { 0x2cb5, 0x2cb5, 0x2cb4 },
+ { 0x2cb7, 0x2cb7, 0x2cb6 },
+ { 0x2cb9, 0x2cb9, 0x2cb8 },
+ { 0x2cbb, 0x2cbb, 0x2cba },
+ { 0x2cbd, 0x2cbd, 0x2cbc },
+ { 0x2cbf, 0x2cbf, 0x2cbe },
+ { 0x2cc1, 0x2cc1, 0x2cc0 },
+ { 0x2cc3, 0x2cc3, 0x2cc2 },
+ { 0x2cc5, 0x2cc5, 0x2cc4 },
+ { 0x2cc7, 0x2cc7, 0x2cc6 },
+ { 0x2cc9, 0x2cc9, 0x2cc8 },
+ { 0x2ccb, 0x2ccb, 0x2cca },
+ { 0x2ccd, 0x2ccd, 0x2ccc },
+ { 0x2ccf, 0x2ccf, 0x2cce },
+ { 0x2cd1, 0x2cd1, 0x2cd0 },
+ { 0x2cd3, 0x2cd3, 0x2cd2 },
+ { 0x2cd5, 0x2cd5, 0x2cd4 },
+ { 0x2cd7, 0x2cd7, 0x2cd6 },
+ { 0x2cd9, 0x2cd9, 0x2cd8 },
+ { 0x2cdb, 0x2cdb, 0x2cda },
+ { 0x2cdd, 0x2cdd, 0x2cdc },
+ { 0x2cdf, 0x2cdf, 0x2cde },
+ { 0x2ce1, 0x2ce1, 0x2ce0 },
+ { 0x2ce3, 0x2ce3, 0x2ce2 },
+ { 0x2cec, 0x2cec, 0x2ceb },
+ { 0x2cee, 0x2cee, 0x2ced },
+ { 0x2cf3, 0x2cf3, 0x2cf2 },
+ { 0x2d00, 0x2d25, 0x10a0 },
+ { 0x2d27, 0x2d27, 0x10c7 },
+ { 0x2d2d, 0x2d2d, 0x10cd },
+ { 0xa641, 0xa641, 0xa640 },
+ { 0xa643, 0xa643, 0xa642 },
+ { 0xa645, 0xa645, 0xa644 },
+ { 0xa647, 0xa647, 0xa646 },
+ { 0xa649, 0xa649, 0xa648 },
+ { 0xa64b, 0xa64b, 0xa64a },
+ { 0xa64d, 0xa64d, 0xa64c },
+ { 0xa64f, 0xa64f, 0xa64e },
+ { 0xa651, 0xa651, 0xa650 },
+ { 0xa653, 0xa653, 0xa652 },
+ { 0xa655, 0xa655, 0xa654 },
+ { 0xa657, 0xa657, 0xa656 },
+ { 0xa659, 0xa659, 0xa658 },
+ { 0xa65b, 0xa65b, 0xa65a },
+ { 0xa65d, 0xa65d, 0xa65c },
+ { 0xa65f, 0xa65f, 0xa65e },
+ { 0xa661, 0xa661, 0xa660 },
+ { 0xa663, 0xa663, 0xa662 },
+ { 0xa665, 0xa665, 0xa664 },
+ { 0xa667, 0xa667, 0xa666 },
+ { 0xa669, 0xa669, 0xa668 },
+ { 0xa66b, 0xa66b, 0xa66a },
+ { 0xa66d, 0xa66d, 0xa66c },
+ { 0xa681, 0xa681, 0xa680 },
+ { 0xa683, 0xa683, 0xa682 },
+ { 0xa685, 0xa685, 0xa684 },
+ { 0xa687, 0xa687, 0xa686 },
+ { 0xa689, 0xa689, 0xa688 },
+ { 0xa68b, 0xa68b, 0xa68a },
+ { 0xa68d, 0xa68d, 0xa68c },
+ { 0xa68f, 0xa68f, 0xa68e },
+ { 0xa691, 0xa691, 0xa690 },
+ { 0xa693, 0xa693, 0xa692 },
+ { 0xa695, 0xa695, 0xa694 },
+ { 0xa697, 0xa697, 0xa696 },
+ { 0xa699, 0xa699, 0xa698 },
+ { 0xa69b, 0xa69b, 0xa69a },
+ { 0xa723, 0xa723, 0xa722 },
+ { 0xa725, 0xa725, 0xa724 },
+ { 0xa727, 0xa727, 0xa726 },
+ { 0xa729, 0xa729, 0xa728 },
+ { 0xa72b, 0xa72b, 0xa72a },
+ { 0xa72d, 0xa72d, 0xa72c },
+ { 0xa72f, 0xa72f, 0xa72e },
+ { 0xa733, 0xa733, 0xa732 },
+ { 0xa735, 0xa735, 0xa734 },
+ { 0xa737, 0xa737, 0xa736 },
+ { 0xa739, 0xa739, 0xa738 },
+ { 0xa73b, 0xa73b, 0xa73a },
+ { 0xa73d, 0xa73d, 0xa73c },
+ { 0xa73f, 0xa73f, 0xa73e },
+ { 0xa741, 0xa741, 0xa740 },
+ { 0xa743, 0xa743, 0xa742 },
+ { 0xa745, 0xa745, 0xa744 },
+ { 0xa747, 0xa747, 0xa746 },
+ { 0xa749, 0xa749, 0xa748 },
+ { 0xa74b, 0xa74b, 0xa74a },
+ { 0xa74d, 0xa74d, 0xa74c },
+ { 0xa74f, 0xa74f, 0xa74e },
+ { 0xa751, 0xa751, 0xa750 },
+ { 0xa753, 0xa753, 0xa752 },
+ { 0xa755, 0xa755, 0xa754 },
+ { 0xa757, 0xa757, 0xa756 },
+ { 0xa759, 0xa759, 0xa758 },
+ { 0xa75b, 0xa75b, 0xa75a },
+ { 0xa75d, 0xa75d, 0xa75c },
+ { 0xa75f, 0xa75f, 0xa75e },
+ { 0xa761, 0xa761, 0xa760 },
+ { 0xa763, 0xa763, 0xa762 },
+ { 0xa765, 0xa765, 0xa764 },
+ { 0xa767, 0xa767, 0xa766 },
+ { 0xa769, 0xa769, 0xa768 },
+ { 0xa76b, 0xa76b, 0xa76a },
+ { 0xa76d, 0xa76d, 0xa76c },
+ { 0xa76f, 0xa76f, 0xa76e },
+ { 0xa77a, 0xa77a, 0xa779 },
+ { 0xa77c, 0xa77c, 0xa77b },
+ { 0xa77f, 0xa77f, 0xa77e },
+ { 0xa781, 0xa781, 0xa780 },
+ { 0xa783, 0xa783, 0xa782 },
+ { 0xa785, 0xa785, 0xa784 },
+ { 0xa787, 0xa787, 0xa786 },
+ { 0xa78c, 0xa78c, 0xa78b },
+ { 0xa791, 0xa791, 0xa790 },
+ { 0xa793, 0xa793, 0xa792 },
+ { 0xa794, 0xa794, 0xa7c4 },
+ { 0xa797, 0xa797, 0xa796 },
+ { 0xa799, 0xa799, 0xa798 },
+ { 0xa79b, 0xa79b, 0xa79a },
+ { 0xa79d, 0xa79d, 0xa79c },
+ { 0xa79f, 0xa79f, 0xa79e },
+ { 0xa7a1, 0xa7a1, 0xa7a0 },
+ { 0xa7a3, 0xa7a3, 0xa7a2 },
+ { 0xa7a5, 0xa7a5, 0xa7a4 },
+ { 0xa7a7, 0xa7a7, 0xa7a6 },
+ { 0xa7a9, 0xa7a9, 0xa7a8 },
+ { 0xa7b5, 0xa7b5, 0xa7b4 },
+ { 0xa7b7, 0xa7b7, 0xa7b6 },
+ { 0xa7b9, 0xa7b9, 0xa7b8 },
+ { 0xa7bb, 0xa7bb, 0xa7ba },
+ { 0xa7bd, 0xa7bd, 0xa7bc },
+ { 0xa7bf, 0xa7bf, 0xa7be },
+ { 0xa7c1, 0xa7c1, 0xa7c0 },
+ { 0xa7c3, 0xa7c3, 0xa7c2 },
+ { 0xa7c8, 0xa7c8, 0xa7c7 },
+ { 0xa7ca, 0xa7ca, 0xa7c9 },
+ { 0xa7cd, 0xa7cd, 0xa7cc },
+ { 0xa7cf, 0xa7cf, 0xa7ce },
+ { 0xa7d1, 0xa7d1, 0xa7d0 },
+ { 0xa7d3, 0xa7d3, 0xa7d2 },
+ { 0xa7d5, 0xa7d5, 0xa7d4 },
+ { 0xa7d7, 0xa7d7, 0xa7d6 },
+ { 0xa7d9, 0xa7d9, 0xa7d8 },
+ { 0xa7db, 0xa7db, 0xa7da },
+ { 0xa7f6, 0xa7f6, 0xa7f5 },
+ { 0xab53, 0xab53, 0xa7b3 },
+ { 0xab70, 0xabbf, 0x13a0 },
+ { 0xff41, 0xff5a, 0xff21 },
+ { 0x10428, 0x1044f, 0x10400 },
+ { 0x104d8, 0x104fb, 0x104b0 },
+ { 0x10597, 0x105a1, 0x10570 },
+ { 0x105a3, 0x105b1, 0x1057c },
+ { 0x105b3, 0x105b9, 0x1058c },
+ { 0x105bb, 0x105bc, 0x10594 },
+ { 0x10cc0, 0x10cf2, 0x10c80 },
+ { 0x10d70, 0x10d85, 0x10d50 },
+ { 0x118c0, 0x118df, 0x118a0 },
+ { 0x16e60, 0x16e7f, 0x16e40 },
+ { 0x16ebb, 0x16ed3, 0x16ea0 },
+ { 0x1e922, 0x1e943, 0x1e900 },
+};
+static const int fold1[][2] = {
+ { 0x41, 0x61 },
+ { 0x42, 0x62 },
+ { 0x43, 0x63 },
+ { 0x44, 0x64 },
+ { 0x45, 0x65 },
+ { 0x46, 0x66 },
+ { 0x47, 0x67 },
+ { 0x48, 0x68 },
+ { 0x49, 0x69 },
+ { 0x4a, 0x6a },
+ { 0x4b, 0x6b },
+ { 0x4c, 0x6c },
+ { 0x4d, 0x6d },
+ { 0x4e, 0x6e },
+ { 0x4f, 0x6f },
+ { 0x50, 0x70 },
+ { 0x51, 0x71 },
+ { 0x52, 0x72 },
+ { 0x53, 0x73 },
+ { 0x54, 0x74 },
+ { 0x55, 0x75 },
+ { 0x56, 0x76 },
+ { 0x57, 0x77 },
+ { 0x58, 0x78 },
+ { 0x59, 0x79 },
+ { 0x5a, 0x7a },
+ { 0xb5, 0x3bc },
+ { 0xc0, 0xe0 },
+ { 0xc1, 0xe1 },
+ { 0xc2, 0xe2 },
+ { 0xc3, 0xe3 },
+ { 0xc4, 0xe4 },
+ { 0xc5, 0xe5 },
+ { 0xc6, 0xe6 },
+ { 0xc7, 0xe7 },
+ { 0xc8, 0xe8 },
+ { 0xc9, 0xe9 },
+ { 0xca, 0xea },
+ { 0xcb, 0xeb },
+ { 0xcc, 0xec },
+ { 0xcd, 0xed },
+ { 0xce, 0xee },
+ { 0xcf, 0xef },
+ { 0xd0, 0xf0 },
+ { 0xd1, 0xf1 },
+ { 0xd2, 0xf2 },
+ { 0xd3, 0xf3 },
+ { 0xd4, 0xf4 },
+ { 0xd5, 0xf5 },
+ { 0xd6, 0xf6 },
+ { 0xd8, 0xf8 },
+ { 0xd9, 0xf9 },
+ { 0xda, 0xfa },
+ { 0xdb, 0xfb },
+ { 0xdc, 0xfc },
+ { 0xdd, 0xfd },
+ { 0xde, 0xfe },
+ { 0x100, 0x101 },
+ { 0x102, 0x103 },
+ { 0x104, 0x105 },
+ { 0x106, 0x107 },
+ { 0x108, 0x109 },
+ { 0x10a, 0x10b },
+ { 0x10c, 0x10d },
+ { 0x10e, 0x10f },
+ { 0x110, 0x111 },
+ { 0x112, 0x113 },
+ { 0x114, 0x115 },
+ { 0x116, 0x117 },
+ { 0x118, 0x119 },
+ { 0x11a, 0x11b },
+ { 0x11c, 0x11d },
+ { 0x11e, 0x11f },
+ { 0x120, 0x121 },
+ { 0x122, 0x123 },
+ { 0x124, 0x125 },
+ { 0x126, 0x127 },
+ { 0x128, 0x129 },
+ { 0x12a, 0x12b },
+ { 0x12c, 0x12d },
+ { 0x12e, 0x12f },
+ { 0x132, 0x133 },
+ { 0x134, 0x135 },
+ { 0x136, 0x137 },
+ { 0x139, 0x13a },
+ { 0x13b, 0x13c },
+ { 0x13d, 0x13e },
+ { 0x13f, 0x140 },
+ { 0x141, 0x142 },
+ { 0x143, 0x144 },
+ { 0x145, 0x146 },
+ { 0x147, 0x148 },
+ { 0x14a, 0x14b },
+ { 0x14c, 0x14d },
+ { 0x14e, 0x14f },
+ { 0x150, 0x151 },
+ { 0x152, 0x153 },
+ { 0x154, 0x155 },
+ { 0x156, 0x157 },
+ { 0x158, 0x159 },
+ { 0x15a, 0x15b },
+ { 0x15c, 0x15d },
+ { 0x15e, 0x15f },
+ { 0x160, 0x161 },
+ { 0x162, 0x163 },
+ { 0x164, 0x165 },
+ { 0x166, 0x167 },
+ { 0x168, 0x169 },
+ { 0x16a, 0x16b },
+ { 0x16c, 0x16d },
+ { 0x16e, 0x16f },
+ { 0x170, 0x171 },
+ { 0x172, 0x173 },
+ { 0x174, 0x175 },
+ { 0x176, 0x177 },
+ { 0x178, 0xff },
+ { 0x179, 0x17a },
+ { 0x17b, 0x17c },
+ { 0x17d, 0x17e },
+ { 0x17f, 0x73 },
+ { 0x181, 0x253 },
+ { 0x182, 0x183 },
+ { 0x184, 0x185 },
+ { 0x186, 0x254 },
+ { 0x187, 0x188 },
+ { 0x189, 0x256 },
+ { 0x18a, 0x257 },
+ { 0x18b, 0x18c },
+ { 0x18e, 0x1dd },
+ { 0x18f, 0x259 },
+ { 0x190, 0x25b },
+ { 0x191, 0x192 },
+ { 0x193, 0x260 },
+ { 0x194, 0x263 },
+ { 0x196, 0x269 },
+ { 0x197, 0x268 },
+ { 0x198, 0x199 },
+ { 0x19c, 0x26f },
+ { 0x19d, 0x272 },
+ { 0x19f, 0x275 },
+ { 0x1a0, 0x1a1 },
+ { 0x1a2, 0x1a3 },
+ { 0x1a4, 0x1a5 },
+ { 0x1a6, 0x280 },
+ { 0x1a7, 0x1a8 },
+ { 0x1a9, 0x283 },
+ { 0x1ac, 0x1ad },
+ { 0x1ae, 0x288 },
+ { 0x1af, 0x1b0 },
+ { 0x1b1, 0x28a },
+ { 0x1b2, 0x28b },
+ { 0x1b3, 0x1b4 },
+ { 0x1b5, 0x1b6 },
+ { 0x1b7, 0x292 },
+ { 0x1b8, 0x1b9 },
+ { 0x1bc, 0x1bd },
+ { 0x1c4, 0x1c6 },
+ { 0x1c5, 0x1c6 },
+ { 0x1c7, 0x1c9 },
+ { 0x1c8, 0x1c9 },
+ { 0x1ca, 0x1cc },
+ { 0x1cb, 0x1cc },
+ { 0x1cd, 0x1ce },
+ { 0x1cf, 0x1d0 },
+ { 0x1d1, 0x1d2 },
+ { 0x1d3, 0x1d4 },
+ { 0x1d5, 0x1d6 },
+ { 0x1d7, 0x1d8 },
+ { 0x1d9, 0x1da },
+ { 0x1db, 0x1dc },
+ { 0x1de, 0x1df },
+ { 0x1e0, 0x1e1 },
+ { 0x1e2, 0x1e3 },
+ { 0x1e4, 0x1e5 },
+ { 0x1e6, 0x1e7 },
+ { 0x1e8, 0x1e9 },
+ { 0x1ea, 0x1eb },
+ { 0x1ec, 0x1ed },
+ { 0x1ee, 0x1ef },
+ { 0x1f1, 0x1f3 },
+ { 0x1f2, 0x1f3 },
+ { 0x1f4, 0x1f5 },
+ { 0x1f6, 0x195 },
+ { 0x1f7, 0x1bf },
+ { 0x1f8, 0x1f9 },
+ { 0x1fa, 0x1fb },
+ { 0x1fc, 0x1fd },
+ { 0x1fe, 0x1ff },
+ { 0x200, 0x201 },
+ { 0x202, 0x203 },
+ { 0x204, 0x205 },
+ { 0x206, 0x207 },
+ { 0x208, 0x209 },
+ { 0x20a, 0x20b },
+ { 0x20c, 0x20d },
+ { 0x20e, 0x20f },
+ { 0x210, 0x211 },
+ { 0x212, 0x213 },
+ { 0x214, 0x215 },
+ { 0x216, 0x217 },
+ { 0x218, 0x219 },
+ { 0x21a, 0x21b },
+ { 0x21c, 0x21d },
+ { 0x21e, 0x21f },
+ { 0x220, 0x19e },
+ { 0x222, 0x223 },
+ { 0x224, 0x225 },
+ { 0x226, 0x227 },
+ { 0x228, 0x229 },
+ { 0x22a, 0x22b },
+ { 0x22c, 0x22d },
+ { 0x22e, 0x22f },
+ { 0x230, 0x231 },
+ { 0x232, 0x233 },
+ { 0x23a, 0x2c65 },
+ { 0x23b, 0x23c },
+ { 0x23d, 0x19a },
+ { 0x23e, 0x2c66 },
+ { 0x241, 0x242 },
+ { 0x243, 0x180 },
+ { 0x244, 0x289 },
+ { 0x245, 0x28c },
+ { 0x246, 0x247 },
+ { 0x248, 0x249 },
+ { 0x24a, 0x24b },
+ { 0x24c, 0x24d },
+ { 0x24e, 0x24f },
+ { 0x345, 0x3b9 },
+ { 0x370, 0x371 },
+ { 0x372, 0x373 },
+ { 0x376, 0x377 },
+ { 0x37f, 0x3f3 },
+ { 0x386, 0x3ac },
+ { 0x388, 0x3ad },
+ { 0x389, 0x3ae },
+ { 0x38a, 0x3af },
+ { 0x38c, 0x3cc },
+ { 0x38e, 0x3cd },
+ { 0x38f, 0x3ce },
+ { 0x391, 0x3b1 },
+ { 0x392, 0x3b2 },
+ { 0x393, 0x3b3 },
+ { 0x394, 0x3b4 },
+ { 0x395, 0x3b5 },
+ { 0x396, 0x3b6 },
+ { 0x397, 0x3b7 },
+ { 0x398, 0x3b8 },
+ { 0x399, 0x3b9 },
+ { 0x39a, 0x3ba },
+ { 0x39b, 0x3bb },
+ { 0x39c, 0x3bc },
+ { 0x39d, 0x3bd },
+ { 0x39e, 0x3be },
+ { 0x39f, 0x3bf },
+ { 0x3a0, 0x3c0 },
+ { 0x3a1, 0x3c1 },
+ { 0x3a3, 0x3c3 },
+ { 0x3a4, 0x3c4 },
+ { 0x3a5, 0x3c5 },
+ { 0x3a6, 0x3c6 },
+ { 0x3a7, 0x3c7 },
+ { 0x3a8, 0x3c8 },
+ { 0x3a9, 0x3c9 },
+ { 0x3aa, 0x3ca },
+ { 0x3ab, 0x3cb },
+ { 0x3c2, 0x3c3 },
+ { 0x3cf, 0x3d7 },
+ { 0x3d0, 0x3b2 },
+ { 0x3d1, 0x3b8 },
+ { 0x3d5, 0x3c6 },
+ { 0x3d6, 0x3c0 },
+ { 0x3d8, 0x3d9 },
+ { 0x3da, 0x3db },
+ { 0x3dc, 0x3dd },
+ { 0x3de, 0x3df },
+ { 0x3e0, 0x3e1 },
+ { 0x3e2, 0x3e3 },
+ { 0x3e4, 0x3e5 },
+ { 0x3e6, 0x3e7 },
+ { 0x3e8, 0x3e9 },
+ { 0x3ea, 0x3eb },
+ { 0x3ec, 0x3ed },
+ { 0x3ee, 0x3ef },
+ { 0x3f0, 0x3ba },
+ { 0x3f1, 0x3c1 },
+ { 0x3f4, 0x3b8 },
+ { 0x3f5, 0x3b5 },
+ { 0x3f7, 0x3f8 },
+ { 0x3f9, 0x3f2 },
+ { 0x3fa, 0x3fb },
+ { 0x3fd, 0x37b },
+ { 0x3fe, 0x37c },
+ { 0x3ff, 0x37d },
+ { 0x400, 0x450 },
+ { 0x401, 0x451 },
+ { 0x402, 0x452 },
+ { 0x403, 0x453 },
+ { 0x404, 0x454 },
+ { 0x405, 0x455 },
+ { 0x406, 0x456 },
+ { 0x407, 0x457 },
+ { 0x408, 0x458 },
+ { 0x409, 0x459 },
+ { 0x40a, 0x45a },
+ { 0x40b, 0x45b },
+ { 0x40c, 0x45c },
+ { 0x40d, 0x45d },
+ { 0x40e, 0x45e },
+ { 0x40f, 0x45f },
+ { 0x410, 0x430 },
+ { 0x411, 0x431 },
+ { 0x412, 0x432 },
+ { 0x413, 0x433 },
+ { 0x414, 0x434 },
+ { 0x415, 0x435 },
+ { 0x416, 0x436 },
+ { 0x417, 0x437 },
+ { 0x418, 0x438 },
+ { 0x419, 0x439 },
+ { 0x41a, 0x43a },
+ { 0x41b, 0x43b },
+ { 0x41c, 0x43c },
+ { 0x41d, 0x43d },
+ { 0x41e, 0x43e },
+ { 0x41f, 0x43f },
+ { 0x420, 0x440 },
+ { 0x421, 0x441 },
+ { 0x422, 0x442 },
+ { 0x423, 0x443 },
+ { 0x424, 0x444 },
+ { 0x425, 0x445 },
+ { 0x426, 0x446 },
+ { 0x427, 0x447 },
+ { 0x428, 0x448 },
+ { 0x429, 0x449 },
+ { 0x42a, 0x44a },
+ { 0x42b, 0x44b },
+ { 0x42c, 0x44c },
+ { 0x42d, 0x44d },
+ { 0x42e, 0x44e },
+ { 0x42f, 0x44f },
+ { 0x460, 0x461 },
+ { 0x462, 0x463 },
+ { 0x464, 0x465 },
+ { 0x466, 0x467 },
+ { 0x468, 0x469 },
+ { 0x46a, 0x46b },
+ { 0x46c, 0x46d },
+ { 0x46e, 0x46f },
+ { 0x470, 0x471 },
+ { 0x472, 0x473 },
+ { 0x474, 0x475 },
+ { 0x476, 0x477 },
+ { 0x478, 0x479 },
+ { 0x47a, 0x47b },
+ { 0x47c, 0x47d },
+ { 0x47e, 0x47f },
+ { 0x480, 0x481 },
+ { 0x48a, 0x48b },
+ { 0x48c, 0x48d },
+ { 0x48e, 0x48f },
+ { 0x490, 0x491 },
+ { 0x492, 0x493 },
+ { 0x494, 0x495 },
+ { 0x496, 0x497 },
+ { 0x498, 0x499 },
+ { 0x49a, 0x49b },
+ { 0x49c, 0x49d },
+ { 0x49e, 0x49f },
+ { 0x4a0, 0x4a1 },
+ { 0x4a2, 0x4a3 },
+ { 0x4a4, 0x4a5 },
+ { 0x4a6, 0x4a7 },
+ { 0x4a8, 0x4a9 },
+ { 0x4aa, 0x4ab },
+ { 0x4ac, 0x4ad },
+ { 0x4ae, 0x4af },
+ { 0x4b0, 0x4b1 },
+ { 0x4b2, 0x4b3 },
+ { 0x4b4, 0x4b5 },
+ { 0x4b6, 0x4b7 },
+ { 0x4b8, 0x4b9 },
+ { 0x4ba, 0x4bb },
+ { 0x4bc, 0x4bd },
+ { 0x4be, 0x4bf },
+ { 0x4c0, 0x4cf },
+ { 0x4c1, 0x4c2 },
+ { 0x4c3, 0x4c4 },
+ { 0x4c5, 0x4c6 },
+ { 0x4c7, 0x4c8 },
+ { 0x4c9, 0x4ca },
+ { 0x4cb, 0x4cc },
+ { 0x4cd, 0x4ce },
+ { 0x4d0, 0x4d1 },
+ { 0x4d2, 0x4d3 },
+ { 0x4d4, 0x4d5 },
+ { 0x4d6, 0x4d7 },
+ { 0x4d8, 0x4d9 },
+ { 0x4da, 0x4db },
+ { 0x4dc, 0x4dd },
+ { 0x4de, 0x4df },
+ { 0x4e0, 0x4e1 },
+ { 0x4e2, 0x4e3 },
+ { 0x4e4, 0x4e5 },
+ { 0x4e6, 0x4e7 },
+ { 0x4e8, 0x4e9 },
+ { 0x4ea, 0x4eb },
+ { 0x4ec, 0x4ed },
+ { 0x4ee, 0x4ef },
+ { 0x4f0, 0x4f1 },
+ { 0x4f2, 0x4f3 },
+ { 0x4f4, 0x4f5 },
+ { 0x4f6, 0x4f7 },
+ { 0x4f8, 0x4f9 },
+ { 0x4fa, 0x4fb },
+ { 0x4fc, 0x4fd },
+ { 0x4fe, 0x4ff },
+ { 0x500, 0x501 },
+ { 0x502, 0x503 },
+ { 0x504, 0x505 },
+ { 0x506, 0x507 },
+ { 0x508, 0x509 },
+ { 0x50a, 0x50b },
+ { 0x50c, 0x50d },
+ { 0x50e, 0x50f },
+ { 0x510, 0x511 },
+ { 0x512, 0x513 },
+ { 0x514, 0x515 },
+ { 0x516, 0x517 },
+ { 0x518, 0x519 },
+ { 0x51a, 0x51b },
+ { 0x51c, 0x51d },
+ { 0x51e, 0x51f },
+ { 0x520, 0x521 },
+ { 0x522, 0x523 },
+ { 0x524, 0x525 },
+ { 0x526, 0x527 },
+ { 0x528, 0x529 },
+ { 0x52a, 0x52b },
+ { 0x52c, 0x52d },
+ { 0x52e, 0x52f },
+ { 0x531, 0x561 },
+ { 0x532, 0x562 },
+ { 0x533, 0x563 },
+ { 0x534, 0x564 },
+ { 0x535, 0x565 },
+ { 0x536, 0x566 },
+ { 0x537, 0x567 },
+ { 0x538, 0x568 },
+ { 0x539, 0x569 },
+ { 0x53a, 0x56a },
+ { 0x53b, 0x56b },
+ { 0x53c, 0x56c },
+ { 0x53d, 0x56d },
+ { 0x53e, 0x56e },
+ { 0x53f, 0x56f },
+ { 0x540, 0x570 },
+ { 0x541, 0x571 },
+ { 0x542, 0x572 },
+ { 0x543, 0x573 },
+ { 0x544, 0x574 },
+ { 0x545, 0x575 },
+ { 0x546, 0x576 },
+ { 0x547, 0x577 },
+ { 0x548, 0x578 },
+ { 0x549, 0x579 },
+ { 0x54a, 0x57a },
+ { 0x54b, 0x57b },
+ { 0x54c, 0x57c },
+ { 0x54d, 0x57d },
+ { 0x54e, 0x57e },
+ { 0x54f, 0x57f },
+ { 0x550, 0x580 },
+ { 0x551, 0x581 },
+ { 0x552, 0x582 },
+ { 0x553, 0x583 },
+ { 0x554, 0x584 },
+ { 0x555, 0x585 },
+ { 0x556, 0x586 },
+ { 0x10a0, 0x2d00 },
+ { 0x10a1, 0x2d01 },
+ { 0x10a2, 0x2d02 },
+ { 0x10a3, 0x2d03 },
+ { 0x10a4, 0x2d04 },
+ { 0x10a5, 0x2d05 },
+ { 0x10a6, 0x2d06 },
+ { 0x10a7, 0x2d07 },
+ { 0x10a8, 0x2d08 },
+ { 0x10a9, 0x2d09 },
+ { 0x10aa, 0x2d0a },
+ { 0x10ab, 0x2d0b },
+ { 0x10ac, 0x2d0c },
+ { 0x10ad, 0x2d0d },
+ { 0x10ae, 0x2d0e },
+ { 0x10af, 0x2d0f },
+ { 0x10b0, 0x2d10 },
+ { 0x10b1, 0x2d11 },
+ { 0x10b2, 0x2d12 },
+ { 0x10b3, 0x2d13 },
+ { 0x10b4, 0x2d14 },
+ { 0x10b5, 0x2d15 },
+ { 0x10b6, 0x2d16 },
+ { 0x10b7, 0x2d17 },
+ { 0x10b8, 0x2d18 },
+ { 0x10b9, 0x2d19 },
+ { 0x10ba, 0x2d1a },
+ { 0x10bb, 0x2d1b },
+ { 0x10bc, 0x2d1c },
+ { 0x10bd, 0x2d1d },
+ { 0x10be, 0x2d1e },
+ { 0x10bf, 0x2d1f },
+ { 0x10c0, 0x2d20 },
+ { 0x10c1, 0x2d21 },
+ { 0x10c2, 0x2d22 },
+ { 0x10c3, 0x2d23 },
+ { 0x10c4, 0x2d24 },
+ { 0x10c5, 0x2d25 },
+ { 0x10c7, 0x2d27 },
+ { 0x10cd, 0x2d2d },
+ { 0x13f8, 0x13f0 },
+ { 0x13f9, 0x13f1 },
+ { 0x13fa, 0x13f2 },
+ { 0x13fb, 0x13f3 },
+ { 0x13fc, 0x13f4 },
+ { 0x13fd, 0x13f5 },
+ { 0x1c80, 0x432 },
+ { 0x1c81, 0x434 },
+ { 0x1c82, 0x43e },
+ { 0x1c83, 0x441 },
+ { 0x1c84, 0x442 },
+ { 0x1c85, 0x442 },
+ { 0x1c86, 0x44a },
+ { 0x1c87, 0x463 },
+ { 0x1c88, 0xa64b },
+ { 0x1c89, 0x1c8a },
+ { 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 },
+ { 0x1cbd, 0x10fd },
+ { 0x1cbe, 0x10fe },
+ { 0x1cbf, 0x10ff },
+ { 0x1e00, 0x1e01 },
+ { 0x1e02, 0x1e03 },
+ { 0x1e04, 0x1e05 },
+ { 0x1e06, 0x1e07 },
+ { 0x1e08, 0x1e09 },
+ { 0x1e0a, 0x1e0b },
+ { 0x1e0c, 0x1e0d },
+ { 0x1e0e, 0x1e0f },
+ { 0x1e10, 0x1e11 },
+ { 0x1e12, 0x1e13 },
+ { 0x1e14, 0x1e15 },
+ { 0x1e16, 0x1e17 },
+ { 0x1e18, 0x1e19 },
+ { 0x1e1a, 0x1e1b },
+ { 0x1e1c, 0x1e1d },
+ { 0x1e1e, 0x1e1f },
+ { 0x1e20, 0x1e21 },
+ { 0x1e22, 0x1e23 },
+ { 0x1e24, 0x1e25 },
+ { 0x1e26, 0x1e27 },
+ { 0x1e28, 0x1e29 },
+ { 0x1e2a, 0x1e2b },
+ { 0x1e2c, 0x1e2d },
+ { 0x1e2e, 0x1e2f },
+ { 0x1e30, 0x1e31 },
+ { 0x1e32, 0x1e33 },
+ { 0x1e34, 0x1e35 },
+ { 0x1e36, 0x1e37 },
+ { 0x1e38, 0x1e39 },
+ { 0x1e3a, 0x1e3b },
+ { 0x1e3c, 0x1e3d },
+ { 0x1e3e, 0x1e3f },
+ { 0x1e40, 0x1e41 },
+ { 0x1e42, 0x1e43 },
+ { 0x1e44, 0x1e45 },
+ { 0x1e46, 0x1e47 },
+ { 0x1e48, 0x1e49 },
+ { 0x1e4a, 0x1e4b },
+ { 0x1e4c, 0x1e4d },
+ { 0x1e4e, 0x1e4f },
+ { 0x1e50, 0x1e51 },
+ { 0x1e52, 0x1e53 },
+ { 0x1e54, 0x1e55 },
+ { 0x1e56, 0x1e57 },
+ { 0x1e58, 0x1e59 },
+ { 0x1e5a, 0x1e5b },
+ { 0x1e5c, 0x1e5d },
+ { 0x1e5e, 0x1e5f },
+ { 0x1e60, 0x1e61 },
+ { 0x1e62, 0x1e63 },
+ { 0x1e64, 0x1e65 },
+ { 0x1e66, 0x1e67 },
+ { 0x1e68, 0x1e69 },
+ { 0x1e6a, 0x1e6b },
+ { 0x1e6c, 0x1e6d },
+ { 0x1e6e, 0x1e6f },
+ { 0x1e70, 0x1e71 },
+ { 0x1e72, 0x1e73 },
+ { 0x1e74, 0x1e75 },
+ { 0x1e76, 0x1e77 },
+ { 0x1e78, 0x1e79 },
+ { 0x1e7a, 0x1e7b },
+ { 0x1e7c, 0x1e7d },
+ { 0x1e7e, 0x1e7f },
+ { 0x1e80, 0x1e81 },
+ { 0x1e82, 0x1e83 },
+ { 0x1e84, 0x1e85 },
+ { 0x1e86, 0x1e87 },
+ { 0x1e88, 0x1e89 },
+ { 0x1e8a, 0x1e8b },
+ { 0x1e8c, 0x1e8d },
+ { 0x1e8e, 0x1e8f },
+ { 0x1e90, 0x1e91 },
+ { 0x1e92, 0x1e93 },
+ { 0x1e94, 0x1e95 },
+ { 0x1e9b, 0x1e61 },
+ { 0x1e9e, 0xdf },
+ { 0x1ea0, 0x1ea1 },
+ { 0x1ea2, 0x1ea3 },
+ { 0x1ea4, 0x1ea5 },
+ { 0x1ea6, 0x1ea7 },
+ { 0x1ea8, 0x1ea9 },
+ { 0x1eaa, 0x1eab },
+ { 0x1eac, 0x1ead },
+ { 0x1eae, 0x1eaf },
+ { 0x1eb0, 0x1eb1 },
+ { 0x1eb2, 0x1eb3 },
+ { 0x1eb4, 0x1eb5 },
+ { 0x1eb6, 0x1eb7 },
+ { 0x1eb8, 0x1eb9 },
+ { 0x1eba, 0x1ebb },
+ { 0x1ebc, 0x1ebd },
+ { 0x1ebe, 0x1ebf },
+ { 0x1ec0, 0x1ec1 },
+ { 0x1ec2, 0x1ec3 },
+ { 0x1ec4, 0x1ec5 },
+ { 0x1ec6, 0x1ec7 },
+ { 0x1ec8, 0x1ec9 },
+ { 0x1eca, 0x1ecb },
+ { 0x1ecc, 0x1ecd },
+ { 0x1ece, 0x1ecf },
+ { 0x1ed0, 0x1ed1 },
+ { 0x1ed2, 0x1ed3 },
+ { 0x1ed4, 0x1ed5 },
+ { 0x1ed6, 0x1ed7 },
+ { 0x1ed8, 0x1ed9 },
+ { 0x1eda, 0x1edb },
+ { 0x1edc, 0x1edd },
+ { 0x1ede, 0x1edf },
+ { 0x1ee0, 0x1ee1 },
+ { 0x1ee2, 0x1ee3 },
+ { 0x1ee4, 0x1ee5 },
+ { 0x1ee6, 0x1ee7 },
+ { 0x1ee8, 0x1ee9 },
+ { 0x1eea, 0x1eeb },
+ { 0x1eec, 0x1eed },
+ { 0x1eee, 0x1eef },
+ { 0x1ef0, 0x1ef1 },
+ { 0x1ef2, 0x1ef3 },
+ { 0x1ef4, 0x1ef5 },
+ { 0x1ef6, 0x1ef7 },
+ { 0x1ef8, 0x1ef9 },
+ { 0x1efa, 0x1efb },
+ { 0x1efc, 0x1efd },
+ { 0x1efe, 0x1eff },
+ { 0x1f08, 0x1f00 },
+ { 0x1f09, 0x1f01 },
+ { 0x1f0a, 0x1f02 },
+ { 0x1f0b, 0x1f03 },
+ { 0x1f0c, 0x1f04 },
+ { 0x1f0d, 0x1f05 },
+ { 0x1f0e, 0x1f06 },
+ { 0x1f0f, 0x1f07 },
+ { 0x1f18, 0x1f10 },
+ { 0x1f19, 0x1f11 },
+ { 0x1f1a, 0x1f12 },
+ { 0x1f1b, 0x1f13 },
+ { 0x1f1c, 0x1f14 },
+ { 0x1f1d, 0x1f15 },
+ { 0x1f28, 0x1f20 },
+ { 0x1f29, 0x1f21 },
+ { 0x1f2a, 0x1f22 },
+ { 0x1f2b, 0x1f23 },
+ { 0x1f2c, 0x1f24 },
+ { 0x1f2d, 0x1f25 },
+ { 0x1f2e, 0x1f26 },
+ { 0x1f2f, 0x1f27 },
+ { 0x1f38, 0x1f30 },
+ { 0x1f39, 0x1f31 },
+ { 0x1f3a, 0x1f32 },
+ { 0x1f3b, 0x1f33 },
+ { 0x1f3c, 0x1f34 },
+ { 0x1f3d, 0x1f35 },
+ { 0x1f3e, 0x1f36 },
+ { 0x1f3f, 0x1f37 },
+ { 0x1f48, 0x1f40 },
+ { 0x1f49, 0x1f41 },
+ { 0x1f4a, 0x1f42 },
+ { 0x1f4b, 0x1f43 },
+ { 0x1f4c, 0x1f44 },
+ { 0x1f4d, 0x1f45 },
+ { 0x1f59, 0x1f51 },
+ { 0x1f5b, 0x1f53 },
+ { 0x1f5d, 0x1f55 },
+ { 0x1f5f, 0x1f57 },
+ { 0x1f68, 0x1f60 },
+ { 0x1f69, 0x1f61 },
+ { 0x1f6a, 0x1f62 },
+ { 0x1f6b, 0x1f63 },
+ { 0x1f6c, 0x1f64 },
+ { 0x1f6d, 0x1f65 },
+ { 0x1f6e, 0x1f66 },
+ { 0x1f6f, 0x1f67 },
+ { 0x1f88, 0x1f80 },
+ { 0x1f89, 0x1f81 },
+ { 0x1f8a, 0x1f82 },
+ { 0x1f8b, 0x1f83 },
+ { 0x1f8c, 0x1f84 },
+ { 0x1f8d, 0x1f85 },
+ { 0x1f8e, 0x1f86 },
+ { 0x1f8f, 0x1f87 },
+ { 0x1f98, 0x1f90 },
+ { 0x1f99, 0x1f91 },
+ { 0x1f9a, 0x1f92 },
+ { 0x1f9b, 0x1f93 },
+ { 0x1f9c, 0x1f94 },
+ { 0x1f9d, 0x1f95 },
+ { 0x1f9e, 0x1f96 },
+ { 0x1f9f, 0x1f97 },
+ { 0x1fa8, 0x1fa0 },
+ { 0x1fa9, 0x1fa1 },
+ { 0x1faa, 0x1fa2 },
+ { 0x1fab, 0x1fa3 },
+ { 0x1fac, 0x1fa4 },
+ { 0x1fad, 0x1fa5 },
+ { 0x1fae, 0x1fa6 },
+ { 0x1faf, 0x1fa7 },
+ { 0x1fb8, 0x1fb0 },
+ { 0x1fb9, 0x1fb1 },
+ { 0x1fba, 0x1f70 },
+ { 0x1fbb, 0x1f71 },
+ { 0x1fbc, 0x1fb3 },
+ { 0x1fbe, 0x3b9 },
+ { 0x1fc8, 0x1f72 },
+ { 0x1fc9, 0x1f73 },
+ { 0x1fca, 0x1f74 },
+ { 0x1fcb, 0x1f75 },
+ { 0x1fcc, 0x1fc3 },
+ { 0x1fd3, 0x390 },
+ { 0x1fd8, 0x1fd0 },
+ { 0x1fd9, 0x1fd1 },
+ { 0x1fda, 0x1f76 },
+ { 0x1fdb, 0x1f77 },
+ { 0x1fe3, 0x3b0 },
+ { 0x1fe8, 0x1fe0 },
+ { 0x1fe9, 0x1fe1 },
+ { 0x1fea, 0x1f7a },
+ { 0x1feb, 0x1f7b },
+ { 0x1fec, 0x1fe5 },
+ { 0x1ff8, 0x1f78 },
+ { 0x1ff9, 0x1f79 },
+ { 0x1ffa, 0x1f7c },
+ { 0x1ffb, 0x1f7d },
+ { 0x1ffc, 0x1ff3 },
+ { 0x2126, 0x3c9 },
+ { 0x212a, 0x6b },
+ { 0x212b, 0xe5 },
+ { 0x2132, 0x214e },
+ { 0x2160, 0x2170 },
+ { 0x2161, 0x2171 },
+ { 0x2162, 0x2172 },
+ { 0x2163, 0x2173 },
+ { 0x2164, 0x2174 },
+ { 0x2165, 0x2175 },
+ { 0x2166, 0x2176 },
+ { 0x2167, 0x2177 },
+ { 0x2168, 0x2178 },
+ { 0x2169, 0x2179 },
+ { 0x216a, 0x217a },
+ { 0x216b, 0x217b },
+ { 0x216c, 0x217c },
+ { 0x216d, 0x217d },
+ { 0x216e, 0x217e },
+ { 0x216f, 0x217f },
+ { 0x2183, 0x2184 },
+ { 0x24b6, 0x24d0 },
+ { 0x24b7, 0x24d1 },
+ { 0x24b8, 0x24d2 },
+ { 0x24b9, 0x24d3 },
+ { 0x24ba, 0x24d4 },
+ { 0x24bb, 0x24d5 },
+ { 0x24bc, 0x24d6 },
+ { 0x24bd, 0x24d7 },
+ { 0x24be, 0x24d8 },
+ { 0x24bf, 0x24d9 },
+ { 0x24c0, 0x24da },
+ { 0x24c1, 0x24db },
+ { 0x24c2, 0x24dc },
+ { 0x24c3, 0x24dd },
+ { 0x24c4, 0x24de },
+ { 0x24c5, 0x24df },
+ { 0x24c6, 0x24e0 },
+ { 0x24c7, 0x24e1 },
+ { 0x24c8, 0x24e2 },
+ { 0x24c9, 0x24e3 },
+ { 0x24ca, 0x24e4 },
+ { 0x24cb, 0x24e5 },
+ { 0x24cc, 0x24e6 },
+ { 0x24cd, 0x24e7 },
+ { 0x24ce, 0x24e8 },
+ { 0x24cf, 0x24e9 },
+ { 0x2c00, 0x2c30 },
+ { 0x2c01, 0x2c31 },
+ { 0x2c02, 0x2c32 },
+ { 0x2c03, 0x2c33 },
+ { 0x2c04, 0x2c34 },
+ { 0x2c05, 0x2c35 },
+ { 0x2c06, 0x2c36 },
+ { 0x2c07, 0x2c37 },
+ { 0x2c08, 0x2c38 },
+ { 0x2c09, 0x2c39 },
+ { 0x2c0a, 0x2c3a },
+ { 0x2c0b, 0x2c3b },
+ { 0x2c0c, 0x2c3c },
+ { 0x2c0d, 0x2c3d },
+ { 0x2c0e, 0x2c3e },
+ { 0x2c0f, 0x2c3f },
+ { 0x2c10, 0x2c40 },
+ { 0x2c11, 0x2c41 },
+ { 0x2c12, 0x2c42 },
+ { 0x2c13, 0x2c43 },
+ { 0x2c14, 0x2c44 },
+ { 0x2c15, 0x2c45 },
+ { 0x2c16, 0x2c46 },
+ { 0x2c17, 0x2c47 },
+ { 0x2c18, 0x2c48 },
+ { 0x2c19, 0x2c49 },
+ { 0x2c1a, 0x2c4a },
+ { 0x2c1b, 0x2c4b },
+ { 0x2c1c, 0x2c4c },
+ { 0x2c1d, 0x2c4d },
+ { 0x2c1e, 0x2c4e },
+ { 0x2c1f, 0x2c4f },
+ { 0x2c20, 0x2c50 },
+ { 0x2c21, 0x2c51 },
+ { 0x2c22, 0x2c52 },
+ { 0x2c23, 0x2c53 },
+ { 0x2c24, 0x2c54 },
+ { 0x2c25, 0x2c55 },
+ { 0x2c26, 0x2c56 },
+ { 0x2c27, 0x2c57 },
+ { 0x2c28, 0x2c58 },
+ { 0x2c29, 0x2c59 },
+ { 0x2c2a, 0x2c5a },
+ { 0x2c2b, 0x2c5b },
+ { 0x2c2c, 0x2c5c },
+ { 0x2c2d, 0x2c5d },
+ { 0x2c2e, 0x2c5e },
+ { 0x2c2f, 0x2c5f },
+ { 0x2c60, 0x2c61 },
+ { 0x2c62, 0x26b },
+ { 0x2c63, 0x1d7d },
+ { 0x2c64, 0x27d },
+ { 0x2c67, 0x2c68 },
+ { 0x2c69, 0x2c6a },
+ { 0x2c6b, 0x2c6c },
+ { 0x2c6d, 0x251 },
+ { 0x2c6e, 0x271 },
+ { 0x2c6f, 0x250 },
+ { 0x2c70, 0x252 },
+ { 0x2c72, 0x2c73 },
+ { 0x2c75, 0x2c76 },
+ { 0x2c7e, 0x23f },
+ { 0x2c7f, 0x240 },
+ { 0x2c80, 0x2c81 },
+ { 0x2c82, 0x2c83 },
+ { 0x2c84, 0x2c85 },
+ { 0x2c86, 0x2c87 },
+ { 0x2c88, 0x2c89 },
+ { 0x2c8a, 0x2c8b },
+ { 0x2c8c, 0x2c8d },
+ { 0x2c8e, 0x2c8f },
+ { 0x2c90, 0x2c91 },
+ { 0x2c92, 0x2c93 },
+ { 0x2c94, 0x2c95 },
+ { 0x2c96, 0x2c97 },
+ { 0x2c98, 0x2c99 },
+ { 0x2c9a, 0x2c9b },
+ { 0x2c9c, 0x2c9d },
+ { 0x2c9e, 0x2c9f },
+ { 0x2ca0, 0x2ca1 },
+ { 0x2ca2, 0x2ca3 },
+ { 0x2ca4, 0x2ca5 },
+ { 0x2ca6, 0x2ca7 },
+ { 0x2ca8, 0x2ca9 },
+ { 0x2caa, 0x2cab },
+ { 0x2cac, 0x2cad },
+ { 0x2cae, 0x2caf },
+ { 0x2cb0, 0x2cb1 },
+ { 0x2cb2, 0x2cb3 },
+ { 0x2cb4, 0x2cb5 },
+ { 0x2cb6, 0x2cb7 },
+ { 0x2cb8, 0x2cb9 },
+ { 0x2cba, 0x2cbb },
+ { 0x2cbc, 0x2cbd },
+ { 0x2cbe, 0x2cbf },
+ { 0x2cc0, 0x2cc1 },
+ { 0x2cc2, 0x2cc3 },
+ { 0x2cc4, 0x2cc5 },
+ { 0x2cc6, 0x2cc7 },
+ { 0x2cc8, 0x2cc9 },
+ { 0x2cca, 0x2ccb },
+ { 0x2ccc, 0x2ccd },
+ { 0x2cce, 0x2ccf },
+ { 0x2cd0, 0x2cd1 },
+ { 0x2cd2, 0x2cd3 },
+ { 0x2cd4, 0x2cd5 },
+ { 0x2cd6, 0x2cd7 },
+ { 0x2cd8, 0x2cd9 },
+ { 0x2cda, 0x2cdb },
+ { 0x2cdc, 0x2cdd },
+ { 0x2cde, 0x2cdf },
+ { 0x2ce0, 0x2ce1 },
+ { 0x2ce2, 0x2ce3 },
+ { 0x2ceb, 0x2cec },
+ { 0x2ced, 0x2cee },
+ { 0x2cf2, 0x2cf3 },
+ { 0xa640, 0xa641 },
+ { 0xa642, 0xa643 },
+ { 0xa644, 0xa645 },
+ { 0xa646, 0xa647 },
+ { 0xa648, 0xa649 },
+ { 0xa64a, 0xa64b },
+ { 0xa64c, 0xa64d },
+ { 0xa64e, 0xa64f },
+ { 0xa650, 0xa651 },
+ { 0xa652, 0xa653 },
+ { 0xa654, 0xa655 },
+ { 0xa656, 0xa657 },
+ { 0xa658, 0xa659 },
+ { 0xa65a, 0xa65b },
+ { 0xa65c, 0xa65d },
+ { 0xa65e, 0xa65f },
+ { 0xa660, 0xa661 },
+ { 0xa662, 0xa663 },
+ { 0xa664, 0xa665 },
+ { 0xa666, 0xa667 },
+ { 0xa668, 0xa669 },
+ { 0xa66a, 0xa66b },
+ { 0xa66c, 0xa66d },
+ { 0xa680, 0xa681 },
+ { 0xa682, 0xa683 },
+ { 0xa684, 0xa685 },
+ { 0xa686, 0xa687 },
+ { 0xa688, 0xa689 },
+ { 0xa68a, 0xa68b },
+ { 0xa68c, 0xa68d },
+ { 0xa68e, 0xa68f },
+ { 0xa690, 0xa691 },
+ { 0xa692, 0xa693 },
+ { 0xa694, 0xa695 },
+ { 0xa696, 0xa697 },
+ { 0xa698, 0xa699 },
+ { 0xa69a, 0xa69b },
+ { 0xa722, 0xa723 },
+ { 0xa724, 0xa725 },
+ { 0xa726, 0xa727 },
+ { 0xa728, 0xa729 },
+ { 0xa72a, 0xa72b },
+ { 0xa72c, 0xa72d },
+ { 0xa72e, 0xa72f },
+ { 0xa732, 0xa733 },
+ { 0xa734, 0xa735 },
+ { 0xa736, 0xa737 },
+ { 0xa738, 0xa739 },
+ { 0xa73a, 0xa73b },
+ { 0xa73c, 0xa73d },
+ { 0xa73e, 0xa73f },
+ { 0xa740, 0xa741 },
+ { 0xa742, 0xa743 },
+ { 0xa744, 0xa745 },
+ { 0xa746, 0xa747 },
+ { 0xa748, 0xa749 },
+ { 0xa74a, 0xa74b },
+ { 0xa74c, 0xa74d },
+ { 0xa74e, 0xa74f },
+ { 0xa750, 0xa751 },
+ { 0xa752, 0xa753 },
+ { 0xa754, 0xa755 },
+ { 0xa756, 0xa757 },
+ { 0xa758, 0xa759 },
+ { 0xa75a, 0xa75b },
+ { 0xa75c, 0xa75d },
+ { 0xa75e, 0xa75f },
+ { 0xa760, 0xa761 },
+ { 0xa762, 0xa763 },
+ { 0xa764, 0xa765 },
+ { 0xa766, 0xa767 },
+ { 0xa768, 0xa769 },
+ { 0xa76a, 0xa76b },
+ { 0xa76c, 0xa76d },
+ { 0xa76e, 0xa76f },
+ { 0xa779, 0xa77a },
+ { 0xa77b, 0xa77c },
+ { 0xa77d, 0x1d79 },
+ { 0xa77e, 0xa77f },
+ { 0xa780, 0xa781 },
+ { 0xa782, 0xa783 },
+ { 0xa784, 0xa785 },
+ { 0xa786, 0xa787 },
+ { 0xa78b, 0xa78c },
+ { 0xa78d, 0x265 },
+ { 0xa790, 0xa791 },
+ { 0xa792, 0xa793 },
+ { 0xa796, 0xa797 },
+ { 0xa798, 0xa799 },
+ { 0xa79a, 0xa79b },
+ { 0xa79c, 0xa79d },
+ { 0xa79e, 0xa79f },
+ { 0xa7a0, 0xa7a1 },
+ { 0xa7a2, 0xa7a3 },
+ { 0xa7a4, 0xa7a5 },
+ { 0xa7a6, 0xa7a7 },
+ { 0xa7a8, 0xa7a9 },
+ { 0xa7aa, 0x266 },
+ { 0xa7ab, 0x25c },
+ { 0xa7ac, 0x261 },
+ { 0xa7ad, 0x26c },
+ { 0xa7ae, 0x26a },
+ { 0xa7b0, 0x29e },
+ { 0xa7b1, 0x287 },
+ { 0xa7b2, 0x29d },
+ { 0xa7b3, 0xab53 },
+ { 0xa7b4, 0xa7b5 },
+ { 0xa7b6, 0xa7b7 },
+ { 0xa7b8, 0xa7b9 },
+ { 0xa7ba, 0xa7bb },
+ { 0xa7bc, 0xa7bd },
+ { 0xa7be, 0xa7bf },
+ { 0xa7c0, 0xa7c1 },
+ { 0xa7c2, 0xa7c3 },
+ { 0xa7c4, 0xa794 },
+ { 0xa7c5, 0x282 },
+ { 0xa7c6, 0x1d8e },
+ { 0xa7c7, 0xa7c8 },
+ { 0xa7c9, 0xa7ca },
+ { 0xa7cb, 0x264 },
+ { 0xa7cc, 0xa7cd },
+ { 0xa7ce, 0xa7cf },
+ { 0xa7d0, 0xa7d1 },
+ { 0xa7d2, 0xa7d3 },
+ { 0xa7d4, 0xa7d5 },
+ { 0xa7d6, 0xa7d7 },
+ { 0xa7d8, 0xa7d9 },
+ { 0xa7da, 0xa7db },
+ { 0xa7dc, 0x19b },
+ { 0xa7f5, 0xa7f6 },
+ { 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 },
+ { 0xfb05, 0xfb06 },
+ { 0xff21, 0xff41 },
+ { 0xff22, 0xff42 },
+ { 0xff23, 0xff43 },
+ { 0xff24, 0xff44 },
+ { 0xff25, 0xff45 },
+ { 0xff26, 0xff46 },
+ { 0xff27, 0xff47 },
+ { 0xff28, 0xff48 },
+ { 0xff29, 0xff49 },
+ { 0xff2a, 0xff4a },
+ { 0xff2b, 0xff4b },
+ { 0xff2c, 0xff4c },
+ { 0xff2d, 0xff4d },
+ { 0xff2e, 0xff4e },
+ { 0xff2f, 0xff4f },
+ { 0xff30, 0xff50 },
+ { 0xff31, 0xff51 },
+ { 0xff32, 0xff52 },
+ { 0xff33, 0xff53 },
+ { 0xff34, 0xff54 },
+ { 0xff35, 0xff55 },
+ { 0xff36, 0xff56 },
+ { 0xff37, 0xff57 },
+ { 0xff38, 0xff58 },
+ { 0xff39, 0xff59 },
+ { 0xff3a, 0xff5a },
+ { 0x10400, 0x10428 },
+ { 0x10401, 0x10429 },
+ { 0x10402, 0x1042a },
+ { 0x10403, 0x1042b },
+ { 0x10404, 0x1042c },
+ { 0x10405, 0x1042d },
+ { 0x10406, 0x1042e },
+ { 0x10407, 0x1042f },
+ { 0x10408, 0x10430 },
+ { 0x10409, 0x10431 },
+ { 0x1040a, 0x10432 },
+ { 0x1040b, 0x10433 },
+ { 0x1040c, 0x10434 },
+ { 0x1040d, 0x10435 },
+ { 0x1040e, 0x10436 },
+ { 0x1040f, 0x10437 },
+ { 0x10410, 0x10438 },
+ { 0x10411, 0x10439 },
+ { 0x10412, 0x1043a },
+ { 0x10413, 0x1043b },
+ { 0x10414, 0x1043c },
+ { 0x10415, 0x1043d },
+ { 0x10416, 0x1043e },
+ { 0x10417, 0x1043f },
+ { 0x10418, 0x10440 },
+ { 0x10419, 0x10441 },
+ { 0x1041a, 0x10442 },
+ { 0x1041b, 0x10443 },
+ { 0x1041c, 0x10444 },
+ { 0x1041d, 0x10445 },
+ { 0x1041e, 0x10446 },
+ { 0x1041f, 0x10447 },
+ { 0x10420, 0x10448 },
+ { 0x10421, 0x10449 },
+ { 0x10422, 0x1044a },
+ { 0x10423, 0x1044b },
+ { 0x10424, 0x1044c },
+ { 0x10425, 0x1044d },
+ { 0x10426, 0x1044e },
+ { 0x10427, 0x1044f },
+ { 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 },
+ { 0x10570, 0x10597 },
+ { 0x10571, 0x10598 },
+ { 0x10572, 0x10599 },
+ { 0x10573, 0x1059a },
+ { 0x10574, 0x1059b },
+ { 0x10575, 0x1059c },
+ { 0x10576, 0x1059d },
+ { 0x10577, 0x1059e },
+ { 0x10578, 0x1059f },
+ { 0x10579, 0x105a0 },
+ { 0x1057a, 0x105a1 },
+ { 0x1057c, 0x105a3 },
+ { 0x1057d, 0x105a4 },
+ { 0x1057e, 0x105a5 },
+ { 0x1057f, 0x105a6 },
+ { 0x10580, 0x105a7 },
+ { 0x10581, 0x105a8 },
+ { 0x10582, 0x105a9 },
+ { 0x10583, 0x105aa },
+ { 0x10584, 0x105ab },
+ { 0x10585, 0x105ac },
+ { 0x10586, 0x105ad },
+ { 0x10587, 0x105ae },
+ { 0x10588, 0x105af },
+ { 0x10589, 0x105b0 },
+ { 0x1058a, 0x105b1 },
+ { 0x1058c, 0x105b3 },
+ { 0x1058d, 0x105b4 },
+ { 0x1058e, 0x105b5 },
+ { 0x1058f, 0x105b6 },
+ { 0x10590, 0x105b7 },
+ { 0x10591, 0x105b8 },
+ { 0x10592, 0x105b9 },
+ { 0x10594, 0x105bb },
+ { 0x10595, 0x105bc },
+ { 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 },
+ { 0x10d50, 0x10d70 },
+ { 0x10d51, 0x10d71 },
+ { 0x10d52, 0x10d72 },
+ { 0x10d53, 0x10d73 },
+ { 0x10d54, 0x10d74 },
+ { 0x10d55, 0x10d75 },
+ { 0x10d56, 0x10d76 },
+ { 0x10d57, 0x10d77 },
+ { 0x10d58, 0x10d78 },
+ { 0x10d59, 0x10d79 },
+ { 0x10d5a, 0x10d7a },
+ { 0x10d5b, 0x10d7b },
+ { 0x10d5c, 0x10d7c },
+ { 0x10d5d, 0x10d7d },
+ { 0x10d5e, 0x10d7e },
+ { 0x10d5f, 0x10d7f },
+ { 0x10d60, 0x10d80 },
+ { 0x10d61, 0x10d81 },
+ { 0x10d62, 0x10d82 },
+ { 0x10d63, 0x10d83 },
+ { 0x10d64, 0x10d84 },
+ { 0x10d65, 0x10d85 },
+ { 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 },
+ { 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 },
+ { 0x16ea0, 0x16ebb },
+ { 0x16ea1, 0x16ebc },
+ { 0x16ea2, 0x16ebd },
+ { 0x16ea3, 0x16ebe },
+ { 0x16ea4, 0x16ebf },
+ { 0x16ea5, 0x16ec0 },
+ { 0x16ea6, 0x16ec1 },
+ { 0x16ea7, 0x16ec2 },
+ { 0x16ea8, 0x16ec3 },
+ { 0x16ea9, 0x16ec4 },
+ { 0x16eaa, 0x16ec5 },
+ { 0x16eab, 0x16ec6 },
+ { 0x16eac, 0x16ec7 },
+ { 0x16ead, 0x16ec8 },
+ { 0x16eae, 0x16ec9 },
+ { 0x16eaf, 0x16eca },
+ { 0x16eb0, 0x16ecb },
+ { 0x16eb1, 0x16ecc },
+ { 0x16eb2, 0x16ecd },
+ { 0x16eb3, 0x16ece },
+ { 0x16eb4, 0x16ecf },
+ { 0x16eb5, 0x16ed0 },
+ { 0x16eb6, 0x16ed1 },
+ { 0x16eb7, 0x16ed2 },
+ { 0x16eb8, 0x16ed3 },
+ { 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 },
+};
+static const int fold2[][4] = {
+ { 0xdf, 0x73, 0x73, 0x0 },
+ { 0x130, 0x69, 0x307, 0x0 },
+ { 0x149, 0x2bc, 0x6e, 0x0 },
+ { 0x1f0, 0x6a, 0x30c, 0x0 },
+ { 0x390, 0x3b9, 0x308, 0x301 },
+ { 0x3b0, 0x3c5, 0x308, 0x301 },
+ { 0x587, 0x565, 0x582, 0x0 },
+ { 0x1e96, 0x68, 0x331, 0x0 },
+ { 0x1e97, 0x74, 0x308, 0x0 },
+ { 0x1e98, 0x77, 0x30a, 0x0 },
+ { 0x1e99, 0x79, 0x30a, 0x0 },
+ { 0x1e9a, 0x61, 0x2be, 0x0 },
+ { 0x1e9e, 0x73, 0x73, 0x0 },
+ { 0x1f50, 0x3c5, 0x313, 0x0 },
+ { 0x1f52, 0x3c5, 0x313, 0x300 },
+ { 0x1f54, 0x3c5, 0x313, 0x301 },
+ { 0x1f56, 0x3c5, 0x313, 0x342 },
+ { 0x1f80, 0x1f00, 0x3b9, 0x0 },
+ { 0x1f81, 0x1f01, 0x3b9, 0x0 },
+ { 0x1f82, 0x1f02, 0x3b9, 0x0 },
+ { 0x1f83, 0x1f03, 0x3b9, 0x0 },
+ { 0x1f84, 0x1f04, 0x3b9, 0x0 },
+ { 0x1f85, 0x1f05, 0x3b9, 0x0 },
+ { 0x1f86, 0x1f06, 0x3b9, 0x0 },
+ { 0x1f87, 0x1f07, 0x3b9, 0x0 },
+ { 0x1f88, 0x1f00, 0x3b9, 0x0 },
+ { 0x1f89, 0x1f01, 0x3b9, 0x0 },
+ { 0x1f8a, 0x1f02, 0x3b9, 0x0 },
+ { 0x1f8b, 0x1f03, 0x3b9, 0x0 },
+ { 0x1f8c, 0x1f04, 0x3b9, 0x0 },
+ { 0x1f8d, 0x1f05, 0x3b9, 0x0 },
+ { 0x1f8e, 0x1f06, 0x3b9, 0x0 },
+ { 0x1f8f, 0x1f07, 0x3b9, 0x0 },
+ { 0x1f90, 0x1f20, 0x3b9, 0x0 },
+ { 0x1f91, 0x1f21, 0x3b9, 0x0 },
+ { 0x1f92, 0x1f22, 0x3b9, 0x0 },
+ { 0x1f93, 0x1f23, 0x3b9, 0x0 },
+ { 0x1f94, 0x1f24, 0x3b9, 0x0 },
+ { 0x1f95, 0x1f25, 0x3b9, 0x0 },
+ { 0x1f96, 0x1f26, 0x3b9, 0x0 },
+ { 0x1f97, 0x1f27, 0x3b9, 0x0 },
+ { 0x1f98, 0x1f20, 0x3b9, 0x0 },
+ { 0x1f99, 0x1f21, 0x3b9, 0x0 },
+ { 0x1f9a, 0x1f22, 0x3b9, 0x0 },
+ { 0x1f9b, 0x1f23, 0x3b9, 0x0 },
+ { 0x1f9c, 0x1f24, 0x3b9, 0x0 },
+ { 0x1f9d, 0x1f25, 0x3b9, 0x0 },
+ { 0x1f9e, 0x1f26, 0x3b9, 0x0 },
+ { 0x1f9f, 0x1f27, 0x3b9, 0x0 },
+ { 0x1fa0, 0x1f60, 0x3b9, 0x0 },
+ { 0x1fa1, 0x1f61, 0x3b9, 0x0 },
+ { 0x1fa2, 0x1f62, 0x3b9, 0x0 },
+ { 0x1fa3, 0x1f63, 0x3b9, 0x0 },
+ { 0x1fa4, 0x1f64, 0x3b9, 0x0 },
+ { 0x1fa5, 0x1f65, 0x3b9, 0x0 },
+ { 0x1fa6, 0x1f66, 0x3b9, 0x0 },
+ { 0x1fa7, 0x1f67, 0x3b9, 0x0 },
+ { 0x1fa8, 0x1f60, 0x3b9, 0x0 },
+ { 0x1fa9, 0x1f61, 0x3b9, 0x0 },
+ { 0x1faa, 0x1f62, 0x3b9, 0x0 },
+ { 0x1fab, 0x1f63, 0x3b9, 0x0 },
+ { 0x1fac, 0x1f64, 0x3b9, 0x0 },
+ { 0x1fad, 0x1f65, 0x3b9, 0x0 },
+ { 0x1fae, 0x1f66, 0x3b9, 0x0 },
+ { 0x1faf, 0x1f67, 0x3b9, 0x0 },
+ { 0x1fb2, 0x1f70, 0x3b9, 0x0 },
+ { 0x1fb3, 0x3b1, 0x3b9, 0x0 },
+ { 0x1fb4, 0x3ac, 0x3b9, 0x0 },
+ { 0x1fb6, 0x3b1, 0x342, 0x0 },
+ { 0x1fb7, 0x3b1, 0x342, 0x3b9 },
+ { 0x1fbc, 0x3b1, 0x3b9, 0x0 },
+ { 0x1fc2, 0x1f74, 0x3b9, 0x0 },
+ { 0x1fc3, 0x3b7, 0x3b9, 0x0 },
+ { 0x1fc4, 0x3ae, 0x3b9, 0x0 },
+ { 0x1fc6, 0x3b7, 0x342, 0x0 },
+ { 0x1fc7, 0x3b7, 0x342, 0x3b9 },
+ { 0x1fcc, 0x3b7, 0x3b9, 0x0 },
+ { 0x1fd2, 0x3b9, 0x308, 0x300 },
+ { 0x1fd3, 0x3b9, 0x308, 0x301 },
+ { 0x1fd6, 0x3b9, 0x342, 0x0 },
+ { 0x1fd7, 0x3b9, 0x308, 0x342 },
+ { 0x1fe2, 0x3c5, 0x308, 0x300 },
+ { 0x1fe3, 0x3c5, 0x308, 0x301 },
+ { 0x1fe4, 0x3c1, 0x313, 0x0 },
+ { 0x1fe6, 0x3c5, 0x342, 0x0 },
+ { 0x1fe7, 0x3c5, 0x308, 0x342 },
+ { 0x1ff2, 0x1f7c, 0x3b9, 0x0 },
+ { 0x1ff3, 0x3c9, 0x3b9, 0x0 },
+ { 0x1ff4, 0x3ce, 0x3b9, 0x0 },
+ { 0x1ff6, 0x3c9, 0x342, 0x0 },
+ { 0x1ff7, 0x3c9, 0x342, 0x3b9 },
+ { 0x1ffc, 0x3c9, 0x3b9, 0x0 },
+ { 0xfb00, 0x66, 0x66, 0x0 },
+ { 0xfb01, 0x66, 0x69, 0x0 },
+ { 0xfb02, 0x66, 0x6c, 0x0 },
+ { 0xfb03, 0x66, 0x66, 0x69 },
+ { 0xfb04, 0x66, 0x66, 0x6c },
+ { 0xfb05, 0x73, 0x74, 0x0 },
+ { 0xfb06, 0x73, 0x74, 0x0 },
+ { 0xfb13, 0x574, 0x576, 0x0 },
+ { 0xfb14, 0x574, 0x565, 0x0 },
+ { 0xfb15, 0x574, 0x56b, 0x0 },
+ { 0xfb16, 0x57e, 0x576, 0x0 },
+ { 0xfb17, 0x574, 0x56d, 0x0 },
+};
diff --git a/utf.c b/utf.c
index 684ff407..133bf7dd 100644
--- a/utf.c
+++ b/utf.c
@@ -31,28 +31,30 @@
# include <windows.h>
#endif
-/* partially generated by mkrunetype.awk from http://git.suckless.org/ubase/
- see LICENSE for more information */
+/* The comparison helpers below and the layout of the tables they search
+ are inspired by http://git.suckless.org/ubase/; see LICENSE for more
+ information.
-#define nelem(x) (sizeof (x) / sizeof *(x))
-
-static int
-rune1cmp(const void *v1, const void *v2)
-{
- int r1 = *(int *)v1, r2 = *(int *)v2;
+ The tables are now generated by scripts/mkunicodetables.scm from the Unicode
+ character database. */
- return r1 - r2;
-}
+#define nelem(x) (sizeof (x) / sizeof *(x))
+/* Hacker's Delight, 2-nd edition; 4-1 Checking bounds of integers.
+ Compiles to branchless code on ARM64 and x86-64. */
static int
rune2cmp(const void *v1, const void *v2)
{
- int r = *(int *)v1, *p = (int *)v2;
+ int r = *(const int *)v1;
+ const int *p = (const int *)v2;
+ int d = r - p[0];
- if(r >= p[0] && r <= p[1])
+ /* Signed overflow is UB, but the range of Unicode codepoints
+ is way smaller than the range of int32. */
+ if ((unsigned)d <= (unsigned)(p[1] - p[0]))
return 0;
- else
- return r - p[0];
+
+ return d;
}
static int
@@ -61,3087 +63,41 @@ runemapcmp(const void *v1, const void *v2)
return *(int *)v1 - *(int *)v2;
}
-/* generated by mkrunetype.awk from http://git.suckless.org/ubase/
- see LICENSE for more information */
-
-static int upper3[][2] = {
- { 0x0100, 0x012E },
- { 0x0132, 0x0136 },
- { 0x0139, 0x0147 },
- { 0x014A, 0x0176 },
- { 0x0179, 0x017D },
- { 0x0182, 0x0184 },
- { 0x01A0, 0x01A4 },
- { 0x01B3, 0x01B5 },
- { 0x01CD, 0x01DB },
- { 0x01DE, 0x01EE },
- { 0x01F8, 0x021E },
- { 0x0222, 0x0232 },
- { 0x0246, 0x024E },
- { 0x0370, 0x0372 },
- { 0x03D8, 0x03EE },
- { 0x0460, 0x0480 },
- { 0x048A, 0x04BE },
- { 0x04C1, 0x04CD },
- { 0x04D0, 0x052E },
- { 0x1E00, 0x1E94 },
- { 0x1EA0, 0x1EFE },
- { 0x2C67, 0x2C6B },
- { 0x2C80, 0x2CE2 },
- { 0x2CEB, 0x2CED },
- { 0xA640, 0xA66C },
- { 0xA680, 0xA69A },
- { 0xA722, 0xA72E },
- { 0xA732, 0xA76E },
- { 0xA779, 0xA77B },
- { 0xA77E, 0xA786 },
- { 0xA790, 0xA792 },
- { 0xA796, 0xA7A8 },
- { 0xA7B4, 0xA7C2 },
- { 0xA7C7, 0xA7C9 },
- { 0xA7D6, 0xA7D8 },
-};
-
-static int upper2[][3] = {
- { 0x0041, 0x005A, 0x0061 },
- { 0x00C0, 0x00D6, 0x00E0 },
- { 0x00D8, 0x00DE, 0x00F8 },
- { 0x0189, 0x018A, 0x0256 },
- { 0x01B1, 0x01B2, 0x028A },
- { 0x0388, 0x038A, 0x03AD },
- { 0x038E, 0x038F, 0x03CD },
- { 0x0391, 0x03A1, 0x03B1 },
- { 0x03A3, 0x03AB, 0x03C3 },
- { 0x03D2, 0x03D4, 0x03D2 },
- { 0x03FD, 0x03FF, 0x037B },
- { 0x0400, 0x040F, 0x0450 },
- { 0x0410, 0x042F, 0x0430 },
- { 0x0531, 0x0556, 0x0561 },
- { 0x10A0, 0x10C5, 0x2D00 },
- { 0x13A0, 0x13EF, 0xAB70 },
- { 0x13F0, 0x13F5, 0x13F8 },
- { 0x1C90, 0x1CBA, 0x10D0 },
- { 0x1CBD, 0x1CBF, 0x10FD },
- { 0x1F08, 0x1F0F, 0x1F00 },
- { 0x1F18, 0x1F1D, 0x1F10 },
- { 0x1F28, 0x1F2F, 0x1F20 },
- { 0x1F38, 0x1F3F, 0x1F30 },
- { 0x1F48, 0x1F4D, 0x1F40 },
- { 0x1F68, 0x1F6F, 0x1F60 },
- { 0x1FB8, 0x1FB9, 0x1FB0 },
- { 0x1FBA, 0x1FBB, 0x1F70 },
- { 0x1FC8, 0x1FCB, 0x1F72 },
- { 0x1FD8, 0x1FD9, 0x1FD0 },
- { 0x1FDA, 0x1FDB, 0x1F76 },
- { 0x1FE8, 0x1FE9, 0x1FE0 },
- { 0x1FEA, 0x1FEB, 0x1F7A },
- { 0x1FF8, 0x1FF9, 0x1F78 },
- { 0x1FFA, 0x1FFB, 0x1F7C },
- { 0x210B, 0x210D, 0x210B },
- { 0x2110, 0x2112, 0x2110 },
- { 0x2119, 0x211D, 0x2119 },
- { 0x212C, 0x212D, 0x212C },
- { 0x2130, 0x2131, 0x2130 },
- { 0x213E, 0x213F, 0x213E },
- { 0x2C00, 0x2C2F, 0x2C30 },
- { 0x2C7E, 0x2C7F, 0x023F },
- { 0xFF21, 0xFF3A, 0xFF41 },
- { 0x10400, 0x10427, 0x10428 },
- { 0x104B0, 0x104D3, 0x104D8 },
- { 0x10570, 0x1057A, 0x10597 },
- { 0x1057C, 0x1058A, 0x105A3 },
- { 0x1058C, 0x10592, 0x105B3 },
- { 0x10594, 0x10595, 0x105BB },
- { 0x10C80, 0x10CB2, 0x10CC0 },
- { 0x118A0, 0x118BF, 0x118C0 },
- { 0x16E40, 0x16E5F, 0x16E60 },
- { 0x1D400, 0x1D419, 0x1D400 },
- { 0x1D434, 0x1D44D, 0x1D434 },
- { 0x1D468, 0x1D481, 0x1D468 },
- { 0x1D49E, 0x1D49F, 0x1D49E },
- { 0x1D4A5, 0x1D4A6, 0x1D4A5 },
- { 0x1D4A9, 0x1D4AC, 0x1D4A9 },
- { 0x1D4AE, 0x1D4B5, 0x1D4AE },
- { 0x1D4D0, 0x1D4E9, 0x1D4D0 },
- { 0x1D504, 0x1D505, 0x1D504 },
- { 0x1D507, 0x1D50A, 0x1D507 },
- { 0x1D50D, 0x1D514, 0x1D50D },
- { 0x1D516, 0x1D51C, 0x1D516 },
- { 0x1D538, 0x1D539, 0x1D538 },
- { 0x1D53B, 0x1D53E, 0x1D53B },
- { 0x1D540, 0x1D544, 0x1D540 },
- { 0x1D54A, 0x1D550, 0x1D54A },
- { 0x1D56C, 0x1D585, 0x1D56C },
- { 0x1D5A0, 0x1D5B9, 0x1D5A0 },
- { 0x1D5D4, 0x1D5ED, 0x1D5D4 },
- { 0x1D608, 0x1D621, 0x1D608 },
- { 0x1D63C, 0x1D655, 0x1D63C },
- { 0x1D670, 0x1D689, 0x1D670 },
- { 0x1D6A8, 0x1D6C0, 0x1D6A8 },
- { 0x1D6E2, 0x1D6FA, 0x1D6E2 },
- { 0x1D71C, 0x1D734, 0x1D71C },
- { 0x1D756, 0x1D76E, 0x1D756 },
- { 0x1D790, 0x1D7A8, 0x1D790 },
- { 0x1E900, 0x1E921, 0x1E922 },
-};
-
-static int upper1[][2] = {
- { 0x0130, 0x0069 },
- { 0x0178, 0x00FF },
- { 0x0181, 0x0253 },
- { 0x0186, 0x0254 },
- { 0x0187, 0x0188 },
- { 0x018B, 0x018C },
- { 0x018E, 0x01DD },
- { 0x018F, 0x0259 },
- { 0x0190, 0x025B },
- { 0x0191, 0x0192 },
- { 0x0193, 0x0260 },
- { 0x0194, 0x0263 },
- { 0x0196, 0x0269 },
- { 0x0197, 0x0268 },
- { 0x0198, 0x0199 },
- { 0x019C, 0x026F },
- { 0x019D, 0x0272 },
- { 0x019F, 0x0275 },
- { 0x01A6, 0x0280 },
- { 0x01A7, 0x01A8 },
- { 0x01A9, 0x0283 },
- { 0x01AC, 0x01AD },
- { 0x01AE, 0x0288 },
- { 0x01AF, 0x01B0 },
- { 0x01B7, 0x0292 },
- { 0x01B8, 0x01B9 },
- { 0x01BC, 0x01BD },
- { 0x01C4, 0x01C6 },
- { 0x01C7, 0x01C9 },
- { 0x01CA, 0x01CC },
- { 0x01F1, 0x01F3 },
- { 0x01F4, 0x01F5 },
- { 0x01F6, 0x0195 },
- { 0x01F7, 0x01BF },
- { 0x0220, 0x019E },
- { 0x023A, 0x2C65 },
- { 0x023B, 0x023C },
- { 0x023D, 0x019A },
- { 0x023E, 0x2C66 },
- { 0x0241, 0x0242 },
- { 0x0243, 0x0180 },
- { 0x0244, 0x0289 },
- { 0x0245, 0x028C },
- { 0x0376, 0x0377 },
- { 0x037F, 0x03F3 },
- { 0x0386, 0x03AC },
- { 0x038C, 0x03CC },
- { 0x03CF, 0x03D7 },
- { 0x03F4, 0x03B8 },
- { 0x03F7, 0x03F8 },
- { 0x03F9, 0x03F2 },
- { 0x03FA, 0x03FB },
- { 0x04C0, 0x04CF },
- { 0x10C7, 0x2D27 },
- { 0x10CD, 0x2D2D },
- { 0x1E9E, 0x00DF },
- { 0x1F59, 0x1F51 },
- { 0x1F5B, 0x1F53 },
- { 0x1F5D, 0x1F55 },
- { 0x1F5F, 0x1F57 },
- { 0x1FEC, 0x1FE5 },
- { 0x2102, 0x2102 },
- { 0x2107, 0x2107 },
- { 0x2115, 0x2115 },
- { 0x2124, 0x2124 },
- { 0x2126, 0x03C9 },
- { 0x2128, 0x2128 },
- { 0x212A, 0x006B },
- { 0x212B, 0x00E5 },
- { 0x2132, 0x214E },
- { 0x2133, 0x2133 },
- { 0x2145, 0x2145 },
- { 0x2183, 0x2184 },
- { 0x2C60, 0x2C61 },
- { 0x2C62, 0x026B },
- { 0x2C63, 0x1D7D },
- { 0x2C64, 0x027D },
- { 0x2C6D, 0x0251 },
- { 0x2C6E, 0x0271 },
- { 0x2C6F, 0x0250 },
- { 0x2C70, 0x0252 },
- { 0x2C72, 0x2C73 },
- { 0x2C75, 0x2C76 },
- { 0x2CF2, 0x2CF3 },
- { 0xA77D, 0x1D79 },
- { 0xA78B, 0xA78C },
- { 0xA78D, 0x0265 },
- { 0xA7AA, 0x0266 },
- { 0xA7AB, 0x025C },
- { 0xA7AC, 0x0261 },
- { 0xA7AD, 0x026C },
- { 0xA7AE, 0x026A },
- { 0xA7B0, 0x029E },
- { 0xA7B1, 0x0287 },
- { 0xA7B2, 0x029D },
- { 0xA7B3, 0xAB53 },
- { 0xA7C4, 0xA794 },
- { 0xA7C5, 0x0282 },
- { 0xA7C6, 0x1D8E },
- { 0xA7D0, 0xA7D1 },
- { 0xA7F5, 0xA7F6 },
- { 0x1D49C, 0x1D49C },
- { 0x1D4A2, 0x1D4A2 },
- { 0x1D546, 0x1D546 },
- { 0x1D7CA, 0x1D7CA },
-};
+#include "utf-tables.c"
-C_regparm int C_utf_isupper(int r)
+/* Is rune r in set? */
+static int
+in_set(int r, const int (*set)[2], int n)
{
- int *match;
-
- if((match = bsearch(&r, upper3, nelem(upper3), sizeof *upper3, &rune2cmp)))
- return !((r - match[0]) % 2);
- if(bsearch(&r, upper2, nelem(upper2), sizeof *upper2, &rune2cmp))
- return 1;
- if(bsearch(&r, upper1, nelem(upper1), sizeof *upper1, &rune1cmp))
- return 1;
- return 0;
+ return bsearch(&r, set, n, sizeof *set, &rune2cmp) != NULL;
}
-C_regparm int C_utf_char_downcase(int r)
+/* Map rune r using map; return unchanged if not in map. */
+static int
+mapped(int r, const int (*map)[3], int n)
{
- int *match;
-
- match = bsearch(&r, upper3, nelem(upper3), sizeof *upper3, &rune2cmp);
- if (match)
- return ((r - match[0]) % 2) ? r : r + 1;
- match = bsearch(&r, upper2, nelem(upper2), sizeof *upper2, &rune2cmp);
- if (match)
- return match[2] + (r - match[0]);
- match = bsearch(&r, upper1, nelem(upper1), sizeof *upper1, &rune1cmp);
- if (match)
- return match[1];
- return r;
-}
-
-static int lower4[][2] = {
- { 0x0101, 0x012F },
- { 0x0133, 0x0137 },
- { 0x013A, 0x0148 },
- { 0x014B, 0x0177 },
- { 0x017A, 0x017E },
- { 0x0183, 0x0185 },
- { 0x01A1, 0x01A5 },
- { 0x01B4, 0x01B6 },
- { 0x01CE, 0x01DC },
- { 0x01DF, 0x01EF },
- { 0x01F9, 0x021F },
- { 0x0223, 0x0233 },
- { 0x0247, 0x024F },
- { 0x0371, 0x0373 },
- { 0x03D9, 0x03EF },
- { 0x0461, 0x0481 },
- { 0x048B, 0x04BF },
- { 0x04C2, 0x04CE },
- { 0x04D1, 0x052F },
- { 0x1E01, 0x1E95 },
- { 0x1EA1, 0x1EFF },
- { 0x2C68, 0x2C6C },
- { 0x2C81, 0x2CE3 },
- { 0x2CEC, 0x2CEE },
- { 0xA641, 0xA66D },
- { 0xA681, 0xA69B },
- { 0xA723, 0xA72F },
- { 0xA733, 0xA76F },
- { 0xA77A, 0xA77C },
- { 0xA77F, 0xA787 },
- { 0xA791, 0xA793 },
- { 0xA797, 0xA7A9 },
- { 0xA7B5, 0xA7C3 },
- { 0xA7C8, 0xA7CA },
- { 0xA7D7, 0xA7D9 },
-};
+ const int *m = bsearch(&r, map, n, sizeof *map, &rune2cmp);
-static int lower2[][3] = {
- { 0x0061, 0x007A, 0x0041 },
- { 0x00E0, 0x00F6, 0x00C0 },
- { 0x00F8, 0x00FE, 0x00D8 },
- { 0x01AA, 0x01AB, 0x01AA },
- { 0x0234, 0x0239, 0x0234 },
- { 0x023F, 0x0240, 0x2C7E },
- { 0x0256, 0x0257, 0x0189 },
- { 0x025D, 0x025F, 0x025D },
- { 0x026D, 0x026E, 0x026D },
- { 0x0273, 0x0274, 0x0273 },
- { 0x0276, 0x027C, 0x0276 },
- { 0x027E, 0x027F, 0x027E },
- { 0x0284, 0x0286, 0x0284 },
- { 0x028A, 0x028B, 0x01B1 },
- { 0x028D, 0x0291, 0x028D },
- { 0x0295, 0x029C, 0x0295 },
- { 0x029F, 0x02AF, 0x029F },
- { 0x037B, 0x037D, 0x03FD },
- { 0x03AD, 0x03AF, 0x0388 },
- { 0x03B1, 0x03C1, 0x0391 },
- { 0x03C3, 0x03CB, 0x03A3 },
- { 0x03CD, 0x03CE, 0x038E },
- { 0x0430, 0x044F, 0x0410 },
- { 0x0450, 0x045F, 0x0400 },
- { 0x0561, 0x0586, 0x0531 },
- { 0x0587, 0x0588, 0x0587 },
- { 0x10D0, 0x10FA, 0x1C90 },
- { 0x10FD, 0x10FF, 0x1CBD },
- { 0x13F8, 0x13FD, 0x13F0 },
- { 0x1C83, 0x1C84, 0x0421 },
- { 0x1D00, 0x1D2B, 0x1D00 },
- { 0x1D6B, 0x1D77, 0x1D6B },
- { 0x1D7A, 0x1D7C, 0x1D7A },
- { 0x1D7E, 0x1D8D, 0x1D7E },
- { 0x1D8F, 0x1D9A, 0x1D8F },
- { 0x1E96, 0x1E9A, 0x1E96 },
- { 0x1E9C, 0x1E9D, 0x1E9C },
- { 0x1F00, 0x1F07, 0x1F08 },
- { 0x1F10, 0x1F15, 0x1F18 },
- { 0x1F20, 0x1F27, 0x1F28 },
- { 0x1F30, 0x1F37, 0x1F38 },
- { 0x1F40, 0x1F45, 0x1F48 },
- { 0x1F60, 0x1F67, 0x1F68 },
- { 0x1F70, 0x1F71, 0x1FBA },
- { 0x1F72, 0x1F75, 0x1FC8 },
- { 0x1F76, 0x1F77, 0x1FDA },
- { 0x1F78, 0x1F79, 0x1FF8 },
- { 0x1F7A, 0x1F7B, 0x1FEA },
- { 0x1F7C, 0x1F7D, 0x1FFA },
- { 0x1F80, 0x1F87, 0x1F88 },
- { 0x1F90, 0x1F97, 0x1F98 },
- { 0x1FA0, 0x1FA7, 0x1FA8 },
- { 0x1FB0, 0x1FB1, 0x1FB8 },
- { 0x1FB6, 0x1FB7, 0x1FB6 },
- { 0x1FC6, 0x1FC7, 0x1FC6 },
- { 0x1FD0, 0x1FD1, 0x1FD8 },
- { 0x1FD2, 0x1FD3, 0x1FD2 },
- { 0x1FD6, 0x1FD7, 0x1FD6 },
- { 0x1FE0, 0x1FE1, 0x1FE8 },
- { 0x1FE2, 0x1FE4, 0x1FE2 },
- { 0x1FE6, 0x1FE7, 0x1FE6 },
- { 0x1FF6, 0x1FF7, 0x1FF6 },
- { 0x210E, 0x210F, 0x210E },
- { 0x213C, 0x213D, 0x213C },
- { 0x2146, 0x2149, 0x2146 },
- { 0x2C30, 0x2C5F, 0x2C00 },
- { 0x2C77, 0x2C7B, 0x2C77 },
- { 0x2D00, 0x2D25, 0x10A0 },
- { 0xA730, 0xA731, 0xA730 },
- { 0xA771, 0xA778, 0xA771 },
- { 0xAB30, 0xAB52, 0xAB30 },
- { 0xAB54, 0xAB5A, 0xAB54 },
- { 0xAB60, 0xAB68, 0xAB60 },
- { 0xAB70, 0xABBF, 0x13A0 },
- { 0xFB00, 0xFB06, 0xFB00 },
- { 0xFB13, 0xFB17, 0xFB13 },
- { 0xFF41, 0xFF5A, 0xFF21 },
- { 0x10428, 0x1044F, 0x10400 },
- { 0x104D8, 0x104FB, 0x104B0 },
- { 0x10597, 0x105A1, 0x10570 },
- { 0x105A3, 0x105B1, 0x1057C },
- { 0x105B3, 0x105B9, 0x1058C },
- { 0x105BB, 0x105BC, 0x10594 },
- { 0x10CC0, 0x10CF2, 0x10C80 },
- { 0x118C0, 0x118DF, 0x118A0 },
- { 0x16E60, 0x16E7F, 0x16E40 },
- { 0x1D41A, 0x1D433, 0x1D41A },
- { 0x1D44E, 0x1D454, 0x1D44E },
- { 0x1D456, 0x1D467, 0x1D456 },
- { 0x1D482, 0x1D49B, 0x1D482 },
- { 0x1D4B6, 0x1D4B9, 0x1D4B6 },
- { 0x1D4BD, 0x1D4C3, 0x1D4BD },
- { 0x1D4C5, 0x1D4CF, 0x1D4C5 },
- { 0x1D4EA, 0x1D503, 0x1D4EA },
- { 0x1D51E, 0x1D537, 0x1D51E },
- { 0x1D552, 0x1D56B, 0x1D552 },
- { 0x1D586, 0x1D59F, 0x1D586 },
- { 0x1D5BA, 0x1D5D3, 0x1D5BA },
- { 0x1D5EE, 0x1D607, 0x1D5EE },
- { 0x1D622, 0x1D63B, 0x1D622 },
- { 0x1D656, 0x1D66F, 0x1D656 },
- { 0x1D68A, 0x1D6A5, 0x1D68A },
- { 0x1D6C2, 0x1D6DA, 0x1D6C2 },
- { 0x1D6DC, 0x1D6E1, 0x1D6DC },
- { 0x1D6FC, 0x1D714, 0x1D6FC },
- { 0x1D716, 0x1D71B, 0x1D716 },
- { 0x1D736, 0x1D74E, 0x1D736 },
- { 0x1D750, 0x1D755, 0x1D750 },
- { 0x1D770, 0x1D788, 0x1D770 },
- { 0x1D78A, 0x1D78F, 0x1D78A },
- { 0x1D7AA, 0x1D7C2, 0x1D7AA },
- { 0x1D7C4, 0x1D7C9, 0x1D7C4 },
- { 0x1DF00, 0x1DF09, 0x1DF00 },
- { 0x1DF0B, 0x1DF1E, 0x1DF0B },
- { 0x1E922, 0x1E943, 0x1E900 },
-};
-
-static int lower1[][2] = {
- { 0x00B5, 0x039C },
- { 0x00DF, 0x00DF },
- { 0x00FF, 0x0178 },
- { 0x0131, 0x0049 },
- { 0x0138, 0x0138 },
- { 0x0149, 0x0149 },
- { 0x017F, 0x0053 },
- { 0x0180, 0x0243 },
- { 0x0188, 0x0187 },
- { 0x018C, 0x018B },
- { 0x018D, 0x018D },
- { 0x0192, 0x0191 },
- { 0x0195, 0x01F6 },
- { 0x0199, 0x0198 },
- { 0x019A, 0x023D },
- { 0x019B, 0x019B },
- { 0x019E, 0x0220 },
- { 0x01A8, 0x01A7 },
- { 0x01AD, 0x01AC },
- { 0x01B0, 0x01AF },
- { 0x01B9, 0x01B8 },
- { 0x01BA, 0x01BA },
- { 0x01BD, 0x01BC },
- { 0x01BE, 0x01BE },
- { 0x01BF, 0x01F7 },
- { 0x01C6, 0x01C4 },
- { 0x01C9, 0x01C7 },
- { 0x01CC, 0x01CA },
- { 0x01DD, 0x018E },
- { 0x01F0, 0x01F0 },
- { 0x01F3, 0x01F1 },
- { 0x01F5, 0x01F4 },
- { 0x0221, 0x0221 },
- { 0x023C, 0x023B },
- { 0x0242, 0x0241 },
- { 0x0250, 0x2C6F },
- { 0x0251, 0x2C6D },
- { 0x0252, 0x2C70 },
- { 0x0253, 0x0181 },
- { 0x0254, 0x0186 },
- { 0x0255, 0x0255 },
- { 0x0258, 0x0258 },
- { 0x0259, 0x018F },
- { 0x025A, 0x025A },
- { 0x025B, 0x0190 },
- { 0x025C, 0xA7AB },
- { 0x0260, 0x0193 },
- { 0x0261, 0xA7AC },
- { 0x0262, 0x0262 },
- { 0x0263, 0x0194 },
- { 0x0264, 0x0264 },
- { 0x0265, 0xA78D },
- { 0x0266, 0xA7AA },
- { 0x0267, 0x0267 },
- { 0x0268, 0x0197 },
- { 0x0269, 0x0196 },
- { 0x026A, 0xA7AE },
- { 0x026B, 0x2C62 },
- { 0x026C, 0xA7AD },
- { 0x026F, 0x019C },
- { 0x0270, 0x0270 },
- { 0x0271, 0x2C6E },
- { 0x0272, 0x019D },
- { 0x0275, 0x019F },
- { 0x027D, 0x2C64 },
- { 0x0280, 0x01A6 },
- { 0x0281, 0x0281 },
- { 0x0282, 0xA7C5 },
- { 0x0283, 0x01A9 },
- { 0x0287, 0xA7B1 },
- { 0x0288, 0x01AE },
- { 0x0289, 0x0244 },
- { 0x028C, 0x0245 },
- { 0x0292, 0x01B7 },
- { 0x0293, 0x0293 },
- { 0x029D, 0xA7B2 },
- { 0x029E, 0xA7B0 },
- { 0x0377, 0x0376 },
- { 0x0390, 0x0390 },
- { 0x03AC, 0x0386 },
- { 0x03B0, 0x03B0 },
- { 0x03C2, 0x03A3 },
- { 0x03CC, 0x038C },
- { 0x03D0, 0x0392 },
- { 0x03D1, 0x0398 },
- { 0x03D5, 0x03A6 },
- { 0x03D6, 0x03A0 },
- { 0x03D7, 0x03CF },
- { 0x03F0, 0x039A },
- { 0x03F1, 0x03A1 },
- { 0x03F2, 0x03F9 },
- { 0x03F3, 0x037F },
- { 0x03F5, 0x0395 },
- { 0x03F8, 0x03F7 },
- { 0x03FB, 0x03FA },
- { 0x03FC, 0x03FC },
- { 0x04CF, 0x04C0 },
- { 0x0560, 0x0560 },
- { 0x1C80, 0x0412 },
- { 0x1C81, 0x0414 },
- { 0x1C82, 0x041E },
- { 0x1C85, 0x0422 },
- { 0x1C86, 0x042A },
- { 0x1C87, 0x0462 },
- { 0x1C88, 0xA64A },
- { 0x1D79, 0xA77D },
- { 0x1D7D, 0x2C63 },
- { 0x1D8E, 0xA7C6 },
- { 0x1E9B, 0x1E60 },
- { 0x1E9F, 0x1E9F },
- { 0x1F50, 0x1F50 },
- { 0x1F51, 0x1F59 },
- { 0x1F52, 0x1F52 },
- { 0x1F53, 0x1F5B },
- { 0x1F54, 0x1F54 },
- { 0x1F55, 0x1F5D },
- { 0x1F56, 0x1F56 },
- { 0x1F57, 0x1F5F },
- { 0x1FB2, 0x1FB2 },
- { 0x1FB3, 0x1FBC },
- { 0x1FB4, 0x1FB4 },
- { 0x1FBE, 0x0399 },
- { 0x1FC2, 0x1FC2 },
- { 0x1FC3, 0x1FCC },
- { 0x1FC4, 0x1FC4 },
- { 0x1FE5, 0x1FEC },
- { 0x1FF2, 0x1FF2 },
- { 0x1FF3, 0x1FFC },
- { 0x1FF4, 0x1FF4 },
- { 0x210A, 0x210A },
- { 0x2113, 0x2113 },
- { 0x212F, 0x212F },
- { 0x2134, 0x2134 },
- { 0x2139, 0x2139 },
- { 0x214E, 0x2132 },
- { 0x2184, 0x2183 },
- { 0x2C61, 0x2C60 },
- { 0x2C65, 0x023A },
- { 0x2C66, 0x023E },
- { 0x2C71, 0x2C71 },
- { 0x2C73, 0x2C72 },
- { 0x2C74, 0x2C74 },
- { 0x2C76, 0x2C75 },
- { 0x2CE4, 0x2CE4 },
- { 0x2CF3, 0x2CF2 },
- { 0x2D27, 0x10C7 },
- { 0x2D2D, 0x10CD },
- { 0xA78C, 0xA78B },
- { 0xA78E, 0xA78E },
- { 0xA794, 0xA7C4 },
- { 0xA795, 0xA795 },
- { 0xA7AF, 0xA7AF },
- { 0xA7D1, 0xA7D0 },
- { 0xA7D3, 0xA7D3 },
- { 0xA7D5, 0xA7D5 },
- { 0xA7F6, 0xA7F5 },
- { 0xA7FA, 0xA7FA },
- { 0xAB53, 0xA7B3 },
- { 0x1D4BB, 0x1D4BB },
- { 0x1D7CB, 0x1D7CB },
-};
-
-C_regparm int C_utf_islower(int r)
-{
- int *match;
-
- if((match = bsearch(&r, lower4, nelem(lower4), sizeof *lower4, &rune2cmp)))
- return !((r - match[0]) % 2);
- if(bsearch(&r, lower2, nelem(lower2), sizeof *lower2, &rune2cmp))
- return 1;
- if(bsearch(&r, lower1, nelem(lower1), sizeof *lower1, &rune1cmp))
- return 1;
- return 0;
+ return m == NULL ? r : m[2] + (r - m[0]);
}
-C_regparm int C_utf_char_upcase(int r)
-{
- int *match;
-
- match = bsearch(&r, lower4, nelem(lower4), sizeof *lower4, &rune2cmp);
- if (match)
- return ((r - match[0]) % 2) ? r : r - 1;
- match = bsearch(&r, lower2, nelem(lower2), sizeof *lower2, &rune2cmp);
- if (match)
- return match[2] + (r - match[0]);
- match = bsearch(&r, lower1, nelem(lower1), sizeof *lower1, &rune1cmp);
- if (match)
- return match[1];
- return r;
-}
+/* As per R7RS 6.6 */
+C_regparm int C_utf_isalpha(int r) { return in_set(r, alpha, nelem(alpha)); }
+C_regparm int C_utf_isupper(int r) { return in_set(r, upper, nelem(upper)); }
+C_regparm int C_utf_islower(int r) { return in_set(r, lower, nelem(lower)); }
+C_regparm int C_utf_isspace(int r) { return in_set(r, space, nelem(space)); }
-static int digit2[][2] = {
- { 0x0030, 0x0039 },
- { 0x0660, 0x0669 },
- { 0x06F0, 0x06F9 },
- { 0x07C0, 0x07C9 },
- { 0x0966, 0x096F },
- { 0x09E6, 0x09EF },
- { 0x0A66, 0x0A6F },
- { 0x0AE6, 0x0AEF },
- { 0x0B66, 0x0B6F },
- { 0x0BE6, 0x0BEF },
- { 0x0C66, 0x0C6F },
- { 0x0CE6, 0x0CEF },
- { 0x0D66, 0x0D6F },
- { 0x0DE6, 0x0DEF },
- { 0x0E50, 0x0E59 },
- { 0x0ED0, 0x0ED9 },
- { 0x0F20, 0x0F29 },
- { 0x1040, 0x1049 },
- { 0x1090, 0x1099 },
- { 0x17E0, 0x17E9 },
- { 0x1810, 0x1819 },
- { 0x1946, 0x194F },
- { 0x19D0, 0x19D9 },
- { 0x1A80, 0x1A89 },
- { 0x1A90, 0x1A99 },
- { 0x1B50, 0x1B59 },
- { 0x1BB0, 0x1BB9 },
- { 0x1C40, 0x1C49 },
- { 0x1C50, 0x1C59 },
- { 0xA620, 0xA629 },
- { 0xA8D0, 0xA8D9 },
- { 0xA900, 0xA909 },
- { 0xA9D0, 0xA9D9 },
- { 0xA9F0, 0xA9F9 },
- { 0xAA50, 0xAA59 },
- { 0xABF0, 0xABF9 },
- { 0xFF10, 0xFF19 },
- { 0x104A0, 0x104A9 },
- { 0x10D30, 0x10D39 },
- { 0x11066, 0x1106F },
- { 0x110F0, 0x110F9 },
- { 0x11136, 0x1113F },
- { 0x111D0, 0x111D9 },
- { 0x112F0, 0x112F9 },
- { 0x11450, 0x11459 },
- { 0x114D0, 0x114D9 },
- { 0x11650, 0x11659 },
- { 0x116C0, 0x116C9 },
- { 0x11730, 0x11739 },
- { 0x118E0, 0x118E9 },
- { 0x11950, 0x11959 },
- { 0x11C50, 0x11C59 },
- { 0x11D50, 0x11D59 },
- { 0x11DA0, 0x11DA9 },
- { 0x16A60, 0x16A69 },
- { 0x16AC0, 0x16AC9 },
- { 0x16B50, 0x16B59 },
- { 0x1D7CE, 0x1D7FF },
- { 0x1E140, 0x1E149 },
- { 0x1E2F0, 0x1E2F9 },
- { 0x1E950, 0x1E959 },
- { 0x1FBF0, 0x1FBF9 },
-};
+C_regparm int C_utf_char_upcase(int r) { return mapped(r, uppermap, nelem(uppermap)); }
+C_regparm int C_utf_char_downcase(int r) { return mapped(r, lowermap, nelem(lowermap)); }
+/* Return rune r decimal digit value + 1, or 0 if not a decimal digit. */
C_regparm int C_utf_isdigit(int r)
{
- int *dp = bsearch(&r, digit2, nelem(digit2), sizeof *digit2, &rune2cmp);
- if(dp != NULL) return 1 + r - dp[ 0 ];
- return 0;
-}
-
-static int alpha3[][2] = {
- { 0x00D6, 0x00D8 },
- { 0x00F6, 0x00F8 },
- { 0x02EC, 0x02EE },
- { 0x0374, 0x0376 },
- { 0x037D, 0x037F },
- { 0x0386, 0x0388 },
- { 0x038A, 0x038E },
- { 0x03A1, 0x03A3 },
- { 0x03F5, 0x03F7 },
- { 0x052F, 0x0531 },
- { 0x066F, 0x0671 },
- { 0x06D3, 0x06D5 },
- { 0x0710, 0x0712 },
- { 0x0887, 0x0889 },
- { 0x09A8, 0x09AA },
- { 0x09B0, 0x09B2 },
- { 0x09DD, 0x09DF },
- { 0x0A28, 0x0A2A },
- { 0x0A30, 0x0A32 },
- { 0x0A33, 0x0A35 },
- { 0x0A36, 0x0A38 },
- { 0x0A5C, 0x0A5E },
- { 0x0A8D, 0x0A8F },
- { 0x0A91, 0x0A93 },
- { 0x0AA8, 0x0AAA },
- { 0x0AB0, 0x0AB2 },
- { 0x0AB3, 0x0AB5 },
- { 0x0B28, 0x0B2A },
- { 0x0B30, 0x0B32 },
- { 0x0B33, 0x0B35 },
- { 0x0B5D, 0x0B5F },
- { 0x0B83, 0x0B85 },
- { 0x0B90, 0x0B92 },
- { 0x0B9A, 0x0B9E },
- { 0x0C0C, 0x0C0E },
- { 0x0C10, 0x0C12 },
- { 0x0C28, 0x0C2A },
- { 0x0C8C, 0x0C8E },
- { 0x0C90, 0x0C92 },
- { 0x0CA8, 0x0CAA },
- { 0x0CB3, 0x0CB5 },
- { 0x0CDE, 0x0CE0 },
- { 0x0D0C, 0x0D0E },
- { 0x0D10, 0x0D12 },
- { 0x0DB1, 0x0DB3 },
- { 0x0DBB, 0x0DBD },
- { 0x0E30, 0x0E32 },
- { 0x0E82, 0x0E86 },
- { 0x0E8A, 0x0E8C },
- { 0x0EA3, 0x0EA7 },
- { 0x0EB0, 0x0EB2 },
- { 0x0EC4, 0x0EC6 },
- { 0x0F47, 0x0F49 },
- { 0x10C5, 0x10C7 },
- { 0x10FA, 0x10FC },
- { 0x1248, 0x124A },
- { 0x1256, 0x125A },
- { 0x1288, 0x128A },
- { 0x12B0, 0x12B2 },
- { 0x12BE, 0x12C2 },
- { 0x12D6, 0x12D8 },
- { 0x1310, 0x1312 },
- { 0x167F, 0x1681 },
- { 0x176C, 0x176E },
- { 0x18A8, 0x18AA },
- { 0x1CEC, 0x1CEE },
- { 0x1CF3, 0x1CF5 },
- { 0x1F57, 0x1F5F },
- { 0x1FB4, 0x1FB6 },
- { 0x1FBC, 0x1FBE },
- { 0x1FC4, 0x1FC6 },
- { 0x1FF4, 0x1FF6 },
- { 0x2113, 0x2115 },
- { 0x2124, 0x212A },
- { 0x212D, 0x212F },
- { 0x2D25, 0x2D27 },
- { 0x2DA6, 0x2DA8 },
- { 0x2DAE, 0x2DB0 },
- { 0x2DB6, 0x2DB8 },
- { 0x2DBE, 0x2DC0 },
- { 0x2DC6, 0x2DC8 },
- { 0x2DCE, 0x2DD0 },
- { 0x2DD6, 0x2DD8 },
- { 0x309F, 0x30A1 },
- { 0x30FA, 0x30FC },
- { 0x312F, 0x3131 },
- { 0xA7D1, 0xA7D5 },
- { 0xA801, 0xA803 },
- { 0xA805, 0xA807 },
- { 0xA80A, 0xA80C },
- { 0xA8FB, 0xA8FD },
- { 0xA9E4, 0xA9E6 },
- { 0xA9FE, 0xAA00 },
- { 0xAA42, 0xAA44 },
- { 0xAAAF, 0xAAB1 },
- { 0xAAC0, 0xAAC2 },
- { 0xAB26, 0xAB28 },
- { 0xAB2E, 0xAB30 },
- { 0xAB5A, 0xAB5C },
- { 0xFB1D, 0xFB1F },
- { 0xFB28, 0xFB2A },
- { 0xFB36, 0xFB38 },
- { 0xFB3C, 0xFB40 },
- { 0xFB41, 0xFB43 },
- { 0xFB44, 0xFB46 },
- { 0xFE74, 0xFE76 },
- { 0x1000B, 0x1000D },
- { 0x10026, 0x10028 },
- { 0x1003A, 0x1003C },
- { 0x1003D, 0x1003F },
- { 0x10340, 0x10342 },
- { 0x1057A, 0x1057C },
- { 0x1058A, 0x1058C },
- { 0x10592, 0x10594 },
- { 0x10595, 0x10597 },
- { 0x105A1, 0x105A3 },
- { 0x105B1, 0x105B3 },
- { 0x105B9, 0x105BB },
- { 0x10785, 0x10787 },
- { 0x107B0, 0x107B2 },
- { 0x10808, 0x1080A },
- { 0x10835, 0x10837 },
- { 0x108F2, 0x108F4 },
- { 0x10A13, 0x10A15 },
- { 0x10A17, 0x10A19 },
- { 0x10AC7, 0x10AC9 },
- { 0x111DA, 0x111DC },
- { 0x11211, 0x11213 },
- { 0x11286, 0x1128A },
- { 0x1128D, 0x1128F },
- { 0x1129D, 0x1129F },
- { 0x11328, 0x1132A },
- { 0x11330, 0x11332 },
- { 0x11333, 0x11335 },
- { 0x114C5, 0x114C7 },
- { 0x11913, 0x11915 },
- { 0x11916, 0x11918 },
- { 0x1193F, 0x11941 },
- { 0x119E1, 0x119E3 },
- { 0x11C08, 0x11C0A },
- { 0x11D06, 0x11D08 },
- { 0x11D09, 0x11D0B },
- { 0x11D65, 0x11D67 },
- { 0x11D68, 0x11D6A },
- { 0x16FE1, 0x16FE3 },
- { 0x1AFF3, 0x1AFF5 },
- { 0x1AFFB, 0x1AFFD },
- { 0x1AFFE, 0x1B000 },
- { 0x1D454, 0x1D456 },
- { 0x1D49C, 0x1D49E },
- { 0x1D4AC, 0x1D4AE },
- { 0x1D4B9, 0x1D4BD },
- { 0x1D4C3, 0x1D4C5 },
- { 0x1D505, 0x1D507 },
- { 0x1D514, 0x1D516 },
- { 0x1D51C, 0x1D51E },
- { 0x1D539, 0x1D53B },
- { 0x1D53E, 0x1D540 },
- { 0x1D544, 0x1D546 },
- { 0x1D550, 0x1D552 },
- { 0x1D6C0, 0x1D6C2 },
- { 0x1D6DA, 0x1D6DC },
- { 0x1D6FA, 0x1D6FC },
- { 0x1D714, 0x1D716 },
- { 0x1D734, 0x1D736 },
- { 0x1D74E, 0x1D750 },
- { 0x1D76E, 0x1D770 },
- { 0x1D788, 0x1D78A },
- { 0x1D7A8, 0x1D7AA },
- { 0x1D7C2, 0x1D7C4 },
- { 0x1E7E6, 0x1E7E8 },
- { 0x1E7EB, 0x1E7ED },
- { 0x1E7EE, 0x1E7F0 },
- { 0x1E7FE, 0x1E800 },
- { 0x1EE03, 0x1EE05 },
- { 0x1EE1F, 0x1EE21 },
- { 0x1EE22, 0x1EE24 },
- { 0x1EE27, 0x1EE29 },
- { 0x1EE32, 0x1EE34 },
- { 0x1EE37, 0x1EE3B },
- { 0x1EE47, 0x1EE4D },
- { 0x1EE4F, 0x1EE51 },
- { 0x1EE52, 0x1EE54 },
- { 0x1EE57, 0x1EE61 },
- { 0x1EE62, 0x1EE64 },
- { 0x1EE6A, 0x1EE6C },
- { 0x1EE72, 0x1EE74 },
- { 0x1EE77, 0x1EE79 },
- { 0x1EE7C, 0x1EE80 },
- { 0x1EE89, 0x1EE8B },
- { 0x1EEA3, 0x1EEA5 },
- { 0x1EEA9, 0x1EEAB },
-};
-
-static int alpha2[][2] = {
- { 0x0041, 0x005A },
- { 0x0061, 0x007A },
- { 0x00C0, 0x00D6 },
- { 0x00D8, 0x00F6 },
- { 0x00F8, 0x02C1 },
- { 0x02C6, 0x02D1 },
- { 0x02E0, 0x02E4 },
- { 0x0370, 0x0374 },
- { 0x0376, 0x0377 },
- { 0x037A, 0x037D },
- { 0x0388, 0x038A },
- { 0x038E, 0x03A1 },
- { 0x03A3, 0x03F5 },
- { 0x03F7, 0x0481 },
- { 0x048A, 0x052F },
- { 0x0531, 0x0556 },
- { 0x0560, 0x0588 },
- { 0x05D0, 0x05EA },
- { 0x05EF, 0x05F2 },
- { 0x0620, 0x064A },
- { 0x066E, 0x066F },
- { 0x0671, 0x06D3 },
- { 0x06E5, 0x06E6 },
- { 0x06EE, 0x06EF },
- { 0x06FA, 0x06FC },
- { 0x0712, 0x072F },
- { 0x074D, 0x07A5 },
- { 0x07CA, 0x07EA },
- { 0x07F4, 0x07F5 },
- { 0x0800, 0x0815 },
- { 0x0840, 0x0858 },
- { 0x0860, 0x086A },
- { 0x0870, 0x0887 },
- { 0x0889, 0x088E },
- { 0x08A0, 0x08C9 },
- { 0x0904, 0x0939 },
- { 0x0958, 0x0961 },
- { 0x0971, 0x0980 },
- { 0x0985, 0x098C },
- { 0x098F, 0x0990 },
- { 0x0993, 0x09A8 },
- { 0x09AA, 0x09B0 },
- { 0x09B6, 0x09B9 },
- { 0x09DC, 0x09DD },
- { 0x09DF, 0x09E1 },
- { 0x09F0, 0x09F1 },
- { 0x0A05, 0x0A0A },
- { 0x0A0F, 0x0A10 },
- { 0x0A13, 0x0A28 },
- { 0x0A2A, 0x0A30 },
- { 0x0A32, 0x0A33 },
- { 0x0A35, 0x0A36 },
- { 0x0A38, 0x0A39 },
- { 0x0A59, 0x0A5C },
- { 0x0A72, 0x0A74 },
- { 0x0A85, 0x0A8D },
- { 0x0A8F, 0x0A91 },
- { 0x0A93, 0x0AA8 },
- { 0x0AAA, 0x0AB0 },
- { 0x0AB2, 0x0AB3 },
- { 0x0AB5, 0x0AB9 },
- { 0x0AE0, 0x0AE1 },
- { 0x0B05, 0x0B0C },
- { 0x0B0F, 0x0B10 },
- { 0x0B13, 0x0B28 },
- { 0x0B2A, 0x0B30 },
- { 0x0B32, 0x0B33 },
- { 0x0B35, 0x0B39 },
- { 0x0B5C, 0x0B5D },
- { 0x0B5F, 0x0B61 },
- { 0x0B85, 0x0B8A },
- { 0x0B8E, 0x0B90 },
- { 0x0B92, 0x0B95 },
- { 0x0B99, 0x0B9A },
- { 0x0B9E, 0x0B9F },
- { 0x0BA3, 0x0BA4 },
- { 0x0BA8, 0x0BAA },
- { 0x0BAE, 0x0BB9 },
- { 0x0C05, 0x0C0C },
- { 0x0C0E, 0x0C10 },
- { 0x0C12, 0x0C28 },
- { 0x0C2A, 0x0C39 },
- { 0x0C58, 0x0C5A },
- { 0x0C60, 0x0C61 },
- { 0x0C85, 0x0C8C },
- { 0x0C8E, 0x0C90 },
- { 0x0C92, 0x0CA8 },
- { 0x0CAA, 0x0CB3 },
- { 0x0CB5, 0x0CB9 },
- { 0x0CDD, 0x0CDE },
- { 0x0CE0, 0x0CE1 },
- { 0x0CF1, 0x0CF2 },
- { 0x0D04, 0x0D0C },
- { 0x0D0E, 0x0D10 },
- { 0x0D12, 0x0D3A },
- { 0x0D54, 0x0D56 },
- { 0x0D5F, 0x0D61 },
- { 0x0D7A, 0x0D7F },
- { 0x0D85, 0x0D96 },
- { 0x0D9A, 0x0DB1 },
- { 0x0DB3, 0x0DBB },
- { 0x0DC0, 0x0DC6 },
- { 0x0E01, 0x0E30 },
- { 0x0E32, 0x0E33 },
- { 0x0E40, 0x0E46 },
- { 0x0E81, 0x0E82 },
- { 0x0E86, 0x0E8A },
- { 0x0E8C, 0x0EA3 },
- { 0x0EA7, 0x0EB0 },
- { 0x0EB2, 0x0EB3 },
- { 0x0EC0, 0x0EC4 },
- { 0x0EDC, 0x0EDF },
- { 0x0F40, 0x0F47 },
- { 0x0F49, 0x0F6C },
- { 0x0F88, 0x0F8C },
- { 0x1000, 0x102A },
- { 0x1050, 0x1055 },
- { 0x105A, 0x105D },
- { 0x1065, 0x1066 },
- { 0x106E, 0x1070 },
- { 0x1075, 0x1081 },
- { 0x10A0, 0x10C5 },
- { 0x10D0, 0x10FA },
- { 0x10FC, 0x1248 },
- { 0x124A, 0x124D },
- { 0x1250, 0x1256 },
- { 0x125A, 0x125D },
- { 0x1260, 0x1288 },
- { 0x128A, 0x128D },
- { 0x1290, 0x12B0 },
- { 0x12B2, 0x12B5 },
- { 0x12B8, 0x12BE },
- { 0x12C2, 0x12C5 },
- { 0x12C8, 0x12D6 },
- { 0x12D8, 0x1310 },
- { 0x1312, 0x1315 },
- { 0x1318, 0x135A },
- { 0x1380, 0x138F },
- { 0x13A0, 0x13F5 },
- { 0x13F8, 0x13FD },
- { 0x1401, 0x166C },
- { 0x166F, 0x167F },
- { 0x1681, 0x169A },
- { 0x16A0, 0x16EA },
- { 0x16F1, 0x16F8 },
- { 0x1700, 0x1711 },
- { 0x171F, 0x1731 },
- { 0x1740, 0x1751 },
- { 0x1760, 0x176C },
- { 0x176E, 0x1770 },
- { 0x1780, 0x17B3 },
- { 0x1820, 0x1878 },
- { 0x1880, 0x1884 },
- { 0x1887, 0x18A8 },
- { 0x18B0, 0x18F5 },
- { 0x1900, 0x191E },
- { 0x1950, 0x196D },
- { 0x1970, 0x1974 },
- { 0x1980, 0x19AB },
- { 0x19B0, 0x19C9 },
- { 0x1A00, 0x1A16 },
- { 0x1A20, 0x1A54 },
- { 0x1B05, 0x1B33 },
- { 0x1B45, 0x1B4C },
- { 0x1B83, 0x1BA0 },
- { 0x1BAE, 0x1BAF },
- { 0x1BBA, 0x1BE5 },
- { 0x1C00, 0x1C23 },
- { 0x1C4D, 0x1C4F },
- { 0x1C5A, 0x1C7D },
- { 0x1C80, 0x1C88 },
- { 0x1C90, 0x1CBA },
- { 0x1CBD, 0x1CBF },
- { 0x1CE9, 0x1CEC },
- { 0x1CEE, 0x1CF3 },
- { 0x1CF5, 0x1CF6 },
- { 0x1D00, 0x1DBF },
- { 0x1E00, 0x1F15 },
- { 0x1F18, 0x1F1D },
- { 0x1F20, 0x1F45 },
- { 0x1F48, 0x1F4D },
- { 0x1F50, 0x1F57 },
- { 0x1F5F, 0x1F7D },
- { 0x1F80, 0x1FB4 },
- { 0x1FB6, 0x1FBC },
- { 0x1FC2, 0x1FC4 },
- { 0x1FC6, 0x1FCC },
- { 0x1FD0, 0x1FD3 },
- { 0x1FD6, 0x1FDB },
- { 0x1FE0, 0x1FEC },
- { 0x1FF2, 0x1FF4 },
- { 0x1FF6, 0x1FFC },
- { 0x2090, 0x209C },
- { 0x210A, 0x2113 },
- { 0x2119, 0x211D },
- { 0x212A, 0x212D },
- { 0x212F, 0x2139 },
- { 0x213C, 0x213F },
- { 0x2145, 0x2149 },
- { 0x2183, 0x2184 },
- { 0x2C00, 0x2CE4 },
- { 0x2CEB, 0x2CEE },
- { 0x2CF2, 0x2CF3 },
- { 0x2D00, 0x2D25 },
- { 0x2D30, 0x2D67 },
- { 0x2D80, 0x2D96 },
- { 0x2DA0, 0x2DA6 },
- { 0x2DA8, 0x2DAE },
- { 0x2DB0, 0x2DB6 },
- { 0x2DB8, 0x2DBE },
- { 0x2DC0, 0x2DC6 },
- { 0x2DC8, 0x2DCE },
- { 0x2DD0, 0x2DD6 },
- { 0x2DD8, 0x2DDE },
- { 0x3005, 0x3006 },
- { 0x3031, 0x3035 },
- { 0x303B, 0x303C },
- { 0x3041, 0x3096 },
- { 0x309D, 0x309F },
- { 0x30A1, 0x30FA },
- { 0x30FC, 0x30FF },
- { 0x3105, 0x312F },
- { 0x3131, 0x318E },
- { 0x31A0, 0x31BF },
- { 0x31F0, 0x31FF },
- { 0x9FFF, 0xA48C },
- { 0xA4D0, 0xA4FD },
- { 0xA500, 0xA60C },
- { 0xA610, 0xA61F },
- { 0xA62A, 0xA62B },
- { 0xA640, 0xA66E },
- { 0xA67F, 0xA69D },
- { 0xA6A0, 0xA6E5 },
- { 0xA717, 0xA71F },
- { 0xA722, 0xA788 },
- { 0xA78B, 0xA7CA },
- { 0xA7D0, 0xA7D1 },
- { 0xA7D5, 0xA7D9 },
- { 0xA7F2, 0xA801 },
- { 0xA803, 0xA805 },
- { 0xA807, 0xA80A },
- { 0xA80C, 0xA822 },
- { 0xA840, 0xA873 },
- { 0xA882, 0xA8B3 },
- { 0xA8F2, 0xA8F7 },
- { 0xA8FD, 0xA8FE },
- { 0xA90A, 0xA925 },
- { 0xA930, 0xA946 },
- { 0xA960, 0xA97C },
- { 0xA984, 0xA9B2 },
- { 0xA9E0, 0xA9E4 },
- { 0xA9E6, 0xA9EF },
- { 0xA9FA, 0xA9FE },
- { 0xAA00, 0xAA28 },
- { 0xAA40, 0xAA42 },
- { 0xAA44, 0xAA4B },
- { 0xAA60, 0xAA76 },
- { 0xAA7E, 0xAAAF },
- { 0xAAB5, 0xAAB6 },
- { 0xAAB9, 0xAABD },
- { 0xAADB, 0xAADD },
- { 0xAAE0, 0xAAEA },
- { 0xAAF2, 0xAAF4 },
- { 0xAB01, 0xAB06 },
- { 0xAB09, 0xAB0E },
- { 0xAB11, 0xAB16 },
- { 0xAB20, 0xAB26 },
- { 0xAB28, 0xAB2E },
- { 0xAB30, 0xAB5A },
- { 0xAB5C, 0xAB69 },
- { 0xAB70, 0xABE2 },
- { 0xD7B0, 0xD7C6 },
- { 0xD7CB, 0xD7FB },
- { 0xF900, 0xFA6D },
- { 0xFA70, 0xFAD9 },
- { 0xFB00, 0xFB06 },
- { 0xFB13, 0xFB17 },
- { 0xFB1F, 0xFB28 },
- { 0xFB2A, 0xFB36 },
- { 0xFB38, 0xFB3C },
- { 0xFB40, 0xFB41 },
- { 0xFB43, 0xFB44 },
- { 0xFB46, 0xFBB1 },
- { 0xFBD3, 0xFD3D },
- { 0xFD50, 0xFD8F },
- { 0xFD92, 0xFDC7 },
- { 0xFDF0, 0xFDFB },
- { 0xFE70, 0xFE74 },
- { 0xFE76, 0xFEFC },
- { 0xFF21, 0xFF3A },
- { 0xFF41, 0xFF5A },
- { 0xFF66, 0xFFBE },
- { 0xFFC2, 0xFFC7 },
- { 0xFFCA, 0xFFCF },
- { 0xFFD2, 0xFFD7 },
- { 0xFFDA, 0xFFDC },
- { 0x10000, 0x1000B },
- { 0x1000D, 0x10026 },
- { 0x10028, 0x1003A },
- { 0x1003C, 0x1003D },
- { 0x1003F, 0x1004D },
- { 0x10050, 0x1005D },
- { 0x10080, 0x100FA },
- { 0x10280, 0x1029C },
- { 0x102A0, 0x102D0 },
- { 0x10300, 0x1031F },
- { 0x1032D, 0x10340 },
- { 0x10342, 0x10349 },
- { 0x10350, 0x10375 },
- { 0x10380, 0x1039D },
- { 0x103A0, 0x103C3 },
- { 0x103C8, 0x103CF },
- { 0x10400, 0x1049D },
- { 0x104B0, 0x104D3 },
- { 0x104D8, 0x104FB },
- { 0x10500, 0x10527 },
- { 0x10530, 0x10563 },
- { 0x10570, 0x1057A },
- { 0x1057C, 0x1058A },
- { 0x1058C, 0x10592 },
- { 0x10594, 0x10595 },
- { 0x10597, 0x105A1 },
- { 0x105A3, 0x105B1 },
- { 0x105B3, 0x105B9 },
- { 0x105BB, 0x105BC },
- { 0x10600, 0x10736 },
- { 0x10740, 0x10755 },
- { 0x10760, 0x10767 },
- { 0x10780, 0x10785 },
- { 0x10787, 0x107B0 },
- { 0x107B2, 0x107BA },
- { 0x10800, 0x10805 },
- { 0x1080A, 0x10835 },
- { 0x10837, 0x10838 },
- { 0x1083F, 0x10855 },
- { 0x10860, 0x10876 },
- { 0x10880, 0x1089E },
- { 0x108E0, 0x108F2 },
- { 0x108F4, 0x108F5 },
- { 0x10900, 0x10915 },
- { 0x10920, 0x10939 },
- { 0x10980, 0x109B7 },
- { 0x109BE, 0x109BF },
- { 0x10A10, 0x10A13 },
- { 0x10A15, 0x10A17 },
- { 0x10A19, 0x10A35 },
- { 0x10A60, 0x10A7C },
- { 0x10A80, 0x10A9C },
- { 0x10AC0, 0x10AC7 },
- { 0x10AC9, 0x10AE4 },
- { 0x10B00, 0x10B35 },
- { 0x10B40, 0x10B55 },
- { 0x10B60, 0x10B72 },
- { 0x10B80, 0x10B91 },
- { 0x10C00, 0x10C48 },
- { 0x10C80, 0x10CB2 },
- { 0x10CC0, 0x10CF2 },
- { 0x10D00, 0x10D23 },
- { 0x10E80, 0x10EA9 },
- { 0x10EB0, 0x10EB1 },
- { 0x10F00, 0x10F1C },
- { 0x10F30, 0x10F45 },
- { 0x10F70, 0x10F81 },
- { 0x10FB0, 0x10FC4 },
- { 0x10FE0, 0x10FF6 },
- { 0x11003, 0x11037 },
- { 0x11071, 0x11072 },
- { 0x11083, 0x110AF },
- { 0x110D0, 0x110E8 },
- { 0x11103, 0x11126 },
- { 0x11150, 0x11172 },
- { 0x11183, 0x111B2 },
- { 0x111C1, 0x111C4 },
- { 0x11200, 0x11211 },
- { 0x11213, 0x1122B },
- { 0x11280, 0x11286 },
- { 0x1128A, 0x1128D },
- { 0x1128F, 0x1129D },
- { 0x1129F, 0x112A8 },
- { 0x112B0, 0x112DE },
- { 0x11305, 0x1130C },
- { 0x1130F, 0x11310 },
- { 0x11313, 0x11328 },
- { 0x1132A, 0x11330 },
- { 0x11332, 0x11333 },
- { 0x11335, 0x11339 },
- { 0x1135D, 0x11361 },
- { 0x11400, 0x11434 },
- { 0x11447, 0x1144A },
- { 0x1145F, 0x11461 },
- { 0x11480, 0x114AF },
- { 0x114C4, 0x114C5 },
- { 0x11580, 0x115AE },
- { 0x115D8, 0x115DB },
- { 0x11600, 0x1162F },
- { 0x11680, 0x116AA },
- { 0x11700, 0x1171A },
- { 0x11740, 0x11746 },
- { 0x11800, 0x1182B },
- { 0x118A0, 0x118DF },
- { 0x118FF, 0x11906 },
- { 0x1190C, 0x11913 },
- { 0x11915, 0x11916 },
- { 0x11918, 0x1192F },
- { 0x119A0, 0x119A7 },
- { 0x119AA, 0x119D0 },
- { 0x11A0B, 0x11A32 },
- { 0x11A5C, 0x11A89 },
- { 0x11AB0, 0x11AF8 },
- { 0x11C00, 0x11C08 },
- { 0x11C0A, 0x11C2E },
- { 0x11C72, 0x11C8F },
- { 0x11D00, 0x11D06 },
- { 0x11D08, 0x11D09 },
- { 0x11D0B, 0x11D30 },
- { 0x11D60, 0x11D65 },
- { 0x11D67, 0x11D68 },
- { 0x11D6A, 0x11D89 },
- { 0x11EE0, 0x11EF2 },
- { 0x12000, 0x12399 },
- { 0x12480, 0x12543 },
- { 0x12F90, 0x12FF0 },
- { 0x13000, 0x1342E },
- { 0x14400, 0x14646 },
- { 0x16800, 0x16A38 },
- { 0x16A40, 0x16A5E },
- { 0x16A70, 0x16ABE },
- { 0x16AD0, 0x16AED },
- { 0x16B00, 0x16B2F },
- { 0x16B40, 0x16B43 },
- { 0x16B63, 0x16B77 },
- { 0x16B7D, 0x16B8F },
- { 0x16E40, 0x16E7F },
- { 0x16F00, 0x16F4A },
- { 0x16F93, 0x16F9F },
- { 0x16FE0, 0x16FE1 },
- { 0x18800, 0x18CD5 },
- { 0x1AFF0, 0x1AFF3 },
- { 0x1AFF5, 0x1AFFB },
- { 0x1AFFD, 0x1AFFE },
- { 0x1B000, 0x1B122 },
- { 0x1B150, 0x1B152 },
- { 0x1B164, 0x1B167 },
- { 0x1B170, 0x1B2FB },
- { 0x1BC00, 0x1BC6A },
- { 0x1BC70, 0x1BC7C },
- { 0x1BC80, 0x1BC88 },
- { 0x1BC90, 0x1BC99 },
- { 0x1D400, 0x1D454 },
- { 0x1D456, 0x1D49C },
- { 0x1D49E, 0x1D49F },
- { 0x1D4A5, 0x1D4A6 },
- { 0x1D4A9, 0x1D4AC },
- { 0x1D4AE, 0x1D4B9 },
- { 0x1D4BD, 0x1D4C3 },
- { 0x1D4C5, 0x1D505 },
- { 0x1D507, 0x1D50A },
- { 0x1D50D, 0x1D514 },
- { 0x1D516, 0x1D51C },
- { 0x1D51E, 0x1D539 },
- { 0x1D53B, 0x1D53E },
- { 0x1D540, 0x1D544 },
- { 0x1D54A, 0x1D550 },
- { 0x1D552, 0x1D6A5 },
- { 0x1D6A8, 0x1D6C0 },
- { 0x1D6C2, 0x1D6DA },
- { 0x1D6DC, 0x1D6FA },
- { 0x1D6FC, 0x1D714 },
- { 0x1D716, 0x1D734 },
- { 0x1D736, 0x1D74E },
- { 0x1D750, 0x1D76E },
- { 0x1D770, 0x1D788 },
- { 0x1D78A, 0x1D7A8 },
- { 0x1D7AA, 0x1D7C2 },
- { 0x1D7C4, 0x1D7CB },
- { 0x1DF00, 0x1DF1E },
- { 0x1E100, 0x1E12C },
- { 0x1E137, 0x1E13D },
- { 0x1E290, 0x1E2AD },
- { 0x1E2C0, 0x1E2EB },
- { 0x1E7E0, 0x1E7E6 },
- { 0x1E7E8, 0x1E7EB },
- { 0x1E7ED, 0x1E7EE },
- { 0x1E7F0, 0x1E7FE },
- { 0x1E800, 0x1E8C4 },
- { 0x1E900, 0x1E943 },
- { 0x1EE00, 0x1EE03 },
- { 0x1EE05, 0x1EE1F },
- { 0x1EE21, 0x1EE22 },
- { 0x1EE29, 0x1EE32 },
- { 0x1EE34, 0x1EE37 },
- { 0x1EE4D, 0x1EE4F },
- { 0x1EE51, 0x1EE52 },
- { 0x1EE61, 0x1EE62 },
- { 0x1EE67, 0x1EE6A },
- { 0x1EE6C, 0x1EE72 },
- { 0x1EE74, 0x1EE77 },
- { 0x1EE79, 0x1EE7C },
- { 0x1EE80, 0x1EE89 },
- { 0x1EE8B, 0x1EE9B },
- { 0x1EEA1, 0x1EEA3 },
- { 0x1EEA5, 0x1EEA9 },
- { 0x1EEAB, 0x1EEBB },
- { 0x2F800, 0x2FA1D },
-};
-
-static int alpha1[] = {
- 0x00AA,
- 0x00B5,
- 0x00BA,
- 0x0559,
- 0x06FF,
- 0x07B1,
- 0x07FA,
- 0x081A,
- 0x0824,
- 0x0828,
- 0x093D,
- 0x0950,
- 0x09BD,
- 0x09CE,
- 0x09FC,
- 0x0ABD,
- 0x0AD0,
- 0x0AF9,
- 0x0B3D,
- 0x0B71,
- 0x0BD0,
- 0x0C3D,
- 0x0C5D,
- 0x0C80,
- 0x0CBD,
- 0x0D3D,
- 0x0D4E,
- 0x0EBD,
- 0x0F00,
- 0x103F,
- 0x1061,
- 0x108E,
- 0x10CD,
- 0x17D7,
- 0x17DC,
- 0x1AA7,
- 0x1CFA,
- 0x2071,
- 0x207F,
- 0x2102,
- 0x2107,
- 0x214E,
- 0x2D2D,
- 0x2D6F,
- 0x2E2F,
- 0x3400,
- 0x4DBF,
- 0x4E00,
- 0xA9CF,
- 0xAA7A,
- 0xAC00,
- 0xD7A3,
- 0x1083C,
- 0x10A00,
- 0x10F27,
- 0x11075,
- 0x11144,
- 0x11147,
- 0x11176,
- 0x1133D,
- 0x11350,
- 0x11644,
- 0x116B8,
- 0x11909,
- 0x11A00,
- 0x11A3A,
- 0x11A50,
- 0x11A9D,
- 0x11C40,
- 0x11D46,
- 0x11D98,
- 0x11FB0,
- 0x16F50,
- 0x17000,
- 0x187F7,
- 0x18D00,
- 0x18D08,
- 0x1D4A2,
- 0x1E14E,
- 0x1E94B,
- 0x1EE42,
- 0x20000,
- 0x2A6DF,
- 0x2A700,
- 0x2B738,
- 0x2B740,
- 0x2B81D,
- 0x2B820,
- 0x2CEA1,
- 0x2CEB0,
- 0x2EBE0,
- 0x30000,
- 0x3134A,
-};
-
-C_regparm int C_utf_isalpha(int r)
-{
- int *match;
-
- if((match = bsearch(&r, alpha3, nelem(alpha3), sizeof *alpha3, &rune2cmp)))
- return !((r - match[0]) % 2);
- if(bsearch(&r, alpha2, nelem(alpha2), sizeof *alpha2, &rune2cmp))
- return 1;
- if(bsearch(&r, alpha1, nelem(alpha1), sizeof *alpha1, &rune1cmp))
- return 1;
- return 0;
-}
-
-static int space2[][2] = {
- { 0x0009, 0x000D },
- { 0x001C, 0x0020 },
- { 0x2000, 0x200A },
- { 0x2028, 0x2029 },
-};
-
-static int space1[] = {
- 0x0085,
- 0x00A0,
- 0x1680,
- 0x202F,
- 0x205F,
- 0x3000,
-};
+ const int *d = bsearch(&r, digit, nelem(digit), sizeof *digit, &rune2cmp);
-C_regparm int C_utf_isspace(int r)
-{
- if(bsearch(&r, space2, nelem(space2), sizeof *space2, &rune2cmp))
- return 1;
- if(bsearch(&r, space1, nelem(space1), sizeof *space1, &rune1cmp))
- return 1;
- return 0;
+ return d == NULL ? 0 : 1 + (r - d[0]);
}
-static int fold1[][ 2 ] = {
- {0x0041, 0x0061},
- {0x0042, 0x0062},
- {0x0043, 0x0063},
- {0x0044, 0x0064},
- {0x0045, 0x0065},
- {0x0046, 0x0066},
- {0x0047, 0x0067},
- {0x0048, 0x0068},
- {0x0049, 0x0069},
- {0x004A, 0x006A},
- {0x004B, 0x006B},
- {0x004C, 0x006C},
- {0x004D, 0x006D},
- {0x004E, 0x006E},
- {0x004F, 0x006F},
- {0x0050, 0x0070},
- {0x0051, 0x0071},
- {0x0052, 0x0072},
- {0x0053, 0x0073},
- {0x0054, 0x0074},
- {0x0055, 0x0075},
- {0x0056, 0x0076},
- {0x0057, 0x0077},
- {0x0058, 0x0078},
- {0x0059, 0x0079},
- {0x005A, 0x007A},
- {0x00B5, 0x03BC},
- {0x00C0, 0x00E0},
- {0x00C1, 0x00E1},
- {0x00C2, 0x00E2},
- {0x00C3, 0x00E3},
- {0x00C4, 0x00E4},
- {0x00C5, 0x00E5},
- {0x00C6, 0x00E6},
- {0x00C7, 0x00E7},
- {0x00C8, 0x00E8},
- {0x00C9, 0x00E9},
- {0x00CA, 0x00EA},
- {0x00CB, 0x00EB},
- {0x00CC, 0x00EC},
- {0x00CD, 0x00ED},
- {0x00CE, 0x00EE},
- {0x00CF, 0x00EF},
- {0x00D0, 0x00F0},
- {0x00D1, 0x00F1},
- {0x00D2, 0x00F2},
- {0x00D3, 0x00F3},
- {0x00D4, 0x00F4},
- {0x00D5, 0x00F5},
- {0x00D6, 0x00F6},
- {0x00D8, 0x00F8},
- {0x00D9, 0x00F9},
- {0x00DA, 0x00FA},
- {0x00DB, 0x00FB},
- {0x00DC, 0x00FC},
- {0x00DD, 0x00FD},
- {0x00DE, 0x00FE},
- {0x0100, 0x0101},
- {0x0102, 0x0103},
- {0x0104, 0x0105},
- {0x0106, 0x0107},
- {0x0108, 0x0109},
- {0x010A, 0x010B},
- {0x010C, 0x010D},
- {0x010E, 0x010F},
- {0x0110, 0x0111},
- {0x0112, 0x0113},
- {0x0114, 0x0115},
- {0x0116, 0x0117},
- {0x0118, 0x0119},
- {0x011A, 0x011B},
- {0x011C, 0x011D},
- {0x011E, 0x011F},
- {0x0120, 0x0121},
- {0x0122, 0x0123},
- {0x0124, 0x0125},
- {0x0126, 0x0127},
- {0x0128, 0x0129},
- {0x012A, 0x012B},
- {0x012C, 0x012D},
- {0x012E, 0x012F},
- {0x0132, 0x0133},
- {0x0134, 0x0135},
- {0x0136, 0x0137},
- {0x0139, 0x013A},
- {0x013B, 0x013C},
- {0x013D, 0x013E},
- {0x013F, 0x0140},
- {0x0141, 0x0142},
- {0x0143, 0x0144},
- {0x0145, 0x0146},
- {0x0147, 0x0148},
- {0x014A, 0x014B},
- {0x014C, 0x014D},
- {0x014E, 0x014F},
- {0x0150, 0x0151},
- {0x0152, 0x0153},
- {0x0154, 0x0155},
- {0x0156, 0x0157},
- {0x0158, 0x0159},
- {0x015A, 0x015B},
- {0x015C, 0x015D},
- {0x015E, 0x015F},
- {0x0160, 0x0161},
- {0x0162, 0x0163},
- {0x0164, 0x0165},
- {0x0166, 0x0167},
- {0x0168, 0x0169},
- {0x016A, 0x016B},
- {0x016C, 0x016D},
- {0x016E, 0x016F},
- {0x0170, 0x0171},
- {0x0172, 0x0173},
- {0x0174, 0x0175},
- {0x0176, 0x0177},
- {0x0178, 0x00FF},
- {0x0179, 0x017A},
- {0x017B, 0x017C},
- {0x017D, 0x017E},
- {0x017F, 0x0073},
- {0x0181, 0x0253},
- {0x0182, 0x0183},
- {0x0184, 0x0185},
- {0x0186, 0x0254},
- {0x0187, 0x0188},
- {0x0189, 0x0256},
- {0x018A, 0x0257},
- {0x018B, 0x018C},
- {0x018E, 0x01DD},
- {0x018F, 0x0259},
- {0x0190, 0x025B},
- {0x0191, 0x0192},
- {0x0193, 0x0260},
- {0x0194, 0x0263},
- {0x0196, 0x0269},
- {0x0197, 0x0268},
- {0x0198, 0x0199},
- {0x019C, 0x026F},
- {0x019D, 0x0272},
- {0x019F, 0x0275},
- {0x01A0, 0x01A1},
- {0x01A2, 0x01A3},
- {0x01A4, 0x01A5},
- {0x01A6, 0x0280},
- {0x01A7, 0x01A8},
- {0x01A9, 0x0283},
- {0x01AC, 0x01AD},
- {0x01AE, 0x0288},
- {0x01AF, 0x01B0},
- {0x01B1, 0x028A},
- {0x01B2, 0x028B},
- {0x01B3, 0x01B4},
- {0x01B5, 0x01B6},
- {0x01B7, 0x0292},
- {0x01B8, 0x01B9},
- {0x01BC, 0x01BD},
- {0x01C4, 0x01C6},
- {0x01C5, 0x01C6},
- {0x01C7, 0x01C9},
- {0x01C8, 0x01C9},
- {0x01CA, 0x01CC},
- {0x01CB, 0x01CC},
- {0x01CD, 0x01CE},
- {0x01CF, 0x01D0},
- {0x01D1, 0x01D2},
- {0x01D3, 0x01D4},
- {0x01D5, 0x01D6},
- {0x01D7, 0x01D8},
- {0x01D9, 0x01DA},
- {0x01DB, 0x01DC},
- {0x01DE, 0x01DF},
- {0x01E0, 0x01E1},
- {0x01E2, 0x01E3},
- {0x01E4, 0x01E5},
- {0x01E6, 0x01E7},
- {0x01E8, 0x01E9},
- {0x01EA, 0x01EB},
- {0x01EC, 0x01ED},
- {0x01EE, 0x01EF},
- {0x01F1, 0x01F3},
- {0x01F2, 0x01F3},
- {0x01F4, 0x01F5},
- {0x01F6, 0x0195},
- {0x01F7, 0x01BF},
- {0x01F8, 0x01F9},
- {0x01FA, 0x01FB},
- {0x01FC, 0x01FD},
- {0x01FE, 0x01FF},
- {0x0200, 0x0201},
- {0x0202, 0x0203},
- {0x0204, 0x0205},
- {0x0206, 0x0207},
- {0x0208, 0x0209},
- {0x020A, 0x020B},
- {0x020C, 0x020D},
- {0x020E, 0x020F},
- {0x0210, 0x0211},
- {0x0212, 0x0213},
- {0x0214, 0x0215},
- {0x0216, 0x0217},
- {0x0218, 0x0219},
- {0x021A, 0x021B},
- {0x021C, 0x021D},
- {0x021E, 0x021F},
- {0x0220, 0x019E},
- {0x0222, 0x0223},
- {0x0224, 0x0225},
- {0x0226, 0x0227},
- {0x0228, 0x0229},
- {0x022A, 0x022B},
- {0x022C, 0x022D},
- {0x022E, 0x022F},
- {0x0230, 0x0231},
- {0x0232, 0x0233},
- {0x023A, 0x2C65},
- {0x023B, 0x023C},
- {0x023D, 0x019A},
- {0x023E, 0x2C66},
- {0x0241, 0x0242},
- {0x0243, 0x0180},
- {0x0244, 0x0289},
- {0x0245, 0x028C},
- {0x0246, 0x0247},
- {0x0248, 0x0249},
- {0x024A, 0x024B},
- {0x024C, 0x024D},
- {0x024E, 0x024F},
- {0x0345, 0x03B9},
- {0x0370, 0x0371},
- {0x0372, 0x0373},
- {0x0376, 0x0377},
- {0x037F, 0x03F3},
- {0x0386, 0x03AC},
- {0x0388, 0x03AD},
- {0x0389, 0x03AE},
- {0x038A, 0x03AF},
- {0x038C, 0x03CC},
- {0x038E, 0x03CD},
- {0x038F, 0x03CE},
- {0x0391, 0x03B1},
- {0x0392, 0x03B2},
- {0x0393, 0x03B3},
- {0x0394, 0x03B4},
- {0x0395, 0x03B5},
- {0x0396, 0x03B6},
- {0x0397, 0x03B7},
- {0x0398, 0x03B8},
- {0x0399, 0x03B9},
- {0x039A, 0x03BA},
- {0x039B, 0x03BB},
- {0x039C, 0x03BC},
- {0x039D, 0x03BD},
- {0x039E, 0x03BE},
- {0x039F, 0x03BF},
- {0x03A0, 0x03C0},
- {0x03A1, 0x03C1},
- {0x03A3, 0x03C3},
- {0x03A4, 0x03C4},
- {0x03A5, 0x03C5},
- {0x03A6, 0x03C6},
- {0x03A7, 0x03C7},
- {0x03A8, 0x03C8},
- {0x03A9, 0x03C9},
- {0x03AA, 0x03CA},
- {0x03AB, 0x03CB},
- {0x03C2, 0x03C3},
- {0x03CF, 0x03D7},
- {0x03D0, 0x03B2},
- {0x03D1, 0x03B8},
- {0x03D5, 0x03C6},
- {0x03D6, 0x03C0},
- {0x03D8, 0x03D9},
- {0x03DA, 0x03DB},
- {0x03DC, 0x03DD},
- {0x03DE, 0x03DF},
- {0x03E0, 0x03E1},
- {0x03E2, 0x03E3},
- {0x03E4, 0x03E5},
- {0x03E6, 0x03E7},
- {0x03E8, 0x03E9},
- {0x03EA, 0x03EB},
- {0x03EC, 0x03ED},
- {0x03EE, 0x03EF},
- {0x03F0, 0x03BA},
- {0x03F1, 0x03C1},
- {0x03F4, 0x03B8},
- {0x03F5, 0x03B5},
- {0x03F7, 0x03F8},
- {0x03F9, 0x03F2},
- {0x03FA, 0x03FB},
- {0x03FD, 0x037B},
- {0x03FE, 0x037C},
- {0x03FF, 0x037D},
- {0x0400, 0x0450},
- {0x0401, 0x0451},
- {0x0402, 0x0452},
- {0x0403, 0x0453},
- {0x0404, 0x0454},
- {0x0405, 0x0455},
- {0x0406, 0x0456},
- {0x0407, 0x0457},
- {0x0408, 0x0458},
- {0x0409, 0x0459},
- {0x040A, 0x045A},
- {0x040B, 0x045B},
- {0x040C, 0x045C},
- {0x040D, 0x045D},
- {0x040E, 0x045E},
- {0x040F, 0x045F},
- {0x0410, 0x0430},
- {0x0411, 0x0431},
- {0x0412, 0x0432},
- {0x0413, 0x0433},
- {0x0414, 0x0434},
- {0x0415, 0x0435},
- {0x0416, 0x0436},
- {0x0417, 0x0437},
- {0x0418, 0x0438},
- {0x0419, 0x0439},
- {0x041A, 0x043A},
- {0x041B, 0x043B},
- {0x041C, 0x043C},
- {0x041D, 0x043D},
- {0x041E, 0x043E},
- {0x041F, 0x043F},
- {0x0420, 0x0440},
- {0x0421, 0x0441},
- {0x0422, 0x0442},
- {0x0423, 0x0443},
- {0x0424, 0x0444},
- {0x0425, 0x0445},
- {0x0426, 0x0446},
- {0x0427, 0x0447},
- {0x0428, 0x0448},
- {0x0429, 0x0449},
- {0x042A, 0x044A},
- {0x042B, 0x044B},
- {0x042C, 0x044C},
- {0x042D, 0x044D},
- {0x042E, 0x044E},
- {0x042F, 0x044F},
- {0x0460, 0x0461},
- {0x0462, 0x0463},
- {0x0464, 0x0465},
- {0x0466, 0x0467},
- {0x0468, 0x0469},
- {0x046A, 0x046B},
- {0x046C, 0x046D},
- {0x046E, 0x046F},
- {0x0470, 0x0471},
- {0x0472, 0x0473},
- {0x0474, 0x0475},
- {0x0476, 0x0477},
- {0x0478, 0x0479},
- {0x047A, 0x047B},
- {0x047C, 0x047D},
- {0x047E, 0x047F},
- {0x0480, 0x0481},
- {0x048A, 0x048B},
- {0x048C, 0x048D},
- {0x048E, 0x048F},
- {0x0490, 0x0491},
- {0x0492, 0x0493},
- {0x0494, 0x0495},
- {0x0496, 0x0497},
- {0x0498, 0x0499},
- {0x049A, 0x049B},
- {0x049C, 0x049D},
- {0x049E, 0x049F},
- {0x04A0, 0x04A1},
- {0x04A2, 0x04A3},
- {0x04A4, 0x04A5},
- {0x04A6, 0x04A7},
- {0x04A8, 0x04A9},
- {0x04AA, 0x04AB},
- {0x04AC, 0x04AD},
- {0x04AE, 0x04AF},
- {0x04B0, 0x04B1},
- {0x04B2, 0x04B3},
- {0x04B4, 0x04B5},
- {0x04B6, 0x04B7},
- {0x04B8, 0x04B9},
- {0x04BA, 0x04BB},
- {0x04BC, 0x04BD},
- {0x04BE, 0x04BF},
- {0x04C0, 0x04CF},
- {0x04C1, 0x04C2},
- {0x04C3, 0x04C4},
- {0x04C5, 0x04C6},
- {0x04C7, 0x04C8},
- {0x04C9, 0x04CA},
- {0x04CB, 0x04CC},
- {0x04CD, 0x04CE},
- {0x04D0, 0x04D1},
- {0x04D2, 0x04D3},
- {0x04D4, 0x04D5},
- {0x04D6, 0x04D7},
- {0x04D8, 0x04D9},
- {0x04DA, 0x04DB},
- {0x04DC, 0x04DD},
- {0x04DE, 0x04DF},
- {0x04E0, 0x04E1},
- {0x04E2, 0x04E3},
- {0x04E4, 0x04E5},
- {0x04E6, 0x04E7},
- {0x04E8, 0x04E9},
- {0x04EA, 0x04EB},
- {0x04EC, 0x04ED},
- {0x04EE, 0x04EF},
- {0x04F0, 0x04F1},
- {0x04F2, 0x04F3},
- {0x04F4, 0x04F5},
- {0x04F6, 0x04F7},
- {0x04F8, 0x04F9},
- {0x04FA, 0x04FB},
- {0x04FC, 0x04FD},
- {0x04FE, 0x04FF},
- {0x0500, 0x0501},
- {0x0502, 0x0503},
- {0x0504, 0x0505},
- {0x0506, 0x0507},
- {0x0508, 0x0509},
- {0x050A, 0x050B},
- {0x050C, 0x050D},
- {0x050E, 0x050F},
- {0x0510, 0x0511},
- {0x0512, 0x0513},
- {0x0514, 0x0515},
- {0x0516, 0x0517},
- {0x0518, 0x0519},
- {0x051A, 0x051B},
- {0x051C, 0x051D},
- {0x051E, 0x051F},
- {0x0520, 0x0521},
- {0x0522, 0x0523},
- {0x0524, 0x0525},
- {0x0526, 0x0527},
- {0x0528, 0x0529},
- {0x052A, 0x052B},
- {0x052C, 0x052D},
- {0x052E, 0x052F},
- {0x0531, 0x0561},
- {0x0532, 0x0562},
- {0x0533, 0x0563},
- {0x0534, 0x0564},
- {0x0535, 0x0565},
- {0x0536, 0x0566},
- {0x0537, 0x0567},
- {0x0538, 0x0568},
- {0x0539, 0x0569},
- {0x053A, 0x056A},
- {0x053B, 0x056B},
- {0x053C, 0x056C},
- {0x053D, 0x056D},
- {0x053E, 0x056E},
- {0x053F, 0x056F},
- {0x0540, 0x0570},
- {0x0541, 0x0571},
- {0x0542, 0x0572},
- {0x0543, 0x0573},
- {0x0544, 0x0574},
- {0x0545, 0x0575},
- {0x0546, 0x0576},
- {0x0547, 0x0577},
- {0x0548, 0x0578},
- {0x0549, 0x0579},
- {0x054A, 0x057A},
- {0x054B, 0x057B},
- {0x054C, 0x057C},
- {0x054D, 0x057D},
- {0x054E, 0x057E},
- {0x054F, 0x057F},
- {0x0550, 0x0580},
- {0x0551, 0x0581},
- {0x0552, 0x0582},
- {0x0553, 0x0583},
- {0x0554, 0x0584},
- {0x0555, 0x0585},
- {0x0556, 0x0586},
- {0x10A0, 0x2D00},
- {0x10A1, 0x2D01},
- {0x10A2, 0x2D02},
- {0x10A3, 0x2D03},
- {0x10A4, 0x2D04},
- {0x10A5, 0x2D05},
- {0x10A6, 0x2D06},
- {0x10A7, 0x2D07},
- {0x10A8, 0x2D08},
- {0x10A9, 0x2D09},
- {0x10AA, 0x2D0A},
- {0x10AB, 0x2D0B},
- {0x10AC, 0x2D0C},
- {0x10AD, 0x2D0D},
- {0x10AE, 0x2D0E},
- {0x10AF, 0x2D0F},
- {0x10B0, 0x2D10},
- {0x10B1, 0x2D11},
- {0x10B2, 0x2D12},
- {0x10B3, 0x2D13},
- {0x10B4, 0x2D14},
- {0x10B5, 0x2D15},
- {0x10B6, 0x2D16},
- {0x10B7, 0x2D17},
- {0x10B8, 0x2D18},
- {0x10B9, 0x2D19},
- {0x10BA, 0x2D1A},
- {0x10BB, 0x2D1B},
- {0x10BC, 0x2D1C},
- {0x10BD, 0x2D1D},
- {0x10BE, 0x2D1E},
- {0x10BF, 0x2D1F},
- {0x10C0, 0x2D20},
- {0x10C1, 0x2D21},
- {0x10C2, 0x2D22},
- {0x10C3, 0x2D23},
- {0x10C4, 0x2D24},
- {0x10C5, 0x2D25},
- {0x10C7, 0x2D27},
- {0x10CD, 0x2D2D},
- {0x13F8, 0x13F0},
- {0x13F9, 0x13F1},
- {0x13FA, 0x13F2},
- {0x13FB, 0x13F3},
- {0x13FC, 0x13F4},
- {0x13FD, 0x13F5},
- {0x1C80, 0x0432},
- {0x1C81, 0x0434},
- {0x1C82, 0x043E},
- {0x1C83, 0x0441},
- {0x1C84, 0x0442},
- {0x1C85, 0x0442},
- {0x1C86, 0x044A},
- {0x1C87, 0x0463},
- {0x1C88, 0xA64B},
- {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},
- {0x1CBD, 0x10FD},
- {0x1CBE, 0x10FE},
- {0x1CBF, 0x10FF},
- {0x1E00, 0x1E01},
- {0x1E02, 0x1E03},
- {0x1E04, 0x1E05},
- {0x1E06, 0x1E07},
- {0x1E08, 0x1E09},
- {0x1E0A, 0x1E0B},
- {0x1E0C, 0x1E0D},
- {0x1E0E, 0x1E0F},
- {0x1E10, 0x1E11},
- {0x1E12, 0x1E13},
- {0x1E14, 0x1E15},
- {0x1E16, 0x1E17},
- {0x1E18, 0x1E19},
- {0x1E1A, 0x1E1B},
- {0x1E1C, 0x1E1D},
- {0x1E1E, 0x1E1F},
- {0x1E20, 0x1E21},
- {0x1E22, 0x1E23},
- {0x1E24, 0x1E25},
- {0x1E26, 0x1E27},
- {0x1E28, 0x1E29},
- {0x1E2A, 0x1E2B},
- {0x1E2C, 0x1E2D},
- {0x1E2E, 0x1E2F},
- {0x1E30, 0x1E31},
- {0x1E32, 0x1E33},
- {0x1E34, 0x1E35},
- {0x1E36, 0x1E37},
- {0x1E38, 0x1E39},
- {0x1E3A, 0x1E3B},
- {0x1E3C, 0x1E3D},
- {0x1E3E, 0x1E3F},
- {0x1E40, 0x1E41},
- {0x1E42, 0x1E43},
- {0x1E44, 0x1E45},
- {0x1E46, 0x1E47},
- {0x1E48, 0x1E49},
- {0x1E4A, 0x1E4B},
- {0x1E4C, 0x1E4D},
- {0x1E4E, 0x1E4F},
- {0x1E50, 0x1E51},
- {0x1E52, 0x1E53},
- {0x1E54, 0x1E55},
- {0x1E56, 0x1E57},
- {0x1E58, 0x1E59},
- {0x1E5A, 0x1E5B},
- {0x1E5C, 0x1E5D},
- {0x1E5E, 0x1E5F},
- {0x1E60, 0x1E61},
- {0x1E62, 0x1E63},
- {0x1E64, 0x1E65},
- {0x1E66, 0x1E67},
- {0x1E68, 0x1E69},
- {0x1E6A, 0x1E6B},
- {0x1E6C, 0x1E6D},
- {0x1E6E, 0x1E6F},
- {0x1E70, 0x1E71},
- {0x1E72, 0x1E73},
- {0x1E74, 0x1E75},
- {0x1E76, 0x1E77},
- {0x1E78, 0x1E79},
- {0x1E7A, 0x1E7B},
- {0x1E7C, 0x1E7D},
- {0x1E7E, 0x1E7F},
- {0x1E80, 0x1E81},
- {0x1E82, 0x1E83},
- {0x1E84, 0x1E85},
- {0x1E86, 0x1E87},
- {0x1E88, 0x1E89},
- {0x1E8A, 0x1E8B},
- {0x1E8C, 0x1E8D},
- {0x1E8E, 0x1E8F},
- {0x1E90, 0x1E91},
- {0x1E92, 0x1E93},
- {0x1E94, 0x1E95},
- {0x1E9B, 0x1E61},
- {0x1E9E, 0x00DF},
- {0x1EA0, 0x1EA1},
- {0x1EA2, 0x1EA3},
- {0x1EA4, 0x1EA5},
- {0x1EA6, 0x1EA7},
- {0x1EA8, 0x1EA9},
- {0x1EAA, 0x1EAB},
- {0x1EAC, 0x1EAD},
- {0x1EAE, 0x1EAF},
- {0x1EB0, 0x1EB1},
- {0x1EB2, 0x1EB3},
- {0x1EB4, 0x1EB5},
- {0x1EB6, 0x1EB7},
- {0x1EB8, 0x1EB9},
- {0x1EBA, 0x1EBB},
- {0x1EBC, 0x1EBD},
- {0x1EBE, 0x1EBF},
- {0x1EC0, 0x1EC1},
- {0x1EC2, 0x1EC3},
- {0x1EC4, 0x1EC5},
- {0x1EC6, 0x1EC7},
- {0x1EC8, 0x1EC9},
- {0x1ECA, 0x1ECB},
- {0x1ECC, 0x1ECD},
- {0x1ECE, 0x1ECF},
- {0x1ED0, 0x1ED1},
- {0x1ED2, 0x1ED3},
- {0x1ED4, 0x1ED5},
- {0x1ED6, 0x1ED7},
- {0x1ED8, 0x1ED9},
- {0x1EDA, 0x1EDB},
- {0x1EDC, 0x1EDD},
- {0x1EDE, 0x1EDF},
- {0x1EE0, 0x1EE1},
- {0x1EE2, 0x1EE3},
- {0x1EE4, 0x1EE5},
- {0x1EE6, 0x1EE7},
- {0x1EE8, 0x1EE9},
- {0x1EEA, 0x1EEB},
- {0x1EEC, 0x1EED},
- {0x1EEE, 0x1EEF},
- {0x1EF0, 0x1EF1},
- {0x1EF2, 0x1EF3},
- {0x1EF4, 0x1EF5},
- {0x1EF6, 0x1EF7},
- {0x1EF8, 0x1EF9},
- {0x1EFA, 0x1EFB},
- {0x1EFC, 0x1EFD},
- {0x1EFE, 0x1EFF},
- {0x1F08, 0x1F00},
- {0x1F09, 0x1F01},
- {0x1F0A, 0x1F02},
- {0x1F0B, 0x1F03},
- {0x1F0C, 0x1F04},
- {0x1F0D, 0x1F05},
- {0x1F0E, 0x1F06},
- {0x1F0F, 0x1F07},
- {0x1F18, 0x1F10},
- {0x1F19, 0x1F11},
- {0x1F1A, 0x1F12},
- {0x1F1B, 0x1F13},
- {0x1F1C, 0x1F14},
- {0x1F1D, 0x1F15},
- {0x1F28, 0x1F20},
- {0x1F29, 0x1F21},
- {0x1F2A, 0x1F22},
- {0x1F2B, 0x1F23},
- {0x1F2C, 0x1F24},
- {0x1F2D, 0x1F25},
- {0x1F2E, 0x1F26},
- {0x1F2F, 0x1F27},
- {0x1F38, 0x1F30},
- {0x1F39, 0x1F31},
- {0x1F3A, 0x1F32},
- {0x1F3B, 0x1F33},
- {0x1F3C, 0x1F34},
- {0x1F3D, 0x1F35},
- {0x1F3E, 0x1F36},
- {0x1F3F, 0x1F37},
- {0x1F48, 0x1F40},
- {0x1F49, 0x1F41},
- {0x1F4A, 0x1F42},
- {0x1F4B, 0x1F43},
- {0x1F4C, 0x1F44},
- {0x1F4D, 0x1F45},
- {0x1F59, 0x1F51},
- {0x1F5B, 0x1F53},
- {0x1F5D, 0x1F55},
- {0x1F5F, 0x1F57},
- {0x1F68, 0x1F60},
- {0x1F69, 0x1F61},
- {0x1F6A, 0x1F62},
- {0x1F6B, 0x1F63},
- {0x1F6C, 0x1F64},
- {0x1F6D, 0x1F65},
- {0x1F6E, 0x1F66},
- {0x1F6F, 0x1F67},
- {0x1F88, 0x1F80},
- {0x1F89, 0x1F81},
- {0x1F8A, 0x1F82},
- {0x1F8B, 0x1F83},
- {0x1F8C, 0x1F84},
- {0x1F8D, 0x1F85},
- {0x1F8E, 0x1F86},
- {0x1F8F, 0x1F87},
- {0x1F98, 0x1F90},
- {0x1F99, 0x1F91},
- {0x1F9A, 0x1F92},
- {0x1F9B, 0x1F93},
- {0x1F9C, 0x1F94},
- {0x1F9D, 0x1F95},
- {0x1F9E, 0x1F96},
- {0x1F9F, 0x1F97},
- {0x1FA8, 0x1FA0},
- {0x1FA9, 0x1FA1},
- {0x1FAA, 0x1FA2},
- {0x1FAB, 0x1FA3},
- {0x1FAC, 0x1FA4},
- {0x1FAD, 0x1FA5},
- {0x1FAE, 0x1FA6},
- {0x1FAF, 0x1FA7},
- {0x1FB8, 0x1FB0},
- {0x1FB9, 0x1FB1},
- {0x1FBA, 0x1F70},
- {0x1FBB, 0x1F71},
- {0x1FBC, 0x1FB3},
- {0x1FBE, 0x03B9},
- {0x1FC8, 0x1F72},
- {0x1FC9, 0x1F73},
- {0x1FCA, 0x1F74},
- {0x1FCB, 0x1F75},
- {0x1FCC, 0x1FC3},
- {0x1FD8, 0x1FD0},
- {0x1FD9, 0x1FD1},
- {0x1FDA, 0x1F76},
- {0x1FDB, 0x1F77},
- {0x1FE8, 0x1FE0},
- {0x1FE9, 0x1FE1},
- {0x1FEA, 0x1F7A},
- {0x1FEB, 0x1F7B},
- {0x1FEC, 0x1FE5},
- {0x1FF8, 0x1F78},
- {0x1FF9, 0x1F79},
- {0x1FFA, 0x1F7C},
- {0x1FFB, 0x1F7D},
- {0x1FFC, 0x1FF3},
- {0x2126, 0x03C9},
- {0x212A, 0x006B},
- {0x212B, 0x00E5},
- {0x2132, 0x214E},
- {0x2160, 0x2170},
- {0x2161, 0x2171},
- {0x2162, 0x2172},
- {0x2163, 0x2173},
- {0x2164, 0x2174},
- {0x2165, 0x2175},
- {0x2166, 0x2176},
- {0x2167, 0x2177},
- {0x2168, 0x2178},
- {0x2169, 0x2179},
- {0x216A, 0x217A},
- {0x216B, 0x217B},
- {0x216C, 0x217C},
- {0x216D, 0x217D},
- {0x216E, 0x217E},
- {0x216F, 0x217F},
- {0x2183, 0x2184},
- {0x24B6, 0x24D0},
- {0x24B7, 0x24D1},
- {0x24B8, 0x24D2},
- {0x24B9, 0x24D3},
- {0x24BA, 0x24D4},
- {0x24BB, 0x24D5},
- {0x24BC, 0x24D6},
- {0x24BD, 0x24D7},
- {0x24BE, 0x24D8},
- {0x24BF, 0x24D9},
- {0x24C0, 0x24DA},
- {0x24C1, 0x24DB},
- {0x24C2, 0x24DC},
- {0x24C3, 0x24DD},
- {0x24C4, 0x24DE},
- {0x24C5, 0x24DF},
- {0x24C6, 0x24E0},
- {0x24C7, 0x24E1},
- {0x24C8, 0x24E2},
- {0x24C9, 0x24E3},
- {0x24CA, 0x24E4},
- {0x24CB, 0x24E5},
- {0x24CC, 0x24E6},
- {0x24CD, 0x24E7},
- {0x24CE, 0x24E8},
- {0x24CF, 0x24E9},
- {0x2C00, 0x2C30},
- {0x2C01, 0x2C31},
- {0x2C02, 0x2C32},
- {0x2C03, 0x2C33},
- {0x2C04, 0x2C34},
- {0x2C05, 0x2C35},
- {0x2C06, 0x2C36},
- {0x2C07, 0x2C37},
- {0x2C08, 0x2C38},
- {0x2C09, 0x2C39},
- {0x2C0A, 0x2C3A},
- {0x2C0B, 0x2C3B},
- {0x2C0C, 0x2C3C},
- {0x2C0D, 0x2C3D},
- {0x2C0E, 0x2C3E},
- {0x2C0F, 0x2C3F},
- {0x2C10, 0x2C40},
- {0x2C11, 0x2C41},
- {0x2C12, 0x2C42},
- {0x2C13, 0x2C43},
- {0x2C14, 0x2C44},
- {0x2C15, 0x2C45},
- {0x2C16, 0x2C46},
- {0x2C17, 0x2C47},
- {0x2C18, 0x2C48},
- {0x2C19, 0x2C49},
- {0x2C1A, 0x2C4A},
- {0x2C1B, 0x2C4B},
- {0x2C1C, 0x2C4C},
- {0x2C1D, 0x2C4D},
- {0x2C1E, 0x2C4E},
- {0x2C1F, 0x2C4F},
- {0x2C20, 0x2C50},
- {0x2C21, 0x2C51},
- {0x2C22, 0x2C52},
- {0x2C23, 0x2C53},
- {0x2C24, 0x2C54},
- {0x2C25, 0x2C55},
- {0x2C26, 0x2C56},
- {0x2C27, 0x2C57},
- {0x2C28, 0x2C58},
- {0x2C29, 0x2C59},
- {0x2C2A, 0x2C5A},
- {0x2C2B, 0x2C5B},
- {0x2C2C, 0x2C5C},
- {0x2C2D, 0x2C5D},
- {0x2C2E, 0x2C5E},
- {0x2C2F, 0x2C5F},
- {0x2C60, 0x2C61},
- {0x2C62, 0x026B},
- {0x2C63, 0x1D7D},
- {0x2C64, 0x027D},
- {0x2C67, 0x2C68},
- {0x2C69, 0x2C6A},
- {0x2C6B, 0x2C6C},
- {0x2C6D, 0x0251},
- {0x2C6E, 0x0271},
- {0x2C6F, 0x0250},
- {0x2C70, 0x0252},
- {0x2C72, 0x2C73},
- {0x2C75, 0x2C76},
- {0x2C7E, 0x023F},
- {0x2C7F, 0x0240},
- {0x2C80, 0x2C81},
- {0x2C82, 0x2C83},
- {0x2C84, 0x2C85},
- {0x2C86, 0x2C87},
- {0x2C88, 0x2C89},
- {0x2C8A, 0x2C8B},
- {0x2C8C, 0x2C8D},
- {0x2C8E, 0x2C8F},
- {0x2C90, 0x2C91},
- {0x2C92, 0x2C93},
- {0x2C94, 0x2C95},
- {0x2C96, 0x2C97},
- {0x2C98, 0x2C99},
- {0x2C9A, 0x2C9B},
- {0x2C9C, 0x2C9D},
- {0x2C9E, 0x2C9F},
- {0x2CA0, 0x2CA1},
- {0x2CA2, 0x2CA3},
- {0x2CA4, 0x2CA5},
- {0x2CA6, 0x2CA7},
- {0x2CA8, 0x2CA9},
- {0x2CAA, 0x2CAB},
- {0x2CAC, 0x2CAD},
- {0x2CAE, 0x2CAF},
- {0x2CB0, 0x2CB1},
- {0x2CB2, 0x2CB3},
- {0x2CB4, 0x2CB5},
- {0x2CB6, 0x2CB7},
- {0x2CB8, 0x2CB9},
- {0x2CBA, 0x2CBB},
- {0x2CBC, 0x2CBD},
- {0x2CBE, 0x2CBF},
- {0x2CC0, 0x2CC1},
- {0x2CC2, 0x2CC3},
- {0x2CC4, 0x2CC5},
- {0x2CC6, 0x2CC7},
- {0x2CC8, 0x2CC9},
- {0x2CCA, 0x2CCB},
- {0x2CCC, 0x2CCD},
- {0x2CCE, 0x2CCF},
- {0x2CD0, 0x2CD1},
- {0x2CD2, 0x2CD3},
- {0x2CD4, 0x2CD5},
- {0x2CD6, 0x2CD7},
- {0x2CD8, 0x2CD9},
- {0x2CDA, 0x2CDB},
- {0x2CDC, 0x2CDD},
- {0x2CDE, 0x2CDF},
- {0x2CE0, 0x2CE1},
- {0x2CE2, 0x2CE3},
- {0x2CEB, 0x2CEC},
- {0x2CED, 0x2CEE},
- {0x2CF2, 0x2CF3},
- {0xA640, 0xA641},
- {0xA642, 0xA643},
- {0xA644, 0xA645},
- {0xA646, 0xA647},
- {0xA648, 0xA649},
- {0xA64A, 0xA64B},
- {0xA64C, 0xA64D},
- {0xA64E, 0xA64F},
- {0xA650, 0xA651},
- {0xA652, 0xA653},
- {0xA654, 0xA655},
- {0xA656, 0xA657},
- {0xA658, 0xA659},
- {0xA65A, 0xA65B},
- {0xA65C, 0xA65D},
- {0xA65E, 0xA65F},
- {0xA660, 0xA661},
- {0xA662, 0xA663},
- {0xA664, 0xA665},
- {0xA666, 0xA667},
- {0xA668, 0xA669},
- {0xA66A, 0xA66B},
- {0xA66C, 0xA66D},
- {0xA680, 0xA681},
- {0xA682, 0xA683},
- {0xA684, 0xA685},
- {0xA686, 0xA687},
- {0xA688, 0xA689},
- {0xA68A, 0xA68B},
- {0xA68C, 0xA68D},
- {0xA68E, 0xA68F},
- {0xA690, 0xA691},
- {0xA692, 0xA693},
- {0xA694, 0xA695},
- {0xA696, 0xA697},
- {0xA698, 0xA699},
- {0xA69A, 0xA69B},
- {0xA722, 0xA723},
- {0xA724, 0xA725},
- {0xA726, 0xA727},
- {0xA728, 0xA729},
- {0xA72A, 0xA72B},
- {0xA72C, 0xA72D},
- {0xA72E, 0xA72F},
- {0xA732, 0xA733},
- {0xA734, 0xA735},
- {0xA736, 0xA737},
- {0xA738, 0xA739},
- {0xA73A, 0xA73B},
- {0xA73C, 0xA73D},
- {0xA73E, 0xA73F},
- {0xA740, 0xA741},
- {0xA742, 0xA743},
- {0xA744, 0xA745},
- {0xA746, 0xA747},
- {0xA748, 0xA749},
- {0xA74A, 0xA74B},
- {0xA74C, 0xA74D},
- {0xA74E, 0xA74F},
- {0xA750, 0xA751},
- {0xA752, 0xA753},
- {0xA754, 0xA755},
- {0xA756, 0xA757},
- {0xA758, 0xA759},
- {0xA75A, 0xA75B},
- {0xA75C, 0xA75D},
- {0xA75E, 0xA75F},
- {0xA760, 0xA761},
- {0xA762, 0xA763},
- {0xA764, 0xA765},
- {0xA766, 0xA767},
- {0xA768, 0xA769},
- {0xA76A, 0xA76B},
- {0xA76C, 0xA76D},
- {0xA76E, 0xA76F},
- {0xA779, 0xA77A},
- {0xA77B, 0xA77C},
- {0xA77D, 0x1D79},
- {0xA77E, 0xA77F},
- {0xA780, 0xA781},
- {0xA782, 0xA783},
- {0xA784, 0xA785},
- {0xA786, 0xA787},
- {0xA78B, 0xA78C},
- {0xA78D, 0x0265},
- {0xA790, 0xA791},
- {0xA792, 0xA793},
- {0xA796, 0xA797},
- {0xA798, 0xA799},
- {0xA79A, 0xA79B},
- {0xA79C, 0xA79D},
- {0xA79E, 0xA79F},
- {0xA7A0, 0xA7A1},
- {0xA7A2, 0xA7A3},
- {0xA7A4, 0xA7A5},
- {0xA7A6, 0xA7A7},
- {0xA7A8, 0xA7A9},
- {0xA7AA, 0x0266},
- {0xA7AB, 0x025C},
- {0xA7AC, 0x0261},
- {0xA7AD, 0x026C},
- {0xA7AE, 0x026A},
- {0xA7B0, 0x029E},
- {0xA7B1, 0x0287},
- {0xA7B2, 0x029D},
- {0xA7B3, 0xAB53},
- {0xA7B4, 0xA7B5},
- {0xA7B6, 0xA7B7},
- {0xA7B8, 0xA7B9},
- {0xA7BA, 0xA7BB},
- {0xA7BC, 0xA7BD},
- {0xA7BE, 0xA7BF},
- {0xA7C0, 0xA7C1},
- {0xA7C2, 0xA7C3},
- {0xA7C4, 0xA794},
- {0xA7C5, 0x0282},
- {0xA7C6, 0x1D8E},
- {0xA7C7, 0xA7C8},
- {0xA7C9, 0xA7CA},
- {0xA7D0, 0xA7D1},
- {0xA7D6, 0xA7D7},
- {0xA7D8, 0xA7D9},
- {0xA7F5, 0xA7F6},
- {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},
- {0xFF21, 0xFF41},
- {0xFF22, 0xFF42},
- {0xFF23, 0xFF43},
- {0xFF24, 0xFF44},
- {0xFF25, 0xFF45},
- {0xFF26, 0xFF46},
- {0xFF27, 0xFF47},
- {0xFF28, 0xFF48},
- {0xFF29, 0xFF49},
- {0xFF2A, 0xFF4A},
- {0xFF2B, 0xFF4B},
- {0xFF2C, 0xFF4C},
- {0xFF2D, 0xFF4D},
- {0xFF2E, 0xFF4E},
- {0xFF2F, 0xFF4F},
- {0xFF30, 0xFF50},
- {0xFF31, 0xFF51},
- {0xFF32, 0xFF52},
- {0xFF33, 0xFF53},
- {0xFF34, 0xFF54},
- {0xFF35, 0xFF55},
- {0xFF36, 0xFF56},
- {0xFF37, 0xFF57},
- {0xFF38, 0xFF58},
- {0xFF39, 0xFF59},
- {0xFF3A, 0xFF5A},
- {0x10400, 0x10428},
- {0x10401, 0x10429},
- {0x10402, 0x1042A},
- {0x10403, 0x1042B},
- {0x10404, 0x1042C},
- {0x10405, 0x1042D},
- {0x10406, 0x1042E},
- {0x10407, 0x1042F},
- {0x10408, 0x10430},
- {0x10409, 0x10431},
- {0x1040A, 0x10432},
- {0x1040B, 0x10433},
- {0x1040C, 0x10434},
- {0x1040D, 0x10435},
- {0x1040E, 0x10436},
- {0x1040F, 0x10437},
- {0x10410, 0x10438},
- {0x10411, 0x10439},
- {0x10412, 0x1043A},
- {0x10413, 0x1043B},
- {0x10414, 0x1043C},
- {0x10415, 0x1043D},
- {0x10416, 0x1043E},
- {0x10417, 0x1043F},
- {0x10418, 0x10440},
- {0x10419, 0x10441},
- {0x1041A, 0x10442},
- {0x1041B, 0x10443},
- {0x1041C, 0x10444},
- {0x1041D, 0x10445},
- {0x1041E, 0x10446},
- {0x1041F, 0x10447},
- {0x10420, 0x10448},
- {0x10421, 0x10449},
- {0x10422, 0x1044A},
- {0x10423, 0x1044B},
- {0x10424, 0x1044C},
- {0x10425, 0x1044D},
- {0x10426, 0x1044E},
- {0x10427, 0x1044F},
- {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},
- {0x10570, 0x10597},
- {0x10571, 0x10598},
- {0x10572, 0x10599},
- {0x10573, 0x1059A},
- {0x10574, 0x1059B},
- {0x10575, 0x1059C},
- {0x10576, 0x1059D},
- {0x10577, 0x1059E},
- {0x10578, 0x1059F},
- {0x10579, 0x105A0},
- {0x1057A, 0x105A1},
- {0x1057C, 0x105A3},
- {0x1057D, 0x105A4},
- {0x1057E, 0x105A5},
- {0x1057F, 0x105A6},
- {0x10580, 0x105A7},
- {0x10581, 0x105A8},
- {0x10582, 0x105A9},
- {0x10583, 0x105AA},
- {0x10584, 0x105AB},
- {0x10585, 0x105AC},
- {0x10586, 0x105AD},
- {0x10587, 0x105AE},
- {0x10588, 0x105AF},
- {0x10589, 0x105B0},
- {0x1058A, 0x105B1},
- {0x1058C, 0x105B3},
- {0x1058D, 0x105B4},
- {0x1058E, 0x105B5},
- {0x1058F, 0x105B6},
- {0x10590, 0x105B7},
- {0x10591, 0x105B8},
- {0x10592, 0x105B9},
- {0x10594, 0x105BB},
- {0x10595, 0x105BC},
- {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},
- {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},
- {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},
- {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},
-};
-
-static int fold2[][ 4 ] = {
- {0x00DF, 0x0073, 0x0073, 0x0},
- {0x0130, 0x0069, 0x0307, 0x0},
- {0x0149, 0x02BC, 0x006E, 0x0},
- {0x01F0, 0x006A, 0x030C, 0x0},
- {0x0390, 0x03B9, 0x0308, 0x0301},
- {0x03B0, 0x03C5, 0x0308, 0x0301},
- {0x0587, 0x0565, 0x0582, 0x0},
- {0x1E96, 0x0068, 0x0331, 0x0},
- {0x1E97, 0x0074, 0x0308, 0x0},
- {0x1E98, 0x0077, 0x030A, 0x0},
- {0x1E99, 0x0079, 0x030A, 0x0},
- {0x1E9A, 0x0061, 0x02BE, 0x0},
- {0x1E9E, 0x0073, 0x0073, 0x0},
- {0x1F50, 0x03C5, 0x0313, 0x0},
- {0x1F52, 0x03C5, 0x0313, 0x0300},
- {0x1F54, 0x03C5, 0x0313, 0x0301},
- {0x1F56, 0x03C5, 0x0313, 0x0342},
- {0x1F80, 0x1F00, 0x03B9, 0x0},
- {0x1F81, 0x1F01, 0x03B9, 0x0},
- {0x1F82, 0x1F02, 0x03B9, 0x0},
- {0x1F83, 0x1F03, 0x03B9, 0x0},
- {0x1F84, 0x1F04, 0x03B9, 0x0},
- {0x1F85, 0x1F05, 0x03B9, 0x0},
- {0x1F86, 0x1F06, 0x03B9, 0x0},
- {0x1F87, 0x1F07, 0x03B9, 0x0},
- {0x1F88, 0x1F00, 0x03B9, 0x0},
- {0x1F89, 0x1F01, 0x03B9, 0x0},
- {0x1F8A, 0x1F02, 0x03B9, 0x0},
- {0x1F8B, 0x1F03, 0x03B9, 0x0},
- {0x1F8C, 0x1F04, 0x03B9, 0x0},
- {0x1F8D, 0x1F05, 0x03B9, 0x0},
- {0x1F8E, 0x1F06, 0x03B9, 0x0},
- {0x1F8F, 0x1F07, 0x03B9, 0x0},
- {0x1F90, 0x1F20, 0x03B9, 0x0},
- {0x1F91, 0x1F21, 0x03B9, 0x0},
- {0x1F92, 0x1F22, 0x03B9, 0x0},
- {0x1F93, 0x1F23, 0x03B9, 0x0},
- {0x1F94, 0x1F24, 0x03B9, 0x0},
- {0x1F95, 0x1F25, 0x03B9, 0x0},
- {0x1F96, 0x1F26, 0x03B9, 0x0},
- {0x1F97, 0x1F27, 0x03B9, 0x0},
- {0x1F98, 0x1F20, 0x03B9, 0x0},
- {0x1F99, 0x1F21, 0x03B9, 0x0},
- {0x1F9A, 0x1F22, 0x03B9, 0x0},
- {0x1F9B, 0x1F23, 0x03B9, 0x0},
- {0x1F9C, 0x1F24, 0x03B9, 0x0},
- {0x1F9D, 0x1F25, 0x03B9, 0x0},
- {0x1F9E, 0x1F26, 0x03B9, 0x0},
- {0x1F9F, 0x1F27, 0x03B9, 0x0},
- {0x1FA0, 0x1F60, 0x03B9, 0x0},
- {0x1FA1, 0x1F61, 0x03B9, 0x0},
- {0x1FA2, 0x1F62, 0x03B9, 0x0},
- {0x1FA3, 0x1F63, 0x03B9, 0x0},
- {0x1FA4, 0x1F64, 0x03B9, 0x0},
- {0x1FA5, 0x1F65, 0x03B9, 0x0},
- {0x1FA6, 0x1F66, 0x03B9, 0x0},
- {0x1FA7, 0x1F67, 0x03B9, 0x0},
- {0x1FA8, 0x1F60, 0x03B9, 0x0},
- {0x1FA9, 0x1F61, 0x03B9, 0x0},
- {0x1FAA, 0x1F62, 0x03B9, 0x0},
- {0x1FAB, 0x1F63, 0x03B9, 0x0},
- {0x1FAC, 0x1F64, 0x03B9, 0x0},
- {0x1FAD, 0x1F65, 0x03B9, 0x0},
- {0x1FAE, 0x1F66, 0x03B9, 0x0},
- {0x1FAF, 0x1F67, 0x03B9, 0x0},
- {0x1FB2, 0x1F70, 0x03B9, 0x0},
- {0x1FB3, 0x03B1, 0x03B9, 0x0},
- {0x1FB4, 0x03AC, 0x03B9, 0x0},
- {0x1FB6, 0x03B1, 0x0342, 0x0},
- {0x1FB7, 0x03B1, 0x0342, 0x03B9},
- {0x1FBC, 0x03B1, 0x03B9, 0x0},
- {0x1FC2, 0x1F74, 0x03B9, 0x0},
- {0x1FC3, 0x03B7, 0x03B9, 0x0},
- {0x1FC4, 0x03AE, 0x03B9, 0x0},
- {0x1FC6, 0x03B7, 0x0342, 0x0},
- {0x1FC7, 0x03B7, 0x0342, 0x03B9},
- {0x1FCC, 0x03B7, 0x03B9, 0x0},
- {0x1FD2, 0x03B9, 0x0308, 0x0300},
- {0x1FD3, 0x03B9, 0x0308, 0x0301},
- {0x1FD6, 0x03B9, 0x0342, 0x0},
- {0x1FD7, 0x03B9, 0x0308, 0x0342},
- {0x1FE2, 0x03C5, 0x0308, 0x0300},
- {0x1FE3, 0x03C5, 0x0308, 0x0301},
- {0x1FE4, 0x03C1, 0x0313, 0x0},
- {0x1FE6, 0x03C5, 0x0342, 0x0},
- {0x1FE7, 0x03C5, 0x0308, 0x0342},
- {0x1FF2, 0x1F7C, 0x03B9, 0x0},
- {0x1FF3, 0x03C9, 0x03B9, 0x0},
- {0x1FF4, 0x03CE, 0x03B9, 0x0},
- {0x1FF6, 0x03C9, 0x0342, 0x0},
- {0x1FF7, 0x03C9, 0x0342, 0x03B9},
- {0x1FFC, 0x03C9, 0x03B9, 0x0},
- {0xFB00, 0x0066, 0x0066, 0x0},
- {0xFB01, 0x0066, 0x0069, 0x0},
- {0xFB02, 0x0066, 0x006C, 0x0},
- {0xFB03, 0x0066, 0x0066, 0x0069},
- {0xFB04, 0x0066, 0x0066, 0x006C},
- {0xFB05, 0x0073, 0x0074, 0x0},
- {0xFB06, 0x0073, 0x0074, 0x0},
- {0xFB13, 0x0574, 0x0576, 0x0},
- {0xFB14, 0x0574, 0x0565, 0x0},
- {0xFB15, 0x0574, 0x056B, 0x0},
- {0xFB16, 0x057E, 0x0576, 0x0},
- {0xFB17, 0x0574, 0x056D, 0x0},
-};
-
/* Branchless UTF-8 decoder
* https://raw.githubusercontent.com/skeeto/branchless-utf8/
@@ -3403,7 +359,8 @@ C_regparm C_word C_utf_compare_ci(C_word s1, C_word s2, C_word start1, C_word st
int e, n = C_unfix(len);
while(n--) {
C_u32 c1, c2;
- int *m, r1, r2, i;
+ const int *m;
+ int r1, r2, i;
p1 = utf8_decode(p1, &c1, &e);
p2 = utf8_decode(p2, &c2, &e);
if(c1 >= 'A' && c1 <= 'Z') r1 = c1 + 32;
@@ -3700,7 +657,7 @@ C_regparm C_word C_utf_to_latin(C_word from, C_word to, C_word start, C_word ble
C_regparm C_word C_utf_char_foldcase(C_word c)
{
int r = C_character_code(c);
- int *m = bsearch(&r, fold1, nelem(fold1), sizeof(*fold1), &runemapcmp);
+ const int *m = bsearch(&r, fold1, nelem(fold1), sizeof(*fold1), &runemapcmp);
if(m) return C_make_character(m[ 1 ]);
return c;
}
@@ -3716,7 +673,7 @@ C_regparm C_word C_utf_string_foldcase(C_word from, C_word to, C_word len)
pf2 = utf8_decode(pf, &c, &e);
if(!e) {
int r = c;
- int *m = bsearch(&r, fold2, nelem(fold2), sizeof(*fold2), &runemapcmp);
+ const int *m = bsearch(&r, fold2, nelem(fold2), sizeof(*fold2), &runemapcmp);
if(m) {
pt = utf8_encode(m[ 1 ], pt);
if(m[ 3 ] != 0) {
Trap