- Update to 6.07

- Support staging

PR:		ports/189848
Submitted by:	Alex Stangl <alex@stangl.us> (maintainer)

8 files changed, 28833 insertions, 123 deletions

diff --git a/www/geneweb/Makefile b/www/geneweb/Makefile
index f116be5604a0..121ce9eeadae 100644
--- a/www/geneweb/Makefile
+++ b/www/geneweb/Makefile
@@ -2,9 +2,9 @@
 # $FreeBSD$
 
 PORTNAME=	geneweb
-PORTVERSION=	6.06
+PORTVERSION=	6.07
 CATEGORIES=	www
-MASTER_SITES=	http://opensource.geneanet.org/attachments/download/211/
+MASTER_SITES=	http://opensource.geneanet.org/attachments/download/240/
 DISTNAME=	gw-${PORTVERSION}-src
 EXTRACT_SUFX=	.tgz
 
@@ -21,7 +21,6 @@ MAKE_JOBS_UNSAFE=	yes
 
 OPTIONS_DEFINE=	GTK2
 
-NO_STAGE=	yes
 .include <bsd.port.options.mk>
 
 .if ${PORT_OPTIONS:MGTK2}
@@ -32,18 +31,17 @@ PLIST_SUB+=	GUI=""
 PLIST_SUB+=	GUI="@comment "
 .endif
 
-MAN1=		ged2gwb.1 gwb2ged.1 gwc.1 gwc2.1 gwu.1 gwd.1 consang.1 gwsetup.1
-
+MAKE_ENV+=	STAGEDIR=${STAGEDIR}
 SUB_FILES+=	pkg-message
 USE_RC_SUBR=	gwd
 
 post-install:
 	(cd ${INSTALL_WRKSRC} && ${SETENV} ${MAKE_ENV} ${MAKE} ${MAKE_FLAGS} ${MAKEFILE} distrib)
-	${INSTALL_DATA} ${WRKSRC}/etc/a.gwf ${PREFIX}/share/geneweb
-	${MKDIR} ${PREFIX}/share/geneweb/distribution
-	${CP} -a ${WRKSRC}/distribution ${PREFIX}/share/geneweb/
-	${INSTALL_SCRIPT} ${FILESDIR}/install.sh ${PREFIX}/share/geneweb
-	${CHMOD} -R go+r  ${PREFIX}/share/geneweb ${_MANPAGES}
-	@${CAT} ${PKGMESSAGE}
+	@${INSTALL_DATA} ${WRKSRC}/etc/a.gwf ${STAGEDIR}${PREFIX}/share/geneweb
+	@${MKDIR} ${STAGEDIR}${PREFIX}/share/geneweb/distribution
+	@${CP} -a ${WRKSRC}/distribution ${STAGEDIR}${PREFIX}/share/geneweb/
+	@${STRIP_CMD} ${STAGEDIR}${PREFIX}/bin/gwc1
+	@${STRIP_CMD} ${STAGEDIR}${PREFIX}/share/geneweb/distribution/gw/gwc1
+	@${INSTALL_SCRIPT} ${FILESDIR}/install.sh ${STAGEDIR}${PREFIX}/share/geneweb
 
 .include <bsd.port.mk>
diff --git a/www/geneweb/distinfo b/www/geneweb/distinfo
index f482bb9dc3c7..237ffb8a03b6 100644
--- a/www/geneweb/distinfo
+++ b/www/geneweb/distinfo
@@ -1,2 +1,2 @@
-SHA256 (gw-6.06-src.tgz) = 6b493369d0935c80e7f08d61d8b8c1c42e765cdc39ec038474b45e6412f0fb4c
-SIZE (gw-6.06-src.tgz) = 1783868
+SHA256 (gw-6.07-src.tgz) = c1ecc337f8bce4d8509ca49081d098b5a44ddb6407208496e55e9a38d6bfb1f6
+SIZE (gw-6.07-src.tgz) = 1855016
diff --git a/www/geneweb/files/patch-Makefile b/www/geneweb/files/patch-Makefile
index 9bc1a5b1d9ce..29a91bdbfca1 100644
--- a/www/geneweb/files/patch-Makefile
+++ b/www/geneweb/files/patch-Makefile
@@ -1,86 +1,65 @@
---- Makefile.orig	2012-12-02 15:04:17.000000000 -0600
-+++ Makefile	2013-02-03 09:45:27.000000000 -0600
-@@ -1,6 +1,5 @@
+--- ./Makefile.orig	2013-03-01 03:06:49.000000000 -0600
++++ ./Makefile	2014-05-14 06:57:05.000000000 -0500
+@@ -1,8 +1,7 @@
  # $Id: Makefile,v 5.7 2009-03-11 10:53:30 ddr Exp $
  
 -PREFIX=/usr
- LANGDIR=$(PREFIX)/share/geneweb
- MANDIR=$(PREFIX)/man/man1
+-LANGDIR=$(PREFIX)/share/geneweb
+-MANDIR=$(PREFIX)/man/man1
++LANGDIR=$(STAGEDIR)$(PREFIX)/share/geneweb
++MANDIR=$(STAGEDIR)$(PREFIX)/man/man1
  DESTDIR=distribution
-@@ -18,7 +17,9 @@
- 	cd gwb2ged; $(MAKE) all
- 	cd setup; $(MAKE) all
- 	cd gwtp; $(MAKE) all
-+.if defined(ENABLE_GUI)
- 	cd gui; $(MAKE) all
-+.endif
+ MANPAGES=ged2gwb.1 gwb2ged.1 gwc.1 gwc2.1 gwu.1 gwd.1 consang.1 gwsetup.1
  
- opt::
- 	cd wserver; $(MAKE) opt
-@@ -28,7 +29,9 @@
- 	cd gwb2ged; $(MAKE) opt
- 	cd setup; $(MAKE) opt
+@@ -29,16 +28,16 @@
  	cd gwtp; $(MAKE) opt
-+.if defined(ENABLE_GUI)
- 	cd gui; $(MAKE) opt
-+.endif
  
  install:
- 	mkdir -p $(PREFIX)/bin
-@@ -65,7 +68,12 @@
- 	rm -rf $(PREFIX)/share/geneweb
+-	mkdir -p $(PREFIX)/bin
+-	cp src/gwc $(PREFIX)/bin/gwc$(EXE)
+-	cp src/gwc1 $(PREFIX)/bin/gwc1$(EXE)
+-	cp src/gwc2 $(PREFIX)/bin/gwc2$(EXE)
+-	cp src/consang $(PREFIX)/bin/consang$(EXE)
+-	cp src/gwd $(PREFIX)/bin/gwd$(EXE)
+-	cp src/gwu $(PREFIX)/bin/gwu$(EXE)
+-	cp ged2gwb/ged2gwb $(PREFIX)/bin/ged2gwb$(EXE)
+-	cp ged2gwb/ged2gwb2 $(PREFIX)/bin/ged2gwb2$(EXE)
+-	cp gwb2ged/gwb2ged $(PREFIX)/bin/gwb2ged$(EXE)
++	mkdir -p $(STAGEDIR)$(PREFIX)/bin
++	cp src/gwc $(STAGEDIR)$(PREFIX)/bin/gwc$(EXE)
++	cp src/gwc1 $(STAGEDIR)$(PREFIX)/bin/gwc1$(EXE)
++	cp src/gwc2 $(STAGEDIR)$(PREFIX)/bin/gwc2$(EXE)
++	cp src/consang $(STAGEDIR)$(PREFIX)/bin/consang$(EXE)
++	cp src/gwd $(STAGEDIR)$(PREFIX)/bin/gwd$(EXE)
++	cp src/gwu $(STAGEDIR)$(PREFIX)/bin/gwu$(EXE)
++	cp ged2gwb/ged2gwb $(STAGEDIR)$(PREFIX)/bin/ged2gwb$(EXE)
++	cp ged2gwb/ged2gwb2 $(STAGEDIR)$(PREFIX)/bin/ged2gwb2$(EXE)
++	cp gwb2ged/gwb2ged $(STAGEDIR)$(PREFIX)/bin/gwb2ged$(EXE)
+ 	mkdir -p $(LANGDIR)/lang
+ 	cp hd/lang/*.txt $(LANGDIR)/lang/.
+ 	mkdir -p $(LANGDIR)/images
+@@ -52,15 +51,15 @@
+ 	cd man; cp $(MANPAGES) $(MANDIR)/.
+ 
+ uninstall:
+-	rm -f $(PREFIX)/bin/gwc$(EXE)
+-	rm -f $(PREFIX)/bin/gwc1$(EXE)
+-	rm -f $(PREFIX)/bin/gwc2$(EXE)
+-	rm -f $(PREFIX)/bin/consang$(EXE)
+-	rm -f $(PREFIX)/bin/gwd$(EXE)
+-	rm -f $(PREFIX)/bin/gwu$(EXE)
+-	rm -f $(PREFIX)/bin/ged2gwb$(EXE)
+-	rm -f $(PREFIX)/bin/gwb2ged$(EXE)
+-	rm -rf $(PREFIX)/share/geneweb
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwc$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwc1$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwc2$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/consang$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwd$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwu$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/ged2gwb$(EXE)
++	rm -f $(STAGEDIR)$(PREFIX)/bin/gwb2ged$(EXE)
++	rm -rf $(STAGEDIR)$(PREFIX)/share/geneweb
  	cd $(MANDIR); rm -f $(MANPAGES)
  
-+
-+.if defined(ENABLE_GUI)
-+distrib: new_distrib wrappers wrappers_gui
-+.else
  distrib: new_distrib wrappers
-+.endif
- 
- wrappers:
- 	if test "$(CAMLP5F)" = "-DWIN95"; then \
-@@ -79,7 +87,6 @@
- 	  echo -ne 'endlocal\r\n' >> $(DESTDIR)/gwsetup.bat; \
- 	  echo -ne 'cd bases\r\n' >> $(DESTDIR)/gwsetup.bat; \
- 	  echo -ne 'start /MIN ..\\gw\\gwsetup -lang fr -gd ..\\gw\r\n' >> $(DESTDIR)/gwsetup.bat; \
--	  echo -ne 'start ..\\gw\\gui' > $(DESTDIR)/geneweb_gui.bat; \
- 	else \
- 	  (echo '#!/bin/sh'; \
- 	   echo 'mkdir -p bases'; \
-@@ -89,9 +96,16 @@
- 	   echo 'mkdir -p bases'; \
- 	   echo 'cd bases'; \
- 	   echo 'exec ../gw/gwsetup -gd ../gw "$$@"') > $(DESTDIR)/gwsetup; \
-+	  chmod +x $(DESTDIR)/gwd $(DESTDIR)/gwsetup; \
-+	fi
-+
-+wrappers_gui:
-+	if test "$(CAMLP5F)" = "-DWIN95"; then \
-+	  echo -ne 'start ..\\gw\\gui' > $(DESTDIR)/geneweb_gui.bat; \
-+	else \
- 	  (echo '#!/bin/sh'; \
- 	   echo 'exec ../gw/gui') > $(DESTDIR)/geneweb_gui; \
--	  chmod +x $(DESTDIR)/gwd $(DESTDIR)/gwsetup $(DESTDIR)/geneweb_gui; \
-+	  chmod +x $(DESTDIR)/geneweb_gui; \
- 	fi
- 
- new_distrib: classical_distrib
-@@ -110,8 +124,10 @@
- 	cp setup/lang/*.htm $(DESTDIR)/gw/setup/lang/.
- 	cp setup/lang/lexicon.txt $(DESTDIR)/gw/setup/lang/.
- 	cp setup/gwsetup $(DESTDIR)/gw/gwsetup$(EXE)
-+.if defined(ENABLE_GUI)
- 	cp gui/gw/gui_lex.txt $(DESTDIR)/gw/.
- 	cp gui/gui $(DESTDIR)/gw/gui$(EXE)
-+.endif
- 	cp LICENSE $(DESTDIR)/LICENSE.txt
- 	cp etc/START.htm $(DESTDIR)/.
- 	cp CHANGES $(DESTDIR)/CHANGES.txt
-@@ -180,4 +196,6 @@
- 	cd gwb2ged; $(MAKE) depend
- 	cd setup; $(MAKE) depend
- 	cd gwtp; $(MAKE) depend
-+.if defined(ENABLE_GUI)
- 	cd gui; $(MAKE) depend
-+.endif
diff --git a/www/geneweb/files/patch-dag2html__Makefile b/www/geneweb/files/patch-dag2html__Makefile
new file mode 100644
index 000000000000..8b976d4e9056
--- /dev/null
+++ b/www/geneweb/files/patch-dag2html__Makefile
@@ -0,0 +1,12 @@
+--- ./dag2html/Makefile.orig	2013-03-01 03:06:49.000000000 -0600
++++ ./dag2html/Makefile	2014-05-14 07:00:04.000000000 -0500
+@@ -1,7 +1,7 @@
+ # $Id: Makefile,v 5.1 2007-07-11 16:15:21 ddr Exp $
+ 
+-BINDIR=/usr/local/bin
+-MANDIR=/usr/local/share/man/man1
++BINDIR=$(STAGING)$(PREFIX)/bin
++MANDIR=$(STAGING)$(PREFIX)/share/man/man1
+ OCAMLC=ocamlc
+ OCAMLOPT=ocamlopt
+ OCARGS=
diff --git a/www/geneweb/files/patch-ged2gwb__utf8.ml b/www/geneweb/files/patch-ged2gwb__utf8.ml
new file mode 100644
index 000000000000..0bfa4a21b6ee
--- /dev/null
+++ b/www/geneweb/files/patch-ged2gwb__utf8.ml
@@ -0,0 +1,28683 @@
+--- ./ged2gwb/utf8.ml.orig	2013-03-01 03:06:44.000000000 -0600
++++ ./ged2gwb/utf8.ml	2014-05-13 23:46:54.000000000 -0500
+@@ -8,72 +8,7 @@
+ *)
+ 
+ value utf8_list =
+-  [("/x00", "NULL");
+-   ("/x01", "START OF HEADING");
+-   ("/x02", "START OF TEXT");
+-   ("/x03", "END OF TEXT");
+-   ("/x04", "END OF TRANSMISSION");
+-   ("/x05", "ENQUIRY");
+-   ("/x06", "ACKNOWLEDGE");
+-   ("/x07", "BELL");
+-   ("/x08", "BACKSPACE");
+-   ("/x09", "HORIZONTAL TABULATION");
+-   ("/x0a", "LINE FEED");
+-   ("/x0b", "VERTICAL TABULATION");
+-   ("/x0c", "FORM FEED");
+-   ("/x0d", "CARRIAGE RETURN");
+-   ("/x0e", "SHIFT OUT");
+-   ("/x0f", "SHIFT IN");
+-   ("/x10", "DATA LINK ESCAPE");
+-   ("/x11", "DEVICE CONTROL ONE");
+-   ("/x12", "DEVICE CONTROL TWO");
+-   ("/x13", "DEVICE CONTROL THREE");
+-   ("/x14", "DEVICE CONTROL FOUR");
+-   ("/x15", "NEGATIVE ACKNOWLEDGE");
+-   ("/x16", "SYNCHRONOUS IDLE");
+-   ("/x17", "END OF TRANSMISSION BLOCK");
+-   ("/x18", "CANCEL");
+-   ("/x19", "END OF MEDIUM");
+-   ("/x1a", "SUBSTITUTE");
+-   ("/x1b", "ESCAPE");
+-   ("/x1c", "FILE SEPARATOR");
+-   ("/x1d", "GROUP SEPARATOR");
+-   ("/x1e", "RECORD SEPARATOR");
+-   ("/x1f", "UNIT SEPARATOR");
+-   ("/x20", "SPACE");
+-   ("/x21", "EXCLAMATION MARK");
+-   ("/x22", "QUOTATION MARK");
+-   ("/x23", "NUMBER SIGN");
+-   ("/x24", "DOLLAR SIGN");
+-   ("/x25", "PERCENT SIGN");
+-   ("/x26", "AMPERSAND");
+-   ("/x27", "APOSTROPHE");
+-   ("/x28", "LEFT PARENTHESIS");
+-   ("/x29", "RIGHT PARENTHESIS");
+-   ("/x2a", "ASTERISK");
+-   ("/x2b", "PLUS SIGN");
+-   ("/x2c", "COMMA");
+-   ("/x2d", "HYPHEN-MINUS");
+-   ("/x2e", "FULL STOP");
+-   ("/x2f", "SOLIDUS");
+-   ("/x30", "DIGIT ZERO");
+-   ("/x31", "DIGIT ONE");
+-   ("/x32", "DIGIT TWO");
+-   ("/x33", "DIGIT THREE");
+-   ("/x34", "DIGIT FOUR");
+-   ("/x35", "DIGIT FIVE");
+-   ("/x36", "DIGIT SIX");
+-   ("/x37", "DIGIT SEVEN");
+-   ("/x38", "DIGIT EIGHT");
+-   ("/x39", "DIGIT NINE");
+-   ("/x3a", "COLON");
+-   ("/x3b", "SEMICOLON");
+-   ("/x3c", "LESS-THAN SIGN");
+-   ("/x3d", "EQUALS SIGN");
+-   ("/x3e", "GREATER-THAN SIGN");
+-   ("/x3f", "QUESTION MARK");
+-   ("/x40", "COMMERCIAL AT");
+-   ("/x41", "LATIN CAPITAL LETTER A");
++  [("/x41", "LATIN CAPITAL LETTER A");
+    ("/x42", "LATIN CAPITAL LETTER B");
+    ("/x43", "LATIN CAPITAL LETTER C");
+    ("/x44", "LATIN CAPITAL LETTER D");
+@@ -99,12 +34,6 @@
+    ("/x58", "LATIN CAPITAL LETTER X");
+    ("/x59", "LATIN CAPITAL LETTER Y");
+    ("/x5a", "LATIN CAPITAL LETTER Z");
+-   ("/x5b", "LEFT SQUARE BRACKET");
+-   ("/x5c", "REVERSE SOLIDUS");
+-   ("/x5d", "RIGHT SQUARE BRACKET");
+-   ("/x5e", "CIRCUMFLEX ACCENT");
+-   ("/x5f", "LOW LINE");
+-   ("/x60", "GRAVE ACCENT");
+    ("/x61", "LATIN SMALL LETTER A");
+    ("/x62", "LATIN SMALL LETTER B");
+    ("/x63", "LATIN SMALL LETTER C");
+@@ -131,75 +60,6 @@
+    ("/x78", "LATIN SMALL LETTER X");
+    ("/x79", "LATIN SMALL LETTER Y");
+    ("/x7a", "LATIN SMALL LETTER Z");
+-   ("/x7b", "LEFT CURLY BRACKET");
+-   ("/x7c", "VERTICAL LINE");
+-   ("/x7d", "RIGHT CURLY BRACKET");
+-   ("/x7e", "TILDE");
+-   ("/x7f", "DELETE");
+-   ("/xc2/x80", "PADDING CHARACTER (PAD)");
+-   ("/xc2/x81", "HIGH OCTET PRESET (HOP)");
+-   ("/xc2/x82", "BREAK PERMITTED HERE (BPH)");
+-   ("/xc2/x83", "NO BREAK HERE (NBH)");
+-   ("/xc2/x84", "INDEX (IND)");
+-   ("/xc2/x85", "NEXT LINE (NEL)");
+-   ("/xc2/x86", "START OF SELECTED AREA (SSA)");
+-   ("/xc2/x87", "END OF SELECTED AREA (ESA)");
+-   ("/xc2/x88", "CHARACTER TABULATION SET (HTS)");
+-   ("/xc2/x89", "CHARACTER TABULATION WITH JUSTIFICATION (HTJ)");
+-   ("/xc2/x8a", "LINE TABULATION SET (VTS)");
+-   ("/xc2/x8b", "PARTIAL LINE FORWARD (PLD)");
+-   ("/xc2/x8c", "PARTIAL LINE BACKWARD (PLU)");
+-   ("/xc2/x8d", "REVERSE LINE FEED (RI)");
+-   ("/xc2/x8e", "SINGLE-SHIFT TWO (SS2)");
+-   ("/xc2/x8f", "SINGLE-SHIFT THREE (SS3)");
+-   ("/xc2/x90", "DEVICE CONTROL STRING (DCS)");
+-   ("/xc2/x91", "PRIVATE USE ONE (PU1)");
+-   ("/xc2/x92", "PRIVATE USE TWO (PU2)");
+-   ("/xc2/x93", "SET TRANSMIT STATE (STS)");
+-   ("/xc2/x94", "CANCEL CHARACTER (CCH)");
+-   ("/xc2/x95", "MESSAGE WAITING (MW)");
+-   ("/xc2/x96", "START OF GUARDED AREA (SPA)");
+-   ("/xc2/x97", "END OF GUARDED AREA (EPA)");
+-   ("/xc2/x98", "START OF STRING (SOS)");
+-   ("/xc2/x99", "SINGLE GRAPHIC CHARACTER INTRODUCER (SGCI)");
+-   ("/xc2/x9a", "SINGLE CHARACTER INTRODUCER (SCI)");
+-   ("/xc2/x9b", "CONTROL SEQUENCE INTRODUCER (CSI)");
+-   ("/xc2/x9c", "STRING TERMINATOR (ST)");
+-   ("/xc2/x9d", "OPERATING SYSTEM COMMAND (OSC)");
+-   ("/xc2/x9e", "PRIVACY MESSAGE (PM)");
+-   ("/xc2/x9f", "APPLICATION PROGRAM COMMAND (APC)");
+-   ("/xc2/xa0", "NO-BREAK SPACE");
+-   ("/xc2/xa1", "INVERTED EXCLAMATION MARK");
+-   ("/xc2/xa2", "CENT SIGN");
+-   ("/xc2/xa3", "POUND SIGN");
+-   ("/xc2/xa4", "CURRENCY SIGN");
+-   ("/xc2/xa5", "YEN SIGN");
+-   ("/xc2/xa6", "BROKEN BAR");
+-   ("/xc2/xa7", "SECTION SIGN");
+-   ("/xc2/xa8", "DIAERESIS");
+-   ("/xc2/xa9", "COPYRIGHT SIGN");
+-   ("/xc2/xaa", "FEMININE ORDINAL INDICATOR");
+-   ("/xc2/xab", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK");
+-   ("/xc2/xac", "NOT SIGN");
+-   ("/xc2/xad", "SOFT HYPHEN");
+-   ("/xc2/xae", "REGISTERED SIGN");
+-   ("/xc2/xaf", "MACRON");
+-   ("/xc2/xb0", "DEGREE SIGN");
+-   ("/xc2/xb1", "PLUS-MINUS SIGN");
+-   ("/xc2/xb2", "SUPERSCRIPT TWO");
+-   ("/xc2/xb3", "SUPERSCRIPT THREE");
+-   ("/xc2/xb4", "ACUTE ACCENT");
+-   ("/xc2/xb5", "MICRO SIGN");
+-   ("/xc2/xb6", "PILCROW SIGN");
+-   ("/xc2/xb7", "MIDDLE DOT");
+-   ("/xc2/xb8", "CEDILLA");
+-   ("/xc2/xb9", "SUPERSCRIPT ONE");
+-   ("/xc2/xba", "MASCULINE ORDINAL INDICATOR");
+-   ("/xc2/xbb", "RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK");
+-   ("/xc2/xbc", "VULGAR FRACTION ONE QUARTER");
+-   ("/xc2/xbd", "VULGAR FRACTION ONE HALF");
+-   ("/xc2/xbe", "VULGAR FRACTION THREE QUARTERS");
+-   ("/xc2/xbf", "INVERTED QUESTION MARK");
+    ("/xc3/x80", "LATIN CAPITAL LETTER A WITH GRAVE");
+    ("/xc3/x81", "LATIN CAPITAL LETTER A WITH ACUTE");
+    ("/xc3/x82", "LATIN CAPITAL LETTER A WITH CIRCUMFLEX");
+@@ -223,7 +83,6 @@
+    ("/xc3/x94", "LATIN CAPITAL LETTER O WITH CIRCUMFLEX");
+    ("/xc3/x95", "LATIN CAPITAL LETTER O WITH TILDE");
+    ("/xc3/x96", "LATIN CAPITAL LETTER O WITH DIAERESIS");
+-   ("/xc3/x97", "MULTIPLICATION SIGN");
+    ("/xc3/x98", "LATIN CAPITAL LETTER O WITH STROKE");
+    ("/xc3/x99", "LATIN CAPITAL LETTER U WITH GRAVE");
+    ("/xc3/x9a", "LATIN CAPITAL LETTER U WITH ACUTE");
+@@ -255,7 +114,6 @@
+    ("/xc3/xb4", "LATIN SMALL LETTER O WITH CIRCUMFLEX");
+    ("/xc3/xb5", "LATIN SMALL LETTER O WITH TILDE");
+    ("/xc3/xb6", "LATIN SMALL LETTER O WITH DIAERESIS");
+-   ("/xc3/xb7", "DIVISION SIGN");
+    ("/xc3/xb8", "LATIN SMALL LETTER O WITH STROKE");
+    ("/xc3/xb9", "LATIN SMALL LETTER U WITH GRAVE");
+    ("/xc3/xba", "LATIN SMALL LETTER U WITH ACUTE");
+@@ -430,11 +288,9 @@
+    ("/xc6/xa3", "LATIN SMALL LETTER OI");
+    ("/xc6/xa4", "LATIN CAPITAL LETTER P WITH HOOK");
+    ("/xc6/xa5", "LATIN SMALL LETTER P WITH HOOK");
+-   ("/xc6/xa6", "LATIN LETTER YR");
+    ("/xc6/xa7", "LATIN CAPITAL LETTER TONE TWO");
+    ("/xc6/xa8", "LATIN SMALL LETTER TONE TWO");
+    ("/xc6/xa9", "LATIN CAPITAL LETTER ESH");
+-   ("/xc6/xaa", "LATIN LETTER REVERSED ESH LOOP");
+    ("/xc6/xab", "LATIN SMALL LETTER T WITH PALATAL HOOK");
+    ("/xc6/xac", "LATIN CAPITAL LETTER T WITH HOOK");
+    ("/xc6/xad", "LATIN SMALL LETTER T WITH HOOK");
+@@ -451,15 +307,8 @@
+    ("/xc6/xb8", "LATIN CAPITAL LETTER EZH REVERSED");
+    ("/xc6/xb9", "LATIN SMALL LETTER EZH REVERSED");
+    ("/xc6/xba", "LATIN SMALL LETTER EZH WITH TAIL");
+-   ("/xc6/xbb", "LATIN LETTER TWO WITH STROKE");
+    ("/xc6/xbc", "LATIN CAPITAL LETTER TONE FIVE");
+    ("/xc6/xbd", "LATIN SMALL LETTER TONE FIVE");
+-   ("/xc6/xbe", "LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE");
+-   ("/xc6/xbf", "LATIN LETTER WYNN");
+-   ("/xc7/x80", "LATIN LETTER DENTAL CLICK");
+-   ("/xc7/x81", "LATIN LETTER LATERAL CLICK");
+-   ("/xc7/x82", "LATIN LETTER ALVEOLAR CLICK");
+-   ("/xc7/x83", "LATIN LETTER RETROFLEX CLICK");
+    ("/xc7/x84", "LATIN CAPITAL LETTER DZ WITH CARON");
+    ("/xc7/x85", "LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON");
+    ("/xc7/x86", "LATIN SMALL LETTER DZ WITH CARON");
+@@ -668,11 +517,6 @@
+    ("/xca/x91", "LATIN SMALL LETTER Z WITH CURL");
+    ("/xca/x92", "LATIN SMALL LETTER EZH");
+    ("/xca/x93", "LATIN SMALL LETTER EZH WITH CURL");
+-   ("/xca/x94", "LATIN LETTER GLOTTAL STOP");
+-   ("/xca/x95", "LATIN LETTER PHARYNGEAL VOICED FRICATIVE");
+-   ("/xca/x96", "LATIN LETTER INVERTED GLOTTAL STOP");
+-   ("/xca/x97", "LATIN LETTER STRETCHED C");
+-   ("/xca/x98", "LATIN LETTER BILABIAL CLICK");
+    ("/xca/x99", "LATIN LETTER SMALL CAPITAL B");
+    ("/xca/x9a", "LATIN SMALL LETTER CLOSED OPEN E");
+    ("/xca/x9b", "LATIN LETTER SMALL CAPITAL G WITH HOOK");
+@@ -681,8 +525,6 @@
+    ("/xca/x9e", "LATIN SMALL LETTER TURNED K");
+    ("/xca/x9f", "LATIN LETTER SMALL CAPITAL L");
+    ("/xca/xa0", "LATIN SMALL LETTER Q WITH HOOK");
+-   ("/xca/xa1", "LATIN LETTER GLOTTAL STOP WITH STROKE");
+-   ("/xca/xa2", "LATIN LETTER REVERSED GLOTTAL STOP WITH STROKE");
+    ("/xca/xa3", "LATIN SMALL LETTER DZ DIGRAPH");
+    ("/xca/xa4", "LATIN SMALL LETTER DEZH DIGRAPH");
+    ("/xca/xa5", "LATIN SMALL LETTER DZ DIGRAPH WITH CURL");
+@@ -692,8 +534,6 @@
+    ("/xca/xa9", "LATIN SMALL LETTER FENG DIGRAPH");
+    ("/xca/xaa", "LATIN SMALL LETTER LS DIGRAPH");
+    ("/xca/xab", "LATIN SMALL LETTER LZ DIGRAPH");
+-   ("/xca/xac", "LATIN LETTER BILABIAL PERCUSSIVE");
+-   ("/xca/xad", "LATIN LETTER BIDENTAL PERCUSSIVE");
+    ("/xca/xae", "LATIN SMALL LETTER TURNED H WITH FISHHOOK");
+    ("/xca/xaf", "LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL");
+    ("/xca/xb0", "MODIFIER LETTER SMALL H");
+@@ -705,176 +545,12 @@
+    ("/xca/xb6", "MODIFIER LETTER SMALL CAPITAL INVERTED R");
+    ("/xca/xb7", "MODIFIER LETTER SMALL W");
+    ("/xca/xb8", "MODIFIER LETTER SMALL Y");
+-   ("/xca/xb9", "MODIFIER LETTER PRIME");
+-   ("/xca/xba", "MODIFIER LETTER DOUBLE PRIME");
+-   ("/xca/xbb", "MODIFIER LETTER TURNED COMMA");
+-   ("/xca/xbc", "MODIFIER LETTER APOSTROPHE");
+-   ("/xca/xbd", "MODIFIER LETTER REVERSED COMMA");
+-   ("/xca/xbe", "MODIFIER LETTER RIGHT HALF RING");
+-   ("/xca/xbf", "MODIFIER LETTER LEFT HALF RING");
+-   ("/xcb/x80", "MODIFIER LETTER GLOTTAL STOP");
+-   ("/xcb/x81", "MODIFIER LETTER REVERSED GLOTTAL STOP");
+-   ("/xcb/x82", "MODIFIER LETTER LEFT ARROWHEAD");
+-   ("/xcb/x83", "MODIFIER LETTER RIGHT ARROWHEAD");
+-   ("/xcb/x84", "MODIFIER LETTER UP ARROWHEAD");
+-   ("/xcb/x85", "MODIFIER LETTER DOWN ARROWHEAD");
+-   ("/xcb/x86", "MODIFIER LETTER CIRCUMFLEX ACCENT");
+-   ("/xcb/x87", "CARON");
+-   ("/xcb/x88", "MODIFIER LETTER VERTICAL LINE");
+-   ("/xcb/x89", "MODIFIER LETTER MACRON");
+-   ("/xcb/x8a", "MODIFIER LETTER ACUTE ACCENT");
+-   ("/xcb/x8b", "MODIFIER LETTER GRAVE ACCENT");
+-   ("/xcb/x8c", "MODIFIER LETTER LOW VERTICAL LINE");
+-   ("/xcb/x8d", "MODIFIER LETTER LOW MACRON");
+-   ("/xcb/x8e", "MODIFIER LETTER LOW GRAVE ACCENT");
+-   ("/xcb/x8f", "MODIFIER LETTER LOW ACUTE ACCENT");
+-   ("/xcb/x90", "MODIFIER LETTER TRIANGULAR COLON");
+-   ("/xcb/x91", "MODIFIER LETTER HALF TRIANGULAR COLON");
+-   ("/xcb/x92", "MODIFIER LETTER CENTRED RIGHT HALF RING");
+-   ("/xcb/x93", "MODIFIER LETTER CENTRED LEFT HALF RING");
+-   ("/xcb/x94", "MODIFIER LETTER UP TACK");
+-   ("/xcb/x95", "MODIFIER LETTER DOWN TACK");
+-   ("/xcb/x96", "MODIFIER LETTER PLUS SIGN");
+-   ("/xcb/x97", "MODIFIER LETTER MINUS SIGN");
+-   ("/xcb/x98", "BREVE");
+-   ("/xcb/x99", "DOT ABOVE");
+-   ("/xcb/x9a", "RING ABOVE");
+-   ("/xcb/x9b", "OGONEK");
+    ("/xcb/x9c", "SMALL TILDE");
+-   ("/xcb/x9d", "DOUBLE ACUTE ACCENT");
+-   ("/xcb/x9e", "MODIFIER LETTER RHOTIC HOOK");
+-   ("/xcb/x9f", "MODIFIER LETTER CROSS ACCENT");
+    ("/xcb/xa0", "MODIFIER LETTER SMALL GAMMA");
+    ("/xcb/xa1", "MODIFIER LETTER SMALL L");
+    ("/xcb/xa2", "MODIFIER LETTER SMALL S");
+    ("/xcb/xa3", "MODIFIER LETTER SMALL X");
+    ("/xcb/xa4", "MODIFIER LETTER SMALL REVERSED GLOTTAL STOP");
+-   ("/xcb/xa5", "MODIFIER LETTER EXTRA-HIGH TONE BAR");
+-   ("/xcb/xa6", "MODIFIER LETTER HIGH TONE BAR");
+-   ("/xcb/xa7", "MODIFIER LETTER MID TONE BAR");
+-   ("/xcb/xa8", "MODIFIER LETTER LOW TONE BAR");
+-   ("/xcb/xa9", "MODIFIER LETTER EXTRA-LOW TONE BAR");
+-   ("/xcb/xaa", "MODIFIER LETTER YIN DEPARTING TONE MARK");
+-   ("/xcb/xab", "MODIFIER LETTER YANG DEPARTING TONE MARK");
+-   ("/xcb/xac", "MODIFIER LETTER VOICING");
+-   ("/xcb/xad", "MODIFIER LETTER UNASPIRATED");
+-   ("/xcb/xae", "MODIFIER LETTER DOUBLE APOSTROPHE");
+-   ("/xcb/xaf", "MODIFIER LETTER LOW DOWN ARROWHEAD");
+-   ("/xcb/xb0", "MODIFIER LETTER LOW UP ARROWHEAD");
+-   ("/xcb/xb1", "MODIFIER LETTER LOW LEFT ARROWHEAD");
+-   ("/xcb/xb2", "MODIFIER LETTER LOW RIGHT ARROWHEAD");
+-   ("/xcb/xb3", "MODIFIER LETTER LOW RING");
+-   ("/xcb/xb4", "MODIFIER LETTER MIDDLE GRAVE ACCENT");
+-   ("/xcb/xb5", "MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT");
+-   ("/xcb/xb6", "MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT");
+-   ("/xcb/xb7", "MODIFIER LETTER LOW TILDE");
+-   ("/xcb/xb8", "MODIFIER LETTER RAISED COLON");
+-   ("/xcb/xb9", "MODIFIER LETTER BEGIN HIGH TONE");
+-   ("/xcb/xba", "MODIFIER LETTER END HIGH TONE");
+-   ("/xcb/xbb", "MODIFIER LETTER BEGIN LOW TONE");
+-   ("/xcb/xbc", "MODIFIER LETTER END LOW TONE");
+-   ("/xcb/xbd", "MODIFIER LETTER SHELF");
+-   ("/xcb/xbe", "MODIFIER LETTER OPEN SHELF");
+-   ("/xcb/xbf", "MODIFIER LETTER LOW LEFT ARROW");
+-   ("/xcc/x80", "COMBINING GRAVE ACCENT");
+-   ("/xcc/x81", "COMBINING ACUTE ACCENT");
+-   ("/xcc/x82", "COMBINING CIRCUMFLEX ACCENT");
+-   ("/xcc/x83", "COMBINING TILDE");
+-   ("/xcc/x84", "COMBINING MACRON");
+-   ("/xcc/x85", "COMBINING OVERLINE");
+-   ("/xcc/x86", "COMBINING BREVE");
+-   ("/xcc/x87", "COMBINING DOT ABOVE");
+-   ("/xcc/x88", "COMBINING DIAERESIS");
+-   ("/xcc/x89", "COMBINING HOOK ABOVE");
+-   ("/xcc/x8a", "COMBINING RING ABOVE");
+-   ("/xcc/x8b", "COMBINING DOUBLE ACUTE ACCENT");
+-   ("/xcc/x8c", "COMBINING CARON");
+-   ("/xcc/x8d", "COMBINING VERTICAL LINE ABOVE");
+-   ("/xcc/x8e", "COMBINING DOUBLE VERTICAL LINE ABOVE");
+-   ("/xcc/x8f", "COMBINING DOUBLE GRAVE ACCENT");
+-   ("/xcc/x90", "COMBINING CANDRABINDU");
+-   ("/xcc/x91", "COMBINING INVERTED BREVE");
+-   ("/xcc/x92", "COMBINING TURNED COMMA ABOVE");
+-   ("/xcc/x93", "COMBINING COMMA ABOVE");
+-   ("/xcc/x94", "COMBINING REVERSED COMMA ABOVE");
+-   ("/xcc/x95", "COMBINING COMMA ABOVE RIGHT");
+-   ("/xcc/x96", "COMBINING GRAVE ACCENT BELOW");
+-   ("/xcc/x97", "COMBINING ACUTE ACCENT BELOW");
+-   ("/xcc/x98", "COMBINING LEFT TACK BELOW");
+-   ("/xcc/x99", "COMBINING RIGHT TACK BELOW");
+-   ("/xcc/x9a", "COMBINING LEFT ANGLE ABOVE");
+-   ("/xcc/x9b", "COMBINING HORN");
+-   ("/xcc/x9c", "COMBINING LEFT HALF RING BELOW");
+-   ("/xcc/x9d", "COMBINING UP TACK BELOW");
+-   ("/xcc/x9e", "COMBINING DOWN TACK BELOW");
+-   ("/xcc/x9f", "COMBINING PLUS SIGN BELOW");
+-   ("/xcc/xa0", "COMBINING MINUS SIGN BELOW");
+-   ("/xcc/xa1", "COMBINING PALATALIZED HOOK BELOW");
+-   ("/xcc/xa2", "COMBINING RETROFLEX HOOK BELOW");
+-   ("/xcc/xa3", "COMBINING DOT BELOW");
+-   ("/xcc/xa4", "COMBINING DIAERESIS BELOW");
+-   ("/xcc/xa5", "COMBINING RING BELOW");
+-   ("/xcc/xa6", "COMBINING COMMA BELOW");
+-   ("/xcc/xa7", "COMBINING CEDILLA");
+-   ("/xcc/xa8", "COMBINING OGONEK");
+-   ("/xcc/xa9", "COMBINING VERTICAL LINE BELOW");
+-   ("/xcc/xaa", "COMBINING BRIDGE BELOW");
+-   ("/xcc/xab", "COMBINING INVERTED DOUBLE ARCH BELOW");
+-   ("/xcc/xac", "COMBINING CARON BELOW");
+-   ("/xcc/xad", "COMBINING CIRCUMFLEX ACCENT BELOW");
+-   ("/xcc/xae", "COMBINING BREVE BELOW");
+-   ("/xcc/xaf", "COMBINING INVERTED BREVE BELOW");
+-   ("/xcc/xb0", "COMBINING TILDE BELOW");
+-   ("/xcc/xb1", "COMBINING MACRON BELOW");
+-   ("/xcc/xb2", "COMBINING LOW LINE");
+-   ("/xcc/xb3", "COMBINING DOUBLE LOW LINE");
+-   ("/xcc/xb4", "COMBINING TILDE OVERLAY");
+-   ("/xcc/xb5", "COMBINING SHORT STROKE OVERLAY");
+-   ("/xcc/xb6", "COMBINING LONG STROKE OVERLAY");
+-   ("/xcc/xb7", "COMBINING SHORT SOLIDUS OVERLAY");
+-   ("/xcc/xb8", "COMBINING LONG SOLIDUS OVERLAY");
+-   ("/xcc/xb9", "COMBINING RIGHT HALF RING BELOW");
+-   ("/xcc/xba", "COMBINING INVERTED BRIDGE BELOW");
+-   ("/xcc/xbb", "COMBINING SQUARE BELOW");
+-   ("/xcc/xbc", "COMBINING SEAGULL BELOW");
+-   ("/xcc/xbd", "COMBINING X ABOVE");
+-   ("/xcc/xbe", "COMBINING VERTICAL TILDE");
+-   ("/xcc/xbf", "COMBINING DOUBLE OVERLINE");
+-   ("/xcd/x80", "COMBINING GRAVE TONE MARK");
+-   ("/xcd/x81", "COMBINING ACUTE TONE MARK");
+-   ("/xcd/x82", "COMBINING GREEK PERISPOMENI");
+-   ("/xcd/x83", "COMBINING GREEK KORONIS");
+-   ("/xcd/x84", "COMBINING GREEK DIALYTIKA TONOS");
+-   ("/xcd/x85", "COMBINING GREEK YPOGEGRAMMENI");
+-   ("/xcd/x86", "COMBINING BRIDGE ABOVE");
+-   ("/xcd/x87", "COMBINING EQUALS SIGN BELOW");
+-   ("/xcd/x88", "COMBINING DOUBLE VERTICAL LINE BELOW");
+-   ("/xcd/x89", "COMBINING LEFT ANGLE BELOW");
+-   ("/xcd/x8a", "COMBINING NOT TILDE ABOVE");
+-   ("/xcd/x8b", "COMBINING HOMOTHETIC ABOVE");
+-   ("/xcd/x8c", "COMBINING ALMOST EQUAL TO ABOVE");
+-   ("/xcd/x8d", "COMBINING LEFT RIGHT ARROW BELOW");
+-   ("/xcd/x8e", "COMBINING UPWARDS ARROW BELOW");
+-   ("/xcd/x8f", "COMBINING GRAPHEME JOINER");
+-   ("/xcd/x90", "COMBINING RIGHT ARROWHEAD ABOVE");
+-   ("/xcd/x91", "COMBINING LEFT HALF RING ABOVE");
+-   ("/xcd/x92", "COMBINING FERMATA");
+-   ("/xcd/x93", "COMBINING X BELOW");
+-   ("/xcd/x94", "COMBINING LEFT ARROWHEAD BELOW");
+-   ("/xcd/x95", "COMBINING RIGHT ARROWHEAD BELOW");
+-   ("/xcd/x96", "COMBINING RIGHT ARROWHEAD AND UP ARROWHEAD BELOW");
+-   ("/xcd/x97", "COMBINING RIGHT HALF RING ABOVE");
+-   ("/xcd/x98", "COMBINING DOT ABOVE RIGHT");
+-   ("/xcd/x99", "COMBINING ASTERISK BELOW");
+-   ("/xcd/x9a", "COMBINING DOUBLE RING BELOW");
+-   ("/xcd/x9b", "COMBINING ZIGZAG ABOVE");
+-   ("/xcd/x9c", "COMBINING DOUBLE BREVE BELOW");
+-   ("/xcd/x9d", "COMBINING DOUBLE BREVE");
+-   ("/xcd/x9e", "COMBINING DOUBLE MACRON");
+-   ("/xcd/x9f", "COMBINING DOUBLE MACRON BELOW");
+-   ("/xcd/xa0", "COMBINING DOUBLE TILDE");
+-   ("/xcd/xa1", "COMBINING DOUBLE INVERTED BREVE");
+-   ("/xcd/xa2", "COMBINING DOUBLE RIGHTWARDS ARROW BELOW");
+    ("/xcd/xa3", "COMBINING LATIN SMALL LETTER A");
+    ("/xcd/xa4", "COMBINING LATIN SMALL LETTER E");
+    ("/xcd/xa5", "COMBINING LATIN SMALL LETTER I");
+@@ -892,19 +568,12 @@
+    ("/xcd/xb1", "GREEK SMALL LETTER HETA");
+    ("/xcd/xb2", "GREEK CAPITAL LETTER ARCHAIC SAMPI");
+    ("/xcd/xb3", "GREEK SMALL LETTER ARCHAIC SAMPI");
+-   ("/xcd/xb4", "GREEK NUMERAL SIGN");
+-   ("/xcd/xb5", "GREEK LOWER NUMERAL SIGN");
+    ("/xcd/xb6", "GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA");
+    ("/xcd/xb7", "GREEK SMALL LETTER PAMPHYLIAN DIGAMMA");
+-   ("/xcd/xba", "GREEK YPOGEGRAMMENI");
+    ("/xcd/xbb", "GREEK SMALL REVERSED LUNATE SIGMA SYMBOL");
+    ("/xcd/xbc", "GREEK SMALL DOTTED LUNATE SIGMA SYMBOL");
+    ("/xcd/xbd", "GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL");
+-   ("/xcd/xbe", "GREEK QUESTION MARK");
+-   ("/xce/x84", "GREEK TONOS");
+-   ("/xce/x85", "GREEK DIALYTIKA TONOS");
+    ("/xce/x86", "GREEK CAPITAL LETTER ALPHA WITH TONOS");
+-   ("/xce/x87", "GREEK ANO TELEIA");
+    ("/xce/x88", "GREEK CAPITAL LETTER EPSILON WITH TONOS");
+    ("/xce/x89", "GREEK CAPITAL LETTER ETA WITH TONOS");
+    ("/xce/x8a", "GREEK CAPITAL LETTER IOTA WITH TONOS");
+@@ -974,23 +643,10 @@
+    ("/xcf/x8d", "GREEK SMALL LETTER UPSILON WITH TONOS");
+    ("/xcf/x8e", "GREEK SMALL LETTER OMEGA WITH TONOS");
+    ("/xcf/x8f", "GREEK CAPITAL KAI SYMBOL");
+-   ("/xcf/x90", "GREEK BETA SYMBOL");
+-   ("/xcf/x91", "GREEK THETA SYMBOL");
+-   ("/xcf/x92", "GREEK UPSILON WITH HOOK SYMBOL");
+-   ("/xcf/x93", "GREEK UPSILON WITH ACUTE AND HOOK SYMBOL");
+-   ("/xcf/x94", "GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL");
+-   ("/xcf/x95", "GREEK PHI SYMBOL");
+-   ("/xcf/x96", "GREEK PI SYMBOL");
+-   ("/xcf/x97", "GREEK KAI SYMBOL");
+-   ("/xcf/x98", "GREEK LETTER ARCHAIC KOPPA");
+    ("/xcf/x99", "GREEK SMALL LETTER ARCHAIC KOPPA");
+-   ("/xcf/x9a", "GREEK LETTER STIGMA");
+    ("/xcf/x9b", "GREEK SMALL LETTER STIGMA");
+-   ("/xcf/x9c", "GREEK LETTER DIGAMMA");
+    ("/xcf/x9d", "GREEK SMALL LETTER DIGAMMA");
+-   ("/xcf/x9e", "GREEK LETTER KOPPA");
+    ("/xcf/x9f", "GREEK SMALL LETTER KOPPA");
+-   ("/xcf/xa0", "GREEK LETTER SAMPI");
+    ("/xcf/xa1", "GREEK SMALL LETTER SAMPI");
+    ("/xcf/xa2", "COPTIC CAPITAL LETTER SHEI");
+    ("/xcf/xa3", "COPTIC SMALL LETTER SHEI");
+@@ -1006,19 +662,12 @@
+    ("/xcf/xad", "COPTIC SMALL LETTER SHIMA");
+    ("/xcf/xae", "COPTIC CAPITAL LETTER DEI");
+    ("/xcf/xaf", "COPTIC SMALL LETTER DEI");
+-   ("/xcf/xb0", "GREEK KAPPA SYMBOL");
+-   ("/xcf/xb1", "GREEK RHO SYMBOL");
+-   ("/xcf/xb2", "GREEK LUNATE SIGMA SYMBOL");
+-   ("/xcf/xb3", "GREEK LETTER YOT");
+    ("/xcf/xb4", "GREEK CAPITAL THETA SYMBOL");
+-   ("/xcf/xb5", "GREEK LUNATE EPSILON SYMBOL");
+-   ("/xcf/xb6", "GREEK REVERSED LUNATE EPSILON SYMBOL");
+    ("/xcf/xb7", "GREEK CAPITAL LETTER SHO");
+    ("/xcf/xb8", "GREEK SMALL LETTER SHO");
+    ("/xcf/xb9", "GREEK CAPITAL LUNATE SIGMA SYMBOL");
+    ("/xcf/xba", "GREEK CAPITAL LETTER SAN");
+    ("/xcf/xbb", "GREEK SMALL LETTER SAN");
+-   ("/xcf/xbc", "GREEK RHO WITH STROKE SYMBOL");
+    ("/xcf/xbd", "GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL");
+    ("/xcf/xbe", "GREEK CAPITAL DOTTED LUNATE SIGMA SYMBOL");
+    ("/xcf/xbf", "GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL");
+@@ -1152,14 +801,6 @@
+    ("/xd1/xbf", "CYRILLIC SMALL LETTER OT");
+    ("/xd2/x80", "CYRILLIC CAPITAL LETTER KOPPA");
+    ("/xd2/x81", "CYRILLIC SMALL LETTER KOPPA");
+-   ("/xd2/x82", "CYRILLIC THOUSANDS SIGN");
+-   ("/xd2/x83", "COMBINING CYRILLIC TITLO");
+-   ("/xd2/x84", "COMBINING CYRILLIC PALATALIZATION");
+-   ("/xd2/x85", "COMBINING CYRILLIC DASIA PNEUMATA");
+-   ("/xd2/x86", "COMBINING CYRILLIC PSILI PNEUMATA");
+-   ("/xd2/x87", "COMBINING CYRILLIC POKRYTIE");
+-   ("/xd2/x88", "COMBINING CYRILLIC HUNDRED THOUSANDS SIGN");
+-   ("/xd2/x89", "COMBINING CYRILLIC MILLIONS SIGN");
+    ("/xd2/x8a", "CYRILLIC CAPITAL LETTER SHORT I WITH TAIL");
+    ("/xd2/x8b", "CYRILLIC SMALL LETTER SHORT I WITH TAIL");
+    ("/xd2/x8c", "CYRILLIC CAPITAL LETTER SEMISOFT SIGN");
+@@ -1214,7 +855,6 @@
+    ("/xd2/xbd", "CYRILLIC SMALL LETTER ABKHASIAN CHE");
+    ("/xd2/xbe", "CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER");
+    ("/xd2/xbf", "CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER");
+-   ("/xd3/x80", "CYRILLIC LETTER PALOCHKA");
+    ("/xd3/x81", "CYRILLIC CAPITAL LETTER ZHE WITH BREVE");
+    ("/xd3/x82", "CYRILLIC SMALL LETTER ZHE WITH BREVE");
+    ("/xd3/x83", "CYRILLIC CAPITAL LETTER KA WITH HOOK");
+@@ -1352,13 +992,6 @@
+    ("/xd5/x94", "ARMENIAN CAPITAL LETTER KEH");
+    ("/xd5/x95", "ARMENIAN CAPITAL LETTER OH");
+    ("/xd5/x96", "ARMENIAN CAPITAL LETTER FEH");
+-   ("/xd5/x99", "ARMENIAN MODIFIER LETTER LEFT HALF RING");
+-   ("/xd5/x9a", "ARMENIAN APOSTROPHE");
+-   ("/xd5/x9b", "ARMENIAN EMPHASIS MARK");
+-   ("/xd5/x9c", "ARMENIAN EXCLAMATION MARK");
+-   ("/xd5/x9d", "ARMENIAN COMMA");
+-   ("/xd5/x9e", "ARMENIAN QUESTION MARK");
+-   ("/xd5/x9f", "ARMENIAN ABBREVIATION MARK");
+    ("/xd5/xa1", "ARMENIAN SMALL LETTER AYB");
+    ("/xd5/xa2", "ARMENIAN SMALL LETTER BEN");
+    ("/xd5/xa3", "ARMENIAN SMALL LETTER GIM");
+@@ -1398,303 +1031,19 @@
+    ("/xd6/x85", "ARMENIAN SMALL LETTER OH");
+    ("/xd6/x86", "ARMENIAN SMALL LETTER FEH");
+    ("/xd6/x87", "ARMENIAN SMALL LIGATURE ECH YIWN");
+-   ("/xd6/x89", "ARMENIAN FULL STOP");
+-   ("/xd6/x8a", "ARMENIAN HYPHEN");
+-   ("/xd6/x91", "HEBREW ACCENT ETNAHTA");
+-   ("/xd6/x92", "HEBREW ACCENT SEGOL");
+-   ("/xd6/x93", "HEBREW ACCENT SHALSHELET");
+-   ("/xd6/x94", "HEBREW ACCENT ZAQEF QATAN");
+-   ("/xd6/x95", "HEBREW ACCENT ZAQEF GADOL");
+-   ("/xd6/x96", "HEBREW ACCENT TIPEHA");
+-   ("/xd6/x97", "HEBREW ACCENT REVIA");
+-   ("/xd6/x98", "HEBREW ACCENT ZARQA");
+-   ("/xd6/x99", "HEBREW ACCENT PASHTA");
+-   ("/xd6/x9a", "HEBREW ACCENT YETIV");
+-   ("/xd6/x9b", "HEBREW ACCENT TEVIR");
+-   ("/xd6/x9c", "HEBREW ACCENT GERESH");
+-   ("/xd6/x9d", "HEBREW ACCENT GERESH MUQDAM");
+-   ("/xd6/x9e", "HEBREW ACCENT GERSHAYIM");
+-   ("/xd6/x9f", "HEBREW ACCENT QARNEY PARA");
+-   ("/xd6/xa0", "HEBREW ACCENT TELISHA GEDOLA");
+-   ("/xd6/xa1", "HEBREW ACCENT PAZER");
+-   ("/xd6/xa2", "HEBREW ACCENT ATNAH HAFUKH");
+-   ("/xd6/xa3", "HEBREW ACCENT MUNAH");
+-   ("/xd6/xa4", "HEBREW ACCENT MAHAPAKH");
+-   ("/xd6/xa5", "HEBREW ACCENT MERKHA");
+-   ("/xd6/xa6", "HEBREW ACCENT MERKHA KEFULA");
+-   ("/xd6/xa7", "HEBREW ACCENT DARGA");
+-   ("/xd6/xa8", "HEBREW ACCENT QADMA");
+-   ("/xd6/xa9", "HEBREW ACCENT TELISHA QETANA");
+-   ("/xd6/xaa", "HEBREW ACCENT YERAH BEN YOMO");
+-   ("/xd6/xab", "HEBREW ACCENT OLE");
+-   ("/xd6/xac", "HEBREW ACCENT ILUY");
+-   ("/xd6/xad", "HEBREW ACCENT DEHI");
+-   ("/xd6/xae", "HEBREW ACCENT ZINOR");
+-   ("/xd6/xaf", "HEBREW MARK MASORA CIRCLE");
+-   ("/xd6/xb0", "HEBREW POINT SHEVA");
+-   ("/xd6/xb1", "HEBREW POINT HATAF SEGOL");
+-   ("/xd6/xb2", "HEBREW POINT HATAF PATAH");
+-   ("/xd6/xb3", "HEBREW POINT HATAF QAMATS");
+-   ("/xd6/xb4", "HEBREW POINT HIRIQ");
+-   ("/xd6/xb5", "HEBREW POINT TSERE");
+-   ("/xd6/xb6", "HEBREW POINT SEGOL");
+-   ("/xd6/xb7", "HEBREW POINT PATAH");
+-   ("/xd6/xb8", "HEBREW POINT QAMATS");
+-   ("/xd6/xb9", "HEBREW POINT HOLAM");
+-   ("/xd6/xba", "HEBREW POINT HOLAM HASER FOR VAV");
+-   ("/xd6/xbb", "HEBREW POINT QUBUTS");
+-   ("/xd6/xbc", "HEBREW POINT DAGESH OR MAPIQ");
+-   ("/xd6/xbd", "HEBREW POINT METEG");
+-   ("/xd6/xbe", "HEBREW PUNCTUATION MAQAF");
+-   ("/xd6/xbf", "HEBREW POINT RAFE");
+-   ("/xd7/x80", "HEBREW PUNCTUATION PASEQ");
+-   ("/xd7/x81", "HEBREW POINT SHIN DOT");
+-   ("/xd7/x82", "HEBREW POINT SIN DOT");
+-   ("/xd7/x83", "HEBREW PUNCTUATION SOF PASUQ");
+-   ("/xd7/x84", "HEBREW MARK UPPER DOT");
+-   ("/xd7/x85", "HEBREW MARK LOWER DOT");
+-   ("/xd7/x86", "HEBREW PUNCTUATION NUN HAFUKHA");
+-   ("/xd7/x87", "HEBREW POINT QAMATS QATAN");
+-   ("/xd7/x90", "HEBREW LETTER ALEF");
+-   ("/xd7/x91", "HEBREW LETTER BET");
+-   ("/xd7/x92", "HEBREW LETTER GIMEL");
+-   ("/xd7/x93", "HEBREW LETTER DALET");
+-   ("/xd7/x94", "HEBREW LETTER HE");
+-   ("/xd7/x95", "HEBREW LETTER VAV");
+-   ("/xd7/x96", "HEBREW LETTER ZAYIN");
+-   ("/xd7/x97", "HEBREW LETTER HET");
+-   ("/xd7/x98", "HEBREW LETTER TET");
+-   ("/xd7/x99", "HEBREW LETTER YOD");
+-   ("/xd7/x9a", "HEBREW LETTER FINAL KAF");
+-   ("/xd7/x9b", "HEBREW LETTER KAF");
+-   ("/xd7/x9c", "HEBREW LETTER LAMED");
+-   ("/xd7/x9d", "HEBREW LETTER FINAL MEM");
+-   ("/xd7/x9e", "HEBREW LETTER MEM");
+-   ("/xd7/x9f", "HEBREW LETTER FINAL NUN");
+-   ("/xd7/xa0", "HEBREW LETTER NUN");
+-   ("/xd7/xa1", "HEBREW LETTER SAMEKH");
+-   ("/xd7/xa2", "HEBREW LETTER AYIN");
+-   ("/xd7/xa3", "HEBREW LETTER FINAL PE");
+-   ("/xd7/xa4", "HEBREW LETTER PE");
+-   ("/xd7/xa5", "HEBREW LETTER FINAL TSADI");
+-   ("/xd7/xa6", "HEBREW LETTER TSADI");
+-   ("/xd7/xa7", "HEBREW LETTER QOF");
+-   ("/xd7/xa8", "HEBREW LETTER RESH");
+-   ("/xd7/xa9", "HEBREW LETTER SHIN");
+-   ("/xd7/xaa", "HEBREW LETTER TAV");
+-   ("/xd7/xb0", "HEBREW LIGATURE YIDDISH DOUBLE VAV");
+-   ("/xd7/xb1", "HEBREW LIGATURE YIDDISH VAV YOD");
+-   ("/xd7/xb2", "HEBREW LIGATURE YIDDISH DOUBLE YOD");
+-   ("/xd7/xb3", "HEBREW PUNCTUATION GERESH");
+-   ("/xd7/xb4", "HEBREW PUNCTUATION GERSHAYIM");
+-   ("/xd8/x80", "ARABIC NUMBER SIGN");
+-   ("/xd8/x81", "ARABIC SIGN SANAH");
+-   ("/xd8/x82", "ARABIC FOOTNOTE MARKER");
+-   ("/xd8/x83", "ARABIC SIGN SAFHA");
+-   ("/xd8/x86", "ARABIC-INDIC CUBE ROOT");
+-   ("/xd8/x87", "ARABIC-INDIC FOURTH ROOT");
+-   ("/xd8/x88", "ARABIC RAY");
+-   ("/xd8/x89", "ARABIC-INDIC PER MILLE SIGN");
+-   ("/xd8/x8a", "ARABIC-INDIC PER TEN THOUSAND SIGN");
+-   ("/xd8/x8b", "AFGHANI SIGN");
+-   ("/xd8/x8c", "ARABIC COMMA");
+-   ("/xd8/x8d", "ARABIC DATE SEPARATOR");
+-   ("/xd8/x8e", "ARABIC POETIC VERSE SIGN");
+-   ("/xd8/x8f", "ARABIC SIGN MISRA");
+-   ("/xd8/x90", "ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM");
+-   ("/xd8/x91", "ARABIC SIGN ALAYHE ASSALLAM");
+-   ("/xd8/x92", "ARABIC SIGN RAHMATULLAH ALAYHE");
+-   ("/xd8/x93", "ARABIC SIGN RADI ALLAHOU ANHU");
+-   ("/xd8/x94", "ARABIC SIGN TAKHALLUS");
+    ("/xd8/x95", "ARABIC SMALL HIGH TAH");
+    ("/xd8/x96", "ARABIC SMALL HIGH LIGATURE ALEF WITH LAM WITH YEH");
+    ("/xd8/x97", "ARABIC SMALL HIGH ZAIN");
+    ("/xd8/x98", "ARABIC SMALL FATHA");
+    ("/xd8/x99", "ARABIC SMALL DAMMA");
+    ("/xd8/x9a", "ARABIC SMALL KASRA");
+-   ("/xd8/x9b", "ARABIC SEMICOLON");
+-   ("/xd8/x9e", "ARABIC TRIPLE DOT PUNCTUATION MARK");
+-   ("/xd8/x9f", "ARABIC QUESTION MARK");
+-   ("/xd8/xa1", "ARABIC LETTER HAMZA");
+-   ("/xd8/xa2", "ARABIC LETTER ALEF WITH MADDA ABOVE");
+-   ("/xd8/xa3", "ARABIC LETTER ALEF WITH HAMZA ABOVE");
+-   ("/xd8/xa4", "ARABIC LETTER WAW WITH HAMZA ABOVE");
+-   ("/xd8/xa5", "ARABIC LETTER ALEF WITH HAMZA BELOW");
+-   ("/xd8/xa6", "ARABIC LETTER YEH WITH HAMZA ABOVE");
+-   ("/xd8/xa7", "ARABIC LETTER ALEF");
+-   ("/xd8/xa8", "ARABIC LETTER BEH");
+-   ("/xd8/xa9", "ARABIC LETTER TEH MARBUTA");
+-   ("/xd8/xaa", "ARABIC LETTER TEH");
+-   ("/xd8/xab", "ARABIC LETTER THEH");
+-   ("/xd8/xac", "ARABIC LETTER JEEM");
+-   ("/xd8/xad", "ARABIC LETTER HAH");
+-   ("/xd8/xae", "ARABIC LETTER KHAH");
+-   ("/xd8/xaf", "ARABIC LETTER DAL");
+-   ("/xd8/xb0", "ARABIC LETTER THAL");
+-   ("/xd8/xb1", "ARABIC LETTER REH");
+-   ("/xd8/xb2", "ARABIC LETTER ZAIN");
+-   ("/xd8/xb3", "ARABIC LETTER SEEN");
+-   ("/xd8/xb4", "ARABIC LETTER SHEEN");
+-   ("/xd8/xb5", "ARABIC LETTER SAD");
+-   ("/xd8/xb6", "ARABIC LETTER DAD");
+-   ("/xd8/xb7", "ARABIC LETTER TAH");
+-   ("/xd8/xb8", "ARABIC LETTER ZAH");
+-   ("/xd8/xb9", "ARABIC LETTER AIN");
+-   ("/xd8/xba", "ARABIC LETTER GHAIN");
+-   ("/xd8/xbb", "ARABIC LETTER KEHEH WITH TWO DOTS ABOVE");
+-   ("/xd8/xbc", "ARABIC LETTER KEHEH WITH THREE DOTS BELOW");
+-   ("/xd8/xbd", "ARABIC LETTER FARSI YEH WITH INVERTED V");
+-   ("/xd8/xbe", "ARABIC LETTER FARSI YEH WITH TWO DOTS ABOVE");
+-   ("/xd8/xbf", "ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE");
+-   ("/xd9/x80", "ARABIC TATWEEL");
+-   ("/xd9/x81", "ARABIC LETTER FEH");
+-   ("/xd9/x82", "ARABIC LETTER QAF");
+-   ("/xd9/x83", "ARABIC LETTER KAF");
+-   ("/xd9/x84", "ARABIC LETTER LAM");
+-   ("/xd9/x85", "ARABIC LETTER MEEM");
+-   ("/xd9/x86", "ARABIC LETTER NOON");
+-   ("/xd9/x87", "ARABIC LETTER HEH");
+-   ("/xd9/x88", "ARABIC LETTER WAW");
+-   ("/xd9/x89", "ARABIC LETTER ALEF MAKSURA");
+-   ("/xd9/x8a", "ARABIC LETTER YEH");
+-   ("/xd9/x8b", "ARABIC FATHATAN");
+-   ("/xd9/x8c", "ARABIC DAMMATAN");
+-   ("/xd9/x8d", "ARABIC KASRATAN");
+-   ("/xd9/x8e", "ARABIC FATHA");
+-   ("/xd9/x8f", "ARABIC DAMMA");
+-   ("/xd9/x90", "ARABIC KASRA");
+-   ("/xd9/x91", "ARABIC SHADDA");
+-   ("/xd9/x92", "ARABIC SUKUN");
+-   ("/xd9/x93", "ARABIC MADDAH ABOVE");
+-   ("/xd9/x94", "ARABIC HAMZA ABOVE");
+-   ("/xd9/x95", "ARABIC HAMZA BELOW");
+-   ("/xd9/x96", "ARABIC SUBSCRIPT ALEF");
+-   ("/xd9/x97", "ARABIC INVERTED DAMMA");
+-   ("/xd9/x98", "ARABIC MARK NOON GHUNNA");
+-   ("/xd9/x99", "ARABIC ZWARAKAY");
+    ("/xd9/x9a", "ARABIC VOWEL SIGN SMALL V ABOVE");
+    ("/xd9/x9b", "ARABIC VOWEL SIGN INVERTED SMALL V ABOVE");
+-   ("/xd9/x9c", "ARABIC VOWEL SIGN DOT BELOW");
+-   ("/xd9/x9d", "ARABIC REVERSED DAMMA");
+-   ("/xd9/x9e", "ARABIC FATHA WITH TWO DOTS");
+-   ("/xd9/xa0", "ARABIC-INDIC DIGIT ZERO");
+-   ("/xd9/xa1", "ARABIC-INDIC DIGIT ONE");
+-   ("/xd9/xa2", "ARABIC-INDIC DIGIT TWO");
+-   ("/xd9/xa3", "ARABIC-INDIC DIGIT THREE");
+-   ("/xd9/xa4", "ARABIC-INDIC DIGIT FOUR");
+-   ("/xd9/xa5", "ARABIC-INDIC DIGIT FIVE");
+-   ("/xd9/xa6", "ARABIC-INDIC DIGIT SIX");
+-   ("/xd9/xa7", "ARABIC-INDIC DIGIT SEVEN");
+-   ("/xd9/xa8", "ARABIC-INDIC DIGIT EIGHT");
+-   ("/xd9/xa9", "ARABIC-INDIC DIGIT NINE");
+-   ("/xd9/xaa", "ARABIC PERCENT SIGN");
+-   ("/xd9/xab", "ARABIC DECIMAL SEPARATOR");
+-   ("/xd9/xac", "ARABIC THOUSANDS SEPARATOR");
+-   ("/xd9/xad", "ARABIC FIVE POINTED STAR");
+-   ("/xd9/xae", "ARABIC LETTER DOTLESS BEH");
+-   ("/xd9/xaf", "ARABIC LETTER DOTLESS QAF");
+-   ("/xd9/xb0", "ARABIC LETTER SUPERSCRIPT ALEF");
+-   ("/xd9/xb1", "ARABIC LETTER ALEF WASLA");
+-   ("/xd9/xb2", "ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE");
+-   ("/xd9/xb3", "ARABIC LETTER ALEF WITH WAVY HAMZA BELOW");
+-   ("/xd9/xb4", "ARABIC LETTER HIGH HAMZA");
+-   ("/xd9/xb5", "ARABIC LETTER HIGH HAMZA ALEF");
+-   ("/xd9/xb6", "ARABIC LETTER HIGH HAMZA WAW");
+-   ("/xd9/xb7", "ARABIC LETTER U WITH HAMZA ABOVE");
+-   ("/xd9/xb8", "ARABIC LETTER HIGH HAMZA YEH");
+-   ("/xd9/xb9", "ARABIC LETTER TTEH");
+-   ("/xd9/xba", "ARABIC LETTER TTEHEH");
+-   ("/xd9/xbb", "ARABIC LETTER BEEH");
+-   ("/xd9/xbc", "ARABIC LETTER TEH WITH RING");
+-   ("/xd9/xbd", "ARABIC LETTER TEH WITH THREE DOTS ABOVE DOWNWARDS");
+-   ("/xd9/xbe", "ARABIC LETTER PEH");
+-   ("/xd9/xbf", "ARABIC LETTER TEHEH");
+-   ("/xda/x80", "ARABIC LETTER BEHEH");
+-   ("/xda/x81", "ARABIC LETTER HAH WITH HAMZA ABOVE");
+-   ("/xda/x82", "ARABIC LETTER HAH WITH TWO DOTS VERTICAL ABOVE");
+-   ("/xda/x83", "ARABIC LETTER NYEH");
+-   ("/xda/x84", "ARABIC LETTER DYEH");
+-   ("/xda/x85", "ARABIC LETTER HAH WITH THREE DOTS ABOVE");
+-   ("/xda/x86", "ARABIC LETTER TCHEH");
+-   ("/xda/x87", "ARABIC LETTER TCHEHEH");
+-   ("/xda/x88", "ARABIC LETTER DDAL");
+-   ("/xda/x89", "ARABIC LETTER DAL WITH RING");
+-   ("/xda/x8a", "ARABIC LETTER DAL WITH DOT BELOW");
+    ("/xda/x8b", "ARABIC LETTER DAL WITH DOT BELOW AND SMALL TAH");
+-   ("/xda/x8c", "ARABIC LETTER DAHAL");
+-   ("/xda/x8d", "ARABIC LETTER DDAHAL");
+-   ("/xda/x8e", "ARABIC LETTER DUL");
+-   ("/xda/x8f", "ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS");
+-   ("/xda/x90", "ARABIC LETTER DAL WITH FOUR DOTS ABOVE");
+-   ("/xda/x91", "ARABIC LETTER RREH");
+    ("/xda/x92", "ARABIC LETTER REH WITH SMALL V");
+-   ("/xda/x93", "ARABIC LETTER REH WITH RING");
+-   ("/xda/x94", "ARABIC LETTER REH WITH DOT BELOW");
+    ("/xda/x95", "ARABIC LETTER REH WITH SMALL V BELOW");
+-   ("/xda/x96", "ARABIC LETTER REH WITH DOT BELOW AND DOT ABOVE");
+-   ("/xda/x97", "ARABIC LETTER REH WITH TWO DOTS ABOVE");
+-   ("/xda/x98", "ARABIC LETTER JEH");
+-   ("/xda/x99", "ARABIC LETTER REH WITH FOUR DOTS ABOVE");
+-   ("/xda/x9a", "ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE");
+-   ("/xda/x9b", "ARABIC LETTER SEEN WITH THREE DOTS BELOW");
+-   ("/xda/x9c", "ARABIC LETTER SEEN WITH THREE DOTS BELOW AND THREE DOTS ABOVE");
+-   ("/xda/x9d", "ARABIC LETTER SAD WITH TWO DOTS BELOW");
+-   ("/xda/x9e", "ARABIC LETTER SAD WITH THREE DOTS ABOVE");
+-   ("/xda/x9f", "ARABIC LETTER TAH WITH THREE DOTS ABOVE");
+-   ("/xda/xa0", "ARABIC LETTER AIN WITH THREE DOTS ABOVE");
+-   ("/xda/xa1", "ARABIC LETTER DOTLESS FEH");
+-   ("/xda/xa2", "ARABIC LETTER FEH WITH DOT MOVED BELOW");
+-   ("/xda/xa3", "ARABIC LETTER FEH WITH DOT BELOW");
+-   ("/xda/xa4", "ARABIC LETTER VEH");
+-   ("/xda/xa5", "ARABIC LETTER FEH WITH THREE DOTS BELOW");
+-   ("/xda/xa6", "ARABIC LETTER PEHEH");
+-   ("/xda/xa7", "ARABIC LETTER QAF WITH DOT ABOVE");
+-   ("/xda/xa8", "ARABIC LETTER QAF WITH THREE DOTS ABOVE");
+-   ("/xda/xa9", "ARABIC LETTER KEHEH");
+-   ("/xda/xaa", "ARABIC LETTER SWASH KAF");
+-   ("/xda/xab", "ARABIC LETTER KAF WITH RING");
+-   ("/xda/xac", "ARABIC LETTER KAF WITH DOT ABOVE");
+-   ("/xda/xad", "ARABIC LETTER NG");
+-   ("/xda/xae", "ARABIC LETTER KAF WITH THREE DOTS BELOW");
+-   ("/xda/xaf", "ARABIC LETTER GAF");
+-   ("/xda/xb0", "ARABIC LETTER GAF WITH RING");
+-   ("/xda/xb1", "ARABIC LETTER NGOEH");
+-   ("/xda/xb2", "ARABIC LETTER GAF WITH TWO DOTS BELOW");
+-   ("/xda/xb3", "ARABIC LETTER GUEH");
+-   ("/xda/xb4", "ARABIC LETTER GAF WITH THREE DOTS ABOVE");
+    ("/xda/xb5", "ARABIC LETTER LAM WITH SMALL V");
+-   ("/xda/xb6", "ARABIC LETTER LAM WITH DOT ABOVE");
+-   ("/xda/xb7", "ARABIC LETTER LAM WITH THREE DOTS ABOVE");
+-   ("/xda/xb8", "ARABIC LETTER LAM WITH THREE DOTS BELOW");
+-   ("/xda/xb9", "ARABIC LETTER NOON WITH DOT BELOW");
+-   ("/xda/xba", "ARABIC LETTER NOON GHUNNA");
+-   ("/xda/xbb", "ARABIC LETTER RNOON");
+-   ("/xda/xbc", "ARABIC LETTER NOON WITH RING");
+-   ("/xda/xbd", "ARABIC LETTER NOON WITH THREE DOTS ABOVE");
+-   ("/xda/xbe", "ARABIC LETTER HEH DOACHASHMEE");
+-   ("/xda/xbf", "ARABIC LETTER TCHEH WITH DOT ABOVE");
+-   ("/xdb/x80", "ARABIC LETTER HEH WITH YEH ABOVE");
+-   ("/xdb/x81", "ARABIC LETTER HEH GOAL");
+-   ("/xdb/x82", "ARABIC LETTER HEH GOAL WITH HAMZA ABOVE");
+-   ("/xdb/x83", "ARABIC LETTER TEH MARBUTA GOAL");
+-   ("/xdb/x84", "ARABIC LETTER WAW WITH RING");
+-   ("/xdb/x85", "ARABIC LETTER KIRGHIZ OE");
+-   ("/xdb/x86", "ARABIC LETTER OE");
+-   ("/xdb/x87", "ARABIC LETTER U");
+-   ("/xdb/x88", "ARABIC LETTER YU");
+-   ("/xdb/x89", "ARABIC LETTER KIRGHIZ YU");
+-   ("/xdb/x8a", "ARABIC LETTER WAW WITH TWO DOTS ABOVE");
+-   ("/xdb/x8b", "ARABIC LETTER VE");
+-   ("/xdb/x8c", "ARABIC LETTER FARSI YEH");
+-   ("/xdb/x8d", "ARABIC LETTER YEH WITH TAIL");
+    ("/xdb/x8e", "ARABIC LETTER YEH WITH SMALL V");
+-   ("/xdb/x8f", "ARABIC LETTER WAW WITH DOT ABOVE");
+-   ("/xdb/x90", "ARABIC LETTER E");
+-   ("/xdb/x91", "ARABIC LETTER YEH WITH THREE DOTS BELOW");
+-   ("/xdb/x92", "ARABIC LETTER YEH BARREE");
+-   ("/xdb/x93", "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE");
+-   ("/xdb/x94", "ARABIC FULL STOP");
+-   ("/xdb/x95", "ARABIC LETTER AE");
+    ("/xdb/x96", "ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA");
+    ("/xdb/x97", "ARABIC SMALL HIGH LIGATURE QAF WITH LAM WITH ALEF MAKSURA");
+    ("/xdb/x98", "ARABIC SMALL HIGH MEEM INITIAL FORM");
+@@ -1702,8 +1051,6 @@
+    ("/xdb/x9a", "ARABIC SMALL HIGH JEEM");
+    ("/xdb/x9b", "ARABIC SMALL HIGH THREE DOTS");
+    ("/xdb/x9c", "ARABIC SMALL HIGH SEEN");
+-   ("/xdb/x9d", "ARABIC END OF AYAH");
+-   ("/xdb/x9e", "ARABIC START OF RUB EL HIZB");
+    ("/xdb/x9f", "ARABIC SMALL HIGH ROUNDED ZERO");
+    ("/xdb/xa0", "ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO");
+    ("/xdb/xa1", "ARABIC SMALL HIGH DOTLESS HEAD OF KHAH");
+@@ -1714,1647 +1061,18 @@
+    ("/xdb/xa6", "ARABIC SMALL YEH");
+    ("/xdb/xa7", "ARABIC SMALL HIGH YEH");
+    ("/xdb/xa8", "ARABIC SMALL HIGH NOON");
+-   ("/xdb/xa9", "ARABIC PLACE OF SAJDAH");
+-   ("/xdb/xaa", "ARABIC EMPTY CENTRE LOW STOP");
+-   ("/xdb/xab", "ARABIC EMPTY CENTRE HIGH STOP");
+-   ("/xdb/xac", "ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE");
+    ("/xdb/xad", "ARABIC SMALL LOW MEEM");
+-   ("/xdb/xae", "ARABIC LETTER DAL WITH INVERTED V");
+-   ("/xdb/xaf", "ARABIC LETTER REH WITH INVERTED V");
+-   ("/xdb/xb0", "EXTENDED ARABIC-INDIC DIGIT ZERO");
+-   ("/xdb/xb1", "EXTENDED ARABIC-INDIC DIGIT ONE");
+-   ("/xdb/xb2", "EXTENDED ARABIC-INDIC DIGIT TWO");
+-   ("/xdb/xb3", "EXTENDED ARABIC-INDIC DIGIT THREE");
+-   ("/xdb/xb4", "EXTENDED ARABIC-INDIC DIGIT FOUR");
+-   ("/xdb/xb5", "EXTENDED ARABIC-INDIC DIGIT FIVE");
+-   ("/xdb/xb6", "EXTENDED ARABIC-INDIC DIGIT SIX");
+-   ("/xdb/xb7", "EXTENDED ARABIC-INDIC DIGIT SEVEN");
+-   ("/xdb/xb8", "EXTENDED ARABIC-INDIC DIGIT EIGHT");
+-   ("/xdb/xb9", "EXTENDED ARABIC-INDIC DIGIT NINE");
+-   ("/xdb/xba", "ARABIC LETTER SHEEN WITH DOT BELOW");
+-   ("/xdb/xbb", "ARABIC LETTER DAD WITH DOT BELOW");
+-   ("/xdb/xbc", "ARABIC LETTER GHAIN WITH DOT BELOW");
+-   ("/xdb/xbd", "ARABIC SIGN SINDHI AMPERSAND");
+-   ("/xdb/xbe", "ARABIC SIGN SINDHI POSTPOSITION MEN");
+-   ("/xdb/xbf", "ARABIC LETTER HEH WITH INVERTED V");
+-   ("/xdc/x80", "SYRIAC END OF PARAGRAPH");
+-   ("/xdc/x81", "SYRIAC SUPRALINEAR FULL STOP");
+-   ("/xdc/x82", "SYRIAC SUBLINEAR FULL STOP");
+-   ("/xdc/x83", "SYRIAC SUPRALINEAR COLON");
+-   ("/xdc/x84", "SYRIAC SUBLINEAR COLON");
+-   ("/xdc/x85", "SYRIAC HORIZONTAL COLON");
+-   ("/xdc/x86", "SYRIAC COLON SKEWED LEFT");
+-   ("/xdc/x87", "SYRIAC COLON SKEWED RIGHT");
+-   ("/xdc/x88", "SYRIAC SUPRALINEAR COLON SKEWED LEFT");
+-   ("/xdc/x89", "SYRIAC SUBLINEAR COLON SKEWED RIGHT");
+-   ("/xdc/x8a", "SYRIAC CONTRACTION");
+-   ("/xdc/x8b", "SYRIAC HARKLEAN OBELUS");
+-   ("/xdc/x8c", "SYRIAC HARKLEAN METOBELUS");
+-   ("/xdc/x8d", "SYRIAC HARKLEAN ASTERISCUS");
+-   ("/xdc/x8f", "SYRIAC ABBREVIATION MARK");
+-   ("/xdc/x90", "SYRIAC LETTER ALAPH");
+-   ("/xdc/x91", "SYRIAC LETTER SUPERSCRIPT ALAPH");
+-   ("/xdc/x92", "SYRIAC LETTER BETH");
+-   ("/xdc/x93", "SYRIAC LETTER GAMAL");
+-   ("/xdc/x94", "SYRIAC LETTER GAMAL GARSHUNI");
+-   ("/xdc/x95", "SYRIAC LETTER DALATH");
+-   ("/xdc/x96", "SYRIAC LETTER DOTLESS DALATH RISH");
+-   ("/xdc/x97", "SYRIAC LETTER HE");
+-   ("/xdc/x98", "SYRIAC LETTER WAW");
+-   ("/xdc/x99", "SYRIAC LETTER ZAIN");
+-   ("/xdc/x9a", "SYRIAC LETTER HETH");
+-   ("/xdc/x9b", "SYRIAC LETTER TETH");
+-   ("/xdc/x9c", "SYRIAC LETTER TETH GARSHUNI");
+-   ("/xdc/x9d", "SYRIAC LETTER YUDH");
+-   ("/xdc/x9e", "SYRIAC LETTER YUDH HE");
+-   ("/xdc/x9f", "SYRIAC LETTER KAPH");
+-   ("/xdc/xa0", "SYRIAC LETTER LAMADH");
+-   ("/xdc/xa1", "SYRIAC LETTER MIM");
+-   ("/xdc/xa2", "SYRIAC LETTER NUN");
+-   ("/xdc/xa3", "SYRIAC LETTER SEMKATH");
+-   ("/xdc/xa4", "SYRIAC LETTER FINAL SEMKATH");
+-   ("/xdc/xa5", "SYRIAC LETTER E");
+-   ("/xdc/xa6", "SYRIAC LETTER PE");
+-   ("/xdc/xa7", "SYRIAC LETTER REVERSED PE");
+-   ("/xdc/xa8", "SYRIAC LETTER SADHE");
+-   ("/xdc/xa9", "SYRIAC LETTER QAPH");
+-   ("/xdc/xaa", "SYRIAC LETTER RISH");
+-   ("/xdc/xab", "SYRIAC LETTER SHIN");
+-   ("/xdc/xac", "SYRIAC LETTER TAW");
+-   ("/xdc/xad", "SYRIAC LETTER PERSIAN BHETH");
+-   ("/xdc/xae", "SYRIAC LETTER PERSIAN GHAMAL");
+-   ("/xdc/xaf", "SYRIAC LETTER PERSIAN DHALATH");
+-   ("/xdc/xb0", "SYRIAC PTHAHA ABOVE");
+-   ("/xdc/xb1", "SYRIAC PTHAHA BELOW");
+-   ("/xdc/xb2", "SYRIAC PTHAHA DOTTED");
+-   ("/xdc/xb3", "SYRIAC ZQAPHA ABOVE");
+-   ("/xdc/xb4", "SYRIAC ZQAPHA BELOW");
+-   ("/xdc/xb5", "SYRIAC ZQAPHA DOTTED");
+-   ("/xdc/xb6", "SYRIAC RBASA ABOVE");
+-   ("/xdc/xb7", "SYRIAC RBASA BELOW");
+-   ("/xdc/xb8", "SYRIAC DOTTED ZLAMA HORIZONTAL");
+-   ("/xdc/xb9", "SYRIAC DOTTED ZLAMA ANGULAR");
+-   ("/xdc/xba", "SYRIAC HBASA ABOVE");
+-   ("/xdc/xbb", "SYRIAC HBASA BELOW");
+-   ("/xdc/xbc", "SYRIAC HBASA-ESASA DOTTED");
+-   ("/xdc/xbd", "SYRIAC ESASA ABOVE");
+-   ("/xdc/xbe", "SYRIAC ESASA BELOW");
+-   ("/xdc/xbf", "SYRIAC RWAHA");
+-   ("/xdd/x80", "SYRIAC FEMININE DOT");
+-   ("/xdd/x81", "SYRIAC QUSHSHAYA");
+-   ("/xdd/x82", "SYRIAC RUKKAKHA");
+-   ("/xdd/x83", "SYRIAC TWO VERTICAL DOTS ABOVE");
+-   ("/xdd/x84", "SYRIAC TWO VERTICAL DOTS BELOW");
+-   ("/xdd/x85", "SYRIAC THREE DOTS ABOVE");
+-   ("/xdd/x86", "SYRIAC THREE DOTS BELOW");
+-   ("/xdd/x87", "SYRIAC OBLIQUE LINE ABOVE");
+-   ("/xdd/x88", "SYRIAC OBLIQUE LINE BELOW");
+-   ("/xdd/x89", "SYRIAC MUSIC");
+-   ("/xdd/x8a", "SYRIAC BARREKH");
+-   ("/xdd/x8d", "SYRIAC LETTER SOGDIAN ZHAIN");
+-   ("/xdd/x8e", "SYRIAC LETTER SOGDIAN KHAPH");
+-   ("/xdd/x8f", "SYRIAC LETTER SOGDIAN FE");
+-   ("/xdd/x90", "ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW");
+-   ("/xdd/x91", "ARABIC LETTER BEH WITH DOT BELOW AND THREE DOTS ABOVE");
+-   ("/xdd/x92", "ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW");
+-   ("/xdd/x93", "ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW AND TWO DOTS ABOVE");
+-   ("/xdd/x94", "ARABIC LETTER BEH WITH TWO DOTS BELOW AND DOT ABOVE");
+    ("/xdd/x95", "ARABIC LETTER BEH WITH INVERTED SMALL V BELOW");
+    ("/xdd/x96", "ARABIC LETTER BEH WITH SMALL V");
+-   ("/xdd/x97", "ARABIC LETTER HAH WITH TWO DOTS ABOVE");
+-   ("/xdd/x98", "ARABIC LETTER HAH WITH THREE DOTS POINTING UPWARDS BELOW");
+    ("/xdd/x99", "ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW AND SMALL TAH");
+    ("/xdd/x9a", "ARABIC LETTER DAL WITH INVERTED SMALL V BELOW");
+-   ("/xdd/x9b", "ARABIC LETTER REH WITH STROKE");
+-   ("/xdd/x9c", "ARABIC LETTER SEEN WITH FOUR DOTS ABOVE");
+-   ("/xdd/x9d", "ARABIC LETTER AIN WITH TWO DOTS ABOVE");
+-   ("/xdd/x9e", "ARABIC LETTER AIN WITH THREE DOTS POINTING DOWNWARDS ABOVE");
+-   ("/xdd/x9f", "ARABIC LETTER AIN WITH TWO DOTS VERTICALLY ABOVE");
+-   ("/xdd/xa0", "ARABIC LETTER FEH WITH TWO DOTS BELOW");
+-   ("/xdd/xa1", "ARABIC LETTER FEH WITH THREE DOTS POINTING UPWARDS BELOW");
+-   ("/xdd/xa2", "ARABIC LETTER KEHEH WITH DOT ABOVE");
+-   ("/xdd/xa3", "ARABIC LETTER KEHEH WITH THREE DOTS ABOVE");
+-   ("/xdd/xa4", "ARABIC LETTER KEHEH WITH THREE DOTS POINTING UPWARDS BELOW");
+-   ("/xdd/xa5", "ARABIC LETTER MEEM WITH DOT ABOVE");
+-   ("/xdd/xa6", "ARABIC LETTER MEEM WITH DOT BELOW");
+-   ("/xdd/xa7", "ARABIC LETTER NOON WITH TWO DOTS BELOW");
+    ("/xdd/xa8", "ARABIC LETTER NOON WITH SMALL TAH");
+    ("/xdd/xa9", "ARABIC LETTER NOON WITH SMALL V");
+-   ("/xdd/xaa", "ARABIC LETTER LAM WITH BAR");
+-   ("/xdd/xab", "ARABIC LETTER REH WITH TWO DOTS VERTICALLY ABOVE");
+-   ("/xdd/xac", "ARABIC LETTER REH WITH HAMZA ABOVE");
+-   ("/xdd/xad", "ARABIC LETTER SEEN WITH TWO DOTS VERTICALLY ABOVE");
+    ("/xdd/xae", "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH BELOW");
+    ("/xdd/xaf", "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH AND TWO DOTS");
+    ("/xdd/xb0", "ARABIC LETTER SEEN WITH SMALL ARABIC LETTER TAH AND TWO DOTS");
+    ("/xdd/xb1", "ARABIC LETTER REH WITH SMALL ARABIC LETTER TAH AND TWO DOTS");
+    ("/xdd/xb2", "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH ABOVE");
+-   ("/xdd/xb3", "ARABIC LETTER ALEF WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE");
+-   ("/xdd/xb4", "ARABIC LETTER ALEF WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE");
+-   ("/xdd/xb5", "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE");
+-   ("/xdd/xb6", "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE");
+-   ("/xdd/xb7", "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT FOUR BELOW");
+-   ("/xdd/xb8", "ARABIC LETTER WAW WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE");
+-   ("/xdd/xb9", "ARABIC LETTER WAW WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE");
+-   ("/xdd/xba", "ARABIC LETTER YEH BARREE WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE");
+-   ("/xdd/xbb", "ARABIC LETTER YEH BARREE WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE");
+-   ("/xdd/xbc", "ARABIC LETTER HAH WITH EXTENDED ARABIC-INDIC DIGIT FOUR BELOW");
+-   ("/xdd/xbd", "ARABIC LETTER SEEN WITH EXTENDED ARABIC-INDIC DIGIT FOUR ABOVE");
+-   ("/xdd/xbe", "ARABIC LETTER SEEN WITH INVERTED V");
+-   ("/xdd/xbf", "ARABIC LETTER KAF WITH TWO DOTS ABOVE");
+-   ("/xde/x80", "THAANA LETTER HAA");
+-   ("/xde/x81", "THAANA LETTER SHAVIYANI");
+-   ("/xde/x82", "THAANA LETTER NOONU");
+-   ("/xde/x83", "THAANA LETTER RAA");
+-   ("/xde/x84", "THAANA LETTER BAA");
+-   ("/xde/x85", "THAANA LETTER LHAVIYANI");
+-   ("/xde/x86", "THAANA LETTER KAAFU");
+-   ("/xde/x87", "THAANA LETTER ALIFU");
+-   ("/xde/x88", "THAANA LETTER VAAVU");
+-   ("/xde/x89", "THAANA LETTER MEEMU");
+-   ("/xde/x8a", "THAANA LETTER FAAFU");
+-   ("/xde/x8b", "THAANA LETTER DHAALU");
+-   ("/xde/x8c", "THAANA LETTER THAA");
+-   ("/xde/x8d", "THAANA LETTER LAAMU");
+-   ("/xde/x8e", "THAANA LETTER GAAFU");
+-   ("/xde/x8f", "THAANA LETTER GNAVIYANI");
+-   ("/xde/x90", "THAANA LETTER SEENU");
+-   ("/xde/x91", "THAANA LETTER DAVIYANI");
+-   ("/xde/x92", "THAANA LETTER ZAVIYANI");
+-   ("/xde/x93", "THAANA LETTER TAVIYANI");
+-   ("/xde/x94", "THAANA LETTER YAA");
+-   ("/xde/x95", "THAANA LETTER PAVIYANI");
+-   ("/xde/x96", "THAANA LETTER JAVIYANI");
+-   ("/xde/x97", "THAANA LETTER CHAVIYANI");
+-   ("/xde/x98", "THAANA LETTER TTAA");
+-   ("/xde/x99", "THAANA LETTER HHAA");
+-   ("/xde/x9a", "THAANA LETTER KHAA");
+-   ("/xde/x9b", "THAANA LETTER THAALU");
+-   ("/xde/x9c", "THAANA LETTER ZAA");
+-   ("/xde/x9d", "THAANA LETTER SHEENU");
+-   ("/xde/x9e", "THAANA LETTER SAADHU");
+-   ("/xde/x9f", "THAANA LETTER DAADHU");
+-   ("/xde/xa0", "THAANA LETTER TO");
+-   ("/xde/xa1", "THAANA LETTER ZO");
+-   ("/xde/xa2", "THAANA LETTER AINU");
+-   ("/xde/xa3", "THAANA LETTER GHAINU");
+-   ("/xde/xa4", "THAANA LETTER QAAFU");
+-   ("/xde/xa5", "THAANA LETTER WAAVU");
+-   ("/xde/xa6", "THAANA ABAFILI");
+-   ("/xde/xa7", "THAANA AABAAFILI");
+-   ("/xde/xa8", "THAANA IBIFILI");
+-   ("/xde/xa9", "THAANA EEBEEFILI");
+-   ("/xde/xaa", "THAANA UBUFILI");
+-   ("/xde/xab", "THAANA OOBOOFILI");
+-   ("/xde/xac", "THAANA EBEFILI");
+-   ("/xde/xad", "THAANA EYBEYFILI");
+-   ("/xde/xae", "THAANA OBOFILI");
+-   ("/xde/xaf", "THAANA OABOAFILI");
+-   ("/xde/xb0", "THAANA SUKUN");
+-   ("/xde/xb1", "THAANA LETTER NAA");
+-   ("/xdf/x80", "NKO DIGIT ZERO");
+-   ("/xdf/x81", "NKO DIGIT ONE");
+-   ("/xdf/x82", "NKO DIGIT TWO");
+-   ("/xdf/x83", "NKO DIGIT THREE");
+-   ("/xdf/x84", "NKO DIGIT FOUR");
+-   ("/xdf/x85", "NKO DIGIT FIVE");
+-   ("/xdf/x86", "NKO DIGIT SIX");
+-   ("/xdf/x87", "NKO DIGIT SEVEN");
+-   ("/xdf/x88", "NKO DIGIT EIGHT");
+-   ("/xdf/x89", "NKO DIGIT NINE");
+-   ("/xdf/x8a", "NKO LETTER A");
+-   ("/xdf/x8b", "NKO LETTER EE");
+-   ("/xdf/x8c", "NKO LETTER I");
+-   ("/xdf/x8d", "NKO LETTER E");
+-   ("/xdf/x8e", "NKO LETTER U");
+-   ("/xdf/x8f", "NKO LETTER OO");
+-   ("/xdf/x90", "NKO LETTER O");
+-   ("/xdf/x91", "NKO LETTER DAGBASINNA");
+-   ("/xdf/x92", "NKO LETTER N");
+-   ("/xdf/x93", "NKO LETTER BA");
+-   ("/xdf/x94", "NKO LETTER PA");
+-   ("/xdf/x95", "NKO LETTER TA");
+-   ("/xdf/x96", "NKO LETTER JA");
+-   ("/xdf/x97", "NKO LETTER CHA");
+-   ("/xdf/x98", "NKO LETTER DA");
+-   ("/xdf/x99", "NKO LETTER RA");
+-   ("/xdf/x9a", "NKO LETTER RRA");
+-   ("/xdf/x9b", "NKO LETTER SA");
+-   ("/xdf/x9c", "NKO LETTER GBA");
+-   ("/xdf/x9d", "NKO LETTER FA");
+-   ("/xdf/x9e", "NKO LETTER KA");
+-   ("/xdf/x9f", "NKO LETTER LA");
+-   ("/xdf/xa0", "NKO LETTER NA WOLOSO");
+-   ("/xdf/xa1", "NKO LETTER MA");
+-   ("/xdf/xa2", "NKO LETTER NYA");
+-   ("/xdf/xa3", "NKO LETTER NA");
+-   ("/xdf/xa4", "NKO LETTER HA");
+-   ("/xdf/xa5", "NKO LETTER WA");
+-   ("/xdf/xa6", "NKO LETTER YA");
+-   ("/xdf/xa7", "NKO LETTER NYA WOLOSO");
+-   ("/xdf/xa8", "NKO LETTER JONA JA");
+-   ("/xdf/xa9", "NKO LETTER JONA CHA");
+-   ("/xdf/xaa", "NKO LETTER JONA RA");
+-   ("/xdf/xab", "NKO COMBINING SHORT HIGH TONE");
+-   ("/xdf/xac", "NKO COMBINING SHORT LOW TONE");
+-   ("/xdf/xad", "NKO COMBINING SHORT RISING TONE");
+-   ("/xdf/xae", "NKO COMBINING LONG DESCENDING TONE");
+-   ("/xdf/xaf", "NKO COMBINING LONG HIGH TONE");
+-   ("/xdf/xb0", "NKO COMBINING LONG LOW TONE");
+-   ("/xdf/xb1", "NKO COMBINING LONG RISING TONE");
+-   ("/xdf/xb2", "NKO COMBINING NASALIZATION MARK");
+-   ("/xdf/xb3", "NKO COMBINING DOUBLE DOT ABOVE");
+-   ("/xdf/xb4", "NKO HIGH TONE APOSTROPHE");
+-   ("/xdf/xb5", "NKO LOW TONE APOSTROPHE");
+-   ("/xdf/xb6", "NKO SYMBOL OO DENNEN");
+-   ("/xdf/xb7", "NKO SYMBOL GBAKURUNEN");
+-   ("/xdf/xb8", "NKO COMMA");
+-   ("/xdf/xb9", "NKO EXCLAMATION MARK");
+-   ("/xdf/xba", "NKO LAJANYALAN");
+-   ("/xe0/xa4/x81", "DEVANAGARI SIGN CANDRABINDU");
+-   ("/xe0/xa4/x82", "DEVANAGARI SIGN ANUSVARA");
+-   ("/xe0/xa4/x83", "DEVANAGARI SIGN VISARGA");
+-   ("/xe0/xa4/x84", "DEVANAGARI LETTER SHORT A");
+-   ("/xe0/xa4/x85", "DEVANAGARI LETTER A");
+-   ("/xe0/xa4/x86", "DEVANAGARI LETTER AA");
+-   ("/xe0/xa4/x87", "DEVANAGARI LETTER I");
+-   ("/xe0/xa4/x88", "DEVANAGARI LETTER II");
+-   ("/xe0/xa4/x89", "DEVANAGARI LETTER U");
+-   ("/xe0/xa4/x8a", "DEVANAGARI LETTER UU");
+-   ("/xe0/xa4/x8b", "DEVANAGARI LETTER VOCALIC R");
+-   ("/xe0/xa4/x8c", "DEVANAGARI LETTER VOCALIC L");
+-   ("/xe0/xa4/x8d", "DEVANAGARI LETTER CANDRA E");
+-   ("/xe0/xa4/x8e", "DEVANAGARI LETTER SHORT E");
+-   ("/xe0/xa4/x8f", "DEVANAGARI LETTER E");
+-   ("/xe0/xa4/x90", "DEVANAGARI LETTER AI");
+-   ("/xe0/xa4/x91", "DEVANAGARI LETTER CANDRA O");
+-   ("/xe0/xa4/x92", "DEVANAGARI LETTER SHORT O");
+-   ("/xe0/xa4/x93", "DEVANAGARI LETTER O");
+-   ("/xe0/xa4/x94", "DEVANAGARI LETTER AU");
+-   ("/xe0/xa4/x95", "DEVANAGARI LETTER KA");
+-   ("/xe0/xa4/x96", "DEVANAGARI LETTER KHA");
+-   ("/xe0/xa4/x97", "DEVANAGARI LETTER GA");
+-   ("/xe0/xa4/x98", "DEVANAGARI LETTER GHA");
+-   ("/xe0/xa4/x99", "DEVANAGARI LETTER NGA");
+-   ("/xe0/xa4/x9a", "DEVANAGARI LETTER CA");
+-   ("/xe0/xa4/x9b", "DEVANAGARI LETTER CHA");
+-   ("/xe0/xa4/x9c", "DEVANAGARI LETTER JA");
+-   ("/xe0/xa4/x9d", "DEVANAGARI LETTER JHA");
+-   ("/xe0/xa4/x9e", "DEVANAGARI LETTER NYA");
+-   ("/xe0/xa4/x9f", "DEVANAGARI LETTER TTA");
+-   ("/xe0/xa4/xa0", "DEVANAGARI LETTER TTHA");
+-   ("/xe0/xa4/xa1", "DEVANAGARI LETTER DDA");
+-   ("/xe0/xa4/xa2", "DEVANAGARI LETTER DDHA");
+-   ("/xe0/xa4/xa3", "DEVANAGARI LETTER NNA");
+-   ("/xe0/xa4/xa4", "DEVANAGARI LETTER TA");
+-   ("/xe0/xa4/xa5", "DEVANAGARI LETTER THA");
+-   ("/xe0/xa4/xa6", "DEVANAGARI LETTER DA");
+-   ("/xe0/xa4/xa7", "DEVANAGARI LETTER DHA");
+-   ("/xe0/xa4/xa8", "DEVANAGARI LETTER NA");
+-   ("/xe0/xa4/xa9", "DEVANAGARI LETTER NNNA");
+-   ("/xe0/xa4/xaa", "DEVANAGARI LETTER PA");
+-   ("/xe0/xa4/xab", "DEVANAGARI LETTER PHA");
+-   ("/xe0/xa4/xac", "DEVANAGARI LETTER BA");
+-   ("/xe0/xa4/xad", "DEVANAGARI LETTER BHA");
+-   ("/xe0/xa4/xae", "DEVANAGARI LETTER MA");
+-   ("/xe0/xa4/xaf", "DEVANAGARI LETTER YA");
+-   ("/xe0/xa4/xb0", "DEVANAGARI LETTER RA");
+-   ("/xe0/xa4/xb1", "DEVANAGARI LETTER RRA");
+-   ("/xe0/xa4/xb2", "DEVANAGARI LETTER LA");
+-   ("/xe0/xa4/xb3", "DEVANAGARI LETTER LLA");
+-   ("/xe0/xa4/xb4", "DEVANAGARI LETTER LLLA");
+-   ("/xe0/xa4/xb5", "DEVANAGARI LETTER VA");
+-   ("/xe0/xa4/xb6", "DEVANAGARI LETTER SHA");
+-   ("/xe0/xa4/xb7", "DEVANAGARI LETTER SSA");
+-   ("/xe0/xa4/xb8", "DEVANAGARI LETTER SA");
+-   ("/xe0/xa4/xb9", "DEVANAGARI LETTER HA");
+-   ("/xe0/xa4/xbc", "DEVANAGARI SIGN NUKTA");
+-   ("/xe0/xa4/xbd", "DEVANAGARI SIGN AVAGRAHA");
+-   ("/xe0/xa4/xbe", "DEVANAGARI VOWEL SIGN AA");
+-   ("/xe0/xa4/xbf", "DEVANAGARI VOWEL SIGN I");
+-   ("/xe0/xa5/x80", "DEVANAGARI VOWEL SIGN II");
+-   ("/xe0/xa5/x81", "DEVANAGARI VOWEL SIGN U");
+-   ("/xe0/xa5/x82", "DEVANAGARI VOWEL SIGN UU");
+-   ("/xe0/xa5/x83", "DEVANAGARI VOWEL SIGN VOCALIC R");
+-   ("/xe0/xa5/x84", "DEVANAGARI VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xa5/x85", "DEVANAGARI VOWEL SIGN CANDRA E");
+-   ("/xe0/xa5/x86", "DEVANAGARI VOWEL SIGN SHORT E");
+-   ("/xe0/xa5/x87", "DEVANAGARI VOWEL SIGN E");
+-   ("/xe0/xa5/x88", "DEVANAGARI VOWEL SIGN AI");
+-   ("/xe0/xa5/x89", "DEVANAGARI VOWEL SIGN CANDRA O");
+-   ("/xe0/xa5/x8a", "DEVANAGARI VOWEL SIGN SHORT O");
+-   ("/xe0/xa5/x8b", "DEVANAGARI VOWEL SIGN O");
+-   ("/xe0/xa5/x8c", "DEVANAGARI VOWEL SIGN AU");
+-   ("/xe0/xa5/x8d", "DEVANAGARI SIGN VIRAMA");
+-   ("/xe0/xa5/x90", "DEVANAGARI OM");
+-   ("/xe0/xa5/x91", "DEVANAGARI STRESS SIGN UDATTA");
+-   ("/xe0/xa5/x92", "DEVANAGARI STRESS SIGN ANUDATTA");
+-   ("/xe0/xa5/x93", "DEVANAGARI GRAVE ACCENT");
+-   ("/xe0/xa5/x94", "DEVANAGARI ACUTE ACCENT");
+-   ("/xe0/xa5/x98", "DEVANAGARI LETTER QA");
+-   ("/xe0/xa5/x99", "DEVANAGARI LETTER KHHA");
+-   ("/xe0/xa5/x9a", "DEVANAGARI LETTER GHHA");
+-   ("/xe0/xa5/x9b", "DEVANAGARI LETTER ZA");
+-   ("/xe0/xa5/x9c", "DEVANAGARI LETTER DDDHA");
+-   ("/xe0/xa5/x9d", "DEVANAGARI LETTER RHA");
+-   ("/xe0/xa5/x9e", "DEVANAGARI LETTER FA");
+-   ("/xe0/xa5/x9f", "DEVANAGARI LETTER YYA");
+-   ("/xe0/xa5/xa0", "DEVANAGARI LETTER VOCALIC RR");
+-   ("/xe0/xa5/xa1", "DEVANAGARI LETTER VOCALIC LL");
+-   ("/xe0/xa5/xa2", "DEVANAGARI VOWEL SIGN VOCALIC L");
+-   ("/xe0/xa5/xa3", "DEVANAGARI VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xa5/xa4", "DEVANAGARI DANDA");
+-   ("/xe0/xa5/xa5", "DEVANAGARI DOUBLE DANDA");
+-   ("/xe0/xa5/xa6", "DEVANAGARI DIGIT ZERO");
+-   ("/xe0/xa5/xa7", "DEVANAGARI DIGIT ONE");
+-   ("/xe0/xa5/xa8", "DEVANAGARI DIGIT TWO");
+-   ("/xe0/xa5/xa9", "DEVANAGARI DIGIT THREE");
+-   ("/xe0/xa5/xaa", "DEVANAGARI DIGIT FOUR");
+-   ("/xe0/xa5/xab", "DEVANAGARI DIGIT FIVE");
+-   ("/xe0/xa5/xac", "DEVANAGARI DIGIT SIX");
+-   ("/xe0/xa5/xad", "DEVANAGARI DIGIT SEVEN");
+-   ("/xe0/xa5/xae", "DEVANAGARI DIGIT EIGHT");
+-   ("/xe0/xa5/xaf", "DEVANAGARI DIGIT NINE");
+-   ("/xe0/xa5/xb0", "DEVANAGARI ABBREVIATION SIGN");
+-   ("/xe0/xa5/xb1", "DEVANAGARI SIGN HIGH SPACING DOT");
+-   ("/xe0/xa5/xb2", "DEVANAGARI LETTER CANDRA A");
+-   ("/xe0/xa5/xbb", "DEVANAGARI LETTER GGA");
+-   ("/xe0/xa5/xbc", "DEVANAGARI LETTER JJA");
+-   ("/xe0/xa5/xbd", "DEVANAGARI LETTER GLOTTAL STOP");
+-   ("/xe0/xa5/xbe", "DEVANAGARI LETTER DDDA");
+-   ("/xe0/xa5/xbf", "DEVANAGARI LETTER BBA");
+-   ("/xe0/xa6/x81", "BENGALI SIGN CANDRABINDU");
+-   ("/xe0/xa6/x82", "BENGALI SIGN ANUSVARA");
+-   ("/xe0/xa6/x83", "BENGALI SIGN VISARGA");
+-   ("/xe0/xa6/x85", "BENGALI LETTER A");
+-   ("/xe0/xa6/x86", "BENGALI LETTER AA");
+-   ("/xe0/xa6/x87", "BENGALI LETTER I");
+-   ("/xe0/xa6/x88", "BENGALI LETTER II");
+-   ("/xe0/xa6/x89", "BENGALI LETTER U");
+-   ("/xe0/xa6/x8a", "BENGALI LETTER UU");
+-   ("/xe0/xa6/x8b", "BENGALI LETTER VOCALIC R");
+-   ("/xe0/xa6/x8c", "BENGALI LETTER VOCALIC L");
+-   ("/xe0/xa6/x8f", "BENGALI LETTER E");
+-   ("/xe0/xa6/x90", "BENGALI LETTER AI");
+-   ("/xe0/xa6/x93", "BENGALI LETTER O");
+-   ("/xe0/xa6/x94", "BENGALI LETTER AU");
+-   ("/xe0/xa6/x95", "BENGALI LETTER KA");
+-   ("/xe0/xa6/x96", "BENGALI LETTER KHA");
+-   ("/xe0/xa6/x97", "BENGALI LETTER GA");
+-   ("/xe0/xa6/x98", "BENGALI LETTER GHA");
+-   ("/xe0/xa6/x99", "BENGALI LETTER NGA");
+-   ("/xe0/xa6/x9a", "BENGALI LETTER CA");
+-   ("/xe0/xa6/x9b", "BENGALI LETTER CHA");
+-   ("/xe0/xa6/x9c", "BENGALI LETTER JA");
+-   ("/xe0/xa6/x9d", "BENGALI LETTER JHA");
+-   ("/xe0/xa6/x9e", "BENGALI LETTER NYA");
+-   ("/xe0/xa6/x9f", "BENGALI LETTER TTA");
+-   ("/xe0/xa6/xa0", "BENGALI LETTER TTHA");
+-   ("/xe0/xa6/xa1", "BENGALI LETTER DDA");
+-   ("/xe0/xa6/xa2", "BENGALI LETTER DDHA");
+-   ("/xe0/xa6/xa3", "BENGALI LETTER NNA");
+-   ("/xe0/xa6/xa4", "BENGALI LETTER TA");
+-   ("/xe0/xa6/xa5", "BENGALI LETTER THA");
+-   ("/xe0/xa6/xa6", "BENGALI LETTER DA");
+-   ("/xe0/xa6/xa7", "BENGALI LETTER DHA");
+-   ("/xe0/xa6/xa8", "BENGALI LETTER NA");
+-   ("/xe0/xa6/xaa", "BENGALI LETTER PA");
+-   ("/xe0/xa6/xab", "BENGALI LETTER PHA");
+-   ("/xe0/xa6/xac", "BENGALI LETTER BA");
+-   ("/xe0/xa6/xad", "BENGALI LETTER BHA");
+-   ("/xe0/xa6/xae", "BENGALI LETTER MA");
+-   ("/xe0/xa6/xaf", "BENGALI LETTER YA");
+-   ("/xe0/xa6/xb0", "BENGALI LETTER RA");
+-   ("/xe0/xa6/xb2", "BENGALI LETTER LA");
+-   ("/xe0/xa6/xb6", "BENGALI LETTER SHA");
+-   ("/xe0/xa6/xb7", "BENGALI LETTER SSA");
+-   ("/xe0/xa6/xb8", "BENGALI LETTER SA");
+-   ("/xe0/xa6/xb9", "BENGALI LETTER HA");
+-   ("/xe0/xa6/xbc", "BENGALI SIGN NUKTA");
+-   ("/xe0/xa6/xbd", "BENGALI SIGN AVAGRAHA");
+-   ("/xe0/xa6/xbe", "BENGALI VOWEL SIGN AA");
+-   ("/xe0/xa6/xbf", "BENGALI VOWEL SIGN I");
+-   ("/xe0/xa7/x80", "BENGALI VOWEL SIGN II");
+-   ("/xe0/xa7/x81", "BENGALI VOWEL SIGN U");
+-   ("/xe0/xa7/x82", "BENGALI VOWEL SIGN UU");
+-   ("/xe0/xa7/x83", "BENGALI VOWEL SIGN VOCALIC R");
+-   ("/xe0/xa7/x84", "BENGALI VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xa7/x87", "BENGALI VOWEL SIGN E");
+-   ("/xe0/xa7/x88", "BENGALI VOWEL SIGN AI");
+-   ("/xe0/xa7/x8b", "BENGALI VOWEL SIGN O");
+-   ("/xe0/xa7/x8c", "BENGALI VOWEL SIGN AU");
+-   ("/xe0/xa7/x8d", "BENGALI SIGN VIRAMA");
+-   ("/xe0/xa7/x8e", "BENGALI LETTER KHANDA TA");
+-   ("/xe0/xa7/x97", "BENGALI AU LENGTH MARK");
+-   ("/xe0/xa7/x9c", "BENGALI LETTER RRA");
+-   ("/xe0/xa7/x9d", "BENGALI LETTER RHA");
+-   ("/xe0/xa7/x9f", "BENGALI LETTER YYA");
+-   ("/xe0/xa7/xa0", "BENGALI LETTER VOCALIC RR");
+-   ("/xe0/xa7/xa1", "BENGALI LETTER VOCALIC LL");
+-   ("/xe0/xa7/xa2", "BENGALI VOWEL SIGN VOCALIC L");
+-   ("/xe0/xa7/xa3", "BENGALI VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xa7/xa6", "BENGALI DIGIT ZERO");
+-   ("/xe0/xa7/xa7", "BENGALI DIGIT ONE");
+-   ("/xe0/xa7/xa8", "BENGALI DIGIT TWO");
+-   ("/xe0/xa7/xa9", "BENGALI DIGIT THREE");
+-   ("/xe0/xa7/xaa", "BENGALI DIGIT FOUR");
+-   ("/xe0/xa7/xab", "BENGALI DIGIT FIVE");
+-   ("/xe0/xa7/xac", "BENGALI DIGIT SIX");
+-   ("/xe0/xa7/xad", "BENGALI DIGIT SEVEN");
+-   ("/xe0/xa7/xae", "BENGALI DIGIT EIGHT");
+-   ("/xe0/xa7/xaf", "BENGALI DIGIT NINE");
+-   ("/xe0/xa7/xb0", "BENGALI LETTER RA WITH MIDDLE DIAGONAL");
+-   ("/xe0/xa7/xb1", "BENGALI LETTER RA WITH LOWER DIAGONAL");
+-   ("/xe0/xa7/xb2", "BENGALI RUPEE MARK");
+-   ("/xe0/xa7/xb3", "BENGALI RUPEE SIGN");
+-   ("/xe0/xa7/xb4", "BENGALI CURRENCY NUMERATOR ONE");
+-   ("/xe0/xa7/xb5", "BENGALI CURRENCY NUMERATOR TWO");
+-   ("/xe0/xa7/xb6", "BENGALI CURRENCY NUMERATOR THREE");
+-   ("/xe0/xa7/xb7", "BENGALI CURRENCY NUMERATOR FOUR");
+-   ("/xe0/xa7/xb8", "BENGALI CURRENCY NUMERATOR ONE LESS THAN THE DENOMINATOR");
+-   ("/xe0/xa7/xb9", "BENGALI CURRENCY DENOMINATOR SIXTEEN");
+-   ("/xe0/xa7/xba", "BENGALI ISSHAR");
+-   ("/xe0/xa8/x81", "GURMUKHI SIGN ADAK BINDI");
+-   ("/xe0/xa8/x82", "GURMUKHI SIGN BINDI");
+-   ("/xe0/xa8/x83", "GURMUKHI SIGN VISARGA");
+-   ("/xe0/xa8/x85", "GURMUKHI LETTER A");
+-   ("/xe0/xa8/x86", "GURMUKHI LETTER AA");
+-   ("/xe0/xa8/x87", "GURMUKHI LETTER I");
+-   ("/xe0/xa8/x88", "GURMUKHI LETTER II");
+-   ("/xe0/xa8/x89", "GURMUKHI LETTER U");
+-   ("/xe0/xa8/x8a", "GURMUKHI LETTER UU");
+-   ("/xe0/xa8/x8f", "GURMUKHI LETTER EE");
+-   ("/xe0/xa8/x90", "GURMUKHI LETTER AI");
+-   ("/xe0/xa8/x93", "GURMUKHI LETTER OO");
+-   ("/xe0/xa8/x94", "GURMUKHI LETTER AU");
+-   ("/xe0/xa8/x95", "GURMUKHI LETTER KA");
+-   ("/xe0/xa8/x96", "GURMUKHI LETTER KHA");
+-   ("/xe0/xa8/x97", "GURMUKHI LETTER GA");
+-   ("/xe0/xa8/x98", "GURMUKHI LETTER GHA");
+-   ("/xe0/xa8/x99", "GURMUKHI LETTER NGA");
+-   ("/xe0/xa8/x9a", "GURMUKHI LETTER CA");
+-   ("/xe0/xa8/x9b", "GURMUKHI LETTER CHA");
+-   ("/xe0/xa8/x9c", "GURMUKHI LETTER JA");
+-   ("/xe0/xa8/x9d", "GURMUKHI LETTER JHA");
+-   ("/xe0/xa8/x9e", "GURMUKHI LETTER NYA");
+-   ("/xe0/xa8/x9f", "GURMUKHI LETTER TTA");
+-   ("/xe0/xa8/xa0", "GURMUKHI LETTER TTHA");
+-   ("/xe0/xa8/xa1", "GURMUKHI LETTER DDA");
+-   ("/xe0/xa8/xa2", "GURMUKHI LETTER DDHA");
+-   ("/xe0/xa8/xa3", "GURMUKHI LETTER NNA");
+-   ("/xe0/xa8/xa4", "GURMUKHI LETTER TA");
+-   ("/xe0/xa8/xa5", "GURMUKHI LETTER THA");
+-   ("/xe0/xa8/xa6", "GURMUKHI LETTER DA");
+-   ("/xe0/xa8/xa7", "GURMUKHI LETTER DHA");
+-   ("/xe0/xa8/xa8", "GURMUKHI LETTER NA");
+-   ("/xe0/xa8/xaa", "GURMUKHI LETTER PA");
+-   ("/xe0/xa8/xab", "GURMUKHI LETTER PHA");
+-   ("/xe0/xa8/xac", "GURMUKHI LETTER BA");
+-   ("/xe0/xa8/xad", "GURMUKHI LETTER BHA");
+-   ("/xe0/xa8/xae", "GURMUKHI LETTER MA");
+-   ("/xe0/xa8/xaf", "GURMUKHI LETTER YA");
+-   ("/xe0/xa8/xb0", "GURMUKHI LETTER RA");
+-   ("/xe0/xa8/xb2", "GURMUKHI LETTER LA");
+-   ("/xe0/xa8/xb3", "GURMUKHI LETTER LLA");
+-   ("/xe0/xa8/xb5", "GURMUKHI LETTER VA");
+-   ("/xe0/xa8/xb6", "GURMUKHI LETTER SHA");
+-   ("/xe0/xa8/xb8", "GURMUKHI LETTER SA");
+-   ("/xe0/xa8/xb9", "GURMUKHI LETTER HA");
+-   ("/xe0/xa8/xbc", "GURMUKHI SIGN NUKTA");
+-   ("/xe0/xa8/xbe", "GURMUKHI VOWEL SIGN AA");
+-   ("/xe0/xa8/xbf", "GURMUKHI VOWEL SIGN I");
+-   ("/xe0/xa9/x80", "GURMUKHI VOWEL SIGN II");
+-   ("/xe0/xa9/x81", "GURMUKHI VOWEL SIGN U");
+-   ("/xe0/xa9/x82", "GURMUKHI VOWEL SIGN UU");
+-   ("/xe0/xa9/x87", "GURMUKHI VOWEL SIGN EE");
+-   ("/xe0/xa9/x88", "GURMUKHI VOWEL SIGN AI");
+-   ("/xe0/xa9/x8b", "GURMUKHI VOWEL SIGN OO");
+-   ("/xe0/xa9/x8c", "GURMUKHI VOWEL SIGN AU");
+-   ("/xe0/xa9/x8d", "GURMUKHI SIGN VIRAMA");
+-   ("/xe0/xa9/x91", "GURMUKHI SIGN UDAAT");
+-   ("/xe0/xa9/x99", "GURMUKHI LETTER KHHA");
+-   ("/xe0/xa9/x9a", "GURMUKHI LETTER GHHA");
+-   ("/xe0/xa9/x9b", "GURMUKHI LETTER ZA");
+-   ("/xe0/xa9/x9c", "GURMUKHI LETTER RRA");
+-   ("/xe0/xa9/x9e", "GURMUKHI LETTER FA");
+-   ("/xe0/xa9/xa6", "GURMUKHI DIGIT ZERO");
+-   ("/xe0/xa9/xa7", "GURMUKHI DIGIT ONE");
+-   ("/xe0/xa9/xa8", "GURMUKHI DIGIT TWO");
+-   ("/xe0/xa9/xa9", "GURMUKHI DIGIT THREE");
+-   ("/xe0/xa9/xaa", "GURMUKHI DIGIT FOUR");
+-   ("/xe0/xa9/xab", "GURMUKHI DIGIT FIVE");
+-   ("/xe0/xa9/xac", "GURMUKHI DIGIT SIX");
+-   ("/xe0/xa9/xad", "GURMUKHI DIGIT SEVEN");
+-   ("/xe0/xa9/xae", "GURMUKHI DIGIT EIGHT");
+-   ("/xe0/xa9/xaf", "GURMUKHI DIGIT NINE");
+-   ("/xe0/xa9/xb0", "GURMUKHI TIPPI");
+-   ("/xe0/xa9/xb1", "GURMUKHI ADDAK");
+-   ("/xe0/xa9/xb2", "GURMUKHI IRI");
+-   ("/xe0/xa9/xb3", "GURMUKHI URA");
+-   ("/xe0/xa9/xb4", "GURMUKHI EK ONKAR");
+-   ("/xe0/xa9/xb5", "GURMUKHI SIGN YAKASH");
+-   ("/xe0/xaa/x81", "GUJARATI SIGN CANDRABINDU");
+-   ("/xe0/xaa/x82", "GUJARATI SIGN ANUSVARA");
+-   ("/xe0/xaa/x83", "GUJARATI SIGN VISARGA");
+-   ("/xe0/xaa/x85", "GUJARATI LETTER A");
+-   ("/xe0/xaa/x86", "GUJARATI LETTER AA");
+-   ("/xe0/xaa/x87", "GUJARATI LETTER I");
+-   ("/xe0/xaa/x88", "GUJARATI LETTER II");
+-   ("/xe0/xaa/x89", "GUJARATI LETTER U");
+-   ("/xe0/xaa/x8a", "GUJARATI LETTER UU");
+-   ("/xe0/xaa/x8b", "GUJARATI LETTER VOCALIC R");
+-   ("/xe0/xaa/x8c", "GUJARATI LETTER VOCALIC L");
+-   ("/xe0/xaa/x8d", "GUJARATI VOWEL CANDRA E");
+-   ("/xe0/xaa/x8f", "GUJARATI LETTER E");
+-   ("/xe0/xaa/x90", "GUJARATI LETTER AI");
+-   ("/xe0/xaa/x91", "GUJARATI VOWEL CANDRA O");
+-   ("/xe0/xaa/x93", "GUJARATI LETTER O");
+-   ("/xe0/xaa/x94", "GUJARATI LETTER AU");
+-   ("/xe0/xaa/x95", "GUJARATI LETTER KA");
+-   ("/xe0/xaa/x96", "GUJARATI LETTER KHA");
+-   ("/xe0/xaa/x97", "GUJARATI LETTER GA");
+-   ("/xe0/xaa/x98", "GUJARATI LETTER GHA");
+-   ("/xe0/xaa/x99", "GUJARATI LETTER NGA");
+-   ("/xe0/xaa/x9a", "GUJARATI LETTER CA");
+-   ("/xe0/xaa/x9b", "GUJARATI LETTER CHA");
+-   ("/xe0/xaa/x9c", "GUJARATI LETTER JA");
+-   ("/xe0/xaa/x9d", "GUJARATI LETTER JHA");
+-   ("/xe0/xaa/x9e", "GUJARATI LETTER NYA");
+-   ("/xe0/xaa/x9f", "GUJARATI LETTER TTA");
+-   ("/xe0/xaa/xa0", "GUJARATI LETTER TTHA");
+-   ("/xe0/xaa/xa1", "GUJARATI LETTER DDA");
+-   ("/xe0/xaa/xa2", "GUJARATI LETTER DDHA");
+-   ("/xe0/xaa/xa3", "GUJARATI LETTER NNA");
+-   ("/xe0/xaa/xa4", "GUJARATI LETTER TA");
+-   ("/xe0/xaa/xa5", "GUJARATI LETTER THA");
+-   ("/xe0/xaa/xa6", "GUJARATI LETTER DA");
+-   ("/xe0/xaa/xa7", "GUJARATI LETTER DHA");
+-   ("/xe0/xaa/xa8", "GUJARATI LETTER NA");
+-   ("/xe0/xaa/xaa", "GUJARATI LETTER PA");
+-   ("/xe0/xaa/xab", "GUJARATI LETTER PHA");
+-   ("/xe0/xaa/xac", "GUJARATI LETTER BA");
+-   ("/xe0/xaa/xad", "GUJARATI LETTER BHA");
+-   ("/xe0/xaa/xae", "GUJARATI LETTER MA");
+-   ("/xe0/xaa/xaf", "GUJARATI LETTER YA");
+-   ("/xe0/xaa/xb0", "GUJARATI LETTER RA");
+-   ("/xe0/xaa/xb2", "GUJARATI LETTER LA");
+-   ("/xe0/xaa/xb3", "GUJARATI LETTER LLA");
+-   ("/xe0/xaa/xb5", "GUJARATI LETTER VA");
+-   ("/xe0/xaa/xb6", "GUJARATI LETTER SHA");
+-   ("/xe0/xaa/xb7", "GUJARATI LETTER SSA");
+-   ("/xe0/xaa/xb8", "GUJARATI LETTER SA");
+-   ("/xe0/xaa/xb9", "GUJARATI LETTER HA");
+-   ("/xe0/xaa/xbc", "GUJARATI SIGN NUKTA");
+-   ("/xe0/xaa/xbd", "GUJARATI SIGN AVAGRAHA");
+-   ("/xe0/xaa/xbe", "GUJARATI VOWEL SIGN AA");
+-   ("/xe0/xaa/xbf", "GUJARATI VOWEL SIGN I");
+-   ("/xe0/xab/x80", "GUJARATI VOWEL SIGN II");
+-   ("/xe0/xab/x81", "GUJARATI VOWEL SIGN U");
+-   ("/xe0/xab/x82", "GUJARATI VOWEL SIGN UU");
+-   ("/xe0/xab/x83", "GUJARATI VOWEL SIGN VOCALIC R");
+-   ("/xe0/xab/x84", "GUJARATI VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xab/x85", "GUJARATI VOWEL SIGN CANDRA E");
+-   ("/xe0/xab/x87", "GUJARATI VOWEL SIGN E");
+-   ("/xe0/xab/x88", "GUJARATI VOWEL SIGN AI");
+-   ("/xe0/xab/x89", "GUJARATI VOWEL SIGN CANDRA O");
+-   ("/xe0/xab/x8b", "GUJARATI VOWEL SIGN O");
+-   ("/xe0/xab/x8c", "GUJARATI VOWEL SIGN AU");
+-   ("/xe0/xab/x8d", "GUJARATI SIGN VIRAMA");
+-   ("/xe0/xab/x90", "GUJARATI OM");
+-   ("/xe0/xab/xa0", "GUJARATI LETTER VOCALIC RR");
+-   ("/xe0/xab/xa1", "GUJARATI LETTER VOCALIC LL");
+-   ("/xe0/xab/xa2", "GUJARATI VOWEL SIGN VOCALIC L");
+-   ("/xe0/xab/xa3", "GUJARATI VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xab/xa6", "GUJARATI DIGIT ZERO");
+-   ("/xe0/xab/xa7", "GUJARATI DIGIT ONE");
+-   ("/xe0/xab/xa8", "GUJARATI DIGIT TWO");
+-   ("/xe0/xab/xa9", "GUJARATI DIGIT THREE");
+-   ("/xe0/xab/xaa", "GUJARATI DIGIT FOUR");
+-   ("/xe0/xab/xab", "GUJARATI DIGIT FIVE");
+-   ("/xe0/xab/xac", "GUJARATI DIGIT SIX");
+-   ("/xe0/xab/xad", "GUJARATI DIGIT SEVEN");
+-   ("/xe0/xab/xae", "GUJARATI DIGIT EIGHT");
+-   ("/xe0/xab/xaf", "GUJARATI DIGIT NINE");
+-   ("/xe0/xab/xb1", "GUJARATI RUPEE SIGN");
+-   ("/xe0/xac/x81", "ORIYA SIGN CANDRABINDU");
+-   ("/xe0/xac/x82", "ORIYA SIGN ANUSVARA");
+-   ("/xe0/xac/x83", "ORIYA SIGN VISARGA");
+-   ("/xe0/xac/x85", "ORIYA LETTER A");
+-   ("/xe0/xac/x86", "ORIYA LETTER AA");
+-   ("/xe0/xac/x87", "ORIYA LETTER I");
+-   ("/xe0/xac/x88", "ORIYA LETTER II");
+-   ("/xe0/xac/x89", "ORIYA LETTER U");
+-   ("/xe0/xac/x8a", "ORIYA LETTER UU");
+-   ("/xe0/xac/x8b", "ORIYA LETTER VOCALIC R");
+-   ("/xe0/xac/x8c", "ORIYA LETTER VOCALIC L");
+-   ("/xe0/xac/x8f", "ORIYA LETTER E");
+-   ("/xe0/xac/x90", "ORIYA LETTER AI");
+-   ("/xe0/xac/x93", "ORIYA LETTER O");
+-   ("/xe0/xac/x94", "ORIYA LETTER AU");
+-   ("/xe0/xac/x95", "ORIYA LETTER KA");
+-   ("/xe0/xac/x96", "ORIYA LETTER KHA");
+-   ("/xe0/xac/x97", "ORIYA LETTER GA");
+-   ("/xe0/xac/x98", "ORIYA LETTER GHA");
+-   ("/xe0/xac/x99", "ORIYA LETTER NGA");
+-   ("/xe0/xac/x9a", "ORIYA LETTER CA");
+-   ("/xe0/xac/x9b", "ORIYA LETTER CHA");
+-   ("/xe0/xac/x9c", "ORIYA LETTER JA");
+-   ("/xe0/xac/x9d", "ORIYA LETTER JHA");
+-   ("/xe0/xac/x9e", "ORIYA LETTER NYA");
+-   ("/xe0/xac/x9f", "ORIYA LETTER TTA");
+-   ("/xe0/xac/xa0", "ORIYA LETTER TTHA");
+-   ("/xe0/xac/xa1", "ORIYA LETTER DDA");
+-   ("/xe0/xac/xa2", "ORIYA LETTER DDHA");
+-   ("/xe0/xac/xa3", "ORIYA LETTER NNA");
+-   ("/xe0/xac/xa4", "ORIYA LETTER TA");
+-   ("/xe0/xac/xa5", "ORIYA LETTER THA");
+-   ("/xe0/xac/xa6", "ORIYA LETTER DA");
+-   ("/xe0/xac/xa7", "ORIYA LETTER DHA");
+-   ("/xe0/xac/xa8", "ORIYA LETTER NA");
+-   ("/xe0/xac/xaa", "ORIYA LETTER PA");
+-   ("/xe0/xac/xab", "ORIYA LETTER PHA");
+-   ("/xe0/xac/xac", "ORIYA LETTER BA");
+-   ("/xe0/xac/xad", "ORIYA LETTER BHA");
+-   ("/xe0/xac/xae", "ORIYA LETTER MA");
+-   ("/xe0/xac/xaf", "ORIYA LETTER YA");
+-   ("/xe0/xac/xb0", "ORIYA LETTER RA");
+-   ("/xe0/xac/xb2", "ORIYA LETTER LA");
+-   ("/xe0/xac/xb3", "ORIYA LETTER LLA");
+-   ("/xe0/xac/xb5", "ORIYA LETTER VA");
+-   ("/xe0/xac/xb6", "ORIYA LETTER SHA");
+-   ("/xe0/xac/xb7", "ORIYA LETTER SSA");
+-   ("/xe0/xac/xb8", "ORIYA LETTER SA");
+-   ("/xe0/xac/xb9", "ORIYA LETTER HA");
+-   ("/xe0/xac/xbc", "ORIYA SIGN NUKTA");
+-   ("/xe0/xac/xbd", "ORIYA SIGN AVAGRAHA");
+-   ("/xe0/xac/xbe", "ORIYA VOWEL SIGN AA");
+-   ("/xe0/xac/xbf", "ORIYA VOWEL SIGN I");
+-   ("/xe0/xad/x80", "ORIYA VOWEL SIGN II");
+-   ("/xe0/xad/x81", "ORIYA VOWEL SIGN U");
+-   ("/xe0/xad/x82", "ORIYA VOWEL SIGN UU");
+-   ("/xe0/xad/x83", "ORIYA VOWEL SIGN VOCALIC R");
+-   ("/xe0/xad/x84", "ORIYA VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xad/x87", "ORIYA VOWEL SIGN E");
+-   ("/xe0/xad/x88", "ORIYA VOWEL SIGN AI");
+-   ("/xe0/xad/x8b", "ORIYA VOWEL SIGN O");
+-   ("/xe0/xad/x8c", "ORIYA VOWEL SIGN AU");
+-   ("/xe0/xad/x8d", "ORIYA SIGN VIRAMA");
+-   ("/xe0/xad/x96", "ORIYA AI LENGTH MARK");
+-   ("/xe0/xad/x97", "ORIYA AU LENGTH MARK");
+-   ("/xe0/xad/x9c", "ORIYA LETTER RRA");
+-   ("/xe0/xad/x9d", "ORIYA LETTER RHA");
+-   ("/xe0/xad/x9f", "ORIYA LETTER YYA");
+-   ("/xe0/xad/xa0", "ORIYA LETTER VOCALIC RR");
+-   ("/xe0/xad/xa1", "ORIYA LETTER VOCALIC LL");
+-   ("/xe0/xad/xa2", "ORIYA VOWEL SIGN VOCALIC L");
+-   ("/xe0/xad/xa3", "ORIYA VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xad/xa6", "ORIYA DIGIT ZERO");
+-   ("/xe0/xad/xa7", "ORIYA DIGIT ONE");
+-   ("/xe0/xad/xa8", "ORIYA DIGIT TWO");
+-   ("/xe0/xad/xa9", "ORIYA DIGIT THREE");
+-   ("/xe0/xad/xaa", "ORIYA DIGIT FOUR");
+-   ("/xe0/xad/xab", "ORIYA DIGIT FIVE");
+-   ("/xe0/xad/xac", "ORIYA DIGIT SIX");
+-   ("/xe0/xad/xad", "ORIYA DIGIT SEVEN");
+-   ("/xe0/xad/xae", "ORIYA DIGIT EIGHT");
+-   ("/xe0/xad/xaf", "ORIYA DIGIT NINE");
+-   ("/xe0/xad/xb0", "ORIYA ISSHAR");
+-   ("/xe0/xad/xb1", "ORIYA LETTER WA");
+-   ("/xe0/xae/x82", "TAMIL SIGN ANUSVARA");
+-   ("/xe0/xae/x83", "TAMIL SIGN VISARGA");
+-   ("/xe0/xae/x85", "TAMIL LETTER A");
+-   ("/xe0/xae/x86", "TAMIL LETTER AA");
+-   ("/xe0/xae/x87", "TAMIL LETTER I");
+-   ("/xe0/xae/x88", "TAMIL LETTER II");
+-   ("/xe0/xae/x89", "TAMIL LETTER U");
+-   ("/xe0/xae/x8a", "TAMIL LETTER UU");
+-   ("/xe0/xae/x8e", "TAMIL LETTER E");
+-   ("/xe0/xae/x8f", "TAMIL LETTER EE");
+-   ("/xe0/xae/x90", "TAMIL LETTER AI");
+-   ("/xe0/xae/x92", "TAMIL LETTER O");
+-   ("/xe0/xae/x93", "TAMIL LETTER OO");
+-   ("/xe0/xae/x94", "TAMIL LETTER AU");
+-   ("/xe0/xae/x95", "TAMIL LETTER KA");
+-   ("/xe0/xae/x99", "TAMIL LETTER NGA");
+-   ("/xe0/xae/x9a", "TAMIL LETTER CA");
+-   ("/xe0/xae/x9c", "TAMIL LETTER JA");
+-   ("/xe0/xae/x9e", "TAMIL LETTER NYA");
+-   ("/xe0/xae/x9f", "TAMIL LETTER TTA");
+-   ("/xe0/xae/xa3", "TAMIL LETTER NNA");
+-   ("/xe0/xae/xa4", "TAMIL LETTER TA");
+-   ("/xe0/xae/xa8", "TAMIL LETTER NA");
+-   ("/xe0/xae/xa9", "TAMIL LETTER NNNA");
+-   ("/xe0/xae/xaa", "TAMIL LETTER PA");
+-   ("/xe0/xae/xae", "TAMIL LETTER MA");
+-   ("/xe0/xae/xaf", "TAMIL LETTER YA");
+-   ("/xe0/xae/xb0", "TAMIL LETTER RA");
+-   ("/xe0/xae/xb1", "TAMIL LETTER RRA");
+-   ("/xe0/xae/xb2", "TAMIL LETTER LA");
+-   ("/xe0/xae/xb3", "TAMIL LETTER LLA");
+-   ("/xe0/xae/xb4", "TAMIL LETTER LLLA");
+-   ("/xe0/xae/xb5", "TAMIL LETTER VA");
+-   ("/xe0/xae/xb6", "TAMIL LETTER SHA");
+-   ("/xe0/xae/xb7", "TAMIL LETTER SSA");
+-   ("/xe0/xae/xb8", "TAMIL LETTER SA");
+-   ("/xe0/xae/xb9", "TAMIL LETTER HA");
+-   ("/xe0/xae/xbe", "TAMIL VOWEL SIGN AA");
+-   ("/xe0/xae/xbf", "TAMIL VOWEL SIGN I");
+-   ("/xe0/xaf/x80", "TAMIL VOWEL SIGN II");
+-   ("/xe0/xaf/x81", "TAMIL VOWEL SIGN U");
+-   ("/xe0/xaf/x82", "TAMIL VOWEL SIGN UU");
+-   ("/xe0/xaf/x86", "TAMIL VOWEL SIGN E");
+-   ("/xe0/xaf/x87", "TAMIL VOWEL SIGN EE");
+-   ("/xe0/xaf/x88", "TAMIL VOWEL SIGN AI");
+-   ("/xe0/xaf/x8a", "TAMIL VOWEL SIGN O");
+-   ("/xe0/xaf/x8b", "TAMIL VOWEL SIGN OO");
+-   ("/xe0/xaf/x8c", "TAMIL VOWEL SIGN AU");
+-   ("/xe0/xaf/x8d", "TAMIL SIGN VIRAMA");
+-   ("/xe0/xaf/x90", "TAMIL OM");
+-   ("/xe0/xaf/x97", "TAMIL AU LENGTH MARK");
+-   ("/xe0/xaf/xa6", "TAMIL DIGIT ZERO");
+-   ("/xe0/xaf/xa7", "TAMIL DIGIT ONE");
+-   ("/xe0/xaf/xa8", "TAMIL DIGIT TWO");
+-   ("/xe0/xaf/xa9", "TAMIL DIGIT THREE");
+-   ("/xe0/xaf/xaa", "TAMIL DIGIT FOUR");
+-   ("/xe0/xaf/xab", "TAMIL DIGIT FIVE");
+-   ("/xe0/xaf/xac", "TAMIL DIGIT SIX");
+-   ("/xe0/xaf/xad", "TAMIL DIGIT SEVEN");
+-   ("/xe0/xaf/xae", "TAMIL DIGIT EIGHT");
+-   ("/xe0/xaf/xaf", "TAMIL DIGIT NINE");
+-   ("/xe0/xaf/xb0", "TAMIL NUMBER TEN");
+-   ("/xe0/xaf/xb1", "TAMIL NUMBER ONE HUNDRED");
+-   ("/xe0/xaf/xb2", "TAMIL NUMBER ONE THOUSAND");
+-   ("/xe0/xaf/xb3", "TAMIL DAY SIGN");
+-   ("/xe0/xaf/xb4", "TAMIL MONTH SIGN");
+-   ("/xe0/xaf/xb5", "TAMIL YEAR SIGN");
+-   ("/xe0/xaf/xb6", "TAMIL DEBIT SIGN");
+-   ("/xe0/xaf/xb7", "TAMIL CREDIT SIGN");
+-   ("/xe0/xaf/xb8", "TAMIL AS ABOVE SIGN");
+-   ("/xe0/xaf/xb9", "TAMIL RUPEE SIGN");
+-   ("/xe0/xaf/xba", "TAMIL NUMBER SIGN");
+-   ("/xe0/xb0/x81", "TELUGU SIGN CANDRABINDU");
+-   ("/xe0/xb0/x82", "TELUGU SIGN ANUSVARA");
+-   ("/xe0/xb0/x83", "TELUGU SIGN VISARGA");
+-   ("/xe0/xb0/x85", "TELUGU LETTER A");
+-   ("/xe0/xb0/x86", "TELUGU LETTER AA");
+-   ("/xe0/xb0/x87", "TELUGU LETTER I");
+-   ("/xe0/xb0/x88", "TELUGU LETTER II");
+-   ("/xe0/xb0/x89", "TELUGU LETTER U");
+-   ("/xe0/xb0/x8a", "TELUGU LETTER UU");
+-   ("/xe0/xb0/x8b", "TELUGU LETTER VOCALIC R");
+-   ("/xe0/xb0/x8c", "TELUGU LETTER VOCALIC L");
+-   ("/xe0/xb0/x8e", "TELUGU LETTER E");
+-   ("/xe0/xb0/x8f", "TELUGU LETTER EE");
+-   ("/xe0/xb0/x90", "TELUGU LETTER AI");
+-   ("/xe0/xb0/x92", "TELUGU LETTER O");
+-   ("/xe0/xb0/x93", "TELUGU LETTER OO");
+-   ("/xe0/xb0/x94", "TELUGU LETTER AU");
+-   ("/xe0/xb0/x95", "TELUGU LETTER KA");
+-   ("/xe0/xb0/x96", "TELUGU LETTER KHA");
+-   ("/xe0/xb0/x97", "TELUGU LETTER GA");
+-   ("/xe0/xb0/x98", "TELUGU LETTER GHA");
+-   ("/xe0/xb0/x99", "TELUGU LETTER NGA");
+-   ("/xe0/xb0/x9a", "TELUGU LETTER CA");
+-   ("/xe0/xb0/x9b", "TELUGU LETTER CHA");
+-   ("/xe0/xb0/x9c", "TELUGU LETTER JA");
+-   ("/xe0/xb0/x9d", "TELUGU LETTER JHA");
+-   ("/xe0/xb0/x9e", "TELUGU LETTER NYA");
+-   ("/xe0/xb0/x9f", "TELUGU LETTER TTA");
+-   ("/xe0/xb0/xa0", "TELUGU LETTER TTHA");
+-   ("/xe0/xb0/xa1", "TELUGU LETTER DDA");
+-   ("/xe0/xb0/xa2", "TELUGU LETTER DDHA");
+-   ("/xe0/xb0/xa3", "TELUGU LETTER NNA");
+-   ("/xe0/xb0/xa4", "TELUGU LETTER TA");
+-   ("/xe0/xb0/xa5", "TELUGU LETTER THA");
+-   ("/xe0/xb0/xa6", "TELUGU LETTER DA");
+-   ("/xe0/xb0/xa7", "TELUGU LETTER DHA");
+-   ("/xe0/xb0/xa8", "TELUGU LETTER NA");
+-   ("/xe0/xb0/xaa", "TELUGU LETTER PA");
+-   ("/xe0/xb0/xab", "TELUGU LETTER PHA");
+-   ("/xe0/xb0/xac", "TELUGU LETTER BA");
+-   ("/xe0/xb0/xad", "TELUGU LETTER BHA");
+-   ("/xe0/xb0/xae", "TELUGU LETTER MA");
+-   ("/xe0/xb0/xaf", "TELUGU LETTER YA");
+-   ("/xe0/xb0/xb0", "TELUGU LETTER RA");
+-   ("/xe0/xb0/xb1", "TELUGU LETTER RRA");
+-   ("/xe0/xb0/xb2", "TELUGU LETTER LA");
+-   ("/xe0/xb0/xb3", "TELUGU LETTER LLA");
+-   ("/xe0/xb0/xb5", "TELUGU LETTER VA");
+-   ("/xe0/xb0/xb6", "TELUGU LETTER SHA");
+-   ("/xe0/xb0/xb7", "TELUGU LETTER SSA");
+-   ("/xe0/xb0/xb8", "TELUGU LETTER SA");
+-   ("/xe0/xb0/xb9", "TELUGU LETTER HA");
+-   ("/xe0/xb0/xbd", "TELUGU SIGN AVAGRAHA");
+-   ("/xe0/xb0/xbe", "TELUGU VOWEL SIGN AA");
+-   ("/xe0/xb0/xbf", "TELUGU VOWEL SIGN I");
+-   ("/xe0/xb1/x80", "TELUGU VOWEL SIGN II");
+-   ("/xe0/xb1/x81", "TELUGU VOWEL SIGN U");
+-   ("/xe0/xb1/x82", "TELUGU VOWEL SIGN UU");
+-   ("/xe0/xb1/x83", "TELUGU VOWEL SIGN VOCALIC R");
+-   ("/xe0/xb1/x84", "TELUGU VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xb1/x86", "TELUGU VOWEL SIGN E");
+-   ("/xe0/xb1/x87", "TELUGU VOWEL SIGN EE");
+-   ("/xe0/xb1/x88", "TELUGU VOWEL SIGN AI");
+-   ("/xe0/xb1/x8a", "TELUGU VOWEL SIGN O");
+-   ("/xe0/xb1/x8b", "TELUGU VOWEL SIGN OO");
+-   ("/xe0/xb1/x8c", "TELUGU VOWEL SIGN AU");
+-   ("/xe0/xb1/x8d", "TELUGU SIGN VIRAMA");
+-   ("/xe0/xb1/x95", "TELUGU LENGTH MARK");
+-   ("/xe0/xb1/x96", "TELUGU AI LENGTH MARK");
+-   ("/xe0/xb1/x98", "TELUGU LETTER TSA");
+-   ("/xe0/xb1/x99", "TELUGU LETTER DZA");
+-   ("/xe0/xb1/xa0", "TELUGU LETTER VOCALIC RR");
+-   ("/xe0/xb1/xa1", "TELUGU LETTER VOCALIC LL");
+-   ("/xe0/xb1/xa2", "TELUGU VOWEL SIGN VOCALIC L");
+-   ("/xe0/xb1/xa3", "TELUGU VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xb1/xa6", "TELUGU DIGIT ZERO");
+-   ("/xe0/xb1/xa7", "TELUGU DIGIT ONE");
+-   ("/xe0/xb1/xa8", "TELUGU DIGIT TWO");
+-   ("/xe0/xb1/xa9", "TELUGU DIGIT THREE");
+-   ("/xe0/xb1/xaa", "TELUGU DIGIT FOUR");
+-   ("/xe0/xb1/xab", "TELUGU DIGIT FIVE");
+-   ("/xe0/xb1/xac", "TELUGU DIGIT SIX");
+-   ("/xe0/xb1/xad", "TELUGU DIGIT SEVEN");
+-   ("/xe0/xb1/xae", "TELUGU DIGIT EIGHT");
+-   ("/xe0/xb1/xaf", "TELUGU DIGIT NINE");
+-   ("/xe0/xb1/xb8", "TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR");
+-   ("/xe0/xb1/xb9", "TELUGU FRACTION DIGIT ONE FOR ODD POWERS OF FOUR");
+-   ("/xe0/xb1/xba", "TELUGU FRACTION DIGIT TWO FOR ODD POWERS OF FOUR");
+-   ("/xe0/xb1/xbb", "TELUGU FRACTION DIGIT THREE FOR ODD POWERS OF FOUR");
+-   ("/xe0/xb1/xbc", "TELUGU FRACTION DIGIT ONE FOR EVEN POWERS OF FOUR");
+-   ("/xe0/xb1/xbd", "TELUGU FRACTION DIGIT TWO FOR EVEN POWERS OF FOUR");
+-   ("/xe0/xb1/xbe", "TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR");
+-   ("/xe0/xb1/xbf", "TELUGU SIGN TUUMU");
+-   ("/xe0/xb2/x82", "KANNADA SIGN ANUSVARA");
+-   ("/xe0/xb2/x83", "KANNADA SIGN VISARGA");
+-   ("/xe0/xb2/x85", "KANNADA LETTER A");
+-   ("/xe0/xb2/x86", "KANNADA LETTER AA");
+-   ("/xe0/xb2/x87", "KANNADA LETTER I");
+-   ("/xe0/xb2/x88", "KANNADA LETTER II");
+-   ("/xe0/xb2/x89", "KANNADA LETTER U");
+-   ("/xe0/xb2/x8a", "KANNADA LETTER UU");
+-   ("/xe0/xb2/x8b", "KANNADA LETTER VOCALIC R");
+-   ("/xe0/xb2/x8c", "KANNADA LETTER VOCALIC L");
+-   ("/xe0/xb2/x8e", "KANNADA LETTER E");
+-   ("/xe0/xb2/x8f", "KANNADA LETTER EE");
+-   ("/xe0/xb2/x90", "KANNADA LETTER AI");
+-   ("/xe0/xb2/x92", "KANNADA LETTER O");
+-   ("/xe0/xb2/x93", "KANNADA LETTER OO");
+-   ("/xe0/xb2/x94", "KANNADA LETTER AU");
+-   ("/xe0/xb2/x95", "KANNADA LETTER KA");
+-   ("/xe0/xb2/x96", "KANNADA LETTER KHA");
+-   ("/xe0/xb2/x97", "KANNADA LETTER GA");
+-   ("/xe0/xb2/x98", "KANNADA LETTER GHA");
+-   ("/xe0/xb2/x99", "KANNADA LETTER NGA");
+-   ("/xe0/xb2/x9a", "KANNADA LETTER CA");
+-   ("/xe0/xb2/x9b", "KANNADA LETTER CHA");
+-   ("/xe0/xb2/x9c", "KANNADA LETTER JA");
+-   ("/xe0/xb2/x9d", "KANNADA LETTER JHA");
+-   ("/xe0/xb2/x9e", "KANNADA LETTER NYA");
+-   ("/xe0/xb2/x9f", "KANNADA LETTER TTA");
+-   ("/xe0/xb2/xa0", "KANNADA LETTER TTHA");
+-   ("/xe0/xb2/xa1", "KANNADA LETTER DDA");
+-   ("/xe0/xb2/xa2", "KANNADA LETTER DDHA");
+-   ("/xe0/xb2/xa3", "KANNADA LETTER NNA");
+-   ("/xe0/xb2/xa4", "KANNADA LETTER TA");
+-   ("/xe0/xb2/xa5", "KANNADA LETTER THA");
+-   ("/xe0/xb2/xa6", "KANNADA LETTER DA");
+-   ("/xe0/xb2/xa7", "KANNADA LETTER DHA");
+-   ("/xe0/xb2/xa8", "KANNADA LETTER NA");
+-   ("/xe0/xb2/xaa", "KANNADA LETTER PA");
+-   ("/xe0/xb2/xab", "KANNADA LETTER PHA");
+-   ("/xe0/xb2/xac", "KANNADA LETTER BA");
+-   ("/xe0/xb2/xad", "KANNADA LETTER BHA");
+-   ("/xe0/xb2/xae", "KANNADA LETTER MA");
+-   ("/xe0/xb2/xaf", "KANNADA LETTER YA");
+-   ("/xe0/xb2/xb0", "KANNADA LETTER RA");
+-   ("/xe0/xb2/xb1", "KANNADA LETTER RRA");
+-   ("/xe0/xb2/xb2", "KANNADA LETTER LA");
+-   ("/xe0/xb2/xb3", "KANNADA LETTER LLA");
+-   ("/xe0/xb2/xb5", "KANNADA LETTER VA");
+-   ("/xe0/xb2/xb6", "KANNADA LETTER SHA");
+-   ("/xe0/xb2/xb7", "KANNADA LETTER SSA");
+-   ("/xe0/xb2/xb8", "KANNADA LETTER SA");
+-   ("/xe0/xb2/xb9", "KANNADA LETTER HA");
+-   ("/xe0/xb2/xbc", "KANNADA SIGN NUKTA");
+-   ("/xe0/xb2/xbd", "KANNADA SIGN AVAGRAHA");
+-   ("/xe0/xb2/xbe", "KANNADA VOWEL SIGN AA");
+-   ("/xe0/xb2/xbf", "KANNADA VOWEL SIGN I");
+-   ("/xe0/xb3/x80", "KANNADA VOWEL SIGN II");
+-   ("/xe0/xb3/x81", "KANNADA VOWEL SIGN U");
+-   ("/xe0/xb3/x82", "KANNADA VOWEL SIGN UU");
+-   ("/xe0/xb3/x83", "KANNADA VOWEL SIGN VOCALIC R");
+-   ("/xe0/xb3/x84", "KANNADA VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xb3/x86", "KANNADA VOWEL SIGN E");
+-   ("/xe0/xb3/x87", "KANNADA VOWEL SIGN EE");
+-   ("/xe0/xb3/x88", "KANNADA VOWEL SIGN AI");
+-   ("/xe0/xb3/x8a", "KANNADA VOWEL SIGN O");
+-   ("/xe0/xb3/x8b", "KANNADA VOWEL SIGN OO");
+-   ("/xe0/xb3/x8c", "KANNADA VOWEL SIGN AU");
+-   ("/xe0/xb3/x8d", "KANNADA SIGN VIRAMA");
+-   ("/xe0/xb3/x95", "KANNADA LENGTH MARK");
+-   ("/xe0/xb3/x96", "KANNADA AI LENGTH MARK");
+-   ("/xe0/xb3/x9e", "KANNADA LETTER FA");
+-   ("/xe0/xb3/xa0", "KANNADA LETTER VOCALIC RR");
+-   ("/xe0/xb3/xa1", "KANNADA LETTER VOCALIC LL");
+-   ("/xe0/xb3/xa2", "KANNADA VOWEL SIGN VOCALIC L");
+-   ("/xe0/xb3/xa3", "KANNADA VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xb3/xa6", "KANNADA DIGIT ZERO");
+-   ("/xe0/xb3/xa7", "KANNADA DIGIT ONE");
+-   ("/xe0/xb3/xa8", "KANNADA DIGIT TWO");
+-   ("/xe0/xb3/xa9", "KANNADA DIGIT THREE");
+-   ("/xe0/xb3/xaa", "KANNADA DIGIT FOUR");
+-   ("/xe0/xb3/xab", "KANNADA DIGIT FIVE");
+-   ("/xe0/xb3/xac", "KANNADA DIGIT SIX");
+-   ("/xe0/xb3/xad", "KANNADA DIGIT SEVEN");
+-   ("/xe0/xb3/xae", "KANNADA DIGIT EIGHT");
+-   ("/xe0/xb3/xaf", "KANNADA DIGIT NINE");
+-   ("/xe0/xb3/xb1", "KANNADA SIGN JIHVAMULIYA");
+-   ("/xe0/xb3/xb2", "KANNADA SIGN UPADHMANIYA");
+-   ("/xe0/xb4/x82", "MALAYALAM SIGN ANUSVARA");
+-   ("/xe0/xb4/x83", "MALAYALAM SIGN VISARGA");
+-   ("/xe0/xb4/x85", "MALAYALAM LETTER A");
+-   ("/xe0/xb4/x86", "MALAYALAM LETTER AA");
+-   ("/xe0/xb4/x87", "MALAYALAM LETTER I");
+-   ("/xe0/xb4/x88", "MALAYALAM LETTER II");
+-   ("/xe0/xb4/x89", "MALAYALAM LETTER U");
+-   ("/xe0/xb4/x8a", "MALAYALAM LETTER UU");
+-   ("/xe0/xb4/x8b", "MALAYALAM LETTER VOCALIC R");
+-   ("/xe0/xb4/x8c", "MALAYALAM LETTER VOCALIC L");
+-   ("/xe0/xb4/x8e", "MALAYALAM LETTER E");
+-   ("/xe0/xb4/x8f", "MALAYALAM LETTER EE");
+-   ("/xe0/xb4/x90", "MALAYALAM LETTER AI");
+-   ("/xe0/xb4/x92", "MALAYALAM LETTER O");
+-   ("/xe0/xb4/x93", "MALAYALAM LETTER OO");
+-   ("/xe0/xb4/x94", "MALAYALAM LETTER AU");
+-   ("/xe0/xb4/x95", "MALAYALAM LETTER KA");
+-   ("/xe0/xb4/x96", "MALAYALAM LETTER KHA");
+-   ("/xe0/xb4/x97", "MALAYALAM LETTER GA");
+-   ("/xe0/xb4/x98", "MALAYALAM LETTER GHA");
+-   ("/xe0/xb4/x99", "MALAYALAM LETTER NGA");
+-   ("/xe0/xb4/x9a", "MALAYALAM LETTER CA");
+-   ("/xe0/xb4/x9b", "MALAYALAM LETTER CHA");
+-   ("/xe0/xb4/x9c", "MALAYALAM LETTER JA");
+-   ("/xe0/xb4/x9d", "MALAYALAM LETTER JHA");
+-   ("/xe0/xb4/x9e", "MALAYALAM LETTER NYA");
+-   ("/xe0/xb4/x9f", "MALAYALAM LETTER TTA");
+-   ("/xe0/xb4/xa0", "MALAYALAM LETTER TTHA");
+-   ("/xe0/xb4/xa1", "MALAYALAM LETTER DDA");
+-   ("/xe0/xb4/xa2", "MALAYALAM LETTER DDHA");
+-   ("/xe0/xb4/xa3", "MALAYALAM LETTER NNA");
+-   ("/xe0/xb4/xa4", "MALAYALAM LETTER TA");
+-   ("/xe0/xb4/xa5", "MALAYALAM LETTER THA");
+-   ("/xe0/xb4/xa6", "MALAYALAM LETTER DA");
+-   ("/xe0/xb4/xa7", "MALAYALAM LETTER DHA");
+-   ("/xe0/xb4/xa8", "MALAYALAM LETTER NA");
+-   ("/xe0/xb4/xaa", "MALAYALAM LETTER PA");
+-   ("/xe0/xb4/xab", "MALAYALAM LETTER PHA");
+-   ("/xe0/xb4/xac", "MALAYALAM LETTER BA");
+-   ("/xe0/xb4/xad", "MALAYALAM LETTER BHA");
+-   ("/xe0/xb4/xae", "MALAYALAM LETTER MA");
+-   ("/xe0/xb4/xaf", "MALAYALAM LETTER YA");
+-   ("/xe0/xb4/xb0", "MALAYALAM LETTER RA");
+-   ("/xe0/xb4/xb1", "MALAYALAM LETTER RRA");
+-   ("/xe0/xb4/xb2", "MALAYALAM LETTER LA");
+-   ("/xe0/xb4/xb3", "MALAYALAM LETTER LLA");
+-   ("/xe0/xb4/xb4", "MALAYALAM LETTER LLLA");
+-   ("/xe0/xb4/xb5", "MALAYALAM LETTER VA");
+-   ("/xe0/xb4/xb6", "MALAYALAM LETTER SHA");
+-   ("/xe0/xb4/xb7", "MALAYALAM LETTER SSA");
+-   ("/xe0/xb4/xb8", "MALAYALAM LETTER SA");
+-   ("/xe0/xb4/xb9", "MALAYALAM LETTER HA");
+-   ("/xe0/xb4/xbd", "MALAYALAM SIGN AVAGRAHA");
+-   ("/xe0/xb4/xbe", "MALAYALAM VOWEL SIGN AA");
+-   ("/xe0/xb4/xbf", "MALAYALAM VOWEL SIGN I");
+-   ("/xe0/xb5/x80", "MALAYALAM VOWEL SIGN II");
+-   ("/xe0/xb5/x81", "MALAYALAM VOWEL SIGN U");
+-   ("/xe0/xb5/x82", "MALAYALAM VOWEL SIGN UU");
+-   ("/xe0/xb5/x83", "MALAYALAM VOWEL SIGN VOCALIC R");
+-   ("/xe0/xb5/x84", "MALAYALAM VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xb5/x86", "MALAYALAM VOWEL SIGN E");
+-   ("/xe0/xb5/x87", "MALAYALAM VOWEL SIGN EE");
+-   ("/xe0/xb5/x88", "MALAYALAM VOWEL SIGN AI");
+-   ("/xe0/xb5/x8a", "MALAYALAM VOWEL SIGN O");
+-   ("/xe0/xb5/x8b", "MALAYALAM VOWEL SIGN OO");
+-   ("/xe0/xb5/x8c", "MALAYALAM VOWEL SIGN AU");
+-   ("/xe0/xb5/x8d", "MALAYALAM SIGN VIRAMA");
+-   ("/xe0/xb5/x97", "MALAYALAM AU LENGTH MARK");
+-   ("/xe0/xb5/xa0", "MALAYALAM LETTER VOCALIC RR");
+-   ("/xe0/xb5/xa1", "MALAYALAM LETTER VOCALIC LL");
+-   ("/xe0/xb5/xa2", "MALAYALAM VOWEL SIGN VOCALIC L");
+-   ("/xe0/xb5/xa3", "MALAYALAM VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xb5/xa6", "MALAYALAM DIGIT ZERO");
+-   ("/xe0/xb5/xa7", "MALAYALAM DIGIT ONE");
+-   ("/xe0/xb5/xa8", "MALAYALAM DIGIT TWO");
+-   ("/xe0/xb5/xa9", "MALAYALAM DIGIT THREE");
+-   ("/xe0/xb5/xaa", "MALAYALAM DIGIT FOUR");
+-   ("/xe0/xb5/xab", "MALAYALAM DIGIT FIVE");
+-   ("/xe0/xb5/xac", "MALAYALAM DIGIT SIX");
+-   ("/xe0/xb5/xad", "MALAYALAM DIGIT SEVEN");
+-   ("/xe0/xb5/xae", "MALAYALAM DIGIT EIGHT");
+-   ("/xe0/xb5/xaf", "MALAYALAM DIGIT NINE");
+-   ("/xe0/xb5/xb0", "MALAYALAM NUMBER TEN");
+-   ("/xe0/xb5/xb1", "MALAYALAM NUMBER ONE HUNDRED");
+-   ("/xe0/xb5/xb2", "MALAYALAM NUMBER ONE THOUSAND");
+-   ("/xe0/xb5/xb3", "MALAYALAM FRACTION ONE QUARTER");
+-   ("/xe0/xb5/xb4", "MALAYALAM FRACTION ONE HALF");
+-   ("/xe0/xb5/xb5", "MALAYALAM FRACTION THREE QUARTERS");
+-   ("/xe0/xb5/xb9", "MALAYALAM DATE MARK");
+-   ("/xe0/xb5/xba", "MALAYALAM LETTER CHILLU NN");
+-   ("/xe0/xb5/xbb", "MALAYALAM LETTER CHILLU N");
+-   ("/xe0/xb5/xbc", "MALAYALAM LETTER CHILLU RR");
+-   ("/xe0/xb5/xbd", "MALAYALAM LETTER CHILLU L");
+-   ("/xe0/xb5/xbe", "MALAYALAM LETTER CHILLU LL");
+-   ("/xe0/xb5/xbf", "MALAYALAM LETTER CHILLU K");
+-   ("/xe0/xb6/x82", "SINHALA SIGN ANUSVARAYA");
+-   ("/xe0/xb6/x83", "SINHALA SIGN VISARGAYA");
+-   ("/xe0/xb6/x85", "SINHALA LETTER AYANNA");
+-   ("/xe0/xb6/x86", "SINHALA LETTER AAYANNA");
+-   ("/xe0/xb6/x87", "SINHALA LETTER AEYANNA");
+-   ("/xe0/xb6/x88", "SINHALA LETTER AEEYANNA");
+-   ("/xe0/xb6/x89", "SINHALA LETTER IYANNA");
+-   ("/xe0/xb6/x8a", "SINHALA LETTER IIYANNA");
+-   ("/xe0/xb6/x8b", "SINHALA LETTER UYANNA");
+-   ("/xe0/xb6/x8c", "SINHALA LETTER UUYANNA");
+-   ("/xe0/xb6/x8d", "SINHALA LETTER IRUYANNA");
+-   ("/xe0/xb6/x8e", "SINHALA LETTER IRUUYANNA");
+-   ("/xe0/xb6/x8f", "SINHALA LETTER ILUYANNA");
+-   ("/xe0/xb6/x90", "SINHALA LETTER ILUUYANNA");
+-   ("/xe0/xb6/x91", "SINHALA LETTER EYANNA");
+-   ("/xe0/xb6/x92", "SINHALA LETTER EEYANNA");
+-   ("/xe0/xb6/x93", "SINHALA LETTER AIYANNA");
+-   ("/xe0/xb6/x94", "SINHALA LETTER OYANNA");
+-   ("/xe0/xb6/x95", "SINHALA LETTER OOYANNA");
+-   ("/xe0/xb6/x96", "SINHALA LETTER AUYANNA");
+-   ("/xe0/xb6/x9a", "SINHALA LETTER ALPAPRAANA KAYANNA");
+-   ("/xe0/xb6/x9b", "SINHALA LETTER MAHAAPRAANA KAYANNA");
+-   ("/xe0/xb6/x9c", "SINHALA LETTER ALPAPRAANA GAYANNA");
+-   ("/xe0/xb6/x9d", "SINHALA LETTER MAHAAPRAANA GAYANNA");
+-   ("/xe0/xb6/x9e", "SINHALA LETTER KANTAJA NAASIKYAYA");
+-   ("/xe0/xb6/x9f", "SINHALA LETTER SANYAKA GAYANNA");
+-   ("/xe0/xb6/xa0", "SINHALA LETTER ALPAPRAANA CAYANNA");
+-   ("/xe0/xb6/xa1", "SINHALA LETTER MAHAAPRAANA CAYANNA");
+-   ("/xe0/xb6/xa2", "SINHALA LETTER ALPAPRAANA JAYANNA");
+-   ("/xe0/xb6/xa3", "SINHALA LETTER MAHAAPRAANA JAYANNA");
+-   ("/xe0/xb6/xa4", "SINHALA LETTER TAALUJA NAASIKYAYA");
+-   ("/xe0/xb6/xa5", "SINHALA LETTER TAALUJA SANYOOGA NAAKSIKYAYA");
+-   ("/xe0/xb6/xa6", "SINHALA LETTER SANYAKA JAYANNA");
+-   ("/xe0/xb6/xa7", "SINHALA LETTER ALPAPRAANA TTAYANNA");
+-   ("/xe0/xb6/xa8", "SINHALA LETTER MAHAAPRAANA TTAYANNA");
+-   ("/xe0/xb6/xa9", "SINHALA LETTER ALPAPRAANA DDAYANNA");
+-   ("/xe0/xb6/xaa", "SINHALA LETTER MAHAAPRAANA DDAYANNA");
+-   ("/xe0/xb6/xab", "SINHALA LETTER MUURDHAJA NAYANNA");
+-   ("/xe0/xb6/xac", "SINHALA LETTER SANYAKA DDAYANNA");
+-   ("/xe0/xb6/xad", "SINHALA LETTER ALPAPRAANA TAYANNA");
+-   ("/xe0/xb6/xae", "SINHALA LETTER MAHAAPRAANA TAYANNA");
+-   ("/xe0/xb6/xaf", "SINHALA LETTER ALPAPRAANA DAYANNA");
+-   ("/xe0/xb6/xb0", "SINHALA LETTER MAHAAPRAANA DAYANNA");
+-   ("/xe0/xb6/xb1", "SINHALA LETTER DANTAJA NAYANNA");
+-   ("/xe0/xb6/xb3", "SINHALA LETTER SANYAKA DAYANNA");
+-   ("/xe0/xb6/xb4", "SINHALA LETTER ALPAPRAANA PAYANNA");
+-   ("/xe0/xb6/xb5", "SINHALA LETTER MAHAAPRAANA PAYANNA");
+-   ("/xe0/xb6/xb6", "SINHALA LETTER ALPAPRAANA BAYANNA");
+-   ("/xe0/xb6/xb7", "SINHALA LETTER MAHAAPRAANA BAYANNA");
+-   ("/xe0/xb6/xb8", "SINHALA LETTER MAYANNA");
+-   ("/xe0/xb6/xb9", "SINHALA LETTER AMBA BAYANNA");
+-   ("/xe0/xb6/xba", "SINHALA LETTER YAYANNA");
+-   ("/xe0/xb6/xbb", "SINHALA LETTER RAYANNA");
+-   ("/xe0/xb6/xbd", "SINHALA LETTER DANTAJA LAYANNA");
+-   ("/xe0/xb7/x80", "SINHALA LETTER VAYANNA");
+-   ("/xe0/xb7/x81", "SINHALA LETTER TAALUJA SAYANNA");
+-   ("/xe0/xb7/x82", "SINHALA LETTER MUURDHAJA SAYANNA");
+-   ("/xe0/xb7/x83", "SINHALA LETTER DANTAJA SAYANNA");
+-   ("/xe0/xb7/x84", "SINHALA LETTER HAYANNA");
+-   ("/xe0/xb7/x85", "SINHALA LETTER MUURDHAJA LAYANNA");
+-   ("/xe0/xb7/x86", "SINHALA LETTER FAYANNA");
+-   ("/xe0/xb7/x8a", "SINHALA SIGN AL-LAKUNA");
+-   ("/xe0/xb7/x8f", "SINHALA VOWEL SIGN AELA-PILLA");
+-   ("/xe0/xb7/x90", "SINHALA VOWEL SIGN KETTI AEDA-PILLA");
+-   ("/xe0/xb7/x91", "SINHALA VOWEL SIGN DIGA AEDA-PILLA");
+-   ("/xe0/xb7/x92", "SINHALA VOWEL SIGN KETTI IS-PILLA");
+-   ("/xe0/xb7/x93", "SINHALA VOWEL SIGN DIGA IS-PILLA");
+-   ("/xe0/xb7/x94", "SINHALA VOWEL SIGN KETTI PAA-PILLA");
+-   ("/xe0/xb7/x96", "SINHALA VOWEL SIGN DIGA PAA-PILLA");
+-   ("/xe0/xb7/x98", "SINHALA VOWEL SIGN GAETTA-PILLA");
+-   ("/xe0/xb7/x99", "SINHALA VOWEL SIGN KOMBUVA");
+-   ("/xe0/xb7/x9a", "SINHALA VOWEL SIGN DIGA KOMBUVA");
+-   ("/xe0/xb7/x9b", "SINHALA VOWEL SIGN KOMBU DEKA");
+-   ("/xe0/xb7/x9c", "SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA");
+-   ("/xe0/xb7/x9d", "SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA");
+-   ("/xe0/xb7/x9e", "SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA");
+-   ("/xe0/xb7/x9f", "SINHALA VOWEL SIGN GAYANUKITTA");
+-   ("/xe0/xb7/xb2", "SINHALA VOWEL SIGN DIGA GAETTA-PILLA");
+-   ("/xe0/xb7/xb3", "SINHALA VOWEL SIGN DIGA GAYANUKITTA");
+-   ("/xe0/xb7/xb4", "SINHALA PUNCTUATION KUNDDALIYA");
+-   ("/xe0/xb8/x81", "THAI CHARACTER KO KAI");
+-   ("/xe0/xb8/x82", "THAI CHARACTER KHO KHAI");
+-   ("/xe0/xb8/x83", "THAI CHARACTER KHO KHUAT");
+-   ("/xe0/xb8/x84", "THAI CHARACTER KHO KHWAI");
+-   ("/xe0/xb8/x85", "THAI CHARACTER KHO KHON");
+-   ("/xe0/xb8/x86", "THAI CHARACTER KHO RAKHANG");
+-   ("/xe0/xb8/x87", "THAI CHARACTER NGO NGU");
+-   ("/xe0/xb8/x88", "THAI CHARACTER CHO CHAN");
+-   ("/xe0/xb8/x89", "THAI CHARACTER CHO CHING");
+-   ("/xe0/xb8/x8a", "THAI CHARACTER CHO CHANG");
+-   ("/xe0/xb8/x8b", "THAI CHARACTER SO SO");
+-   ("/xe0/xb8/x8c", "THAI CHARACTER CHO CHOE");
+-   ("/xe0/xb8/x8d", "THAI CHARACTER YO YING");
+-   ("/xe0/xb8/x8e", "THAI CHARACTER DO CHADA");
+-   ("/xe0/xb8/x8f", "THAI CHARACTER TO PATAK");
+-   ("/xe0/xb8/x90", "THAI CHARACTER THO THAN");
+-   ("/xe0/xb8/x91", "THAI CHARACTER THO NANGMONTHO");
+-   ("/xe0/xb8/x92", "THAI CHARACTER THO PHUTHAO");
+-   ("/xe0/xb8/x93", "THAI CHARACTER NO NEN");
+-   ("/xe0/xb8/x94", "THAI CHARACTER DO DEK");
+-   ("/xe0/xb8/x95", "THAI CHARACTER TO TAO");
+-   ("/xe0/xb8/x96", "THAI CHARACTER THO THUNG");
+-   ("/xe0/xb8/x97", "THAI CHARACTER THO THAHAN");
+-   ("/xe0/xb8/x98", "THAI CHARACTER THO THONG");
+-   ("/xe0/xb8/x99", "THAI CHARACTER NO NU");
+-   ("/xe0/xb8/x9a", "THAI CHARACTER BO BAIMAI");
+-   ("/xe0/xb8/x9b", "THAI CHARACTER PO PLA");
+-   ("/xe0/xb8/x9c", "THAI CHARACTER PHO PHUNG");
+-   ("/xe0/xb8/x9d", "THAI CHARACTER FO FA");
+-   ("/xe0/xb8/x9e", "THAI CHARACTER PHO PHAN");
+-   ("/xe0/xb8/x9f", "THAI CHARACTER FO FAN");
+-   ("/xe0/xb8/xa0", "THAI CHARACTER PHO SAMPHAO");
+-   ("/xe0/xb8/xa1", "THAI CHARACTER MO MA");
+-   ("/xe0/xb8/xa2", "THAI CHARACTER YO YAK");
+-   ("/xe0/xb8/xa3", "THAI CHARACTER RO RUA");
+-   ("/xe0/xb8/xa4", "THAI CHARACTER RU");
+-   ("/xe0/xb8/xa5", "THAI CHARACTER LO LING");
+-   ("/xe0/xb8/xa6", "THAI CHARACTER LU");
+-   ("/xe0/xb8/xa7", "THAI CHARACTER WO WAEN");
+-   ("/xe0/xb8/xa8", "THAI CHARACTER SO SALA");
+-   ("/xe0/xb8/xa9", "THAI CHARACTER SO RUSI");
+-   ("/xe0/xb8/xaa", "THAI CHARACTER SO SUA");
+-   ("/xe0/xb8/xab", "THAI CHARACTER HO HIP");
+-   ("/xe0/xb8/xac", "THAI CHARACTER LO CHULA");
+-   ("/xe0/xb8/xad", "THAI CHARACTER O ANG");
+-   ("/xe0/xb8/xae", "THAI CHARACTER HO NOKHUK");
+-   ("/xe0/xb8/xaf", "THAI CHARACTER PAIYANNOI");
+-   ("/xe0/xb8/xb0", "THAI CHARACTER SARA A");
+-   ("/xe0/xb8/xb1", "THAI CHARACTER MAI HAN-AKAT");
+-   ("/xe0/xb8/xb2", "THAI CHARACTER SARA AA");
+-   ("/xe0/xb8/xb3", "THAI CHARACTER SARA AM");
+-   ("/xe0/xb8/xb4", "THAI CHARACTER SARA I");
+-   ("/xe0/xb8/xb5", "THAI CHARACTER SARA II");
+-   ("/xe0/xb8/xb6", "THAI CHARACTER SARA UE");
+-   ("/xe0/xb8/xb7", "THAI CHARACTER SARA UEE");
+-   ("/xe0/xb8/xb8", "THAI CHARACTER SARA U");
+-   ("/xe0/xb8/xb9", "THAI CHARACTER SARA UU");
+-   ("/xe0/xb8/xba", "THAI CHARACTER PHINTHU");
+-   ("/xe0/xb8/xbf", "THAI CURRENCY SYMBOL BAHT");
+-   ("/xe0/xb9/x80", "THAI CHARACTER SARA E");
+-   ("/xe0/xb9/x81", "THAI CHARACTER SARA AE");
+-   ("/xe0/xb9/x82", "THAI CHARACTER SARA O");
+-   ("/xe0/xb9/x83", "THAI CHARACTER SARA AI MAIMUAN");
+-   ("/xe0/xb9/x84", "THAI CHARACTER SARA AI MAIMALAI");
+-   ("/xe0/xb9/x85", "THAI CHARACTER LAKKHANGYAO");
+-   ("/xe0/xb9/x86", "THAI CHARACTER MAIYAMOK");
+-   ("/xe0/xb9/x87", "THAI CHARACTER MAITAIKHU");
+-   ("/xe0/xb9/x88", "THAI CHARACTER MAI EK");
+-   ("/xe0/xb9/x89", "THAI CHARACTER MAI THO");
+-   ("/xe0/xb9/x8a", "THAI CHARACTER MAI TRI");
+-   ("/xe0/xb9/x8b", "THAI CHARACTER MAI CHATTAWA");
+-   ("/xe0/xb9/x8c", "THAI CHARACTER THANTHAKHAT");
+-   ("/xe0/xb9/x8d", "THAI CHARACTER NIKHAHIT");
+-   ("/xe0/xb9/x8e", "THAI CHARACTER YAMAKKAN");
+-   ("/xe0/xb9/x8f", "THAI CHARACTER FONGMAN");
+-   ("/xe0/xb9/x90", "THAI DIGIT ZERO");
+-   ("/xe0/xb9/x91", "THAI DIGIT ONE");
+-   ("/xe0/xb9/x92", "THAI DIGIT TWO");
+-   ("/xe0/xb9/x93", "THAI DIGIT THREE");
+-   ("/xe0/xb9/x94", "THAI DIGIT FOUR");
+-   ("/xe0/xb9/x95", "THAI DIGIT FIVE");
+-   ("/xe0/xb9/x96", "THAI DIGIT SIX");
+-   ("/xe0/xb9/x97", "THAI DIGIT SEVEN");
+-   ("/xe0/xb9/x98", "THAI DIGIT EIGHT");
+-   ("/xe0/xb9/x99", "THAI DIGIT NINE");
+-   ("/xe0/xb9/x9a", "THAI CHARACTER ANGKHANKHU");
+-   ("/xe0/xb9/x9b", "THAI CHARACTER KHOMUT");
+-   ("/xe0/xba/x81", "LAO LETTER KO");
+-   ("/xe0/xba/x82", "LAO LETTER KHO SUNG");
+-   ("/xe0/xba/x84", "LAO LETTER KHO TAM");
+-   ("/xe0/xba/x87", "LAO LETTER NGO");
+-   ("/xe0/xba/x88", "LAO LETTER CO");
+-   ("/xe0/xba/x8a", "LAO LETTER SO TAM");
+-   ("/xe0/xba/x8d", "LAO LETTER NYO");
+-   ("/xe0/xba/x94", "LAO LETTER DO");
+-   ("/xe0/xba/x95", "LAO LETTER TO");
+-   ("/xe0/xba/x96", "LAO LETTER THO SUNG");
+-   ("/xe0/xba/x97", "LAO LETTER THO TAM");
+-   ("/xe0/xba/x99", "LAO LETTER NO");
+-   ("/xe0/xba/x9a", "LAO LETTER BO");
+-   ("/xe0/xba/x9b", "LAO LETTER PO");
+-   ("/xe0/xba/x9c", "LAO LETTER PHO SUNG");
+-   ("/xe0/xba/x9d", "LAO LETTER FO TAM");
+-   ("/xe0/xba/x9e", "LAO LETTER PHO TAM");
+-   ("/xe0/xba/x9f", "LAO LETTER FO SUNG");
+-   ("/xe0/xba/xa1", "LAO LETTER MO");
+-   ("/xe0/xba/xa2", "LAO LETTER YO");
+-   ("/xe0/xba/xa3", "LAO LETTER LO LING");
+-   ("/xe0/xba/xa5", "LAO LETTER LO LOOT");
+-   ("/xe0/xba/xa7", "LAO LETTER WO");
+-   ("/xe0/xba/xaa", "LAO LETTER SO SUNG");
+-   ("/xe0/xba/xab", "LAO LETTER HO SUNG");
+-   ("/xe0/xba/xad", "LAO LETTER O");
+-   ("/xe0/xba/xae", "LAO LETTER HO TAM");
+-   ("/xe0/xba/xaf", "LAO ELLIPSIS");
+-   ("/xe0/xba/xb0", "LAO VOWEL SIGN A");
+-   ("/xe0/xba/xb1", "LAO VOWEL SIGN MAI KAN");
+-   ("/xe0/xba/xb2", "LAO VOWEL SIGN AA");
+-   ("/xe0/xba/xb3", "LAO VOWEL SIGN AM");
+-   ("/xe0/xba/xb4", "LAO VOWEL SIGN I");
+-   ("/xe0/xba/xb5", "LAO VOWEL SIGN II");
+-   ("/xe0/xba/xb6", "LAO VOWEL SIGN Y");
+-   ("/xe0/xba/xb7", "LAO VOWEL SIGN YY");
+-   ("/xe0/xba/xb8", "LAO VOWEL SIGN U");
+-   ("/xe0/xba/xb9", "LAO VOWEL SIGN UU");
+-   ("/xe0/xba/xbb", "LAO VOWEL SIGN MAI KON");
+-   ("/xe0/xba/xbc", "LAO SEMIVOWEL SIGN LO");
+-   ("/xe0/xba/xbd", "LAO SEMIVOWEL SIGN NYO");
+-   ("/xe0/xbb/x80", "LAO VOWEL SIGN E");
+-   ("/xe0/xbb/x81", "LAO VOWEL SIGN EI");
+-   ("/xe0/xbb/x82", "LAO VOWEL SIGN O");
+-   ("/xe0/xbb/x83", "LAO VOWEL SIGN AY");
+-   ("/xe0/xbb/x84", "LAO VOWEL SIGN AI");
+-   ("/xe0/xbb/x86", "LAO KO LA");
+-   ("/xe0/xbb/x88", "LAO TONE MAI EK");
+-   ("/xe0/xbb/x89", "LAO TONE MAI THO");
+-   ("/xe0/xbb/x8a", "LAO TONE MAI TI");
+-   ("/xe0/xbb/x8b", "LAO TONE MAI CATAWA");
+-   ("/xe0/xbb/x8c", "LAO CANCELLATION MARK");
+-   ("/xe0/xbb/x8d", "LAO NIGGAHITA");
+-   ("/xe0/xbb/x90", "LAO DIGIT ZERO");
+-   ("/xe0/xbb/x91", "LAO DIGIT ONE");
+-   ("/xe0/xbb/x92", "LAO DIGIT TWO");
+-   ("/xe0/xbb/x93", "LAO DIGIT THREE");
+-   ("/xe0/xbb/x94", "LAO DIGIT FOUR");
+-   ("/xe0/xbb/x95", "LAO DIGIT FIVE");
+-   ("/xe0/xbb/x96", "LAO DIGIT SIX");
+-   ("/xe0/xbb/x97", "LAO DIGIT SEVEN");
+-   ("/xe0/xbb/x98", "LAO DIGIT EIGHT");
+-   ("/xe0/xbb/x99", "LAO DIGIT NINE");
+-   ("/xe0/xbb/x9c", "LAO HO NO");
+-   ("/xe0/xbb/x9d", "LAO HO MO");
+-   ("/xe0/xbc/x80", "TIBETAN SYLLABLE OM");
+-   ("/xe0/xbc/x81", "TIBETAN MARK GTER YIG MGO TRUNCATED A");
+-   ("/xe0/xbc/x82", "TIBETAN MARK GTER YIG MGO -UM RNAM BCAD MA");
+-   ("/xe0/xbc/x83", "TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA");
+-   ("/xe0/xbc/x84", "TIBETAN MARK INITIAL YIG MGO MDUN MA");
+-   ("/xe0/xbc/x85", "TIBETAN MARK CLOSING YIG MGO SGAB MA");
+-   ("/xe0/xbc/x86", "TIBETAN MARK CARET YIG MGO PHUR SHAD MA");
+-   ("/xe0/xbc/x87", "TIBETAN MARK YIG MGO TSHEG SHAD MA");
+-   ("/xe0/xbc/x88", "TIBETAN MARK SBRUL SHAD");
+-   ("/xe0/xbc/x89", "TIBETAN MARK BSKUR YIG MGO");
+-   ("/xe0/xbc/x8a", "TIBETAN MARK BKA- SHOG YIG MGO");
+-   ("/xe0/xbc/x8b", "TIBETAN MARK INTERSYLLABIC TSHEG");
+-   ("/xe0/xbc/x8c", "TIBETAN MARK DELIMITER TSHEG BSTAR");
+-   ("/xe0/xbc/x8d", "TIBETAN MARK SHAD");
+-   ("/xe0/xbc/x8e", "TIBETAN MARK NYIS SHAD");
+-   ("/xe0/xbc/x8f", "TIBETAN MARK TSHEG SHAD");
+-   ("/xe0/xbc/x90", "TIBETAN MARK NYIS TSHEG SHAD");
+-   ("/xe0/xbc/x91", "TIBETAN MARK RIN CHEN SPUNGS SHAD");
+-   ("/xe0/xbc/x92", "TIBETAN MARK RGYA GRAM SHAD");
+-   ("/xe0/xbc/x93", "TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN");
+-   ("/xe0/xbc/x94", "TIBETAN MARK GTER TSHEG");
+-   ("/xe0/xbc/x95", "TIBETAN LOGOTYPE SIGN CHAD RTAGS");
+-   ("/xe0/xbc/x96", "TIBETAN LOGOTYPE SIGN LHAG RTAGS");
+-   ("/xe0/xbc/x97", "TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS");
+-   ("/xe0/xbc/x98", "TIBETAN ASTROLOGICAL SIGN -KHYUD PA");
+-   ("/xe0/xbc/x99", "TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS");
+-   ("/xe0/xbc/x9a", "TIBETAN SIGN RDEL DKAR GCIG");
+-   ("/xe0/xbc/x9b", "TIBETAN SIGN RDEL DKAR GNYIS");
+-   ("/xe0/xbc/x9c", "TIBETAN SIGN RDEL DKAR GSUM");
+-   ("/xe0/xbc/x9d", "TIBETAN SIGN RDEL NAG GCIG");
+-   ("/xe0/xbc/x9e", "TIBETAN SIGN RDEL NAG GNYIS");
+-   ("/xe0/xbc/x9f", "TIBETAN SIGN RDEL DKAR RDEL NAG");
+-   ("/xe0/xbc/xa0", "TIBETAN DIGIT ZERO");
+-   ("/xe0/xbc/xa1", "TIBETAN DIGIT ONE");
+-   ("/xe0/xbc/xa2", "TIBETAN DIGIT TWO");
+-   ("/xe0/xbc/xa3", "TIBETAN DIGIT THREE");
+-   ("/xe0/xbc/xa4", "TIBETAN DIGIT FOUR");
+-   ("/xe0/xbc/xa5", "TIBETAN DIGIT FIVE");
+-   ("/xe0/xbc/xa6", "TIBETAN DIGIT SIX");
+-   ("/xe0/xbc/xa7", "TIBETAN DIGIT SEVEN");
+-   ("/xe0/xbc/xa8", "TIBETAN DIGIT EIGHT");
+-   ("/xe0/xbc/xa9", "TIBETAN DIGIT NINE");
+-   ("/xe0/xbc/xaa", "TIBETAN DIGIT HALF ONE");
+-   ("/xe0/xbc/xab", "TIBETAN DIGIT HALF TWO");
+-   ("/xe0/xbc/xac", "TIBETAN DIGIT HALF THREE");
+-   ("/xe0/xbc/xad", "TIBETAN DIGIT HALF FOUR");
+-   ("/xe0/xbc/xae", "TIBETAN DIGIT HALF FIVE");
+-   ("/xe0/xbc/xaf", "TIBETAN DIGIT HALF SIX");
+-   ("/xe0/xbc/xb0", "TIBETAN DIGIT HALF SEVEN");
+-   ("/xe0/xbc/xb1", "TIBETAN DIGIT HALF EIGHT");
+-   ("/xe0/xbc/xb2", "TIBETAN DIGIT HALF NINE");
+-   ("/xe0/xbc/xb3", "TIBETAN DIGIT HALF ZERO");
+-   ("/xe0/xbc/xb4", "TIBETAN MARK BSDUS RTAGS");
+-   ("/xe0/xbc/xb5", "TIBETAN MARK NGAS BZUNG NYI ZLA");
+-   ("/xe0/xbc/xb6", "TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN");
+-   ("/xe0/xbc/xb7", "TIBETAN MARK NGAS BZUNG SGOR RTAGS");
+-   ("/xe0/xbc/xb8", "TIBETAN MARK CHE MGO");
+-   ("/xe0/xbc/xb9", "TIBETAN MARK TSA -PHRU");
+-   ("/xe0/xbc/xba", "TIBETAN MARK GUG RTAGS GYON");
+-   ("/xe0/xbc/xbb", "TIBETAN MARK GUG RTAGS GYAS");
+-   ("/xe0/xbc/xbc", "TIBETAN MARK ANG KHANG GYON");
+-   ("/xe0/xbc/xbd", "TIBETAN MARK ANG KHANG GYAS");
+-   ("/xe0/xbc/xbe", "TIBETAN SIGN YAR TSHES");
+-   ("/xe0/xbc/xbf", "TIBETAN SIGN MAR TSHES");
+-   ("/xe0/xbd/x80", "TIBETAN LETTER KA");
+-   ("/xe0/xbd/x81", "TIBETAN LETTER KHA");
+-   ("/xe0/xbd/x82", "TIBETAN LETTER GA");
+-   ("/xe0/xbd/x83", "TIBETAN LETTER GHA");
+-   ("/xe0/xbd/x84", "TIBETAN LETTER NGA");
+-   ("/xe0/xbd/x85", "TIBETAN LETTER CA");
+-   ("/xe0/xbd/x86", "TIBETAN LETTER CHA");
+-   ("/xe0/xbd/x87", "TIBETAN LETTER JA");
+-   ("/xe0/xbd/x89", "TIBETAN LETTER NYA");
+-   ("/xe0/xbd/x8a", "TIBETAN LETTER TTA");
+-   ("/xe0/xbd/x8b", "TIBETAN LETTER TTHA");
+-   ("/xe0/xbd/x8c", "TIBETAN LETTER DDA");
+-   ("/xe0/xbd/x8d", "TIBETAN LETTER DDHA");
+-   ("/xe0/xbd/x8e", "TIBETAN LETTER NNA");
+-   ("/xe0/xbd/x8f", "TIBETAN LETTER TA");
+-   ("/xe0/xbd/x90", "TIBETAN LETTER THA");
+-   ("/xe0/xbd/x91", "TIBETAN LETTER DA");
+-   ("/xe0/xbd/x92", "TIBETAN LETTER DHA");
+-   ("/xe0/xbd/x93", "TIBETAN LETTER NA");
+-   ("/xe0/xbd/x94", "TIBETAN LETTER PA");
+-   ("/xe0/xbd/x95", "TIBETAN LETTER PHA");
+-   ("/xe0/xbd/x96", "TIBETAN LETTER BA");
+-   ("/xe0/xbd/x97", "TIBETAN LETTER BHA");
+-   ("/xe0/xbd/x98", "TIBETAN LETTER MA");
+-   ("/xe0/xbd/x99", "TIBETAN LETTER TSA");
+-   ("/xe0/xbd/x9a", "TIBETAN LETTER TSHA");
+-   ("/xe0/xbd/x9b", "TIBETAN LETTER DZA");
+-   ("/xe0/xbd/x9c", "TIBETAN LETTER DZHA");
+-   ("/xe0/xbd/x9d", "TIBETAN LETTER WA");
+-   ("/xe0/xbd/x9e", "TIBETAN LETTER ZHA");
+-   ("/xe0/xbd/x9f", "TIBETAN LETTER ZA");
+-   ("/xe0/xbd/xa0", "TIBETAN LETTER -A");
+-   ("/xe0/xbd/xa1", "TIBETAN LETTER YA");
+-   ("/xe0/xbd/xa2", "TIBETAN LETTER RA");
+-   ("/xe0/xbd/xa3", "TIBETAN LETTER LA");
+-   ("/xe0/xbd/xa4", "TIBETAN LETTER SHA");
+-   ("/xe0/xbd/xa5", "TIBETAN LETTER SSA");
+-   ("/xe0/xbd/xa6", "TIBETAN LETTER SA");
+-   ("/xe0/xbd/xa7", "TIBETAN LETTER HA");
+-   ("/xe0/xbd/xa8", "TIBETAN LETTER A");
+-   ("/xe0/xbd/xa9", "TIBETAN LETTER KSSA");
+-   ("/xe0/xbd/xaa", "TIBETAN LETTER FIXED-FORM RA");
+-   ("/xe0/xbd/xab", "TIBETAN LETTER KKA");
+-   ("/xe0/xbd/xac", "TIBETAN LETTER RRA");
+-   ("/xe0/xbd/xb1", "TIBETAN VOWEL SIGN AA");
+-   ("/xe0/xbd/xb2", "TIBETAN VOWEL SIGN I");
+-   ("/xe0/xbd/xb3", "TIBETAN VOWEL SIGN II");
+-   ("/xe0/xbd/xb4", "TIBETAN VOWEL SIGN U");
+-   ("/xe0/xbd/xb5", "TIBETAN VOWEL SIGN UU");
+-   ("/xe0/xbd/xb6", "TIBETAN VOWEL SIGN VOCALIC R");
+-   ("/xe0/xbd/xb7", "TIBETAN VOWEL SIGN VOCALIC RR");
+-   ("/xe0/xbd/xb8", "TIBETAN VOWEL SIGN VOCALIC L");
+-   ("/xe0/xbd/xb9", "TIBETAN VOWEL SIGN VOCALIC LL");
+-   ("/xe0/xbd/xba", "TIBETAN VOWEL SIGN E");
+-   ("/xe0/xbd/xbb", "TIBETAN VOWEL SIGN EE");
+-   ("/xe0/xbd/xbc", "TIBETAN VOWEL SIGN O");
+-   ("/xe0/xbd/xbd", "TIBETAN VOWEL SIGN OO");
+-   ("/xe0/xbd/xbe", "TIBETAN SIGN RJES SU NGA RO");
+-   ("/xe0/xbd/xbf", "TIBETAN SIGN RNAM BCAD");
+-   ("/xe0/xbe/x80", "TIBETAN VOWEL SIGN REVERSED I");
+-   ("/xe0/xbe/x81", "TIBETAN VOWEL SIGN REVERSED II");
+-   ("/xe0/xbe/x82", "TIBETAN SIGN NYI ZLA NAA DA");
+-   ("/xe0/xbe/x83", "TIBETAN SIGN SNA LDAN");
+-   ("/xe0/xbe/x84", "TIBETAN MARK HALANTA");
+-   ("/xe0/xbe/x85", "TIBETAN MARK PALUTA");
+-   ("/xe0/xbe/x86", "TIBETAN SIGN LCI RTAGS");
+-   ("/xe0/xbe/x87", "TIBETAN SIGN YANG RTAGS");
+-   ("/xe0/xbe/x88", "TIBETAN SIGN LCE TSA CAN");
+-   ("/xe0/xbe/x89", "TIBETAN SIGN MCHU CAN");
+-   ("/xe0/xbe/x8a", "TIBETAN SIGN GRU CAN RGYINGS");
+-   ("/xe0/xbe/x8b", "TIBETAN SIGN GRU MED RGYINGS");
+-   ("/xe0/xbe/x90", "TIBETAN SUBJOINED LETTER KA");
+-   ("/xe0/xbe/x91", "TIBETAN SUBJOINED LETTER KHA");
+-   ("/xe0/xbe/x92", "TIBETAN SUBJOINED LETTER GA");
+-   ("/xe0/xbe/x93", "TIBETAN SUBJOINED LETTER GHA");
+-   ("/xe0/xbe/x94", "TIBETAN SUBJOINED LETTER NGA");
+-   ("/xe0/xbe/x95", "TIBETAN SUBJOINED LETTER CA");
+-   ("/xe0/xbe/x96", "TIBETAN SUBJOINED LETTER CHA");
+-   ("/xe0/xbe/x97", "TIBETAN SUBJOINED LETTER JA");
+-   ("/xe0/xbe/x99", "TIBETAN SUBJOINED LETTER NYA");
+-   ("/xe0/xbe/x9a", "TIBETAN SUBJOINED LETTER TTA");
+-   ("/xe0/xbe/x9b", "TIBETAN SUBJOINED LETTER TTHA");
+-   ("/xe0/xbe/x9c", "TIBETAN SUBJOINED LETTER DDA");
+-   ("/xe0/xbe/x9d", "TIBETAN SUBJOINED LETTER DDHA");
+-   ("/xe0/xbe/x9e", "TIBETAN SUBJOINED LETTER NNA");
+-   ("/xe0/xbe/x9f", "TIBETAN SUBJOINED LETTER TA");
+-   ("/xe0/xbe/xa0", "TIBETAN SUBJOINED LETTER THA");
+-   ("/xe0/xbe/xa1", "TIBETAN SUBJOINED LETTER DA");
+-   ("/xe0/xbe/xa2", "TIBETAN SUBJOINED LETTER DHA");
+-   ("/xe0/xbe/xa3", "TIBETAN SUBJOINED LETTER NA");
+-   ("/xe0/xbe/xa4", "TIBETAN SUBJOINED LETTER PA");
+-   ("/xe0/xbe/xa5", "TIBETAN SUBJOINED LETTER PHA");
+-   ("/xe0/xbe/xa6", "TIBETAN SUBJOINED LETTER BA");
+-   ("/xe0/xbe/xa7", "TIBETAN SUBJOINED LETTER BHA");
+-   ("/xe0/xbe/xa8", "TIBETAN SUBJOINED LETTER MA");
+-   ("/xe0/xbe/xa9", "TIBETAN SUBJOINED LETTER TSA");
+-   ("/xe0/xbe/xaa", "TIBETAN SUBJOINED LETTER TSHA");
+-   ("/xe0/xbe/xab", "TIBETAN SUBJOINED LETTER DZA");
+-   ("/xe0/xbe/xac", "TIBETAN SUBJOINED LETTER DZHA");
+-   ("/xe0/xbe/xad", "TIBETAN SUBJOINED LETTER WA");
+-   ("/xe0/xbe/xae", "TIBETAN SUBJOINED LETTER ZHA");
+-   ("/xe0/xbe/xaf", "TIBETAN SUBJOINED LETTER ZA");
+-   ("/xe0/xbe/xb0", "TIBETAN SUBJOINED LETTER -A");
+-   ("/xe0/xbe/xb1", "TIBETAN SUBJOINED LETTER YA");
+-   ("/xe0/xbe/xb2", "TIBETAN SUBJOINED LETTER RA");
+-   ("/xe0/xbe/xb3", "TIBETAN SUBJOINED LETTER LA");
+-   ("/xe0/xbe/xb4", "TIBETAN SUBJOINED LETTER SHA");
+-   ("/xe0/xbe/xb5", "TIBETAN SUBJOINED LETTER SSA");
+-   ("/xe0/xbe/xb6", "TIBETAN SUBJOINED LETTER SA");
+-   ("/xe0/xbe/xb7", "TIBETAN SUBJOINED LETTER HA");
+-   ("/xe0/xbe/xb8", "TIBETAN SUBJOINED LETTER A");
+-   ("/xe0/xbe/xb9", "TIBETAN SUBJOINED LETTER KSSA");
+-   ("/xe0/xbe/xba", "TIBETAN SUBJOINED LETTER FIXED-FORM WA");
+-   ("/xe0/xbe/xbb", "TIBETAN SUBJOINED LETTER FIXED-FORM YA");
+-   ("/xe0/xbe/xbc", "TIBETAN SUBJOINED LETTER FIXED-FORM RA");
+-   ("/xe0/xbe/xbe", "TIBETAN KU RU KHA");
+-   ("/xe0/xbe/xbf", "TIBETAN KU RU KHA BZHI MIG CAN");
+-   ("/xe0/xbf/x80", "TIBETAN CANTILLATION SIGN HEAVY BEAT");
+-   ("/xe0/xbf/x81", "TIBETAN CANTILLATION SIGN LIGHT BEAT");
+-   ("/xe0/xbf/x82", "TIBETAN CANTILLATION SIGN CANG TE-U");
+-   ("/xe0/xbf/x83", "TIBETAN CANTILLATION SIGN SBUB -CHAL");
+-   ("/xe0/xbf/x84", "TIBETAN SYMBOL DRIL BU");
+-   ("/xe0/xbf/x85", "TIBETAN SYMBOL RDO RJE");
+-   ("/xe0/xbf/x86", "TIBETAN SYMBOL PADMA GDAN");
+-   ("/xe0/xbf/x87", "TIBETAN SYMBOL RDO RJE RGYA GRAM");
+-   ("/xe0/xbf/x88", "TIBETAN SYMBOL PHUR PA");
+-   ("/xe0/xbf/x89", "TIBETAN SYMBOL NOR BU");
+-   ("/xe0/xbf/x8a", "TIBETAN SYMBOL NOR BU NYIS -KHYIL");
+-   ("/xe0/xbf/x8b", "TIBETAN SYMBOL NOR BU GSUM -KHYIL");
+-   ("/xe0/xbf/x8c", "TIBETAN SYMBOL NOR BU BZHI -KHYIL");
+-   ("/xe0/xbf/x8e", "TIBETAN SIGN RDEL NAG RDEL DKAR");
+-   ("/xe0/xbf/x8f", "TIBETAN SIGN RDEL NAG GSUM");
+-   ("/xe0/xbf/x90", "TIBETAN MARK BSKA- SHOG GI MGO RGYAN");
+-   ("/xe0/xbf/x91", "TIBETAN MARK MNYAM YIG GI MGO RGYAN");
+-   ("/xe0/xbf/x92", "TIBETAN MARK NYIS TSHEG");
+-   ("/xe0/xbf/x93", "TIBETAN MARK INITIAL BRDA RNYING YIG MGO MDUN MA");
+-   ("/xe0/xbf/x94", "TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA");
+-   ("/xe1/x80/x80", "MYANMAR LETTER KA");
+-   ("/xe1/x80/x81", "MYANMAR LETTER KHA");
+-   ("/xe1/x80/x82", "MYANMAR LETTER GA");
+-   ("/xe1/x80/x83", "MYANMAR LETTER GHA");
+-   ("/xe1/x80/x84", "MYANMAR LETTER NGA");
+-   ("/xe1/x80/x85", "MYANMAR LETTER CA");
+-   ("/xe1/x80/x86", "MYANMAR LETTER CHA");
+-   ("/xe1/x80/x87", "MYANMAR LETTER JA");
+-   ("/xe1/x80/x88", "MYANMAR LETTER JHA");
+-   ("/xe1/x80/x89", "MYANMAR LETTER NYA");
+-   ("/xe1/x80/x8a", "MYANMAR LETTER NNYA");
+-   ("/xe1/x80/x8b", "MYANMAR LETTER TTA");
+-   ("/xe1/x80/x8c", "MYANMAR LETTER TTHA");
+-   ("/xe1/x80/x8d", "MYANMAR LETTER DDA");
+-   ("/xe1/x80/x8e", "MYANMAR LETTER DDHA");
+-   ("/xe1/x80/x8f", "MYANMAR LETTER NNA");
+-   ("/xe1/x80/x90", "MYANMAR LETTER TA");
+-   ("/xe1/x80/x91", "MYANMAR LETTER THA");
+-   ("/xe1/x80/x92", "MYANMAR LETTER DA");
+-   ("/xe1/x80/x93", "MYANMAR LETTER DHA");
+-   ("/xe1/x80/x94", "MYANMAR LETTER NA");
+-   ("/xe1/x80/x95", "MYANMAR LETTER PA");
+-   ("/xe1/x80/x96", "MYANMAR LETTER PHA");
+-   ("/xe1/x80/x97", "MYANMAR LETTER BA");
+-   ("/xe1/x80/x98", "MYANMAR LETTER BHA");
+-   ("/xe1/x80/x99", "MYANMAR LETTER MA");
+-   ("/xe1/x80/x9a", "MYANMAR LETTER YA");
+-   ("/xe1/x80/x9b", "MYANMAR LETTER RA");
+-   ("/xe1/x80/x9c", "MYANMAR LETTER LA");
+-   ("/xe1/x80/x9d", "MYANMAR LETTER WA");
+-   ("/xe1/x80/x9e", "MYANMAR LETTER SA");
+-   ("/xe1/x80/x9f", "MYANMAR LETTER HA");
+-   ("/xe1/x80/xa0", "MYANMAR LETTER LLA");
+-   ("/xe1/x80/xa1", "MYANMAR LETTER A");
+-   ("/xe1/x80/xa2", "MYANMAR LETTER SHAN A");
+-   ("/xe1/x80/xa3", "MYANMAR LETTER I");
+-   ("/xe1/x80/xa4", "MYANMAR LETTER II");
+-   ("/xe1/x80/xa5", "MYANMAR LETTER U");
+-   ("/xe1/x80/xa6", "MYANMAR LETTER UU");
+-   ("/xe1/x80/xa7", "MYANMAR LETTER E");
+-   ("/xe1/x80/xa8", "MYANMAR LETTER MON E");
+-   ("/xe1/x80/xa9", "MYANMAR LETTER O");
+-   ("/xe1/x80/xaa", "MYANMAR LETTER AU");
+-   ("/xe1/x80/xab", "MYANMAR VOWEL SIGN TALL AA");
+-   ("/xe1/x80/xac", "MYANMAR VOWEL SIGN AA");
+-   ("/xe1/x80/xad", "MYANMAR VOWEL SIGN I");
+-   ("/xe1/x80/xae", "MYANMAR VOWEL SIGN II");
+-   ("/xe1/x80/xaf", "MYANMAR VOWEL SIGN U");
+-   ("/xe1/x80/xb0", "MYANMAR VOWEL SIGN UU");
+-   ("/xe1/x80/xb1", "MYANMAR VOWEL SIGN E");
+-   ("/xe1/x80/xb2", "MYANMAR VOWEL SIGN AI");
+-   ("/xe1/x80/xb3", "MYANMAR VOWEL SIGN MON II");
+-   ("/xe1/x80/xb4", "MYANMAR VOWEL SIGN MON O");
+-   ("/xe1/x80/xb5", "MYANMAR VOWEL SIGN E ABOVE");
+-   ("/xe1/x80/xb6", "MYANMAR SIGN ANUSVARA");
+-   ("/xe1/x80/xb7", "MYANMAR SIGN DOT BELOW");
+-   ("/xe1/x80/xb8", "MYANMAR SIGN VISARGA");
+-   ("/xe1/x80/xb9", "MYANMAR SIGN VIRAMA");
+-   ("/xe1/x80/xba", "MYANMAR SIGN ASAT");
+-   ("/xe1/x80/xbb", "MYANMAR CONSONANT SIGN MEDIAL YA");
+-   ("/xe1/x80/xbc", "MYANMAR CONSONANT SIGN MEDIAL RA");
+-   ("/xe1/x80/xbd", "MYANMAR CONSONANT SIGN MEDIAL WA");
+-   ("/xe1/x80/xbe", "MYANMAR CONSONANT SIGN MEDIAL HA");
+-   ("/xe1/x80/xbf", "MYANMAR LETTER GREAT SA");
+-   ("/xe1/x81/x80", "MYANMAR DIGIT ZERO");
+-   ("/xe1/x81/x81", "MYANMAR DIGIT ONE");
+-   ("/xe1/x81/x82", "MYANMAR DIGIT TWO");
+-   ("/xe1/x81/x83", "MYANMAR DIGIT THREE");
+-   ("/xe1/x81/x84", "MYANMAR DIGIT FOUR");
+-   ("/xe1/x81/x85", "MYANMAR DIGIT FIVE");
+-   ("/xe1/x81/x86", "MYANMAR DIGIT SIX");
+-   ("/xe1/x81/x87", "MYANMAR DIGIT SEVEN");
+-   ("/xe1/x81/x88", "MYANMAR DIGIT EIGHT");
+-   ("/xe1/x81/x89", "MYANMAR DIGIT NINE");
+-   ("/xe1/x81/x8a", "MYANMAR SIGN LITTLE SECTION");
+-   ("/xe1/x81/x8b", "MYANMAR SIGN SECTION");
+-   ("/xe1/x81/x8c", "MYANMAR SYMBOL LOCATIVE");
+-   ("/xe1/x81/x8d", "MYANMAR SYMBOL COMPLETED");
+-   ("/xe1/x81/x8e", "MYANMAR SYMBOL AFOREMENTIONED");
+-   ("/xe1/x81/x8f", "MYANMAR SYMBOL GENITIVE");
+-   ("/xe1/x81/x90", "MYANMAR LETTER SHA");
+-   ("/xe1/x81/x91", "MYANMAR LETTER SSA");
+-   ("/xe1/x81/x92", "MYANMAR LETTER VOCALIC R");
+-   ("/xe1/x81/x93", "MYANMAR LETTER VOCALIC RR");
+-   ("/xe1/x81/x94", "MYANMAR LETTER VOCALIC L");
+-   ("/xe1/x81/x95", "MYANMAR LETTER VOCALIC LL");
+-   ("/xe1/x81/x96", "MYANMAR VOWEL SIGN VOCALIC R");
+-   ("/xe1/x81/x97", "MYANMAR VOWEL SIGN VOCALIC RR");
+-   ("/xe1/x81/x98", "MYANMAR VOWEL SIGN VOCALIC L");
+-   ("/xe1/x81/x99", "MYANMAR VOWEL SIGN VOCALIC LL");
+-   ("/xe1/x81/x9a", "MYANMAR LETTER MON NGA");
+-   ("/xe1/x81/x9b", "MYANMAR LETTER MON JHA");
+-   ("/xe1/x81/x9c", "MYANMAR LETTER MON BBA");
+-   ("/xe1/x81/x9d", "MYANMAR LETTER MON BBE");
+-   ("/xe1/x81/x9e", "MYANMAR CONSONANT SIGN MON MEDIAL NA");
+-   ("/xe1/x81/x9f", "MYANMAR CONSONANT SIGN MON MEDIAL MA");
+-   ("/xe1/x81/xa0", "MYANMAR CONSONANT SIGN MON MEDIAL LA");
+-   ("/xe1/x81/xa1", "MYANMAR LETTER SGAW KAREN SHA");
+-   ("/xe1/x81/xa2", "MYANMAR VOWEL SIGN SGAW KAREN EU");
+-   ("/xe1/x81/xa3", "MYANMAR TONE MARK SGAW KAREN HATHI");
+-   ("/xe1/x81/xa4", "MYANMAR TONE MARK SGAW KAREN KE PHO");
+-   ("/xe1/x81/xa5", "MYANMAR LETTER WESTERN PWO KAREN THA");
+-   ("/xe1/x81/xa6", "MYANMAR LETTER WESTERN PWO KAREN PWA");
+-   ("/xe1/x81/xa7", "MYANMAR VOWEL SIGN WESTERN PWO KAREN EU");
+-   ("/xe1/x81/xa8", "MYANMAR VOWEL SIGN WESTERN PWO KAREN UE");
+-   ("/xe1/x81/xa9", "MYANMAR SIGN WESTERN PWO KAREN TONE-1");
+-   ("/xe1/x81/xaa", "MYANMAR SIGN WESTERN PWO KAREN TONE-2");
+-   ("/xe1/x81/xab", "MYANMAR SIGN WESTERN PWO KAREN TONE-3");
+-   ("/xe1/x81/xac", "MYANMAR SIGN WESTERN PWO KAREN TONE-4");
+-   ("/xe1/x81/xad", "MYANMAR SIGN WESTERN PWO KAREN TONE-5");
+-   ("/xe1/x81/xae", "MYANMAR LETTER EASTERN PWO KAREN NNA");
+-   ("/xe1/x81/xaf", "MYANMAR LETTER EASTERN PWO KAREN YWA");
+-   ("/xe1/x81/xb0", "MYANMAR LETTER EASTERN PWO KAREN GHWA");
+-   ("/xe1/x81/xb1", "MYANMAR VOWEL SIGN GEBA KAREN I");
+-   ("/xe1/x81/xb2", "MYANMAR VOWEL SIGN KAYAH OE");
+-   ("/xe1/x81/xb3", "MYANMAR VOWEL SIGN KAYAH U");
+-   ("/xe1/x81/xb4", "MYANMAR VOWEL SIGN KAYAH EE");
+-   ("/xe1/x81/xb5", "MYANMAR LETTER SHAN KA");
+-   ("/xe1/x81/xb6", "MYANMAR LETTER SHAN KHA");
+-   ("/xe1/x81/xb7", "MYANMAR LETTER SHAN GA");
+-   ("/xe1/x81/xb8", "MYANMAR LETTER SHAN CA");
+-   ("/xe1/x81/xb9", "MYANMAR LETTER SHAN ZA");
+-   ("/xe1/x81/xba", "MYANMAR LETTER SHAN NYA");
+-   ("/xe1/x81/xbb", "MYANMAR LETTER SHAN DA");
+-   ("/xe1/x81/xbc", "MYANMAR LETTER SHAN NA");
+-   ("/xe1/x81/xbd", "MYANMAR LETTER SHAN PHA");
+-   ("/xe1/x81/xbe", "MYANMAR LETTER SHAN FA");
+-   ("/xe1/x81/xbf", "MYANMAR LETTER SHAN BA");
+-   ("/xe1/x82/x80", "MYANMAR LETTER SHAN THA");
+-   ("/xe1/x82/x81", "MYANMAR LETTER SHAN HA");
+-   ("/xe1/x82/x82", "MYANMAR CONSONANT SIGN SHAN MEDIAL WA");
+-   ("/xe1/x82/x83", "MYANMAR VOWEL SIGN SHAN AA");
+-   ("/xe1/x82/x84", "MYANMAR VOWEL SIGN SHAN E");
+-   ("/xe1/x82/x85", "MYANMAR VOWEL SIGN SHAN E ABOVE");
+-   ("/xe1/x82/x86", "MYANMAR VOWEL SIGN SHAN FINAL Y");
+-   ("/xe1/x82/x87", "MYANMAR SIGN SHAN TONE-2");
+-   ("/xe1/x82/x88", "MYANMAR SIGN SHAN TONE-3");
+-   ("/xe1/x82/x89", "MYANMAR SIGN SHAN TONE-5");
+-   ("/xe1/x82/x8a", "MYANMAR SIGN SHAN TONE-6");
+-   ("/xe1/x82/x8b", "MYANMAR SIGN SHAN COUNCIL TONE-2");
+-   ("/xe1/x82/x8c", "MYANMAR SIGN SHAN COUNCIL TONE-3");
+-   ("/xe1/x82/x8d", "MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE");
+-   ("/xe1/x82/x8e", "MYANMAR LETTER RUMAI PALAUNG FA");
+-   ("/xe1/x82/x8f", "MYANMAR SIGN RUMAI PALAUNG TONE-5");
+-   ("/xe1/x82/x90", "MYANMAR SHAN DIGIT ZERO");
+-   ("/xe1/x82/x91", "MYANMAR SHAN DIGIT ONE");
+-   ("/xe1/x82/x92", "MYANMAR SHAN DIGIT TWO");
+-   ("/xe1/x82/x93", "MYANMAR SHAN DIGIT THREE");
+-   ("/xe1/x82/x94", "MYANMAR SHAN DIGIT FOUR");
+-   ("/xe1/x82/x95", "MYANMAR SHAN DIGIT FIVE");
+-   ("/xe1/x82/x96", "MYANMAR SHAN DIGIT SIX");
+-   ("/xe1/x82/x97", "MYANMAR SHAN DIGIT SEVEN");
+-   ("/xe1/x82/x98", "MYANMAR SHAN DIGIT EIGHT");
+-   ("/xe1/x82/x99", "MYANMAR SHAN DIGIT NINE");
+-   ("/xe1/x82/x9e", "MYANMAR SYMBOL SHAN ONE");
+-   ("/xe1/x82/x9f", "MYANMAR SYMBOL SHAN EXCLAMATION");
+    ("/xe1/x82/xa0", "GEORGIAN CAPITAL LETTER AN");
+    ("/xe1/x82/xa1", "GEORGIAN CAPITAL LETTER BAN");
+    ("/xe1/x82/xa2", "GEORGIAN CAPITAL LETTER GAN");
+@@ -3393,1890 +1111,6 @@
+    ("/xe1/x83/x83", "GEORGIAN CAPITAL LETTER WE");
+    ("/xe1/x83/x84", "GEORGIAN CAPITAL LETTER HAR");
+    ("/xe1/x83/x85", "GEORGIAN CAPITAL LETTER HOE");
+-   ("/xe1/x83/x90", "GEORGIAN LETTER AN");
+-   ("/xe1/x83/x91", "GEORGIAN LETTER BAN");
+-   ("/xe1/x83/x92", "GEORGIAN LETTER GAN");
+-   ("/xe1/x83/x93", "GEORGIAN LETTER DON");
+-   ("/xe1/x83/x94", "GEORGIAN LETTER EN");
+-   ("/xe1/x83/x95", "GEORGIAN LETTER VIN");
+-   ("/xe1/x83/x96", "GEORGIAN LETTER ZEN");
+-   ("/xe1/x83/x97", "GEORGIAN LETTER TAN");
+-   ("/xe1/x83/x98", "GEORGIAN LETTER IN");
+-   ("/xe1/x83/x99", "GEORGIAN LETTER KAN");
+-   ("/xe1/x83/x9a", "GEORGIAN LETTER LAS");
+-   ("/xe1/x83/x9b", "GEORGIAN LETTER MAN");
+-   ("/xe1/x83/x9c", "GEORGIAN LETTER NAR");
+-   ("/xe1/x83/x9d", "GEORGIAN LETTER ON");
+-   ("/xe1/x83/x9e", "GEORGIAN LETTER PAR");
+-   ("/xe1/x83/x9f", "GEORGIAN LETTER ZHAR");
+-   ("/xe1/x83/xa0", "GEORGIAN LETTER RAE");
+-   ("/xe1/x83/xa1", "GEORGIAN LETTER SAN");
+-   ("/xe1/x83/xa2", "GEORGIAN LETTER TAR");
+-   ("/xe1/x83/xa3", "GEORGIAN LETTER UN");
+-   ("/xe1/x83/xa4", "GEORGIAN LETTER PHAR");
+-   ("/xe1/x83/xa5", "GEORGIAN LETTER KHAR");
+-   ("/xe1/x83/xa6", "GEORGIAN LETTER GHAN");
+-   ("/xe1/x83/xa7", "GEORGIAN LETTER QAR");
+-   ("/xe1/x83/xa8", "GEORGIAN LETTER SHIN");
+-   ("/xe1/x83/xa9", "GEORGIAN LETTER CHIN");
+-   ("/xe1/x83/xaa", "GEORGIAN LETTER CAN");
+-   ("/xe1/x83/xab", "GEORGIAN LETTER JIL");
+-   ("/xe1/x83/xac", "GEORGIAN LETTER CIL");
+-   ("/xe1/x83/xad", "GEORGIAN LETTER CHAR");
+-   ("/xe1/x83/xae", "GEORGIAN LETTER XAN");
+-   ("/xe1/x83/xaf", "GEORGIAN LETTER JHAN");
+-   ("/xe1/x83/xb0", "GEORGIAN LETTER HAE");
+-   ("/xe1/x83/xb1", "GEORGIAN LETTER HE");
+-   ("/xe1/x83/xb2", "GEORGIAN LETTER HIE");
+-   ("/xe1/x83/xb3", "GEORGIAN LETTER WE");
+-   ("/xe1/x83/xb4", "GEORGIAN LETTER HAR");
+-   ("/xe1/x83/xb5", "GEORGIAN LETTER HOE");
+-   ("/xe1/x83/xb6", "GEORGIAN LETTER FI");
+-   ("/xe1/x83/xb7", "GEORGIAN LETTER YN");
+-   ("/xe1/x83/xb8", "GEORGIAN LETTER ELIFI");
+-   ("/xe1/x83/xb9", "GEORGIAN LETTER TURNED GAN");
+-   ("/xe1/x83/xba", "GEORGIAN LETTER AIN");
+-   ("/xe1/x83/xbb", "GEORGIAN PARAGRAPH SEPARATOR");
+-   ("/xe1/x83/xbc", "MODIFIER LETTER GEORGIAN NAR");
+-   ("/xe1/x84/x80", "HANGUL CHOSEONG KIYEOK");
+-   ("/xe1/x84/x81", "HANGUL CHOSEONG SSANGKIYEOK");
+-   ("/xe1/x84/x82", "HANGUL CHOSEONG NIEUN");
+-   ("/xe1/x84/x83", "HANGUL CHOSEONG TIKEUT");
+-   ("/xe1/x84/x84", "HANGUL CHOSEONG SSANGTIKEUT");
+-   ("/xe1/x84/x85", "HANGUL CHOSEONG RIEUL");
+-   ("/xe1/x84/x86", "HANGUL CHOSEONG MIEUM");
+-   ("/xe1/x84/x87", "HANGUL CHOSEONG PIEUP");
+-   ("/xe1/x84/x88", "HANGUL CHOSEONG SSANGPIEUP");
+-   ("/xe1/x84/x89", "HANGUL CHOSEONG SIOS");
+-   ("/xe1/x84/x8a", "HANGUL CHOSEONG SSANGSIOS");
+-   ("/xe1/x84/x8b", "HANGUL CHOSEONG IEUNG");
+-   ("/xe1/x84/x8c", "HANGUL CHOSEONG CIEUC");
+-   ("/xe1/x84/x8d", "HANGUL CHOSEONG SSANGCIEUC");
+-   ("/xe1/x84/x8e", "HANGUL CHOSEONG CHIEUCH");
+-   ("/xe1/x84/x8f", "HANGUL CHOSEONG KHIEUKH");
+-   ("/xe1/x84/x90", "HANGUL CHOSEONG THIEUTH");
+-   ("/xe1/x84/x91", "HANGUL CHOSEONG PHIEUPH");
+-   ("/xe1/x84/x92", "HANGUL CHOSEONG HIEUH");
+-   ("/xe1/x84/x93", "HANGUL CHOSEONG NIEUN-KIYEOK");
+-   ("/xe1/x84/x94", "HANGUL CHOSEONG SSANGNIEUN");
+-   ("/xe1/x84/x95", "HANGUL CHOSEONG NIEUN-TIKEUT");
+-   ("/xe1/x84/x96", "HANGUL CHOSEONG NIEUN-PIEUP");
+-   ("/xe1/x84/x97", "HANGUL CHOSEONG TIKEUT-KIYEOK");
+-   ("/xe1/x84/x98", "HANGUL CHOSEONG RIEUL-NIEUN");
+-   ("/xe1/x84/x99", "HANGUL CHOSEONG SSANGRIEUL");
+-   ("/xe1/x84/x9a", "HANGUL CHOSEONG RIEUL-HIEUH");
+-   ("/xe1/x84/x9b", "HANGUL CHOSEONG KAPYEOUNRIEUL");
+-   ("/xe1/x84/x9c", "HANGUL CHOSEONG MIEUM-PIEUP");
+-   ("/xe1/x84/x9d", "HANGUL CHOSEONG KAPYEOUNMIEUM");
+-   ("/xe1/x84/x9e", "HANGUL CHOSEONG PIEUP-KIYEOK");
+-   ("/xe1/x84/x9f", "HANGUL CHOSEONG PIEUP-NIEUN");
+-   ("/xe1/x84/xa0", "HANGUL CHOSEONG PIEUP-TIKEUT");
+-   ("/xe1/x84/xa1", "HANGUL CHOSEONG PIEUP-SIOS");
+-   ("/xe1/x84/xa2", "HANGUL CHOSEONG PIEUP-SIOS-KIYEOK");
+-   ("/xe1/x84/xa3", "HANGUL CHOSEONG PIEUP-SIOS-TIKEUT");
+-   ("/xe1/x84/xa4", "HANGUL CHOSEONG PIEUP-SIOS-PIEUP");
+-   ("/xe1/x84/xa5", "HANGUL CHOSEONG PIEUP-SSANGSIOS");
+-   ("/xe1/x84/xa6", "HANGUL CHOSEONG PIEUP-SIOS-CIEUC");
+-   ("/xe1/x84/xa7", "HANGUL CHOSEONG PIEUP-CIEUC");
+-   ("/xe1/x84/xa8", "HANGUL CHOSEONG PIEUP-CHIEUCH");
+-   ("/xe1/x84/xa9", "HANGUL CHOSEONG PIEUP-THIEUTH");
+-   ("/xe1/x84/xaa", "HANGUL CHOSEONG PIEUP-PHIEUPH");
+-   ("/xe1/x84/xab", "HANGUL CHOSEONG KAPYEOUNPIEUP");
+-   ("/xe1/x84/xac", "HANGUL CHOSEONG KAPYEOUNSSANGPIEUP");
+-   ("/xe1/x84/xad", "HANGUL CHOSEONG SIOS-KIYEOK");
+-   ("/xe1/x84/xae", "HANGUL CHOSEONG SIOS-NIEUN");
+-   ("/xe1/x84/xaf", "HANGUL CHOSEONG SIOS-TIKEUT");
+-   ("/xe1/x84/xb0", "HANGUL CHOSEONG SIOS-RIEUL");
+-   ("/xe1/x84/xb1", "HANGUL CHOSEONG SIOS-MIEUM");
+-   ("/xe1/x84/xb2", "HANGUL CHOSEONG SIOS-PIEUP");
+-   ("/xe1/x84/xb3", "HANGUL CHOSEONG SIOS-PIEUP-KIYEOK");
+-   ("/xe1/x84/xb4", "HANGUL CHOSEONG SIOS-SSANGSIOS");
+-   ("/xe1/x84/xb5", "HANGUL CHOSEONG SIOS-IEUNG");
+-   ("/xe1/x84/xb6", "HANGUL CHOSEONG SIOS-CIEUC");
+-   ("/xe1/x84/xb7", "HANGUL CHOSEONG SIOS-CHIEUCH");
+-   ("/xe1/x84/xb8", "HANGUL CHOSEONG SIOS-KHIEUKH");
+-   ("/xe1/x84/xb9", "HANGUL CHOSEONG SIOS-THIEUTH");
+-   ("/xe1/x84/xba", "HANGUL CHOSEONG SIOS-PHIEUPH");
+-   ("/xe1/x84/xbb", "HANGUL CHOSEONG SIOS-HIEUH");
+-   ("/xe1/x84/xbc", "HANGUL CHOSEONG CHITUEUMSIOS");
+-   ("/xe1/x84/xbd", "HANGUL CHOSEONG CHITUEUMSSANGSIOS");
+-   ("/xe1/x84/xbe", "HANGUL CHOSEONG CEONGCHIEUMSIOS");
+-   ("/xe1/x84/xbf", "HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS");
+-   ("/xe1/x85/x80", "HANGUL CHOSEONG PANSIOS");
+-   ("/xe1/x85/x81", "HANGUL CHOSEONG IEUNG-KIYEOK");
+-   ("/xe1/x85/x82", "HANGUL CHOSEONG IEUNG-TIKEUT");
+-   ("/xe1/x85/x83", "HANGUL CHOSEONG IEUNG-MIEUM");
+-   ("/xe1/x85/x84", "HANGUL CHOSEONG IEUNG-PIEUP");
+-   ("/xe1/x85/x85", "HANGUL CHOSEONG IEUNG-SIOS");
+-   ("/xe1/x85/x86", "HANGUL CHOSEONG IEUNG-PANSIOS");
+-   ("/xe1/x85/x87", "HANGUL CHOSEONG SSANGIEUNG");
+-   ("/xe1/x85/x88", "HANGUL CHOSEONG IEUNG-CIEUC");
+-   ("/xe1/x85/x89", "HANGUL CHOSEONG IEUNG-CHIEUCH");
+-   ("/xe1/x85/x8a", "HANGUL CHOSEONG IEUNG-THIEUTH");
+-   ("/xe1/x85/x8b", "HANGUL CHOSEONG IEUNG-PHIEUPH");
+-   ("/xe1/x85/x8c", "HANGUL CHOSEONG YESIEUNG");
+-   ("/xe1/x85/x8d", "HANGUL CHOSEONG CIEUC-IEUNG");
+-   ("/xe1/x85/x8e", "HANGUL CHOSEONG CHITUEUMCIEUC");
+-   ("/xe1/x85/x8f", "HANGUL CHOSEONG CHITUEUMSSANGCIEUC");
+-   ("/xe1/x85/x90", "HANGUL CHOSEONG CEONGCHIEUMCIEUC");
+-   ("/xe1/x85/x91", "HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC");
+-   ("/xe1/x85/x92", "HANGUL CHOSEONG CHIEUCH-KHIEUKH");
+-   ("/xe1/x85/x93", "HANGUL CHOSEONG CHIEUCH-HIEUH");
+-   ("/xe1/x85/x94", "HANGUL CHOSEONG CHITUEUMCHIEUCH");
+-   ("/xe1/x85/x95", "HANGUL CHOSEONG CEONGCHIEUMCHIEUCH");
+-   ("/xe1/x85/x96", "HANGUL CHOSEONG PHIEUPH-PIEUP");
+-   ("/xe1/x85/x97", "HANGUL CHOSEONG KAPYEOUNPHIEUPH");
+-   ("/xe1/x85/x98", "HANGUL CHOSEONG SSANGHIEUH");
+-   ("/xe1/x85/x99", "HANGUL CHOSEONG YEORINHIEUH");
+-   ("/xe1/x85/x9f", "HANGUL CHOSEONG FILLER");
+-   ("/xe1/x85/xa0", "HANGUL JUNGSEONG FILLER");
+-   ("/xe1/x85/xa1", "HANGUL JUNGSEONG A");
+-   ("/xe1/x85/xa2", "HANGUL JUNGSEONG AE");
+-   ("/xe1/x85/xa3", "HANGUL JUNGSEONG YA");
+-   ("/xe1/x85/xa4", "HANGUL JUNGSEONG YAE");
+-   ("/xe1/x85/xa5", "HANGUL JUNGSEONG EO");
+-   ("/xe1/x85/xa6", "HANGUL JUNGSEONG E");
+-   ("/xe1/x85/xa7", "HANGUL JUNGSEONG YEO");
+-   ("/xe1/x85/xa8", "HANGUL JUNGSEONG YE");
+-   ("/xe1/x85/xa9", "HANGUL JUNGSEONG O");
+-   ("/xe1/x85/xaa", "HANGUL JUNGSEONG WA");
+-   ("/xe1/x85/xab", "HANGUL JUNGSEONG WAE");
+-   ("/xe1/x85/xac", "HANGUL JUNGSEONG OE");
+-   ("/xe1/x85/xad", "HANGUL JUNGSEONG YO");
+-   ("/xe1/x85/xae", "HANGUL JUNGSEONG U");
+-   ("/xe1/x85/xaf", "HANGUL JUNGSEONG WEO");
+-   ("/xe1/x85/xb0", "HANGUL JUNGSEONG WE");
+-   ("/xe1/x85/xb1", "HANGUL JUNGSEONG WI");
+-   ("/xe1/x85/xb2", "HANGUL JUNGSEONG YU");
+-   ("/xe1/x85/xb3", "HANGUL JUNGSEONG EU");
+-   ("/xe1/x85/xb4", "HANGUL JUNGSEONG YI");
+-   ("/xe1/x85/xb5", "HANGUL JUNGSEONG I");
+-   ("/xe1/x85/xb6", "HANGUL JUNGSEONG A-O");
+-   ("/xe1/x85/xb7", "HANGUL JUNGSEONG A-U");
+-   ("/xe1/x85/xb8", "HANGUL JUNGSEONG YA-O");
+-   ("/xe1/x85/xb9", "HANGUL JUNGSEONG YA-YO");
+-   ("/xe1/x85/xba", "HANGUL JUNGSEONG EO-O");
+-   ("/xe1/x85/xbb", "HANGUL JUNGSEONG EO-U");
+-   ("/xe1/x85/xbc", "HANGUL JUNGSEONG EO-EU");
+-   ("/xe1/x85/xbd", "HANGUL JUNGSEONG YEO-O");
+-   ("/xe1/x85/xbe", "HANGUL JUNGSEONG YEO-U");
+-   ("/xe1/x85/xbf", "HANGUL JUNGSEONG O-EO");
+-   ("/xe1/x86/x80", "HANGUL JUNGSEONG O-E");
+-   ("/xe1/x86/x81", "HANGUL JUNGSEONG O-YE");
+-   ("/xe1/x86/x82", "HANGUL JUNGSEONG O-O");
+-   ("/xe1/x86/x83", "HANGUL JUNGSEONG O-U");
+-   ("/xe1/x86/x84", "HANGUL JUNGSEONG YO-YA");
+-   ("/xe1/x86/x85", "HANGUL JUNGSEONG YO-YAE");
+-   ("/xe1/x86/x86", "HANGUL JUNGSEONG YO-YEO");
+-   ("/xe1/x86/x87", "HANGUL JUNGSEONG YO-O");
+-   ("/xe1/x86/x88", "HANGUL JUNGSEONG YO-I");
+-   ("/xe1/x86/x89", "HANGUL JUNGSEONG U-A");
+-   ("/xe1/x86/x8a", "HANGUL JUNGSEONG U-AE");
+-   ("/xe1/x86/x8b", "HANGUL JUNGSEONG U-EO-EU");
+-   ("/xe1/x86/x8c", "HANGUL JUNGSEONG U-YE");
+-   ("/xe1/x86/x8d", "HANGUL JUNGSEONG U-U");
+-   ("/xe1/x86/x8e", "HANGUL JUNGSEONG YU-A");
+-   ("/xe1/x86/x8f", "HANGUL JUNGSEONG YU-EO");
+-   ("/xe1/x86/x90", "HANGUL JUNGSEONG YU-E");
+-   ("/xe1/x86/x91", "HANGUL JUNGSEONG YU-YEO");
+-   ("/xe1/x86/x92", "HANGUL JUNGSEONG YU-YE");
+-   ("/xe1/x86/x93", "HANGUL JUNGSEONG YU-U");
+-   ("/xe1/x86/x94", "HANGUL JUNGSEONG YU-I");
+-   ("/xe1/x86/x95", "HANGUL JUNGSEONG EU-U");
+-   ("/xe1/x86/x96", "HANGUL JUNGSEONG EU-EU");
+-   ("/xe1/x86/x97", "HANGUL JUNGSEONG YI-U");
+-   ("/xe1/x86/x98", "HANGUL JUNGSEONG I-A");
+-   ("/xe1/x86/x99", "HANGUL JUNGSEONG I-YA");
+-   ("/xe1/x86/x9a", "HANGUL JUNGSEONG I-O");
+-   ("/xe1/x86/x9b", "HANGUL JUNGSEONG I-U");
+-   ("/xe1/x86/x9c", "HANGUL JUNGSEONG I-EU");
+-   ("/xe1/x86/x9d", "HANGUL JUNGSEONG I-ARAEA");
+-   ("/xe1/x86/x9e", "HANGUL JUNGSEONG ARAEA");
+-   ("/xe1/x86/x9f", "HANGUL JUNGSEONG ARAEA-EO");
+-   ("/xe1/x86/xa0", "HANGUL JUNGSEONG ARAEA-U");
+-   ("/xe1/x86/xa1", "HANGUL JUNGSEONG ARAEA-I");
+-   ("/xe1/x86/xa2", "HANGUL JUNGSEONG SSANGARAEA");
+-   ("/xe1/x86/xa8", "HANGUL JONGSEONG KIYEOK");
+-   ("/xe1/x86/xa9", "HANGUL JONGSEONG SSANGKIYEOK");
+-   ("/xe1/x86/xaa", "HANGUL JONGSEONG KIYEOK-SIOS");
+-   ("/xe1/x86/xab", "HANGUL JONGSEONG NIEUN");
+-   ("/xe1/x86/xac", "HANGUL JONGSEONG NIEUN-CIEUC");
+-   ("/xe1/x86/xad", "HANGUL JONGSEONG NIEUN-HIEUH");
+-   ("/xe1/x86/xae", "HANGUL JONGSEONG TIKEUT");
+-   ("/xe1/x86/xaf", "HANGUL JONGSEONG RIEUL");
+-   ("/xe1/x86/xb0", "HANGUL JONGSEONG RIEUL-KIYEOK");
+-   ("/xe1/x86/xb1", "HANGUL JONGSEONG RIEUL-MIEUM");
+-   ("/xe1/x86/xb2", "HANGUL JONGSEONG RIEUL-PIEUP");
+-   ("/xe1/x86/xb3", "HANGUL JONGSEONG RIEUL-SIOS");
+-   ("/xe1/x86/xb4", "HANGUL JONGSEONG RIEUL-THIEUTH");
+-   ("/xe1/x86/xb5", "HANGUL JONGSEONG RIEUL-PHIEUPH");
+-   ("/xe1/x86/xb6", "HANGUL JONGSEONG RIEUL-HIEUH");
+-   ("/xe1/x86/xb7", "HANGUL JONGSEONG MIEUM");
+-   ("/xe1/x86/xb8", "HANGUL JONGSEONG PIEUP");
+-   ("/xe1/x86/xb9", "HANGUL JONGSEONG PIEUP-SIOS");
+-   ("/xe1/x86/xba", "HANGUL JONGSEONG SIOS");
+-   ("/xe1/x86/xbb", "HANGUL JONGSEONG SSANGSIOS");
+-   ("/xe1/x86/xbc", "HANGUL JONGSEONG IEUNG");
+-   ("/xe1/x86/xbd", "HANGUL JONGSEONG CIEUC");
+-   ("/xe1/x86/xbe", "HANGUL JONGSEONG CHIEUCH");
+-   ("/xe1/x86/xbf", "HANGUL JONGSEONG KHIEUKH");
+-   ("/xe1/x87/x80", "HANGUL JONGSEONG THIEUTH");
+-   ("/xe1/x87/x81", "HANGUL JONGSEONG PHIEUPH");
+-   ("/xe1/x87/x82", "HANGUL JONGSEONG HIEUH");
+-   ("/xe1/x87/x83", "HANGUL JONGSEONG KIYEOK-RIEUL");
+-   ("/xe1/x87/x84", "HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK");
+-   ("/xe1/x87/x85", "HANGUL JONGSEONG NIEUN-KIYEOK");
+-   ("/xe1/x87/x86", "HANGUL JONGSEONG NIEUN-TIKEUT");
+-   ("/xe1/x87/x87", "HANGUL JONGSEONG NIEUN-SIOS");
+-   ("/xe1/x87/x88", "HANGUL JONGSEONG NIEUN-PANSIOS");
+-   ("/xe1/x87/x89", "HANGUL JONGSEONG NIEUN-THIEUTH");
+-   ("/xe1/x87/x8a", "HANGUL JONGSEONG TIKEUT-KIYEOK");
+-   ("/xe1/x87/x8b", "HANGUL JONGSEONG TIKEUT-RIEUL");
+-   ("/xe1/x87/x8c", "HANGUL JONGSEONG RIEUL-KIYEOK-SIOS");
+-   ("/xe1/x87/x8d", "HANGUL JONGSEONG RIEUL-NIEUN");
+-   ("/xe1/x87/x8e", "HANGUL JONGSEONG RIEUL-TIKEUT");
+-   ("/xe1/x87/x8f", "HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH");
+-   ("/xe1/x87/x90", "HANGUL JONGSEONG SSANGRIEUL");
+-   ("/xe1/x87/x91", "HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK");
+-   ("/xe1/x87/x92", "HANGUL JONGSEONG RIEUL-MIEUM-SIOS");
+-   ("/xe1/x87/x93", "HANGUL JONGSEONG RIEUL-PIEUP-SIOS");
+-   ("/xe1/x87/x94", "HANGUL JONGSEONG RIEUL-PIEUP-HIEUH");
+-   ("/xe1/x87/x95", "HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP");
+-   ("/xe1/x87/x96", "HANGUL JONGSEONG RIEUL-SSANGSIOS");
+-   ("/xe1/x87/x97", "HANGUL JONGSEONG RIEUL-PANSIOS");
+-   ("/xe1/x87/x98", "HANGUL JONGSEONG RIEUL-KHIEUKH");
+-   ("/xe1/x87/x99", "HANGUL JONGSEONG RIEUL-YEORINHIEUH");
+-   ("/xe1/x87/x9a", "HANGUL JONGSEONG MIEUM-KIYEOK");
+-   ("/xe1/x87/x9b", "HANGUL JONGSEONG MIEUM-RIEUL");
+-   ("/xe1/x87/x9c", "HANGUL JONGSEONG MIEUM-PIEUP");
+-   ("/xe1/x87/x9d", "HANGUL JONGSEONG MIEUM-SIOS");
+-   ("/xe1/x87/x9e", "HANGUL JONGSEONG MIEUM-SSANGSIOS");
+-   ("/xe1/x87/x9f", "HANGUL JONGSEONG MIEUM-PANSIOS");
+-   ("/xe1/x87/xa0", "HANGUL JONGSEONG MIEUM-CHIEUCH");
+-   ("/xe1/x87/xa1", "HANGUL JONGSEONG MIEUM-HIEUH");
+-   ("/xe1/x87/xa2", "HANGUL JONGSEONG KAPYEOUNMIEUM");
+-   ("/xe1/x87/xa3", "HANGUL JONGSEONG PIEUP-RIEUL");
+-   ("/xe1/x87/xa4", "HANGUL JONGSEONG PIEUP-PHIEUPH");
+-   ("/xe1/x87/xa5", "HANGUL JONGSEONG PIEUP-HIEUH");
+-   ("/xe1/x87/xa6", "HANGUL JONGSEONG KAPYEOUNPIEUP");
+-   ("/xe1/x87/xa7", "HANGUL JONGSEONG SIOS-KIYEOK");
+-   ("/xe1/x87/xa8", "HANGUL JONGSEONG SIOS-TIKEUT");
+-   ("/xe1/x87/xa9", "HANGUL JONGSEONG SIOS-RIEUL");
+-   ("/xe1/x87/xaa", "HANGUL JONGSEONG SIOS-PIEUP");
+-   ("/xe1/x87/xab", "HANGUL JONGSEONG PANSIOS");
+-   ("/xe1/x87/xac", "HANGUL JONGSEONG IEUNG-KIYEOK");
+-   ("/xe1/x87/xad", "HANGUL JONGSEONG IEUNG-SSANGKIYEOK");
+-   ("/xe1/x87/xae", "HANGUL JONGSEONG SSANGIEUNG");
+-   ("/xe1/x87/xaf", "HANGUL JONGSEONG IEUNG-KHIEUKH");
+-   ("/xe1/x87/xb0", "HANGUL JONGSEONG YESIEUNG");
+-   ("/xe1/x87/xb1", "HANGUL JONGSEONG YESIEUNG-SIOS");
+-   ("/xe1/x87/xb2", "HANGUL JONGSEONG YESIEUNG-PANSIOS");
+-   ("/xe1/x87/xb3", "HANGUL JONGSEONG PHIEUPH-PIEUP");
+-   ("/xe1/x87/xb4", "HANGUL JONGSEONG KAPYEOUNPHIEUPH");
+-   ("/xe1/x87/xb5", "HANGUL JONGSEONG HIEUH-NIEUN");
+-   ("/xe1/x87/xb6", "HANGUL JONGSEONG HIEUH-RIEUL");
+-   ("/xe1/x87/xb7", "HANGUL JONGSEONG HIEUH-MIEUM");
+-   ("/xe1/x87/xb8", "HANGUL JONGSEONG HIEUH-PIEUP");
+-   ("/xe1/x87/xb9", "HANGUL JONGSEONG YEORINHIEUH");
+-   ("/xe1/x88/x80", "ETHIOPIC SYLLABLE HA");
+-   ("/xe1/x88/x81", "ETHIOPIC SYLLABLE HU");
+-   ("/xe1/x88/x82", "ETHIOPIC SYLLABLE HI");
+-   ("/xe1/x88/x83", "ETHIOPIC SYLLABLE HAA");
+-   ("/xe1/x88/x84", "ETHIOPIC SYLLABLE HEE");
+-   ("/xe1/x88/x85", "ETHIOPIC SYLLABLE HE");
+-   ("/xe1/x88/x86", "ETHIOPIC SYLLABLE HO");
+-   ("/xe1/x88/x87", "ETHIOPIC SYLLABLE HOA");
+-   ("/xe1/x88/x88", "ETHIOPIC SYLLABLE LA");
+-   ("/xe1/x88/x89", "ETHIOPIC SYLLABLE LU");
+-   ("/xe1/x88/x8a", "ETHIOPIC SYLLABLE LI");
+-   ("/xe1/x88/x8b", "ETHIOPIC SYLLABLE LAA");
+-   ("/xe1/x88/x8c", "ETHIOPIC SYLLABLE LEE");
+-   ("/xe1/x88/x8d", "ETHIOPIC SYLLABLE LE");
+-   ("/xe1/x88/x8e", "ETHIOPIC SYLLABLE LO");
+-   ("/xe1/x88/x8f", "ETHIOPIC SYLLABLE LWA");
+-   ("/xe1/x88/x90", "ETHIOPIC SYLLABLE HHA");
+-   ("/xe1/x88/x91", "ETHIOPIC SYLLABLE HHU");
+-   ("/xe1/x88/x92", "ETHIOPIC SYLLABLE HHI");
+-   ("/xe1/x88/x93", "ETHIOPIC SYLLABLE HHAA");
+-   ("/xe1/x88/x94", "ETHIOPIC SYLLABLE HHEE");
+-   ("/xe1/x88/x95", "ETHIOPIC SYLLABLE HHE");
+-   ("/xe1/x88/x96", "ETHIOPIC SYLLABLE HHO");
+-   ("/xe1/x88/x97", "ETHIOPIC SYLLABLE HHWA");
+-   ("/xe1/x88/x98", "ETHIOPIC SYLLABLE MA");
+-   ("/xe1/x88/x99", "ETHIOPIC SYLLABLE MU");
+-   ("/xe1/x88/x9a", "ETHIOPIC SYLLABLE MI");
+-   ("/xe1/x88/x9b", "ETHIOPIC SYLLABLE MAA");
+-   ("/xe1/x88/x9c", "ETHIOPIC SYLLABLE MEE");
+-   ("/xe1/x88/x9d", "ETHIOPIC SYLLABLE ME");
+-   ("/xe1/x88/x9e", "ETHIOPIC SYLLABLE MO");
+-   ("/xe1/x88/x9f", "ETHIOPIC SYLLABLE MWA");
+-   ("/xe1/x88/xa0", "ETHIOPIC SYLLABLE SZA");
+-   ("/xe1/x88/xa1", "ETHIOPIC SYLLABLE SZU");
+-   ("/xe1/x88/xa2", "ETHIOPIC SYLLABLE SZI");
+-   ("/xe1/x88/xa3", "ETHIOPIC SYLLABLE SZAA");
+-   ("/xe1/x88/xa4", "ETHIOPIC SYLLABLE SZEE");
+-   ("/xe1/x88/xa5", "ETHIOPIC SYLLABLE SZE");
+-   ("/xe1/x88/xa6", "ETHIOPIC SYLLABLE SZO");
+-   ("/xe1/x88/xa7", "ETHIOPIC SYLLABLE SZWA");
+-   ("/xe1/x88/xa8", "ETHIOPIC SYLLABLE RA");
+-   ("/xe1/x88/xa9", "ETHIOPIC SYLLABLE RU");
+-   ("/xe1/x88/xaa", "ETHIOPIC SYLLABLE RI");
+-   ("/xe1/x88/xab", "ETHIOPIC SYLLABLE RAA");
+-   ("/xe1/x88/xac", "ETHIOPIC SYLLABLE REE");
+-   ("/xe1/x88/xad", "ETHIOPIC SYLLABLE RE");
+-   ("/xe1/x88/xae", "ETHIOPIC SYLLABLE RO");
+-   ("/xe1/x88/xaf", "ETHIOPIC SYLLABLE RWA");
+-   ("/xe1/x88/xb0", "ETHIOPIC SYLLABLE SA");
+-   ("/xe1/x88/xb1", "ETHIOPIC SYLLABLE SU");
+-   ("/xe1/x88/xb2", "ETHIOPIC SYLLABLE SI");
+-   ("/xe1/x88/xb3", "ETHIOPIC SYLLABLE SAA");
+-   ("/xe1/x88/xb4", "ETHIOPIC SYLLABLE SEE");
+-   ("/xe1/x88/xb5", "ETHIOPIC SYLLABLE SE");
+-   ("/xe1/x88/xb6", "ETHIOPIC SYLLABLE SO");
+-   ("/xe1/x88/xb7", "ETHIOPIC SYLLABLE SWA");
+-   ("/xe1/x88/xb8", "ETHIOPIC SYLLABLE SHA");
+-   ("/xe1/x88/xb9", "ETHIOPIC SYLLABLE SHU");
+-   ("/xe1/x88/xba", "ETHIOPIC SYLLABLE SHI");
+-   ("/xe1/x88/xbb", "ETHIOPIC SYLLABLE SHAA");
+-   ("/xe1/x88/xbc", "ETHIOPIC SYLLABLE SHEE");
+-   ("/xe1/x88/xbd", "ETHIOPIC SYLLABLE SHE");
+-   ("/xe1/x88/xbe", "ETHIOPIC SYLLABLE SHO");
+-   ("/xe1/x88/xbf", "ETHIOPIC SYLLABLE SHWA");
+-   ("/xe1/x89/x80", "ETHIOPIC SYLLABLE QA");
+-   ("/xe1/x89/x81", "ETHIOPIC SYLLABLE QU");
+-   ("/xe1/x89/x82", "ETHIOPIC SYLLABLE QI");
+-   ("/xe1/x89/x83", "ETHIOPIC SYLLABLE QAA");
+-   ("/xe1/x89/x84", "ETHIOPIC SYLLABLE QEE");
+-   ("/xe1/x89/x85", "ETHIOPIC SYLLABLE QE");
+-   ("/xe1/x89/x86", "ETHIOPIC SYLLABLE QO");
+-   ("/xe1/x89/x87", "ETHIOPIC SYLLABLE QOA");
+-   ("/xe1/x89/x88", "ETHIOPIC SYLLABLE QWA");
+-   ("/xe1/x89/x8a", "ETHIOPIC SYLLABLE QWI");
+-   ("/xe1/x89/x8b", "ETHIOPIC SYLLABLE QWAA");
+-   ("/xe1/x89/x8c", "ETHIOPIC SYLLABLE QWEE");
+-   ("/xe1/x89/x8d", "ETHIOPIC SYLLABLE QWE");
+-   ("/xe1/x89/x90", "ETHIOPIC SYLLABLE QHA");
+-   ("/xe1/x89/x91", "ETHIOPIC SYLLABLE QHU");
+-   ("/xe1/x89/x92", "ETHIOPIC SYLLABLE QHI");
+-   ("/xe1/x89/x93", "ETHIOPIC SYLLABLE QHAA");
+-   ("/xe1/x89/x94", "ETHIOPIC SYLLABLE QHEE");
+-   ("/xe1/x89/x95", "ETHIOPIC SYLLABLE QHE");
+-   ("/xe1/x89/x96", "ETHIOPIC SYLLABLE QHO");
+-   ("/xe1/x89/x98", "ETHIOPIC SYLLABLE QHWA");
+-   ("/xe1/x89/x9a", "ETHIOPIC SYLLABLE QHWI");
+-   ("/xe1/x89/x9b", "ETHIOPIC SYLLABLE QHWAA");
+-   ("/xe1/x89/x9c", "ETHIOPIC SYLLABLE QHWEE");
+-   ("/xe1/x89/x9d", "ETHIOPIC SYLLABLE QHWE");
+-   ("/xe1/x89/xa0", "ETHIOPIC SYLLABLE BA");
+-   ("/xe1/x89/xa1", "ETHIOPIC SYLLABLE BU");
+-   ("/xe1/x89/xa2", "ETHIOPIC SYLLABLE BI");
+-   ("/xe1/x89/xa3", "ETHIOPIC SYLLABLE BAA");
+-   ("/xe1/x89/xa4", "ETHIOPIC SYLLABLE BEE");
+-   ("/xe1/x89/xa5", "ETHIOPIC SYLLABLE BE");
+-   ("/xe1/x89/xa6", "ETHIOPIC SYLLABLE BO");
+-   ("/xe1/x89/xa7", "ETHIOPIC SYLLABLE BWA");
+-   ("/xe1/x89/xa8", "ETHIOPIC SYLLABLE VA");
+-   ("/xe1/x89/xa9", "ETHIOPIC SYLLABLE VU");
+-   ("/xe1/x89/xaa", "ETHIOPIC SYLLABLE VI");
+-   ("/xe1/x89/xab", "ETHIOPIC SYLLABLE VAA");
+-   ("/xe1/x89/xac", "ETHIOPIC SYLLABLE VEE");
+-   ("/xe1/x89/xad", "ETHIOPIC SYLLABLE VE");
+-   ("/xe1/x89/xae", "ETHIOPIC SYLLABLE VO");
+-   ("/xe1/x89/xaf", "ETHIOPIC SYLLABLE VWA");
+-   ("/xe1/x89/xb0", "ETHIOPIC SYLLABLE TA");
+-   ("/xe1/x89/xb1", "ETHIOPIC SYLLABLE TU");
+-   ("/xe1/x89/xb2", "ETHIOPIC SYLLABLE TI");
+-   ("/xe1/x89/xb3", "ETHIOPIC SYLLABLE TAA");
+-   ("/xe1/x89/xb4", "ETHIOPIC SYLLABLE TEE");
+-   ("/xe1/x89/xb5", "ETHIOPIC SYLLABLE TE");
+-   ("/xe1/x89/xb6", "ETHIOPIC SYLLABLE TO");
+-   ("/xe1/x89/xb7", "ETHIOPIC SYLLABLE TWA");
+-   ("/xe1/x89/xb8", "ETHIOPIC SYLLABLE CA");
+-   ("/xe1/x89/xb9", "ETHIOPIC SYLLABLE CU");
+-   ("/xe1/x89/xba", "ETHIOPIC SYLLABLE CI");
+-   ("/xe1/x89/xbb", "ETHIOPIC SYLLABLE CAA");
+-   ("/xe1/x89/xbc", "ETHIOPIC SYLLABLE CEE");
+-   ("/xe1/x89/xbd", "ETHIOPIC SYLLABLE CE");
+-   ("/xe1/x89/xbe", "ETHIOPIC SYLLABLE CO");
+-   ("/xe1/x89/xbf", "ETHIOPIC SYLLABLE CWA");
+-   ("/xe1/x8a/x80", "ETHIOPIC SYLLABLE XA");
+-   ("/xe1/x8a/x81", "ETHIOPIC SYLLABLE XU");
+-   ("/xe1/x8a/x82", "ETHIOPIC SYLLABLE XI");
+-   ("/xe1/x8a/x83", "ETHIOPIC SYLLABLE XAA");
+-   ("/xe1/x8a/x84", "ETHIOPIC SYLLABLE XEE");
+-   ("/xe1/x8a/x85", "ETHIOPIC SYLLABLE XE");
+-   ("/xe1/x8a/x86", "ETHIOPIC SYLLABLE XO");
+-   ("/xe1/x8a/x87", "ETHIOPIC SYLLABLE XOA");
+-   ("/xe1/x8a/x88", "ETHIOPIC SYLLABLE XWA");
+-   ("/xe1/x8a/x8a", "ETHIOPIC SYLLABLE XWI");
+-   ("/xe1/x8a/x8b", "ETHIOPIC SYLLABLE XWAA");
+-   ("/xe1/x8a/x8c", "ETHIOPIC SYLLABLE XWEE");
+-   ("/xe1/x8a/x8d", "ETHIOPIC SYLLABLE XWE");
+-   ("/xe1/x8a/x90", "ETHIOPIC SYLLABLE NA");
+-   ("/xe1/x8a/x91", "ETHIOPIC SYLLABLE NU");
+-   ("/xe1/x8a/x92", "ETHIOPIC SYLLABLE NI");
+-   ("/xe1/x8a/x93", "ETHIOPIC SYLLABLE NAA");
+-   ("/xe1/x8a/x94", "ETHIOPIC SYLLABLE NEE");
+-   ("/xe1/x8a/x95", "ETHIOPIC SYLLABLE NE");
+-   ("/xe1/x8a/x96", "ETHIOPIC SYLLABLE NO");
+-   ("/xe1/x8a/x97", "ETHIOPIC SYLLABLE NWA");
+-   ("/xe1/x8a/x98", "ETHIOPIC SYLLABLE NYA");
+-   ("/xe1/x8a/x99", "ETHIOPIC SYLLABLE NYU");
+-   ("/xe1/x8a/x9a", "ETHIOPIC SYLLABLE NYI");
+-   ("/xe1/x8a/x9b", "ETHIOPIC SYLLABLE NYAA");
+-   ("/xe1/x8a/x9c", "ETHIOPIC SYLLABLE NYEE");
+-   ("/xe1/x8a/x9d", "ETHIOPIC SYLLABLE NYE");
+-   ("/xe1/x8a/x9e", "ETHIOPIC SYLLABLE NYO");
+-   ("/xe1/x8a/x9f", "ETHIOPIC SYLLABLE NYWA");
+-   ("/xe1/x8a/xa0", "ETHIOPIC SYLLABLE GLOTTAL A");
+-   ("/xe1/x8a/xa1", "ETHIOPIC SYLLABLE GLOTTAL U");
+-   ("/xe1/x8a/xa2", "ETHIOPIC SYLLABLE GLOTTAL I");
+-   ("/xe1/x8a/xa3", "ETHIOPIC SYLLABLE GLOTTAL AA");
+-   ("/xe1/x8a/xa4", "ETHIOPIC SYLLABLE GLOTTAL EE");
+-   ("/xe1/x8a/xa5", "ETHIOPIC SYLLABLE GLOTTAL E");
+-   ("/xe1/x8a/xa6", "ETHIOPIC SYLLABLE GLOTTAL O");
+-   ("/xe1/x8a/xa7", "ETHIOPIC SYLLABLE GLOTTAL WA");
+-   ("/xe1/x8a/xa8", "ETHIOPIC SYLLABLE KA");
+-   ("/xe1/x8a/xa9", "ETHIOPIC SYLLABLE KU");
+-   ("/xe1/x8a/xaa", "ETHIOPIC SYLLABLE KI");
+-   ("/xe1/x8a/xab", "ETHIOPIC SYLLABLE KAA");
+-   ("/xe1/x8a/xac", "ETHIOPIC SYLLABLE KEE");
+-   ("/xe1/x8a/xad", "ETHIOPIC SYLLABLE KE");
+-   ("/xe1/x8a/xae", "ETHIOPIC SYLLABLE KO");
+-   ("/xe1/x8a/xaf", "ETHIOPIC SYLLABLE KOA");
+-   ("/xe1/x8a/xb0", "ETHIOPIC SYLLABLE KWA");
+-   ("/xe1/x8a/xb2", "ETHIOPIC SYLLABLE KWI");
+-   ("/xe1/x8a/xb3", "ETHIOPIC SYLLABLE KWAA");
+-   ("/xe1/x8a/xb4", "ETHIOPIC SYLLABLE KWEE");
+-   ("/xe1/x8a/xb5", "ETHIOPIC SYLLABLE KWE");
+-   ("/xe1/x8a/xb8", "ETHIOPIC SYLLABLE KXA");
+-   ("/xe1/x8a/xb9", "ETHIOPIC SYLLABLE KXU");
+-   ("/xe1/x8a/xba", "ETHIOPIC SYLLABLE KXI");
+-   ("/xe1/x8a/xbb", "ETHIOPIC SYLLABLE KXAA");
+-   ("/xe1/x8a/xbc", "ETHIOPIC SYLLABLE KXEE");
+-   ("/xe1/x8a/xbd", "ETHIOPIC SYLLABLE KXE");
+-   ("/xe1/x8a/xbe", "ETHIOPIC SYLLABLE KXO");
+-   ("/xe1/x8b/x80", "ETHIOPIC SYLLABLE KXWA");
+-   ("/xe1/x8b/x82", "ETHIOPIC SYLLABLE KXWI");
+-   ("/xe1/x8b/x83", "ETHIOPIC SYLLABLE KXWAA");
+-   ("/xe1/x8b/x84", "ETHIOPIC SYLLABLE KXWEE");
+-   ("/xe1/x8b/x85", "ETHIOPIC SYLLABLE KXWE");
+-   ("/xe1/x8b/x88", "ETHIOPIC SYLLABLE WA");
+-   ("/xe1/x8b/x89", "ETHIOPIC SYLLABLE WU");
+-   ("/xe1/x8b/x8a", "ETHIOPIC SYLLABLE WI");
+-   ("/xe1/x8b/x8b", "ETHIOPIC SYLLABLE WAA");
+-   ("/xe1/x8b/x8c", "ETHIOPIC SYLLABLE WEE");
+-   ("/xe1/x8b/x8d", "ETHIOPIC SYLLABLE WE");
+-   ("/xe1/x8b/x8e", "ETHIOPIC SYLLABLE WO");
+-   ("/xe1/x8b/x8f", "ETHIOPIC SYLLABLE WOA");
+-   ("/xe1/x8b/x90", "ETHIOPIC SYLLABLE PHARYNGEAL A");
+-   ("/xe1/x8b/x91", "ETHIOPIC SYLLABLE PHARYNGEAL U");
+-   ("/xe1/x8b/x92", "ETHIOPIC SYLLABLE PHARYNGEAL I");
+-   ("/xe1/x8b/x93", "ETHIOPIC SYLLABLE PHARYNGEAL AA");
+-   ("/xe1/x8b/x94", "ETHIOPIC SYLLABLE PHARYNGEAL EE");
+-   ("/xe1/x8b/x95", "ETHIOPIC SYLLABLE PHARYNGEAL E");
+-   ("/xe1/x8b/x96", "ETHIOPIC SYLLABLE PHARYNGEAL O");
+-   ("/xe1/x8b/x98", "ETHIOPIC SYLLABLE ZA");
+-   ("/xe1/x8b/x99", "ETHIOPIC SYLLABLE ZU");
+-   ("/xe1/x8b/x9a", "ETHIOPIC SYLLABLE ZI");
+-   ("/xe1/x8b/x9b", "ETHIOPIC SYLLABLE ZAA");
+-   ("/xe1/x8b/x9c", "ETHIOPIC SYLLABLE ZEE");
+-   ("/xe1/x8b/x9d", "ETHIOPIC SYLLABLE ZE");
+-   ("/xe1/x8b/x9e", "ETHIOPIC SYLLABLE ZO");
+-   ("/xe1/x8b/x9f", "ETHIOPIC SYLLABLE ZWA");
+-   ("/xe1/x8b/xa0", "ETHIOPIC SYLLABLE ZHA");
+-   ("/xe1/x8b/xa1", "ETHIOPIC SYLLABLE ZHU");
+-   ("/xe1/x8b/xa2", "ETHIOPIC SYLLABLE ZHI");
+-   ("/xe1/x8b/xa3", "ETHIOPIC SYLLABLE ZHAA");
+-   ("/xe1/x8b/xa4", "ETHIOPIC SYLLABLE ZHEE");
+-   ("/xe1/x8b/xa5", "ETHIOPIC SYLLABLE ZHE");
+-   ("/xe1/x8b/xa6", "ETHIOPIC SYLLABLE ZHO");
+-   ("/xe1/x8b/xa7", "ETHIOPIC SYLLABLE ZHWA");
+-   ("/xe1/x8b/xa8", "ETHIOPIC SYLLABLE YA");
+-   ("/xe1/x8b/xa9", "ETHIOPIC SYLLABLE YU");
+-   ("/xe1/x8b/xaa", "ETHIOPIC SYLLABLE YI");
+-   ("/xe1/x8b/xab", "ETHIOPIC SYLLABLE YAA");
+-   ("/xe1/x8b/xac", "ETHIOPIC SYLLABLE YEE");
+-   ("/xe1/x8b/xad", "ETHIOPIC SYLLABLE YE");
+-   ("/xe1/x8b/xae", "ETHIOPIC SYLLABLE YO");
+-   ("/xe1/x8b/xaf", "ETHIOPIC SYLLABLE YOA");
+-   ("/xe1/x8b/xb0", "ETHIOPIC SYLLABLE DA");
+-   ("/xe1/x8b/xb1", "ETHIOPIC SYLLABLE DU");
+-   ("/xe1/x8b/xb2", "ETHIOPIC SYLLABLE DI");
+-   ("/xe1/x8b/xb3", "ETHIOPIC SYLLABLE DAA");
+-   ("/xe1/x8b/xb4", "ETHIOPIC SYLLABLE DEE");
+-   ("/xe1/x8b/xb5", "ETHIOPIC SYLLABLE DE");
+-   ("/xe1/x8b/xb6", "ETHIOPIC SYLLABLE DO");
+-   ("/xe1/x8b/xb7", "ETHIOPIC SYLLABLE DWA");
+-   ("/xe1/x8b/xb8", "ETHIOPIC SYLLABLE DDA");
+-   ("/xe1/x8b/xb9", "ETHIOPIC SYLLABLE DDU");
+-   ("/xe1/x8b/xba", "ETHIOPIC SYLLABLE DDI");
+-   ("/xe1/x8b/xbb", "ETHIOPIC SYLLABLE DDAA");
+-   ("/xe1/x8b/xbc", "ETHIOPIC SYLLABLE DDEE");
+-   ("/xe1/x8b/xbd", "ETHIOPIC SYLLABLE DDE");
+-   ("/xe1/x8b/xbe", "ETHIOPIC SYLLABLE DDO");
+-   ("/xe1/x8b/xbf", "ETHIOPIC SYLLABLE DDWA");
+-   ("/xe1/x8c/x80", "ETHIOPIC SYLLABLE JA");
+-   ("/xe1/x8c/x81", "ETHIOPIC SYLLABLE JU");
+-   ("/xe1/x8c/x82", "ETHIOPIC SYLLABLE JI");
+-   ("/xe1/x8c/x83", "ETHIOPIC SYLLABLE JAA");
+-   ("/xe1/x8c/x84", "ETHIOPIC SYLLABLE JEE");
+-   ("/xe1/x8c/x85", "ETHIOPIC SYLLABLE JE");
+-   ("/xe1/x8c/x86", "ETHIOPIC SYLLABLE JO");
+-   ("/xe1/x8c/x87", "ETHIOPIC SYLLABLE JWA");
+-   ("/xe1/x8c/x88", "ETHIOPIC SYLLABLE GA");
+-   ("/xe1/x8c/x89", "ETHIOPIC SYLLABLE GU");
+-   ("/xe1/x8c/x8a", "ETHIOPIC SYLLABLE GI");
+-   ("/xe1/x8c/x8b", "ETHIOPIC SYLLABLE GAA");
+-   ("/xe1/x8c/x8c", "ETHIOPIC SYLLABLE GEE");
+-   ("/xe1/x8c/x8d", "ETHIOPIC SYLLABLE GE");
+-   ("/xe1/x8c/x8e", "ETHIOPIC SYLLABLE GO");
+-   ("/xe1/x8c/x8f", "ETHIOPIC SYLLABLE GOA");
+-   ("/xe1/x8c/x90", "ETHIOPIC SYLLABLE GWA");
+-   ("/xe1/x8c/x92", "ETHIOPIC SYLLABLE GWI");
+-   ("/xe1/x8c/x93", "ETHIOPIC SYLLABLE GWAA");
+-   ("/xe1/x8c/x94", "ETHIOPIC SYLLABLE GWEE");
+-   ("/xe1/x8c/x95", "ETHIOPIC SYLLABLE GWE");
+-   ("/xe1/x8c/x98", "ETHIOPIC SYLLABLE GGA");
+-   ("/xe1/x8c/x99", "ETHIOPIC SYLLABLE GGU");
+-   ("/xe1/x8c/x9a", "ETHIOPIC SYLLABLE GGI");
+-   ("/xe1/x8c/x9b", "ETHIOPIC SYLLABLE GGAA");
+-   ("/xe1/x8c/x9c", "ETHIOPIC SYLLABLE GGEE");
+-   ("/xe1/x8c/x9d", "ETHIOPIC SYLLABLE GGE");
+-   ("/xe1/x8c/x9e", "ETHIOPIC SYLLABLE GGO");
+-   ("/xe1/x8c/x9f", "ETHIOPIC SYLLABLE GGWAA");
+-   ("/xe1/x8c/xa0", "ETHIOPIC SYLLABLE THA");
+-   ("/xe1/x8c/xa1", "ETHIOPIC SYLLABLE THU");
+-   ("/xe1/x8c/xa2", "ETHIOPIC SYLLABLE THI");
+-   ("/xe1/x8c/xa3", "ETHIOPIC SYLLABLE THAA");
+-   ("/xe1/x8c/xa4", "ETHIOPIC SYLLABLE THEE");
+-   ("/xe1/x8c/xa5", "ETHIOPIC SYLLABLE THE");
+-   ("/xe1/x8c/xa6", "ETHIOPIC SYLLABLE THO");
+-   ("/xe1/x8c/xa7", "ETHIOPIC SYLLABLE THWA");
+-   ("/xe1/x8c/xa8", "ETHIOPIC SYLLABLE CHA");
+-   ("/xe1/x8c/xa9", "ETHIOPIC SYLLABLE CHU");
+-   ("/xe1/x8c/xaa", "ETHIOPIC SYLLABLE CHI");
+-   ("/xe1/x8c/xab", "ETHIOPIC SYLLABLE CHAA");
+-   ("/xe1/x8c/xac", "ETHIOPIC SYLLABLE CHEE");
+-   ("/xe1/x8c/xad", "ETHIOPIC SYLLABLE CHE");
+-   ("/xe1/x8c/xae", "ETHIOPIC SYLLABLE CHO");
+-   ("/xe1/x8c/xaf", "ETHIOPIC SYLLABLE CHWA");
+-   ("/xe1/x8c/xb0", "ETHIOPIC SYLLABLE PHA");
+-   ("/xe1/x8c/xb1", "ETHIOPIC SYLLABLE PHU");
+-   ("/xe1/x8c/xb2", "ETHIOPIC SYLLABLE PHI");
+-   ("/xe1/x8c/xb3", "ETHIOPIC SYLLABLE PHAA");
+-   ("/xe1/x8c/xb4", "ETHIOPIC SYLLABLE PHEE");
+-   ("/xe1/x8c/xb5", "ETHIOPIC SYLLABLE PHE");
+-   ("/xe1/x8c/xb6", "ETHIOPIC SYLLABLE PHO");
+-   ("/xe1/x8c/xb7", "ETHIOPIC SYLLABLE PHWA");
+-   ("/xe1/x8c/xb8", "ETHIOPIC SYLLABLE TSA");
+-   ("/xe1/x8c/xb9", "ETHIOPIC SYLLABLE TSU");
+-   ("/xe1/x8c/xba", "ETHIOPIC SYLLABLE TSI");
+-   ("/xe1/x8c/xbb", "ETHIOPIC SYLLABLE TSAA");
+-   ("/xe1/x8c/xbc", "ETHIOPIC SYLLABLE TSEE");
+-   ("/xe1/x8c/xbd", "ETHIOPIC SYLLABLE TSE");
+-   ("/xe1/x8c/xbe", "ETHIOPIC SYLLABLE TSO");
+-   ("/xe1/x8c/xbf", "ETHIOPIC SYLLABLE TSWA");
+-   ("/xe1/x8d/x80", "ETHIOPIC SYLLABLE TZA");
+-   ("/xe1/x8d/x81", "ETHIOPIC SYLLABLE TZU");
+-   ("/xe1/x8d/x82", "ETHIOPIC SYLLABLE TZI");
+-   ("/xe1/x8d/x83", "ETHIOPIC SYLLABLE TZAA");
+-   ("/xe1/x8d/x84", "ETHIOPIC SYLLABLE TZEE");
+-   ("/xe1/x8d/x85", "ETHIOPIC SYLLABLE TZE");
+-   ("/xe1/x8d/x86", "ETHIOPIC SYLLABLE TZO");
+-   ("/xe1/x8d/x87", "ETHIOPIC SYLLABLE TZOA");
+-   ("/xe1/x8d/x88", "ETHIOPIC SYLLABLE FA");
+-   ("/xe1/x8d/x89", "ETHIOPIC SYLLABLE FU");
+-   ("/xe1/x8d/x8a", "ETHIOPIC SYLLABLE FI");
+-   ("/xe1/x8d/x8b", "ETHIOPIC SYLLABLE FAA");
+-   ("/xe1/x8d/x8c", "ETHIOPIC SYLLABLE FEE");
+-   ("/xe1/x8d/x8d", "ETHIOPIC SYLLABLE FE");
+-   ("/xe1/x8d/x8e", "ETHIOPIC SYLLABLE FO");
+-   ("/xe1/x8d/x8f", "ETHIOPIC SYLLABLE FWA");
+-   ("/xe1/x8d/x90", "ETHIOPIC SYLLABLE PA");
+-   ("/xe1/x8d/x91", "ETHIOPIC SYLLABLE PU");
+-   ("/xe1/x8d/x92", "ETHIOPIC SYLLABLE PI");
+-   ("/xe1/x8d/x93", "ETHIOPIC SYLLABLE PAA");
+-   ("/xe1/x8d/x94", "ETHIOPIC SYLLABLE PEE");
+-   ("/xe1/x8d/x95", "ETHIOPIC SYLLABLE PE");
+-   ("/xe1/x8d/x96", "ETHIOPIC SYLLABLE PO");
+-   ("/xe1/x8d/x97", "ETHIOPIC SYLLABLE PWA");
+-   ("/xe1/x8d/x98", "ETHIOPIC SYLLABLE RYA");
+-   ("/xe1/x8d/x99", "ETHIOPIC SYLLABLE MYA");
+-   ("/xe1/x8d/x9a", "ETHIOPIC SYLLABLE FYA");
+-   ("/xe1/x8d/x9f", "ETHIOPIC COMBINING GEMINATION MARK");
+-   ("/xe1/x8d/xa0", "ETHIOPIC SECTION MARK");
+-   ("/xe1/x8d/xa1", "ETHIOPIC WORDSPACE");
+-   ("/xe1/x8d/xa2", "ETHIOPIC FULL STOP");
+-   ("/xe1/x8d/xa3", "ETHIOPIC COMMA");
+-   ("/xe1/x8d/xa4", "ETHIOPIC SEMICOLON");
+-   ("/xe1/x8d/xa5", "ETHIOPIC COLON");
+-   ("/xe1/x8d/xa6", "ETHIOPIC PREFACE COLON");
+-   ("/xe1/x8d/xa7", "ETHIOPIC QUESTION MARK");
+-   ("/xe1/x8d/xa8", "ETHIOPIC PARAGRAPH SEPARATOR");
+-   ("/xe1/x8d/xa9", "ETHIOPIC DIGIT ONE");
+-   ("/xe1/x8d/xaa", "ETHIOPIC DIGIT TWO");
+-   ("/xe1/x8d/xab", "ETHIOPIC DIGIT THREE");
+-   ("/xe1/x8d/xac", "ETHIOPIC DIGIT FOUR");
+-   ("/xe1/x8d/xad", "ETHIOPIC DIGIT FIVE");
+-   ("/xe1/x8d/xae", "ETHIOPIC DIGIT SIX");
+-   ("/xe1/x8d/xaf", "ETHIOPIC DIGIT SEVEN");
+-   ("/xe1/x8d/xb0", "ETHIOPIC DIGIT EIGHT");
+-   ("/xe1/x8d/xb1", "ETHIOPIC DIGIT NINE");
+-   ("/xe1/x8d/xb2", "ETHIOPIC NUMBER TEN");
+-   ("/xe1/x8d/xb3", "ETHIOPIC NUMBER TWENTY");
+-   ("/xe1/x8d/xb4", "ETHIOPIC NUMBER THIRTY");
+-   ("/xe1/x8d/xb5", "ETHIOPIC NUMBER FORTY");
+-   ("/xe1/x8d/xb6", "ETHIOPIC NUMBER FIFTY");
+-   ("/xe1/x8d/xb7", "ETHIOPIC NUMBER SIXTY");
+-   ("/xe1/x8d/xb8", "ETHIOPIC NUMBER SEVENTY");
+-   ("/xe1/x8d/xb9", "ETHIOPIC NUMBER EIGHTY");
+-   ("/xe1/x8d/xba", "ETHIOPIC NUMBER NINETY");
+-   ("/xe1/x8d/xbb", "ETHIOPIC NUMBER HUNDRED");
+-   ("/xe1/x8d/xbc", "ETHIOPIC NUMBER TEN THOUSAND");
+-   ("/xe1/x8e/x80", "ETHIOPIC SYLLABLE SEBATBEIT MWA");
+-   ("/xe1/x8e/x81", "ETHIOPIC SYLLABLE MWI");
+-   ("/xe1/x8e/x82", "ETHIOPIC SYLLABLE MWEE");
+-   ("/xe1/x8e/x83", "ETHIOPIC SYLLABLE MWE");
+-   ("/xe1/x8e/x84", "ETHIOPIC SYLLABLE SEBATBEIT BWA");
+-   ("/xe1/x8e/x85", "ETHIOPIC SYLLABLE BWI");
+-   ("/xe1/x8e/x86", "ETHIOPIC SYLLABLE BWEE");
+-   ("/xe1/x8e/x87", "ETHIOPIC SYLLABLE BWE");
+-   ("/xe1/x8e/x88", "ETHIOPIC SYLLABLE SEBATBEIT FWA");
+-   ("/xe1/x8e/x89", "ETHIOPIC SYLLABLE FWI");
+-   ("/xe1/x8e/x8a", "ETHIOPIC SYLLABLE FWEE");
+-   ("/xe1/x8e/x8b", "ETHIOPIC SYLLABLE FWE");
+-   ("/xe1/x8e/x8c", "ETHIOPIC SYLLABLE SEBATBEIT PWA");
+-   ("/xe1/x8e/x8d", "ETHIOPIC SYLLABLE PWI");
+-   ("/xe1/x8e/x8e", "ETHIOPIC SYLLABLE PWEE");
+-   ("/xe1/x8e/x8f", "ETHIOPIC SYLLABLE PWE");
+-   ("/xe1/x8e/x90", "ETHIOPIC TONAL MARK YIZET");
+-   ("/xe1/x8e/x91", "ETHIOPIC TONAL MARK DERET");
+-   ("/xe1/x8e/x92", "ETHIOPIC TONAL MARK RIKRIK");
+-   ("/xe1/x8e/x93", "ETHIOPIC TONAL MARK SHORT RIKRIK");
+-   ("/xe1/x8e/x94", "ETHIOPIC TONAL MARK DIFAT");
+-   ("/xe1/x8e/x95", "ETHIOPIC TONAL MARK KENAT");
+-   ("/xe1/x8e/x96", "ETHIOPIC TONAL MARK CHIRET");
+-   ("/xe1/x8e/x97", "ETHIOPIC TONAL MARK HIDET");
+-   ("/xe1/x8e/x98", "ETHIOPIC TONAL MARK DERET-HIDET");
+-   ("/xe1/x8e/x99", "ETHIOPIC TONAL MARK KURT");
+-   ("/xe1/x8e/xa0", "CHEROKEE LETTER A");
+-   ("/xe1/x8e/xa1", "CHEROKEE LETTER E");
+-   ("/xe1/x8e/xa2", "CHEROKEE LETTER I");
+-   ("/xe1/x8e/xa3", "CHEROKEE LETTER O");
+-   ("/xe1/x8e/xa4", "CHEROKEE LETTER U");
+-   ("/xe1/x8e/xa5", "CHEROKEE LETTER V");
+-   ("/xe1/x8e/xa6", "CHEROKEE LETTER GA");
+-   ("/xe1/x8e/xa7", "CHEROKEE LETTER KA");
+-   ("/xe1/x8e/xa8", "CHEROKEE LETTER GE");
+-   ("/xe1/x8e/xa9", "CHEROKEE LETTER GI");
+-   ("/xe1/x8e/xaa", "CHEROKEE LETTER GO");
+-   ("/xe1/x8e/xab", "CHEROKEE LETTER GU");
+-   ("/xe1/x8e/xac", "CHEROKEE LETTER GV");
+-   ("/xe1/x8e/xad", "CHEROKEE LETTER HA");
+-   ("/xe1/x8e/xae", "CHEROKEE LETTER HE");
+-   ("/xe1/x8e/xaf", "CHEROKEE LETTER HI");
+-   ("/xe1/x8e/xb0", "CHEROKEE LETTER HO");
+-   ("/xe1/x8e/xb1", "CHEROKEE LETTER HU");
+-   ("/xe1/x8e/xb2", "CHEROKEE LETTER HV");
+-   ("/xe1/x8e/xb3", "CHEROKEE LETTER LA");
+-   ("/xe1/x8e/xb4", "CHEROKEE LETTER LE");
+-   ("/xe1/x8e/xb5", "CHEROKEE LETTER LI");
+-   ("/xe1/x8e/xb6", "CHEROKEE LETTER LO");
+-   ("/xe1/x8e/xb7", "CHEROKEE LETTER LU");
+-   ("/xe1/x8e/xb8", "CHEROKEE LETTER LV");
+-   ("/xe1/x8e/xb9", "CHEROKEE LETTER MA");
+-   ("/xe1/x8e/xba", "CHEROKEE LETTER ME");
+-   ("/xe1/x8e/xbb", "CHEROKEE LETTER MI");
+-   ("/xe1/x8e/xbc", "CHEROKEE LETTER MO");
+-   ("/xe1/x8e/xbd", "CHEROKEE LETTER MU");
+-   ("/xe1/x8e/xbe", "CHEROKEE LETTER NA");
+-   ("/xe1/x8e/xbf", "CHEROKEE LETTER HNA");
+-   ("/xe1/x8f/x80", "CHEROKEE LETTER NAH");
+-   ("/xe1/x8f/x81", "CHEROKEE LETTER NE");
+-   ("/xe1/x8f/x82", "CHEROKEE LETTER NI");
+-   ("/xe1/x8f/x83", "CHEROKEE LETTER NO");
+-   ("/xe1/x8f/x84", "CHEROKEE LETTER NU");
+-   ("/xe1/x8f/x85", "CHEROKEE LETTER NV");
+-   ("/xe1/x8f/x86", "CHEROKEE LETTER QUA");
+-   ("/xe1/x8f/x87", "CHEROKEE LETTER QUE");
+-   ("/xe1/x8f/x88", "CHEROKEE LETTER QUI");
+-   ("/xe1/x8f/x89", "CHEROKEE LETTER QUO");
+-   ("/xe1/x8f/x8a", "CHEROKEE LETTER QUU");
+-   ("/xe1/x8f/x8b", "CHEROKEE LETTER QUV");
+-   ("/xe1/x8f/x8c", "CHEROKEE LETTER SA");
+-   ("/xe1/x8f/x8d", "CHEROKEE LETTER S");
+-   ("/xe1/x8f/x8e", "CHEROKEE LETTER SE");
+-   ("/xe1/x8f/x8f", "CHEROKEE LETTER SI");
+-   ("/xe1/x8f/x90", "CHEROKEE LETTER SO");
+-   ("/xe1/x8f/x91", "CHEROKEE LETTER SU");
+-   ("/xe1/x8f/x92", "CHEROKEE LETTER SV");
+-   ("/xe1/x8f/x93", "CHEROKEE LETTER DA");
+-   ("/xe1/x8f/x94", "CHEROKEE LETTER TA");
+-   ("/xe1/x8f/x95", "CHEROKEE LETTER DE");
+-   ("/xe1/x8f/x96", "CHEROKEE LETTER TE");
+-   ("/xe1/x8f/x97", "CHEROKEE LETTER DI");
+-   ("/xe1/x8f/x98", "CHEROKEE LETTER TI");
+-   ("/xe1/x8f/x99", "CHEROKEE LETTER DO");
+-   ("/xe1/x8f/x9a", "CHEROKEE LETTER DU");
+-   ("/xe1/x8f/x9b", "CHEROKEE LETTER DV");
+-   ("/xe1/x8f/x9c", "CHEROKEE LETTER DLA");
+-   ("/xe1/x8f/x9d", "CHEROKEE LETTER TLA");
+-   ("/xe1/x8f/x9e", "CHEROKEE LETTER TLE");
+-   ("/xe1/x8f/x9f", "CHEROKEE LETTER TLI");
+-   ("/xe1/x8f/xa0", "CHEROKEE LETTER TLO");
+-   ("/xe1/x8f/xa1", "CHEROKEE LETTER TLU");
+-   ("/xe1/x8f/xa2", "CHEROKEE LETTER TLV");
+-   ("/xe1/x8f/xa3", "CHEROKEE LETTER TSA");
+-   ("/xe1/x8f/xa4", "CHEROKEE LETTER TSE");
+-   ("/xe1/x8f/xa5", "CHEROKEE LETTER TSI");
+-   ("/xe1/x8f/xa6", "CHEROKEE LETTER TSO");
+-   ("/xe1/x8f/xa7", "CHEROKEE LETTER TSU");
+-   ("/xe1/x8f/xa8", "CHEROKEE LETTER TSV");
+-   ("/xe1/x8f/xa9", "CHEROKEE LETTER WA");
+-   ("/xe1/x8f/xaa", "CHEROKEE LETTER WE");
+-   ("/xe1/x8f/xab", "CHEROKEE LETTER WI");
+-   ("/xe1/x8f/xac", "CHEROKEE LETTER WO");
+-   ("/xe1/x8f/xad", "CHEROKEE LETTER WU");
+-   ("/xe1/x8f/xae", "CHEROKEE LETTER WV");
+-   ("/xe1/x8f/xaf", "CHEROKEE LETTER YA");
+-   ("/xe1/x8f/xb0", "CHEROKEE LETTER YE");
+-   ("/xe1/x8f/xb1", "CHEROKEE LETTER YI");
+-   ("/xe1/x8f/xb2", "CHEROKEE LETTER YO");
+-   ("/xe1/x8f/xb3", "CHEROKEE LETTER YU");
+-   ("/xe1/x8f/xb4", "CHEROKEE LETTER YV");
+-   ("/xe1/x90/x81", "CANADIAN SYLLABICS E");
+-   ("/xe1/x90/x82", "CANADIAN SYLLABICS AAI");
+-   ("/xe1/x90/x83", "CANADIAN SYLLABICS I");
+-   ("/xe1/x90/x84", "CANADIAN SYLLABICS II");
+-   ("/xe1/x90/x85", "CANADIAN SYLLABICS O");
+-   ("/xe1/x90/x86", "CANADIAN SYLLABICS OO");
+-   ("/xe1/x90/x87", "CANADIAN SYLLABICS Y-CREE OO");
+-   ("/xe1/x90/x88", "CANADIAN SYLLABICS CARRIER EE");
+-   ("/xe1/x90/x89", "CANADIAN SYLLABICS CARRIER I");
+-   ("/xe1/x90/x8a", "CANADIAN SYLLABICS A");
+-   ("/xe1/x90/x8b", "CANADIAN SYLLABICS AA");
+-   ("/xe1/x90/x8c", "CANADIAN SYLLABICS WE");
+-   ("/xe1/x90/x8d", "CANADIAN SYLLABICS WEST-CREE WE");
+-   ("/xe1/x90/x8e", "CANADIAN SYLLABICS WI");
+-   ("/xe1/x90/x8f", "CANADIAN SYLLABICS WEST-CREE WI");
+-   ("/xe1/x90/x90", "CANADIAN SYLLABICS WII");
+-   ("/xe1/x90/x91", "CANADIAN SYLLABICS WEST-CREE WII");
+-   ("/xe1/x90/x92", "CANADIAN SYLLABICS WO");
+-   ("/xe1/x90/x93", "CANADIAN SYLLABICS WEST-CREE WO");
+-   ("/xe1/x90/x94", "CANADIAN SYLLABICS WOO");
+-   ("/xe1/x90/x95", "CANADIAN SYLLABICS WEST-CREE WOO");
+-   ("/xe1/x90/x96", "CANADIAN SYLLABICS NASKAPI WOO");
+-   ("/xe1/x90/x97", "CANADIAN SYLLABICS WA");
+-   ("/xe1/x90/x98", "CANADIAN SYLLABICS WEST-CREE WA");
+-   ("/xe1/x90/x99", "CANADIAN SYLLABICS WAA");
+-   ("/xe1/x90/x9a", "CANADIAN SYLLABICS WEST-CREE WAA");
+-   ("/xe1/x90/x9b", "CANADIAN SYLLABICS NASKAPI WAA");
+-   ("/xe1/x90/x9c", "CANADIAN SYLLABICS AI");
+-   ("/xe1/x90/x9d", "CANADIAN SYLLABICS Y-CREE W");
+-   ("/xe1/x90/x9e", "CANADIAN SYLLABICS GLOTTAL STOP");
+-   ("/xe1/x90/x9f", "CANADIAN SYLLABICS FINAL ACUTE");
+-   ("/xe1/x90/xa0", "CANADIAN SYLLABICS FINAL GRAVE");
+-   ("/xe1/x90/xa1", "CANADIAN SYLLABICS FINAL BOTTOM HALF RING");
+-   ("/xe1/x90/xa2", "CANADIAN SYLLABICS FINAL TOP HALF RING");
+-   ("/xe1/x90/xa3", "CANADIAN SYLLABICS FINAL RIGHT HALF RING");
+-   ("/xe1/x90/xa4", "CANADIAN SYLLABICS FINAL RING");
+-   ("/xe1/x90/xa5", "CANADIAN SYLLABICS FINAL DOUBLE ACUTE");
+-   ("/xe1/x90/xa6", "CANADIAN SYLLABICS FINAL DOUBLE SHORT VERTICAL STROKES");
+-   ("/xe1/x90/xa7", "CANADIAN SYLLABICS FINAL MIDDLE DOT");
+-   ("/xe1/x90/xa8", "CANADIAN SYLLABICS FINAL SHORT HORIZONTAL STROKE");
+-   ("/xe1/x90/xa9", "CANADIAN SYLLABICS FINAL PLUS");
+-   ("/xe1/x90/xaa", "CANADIAN SYLLABICS FINAL DOWN TACK");
+-   ("/xe1/x90/xab", "CANADIAN SYLLABICS EN");
+-   ("/xe1/x90/xac", "CANADIAN SYLLABICS IN");
+-   ("/xe1/x90/xad", "CANADIAN SYLLABICS ON");
+-   ("/xe1/x90/xae", "CANADIAN SYLLABICS AN");
+-   ("/xe1/x90/xaf", "CANADIAN SYLLABICS PE");
+-   ("/xe1/x90/xb0", "CANADIAN SYLLABICS PAAI");
+-   ("/xe1/x90/xb1", "CANADIAN SYLLABICS PI");
+-   ("/xe1/x90/xb2", "CANADIAN SYLLABICS PII");
+-   ("/xe1/x90/xb3", "CANADIAN SYLLABICS PO");
+-   ("/xe1/x90/xb4", "CANADIAN SYLLABICS POO");
+-   ("/xe1/x90/xb5", "CANADIAN SYLLABICS Y-CREE POO");
+-   ("/xe1/x90/xb6", "CANADIAN SYLLABICS CARRIER HEE");
+-   ("/xe1/x90/xb7", "CANADIAN SYLLABICS CARRIER HI");
+-   ("/xe1/x90/xb8", "CANADIAN SYLLABICS PA");
+-   ("/xe1/x90/xb9", "CANADIAN SYLLABICS PAA");
+-   ("/xe1/x90/xba", "CANADIAN SYLLABICS PWE");
+-   ("/xe1/x90/xbb", "CANADIAN SYLLABICS WEST-CREE PWE");
+-   ("/xe1/x90/xbc", "CANADIAN SYLLABICS PWI");
+-   ("/xe1/x90/xbd", "CANADIAN SYLLABICS WEST-CREE PWI");
+-   ("/xe1/x90/xbe", "CANADIAN SYLLABICS PWII");
+-   ("/xe1/x90/xbf", "CANADIAN SYLLABICS WEST-CREE PWII");
+-   ("/xe1/x91/x80", "CANADIAN SYLLABICS PWO");
+-   ("/xe1/x91/x81", "CANADIAN SYLLABICS WEST-CREE PWO");
+-   ("/xe1/x91/x82", "CANADIAN SYLLABICS PWOO");
+-   ("/xe1/x91/x83", "CANADIAN SYLLABICS WEST-CREE PWOO");
+-   ("/xe1/x91/x84", "CANADIAN SYLLABICS PWA");
+-   ("/xe1/x91/x85", "CANADIAN SYLLABICS WEST-CREE PWA");
+-   ("/xe1/x91/x86", "CANADIAN SYLLABICS PWAA");
+-   ("/xe1/x91/x87", "CANADIAN SYLLABICS WEST-CREE PWAA");
+-   ("/xe1/x91/x88", "CANADIAN SYLLABICS Y-CREE PWAA");
+-   ("/xe1/x91/x89", "CANADIAN SYLLABICS P");
+-   ("/xe1/x91/x8a", "CANADIAN SYLLABICS WEST-CREE P");
+-   ("/xe1/x91/x8b", "CANADIAN SYLLABICS CARRIER H");
+-   ("/xe1/x91/x8c", "CANADIAN SYLLABICS TE");
+-   ("/xe1/x91/x8d", "CANADIAN SYLLABICS TAAI");
+-   ("/xe1/x91/x8e", "CANADIAN SYLLABICS TI");
+-   ("/xe1/x91/x8f", "CANADIAN SYLLABICS TII");
+-   ("/xe1/x91/x90", "CANADIAN SYLLABICS TO");
+-   ("/xe1/x91/x91", "CANADIAN SYLLABICS TOO");
+-   ("/xe1/x91/x92", "CANADIAN SYLLABICS Y-CREE TOO");
+-   ("/xe1/x91/x93", "CANADIAN SYLLABICS CARRIER DEE");
+-   ("/xe1/x91/x94", "CANADIAN SYLLABICS CARRIER DI");
+-   ("/xe1/x91/x95", "CANADIAN SYLLABICS TA");
+-   ("/xe1/x91/x96", "CANADIAN SYLLABICS TAA");
+-   ("/xe1/x91/x97", "CANADIAN SYLLABICS TWE");
+-   ("/xe1/x91/x98", "CANADIAN SYLLABICS WEST-CREE TWE");
+-   ("/xe1/x91/x99", "CANADIAN SYLLABICS TWI");
+-   ("/xe1/x91/x9a", "CANADIAN SYLLABICS WEST-CREE TWI");
+-   ("/xe1/x91/x9b", "CANADIAN SYLLABICS TWII");
+-   ("/xe1/x91/x9c", "CANADIAN SYLLABICS WEST-CREE TWII");
+-   ("/xe1/x91/x9d", "CANADIAN SYLLABICS TWO");
+-   ("/xe1/x91/x9e", "CANADIAN SYLLABICS WEST-CREE TWO");
+-   ("/xe1/x91/x9f", "CANADIAN SYLLABICS TWOO");
+-   ("/xe1/x91/xa0", "CANADIAN SYLLABICS WEST-CREE TWOO");
+-   ("/xe1/x91/xa1", "CANADIAN SYLLABICS TWA");
+-   ("/xe1/x91/xa2", "CANADIAN SYLLABICS WEST-CREE TWA");
+-   ("/xe1/x91/xa3", "CANADIAN SYLLABICS TWAA");
+-   ("/xe1/x91/xa4", "CANADIAN SYLLABICS WEST-CREE TWAA");
+-   ("/xe1/x91/xa5", "CANADIAN SYLLABICS NASKAPI TWAA");
+-   ("/xe1/x91/xa6", "CANADIAN SYLLABICS T");
+-   ("/xe1/x91/xa7", "CANADIAN SYLLABICS TTE");
+-   ("/xe1/x91/xa8", "CANADIAN SYLLABICS TTI");
+-   ("/xe1/x91/xa9", "CANADIAN SYLLABICS TTO");
+-   ("/xe1/x91/xaa", "CANADIAN SYLLABICS TTA");
+-   ("/xe1/x91/xab", "CANADIAN SYLLABICS KE");
+-   ("/xe1/x91/xac", "CANADIAN SYLLABICS KAAI");
+-   ("/xe1/x91/xad", "CANADIAN SYLLABICS KI");
+-   ("/xe1/x91/xae", "CANADIAN SYLLABICS KII");
+-   ("/xe1/x91/xaf", "CANADIAN SYLLABICS KO");
+-   ("/xe1/x91/xb0", "CANADIAN SYLLABICS KOO");
+-   ("/xe1/x91/xb1", "CANADIAN SYLLABICS Y-CREE KOO");
+-   ("/xe1/x91/xb2", "CANADIAN SYLLABICS KA");
+-   ("/xe1/x91/xb3", "CANADIAN SYLLABICS KAA");
+-   ("/xe1/x91/xb4", "CANADIAN SYLLABICS KWE");
+-   ("/xe1/x91/xb5", "CANADIAN SYLLABICS WEST-CREE KWE");
+-   ("/xe1/x91/xb6", "CANADIAN SYLLABICS KWI");
+-   ("/xe1/x91/xb7", "CANADIAN SYLLABICS WEST-CREE KWI");
+-   ("/xe1/x91/xb8", "CANADIAN SYLLABICS KWII");
+-   ("/xe1/x91/xb9", "CANADIAN SYLLABICS WEST-CREE KWII");
+-   ("/xe1/x91/xba", "CANADIAN SYLLABICS KWO");
+-   ("/xe1/x91/xbb", "CANADIAN SYLLABICS WEST-CREE KWO");
+-   ("/xe1/x91/xbc", "CANADIAN SYLLABICS KWOO");
+-   ("/xe1/x91/xbd", "CANADIAN SYLLABICS WEST-CREE KWOO");
+-   ("/xe1/x91/xbe", "CANADIAN SYLLABICS KWA");
+-   ("/xe1/x91/xbf", "CANADIAN SYLLABICS WEST-CREE KWA");
+-   ("/xe1/x92/x80", "CANADIAN SYLLABICS KWAA");
+-   ("/xe1/x92/x81", "CANADIAN SYLLABICS WEST-CREE KWAA");
+-   ("/xe1/x92/x82", "CANADIAN SYLLABICS NASKAPI KWAA");
+-   ("/xe1/x92/x83", "CANADIAN SYLLABICS K");
+-   ("/xe1/x92/x84", "CANADIAN SYLLABICS KW");
+-   ("/xe1/x92/x85", "CANADIAN SYLLABICS SOUTH-SLAVEY KEH");
+-   ("/xe1/x92/x86", "CANADIAN SYLLABICS SOUTH-SLAVEY KIH");
+-   ("/xe1/x92/x87", "CANADIAN SYLLABICS SOUTH-SLAVEY KOH");
+-   ("/xe1/x92/x88", "CANADIAN SYLLABICS SOUTH-SLAVEY KAH");
+-   ("/xe1/x92/x89", "CANADIAN SYLLABICS CE");
+-   ("/xe1/x92/x8a", "CANADIAN SYLLABICS CAAI");
+-   ("/xe1/x92/x8b", "CANADIAN SYLLABICS CI");
+-   ("/xe1/x92/x8c", "CANADIAN SYLLABICS CII");
+-   ("/xe1/x92/x8d", "CANADIAN SYLLABICS CO");
+-   ("/xe1/x92/x8e", "CANADIAN SYLLABICS COO");
+-   ("/xe1/x92/x8f", "CANADIAN SYLLABICS Y-CREE COO");
+-   ("/xe1/x92/x90", "CANADIAN SYLLABICS CA");
+-   ("/xe1/x92/x91", "CANADIAN SYLLABICS CAA");
+-   ("/xe1/x92/x92", "CANADIAN SYLLABICS CWE");
+-   ("/xe1/x92/x93", "CANADIAN SYLLABICS WEST-CREE CWE");
+-   ("/xe1/x92/x94", "CANADIAN SYLLABICS CWI");
+-   ("/xe1/x92/x95", "CANADIAN SYLLABICS WEST-CREE CWI");
+-   ("/xe1/x92/x96", "CANADIAN SYLLABICS CWII");
+-   ("/xe1/x92/x97", "CANADIAN SYLLABICS WEST-CREE CWII");
+-   ("/xe1/x92/x98", "CANADIAN SYLLABICS CWO");
+-   ("/xe1/x92/x99", "CANADIAN SYLLABICS WEST-CREE CWO");
+-   ("/xe1/x92/x9a", "CANADIAN SYLLABICS CWOO");
+-   ("/xe1/x92/x9b", "CANADIAN SYLLABICS WEST-CREE CWOO");
+-   ("/xe1/x92/x9c", "CANADIAN SYLLABICS CWA");
+-   ("/xe1/x92/x9d", "CANADIAN SYLLABICS WEST-CREE CWA");
+-   ("/xe1/x92/x9e", "CANADIAN SYLLABICS CWAA");
+-   ("/xe1/x92/x9f", "CANADIAN SYLLABICS WEST-CREE CWAA");
+-   ("/xe1/x92/xa0", "CANADIAN SYLLABICS NASKAPI CWAA");
+-   ("/xe1/x92/xa1", "CANADIAN SYLLABICS C");
+-   ("/xe1/x92/xa2", "CANADIAN SYLLABICS SAYISI TH");
+-   ("/xe1/x92/xa3", "CANADIAN SYLLABICS ME");
+-   ("/xe1/x92/xa4", "CANADIAN SYLLABICS MAAI");
+-   ("/xe1/x92/xa5", "CANADIAN SYLLABICS MI");
+-   ("/xe1/x92/xa6", "CANADIAN SYLLABICS MII");
+-   ("/xe1/x92/xa7", "CANADIAN SYLLABICS MO");
+-   ("/xe1/x92/xa8", "CANADIAN SYLLABICS MOO");
+-   ("/xe1/x92/xa9", "CANADIAN SYLLABICS Y-CREE MOO");
+-   ("/xe1/x92/xaa", "CANADIAN SYLLABICS MA");
+-   ("/xe1/x92/xab", "CANADIAN SYLLABICS MAA");
+-   ("/xe1/x92/xac", "CANADIAN SYLLABICS MWE");
+-   ("/xe1/x92/xad", "CANADIAN SYLLABICS WEST-CREE MWE");
+-   ("/xe1/x92/xae", "CANADIAN SYLLABICS MWI");
+-   ("/xe1/x92/xaf", "CANADIAN SYLLABICS WEST-CREE MWI");
+-   ("/xe1/x92/xb0", "CANADIAN SYLLABICS MWII");
+-   ("/xe1/x92/xb1", "CANADIAN SYLLABICS WEST-CREE MWII");
+-   ("/xe1/x92/xb2", "CANADIAN SYLLABICS MWO");
+-   ("/xe1/x92/xb3", "CANADIAN SYLLABICS WEST-CREE MWO");
+-   ("/xe1/x92/xb4", "CANADIAN SYLLABICS MWOO");
+-   ("/xe1/x92/xb5", "CANADIAN SYLLABICS WEST-CREE MWOO");
+-   ("/xe1/x92/xb6", "CANADIAN SYLLABICS MWA");
+-   ("/xe1/x92/xb7", "CANADIAN SYLLABICS WEST-CREE MWA");
+-   ("/xe1/x92/xb8", "CANADIAN SYLLABICS MWAA");
+-   ("/xe1/x92/xb9", "CANADIAN SYLLABICS WEST-CREE MWAA");
+-   ("/xe1/x92/xba", "CANADIAN SYLLABICS NASKAPI MWAA");
+-   ("/xe1/x92/xbb", "CANADIAN SYLLABICS M");
+-   ("/xe1/x92/xbc", "CANADIAN SYLLABICS WEST-CREE M");
+-   ("/xe1/x92/xbd", "CANADIAN SYLLABICS MH");
+-   ("/xe1/x92/xbe", "CANADIAN SYLLABICS ATHAPASCAN M");
+-   ("/xe1/x92/xbf", "CANADIAN SYLLABICS SAYISI M");
+-   ("/xe1/x93/x80", "CANADIAN SYLLABICS NE");
+-   ("/xe1/x93/x81", "CANADIAN SYLLABICS NAAI");
+-   ("/xe1/x93/x82", "CANADIAN SYLLABICS NI");
+-   ("/xe1/x93/x83", "CANADIAN SYLLABICS NII");
+-   ("/xe1/x93/x84", "CANADIAN SYLLABICS NO");
+-   ("/xe1/x93/x85", "CANADIAN SYLLABICS NOO");
+-   ("/xe1/x93/x86", "CANADIAN SYLLABICS Y-CREE NOO");
+-   ("/xe1/x93/x87", "CANADIAN SYLLABICS NA");
+-   ("/xe1/x93/x88", "CANADIAN SYLLABICS NAA");
+-   ("/xe1/x93/x89", "CANADIAN SYLLABICS NWE");
+-   ("/xe1/x93/x8a", "CANADIAN SYLLABICS WEST-CREE NWE");
+-   ("/xe1/x93/x8b", "CANADIAN SYLLABICS NWA");
+-   ("/xe1/x93/x8c", "CANADIAN SYLLABICS WEST-CREE NWA");
+-   ("/xe1/x93/x8d", "CANADIAN SYLLABICS NWAA");
+-   ("/xe1/x93/x8e", "CANADIAN SYLLABICS WEST-CREE NWAA");
+-   ("/xe1/x93/x8f", "CANADIAN SYLLABICS NASKAPI NWAA");
+-   ("/xe1/x93/x90", "CANADIAN SYLLABICS N");
+-   ("/xe1/x93/x91", "CANADIAN SYLLABICS CARRIER NG");
+-   ("/xe1/x93/x92", "CANADIAN SYLLABICS NH");
+-   ("/xe1/x93/x93", "CANADIAN SYLLABICS LE");
+-   ("/xe1/x93/x94", "CANADIAN SYLLABICS LAAI");
+-   ("/xe1/x93/x95", "CANADIAN SYLLABICS LI");
+-   ("/xe1/x93/x96", "CANADIAN SYLLABICS LII");
+-   ("/xe1/x93/x97", "CANADIAN SYLLABICS LO");
+-   ("/xe1/x93/x98", "CANADIAN SYLLABICS LOO");
+-   ("/xe1/x93/x99", "CANADIAN SYLLABICS Y-CREE LOO");
+-   ("/xe1/x93/x9a", "CANADIAN SYLLABICS LA");
+-   ("/xe1/x93/x9b", "CANADIAN SYLLABICS LAA");
+-   ("/xe1/x93/x9c", "CANADIAN SYLLABICS LWE");
+-   ("/xe1/x93/x9d", "CANADIAN SYLLABICS WEST-CREE LWE");
+-   ("/xe1/x93/x9e", "CANADIAN SYLLABICS LWI");
+-   ("/xe1/x93/x9f", "CANADIAN SYLLABICS WEST-CREE LWI");
+-   ("/xe1/x93/xa0", "CANADIAN SYLLABICS LWII");
+-   ("/xe1/x93/xa1", "CANADIAN SYLLABICS WEST-CREE LWII");
+-   ("/xe1/x93/xa2", "CANADIAN SYLLABICS LWO");
+-   ("/xe1/x93/xa3", "CANADIAN SYLLABICS WEST-CREE LWO");
+-   ("/xe1/x93/xa4", "CANADIAN SYLLABICS LWOO");
+-   ("/xe1/x93/xa5", "CANADIAN SYLLABICS WEST-CREE LWOO");
+-   ("/xe1/x93/xa6", "CANADIAN SYLLABICS LWA");
+-   ("/xe1/x93/xa7", "CANADIAN SYLLABICS WEST-CREE LWA");
+-   ("/xe1/x93/xa8", "CANADIAN SYLLABICS LWAA");
+-   ("/xe1/x93/xa9", "CANADIAN SYLLABICS WEST-CREE LWAA");
+-   ("/xe1/x93/xaa", "CANADIAN SYLLABICS L");
+-   ("/xe1/x93/xab", "CANADIAN SYLLABICS WEST-CREE L");
+-   ("/xe1/x93/xac", "CANADIAN SYLLABICS MEDIAL L");
+-   ("/xe1/x93/xad", "CANADIAN SYLLABICS SE");
+-   ("/xe1/x93/xae", "CANADIAN SYLLABICS SAAI");
+-   ("/xe1/x93/xaf", "CANADIAN SYLLABICS SI");
+-   ("/xe1/x93/xb0", "CANADIAN SYLLABICS SII");
+-   ("/xe1/x93/xb1", "CANADIAN SYLLABICS SO");
+-   ("/xe1/x93/xb2", "CANADIAN SYLLABICS SOO");
+-   ("/xe1/x93/xb3", "CANADIAN SYLLABICS Y-CREE SOO");
+-   ("/xe1/x93/xb4", "CANADIAN SYLLABICS SA");
+-   ("/xe1/x93/xb5", "CANADIAN SYLLABICS SAA");
+-   ("/xe1/x93/xb6", "CANADIAN SYLLABICS SWE");
+-   ("/xe1/x93/xb7", "CANADIAN SYLLABICS WEST-CREE SWE");
+-   ("/xe1/x93/xb8", "CANADIAN SYLLABICS SWI");
+-   ("/xe1/x93/xb9", "CANADIAN SYLLABICS WEST-CREE SWI");
+-   ("/xe1/x93/xba", "CANADIAN SYLLABICS SWII");
+-   ("/xe1/x93/xbb", "CANADIAN SYLLABICS WEST-CREE SWII");
+-   ("/xe1/x93/xbc", "CANADIAN SYLLABICS SWO");
+-   ("/xe1/x93/xbd", "CANADIAN SYLLABICS WEST-CREE SWO");
+-   ("/xe1/x93/xbe", "CANADIAN SYLLABICS SWOO");
+-   ("/xe1/x93/xbf", "CANADIAN SYLLABICS WEST-CREE SWOO");
+-   ("/xe1/x94/x80", "CANADIAN SYLLABICS SWA");
+-   ("/xe1/x94/x81", "CANADIAN SYLLABICS WEST-CREE SWA");
+-   ("/xe1/x94/x82", "CANADIAN SYLLABICS SWAA");
+-   ("/xe1/x94/x83", "CANADIAN SYLLABICS WEST-CREE SWAA");
+-   ("/xe1/x94/x84", "CANADIAN SYLLABICS NASKAPI SWAA");
+-   ("/xe1/x94/x85", "CANADIAN SYLLABICS S");
+-   ("/xe1/x94/x86", "CANADIAN SYLLABICS ATHAPASCAN S");
+-   ("/xe1/x94/x87", "CANADIAN SYLLABICS SW");
+-   ("/xe1/x94/x88", "CANADIAN SYLLABICS BLACKFOOT S");
+-   ("/xe1/x94/x89", "CANADIAN SYLLABICS MOOSE-CREE SK");
+-   ("/xe1/x94/x8a", "CANADIAN SYLLABICS NASKAPI SKW");
+-   ("/xe1/x94/x8b", "CANADIAN SYLLABICS NASKAPI S-W");
+-   ("/xe1/x94/x8c", "CANADIAN SYLLABICS NASKAPI SPWA");
+-   ("/xe1/x94/x8d", "CANADIAN SYLLABICS NASKAPI STWA");
+-   ("/xe1/x94/x8e", "CANADIAN SYLLABICS NASKAPI SKWA");
+-   ("/xe1/x94/x8f", "CANADIAN SYLLABICS NASKAPI SCWA");
+-   ("/xe1/x94/x90", "CANADIAN SYLLABICS SHE");
+-   ("/xe1/x94/x91", "CANADIAN SYLLABICS SHI");
+-   ("/xe1/x94/x92", "CANADIAN SYLLABICS SHII");
+-   ("/xe1/x94/x93", "CANADIAN SYLLABICS SHO");
+-   ("/xe1/x94/x94", "CANADIAN SYLLABICS SHOO");
+-   ("/xe1/x94/x95", "CANADIAN SYLLABICS SHA");
+-   ("/xe1/x94/x96", "CANADIAN SYLLABICS SHAA");
+-   ("/xe1/x94/x97", "CANADIAN SYLLABICS SHWE");
+-   ("/xe1/x94/x98", "CANADIAN SYLLABICS WEST-CREE SHWE");
+-   ("/xe1/x94/x99", "CANADIAN SYLLABICS SHWI");
+-   ("/xe1/x94/x9a", "CANADIAN SYLLABICS WEST-CREE SHWI");
+-   ("/xe1/x94/x9b", "CANADIAN SYLLABICS SHWII");
+-   ("/xe1/x94/x9c", "CANADIAN SYLLABICS WEST-CREE SHWII");
+-   ("/xe1/x94/x9d", "CANADIAN SYLLABICS SHWO");
+-   ("/xe1/x94/x9e", "CANADIAN SYLLABICS WEST-CREE SHWO");
+-   ("/xe1/x94/x9f", "CANADIAN SYLLABICS SHWOO");
+-   ("/xe1/x94/xa0", "CANADIAN SYLLABICS WEST-CREE SHWOO");
+-   ("/xe1/x94/xa1", "CANADIAN SYLLABICS SHWA");
+-   ("/xe1/x94/xa2", "CANADIAN SYLLABICS WEST-CREE SHWA");
+-   ("/xe1/x94/xa3", "CANADIAN SYLLABICS SHWAA");
+-   ("/xe1/x94/xa4", "CANADIAN SYLLABICS WEST-CREE SHWAA");
+-   ("/xe1/x94/xa5", "CANADIAN SYLLABICS SH");
+-   ("/xe1/x94/xa6", "CANADIAN SYLLABICS YE");
+-   ("/xe1/x94/xa7", "CANADIAN SYLLABICS YAAI");
+-   ("/xe1/x94/xa8", "CANADIAN SYLLABICS YI");
+-   ("/xe1/x94/xa9", "CANADIAN SYLLABICS YII");
+-   ("/xe1/x94/xaa", "CANADIAN SYLLABICS YO");
+-   ("/xe1/x94/xab", "CANADIAN SYLLABICS YOO");
+-   ("/xe1/x94/xac", "CANADIAN SYLLABICS Y-CREE YOO");
+-   ("/xe1/x94/xad", "CANADIAN SYLLABICS YA");
+-   ("/xe1/x94/xae", "CANADIAN SYLLABICS YAA");
+-   ("/xe1/x94/xaf", "CANADIAN SYLLABICS YWE");
+-   ("/xe1/x94/xb0", "CANADIAN SYLLABICS WEST-CREE YWE");
+-   ("/xe1/x94/xb1", "CANADIAN SYLLABICS YWI");
+-   ("/xe1/x94/xb2", "CANADIAN SYLLABICS WEST-CREE YWI");
+-   ("/xe1/x94/xb3", "CANADIAN SYLLABICS YWII");
+-   ("/xe1/x94/xb4", "CANADIAN SYLLABICS WEST-CREE YWII");
+-   ("/xe1/x94/xb5", "CANADIAN SYLLABICS YWO");
+-   ("/xe1/x94/xb6", "CANADIAN SYLLABICS WEST-CREE YWO");
+-   ("/xe1/x94/xb7", "CANADIAN SYLLABICS YWOO");
+-   ("/xe1/x94/xb8", "CANADIAN SYLLABICS WEST-CREE YWOO");
+-   ("/xe1/x94/xb9", "CANADIAN SYLLABICS YWA");
+-   ("/xe1/x94/xba", "CANADIAN SYLLABICS WEST-CREE YWA");
+-   ("/xe1/x94/xbb", "CANADIAN SYLLABICS YWAA");
+-   ("/xe1/x94/xbc", "CANADIAN SYLLABICS WEST-CREE YWAA");
+-   ("/xe1/x94/xbd", "CANADIAN SYLLABICS NASKAPI YWAA");
+-   ("/xe1/x94/xbe", "CANADIAN SYLLABICS Y");
+-   ("/xe1/x94/xbf", "CANADIAN SYLLABICS BIBLE-CREE Y");
+-   ("/xe1/x95/x80", "CANADIAN SYLLABICS WEST-CREE Y");
+-   ("/xe1/x95/x81", "CANADIAN SYLLABICS SAYISI YI");
+-   ("/xe1/x95/x82", "CANADIAN SYLLABICS RE");
+-   ("/xe1/x95/x83", "CANADIAN SYLLABICS R-CREE RE");
+-   ("/xe1/x95/x84", "CANADIAN SYLLABICS WEST-CREE LE");
+-   ("/xe1/x95/x85", "CANADIAN SYLLABICS RAAI");
+-   ("/xe1/x95/x86", "CANADIAN SYLLABICS RI");
+-   ("/xe1/x95/x87", "CANADIAN SYLLABICS RII");
+-   ("/xe1/x95/x88", "CANADIAN SYLLABICS RO");
+-   ("/xe1/x95/x89", "CANADIAN SYLLABICS ROO");
+-   ("/xe1/x95/x8a", "CANADIAN SYLLABICS WEST-CREE LO");
+-   ("/xe1/x95/x8b", "CANADIAN SYLLABICS RA");
+-   ("/xe1/x95/x8c", "CANADIAN SYLLABICS RAA");
+-   ("/xe1/x95/x8d", "CANADIAN SYLLABICS WEST-CREE LA");
+-   ("/xe1/x95/x8e", "CANADIAN SYLLABICS RWAA");
+-   ("/xe1/x95/x8f", "CANADIAN SYLLABICS WEST-CREE RWAA");
+-   ("/xe1/x95/x90", "CANADIAN SYLLABICS R");
+-   ("/xe1/x95/x91", "CANADIAN SYLLABICS WEST-CREE R");
+-   ("/xe1/x95/x92", "CANADIAN SYLLABICS MEDIAL R");
+-   ("/xe1/x95/x93", "CANADIAN SYLLABICS FE");
+-   ("/xe1/x95/x94", "CANADIAN SYLLABICS FAAI");
+-   ("/xe1/x95/x95", "CANADIAN SYLLABICS FI");
+-   ("/xe1/x95/x96", "CANADIAN SYLLABICS FII");
+-   ("/xe1/x95/x97", "CANADIAN SYLLABICS FO");
+-   ("/xe1/x95/x98", "CANADIAN SYLLABICS FOO");
+-   ("/xe1/x95/x99", "CANADIAN SYLLABICS FA");
+-   ("/xe1/x95/x9a", "CANADIAN SYLLABICS FAA");
+-   ("/xe1/x95/x9b", "CANADIAN SYLLABICS FWAA");
+-   ("/xe1/x95/x9c", "CANADIAN SYLLABICS WEST-CREE FWAA");
+-   ("/xe1/x95/x9d", "CANADIAN SYLLABICS F");
+-   ("/xe1/x95/x9e", "CANADIAN SYLLABICS THE");
+-   ("/xe1/x95/x9f", "CANADIAN SYLLABICS N-CREE THE");
+-   ("/xe1/x95/xa0", "CANADIAN SYLLABICS THI");
+-   ("/xe1/x95/xa1", "CANADIAN SYLLABICS N-CREE THI");
+-   ("/xe1/x95/xa2", "CANADIAN SYLLABICS THII");
+-   ("/xe1/x95/xa3", "CANADIAN SYLLABICS N-CREE THII");
+-   ("/xe1/x95/xa4", "CANADIAN SYLLABICS THO");
+-   ("/xe1/x95/xa5", "CANADIAN SYLLABICS THOO");
+-   ("/xe1/x95/xa6", "CANADIAN SYLLABICS THA");
+-   ("/xe1/x95/xa7", "CANADIAN SYLLABICS THAA");
+-   ("/xe1/x95/xa8", "CANADIAN SYLLABICS THWAA");
+-   ("/xe1/x95/xa9", "CANADIAN SYLLABICS WEST-CREE THWAA");
+-   ("/xe1/x95/xaa", "CANADIAN SYLLABICS TH");
+-   ("/xe1/x95/xab", "CANADIAN SYLLABICS TTHE");
+-   ("/xe1/x95/xac", "CANADIAN SYLLABICS TTHI");
+-   ("/xe1/x95/xad", "CANADIAN SYLLABICS TTHO");
+-   ("/xe1/x95/xae", "CANADIAN SYLLABICS TTHA");
+-   ("/xe1/x95/xaf", "CANADIAN SYLLABICS TTH");
+-   ("/xe1/x95/xb0", "CANADIAN SYLLABICS TYE");
+-   ("/xe1/x95/xb1", "CANADIAN SYLLABICS TYI");
+-   ("/xe1/x95/xb2", "CANADIAN SYLLABICS TYO");
+-   ("/xe1/x95/xb3", "CANADIAN SYLLABICS TYA");
+-   ("/xe1/x95/xb4", "CANADIAN SYLLABICS NUNAVIK HE");
+-   ("/xe1/x95/xb5", "CANADIAN SYLLABICS NUNAVIK HI");
+-   ("/xe1/x95/xb6", "CANADIAN SYLLABICS NUNAVIK HII");
+-   ("/xe1/x95/xb7", "CANADIAN SYLLABICS NUNAVIK HO");
+-   ("/xe1/x95/xb8", "CANADIAN SYLLABICS NUNAVIK HOO");
+-   ("/xe1/x95/xb9", "CANADIAN SYLLABICS NUNAVIK HA");
+-   ("/xe1/x95/xba", "CANADIAN SYLLABICS NUNAVIK HAA");
+-   ("/xe1/x95/xbb", "CANADIAN SYLLABICS NUNAVIK H");
+-   ("/xe1/x95/xbc", "CANADIAN SYLLABICS NUNAVUT H");
+-   ("/xe1/x95/xbd", "CANADIAN SYLLABICS HK");
+-   ("/xe1/x95/xbe", "CANADIAN SYLLABICS QAAI");
+-   ("/xe1/x95/xbf", "CANADIAN SYLLABICS QI");
+-   ("/xe1/x96/x80", "CANADIAN SYLLABICS QII");
+-   ("/xe1/x96/x81", "CANADIAN SYLLABICS QO");
+-   ("/xe1/x96/x82", "CANADIAN SYLLABICS QOO");
+-   ("/xe1/x96/x83", "CANADIAN SYLLABICS QA");
+-   ("/xe1/x96/x84", "CANADIAN SYLLABICS QAA");
+-   ("/xe1/x96/x85", "CANADIAN SYLLABICS Q");
+-   ("/xe1/x96/x86", "CANADIAN SYLLABICS TLHE");
+-   ("/xe1/x96/x87", "CANADIAN SYLLABICS TLHI");
+-   ("/xe1/x96/x88", "CANADIAN SYLLABICS TLHO");
+-   ("/xe1/x96/x89", "CANADIAN SYLLABICS TLHA");
+-   ("/xe1/x96/x8a", "CANADIAN SYLLABICS WEST-CREE RE");
+-   ("/xe1/x96/x8b", "CANADIAN SYLLABICS WEST-CREE RI");
+-   ("/xe1/x96/x8c", "CANADIAN SYLLABICS WEST-CREE RO");
+-   ("/xe1/x96/x8d", "CANADIAN SYLLABICS WEST-CREE RA");
+-   ("/xe1/x96/x8e", "CANADIAN SYLLABICS NGAAI");
+-   ("/xe1/x96/x8f", "CANADIAN SYLLABICS NGI");
+-   ("/xe1/x96/x90", "CANADIAN SYLLABICS NGII");
+-   ("/xe1/x96/x91", "CANADIAN SYLLABICS NGO");
+-   ("/xe1/x96/x92", "CANADIAN SYLLABICS NGOO");
+-   ("/xe1/x96/x93", "CANADIAN SYLLABICS NGA");
+-   ("/xe1/x96/x94", "CANADIAN SYLLABICS NGAA");
+-   ("/xe1/x96/x95", "CANADIAN SYLLABICS NG");
+-   ("/xe1/x96/x96", "CANADIAN SYLLABICS NNG");
+-   ("/xe1/x96/x97", "CANADIAN SYLLABICS SAYISI SHE");
+-   ("/xe1/x96/x98", "CANADIAN SYLLABICS SAYISI SHI");
+-   ("/xe1/x96/x99", "CANADIAN SYLLABICS SAYISI SHO");
+-   ("/xe1/x96/x9a", "CANADIAN SYLLABICS SAYISI SHA");
+-   ("/xe1/x96/x9b", "CANADIAN SYLLABICS WOODS-CREE THE");
+-   ("/xe1/x96/x9c", "CANADIAN SYLLABICS WOODS-CREE THI");
+-   ("/xe1/x96/x9d", "CANADIAN SYLLABICS WOODS-CREE THO");
+-   ("/xe1/x96/x9e", "CANADIAN SYLLABICS WOODS-CREE THA");
+-   ("/xe1/x96/x9f", "CANADIAN SYLLABICS WOODS-CREE TH");
+-   ("/xe1/x96/xa0", "CANADIAN SYLLABICS LHI");
+-   ("/xe1/x96/xa1", "CANADIAN SYLLABICS LHII");
+-   ("/xe1/x96/xa2", "CANADIAN SYLLABICS LHO");
+-   ("/xe1/x96/xa3", "CANADIAN SYLLABICS LHOO");
+-   ("/xe1/x96/xa4", "CANADIAN SYLLABICS LHA");
+-   ("/xe1/x96/xa5", "CANADIAN SYLLABICS LHAA");
+-   ("/xe1/x96/xa6", "CANADIAN SYLLABICS LH");
+-   ("/xe1/x96/xa7", "CANADIAN SYLLABICS TH-CREE THE");
+-   ("/xe1/x96/xa8", "CANADIAN SYLLABICS TH-CREE THI");
+-   ("/xe1/x96/xa9", "CANADIAN SYLLABICS TH-CREE THII");
+-   ("/xe1/x96/xaa", "CANADIAN SYLLABICS TH-CREE THO");
+-   ("/xe1/x96/xab", "CANADIAN SYLLABICS TH-CREE THOO");
+-   ("/xe1/x96/xac", "CANADIAN SYLLABICS TH-CREE THA");
+-   ("/xe1/x96/xad", "CANADIAN SYLLABICS TH-CREE THAA");
+-   ("/xe1/x96/xae", "CANADIAN SYLLABICS TH-CREE TH");
+-   ("/xe1/x96/xaf", "CANADIAN SYLLABICS AIVILIK B");
+-   ("/xe1/x96/xb0", "CANADIAN SYLLABICS BLACKFOOT E");
+-   ("/xe1/x96/xb1", "CANADIAN SYLLABICS BLACKFOOT I");
+-   ("/xe1/x96/xb2", "CANADIAN SYLLABICS BLACKFOOT O");
+-   ("/xe1/x96/xb3", "CANADIAN SYLLABICS BLACKFOOT A");
+-   ("/xe1/x96/xb4", "CANADIAN SYLLABICS BLACKFOOT WE");
+-   ("/xe1/x96/xb5", "CANADIAN SYLLABICS BLACKFOOT WI");
+-   ("/xe1/x96/xb6", "CANADIAN SYLLABICS BLACKFOOT WO");
+-   ("/xe1/x96/xb7", "CANADIAN SYLLABICS BLACKFOOT WA");
+-   ("/xe1/x96/xb8", "CANADIAN SYLLABICS BLACKFOOT NE");
+-   ("/xe1/x96/xb9", "CANADIAN SYLLABICS BLACKFOOT NI");
+-   ("/xe1/x96/xba", "CANADIAN SYLLABICS BLACKFOOT NO");
+-   ("/xe1/x96/xbb", "CANADIAN SYLLABICS BLACKFOOT NA");
+-   ("/xe1/x96/xbc", "CANADIAN SYLLABICS BLACKFOOT KE");
+-   ("/xe1/x96/xbd", "CANADIAN SYLLABICS BLACKFOOT KI");
+-   ("/xe1/x96/xbe", "CANADIAN SYLLABICS BLACKFOOT KO");
+-   ("/xe1/x96/xbf", "CANADIAN SYLLABICS BLACKFOOT KA");
+-   ("/xe1/x97/x80", "CANADIAN SYLLABICS SAYISI HE");
+-   ("/xe1/x97/x81", "CANADIAN SYLLABICS SAYISI HI");
+-   ("/xe1/x97/x82", "CANADIAN SYLLABICS SAYISI HO");
+-   ("/xe1/x97/x83", "CANADIAN SYLLABICS SAYISI HA");
+-   ("/xe1/x97/x84", "CANADIAN SYLLABICS CARRIER GHU");
+-   ("/xe1/x97/x85", "CANADIAN SYLLABICS CARRIER GHO");
+-   ("/xe1/x97/x86", "CANADIAN SYLLABICS CARRIER GHE");
+-   ("/xe1/x97/x87", "CANADIAN SYLLABICS CARRIER GHEE");
+-   ("/xe1/x97/x88", "CANADIAN SYLLABICS CARRIER GHI");
+-   ("/xe1/x97/x89", "CANADIAN SYLLABICS CARRIER GHA");
+-   ("/xe1/x97/x8a", "CANADIAN SYLLABICS CARRIER RU");
+-   ("/xe1/x97/x8b", "CANADIAN SYLLABICS CARRIER RO");
+-   ("/xe1/x97/x8c", "CANADIAN SYLLABICS CARRIER RE");
+-   ("/xe1/x97/x8d", "CANADIAN SYLLABICS CARRIER REE");
+-   ("/xe1/x97/x8e", "CANADIAN SYLLABICS CARRIER RI");
+-   ("/xe1/x97/x8f", "CANADIAN SYLLABICS CARRIER RA");
+-   ("/xe1/x97/x90", "CANADIAN SYLLABICS CARRIER WU");
+-   ("/xe1/x97/x91", "CANADIAN SYLLABICS CARRIER WO");
+-   ("/xe1/x97/x92", "CANADIAN SYLLABICS CARRIER WE");
+-   ("/xe1/x97/x93", "CANADIAN SYLLABICS CARRIER WEE");
+-   ("/xe1/x97/x94", "CANADIAN SYLLABICS CARRIER WI");
+-   ("/xe1/x97/x95", "CANADIAN SYLLABICS CARRIER WA");
+-   ("/xe1/x97/x96", "CANADIAN SYLLABICS CARRIER HWU");
+-   ("/xe1/x97/x97", "CANADIAN SYLLABICS CARRIER HWO");
+-   ("/xe1/x97/x98", "CANADIAN SYLLABICS CARRIER HWE");
+-   ("/xe1/x97/x99", "CANADIAN SYLLABICS CARRIER HWEE");
+-   ("/xe1/x97/x9a", "CANADIAN SYLLABICS CARRIER HWI");
+-   ("/xe1/x97/x9b", "CANADIAN SYLLABICS CARRIER HWA");
+-   ("/xe1/x97/x9c", "CANADIAN SYLLABICS CARRIER THU");
+-   ("/xe1/x97/x9d", "CANADIAN SYLLABICS CARRIER THO");
+-   ("/xe1/x97/x9e", "CANADIAN SYLLABICS CARRIER THE");
+-   ("/xe1/x97/x9f", "CANADIAN SYLLABICS CARRIER THEE");
+-   ("/xe1/x97/xa0", "CANADIAN SYLLABICS CARRIER THI");
+-   ("/xe1/x97/xa1", "CANADIAN SYLLABICS CARRIER THA");
+-   ("/xe1/x97/xa2", "CANADIAN SYLLABICS CARRIER TTU");
+-   ("/xe1/x97/xa3", "CANADIAN SYLLABICS CARRIER TTO");
+-   ("/xe1/x97/xa4", "CANADIAN SYLLABICS CARRIER TTE");
+-   ("/xe1/x97/xa5", "CANADIAN SYLLABICS CARRIER TTEE");
+-   ("/xe1/x97/xa6", "CANADIAN SYLLABICS CARRIER TTI");
+-   ("/xe1/x97/xa7", "CANADIAN SYLLABICS CARRIER TTA");
+-   ("/xe1/x97/xa8", "CANADIAN SYLLABICS CARRIER PU");
+-   ("/xe1/x97/xa9", "CANADIAN SYLLABICS CARRIER PO");
+-   ("/xe1/x97/xaa", "CANADIAN SYLLABICS CARRIER PE");
+-   ("/xe1/x97/xab", "CANADIAN SYLLABICS CARRIER PEE");
+-   ("/xe1/x97/xac", "CANADIAN SYLLABICS CARRIER PI");
+-   ("/xe1/x97/xad", "CANADIAN SYLLABICS CARRIER PA");
+-   ("/xe1/x97/xae", "CANADIAN SYLLABICS CARRIER P");
+-   ("/xe1/x97/xaf", "CANADIAN SYLLABICS CARRIER GU");
+-   ("/xe1/x97/xb0", "CANADIAN SYLLABICS CARRIER GO");
+-   ("/xe1/x97/xb1", "CANADIAN SYLLABICS CARRIER GE");
+-   ("/xe1/x97/xb2", "CANADIAN SYLLABICS CARRIER GEE");
+-   ("/xe1/x97/xb3", "CANADIAN SYLLABICS CARRIER GI");
+-   ("/xe1/x97/xb4", "CANADIAN SYLLABICS CARRIER GA");
+-   ("/xe1/x97/xb5", "CANADIAN SYLLABICS CARRIER KHU");
+-   ("/xe1/x97/xb6", "CANADIAN SYLLABICS CARRIER KHO");
+-   ("/xe1/x97/xb7", "CANADIAN SYLLABICS CARRIER KHE");
+-   ("/xe1/x97/xb8", "CANADIAN SYLLABICS CARRIER KHEE");
+-   ("/xe1/x97/xb9", "CANADIAN SYLLABICS CARRIER KHI");
+-   ("/xe1/x97/xba", "CANADIAN SYLLABICS CARRIER KHA");
+-   ("/xe1/x97/xbb", "CANADIAN SYLLABICS CARRIER KKU");
+-   ("/xe1/x97/xbc", "CANADIAN SYLLABICS CARRIER KKO");
+-   ("/xe1/x97/xbd", "CANADIAN SYLLABICS CARRIER KKE");
+-   ("/xe1/x97/xbe", "CANADIAN SYLLABICS CARRIER KKEE");
+-   ("/xe1/x97/xbf", "CANADIAN SYLLABICS CARRIER KKI");
+-   ("/xe1/x98/x80", "CANADIAN SYLLABICS CARRIER KKA");
+-   ("/xe1/x98/x81", "CANADIAN SYLLABICS CARRIER KK");
+-   ("/xe1/x98/x82", "CANADIAN SYLLABICS CARRIER NU");
+-   ("/xe1/x98/x83", "CANADIAN SYLLABICS CARRIER NO");
+-   ("/xe1/x98/x84", "CANADIAN SYLLABICS CARRIER NE");
+-   ("/xe1/x98/x85", "CANADIAN SYLLABICS CARRIER NEE");
+-   ("/xe1/x98/x86", "CANADIAN SYLLABICS CARRIER NI");
+-   ("/xe1/x98/x87", "CANADIAN SYLLABICS CARRIER NA");
+-   ("/xe1/x98/x88", "CANADIAN SYLLABICS CARRIER MU");
+-   ("/xe1/x98/x89", "CANADIAN SYLLABICS CARRIER MO");
+-   ("/xe1/x98/x8a", "CANADIAN SYLLABICS CARRIER ME");
+-   ("/xe1/x98/x8b", "CANADIAN SYLLABICS CARRIER MEE");
+-   ("/xe1/x98/x8c", "CANADIAN SYLLABICS CARRIER MI");
+-   ("/xe1/x98/x8d", "CANADIAN SYLLABICS CARRIER MA");
+-   ("/xe1/x98/x8e", "CANADIAN SYLLABICS CARRIER YU");
+-   ("/xe1/x98/x8f", "CANADIAN SYLLABICS CARRIER YO");
+-   ("/xe1/x98/x90", "CANADIAN SYLLABICS CARRIER YE");
+-   ("/xe1/x98/x91", "CANADIAN SYLLABICS CARRIER YEE");
+-   ("/xe1/x98/x92", "CANADIAN SYLLABICS CARRIER YI");
+-   ("/xe1/x98/x93", "CANADIAN SYLLABICS CARRIER YA");
+-   ("/xe1/x98/x94", "CANADIAN SYLLABICS CARRIER JU");
+-   ("/xe1/x98/x95", "CANADIAN SYLLABICS SAYISI JU");
+-   ("/xe1/x98/x96", "CANADIAN SYLLABICS CARRIER JO");
+-   ("/xe1/x98/x97", "CANADIAN SYLLABICS CARRIER JE");
+-   ("/xe1/x98/x98", "CANADIAN SYLLABICS CARRIER JEE");
+-   ("/xe1/x98/x99", "CANADIAN SYLLABICS CARRIER JI");
+-   ("/xe1/x98/x9a", "CANADIAN SYLLABICS SAYISI JI");
+-   ("/xe1/x98/x9b", "CANADIAN SYLLABICS CARRIER JA");
+-   ("/xe1/x98/x9c", "CANADIAN SYLLABICS CARRIER JJU");
+-   ("/xe1/x98/x9d", "CANADIAN SYLLABICS CARRIER JJO");
+-   ("/xe1/x98/x9e", "CANADIAN SYLLABICS CARRIER JJE");
+-   ("/xe1/x98/x9f", "CANADIAN SYLLABICS CARRIER JJEE");
+-   ("/xe1/x98/xa0", "CANADIAN SYLLABICS CARRIER JJI");
+-   ("/xe1/x98/xa1", "CANADIAN SYLLABICS CARRIER JJA");
+-   ("/xe1/x98/xa2", "CANADIAN SYLLABICS CARRIER LU");
+-   ("/xe1/x98/xa3", "CANADIAN SYLLABICS CARRIER LO");
+-   ("/xe1/x98/xa4", "CANADIAN SYLLABICS CARRIER LE");
+-   ("/xe1/x98/xa5", "CANADIAN SYLLABICS CARRIER LEE");
+-   ("/xe1/x98/xa6", "CANADIAN SYLLABICS CARRIER LI");
+-   ("/xe1/x98/xa7", "CANADIAN SYLLABICS CARRIER LA");
+-   ("/xe1/x98/xa8", "CANADIAN SYLLABICS CARRIER DLU");
+-   ("/xe1/x98/xa9", "CANADIAN SYLLABICS CARRIER DLO");
+-   ("/xe1/x98/xaa", "CANADIAN SYLLABICS CARRIER DLE");
+-   ("/xe1/x98/xab", "CANADIAN SYLLABICS CARRIER DLEE");
+-   ("/xe1/x98/xac", "CANADIAN SYLLABICS CARRIER DLI");
+-   ("/xe1/x98/xad", "CANADIAN SYLLABICS CARRIER DLA");
+-   ("/xe1/x98/xae", "CANADIAN SYLLABICS CARRIER LHU");
+-   ("/xe1/x98/xaf", "CANADIAN SYLLABICS CARRIER LHO");
+-   ("/xe1/x98/xb0", "CANADIAN SYLLABICS CARRIER LHE");
+-   ("/xe1/x98/xb1", "CANADIAN SYLLABICS CARRIER LHEE");
+-   ("/xe1/x98/xb2", "CANADIAN SYLLABICS CARRIER LHI");
+-   ("/xe1/x98/xb3", "CANADIAN SYLLABICS CARRIER LHA");
+-   ("/xe1/x98/xb4", "CANADIAN SYLLABICS CARRIER TLHU");
+-   ("/xe1/x98/xb5", "CANADIAN SYLLABICS CARRIER TLHO");
+-   ("/xe1/x98/xb6", "CANADIAN SYLLABICS CARRIER TLHE");
+-   ("/xe1/x98/xb7", "CANADIAN SYLLABICS CARRIER TLHEE");
+-   ("/xe1/x98/xb8", "CANADIAN SYLLABICS CARRIER TLHI");
+-   ("/xe1/x98/xb9", "CANADIAN SYLLABICS CARRIER TLHA");
+-   ("/xe1/x98/xba", "CANADIAN SYLLABICS CARRIER TLU");
+-   ("/xe1/x98/xbb", "CANADIAN SYLLABICS CARRIER TLO");
+-   ("/xe1/x98/xbc", "CANADIAN SYLLABICS CARRIER TLE");
+-   ("/xe1/x98/xbd", "CANADIAN SYLLABICS CARRIER TLEE");
+-   ("/xe1/x98/xbe", "CANADIAN SYLLABICS CARRIER TLI");
+-   ("/xe1/x98/xbf", "CANADIAN SYLLABICS CARRIER TLA");
+-   ("/xe1/x99/x80", "CANADIAN SYLLABICS CARRIER ZU");
+-   ("/xe1/x99/x81", "CANADIAN SYLLABICS CARRIER ZO");
+-   ("/xe1/x99/x82", "CANADIAN SYLLABICS CARRIER ZE");
+-   ("/xe1/x99/x83", "CANADIAN SYLLABICS CARRIER ZEE");
+-   ("/xe1/x99/x84", "CANADIAN SYLLABICS CARRIER ZI");
+-   ("/xe1/x99/x85", "CANADIAN SYLLABICS CARRIER ZA");
+-   ("/xe1/x99/x86", "CANADIAN SYLLABICS CARRIER Z");
+-   ("/xe1/x99/x87", "CANADIAN SYLLABICS CARRIER INITIAL Z");
+-   ("/xe1/x99/x88", "CANADIAN SYLLABICS CARRIER DZU");
+-   ("/xe1/x99/x89", "CANADIAN SYLLABICS CARRIER DZO");
+-   ("/xe1/x99/x8a", "CANADIAN SYLLABICS CARRIER DZE");
+-   ("/xe1/x99/x8b", "CANADIAN SYLLABICS CARRIER DZEE");
+-   ("/xe1/x99/x8c", "CANADIAN SYLLABICS CARRIER DZI");
+-   ("/xe1/x99/x8d", "CANADIAN SYLLABICS CARRIER DZA");
+-   ("/xe1/x99/x8e", "CANADIAN SYLLABICS CARRIER SU");
+-   ("/xe1/x99/x8f", "CANADIAN SYLLABICS CARRIER SO");
+-   ("/xe1/x99/x90", "CANADIAN SYLLABICS CARRIER SE");
+-   ("/xe1/x99/x91", "CANADIAN SYLLABICS CARRIER SEE");
+-   ("/xe1/x99/x92", "CANADIAN SYLLABICS CARRIER SI");
+-   ("/xe1/x99/x93", "CANADIAN SYLLABICS CARRIER SA");
+-   ("/xe1/x99/x94", "CANADIAN SYLLABICS CARRIER SHU");
+-   ("/xe1/x99/x95", "CANADIAN SYLLABICS CARRIER SHO");
+-   ("/xe1/x99/x96", "CANADIAN SYLLABICS CARRIER SHE");
+-   ("/xe1/x99/x97", "CANADIAN SYLLABICS CARRIER SHEE");
+-   ("/xe1/x99/x98", "CANADIAN SYLLABICS CARRIER SHI");
+-   ("/xe1/x99/x99", "CANADIAN SYLLABICS CARRIER SHA");
+-   ("/xe1/x99/x9a", "CANADIAN SYLLABICS CARRIER SH");
+-   ("/xe1/x99/x9b", "CANADIAN SYLLABICS CARRIER TSU");
+-   ("/xe1/x99/x9c", "CANADIAN SYLLABICS CARRIER TSO");
+-   ("/xe1/x99/x9d", "CANADIAN SYLLABICS CARRIER TSE");
+-   ("/xe1/x99/x9e", "CANADIAN SYLLABICS CARRIER TSEE");
+-   ("/xe1/x99/x9f", "CANADIAN SYLLABICS CARRIER TSI");
+-   ("/xe1/x99/xa0", "CANADIAN SYLLABICS CARRIER TSA");
+-   ("/xe1/x99/xa1", "CANADIAN SYLLABICS CARRIER CHU");
+-   ("/xe1/x99/xa2", "CANADIAN SYLLABICS CARRIER CHO");
+-   ("/xe1/x99/xa3", "CANADIAN SYLLABICS CARRIER CHE");
+-   ("/xe1/x99/xa4", "CANADIAN SYLLABICS CARRIER CHEE");
+-   ("/xe1/x99/xa5", "CANADIAN SYLLABICS CARRIER CHI");
+-   ("/xe1/x99/xa6", "CANADIAN SYLLABICS CARRIER CHA");
+-   ("/xe1/x99/xa7", "CANADIAN SYLLABICS CARRIER TTSU");
+-   ("/xe1/x99/xa8", "CANADIAN SYLLABICS CARRIER TTSO");
+-   ("/xe1/x99/xa9", "CANADIAN SYLLABICS CARRIER TTSE");
+-   ("/xe1/x99/xaa", "CANADIAN SYLLABICS CARRIER TTSEE");
+-   ("/xe1/x99/xab", "CANADIAN SYLLABICS CARRIER TTSI");
+-   ("/xe1/x99/xac", "CANADIAN SYLLABICS CARRIER TTSA");
+-   ("/xe1/x99/xad", "CANADIAN SYLLABICS CHI SIGN");
+-   ("/xe1/x99/xae", "CANADIAN SYLLABICS FULL STOP");
+-   ("/xe1/x99/xaf", "CANADIAN SYLLABICS QAI");
+-   ("/xe1/x99/xb0", "CANADIAN SYLLABICS NGAI");
+-   ("/xe1/x99/xb1", "CANADIAN SYLLABICS NNGI");
+-   ("/xe1/x99/xb2", "CANADIAN SYLLABICS NNGII");
+-   ("/xe1/x99/xb3", "CANADIAN SYLLABICS NNGO");
+-   ("/xe1/x99/xb4", "CANADIAN SYLLABICS NNGOO");
+-   ("/xe1/x99/xb5", "CANADIAN SYLLABICS NNGA");
+-   ("/xe1/x99/xb6", "CANADIAN SYLLABICS NNGAA");
+-   ("/xe1/x9a/x80", "OGHAM SPACE MARK");
+-   ("/xe1/x9a/x81", "OGHAM LETTER BEITH");
+-   ("/xe1/x9a/x82", "OGHAM LETTER LUIS");
+-   ("/xe1/x9a/x83", "OGHAM LETTER FEARN");
+-   ("/xe1/x9a/x84", "OGHAM LETTER SAIL");
+-   ("/xe1/x9a/x85", "OGHAM LETTER NION");
+-   ("/xe1/x9a/x86", "OGHAM LETTER UATH");
+-   ("/xe1/x9a/x87", "OGHAM LETTER DAIR");
+-   ("/xe1/x9a/x88", "OGHAM LETTER TINNE");
+-   ("/xe1/x9a/x89", "OGHAM LETTER COLL");
+-   ("/xe1/x9a/x8a", "OGHAM LETTER CEIRT");
+-   ("/xe1/x9a/x8b", "OGHAM LETTER MUIN");
+-   ("/xe1/x9a/x8c", "OGHAM LETTER GORT");
+-   ("/xe1/x9a/x8d", "OGHAM LETTER NGEADAL");
+-   ("/xe1/x9a/x8e", "OGHAM LETTER STRAIF");
+-   ("/xe1/x9a/x8f", "OGHAM LETTER RUIS");
+-   ("/xe1/x9a/x90", "OGHAM LETTER AILM");
+-   ("/xe1/x9a/x91", "OGHAM LETTER ONN");
+-   ("/xe1/x9a/x92", "OGHAM LETTER UR");
+-   ("/xe1/x9a/x93", "OGHAM LETTER EADHADH");
+-   ("/xe1/x9a/x94", "OGHAM LETTER IODHADH");
+-   ("/xe1/x9a/x95", "OGHAM LETTER EABHADH");
+-   ("/xe1/x9a/x96", "OGHAM LETTER OR");
+-   ("/xe1/x9a/x97", "OGHAM LETTER UILLEANN");
+-   ("/xe1/x9a/x98", "OGHAM LETTER IFIN");
+-   ("/xe1/x9a/x99", "OGHAM LETTER EAMHANCHOLL");
+-   ("/xe1/x9a/x9a", "OGHAM LETTER PEITH");
+-   ("/xe1/x9a/x9b", "OGHAM FEATHER MARK");
+-   ("/xe1/x9a/x9c", "OGHAM REVERSED FEATHER MARK");
+-   ("/xe1/x9a/xa0", "RUNIC LETTER FEHU FEOH FE F");
+-   ("/xe1/x9a/xa1", "RUNIC LETTER V");
+-   ("/xe1/x9a/xa2", "RUNIC LETTER URUZ UR U");
+-   ("/xe1/x9a/xa3", "RUNIC LETTER YR");
+-   ("/xe1/x9a/xa4", "RUNIC LETTER Y");
+-   ("/xe1/x9a/xa5", "RUNIC LETTER W");
+-   ("/xe1/x9a/xa6", "RUNIC LETTER THURISAZ THURS THORN");
+-   ("/xe1/x9a/xa7", "RUNIC LETTER ETH");
+-   ("/xe1/x9a/xa8", "RUNIC LETTER ANSUZ A");
+-   ("/xe1/x9a/xa9", "RUNIC LETTER OS O");
+-   ("/xe1/x9a/xaa", "RUNIC LETTER AC A");
+-   ("/xe1/x9a/xab", "RUNIC LETTER AESC");
+-   ("/xe1/x9a/xac", "RUNIC LETTER LONG-BRANCH-OSS O");
+-   ("/xe1/x9a/xad", "RUNIC LETTER SHORT-TWIG-OSS O");
+-   ("/xe1/x9a/xae", "RUNIC LETTER O");
+-   ("/xe1/x9a/xaf", "RUNIC LETTER OE");
+-   ("/xe1/x9a/xb0", "RUNIC LETTER ON");
+-   ("/xe1/x9a/xb1", "RUNIC LETTER RAIDO RAD REID R");
+-   ("/xe1/x9a/xb2", "RUNIC LETTER KAUNA");
+-   ("/xe1/x9a/xb3", "RUNIC LETTER CEN");
+-   ("/xe1/x9a/xb4", "RUNIC LETTER KAUN K");
+-   ("/xe1/x9a/xb5", "RUNIC LETTER G");
+-   ("/xe1/x9a/xb6", "RUNIC LETTER ENG");
+-   ("/xe1/x9a/xb7", "RUNIC LETTER GEBO GYFU G");
+-   ("/xe1/x9a/xb8", "RUNIC LETTER GAR");
+-   ("/xe1/x9a/xb9", "RUNIC LETTER WUNJO WYNN W");
+-   ("/xe1/x9a/xba", "RUNIC LETTER HAGLAZ H");
+-   ("/xe1/x9a/xbb", "RUNIC LETTER HAEGL H");
+-   ("/xe1/x9a/xbc", "RUNIC LETTER LONG-BRANCH-HAGALL H");
+-   ("/xe1/x9a/xbd", "RUNIC LETTER SHORT-TWIG-HAGALL H");
+-   ("/xe1/x9a/xbe", "RUNIC LETTER NAUDIZ NYD NAUD N");
+-   ("/xe1/x9a/xbf", "RUNIC LETTER SHORT-TWIG-NAUD N");
+-   ("/xe1/x9b/x80", "RUNIC LETTER DOTTED-N");
+-   ("/xe1/x9b/x81", "RUNIC LETTER ISAZ IS ISS I");
+-   ("/xe1/x9b/x82", "RUNIC LETTER E");
+-   ("/xe1/x9b/x83", "RUNIC LETTER JERAN J");
+-   ("/xe1/x9b/x84", "RUNIC LETTER GER");
+-   ("/xe1/x9b/x85", "RUNIC LETTER LONG-BRANCH-AR AE");
+-   ("/xe1/x9b/x86", "RUNIC LETTER SHORT-TWIG-AR A");
+-   ("/xe1/x9b/x87", "RUNIC LETTER IWAZ EOH");
+-   ("/xe1/x9b/x88", "RUNIC LETTER PERTHO PEORTH P");
+-   ("/xe1/x9b/x89", "RUNIC LETTER ALGIZ EOLHX");
+-   ("/xe1/x9b/x8a", "RUNIC LETTER SOWILO S");
+-   ("/xe1/x9b/x8b", "RUNIC LETTER SIGEL LONG-BRANCH-SOL S");
+-   ("/xe1/x9b/x8c", "RUNIC LETTER SHORT-TWIG-SOL S");
+-   ("/xe1/x9b/x8d", "RUNIC LETTER C");
+-   ("/xe1/x9b/x8e", "RUNIC LETTER Z");
+-   ("/xe1/x9b/x8f", "RUNIC LETTER TIWAZ TIR TYR T");
+-   ("/xe1/x9b/x90", "RUNIC LETTER SHORT-TWIG-TYR T");
+-   ("/xe1/x9b/x91", "RUNIC LETTER D");
+-   ("/xe1/x9b/x92", "RUNIC LETTER BERKANAN BEORC BJARKAN B");
+-   ("/xe1/x9b/x93", "RUNIC LETTER SHORT-TWIG-BJARKAN B");
+-   ("/xe1/x9b/x94", "RUNIC LETTER DOTTED-P");
+-   ("/xe1/x9b/x95", "RUNIC LETTER OPEN-P");
+-   ("/xe1/x9b/x96", "RUNIC LETTER EHWAZ EH E");
+-   ("/xe1/x9b/x97", "RUNIC LETTER MANNAZ MAN M");
+-   ("/xe1/x9b/x98", "RUNIC LETTER LONG-BRANCH-MADR M");
+-   ("/xe1/x9b/x99", "RUNIC LETTER SHORT-TWIG-MADR M");
+-   ("/xe1/x9b/x9a", "RUNIC LETTER LAUKAZ LAGU LOGR L");
+-   ("/xe1/x9b/x9b", "RUNIC LETTER DOTTED-L");
+-   ("/xe1/x9b/x9c", "RUNIC LETTER INGWAZ");
+-   ("/xe1/x9b/x9d", "RUNIC LETTER ING");
+-   ("/xe1/x9b/x9e", "RUNIC LETTER DAGAZ DAEG D");
+-   ("/xe1/x9b/x9f", "RUNIC LETTER OTHALAN ETHEL O");
+-   ("/xe1/x9b/xa0", "RUNIC LETTER EAR");
+-   ("/xe1/x9b/xa1", "RUNIC LETTER IOR");
+-   ("/xe1/x9b/xa2", "RUNIC LETTER CWEORTH");
+-   ("/xe1/x9b/xa3", "RUNIC LETTER CALC");
+-   ("/xe1/x9b/xa4", "RUNIC LETTER CEALC");
+-   ("/xe1/x9b/xa5", "RUNIC LETTER STAN");
+-   ("/xe1/x9b/xa6", "RUNIC LETTER LONG-BRANCH-YR");
+-   ("/xe1/x9b/xa7", "RUNIC LETTER SHORT-TWIG-YR");
+-   ("/xe1/x9b/xa8", "RUNIC LETTER ICELANDIC-YR");
+-   ("/xe1/x9b/xa9", "RUNIC LETTER Q");
+-   ("/xe1/x9b/xaa", "RUNIC LETTER X");
+-   ("/xe1/x9b/xab", "RUNIC SINGLE PUNCTUATION");
+-   ("/xe1/x9b/xac", "RUNIC MULTIPLE PUNCTUATION");
+-   ("/xe1/x9b/xad", "RUNIC CROSS PUNCTUATION");
+-   ("/xe1/x9b/xae", "RUNIC ARLAUG SYMBOL");
+-   ("/xe1/x9b/xaf", "RUNIC TVIMADUR SYMBOL");
+-   ("/xe1/x9b/xb0", "RUNIC BELGTHOR SYMBOL");
+-   ("/xe1/x9c/x80", "TAGALOG LETTER A");
+-   ("/xe1/x9c/x81", "TAGALOG LETTER I");
+-   ("/xe1/x9c/x82", "TAGALOG LETTER U");
+-   ("/xe1/x9c/x83", "TAGALOG LETTER KA");
+-   ("/xe1/x9c/x84", "TAGALOG LETTER GA");
+-   ("/xe1/x9c/x85", "TAGALOG LETTER NGA");
+-   ("/xe1/x9c/x86", "TAGALOG LETTER TA");
+-   ("/xe1/x9c/x87", "TAGALOG LETTER DA");
+-   ("/xe1/x9c/x88", "TAGALOG LETTER NA");
+-   ("/xe1/x9c/x89", "TAGALOG LETTER PA");
+-   ("/xe1/x9c/x8a", "TAGALOG LETTER BA");
+-   ("/xe1/x9c/x8b", "TAGALOG LETTER MA");
+-   ("/xe1/x9c/x8c", "TAGALOG LETTER YA");
+-   ("/xe1/x9c/x8e", "TAGALOG LETTER LA");
+-   ("/xe1/x9c/x8f", "TAGALOG LETTER WA");
+-   ("/xe1/x9c/x90", "TAGALOG LETTER SA");
+-   ("/xe1/x9c/x91", "TAGALOG LETTER HA");
+-   ("/xe1/x9c/x92", "TAGALOG VOWEL SIGN I");
+-   ("/xe1/x9c/x93", "TAGALOG VOWEL SIGN U");
+-   ("/xe1/x9c/x94", "TAGALOG SIGN VIRAMA");
+-   ("/xe1/x9c/xa0", "HANUNOO LETTER A");
+-   ("/xe1/x9c/xa1", "HANUNOO LETTER I");
+-   ("/xe1/x9c/xa2", "HANUNOO LETTER U");
+-   ("/xe1/x9c/xa3", "HANUNOO LETTER KA");
+-   ("/xe1/x9c/xa4", "HANUNOO LETTER GA");
+-   ("/xe1/x9c/xa5", "HANUNOO LETTER NGA");
+-   ("/xe1/x9c/xa6", "HANUNOO LETTER TA");
+-   ("/xe1/x9c/xa7", "HANUNOO LETTER DA");
+-   ("/xe1/x9c/xa8", "HANUNOO LETTER NA");
+-   ("/xe1/x9c/xa9", "HANUNOO LETTER PA");
+-   ("/xe1/x9c/xaa", "HANUNOO LETTER BA");
+-   ("/xe1/x9c/xab", "HANUNOO LETTER MA");
+-   ("/xe1/x9c/xac", "HANUNOO LETTER YA");
+-   ("/xe1/x9c/xad", "HANUNOO LETTER RA");
+-   ("/xe1/x9c/xae", "HANUNOO LETTER LA");
+-   ("/xe1/x9c/xaf", "HANUNOO LETTER WA");
+-   ("/xe1/x9c/xb0", "HANUNOO LETTER SA");
+-   ("/xe1/x9c/xb1", "HANUNOO LETTER HA");
+-   ("/xe1/x9c/xb2", "HANUNOO VOWEL SIGN I");
+-   ("/xe1/x9c/xb3", "HANUNOO VOWEL SIGN U");
+-   ("/xe1/x9c/xb4", "HANUNOO SIGN PAMUDPOD");
+-   ("/xe1/x9c/xb5", "PHILIPPINE SINGLE PUNCTUATION");
+-   ("/xe1/x9c/xb6", "PHILIPPINE DOUBLE PUNCTUATION");
+-   ("/xe1/x9d/x80", "BUHID LETTER A");
+-   ("/xe1/x9d/x81", "BUHID LETTER I");
+-   ("/xe1/x9d/x82", "BUHID LETTER U");
+-   ("/xe1/x9d/x83", "BUHID LETTER KA");
+-   ("/xe1/x9d/x84", "BUHID LETTER GA");
+-   ("/xe1/x9d/x85", "BUHID LETTER NGA");
+-   ("/xe1/x9d/x86", "BUHID LETTER TA");
+-   ("/xe1/x9d/x87", "BUHID LETTER DA");
+-   ("/xe1/x9d/x88", "BUHID LETTER NA");
+-   ("/xe1/x9d/x89", "BUHID LETTER PA");
+-   ("/xe1/x9d/x8a", "BUHID LETTER BA");
+-   ("/xe1/x9d/x8b", "BUHID LETTER MA");
+-   ("/xe1/x9d/x8c", "BUHID LETTER YA");
+-   ("/xe1/x9d/x8d", "BUHID LETTER RA");
+-   ("/xe1/x9d/x8e", "BUHID LETTER LA");
+-   ("/xe1/x9d/x8f", "BUHID LETTER WA");
+-   ("/xe1/x9d/x90", "BUHID LETTER SA");
+-   ("/xe1/x9d/x91", "BUHID LETTER HA");
+-   ("/xe1/x9d/x92", "BUHID VOWEL SIGN I");
+-   ("/xe1/x9d/x93", "BUHID VOWEL SIGN U");
+-   ("/xe1/x9d/xa0", "TAGBANWA LETTER A");
+-   ("/xe1/x9d/xa1", "TAGBANWA LETTER I");
+-   ("/xe1/x9d/xa2", "TAGBANWA LETTER U");
+-   ("/xe1/x9d/xa3", "TAGBANWA LETTER KA");
+-   ("/xe1/x9d/xa4", "TAGBANWA LETTER GA");
+-   ("/xe1/x9d/xa5", "TAGBANWA LETTER NGA");
+-   ("/xe1/x9d/xa6", "TAGBANWA LETTER TA");
+-   ("/xe1/x9d/xa7", "TAGBANWA LETTER DA");
+-   ("/xe1/x9d/xa8", "TAGBANWA LETTER NA");
+-   ("/xe1/x9d/xa9", "TAGBANWA LETTER PA");
+-   ("/xe1/x9d/xaa", "TAGBANWA LETTER BA");
+-   ("/xe1/x9d/xab", "TAGBANWA LETTER MA");
+-   ("/xe1/x9d/xac", "TAGBANWA LETTER YA");
+-   ("/xe1/x9d/xae", "TAGBANWA LETTER LA");
+-   ("/xe1/x9d/xaf", "TAGBANWA LETTER WA");
+-   ("/xe1/x9d/xb0", "TAGBANWA LETTER SA");
+-   ("/xe1/x9d/xb2", "TAGBANWA VOWEL SIGN I");
+-   ("/xe1/x9d/xb3", "TAGBANWA VOWEL SIGN U");
+-   ("/xe1/x9e/x80", "KHMER LETTER KA");
+-   ("/xe1/x9e/x81", "KHMER LETTER KHA");
+-   ("/xe1/x9e/x82", "KHMER LETTER KO");
+-   ("/xe1/x9e/x83", "KHMER LETTER KHO");
+-   ("/xe1/x9e/x84", "KHMER LETTER NGO");
+-   ("/xe1/x9e/x85", "KHMER LETTER CA");
+-   ("/xe1/x9e/x86", "KHMER LETTER CHA");
+-   ("/xe1/x9e/x87", "KHMER LETTER CO");
+-   ("/xe1/x9e/x88", "KHMER LETTER CHO");
+-   ("/xe1/x9e/x89", "KHMER LETTER NYO");
+-   ("/xe1/x9e/x8a", "KHMER LETTER DA");
+-   ("/xe1/x9e/x8b", "KHMER LETTER TTHA");
+-   ("/xe1/x9e/x8c", "KHMER LETTER DO");
+-   ("/xe1/x9e/x8d", "KHMER LETTER TTHO");
+-   ("/xe1/x9e/x8e", "KHMER LETTER NNO");
+-   ("/xe1/x9e/x8f", "KHMER LETTER TA");
+-   ("/xe1/x9e/x90", "KHMER LETTER THA");
+-   ("/xe1/x9e/x91", "KHMER LETTER TO");
+-   ("/xe1/x9e/x92", "KHMER LETTER THO");
+-   ("/xe1/x9e/x93", "KHMER LETTER NO");
+-   ("/xe1/x9e/x94", "KHMER LETTER BA");
+-   ("/xe1/x9e/x95", "KHMER LETTER PHA");
+-   ("/xe1/x9e/x96", "KHMER LETTER PO");
+-   ("/xe1/x9e/x97", "KHMER LETTER PHO");
+-   ("/xe1/x9e/x98", "KHMER LETTER MO");
+-   ("/xe1/x9e/x99", "KHMER LETTER YO");
+-   ("/xe1/x9e/x9a", "KHMER LETTER RO");
+-   ("/xe1/x9e/x9b", "KHMER LETTER LO");
+-   ("/xe1/x9e/x9c", "KHMER LETTER VO");
+-   ("/xe1/x9e/x9d", "KHMER LETTER SHA");
+-   ("/xe1/x9e/x9e", "KHMER LETTER SSO");
+-   ("/xe1/x9e/x9f", "KHMER LETTER SA");
+-   ("/xe1/x9e/xa0", "KHMER LETTER HA");
+-   ("/xe1/x9e/xa1", "KHMER LETTER LA");
+-   ("/xe1/x9e/xa2", "KHMER LETTER QA");
+-   ("/xe1/x9e/xa3", "KHMER INDEPENDENT VOWEL QAQ");
+-   ("/xe1/x9e/xa4", "KHMER INDEPENDENT VOWEL QAA");
+-   ("/xe1/x9e/xa5", "KHMER INDEPENDENT VOWEL QI");
+-   ("/xe1/x9e/xa6", "KHMER INDEPENDENT VOWEL QII");
+-   ("/xe1/x9e/xa7", "KHMER INDEPENDENT VOWEL QU");
+-   ("/xe1/x9e/xa8", "KHMER INDEPENDENT VOWEL QUK");
+-   ("/xe1/x9e/xa9", "KHMER INDEPENDENT VOWEL QUU");
+-   ("/xe1/x9e/xaa", "KHMER INDEPENDENT VOWEL QUUV");
+-   ("/xe1/x9e/xab", "KHMER INDEPENDENT VOWEL RY");
+-   ("/xe1/x9e/xac", "KHMER INDEPENDENT VOWEL RYY");
+-   ("/xe1/x9e/xad", "KHMER INDEPENDENT VOWEL LY");
+-   ("/xe1/x9e/xae", "KHMER INDEPENDENT VOWEL LYY");
+-   ("/xe1/x9e/xaf", "KHMER INDEPENDENT VOWEL QE");
+-   ("/xe1/x9e/xb0", "KHMER INDEPENDENT VOWEL QAI");
+-   ("/xe1/x9e/xb1", "KHMER INDEPENDENT VOWEL QOO TYPE ONE");
+-   ("/xe1/x9e/xb2", "KHMER INDEPENDENT VOWEL QOO TYPE TWO");
+-   ("/xe1/x9e/xb3", "KHMER INDEPENDENT VOWEL QAU");
+-   ("/xe1/x9e/xb4", "KHMER VOWEL INHERENT AQ");
+-   ("/xe1/x9e/xb5", "KHMER VOWEL INHERENT AA");
+-   ("/xe1/x9e/xb6", "KHMER VOWEL SIGN AA");
+-   ("/xe1/x9e/xb7", "KHMER VOWEL SIGN I");
+-   ("/xe1/x9e/xb8", "KHMER VOWEL SIGN II");
+-   ("/xe1/x9e/xb9", "KHMER VOWEL SIGN Y");
+-   ("/xe1/x9e/xba", "KHMER VOWEL SIGN YY");
+-   ("/xe1/x9e/xbb", "KHMER VOWEL SIGN U");
+-   ("/xe1/x9e/xbc", "KHMER VOWEL SIGN UU");
+-   ("/xe1/x9e/xbd", "KHMER VOWEL SIGN UA");
+-   ("/xe1/x9e/xbe", "KHMER VOWEL SIGN OE");
+-   ("/xe1/x9e/xbf", "KHMER VOWEL SIGN YA");
+-   ("/xe1/x9f/x80", "KHMER VOWEL SIGN IE");
+-   ("/xe1/x9f/x81", "KHMER VOWEL SIGN E");
+-   ("/xe1/x9f/x82", "KHMER VOWEL SIGN AE");
+-   ("/xe1/x9f/x83", "KHMER VOWEL SIGN AI");
+-   ("/xe1/x9f/x84", "KHMER VOWEL SIGN OO");
+-   ("/xe1/x9f/x85", "KHMER VOWEL SIGN AU");
+-   ("/xe1/x9f/x86", "KHMER SIGN NIKAHIT");
+-   ("/xe1/x9f/x87", "KHMER SIGN REAHMUK");
+-   ("/xe1/x9f/x88", "KHMER SIGN YUUKALEAPINTU");
+-   ("/xe1/x9f/x89", "KHMER SIGN MUUSIKATOAN");
+-   ("/xe1/x9f/x8a", "KHMER SIGN TRIISAP");
+-   ("/xe1/x9f/x8b", "KHMER SIGN BANTOC");
+-   ("/xe1/x9f/x8c", "KHMER SIGN ROBAT");
+-   ("/xe1/x9f/x8d", "KHMER SIGN TOANDAKHIAT");
+-   ("/xe1/x9f/x8e", "KHMER SIGN KAKABAT");
+-   ("/xe1/x9f/x8f", "KHMER SIGN AHSDA");
+-   ("/xe1/x9f/x90", "KHMER SIGN SAMYOK SANNYA");
+-   ("/xe1/x9f/x91", "KHMER SIGN VIRIAM");
+-   ("/xe1/x9f/x92", "KHMER SIGN COENG");
+-   ("/xe1/x9f/x93", "KHMER SIGN BATHAMASAT");
+-   ("/xe1/x9f/x94", "KHMER SIGN KHAN");
+-   ("/xe1/x9f/x95", "KHMER SIGN BARIYOOSAN");
+-   ("/xe1/x9f/x96", "KHMER SIGN CAMNUC PII KUUH");
+-   ("/xe1/x9f/x97", "KHMER SIGN LEK TOO");
+-   ("/xe1/x9f/x98", "KHMER SIGN BEYYAL");
+-   ("/xe1/x9f/x99", "KHMER SIGN PHNAEK MUAN");
+-   ("/xe1/x9f/x9a", "KHMER SIGN KOOMUUT");
+-   ("/xe1/x9f/x9b", "KHMER CURRENCY SYMBOL RIEL");
+-   ("/xe1/x9f/x9c", "KHMER SIGN AVAKRAHASANYA");
+-   ("/xe1/x9f/x9d", "KHMER SIGN ATTHACAN");
+-   ("/xe1/x9f/xa0", "KHMER DIGIT ZERO");
+-   ("/xe1/x9f/xa1", "KHMER DIGIT ONE");
+-   ("/xe1/x9f/xa2", "KHMER DIGIT TWO");
+-   ("/xe1/x9f/xa3", "KHMER DIGIT THREE");
+-   ("/xe1/x9f/xa4", "KHMER DIGIT FOUR");
+-   ("/xe1/x9f/xa5", "KHMER DIGIT FIVE");
+-   ("/xe1/x9f/xa6", "KHMER DIGIT SIX");
+-   ("/xe1/x9f/xa7", "KHMER DIGIT SEVEN");
+-   ("/xe1/x9f/xa8", "KHMER DIGIT EIGHT");
+-   ("/xe1/x9f/xa9", "KHMER DIGIT NINE");
+-   ("/xe1/x9f/xb0", "KHMER SYMBOL LEK ATTAK SON");
+-   ("/xe1/x9f/xb1", "KHMER SYMBOL LEK ATTAK MUOY");
+-   ("/xe1/x9f/xb2", "KHMER SYMBOL LEK ATTAK PII");
+-   ("/xe1/x9f/xb3", "KHMER SYMBOL LEK ATTAK BEI");
+-   ("/xe1/x9f/xb4", "KHMER SYMBOL LEK ATTAK BUON");
+-   ("/xe1/x9f/xb5", "KHMER SYMBOL LEK ATTAK PRAM");
+-   ("/xe1/x9f/xb6", "KHMER SYMBOL LEK ATTAK PRAM-MUOY");
+-   ("/xe1/x9f/xb7", "KHMER SYMBOL LEK ATTAK PRAM-PII");
+-   ("/xe1/x9f/xb8", "KHMER SYMBOL LEK ATTAK PRAM-BEI");
+-   ("/xe1/x9f/xb9", "KHMER SYMBOL LEK ATTAK PRAM-BUON");
+-   ("/xe1/xa0/x80", "MONGOLIAN BIRGA");
+-   ("/xe1/xa0/x81", "MONGOLIAN ELLIPSIS");
+-   ("/xe1/xa0/x82", "MONGOLIAN COMMA");
+-   ("/xe1/xa0/x83", "MONGOLIAN FULL STOP");
+-   ("/xe1/xa0/x84", "MONGOLIAN COLON");
+-   ("/xe1/xa0/x85", "MONGOLIAN FOUR DOTS");
+-   ("/xe1/xa0/x86", "MONGOLIAN TODO SOFT HYPHEN");
+-   ("/xe1/xa0/x87", "MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER");
+-   ("/xe1/xa0/x88", "MONGOLIAN MANCHU COMMA");
+-   ("/xe1/xa0/x89", "MONGOLIAN MANCHU FULL STOP");
+-   ("/xe1/xa0/x8a", "MONGOLIAN NIRUGU");
+-   ("/xe1/xa0/x8b", "MONGOLIAN FREE VARIATION SELECTOR ONE");
+-   ("/xe1/xa0/x8c", "MONGOLIAN FREE VARIATION SELECTOR TWO");
+-   ("/xe1/xa0/x8d", "MONGOLIAN FREE VARIATION SELECTOR THREE");
+-   ("/xe1/xa0/x8e", "MONGOLIAN VOWEL SEPARATOR");
+-   ("/xe1/xa0/x90", "MONGOLIAN DIGIT ZERO");
+-   ("/xe1/xa0/x91", "MONGOLIAN DIGIT ONE");
+-   ("/xe1/xa0/x92", "MONGOLIAN DIGIT TWO");
+-   ("/xe1/xa0/x93", "MONGOLIAN DIGIT THREE");
+-   ("/xe1/xa0/x94", "MONGOLIAN DIGIT FOUR");
+-   ("/xe1/xa0/x95", "MONGOLIAN DIGIT FIVE");
+-   ("/xe1/xa0/x96", "MONGOLIAN DIGIT SIX");
+-   ("/xe1/xa0/x97", "MONGOLIAN DIGIT SEVEN");
+-   ("/xe1/xa0/x98", "MONGOLIAN DIGIT EIGHT");
+-   ("/xe1/xa0/x99", "MONGOLIAN DIGIT NINE");
+-   ("/xe1/xa0/xa0", "MONGOLIAN LETTER A");
+-   ("/xe1/xa0/xa1", "MONGOLIAN LETTER E");
+-   ("/xe1/xa0/xa2", "MONGOLIAN LETTER I");
+-   ("/xe1/xa0/xa3", "MONGOLIAN LETTER O");
+-   ("/xe1/xa0/xa4", "MONGOLIAN LETTER U");
+-   ("/xe1/xa0/xa5", "MONGOLIAN LETTER OE");
+-   ("/xe1/xa0/xa6", "MONGOLIAN LETTER UE");
+-   ("/xe1/xa0/xa7", "MONGOLIAN LETTER EE");
+-   ("/xe1/xa0/xa8", "MONGOLIAN LETTER NA");
+-   ("/xe1/xa0/xa9", "MONGOLIAN LETTER ANG");
+-   ("/xe1/xa0/xaa", "MONGOLIAN LETTER BA");
+-   ("/xe1/xa0/xab", "MONGOLIAN LETTER PA");
+-   ("/xe1/xa0/xac", "MONGOLIAN LETTER QA");
+-   ("/xe1/xa0/xad", "MONGOLIAN LETTER GA");
+-   ("/xe1/xa0/xae", "MONGOLIAN LETTER MA");
+-   ("/xe1/xa0/xaf", "MONGOLIAN LETTER LA");
+-   ("/xe1/xa0/xb0", "MONGOLIAN LETTER SA");
+-   ("/xe1/xa0/xb1", "MONGOLIAN LETTER SHA");
+-   ("/xe1/xa0/xb2", "MONGOLIAN LETTER TA");
+-   ("/xe1/xa0/xb3", "MONGOLIAN LETTER DA");
+-   ("/xe1/xa0/xb4", "MONGOLIAN LETTER CHA");
+-   ("/xe1/xa0/xb5", "MONGOLIAN LETTER JA");
+-   ("/xe1/xa0/xb6", "MONGOLIAN LETTER YA");
+-   ("/xe1/xa0/xb7", "MONGOLIAN LETTER RA");
+-   ("/xe1/xa0/xb8", "MONGOLIAN LETTER WA");
+-   ("/xe1/xa0/xb9", "MONGOLIAN LETTER FA");
+-   ("/xe1/xa0/xba", "MONGOLIAN LETTER KA");
+-   ("/xe1/xa0/xbb", "MONGOLIAN LETTER KHA");
+-   ("/xe1/xa0/xbc", "MONGOLIAN LETTER TSA");
+-   ("/xe1/xa0/xbd", "MONGOLIAN LETTER ZA");
+-   ("/xe1/xa0/xbe", "MONGOLIAN LETTER HAA");
+-   ("/xe1/xa0/xbf", "MONGOLIAN LETTER ZRA");
+-   ("/xe1/xa1/x80", "MONGOLIAN LETTER LHA");
+-   ("/xe1/xa1/x81", "MONGOLIAN LETTER ZHI");
+-   ("/xe1/xa1/x82", "MONGOLIAN LETTER CHI");
+-   ("/xe1/xa1/x83", "MONGOLIAN LETTER TODO LONG VOWEL SIGN");
+-   ("/xe1/xa1/x84", "MONGOLIAN LETTER TODO E");
+-   ("/xe1/xa1/x85", "MONGOLIAN LETTER TODO I");
+-   ("/xe1/xa1/x86", "MONGOLIAN LETTER TODO O");
+-   ("/xe1/xa1/x87", "MONGOLIAN LETTER TODO U");
+-   ("/xe1/xa1/x88", "MONGOLIAN LETTER TODO OE");
+-   ("/xe1/xa1/x89", "MONGOLIAN LETTER TODO UE");
+-   ("/xe1/xa1/x8a", "MONGOLIAN LETTER TODO ANG");
+-   ("/xe1/xa1/x8b", "MONGOLIAN LETTER TODO BA");
+-   ("/xe1/xa1/x8c", "MONGOLIAN LETTER TODO PA");
+-   ("/xe1/xa1/x8d", "MONGOLIAN LETTER TODO QA");
+-   ("/xe1/xa1/x8e", "MONGOLIAN LETTER TODO GA");
+-   ("/xe1/xa1/x8f", "MONGOLIAN LETTER TODO MA");
+-   ("/xe1/xa1/x90", "MONGOLIAN LETTER TODO TA");
+-   ("/xe1/xa1/x91", "MONGOLIAN LETTER TODO DA");
+-   ("/xe1/xa1/x92", "MONGOLIAN LETTER TODO CHA");
+-   ("/xe1/xa1/x93", "MONGOLIAN LETTER TODO JA");
+-   ("/xe1/xa1/x94", "MONGOLIAN LETTER TODO TSA");
+-   ("/xe1/xa1/x95", "MONGOLIAN LETTER TODO YA");
+-   ("/xe1/xa1/x96", "MONGOLIAN LETTER TODO WA");
+-   ("/xe1/xa1/x97", "MONGOLIAN LETTER TODO KA");
+-   ("/xe1/xa1/x98", "MONGOLIAN LETTER TODO GAA");
+-   ("/xe1/xa1/x99", "MONGOLIAN LETTER TODO HAA");
+-   ("/xe1/xa1/x9a", "MONGOLIAN LETTER TODO JIA");
+-   ("/xe1/xa1/x9b", "MONGOLIAN LETTER TODO NIA");
+-   ("/xe1/xa1/x9c", "MONGOLIAN LETTER TODO DZA");
+-   ("/xe1/xa1/x9d", "MONGOLIAN LETTER SIBE E");
+-   ("/xe1/xa1/x9e", "MONGOLIAN LETTER SIBE I");
+-   ("/xe1/xa1/x9f", "MONGOLIAN LETTER SIBE IY");
+-   ("/xe1/xa1/xa0", "MONGOLIAN LETTER SIBE UE");
+-   ("/xe1/xa1/xa1", "MONGOLIAN LETTER SIBE U");
+-   ("/xe1/xa1/xa2", "MONGOLIAN LETTER SIBE ANG");
+-   ("/xe1/xa1/xa3", "MONGOLIAN LETTER SIBE KA");
+-   ("/xe1/xa1/xa4", "MONGOLIAN LETTER SIBE GA");
+-   ("/xe1/xa1/xa5", "MONGOLIAN LETTER SIBE HA");
+-   ("/xe1/xa1/xa6", "MONGOLIAN LETTER SIBE PA");
+-   ("/xe1/xa1/xa7", "MONGOLIAN LETTER SIBE SHA");
+-   ("/xe1/xa1/xa8", "MONGOLIAN LETTER SIBE TA");
+-   ("/xe1/xa1/xa9", "MONGOLIAN LETTER SIBE DA");
+-   ("/xe1/xa1/xaa", "MONGOLIAN LETTER SIBE JA");
+-   ("/xe1/xa1/xab", "MONGOLIAN LETTER SIBE FA");
+-   ("/xe1/xa1/xac", "MONGOLIAN LETTER SIBE GAA");
+-   ("/xe1/xa1/xad", "MONGOLIAN LETTER SIBE HAA");
+-   ("/xe1/xa1/xae", "MONGOLIAN LETTER SIBE TSA");
+-   ("/xe1/xa1/xaf", "MONGOLIAN LETTER SIBE ZA");
+-   ("/xe1/xa1/xb0", "MONGOLIAN LETTER SIBE RAA");
+-   ("/xe1/xa1/xb1", "MONGOLIAN LETTER SIBE CHA");
+-   ("/xe1/xa1/xb2", "MONGOLIAN LETTER SIBE ZHA");
+-   ("/xe1/xa1/xb3", "MONGOLIAN LETTER MANCHU I");
+-   ("/xe1/xa1/xb4", "MONGOLIAN LETTER MANCHU KA");
+-   ("/xe1/xa1/xb5", "MONGOLIAN LETTER MANCHU RA");
+-   ("/xe1/xa1/xb6", "MONGOLIAN LETTER MANCHU FA");
+-   ("/xe1/xa1/xb7", "MONGOLIAN LETTER MANCHU ZHA");
+-   ("/xe1/xa2/x80", "MONGOLIAN LETTER ALI GALI ANUSVARA ONE");
+-   ("/xe1/xa2/x81", "MONGOLIAN LETTER ALI GALI VISARGA ONE");
+-   ("/xe1/xa2/x82", "MONGOLIAN LETTER ALI GALI DAMARU");
+-   ("/xe1/xa2/x83", "MONGOLIAN LETTER ALI GALI UBADAMA");
+-   ("/xe1/xa2/x84", "MONGOLIAN LETTER ALI GALI INVERTED UBADAMA");
+-   ("/xe1/xa2/x85", "MONGOLIAN LETTER ALI GALI BALUDA");
+-   ("/xe1/xa2/x86", "MONGOLIAN LETTER ALI GALI THREE BALUDA");
+-   ("/xe1/xa2/x87", "MONGOLIAN LETTER ALI GALI A");
+-   ("/xe1/xa2/x88", "MONGOLIAN LETTER ALI GALI I");
+-   ("/xe1/xa2/x89", "MONGOLIAN LETTER ALI GALI KA");
+-   ("/xe1/xa2/x8a", "MONGOLIAN LETTER ALI GALI NGA");
+-   ("/xe1/xa2/x8b", "MONGOLIAN LETTER ALI GALI CA");
+-   ("/xe1/xa2/x8c", "MONGOLIAN LETTER ALI GALI TTA");
+-   ("/xe1/xa2/x8d", "MONGOLIAN LETTER ALI GALI TTHA");
+-   ("/xe1/xa2/x8e", "MONGOLIAN LETTER ALI GALI DDA");
+-   ("/xe1/xa2/x8f", "MONGOLIAN LETTER ALI GALI NNA");
+-   ("/xe1/xa2/x90", "MONGOLIAN LETTER ALI GALI TA");
+-   ("/xe1/xa2/x91", "MONGOLIAN LETTER ALI GALI DA");
+-   ("/xe1/xa2/x92", "MONGOLIAN LETTER ALI GALI PA");
+-   ("/xe1/xa2/x93", "MONGOLIAN LETTER ALI GALI PHA");
+-   ("/xe1/xa2/x94", "MONGOLIAN LETTER ALI GALI SSA");
+-   ("/xe1/xa2/x95", "MONGOLIAN LETTER ALI GALI ZHA");
+-   ("/xe1/xa2/x96", "MONGOLIAN LETTER ALI GALI ZA");
+-   ("/xe1/xa2/x97", "MONGOLIAN LETTER ALI GALI AH");
+-   ("/xe1/xa2/x98", "MONGOLIAN LETTER TODO ALI GALI TA");
+-   ("/xe1/xa2/x99", "MONGOLIAN LETTER TODO ALI GALI ZHA");
+-   ("/xe1/xa2/x9a", "MONGOLIAN LETTER MANCHU ALI GALI GHA");
+-   ("/xe1/xa2/x9b", "MONGOLIAN LETTER MANCHU ALI GALI NGA");
+-   ("/xe1/xa2/x9c", "MONGOLIAN LETTER MANCHU ALI GALI CA");
+-   ("/xe1/xa2/x9d", "MONGOLIAN LETTER MANCHU ALI GALI JHA");
+-   ("/xe1/xa2/x9e", "MONGOLIAN LETTER MANCHU ALI GALI TTA");
+-   ("/xe1/xa2/x9f", "MONGOLIAN LETTER MANCHU ALI GALI DDHA");
+-   ("/xe1/xa2/xa0", "MONGOLIAN LETTER MANCHU ALI GALI TA");
+-   ("/xe1/xa2/xa1", "MONGOLIAN LETTER MANCHU ALI GALI DHA");
+-   ("/xe1/xa2/xa2", "MONGOLIAN LETTER MANCHU ALI GALI SSA");
+-   ("/xe1/xa2/xa3", "MONGOLIAN LETTER MANCHU ALI GALI CYA");
+-   ("/xe1/xa2/xa4", "MONGOLIAN LETTER MANCHU ALI GALI ZHA");
+-   ("/xe1/xa2/xa5", "MONGOLIAN LETTER MANCHU ALI GALI ZA");
+-   ("/xe1/xa2/xa6", "MONGOLIAN LETTER ALI GALI HALF U");
+-   ("/xe1/xa2/xa7", "MONGOLIAN LETTER ALI GALI HALF YA");
+-   ("/xe1/xa2/xa8", "MONGOLIAN LETTER MANCHU ALI GALI BHA");
+-   ("/xe1/xa2/xa9", "MONGOLIAN LETTER ALI GALI DAGALGA");
+-   ("/xe1/xa2/xaa", "MONGOLIAN LETTER MANCHU ALI GALI LHA");
+-   ("/xe1/xa4/x80", "LIMBU VOWEL-CARRIER LETTER");
+-   ("/xe1/xa4/x81", "LIMBU LETTER KA");
+-   ("/xe1/xa4/x82", "LIMBU LETTER KHA");
+-   ("/xe1/xa4/x83", "LIMBU LETTER GA");
+-   ("/xe1/xa4/x84", "LIMBU LETTER GHA");
+-   ("/xe1/xa4/x85", "LIMBU LETTER NGA");
+-   ("/xe1/xa4/x86", "LIMBU LETTER CA");
+-   ("/xe1/xa4/x87", "LIMBU LETTER CHA");
+-   ("/xe1/xa4/x88", "LIMBU LETTER JA");
+-   ("/xe1/xa4/x89", "LIMBU LETTER JHA");
+-   ("/xe1/xa4/x8a", "LIMBU LETTER YAN");
+-   ("/xe1/xa4/x8b", "LIMBU LETTER TA");
+-   ("/xe1/xa4/x8c", "LIMBU LETTER THA");
+-   ("/xe1/xa4/x8d", "LIMBU LETTER DA");
+-   ("/xe1/xa4/x8e", "LIMBU LETTER DHA");
+-   ("/xe1/xa4/x8f", "LIMBU LETTER NA");
+-   ("/xe1/xa4/x90", "LIMBU LETTER PA");
+-   ("/xe1/xa4/x91", "LIMBU LETTER PHA");
+-   ("/xe1/xa4/x92", "LIMBU LETTER BA");
+-   ("/xe1/xa4/x93", "LIMBU LETTER BHA");
+-   ("/xe1/xa4/x94", "LIMBU LETTER MA");
+-   ("/xe1/xa4/x95", "LIMBU LETTER YA");
+-   ("/xe1/xa4/x96", "LIMBU LETTER RA");
+-   ("/xe1/xa4/x97", "LIMBU LETTER LA");
+-   ("/xe1/xa4/x98", "LIMBU LETTER WA");
+-   ("/xe1/xa4/x99", "LIMBU LETTER SHA");
+-   ("/xe1/xa4/x9a", "LIMBU LETTER SSA");
+-   ("/xe1/xa4/x9b", "LIMBU LETTER SA");
+-   ("/xe1/xa4/x9c", "LIMBU LETTER HA");
+-   ("/xe1/xa4/xa0", "LIMBU VOWEL SIGN A");
+-   ("/xe1/xa4/xa1", "LIMBU VOWEL SIGN I");
+-   ("/xe1/xa4/xa2", "LIMBU VOWEL SIGN U");
+-   ("/xe1/xa4/xa3", "LIMBU VOWEL SIGN EE");
+-   ("/xe1/xa4/xa4", "LIMBU VOWEL SIGN AI");
+-   ("/xe1/xa4/xa5", "LIMBU VOWEL SIGN OO");
+-   ("/xe1/xa4/xa6", "LIMBU VOWEL SIGN AU");
+-   ("/xe1/xa4/xa7", "LIMBU VOWEL SIGN E");
+-   ("/xe1/xa4/xa8", "LIMBU VOWEL SIGN O");
+-   ("/xe1/xa4/xa9", "LIMBU SUBJOINED LETTER YA");
+-   ("/xe1/xa4/xaa", "LIMBU SUBJOINED LETTER RA");
+-   ("/xe1/xa4/xab", "LIMBU SUBJOINED LETTER WA");
+    ("/xe1/xa4/xb0", "LIMBU SMALL LETTER KA");
+    ("/xe1/xa4/xb1", "LIMBU SMALL LETTER NGA");
+    ("/xe1/xa4/xb2", "LIMBU SMALL LETTER ANUSVARA");
+@@ -5286,497 +1120,6 @@
+    ("/xe1/xa4/xb6", "LIMBU SMALL LETTER MA");
+    ("/xe1/xa4/xb7", "LIMBU SMALL LETTER RA");
+    ("/xe1/xa4/xb8", "LIMBU SMALL LETTER LA");
+-   ("/xe1/xa4/xb9", "LIMBU SIGN MUKPHRENG");
+-   ("/xe1/xa4/xba", "LIMBU SIGN KEMPHRENG");
+-   ("/xe1/xa4/xbb", "LIMBU SIGN SA-I");
+-   ("/xe1/xa5/x80", "LIMBU SIGN LOO");
+-   ("/xe1/xa5/x84", "LIMBU EXCLAMATION MARK");
+-   ("/xe1/xa5/x85", "LIMBU QUESTION MARK");
+-   ("/xe1/xa5/x86", "LIMBU DIGIT ZERO");
+-   ("/xe1/xa5/x87", "LIMBU DIGIT ONE");
+-   ("/xe1/xa5/x88", "LIMBU DIGIT TWO");
+-   ("/xe1/xa5/x89", "LIMBU DIGIT THREE");
+-   ("/xe1/xa5/x8a", "LIMBU DIGIT FOUR");
+-   ("/xe1/xa5/x8b", "LIMBU DIGIT FIVE");
+-   ("/xe1/xa5/x8c", "LIMBU DIGIT SIX");
+-   ("/xe1/xa5/x8d", "LIMBU DIGIT SEVEN");
+-   ("/xe1/xa5/x8e", "LIMBU DIGIT EIGHT");
+-   ("/xe1/xa5/x8f", "LIMBU DIGIT NINE");
+-   ("/xe1/xa5/x90", "TAI LE LETTER KA");
+-   ("/xe1/xa5/x91", "TAI LE LETTER XA");
+-   ("/xe1/xa5/x92", "TAI LE LETTER NGA");
+-   ("/xe1/xa5/x93", "TAI LE LETTER TSA");
+-   ("/xe1/xa5/x94", "TAI LE LETTER SA");
+-   ("/xe1/xa5/x95", "TAI LE LETTER YA");
+-   ("/xe1/xa5/x96", "TAI LE LETTER TA");
+-   ("/xe1/xa5/x97", "TAI LE LETTER THA");
+-   ("/xe1/xa5/x98", "TAI LE LETTER LA");
+-   ("/xe1/xa5/x99", "TAI LE LETTER PA");
+-   ("/xe1/xa5/x9a", "TAI LE LETTER PHA");
+-   ("/xe1/xa5/x9b", "TAI LE LETTER MA");
+-   ("/xe1/xa5/x9c", "TAI LE LETTER FA");
+-   ("/xe1/xa5/x9d", "TAI LE LETTER VA");
+-   ("/xe1/xa5/x9e", "TAI LE LETTER HA");
+-   ("/xe1/xa5/x9f", "TAI LE LETTER QA");
+-   ("/xe1/xa5/xa0", "TAI LE LETTER KHA");
+-   ("/xe1/xa5/xa1", "TAI LE LETTER TSHA");
+-   ("/xe1/xa5/xa2", "TAI LE LETTER NA");
+-   ("/xe1/xa5/xa3", "TAI LE LETTER A");
+-   ("/xe1/xa5/xa4", "TAI LE LETTER I");
+-   ("/xe1/xa5/xa5", "TAI LE LETTER EE");
+-   ("/xe1/xa5/xa6", "TAI LE LETTER EH");
+-   ("/xe1/xa5/xa7", "TAI LE LETTER U");
+-   ("/xe1/xa5/xa8", "TAI LE LETTER OO");
+-   ("/xe1/xa5/xa9", "TAI LE LETTER O");
+-   ("/xe1/xa5/xaa", "TAI LE LETTER UE");
+-   ("/xe1/xa5/xab", "TAI LE LETTER E");
+-   ("/xe1/xa5/xac", "TAI LE LETTER AUE");
+-   ("/xe1/xa5/xad", "TAI LE LETTER AI");
+-   ("/xe1/xa5/xb0", "TAI LE LETTER TONE-2");
+-   ("/xe1/xa5/xb1", "TAI LE LETTER TONE-3");
+-   ("/xe1/xa5/xb2", "TAI LE LETTER TONE-4");
+-   ("/xe1/xa5/xb3", "TAI LE LETTER TONE-5");
+-   ("/xe1/xa5/xb4", "TAI LE LETTER TONE-6");
+-   ("/xe1/xa6/x80", "NEW TAI LUE LETTER HIGH QA");
+-   ("/xe1/xa6/x81", "NEW TAI LUE LETTER LOW QA");
+-   ("/xe1/xa6/x82", "NEW TAI LUE LETTER HIGH KA");
+-   ("/xe1/xa6/x83", "NEW TAI LUE LETTER HIGH XA");
+-   ("/xe1/xa6/x84", "NEW TAI LUE LETTER HIGH NGA");
+-   ("/xe1/xa6/x85", "NEW TAI LUE LETTER LOW KA");
+-   ("/xe1/xa6/x86", "NEW TAI LUE LETTER LOW XA");
+-   ("/xe1/xa6/x87", "NEW TAI LUE LETTER LOW NGA");
+-   ("/xe1/xa6/x88", "NEW TAI LUE LETTER HIGH TSA");
+-   ("/xe1/xa6/x89", "NEW TAI LUE LETTER HIGH SA");
+-   ("/xe1/xa6/x8a", "NEW TAI LUE LETTER HIGH YA");
+-   ("/xe1/xa6/x8b", "NEW TAI LUE LETTER LOW TSA");
+-   ("/xe1/xa6/x8c", "NEW TAI LUE LETTER LOW SA");
+-   ("/xe1/xa6/x8d", "NEW TAI LUE LETTER LOW YA");
+-   ("/xe1/xa6/x8e", "NEW TAI LUE LETTER HIGH TA");
+-   ("/xe1/xa6/x8f", "NEW TAI LUE LETTER HIGH THA");
+-   ("/xe1/xa6/x90", "NEW TAI LUE LETTER HIGH NA");
+-   ("/xe1/xa6/x91", "NEW TAI LUE LETTER LOW TA");
+-   ("/xe1/xa6/x92", "NEW TAI LUE LETTER LOW THA");
+-   ("/xe1/xa6/x93", "NEW TAI LUE LETTER LOW NA");
+-   ("/xe1/xa6/x94", "NEW TAI LUE LETTER HIGH PA");
+-   ("/xe1/xa6/x95", "NEW TAI LUE LETTER HIGH PHA");
+-   ("/xe1/xa6/x96", "NEW TAI LUE LETTER HIGH MA");
+-   ("/xe1/xa6/x97", "NEW TAI LUE LETTER LOW PA");
+-   ("/xe1/xa6/x98", "NEW TAI LUE LETTER LOW PHA");
+-   ("/xe1/xa6/x99", "NEW TAI LUE LETTER LOW MA");
+-   ("/xe1/xa6/x9a", "NEW TAI LUE LETTER HIGH FA");
+-   ("/xe1/xa6/x9b", "NEW TAI LUE LETTER HIGH VA");
+-   ("/xe1/xa6/x9c", "NEW TAI LUE LETTER HIGH LA");
+-   ("/xe1/xa6/x9d", "NEW TAI LUE LETTER LOW FA");
+-   ("/xe1/xa6/x9e", "NEW TAI LUE LETTER LOW VA");
+-   ("/xe1/xa6/x9f", "NEW TAI LUE LETTER LOW LA");
+-   ("/xe1/xa6/xa0", "NEW TAI LUE LETTER HIGH HA");
+-   ("/xe1/xa6/xa1", "NEW TAI LUE LETTER HIGH DA");
+-   ("/xe1/xa6/xa2", "NEW TAI LUE LETTER HIGH BA");
+-   ("/xe1/xa6/xa3", "NEW TAI LUE LETTER LOW HA");
+-   ("/xe1/xa6/xa4", "NEW TAI LUE LETTER LOW DA");
+-   ("/xe1/xa6/xa5", "NEW TAI LUE LETTER LOW BA");
+-   ("/xe1/xa6/xa6", "NEW TAI LUE LETTER HIGH KVA");
+-   ("/xe1/xa6/xa7", "NEW TAI LUE LETTER HIGH XVA");
+-   ("/xe1/xa6/xa8", "NEW TAI LUE LETTER LOW KVA");
+-   ("/xe1/xa6/xa9", "NEW TAI LUE LETTER LOW XVA");
+-   ("/xe1/xa6/xb0", "NEW TAI LUE VOWEL SIGN VOWEL SHORTENER");
+-   ("/xe1/xa6/xb1", "NEW TAI LUE VOWEL SIGN AA");
+-   ("/xe1/xa6/xb2", "NEW TAI LUE VOWEL SIGN II");
+-   ("/xe1/xa6/xb3", "NEW TAI LUE VOWEL SIGN U");
+-   ("/xe1/xa6/xb4", "NEW TAI LUE VOWEL SIGN UU");
+-   ("/xe1/xa6/xb5", "NEW TAI LUE VOWEL SIGN E");
+-   ("/xe1/xa6/xb6", "NEW TAI LUE VOWEL SIGN AE");
+-   ("/xe1/xa6/xb7", "NEW TAI LUE VOWEL SIGN O");
+-   ("/xe1/xa6/xb8", "NEW TAI LUE VOWEL SIGN OA");
+-   ("/xe1/xa6/xb9", "NEW TAI LUE VOWEL SIGN UE");
+-   ("/xe1/xa6/xba", "NEW TAI LUE VOWEL SIGN AY");
+-   ("/xe1/xa6/xbb", "NEW TAI LUE VOWEL SIGN AAY");
+-   ("/xe1/xa6/xbc", "NEW TAI LUE VOWEL SIGN UY");
+-   ("/xe1/xa6/xbd", "NEW TAI LUE VOWEL SIGN OY");
+-   ("/xe1/xa6/xbe", "NEW TAI LUE VOWEL SIGN OAY");
+-   ("/xe1/xa6/xbf", "NEW TAI LUE VOWEL SIGN UEY");
+-   ("/xe1/xa7/x80", "NEW TAI LUE VOWEL SIGN IY");
+-   ("/xe1/xa7/x81", "NEW TAI LUE LETTER FINAL V");
+-   ("/xe1/xa7/x82", "NEW TAI LUE LETTER FINAL NG");
+-   ("/xe1/xa7/x83", "NEW TAI LUE LETTER FINAL N");
+-   ("/xe1/xa7/x84", "NEW TAI LUE LETTER FINAL M");
+-   ("/xe1/xa7/x85", "NEW TAI LUE LETTER FINAL K");
+-   ("/xe1/xa7/x86", "NEW TAI LUE LETTER FINAL D");
+-   ("/xe1/xa7/x87", "NEW TAI LUE LETTER FINAL B");
+-   ("/xe1/xa7/x88", "NEW TAI LUE TONE MARK-1");
+-   ("/xe1/xa7/x89", "NEW TAI LUE TONE MARK-2");
+-   ("/xe1/xa7/x90", "NEW TAI LUE DIGIT ZERO");
+-   ("/xe1/xa7/x91", "NEW TAI LUE DIGIT ONE");
+-   ("/xe1/xa7/x92", "NEW TAI LUE DIGIT TWO");
+-   ("/xe1/xa7/x93", "NEW TAI LUE DIGIT THREE");
+-   ("/xe1/xa7/x94", "NEW TAI LUE DIGIT FOUR");
+-   ("/xe1/xa7/x95", "NEW TAI LUE DIGIT FIVE");
+-   ("/xe1/xa7/x96", "NEW TAI LUE DIGIT SIX");
+-   ("/xe1/xa7/x97", "NEW TAI LUE DIGIT SEVEN");
+-   ("/xe1/xa7/x98", "NEW TAI LUE DIGIT EIGHT");
+-   ("/xe1/xa7/x99", "NEW TAI LUE DIGIT NINE");
+-   ("/xe1/xa7/x9e", "NEW TAI LUE SIGN LAE");
+-   ("/xe1/xa7/x9f", "NEW TAI LUE SIGN LAEV");
+-   ("/xe1/xa7/xa0", "KHMER SYMBOL PATHAMASAT");
+-   ("/xe1/xa7/xa1", "KHMER SYMBOL MUOY KOET");
+-   ("/xe1/xa7/xa2", "KHMER SYMBOL PII KOET");
+-   ("/xe1/xa7/xa3", "KHMER SYMBOL BEI KOET");
+-   ("/xe1/xa7/xa4", "KHMER SYMBOL BUON KOET");
+-   ("/xe1/xa7/xa5", "KHMER SYMBOL PRAM KOET");
+-   ("/xe1/xa7/xa6", "KHMER SYMBOL PRAM-MUOY KOET");
+-   ("/xe1/xa7/xa7", "KHMER SYMBOL PRAM-PII KOET");
+-   ("/xe1/xa7/xa8", "KHMER SYMBOL PRAM-BEI KOET");
+-   ("/xe1/xa7/xa9", "KHMER SYMBOL PRAM-BUON KOET");
+-   ("/xe1/xa7/xaa", "KHMER SYMBOL DAP KOET");
+-   ("/xe1/xa7/xab", "KHMER SYMBOL DAP-MUOY KOET");
+-   ("/xe1/xa7/xac", "KHMER SYMBOL DAP-PII KOET");
+-   ("/xe1/xa7/xad", "KHMER SYMBOL DAP-BEI KOET");
+-   ("/xe1/xa7/xae", "KHMER SYMBOL DAP-BUON KOET");
+-   ("/xe1/xa7/xaf", "KHMER SYMBOL DAP-PRAM KOET");
+-   ("/xe1/xa7/xb0", "KHMER SYMBOL TUTEYASAT");
+-   ("/xe1/xa7/xb1", "KHMER SYMBOL MUOY ROC");
+-   ("/xe1/xa7/xb2", "KHMER SYMBOL PII ROC");
+-   ("/xe1/xa7/xb3", "KHMER SYMBOL BEI ROC");
+-   ("/xe1/xa7/xb4", "KHMER SYMBOL BUON ROC");
+-   ("/xe1/xa7/xb5", "KHMER SYMBOL PRAM ROC");
+-   ("/xe1/xa7/xb6", "KHMER SYMBOL PRAM-MUOY ROC");
+-   ("/xe1/xa7/xb7", "KHMER SYMBOL PRAM-PII ROC");
+-   ("/xe1/xa7/xb8", "KHMER SYMBOL PRAM-BEI ROC");
+-   ("/xe1/xa7/xb9", "KHMER SYMBOL PRAM-BUON ROC");
+-   ("/xe1/xa7/xba", "KHMER SYMBOL DAP ROC");
+-   ("/xe1/xa7/xbb", "KHMER SYMBOL DAP-MUOY ROC");
+-   ("/xe1/xa7/xbc", "KHMER SYMBOL DAP-PII ROC");
+-   ("/xe1/xa7/xbd", "KHMER SYMBOL DAP-BEI ROC");
+-   ("/xe1/xa7/xbe", "KHMER SYMBOL DAP-BUON ROC");
+-   ("/xe1/xa7/xbf", "KHMER SYMBOL DAP-PRAM ROC");
+-   ("/xe1/xa8/x80", "BUGINESE LETTER KA");
+-   ("/xe1/xa8/x81", "BUGINESE LETTER GA");
+-   ("/xe1/xa8/x82", "BUGINESE LETTER NGA");
+-   ("/xe1/xa8/x83", "BUGINESE LETTER NGKA");
+-   ("/xe1/xa8/x84", "BUGINESE LETTER PA");
+-   ("/xe1/xa8/x85", "BUGINESE LETTER BA");
+-   ("/xe1/xa8/x86", "BUGINESE LETTER MA");
+-   ("/xe1/xa8/x87", "BUGINESE LETTER MPA");
+-   ("/xe1/xa8/x88", "BUGINESE LETTER TA");
+-   ("/xe1/xa8/x89", "BUGINESE LETTER DA");
+-   ("/xe1/xa8/x8a", "BUGINESE LETTER NA");
+-   ("/xe1/xa8/x8b", "BUGINESE LETTER NRA");
+-   ("/xe1/xa8/x8c", "BUGINESE LETTER CA");
+-   ("/xe1/xa8/x8d", "BUGINESE LETTER JA");
+-   ("/xe1/xa8/x8e", "BUGINESE LETTER NYA");
+-   ("/xe1/xa8/x8f", "BUGINESE LETTER NYCA");
+-   ("/xe1/xa8/x90", "BUGINESE LETTER YA");
+-   ("/xe1/xa8/x91", "BUGINESE LETTER RA");
+-   ("/xe1/xa8/x92", "BUGINESE LETTER LA");
+-   ("/xe1/xa8/x93", "BUGINESE LETTER VA");
+-   ("/xe1/xa8/x94", "BUGINESE LETTER SA");
+-   ("/xe1/xa8/x95", "BUGINESE LETTER A");
+-   ("/xe1/xa8/x96", "BUGINESE LETTER HA");
+-   ("/xe1/xa8/x97", "BUGINESE VOWEL SIGN I");
+-   ("/xe1/xa8/x98", "BUGINESE VOWEL SIGN U");
+-   ("/xe1/xa8/x99", "BUGINESE VOWEL SIGN E");
+-   ("/xe1/xa8/x9a", "BUGINESE VOWEL SIGN O");
+-   ("/xe1/xa8/x9b", "BUGINESE VOWEL SIGN AE");
+-   ("/xe1/xa8/x9e", "BUGINESE PALLAWA");
+-   ("/xe1/xa8/x9f", "BUGINESE END OF SECTION");
+-   ("/xe1/xac/x80", "BALINESE SIGN ULU RICEM");
+-   ("/xe1/xac/x81", "BALINESE SIGN ULU CANDRA");
+-   ("/xe1/xac/x82", "BALINESE SIGN CECEK");
+-   ("/xe1/xac/x83", "BALINESE SIGN SURANG");
+-   ("/xe1/xac/x84", "BALINESE SIGN BISAH");
+-   ("/xe1/xac/x85", "BALINESE LETTER AKARA");
+-   ("/xe1/xac/x86", "BALINESE LETTER AKARA TEDUNG");
+-   ("/xe1/xac/x87", "BALINESE LETTER IKARA");
+-   ("/xe1/xac/x88", "BALINESE LETTER IKARA TEDUNG");
+-   ("/xe1/xac/x89", "BALINESE LETTER UKARA");
+-   ("/xe1/xac/x8a", "BALINESE LETTER UKARA TEDUNG");
+-   ("/xe1/xac/x8b", "BALINESE LETTER RA REPA");
+-   ("/xe1/xac/x8c", "BALINESE LETTER RA REPA TEDUNG");
+-   ("/xe1/xac/x8d", "BALINESE LETTER LA LENGA");
+-   ("/xe1/xac/x8e", "BALINESE LETTER LA LENGA TEDUNG");
+-   ("/xe1/xac/x8f", "BALINESE LETTER EKARA");
+-   ("/xe1/xac/x90", "BALINESE LETTER AIKARA");
+-   ("/xe1/xac/x91", "BALINESE LETTER OKARA");
+-   ("/xe1/xac/x92", "BALINESE LETTER OKARA TEDUNG");
+-   ("/xe1/xac/x93", "BALINESE LETTER KA");
+-   ("/xe1/xac/x94", "BALINESE LETTER KA MAHAPRANA");
+-   ("/xe1/xac/x95", "BALINESE LETTER GA");
+-   ("/xe1/xac/x96", "BALINESE LETTER GA GORA");
+-   ("/xe1/xac/x97", "BALINESE LETTER NGA");
+-   ("/xe1/xac/x98", "BALINESE LETTER CA");
+-   ("/xe1/xac/x99", "BALINESE LETTER CA LACA");
+-   ("/xe1/xac/x9a", "BALINESE LETTER JA");
+-   ("/xe1/xac/x9b", "BALINESE LETTER JA JERA");
+-   ("/xe1/xac/x9c", "BALINESE LETTER NYA");
+-   ("/xe1/xac/x9d", "BALINESE LETTER TA LATIK");
+-   ("/xe1/xac/x9e", "BALINESE LETTER TA MURDA MAHAPRANA");
+-   ("/xe1/xac/x9f", "BALINESE LETTER DA MURDA ALPAPRANA");
+-   ("/xe1/xac/xa0", "BALINESE LETTER DA MURDA MAHAPRANA");
+-   ("/xe1/xac/xa1", "BALINESE LETTER NA RAMBAT");
+-   ("/xe1/xac/xa2", "BALINESE LETTER TA");
+-   ("/xe1/xac/xa3", "BALINESE LETTER TA TAWA");
+-   ("/xe1/xac/xa4", "BALINESE LETTER DA");
+-   ("/xe1/xac/xa5", "BALINESE LETTER DA MADU");
+-   ("/xe1/xac/xa6", "BALINESE LETTER NA");
+-   ("/xe1/xac/xa7", "BALINESE LETTER PA");
+-   ("/xe1/xac/xa8", "BALINESE LETTER PA KAPAL");
+-   ("/xe1/xac/xa9", "BALINESE LETTER BA");
+-   ("/xe1/xac/xaa", "BALINESE LETTER BA KEMBANG");
+-   ("/xe1/xac/xab", "BALINESE LETTER MA");
+-   ("/xe1/xac/xac", "BALINESE LETTER YA");
+-   ("/xe1/xac/xad", "BALINESE LETTER RA");
+-   ("/xe1/xac/xae", "BALINESE LETTER LA");
+-   ("/xe1/xac/xaf", "BALINESE LETTER WA");
+-   ("/xe1/xac/xb0", "BALINESE LETTER SA SAGA");
+-   ("/xe1/xac/xb1", "BALINESE LETTER SA SAPA");
+-   ("/xe1/xac/xb2", "BALINESE LETTER SA");
+-   ("/xe1/xac/xb3", "BALINESE LETTER HA");
+-   ("/xe1/xac/xb4", "BALINESE SIGN REREKAN");
+-   ("/xe1/xac/xb5", "BALINESE VOWEL SIGN TEDUNG");
+-   ("/xe1/xac/xb6", "BALINESE VOWEL SIGN ULU");
+-   ("/xe1/xac/xb7", "BALINESE VOWEL SIGN ULU SARI");
+-   ("/xe1/xac/xb8", "BALINESE VOWEL SIGN SUKU");
+-   ("/xe1/xac/xb9", "BALINESE VOWEL SIGN SUKU ILUT");
+-   ("/xe1/xac/xba", "BALINESE VOWEL SIGN RA REPA");
+-   ("/xe1/xac/xbb", "BALINESE VOWEL SIGN RA REPA TEDUNG");
+-   ("/xe1/xac/xbc", "BALINESE VOWEL SIGN LA LENGA");
+-   ("/xe1/xac/xbd", "BALINESE VOWEL SIGN LA LENGA TEDUNG");
+-   ("/xe1/xac/xbe", "BALINESE VOWEL SIGN TALING");
+-   ("/xe1/xac/xbf", "BALINESE VOWEL SIGN TALING REPA");
+-   ("/xe1/xad/x80", "BALINESE VOWEL SIGN TALING TEDUNG");
+-   ("/xe1/xad/x81", "BALINESE VOWEL SIGN TALING REPA TEDUNG");
+-   ("/xe1/xad/x82", "BALINESE VOWEL SIGN PEPET");
+-   ("/xe1/xad/x83", "BALINESE VOWEL SIGN PEPET TEDUNG");
+-   ("/xe1/xad/x84", "BALINESE ADEG ADEG");
+-   ("/xe1/xad/x85", "BALINESE LETTER KAF SASAK");
+-   ("/xe1/xad/x86", "BALINESE LETTER KHOT SASAK");
+-   ("/xe1/xad/x87", "BALINESE LETTER TZIR SASAK");
+-   ("/xe1/xad/x88", "BALINESE LETTER EF SASAK");
+-   ("/xe1/xad/x89", "BALINESE LETTER VE SASAK");
+-   ("/xe1/xad/x8a", "BALINESE LETTER ZAL SASAK");
+-   ("/xe1/xad/x8b", "BALINESE LETTER ASYURA SASAK");
+-   ("/xe1/xad/x90", "BALINESE DIGIT ZERO");
+-   ("/xe1/xad/x91", "BALINESE DIGIT ONE");
+-   ("/xe1/xad/x92", "BALINESE DIGIT TWO");
+-   ("/xe1/xad/x93", "BALINESE DIGIT THREE");
+-   ("/xe1/xad/x94", "BALINESE DIGIT FOUR");
+-   ("/xe1/xad/x95", "BALINESE DIGIT FIVE");
+-   ("/xe1/xad/x96", "BALINESE DIGIT SIX");
+-   ("/xe1/xad/x97", "BALINESE DIGIT SEVEN");
+-   ("/xe1/xad/x98", "BALINESE DIGIT EIGHT");
+-   ("/xe1/xad/x99", "BALINESE DIGIT NINE");
+-   ("/xe1/xad/x9a", "BALINESE PANTI");
+-   ("/xe1/xad/x9b", "BALINESE PAMADA");
+-   ("/xe1/xad/x9c", "BALINESE WINDU");
+-   ("/xe1/xad/x9d", "BALINESE CARIK PAMUNGKAH");
+-   ("/xe1/xad/x9e", "BALINESE CARIK SIKI");
+-   ("/xe1/xad/x9f", "BALINESE CARIK PAREREN");
+-   ("/xe1/xad/xa0", "BALINESE PAMENENG");
+-   ("/xe1/xad/xa1", "BALINESE MUSICAL SYMBOL DONG");
+-   ("/xe1/xad/xa2", "BALINESE MUSICAL SYMBOL DENG");
+-   ("/xe1/xad/xa3", "BALINESE MUSICAL SYMBOL DUNG");
+-   ("/xe1/xad/xa4", "BALINESE MUSICAL SYMBOL DANG");
+-   ("/xe1/xad/xa5", "BALINESE MUSICAL SYMBOL DANG SURANG");
+-   ("/xe1/xad/xa6", "BALINESE MUSICAL SYMBOL DING");
+-   ("/xe1/xad/xa7", "BALINESE MUSICAL SYMBOL DAENG");
+-   ("/xe1/xad/xa8", "BALINESE MUSICAL SYMBOL DEUNG");
+-   ("/xe1/xad/xa9", "BALINESE MUSICAL SYMBOL DAING");
+-   ("/xe1/xad/xaa", "BALINESE MUSICAL SYMBOL DANG GEDE");
+-   ("/xe1/xad/xab", "BALINESE MUSICAL SYMBOL COMBINING TEGEH");
+-   ("/xe1/xad/xac", "BALINESE MUSICAL SYMBOL COMBINING ENDEP");
+-   ("/xe1/xad/xad", "BALINESE MUSICAL SYMBOL COMBINING KEMPUL");
+-   ("/xe1/xad/xae", "BALINESE MUSICAL SYMBOL COMBINING KEMPLI");
+-   ("/xe1/xad/xaf", "BALINESE MUSICAL SYMBOL COMBINING JEGOGAN");
+-   ("/xe1/xad/xb0", "BALINESE MUSICAL SYMBOL COMBINING KEMPUL WITH JEGOGAN");
+-   ("/xe1/xad/xb1", "BALINESE MUSICAL SYMBOL COMBINING KEMPLI WITH JEGOGAN");
+-   ("/xe1/xad/xb2", "BALINESE MUSICAL SYMBOL COMBINING BENDE");
+-   ("/xe1/xad/xb3", "BALINESE MUSICAL SYMBOL COMBINING GONG");
+-   ("/xe1/xad/xb4", "BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG");
+-   ("/xe1/xad/xb5", "BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DAG");
+-   ("/xe1/xad/xb6", "BALINESE MUSICAL SYMBOL RIGHT-HAND CLOSED TUK");
+-   ("/xe1/xad/xb7", "BALINESE MUSICAL SYMBOL RIGHT-HAND CLOSED TAK");
+-   ("/xe1/xad/xb8", "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PANG");
+-   ("/xe1/xad/xb9", "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PUNG");
+-   ("/xe1/xad/xba", "BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLAK");
+-   ("/xe1/xad/xbb", "BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLUK");
+-   ("/xe1/xad/xbc", "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING");
+-   ("/xe1/xae/x80", "SUNDANESE SIGN PANYECEK");
+-   ("/xe1/xae/x81", "SUNDANESE SIGN PANGLAYAR");
+-   ("/xe1/xae/x82", "SUNDANESE SIGN PANGWISAD");
+-   ("/xe1/xae/x83", "SUNDANESE LETTER A");
+-   ("/xe1/xae/x84", "SUNDANESE LETTER I");
+-   ("/xe1/xae/x85", "SUNDANESE LETTER U");
+-   ("/xe1/xae/x86", "SUNDANESE LETTER AE");
+-   ("/xe1/xae/x87", "SUNDANESE LETTER O");
+-   ("/xe1/xae/x88", "SUNDANESE LETTER E");
+-   ("/xe1/xae/x89", "SUNDANESE LETTER EU");
+-   ("/xe1/xae/x8a", "SUNDANESE LETTER KA");
+-   ("/xe1/xae/x8b", "SUNDANESE LETTER QA");
+-   ("/xe1/xae/x8c", "SUNDANESE LETTER GA");
+-   ("/xe1/xae/x8d", "SUNDANESE LETTER NGA");
+-   ("/xe1/xae/x8e", "SUNDANESE LETTER CA");
+-   ("/xe1/xae/x8f", "SUNDANESE LETTER JA");
+-   ("/xe1/xae/x90", "SUNDANESE LETTER ZA");
+-   ("/xe1/xae/x91", "SUNDANESE LETTER NYA");
+-   ("/xe1/xae/x92", "SUNDANESE LETTER TA");
+-   ("/xe1/xae/x93", "SUNDANESE LETTER DA");
+-   ("/xe1/xae/x94", "SUNDANESE LETTER NA");
+-   ("/xe1/xae/x95", "SUNDANESE LETTER PA");
+-   ("/xe1/xae/x96", "SUNDANESE LETTER FA");
+-   ("/xe1/xae/x97", "SUNDANESE LETTER VA");
+-   ("/xe1/xae/x98", "SUNDANESE LETTER BA");
+-   ("/xe1/xae/x99", "SUNDANESE LETTER MA");
+-   ("/xe1/xae/x9a", "SUNDANESE LETTER YA");
+-   ("/xe1/xae/x9b", "SUNDANESE LETTER RA");
+-   ("/xe1/xae/x9c", "SUNDANESE LETTER LA");
+-   ("/xe1/xae/x9d", "SUNDANESE LETTER WA");
+-   ("/xe1/xae/x9e", "SUNDANESE LETTER SA");
+-   ("/xe1/xae/x9f", "SUNDANESE LETTER XA");
+-   ("/xe1/xae/xa0", "SUNDANESE LETTER HA");
+-   ("/xe1/xae/xa1", "SUNDANESE CONSONANT SIGN PAMINGKAL");
+-   ("/xe1/xae/xa2", "SUNDANESE CONSONANT SIGN PANYAKRA");
+-   ("/xe1/xae/xa3", "SUNDANESE CONSONANT SIGN PANYIKU");
+-   ("/xe1/xae/xa4", "SUNDANESE VOWEL SIGN PANGHULU");
+-   ("/xe1/xae/xa5", "SUNDANESE VOWEL SIGN PANYUKU");
+-   ("/xe1/xae/xa6", "SUNDANESE VOWEL SIGN PANAELAENG");
+-   ("/xe1/xae/xa7", "SUNDANESE VOWEL SIGN PANOLONG");
+-   ("/xe1/xae/xa8", "SUNDANESE VOWEL SIGN PAMEPET");
+-   ("/xe1/xae/xa9", "SUNDANESE VOWEL SIGN PANEULEUNG");
+-   ("/xe1/xae/xaa", "SUNDANESE SIGN PAMAAEH");
+-   ("/xe1/xae/xae", "SUNDANESE LETTER KHA");
+-   ("/xe1/xae/xaf", "SUNDANESE LETTER SYA");
+-   ("/xe1/xae/xb0", "SUNDANESE DIGIT ZERO");
+-   ("/xe1/xae/xb1", "SUNDANESE DIGIT ONE");
+-   ("/xe1/xae/xb2", "SUNDANESE DIGIT TWO");
+-   ("/xe1/xae/xb3", "SUNDANESE DIGIT THREE");
+-   ("/xe1/xae/xb4", "SUNDANESE DIGIT FOUR");
+-   ("/xe1/xae/xb5", "SUNDANESE DIGIT FIVE");
+-   ("/xe1/xae/xb6", "SUNDANESE DIGIT SIX");
+-   ("/xe1/xae/xb7", "SUNDANESE DIGIT SEVEN");
+-   ("/xe1/xae/xb8", "SUNDANESE DIGIT EIGHT");
+-   ("/xe1/xae/xb9", "SUNDANESE DIGIT NINE");
+-   ("/xe1/xb0/x80", "LEPCHA LETTER KA");
+-   ("/xe1/xb0/x81", "LEPCHA LETTER KLA");
+-   ("/xe1/xb0/x82", "LEPCHA LETTER KHA");
+-   ("/xe1/xb0/x83", "LEPCHA LETTER GA");
+-   ("/xe1/xb0/x84", "LEPCHA LETTER GLA");
+-   ("/xe1/xb0/x85", "LEPCHA LETTER NGA");
+-   ("/xe1/xb0/x86", "LEPCHA LETTER CA");
+-   ("/xe1/xb0/x87", "LEPCHA LETTER CHA");
+-   ("/xe1/xb0/x88", "LEPCHA LETTER JA");
+-   ("/xe1/xb0/x89", "LEPCHA LETTER NYA");
+-   ("/xe1/xb0/x8a", "LEPCHA LETTER TA");
+-   ("/xe1/xb0/x8b", "LEPCHA LETTER THA");
+-   ("/xe1/xb0/x8c", "LEPCHA LETTER DA");
+-   ("/xe1/xb0/x8d", "LEPCHA LETTER NA");
+-   ("/xe1/xb0/x8e", "LEPCHA LETTER PA");
+-   ("/xe1/xb0/x8f", "LEPCHA LETTER PLA");
+-   ("/xe1/xb0/x90", "LEPCHA LETTER PHA");
+-   ("/xe1/xb0/x91", "LEPCHA LETTER FA");
+-   ("/xe1/xb0/x92", "LEPCHA LETTER FLA");
+-   ("/xe1/xb0/x93", "LEPCHA LETTER BA");
+-   ("/xe1/xb0/x94", "LEPCHA LETTER BLA");
+-   ("/xe1/xb0/x95", "LEPCHA LETTER MA");
+-   ("/xe1/xb0/x96", "LEPCHA LETTER MLA");
+-   ("/xe1/xb0/x97", "LEPCHA LETTER TSA");
+-   ("/xe1/xb0/x98", "LEPCHA LETTER TSHA");
+-   ("/xe1/xb0/x99", "LEPCHA LETTER DZA");
+-   ("/xe1/xb0/x9a", "LEPCHA LETTER YA");
+-   ("/xe1/xb0/x9b", "LEPCHA LETTER RA");
+-   ("/xe1/xb0/x9c", "LEPCHA LETTER LA");
+-   ("/xe1/xb0/x9d", "LEPCHA LETTER HA");
+-   ("/xe1/xb0/x9e", "LEPCHA LETTER HLA");
+-   ("/xe1/xb0/x9f", "LEPCHA LETTER VA");
+-   ("/xe1/xb0/xa0", "LEPCHA LETTER SA");
+-   ("/xe1/xb0/xa1", "LEPCHA LETTER SHA");
+-   ("/xe1/xb0/xa2", "LEPCHA LETTER WA");
+-   ("/xe1/xb0/xa3", "LEPCHA LETTER A");
+-   ("/xe1/xb0/xa4", "LEPCHA SUBJOINED LETTER YA");
+-   ("/xe1/xb0/xa5", "LEPCHA SUBJOINED LETTER RA");
+-   ("/xe1/xb0/xa6", "LEPCHA VOWEL SIGN AA");
+-   ("/xe1/xb0/xa7", "LEPCHA VOWEL SIGN I");
+-   ("/xe1/xb0/xa8", "LEPCHA VOWEL SIGN O");
+-   ("/xe1/xb0/xa9", "LEPCHA VOWEL SIGN OO");
+-   ("/xe1/xb0/xaa", "LEPCHA VOWEL SIGN U");
+-   ("/xe1/xb0/xab", "LEPCHA VOWEL SIGN UU");
+-   ("/xe1/xb0/xac", "LEPCHA VOWEL SIGN E");
+-   ("/xe1/xb0/xad", "LEPCHA CONSONANT SIGN K");
+-   ("/xe1/xb0/xae", "LEPCHA CONSONANT SIGN M");
+-   ("/xe1/xb0/xaf", "LEPCHA CONSONANT SIGN L");
+-   ("/xe1/xb0/xb0", "LEPCHA CONSONANT SIGN N");
+-   ("/xe1/xb0/xb1", "LEPCHA CONSONANT SIGN P");
+-   ("/xe1/xb0/xb2", "LEPCHA CONSONANT SIGN R");
+-   ("/xe1/xb0/xb3", "LEPCHA CONSONANT SIGN T");
+-   ("/xe1/xb0/xb4", "LEPCHA CONSONANT SIGN NYIN-DO");
+-   ("/xe1/xb0/xb5", "LEPCHA CONSONANT SIGN KANG");
+-   ("/xe1/xb0/xb6", "LEPCHA SIGN RAN");
+-   ("/xe1/xb0/xb7", "LEPCHA SIGN NUKTA");
+-   ("/xe1/xb0/xbb", "LEPCHA PUNCTUATION TA-ROL");
+-   ("/xe1/xb0/xbc", "LEPCHA PUNCTUATION NYET THYOOM TA-ROL");
+-   ("/xe1/xb0/xbd", "LEPCHA PUNCTUATION CER-WA");
+-   ("/xe1/xb0/xbe", "LEPCHA PUNCTUATION TSHOOK CER-WA");
+-   ("/xe1/xb0/xbf", "LEPCHA PUNCTUATION TSHOOK");
+-   ("/xe1/xb1/x80", "LEPCHA DIGIT ZERO");
+-   ("/xe1/xb1/x81", "LEPCHA DIGIT ONE");
+-   ("/xe1/xb1/x82", "LEPCHA DIGIT TWO");
+-   ("/xe1/xb1/x83", "LEPCHA DIGIT THREE");
+-   ("/xe1/xb1/x84", "LEPCHA DIGIT FOUR");
+-   ("/xe1/xb1/x85", "LEPCHA DIGIT FIVE");
+-   ("/xe1/xb1/x86", "LEPCHA DIGIT SIX");
+-   ("/xe1/xb1/x87", "LEPCHA DIGIT SEVEN");
+-   ("/xe1/xb1/x88", "LEPCHA DIGIT EIGHT");
+-   ("/xe1/xb1/x89", "LEPCHA DIGIT NINE");
+-   ("/xe1/xb1/x8d", "LEPCHA LETTER TTA");
+-   ("/xe1/xb1/x8e", "LEPCHA LETTER TTHA");
+-   ("/xe1/xb1/x8f", "LEPCHA LETTER DDA");
+-   ("/xe1/xb1/x90", "OL CHIKI DIGIT ZERO");
+-   ("/xe1/xb1/x91", "OL CHIKI DIGIT ONE");
+-   ("/xe1/xb1/x92", "OL CHIKI DIGIT TWO");
+-   ("/xe1/xb1/x93", "OL CHIKI DIGIT THREE");
+-   ("/xe1/xb1/x94", "OL CHIKI DIGIT FOUR");
+-   ("/xe1/xb1/x95", "OL CHIKI DIGIT FIVE");
+-   ("/xe1/xb1/x96", "OL CHIKI DIGIT SIX");
+-   ("/xe1/xb1/x97", "OL CHIKI DIGIT SEVEN");
+-   ("/xe1/xb1/x98", "OL CHIKI DIGIT EIGHT");
+-   ("/xe1/xb1/x99", "OL CHIKI DIGIT NINE");
+-   ("/xe1/xb1/x9a", "OL CHIKI LETTER LA");
+-   ("/xe1/xb1/x9b", "OL CHIKI LETTER AT");
+-   ("/xe1/xb1/x9c", "OL CHIKI LETTER AG");
+-   ("/xe1/xb1/x9d", "OL CHIKI LETTER ANG");
+-   ("/xe1/xb1/x9e", "OL CHIKI LETTER AL");
+-   ("/xe1/xb1/x9f", "OL CHIKI LETTER LAA");
+-   ("/xe1/xb1/xa0", "OL CHIKI LETTER AAK");
+-   ("/xe1/xb1/xa1", "OL CHIKI LETTER AAJ");
+-   ("/xe1/xb1/xa2", "OL CHIKI LETTER AAM");
+-   ("/xe1/xb1/xa3", "OL CHIKI LETTER AAW");
+-   ("/xe1/xb1/xa4", "OL CHIKI LETTER LI");
+-   ("/xe1/xb1/xa5", "OL CHIKI LETTER IS");
+-   ("/xe1/xb1/xa6", "OL CHIKI LETTER IH");
+-   ("/xe1/xb1/xa7", "OL CHIKI LETTER INY");
+-   ("/xe1/xb1/xa8", "OL CHIKI LETTER IR");
+-   ("/xe1/xb1/xa9", "OL CHIKI LETTER LU");
+-   ("/xe1/xb1/xaa", "OL CHIKI LETTER UC");
+-   ("/xe1/xb1/xab", "OL CHIKI LETTER UD");
+-   ("/xe1/xb1/xac", "OL CHIKI LETTER UNN");
+-   ("/xe1/xb1/xad", "OL CHIKI LETTER UY");
+-   ("/xe1/xb1/xae", "OL CHIKI LETTER LE");
+-   ("/xe1/xb1/xaf", "OL CHIKI LETTER EP");
+-   ("/xe1/xb1/xb0", "OL CHIKI LETTER EDD");
+-   ("/xe1/xb1/xb1", "OL CHIKI LETTER EN");
+-   ("/xe1/xb1/xb2", "OL CHIKI LETTER ERR");
+-   ("/xe1/xb1/xb3", "OL CHIKI LETTER LO");
+-   ("/xe1/xb1/xb4", "OL CHIKI LETTER OTT");
+-   ("/xe1/xb1/xb5", "OL CHIKI LETTER OB");
+-   ("/xe1/xb1/xb6", "OL CHIKI LETTER OV");
+-   ("/xe1/xb1/xb7", "OL CHIKI LETTER OH");
+-   ("/xe1/xb1/xb8", "OL CHIKI MU TTUDDAG");
+-   ("/xe1/xb1/xb9", "OL CHIKI GAAHLAA TTUDDAAG");
+-   ("/xe1/xb1/xba", "OL CHIKI MU-GAAHLAA TTUDDAAG");
+-   ("/xe1/xb1/xbb", "OL CHIKI RELAA");
+-   ("/xe1/xb1/xbc", "OL CHIKI PHAARKAA");
+-   ("/xe1/xb1/xbd", "OL CHIKI AHAD");
+-   ("/xe1/xb1/xbe", "OL CHIKI PUNCTUATION MUCAAD");
+-   ("/xe1/xb1/xbf", "OL CHIKI PUNCTUATION DOUBLE MUCAAD");
+    ("/xe1/xb4/x80", "LATIN LETTER SMALL CAPITAL A");
+    ("/xe1/xb4/x81", "LATIN LETTER SMALL CAPITAL AE");
+    ("/xe1/xb4/x82", "LATIN SMALL LETTER TURNED AE");
+@@ -5813,8 +1156,6 @@
+    ("/xe1/xb4/xa1", "LATIN LETTER SMALL CAPITAL W");
+    ("/xe1/xb4/xa2", "LATIN LETTER SMALL CAPITAL Z");
+    ("/xe1/xb4/xa3", "LATIN LETTER SMALL CAPITAL EZH");
+-   ("/xe1/xb4/xa4", "LATIN LETTER VOICED LARYNGEAL SPIRANT");
+-   ("/xe1/xb4/xa5", "LATIN LETTER AIN");
+    ("/xe1/xb4/xa6", "GREEK LETTER SMALL CAPITAL GAMMA");
+    ("/xe1/xb4/xa7", "GREEK LETTER SMALL CAPITAL LAMDA");
+    ("/xe1/xb4/xa8", "GREEK LETTER SMALL CAPITAL PI");
+@@ -5897,7 +1238,6 @@
+    ("/xe1/xb5/xb5", "LATIN SMALL LETTER T WITH MIDDLE TILDE");
+    ("/xe1/xb5/xb6", "LATIN SMALL LETTER Z WITH MIDDLE TILDE");
+    ("/xe1/xb5/xb7", "LATIN SMALL LETTER TURNED G");
+-   ("/xe1/xb5/xb8", "MODIFIER LETTER CYRILLIC EN");
+    ("/xe1/xb5/xb9", "LATIN SMALL LETTER INSULAR G");
+    ("/xe1/xb5/xba", "LATIN SMALL LETTER TH WITH STRIKETHROUGH");
+    ("/xe1/xb5/xbb", "LATIN SMALL CAPITAL LETTER I WITH STROKE");
+@@ -5969,25 +1309,7 @@
+    ("/xe1/xb6/xbd", "MODIFIER LETTER SMALL Z WITH CURL");
+    ("/xe1/xb6/xbe", "MODIFIER LETTER SMALL EZH");
+    ("/xe1/xb6/xbf", "MODIFIER LETTER SMALL THETA");
+-   ("/xe1/xb7/x80", "COMBINING DOTTED GRAVE ACCENT");
+-   ("/xe1/xb7/x81", "COMBINING DOTTED ACUTE ACCENT");
+-   ("/xe1/xb7/x82", "COMBINING SNAKE BELOW");
+-   ("/xe1/xb7/x83", "COMBINING SUSPENSION MARK");
+-   ("/xe1/xb7/x84", "COMBINING MACRON-ACUTE");
+-   ("/xe1/xb7/x85", "COMBINING GRAVE-MACRON");
+-   ("/xe1/xb7/x86", "COMBINING MACRON-GRAVE");
+-   ("/xe1/xb7/x87", "COMBINING ACUTE-MACRON");
+-   ("/xe1/xb7/x88", "COMBINING GRAVE-ACUTE-GRAVE");
+-   ("/xe1/xb7/x89", "COMBINING ACUTE-GRAVE-ACUTE");
+    ("/xe1/xb7/x8a", "COMBINING LATIN SMALL LETTER R BELOW");
+-   ("/xe1/xb7/x8b", "COMBINING BREVE-MACRON");
+-   ("/xe1/xb7/x8c", "COMBINING MACRON-BREVE");
+-   ("/xe1/xb7/x8d", "COMBINING DOUBLE CIRCUMFLEX ABOVE");
+-   ("/xe1/xb7/x8e", "COMBINING OGONEK ABOVE");
+-   ("/xe1/xb7/x8f", "COMBINING ZIGZAG BELOW");
+-   ("/xe1/xb7/x90", "COMBINING IS BELOW");
+-   ("/xe1/xb7/x91", "COMBINING UR ABOVE");
+-   ("/xe1/xb7/x92", "COMBINING US ABOVE");
+    ("/xe1/xb7/x93", "COMBINING LATIN SMALL LETTER FLATTENED OPEN A ABOVE");
+    ("/xe1/xb7/x94", "COMBINING LATIN SMALL LETTER AE");
+    ("/xe1/xb7/x95", "COMBINING LATIN SMALL LETTER AO");
+@@ -6008,8 +1330,6 @@
+    ("/xe1/xb7/xa4", "COMBINING LATIN SMALL LETTER S");
+    ("/xe1/xb7/xa5", "COMBINING LATIN SMALL LETTER LONG S");
+    ("/xe1/xb7/xa6", "COMBINING LATIN SMALL LETTER Z");
+-   ("/xe1/xb7/xbe", "COMBINING LEFT ARROWHEAD ABOVE");
+-   ("/xe1/xb7/xbf", "COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW");
+    ("/xe1/xb8/x80", "LATIN CAPITAL LETTER A WITH RING BELOW");
+    ("/xe1/xb8/x81", "LATIN SMALL LETTER A WITH RING BELOW");
+    ("/xe1/xb8/x82", "LATIN CAPITAL LETTER B WITH DOT ABOVE");
+@@ -6440,11 +1760,6 @@
+    ("/xe1/xbe/xba", "GREEK CAPITAL LETTER ALPHA WITH VARIA");
+    ("/xe1/xbe/xbb", "GREEK CAPITAL LETTER ALPHA WITH OXIA");
+    ("/xe1/xbe/xbc", "GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI");
+-   ("/xe1/xbe/xbd", "GREEK KORONIS");
+-   ("/xe1/xbe/xbe", "GREEK PROSGEGRAMMENI");
+-   ("/xe1/xbe/xbf", "GREEK PSILI");
+-   ("/xe1/xbf/x80", "GREEK PERISPOMENI");
+-   ("/xe1/xbf/x81", "GREEK DIALYTIKA AND PERISPOMENI");
+    ("/xe1/xbf/x82", "GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI");
+    ("/xe1/xbf/x83", "GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI");
+    ("/xe1/xbf/x84", "GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI");
+@@ -6455,9 +1770,6 @@
+    ("/xe1/xbf/x8a", "GREEK CAPITAL LETTER ETA WITH VARIA");
+    ("/xe1/xbf/x8b", "GREEK CAPITAL LETTER ETA WITH OXIA");
+    ("/xe1/xbf/x8c", "GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI");
+-   ("/xe1/xbf/x8d", "GREEK PSILI AND VARIA");
+-   ("/xe1/xbf/x8e", "GREEK PSILI AND OXIA");
+-   ("/xe1/xbf/x8f", "GREEK PSILI AND PERISPOMENI");
+    ("/xe1/xbf/x90", "GREEK SMALL LETTER IOTA WITH VRACHY");
+    ("/xe1/xbf/x91", "GREEK SMALL LETTER IOTA WITH MACRON");
+    ("/xe1/xbf/x92", "GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA");
+@@ -6468,9 +1780,6 @@
+    ("/xe1/xbf/x99", "GREEK CAPITAL LETTER IOTA WITH MACRON");
+    ("/xe1/xbf/x9a", "GREEK CAPITAL LETTER IOTA WITH VARIA");
+    ("/xe1/xbf/x9b", "GREEK CAPITAL LETTER IOTA WITH OXIA");
+-   ("/xe1/xbf/x9d", "GREEK DASIA AND VARIA");
+-   ("/xe1/xbf/x9e", "GREEK DASIA AND OXIA");
+-   ("/xe1/xbf/x9f", "GREEK DASIA AND PERISPOMENI");
+    ("/xe1/xbf/xa0", "GREEK SMALL LETTER UPSILON WITH VRACHY");
+    ("/xe1/xbf/xa1", "GREEK SMALL LETTER UPSILON WITH MACRON");
+    ("/xe1/xbf/xa2", "GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA");
+@@ -6484,9 +1793,6 @@
+    ("/xe1/xbf/xaa", "GREEK CAPITAL LETTER UPSILON WITH VARIA");
+    ("/xe1/xbf/xab", "GREEK CAPITAL LETTER UPSILON WITH OXIA");
+    ("/xe1/xbf/xac", "GREEK CAPITAL LETTER RHO WITH DASIA");
+-   ("/xe1/xbf/xad", "GREEK DIALYTIKA AND VARIA");
+-   ("/xe1/xbf/xae", "GREEK DIALYTIKA AND OXIA");
+-   ("/xe1/xbf/xaf", "GREEK VARIA");
+    ("/xe1/xbf/xb2", "GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI");
+    ("/xe1/xbf/xb3", "GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI");
+    ("/xe1/xbf/xb4", "GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI");
+@@ -6497,269 +1803,45 @@
+    ("/xe1/xbf/xba", "GREEK CAPITAL LETTER OMEGA WITH VARIA");
+    ("/xe1/xbf/xbb", "GREEK CAPITAL LETTER OMEGA WITH OXIA");
+    ("/xe1/xbf/xbc", "GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI");
+-   ("/xe1/xbf/xbd", "GREEK OXIA");
+-   ("/xe1/xbf/xbe", "GREEK DASIA");
+-   ("/xe2/x80/x80", "EN QUAD");
+-   ("/xe2/x80/x81", "EM QUAD");
+-   ("/xe2/x80/x82", "EN SPACE");
+-   ("/xe2/x80/x83", "EM SPACE");
+-   ("/xe2/x80/x84", "THREE-PER-EM SPACE");
+-   ("/xe2/x80/x85", "FOUR-PER-EM SPACE");
+-   ("/xe2/x80/x86", "SIX-PER-EM SPACE");
+-   ("/xe2/x80/x87", "FIGURE SPACE");
+-   ("/xe2/x80/x88", "PUNCTUATION SPACE");
+-   ("/xe2/x80/x89", "THIN SPACE");
+-   ("/xe2/x80/x8a", "HAIR SPACE");
+-   ("/xe2/x80/x8b", "ZERO WIDTH SPACE");
+-   ("/xe2/x80/x8c", "ZERO WIDTH NON-JOINER");
+-   ("/xe2/x80/x8d", "ZERO WIDTH JOINER");
+-   ("/xe2/x80/x8e", "LEFT-TO-RIGHT MARK");
+-   ("/xe2/x80/x8f", "RIGHT-TO-LEFT MARK");
+-   ("/xe2/x80/x90", "HYPHEN");
+-   ("/xe2/x80/x91", "NON-BREAKING HYPHEN");
+-   ("/xe2/x80/x92", "FIGURE DASH");
+-   ("/xe2/x80/x93", "EN DASH");
+-   ("/xe2/x80/x94", "EM DASH");
+-   ("/xe2/x80/x95", "HORIZONTAL BAR");
+-   ("/xe2/x80/x96", "DOUBLE VERTICAL LINE");
+-   ("/xe2/x80/x97", "DOUBLE LOW LINE");
+-   ("/xe2/x80/x98", "LEFT SINGLE QUOTATION MARK");
+-   ("/xe2/x80/x99", "RIGHT SINGLE QUOTATION MARK");
+-   ("/xe2/x80/x9a", "SINGLE LOW-9 QUOTATION MARK");
+-   ("/xe2/x80/x9b", "SINGLE HIGH-REVERSED-9 QUOTATION MARK");
+-   ("/xe2/x80/x9c", "LEFT DOUBLE QUOTATION MARK");
+-   ("/xe2/x80/x9d", "RIGHT DOUBLE QUOTATION MARK");
+-   ("/xe2/x80/x9e", "DOUBLE LOW-9 QUOTATION MARK");
+-   ("/xe2/x80/x9f", "DOUBLE HIGH-REVERSED-9 QUOTATION MARK");
+-   ("/xe2/x80/xa0", "DAGGER");
+-   ("/xe2/x80/xa1", "DOUBLE DAGGER");
+-   ("/xe2/x80/xa2", "BULLET");
+-   ("/xe2/x80/xa3", "TRIANGULAR BULLET");
+-   ("/xe2/x80/xa4", "ONE DOT LEADER");
+-   ("/xe2/x80/xa5", "TWO DOT LEADER");
+-   ("/xe2/x80/xa6", "HORIZONTAL ELLIPSIS");
+-   ("/xe2/x80/xa7", "HYPHENATION POINT");
+-   ("/xe2/x80/xa8", "LINE SEPARATOR");
+-   ("/xe2/x80/xa9", "PARAGRAPH SEPARATOR");
+-   ("/xe2/x80/xaa", "LEFT-TO-RIGHT EMBEDDING");
+-   ("/xe2/x80/xab", "RIGHT-TO-LEFT EMBEDDING");
+-   ("/xe2/x80/xac", "POP DIRECTIONAL FORMATTING");
+-   ("/xe2/x80/xad", "LEFT-TO-RIGHT OVERRIDE");
+-   ("/xe2/x80/xae", "RIGHT-TO-LEFT OVERRIDE");
+-   ("/xe2/x80/xaf", "NARROW NO-BREAK SPACE");
+-   ("/xe2/x80/xb0", "PER MILLE SIGN");
+-   ("/xe2/x80/xb1", "PER TEN THOUSAND SIGN");
+-   ("/xe2/x80/xb2", "PRIME");
+-   ("/xe2/x80/xb3", "DOUBLE PRIME");
+-   ("/xe2/x80/xb4", "TRIPLE PRIME");
+-   ("/xe2/x80/xb5", "REVERSED PRIME");
+-   ("/xe2/x80/xb6", "REVERSED DOUBLE PRIME");
+-   ("/xe2/x80/xb7", "REVERSED TRIPLE PRIME");
+-   ("/xe2/x80/xb8", "CARET");
+-   ("/xe2/x80/xb9", "SINGLE LEFT-POINTING ANGLE QUOTATION MARK");
+-   ("/xe2/x80/xba", "SINGLE RIGHT-POINTING ANGLE QUOTATION MARK");
+-   ("/xe2/x80/xbb", "REFERENCE MARK");
+-   ("/xe2/x80/xbc", "DOUBLE EXCLAMATION MARK");
+-   ("/xe2/x80/xbd", "INTERROBANG");
+-   ("/xe2/x80/xbe", "OVERLINE");
+-   ("/xe2/x80/xbf", "UNDERTIE");
+-   ("/xe2/x81/x80", "CHARACTER TIE");
+-   ("/xe2/x81/x81", "CARET INSERTION POINT");
+-   ("/xe2/x81/x82", "ASTERISM");
+-   ("/xe2/x81/x83", "HYPHEN BULLET");
+-   ("/xe2/x81/x84", "FRACTION SLASH");
+-   ("/xe2/x81/x85", "LEFT SQUARE BRACKET WITH QUILL");
+-   ("/xe2/x81/x86", "RIGHT SQUARE BRACKET WITH QUILL");
+-   ("/xe2/x81/x87", "DOUBLE QUESTION MARK");
+-   ("/xe2/x81/x88", "QUESTION EXCLAMATION MARK");
+-   ("/xe2/x81/x89", "EXCLAMATION QUESTION MARK");
+-   ("/xe2/x81/x8a", "TIRONIAN SIGN ET");
+-   ("/xe2/x81/x8b", "REVERSED PILCROW SIGN");
+-   ("/xe2/x81/x8c", "BLACK LEFTWARDS BULLET");
+-   ("/xe2/x81/x8d", "BLACK RIGHTWARDS BULLET");
+-   ("/xe2/x81/x8e", "LOW ASTERISK");
+-   ("/xe2/x81/x8f", "REVERSED SEMICOLON");
+-   ("/xe2/x81/x90", "CLOSE UP");
+-   ("/xe2/x81/x91", "TWO ASTERISKS ALIGNED VERTICALLY");
+-   ("/xe2/x81/x92", "COMMERCIAL MINUS SIGN");
+-   ("/xe2/x81/x93", "SWUNG DASH");
+-   ("/xe2/x81/x94", "INVERTED UNDERTIE");
+-   ("/xe2/x81/x95", "FLOWER PUNCTUATION MARK");
+-   ("/xe2/x81/x96", "THREE DOT PUNCTUATION");
+-   ("/xe2/x81/x97", "QUADRUPLE PRIME");
+-   ("/xe2/x81/x98", "FOUR DOT PUNCTUATION");
+-   ("/xe2/x81/x99", "FIVE DOT PUNCTUATION");
+-   ("/xe2/x81/x9a", "TWO DOT PUNCTUATION");
+-   ("/xe2/x81/x9b", "FOUR DOT MARK");
+-   ("/xe2/x81/x9c", "DOTTED CROSS");
+-   ("/xe2/x81/x9d", "TRICOLON");
+-   ("/xe2/x81/x9e", "VERTICAL FOUR DOTS");
+-   ("/xe2/x81/x9f", "MEDIUM MATHEMATICAL SPACE");
+-   ("/xe2/x81/xa0", "WORD JOINER");
+-   ("/xe2/x81/xa1", "FUNCTION APPLICATION");
+-   ("/xe2/x81/xa2", "INVISIBLE TIMES");
+-   ("/xe2/x81/xa3", "INVISIBLE SEPARATOR");
+-   ("/xe2/x81/xa4", "INVISIBLE PLUS");
+-   ("/xe2/x81/xaa", "INHIBIT SYMMETRIC SWAPPING");
+-   ("/xe2/x81/xab", "ACTIVATE SYMMETRIC SWAPPING");
+-   ("/xe2/x81/xac", "INHIBIT ARABIC FORM SHAPING");
+-   ("/xe2/x81/xad", "ACTIVATE ARABIC FORM SHAPING");
+-   ("/xe2/x81/xae", "NATIONAL DIGIT SHAPES");
+-   ("/xe2/x81/xaf", "NOMINAL DIGIT SHAPES");
+-   ("/xe2/x81/xb0", "SUPERSCRIPT ZERO");
+    ("/xe2/x81/xb1", "SUPERSCRIPT LATIN SMALL LETTER I");
+-   ("/xe2/x81/xb4", "SUPERSCRIPT FOUR");
+-   ("/xe2/x81/xb5", "SUPERSCRIPT FIVE");
+-   ("/xe2/x81/xb6", "SUPERSCRIPT SIX");
+-   ("/xe2/x81/xb7", "SUPERSCRIPT SEVEN");
+-   ("/xe2/x81/xb8", "SUPERSCRIPT EIGHT");
+-   ("/xe2/x81/xb9", "SUPERSCRIPT NINE");
+-   ("/xe2/x81/xba", "SUPERSCRIPT PLUS SIGN");
+-   ("/xe2/x81/xbb", "SUPERSCRIPT MINUS");
+-   ("/xe2/x81/xbc", "SUPERSCRIPT EQUALS SIGN");
+-   ("/xe2/x81/xbd", "SUPERSCRIPT LEFT PARENTHESIS");
+-   ("/xe2/x81/xbe", "SUPERSCRIPT RIGHT PARENTHESIS");
+    ("/xe2/x81/xbf", "SUPERSCRIPT LATIN SMALL LETTER N");
+-   ("/xe2/x82/x80", "SUBSCRIPT ZERO");
+-   ("/xe2/x82/x81", "SUBSCRIPT ONE");
+-   ("/xe2/x82/x82", "SUBSCRIPT TWO");
+-   ("/xe2/x82/x83", "SUBSCRIPT THREE");
+-   ("/xe2/x82/x84", "SUBSCRIPT FOUR");
+-   ("/xe2/x82/x85", "SUBSCRIPT FIVE");
+-   ("/xe2/x82/x86", "SUBSCRIPT SIX");
+-   ("/xe2/x82/x87", "SUBSCRIPT SEVEN");
+-   ("/xe2/x82/x88", "SUBSCRIPT EIGHT");
+-   ("/xe2/x82/x89", "SUBSCRIPT NINE");
+-   ("/xe2/x82/x8a", "SUBSCRIPT PLUS SIGN");
+-   ("/xe2/x82/x8b", "SUBSCRIPT MINUS");
+-   ("/xe2/x82/x8c", "SUBSCRIPT EQUALS SIGN");
+-   ("/xe2/x82/x8d", "SUBSCRIPT LEFT PARENTHESIS");
+-   ("/xe2/x82/x8e", "SUBSCRIPT RIGHT PARENTHESIS");
+    ("/xe2/x82/x90", "LATIN SUBSCRIPT SMALL LETTER A");
+    ("/xe2/x82/x91", "LATIN SUBSCRIPT SMALL LETTER E");
+    ("/xe2/x82/x92", "LATIN SUBSCRIPT SMALL LETTER O");
+    ("/xe2/x82/x93", "LATIN SUBSCRIPT SMALL LETTER X");
+    ("/xe2/x82/x94", "LATIN SUBSCRIPT SMALL LETTER SCHWA");
+-   ("/xe2/x82/xa0", "EURO-CURRENCY SIGN");
+-   ("/xe2/x82/xa1", "COLON SIGN");
+-   ("/xe2/x82/xa2", "CRUZEIRO SIGN");
+-   ("/xe2/x82/xa3", "FRENCH FRANC SIGN");
+-   ("/xe2/x82/xa4", "LIRA SIGN");
+-   ("/xe2/x82/xa5", "MILL SIGN");
+-   ("/xe2/x82/xa6", "NAIRA SIGN");
+-   ("/xe2/x82/xa7", "PESETA SIGN");
+-   ("/xe2/x82/xa8", "RUPEE SIGN");
+-   ("/xe2/x82/xa9", "WON SIGN");
+-   ("/xe2/x82/xaa", "NEW SHEQEL SIGN");
+-   ("/xe2/x82/xab", "DONG SIGN");
+-   ("/xe2/x82/xac", "EURO SIGN");
+-   ("/xe2/x82/xad", "KIP SIGN");
+-   ("/xe2/x82/xae", "TUGRIK SIGN");
+-   ("/xe2/x82/xaf", "DRACHMA SIGN");
+-   ("/xe2/x82/xb0", "GERMAN PENNY SIGN");
+-   ("/xe2/x82/xb1", "PESO SIGN");
+-   ("/xe2/x82/xb2", "GUARANI SIGN");
+-   ("/xe2/x82/xb3", "AUSTRAL SIGN");
+-   ("/xe2/x82/xb4", "HRYVNIA SIGN");
+-   ("/xe2/x82/xb5", "CEDI SIGN");
+-   ("/xe2/x83/x90", "COMBINING LEFT HARPOON ABOVE");
+-   ("/xe2/x83/x91", "COMBINING RIGHT HARPOON ABOVE");
+-   ("/xe2/x83/x92", "COMBINING LONG VERTICAL LINE OVERLAY");
+-   ("/xe2/x83/x93", "COMBINING SHORT VERTICAL LINE OVERLAY");
+-   ("/xe2/x83/x94", "COMBINING ANTICLOCKWISE ARROW ABOVE");
+-   ("/xe2/x83/x95", "COMBINING CLOCKWISE ARROW ABOVE");
+-   ("/xe2/x83/x96", "COMBINING LEFT ARROW ABOVE");
+-   ("/xe2/x83/x97", "COMBINING RIGHT ARROW ABOVE");
+-   ("/xe2/x83/x98", "COMBINING RING OVERLAY");
+-   ("/xe2/x83/x99", "COMBINING CLOCKWISE RING OVERLAY");
+-   ("/xe2/x83/x9a", "COMBINING ANTICLOCKWISE RING OVERLAY");
+-   ("/xe2/x83/x9b", "COMBINING THREE DOTS ABOVE");
+-   ("/xe2/x83/x9c", "COMBINING FOUR DOTS ABOVE");
+-   ("/xe2/x83/x9d", "COMBINING ENCLOSING CIRCLE");
+-   ("/xe2/x83/x9e", "COMBINING ENCLOSING SQUARE");
+-   ("/xe2/x83/x9f", "COMBINING ENCLOSING DIAMOND");
+-   ("/xe2/x83/xa0", "COMBINING ENCLOSING CIRCLE BACKSLASH");
+-   ("/xe2/x83/xa1", "COMBINING LEFT RIGHT ARROW ABOVE");
+-   ("/xe2/x83/xa2", "COMBINING ENCLOSING SCREEN");
+-   ("/xe2/x83/xa3", "COMBINING ENCLOSING KEYCAP");
+-   ("/xe2/x83/xa4", "COMBINING ENCLOSING UPWARD POINTING TRIANGLE");
+-   ("/xe2/x83/xa5", "COMBINING REVERSE SOLIDUS OVERLAY");
+-   ("/xe2/x83/xa6", "COMBINING DOUBLE VERTICAL STROKE OVERLAY");
+-   ("/xe2/x83/xa7", "COMBINING ANNUITY SYMBOL");
+-   ("/xe2/x83/xa8", "COMBINING TRIPLE UNDERDOT");
+-   ("/xe2/x83/xa9", "COMBINING WIDE BRIDGE ABOVE");
+-   ("/xe2/x83/xaa", "COMBINING LEFTWARDS ARROW OVERLAY");
+-   ("/xe2/x83/xab", "COMBINING LONG DOUBLE SOLIDUS OVERLAY");
+-   ("/xe2/x83/xac", "COMBINING RIGHTWARDS HARPOON WITH BARB DOWNWARDS");
+-   ("/xe2/x83/xad", "COMBINING LEFTWARDS HARPOON WITH BARB DOWNWARDS");
+-   ("/xe2/x83/xae", "COMBINING LEFT ARROW BELOW");
+-   ("/xe2/x83/xaf", "COMBINING RIGHT ARROW BELOW");
+-   ("/xe2/x83/xb0", "COMBINING ASTERISK ABOVE");
+-   ("/xe2/x84/x80", "ACCOUNT OF");
+-   ("/xe2/x84/x81", "ADDRESSED TO THE SUBJECT");
+    ("/xe2/x84/x82", "DOUBLE-STRUCK CAPITAL C");
+-   ("/xe2/x84/x83", "DEGREE CELSIUS");
+-   ("/xe2/x84/x84", "CENTRE LINE SYMBOL");
+-   ("/xe2/x84/x85", "CARE OF");
+-   ("/xe2/x84/x86", "CADA UNA");
+-   ("/xe2/x84/x87", "EULER CONSTANT");
+-   ("/xe2/x84/x88", "SCRUPLE");
+-   ("/xe2/x84/x89", "DEGREE FAHRENHEIT");
+    ("/xe2/x84/x8a", "SCRIPT SMALL G");
+    ("/xe2/x84/x8b", "SCRIPT CAPITAL H");
+    ("/xe2/x84/x8c", "BLACK-LETTER CAPITAL H");
+    ("/xe2/x84/x8d", "DOUBLE-STRUCK CAPITAL H");
+-   ("/xe2/x84/x8e", "PLANCK CONSTANT");
+-   ("/xe2/x84/x8f", "PLANCK CONSTANT OVER TWO PI");
+    ("/xe2/x84/x90", "SCRIPT CAPITAL I");
+    ("/xe2/x84/x91", "BLACK-LETTER CAPITAL I");
+    ("/xe2/x84/x92", "SCRIPT CAPITAL L");
+    ("/xe2/x84/x93", "SCRIPT SMALL L");
+-   ("/xe2/x84/x94", "L B BAR SYMBOL");
+    ("/xe2/x84/x95", "DOUBLE-STRUCK CAPITAL N");
+-   ("/xe2/x84/x96", "NUMERO SIGN");
+-   ("/xe2/x84/x97", "SOUND RECORDING COPYRIGHT");
+    ("/xe2/x84/x98", "SCRIPT CAPITAL P");
+    ("/xe2/x84/x99", "DOUBLE-STRUCK CAPITAL P");
+    ("/xe2/x84/x9a", "DOUBLE-STRUCK CAPITAL Q");
+    ("/xe2/x84/x9b", "SCRIPT CAPITAL R");
+    ("/xe2/x84/x9c", "BLACK-LETTER CAPITAL R");
+    ("/xe2/x84/x9d", "DOUBLE-STRUCK CAPITAL R");
+-   ("/xe2/x84/x9e", "PRESCRIPTION TAKE");
+-   ("/xe2/x84/x9f", "RESPONSE");
+-   ("/xe2/x84/xa0", "SERVICE MARK");
+-   ("/xe2/x84/xa1", "TELEPHONE SIGN");
+-   ("/xe2/x84/xa2", "TRADE MARK SIGN");
+-   ("/xe2/x84/xa3", "VERSICLE");
+    ("/xe2/x84/xa4", "DOUBLE-STRUCK CAPITAL Z");
+-   ("/xe2/x84/xa5", "OUNCE SIGN");
+-   ("/xe2/x84/xa6", "OHM SIGN");
+-   ("/xe2/x84/xa7", "INVERTED OHM SIGN");
+    ("/xe2/x84/xa8", "BLACK-LETTER CAPITAL Z");
+    ("/xe2/x84/xa9", "TURNED GREEK SMALL LETTER IOTA");
+-   ("/xe2/x84/xaa", "KELVIN SIGN");
+-   ("/xe2/x84/xab", "ANGSTROM SIGN");
+    ("/xe2/x84/xac", "SCRIPT CAPITAL B");
+    ("/xe2/x84/xad", "BLACK-LETTER CAPITAL C");
+-   ("/xe2/x84/xae", "ESTIMATED SYMBOL");
+    ("/xe2/x84/xaf", "SCRIPT SMALL E");
+    ("/xe2/x84/xb0", "SCRIPT CAPITAL E");
+    ("/xe2/x84/xb1", "SCRIPT CAPITAL F");
+    ("/xe2/x84/xb2", "TURNED CAPITAL F");
+    ("/xe2/x84/xb3", "SCRIPT CAPITAL M");
+    ("/xe2/x84/xb4", "SCRIPT SMALL O");
+-   ("/xe2/x84/xb5", "ALEF SYMBOL");
+-   ("/xe2/x84/xb6", "BET SYMBOL");
+-   ("/xe2/x84/xb7", "GIMEL SYMBOL");
+-   ("/xe2/x84/xb8", "DALET SYMBOL");
+-   ("/xe2/x84/xb9", "INFORMATION SOURCE");
+    ("/xe2/x84/xba", "ROTATED CAPITAL Q");
+-   ("/xe2/x84/xbb", "FACSIMILE SIGN");
+    ("/xe2/x84/xbc", "DOUBLE-STRUCK SMALL PI");
+    ("/xe2/x84/xbd", "DOUBLE-STRUCK SMALL GAMMA");
+    ("/xe2/x84/xbe", "DOUBLE-STRUCK CAPITAL GAMMA");
+    ("/xe2/x84/xbf", "DOUBLE-STRUCK CAPITAL PI");
+-   ("/xe2/x85/x80", "DOUBLE-STRUCK N-ARY SUMMATION");
+    ("/xe2/x85/x81", "TURNED SANS-SERIF CAPITAL G");
+    ("/xe2/x85/x82", "TURNED SANS-SERIF CAPITAL L");
+    ("/xe2/x85/x83", "REVERSED SANS-SERIF CAPITAL L");
+@@ -6769,41 +1851,7 @@
+    ("/xe2/x85/x87", "DOUBLE-STRUCK ITALIC SMALL E");
+    ("/xe2/x85/x88", "DOUBLE-STRUCK ITALIC SMALL I");
+    ("/xe2/x85/x89", "DOUBLE-STRUCK ITALIC SMALL J");
+-   ("/xe2/x85/x8a", "PROPERTY LINE");
+-   ("/xe2/x85/x8b", "TURNED AMPERSAND");
+-   ("/xe2/x85/x8c", "PER SIGN");
+-   ("/xe2/x85/x8d", "AKTIESELSKAB");
+    ("/xe2/x85/x8e", "TURNED SMALL F");
+-   ("/xe2/x85/x8f", "SYMBOL FOR SAMARITAN SOURCE");
+-   ("/xe2/x85/x93", "VULGAR FRACTION ONE THIRD");
+-   ("/xe2/x85/x94", "VULGAR FRACTION TWO THIRDS");
+-   ("/xe2/x85/x95", "VULGAR FRACTION ONE FIFTH");
+-   ("/xe2/x85/x96", "VULGAR FRACTION TWO FIFTHS");
+-   ("/xe2/x85/x97", "VULGAR FRACTION THREE FIFTHS");
+-   ("/xe2/x85/x98", "VULGAR FRACTION FOUR FIFTHS");
+-   ("/xe2/x85/x99", "VULGAR FRACTION ONE SIXTH");
+-   ("/xe2/x85/x9a", "VULGAR FRACTION FIVE SIXTHS");
+-   ("/xe2/x85/x9b", "VULGAR FRACTION ONE EIGHTH");
+-   ("/xe2/x85/x9c", "VULGAR FRACTION THREE EIGHTHS");
+-   ("/xe2/x85/x9d", "VULGAR FRACTION FIVE EIGHTHS");
+-   ("/xe2/x85/x9e", "VULGAR FRACTION SEVEN EIGHTHS");
+-   ("/xe2/x85/x9f", "FRACTION NUMERATOR ONE");
+-   ("/xe2/x85/xa0", "ROMAN NUMERAL ONE");
+-   ("/xe2/x85/xa1", "ROMAN NUMERAL TWO");
+-   ("/xe2/x85/xa2", "ROMAN NUMERAL THREE");
+-   ("/xe2/x85/xa3", "ROMAN NUMERAL FOUR");
+-   ("/xe2/x85/xa4", "ROMAN NUMERAL FIVE");
+-   ("/xe2/x85/xa5", "ROMAN NUMERAL SIX");
+-   ("/xe2/x85/xa6", "ROMAN NUMERAL SEVEN");
+-   ("/xe2/x85/xa7", "ROMAN NUMERAL EIGHT");
+-   ("/xe2/x85/xa8", "ROMAN NUMERAL NINE");
+-   ("/xe2/x85/xa9", "ROMAN NUMERAL TEN");
+-   ("/xe2/x85/xaa", "ROMAN NUMERAL ELEVEN");
+-   ("/xe2/x85/xab", "ROMAN NUMERAL TWELVE");
+-   ("/xe2/x85/xac", "ROMAN NUMERAL FIFTY");
+-   ("/xe2/x85/xad", "ROMAN NUMERAL ONE HUNDRED");
+-   ("/xe2/x85/xae", "ROMAN NUMERAL FIVE HUNDRED");
+-   ("/xe2/x85/xaf", "ROMAN NUMERAL ONE THOUSAND");
+    ("/xe2/x85/xb0", "SMALL ROMAN NUMERAL ONE");
+    ("/xe2/x85/xb1", "SMALL ROMAN NUMERAL TWO");
+    ("/xe2/x85/xb2", "SMALL ROMAN NUMERAL THREE");
+@@ -6820,725 +1868,14 @@
+    ("/xe2/x85/xbd", "SMALL ROMAN NUMERAL ONE HUNDRED");
+    ("/xe2/x85/xbe", "SMALL ROMAN NUMERAL FIVE HUNDRED");
+    ("/xe2/x85/xbf", "SMALL ROMAN NUMERAL ONE THOUSAND");
+-   ("/xe2/x86/x80", "ROMAN NUMERAL ONE THOUSAND C D");
+-   ("/xe2/x86/x81", "ROMAN NUMERAL FIVE THOUSAND");
+-   ("/xe2/x86/x82", "ROMAN NUMERAL TEN THOUSAND");
+-   ("/xe2/x86/x83", "ROMAN NUMERAL REVERSED ONE HUNDRED");
+    ("/xe2/x86/x84", "LATIN SMALL LETTER REVERSED C");
+-   ("/xe2/x86/x85", "ROMAN NUMERAL SIX LATE FORM");
+-   ("/xe2/x86/x86", "ROMAN NUMERAL FIFTY EARLY FORM");
+-   ("/xe2/x86/x87", "ROMAN NUMERAL FIFTY THOUSAND");
+-   ("/xe2/x86/x88", "ROMAN NUMERAL ONE HUNDRED THOUSAND");
+-   ("/xe2/x86/x90", "LEFTWARDS ARROW");
+-   ("/xe2/x86/x91", "UPWARDS ARROW");
+-   ("/xe2/x86/x92", "RIGHTWARDS ARROW");
+-   ("/xe2/x86/x93", "DOWNWARDS ARROW");
+-   ("/xe2/x86/x94", "LEFT RIGHT ARROW");
+-   ("/xe2/x86/x95", "UP DOWN ARROW");
+-   ("/xe2/x86/x96", "NORTH WEST ARROW");
+-   ("/xe2/x86/x97", "NORTH EAST ARROW");
+-   ("/xe2/x86/x98", "SOUTH EAST ARROW");
+-   ("/xe2/x86/x99", "SOUTH WEST ARROW");
+-   ("/xe2/x86/x9a", "LEFTWARDS ARROW WITH STROKE");
+-   ("/xe2/x86/x9b", "RIGHTWARDS ARROW WITH STROKE");
+-   ("/xe2/x86/x9c", "LEFTWARDS WAVE ARROW");
+-   ("/xe2/x86/x9d", "RIGHTWARDS WAVE ARROW");
+-   ("/xe2/x86/x9e", "LEFTWARDS TWO HEADED ARROW");
+-   ("/xe2/x86/x9f", "UPWARDS TWO HEADED ARROW");
+-   ("/xe2/x86/xa0", "RIGHTWARDS TWO HEADED ARROW");
+-   ("/xe2/x86/xa1", "DOWNWARDS TWO HEADED ARROW");
+-   ("/xe2/x86/xa2", "LEFTWARDS ARROW WITH TAIL");
+-   ("/xe2/x86/xa3", "RIGHTWARDS ARROW WITH TAIL");
+-   ("/xe2/x86/xa4", "LEFTWARDS ARROW FROM BAR");
+-   ("/xe2/x86/xa5", "UPWARDS ARROW FROM BAR");
+-   ("/xe2/x86/xa6", "RIGHTWARDS ARROW FROM BAR");
+-   ("/xe2/x86/xa7", "DOWNWARDS ARROW FROM BAR");
+-   ("/xe2/x86/xa8", "UP DOWN ARROW WITH BASE");
+-   ("/xe2/x86/xa9", "LEFTWARDS ARROW WITH HOOK");
+-   ("/xe2/x86/xaa", "RIGHTWARDS ARROW WITH HOOK");
+-   ("/xe2/x86/xab", "LEFTWARDS ARROW WITH LOOP");
+-   ("/xe2/x86/xac", "RIGHTWARDS ARROW WITH LOOP");
+-   ("/xe2/x86/xad", "LEFT RIGHT WAVE ARROW");
+-   ("/xe2/x86/xae", "LEFT RIGHT ARROW WITH STROKE");
+-   ("/xe2/x86/xaf", "DOWNWARDS ZIGZAG ARROW");
+-   ("/xe2/x86/xb0", "UPWARDS ARROW WITH TIP LEFTWARDS");
+-   ("/xe2/x86/xb1", "UPWARDS ARROW WITH TIP RIGHTWARDS");
+-   ("/xe2/x86/xb2", "DOWNWARDS ARROW WITH TIP LEFTWARDS");
+-   ("/xe2/x86/xb3", "DOWNWARDS ARROW WITH TIP RIGHTWARDS");
+-   ("/xe2/x86/xb4", "RIGHTWARDS ARROW WITH CORNER DOWNWARDS");
+-   ("/xe2/x86/xb5", "DOWNWARDS ARROW WITH CORNER LEFTWARDS");
+-   ("/xe2/x86/xb6", "ANTICLOCKWISE TOP SEMICIRCLE ARROW");
+-   ("/xe2/x86/xb7", "CLOCKWISE TOP SEMICIRCLE ARROW");
+-   ("/xe2/x86/xb8", "NORTH WEST ARROW TO LONG BAR");
+-   ("/xe2/x86/xb9", "LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR");
+-   ("/xe2/x86/xba", "ANTICLOCKWISE OPEN CIRCLE ARROW");
+-   ("/xe2/x86/xbb", "CLOCKWISE OPEN CIRCLE ARROW");
+-   ("/xe2/x86/xbc", "LEFTWARDS HARPOON WITH BARB UPWARDS");
+-   ("/xe2/x86/xbd", "LEFTWARDS HARPOON WITH BARB DOWNWARDS");
+-   ("/xe2/x86/xbe", "UPWARDS HARPOON WITH BARB RIGHTWARDS");
+-   ("/xe2/x86/xbf", "UPWARDS HARPOON WITH BARB LEFTWARDS");
+-   ("/xe2/x87/x80", "RIGHTWARDS HARPOON WITH BARB UPWARDS");
+-   ("/xe2/x87/x81", "RIGHTWARDS HARPOON WITH BARB DOWNWARDS");
+-   ("/xe2/x87/x82", "DOWNWARDS HARPOON WITH BARB RIGHTWARDS");
+-   ("/xe2/x87/x83", "DOWNWARDS HARPOON WITH BARB LEFTWARDS");
+-   ("/xe2/x87/x84", "RIGHTWARDS ARROW OVER LEFTWARDS ARROW");
+-   ("/xe2/x87/x85", "UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW");
+-   ("/xe2/x87/x86", "LEFTWARDS ARROW OVER RIGHTWARDS ARROW");
+-   ("/xe2/x87/x87", "LEFTWARDS PAIRED ARROWS");
+-   ("/xe2/x87/x88", "UPWARDS PAIRED ARROWS");
+-   ("/xe2/x87/x89", "RIGHTWARDS PAIRED ARROWS");
+-   ("/xe2/x87/x8a", "DOWNWARDS PAIRED ARROWS");
+-   ("/xe2/x87/x8b", "LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON");
+-   ("/xe2/x87/x8c", "RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON");
+-   ("/xe2/x87/x8d", "LEFTWARDS DOUBLE ARROW WITH STROKE");
+-   ("/xe2/x87/x8e", "LEFT RIGHT DOUBLE ARROW WITH STROKE");
+-   ("/xe2/x87/x8f", "RIGHTWARDS DOUBLE ARROW WITH STROKE");
+-   ("/xe2/x87/x90", "LEFTWARDS DOUBLE ARROW");
+-   ("/xe2/x87/x91", "UPWARDS DOUBLE ARROW");
+-   ("/xe2/x87/x92", "RIGHTWARDS DOUBLE ARROW");
+-   ("/xe2/x87/x93", "DOWNWARDS DOUBLE ARROW");
+-   ("/xe2/x87/x94", "LEFT RIGHT DOUBLE ARROW");
+-   ("/xe2/x87/x95", "UP DOWN DOUBLE ARROW");
+-   ("/xe2/x87/x96", "NORTH WEST DOUBLE ARROW");
+-   ("/xe2/x87/x97", "NORTH EAST DOUBLE ARROW");
+-   ("/xe2/x87/x98", "SOUTH EAST DOUBLE ARROW");
+-   ("/xe2/x87/x99", "SOUTH WEST DOUBLE ARROW");
+-   ("/xe2/x87/x9a", "LEFTWARDS TRIPLE ARROW");
+-   ("/xe2/x87/x9b", "RIGHTWARDS TRIPLE ARROW");
+-   ("/xe2/x87/x9c", "LEFTWARDS SQUIGGLE ARROW");
+-   ("/xe2/x87/x9d", "RIGHTWARDS SQUIGGLE ARROW");
+-   ("/xe2/x87/x9e", "UPWARDS ARROW WITH DOUBLE STROKE");
+-   ("/xe2/x87/x9f", "DOWNWARDS ARROW WITH DOUBLE STROKE");
+-   ("/xe2/x87/xa0", "LEFTWARDS DASHED ARROW");
+-   ("/xe2/x87/xa1", "UPWARDS DASHED ARROW");
+-   ("/xe2/x87/xa2", "RIGHTWARDS DASHED ARROW");
+-   ("/xe2/x87/xa3", "DOWNWARDS DASHED ARROW");
+-   ("/xe2/x87/xa4", "LEFTWARDS ARROW TO BAR");
+-   ("/xe2/x87/xa5", "RIGHTWARDS ARROW TO BAR");
+-   ("/xe2/x87/xa6", "LEFTWARDS WHITE ARROW");
+-   ("/xe2/x87/xa7", "UPWARDS WHITE ARROW");
+-   ("/xe2/x87/xa8", "RIGHTWARDS WHITE ARROW");
+-   ("/xe2/x87/xa9", "DOWNWARDS WHITE ARROW");
+-   ("/xe2/x87/xaa", "UPWARDS WHITE ARROW FROM BAR");
+-   ("/xe2/x87/xab", "UPWARDS WHITE ARROW ON PEDESTAL");
+-   ("/xe2/x87/xac", "UPWARDS WHITE ARROW ON PEDESTAL WITH HORIZONTAL BAR");
+-   ("/xe2/x87/xad", "UPWARDS WHITE ARROW ON PEDESTAL WITH VERTICAL BAR");
+-   ("/xe2/x87/xae", "UPWARDS WHITE DOUBLE ARROW");
+-   ("/xe2/x87/xaf", "UPWARDS WHITE DOUBLE ARROW ON PEDESTAL");
+-   ("/xe2/x87/xb0", "RIGHTWARDS WHITE ARROW FROM WALL");
+-   ("/xe2/x87/xb1", "NORTH WEST ARROW TO CORNER");
+-   ("/xe2/x87/xb2", "SOUTH EAST ARROW TO CORNER");
+-   ("/xe2/x87/xb3", "UP DOWN WHITE ARROW");
+    ("/xe2/x87/xb4", "RIGHT ARROW WITH SMALL CIRCLE");
+-   ("/xe2/x87/xb5", "DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW");
+-   ("/xe2/x87/xb6", "THREE RIGHTWARDS ARROWS");
+-   ("/xe2/x87/xb7", "LEFTWARDS ARROW WITH VERTICAL STROKE");
+-   ("/xe2/x87/xb8", "RIGHTWARDS ARROW WITH VERTICAL STROKE");
+-   ("/xe2/x87/xb9", "LEFT RIGHT ARROW WITH VERTICAL STROKE");
+-   ("/xe2/x87/xba", "LEFTWARDS ARROW WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/x87/xbb", "RIGHTWARDS ARROW WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/x87/xbc", "LEFT RIGHT ARROW WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/x87/xbd", "LEFTWARDS OPEN-HEADED ARROW");
+-   ("/xe2/x87/xbe", "RIGHTWARDS OPEN-HEADED ARROW");
+-   ("/xe2/x87/xbf", "LEFT RIGHT OPEN-HEADED ARROW");
+-   ("/xe2/x88/x80", "FOR ALL");
+-   ("/xe2/x88/x81", "COMPLEMENT");
+-   ("/xe2/x88/x82", "PARTIAL DIFFERENTIAL");
+-   ("/xe2/x88/x83", "THERE EXISTS");
+-   ("/xe2/x88/x84", "THERE DOES NOT EXIST");
+-   ("/xe2/x88/x85", "EMPTY SET");
+-   ("/xe2/x88/x86", "INCREMENT");
+-   ("/xe2/x88/x87", "NABLA");
+-   ("/xe2/x88/x88", "ELEMENT OF");
+-   ("/xe2/x88/x89", "NOT AN ELEMENT OF");
+    ("/xe2/x88/x8a", "SMALL ELEMENT OF");
+-   ("/xe2/x88/x8b", "CONTAINS AS MEMBER");
+-   ("/xe2/x88/x8c", "DOES NOT CONTAIN AS MEMBER");
+    ("/xe2/x88/x8d", "SMALL CONTAINS AS MEMBER");
+-   ("/xe2/x88/x8e", "END OF PROOF");
+-   ("/xe2/x88/x8f", "N-ARY PRODUCT");
+-   ("/xe2/x88/x90", "N-ARY COPRODUCT");
+-   ("/xe2/x88/x91", "N-ARY SUMMATION");
+-   ("/xe2/x88/x92", "MINUS SIGN");
+-   ("/xe2/x88/x93", "MINUS-OR-PLUS SIGN");
+-   ("/xe2/x88/x94", "DOT PLUS");
+-   ("/xe2/x88/x95", "DIVISION SLASH");
+-   ("/xe2/x88/x96", "SET MINUS");
+-   ("/xe2/x88/x97", "ASTERISK OPERATOR");
+-   ("/xe2/x88/x98", "RING OPERATOR");
+-   ("/xe2/x88/x99", "BULLET OPERATOR");
+-   ("/xe2/x88/x9a", "SQUARE ROOT");
+-   ("/xe2/x88/x9b", "CUBE ROOT");
+-   ("/xe2/x88/x9c", "FOURTH ROOT");
+-   ("/xe2/x88/x9d", "PROPORTIONAL TO");
+-   ("/xe2/x88/x9e", "INFINITY");
+-   ("/xe2/x88/x9f", "RIGHT ANGLE");
+-   ("/xe2/x88/xa0", "ANGLE");
+-   ("/xe2/x88/xa1", "MEASURED ANGLE");
+-   ("/xe2/x88/xa2", "SPHERICAL ANGLE");
+-   ("/xe2/x88/xa3", "DIVIDES");
+-   ("/xe2/x88/xa4", "DOES NOT DIVIDE");
+-   ("/xe2/x88/xa5", "PARALLEL TO");
+-   ("/xe2/x88/xa6", "NOT PARALLEL TO");
+-   ("/xe2/x88/xa7", "LOGICAL AND");
+-   ("/xe2/x88/xa8", "LOGICAL OR");
+-   ("/xe2/x88/xa9", "INTERSECTION");
+-   ("/xe2/x88/xaa", "UNION");
+-   ("/xe2/x88/xab", "INTEGRAL");
+-   ("/xe2/x88/xac", "DOUBLE INTEGRAL");
+-   ("/xe2/x88/xad", "TRIPLE INTEGRAL");
+-   ("/xe2/x88/xae", "CONTOUR INTEGRAL");
+-   ("/xe2/x88/xaf", "SURFACE INTEGRAL");
+-   ("/xe2/x88/xb0", "VOLUME INTEGRAL");
+-   ("/xe2/x88/xb1", "CLOCKWISE INTEGRAL");
+-   ("/xe2/x88/xb2", "CLOCKWISE CONTOUR INTEGRAL");
+-   ("/xe2/x88/xb3", "ANTICLOCKWISE CONTOUR INTEGRAL");
+-   ("/xe2/x88/xb4", "THEREFORE");
+-   ("/xe2/x88/xb5", "BECAUSE");
+-   ("/xe2/x88/xb6", "RATIO");
+-   ("/xe2/x88/xb7", "PROPORTION");
+-   ("/xe2/x88/xb8", "DOT MINUS");
+-   ("/xe2/x88/xb9", "EXCESS");
+-   ("/xe2/x88/xba", "GEOMETRIC PROPORTION");
+-   ("/xe2/x88/xbb", "HOMOTHETIC");
+-   ("/xe2/x88/xbc", "TILDE OPERATOR");
+-   ("/xe2/x88/xbd", "REVERSED TILDE");
+-   ("/xe2/x88/xbe", "INVERTED LAZY S");
+-   ("/xe2/x88/xbf", "SINE WAVE");
+-   ("/xe2/x89/x80", "WREATH PRODUCT");
+-   ("/xe2/x89/x81", "NOT TILDE");
+-   ("/xe2/x89/x82", "MINUS TILDE");
+-   ("/xe2/x89/x83", "ASYMPTOTICALLY EQUAL TO");
+-   ("/xe2/x89/x84", "NOT ASYMPTOTICALLY EQUAL TO");
+-   ("/xe2/x89/x85", "APPROXIMATELY EQUAL TO");
+-   ("/xe2/x89/x86", "APPROXIMATELY BUT NOT ACTUALLY EQUAL TO");
+-   ("/xe2/x89/x87", "NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO");
+-   ("/xe2/x89/x88", "ALMOST EQUAL TO");
+-   ("/xe2/x89/x89", "NOT ALMOST EQUAL TO");
+-   ("/xe2/x89/x8a", "ALMOST EQUAL OR EQUAL TO");
+-   ("/xe2/x89/x8b", "TRIPLE TILDE");
+-   ("/xe2/x89/x8c", "ALL EQUAL TO");
+-   ("/xe2/x89/x8d", "EQUIVALENT TO");
+-   ("/xe2/x89/x8e", "GEOMETRICALLY EQUIVALENT TO");
+-   ("/xe2/x89/x8f", "DIFFERENCE BETWEEN");
+-   ("/xe2/x89/x90", "APPROACHES THE LIMIT");
+-   ("/xe2/x89/x91", "GEOMETRICALLY EQUAL TO");
+-   ("/xe2/x89/x92", "APPROXIMATELY EQUAL TO OR THE IMAGE OF");
+-   ("/xe2/x89/x93", "IMAGE OF OR APPROXIMATELY EQUAL TO");
+-   ("/xe2/x89/x94", "COLON EQUALS");
+-   ("/xe2/x89/x95", "EQUALS COLON");
+-   ("/xe2/x89/x96", "RING IN EQUAL TO");
+-   ("/xe2/x89/x97", "RING EQUAL TO");
+-   ("/xe2/x89/x98", "CORRESPONDS TO");
+-   ("/xe2/x89/x99", "ESTIMATES");
+-   ("/xe2/x89/x9a", "EQUIANGULAR TO");
+-   ("/xe2/x89/x9b", "STAR EQUALS");
+-   ("/xe2/x89/x9c", "DELTA EQUAL TO");
+-   ("/xe2/x89/x9d", "EQUAL TO BY DEFINITION");
+-   ("/xe2/x89/x9e", "MEASURED BY");
+-   ("/xe2/x89/x9f", "QUESTIONED EQUAL TO");
+-   ("/xe2/x89/xa0", "NOT EQUAL TO");
+-   ("/xe2/x89/xa1", "IDENTICAL TO");
+-   ("/xe2/x89/xa2", "NOT IDENTICAL TO");
+-   ("/xe2/x89/xa3", "STRICTLY EQUIVALENT TO");
+-   ("/xe2/x89/xa4", "LESS-THAN OR EQUAL TO");
+-   ("/xe2/x89/xa5", "GREATER-THAN OR EQUAL TO");
+-   ("/xe2/x89/xa6", "LESS-THAN OVER EQUAL TO");
+-   ("/xe2/x89/xa7", "GREATER-THAN OVER EQUAL TO");
+-   ("/xe2/x89/xa8", "LESS-THAN BUT NOT EQUAL TO");
+-   ("/xe2/x89/xa9", "GREATER-THAN BUT NOT EQUAL TO");
+-   ("/xe2/x89/xaa", "MUCH LESS-THAN");
+-   ("/xe2/x89/xab", "MUCH GREATER-THAN");
+-   ("/xe2/x89/xac", "BETWEEN");
+-   ("/xe2/x89/xad", "NOT EQUIVALENT TO");
+-   ("/xe2/x89/xae", "NOT LESS-THAN");
+-   ("/xe2/x89/xaf", "NOT GREATER-THAN");
+-   ("/xe2/x89/xb0", "NEITHER LESS-THAN NOR EQUAL TO");
+-   ("/xe2/x89/xb1", "NEITHER GREATER-THAN NOR EQUAL TO");
+-   ("/xe2/x89/xb2", "LESS-THAN OR EQUIVALENT TO");
+-   ("/xe2/x89/xb3", "GREATER-THAN OR EQUIVALENT TO");
+-   ("/xe2/x89/xb4", "NEITHER LESS-THAN NOR EQUIVALENT TO");
+-   ("/xe2/x89/xb5", "NEITHER GREATER-THAN NOR EQUIVALENT TO");
+-   ("/xe2/x89/xb6", "LESS-THAN OR GREATER-THAN");
+-   ("/xe2/x89/xb7", "GREATER-THAN OR LESS-THAN");
+-   ("/xe2/x89/xb8", "NEITHER LESS-THAN NOR GREATER-THAN");
+-   ("/xe2/x89/xb9", "NEITHER GREATER-THAN NOR LESS-THAN");
+-   ("/xe2/x89/xba", "PRECEDES");
+-   ("/xe2/x89/xbb", "SUCCEEDS");
+-   ("/xe2/x89/xbc", "PRECEDES OR EQUAL TO");
+-   ("/xe2/x89/xbd", "SUCCEEDS OR EQUAL TO");
+-   ("/xe2/x89/xbe", "PRECEDES OR EQUIVALENT TO");
+-   ("/xe2/x89/xbf", "SUCCEEDS OR EQUIVALENT TO");
+-   ("/xe2/x8a/x80", "DOES NOT PRECEDE");
+-   ("/xe2/x8a/x81", "DOES NOT SUCCEED");
+-   ("/xe2/x8a/x82", "SUBSET OF");
+-   ("/xe2/x8a/x83", "SUPERSET OF");
+-   ("/xe2/x8a/x84", "NOT A SUBSET OF");
+-   ("/xe2/x8a/x85", "NOT A SUPERSET OF");
+-   ("/xe2/x8a/x86", "SUBSET OF OR EQUAL TO");
+-   ("/xe2/x8a/x87", "SUPERSET OF OR EQUAL TO");
+-   ("/xe2/x8a/x88", "NEITHER A SUBSET OF NOR EQUAL TO");
+-   ("/xe2/x8a/x89", "NEITHER A SUPERSET OF NOR EQUAL TO");
+-   ("/xe2/x8a/x8a", "SUBSET OF WITH NOT EQUAL TO");
+-   ("/xe2/x8a/x8b", "SUPERSET OF WITH NOT EQUAL TO");
+-   ("/xe2/x8a/x8c", "MULTISET");
+-   ("/xe2/x8a/x8d", "MULTISET MULTIPLICATION");
+-   ("/xe2/x8a/x8e", "MULTISET UNION");
+-   ("/xe2/x8a/x8f", "SQUARE IMAGE OF");
+-   ("/xe2/x8a/x90", "SQUARE ORIGINAL OF");
+-   ("/xe2/x8a/x91", "SQUARE IMAGE OF OR EQUAL TO");
+-   ("/xe2/x8a/x92", "SQUARE ORIGINAL OF OR EQUAL TO");
+-   ("/xe2/x8a/x93", "SQUARE CAP");
+-   ("/xe2/x8a/x94", "SQUARE CUP");
+-   ("/xe2/x8a/x95", "CIRCLED PLUS");
+-   ("/xe2/x8a/x96", "CIRCLED MINUS");
+-   ("/xe2/x8a/x97", "CIRCLED TIMES");
+-   ("/xe2/x8a/x98", "CIRCLED DIVISION SLASH");
+-   ("/xe2/x8a/x99", "CIRCLED DOT OPERATOR");
+-   ("/xe2/x8a/x9a", "CIRCLED RING OPERATOR");
+-   ("/xe2/x8a/x9b", "CIRCLED ASTERISK OPERATOR");
+-   ("/xe2/x8a/x9c", "CIRCLED EQUALS");
+-   ("/xe2/x8a/x9d", "CIRCLED DASH");
+-   ("/xe2/x8a/x9e", "SQUARED PLUS");
+-   ("/xe2/x8a/x9f", "SQUARED MINUS");
+-   ("/xe2/x8a/xa0", "SQUARED TIMES");
+-   ("/xe2/x8a/xa1", "SQUARED DOT OPERATOR");
+-   ("/xe2/x8a/xa2", "RIGHT TACK");
+-   ("/xe2/x8a/xa3", "LEFT TACK");
+-   ("/xe2/x8a/xa4", "DOWN TACK");
+-   ("/xe2/x8a/xa5", "UP TACK");
+-   ("/xe2/x8a/xa6", "ASSERTION");
+-   ("/xe2/x8a/xa7", "MODELS");
+-   ("/xe2/x8a/xa8", "TRUE");
+-   ("/xe2/x8a/xa9", "FORCES");
+-   ("/xe2/x8a/xaa", "TRIPLE VERTICAL BAR RIGHT TURNSTILE");
+-   ("/xe2/x8a/xab", "DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE");
+-   ("/xe2/x8a/xac", "DOES NOT PROVE");
+-   ("/xe2/x8a/xad", "NOT TRUE");
+-   ("/xe2/x8a/xae", "DOES NOT FORCE");
+-   ("/xe2/x8a/xaf", "NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE");
+-   ("/xe2/x8a/xb0", "PRECEDES UNDER RELATION");
+-   ("/xe2/x8a/xb1", "SUCCEEDS UNDER RELATION");
+-   ("/xe2/x8a/xb2", "NORMAL SUBGROUP OF");
+-   ("/xe2/x8a/xb3", "CONTAINS AS NORMAL SUBGROUP");
+-   ("/xe2/x8a/xb4", "NORMAL SUBGROUP OF OR EQUAL TO");
+-   ("/xe2/x8a/xb5", "CONTAINS AS NORMAL SUBGROUP OR EQUAL TO");
+-   ("/xe2/x8a/xb6", "ORIGINAL OF");
+-   ("/xe2/x8a/xb7", "IMAGE OF");
+-   ("/xe2/x8a/xb8", "MULTIMAP");
+-   ("/xe2/x8a/xb9", "HERMITIAN CONJUGATE MATRIX");
+-   ("/xe2/x8a/xba", "INTERCALATE");
+-   ("/xe2/x8a/xbb", "XOR");
+-   ("/xe2/x8a/xbc", "NAND");
+-   ("/xe2/x8a/xbd", "NOR");
+-   ("/xe2/x8a/xbe", "RIGHT ANGLE WITH ARC");
+-   ("/xe2/x8a/xbf", "RIGHT TRIANGLE");
+-   ("/xe2/x8b/x80", "N-ARY LOGICAL AND");
+-   ("/xe2/x8b/x81", "N-ARY LOGICAL OR");
+-   ("/xe2/x8b/x82", "N-ARY INTERSECTION");
+-   ("/xe2/x8b/x83", "N-ARY UNION");
+-   ("/xe2/x8b/x84", "DIAMOND OPERATOR");
+-   ("/xe2/x8b/x85", "DOT OPERATOR");
+-   ("/xe2/x8b/x86", "STAR OPERATOR");
+-   ("/xe2/x8b/x87", "DIVISION TIMES");
+-   ("/xe2/x8b/x88", "BOWTIE");
+-   ("/xe2/x8b/x89", "LEFT NORMAL FACTOR SEMIDIRECT PRODUCT");
+-   ("/xe2/x8b/x8a", "RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT");
+-   ("/xe2/x8b/x8b", "LEFT SEMIDIRECT PRODUCT");
+-   ("/xe2/x8b/x8c", "RIGHT SEMIDIRECT PRODUCT");
+-   ("/xe2/x8b/x8d", "REVERSED TILDE EQUALS");
+-   ("/xe2/x8b/x8e", "CURLY LOGICAL OR");
+-   ("/xe2/x8b/x8f", "CURLY LOGICAL AND");
+-   ("/xe2/x8b/x90", "DOUBLE SUBSET");
+-   ("/xe2/x8b/x91", "DOUBLE SUPERSET");
+-   ("/xe2/x8b/x92", "DOUBLE INTERSECTION");
+-   ("/xe2/x8b/x93", "DOUBLE UNION");
+-   ("/xe2/x8b/x94", "PITCHFORK");
+-   ("/xe2/x8b/x95", "EQUAL AND PARALLEL TO");
+-   ("/xe2/x8b/x96", "LESS-THAN WITH DOT");
+-   ("/xe2/x8b/x97", "GREATER-THAN WITH DOT");
+-   ("/xe2/x8b/x98", "VERY MUCH LESS-THAN");
+-   ("/xe2/x8b/x99", "VERY MUCH GREATER-THAN");
+-   ("/xe2/x8b/x9a", "LESS-THAN EQUAL TO OR GREATER-THAN");
+-   ("/xe2/x8b/x9b", "GREATER-THAN EQUAL TO OR LESS-THAN");
+-   ("/xe2/x8b/x9c", "EQUAL TO OR LESS-THAN");
+-   ("/xe2/x8b/x9d", "EQUAL TO OR GREATER-THAN");
+-   ("/xe2/x8b/x9e", "EQUAL TO OR PRECEDES");
+-   ("/xe2/x8b/x9f", "EQUAL TO OR SUCCEEDS");
+-   ("/xe2/x8b/xa0", "DOES NOT PRECEDE OR EQUAL");
+-   ("/xe2/x8b/xa1", "DOES NOT SUCCEED OR EQUAL");
+-   ("/xe2/x8b/xa2", "NOT SQUARE IMAGE OF OR EQUAL TO");
+-   ("/xe2/x8b/xa3", "NOT SQUARE ORIGINAL OF OR EQUAL TO");
+-   ("/xe2/x8b/xa4", "SQUARE IMAGE OF OR NOT EQUAL TO");
+-   ("/xe2/x8b/xa5", "SQUARE ORIGINAL OF OR NOT EQUAL TO");
+-   ("/xe2/x8b/xa6", "LESS-THAN BUT NOT EQUIVALENT TO");
+-   ("/xe2/x8b/xa7", "GREATER-THAN BUT NOT EQUIVALENT TO");
+-   ("/xe2/x8b/xa8", "PRECEDES BUT NOT EQUIVALENT TO");
+-   ("/xe2/x8b/xa9", "SUCCEEDS BUT NOT EQUIVALENT TO");
+-   ("/xe2/x8b/xaa", "NOT NORMAL SUBGROUP OF");
+-   ("/xe2/x8b/xab", "DOES NOT CONTAIN AS NORMAL SUBGROUP");
+-   ("/xe2/x8b/xac", "NOT NORMAL SUBGROUP OF OR EQUAL TO");
+-   ("/xe2/x8b/xad", "DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL");
+-   ("/xe2/x8b/xae", "VERTICAL ELLIPSIS");
+-   ("/xe2/x8b/xaf", "MIDLINE HORIZONTAL ELLIPSIS");
+-   ("/xe2/x8b/xb0", "UP RIGHT DIAGONAL ELLIPSIS");
+-   ("/xe2/x8b/xb1", "DOWN RIGHT DIAGONAL ELLIPSIS");
+-   ("/xe2/x8b/xb2", "ELEMENT OF WITH LONG HORIZONTAL STROKE");
+-   ("/xe2/x8b/xb3", "ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE");
+    ("/xe2/x8b/xb4", "SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE");
+-   ("/xe2/x8b/xb5", "ELEMENT OF WITH DOT ABOVE");
+-   ("/xe2/x8b/xb6", "ELEMENT OF WITH OVERBAR");
+    ("/xe2/x8b/xb7", "SMALL ELEMENT OF WITH OVERBAR");
+-   ("/xe2/x8b/xb8", "ELEMENT OF WITH UNDERBAR");
+-   ("/xe2/x8b/xb9", "ELEMENT OF WITH TWO HORIZONTAL STROKES");
+-   ("/xe2/x8b/xba", "CONTAINS WITH LONG HORIZONTAL STROKE");
+-   ("/xe2/x8b/xbb", "CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE");
+    ("/xe2/x8b/xbc", "SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE");
+-   ("/xe2/x8b/xbd", "CONTAINS WITH OVERBAR");
+    ("/xe2/x8b/xbe", "SMALL CONTAINS WITH OVERBAR");
+-   ("/xe2/x8b/xbf", "Z NOTATION BAG MEMBERSHIP");
+-   ("/xe2/x8c/x80", "DIAMETER SIGN");
+-   ("/xe2/x8c/x81", "ELECTRIC ARROW");
+-   ("/xe2/x8c/x82", "HOUSE");
+-   ("/xe2/x8c/x83", "UP ARROWHEAD");
+-   ("/xe2/x8c/x84", "DOWN ARROWHEAD");
+-   ("/xe2/x8c/x85", "PROJECTIVE");
+-   ("/xe2/x8c/x86", "PERSPECTIVE");
+-   ("/xe2/x8c/x87", "WAVY LINE");
+-   ("/xe2/x8c/x88", "LEFT CEILING");
+-   ("/xe2/x8c/x89", "RIGHT CEILING");
+-   ("/xe2/x8c/x8a", "LEFT FLOOR");
+-   ("/xe2/x8c/x8b", "RIGHT FLOOR");
+-   ("/xe2/x8c/x8c", "BOTTOM RIGHT CROP");
+-   ("/xe2/x8c/x8d", "BOTTOM LEFT CROP");
+-   ("/xe2/x8c/x8e", "TOP RIGHT CROP");
+-   ("/xe2/x8c/x8f", "TOP LEFT CROP");
+-   ("/xe2/x8c/x90", "REVERSED NOT SIGN");
+-   ("/xe2/x8c/x91", "SQUARE LOZENGE");
+-   ("/xe2/x8c/x92", "ARC");
+-   ("/xe2/x8c/x93", "SEGMENT");
+-   ("/xe2/x8c/x94", "SECTOR");
+-   ("/xe2/x8c/x95", "TELEPHONE RECORDER");
+-   ("/xe2/x8c/x96", "POSITION INDICATOR");
+-   ("/xe2/x8c/x97", "VIEWDATA SQUARE");
+-   ("/xe2/x8c/x98", "PLACE OF INTEREST SIGN");
+-   ("/xe2/x8c/x99", "TURNED NOT SIGN");
+-   ("/xe2/x8c/x9a", "WATCH");
+-   ("/xe2/x8c/x9b", "HOURGLASS");
+-   ("/xe2/x8c/x9c", "TOP LEFT CORNER");
+-   ("/xe2/x8c/x9d", "TOP RIGHT CORNER");
+-   ("/xe2/x8c/x9e", "BOTTOM LEFT CORNER");
+-   ("/xe2/x8c/x9f", "BOTTOM RIGHT CORNER");
+-   ("/xe2/x8c/xa0", "TOP HALF INTEGRAL");
+-   ("/xe2/x8c/xa1", "BOTTOM HALF INTEGRAL");
+-   ("/xe2/x8c/xa2", "FROWN");
+-   ("/xe2/x8c/xa3", "SMILE");
+-   ("/xe2/x8c/xa4", "UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS");
+-   ("/xe2/x8c/xa5", "OPTION KEY");
+-   ("/xe2/x8c/xa6", "ERASE TO THE RIGHT");
+-   ("/xe2/x8c/xa7", "X IN A RECTANGLE BOX");
+-   ("/xe2/x8c/xa8", "KEYBOARD");
+-   ("/xe2/x8c/xa9", "LEFT-POINTING ANGLE BRACKET");
+-   ("/xe2/x8c/xaa", "RIGHT-POINTING ANGLE BRACKET");
+-   ("/xe2/x8c/xab", "ERASE TO THE LEFT");
+-   ("/xe2/x8c/xac", "BENZENE RING");
+-   ("/xe2/x8c/xad", "CYLINDRICITY");
+-   ("/xe2/x8c/xae", "ALL AROUND-PROFILE");
+-   ("/xe2/x8c/xaf", "SYMMETRY");
+-   ("/xe2/x8c/xb0", "TOTAL RUNOUT");
+-   ("/xe2/x8c/xb1", "DIMENSION ORIGIN");
+-   ("/xe2/x8c/xb2", "CONICAL TAPER");
+-   ("/xe2/x8c/xb3", "SLOPE");
+-   ("/xe2/x8c/xb4", "COUNTERBORE");
+-   ("/xe2/x8c/xb5", "COUNTERSINK");
+-   ("/xe2/x8c/xb6", "APL FUNCTIONAL SYMBOL I-BEAM");
+-   ("/xe2/x8c/xb7", "APL FUNCTIONAL SYMBOL SQUISH QUAD");
+-   ("/xe2/x8c/xb8", "APL FUNCTIONAL SYMBOL QUAD EQUAL");
+-   ("/xe2/x8c/xb9", "APL FUNCTIONAL SYMBOL QUAD DIVIDE");
+-   ("/xe2/x8c/xba", "APL FUNCTIONAL SYMBOL QUAD DIAMOND");
+-   ("/xe2/x8c/xbb", "APL FUNCTIONAL SYMBOL QUAD JOT");
+-   ("/xe2/x8c/xbc", "APL FUNCTIONAL SYMBOL QUAD CIRCLE");
+-   ("/xe2/x8c/xbd", "APL FUNCTIONAL SYMBOL CIRCLE STILE");
+-   ("/xe2/x8c/xbe", "APL FUNCTIONAL SYMBOL CIRCLE JOT");
+-   ("/xe2/x8c/xbf", "APL FUNCTIONAL SYMBOL SLASH BAR");
+-   ("/xe2/x8d/x80", "APL FUNCTIONAL SYMBOL BACKSLASH BAR");
+-   ("/xe2/x8d/x81", "APL FUNCTIONAL SYMBOL QUAD SLASH");
+-   ("/xe2/x8d/x82", "APL FUNCTIONAL SYMBOL QUAD BACKSLASH");
+-   ("/xe2/x8d/x83", "APL FUNCTIONAL SYMBOL QUAD LESS-THAN");
+-   ("/xe2/x8d/x84", "APL FUNCTIONAL SYMBOL QUAD GREATER-THAN");
+-   ("/xe2/x8d/x85", "APL FUNCTIONAL SYMBOL LEFTWARDS VANE");
+-   ("/xe2/x8d/x86", "APL FUNCTIONAL SYMBOL RIGHTWARDS VANE");
+-   ("/xe2/x8d/x87", "APL FUNCTIONAL SYMBOL QUAD LEFTWARDS ARROW");
+-   ("/xe2/x8d/x88", "APL FUNCTIONAL SYMBOL QUAD RIGHTWARDS ARROW");
+-   ("/xe2/x8d/x89", "APL FUNCTIONAL SYMBOL CIRCLE BACKSLASH");
+-   ("/xe2/x8d/x8a", "APL FUNCTIONAL SYMBOL DOWN TACK UNDERBAR");
+-   ("/xe2/x8d/x8b", "APL FUNCTIONAL SYMBOL DELTA STILE");
+-   ("/xe2/x8d/x8c", "APL FUNCTIONAL SYMBOL QUAD DOWN CARET");
+-   ("/xe2/x8d/x8d", "APL FUNCTIONAL SYMBOL QUAD DELTA");
+-   ("/xe2/x8d/x8e", "APL FUNCTIONAL SYMBOL DOWN TACK JOT");
+-   ("/xe2/x8d/x8f", "APL FUNCTIONAL SYMBOL UPWARDS VANE");
+-   ("/xe2/x8d/x90", "APL FUNCTIONAL SYMBOL QUAD UPWARDS ARROW");
+-   ("/xe2/x8d/x91", "APL FUNCTIONAL SYMBOL UP TACK OVERBAR");
+-   ("/xe2/x8d/x92", "APL FUNCTIONAL SYMBOL DEL STILE");
+-   ("/xe2/x8d/x93", "APL FUNCTIONAL SYMBOL QUAD UP CARET");
+-   ("/xe2/x8d/x94", "APL FUNCTIONAL SYMBOL QUAD DEL");
+-   ("/xe2/x8d/x95", "APL FUNCTIONAL SYMBOL UP TACK JOT");
+-   ("/xe2/x8d/x96", "APL FUNCTIONAL SYMBOL DOWNWARDS VANE");
+-   ("/xe2/x8d/x97", "APL FUNCTIONAL SYMBOL QUAD DOWNWARDS ARROW");
+-   ("/xe2/x8d/x98", "APL FUNCTIONAL SYMBOL QUOTE UNDERBAR");
+-   ("/xe2/x8d/x99", "APL FUNCTIONAL SYMBOL DELTA UNDERBAR");
+-   ("/xe2/x8d/x9a", "APL FUNCTIONAL SYMBOL DIAMOND UNDERBAR");
+-   ("/xe2/x8d/x9b", "APL FUNCTIONAL SYMBOL JOT UNDERBAR");
+-   ("/xe2/x8d/x9c", "APL FUNCTIONAL SYMBOL CIRCLE UNDERBAR");
+-   ("/xe2/x8d/x9d", "APL FUNCTIONAL SYMBOL UP SHOE JOT");
+-   ("/xe2/x8d/x9e", "APL FUNCTIONAL SYMBOL QUOTE QUAD");
+-   ("/xe2/x8d/x9f", "APL FUNCTIONAL SYMBOL CIRCLE STAR");
+-   ("/xe2/x8d/xa0", "APL FUNCTIONAL SYMBOL QUAD COLON");
+-   ("/xe2/x8d/xa1", "APL FUNCTIONAL SYMBOL UP TACK DIAERESIS");
+-   ("/xe2/x8d/xa2", "APL FUNCTIONAL SYMBOL DEL DIAERESIS");
+-   ("/xe2/x8d/xa3", "APL FUNCTIONAL SYMBOL STAR DIAERESIS");
+-   ("/xe2/x8d/xa4", "APL FUNCTIONAL SYMBOL JOT DIAERESIS");
+-   ("/xe2/x8d/xa5", "APL FUNCTIONAL SYMBOL CIRCLE DIAERESIS");
+-   ("/xe2/x8d/xa6", "APL FUNCTIONAL SYMBOL DOWN SHOE STILE");
+-   ("/xe2/x8d/xa7", "APL FUNCTIONAL SYMBOL LEFT SHOE STILE");
+-   ("/xe2/x8d/xa8", "APL FUNCTIONAL SYMBOL TILDE DIAERESIS");
+-   ("/xe2/x8d/xa9", "APL FUNCTIONAL SYMBOL GREATER-THAN DIAERESIS");
+-   ("/xe2/x8d/xaa", "APL FUNCTIONAL SYMBOL COMMA BAR");
+-   ("/xe2/x8d/xab", "APL FUNCTIONAL SYMBOL DEL TILDE");
+-   ("/xe2/x8d/xac", "APL FUNCTIONAL SYMBOL ZILDE");
+-   ("/xe2/x8d/xad", "APL FUNCTIONAL SYMBOL STILE TILDE");
+-   ("/xe2/x8d/xae", "APL FUNCTIONAL SYMBOL SEMICOLON UNDERBAR");
+-   ("/xe2/x8d/xaf", "APL FUNCTIONAL SYMBOL QUAD NOT EQUAL");
+-   ("/xe2/x8d/xb0", "APL FUNCTIONAL SYMBOL QUAD QUESTION");
+-   ("/xe2/x8d/xb1", "APL FUNCTIONAL SYMBOL DOWN CARET TILDE");
+-   ("/xe2/x8d/xb2", "APL FUNCTIONAL SYMBOL UP CARET TILDE");
+-   ("/xe2/x8d/xb3", "APL FUNCTIONAL SYMBOL IOTA");
+-   ("/xe2/x8d/xb4", "APL FUNCTIONAL SYMBOL RHO");
+-   ("/xe2/x8d/xb5", "APL FUNCTIONAL SYMBOL OMEGA");
+-   ("/xe2/x8d/xb6", "APL FUNCTIONAL SYMBOL ALPHA UNDERBAR");
+-   ("/xe2/x8d/xb7", "APL FUNCTIONAL SYMBOL EPSILON UNDERBAR");
+-   ("/xe2/x8d/xb8", "APL FUNCTIONAL SYMBOL IOTA UNDERBAR");
+-   ("/xe2/x8d/xb9", "APL FUNCTIONAL SYMBOL OMEGA UNDERBAR");
+-   ("/xe2/x8d/xba", "APL FUNCTIONAL SYMBOL ALPHA");
+-   ("/xe2/x8d/xbb", "NOT CHECK MARK");
+-   ("/xe2/x8d/xbc", "RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW");
+-   ("/xe2/x8d/xbd", "SHOULDERED OPEN BOX");
+-   ("/xe2/x8d/xbe", "BELL SYMBOL");
+-   ("/xe2/x8d/xbf", "VERTICAL LINE WITH MIDDLE DOT");
+-   ("/xe2/x8e/x80", "INSERTION SYMBOL");
+-   ("/xe2/x8e/x81", "CONTINUOUS UNDERLINE SYMBOL");
+-   ("/xe2/x8e/x82", "DISCONTINUOUS UNDERLINE SYMBOL");
+-   ("/xe2/x8e/x83", "EMPHASIS SYMBOL");
+-   ("/xe2/x8e/x84", "COMPOSITION SYMBOL");
+-   ("/xe2/x8e/x85", "WHITE SQUARE WITH CENTRE VERTICAL LINE");
+-   ("/xe2/x8e/x86", "ENTER SYMBOL");
+-   ("/xe2/x8e/x87", "ALTERNATIVE KEY SYMBOL");
+-   ("/xe2/x8e/x88", "HELM SYMBOL");
+-   ("/xe2/x8e/x89", "CIRCLED HORIZONTAL BAR WITH NOTCH");
+-   ("/xe2/x8e/x8a", "CIRCLED TRIANGLE DOWN");
+-   ("/xe2/x8e/x8b", "BROKEN CIRCLE WITH NORTHWEST ARROW");
+-   ("/xe2/x8e/x8c", "UNDO SYMBOL");
+-   ("/xe2/x8e/x8d", "MONOSTABLE SYMBOL");
+-   ("/xe2/x8e/x8e", "HYSTERESIS SYMBOL");
+-   ("/xe2/x8e/x8f", "OPEN-CIRCUIT-OUTPUT H-TYPE SYMBOL");
+-   ("/xe2/x8e/x90", "OPEN-CIRCUIT-OUTPUT L-TYPE SYMBOL");
+-   ("/xe2/x8e/x91", "PASSIVE-PULL-DOWN-OUTPUT SYMBOL");
+-   ("/xe2/x8e/x92", "PASSIVE-PULL-UP-OUTPUT SYMBOL");
+-   ("/xe2/x8e/x93", "DIRECT CURRENT SYMBOL FORM TWO");
+-   ("/xe2/x8e/x94", "SOFTWARE-FUNCTION SYMBOL");
+-   ("/xe2/x8e/x95", "APL FUNCTIONAL SYMBOL QUAD");
+-   ("/xe2/x8e/x96", "DECIMAL SEPARATOR KEY SYMBOL");
+-   ("/xe2/x8e/x97", "PREVIOUS PAGE");
+-   ("/xe2/x8e/x98", "NEXT PAGE");
+-   ("/xe2/x8e/x99", "PRINT SCREEN SYMBOL");
+-   ("/xe2/x8e/x9a", "CLEAR SCREEN SYMBOL");
+-   ("/xe2/x8e/x9b", "LEFT PARENTHESIS UPPER HOOK");
+-   ("/xe2/x8e/x9c", "LEFT PARENTHESIS EXTENSION");
+-   ("/xe2/x8e/x9d", "LEFT PARENTHESIS LOWER HOOK");
+-   ("/xe2/x8e/x9e", "RIGHT PARENTHESIS UPPER HOOK");
+-   ("/xe2/x8e/x9f", "RIGHT PARENTHESIS EXTENSION");
+-   ("/xe2/x8e/xa0", "RIGHT PARENTHESIS LOWER HOOK");
+-   ("/xe2/x8e/xa1", "LEFT SQUARE BRACKET UPPER CORNER");
+-   ("/xe2/x8e/xa2", "LEFT SQUARE BRACKET EXTENSION");
+-   ("/xe2/x8e/xa3", "LEFT SQUARE BRACKET LOWER CORNER");
+-   ("/xe2/x8e/xa4", "RIGHT SQUARE BRACKET UPPER CORNER");
+-   ("/xe2/x8e/xa5", "RIGHT SQUARE BRACKET EXTENSION");
+-   ("/xe2/x8e/xa6", "RIGHT SQUARE BRACKET LOWER CORNER");
+-   ("/xe2/x8e/xa7", "LEFT CURLY BRACKET UPPER HOOK");
+-   ("/xe2/x8e/xa8", "LEFT CURLY BRACKET MIDDLE PIECE");
+-   ("/xe2/x8e/xa9", "LEFT CURLY BRACKET LOWER HOOK");
+-   ("/xe2/x8e/xaa", "CURLY BRACKET EXTENSION");
+-   ("/xe2/x8e/xab", "RIGHT CURLY BRACKET UPPER HOOK");
+-   ("/xe2/x8e/xac", "RIGHT CURLY BRACKET MIDDLE PIECE");
+-   ("/xe2/x8e/xad", "RIGHT CURLY BRACKET LOWER HOOK");
+-   ("/xe2/x8e/xae", "INTEGRAL EXTENSION");
+-   ("/xe2/x8e/xaf", "HORIZONTAL LINE EXTENSION");
+-   ("/xe2/x8e/xb0", "UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION");
+-   ("/xe2/x8e/xb1", "UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION");
+-   ("/xe2/x8e/xb2", "SUMMATION TOP");
+-   ("/xe2/x8e/xb3", "SUMMATION BOTTOM");
+-   ("/xe2/x8e/xb4", "TOP SQUARE BRACKET");
+-   ("/xe2/x8e/xb5", "BOTTOM SQUARE BRACKET");
+-   ("/xe2/x8e/xb6", "BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET");
+-   ("/xe2/x8e/xb7", "RADICAL SYMBOL BOTTOM");
+-   ("/xe2/x8e/xb8", "LEFT VERTICAL BOX LINE");
+-   ("/xe2/x8e/xb9", "RIGHT VERTICAL BOX LINE");
+-   ("/xe2/x8e/xba", "HORIZONTAL SCAN LINE-1");
+-   ("/xe2/x8e/xbb", "HORIZONTAL SCAN LINE-3");
+-   ("/xe2/x8e/xbc", "HORIZONTAL SCAN LINE-7");
+-   ("/xe2/x8e/xbd", "HORIZONTAL SCAN LINE-9");
+-   ("/xe2/x8e/xbe", "DENTISTRY SYMBOL LIGHT VERTICAL AND TOP RIGHT");
+-   ("/xe2/x8e/xbf", "DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM RIGHT");
+-   ("/xe2/x8f/x80", "DENTISTRY SYMBOL LIGHT VERTICAL WITH CIRCLE");
+-   ("/xe2/x8f/x81", "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH CIRCLE");
+-   ("/xe2/x8f/x82", "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH CIRCLE");
+-   ("/xe2/x8f/x83", "DENTISTRY SYMBOL LIGHT VERTICAL WITH TRIANGLE");
+-   ("/xe2/x8f/x84", "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH TRIANGLE");
+-   ("/xe2/x8f/x85", "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH TRIANGLE");
+-   ("/xe2/x8f/x86", "DENTISTRY SYMBOL LIGHT VERTICAL AND WAVE");
+-   ("/xe2/x8f/x87", "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH WAVE");
+-   ("/xe2/x8f/x88", "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH WAVE");
+-   ("/xe2/x8f/x89", "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL");
+-   ("/xe2/x8f/x8a", "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL");
+-   ("/xe2/x8f/x8b", "DENTISTRY SYMBOL LIGHT VERTICAL AND TOP LEFT");
+-   ("/xe2/x8f/x8c", "DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM LEFT");
+-   ("/xe2/x8f/x8d", "SQUARE FOOT");
+-   ("/xe2/x8f/x8e", "RETURN SYMBOL");
+-   ("/xe2/x8f/x8f", "EJECT SYMBOL");
+-   ("/xe2/x8f/x90", "VERTICAL LINE EXTENSION");
+-   ("/xe2/x8f/x91", "METRICAL BREVE");
+-   ("/xe2/x8f/x92", "METRICAL LONG OVER SHORT");
+-   ("/xe2/x8f/x93", "METRICAL SHORT OVER LONG");
+-   ("/xe2/x8f/x94", "METRICAL LONG OVER TWO SHORTS");
+-   ("/xe2/x8f/x95", "METRICAL TWO SHORTS OVER LONG");
+-   ("/xe2/x8f/x96", "METRICAL TWO SHORTS JOINED");
+-   ("/xe2/x8f/x97", "METRICAL TRISEME");
+-   ("/xe2/x8f/x98", "METRICAL TETRASEME");
+-   ("/xe2/x8f/x99", "METRICAL PENTASEME");
+-   ("/xe2/x8f/x9a", "EARTH GROUND");
+-   ("/xe2/x8f/x9b", "FUSE");
+-   ("/xe2/x8f/x9c", "TOP PARENTHESIS");
+-   ("/xe2/x8f/x9d", "BOTTOM PARENTHESIS");
+-   ("/xe2/x8f/x9e", "TOP CURLY BRACKET");
+-   ("/xe2/x8f/x9f", "BOTTOM CURLY BRACKET");
+-   ("/xe2/x8f/xa0", "TOP TORTOISE SHELL BRACKET");
+-   ("/xe2/x8f/xa1", "BOTTOM TORTOISE SHELL BRACKET");
+-   ("/xe2/x8f/xa2", "WHITE TRAPEZIUM");
+-   ("/xe2/x8f/xa3", "BENZENE RING WITH CIRCLE");
+-   ("/xe2/x8f/xa4", "STRAIGHTNESS");
+-   ("/xe2/x8f/xa5", "FLATNESS");
+-   ("/xe2/x8f/xa6", "AC CURRENT");
+-   ("/xe2/x8f/xa7", "ELECTRICAL INTERSECTION");
+-   ("/xe2/x90/x80", "SYMBOL FOR NULL");
+-   ("/xe2/x90/x81", "SYMBOL FOR START OF HEADING");
+-   ("/xe2/x90/x82", "SYMBOL FOR START OF TEXT");
+-   ("/xe2/x90/x83", "SYMBOL FOR END OF TEXT");
+-   ("/xe2/x90/x84", "SYMBOL FOR END OF TRANSMISSION");
+-   ("/xe2/x90/x85", "SYMBOL FOR ENQUIRY");
+-   ("/xe2/x90/x86", "SYMBOL FOR ACKNOWLEDGE");
+-   ("/xe2/x90/x87", "SYMBOL FOR BELL");
+-   ("/xe2/x90/x88", "SYMBOL FOR BACKSPACE");
+-   ("/xe2/x90/x89", "SYMBOL FOR HORIZONTAL TABULATION");
+-   ("/xe2/x90/x8a", "SYMBOL FOR LINE FEED");
+-   ("/xe2/x90/x8b", "SYMBOL FOR VERTICAL TABULATION");
+-   ("/xe2/x90/x8c", "SYMBOL FOR FORM FEED");
+-   ("/xe2/x90/x8d", "SYMBOL FOR CARRIAGE RETURN");
+-   ("/xe2/x90/x8e", "SYMBOL FOR SHIFT OUT");
+-   ("/xe2/x90/x8f", "SYMBOL FOR SHIFT IN");
+-   ("/xe2/x90/x90", "SYMBOL FOR DATA LINK ESCAPE");
+-   ("/xe2/x90/x91", "SYMBOL FOR DEVICE CONTROL ONE");
+-   ("/xe2/x90/x92", "SYMBOL FOR DEVICE CONTROL TWO");
+-   ("/xe2/x90/x93", "SYMBOL FOR DEVICE CONTROL THREE");
+-   ("/xe2/x90/x94", "SYMBOL FOR DEVICE CONTROL FOUR");
+-   ("/xe2/x90/x95", "SYMBOL FOR NEGATIVE ACKNOWLEDGE");
+-   ("/xe2/x90/x96", "SYMBOL FOR SYNCHRONOUS IDLE");
+-   ("/xe2/x90/x97", "SYMBOL FOR END OF TRANSMISSION BLOCK");
+-   ("/xe2/x90/x98", "SYMBOL FOR CANCEL");
+-   ("/xe2/x90/x99", "SYMBOL FOR END OF MEDIUM");
+-   ("/xe2/x90/x9a", "SYMBOL FOR SUBSTITUTE");
+-   ("/xe2/x90/x9b", "SYMBOL FOR ESCAPE");
+-   ("/xe2/x90/x9c", "SYMBOL FOR FILE SEPARATOR");
+-   ("/xe2/x90/x9d", "SYMBOL FOR GROUP SEPARATOR");
+-   ("/xe2/x90/x9e", "SYMBOL FOR RECORD SEPARATOR");
+-   ("/xe2/x90/x9f", "SYMBOL FOR UNIT SEPARATOR");
+-   ("/xe2/x90/xa0", "SYMBOL FOR SPACE");
+-   ("/xe2/x90/xa1", "SYMBOL FOR DELETE");
+-   ("/xe2/x90/xa2", "BLANK SYMBOL");
+-   ("/xe2/x90/xa3", "OPEN BOX");
+-   ("/xe2/x90/xa4", "SYMBOL FOR NEWLINE");
+-   ("/xe2/x90/xa5", "SYMBOL FOR DELETE FORM TWO");
+-   ("/xe2/x90/xa6", "SYMBOL FOR SUBSTITUTE FORM TWO");
+-   ("/xe2/x91/x80", "OCR HOOK");
+-   ("/xe2/x91/x81", "OCR CHAIR");
+-   ("/xe2/x91/x82", "OCR FORK");
+-   ("/xe2/x91/x83", "OCR INVERTED FORK");
+-   ("/xe2/x91/x84", "OCR BELT BUCKLE");
+-   ("/xe2/x91/x85", "OCR BOW TIE");
+-   ("/xe2/x91/x86", "OCR BRANCH BANK IDENTIFICATION");
+-   ("/xe2/x91/x87", "OCR AMOUNT OF CHECK");
+-   ("/xe2/x91/x88", "OCR DASH");
+-   ("/xe2/x91/x89", "OCR CUSTOMER ACCOUNT NUMBER");
+-   ("/xe2/x91/x8a", "OCR DOUBLE BACKSLASH");
+-   ("/xe2/x91/xa0", "CIRCLED DIGIT ONE");
+-   ("/xe2/x91/xa1", "CIRCLED DIGIT TWO");
+-   ("/xe2/x91/xa2", "CIRCLED DIGIT THREE");
+-   ("/xe2/x91/xa3", "CIRCLED DIGIT FOUR");
+-   ("/xe2/x91/xa4", "CIRCLED DIGIT FIVE");
+-   ("/xe2/x91/xa5", "CIRCLED DIGIT SIX");
+-   ("/xe2/x91/xa6", "CIRCLED DIGIT SEVEN");
+-   ("/xe2/x91/xa7", "CIRCLED DIGIT EIGHT");
+-   ("/xe2/x91/xa8", "CIRCLED DIGIT NINE");
+-   ("/xe2/x91/xa9", "CIRCLED NUMBER TEN");
+-   ("/xe2/x91/xaa", "CIRCLED NUMBER ELEVEN");
+-   ("/xe2/x91/xab", "CIRCLED NUMBER TWELVE");
+-   ("/xe2/x91/xac", "CIRCLED NUMBER THIRTEEN");
+-   ("/xe2/x91/xad", "CIRCLED NUMBER FOURTEEN");
+-   ("/xe2/x91/xae", "CIRCLED NUMBER FIFTEEN");
+-   ("/xe2/x91/xaf", "CIRCLED NUMBER SIXTEEN");
+-   ("/xe2/x91/xb0", "CIRCLED NUMBER SEVENTEEN");
+-   ("/xe2/x91/xb1", "CIRCLED NUMBER EIGHTEEN");
+-   ("/xe2/x91/xb2", "CIRCLED NUMBER NINETEEN");
+-   ("/xe2/x91/xb3", "CIRCLED NUMBER TWENTY");
+-   ("/xe2/x91/xb4", "PARENTHESIZED DIGIT ONE");
+-   ("/xe2/x91/xb5", "PARENTHESIZED DIGIT TWO");
+-   ("/xe2/x91/xb6", "PARENTHESIZED DIGIT THREE");
+-   ("/xe2/x91/xb7", "PARENTHESIZED DIGIT FOUR");
+-   ("/xe2/x91/xb8", "PARENTHESIZED DIGIT FIVE");
+-   ("/xe2/x91/xb9", "PARENTHESIZED DIGIT SIX");
+-   ("/xe2/x91/xba", "PARENTHESIZED DIGIT SEVEN");
+-   ("/xe2/x91/xbb", "PARENTHESIZED DIGIT EIGHT");
+-   ("/xe2/x91/xbc", "PARENTHESIZED DIGIT NINE");
+-   ("/xe2/x91/xbd", "PARENTHESIZED NUMBER TEN");
+-   ("/xe2/x91/xbe", "PARENTHESIZED NUMBER ELEVEN");
+-   ("/xe2/x91/xbf", "PARENTHESIZED NUMBER TWELVE");
+-   ("/xe2/x92/x80", "PARENTHESIZED NUMBER THIRTEEN");
+-   ("/xe2/x92/x81", "PARENTHESIZED NUMBER FOURTEEN");
+-   ("/xe2/x92/x82", "PARENTHESIZED NUMBER FIFTEEN");
+-   ("/xe2/x92/x83", "PARENTHESIZED NUMBER SIXTEEN");
+-   ("/xe2/x92/x84", "PARENTHESIZED NUMBER SEVENTEEN");
+-   ("/xe2/x92/x85", "PARENTHESIZED NUMBER EIGHTEEN");
+-   ("/xe2/x92/x86", "PARENTHESIZED NUMBER NINETEEN");
+-   ("/xe2/x92/x87", "PARENTHESIZED NUMBER TWENTY");
+-   ("/xe2/x92/x88", "DIGIT ONE FULL STOP");
+-   ("/xe2/x92/x89", "DIGIT TWO FULL STOP");
+-   ("/xe2/x92/x8a", "DIGIT THREE FULL STOP");
+-   ("/xe2/x92/x8b", "DIGIT FOUR FULL STOP");
+-   ("/xe2/x92/x8c", "DIGIT FIVE FULL STOP");
+-   ("/xe2/x92/x8d", "DIGIT SIX FULL STOP");
+-   ("/xe2/x92/x8e", "DIGIT SEVEN FULL STOP");
+-   ("/xe2/x92/x8f", "DIGIT EIGHT FULL STOP");
+-   ("/xe2/x92/x90", "DIGIT NINE FULL STOP");
+-   ("/xe2/x92/x91", "NUMBER TEN FULL STOP");
+-   ("/xe2/x92/x92", "NUMBER ELEVEN FULL STOP");
+-   ("/xe2/x92/x93", "NUMBER TWELVE FULL STOP");
+-   ("/xe2/x92/x94", "NUMBER THIRTEEN FULL STOP");
+-   ("/xe2/x92/x95", "NUMBER FOURTEEN FULL STOP");
+-   ("/xe2/x92/x96", "NUMBER FIFTEEN FULL STOP");
+-   ("/xe2/x92/x97", "NUMBER SIXTEEN FULL STOP");
+-   ("/xe2/x92/x98", "NUMBER SEVENTEEN FULL STOP");
+-   ("/xe2/x92/x99", "NUMBER EIGHTEEN FULL STOP");
+-   ("/xe2/x92/x9a", "NUMBER NINETEEN FULL STOP");
+-   ("/xe2/x92/x9b", "NUMBER TWENTY FULL STOP");
+    ("/xe2/x92/x9c", "PARENTHESIZED LATIN SMALL LETTER A");
+    ("/xe2/x92/x9d", "PARENTHESIZED LATIN SMALL LETTER B");
+    ("/xe2/x92/x9e", "PARENTHESIZED LATIN SMALL LETTER C");
+@@ -7617,1559 +1954,39 @@
+    ("/xe2/x93/xa7", "CIRCLED LATIN SMALL LETTER X");
+    ("/xe2/x93/xa8", "CIRCLED LATIN SMALL LETTER Y");
+    ("/xe2/x93/xa9", "CIRCLED LATIN SMALL LETTER Z");
+-   ("/xe2/x93/xaa", "CIRCLED DIGIT ZERO");
+-   ("/xe2/x93/xab", "NEGATIVE CIRCLED NUMBER ELEVEN");
+-   ("/xe2/x93/xac", "NEGATIVE CIRCLED NUMBER TWELVE");
+-   ("/xe2/x93/xad", "NEGATIVE CIRCLED NUMBER THIRTEEN");
+-   ("/xe2/x93/xae", "NEGATIVE CIRCLED NUMBER FOURTEEN");
+-   ("/xe2/x93/xaf", "NEGATIVE CIRCLED NUMBER FIFTEEN");
+-   ("/xe2/x93/xb0", "NEGATIVE CIRCLED NUMBER SIXTEEN");
+-   ("/xe2/x93/xb1", "NEGATIVE CIRCLED NUMBER SEVENTEEN");
+-   ("/xe2/x93/xb2", "NEGATIVE CIRCLED NUMBER EIGHTEEN");
+-   ("/xe2/x93/xb3", "NEGATIVE CIRCLED NUMBER NINETEEN");
+-   ("/xe2/x93/xb4", "NEGATIVE CIRCLED NUMBER TWENTY");
+-   ("/xe2/x93/xb5", "DOUBLE CIRCLED DIGIT ONE");
+-   ("/xe2/x93/xb6", "DOUBLE CIRCLED DIGIT TWO");
+-   ("/xe2/x93/xb7", "DOUBLE CIRCLED DIGIT THREE");
+-   ("/xe2/x93/xb8", "DOUBLE CIRCLED DIGIT FOUR");
+-   ("/xe2/x93/xb9", "DOUBLE CIRCLED DIGIT FIVE");
+-   ("/xe2/x93/xba", "DOUBLE CIRCLED DIGIT SIX");
+-   ("/xe2/x93/xbb", "DOUBLE CIRCLED DIGIT SEVEN");
+-   ("/xe2/x93/xbc", "DOUBLE CIRCLED DIGIT EIGHT");
+-   ("/xe2/x93/xbd", "DOUBLE CIRCLED DIGIT NINE");
+-   ("/xe2/x93/xbe", "DOUBLE CIRCLED NUMBER TEN");
+-   ("/xe2/x93/xbf", "NEGATIVE CIRCLED DIGIT ZERO");
+-   ("/xe2/x94/x80", "BOX DRAWINGS LIGHT HORIZONTAL");
+-   ("/xe2/x94/x81", "BOX DRAWINGS HEAVY HORIZONTAL");
+-   ("/xe2/x94/x82", "BOX DRAWINGS LIGHT VERTICAL");
+-   ("/xe2/x94/x83", "BOX DRAWINGS HEAVY VERTICAL");
+-   ("/xe2/x94/x84", "BOX DRAWINGS LIGHT TRIPLE DASH HORIZONTAL");
+-   ("/xe2/x94/x85", "BOX DRAWINGS HEAVY TRIPLE DASH HORIZONTAL");
+-   ("/xe2/x94/x86", "BOX DRAWINGS LIGHT TRIPLE DASH VERTICAL");
+-   ("/xe2/x94/x87", "BOX DRAWINGS HEAVY TRIPLE DASH VERTICAL");
+-   ("/xe2/x94/x88", "BOX DRAWINGS LIGHT QUADRUPLE DASH HORIZONTAL");
+-   ("/xe2/x94/x89", "BOX DRAWINGS HEAVY QUADRUPLE DASH HORIZONTAL");
+-   ("/xe2/x94/x8a", "BOX DRAWINGS LIGHT QUADRUPLE DASH VERTICAL");
+-   ("/xe2/x94/x8b", "BOX DRAWINGS HEAVY QUADRUPLE DASH VERTICAL");
+-   ("/xe2/x94/x8c", "BOX DRAWINGS LIGHT DOWN AND RIGHT");
+-   ("/xe2/x94/x8d", "BOX DRAWINGS DOWN LIGHT AND RIGHT HEAVY");
+-   ("/xe2/x94/x8e", "BOX DRAWINGS DOWN HEAVY AND RIGHT LIGHT");
+-   ("/xe2/x94/x8f", "BOX DRAWINGS HEAVY DOWN AND RIGHT");
+-   ("/xe2/x94/x90", "BOX DRAWINGS LIGHT DOWN AND LEFT");
+-   ("/xe2/x94/x91", "BOX DRAWINGS DOWN LIGHT AND LEFT HEAVY");
+-   ("/xe2/x94/x92", "BOX DRAWINGS DOWN HEAVY AND LEFT LIGHT");
+-   ("/xe2/x94/x93", "BOX DRAWINGS HEAVY DOWN AND LEFT");
+-   ("/xe2/x94/x94", "BOX DRAWINGS LIGHT UP AND RIGHT");
+-   ("/xe2/x94/x95", "BOX DRAWINGS UP LIGHT AND RIGHT HEAVY");
+-   ("/xe2/x94/x96", "BOX DRAWINGS UP HEAVY AND RIGHT LIGHT");
+-   ("/xe2/x94/x97", "BOX DRAWINGS HEAVY UP AND RIGHT");
+-   ("/xe2/x94/x98", "BOX DRAWINGS LIGHT UP AND LEFT");
+-   ("/xe2/x94/x99", "BOX DRAWINGS UP LIGHT AND LEFT HEAVY");
+-   ("/xe2/x94/x9a", "BOX DRAWINGS UP HEAVY AND LEFT LIGHT");
+-   ("/xe2/x94/x9b", "BOX DRAWINGS HEAVY UP AND LEFT");
+-   ("/xe2/x94/x9c", "BOX DRAWINGS LIGHT VERTICAL AND RIGHT");
+-   ("/xe2/x94/x9d", "BOX DRAWINGS VERTICAL LIGHT AND RIGHT HEAVY");
+-   ("/xe2/x94/x9e", "BOX DRAWINGS UP HEAVY AND RIGHT DOWN LIGHT");
+-   ("/xe2/x94/x9f", "BOX DRAWINGS DOWN HEAVY AND RIGHT UP LIGHT");
+-   ("/xe2/x94/xa0", "BOX DRAWINGS VERTICAL HEAVY AND RIGHT LIGHT");
+-   ("/xe2/x94/xa1", "BOX DRAWINGS DOWN LIGHT AND RIGHT UP HEAVY");
+-   ("/xe2/x94/xa2", "BOX DRAWINGS UP LIGHT AND RIGHT DOWN HEAVY");
+-   ("/xe2/x94/xa3", "BOX DRAWINGS HEAVY VERTICAL AND RIGHT");
+-   ("/xe2/x94/xa4", "BOX DRAWINGS LIGHT VERTICAL AND LEFT");
+-   ("/xe2/x94/xa5", "BOX DRAWINGS VERTICAL LIGHT AND LEFT HEAVY");
+-   ("/xe2/x94/xa6", "BOX DRAWINGS UP HEAVY AND LEFT DOWN LIGHT");
+-   ("/xe2/x94/xa7", "BOX DRAWINGS DOWN HEAVY AND LEFT UP LIGHT");
+-   ("/xe2/x94/xa8", "BOX DRAWINGS VERTICAL HEAVY AND LEFT LIGHT");
+-   ("/xe2/x94/xa9", "BOX DRAWINGS DOWN LIGHT AND LEFT UP HEAVY");
+-   ("/xe2/x94/xaa", "BOX DRAWINGS UP LIGHT AND LEFT DOWN HEAVY");
+-   ("/xe2/x94/xab", "BOX DRAWINGS HEAVY VERTICAL AND LEFT");
+-   ("/xe2/x94/xac", "BOX DRAWINGS LIGHT DOWN AND HORIZONTAL");
+-   ("/xe2/x94/xad", "BOX DRAWINGS LEFT HEAVY AND RIGHT DOWN LIGHT");
+-   ("/xe2/x94/xae", "BOX DRAWINGS RIGHT HEAVY AND LEFT DOWN LIGHT");
+-   ("/xe2/x94/xaf", "BOX DRAWINGS DOWN LIGHT AND HORIZONTAL HEAVY");
+-   ("/xe2/x94/xb0", "BOX DRAWINGS DOWN HEAVY AND HORIZONTAL LIGHT");
+-   ("/xe2/x94/xb1", "BOX DRAWINGS RIGHT LIGHT AND LEFT DOWN HEAVY");
+-   ("/xe2/x94/xb2", "BOX DRAWINGS LEFT LIGHT AND RIGHT DOWN HEAVY");
+-   ("/xe2/x94/xb3", "BOX DRAWINGS HEAVY DOWN AND HORIZONTAL");
+-   ("/xe2/x94/xb4", "BOX DRAWINGS LIGHT UP AND HORIZONTAL");
+-   ("/xe2/x94/xb5", "BOX DRAWINGS LEFT HEAVY AND RIGHT UP LIGHT");
+-   ("/xe2/x94/xb6", "BOX DRAWINGS RIGHT HEAVY AND LEFT UP LIGHT");
+-   ("/xe2/x94/xb7", "BOX DRAWINGS UP LIGHT AND HORIZONTAL HEAVY");
+-   ("/xe2/x94/xb8", "BOX DRAWINGS UP HEAVY AND HORIZONTAL LIGHT");
+-   ("/xe2/x94/xb9", "BOX DRAWINGS RIGHT LIGHT AND LEFT UP HEAVY");
+-   ("/xe2/x94/xba", "BOX DRAWINGS LEFT LIGHT AND RIGHT UP HEAVY");
+-   ("/xe2/x94/xbb", "BOX DRAWINGS HEAVY UP AND HORIZONTAL");
+-   ("/xe2/x94/xbc", "BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL");
+-   ("/xe2/x94/xbd", "BOX DRAWINGS LEFT HEAVY AND RIGHT VERTICAL LIGHT");
+-   ("/xe2/x94/xbe", "BOX DRAWINGS RIGHT HEAVY AND LEFT VERTICAL LIGHT");
+-   ("/xe2/x94/xbf", "BOX DRAWINGS VERTICAL LIGHT AND HORIZONTAL HEAVY");
+-   ("/xe2/x95/x80", "BOX DRAWINGS UP HEAVY AND DOWN HORIZONTAL LIGHT");
+-   ("/xe2/x95/x81", "BOX DRAWINGS DOWN HEAVY AND UP HORIZONTAL LIGHT");
+-   ("/xe2/x95/x82", "BOX DRAWINGS VERTICAL HEAVY AND HORIZONTAL LIGHT");
+-   ("/xe2/x95/x83", "BOX DRAWINGS LEFT UP HEAVY AND RIGHT DOWN LIGHT");
+-   ("/xe2/x95/x84", "BOX DRAWINGS RIGHT UP HEAVY AND LEFT DOWN LIGHT");
+-   ("/xe2/x95/x85", "BOX DRAWINGS LEFT DOWN HEAVY AND RIGHT UP LIGHT");
+-   ("/xe2/x95/x86", "BOX DRAWINGS RIGHT DOWN HEAVY AND LEFT UP LIGHT");
+-   ("/xe2/x95/x87", "BOX DRAWINGS DOWN LIGHT AND UP HORIZONTAL HEAVY");
+-   ("/xe2/x95/x88", "BOX DRAWINGS UP LIGHT AND DOWN HORIZONTAL HEAVY");
+-   ("/xe2/x95/x89", "BOX DRAWINGS RIGHT LIGHT AND LEFT VERTICAL HEAVY");
+-   ("/xe2/x95/x8a", "BOX DRAWINGS LEFT LIGHT AND RIGHT VERTICAL HEAVY");
+-   ("/xe2/x95/x8b", "BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL");
+-   ("/xe2/x95/x8c", "BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL");
+-   ("/xe2/x95/x8d", "BOX DRAWINGS HEAVY DOUBLE DASH HORIZONTAL");
+-   ("/xe2/x95/x8e", "BOX DRAWINGS LIGHT DOUBLE DASH VERTICAL");
+-   ("/xe2/x95/x8f", "BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL");
+-   ("/xe2/x95/x90", "BOX DRAWINGS DOUBLE HORIZONTAL");
+-   ("/xe2/x95/x91", "BOX DRAWINGS DOUBLE VERTICAL");
+-   ("/xe2/x95/x92", "BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE");
+-   ("/xe2/x95/x93", "BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE");
+-   ("/xe2/x95/x94", "BOX DRAWINGS DOUBLE DOWN AND RIGHT");
+-   ("/xe2/x95/x95", "BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE");
+-   ("/xe2/x95/x96", "BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE");
+-   ("/xe2/x95/x97", "BOX DRAWINGS DOUBLE DOWN AND LEFT");
+-   ("/xe2/x95/x98", "BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE");
+-   ("/xe2/x95/x99", "BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE");
+-   ("/xe2/x95/x9a", "BOX DRAWINGS DOUBLE UP AND RIGHT");
+-   ("/xe2/x95/x9b", "BOX DRAWINGS UP SINGLE AND LEFT DOUBLE");
+-   ("/xe2/x95/x9c", "BOX DRAWINGS UP DOUBLE AND LEFT SINGLE");
+-   ("/xe2/x95/x9d", "BOX DRAWINGS DOUBLE UP AND LEFT");
+-   ("/xe2/x95/x9e", "BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE");
+-   ("/xe2/x95/x9f", "BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE");
+-   ("/xe2/x95/xa0", "BOX DRAWINGS DOUBLE VERTICAL AND RIGHT");
+-   ("/xe2/x95/xa1", "BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE");
+-   ("/xe2/x95/xa2", "BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE");
+-   ("/xe2/x95/xa3", "BOX DRAWINGS DOUBLE VERTICAL AND LEFT");
+-   ("/xe2/x95/xa4", "BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE");
+-   ("/xe2/x95/xa5", "BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE");
+-   ("/xe2/x95/xa6", "BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL");
+-   ("/xe2/x95/xa7", "BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE");
+-   ("/xe2/x95/xa8", "BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE");
+-   ("/xe2/x95/xa9", "BOX DRAWINGS DOUBLE UP AND HORIZONTAL");
+-   ("/xe2/x95/xaa", "BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE");
+-   ("/xe2/x95/xab", "BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE");
+-   ("/xe2/x95/xac", "BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL");
+-   ("/xe2/x95/xad", "BOX DRAWINGS LIGHT ARC DOWN AND RIGHT");
+-   ("/xe2/x95/xae", "BOX DRAWINGS LIGHT ARC DOWN AND LEFT");
+-   ("/xe2/x95/xaf", "BOX DRAWINGS LIGHT ARC UP AND LEFT");
+-   ("/xe2/x95/xb0", "BOX DRAWINGS LIGHT ARC UP AND RIGHT");
+-   ("/xe2/x95/xb1", "BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT");
+-   ("/xe2/x95/xb2", "BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT");
+-   ("/xe2/x95/xb3", "BOX DRAWINGS LIGHT DIAGONAL CROSS");
+-   ("/xe2/x95/xb4", "BOX DRAWINGS LIGHT LEFT");
+-   ("/xe2/x95/xb5", "BOX DRAWINGS LIGHT UP");
+-   ("/xe2/x95/xb6", "BOX DRAWINGS LIGHT RIGHT");
+-   ("/xe2/x95/xb7", "BOX DRAWINGS LIGHT DOWN");
+-   ("/xe2/x95/xb8", "BOX DRAWINGS HEAVY LEFT");
+-   ("/xe2/x95/xb9", "BOX DRAWINGS HEAVY UP");
+-   ("/xe2/x95/xba", "BOX DRAWINGS HEAVY RIGHT");
+-   ("/xe2/x95/xbb", "BOX DRAWINGS HEAVY DOWN");
+-   ("/xe2/x95/xbc", "BOX DRAWINGS LIGHT LEFT AND HEAVY RIGHT");
+-   ("/xe2/x95/xbd", "BOX DRAWINGS LIGHT UP AND HEAVY DOWN");
+-   ("/xe2/x95/xbe", "BOX DRAWINGS HEAVY LEFT AND LIGHT RIGHT");
+-   ("/xe2/x95/xbf", "BOX DRAWINGS HEAVY UP AND LIGHT DOWN");
+-   ("/xe2/x96/x80", "UPPER HALF BLOCK");
+-   ("/xe2/x96/x81", "LOWER ONE EIGHTH BLOCK");
+-   ("/xe2/x96/x82", "LOWER ONE QUARTER BLOCK");
+-   ("/xe2/x96/x83", "LOWER THREE EIGHTHS BLOCK");
+-   ("/xe2/x96/x84", "LOWER HALF BLOCK");
+-   ("/xe2/x96/x85", "LOWER FIVE EIGHTHS BLOCK");
+-   ("/xe2/x96/x86", "LOWER THREE QUARTERS BLOCK");
+-   ("/xe2/x96/x87", "LOWER SEVEN EIGHTHS BLOCK");
+-   ("/xe2/x96/x88", "FULL BLOCK");
+-   ("/xe2/x96/x89", "LEFT SEVEN EIGHTHS BLOCK");
+-   ("/xe2/x96/x8a", "LEFT THREE QUARTERS BLOCK");
+-   ("/xe2/x96/x8b", "LEFT FIVE EIGHTHS BLOCK");
+-   ("/xe2/x96/x8c", "LEFT HALF BLOCK");
+-   ("/xe2/x96/x8d", "LEFT THREE EIGHTHS BLOCK");
+-   ("/xe2/x96/x8e", "LEFT ONE QUARTER BLOCK");
+-   ("/xe2/x96/x8f", "LEFT ONE EIGHTH BLOCK");
+-   ("/xe2/x96/x90", "RIGHT HALF BLOCK");
+-   ("/xe2/x96/x91", "LIGHT SHADE");
+-   ("/xe2/x96/x92", "MEDIUM SHADE");
+-   ("/xe2/x96/x93", "DARK SHADE");
+-   ("/xe2/x96/x94", "UPPER ONE EIGHTH BLOCK");
+-   ("/xe2/x96/x95", "RIGHT ONE EIGHTH BLOCK");
+-   ("/xe2/x96/x96", "QUADRANT LOWER LEFT");
+-   ("/xe2/x96/x97", "QUADRANT LOWER RIGHT");
+-   ("/xe2/x96/x98", "QUADRANT UPPER LEFT");
+-   ("/xe2/x96/x99", "QUADRANT UPPER LEFT AND LOWER LEFT AND LOWER RIGHT");
+-   ("/xe2/x96/x9a", "QUADRANT UPPER LEFT AND LOWER RIGHT");
+-   ("/xe2/x96/x9b", "QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER LEFT");
+-   ("/xe2/x96/x9c", "QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER RIGHT");
+-   ("/xe2/x96/x9d", "QUADRANT UPPER RIGHT");
+-   ("/xe2/x96/x9e", "QUADRANT UPPER RIGHT AND LOWER LEFT");
+-   ("/xe2/x96/x9f", "QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT");
+-   ("/xe2/x96/xa0", "BLACK SQUARE");
+-   ("/xe2/x96/xa1", "WHITE SQUARE");
+-   ("/xe2/x96/xa2", "WHITE SQUARE WITH ROUNDED CORNERS");
+    ("/xe2/x96/xa3", "WHITE SQUARE CONTAINING BLACK SMALL SQUARE");
+-   ("/xe2/x96/xa4", "SQUARE WITH HORIZONTAL FILL");
+-   ("/xe2/x96/xa5", "SQUARE WITH VERTICAL FILL");
+-   ("/xe2/x96/xa6", "SQUARE WITH ORTHOGONAL CROSSHATCH FILL");
+-   ("/xe2/x96/xa7", "SQUARE WITH UPPER LEFT TO LOWER RIGHT FILL");
+-   ("/xe2/x96/xa8", "SQUARE WITH UPPER RIGHT TO LOWER LEFT FILL");
+-   ("/xe2/x96/xa9", "SQUARE WITH DIAGONAL CROSSHATCH FILL");
+    ("/xe2/x96/xaa", "BLACK SMALL SQUARE");
+    ("/xe2/x96/xab", "WHITE SMALL SQUARE");
+-   ("/xe2/x96/xac", "BLACK RECTANGLE");
+-   ("/xe2/x96/xad", "WHITE RECTANGLE");
+-   ("/xe2/x96/xae", "BLACK VERTICAL RECTANGLE");
+-   ("/xe2/x96/xaf", "WHITE VERTICAL RECTANGLE");
+-   ("/xe2/x96/xb0", "BLACK PARALLELOGRAM");
+-   ("/xe2/x96/xb1", "WHITE PARALLELOGRAM");
+-   ("/xe2/x96/xb2", "BLACK UP-POINTING TRIANGLE");
+-   ("/xe2/x96/xb3", "WHITE UP-POINTING TRIANGLE");
+    ("/xe2/x96/xb4", "BLACK UP-POINTING SMALL TRIANGLE");
+    ("/xe2/x96/xb5", "WHITE UP-POINTING SMALL TRIANGLE");
+-   ("/xe2/x96/xb6", "BLACK RIGHT-POINTING TRIANGLE");
+-   ("/xe2/x96/xb7", "WHITE RIGHT-POINTING TRIANGLE");
+    ("/xe2/x96/xb8", "BLACK RIGHT-POINTING SMALL TRIANGLE");
+    ("/xe2/x96/xb9", "WHITE RIGHT-POINTING SMALL TRIANGLE");
+-   ("/xe2/x96/xba", "BLACK RIGHT-POINTING POINTER");
+-   ("/xe2/x96/xbb", "WHITE RIGHT-POINTING POINTER");
+-   ("/xe2/x96/xbc", "BLACK DOWN-POINTING TRIANGLE");
+-   ("/xe2/x96/xbd", "WHITE DOWN-POINTING TRIANGLE");
+    ("/xe2/x96/xbe", "BLACK DOWN-POINTING SMALL TRIANGLE");
+    ("/xe2/x96/xbf", "WHITE DOWN-POINTING SMALL TRIANGLE");
+-   ("/xe2/x97/x80", "BLACK LEFT-POINTING TRIANGLE");
+-   ("/xe2/x97/x81", "WHITE LEFT-POINTING TRIANGLE");
+    ("/xe2/x97/x82", "BLACK LEFT-POINTING SMALL TRIANGLE");
+    ("/xe2/x97/x83", "WHITE LEFT-POINTING SMALL TRIANGLE");
+-   ("/xe2/x97/x84", "BLACK LEFT-POINTING POINTER");
+-   ("/xe2/x97/x85", "WHITE LEFT-POINTING POINTER");
+-   ("/xe2/x97/x86", "BLACK DIAMOND");
+-   ("/xe2/x97/x87", "WHITE DIAMOND");
+    ("/xe2/x97/x88", "WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND");
+-   ("/xe2/x97/x89", "FISHEYE");
+-   ("/xe2/x97/x8a", "LOZENGE");
+-   ("/xe2/x97/x8b", "WHITE CIRCLE");
+-   ("/xe2/x97/x8c", "DOTTED CIRCLE");
+-   ("/xe2/x97/x8d", "CIRCLE WITH VERTICAL FILL");
+-   ("/xe2/x97/x8e", "BULLSEYE");
+-   ("/xe2/x97/x8f", "BLACK CIRCLE");
+-   ("/xe2/x97/x90", "CIRCLE WITH LEFT HALF BLACK");
+-   ("/xe2/x97/x91", "CIRCLE WITH RIGHT HALF BLACK");
+-   ("/xe2/x97/x92", "CIRCLE WITH LOWER HALF BLACK");
+-   ("/xe2/x97/x93", "CIRCLE WITH UPPER HALF BLACK");
+-   ("/xe2/x97/x94", "CIRCLE WITH UPPER RIGHT QUADRANT BLACK");
+-   ("/xe2/x97/x95", "CIRCLE WITH ALL BUT UPPER LEFT QUADRANT BLACK");
+-   ("/xe2/x97/x96", "LEFT HALF BLACK CIRCLE");
+-   ("/xe2/x97/x97", "RIGHT HALF BLACK CIRCLE");
+-   ("/xe2/x97/x98", "INVERSE BULLET");
+-   ("/xe2/x97/x99", "INVERSE WHITE CIRCLE");
+-   ("/xe2/x97/x9a", "UPPER HALF INVERSE WHITE CIRCLE");
+-   ("/xe2/x97/x9b", "LOWER HALF INVERSE WHITE CIRCLE");
+-   ("/xe2/x97/x9c", "UPPER LEFT QUADRANT CIRCULAR ARC");
+-   ("/xe2/x97/x9d", "UPPER RIGHT QUADRANT CIRCULAR ARC");
+-   ("/xe2/x97/x9e", "LOWER RIGHT QUADRANT CIRCULAR ARC");
+-   ("/xe2/x97/x9f", "LOWER LEFT QUADRANT CIRCULAR ARC");
+-   ("/xe2/x97/xa0", "UPPER HALF CIRCLE");
+-   ("/xe2/x97/xa1", "LOWER HALF CIRCLE");
+-   ("/xe2/x97/xa2", "BLACK LOWER RIGHT TRIANGLE");
+-   ("/xe2/x97/xa3", "BLACK LOWER LEFT TRIANGLE");
+-   ("/xe2/x97/xa4", "BLACK UPPER LEFT TRIANGLE");
+-   ("/xe2/x97/xa5", "BLACK UPPER RIGHT TRIANGLE");
+-   ("/xe2/x97/xa6", "WHITE BULLET");
+-   ("/xe2/x97/xa7", "SQUARE WITH LEFT HALF BLACK");
+-   ("/xe2/x97/xa8", "SQUARE WITH RIGHT HALF BLACK");
+-   ("/xe2/x97/xa9", "SQUARE WITH UPPER LEFT DIAGONAL HALF BLACK");
+-   ("/xe2/x97/xaa", "SQUARE WITH LOWER RIGHT DIAGONAL HALF BLACK");
+-   ("/xe2/x97/xab", "WHITE SQUARE WITH VERTICAL BISECTING LINE");
+-   ("/xe2/x97/xac", "WHITE UP-POINTING TRIANGLE WITH DOT");
+-   ("/xe2/x97/xad", "UP-POINTING TRIANGLE WITH LEFT HALF BLACK");
+-   ("/xe2/x97/xae", "UP-POINTING TRIANGLE WITH RIGHT HALF BLACK");
+-   ("/xe2/x97/xaf", "LARGE CIRCLE");
+-   ("/xe2/x97/xb0", "WHITE SQUARE WITH UPPER LEFT QUADRANT");
+-   ("/xe2/x97/xb1", "WHITE SQUARE WITH LOWER LEFT QUADRANT");
+-   ("/xe2/x97/xb2", "WHITE SQUARE WITH LOWER RIGHT QUADRANT");
+-   ("/xe2/x97/xb3", "WHITE SQUARE WITH UPPER RIGHT QUADRANT");
+-   ("/xe2/x97/xb4", "WHITE CIRCLE WITH UPPER LEFT QUADRANT");
+-   ("/xe2/x97/xb5", "WHITE CIRCLE WITH LOWER LEFT QUADRANT");
+-   ("/xe2/x97/xb6", "WHITE CIRCLE WITH LOWER RIGHT QUADRANT");
+-   ("/xe2/x97/xb7", "WHITE CIRCLE WITH UPPER RIGHT QUADRANT");
+-   ("/xe2/x97/xb8", "UPPER LEFT TRIANGLE");
+-   ("/xe2/x97/xb9", "UPPER RIGHT TRIANGLE");
+-   ("/xe2/x97/xba", "LOWER LEFT TRIANGLE");
+-   ("/xe2/x97/xbb", "WHITE MEDIUM SQUARE");
+-   ("/xe2/x97/xbc", "BLACK MEDIUM SQUARE");
+    ("/xe2/x97/xbd", "WHITE MEDIUM SMALL SQUARE");
+    ("/xe2/x97/xbe", "BLACK MEDIUM SMALL SQUARE");
+-   ("/xe2/x97/xbf", "LOWER RIGHT TRIANGLE");
+-   ("/xe2/x98/x80", "BLACK SUN WITH RAYS");
+-   ("/xe2/x98/x81", "CLOUD");
+-   ("/xe2/x98/x82", "UMBRELLA");
+-   ("/xe2/x98/x83", "SNOWMAN");
+-   ("/xe2/x98/x84", "COMET");
+-   ("/xe2/x98/x85", "BLACK STAR");
+-   ("/xe2/x98/x86", "WHITE STAR");
+-   ("/xe2/x98/x87", "LIGHTNING");
+-   ("/xe2/x98/x88", "THUNDERSTORM");
+-   ("/xe2/x98/x89", "SUN");
+-   ("/xe2/x98/x8a", "ASCENDING NODE");
+-   ("/xe2/x98/x8b", "DESCENDING NODE");
+-   ("/xe2/x98/x8c", "CONJUNCTION");
+-   ("/xe2/x98/x8d", "OPPOSITION");
+-   ("/xe2/x98/x8e", "BLACK TELEPHONE");
+-   ("/xe2/x98/x8f", "WHITE TELEPHONE");
+-   ("/xe2/x98/x90", "BALLOT BOX");
+-   ("/xe2/x98/x91", "BALLOT BOX WITH CHECK");
+-   ("/xe2/x98/x92", "BALLOT BOX WITH X");
+-   ("/xe2/x98/x93", "SALTIRE");
+-   ("/xe2/x98/x94", "UMBRELLA WITH RAIN DROPS");
+-   ("/xe2/x98/x95", "HOT BEVERAGE");
+-   ("/xe2/x98/x96", "WHITE SHOGI PIECE");
+-   ("/xe2/x98/x97", "BLACK SHOGI PIECE");
+-   ("/xe2/x98/x98", "SHAMROCK");
+-   ("/xe2/x98/x99", "REVERSED ROTATED FLORAL HEART BULLET");
+-   ("/xe2/x98/x9a", "BLACK LEFT POINTING INDEX");
+-   ("/xe2/x98/x9b", "BLACK RIGHT POINTING INDEX");
+-   ("/xe2/x98/x9c", "WHITE LEFT POINTING INDEX");
+-   ("/xe2/x98/x9d", "WHITE UP POINTING INDEX");
+-   ("/xe2/x98/x9e", "WHITE RIGHT POINTING INDEX");
+-   ("/xe2/x98/x9f", "WHITE DOWN POINTING INDEX");
+-   ("/xe2/x98/xa0", "SKULL AND CROSSBONES");
+-   ("/xe2/x98/xa1", "CAUTION SIGN");
+-   ("/xe2/x98/xa2", "RADIOACTIVE SIGN");
+-   ("/xe2/x98/xa3", "BIOHAZARD SIGN");
+-   ("/xe2/x98/xa4", "CADUCEUS");
+-   ("/xe2/x98/xa5", "ANKH");
+-   ("/xe2/x98/xa6", "ORTHODOX CROSS");
+-   ("/xe2/x98/xa7", "CHI RHO");
+-   ("/xe2/x98/xa8", "CROSS OF LORRAINE");
+-   ("/xe2/x98/xa9", "CROSS OF JERUSALEM");
+-   ("/xe2/x98/xaa", "STAR AND CRESCENT");
+-   ("/xe2/x98/xab", "FARSI SYMBOL");
+-   ("/xe2/x98/xac", "ADI SHAKTI");
+-   ("/xe2/x98/xad", "HAMMER AND SICKLE");
+-   ("/xe2/x98/xae", "PEACE SYMBOL");
+-   ("/xe2/x98/xaf", "YIN YANG");
+-   ("/xe2/x98/xb0", "TRIGRAM FOR HEAVEN");
+-   ("/xe2/x98/xb1", "TRIGRAM FOR LAKE");
+-   ("/xe2/x98/xb2", "TRIGRAM FOR FIRE");
+-   ("/xe2/x98/xb3", "TRIGRAM FOR THUNDER");
+-   ("/xe2/x98/xb4", "TRIGRAM FOR WIND");
+-   ("/xe2/x98/xb5", "TRIGRAM FOR WATER");
+-   ("/xe2/x98/xb6", "TRIGRAM FOR MOUNTAIN");
+-   ("/xe2/x98/xb7", "TRIGRAM FOR EARTH");
+-   ("/xe2/x98/xb8", "WHEEL OF DHARMA");
+-   ("/xe2/x98/xb9", "WHITE FROWNING FACE");
+-   ("/xe2/x98/xba", "WHITE SMILING FACE");
+-   ("/xe2/x98/xbb", "BLACK SMILING FACE");
+-   ("/xe2/x98/xbc", "WHITE SUN WITH RAYS");
+-   ("/xe2/x98/xbd", "FIRST QUARTER MOON");
+-   ("/xe2/x98/xbe", "LAST QUARTER MOON");
+-   ("/xe2/x98/xbf", "MERCURY");
+-   ("/xe2/x99/x80", "FEMALE SIGN");
+-   ("/xe2/x99/x81", "EARTH");
+-   ("/xe2/x99/x82", "MALE SIGN");
+-   ("/xe2/x99/x83", "JUPITER");
+-   ("/xe2/x99/x84", "SATURN");
+-   ("/xe2/x99/x85", "URANUS");
+-   ("/xe2/x99/x86", "NEPTUNE");
+-   ("/xe2/x99/x87", "PLUTO");
+-   ("/xe2/x99/x88", "ARIES");
+-   ("/xe2/x99/x89", "TAURUS");
+-   ("/xe2/x99/x8a", "GEMINI");
+-   ("/xe2/x99/x8b", "CANCER");
+-   ("/xe2/x99/x8c", "LEO");
+-   ("/xe2/x99/x8d", "VIRGO");
+-   ("/xe2/x99/x8e", "LIBRA");
+-   ("/xe2/x99/x8f", "SCORPIUS");
+-   ("/xe2/x99/x90", "SAGITTARIUS");
+-   ("/xe2/x99/x91", "CAPRICORN");
+-   ("/xe2/x99/x92", "AQUARIUS");
+-   ("/xe2/x99/x93", "PISCES");
+-   ("/xe2/x99/x94", "WHITE CHESS KING");
+-   ("/xe2/x99/x95", "WHITE CHESS QUEEN");
+-   ("/xe2/x99/x96", "WHITE CHESS ROOK");
+-   ("/xe2/x99/x97", "WHITE CHESS BISHOP");
+-   ("/xe2/x99/x98", "WHITE CHESS KNIGHT");
+-   ("/xe2/x99/x99", "WHITE CHESS PAWN");
+-   ("/xe2/x99/x9a", "BLACK CHESS KING");
+-   ("/xe2/x99/x9b", "BLACK CHESS QUEEN");
+-   ("/xe2/x99/x9c", "BLACK CHESS ROOK");
+-   ("/xe2/x99/x9d", "BLACK CHESS BISHOP");
+-   ("/xe2/x99/x9e", "BLACK CHESS KNIGHT");
+-   ("/xe2/x99/x9f", "BLACK CHESS PAWN");
+-   ("/xe2/x99/xa0", "BLACK SPADE SUIT");
+-   ("/xe2/x99/xa1", "WHITE HEART SUIT");
+-   ("/xe2/x99/xa2", "WHITE DIAMOND SUIT");
+-   ("/xe2/x99/xa3", "BLACK CLUB SUIT");
+-   ("/xe2/x99/xa4", "WHITE SPADE SUIT");
+-   ("/xe2/x99/xa5", "BLACK HEART SUIT");
+-   ("/xe2/x99/xa6", "BLACK DIAMOND SUIT");
+-   ("/xe2/x99/xa7", "WHITE CLUB SUIT");
+-   ("/xe2/x99/xa8", "HOT SPRINGS");
+-   ("/xe2/x99/xa9", "QUARTER NOTE");
+-   ("/xe2/x99/xaa", "EIGHTH NOTE");
+-   ("/xe2/x99/xab", "BEAMED EIGHTH NOTES");
+-   ("/xe2/x99/xac", "BEAMED SIXTEENTH NOTES");
+-   ("/xe2/x99/xad", "MUSIC FLAT SIGN");
+-   ("/xe2/x99/xae", "MUSIC NATURAL SIGN");
+-   ("/xe2/x99/xaf", "MUSIC SHARP SIGN");
+-   ("/xe2/x99/xb0", "WEST SYRIAC CROSS");
+-   ("/xe2/x99/xb1", "EAST SYRIAC CROSS");
+-   ("/xe2/x99/xb2", "UNIVERSAL RECYCLING SYMBOL");
+-   ("/xe2/x99/xb3", "RECYCLING SYMBOL FOR TYPE-1 PLASTICS");
+-   ("/xe2/x99/xb4", "RECYCLING SYMBOL FOR TYPE-2 PLASTICS");
+-   ("/xe2/x99/xb5", "RECYCLING SYMBOL FOR TYPE-3 PLASTICS");
+-   ("/xe2/x99/xb6", "RECYCLING SYMBOL FOR TYPE-4 PLASTICS");
+-   ("/xe2/x99/xb7", "RECYCLING SYMBOL FOR TYPE-5 PLASTICS");
+-   ("/xe2/x99/xb8", "RECYCLING SYMBOL FOR TYPE-6 PLASTICS");
+-   ("/xe2/x99/xb9", "RECYCLING SYMBOL FOR TYPE-7 PLASTICS");
+-   ("/xe2/x99/xba", "RECYCLING SYMBOL FOR GENERIC MATERIALS");
+-   ("/xe2/x99/xbb", "BLACK UNIVERSAL RECYCLING SYMBOL");
+-   ("/xe2/x99/xbc", "RECYCLED PAPER SYMBOL");
+-   ("/xe2/x99/xbd", "PARTIALLY-RECYCLED PAPER SYMBOL");
+-   ("/xe2/x99/xbe", "PERMANENT PAPER SIGN");
+-   ("/xe2/x99/xbf", "WHEELCHAIR SYMBOL");
+-   ("/xe2/x9a/x80", "DIE FACE-1");
+-   ("/xe2/x9a/x81", "DIE FACE-2");
+-   ("/xe2/x9a/x82", "DIE FACE-3");
+-   ("/xe2/x9a/x83", "DIE FACE-4");
+-   ("/xe2/x9a/x84", "DIE FACE-5");
+-   ("/xe2/x9a/x85", "DIE FACE-6");
+-   ("/xe2/x9a/x86", "WHITE CIRCLE WITH DOT RIGHT");
+-   ("/xe2/x9a/x87", "WHITE CIRCLE WITH TWO DOTS");
+-   ("/xe2/x9a/x88", "BLACK CIRCLE WITH WHITE DOT RIGHT");
+-   ("/xe2/x9a/x89", "BLACK CIRCLE WITH TWO WHITE DOTS");
+-   ("/xe2/x9a/x8a", "MONOGRAM FOR YANG");
+-   ("/xe2/x9a/x8b", "MONOGRAM FOR YIN");
+-   ("/xe2/x9a/x8c", "DIGRAM FOR GREATER YANG");
+-   ("/xe2/x9a/x8d", "DIGRAM FOR LESSER YIN");
+-   ("/xe2/x9a/x8e", "DIGRAM FOR LESSER YANG");
+-   ("/xe2/x9a/x8f", "DIGRAM FOR GREATER YIN");
+-   ("/xe2/x9a/x90", "WHITE FLAG");
+-   ("/xe2/x9a/x91", "BLACK FLAG");
+-   ("/xe2/x9a/x92", "HAMMER AND PICK");
+-   ("/xe2/x9a/x93", "ANCHOR");
+-   ("/xe2/x9a/x94", "CROSSED SWORDS");
+-   ("/xe2/x9a/x95", "STAFF OF AESCULAPIUS");
+-   ("/xe2/x9a/x96", "SCALES");
+-   ("/xe2/x9a/x97", "ALEMBIC");
+-   ("/xe2/x9a/x98", "FLOWER");
+-   ("/xe2/x9a/x99", "GEAR");
+-   ("/xe2/x9a/x9a", "STAFF OF HERMES");
+-   ("/xe2/x9a/x9b", "ATOM SYMBOL");
+-   ("/xe2/x9a/x9c", "FLEUR-DE-LIS");
+-   ("/xe2/x9a/x9d", "OUTLINED WHITE STAR");
+-   ("/xe2/x9a/xa0", "WARNING SIGN");
+-   ("/xe2/x9a/xa1", "HIGH VOLTAGE SIGN");
+-   ("/xe2/x9a/xa2", "DOUBLED FEMALE SIGN");
+-   ("/xe2/x9a/xa3", "DOUBLED MALE SIGN");
+-   ("/xe2/x9a/xa4", "INTERLOCKED FEMALE AND MALE SIGN");
+-   ("/xe2/x9a/xa5", "MALE AND FEMALE SIGN");
+-   ("/xe2/x9a/xa6", "MALE WITH STROKE SIGN");
+-   ("/xe2/x9a/xa7", "MALE WITH STROKE AND MALE AND FEMALE SIGN");
+-   ("/xe2/x9a/xa8", "VERTICAL MALE WITH STROKE SIGN");
+-   ("/xe2/x9a/xa9", "HORIZONTAL MALE WITH STROKE SIGN");
+-   ("/xe2/x9a/xaa", "MEDIUM WHITE CIRCLE");
+-   ("/xe2/x9a/xab", "MEDIUM BLACK CIRCLE");
+    ("/xe2/x9a/xac", "MEDIUM SMALL WHITE CIRCLE");
+-   ("/xe2/x9a/xad", "MARRIAGE SYMBOL");
+-   ("/xe2/x9a/xae", "DIVORCE SYMBOL");
+-   ("/xe2/x9a/xaf", "UNMARRIED PARTNERSHIP SYMBOL");
+-   ("/xe2/x9a/xb0", "COFFIN");
+-   ("/xe2/x9a/xb1", "FUNERAL URN");
+-   ("/xe2/x9a/xb2", "NEUTER");
+-   ("/xe2/x9a/xb3", "CERES");
+-   ("/xe2/x9a/xb4", "PALLAS");
+-   ("/xe2/x9a/xb5", "JUNO");
+-   ("/xe2/x9a/xb6", "VESTA");
+-   ("/xe2/x9a/xb7", "CHIRON");
+-   ("/xe2/x9a/xb8", "BLACK MOON LILITH");
+-   ("/xe2/x9a/xb9", "SEXTILE");
+-   ("/xe2/x9a/xba", "SEMISEXTILE");
+-   ("/xe2/x9a/xbb", "QUINCUNX");
+-   ("/xe2/x9a/xbc", "SESQUIQUADRATE");
+-   ("/xe2/x9b/x80", "WHITE DRAUGHTS MAN");
+-   ("/xe2/x9b/x81", "WHITE DRAUGHTS KING");
+-   ("/xe2/x9b/x82", "BLACK DRAUGHTS MAN");
+-   ("/xe2/x9b/x83", "BLACK DRAUGHTS KING");
+-   ("/xe2/x9c/x81", "UPPER BLADE SCISSORS");
+-   ("/xe2/x9c/x82", "BLACK SCISSORS");
+-   ("/xe2/x9c/x83", "LOWER BLADE SCISSORS");
+-   ("/xe2/x9c/x84", "WHITE SCISSORS");
+-   ("/xe2/x9c/x86", "TELEPHONE LOCATION SIGN");
+-   ("/xe2/x9c/x87", "TAPE DRIVE");
+-   ("/xe2/x9c/x88", "AIRPLANE");
+-   ("/xe2/x9c/x89", "ENVELOPE");
+-   ("/xe2/x9c/x8c", "VICTORY HAND");
+-   ("/xe2/x9c/x8d", "WRITING HAND");
+-   ("/xe2/x9c/x8e", "LOWER RIGHT PENCIL");
+-   ("/xe2/x9c/x8f", "PENCIL");
+-   ("/xe2/x9c/x90", "UPPER RIGHT PENCIL");
+-   ("/xe2/x9c/x91", "WHITE NIB");
+-   ("/xe2/x9c/x92", "BLACK NIB");
+-   ("/xe2/x9c/x93", "CHECK MARK");
+-   ("/xe2/x9c/x94", "HEAVY CHECK MARK");
+-   ("/xe2/x9c/x95", "MULTIPLICATION X");
+-   ("/xe2/x9c/x96", "HEAVY MULTIPLICATION X");
+-   ("/xe2/x9c/x97", "BALLOT X");
+-   ("/xe2/x9c/x98", "HEAVY BALLOT X");
+-   ("/xe2/x9c/x99", "OUTLINED GREEK CROSS");
+-   ("/xe2/x9c/x9a", "HEAVY GREEK CROSS");
+-   ("/xe2/x9c/x9b", "OPEN CENTRE CROSS");
+-   ("/xe2/x9c/x9c", "HEAVY OPEN CENTRE CROSS");
+-   ("/xe2/x9c/x9d", "LATIN CROSS");
+-   ("/xe2/x9c/x9e", "SHADOWED WHITE LATIN CROSS");
+-   ("/xe2/x9c/x9f", "OUTLINED LATIN CROSS");
+-   ("/xe2/x9c/xa0", "MALTESE CROSS");
+-   ("/xe2/x9c/xa1", "STAR OF DAVID");
+-   ("/xe2/x9c/xa2", "FOUR TEARDROP-SPOKED ASTERISK");
+-   ("/xe2/x9c/xa3", "FOUR BALLOON-SPOKED ASTERISK");
+-   ("/xe2/x9c/xa4", "HEAVY FOUR BALLOON-SPOKED ASTERISK");
+-   ("/xe2/x9c/xa5", "FOUR CLUB-SPOKED ASTERISK");
+-   ("/xe2/x9c/xa6", "BLACK FOUR POINTED STAR");
+-   ("/xe2/x9c/xa7", "WHITE FOUR POINTED STAR");
+-   ("/xe2/x9c/xa9", "STRESS OUTLINED WHITE STAR");
+-   ("/xe2/x9c/xaa", "CIRCLED WHITE STAR");
+-   ("/xe2/x9c/xab", "OPEN CENTRE BLACK STAR");
+-   ("/xe2/x9c/xac", "BLACK CENTRE WHITE STAR");
+-   ("/xe2/x9c/xad", "OUTLINED BLACK STAR");
+-   ("/xe2/x9c/xae", "HEAVY OUTLINED BLACK STAR");
+-   ("/xe2/x9c/xaf", "PINWHEEL STAR");
+-   ("/xe2/x9c/xb0", "SHADOWED WHITE STAR");
+-   ("/xe2/x9c/xb1", "HEAVY ASTERISK");
+-   ("/xe2/x9c/xb2", "OPEN CENTRE ASTERISK");
+-   ("/xe2/x9c/xb3", "EIGHT SPOKED ASTERISK");
+-   ("/xe2/x9c/xb4", "EIGHT POINTED BLACK STAR");
+-   ("/xe2/x9c/xb5", "EIGHT POINTED PINWHEEL STAR");
+-   ("/xe2/x9c/xb6", "SIX POINTED BLACK STAR");
+-   ("/xe2/x9c/xb7", "EIGHT POINTED RECTILINEAR BLACK STAR");
+-   ("/xe2/x9c/xb8", "HEAVY EIGHT POINTED RECTILINEAR BLACK STAR");
+-   ("/xe2/x9c/xb9", "TWELVE POINTED BLACK STAR");
+-   ("/xe2/x9c/xba", "SIXTEEN POINTED ASTERISK");
+-   ("/xe2/x9c/xbb", "TEARDROP-SPOKED ASTERISK");
+-   ("/xe2/x9c/xbc", "OPEN CENTRE TEARDROP-SPOKED ASTERISK");
+-   ("/xe2/x9c/xbd", "HEAVY TEARDROP-SPOKED ASTERISK");
+-   ("/xe2/x9c/xbe", "SIX PETALLED BLACK AND WHITE FLORETTE");
+-   ("/xe2/x9c/xbf", "BLACK FLORETTE");
+-   ("/xe2/x9d/x80", "WHITE FLORETTE");
+-   ("/xe2/x9d/x81", "EIGHT PETALLED OUTLINED BLACK FLORETTE");
+-   ("/xe2/x9d/x82", "CIRCLED OPEN CENTRE EIGHT POINTED STAR");
+-   ("/xe2/x9d/x83", "HEAVY TEARDROP-SPOKED PINWHEEL ASTERISK");
+-   ("/xe2/x9d/x84", "SNOWFLAKE");
+-   ("/xe2/x9d/x85", "TIGHT TRIFOLIATE SNOWFLAKE");
+-   ("/xe2/x9d/x86", "HEAVY CHEVRON SNOWFLAKE");
+-   ("/xe2/x9d/x87", "SPARKLE");
+-   ("/xe2/x9d/x88", "HEAVY SPARKLE");
+-   ("/xe2/x9d/x89", "BALLOON-SPOKED ASTERISK");
+-   ("/xe2/x9d/x8a", "EIGHT TEARDROP-SPOKED PROPELLER ASTERISK");
+-   ("/xe2/x9d/x8b", "HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK");
+-   ("/xe2/x9d/x8d", "SHADOWED WHITE CIRCLE");
+-   ("/xe2/x9d/x8f", "LOWER RIGHT DROP-SHADOWED WHITE SQUARE");
+-   ("/xe2/x9d/x90", "UPPER RIGHT DROP-SHADOWED WHITE SQUARE");
+-   ("/xe2/x9d/x91", "LOWER RIGHT SHADOWED WHITE SQUARE");
+-   ("/xe2/x9d/x92", "UPPER RIGHT SHADOWED WHITE SQUARE");
+-   ("/xe2/x9d/x96", "BLACK DIAMOND MINUS WHITE X");
+-   ("/xe2/x9d/x98", "LIGHT VERTICAL BAR");
+-   ("/xe2/x9d/x99", "MEDIUM VERTICAL BAR");
+-   ("/xe2/x9d/x9a", "HEAVY VERTICAL BAR");
+-   ("/xe2/x9d/x9b", "HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/x9c", "HEAVY SINGLE COMMA QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/x9d", "HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/x9e", "HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/xa1", "CURVED STEM PARAGRAPH SIGN ORNAMENT");
+-   ("/xe2/x9d/xa2", "HEAVY EXCLAMATION MARK ORNAMENT");
+-   ("/xe2/x9d/xa3", "HEAVY HEART EXCLAMATION MARK ORNAMENT");
+-   ("/xe2/x9d/xa4", "HEAVY BLACK HEART");
+-   ("/xe2/x9d/xa5", "ROTATED HEAVY BLACK HEART BULLET");
+-   ("/xe2/x9d/xa6", "FLORAL HEART");
+-   ("/xe2/x9d/xa7", "ROTATED FLORAL HEART BULLET");
+-   ("/xe2/x9d/xa8", "MEDIUM LEFT PARENTHESIS ORNAMENT");
+-   ("/xe2/x9d/xa9", "MEDIUM RIGHT PARENTHESIS ORNAMENT");
+-   ("/xe2/x9d/xaa", "MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT");
+-   ("/xe2/x9d/xab", "MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT");
+-   ("/xe2/x9d/xac", "MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT");
+-   ("/xe2/x9d/xad", "MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT");
+-   ("/xe2/x9d/xae", "HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/xaf", "HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT");
+-   ("/xe2/x9d/xb0", "HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb1", "HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb2", "LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb3", "LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb4", "MEDIUM LEFT CURLY BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb5", "MEDIUM RIGHT CURLY BRACKET ORNAMENT");
+-   ("/xe2/x9d/xb6", "DINGBAT NEGATIVE CIRCLED DIGIT ONE");
+-   ("/xe2/x9d/xb7", "DINGBAT NEGATIVE CIRCLED DIGIT TWO");
+-   ("/xe2/x9d/xb8", "DINGBAT NEGATIVE CIRCLED DIGIT THREE");
+-   ("/xe2/x9d/xb9", "DINGBAT NEGATIVE CIRCLED DIGIT FOUR");
+-   ("/xe2/x9d/xba", "DINGBAT NEGATIVE CIRCLED DIGIT FIVE");
+-   ("/xe2/x9d/xbb", "DINGBAT NEGATIVE CIRCLED DIGIT SIX");
+-   ("/xe2/x9d/xbc", "DINGBAT NEGATIVE CIRCLED DIGIT SEVEN");
+-   ("/xe2/x9d/xbd", "DINGBAT NEGATIVE CIRCLED DIGIT EIGHT");
+-   ("/xe2/x9d/xbe", "DINGBAT NEGATIVE CIRCLED DIGIT NINE");
+-   ("/xe2/x9d/xbf", "DINGBAT NEGATIVE CIRCLED NUMBER TEN");
+-   ("/xe2/x9e/x80", "DINGBAT CIRCLED SANS-SERIF DIGIT ONE");
+-   ("/xe2/x9e/x81", "DINGBAT CIRCLED SANS-SERIF DIGIT TWO");
+-   ("/xe2/x9e/x82", "DINGBAT CIRCLED SANS-SERIF DIGIT THREE");
+-   ("/xe2/x9e/x83", "DINGBAT CIRCLED SANS-SERIF DIGIT FOUR");
+-   ("/xe2/x9e/x84", "DINGBAT CIRCLED SANS-SERIF DIGIT FIVE");
+-   ("/xe2/x9e/x85", "DINGBAT CIRCLED SANS-SERIF DIGIT SIX");
+-   ("/xe2/x9e/x86", "DINGBAT CIRCLED SANS-SERIF DIGIT SEVEN");
+-   ("/xe2/x9e/x87", "DINGBAT CIRCLED SANS-SERIF DIGIT EIGHT");
+-   ("/xe2/x9e/x88", "DINGBAT CIRCLED SANS-SERIF DIGIT NINE");
+-   ("/xe2/x9e/x89", "DINGBAT CIRCLED SANS-SERIF NUMBER TEN");
+-   ("/xe2/x9e/x8a", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ONE");
+-   ("/xe2/x9e/x8b", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT TWO");
+-   ("/xe2/x9e/x8c", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT THREE");
+-   ("/xe2/x9e/x8d", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FOUR");
+-   ("/xe2/x9e/x8e", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FIVE");
+-   ("/xe2/x9e/x8f", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SIX");
+-   ("/xe2/x9e/x90", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SEVEN");
+-   ("/xe2/x9e/x91", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT EIGHT");
+-   ("/xe2/x9e/x92", "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT NINE");
+-   ("/xe2/x9e/x93", "DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN");
+-   ("/xe2/x9e/x94", "HEAVY WIDE-HEADED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x98", "HEAVY SOUTH EAST ARROW");
+-   ("/xe2/x9e/x99", "HEAVY RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x9a", "HEAVY NORTH EAST ARROW");
+-   ("/xe2/x9e/x9b", "DRAFTING POINT RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x9c", "HEAVY ROUND-TIPPED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x9d", "TRIANGLE-HEADED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x9e", "HEAVY TRIANGLE-HEADED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/x9f", "DASHED TRIANGLE-HEADED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa0", "HEAVY DASHED TRIANGLE-HEADED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa1", "BLACK RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa2", "THREE-D TOP-LIGHTED RIGHTWARDS ARROWHEAD");
+-   ("/xe2/x9e/xa3", "THREE-D BOTTOM-LIGHTED RIGHTWARDS ARROWHEAD");
+-   ("/xe2/x9e/xa4", "BLACK RIGHTWARDS ARROWHEAD");
+-   ("/xe2/x9e/xa5", "HEAVY BLACK CURVED DOWNWARDS AND RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa6", "HEAVY BLACK CURVED UPWARDS AND RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa7", "SQUAT BLACK RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa8", "HEAVY CONCAVE-POINTED BLACK RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xa9", "RIGHT-SHADED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xaa", "LEFT-SHADED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xab", "BACK-TILTED SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xac", "FRONT-TILTED SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xad", "HEAVY LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xae", "HEAVY UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xaf", "NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb1", "NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb2", "CIRCLED HEAVY WHITE RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb3", "WHITE-FEATHERED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb4", "BLACK-FEATHERED SOUTH EAST ARROW");
+-   ("/xe2/x9e/xb5", "BLACK-FEATHERED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb6", "BLACK-FEATHERED NORTH EAST ARROW");
+-   ("/xe2/x9e/xb7", "HEAVY BLACK-FEATHERED SOUTH EAST ARROW");
+-   ("/xe2/x9e/xb8", "HEAVY BLACK-FEATHERED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xb9", "HEAVY BLACK-FEATHERED NORTH EAST ARROW");
+-   ("/xe2/x9e/xba", "TEARDROP-BARBED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xbb", "HEAVY TEARDROP-SHANKED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xbc", "WEDGE-TAILED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xbd", "HEAVY WEDGE-TAILED RIGHTWARDS ARROW");
+-   ("/xe2/x9e/xbe", "OPEN-OUTLINED RIGHTWARDS ARROW");
+-   ("/xe2/x9f/x80", "THREE DIMENSIONAL ANGLE");
+    ("/xe2/x9f/x81", "WHITE TRIANGLE CONTAINING SMALL WHITE TRIANGLE");
+-   ("/xe2/x9f/x82", "PERPENDICULAR");
+-   ("/xe2/x9f/x83", "OPEN SUBSET");
+-   ("/xe2/x9f/x84", "OPEN SUPERSET");
+-   ("/xe2/x9f/x85", "LEFT S-SHAPED BAG DELIMITER");
+-   ("/xe2/x9f/x86", "RIGHT S-SHAPED BAG DELIMITER");
+-   ("/xe2/x9f/x87", "OR WITH DOT INSIDE");
+-   ("/xe2/x9f/x88", "REVERSE SOLIDUS PRECEDING SUBSET");
+-   ("/xe2/x9f/x89", "SUPERSET PRECEDING SOLIDUS");
+-   ("/xe2/x9f/x8a", "VERTICAL BAR WITH HORIZONTAL STROKE");
+-   ("/xe2/x9f/x8c", "LONG DIVISION");
+-   ("/xe2/x9f/x90", "WHITE DIAMOND WITH CENTRED DOT");
+-   ("/xe2/x9f/x91", "AND WITH DOT");
+-   ("/xe2/x9f/x92", "ELEMENT OF OPENING UPWARDS");
+-   ("/xe2/x9f/x93", "LOWER RIGHT CORNER WITH DOT");
+-   ("/xe2/x9f/x94", "UPPER LEFT CORNER WITH DOT");
+-   ("/xe2/x9f/x95", "LEFT OUTER JOIN");
+-   ("/xe2/x9f/x96", "RIGHT OUTER JOIN");
+-   ("/xe2/x9f/x97", "FULL OUTER JOIN");
+-   ("/xe2/x9f/x98", "LARGE UP TACK");
+-   ("/xe2/x9f/x99", "LARGE DOWN TACK");
+-   ("/xe2/x9f/x9a", "LEFT AND RIGHT DOUBLE TURNSTILE");
+-   ("/xe2/x9f/x9b", "LEFT AND RIGHT TACK");
+-   ("/xe2/x9f/x9c", "LEFT MULTIMAP");
+-   ("/xe2/x9f/x9d", "LONG RIGHT TACK");
+-   ("/xe2/x9f/x9e", "LONG LEFT TACK");
+-   ("/xe2/x9f/x9f", "UP TACK WITH CIRCLE ABOVE");
+-   ("/xe2/x9f/xa0", "LOZENGE DIVIDED BY HORIZONTAL RULE");
+-   ("/xe2/x9f/xa1", "WHITE CONCAVE-SIDED DIAMOND");
+-   ("/xe2/x9f/xa2", "WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK");
+-   ("/xe2/x9f/xa3", "WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK");
+-   ("/xe2/x9f/xa4", "WHITE SQUARE WITH LEFTWARDS TICK");
+-   ("/xe2/x9f/xa5", "WHITE SQUARE WITH RIGHTWARDS TICK");
+-   ("/xe2/x9f/xa6", "MATHEMATICAL LEFT WHITE SQUARE BRACKET");
+-   ("/xe2/x9f/xa7", "MATHEMATICAL RIGHT WHITE SQUARE BRACKET");
+-   ("/xe2/x9f/xa8", "MATHEMATICAL LEFT ANGLE BRACKET");
+-   ("/xe2/x9f/xa9", "MATHEMATICAL RIGHT ANGLE BRACKET");
+-   ("/xe2/x9f/xaa", "MATHEMATICAL LEFT DOUBLE ANGLE BRACKET");
+-   ("/xe2/x9f/xab", "MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET");
+-   ("/xe2/x9f/xac", "MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET");
+-   ("/xe2/x9f/xad", "MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET");
+-   ("/xe2/x9f/xae", "MATHEMATICAL LEFT FLATTENED PARENTHESIS");
+-   ("/xe2/x9f/xaf", "MATHEMATICAL RIGHT FLATTENED PARENTHESIS");
+-   ("/xe2/x9f/xb0", "UPWARDS QUADRUPLE ARROW");
+-   ("/xe2/x9f/xb1", "DOWNWARDS QUADRUPLE ARROW");
+-   ("/xe2/x9f/xb2", "ANTICLOCKWISE GAPPED CIRCLE ARROW");
+-   ("/xe2/x9f/xb3", "CLOCKWISE GAPPED CIRCLE ARROW");
+-   ("/xe2/x9f/xb4", "RIGHT ARROW WITH CIRCLED PLUS");
+-   ("/xe2/x9f/xb5", "LONG LEFTWARDS ARROW");
+-   ("/xe2/x9f/xb6", "LONG RIGHTWARDS ARROW");
+-   ("/xe2/x9f/xb7", "LONG LEFT RIGHT ARROW");
+-   ("/xe2/x9f/xb8", "LONG LEFTWARDS DOUBLE ARROW");
+-   ("/xe2/x9f/xb9", "LONG RIGHTWARDS DOUBLE ARROW");
+-   ("/xe2/x9f/xba", "LONG LEFT RIGHT DOUBLE ARROW");
+-   ("/xe2/x9f/xbb", "LONG LEFTWARDS ARROW FROM BAR");
+-   ("/xe2/x9f/xbc", "LONG RIGHTWARDS ARROW FROM BAR");
+-   ("/xe2/x9f/xbd", "LONG LEFTWARDS DOUBLE ARROW FROM BAR");
+-   ("/xe2/x9f/xbe", "LONG RIGHTWARDS DOUBLE ARROW FROM BAR");
+-   ("/xe2/x9f/xbf", "LONG RIGHTWARDS SQUIGGLE ARROW");
+-   ("/xe2/xa0/x80", "BRAILLE PATTERN BLANK");
+-   ("/xe2/xa0/x81", "BRAILLE PATTERN DOTS-1");
+-   ("/xe2/xa0/x82", "BRAILLE PATTERN DOTS-2");
+-   ("/xe2/xa0/x83", "BRAILLE PATTERN DOTS-12");
+-   ("/xe2/xa0/x84", "BRAILLE PATTERN DOTS-3");
+-   ("/xe2/xa0/x85", "BRAILLE PATTERN DOTS-13");
+-   ("/xe2/xa0/x86", "BRAILLE PATTERN DOTS-23");
+-   ("/xe2/xa0/x87", "BRAILLE PATTERN DOTS-123");
+-   ("/xe2/xa0/x88", "BRAILLE PATTERN DOTS-4");
+-   ("/xe2/xa0/x89", "BRAILLE PATTERN DOTS-14");
+-   ("/xe2/xa0/x8a", "BRAILLE PATTERN DOTS-24");
+-   ("/xe2/xa0/x8b", "BRAILLE PATTERN DOTS-124");
+-   ("/xe2/xa0/x8c", "BRAILLE PATTERN DOTS-34");
+-   ("/xe2/xa0/x8d", "BRAILLE PATTERN DOTS-134");
+-   ("/xe2/xa0/x8e", "BRAILLE PATTERN DOTS-234");
+-   ("/xe2/xa0/x8f", "BRAILLE PATTERN DOTS-1234");
+-   ("/xe2/xa0/x90", "BRAILLE PATTERN DOTS-5");
+-   ("/xe2/xa0/x91", "BRAILLE PATTERN DOTS-15");
+-   ("/xe2/xa0/x92", "BRAILLE PATTERN DOTS-25");
+-   ("/xe2/xa0/x93", "BRAILLE PATTERN DOTS-125");
+-   ("/xe2/xa0/x94", "BRAILLE PATTERN DOTS-35");
+-   ("/xe2/xa0/x95", "BRAILLE PATTERN DOTS-135");
+-   ("/xe2/xa0/x96", "BRAILLE PATTERN DOTS-235");
+-   ("/xe2/xa0/x97", "BRAILLE PATTERN DOTS-1235");
+-   ("/xe2/xa0/x98", "BRAILLE PATTERN DOTS-45");
+-   ("/xe2/xa0/x99", "BRAILLE PATTERN DOTS-145");
+-   ("/xe2/xa0/x9a", "BRAILLE PATTERN DOTS-245");
+-   ("/xe2/xa0/x9b", "BRAILLE PATTERN DOTS-1245");
+-   ("/xe2/xa0/x9c", "BRAILLE PATTERN DOTS-345");
+-   ("/xe2/xa0/x9d", "BRAILLE PATTERN DOTS-1345");
+-   ("/xe2/xa0/x9e", "BRAILLE PATTERN DOTS-2345");
+-   ("/xe2/xa0/x9f", "BRAILLE PATTERN DOTS-12345");
+-   ("/xe2/xa0/xa0", "BRAILLE PATTERN DOTS-6");
+-   ("/xe2/xa0/xa1", "BRAILLE PATTERN DOTS-16");
+-   ("/xe2/xa0/xa2", "BRAILLE PATTERN DOTS-26");
+-   ("/xe2/xa0/xa3", "BRAILLE PATTERN DOTS-126");
+-   ("/xe2/xa0/xa4", "BRAILLE PATTERN DOTS-36");
+-   ("/xe2/xa0/xa5", "BRAILLE PATTERN DOTS-136");
+-   ("/xe2/xa0/xa6", "BRAILLE PATTERN DOTS-236");
+-   ("/xe2/xa0/xa7", "BRAILLE PATTERN DOTS-1236");
+-   ("/xe2/xa0/xa8", "BRAILLE PATTERN DOTS-46");
+-   ("/xe2/xa0/xa9", "BRAILLE PATTERN DOTS-146");
+-   ("/xe2/xa0/xaa", "BRAILLE PATTERN DOTS-246");
+-   ("/xe2/xa0/xab", "BRAILLE PATTERN DOTS-1246");
+-   ("/xe2/xa0/xac", "BRAILLE PATTERN DOTS-346");
+-   ("/xe2/xa0/xad", "BRAILLE PATTERN DOTS-1346");
+-   ("/xe2/xa0/xae", "BRAILLE PATTERN DOTS-2346");
+-   ("/xe2/xa0/xaf", "BRAILLE PATTERN DOTS-12346");
+-   ("/xe2/xa0/xb0", "BRAILLE PATTERN DOTS-56");
+-   ("/xe2/xa0/xb1", "BRAILLE PATTERN DOTS-156");
+-   ("/xe2/xa0/xb2", "BRAILLE PATTERN DOTS-256");
+-   ("/xe2/xa0/xb3", "BRAILLE PATTERN DOTS-1256");
+-   ("/xe2/xa0/xb4", "BRAILLE PATTERN DOTS-356");
+-   ("/xe2/xa0/xb5", "BRAILLE PATTERN DOTS-1356");
+-   ("/xe2/xa0/xb6", "BRAILLE PATTERN DOTS-2356");
+-   ("/xe2/xa0/xb7", "BRAILLE PATTERN DOTS-12356");
+-   ("/xe2/xa0/xb8", "BRAILLE PATTERN DOTS-456");
+-   ("/xe2/xa0/xb9", "BRAILLE PATTERN DOTS-1456");
+-   ("/xe2/xa0/xba", "BRAILLE PATTERN DOTS-2456");
+-   ("/xe2/xa0/xbb", "BRAILLE PATTERN DOTS-12456");
+-   ("/xe2/xa0/xbc", "BRAILLE PATTERN DOTS-3456");
+-   ("/xe2/xa0/xbd", "BRAILLE PATTERN DOTS-13456");
+-   ("/xe2/xa0/xbe", "BRAILLE PATTERN DOTS-23456");
+-   ("/xe2/xa0/xbf", "BRAILLE PATTERN DOTS-123456");
+-   ("/xe2/xa1/x80", "BRAILLE PATTERN DOTS-7");
+-   ("/xe2/xa1/x81", "BRAILLE PATTERN DOTS-17");
+-   ("/xe2/xa1/x82", "BRAILLE PATTERN DOTS-27");
+-   ("/xe2/xa1/x83", "BRAILLE PATTERN DOTS-127");
+-   ("/xe2/xa1/x84", "BRAILLE PATTERN DOTS-37");
+-   ("/xe2/xa1/x85", "BRAILLE PATTERN DOTS-137");
+-   ("/xe2/xa1/x86", "BRAILLE PATTERN DOTS-237");
+-   ("/xe2/xa1/x87", "BRAILLE PATTERN DOTS-1237");
+-   ("/xe2/xa1/x88", "BRAILLE PATTERN DOTS-47");
+-   ("/xe2/xa1/x89", "BRAILLE PATTERN DOTS-147");
+-   ("/xe2/xa1/x8a", "BRAILLE PATTERN DOTS-247");
+-   ("/xe2/xa1/x8b", "BRAILLE PATTERN DOTS-1247");
+-   ("/xe2/xa1/x8c", "BRAILLE PATTERN DOTS-347");
+-   ("/xe2/xa1/x8d", "BRAILLE PATTERN DOTS-1347");
+-   ("/xe2/xa1/x8e", "BRAILLE PATTERN DOTS-2347");
+-   ("/xe2/xa1/x8f", "BRAILLE PATTERN DOTS-12347");
+-   ("/xe2/xa1/x90", "BRAILLE PATTERN DOTS-57");
+-   ("/xe2/xa1/x91", "BRAILLE PATTERN DOTS-157");
+-   ("/xe2/xa1/x92", "BRAILLE PATTERN DOTS-257");
+-   ("/xe2/xa1/x93", "BRAILLE PATTERN DOTS-1257");
+-   ("/xe2/xa1/x94", "BRAILLE PATTERN DOTS-357");
+-   ("/xe2/xa1/x95", "BRAILLE PATTERN DOTS-1357");
+-   ("/xe2/xa1/x96", "BRAILLE PATTERN DOTS-2357");
+-   ("/xe2/xa1/x97", "BRAILLE PATTERN DOTS-12357");
+-   ("/xe2/xa1/x98", "BRAILLE PATTERN DOTS-457");
+-   ("/xe2/xa1/x99", "BRAILLE PATTERN DOTS-1457");
+-   ("/xe2/xa1/x9a", "BRAILLE PATTERN DOTS-2457");
+-   ("/xe2/xa1/x9b", "BRAILLE PATTERN DOTS-12457");
+-   ("/xe2/xa1/x9c", "BRAILLE PATTERN DOTS-3457");
+-   ("/xe2/xa1/x9d", "BRAILLE PATTERN DOTS-13457");
+-   ("/xe2/xa1/x9e", "BRAILLE PATTERN DOTS-23457");
+-   ("/xe2/xa1/x9f", "BRAILLE PATTERN DOTS-123457");
+-   ("/xe2/xa1/xa0", "BRAILLE PATTERN DOTS-67");
+-   ("/xe2/xa1/xa1", "BRAILLE PATTERN DOTS-167");
+-   ("/xe2/xa1/xa2", "BRAILLE PATTERN DOTS-267");
+-   ("/xe2/xa1/xa3", "BRAILLE PATTERN DOTS-1267");
+-   ("/xe2/xa1/xa4", "BRAILLE PATTERN DOTS-367");
+-   ("/xe2/xa1/xa5", "BRAILLE PATTERN DOTS-1367");
+-   ("/xe2/xa1/xa6", "BRAILLE PATTERN DOTS-2367");
+-   ("/xe2/xa1/xa7", "BRAILLE PATTERN DOTS-12367");
+-   ("/xe2/xa1/xa8", "BRAILLE PATTERN DOTS-467");
+-   ("/xe2/xa1/xa9", "BRAILLE PATTERN DOTS-1467");
+-   ("/xe2/xa1/xaa", "BRAILLE PATTERN DOTS-2467");
+-   ("/xe2/xa1/xab", "BRAILLE PATTERN DOTS-12467");
+-   ("/xe2/xa1/xac", "BRAILLE PATTERN DOTS-3467");
+-   ("/xe2/xa1/xad", "BRAILLE PATTERN DOTS-13467");
+-   ("/xe2/xa1/xae", "BRAILLE PATTERN DOTS-23467");
+-   ("/xe2/xa1/xaf", "BRAILLE PATTERN DOTS-123467");
+-   ("/xe2/xa1/xb0", "BRAILLE PATTERN DOTS-567");
+-   ("/xe2/xa1/xb1", "BRAILLE PATTERN DOTS-1567");
+-   ("/xe2/xa1/xb2", "BRAILLE PATTERN DOTS-2567");
+-   ("/xe2/xa1/xb3", "BRAILLE PATTERN DOTS-12567");
+-   ("/xe2/xa1/xb4", "BRAILLE PATTERN DOTS-3567");
+-   ("/xe2/xa1/xb5", "BRAILLE PATTERN DOTS-13567");
+-   ("/xe2/xa1/xb6", "BRAILLE PATTERN DOTS-23567");
+-   ("/xe2/xa1/xb7", "BRAILLE PATTERN DOTS-123567");
+-   ("/xe2/xa1/xb8", "BRAILLE PATTERN DOTS-4567");
+-   ("/xe2/xa1/xb9", "BRAILLE PATTERN DOTS-14567");
+-   ("/xe2/xa1/xba", "BRAILLE PATTERN DOTS-24567");
+-   ("/xe2/xa1/xbb", "BRAILLE PATTERN DOTS-124567");
+-   ("/xe2/xa1/xbc", "BRAILLE PATTERN DOTS-34567");
+-   ("/xe2/xa1/xbd", "BRAILLE PATTERN DOTS-134567");
+-   ("/xe2/xa1/xbe", "BRAILLE PATTERN DOTS-234567");
+-   ("/xe2/xa1/xbf", "BRAILLE PATTERN DOTS-1234567");
+-   ("/xe2/xa2/x80", "BRAILLE PATTERN DOTS-8");
+-   ("/xe2/xa2/x81", "BRAILLE PATTERN DOTS-18");
+-   ("/xe2/xa2/x82", "BRAILLE PATTERN DOTS-28");
+-   ("/xe2/xa2/x83", "BRAILLE PATTERN DOTS-128");
+-   ("/xe2/xa2/x84", "BRAILLE PATTERN DOTS-38");
+-   ("/xe2/xa2/x85", "BRAILLE PATTERN DOTS-138");
+-   ("/xe2/xa2/x86", "BRAILLE PATTERN DOTS-238");
+-   ("/xe2/xa2/x87", "BRAILLE PATTERN DOTS-1238");
+-   ("/xe2/xa2/x88", "BRAILLE PATTERN DOTS-48");
+-   ("/xe2/xa2/x89", "BRAILLE PATTERN DOTS-148");
+-   ("/xe2/xa2/x8a", "BRAILLE PATTERN DOTS-248");
+-   ("/xe2/xa2/x8b", "BRAILLE PATTERN DOTS-1248");
+-   ("/xe2/xa2/x8c", "BRAILLE PATTERN DOTS-348");
+-   ("/xe2/xa2/x8d", "BRAILLE PATTERN DOTS-1348");
+-   ("/xe2/xa2/x8e", "BRAILLE PATTERN DOTS-2348");
+-   ("/xe2/xa2/x8f", "BRAILLE PATTERN DOTS-12348");
+-   ("/xe2/xa2/x90", "BRAILLE PATTERN DOTS-58");
+-   ("/xe2/xa2/x91", "BRAILLE PATTERN DOTS-158");
+-   ("/xe2/xa2/x92", "BRAILLE PATTERN DOTS-258");
+-   ("/xe2/xa2/x93", "BRAILLE PATTERN DOTS-1258");
+-   ("/xe2/xa2/x94", "BRAILLE PATTERN DOTS-358");
+-   ("/xe2/xa2/x95", "BRAILLE PATTERN DOTS-1358");
+-   ("/xe2/xa2/x96", "BRAILLE PATTERN DOTS-2358");
+-   ("/xe2/xa2/x97", "BRAILLE PATTERN DOTS-12358");
+-   ("/xe2/xa2/x98", "BRAILLE PATTERN DOTS-458");
+-   ("/xe2/xa2/x99", "BRAILLE PATTERN DOTS-1458");
+-   ("/xe2/xa2/x9a", "BRAILLE PATTERN DOTS-2458");
+-   ("/xe2/xa2/x9b", "BRAILLE PATTERN DOTS-12458");
+-   ("/xe2/xa2/x9c", "BRAILLE PATTERN DOTS-3458");
+-   ("/xe2/xa2/x9d", "BRAILLE PATTERN DOTS-13458");
+-   ("/xe2/xa2/x9e", "BRAILLE PATTERN DOTS-23458");
+-   ("/xe2/xa2/x9f", "BRAILLE PATTERN DOTS-123458");
+-   ("/xe2/xa2/xa0", "BRAILLE PATTERN DOTS-68");
+-   ("/xe2/xa2/xa1", "BRAILLE PATTERN DOTS-168");
+-   ("/xe2/xa2/xa2", "BRAILLE PATTERN DOTS-268");
+-   ("/xe2/xa2/xa3", "BRAILLE PATTERN DOTS-1268");
+-   ("/xe2/xa2/xa4", "BRAILLE PATTERN DOTS-368");
+-   ("/xe2/xa2/xa5", "BRAILLE PATTERN DOTS-1368");
+-   ("/xe2/xa2/xa6", "BRAILLE PATTERN DOTS-2368");
+-   ("/xe2/xa2/xa7", "BRAILLE PATTERN DOTS-12368");
+-   ("/xe2/xa2/xa8", "BRAILLE PATTERN DOTS-468");
+-   ("/xe2/xa2/xa9", "BRAILLE PATTERN DOTS-1468");
+-   ("/xe2/xa2/xaa", "BRAILLE PATTERN DOTS-2468");
+-   ("/xe2/xa2/xab", "BRAILLE PATTERN DOTS-12468");
+-   ("/xe2/xa2/xac", "BRAILLE PATTERN DOTS-3468");
+-   ("/xe2/xa2/xad", "BRAILLE PATTERN DOTS-13468");
+-   ("/xe2/xa2/xae", "BRAILLE PATTERN DOTS-23468");
+-   ("/xe2/xa2/xaf", "BRAILLE PATTERN DOTS-123468");
+-   ("/xe2/xa2/xb0", "BRAILLE PATTERN DOTS-568");
+-   ("/xe2/xa2/xb1", "BRAILLE PATTERN DOTS-1568");
+-   ("/xe2/xa2/xb2", "BRAILLE PATTERN DOTS-2568");
+-   ("/xe2/xa2/xb3", "BRAILLE PATTERN DOTS-12568");
+-   ("/xe2/xa2/xb4", "BRAILLE PATTERN DOTS-3568");
+-   ("/xe2/xa2/xb5", "BRAILLE PATTERN DOTS-13568");
+-   ("/xe2/xa2/xb6", "BRAILLE PATTERN DOTS-23568");
+-   ("/xe2/xa2/xb7", "BRAILLE PATTERN DOTS-123568");
+-   ("/xe2/xa2/xb8", "BRAILLE PATTERN DOTS-4568");
+-   ("/xe2/xa2/xb9", "BRAILLE PATTERN DOTS-14568");
+-   ("/xe2/xa2/xba", "BRAILLE PATTERN DOTS-24568");
+-   ("/xe2/xa2/xbb", "BRAILLE PATTERN DOTS-124568");
+-   ("/xe2/xa2/xbc", "BRAILLE PATTERN DOTS-34568");
+-   ("/xe2/xa2/xbd", "BRAILLE PATTERN DOTS-134568");
+-   ("/xe2/xa2/xbe", "BRAILLE PATTERN DOTS-234568");
+-   ("/xe2/xa2/xbf", "BRAILLE PATTERN DOTS-1234568");
+-   ("/xe2/xa3/x80", "BRAILLE PATTERN DOTS-78");
+-   ("/xe2/xa3/x81", "BRAILLE PATTERN DOTS-178");
+-   ("/xe2/xa3/x82", "BRAILLE PATTERN DOTS-278");
+-   ("/xe2/xa3/x83", "BRAILLE PATTERN DOTS-1278");
+-   ("/xe2/xa3/x84", "BRAILLE PATTERN DOTS-378");
+-   ("/xe2/xa3/x85", "BRAILLE PATTERN DOTS-1378");
+-   ("/xe2/xa3/x86", "BRAILLE PATTERN DOTS-2378");
+-   ("/xe2/xa3/x87", "BRAILLE PATTERN DOTS-12378");
+-   ("/xe2/xa3/x88", "BRAILLE PATTERN DOTS-478");
+-   ("/xe2/xa3/x89", "BRAILLE PATTERN DOTS-1478");
+-   ("/xe2/xa3/x8a", "BRAILLE PATTERN DOTS-2478");
+-   ("/xe2/xa3/x8b", "BRAILLE PATTERN DOTS-12478");
+-   ("/xe2/xa3/x8c", "BRAILLE PATTERN DOTS-3478");
+-   ("/xe2/xa3/x8d", "BRAILLE PATTERN DOTS-13478");
+-   ("/xe2/xa3/x8e", "BRAILLE PATTERN DOTS-23478");
+-   ("/xe2/xa3/x8f", "BRAILLE PATTERN DOTS-123478");
+-   ("/xe2/xa3/x90", "BRAILLE PATTERN DOTS-578");
+-   ("/xe2/xa3/x91", "BRAILLE PATTERN DOTS-1578");
+-   ("/xe2/xa3/x92", "BRAILLE PATTERN DOTS-2578");
+-   ("/xe2/xa3/x93", "BRAILLE PATTERN DOTS-12578");
+-   ("/xe2/xa3/x94", "BRAILLE PATTERN DOTS-3578");
+-   ("/xe2/xa3/x95", "BRAILLE PATTERN DOTS-13578");
+-   ("/xe2/xa3/x96", "BRAILLE PATTERN DOTS-23578");
+-   ("/xe2/xa3/x97", "BRAILLE PATTERN DOTS-123578");
+-   ("/xe2/xa3/x98", "BRAILLE PATTERN DOTS-4578");
+-   ("/xe2/xa3/x99", "BRAILLE PATTERN DOTS-14578");
+-   ("/xe2/xa3/x9a", "BRAILLE PATTERN DOTS-24578");
+-   ("/xe2/xa3/x9b", "BRAILLE PATTERN DOTS-124578");
+-   ("/xe2/xa3/x9c", "BRAILLE PATTERN DOTS-34578");
+-   ("/xe2/xa3/x9d", "BRAILLE PATTERN DOTS-134578");
+-   ("/xe2/xa3/x9e", "BRAILLE PATTERN DOTS-234578");
+-   ("/xe2/xa3/x9f", "BRAILLE PATTERN DOTS-1234578");
+-   ("/xe2/xa3/xa0", "BRAILLE PATTERN DOTS-678");
+-   ("/xe2/xa3/xa1", "BRAILLE PATTERN DOTS-1678");
+-   ("/xe2/xa3/xa2", "BRAILLE PATTERN DOTS-2678");
+-   ("/xe2/xa3/xa3", "BRAILLE PATTERN DOTS-12678");
+-   ("/xe2/xa3/xa4", "BRAILLE PATTERN DOTS-3678");
+-   ("/xe2/xa3/xa5", "BRAILLE PATTERN DOTS-13678");
+-   ("/xe2/xa3/xa6", "BRAILLE PATTERN DOTS-23678");
+-   ("/xe2/xa3/xa7", "BRAILLE PATTERN DOTS-123678");
+-   ("/xe2/xa3/xa8", "BRAILLE PATTERN DOTS-4678");
+-   ("/xe2/xa3/xa9", "BRAILLE PATTERN DOTS-14678");
+-   ("/xe2/xa3/xaa", "BRAILLE PATTERN DOTS-24678");
+-   ("/xe2/xa3/xab", "BRAILLE PATTERN DOTS-124678");
+-   ("/xe2/xa3/xac", "BRAILLE PATTERN DOTS-34678");
+-   ("/xe2/xa3/xad", "BRAILLE PATTERN DOTS-134678");
+-   ("/xe2/xa3/xae", "BRAILLE PATTERN DOTS-234678");
+-   ("/xe2/xa3/xaf", "BRAILLE PATTERN DOTS-1234678");
+-   ("/xe2/xa3/xb0", "BRAILLE PATTERN DOTS-5678");
+-   ("/xe2/xa3/xb1", "BRAILLE PATTERN DOTS-15678");
+-   ("/xe2/xa3/xb2", "BRAILLE PATTERN DOTS-25678");
+-   ("/xe2/xa3/xb3", "BRAILLE PATTERN DOTS-125678");
+-   ("/xe2/xa3/xb4", "BRAILLE PATTERN DOTS-35678");
+-   ("/xe2/xa3/xb5", "BRAILLE PATTERN DOTS-135678");
+-   ("/xe2/xa3/xb6", "BRAILLE PATTERN DOTS-235678");
+-   ("/xe2/xa3/xb7", "BRAILLE PATTERN DOTS-1235678");
+-   ("/xe2/xa3/xb8", "BRAILLE PATTERN DOTS-45678");
+-   ("/xe2/xa3/xb9", "BRAILLE PATTERN DOTS-145678");
+-   ("/xe2/xa3/xba", "BRAILLE PATTERN DOTS-245678");
+-   ("/xe2/xa3/xbb", "BRAILLE PATTERN DOTS-1245678");
+-   ("/xe2/xa3/xbc", "BRAILLE PATTERN DOTS-345678");
+-   ("/xe2/xa3/xbd", "BRAILLE PATTERN DOTS-1345678");
+-   ("/xe2/xa3/xbe", "BRAILLE PATTERN DOTS-2345678");
+-   ("/xe2/xa3/xbf", "BRAILLE PATTERN DOTS-12345678");
+-   ("/xe2/xa4/x80", "RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x81", "RIGHTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xa4/x82", "LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x83", "RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x84", "LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x85", "RIGHTWARDS TWO-HEADED ARROW FROM BAR");
+-   ("/xe2/xa4/x86", "LEFTWARDS DOUBLE ARROW FROM BAR");
+-   ("/xe2/xa4/x87", "RIGHTWARDS DOUBLE ARROW FROM BAR");
+-   ("/xe2/xa4/x88", "DOWNWARDS ARROW WITH HORIZONTAL STROKE");
+-   ("/xe2/xa4/x89", "UPWARDS ARROW WITH HORIZONTAL STROKE");
+-   ("/xe2/xa4/x8a", "UPWARDS TRIPLE ARROW");
+-   ("/xe2/xa4/x8b", "DOWNWARDS TRIPLE ARROW");
+-   ("/xe2/xa4/x8c", "LEFTWARDS DOUBLE DASH ARROW");
+-   ("/xe2/xa4/x8d", "RIGHTWARDS DOUBLE DASH ARROW");
+-   ("/xe2/xa4/x8e", "LEFTWARDS TRIPLE DASH ARROW");
+-   ("/xe2/xa4/x8f", "RIGHTWARDS TRIPLE DASH ARROW");
+-   ("/xe2/xa4/x90", "RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW");
+-   ("/xe2/xa4/x91", "RIGHTWARDS ARROW WITH DOTTED STEM");
+-   ("/xe2/xa4/x92", "UPWARDS ARROW TO BAR");
+-   ("/xe2/xa4/x93", "DOWNWARDS ARROW TO BAR");
+-   ("/xe2/xa4/x94", "RIGHTWARDS ARROW WITH TAIL WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x95", "RIGHTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xa4/x96", "RIGHTWARDS TWO-HEADED ARROW WITH TAIL");
+-   ("/xe2/xa4/x97", "RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE");
+-   ("/xe2/xa4/x98", "RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xa4/x99", "LEFTWARDS ARROW-TAIL");
+-   ("/xe2/xa4/x9a", "RIGHTWARDS ARROW-TAIL");
+-   ("/xe2/xa4/x9b", "LEFTWARDS DOUBLE ARROW-TAIL");
+-   ("/xe2/xa4/x9c", "RIGHTWARDS DOUBLE ARROW-TAIL");
+-   ("/xe2/xa4/x9d", "LEFTWARDS ARROW TO BLACK DIAMOND");
+-   ("/xe2/xa4/x9e", "RIGHTWARDS ARROW TO BLACK DIAMOND");
+-   ("/xe2/xa4/x9f", "LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND");
+-   ("/xe2/xa4/xa0", "RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND");
+-   ("/xe2/xa4/xa1", "NORTH WEST AND SOUTH EAST ARROW");
+-   ("/xe2/xa4/xa2", "NORTH EAST AND SOUTH WEST ARROW");
+-   ("/xe2/xa4/xa3", "NORTH WEST ARROW WITH HOOK");
+-   ("/xe2/xa4/xa4", "NORTH EAST ARROW WITH HOOK");
+-   ("/xe2/xa4/xa5", "SOUTH EAST ARROW WITH HOOK");
+-   ("/xe2/xa4/xa6", "SOUTH WEST ARROW WITH HOOK");
+-   ("/xe2/xa4/xa7", "NORTH WEST ARROW AND NORTH EAST ARROW");
+-   ("/xe2/xa4/xa8", "NORTH EAST ARROW AND SOUTH EAST ARROW");
+-   ("/xe2/xa4/xa9", "SOUTH EAST ARROW AND SOUTH WEST ARROW");
+-   ("/xe2/xa4/xaa", "SOUTH WEST ARROW AND NORTH WEST ARROW");
+-   ("/xe2/xa4/xab", "RISING DIAGONAL CROSSING FALLING DIAGONAL");
+-   ("/xe2/xa4/xac", "FALLING DIAGONAL CROSSING RISING DIAGONAL");
+-   ("/xe2/xa4/xad", "SOUTH EAST ARROW CROSSING NORTH EAST ARROW");
+-   ("/xe2/xa4/xae", "NORTH EAST ARROW CROSSING SOUTH EAST ARROW");
+-   ("/xe2/xa4/xaf", "FALLING DIAGONAL CROSSING NORTH EAST ARROW");
+-   ("/xe2/xa4/xb0", "RISING DIAGONAL CROSSING SOUTH EAST ARROW");
+-   ("/xe2/xa4/xb1", "NORTH EAST ARROW CROSSING NORTH WEST ARROW");
+-   ("/xe2/xa4/xb2", "NORTH WEST ARROW CROSSING NORTH EAST ARROW");
+-   ("/xe2/xa4/xb3", "WAVE ARROW POINTING DIRECTLY RIGHT");
+-   ("/xe2/xa4/xb4", "ARROW POINTING RIGHTWARDS THEN CURVING UPWARDS");
+-   ("/xe2/xa4/xb5", "ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS");
+-   ("/xe2/xa4/xb6", "ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS");
+-   ("/xe2/xa4/xb7", "ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS");
+-   ("/xe2/xa4/xb8", "RIGHT-SIDE ARC CLOCKWISE ARROW");
+-   ("/xe2/xa4/xb9", "LEFT-SIDE ARC ANTICLOCKWISE ARROW");
+-   ("/xe2/xa4/xba", "TOP ARC ANTICLOCKWISE ARROW");
+-   ("/xe2/xa4/xbb", "BOTTOM ARC ANTICLOCKWISE ARROW");
+-   ("/xe2/xa4/xbc", "TOP ARC CLOCKWISE ARROW WITH MINUS");
+-   ("/xe2/xa4/xbd", "TOP ARC ANTICLOCKWISE ARROW WITH PLUS");
+-   ("/xe2/xa4/xbe", "LOWER RIGHT SEMICIRCULAR CLOCKWISE ARROW");
+-   ("/xe2/xa4/xbf", "LOWER LEFT SEMICIRCULAR ANTICLOCKWISE ARROW");
+-   ("/xe2/xa5/x80", "ANTICLOCKWISE CLOSED CIRCLE ARROW");
+-   ("/xe2/xa5/x81", "CLOCKWISE CLOSED CIRCLE ARROW");
+-   ("/xe2/xa5/x82", "RIGHTWARDS ARROW ABOVE SHORT LEFTWARDS ARROW");
+-   ("/xe2/xa5/x83", "LEFTWARDS ARROW ABOVE SHORT RIGHTWARDS ARROW");
+-   ("/xe2/xa5/x84", "SHORT RIGHTWARDS ARROW ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xa5/x85", "RIGHTWARDS ARROW WITH PLUS BELOW");
+-   ("/xe2/xa5/x86", "LEFTWARDS ARROW WITH PLUS BELOW");
+-   ("/xe2/xa5/x87", "RIGHTWARDS ARROW THROUGH X");
+    ("/xe2/xa5/x88", "LEFT RIGHT ARROW THROUGH SMALL CIRCLE");
+    ("/xe2/xa5/x89", "UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE");
+-   ("/xe2/xa5/x8a", "LEFT BARB UP RIGHT BARB DOWN HARPOON");
+-   ("/xe2/xa5/x8b", "LEFT BARB DOWN RIGHT BARB UP HARPOON");
+-   ("/xe2/xa5/x8c", "UP BARB RIGHT DOWN BARB LEFT HARPOON");
+-   ("/xe2/xa5/x8d", "UP BARB LEFT DOWN BARB RIGHT HARPOON");
+-   ("/xe2/xa5/x8e", "LEFT BARB UP RIGHT BARB UP HARPOON");
+-   ("/xe2/xa5/x8f", "UP BARB RIGHT DOWN BARB RIGHT HARPOON");
+-   ("/xe2/xa5/x90", "LEFT BARB DOWN RIGHT BARB DOWN HARPOON");
+-   ("/xe2/xa5/x91", "UP BARB LEFT DOWN BARB LEFT HARPOON");
+-   ("/xe2/xa5/x92", "LEFTWARDS HARPOON WITH BARB UP TO BAR");
+-   ("/xe2/xa5/x93", "RIGHTWARDS HARPOON WITH BARB UP TO BAR");
+-   ("/xe2/xa5/x94", "UPWARDS HARPOON WITH BARB RIGHT TO BAR");
+-   ("/xe2/xa5/x95", "DOWNWARDS HARPOON WITH BARB RIGHT TO BAR");
+-   ("/xe2/xa5/x96", "LEFTWARDS HARPOON WITH BARB DOWN TO BAR");
+-   ("/xe2/xa5/x97", "RIGHTWARDS HARPOON WITH BARB DOWN TO BAR");
+-   ("/xe2/xa5/x98", "UPWARDS HARPOON WITH BARB LEFT TO BAR");
+-   ("/xe2/xa5/x99", "DOWNWARDS HARPOON WITH BARB LEFT TO BAR");
+-   ("/xe2/xa5/x9a", "LEFTWARDS HARPOON WITH BARB UP FROM BAR");
+-   ("/xe2/xa5/x9b", "RIGHTWARDS HARPOON WITH BARB UP FROM BAR");
+-   ("/xe2/xa5/x9c", "UPWARDS HARPOON WITH BARB RIGHT FROM BAR");
+-   ("/xe2/xa5/x9d", "DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR");
+-   ("/xe2/xa5/x9e", "LEFTWARDS HARPOON WITH BARB DOWN FROM BAR");
+-   ("/xe2/xa5/x9f", "RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR");
+-   ("/xe2/xa5/xa0", "UPWARDS HARPOON WITH BARB LEFT FROM BAR");
+-   ("/xe2/xa5/xa1", "DOWNWARDS HARPOON WITH BARB LEFT FROM BAR");
+-   ("/xe2/xa5/xa2", "LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN");
+-   ("/xe2/xa5/xa3", "UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT");
+-   ("/xe2/xa5/xa4", "RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN");
+-   ("/xe2/xa5/xa5", "DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT");
+-   ("/xe2/xa5/xa6", "LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP");
+-   ("/xe2/xa5/xa7", "LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN");
+-   ("/xe2/xa5/xa8", "RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP");
+-   ("/xe2/xa5/xa9", "RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN");
+-   ("/xe2/xa5/xaa", "LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH");
+-   ("/xe2/xa5/xab", "LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH");
+-   ("/xe2/xa5/xac", "RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH");
+-   ("/xe2/xa5/xad", "RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH");
+-   ("/xe2/xa5/xae", "UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT");
+-   ("/xe2/xa5/xaf", "DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT");
+-   ("/xe2/xa5/xb0", "RIGHT DOUBLE ARROW WITH ROUNDED HEAD");
+-   ("/xe2/xa5/xb1", "EQUALS SIGN ABOVE RIGHTWARDS ARROW");
+-   ("/xe2/xa5/xb2", "TILDE OPERATOR ABOVE RIGHTWARDS ARROW");
+-   ("/xe2/xa5/xb3", "LEFTWARDS ARROW ABOVE TILDE OPERATOR");
+-   ("/xe2/xa5/xb4", "RIGHTWARDS ARROW ABOVE TILDE OPERATOR");
+-   ("/xe2/xa5/xb5", "RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xa5/xb6", "LESS-THAN ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xa5/xb7", "LEFTWARDS ARROW THROUGH LESS-THAN");
+-   ("/xe2/xa5/xb8", "GREATER-THAN ABOVE RIGHTWARDS ARROW");
+-   ("/xe2/xa5/xb9", "SUBSET ABOVE RIGHTWARDS ARROW");
+-   ("/xe2/xa5/xba", "LEFTWARDS ARROW THROUGH SUBSET");
+-   ("/xe2/xa5/xbb", "SUPERSET ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xa5/xbc", "LEFT FISH TAIL");
+-   ("/xe2/xa5/xbd", "RIGHT FISH TAIL");
+-   ("/xe2/xa5/xbe", "UP FISH TAIL");
+-   ("/xe2/xa5/xbf", "DOWN FISH TAIL");
+-   ("/xe2/xa6/x80", "TRIPLE VERTICAL BAR DELIMITER");
+-   ("/xe2/xa6/x81", "Z NOTATION SPOT");
+-   ("/xe2/xa6/x82", "Z NOTATION TYPE COLON");
+-   ("/xe2/xa6/x83", "LEFT WHITE CURLY BRACKET");
+-   ("/xe2/xa6/x84", "RIGHT WHITE CURLY BRACKET");
+-   ("/xe2/xa6/x85", "LEFT WHITE PARENTHESIS");
+-   ("/xe2/xa6/x86", "RIGHT WHITE PARENTHESIS");
+-   ("/xe2/xa6/x87", "Z NOTATION LEFT IMAGE BRACKET");
+-   ("/xe2/xa6/x88", "Z NOTATION RIGHT IMAGE BRACKET");
+-   ("/xe2/xa6/x89", "Z NOTATION LEFT BINDING BRACKET");
+-   ("/xe2/xa6/x8a", "Z NOTATION RIGHT BINDING BRACKET");
+-   ("/xe2/xa6/x8b", "LEFT SQUARE BRACKET WITH UNDERBAR");
+-   ("/xe2/xa6/x8c", "RIGHT SQUARE BRACKET WITH UNDERBAR");
+-   ("/xe2/xa6/x8d", "LEFT SQUARE BRACKET WITH TICK IN TOP CORNER");
+-   ("/xe2/xa6/x8e", "RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER");
+-   ("/xe2/xa6/x8f", "LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER");
+-   ("/xe2/xa6/x90", "RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER");
+-   ("/xe2/xa6/x91", "LEFT ANGLE BRACKET WITH DOT");
+-   ("/xe2/xa6/x92", "RIGHT ANGLE BRACKET WITH DOT");
+-   ("/xe2/xa6/x93", "LEFT ARC LESS-THAN BRACKET");
+-   ("/xe2/xa6/x94", "RIGHT ARC GREATER-THAN BRACKET");
+-   ("/xe2/xa6/x95", "DOUBLE LEFT ARC GREATER-THAN BRACKET");
+-   ("/xe2/xa6/x96", "DOUBLE RIGHT ARC LESS-THAN BRACKET");
+-   ("/xe2/xa6/x97", "LEFT BLACK TORTOISE SHELL BRACKET");
+-   ("/xe2/xa6/x98", "RIGHT BLACK TORTOISE SHELL BRACKET");
+-   ("/xe2/xa6/x99", "DOTTED FENCE");
+-   ("/xe2/xa6/x9a", "VERTICAL ZIGZAG LINE");
+-   ("/xe2/xa6/x9b", "MEASURED ANGLE OPENING LEFT");
+-   ("/xe2/xa6/x9c", "RIGHT ANGLE VARIANT WITH SQUARE");
+-   ("/xe2/xa6/x9d", "MEASURED RIGHT ANGLE WITH DOT");
+-   ("/xe2/xa6/x9e", "ANGLE WITH S INSIDE");
+-   ("/xe2/xa6/x9f", "ACUTE ANGLE");
+-   ("/xe2/xa6/xa0", "SPHERICAL ANGLE OPENING LEFT");
+-   ("/xe2/xa6/xa1", "SPHERICAL ANGLE OPENING UP");
+-   ("/xe2/xa6/xa2", "TURNED ANGLE");
+-   ("/xe2/xa6/xa3", "REVERSED ANGLE");
+-   ("/xe2/xa6/xa4", "ANGLE WITH UNDERBAR");
+-   ("/xe2/xa6/xa5", "REVERSED ANGLE WITH UNDERBAR");
+-   ("/xe2/xa6/xa6", "OBLIQUE ANGLE OPENING UP");
+-   ("/xe2/xa6/xa7", "OBLIQUE ANGLE OPENING DOWN");
+-   ("/xe2/xa6/xa8", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT");
+-   ("/xe2/xa6/xa9", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT");
+-   ("/xe2/xa6/xaa", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT");
+-   ("/xe2/xa6/xab", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT");
+-   ("/xe2/xa6/xac", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP");
+-   ("/xe2/xa6/xad", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP");
+-   ("/xe2/xa6/xae", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN");
+-   ("/xe2/xa6/xaf", "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN");
+-   ("/xe2/xa6/xb0", "REVERSED EMPTY SET");
+-   ("/xe2/xa6/xb1", "EMPTY SET WITH OVERBAR");
+    ("/xe2/xa6/xb2", "EMPTY SET WITH SMALL CIRCLE ABOVE");
+-   ("/xe2/xa6/xb3", "EMPTY SET WITH RIGHT ARROW ABOVE");
+-   ("/xe2/xa6/xb4", "EMPTY SET WITH LEFT ARROW ABOVE");
+-   ("/xe2/xa6/xb5", "CIRCLE WITH HORIZONTAL BAR");
+-   ("/xe2/xa6/xb6", "CIRCLED VERTICAL BAR");
+-   ("/xe2/xa6/xb7", "CIRCLED PARALLEL");
+-   ("/xe2/xa6/xb8", "CIRCLED REVERSE SOLIDUS");
+-   ("/xe2/xa6/xb9", "CIRCLED PERPENDICULAR");
+-   ("/xe2/xa6/xba", "CIRCLE DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BAR");
+-   ("/xe2/xa6/xbb", "CIRCLE WITH SUPERIMPOSED X");
+-   ("/xe2/xa6/xbc", "CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN");
+-   ("/xe2/xa6/xbd", "UP ARROW THROUGH CIRCLE");
+-   ("/xe2/xa6/xbe", "CIRCLED WHITE BULLET");
+-   ("/xe2/xa6/xbf", "CIRCLED BULLET");
+-   ("/xe2/xa7/x80", "CIRCLED LESS-THAN");
+-   ("/xe2/xa7/x81", "CIRCLED GREATER-THAN");
+    ("/xe2/xa7/x82", "CIRCLE WITH SMALL CIRCLE TO THE RIGHT");
+-   ("/xe2/xa7/x83", "CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT");
+-   ("/xe2/xa7/x84", "SQUARED RISING DIAGONAL SLASH");
+-   ("/xe2/xa7/x85", "SQUARED FALLING DIAGONAL SLASH");
+-   ("/xe2/xa7/x86", "SQUARED ASTERISK");
+    ("/xe2/xa7/x87", "SQUARED SMALL CIRCLE");
+-   ("/xe2/xa7/x88", "SQUARED SQUARE");
+-   ("/xe2/xa7/x89", "TWO JOINED SQUARES");
+-   ("/xe2/xa7/x8a", "TRIANGLE WITH DOT ABOVE");
+-   ("/xe2/xa7/x8b", "TRIANGLE WITH UNDERBAR");
+-   ("/xe2/xa7/x8c", "S IN TRIANGLE");
+-   ("/xe2/xa7/x8d", "TRIANGLE WITH SERIFS AT BOTTOM");
+-   ("/xe2/xa7/x8e", "RIGHT TRIANGLE ABOVE LEFT TRIANGLE");
+-   ("/xe2/xa7/x8f", "LEFT TRIANGLE BESIDE VERTICAL BAR");
+-   ("/xe2/xa7/x90", "VERTICAL BAR BESIDE RIGHT TRIANGLE");
+-   ("/xe2/xa7/x91", "BOWTIE WITH LEFT HALF BLACK");
+-   ("/xe2/xa7/x92", "BOWTIE WITH RIGHT HALF BLACK");
+-   ("/xe2/xa7/x93", "BLACK BOWTIE");
+-   ("/xe2/xa7/x94", "TIMES WITH LEFT HALF BLACK");
+-   ("/xe2/xa7/x95", "TIMES WITH RIGHT HALF BLACK");
+-   ("/xe2/xa7/x96", "WHITE HOURGLASS");
+-   ("/xe2/xa7/x97", "BLACK HOURGLASS");
+-   ("/xe2/xa7/x98", "LEFT WIGGLY FENCE");
+-   ("/xe2/xa7/x99", "RIGHT WIGGLY FENCE");
+-   ("/xe2/xa7/x9a", "LEFT DOUBLE WIGGLY FENCE");
+-   ("/xe2/xa7/x9b", "RIGHT DOUBLE WIGGLY FENCE");
+-   ("/xe2/xa7/x9c", "INCOMPLETE INFINITY");
+-   ("/xe2/xa7/x9d", "TIE OVER INFINITY");
+-   ("/xe2/xa7/x9e", "INFINITY NEGATED WITH VERTICAL BAR");
+-   ("/xe2/xa7/x9f", "DOUBLE-ENDED MULTIMAP");
+-   ("/xe2/xa7/xa0", "SQUARE WITH CONTOURED OUTLINE");
+-   ("/xe2/xa7/xa1", "INCREASES AS");
+-   ("/xe2/xa7/xa2", "SHUFFLE PRODUCT");
+-   ("/xe2/xa7/xa3", "EQUALS SIGN AND SLANTED PARALLEL");
+-   ("/xe2/xa7/xa4", "EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE");
+-   ("/xe2/xa7/xa5", "IDENTICAL TO AND SLANTED PARALLEL");
+-   ("/xe2/xa7/xa6", "GLEICH STARK");
+-   ("/xe2/xa7/xa7", "THERMODYNAMIC");
+-   ("/xe2/xa7/xa8", "DOWN-POINTING TRIANGLE WITH LEFT HALF BLACK");
+-   ("/xe2/xa7/xa9", "DOWN-POINTING TRIANGLE WITH RIGHT HALF BLACK");
+-   ("/xe2/xa7/xaa", "BLACK DIAMOND WITH DOWN ARROW");
+-   ("/xe2/xa7/xab", "BLACK LOZENGE");
+-   ("/xe2/xa7/xac", "WHITE CIRCLE WITH DOWN ARROW");
+-   ("/xe2/xa7/xad", "BLACK CIRCLE WITH DOWN ARROW");
+-   ("/xe2/xa7/xae", "ERROR-BARRED WHITE SQUARE");
+-   ("/xe2/xa7/xaf", "ERROR-BARRED BLACK SQUARE");
+-   ("/xe2/xa7/xb0", "ERROR-BARRED WHITE DIAMOND");
+-   ("/xe2/xa7/xb1", "ERROR-BARRED BLACK DIAMOND");
+-   ("/xe2/xa7/xb2", "ERROR-BARRED WHITE CIRCLE");
+-   ("/xe2/xa7/xb3", "ERROR-BARRED BLACK CIRCLE");
+-   ("/xe2/xa7/xb4", "RULE-DELAYED");
+-   ("/xe2/xa7/xb5", "REVERSE SOLIDUS OPERATOR");
+-   ("/xe2/xa7/xb6", "SOLIDUS WITH OVERBAR");
+-   ("/xe2/xa7/xb7", "REVERSE SOLIDUS WITH HORIZONTAL STROKE");
+-   ("/xe2/xa7/xb8", "BIG SOLIDUS");
+-   ("/xe2/xa7/xb9", "BIG REVERSE SOLIDUS");
+-   ("/xe2/xa7/xba", "DOUBLE PLUS");
+-   ("/xe2/xa7/xbb", "TRIPLE PLUS");
+-   ("/xe2/xa7/xbc", "LEFT-POINTING CURVED ANGLE BRACKET");
+-   ("/xe2/xa7/xbd", "RIGHT-POINTING CURVED ANGLE BRACKET");
+-   ("/xe2/xa7/xbe", "TINY");
+-   ("/xe2/xa7/xbf", "MINY");
+-   ("/xe2/xa8/x80", "N-ARY CIRCLED DOT OPERATOR");
+-   ("/xe2/xa8/x81", "N-ARY CIRCLED PLUS OPERATOR");
+-   ("/xe2/xa8/x82", "N-ARY CIRCLED TIMES OPERATOR");
+-   ("/xe2/xa8/x83", "N-ARY UNION OPERATOR WITH DOT");
+-   ("/xe2/xa8/x84", "N-ARY UNION OPERATOR WITH PLUS");
+-   ("/xe2/xa8/x85", "N-ARY SQUARE INTERSECTION OPERATOR");
+-   ("/xe2/xa8/x86", "N-ARY SQUARE UNION OPERATOR");
+-   ("/xe2/xa8/x87", "TWO LOGICAL AND OPERATOR");
+-   ("/xe2/xa8/x88", "TWO LOGICAL OR OPERATOR");
+-   ("/xe2/xa8/x89", "N-ARY TIMES OPERATOR");
+-   ("/xe2/xa8/x8a", "MODULO TWO SUM");
+-   ("/xe2/xa8/x8b", "SUMMATION WITH INTEGRAL");
+-   ("/xe2/xa8/x8c", "QUADRUPLE INTEGRAL OPERATOR");
+-   ("/xe2/xa8/x8d", "FINITE PART INTEGRAL");
+-   ("/xe2/xa8/x8e", "INTEGRAL WITH DOUBLE STROKE");
+-   ("/xe2/xa8/x8f", "INTEGRAL AVERAGE WITH SLASH");
+-   ("/xe2/xa8/x90", "CIRCULATION FUNCTION");
+-   ("/xe2/xa8/x91", "ANTICLOCKWISE INTEGRATION");
+-   ("/xe2/xa8/x92", "LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE");
+-   ("/xe2/xa8/x93", "LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE");
+-   ("/xe2/xa8/x94", "LINE INTEGRATION NOT INCLUDING THE POLE");
+-   ("/xe2/xa8/x95", "INTEGRAL AROUND A POINT OPERATOR");
+-   ("/xe2/xa8/x96", "QUATERNION INTEGRAL OPERATOR");
+-   ("/xe2/xa8/x97", "INTEGRAL WITH LEFTWARDS ARROW WITH HOOK");
+-   ("/xe2/xa8/x98", "INTEGRAL WITH TIMES SIGN");
+-   ("/xe2/xa8/x99", "INTEGRAL WITH INTERSECTION");
+-   ("/xe2/xa8/x9a", "INTEGRAL WITH UNION");
+-   ("/xe2/xa8/x9b", "INTEGRAL WITH OVERBAR");
+-   ("/xe2/xa8/x9c", "INTEGRAL WITH UNDERBAR");
+-   ("/xe2/xa8/x9d", "JOIN");
+-   ("/xe2/xa8/x9e", "LARGE LEFT TRIANGLE OPERATOR");
+-   ("/xe2/xa8/x9f", "Z NOTATION SCHEMA COMPOSITION");
+-   ("/xe2/xa8/xa0", "Z NOTATION SCHEMA PIPING");
+-   ("/xe2/xa8/xa1", "Z NOTATION SCHEMA PROJECTION");
+    ("/xe2/xa8/xa2", "PLUS SIGN WITH SMALL CIRCLE ABOVE");
+-   ("/xe2/xa8/xa3", "PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE");
+-   ("/xe2/xa8/xa4", "PLUS SIGN WITH TILDE ABOVE");
+-   ("/xe2/xa8/xa5", "PLUS SIGN WITH DOT BELOW");
+-   ("/xe2/xa8/xa6", "PLUS SIGN WITH TILDE BELOW");
+-   ("/xe2/xa8/xa7", "PLUS SIGN WITH SUBSCRIPT TWO");
+-   ("/xe2/xa8/xa8", "PLUS SIGN WITH BLACK TRIANGLE");
+-   ("/xe2/xa8/xa9", "MINUS SIGN WITH COMMA ABOVE");
+-   ("/xe2/xa8/xaa", "MINUS SIGN WITH DOT BELOW");
+-   ("/xe2/xa8/xab", "MINUS SIGN WITH FALLING DOTS");
+-   ("/xe2/xa8/xac", "MINUS SIGN WITH RISING DOTS");
+-   ("/xe2/xa8/xad", "PLUS SIGN IN LEFT HALF CIRCLE");
+-   ("/xe2/xa8/xae", "PLUS SIGN IN RIGHT HALF CIRCLE");
+-   ("/xe2/xa8/xaf", "VECTOR OR CROSS PRODUCT");
+-   ("/xe2/xa8/xb0", "MULTIPLICATION SIGN WITH DOT ABOVE");
+-   ("/xe2/xa8/xb1", "MULTIPLICATION SIGN WITH UNDERBAR");
+-   ("/xe2/xa8/xb2", "SEMIDIRECT PRODUCT WITH BOTTOM CLOSED");
+-   ("/xe2/xa8/xb3", "SMASH PRODUCT");
+-   ("/xe2/xa8/xb4", "MULTIPLICATION SIGN IN LEFT HALF CIRCLE");
+-   ("/xe2/xa8/xb5", "MULTIPLICATION SIGN IN RIGHT HALF CIRCLE");
+-   ("/xe2/xa8/xb6", "CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT");
+-   ("/xe2/xa8/xb7", "MULTIPLICATION SIGN IN DOUBLE CIRCLE");
+-   ("/xe2/xa8/xb8", "CIRCLED DIVISION SIGN");
+-   ("/xe2/xa8/xb9", "PLUS SIGN IN TRIANGLE");
+-   ("/xe2/xa8/xba", "MINUS SIGN IN TRIANGLE");
+-   ("/xe2/xa8/xbb", "MULTIPLICATION SIGN IN TRIANGLE");
+-   ("/xe2/xa8/xbc", "INTERIOR PRODUCT");
+-   ("/xe2/xa8/xbd", "RIGHTHAND INTERIOR PRODUCT");
+-   ("/xe2/xa8/xbe", "Z NOTATION RELATIONAL COMPOSITION");
+-   ("/xe2/xa8/xbf", "AMALGAMATION OR COPRODUCT");
+-   ("/xe2/xa9/x80", "INTERSECTION WITH DOT");
+-   ("/xe2/xa9/x81", "UNION WITH MINUS SIGN");
+-   ("/xe2/xa9/x82", "UNION WITH OVERBAR");
+-   ("/xe2/xa9/x83", "INTERSECTION WITH OVERBAR");
+-   ("/xe2/xa9/x84", "INTERSECTION WITH LOGICAL AND");
+-   ("/xe2/xa9/x85", "UNION WITH LOGICAL OR");
+-   ("/xe2/xa9/x86", "UNION ABOVE INTERSECTION");
+-   ("/xe2/xa9/x87", "INTERSECTION ABOVE UNION");
+-   ("/xe2/xa9/x88", "UNION ABOVE BAR ABOVE INTERSECTION");
+-   ("/xe2/xa9/x89", "INTERSECTION ABOVE BAR ABOVE UNION");
+-   ("/xe2/xa9/x8a", "UNION BESIDE AND JOINED WITH UNION");
+-   ("/xe2/xa9/x8b", "INTERSECTION BESIDE AND JOINED WITH INTERSECTION");
+-   ("/xe2/xa9/x8c", "CLOSED UNION WITH SERIFS");
+-   ("/xe2/xa9/x8d", "CLOSED INTERSECTION WITH SERIFS");
+-   ("/xe2/xa9/x8e", "DOUBLE SQUARE INTERSECTION");
+-   ("/xe2/xa9/x8f", "DOUBLE SQUARE UNION");
+-   ("/xe2/xa9/x90", "CLOSED UNION WITH SERIFS AND SMASH PRODUCT");
+-   ("/xe2/xa9/x91", "LOGICAL AND WITH DOT ABOVE");
+-   ("/xe2/xa9/x92", "LOGICAL OR WITH DOT ABOVE");
+-   ("/xe2/xa9/x93", "DOUBLE LOGICAL AND");
+-   ("/xe2/xa9/x94", "DOUBLE LOGICAL OR");
+-   ("/xe2/xa9/x95", "TWO INTERSECTING LOGICAL AND");
+-   ("/xe2/xa9/x96", "TWO INTERSECTING LOGICAL OR");
+-   ("/xe2/xa9/x97", "SLOPING LARGE OR");
+-   ("/xe2/xa9/x98", "SLOPING LARGE AND");
+-   ("/xe2/xa9/x99", "LOGICAL OR OVERLAPPING LOGICAL AND");
+-   ("/xe2/xa9/x9a", "LOGICAL AND WITH MIDDLE STEM");
+-   ("/xe2/xa9/x9b", "LOGICAL OR WITH MIDDLE STEM");
+-   ("/xe2/xa9/x9c", "LOGICAL AND WITH HORIZONTAL DASH");
+-   ("/xe2/xa9/x9d", "LOGICAL OR WITH HORIZONTAL DASH");
+-   ("/xe2/xa9/x9e", "LOGICAL AND WITH DOUBLE OVERBAR");
+-   ("/xe2/xa9/x9f", "LOGICAL AND WITH UNDERBAR");
+-   ("/xe2/xa9/xa0", "LOGICAL AND WITH DOUBLE UNDERBAR");
+    ("/xe2/xa9/xa1", "SMALL VEE WITH UNDERBAR");
+-   ("/xe2/xa9/xa2", "LOGICAL OR WITH DOUBLE OVERBAR");
+-   ("/xe2/xa9/xa3", "LOGICAL OR WITH DOUBLE UNDERBAR");
+-   ("/xe2/xa9/xa4", "Z NOTATION DOMAIN ANTIRESTRICTION");
+-   ("/xe2/xa9/xa5", "Z NOTATION RANGE ANTIRESTRICTION");
+-   ("/xe2/xa9/xa6", "EQUALS SIGN WITH DOT BELOW");
+-   ("/xe2/xa9/xa7", "IDENTICAL WITH DOT ABOVE");
+-   ("/xe2/xa9/xa8", "TRIPLE HORIZONTAL BAR WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xa9/xa9", "TRIPLE HORIZONTAL BAR WITH TRIPLE VERTICAL STROKE");
+-   ("/xe2/xa9/xaa", "TILDE OPERATOR WITH DOT ABOVE");
+-   ("/xe2/xa9/xab", "TILDE OPERATOR WITH RISING DOTS");
+-   ("/xe2/xa9/xac", "SIMILAR MINUS SIMILAR");
+-   ("/xe2/xa9/xad", "CONGRUENT WITH DOT ABOVE");
+-   ("/xe2/xa9/xae", "EQUALS WITH ASTERISK");
+-   ("/xe2/xa9/xaf", "ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT");
+-   ("/xe2/xa9/xb0", "APPROXIMATELY EQUAL OR EQUAL TO");
+-   ("/xe2/xa9/xb1", "EQUALS SIGN ABOVE PLUS SIGN");
+-   ("/xe2/xa9/xb2", "PLUS SIGN ABOVE EQUALS SIGN");
+-   ("/xe2/xa9/xb3", "EQUALS SIGN ABOVE TILDE OPERATOR");
+-   ("/xe2/xa9/xb4", "DOUBLE COLON EQUAL");
+-   ("/xe2/xa9/xb5", "TWO CONSECUTIVE EQUALS SIGNS");
+-   ("/xe2/xa9/xb6", "THREE CONSECUTIVE EQUALS SIGNS");
+-   ("/xe2/xa9/xb7", "EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW");
+-   ("/xe2/xa9/xb8", "EQUIVALENT WITH FOUR DOTS ABOVE");
+-   ("/xe2/xa9/xb9", "LESS-THAN WITH CIRCLE INSIDE");
+-   ("/xe2/xa9/xba", "GREATER-THAN WITH CIRCLE INSIDE");
+-   ("/xe2/xa9/xbb", "LESS-THAN WITH QUESTION MARK ABOVE");
+-   ("/xe2/xa9/xbc", "GREATER-THAN WITH QUESTION MARK ABOVE");
+-   ("/xe2/xa9/xbd", "LESS-THAN OR SLANTED EQUAL TO");
+-   ("/xe2/xa9/xbe", "GREATER-THAN OR SLANTED EQUAL TO");
+-   ("/xe2/xa9/xbf", "LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE");
+-   ("/xe2/xaa/x80", "GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE");
+-   ("/xe2/xaa/x81", "LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE");
+-   ("/xe2/xaa/x82", "GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE");
+-   ("/xe2/xaa/x83", "LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT");
+-   ("/xe2/xaa/x84", "GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT");
+-   ("/xe2/xaa/x85", "LESS-THAN OR APPROXIMATE");
+-   ("/xe2/xaa/x86", "GREATER-THAN OR APPROXIMATE");
+-   ("/xe2/xaa/x87", "LESS-THAN AND SINGLE-LINE NOT EQUAL TO");
+-   ("/xe2/xaa/x88", "GREATER-THAN AND SINGLE-LINE NOT EQUAL TO");
+-   ("/xe2/xaa/x89", "LESS-THAN AND NOT APPROXIMATE");
+-   ("/xe2/xaa/x8a", "GREATER-THAN AND NOT APPROXIMATE");
+-   ("/xe2/xaa/x8b", "LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN");
+-   ("/xe2/xaa/x8c", "GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN");
+-   ("/xe2/xaa/x8d", "LESS-THAN ABOVE SIMILAR OR EQUAL");
+-   ("/xe2/xaa/x8e", "GREATER-THAN ABOVE SIMILAR OR EQUAL");
+-   ("/xe2/xaa/x8f", "LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN");
+-   ("/xe2/xaa/x90", "GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN");
+-   ("/xe2/xaa/x91", "LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL");
+-   ("/xe2/xaa/x92", "GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL");
+-   ("/xe2/xaa/x93", "LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL");
+-   ("/xe2/xaa/x94", "GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL");
+-   ("/xe2/xaa/x95", "SLANTED EQUAL TO OR LESS-THAN");
+-   ("/xe2/xaa/x96", "SLANTED EQUAL TO OR GREATER-THAN");
+-   ("/xe2/xaa/x97", "SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE");
+-   ("/xe2/xaa/x98", "SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE");
+-   ("/xe2/xaa/x99", "DOUBLE-LINE EQUAL TO OR LESS-THAN");
+-   ("/xe2/xaa/x9a", "DOUBLE-LINE EQUAL TO OR GREATER-THAN");
+-   ("/xe2/xaa/x9b", "DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN");
+-   ("/xe2/xaa/x9c", "DOUBLE-LINE SLANTED EQUAL TO OR GREATER-THAN");
+-   ("/xe2/xaa/x9d", "SIMILAR OR LESS-THAN");
+-   ("/xe2/xaa/x9e", "SIMILAR OR GREATER-THAN");
+-   ("/xe2/xaa/x9f", "SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN");
+-   ("/xe2/xaa/xa0", "SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN");
+-   ("/xe2/xaa/xa1", "DOUBLE NESTED LESS-THAN");
+-   ("/xe2/xaa/xa2", "DOUBLE NESTED GREATER-THAN");
+-   ("/xe2/xaa/xa3", "DOUBLE NESTED LESS-THAN WITH UNDERBAR");
+-   ("/xe2/xaa/xa4", "GREATER-THAN OVERLAPPING LESS-THAN");
+-   ("/xe2/xaa/xa5", "GREATER-THAN BESIDE LESS-THAN");
+-   ("/xe2/xaa/xa6", "LESS-THAN CLOSED BY CURVE");
+-   ("/xe2/xaa/xa7", "GREATER-THAN CLOSED BY CURVE");
+-   ("/xe2/xaa/xa8", "LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL");
+-   ("/xe2/xaa/xa9", "GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL");
+    ("/xe2/xaa/xaa", "SMALLER THAN");
+-   ("/xe2/xaa/xab", "LARGER THAN");
+    ("/xe2/xaa/xac", "SMALLER THAN OR EQUAL TO");
+-   ("/xe2/xaa/xad", "LARGER THAN OR EQUAL TO");
+-   ("/xe2/xaa/xae", "EQUALS SIGN WITH BUMPY ABOVE");
+-   ("/xe2/xaa/xaf", "PRECEDES ABOVE SINGLE-LINE EQUALS SIGN");
+-   ("/xe2/xaa/xb0", "SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN");
+-   ("/xe2/xaa/xb1", "PRECEDES ABOVE SINGLE-LINE NOT EQUAL TO");
+-   ("/xe2/xaa/xb2", "SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO");
+-   ("/xe2/xaa/xb3", "PRECEDES ABOVE EQUALS SIGN");
+-   ("/xe2/xaa/xb4", "SUCCEEDS ABOVE EQUALS SIGN");
+-   ("/xe2/xaa/xb5", "PRECEDES ABOVE NOT EQUAL TO");
+-   ("/xe2/xaa/xb6", "SUCCEEDS ABOVE NOT EQUAL TO");
+-   ("/xe2/xaa/xb7", "PRECEDES ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xaa/xb8", "SUCCEEDS ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xaa/xb9", "PRECEDES ABOVE NOT ALMOST EQUAL TO");
+-   ("/xe2/xaa/xba", "SUCCEEDS ABOVE NOT ALMOST EQUAL TO");
+-   ("/xe2/xaa/xbb", "DOUBLE PRECEDES");
+-   ("/xe2/xaa/xbc", "DOUBLE SUCCEEDS");
+-   ("/xe2/xaa/xbd", "SUBSET WITH DOT");
+-   ("/xe2/xaa/xbe", "SUPERSET WITH DOT");
+-   ("/xe2/xaa/xbf", "SUBSET WITH PLUS SIGN BELOW");
+-   ("/xe2/xab/x80", "SUPERSET WITH PLUS SIGN BELOW");
+-   ("/xe2/xab/x81", "SUBSET WITH MULTIPLICATION SIGN BELOW");
+-   ("/xe2/xab/x82", "SUPERSET WITH MULTIPLICATION SIGN BELOW");
+-   ("/xe2/xab/x83", "SUBSET OF OR EQUAL TO WITH DOT ABOVE");
+-   ("/xe2/xab/x84", "SUPERSET OF OR EQUAL TO WITH DOT ABOVE");
+-   ("/xe2/xab/x85", "SUBSET OF ABOVE EQUALS SIGN");
+-   ("/xe2/xab/x86", "SUPERSET OF ABOVE EQUALS SIGN");
+-   ("/xe2/xab/x87", "SUBSET OF ABOVE TILDE OPERATOR");
+-   ("/xe2/xab/x88", "SUPERSET OF ABOVE TILDE OPERATOR");
+-   ("/xe2/xab/x89", "SUBSET OF ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xab/x8a", "SUPERSET OF ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xab/x8b", "SUBSET OF ABOVE NOT EQUAL TO");
+-   ("/xe2/xab/x8c", "SUPERSET OF ABOVE NOT EQUAL TO");
+-   ("/xe2/xab/x8d", "SQUARE LEFT OPEN BOX OPERATOR");
+-   ("/xe2/xab/x8e", "SQUARE RIGHT OPEN BOX OPERATOR");
+-   ("/xe2/xab/x8f", "CLOSED SUBSET");
+-   ("/xe2/xab/x90", "CLOSED SUPERSET");
+-   ("/xe2/xab/x91", "CLOSED SUBSET OR EQUAL TO");
+-   ("/xe2/xab/x92", "CLOSED SUPERSET OR EQUAL TO");
+-   ("/xe2/xab/x93", "SUBSET ABOVE SUPERSET");
+-   ("/xe2/xab/x94", "SUPERSET ABOVE SUBSET");
+-   ("/xe2/xab/x95", "SUBSET ABOVE SUBSET");
+-   ("/xe2/xab/x96", "SUPERSET ABOVE SUPERSET");
+-   ("/xe2/xab/x97", "SUPERSET BESIDE SUBSET");
+-   ("/xe2/xab/x98", "SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET");
+-   ("/xe2/xab/x99", "ELEMENT OF OPENING DOWNWARDS");
+-   ("/xe2/xab/x9a", "PITCHFORK WITH TEE TOP");
+-   ("/xe2/xab/x9b", "TRANSVERSAL INTERSECTION");
+-   ("/xe2/xab/x9c", "FORKING");
+-   ("/xe2/xab/x9d", "NONFORKING");
+-   ("/xe2/xab/x9e", "SHORT LEFT TACK");
+-   ("/xe2/xab/x9f", "SHORT DOWN TACK");
+-   ("/xe2/xab/xa0", "SHORT UP TACK");
+-   ("/xe2/xab/xa1", "PERPENDICULAR WITH S");
+-   ("/xe2/xab/xa2", "VERTICAL BAR TRIPLE RIGHT TURNSTILE");
+-   ("/xe2/xab/xa3", "DOUBLE VERTICAL BAR LEFT TURNSTILE");
+-   ("/xe2/xab/xa4", "VERTICAL BAR DOUBLE LEFT TURNSTILE");
+-   ("/xe2/xab/xa5", "DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE");
+-   ("/xe2/xab/xa6", "LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL");
+-   ("/xe2/xab/xa7", "SHORT DOWN TACK WITH OVERBAR");
+-   ("/xe2/xab/xa8", "SHORT UP TACK WITH UNDERBAR");
+-   ("/xe2/xab/xa9", "SHORT UP TACK ABOVE SHORT DOWN TACK");
+-   ("/xe2/xab/xaa", "DOUBLE DOWN TACK");
+-   ("/xe2/xab/xab", "DOUBLE UP TACK");
+-   ("/xe2/xab/xac", "DOUBLE STROKE NOT SIGN");
+-   ("/xe2/xab/xad", "REVERSED DOUBLE STROKE NOT SIGN");
+-   ("/xe2/xab/xae", "DOES NOT DIVIDE WITH REVERSED NEGATION SLASH");
+-   ("/xe2/xab/xaf", "VERTICAL LINE WITH CIRCLE ABOVE");
+-   ("/xe2/xab/xb0", "VERTICAL LINE WITH CIRCLE BELOW");
+-   ("/xe2/xab/xb1", "DOWN TACK WITH CIRCLE BELOW");
+-   ("/xe2/xab/xb2", "PARALLEL WITH HORIZONTAL STROKE");
+-   ("/xe2/xab/xb3", "PARALLEL WITH TILDE OPERATOR");
+-   ("/xe2/xab/xb4", "TRIPLE VERTICAL BAR BINARY RELATION");
+-   ("/xe2/xab/xb5", "TRIPLE VERTICAL BAR WITH HORIZONTAL STROKE");
+-   ("/xe2/xab/xb6", "TRIPLE COLON OPERATOR");
+-   ("/xe2/xab/xb7", "TRIPLE NESTED LESS-THAN");
+-   ("/xe2/xab/xb8", "TRIPLE NESTED GREATER-THAN");
+-   ("/xe2/xab/xb9", "DOUBLE-LINE SLANTED LESS-THAN OR EQUAL TO");
+-   ("/xe2/xab/xba", "DOUBLE-LINE SLANTED GREATER-THAN OR EQUAL TO");
+-   ("/xe2/xab/xbb", "TRIPLE SOLIDUS BINARY RELATION");
+-   ("/xe2/xab/xbc", "LARGE TRIPLE VERTICAL BAR OPERATOR");
+-   ("/xe2/xab/xbd", "DOUBLE SOLIDUS OPERATOR");
+-   ("/xe2/xab/xbe", "WHITE VERTICAL BAR");
+-   ("/xe2/xab/xbf", "N-ARY WHITE VERTICAL BAR");
+-   ("/xe2/xac/x80", "NORTH EAST WHITE ARROW");
+-   ("/xe2/xac/x81", "NORTH WEST WHITE ARROW");
+-   ("/xe2/xac/x82", "SOUTH EAST WHITE ARROW");
+-   ("/xe2/xac/x83", "SOUTH WEST WHITE ARROW");
+-   ("/xe2/xac/x84", "LEFT RIGHT WHITE ARROW");
+-   ("/xe2/xac/x85", "LEFTWARDS BLACK ARROW");
+-   ("/xe2/xac/x86", "UPWARDS BLACK ARROW");
+-   ("/xe2/xac/x87", "DOWNWARDS BLACK ARROW");
+-   ("/xe2/xac/x88", "NORTH EAST BLACK ARROW");
+-   ("/xe2/xac/x89", "NORTH WEST BLACK ARROW");
+-   ("/xe2/xac/x8a", "SOUTH EAST BLACK ARROW");
+-   ("/xe2/xac/x8b", "SOUTH WEST BLACK ARROW");
+-   ("/xe2/xac/x8c", "LEFT RIGHT BLACK ARROW");
+-   ("/xe2/xac/x8d", "UP DOWN BLACK ARROW");
+-   ("/xe2/xac/x8e", "RIGHTWARDS ARROW WITH TIP DOWNWARDS");
+-   ("/xe2/xac/x8f", "RIGHTWARDS ARROW WITH TIP UPWARDS");
+-   ("/xe2/xac/x90", "LEFTWARDS ARROW WITH TIP DOWNWARDS");
+-   ("/xe2/xac/x91", "LEFTWARDS ARROW WITH TIP UPWARDS");
+-   ("/xe2/xac/x92", "SQUARE WITH TOP HALF BLACK");
+-   ("/xe2/xac/x93", "SQUARE WITH BOTTOM HALF BLACK");
+-   ("/xe2/xac/x94", "SQUARE WITH UPPER RIGHT DIAGONAL HALF BLACK");
+-   ("/xe2/xac/x95", "SQUARE WITH LOWER LEFT DIAGONAL HALF BLACK");
+-   ("/xe2/xac/x96", "DIAMOND WITH LEFT HALF BLACK");
+-   ("/xe2/xac/x97", "DIAMOND WITH RIGHT HALF BLACK");
+-   ("/xe2/xac/x98", "DIAMOND WITH TOP HALF BLACK");
+-   ("/xe2/xac/x99", "DIAMOND WITH BOTTOM HALF BLACK");
+-   ("/xe2/xac/x9a", "DOTTED SQUARE");
+-   ("/xe2/xac/x9b", "BLACK LARGE SQUARE");
+-   ("/xe2/xac/x9c", "WHITE LARGE SQUARE");
+    ("/xe2/xac/x9d", "BLACK VERY SMALL SQUARE");
+    ("/xe2/xac/x9e", "WHITE VERY SMALL SQUARE");
+-   ("/xe2/xac/x9f", "BLACK PENTAGON");
+-   ("/xe2/xac/xa0", "WHITE PENTAGON");
+-   ("/xe2/xac/xa1", "WHITE HEXAGON");
+-   ("/xe2/xac/xa2", "BLACK HEXAGON");
+-   ("/xe2/xac/xa3", "HORIZONTAL BLACK HEXAGON");
+-   ("/xe2/xac/xa4", "BLACK LARGE CIRCLE");
+-   ("/xe2/xac/xa5", "BLACK MEDIUM DIAMOND");
+-   ("/xe2/xac/xa6", "WHITE MEDIUM DIAMOND");
+-   ("/xe2/xac/xa7", "BLACK MEDIUM LOZENGE");
+-   ("/xe2/xac/xa8", "WHITE MEDIUM LOZENGE");
+    ("/xe2/xac/xa9", "BLACK SMALL DIAMOND");
+    ("/xe2/xac/xaa", "BLACK SMALL LOZENGE");
+    ("/xe2/xac/xab", "WHITE SMALL LOZENGE");
+-   ("/xe2/xac/xac", "BLACK HORIZONTAL ELLIPSE");
+-   ("/xe2/xac/xad", "WHITE HORIZONTAL ELLIPSE");
+-   ("/xe2/xac/xae", "BLACK VERTICAL ELLIPSE");
+-   ("/xe2/xac/xaf", "WHITE VERTICAL ELLIPSE");
+    ("/xe2/xac/xb0", "LEFT ARROW WITH SMALL CIRCLE");
+-   ("/xe2/xac/xb1", "THREE LEFTWARDS ARROWS");
+-   ("/xe2/xac/xb2", "LEFT ARROW WITH CIRCLED PLUS");
+-   ("/xe2/xac/xb3", "LONG LEFTWARDS SQUIGGLE ARROW");
+-   ("/xe2/xac/xb4", "LEFTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE");
+-   ("/xe2/xac/xb5", "LEFTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xac/xb6", "LEFTWARDS TWO-HEADED ARROW FROM BAR");
+-   ("/xe2/xac/xb7", "LEFTWARDS TWO-HEADED TRIPLE DASH ARROW");
+-   ("/xe2/xac/xb8", "LEFTWARDS ARROW WITH DOTTED STEM");
+-   ("/xe2/xac/xb9", "LEFTWARDS ARROW WITH TAIL WITH VERTICAL STROKE");
+-   ("/xe2/xac/xba", "LEFTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xac/xbb", "LEFTWARDS TWO-HEADED ARROW WITH TAIL");
+-   ("/xe2/xac/xbc", "LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE");
+-   ("/xe2/xac/xbd", "LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE");
+-   ("/xe2/xac/xbe", "LEFTWARDS ARROW THROUGH X");
+-   ("/xe2/xac/xbf", "WAVE ARROW POINTING DIRECTLY LEFT");
+-   ("/xe2/xad/x80", "EQUALS SIGN ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xad/x81", "REVERSE TILDE OPERATOR ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xad/x82", "LEFTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO");
+-   ("/xe2/xad/x83", "RIGHTWARDS ARROW THROUGH GREATER-THAN");
+-   ("/xe2/xad/x84", "RIGHTWARDS ARROW THROUGH SUPERSET");
+-   ("/xe2/xad/x85", "LEFTWARDS QUADRUPLE ARROW");
+-   ("/xe2/xad/x86", "RIGHTWARDS QUADRUPLE ARROW");
+-   ("/xe2/xad/x87", "REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW");
+-   ("/xe2/xad/x88", "RIGHTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO");
+-   ("/xe2/xad/x89", "TILDE OPERATOR ABOVE LEFTWARDS ARROW");
+-   ("/xe2/xad/x8a", "LEFTWARDS ARROW ABOVE ALMOST EQUAL TO");
+-   ("/xe2/xad/x8b", "LEFTWARDS ARROW ABOVE REVERSE TILDE OPERATOR");
+-   ("/xe2/xad/x8c", "RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR");
+-   ("/xe2/xad/x90", "WHITE MEDIUM STAR");
+    ("/xe2/xad/x91", "BLACK SMALL STAR");
+    ("/xe2/xad/x92", "WHITE SMALL STAR");
+-   ("/xe2/xad/x93", "BLACK RIGHT-POINTING PENTAGON");
+-   ("/xe2/xad/x94", "WHITE RIGHT-POINTING PENTAGON");
+    ("/xe2/xb0/x80", "GLAGOLITIC CAPITAL LETTER AZU");
+    ("/xe2/xb0/x81", "GLAGOLITIC CAPITAL LETTER BUKY");
+    ("/xe2/xb0/x82", "GLAGOLITIC CAPITAL LETTER VEDE");
+@@ -9393,20 +2210,6 @@
+    ("/xe2/xb3/xa1", "COPTIC SMALL LETTER OLD NUBIAN NYI");
+    ("/xe2/xb3/xa2", "COPTIC CAPITAL LETTER OLD NUBIAN WAU");
+    ("/xe2/xb3/xa3", "COPTIC SMALL LETTER OLD NUBIAN WAU");
+-   ("/xe2/xb3/xa4", "COPTIC SYMBOL KAI");
+-   ("/xe2/xb3/xa5", "COPTIC SYMBOL MI RO");
+-   ("/xe2/xb3/xa6", "COPTIC SYMBOL PI RO");
+-   ("/xe2/xb3/xa7", "COPTIC SYMBOL STAUROS");
+-   ("/xe2/xb3/xa8", "COPTIC SYMBOL TAU RO");
+-   ("/xe2/xb3/xa9", "COPTIC SYMBOL KHI RO");
+-   ("/xe2/xb3/xaa", "COPTIC SYMBOL SHIMA SIMA");
+-   ("/xe2/xb3/xb9", "COPTIC OLD NUBIAN FULL STOP");
+-   ("/xe2/xb3/xba", "COPTIC OLD NUBIAN DIRECT QUESTION MARK");
+-   ("/xe2/xb3/xbb", "COPTIC OLD NUBIAN INDIRECT QUESTION MARK");
+-   ("/xe2/xb3/xbc", "COPTIC OLD NUBIAN VERSE DIVIDER");
+-   ("/xe2/xb3/xbd", "COPTIC FRACTION ONE HALF");
+-   ("/xe2/xb3/xbe", "COPTIC FULL STOP");
+-   ("/xe2/xb3/xbf", "COPTIC MORPHOLOGICAL DIVIDER");
+    ("/xe2/xb4/x80", "GEORGIAN SMALL LETTER AN");
+    ("/xe2/xb4/x81", "GEORGIAN SMALL LETTER BAN");
+    ("/xe2/xb4/x82", "GEORGIAN SMALL LETTER GAN");
+@@ -9445,1026 +2248,33 @@
+    ("/xe2/xb4/xa3", "GEORGIAN SMALL LETTER WE");
+    ("/xe2/xb4/xa4", "GEORGIAN SMALL LETTER HAR");
+    ("/xe2/xb4/xa5", "GEORGIAN SMALL LETTER HOE");
+-   ("/xe2/xb4/xb0", "TIFINAGH LETTER YA");
+-   ("/xe2/xb4/xb1", "TIFINAGH LETTER YAB");
+-   ("/xe2/xb4/xb2", "TIFINAGH LETTER YABH");
+-   ("/xe2/xb4/xb3", "TIFINAGH LETTER YAG");
+-   ("/xe2/xb4/xb4", "TIFINAGH LETTER YAGHH");
+-   ("/xe2/xb4/xb5", "TIFINAGH LETTER BERBER ACADEMY YAJ");
+-   ("/xe2/xb4/xb6", "TIFINAGH LETTER YAJ");
+-   ("/xe2/xb4/xb7", "TIFINAGH LETTER YAD");
+-   ("/xe2/xb4/xb8", "TIFINAGH LETTER YADH");
+-   ("/xe2/xb4/xb9", "TIFINAGH LETTER YADD");
+-   ("/xe2/xb4/xba", "TIFINAGH LETTER YADDH");
+-   ("/xe2/xb4/xbb", "TIFINAGH LETTER YEY");
+-   ("/xe2/xb4/xbc", "TIFINAGH LETTER YAF");
+-   ("/xe2/xb4/xbd", "TIFINAGH LETTER YAK");
+-   ("/xe2/xb4/xbe", "TIFINAGH LETTER TUAREG YAK");
+-   ("/xe2/xb4/xbf", "TIFINAGH LETTER YAKHH");
+-   ("/xe2/xb5/x80", "TIFINAGH LETTER YAH");
+-   ("/xe2/xb5/x81", "TIFINAGH LETTER BERBER ACADEMY YAH");
+-   ("/xe2/xb5/x82", "TIFINAGH LETTER TUAREG YAH");
+-   ("/xe2/xb5/x83", "TIFINAGH LETTER YAHH");
+-   ("/xe2/xb5/x84", "TIFINAGH LETTER YAA");
+-   ("/xe2/xb5/x85", "TIFINAGH LETTER YAKH");
+-   ("/xe2/xb5/x86", "TIFINAGH LETTER TUAREG YAKH");
+-   ("/xe2/xb5/x87", "TIFINAGH LETTER YAQ");
+-   ("/xe2/xb5/x88", "TIFINAGH LETTER TUAREG YAQ");
+-   ("/xe2/xb5/x89", "TIFINAGH LETTER YI");
+-   ("/xe2/xb5/x8a", "TIFINAGH LETTER YAZH");
+-   ("/xe2/xb5/x8b", "TIFINAGH LETTER AHAGGAR YAZH");
+-   ("/xe2/xb5/x8c", "TIFINAGH LETTER TUAREG YAZH");
+-   ("/xe2/xb5/x8d", "TIFINAGH LETTER YAL");
+-   ("/xe2/xb5/x8e", "TIFINAGH LETTER YAM");
+-   ("/xe2/xb5/x8f", "TIFINAGH LETTER YAN");
+-   ("/xe2/xb5/x90", "TIFINAGH LETTER TUAREG YAGN");
+-   ("/xe2/xb5/x91", "TIFINAGH LETTER TUAREG YANG");
+-   ("/xe2/xb5/x92", "TIFINAGH LETTER YAP");
+-   ("/xe2/xb5/x93", "TIFINAGH LETTER YU");
+-   ("/xe2/xb5/x94", "TIFINAGH LETTER YAR");
+-   ("/xe2/xb5/x95", "TIFINAGH LETTER YARR");
+-   ("/xe2/xb5/x96", "TIFINAGH LETTER YAGH");
+-   ("/xe2/xb5/x97", "TIFINAGH LETTER TUAREG YAGH");
+-   ("/xe2/xb5/x98", "TIFINAGH LETTER AYER YAGH");
+-   ("/xe2/xb5/x99", "TIFINAGH LETTER YAS");
+-   ("/xe2/xb5/x9a", "TIFINAGH LETTER YASS");
+-   ("/xe2/xb5/x9b", "TIFINAGH LETTER YASH");
+-   ("/xe2/xb5/x9c", "TIFINAGH LETTER YAT");
+-   ("/xe2/xb5/x9d", "TIFINAGH LETTER YATH");
+-   ("/xe2/xb5/x9e", "TIFINAGH LETTER YACH");
+-   ("/xe2/xb5/x9f", "TIFINAGH LETTER YATT");
+-   ("/xe2/xb5/xa0", "TIFINAGH LETTER YAV");
+-   ("/xe2/xb5/xa1", "TIFINAGH LETTER YAW");
+-   ("/xe2/xb5/xa2", "TIFINAGH LETTER YAY");
+-   ("/xe2/xb5/xa3", "TIFINAGH LETTER YAZ");
+-   ("/xe2/xb5/xa4", "TIFINAGH LETTER TAWELLEMET YAZ");
+-   ("/xe2/xb5/xa5", "TIFINAGH LETTER YAZZ");
+-   ("/xe2/xb5/xaf", "TIFINAGH MODIFIER LETTER LABIALIZATION MARK");
+-   ("/xe2/xb6/x80", "ETHIOPIC SYLLABLE LOA");
+-   ("/xe2/xb6/x81", "ETHIOPIC SYLLABLE MOA");
+-   ("/xe2/xb6/x82", "ETHIOPIC SYLLABLE ROA");
+-   ("/xe2/xb6/x83", "ETHIOPIC SYLLABLE SOA");
+-   ("/xe2/xb6/x84", "ETHIOPIC SYLLABLE SHOA");
+-   ("/xe2/xb6/x85", "ETHIOPIC SYLLABLE BOA");
+-   ("/xe2/xb6/x86", "ETHIOPIC SYLLABLE TOA");
+-   ("/xe2/xb6/x87", "ETHIOPIC SYLLABLE COA");
+-   ("/xe2/xb6/x88", "ETHIOPIC SYLLABLE NOA");
+-   ("/xe2/xb6/x89", "ETHIOPIC SYLLABLE NYOA");
+-   ("/xe2/xb6/x8a", "ETHIOPIC SYLLABLE GLOTTAL OA");
+-   ("/xe2/xb6/x8b", "ETHIOPIC SYLLABLE ZOA");
+-   ("/xe2/xb6/x8c", "ETHIOPIC SYLLABLE DOA");
+-   ("/xe2/xb6/x8d", "ETHIOPIC SYLLABLE DDOA");
+-   ("/xe2/xb6/x8e", "ETHIOPIC SYLLABLE JOA");
+-   ("/xe2/xb6/x8f", "ETHIOPIC SYLLABLE THOA");
+-   ("/xe2/xb6/x90", "ETHIOPIC SYLLABLE CHOA");
+-   ("/xe2/xb6/x91", "ETHIOPIC SYLLABLE PHOA");
+-   ("/xe2/xb6/x92", "ETHIOPIC SYLLABLE POA");
+-   ("/xe2/xb6/x93", "ETHIOPIC SYLLABLE GGWA");
+-   ("/xe2/xb6/x94", "ETHIOPIC SYLLABLE GGWI");
+-   ("/xe2/xb6/x95", "ETHIOPIC SYLLABLE GGWEE");
+-   ("/xe2/xb6/x96", "ETHIOPIC SYLLABLE GGWE");
+-   ("/xe2/xb6/xa0", "ETHIOPIC SYLLABLE SSA");
+-   ("/xe2/xb6/xa1", "ETHIOPIC SYLLABLE SSU");
+-   ("/xe2/xb6/xa2", "ETHIOPIC SYLLABLE SSI");
+-   ("/xe2/xb6/xa3", "ETHIOPIC SYLLABLE SSAA");
+-   ("/xe2/xb6/xa4", "ETHIOPIC SYLLABLE SSEE");
+-   ("/xe2/xb6/xa5", "ETHIOPIC SYLLABLE SSE");
+-   ("/xe2/xb6/xa6", "ETHIOPIC SYLLABLE SSO");
+-   ("/xe2/xb6/xa8", "ETHIOPIC SYLLABLE CCA");
+-   ("/xe2/xb6/xa9", "ETHIOPIC SYLLABLE CCU");
+-   ("/xe2/xb6/xaa", "ETHIOPIC SYLLABLE CCI");
+-   ("/xe2/xb6/xab", "ETHIOPIC SYLLABLE CCAA");
+-   ("/xe2/xb6/xac", "ETHIOPIC SYLLABLE CCEE");
+-   ("/xe2/xb6/xad", "ETHIOPIC SYLLABLE CCE");
+-   ("/xe2/xb6/xae", "ETHIOPIC SYLLABLE CCO");
+-   ("/xe2/xb6/xb0", "ETHIOPIC SYLLABLE ZZA");
+-   ("/xe2/xb6/xb1", "ETHIOPIC SYLLABLE ZZU");
+-   ("/xe2/xb6/xb2", "ETHIOPIC SYLLABLE ZZI");
+-   ("/xe2/xb6/xb3", "ETHIOPIC SYLLABLE ZZAA");
+-   ("/xe2/xb6/xb4", "ETHIOPIC SYLLABLE ZZEE");
+-   ("/xe2/xb6/xb5", "ETHIOPIC SYLLABLE ZZE");
+-   ("/xe2/xb6/xb6", "ETHIOPIC SYLLABLE ZZO");
+-   ("/xe2/xb6/xb8", "ETHIOPIC SYLLABLE CCHA");
+-   ("/xe2/xb6/xb9", "ETHIOPIC SYLLABLE CCHU");
+-   ("/xe2/xb6/xba", "ETHIOPIC SYLLABLE CCHI");
+-   ("/xe2/xb6/xbb", "ETHIOPIC SYLLABLE CCHAA");
+-   ("/xe2/xb6/xbc", "ETHIOPIC SYLLABLE CCHEE");
+-   ("/xe2/xb6/xbd", "ETHIOPIC SYLLABLE CCHE");
+-   ("/xe2/xb6/xbe", "ETHIOPIC SYLLABLE CCHO");
+-   ("/xe2/xb7/x80", "ETHIOPIC SYLLABLE QYA");
+-   ("/xe2/xb7/x81", "ETHIOPIC SYLLABLE QYU");
+-   ("/xe2/xb7/x82", "ETHIOPIC SYLLABLE QYI");
+-   ("/xe2/xb7/x83", "ETHIOPIC SYLLABLE QYAA");
+-   ("/xe2/xb7/x84", "ETHIOPIC SYLLABLE QYEE");
+-   ("/xe2/xb7/x85", "ETHIOPIC SYLLABLE QYE");
+-   ("/xe2/xb7/x86", "ETHIOPIC SYLLABLE QYO");
+-   ("/xe2/xb7/x88", "ETHIOPIC SYLLABLE KYA");
+-   ("/xe2/xb7/x89", "ETHIOPIC SYLLABLE KYU");
+-   ("/xe2/xb7/x8a", "ETHIOPIC SYLLABLE KYI");
+-   ("/xe2/xb7/x8b", "ETHIOPIC SYLLABLE KYAA");
+-   ("/xe2/xb7/x8c", "ETHIOPIC SYLLABLE KYEE");
+-   ("/xe2/xb7/x8d", "ETHIOPIC SYLLABLE KYE");
+-   ("/xe2/xb7/x8e", "ETHIOPIC SYLLABLE KYO");
+-   ("/xe2/xb7/x90", "ETHIOPIC SYLLABLE XYA");
+-   ("/xe2/xb7/x91", "ETHIOPIC SYLLABLE XYU");
+-   ("/xe2/xb7/x92", "ETHIOPIC SYLLABLE XYI");
+-   ("/xe2/xb7/x93", "ETHIOPIC SYLLABLE XYAA");
+-   ("/xe2/xb7/x94", "ETHIOPIC SYLLABLE XYEE");
+-   ("/xe2/xb7/x95", "ETHIOPIC SYLLABLE XYE");
+-   ("/xe2/xb7/x96", "ETHIOPIC SYLLABLE XYO");
+-   ("/xe2/xb7/x98", "ETHIOPIC SYLLABLE GYA");
+-   ("/xe2/xb7/x99", "ETHIOPIC SYLLABLE GYU");
+-   ("/xe2/xb7/x9a", "ETHIOPIC SYLLABLE GYI");
+-   ("/xe2/xb7/x9b", "ETHIOPIC SYLLABLE GYAA");
+-   ("/xe2/xb7/x9c", "ETHIOPIC SYLLABLE GYEE");
+-   ("/xe2/xb7/x9d", "ETHIOPIC SYLLABLE GYE");
+-   ("/xe2/xb7/x9e", "ETHIOPIC SYLLABLE GYO");
+-   ("/xe2/xb7/xa0", "COMBINING CYRILLIC LETTER BE");
+-   ("/xe2/xb7/xa1", "COMBINING CYRILLIC LETTER VE");
+-   ("/xe2/xb7/xa2", "COMBINING CYRILLIC LETTER GHE");
+-   ("/xe2/xb7/xa3", "COMBINING CYRILLIC LETTER DE");
+-   ("/xe2/xb7/xa4", "COMBINING CYRILLIC LETTER ZHE");
+-   ("/xe2/xb7/xa5", "COMBINING CYRILLIC LETTER ZE");
+-   ("/xe2/xb7/xa6", "COMBINING CYRILLIC LETTER KA");
+-   ("/xe2/xb7/xa7", "COMBINING CYRILLIC LETTER EL");
+-   ("/xe2/xb7/xa8", "COMBINING CYRILLIC LETTER EM");
+-   ("/xe2/xb7/xa9", "COMBINING CYRILLIC LETTER EN");
+-   ("/xe2/xb7/xaa", "COMBINING CYRILLIC LETTER O");
+-   ("/xe2/xb7/xab", "COMBINING CYRILLIC LETTER PE");
+-   ("/xe2/xb7/xac", "COMBINING CYRILLIC LETTER ER");
+-   ("/xe2/xb7/xad", "COMBINING CYRILLIC LETTER ES");
+-   ("/xe2/xb7/xae", "COMBINING CYRILLIC LETTER TE");
+-   ("/xe2/xb7/xaf", "COMBINING CYRILLIC LETTER HA");
+-   ("/xe2/xb7/xb0", "COMBINING CYRILLIC LETTER TSE");
+-   ("/xe2/xb7/xb1", "COMBINING CYRILLIC LETTER CHE");
+-   ("/xe2/xb7/xb2", "COMBINING CYRILLIC LETTER SHA");
+-   ("/xe2/xb7/xb3", "COMBINING CYRILLIC LETTER SHCHA");
+-   ("/xe2/xb7/xb4", "COMBINING CYRILLIC LETTER FITA");
+-   ("/xe2/xb7/xb5", "COMBINING CYRILLIC LETTER ES-TE");
+-   ("/xe2/xb7/xb6", "COMBINING CYRILLIC LETTER A");
+-   ("/xe2/xb7/xb7", "COMBINING CYRILLIC LETTER IE");
+-   ("/xe2/xb7/xb8", "COMBINING CYRILLIC LETTER DJERV");
+-   ("/xe2/xb7/xb9", "COMBINING CYRILLIC LETTER MONOGRAPH UK");
+-   ("/xe2/xb7/xba", "COMBINING CYRILLIC LETTER YAT");
+-   ("/xe2/xb7/xbb", "COMBINING CYRILLIC LETTER YU");
+-   ("/xe2/xb7/xbc", "COMBINING CYRILLIC LETTER IOTIFIED A");
+-   ("/xe2/xb7/xbd", "COMBINING CYRILLIC LETTER LITTLE YUS");
+-   ("/xe2/xb7/xbe", "COMBINING CYRILLIC LETTER BIG YUS");
+-   ("/xe2/xb7/xbf", "COMBINING CYRILLIC LETTER IOTIFIED BIG YUS");
+-   ("/xe2/xb8/x80", "RIGHT ANGLE SUBSTITUTION MARKER");
+-   ("/xe2/xb8/x81", "RIGHT ANGLE DOTTED SUBSTITUTION MARKER");
+-   ("/xe2/xb8/x82", "LEFT SUBSTITUTION BRACKET");
+-   ("/xe2/xb8/x83", "RIGHT SUBSTITUTION BRACKET");
+-   ("/xe2/xb8/x84", "LEFT DOTTED SUBSTITUTION BRACKET");
+-   ("/xe2/xb8/x85", "RIGHT DOTTED SUBSTITUTION BRACKET");
+-   ("/xe2/xb8/x86", "RAISED INTERPOLATION MARKER");
+-   ("/xe2/xb8/x87", "RAISED DOTTED INTERPOLATION MARKER");
+-   ("/xe2/xb8/x88", "DOTTED TRANSPOSITION MARKER");
+-   ("/xe2/xb8/x89", "LEFT TRANSPOSITION BRACKET");
+-   ("/xe2/xb8/x8a", "RIGHT TRANSPOSITION BRACKET");
+-   ("/xe2/xb8/x8b", "RAISED SQUARE");
+-   ("/xe2/xb8/x8c", "LEFT RAISED OMISSION BRACKET");
+-   ("/xe2/xb8/x8d", "RIGHT RAISED OMISSION BRACKET");
+-   ("/xe2/xb8/x8e", "EDITORIAL CORONIS");
+-   ("/xe2/xb8/x8f", "PARAGRAPHOS");
+-   ("/xe2/xb8/x90", "FORKED PARAGRAPHOS");
+-   ("/xe2/xb8/x91", "REVERSED FORKED PARAGRAPHOS");
+-   ("/xe2/xb8/x92", "HYPODIASTOLE");
+-   ("/xe2/xb8/x93", "DOTTED OBELOS");
+-   ("/xe2/xb8/x94", "DOWNWARDS ANCORA");
+-   ("/xe2/xb8/x95", "UPWARDS ANCORA");
+-   ("/xe2/xb8/x96", "DOTTED RIGHT-POINTING ANGLE");
+-   ("/xe2/xb8/x97", "DOUBLE OBLIQUE HYPHEN");
+-   ("/xe2/xb8/x98", "INVERTED INTERROBANG");
+-   ("/xe2/xb8/x99", "PALM BRANCH");
+-   ("/xe2/xb8/x9a", "HYPHEN WITH DIAERESIS");
+-   ("/xe2/xb8/x9b", "TILDE WITH RING ABOVE");
+-   ("/xe2/xb8/x9c", "LEFT LOW PARAPHRASE BRACKET");
+-   ("/xe2/xb8/x9d", "RIGHT LOW PARAPHRASE BRACKET");
+-   ("/xe2/xb8/x9e", "TILDE WITH DOT ABOVE");
+-   ("/xe2/xb8/x9f", "TILDE WITH DOT BELOW");
+-   ("/xe2/xb8/xa0", "LEFT VERTICAL BAR WITH QUILL");
+-   ("/xe2/xb8/xa1", "RIGHT VERTICAL BAR WITH QUILL");
+-   ("/xe2/xb8/xa2", "TOP LEFT HALF BRACKET");
+-   ("/xe2/xb8/xa3", "TOP RIGHT HALF BRACKET");
+-   ("/xe2/xb8/xa4", "BOTTOM LEFT HALF BRACKET");
+-   ("/xe2/xb8/xa5", "BOTTOM RIGHT HALF BRACKET");
+-   ("/xe2/xb8/xa6", "LEFT SIDEWAYS U BRACKET");
+-   ("/xe2/xb8/xa7", "RIGHT SIDEWAYS U BRACKET");
+-   ("/xe2/xb8/xa8", "LEFT DOUBLE PARENTHESIS");
+-   ("/xe2/xb8/xa9", "RIGHT DOUBLE PARENTHESIS");
+-   ("/xe2/xb8/xaa", "TWO DOTS OVER ONE DOT PUNCTUATION");
+-   ("/xe2/xb8/xab", "ONE DOT OVER TWO DOTS PUNCTUATION");
+-   ("/xe2/xb8/xac", "SQUARED FOUR DOT PUNCTUATION");
+-   ("/xe2/xb8/xad", "FIVE DOT MARK");
+-   ("/xe2/xb8/xae", "REVERSED QUESTION MARK");
+-   ("/xe2/xb8/xaf", "VERTICAL TILDE");
+-   ("/xe2/xb8/xb0", "RING POINT");
+-   ("/xe2/xba/x80", "CJK RADICAL REPEAT");
+-   ("/xe2/xba/x81", "CJK RADICAL CLIFF");
+-   ("/xe2/xba/x82", "CJK RADICAL SECOND ONE");
+-   ("/xe2/xba/x83", "CJK RADICAL SECOND TWO");
+-   ("/xe2/xba/x84", "CJK RADICAL SECOND THREE");
+-   ("/xe2/xba/x85", "CJK RADICAL PERSON");
+-   ("/xe2/xba/x86", "CJK RADICAL BOX");
+-   ("/xe2/xba/x87", "CJK RADICAL TABLE");
+-   ("/xe2/xba/x88", "CJK RADICAL KNIFE ONE");
+-   ("/xe2/xba/x89", "CJK RADICAL KNIFE TWO");
+-   ("/xe2/xba/x8a", "CJK RADICAL DIVINATION");
+-   ("/xe2/xba/x8b", "CJK RADICAL SEAL");
+    ("/xe2/xba/x8c", "CJK RADICAL SMALL ONE");
+    ("/xe2/xba/x8d", "CJK RADICAL SMALL TWO");
+-   ("/xe2/xba/x8e", "CJK RADICAL LAME ONE");
+-   ("/xe2/xba/x8f", "CJK RADICAL LAME TWO");
+-   ("/xe2/xba/x90", "CJK RADICAL LAME THREE");
+-   ("/xe2/xba/x91", "CJK RADICAL LAME FOUR");
+-   ("/xe2/xba/x92", "CJK RADICAL SNAKE");
+-   ("/xe2/xba/x93", "CJK RADICAL THREAD");
+-   ("/xe2/xba/x94", "CJK RADICAL SNOUT ONE");
+-   ("/xe2/xba/x95", "CJK RADICAL SNOUT TWO");
+-   ("/xe2/xba/x96", "CJK RADICAL HEART ONE");
+-   ("/xe2/xba/x97", "CJK RADICAL HEART TWO");
+-   ("/xe2/xba/x98", "CJK RADICAL HAND");
+-   ("/xe2/xba/x99", "CJK RADICAL RAP");
+-   ("/xe2/xba/x9b", "CJK RADICAL CHOKE");
+-   ("/xe2/xba/x9c", "CJK RADICAL SUN");
+-   ("/xe2/xba/x9d", "CJK RADICAL MOON");
+-   ("/xe2/xba/x9e", "CJK RADICAL DEATH");
+-   ("/xe2/xba/x9f", "CJK RADICAL MOTHER");
+-   ("/xe2/xba/xa0", "CJK RADICAL CIVILIAN");
+-   ("/xe2/xba/xa1", "CJK RADICAL WATER ONE");
+-   ("/xe2/xba/xa2", "CJK RADICAL WATER TWO");
+-   ("/xe2/xba/xa3", "CJK RADICAL FIRE");
+-   ("/xe2/xba/xa4", "CJK RADICAL PAW ONE");
+-   ("/xe2/xba/xa5", "CJK RADICAL PAW TWO");
+-   ("/xe2/xba/xa6", "CJK RADICAL SIMPLIFIED HALF TREE TRUNK");
+-   ("/xe2/xba/xa7", "CJK RADICAL COW");
+-   ("/xe2/xba/xa8", "CJK RADICAL DOG");
+-   ("/xe2/xba/xa9", "CJK RADICAL JADE");
+-   ("/xe2/xba/xaa", "CJK RADICAL BOLT OF CLOTH");
+-   ("/xe2/xba/xab", "CJK RADICAL EYE");
+-   ("/xe2/xba/xac", "CJK RADICAL SPIRIT ONE");
+-   ("/xe2/xba/xad", "CJK RADICAL SPIRIT TWO");
+-   ("/xe2/xba/xae", "CJK RADICAL BAMBOO");
+-   ("/xe2/xba/xaf", "CJK RADICAL SILK");
+-   ("/xe2/xba/xb0", "CJK RADICAL C-SIMPLIFIED SILK");
+-   ("/xe2/xba/xb1", "CJK RADICAL NET ONE");
+-   ("/xe2/xba/xb2", "CJK RADICAL NET TWO");
+-   ("/xe2/xba/xb3", "CJK RADICAL NET THREE");
+-   ("/xe2/xba/xb4", "CJK RADICAL NET FOUR");
+-   ("/xe2/xba/xb5", "CJK RADICAL MESH");
+-   ("/xe2/xba/xb6", "CJK RADICAL SHEEP");
+-   ("/xe2/xba/xb7", "CJK RADICAL RAM");
+-   ("/xe2/xba/xb8", "CJK RADICAL EWE");
+-   ("/xe2/xba/xb9", "CJK RADICAL OLD");
+-   ("/xe2/xba/xba", "CJK RADICAL BRUSH ONE");
+-   ("/xe2/xba/xbb", "CJK RADICAL BRUSH TWO");
+-   ("/xe2/xba/xbc", "CJK RADICAL MEAT");
+-   ("/xe2/xba/xbd", "CJK RADICAL MORTAR");
+-   ("/xe2/xba/xbe", "CJK RADICAL GRASS ONE");
+-   ("/xe2/xba/xbf", "CJK RADICAL GRASS TWO");
+-   ("/xe2/xbb/x80", "CJK RADICAL GRASS THREE");
+-   ("/xe2/xbb/x81", "CJK RADICAL TIGER");
+-   ("/xe2/xbb/x82", "CJK RADICAL CLOTHES");
+-   ("/xe2/xbb/x83", "CJK RADICAL WEST ONE");
+-   ("/xe2/xbb/x84", "CJK RADICAL WEST TWO");
+-   ("/xe2/xbb/x85", "CJK RADICAL C-SIMPLIFIED SEE");
+-   ("/xe2/xbb/x86", "CJK RADICAL SIMPLIFIED HORN");
+-   ("/xe2/xbb/x87", "CJK RADICAL HORN");
+-   ("/xe2/xbb/x88", "CJK RADICAL C-SIMPLIFIED SPEECH");
+-   ("/xe2/xbb/x89", "CJK RADICAL C-SIMPLIFIED SHELL");
+-   ("/xe2/xbb/x8a", "CJK RADICAL FOOT");
+-   ("/xe2/xbb/x8b", "CJK RADICAL C-SIMPLIFIED CART");
+-   ("/xe2/xbb/x8c", "CJK RADICAL SIMPLIFIED WALK");
+-   ("/xe2/xbb/x8d", "CJK RADICAL WALK ONE");
+-   ("/xe2/xbb/x8e", "CJK RADICAL WALK TWO");
+-   ("/xe2/xbb/x8f", "CJK RADICAL CITY");
+-   ("/xe2/xbb/x90", "CJK RADICAL C-SIMPLIFIED GOLD");
+-   ("/xe2/xbb/x91", "CJK RADICAL LONG ONE");
+-   ("/xe2/xbb/x92", "CJK RADICAL LONG TWO");
+-   ("/xe2/xbb/x93", "CJK RADICAL C-SIMPLIFIED LONG");
+-   ("/xe2/xbb/x94", "CJK RADICAL C-SIMPLIFIED GATE");
+-   ("/xe2/xbb/x95", "CJK RADICAL MOUND ONE");
+-   ("/xe2/xbb/x96", "CJK RADICAL MOUND TWO");
+-   ("/xe2/xbb/x97", "CJK RADICAL RAIN");
+-   ("/xe2/xbb/x98", "CJK RADICAL BLUE");
+-   ("/xe2/xbb/x99", "CJK RADICAL C-SIMPLIFIED TANNED LEATHER");
+-   ("/xe2/xbb/x9a", "CJK RADICAL C-SIMPLIFIED LEAF");
+-   ("/xe2/xbb/x9b", "CJK RADICAL C-SIMPLIFIED WIND");
+-   ("/xe2/xbb/x9c", "CJK RADICAL C-SIMPLIFIED FLY");
+-   ("/xe2/xbb/x9d", "CJK RADICAL EAT ONE");
+-   ("/xe2/xbb/x9e", "CJK RADICAL EAT TWO");
+-   ("/xe2/xbb/x9f", "CJK RADICAL EAT THREE");
+-   ("/xe2/xbb/xa0", "CJK RADICAL C-SIMPLIFIED EAT");
+-   ("/xe2/xbb/xa1", "CJK RADICAL HEAD");
+-   ("/xe2/xbb/xa2", "CJK RADICAL C-SIMPLIFIED HORSE");
+-   ("/xe2/xbb/xa3", "CJK RADICAL BONE");
+-   ("/xe2/xbb/xa4", "CJK RADICAL GHOST");
+-   ("/xe2/xbb/xa5", "CJK RADICAL C-SIMPLIFIED FISH");
+-   ("/xe2/xbb/xa6", "CJK RADICAL C-SIMPLIFIED BIRD");
+-   ("/xe2/xbb/xa7", "CJK RADICAL C-SIMPLIFIED SALT");
+-   ("/xe2/xbb/xa8", "CJK RADICAL SIMPLIFIED WHEAT");
+-   ("/xe2/xbb/xa9", "CJK RADICAL SIMPLIFIED YELLOW");
+-   ("/xe2/xbb/xaa", "CJK RADICAL C-SIMPLIFIED FROG");
+-   ("/xe2/xbb/xab", "CJK RADICAL J-SIMPLIFIED EVEN");
+-   ("/xe2/xbb/xac", "CJK RADICAL C-SIMPLIFIED EVEN");
+-   ("/xe2/xbb/xad", "CJK RADICAL J-SIMPLIFIED TOOTH");
+-   ("/xe2/xbb/xae", "CJK RADICAL C-SIMPLIFIED TOOTH");
+-   ("/xe2/xbb/xaf", "CJK RADICAL J-SIMPLIFIED DRAGON");
+-   ("/xe2/xbb/xb0", "CJK RADICAL C-SIMPLIFIED DRAGON");
+-   ("/xe2/xbb/xb1", "CJK RADICAL TURTLE");
+-   ("/xe2/xbb/xb2", "CJK RADICAL J-SIMPLIFIED TURTLE");
+-   ("/xe2/xbb/xb3", "CJK RADICAL C-SIMPLIFIED TURTLE");
+-   ("/xe2/xbc/x80", "KANGXI RADICAL ONE");
+-   ("/xe2/xbc/x81", "KANGXI RADICAL LINE");
+-   ("/xe2/xbc/x82", "KANGXI RADICAL DOT");
+-   ("/xe2/xbc/x83", "KANGXI RADICAL SLASH");
+-   ("/xe2/xbc/x84", "KANGXI RADICAL SECOND");
+-   ("/xe2/xbc/x85", "KANGXI RADICAL HOOK");
+-   ("/xe2/xbc/x86", "KANGXI RADICAL TWO");
+-   ("/xe2/xbc/x87", "KANGXI RADICAL LID");
+-   ("/xe2/xbc/x88", "KANGXI RADICAL MAN");
+-   ("/xe2/xbc/x89", "KANGXI RADICAL LEGS");
+-   ("/xe2/xbc/x8a", "KANGXI RADICAL ENTER");
+-   ("/xe2/xbc/x8b", "KANGXI RADICAL EIGHT");
+-   ("/xe2/xbc/x8c", "KANGXI RADICAL DOWN BOX");
+-   ("/xe2/xbc/x8d", "KANGXI RADICAL COVER");
+-   ("/xe2/xbc/x8e", "KANGXI RADICAL ICE");
+-   ("/xe2/xbc/x8f", "KANGXI RADICAL TABLE");
+-   ("/xe2/xbc/x90", "KANGXI RADICAL OPEN BOX");
+-   ("/xe2/xbc/x91", "KANGXI RADICAL KNIFE");
+-   ("/xe2/xbc/x92", "KANGXI RADICAL POWER");
+-   ("/xe2/xbc/x93", "KANGXI RADICAL WRAP");
+-   ("/xe2/xbc/x94", "KANGXI RADICAL SPOON");
+-   ("/xe2/xbc/x95", "KANGXI RADICAL RIGHT OPEN BOX");
+-   ("/xe2/xbc/x96", "KANGXI RADICAL HIDING ENCLOSURE");
+-   ("/xe2/xbc/x97", "KANGXI RADICAL TEN");
+-   ("/xe2/xbc/x98", "KANGXI RADICAL DIVINATION");
+-   ("/xe2/xbc/x99", "KANGXI RADICAL SEAL");
+-   ("/xe2/xbc/x9a", "KANGXI RADICAL CLIFF");
+-   ("/xe2/xbc/x9b", "KANGXI RADICAL PRIVATE");
+-   ("/xe2/xbc/x9c", "KANGXI RADICAL AGAIN");
+-   ("/xe2/xbc/x9d", "KANGXI RADICAL MOUTH");
+-   ("/xe2/xbc/x9e", "KANGXI RADICAL ENCLOSURE");
+-   ("/xe2/xbc/x9f", "KANGXI RADICAL EARTH");
+-   ("/xe2/xbc/xa0", "KANGXI RADICAL SCHOLAR");
+-   ("/xe2/xbc/xa1", "KANGXI RADICAL GO");
+-   ("/xe2/xbc/xa2", "KANGXI RADICAL GO SLOWLY");
+-   ("/xe2/xbc/xa3", "KANGXI RADICAL EVENING");
+-   ("/xe2/xbc/xa4", "KANGXI RADICAL BIG");
+-   ("/xe2/xbc/xa5", "KANGXI RADICAL WOMAN");
+-   ("/xe2/xbc/xa6", "KANGXI RADICAL CHILD");
+-   ("/xe2/xbc/xa7", "KANGXI RADICAL ROOF");
+-   ("/xe2/xbc/xa8", "KANGXI RADICAL INCH");
+    ("/xe2/xbc/xa9", "KANGXI RADICAL SMALL");
+-   ("/xe2/xbc/xaa", "KANGXI RADICAL LAME");
+-   ("/xe2/xbc/xab", "KANGXI RADICAL CORPSE");
+-   ("/xe2/xbc/xac", "KANGXI RADICAL SPROUT");
+-   ("/xe2/xbc/xad", "KANGXI RADICAL MOUNTAIN");
+-   ("/xe2/xbc/xae", "KANGXI RADICAL RIVER");
+-   ("/xe2/xbc/xaf", "KANGXI RADICAL WORK");
+-   ("/xe2/xbc/xb0", "KANGXI RADICAL ONESELF");
+-   ("/xe2/xbc/xb1", "KANGXI RADICAL TURBAN");
+-   ("/xe2/xbc/xb2", "KANGXI RADICAL DRY");
+-   ("/xe2/xbc/xb3", "KANGXI RADICAL SHORT THREAD");
+-   ("/xe2/xbc/xb4", "KANGXI RADICAL DOTTED CLIFF");
+-   ("/xe2/xbc/xb5", "KANGXI RADICAL LONG STRIDE");
+-   ("/xe2/xbc/xb6", "KANGXI RADICAL TWO HANDS");
+-   ("/xe2/xbc/xb7", "KANGXI RADICAL SHOOT");
+-   ("/xe2/xbc/xb8", "KANGXI RADICAL BOW");
+-   ("/xe2/xbc/xb9", "KANGXI RADICAL SNOUT");
+-   ("/xe2/xbc/xba", "KANGXI RADICAL BRISTLE");
+-   ("/xe2/xbc/xbb", "KANGXI RADICAL STEP");
+-   ("/xe2/xbc/xbc", "KANGXI RADICAL HEART");
+-   ("/xe2/xbc/xbd", "KANGXI RADICAL HALBERD");
+-   ("/xe2/xbc/xbe", "KANGXI RADICAL DOOR");
+-   ("/xe2/xbc/xbf", "KANGXI RADICAL HAND");
+-   ("/xe2/xbd/x80", "KANGXI RADICAL BRANCH");
+-   ("/xe2/xbd/x81", "KANGXI RADICAL RAP");
+-   ("/xe2/xbd/x82", "KANGXI RADICAL SCRIPT");
+-   ("/xe2/xbd/x83", "KANGXI RADICAL DIPPER");
+-   ("/xe2/xbd/x84", "KANGXI RADICAL AXE");
+-   ("/xe2/xbd/x85", "KANGXI RADICAL SQUARE");
+-   ("/xe2/xbd/x86", "KANGXI RADICAL NOT");
+-   ("/xe2/xbd/x87", "KANGXI RADICAL SUN");
+-   ("/xe2/xbd/x88", "KANGXI RADICAL SAY");
+-   ("/xe2/xbd/x89", "KANGXI RADICAL MOON");
+-   ("/xe2/xbd/x8a", "KANGXI RADICAL TREE");
+-   ("/xe2/xbd/x8b", "KANGXI RADICAL LACK");
+-   ("/xe2/xbd/x8c", "KANGXI RADICAL STOP");
+-   ("/xe2/xbd/x8d", "KANGXI RADICAL DEATH");
+-   ("/xe2/xbd/x8e", "KANGXI RADICAL WEAPON");
+-   ("/xe2/xbd/x8f", "KANGXI RADICAL DO NOT");
+-   ("/xe2/xbd/x90", "KANGXI RADICAL COMPARE");
+-   ("/xe2/xbd/x91", "KANGXI RADICAL FUR");
+-   ("/xe2/xbd/x92", "KANGXI RADICAL CLAN");
+-   ("/xe2/xbd/x93", "KANGXI RADICAL STEAM");
+-   ("/xe2/xbd/x94", "KANGXI RADICAL WATER");
+-   ("/xe2/xbd/x95", "KANGXI RADICAL FIRE");
+-   ("/xe2/xbd/x96", "KANGXI RADICAL CLAW");
+-   ("/xe2/xbd/x97", "KANGXI RADICAL FATHER");
+-   ("/xe2/xbd/x98", "KANGXI RADICAL DOUBLE X");
+-   ("/xe2/xbd/x99", "KANGXI RADICAL HALF TREE TRUNK");
+-   ("/xe2/xbd/x9a", "KANGXI RADICAL SLICE");
+-   ("/xe2/xbd/x9b", "KANGXI RADICAL FANG");
+-   ("/xe2/xbd/x9c", "KANGXI RADICAL COW");
+-   ("/xe2/xbd/x9d", "KANGXI RADICAL DOG");
+-   ("/xe2/xbd/x9e", "KANGXI RADICAL PROFOUND");
+-   ("/xe2/xbd/x9f", "KANGXI RADICAL JADE");
+-   ("/xe2/xbd/xa0", "KANGXI RADICAL MELON");
+-   ("/xe2/xbd/xa1", "KANGXI RADICAL TILE");
+-   ("/xe2/xbd/xa2", "KANGXI RADICAL SWEET");
+-   ("/xe2/xbd/xa3", "KANGXI RADICAL LIFE");
+-   ("/xe2/xbd/xa4", "KANGXI RADICAL USE");
+-   ("/xe2/xbd/xa5", "KANGXI RADICAL FIELD");
+-   ("/xe2/xbd/xa6", "KANGXI RADICAL BOLT OF CLOTH");
+-   ("/xe2/xbd/xa7", "KANGXI RADICAL SICKNESS");
+-   ("/xe2/xbd/xa8", "KANGXI RADICAL DOTTED TENT");
+-   ("/xe2/xbd/xa9", "KANGXI RADICAL WHITE");
+-   ("/xe2/xbd/xaa", "KANGXI RADICAL SKIN");
+-   ("/xe2/xbd/xab", "KANGXI RADICAL DISH");
+-   ("/xe2/xbd/xac", "KANGXI RADICAL EYE");
+-   ("/xe2/xbd/xad", "KANGXI RADICAL SPEAR");
+-   ("/xe2/xbd/xae", "KANGXI RADICAL ARROW");
+-   ("/xe2/xbd/xaf", "KANGXI RADICAL STONE");
+-   ("/xe2/xbd/xb0", "KANGXI RADICAL SPIRIT");
+-   ("/xe2/xbd/xb1", "KANGXI RADICAL TRACK");
+-   ("/xe2/xbd/xb2", "KANGXI RADICAL GRAIN");
+-   ("/xe2/xbd/xb3", "KANGXI RADICAL CAVE");
+-   ("/xe2/xbd/xb4", "KANGXI RADICAL STAND");
+-   ("/xe2/xbd/xb5", "KANGXI RADICAL BAMBOO");
+-   ("/xe2/xbd/xb6", "KANGXI RADICAL RICE");
+-   ("/xe2/xbd/xb7", "KANGXI RADICAL SILK");
+-   ("/xe2/xbd/xb8", "KANGXI RADICAL JAR");
+-   ("/xe2/xbd/xb9", "KANGXI RADICAL NET");
+-   ("/xe2/xbd/xba", "KANGXI RADICAL SHEEP");
+-   ("/xe2/xbd/xbb", "KANGXI RADICAL FEATHER");
+-   ("/xe2/xbd/xbc", "KANGXI RADICAL OLD");
+-   ("/xe2/xbd/xbd", "KANGXI RADICAL AND");
+-   ("/xe2/xbd/xbe", "KANGXI RADICAL PLOW");
+-   ("/xe2/xbd/xbf", "KANGXI RADICAL EAR");
+-   ("/xe2/xbe/x80", "KANGXI RADICAL BRUSH");
+-   ("/xe2/xbe/x81", "KANGXI RADICAL MEAT");
+-   ("/xe2/xbe/x82", "KANGXI RADICAL MINISTER");
+-   ("/xe2/xbe/x83", "KANGXI RADICAL SELF");
+-   ("/xe2/xbe/x84", "KANGXI RADICAL ARRIVE");
+-   ("/xe2/xbe/x85", "KANGXI RADICAL MORTAR");
+-   ("/xe2/xbe/x86", "KANGXI RADICAL TONGUE");
+-   ("/xe2/xbe/x87", "KANGXI RADICAL OPPOSE");
+-   ("/xe2/xbe/x88", "KANGXI RADICAL BOAT");
+-   ("/xe2/xbe/x89", "KANGXI RADICAL STOPPING");
+-   ("/xe2/xbe/x8a", "KANGXI RADICAL COLOR");
+-   ("/xe2/xbe/x8b", "KANGXI RADICAL GRASS");
+-   ("/xe2/xbe/x8c", "KANGXI RADICAL TIGER");
+-   ("/xe2/xbe/x8d", "KANGXI RADICAL INSECT");
+-   ("/xe2/xbe/x8e", "KANGXI RADICAL BLOOD");
+-   ("/xe2/xbe/x8f", "KANGXI RADICAL WALK ENCLOSURE");
+-   ("/xe2/xbe/x90", "KANGXI RADICAL CLOTHES");
+-   ("/xe2/xbe/x91", "KANGXI RADICAL WEST");
+-   ("/xe2/xbe/x92", "KANGXI RADICAL SEE");
+-   ("/xe2/xbe/x93", "KANGXI RADICAL HORN");
+-   ("/xe2/xbe/x94", "KANGXI RADICAL SPEECH");
+-   ("/xe2/xbe/x95", "KANGXI RADICAL VALLEY");
+-   ("/xe2/xbe/x96", "KANGXI RADICAL BEAN");
+-   ("/xe2/xbe/x97", "KANGXI RADICAL PIG");
+-   ("/xe2/xbe/x98", "KANGXI RADICAL BADGER");
+-   ("/xe2/xbe/x99", "KANGXI RADICAL SHELL");
+-   ("/xe2/xbe/x9a", "KANGXI RADICAL RED");
+-   ("/xe2/xbe/x9b", "KANGXI RADICAL RUN");
+-   ("/xe2/xbe/x9c", "KANGXI RADICAL FOOT");
+-   ("/xe2/xbe/x9d", "KANGXI RADICAL BODY");
+-   ("/xe2/xbe/x9e", "KANGXI RADICAL CART");
+-   ("/xe2/xbe/x9f", "KANGXI RADICAL BITTER");
+-   ("/xe2/xbe/xa0", "KANGXI RADICAL MORNING");
+-   ("/xe2/xbe/xa1", "KANGXI RADICAL WALK");
+-   ("/xe2/xbe/xa2", "KANGXI RADICAL CITY");
+-   ("/xe2/xbe/xa3", "KANGXI RADICAL WINE");
+-   ("/xe2/xbe/xa4", "KANGXI RADICAL DISTINGUISH");
+-   ("/xe2/xbe/xa5", "KANGXI RADICAL VILLAGE");
+-   ("/xe2/xbe/xa6", "KANGXI RADICAL GOLD");
+-   ("/xe2/xbe/xa7", "KANGXI RADICAL LONG");
+-   ("/xe2/xbe/xa8", "KANGXI RADICAL GATE");
+-   ("/xe2/xbe/xa9", "KANGXI RADICAL MOUND");
+-   ("/xe2/xbe/xaa", "KANGXI RADICAL SLAVE");
+-   ("/xe2/xbe/xab", "KANGXI RADICAL SHORT TAILED BIRD");
+-   ("/xe2/xbe/xac", "KANGXI RADICAL RAIN");
+-   ("/xe2/xbe/xad", "KANGXI RADICAL BLUE");
+-   ("/xe2/xbe/xae", "KANGXI RADICAL WRONG");
+-   ("/xe2/xbe/xaf", "KANGXI RADICAL FACE");
+-   ("/xe2/xbe/xb0", "KANGXI RADICAL LEATHER");
+-   ("/xe2/xbe/xb1", "KANGXI RADICAL TANNED LEATHER");
+-   ("/xe2/xbe/xb2", "KANGXI RADICAL LEEK");
+-   ("/xe2/xbe/xb3", "KANGXI RADICAL SOUND");
+-   ("/xe2/xbe/xb4", "KANGXI RADICAL LEAF");
+-   ("/xe2/xbe/xb5", "KANGXI RADICAL WIND");
+-   ("/xe2/xbe/xb6", "KANGXI RADICAL FLY");
+-   ("/xe2/xbe/xb7", "KANGXI RADICAL EAT");
+-   ("/xe2/xbe/xb8", "KANGXI RADICAL HEAD");
+-   ("/xe2/xbe/xb9", "KANGXI RADICAL FRAGRANT");
+-   ("/xe2/xbe/xba", "KANGXI RADICAL HORSE");
+-   ("/xe2/xbe/xbb", "KANGXI RADICAL BONE");
+-   ("/xe2/xbe/xbc", "KANGXI RADICAL TALL");
+-   ("/xe2/xbe/xbd", "KANGXI RADICAL HAIR");
+-   ("/xe2/xbe/xbe", "KANGXI RADICAL FIGHT");
+-   ("/xe2/xbe/xbf", "KANGXI RADICAL SACRIFICIAL WINE");
+-   ("/xe2/xbf/x80", "KANGXI RADICAL CAULDRON");
+-   ("/xe2/xbf/x81", "KANGXI RADICAL GHOST");
+-   ("/xe2/xbf/x82", "KANGXI RADICAL FISH");
+-   ("/xe2/xbf/x83", "KANGXI RADICAL BIRD");
+-   ("/xe2/xbf/x84", "KANGXI RADICAL SALT");
+-   ("/xe2/xbf/x85", "KANGXI RADICAL DEER");
+-   ("/xe2/xbf/x86", "KANGXI RADICAL WHEAT");
+-   ("/xe2/xbf/x87", "KANGXI RADICAL HEMP");
+-   ("/xe2/xbf/x88", "KANGXI RADICAL YELLOW");
+-   ("/xe2/xbf/x89", "KANGXI RADICAL MILLET");
+-   ("/xe2/xbf/x8a", "KANGXI RADICAL BLACK");
+-   ("/xe2/xbf/x8b", "KANGXI RADICAL EMBROIDERY");
+-   ("/xe2/xbf/x8c", "KANGXI RADICAL FROG");
+-   ("/xe2/xbf/x8d", "KANGXI RADICAL TRIPOD");
+-   ("/xe2/xbf/x8e", "KANGXI RADICAL DRUM");
+-   ("/xe2/xbf/x8f", "KANGXI RADICAL RAT");
+-   ("/xe2/xbf/x90", "KANGXI RADICAL NOSE");
+-   ("/xe2/xbf/x91", "KANGXI RADICAL EVEN");
+-   ("/xe2/xbf/x92", "KANGXI RADICAL TOOTH");
+-   ("/xe2/xbf/x93", "KANGXI RADICAL DRAGON");
+-   ("/xe2/xbf/x94", "KANGXI RADICAL TURTLE");
+-   ("/xe2/xbf/x95", "KANGXI RADICAL FLUTE");
+-   ("/xe2/xbf/xb0", "IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT");
+-   ("/xe2/xbf/xb1", "IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW");
+-   ("/xe2/xbf/xb2", "IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT");
+-   ("/xe2/xbf/xb3", "IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW");
+-   ("/xe2/xbf/xb4", "IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND");
+-   ("/xe2/xbf/xb5", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM ABOVE");
+-   ("/xe2/xbf/xb6", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM BELOW");
+-   ("/xe2/xbf/xb7", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LEFT");
+-   ("/xe2/xbf/xb8", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER LEFT");
+-   ("/xe2/xbf/xb9", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER RIGHT");
+-   ("/xe2/xbf/xba", "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER LEFT");
+-   ("/xe2/xbf/xbb", "IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID");
+-   ("/xe3/x80/x80", "IDEOGRAPHIC SPACE");
+-   ("/xe3/x80/x81", "IDEOGRAPHIC COMMA");
+-   ("/xe3/x80/x82", "IDEOGRAPHIC FULL STOP");
+-   ("/xe3/x80/x83", "DITTO MARK");
+-   ("/xe3/x80/x84", "JAPANESE INDUSTRIAL STANDARD SYMBOL");
+-   ("/xe3/x80/x85", "IDEOGRAPHIC ITERATION MARK");
+-   ("/xe3/x80/x86", "IDEOGRAPHIC CLOSING MARK");
+-   ("/xe3/x80/x87", "IDEOGRAPHIC NUMBER ZERO");
+-   ("/xe3/x80/x88", "LEFT ANGLE BRACKET");
+-   ("/xe3/x80/x89", "RIGHT ANGLE BRACKET");
+-   ("/xe3/x80/x8a", "LEFT DOUBLE ANGLE BRACKET");
+-   ("/xe3/x80/x8b", "RIGHT DOUBLE ANGLE BRACKET");
+-   ("/xe3/x80/x8c", "LEFT CORNER BRACKET");
+-   ("/xe3/x80/x8d", "RIGHT CORNER BRACKET");
+-   ("/xe3/x80/x8e", "LEFT WHITE CORNER BRACKET");
+-   ("/xe3/x80/x8f", "RIGHT WHITE CORNER BRACKET");
+-   ("/xe3/x80/x90", "LEFT BLACK LENTICULAR BRACKET");
+-   ("/xe3/x80/x91", "RIGHT BLACK LENTICULAR BRACKET");
+-   ("/xe3/x80/x92", "POSTAL MARK");
+-   ("/xe3/x80/x93", "GETA MARK");
+-   ("/xe3/x80/x94", "LEFT TORTOISE SHELL BRACKET");
+-   ("/xe3/x80/x95", "RIGHT TORTOISE SHELL BRACKET");
+-   ("/xe3/x80/x96", "LEFT WHITE LENTICULAR BRACKET");
+-   ("/xe3/x80/x97", "RIGHT WHITE LENTICULAR BRACKET");
+-   ("/xe3/x80/x98", "LEFT WHITE TORTOISE SHELL BRACKET");
+-   ("/xe3/x80/x99", "RIGHT WHITE TORTOISE SHELL BRACKET");
+-   ("/xe3/x80/x9a", "LEFT WHITE SQUARE BRACKET");
+-   ("/xe3/x80/x9b", "RIGHT WHITE SQUARE BRACKET");
+-   ("/xe3/x80/x9c", "WAVE DASH");
+-   ("/xe3/x80/x9d", "REVERSED DOUBLE PRIME QUOTATION MARK");
+-   ("/xe3/x80/x9e", "DOUBLE PRIME QUOTATION MARK");
+-   ("/xe3/x80/x9f", "LOW DOUBLE PRIME QUOTATION MARK");
+-   ("/xe3/x80/xa0", "POSTAL MARK FACE");
+-   ("/xe3/x80/xa1", "HANGZHOU NUMERAL ONE");
+-   ("/xe3/x80/xa2", "HANGZHOU NUMERAL TWO");
+-   ("/xe3/x80/xa3", "HANGZHOU NUMERAL THREE");
+-   ("/xe3/x80/xa4", "HANGZHOU NUMERAL FOUR");
+-   ("/xe3/x80/xa5", "HANGZHOU NUMERAL FIVE");
+-   ("/xe3/x80/xa6", "HANGZHOU NUMERAL SIX");
+-   ("/xe3/x80/xa7", "HANGZHOU NUMERAL SEVEN");
+-   ("/xe3/x80/xa8", "HANGZHOU NUMERAL EIGHT");
+-   ("/xe3/x80/xa9", "HANGZHOU NUMERAL NINE");
+-   ("/xe3/x80/xaa", "IDEOGRAPHIC LEVEL TONE MARK");
+-   ("/xe3/x80/xab", "IDEOGRAPHIC RISING TONE MARK");
+-   ("/xe3/x80/xac", "IDEOGRAPHIC DEPARTING TONE MARK");
+-   ("/xe3/x80/xad", "IDEOGRAPHIC ENTERING TONE MARK");
+-   ("/xe3/x80/xae", "HANGUL SINGLE DOT TONE MARK");
+-   ("/xe3/x80/xaf", "HANGUL DOUBLE DOT TONE MARK");
+-   ("/xe3/x80/xb0", "WAVY DASH");
+-   ("/xe3/x80/xb1", "VERTICAL KANA REPEAT MARK");
+-   ("/xe3/x80/xb2", "VERTICAL KANA REPEAT WITH VOICED SOUND MARK");
+-   ("/xe3/x80/xb3", "VERTICAL KANA REPEAT MARK UPPER HALF");
+-   ("/xe3/x80/xb4", "VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF");
+-   ("/xe3/x80/xb5", "VERTICAL KANA REPEAT MARK LOWER HALF");
+-   ("/xe3/x80/xb6", "CIRCLED POSTAL MARK");
+-   ("/xe3/x80/xb7", "IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL");
+-   ("/xe3/x80/xb8", "HANGZHOU NUMERAL TEN");
+-   ("/xe3/x80/xb9", "HANGZHOU NUMERAL TWENTY");
+-   ("/xe3/x80/xba", "HANGZHOU NUMERAL THIRTY");
+-   ("/xe3/x80/xbb", "VERTICAL IDEOGRAPHIC ITERATION MARK");
+-   ("/xe3/x80/xbc", "MASU MARK");
+-   ("/xe3/x80/xbd", "PART ALTERNATION MARK");
+-   ("/xe3/x80/xbe", "IDEOGRAPHIC VARIATION INDICATOR");
+-   ("/xe3/x80/xbf", "IDEOGRAPHIC HALF FILL SPACE");
+    ("/xe3/x81/x81", "HIRAGANA LETTER SMALL A");
+-   ("/xe3/x81/x82", "HIRAGANA LETTER A");
+    ("/xe3/x81/x83", "HIRAGANA LETTER SMALL I");
+-   ("/xe3/x81/x84", "HIRAGANA LETTER I");
+    ("/xe3/x81/x85", "HIRAGANA LETTER SMALL U");
+-   ("/xe3/x81/x86", "HIRAGANA LETTER U");
+    ("/xe3/x81/x87", "HIRAGANA LETTER SMALL E");
+-   ("/xe3/x81/x88", "HIRAGANA LETTER E");
+    ("/xe3/x81/x89", "HIRAGANA LETTER SMALL O");
+-   ("/xe3/x81/x8a", "HIRAGANA LETTER O");
+-   ("/xe3/x81/x8b", "HIRAGANA LETTER KA");
+-   ("/xe3/x81/x8c", "HIRAGANA LETTER GA");
+-   ("/xe3/x81/x8d", "HIRAGANA LETTER KI");
+-   ("/xe3/x81/x8e", "HIRAGANA LETTER GI");
+-   ("/xe3/x81/x8f", "HIRAGANA LETTER KU");
+-   ("/xe3/x81/x90", "HIRAGANA LETTER GU");
+-   ("/xe3/x81/x91", "HIRAGANA LETTER KE");
+-   ("/xe3/x81/x92", "HIRAGANA LETTER GE");
+-   ("/xe3/x81/x93", "HIRAGANA LETTER KO");
+-   ("/xe3/x81/x94", "HIRAGANA LETTER GO");
+-   ("/xe3/x81/x95", "HIRAGANA LETTER SA");
+-   ("/xe3/x81/x96", "HIRAGANA LETTER ZA");
+-   ("/xe3/x81/x97", "HIRAGANA LETTER SI");
+-   ("/xe3/x81/x98", "HIRAGANA LETTER ZI");
+-   ("/xe3/x81/x99", "HIRAGANA LETTER SU");
+-   ("/xe3/x81/x9a", "HIRAGANA LETTER ZU");
+-   ("/xe3/x81/x9b", "HIRAGANA LETTER SE");
+-   ("/xe3/x81/x9c", "HIRAGANA LETTER ZE");
+-   ("/xe3/x81/x9d", "HIRAGANA LETTER SO");
+-   ("/xe3/x81/x9e", "HIRAGANA LETTER ZO");
+-   ("/xe3/x81/x9f", "HIRAGANA LETTER TA");
+-   ("/xe3/x81/xa0", "HIRAGANA LETTER DA");
+-   ("/xe3/x81/xa1", "HIRAGANA LETTER TI");
+-   ("/xe3/x81/xa2", "HIRAGANA LETTER DI");
+    ("/xe3/x81/xa3", "HIRAGANA LETTER SMALL TU");
+-   ("/xe3/x81/xa4", "HIRAGANA LETTER TU");
+-   ("/xe3/x81/xa5", "HIRAGANA LETTER DU");
+-   ("/xe3/x81/xa6", "HIRAGANA LETTER TE");
+-   ("/xe3/x81/xa7", "HIRAGANA LETTER DE");
+-   ("/xe3/x81/xa8", "HIRAGANA LETTER TO");
+-   ("/xe3/x81/xa9", "HIRAGANA LETTER DO");
+-   ("/xe3/x81/xaa", "HIRAGANA LETTER NA");
+-   ("/xe3/x81/xab", "HIRAGANA LETTER NI");
+-   ("/xe3/x81/xac", "HIRAGANA LETTER NU");
+-   ("/xe3/x81/xad", "HIRAGANA LETTER NE");
+-   ("/xe3/x81/xae", "HIRAGANA LETTER NO");
+-   ("/xe3/x81/xaf", "HIRAGANA LETTER HA");
+-   ("/xe3/x81/xb0", "HIRAGANA LETTER BA");
+-   ("/xe3/x81/xb1", "HIRAGANA LETTER PA");
+-   ("/xe3/x81/xb2", "HIRAGANA LETTER HI");
+-   ("/xe3/x81/xb3", "HIRAGANA LETTER BI");
+-   ("/xe3/x81/xb4", "HIRAGANA LETTER PI");
+-   ("/xe3/x81/xb5", "HIRAGANA LETTER HU");
+-   ("/xe3/x81/xb6", "HIRAGANA LETTER BU");
+-   ("/xe3/x81/xb7", "HIRAGANA LETTER PU");
+-   ("/xe3/x81/xb8", "HIRAGANA LETTER HE");
+-   ("/xe3/x81/xb9", "HIRAGANA LETTER BE");
+-   ("/xe3/x81/xba", "HIRAGANA LETTER PE");
+-   ("/xe3/x81/xbb", "HIRAGANA LETTER HO");
+-   ("/xe3/x81/xbc", "HIRAGANA LETTER BO");
+-   ("/xe3/x81/xbd", "HIRAGANA LETTER PO");
+-   ("/xe3/x81/xbe", "HIRAGANA LETTER MA");
+-   ("/xe3/x81/xbf", "HIRAGANA LETTER MI");
+-   ("/xe3/x82/x80", "HIRAGANA LETTER MU");
+-   ("/xe3/x82/x81", "HIRAGANA LETTER ME");
+-   ("/xe3/x82/x82", "HIRAGANA LETTER MO");
+    ("/xe3/x82/x83", "HIRAGANA LETTER SMALL YA");
+-   ("/xe3/x82/x84", "HIRAGANA LETTER YA");
+    ("/xe3/x82/x85", "HIRAGANA LETTER SMALL YU");
+-   ("/xe3/x82/x86", "HIRAGANA LETTER YU");
+    ("/xe3/x82/x87", "HIRAGANA LETTER SMALL YO");
+-   ("/xe3/x82/x88", "HIRAGANA LETTER YO");
+-   ("/xe3/x82/x89", "HIRAGANA LETTER RA");
+-   ("/xe3/x82/x8a", "HIRAGANA LETTER RI");
+-   ("/xe3/x82/x8b", "HIRAGANA LETTER RU");
+-   ("/xe3/x82/x8c", "HIRAGANA LETTER RE");
+-   ("/xe3/x82/x8d", "HIRAGANA LETTER RO");
+    ("/xe3/x82/x8e", "HIRAGANA LETTER SMALL WA");
+-   ("/xe3/x82/x8f", "HIRAGANA LETTER WA");
+-   ("/xe3/x82/x90", "HIRAGANA LETTER WI");
+-   ("/xe3/x82/x91", "HIRAGANA LETTER WE");
+-   ("/xe3/x82/x92", "HIRAGANA LETTER WO");
+-   ("/xe3/x82/x93", "HIRAGANA LETTER N");
+-   ("/xe3/x82/x94", "HIRAGANA LETTER VU");
+    ("/xe3/x82/x95", "HIRAGANA LETTER SMALL KA");
+    ("/xe3/x82/x96", "HIRAGANA LETTER SMALL KE");
+-   ("/xe3/x82/x99", "COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK");
+-   ("/xe3/x82/x9a", "COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK");
+-   ("/xe3/x82/x9b", "KATAKANA-HIRAGANA VOICED SOUND MARK");
+-   ("/xe3/x82/x9c", "KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK");
+-   ("/xe3/x82/x9d", "HIRAGANA ITERATION MARK");
+-   ("/xe3/x82/x9e", "HIRAGANA VOICED ITERATION MARK");
+-   ("/xe3/x82/x9f", "HIRAGANA DIGRAPH YORI");
+-   ("/xe3/x82/xa0", "KATAKANA-HIRAGANA DOUBLE HYPHEN");
+    ("/xe3/x82/xa1", "KATAKANA LETTER SMALL A");
+-   ("/xe3/x82/xa2", "KATAKANA LETTER A");
+    ("/xe3/x82/xa3", "KATAKANA LETTER SMALL I");
+-   ("/xe3/x82/xa4", "KATAKANA LETTER I");
+    ("/xe3/x82/xa5", "KATAKANA LETTER SMALL U");
+-   ("/xe3/x82/xa6", "KATAKANA LETTER U");
+    ("/xe3/x82/xa7", "KATAKANA LETTER SMALL E");
+-   ("/xe3/x82/xa8", "KATAKANA LETTER E");
+    ("/xe3/x82/xa9", "KATAKANA LETTER SMALL O");
+-   ("/xe3/x82/xaa", "KATAKANA LETTER O");
+-   ("/xe3/x82/xab", "KATAKANA LETTER KA");
+-   ("/xe3/x82/xac", "KATAKANA LETTER GA");
+-   ("/xe3/x82/xad", "KATAKANA LETTER KI");
+-   ("/xe3/x82/xae", "KATAKANA LETTER GI");
+-   ("/xe3/x82/xaf", "KATAKANA LETTER KU");
+-   ("/xe3/x82/xb0", "KATAKANA LETTER GU");
+-   ("/xe3/x82/xb1", "KATAKANA LETTER KE");
+-   ("/xe3/x82/xb2", "KATAKANA LETTER GE");
+-   ("/xe3/x82/xb3", "KATAKANA LETTER KO");
+-   ("/xe3/x82/xb4", "KATAKANA LETTER GO");
+-   ("/xe3/x82/xb5", "KATAKANA LETTER SA");
+-   ("/xe3/x82/xb6", "KATAKANA LETTER ZA");
+-   ("/xe3/x82/xb7", "KATAKANA LETTER SI");
+-   ("/xe3/x82/xb8", "KATAKANA LETTER ZI");
+-   ("/xe3/x82/xb9", "KATAKANA LETTER SU");
+-   ("/xe3/x82/xba", "KATAKANA LETTER ZU");
+-   ("/xe3/x82/xbb", "KATAKANA LETTER SE");
+-   ("/xe3/x82/xbc", "KATAKANA LETTER ZE");
+-   ("/xe3/x82/xbd", "KATAKANA LETTER SO");
+-   ("/xe3/x82/xbe", "KATAKANA LETTER ZO");
+-   ("/xe3/x82/xbf", "KATAKANA LETTER TA");
+-   ("/xe3/x83/x80", "KATAKANA LETTER DA");
+-   ("/xe3/x83/x81", "KATAKANA LETTER TI");
+-   ("/xe3/x83/x82", "KATAKANA LETTER DI");
+    ("/xe3/x83/x83", "KATAKANA LETTER SMALL TU");
+-   ("/xe3/x83/x84", "KATAKANA LETTER TU");
+-   ("/xe3/x83/x85", "KATAKANA LETTER DU");
+-   ("/xe3/x83/x86", "KATAKANA LETTER TE");
+-   ("/xe3/x83/x87", "KATAKANA LETTER DE");
+-   ("/xe3/x83/x88", "KATAKANA LETTER TO");
+-   ("/xe3/x83/x89", "KATAKANA LETTER DO");
+-   ("/xe3/x83/x8a", "KATAKANA LETTER NA");
+-   ("/xe3/x83/x8b", "KATAKANA LETTER NI");
+-   ("/xe3/x83/x8c", "KATAKANA LETTER NU");
+-   ("/xe3/x83/x8d", "KATAKANA LETTER NE");
+-   ("/xe3/x83/x8e", "KATAKANA LETTER NO");
+-   ("/xe3/x83/x8f", "KATAKANA LETTER HA");
+-   ("/xe3/x83/x90", "KATAKANA LETTER BA");
+-   ("/xe3/x83/x91", "KATAKANA LETTER PA");
+-   ("/xe3/x83/x92", "KATAKANA LETTER HI");
+-   ("/xe3/x83/x93", "KATAKANA LETTER BI");
+-   ("/xe3/x83/x94", "KATAKANA LETTER PI");
+-   ("/xe3/x83/x95", "KATAKANA LETTER HU");
+-   ("/xe3/x83/x96", "KATAKANA LETTER BU");
+-   ("/xe3/x83/x97", "KATAKANA LETTER PU");
+-   ("/xe3/x83/x98", "KATAKANA LETTER HE");
+-   ("/xe3/x83/x99", "KATAKANA LETTER BE");
+-   ("/xe3/x83/x9a", "KATAKANA LETTER PE");
+-   ("/xe3/x83/x9b", "KATAKANA LETTER HO");
+-   ("/xe3/x83/x9c", "KATAKANA LETTER BO");
+-   ("/xe3/x83/x9d", "KATAKANA LETTER PO");
+-   ("/xe3/x83/x9e", "KATAKANA LETTER MA");
+-   ("/xe3/x83/x9f", "KATAKANA LETTER MI");
+-   ("/xe3/x83/xa0", "KATAKANA LETTER MU");
+-   ("/xe3/x83/xa1", "KATAKANA LETTER ME");
+-   ("/xe3/x83/xa2", "KATAKANA LETTER MO");
+    ("/xe3/x83/xa3", "KATAKANA LETTER SMALL YA");
+-   ("/xe3/x83/xa4", "KATAKANA LETTER YA");
+    ("/xe3/x83/xa5", "KATAKANA LETTER SMALL YU");
+-   ("/xe3/x83/xa6", "KATAKANA LETTER YU");
+    ("/xe3/x83/xa7", "KATAKANA LETTER SMALL YO");
+-   ("/xe3/x83/xa8", "KATAKANA LETTER YO");
+-   ("/xe3/x83/xa9", "KATAKANA LETTER RA");
+-   ("/xe3/x83/xaa", "KATAKANA LETTER RI");
+-   ("/xe3/x83/xab", "KATAKANA LETTER RU");
+-   ("/xe3/x83/xac", "KATAKANA LETTER RE");
+-   ("/xe3/x83/xad", "KATAKANA LETTER RO");
+    ("/xe3/x83/xae", "KATAKANA LETTER SMALL WA");
+-   ("/xe3/x83/xaf", "KATAKANA LETTER WA");
+-   ("/xe3/x83/xb0", "KATAKANA LETTER WI");
+-   ("/xe3/x83/xb1", "KATAKANA LETTER WE");
+-   ("/xe3/x83/xb2", "KATAKANA LETTER WO");
+-   ("/xe3/x83/xb3", "KATAKANA LETTER N");
+-   ("/xe3/x83/xb4", "KATAKANA LETTER VU");
+    ("/xe3/x83/xb5", "KATAKANA LETTER SMALL KA");
+    ("/xe3/x83/xb6", "KATAKANA LETTER SMALL KE");
+-   ("/xe3/x83/xb7", "KATAKANA LETTER VA");
+-   ("/xe3/x83/xb8", "KATAKANA LETTER VI");
+-   ("/xe3/x83/xb9", "KATAKANA LETTER VE");
+-   ("/xe3/x83/xba", "KATAKANA LETTER VO");
+-   ("/xe3/x83/xbb", "KATAKANA MIDDLE DOT");
+-   ("/xe3/x83/xbc", "KATAKANA-HIRAGANA PROLONGED SOUND MARK");
+-   ("/xe3/x83/xbd", "KATAKANA ITERATION MARK");
+-   ("/xe3/x83/xbe", "KATAKANA VOICED ITERATION MARK");
+-   ("/xe3/x83/xbf", "KATAKANA DIGRAPH KOTO");
+-   ("/xe3/x84/x85", "BOPOMOFO LETTER B");
+-   ("/xe3/x84/x86", "BOPOMOFO LETTER P");
+-   ("/xe3/x84/x87", "BOPOMOFO LETTER M");
+-   ("/xe3/x84/x88", "BOPOMOFO LETTER F");
+-   ("/xe3/x84/x89", "BOPOMOFO LETTER D");
+-   ("/xe3/x84/x8a", "BOPOMOFO LETTER T");
+-   ("/xe3/x84/x8b", "BOPOMOFO LETTER N");
+-   ("/xe3/x84/x8c", "BOPOMOFO LETTER L");
+-   ("/xe3/x84/x8d", "BOPOMOFO LETTER G");
+-   ("/xe3/x84/x8e", "BOPOMOFO LETTER K");
+-   ("/xe3/x84/x8f", "BOPOMOFO LETTER H");
+-   ("/xe3/x84/x90", "BOPOMOFO LETTER J");
+-   ("/xe3/x84/x91", "BOPOMOFO LETTER Q");
+-   ("/xe3/x84/x92", "BOPOMOFO LETTER X");
+-   ("/xe3/x84/x93", "BOPOMOFO LETTER ZH");
+-   ("/xe3/x84/x94", "BOPOMOFO LETTER CH");
+-   ("/xe3/x84/x95", "BOPOMOFO LETTER SH");
+-   ("/xe3/x84/x96", "BOPOMOFO LETTER R");
+-   ("/xe3/x84/x97", "BOPOMOFO LETTER Z");
+-   ("/xe3/x84/x98", "BOPOMOFO LETTER C");
+-   ("/xe3/x84/x99", "BOPOMOFO LETTER S");
+-   ("/xe3/x84/x9a", "BOPOMOFO LETTER A");
+-   ("/xe3/x84/x9b", "BOPOMOFO LETTER O");
+-   ("/xe3/x84/x9c", "BOPOMOFO LETTER E");
+-   ("/xe3/x84/x9d", "BOPOMOFO LETTER EH");
+-   ("/xe3/x84/x9e", "BOPOMOFO LETTER AI");
+-   ("/xe3/x84/x9f", "BOPOMOFO LETTER EI");
+-   ("/xe3/x84/xa0", "BOPOMOFO LETTER AU");
+-   ("/xe3/x84/xa1", "BOPOMOFO LETTER OU");
+-   ("/xe3/x84/xa2", "BOPOMOFO LETTER AN");
+-   ("/xe3/x84/xa3", "BOPOMOFO LETTER EN");
+-   ("/xe3/x84/xa4", "BOPOMOFO LETTER ANG");
+-   ("/xe3/x84/xa5", "BOPOMOFO LETTER ENG");
+-   ("/xe3/x84/xa6", "BOPOMOFO LETTER ER");
+-   ("/xe3/x84/xa7", "BOPOMOFO LETTER I");
+-   ("/xe3/x84/xa8", "BOPOMOFO LETTER U");
+-   ("/xe3/x84/xa9", "BOPOMOFO LETTER IU");
+-   ("/xe3/x84/xaa", "BOPOMOFO LETTER V");
+-   ("/xe3/x84/xab", "BOPOMOFO LETTER NG");
+-   ("/xe3/x84/xac", "BOPOMOFO LETTER GN");
+-   ("/xe3/x84/xad", "BOPOMOFO LETTER IH");
+-   ("/xe3/x84/xb1", "HANGUL LETTER KIYEOK");
+-   ("/xe3/x84/xb2", "HANGUL LETTER SSANGKIYEOK");
+-   ("/xe3/x84/xb3", "HANGUL LETTER KIYEOK-SIOS");
+-   ("/xe3/x84/xb4", "HANGUL LETTER NIEUN");
+-   ("/xe3/x84/xb5", "HANGUL LETTER NIEUN-CIEUC");
+-   ("/xe3/x84/xb6", "HANGUL LETTER NIEUN-HIEUH");
+-   ("/xe3/x84/xb7", "HANGUL LETTER TIKEUT");
+-   ("/xe3/x84/xb8", "HANGUL LETTER SSANGTIKEUT");
+-   ("/xe3/x84/xb9", "HANGUL LETTER RIEUL");
+-   ("/xe3/x84/xba", "HANGUL LETTER RIEUL-KIYEOK");
+-   ("/xe3/x84/xbb", "HANGUL LETTER RIEUL-MIEUM");
+-   ("/xe3/x84/xbc", "HANGUL LETTER RIEUL-PIEUP");
+-   ("/xe3/x84/xbd", "HANGUL LETTER RIEUL-SIOS");
+-   ("/xe3/x84/xbe", "HANGUL LETTER RIEUL-THIEUTH");
+-   ("/xe3/x84/xbf", "HANGUL LETTER RIEUL-PHIEUPH");
+-   ("/xe3/x85/x80", "HANGUL LETTER RIEUL-HIEUH");
+-   ("/xe3/x85/x81", "HANGUL LETTER MIEUM");
+-   ("/xe3/x85/x82", "HANGUL LETTER PIEUP");
+-   ("/xe3/x85/x83", "HANGUL LETTER SSANGPIEUP");
+-   ("/xe3/x85/x84", "HANGUL LETTER PIEUP-SIOS");
+-   ("/xe3/x85/x85", "HANGUL LETTER SIOS");
+-   ("/xe3/x85/x86", "HANGUL LETTER SSANGSIOS");
+-   ("/xe3/x85/x87", "HANGUL LETTER IEUNG");
+-   ("/xe3/x85/x88", "HANGUL LETTER CIEUC");
+-   ("/xe3/x85/x89", "HANGUL LETTER SSANGCIEUC");
+-   ("/xe3/x85/x8a", "HANGUL LETTER CHIEUCH");
+-   ("/xe3/x85/x8b", "HANGUL LETTER KHIEUKH");
+-   ("/xe3/x85/x8c", "HANGUL LETTER THIEUTH");
+-   ("/xe3/x85/x8d", "HANGUL LETTER PHIEUPH");
+-   ("/xe3/x85/x8e", "HANGUL LETTER HIEUH");
+-   ("/xe3/x85/x8f", "HANGUL LETTER A");
+-   ("/xe3/x85/x90", "HANGUL LETTER AE");
+-   ("/xe3/x85/x91", "HANGUL LETTER YA");
+-   ("/xe3/x85/x92", "HANGUL LETTER YAE");
+-   ("/xe3/x85/x93", "HANGUL LETTER EO");
+-   ("/xe3/x85/x94", "HANGUL LETTER E");
+-   ("/xe3/x85/x95", "HANGUL LETTER YEO");
+-   ("/xe3/x85/x96", "HANGUL LETTER YE");
+-   ("/xe3/x85/x97", "HANGUL LETTER O");
+-   ("/xe3/x85/x98", "HANGUL LETTER WA");
+-   ("/xe3/x85/x99", "HANGUL LETTER WAE");
+-   ("/xe3/x85/x9a", "HANGUL LETTER OE");
+-   ("/xe3/x85/x9b", "HANGUL LETTER YO");
+-   ("/xe3/x85/x9c", "HANGUL LETTER U");
+-   ("/xe3/x85/x9d", "HANGUL LETTER WEO");
+-   ("/xe3/x85/x9e", "HANGUL LETTER WE");
+-   ("/xe3/x85/x9f", "HANGUL LETTER WI");
+-   ("/xe3/x85/xa0", "HANGUL LETTER YU");
+-   ("/xe3/x85/xa1", "HANGUL LETTER EU");
+-   ("/xe3/x85/xa2", "HANGUL LETTER YI");
+-   ("/xe3/x85/xa3", "HANGUL LETTER I");
+-   ("/xe3/x85/xa4", "HANGUL FILLER");
+-   ("/xe3/x85/xa5", "HANGUL LETTER SSANGNIEUN");
+-   ("/xe3/x85/xa6", "HANGUL LETTER NIEUN-TIKEUT");
+-   ("/xe3/x85/xa7", "HANGUL LETTER NIEUN-SIOS");
+-   ("/xe3/x85/xa8", "HANGUL LETTER NIEUN-PANSIOS");
+-   ("/xe3/x85/xa9", "HANGUL LETTER RIEUL-KIYEOK-SIOS");
+-   ("/xe3/x85/xaa", "HANGUL LETTER RIEUL-TIKEUT");
+-   ("/xe3/x85/xab", "HANGUL LETTER RIEUL-PIEUP-SIOS");
+-   ("/xe3/x85/xac", "HANGUL LETTER RIEUL-PANSIOS");
+-   ("/xe3/x85/xad", "HANGUL LETTER RIEUL-YEORINHIEUH");
+-   ("/xe3/x85/xae", "HANGUL LETTER MIEUM-PIEUP");
+-   ("/xe3/x85/xaf", "HANGUL LETTER MIEUM-SIOS");
+-   ("/xe3/x85/xb0", "HANGUL LETTER MIEUM-PANSIOS");
+-   ("/xe3/x85/xb1", "HANGUL LETTER KAPYEOUNMIEUM");
+-   ("/xe3/x85/xb2", "HANGUL LETTER PIEUP-KIYEOK");
+-   ("/xe3/x85/xb3", "HANGUL LETTER PIEUP-TIKEUT");
+-   ("/xe3/x85/xb4", "HANGUL LETTER PIEUP-SIOS-KIYEOK");
+-   ("/xe3/x85/xb5", "HANGUL LETTER PIEUP-SIOS-TIKEUT");
+-   ("/xe3/x85/xb6", "HANGUL LETTER PIEUP-CIEUC");
+-   ("/xe3/x85/xb7", "HANGUL LETTER PIEUP-THIEUTH");
+-   ("/xe3/x85/xb8", "HANGUL LETTER KAPYEOUNPIEUP");
+-   ("/xe3/x85/xb9", "HANGUL LETTER KAPYEOUNSSANGPIEUP");
+-   ("/xe3/x85/xba", "HANGUL LETTER SIOS-KIYEOK");
+-   ("/xe3/x85/xbb", "HANGUL LETTER SIOS-NIEUN");
+-   ("/xe3/x85/xbc", "HANGUL LETTER SIOS-TIKEUT");
+-   ("/xe3/x85/xbd", "HANGUL LETTER SIOS-PIEUP");
+-   ("/xe3/x85/xbe", "HANGUL LETTER SIOS-CIEUC");
+-   ("/xe3/x85/xbf", "HANGUL LETTER PANSIOS");
+-   ("/xe3/x86/x80", "HANGUL LETTER SSANGIEUNG");
+-   ("/xe3/x86/x81", "HANGUL LETTER YESIEUNG");
+-   ("/xe3/x86/x82", "HANGUL LETTER YESIEUNG-SIOS");
+-   ("/xe3/x86/x83", "HANGUL LETTER YESIEUNG-PANSIOS");
+-   ("/xe3/x86/x84", "HANGUL LETTER KAPYEOUNPHIEUPH");
+-   ("/xe3/x86/x85", "HANGUL LETTER SSANGHIEUH");
+-   ("/xe3/x86/x86", "HANGUL LETTER YEORINHIEUH");
+-   ("/xe3/x86/x87", "HANGUL LETTER YO-YA");
+-   ("/xe3/x86/x88", "HANGUL LETTER YO-YAE");
+-   ("/xe3/x86/x89", "HANGUL LETTER YO-I");
+-   ("/xe3/x86/x8a", "HANGUL LETTER YU-YEO");
+-   ("/xe3/x86/x8b", "HANGUL LETTER YU-YE");
+-   ("/xe3/x86/x8c", "HANGUL LETTER YU-I");
+-   ("/xe3/x86/x8d", "HANGUL LETTER ARAEA");
+-   ("/xe3/x86/x8e", "HANGUL LETTER ARAEAE");
+-   ("/xe3/x86/x90", "IDEOGRAPHIC ANNOTATION LINKING MARK");
+-   ("/xe3/x86/x91", "IDEOGRAPHIC ANNOTATION REVERSE MARK");
+-   ("/xe3/x86/x92", "IDEOGRAPHIC ANNOTATION ONE MARK");
+-   ("/xe3/x86/x93", "IDEOGRAPHIC ANNOTATION TWO MARK");
+-   ("/xe3/x86/x94", "IDEOGRAPHIC ANNOTATION THREE MARK");
+-   ("/xe3/x86/x95", "IDEOGRAPHIC ANNOTATION FOUR MARK");
+-   ("/xe3/x86/x96", "IDEOGRAPHIC ANNOTATION TOP MARK");
+-   ("/xe3/x86/x97", "IDEOGRAPHIC ANNOTATION MIDDLE MARK");
+-   ("/xe3/x86/x98", "IDEOGRAPHIC ANNOTATION BOTTOM MARK");
+-   ("/xe3/x86/x99", "IDEOGRAPHIC ANNOTATION FIRST MARK");
+-   ("/xe3/x86/x9a", "IDEOGRAPHIC ANNOTATION SECOND MARK");
+-   ("/xe3/x86/x9b", "IDEOGRAPHIC ANNOTATION THIRD MARK");
+-   ("/xe3/x86/x9c", "IDEOGRAPHIC ANNOTATION FOURTH MARK");
+-   ("/xe3/x86/x9d", "IDEOGRAPHIC ANNOTATION HEAVEN MARK");
+-   ("/xe3/x86/x9e", "IDEOGRAPHIC ANNOTATION EARTH MARK");
+-   ("/xe3/x86/x9f", "IDEOGRAPHIC ANNOTATION MAN MARK");
+-   ("/xe3/x86/xa0", "BOPOMOFO LETTER BU");
+-   ("/xe3/x86/xa1", "BOPOMOFO LETTER ZI");
+-   ("/xe3/x86/xa2", "BOPOMOFO LETTER JI");
+-   ("/xe3/x86/xa3", "BOPOMOFO LETTER GU");
+-   ("/xe3/x86/xa4", "BOPOMOFO LETTER EE");
+-   ("/xe3/x86/xa5", "BOPOMOFO LETTER ENN");
+-   ("/xe3/x86/xa6", "BOPOMOFO LETTER OO");
+-   ("/xe3/x86/xa7", "BOPOMOFO LETTER ONN");
+-   ("/xe3/x86/xa8", "BOPOMOFO LETTER IR");
+-   ("/xe3/x86/xa9", "BOPOMOFO LETTER ANN");
+-   ("/xe3/x86/xaa", "BOPOMOFO LETTER INN");
+-   ("/xe3/x86/xab", "BOPOMOFO LETTER UNN");
+-   ("/xe3/x86/xac", "BOPOMOFO LETTER IM");
+-   ("/xe3/x86/xad", "BOPOMOFO LETTER NGG");
+-   ("/xe3/x86/xae", "BOPOMOFO LETTER AINN");
+-   ("/xe3/x86/xaf", "BOPOMOFO LETTER AUNN");
+-   ("/xe3/x86/xb0", "BOPOMOFO LETTER AM");
+-   ("/xe3/x86/xb1", "BOPOMOFO LETTER OM");
+-   ("/xe3/x86/xb2", "BOPOMOFO LETTER ONG");
+-   ("/xe3/x86/xb3", "BOPOMOFO LETTER INNN");
+-   ("/xe3/x86/xb4", "BOPOMOFO FINAL LETTER P");
+-   ("/xe3/x86/xb5", "BOPOMOFO FINAL LETTER T");
+-   ("/xe3/x86/xb6", "BOPOMOFO FINAL LETTER K");
+-   ("/xe3/x86/xb7", "BOPOMOFO FINAL LETTER H");
+-   ("/xe3/x87/x80", "CJK STROKE T");
+-   ("/xe3/x87/x81", "CJK STROKE WG");
+-   ("/xe3/x87/x82", "CJK STROKE XG");
+-   ("/xe3/x87/x83", "CJK STROKE BXG");
+-   ("/xe3/x87/x84", "CJK STROKE SW");
+-   ("/xe3/x87/x85", "CJK STROKE HZZ");
+-   ("/xe3/x87/x86", "CJK STROKE HZG");
+-   ("/xe3/x87/x87", "CJK STROKE HP");
+-   ("/xe3/x87/x88", "CJK STROKE HZWG");
+-   ("/xe3/x87/x89", "CJK STROKE SZWG");
+-   ("/xe3/x87/x8a", "CJK STROKE HZT");
+-   ("/xe3/x87/x8b", "CJK STROKE HZZP");
+-   ("/xe3/x87/x8c", "CJK STROKE HPWG");
+-   ("/xe3/x87/x8d", "CJK STROKE HZW");
+-   ("/xe3/x87/x8e", "CJK STROKE HZZZ");
+-   ("/xe3/x87/x8f", "CJK STROKE N");
+-   ("/xe3/x87/x90", "CJK STROKE H");
+-   ("/xe3/x87/x91", "CJK STROKE S");
+-   ("/xe3/x87/x92", "CJK STROKE P");
+-   ("/xe3/x87/x93", "CJK STROKE SP");
+-   ("/xe3/x87/x94", "CJK STROKE D");
+-   ("/xe3/x87/x95", "CJK STROKE HZ");
+-   ("/xe3/x87/x96", "CJK STROKE HG");
+-   ("/xe3/x87/x97", "CJK STROKE SZ");
+-   ("/xe3/x87/x98", "CJK STROKE SWZ");
+-   ("/xe3/x87/x99", "CJK STROKE ST");
+-   ("/xe3/x87/x9a", "CJK STROKE SG");
+-   ("/xe3/x87/x9b", "CJK STROKE PD");
+-   ("/xe3/x87/x9c", "CJK STROKE PZ");
+-   ("/xe3/x87/x9d", "CJK STROKE TN");
+-   ("/xe3/x87/x9e", "CJK STROKE SZZ");
+-   ("/xe3/x87/x9f", "CJK STROKE SWG");
+-   ("/xe3/x87/xa0", "CJK STROKE HXWG");
+-   ("/xe3/x87/xa1", "CJK STROKE HZZZG");
+-   ("/xe3/x87/xa2", "CJK STROKE PG");
+-   ("/xe3/x87/xa3", "CJK STROKE Q");
+    ("/xe3/x87/xb0", "KATAKANA LETTER SMALL KU");
+    ("/xe3/x87/xb1", "KATAKANA LETTER SMALL SI");
+    ("/xe3/x87/xb2", "KATAKANA LETTER SMALL SU");
+@@ -10481,2518 +2291,10 @@
+    ("/xe3/x87/xbd", "KATAKANA LETTER SMALL RU");
+    ("/xe3/x87/xbe", "KATAKANA LETTER SMALL RE");
+    ("/xe3/x87/xbf", "KATAKANA LETTER SMALL RO");
+-   ("/xe3/x88/x80", "PARENTHESIZED HANGUL KIYEOK");
+-   ("/xe3/x88/x81", "PARENTHESIZED HANGUL NIEUN");
+-   ("/xe3/x88/x82", "PARENTHESIZED HANGUL TIKEUT");
+-   ("/xe3/x88/x83", "PARENTHESIZED HANGUL RIEUL");
+-   ("/xe3/x88/x84", "PARENTHESIZED HANGUL MIEUM");
+-   ("/xe3/x88/x85", "PARENTHESIZED HANGUL PIEUP");
+-   ("/xe3/x88/x86", "PARENTHESIZED HANGUL SIOS");
+-   ("/xe3/x88/x87", "PARENTHESIZED HANGUL IEUNG");
+-   ("/xe3/x88/x88", "PARENTHESIZED HANGUL CIEUC");
+-   ("/xe3/x88/x89", "PARENTHESIZED HANGUL CHIEUCH");
+-   ("/xe3/x88/x8a", "PARENTHESIZED HANGUL KHIEUKH");
+-   ("/xe3/x88/x8b", "PARENTHESIZED HANGUL THIEUTH");
+-   ("/xe3/x88/x8c", "PARENTHESIZED HANGUL PHIEUPH");
+-   ("/xe3/x88/x8d", "PARENTHESIZED HANGUL HIEUH");
+-   ("/xe3/x88/x8e", "PARENTHESIZED HANGUL KIYEOK A");
+-   ("/xe3/x88/x8f", "PARENTHESIZED HANGUL NIEUN A");
+-   ("/xe3/x88/x90", "PARENTHESIZED HANGUL TIKEUT A");
+-   ("/xe3/x88/x91", "PARENTHESIZED HANGUL RIEUL A");
+-   ("/xe3/x88/x92", "PARENTHESIZED HANGUL MIEUM A");
+-   ("/xe3/x88/x93", "PARENTHESIZED HANGUL PIEUP A");
+-   ("/xe3/x88/x94", "PARENTHESIZED HANGUL SIOS A");
+-   ("/xe3/x88/x95", "PARENTHESIZED HANGUL IEUNG A");
+-   ("/xe3/x88/x96", "PARENTHESIZED HANGUL CIEUC A");
+-   ("/xe3/x88/x97", "PARENTHESIZED HANGUL CHIEUCH A");
+-   ("/xe3/x88/x98", "PARENTHESIZED HANGUL KHIEUKH A");
+-   ("/xe3/x88/x99", "PARENTHESIZED HANGUL THIEUTH A");
+-   ("/xe3/x88/x9a", "PARENTHESIZED HANGUL PHIEUPH A");
+-   ("/xe3/x88/x9b", "PARENTHESIZED HANGUL HIEUH A");
+-   ("/xe3/x88/x9c", "PARENTHESIZED HANGUL CIEUC U");
+-   ("/xe3/x88/x9d", "PARENTHESIZED KOREAN CHARACTER OJEON");
+-   ("/xe3/x88/x9e", "PARENTHESIZED KOREAN CHARACTER O HU");
+-   ("/xe3/x88/xa0", "PARENTHESIZED IDEOGRAPH ONE");
+-   ("/xe3/x88/xa1", "PARENTHESIZED IDEOGRAPH TWO");
+-   ("/xe3/x88/xa2", "PARENTHESIZED IDEOGRAPH THREE");
+-   ("/xe3/x88/xa3", "PARENTHESIZED IDEOGRAPH FOUR");
+-   ("/xe3/x88/xa4", "PARENTHESIZED IDEOGRAPH FIVE");
+-   ("/xe3/x88/xa5", "PARENTHESIZED IDEOGRAPH SIX");
+-   ("/xe3/x88/xa6", "PARENTHESIZED IDEOGRAPH SEVEN");
+-   ("/xe3/x88/xa7", "PARENTHESIZED IDEOGRAPH EIGHT");
+-   ("/xe3/x88/xa8", "PARENTHESIZED IDEOGRAPH NINE");
+-   ("/xe3/x88/xa9", "PARENTHESIZED IDEOGRAPH TEN");
+-   ("/xe3/x88/xaa", "PARENTHESIZED IDEOGRAPH MOON");
+-   ("/xe3/x88/xab", "PARENTHESIZED IDEOGRAPH FIRE");
+-   ("/xe3/x88/xac", "PARENTHESIZED IDEOGRAPH WATER");
+-   ("/xe3/x88/xad", "PARENTHESIZED IDEOGRAPH WOOD");
+-   ("/xe3/x88/xae", "PARENTHESIZED IDEOGRAPH METAL");
+-   ("/xe3/x88/xaf", "PARENTHESIZED IDEOGRAPH EARTH");
+-   ("/xe3/x88/xb0", "PARENTHESIZED IDEOGRAPH SUN");
+-   ("/xe3/x88/xb1", "PARENTHESIZED IDEOGRAPH STOCK");
+-   ("/xe3/x88/xb2", "PARENTHESIZED IDEOGRAPH HAVE");
+-   ("/xe3/x88/xb3", "PARENTHESIZED IDEOGRAPH SOCIETY");
+-   ("/xe3/x88/xb4", "PARENTHESIZED IDEOGRAPH NAME");
+-   ("/xe3/x88/xb5", "PARENTHESIZED IDEOGRAPH SPECIAL");
+-   ("/xe3/x88/xb6", "PARENTHESIZED IDEOGRAPH FINANCIAL");
+-   ("/xe3/x88/xb7", "PARENTHESIZED IDEOGRAPH CONGRATULATION");
+-   ("/xe3/x88/xb8", "PARENTHESIZED IDEOGRAPH LABOR");
+-   ("/xe3/x88/xb9", "PARENTHESIZED IDEOGRAPH REPRESENT");
+-   ("/xe3/x88/xba", "PARENTHESIZED IDEOGRAPH CALL");
+-   ("/xe3/x88/xbb", "PARENTHESIZED IDEOGRAPH STUDY");
+-   ("/xe3/x88/xbc", "PARENTHESIZED IDEOGRAPH SUPERVISE");
+-   ("/xe3/x88/xbd", "PARENTHESIZED IDEOGRAPH ENTERPRISE");
+-   ("/xe3/x88/xbe", "PARENTHESIZED IDEOGRAPH RESOURCE");
+-   ("/xe3/x88/xbf", "PARENTHESIZED IDEOGRAPH ALLIANCE");
+-   ("/xe3/x89/x80", "PARENTHESIZED IDEOGRAPH FESTIVAL");
+-   ("/xe3/x89/x81", "PARENTHESIZED IDEOGRAPH REST");
+-   ("/xe3/x89/x82", "PARENTHESIZED IDEOGRAPH SELF");
+-   ("/xe3/x89/x83", "PARENTHESIZED IDEOGRAPH REACH");
+-   ("/xe3/x89/x90", "PARTNERSHIP SIGN");
+-   ("/xe3/x89/x91", "CIRCLED NUMBER TWENTY ONE");
+-   ("/xe3/x89/x92", "CIRCLED NUMBER TWENTY TWO");
+-   ("/xe3/x89/x93", "CIRCLED NUMBER TWENTY THREE");
+-   ("/xe3/x89/x94", "CIRCLED NUMBER TWENTY FOUR");
+-   ("/xe3/x89/x95", "CIRCLED NUMBER TWENTY FIVE");
+-   ("/xe3/x89/x96", "CIRCLED NUMBER TWENTY SIX");
+-   ("/xe3/x89/x97", "CIRCLED NUMBER TWENTY SEVEN");
+-   ("/xe3/x89/x98", "CIRCLED NUMBER TWENTY EIGHT");
+-   ("/xe3/x89/x99", "CIRCLED NUMBER TWENTY NINE");
+-   ("/xe3/x89/x9a", "CIRCLED NUMBER THIRTY");
+-   ("/xe3/x89/x9b", "CIRCLED NUMBER THIRTY ONE");
+-   ("/xe3/x89/x9c", "CIRCLED NUMBER THIRTY TWO");
+-   ("/xe3/x89/x9d", "CIRCLED NUMBER THIRTY THREE");
+-   ("/xe3/x89/x9e", "CIRCLED NUMBER THIRTY FOUR");
+-   ("/xe3/x89/x9f", "CIRCLED NUMBER THIRTY FIVE");
+-   ("/xe3/x89/xa0", "CIRCLED HANGUL KIYEOK");
+-   ("/xe3/x89/xa1", "CIRCLED HANGUL NIEUN");
+-   ("/xe3/x89/xa2", "CIRCLED HANGUL TIKEUT");
+-   ("/xe3/x89/xa3", "CIRCLED HANGUL RIEUL");
+-   ("/xe3/x89/xa4", "CIRCLED HANGUL MIEUM");
+-   ("/xe3/x89/xa5", "CIRCLED HANGUL PIEUP");
+-   ("/xe3/x89/xa6", "CIRCLED HANGUL SIOS");
+-   ("/xe3/x89/xa7", "CIRCLED HANGUL IEUNG");
+-   ("/xe3/x89/xa8", "CIRCLED HANGUL CIEUC");
+-   ("/xe3/x89/xa9", "CIRCLED HANGUL CHIEUCH");
+-   ("/xe3/x89/xaa", "CIRCLED HANGUL KHIEUKH");
+-   ("/xe3/x89/xab", "CIRCLED HANGUL THIEUTH");
+-   ("/xe3/x89/xac", "CIRCLED HANGUL PHIEUPH");
+-   ("/xe3/x89/xad", "CIRCLED HANGUL HIEUH");
+-   ("/xe3/x89/xae", "CIRCLED HANGUL KIYEOK A");
+-   ("/xe3/x89/xaf", "CIRCLED HANGUL NIEUN A");
+-   ("/xe3/x89/xb0", "CIRCLED HANGUL TIKEUT A");
+-   ("/xe3/x89/xb1", "CIRCLED HANGUL RIEUL A");
+-   ("/xe3/x89/xb2", "CIRCLED HANGUL MIEUM A");
+-   ("/xe3/x89/xb3", "CIRCLED HANGUL PIEUP A");
+-   ("/xe3/x89/xb4", "CIRCLED HANGUL SIOS A");
+-   ("/xe3/x89/xb5", "CIRCLED HANGUL IEUNG A");
+-   ("/xe3/x89/xb6", "CIRCLED HANGUL CIEUC A");
+-   ("/xe3/x89/xb7", "CIRCLED HANGUL CHIEUCH A");
+-   ("/xe3/x89/xb8", "CIRCLED HANGUL KHIEUKH A");
+-   ("/xe3/x89/xb9", "CIRCLED HANGUL THIEUTH A");
+-   ("/xe3/x89/xba", "CIRCLED HANGUL PHIEUPH A");
+-   ("/xe3/x89/xbb", "CIRCLED HANGUL HIEUH A");
+-   ("/xe3/x89/xbc", "CIRCLED KOREAN CHARACTER CHAMKO");
+-   ("/xe3/x89/xbd", "CIRCLED KOREAN CHARACTER JUEUI");
+-   ("/xe3/x89/xbe", "CIRCLED HANGUL IEUNG U");
+-   ("/xe3/x89/xbf", "KOREAN STANDARD SYMBOL");
+-   ("/xe3/x8a/x80", "CIRCLED IDEOGRAPH ONE");
+-   ("/xe3/x8a/x81", "CIRCLED IDEOGRAPH TWO");
+-   ("/xe3/x8a/x82", "CIRCLED IDEOGRAPH THREE");
+-   ("/xe3/x8a/x83", "CIRCLED IDEOGRAPH FOUR");
+-   ("/xe3/x8a/x84", "CIRCLED IDEOGRAPH FIVE");
+-   ("/xe3/x8a/x85", "CIRCLED IDEOGRAPH SIX");
+-   ("/xe3/x8a/x86", "CIRCLED IDEOGRAPH SEVEN");
+-   ("/xe3/x8a/x87", "CIRCLED IDEOGRAPH EIGHT");
+-   ("/xe3/x8a/x88", "CIRCLED IDEOGRAPH NINE");
+-   ("/xe3/x8a/x89", "CIRCLED IDEOGRAPH TEN");
+-   ("/xe3/x8a/x8a", "CIRCLED IDEOGRAPH MOON");
+-   ("/xe3/x8a/x8b", "CIRCLED IDEOGRAPH FIRE");
+-   ("/xe3/x8a/x8c", "CIRCLED IDEOGRAPH WATER");
+-   ("/xe3/x8a/x8d", "CIRCLED IDEOGRAPH WOOD");
+-   ("/xe3/x8a/x8e", "CIRCLED IDEOGRAPH METAL");
+-   ("/xe3/x8a/x8f", "CIRCLED IDEOGRAPH EARTH");
+-   ("/xe3/x8a/x90", "CIRCLED IDEOGRAPH SUN");
+-   ("/xe3/x8a/x91", "CIRCLED IDEOGRAPH STOCK");
+-   ("/xe3/x8a/x92", "CIRCLED IDEOGRAPH HAVE");
+-   ("/xe3/x8a/x93", "CIRCLED IDEOGRAPH SOCIETY");
+-   ("/xe3/x8a/x94", "CIRCLED IDEOGRAPH NAME");
+-   ("/xe3/x8a/x95", "CIRCLED IDEOGRAPH SPECIAL");
+-   ("/xe3/x8a/x96", "CIRCLED IDEOGRAPH FINANCIAL");
+-   ("/xe3/x8a/x97", "CIRCLED IDEOGRAPH CONGRATULATION");
+-   ("/xe3/x8a/x98", "CIRCLED IDEOGRAPH LABOR");
+-   ("/xe3/x8a/x99", "CIRCLED IDEOGRAPH SECRET");
+-   ("/xe3/x8a/x9a", "CIRCLED IDEOGRAPH MALE");
+-   ("/xe3/x8a/x9b", "CIRCLED IDEOGRAPH FEMALE");
+-   ("/xe3/x8a/x9c", "CIRCLED IDEOGRAPH SUITABLE");
+-   ("/xe3/x8a/x9d", "CIRCLED IDEOGRAPH EXCELLENT");
+-   ("/xe3/x8a/x9e", "CIRCLED IDEOGRAPH PRINT");
+-   ("/xe3/x8a/x9f", "CIRCLED IDEOGRAPH ATTENTION");
+-   ("/xe3/x8a/xa0", "CIRCLED IDEOGRAPH ITEM");
+-   ("/xe3/x8a/xa1", "CIRCLED IDEOGRAPH REST");
+-   ("/xe3/x8a/xa2", "CIRCLED IDEOGRAPH COPY");
+-   ("/xe3/x8a/xa3", "CIRCLED IDEOGRAPH CORRECT");
+-   ("/xe3/x8a/xa4", "CIRCLED IDEOGRAPH HIGH");
+-   ("/xe3/x8a/xa5", "CIRCLED IDEOGRAPH CENTRE");
+-   ("/xe3/x8a/xa6", "CIRCLED IDEOGRAPH LOW");
+-   ("/xe3/x8a/xa7", "CIRCLED IDEOGRAPH LEFT");
+-   ("/xe3/x8a/xa8", "CIRCLED IDEOGRAPH RIGHT");
+-   ("/xe3/x8a/xa9", "CIRCLED IDEOGRAPH MEDICINE");
+-   ("/xe3/x8a/xaa", "CIRCLED IDEOGRAPH RELIGION");
+-   ("/xe3/x8a/xab", "CIRCLED IDEOGRAPH STUDY");
+-   ("/xe3/x8a/xac", "CIRCLED IDEOGRAPH SUPERVISE");
+-   ("/xe3/x8a/xad", "CIRCLED IDEOGRAPH ENTERPRISE");
+-   ("/xe3/x8a/xae", "CIRCLED IDEOGRAPH RESOURCE");
+-   ("/xe3/x8a/xaf", "CIRCLED IDEOGRAPH ALLIANCE");
+-   ("/xe3/x8a/xb0", "CIRCLED IDEOGRAPH NIGHT");
+-   ("/xe3/x8a/xb1", "CIRCLED NUMBER THIRTY SIX");
+-   ("/xe3/x8a/xb2", "CIRCLED NUMBER THIRTY SEVEN");
+-   ("/xe3/x8a/xb3", "CIRCLED NUMBER THIRTY EIGHT");
+-   ("/xe3/x8a/xb4", "CIRCLED NUMBER THIRTY NINE");
+-   ("/xe3/x8a/xb5", "CIRCLED NUMBER FORTY");
+-   ("/xe3/x8a/xb6", "CIRCLED NUMBER FORTY ONE");
+-   ("/xe3/x8a/xb7", "CIRCLED NUMBER FORTY TWO");
+-   ("/xe3/x8a/xb8", "CIRCLED NUMBER FORTY THREE");
+-   ("/xe3/x8a/xb9", "CIRCLED NUMBER FORTY FOUR");
+-   ("/xe3/x8a/xba", "CIRCLED NUMBER FORTY FIVE");
+-   ("/xe3/x8a/xbb", "CIRCLED NUMBER FORTY SIX");
+-   ("/xe3/x8a/xbc", "CIRCLED NUMBER FORTY SEVEN");
+-   ("/xe3/x8a/xbd", "CIRCLED NUMBER FORTY EIGHT");
+-   ("/xe3/x8a/xbe", "CIRCLED NUMBER FORTY NINE");
+-   ("/xe3/x8a/xbf", "CIRCLED NUMBER FIFTY");
+-   ("/xe3/x8b/x80", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY");
+-   ("/xe3/x8b/x81", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR FEBRUARY");
+-   ("/xe3/x8b/x82", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR MARCH");
+-   ("/xe3/x8b/x83", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR APRIL");
+-   ("/xe3/x8b/x84", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR MAY");
+-   ("/xe3/x8b/x85", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JUNE");
+-   ("/xe3/x8b/x86", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JULY");
+-   ("/xe3/x8b/x87", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR AUGUST");
+-   ("/xe3/x8b/x88", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR SEPTEMBER");
+-   ("/xe3/x8b/x89", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR OCTOBER");
+-   ("/xe3/x8b/x8a", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR NOVEMBER");
+-   ("/xe3/x8b/x8b", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER");
+-   ("/xe3/x8b/x8c", "SQUARE HG");
+-   ("/xe3/x8b/x8d", "SQUARE ERG");
+-   ("/xe3/x8b/x8e", "SQUARE EV");
+-   ("/xe3/x8b/x8f", "LIMITED LIABILITY SIGN");
+-   ("/xe3/x8b/x90", "CIRCLED KATAKANA A");
+-   ("/xe3/x8b/x91", "CIRCLED KATAKANA I");
+-   ("/xe3/x8b/x92", "CIRCLED KATAKANA U");
+-   ("/xe3/x8b/x93", "CIRCLED KATAKANA E");
+-   ("/xe3/x8b/x94", "CIRCLED KATAKANA O");
+-   ("/xe3/x8b/x95", "CIRCLED KATAKANA KA");
+-   ("/xe3/x8b/x96", "CIRCLED KATAKANA KI");
+-   ("/xe3/x8b/x97", "CIRCLED KATAKANA KU");
+-   ("/xe3/x8b/x98", "CIRCLED KATAKANA KE");
+-   ("/xe3/x8b/x99", "CIRCLED KATAKANA KO");
+-   ("/xe3/x8b/x9a", "CIRCLED KATAKANA SA");
+-   ("/xe3/x8b/x9b", "CIRCLED KATAKANA SI");
+-   ("/xe3/x8b/x9c", "CIRCLED KATAKANA SU");
+-   ("/xe3/x8b/x9d", "CIRCLED KATAKANA SE");
+-   ("/xe3/x8b/x9e", "CIRCLED KATAKANA SO");
+-   ("/xe3/x8b/x9f", "CIRCLED KATAKANA TA");
+-   ("/xe3/x8b/xa0", "CIRCLED KATAKANA TI");
+-   ("/xe3/x8b/xa1", "CIRCLED KATAKANA TU");
+-   ("/xe3/x8b/xa2", "CIRCLED KATAKANA TE");
+-   ("/xe3/x8b/xa3", "CIRCLED KATAKANA TO");
+-   ("/xe3/x8b/xa4", "CIRCLED KATAKANA NA");
+-   ("/xe3/x8b/xa5", "CIRCLED KATAKANA NI");
+-   ("/xe3/x8b/xa6", "CIRCLED KATAKANA NU");
+-   ("/xe3/x8b/xa7", "CIRCLED KATAKANA NE");
+-   ("/xe3/x8b/xa8", "CIRCLED KATAKANA NO");
+-   ("/xe3/x8b/xa9", "CIRCLED KATAKANA HA");
+-   ("/xe3/x8b/xaa", "CIRCLED KATAKANA HI");
+-   ("/xe3/x8b/xab", "CIRCLED KATAKANA HU");
+-   ("/xe3/x8b/xac", "CIRCLED KATAKANA HE");
+-   ("/xe3/x8b/xad", "CIRCLED KATAKANA HO");
+-   ("/xe3/x8b/xae", "CIRCLED KATAKANA MA");
+-   ("/xe3/x8b/xaf", "CIRCLED KATAKANA MI");
+-   ("/xe3/x8b/xb0", "CIRCLED KATAKANA MU");
+-   ("/xe3/x8b/xb1", "CIRCLED KATAKANA ME");
+-   ("/xe3/x8b/xb2", "CIRCLED KATAKANA MO");
+-   ("/xe3/x8b/xb3", "CIRCLED KATAKANA YA");
+-   ("/xe3/x8b/xb4", "CIRCLED KATAKANA YU");
+-   ("/xe3/x8b/xb5", "CIRCLED KATAKANA YO");
+-   ("/xe3/x8b/xb6", "CIRCLED KATAKANA RA");
+-   ("/xe3/x8b/xb7", "CIRCLED KATAKANA RI");
+-   ("/xe3/x8b/xb8", "CIRCLED KATAKANA RU");
+-   ("/xe3/x8b/xb9", "CIRCLED KATAKANA RE");
+-   ("/xe3/x8b/xba", "CIRCLED KATAKANA RO");
+-   ("/xe3/x8b/xbb", "CIRCLED KATAKANA WA");
+-   ("/xe3/x8b/xbc", "CIRCLED KATAKANA WI");
+-   ("/xe3/x8b/xbd", "CIRCLED KATAKANA WE");
+-   ("/xe3/x8b/xbe", "CIRCLED KATAKANA WO");
+-   ("/xe3/x8c/x80", "SQUARE APAATO");
+-   ("/xe3/x8c/x81", "SQUARE ARUHUA");
+-   ("/xe3/x8c/x82", "SQUARE ANPEA");
+-   ("/xe3/x8c/x83", "SQUARE AARU");
+-   ("/xe3/x8c/x84", "SQUARE ININGU");
+-   ("/xe3/x8c/x85", "SQUARE INTI");
+-   ("/xe3/x8c/x86", "SQUARE UON");
+-   ("/xe3/x8c/x87", "SQUARE ESUKUUDO");
+-   ("/xe3/x8c/x88", "SQUARE EEKAA");
+-   ("/xe3/x8c/x89", "SQUARE ONSU");
+-   ("/xe3/x8c/x8a", "SQUARE OOMU");
+-   ("/xe3/x8c/x8b", "SQUARE KAIRI");
+-   ("/xe3/x8c/x8c", "SQUARE KARATTO");
+-   ("/xe3/x8c/x8d", "SQUARE KARORII");
+-   ("/xe3/x8c/x8e", "SQUARE GARON");
+-   ("/xe3/x8c/x8f", "SQUARE GANMA");
+-   ("/xe3/x8c/x90", "SQUARE GIGA");
+-   ("/xe3/x8c/x91", "SQUARE GINII");
+-   ("/xe3/x8c/x92", "SQUARE KYURII");
+-   ("/xe3/x8c/x93", "SQUARE GIRUDAA");
+-   ("/xe3/x8c/x94", "SQUARE KIRO");
+-   ("/xe3/x8c/x95", "SQUARE KIROGURAMU");
+-   ("/xe3/x8c/x96", "SQUARE KIROMEETORU");
+-   ("/xe3/x8c/x97", "SQUARE KIROWATTO");
+-   ("/xe3/x8c/x98", "SQUARE GURAMU");
+-   ("/xe3/x8c/x99", "SQUARE GURAMUTON");
+-   ("/xe3/x8c/x9a", "SQUARE KURUZEIRO");
+-   ("/xe3/x8c/x9b", "SQUARE KUROONE");
+-   ("/xe3/x8c/x9c", "SQUARE KEESU");
+-   ("/xe3/x8c/x9d", "SQUARE KORUNA");
+-   ("/xe3/x8c/x9e", "SQUARE KOOPO");
+-   ("/xe3/x8c/x9f", "SQUARE SAIKURU");
+-   ("/xe3/x8c/xa0", "SQUARE SANTIIMU");
+-   ("/xe3/x8c/xa1", "SQUARE SIRINGU");
+-   ("/xe3/x8c/xa2", "SQUARE SENTI");
+-   ("/xe3/x8c/xa3", "SQUARE SENTO");
+-   ("/xe3/x8c/xa4", "SQUARE DAASU");
+-   ("/xe3/x8c/xa5", "SQUARE DESI");
+-   ("/xe3/x8c/xa6", "SQUARE DORU");
+-   ("/xe3/x8c/xa7", "SQUARE TON");
+-   ("/xe3/x8c/xa8", "SQUARE NANO");
+-   ("/xe3/x8c/xa9", "SQUARE NOTTO");
+-   ("/xe3/x8c/xaa", "SQUARE HAITU");
+-   ("/xe3/x8c/xab", "SQUARE PAASENTO");
+-   ("/xe3/x8c/xac", "SQUARE PAATU");
+-   ("/xe3/x8c/xad", "SQUARE BAARERU");
+-   ("/xe3/x8c/xae", "SQUARE PIASUTORU");
+-   ("/xe3/x8c/xaf", "SQUARE PIKURU");
+-   ("/xe3/x8c/xb0", "SQUARE PIKO");
+-   ("/xe3/x8c/xb1", "SQUARE BIRU");
+-   ("/xe3/x8c/xb2", "SQUARE HUARADDO");
+-   ("/xe3/x8c/xb3", "SQUARE HUIITO");
+-   ("/xe3/x8c/xb4", "SQUARE BUSSYERU");
+-   ("/xe3/x8c/xb5", "SQUARE HURAN");
+-   ("/xe3/x8c/xb6", "SQUARE HEKUTAARU");
+-   ("/xe3/x8c/xb7", "SQUARE PESO");
+-   ("/xe3/x8c/xb8", "SQUARE PENIHI");
+-   ("/xe3/x8c/xb9", "SQUARE HERUTU");
+-   ("/xe3/x8c/xba", "SQUARE PENSU");
+-   ("/xe3/x8c/xbb", "SQUARE PEEZI");
+-   ("/xe3/x8c/xbc", "SQUARE BEETA");
+-   ("/xe3/x8c/xbd", "SQUARE POINTO");
+-   ("/xe3/x8c/xbe", "SQUARE BORUTO");
+-   ("/xe3/x8c/xbf", "SQUARE HON");
+-   ("/xe3/x8d/x80", "SQUARE PONDO");
+-   ("/xe3/x8d/x81", "SQUARE HOORU");
+-   ("/xe3/x8d/x82", "SQUARE HOON");
+-   ("/xe3/x8d/x83", "SQUARE MAIKURO");
+-   ("/xe3/x8d/x84", "SQUARE MAIRU");
+-   ("/xe3/x8d/x85", "SQUARE MAHHA");
+-   ("/xe3/x8d/x86", "SQUARE MARUKU");
+-   ("/xe3/x8d/x87", "SQUARE MANSYON");
+-   ("/xe3/x8d/x88", "SQUARE MIKURON");
+-   ("/xe3/x8d/x89", "SQUARE MIRI");
+-   ("/xe3/x8d/x8a", "SQUARE MIRIBAARU");
+-   ("/xe3/x8d/x8b", "SQUARE MEGA");
+-   ("/xe3/x8d/x8c", "SQUARE MEGATON");
+-   ("/xe3/x8d/x8d", "SQUARE MEETORU");
+-   ("/xe3/x8d/x8e", "SQUARE YAADO");
+-   ("/xe3/x8d/x8f", "SQUARE YAARU");
+-   ("/xe3/x8d/x90", "SQUARE YUAN");
+-   ("/xe3/x8d/x91", "SQUARE RITTORU");
+-   ("/xe3/x8d/x92", "SQUARE RIRA");
+-   ("/xe3/x8d/x93", "SQUARE RUPII");
+-   ("/xe3/x8d/x94", "SQUARE RUUBURU");
+-   ("/xe3/x8d/x95", "SQUARE REMU");
+-   ("/xe3/x8d/x96", "SQUARE RENTOGEN");
+-   ("/xe3/x8d/x97", "SQUARE WATTO");
+-   ("/xe3/x8d/x98", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO");
+-   ("/xe3/x8d/x99", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ONE");
+-   ("/xe3/x8d/x9a", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWO");
+-   ("/xe3/x8d/x9b", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THREE");
+-   ("/xe3/x8d/x9c", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOUR");
+-   ("/xe3/x8d/x9d", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIVE");
+-   ("/xe3/x8d/x9e", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIX");
+-   ("/xe3/x8d/x9f", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVEN");
+-   ("/xe3/x8d/xa0", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHT");
+-   ("/xe3/x8d/xa1", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINE");
+-   ("/xe3/x8d/xa2", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TEN");
+-   ("/xe3/x8d/xa3", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ELEVEN");
+-   ("/xe3/x8d/xa4", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWELVE");
+-   ("/xe3/x8d/xa5", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THIRTEEN");
+-   ("/xe3/x8d/xa6", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOURTEEN");
+-   ("/xe3/x8d/xa7", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIFTEEN");
+-   ("/xe3/x8d/xa8", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIXTEEN");
+-   ("/xe3/x8d/xa9", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVENTEEN");
+-   ("/xe3/x8d/xaa", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHTEEN");
+-   ("/xe3/x8d/xab", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINETEEN");
+-   ("/xe3/x8d/xac", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY");
+-   ("/xe3/x8d/xad", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-ONE");
+-   ("/xe3/x8d/xae", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-TWO");
+-   ("/xe3/x8d/xaf", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-THREE");
+-   ("/xe3/x8d/xb0", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR");
+-   ("/xe3/x8d/xb1", "SQUARE HPA");
+-   ("/xe3/x8d/xb2", "SQUARE DA");
+-   ("/xe3/x8d/xb3", "SQUARE AU");
+-   ("/xe3/x8d/xb4", "SQUARE BAR");
+-   ("/xe3/x8d/xb5", "SQUARE OV");
+-   ("/xe3/x8d/xb6", "SQUARE PC");
+-   ("/xe3/x8d/xb7", "SQUARE DM");
+-   ("/xe3/x8d/xb8", "SQUARE DM SQUARED");
+-   ("/xe3/x8d/xb9", "SQUARE DM CUBED");
+-   ("/xe3/x8d/xba", "SQUARE IU");
+-   ("/xe3/x8d/xbb", "SQUARE ERA NAME HEISEI");
+-   ("/xe3/x8d/xbc", "SQUARE ERA NAME SYOUWA");
+-   ("/xe3/x8d/xbd", "SQUARE ERA NAME TAISYOU");
+-   ("/xe3/x8d/xbe", "SQUARE ERA NAME MEIZI");
+-   ("/xe3/x8d/xbf", "SQUARE CORPORATION");
+-   ("/xe3/x8e/x80", "SQUARE PA AMPS");
+-   ("/xe3/x8e/x81", "SQUARE NA");
+-   ("/xe3/x8e/x82", "SQUARE MU A");
+-   ("/xe3/x8e/x83", "SQUARE MA");
+-   ("/xe3/x8e/x84", "SQUARE KA");
+-   ("/xe3/x8e/x85", "SQUARE KB");
+-   ("/xe3/x8e/x86", "SQUARE MB");
+-   ("/xe3/x8e/x87", "SQUARE GB");
+-   ("/xe3/x8e/x88", "SQUARE CAL");
+-   ("/xe3/x8e/x89", "SQUARE KCAL");
+-   ("/xe3/x8e/x8a", "SQUARE PF");
+-   ("/xe3/x8e/x8b", "SQUARE NF");
+-   ("/xe3/x8e/x8c", "SQUARE MU F");
+-   ("/xe3/x8e/x8d", "SQUARE MU G");
+-   ("/xe3/x8e/x8e", "SQUARE MG");
+-   ("/xe3/x8e/x8f", "SQUARE KG");
+-   ("/xe3/x8e/x90", "SQUARE HZ");
+-   ("/xe3/x8e/x91", "SQUARE KHZ");
+-   ("/xe3/x8e/x92", "SQUARE MHZ");
+-   ("/xe3/x8e/x93", "SQUARE GHZ");
+-   ("/xe3/x8e/x94", "SQUARE THZ");
+-   ("/xe3/x8e/x95", "SQUARE MU L");
+-   ("/xe3/x8e/x96", "SQUARE ML");
+-   ("/xe3/x8e/x97", "SQUARE DL");
+-   ("/xe3/x8e/x98", "SQUARE KL");
+-   ("/xe3/x8e/x99", "SQUARE FM");
+-   ("/xe3/x8e/x9a", "SQUARE NM");
+-   ("/xe3/x8e/x9b", "SQUARE MU M");
+-   ("/xe3/x8e/x9c", "SQUARE MM");
+-   ("/xe3/x8e/x9d", "SQUARE CM");
+-   ("/xe3/x8e/x9e", "SQUARE KM");
+-   ("/xe3/x8e/x9f", "SQUARE MM SQUARED");
+-   ("/xe3/x8e/xa0", "SQUARE CM SQUARED");
+-   ("/xe3/x8e/xa1", "SQUARE M SQUARED");
+-   ("/xe3/x8e/xa2", "SQUARE KM SQUARED");
+-   ("/xe3/x8e/xa3", "SQUARE MM CUBED");
+-   ("/xe3/x8e/xa4", "SQUARE CM CUBED");
+-   ("/xe3/x8e/xa5", "SQUARE M CUBED");
+-   ("/xe3/x8e/xa6", "SQUARE KM CUBED");
+-   ("/xe3/x8e/xa7", "SQUARE M OVER S");
+-   ("/xe3/x8e/xa8", "SQUARE M OVER S SQUARED");
+-   ("/xe3/x8e/xa9", "SQUARE PA");
+-   ("/xe3/x8e/xaa", "SQUARE KPA");
+-   ("/xe3/x8e/xab", "SQUARE MPA");
+-   ("/xe3/x8e/xac", "SQUARE GPA");
+-   ("/xe3/x8e/xad", "SQUARE RAD");
+-   ("/xe3/x8e/xae", "SQUARE RAD OVER S");
+-   ("/xe3/x8e/xaf", "SQUARE RAD OVER S SQUARED");
+-   ("/xe3/x8e/xb0", "SQUARE PS");
+-   ("/xe3/x8e/xb1", "SQUARE NS");
+-   ("/xe3/x8e/xb2", "SQUARE MU S");
+-   ("/xe3/x8e/xb3", "SQUARE MS");
+-   ("/xe3/x8e/xb4", "SQUARE PV");
+-   ("/xe3/x8e/xb5", "SQUARE NV");
+-   ("/xe3/x8e/xb6", "SQUARE MU V");
+-   ("/xe3/x8e/xb7", "SQUARE MV");
+-   ("/xe3/x8e/xb8", "SQUARE KV");
+-   ("/xe3/x8e/xb9", "SQUARE MV MEGA");
+-   ("/xe3/x8e/xba", "SQUARE PW");
+-   ("/xe3/x8e/xbb", "SQUARE NW");
+-   ("/xe3/x8e/xbc", "SQUARE MU W");
+-   ("/xe3/x8e/xbd", "SQUARE MW");
+-   ("/xe3/x8e/xbe", "SQUARE KW");
+-   ("/xe3/x8e/xbf", "SQUARE MW MEGA");
+-   ("/xe3/x8f/x80", "SQUARE K OHM");
+-   ("/xe3/x8f/x81", "SQUARE M OHM");
+-   ("/xe3/x8f/x82", "SQUARE AM");
+-   ("/xe3/x8f/x83", "SQUARE BQ");
+-   ("/xe3/x8f/x84", "SQUARE CC");
+-   ("/xe3/x8f/x85", "SQUARE CD");
+-   ("/xe3/x8f/x86", "SQUARE C OVER KG");
+-   ("/xe3/x8f/x87", "SQUARE CO");
+-   ("/xe3/x8f/x88", "SQUARE DB");
+-   ("/xe3/x8f/x89", "SQUARE GY");
+-   ("/xe3/x8f/x8a", "SQUARE HA");
+-   ("/xe3/x8f/x8b", "SQUARE HP");
+-   ("/xe3/x8f/x8c", "SQUARE IN");
+-   ("/xe3/x8f/x8d", "SQUARE KK");
+    ("/xe3/x8f/x8e", "SQUARE KM CAPITAL");
+-   ("/xe3/x8f/x8f", "SQUARE KT");
+-   ("/xe3/x8f/x90", "SQUARE LM");
+-   ("/xe3/x8f/x91", "SQUARE LN");
+-   ("/xe3/x8f/x92", "SQUARE LOG");
+-   ("/xe3/x8f/x93", "SQUARE LX");
+    ("/xe3/x8f/x94", "SQUARE MB SMALL");
+-   ("/xe3/x8f/x95", "SQUARE MIL");
+-   ("/xe3/x8f/x96", "SQUARE MOL");
+-   ("/xe3/x8f/x97", "SQUARE PH");
+-   ("/xe3/x8f/x98", "SQUARE PM");
+-   ("/xe3/x8f/x99", "SQUARE PPM");
+-   ("/xe3/x8f/x9a", "SQUARE PR");
+-   ("/xe3/x8f/x9b", "SQUARE SR");
+-   ("/xe3/x8f/x9c", "SQUARE SV");
+-   ("/xe3/x8f/x9d", "SQUARE WB");
+-   ("/xe3/x8f/x9e", "SQUARE V OVER M");
+-   ("/xe3/x8f/x9f", "SQUARE A OVER M");
+-   ("/xe3/x8f/xa0", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE");
+-   ("/xe3/x8f/xa1", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWO");
+-   ("/xe3/x8f/xa2", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THREE");
+-   ("/xe3/x8f/xa3", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOUR");
+-   ("/xe3/x8f/xa4", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIVE");
+-   ("/xe3/x8f/xa5", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIX");
+-   ("/xe3/x8f/xa6", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVEN");
+-   ("/xe3/x8f/xa7", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHT");
+-   ("/xe3/x8f/xa8", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINE");
+-   ("/xe3/x8f/xa9", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TEN");
+-   ("/xe3/x8f/xaa", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ELEVEN");
+-   ("/xe3/x8f/xab", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWELVE");
+-   ("/xe3/x8f/xac", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTEEN");
+-   ("/xe3/x8f/xad", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOURTEEN");
+-   ("/xe3/x8f/xae", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIFTEEN");
+-   ("/xe3/x8f/xaf", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIXTEEN");
+-   ("/xe3/x8f/xb0", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVENTEEN");
+-   ("/xe3/x8f/xb1", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHTEEN");
+-   ("/xe3/x8f/xb2", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINETEEN");
+-   ("/xe3/x8f/xb3", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY");
+-   ("/xe3/x8f/xb4", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-ONE");
+-   ("/xe3/x8f/xb5", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-TWO");
+-   ("/xe3/x8f/xb6", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-THREE");
+-   ("/xe3/x8f/xb7", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FOUR");
+-   ("/xe3/x8f/xb8", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FIVE");
+-   ("/xe3/x8f/xb9", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SIX");
+-   ("/xe3/x8f/xba", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SEVEN");
+-   ("/xe3/x8f/xbb", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-EIGHT");
+-   ("/xe3/x8f/xbc", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-NINE");
+-   ("/xe3/x8f/xbd", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY");
+-   ("/xe3/x8f/xbe", "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE");
+-   ("/xe3/x8f/xbf", "SQUARE GAL");
+-   ("/xe3/x90/x80", "<CJK>");
+-   ("/xe3/x91/x80", "<CJK>");
+-   ("/xe3/x92/x80", "<CJK>");
+-   ("/xe3/x93/x80", "<CJK>");
+-   ("/xe3/x94/x80", "<CJK>");
+-   ("/xe3/x95/x80", "<CJK>");
+-   ("/xe3/x96/x80", "<CJK>");
+-   ("/xe3/x97/x80", "<CJK>");
+-   ("/xe3/x98/x80", "<CJK>");
+-   ("/xe3/x99/x80", "<CJK>");
+-   ("/xe3/x9a/x80", "<CJK>");
+-   ("/xe3/x9b/x80", "<CJK>");
+-   ("/xe3/x9c/x80", "<CJK>");
+-   ("/xe3/x9d/x80", "<CJK>");
+-   ("/xe3/x9e/x80", "<CJK>");
+-   ("/xe3/x9f/x80", "<CJK>");
+-   ("/xe3/xa0/x80", "<CJK>");
+-   ("/xe3/xa1/x80", "<CJK>");
+-   ("/xe3/xa2/x80", "<CJK>");
+-   ("/xe3/xa3/x80", "<CJK>");
+-   ("/xe3/xa4/x80", "<CJK>");
+-   ("/xe3/xa5/x80", "<CJK>");
+-   ("/xe3/xa6/x80", "<CJK>");
+-   ("/xe3/xa7/x80", "<CJK>");
+-   ("/xe3/xa8/x80", "<CJK>");
+-   ("/xe3/xa9/x80", "<CJK>");
+-   ("/xe3/xaa/x80", "<CJK>");
+-   ("/xe3/xab/x80", "<CJK>");
+-   ("/xe3/xac/x80", "<CJK>");
+-   ("/xe3/xad/x80", "<CJK>");
+-   ("/xe3/xae/x80", "<CJK>");
+-   ("/xe3/xaf/x80", "<CJK>");
+-   ("/xe3/xb0/x80", "<CJK>");
+-   ("/xe3/xb1/x80", "<CJK>");
+-   ("/xe3/xb2/x80", "<CJK>");
+-   ("/xe3/xb3/x80", "<CJK>");
+-   ("/xe3/xb4/x80", "<CJK>");
+-   ("/xe3/xb5/x80", "<CJK>");
+-   ("/xe3/xb6/x80", "<CJK>");
+-   ("/xe3/xb7/x80", "<CJK>");
+-   ("/xe3/xb8/x80", "<CJK>");
+-   ("/xe3/xb9/x80", "<CJK>");
+-   ("/xe3/xba/x80", "<CJK>");
+-   ("/xe3/xbb/x80", "<CJK>");
+-   ("/xe3/xbc/x80", "<CJK>");
+-   ("/xe3/xbd/x80", "<CJK>");
+-   ("/xe3/xbe/x80", "<CJK>");
+-   ("/xe3/xbf/x80", "<CJK>");
+-   ("/xe4/x80/x80", "<CJK>");
+-   ("/xe4/x81/x80", "<CJK>");
+-   ("/xe4/x82/x80", "<CJK>");
+-   ("/xe4/x83/x80", "<CJK>");
+-   ("/xe4/x84/x80", "<CJK>");
+-   ("/xe4/x85/x80", "<CJK>");
+-   ("/xe4/x86/x80", "<CJK>");
+-   ("/xe4/x87/x80", "<CJK>");
+-   ("/xe4/x88/x80", "<CJK>");
+-   ("/xe4/x89/x80", "<CJK>");
+-   ("/xe4/x8a/x80", "<CJK>");
+-   ("/xe4/x8b/x80", "<CJK>");
+-   ("/xe4/x8c/x80", "<CJK>");
+-   ("/xe4/x8d/x80", "<CJK>");
+-   ("/xe4/x8e/x80", "<CJK>");
+-   ("/xe4/x8f/x80", "<CJK>");
+-   ("/xe4/x90/x80", "<CJK>");
+-   ("/xe4/x91/x80", "<CJK>");
+-   ("/xe4/x92/x80", "<CJK>");
+-   ("/xe4/x93/x80", "<CJK>");
+-   ("/xe4/x94/x80", "<CJK>");
+-   ("/xe4/x95/x80", "<CJK>");
+-   ("/xe4/x96/x80", "<CJK>");
+-   ("/xe4/x97/x80", "<CJK>");
+-   ("/xe4/x98/x80", "<CJK>");
+-   ("/xe4/x99/x80", "<CJK>");
+-   ("/xe4/x9a/x80", "<CJK>");
+-   ("/xe4/x9b/x80", "<CJK>");
+-   ("/xe4/x9c/x80", "<CJK>");
+-   ("/xe4/x9d/x80", "<CJK>");
+-   ("/xe4/x9e/x80", "<CJK>");
+-   ("/xe4/x9f/x80", "<CJK>");
+-   ("/xe4/xa0/x80", "<CJK>");
+-   ("/xe4/xa1/x80", "<CJK>");
+-   ("/xe4/xa2/x80", "<CJK>");
+-   ("/xe4/xa3/x80", "<CJK>");
+-   ("/xe4/xa4/x80", "<CJK>");
+-   ("/xe4/xa5/x80", "<CJK>");
+-   ("/xe4/xa6/x80", "<CJK>");
+-   ("/xe4/xa7/x80", "<CJK>");
+-   ("/xe4/xa8/x80", "<CJK>");
+-   ("/xe4/xa9/x80", "<CJK>");
+-   ("/xe4/xaa/x80", "<CJK>");
+-   ("/xe4/xab/x80", "<CJK>");
+-   ("/xe4/xac/x80", "<CJK>");
+-   ("/xe4/xad/x80", "<CJK>");
+-   ("/xe4/xae/x80", "<CJK>");
+-   ("/xe4/xaf/x80", "<CJK>");
+-   ("/xe4/xb0/x80", "<CJK>");
+-   ("/xe4/xb1/x80", "<CJK>");
+-   ("/xe4/xb2/x80", "<CJK>");
+-   ("/xe4/xb3/x80", "<CJK>");
+-   ("/xe4/xb4/x80", "<CJK>");
+-   ("/xe4/xb5/x80", "<CJK>");
+-   ("/xe4/xb6/x80", "<CJK>");
+-   ("/xe4/xb7/x80", "HEXAGRAM FOR THE CREATIVE HEAVEN");
+-   ("/xe4/xb7/x81", "HEXAGRAM FOR THE RECEPTIVE EARTH");
+-   ("/xe4/xb7/x82", "HEXAGRAM FOR DIFFICULTY AT THE BEGINNING");
+-   ("/xe4/xb7/x83", "HEXAGRAM FOR YOUTHFUL FOLLY");
+-   ("/xe4/xb7/x84", "HEXAGRAM FOR WAITING");
+-   ("/xe4/xb7/x85", "HEXAGRAM FOR CONFLICT");
+-   ("/xe4/xb7/x86", "HEXAGRAM FOR THE ARMY");
+-   ("/xe4/xb7/x87", "HEXAGRAM FOR HOLDING TOGETHER");
+    ("/xe4/xb7/x88", "HEXAGRAM FOR SMALL TAMING");
+-   ("/xe4/xb7/x89", "HEXAGRAM FOR TREADING");
+-   ("/xe4/xb7/x8a", "HEXAGRAM FOR PEACE");
+-   ("/xe4/xb7/x8b", "HEXAGRAM FOR STANDSTILL");
+-   ("/xe4/xb7/x8c", "HEXAGRAM FOR FELLOWSHIP");
+-   ("/xe4/xb7/x8d", "HEXAGRAM FOR GREAT POSSESSION");
+-   ("/xe4/xb7/x8e", "HEXAGRAM FOR MODESTY");
+-   ("/xe4/xb7/x8f", "HEXAGRAM FOR ENTHUSIASM");
+-   ("/xe4/xb7/x90", "HEXAGRAM FOR FOLLOWING");
+-   ("/xe4/xb7/x91", "HEXAGRAM FOR WORK ON THE DECAYED");
+-   ("/xe4/xb7/x92", "HEXAGRAM FOR APPROACH");
+-   ("/xe4/xb7/x93", "HEXAGRAM FOR CONTEMPLATION");
+-   ("/xe4/xb7/x94", "HEXAGRAM FOR BITING THROUGH");
+-   ("/xe4/xb7/x95", "HEXAGRAM FOR GRACE");
+-   ("/xe4/xb7/x96", "HEXAGRAM FOR SPLITTING APART");
+-   ("/xe4/xb7/x97", "HEXAGRAM FOR RETURN");
+-   ("/xe4/xb7/x98", "HEXAGRAM FOR INNOCENCE");
+-   ("/xe4/xb7/x99", "HEXAGRAM FOR GREAT TAMING");
+-   ("/xe4/xb7/x9a", "HEXAGRAM FOR MOUTH CORNERS");
+-   ("/xe4/xb7/x9b", "HEXAGRAM FOR GREAT PREPONDERANCE");
+-   ("/xe4/xb7/x9c", "HEXAGRAM FOR THE ABYSMAL WATER");
+-   ("/xe4/xb7/x9d", "HEXAGRAM FOR THE CLINGING FIRE");
+-   ("/xe4/xb7/x9e", "HEXAGRAM FOR INFLUENCE");
+-   ("/xe4/xb7/x9f", "HEXAGRAM FOR DURATION");
+-   ("/xe4/xb7/xa0", "HEXAGRAM FOR RETREAT");
+-   ("/xe4/xb7/xa1", "HEXAGRAM FOR GREAT POWER");
+-   ("/xe4/xb7/xa2", "HEXAGRAM FOR PROGRESS");
+-   ("/xe4/xb7/xa3", "HEXAGRAM FOR DARKENING OF THE LIGHT");
+-   ("/xe4/xb7/xa4", "HEXAGRAM FOR THE FAMILY");
+-   ("/xe4/xb7/xa5", "HEXAGRAM FOR OPPOSITION");
+-   ("/xe4/xb7/xa6", "HEXAGRAM FOR OBSTRUCTION");
+-   ("/xe4/xb7/xa7", "HEXAGRAM FOR DELIVERANCE");
+-   ("/xe4/xb7/xa8", "HEXAGRAM FOR DECREASE");
+-   ("/xe4/xb7/xa9", "HEXAGRAM FOR INCREASE");
+-   ("/xe4/xb7/xaa", "HEXAGRAM FOR BREAKTHROUGH");
+-   ("/xe4/xb7/xab", "HEXAGRAM FOR COMING TO MEET");
+-   ("/xe4/xb7/xac", "HEXAGRAM FOR GATHERING TOGETHER");
+-   ("/xe4/xb7/xad", "HEXAGRAM FOR PUSHING UPWARD");
+-   ("/xe4/xb7/xae", "HEXAGRAM FOR OPPRESSION");
+-   ("/xe4/xb7/xaf", "HEXAGRAM FOR THE WELL");
+-   ("/xe4/xb7/xb0", "HEXAGRAM FOR REVOLUTION");
+-   ("/xe4/xb7/xb1", "HEXAGRAM FOR THE CAULDRON");
+-   ("/xe4/xb7/xb2", "HEXAGRAM FOR THE AROUSING THUNDER");
+-   ("/xe4/xb7/xb3", "HEXAGRAM FOR THE KEEPING STILL MOUNTAIN");
+-   ("/xe4/xb7/xb4", "HEXAGRAM FOR DEVELOPMENT");
+-   ("/xe4/xb7/xb5", "HEXAGRAM FOR THE MARRYING MAIDEN");
+-   ("/xe4/xb7/xb6", "HEXAGRAM FOR ABUNDANCE");
+-   ("/xe4/xb7/xb7", "HEXAGRAM FOR THE WANDERER");
+-   ("/xe4/xb7/xb8", "HEXAGRAM FOR THE GENTLE WIND");
+-   ("/xe4/xb7/xb9", "HEXAGRAM FOR THE JOYOUS LAKE");
+-   ("/xe4/xb7/xba", "HEXAGRAM FOR DISPERSION");
+-   ("/xe4/xb7/xbb", "HEXAGRAM FOR LIMITATION");
+-   ("/xe4/xb7/xbc", "HEXAGRAM FOR INNER TRUTH");
+    ("/xe4/xb7/xbd", "HEXAGRAM FOR SMALL PREPONDERANCE");
+-   ("/xe4/xb7/xbe", "HEXAGRAM FOR AFTER COMPLETION");
+-   ("/xe4/xb7/xbf", "HEXAGRAM FOR BEFORE COMPLETION");
+-   ("/xe4/xb8/x80", "<CJK>");
+-   ("/xe4/xb9/x80", "<CJK>");
+-   ("/xe4/xba/x80", "<CJK>");
+-   ("/xe4/xbb/x80", "<CJK>");
+-   ("/xe4/xbc/x80", "<CJK>");
+-   ("/xe4/xbd/x80", "<CJK>");
+-   ("/xe4/xbe/x80", "<CJK>");
+-   ("/xe4/xbf/x80", "<CJK>");
+-   ("/xe5/x80/x80", "<CJK>");
+-   ("/xe5/x81/x80", "<CJK>");
+-   ("/xe5/x82/x80", "<CJK>");
+-   ("/xe5/x83/x80", "<CJK>");
+-   ("/xe5/x84/x80", "<CJK>");
+-   ("/xe5/x85/x80", "<CJK>");
+-   ("/xe5/x86/x80", "<CJK>");
+-   ("/xe5/x87/x80", "<CJK>");
+-   ("/xe5/x88/x80", "<CJK>");
+-   ("/xe5/x89/x80", "<CJK>");
+-   ("/xe5/x8a/x80", "<CJK>");
+-   ("/xe5/x8b/x80", "<CJK>");
+-   ("/xe5/x8c/x80", "<CJK>");
+-   ("/xe5/x8d/x80", "<CJK>");
+-   ("/xe5/x8e/x80", "<CJK>");
+-   ("/xe5/x8f/x80", "<CJK>");
+-   ("/xe5/x90/x80", "<CJK>");
+-   ("/xe5/x91/x80", "<CJK>");
+-   ("/xe5/x92/x80", "<CJK>");
+-   ("/xe5/x93/x80", "<CJK>");
+-   ("/xe5/x94/x80", "<CJK>");
+-   ("/xe5/x95/x80", "<CJK>");
+-   ("/xe5/x96/x80", "<CJK>");
+-   ("/xe5/x97/x80", "<CJK>");
+-   ("/xe5/x98/x80", "<CJK>");
+-   ("/xe5/x99/x80", "<CJK>");
+-   ("/xe5/x9a/x80", "<CJK>");
+-   ("/xe5/x9b/x80", "<CJK>");
+-   ("/xe5/x9c/x80", "<CJK>");
+-   ("/xe5/x9d/x80", "<CJK>");
+-   ("/xe5/x9e/x80", "<CJK>");
+-   ("/xe5/x9f/x80", "<CJK>");
+-   ("/xe5/xa0/x80", "<CJK>");
+-   ("/xe5/xa1/x80", "<CJK>");
+-   ("/xe5/xa2/x80", "<CJK>");
+-   ("/xe5/xa3/x80", "<CJK>");
+-   ("/xe5/xa4/x80", "<CJK>");
+-   ("/xe5/xa5/x80", "<CJK>");
+-   ("/xe5/xa6/x80", "<CJK>");
+-   ("/xe5/xa7/x80", "<CJK>");
+-   ("/xe5/xa8/x80", "<CJK>");
+-   ("/xe5/xa9/x80", "<CJK>");
+-   ("/xe5/xaa/x80", "<CJK>");
+-   ("/xe5/xab/x80", "<CJK>");
+-   ("/xe5/xac/x80", "<CJK>");
+-   ("/xe5/xad/x80", "<CJK>");
+-   ("/xe5/xae/x80", "<CJK>");
+-   ("/xe5/xaf/x80", "<CJK>");
+-   ("/xe5/xb0/x80", "<CJK>");
+-   ("/xe5/xb1/x80", "<CJK>");
+-   ("/xe5/xb2/x80", "<CJK>");
+-   ("/xe5/xb3/x80", "<CJK>");
+-   ("/xe5/xb4/x80", "<CJK>");
+-   ("/xe5/xb5/x80", "<CJK>");
+-   ("/xe5/xb6/x80", "<CJK>");
+-   ("/xe5/xb7/x80", "<CJK>");
+-   ("/xe5/xb8/x80", "<CJK>");
+-   ("/xe5/xb9/x80", "<CJK>");
+-   ("/xe5/xba/x80", "<CJK>");
+-   ("/xe5/xbb/x80", "<CJK>");
+-   ("/xe5/xbc/x80", "<CJK>");
+-   ("/xe5/xbd/x80", "<CJK>");
+-   ("/xe5/xbe/x80", "<CJK>");
+-   ("/xe5/xbf/x80", "<CJK>");
+-   ("/xe6/x80/x80", "<CJK>");
+-   ("/xe6/x81/x80", "<CJK>");
+-   ("/xe6/x82/x80", "<CJK>");
+-   ("/xe6/x83/x80", "<CJK>");
+-   ("/xe6/x84/x80", "<CJK>");
+-   ("/xe6/x85/x80", "<CJK>");
+-   ("/xe6/x86/x80", "<CJK>");
+-   ("/xe6/x87/x80", "<CJK>");
+-   ("/xe6/x88/x80", "<CJK>");
+-   ("/xe6/x89/x80", "<CJK>");
+-   ("/xe6/x8a/x80", "<CJK>");
+-   ("/xe6/x8b/x80", "<CJK>");
+-   ("/xe6/x8c/x80", "<CJK>");
+-   ("/xe6/x8d/x80", "<CJK>");
+-   ("/xe6/x8e/x80", "<CJK>");
+-   ("/xe6/x8f/x80", "<CJK>");
+-   ("/xe6/x90/x80", "<CJK>");
+-   ("/xe6/x91/x80", "<CJK>");
+-   ("/xe6/x92/x80", "<CJK>");
+-   ("/xe6/x93/x80", "<CJK>");
+-   ("/xe6/x94/x80", "<CJK>");
+-   ("/xe6/x95/x80", "<CJK>");
+-   ("/xe6/x96/x80", "<CJK>");
+-   ("/xe6/x97/x80", "<CJK>");
+-   ("/xe6/x98/x80", "<CJK>");
+-   ("/xe6/x99/x80", "<CJK>");
+-   ("/xe6/x9a/x80", "<CJK>");
+-   ("/xe6/x9b/x80", "<CJK>");
+-   ("/xe6/x9c/x80", "<CJK>");
+-   ("/xe6/x9d/x80", "<CJK>");
+-   ("/xe6/x9e/x80", "<CJK>");
+-   ("/xe6/x9f/x80", "<CJK>");
+-   ("/xe6/xa0/x80", "<CJK>");
+-   ("/xe6/xa1/x80", "<CJK>");
+-   ("/xe6/xa2/x80", "<CJK>");
+-   ("/xe6/xa3/x80", "<CJK>");
+-   ("/xe6/xa4/x80", "<CJK>");
+-   ("/xe6/xa5/x80", "<CJK>");
+-   ("/xe6/xa6/x80", "<CJK>");
+-   ("/xe6/xa7/x80", "<CJK>");
+-   ("/xe6/xa8/x80", "<CJK>");
+-   ("/xe6/xa9/x80", "<CJK>");
+-   ("/xe6/xaa/x80", "<CJK>");
+-   ("/xe6/xab/x80", "<CJK>");
+-   ("/xe6/xac/x80", "<CJK>");
+-   ("/xe6/xad/x80", "<CJK>");
+-   ("/xe6/xae/x80", "<CJK>");
+-   ("/xe6/xaf/x80", "<CJK>");
+-   ("/xe6/xb0/x80", "<CJK>");
+-   ("/xe6/xb1/x80", "<CJK>");
+-   ("/xe6/xb2/x80", "<CJK>");
+-   ("/xe6/xb3/x80", "<CJK>");
+-   ("/xe6/xb4/x80", "<CJK>");
+-   ("/xe6/xb5/x80", "<CJK>");
+-   ("/xe6/xb6/x80", "<CJK>");
+-   ("/xe6/xb7/x80", "<CJK>");
+-   ("/xe6/xb8/x80", "<CJK>");
+-   ("/xe6/xb9/x80", "<CJK>");
+-   ("/xe6/xba/x80", "<CJK>");
+-   ("/xe6/xbb/x80", "<CJK>");
+-   ("/xe6/xbc/x80", "<CJK>");
+-   ("/xe6/xbd/x80", "<CJK>");
+-   ("/xe6/xbe/x80", "<CJK>");
+-   ("/xe6/xbf/x80", "<CJK>");
+-   ("/xe7/x80/x80", "<CJK>");
+-   ("/xe7/x81/x80", "<CJK>");
+-   ("/xe7/x82/x80", "<CJK>");
+-   ("/xe7/x83/x80", "<CJK>");
+-   ("/xe7/x84/x80", "<CJK>");
+-   ("/xe7/x85/x80", "<CJK>");
+-   ("/xe7/x86/x80", "<CJK>");
+-   ("/xe7/x87/x80", "<CJK>");
+-   ("/xe7/x88/x80", "<CJK>");
+-   ("/xe7/x89/x80", "<CJK>");
+-   ("/xe7/x8a/x80", "<CJK>");
+-   ("/xe7/x8b/x80", "<CJK>");
+-   ("/xe7/x8c/x80", "<CJK>");
+-   ("/xe7/x8d/x80", "<CJK>");
+-   ("/xe7/x8e/x80", "<CJK>");
+-   ("/xe7/x8f/x80", "<CJK>");
+-   ("/xe7/x90/x80", "<CJK>");
+-   ("/xe7/x91/x80", "<CJK>");
+-   ("/xe7/x92/x80", "<CJK>");
+-   ("/xe7/x93/x80", "<CJK>");
+-   ("/xe7/x94/x80", "<CJK>");
+-   ("/xe7/x95/x80", "<CJK>");
+-   ("/xe7/x96/x80", "<CJK>");
+-   ("/xe7/x97/x80", "<CJK>");
+-   ("/xe7/x98/x80", "<CJK>");
+-   ("/xe7/x99/x80", "<CJK>");
+-   ("/xe7/x9a/x80", "<CJK>");
+-   ("/xe7/x9b/x80", "<CJK>");
+-   ("/xe7/x9c/x80", "<CJK>");
+-   ("/xe7/x9d/x80", "<CJK>");
+-   ("/xe7/x9e/x80", "<CJK>");
+-   ("/xe7/x9f/x80", "<CJK>");
+-   ("/xe7/xa0/x80", "<CJK>");
+-   ("/xe7/xa1/x80", "<CJK>");
+-   ("/xe7/xa2/x80", "<CJK>");
+-   ("/xe7/xa3/x80", "<CJK>");
+-   ("/xe7/xa4/x80", "<CJK>");
+-   ("/xe7/xa5/x80", "<CJK>");
+-   ("/xe7/xa6/x80", "<CJK>");
+-   ("/xe7/xa7/x80", "<CJK>");
+-   ("/xe7/xa8/x80", "<CJK>");
+-   ("/xe7/xa9/x80", "<CJK>");
+-   ("/xe7/xaa/x80", "<CJK>");
+-   ("/xe7/xab/x80", "<CJK>");
+-   ("/xe7/xac/x80", "<CJK>");
+-   ("/xe7/xad/x80", "<CJK>");
+-   ("/xe7/xae/x80", "<CJK>");
+-   ("/xe7/xaf/x80", "<CJK>");
+-   ("/xe7/xb0/x80", "<CJK>");
+-   ("/xe7/xb1/x80", "<CJK>");
+-   ("/xe7/xb2/x80", "<CJK>");
+-   ("/xe7/xb3/x80", "<CJK>");
+-   ("/xe7/xb4/x80", "<CJK>");
+-   ("/xe7/xb5/x80", "<CJK>");
+-   ("/xe7/xb6/x80", "<CJK>");
+-   ("/xe7/xb7/x80", "<CJK>");
+-   ("/xe7/xb8/x80", "<CJK>");
+-   ("/xe7/xb9/x80", "<CJK>");
+-   ("/xe7/xba/x80", "<CJK>");
+-   ("/xe7/xbb/x80", "<CJK>");
+-   ("/xe7/xbc/x80", "<CJK>");
+-   ("/xe7/xbd/x80", "<CJK>");
+-   ("/xe7/xbe/x80", "<CJK>");
+-   ("/xe7/xbf/x80", "<CJK>");
+-   ("/xe8/x80/x80", "<CJK>");
+-   ("/xe8/x81/x80", "<CJK>");
+-   ("/xe8/x82/x80", "<CJK>");
+-   ("/xe8/x83/x80", "<CJK>");
+-   ("/xe8/x84/x80", "<CJK>");
+-   ("/xe8/x85/x80", "<CJK>");
+-   ("/xe8/x86/x80", "<CJK>");
+-   ("/xe8/x87/x80", "<CJK>");
+-   ("/xe8/x88/x80", "<CJK>");
+-   ("/xe8/x89/x80", "<CJK>");
+-   ("/xe8/x8a/x80", "<CJK>");
+-   ("/xe8/x8b/x80", "<CJK>");
+-   ("/xe8/x8c/x80", "<CJK>");
+-   ("/xe8/x8d/x80", "<CJK>");
+-   ("/xe8/x8e/x80", "<CJK>");
+-   ("/xe8/x8f/x80", "<CJK>");
+-   ("/xe8/x90/x80", "<CJK>");
+-   ("/xe8/x91/x80", "<CJK>");
+-   ("/xe8/x92/x80", "<CJK>");
+-   ("/xe8/x93/x80", "<CJK>");
+-   ("/xe8/x94/x80", "<CJK>");
+-   ("/xe8/x95/x80", "<CJK>");
+-   ("/xe8/x96/x80", "<CJK>");
+-   ("/xe8/x97/x80", "<CJK>");
+-   ("/xe8/x98/x80", "<CJK>");
+-   ("/xe8/x99/x80", "<CJK>");
+-   ("/xe8/x9a/x80", "<CJK>");
+-   ("/xe8/x9b/x80", "<CJK>");
+-   ("/xe8/x9c/x80", "<CJK>");
+-   ("/xe8/x9d/x80", "<CJK>");
+-   ("/xe8/x9e/x80", "<CJK>");
+-   ("/xe8/x9f/x80", "<CJK>");
+-   ("/xe8/xa0/x80", "<CJK>");
+-   ("/xe8/xa1/x80", "<CJK>");
+-   ("/xe8/xa2/x80", "<CJK>");
+-   ("/xe8/xa3/x80", "<CJK>");
+-   ("/xe8/xa4/x80", "<CJK>");
+-   ("/xe8/xa5/x80", "<CJK>");
+-   ("/xe8/xa6/x80", "<CJK>");
+-   ("/xe8/xa7/x80", "<CJK>");
+-   ("/xe8/xa8/x80", "<CJK>");
+-   ("/xe8/xa9/x80", "<CJK>");
+-   ("/xe8/xaa/x80", "<CJK>");
+-   ("/xe8/xab/x80", "<CJK>");
+-   ("/xe8/xac/x80", "<CJK>");
+-   ("/xe8/xad/x80", "<CJK>");
+-   ("/xe8/xae/x80", "<CJK>");
+-   ("/xe8/xaf/x80", "<CJK>");
+-   ("/xe8/xb0/x80", "<CJK>");
+-   ("/xe8/xb1/x80", "<CJK>");
+-   ("/xe8/xb2/x80", "<CJK>");
+-   ("/xe8/xb3/x80", "<CJK>");
+-   ("/xe8/xb4/x80", "<CJK>");
+-   ("/xe8/xb5/x80", "<CJK>");
+-   ("/xe8/xb6/x80", "<CJK>");
+-   ("/xe8/xb7/x80", "<CJK>");
+-   ("/xe8/xb8/x80", "<CJK>");
+-   ("/xe8/xb9/x80", "<CJK>");
+-   ("/xe8/xba/x80", "<CJK>");
+-   ("/xe8/xbb/x80", "<CJK>");
+-   ("/xe8/xbc/x80", "<CJK>");
+-   ("/xe8/xbd/x80", "<CJK>");
+-   ("/xe8/xbe/x80", "<CJK>");
+-   ("/xe8/xbf/x80", "<CJK>");
+-   ("/xe9/x80/x80", "<CJK>");
+-   ("/xe9/x81/x80", "<CJK>");
+-   ("/xe9/x82/x80", "<CJK>");
+-   ("/xe9/x83/x80", "<CJK>");
+-   ("/xe9/x84/x80", "<CJK>");
+-   ("/xe9/x85/x80", "<CJK>");
+-   ("/xe9/x86/x80", "<CJK>");
+-   ("/xe9/x87/x80", "<CJK>");
+-   ("/xe9/x88/x80", "<CJK>");
+-   ("/xe9/x89/x80", "<CJK>");
+-   ("/xe9/x8a/x80", "<CJK>");
+-   ("/xe9/x8b/x80", "<CJK>");
+-   ("/xe9/x8c/x80", "<CJK>");
+-   ("/xe9/x8d/x80", "<CJK>");
+-   ("/xe9/x8e/x80", "<CJK>");
+-   ("/xe9/x8f/x80", "<CJK>");
+-   ("/xe9/x90/x80", "<CJK>");
+-   ("/xe9/x91/x80", "<CJK>");
+-   ("/xe9/x92/x80", "<CJK>");
+-   ("/xe9/x93/x80", "<CJK>");
+-   ("/xe9/x94/x80", "<CJK>");
+-   ("/xe9/x95/x80", "<CJK>");
+-   ("/xe9/x96/x80", "<CJK>");
+-   ("/xe9/x97/x80", "<CJK>");
+-   ("/xe9/x98/x80", "<CJK>");
+-   ("/xe9/x99/x80", "<CJK>");
+-   ("/xe9/x9a/x80", "<CJK>");
+-   ("/xe9/x9b/x80", "<CJK>");
+-   ("/xe9/x9c/x80", "<CJK>");
+-   ("/xe9/x9d/x80", "<CJK>");
+-   ("/xe9/x9e/x80", "<CJK>");
+-   ("/xe9/x9f/x80", "<CJK>");
+-   ("/xe9/xa0/x80", "<CJK>");
+-   ("/xe9/xa1/x80", "<CJK>");
+-   ("/xe9/xa2/x80", "<CJK>");
+-   ("/xe9/xa3/x80", "<CJK>");
+-   ("/xe9/xa4/x80", "<CJK>");
+-   ("/xe9/xa5/x80", "<CJK>");
+-   ("/xe9/xa6/x80", "<CJK>");
+-   ("/xe9/xa7/x80", "<CJK>");
+-   ("/xe9/xa8/x80", "<CJK>");
+-   ("/xe9/xa9/x80", "<CJK>");
+-   ("/xe9/xaa/x80", "<CJK>");
+-   ("/xe9/xab/x80", "<CJK>");
+-   ("/xe9/xac/x80", "<CJK>");
+-   ("/xe9/xad/x80", "<CJK>");
+-   ("/xe9/xae/x80", "<CJK>");
+-   ("/xe9/xaf/x80", "<CJK>");
+-   ("/xe9/xb0/x80", "<CJK>");
+-   ("/xe9/xb1/x80", "<CJK>");
+-   ("/xe9/xb2/x80", "<CJK>");
+-   ("/xe9/xb3/x80", "<CJK>");
+-   ("/xe9/xb4/x80", "<CJK>");
+-   ("/xe9/xb5/x80", "<CJK>");
+-   ("/xe9/xb6/x80", "<CJK>");
+-   ("/xe9/xb7/x80", "<CJK>");
+-   ("/xe9/xb8/x80", "<CJK>");
+-   ("/xe9/xb9/x80", "<CJK>");
+-   ("/xe9/xba/x80", "<CJK>");
+-   ("/xe9/xbb/x80", "<CJK>");
+-   ("/xe9/xbc/x80", "<CJK>");
+-   ("/xe9/xbd/x80", "<CJK>");
+-   ("/xe9/xbe/x80", "<CJK>");
+-   ("/xea/x80/x80", "YI SYLLABLE IT");
+-   ("/xea/x80/x81", "YI SYLLABLE IX");
+-   ("/xea/x80/x82", "YI SYLLABLE I");
+-   ("/xea/x80/x83", "YI SYLLABLE IP");
+-   ("/xea/x80/x84", "YI SYLLABLE IET");
+-   ("/xea/x80/x85", "YI SYLLABLE IEX");
+-   ("/xea/x80/x86", "YI SYLLABLE IE");
+-   ("/xea/x80/x87", "YI SYLLABLE IEP");
+-   ("/xea/x80/x88", "YI SYLLABLE AT");
+-   ("/xea/x80/x89", "YI SYLLABLE AX");
+-   ("/xea/x80/x8a", "YI SYLLABLE A");
+-   ("/xea/x80/x8b", "YI SYLLABLE AP");
+-   ("/xea/x80/x8c", "YI SYLLABLE UOX");
+-   ("/xea/x80/x8d", "YI SYLLABLE UO");
+-   ("/xea/x80/x8e", "YI SYLLABLE UOP");
+-   ("/xea/x80/x8f", "YI SYLLABLE OT");
+-   ("/xea/x80/x90", "YI SYLLABLE OX");
+-   ("/xea/x80/x91", "YI SYLLABLE O");
+-   ("/xea/x80/x92", "YI SYLLABLE OP");
+-   ("/xea/x80/x93", "YI SYLLABLE EX");
+-   ("/xea/x80/x94", "YI SYLLABLE E");
+-   ("/xea/x80/x95", "YI SYLLABLE WU");
+-   ("/xea/x80/x96", "YI SYLLABLE BIT");
+-   ("/xea/x80/x97", "YI SYLLABLE BIX");
+-   ("/xea/x80/x98", "YI SYLLABLE BI");
+-   ("/xea/x80/x99", "YI SYLLABLE BIP");
+-   ("/xea/x80/x9a", "YI SYLLABLE BIET");
+-   ("/xea/x80/x9b", "YI SYLLABLE BIEX");
+-   ("/xea/x80/x9c", "YI SYLLABLE BIE");
+-   ("/xea/x80/x9d", "YI SYLLABLE BIEP");
+-   ("/xea/x80/x9e", "YI SYLLABLE BAT");
+-   ("/xea/x80/x9f", "YI SYLLABLE BAX");
+-   ("/xea/x80/xa0", "YI SYLLABLE BA");
+-   ("/xea/x80/xa1", "YI SYLLABLE BAP");
+-   ("/xea/x80/xa2", "YI SYLLABLE BUOX");
+-   ("/xea/x80/xa3", "YI SYLLABLE BUO");
+-   ("/xea/x80/xa4", "YI SYLLABLE BUOP");
+-   ("/xea/x80/xa5", "YI SYLLABLE BOT");
+-   ("/xea/x80/xa6", "YI SYLLABLE BOX");
+-   ("/xea/x80/xa7", "YI SYLLABLE BO");
+-   ("/xea/x80/xa8", "YI SYLLABLE BOP");
+-   ("/xea/x80/xa9", "YI SYLLABLE BEX");
+-   ("/xea/x80/xaa", "YI SYLLABLE BE");
+-   ("/xea/x80/xab", "YI SYLLABLE BEP");
+-   ("/xea/x80/xac", "YI SYLLABLE BUT");
+-   ("/xea/x80/xad", "YI SYLLABLE BUX");
+-   ("/xea/x80/xae", "YI SYLLABLE BU");
+-   ("/xea/x80/xaf", "YI SYLLABLE BUP");
+-   ("/xea/x80/xb0", "YI SYLLABLE BURX");
+-   ("/xea/x80/xb1", "YI SYLLABLE BUR");
+-   ("/xea/x80/xb2", "YI SYLLABLE BYT");
+-   ("/xea/x80/xb3", "YI SYLLABLE BYX");
+-   ("/xea/x80/xb4", "YI SYLLABLE BY");
+-   ("/xea/x80/xb5", "YI SYLLABLE BYP");
+-   ("/xea/x80/xb6", "YI SYLLABLE BYRX");
+-   ("/xea/x80/xb7", "YI SYLLABLE BYR");
+-   ("/xea/x80/xb8", "YI SYLLABLE PIT");
+-   ("/xea/x80/xb9", "YI SYLLABLE PIX");
+-   ("/xea/x80/xba", "YI SYLLABLE PI");
+-   ("/xea/x80/xbb", "YI SYLLABLE PIP");
+-   ("/xea/x80/xbc", "YI SYLLABLE PIEX");
+-   ("/xea/x80/xbd", "YI SYLLABLE PIE");
+-   ("/xea/x80/xbe", "YI SYLLABLE PIEP");
+-   ("/xea/x80/xbf", "YI SYLLABLE PAT");
+-   ("/xea/x81/x80", "YI SYLLABLE PAX");
+-   ("/xea/x81/x81", "YI SYLLABLE PA");
+-   ("/xea/x81/x82", "YI SYLLABLE PAP");
+-   ("/xea/x81/x83", "YI SYLLABLE PUOX");
+-   ("/xea/x81/x84", "YI SYLLABLE PUO");
+-   ("/xea/x81/x85", "YI SYLLABLE PUOP");
+-   ("/xea/x81/x86", "YI SYLLABLE POT");
+-   ("/xea/x81/x87", "YI SYLLABLE POX");
+-   ("/xea/x81/x88", "YI SYLLABLE PO");
+-   ("/xea/x81/x89", "YI SYLLABLE POP");
+-   ("/xea/x81/x8a", "YI SYLLABLE PUT");
+-   ("/xea/x81/x8b", "YI SYLLABLE PUX");
+-   ("/xea/x81/x8c", "YI SYLLABLE PU");
+-   ("/xea/x81/x8d", "YI SYLLABLE PUP");
+-   ("/xea/x81/x8e", "YI SYLLABLE PURX");
+-   ("/xea/x81/x8f", "YI SYLLABLE PUR");
+-   ("/xea/x81/x90", "YI SYLLABLE PYT");
+-   ("/xea/x81/x91", "YI SYLLABLE PYX");
+-   ("/xea/x81/x92", "YI SYLLABLE PY");
+-   ("/xea/x81/x93", "YI SYLLABLE PYP");
+-   ("/xea/x81/x94", "YI SYLLABLE PYRX");
+-   ("/xea/x81/x95", "YI SYLLABLE PYR");
+-   ("/xea/x81/x96", "YI SYLLABLE BBIT");
+-   ("/xea/x81/x97", "YI SYLLABLE BBIX");
+-   ("/xea/x81/x98", "YI SYLLABLE BBI");
+-   ("/xea/x81/x99", "YI SYLLABLE BBIP");
+-   ("/xea/x81/x9a", "YI SYLLABLE BBIET");
+-   ("/xea/x81/x9b", "YI SYLLABLE BBIEX");
+-   ("/xea/x81/x9c", "YI SYLLABLE BBIE");
+-   ("/xea/x81/x9d", "YI SYLLABLE BBIEP");
+-   ("/xea/x81/x9e", "YI SYLLABLE BBAT");
+-   ("/xea/x81/x9f", "YI SYLLABLE BBAX");
+-   ("/xea/x81/xa0", "YI SYLLABLE BBA");
+-   ("/xea/x81/xa1", "YI SYLLABLE BBAP");
+-   ("/xea/x81/xa2", "YI SYLLABLE BBUOX");
+-   ("/xea/x81/xa3", "YI SYLLABLE BBUO");
+-   ("/xea/x81/xa4", "YI SYLLABLE BBUOP");
+-   ("/xea/x81/xa5", "YI SYLLABLE BBOT");
+-   ("/xea/x81/xa6", "YI SYLLABLE BBOX");
+-   ("/xea/x81/xa7", "YI SYLLABLE BBO");
+-   ("/xea/x81/xa8", "YI SYLLABLE BBOP");
+-   ("/xea/x81/xa9", "YI SYLLABLE BBEX");
+-   ("/xea/x81/xaa", "YI SYLLABLE BBE");
+-   ("/xea/x81/xab", "YI SYLLABLE BBEP");
+-   ("/xea/x81/xac", "YI SYLLABLE BBUT");
+-   ("/xea/x81/xad", "YI SYLLABLE BBUX");
+-   ("/xea/x81/xae", "YI SYLLABLE BBU");
+-   ("/xea/x81/xaf", "YI SYLLABLE BBUP");
+-   ("/xea/x81/xb0", "YI SYLLABLE BBURX");
+-   ("/xea/x81/xb1", "YI SYLLABLE BBUR");
+-   ("/xea/x81/xb2", "YI SYLLABLE BBYT");
+-   ("/xea/x81/xb3", "YI SYLLABLE BBYX");
+-   ("/xea/x81/xb4", "YI SYLLABLE BBY");
+-   ("/xea/x81/xb5", "YI SYLLABLE BBYP");
+-   ("/xea/x81/xb6", "YI SYLLABLE NBIT");
+-   ("/xea/x81/xb7", "YI SYLLABLE NBIX");
+-   ("/xea/x81/xb8", "YI SYLLABLE NBI");
+-   ("/xea/x81/xb9", "YI SYLLABLE NBIP");
+-   ("/xea/x81/xba", "YI SYLLABLE NBIEX");
+-   ("/xea/x81/xbb", "YI SYLLABLE NBIE");
+-   ("/xea/x81/xbc", "YI SYLLABLE NBIEP");
+-   ("/xea/x81/xbd", "YI SYLLABLE NBAT");
+-   ("/xea/x81/xbe", "YI SYLLABLE NBAX");
+-   ("/xea/x81/xbf", "YI SYLLABLE NBA");
+-   ("/xea/x82/x80", "YI SYLLABLE NBAP");
+-   ("/xea/x82/x81", "YI SYLLABLE NBOT");
+-   ("/xea/x82/x82", "YI SYLLABLE NBOX");
+-   ("/xea/x82/x83", "YI SYLLABLE NBO");
+-   ("/xea/x82/x84", "YI SYLLABLE NBOP");
+-   ("/xea/x82/x85", "YI SYLLABLE NBUT");
+-   ("/xea/x82/x86", "YI SYLLABLE NBUX");
+-   ("/xea/x82/x87", "YI SYLLABLE NBU");
+-   ("/xea/x82/x88", "YI SYLLABLE NBUP");
+-   ("/xea/x82/x89", "YI SYLLABLE NBURX");
+-   ("/xea/x82/x8a", "YI SYLLABLE NBUR");
+-   ("/xea/x82/x8b", "YI SYLLABLE NBYT");
+-   ("/xea/x82/x8c", "YI SYLLABLE NBYX");
+-   ("/xea/x82/x8d", "YI SYLLABLE NBY");
+-   ("/xea/x82/x8e", "YI SYLLABLE NBYP");
+-   ("/xea/x82/x8f", "YI SYLLABLE NBYRX");
+-   ("/xea/x82/x90", "YI SYLLABLE NBYR");
+-   ("/xea/x82/x91", "YI SYLLABLE HMIT");
+-   ("/xea/x82/x92", "YI SYLLABLE HMIX");
+-   ("/xea/x82/x93", "YI SYLLABLE HMI");
+-   ("/xea/x82/x94", "YI SYLLABLE HMIP");
+-   ("/xea/x82/x95", "YI SYLLABLE HMIEX");
+-   ("/xea/x82/x96", "YI SYLLABLE HMIE");
+-   ("/xea/x82/x97", "YI SYLLABLE HMIEP");
+-   ("/xea/x82/x98", "YI SYLLABLE HMAT");
+-   ("/xea/x82/x99", "YI SYLLABLE HMAX");
+-   ("/xea/x82/x9a", "YI SYLLABLE HMA");
+-   ("/xea/x82/x9b", "YI SYLLABLE HMAP");
+-   ("/xea/x82/x9c", "YI SYLLABLE HMUOX");
+-   ("/xea/x82/x9d", "YI SYLLABLE HMUO");
+-   ("/xea/x82/x9e", "YI SYLLABLE HMUOP");
+-   ("/xea/x82/x9f", "YI SYLLABLE HMOT");
+-   ("/xea/x82/xa0", "YI SYLLABLE HMOX");
+-   ("/xea/x82/xa1", "YI SYLLABLE HMO");
+-   ("/xea/x82/xa2", "YI SYLLABLE HMOP");
+-   ("/xea/x82/xa3", "YI SYLLABLE HMUT");
+-   ("/xea/x82/xa4", "YI SYLLABLE HMUX");
+-   ("/xea/x82/xa5", "YI SYLLABLE HMU");
+-   ("/xea/x82/xa6", "YI SYLLABLE HMUP");
+-   ("/xea/x82/xa7", "YI SYLLABLE HMURX");
+-   ("/xea/x82/xa8", "YI SYLLABLE HMUR");
+-   ("/xea/x82/xa9", "YI SYLLABLE HMYX");
+-   ("/xea/x82/xaa", "YI SYLLABLE HMY");
+-   ("/xea/x82/xab", "YI SYLLABLE HMYP");
+-   ("/xea/x82/xac", "YI SYLLABLE HMYRX");
+-   ("/xea/x82/xad", "YI SYLLABLE HMYR");
+-   ("/xea/x82/xae", "YI SYLLABLE MIT");
+-   ("/xea/x82/xaf", "YI SYLLABLE MIX");
+-   ("/xea/x82/xb0", "YI SYLLABLE MI");
+-   ("/xea/x82/xb1", "YI SYLLABLE MIP");
+-   ("/xea/x82/xb2", "YI SYLLABLE MIEX");
+-   ("/xea/x82/xb3", "YI SYLLABLE MIE");
+-   ("/xea/x82/xb4", "YI SYLLABLE MIEP");
+-   ("/xea/x82/xb5", "YI SYLLABLE MAT");
+-   ("/xea/x82/xb6", "YI SYLLABLE MAX");
+-   ("/xea/x82/xb7", "YI SYLLABLE MA");
+-   ("/xea/x82/xb8", "YI SYLLABLE MAP");
+-   ("/xea/x82/xb9", "YI SYLLABLE MUOT");
+-   ("/xea/x82/xba", "YI SYLLABLE MUOX");
+-   ("/xea/x82/xbb", "YI SYLLABLE MUO");
+-   ("/xea/x82/xbc", "YI SYLLABLE MUOP");
+-   ("/xea/x82/xbd", "YI SYLLABLE MOT");
+-   ("/xea/x82/xbe", "YI SYLLABLE MOX");
+-   ("/xea/x82/xbf", "YI SYLLABLE MO");
+-   ("/xea/x83/x80", "YI SYLLABLE MOP");
+-   ("/xea/x83/x81", "YI SYLLABLE MEX");
+-   ("/xea/x83/x82", "YI SYLLABLE ME");
+-   ("/xea/x83/x83", "YI SYLLABLE MUT");
+-   ("/xea/x83/x84", "YI SYLLABLE MUX");
+-   ("/xea/x83/x85", "YI SYLLABLE MU");
+-   ("/xea/x83/x86", "YI SYLLABLE MUP");
+-   ("/xea/x83/x87", "YI SYLLABLE MURX");
+-   ("/xea/x83/x88", "YI SYLLABLE MUR");
+-   ("/xea/x83/x89", "YI SYLLABLE MYT");
+-   ("/xea/x83/x8a", "YI SYLLABLE MYX");
+-   ("/xea/x83/x8b", "YI SYLLABLE MY");
+-   ("/xea/x83/x8c", "YI SYLLABLE MYP");
+-   ("/xea/x83/x8d", "YI SYLLABLE FIT");
+-   ("/xea/x83/x8e", "YI SYLLABLE FIX");
+-   ("/xea/x83/x8f", "YI SYLLABLE FI");
+-   ("/xea/x83/x90", "YI SYLLABLE FIP");
+-   ("/xea/x83/x91", "YI SYLLABLE FAT");
+-   ("/xea/x83/x92", "YI SYLLABLE FAX");
+-   ("/xea/x83/x93", "YI SYLLABLE FA");
+-   ("/xea/x83/x94", "YI SYLLABLE FAP");
+-   ("/xea/x83/x95", "YI SYLLABLE FOX");
+-   ("/xea/x83/x96", "YI SYLLABLE FO");
+-   ("/xea/x83/x97", "YI SYLLABLE FOP");
+-   ("/xea/x83/x98", "YI SYLLABLE FUT");
+-   ("/xea/x83/x99", "YI SYLLABLE FUX");
+-   ("/xea/x83/x9a", "YI SYLLABLE FU");
+-   ("/xea/x83/x9b", "YI SYLLABLE FUP");
+-   ("/xea/x83/x9c", "YI SYLLABLE FURX");
+-   ("/xea/x83/x9d", "YI SYLLABLE FUR");
+-   ("/xea/x83/x9e", "YI SYLLABLE FYT");
+-   ("/xea/x83/x9f", "YI SYLLABLE FYX");
+-   ("/xea/x83/xa0", "YI SYLLABLE FY");
+-   ("/xea/x83/xa1", "YI SYLLABLE FYP");
+-   ("/xea/x83/xa2", "YI SYLLABLE VIT");
+-   ("/xea/x83/xa3", "YI SYLLABLE VIX");
+-   ("/xea/x83/xa4", "YI SYLLABLE VI");
+-   ("/xea/x83/xa5", "YI SYLLABLE VIP");
+-   ("/xea/x83/xa6", "YI SYLLABLE VIET");
+-   ("/xea/x83/xa7", "YI SYLLABLE VIEX");
+-   ("/xea/x83/xa8", "YI SYLLABLE VIE");
+-   ("/xea/x83/xa9", "YI SYLLABLE VIEP");
+-   ("/xea/x83/xaa", "YI SYLLABLE VAT");
+-   ("/xea/x83/xab", "YI SYLLABLE VAX");
+-   ("/xea/x83/xac", "YI SYLLABLE VA");
+-   ("/xea/x83/xad", "YI SYLLABLE VAP");
+-   ("/xea/x83/xae", "YI SYLLABLE VOT");
+-   ("/xea/x83/xaf", "YI SYLLABLE VOX");
+-   ("/xea/x83/xb0", "YI SYLLABLE VO");
+-   ("/xea/x83/xb1", "YI SYLLABLE VOP");
+-   ("/xea/x83/xb2", "YI SYLLABLE VEX");
+-   ("/xea/x83/xb3", "YI SYLLABLE VEP");
+-   ("/xea/x83/xb4", "YI SYLLABLE VUT");
+-   ("/xea/x83/xb5", "YI SYLLABLE VUX");
+-   ("/xea/x83/xb6", "YI SYLLABLE VU");
+-   ("/xea/x83/xb7", "YI SYLLABLE VUP");
+-   ("/xea/x83/xb8", "YI SYLLABLE VURX");
+-   ("/xea/x83/xb9", "YI SYLLABLE VUR");
+-   ("/xea/x83/xba", "YI SYLLABLE VYT");
+-   ("/xea/x83/xbb", "YI SYLLABLE VYX");
+-   ("/xea/x83/xbc", "YI SYLLABLE VY");
+-   ("/xea/x83/xbd", "YI SYLLABLE VYP");
+-   ("/xea/x83/xbe", "YI SYLLABLE VYRX");
+-   ("/xea/x83/xbf", "YI SYLLABLE VYR");
+-   ("/xea/x84/x80", "YI SYLLABLE DIT");
+-   ("/xea/x84/x81", "YI SYLLABLE DIX");
+-   ("/xea/x84/x82", "YI SYLLABLE DI");
+-   ("/xea/x84/x83", "YI SYLLABLE DIP");
+-   ("/xea/x84/x84", "YI SYLLABLE DIEX");
+-   ("/xea/x84/x85", "YI SYLLABLE DIE");
+-   ("/xea/x84/x86", "YI SYLLABLE DIEP");
+-   ("/xea/x84/x87", "YI SYLLABLE DAT");
+-   ("/xea/x84/x88", "YI SYLLABLE DAX");
+-   ("/xea/x84/x89", "YI SYLLABLE DA");
+-   ("/xea/x84/x8a", "YI SYLLABLE DAP");
+-   ("/xea/x84/x8b", "YI SYLLABLE DUOX");
+-   ("/xea/x84/x8c", "YI SYLLABLE DUO");
+-   ("/xea/x84/x8d", "YI SYLLABLE DOT");
+-   ("/xea/x84/x8e", "YI SYLLABLE DOX");
+-   ("/xea/x84/x8f", "YI SYLLABLE DO");
+-   ("/xea/x84/x90", "YI SYLLABLE DOP");
+-   ("/xea/x84/x91", "YI SYLLABLE DEX");
+-   ("/xea/x84/x92", "YI SYLLABLE DE");
+-   ("/xea/x84/x93", "YI SYLLABLE DEP");
+-   ("/xea/x84/x94", "YI SYLLABLE DUT");
+-   ("/xea/x84/x95", "YI SYLLABLE DUX");
+-   ("/xea/x84/x96", "YI SYLLABLE DU");
+-   ("/xea/x84/x97", "YI SYLLABLE DUP");
+-   ("/xea/x84/x98", "YI SYLLABLE DURX");
+-   ("/xea/x84/x99", "YI SYLLABLE DUR");
+-   ("/xea/x84/x9a", "YI SYLLABLE TIT");
+-   ("/xea/x84/x9b", "YI SYLLABLE TIX");
+-   ("/xea/x84/x9c", "YI SYLLABLE TI");
+-   ("/xea/x84/x9d", "YI SYLLABLE TIP");
+-   ("/xea/x84/x9e", "YI SYLLABLE TIEX");
+-   ("/xea/x84/x9f", "YI SYLLABLE TIE");
+-   ("/xea/x84/xa0", "YI SYLLABLE TIEP");
+-   ("/xea/x84/xa1", "YI SYLLABLE TAT");
+-   ("/xea/x84/xa2", "YI SYLLABLE TAX");
+-   ("/xea/x84/xa3", "YI SYLLABLE TA");
+-   ("/xea/x84/xa4", "YI SYLLABLE TAP");
+-   ("/xea/x84/xa5", "YI SYLLABLE TUOT");
+-   ("/xea/x84/xa6", "YI SYLLABLE TUOX");
+-   ("/xea/x84/xa7", "YI SYLLABLE TUO");
+-   ("/xea/x84/xa8", "YI SYLLABLE TUOP");
+-   ("/xea/x84/xa9", "YI SYLLABLE TOT");
+-   ("/xea/x84/xaa", "YI SYLLABLE TOX");
+-   ("/xea/x84/xab", "YI SYLLABLE TO");
+-   ("/xea/x84/xac", "YI SYLLABLE TOP");
+-   ("/xea/x84/xad", "YI SYLLABLE TEX");
+-   ("/xea/x84/xae", "YI SYLLABLE TE");
+-   ("/xea/x84/xaf", "YI SYLLABLE TEP");
+-   ("/xea/x84/xb0", "YI SYLLABLE TUT");
+-   ("/xea/x84/xb1", "YI SYLLABLE TUX");
+-   ("/xea/x84/xb2", "YI SYLLABLE TU");
+-   ("/xea/x84/xb3", "YI SYLLABLE TUP");
+-   ("/xea/x84/xb4", "YI SYLLABLE TURX");
+-   ("/xea/x84/xb5", "YI SYLLABLE TUR");
+-   ("/xea/x84/xb6", "YI SYLLABLE DDIT");
+-   ("/xea/x84/xb7", "YI SYLLABLE DDIX");
+-   ("/xea/x84/xb8", "YI SYLLABLE DDI");
+-   ("/xea/x84/xb9", "YI SYLLABLE DDIP");
+-   ("/xea/x84/xba", "YI SYLLABLE DDIEX");
+-   ("/xea/x84/xbb", "YI SYLLABLE DDIE");
+-   ("/xea/x84/xbc", "YI SYLLABLE DDIEP");
+-   ("/xea/x84/xbd", "YI SYLLABLE DDAT");
+-   ("/xea/x84/xbe", "YI SYLLABLE DDAX");
+-   ("/xea/x84/xbf", "YI SYLLABLE DDA");
+-   ("/xea/x85/x80", "YI SYLLABLE DDAP");
+-   ("/xea/x85/x81", "YI SYLLABLE DDUOX");
+-   ("/xea/x85/x82", "YI SYLLABLE DDUO");
+-   ("/xea/x85/x83", "YI SYLLABLE DDUOP");
+-   ("/xea/x85/x84", "YI SYLLABLE DDOT");
+-   ("/xea/x85/x85", "YI SYLLABLE DDOX");
+-   ("/xea/x85/x86", "YI SYLLABLE DDO");
+-   ("/xea/x85/x87", "YI SYLLABLE DDOP");
+-   ("/xea/x85/x88", "YI SYLLABLE DDEX");
+-   ("/xea/x85/x89", "YI SYLLABLE DDE");
+-   ("/xea/x85/x8a", "YI SYLLABLE DDEP");
+-   ("/xea/x85/x8b", "YI SYLLABLE DDUT");
+-   ("/xea/x85/x8c", "YI SYLLABLE DDUX");
+-   ("/xea/x85/x8d", "YI SYLLABLE DDU");
+-   ("/xea/x85/x8e", "YI SYLLABLE DDUP");
+-   ("/xea/x85/x8f", "YI SYLLABLE DDURX");
+-   ("/xea/x85/x90", "YI SYLLABLE DDUR");
+-   ("/xea/x85/x91", "YI SYLLABLE NDIT");
+-   ("/xea/x85/x92", "YI SYLLABLE NDIX");
+-   ("/xea/x85/x93", "YI SYLLABLE NDI");
+-   ("/xea/x85/x94", "YI SYLLABLE NDIP");
+-   ("/xea/x85/x95", "YI SYLLABLE NDIEX");
+-   ("/xea/x85/x96", "YI SYLLABLE NDIE");
+-   ("/xea/x85/x97", "YI SYLLABLE NDAT");
+-   ("/xea/x85/x98", "YI SYLLABLE NDAX");
+-   ("/xea/x85/x99", "YI SYLLABLE NDA");
+-   ("/xea/x85/x9a", "YI SYLLABLE NDAP");
+-   ("/xea/x85/x9b", "YI SYLLABLE NDOT");
+-   ("/xea/x85/x9c", "YI SYLLABLE NDOX");
+-   ("/xea/x85/x9d", "YI SYLLABLE NDO");
+-   ("/xea/x85/x9e", "YI SYLLABLE NDOP");
+-   ("/xea/x85/x9f", "YI SYLLABLE NDEX");
+-   ("/xea/x85/xa0", "YI SYLLABLE NDE");
+-   ("/xea/x85/xa1", "YI SYLLABLE NDEP");
+-   ("/xea/x85/xa2", "YI SYLLABLE NDUT");
+-   ("/xea/x85/xa3", "YI SYLLABLE NDUX");
+-   ("/xea/x85/xa4", "YI SYLLABLE NDU");
+-   ("/xea/x85/xa5", "YI SYLLABLE NDUP");
+-   ("/xea/x85/xa6", "YI SYLLABLE NDURX");
+-   ("/xea/x85/xa7", "YI SYLLABLE NDUR");
+-   ("/xea/x85/xa8", "YI SYLLABLE HNIT");
+-   ("/xea/x85/xa9", "YI SYLLABLE HNIX");
+-   ("/xea/x85/xaa", "YI SYLLABLE HNI");
+-   ("/xea/x85/xab", "YI SYLLABLE HNIP");
+-   ("/xea/x85/xac", "YI SYLLABLE HNIET");
+-   ("/xea/x85/xad", "YI SYLLABLE HNIEX");
+-   ("/xea/x85/xae", "YI SYLLABLE HNIE");
+-   ("/xea/x85/xaf", "YI SYLLABLE HNIEP");
+-   ("/xea/x85/xb0", "YI SYLLABLE HNAT");
+-   ("/xea/x85/xb1", "YI SYLLABLE HNAX");
+-   ("/xea/x85/xb2", "YI SYLLABLE HNA");
+-   ("/xea/x85/xb3", "YI SYLLABLE HNAP");
+-   ("/xea/x85/xb4", "YI SYLLABLE HNUOX");
+-   ("/xea/x85/xb5", "YI SYLLABLE HNUO");
+-   ("/xea/x85/xb6", "YI SYLLABLE HNOT");
+-   ("/xea/x85/xb7", "YI SYLLABLE HNOX");
+-   ("/xea/x85/xb8", "YI SYLLABLE HNOP");
+-   ("/xea/x85/xb9", "YI SYLLABLE HNEX");
+-   ("/xea/x85/xba", "YI SYLLABLE HNE");
+-   ("/xea/x85/xbb", "YI SYLLABLE HNEP");
+-   ("/xea/x85/xbc", "YI SYLLABLE HNUT");
+-   ("/xea/x85/xbd", "YI SYLLABLE NIT");
+-   ("/xea/x85/xbe", "YI SYLLABLE NIX");
+-   ("/xea/x85/xbf", "YI SYLLABLE NI");
+-   ("/xea/x86/x80", "YI SYLLABLE NIP");
+-   ("/xea/x86/x81", "YI SYLLABLE NIEX");
+-   ("/xea/x86/x82", "YI SYLLABLE NIE");
+-   ("/xea/x86/x83", "YI SYLLABLE NIEP");
+-   ("/xea/x86/x84", "YI SYLLABLE NAX");
+-   ("/xea/x86/x85", "YI SYLLABLE NA");
+-   ("/xea/x86/x86", "YI SYLLABLE NAP");
+-   ("/xea/x86/x87", "YI SYLLABLE NUOX");
+-   ("/xea/x86/x88", "YI SYLLABLE NUO");
+-   ("/xea/x86/x89", "YI SYLLABLE NUOP");
+-   ("/xea/x86/x8a", "YI SYLLABLE NOT");
+-   ("/xea/x86/x8b", "YI SYLLABLE NOX");
+-   ("/xea/x86/x8c", "YI SYLLABLE NO");
+-   ("/xea/x86/x8d", "YI SYLLABLE NOP");
+-   ("/xea/x86/x8e", "YI SYLLABLE NEX");
+-   ("/xea/x86/x8f", "YI SYLLABLE NE");
+-   ("/xea/x86/x90", "YI SYLLABLE NEP");
+-   ("/xea/x86/x91", "YI SYLLABLE NUT");
+-   ("/xea/x86/x92", "YI SYLLABLE NUX");
+-   ("/xea/x86/x93", "YI SYLLABLE NU");
+-   ("/xea/x86/x94", "YI SYLLABLE NUP");
+-   ("/xea/x86/x95", "YI SYLLABLE NURX");
+-   ("/xea/x86/x96", "YI SYLLABLE NUR");
+-   ("/xea/x86/x97", "YI SYLLABLE HLIT");
+-   ("/xea/x86/x98", "YI SYLLABLE HLIX");
+-   ("/xea/x86/x99", "YI SYLLABLE HLI");
+-   ("/xea/x86/x9a", "YI SYLLABLE HLIP");
+-   ("/xea/x86/x9b", "YI SYLLABLE HLIEX");
+-   ("/xea/x86/x9c", "YI SYLLABLE HLIE");
+-   ("/xea/x86/x9d", "YI SYLLABLE HLIEP");
+-   ("/xea/x86/x9e", "YI SYLLABLE HLAT");
+-   ("/xea/x86/x9f", "YI SYLLABLE HLAX");
+-   ("/xea/x86/xa0", "YI SYLLABLE HLA");
+-   ("/xea/x86/xa1", "YI SYLLABLE HLAP");
+-   ("/xea/x86/xa2", "YI SYLLABLE HLUOX");
+-   ("/xea/x86/xa3", "YI SYLLABLE HLUO");
+-   ("/xea/x86/xa4", "YI SYLLABLE HLUOP");
+-   ("/xea/x86/xa5", "YI SYLLABLE HLOX");
+-   ("/xea/x86/xa6", "YI SYLLABLE HLO");
+-   ("/xea/x86/xa7", "YI SYLLABLE HLOP");
+-   ("/xea/x86/xa8", "YI SYLLABLE HLEX");
+-   ("/xea/x86/xa9", "YI SYLLABLE HLE");
+-   ("/xea/x86/xaa", "YI SYLLABLE HLEP");
+-   ("/xea/x86/xab", "YI SYLLABLE HLUT");
+-   ("/xea/x86/xac", "YI SYLLABLE HLUX");
+-   ("/xea/x86/xad", "YI SYLLABLE HLU");
+-   ("/xea/x86/xae", "YI SYLLABLE HLUP");
+-   ("/xea/x86/xaf", "YI SYLLABLE HLURX");
+-   ("/xea/x86/xb0", "YI SYLLABLE HLUR");
+-   ("/xea/x86/xb1", "YI SYLLABLE HLYT");
+-   ("/xea/x86/xb2", "YI SYLLABLE HLYX");
+-   ("/xea/x86/xb3", "YI SYLLABLE HLY");
+-   ("/xea/x86/xb4", "YI SYLLABLE HLYP");
+-   ("/xea/x86/xb5", "YI SYLLABLE HLYRX");
+-   ("/xea/x86/xb6", "YI SYLLABLE HLYR");
+-   ("/xea/x86/xb7", "YI SYLLABLE LIT");
+-   ("/xea/x86/xb8", "YI SYLLABLE LIX");
+-   ("/xea/x86/xb9", "YI SYLLABLE LI");
+-   ("/xea/x86/xba", "YI SYLLABLE LIP");
+-   ("/xea/x86/xbb", "YI SYLLABLE LIET");
+-   ("/xea/x86/xbc", "YI SYLLABLE LIEX");
+-   ("/xea/x86/xbd", "YI SYLLABLE LIE");
+-   ("/xea/x86/xbe", "YI SYLLABLE LIEP");
+-   ("/xea/x86/xbf", "YI SYLLABLE LAT");
+-   ("/xea/x87/x80", "YI SYLLABLE LAX");
+-   ("/xea/x87/x81", "YI SYLLABLE LA");
+-   ("/xea/x87/x82", "YI SYLLABLE LAP");
+-   ("/xea/x87/x83", "YI SYLLABLE LUOT");
+-   ("/xea/x87/x84", "YI SYLLABLE LUOX");
+-   ("/xea/x87/x85", "YI SYLLABLE LUO");
+-   ("/xea/x87/x86", "YI SYLLABLE LUOP");
+-   ("/xea/x87/x87", "YI SYLLABLE LOT");
+-   ("/xea/x87/x88", "YI SYLLABLE LOX");
+-   ("/xea/x87/x89", "YI SYLLABLE LO");
+-   ("/xea/x87/x8a", "YI SYLLABLE LOP");
+-   ("/xea/x87/x8b", "YI SYLLABLE LEX");
+-   ("/xea/x87/x8c", "YI SYLLABLE LE");
+-   ("/xea/x87/x8d", "YI SYLLABLE LEP");
+-   ("/xea/x87/x8e", "YI SYLLABLE LUT");
+-   ("/xea/x87/x8f", "YI SYLLABLE LUX");
+-   ("/xea/x87/x90", "YI SYLLABLE LU");
+-   ("/xea/x87/x91", "YI SYLLABLE LUP");
+-   ("/xea/x87/x92", "YI SYLLABLE LURX");
+-   ("/xea/x87/x93", "YI SYLLABLE LUR");
+-   ("/xea/x87/x94", "YI SYLLABLE LYT");
+-   ("/xea/x87/x95", "YI SYLLABLE LYX");
+-   ("/xea/x87/x96", "YI SYLLABLE LY");
+-   ("/xea/x87/x97", "YI SYLLABLE LYP");
+-   ("/xea/x87/x98", "YI SYLLABLE LYRX");
+-   ("/xea/x87/x99", "YI SYLLABLE LYR");
+-   ("/xea/x87/x9a", "YI SYLLABLE GIT");
+-   ("/xea/x87/x9b", "YI SYLLABLE GIX");
+-   ("/xea/x87/x9c", "YI SYLLABLE GI");
+-   ("/xea/x87/x9d", "YI SYLLABLE GIP");
+-   ("/xea/x87/x9e", "YI SYLLABLE GIET");
+-   ("/xea/x87/x9f", "YI SYLLABLE GIEX");
+-   ("/xea/x87/xa0", "YI SYLLABLE GIE");
+-   ("/xea/x87/xa1", "YI SYLLABLE GIEP");
+-   ("/xea/x87/xa2", "YI SYLLABLE GAT");
+-   ("/xea/x87/xa3", "YI SYLLABLE GAX");
+-   ("/xea/x87/xa4", "YI SYLLABLE GA");
+-   ("/xea/x87/xa5", "YI SYLLABLE GAP");
+-   ("/xea/x87/xa6", "YI SYLLABLE GUOT");
+-   ("/xea/x87/xa7", "YI SYLLABLE GUOX");
+-   ("/xea/x87/xa8", "YI SYLLABLE GUO");
+-   ("/xea/x87/xa9", "YI SYLLABLE GUOP");
+-   ("/xea/x87/xaa", "YI SYLLABLE GOT");
+-   ("/xea/x87/xab", "YI SYLLABLE GOX");
+-   ("/xea/x87/xac", "YI SYLLABLE GO");
+-   ("/xea/x87/xad", "YI SYLLABLE GOP");
+-   ("/xea/x87/xae", "YI SYLLABLE GET");
+-   ("/xea/x87/xaf", "YI SYLLABLE GEX");
+-   ("/xea/x87/xb0", "YI SYLLABLE GE");
+-   ("/xea/x87/xb1", "YI SYLLABLE GEP");
+-   ("/xea/x87/xb2", "YI SYLLABLE GUT");
+-   ("/xea/x87/xb3", "YI SYLLABLE GUX");
+-   ("/xea/x87/xb4", "YI SYLLABLE GU");
+-   ("/xea/x87/xb5", "YI SYLLABLE GUP");
+-   ("/xea/x87/xb6", "YI SYLLABLE GURX");
+-   ("/xea/x87/xb7", "YI SYLLABLE GUR");
+-   ("/xea/x87/xb8", "YI SYLLABLE KIT");
+-   ("/xea/x87/xb9", "YI SYLLABLE KIX");
+-   ("/xea/x87/xba", "YI SYLLABLE KI");
+-   ("/xea/x87/xbb", "YI SYLLABLE KIP");
+-   ("/xea/x87/xbc", "YI SYLLABLE KIEX");
+-   ("/xea/x87/xbd", "YI SYLLABLE KIE");
+-   ("/xea/x87/xbe", "YI SYLLABLE KIEP");
+-   ("/xea/x87/xbf", "YI SYLLABLE KAT");
+-   ("/xea/x88/x80", "YI SYLLABLE KAX");
+-   ("/xea/x88/x81", "YI SYLLABLE KA");
+-   ("/xea/x88/x82", "YI SYLLABLE KAP");
+-   ("/xea/x88/x83", "YI SYLLABLE KUOX");
+-   ("/xea/x88/x84", "YI SYLLABLE KUO");
+-   ("/xea/x88/x85", "YI SYLLABLE KUOP");
+-   ("/xea/x88/x86", "YI SYLLABLE KOT");
+-   ("/xea/x88/x87", "YI SYLLABLE KOX");
+-   ("/xea/x88/x88", "YI SYLLABLE KO");
+-   ("/xea/x88/x89", "YI SYLLABLE KOP");
+-   ("/xea/x88/x8a", "YI SYLLABLE KET");
+-   ("/xea/x88/x8b", "YI SYLLABLE KEX");
+-   ("/xea/x88/x8c", "YI SYLLABLE KE");
+-   ("/xea/x88/x8d", "YI SYLLABLE KEP");
+-   ("/xea/x88/x8e", "YI SYLLABLE KUT");
+-   ("/xea/x88/x8f", "YI SYLLABLE KUX");
+-   ("/xea/x88/x90", "YI SYLLABLE KU");
+-   ("/xea/x88/x91", "YI SYLLABLE KUP");
+-   ("/xea/x88/x92", "YI SYLLABLE KURX");
+-   ("/xea/x88/x93", "YI SYLLABLE KUR");
+-   ("/xea/x88/x94", "YI SYLLABLE GGIT");
+-   ("/xea/x88/x95", "YI SYLLABLE GGIX");
+-   ("/xea/x88/x96", "YI SYLLABLE GGI");
+-   ("/xea/x88/x97", "YI SYLLABLE GGIEX");
+-   ("/xea/x88/x98", "YI SYLLABLE GGIE");
+-   ("/xea/x88/x99", "YI SYLLABLE GGIEP");
+-   ("/xea/x88/x9a", "YI SYLLABLE GGAT");
+-   ("/xea/x88/x9b", "YI SYLLABLE GGAX");
+-   ("/xea/x88/x9c", "YI SYLLABLE GGA");
+-   ("/xea/x88/x9d", "YI SYLLABLE GGAP");
+-   ("/xea/x88/x9e", "YI SYLLABLE GGUOT");
+-   ("/xea/x88/x9f", "YI SYLLABLE GGUOX");
+-   ("/xea/x88/xa0", "YI SYLLABLE GGUO");
+-   ("/xea/x88/xa1", "YI SYLLABLE GGUOP");
+-   ("/xea/x88/xa2", "YI SYLLABLE GGOT");
+-   ("/xea/x88/xa3", "YI SYLLABLE GGOX");
+-   ("/xea/x88/xa4", "YI SYLLABLE GGO");
+-   ("/xea/x88/xa5", "YI SYLLABLE GGOP");
+-   ("/xea/x88/xa6", "YI SYLLABLE GGET");
+-   ("/xea/x88/xa7", "YI SYLLABLE GGEX");
+-   ("/xea/x88/xa8", "YI SYLLABLE GGE");
+-   ("/xea/x88/xa9", "YI SYLLABLE GGEP");
+-   ("/xea/x88/xaa", "YI SYLLABLE GGUT");
+-   ("/xea/x88/xab", "YI SYLLABLE GGUX");
+-   ("/xea/x88/xac", "YI SYLLABLE GGU");
+-   ("/xea/x88/xad", "YI SYLLABLE GGUP");
+-   ("/xea/x88/xae", "YI SYLLABLE GGURX");
+-   ("/xea/x88/xaf", "YI SYLLABLE GGUR");
+-   ("/xea/x88/xb0", "YI SYLLABLE MGIEX");
+-   ("/xea/x88/xb1", "YI SYLLABLE MGIE");
+-   ("/xea/x88/xb2", "YI SYLLABLE MGAT");
+-   ("/xea/x88/xb3", "YI SYLLABLE MGAX");
+-   ("/xea/x88/xb4", "YI SYLLABLE MGA");
+-   ("/xea/x88/xb5", "YI SYLLABLE MGAP");
+-   ("/xea/x88/xb6", "YI SYLLABLE MGUOX");
+-   ("/xea/x88/xb7", "YI SYLLABLE MGUO");
+-   ("/xea/x88/xb8", "YI SYLLABLE MGUOP");
+-   ("/xea/x88/xb9", "YI SYLLABLE MGOT");
+-   ("/xea/x88/xba", "YI SYLLABLE MGOX");
+-   ("/xea/x88/xbb", "YI SYLLABLE MGO");
+-   ("/xea/x88/xbc", "YI SYLLABLE MGOP");
+-   ("/xea/x88/xbd", "YI SYLLABLE MGEX");
+-   ("/xea/x88/xbe", "YI SYLLABLE MGE");
+-   ("/xea/x88/xbf", "YI SYLLABLE MGEP");
+-   ("/xea/x89/x80", "YI SYLLABLE MGUT");
+-   ("/xea/x89/x81", "YI SYLLABLE MGUX");
+-   ("/xea/x89/x82", "YI SYLLABLE MGU");
+-   ("/xea/x89/x83", "YI SYLLABLE MGUP");
+-   ("/xea/x89/x84", "YI SYLLABLE MGURX");
+-   ("/xea/x89/x85", "YI SYLLABLE MGUR");
+-   ("/xea/x89/x86", "YI SYLLABLE HXIT");
+-   ("/xea/x89/x87", "YI SYLLABLE HXIX");
+-   ("/xea/x89/x88", "YI SYLLABLE HXI");
+-   ("/xea/x89/x89", "YI SYLLABLE HXIP");
+-   ("/xea/x89/x8a", "YI SYLLABLE HXIET");
+-   ("/xea/x89/x8b", "YI SYLLABLE HXIEX");
+-   ("/xea/x89/x8c", "YI SYLLABLE HXIE");
+-   ("/xea/x89/x8d", "YI SYLLABLE HXIEP");
+-   ("/xea/x89/x8e", "YI SYLLABLE HXAT");
+-   ("/xea/x89/x8f", "YI SYLLABLE HXAX");
+-   ("/xea/x89/x90", "YI SYLLABLE HXA");
+-   ("/xea/x89/x91", "YI SYLLABLE HXAP");
+-   ("/xea/x89/x92", "YI SYLLABLE HXUOT");
+-   ("/xea/x89/x93", "YI SYLLABLE HXUOX");
+-   ("/xea/x89/x94", "YI SYLLABLE HXUO");
+-   ("/xea/x89/x95", "YI SYLLABLE HXUOP");
+-   ("/xea/x89/x96", "YI SYLLABLE HXOT");
+-   ("/xea/x89/x97", "YI SYLLABLE HXOX");
+-   ("/xea/x89/x98", "YI SYLLABLE HXO");
+-   ("/xea/x89/x99", "YI SYLLABLE HXOP");
+-   ("/xea/x89/x9a", "YI SYLLABLE HXEX");
+-   ("/xea/x89/x9b", "YI SYLLABLE HXE");
+-   ("/xea/x89/x9c", "YI SYLLABLE HXEP");
+-   ("/xea/x89/x9d", "YI SYLLABLE NGIEX");
+-   ("/xea/x89/x9e", "YI SYLLABLE NGIE");
+-   ("/xea/x89/x9f", "YI SYLLABLE NGIEP");
+-   ("/xea/x89/xa0", "YI SYLLABLE NGAT");
+-   ("/xea/x89/xa1", "YI SYLLABLE NGAX");
+-   ("/xea/x89/xa2", "YI SYLLABLE NGA");
+-   ("/xea/x89/xa3", "YI SYLLABLE NGAP");
+-   ("/xea/x89/xa4", "YI SYLLABLE NGUOT");
+-   ("/xea/x89/xa5", "YI SYLLABLE NGUOX");
+-   ("/xea/x89/xa6", "YI SYLLABLE NGUO");
+-   ("/xea/x89/xa7", "YI SYLLABLE NGOT");
+-   ("/xea/x89/xa8", "YI SYLLABLE NGOX");
+-   ("/xea/x89/xa9", "YI SYLLABLE NGO");
+-   ("/xea/x89/xaa", "YI SYLLABLE NGOP");
+-   ("/xea/x89/xab", "YI SYLLABLE NGEX");
+-   ("/xea/x89/xac", "YI SYLLABLE NGE");
+-   ("/xea/x89/xad", "YI SYLLABLE NGEP");
+-   ("/xea/x89/xae", "YI SYLLABLE HIT");
+-   ("/xea/x89/xaf", "YI SYLLABLE HIEX");
+-   ("/xea/x89/xb0", "YI SYLLABLE HIE");
+-   ("/xea/x89/xb1", "YI SYLLABLE HAT");
+-   ("/xea/x89/xb2", "YI SYLLABLE HAX");
+-   ("/xea/x89/xb3", "YI SYLLABLE HA");
+-   ("/xea/x89/xb4", "YI SYLLABLE HAP");
+-   ("/xea/x89/xb5", "YI SYLLABLE HUOT");
+-   ("/xea/x89/xb6", "YI SYLLABLE HUOX");
+-   ("/xea/x89/xb7", "YI SYLLABLE HUO");
+-   ("/xea/x89/xb8", "YI SYLLABLE HUOP");
+-   ("/xea/x89/xb9", "YI SYLLABLE HOT");
+-   ("/xea/x89/xba", "YI SYLLABLE HOX");
+-   ("/xea/x89/xbb", "YI SYLLABLE HO");
+-   ("/xea/x89/xbc", "YI SYLLABLE HOP");
+-   ("/xea/x89/xbd", "YI SYLLABLE HEX");
+-   ("/xea/x89/xbe", "YI SYLLABLE HE");
+-   ("/xea/x89/xbf", "YI SYLLABLE HEP");
+-   ("/xea/x8a/x80", "YI SYLLABLE WAT");
+-   ("/xea/x8a/x81", "YI SYLLABLE WAX");
+-   ("/xea/x8a/x82", "YI SYLLABLE WA");
+-   ("/xea/x8a/x83", "YI SYLLABLE WAP");
+-   ("/xea/x8a/x84", "YI SYLLABLE WUOX");
+-   ("/xea/x8a/x85", "YI SYLLABLE WUO");
+-   ("/xea/x8a/x86", "YI SYLLABLE WUOP");
+-   ("/xea/x8a/x87", "YI SYLLABLE WOX");
+-   ("/xea/x8a/x88", "YI SYLLABLE WO");
+-   ("/xea/x8a/x89", "YI SYLLABLE WOP");
+-   ("/xea/x8a/x8a", "YI SYLLABLE WEX");
+-   ("/xea/x8a/x8b", "YI SYLLABLE WE");
+-   ("/xea/x8a/x8c", "YI SYLLABLE WEP");
+-   ("/xea/x8a/x8d", "YI SYLLABLE ZIT");
+-   ("/xea/x8a/x8e", "YI SYLLABLE ZIX");
+-   ("/xea/x8a/x8f", "YI SYLLABLE ZI");
+-   ("/xea/x8a/x90", "YI SYLLABLE ZIP");
+-   ("/xea/x8a/x91", "YI SYLLABLE ZIEX");
+-   ("/xea/x8a/x92", "YI SYLLABLE ZIE");
+-   ("/xea/x8a/x93", "YI SYLLABLE ZIEP");
+-   ("/xea/x8a/x94", "YI SYLLABLE ZAT");
+-   ("/xea/x8a/x95", "YI SYLLABLE ZAX");
+-   ("/xea/x8a/x96", "YI SYLLABLE ZA");
+-   ("/xea/x8a/x97", "YI SYLLABLE ZAP");
+-   ("/xea/x8a/x98", "YI SYLLABLE ZUOX");
+-   ("/xea/x8a/x99", "YI SYLLABLE ZUO");
+-   ("/xea/x8a/x9a", "YI SYLLABLE ZUOP");
+-   ("/xea/x8a/x9b", "YI SYLLABLE ZOT");
+-   ("/xea/x8a/x9c", "YI SYLLABLE ZOX");
+-   ("/xea/x8a/x9d", "YI SYLLABLE ZO");
+-   ("/xea/x8a/x9e", "YI SYLLABLE ZOP");
+-   ("/xea/x8a/x9f", "YI SYLLABLE ZEX");
+-   ("/xea/x8a/xa0", "YI SYLLABLE ZE");
+-   ("/xea/x8a/xa1", "YI SYLLABLE ZEP");
+-   ("/xea/x8a/xa2", "YI SYLLABLE ZUT");
+-   ("/xea/x8a/xa3", "YI SYLLABLE ZUX");
+-   ("/xea/x8a/xa4", "YI SYLLABLE ZU");
+-   ("/xea/x8a/xa5", "YI SYLLABLE ZUP");
+-   ("/xea/x8a/xa6", "YI SYLLABLE ZURX");
+-   ("/xea/x8a/xa7", "YI SYLLABLE ZUR");
+-   ("/xea/x8a/xa8", "YI SYLLABLE ZYT");
+-   ("/xea/x8a/xa9", "YI SYLLABLE ZYX");
+-   ("/xea/x8a/xaa", "YI SYLLABLE ZY");
+-   ("/xea/x8a/xab", "YI SYLLABLE ZYP");
+-   ("/xea/x8a/xac", "YI SYLLABLE ZYRX");
+-   ("/xea/x8a/xad", "YI SYLLABLE ZYR");
+-   ("/xea/x8a/xae", "YI SYLLABLE CIT");
+-   ("/xea/x8a/xaf", "YI SYLLABLE CIX");
+-   ("/xea/x8a/xb0", "YI SYLLABLE CI");
+-   ("/xea/x8a/xb1", "YI SYLLABLE CIP");
+-   ("/xea/x8a/xb2", "YI SYLLABLE CIET");
+-   ("/xea/x8a/xb3", "YI SYLLABLE CIEX");
+-   ("/xea/x8a/xb4", "YI SYLLABLE CIE");
+-   ("/xea/x8a/xb5", "YI SYLLABLE CIEP");
+-   ("/xea/x8a/xb6", "YI SYLLABLE CAT");
+-   ("/xea/x8a/xb7", "YI SYLLABLE CAX");
+-   ("/xea/x8a/xb8", "YI SYLLABLE CA");
+-   ("/xea/x8a/xb9", "YI SYLLABLE CAP");
+-   ("/xea/x8a/xba", "YI SYLLABLE CUOX");
+-   ("/xea/x8a/xbb", "YI SYLLABLE CUO");
+-   ("/xea/x8a/xbc", "YI SYLLABLE CUOP");
+-   ("/xea/x8a/xbd", "YI SYLLABLE COT");
+-   ("/xea/x8a/xbe", "YI SYLLABLE COX");
+-   ("/xea/x8a/xbf", "YI SYLLABLE CO");
+-   ("/xea/x8b/x80", "YI SYLLABLE COP");
+-   ("/xea/x8b/x81", "YI SYLLABLE CEX");
+-   ("/xea/x8b/x82", "YI SYLLABLE CE");
+-   ("/xea/x8b/x83", "YI SYLLABLE CEP");
+-   ("/xea/x8b/x84", "YI SYLLABLE CUT");
+-   ("/xea/x8b/x85", "YI SYLLABLE CUX");
+-   ("/xea/x8b/x86", "YI SYLLABLE CU");
+-   ("/xea/x8b/x87", "YI SYLLABLE CUP");
+-   ("/xea/x8b/x88", "YI SYLLABLE CURX");
+-   ("/xea/x8b/x89", "YI SYLLABLE CUR");
+-   ("/xea/x8b/x8a", "YI SYLLABLE CYT");
+-   ("/xea/x8b/x8b", "YI SYLLABLE CYX");
+-   ("/xea/x8b/x8c", "YI SYLLABLE CY");
+-   ("/xea/x8b/x8d", "YI SYLLABLE CYP");
+-   ("/xea/x8b/x8e", "YI SYLLABLE CYRX");
+-   ("/xea/x8b/x8f", "YI SYLLABLE CYR");
+-   ("/xea/x8b/x90", "YI SYLLABLE ZZIT");
+-   ("/xea/x8b/x91", "YI SYLLABLE ZZIX");
+-   ("/xea/x8b/x92", "YI SYLLABLE ZZI");
+-   ("/xea/x8b/x93", "YI SYLLABLE ZZIP");
+-   ("/xea/x8b/x94", "YI SYLLABLE ZZIET");
+-   ("/xea/x8b/x95", "YI SYLLABLE ZZIEX");
+-   ("/xea/x8b/x96", "YI SYLLABLE ZZIE");
+-   ("/xea/x8b/x97", "YI SYLLABLE ZZIEP");
+-   ("/xea/x8b/x98", "YI SYLLABLE ZZAT");
+-   ("/xea/x8b/x99", "YI SYLLABLE ZZAX");
+-   ("/xea/x8b/x9a", "YI SYLLABLE ZZA");
+-   ("/xea/x8b/x9b", "YI SYLLABLE ZZAP");
+-   ("/xea/x8b/x9c", "YI SYLLABLE ZZOX");
+-   ("/xea/x8b/x9d", "YI SYLLABLE ZZO");
+-   ("/xea/x8b/x9e", "YI SYLLABLE ZZOP");
+-   ("/xea/x8b/x9f", "YI SYLLABLE ZZEX");
+-   ("/xea/x8b/xa0", "YI SYLLABLE ZZE");
+-   ("/xea/x8b/xa1", "YI SYLLABLE ZZEP");
+-   ("/xea/x8b/xa2", "YI SYLLABLE ZZUX");
+-   ("/xea/x8b/xa3", "YI SYLLABLE ZZU");
+-   ("/xea/x8b/xa4", "YI SYLLABLE ZZUP");
+-   ("/xea/x8b/xa5", "YI SYLLABLE ZZURX");
+-   ("/xea/x8b/xa6", "YI SYLLABLE ZZUR");
+-   ("/xea/x8b/xa7", "YI SYLLABLE ZZYT");
+-   ("/xea/x8b/xa8", "YI SYLLABLE ZZYX");
+-   ("/xea/x8b/xa9", "YI SYLLABLE ZZY");
+-   ("/xea/x8b/xaa", "YI SYLLABLE ZZYP");
+-   ("/xea/x8b/xab", "YI SYLLABLE ZZYRX");
+-   ("/xea/x8b/xac", "YI SYLLABLE ZZYR");
+-   ("/xea/x8b/xad", "YI SYLLABLE NZIT");
+-   ("/xea/x8b/xae", "YI SYLLABLE NZIX");
+-   ("/xea/x8b/xaf", "YI SYLLABLE NZI");
+-   ("/xea/x8b/xb0", "YI SYLLABLE NZIP");
+-   ("/xea/x8b/xb1", "YI SYLLABLE NZIEX");
+-   ("/xea/x8b/xb2", "YI SYLLABLE NZIE");
+-   ("/xea/x8b/xb3", "YI SYLLABLE NZIEP");
+-   ("/xea/x8b/xb4", "YI SYLLABLE NZAT");
+-   ("/xea/x8b/xb5", "YI SYLLABLE NZAX");
+-   ("/xea/x8b/xb6", "YI SYLLABLE NZA");
+-   ("/xea/x8b/xb7", "YI SYLLABLE NZAP");
+-   ("/xea/x8b/xb8", "YI SYLLABLE NZUOX");
+-   ("/xea/x8b/xb9", "YI SYLLABLE NZUO");
+-   ("/xea/x8b/xba", "YI SYLLABLE NZOX");
+-   ("/xea/x8b/xbb", "YI SYLLABLE NZOP");
+-   ("/xea/x8b/xbc", "YI SYLLABLE NZEX");
+-   ("/xea/x8b/xbd", "YI SYLLABLE NZE");
+-   ("/xea/x8b/xbe", "YI SYLLABLE NZUX");
+-   ("/xea/x8b/xbf", "YI SYLLABLE NZU");
+-   ("/xea/x8c/x80", "YI SYLLABLE NZUP");
+-   ("/xea/x8c/x81", "YI SYLLABLE NZURX");
+-   ("/xea/x8c/x82", "YI SYLLABLE NZUR");
+-   ("/xea/x8c/x83", "YI SYLLABLE NZYT");
+-   ("/xea/x8c/x84", "YI SYLLABLE NZYX");
+-   ("/xea/x8c/x85", "YI SYLLABLE NZY");
+-   ("/xea/x8c/x86", "YI SYLLABLE NZYP");
+-   ("/xea/x8c/x87", "YI SYLLABLE NZYRX");
+-   ("/xea/x8c/x88", "YI SYLLABLE NZYR");
+-   ("/xea/x8c/x89", "YI SYLLABLE SIT");
+-   ("/xea/x8c/x8a", "YI SYLLABLE SIX");
+-   ("/xea/x8c/x8b", "YI SYLLABLE SI");
+-   ("/xea/x8c/x8c", "YI SYLLABLE SIP");
+-   ("/xea/x8c/x8d", "YI SYLLABLE SIEX");
+-   ("/xea/x8c/x8e", "YI SYLLABLE SIE");
+-   ("/xea/x8c/x8f", "YI SYLLABLE SIEP");
+-   ("/xea/x8c/x90", "YI SYLLABLE SAT");
+-   ("/xea/x8c/x91", "YI SYLLABLE SAX");
+-   ("/xea/x8c/x92", "YI SYLLABLE SA");
+-   ("/xea/x8c/x93", "YI SYLLABLE SAP");
+-   ("/xea/x8c/x94", "YI SYLLABLE SUOX");
+-   ("/xea/x8c/x95", "YI SYLLABLE SUO");
+-   ("/xea/x8c/x96", "YI SYLLABLE SUOP");
+-   ("/xea/x8c/x97", "YI SYLLABLE SOT");
+-   ("/xea/x8c/x98", "YI SYLLABLE SOX");
+-   ("/xea/x8c/x99", "YI SYLLABLE SO");
+-   ("/xea/x8c/x9a", "YI SYLLABLE SOP");
+-   ("/xea/x8c/x9b", "YI SYLLABLE SEX");
+-   ("/xea/x8c/x9c", "YI SYLLABLE SE");
+-   ("/xea/x8c/x9d", "YI SYLLABLE SEP");
+-   ("/xea/x8c/x9e", "YI SYLLABLE SUT");
+-   ("/xea/x8c/x9f", "YI SYLLABLE SUX");
+-   ("/xea/x8c/xa0", "YI SYLLABLE SU");
+-   ("/xea/x8c/xa1", "YI SYLLABLE SUP");
+-   ("/xea/x8c/xa2", "YI SYLLABLE SURX");
+-   ("/xea/x8c/xa3", "YI SYLLABLE SUR");
+-   ("/xea/x8c/xa4", "YI SYLLABLE SYT");
+-   ("/xea/x8c/xa5", "YI SYLLABLE SYX");
+-   ("/xea/x8c/xa6", "YI SYLLABLE SY");
+-   ("/xea/x8c/xa7", "YI SYLLABLE SYP");
+-   ("/xea/x8c/xa8", "YI SYLLABLE SYRX");
+-   ("/xea/x8c/xa9", "YI SYLLABLE SYR");
+-   ("/xea/x8c/xaa", "YI SYLLABLE SSIT");
+-   ("/xea/x8c/xab", "YI SYLLABLE SSIX");
+-   ("/xea/x8c/xac", "YI SYLLABLE SSI");
+-   ("/xea/x8c/xad", "YI SYLLABLE SSIP");
+-   ("/xea/x8c/xae", "YI SYLLABLE SSIEX");
+-   ("/xea/x8c/xaf", "YI SYLLABLE SSIE");
+-   ("/xea/x8c/xb0", "YI SYLLABLE SSIEP");
+-   ("/xea/x8c/xb1", "YI SYLLABLE SSAT");
+-   ("/xea/x8c/xb2", "YI SYLLABLE SSAX");
+-   ("/xea/x8c/xb3", "YI SYLLABLE SSA");
+-   ("/xea/x8c/xb4", "YI SYLLABLE SSAP");
+-   ("/xea/x8c/xb5", "YI SYLLABLE SSOT");
+-   ("/xea/x8c/xb6", "YI SYLLABLE SSOX");
+-   ("/xea/x8c/xb7", "YI SYLLABLE SSO");
+-   ("/xea/x8c/xb8", "YI SYLLABLE SSOP");
+-   ("/xea/x8c/xb9", "YI SYLLABLE SSEX");
+-   ("/xea/x8c/xba", "YI SYLLABLE SSE");
+-   ("/xea/x8c/xbb", "YI SYLLABLE SSEP");
+-   ("/xea/x8c/xbc", "YI SYLLABLE SSUT");
+-   ("/xea/x8c/xbd", "YI SYLLABLE SSUX");
+-   ("/xea/x8c/xbe", "YI SYLLABLE SSU");
+-   ("/xea/x8c/xbf", "YI SYLLABLE SSUP");
+-   ("/xea/x8d/x80", "YI SYLLABLE SSYT");
+-   ("/xea/x8d/x81", "YI SYLLABLE SSYX");
+-   ("/xea/x8d/x82", "YI SYLLABLE SSY");
+-   ("/xea/x8d/x83", "YI SYLLABLE SSYP");
+-   ("/xea/x8d/x84", "YI SYLLABLE SSYRX");
+-   ("/xea/x8d/x85", "YI SYLLABLE SSYR");
+-   ("/xea/x8d/x86", "YI SYLLABLE ZHAT");
+-   ("/xea/x8d/x87", "YI SYLLABLE ZHAX");
+-   ("/xea/x8d/x88", "YI SYLLABLE ZHA");
+-   ("/xea/x8d/x89", "YI SYLLABLE ZHAP");
+-   ("/xea/x8d/x8a", "YI SYLLABLE ZHUOX");
+-   ("/xea/x8d/x8b", "YI SYLLABLE ZHUO");
+-   ("/xea/x8d/x8c", "YI SYLLABLE ZHUOP");
+-   ("/xea/x8d/x8d", "YI SYLLABLE ZHOT");
+-   ("/xea/x8d/x8e", "YI SYLLABLE ZHOX");
+-   ("/xea/x8d/x8f", "YI SYLLABLE ZHO");
+-   ("/xea/x8d/x90", "YI SYLLABLE ZHOP");
+-   ("/xea/x8d/x91", "YI SYLLABLE ZHET");
+-   ("/xea/x8d/x92", "YI SYLLABLE ZHEX");
+-   ("/xea/x8d/x93", "YI SYLLABLE ZHE");
+-   ("/xea/x8d/x94", "YI SYLLABLE ZHEP");
+-   ("/xea/x8d/x95", "YI SYLLABLE ZHUT");
+-   ("/xea/x8d/x96", "YI SYLLABLE ZHUX");
+-   ("/xea/x8d/x97", "YI SYLLABLE ZHU");
+-   ("/xea/x8d/x98", "YI SYLLABLE ZHUP");
+-   ("/xea/x8d/x99", "YI SYLLABLE ZHURX");
+-   ("/xea/x8d/x9a", "YI SYLLABLE ZHUR");
+-   ("/xea/x8d/x9b", "YI SYLLABLE ZHYT");
+-   ("/xea/x8d/x9c", "YI SYLLABLE ZHYX");
+-   ("/xea/x8d/x9d", "YI SYLLABLE ZHY");
+-   ("/xea/x8d/x9e", "YI SYLLABLE ZHYP");
+-   ("/xea/x8d/x9f", "YI SYLLABLE ZHYRX");
+-   ("/xea/x8d/xa0", "YI SYLLABLE ZHYR");
+-   ("/xea/x8d/xa1", "YI SYLLABLE CHAT");
+-   ("/xea/x8d/xa2", "YI SYLLABLE CHAX");
+-   ("/xea/x8d/xa3", "YI SYLLABLE CHA");
+-   ("/xea/x8d/xa4", "YI SYLLABLE CHAP");
+-   ("/xea/x8d/xa5", "YI SYLLABLE CHUOT");
+-   ("/xea/x8d/xa6", "YI SYLLABLE CHUOX");
+-   ("/xea/x8d/xa7", "YI SYLLABLE CHUO");
+-   ("/xea/x8d/xa8", "YI SYLLABLE CHUOP");
+-   ("/xea/x8d/xa9", "YI SYLLABLE CHOT");
+-   ("/xea/x8d/xaa", "YI SYLLABLE CHOX");
+-   ("/xea/x8d/xab", "YI SYLLABLE CHO");
+-   ("/xea/x8d/xac", "YI SYLLABLE CHOP");
+-   ("/xea/x8d/xad", "YI SYLLABLE CHET");
+-   ("/xea/x8d/xae", "YI SYLLABLE CHEX");
+-   ("/xea/x8d/xaf", "YI SYLLABLE CHE");
+-   ("/xea/x8d/xb0", "YI SYLLABLE CHEP");
+-   ("/xea/x8d/xb1", "YI SYLLABLE CHUX");
+-   ("/xea/x8d/xb2", "YI SYLLABLE CHU");
+-   ("/xea/x8d/xb3", "YI SYLLABLE CHUP");
+-   ("/xea/x8d/xb4", "YI SYLLABLE CHURX");
+-   ("/xea/x8d/xb5", "YI SYLLABLE CHUR");
+-   ("/xea/x8d/xb6", "YI SYLLABLE CHYT");
+-   ("/xea/x8d/xb7", "YI SYLLABLE CHYX");
+-   ("/xea/x8d/xb8", "YI SYLLABLE CHY");
+-   ("/xea/x8d/xb9", "YI SYLLABLE CHYP");
+-   ("/xea/x8d/xba", "YI SYLLABLE CHYRX");
+-   ("/xea/x8d/xbb", "YI SYLLABLE CHYR");
+-   ("/xea/x8d/xbc", "YI SYLLABLE RRAX");
+-   ("/xea/x8d/xbd", "YI SYLLABLE RRA");
+-   ("/xea/x8d/xbe", "YI SYLLABLE RRUOX");
+-   ("/xea/x8d/xbf", "YI SYLLABLE RRUO");
+-   ("/xea/x8e/x80", "YI SYLLABLE RROT");
+-   ("/xea/x8e/x81", "YI SYLLABLE RROX");
+-   ("/xea/x8e/x82", "YI SYLLABLE RRO");
+-   ("/xea/x8e/x83", "YI SYLLABLE RROP");
+-   ("/xea/x8e/x84", "YI SYLLABLE RRET");
+-   ("/xea/x8e/x85", "YI SYLLABLE RREX");
+-   ("/xea/x8e/x86", "YI SYLLABLE RRE");
+-   ("/xea/x8e/x87", "YI SYLLABLE RREP");
+-   ("/xea/x8e/x88", "YI SYLLABLE RRUT");
+-   ("/xea/x8e/x89", "YI SYLLABLE RRUX");
+-   ("/xea/x8e/x8a", "YI SYLLABLE RRU");
+-   ("/xea/x8e/x8b", "YI SYLLABLE RRUP");
+-   ("/xea/x8e/x8c", "YI SYLLABLE RRURX");
+-   ("/xea/x8e/x8d", "YI SYLLABLE RRUR");
+-   ("/xea/x8e/x8e", "YI SYLLABLE RRYT");
+-   ("/xea/x8e/x8f", "YI SYLLABLE RRYX");
+-   ("/xea/x8e/x90", "YI SYLLABLE RRY");
+-   ("/xea/x8e/x91", "YI SYLLABLE RRYP");
+-   ("/xea/x8e/x92", "YI SYLLABLE RRYRX");
+-   ("/xea/x8e/x93", "YI SYLLABLE RRYR");
+-   ("/xea/x8e/x94", "YI SYLLABLE NRAT");
+-   ("/xea/x8e/x95", "YI SYLLABLE NRAX");
+-   ("/xea/x8e/x96", "YI SYLLABLE NRA");
+-   ("/xea/x8e/x97", "YI SYLLABLE NRAP");
+-   ("/xea/x8e/x98", "YI SYLLABLE NROX");
+-   ("/xea/x8e/x99", "YI SYLLABLE NRO");
+-   ("/xea/x8e/x9a", "YI SYLLABLE NROP");
+-   ("/xea/x8e/x9b", "YI SYLLABLE NRET");
+-   ("/xea/x8e/x9c", "YI SYLLABLE NREX");
+-   ("/xea/x8e/x9d", "YI SYLLABLE NRE");
+-   ("/xea/x8e/x9e", "YI SYLLABLE NREP");
+-   ("/xea/x8e/x9f", "YI SYLLABLE NRUT");
+-   ("/xea/x8e/xa0", "YI SYLLABLE NRUX");
+-   ("/xea/x8e/xa1", "YI SYLLABLE NRU");
+-   ("/xea/x8e/xa2", "YI SYLLABLE NRUP");
+-   ("/xea/x8e/xa3", "YI SYLLABLE NRURX");
+-   ("/xea/x8e/xa4", "YI SYLLABLE NRUR");
+-   ("/xea/x8e/xa5", "YI SYLLABLE NRYT");
+-   ("/xea/x8e/xa6", "YI SYLLABLE NRYX");
+-   ("/xea/x8e/xa7", "YI SYLLABLE NRY");
+-   ("/xea/x8e/xa8", "YI SYLLABLE NRYP");
+-   ("/xea/x8e/xa9", "YI SYLLABLE NRYRX");
+-   ("/xea/x8e/xaa", "YI SYLLABLE NRYR");
+-   ("/xea/x8e/xab", "YI SYLLABLE SHAT");
+-   ("/xea/x8e/xac", "YI SYLLABLE SHAX");
+-   ("/xea/x8e/xad", "YI SYLLABLE SHA");
+-   ("/xea/x8e/xae", "YI SYLLABLE SHAP");
+-   ("/xea/x8e/xaf", "YI SYLLABLE SHUOX");
+-   ("/xea/x8e/xb0", "YI SYLLABLE SHUO");
+-   ("/xea/x8e/xb1", "YI SYLLABLE SHUOP");
+-   ("/xea/x8e/xb2", "YI SYLLABLE SHOT");
+-   ("/xea/x8e/xb3", "YI SYLLABLE SHOX");
+-   ("/xea/x8e/xb4", "YI SYLLABLE SHO");
+-   ("/xea/x8e/xb5", "YI SYLLABLE SHOP");
+-   ("/xea/x8e/xb6", "YI SYLLABLE SHET");
+-   ("/xea/x8e/xb7", "YI SYLLABLE SHEX");
+-   ("/xea/x8e/xb8", "YI SYLLABLE SHE");
+-   ("/xea/x8e/xb9", "YI SYLLABLE SHEP");
+-   ("/xea/x8e/xba", "YI SYLLABLE SHUT");
+-   ("/xea/x8e/xbb", "YI SYLLABLE SHUX");
+-   ("/xea/x8e/xbc", "YI SYLLABLE SHU");
+-   ("/xea/x8e/xbd", "YI SYLLABLE SHUP");
+-   ("/xea/x8e/xbe", "YI SYLLABLE SHURX");
+-   ("/xea/x8e/xbf", "YI SYLLABLE SHUR");
+-   ("/xea/x8f/x80", "YI SYLLABLE SHYT");
+-   ("/xea/x8f/x81", "YI SYLLABLE SHYX");
+-   ("/xea/x8f/x82", "YI SYLLABLE SHY");
+-   ("/xea/x8f/x83", "YI SYLLABLE SHYP");
+-   ("/xea/x8f/x84", "YI SYLLABLE SHYRX");
+-   ("/xea/x8f/x85", "YI SYLLABLE SHYR");
+-   ("/xea/x8f/x86", "YI SYLLABLE RAT");
+-   ("/xea/x8f/x87", "YI SYLLABLE RAX");
+-   ("/xea/x8f/x88", "YI SYLLABLE RA");
+-   ("/xea/x8f/x89", "YI SYLLABLE RAP");
+-   ("/xea/x8f/x8a", "YI SYLLABLE RUOX");
+-   ("/xea/x8f/x8b", "YI SYLLABLE RUO");
+-   ("/xea/x8f/x8c", "YI SYLLABLE RUOP");
+-   ("/xea/x8f/x8d", "YI SYLLABLE ROT");
+-   ("/xea/x8f/x8e", "YI SYLLABLE ROX");
+-   ("/xea/x8f/x8f", "YI SYLLABLE RO");
+-   ("/xea/x8f/x90", "YI SYLLABLE ROP");
+-   ("/xea/x8f/x91", "YI SYLLABLE REX");
+-   ("/xea/x8f/x92", "YI SYLLABLE RE");
+-   ("/xea/x8f/x93", "YI SYLLABLE REP");
+-   ("/xea/x8f/x94", "YI SYLLABLE RUT");
+-   ("/xea/x8f/x95", "YI SYLLABLE RUX");
+-   ("/xea/x8f/x96", "YI SYLLABLE RU");
+-   ("/xea/x8f/x97", "YI SYLLABLE RUP");
+-   ("/xea/x8f/x98", "YI SYLLABLE RURX");
+-   ("/xea/x8f/x99", "YI SYLLABLE RUR");
+-   ("/xea/x8f/x9a", "YI SYLLABLE RYT");
+-   ("/xea/x8f/x9b", "YI SYLLABLE RYX");
+-   ("/xea/x8f/x9c", "YI SYLLABLE RY");
+-   ("/xea/x8f/x9d", "YI SYLLABLE RYP");
+-   ("/xea/x8f/x9e", "YI SYLLABLE RYRX");
+-   ("/xea/x8f/x9f", "YI SYLLABLE RYR");
+-   ("/xea/x8f/xa0", "YI SYLLABLE JIT");
+-   ("/xea/x8f/xa1", "YI SYLLABLE JIX");
+-   ("/xea/x8f/xa2", "YI SYLLABLE JI");
+-   ("/xea/x8f/xa3", "YI SYLLABLE JIP");
+-   ("/xea/x8f/xa4", "YI SYLLABLE JIET");
+-   ("/xea/x8f/xa5", "YI SYLLABLE JIEX");
+-   ("/xea/x8f/xa6", "YI SYLLABLE JIE");
+-   ("/xea/x8f/xa7", "YI SYLLABLE JIEP");
+-   ("/xea/x8f/xa8", "YI SYLLABLE JUOT");
+-   ("/xea/x8f/xa9", "YI SYLLABLE JUOX");
+-   ("/xea/x8f/xaa", "YI SYLLABLE JUO");
+-   ("/xea/x8f/xab", "YI SYLLABLE JUOP");
+-   ("/xea/x8f/xac", "YI SYLLABLE JOT");
+-   ("/xea/x8f/xad", "YI SYLLABLE JOX");
+-   ("/xea/x8f/xae", "YI SYLLABLE JO");
+-   ("/xea/x8f/xaf", "YI SYLLABLE JOP");
+-   ("/xea/x8f/xb0", "YI SYLLABLE JUT");
+-   ("/xea/x8f/xb1", "YI SYLLABLE JUX");
+-   ("/xea/x8f/xb2", "YI SYLLABLE JU");
+-   ("/xea/x8f/xb3", "YI SYLLABLE JUP");
+-   ("/xea/x8f/xb4", "YI SYLLABLE JURX");
+-   ("/xea/x8f/xb5", "YI SYLLABLE JUR");
+-   ("/xea/x8f/xb6", "YI SYLLABLE JYT");
+-   ("/xea/x8f/xb7", "YI SYLLABLE JYX");
+-   ("/xea/x8f/xb8", "YI SYLLABLE JY");
+-   ("/xea/x8f/xb9", "YI SYLLABLE JYP");
+-   ("/xea/x8f/xba", "YI SYLLABLE JYRX");
+-   ("/xea/x8f/xbb", "YI SYLLABLE JYR");
+-   ("/xea/x8f/xbc", "YI SYLLABLE QIT");
+-   ("/xea/x8f/xbd", "YI SYLLABLE QIX");
+-   ("/xea/x8f/xbe", "YI SYLLABLE QI");
+-   ("/xea/x8f/xbf", "YI SYLLABLE QIP");
+-   ("/xea/x90/x80", "YI SYLLABLE QIET");
+-   ("/xea/x90/x81", "YI SYLLABLE QIEX");
+-   ("/xea/x90/x82", "YI SYLLABLE QIE");
+-   ("/xea/x90/x83", "YI SYLLABLE QIEP");
+-   ("/xea/x90/x84", "YI SYLLABLE QUOT");
+-   ("/xea/x90/x85", "YI SYLLABLE QUOX");
+-   ("/xea/x90/x86", "YI SYLLABLE QUO");
+-   ("/xea/x90/x87", "YI SYLLABLE QUOP");
+-   ("/xea/x90/x88", "YI SYLLABLE QOT");
+-   ("/xea/x90/x89", "YI SYLLABLE QOX");
+-   ("/xea/x90/x8a", "YI SYLLABLE QO");
+-   ("/xea/x90/x8b", "YI SYLLABLE QOP");
+-   ("/xea/x90/x8c", "YI SYLLABLE QUT");
+-   ("/xea/x90/x8d", "YI SYLLABLE QUX");
+-   ("/xea/x90/x8e", "YI SYLLABLE QU");
+-   ("/xea/x90/x8f", "YI SYLLABLE QUP");
+-   ("/xea/x90/x90", "YI SYLLABLE QURX");
+-   ("/xea/x90/x91", "YI SYLLABLE QUR");
+-   ("/xea/x90/x92", "YI SYLLABLE QYT");
+-   ("/xea/x90/x93", "YI SYLLABLE QYX");
+-   ("/xea/x90/x94", "YI SYLLABLE QY");
+-   ("/xea/x90/x95", "YI SYLLABLE QYP");
+-   ("/xea/x90/x96", "YI SYLLABLE QYRX");
+-   ("/xea/x90/x97", "YI SYLLABLE QYR");
+-   ("/xea/x90/x98", "YI SYLLABLE JJIT");
+-   ("/xea/x90/x99", "YI SYLLABLE JJIX");
+-   ("/xea/x90/x9a", "YI SYLLABLE JJI");
+-   ("/xea/x90/x9b", "YI SYLLABLE JJIP");
+-   ("/xea/x90/x9c", "YI SYLLABLE JJIET");
+-   ("/xea/x90/x9d", "YI SYLLABLE JJIEX");
+-   ("/xea/x90/x9e", "YI SYLLABLE JJIE");
+-   ("/xea/x90/x9f", "YI SYLLABLE JJIEP");
+-   ("/xea/x90/xa0", "YI SYLLABLE JJUOX");
+-   ("/xea/x90/xa1", "YI SYLLABLE JJUO");
+-   ("/xea/x90/xa2", "YI SYLLABLE JJUOP");
+-   ("/xea/x90/xa3", "YI SYLLABLE JJOT");
+-   ("/xea/x90/xa4", "YI SYLLABLE JJOX");
+-   ("/xea/x90/xa5", "YI SYLLABLE JJO");
+-   ("/xea/x90/xa6", "YI SYLLABLE JJOP");
+-   ("/xea/x90/xa7", "YI SYLLABLE JJUT");
+-   ("/xea/x90/xa8", "YI SYLLABLE JJUX");
+-   ("/xea/x90/xa9", "YI SYLLABLE JJU");
+-   ("/xea/x90/xaa", "YI SYLLABLE JJUP");
+-   ("/xea/x90/xab", "YI SYLLABLE JJURX");
+-   ("/xea/x90/xac", "YI SYLLABLE JJUR");
+-   ("/xea/x90/xad", "YI SYLLABLE JJYT");
+-   ("/xea/x90/xae", "YI SYLLABLE JJYX");
+-   ("/xea/x90/xaf", "YI SYLLABLE JJY");
+-   ("/xea/x90/xb0", "YI SYLLABLE JJYP");
+-   ("/xea/x90/xb1", "YI SYLLABLE NJIT");
+-   ("/xea/x90/xb2", "YI SYLLABLE NJIX");
+-   ("/xea/x90/xb3", "YI SYLLABLE NJI");
+-   ("/xea/x90/xb4", "YI SYLLABLE NJIP");
+-   ("/xea/x90/xb5", "YI SYLLABLE NJIET");
+-   ("/xea/x90/xb6", "YI SYLLABLE NJIEX");
+-   ("/xea/x90/xb7", "YI SYLLABLE NJIE");
+-   ("/xea/x90/xb8", "YI SYLLABLE NJIEP");
+-   ("/xea/x90/xb9", "YI SYLLABLE NJUOX");
+-   ("/xea/x90/xba", "YI SYLLABLE NJUO");
+-   ("/xea/x90/xbb", "YI SYLLABLE NJOT");
+-   ("/xea/x90/xbc", "YI SYLLABLE NJOX");
+-   ("/xea/x90/xbd", "YI SYLLABLE NJO");
+-   ("/xea/x90/xbe", "YI SYLLABLE NJOP");
+-   ("/xea/x90/xbf", "YI SYLLABLE NJUX");
+-   ("/xea/x91/x80", "YI SYLLABLE NJU");
+-   ("/xea/x91/x81", "YI SYLLABLE NJUP");
+-   ("/xea/x91/x82", "YI SYLLABLE NJURX");
+-   ("/xea/x91/x83", "YI SYLLABLE NJUR");
+-   ("/xea/x91/x84", "YI SYLLABLE NJYT");
+-   ("/xea/x91/x85", "YI SYLLABLE NJYX");
+-   ("/xea/x91/x86", "YI SYLLABLE NJY");
+-   ("/xea/x91/x87", "YI SYLLABLE NJYP");
+-   ("/xea/x91/x88", "YI SYLLABLE NJYRX");
+-   ("/xea/x91/x89", "YI SYLLABLE NJYR");
+-   ("/xea/x91/x8a", "YI SYLLABLE NYIT");
+-   ("/xea/x91/x8b", "YI SYLLABLE NYIX");
+-   ("/xea/x91/x8c", "YI SYLLABLE NYI");
+-   ("/xea/x91/x8d", "YI SYLLABLE NYIP");
+-   ("/xea/x91/x8e", "YI SYLLABLE NYIET");
+-   ("/xea/x91/x8f", "YI SYLLABLE NYIEX");
+-   ("/xea/x91/x90", "YI SYLLABLE NYIE");
+-   ("/xea/x91/x91", "YI SYLLABLE NYIEP");
+-   ("/xea/x91/x92", "YI SYLLABLE NYUOX");
+-   ("/xea/x91/x93", "YI SYLLABLE NYUO");
+-   ("/xea/x91/x94", "YI SYLLABLE NYUOP");
+-   ("/xea/x91/x95", "YI SYLLABLE NYOT");
+-   ("/xea/x91/x96", "YI SYLLABLE NYOX");
+-   ("/xea/x91/x97", "YI SYLLABLE NYO");
+-   ("/xea/x91/x98", "YI SYLLABLE NYOP");
+-   ("/xea/x91/x99", "YI SYLLABLE NYUT");
+-   ("/xea/x91/x9a", "YI SYLLABLE NYUX");
+-   ("/xea/x91/x9b", "YI SYLLABLE NYU");
+-   ("/xea/x91/x9c", "YI SYLLABLE NYUP");
+-   ("/xea/x91/x9d", "YI SYLLABLE XIT");
+-   ("/xea/x91/x9e", "YI SYLLABLE XIX");
+-   ("/xea/x91/x9f", "YI SYLLABLE XI");
+-   ("/xea/x91/xa0", "YI SYLLABLE XIP");
+-   ("/xea/x91/xa1", "YI SYLLABLE XIET");
+-   ("/xea/x91/xa2", "YI SYLLABLE XIEX");
+-   ("/xea/x91/xa3", "YI SYLLABLE XIE");
+-   ("/xea/x91/xa4", "YI SYLLABLE XIEP");
+-   ("/xea/x91/xa5", "YI SYLLABLE XUOX");
+-   ("/xea/x91/xa6", "YI SYLLABLE XUO");
+-   ("/xea/x91/xa7", "YI SYLLABLE XOT");
+-   ("/xea/x91/xa8", "YI SYLLABLE XOX");
+-   ("/xea/x91/xa9", "YI SYLLABLE XO");
+-   ("/xea/x91/xaa", "YI SYLLABLE XOP");
+-   ("/xea/x91/xab", "YI SYLLABLE XYT");
+-   ("/xea/x91/xac", "YI SYLLABLE XYX");
+-   ("/xea/x91/xad", "YI SYLLABLE XY");
+-   ("/xea/x91/xae", "YI SYLLABLE XYP");
+-   ("/xea/x91/xaf", "YI SYLLABLE XYRX");
+-   ("/xea/x91/xb0", "YI SYLLABLE XYR");
+-   ("/xea/x91/xb1", "YI SYLLABLE YIT");
+-   ("/xea/x91/xb2", "YI SYLLABLE YIX");
+-   ("/xea/x91/xb3", "YI SYLLABLE YI");
+-   ("/xea/x91/xb4", "YI SYLLABLE YIP");
+-   ("/xea/x91/xb5", "YI SYLLABLE YIET");
+-   ("/xea/x91/xb6", "YI SYLLABLE YIEX");
+-   ("/xea/x91/xb7", "YI SYLLABLE YIE");
+-   ("/xea/x91/xb8", "YI SYLLABLE YIEP");
+-   ("/xea/x91/xb9", "YI SYLLABLE YUOT");
+-   ("/xea/x91/xba", "YI SYLLABLE YUOX");
+-   ("/xea/x91/xbb", "YI SYLLABLE YUO");
+-   ("/xea/x91/xbc", "YI SYLLABLE YUOP");
+-   ("/xea/x91/xbd", "YI SYLLABLE YOT");
+-   ("/xea/x91/xbe", "YI SYLLABLE YOX");
+-   ("/xea/x91/xbf", "YI SYLLABLE YO");
+-   ("/xea/x92/x80", "YI SYLLABLE YOP");
+-   ("/xea/x92/x81", "YI SYLLABLE YUT");
+-   ("/xea/x92/x82", "YI SYLLABLE YUX");
+-   ("/xea/x92/x83", "YI SYLLABLE YU");
+-   ("/xea/x92/x84", "YI SYLLABLE YUP");
+-   ("/xea/x92/x85", "YI SYLLABLE YURX");
+-   ("/xea/x92/x86", "YI SYLLABLE YUR");
+-   ("/xea/x92/x87", "YI SYLLABLE YYT");
+-   ("/xea/x92/x88", "YI SYLLABLE YYX");
+-   ("/xea/x92/x89", "YI SYLLABLE YY");
+-   ("/xea/x92/x8a", "YI SYLLABLE YYP");
+-   ("/xea/x92/x8b", "YI SYLLABLE YYRX");
+-   ("/xea/x92/x8c", "YI SYLLABLE YYR");
+-   ("/xea/x92/x90", "YI RADICAL QOT");
+-   ("/xea/x92/x91", "YI RADICAL LI");
+-   ("/xea/x92/x92", "YI RADICAL KIT");
+-   ("/xea/x92/x93", "YI RADICAL NYIP");
+-   ("/xea/x92/x94", "YI RADICAL CYP");
+-   ("/xea/x92/x95", "YI RADICAL SSI");
+-   ("/xea/x92/x96", "YI RADICAL GGOP");
+-   ("/xea/x92/x97", "YI RADICAL GEP");
+-   ("/xea/x92/x98", "YI RADICAL MI");
+-   ("/xea/x92/x99", "YI RADICAL HXIT");
+-   ("/xea/x92/x9a", "YI RADICAL LYR");
+-   ("/xea/x92/x9b", "YI RADICAL BBUT");
+-   ("/xea/x92/x9c", "YI RADICAL MOP");
+-   ("/xea/x92/x9d", "YI RADICAL YO");
+-   ("/xea/x92/x9e", "YI RADICAL PUT");
+-   ("/xea/x92/x9f", "YI RADICAL HXUO");
+-   ("/xea/x92/xa0", "YI RADICAL TAT");
+-   ("/xea/x92/xa1", "YI RADICAL GA");
+-   ("/xea/x92/xa2", "YI RADICAL ZUP");
+-   ("/xea/x92/xa3", "YI RADICAL CYT");
+-   ("/xea/x92/xa4", "YI RADICAL DDUR");
+-   ("/xea/x92/xa5", "YI RADICAL BUR");
+-   ("/xea/x92/xa6", "YI RADICAL GGUO");
+-   ("/xea/x92/xa7", "YI RADICAL NYOP");
+-   ("/xea/x92/xa8", "YI RADICAL TU");
+-   ("/xea/x92/xa9", "YI RADICAL OP");
+-   ("/xea/x92/xaa", "YI RADICAL JJUT");
+-   ("/xea/x92/xab", "YI RADICAL ZOT");
+-   ("/xea/x92/xac", "YI RADICAL PYT");
+-   ("/xea/x92/xad", "YI RADICAL HMO");
+-   ("/xea/x92/xae", "YI RADICAL YIT");
+-   ("/xea/x92/xaf", "YI RADICAL VUR");
+-   ("/xea/x92/xb0", "YI RADICAL SHY");
+-   ("/xea/x92/xb1", "YI RADICAL VEP");
+-   ("/xea/x92/xb2", "YI RADICAL ZA");
+-   ("/xea/x92/xb3", "YI RADICAL JO");
+-   ("/xea/x92/xb4", "YI RADICAL NZUP");
+-   ("/xea/x92/xb5", "YI RADICAL JJY");
+-   ("/xea/x92/xb6", "YI RADICAL GOT");
+-   ("/xea/x92/xb7", "YI RADICAL JJIE");
+-   ("/xea/x92/xb8", "YI RADICAL WO");
+-   ("/xea/x92/xb9", "YI RADICAL DU");
+-   ("/xea/x92/xba", "YI RADICAL SHUR");
+-   ("/xea/x92/xbb", "YI RADICAL LIE");
+-   ("/xea/x92/xbc", "YI RADICAL CY");
+-   ("/xea/x92/xbd", "YI RADICAL CUOP");
+-   ("/xea/x92/xbe", "YI RADICAL CIP");
+-   ("/xea/x92/xbf", "YI RADICAL HXOP");
+-   ("/xea/x93/x80", "YI RADICAL SHAT");
+-   ("/xea/x93/x81", "YI RADICAL ZUR");
+-   ("/xea/x93/x82", "YI RADICAL SHOP");
+-   ("/xea/x93/x83", "YI RADICAL CHE");
+-   ("/xea/x93/x84", "YI RADICAL ZZIET");
+-   ("/xea/x93/x85", "YI RADICAL NBIE");
+-   ("/xea/x93/x86", "YI RADICAL KE");
+-   ("/xea/x94/x80", "VAI SYLLABLE EE");
+-   ("/xea/x94/x81", "VAI SYLLABLE EEN");
+-   ("/xea/x94/x82", "VAI SYLLABLE HEE");
+-   ("/xea/x94/x83", "VAI SYLLABLE WEE");
+-   ("/xea/x94/x84", "VAI SYLLABLE WEEN");
+-   ("/xea/x94/x85", "VAI SYLLABLE PEE");
+-   ("/xea/x94/x86", "VAI SYLLABLE BHEE");
+-   ("/xea/x94/x87", "VAI SYLLABLE BEE");
+-   ("/xea/x94/x88", "VAI SYLLABLE MBEE");
+-   ("/xea/x94/x89", "VAI SYLLABLE KPEE");
+-   ("/xea/x94/x8a", "VAI SYLLABLE MGBEE");
+-   ("/xea/x94/x8b", "VAI SYLLABLE GBEE");
+-   ("/xea/x94/x8c", "VAI SYLLABLE FEE");
+-   ("/xea/x94/x8d", "VAI SYLLABLE VEE");
+-   ("/xea/x94/x8e", "VAI SYLLABLE TEE");
+-   ("/xea/x94/x8f", "VAI SYLLABLE THEE");
+-   ("/xea/x94/x90", "VAI SYLLABLE DHEE");
+-   ("/xea/x94/x91", "VAI SYLLABLE DHHEE");
+-   ("/xea/x94/x92", "VAI SYLLABLE LEE");
+-   ("/xea/x94/x93", "VAI SYLLABLE REE");
+-   ("/xea/x94/x94", "VAI SYLLABLE DEE");
+-   ("/xea/x94/x95", "VAI SYLLABLE NDEE");
+-   ("/xea/x94/x96", "VAI SYLLABLE SEE");
+-   ("/xea/x94/x97", "VAI SYLLABLE SHEE");
+-   ("/xea/x94/x98", "VAI SYLLABLE ZEE");
+-   ("/xea/x94/x99", "VAI SYLLABLE ZHEE");
+-   ("/xea/x94/x9a", "VAI SYLLABLE CEE");
+-   ("/xea/x94/x9b", "VAI SYLLABLE JEE");
+-   ("/xea/x94/x9c", "VAI SYLLABLE NJEE");
+-   ("/xea/x94/x9d", "VAI SYLLABLE YEE");
+-   ("/xea/x94/x9e", "VAI SYLLABLE KEE");
+-   ("/xea/x94/x9f", "VAI SYLLABLE NGGEE");
+-   ("/xea/x94/xa0", "VAI SYLLABLE GEE");
+-   ("/xea/x94/xa1", "VAI SYLLABLE MEE");
+-   ("/xea/x94/xa2", "VAI SYLLABLE NEE");
+-   ("/xea/x94/xa3", "VAI SYLLABLE NYEE");
+-   ("/xea/x94/xa4", "VAI SYLLABLE I");
+-   ("/xea/x94/xa5", "VAI SYLLABLE IN");
+-   ("/xea/x94/xa6", "VAI SYLLABLE HI");
+-   ("/xea/x94/xa7", "VAI SYLLABLE HIN");
+-   ("/xea/x94/xa8", "VAI SYLLABLE WI");
+-   ("/xea/x94/xa9", "VAI SYLLABLE WIN");
+-   ("/xea/x94/xaa", "VAI SYLLABLE PI");
+-   ("/xea/x94/xab", "VAI SYLLABLE BHI");
+-   ("/xea/x94/xac", "VAI SYLLABLE BI");
+-   ("/xea/x94/xad", "VAI SYLLABLE MBI");
+-   ("/xea/x94/xae", "VAI SYLLABLE KPI");
+-   ("/xea/x94/xaf", "VAI SYLLABLE MGBI");
+-   ("/xea/x94/xb0", "VAI SYLLABLE GBI");
+-   ("/xea/x94/xb1", "VAI SYLLABLE FI");
+-   ("/xea/x94/xb2", "VAI SYLLABLE VI");
+-   ("/xea/x94/xb3", "VAI SYLLABLE TI");
+-   ("/xea/x94/xb4", "VAI SYLLABLE THI");
+-   ("/xea/x94/xb5", "VAI SYLLABLE DHI");
+-   ("/xea/x94/xb6", "VAI SYLLABLE DHHI");
+-   ("/xea/x94/xb7", "VAI SYLLABLE LI");
+-   ("/xea/x94/xb8", "VAI SYLLABLE RI");
+-   ("/xea/x94/xb9", "VAI SYLLABLE DI");
+-   ("/xea/x94/xba", "VAI SYLLABLE NDI");
+-   ("/xea/x94/xbb", "VAI SYLLABLE SI");
+-   ("/xea/x94/xbc", "VAI SYLLABLE SHI");
+-   ("/xea/x94/xbd", "VAI SYLLABLE ZI");
+-   ("/xea/x94/xbe", "VAI SYLLABLE ZHI");
+-   ("/xea/x94/xbf", "VAI SYLLABLE CI");
+-   ("/xea/x95/x80", "VAI SYLLABLE JI");
+-   ("/xea/x95/x81", "VAI SYLLABLE NJI");
+-   ("/xea/x95/x82", "VAI SYLLABLE YI");
+-   ("/xea/x95/x83", "VAI SYLLABLE KI");
+-   ("/xea/x95/x84", "VAI SYLLABLE NGGI");
+-   ("/xea/x95/x85", "VAI SYLLABLE GI");
+-   ("/xea/x95/x86", "VAI SYLLABLE MI");
+-   ("/xea/x95/x87", "VAI SYLLABLE NI");
+-   ("/xea/x95/x88", "VAI SYLLABLE NYI");
+-   ("/xea/x95/x89", "VAI SYLLABLE A");
+-   ("/xea/x95/x8a", "VAI SYLLABLE AN");
+-   ("/xea/x95/x8b", "VAI SYLLABLE NGAN");
+-   ("/xea/x95/x8c", "VAI SYLLABLE HA");
+-   ("/xea/x95/x8d", "VAI SYLLABLE HAN");
+-   ("/xea/x95/x8e", "VAI SYLLABLE WA");
+-   ("/xea/x95/x8f", "VAI SYLLABLE WAN");
+-   ("/xea/x95/x90", "VAI SYLLABLE PA");
+-   ("/xea/x95/x91", "VAI SYLLABLE BHA");
+-   ("/xea/x95/x92", "VAI SYLLABLE BA");
+-   ("/xea/x95/x93", "VAI SYLLABLE MBA");
+-   ("/xea/x95/x94", "VAI SYLLABLE KPA");
+-   ("/xea/x95/x95", "VAI SYLLABLE KPAN");
+-   ("/xea/x95/x96", "VAI SYLLABLE MGBA");
+-   ("/xea/x95/x97", "VAI SYLLABLE GBA");
+-   ("/xea/x95/x98", "VAI SYLLABLE FA");
+-   ("/xea/x95/x99", "VAI SYLLABLE VA");
+-   ("/xea/x95/x9a", "VAI SYLLABLE TA");
+-   ("/xea/x95/x9b", "VAI SYLLABLE THA");
+-   ("/xea/x95/x9c", "VAI SYLLABLE DHA");
+-   ("/xea/x95/x9d", "VAI SYLLABLE DHHA");
+-   ("/xea/x95/x9e", "VAI SYLLABLE LA");
+-   ("/xea/x95/x9f", "VAI SYLLABLE RA");
+-   ("/xea/x95/xa0", "VAI SYLLABLE DA");
+-   ("/xea/x95/xa1", "VAI SYLLABLE NDA");
+-   ("/xea/x95/xa2", "VAI SYLLABLE SA");
+-   ("/xea/x95/xa3", "VAI SYLLABLE SHA");
+-   ("/xea/x95/xa4", "VAI SYLLABLE ZA");
+-   ("/xea/x95/xa5", "VAI SYLLABLE ZHA");
+-   ("/xea/x95/xa6", "VAI SYLLABLE CA");
+-   ("/xea/x95/xa7", "VAI SYLLABLE JA");
+-   ("/xea/x95/xa8", "VAI SYLLABLE NJA");
+-   ("/xea/x95/xa9", "VAI SYLLABLE YA");
+-   ("/xea/x95/xaa", "VAI SYLLABLE KA");
+-   ("/xea/x95/xab", "VAI SYLLABLE KAN");
+-   ("/xea/x95/xac", "VAI SYLLABLE NGGA");
+-   ("/xea/x95/xad", "VAI SYLLABLE GA");
+-   ("/xea/x95/xae", "VAI SYLLABLE MA");
+-   ("/xea/x95/xaf", "VAI SYLLABLE NA");
+-   ("/xea/x95/xb0", "VAI SYLLABLE NYA");
+-   ("/xea/x95/xb1", "VAI SYLLABLE OO");
+-   ("/xea/x95/xb2", "VAI SYLLABLE OON");
+-   ("/xea/x95/xb3", "VAI SYLLABLE HOO");
+-   ("/xea/x95/xb4", "VAI SYLLABLE WOO");
+-   ("/xea/x95/xb5", "VAI SYLLABLE WOON");
+-   ("/xea/x95/xb6", "VAI SYLLABLE POO");
+-   ("/xea/x95/xb7", "VAI SYLLABLE BHOO");
+-   ("/xea/x95/xb8", "VAI SYLLABLE BOO");
+-   ("/xea/x95/xb9", "VAI SYLLABLE MBOO");
+-   ("/xea/x95/xba", "VAI SYLLABLE KPOO");
+-   ("/xea/x95/xbb", "VAI SYLLABLE MGBOO");
+-   ("/xea/x95/xbc", "VAI SYLLABLE GBOO");
+-   ("/xea/x95/xbd", "VAI SYLLABLE FOO");
+-   ("/xea/x95/xbe", "VAI SYLLABLE VOO");
+-   ("/xea/x95/xbf", "VAI SYLLABLE TOO");
+-   ("/xea/x96/x80", "VAI SYLLABLE THOO");
+-   ("/xea/x96/x81", "VAI SYLLABLE DHOO");
+-   ("/xea/x96/x82", "VAI SYLLABLE DHHOO");
+-   ("/xea/x96/x83", "VAI SYLLABLE LOO");
+-   ("/xea/x96/x84", "VAI SYLLABLE ROO");
+-   ("/xea/x96/x85", "VAI SYLLABLE DOO");
+-   ("/xea/x96/x86", "VAI SYLLABLE NDOO");
+-   ("/xea/x96/x87", "VAI SYLLABLE SOO");
+-   ("/xea/x96/x88", "VAI SYLLABLE SHOO");
+-   ("/xea/x96/x89", "VAI SYLLABLE ZOO");
+-   ("/xea/x96/x8a", "VAI SYLLABLE ZHOO");
+-   ("/xea/x96/x8b", "VAI SYLLABLE COO");
+-   ("/xea/x96/x8c", "VAI SYLLABLE JOO");
+-   ("/xea/x96/x8d", "VAI SYLLABLE NJOO");
+-   ("/xea/x96/x8e", "VAI SYLLABLE YOO");
+-   ("/xea/x96/x8f", "VAI SYLLABLE KOO");
+-   ("/xea/x96/x90", "VAI SYLLABLE NGGOO");
+-   ("/xea/x96/x91", "VAI SYLLABLE GOO");
+-   ("/xea/x96/x92", "VAI SYLLABLE MOO");
+-   ("/xea/x96/x93", "VAI SYLLABLE NOO");
+-   ("/xea/x96/x94", "VAI SYLLABLE NYOO");
+-   ("/xea/x96/x95", "VAI SYLLABLE U");
+-   ("/xea/x96/x96", "VAI SYLLABLE UN");
+-   ("/xea/x96/x97", "VAI SYLLABLE HU");
+-   ("/xea/x96/x98", "VAI SYLLABLE HUN");
+-   ("/xea/x96/x99", "VAI SYLLABLE WU");
+-   ("/xea/x96/x9a", "VAI SYLLABLE WUN");
+-   ("/xea/x96/x9b", "VAI SYLLABLE PU");
+-   ("/xea/x96/x9c", "VAI SYLLABLE BHU");
+-   ("/xea/x96/x9d", "VAI SYLLABLE BU");
+-   ("/xea/x96/x9e", "VAI SYLLABLE MBU");
+-   ("/xea/x96/x9f", "VAI SYLLABLE KPU");
+-   ("/xea/x96/xa0", "VAI SYLLABLE MGBU");
+-   ("/xea/x96/xa1", "VAI SYLLABLE GBU");
+-   ("/xea/x96/xa2", "VAI SYLLABLE FU");
+-   ("/xea/x96/xa3", "VAI SYLLABLE VU");
+-   ("/xea/x96/xa4", "VAI SYLLABLE TU");
+-   ("/xea/x96/xa5", "VAI SYLLABLE THU");
+-   ("/xea/x96/xa6", "VAI SYLLABLE DHU");
+-   ("/xea/x96/xa7", "VAI SYLLABLE DHHU");
+-   ("/xea/x96/xa8", "VAI SYLLABLE LU");
+-   ("/xea/x96/xa9", "VAI SYLLABLE RU");
+-   ("/xea/x96/xaa", "VAI SYLLABLE DU");
+-   ("/xea/x96/xab", "VAI SYLLABLE NDU");
+-   ("/xea/x96/xac", "VAI SYLLABLE SU");
+-   ("/xea/x96/xad", "VAI SYLLABLE SHU");
+-   ("/xea/x96/xae", "VAI SYLLABLE ZU");
+-   ("/xea/x96/xaf", "VAI SYLLABLE ZHU");
+-   ("/xea/x96/xb0", "VAI SYLLABLE CU");
+-   ("/xea/x96/xb1", "VAI SYLLABLE JU");
+-   ("/xea/x96/xb2", "VAI SYLLABLE NJU");
+-   ("/xea/x96/xb3", "VAI SYLLABLE YU");
+-   ("/xea/x96/xb4", "VAI SYLLABLE KU");
+-   ("/xea/x96/xb5", "VAI SYLLABLE NGGU");
+-   ("/xea/x96/xb6", "VAI SYLLABLE GU");
+-   ("/xea/x96/xb7", "VAI SYLLABLE MU");
+-   ("/xea/x96/xb8", "VAI SYLLABLE NU");
+-   ("/xea/x96/xb9", "VAI SYLLABLE NYU");
+-   ("/xea/x96/xba", "VAI SYLLABLE O");
+-   ("/xea/x96/xbb", "VAI SYLLABLE ON");
+-   ("/xea/x96/xbc", "VAI SYLLABLE NGON");
+-   ("/xea/x96/xbd", "VAI SYLLABLE HO");
+-   ("/xea/x96/xbe", "VAI SYLLABLE HON");
+-   ("/xea/x96/xbf", "VAI SYLLABLE WO");
+-   ("/xea/x97/x80", "VAI SYLLABLE WON");
+-   ("/xea/x97/x81", "VAI SYLLABLE PO");
+-   ("/xea/x97/x82", "VAI SYLLABLE BHO");
+-   ("/xea/x97/x83", "VAI SYLLABLE BO");
+-   ("/xea/x97/x84", "VAI SYLLABLE MBO");
+-   ("/xea/x97/x85", "VAI SYLLABLE KPO");
+-   ("/xea/x97/x86", "VAI SYLLABLE MGBO");
+-   ("/xea/x97/x87", "VAI SYLLABLE GBO");
+-   ("/xea/x97/x88", "VAI SYLLABLE GBON");
+-   ("/xea/x97/x89", "VAI SYLLABLE FO");
+-   ("/xea/x97/x8a", "VAI SYLLABLE VO");
+-   ("/xea/x97/x8b", "VAI SYLLABLE TO");
+-   ("/xea/x97/x8c", "VAI SYLLABLE THO");
+-   ("/xea/x97/x8d", "VAI SYLLABLE DHO");
+-   ("/xea/x97/x8e", "VAI SYLLABLE DHHO");
+-   ("/xea/x97/x8f", "VAI SYLLABLE LO");
+-   ("/xea/x97/x90", "VAI SYLLABLE RO");
+-   ("/xea/x97/x91", "VAI SYLLABLE DO");
+-   ("/xea/x97/x92", "VAI SYLLABLE NDO");
+-   ("/xea/x97/x93", "VAI SYLLABLE SO");
+-   ("/xea/x97/x94", "VAI SYLLABLE SHO");
+-   ("/xea/x97/x95", "VAI SYLLABLE ZO");
+-   ("/xea/x97/x96", "VAI SYLLABLE ZHO");
+-   ("/xea/x97/x97", "VAI SYLLABLE CO");
+-   ("/xea/x97/x98", "VAI SYLLABLE JO");
+-   ("/xea/x97/x99", "VAI SYLLABLE NJO");
+-   ("/xea/x97/x9a", "VAI SYLLABLE YO");
+-   ("/xea/x97/x9b", "VAI SYLLABLE KO");
+-   ("/xea/x97/x9c", "VAI SYLLABLE NGGO");
+-   ("/xea/x97/x9d", "VAI SYLLABLE GO");
+-   ("/xea/x97/x9e", "VAI SYLLABLE MO");
+-   ("/xea/x97/x9f", "VAI SYLLABLE NO");
+-   ("/xea/x97/xa0", "VAI SYLLABLE NYO");
+-   ("/xea/x97/xa1", "VAI SYLLABLE E");
+-   ("/xea/x97/xa2", "VAI SYLLABLE EN");
+-   ("/xea/x97/xa3", "VAI SYLLABLE NGEN");
+-   ("/xea/x97/xa4", "VAI SYLLABLE HE");
+-   ("/xea/x97/xa5", "VAI SYLLABLE HEN");
+-   ("/xea/x97/xa6", "VAI SYLLABLE WE");
+-   ("/xea/x97/xa7", "VAI SYLLABLE WEN");
+-   ("/xea/x97/xa8", "VAI SYLLABLE PE");
+-   ("/xea/x97/xa9", "VAI SYLLABLE BHE");
+-   ("/xea/x97/xaa", "VAI SYLLABLE BE");
+-   ("/xea/x97/xab", "VAI SYLLABLE MBE");
+-   ("/xea/x97/xac", "VAI SYLLABLE KPE");
+-   ("/xea/x97/xad", "VAI SYLLABLE KPEN");
+-   ("/xea/x97/xae", "VAI SYLLABLE MGBE");
+-   ("/xea/x97/xaf", "VAI SYLLABLE GBE");
+-   ("/xea/x97/xb0", "VAI SYLLABLE GBEN");
+-   ("/xea/x97/xb1", "VAI SYLLABLE FE");
+-   ("/xea/x97/xb2", "VAI SYLLABLE VE");
+-   ("/xea/x97/xb3", "VAI SYLLABLE TE");
+-   ("/xea/x97/xb4", "VAI SYLLABLE THE");
+-   ("/xea/x97/xb5", "VAI SYLLABLE DHE");
+-   ("/xea/x97/xb6", "VAI SYLLABLE DHHE");
+-   ("/xea/x97/xb7", "VAI SYLLABLE LE");
+-   ("/xea/x97/xb8", "VAI SYLLABLE RE");
+-   ("/xea/x97/xb9", "VAI SYLLABLE DE");
+-   ("/xea/x97/xba", "VAI SYLLABLE NDE");
+-   ("/xea/x97/xbb", "VAI SYLLABLE SE");
+-   ("/xea/x97/xbc", "VAI SYLLABLE SHE");
+-   ("/xea/x97/xbd", "VAI SYLLABLE ZE");
+-   ("/xea/x97/xbe", "VAI SYLLABLE ZHE");
+-   ("/xea/x97/xbf", "VAI SYLLABLE CE");
+-   ("/xea/x98/x80", "VAI SYLLABLE JE");
+-   ("/xea/x98/x81", "VAI SYLLABLE NJE");
+-   ("/xea/x98/x82", "VAI SYLLABLE YE");
+-   ("/xea/x98/x83", "VAI SYLLABLE KE");
+-   ("/xea/x98/x84", "VAI SYLLABLE NGGE");
+-   ("/xea/x98/x85", "VAI SYLLABLE NGGEN");
+-   ("/xea/x98/x86", "VAI SYLLABLE GE");
+-   ("/xea/x98/x87", "VAI SYLLABLE GEN");
+-   ("/xea/x98/x88", "VAI SYLLABLE ME");
+-   ("/xea/x98/x89", "VAI SYLLABLE NE");
+-   ("/xea/x98/x8a", "VAI SYLLABLE NYE");
+-   ("/xea/x98/x8b", "VAI SYLLABLE NG");
+-   ("/xea/x98/x8c", "VAI SYLLABLE LENGTHENER");
+-   ("/xea/x98/x8d", "VAI COMMA");
+-   ("/xea/x98/x8e", "VAI FULL STOP");
+-   ("/xea/x98/x8f", "VAI QUESTION MARK");
+-   ("/xea/x98/x90", "VAI SYLLABLE NDOLE FA");
+-   ("/xea/x98/x91", "VAI SYLLABLE NDOLE KA");
+-   ("/xea/x98/x92", "VAI SYLLABLE NDOLE SOO");
+-   ("/xea/x98/x93", "VAI SYMBOL FEENG");
+-   ("/xea/x98/x94", "VAI SYMBOL KEENG");
+-   ("/xea/x98/x95", "VAI SYMBOL TING");
+-   ("/xea/x98/x96", "VAI SYMBOL NII");
+-   ("/xea/x98/x97", "VAI SYMBOL BANG");
+-   ("/xea/x98/x98", "VAI SYMBOL FAA");
+-   ("/xea/x98/x99", "VAI SYMBOL TAA");
+-   ("/xea/x98/x9a", "VAI SYMBOL DANG");
+-   ("/xea/x98/x9b", "VAI SYMBOL DOONG");
+-   ("/xea/x98/x9c", "VAI SYMBOL KUNG");
+-   ("/xea/x98/x9d", "VAI SYMBOL TONG");
+-   ("/xea/x98/x9e", "VAI SYMBOL DO-O");
+-   ("/xea/x98/x9f", "VAI SYMBOL JONG");
+-   ("/xea/x98/xa0", "VAI DIGIT ZERO");
+-   ("/xea/x98/xa1", "VAI DIGIT ONE");
+-   ("/xea/x98/xa2", "VAI DIGIT TWO");
+-   ("/xea/x98/xa3", "VAI DIGIT THREE");
+-   ("/xea/x98/xa4", "VAI DIGIT FOUR");
+-   ("/xea/x98/xa5", "VAI DIGIT FIVE");
+-   ("/xea/x98/xa6", "VAI DIGIT SIX");
+-   ("/xea/x98/xa7", "VAI DIGIT SEVEN");
+-   ("/xea/x98/xa8", "VAI DIGIT EIGHT");
+-   ("/xea/x98/xa9", "VAI DIGIT NINE");
+-   ("/xea/x98/xaa", "VAI SYLLABLE NDOLE MA");
+-   ("/xea/x98/xab", "VAI SYLLABLE NDOLE DO");
+    ("/xea/x99/x80", "CYRILLIC CAPITAL LETTER ZEMLYA");
+    ("/xea/x99/x81", "CYRILLIC SMALL LETTER ZEMLYA");
+    ("/xea/x99/x82", "CYRILLIC CAPITAL LETTER DZELO");
+@@ -13037,16 +2339,6 @@
+    ("/xea/x99/xab", "CYRILLIC SMALL LETTER BINOCULAR O");
+    ("/xea/x99/xac", "CYRILLIC CAPITAL LETTER DOUBLE MONOCULAR O");
+    ("/xea/x99/xad", "CYRILLIC SMALL LETTER DOUBLE MONOCULAR O");
+-   ("/xea/x99/xae", "CYRILLIC LETTER MULTIOCULAR O");
+-   ("/xea/x99/xaf", "COMBINING CYRILLIC VZMET");
+-   ("/xea/x99/xb0", "COMBINING CYRILLIC TEN MILLIONS SIGN");
+-   ("/xea/x99/xb1", "COMBINING CYRILLIC HUNDRED MILLIONS SIGN");
+-   ("/xea/x99/xb2", "COMBINING CYRILLIC THOUSAND MILLIONS SIGN");
+-   ("/xea/x99/xb3", "SLAVONIC ASTERISK");
+-   ("/xea/x99/xbc", "COMBINING CYRILLIC KAVYKA");
+-   ("/xea/x99/xbd", "COMBINING CYRILLIC PAYEROK");
+-   ("/xea/x99/xbe", "CYRILLIC KAVYKA");
+-   ("/xea/x99/xbf", "CYRILLIC PAYEROK");
+    ("/xea/x9a/x80", "CYRILLIC CAPITAL LETTER DWE");
+    ("/xea/x9a/x81", "CYRILLIC SMALL LETTER DWE");
+    ("/xea/x9a/x82", "CYRILLIC CAPITAL LETTER DZWE");
+@@ -13071,40 +2363,6 @@
+    ("/xea/x9a/x95", "CYRILLIC SMALL LETTER HWE");
+    ("/xea/x9a/x96", "CYRILLIC CAPITAL LETTER SHWE");
+    ("/xea/x9a/x97", "CYRILLIC SMALL LETTER SHWE");
+-   ("/xea/x9c/x80", "MODIFIER LETTER CHINESE TONE YIN PING");
+-   ("/xea/x9c/x81", "MODIFIER LETTER CHINESE TONE YANG PING");
+-   ("/xea/x9c/x82", "MODIFIER LETTER CHINESE TONE YIN SHANG");
+-   ("/xea/x9c/x83", "MODIFIER LETTER CHINESE TONE YANG SHANG");
+-   ("/xea/x9c/x84", "MODIFIER LETTER CHINESE TONE YIN QU");
+-   ("/xea/x9c/x85", "MODIFIER LETTER CHINESE TONE YANG QU");
+-   ("/xea/x9c/x86", "MODIFIER LETTER CHINESE TONE YIN RU");
+-   ("/xea/x9c/x87", "MODIFIER LETTER CHINESE TONE YANG RU");
+-   ("/xea/x9c/x88", "MODIFIER LETTER EXTRA-HIGH DOTTED TONE BAR");
+-   ("/xea/x9c/x89", "MODIFIER LETTER HIGH DOTTED TONE BAR");
+-   ("/xea/x9c/x8a", "MODIFIER LETTER MID DOTTED TONE BAR");
+-   ("/xea/x9c/x8b", "MODIFIER LETTER LOW DOTTED TONE BAR");
+-   ("/xea/x9c/x8c", "MODIFIER LETTER EXTRA-LOW DOTTED TONE BAR");
+-   ("/xea/x9c/x8d", "MODIFIER LETTER EXTRA-HIGH DOTTED LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x8e", "MODIFIER LETTER HIGH DOTTED LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x8f", "MODIFIER LETTER MID DOTTED LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x90", "MODIFIER LETTER LOW DOTTED LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x91", "MODIFIER LETTER EXTRA-LOW DOTTED LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x92", "MODIFIER LETTER EXTRA-HIGH LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x93", "MODIFIER LETTER HIGH LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x94", "MODIFIER LETTER MID LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x95", "MODIFIER LETTER LOW LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x96", "MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR");
+-   ("/xea/x9c/x97", "MODIFIER LETTER DOT VERTICAL BAR");
+-   ("/xea/x9c/x98", "MODIFIER LETTER DOT SLASH");
+-   ("/xea/x9c/x99", "MODIFIER LETTER DOT HORIZONTAL BAR");
+-   ("/xea/x9c/x9a", "MODIFIER LETTER LOWER RIGHT CORNER ANGLE");
+-   ("/xea/x9c/x9b", "MODIFIER LETTER RAISED UP ARROW");
+-   ("/xea/x9c/x9c", "MODIFIER LETTER RAISED DOWN ARROW");
+-   ("/xea/x9c/x9d", "MODIFIER LETTER RAISED EXCLAMATION MARK");
+-   ("/xea/x9c/x9e", "MODIFIER LETTER RAISED INVERTED EXCLAMATION MARK");
+-   ("/xea/x9c/x9f", "MODIFIER LETTER LOW INVERTED EXCLAMATION MARK");
+-   ("/xea/x9c/xa0", "MODIFIER LETTER STRESS AND HIGH TONE");
+-   ("/xea/x9c/xa1", "MODIFIER LETTER STRESS AND LOW TONE");
+    ("/xea/x9c/xa2", "LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF");
+    ("/xea/x9c/xa3", "LATIN SMALL LETTER EGYPTOLOGICAL ALEF");
+    ("/xea/x9c/xa4", "LATIN CAPITAL LETTER EGYPTOLOGICAL AIN");
+@@ -13183,7 +2441,6 @@
+    ("/xea/x9d/xad", "LATIN SMALL LETTER IS");
+    ("/xea/x9d/xae", "LATIN CAPITAL LETTER CON");
+    ("/xea/x9d/xaf", "LATIN SMALL LETTER CON");
+-   ("/xea/x9d/xb0", "MODIFIER LETTER US");
+    ("/xea/x9d/xb1", "LATIN SMALL LETTER DUM");
+    ("/xea/x9d/xb2", "LATIN SMALL LETTER LUM");
+    ("/xea/x9d/xb3", "LATIN SMALL LETTER MUM");
+@@ -13207,12110 +2464,9 @@
+    ("/xea/x9e/x85", "LATIN SMALL LETTER INSULAR S");
+    ("/xea/x9e/x86", "LATIN CAPITAL LETTER INSULAR T");
+    ("/xea/x9e/x87", "LATIN SMALL LETTER INSULAR T");
+-   ("/xea/x9e/x88", "MODIFIER LETTER LOW CIRCUMFLEX ACCENT");
+-   ("/xea/x9e/x89", "MODIFIER LETTER COLON");
+-   ("/xea/x9e/x8a", "MODIFIER LETTER SHORT EQUALS SIGN");
+    ("/xea/x9e/x8b", "LATIN CAPITAL LETTER SALTILLO");
+    ("/xea/x9e/x8c", "LATIN SMALL LETTER SALTILLO");
+-   ("/xea/x9f/xbb", "LATIN EPIGRAPHIC LETTER REVERSED F");
+-   ("/xea/x9f/xbc", "LATIN EPIGRAPHIC LETTER REVERSED P");
+-   ("/xea/x9f/xbd", "LATIN EPIGRAPHIC LETTER INVERTED M");
+-   ("/xea/x9f/xbe", "LATIN EPIGRAPHIC LETTER I LONGA");
+-   ("/xea/x9f/xbf", "LATIN EPIGRAPHIC LETTER ARCHAIC M");
+-   ("/xea/xa0/x80", "SYLOTI NAGRI LETTER A");
+-   ("/xea/xa0/x81", "SYLOTI NAGRI LETTER I");
+-   ("/xea/xa0/x82", "SYLOTI NAGRI SIGN DVISVARA");
+-   ("/xea/xa0/x83", "SYLOTI NAGRI LETTER U");
+-   ("/xea/xa0/x84", "SYLOTI NAGRI LETTER E");
+-   ("/xea/xa0/x85", "SYLOTI NAGRI LETTER O");
+-   ("/xea/xa0/x86", "SYLOTI NAGRI SIGN HASANTA");
+-   ("/xea/xa0/x87", "SYLOTI NAGRI LETTER KO");
+-   ("/xea/xa0/x88", "SYLOTI NAGRI LETTER KHO");
+-   ("/xea/xa0/x89", "SYLOTI NAGRI LETTER GO");
+-   ("/xea/xa0/x8a", "SYLOTI NAGRI LETTER GHO");
+-   ("/xea/xa0/x8b", "SYLOTI NAGRI SIGN ANUSVARA");
+-   ("/xea/xa0/x8c", "SYLOTI NAGRI LETTER CO");
+-   ("/xea/xa0/x8d", "SYLOTI NAGRI LETTER CHO");
+-   ("/xea/xa0/x8e", "SYLOTI NAGRI LETTER JO");
+-   ("/xea/xa0/x8f", "SYLOTI NAGRI LETTER JHO");
+-   ("/xea/xa0/x90", "SYLOTI NAGRI LETTER TTO");
+-   ("/xea/xa0/x91", "SYLOTI NAGRI LETTER TTHO");
+-   ("/xea/xa0/x92", "SYLOTI NAGRI LETTER DDO");
+-   ("/xea/xa0/x93", "SYLOTI NAGRI LETTER DDHO");
+-   ("/xea/xa0/x94", "SYLOTI NAGRI LETTER TO");
+-   ("/xea/xa0/x95", "SYLOTI NAGRI LETTER THO");
+-   ("/xea/xa0/x96", "SYLOTI NAGRI LETTER DO");
+-   ("/xea/xa0/x97", "SYLOTI NAGRI LETTER DHO");
+-   ("/xea/xa0/x98", "SYLOTI NAGRI LETTER NO");
+-   ("/xea/xa0/x99", "SYLOTI NAGRI LETTER PO");
+-   ("/xea/xa0/x9a", "SYLOTI NAGRI LETTER PHO");
+-   ("/xea/xa0/x9b", "SYLOTI NAGRI LETTER BO");
+-   ("/xea/xa0/x9c", "SYLOTI NAGRI LETTER BHO");
+-   ("/xea/xa0/x9d", "SYLOTI NAGRI LETTER MO");
+-   ("/xea/xa0/x9e", "SYLOTI NAGRI LETTER RO");
+-   ("/xea/xa0/x9f", "SYLOTI NAGRI LETTER LO");
+-   ("/xea/xa0/xa0", "SYLOTI NAGRI LETTER RRO");
+-   ("/xea/xa0/xa1", "SYLOTI NAGRI LETTER SO");
+-   ("/xea/xa0/xa2", "SYLOTI NAGRI LETTER HO");
+-   ("/xea/xa0/xa3", "SYLOTI NAGRI VOWEL SIGN A");
+-   ("/xea/xa0/xa4", "SYLOTI NAGRI VOWEL SIGN I");
+-   ("/xea/xa0/xa5", "SYLOTI NAGRI VOWEL SIGN U");
+-   ("/xea/xa0/xa6", "SYLOTI NAGRI VOWEL SIGN E");
+-   ("/xea/xa0/xa7", "SYLOTI NAGRI VOWEL SIGN OO");
+-   ("/xea/xa0/xa8", "SYLOTI NAGRI POETRY MARK-1");
+-   ("/xea/xa0/xa9", "SYLOTI NAGRI POETRY MARK-2");
+-   ("/xea/xa0/xaa", "SYLOTI NAGRI POETRY MARK-3");
+-   ("/xea/xa0/xab", "SYLOTI NAGRI POETRY MARK-4");
+-   ("/xea/xa1/x80", "PHAGS-PA LETTER KA");
+-   ("/xea/xa1/x81", "PHAGS-PA LETTER KHA");
+-   ("/xea/xa1/x82", "PHAGS-PA LETTER GA");
+-   ("/xea/xa1/x83", "PHAGS-PA LETTER NGA");
+-   ("/xea/xa1/x84", "PHAGS-PA LETTER CA");
+-   ("/xea/xa1/x85", "PHAGS-PA LETTER CHA");
+-   ("/xea/xa1/x86", "PHAGS-PA LETTER JA");
+-   ("/xea/xa1/x87", "PHAGS-PA LETTER NYA");
+-   ("/xea/xa1/x88", "PHAGS-PA LETTER TA");
+-   ("/xea/xa1/x89", "PHAGS-PA LETTER THA");
+-   ("/xea/xa1/x8a", "PHAGS-PA LETTER DA");
+-   ("/xea/xa1/x8b", "PHAGS-PA LETTER NA");
+-   ("/xea/xa1/x8c", "PHAGS-PA LETTER PA");
+-   ("/xea/xa1/x8d", "PHAGS-PA LETTER PHA");
+-   ("/xea/xa1/x8e", "PHAGS-PA LETTER BA");
+-   ("/xea/xa1/x8f", "PHAGS-PA LETTER MA");
+-   ("/xea/xa1/x90", "PHAGS-PA LETTER TSA");
+-   ("/xea/xa1/x91", "PHAGS-PA LETTER TSHA");
+-   ("/xea/xa1/x92", "PHAGS-PA LETTER DZA");
+-   ("/xea/xa1/x93", "PHAGS-PA LETTER WA");
+-   ("/xea/xa1/x94", "PHAGS-PA LETTER ZHA");
+-   ("/xea/xa1/x95", "PHAGS-PA LETTER ZA");
+    ("/xea/xa1/x96", "PHAGS-PA LETTER SMALL A");
+-   ("/xea/xa1/x97", "PHAGS-PA LETTER YA");
+-   ("/xea/xa1/x98", "PHAGS-PA LETTER RA");
+-   ("/xea/xa1/x99", "PHAGS-PA LETTER LA");
+-   ("/xea/xa1/x9a", "PHAGS-PA LETTER SHA");
+-   ("/xea/xa1/x9b", "PHAGS-PA LETTER SA");
+-   ("/xea/xa1/x9c", "PHAGS-PA LETTER HA");
+-   ("/xea/xa1/x9d", "PHAGS-PA LETTER A");
+-   ("/xea/xa1/x9e", "PHAGS-PA LETTER I");
+-   ("/xea/xa1/x9f", "PHAGS-PA LETTER U");
+-   ("/xea/xa1/xa0", "PHAGS-PA LETTER E");
+-   ("/xea/xa1/xa1", "PHAGS-PA LETTER O");
+-   ("/xea/xa1/xa2", "PHAGS-PA LETTER QA");
+-   ("/xea/xa1/xa3", "PHAGS-PA LETTER XA");
+-   ("/xea/xa1/xa4", "PHAGS-PA LETTER FA");
+-   ("/xea/xa1/xa5", "PHAGS-PA LETTER GGA");
+-   ("/xea/xa1/xa6", "PHAGS-PA LETTER EE");
+-   ("/xea/xa1/xa7", "PHAGS-PA SUBJOINED LETTER WA");
+-   ("/xea/xa1/xa8", "PHAGS-PA SUBJOINED LETTER YA");
+-   ("/xea/xa1/xa9", "PHAGS-PA LETTER TTA");
+-   ("/xea/xa1/xaa", "PHAGS-PA LETTER TTHA");
+-   ("/xea/xa1/xab", "PHAGS-PA LETTER DDA");
+-   ("/xea/xa1/xac", "PHAGS-PA LETTER NNA");
+-   ("/xea/xa1/xad", "PHAGS-PA LETTER ALTERNATE YA");
+-   ("/xea/xa1/xae", "PHAGS-PA LETTER VOICELESS SHA");
+-   ("/xea/xa1/xaf", "PHAGS-PA LETTER VOICED HA");
+-   ("/xea/xa1/xb0", "PHAGS-PA LETTER ASPIRATED FA");
+-   ("/xea/xa1/xb1", "PHAGS-PA SUBJOINED LETTER RA");
+-   ("/xea/xa1/xb2", "PHAGS-PA SUPERFIXED LETTER RA");
+-   ("/xea/xa1/xb3", "PHAGS-PA LETTER CANDRABINDU");
+-   ("/xea/xa1/xb4", "PHAGS-PA SINGLE HEAD MARK");
+-   ("/xea/xa1/xb5", "PHAGS-PA DOUBLE HEAD MARK");
+-   ("/xea/xa1/xb6", "PHAGS-PA MARK SHAD");
+-   ("/xea/xa1/xb7", "PHAGS-PA MARK DOUBLE SHAD");
+-   ("/xea/xa2/x80", "SAURASHTRA SIGN ANUSVARA");
+-   ("/xea/xa2/x81", "SAURASHTRA SIGN VISARGA");
+-   ("/xea/xa2/x82", "SAURASHTRA LETTER A");
+-   ("/xea/xa2/x83", "SAURASHTRA LETTER AA");
+-   ("/xea/xa2/x84", "SAURASHTRA LETTER I");
+-   ("/xea/xa2/x85", "SAURASHTRA LETTER II");
+-   ("/xea/xa2/x86", "SAURASHTRA LETTER U");
+-   ("/xea/xa2/x87", "SAURASHTRA LETTER UU");
+-   ("/xea/xa2/x88", "SAURASHTRA LETTER VOCALIC R");
+-   ("/xea/xa2/x89", "SAURASHTRA LETTER VOCALIC RR");
+-   ("/xea/xa2/x8a", "SAURASHTRA LETTER VOCALIC L");
+-   ("/xea/xa2/x8b", "SAURASHTRA LETTER VOCALIC LL");
+-   ("/xea/xa2/x8c", "SAURASHTRA LETTER E");
+-   ("/xea/xa2/x8d", "SAURASHTRA LETTER EE");
+-   ("/xea/xa2/x8e", "SAURASHTRA LETTER AI");
+-   ("/xea/xa2/x8f", "SAURASHTRA LETTER O");
+-   ("/xea/xa2/x90", "SAURASHTRA LETTER OO");
+-   ("/xea/xa2/x91", "SAURASHTRA LETTER AU");
+-   ("/xea/xa2/x92", "SAURASHTRA LETTER KA");
+-   ("/xea/xa2/x93", "SAURASHTRA LETTER KHA");
+-   ("/xea/xa2/x94", "SAURASHTRA LETTER GA");
+-   ("/xea/xa2/x95", "SAURASHTRA LETTER GHA");
+-   ("/xea/xa2/x96", "SAURASHTRA LETTER NGA");
+-   ("/xea/xa2/x97", "SAURASHTRA LETTER CA");
+-   ("/xea/xa2/x98", "SAURASHTRA LETTER CHA");
+-   ("/xea/xa2/x99", "SAURASHTRA LETTER JA");
+-   ("/xea/xa2/x9a", "SAURASHTRA LETTER JHA");
+-   ("/xea/xa2/x9b", "SAURASHTRA LETTER NYA");
+-   ("/xea/xa2/x9c", "SAURASHTRA LETTER TTA");
+-   ("/xea/xa2/x9d", "SAURASHTRA LETTER TTHA");
+-   ("/xea/xa2/x9e", "SAURASHTRA LETTER DDA");
+-   ("/xea/xa2/x9f", "SAURASHTRA LETTER DDHA");
+-   ("/xea/xa2/xa0", "SAURASHTRA LETTER NNA");
+-   ("/xea/xa2/xa1", "SAURASHTRA LETTER TA");
+-   ("/xea/xa2/xa2", "SAURASHTRA LETTER THA");
+-   ("/xea/xa2/xa3", "SAURASHTRA LETTER DA");
+-   ("/xea/xa2/xa4", "SAURASHTRA LETTER DHA");
+-   ("/xea/xa2/xa5", "SAURASHTRA LETTER NA");
+-   ("/xea/xa2/xa6", "SAURASHTRA LETTER PA");
+-   ("/xea/xa2/xa7", "SAURASHTRA LETTER PHA");
+-   ("/xea/xa2/xa8", "SAURASHTRA LETTER BA");
+-   ("/xea/xa2/xa9", "SAURASHTRA LETTER BHA");
+-   ("/xea/xa2/xaa", "SAURASHTRA LETTER MA");
+-   ("/xea/xa2/xab", "SAURASHTRA LETTER YA");
+-   ("/xea/xa2/xac", "SAURASHTRA LETTER RA");
+-   ("/xea/xa2/xad", "SAURASHTRA LETTER LA");
+-   ("/xea/xa2/xae", "SAURASHTRA LETTER VA");
+-   ("/xea/xa2/xaf", "SAURASHTRA LETTER SHA");
+-   ("/xea/xa2/xb0", "SAURASHTRA LETTER SSA");
+-   ("/xea/xa2/xb1", "SAURASHTRA LETTER SA");
+-   ("/xea/xa2/xb2", "SAURASHTRA LETTER HA");
+-   ("/xea/xa2/xb3", "SAURASHTRA LETTER LLA");
+-   ("/xea/xa2/xb4", "SAURASHTRA CONSONANT SIGN HAARU");
+-   ("/xea/xa2/xb5", "SAURASHTRA VOWEL SIGN AA");
+-   ("/xea/xa2/xb6", "SAURASHTRA VOWEL SIGN I");
+-   ("/xea/xa2/xb7", "SAURASHTRA VOWEL SIGN II");
+-   ("/xea/xa2/xb8", "SAURASHTRA VOWEL SIGN U");
+-   ("/xea/xa2/xb9", "SAURASHTRA VOWEL SIGN UU");
+-   ("/xea/xa2/xba", "SAURASHTRA VOWEL SIGN VOCALIC R");
+-   ("/xea/xa2/xbb", "SAURASHTRA VOWEL SIGN VOCALIC RR");
+-   ("/xea/xa2/xbc", "SAURASHTRA VOWEL SIGN VOCALIC L");
+-   ("/xea/xa2/xbd", "SAURASHTRA VOWEL SIGN VOCALIC LL");
+-   ("/xea/xa2/xbe", "SAURASHTRA VOWEL SIGN E");
+-   ("/xea/xa2/xbf", "SAURASHTRA VOWEL SIGN EE");
+-   ("/xea/xa3/x80", "SAURASHTRA VOWEL SIGN AI");
+-   ("/xea/xa3/x81", "SAURASHTRA VOWEL SIGN O");
+-   ("/xea/xa3/x82", "SAURASHTRA VOWEL SIGN OO");
+-   ("/xea/xa3/x83", "SAURASHTRA VOWEL SIGN AU");
+-   ("/xea/xa3/x84", "SAURASHTRA SIGN VIRAMA");
+-   ("/xea/xa3/x8e", "SAURASHTRA DANDA");
+-   ("/xea/xa3/x8f", "SAURASHTRA DOUBLE DANDA");
+-   ("/xea/xa3/x90", "SAURASHTRA DIGIT ZERO");
+-   ("/xea/xa3/x91", "SAURASHTRA DIGIT ONE");
+-   ("/xea/xa3/x92", "SAURASHTRA DIGIT TWO");
+-   ("/xea/xa3/x93", "SAURASHTRA DIGIT THREE");
+-   ("/xea/xa3/x94", "SAURASHTRA DIGIT FOUR");
+-   ("/xea/xa3/x95", "SAURASHTRA DIGIT FIVE");
+-   ("/xea/xa3/x96", "SAURASHTRA DIGIT SIX");
+-   ("/xea/xa3/x97", "SAURASHTRA DIGIT SEVEN");
+-   ("/xea/xa3/x98", "SAURASHTRA DIGIT EIGHT");
+-   ("/xea/xa3/x99", "SAURASHTRA DIGIT NINE");
+-   ("/xea/xa4/x80", "KAYAH LI DIGIT ZERO");
+-   ("/xea/xa4/x81", "KAYAH LI DIGIT ONE");
+-   ("/xea/xa4/x82", "KAYAH LI DIGIT TWO");
+-   ("/xea/xa4/x83", "KAYAH LI DIGIT THREE");
+-   ("/xea/xa4/x84", "KAYAH LI DIGIT FOUR");
+-   ("/xea/xa4/x85", "KAYAH LI DIGIT FIVE");
+-   ("/xea/xa4/x86", "KAYAH LI DIGIT SIX");
+-   ("/xea/xa4/x87", "KAYAH LI DIGIT SEVEN");
+-   ("/xea/xa4/x88", "KAYAH LI DIGIT EIGHT");
+-   ("/xea/xa4/x89", "KAYAH LI DIGIT NINE");
+-   ("/xea/xa4/x8a", "KAYAH LI LETTER KA");
+-   ("/xea/xa4/x8b", "KAYAH LI LETTER KHA");
+-   ("/xea/xa4/x8c", "KAYAH LI LETTER GA");
+-   ("/xea/xa4/x8d", "KAYAH LI LETTER NGA");
+-   ("/xea/xa4/x8e", "KAYAH LI LETTER SA");
+-   ("/xea/xa4/x8f", "KAYAH LI LETTER SHA");
+-   ("/xea/xa4/x90", "KAYAH LI LETTER ZA");
+-   ("/xea/xa4/x91", "KAYAH LI LETTER NYA");
+-   ("/xea/xa4/x92", "KAYAH LI LETTER TA");
+-   ("/xea/xa4/x93", "KAYAH LI LETTER HTA");
+-   ("/xea/xa4/x94", "KAYAH LI LETTER NA");
+-   ("/xea/xa4/x95", "KAYAH LI LETTER PA");
+-   ("/xea/xa4/x96", "KAYAH LI LETTER PHA");
+-   ("/xea/xa4/x97", "KAYAH LI LETTER MA");
+-   ("/xea/xa4/x98", "KAYAH LI LETTER DA");
+-   ("/xea/xa4/x99", "KAYAH LI LETTER BA");
+-   ("/xea/xa4/x9a", "KAYAH LI LETTER RA");
+-   ("/xea/xa4/x9b", "KAYAH LI LETTER YA");
+-   ("/xea/xa4/x9c", "KAYAH LI LETTER LA");
+-   ("/xea/xa4/x9d", "KAYAH LI LETTER WA");
+-   ("/xea/xa4/x9e", "KAYAH LI LETTER THA");
+-   ("/xea/xa4/x9f", "KAYAH LI LETTER HA");
+-   ("/xea/xa4/xa0", "KAYAH LI LETTER VA");
+-   ("/xea/xa4/xa1", "KAYAH LI LETTER CA");
+-   ("/xea/xa4/xa2", "KAYAH LI LETTER A");
+-   ("/xea/xa4/xa3", "KAYAH LI LETTER OE");
+-   ("/xea/xa4/xa4", "KAYAH LI LETTER I");
+-   ("/xea/xa4/xa5", "KAYAH LI LETTER OO");
+-   ("/xea/xa4/xa6", "KAYAH LI VOWEL UE");
+-   ("/xea/xa4/xa7", "KAYAH LI VOWEL E");
+-   ("/xea/xa4/xa8", "KAYAH LI VOWEL U");
+-   ("/xea/xa4/xa9", "KAYAH LI VOWEL EE");
+-   ("/xea/xa4/xaa", "KAYAH LI VOWEL O");
+-   ("/xea/xa4/xab", "KAYAH LI TONE PLOPHU");
+-   ("/xea/xa4/xac", "KAYAH LI TONE CALYA");
+-   ("/xea/xa4/xad", "KAYAH LI TONE CALYA PLOPHU");
+-   ("/xea/xa4/xae", "KAYAH LI SIGN CWI");
+-   ("/xea/xa4/xaf", "KAYAH LI SIGN SHYA");
+-   ("/xea/xa4/xb0", "REJANG LETTER KA");
+-   ("/xea/xa4/xb1", "REJANG LETTER GA");
+-   ("/xea/xa4/xb2", "REJANG LETTER NGA");
+-   ("/xea/xa4/xb3", "REJANG LETTER TA");
+-   ("/xea/xa4/xb4", "REJANG LETTER DA");
+-   ("/xea/xa4/xb5", "REJANG LETTER NA");
+-   ("/xea/xa4/xb6", "REJANG LETTER PA");
+-   ("/xea/xa4/xb7", "REJANG LETTER BA");
+-   ("/xea/xa4/xb8", "REJANG LETTER MA");
+-   ("/xea/xa4/xb9", "REJANG LETTER CA");
+-   ("/xea/xa4/xba", "REJANG LETTER JA");
+-   ("/xea/xa4/xbb", "REJANG LETTER NYA");
+-   ("/xea/xa4/xbc", "REJANG LETTER SA");
+-   ("/xea/xa4/xbd", "REJANG LETTER RA");
+-   ("/xea/xa4/xbe", "REJANG LETTER LA");
+-   ("/xea/xa4/xbf", "REJANG LETTER YA");
+-   ("/xea/xa5/x80", "REJANG LETTER WA");
+-   ("/xea/xa5/x81", "REJANG LETTER HA");
+-   ("/xea/xa5/x82", "REJANG LETTER MBA");
+-   ("/xea/xa5/x83", "REJANG LETTER NGGA");
+-   ("/xea/xa5/x84", "REJANG LETTER NDA");
+-   ("/xea/xa5/x85", "REJANG LETTER NYJA");
+-   ("/xea/xa5/x86", "REJANG LETTER A");
+-   ("/xea/xa5/x87", "REJANG VOWEL SIGN I");
+-   ("/xea/xa5/x88", "REJANG VOWEL SIGN U");
+-   ("/xea/xa5/x89", "REJANG VOWEL SIGN E");
+-   ("/xea/xa5/x8a", "REJANG VOWEL SIGN AI");
+-   ("/xea/xa5/x8b", "REJANG VOWEL SIGN O");
+-   ("/xea/xa5/x8c", "REJANG VOWEL SIGN AU");
+-   ("/xea/xa5/x8d", "REJANG VOWEL SIGN EU");
+-   ("/xea/xa5/x8e", "REJANG VOWEL SIGN EA");
+-   ("/xea/xa5/x8f", "REJANG CONSONANT SIGN NG");
+-   ("/xea/xa5/x90", "REJANG CONSONANT SIGN N");
+-   ("/xea/xa5/x91", "REJANG CONSONANT SIGN R");
+-   ("/xea/xa5/x92", "REJANG CONSONANT SIGN H");
+-   ("/xea/xa5/x93", "REJANG VIRAMA");
+-   ("/xea/xa5/x9f", "REJANG SECTION MARK");
+-   ("/xea/xa8/x80", "CHAM LETTER A");
+-   ("/xea/xa8/x81", "CHAM LETTER I");
+-   ("/xea/xa8/x82", "CHAM LETTER U");
+-   ("/xea/xa8/x83", "CHAM LETTER E");
+-   ("/xea/xa8/x84", "CHAM LETTER AI");
+-   ("/xea/xa8/x85", "CHAM LETTER O");
+-   ("/xea/xa8/x86", "CHAM LETTER KA");
+-   ("/xea/xa8/x87", "CHAM LETTER KHA");
+-   ("/xea/xa8/x88", "CHAM LETTER GA");
+-   ("/xea/xa8/x89", "CHAM LETTER GHA");
+-   ("/xea/xa8/x8a", "CHAM LETTER NGUE");
+-   ("/xea/xa8/x8b", "CHAM LETTER NGA");
+-   ("/xea/xa8/x8c", "CHAM LETTER CHA");
+-   ("/xea/xa8/x8d", "CHAM LETTER CHHA");
+-   ("/xea/xa8/x8e", "CHAM LETTER JA");
+-   ("/xea/xa8/x8f", "CHAM LETTER JHA");
+-   ("/xea/xa8/x90", "CHAM LETTER NHUE");
+-   ("/xea/xa8/x91", "CHAM LETTER NHA");
+-   ("/xea/xa8/x92", "CHAM LETTER NHJA");
+-   ("/xea/xa8/x93", "CHAM LETTER TA");
+-   ("/xea/xa8/x94", "CHAM LETTER THA");
+-   ("/xea/xa8/x95", "CHAM LETTER DA");
+-   ("/xea/xa8/x96", "CHAM LETTER DHA");
+-   ("/xea/xa8/x97", "CHAM LETTER NUE");
+-   ("/xea/xa8/x98", "CHAM LETTER NA");
+-   ("/xea/xa8/x99", "CHAM LETTER DDA");
+-   ("/xea/xa8/x9a", "CHAM LETTER PA");
+-   ("/xea/xa8/x9b", "CHAM LETTER PPA");
+-   ("/xea/xa8/x9c", "CHAM LETTER PHA");
+-   ("/xea/xa8/x9d", "CHAM LETTER BA");
+-   ("/xea/xa8/x9e", "CHAM LETTER BHA");
+-   ("/xea/xa8/x9f", "CHAM LETTER MUE");
+-   ("/xea/xa8/xa0", "CHAM LETTER MA");
+-   ("/xea/xa8/xa1", "CHAM LETTER BBA");
+-   ("/xea/xa8/xa2", "CHAM LETTER YA");
+-   ("/xea/xa8/xa3", "CHAM LETTER RA");
+-   ("/xea/xa8/xa4", "CHAM LETTER LA");
+-   ("/xea/xa8/xa5", "CHAM LETTER VA");
+-   ("/xea/xa8/xa6", "CHAM LETTER SSA");
+-   ("/xea/xa8/xa7", "CHAM LETTER SA");
+-   ("/xea/xa8/xa8", "CHAM LETTER HA");
+-   ("/xea/xa8/xa9", "CHAM VOWEL SIGN AA");
+-   ("/xea/xa8/xaa", "CHAM VOWEL SIGN I");
+-   ("/xea/xa8/xab", "CHAM VOWEL SIGN II");
+-   ("/xea/xa8/xac", "CHAM VOWEL SIGN EI");
+-   ("/xea/xa8/xad", "CHAM VOWEL SIGN U");
+-   ("/xea/xa8/xae", "CHAM VOWEL SIGN OE");
+-   ("/xea/xa8/xaf", "CHAM VOWEL SIGN O");
+-   ("/xea/xa8/xb0", "CHAM VOWEL SIGN AI");
+-   ("/xea/xa8/xb1", "CHAM VOWEL SIGN AU");
+-   ("/xea/xa8/xb2", "CHAM VOWEL SIGN UE");
+-   ("/xea/xa8/xb3", "CHAM CONSONANT SIGN YA");
+-   ("/xea/xa8/xb4", "CHAM CONSONANT SIGN RA");
+-   ("/xea/xa8/xb5", "CHAM CONSONANT SIGN LA");
+-   ("/xea/xa8/xb6", "CHAM CONSONANT SIGN WA");
+-   ("/xea/xa9/x80", "CHAM LETTER FINAL K");
+-   ("/xea/xa9/x81", "CHAM LETTER FINAL G");
+-   ("/xea/xa9/x82", "CHAM LETTER FINAL NG");
+-   ("/xea/xa9/x83", "CHAM CONSONANT SIGN FINAL NG");
+-   ("/xea/xa9/x84", "CHAM LETTER FINAL CH");
+-   ("/xea/xa9/x85", "CHAM LETTER FINAL T");
+-   ("/xea/xa9/x86", "CHAM LETTER FINAL N");
+-   ("/xea/xa9/x87", "CHAM LETTER FINAL P");
+-   ("/xea/xa9/x88", "CHAM LETTER FINAL Y");
+-   ("/xea/xa9/x89", "CHAM LETTER FINAL R");
+-   ("/xea/xa9/x8a", "CHAM LETTER FINAL L");
+-   ("/xea/xa9/x8b", "CHAM LETTER FINAL SS");
+-   ("/xea/xa9/x8c", "CHAM CONSONANT SIGN FINAL M");
+-   ("/xea/xa9/x8d", "CHAM CONSONANT SIGN FINAL H");
+-   ("/xea/xa9/x90", "CHAM DIGIT ZERO");
+-   ("/xea/xa9/x91", "CHAM DIGIT ONE");
+-   ("/xea/xa9/x92", "CHAM DIGIT TWO");
+-   ("/xea/xa9/x93", "CHAM DIGIT THREE");
+-   ("/xea/xa9/x94", "CHAM DIGIT FOUR");
+-   ("/xea/xa9/x95", "CHAM DIGIT FIVE");
+-   ("/xea/xa9/x96", "CHAM DIGIT SIX");
+-   ("/xea/xa9/x97", "CHAM DIGIT SEVEN");
+-   ("/xea/xa9/x98", "CHAM DIGIT EIGHT");
+-   ("/xea/xa9/x99", "CHAM DIGIT NINE");
+-   ("/xea/xa9/x9c", "CHAM PUNCTUATION SPIRAL");
+-   ("/xea/xa9/x9d", "CHAM PUNCTUATION DANDA");
+-   ("/xea/xa9/x9e", "CHAM PUNCTUATION DOUBLE DANDA");
+-   ("/xea/xa9/x9f", "CHAM PUNCTUATION TRIPLE DANDA");
+-   ("/xea/xb0/x80", "HANGUL SYLLABLE GA");
+-   ("/xea/xb0/x81", "HANGUL SYLLABLE GAG");
+-   ("/xea/xb0/x82", "HANGUL SYLLABLE GAGG");
+-   ("/xea/xb0/x83", "HANGUL SYLLABLE GAGS");
+-   ("/xea/xb0/x84", "HANGUL SYLLABLE GAN");
+-   ("/xea/xb0/x85", "HANGUL SYLLABLE GANI");
+-   ("/xea/xb0/x86", "HANGUL SYLLABLE GANH");
+-   ("/xea/xb0/x87", "HANGUL SYLLABLE GAD");
+-   ("/xea/xb0/x88", "HANGUL SYLLABLE GAL");
+-   ("/xea/xb0/x89", "HANGUL SYLLABLE GALG");
+-   ("/xea/xb0/x8a", "HANGUL SYLLABLE GALM");
+-   ("/xea/xb0/x8b", "HANGUL SYLLABLE GALB");
+-   ("/xea/xb0/x8c", "HANGUL SYLLABLE GALS");
+-   ("/xea/xb0/x8d", "HANGUL SYLLABLE GALT");
+-   ("/xea/xb0/x8e", "HANGUL SYLLABLE GALP");
+-   ("/xea/xb0/x8f", "HANGUL SYLLABLE GALH");
+-   ("/xea/xb0/x90", "HANGUL SYLLABLE GAM");
+-   ("/xea/xb0/x91", "HANGUL SYLLABLE GAB");
+-   ("/xea/xb0/x92", "HANGUL SYLLABLE GABS");
+-   ("/xea/xb0/x93", "HANGUL SYLLABLE GAS");
+-   ("/xea/xb0/x94", "HANGUL SYLLABLE GASS");
+-   ("/xea/xb0/x95", "HANGUL SYLLABLE GANG");
+-   ("/xea/xb0/x96", "HANGUL SYLLABLE GAJ");
+-   ("/xea/xb0/x97", "HANGUL SYLLABLE GAC");
+-   ("/xea/xb0/x98", "HANGUL SYLLABLE GAK");
+-   ("/xea/xb0/x99", "HANGUL SYLLABLE GAT");
+-   ("/xea/xb0/x9a", "HANGUL SYLLABLE GAP");
+-   ("/xea/xb0/x9b", "HANGUL SYLLABLE GAH");
+-   ("/xea/xb0/x9c", "HANGUL SYLLABLE GAE");
+-   ("/xea/xb0/x9d", "HANGUL SYLLABLE GAEG");
+-   ("/xea/xb0/x9e", "HANGUL SYLLABLE GAEGG");
+-   ("/xea/xb0/x9f", "HANGUL SYLLABLE GAEGS");
+-   ("/xea/xb0/xa0", "HANGUL SYLLABLE GAEN");
+-   ("/xea/xb0/xa1", "HANGUL SYLLABLE GAENI");
+-   ("/xea/xb0/xa2", "HANGUL SYLLABLE GAENH");
+-   ("/xea/xb0/xa3", "HANGUL SYLLABLE GAED");
+-   ("/xea/xb0/xa4", "HANGUL SYLLABLE GAEL");
+-   ("/xea/xb0/xa5", "HANGUL SYLLABLE GAELG");
+-   ("/xea/xb0/xa6", "HANGUL SYLLABLE GAELM");
+-   ("/xea/xb0/xa7", "HANGUL SYLLABLE GAELB");
+-   ("/xea/xb0/xa8", "HANGUL SYLLABLE GAELS");
+-   ("/xea/xb0/xa9", "HANGUL SYLLABLE GAELT");
+-   ("/xea/xb0/xaa", "HANGUL SYLLABLE GAELP");
+-   ("/xea/xb0/xab", "HANGUL SYLLABLE GAELH");
+-   ("/xea/xb0/xac", "HANGUL SYLLABLE GAEM");
+-   ("/xea/xb0/xad", "HANGUL SYLLABLE GAEB");
+-   ("/xea/xb0/xae", "HANGUL SYLLABLE GAEBS");
+-   ("/xea/xb0/xaf", "HANGUL SYLLABLE GAES");
+-   ("/xea/xb0/xb0", "HANGUL SYLLABLE GAESS");
+-   ("/xea/xb0/xb1", "HANGUL SYLLABLE GAENG");
+-   ("/xea/xb0/xb2", "HANGUL SYLLABLE GAEJ");
+-   ("/xea/xb0/xb3", "HANGUL SYLLABLE GAEC");
+-   ("/xea/xb0/xb4", "HANGUL SYLLABLE GAEK");
+-   ("/xea/xb0/xb5", "HANGUL SYLLABLE GAET");
+-   ("/xea/xb0/xb6", "HANGUL SYLLABLE GAEP");
+-   ("/xea/xb0/xb7", "HANGUL SYLLABLE GAEH");
+-   ("/xea/xb0/xb8", "HANGUL SYLLABLE GYA");
+-   ("/xea/xb0/xb9", "HANGUL SYLLABLE GYAG");
+-   ("/xea/xb0/xba", "HANGUL SYLLABLE GYAGG");
+-   ("/xea/xb0/xbb", "HANGUL SYLLABLE GYAGS");
+-   ("/xea/xb0/xbc", "HANGUL SYLLABLE GYAN");
+-   ("/xea/xb0/xbd", "HANGUL SYLLABLE GYANI");
+-   ("/xea/xb0/xbe", "HANGUL SYLLABLE GYANH");
+-   ("/xea/xb0/xbf", "HANGUL SYLLABLE GYAD");
+-   ("/xea/xb1/x80", "HANGUL SYLLABLE GYAL");
+-   ("/xea/xb1/x81", "HANGUL SYLLABLE GYALG");
+-   ("/xea/xb1/x82", "HANGUL SYLLABLE GYALM");
+-   ("/xea/xb1/x83", "HANGUL SYLLABLE GYALB");
+-   ("/xea/xb1/x84", "HANGUL SYLLABLE GYALS");
+-   ("/xea/xb1/x85", "HANGUL SYLLABLE GYALT");
+-   ("/xea/xb1/x86", "HANGUL SYLLABLE GYALP");
+-   ("/xea/xb1/x87", "HANGUL SYLLABLE GYALH");
+-   ("/xea/xb1/x88", "HANGUL SYLLABLE GYAM");
+-   ("/xea/xb1/x89", "HANGUL SYLLABLE GYAB");
+-   ("/xea/xb1/x8a", "HANGUL SYLLABLE GYABS");
+-   ("/xea/xb1/x8b", "HANGUL SYLLABLE GYAS");
+-   ("/xea/xb1/x8c", "HANGUL SYLLABLE GYASS");
+-   ("/xea/xb1/x8d", "HANGUL SYLLABLE GYANG");
+-   ("/xea/xb1/x8e", "HANGUL SYLLABLE GYAJ");
+-   ("/xea/xb1/x8f", "HANGUL SYLLABLE GYAC");
+-   ("/xea/xb1/x90", "HANGUL SYLLABLE GYAK");
+-   ("/xea/xb1/x91", "HANGUL SYLLABLE GYAT");
+-   ("/xea/xb1/x92", "HANGUL SYLLABLE GYAP");
+-   ("/xea/xb1/x93", "HANGUL SYLLABLE GYAH");
+-   ("/xea/xb1/x94", "HANGUL SYLLABLE GYAE");
+-   ("/xea/xb1/x95", "HANGUL SYLLABLE GYAEG");
+-   ("/xea/xb1/x96", "HANGUL SYLLABLE GYAEGG");
+-   ("/xea/xb1/x97", "HANGUL SYLLABLE GYAEGS");
+-   ("/xea/xb1/x98", "HANGUL SYLLABLE GYAEN");
+-   ("/xea/xb1/x99", "HANGUL SYLLABLE GYAENI");
+-   ("/xea/xb1/x9a", "HANGUL SYLLABLE GYAENH");
+-   ("/xea/xb1/x9b", "HANGUL SYLLABLE GYAED");
+-   ("/xea/xb1/x9c", "HANGUL SYLLABLE GYAEL");
+-   ("/xea/xb1/x9d", "HANGUL SYLLABLE GYAELG");
+-   ("/xea/xb1/x9e", "HANGUL SYLLABLE GYAELM");
+-   ("/xea/xb1/x9f", "HANGUL SYLLABLE GYAELB");
+-   ("/xea/xb1/xa0", "HANGUL SYLLABLE GYAELS");
+-   ("/xea/xb1/xa1", "HANGUL SYLLABLE GYAELT");
+-   ("/xea/xb1/xa2", "HANGUL SYLLABLE GYAELP");
+-   ("/xea/xb1/xa3", "HANGUL SYLLABLE GYAELH");
+-   ("/xea/xb1/xa4", "HANGUL SYLLABLE GYAEM");
+-   ("/xea/xb1/xa5", "HANGUL SYLLABLE GYAEB");
+-   ("/xea/xb1/xa6", "HANGUL SYLLABLE GYAEBS");
+-   ("/xea/xb1/xa7", "HANGUL SYLLABLE GYAES");
+-   ("/xea/xb1/xa8", "HANGUL SYLLABLE GYAESS");
+-   ("/xea/xb1/xa9", "HANGUL SYLLABLE GYAENG");
+-   ("/xea/xb1/xaa", "HANGUL SYLLABLE GYAEJ");
+-   ("/xea/xb1/xab", "HANGUL SYLLABLE GYAEC");
+-   ("/xea/xb1/xac", "HANGUL SYLLABLE GYAEK");
+-   ("/xea/xb1/xad", "HANGUL SYLLABLE GYAET");
+-   ("/xea/xb1/xae", "HANGUL SYLLABLE GYAEP");
+-   ("/xea/xb1/xaf", "HANGUL SYLLABLE GYAEH");
+-   ("/xea/xb1/xb0", "HANGUL SYLLABLE GEO");
+-   ("/xea/xb1/xb1", "HANGUL SYLLABLE GEOG");
+-   ("/xea/xb1/xb2", "HANGUL SYLLABLE GEOGG");
+-   ("/xea/xb1/xb3", "HANGUL SYLLABLE GEOGS");
+-   ("/xea/xb1/xb4", "HANGUL SYLLABLE GEON");
+-   ("/xea/xb1/xb5", "HANGUL SYLLABLE GEONI");
+-   ("/xea/xb1/xb6", "HANGUL SYLLABLE GEONH");
+-   ("/xea/xb1/xb7", "HANGUL SYLLABLE GEOD");
+-   ("/xea/xb1/xb8", "HANGUL SYLLABLE GEOL");
+-   ("/xea/xb1/xb9", "HANGUL SYLLABLE GEOLG");
+-   ("/xea/xb1/xba", "HANGUL SYLLABLE GEOLM");
+-   ("/xea/xb1/xbb", "HANGUL SYLLABLE GEOLB");
+-   ("/xea/xb1/xbc", "HANGUL SYLLABLE GEOLS");
+-   ("/xea/xb1/xbd", "HANGUL SYLLABLE GEOLT");
+-   ("/xea/xb1/xbe", "HANGUL SYLLABLE GEOLP");
+-   ("/xea/xb1/xbf", "HANGUL SYLLABLE GEOLH");
+-   ("/xea/xb2/x80", "HANGUL SYLLABLE GEOM");
+-   ("/xea/xb2/x81", "HANGUL SYLLABLE GEOB");
+-   ("/xea/xb2/x82", "HANGUL SYLLABLE GEOBS");
+-   ("/xea/xb2/x83", "HANGUL SYLLABLE GEOS");
+-   ("/xea/xb2/x84", "HANGUL SYLLABLE GEOSS");
+-   ("/xea/xb2/x85", "HANGUL SYLLABLE GEONG");
+-   ("/xea/xb2/x86", "HANGUL SYLLABLE GEOJ");
+-   ("/xea/xb2/x87", "HANGUL SYLLABLE GEOC");
+-   ("/xea/xb2/x88", "HANGUL SYLLABLE GEOK");
+-   ("/xea/xb2/x89", "HANGUL SYLLABLE GEOT");
+-   ("/xea/xb2/x8a", "HANGUL SYLLABLE GEOP");
+-   ("/xea/xb2/x8b", "HANGUL SYLLABLE GEOH");
+-   ("/xea/xb2/x8c", "HANGUL SYLLABLE GE");
+-   ("/xea/xb2/x8d", "HANGUL SYLLABLE GEG");
+-   ("/xea/xb2/x8e", "HANGUL SYLLABLE GEGG");
+-   ("/xea/xb2/x8f", "HANGUL SYLLABLE GEGS");
+-   ("/xea/xb2/x90", "HANGUL SYLLABLE GEN");
+-   ("/xea/xb2/x91", "HANGUL SYLLABLE GENI");
+-   ("/xea/xb2/x92", "HANGUL SYLLABLE GENH");
+-   ("/xea/xb2/x93", "HANGUL SYLLABLE GED");
+-   ("/xea/xb2/x94", "HANGUL SYLLABLE GEL");
+-   ("/xea/xb2/x95", "HANGUL SYLLABLE GELG");
+-   ("/xea/xb2/x96", "HANGUL SYLLABLE GELM");
+-   ("/xea/xb2/x97", "HANGUL SYLLABLE GELB");
+-   ("/xea/xb2/x98", "HANGUL SYLLABLE GELS");
+-   ("/xea/xb2/x99", "HANGUL SYLLABLE GELT");
+-   ("/xea/xb2/x9a", "HANGUL SYLLABLE GELP");
+-   ("/xea/xb2/x9b", "HANGUL SYLLABLE GELH");
+-   ("/xea/xb2/x9c", "HANGUL SYLLABLE GEM");
+-   ("/xea/xb2/x9d", "HANGUL SYLLABLE GEB");
+-   ("/xea/xb2/x9e", "HANGUL SYLLABLE GEBS");
+-   ("/xea/xb2/x9f", "HANGUL SYLLABLE GES");
+-   ("/xea/xb2/xa0", "HANGUL SYLLABLE GESS");
+-   ("/xea/xb2/xa1", "HANGUL SYLLABLE GENG");
+-   ("/xea/xb2/xa2", "HANGUL SYLLABLE GEJ");
+-   ("/xea/xb2/xa3", "HANGUL SYLLABLE GEC");
+-   ("/xea/xb2/xa4", "HANGUL SYLLABLE GEK");
+-   ("/xea/xb2/xa5", "HANGUL SYLLABLE GET");
+-   ("/xea/xb2/xa6", "HANGUL SYLLABLE GEP");
+-   ("/xea/xb2/xa7", "HANGUL SYLLABLE GEH");
+-   ("/xea/xb2/xa8", "HANGUL SYLLABLE GYEO");
+-   ("/xea/xb2/xa9", "HANGUL SYLLABLE GYEOG");
+-   ("/xea/xb2/xaa", "HANGUL SYLLABLE GYEOGG");
+-   ("/xea/xb2/xab", "HANGUL SYLLABLE GYEOGS");
+-   ("/xea/xb2/xac", "HANGUL SYLLABLE GYEON");
+-   ("/xea/xb2/xad", "HANGUL SYLLABLE GYEONI");
+-   ("/xea/xb2/xae", "HANGUL SYLLABLE GYEONH");
+-   ("/xea/xb2/xaf", "HANGUL SYLLABLE GYEOD");
+-   ("/xea/xb2/xb0", "HANGUL SYLLABLE GYEOL");
+-   ("/xea/xb2/xb1", "HANGUL SYLLABLE GYEOLG");
+-   ("/xea/xb2/xb2", "HANGUL SYLLABLE GYEOLM");
+-   ("/xea/xb2/xb3", "HANGUL SYLLABLE GYEOLB");
+-   ("/xea/xb2/xb4", "HANGUL SYLLABLE GYEOLS");
+-   ("/xea/xb2/xb5", "HANGUL SYLLABLE GYEOLT");
+-   ("/xea/xb2/xb6", "HANGUL SYLLABLE GYEOLP");
+-   ("/xea/xb2/xb7", "HANGUL SYLLABLE GYEOLH");
+-   ("/xea/xb2/xb8", "HANGUL SYLLABLE GYEOM");
+-   ("/xea/xb2/xb9", "HANGUL SYLLABLE GYEOB");
+-   ("/xea/xb2/xba", "HANGUL SYLLABLE GYEOBS");
+-   ("/xea/xb2/xbb", "HANGUL SYLLABLE GYEOS");
+-   ("/xea/xb2/xbc", "HANGUL SYLLABLE GYEOSS");
+-   ("/xea/xb2/xbd", "HANGUL SYLLABLE GYEONG");
+-   ("/xea/xb2/xbe", "HANGUL SYLLABLE GYEOJ");
+-   ("/xea/xb2/xbf", "HANGUL SYLLABLE GYEOC");
+-   ("/xea/xb3/x80", "HANGUL SYLLABLE GYEOK");
+-   ("/xea/xb3/x81", "HANGUL SYLLABLE GYEOT");
+-   ("/xea/xb3/x82", "HANGUL SYLLABLE GYEOP");
+-   ("/xea/xb3/x83", "HANGUL SYLLABLE GYEOH");
+-   ("/xea/xb3/x84", "HANGUL SYLLABLE GYE");
+-   ("/xea/xb3/x85", "HANGUL SYLLABLE GYEG");
+-   ("/xea/xb3/x86", "HANGUL SYLLABLE GYEGG");
+-   ("/xea/xb3/x87", "HANGUL SYLLABLE GYEGS");
+-   ("/xea/xb3/x88", "HANGUL SYLLABLE GYEN");
+-   ("/xea/xb3/x89", "HANGUL SYLLABLE GYENI");
+-   ("/xea/xb3/x8a", "HANGUL SYLLABLE GYENH");
+-   ("/xea/xb3/x8b", "HANGUL SYLLABLE GYED");
+-   ("/xea/xb3/x8c", "HANGUL SYLLABLE GYEL");
+-   ("/xea/xb3/x8d", "HANGUL SYLLABLE GYELG");
+-   ("/xea/xb3/x8e", "HANGUL SYLLABLE GYELM");
+-   ("/xea/xb3/x8f", "HANGUL SYLLABLE GYELB");
+-   ("/xea/xb3/x90", "HANGUL SYLLABLE GYELS");
+-   ("/xea/xb3/x91", "HANGUL SYLLABLE GYELT");
+-   ("/xea/xb3/x92", "HANGUL SYLLABLE GYELP");
+-   ("/xea/xb3/x93", "HANGUL SYLLABLE GYELH");
+-   ("/xea/xb3/x94", "HANGUL SYLLABLE GYEM");
+-   ("/xea/xb3/x95", "HANGUL SYLLABLE GYEB");
+-   ("/xea/xb3/x96", "HANGUL SYLLABLE GYEBS");
+-   ("/xea/xb3/x97", "HANGUL SYLLABLE GYES");
+-   ("/xea/xb3/x98", "HANGUL SYLLABLE GYESS");
+-   ("/xea/xb3/x99", "HANGUL SYLLABLE GYENG");
+-   ("/xea/xb3/x9a", "HANGUL SYLLABLE GYEJ");
+-   ("/xea/xb3/x9b", "HANGUL SYLLABLE GYEC");
+-   ("/xea/xb3/x9c", "HANGUL SYLLABLE GYEK");
+-   ("/xea/xb3/x9d", "HANGUL SYLLABLE GYET");
+-   ("/xea/xb3/x9e", "HANGUL SYLLABLE GYEP");
+-   ("/xea/xb3/x9f", "HANGUL SYLLABLE GYEH");
+-   ("/xea/xb3/xa0", "HANGUL SYLLABLE GO");
+-   ("/xea/xb3/xa1", "HANGUL SYLLABLE GOG");
+-   ("/xea/xb3/xa2", "HANGUL SYLLABLE GOGG");
+-   ("/xea/xb3/xa3", "HANGUL SYLLABLE GOGS");
+-   ("/xea/xb3/xa4", "HANGUL SYLLABLE GON");
+-   ("/xea/xb3/xa5", "HANGUL SYLLABLE GONI");
+-   ("/xea/xb3/xa6", "HANGUL SYLLABLE GONH");
+-   ("/xea/xb3/xa7", "HANGUL SYLLABLE GOD");
+-   ("/xea/xb3/xa8", "HANGUL SYLLABLE GOL");
+-   ("/xea/xb3/xa9", "HANGUL SYLLABLE GOLG");
+-   ("/xea/xb3/xaa", "HANGUL SYLLABLE GOLM");
+-   ("/xea/xb3/xab", "HANGUL SYLLABLE GOLB");
+-   ("/xea/xb3/xac", "HANGUL SYLLABLE GOLS");
+-   ("/xea/xb3/xad", "HANGUL SYLLABLE GOLT");
+-   ("/xea/xb3/xae", "HANGUL SYLLABLE GOLP");
+-   ("/xea/xb3/xaf", "HANGUL SYLLABLE GOLH");
+-   ("/xea/xb3/xb0", "HANGUL SYLLABLE GOM");
+-   ("/xea/xb3/xb1", "HANGUL SYLLABLE GOB");
+-   ("/xea/xb3/xb2", "HANGUL SYLLABLE GOBS");
+-   ("/xea/xb3/xb3", "HANGUL SYLLABLE GOS");
+-   ("/xea/xb3/xb4", "HANGUL SYLLABLE GOSS");
+-   ("/xea/xb3/xb5", "HANGUL SYLLABLE GONG");
+-   ("/xea/xb3/xb6", "HANGUL SYLLABLE GOJ");
+-   ("/xea/xb3/xb7", "HANGUL SYLLABLE GOC");
+-   ("/xea/xb3/xb8", "HANGUL SYLLABLE GOK");
+-   ("/xea/xb3/xb9", "HANGUL SYLLABLE GOT");
+-   ("/xea/xb3/xba", "HANGUL SYLLABLE GOP");
+-   ("/xea/xb3/xbb", "HANGUL SYLLABLE GOH");
+-   ("/xea/xb3/xbc", "HANGUL SYLLABLE GWA");
+-   ("/xea/xb3/xbd", "HANGUL SYLLABLE GWAG");
+-   ("/xea/xb3/xbe", "HANGUL SYLLABLE GWAGG");
+-   ("/xea/xb3/xbf", "HANGUL SYLLABLE GWAGS");
+-   ("/xea/xb4/x80", "HANGUL SYLLABLE GWAN");
+-   ("/xea/xb4/x81", "HANGUL SYLLABLE GWANI");
+-   ("/xea/xb4/x82", "HANGUL SYLLABLE GWANH");
+-   ("/xea/xb4/x83", "HANGUL SYLLABLE GWAD");
+-   ("/xea/xb4/x84", "HANGUL SYLLABLE GWAL");
+-   ("/xea/xb4/x85", "HANGUL SYLLABLE GWALG");
+-   ("/xea/xb4/x86", "HANGUL SYLLABLE GWALM");
+-   ("/xea/xb4/x87", "HANGUL SYLLABLE GWALB");
+-   ("/xea/xb4/x88", "HANGUL SYLLABLE GWALS");
+-   ("/xea/xb4/x89", "HANGUL SYLLABLE GWALT");
+-   ("/xea/xb4/x8a", "HANGUL SYLLABLE GWALP");
+-   ("/xea/xb4/x8b", "HANGUL SYLLABLE GWALH");
+-   ("/xea/xb4/x8c", "HANGUL SYLLABLE GWAM");
+-   ("/xea/xb4/x8d", "HANGUL SYLLABLE GWAB");
+-   ("/xea/xb4/x8e", "HANGUL SYLLABLE GWABS");
+-   ("/xea/xb4/x8f", "HANGUL SYLLABLE GWAS");
+-   ("/xea/xb4/x90", "HANGUL SYLLABLE GWASS");
+-   ("/xea/xb4/x91", "HANGUL SYLLABLE GWANG");
+-   ("/xea/xb4/x92", "HANGUL SYLLABLE GWAJ");
+-   ("/xea/xb4/x93", "HANGUL SYLLABLE GWAC");
+-   ("/xea/xb4/x94", "HANGUL SYLLABLE GWAK");
+-   ("/xea/xb4/x95", "HANGUL SYLLABLE GWAT");
+-   ("/xea/xb4/x96", "HANGUL SYLLABLE GWAP");
+-   ("/xea/xb4/x97", "HANGUL SYLLABLE GWAH");
+-   ("/xea/xb4/x98", "HANGUL SYLLABLE GWAE");
+-   ("/xea/xb4/x99", "HANGUL SYLLABLE GWAEG");
+-   ("/xea/xb4/x9a", "HANGUL SYLLABLE GWAEGG");
+-   ("/xea/xb4/x9b", "HANGUL SYLLABLE GWAEGS");
+-   ("/xea/xb4/x9c", "HANGUL SYLLABLE GWAEN");
+-   ("/xea/xb4/x9d", "HANGUL SYLLABLE GWAENI");
+-   ("/xea/xb4/x9e", "HANGUL SYLLABLE GWAENH");
+-   ("/xea/xb4/x9f", "HANGUL SYLLABLE GWAED");
+-   ("/xea/xb4/xa0", "HANGUL SYLLABLE GWAEL");
+-   ("/xea/xb4/xa1", "HANGUL SYLLABLE GWAELG");
+-   ("/xea/xb4/xa2", "HANGUL SYLLABLE GWAELM");
+-   ("/xea/xb4/xa3", "HANGUL SYLLABLE GWAELB");
+-   ("/xea/xb4/xa4", "HANGUL SYLLABLE GWAELS");
+-   ("/xea/xb4/xa5", "HANGUL SYLLABLE GWAELT");
+-   ("/xea/xb4/xa6", "HANGUL SYLLABLE GWAELP");
+-   ("/xea/xb4/xa7", "HANGUL SYLLABLE GWAELH");
+-   ("/xea/xb4/xa8", "HANGUL SYLLABLE GWAEM");
+-   ("/xea/xb4/xa9", "HANGUL SYLLABLE GWAEB");
+-   ("/xea/xb4/xaa", "HANGUL SYLLABLE GWAEBS");
+-   ("/xea/xb4/xab", "HANGUL SYLLABLE GWAES");
+-   ("/xea/xb4/xac", "HANGUL SYLLABLE GWAESS");
+-   ("/xea/xb4/xad", "HANGUL SYLLABLE GWAENG");
+-   ("/xea/xb4/xae", "HANGUL SYLLABLE GWAEJ");
+-   ("/xea/xb4/xaf", "HANGUL SYLLABLE GWAEC");
+-   ("/xea/xb4/xb0", "HANGUL SYLLABLE GWAEK");
+-   ("/xea/xb4/xb1", "HANGUL SYLLABLE GWAET");
+-   ("/xea/xb4/xb2", "HANGUL SYLLABLE GWAEP");
+-   ("/xea/xb4/xb3", "HANGUL SYLLABLE GWAEH");
+-   ("/xea/xb4/xb4", "HANGUL SYLLABLE GOE");
+-   ("/xea/xb4/xb5", "HANGUL SYLLABLE GOEG");
+-   ("/xea/xb4/xb6", "HANGUL SYLLABLE GOEGG");
+-   ("/xea/xb4/xb7", "HANGUL SYLLABLE GOEGS");
+-   ("/xea/xb4/xb8", "HANGUL SYLLABLE GOEN");
+-   ("/xea/xb4/xb9", "HANGUL SYLLABLE GOENI");
+-   ("/xea/xb4/xba", "HANGUL SYLLABLE GOENH");
+-   ("/xea/xb4/xbb", "HANGUL SYLLABLE GOED");
+-   ("/xea/xb4/xbc", "HANGUL SYLLABLE GOEL");
+-   ("/xea/xb4/xbd", "HANGUL SYLLABLE GOELG");
+-   ("/xea/xb4/xbe", "HANGUL SYLLABLE GOELM");
+-   ("/xea/xb4/xbf", "HANGUL SYLLABLE GOELB");
+-   ("/xea/xb5/x80", "HANGUL SYLLABLE GOELS");
+-   ("/xea/xb5/x81", "HANGUL SYLLABLE GOELT");
+-   ("/xea/xb5/x82", "HANGUL SYLLABLE GOELP");
+-   ("/xea/xb5/x83", "HANGUL SYLLABLE GOELH");
+-   ("/xea/xb5/x84", "HANGUL SYLLABLE GOEM");
+-   ("/xea/xb5/x85", "HANGUL SYLLABLE GOEB");
+-   ("/xea/xb5/x86", "HANGUL SYLLABLE GOEBS");
+-   ("/xea/xb5/x87", "HANGUL SYLLABLE GOES");
+-   ("/xea/xb5/x88", "HANGUL SYLLABLE GOESS");
+-   ("/xea/xb5/x89", "HANGUL SYLLABLE GOENG");
+-   ("/xea/xb5/x8a", "HANGUL SYLLABLE GOEJ");
+-   ("/xea/xb5/x8b", "HANGUL SYLLABLE GOEC");
+-   ("/xea/xb5/x8c", "HANGUL SYLLABLE GOEK");
+-   ("/xea/xb5/x8d", "HANGUL SYLLABLE GOET");
+-   ("/xea/xb5/x8e", "HANGUL SYLLABLE GOEP");
+-   ("/xea/xb5/x8f", "HANGUL SYLLABLE GOEH");
+-   ("/xea/xb5/x90", "HANGUL SYLLABLE GYO");
+-   ("/xea/xb5/x91", "HANGUL SYLLABLE GYOG");
+-   ("/xea/xb5/x92", "HANGUL SYLLABLE GYOGG");
+-   ("/xea/xb5/x93", "HANGUL SYLLABLE GYOGS");
+-   ("/xea/xb5/x94", "HANGUL SYLLABLE GYON");
+-   ("/xea/xb5/x95", "HANGUL SYLLABLE GYONI");
+-   ("/xea/xb5/x96", "HANGUL SYLLABLE GYONH");
+-   ("/xea/xb5/x97", "HANGUL SYLLABLE GYOD");
+-   ("/xea/xb5/x98", "HANGUL SYLLABLE GYOL");
+-   ("/xea/xb5/x99", "HANGUL SYLLABLE GYOLG");
+-   ("/xea/xb5/x9a", "HANGUL SYLLABLE GYOLM");
+-   ("/xea/xb5/x9b", "HANGUL SYLLABLE GYOLB");
+-   ("/xea/xb5/x9c", "HANGUL SYLLABLE GYOLS");
+-   ("/xea/xb5/x9d", "HANGUL SYLLABLE GYOLT");
+-   ("/xea/xb5/x9e", "HANGUL SYLLABLE GYOLP");
+-   ("/xea/xb5/x9f", "HANGUL SYLLABLE GYOLH");
+-   ("/xea/xb5/xa0", "HANGUL SYLLABLE GYOM");
+-   ("/xea/xb5/xa1", "HANGUL SYLLABLE GYOB");
+-   ("/xea/xb5/xa2", "HANGUL SYLLABLE GYOBS");
+-   ("/xea/xb5/xa3", "HANGUL SYLLABLE GYOS");
+-   ("/xea/xb5/xa4", "HANGUL SYLLABLE GYOSS");
+-   ("/xea/xb5/xa5", "HANGUL SYLLABLE GYONG");
+-   ("/xea/xb5/xa6", "HANGUL SYLLABLE GYOJ");
+-   ("/xea/xb5/xa7", "HANGUL SYLLABLE GYOC");
+-   ("/xea/xb5/xa8", "HANGUL SYLLABLE GYOK");
+-   ("/xea/xb5/xa9", "HANGUL SYLLABLE GYOT");
+-   ("/xea/xb5/xaa", "HANGUL SYLLABLE GYOP");
+-   ("/xea/xb5/xab", "HANGUL SYLLABLE GYOH");
+-   ("/xea/xb5/xac", "HANGUL SYLLABLE GU");
+-   ("/xea/xb5/xad", "HANGUL SYLLABLE GUG");
+-   ("/xea/xb5/xae", "HANGUL SYLLABLE GUGG");
+-   ("/xea/xb5/xaf", "HANGUL SYLLABLE GUGS");
+-   ("/xea/xb5/xb0", "HANGUL SYLLABLE GUN");
+-   ("/xea/xb5/xb1", "HANGUL SYLLABLE GUNI");
+-   ("/xea/xb5/xb2", "HANGUL SYLLABLE GUNH");
+-   ("/xea/xb5/xb3", "HANGUL SYLLABLE GUD");
+-   ("/xea/xb5/xb4", "HANGUL SYLLABLE GUL");
+-   ("/xea/xb5/xb5", "HANGUL SYLLABLE GULG");
+-   ("/xea/xb5/xb6", "HANGUL SYLLABLE GULM");
+-   ("/xea/xb5/xb7", "HANGUL SYLLABLE GULB");
+-   ("/xea/xb5/xb8", "HANGUL SYLLABLE GULS");
+-   ("/xea/xb5/xb9", "HANGUL SYLLABLE GULT");
+-   ("/xea/xb5/xba", "HANGUL SYLLABLE GULP");
+-   ("/xea/xb5/xbb", "HANGUL SYLLABLE GULH");
+-   ("/xea/xb5/xbc", "HANGUL SYLLABLE GUM");
+-   ("/xea/xb5/xbd", "HANGUL SYLLABLE GUB");
+-   ("/xea/xb5/xbe", "HANGUL SYLLABLE GUBS");
+-   ("/xea/xb5/xbf", "HANGUL SYLLABLE GUS");
+-   ("/xea/xb6/x80", "HANGUL SYLLABLE GUSS");
+-   ("/xea/xb6/x81", "HANGUL SYLLABLE GUNG");
+-   ("/xea/xb6/x82", "HANGUL SYLLABLE GUJ");
+-   ("/xea/xb6/x83", "HANGUL SYLLABLE GUC");
+-   ("/xea/xb6/x84", "HANGUL SYLLABLE GUK");
+-   ("/xea/xb6/x85", "HANGUL SYLLABLE GUT");
+-   ("/xea/xb6/x86", "HANGUL SYLLABLE GUP");
+-   ("/xea/xb6/x87", "HANGUL SYLLABLE GUH");
+-   ("/xea/xb6/x88", "HANGUL SYLLABLE GWEO");
+-   ("/xea/xb6/x89", "HANGUL SYLLABLE GWEOG");
+-   ("/xea/xb6/x8a", "HANGUL SYLLABLE GWEOGG");
+-   ("/xea/xb6/x8b", "HANGUL SYLLABLE GWEOGS");
+-   ("/xea/xb6/x8c", "HANGUL SYLLABLE GWEON");
+-   ("/xea/xb6/x8d", "HANGUL SYLLABLE GWEONI");
+-   ("/xea/xb6/x8e", "HANGUL SYLLABLE GWEONH");
+-   ("/xea/xb6/x8f", "HANGUL SYLLABLE GWEOD");
+-   ("/xea/xb6/x90", "HANGUL SYLLABLE GWEOL");
+-   ("/xea/xb6/x91", "HANGUL SYLLABLE GWEOLG");
+-   ("/xea/xb6/x92", "HANGUL SYLLABLE GWEOLM");
+-   ("/xea/xb6/x93", "HANGUL SYLLABLE GWEOLB");
+-   ("/xea/xb6/x94", "HANGUL SYLLABLE GWEOLS");
+-   ("/xea/xb6/x95", "HANGUL SYLLABLE GWEOLT");
+-   ("/xea/xb6/x96", "HANGUL SYLLABLE GWEOLP");
+-   ("/xea/xb6/x97", "HANGUL SYLLABLE GWEOLH");
+-   ("/xea/xb6/x98", "HANGUL SYLLABLE GWEOM");
+-   ("/xea/xb6/x99", "HANGUL SYLLABLE GWEOB");
+-   ("/xea/xb6/x9a", "HANGUL SYLLABLE GWEOBS");
+-   ("/xea/xb6/x9b", "HANGUL SYLLABLE GWEOS");
+-   ("/xea/xb6/x9c", "HANGUL SYLLABLE GWEOSS");
+-   ("/xea/xb6/x9d", "HANGUL SYLLABLE GWEONG");
+-   ("/xea/xb6/x9e", "HANGUL SYLLABLE GWEOJ");
+-   ("/xea/xb6/x9f", "HANGUL SYLLABLE GWEOC");
+-   ("/xea/xb6/xa0", "HANGUL SYLLABLE GWEOK");
+-   ("/xea/xb6/xa1", "HANGUL SYLLABLE GWEOT");
+-   ("/xea/xb6/xa2", "HANGUL SYLLABLE GWEOP");
+-   ("/xea/xb6/xa3", "HANGUL SYLLABLE GWEOH");
+-   ("/xea/xb6/xa4", "HANGUL SYLLABLE GWE");
+-   ("/xea/xb6/xa5", "HANGUL SYLLABLE GWEG");
+-   ("/xea/xb6/xa6", "HANGUL SYLLABLE GWEGG");
+-   ("/xea/xb6/xa7", "HANGUL SYLLABLE GWEGS");
+-   ("/xea/xb6/xa8", "HANGUL SYLLABLE GWEN");
+-   ("/xea/xb6/xa9", "HANGUL SYLLABLE GWENI");
+-   ("/xea/xb6/xaa", "HANGUL SYLLABLE GWENH");
+-   ("/xea/xb6/xab", "HANGUL SYLLABLE GWED");
+-   ("/xea/xb6/xac", "HANGUL SYLLABLE GWEL");
+-   ("/xea/xb6/xad", "HANGUL SYLLABLE GWELG");
+-   ("/xea/xb6/xae", "HANGUL SYLLABLE GWELM");
+-   ("/xea/xb6/xaf", "HANGUL SYLLABLE GWELB");
+-   ("/xea/xb6/xb0", "HANGUL SYLLABLE GWELS");
+-   ("/xea/xb6/xb1", "HANGUL SYLLABLE GWELT");
+-   ("/xea/xb6/xb2", "HANGUL SYLLABLE GWELP");
+-   ("/xea/xb6/xb3", "HANGUL SYLLABLE GWELH");
+-   ("/xea/xb6/xb4", "HANGUL SYLLABLE GWEM");
+-   ("/xea/xb6/xb5", "HANGUL SYLLABLE GWEB");
+-   ("/xea/xb6/xb6", "HANGUL SYLLABLE GWEBS");
+-   ("/xea/xb6/xb7", "HANGUL SYLLABLE GWES");
+-   ("/xea/xb6/xb8", "HANGUL SYLLABLE GWESS");
+-   ("/xea/xb6/xb9", "HANGUL SYLLABLE GWENG");
+-   ("/xea/xb6/xba", "HANGUL SYLLABLE GWEJ");
+-   ("/xea/xb6/xbb", "HANGUL SYLLABLE GWEC");
+-   ("/xea/xb6/xbc", "HANGUL SYLLABLE GWEK");
+-   ("/xea/xb6/xbd", "HANGUL SYLLABLE GWET");
+-   ("/xea/xb6/xbe", "HANGUL SYLLABLE GWEP");
+-   ("/xea/xb6/xbf", "HANGUL SYLLABLE GWEH");
+-   ("/xea/xb7/x80", "HANGUL SYLLABLE GWI");
+-   ("/xea/xb7/x81", "HANGUL SYLLABLE GWIG");
+-   ("/xea/xb7/x82", "HANGUL SYLLABLE GWIGG");
+-   ("/xea/xb7/x83", "HANGUL SYLLABLE GWIGS");
+-   ("/xea/xb7/x84", "HANGUL SYLLABLE GWIN");
+-   ("/xea/xb7/x85", "HANGUL SYLLABLE GWINI");
+-   ("/xea/xb7/x86", "HANGUL SYLLABLE GWINH");
+-   ("/xea/xb7/x87", "HANGUL SYLLABLE GWID");
+-   ("/xea/xb7/x88", "HANGUL SYLLABLE GWIL");
+-   ("/xea/xb7/x89", "HANGUL SYLLABLE GWILG");
+-   ("/xea/xb7/x8a", "HANGUL SYLLABLE GWILM");
+-   ("/xea/xb7/x8b", "HANGUL SYLLABLE GWILB");
+-   ("/xea/xb7/x8c", "HANGUL SYLLABLE GWILS");
+-   ("/xea/xb7/x8d", "HANGUL SYLLABLE GWILT");
+-   ("/xea/xb7/x8e", "HANGUL SYLLABLE GWILP");
+-   ("/xea/xb7/x8f", "HANGUL SYLLABLE GWILH");
+-   ("/xea/xb7/x90", "HANGUL SYLLABLE GWIM");
+-   ("/xea/xb7/x91", "HANGUL SYLLABLE GWIB");
+-   ("/xea/xb7/x92", "HANGUL SYLLABLE GWIBS");
+-   ("/xea/xb7/x93", "HANGUL SYLLABLE GWIS");
+-   ("/xea/xb7/x94", "HANGUL SYLLABLE GWISS");
+-   ("/xea/xb7/x95", "HANGUL SYLLABLE GWING");
+-   ("/xea/xb7/x96", "HANGUL SYLLABLE GWIJ");
+-   ("/xea/xb7/x97", "HANGUL SYLLABLE GWIC");
+-   ("/xea/xb7/x98", "HANGUL SYLLABLE GWIK");
+-   ("/xea/xb7/x99", "HANGUL SYLLABLE GWIT");
+-   ("/xea/xb7/x9a", "HANGUL SYLLABLE GWIP");
+-   ("/xea/xb7/x9b", "HANGUL SYLLABLE GWIH");
+-   ("/xea/xb7/x9c", "HANGUL SYLLABLE GYU");
+-   ("/xea/xb7/x9d", "HANGUL SYLLABLE GYUG");
+-   ("/xea/xb7/x9e", "HANGUL SYLLABLE GYUGG");
+-   ("/xea/xb7/x9f", "HANGUL SYLLABLE GYUGS");
+-   ("/xea/xb7/xa0", "HANGUL SYLLABLE GYUN");
+-   ("/xea/xb7/xa1", "HANGUL SYLLABLE GYUNI");
+-   ("/xea/xb7/xa2", "HANGUL SYLLABLE GYUNH");
+-   ("/xea/xb7/xa3", "HANGUL SYLLABLE GYUD");
+-   ("/xea/xb7/xa4", "HANGUL SYLLABLE GYUL");
+-   ("/xea/xb7/xa5", "HANGUL SYLLABLE GYULG");
+-   ("/xea/xb7/xa6", "HANGUL SYLLABLE GYULM");
+-   ("/xea/xb7/xa7", "HANGUL SYLLABLE GYULB");
+-   ("/xea/xb7/xa8", "HANGUL SYLLABLE GYULS");
+-   ("/xea/xb7/xa9", "HANGUL SYLLABLE GYULT");
+-   ("/xea/xb7/xaa", "HANGUL SYLLABLE GYULP");
+-   ("/xea/xb7/xab", "HANGUL SYLLABLE GYULH");
+-   ("/xea/xb7/xac", "HANGUL SYLLABLE GYUM");
+-   ("/xea/xb7/xad", "HANGUL SYLLABLE GYUB");
+-   ("/xea/xb7/xae", "HANGUL SYLLABLE GYUBS");
+-   ("/xea/xb7/xaf", "HANGUL SYLLABLE GYUS");
+-   ("/xea/xb7/xb0", "HANGUL SYLLABLE GYUSS");
+-   ("/xea/xb7/xb1", "HANGUL SYLLABLE GYUNG");
+-   ("/xea/xb7/xb2", "HANGUL SYLLABLE GYUJ");
+-   ("/xea/xb7/xb3", "HANGUL SYLLABLE GYUC");
+-   ("/xea/xb7/xb4", "HANGUL SYLLABLE GYUK");
+-   ("/xea/xb7/xb5", "HANGUL SYLLABLE GYUT");
+-   ("/xea/xb7/xb6", "HANGUL SYLLABLE GYUP");
+-   ("/xea/xb7/xb7", "HANGUL SYLLABLE GYUH");
+-   ("/xea/xb7/xb8", "HANGUL SYLLABLE GEU");
+-   ("/xea/xb7/xb9", "HANGUL SYLLABLE GEUG");
+-   ("/xea/xb7/xba", "HANGUL SYLLABLE GEUGG");
+-   ("/xea/xb7/xbb", "HANGUL SYLLABLE GEUGS");
+-   ("/xea/xb7/xbc", "HANGUL SYLLABLE GEUN");
+-   ("/xea/xb7/xbd", "HANGUL SYLLABLE GEUNI");
+-   ("/xea/xb7/xbe", "HANGUL SYLLABLE GEUNH");
+-   ("/xea/xb7/xbf", "HANGUL SYLLABLE GEUD");
+-   ("/xea/xb8/x80", "HANGUL SYLLABLE GEUL");
+-   ("/xea/xb8/x81", "HANGUL SYLLABLE GEULG");
+-   ("/xea/xb8/x82", "HANGUL SYLLABLE GEULM");
+-   ("/xea/xb8/x83", "HANGUL SYLLABLE GEULB");
+-   ("/xea/xb8/x84", "HANGUL SYLLABLE GEULS");
+-   ("/xea/xb8/x85", "HANGUL SYLLABLE GEULT");
+-   ("/xea/xb8/x86", "HANGUL SYLLABLE GEULP");
+-   ("/xea/xb8/x87", "HANGUL SYLLABLE GEULH");
+-   ("/xea/xb8/x88", "HANGUL SYLLABLE GEUM");
+-   ("/xea/xb8/x89", "HANGUL SYLLABLE GEUB");
+-   ("/xea/xb8/x8a", "HANGUL SYLLABLE GEUBS");
+-   ("/xea/xb8/x8b", "HANGUL SYLLABLE GEUS");
+-   ("/xea/xb8/x8c", "HANGUL SYLLABLE GEUSS");
+-   ("/xea/xb8/x8d", "HANGUL SYLLABLE GEUNG");
+-   ("/xea/xb8/x8e", "HANGUL SYLLABLE GEUJ");
+-   ("/xea/xb8/x8f", "HANGUL SYLLABLE GEUC");
+-   ("/xea/xb8/x90", "HANGUL SYLLABLE GEUK");
+-   ("/xea/xb8/x91", "HANGUL SYLLABLE GEUT");
+-   ("/xea/xb8/x92", "HANGUL SYLLABLE GEUP");
+-   ("/xea/xb8/x93", "HANGUL SYLLABLE GEUH");
+-   ("/xea/xb8/x94", "HANGUL SYLLABLE GYI");
+-   ("/xea/xb8/x95", "HANGUL SYLLABLE GYIG");
+-   ("/xea/xb8/x96", "HANGUL SYLLABLE GYIGG");
+-   ("/xea/xb8/x97", "HANGUL SYLLABLE GYIGS");
+-   ("/xea/xb8/x98", "HANGUL SYLLABLE GYIN");
+-   ("/xea/xb8/x99", "HANGUL SYLLABLE GYINI");
+-   ("/xea/xb8/x9a", "HANGUL SYLLABLE GYINH");
+-   ("/xea/xb8/x9b", "HANGUL SYLLABLE GYID");
+-   ("/xea/xb8/x9c", "HANGUL SYLLABLE GYIL");
+-   ("/xea/xb8/x9d", "HANGUL SYLLABLE GYILG");
+-   ("/xea/xb8/x9e", "HANGUL SYLLABLE GYILM");
+-   ("/xea/xb8/x9f", "HANGUL SYLLABLE GYILB");
+-   ("/xea/xb8/xa0", "HANGUL SYLLABLE GYILS");
+-   ("/xea/xb8/xa1", "HANGUL SYLLABLE GYILT");
+-   ("/xea/xb8/xa2", "HANGUL SYLLABLE GYILP");
+-   ("/xea/xb8/xa3", "HANGUL SYLLABLE GYILH");
+-   ("/xea/xb8/xa4", "HANGUL SYLLABLE GYIM");
+-   ("/xea/xb8/xa5", "HANGUL SYLLABLE GYIB");
+-   ("/xea/xb8/xa6", "HANGUL SYLLABLE GYIBS");
+-   ("/xea/xb8/xa7", "HANGUL SYLLABLE GYIS");
+-   ("/xea/xb8/xa8", "HANGUL SYLLABLE GYISS");
+-   ("/xea/xb8/xa9", "HANGUL SYLLABLE GYING");
+-   ("/xea/xb8/xaa", "HANGUL SYLLABLE GYIJ");
+-   ("/xea/xb8/xab", "HANGUL SYLLABLE GYIC");
+-   ("/xea/xb8/xac", "HANGUL SYLLABLE GYIK");
+-   ("/xea/xb8/xad", "HANGUL SYLLABLE GYIT");
+-   ("/xea/xb8/xae", "HANGUL SYLLABLE GYIP");
+-   ("/xea/xb8/xaf", "HANGUL SYLLABLE GYIH");
+-   ("/xea/xb8/xb0", "HANGUL SYLLABLE GI");
+-   ("/xea/xb8/xb1", "HANGUL SYLLABLE GIG");
+-   ("/xea/xb8/xb2", "HANGUL SYLLABLE GIGG");
+-   ("/xea/xb8/xb3", "HANGUL SYLLABLE GIGS");
+-   ("/xea/xb8/xb4", "HANGUL SYLLABLE GIN");
+-   ("/xea/xb8/xb5", "HANGUL SYLLABLE GINI");
+-   ("/xea/xb8/xb6", "HANGUL SYLLABLE GINH");
+-   ("/xea/xb8/xb7", "HANGUL SYLLABLE GID");
+-   ("/xea/xb8/xb8", "HANGUL SYLLABLE GIL");
+-   ("/xea/xb8/xb9", "HANGUL SYLLABLE GILG");
+-   ("/xea/xb8/xba", "HANGUL SYLLABLE GILM");
+-   ("/xea/xb8/xbb", "HANGUL SYLLABLE GILB");
+-   ("/xea/xb8/xbc", "HANGUL SYLLABLE GILS");
+-   ("/xea/xb8/xbd", "HANGUL SYLLABLE GILT");
+-   ("/xea/xb8/xbe", "HANGUL SYLLABLE GILP");
+-   ("/xea/xb8/xbf", "HANGUL SYLLABLE GILH");
+-   ("/xea/xb9/x80", "HANGUL SYLLABLE GIM");
+-   ("/xea/xb9/x81", "HANGUL SYLLABLE GIB");
+-   ("/xea/xb9/x82", "HANGUL SYLLABLE GIBS");
+-   ("/xea/xb9/x83", "HANGUL SYLLABLE GIS");
+-   ("/xea/xb9/x84", "HANGUL SYLLABLE GISS");
+-   ("/xea/xb9/x85", "HANGUL SYLLABLE GING");
+-   ("/xea/xb9/x86", "HANGUL SYLLABLE GIJ");
+-   ("/xea/xb9/x87", "HANGUL SYLLABLE GIC");
+-   ("/xea/xb9/x88", "HANGUL SYLLABLE GIK");
+-   ("/xea/xb9/x89", "HANGUL SYLLABLE GIT");
+-   ("/xea/xb9/x8a", "HANGUL SYLLABLE GIP");
+-   ("/xea/xb9/x8b", "HANGUL SYLLABLE GIH");
+-   ("/xea/xb9/x8c", "HANGUL SYLLABLE GGA");
+-   ("/xea/xb9/x8d", "HANGUL SYLLABLE GGAG");
+-   ("/xea/xb9/x8e", "HANGUL SYLLABLE GGAGG");
+-   ("/xea/xb9/x8f", "HANGUL SYLLABLE GGAGS");
+-   ("/xea/xb9/x90", "HANGUL SYLLABLE GGAN");
+-   ("/xea/xb9/x91", "HANGUL SYLLABLE GGANI");
+-   ("/xea/xb9/x92", "HANGUL SYLLABLE GGANH");
+-   ("/xea/xb9/x93", "HANGUL SYLLABLE GGAD");
+-   ("/xea/xb9/x94", "HANGUL SYLLABLE GGAL");
+-   ("/xea/xb9/x95", "HANGUL SYLLABLE GGALG");
+-   ("/xea/xb9/x96", "HANGUL SYLLABLE GGALM");
+-   ("/xea/xb9/x97", "HANGUL SYLLABLE GGALB");
+-   ("/xea/xb9/x98", "HANGUL SYLLABLE GGALS");
+-   ("/xea/xb9/x99", "HANGUL SYLLABLE GGALT");
+-   ("/xea/xb9/x9a", "HANGUL SYLLABLE GGALP");
+-   ("/xea/xb9/x9b", "HANGUL SYLLABLE GGALH");
+-   ("/xea/xb9/x9c", "HANGUL SYLLABLE GGAM");
+-   ("/xea/xb9/x9d", "HANGUL SYLLABLE GGAB");
+-   ("/xea/xb9/x9e", "HANGUL SYLLABLE GGABS");
+-   ("/xea/xb9/x9f", "HANGUL SYLLABLE GGAS");
+-   ("/xea/xb9/xa0", "HANGUL SYLLABLE GGASS");
+-   ("/xea/xb9/xa1", "HANGUL SYLLABLE GGANG");
+-   ("/xea/xb9/xa2", "HANGUL SYLLABLE GGAJ");
+-   ("/xea/xb9/xa3", "HANGUL SYLLABLE GGAC");
+-   ("/xea/xb9/xa4", "HANGUL SYLLABLE GGAK");
+-   ("/xea/xb9/xa5", "HANGUL SYLLABLE GGAT");
+-   ("/xea/xb9/xa6", "HANGUL SYLLABLE GGAP");
+-   ("/xea/xb9/xa7", "HANGUL SYLLABLE GGAH");
+-   ("/xea/xb9/xa8", "HANGUL SYLLABLE GGAE");
+-   ("/xea/xb9/xa9", "HANGUL SYLLABLE GGAEG");
+-   ("/xea/xb9/xaa", "HANGUL SYLLABLE GGAEGG");
+-   ("/xea/xb9/xab", "HANGUL SYLLABLE GGAEGS");
+-   ("/xea/xb9/xac", "HANGUL SYLLABLE GGAEN");
+-   ("/xea/xb9/xad", "HANGUL SYLLABLE GGAENI");
+-   ("/xea/xb9/xae", "HANGUL SYLLABLE GGAENH");
+-   ("/xea/xb9/xaf", "HANGUL SYLLABLE GGAED");
+-   ("/xea/xb9/xb0", "HANGUL SYLLABLE GGAEL");
+-   ("/xea/xb9/xb1", "HANGUL SYLLABLE GGAELG");
+-   ("/xea/xb9/xb2", "HANGUL SYLLABLE GGAELM");
+-   ("/xea/xb9/xb3", "HANGUL SYLLABLE GGAELB");
+-   ("/xea/xb9/xb4", "HANGUL SYLLABLE GGAELS");
+-   ("/xea/xb9/xb5", "HANGUL SYLLABLE GGAELT");
+-   ("/xea/xb9/xb6", "HANGUL SYLLABLE GGAELP");
+-   ("/xea/xb9/xb7", "HANGUL SYLLABLE GGAELH");
+-   ("/xea/xb9/xb8", "HANGUL SYLLABLE GGAEM");
+-   ("/xea/xb9/xb9", "HANGUL SYLLABLE GGAEB");
+-   ("/xea/xb9/xba", "HANGUL SYLLABLE GGAEBS");
+-   ("/xea/xb9/xbb", "HANGUL SYLLABLE GGAES");
+-   ("/xea/xb9/xbc", "HANGUL SYLLABLE GGAESS");
+-   ("/xea/xb9/xbd", "HANGUL SYLLABLE GGAENG");
+-   ("/xea/xb9/xbe", "HANGUL SYLLABLE GGAEJ");
+-   ("/xea/xb9/xbf", "HANGUL SYLLABLE GGAEC");
+-   ("/xea/xba/x80", "HANGUL SYLLABLE GGAEK");
+-   ("/xea/xba/x81", "HANGUL SYLLABLE GGAET");
+-   ("/xea/xba/x82", "HANGUL SYLLABLE GGAEP");
+-   ("/xea/xba/x83", "HANGUL SYLLABLE GGAEH");
+-   ("/xea/xba/x84", "HANGUL SYLLABLE GGYA");
+-   ("/xea/xba/x85", "HANGUL SYLLABLE GGYAG");
+-   ("/xea/xba/x86", "HANGUL SYLLABLE GGYAGG");
+-   ("/xea/xba/x87", "HANGUL SYLLABLE GGYAGS");
+-   ("/xea/xba/x88", "HANGUL SYLLABLE GGYAN");
+-   ("/xea/xba/x89", "HANGUL SYLLABLE GGYANI");
+-   ("/xea/xba/x8a", "HANGUL SYLLABLE GGYANH");
+-   ("/xea/xba/x8b", "HANGUL SYLLABLE GGYAD");
+-   ("/xea/xba/x8c", "HANGUL SYLLABLE GGYAL");
+-   ("/xea/xba/x8d", "HANGUL SYLLABLE GGYALG");
+-   ("/xea/xba/x8e", "HANGUL SYLLABLE GGYALM");
+-   ("/xea/xba/x8f", "HANGUL SYLLABLE GGYALB");
+-   ("/xea/xba/x90", "HANGUL SYLLABLE GGYALS");
+-   ("/xea/xba/x91", "HANGUL SYLLABLE GGYALT");
+-   ("/xea/xba/x92", "HANGUL SYLLABLE GGYALP");
+-   ("/xea/xba/x93", "HANGUL SYLLABLE GGYALH");
+-   ("/xea/xba/x94", "HANGUL SYLLABLE GGYAM");
+-   ("/xea/xba/x95", "HANGUL SYLLABLE GGYAB");
+-   ("/xea/xba/x96", "HANGUL SYLLABLE GGYABS");
+-   ("/xea/xba/x97", "HANGUL SYLLABLE GGYAS");
+-   ("/xea/xba/x98", "HANGUL SYLLABLE GGYASS");
+-   ("/xea/xba/x99", "HANGUL SYLLABLE GGYANG");
+-   ("/xea/xba/x9a", "HANGUL SYLLABLE GGYAJ");
+-   ("/xea/xba/x9b", "HANGUL SYLLABLE GGYAC");
+-   ("/xea/xba/x9c", "HANGUL SYLLABLE GGYAK");
+-   ("/xea/xba/x9d", "HANGUL SYLLABLE GGYAT");
+-   ("/xea/xba/x9e", "HANGUL SYLLABLE GGYAP");
+-   ("/xea/xba/x9f", "HANGUL SYLLABLE GGYAH");
+-   ("/xea/xba/xa0", "HANGUL SYLLABLE GGYAE");
+-   ("/xea/xba/xa1", "HANGUL SYLLABLE GGYAEG");
+-   ("/xea/xba/xa2", "HANGUL SYLLABLE GGYAEGG");
+-   ("/xea/xba/xa3", "HANGUL SYLLABLE GGYAEGS");
+-   ("/xea/xba/xa4", "HANGUL SYLLABLE GGYAEN");
+-   ("/xea/xba/xa5", "HANGUL SYLLABLE GGYAENI");
+-   ("/xea/xba/xa6", "HANGUL SYLLABLE GGYAENH");
+-   ("/xea/xba/xa7", "HANGUL SYLLABLE GGYAED");
+-   ("/xea/xba/xa8", "HANGUL SYLLABLE GGYAEL");
+-   ("/xea/xba/xa9", "HANGUL SYLLABLE GGYAELG");
+-   ("/xea/xba/xaa", "HANGUL SYLLABLE GGYAELM");
+-   ("/xea/xba/xab", "HANGUL SYLLABLE GGYAELB");
+-   ("/xea/xba/xac", "HANGUL SYLLABLE GGYAELS");
+-   ("/xea/xba/xad", "HANGUL SYLLABLE GGYAELT");
+-   ("/xea/xba/xae", "HANGUL SYLLABLE GGYAELP");
+-   ("/xea/xba/xaf", "HANGUL SYLLABLE GGYAELH");
+-   ("/xea/xba/xb0", "HANGUL SYLLABLE GGYAEM");
+-   ("/xea/xba/xb1", "HANGUL SYLLABLE GGYAEB");
+-   ("/xea/xba/xb2", "HANGUL SYLLABLE GGYAEBS");
+-   ("/xea/xba/xb3", "HANGUL SYLLABLE GGYAES");
+-   ("/xea/xba/xb4", "HANGUL SYLLABLE GGYAESS");
+-   ("/xea/xba/xb5", "HANGUL SYLLABLE GGYAENG");
+-   ("/xea/xba/xb6", "HANGUL SYLLABLE GGYAEJ");
+-   ("/xea/xba/xb7", "HANGUL SYLLABLE GGYAEC");
+-   ("/xea/xba/xb8", "HANGUL SYLLABLE GGYAEK");
+-   ("/xea/xba/xb9", "HANGUL SYLLABLE GGYAET");
+-   ("/xea/xba/xba", "HANGUL SYLLABLE GGYAEP");
+-   ("/xea/xba/xbb", "HANGUL SYLLABLE GGYAEH");
+-   ("/xea/xba/xbc", "HANGUL SYLLABLE GGEO");
+-   ("/xea/xba/xbd", "HANGUL SYLLABLE GGEOG");
+-   ("/xea/xba/xbe", "HANGUL SYLLABLE GGEOGG");
+-   ("/xea/xba/xbf", "HANGUL SYLLABLE GGEOGS");
+-   ("/xea/xbb/x80", "HANGUL SYLLABLE GGEON");
+-   ("/xea/xbb/x81", "HANGUL SYLLABLE GGEONI");
+-   ("/xea/xbb/x82", "HANGUL SYLLABLE GGEONH");
+-   ("/xea/xbb/x83", "HANGUL SYLLABLE GGEOD");
+-   ("/xea/xbb/x84", "HANGUL SYLLABLE GGEOL");
+-   ("/xea/xbb/x85", "HANGUL SYLLABLE GGEOLG");
+-   ("/xea/xbb/x86", "HANGUL SYLLABLE GGEOLM");
+-   ("/xea/xbb/x87", "HANGUL SYLLABLE GGEOLB");
+-   ("/xea/xbb/x88", "HANGUL SYLLABLE GGEOLS");
+-   ("/xea/xbb/x89", "HANGUL SYLLABLE GGEOLT");
+-   ("/xea/xbb/x8a", "HANGUL SYLLABLE GGEOLP");
+-   ("/xea/xbb/x8b", "HANGUL SYLLABLE GGEOLH");
+-   ("/xea/xbb/x8c", "HANGUL SYLLABLE GGEOM");
+-   ("/xea/xbb/x8d", "HANGUL SYLLABLE GGEOB");
+-   ("/xea/xbb/x8e", "HANGUL SYLLABLE GGEOBS");
+-   ("/xea/xbb/x8f", "HANGUL SYLLABLE GGEOS");
+-   ("/xea/xbb/x90", "HANGUL SYLLABLE GGEOSS");
+-   ("/xea/xbb/x91", "HANGUL SYLLABLE GGEONG");
+-   ("/xea/xbb/x92", "HANGUL SYLLABLE GGEOJ");
+-   ("/xea/xbb/x93", "HANGUL SYLLABLE GGEOC");
+-   ("/xea/xbb/x94", "HANGUL SYLLABLE GGEOK");
+-   ("/xea/xbb/x95", "HANGUL SYLLABLE GGEOT");
+-   ("/xea/xbb/x96", "HANGUL SYLLABLE GGEOP");
+-   ("/xea/xbb/x97", "HANGUL SYLLABLE GGEOH");
+-   ("/xea/xbb/x98", "HANGUL SYLLABLE GGE");
+-   ("/xea/xbb/x99", "HANGUL SYLLABLE GGEG");
+-   ("/xea/xbb/x9a", "HANGUL SYLLABLE GGEGG");
+-   ("/xea/xbb/x9b", "HANGUL SYLLABLE GGEGS");
+-   ("/xea/xbb/x9c", "HANGUL SYLLABLE GGEN");
+-   ("/xea/xbb/x9d", "HANGUL SYLLABLE GGENI");
+-   ("/xea/xbb/x9e", "HANGUL SYLLABLE GGENH");
+-   ("/xea/xbb/x9f", "HANGUL SYLLABLE GGED");
+-   ("/xea/xbb/xa0", "HANGUL SYLLABLE GGEL");
+-   ("/xea/xbb/xa1", "HANGUL SYLLABLE GGELG");
+-   ("/xea/xbb/xa2", "HANGUL SYLLABLE GGELM");
+-   ("/xea/xbb/xa3", "HANGUL SYLLABLE GGELB");
+-   ("/xea/xbb/xa4", "HANGUL SYLLABLE GGELS");
+-   ("/xea/xbb/xa5", "HANGUL SYLLABLE GGELT");
+-   ("/xea/xbb/xa6", "HANGUL SYLLABLE GGELP");
+-   ("/xea/xbb/xa7", "HANGUL SYLLABLE GGELH");
+-   ("/xea/xbb/xa8", "HANGUL SYLLABLE GGEM");
+-   ("/xea/xbb/xa9", "HANGUL SYLLABLE GGEB");
+-   ("/xea/xbb/xaa", "HANGUL SYLLABLE GGEBS");
+-   ("/xea/xbb/xab", "HANGUL SYLLABLE GGES");
+-   ("/xea/xbb/xac", "HANGUL SYLLABLE GGESS");
+-   ("/xea/xbb/xad", "HANGUL SYLLABLE GGENG");
+-   ("/xea/xbb/xae", "HANGUL SYLLABLE GGEJ");
+-   ("/xea/xbb/xaf", "HANGUL SYLLABLE GGEC");
+-   ("/xea/xbb/xb0", "HANGUL SYLLABLE GGEK");
+-   ("/xea/xbb/xb1", "HANGUL SYLLABLE GGET");
+-   ("/xea/xbb/xb2", "HANGUL SYLLABLE GGEP");
+-   ("/xea/xbb/xb3", "HANGUL SYLLABLE GGEH");
+-   ("/xea/xbb/xb4", "HANGUL SYLLABLE GGYEO");
+-   ("/xea/xbb/xb5", "HANGUL SYLLABLE GGYEOG");
+-   ("/xea/xbb/xb6", "HANGUL SYLLABLE GGYEOGG");
+-   ("/xea/xbb/xb7", "HANGUL SYLLABLE GGYEOGS");
+-   ("/xea/xbb/xb8", "HANGUL SYLLABLE GGYEON");
+-   ("/xea/xbb/xb9", "HANGUL SYLLABLE GGYEONI");
+-   ("/xea/xbb/xba", "HANGUL SYLLABLE GGYEONH");
+-   ("/xea/xbb/xbb", "HANGUL SYLLABLE GGYEOD");
+-   ("/xea/xbb/xbc", "HANGUL SYLLABLE GGYEOL");
+-   ("/xea/xbb/xbd", "HANGUL SYLLABLE GGYEOLG");
+-   ("/xea/xbb/xbe", "HANGUL SYLLABLE GGYEOLM");
+-   ("/xea/xbb/xbf", "HANGUL SYLLABLE GGYEOLB");
+-   ("/xea/xbc/x80", "HANGUL SYLLABLE GGYEOLS");
+-   ("/xea/xbc/x81", "HANGUL SYLLABLE GGYEOLT");
+-   ("/xea/xbc/x82", "HANGUL SYLLABLE GGYEOLP");
+-   ("/xea/xbc/x83", "HANGUL SYLLABLE GGYEOLH");
+-   ("/xea/xbc/x84", "HANGUL SYLLABLE GGYEOM");
+-   ("/xea/xbc/x85", "HANGUL SYLLABLE GGYEOB");
+-   ("/xea/xbc/x86", "HANGUL SYLLABLE GGYEOBS");
+-   ("/xea/xbc/x87", "HANGUL SYLLABLE GGYEOS");
+-   ("/xea/xbc/x88", "HANGUL SYLLABLE GGYEOSS");
+-   ("/xea/xbc/x89", "HANGUL SYLLABLE GGYEONG");
+-   ("/xea/xbc/x8a", "HANGUL SYLLABLE GGYEOJ");
+-   ("/xea/xbc/x8b", "HANGUL SYLLABLE GGYEOC");
+-   ("/xea/xbc/x8c", "HANGUL SYLLABLE GGYEOK");
+-   ("/xea/xbc/x8d", "HANGUL SYLLABLE GGYEOT");
+-   ("/xea/xbc/x8e", "HANGUL SYLLABLE GGYEOP");
+-   ("/xea/xbc/x8f", "HANGUL SYLLABLE GGYEOH");
+-   ("/xea/xbc/x90", "HANGUL SYLLABLE GGYE");
+-   ("/xea/xbc/x91", "HANGUL SYLLABLE GGYEG");
+-   ("/xea/xbc/x92", "HANGUL SYLLABLE GGYEGG");
+-   ("/xea/xbc/x93", "HANGUL SYLLABLE GGYEGS");
+-   ("/xea/xbc/x94", "HANGUL SYLLABLE GGYEN");
+-   ("/xea/xbc/x95", "HANGUL SYLLABLE GGYENI");
+-   ("/xea/xbc/x96", "HANGUL SYLLABLE GGYENH");
+-   ("/xea/xbc/x97", "HANGUL SYLLABLE GGYED");
+-   ("/xea/xbc/x98", "HANGUL SYLLABLE GGYEL");
+-   ("/xea/xbc/x99", "HANGUL SYLLABLE GGYELG");
+-   ("/xea/xbc/x9a", "HANGUL SYLLABLE GGYELM");
+-   ("/xea/xbc/x9b", "HANGUL SYLLABLE GGYELB");
+-   ("/xea/xbc/x9c", "HANGUL SYLLABLE GGYELS");
+-   ("/xea/xbc/x9d", "HANGUL SYLLABLE GGYELT");
+-   ("/xea/xbc/x9e", "HANGUL SYLLABLE GGYELP");
+-   ("/xea/xbc/x9f", "HANGUL SYLLABLE GGYELH");
+-   ("/xea/xbc/xa0", "HANGUL SYLLABLE GGYEM");
+-   ("/xea/xbc/xa1", "HANGUL SYLLABLE GGYEB");
+-   ("/xea/xbc/xa2", "HANGUL SYLLABLE GGYEBS");
+-   ("/xea/xbc/xa3", "HANGUL SYLLABLE GGYES");
+-   ("/xea/xbc/xa4", "HANGUL SYLLABLE GGYESS");
+-   ("/xea/xbc/xa5", "HANGUL SYLLABLE GGYENG");
+-   ("/xea/xbc/xa6", "HANGUL SYLLABLE GGYEJ");
+-   ("/xea/xbc/xa7", "HANGUL SYLLABLE GGYEC");
+-   ("/xea/xbc/xa8", "HANGUL SYLLABLE GGYEK");
+-   ("/xea/xbc/xa9", "HANGUL SYLLABLE GGYET");
+-   ("/xea/xbc/xaa", "HANGUL SYLLABLE GGYEP");
+-   ("/xea/xbc/xab", "HANGUL SYLLABLE GGYEH");
+-   ("/xea/xbc/xac", "HANGUL SYLLABLE GGO");
+-   ("/xea/xbc/xad", "HANGUL SYLLABLE GGOG");
+-   ("/xea/xbc/xae", "HANGUL SYLLABLE GGOGG");
+-   ("/xea/xbc/xaf", "HANGUL SYLLABLE GGOGS");
+-   ("/xea/xbc/xb0", "HANGUL SYLLABLE GGON");
+-   ("/xea/xbc/xb1", "HANGUL SYLLABLE GGONI");
+-   ("/xea/xbc/xb2", "HANGUL SYLLABLE GGONH");
+-   ("/xea/xbc/xb3", "HANGUL SYLLABLE GGOD");
+-   ("/xea/xbc/xb4", "HANGUL SYLLABLE GGOL");
+-   ("/xea/xbc/xb5", "HANGUL SYLLABLE GGOLG");
+-   ("/xea/xbc/xb6", "HANGUL SYLLABLE GGOLM");
+-   ("/xea/xbc/xb7", "HANGUL SYLLABLE GGOLB");
+-   ("/xea/xbc/xb8", "HANGUL SYLLABLE GGOLS");
+-   ("/xea/xbc/xb9", "HANGUL SYLLABLE GGOLT");
+-   ("/xea/xbc/xba", "HANGUL SYLLABLE GGOLP");
+-   ("/xea/xbc/xbb", "HANGUL SYLLABLE GGOLH");
+-   ("/xea/xbc/xbc", "HANGUL SYLLABLE GGOM");
+-   ("/xea/xbc/xbd", "HANGUL SYLLABLE GGOB");
+-   ("/xea/xbc/xbe", "HANGUL SYLLABLE GGOBS");
+-   ("/xea/xbc/xbf", "HANGUL SYLLABLE GGOS");
+-   ("/xea/xbd/x80", "HANGUL SYLLABLE GGOSS");
+-   ("/xea/xbd/x81", "HANGUL SYLLABLE GGONG");
+-   ("/xea/xbd/x82", "HANGUL SYLLABLE GGOJ");
+-   ("/xea/xbd/x83", "HANGUL SYLLABLE GGOC");
+-   ("/xea/xbd/x84", "HANGUL SYLLABLE GGOK");
+-   ("/xea/xbd/x85", "HANGUL SYLLABLE GGOT");
+-   ("/xea/xbd/x86", "HANGUL SYLLABLE GGOP");
+-   ("/xea/xbd/x87", "HANGUL SYLLABLE GGOH");
+-   ("/xea/xbd/x88", "HANGUL SYLLABLE GGWA");
+-   ("/xea/xbd/x89", "HANGUL SYLLABLE GGWAG");
+-   ("/xea/xbd/x8a", "HANGUL SYLLABLE GGWAGG");
+-   ("/xea/xbd/x8b", "HANGUL SYLLABLE GGWAGS");
+-   ("/xea/xbd/x8c", "HANGUL SYLLABLE GGWAN");
+-   ("/xea/xbd/x8d", "HANGUL SYLLABLE GGWANI");
+-   ("/xea/xbd/x8e", "HANGUL SYLLABLE GGWANH");
+-   ("/xea/xbd/x8f", "HANGUL SYLLABLE GGWAD");
+-   ("/xea/xbd/x90", "HANGUL SYLLABLE GGWAL");
+-   ("/xea/xbd/x91", "HANGUL SYLLABLE GGWALG");
+-   ("/xea/xbd/x92", "HANGUL SYLLABLE GGWALM");
+-   ("/xea/xbd/x93", "HANGUL SYLLABLE GGWALB");
+-   ("/xea/xbd/x94", "HANGUL SYLLABLE GGWALS");
+-   ("/xea/xbd/x95", "HANGUL SYLLABLE GGWALT");
+-   ("/xea/xbd/x96", "HANGUL SYLLABLE GGWALP");
+-   ("/xea/xbd/x97", "HANGUL SYLLABLE GGWALH");
+-   ("/xea/xbd/x98", "HANGUL SYLLABLE GGWAM");
+-   ("/xea/xbd/x99", "HANGUL SYLLABLE GGWAB");
+-   ("/xea/xbd/x9a", "HANGUL SYLLABLE GGWABS");
+-   ("/xea/xbd/x9b", "HANGUL SYLLABLE GGWAS");
+-   ("/xea/xbd/x9c", "HANGUL SYLLABLE GGWASS");
+-   ("/xea/xbd/x9d", "HANGUL SYLLABLE GGWANG");
+-   ("/xea/xbd/x9e", "HANGUL SYLLABLE GGWAJ");
+-   ("/xea/xbd/x9f", "HANGUL SYLLABLE GGWAC");
+-   ("/xea/xbd/xa0", "HANGUL SYLLABLE GGWAK");
+-   ("/xea/xbd/xa1", "HANGUL SYLLABLE GGWAT");
+-   ("/xea/xbd/xa2", "HANGUL SYLLABLE GGWAP");
+-   ("/xea/xbd/xa3", "HANGUL SYLLABLE GGWAH");
+-   ("/xea/xbd/xa4", "HANGUL SYLLABLE GGWAE");
+-   ("/xea/xbd/xa5", "HANGUL SYLLABLE GGWAEG");
+-   ("/xea/xbd/xa6", "HANGUL SYLLABLE GGWAEGG");
+-   ("/xea/xbd/xa7", "HANGUL SYLLABLE GGWAEGS");
+-   ("/xea/xbd/xa8", "HANGUL SYLLABLE GGWAEN");
+-   ("/xea/xbd/xa9", "HANGUL SYLLABLE GGWAENI");
+-   ("/xea/xbd/xaa", "HANGUL SYLLABLE GGWAENH");
+-   ("/xea/xbd/xab", "HANGUL SYLLABLE GGWAED");
+-   ("/xea/xbd/xac", "HANGUL SYLLABLE GGWAEL");
+-   ("/xea/xbd/xad", "HANGUL SYLLABLE GGWAELG");
+-   ("/xea/xbd/xae", "HANGUL SYLLABLE GGWAELM");
+-   ("/xea/xbd/xaf", "HANGUL SYLLABLE GGWAELB");
+-   ("/xea/xbd/xb0", "HANGUL SYLLABLE GGWAELS");
+-   ("/xea/xbd/xb1", "HANGUL SYLLABLE GGWAELT");
+-   ("/xea/xbd/xb2", "HANGUL SYLLABLE GGWAELP");
+-   ("/xea/xbd/xb3", "HANGUL SYLLABLE GGWAELH");
+-   ("/xea/xbd/xb4", "HANGUL SYLLABLE GGWAEM");
+-   ("/xea/xbd/xb5", "HANGUL SYLLABLE GGWAEB");
+-   ("/xea/xbd/xb6", "HANGUL SYLLABLE GGWAEBS");
+-   ("/xea/xbd/xb7", "HANGUL SYLLABLE GGWAES");
+-   ("/xea/xbd/xb8", "HANGUL SYLLABLE GGWAESS");
+-   ("/xea/xbd/xb9", "HANGUL SYLLABLE GGWAENG");
+-   ("/xea/xbd/xba", "HANGUL SYLLABLE GGWAEJ");
+-   ("/xea/xbd/xbb", "HANGUL SYLLABLE GGWAEC");
+-   ("/xea/xbd/xbc", "HANGUL SYLLABLE GGWAEK");
+-   ("/xea/xbd/xbd", "HANGUL SYLLABLE GGWAET");
+-   ("/xea/xbd/xbe", "HANGUL SYLLABLE GGWAEP");
+-   ("/xea/xbd/xbf", "HANGUL SYLLABLE GGWAEH");
+-   ("/xea/xbe/x80", "HANGUL SYLLABLE GGOE");
+-   ("/xea/xbe/x81", "HANGUL SYLLABLE GGOEG");
+-   ("/xea/xbe/x82", "HANGUL SYLLABLE GGOEGG");
+-   ("/xea/xbe/x83", "HANGUL SYLLABLE GGOEGS");
+-   ("/xea/xbe/x84", "HANGUL SYLLABLE GGOEN");
+-   ("/xea/xbe/x85", "HANGUL SYLLABLE GGOENI");
+-   ("/xea/xbe/x86", "HANGUL SYLLABLE GGOENH");
+-   ("/xea/xbe/x87", "HANGUL SYLLABLE GGOED");
+-   ("/xea/xbe/x88", "HANGUL SYLLABLE GGOEL");
+-   ("/xea/xbe/x89", "HANGUL SYLLABLE GGOELG");
+-   ("/xea/xbe/x8a", "HANGUL SYLLABLE GGOELM");
+-   ("/xea/xbe/x8b", "HANGUL SYLLABLE GGOELB");
+-   ("/xea/xbe/x8c", "HANGUL SYLLABLE GGOELS");
+-   ("/xea/xbe/x8d", "HANGUL SYLLABLE GGOELT");
+-   ("/xea/xbe/x8e", "HANGUL SYLLABLE GGOELP");
+-   ("/xea/xbe/x8f", "HANGUL SYLLABLE GGOELH");
+-   ("/xea/xbe/x90", "HANGUL SYLLABLE GGOEM");
+-   ("/xea/xbe/x91", "HANGUL SYLLABLE GGOEB");
+-   ("/xea/xbe/x92", "HANGUL SYLLABLE GGOEBS");
+-   ("/xea/xbe/x93", "HANGUL SYLLABLE GGOES");
+-   ("/xea/xbe/x94", "HANGUL SYLLABLE GGOESS");
+-   ("/xea/xbe/x95", "HANGUL SYLLABLE GGOENG");
+-   ("/xea/xbe/x96", "HANGUL SYLLABLE GGOEJ");
+-   ("/xea/xbe/x97", "HANGUL SYLLABLE GGOEC");
+-   ("/xea/xbe/x98", "HANGUL SYLLABLE GGOEK");
+-   ("/xea/xbe/x99", "HANGUL SYLLABLE GGOET");
+-   ("/xea/xbe/x9a", "HANGUL SYLLABLE GGOEP");
+-   ("/xea/xbe/x9b", "HANGUL SYLLABLE GGOEH");
+-   ("/xea/xbe/x9c", "HANGUL SYLLABLE GGYO");
+-   ("/xea/xbe/x9d", "HANGUL SYLLABLE GGYOG");
+-   ("/xea/xbe/x9e", "HANGUL SYLLABLE GGYOGG");
+-   ("/xea/xbe/x9f", "HANGUL SYLLABLE GGYOGS");
+-   ("/xea/xbe/xa0", "HANGUL SYLLABLE GGYON");
+-   ("/xea/xbe/xa1", "HANGUL SYLLABLE GGYONI");
+-   ("/xea/xbe/xa2", "HANGUL SYLLABLE GGYONH");
+-   ("/xea/xbe/xa3", "HANGUL SYLLABLE GGYOD");
+-   ("/xea/xbe/xa4", "HANGUL SYLLABLE GGYOL");
+-   ("/xea/xbe/xa5", "HANGUL SYLLABLE GGYOLG");
+-   ("/xea/xbe/xa6", "HANGUL SYLLABLE GGYOLM");
+-   ("/xea/xbe/xa7", "HANGUL SYLLABLE GGYOLB");
+-   ("/xea/xbe/xa8", "HANGUL SYLLABLE GGYOLS");
+-   ("/xea/xbe/xa9", "HANGUL SYLLABLE GGYOLT");
+-   ("/xea/xbe/xaa", "HANGUL SYLLABLE GGYOLP");
+-   ("/xea/xbe/xab", "HANGUL SYLLABLE GGYOLH");
+-   ("/xea/xbe/xac", "HANGUL SYLLABLE GGYOM");
+-   ("/xea/xbe/xad", "HANGUL SYLLABLE GGYOB");
+-   ("/xea/xbe/xae", "HANGUL SYLLABLE GGYOBS");
+-   ("/xea/xbe/xaf", "HANGUL SYLLABLE GGYOS");
+-   ("/xea/xbe/xb0", "HANGUL SYLLABLE GGYOSS");
+-   ("/xea/xbe/xb1", "HANGUL SYLLABLE GGYONG");
+-   ("/xea/xbe/xb2", "HANGUL SYLLABLE GGYOJ");
+-   ("/xea/xbe/xb3", "HANGUL SYLLABLE GGYOC");
+-   ("/xea/xbe/xb4", "HANGUL SYLLABLE GGYOK");
+-   ("/xea/xbe/xb5", "HANGUL SYLLABLE GGYOT");
+-   ("/xea/xbe/xb6", "HANGUL SYLLABLE GGYOP");
+-   ("/xea/xbe/xb7", "HANGUL SYLLABLE GGYOH");
+-   ("/xea/xbe/xb8", "HANGUL SYLLABLE GGU");
+-   ("/xea/xbe/xb9", "HANGUL SYLLABLE GGUG");
+-   ("/xea/xbe/xba", "HANGUL SYLLABLE GGUGG");
+-   ("/xea/xbe/xbb", "HANGUL SYLLABLE GGUGS");
+-   ("/xea/xbe/xbc", "HANGUL SYLLABLE GGUN");
+-   ("/xea/xbe/xbd", "HANGUL SYLLABLE GGUNI");
+-   ("/xea/xbe/xbe", "HANGUL SYLLABLE GGUNH");
+-   ("/xea/xbe/xbf", "HANGUL SYLLABLE GGUD");
+-   ("/xea/xbf/x80", "HANGUL SYLLABLE GGUL");
+-   ("/xea/xbf/x81", "HANGUL SYLLABLE GGULG");
+-   ("/xea/xbf/x82", "HANGUL SYLLABLE GGULM");
+-   ("/xea/xbf/x83", "HANGUL SYLLABLE GGULB");
+-   ("/xea/xbf/x84", "HANGUL SYLLABLE GGULS");
+-   ("/xea/xbf/x85", "HANGUL SYLLABLE GGULT");
+-   ("/xea/xbf/x86", "HANGUL SYLLABLE GGULP");
+-   ("/xea/xbf/x87", "HANGUL SYLLABLE GGULH");
+-   ("/xea/xbf/x88", "HANGUL SYLLABLE GGUM");
+-   ("/xea/xbf/x89", "HANGUL SYLLABLE GGUB");
+-   ("/xea/xbf/x8a", "HANGUL SYLLABLE GGUBS");
+-   ("/xea/xbf/x8b", "HANGUL SYLLABLE GGUS");
+-   ("/xea/xbf/x8c", "HANGUL SYLLABLE GGUSS");
+-   ("/xea/xbf/x8d", "HANGUL SYLLABLE GGUNG");
+-   ("/xea/xbf/x8e", "HANGUL SYLLABLE GGUJ");
+-   ("/xea/xbf/x8f", "HANGUL SYLLABLE GGUC");
+-   ("/xea/xbf/x90", "HANGUL SYLLABLE GGUK");
+-   ("/xea/xbf/x91", "HANGUL SYLLABLE GGUT");
+-   ("/xea/xbf/x92", "HANGUL SYLLABLE GGUP");
+-   ("/xea/xbf/x93", "HANGUL SYLLABLE GGUH");
+-   ("/xea/xbf/x94", "HANGUL SYLLABLE GGWEO");
+-   ("/xea/xbf/x95", "HANGUL SYLLABLE GGWEOG");
+-   ("/xea/xbf/x96", "HANGUL SYLLABLE GGWEOGG");
+-   ("/xea/xbf/x97", "HANGUL SYLLABLE GGWEOGS");
+-   ("/xea/xbf/x98", "HANGUL SYLLABLE GGWEON");
+-   ("/xea/xbf/x99", "HANGUL SYLLABLE GGWEONI");
+-   ("/xea/xbf/x9a", "HANGUL SYLLABLE GGWEONH");
+-   ("/xea/xbf/x9b", "HANGUL SYLLABLE GGWEOD");
+-   ("/xea/xbf/x9c", "HANGUL SYLLABLE GGWEOL");
+-   ("/xea/xbf/x9d", "HANGUL SYLLABLE GGWEOLG");
+-   ("/xea/xbf/x9e", "HANGUL SYLLABLE GGWEOLM");
+-   ("/xea/xbf/x9f", "HANGUL SYLLABLE GGWEOLB");
+-   ("/xea/xbf/xa0", "HANGUL SYLLABLE GGWEOLS");
+-   ("/xea/xbf/xa1", "HANGUL SYLLABLE GGWEOLT");
+-   ("/xea/xbf/xa2", "HANGUL SYLLABLE GGWEOLP");
+-   ("/xea/xbf/xa3", "HANGUL SYLLABLE GGWEOLH");
+-   ("/xea/xbf/xa4", "HANGUL SYLLABLE GGWEOM");
+-   ("/xea/xbf/xa5", "HANGUL SYLLABLE GGWEOB");
+-   ("/xea/xbf/xa6", "HANGUL SYLLABLE GGWEOBS");
+-   ("/xea/xbf/xa7", "HANGUL SYLLABLE GGWEOS");
+-   ("/xea/xbf/xa8", "HANGUL SYLLABLE GGWEOSS");
+-   ("/xea/xbf/xa9", "HANGUL SYLLABLE GGWEONG");
+-   ("/xea/xbf/xaa", "HANGUL SYLLABLE GGWEOJ");
+-   ("/xea/xbf/xab", "HANGUL SYLLABLE GGWEOC");
+-   ("/xea/xbf/xac", "HANGUL SYLLABLE GGWEOK");
+-   ("/xea/xbf/xad", "HANGUL SYLLABLE GGWEOT");
+-   ("/xea/xbf/xae", "HANGUL SYLLABLE GGWEOP");
+-   ("/xea/xbf/xaf", "HANGUL SYLLABLE GGWEOH");
+-   ("/xea/xbf/xb0", "HANGUL SYLLABLE GGWE");
+-   ("/xea/xbf/xb1", "HANGUL SYLLABLE GGWEG");
+-   ("/xea/xbf/xb2", "HANGUL SYLLABLE GGWEGG");
+-   ("/xea/xbf/xb3", "HANGUL SYLLABLE GGWEGS");
+-   ("/xea/xbf/xb4", "HANGUL SYLLABLE GGWEN");
+-   ("/xea/xbf/xb5", "HANGUL SYLLABLE GGWENI");
+-   ("/xea/xbf/xb6", "HANGUL SYLLABLE GGWENH");
+-   ("/xea/xbf/xb7", "HANGUL SYLLABLE GGWED");
+-   ("/xea/xbf/xb8", "HANGUL SYLLABLE GGWEL");
+-   ("/xea/xbf/xb9", "HANGUL SYLLABLE GGWELG");
+-   ("/xea/xbf/xba", "HANGUL SYLLABLE GGWELM");
+-   ("/xea/xbf/xbb", "HANGUL SYLLABLE GGWELB");
+-   ("/xea/xbf/xbc", "HANGUL SYLLABLE GGWELS");
+-   ("/xea/xbf/xbd", "HANGUL SYLLABLE GGWELT");
+-   ("/xea/xbf/xbe", "HANGUL SYLLABLE GGWELP");
+-   ("/xea/xbf/xbf", "HANGUL SYLLABLE GGWELH");
+-   ("/xeb/x80/x80", "HANGUL SYLLABLE GGWEM");
+-   ("/xeb/x80/x81", "HANGUL SYLLABLE GGWEB");
+-   ("/xeb/x80/x82", "HANGUL SYLLABLE GGWEBS");
+-   ("/xeb/x80/x83", "HANGUL SYLLABLE GGWES");
+-   ("/xeb/x80/x84", "HANGUL SYLLABLE GGWESS");
+-   ("/xeb/x80/x85", "HANGUL SYLLABLE GGWENG");
+-   ("/xeb/x80/x86", "HANGUL SYLLABLE GGWEJ");
+-   ("/xeb/x80/x87", "HANGUL SYLLABLE GGWEC");
+-   ("/xeb/x80/x88", "HANGUL SYLLABLE GGWEK");
+-   ("/xeb/x80/x89", "HANGUL SYLLABLE GGWET");
+-   ("/xeb/x80/x8a", "HANGUL SYLLABLE GGWEP");
+-   ("/xeb/x80/x8b", "HANGUL SYLLABLE GGWEH");
+-   ("/xeb/x80/x8c", "HANGUL SYLLABLE GGWI");
+-   ("/xeb/x80/x8d", "HANGUL SYLLABLE GGWIG");
+-   ("/xeb/x80/x8e", "HANGUL SYLLABLE GGWIGG");
+-   ("/xeb/x80/x8f", "HANGUL SYLLABLE GGWIGS");
+-   ("/xeb/x80/x90", "HANGUL SYLLABLE GGWIN");
+-   ("/xeb/x80/x91", "HANGUL SYLLABLE GGWINI");
+-   ("/xeb/x80/x92", "HANGUL SYLLABLE GGWINH");
+-   ("/xeb/x80/x93", "HANGUL SYLLABLE GGWID");
+-   ("/xeb/x80/x94", "HANGUL SYLLABLE GGWIL");
+-   ("/xeb/x80/x95", "HANGUL SYLLABLE GGWILG");
+-   ("/xeb/x80/x96", "HANGUL SYLLABLE GGWILM");
+-   ("/xeb/x80/x97", "HANGUL SYLLABLE GGWILB");
+-   ("/xeb/x80/x98", "HANGUL SYLLABLE GGWILS");
+-   ("/xeb/x80/x99", "HANGUL SYLLABLE GGWILT");
+-   ("/xeb/x80/x9a", "HANGUL SYLLABLE GGWILP");
+-   ("/xeb/x80/x9b", "HANGUL SYLLABLE GGWILH");
+-   ("/xeb/x80/x9c", "HANGUL SYLLABLE GGWIM");
+-   ("/xeb/x80/x9d", "HANGUL SYLLABLE GGWIB");
+-   ("/xeb/x80/x9e", "HANGUL SYLLABLE GGWIBS");
+-   ("/xeb/x80/x9f", "HANGUL SYLLABLE GGWIS");
+-   ("/xeb/x80/xa0", "HANGUL SYLLABLE GGWISS");
+-   ("/xeb/x80/xa1", "HANGUL SYLLABLE GGWING");
+-   ("/xeb/x80/xa2", "HANGUL SYLLABLE GGWIJ");
+-   ("/xeb/x80/xa3", "HANGUL SYLLABLE GGWIC");
+-   ("/xeb/x80/xa4", "HANGUL SYLLABLE GGWIK");
+-   ("/xeb/x80/xa5", "HANGUL SYLLABLE GGWIT");
+-   ("/xeb/x80/xa6", "HANGUL SYLLABLE GGWIP");
+-   ("/xeb/x80/xa7", "HANGUL SYLLABLE GGWIH");
+-   ("/xeb/x80/xa8", "HANGUL SYLLABLE GGYU");
+-   ("/xeb/x80/xa9", "HANGUL SYLLABLE GGYUG");
+-   ("/xeb/x80/xaa", "HANGUL SYLLABLE GGYUGG");
+-   ("/xeb/x80/xab", "HANGUL SYLLABLE GGYUGS");
+-   ("/xeb/x80/xac", "HANGUL SYLLABLE GGYUN");
+-   ("/xeb/x80/xad", "HANGUL SYLLABLE GGYUNI");
+-   ("/xeb/x80/xae", "HANGUL SYLLABLE GGYUNH");
+-   ("/xeb/x80/xaf", "HANGUL SYLLABLE GGYUD");
+-   ("/xeb/x80/xb0", "HANGUL SYLLABLE GGYUL");
+-   ("/xeb/x80/xb1", "HANGUL SYLLABLE GGYULG");
+-   ("/xeb/x80/xb2", "HANGUL SYLLABLE GGYULM");
+-   ("/xeb/x80/xb3", "HANGUL SYLLABLE GGYULB");
+-   ("/xeb/x80/xb4", "HANGUL SYLLABLE GGYULS");
+-   ("/xeb/x80/xb5", "HANGUL SYLLABLE GGYULT");
+-   ("/xeb/x80/xb6", "HANGUL SYLLABLE GGYULP");
+-   ("/xeb/x80/xb7", "HANGUL SYLLABLE GGYULH");
+-   ("/xeb/x80/xb8", "HANGUL SYLLABLE GGYUM");
+-   ("/xeb/x80/xb9", "HANGUL SYLLABLE GGYUB");
+-   ("/xeb/x80/xba", "HANGUL SYLLABLE GGYUBS");
+-   ("/xeb/x80/xbb", "HANGUL SYLLABLE GGYUS");
+-   ("/xeb/x80/xbc", "HANGUL SYLLABLE GGYUSS");
+-   ("/xeb/x80/xbd", "HANGUL SYLLABLE GGYUNG");
+-   ("/xeb/x80/xbe", "HANGUL SYLLABLE GGYUJ");
+-   ("/xeb/x80/xbf", "HANGUL SYLLABLE GGYUC");
+-   ("/xeb/x81/x80", "HANGUL SYLLABLE GGYUK");
+-   ("/xeb/x81/x81", "HANGUL SYLLABLE GGYUT");
+-   ("/xeb/x81/x82", "HANGUL SYLLABLE GGYUP");
+-   ("/xeb/x81/x83", "HANGUL SYLLABLE GGYUH");
+-   ("/xeb/x81/x84", "HANGUL SYLLABLE GGEU");
+-   ("/xeb/x81/x85", "HANGUL SYLLABLE GGEUG");
+-   ("/xeb/x81/x86", "HANGUL SYLLABLE GGEUGG");
+-   ("/xeb/x81/x87", "HANGUL SYLLABLE GGEUGS");
+-   ("/xeb/x81/x88", "HANGUL SYLLABLE GGEUN");
+-   ("/xeb/x81/x89", "HANGUL SYLLABLE GGEUNI");
+-   ("/xeb/x81/x8a", "HANGUL SYLLABLE GGEUNH");
+-   ("/xeb/x81/x8b", "HANGUL SYLLABLE GGEUD");
+-   ("/xeb/x81/x8c", "HANGUL SYLLABLE GGEUL");
+-   ("/xeb/x81/x8d", "HANGUL SYLLABLE GGEULG");
+-   ("/xeb/x81/x8e", "HANGUL SYLLABLE GGEULM");
+-   ("/xeb/x81/x8f", "HANGUL SYLLABLE GGEULB");
+-   ("/xeb/x81/x90", "HANGUL SYLLABLE GGEULS");
+-   ("/xeb/x81/x91", "HANGUL SYLLABLE GGEULT");
+-   ("/xeb/x81/x92", "HANGUL SYLLABLE GGEULP");
+-   ("/xeb/x81/x93", "HANGUL SYLLABLE GGEULH");
+-   ("/xeb/x81/x94", "HANGUL SYLLABLE GGEUM");
+-   ("/xeb/x81/x95", "HANGUL SYLLABLE GGEUB");
+-   ("/xeb/x81/x96", "HANGUL SYLLABLE GGEUBS");
+-   ("/xeb/x81/x97", "HANGUL SYLLABLE GGEUS");
+-   ("/xeb/x81/x98", "HANGUL SYLLABLE GGEUSS");
+-   ("/xeb/x81/x99", "HANGUL SYLLABLE GGEUNG");
+-   ("/xeb/x81/x9a", "HANGUL SYLLABLE GGEUJ");
+-   ("/xeb/x81/x9b", "HANGUL SYLLABLE GGEUC");
+-   ("/xeb/x81/x9c", "HANGUL SYLLABLE GGEUK");
+-   ("/xeb/x81/x9d", "HANGUL SYLLABLE GGEUT");
+-   ("/xeb/x81/x9e", "HANGUL SYLLABLE GGEUP");
+-   ("/xeb/x81/x9f", "HANGUL SYLLABLE GGEUH");
+-   ("/xeb/x81/xa0", "HANGUL SYLLABLE GGYI");
+-   ("/xeb/x81/xa1", "HANGUL SYLLABLE GGYIG");
+-   ("/xeb/x81/xa2", "HANGUL SYLLABLE GGYIGG");
+-   ("/xeb/x81/xa3", "HANGUL SYLLABLE GGYIGS");
+-   ("/xeb/x81/xa4", "HANGUL SYLLABLE GGYIN");
+-   ("/xeb/x81/xa5", "HANGUL SYLLABLE GGYINI");
+-   ("/xeb/x81/xa6", "HANGUL SYLLABLE GGYINH");
+-   ("/xeb/x81/xa7", "HANGUL SYLLABLE GGYID");
+-   ("/xeb/x81/xa8", "HANGUL SYLLABLE GGYIL");
+-   ("/xeb/x81/xa9", "HANGUL SYLLABLE GGYILG");
+-   ("/xeb/x81/xaa", "HANGUL SYLLABLE GGYILM");
+-   ("/xeb/x81/xab", "HANGUL SYLLABLE GGYILB");
+-   ("/xeb/x81/xac", "HANGUL SYLLABLE GGYILS");
+-   ("/xeb/x81/xad", "HANGUL SYLLABLE GGYILT");
+-   ("/xeb/x81/xae", "HANGUL SYLLABLE GGYILP");
+-   ("/xeb/x81/xaf", "HANGUL SYLLABLE GGYILH");
+-   ("/xeb/x81/xb0", "HANGUL SYLLABLE GGYIM");
+-   ("/xeb/x81/xb1", "HANGUL SYLLABLE GGYIB");
+-   ("/xeb/x81/xb2", "HANGUL SYLLABLE GGYIBS");
+-   ("/xeb/x81/xb3", "HANGUL SYLLABLE GGYIS");
+-   ("/xeb/x81/xb4", "HANGUL SYLLABLE GGYISS");
+-   ("/xeb/x81/xb5", "HANGUL SYLLABLE GGYING");
+-   ("/xeb/x81/xb6", "HANGUL SYLLABLE GGYIJ");
+-   ("/xeb/x81/xb7", "HANGUL SYLLABLE GGYIC");
+-   ("/xeb/x81/xb8", "HANGUL SYLLABLE GGYIK");
+-   ("/xeb/x81/xb9", "HANGUL SYLLABLE GGYIT");
+-   ("/xeb/x81/xba", "HANGUL SYLLABLE GGYIP");
+-   ("/xeb/x81/xbb", "HANGUL SYLLABLE GGYIH");
+-   ("/xeb/x81/xbc", "HANGUL SYLLABLE GGI");
+-   ("/xeb/x81/xbd", "HANGUL SYLLABLE GGIG");
+-   ("/xeb/x81/xbe", "HANGUL SYLLABLE GGIGG");
+-   ("/xeb/x81/xbf", "HANGUL SYLLABLE GGIGS");
+-   ("/xeb/x82/x80", "HANGUL SYLLABLE GGIN");
+-   ("/xeb/x82/x81", "HANGUL SYLLABLE GGINI");
+-   ("/xeb/x82/x82", "HANGUL SYLLABLE GGINH");
+-   ("/xeb/x82/x83", "HANGUL SYLLABLE GGID");
+-   ("/xeb/x82/x84", "HANGUL SYLLABLE GGIL");
+-   ("/xeb/x82/x85", "HANGUL SYLLABLE GGILG");
+-   ("/xeb/x82/x86", "HANGUL SYLLABLE GGILM");
+-   ("/xeb/x82/x87", "HANGUL SYLLABLE GGILB");
+-   ("/xeb/x82/x88", "HANGUL SYLLABLE GGILS");
+-   ("/xeb/x82/x89", "HANGUL SYLLABLE GGILT");
+-   ("/xeb/x82/x8a", "HANGUL SYLLABLE GGILP");
+-   ("/xeb/x82/x8b", "HANGUL SYLLABLE GGILH");
+-   ("/xeb/x82/x8c", "HANGUL SYLLABLE GGIM");
+-   ("/xeb/x82/x8d", "HANGUL SYLLABLE GGIB");
+-   ("/xeb/x82/x8e", "HANGUL SYLLABLE GGIBS");
+-   ("/xeb/x82/x8f", "HANGUL SYLLABLE GGIS");
+-   ("/xeb/x82/x90", "HANGUL SYLLABLE GGISS");
+-   ("/xeb/x82/x91", "HANGUL SYLLABLE GGING");
+-   ("/xeb/x82/x92", "HANGUL SYLLABLE GGIJ");
+-   ("/xeb/x82/x93", "HANGUL SYLLABLE GGIC");
+-   ("/xeb/x82/x94", "HANGUL SYLLABLE GGIK");
+-   ("/xeb/x82/x95", "HANGUL SYLLABLE GGIT");
+-   ("/xeb/x82/x96", "HANGUL SYLLABLE GGIP");
+-   ("/xeb/x82/x97", "HANGUL SYLLABLE GGIH");
+-   ("/xeb/x82/x98", "HANGUL SYLLABLE NA");
+-   ("/xeb/x82/x99", "HANGUL SYLLABLE NAG");
+-   ("/xeb/x82/x9a", "HANGUL SYLLABLE NAGG");
+-   ("/xeb/x82/x9b", "HANGUL SYLLABLE NAGS");
+-   ("/xeb/x82/x9c", "HANGUL SYLLABLE NAN");
+-   ("/xeb/x82/x9d", "HANGUL SYLLABLE NANI");
+-   ("/xeb/x82/x9e", "HANGUL SYLLABLE NANH");
+-   ("/xeb/x82/x9f", "HANGUL SYLLABLE NAD");
+-   ("/xeb/x82/xa0", "HANGUL SYLLABLE NAL");
+-   ("/xeb/x82/xa1", "HANGUL SYLLABLE NALG");
+-   ("/xeb/x82/xa2", "HANGUL SYLLABLE NALM");
+-   ("/xeb/x82/xa3", "HANGUL SYLLABLE NALB");
+-   ("/xeb/x82/xa4", "HANGUL SYLLABLE NALS");
+-   ("/xeb/x82/xa5", "HANGUL SYLLABLE NALT");
+-   ("/xeb/x82/xa6", "HANGUL SYLLABLE NALP");
+-   ("/xeb/x82/xa7", "HANGUL SYLLABLE NALH");
+-   ("/xeb/x82/xa8", "HANGUL SYLLABLE NAM");
+-   ("/xeb/x82/xa9", "HANGUL SYLLABLE NAB");
+-   ("/xeb/x82/xaa", "HANGUL SYLLABLE NABS");
+-   ("/xeb/x82/xab", "HANGUL SYLLABLE NAS");
+-   ("/xeb/x82/xac", "HANGUL SYLLABLE NASS");
+-   ("/xeb/x82/xad", "HANGUL SYLLABLE NANG");
+-   ("/xeb/x82/xae", "HANGUL SYLLABLE NAJ");
+-   ("/xeb/x82/xaf", "HANGUL SYLLABLE NAC");
+-   ("/xeb/x82/xb0", "HANGUL SYLLABLE NAK");
+-   ("/xeb/x82/xb1", "HANGUL SYLLABLE NAT");
+-   ("/xeb/x82/xb2", "HANGUL SYLLABLE NAP");
+-   ("/xeb/x82/xb3", "HANGUL SYLLABLE NAH");
+-   ("/xeb/x82/xb4", "HANGUL SYLLABLE NAE");
+-   ("/xeb/x82/xb5", "HANGUL SYLLABLE NAEG");
+-   ("/xeb/x82/xb6", "HANGUL SYLLABLE NAEGG");
+-   ("/xeb/x82/xb7", "HANGUL SYLLABLE NAEGS");
+-   ("/xeb/x82/xb8", "HANGUL SYLLABLE NAEN");
+-   ("/xeb/x82/xb9", "HANGUL SYLLABLE NAENI");
+-   ("/xeb/x82/xba", "HANGUL SYLLABLE NAENH");
+-   ("/xeb/x82/xbb", "HANGUL SYLLABLE NAED");
+-   ("/xeb/x82/xbc", "HANGUL SYLLABLE NAEL");
+-   ("/xeb/x82/xbd", "HANGUL SYLLABLE NAELG");
+-   ("/xeb/x82/xbe", "HANGUL SYLLABLE NAELM");
+-   ("/xeb/x82/xbf", "HANGUL SYLLABLE NAELB");
+-   ("/xeb/x83/x80", "HANGUL SYLLABLE NAELS");
+-   ("/xeb/x83/x81", "HANGUL SYLLABLE NAELT");
+-   ("/xeb/x83/x82", "HANGUL SYLLABLE NAELP");
+-   ("/xeb/x83/x83", "HANGUL SYLLABLE NAELH");
+-   ("/xeb/x83/x84", "HANGUL SYLLABLE NAEM");
+-   ("/xeb/x83/x85", "HANGUL SYLLABLE NAEB");
+-   ("/xeb/x83/x86", "HANGUL SYLLABLE NAEBS");
+-   ("/xeb/x83/x87", "HANGUL SYLLABLE NAES");
+-   ("/xeb/x83/x88", "HANGUL SYLLABLE NAESS");
+-   ("/xeb/x83/x89", "HANGUL SYLLABLE NAENG");
+-   ("/xeb/x83/x8a", "HANGUL SYLLABLE NAEJ");
+-   ("/xeb/x83/x8b", "HANGUL SYLLABLE NAEC");
+-   ("/xeb/x83/x8c", "HANGUL SYLLABLE NAEK");
+-   ("/xeb/x83/x8d", "HANGUL SYLLABLE NAET");
+-   ("/xeb/x83/x8e", "HANGUL SYLLABLE NAEP");
+-   ("/xeb/x83/x8f", "HANGUL SYLLABLE NAEH");
+-   ("/xeb/x83/x90", "HANGUL SYLLABLE NYA");
+-   ("/xeb/x83/x91", "HANGUL SYLLABLE NYAG");
+-   ("/xeb/x83/x92", "HANGUL SYLLABLE NYAGG");
+-   ("/xeb/x83/x93", "HANGUL SYLLABLE NYAGS");
+-   ("/xeb/x83/x94", "HANGUL SYLLABLE NYAN");
+-   ("/xeb/x83/x95", "HANGUL SYLLABLE NYANI");
+-   ("/xeb/x83/x96", "HANGUL SYLLABLE NYANH");
+-   ("/xeb/x83/x97", "HANGUL SYLLABLE NYAD");
+-   ("/xeb/x83/x98", "HANGUL SYLLABLE NYAL");
+-   ("/xeb/x83/x99", "HANGUL SYLLABLE NYALG");
+-   ("/xeb/x83/x9a", "HANGUL SYLLABLE NYALM");
+-   ("/xeb/x83/x9b", "HANGUL SYLLABLE NYALB");
+-   ("/xeb/x83/x9c", "HANGUL SYLLABLE NYALS");
+-   ("/xeb/x83/x9d", "HANGUL SYLLABLE NYALT");
+-   ("/xeb/x83/x9e", "HANGUL SYLLABLE NYALP");
+-   ("/xeb/x83/x9f", "HANGUL SYLLABLE NYALH");
+-   ("/xeb/x83/xa0", "HANGUL SYLLABLE NYAM");
+-   ("/xeb/x83/xa1", "HANGUL SYLLABLE NYAB");
+-   ("/xeb/x83/xa2", "HANGUL SYLLABLE NYABS");
+-   ("/xeb/x83/xa3", "HANGUL SYLLABLE NYAS");
+-   ("/xeb/x83/xa4", "HANGUL SYLLABLE NYASS");
+-   ("/xeb/x83/xa5", "HANGUL SYLLABLE NYANG");
+-   ("/xeb/x83/xa6", "HANGUL SYLLABLE NYAJ");
+-   ("/xeb/x83/xa7", "HANGUL SYLLABLE NYAC");
+-   ("/xeb/x83/xa8", "HANGUL SYLLABLE NYAK");
+-   ("/xeb/x83/xa9", "HANGUL SYLLABLE NYAT");
+-   ("/xeb/x83/xaa", "HANGUL SYLLABLE NYAP");
+-   ("/xeb/x83/xab", "HANGUL SYLLABLE NYAH");
+-   ("/xeb/x83/xac", "HANGUL SYLLABLE NYAE");
+-   ("/xeb/x83/xad", "HANGUL SYLLABLE NYAEG");
+-   ("/xeb/x83/xae", "HANGUL SYLLABLE NYAEGG");
+-   ("/xeb/x83/xaf", "HANGUL SYLLABLE NYAEGS");
+-   ("/xeb/x83/xb0", "HANGUL SYLLABLE NYAEN");
+-   ("/xeb/x83/xb1", "HANGUL SYLLABLE NYAENI");
+-   ("/xeb/x83/xb2", "HANGUL SYLLABLE NYAENH");
+-   ("/xeb/x83/xb3", "HANGUL SYLLABLE NYAED");
+-   ("/xeb/x83/xb4", "HANGUL SYLLABLE NYAEL");
+-   ("/xeb/x83/xb5", "HANGUL SYLLABLE NYAELG");
+-   ("/xeb/x83/xb6", "HANGUL SYLLABLE NYAELM");
+-   ("/xeb/x83/xb7", "HANGUL SYLLABLE NYAELB");
+-   ("/xeb/x83/xb8", "HANGUL SYLLABLE NYAELS");
+-   ("/xeb/x83/xb9", "HANGUL SYLLABLE NYAELT");
+-   ("/xeb/x83/xba", "HANGUL SYLLABLE NYAELP");
+-   ("/xeb/x83/xbb", "HANGUL SYLLABLE NYAELH");
+-   ("/xeb/x83/xbc", "HANGUL SYLLABLE NYAEM");
+-   ("/xeb/x83/xbd", "HANGUL SYLLABLE NYAEB");
+-   ("/xeb/x83/xbe", "HANGUL SYLLABLE NYAEBS");
+-   ("/xeb/x83/xbf", "HANGUL SYLLABLE NYAES");
+-   ("/xeb/x84/x80", "HANGUL SYLLABLE NYAESS");
+-   ("/xeb/x84/x81", "HANGUL SYLLABLE NYAENG");
+-   ("/xeb/x84/x82", "HANGUL SYLLABLE NYAEJ");
+-   ("/xeb/x84/x83", "HANGUL SYLLABLE NYAEC");
+-   ("/xeb/x84/x84", "HANGUL SYLLABLE NYAEK");
+-   ("/xeb/x84/x85", "HANGUL SYLLABLE NYAET");
+-   ("/xeb/x84/x86", "HANGUL SYLLABLE NYAEP");
+-   ("/xeb/x84/x87", "HANGUL SYLLABLE NYAEH");
+-   ("/xeb/x84/x88", "HANGUL SYLLABLE NEO");
+-   ("/xeb/x84/x89", "HANGUL SYLLABLE NEOG");
+-   ("/xeb/x84/x8a", "HANGUL SYLLABLE NEOGG");
+-   ("/xeb/x84/x8b", "HANGUL SYLLABLE NEOGS");
+-   ("/xeb/x84/x8c", "HANGUL SYLLABLE NEON");
+-   ("/xeb/x84/x8d", "HANGUL SYLLABLE NEONI");
+-   ("/xeb/x84/x8e", "HANGUL SYLLABLE NEONH");
+-   ("/xeb/x84/x8f", "HANGUL SYLLABLE NEOD");
+-   ("/xeb/x84/x90", "HANGUL SYLLABLE NEOL");
+-   ("/xeb/x84/x91", "HANGUL SYLLABLE NEOLG");
+-   ("/xeb/x84/x92", "HANGUL SYLLABLE NEOLM");
+-   ("/xeb/x84/x93", "HANGUL SYLLABLE NEOLB");
+-   ("/xeb/x84/x94", "HANGUL SYLLABLE NEOLS");
+-   ("/xeb/x84/x95", "HANGUL SYLLABLE NEOLT");
+-   ("/xeb/x84/x96", "HANGUL SYLLABLE NEOLP");
+-   ("/xeb/x84/x97", "HANGUL SYLLABLE NEOLH");
+-   ("/xeb/x84/x98", "HANGUL SYLLABLE NEOM");
+-   ("/xeb/x84/x99", "HANGUL SYLLABLE NEOB");
+-   ("/xeb/x84/x9a", "HANGUL SYLLABLE NEOBS");
+-   ("/xeb/x84/x9b", "HANGUL SYLLABLE NEOS");
+-   ("/xeb/x84/x9c", "HANGUL SYLLABLE NEOSS");
+-   ("/xeb/x84/x9d", "HANGUL SYLLABLE NEONG");
+-   ("/xeb/x84/x9e", "HANGUL SYLLABLE NEOJ");
+-   ("/xeb/x84/x9f", "HANGUL SYLLABLE NEOC");
+-   ("/xeb/x84/xa0", "HANGUL SYLLABLE NEOK");
+-   ("/xeb/x84/xa1", "HANGUL SYLLABLE NEOT");
+-   ("/xeb/x84/xa2", "HANGUL SYLLABLE NEOP");
+-   ("/xeb/x84/xa3", "HANGUL SYLLABLE NEOH");
+-   ("/xeb/x84/xa4", "HANGUL SYLLABLE NE");
+-   ("/xeb/x84/xa5", "HANGUL SYLLABLE NEG");
+-   ("/xeb/x84/xa6", "HANGUL SYLLABLE NEGG");
+-   ("/xeb/x84/xa7", "HANGUL SYLLABLE NEGS");
+-   ("/xeb/x84/xa8", "HANGUL SYLLABLE NEN");
+-   ("/xeb/x84/xa9", "HANGUL SYLLABLE NENI");
+-   ("/xeb/x84/xaa", "HANGUL SYLLABLE NENH");
+-   ("/xeb/x84/xab", "HANGUL SYLLABLE NED");
+-   ("/xeb/x84/xac", "HANGUL SYLLABLE NEL");
+-   ("/xeb/x84/xad", "HANGUL SYLLABLE NELG");
+-   ("/xeb/x84/xae", "HANGUL SYLLABLE NELM");
+-   ("/xeb/x84/xaf", "HANGUL SYLLABLE NELB");
+-   ("/xeb/x84/xb0", "HANGUL SYLLABLE NELS");
+-   ("/xeb/x84/xb1", "HANGUL SYLLABLE NELT");
+-   ("/xeb/x84/xb2", "HANGUL SYLLABLE NELP");
+-   ("/xeb/x84/xb3", "HANGUL SYLLABLE NELH");
+-   ("/xeb/x84/xb4", "HANGUL SYLLABLE NEM");
+-   ("/xeb/x84/xb5", "HANGUL SYLLABLE NEB");
+-   ("/xeb/x84/xb6", "HANGUL SYLLABLE NEBS");
+-   ("/xeb/x84/xb7", "HANGUL SYLLABLE NES");
+-   ("/xeb/x84/xb8", "HANGUL SYLLABLE NESS");
+-   ("/xeb/x84/xb9", "HANGUL SYLLABLE NENG");
+-   ("/xeb/x84/xba", "HANGUL SYLLABLE NEJ");
+-   ("/xeb/x84/xbb", "HANGUL SYLLABLE NEC");
+-   ("/xeb/x84/xbc", "HANGUL SYLLABLE NEK");
+-   ("/xeb/x84/xbd", "HANGUL SYLLABLE NET");
+-   ("/xeb/x84/xbe", "HANGUL SYLLABLE NEP");
+-   ("/xeb/x84/xbf", "HANGUL SYLLABLE NEH");
+-   ("/xeb/x85/x80", "HANGUL SYLLABLE NYEO");
+-   ("/xeb/x85/x81", "HANGUL SYLLABLE NYEOG");
+-   ("/xeb/x85/x82", "HANGUL SYLLABLE NYEOGG");
+-   ("/xeb/x85/x83", "HANGUL SYLLABLE NYEOGS");
+-   ("/xeb/x85/x84", "HANGUL SYLLABLE NYEON");
+-   ("/xeb/x85/x85", "HANGUL SYLLABLE NYEONI");
+-   ("/xeb/x85/x86", "HANGUL SYLLABLE NYEONH");
+-   ("/xeb/x85/x87", "HANGUL SYLLABLE NYEOD");
+-   ("/xeb/x85/x88", "HANGUL SYLLABLE NYEOL");
+-   ("/xeb/x85/x89", "HANGUL SYLLABLE NYEOLG");
+-   ("/xeb/x85/x8a", "HANGUL SYLLABLE NYEOLM");
+-   ("/xeb/x85/x8b", "HANGUL SYLLABLE NYEOLB");
+-   ("/xeb/x85/x8c", "HANGUL SYLLABLE NYEOLS");
+-   ("/xeb/x85/x8d", "HANGUL SYLLABLE NYEOLT");
+-   ("/xeb/x85/x8e", "HANGUL SYLLABLE NYEOLP");
+-   ("/xeb/x85/x8f", "HANGUL SYLLABLE NYEOLH");
+-   ("/xeb/x85/x90", "HANGUL SYLLABLE NYEOM");
+-   ("/xeb/x85/x91", "HANGUL SYLLABLE NYEOB");
+-   ("/xeb/x85/x92", "HANGUL SYLLABLE NYEOBS");
+-   ("/xeb/x85/x93", "HANGUL SYLLABLE NYEOS");
+-   ("/xeb/x85/x94", "HANGUL SYLLABLE NYEOSS");
+-   ("/xeb/x85/x95", "HANGUL SYLLABLE NYEONG");
+-   ("/xeb/x85/x96", "HANGUL SYLLABLE NYEOJ");
+-   ("/xeb/x85/x97", "HANGUL SYLLABLE NYEOC");
+-   ("/xeb/x85/x98", "HANGUL SYLLABLE NYEOK");
+-   ("/xeb/x85/x99", "HANGUL SYLLABLE NYEOT");
+-   ("/xeb/x85/x9a", "HANGUL SYLLABLE NYEOP");
+-   ("/xeb/x85/x9b", "HANGUL SYLLABLE NYEOH");
+-   ("/xeb/x85/x9c", "HANGUL SYLLABLE NYE");
+-   ("/xeb/x85/x9d", "HANGUL SYLLABLE NYEG");
+-   ("/xeb/x85/x9e", "HANGUL SYLLABLE NYEGG");
+-   ("/xeb/x85/x9f", "HANGUL SYLLABLE NYEGS");
+-   ("/xeb/x85/xa0", "HANGUL SYLLABLE NYEN");
+-   ("/xeb/x85/xa1", "HANGUL SYLLABLE NYENI");
+-   ("/xeb/x85/xa2", "HANGUL SYLLABLE NYENH");
+-   ("/xeb/x85/xa3", "HANGUL SYLLABLE NYED");
+-   ("/xeb/x85/xa4", "HANGUL SYLLABLE NYEL");
+-   ("/xeb/x85/xa5", "HANGUL SYLLABLE NYELG");
+-   ("/xeb/x85/xa6", "HANGUL SYLLABLE NYELM");
+-   ("/xeb/x85/xa7", "HANGUL SYLLABLE NYELB");
+-   ("/xeb/x85/xa8", "HANGUL SYLLABLE NYELS");
+-   ("/xeb/x85/xa9", "HANGUL SYLLABLE NYELT");
+-   ("/xeb/x85/xaa", "HANGUL SYLLABLE NYELP");
+-   ("/xeb/x85/xab", "HANGUL SYLLABLE NYELH");
+-   ("/xeb/x85/xac", "HANGUL SYLLABLE NYEM");
+-   ("/xeb/x85/xad", "HANGUL SYLLABLE NYEB");
+-   ("/xeb/x85/xae", "HANGUL SYLLABLE NYEBS");
+-   ("/xeb/x85/xaf", "HANGUL SYLLABLE NYES");
+-   ("/xeb/x85/xb0", "HANGUL SYLLABLE NYESS");
+-   ("/xeb/x85/xb1", "HANGUL SYLLABLE NYENG");
+-   ("/xeb/x85/xb2", "HANGUL SYLLABLE NYEJ");
+-   ("/xeb/x85/xb3", "HANGUL SYLLABLE NYEC");
+-   ("/xeb/x85/xb4", "HANGUL SYLLABLE NYEK");
+-   ("/xeb/x85/xb5", "HANGUL SYLLABLE NYET");
+-   ("/xeb/x85/xb6", "HANGUL SYLLABLE NYEP");
+-   ("/xeb/x85/xb7", "HANGUL SYLLABLE NYEH");
+-   ("/xeb/x85/xb8", "HANGUL SYLLABLE NO");
+-   ("/xeb/x85/xb9", "HANGUL SYLLABLE NOG");
+-   ("/xeb/x85/xba", "HANGUL SYLLABLE NOGG");
+-   ("/xeb/x85/xbb", "HANGUL SYLLABLE NOGS");
+-   ("/xeb/x85/xbc", "HANGUL SYLLABLE NON");
+-   ("/xeb/x85/xbd", "HANGUL SYLLABLE NONI");
+-   ("/xeb/x85/xbe", "HANGUL SYLLABLE NONH");
+-   ("/xeb/x85/xbf", "HANGUL SYLLABLE NOD");
+-   ("/xeb/x86/x80", "HANGUL SYLLABLE NOL");
+-   ("/xeb/x86/x81", "HANGUL SYLLABLE NOLG");
+-   ("/xeb/x86/x82", "HANGUL SYLLABLE NOLM");
+-   ("/xeb/x86/x83", "HANGUL SYLLABLE NOLB");
+-   ("/xeb/x86/x84", "HANGUL SYLLABLE NOLS");
+-   ("/xeb/x86/x85", "HANGUL SYLLABLE NOLT");
+-   ("/xeb/x86/x86", "HANGUL SYLLABLE NOLP");
+-   ("/xeb/x86/x87", "HANGUL SYLLABLE NOLH");
+-   ("/xeb/x86/x88", "HANGUL SYLLABLE NOM");
+-   ("/xeb/x86/x89", "HANGUL SYLLABLE NOB");
+-   ("/xeb/x86/x8a", "HANGUL SYLLABLE NOBS");
+-   ("/xeb/x86/x8b", "HANGUL SYLLABLE NOS");
+-   ("/xeb/x86/x8c", "HANGUL SYLLABLE NOSS");
+-   ("/xeb/x86/x8d", "HANGUL SYLLABLE NONG");
+-   ("/xeb/x86/x8e", "HANGUL SYLLABLE NOJ");
+-   ("/xeb/x86/x8f", "HANGUL SYLLABLE NOC");
+-   ("/xeb/x86/x90", "HANGUL SYLLABLE NOK");
+-   ("/xeb/x86/x91", "HANGUL SYLLABLE NOT");
+-   ("/xeb/x86/x92", "HANGUL SYLLABLE NOP");
+-   ("/xeb/x86/x93", "HANGUL SYLLABLE NOH");
+-   ("/xeb/x86/x94", "HANGUL SYLLABLE NWA");
+-   ("/xeb/x86/x95", "HANGUL SYLLABLE NWAG");
+-   ("/xeb/x86/x96", "HANGUL SYLLABLE NWAGG");
+-   ("/xeb/x86/x97", "HANGUL SYLLABLE NWAGS");
+-   ("/xeb/x86/x98", "HANGUL SYLLABLE NWAN");
+-   ("/xeb/x86/x99", "HANGUL SYLLABLE NWANI");
+-   ("/xeb/x86/x9a", "HANGUL SYLLABLE NWANH");
+-   ("/xeb/x86/x9b", "HANGUL SYLLABLE NWAD");
+-   ("/xeb/x86/x9c", "HANGUL SYLLABLE NWAL");
+-   ("/xeb/x86/x9d", "HANGUL SYLLABLE NWALG");
+-   ("/xeb/x86/x9e", "HANGUL SYLLABLE NWALM");
+-   ("/xeb/x86/x9f", "HANGUL SYLLABLE NWALB");
+-   ("/xeb/x86/xa0", "HANGUL SYLLABLE NWALS");
+-   ("/xeb/x86/xa1", "HANGUL SYLLABLE NWALT");
+-   ("/xeb/x86/xa2", "HANGUL SYLLABLE NWALP");
+-   ("/xeb/x86/xa3", "HANGUL SYLLABLE NWALH");
+-   ("/xeb/x86/xa4", "HANGUL SYLLABLE NWAM");
+-   ("/xeb/x86/xa5", "HANGUL SYLLABLE NWAB");
+-   ("/xeb/x86/xa6", "HANGUL SYLLABLE NWABS");
+-   ("/xeb/x86/xa7", "HANGUL SYLLABLE NWAS");
+-   ("/xeb/x86/xa8", "HANGUL SYLLABLE NWASS");
+-   ("/xeb/x86/xa9", "HANGUL SYLLABLE NWANG");
+-   ("/xeb/x86/xaa", "HANGUL SYLLABLE NWAJ");
+-   ("/xeb/x86/xab", "HANGUL SYLLABLE NWAC");
+-   ("/xeb/x86/xac", "HANGUL SYLLABLE NWAK");
+-   ("/xeb/x86/xad", "HANGUL SYLLABLE NWAT");
+-   ("/xeb/x86/xae", "HANGUL SYLLABLE NWAP");
+-   ("/xeb/x86/xaf", "HANGUL SYLLABLE NWAH");
+-   ("/xeb/x86/xb0", "HANGUL SYLLABLE NWAE");
+-   ("/xeb/x86/xb1", "HANGUL SYLLABLE NWAEG");
+-   ("/xeb/x86/xb2", "HANGUL SYLLABLE NWAEGG");
+-   ("/xeb/x86/xb3", "HANGUL SYLLABLE NWAEGS");
+-   ("/xeb/x86/xb4", "HANGUL SYLLABLE NWAEN");
+-   ("/xeb/x86/xb5", "HANGUL SYLLABLE NWAENI");
+-   ("/xeb/x86/xb6", "HANGUL SYLLABLE NWAENH");
+-   ("/xeb/x86/xb7", "HANGUL SYLLABLE NWAED");
+-   ("/xeb/x86/xb8", "HANGUL SYLLABLE NWAEL");
+-   ("/xeb/x86/xb9", "HANGUL SYLLABLE NWAELG");
+-   ("/xeb/x86/xba", "HANGUL SYLLABLE NWAELM");
+-   ("/xeb/x86/xbb", "HANGUL SYLLABLE NWAELB");
+-   ("/xeb/x86/xbc", "HANGUL SYLLABLE NWAELS");
+-   ("/xeb/x86/xbd", "HANGUL SYLLABLE NWAELT");
+-   ("/xeb/x86/xbe", "HANGUL SYLLABLE NWAELP");
+-   ("/xeb/x86/xbf", "HANGUL SYLLABLE NWAELH");
+-   ("/xeb/x87/x80", "HANGUL SYLLABLE NWAEM");
+-   ("/xeb/x87/x81", "HANGUL SYLLABLE NWAEB");
+-   ("/xeb/x87/x82", "HANGUL SYLLABLE NWAEBS");
+-   ("/xeb/x87/x83", "HANGUL SYLLABLE NWAES");
+-   ("/xeb/x87/x84", "HANGUL SYLLABLE NWAESS");
+-   ("/xeb/x87/x85", "HANGUL SYLLABLE NWAENG");
+-   ("/xeb/x87/x86", "HANGUL SYLLABLE NWAEJ");
+-   ("/xeb/x87/x87", "HANGUL SYLLABLE NWAEC");
+-   ("/xeb/x87/x88", "HANGUL SYLLABLE NWAEK");
+-   ("/xeb/x87/x89", "HANGUL SYLLABLE NWAET");
+-   ("/xeb/x87/x8a", "HANGUL SYLLABLE NWAEP");
+-   ("/xeb/x87/x8b", "HANGUL SYLLABLE NWAEH");
+-   ("/xeb/x87/x8c", "HANGUL SYLLABLE NOE");
+-   ("/xeb/x87/x8d", "HANGUL SYLLABLE NOEG");
+-   ("/xeb/x87/x8e", "HANGUL SYLLABLE NOEGG");
+-   ("/xeb/x87/x8f", "HANGUL SYLLABLE NOEGS");
+-   ("/xeb/x87/x90", "HANGUL SYLLABLE NOEN");
+-   ("/xeb/x87/x91", "HANGUL SYLLABLE NOENI");
+-   ("/xeb/x87/x92", "HANGUL SYLLABLE NOENH");
+-   ("/xeb/x87/x93", "HANGUL SYLLABLE NOED");
+-   ("/xeb/x87/x94", "HANGUL SYLLABLE NOEL");
+-   ("/xeb/x87/x95", "HANGUL SYLLABLE NOELG");
+-   ("/xeb/x87/x96", "HANGUL SYLLABLE NOELM");
+-   ("/xeb/x87/x97", "HANGUL SYLLABLE NOELB");
+-   ("/xeb/x87/x98", "HANGUL SYLLABLE NOELS");
+-   ("/xeb/x87/x99", "HANGUL SYLLABLE NOELT");
+-   ("/xeb/x87/x9a", "HANGUL SYLLABLE NOELP");
+-   ("/xeb/x87/x9b", "HANGUL SYLLABLE NOELH");
+-   ("/xeb/x87/x9c", "HANGUL SYLLABLE NOEM");
+-   ("/xeb/x87/x9d", "HANGUL SYLLABLE NOEB");
+-   ("/xeb/x87/x9e", "HANGUL SYLLABLE NOEBS");
+-   ("/xeb/x87/x9f", "HANGUL SYLLABLE NOES");
+-   ("/xeb/x87/xa0", "HANGUL SYLLABLE NOESS");
+-   ("/xeb/x87/xa1", "HANGUL SYLLABLE NOENG");
+-   ("/xeb/x87/xa2", "HANGUL SYLLABLE NOEJ");
+-   ("/xeb/x87/xa3", "HANGUL SYLLABLE NOEC");
+-   ("/xeb/x87/xa4", "HANGUL SYLLABLE NOEK");
+-   ("/xeb/x87/xa5", "HANGUL SYLLABLE NOET");
+-   ("/xeb/x87/xa6", "HANGUL SYLLABLE NOEP");
+-   ("/xeb/x87/xa7", "HANGUL SYLLABLE NOEH");
+-   ("/xeb/x87/xa8", "HANGUL SYLLABLE NYO");
+-   ("/xeb/x87/xa9", "HANGUL SYLLABLE NYOG");
+-   ("/xeb/x87/xaa", "HANGUL SYLLABLE NYOGG");
+-   ("/xeb/x87/xab", "HANGUL SYLLABLE NYOGS");
+-   ("/xeb/x87/xac", "HANGUL SYLLABLE NYON");
+-   ("/xeb/x87/xad", "HANGUL SYLLABLE NYONI");
+-   ("/xeb/x87/xae", "HANGUL SYLLABLE NYONH");
+-   ("/xeb/x87/xaf", "HANGUL SYLLABLE NYOD");
+-   ("/xeb/x87/xb0", "HANGUL SYLLABLE NYOL");
+-   ("/xeb/x87/xb1", "HANGUL SYLLABLE NYOLG");
+-   ("/xeb/x87/xb2", "HANGUL SYLLABLE NYOLM");
+-   ("/xeb/x87/xb3", "HANGUL SYLLABLE NYOLB");
+-   ("/xeb/x87/xb4", "HANGUL SYLLABLE NYOLS");
+-   ("/xeb/x87/xb5", "HANGUL SYLLABLE NYOLT");
+-   ("/xeb/x87/xb6", "HANGUL SYLLABLE NYOLP");
+-   ("/xeb/x87/xb7", "HANGUL SYLLABLE NYOLH");
+-   ("/xeb/x87/xb8", "HANGUL SYLLABLE NYOM");
+-   ("/xeb/x87/xb9", "HANGUL SYLLABLE NYOB");
+-   ("/xeb/x87/xba", "HANGUL SYLLABLE NYOBS");
+-   ("/xeb/x87/xbb", "HANGUL SYLLABLE NYOS");
+-   ("/xeb/x87/xbc", "HANGUL SYLLABLE NYOSS");
+-   ("/xeb/x87/xbd", "HANGUL SYLLABLE NYONG");
+-   ("/xeb/x87/xbe", "HANGUL SYLLABLE NYOJ");
+-   ("/xeb/x87/xbf", "HANGUL SYLLABLE NYOC");
+-   ("/xeb/x88/x80", "HANGUL SYLLABLE NYOK");
+-   ("/xeb/x88/x81", "HANGUL SYLLABLE NYOT");
+-   ("/xeb/x88/x82", "HANGUL SYLLABLE NYOP");
+-   ("/xeb/x88/x83", "HANGUL SYLLABLE NYOH");
+-   ("/xeb/x88/x84", "HANGUL SYLLABLE NU");
+-   ("/xeb/x88/x85", "HANGUL SYLLABLE NUG");
+-   ("/xeb/x88/x86", "HANGUL SYLLABLE NUGG");
+-   ("/xeb/x88/x87", "HANGUL SYLLABLE NUGS");
+-   ("/xeb/x88/x88", "HANGUL SYLLABLE NUN");
+-   ("/xeb/x88/x89", "HANGUL SYLLABLE NUNI");
+-   ("/xeb/x88/x8a", "HANGUL SYLLABLE NUNH");
+-   ("/xeb/x88/x8b", "HANGUL SYLLABLE NUD");
+-   ("/xeb/x88/x8c", "HANGUL SYLLABLE NUL");
+-   ("/xeb/x88/x8d", "HANGUL SYLLABLE NULG");
+-   ("/xeb/x88/x8e", "HANGUL SYLLABLE NULM");
+-   ("/xeb/x88/x8f", "HANGUL SYLLABLE NULB");
+-   ("/xeb/x88/x90", "HANGUL SYLLABLE NULS");
+-   ("/xeb/x88/x91", "HANGUL SYLLABLE NULT");
+-   ("/xeb/x88/x92", "HANGUL SYLLABLE NULP");
+-   ("/xeb/x88/x93", "HANGUL SYLLABLE NULH");
+-   ("/xeb/x88/x94", "HANGUL SYLLABLE NUM");
+-   ("/xeb/x88/x95", "HANGUL SYLLABLE NUB");
+-   ("/xeb/x88/x96", "HANGUL SYLLABLE NUBS");
+-   ("/xeb/x88/x97", "HANGUL SYLLABLE NUS");
+-   ("/xeb/x88/x98", "HANGUL SYLLABLE NUSS");
+-   ("/xeb/x88/x99", "HANGUL SYLLABLE NUNG");
+-   ("/xeb/x88/x9a", "HANGUL SYLLABLE NUJ");
+-   ("/xeb/x88/x9b", "HANGUL SYLLABLE NUC");
+-   ("/xeb/x88/x9c", "HANGUL SYLLABLE NUK");
+-   ("/xeb/x88/x9d", "HANGUL SYLLABLE NUT");
+-   ("/xeb/x88/x9e", "HANGUL SYLLABLE NUP");
+-   ("/xeb/x88/x9f", "HANGUL SYLLABLE NUH");
+-   ("/xeb/x88/xa0", "HANGUL SYLLABLE NWEO");
+-   ("/xeb/x88/xa1", "HANGUL SYLLABLE NWEOG");
+-   ("/xeb/x88/xa2", "HANGUL SYLLABLE NWEOGG");
+-   ("/xeb/x88/xa3", "HANGUL SYLLABLE NWEOGS");
+-   ("/xeb/x88/xa4", "HANGUL SYLLABLE NWEON");
+-   ("/xeb/x88/xa5", "HANGUL SYLLABLE NWEONI");
+-   ("/xeb/x88/xa6", "HANGUL SYLLABLE NWEONH");
+-   ("/xeb/x88/xa7", "HANGUL SYLLABLE NWEOD");
+-   ("/xeb/x88/xa8", "HANGUL SYLLABLE NWEOL");
+-   ("/xeb/x88/xa9", "HANGUL SYLLABLE NWEOLG");
+-   ("/xeb/x88/xaa", "HANGUL SYLLABLE NWEOLM");
+-   ("/xeb/x88/xab", "HANGUL SYLLABLE NWEOLB");
+-   ("/xeb/x88/xac", "HANGUL SYLLABLE NWEOLS");
+-   ("/xeb/x88/xad", "HANGUL SYLLABLE NWEOLT");
+-   ("/xeb/x88/xae", "HANGUL SYLLABLE NWEOLP");
+-   ("/xeb/x88/xaf", "HANGUL SYLLABLE NWEOLH");
+-   ("/xeb/x88/xb0", "HANGUL SYLLABLE NWEOM");
+-   ("/xeb/x88/xb1", "HANGUL SYLLABLE NWEOB");
+-   ("/xeb/x88/xb2", "HANGUL SYLLABLE NWEOBS");
+-   ("/xeb/x88/xb3", "HANGUL SYLLABLE NWEOS");
+-   ("/xeb/x88/xb4", "HANGUL SYLLABLE NWEOSS");
+-   ("/xeb/x88/xb5", "HANGUL SYLLABLE NWEONG");
+-   ("/xeb/x88/xb6", "HANGUL SYLLABLE NWEOJ");
+-   ("/xeb/x88/xb7", "HANGUL SYLLABLE NWEOC");
+-   ("/xeb/x88/xb8", "HANGUL SYLLABLE NWEOK");
+-   ("/xeb/x88/xb9", "HANGUL SYLLABLE NWEOT");
+-   ("/xeb/x88/xba", "HANGUL SYLLABLE NWEOP");
+-   ("/xeb/x88/xbb", "HANGUL SYLLABLE NWEOH");
+-   ("/xeb/x88/xbc", "HANGUL SYLLABLE NWE");
+-   ("/xeb/x88/xbd", "HANGUL SYLLABLE NWEG");
+-   ("/xeb/x88/xbe", "HANGUL SYLLABLE NWEGG");
+-   ("/xeb/x88/xbf", "HANGUL SYLLABLE NWEGS");
+-   ("/xeb/x89/x80", "HANGUL SYLLABLE NWEN");
+-   ("/xeb/x89/x81", "HANGUL SYLLABLE NWENI");
+-   ("/xeb/x89/x82", "HANGUL SYLLABLE NWENH");
+-   ("/xeb/x89/x83", "HANGUL SYLLABLE NWED");
+-   ("/xeb/x89/x84", "HANGUL SYLLABLE NWEL");
+-   ("/xeb/x89/x85", "HANGUL SYLLABLE NWELG");
+-   ("/xeb/x89/x86", "HANGUL SYLLABLE NWELM");
+-   ("/xeb/x89/x87", "HANGUL SYLLABLE NWELB");
+-   ("/xeb/x89/x88", "HANGUL SYLLABLE NWELS");
+-   ("/xeb/x89/x89", "HANGUL SYLLABLE NWELT");
+-   ("/xeb/x89/x8a", "HANGUL SYLLABLE NWELP");
+-   ("/xeb/x89/x8b", "HANGUL SYLLABLE NWELH");
+-   ("/xeb/x89/x8c", "HANGUL SYLLABLE NWEM");
+-   ("/xeb/x89/x8d", "HANGUL SYLLABLE NWEB");
+-   ("/xeb/x89/x8e", "HANGUL SYLLABLE NWEBS");
+-   ("/xeb/x89/x8f", "HANGUL SYLLABLE NWES");
+-   ("/xeb/x89/x90", "HANGUL SYLLABLE NWESS");
+-   ("/xeb/x89/x91", "HANGUL SYLLABLE NWENG");
+-   ("/xeb/x89/x92", "HANGUL SYLLABLE NWEJ");
+-   ("/xeb/x89/x93", "HANGUL SYLLABLE NWEC");
+-   ("/xeb/x89/x94", "HANGUL SYLLABLE NWEK");
+-   ("/xeb/x89/x95", "HANGUL SYLLABLE NWET");
+-   ("/xeb/x89/x96", "HANGUL SYLLABLE NWEP");
+-   ("/xeb/x89/x97", "HANGUL SYLLABLE NWEH");
+-   ("/xeb/x89/x98", "HANGUL SYLLABLE NWI");
+-   ("/xeb/x89/x99", "HANGUL SYLLABLE NWIG");
+-   ("/xeb/x89/x9a", "HANGUL SYLLABLE NWIGG");
+-   ("/xeb/x89/x9b", "HANGUL SYLLABLE NWIGS");
+-   ("/xeb/x89/x9c", "HANGUL SYLLABLE NWIN");
+-   ("/xeb/x89/x9d", "HANGUL SYLLABLE NWINI");
+-   ("/xeb/x89/x9e", "HANGUL SYLLABLE NWINH");
+-   ("/xeb/x89/x9f", "HANGUL SYLLABLE NWID");
+-   ("/xeb/x89/xa0", "HANGUL SYLLABLE NWIL");
+-   ("/xeb/x89/xa1", "HANGUL SYLLABLE NWILG");
+-   ("/xeb/x89/xa2", "HANGUL SYLLABLE NWILM");
+-   ("/xeb/x89/xa3", "HANGUL SYLLABLE NWILB");
+-   ("/xeb/x89/xa4", "HANGUL SYLLABLE NWILS");
+-   ("/xeb/x89/xa5", "HANGUL SYLLABLE NWILT");
+-   ("/xeb/x89/xa6", "HANGUL SYLLABLE NWILP");
+-   ("/xeb/x89/xa7", "HANGUL SYLLABLE NWILH");
+-   ("/xeb/x89/xa8", "HANGUL SYLLABLE NWIM");
+-   ("/xeb/x89/xa9", "HANGUL SYLLABLE NWIB");
+-   ("/xeb/x89/xaa", "HANGUL SYLLABLE NWIBS");
+-   ("/xeb/x89/xab", "HANGUL SYLLABLE NWIS");
+-   ("/xeb/x89/xac", "HANGUL SYLLABLE NWISS");
+-   ("/xeb/x89/xad", "HANGUL SYLLABLE NWING");
+-   ("/xeb/x89/xae", "HANGUL SYLLABLE NWIJ");
+-   ("/xeb/x89/xaf", "HANGUL SYLLABLE NWIC");
+-   ("/xeb/x89/xb0", "HANGUL SYLLABLE NWIK");
+-   ("/xeb/x89/xb1", "HANGUL SYLLABLE NWIT");
+-   ("/xeb/x89/xb2", "HANGUL SYLLABLE NWIP");
+-   ("/xeb/x89/xb3", "HANGUL SYLLABLE NWIH");
+-   ("/xeb/x89/xb4", "HANGUL SYLLABLE NYU");
+-   ("/xeb/x89/xb5", "HANGUL SYLLABLE NYUG");
+-   ("/xeb/x89/xb6", "HANGUL SYLLABLE NYUGG");
+-   ("/xeb/x89/xb7", "HANGUL SYLLABLE NYUGS");
+-   ("/xeb/x89/xb8", "HANGUL SYLLABLE NYUN");
+-   ("/xeb/x89/xb9", "HANGUL SYLLABLE NYUNI");
+-   ("/xeb/x89/xba", "HANGUL SYLLABLE NYUNH");
+-   ("/xeb/x89/xbb", "HANGUL SYLLABLE NYUD");
+-   ("/xeb/x89/xbc", "HANGUL SYLLABLE NYUL");
+-   ("/xeb/x89/xbd", "HANGUL SYLLABLE NYULG");
+-   ("/xeb/x89/xbe", "HANGUL SYLLABLE NYULM");
+-   ("/xeb/x89/xbf", "HANGUL SYLLABLE NYULB");
+-   ("/xeb/x8a/x80", "HANGUL SYLLABLE NYULS");
+-   ("/xeb/x8a/x81", "HANGUL SYLLABLE NYULT");
+-   ("/xeb/x8a/x82", "HANGUL SYLLABLE NYULP");
+-   ("/xeb/x8a/x83", "HANGUL SYLLABLE NYULH");
+-   ("/xeb/x8a/x84", "HANGUL SYLLABLE NYUM");
+-   ("/xeb/x8a/x85", "HANGUL SYLLABLE NYUB");
+-   ("/xeb/x8a/x86", "HANGUL SYLLABLE NYUBS");
+-   ("/xeb/x8a/x87", "HANGUL SYLLABLE NYUS");
+-   ("/xeb/x8a/x88", "HANGUL SYLLABLE NYUSS");
+-   ("/xeb/x8a/x89", "HANGUL SYLLABLE NYUNG");
+-   ("/xeb/x8a/x8a", "HANGUL SYLLABLE NYUJ");
+-   ("/xeb/x8a/x8b", "HANGUL SYLLABLE NYUC");
+-   ("/xeb/x8a/x8c", "HANGUL SYLLABLE NYUK");
+-   ("/xeb/x8a/x8d", "HANGUL SYLLABLE NYUT");
+-   ("/xeb/x8a/x8e", "HANGUL SYLLABLE NYUP");
+-   ("/xeb/x8a/x8f", "HANGUL SYLLABLE NYUH");
+-   ("/xeb/x8a/x90", "HANGUL SYLLABLE NEU");
+-   ("/xeb/x8a/x91", "HANGUL SYLLABLE NEUG");
+-   ("/xeb/x8a/x92", "HANGUL SYLLABLE NEUGG");
+-   ("/xeb/x8a/x93", "HANGUL SYLLABLE NEUGS");
+-   ("/xeb/x8a/x94", "HANGUL SYLLABLE NEUN");
+-   ("/xeb/x8a/x95", "HANGUL SYLLABLE NEUNI");
+-   ("/xeb/x8a/x96", "HANGUL SYLLABLE NEUNH");
+-   ("/xeb/x8a/x97", "HANGUL SYLLABLE NEUD");
+-   ("/xeb/x8a/x98", "HANGUL SYLLABLE NEUL");
+-   ("/xeb/x8a/x99", "HANGUL SYLLABLE NEULG");
+-   ("/xeb/x8a/x9a", "HANGUL SYLLABLE NEULM");
+-   ("/xeb/x8a/x9b", "HANGUL SYLLABLE NEULB");
+-   ("/xeb/x8a/x9c", "HANGUL SYLLABLE NEULS");
+-   ("/xeb/x8a/x9d", "HANGUL SYLLABLE NEULT");
+-   ("/xeb/x8a/x9e", "HANGUL SYLLABLE NEULP");
+-   ("/xeb/x8a/x9f", "HANGUL SYLLABLE NEULH");
+-   ("/xeb/x8a/xa0", "HANGUL SYLLABLE NEUM");
+-   ("/xeb/x8a/xa1", "HANGUL SYLLABLE NEUB");
+-   ("/xeb/x8a/xa2", "HANGUL SYLLABLE NEUBS");
+-   ("/xeb/x8a/xa3", "HANGUL SYLLABLE NEUS");
+-   ("/xeb/x8a/xa4", "HANGUL SYLLABLE NEUSS");
+-   ("/xeb/x8a/xa5", "HANGUL SYLLABLE NEUNG");
+-   ("/xeb/x8a/xa6", "HANGUL SYLLABLE NEUJ");
+-   ("/xeb/x8a/xa7", "HANGUL SYLLABLE NEUC");
+-   ("/xeb/x8a/xa8", "HANGUL SYLLABLE NEUK");
+-   ("/xeb/x8a/xa9", "HANGUL SYLLABLE NEUT");
+-   ("/xeb/x8a/xaa", "HANGUL SYLLABLE NEUP");
+-   ("/xeb/x8a/xab", "HANGUL SYLLABLE NEUH");
+-   ("/xeb/x8a/xac", "HANGUL SYLLABLE NYI");
+-   ("/xeb/x8a/xad", "HANGUL SYLLABLE NYIG");
+-   ("/xeb/x8a/xae", "HANGUL SYLLABLE NYIGG");
+-   ("/xeb/x8a/xaf", "HANGUL SYLLABLE NYIGS");
+-   ("/xeb/x8a/xb0", "HANGUL SYLLABLE NYIN");
+-   ("/xeb/x8a/xb1", "HANGUL SYLLABLE NYINI");
+-   ("/xeb/x8a/xb2", "HANGUL SYLLABLE NYINH");
+-   ("/xeb/x8a/xb3", "HANGUL SYLLABLE NYID");
+-   ("/xeb/x8a/xb4", "HANGUL SYLLABLE NYIL");
+-   ("/xeb/x8a/xb5", "HANGUL SYLLABLE NYILG");
+-   ("/xeb/x8a/xb6", "HANGUL SYLLABLE NYILM");
+-   ("/xeb/x8a/xb7", "HANGUL SYLLABLE NYILB");
+-   ("/xeb/x8a/xb8", "HANGUL SYLLABLE NYILS");
+-   ("/xeb/x8a/xb9", "HANGUL SYLLABLE NYILT");
+-   ("/xeb/x8a/xba", "HANGUL SYLLABLE NYILP");
+-   ("/xeb/x8a/xbb", "HANGUL SYLLABLE NYILH");
+-   ("/xeb/x8a/xbc", "HANGUL SYLLABLE NYIM");
+-   ("/xeb/x8a/xbd", "HANGUL SYLLABLE NYIB");
+-   ("/xeb/x8a/xbe", "HANGUL SYLLABLE NYIBS");
+-   ("/xeb/x8a/xbf", "HANGUL SYLLABLE NYIS");
+-   ("/xeb/x8b/x80", "HANGUL SYLLABLE NYISS");
+-   ("/xeb/x8b/x81", "HANGUL SYLLABLE NYING");
+-   ("/xeb/x8b/x82", "HANGUL SYLLABLE NYIJ");
+-   ("/xeb/x8b/x83", "HANGUL SYLLABLE NYIC");
+-   ("/xeb/x8b/x84", "HANGUL SYLLABLE NYIK");
+-   ("/xeb/x8b/x85", "HANGUL SYLLABLE NYIT");
+-   ("/xeb/x8b/x86", "HANGUL SYLLABLE NYIP");
+-   ("/xeb/x8b/x87", "HANGUL SYLLABLE NYIH");
+-   ("/xeb/x8b/x88", "HANGUL SYLLABLE NI");
+-   ("/xeb/x8b/x89", "HANGUL SYLLABLE NIG");
+-   ("/xeb/x8b/x8a", "HANGUL SYLLABLE NIGG");
+-   ("/xeb/x8b/x8b", "HANGUL SYLLABLE NIGS");
+-   ("/xeb/x8b/x8c", "HANGUL SYLLABLE NIN");
+-   ("/xeb/x8b/x8d", "HANGUL SYLLABLE NINI");
+-   ("/xeb/x8b/x8e", "HANGUL SYLLABLE NINH");
+-   ("/xeb/x8b/x8f", "HANGUL SYLLABLE NID");
+-   ("/xeb/x8b/x90", "HANGUL SYLLABLE NIL");
+-   ("/xeb/x8b/x91", "HANGUL SYLLABLE NILG");
+-   ("/xeb/x8b/x92", "HANGUL SYLLABLE NILM");
+-   ("/xeb/x8b/x93", "HANGUL SYLLABLE NILB");
+-   ("/xeb/x8b/x94", "HANGUL SYLLABLE NILS");
+-   ("/xeb/x8b/x95", "HANGUL SYLLABLE NILT");
+-   ("/xeb/x8b/x96", "HANGUL SYLLABLE NILP");
+-   ("/xeb/x8b/x97", "HANGUL SYLLABLE NILH");
+-   ("/xeb/x8b/x98", "HANGUL SYLLABLE NIM");
+-   ("/xeb/x8b/x99", "HANGUL SYLLABLE NIB");
+-   ("/xeb/x8b/x9a", "HANGUL SYLLABLE NIBS");
+-   ("/xeb/x8b/x9b", "HANGUL SYLLABLE NIS");
+-   ("/xeb/x8b/x9c", "HANGUL SYLLABLE NISS");
+-   ("/xeb/x8b/x9d", "HANGUL SYLLABLE NING");
+-   ("/xeb/x8b/x9e", "HANGUL SYLLABLE NIJ");
+-   ("/xeb/x8b/x9f", "HANGUL SYLLABLE NIC");
+-   ("/xeb/x8b/xa0", "HANGUL SYLLABLE NIK");
+-   ("/xeb/x8b/xa1", "HANGUL SYLLABLE NIT");
+-   ("/xeb/x8b/xa2", "HANGUL SYLLABLE NIP");
+-   ("/xeb/x8b/xa3", "HANGUL SYLLABLE NIH");
+-   ("/xeb/x8b/xa4", "HANGUL SYLLABLE DA");
+-   ("/xeb/x8b/xa5", "HANGUL SYLLABLE DAG");
+-   ("/xeb/x8b/xa6", "HANGUL SYLLABLE DAGG");
+-   ("/xeb/x8b/xa7", "HANGUL SYLLABLE DAGS");
+-   ("/xeb/x8b/xa8", "HANGUL SYLLABLE DAN");
+-   ("/xeb/x8b/xa9", "HANGUL SYLLABLE DANI");
+-   ("/xeb/x8b/xaa", "HANGUL SYLLABLE DANH");
+-   ("/xeb/x8b/xab", "HANGUL SYLLABLE DAD");
+-   ("/xeb/x8b/xac", "HANGUL SYLLABLE DAL");
+-   ("/xeb/x8b/xad", "HANGUL SYLLABLE DALG");
+-   ("/xeb/x8b/xae", "HANGUL SYLLABLE DALM");
+-   ("/xeb/x8b/xaf", "HANGUL SYLLABLE DALB");
+-   ("/xeb/x8b/xb0", "HANGUL SYLLABLE DALS");
+-   ("/xeb/x8b/xb1", "HANGUL SYLLABLE DALT");
+-   ("/xeb/x8b/xb2", "HANGUL SYLLABLE DALP");
+-   ("/xeb/x8b/xb3", "HANGUL SYLLABLE DALH");
+-   ("/xeb/x8b/xb4", "HANGUL SYLLABLE DAM");
+-   ("/xeb/x8b/xb5", "HANGUL SYLLABLE DAB");
+-   ("/xeb/x8b/xb6", "HANGUL SYLLABLE DABS");
+-   ("/xeb/x8b/xb7", "HANGUL SYLLABLE DAS");
+-   ("/xeb/x8b/xb8", "HANGUL SYLLABLE DASS");
+-   ("/xeb/x8b/xb9", "HANGUL SYLLABLE DANG");
+-   ("/xeb/x8b/xba", "HANGUL SYLLABLE DAJ");
+-   ("/xeb/x8b/xbb", "HANGUL SYLLABLE DAC");
+-   ("/xeb/x8b/xbc", "HANGUL SYLLABLE DAK");
+-   ("/xeb/x8b/xbd", "HANGUL SYLLABLE DAT");
+-   ("/xeb/x8b/xbe", "HANGUL SYLLABLE DAP");
+-   ("/xeb/x8b/xbf", "HANGUL SYLLABLE DAH");
+-   ("/xeb/x8c/x80", "HANGUL SYLLABLE DAE");
+-   ("/xeb/x8c/x81", "HANGUL SYLLABLE DAEG");
+-   ("/xeb/x8c/x82", "HANGUL SYLLABLE DAEGG");
+-   ("/xeb/x8c/x83", "HANGUL SYLLABLE DAEGS");
+-   ("/xeb/x8c/x84", "HANGUL SYLLABLE DAEN");
+-   ("/xeb/x8c/x85", "HANGUL SYLLABLE DAENI");
+-   ("/xeb/x8c/x86", "HANGUL SYLLABLE DAENH");
+-   ("/xeb/x8c/x87", "HANGUL SYLLABLE DAED");
+-   ("/xeb/x8c/x88", "HANGUL SYLLABLE DAEL");
+-   ("/xeb/x8c/x89", "HANGUL SYLLABLE DAELG");
+-   ("/xeb/x8c/x8a", "HANGUL SYLLABLE DAELM");
+-   ("/xeb/x8c/x8b", "HANGUL SYLLABLE DAELB");
+-   ("/xeb/x8c/x8c", "HANGUL SYLLABLE DAELS");
+-   ("/xeb/x8c/x8d", "HANGUL SYLLABLE DAELT");
+-   ("/xeb/x8c/x8e", "HANGUL SYLLABLE DAELP");
+-   ("/xeb/x8c/x8f", "HANGUL SYLLABLE DAELH");
+-   ("/xeb/x8c/x90", "HANGUL SYLLABLE DAEM");
+-   ("/xeb/x8c/x91", "HANGUL SYLLABLE DAEB");
+-   ("/xeb/x8c/x92", "HANGUL SYLLABLE DAEBS");
+-   ("/xeb/x8c/x93", "HANGUL SYLLABLE DAES");
+-   ("/xeb/x8c/x94", "HANGUL SYLLABLE DAESS");
+-   ("/xeb/x8c/x95", "HANGUL SYLLABLE DAENG");
+-   ("/xeb/x8c/x96", "HANGUL SYLLABLE DAEJ");
+-   ("/xeb/x8c/x97", "HANGUL SYLLABLE DAEC");
+-   ("/xeb/x8c/x98", "HANGUL SYLLABLE DAEK");
+-   ("/xeb/x8c/x99", "HANGUL SYLLABLE DAET");
+-   ("/xeb/x8c/x9a", "HANGUL SYLLABLE DAEP");
+-   ("/xeb/x8c/x9b", "HANGUL SYLLABLE DAEH");
+-   ("/xeb/x8c/x9c", "HANGUL SYLLABLE DYA");
+-   ("/xeb/x8c/x9d", "HANGUL SYLLABLE DYAG");
+-   ("/xeb/x8c/x9e", "HANGUL SYLLABLE DYAGG");
+-   ("/xeb/x8c/x9f", "HANGUL SYLLABLE DYAGS");
+-   ("/xeb/x8c/xa0", "HANGUL SYLLABLE DYAN");
+-   ("/xeb/x8c/xa1", "HANGUL SYLLABLE DYANI");
+-   ("/xeb/x8c/xa2", "HANGUL SYLLABLE DYANH");
+-   ("/xeb/x8c/xa3", "HANGUL SYLLABLE DYAD");
+-   ("/xeb/x8c/xa4", "HANGUL SYLLABLE DYAL");
+-   ("/xeb/x8c/xa5", "HANGUL SYLLABLE DYALG");
+-   ("/xeb/x8c/xa6", "HANGUL SYLLABLE DYALM");
+-   ("/xeb/x8c/xa7", "HANGUL SYLLABLE DYALB");
+-   ("/xeb/x8c/xa8", "HANGUL SYLLABLE DYALS");
+-   ("/xeb/x8c/xa9", "HANGUL SYLLABLE DYALT");
+-   ("/xeb/x8c/xaa", "HANGUL SYLLABLE DYALP");
+-   ("/xeb/x8c/xab", "HANGUL SYLLABLE DYALH");
+-   ("/xeb/x8c/xac", "HANGUL SYLLABLE DYAM");
+-   ("/xeb/x8c/xad", "HANGUL SYLLABLE DYAB");
+-   ("/xeb/x8c/xae", "HANGUL SYLLABLE DYABS");
+-   ("/xeb/x8c/xaf", "HANGUL SYLLABLE DYAS");
+-   ("/xeb/x8c/xb0", "HANGUL SYLLABLE DYASS");
+-   ("/xeb/x8c/xb1", "HANGUL SYLLABLE DYANG");
+-   ("/xeb/x8c/xb2", "HANGUL SYLLABLE DYAJ");
+-   ("/xeb/x8c/xb3", "HANGUL SYLLABLE DYAC");
+-   ("/xeb/x8c/xb4", "HANGUL SYLLABLE DYAK");
+-   ("/xeb/x8c/xb5", "HANGUL SYLLABLE DYAT");
+-   ("/xeb/x8c/xb6", "HANGUL SYLLABLE DYAP");
+-   ("/xeb/x8c/xb7", "HANGUL SYLLABLE DYAH");
+-   ("/xeb/x8c/xb8", "HANGUL SYLLABLE DYAE");
+-   ("/xeb/x8c/xb9", "HANGUL SYLLABLE DYAEG");
+-   ("/xeb/x8c/xba", "HANGUL SYLLABLE DYAEGG");
+-   ("/xeb/x8c/xbb", "HANGUL SYLLABLE DYAEGS");
+-   ("/xeb/x8c/xbc", "HANGUL SYLLABLE DYAEN");
+-   ("/xeb/x8c/xbd", "HANGUL SYLLABLE DYAENI");
+-   ("/xeb/x8c/xbe", "HANGUL SYLLABLE DYAENH");
+-   ("/xeb/x8c/xbf", "HANGUL SYLLABLE DYAED");
+-   ("/xeb/x8d/x80", "HANGUL SYLLABLE DYAEL");
+-   ("/xeb/x8d/x81", "HANGUL SYLLABLE DYAELG");
+-   ("/xeb/x8d/x82", "HANGUL SYLLABLE DYAELM");
+-   ("/xeb/x8d/x83", "HANGUL SYLLABLE DYAELB");
+-   ("/xeb/x8d/x84", "HANGUL SYLLABLE DYAELS");
+-   ("/xeb/x8d/x85", "HANGUL SYLLABLE DYAELT");
+-   ("/xeb/x8d/x86", "HANGUL SYLLABLE DYAELP");
+-   ("/xeb/x8d/x87", "HANGUL SYLLABLE DYAELH");
+-   ("/xeb/x8d/x88", "HANGUL SYLLABLE DYAEM");
+-   ("/xeb/x8d/x89", "HANGUL SYLLABLE DYAEB");
+-   ("/xeb/x8d/x8a", "HANGUL SYLLABLE DYAEBS");
+-   ("/xeb/x8d/x8b", "HANGUL SYLLABLE DYAES");
+-   ("/xeb/x8d/x8c", "HANGUL SYLLABLE DYAESS");
+-   ("/xeb/x8d/x8d", "HANGUL SYLLABLE DYAENG");
+-   ("/xeb/x8d/x8e", "HANGUL SYLLABLE DYAEJ");
+-   ("/xeb/x8d/x8f", "HANGUL SYLLABLE DYAEC");
+-   ("/xeb/x8d/x90", "HANGUL SYLLABLE DYAEK");
+-   ("/xeb/x8d/x91", "HANGUL SYLLABLE DYAET");
+-   ("/xeb/x8d/x92", "HANGUL SYLLABLE DYAEP");
+-   ("/xeb/x8d/x93", "HANGUL SYLLABLE DYAEH");
+-   ("/xeb/x8d/x94", "HANGUL SYLLABLE DEO");
+-   ("/xeb/x8d/x95", "HANGUL SYLLABLE DEOG");
+-   ("/xeb/x8d/x96", "HANGUL SYLLABLE DEOGG");
+-   ("/xeb/x8d/x97", "HANGUL SYLLABLE DEOGS");
+-   ("/xeb/x8d/x98", "HANGUL SYLLABLE DEON");
+-   ("/xeb/x8d/x99", "HANGUL SYLLABLE DEONI");
+-   ("/xeb/x8d/x9a", "HANGUL SYLLABLE DEONH");
+-   ("/xeb/x8d/x9b", "HANGUL SYLLABLE DEOD");
+-   ("/xeb/x8d/x9c", "HANGUL SYLLABLE DEOL");
+-   ("/xeb/x8d/x9d", "HANGUL SYLLABLE DEOLG");
+-   ("/xeb/x8d/x9e", "HANGUL SYLLABLE DEOLM");
+-   ("/xeb/x8d/x9f", "HANGUL SYLLABLE DEOLB");
+-   ("/xeb/x8d/xa0", "HANGUL SYLLABLE DEOLS");
+-   ("/xeb/x8d/xa1", "HANGUL SYLLABLE DEOLT");
+-   ("/xeb/x8d/xa2", "HANGUL SYLLABLE DEOLP");
+-   ("/xeb/x8d/xa3", "HANGUL SYLLABLE DEOLH");
+-   ("/xeb/x8d/xa4", "HANGUL SYLLABLE DEOM");
+-   ("/xeb/x8d/xa5", "HANGUL SYLLABLE DEOB");
+-   ("/xeb/x8d/xa6", "HANGUL SYLLABLE DEOBS");
+-   ("/xeb/x8d/xa7", "HANGUL SYLLABLE DEOS");
+-   ("/xeb/x8d/xa8", "HANGUL SYLLABLE DEOSS");
+-   ("/xeb/x8d/xa9", "HANGUL SYLLABLE DEONG");
+-   ("/xeb/x8d/xaa", "HANGUL SYLLABLE DEOJ");
+-   ("/xeb/x8d/xab", "HANGUL SYLLABLE DEOC");
+-   ("/xeb/x8d/xac", "HANGUL SYLLABLE DEOK");
+-   ("/xeb/x8d/xad", "HANGUL SYLLABLE DEOT");
+-   ("/xeb/x8d/xae", "HANGUL SYLLABLE DEOP");
+-   ("/xeb/x8d/xaf", "HANGUL SYLLABLE DEOH");
+-   ("/xeb/x8d/xb0", "HANGUL SYLLABLE DE");
+-   ("/xeb/x8d/xb1", "HANGUL SYLLABLE DEG");
+-   ("/xeb/x8d/xb2", "HANGUL SYLLABLE DEGG");
+-   ("/xeb/x8d/xb3", "HANGUL SYLLABLE DEGS");
+-   ("/xeb/x8d/xb4", "HANGUL SYLLABLE DEN");
+-   ("/xeb/x8d/xb5", "HANGUL SYLLABLE DENI");
+-   ("/xeb/x8d/xb6", "HANGUL SYLLABLE DENH");
+-   ("/xeb/x8d/xb7", "HANGUL SYLLABLE DED");
+-   ("/xeb/x8d/xb8", "HANGUL SYLLABLE DEL");
+-   ("/xeb/x8d/xb9", "HANGUL SYLLABLE DELG");
+-   ("/xeb/x8d/xba", "HANGUL SYLLABLE DELM");
+-   ("/xeb/x8d/xbb", "HANGUL SYLLABLE DELB");
+-   ("/xeb/x8d/xbc", "HANGUL SYLLABLE DELS");
+-   ("/xeb/x8d/xbd", "HANGUL SYLLABLE DELT");
+-   ("/xeb/x8d/xbe", "HANGUL SYLLABLE DELP");
+-   ("/xeb/x8d/xbf", "HANGUL SYLLABLE DELH");
+-   ("/xeb/x8e/x80", "HANGUL SYLLABLE DEM");
+-   ("/xeb/x8e/x81", "HANGUL SYLLABLE DEB");
+-   ("/xeb/x8e/x82", "HANGUL SYLLABLE DEBS");
+-   ("/xeb/x8e/x83", "HANGUL SYLLABLE DES");
+-   ("/xeb/x8e/x84", "HANGUL SYLLABLE DESS");
+-   ("/xeb/x8e/x85", "HANGUL SYLLABLE DENG");
+-   ("/xeb/x8e/x86", "HANGUL SYLLABLE DEJ");
+-   ("/xeb/x8e/x87", "HANGUL SYLLABLE DEC");
+-   ("/xeb/x8e/x88", "HANGUL SYLLABLE DEK");
+-   ("/xeb/x8e/x89", "HANGUL SYLLABLE DET");
+-   ("/xeb/x8e/x8a", "HANGUL SYLLABLE DEP");
+-   ("/xeb/x8e/x8b", "HANGUL SYLLABLE DEH");
+-   ("/xeb/x8e/x8c", "HANGUL SYLLABLE DYEO");
+-   ("/xeb/x8e/x8d", "HANGUL SYLLABLE DYEOG");
+-   ("/xeb/x8e/x8e", "HANGUL SYLLABLE DYEOGG");
+-   ("/xeb/x8e/x8f", "HANGUL SYLLABLE DYEOGS");
+-   ("/xeb/x8e/x90", "HANGUL SYLLABLE DYEON");
+-   ("/xeb/x8e/x91", "HANGUL SYLLABLE DYEONI");
+-   ("/xeb/x8e/x92", "HANGUL SYLLABLE DYEONH");
+-   ("/xeb/x8e/x93", "HANGUL SYLLABLE DYEOD");
+-   ("/xeb/x8e/x94", "HANGUL SYLLABLE DYEOL");
+-   ("/xeb/x8e/x95", "HANGUL SYLLABLE DYEOLG");
+-   ("/xeb/x8e/x96", "HANGUL SYLLABLE DYEOLM");
+-   ("/xeb/x8e/x97", "HANGUL SYLLABLE DYEOLB");
+-   ("/xeb/x8e/x98", "HANGUL SYLLABLE DYEOLS");
+-   ("/xeb/x8e/x99", "HANGUL SYLLABLE DYEOLT");
+-   ("/xeb/x8e/x9a", "HANGUL SYLLABLE DYEOLP");
+-   ("/xeb/x8e/x9b", "HANGUL SYLLABLE DYEOLH");
+-   ("/xeb/x8e/x9c", "HANGUL SYLLABLE DYEOM");
+-   ("/xeb/x8e/x9d", "HANGUL SYLLABLE DYEOB");
+-   ("/xeb/x8e/x9e", "HANGUL SYLLABLE DYEOBS");
+-   ("/xeb/x8e/x9f", "HANGUL SYLLABLE DYEOS");
+-   ("/xeb/x8e/xa0", "HANGUL SYLLABLE DYEOSS");
+-   ("/xeb/x8e/xa1", "HANGUL SYLLABLE DYEONG");
+-   ("/xeb/x8e/xa2", "HANGUL SYLLABLE DYEOJ");
+-   ("/xeb/x8e/xa3", "HANGUL SYLLABLE DYEOC");
+-   ("/xeb/x8e/xa4", "HANGUL SYLLABLE DYEOK");
+-   ("/xeb/x8e/xa5", "HANGUL SYLLABLE DYEOT");
+-   ("/xeb/x8e/xa6", "HANGUL SYLLABLE DYEOP");
+-   ("/xeb/x8e/xa7", "HANGUL SYLLABLE DYEOH");
+-   ("/xeb/x8e/xa8", "HANGUL SYLLABLE DYE");
+-   ("/xeb/x8e/xa9", "HANGUL SYLLABLE DYEG");
+-   ("/xeb/x8e/xaa", "HANGUL SYLLABLE DYEGG");
+-   ("/xeb/x8e/xab", "HANGUL SYLLABLE DYEGS");
+-   ("/xeb/x8e/xac", "HANGUL SYLLABLE DYEN");
+-   ("/xeb/x8e/xad", "HANGUL SYLLABLE DYENI");
+-   ("/xeb/x8e/xae", "HANGUL SYLLABLE DYENH");
+-   ("/xeb/x8e/xaf", "HANGUL SYLLABLE DYED");
+-   ("/xeb/x8e/xb0", "HANGUL SYLLABLE DYEL");
+-   ("/xeb/x8e/xb1", "HANGUL SYLLABLE DYELG");
+-   ("/xeb/x8e/xb2", "HANGUL SYLLABLE DYELM");
+-   ("/xeb/x8e/xb3", "HANGUL SYLLABLE DYELB");
+-   ("/xeb/x8e/xb4", "HANGUL SYLLABLE DYELS");
+-   ("/xeb/x8e/xb5", "HANGUL SYLLABLE DYELT");
+-   ("/xeb/x8e/xb6", "HANGUL SYLLABLE DYELP");
+-   ("/xeb/x8e/xb7", "HANGUL SYLLABLE DYELH");
+-   ("/xeb/x8e/xb8", "HANGUL SYLLABLE DYEM");
+-   ("/xeb/x8e/xb9", "HANGUL SYLLABLE DYEB");
+-   ("/xeb/x8e/xba", "HANGUL SYLLABLE DYEBS");
+-   ("/xeb/x8e/xbb", "HANGUL SYLLABLE DYES");
+-   ("/xeb/x8e/xbc", "HANGUL SYLLABLE DYESS");
+-   ("/xeb/x8e/xbd", "HANGUL SYLLABLE DYENG");
+-   ("/xeb/x8e/xbe", "HANGUL SYLLABLE DYEJ");
+-   ("/xeb/x8e/xbf", "HANGUL SYLLABLE DYEC");
+-   ("/xeb/x8f/x80", "HANGUL SYLLABLE DYEK");
+-   ("/xeb/x8f/x81", "HANGUL SYLLABLE DYET");
+-   ("/xeb/x8f/x82", "HANGUL SYLLABLE DYEP");
+-   ("/xeb/x8f/x83", "HANGUL SYLLABLE DYEH");
+-   ("/xeb/x8f/x84", "HANGUL SYLLABLE DO");
+-   ("/xeb/x8f/x85", "HANGUL SYLLABLE DOG");
+-   ("/xeb/x8f/x86", "HANGUL SYLLABLE DOGG");
+-   ("/xeb/x8f/x87", "HANGUL SYLLABLE DOGS");
+-   ("/xeb/x8f/x88", "HANGUL SYLLABLE DON");
+-   ("/xeb/x8f/x89", "HANGUL SYLLABLE DONI");
+-   ("/xeb/x8f/x8a", "HANGUL SYLLABLE DONH");
+-   ("/xeb/x8f/x8b", "HANGUL SYLLABLE DOD");
+-   ("/xeb/x8f/x8c", "HANGUL SYLLABLE DOL");
+-   ("/xeb/x8f/x8d", "HANGUL SYLLABLE DOLG");
+-   ("/xeb/x8f/x8e", "HANGUL SYLLABLE DOLM");
+-   ("/xeb/x8f/x8f", "HANGUL SYLLABLE DOLB");
+-   ("/xeb/x8f/x90", "HANGUL SYLLABLE DOLS");
+-   ("/xeb/x8f/x91", "HANGUL SYLLABLE DOLT");
+-   ("/xeb/x8f/x92", "HANGUL SYLLABLE DOLP");
+-   ("/xeb/x8f/x93", "HANGUL SYLLABLE DOLH");
+-   ("/xeb/x8f/x94", "HANGUL SYLLABLE DOM");
+-   ("/xeb/x8f/x95", "HANGUL SYLLABLE DOB");
+-   ("/xeb/x8f/x96", "HANGUL SYLLABLE DOBS");
+-   ("/xeb/x8f/x97", "HANGUL SYLLABLE DOS");
+-   ("/xeb/x8f/x98", "HANGUL SYLLABLE DOSS");
+-   ("/xeb/x8f/x99", "HANGUL SYLLABLE DONG");
+-   ("/xeb/x8f/x9a", "HANGUL SYLLABLE DOJ");
+-   ("/xeb/x8f/x9b", "HANGUL SYLLABLE DOC");
+-   ("/xeb/x8f/x9c", "HANGUL SYLLABLE DOK");
+-   ("/xeb/x8f/x9d", "HANGUL SYLLABLE DOT");
+-   ("/xeb/x8f/x9e", "HANGUL SYLLABLE DOP");
+-   ("/xeb/x8f/x9f", "HANGUL SYLLABLE DOH");
+-   ("/xeb/x8f/xa0", "HANGUL SYLLABLE DWA");
+-   ("/xeb/x8f/xa1", "HANGUL SYLLABLE DWAG");
+-   ("/xeb/x8f/xa2", "HANGUL SYLLABLE DWAGG");
+-   ("/xeb/x8f/xa3", "HANGUL SYLLABLE DWAGS");
+-   ("/xeb/x8f/xa4", "HANGUL SYLLABLE DWAN");
+-   ("/xeb/x8f/xa5", "HANGUL SYLLABLE DWANI");
+-   ("/xeb/x8f/xa6", "HANGUL SYLLABLE DWANH");
+-   ("/xeb/x8f/xa7", "HANGUL SYLLABLE DWAD");
+-   ("/xeb/x8f/xa8", "HANGUL SYLLABLE DWAL");
+-   ("/xeb/x8f/xa9", "HANGUL SYLLABLE DWALG");
+-   ("/xeb/x8f/xaa", "HANGUL SYLLABLE DWALM");
+-   ("/xeb/x8f/xab", "HANGUL SYLLABLE DWALB");
+-   ("/xeb/x8f/xac", "HANGUL SYLLABLE DWALS");
+-   ("/xeb/x8f/xad", "HANGUL SYLLABLE DWALT");
+-   ("/xeb/x8f/xae", "HANGUL SYLLABLE DWALP");
+-   ("/xeb/x8f/xaf", "HANGUL SYLLABLE DWALH");
+-   ("/xeb/x8f/xb0", "HANGUL SYLLABLE DWAM");
+-   ("/xeb/x8f/xb1", "HANGUL SYLLABLE DWAB");
+-   ("/xeb/x8f/xb2", "HANGUL SYLLABLE DWABS");
+-   ("/xeb/x8f/xb3", "HANGUL SYLLABLE DWAS");
+-   ("/xeb/x8f/xb4", "HANGUL SYLLABLE DWASS");
+-   ("/xeb/x8f/xb5", "HANGUL SYLLABLE DWANG");
+-   ("/xeb/x8f/xb6", "HANGUL SYLLABLE DWAJ");
+-   ("/xeb/x8f/xb7", "HANGUL SYLLABLE DWAC");
+-   ("/xeb/x8f/xb8", "HANGUL SYLLABLE DWAK");
+-   ("/xeb/x8f/xb9", "HANGUL SYLLABLE DWAT");
+-   ("/xeb/x8f/xba", "HANGUL SYLLABLE DWAP");
+-   ("/xeb/x8f/xbb", "HANGUL SYLLABLE DWAH");
+-   ("/xeb/x8f/xbc", "HANGUL SYLLABLE DWAE");
+-   ("/xeb/x8f/xbd", "HANGUL SYLLABLE DWAEG");
+-   ("/xeb/x8f/xbe", "HANGUL SYLLABLE DWAEGG");
+-   ("/xeb/x8f/xbf", "HANGUL SYLLABLE DWAEGS");
+-   ("/xeb/x90/x80", "HANGUL SYLLABLE DWAEN");
+-   ("/xeb/x90/x81", "HANGUL SYLLABLE DWAENI");
+-   ("/xeb/x90/x82", "HANGUL SYLLABLE DWAENH");
+-   ("/xeb/x90/x83", "HANGUL SYLLABLE DWAED");
+-   ("/xeb/x90/x84", "HANGUL SYLLABLE DWAEL");
+-   ("/xeb/x90/x85", "HANGUL SYLLABLE DWAELG");
+-   ("/xeb/x90/x86", "HANGUL SYLLABLE DWAELM");
+-   ("/xeb/x90/x87", "HANGUL SYLLABLE DWAELB");
+-   ("/xeb/x90/x88", "HANGUL SYLLABLE DWAELS");
+-   ("/xeb/x90/x89", "HANGUL SYLLABLE DWAELT");
+-   ("/xeb/x90/x8a", "HANGUL SYLLABLE DWAELP");
+-   ("/xeb/x90/x8b", "HANGUL SYLLABLE DWAELH");
+-   ("/xeb/x90/x8c", "HANGUL SYLLABLE DWAEM");
+-   ("/xeb/x90/x8d", "HANGUL SYLLABLE DWAEB");
+-   ("/xeb/x90/x8e", "HANGUL SYLLABLE DWAEBS");
+-   ("/xeb/x90/x8f", "HANGUL SYLLABLE DWAES");
+-   ("/xeb/x90/x90", "HANGUL SYLLABLE DWAESS");
+-   ("/xeb/x90/x91", "HANGUL SYLLABLE DWAENG");
+-   ("/xeb/x90/x92", "HANGUL SYLLABLE DWAEJ");
+-   ("/xeb/x90/x93", "HANGUL SYLLABLE DWAEC");
+-   ("/xeb/x90/x94", "HANGUL SYLLABLE DWAEK");
+-   ("/xeb/x90/x95", "HANGUL SYLLABLE DWAET");
+-   ("/xeb/x90/x96", "HANGUL SYLLABLE DWAEP");
+-   ("/xeb/x90/x97", "HANGUL SYLLABLE DWAEH");
+-   ("/xeb/x90/x98", "HANGUL SYLLABLE DOE");
+-   ("/xeb/x90/x99", "HANGUL SYLLABLE DOEG");
+-   ("/xeb/x90/x9a", "HANGUL SYLLABLE DOEGG");
+-   ("/xeb/x90/x9b", "HANGUL SYLLABLE DOEGS");
+-   ("/xeb/x90/x9c", "HANGUL SYLLABLE DOEN");
+-   ("/xeb/x90/x9d", "HANGUL SYLLABLE DOENI");
+-   ("/xeb/x90/x9e", "HANGUL SYLLABLE DOENH");
+-   ("/xeb/x90/x9f", "HANGUL SYLLABLE DOED");
+-   ("/xeb/x90/xa0", "HANGUL SYLLABLE DOEL");
+-   ("/xeb/x90/xa1", "HANGUL SYLLABLE DOELG");
+-   ("/xeb/x90/xa2", "HANGUL SYLLABLE DOELM");
+-   ("/xeb/x90/xa3", "HANGUL SYLLABLE DOELB");
+-   ("/xeb/x90/xa4", "HANGUL SYLLABLE DOELS");
+-   ("/xeb/x90/xa5", "HANGUL SYLLABLE DOELT");
+-   ("/xeb/x90/xa6", "HANGUL SYLLABLE DOELP");
+-   ("/xeb/x90/xa7", "HANGUL SYLLABLE DOELH");
+-   ("/xeb/x90/xa8", "HANGUL SYLLABLE DOEM");
+-   ("/xeb/x90/xa9", "HANGUL SYLLABLE DOEB");
+-   ("/xeb/x90/xaa", "HANGUL SYLLABLE DOEBS");
+-   ("/xeb/x90/xab", "HANGUL SYLLABLE DOES");
+-   ("/xeb/x90/xac", "HANGUL SYLLABLE DOESS");
+-   ("/xeb/x90/xad", "HANGUL SYLLABLE DOENG");
+-   ("/xeb/x90/xae", "HANGUL SYLLABLE DOEJ");
+-   ("/xeb/x90/xaf", "HANGUL SYLLABLE DOEC");
+-   ("/xeb/x90/xb0", "HANGUL SYLLABLE DOEK");
+-   ("/xeb/x90/xb1", "HANGUL SYLLABLE DOET");
+-   ("/xeb/x90/xb2", "HANGUL SYLLABLE DOEP");
+-   ("/xeb/x90/xb3", "HANGUL SYLLABLE DOEH");
+-   ("/xeb/x90/xb4", "HANGUL SYLLABLE DYO");
+-   ("/xeb/x90/xb5", "HANGUL SYLLABLE DYOG");
+-   ("/xeb/x90/xb6", "HANGUL SYLLABLE DYOGG");
+-   ("/xeb/x90/xb7", "HANGUL SYLLABLE DYOGS");
+-   ("/xeb/x90/xb8", "HANGUL SYLLABLE DYON");
+-   ("/xeb/x90/xb9", "HANGUL SYLLABLE DYONI");
+-   ("/xeb/x90/xba", "HANGUL SYLLABLE DYONH");
+-   ("/xeb/x90/xbb", "HANGUL SYLLABLE DYOD");
+-   ("/xeb/x90/xbc", "HANGUL SYLLABLE DYOL");
+-   ("/xeb/x90/xbd", "HANGUL SYLLABLE DYOLG");
+-   ("/xeb/x90/xbe", "HANGUL SYLLABLE DYOLM");
+-   ("/xeb/x90/xbf", "HANGUL SYLLABLE DYOLB");
+-   ("/xeb/x91/x80", "HANGUL SYLLABLE DYOLS");
+-   ("/xeb/x91/x81", "HANGUL SYLLABLE DYOLT");
+-   ("/xeb/x91/x82", "HANGUL SYLLABLE DYOLP");
+-   ("/xeb/x91/x83", "HANGUL SYLLABLE DYOLH");
+-   ("/xeb/x91/x84", "HANGUL SYLLABLE DYOM");
+-   ("/xeb/x91/x85", "HANGUL SYLLABLE DYOB");
+-   ("/xeb/x91/x86", "HANGUL SYLLABLE DYOBS");
+-   ("/xeb/x91/x87", "HANGUL SYLLABLE DYOS");
+-   ("/xeb/x91/x88", "HANGUL SYLLABLE DYOSS");
+-   ("/xeb/x91/x89", "HANGUL SYLLABLE DYONG");
+-   ("/xeb/x91/x8a", "HANGUL SYLLABLE DYOJ");
+-   ("/xeb/x91/x8b", "HANGUL SYLLABLE DYOC");
+-   ("/xeb/x91/x8c", "HANGUL SYLLABLE DYOK");
+-   ("/xeb/x91/x8d", "HANGUL SYLLABLE DYOT");
+-   ("/xeb/x91/x8e", "HANGUL SYLLABLE DYOP");
+-   ("/xeb/x91/x8f", "HANGUL SYLLABLE DYOH");
+-   ("/xeb/x91/x90", "HANGUL SYLLABLE DU");
+-   ("/xeb/x91/x91", "HANGUL SYLLABLE DUG");
+-   ("/xeb/x91/x92", "HANGUL SYLLABLE DUGG");
+-   ("/xeb/x91/x93", "HANGUL SYLLABLE DUGS");
+-   ("/xeb/x91/x94", "HANGUL SYLLABLE DUN");
+-   ("/xeb/x91/x95", "HANGUL SYLLABLE DUNI");
+-   ("/xeb/x91/x96", "HANGUL SYLLABLE DUNH");
+-   ("/xeb/x91/x97", "HANGUL SYLLABLE DUD");
+-   ("/xeb/x91/x98", "HANGUL SYLLABLE DUL");
+-   ("/xeb/x91/x99", "HANGUL SYLLABLE DULG");
+-   ("/xeb/x91/x9a", "HANGUL SYLLABLE DULM");
+-   ("/xeb/x91/x9b", "HANGUL SYLLABLE DULB");
+-   ("/xeb/x91/x9c", "HANGUL SYLLABLE DULS");
+-   ("/xeb/x91/x9d", "HANGUL SYLLABLE DULT");
+-   ("/xeb/x91/x9e", "HANGUL SYLLABLE DULP");
+-   ("/xeb/x91/x9f", "HANGUL SYLLABLE DULH");
+-   ("/xeb/x91/xa0", "HANGUL SYLLABLE DUM");
+-   ("/xeb/x91/xa1", "HANGUL SYLLABLE DUB");
+-   ("/xeb/x91/xa2", "HANGUL SYLLABLE DUBS");
+-   ("/xeb/x91/xa3", "HANGUL SYLLABLE DUS");
+-   ("/xeb/x91/xa4", "HANGUL SYLLABLE DUSS");
+-   ("/xeb/x91/xa5", "HANGUL SYLLABLE DUNG");
+-   ("/xeb/x91/xa6", "HANGUL SYLLABLE DUJ");
+-   ("/xeb/x91/xa7", "HANGUL SYLLABLE DUC");
+-   ("/xeb/x91/xa8", "HANGUL SYLLABLE DUK");
+-   ("/xeb/x91/xa9", "HANGUL SYLLABLE DUT");
+-   ("/xeb/x91/xaa", "HANGUL SYLLABLE DUP");
+-   ("/xeb/x91/xab", "HANGUL SYLLABLE DUH");
+-   ("/xeb/x91/xac", "HANGUL SYLLABLE DWEO");
+-   ("/xeb/x91/xad", "HANGUL SYLLABLE DWEOG");
+-   ("/xeb/x91/xae", "HANGUL SYLLABLE DWEOGG");
+-   ("/xeb/x91/xaf", "HANGUL SYLLABLE DWEOGS");
+-   ("/xeb/x91/xb0", "HANGUL SYLLABLE DWEON");
+-   ("/xeb/x91/xb1", "HANGUL SYLLABLE DWEONI");
+-   ("/xeb/x91/xb2", "HANGUL SYLLABLE DWEONH");
+-   ("/xeb/x91/xb3", "HANGUL SYLLABLE DWEOD");
+-   ("/xeb/x91/xb4", "HANGUL SYLLABLE DWEOL");
+-   ("/xeb/x91/xb5", "HANGUL SYLLABLE DWEOLG");
+-   ("/xeb/x91/xb6", "HANGUL SYLLABLE DWEOLM");
+-   ("/xeb/x91/xb7", "HANGUL SYLLABLE DWEOLB");
+-   ("/xeb/x91/xb8", "HANGUL SYLLABLE DWEOLS");
+-   ("/xeb/x91/xb9", "HANGUL SYLLABLE DWEOLT");
+-   ("/xeb/x91/xba", "HANGUL SYLLABLE DWEOLP");
+-   ("/xeb/x91/xbb", "HANGUL SYLLABLE DWEOLH");
+-   ("/xeb/x91/xbc", "HANGUL SYLLABLE DWEOM");
+-   ("/xeb/x91/xbd", "HANGUL SYLLABLE DWEOB");
+-   ("/xeb/x91/xbe", "HANGUL SYLLABLE DWEOBS");
+-   ("/xeb/x91/xbf", "HANGUL SYLLABLE DWEOS");
+-   ("/xeb/x92/x80", "HANGUL SYLLABLE DWEOSS");
+-   ("/xeb/x92/x81", "HANGUL SYLLABLE DWEONG");
+-   ("/xeb/x92/x82", "HANGUL SYLLABLE DWEOJ");
+-   ("/xeb/x92/x83", "HANGUL SYLLABLE DWEOC");
+-   ("/xeb/x92/x84", "HANGUL SYLLABLE DWEOK");
+-   ("/xeb/x92/x85", "HANGUL SYLLABLE DWEOT");
+-   ("/xeb/x92/x86", "HANGUL SYLLABLE DWEOP");
+-   ("/xeb/x92/x87", "HANGUL SYLLABLE DWEOH");
+-   ("/xeb/x92/x88", "HANGUL SYLLABLE DWE");
+-   ("/xeb/x92/x89", "HANGUL SYLLABLE DWEG");
+-   ("/xeb/x92/x8a", "HANGUL SYLLABLE DWEGG");
+-   ("/xeb/x92/x8b", "HANGUL SYLLABLE DWEGS");
+-   ("/xeb/x92/x8c", "HANGUL SYLLABLE DWEN");
+-   ("/xeb/x92/x8d", "HANGUL SYLLABLE DWENI");
+-   ("/xeb/x92/x8e", "HANGUL SYLLABLE DWENH");
+-   ("/xeb/x92/x8f", "HANGUL SYLLABLE DWED");
+-   ("/xeb/x92/x90", "HANGUL SYLLABLE DWEL");
+-   ("/xeb/x92/x91", "HANGUL SYLLABLE DWELG");
+-   ("/xeb/x92/x92", "HANGUL SYLLABLE DWELM");
+-   ("/xeb/x92/x93", "HANGUL SYLLABLE DWELB");
+-   ("/xeb/x92/x94", "HANGUL SYLLABLE DWELS");
+-   ("/xeb/x92/x95", "HANGUL SYLLABLE DWELT");
+-   ("/xeb/x92/x96", "HANGUL SYLLABLE DWELP");
+-   ("/xeb/x92/x97", "HANGUL SYLLABLE DWELH");
+-   ("/xeb/x92/x98", "HANGUL SYLLABLE DWEM");
+-   ("/xeb/x92/x99", "HANGUL SYLLABLE DWEB");
+-   ("/xeb/x92/x9a", "HANGUL SYLLABLE DWEBS");
+-   ("/xeb/x92/x9b", "HANGUL SYLLABLE DWES");
+-   ("/xeb/x92/x9c", "HANGUL SYLLABLE DWESS");
+-   ("/xeb/x92/x9d", "HANGUL SYLLABLE DWENG");
+-   ("/xeb/x92/x9e", "HANGUL SYLLABLE DWEJ");
+-   ("/xeb/x92/x9f", "HANGUL SYLLABLE DWEC");
+-   ("/xeb/x92/xa0", "HANGUL SYLLABLE DWEK");
+-   ("/xeb/x92/xa1", "HANGUL SYLLABLE DWET");
+-   ("/xeb/x92/xa2", "HANGUL SYLLABLE DWEP");
+-   ("/xeb/x92/xa3", "HANGUL SYLLABLE DWEH");
+-   ("/xeb/x92/xa4", "HANGUL SYLLABLE DWI");
+-   ("/xeb/x92/xa5", "HANGUL SYLLABLE DWIG");
+-   ("/xeb/x92/xa6", "HANGUL SYLLABLE DWIGG");
+-   ("/xeb/x92/xa7", "HANGUL SYLLABLE DWIGS");
+-   ("/xeb/x92/xa8", "HANGUL SYLLABLE DWIN");
+-   ("/xeb/x92/xa9", "HANGUL SYLLABLE DWINI");
+-   ("/xeb/x92/xaa", "HANGUL SYLLABLE DWINH");
+-   ("/xeb/x92/xab", "HANGUL SYLLABLE DWID");
+-   ("/xeb/x92/xac", "HANGUL SYLLABLE DWIL");
+-   ("/xeb/x92/xad", "HANGUL SYLLABLE DWILG");
+-   ("/xeb/x92/xae", "HANGUL SYLLABLE DWILM");
+-   ("/xeb/x92/xaf", "HANGUL SYLLABLE DWILB");
+-   ("/xeb/x92/xb0", "HANGUL SYLLABLE DWILS");
+-   ("/xeb/x92/xb1", "HANGUL SYLLABLE DWILT");
+-   ("/xeb/x92/xb2", "HANGUL SYLLABLE DWILP");
+-   ("/xeb/x92/xb3", "HANGUL SYLLABLE DWILH");
+-   ("/xeb/x92/xb4", "HANGUL SYLLABLE DWIM");
+-   ("/xeb/x92/xb5", "HANGUL SYLLABLE DWIB");
+-   ("/xeb/x92/xb6", "HANGUL SYLLABLE DWIBS");
+-   ("/xeb/x92/xb7", "HANGUL SYLLABLE DWIS");
+-   ("/xeb/x92/xb8", "HANGUL SYLLABLE DWISS");
+-   ("/xeb/x92/xb9", "HANGUL SYLLABLE DWING");
+-   ("/xeb/x92/xba", "HANGUL SYLLABLE DWIJ");
+-   ("/xeb/x92/xbb", "HANGUL SYLLABLE DWIC");
+-   ("/xeb/x92/xbc", "HANGUL SYLLABLE DWIK");
+-   ("/xeb/x92/xbd", "HANGUL SYLLABLE DWIT");
+-   ("/xeb/x92/xbe", "HANGUL SYLLABLE DWIP");
+-   ("/xeb/x92/xbf", "HANGUL SYLLABLE DWIH");
+-   ("/xeb/x93/x80", "HANGUL SYLLABLE DYU");
+-   ("/xeb/x93/x81", "HANGUL SYLLABLE DYUG");
+-   ("/xeb/x93/x82", "HANGUL SYLLABLE DYUGG");
+-   ("/xeb/x93/x83", "HANGUL SYLLABLE DYUGS");
+-   ("/xeb/x93/x84", "HANGUL SYLLABLE DYUN");
+-   ("/xeb/x93/x85", "HANGUL SYLLABLE DYUNI");
+-   ("/xeb/x93/x86", "HANGUL SYLLABLE DYUNH");
+-   ("/xeb/x93/x87", "HANGUL SYLLABLE DYUD");
+-   ("/xeb/x93/x88", "HANGUL SYLLABLE DYUL");
+-   ("/xeb/x93/x89", "HANGUL SYLLABLE DYULG");
+-   ("/xeb/x93/x8a", "HANGUL SYLLABLE DYULM");
+-   ("/xeb/x93/x8b", "HANGUL SYLLABLE DYULB");
+-   ("/xeb/x93/x8c", "HANGUL SYLLABLE DYULS");
+-   ("/xeb/x93/x8d", "HANGUL SYLLABLE DYULT");
+-   ("/xeb/x93/x8e", "HANGUL SYLLABLE DYULP");
+-   ("/xeb/x93/x8f", "HANGUL SYLLABLE DYULH");
+-   ("/xeb/x93/x90", "HANGUL SYLLABLE DYUM");
+-   ("/xeb/x93/x91", "HANGUL SYLLABLE DYUB");
+-   ("/xeb/x93/x92", "HANGUL SYLLABLE DYUBS");
+-   ("/xeb/x93/x93", "HANGUL SYLLABLE DYUS");
+-   ("/xeb/x93/x94", "HANGUL SYLLABLE DYUSS");
+-   ("/xeb/x93/x95", "HANGUL SYLLABLE DYUNG");
+-   ("/xeb/x93/x96", "HANGUL SYLLABLE DYUJ");
+-   ("/xeb/x93/x97", "HANGUL SYLLABLE DYUC");
+-   ("/xeb/x93/x98", "HANGUL SYLLABLE DYUK");
+-   ("/xeb/x93/x99", "HANGUL SYLLABLE DYUT");
+-   ("/xeb/x93/x9a", "HANGUL SYLLABLE DYUP");
+-   ("/xeb/x93/x9b", "HANGUL SYLLABLE DYUH");
+-   ("/xeb/x93/x9c", "HANGUL SYLLABLE DEU");
+-   ("/xeb/x93/x9d", "HANGUL SYLLABLE DEUG");
+-   ("/xeb/x93/x9e", "HANGUL SYLLABLE DEUGG");
+-   ("/xeb/x93/x9f", "HANGUL SYLLABLE DEUGS");
+-   ("/xeb/x93/xa0", "HANGUL SYLLABLE DEUN");
+-   ("/xeb/x93/xa1", "HANGUL SYLLABLE DEUNI");
+-   ("/xeb/x93/xa2", "HANGUL SYLLABLE DEUNH");
+-   ("/xeb/x93/xa3", "HANGUL SYLLABLE DEUD");
+-   ("/xeb/x93/xa4", "HANGUL SYLLABLE DEUL");
+-   ("/xeb/x93/xa5", "HANGUL SYLLABLE DEULG");
+-   ("/xeb/x93/xa6", "HANGUL SYLLABLE DEULM");
+-   ("/xeb/x93/xa7", "HANGUL SYLLABLE DEULB");
+-   ("/xeb/x93/xa8", "HANGUL SYLLABLE DEULS");
+-   ("/xeb/x93/xa9", "HANGUL SYLLABLE DEULT");
+-   ("/xeb/x93/xaa", "HANGUL SYLLABLE DEULP");
+-   ("/xeb/x93/xab", "HANGUL SYLLABLE DEULH");
+-   ("/xeb/x93/xac", "HANGUL SYLLABLE DEUM");
+-   ("/xeb/x93/xad", "HANGUL SYLLABLE DEUB");
+-   ("/xeb/x93/xae", "HANGUL SYLLABLE DEUBS");
+-   ("/xeb/x93/xaf", "HANGUL SYLLABLE DEUS");
+-   ("/xeb/x93/xb0", "HANGUL SYLLABLE DEUSS");
+-   ("/xeb/x93/xb1", "HANGUL SYLLABLE DEUNG");
+-   ("/xeb/x93/xb2", "HANGUL SYLLABLE DEUJ");
+-   ("/xeb/x93/xb3", "HANGUL SYLLABLE DEUC");
+-   ("/xeb/x93/xb4", "HANGUL SYLLABLE DEUK");
+-   ("/xeb/x93/xb5", "HANGUL SYLLABLE DEUT");
+-   ("/xeb/x93/xb6", "HANGUL SYLLABLE DEUP");
+-   ("/xeb/x93/xb7", "HANGUL SYLLABLE DEUH");
+-   ("/xeb/x93/xb8", "HANGUL SYLLABLE DYI");
+-   ("/xeb/x93/xb9", "HANGUL SYLLABLE DYIG");
+-   ("/xeb/x93/xba", "HANGUL SYLLABLE DYIGG");
+-   ("/xeb/x93/xbb", "HANGUL SYLLABLE DYIGS");
+-   ("/xeb/x93/xbc", "HANGUL SYLLABLE DYIN");
+-   ("/xeb/x93/xbd", "HANGUL SYLLABLE DYINI");
+-   ("/xeb/x93/xbe", "HANGUL SYLLABLE DYINH");
+-   ("/xeb/x93/xbf", "HANGUL SYLLABLE DYID");
+-   ("/xeb/x94/x80", "HANGUL SYLLABLE DYIL");
+-   ("/xeb/x94/x81", "HANGUL SYLLABLE DYILG");
+-   ("/xeb/x94/x82", "HANGUL SYLLABLE DYILM");
+-   ("/xeb/x94/x83", "HANGUL SYLLABLE DYILB");
+-   ("/xeb/x94/x84", "HANGUL SYLLABLE DYILS");
+-   ("/xeb/x94/x85", "HANGUL SYLLABLE DYILT");
+-   ("/xeb/x94/x86", "HANGUL SYLLABLE DYILP");
+-   ("/xeb/x94/x87", "HANGUL SYLLABLE DYILH");
+-   ("/xeb/x94/x88", "HANGUL SYLLABLE DYIM");
+-   ("/xeb/x94/x89", "HANGUL SYLLABLE DYIB");
+-   ("/xeb/x94/x8a", "HANGUL SYLLABLE DYIBS");
+-   ("/xeb/x94/x8b", "HANGUL SYLLABLE DYIS");
+-   ("/xeb/x94/x8c", "HANGUL SYLLABLE DYISS");
+-   ("/xeb/x94/x8d", "HANGUL SYLLABLE DYING");
+-   ("/xeb/x94/x8e", "HANGUL SYLLABLE DYIJ");
+-   ("/xeb/x94/x8f", "HANGUL SYLLABLE DYIC");
+-   ("/xeb/x94/x90", "HANGUL SYLLABLE DYIK");
+-   ("/xeb/x94/x91", "HANGUL SYLLABLE DYIT");
+-   ("/xeb/x94/x92", "HANGUL SYLLABLE DYIP");
+-   ("/xeb/x94/x93", "HANGUL SYLLABLE DYIH");
+-   ("/xeb/x94/x94", "HANGUL SYLLABLE DI");
+-   ("/xeb/x94/x95", "HANGUL SYLLABLE DIG");
+-   ("/xeb/x94/x96", "HANGUL SYLLABLE DIGG");
+-   ("/xeb/x94/x97", "HANGUL SYLLABLE DIGS");
+-   ("/xeb/x94/x98", "HANGUL SYLLABLE DIN");
+-   ("/xeb/x94/x99", "HANGUL SYLLABLE DINI");
+-   ("/xeb/x94/x9a", "HANGUL SYLLABLE DINH");
+-   ("/xeb/x94/x9b", "HANGUL SYLLABLE DID");
+-   ("/xeb/x94/x9c", "HANGUL SYLLABLE DIL");
+-   ("/xeb/x94/x9d", "HANGUL SYLLABLE DILG");
+-   ("/xeb/x94/x9e", "HANGUL SYLLABLE DILM");
+-   ("/xeb/x94/x9f", "HANGUL SYLLABLE DILB");
+-   ("/xeb/x94/xa0", "HANGUL SYLLABLE DILS");
+-   ("/xeb/x94/xa1", "HANGUL SYLLABLE DILT");
+-   ("/xeb/x94/xa2", "HANGUL SYLLABLE DILP");
+-   ("/xeb/x94/xa3", "HANGUL SYLLABLE DILH");
+-   ("/xeb/x94/xa4", "HANGUL SYLLABLE DIM");
+-   ("/xeb/x94/xa5", "HANGUL SYLLABLE DIB");
+-   ("/xeb/x94/xa6", "HANGUL SYLLABLE DIBS");
+-   ("/xeb/x94/xa7", "HANGUL SYLLABLE DIS");
+-   ("/xeb/x94/xa8", "HANGUL SYLLABLE DISS");
+-   ("/xeb/x94/xa9", "HANGUL SYLLABLE DING");
+-   ("/xeb/x94/xaa", "HANGUL SYLLABLE DIJ");
+-   ("/xeb/x94/xab", "HANGUL SYLLABLE DIC");
+-   ("/xeb/x94/xac", "HANGUL SYLLABLE DIK");
+-   ("/xeb/x94/xad", "HANGUL SYLLABLE DIT");
+-   ("/xeb/x94/xae", "HANGUL SYLLABLE DIP");
+-   ("/xeb/x94/xaf", "HANGUL SYLLABLE DIH");
+-   ("/xeb/x94/xb0", "HANGUL SYLLABLE DDA");
+-   ("/xeb/x94/xb1", "HANGUL SYLLABLE DDAG");
+-   ("/xeb/x94/xb2", "HANGUL SYLLABLE DDAGG");
+-   ("/xeb/x94/xb3", "HANGUL SYLLABLE DDAGS");
+-   ("/xeb/x94/xb4", "HANGUL SYLLABLE DDAN");
+-   ("/xeb/x94/xb5", "HANGUL SYLLABLE DDANI");
+-   ("/xeb/x94/xb6", "HANGUL SYLLABLE DDANH");
+-   ("/xeb/x94/xb7", "HANGUL SYLLABLE DDAD");
+-   ("/xeb/x94/xb8", "HANGUL SYLLABLE DDAL");
+-   ("/xeb/x94/xb9", "HANGUL SYLLABLE DDALG");
+-   ("/xeb/x94/xba", "HANGUL SYLLABLE DDALM");
+-   ("/xeb/x94/xbb", "HANGUL SYLLABLE DDALB");
+-   ("/xeb/x94/xbc", "HANGUL SYLLABLE DDALS");
+-   ("/xeb/x94/xbd", "HANGUL SYLLABLE DDALT");
+-   ("/xeb/x94/xbe", "HANGUL SYLLABLE DDALP");
+-   ("/xeb/x94/xbf", "HANGUL SYLLABLE DDALH");
+-   ("/xeb/x95/x80", "HANGUL SYLLABLE DDAM");
+-   ("/xeb/x95/x81", "HANGUL SYLLABLE DDAB");
+-   ("/xeb/x95/x82", "HANGUL SYLLABLE DDABS");
+-   ("/xeb/x95/x83", "HANGUL SYLLABLE DDAS");
+-   ("/xeb/x95/x84", "HANGUL SYLLABLE DDASS");
+-   ("/xeb/x95/x85", "HANGUL SYLLABLE DDANG");
+-   ("/xeb/x95/x86", "HANGUL SYLLABLE DDAJ");
+-   ("/xeb/x95/x87", "HANGUL SYLLABLE DDAC");
+-   ("/xeb/x95/x88", "HANGUL SYLLABLE DDAK");
+-   ("/xeb/x95/x89", "HANGUL SYLLABLE DDAT");
+-   ("/xeb/x95/x8a", "HANGUL SYLLABLE DDAP");
+-   ("/xeb/x95/x8b", "HANGUL SYLLABLE DDAH");
+-   ("/xeb/x95/x8c", "HANGUL SYLLABLE DDAE");
+-   ("/xeb/x95/x8d", "HANGUL SYLLABLE DDAEG");
+-   ("/xeb/x95/x8e", "HANGUL SYLLABLE DDAEGG");
+-   ("/xeb/x95/x8f", "HANGUL SYLLABLE DDAEGS");
+-   ("/xeb/x95/x90", "HANGUL SYLLABLE DDAEN");
+-   ("/xeb/x95/x91", "HANGUL SYLLABLE DDAENI");
+-   ("/xeb/x95/x92", "HANGUL SYLLABLE DDAENH");
+-   ("/xeb/x95/x93", "HANGUL SYLLABLE DDAED");
+-   ("/xeb/x95/x94", "HANGUL SYLLABLE DDAEL");
+-   ("/xeb/x95/x95", "HANGUL SYLLABLE DDAELG");
+-   ("/xeb/x95/x96", "HANGUL SYLLABLE DDAELM");
+-   ("/xeb/x95/x97", "HANGUL SYLLABLE DDAELB");
+-   ("/xeb/x95/x98", "HANGUL SYLLABLE DDAELS");
+-   ("/xeb/x95/x99", "HANGUL SYLLABLE DDAELT");
+-   ("/xeb/x95/x9a", "HANGUL SYLLABLE DDAELP");
+-   ("/xeb/x95/x9b", "HANGUL SYLLABLE DDAELH");
+-   ("/xeb/x95/x9c", "HANGUL SYLLABLE DDAEM");
+-   ("/xeb/x95/x9d", "HANGUL SYLLABLE DDAEB");
+-   ("/xeb/x95/x9e", "HANGUL SYLLABLE DDAEBS");
+-   ("/xeb/x95/x9f", "HANGUL SYLLABLE DDAES");
+-   ("/xeb/x95/xa0", "HANGUL SYLLABLE DDAESS");
+-   ("/xeb/x95/xa1", "HANGUL SYLLABLE DDAENG");
+-   ("/xeb/x95/xa2", "HANGUL SYLLABLE DDAEJ");
+-   ("/xeb/x95/xa3", "HANGUL SYLLABLE DDAEC");
+-   ("/xeb/x95/xa4", "HANGUL SYLLABLE DDAEK");
+-   ("/xeb/x95/xa5", "HANGUL SYLLABLE DDAET");
+-   ("/xeb/x95/xa6", "HANGUL SYLLABLE DDAEP");
+-   ("/xeb/x95/xa7", "HANGUL SYLLABLE DDAEH");
+-   ("/xeb/x95/xa8", "HANGUL SYLLABLE DDYA");
+-   ("/xeb/x95/xa9", "HANGUL SYLLABLE DDYAG");
+-   ("/xeb/x95/xaa", "HANGUL SYLLABLE DDYAGG");
+-   ("/xeb/x95/xab", "HANGUL SYLLABLE DDYAGS");
+-   ("/xeb/x95/xac", "HANGUL SYLLABLE DDYAN");
+-   ("/xeb/x95/xad", "HANGUL SYLLABLE DDYANI");
+-   ("/xeb/x95/xae", "HANGUL SYLLABLE DDYANH");
+-   ("/xeb/x95/xaf", "HANGUL SYLLABLE DDYAD");
+-   ("/xeb/x95/xb0", "HANGUL SYLLABLE DDYAL");
+-   ("/xeb/x95/xb1", "HANGUL SYLLABLE DDYALG");
+-   ("/xeb/x95/xb2", "HANGUL SYLLABLE DDYALM");
+-   ("/xeb/x95/xb3", "HANGUL SYLLABLE DDYALB");
+-   ("/xeb/x95/xb4", "HANGUL SYLLABLE DDYALS");
+-   ("/xeb/x95/xb5", "HANGUL SYLLABLE DDYALT");
+-   ("/xeb/x95/xb6", "HANGUL SYLLABLE DDYALP");
+-   ("/xeb/x95/xb7", "HANGUL SYLLABLE DDYALH");
+-   ("/xeb/x95/xb8", "HANGUL SYLLABLE DDYAM");
+-   ("/xeb/x95/xb9", "HANGUL SYLLABLE DDYAB");
+-   ("/xeb/x95/xba", "HANGUL SYLLABLE DDYABS");
+-   ("/xeb/x95/xbb", "HANGUL SYLLABLE DDYAS");
+-   ("/xeb/x95/xbc", "HANGUL SYLLABLE DDYASS");
+-   ("/xeb/x95/xbd", "HANGUL SYLLABLE DDYANG");
+-   ("/xeb/x95/xbe", "HANGUL SYLLABLE DDYAJ");
+-   ("/xeb/x95/xbf", "HANGUL SYLLABLE DDYAC");
+-   ("/xeb/x96/x80", "HANGUL SYLLABLE DDYAK");
+-   ("/xeb/x96/x81", "HANGUL SYLLABLE DDYAT");
+-   ("/xeb/x96/x82", "HANGUL SYLLABLE DDYAP");
+-   ("/xeb/x96/x83", "HANGUL SYLLABLE DDYAH");
+-   ("/xeb/x96/x84", "HANGUL SYLLABLE DDYAE");
+-   ("/xeb/x96/x85", "HANGUL SYLLABLE DDYAEG");
+-   ("/xeb/x96/x86", "HANGUL SYLLABLE DDYAEGG");
+-   ("/xeb/x96/x87", "HANGUL SYLLABLE DDYAEGS");
+-   ("/xeb/x96/x88", "HANGUL SYLLABLE DDYAEN");
+-   ("/xeb/x96/x89", "HANGUL SYLLABLE DDYAENI");
+-   ("/xeb/x96/x8a", "HANGUL SYLLABLE DDYAENH");
+-   ("/xeb/x96/x8b", "HANGUL SYLLABLE DDYAED");
+-   ("/xeb/x96/x8c", "HANGUL SYLLABLE DDYAEL");
+-   ("/xeb/x96/x8d", "HANGUL SYLLABLE DDYAELG");
+-   ("/xeb/x96/x8e", "HANGUL SYLLABLE DDYAELM");
+-   ("/xeb/x96/x8f", "HANGUL SYLLABLE DDYAELB");
+-   ("/xeb/x96/x90", "HANGUL SYLLABLE DDYAELS");
+-   ("/xeb/x96/x91", "HANGUL SYLLABLE DDYAELT");
+-   ("/xeb/x96/x92", "HANGUL SYLLABLE DDYAELP");
+-   ("/xeb/x96/x93", "HANGUL SYLLABLE DDYAELH");
+-   ("/xeb/x96/x94", "HANGUL SYLLABLE DDYAEM");
+-   ("/xeb/x96/x95", "HANGUL SYLLABLE DDYAEB");
+-   ("/xeb/x96/x96", "HANGUL SYLLABLE DDYAEBS");
+-   ("/xeb/x96/x97", "HANGUL SYLLABLE DDYAES");
+-   ("/xeb/x96/x98", "HANGUL SYLLABLE DDYAESS");
+-   ("/xeb/x96/x99", "HANGUL SYLLABLE DDYAENG");
+-   ("/xeb/x96/x9a", "HANGUL SYLLABLE DDYAEJ");
+-   ("/xeb/x96/x9b", "HANGUL SYLLABLE DDYAEC");
+-   ("/xeb/x96/x9c", "HANGUL SYLLABLE DDYAEK");
+-   ("/xeb/x96/x9d", "HANGUL SYLLABLE DDYAET");
+-   ("/xeb/x96/x9e", "HANGUL SYLLABLE DDYAEP");
+-   ("/xeb/x96/x9f", "HANGUL SYLLABLE DDYAEH");
+-   ("/xeb/x96/xa0", "HANGUL SYLLABLE DDEO");
+-   ("/xeb/x96/xa1", "HANGUL SYLLABLE DDEOG");
+-   ("/xeb/x96/xa2", "HANGUL SYLLABLE DDEOGG");
+-   ("/xeb/x96/xa3", "HANGUL SYLLABLE DDEOGS");
+-   ("/xeb/x96/xa4", "HANGUL SYLLABLE DDEON");
+-   ("/xeb/x96/xa5", "HANGUL SYLLABLE DDEONI");
+-   ("/xeb/x96/xa6", "HANGUL SYLLABLE DDEONH");
+-   ("/xeb/x96/xa7", "HANGUL SYLLABLE DDEOD");
+-   ("/xeb/x96/xa8", "HANGUL SYLLABLE DDEOL");
+-   ("/xeb/x96/xa9", "HANGUL SYLLABLE DDEOLG");
+-   ("/xeb/x96/xaa", "HANGUL SYLLABLE DDEOLM");
+-   ("/xeb/x96/xab", "HANGUL SYLLABLE DDEOLB");
+-   ("/xeb/x96/xac", "HANGUL SYLLABLE DDEOLS");
+-   ("/xeb/x96/xad", "HANGUL SYLLABLE DDEOLT");
+-   ("/xeb/x96/xae", "HANGUL SYLLABLE DDEOLP");
+-   ("/xeb/x96/xaf", "HANGUL SYLLABLE DDEOLH");
+-   ("/xeb/x96/xb0", "HANGUL SYLLABLE DDEOM");
+-   ("/xeb/x96/xb1", "HANGUL SYLLABLE DDEOB");
+-   ("/xeb/x96/xb2", "HANGUL SYLLABLE DDEOBS");
+-   ("/xeb/x96/xb3", "HANGUL SYLLABLE DDEOS");
+-   ("/xeb/x96/xb4", "HANGUL SYLLABLE DDEOSS");
+-   ("/xeb/x96/xb5", "HANGUL SYLLABLE DDEONG");
+-   ("/xeb/x96/xb6", "HANGUL SYLLABLE DDEOJ");
+-   ("/xeb/x96/xb7", "HANGUL SYLLABLE DDEOC");
+-   ("/xeb/x96/xb8", "HANGUL SYLLABLE DDEOK");
+-   ("/xeb/x96/xb9", "HANGUL SYLLABLE DDEOT");
+-   ("/xeb/x96/xba", "HANGUL SYLLABLE DDEOP");
+-   ("/xeb/x96/xbb", "HANGUL SYLLABLE DDEOH");
+-   ("/xeb/x96/xbc", "HANGUL SYLLABLE DDE");
+-   ("/xeb/x96/xbd", "HANGUL SYLLABLE DDEG");
+-   ("/xeb/x96/xbe", "HANGUL SYLLABLE DDEGG");
+-   ("/xeb/x96/xbf", "HANGUL SYLLABLE DDEGS");
+-   ("/xeb/x97/x80", "HANGUL SYLLABLE DDEN");
+-   ("/xeb/x97/x81", "HANGUL SYLLABLE DDENI");
+-   ("/xeb/x97/x82", "HANGUL SYLLABLE DDENH");
+-   ("/xeb/x97/x83", "HANGUL SYLLABLE DDED");
+-   ("/xeb/x97/x84", "HANGUL SYLLABLE DDEL");
+-   ("/xeb/x97/x85", "HANGUL SYLLABLE DDELG");
+-   ("/xeb/x97/x86", "HANGUL SYLLABLE DDELM");
+-   ("/xeb/x97/x87", "HANGUL SYLLABLE DDELB");
+-   ("/xeb/x97/x88", "HANGUL SYLLABLE DDELS");
+-   ("/xeb/x97/x89", "HANGUL SYLLABLE DDELT");
+-   ("/xeb/x97/x8a", "HANGUL SYLLABLE DDELP");
+-   ("/xeb/x97/x8b", "HANGUL SYLLABLE DDELH");
+-   ("/xeb/x97/x8c", "HANGUL SYLLABLE DDEM");
+-   ("/xeb/x97/x8d", "HANGUL SYLLABLE DDEB");
+-   ("/xeb/x97/x8e", "HANGUL SYLLABLE DDEBS");
+-   ("/xeb/x97/x8f", "HANGUL SYLLABLE DDES");
+-   ("/xeb/x97/x90", "HANGUL SYLLABLE DDESS");
+-   ("/xeb/x97/x91", "HANGUL SYLLABLE DDENG");
+-   ("/xeb/x97/x92", "HANGUL SYLLABLE DDEJ");
+-   ("/xeb/x97/x93", "HANGUL SYLLABLE DDEC");
+-   ("/xeb/x97/x94", "HANGUL SYLLABLE DDEK");
+-   ("/xeb/x97/x95", "HANGUL SYLLABLE DDET");
+-   ("/xeb/x97/x96", "HANGUL SYLLABLE DDEP");
+-   ("/xeb/x97/x97", "HANGUL SYLLABLE DDEH");
+-   ("/xeb/x97/x98", "HANGUL SYLLABLE DDYEO");
+-   ("/xeb/x97/x99", "HANGUL SYLLABLE DDYEOG");
+-   ("/xeb/x97/x9a", "HANGUL SYLLABLE DDYEOGG");
+-   ("/xeb/x97/x9b", "HANGUL SYLLABLE DDYEOGS");
+-   ("/xeb/x97/x9c", "HANGUL SYLLABLE DDYEON");
+-   ("/xeb/x97/x9d", "HANGUL SYLLABLE DDYEONI");
+-   ("/xeb/x97/x9e", "HANGUL SYLLABLE DDYEONH");
+-   ("/xeb/x97/x9f", "HANGUL SYLLABLE DDYEOD");
+-   ("/xeb/x97/xa0", "HANGUL SYLLABLE DDYEOL");
+-   ("/xeb/x97/xa1", "HANGUL SYLLABLE DDYEOLG");
+-   ("/xeb/x97/xa2", "HANGUL SYLLABLE DDYEOLM");
+-   ("/xeb/x97/xa3", "HANGUL SYLLABLE DDYEOLB");
+-   ("/xeb/x97/xa4", "HANGUL SYLLABLE DDYEOLS");
+-   ("/xeb/x97/xa5", "HANGUL SYLLABLE DDYEOLT");
+-   ("/xeb/x97/xa6", "HANGUL SYLLABLE DDYEOLP");
+-   ("/xeb/x97/xa7", "HANGUL SYLLABLE DDYEOLH");
+-   ("/xeb/x97/xa8", "HANGUL SYLLABLE DDYEOM");
+-   ("/xeb/x97/xa9", "HANGUL SYLLABLE DDYEOB");
+-   ("/xeb/x97/xaa", "HANGUL SYLLABLE DDYEOBS");
+-   ("/xeb/x97/xab", "HANGUL SYLLABLE DDYEOS");
+-   ("/xeb/x97/xac", "HANGUL SYLLABLE DDYEOSS");
+-   ("/xeb/x97/xad", "HANGUL SYLLABLE DDYEONG");
+-   ("/xeb/x97/xae", "HANGUL SYLLABLE DDYEOJ");
+-   ("/xeb/x97/xaf", "HANGUL SYLLABLE DDYEOC");
+-   ("/xeb/x97/xb0", "HANGUL SYLLABLE DDYEOK");
+-   ("/xeb/x97/xb1", "HANGUL SYLLABLE DDYEOT");
+-   ("/xeb/x97/xb2", "HANGUL SYLLABLE DDYEOP");
+-   ("/xeb/x97/xb3", "HANGUL SYLLABLE DDYEOH");
+-   ("/xeb/x97/xb4", "HANGUL SYLLABLE DDYE");
+-   ("/xeb/x97/xb5", "HANGUL SYLLABLE DDYEG");
+-   ("/xeb/x97/xb6", "HANGUL SYLLABLE DDYEGG");
+-   ("/xeb/x97/xb7", "HANGUL SYLLABLE DDYEGS");
+-   ("/xeb/x97/xb8", "HANGUL SYLLABLE DDYEN");
+-   ("/xeb/x97/xb9", "HANGUL SYLLABLE DDYENI");
+-   ("/xeb/x97/xba", "HANGUL SYLLABLE DDYENH");
+-   ("/xeb/x97/xbb", "HANGUL SYLLABLE DDYED");
+-   ("/xeb/x97/xbc", "HANGUL SYLLABLE DDYEL");
+-   ("/xeb/x97/xbd", "HANGUL SYLLABLE DDYELG");
+-   ("/xeb/x97/xbe", "HANGUL SYLLABLE DDYELM");
+-   ("/xeb/x97/xbf", "HANGUL SYLLABLE DDYELB");
+-   ("/xeb/x98/x80", "HANGUL SYLLABLE DDYELS");
+-   ("/xeb/x98/x81", "HANGUL SYLLABLE DDYELT");
+-   ("/xeb/x98/x82", "HANGUL SYLLABLE DDYELP");
+-   ("/xeb/x98/x83", "HANGUL SYLLABLE DDYELH");
+-   ("/xeb/x98/x84", "HANGUL SYLLABLE DDYEM");
+-   ("/xeb/x98/x85", "HANGUL SYLLABLE DDYEB");
+-   ("/xeb/x98/x86", "HANGUL SYLLABLE DDYEBS");
+-   ("/xeb/x98/x87", "HANGUL SYLLABLE DDYES");
+-   ("/xeb/x98/x88", "HANGUL SYLLABLE DDYESS");
+-   ("/xeb/x98/x89", "HANGUL SYLLABLE DDYENG");
+-   ("/xeb/x98/x8a", "HANGUL SYLLABLE DDYEJ");
+-   ("/xeb/x98/x8b", "HANGUL SYLLABLE DDYEC");
+-   ("/xeb/x98/x8c", "HANGUL SYLLABLE DDYEK");
+-   ("/xeb/x98/x8d", "HANGUL SYLLABLE DDYET");
+-   ("/xeb/x98/x8e", "HANGUL SYLLABLE DDYEP");
+-   ("/xeb/x98/x8f", "HANGUL SYLLABLE DDYEH");
+-   ("/xeb/x98/x90", "HANGUL SYLLABLE DDO");
+-   ("/xeb/x98/x91", "HANGUL SYLLABLE DDOG");
+-   ("/xeb/x98/x92", "HANGUL SYLLABLE DDOGG");
+-   ("/xeb/x98/x93", "HANGUL SYLLABLE DDOGS");
+-   ("/xeb/x98/x94", "HANGUL SYLLABLE DDON");
+-   ("/xeb/x98/x95", "HANGUL SYLLABLE DDONI");
+-   ("/xeb/x98/x96", "HANGUL SYLLABLE DDONH");
+-   ("/xeb/x98/x97", "HANGUL SYLLABLE DDOD");
+-   ("/xeb/x98/x98", "HANGUL SYLLABLE DDOL");
+-   ("/xeb/x98/x99", "HANGUL SYLLABLE DDOLG");
+-   ("/xeb/x98/x9a", "HANGUL SYLLABLE DDOLM");
+-   ("/xeb/x98/x9b", "HANGUL SYLLABLE DDOLB");
+-   ("/xeb/x98/x9c", "HANGUL SYLLABLE DDOLS");
+-   ("/xeb/x98/x9d", "HANGUL SYLLABLE DDOLT");
+-   ("/xeb/x98/x9e", "HANGUL SYLLABLE DDOLP");
+-   ("/xeb/x98/x9f", "HANGUL SYLLABLE DDOLH");
+-   ("/xeb/x98/xa0", "HANGUL SYLLABLE DDOM");
+-   ("/xeb/x98/xa1", "HANGUL SYLLABLE DDOB");
+-   ("/xeb/x98/xa2", "HANGUL SYLLABLE DDOBS");
+-   ("/xeb/x98/xa3", "HANGUL SYLLABLE DDOS");
+-   ("/xeb/x98/xa4", "HANGUL SYLLABLE DDOSS");
+-   ("/xeb/x98/xa5", "HANGUL SYLLABLE DDONG");
+-   ("/xeb/x98/xa6", "HANGUL SYLLABLE DDOJ");
+-   ("/xeb/x98/xa7", "HANGUL SYLLABLE DDOC");
+-   ("/xeb/x98/xa8", "HANGUL SYLLABLE DDOK");
+-   ("/xeb/x98/xa9", "HANGUL SYLLABLE DDOT");
+-   ("/xeb/x98/xaa", "HANGUL SYLLABLE DDOP");
+-   ("/xeb/x98/xab", "HANGUL SYLLABLE DDOH");
+-   ("/xeb/x98/xac", "HANGUL SYLLABLE DDWA");
+-   ("/xeb/x98/xad", "HANGUL SYLLABLE DDWAG");
+-   ("/xeb/x98/xae", "HANGUL SYLLABLE DDWAGG");
+-   ("/xeb/x98/xaf", "HANGUL SYLLABLE DDWAGS");
+-   ("/xeb/x98/xb0", "HANGUL SYLLABLE DDWAN");
+-   ("/xeb/x98/xb1", "HANGUL SYLLABLE DDWANI");
+-   ("/xeb/x98/xb2", "HANGUL SYLLABLE DDWANH");
+-   ("/xeb/x98/xb3", "HANGUL SYLLABLE DDWAD");
+-   ("/xeb/x98/xb4", "HANGUL SYLLABLE DDWAL");
+-   ("/xeb/x98/xb5", "HANGUL SYLLABLE DDWALG");
+-   ("/xeb/x98/xb6", "HANGUL SYLLABLE DDWALM");
+-   ("/xeb/x98/xb7", "HANGUL SYLLABLE DDWALB");
+-   ("/xeb/x98/xb8", "HANGUL SYLLABLE DDWALS");
+-   ("/xeb/x98/xb9", "HANGUL SYLLABLE DDWALT");
+-   ("/xeb/x98/xba", "HANGUL SYLLABLE DDWALP");
+-   ("/xeb/x98/xbb", "HANGUL SYLLABLE DDWALH");
+-   ("/xeb/x98/xbc", "HANGUL SYLLABLE DDWAM");
+-   ("/xeb/x98/xbd", "HANGUL SYLLABLE DDWAB");
+-   ("/xeb/x98/xbe", "HANGUL SYLLABLE DDWABS");
+-   ("/xeb/x98/xbf", "HANGUL SYLLABLE DDWAS");
+-   ("/xeb/x99/x80", "HANGUL SYLLABLE DDWASS");
+-   ("/xeb/x99/x81", "HANGUL SYLLABLE DDWANG");
+-   ("/xeb/x99/x82", "HANGUL SYLLABLE DDWAJ");
+-   ("/xeb/x99/x83", "HANGUL SYLLABLE DDWAC");
+-   ("/xeb/x99/x84", "HANGUL SYLLABLE DDWAK");
+-   ("/xeb/x99/x85", "HANGUL SYLLABLE DDWAT");
+-   ("/xeb/x99/x86", "HANGUL SYLLABLE DDWAP");
+-   ("/xeb/x99/x87", "HANGUL SYLLABLE DDWAH");
+-   ("/xeb/x99/x88", "HANGUL SYLLABLE DDWAE");
+-   ("/xeb/x99/x89", "HANGUL SYLLABLE DDWAEG");
+-   ("/xeb/x99/x8a", "HANGUL SYLLABLE DDWAEGG");
+-   ("/xeb/x99/x8b", "HANGUL SYLLABLE DDWAEGS");
+-   ("/xeb/x99/x8c", "HANGUL SYLLABLE DDWAEN");
+-   ("/xeb/x99/x8d", "HANGUL SYLLABLE DDWAENI");
+-   ("/xeb/x99/x8e", "HANGUL SYLLABLE DDWAENH");
+-   ("/xeb/x99/x8f", "HANGUL SYLLABLE DDWAED");
+-   ("/xeb/x99/x90", "HANGUL SYLLABLE DDWAEL");
+-   ("/xeb/x99/x91", "HANGUL SYLLABLE DDWAELG");
+-   ("/xeb/x99/x92", "HANGUL SYLLABLE DDWAELM");
+-   ("/xeb/x99/x93", "HANGUL SYLLABLE DDWAELB");
+-   ("/xeb/x99/x94", "HANGUL SYLLABLE DDWAELS");
+-   ("/xeb/x99/x95", "HANGUL SYLLABLE DDWAELT");
+-   ("/xeb/x99/x96", "HANGUL SYLLABLE DDWAELP");
+-   ("/xeb/x99/x97", "HANGUL SYLLABLE DDWAELH");
+-   ("/xeb/x99/x98", "HANGUL SYLLABLE DDWAEM");
+-   ("/xeb/x99/x99", "HANGUL SYLLABLE DDWAEB");
+-   ("/xeb/x99/x9a", "HANGUL SYLLABLE DDWAEBS");
+-   ("/xeb/x99/x9b", "HANGUL SYLLABLE DDWAES");
+-   ("/xeb/x99/x9c", "HANGUL SYLLABLE DDWAESS");
+-   ("/xeb/x99/x9d", "HANGUL SYLLABLE DDWAENG");
+-   ("/xeb/x99/x9e", "HANGUL SYLLABLE DDWAEJ");
+-   ("/xeb/x99/x9f", "HANGUL SYLLABLE DDWAEC");
+-   ("/xeb/x99/xa0", "HANGUL SYLLABLE DDWAEK");
+-   ("/xeb/x99/xa1", "HANGUL SYLLABLE DDWAET");
+-   ("/xeb/x99/xa2", "HANGUL SYLLABLE DDWAEP");
+-   ("/xeb/x99/xa3", "HANGUL SYLLABLE DDWAEH");
+-   ("/xeb/x99/xa4", "HANGUL SYLLABLE DDOE");
+-   ("/xeb/x99/xa5", "HANGUL SYLLABLE DDOEG");
+-   ("/xeb/x99/xa6", "HANGUL SYLLABLE DDOEGG");
+-   ("/xeb/x99/xa7", "HANGUL SYLLABLE DDOEGS");
+-   ("/xeb/x99/xa8", "HANGUL SYLLABLE DDOEN");
+-   ("/xeb/x99/xa9", "HANGUL SYLLABLE DDOENI");
+-   ("/xeb/x99/xaa", "HANGUL SYLLABLE DDOENH");
+-   ("/xeb/x99/xab", "HANGUL SYLLABLE DDOED");
+-   ("/xeb/x99/xac", "HANGUL SYLLABLE DDOEL");
+-   ("/xeb/x99/xad", "HANGUL SYLLABLE DDOELG");
+-   ("/xeb/x99/xae", "HANGUL SYLLABLE DDOELM");
+-   ("/xeb/x99/xaf", "HANGUL SYLLABLE DDOELB");
+-   ("/xeb/x99/xb0", "HANGUL SYLLABLE DDOELS");
+-   ("/xeb/x99/xb1", "HANGUL SYLLABLE DDOELT");
+-   ("/xeb/x99/xb2", "HANGUL SYLLABLE DDOELP");
+-   ("/xeb/x99/xb3", "HANGUL SYLLABLE DDOELH");
+-   ("/xeb/x99/xb4", "HANGUL SYLLABLE DDOEM");
+-   ("/xeb/x99/xb5", "HANGUL SYLLABLE DDOEB");
+-   ("/xeb/x99/xb6", "HANGUL SYLLABLE DDOEBS");
+-   ("/xeb/x99/xb7", "HANGUL SYLLABLE DDOES");
+-   ("/xeb/x99/xb8", "HANGUL SYLLABLE DDOESS");
+-   ("/xeb/x99/xb9", "HANGUL SYLLABLE DDOENG");
+-   ("/xeb/x99/xba", "HANGUL SYLLABLE DDOEJ");
+-   ("/xeb/x99/xbb", "HANGUL SYLLABLE DDOEC");
+-   ("/xeb/x99/xbc", "HANGUL SYLLABLE DDOEK");
+-   ("/xeb/x99/xbd", "HANGUL SYLLABLE DDOET");
+-   ("/xeb/x99/xbe", "HANGUL SYLLABLE DDOEP");
+-   ("/xeb/x99/xbf", "HANGUL SYLLABLE DDOEH");
+-   ("/xeb/x9a/x80", "HANGUL SYLLABLE DDYO");
+-   ("/xeb/x9a/x81", "HANGUL SYLLABLE DDYOG");
+-   ("/xeb/x9a/x82", "HANGUL SYLLABLE DDYOGG");
+-   ("/xeb/x9a/x83", "HANGUL SYLLABLE DDYOGS");
+-   ("/xeb/x9a/x84", "HANGUL SYLLABLE DDYON");
+-   ("/xeb/x9a/x85", "HANGUL SYLLABLE DDYONI");
+-   ("/xeb/x9a/x86", "HANGUL SYLLABLE DDYONH");
+-   ("/xeb/x9a/x87", "HANGUL SYLLABLE DDYOD");
+-   ("/xeb/x9a/x88", "HANGUL SYLLABLE DDYOL");
+-   ("/xeb/x9a/x89", "HANGUL SYLLABLE DDYOLG");
+-   ("/xeb/x9a/x8a", "HANGUL SYLLABLE DDYOLM");
+-   ("/xeb/x9a/x8b", "HANGUL SYLLABLE DDYOLB");
+-   ("/xeb/x9a/x8c", "HANGUL SYLLABLE DDYOLS");
+-   ("/xeb/x9a/x8d", "HANGUL SYLLABLE DDYOLT");
+-   ("/xeb/x9a/x8e", "HANGUL SYLLABLE DDYOLP");
+-   ("/xeb/x9a/x8f", "HANGUL SYLLABLE DDYOLH");
+-   ("/xeb/x9a/x90", "HANGUL SYLLABLE DDYOM");
+-   ("/xeb/x9a/x91", "HANGUL SYLLABLE DDYOB");
+-   ("/xeb/x9a/x92", "HANGUL SYLLABLE DDYOBS");
+-   ("/xeb/x9a/x93", "HANGUL SYLLABLE DDYOS");
+-   ("/xeb/x9a/x94", "HANGUL SYLLABLE DDYOSS");
+-   ("/xeb/x9a/x95", "HANGUL SYLLABLE DDYONG");
+-   ("/xeb/x9a/x96", "HANGUL SYLLABLE DDYOJ");
+-   ("/xeb/x9a/x97", "HANGUL SYLLABLE DDYOC");
+-   ("/xeb/x9a/x98", "HANGUL SYLLABLE DDYOK");
+-   ("/xeb/x9a/x99", "HANGUL SYLLABLE DDYOT");
+-   ("/xeb/x9a/x9a", "HANGUL SYLLABLE DDYOP");
+-   ("/xeb/x9a/x9b", "HANGUL SYLLABLE DDYOH");
+-   ("/xeb/x9a/x9c", "HANGUL SYLLABLE DDU");
+-   ("/xeb/x9a/x9d", "HANGUL SYLLABLE DDUG");
+-   ("/xeb/x9a/x9e", "HANGUL SYLLABLE DDUGG");
+-   ("/xeb/x9a/x9f", "HANGUL SYLLABLE DDUGS");
+-   ("/xeb/x9a/xa0", "HANGUL SYLLABLE DDUN");
+-   ("/xeb/x9a/xa1", "HANGUL SYLLABLE DDUNI");
+-   ("/xeb/x9a/xa2", "HANGUL SYLLABLE DDUNH");
+-   ("/xeb/x9a/xa3", "HANGUL SYLLABLE DDUD");
+-   ("/xeb/x9a/xa4", "HANGUL SYLLABLE DDUL");
+-   ("/xeb/x9a/xa5", "HANGUL SYLLABLE DDULG");
+-   ("/xeb/x9a/xa6", "HANGUL SYLLABLE DDULM");
+-   ("/xeb/x9a/xa7", "HANGUL SYLLABLE DDULB");
+-   ("/xeb/x9a/xa8", "HANGUL SYLLABLE DDULS");
+-   ("/xeb/x9a/xa9", "HANGUL SYLLABLE DDULT");
+-   ("/xeb/x9a/xaa", "HANGUL SYLLABLE DDULP");
+-   ("/xeb/x9a/xab", "HANGUL SYLLABLE DDULH");
+-   ("/xeb/x9a/xac", "HANGUL SYLLABLE DDUM");
+-   ("/xeb/x9a/xad", "HANGUL SYLLABLE DDUB");
+-   ("/xeb/x9a/xae", "HANGUL SYLLABLE DDUBS");
+-   ("/xeb/x9a/xaf", "HANGUL SYLLABLE DDUS");
+-   ("/xeb/x9a/xb0", "HANGUL SYLLABLE DDUSS");
+-   ("/xeb/x9a/xb1", "HANGUL SYLLABLE DDUNG");
+-   ("/xeb/x9a/xb2", "HANGUL SYLLABLE DDUJ");
+-   ("/xeb/x9a/xb3", "HANGUL SYLLABLE DDUC");
+-   ("/xeb/x9a/xb4", "HANGUL SYLLABLE DDUK");
+-   ("/xeb/x9a/xb5", "HANGUL SYLLABLE DDUT");
+-   ("/xeb/x9a/xb6", "HANGUL SYLLABLE DDUP");
+-   ("/xeb/x9a/xb7", "HANGUL SYLLABLE DDUH");
+-   ("/xeb/x9a/xb8", "HANGUL SYLLABLE DDWEO");
+-   ("/xeb/x9a/xb9", "HANGUL SYLLABLE DDWEOG");
+-   ("/xeb/x9a/xba", "HANGUL SYLLABLE DDWEOGG");
+-   ("/xeb/x9a/xbb", "HANGUL SYLLABLE DDWEOGS");
+-   ("/xeb/x9a/xbc", "HANGUL SYLLABLE DDWEON");
+-   ("/xeb/x9a/xbd", "HANGUL SYLLABLE DDWEONI");
+-   ("/xeb/x9a/xbe", "HANGUL SYLLABLE DDWEONH");
+-   ("/xeb/x9a/xbf", "HANGUL SYLLABLE DDWEOD");
+-   ("/xeb/x9b/x80", "HANGUL SYLLABLE DDWEOL");
+-   ("/xeb/x9b/x81", "HANGUL SYLLABLE DDWEOLG");
+-   ("/xeb/x9b/x82", "HANGUL SYLLABLE DDWEOLM");
+-   ("/xeb/x9b/x83", "HANGUL SYLLABLE DDWEOLB");
+-   ("/xeb/x9b/x84", "HANGUL SYLLABLE DDWEOLS");
+-   ("/xeb/x9b/x85", "HANGUL SYLLABLE DDWEOLT");
+-   ("/xeb/x9b/x86", "HANGUL SYLLABLE DDWEOLP");
+-   ("/xeb/x9b/x87", "HANGUL SYLLABLE DDWEOLH");
+-   ("/xeb/x9b/x88", "HANGUL SYLLABLE DDWEOM");
+-   ("/xeb/x9b/x89", "HANGUL SYLLABLE DDWEOB");
+-   ("/xeb/x9b/x8a", "HANGUL SYLLABLE DDWEOBS");
+-   ("/xeb/x9b/x8b", "HANGUL SYLLABLE DDWEOS");
+-   ("/xeb/x9b/x8c", "HANGUL SYLLABLE DDWEOSS");
+-   ("/xeb/x9b/x8d", "HANGUL SYLLABLE DDWEONG");
+-   ("/xeb/x9b/x8e", "HANGUL SYLLABLE DDWEOJ");
+-   ("/xeb/x9b/x8f", "HANGUL SYLLABLE DDWEOC");
+-   ("/xeb/x9b/x90", "HANGUL SYLLABLE DDWEOK");
+-   ("/xeb/x9b/x91", "HANGUL SYLLABLE DDWEOT");
+-   ("/xeb/x9b/x92", "HANGUL SYLLABLE DDWEOP");
+-   ("/xeb/x9b/x93", "HANGUL SYLLABLE DDWEOH");
+-   ("/xeb/x9b/x94", "HANGUL SYLLABLE DDWE");
+-   ("/xeb/x9b/x95", "HANGUL SYLLABLE DDWEG");
+-   ("/xeb/x9b/x96", "HANGUL SYLLABLE DDWEGG");
+-   ("/xeb/x9b/x97", "HANGUL SYLLABLE DDWEGS");
+-   ("/xeb/x9b/x98", "HANGUL SYLLABLE DDWEN");
+-   ("/xeb/x9b/x99", "HANGUL SYLLABLE DDWENI");
+-   ("/xeb/x9b/x9a", "HANGUL SYLLABLE DDWENH");
+-   ("/xeb/x9b/x9b", "HANGUL SYLLABLE DDWED");
+-   ("/xeb/x9b/x9c", "HANGUL SYLLABLE DDWEL");
+-   ("/xeb/x9b/x9d", "HANGUL SYLLABLE DDWELG");
+-   ("/xeb/x9b/x9e", "HANGUL SYLLABLE DDWELM");
+-   ("/xeb/x9b/x9f", "HANGUL SYLLABLE DDWELB");
+-   ("/xeb/x9b/xa0", "HANGUL SYLLABLE DDWELS");
+-   ("/xeb/x9b/xa1", "HANGUL SYLLABLE DDWELT");
+-   ("/xeb/x9b/xa2", "HANGUL SYLLABLE DDWELP");
+-   ("/xeb/x9b/xa3", "HANGUL SYLLABLE DDWELH");
+-   ("/xeb/x9b/xa4", "HANGUL SYLLABLE DDWEM");
+-   ("/xeb/x9b/xa5", "HANGUL SYLLABLE DDWEB");
+-   ("/xeb/x9b/xa6", "HANGUL SYLLABLE DDWEBS");
+-   ("/xeb/x9b/xa7", "HANGUL SYLLABLE DDWES");
+-   ("/xeb/x9b/xa8", "HANGUL SYLLABLE DDWESS");
+-   ("/xeb/x9b/xa9", "HANGUL SYLLABLE DDWENG");
+-   ("/xeb/x9b/xaa", "HANGUL SYLLABLE DDWEJ");
+-   ("/xeb/x9b/xab", "HANGUL SYLLABLE DDWEC");
+-   ("/xeb/x9b/xac", "HANGUL SYLLABLE DDWEK");
+-   ("/xeb/x9b/xad", "HANGUL SYLLABLE DDWET");
+-   ("/xeb/x9b/xae", "HANGUL SYLLABLE DDWEP");
+-   ("/xeb/x9b/xaf", "HANGUL SYLLABLE DDWEH");
+-   ("/xeb/x9b/xb0", "HANGUL SYLLABLE DDWI");
+-   ("/xeb/x9b/xb1", "HANGUL SYLLABLE DDWIG");
+-   ("/xeb/x9b/xb2", "HANGUL SYLLABLE DDWIGG");
+-   ("/xeb/x9b/xb3", "HANGUL SYLLABLE DDWIGS");
+-   ("/xeb/x9b/xb4", "HANGUL SYLLABLE DDWIN");
+-   ("/xeb/x9b/xb5", "HANGUL SYLLABLE DDWINI");
+-   ("/xeb/x9b/xb6", "HANGUL SYLLABLE DDWINH");
+-   ("/xeb/x9b/xb7", "HANGUL SYLLABLE DDWID");
+-   ("/xeb/x9b/xb8", "HANGUL SYLLABLE DDWIL");
+-   ("/xeb/x9b/xb9", "HANGUL SYLLABLE DDWILG");
+-   ("/xeb/x9b/xba", "HANGUL SYLLABLE DDWILM");
+-   ("/xeb/x9b/xbb", "HANGUL SYLLABLE DDWILB");
+-   ("/xeb/x9b/xbc", "HANGUL SYLLABLE DDWILS");
+-   ("/xeb/x9b/xbd", "HANGUL SYLLABLE DDWILT");
+-   ("/xeb/x9b/xbe", "HANGUL SYLLABLE DDWILP");
+-   ("/xeb/x9b/xbf", "HANGUL SYLLABLE DDWILH");
+-   ("/xeb/x9c/x80", "HANGUL SYLLABLE DDWIM");
+-   ("/xeb/x9c/x81", "HANGUL SYLLABLE DDWIB");
+-   ("/xeb/x9c/x82", "HANGUL SYLLABLE DDWIBS");
+-   ("/xeb/x9c/x83", "HANGUL SYLLABLE DDWIS");
+-   ("/xeb/x9c/x84", "HANGUL SYLLABLE DDWISS");
+-   ("/xeb/x9c/x85", "HANGUL SYLLABLE DDWING");
+-   ("/xeb/x9c/x86", "HANGUL SYLLABLE DDWIJ");
+-   ("/xeb/x9c/x87", "HANGUL SYLLABLE DDWIC");
+-   ("/xeb/x9c/x88", "HANGUL SYLLABLE DDWIK");
+-   ("/xeb/x9c/x89", "HANGUL SYLLABLE DDWIT");
+-   ("/xeb/x9c/x8a", "HANGUL SYLLABLE DDWIP");
+-   ("/xeb/x9c/x8b", "HANGUL SYLLABLE DDWIH");
+-   ("/xeb/x9c/x8c", "HANGUL SYLLABLE DDYU");
+-   ("/xeb/x9c/x8d", "HANGUL SYLLABLE DDYUG");
+-   ("/xeb/x9c/x8e", "HANGUL SYLLABLE DDYUGG");
+-   ("/xeb/x9c/x8f", "HANGUL SYLLABLE DDYUGS");
+-   ("/xeb/x9c/x90", "HANGUL SYLLABLE DDYUN");
+-   ("/xeb/x9c/x91", "HANGUL SYLLABLE DDYUNI");
+-   ("/xeb/x9c/x92", "HANGUL SYLLABLE DDYUNH");
+-   ("/xeb/x9c/x93", "HANGUL SYLLABLE DDYUD");
+-   ("/xeb/x9c/x94", "HANGUL SYLLABLE DDYUL");
+-   ("/xeb/x9c/x95", "HANGUL SYLLABLE DDYULG");
+-   ("/xeb/x9c/x96", "HANGUL SYLLABLE DDYULM");
+-   ("/xeb/x9c/x97", "HANGUL SYLLABLE DDYULB");
+-   ("/xeb/x9c/x98", "HANGUL SYLLABLE DDYULS");
+-   ("/xeb/x9c/x99", "HANGUL SYLLABLE DDYULT");
+-   ("/xeb/x9c/x9a", "HANGUL SYLLABLE DDYULP");
+-   ("/xeb/x9c/x9b", "HANGUL SYLLABLE DDYULH");
+-   ("/xeb/x9c/x9c", "HANGUL SYLLABLE DDYUM");
+-   ("/xeb/x9c/x9d", "HANGUL SYLLABLE DDYUB");
+-   ("/xeb/x9c/x9e", "HANGUL SYLLABLE DDYUBS");
+-   ("/xeb/x9c/x9f", "HANGUL SYLLABLE DDYUS");
+-   ("/xeb/x9c/xa0", "HANGUL SYLLABLE DDYUSS");
+-   ("/xeb/x9c/xa1", "HANGUL SYLLABLE DDYUNG");
+-   ("/xeb/x9c/xa2", "HANGUL SYLLABLE DDYUJ");
+-   ("/xeb/x9c/xa3", "HANGUL SYLLABLE DDYUC");
+-   ("/xeb/x9c/xa4", "HANGUL SYLLABLE DDYUK");
+-   ("/xeb/x9c/xa5", "HANGUL SYLLABLE DDYUT");
+-   ("/xeb/x9c/xa6", "HANGUL SYLLABLE DDYUP");
+-   ("/xeb/x9c/xa7", "HANGUL SYLLABLE DDYUH");
+-   ("/xeb/x9c/xa8", "HANGUL SYLLABLE DDEU");
+-   ("/xeb/x9c/xa9", "HANGUL SYLLABLE DDEUG");
+-   ("/xeb/x9c/xaa", "HANGUL SYLLABLE DDEUGG");
+-   ("/xeb/x9c/xab", "HANGUL SYLLABLE DDEUGS");
+-   ("/xeb/x9c/xac", "HANGUL SYLLABLE DDEUN");
+-   ("/xeb/x9c/xad", "HANGUL SYLLABLE DDEUNI");
+-   ("/xeb/x9c/xae", "HANGUL SYLLABLE DDEUNH");
+-   ("/xeb/x9c/xaf", "HANGUL SYLLABLE DDEUD");
+-   ("/xeb/x9c/xb0", "HANGUL SYLLABLE DDEUL");
+-   ("/xeb/x9c/xb1", "HANGUL SYLLABLE DDEULG");
+-   ("/xeb/x9c/xb2", "HANGUL SYLLABLE DDEULM");
+-   ("/xeb/x9c/xb3", "HANGUL SYLLABLE DDEULB");
+-   ("/xeb/x9c/xb4", "HANGUL SYLLABLE DDEULS");
+-   ("/xeb/x9c/xb5", "HANGUL SYLLABLE DDEULT");
+-   ("/xeb/x9c/xb6", "HANGUL SYLLABLE DDEULP");
+-   ("/xeb/x9c/xb7", "HANGUL SYLLABLE DDEULH");
+-   ("/xeb/x9c/xb8", "HANGUL SYLLABLE DDEUM");
+-   ("/xeb/x9c/xb9", "HANGUL SYLLABLE DDEUB");
+-   ("/xeb/x9c/xba", "HANGUL SYLLABLE DDEUBS");
+-   ("/xeb/x9c/xbb", "HANGUL SYLLABLE DDEUS");
+-   ("/xeb/x9c/xbc", "HANGUL SYLLABLE DDEUSS");
+-   ("/xeb/x9c/xbd", "HANGUL SYLLABLE DDEUNG");
+-   ("/xeb/x9c/xbe", "HANGUL SYLLABLE DDEUJ");
+-   ("/xeb/x9c/xbf", "HANGUL SYLLABLE DDEUC");
+-   ("/xeb/x9d/x80", "HANGUL SYLLABLE DDEUK");
+-   ("/xeb/x9d/x81", "HANGUL SYLLABLE DDEUT");
+-   ("/xeb/x9d/x82", "HANGUL SYLLABLE DDEUP");
+-   ("/xeb/x9d/x83", "HANGUL SYLLABLE DDEUH");
+-   ("/xeb/x9d/x84", "HANGUL SYLLABLE DDYI");
+-   ("/xeb/x9d/x85", "HANGUL SYLLABLE DDYIG");
+-   ("/xeb/x9d/x86", "HANGUL SYLLABLE DDYIGG");
+-   ("/xeb/x9d/x87", "HANGUL SYLLABLE DDYIGS");
+-   ("/xeb/x9d/x88", "HANGUL SYLLABLE DDYIN");
+-   ("/xeb/x9d/x89", "HANGUL SYLLABLE DDYINI");
+-   ("/xeb/x9d/x8a", "HANGUL SYLLABLE DDYINH");
+-   ("/xeb/x9d/x8b", "HANGUL SYLLABLE DDYID");
+-   ("/xeb/x9d/x8c", "HANGUL SYLLABLE DDYIL");
+-   ("/xeb/x9d/x8d", "HANGUL SYLLABLE DDYILG");
+-   ("/xeb/x9d/x8e", "HANGUL SYLLABLE DDYILM");
+-   ("/xeb/x9d/x8f", "HANGUL SYLLABLE DDYILB");
+-   ("/xeb/x9d/x90", "HANGUL SYLLABLE DDYILS");
+-   ("/xeb/x9d/x91", "HANGUL SYLLABLE DDYILT");
+-   ("/xeb/x9d/x92", "HANGUL SYLLABLE DDYILP");
+-   ("/xeb/x9d/x93", "HANGUL SYLLABLE DDYILH");
+-   ("/xeb/x9d/x94", "HANGUL SYLLABLE DDYIM");
+-   ("/xeb/x9d/x95", "HANGUL SYLLABLE DDYIB");
+-   ("/xeb/x9d/x96", "HANGUL SYLLABLE DDYIBS");
+-   ("/xeb/x9d/x97", "HANGUL SYLLABLE DDYIS");
+-   ("/xeb/x9d/x98", "HANGUL SYLLABLE DDYISS");
+-   ("/xeb/x9d/x99", "HANGUL SYLLABLE DDYING");
+-   ("/xeb/x9d/x9a", "HANGUL SYLLABLE DDYIJ");
+-   ("/xeb/x9d/x9b", "HANGUL SYLLABLE DDYIC");
+-   ("/xeb/x9d/x9c", "HANGUL SYLLABLE DDYIK");
+-   ("/xeb/x9d/x9d", "HANGUL SYLLABLE DDYIT");
+-   ("/xeb/x9d/x9e", "HANGUL SYLLABLE DDYIP");
+-   ("/xeb/x9d/x9f", "HANGUL SYLLABLE DDYIH");
+-   ("/xeb/x9d/xa0", "HANGUL SYLLABLE DDI");
+-   ("/xeb/x9d/xa1", "HANGUL SYLLABLE DDIG");
+-   ("/xeb/x9d/xa2", "HANGUL SYLLABLE DDIGG");
+-   ("/xeb/x9d/xa3", "HANGUL SYLLABLE DDIGS");
+-   ("/xeb/x9d/xa4", "HANGUL SYLLABLE DDIN");
+-   ("/xeb/x9d/xa5", "HANGUL SYLLABLE DDINI");
+-   ("/xeb/x9d/xa6", "HANGUL SYLLABLE DDINH");
+-   ("/xeb/x9d/xa7", "HANGUL SYLLABLE DDID");
+-   ("/xeb/x9d/xa8", "HANGUL SYLLABLE DDIL");
+-   ("/xeb/x9d/xa9", "HANGUL SYLLABLE DDILG");
+-   ("/xeb/x9d/xaa", "HANGUL SYLLABLE DDILM");
+-   ("/xeb/x9d/xab", "HANGUL SYLLABLE DDILB");
+-   ("/xeb/x9d/xac", "HANGUL SYLLABLE DDILS");
+-   ("/xeb/x9d/xad", "HANGUL SYLLABLE DDILT");
+-   ("/xeb/x9d/xae", "HANGUL SYLLABLE DDILP");
+-   ("/xeb/x9d/xaf", "HANGUL SYLLABLE DDILH");
+-   ("/xeb/x9d/xb0", "HANGUL SYLLABLE DDIM");
+-   ("/xeb/x9d/xb1", "HANGUL SYLLABLE DDIB");
+-   ("/xeb/x9d/xb2", "HANGUL SYLLABLE DDIBS");
+-   ("/xeb/x9d/xb3", "HANGUL SYLLABLE DDIS");
+-   ("/xeb/x9d/xb4", "HANGUL SYLLABLE DDISS");
+-   ("/xeb/x9d/xb5", "HANGUL SYLLABLE DDING");
+-   ("/xeb/x9d/xb6", "HANGUL SYLLABLE DDIJ");
+-   ("/xeb/x9d/xb7", "HANGUL SYLLABLE DDIC");
+-   ("/xeb/x9d/xb8", "HANGUL SYLLABLE DDIK");
+-   ("/xeb/x9d/xb9", "HANGUL SYLLABLE DDIT");
+-   ("/xeb/x9d/xba", "HANGUL SYLLABLE DDIP");
+-   ("/xeb/x9d/xbb", "HANGUL SYLLABLE DDIH");
+-   ("/xeb/x9d/xbc", "HANGUL SYLLABLE RA");
+-   ("/xeb/x9d/xbd", "HANGUL SYLLABLE RAG");
+-   ("/xeb/x9d/xbe", "HANGUL SYLLABLE RAGG");
+-   ("/xeb/x9d/xbf", "HANGUL SYLLABLE RAGS");
+-   ("/xeb/x9e/x80", "HANGUL SYLLABLE RAN");
+-   ("/xeb/x9e/x81", "HANGUL SYLLABLE RANI");
+-   ("/xeb/x9e/x82", "HANGUL SYLLABLE RANH");
+-   ("/xeb/x9e/x83", "HANGUL SYLLABLE RAD");
+-   ("/xeb/x9e/x84", "HANGUL SYLLABLE RAL");
+-   ("/xeb/x9e/x85", "HANGUL SYLLABLE RALG");
+-   ("/xeb/x9e/x86", "HANGUL SYLLABLE RALM");
+-   ("/xeb/x9e/x87", "HANGUL SYLLABLE RALB");
+-   ("/xeb/x9e/x88", "HANGUL SYLLABLE RALS");
+-   ("/xeb/x9e/x89", "HANGUL SYLLABLE RALT");
+-   ("/xeb/x9e/x8a", "HANGUL SYLLABLE RALP");
+-   ("/xeb/x9e/x8b", "HANGUL SYLLABLE RALH");
+-   ("/xeb/x9e/x8c", "HANGUL SYLLABLE RAM");
+-   ("/xeb/x9e/x8d", "HANGUL SYLLABLE RAB");
+-   ("/xeb/x9e/x8e", "HANGUL SYLLABLE RABS");
+-   ("/xeb/x9e/x8f", "HANGUL SYLLABLE RAS");
+-   ("/xeb/x9e/x90", "HANGUL SYLLABLE RASS");
+-   ("/xeb/x9e/x91", "HANGUL SYLLABLE RANG");
+-   ("/xeb/x9e/x92", "HANGUL SYLLABLE RAJ");
+-   ("/xeb/x9e/x93", "HANGUL SYLLABLE RAC");
+-   ("/xeb/x9e/x94", "HANGUL SYLLABLE RAK");
+-   ("/xeb/x9e/x95", "HANGUL SYLLABLE RAT");
+-   ("/xeb/x9e/x96", "HANGUL SYLLABLE RAP");
+-   ("/xeb/x9e/x97", "HANGUL SYLLABLE RAH");
+-   ("/xeb/x9e/x98", "HANGUL SYLLABLE RAE");
+-   ("/xeb/x9e/x99", "HANGUL SYLLABLE RAEG");
+-   ("/xeb/x9e/x9a", "HANGUL SYLLABLE RAEGG");
+-   ("/xeb/x9e/x9b", "HANGUL SYLLABLE RAEGS");
+-   ("/xeb/x9e/x9c", "HANGUL SYLLABLE RAEN");
+-   ("/xeb/x9e/x9d", "HANGUL SYLLABLE RAENI");
+-   ("/xeb/x9e/x9e", "HANGUL SYLLABLE RAENH");
+-   ("/xeb/x9e/x9f", "HANGUL SYLLABLE RAED");
+-   ("/xeb/x9e/xa0", "HANGUL SYLLABLE RAEL");
+-   ("/xeb/x9e/xa1", "HANGUL SYLLABLE RAELG");
+-   ("/xeb/x9e/xa2", "HANGUL SYLLABLE RAELM");
+-   ("/xeb/x9e/xa3", "HANGUL SYLLABLE RAELB");
+-   ("/xeb/x9e/xa4", "HANGUL SYLLABLE RAELS");
+-   ("/xeb/x9e/xa5", "HANGUL SYLLABLE RAELT");
+-   ("/xeb/x9e/xa6", "HANGUL SYLLABLE RAELP");
+-   ("/xeb/x9e/xa7", "HANGUL SYLLABLE RAELH");
+-   ("/xeb/x9e/xa8", "HANGUL SYLLABLE RAEM");
+-   ("/xeb/x9e/xa9", "HANGUL SYLLABLE RAEB");
+-   ("/xeb/x9e/xaa", "HANGUL SYLLABLE RAEBS");
+-   ("/xeb/x9e/xab", "HANGUL SYLLABLE RAES");
+-   ("/xeb/x9e/xac", "HANGUL SYLLABLE RAESS");
+-   ("/xeb/x9e/xad", "HANGUL SYLLABLE RAENG");
+-   ("/xeb/x9e/xae", "HANGUL SYLLABLE RAEJ");
+-   ("/xeb/x9e/xaf", "HANGUL SYLLABLE RAEC");
+-   ("/xeb/x9e/xb0", "HANGUL SYLLABLE RAEK");
+-   ("/xeb/x9e/xb1", "HANGUL SYLLABLE RAET");
+-   ("/xeb/x9e/xb2", "HANGUL SYLLABLE RAEP");
+-   ("/xeb/x9e/xb3", "HANGUL SYLLABLE RAEH");
+-   ("/xeb/x9e/xb4", "HANGUL SYLLABLE RYA");
+-   ("/xeb/x9e/xb5", "HANGUL SYLLABLE RYAG");
+-   ("/xeb/x9e/xb6", "HANGUL SYLLABLE RYAGG");
+-   ("/xeb/x9e/xb7", "HANGUL SYLLABLE RYAGS");
+-   ("/xeb/x9e/xb8", "HANGUL SYLLABLE RYAN");
+-   ("/xeb/x9e/xb9", "HANGUL SYLLABLE RYANI");
+-   ("/xeb/x9e/xba", "HANGUL SYLLABLE RYANH");
+-   ("/xeb/x9e/xbb", "HANGUL SYLLABLE RYAD");
+-   ("/xeb/x9e/xbc", "HANGUL SYLLABLE RYAL");
+-   ("/xeb/x9e/xbd", "HANGUL SYLLABLE RYALG");
+-   ("/xeb/x9e/xbe", "HANGUL SYLLABLE RYALM");
+-   ("/xeb/x9e/xbf", "HANGUL SYLLABLE RYALB");
+-   ("/xeb/x9f/x80", "HANGUL SYLLABLE RYALS");
+-   ("/xeb/x9f/x81", "HANGUL SYLLABLE RYALT");
+-   ("/xeb/x9f/x82", "HANGUL SYLLABLE RYALP");
+-   ("/xeb/x9f/x83", "HANGUL SYLLABLE RYALH");
+-   ("/xeb/x9f/x84", "HANGUL SYLLABLE RYAM");
+-   ("/xeb/x9f/x85", "HANGUL SYLLABLE RYAB");
+-   ("/xeb/x9f/x86", "HANGUL SYLLABLE RYABS");
+-   ("/xeb/x9f/x87", "HANGUL SYLLABLE RYAS");
+-   ("/xeb/x9f/x88", "HANGUL SYLLABLE RYASS");
+-   ("/xeb/x9f/x89", "HANGUL SYLLABLE RYANG");
+-   ("/xeb/x9f/x8a", "HANGUL SYLLABLE RYAJ");
+-   ("/xeb/x9f/x8b", "HANGUL SYLLABLE RYAC");
+-   ("/xeb/x9f/x8c", "HANGUL SYLLABLE RYAK");
+-   ("/xeb/x9f/x8d", "HANGUL SYLLABLE RYAT");
+-   ("/xeb/x9f/x8e", "HANGUL SYLLABLE RYAP");
+-   ("/xeb/x9f/x8f", "HANGUL SYLLABLE RYAH");
+-   ("/xeb/x9f/x90", "HANGUL SYLLABLE RYAE");
+-   ("/xeb/x9f/x91", "HANGUL SYLLABLE RYAEG");
+-   ("/xeb/x9f/x92", "HANGUL SYLLABLE RYAEGG");
+-   ("/xeb/x9f/x93", "HANGUL SYLLABLE RYAEGS");
+-   ("/xeb/x9f/x94", "HANGUL SYLLABLE RYAEN");
+-   ("/xeb/x9f/x95", "HANGUL SYLLABLE RYAENI");
+-   ("/xeb/x9f/x96", "HANGUL SYLLABLE RYAENH");
+-   ("/xeb/x9f/x97", "HANGUL SYLLABLE RYAED");
+-   ("/xeb/x9f/x98", "HANGUL SYLLABLE RYAEL");
+-   ("/xeb/x9f/x99", "HANGUL SYLLABLE RYAELG");
+-   ("/xeb/x9f/x9a", "HANGUL SYLLABLE RYAELM");
+-   ("/xeb/x9f/x9b", "HANGUL SYLLABLE RYAELB");
+-   ("/xeb/x9f/x9c", "HANGUL SYLLABLE RYAELS");
+-   ("/xeb/x9f/x9d", "HANGUL SYLLABLE RYAELT");
+-   ("/xeb/x9f/x9e", "HANGUL SYLLABLE RYAELP");
+-   ("/xeb/x9f/x9f", "HANGUL SYLLABLE RYAELH");
+-   ("/xeb/x9f/xa0", "HANGUL SYLLABLE RYAEM");
+-   ("/xeb/x9f/xa1", "HANGUL SYLLABLE RYAEB");
+-   ("/xeb/x9f/xa2", "HANGUL SYLLABLE RYAEBS");
+-   ("/xeb/x9f/xa3", "HANGUL SYLLABLE RYAES");
+-   ("/xeb/x9f/xa4", "HANGUL SYLLABLE RYAESS");
+-   ("/xeb/x9f/xa5", "HANGUL SYLLABLE RYAENG");
+-   ("/xeb/x9f/xa6", "HANGUL SYLLABLE RYAEJ");
+-   ("/xeb/x9f/xa7", "HANGUL SYLLABLE RYAEC");
+-   ("/xeb/x9f/xa8", "HANGUL SYLLABLE RYAEK");
+-   ("/xeb/x9f/xa9", "HANGUL SYLLABLE RYAET");
+-   ("/xeb/x9f/xaa", "HANGUL SYLLABLE RYAEP");
+-   ("/xeb/x9f/xab", "HANGUL SYLLABLE RYAEH");
+-   ("/xeb/x9f/xac", "HANGUL SYLLABLE REO");
+-   ("/xeb/x9f/xad", "HANGUL SYLLABLE REOG");
+-   ("/xeb/x9f/xae", "HANGUL SYLLABLE REOGG");
+-   ("/xeb/x9f/xaf", "HANGUL SYLLABLE REOGS");
+-   ("/xeb/x9f/xb0", "HANGUL SYLLABLE REON");
+-   ("/xeb/x9f/xb1", "HANGUL SYLLABLE REONI");
+-   ("/xeb/x9f/xb2", "HANGUL SYLLABLE REONH");
+-   ("/xeb/x9f/xb3", "HANGUL SYLLABLE REOD");
+-   ("/xeb/x9f/xb4", "HANGUL SYLLABLE REOL");
+-   ("/xeb/x9f/xb5", "HANGUL SYLLABLE REOLG");
+-   ("/xeb/x9f/xb6", "HANGUL SYLLABLE REOLM");
+-   ("/xeb/x9f/xb7", "HANGUL SYLLABLE REOLB");
+-   ("/xeb/x9f/xb8", "HANGUL SYLLABLE REOLS");
+-   ("/xeb/x9f/xb9", "HANGUL SYLLABLE REOLT");
+-   ("/xeb/x9f/xba", "HANGUL SYLLABLE REOLP");
+-   ("/xeb/x9f/xbb", "HANGUL SYLLABLE REOLH");
+-   ("/xeb/x9f/xbc", "HANGUL SYLLABLE REOM");
+-   ("/xeb/x9f/xbd", "HANGUL SYLLABLE REOB");
+-   ("/xeb/x9f/xbe", "HANGUL SYLLABLE REOBS");
+-   ("/xeb/x9f/xbf", "HANGUL SYLLABLE REOS");
+-   ("/xeb/xa0/x80", "HANGUL SYLLABLE REOSS");
+-   ("/xeb/xa0/x81", "HANGUL SYLLABLE REONG");
+-   ("/xeb/xa0/x82", "HANGUL SYLLABLE REOJ");
+-   ("/xeb/xa0/x83", "HANGUL SYLLABLE REOC");
+-   ("/xeb/xa0/x84", "HANGUL SYLLABLE REOK");
+-   ("/xeb/xa0/x85", "HANGUL SYLLABLE REOT");
+-   ("/xeb/xa0/x86", "HANGUL SYLLABLE REOP");
+-   ("/xeb/xa0/x87", "HANGUL SYLLABLE REOH");
+-   ("/xeb/xa0/x88", "HANGUL SYLLABLE RE");
+-   ("/xeb/xa0/x89", "HANGUL SYLLABLE REG");
+-   ("/xeb/xa0/x8a", "HANGUL SYLLABLE REGG");
+-   ("/xeb/xa0/x8b", "HANGUL SYLLABLE REGS");
+-   ("/xeb/xa0/x8c", "HANGUL SYLLABLE REN");
+-   ("/xeb/xa0/x8d", "HANGUL SYLLABLE RENI");
+-   ("/xeb/xa0/x8e", "HANGUL SYLLABLE RENH");
+-   ("/xeb/xa0/x8f", "HANGUL SYLLABLE RED");
+-   ("/xeb/xa0/x90", "HANGUL SYLLABLE REL");
+-   ("/xeb/xa0/x91", "HANGUL SYLLABLE RELG");
+-   ("/xeb/xa0/x92", "HANGUL SYLLABLE RELM");
+-   ("/xeb/xa0/x93", "HANGUL SYLLABLE RELB");
+-   ("/xeb/xa0/x94", "HANGUL SYLLABLE RELS");
+-   ("/xeb/xa0/x95", "HANGUL SYLLABLE RELT");
+-   ("/xeb/xa0/x96", "HANGUL SYLLABLE RELP");
+-   ("/xeb/xa0/x97", "HANGUL SYLLABLE RELH");
+-   ("/xeb/xa0/x98", "HANGUL SYLLABLE REM");
+-   ("/xeb/xa0/x99", "HANGUL SYLLABLE REB");
+-   ("/xeb/xa0/x9a", "HANGUL SYLLABLE REBS");
+-   ("/xeb/xa0/x9b", "HANGUL SYLLABLE RES");
+-   ("/xeb/xa0/x9c", "HANGUL SYLLABLE RESS");
+-   ("/xeb/xa0/x9d", "HANGUL SYLLABLE RENG");
+-   ("/xeb/xa0/x9e", "HANGUL SYLLABLE REJ");
+-   ("/xeb/xa0/x9f", "HANGUL SYLLABLE REC");
+-   ("/xeb/xa0/xa0", "HANGUL SYLLABLE REK");
+-   ("/xeb/xa0/xa1", "HANGUL SYLLABLE RET");
+-   ("/xeb/xa0/xa2", "HANGUL SYLLABLE REP");
+-   ("/xeb/xa0/xa3", "HANGUL SYLLABLE REH");
+-   ("/xeb/xa0/xa4", "HANGUL SYLLABLE RYEO");
+-   ("/xeb/xa0/xa5", "HANGUL SYLLABLE RYEOG");
+-   ("/xeb/xa0/xa6", "HANGUL SYLLABLE RYEOGG");
+-   ("/xeb/xa0/xa7", "HANGUL SYLLABLE RYEOGS");
+-   ("/xeb/xa0/xa8", "HANGUL SYLLABLE RYEON");
+-   ("/xeb/xa0/xa9", "HANGUL SYLLABLE RYEONI");
+-   ("/xeb/xa0/xaa", "HANGUL SYLLABLE RYEONH");
+-   ("/xeb/xa0/xab", "HANGUL SYLLABLE RYEOD");
+-   ("/xeb/xa0/xac", "HANGUL SYLLABLE RYEOL");
+-   ("/xeb/xa0/xad", "HANGUL SYLLABLE RYEOLG");
+-   ("/xeb/xa0/xae", "HANGUL SYLLABLE RYEOLM");
+-   ("/xeb/xa0/xaf", "HANGUL SYLLABLE RYEOLB");
+-   ("/xeb/xa0/xb0", "HANGUL SYLLABLE RYEOLS");
+-   ("/xeb/xa0/xb1", "HANGUL SYLLABLE RYEOLT");
+-   ("/xeb/xa0/xb2", "HANGUL SYLLABLE RYEOLP");
+-   ("/xeb/xa0/xb3", "HANGUL SYLLABLE RYEOLH");
+-   ("/xeb/xa0/xb4", "HANGUL SYLLABLE RYEOM");
+-   ("/xeb/xa0/xb5", "HANGUL SYLLABLE RYEOB");
+-   ("/xeb/xa0/xb6", "HANGUL SYLLABLE RYEOBS");
+-   ("/xeb/xa0/xb7", "HANGUL SYLLABLE RYEOS");
+-   ("/xeb/xa0/xb8", "HANGUL SYLLABLE RYEOSS");
+-   ("/xeb/xa0/xb9", "HANGUL SYLLABLE RYEONG");
+-   ("/xeb/xa0/xba", "HANGUL SYLLABLE RYEOJ");
+-   ("/xeb/xa0/xbb", "HANGUL SYLLABLE RYEOC");
+-   ("/xeb/xa0/xbc", "HANGUL SYLLABLE RYEOK");
+-   ("/xeb/xa0/xbd", "HANGUL SYLLABLE RYEOT");
+-   ("/xeb/xa0/xbe", "HANGUL SYLLABLE RYEOP");
+-   ("/xeb/xa0/xbf", "HANGUL SYLLABLE RYEOH");
+-   ("/xeb/xa1/x80", "HANGUL SYLLABLE RYE");
+-   ("/xeb/xa1/x81", "HANGUL SYLLABLE RYEG");
+-   ("/xeb/xa1/x82", "HANGUL SYLLABLE RYEGG");
+-   ("/xeb/xa1/x83", "HANGUL SYLLABLE RYEGS");
+-   ("/xeb/xa1/x84", "HANGUL SYLLABLE RYEN");
+-   ("/xeb/xa1/x85", "HANGUL SYLLABLE RYENI");
+-   ("/xeb/xa1/x86", "HANGUL SYLLABLE RYENH");
+-   ("/xeb/xa1/x87", "HANGUL SYLLABLE RYED");
+-   ("/xeb/xa1/x88", "HANGUL SYLLABLE RYEL");
+-   ("/xeb/xa1/x89", "HANGUL SYLLABLE RYELG");
+-   ("/xeb/xa1/x8a", "HANGUL SYLLABLE RYELM");
+-   ("/xeb/xa1/x8b", "HANGUL SYLLABLE RYELB");
+-   ("/xeb/xa1/x8c", "HANGUL SYLLABLE RYELS");
+-   ("/xeb/xa1/x8d", "HANGUL SYLLABLE RYELT");
+-   ("/xeb/xa1/x8e", "HANGUL SYLLABLE RYELP");
+-   ("/xeb/xa1/x8f", "HANGUL SYLLABLE RYELH");
+-   ("/xeb/xa1/x90", "HANGUL SYLLABLE RYEM");
+-   ("/xeb/xa1/x91", "HANGUL SYLLABLE RYEB");
+-   ("/xeb/xa1/x92", "HANGUL SYLLABLE RYEBS");
+-   ("/xeb/xa1/x93", "HANGUL SYLLABLE RYES");
+-   ("/xeb/xa1/x94", "HANGUL SYLLABLE RYESS");
+-   ("/xeb/xa1/x95", "HANGUL SYLLABLE RYENG");
+-   ("/xeb/xa1/x96", "HANGUL SYLLABLE RYEJ");
+-   ("/xeb/xa1/x97", "HANGUL SYLLABLE RYEC");
+-   ("/xeb/xa1/x98", "HANGUL SYLLABLE RYEK");
+-   ("/xeb/xa1/x99", "HANGUL SYLLABLE RYET");
+-   ("/xeb/xa1/x9a", "HANGUL SYLLABLE RYEP");
+-   ("/xeb/xa1/x9b", "HANGUL SYLLABLE RYEH");
+-   ("/xeb/xa1/x9c", "HANGUL SYLLABLE RO");
+-   ("/xeb/xa1/x9d", "HANGUL SYLLABLE ROG");
+-   ("/xeb/xa1/x9e", "HANGUL SYLLABLE ROGG");
+-   ("/xeb/xa1/x9f", "HANGUL SYLLABLE ROGS");
+-   ("/xeb/xa1/xa0", "HANGUL SYLLABLE RON");
+-   ("/xeb/xa1/xa1", "HANGUL SYLLABLE RONI");
+-   ("/xeb/xa1/xa2", "HANGUL SYLLABLE RONH");
+-   ("/xeb/xa1/xa3", "HANGUL SYLLABLE ROD");
+-   ("/xeb/xa1/xa4", "HANGUL SYLLABLE ROL");
+-   ("/xeb/xa1/xa5", "HANGUL SYLLABLE ROLG");
+-   ("/xeb/xa1/xa6", "HANGUL SYLLABLE ROLM");
+-   ("/xeb/xa1/xa7", "HANGUL SYLLABLE ROLB");
+-   ("/xeb/xa1/xa8", "HANGUL SYLLABLE ROLS");
+-   ("/xeb/xa1/xa9", "HANGUL SYLLABLE ROLT");
+-   ("/xeb/xa1/xaa", "HANGUL SYLLABLE ROLP");
+-   ("/xeb/xa1/xab", "HANGUL SYLLABLE ROLH");
+-   ("/xeb/xa1/xac", "HANGUL SYLLABLE ROM");
+-   ("/xeb/xa1/xad", "HANGUL SYLLABLE ROB");
+-   ("/xeb/xa1/xae", "HANGUL SYLLABLE ROBS");
+-   ("/xeb/xa1/xaf", "HANGUL SYLLABLE ROS");
+-   ("/xeb/xa1/xb0", "HANGUL SYLLABLE ROSS");
+-   ("/xeb/xa1/xb1", "HANGUL SYLLABLE RONG");
+-   ("/xeb/xa1/xb2", "HANGUL SYLLABLE ROJ");
+-   ("/xeb/xa1/xb3", "HANGUL SYLLABLE ROC");
+-   ("/xeb/xa1/xb4", "HANGUL SYLLABLE ROK");
+-   ("/xeb/xa1/xb5", "HANGUL SYLLABLE ROT");
+-   ("/xeb/xa1/xb6", "HANGUL SYLLABLE ROP");
+-   ("/xeb/xa1/xb7", "HANGUL SYLLABLE ROH");
+-   ("/xeb/xa1/xb8", "HANGUL SYLLABLE RWA");
+-   ("/xeb/xa1/xb9", "HANGUL SYLLABLE RWAG");
+-   ("/xeb/xa1/xba", "HANGUL SYLLABLE RWAGG");
+-   ("/xeb/xa1/xbb", "HANGUL SYLLABLE RWAGS");
+-   ("/xeb/xa1/xbc", "HANGUL SYLLABLE RWAN");
+-   ("/xeb/xa1/xbd", "HANGUL SYLLABLE RWANI");
+-   ("/xeb/xa1/xbe", "HANGUL SYLLABLE RWANH");
+-   ("/xeb/xa1/xbf", "HANGUL SYLLABLE RWAD");
+-   ("/xeb/xa2/x80", "HANGUL SYLLABLE RWAL");
+-   ("/xeb/xa2/x81", "HANGUL SYLLABLE RWALG");
+-   ("/xeb/xa2/x82", "HANGUL SYLLABLE RWALM");
+-   ("/xeb/xa2/x83", "HANGUL SYLLABLE RWALB");
+-   ("/xeb/xa2/x84", "HANGUL SYLLABLE RWALS");
+-   ("/xeb/xa2/x85", "HANGUL SYLLABLE RWALT");
+-   ("/xeb/xa2/x86", "HANGUL SYLLABLE RWALP");
+-   ("/xeb/xa2/x87", "HANGUL SYLLABLE RWALH");
+-   ("/xeb/xa2/x88", "HANGUL SYLLABLE RWAM");
+-   ("/xeb/xa2/x89", "HANGUL SYLLABLE RWAB");
+-   ("/xeb/xa2/x8a", "HANGUL SYLLABLE RWABS");
+-   ("/xeb/xa2/x8b", "HANGUL SYLLABLE RWAS");
+-   ("/xeb/xa2/x8c", "HANGUL SYLLABLE RWASS");
+-   ("/xeb/xa2/x8d", "HANGUL SYLLABLE RWANG");
+-   ("/xeb/xa2/x8e", "HANGUL SYLLABLE RWAJ");
+-   ("/xeb/xa2/x8f", "HANGUL SYLLABLE RWAC");
+-   ("/xeb/xa2/x90", "HANGUL SYLLABLE RWAK");
+-   ("/xeb/xa2/x91", "HANGUL SYLLABLE RWAT");
+-   ("/xeb/xa2/x92", "HANGUL SYLLABLE RWAP");
+-   ("/xeb/xa2/x93", "HANGUL SYLLABLE RWAH");
+-   ("/xeb/xa2/x94", "HANGUL SYLLABLE RWAE");
+-   ("/xeb/xa2/x95", "HANGUL SYLLABLE RWAEG");
+-   ("/xeb/xa2/x96", "HANGUL SYLLABLE RWAEGG");
+-   ("/xeb/xa2/x97", "HANGUL SYLLABLE RWAEGS");
+-   ("/xeb/xa2/x98", "HANGUL SYLLABLE RWAEN");
+-   ("/xeb/xa2/x99", "HANGUL SYLLABLE RWAENI");
+-   ("/xeb/xa2/x9a", "HANGUL SYLLABLE RWAENH");
+-   ("/xeb/xa2/x9b", "HANGUL SYLLABLE RWAED");
+-   ("/xeb/xa2/x9c", "HANGUL SYLLABLE RWAEL");
+-   ("/xeb/xa2/x9d", "HANGUL SYLLABLE RWAELG");
+-   ("/xeb/xa2/x9e", "HANGUL SYLLABLE RWAELM");
+-   ("/xeb/xa2/x9f", "HANGUL SYLLABLE RWAELB");
+-   ("/xeb/xa2/xa0", "HANGUL SYLLABLE RWAELS");
+-   ("/xeb/xa2/xa1", "HANGUL SYLLABLE RWAELT");
+-   ("/xeb/xa2/xa2", "HANGUL SYLLABLE RWAELP");
+-   ("/xeb/xa2/xa3", "HANGUL SYLLABLE RWAELH");
+-   ("/xeb/xa2/xa4", "HANGUL SYLLABLE RWAEM");
+-   ("/xeb/xa2/xa5", "HANGUL SYLLABLE RWAEB");
+-   ("/xeb/xa2/xa6", "HANGUL SYLLABLE RWAEBS");
+-   ("/xeb/xa2/xa7", "HANGUL SYLLABLE RWAES");
+-   ("/xeb/xa2/xa8", "HANGUL SYLLABLE RWAESS");
+-   ("/xeb/xa2/xa9", "HANGUL SYLLABLE RWAENG");
+-   ("/xeb/xa2/xaa", "HANGUL SYLLABLE RWAEJ");
+-   ("/xeb/xa2/xab", "HANGUL SYLLABLE RWAEC");
+-   ("/xeb/xa2/xac", "HANGUL SYLLABLE RWAEK");
+-   ("/xeb/xa2/xad", "HANGUL SYLLABLE RWAET");
+-   ("/xeb/xa2/xae", "HANGUL SYLLABLE RWAEP");
+-   ("/xeb/xa2/xaf", "HANGUL SYLLABLE RWAEH");
+-   ("/xeb/xa2/xb0", "HANGUL SYLLABLE ROE");
+-   ("/xeb/xa2/xb1", "HANGUL SYLLABLE ROEG");
+-   ("/xeb/xa2/xb2", "HANGUL SYLLABLE ROEGG");
+-   ("/xeb/xa2/xb3", "HANGUL SYLLABLE ROEGS");
+-   ("/xeb/xa2/xb4", "HANGUL SYLLABLE ROEN");
+-   ("/xeb/xa2/xb5", "HANGUL SYLLABLE ROENI");
+-   ("/xeb/xa2/xb6", "HANGUL SYLLABLE ROENH");
+-   ("/xeb/xa2/xb7", "HANGUL SYLLABLE ROED");
+-   ("/xeb/xa2/xb8", "HANGUL SYLLABLE ROEL");
+-   ("/xeb/xa2/xb9", "HANGUL SYLLABLE ROELG");
+-   ("/xeb/xa2/xba", "HANGUL SYLLABLE ROELM");
+-   ("/xeb/xa2/xbb", "HANGUL SYLLABLE ROELB");
+-   ("/xeb/xa2/xbc", "HANGUL SYLLABLE ROELS");
+-   ("/xeb/xa2/xbd", "HANGUL SYLLABLE ROELT");
+-   ("/xeb/xa2/xbe", "HANGUL SYLLABLE ROELP");
+-   ("/xeb/xa2/xbf", "HANGUL SYLLABLE ROELH");
+-   ("/xeb/xa3/x80", "HANGUL SYLLABLE ROEM");
+-   ("/xeb/xa3/x81", "HANGUL SYLLABLE ROEB");
+-   ("/xeb/xa3/x82", "HANGUL SYLLABLE ROEBS");
+-   ("/xeb/xa3/x83", "HANGUL SYLLABLE ROES");
+-   ("/xeb/xa3/x84", "HANGUL SYLLABLE ROESS");
+-   ("/xeb/xa3/x85", "HANGUL SYLLABLE ROENG");
+-   ("/xeb/xa3/x86", "HANGUL SYLLABLE ROEJ");
+-   ("/xeb/xa3/x87", "HANGUL SYLLABLE ROEC");
+-   ("/xeb/xa3/x88", "HANGUL SYLLABLE ROEK");
+-   ("/xeb/xa3/x89", "HANGUL SYLLABLE ROET");
+-   ("/xeb/xa3/x8a", "HANGUL SYLLABLE ROEP");
+-   ("/xeb/xa3/x8b", "HANGUL SYLLABLE ROEH");
+-   ("/xeb/xa3/x8c", "HANGUL SYLLABLE RYO");
+-   ("/xeb/xa3/x8d", "HANGUL SYLLABLE RYOG");
+-   ("/xeb/xa3/x8e", "HANGUL SYLLABLE RYOGG");
+-   ("/xeb/xa3/x8f", "HANGUL SYLLABLE RYOGS");
+-   ("/xeb/xa3/x90", "HANGUL SYLLABLE RYON");
+-   ("/xeb/xa3/x91", "HANGUL SYLLABLE RYONI");
+-   ("/xeb/xa3/x92", "HANGUL SYLLABLE RYONH");
+-   ("/xeb/xa3/x93", "HANGUL SYLLABLE RYOD");
+-   ("/xeb/xa3/x94", "HANGUL SYLLABLE RYOL");
+-   ("/xeb/xa3/x95", "HANGUL SYLLABLE RYOLG");
+-   ("/xeb/xa3/x96", "HANGUL SYLLABLE RYOLM");
+-   ("/xeb/xa3/x97", "HANGUL SYLLABLE RYOLB");
+-   ("/xeb/xa3/x98", "HANGUL SYLLABLE RYOLS");
+-   ("/xeb/xa3/x99", "HANGUL SYLLABLE RYOLT");
+-   ("/xeb/xa3/x9a", "HANGUL SYLLABLE RYOLP");
+-   ("/xeb/xa3/x9b", "HANGUL SYLLABLE RYOLH");
+-   ("/xeb/xa3/x9c", "HANGUL SYLLABLE RYOM");
+-   ("/xeb/xa3/x9d", "HANGUL SYLLABLE RYOB");
+-   ("/xeb/xa3/x9e", "HANGUL SYLLABLE RYOBS");
+-   ("/xeb/xa3/x9f", "HANGUL SYLLABLE RYOS");
+-   ("/xeb/xa3/xa0", "HANGUL SYLLABLE RYOSS");
+-   ("/xeb/xa3/xa1", "HANGUL SYLLABLE RYONG");
+-   ("/xeb/xa3/xa2", "HANGUL SYLLABLE RYOJ");
+-   ("/xeb/xa3/xa3", "HANGUL SYLLABLE RYOC");
+-   ("/xeb/xa3/xa4", "HANGUL SYLLABLE RYOK");
+-   ("/xeb/xa3/xa5", "HANGUL SYLLABLE RYOT");
+-   ("/xeb/xa3/xa6", "HANGUL SYLLABLE RYOP");
+-   ("/xeb/xa3/xa7", "HANGUL SYLLABLE RYOH");
+-   ("/xeb/xa3/xa8", "HANGUL SYLLABLE RU");
+-   ("/xeb/xa3/xa9", "HANGUL SYLLABLE RUG");
+-   ("/xeb/xa3/xaa", "HANGUL SYLLABLE RUGG");
+-   ("/xeb/xa3/xab", "HANGUL SYLLABLE RUGS");
+-   ("/xeb/xa3/xac", "HANGUL SYLLABLE RUN");
+-   ("/xeb/xa3/xad", "HANGUL SYLLABLE RUNI");
+-   ("/xeb/xa3/xae", "HANGUL SYLLABLE RUNH");
+-   ("/xeb/xa3/xaf", "HANGUL SYLLABLE RUD");
+-   ("/xeb/xa3/xb0", "HANGUL SYLLABLE RUL");
+-   ("/xeb/xa3/xb1", "HANGUL SYLLABLE RULG");
+-   ("/xeb/xa3/xb2", "HANGUL SYLLABLE RULM");
+-   ("/xeb/xa3/xb3", "HANGUL SYLLABLE RULB");
+-   ("/xeb/xa3/xb4", "HANGUL SYLLABLE RULS");
+-   ("/xeb/xa3/xb5", "HANGUL SYLLABLE RULT");
+-   ("/xeb/xa3/xb6", "HANGUL SYLLABLE RULP");
+-   ("/xeb/xa3/xb7", "HANGUL SYLLABLE RULH");
+-   ("/xeb/xa3/xb8", "HANGUL SYLLABLE RUM");
+-   ("/xeb/xa3/xb9", "HANGUL SYLLABLE RUB");
+-   ("/xeb/xa3/xba", "HANGUL SYLLABLE RUBS");
+-   ("/xeb/xa3/xbb", "HANGUL SYLLABLE RUS");
+-   ("/xeb/xa3/xbc", "HANGUL SYLLABLE RUSS");
+-   ("/xeb/xa3/xbd", "HANGUL SYLLABLE RUNG");
+-   ("/xeb/xa3/xbe", "HANGUL SYLLABLE RUJ");
+-   ("/xeb/xa3/xbf", "HANGUL SYLLABLE RUC");
+-   ("/xeb/xa4/x80", "HANGUL SYLLABLE RUK");
+-   ("/xeb/xa4/x81", "HANGUL SYLLABLE RUT");
+-   ("/xeb/xa4/x82", "HANGUL SYLLABLE RUP");
+-   ("/xeb/xa4/x83", "HANGUL SYLLABLE RUH");
+-   ("/xeb/xa4/x84", "HANGUL SYLLABLE RWEO");
+-   ("/xeb/xa4/x85", "HANGUL SYLLABLE RWEOG");
+-   ("/xeb/xa4/x86", "HANGUL SYLLABLE RWEOGG");
+-   ("/xeb/xa4/x87", "HANGUL SYLLABLE RWEOGS");
+-   ("/xeb/xa4/x88", "HANGUL SYLLABLE RWEON");
+-   ("/xeb/xa4/x89", "HANGUL SYLLABLE RWEONI");
+-   ("/xeb/xa4/x8a", "HANGUL SYLLABLE RWEONH");
+-   ("/xeb/xa4/x8b", "HANGUL SYLLABLE RWEOD");
+-   ("/xeb/xa4/x8c", "HANGUL SYLLABLE RWEOL");
+-   ("/xeb/xa4/x8d", "HANGUL SYLLABLE RWEOLG");
+-   ("/xeb/xa4/x8e", "HANGUL SYLLABLE RWEOLM");
+-   ("/xeb/xa4/x8f", "HANGUL SYLLABLE RWEOLB");
+-   ("/xeb/xa4/x90", "HANGUL SYLLABLE RWEOLS");
+-   ("/xeb/xa4/x91", "HANGUL SYLLABLE RWEOLT");
+-   ("/xeb/xa4/x92", "HANGUL SYLLABLE RWEOLP");
+-   ("/xeb/xa4/x93", "HANGUL SYLLABLE RWEOLH");
+-   ("/xeb/xa4/x94", "HANGUL SYLLABLE RWEOM");
+-   ("/xeb/xa4/x95", "HANGUL SYLLABLE RWEOB");
+-   ("/xeb/xa4/x96", "HANGUL SYLLABLE RWEOBS");
+-   ("/xeb/xa4/x97", "HANGUL SYLLABLE RWEOS");
+-   ("/xeb/xa4/x98", "HANGUL SYLLABLE RWEOSS");
+-   ("/xeb/xa4/x99", "HANGUL SYLLABLE RWEONG");
+-   ("/xeb/xa4/x9a", "HANGUL SYLLABLE RWEOJ");
+-   ("/xeb/xa4/x9b", "HANGUL SYLLABLE RWEOC");
+-   ("/xeb/xa4/x9c", "HANGUL SYLLABLE RWEOK");
+-   ("/xeb/xa4/x9d", "HANGUL SYLLABLE RWEOT");
+-   ("/xeb/xa4/x9e", "HANGUL SYLLABLE RWEOP");
+-   ("/xeb/xa4/x9f", "HANGUL SYLLABLE RWEOH");
+-   ("/xeb/xa4/xa0", "HANGUL SYLLABLE RWE");
+-   ("/xeb/xa4/xa1", "HANGUL SYLLABLE RWEG");
+-   ("/xeb/xa4/xa2", "HANGUL SYLLABLE RWEGG");
+-   ("/xeb/xa4/xa3", "HANGUL SYLLABLE RWEGS");
+-   ("/xeb/xa4/xa4", "HANGUL SYLLABLE RWEN");
+-   ("/xeb/xa4/xa5", "HANGUL SYLLABLE RWENI");
+-   ("/xeb/xa4/xa6", "HANGUL SYLLABLE RWENH");
+-   ("/xeb/xa4/xa7", "HANGUL SYLLABLE RWED");
+-   ("/xeb/xa4/xa8", "HANGUL SYLLABLE RWEL");
+-   ("/xeb/xa4/xa9", "HANGUL SYLLABLE RWELG");
+-   ("/xeb/xa4/xaa", "HANGUL SYLLABLE RWELM");
+-   ("/xeb/xa4/xab", "HANGUL SYLLABLE RWELB");
+-   ("/xeb/xa4/xac", "HANGUL SYLLABLE RWELS");
+-   ("/xeb/xa4/xad", "HANGUL SYLLABLE RWELT");
+-   ("/xeb/xa4/xae", "HANGUL SYLLABLE RWELP");
+-   ("/xeb/xa4/xaf", "HANGUL SYLLABLE RWELH");
+-   ("/xeb/xa4/xb0", "HANGUL SYLLABLE RWEM");
+-   ("/xeb/xa4/xb1", "HANGUL SYLLABLE RWEB");
+-   ("/xeb/xa4/xb2", "HANGUL SYLLABLE RWEBS");
+-   ("/xeb/xa4/xb3", "HANGUL SYLLABLE RWES");
+-   ("/xeb/xa4/xb4", "HANGUL SYLLABLE RWESS");
+-   ("/xeb/xa4/xb5", "HANGUL SYLLABLE RWENG");
+-   ("/xeb/xa4/xb6", "HANGUL SYLLABLE RWEJ");
+-   ("/xeb/xa4/xb7", "HANGUL SYLLABLE RWEC");
+-   ("/xeb/xa4/xb8", "HANGUL SYLLABLE RWEK");
+-   ("/xeb/xa4/xb9", "HANGUL SYLLABLE RWET");
+-   ("/xeb/xa4/xba", "HANGUL SYLLABLE RWEP");
+-   ("/xeb/xa4/xbb", "HANGUL SYLLABLE RWEH");
+-   ("/xeb/xa4/xbc", "HANGUL SYLLABLE RWI");
+-   ("/xeb/xa4/xbd", "HANGUL SYLLABLE RWIG");
+-   ("/xeb/xa4/xbe", "HANGUL SYLLABLE RWIGG");
+-   ("/xeb/xa4/xbf", "HANGUL SYLLABLE RWIGS");
+-   ("/xeb/xa5/x80", "HANGUL SYLLABLE RWIN");
+-   ("/xeb/xa5/x81", "HANGUL SYLLABLE RWINI");
+-   ("/xeb/xa5/x82", "HANGUL SYLLABLE RWINH");
+-   ("/xeb/xa5/x83", "HANGUL SYLLABLE RWID");
+-   ("/xeb/xa5/x84", "HANGUL SYLLABLE RWIL");
+-   ("/xeb/xa5/x85", "HANGUL SYLLABLE RWILG");
+-   ("/xeb/xa5/x86", "HANGUL SYLLABLE RWILM");
+-   ("/xeb/xa5/x87", "HANGUL SYLLABLE RWILB");
+-   ("/xeb/xa5/x88", "HANGUL SYLLABLE RWILS");
+-   ("/xeb/xa5/x89", "HANGUL SYLLABLE RWILT");
+-   ("/xeb/xa5/x8a", "HANGUL SYLLABLE RWILP");
+-   ("/xeb/xa5/x8b", "HANGUL SYLLABLE RWILH");
+-   ("/xeb/xa5/x8c", "HANGUL SYLLABLE RWIM");
+-   ("/xeb/xa5/x8d", "HANGUL SYLLABLE RWIB");
+-   ("/xeb/xa5/x8e", "HANGUL SYLLABLE RWIBS");
+-   ("/xeb/xa5/x8f", "HANGUL SYLLABLE RWIS");
+-   ("/xeb/xa5/x90", "HANGUL SYLLABLE RWISS");
+-   ("/xeb/xa5/x91", "HANGUL SYLLABLE RWING");
+-   ("/xeb/xa5/x92", "HANGUL SYLLABLE RWIJ");
+-   ("/xeb/xa5/x93", "HANGUL SYLLABLE RWIC");
+-   ("/xeb/xa5/x94", "HANGUL SYLLABLE RWIK");
+-   ("/xeb/xa5/x95", "HANGUL SYLLABLE RWIT");
+-   ("/xeb/xa5/x96", "HANGUL SYLLABLE RWIP");
+-   ("/xeb/xa5/x97", "HANGUL SYLLABLE RWIH");
+-   ("/xeb/xa5/x98", "HANGUL SYLLABLE RYU");
+-   ("/xeb/xa5/x99", "HANGUL SYLLABLE RYUG");
+-   ("/xeb/xa5/x9a", "HANGUL SYLLABLE RYUGG");
+-   ("/xeb/xa5/x9b", "HANGUL SYLLABLE RYUGS");
+-   ("/xeb/xa5/x9c", "HANGUL SYLLABLE RYUN");
+-   ("/xeb/xa5/x9d", "HANGUL SYLLABLE RYUNI");
+-   ("/xeb/xa5/x9e", "HANGUL SYLLABLE RYUNH");
+-   ("/xeb/xa5/x9f", "HANGUL SYLLABLE RYUD");
+-   ("/xeb/xa5/xa0", "HANGUL SYLLABLE RYUL");
+-   ("/xeb/xa5/xa1", "HANGUL SYLLABLE RYULG");
+-   ("/xeb/xa5/xa2", "HANGUL SYLLABLE RYULM");
+-   ("/xeb/xa5/xa3", "HANGUL SYLLABLE RYULB");
+-   ("/xeb/xa5/xa4", "HANGUL SYLLABLE RYULS");
+-   ("/xeb/xa5/xa5", "HANGUL SYLLABLE RYULT");
+-   ("/xeb/xa5/xa6", "HANGUL SYLLABLE RYULP");
+-   ("/xeb/xa5/xa7", "HANGUL SYLLABLE RYULH");
+-   ("/xeb/xa5/xa8", "HANGUL SYLLABLE RYUM");
+-   ("/xeb/xa5/xa9", "HANGUL SYLLABLE RYUB");
+-   ("/xeb/xa5/xaa", "HANGUL SYLLABLE RYUBS");
+-   ("/xeb/xa5/xab", "HANGUL SYLLABLE RYUS");
+-   ("/xeb/xa5/xac", "HANGUL SYLLABLE RYUSS");
+-   ("/xeb/xa5/xad", "HANGUL SYLLABLE RYUNG");
+-   ("/xeb/xa5/xae", "HANGUL SYLLABLE RYUJ");
+-   ("/xeb/xa5/xaf", "HANGUL SYLLABLE RYUC");
+-   ("/xeb/xa5/xb0", "HANGUL SYLLABLE RYUK");
+-   ("/xeb/xa5/xb1", "HANGUL SYLLABLE RYUT");
+-   ("/xeb/xa5/xb2", "HANGUL SYLLABLE RYUP");
+-   ("/xeb/xa5/xb3", "HANGUL SYLLABLE RYUH");
+-   ("/xeb/xa5/xb4", "HANGUL SYLLABLE REU");
+-   ("/xeb/xa5/xb5", "HANGUL SYLLABLE REUG");
+-   ("/xeb/xa5/xb6", "HANGUL SYLLABLE REUGG");
+-   ("/xeb/xa5/xb7", "HANGUL SYLLABLE REUGS");
+-   ("/xeb/xa5/xb8", "HANGUL SYLLABLE REUN");
+-   ("/xeb/xa5/xb9", "HANGUL SYLLABLE REUNI");
+-   ("/xeb/xa5/xba", "HANGUL SYLLABLE REUNH");
+-   ("/xeb/xa5/xbb", "HANGUL SYLLABLE REUD");
+-   ("/xeb/xa5/xbc", "HANGUL SYLLABLE REUL");
+-   ("/xeb/xa5/xbd", "HANGUL SYLLABLE REULG");
+-   ("/xeb/xa5/xbe", "HANGUL SYLLABLE REULM");
+-   ("/xeb/xa5/xbf", "HANGUL SYLLABLE REULB");
+-   ("/xeb/xa6/x80", "HANGUL SYLLABLE REULS");
+-   ("/xeb/xa6/x81", "HANGUL SYLLABLE REULT");
+-   ("/xeb/xa6/x82", "HANGUL SYLLABLE REULP");
+-   ("/xeb/xa6/x83", "HANGUL SYLLABLE REULH");
+-   ("/xeb/xa6/x84", "HANGUL SYLLABLE REUM");
+-   ("/xeb/xa6/x85", "HANGUL SYLLABLE REUB");
+-   ("/xeb/xa6/x86", "HANGUL SYLLABLE REUBS");
+-   ("/xeb/xa6/x87", "HANGUL SYLLABLE REUS");
+-   ("/xeb/xa6/x88", "HANGUL SYLLABLE REUSS");
+-   ("/xeb/xa6/x89", "HANGUL SYLLABLE REUNG");
+-   ("/xeb/xa6/x8a", "HANGUL SYLLABLE REUJ");
+-   ("/xeb/xa6/x8b", "HANGUL SYLLABLE REUC");
+-   ("/xeb/xa6/x8c", "HANGUL SYLLABLE REUK");
+-   ("/xeb/xa6/x8d", "HANGUL SYLLABLE REUT");
+-   ("/xeb/xa6/x8e", "HANGUL SYLLABLE REUP");
+-   ("/xeb/xa6/x8f", "HANGUL SYLLABLE REUH");
+-   ("/xeb/xa6/x90", "HANGUL SYLLABLE RYI");
+-   ("/xeb/xa6/x91", "HANGUL SYLLABLE RYIG");
+-   ("/xeb/xa6/x92", "HANGUL SYLLABLE RYIGG");
+-   ("/xeb/xa6/x93", "HANGUL SYLLABLE RYIGS");
+-   ("/xeb/xa6/x94", "HANGUL SYLLABLE RYIN");
+-   ("/xeb/xa6/x95", "HANGUL SYLLABLE RYINI");
+-   ("/xeb/xa6/x96", "HANGUL SYLLABLE RYINH");
+-   ("/xeb/xa6/x97", "HANGUL SYLLABLE RYID");
+-   ("/xeb/xa6/x98", "HANGUL SYLLABLE RYIL");
+-   ("/xeb/xa6/x99", "HANGUL SYLLABLE RYILG");
+-   ("/xeb/xa6/x9a", "HANGUL SYLLABLE RYILM");
+-   ("/xeb/xa6/x9b", "HANGUL SYLLABLE RYILB");
+-   ("/xeb/xa6/x9c", "HANGUL SYLLABLE RYILS");
+-   ("/xeb/xa6/x9d", "HANGUL SYLLABLE RYILT");
+-   ("/xeb/xa6/x9e", "HANGUL SYLLABLE RYILP");
+-   ("/xeb/xa6/x9f", "HANGUL SYLLABLE RYILH");
+-   ("/xeb/xa6/xa0", "HANGUL SYLLABLE RYIM");
+-   ("/xeb/xa6/xa1", "HANGUL SYLLABLE RYIB");
+-   ("/xeb/xa6/xa2", "HANGUL SYLLABLE RYIBS");
+-   ("/xeb/xa6/xa3", "HANGUL SYLLABLE RYIS");
+-   ("/xeb/xa6/xa4", "HANGUL SYLLABLE RYISS");
+-   ("/xeb/xa6/xa5", "HANGUL SYLLABLE RYING");
+-   ("/xeb/xa6/xa6", "HANGUL SYLLABLE RYIJ");
+-   ("/xeb/xa6/xa7", "HANGUL SYLLABLE RYIC");
+-   ("/xeb/xa6/xa8", "HANGUL SYLLABLE RYIK");
+-   ("/xeb/xa6/xa9", "HANGUL SYLLABLE RYIT");
+-   ("/xeb/xa6/xaa", "HANGUL SYLLABLE RYIP");
+-   ("/xeb/xa6/xab", "HANGUL SYLLABLE RYIH");
+-   ("/xeb/xa6/xac", "HANGUL SYLLABLE RI");
+-   ("/xeb/xa6/xad", "HANGUL SYLLABLE RIG");
+-   ("/xeb/xa6/xae", "HANGUL SYLLABLE RIGG");
+-   ("/xeb/xa6/xaf", "HANGUL SYLLABLE RIGS");
+-   ("/xeb/xa6/xb0", "HANGUL SYLLABLE RIN");
+-   ("/xeb/xa6/xb1", "HANGUL SYLLABLE RINI");
+-   ("/xeb/xa6/xb2", "HANGUL SYLLABLE RINH");
+-   ("/xeb/xa6/xb3", "HANGUL SYLLABLE RID");
+-   ("/xeb/xa6/xb4", "HANGUL SYLLABLE RIL");
+-   ("/xeb/xa6/xb5", "HANGUL SYLLABLE RILG");
+-   ("/xeb/xa6/xb6", "HANGUL SYLLABLE RILM");
+-   ("/xeb/xa6/xb7", "HANGUL SYLLABLE RILB");
+-   ("/xeb/xa6/xb8", "HANGUL SYLLABLE RILS");
+-   ("/xeb/xa6/xb9", "HANGUL SYLLABLE RILT");
+-   ("/xeb/xa6/xba", "HANGUL SYLLABLE RILP");
+-   ("/xeb/xa6/xbb", "HANGUL SYLLABLE RILH");
+-   ("/xeb/xa6/xbc", "HANGUL SYLLABLE RIM");
+-   ("/xeb/xa6/xbd", "HANGUL SYLLABLE RIB");
+-   ("/xeb/xa6/xbe", "HANGUL SYLLABLE RIBS");
+-   ("/xeb/xa6/xbf", "HANGUL SYLLABLE RIS");
+-   ("/xeb/xa7/x80", "HANGUL SYLLABLE RISS");
+-   ("/xeb/xa7/x81", "HANGUL SYLLABLE RING");
+-   ("/xeb/xa7/x82", "HANGUL SYLLABLE RIJ");
+-   ("/xeb/xa7/x83", "HANGUL SYLLABLE RIC");
+-   ("/xeb/xa7/x84", "HANGUL SYLLABLE RIK");
+-   ("/xeb/xa7/x85", "HANGUL SYLLABLE RIT");
+-   ("/xeb/xa7/x86", "HANGUL SYLLABLE RIP");
+-   ("/xeb/xa7/x87", "HANGUL SYLLABLE RIH");
+-   ("/xeb/xa7/x88", "HANGUL SYLLABLE MA");
+-   ("/xeb/xa7/x89", "HANGUL SYLLABLE MAG");
+-   ("/xeb/xa7/x8a", "HANGUL SYLLABLE MAGG");
+-   ("/xeb/xa7/x8b", "HANGUL SYLLABLE MAGS");
+-   ("/xeb/xa7/x8c", "HANGUL SYLLABLE MAN");
+-   ("/xeb/xa7/x8d", "HANGUL SYLLABLE MANI");
+-   ("/xeb/xa7/x8e", "HANGUL SYLLABLE MANH");
+-   ("/xeb/xa7/x8f", "HANGUL SYLLABLE MAD");
+-   ("/xeb/xa7/x90", "HANGUL SYLLABLE MAL");
+-   ("/xeb/xa7/x91", "HANGUL SYLLABLE MALG");
+-   ("/xeb/xa7/x92", "HANGUL SYLLABLE MALM");
+-   ("/xeb/xa7/x93", "HANGUL SYLLABLE MALB");
+-   ("/xeb/xa7/x94", "HANGUL SYLLABLE MALS");
+-   ("/xeb/xa7/x95", "HANGUL SYLLABLE MALT");
+-   ("/xeb/xa7/x96", "HANGUL SYLLABLE MALP");
+-   ("/xeb/xa7/x97", "HANGUL SYLLABLE MALH");
+-   ("/xeb/xa7/x98", "HANGUL SYLLABLE MAM");
+-   ("/xeb/xa7/x99", "HANGUL SYLLABLE MAB");
+-   ("/xeb/xa7/x9a", "HANGUL SYLLABLE MABS");
+-   ("/xeb/xa7/x9b", "HANGUL SYLLABLE MAS");
+-   ("/xeb/xa7/x9c", "HANGUL SYLLABLE MASS");
+-   ("/xeb/xa7/x9d", "HANGUL SYLLABLE MANG");
+-   ("/xeb/xa7/x9e", "HANGUL SYLLABLE MAJ");
+-   ("/xeb/xa7/x9f", "HANGUL SYLLABLE MAC");
+-   ("/xeb/xa7/xa0", "HANGUL SYLLABLE MAK");
+-   ("/xeb/xa7/xa1", "HANGUL SYLLABLE MAT");
+-   ("/xeb/xa7/xa2", "HANGUL SYLLABLE MAP");
+-   ("/xeb/xa7/xa3", "HANGUL SYLLABLE MAH");
+-   ("/xeb/xa7/xa4", "HANGUL SYLLABLE MAE");
+-   ("/xeb/xa7/xa5", "HANGUL SYLLABLE MAEG");
+-   ("/xeb/xa7/xa6", "HANGUL SYLLABLE MAEGG");
+-   ("/xeb/xa7/xa7", "HANGUL SYLLABLE MAEGS");
+-   ("/xeb/xa7/xa8", "HANGUL SYLLABLE MAEN");
+-   ("/xeb/xa7/xa9", "HANGUL SYLLABLE MAENI");
+-   ("/xeb/xa7/xaa", "HANGUL SYLLABLE MAENH");
+-   ("/xeb/xa7/xab", "HANGUL SYLLABLE MAED");
+-   ("/xeb/xa7/xac", "HANGUL SYLLABLE MAEL");
+-   ("/xeb/xa7/xad", "HANGUL SYLLABLE MAELG");
+-   ("/xeb/xa7/xae", "HANGUL SYLLABLE MAELM");
+-   ("/xeb/xa7/xaf", "HANGUL SYLLABLE MAELB");
+-   ("/xeb/xa7/xb0", "HANGUL SYLLABLE MAELS");
+-   ("/xeb/xa7/xb1", "HANGUL SYLLABLE MAELT");
+-   ("/xeb/xa7/xb2", "HANGUL SYLLABLE MAELP");
+-   ("/xeb/xa7/xb3", "HANGUL SYLLABLE MAELH");
+-   ("/xeb/xa7/xb4", "HANGUL SYLLABLE MAEM");
+-   ("/xeb/xa7/xb5", "HANGUL SYLLABLE MAEB");
+-   ("/xeb/xa7/xb6", "HANGUL SYLLABLE MAEBS");
+-   ("/xeb/xa7/xb7", "HANGUL SYLLABLE MAES");
+-   ("/xeb/xa7/xb8", "HANGUL SYLLABLE MAESS");
+-   ("/xeb/xa7/xb9", "HANGUL SYLLABLE MAENG");
+-   ("/xeb/xa7/xba", "HANGUL SYLLABLE MAEJ");
+-   ("/xeb/xa7/xbb", "HANGUL SYLLABLE MAEC");
+-   ("/xeb/xa7/xbc", "HANGUL SYLLABLE MAEK");
+-   ("/xeb/xa7/xbd", "HANGUL SYLLABLE MAET");
+-   ("/xeb/xa7/xbe", "HANGUL SYLLABLE MAEP");
+-   ("/xeb/xa7/xbf", "HANGUL SYLLABLE MAEH");
+-   ("/xeb/xa8/x80", "HANGUL SYLLABLE MYA");
+-   ("/xeb/xa8/x81", "HANGUL SYLLABLE MYAG");
+-   ("/xeb/xa8/x82", "HANGUL SYLLABLE MYAGG");
+-   ("/xeb/xa8/x83", "HANGUL SYLLABLE MYAGS");
+-   ("/xeb/xa8/x84", "HANGUL SYLLABLE MYAN");
+-   ("/xeb/xa8/x85", "HANGUL SYLLABLE MYANI");
+-   ("/xeb/xa8/x86", "HANGUL SYLLABLE MYANH");
+-   ("/xeb/xa8/x87", "HANGUL SYLLABLE MYAD");
+-   ("/xeb/xa8/x88", "HANGUL SYLLABLE MYAL");
+-   ("/xeb/xa8/x89", "HANGUL SYLLABLE MYALG");
+-   ("/xeb/xa8/x8a", "HANGUL SYLLABLE MYALM");
+-   ("/xeb/xa8/x8b", "HANGUL SYLLABLE MYALB");
+-   ("/xeb/xa8/x8c", "HANGUL SYLLABLE MYALS");
+-   ("/xeb/xa8/x8d", "HANGUL SYLLABLE MYALT");
+-   ("/xeb/xa8/x8e", "HANGUL SYLLABLE MYALP");
+-   ("/xeb/xa8/x8f", "HANGUL SYLLABLE MYALH");
+-   ("/xeb/xa8/x90", "HANGUL SYLLABLE MYAM");
+-   ("/xeb/xa8/x91", "HANGUL SYLLABLE MYAB");
+-   ("/xeb/xa8/x92", "HANGUL SYLLABLE MYABS");
+-   ("/xeb/xa8/x93", "HANGUL SYLLABLE MYAS");
+-   ("/xeb/xa8/x94", "HANGUL SYLLABLE MYASS");
+-   ("/xeb/xa8/x95", "HANGUL SYLLABLE MYANG");
+-   ("/xeb/xa8/x96", "HANGUL SYLLABLE MYAJ");
+-   ("/xeb/xa8/x97", "HANGUL SYLLABLE MYAC");
+-   ("/xeb/xa8/x98", "HANGUL SYLLABLE MYAK");
+-   ("/xeb/xa8/x99", "HANGUL SYLLABLE MYAT");
+-   ("/xeb/xa8/x9a", "HANGUL SYLLABLE MYAP");
+-   ("/xeb/xa8/x9b", "HANGUL SYLLABLE MYAH");
+-   ("/xeb/xa8/x9c", "HANGUL SYLLABLE MYAE");
+-   ("/xeb/xa8/x9d", "HANGUL SYLLABLE MYAEG");
+-   ("/xeb/xa8/x9e", "HANGUL SYLLABLE MYAEGG");
+-   ("/xeb/xa8/x9f", "HANGUL SYLLABLE MYAEGS");
+-   ("/xeb/xa8/xa0", "HANGUL SYLLABLE MYAEN");
+-   ("/xeb/xa8/xa1", "HANGUL SYLLABLE MYAENI");
+-   ("/xeb/xa8/xa2", "HANGUL SYLLABLE MYAENH");
+-   ("/xeb/xa8/xa3", "HANGUL SYLLABLE MYAED");
+-   ("/xeb/xa8/xa4", "HANGUL SYLLABLE MYAEL");
+-   ("/xeb/xa8/xa5", "HANGUL SYLLABLE MYAELG");
+-   ("/xeb/xa8/xa6", "HANGUL SYLLABLE MYAELM");
+-   ("/xeb/xa8/xa7", "HANGUL SYLLABLE MYAELB");
+-   ("/xeb/xa8/xa8", "HANGUL SYLLABLE MYAELS");
+-   ("/xeb/xa8/xa9", "HANGUL SYLLABLE MYAELT");
+-   ("/xeb/xa8/xaa", "HANGUL SYLLABLE MYAELP");
+-   ("/xeb/xa8/xab", "HANGUL SYLLABLE MYAELH");
+-   ("/xeb/xa8/xac", "HANGUL SYLLABLE MYAEM");
+-   ("/xeb/xa8/xad", "HANGUL SYLLABLE MYAEB");
+-   ("/xeb/xa8/xae", "HANGUL SYLLABLE MYAEBS");
+-   ("/xeb/xa8/xaf", "HANGUL SYLLABLE MYAES");
+-   ("/xeb/xa8/xb0", "HANGUL SYLLABLE MYAESS");
+-   ("/xeb/xa8/xb1", "HANGUL SYLLABLE MYAENG");
+-   ("/xeb/xa8/xb2", "HANGUL SYLLABLE MYAEJ");
+-   ("/xeb/xa8/xb3", "HANGUL SYLLABLE MYAEC");
+-   ("/xeb/xa8/xb4", "HANGUL SYLLABLE MYAEK");
+-   ("/xeb/xa8/xb5", "HANGUL SYLLABLE MYAET");
+-   ("/xeb/xa8/xb6", "HANGUL SYLLABLE MYAEP");
+-   ("/xeb/xa8/xb7", "HANGUL SYLLABLE MYAEH");
+-   ("/xeb/xa8/xb8", "HANGUL SYLLABLE MEO");
+-   ("/xeb/xa8/xb9", "HANGUL SYLLABLE MEOG");
+-   ("/xeb/xa8/xba", "HANGUL SYLLABLE MEOGG");
+-   ("/xeb/xa8/xbb", "HANGUL SYLLABLE MEOGS");
+-   ("/xeb/xa8/xbc", "HANGUL SYLLABLE MEON");
+-   ("/xeb/xa8/xbd", "HANGUL SYLLABLE MEONI");
+-   ("/xeb/xa8/xbe", "HANGUL SYLLABLE MEONH");
+-   ("/xeb/xa8/xbf", "HANGUL SYLLABLE MEOD");
+-   ("/xeb/xa9/x80", "HANGUL SYLLABLE MEOL");
+-   ("/xeb/xa9/x81", "HANGUL SYLLABLE MEOLG");
+-   ("/xeb/xa9/x82", "HANGUL SYLLABLE MEOLM");
+-   ("/xeb/xa9/x83", "HANGUL SYLLABLE MEOLB");
+-   ("/xeb/xa9/x84", "HANGUL SYLLABLE MEOLS");
+-   ("/xeb/xa9/x85", "HANGUL SYLLABLE MEOLT");
+-   ("/xeb/xa9/x86", "HANGUL SYLLABLE MEOLP");
+-   ("/xeb/xa9/x87", "HANGUL SYLLABLE MEOLH");
+-   ("/xeb/xa9/x88", "HANGUL SYLLABLE MEOM");
+-   ("/xeb/xa9/x89", "HANGUL SYLLABLE MEOB");
+-   ("/xeb/xa9/x8a", "HANGUL SYLLABLE MEOBS");
+-   ("/xeb/xa9/x8b", "HANGUL SYLLABLE MEOS");
+-   ("/xeb/xa9/x8c", "HANGUL SYLLABLE MEOSS");
+-   ("/xeb/xa9/x8d", "HANGUL SYLLABLE MEONG");
+-   ("/xeb/xa9/x8e", "HANGUL SYLLABLE MEOJ");
+-   ("/xeb/xa9/x8f", "HANGUL SYLLABLE MEOC");
+-   ("/xeb/xa9/x90", "HANGUL SYLLABLE MEOK");
+-   ("/xeb/xa9/x91", "HANGUL SYLLABLE MEOT");
+-   ("/xeb/xa9/x92", "HANGUL SYLLABLE MEOP");
+-   ("/xeb/xa9/x93", "HANGUL SYLLABLE MEOH");
+-   ("/xeb/xa9/x94", "HANGUL SYLLABLE ME");
+-   ("/xeb/xa9/x95", "HANGUL SYLLABLE MEG");
+-   ("/xeb/xa9/x96", "HANGUL SYLLABLE MEGG");
+-   ("/xeb/xa9/x97", "HANGUL SYLLABLE MEGS");
+-   ("/xeb/xa9/x98", "HANGUL SYLLABLE MEN");
+-   ("/xeb/xa9/x99", "HANGUL SYLLABLE MENI");
+-   ("/xeb/xa9/x9a", "HANGUL SYLLABLE MENH");
+-   ("/xeb/xa9/x9b", "HANGUL SYLLABLE MED");
+-   ("/xeb/xa9/x9c", "HANGUL SYLLABLE MEL");
+-   ("/xeb/xa9/x9d", "HANGUL SYLLABLE MELG");
+-   ("/xeb/xa9/x9e", "HANGUL SYLLABLE MELM");
+-   ("/xeb/xa9/x9f", "HANGUL SYLLABLE MELB");
+-   ("/xeb/xa9/xa0", "HANGUL SYLLABLE MELS");
+-   ("/xeb/xa9/xa1", "HANGUL SYLLABLE MELT");
+-   ("/xeb/xa9/xa2", "HANGUL SYLLABLE MELP");
+-   ("/xeb/xa9/xa3", "HANGUL SYLLABLE MELH");
+-   ("/xeb/xa9/xa4", "HANGUL SYLLABLE MEM");
+-   ("/xeb/xa9/xa5", "HANGUL SYLLABLE MEB");
+-   ("/xeb/xa9/xa6", "HANGUL SYLLABLE MEBS");
+-   ("/xeb/xa9/xa7", "HANGUL SYLLABLE MES");
+-   ("/xeb/xa9/xa8", "HANGUL SYLLABLE MESS");
+-   ("/xeb/xa9/xa9", "HANGUL SYLLABLE MENG");
+-   ("/xeb/xa9/xaa", "HANGUL SYLLABLE MEJ");
+-   ("/xeb/xa9/xab", "HANGUL SYLLABLE MEC");
+-   ("/xeb/xa9/xac", "HANGUL SYLLABLE MEK");
+-   ("/xeb/xa9/xad", "HANGUL SYLLABLE MET");
+-   ("/xeb/xa9/xae", "HANGUL SYLLABLE MEP");
+-   ("/xeb/xa9/xaf", "HANGUL SYLLABLE MEH");
+-   ("/xeb/xa9/xb0", "HANGUL SYLLABLE MYEO");
+-   ("/xeb/xa9/xb1", "HANGUL SYLLABLE MYEOG");
+-   ("/xeb/xa9/xb2", "HANGUL SYLLABLE MYEOGG");
+-   ("/xeb/xa9/xb3", "HANGUL SYLLABLE MYEOGS");
+-   ("/xeb/xa9/xb4", "HANGUL SYLLABLE MYEON");
+-   ("/xeb/xa9/xb5", "HANGUL SYLLABLE MYEONI");
+-   ("/xeb/xa9/xb6", "HANGUL SYLLABLE MYEONH");
+-   ("/xeb/xa9/xb7", "HANGUL SYLLABLE MYEOD");
+-   ("/xeb/xa9/xb8", "HANGUL SYLLABLE MYEOL");
+-   ("/xeb/xa9/xb9", "HANGUL SYLLABLE MYEOLG");
+-   ("/xeb/xa9/xba", "HANGUL SYLLABLE MYEOLM");
+-   ("/xeb/xa9/xbb", "HANGUL SYLLABLE MYEOLB");
+-   ("/xeb/xa9/xbc", "HANGUL SYLLABLE MYEOLS");
+-   ("/xeb/xa9/xbd", "HANGUL SYLLABLE MYEOLT");
+-   ("/xeb/xa9/xbe", "HANGUL SYLLABLE MYEOLP");
+-   ("/xeb/xa9/xbf", "HANGUL SYLLABLE MYEOLH");
+-   ("/xeb/xaa/x80", "HANGUL SYLLABLE MYEOM");
+-   ("/xeb/xaa/x81", "HANGUL SYLLABLE MYEOB");
+-   ("/xeb/xaa/x82", "HANGUL SYLLABLE MYEOBS");
+-   ("/xeb/xaa/x83", "HANGUL SYLLABLE MYEOS");
+-   ("/xeb/xaa/x84", "HANGUL SYLLABLE MYEOSS");
+-   ("/xeb/xaa/x85", "HANGUL SYLLABLE MYEONG");
+-   ("/xeb/xaa/x86", "HANGUL SYLLABLE MYEOJ");
+-   ("/xeb/xaa/x87", "HANGUL SYLLABLE MYEOC");
+-   ("/xeb/xaa/x88", "HANGUL SYLLABLE MYEOK");
+-   ("/xeb/xaa/x89", "HANGUL SYLLABLE MYEOT");
+-   ("/xeb/xaa/x8a", "HANGUL SYLLABLE MYEOP");
+-   ("/xeb/xaa/x8b", "HANGUL SYLLABLE MYEOH");
+-   ("/xeb/xaa/x8c", "HANGUL SYLLABLE MYE");
+-   ("/xeb/xaa/x8d", "HANGUL SYLLABLE MYEG");
+-   ("/xeb/xaa/x8e", "HANGUL SYLLABLE MYEGG");
+-   ("/xeb/xaa/x8f", "HANGUL SYLLABLE MYEGS");
+-   ("/xeb/xaa/x90", "HANGUL SYLLABLE MYEN");
+-   ("/xeb/xaa/x91", "HANGUL SYLLABLE MYENI");
+-   ("/xeb/xaa/x92", "HANGUL SYLLABLE MYENH");
+-   ("/xeb/xaa/x93", "HANGUL SYLLABLE MYED");
+-   ("/xeb/xaa/x94", "HANGUL SYLLABLE MYEL");
+-   ("/xeb/xaa/x95", "HANGUL SYLLABLE MYELG");
+-   ("/xeb/xaa/x96", "HANGUL SYLLABLE MYELM");
+-   ("/xeb/xaa/x97", "HANGUL SYLLABLE MYELB");
+-   ("/xeb/xaa/x98", "HANGUL SYLLABLE MYELS");
+-   ("/xeb/xaa/x99", "HANGUL SYLLABLE MYELT");
+-   ("/xeb/xaa/x9a", "HANGUL SYLLABLE MYELP");
+-   ("/xeb/xaa/x9b", "HANGUL SYLLABLE MYELH");
+-   ("/xeb/xaa/x9c", "HANGUL SYLLABLE MYEM");
+-   ("/xeb/xaa/x9d", "HANGUL SYLLABLE MYEB");
+-   ("/xeb/xaa/x9e", "HANGUL SYLLABLE MYEBS");
+-   ("/xeb/xaa/x9f", "HANGUL SYLLABLE MYES");
+-   ("/xeb/xaa/xa0", "HANGUL SYLLABLE MYESS");
+-   ("/xeb/xaa/xa1", "HANGUL SYLLABLE MYENG");
+-   ("/xeb/xaa/xa2", "HANGUL SYLLABLE MYEJ");
+-   ("/xeb/xaa/xa3", "HANGUL SYLLABLE MYEC");
+-   ("/xeb/xaa/xa4", "HANGUL SYLLABLE MYEK");
+-   ("/xeb/xaa/xa5", "HANGUL SYLLABLE MYET");
+-   ("/xeb/xaa/xa6", "HANGUL SYLLABLE MYEP");
+-   ("/xeb/xaa/xa7", "HANGUL SYLLABLE MYEH");
+-   ("/xeb/xaa/xa8", "HANGUL SYLLABLE MO");
+-   ("/xeb/xaa/xa9", "HANGUL SYLLABLE MOG");
+-   ("/xeb/xaa/xaa", "HANGUL SYLLABLE MOGG");
+-   ("/xeb/xaa/xab", "HANGUL SYLLABLE MOGS");
+-   ("/xeb/xaa/xac", "HANGUL SYLLABLE MON");
+-   ("/xeb/xaa/xad", "HANGUL SYLLABLE MONI");
+-   ("/xeb/xaa/xae", "HANGUL SYLLABLE MONH");
+-   ("/xeb/xaa/xaf", "HANGUL SYLLABLE MOD");
+-   ("/xeb/xaa/xb0", "HANGUL SYLLABLE MOL");
+-   ("/xeb/xaa/xb1", "HANGUL SYLLABLE MOLG");
+-   ("/xeb/xaa/xb2", "HANGUL SYLLABLE MOLM");
+-   ("/xeb/xaa/xb3", "HANGUL SYLLABLE MOLB");
+-   ("/xeb/xaa/xb4", "HANGUL SYLLABLE MOLS");
+-   ("/xeb/xaa/xb5", "HANGUL SYLLABLE MOLT");
+-   ("/xeb/xaa/xb6", "HANGUL SYLLABLE MOLP");
+-   ("/xeb/xaa/xb7", "HANGUL SYLLABLE MOLH");
+-   ("/xeb/xaa/xb8", "HANGUL SYLLABLE MOM");
+-   ("/xeb/xaa/xb9", "HANGUL SYLLABLE MOB");
+-   ("/xeb/xaa/xba", "HANGUL SYLLABLE MOBS");
+-   ("/xeb/xaa/xbb", "HANGUL SYLLABLE MOS");
+-   ("/xeb/xaa/xbc", "HANGUL SYLLABLE MOSS");
+-   ("/xeb/xaa/xbd", "HANGUL SYLLABLE MONG");
+-   ("/xeb/xaa/xbe", "HANGUL SYLLABLE MOJ");
+-   ("/xeb/xaa/xbf", "HANGUL SYLLABLE MOC");
+-   ("/xeb/xab/x80", "HANGUL SYLLABLE MOK");
+-   ("/xeb/xab/x81", "HANGUL SYLLABLE MOT");
+-   ("/xeb/xab/x82", "HANGUL SYLLABLE MOP");
+-   ("/xeb/xab/x83", "HANGUL SYLLABLE MOH");
+-   ("/xeb/xab/x84", "HANGUL SYLLABLE MWA");
+-   ("/xeb/xab/x85", "HANGUL SYLLABLE MWAG");
+-   ("/xeb/xab/x86", "HANGUL SYLLABLE MWAGG");
+-   ("/xeb/xab/x87", "HANGUL SYLLABLE MWAGS");
+-   ("/xeb/xab/x88", "HANGUL SYLLABLE MWAN");
+-   ("/xeb/xab/x89", "HANGUL SYLLABLE MWANI");
+-   ("/xeb/xab/x8a", "HANGUL SYLLABLE MWANH");
+-   ("/xeb/xab/x8b", "HANGUL SYLLABLE MWAD");
+-   ("/xeb/xab/x8c", "HANGUL SYLLABLE MWAL");
+-   ("/xeb/xab/x8d", "HANGUL SYLLABLE MWALG");
+-   ("/xeb/xab/x8e", "HANGUL SYLLABLE MWALM");
+-   ("/xeb/xab/x8f", "HANGUL SYLLABLE MWALB");
+-   ("/xeb/xab/x90", "HANGUL SYLLABLE MWALS");
+-   ("/xeb/xab/x91", "HANGUL SYLLABLE MWALT");
+-   ("/xeb/xab/x92", "HANGUL SYLLABLE MWALP");
+-   ("/xeb/xab/x93", "HANGUL SYLLABLE MWALH");
+-   ("/xeb/xab/x94", "HANGUL SYLLABLE MWAM");
+-   ("/xeb/xab/x95", "HANGUL SYLLABLE MWAB");
+-   ("/xeb/xab/x96", "HANGUL SYLLABLE MWABS");
+-   ("/xeb/xab/x97", "HANGUL SYLLABLE MWAS");
+-   ("/xeb/xab/x98", "HANGUL SYLLABLE MWASS");
+-   ("/xeb/xab/x99", "HANGUL SYLLABLE MWANG");
+-   ("/xeb/xab/x9a", "HANGUL SYLLABLE MWAJ");
+-   ("/xeb/xab/x9b", "HANGUL SYLLABLE MWAC");
+-   ("/xeb/xab/x9c", "HANGUL SYLLABLE MWAK");
+-   ("/xeb/xab/x9d", "HANGUL SYLLABLE MWAT");
+-   ("/xeb/xab/x9e", "HANGUL SYLLABLE MWAP");
+-   ("/xeb/xab/x9f", "HANGUL SYLLABLE MWAH");
+-   ("/xeb/xab/xa0", "HANGUL SYLLABLE MWAE");
+-   ("/xeb/xab/xa1", "HANGUL SYLLABLE MWAEG");
+-   ("/xeb/xab/xa2", "HANGUL SYLLABLE MWAEGG");
+-   ("/xeb/xab/xa3", "HANGUL SYLLABLE MWAEGS");
+-   ("/xeb/xab/xa4", "HANGUL SYLLABLE MWAEN");
+-   ("/xeb/xab/xa5", "HANGUL SYLLABLE MWAENI");
+-   ("/xeb/xab/xa6", "HANGUL SYLLABLE MWAENH");
+-   ("/xeb/xab/xa7", "HANGUL SYLLABLE MWAED");
+-   ("/xeb/xab/xa8", "HANGUL SYLLABLE MWAEL");
+-   ("/xeb/xab/xa9", "HANGUL SYLLABLE MWAELG");
+-   ("/xeb/xab/xaa", "HANGUL SYLLABLE MWAELM");
+-   ("/xeb/xab/xab", "HANGUL SYLLABLE MWAELB");
+-   ("/xeb/xab/xac", "HANGUL SYLLABLE MWAELS");
+-   ("/xeb/xab/xad", "HANGUL SYLLABLE MWAELT");
+-   ("/xeb/xab/xae", "HANGUL SYLLABLE MWAELP");
+-   ("/xeb/xab/xaf", "HANGUL SYLLABLE MWAELH");
+-   ("/xeb/xab/xb0", "HANGUL SYLLABLE MWAEM");
+-   ("/xeb/xab/xb1", "HANGUL SYLLABLE MWAEB");
+-   ("/xeb/xab/xb2", "HANGUL SYLLABLE MWAEBS");
+-   ("/xeb/xab/xb3", "HANGUL SYLLABLE MWAES");
+-   ("/xeb/xab/xb4", "HANGUL SYLLABLE MWAESS");
+-   ("/xeb/xab/xb5", "HANGUL SYLLABLE MWAENG");
+-   ("/xeb/xab/xb6", "HANGUL SYLLABLE MWAEJ");
+-   ("/xeb/xab/xb7", "HANGUL SYLLABLE MWAEC");
+-   ("/xeb/xab/xb8", "HANGUL SYLLABLE MWAEK");
+-   ("/xeb/xab/xb9", "HANGUL SYLLABLE MWAET");
+-   ("/xeb/xab/xba", "HANGUL SYLLABLE MWAEP");
+-   ("/xeb/xab/xbb", "HANGUL SYLLABLE MWAEH");
+-   ("/xeb/xab/xbc", "HANGUL SYLLABLE MOE");
+-   ("/xeb/xab/xbd", "HANGUL SYLLABLE MOEG");
+-   ("/xeb/xab/xbe", "HANGUL SYLLABLE MOEGG");
+-   ("/xeb/xab/xbf", "HANGUL SYLLABLE MOEGS");
+-   ("/xeb/xac/x80", "HANGUL SYLLABLE MOEN");
+-   ("/xeb/xac/x81", "HANGUL SYLLABLE MOENI");
+-   ("/xeb/xac/x82", "HANGUL SYLLABLE MOENH");
+-   ("/xeb/xac/x83", "HANGUL SYLLABLE MOED");
+-   ("/xeb/xac/x84", "HANGUL SYLLABLE MOEL");
+-   ("/xeb/xac/x85", "HANGUL SYLLABLE MOELG");
+-   ("/xeb/xac/x86", "HANGUL SYLLABLE MOELM");
+-   ("/xeb/xac/x87", "HANGUL SYLLABLE MOELB");
+-   ("/xeb/xac/x88", "HANGUL SYLLABLE MOELS");
+-   ("/xeb/xac/x89", "HANGUL SYLLABLE MOELT");
+-   ("/xeb/xac/x8a", "HANGUL SYLLABLE MOELP");
+-   ("/xeb/xac/x8b", "HANGUL SYLLABLE MOELH");
+-   ("/xeb/xac/x8c", "HANGUL SYLLABLE MOEM");
+-   ("/xeb/xac/x8d", "HANGUL SYLLABLE MOEB");
+-   ("/xeb/xac/x8e", "HANGUL SYLLABLE MOEBS");
+-   ("/xeb/xac/x8f", "HANGUL SYLLABLE MOES");
+-   ("/xeb/xac/x90", "HANGUL SYLLABLE MOESS");
+-   ("/xeb/xac/x91", "HANGUL SYLLABLE MOENG");
+-   ("/xeb/xac/x92", "HANGUL SYLLABLE MOEJ");
+-   ("/xeb/xac/x93", "HANGUL SYLLABLE MOEC");
+-   ("/xeb/xac/x94", "HANGUL SYLLABLE MOEK");
+-   ("/xeb/xac/x95", "HANGUL SYLLABLE MOET");
+-   ("/xeb/xac/x96", "HANGUL SYLLABLE MOEP");
+-   ("/xeb/xac/x97", "HANGUL SYLLABLE MOEH");
+-   ("/xeb/xac/x98", "HANGUL SYLLABLE MYO");
+-   ("/xeb/xac/x99", "HANGUL SYLLABLE MYOG");
+-   ("/xeb/xac/x9a", "HANGUL SYLLABLE MYOGG");
+-   ("/xeb/xac/x9b", "HANGUL SYLLABLE MYOGS");
+-   ("/xeb/xac/x9c", "HANGUL SYLLABLE MYON");
+-   ("/xeb/xac/x9d", "HANGUL SYLLABLE MYONI");
+-   ("/xeb/xac/x9e", "HANGUL SYLLABLE MYONH");
+-   ("/xeb/xac/x9f", "HANGUL SYLLABLE MYOD");
+-   ("/xeb/xac/xa0", "HANGUL SYLLABLE MYOL");
+-   ("/xeb/xac/xa1", "HANGUL SYLLABLE MYOLG");
+-   ("/xeb/xac/xa2", "HANGUL SYLLABLE MYOLM");
+-   ("/xeb/xac/xa3", "HANGUL SYLLABLE MYOLB");
+-   ("/xeb/xac/xa4", "HANGUL SYLLABLE MYOLS");
+-   ("/xeb/xac/xa5", "HANGUL SYLLABLE MYOLT");
+-   ("/xeb/xac/xa6", "HANGUL SYLLABLE MYOLP");
+-   ("/xeb/xac/xa7", "HANGUL SYLLABLE MYOLH");
+-   ("/xeb/xac/xa8", "HANGUL SYLLABLE MYOM");
+-   ("/xeb/xac/xa9", "HANGUL SYLLABLE MYOB");
+-   ("/xeb/xac/xaa", "HANGUL SYLLABLE MYOBS");
+-   ("/xeb/xac/xab", "HANGUL SYLLABLE MYOS");
+-   ("/xeb/xac/xac", "HANGUL SYLLABLE MYOSS");
+-   ("/xeb/xac/xad", "HANGUL SYLLABLE MYONG");
+-   ("/xeb/xac/xae", "HANGUL SYLLABLE MYOJ");
+-   ("/xeb/xac/xaf", "HANGUL SYLLABLE MYOC");
+-   ("/xeb/xac/xb0", "HANGUL SYLLABLE MYOK");
+-   ("/xeb/xac/xb1", "HANGUL SYLLABLE MYOT");
+-   ("/xeb/xac/xb2", "HANGUL SYLLABLE MYOP");
+-   ("/xeb/xac/xb3", "HANGUL SYLLABLE MYOH");
+-   ("/xeb/xac/xb4", "HANGUL SYLLABLE MU");
+-   ("/xeb/xac/xb5", "HANGUL SYLLABLE MUG");
+-   ("/xeb/xac/xb6", "HANGUL SYLLABLE MUGG");
+-   ("/xeb/xac/xb7", "HANGUL SYLLABLE MUGS");
+-   ("/xeb/xac/xb8", "HANGUL SYLLABLE MUN");
+-   ("/xeb/xac/xb9", "HANGUL SYLLABLE MUNI");
+-   ("/xeb/xac/xba", "HANGUL SYLLABLE MUNH");
+-   ("/xeb/xac/xbb", "HANGUL SYLLABLE MUD");
+-   ("/xeb/xac/xbc", "HANGUL SYLLABLE MUL");
+-   ("/xeb/xac/xbd", "HANGUL SYLLABLE MULG");
+-   ("/xeb/xac/xbe", "HANGUL SYLLABLE MULM");
+-   ("/xeb/xac/xbf", "HANGUL SYLLABLE MULB");
+-   ("/xeb/xad/x80", "HANGUL SYLLABLE MULS");
+-   ("/xeb/xad/x81", "HANGUL SYLLABLE MULT");
+-   ("/xeb/xad/x82", "HANGUL SYLLABLE MULP");
+-   ("/xeb/xad/x83", "HANGUL SYLLABLE MULH");
+-   ("/xeb/xad/x84", "HANGUL SYLLABLE MUM");
+-   ("/xeb/xad/x85", "HANGUL SYLLABLE MUB");
+-   ("/xeb/xad/x86", "HANGUL SYLLABLE MUBS");
+-   ("/xeb/xad/x87", "HANGUL SYLLABLE MUS");
+-   ("/xeb/xad/x88", "HANGUL SYLLABLE MUSS");
+-   ("/xeb/xad/x89", "HANGUL SYLLABLE MUNG");
+-   ("/xeb/xad/x8a", "HANGUL SYLLABLE MUJ");
+-   ("/xeb/xad/x8b", "HANGUL SYLLABLE MUC");
+-   ("/xeb/xad/x8c", "HANGUL SYLLABLE MUK");
+-   ("/xeb/xad/x8d", "HANGUL SYLLABLE MUT");
+-   ("/xeb/xad/x8e", "HANGUL SYLLABLE MUP");
+-   ("/xeb/xad/x8f", "HANGUL SYLLABLE MUH");
+-   ("/xeb/xad/x90", "HANGUL SYLLABLE MWEO");
+-   ("/xeb/xad/x91", "HANGUL SYLLABLE MWEOG");
+-   ("/xeb/xad/x92", "HANGUL SYLLABLE MWEOGG");
+-   ("/xeb/xad/x93", "HANGUL SYLLABLE MWEOGS");
+-   ("/xeb/xad/x94", "HANGUL SYLLABLE MWEON");
+-   ("/xeb/xad/x95", "HANGUL SYLLABLE MWEONI");
+-   ("/xeb/xad/x96", "HANGUL SYLLABLE MWEONH");
+-   ("/xeb/xad/x97", "HANGUL SYLLABLE MWEOD");
+-   ("/xeb/xad/x98", "HANGUL SYLLABLE MWEOL");
+-   ("/xeb/xad/x99", "HANGUL SYLLABLE MWEOLG");
+-   ("/xeb/xad/x9a", "HANGUL SYLLABLE MWEOLM");
+-   ("/xeb/xad/x9b", "HANGUL SYLLABLE MWEOLB");
+-   ("/xeb/xad/x9c", "HANGUL SYLLABLE MWEOLS");
+-   ("/xeb/xad/x9d", "HANGUL SYLLABLE MWEOLT");
+-   ("/xeb/xad/x9e", "HANGUL SYLLABLE MWEOLP");
+-   ("/xeb/xad/x9f", "HANGUL SYLLABLE MWEOLH");
+-   ("/xeb/xad/xa0", "HANGUL SYLLABLE MWEOM");
+-   ("/xeb/xad/xa1", "HANGUL SYLLABLE MWEOB");
+-   ("/xeb/xad/xa2", "HANGUL SYLLABLE MWEOBS");
+-   ("/xeb/xad/xa3", "HANGUL SYLLABLE MWEOS");
+-   ("/xeb/xad/xa4", "HANGUL SYLLABLE MWEOSS");
+-   ("/xeb/xad/xa5", "HANGUL SYLLABLE MWEONG");
+-   ("/xeb/xad/xa6", "HANGUL SYLLABLE MWEOJ");
+-   ("/xeb/xad/xa7", "HANGUL SYLLABLE MWEOC");
+-   ("/xeb/xad/xa8", "HANGUL SYLLABLE MWEOK");
+-   ("/xeb/xad/xa9", "HANGUL SYLLABLE MWEOT");
+-   ("/xeb/xad/xaa", "HANGUL SYLLABLE MWEOP");
+-   ("/xeb/xad/xab", "HANGUL SYLLABLE MWEOH");
+-   ("/xeb/xad/xac", "HANGUL SYLLABLE MWE");
+-   ("/xeb/xad/xad", "HANGUL SYLLABLE MWEG");
+-   ("/xeb/xad/xae", "HANGUL SYLLABLE MWEGG");
+-   ("/xeb/xad/xaf", "HANGUL SYLLABLE MWEGS");
+-   ("/xeb/xad/xb0", "HANGUL SYLLABLE MWEN");
+-   ("/xeb/xad/xb1", "HANGUL SYLLABLE MWENI");
+-   ("/xeb/xad/xb2", "HANGUL SYLLABLE MWENH");
+-   ("/xeb/xad/xb3", "HANGUL SYLLABLE MWED");
+-   ("/xeb/xad/xb4", "HANGUL SYLLABLE MWEL");
+-   ("/xeb/xad/xb5", "HANGUL SYLLABLE MWELG");
+-   ("/xeb/xad/xb6", "HANGUL SYLLABLE MWELM");
+-   ("/xeb/xad/xb7", "HANGUL SYLLABLE MWELB");
+-   ("/xeb/xad/xb8", "HANGUL SYLLABLE MWELS");
+-   ("/xeb/xad/xb9", "HANGUL SYLLABLE MWELT");
+-   ("/xeb/xad/xba", "HANGUL SYLLABLE MWELP");
+-   ("/xeb/xad/xbb", "HANGUL SYLLABLE MWELH");
+-   ("/xeb/xad/xbc", "HANGUL SYLLABLE MWEM");
+-   ("/xeb/xad/xbd", "HANGUL SYLLABLE MWEB");
+-   ("/xeb/xad/xbe", "HANGUL SYLLABLE MWEBS");
+-   ("/xeb/xad/xbf", "HANGUL SYLLABLE MWES");
+-   ("/xeb/xae/x80", "HANGUL SYLLABLE MWESS");
+-   ("/xeb/xae/x81", "HANGUL SYLLABLE MWENG");
+-   ("/xeb/xae/x82", "HANGUL SYLLABLE MWEJ");
+-   ("/xeb/xae/x83", "HANGUL SYLLABLE MWEC");
+-   ("/xeb/xae/x84", "HANGUL SYLLABLE MWEK");
+-   ("/xeb/xae/x85", "HANGUL SYLLABLE MWET");
+-   ("/xeb/xae/x86", "HANGUL SYLLABLE MWEP");
+-   ("/xeb/xae/x87", "HANGUL SYLLABLE MWEH");
+-   ("/xeb/xae/x88", "HANGUL SYLLABLE MWI");
+-   ("/xeb/xae/x89", "HANGUL SYLLABLE MWIG");
+-   ("/xeb/xae/x8a", "HANGUL SYLLABLE MWIGG");
+-   ("/xeb/xae/x8b", "HANGUL SYLLABLE MWIGS");
+-   ("/xeb/xae/x8c", "HANGUL SYLLABLE MWIN");
+-   ("/xeb/xae/x8d", "HANGUL SYLLABLE MWINI");
+-   ("/xeb/xae/x8e", "HANGUL SYLLABLE MWINH");
+-   ("/xeb/xae/x8f", "HANGUL SYLLABLE MWID");
+-   ("/xeb/xae/x90", "HANGUL SYLLABLE MWIL");
+-   ("/xeb/xae/x91", "HANGUL SYLLABLE MWILG");
+-   ("/xeb/xae/x92", "HANGUL SYLLABLE MWILM");
+-   ("/xeb/xae/x93", "HANGUL SYLLABLE MWILB");
+-   ("/xeb/xae/x94", "HANGUL SYLLABLE MWILS");
+-   ("/xeb/xae/x95", "HANGUL SYLLABLE MWILT");
+-   ("/xeb/xae/x96", "HANGUL SYLLABLE MWILP");
+-   ("/xeb/xae/x97", "HANGUL SYLLABLE MWILH");
+-   ("/xeb/xae/x98", "HANGUL SYLLABLE MWIM");
+-   ("/xeb/xae/x99", "HANGUL SYLLABLE MWIB");
+-   ("/xeb/xae/x9a", "HANGUL SYLLABLE MWIBS");
+-   ("/xeb/xae/x9b", "HANGUL SYLLABLE MWIS");
+-   ("/xeb/xae/x9c", "HANGUL SYLLABLE MWISS");
+-   ("/xeb/xae/x9d", "HANGUL SYLLABLE MWING");
+-   ("/xeb/xae/x9e", "HANGUL SYLLABLE MWIJ");
+-   ("/xeb/xae/x9f", "HANGUL SYLLABLE MWIC");
+-   ("/xeb/xae/xa0", "HANGUL SYLLABLE MWIK");
+-   ("/xeb/xae/xa1", "HANGUL SYLLABLE MWIT");
+-   ("/xeb/xae/xa2", "HANGUL SYLLABLE MWIP");
+-   ("/xeb/xae/xa3", "HANGUL SYLLABLE MWIH");
+-   ("/xeb/xae/xa4", "HANGUL SYLLABLE MYU");
+-   ("/xeb/xae/xa5", "HANGUL SYLLABLE MYUG");
+-   ("/xeb/xae/xa6", "HANGUL SYLLABLE MYUGG");
+-   ("/xeb/xae/xa7", "HANGUL SYLLABLE MYUGS");
+-   ("/xeb/xae/xa8", "HANGUL SYLLABLE MYUN");
+-   ("/xeb/xae/xa9", "HANGUL SYLLABLE MYUNI");
+-   ("/xeb/xae/xaa", "HANGUL SYLLABLE MYUNH");
+-   ("/xeb/xae/xab", "HANGUL SYLLABLE MYUD");
+-   ("/xeb/xae/xac", "HANGUL SYLLABLE MYUL");
+-   ("/xeb/xae/xad", "HANGUL SYLLABLE MYULG");
+-   ("/xeb/xae/xae", "HANGUL SYLLABLE MYULM");
+-   ("/xeb/xae/xaf", "HANGUL SYLLABLE MYULB");
+-   ("/xeb/xae/xb0", "HANGUL SYLLABLE MYULS");
+-   ("/xeb/xae/xb1", "HANGUL SYLLABLE MYULT");
+-   ("/xeb/xae/xb2", "HANGUL SYLLABLE MYULP");
+-   ("/xeb/xae/xb3", "HANGUL SYLLABLE MYULH");
+-   ("/xeb/xae/xb4", "HANGUL SYLLABLE MYUM");
+-   ("/xeb/xae/xb5", "HANGUL SYLLABLE MYUB");
+-   ("/xeb/xae/xb6", "HANGUL SYLLABLE MYUBS");
+-   ("/xeb/xae/xb7", "HANGUL SYLLABLE MYUS");
+-   ("/xeb/xae/xb8", "HANGUL SYLLABLE MYUSS");
+-   ("/xeb/xae/xb9", "HANGUL SYLLABLE MYUNG");
+-   ("/xeb/xae/xba", "HANGUL SYLLABLE MYUJ");
+-   ("/xeb/xae/xbb", "HANGUL SYLLABLE MYUC");
+-   ("/xeb/xae/xbc", "HANGUL SYLLABLE MYUK");
+-   ("/xeb/xae/xbd", "HANGUL SYLLABLE MYUT");
+-   ("/xeb/xae/xbe", "HANGUL SYLLABLE MYUP");
+-   ("/xeb/xae/xbf", "HANGUL SYLLABLE MYUH");
+-   ("/xeb/xaf/x80", "HANGUL SYLLABLE MEU");
+-   ("/xeb/xaf/x81", "HANGUL SYLLABLE MEUG");
+-   ("/xeb/xaf/x82", "HANGUL SYLLABLE MEUGG");
+-   ("/xeb/xaf/x83", "HANGUL SYLLABLE MEUGS");
+-   ("/xeb/xaf/x84", "HANGUL SYLLABLE MEUN");
+-   ("/xeb/xaf/x85", "HANGUL SYLLABLE MEUNI");
+-   ("/xeb/xaf/x86", "HANGUL SYLLABLE MEUNH");
+-   ("/xeb/xaf/x87", "HANGUL SYLLABLE MEUD");
+-   ("/xeb/xaf/x88", "HANGUL SYLLABLE MEUL");
+-   ("/xeb/xaf/x89", "HANGUL SYLLABLE MEULG");
+-   ("/xeb/xaf/x8a", "HANGUL SYLLABLE MEULM");
+-   ("/xeb/xaf/x8b", "HANGUL SYLLABLE MEULB");
+-   ("/xeb/xaf/x8c", "HANGUL SYLLABLE MEULS");
+-   ("/xeb/xaf/x8d", "HANGUL SYLLABLE MEULT");
+-   ("/xeb/xaf/x8e", "HANGUL SYLLABLE MEULP");
+-   ("/xeb/xaf/x8f", "HANGUL SYLLABLE MEULH");
+-   ("/xeb/xaf/x90", "HANGUL SYLLABLE MEUM");
+-   ("/xeb/xaf/x91", "HANGUL SYLLABLE MEUB");
+-   ("/xeb/xaf/x92", "HANGUL SYLLABLE MEUBS");
+-   ("/xeb/xaf/x93", "HANGUL SYLLABLE MEUS");
+-   ("/xeb/xaf/x94", "HANGUL SYLLABLE MEUSS");
+-   ("/xeb/xaf/x95", "HANGUL SYLLABLE MEUNG");
+-   ("/xeb/xaf/x96", "HANGUL SYLLABLE MEUJ");
+-   ("/xeb/xaf/x97", "HANGUL SYLLABLE MEUC");
+-   ("/xeb/xaf/x98", "HANGUL SYLLABLE MEUK");
+-   ("/xeb/xaf/x99", "HANGUL SYLLABLE MEUT");
+-   ("/xeb/xaf/x9a", "HANGUL SYLLABLE MEUP");
+-   ("/xeb/xaf/x9b", "HANGUL SYLLABLE MEUH");
+-   ("/xeb/xaf/x9c", "HANGUL SYLLABLE MYI");
+-   ("/xeb/xaf/x9d", "HANGUL SYLLABLE MYIG");
+-   ("/xeb/xaf/x9e", "HANGUL SYLLABLE MYIGG");
+-   ("/xeb/xaf/x9f", "HANGUL SYLLABLE MYIGS");
+-   ("/xeb/xaf/xa0", "HANGUL SYLLABLE MYIN");
+-   ("/xeb/xaf/xa1", "HANGUL SYLLABLE MYINI");
+-   ("/xeb/xaf/xa2", "HANGUL SYLLABLE MYINH");
+-   ("/xeb/xaf/xa3", "HANGUL SYLLABLE MYID");
+-   ("/xeb/xaf/xa4", "HANGUL SYLLABLE MYIL");
+-   ("/xeb/xaf/xa5", "HANGUL SYLLABLE MYILG");
+-   ("/xeb/xaf/xa6", "HANGUL SYLLABLE MYILM");
+-   ("/xeb/xaf/xa7", "HANGUL SYLLABLE MYILB");
+-   ("/xeb/xaf/xa8", "HANGUL SYLLABLE MYILS");
+-   ("/xeb/xaf/xa9", "HANGUL SYLLABLE MYILT");
+-   ("/xeb/xaf/xaa", "HANGUL SYLLABLE MYILP");
+-   ("/xeb/xaf/xab", "HANGUL SYLLABLE MYILH");
+-   ("/xeb/xaf/xac", "HANGUL SYLLABLE MYIM");
+-   ("/xeb/xaf/xad", "HANGUL SYLLABLE MYIB");
+-   ("/xeb/xaf/xae", "HANGUL SYLLABLE MYIBS");
+-   ("/xeb/xaf/xaf", "HANGUL SYLLABLE MYIS");
+-   ("/xeb/xaf/xb0", "HANGUL SYLLABLE MYISS");
+-   ("/xeb/xaf/xb1", "HANGUL SYLLABLE MYING");
+-   ("/xeb/xaf/xb2", "HANGUL SYLLABLE MYIJ");
+-   ("/xeb/xaf/xb3", "HANGUL SYLLABLE MYIC");
+-   ("/xeb/xaf/xb4", "HANGUL SYLLABLE MYIK");
+-   ("/xeb/xaf/xb5", "HANGUL SYLLABLE MYIT");
+-   ("/xeb/xaf/xb6", "HANGUL SYLLABLE MYIP");
+-   ("/xeb/xaf/xb7", "HANGUL SYLLABLE MYIH");
+-   ("/xeb/xaf/xb8", "HANGUL SYLLABLE MI");
+-   ("/xeb/xaf/xb9", "HANGUL SYLLABLE MIG");
+-   ("/xeb/xaf/xba", "HANGUL SYLLABLE MIGG");
+-   ("/xeb/xaf/xbb", "HANGUL SYLLABLE MIGS");
+-   ("/xeb/xaf/xbc", "HANGUL SYLLABLE MIN");
+-   ("/xeb/xaf/xbd", "HANGUL SYLLABLE MINI");
+-   ("/xeb/xaf/xbe", "HANGUL SYLLABLE MINH");
+-   ("/xeb/xaf/xbf", "HANGUL SYLLABLE MID");
+-   ("/xeb/xb0/x80", "HANGUL SYLLABLE MIL");
+-   ("/xeb/xb0/x81", "HANGUL SYLLABLE MILG");
+-   ("/xeb/xb0/x82", "HANGUL SYLLABLE MILM");
+-   ("/xeb/xb0/x83", "HANGUL SYLLABLE MILB");
+-   ("/xeb/xb0/x84", "HANGUL SYLLABLE MILS");
+-   ("/xeb/xb0/x85", "HANGUL SYLLABLE MILT");
+-   ("/xeb/xb0/x86", "HANGUL SYLLABLE MILP");
+-   ("/xeb/xb0/x87", "HANGUL SYLLABLE MILH");
+-   ("/xeb/xb0/x88", "HANGUL SYLLABLE MIM");
+-   ("/xeb/xb0/x89", "HANGUL SYLLABLE MIB");
+-   ("/xeb/xb0/x8a", "HANGUL SYLLABLE MIBS");
+-   ("/xeb/xb0/x8b", "HANGUL SYLLABLE MIS");
+-   ("/xeb/xb0/x8c", "HANGUL SYLLABLE MISS");
+-   ("/xeb/xb0/x8d", "HANGUL SYLLABLE MING");
+-   ("/xeb/xb0/x8e", "HANGUL SYLLABLE MIJ");
+-   ("/xeb/xb0/x8f", "HANGUL SYLLABLE MIC");
+-   ("/xeb/xb0/x90", "HANGUL SYLLABLE MIK");
+-   ("/xeb/xb0/x91", "HANGUL SYLLABLE MIT");
+-   ("/xeb/xb0/x92", "HANGUL SYLLABLE MIP");
+-   ("/xeb/xb0/x93", "HANGUL SYLLABLE MIH");
+-   ("/xeb/xb0/x94", "HANGUL SYLLABLE BA");
+-   ("/xeb/xb0/x95", "HANGUL SYLLABLE BAG");
+-   ("/xeb/xb0/x96", "HANGUL SYLLABLE BAGG");
+-   ("/xeb/xb0/x97", "HANGUL SYLLABLE BAGS");
+-   ("/xeb/xb0/x98", "HANGUL SYLLABLE BAN");
+-   ("/xeb/xb0/x99", "HANGUL SYLLABLE BANI");
+-   ("/xeb/xb0/x9a", "HANGUL SYLLABLE BANH");
+-   ("/xeb/xb0/x9b", "HANGUL SYLLABLE BAD");
+-   ("/xeb/xb0/x9c", "HANGUL SYLLABLE BAL");
+-   ("/xeb/xb0/x9d", "HANGUL SYLLABLE BALG");
+-   ("/xeb/xb0/x9e", "HANGUL SYLLABLE BALM");
+-   ("/xeb/xb0/x9f", "HANGUL SYLLABLE BALB");
+-   ("/xeb/xb0/xa0", "HANGUL SYLLABLE BALS");
+-   ("/xeb/xb0/xa1", "HANGUL SYLLABLE BALT");
+-   ("/xeb/xb0/xa2", "HANGUL SYLLABLE BALP");
+-   ("/xeb/xb0/xa3", "HANGUL SYLLABLE BALH");
+-   ("/xeb/xb0/xa4", "HANGUL SYLLABLE BAM");
+-   ("/xeb/xb0/xa5", "HANGUL SYLLABLE BAB");
+-   ("/xeb/xb0/xa6", "HANGUL SYLLABLE BABS");
+-   ("/xeb/xb0/xa7", "HANGUL SYLLABLE BAS");
+-   ("/xeb/xb0/xa8", "HANGUL SYLLABLE BASS");
+-   ("/xeb/xb0/xa9", "HANGUL SYLLABLE BANG");
+-   ("/xeb/xb0/xaa", "HANGUL SYLLABLE BAJ");
+-   ("/xeb/xb0/xab", "HANGUL SYLLABLE BAC");
+-   ("/xeb/xb0/xac", "HANGUL SYLLABLE BAK");
+-   ("/xeb/xb0/xad", "HANGUL SYLLABLE BAT");
+-   ("/xeb/xb0/xae", "HANGUL SYLLABLE BAP");
+-   ("/xeb/xb0/xaf", "HANGUL SYLLABLE BAH");
+-   ("/xeb/xb0/xb0", "HANGUL SYLLABLE BAE");
+-   ("/xeb/xb0/xb1", "HANGUL SYLLABLE BAEG");
+-   ("/xeb/xb0/xb2", "HANGUL SYLLABLE BAEGG");
+-   ("/xeb/xb0/xb3", "HANGUL SYLLABLE BAEGS");
+-   ("/xeb/xb0/xb4", "HANGUL SYLLABLE BAEN");
+-   ("/xeb/xb0/xb5", "HANGUL SYLLABLE BAENI");
+-   ("/xeb/xb0/xb6", "HANGUL SYLLABLE BAENH");
+-   ("/xeb/xb0/xb7", "HANGUL SYLLABLE BAED");
+-   ("/xeb/xb0/xb8", "HANGUL SYLLABLE BAEL");
+-   ("/xeb/xb0/xb9", "HANGUL SYLLABLE BAELG");
+-   ("/xeb/xb0/xba", "HANGUL SYLLABLE BAELM");
+-   ("/xeb/xb0/xbb", "HANGUL SYLLABLE BAELB");
+-   ("/xeb/xb0/xbc", "HANGUL SYLLABLE BAELS");
+-   ("/xeb/xb0/xbd", "HANGUL SYLLABLE BAELT");
+-   ("/xeb/xb0/xbe", "HANGUL SYLLABLE BAELP");
+-   ("/xeb/xb0/xbf", "HANGUL SYLLABLE BAELH");
+-   ("/xeb/xb1/x80", "HANGUL SYLLABLE BAEM");
+-   ("/xeb/xb1/x81", "HANGUL SYLLABLE BAEB");
+-   ("/xeb/xb1/x82", "HANGUL SYLLABLE BAEBS");
+-   ("/xeb/xb1/x83", "HANGUL SYLLABLE BAES");
+-   ("/xeb/xb1/x84", "HANGUL SYLLABLE BAESS");
+-   ("/xeb/xb1/x85", "HANGUL SYLLABLE BAENG");
+-   ("/xeb/xb1/x86", "HANGUL SYLLABLE BAEJ");
+-   ("/xeb/xb1/x87", "HANGUL SYLLABLE BAEC");
+-   ("/xeb/xb1/x88", "HANGUL SYLLABLE BAEK");
+-   ("/xeb/xb1/x89", "HANGUL SYLLABLE BAET");
+-   ("/xeb/xb1/x8a", "HANGUL SYLLABLE BAEP");
+-   ("/xeb/xb1/x8b", "HANGUL SYLLABLE BAEH");
+-   ("/xeb/xb1/x8c", "HANGUL SYLLABLE BYA");
+-   ("/xeb/xb1/x8d", "HANGUL SYLLABLE BYAG");
+-   ("/xeb/xb1/x8e", "HANGUL SYLLABLE BYAGG");
+-   ("/xeb/xb1/x8f", "HANGUL SYLLABLE BYAGS");
+-   ("/xeb/xb1/x90", "HANGUL SYLLABLE BYAN");
+-   ("/xeb/xb1/x91", "HANGUL SYLLABLE BYANI");
+-   ("/xeb/xb1/x92", "HANGUL SYLLABLE BYANH");
+-   ("/xeb/xb1/x93", "HANGUL SYLLABLE BYAD");
+-   ("/xeb/xb1/x94", "HANGUL SYLLABLE BYAL");
+-   ("/xeb/xb1/x95", "HANGUL SYLLABLE BYALG");
+-   ("/xeb/xb1/x96", "HANGUL SYLLABLE BYALM");
+-   ("/xeb/xb1/x97", "HANGUL SYLLABLE BYALB");
+-   ("/xeb/xb1/x98", "HANGUL SYLLABLE BYALS");
+-   ("/xeb/xb1/x99", "HANGUL SYLLABLE BYALT");
+-   ("/xeb/xb1/x9a", "HANGUL SYLLABLE BYALP");
+-   ("/xeb/xb1/x9b", "HANGUL SYLLABLE BYALH");
+-   ("/xeb/xb1/x9c", "HANGUL SYLLABLE BYAM");
+-   ("/xeb/xb1/x9d", "HANGUL SYLLABLE BYAB");
+-   ("/xeb/xb1/x9e", "HANGUL SYLLABLE BYABS");
+-   ("/xeb/xb1/x9f", "HANGUL SYLLABLE BYAS");
+-   ("/xeb/xb1/xa0", "HANGUL SYLLABLE BYASS");
+-   ("/xeb/xb1/xa1", "HANGUL SYLLABLE BYANG");
+-   ("/xeb/xb1/xa2", "HANGUL SYLLABLE BYAJ");
+-   ("/xeb/xb1/xa3", "HANGUL SYLLABLE BYAC");
+-   ("/xeb/xb1/xa4", "HANGUL SYLLABLE BYAK");
+-   ("/xeb/xb1/xa5", "HANGUL SYLLABLE BYAT");
+-   ("/xeb/xb1/xa6", "HANGUL SYLLABLE BYAP");
+-   ("/xeb/xb1/xa7", "HANGUL SYLLABLE BYAH");
+-   ("/xeb/xb1/xa8", "HANGUL SYLLABLE BYAE");
+-   ("/xeb/xb1/xa9", "HANGUL SYLLABLE BYAEG");
+-   ("/xeb/xb1/xaa", "HANGUL SYLLABLE BYAEGG");
+-   ("/xeb/xb1/xab", "HANGUL SYLLABLE BYAEGS");
+-   ("/xeb/xb1/xac", "HANGUL SYLLABLE BYAEN");
+-   ("/xeb/xb1/xad", "HANGUL SYLLABLE BYAENI");
+-   ("/xeb/xb1/xae", "HANGUL SYLLABLE BYAENH");
+-   ("/xeb/xb1/xaf", "HANGUL SYLLABLE BYAED");
+-   ("/xeb/xb1/xb0", "HANGUL SYLLABLE BYAEL");
+-   ("/xeb/xb1/xb1", "HANGUL SYLLABLE BYAELG");
+-   ("/xeb/xb1/xb2", "HANGUL SYLLABLE BYAELM");
+-   ("/xeb/xb1/xb3", "HANGUL SYLLABLE BYAELB");
+-   ("/xeb/xb1/xb4", "HANGUL SYLLABLE BYAELS");
+-   ("/xeb/xb1/xb5", "HANGUL SYLLABLE BYAELT");
+-   ("/xeb/xb1/xb6", "HANGUL SYLLABLE BYAELP");
+-   ("/xeb/xb1/xb7", "HANGUL SYLLABLE BYAELH");
+-   ("/xeb/xb1/xb8", "HANGUL SYLLABLE BYAEM");
+-   ("/xeb/xb1/xb9", "HANGUL SYLLABLE BYAEB");
+-   ("/xeb/xb1/xba", "HANGUL SYLLABLE BYAEBS");
+-   ("/xeb/xb1/xbb", "HANGUL SYLLABLE BYAES");
+-   ("/xeb/xb1/xbc", "HANGUL SYLLABLE BYAESS");
+-   ("/xeb/xb1/xbd", "HANGUL SYLLABLE BYAENG");
+-   ("/xeb/xb1/xbe", "HANGUL SYLLABLE BYAEJ");
+-   ("/xeb/xb1/xbf", "HANGUL SYLLABLE BYAEC");
+-   ("/xeb/xb2/x80", "HANGUL SYLLABLE BYAEK");
+-   ("/xeb/xb2/x81", "HANGUL SYLLABLE BYAET");
+-   ("/xeb/xb2/x82", "HANGUL SYLLABLE BYAEP");
+-   ("/xeb/xb2/x83", "HANGUL SYLLABLE BYAEH");
+-   ("/xeb/xb2/x84", "HANGUL SYLLABLE BEO");
+-   ("/xeb/xb2/x85", "HANGUL SYLLABLE BEOG");
+-   ("/xeb/xb2/x86", "HANGUL SYLLABLE BEOGG");
+-   ("/xeb/xb2/x87", "HANGUL SYLLABLE BEOGS");
+-   ("/xeb/xb2/x88", "HANGUL SYLLABLE BEON");
+-   ("/xeb/xb2/x89", "HANGUL SYLLABLE BEONI");
+-   ("/xeb/xb2/x8a", "HANGUL SYLLABLE BEONH");
+-   ("/xeb/xb2/x8b", "HANGUL SYLLABLE BEOD");
+-   ("/xeb/xb2/x8c", "HANGUL SYLLABLE BEOL");
+-   ("/xeb/xb2/x8d", "HANGUL SYLLABLE BEOLG");
+-   ("/xeb/xb2/x8e", "HANGUL SYLLABLE BEOLM");
+-   ("/xeb/xb2/x8f", "HANGUL SYLLABLE BEOLB");
+-   ("/xeb/xb2/x90", "HANGUL SYLLABLE BEOLS");
+-   ("/xeb/xb2/x91", "HANGUL SYLLABLE BEOLT");
+-   ("/xeb/xb2/x92", "HANGUL SYLLABLE BEOLP");
+-   ("/xeb/xb2/x93", "HANGUL SYLLABLE BEOLH");
+-   ("/xeb/xb2/x94", "HANGUL SYLLABLE BEOM");
+-   ("/xeb/xb2/x95", "HANGUL SYLLABLE BEOB");
+-   ("/xeb/xb2/x96", "HANGUL SYLLABLE BEOBS");
+-   ("/xeb/xb2/x97", "HANGUL SYLLABLE BEOS");
+-   ("/xeb/xb2/x98", "HANGUL SYLLABLE BEOSS");
+-   ("/xeb/xb2/x99", "HANGUL SYLLABLE BEONG");
+-   ("/xeb/xb2/x9a", "HANGUL SYLLABLE BEOJ");
+-   ("/xeb/xb2/x9b", "HANGUL SYLLABLE BEOC");
+-   ("/xeb/xb2/x9c", "HANGUL SYLLABLE BEOK");
+-   ("/xeb/xb2/x9d", "HANGUL SYLLABLE BEOT");
+-   ("/xeb/xb2/x9e", "HANGUL SYLLABLE BEOP");
+-   ("/xeb/xb2/x9f", "HANGUL SYLLABLE BEOH");
+-   ("/xeb/xb2/xa0", "HANGUL SYLLABLE BE");
+-   ("/xeb/xb2/xa1", "HANGUL SYLLABLE BEG");
+-   ("/xeb/xb2/xa2", "HANGUL SYLLABLE BEGG");
+-   ("/xeb/xb2/xa3", "HANGUL SYLLABLE BEGS");
+-   ("/xeb/xb2/xa4", "HANGUL SYLLABLE BEN");
+-   ("/xeb/xb2/xa5", "HANGUL SYLLABLE BENI");
+-   ("/xeb/xb2/xa6", "HANGUL SYLLABLE BENH");
+-   ("/xeb/xb2/xa7", "HANGUL SYLLABLE BED");
+-   ("/xeb/xb2/xa8", "HANGUL SYLLABLE BEL");
+-   ("/xeb/xb2/xa9", "HANGUL SYLLABLE BELG");
+-   ("/xeb/xb2/xaa", "HANGUL SYLLABLE BELM");
+-   ("/xeb/xb2/xab", "HANGUL SYLLABLE BELB");
+-   ("/xeb/xb2/xac", "HANGUL SYLLABLE BELS");
+-   ("/xeb/xb2/xad", "HANGUL SYLLABLE BELT");
+-   ("/xeb/xb2/xae", "HANGUL SYLLABLE BELP");
+-   ("/xeb/xb2/xaf", "HANGUL SYLLABLE BELH");
+-   ("/xeb/xb2/xb0", "HANGUL SYLLABLE BEM");
+-   ("/xeb/xb2/xb1", "HANGUL SYLLABLE BEB");
+-   ("/xeb/xb2/xb2", "HANGUL SYLLABLE BEBS");
+-   ("/xeb/xb2/xb3", "HANGUL SYLLABLE BES");
+-   ("/xeb/xb2/xb4", "HANGUL SYLLABLE BESS");
+-   ("/xeb/xb2/xb5", "HANGUL SYLLABLE BENG");
+-   ("/xeb/xb2/xb6", "HANGUL SYLLABLE BEJ");
+-   ("/xeb/xb2/xb7", "HANGUL SYLLABLE BEC");
+-   ("/xeb/xb2/xb8", "HANGUL SYLLABLE BEK");
+-   ("/xeb/xb2/xb9", "HANGUL SYLLABLE BET");
+-   ("/xeb/xb2/xba", "HANGUL SYLLABLE BEP");
+-   ("/xeb/xb2/xbb", "HANGUL SYLLABLE BEH");
+-   ("/xeb/xb2/xbc", "HANGUL SYLLABLE BYEO");
+-   ("/xeb/xb2/xbd", "HANGUL SYLLABLE BYEOG");
+-   ("/xeb/xb2/xbe", "HANGUL SYLLABLE BYEOGG");
+-   ("/xeb/xb2/xbf", "HANGUL SYLLABLE BYEOGS");
+-   ("/xeb/xb3/x80", "HANGUL SYLLABLE BYEON");
+-   ("/xeb/xb3/x81", "HANGUL SYLLABLE BYEONI");
+-   ("/xeb/xb3/x82", "HANGUL SYLLABLE BYEONH");
+-   ("/xeb/xb3/x83", "HANGUL SYLLABLE BYEOD");
+-   ("/xeb/xb3/x84", "HANGUL SYLLABLE BYEOL");
+-   ("/xeb/xb3/x85", "HANGUL SYLLABLE BYEOLG");
+-   ("/xeb/xb3/x86", "HANGUL SYLLABLE BYEOLM");
+-   ("/xeb/xb3/x87", "HANGUL SYLLABLE BYEOLB");
+-   ("/xeb/xb3/x88", "HANGUL SYLLABLE BYEOLS");
+-   ("/xeb/xb3/x89", "HANGUL SYLLABLE BYEOLT");
+-   ("/xeb/xb3/x8a", "HANGUL SYLLABLE BYEOLP");
+-   ("/xeb/xb3/x8b", "HANGUL SYLLABLE BYEOLH");
+-   ("/xeb/xb3/x8c", "HANGUL SYLLABLE BYEOM");
+-   ("/xeb/xb3/x8d", "HANGUL SYLLABLE BYEOB");
+-   ("/xeb/xb3/x8e", "HANGUL SYLLABLE BYEOBS");
+-   ("/xeb/xb3/x8f", "HANGUL SYLLABLE BYEOS");
+-   ("/xeb/xb3/x90", "HANGUL SYLLABLE BYEOSS");
+-   ("/xeb/xb3/x91", "HANGUL SYLLABLE BYEONG");
+-   ("/xeb/xb3/x92", "HANGUL SYLLABLE BYEOJ");
+-   ("/xeb/xb3/x93", "HANGUL SYLLABLE BYEOC");
+-   ("/xeb/xb3/x94", "HANGUL SYLLABLE BYEOK");
+-   ("/xeb/xb3/x95", "HANGUL SYLLABLE BYEOT");
+-   ("/xeb/xb3/x96", "HANGUL SYLLABLE BYEOP");
+-   ("/xeb/xb3/x97", "HANGUL SYLLABLE BYEOH");
+-   ("/xeb/xb3/x98", "HANGUL SYLLABLE BYE");
+-   ("/xeb/xb3/x99", "HANGUL SYLLABLE BYEG");
+-   ("/xeb/xb3/x9a", "HANGUL SYLLABLE BYEGG");
+-   ("/xeb/xb3/x9b", "HANGUL SYLLABLE BYEGS");
+-   ("/xeb/xb3/x9c", "HANGUL SYLLABLE BYEN");
+-   ("/xeb/xb3/x9d", "HANGUL SYLLABLE BYENI");
+-   ("/xeb/xb3/x9e", "HANGUL SYLLABLE BYENH");
+-   ("/xeb/xb3/x9f", "HANGUL SYLLABLE BYED");
+-   ("/xeb/xb3/xa0", "HANGUL SYLLABLE BYEL");
+-   ("/xeb/xb3/xa1", "HANGUL SYLLABLE BYELG");
+-   ("/xeb/xb3/xa2", "HANGUL SYLLABLE BYELM");
+-   ("/xeb/xb3/xa3", "HANGUL SYLLABLE BYELB");
+-   ("/xeb/xb3/xa4", "HANGUL SYLLABLE BYELS");
+-   ("/xeb/xb3/xa5", "HANGUL SYLLABLE BYELT");
+-   ("/xeb/xb3/xa6", "HANGUL SYLLABLE BYELP");
+-   ("/xeb/xb3/xa7", "HANGUL SYLLABLE BYELH");
+-   ("/xeb/xb3/xa8", "HANGUL SYLLABLE BYEM");
+-   ("/xeb/xb3/xa9", "HANGUL SYLLABLE BYEB");
+-   ("/xeb/xb3/xaa", "HANGUL SYLLABLE BYEBS");
+-   ("/xeb/xb3/xab", "HANGUL SYLLABLE BYES");
+-   ("/xeb/xb3/xac", "HANGUL SYLLABLE BYESS");
+-   ("/xeb/xb3/xad", "HANGUL SYLLABLE BYENG");
+-   ("/xeb/xb3/xae", "HANGUL SYLLABLE BYEJ");
+-   ("/xeb/xb3/xaf", "HANGUL SYLLABLE BYEC");
+-   ("/xeb/xb3/xb0", "HANGUL SYLLABLE BYEK");
+-   ("/xeb/xb3/xb1", "HANGUL SYLLABLE BYET");
+-   ("/xeb/xb3/xb2", "HANGUL SYLLABLE BYEP");
+-   ("/xeb/xb3/xb3", "HANGUL SYLLABLE BYEH");
+-   ("/xeb/xb3/xb4", "HANGUL SYLLABLE BO");
+-   ("/xeb/xb3/xb5", "HANGUL SYLLABLE BOG");
+-   ("/xeb/xb3/xb6", "HANGUL SYLLABLE BOGG");
+-   ("/xeb/xb3/xb7", "HANGUL SYLLABLE BOGS");
+-   ("/xeb/xb3/xb8", "HANGUL SYLLABLE BON");
+-   ("/xeb/xb3/xb9", "HANGUL SYLLABLE BONI");
+-   ("/xeb/xb3/xba", "HANGUL SYLLABLE BONH");
+-   ("/xeb/xb3/xbb", "HANGUL SYLLABLE BOD");
+-   ("/xeb/xb3/xbc", "HANGUL SYLLABLE BOL");
+-   ("/xeb/xb3/xbd", "HANGUL SYLLABLE BOLG");
+-   ("/xeb/xb3/xbe", "HANGUL SYLLABLE BOLM");
+-   ("/xeb/xb3/xbf", "HANGUL SYLLABLE BOLB");
+-   ("/xeb/xb4/x80", "HANGUL SYLLABLE BOLS");
+-   ("/xeb/xb4/x81", "HANGUL SYLLABLE BOLT");
+-   ("/xeb/xb4/x82", "HANGUL SYLLABLE BOLP");
+-   ("/xeb/xb4/x83", "HANGUL SYLLABLE BOLH");
+-   ("/xeb/xb4/x84", "HANGUL SYLLABLE BOM");
+-   ("/xeb/xb4/x85", "HANGUL SYLLABLE BOB");
+-   ("/xeb/xb4/x86", "HANGUL SYLLABLE BOBS");
+-   ("/xeb/xb4/x87", "HANGUL SYLLABLE BOS");
+-   ("/xeb/xb4/x88", "HANGUL SYLLABLE BOSS");
+-   ("/xeb/xb4/x89", "HANGUL SYLLABLE BONG");
+-   ("/xeb/xb4/x8a", "HANGUL SYLLABLE BOJ");
+-   ("/xeb/xb4/x8b", "HANGUL SYLLABLE BOC");
+-   ("/xeb/xb4/x8c", "HANGUL SYLLABLE BOK");
+-   ("/xeb/xb4/x8d", "HANGUL SYLLABLE BOT");
+-   ("/xeb/xb4/x8e", "HANGUL SYLLABLE BOP");
+-   ("/xeb/xb4/x8f", "HANGUL SYLLABLE BOH");
+-   ("/xeb/xb4/x90", "HANGUL SYLLABLE BWA");
+-   ("/xeb/xb4/x91", "HANGUL SYLLABLE BWAG");
+-   ("/xeb/xb4/x92", "HANGUL SYLLABLE BWAGG");
+-   ("/xeb/xb4/x93", "HANGUL SYLLABLE BWAGS");
+-   ("/xeb/xb4/x94", "HANGUL SYLLABLE BWAN");
+-   ("/xeb/xb4/x95", "HANGUL SYLLABLE BWANI");
+-   ("/xeb/xb4/x96", "HANGUL SYLLABLE BWANH");
+-   ("/xeb/xb4/x97", "HANGUL SYLLABLE BWAD");
+-   ("/xeb/xb4/x98", "HANGUL SYLLABLE BWAL");
+-   ("/xeb/xb4/x99", "HANGUL SYLLABLE BWALG");
+-   ("/xeb/xb4/x9a", "HANGUL SYLLABLE BWALM");
+-   ("/xeb/xb4/x9b", "HANGUL SYLLABLE BWALB");
+-   ("/xeb/xb4/x9c", "HANGUL SYLLABLE BWALS");
+-   ("/xeb/xb4/x9d", "HANGUL SYLLABLE BWALT");
+-   ("/xeb/xb4/x9e", "HANGUL SYLLABLE BWALP");
+-   ("/xeb/xb4/x9f", "HANGUL SYLLABLE BWALH");
+-   ("/xeb/xb4/xa0", "HANGUL SYLLABLE BWAM");
+-   ("/xeb/xb4/xa1", "HANGUL SYLLABLE BWAB");
+-   ("/xeb/xb4/xa2", "HANGUL SYLLABLE BWABS");
+-   ("/xeb/xb4/xa3", "HANGUL SYLLABLE BWAS");
+-   ("/xeb/xb4/xa4", "HANGUL SYLLABLE BWASS");
+-   ("/xeb/xb4/xa5", "HANGUL SYLLABLE BWANG");
+-   ("/xeb/xb4/xa6", "HANGUL SYLLABLE BWAJ");
+-   ("/xeb/xb4/xa7", "HANGUL SYLLABLE BWAC");
+-   ("/xeb/xb4/xa8", "HANGUL SYLLABLE BWAK");
+-   ("/xeb/xb4/xa9", "HANGUL SYLLABLE BWAT");
+-   ("/xeb/xb4/xaa", "HANGUL SYLLABLE BWAP");
+-   ("/xeb/xb4/xab", "HANGUL SYLLABLE BWAH");
+-   ("/xeb/xb4/xac", "HANGUL SYLLABLE BWAE");
+-   ("/xeb/xb4/xad", "HANGUL SYLLABLE BWAEG");
+-   ("/xeb/xb4/xae", "HANGUL SYLLABLE BWAEGG");
+-   ("/xeb/xb4/xaf", "HANGUL SYLLABLE BWAEGS");
+-   ("/xeb/xb4/xb0", "HANGUL SYLLABLE BWAEN");
+-   ("/xeb/xb4/xb1", "HANGUL SYLLABLE BWAENI");
+-   ("/xeb/xb4/xb2", "HANGUL SYLLABLE BWAENH");
+-   ("/xeb/xb4/xb3", "HANGUL SYLLABLE BWAED");
+-   ("/xeb/xb4/xb4", "HANGUL SYLLABLE BWAEL");
+-   ("/xeb/xb4/xb5", "HANGUL SYLLABLE BWAELG");
+-   ("/xeb/xb4/xb6", "HANGUL SYLLABLE BWAELM");
+-   ("/xeb/xb4/xb7", "HANGUL SYLLABLE BWAELB");
+-   ("/xeb/xb4/xb8", "HANGUL SYLLABLE BWAELS");
+-   ("/xeb/xb4/xb9", "HANGUL SYLLABLE BWAELT");
+-   ("/xeb/xb4/xba", "HANGUL SYLLABLE BWAELP");
+-   ("/xeb/xb4/xbb", "HANGUL SYLLABLE BWAELH");
+-   ("/xeb/xb4/xbc", "HANGUL SYLLABLE BWAEM");
+-   ("/xeb/xb4/xbd", "HANGUL SYLLABLE BWAEB");
+-   ("/xeb/xb4/xbe", "HANGUL SYLLABLE BWAEBS");
+-   ("/xeb/xb4/xbf", "HANGUL SYLLABLE BWAES");
+-   ("/xeb/xb5/x80", "HANGUL SYLLABLE BWAESS");
+-   ("/xeb/xb5/x81", "HANGUL SYLLABLE BWAENG");
+-   ("/xeb/xb5/x82", "HANGUL SYLLABLE BWAEJ");
+-   ("/xeb/xb5/x83", "HANGUL SYLLABLE BWAEC");
+-   ("/xeb/xb5/x84", "HANGUL SYLLABLE BWAEK");
+-   ("/xeb/xb5/x85", "HANGUL SYLLABLE BWAET");
+-   ("/xeb/xb5/x86", "HANGUL SYLLABLE BWAEP");
+-   ("/xeb/xb5/x87", "HANGUL SYLLABLE BWAEH");
+-   ("/xeb/xb5/x88", "HANGUL SYLLABLE BOE");
+-   ("/xeb/xb5/x89", "HANGUL SYLLABLE BOEG");
+-   ("/xeb/xb5/x8a", "HANGUL SYLLABLE BOEGG");
+-   ("/xeb/xb5/x8b", "HANGUL SYLLABLE BOEGS");
+-   ("/xeb/xb5/x8c", "HANGUL SYLLABLE BOEN");
+-   ("/xeb/xb5/x8d", "HANGUL SYLLABLE BOENI");
+-   ("/xeb/xb5/x8e", "HANGUL SYLLABLE BOENH");
+-   ("/xeb/xb5/x8f", "HANGUL SYLLABLE BOED");
+-   ("/xeb/xb5/x90", "HANGUL SYLLABLE BOEL");
+-   ("/xeb/xb5/x91", "HANGUL SYLLABLE BOELG");
+-   ("/xeb/xb5/x92", "HANGUL SYLLABLE BOELM");
+-   ("/xeb/xb5/x93", "HANGUL SYLLABLE BOELB");
+-   ("/xeb/xb5/x94", "HANGUL SYLLABLE BOELS");
+-   ("/xeb/xb5/x95", "HANGUL SYLLABLE BOELT");
+-   ("/xeb/xb5/x96", "HANGUL SYLLABLE BOELP");
+-   ("/xeb/xb5/x97", "HANGUL SYLLABLE BOELH");
+-   ("/xeb/xb5/x98", "HANGUL SYLLABLE BOEM");
+-   ("/xeb/xb5/x99", "HANGUL SYLLABLE BOEB");
+-   ("/xeb/xb5/x9a", "HANGUL SYLLABLE BOEBS");
+-   ("/xeb/xb5/x9b", "HANGUL SYLLABLE BOES");
+-   ("/xeb/xb5/x9c", "HANGUL SYLLABLE BOESS");
+-   ("/xeb/xb5/x9d", "HANGUL SYLLABLE BOENG");
+-   ("/xeb/xb5/x9e", "HANGUL SYLLABLE BOEJ");
+-   ("/xeb/xb5/x9f", "HANGUL SYLLABLE BOEC");
+-   ("/xeb/xb5/xa0", "HANGUL SYLLABLE BOEK");
+-   ("/xeb/xb5/xa1", "HANGUL SYLLABLE BOET");
+-   ("/xeb/xb5/xa2", "HANGUL SYLLABLE BOEP");
+-   ("/xeb/xb5/xa3", "HANGUL SYLLABLE BOEH");
+-   ("/xeb/xb5/xa4", "HANGUL SYLLABLE BYO");
+-   ("/xeb/xb5/xa5", "HANGUL SYLLABLE BYOG");
+-   ("/xeb/xb5/xa6", "HANGUL SYLLABLE BYOGG");
+-   ("/xeb/xb5/xa7", "HANGUL SYLLABLE BYOGS");
+-   ("/xeb/xb5/xa8", "HANGUL SYLLABLE BYON");
+-   ("/xeb/xb5/xa9", "HANGUL SYLLABLE BYONI");
+-   ("/xeb/xb5/xaa", "HANGUL SYLLABLE BYONH");
+-   ("/xeb/xb5/xab", "HANGUL SYLLABLE BYOD");
+-   ("/xeb/xb5/xac", "HANGUL SYLLABLE BYOL");
+-   ("/xeb/xb5/xad", "HANGUL SYLLABLE BYOLG");
+-   ("/xeb/xb5/xae", "HANGUL SYLLABLE BYOLM");
+-   ("/xeb/xb5/xaf", "HANGUL SYLLABLE BYOLB");
+-   ("/xeb/xb5/xb0", "HANGUL SYLLABLE BYOLS");
+-   ("/xeb/xb5/xb1", "HANGUL SYLLABLE BYOLT");
+-   ("/xeb/xb5/xb2", "HANGUL SYLLABLE BYOLP");
+-   ("/xeb/xb5/xb3", "HANGUL SYLLABLE BYOLH");
+-   ("/xeb/xb5/xb4", "HANGUL SYLLABLE BYOM");
+-   ("/xeb/xb5/xb5", "HANGUL SYLLABLE BYOB");
+-   ("/xeb/xb5/xb6", "HANGUL SYLLABLE BYOBS");
+-   ("/xeb/xb5/xb7", "HANGUL SYLLABLE BYOS");
+-   ("/xeb/xb5/xb8", "HANGUL SYLLABLE BYOSS");
+-   ("/xeb/xb5/xb9", "HANGUL SYLLABLE BYONG");
+-   ("/xeb/xb5/xba", "HANGUL SYLLABLE BYOJ");
+-   ("/xeb/xb5/xbb", "HANGUL SYLLABLE BYOC");
+-   ("/xeb/xb5/xbc", "HANGUL SYLLABLE BYOK");
+-   ("/xeb/xb5/xbd", "HANGUL SYLLABLE BYOT");
+-   ("/xeb/xb5/xbe", "HANGUL SYLLABLE BYOP");
+-   ("/xeb/xb5/xbf", "HANGUL SYLLABLE BYOH");
+-   ("/xeb/xb6/x80", "HANGUL SYLLABLE BU");
+-   ("/xeb/xb6/x81", "HANGUL SYLLABLE BUG");
+-   ("/xeb/xb6/x82", "HANGUL SYLLABLE BUGG");
+-   ("/xeb/xb6/x83", "HANGUL SYLLABLE BUGS");
+-   ("/xeb/xb6/x84", "HANGUL SYLLABLE BUN");
+-   ("/xeb/xb6/x85", "HANGUL SYLLABLE BUNI");
+-   ("/xeb/xb6/x86", "HANGUL SYLLABLE BUNH");
+-   ("/xeb/xb6/x87", "HANGUL SYLLABLE BUD");
+-   ("/xeb/xb6/x88", "HANGUL SYLLABLE BUL");
+-   ("/xeb/xb6/x89", "HANGUL SYLLABLE BULG");
+-   ("/xeb/xb6/x8a", "HANGUL SYLLABLE BULM");
+-   ("/xeb/xb6/x8b", "HANGUL SYLLABLE BULB");
+-   ("/xeb/xb6/x8c", "HANGUL SYLLABLE BULS");
+-   ("/xeb/xb6/x8d", "HANGUL SYLLABLE BULT");
+-   ("/xeb/xb6/x8e", "HANGUL SYLLABLE BULP");
+-   ("/xeb/xb6/x8f", "HANGUL SYLLABLE BULH");
+-   ("/xeb/xb6/x90", "HANGUL SYLLABLE BUM");
+-   ("/xeb/xb6/x91", "HANGUL SYLLABLE BUB");
+-   ("/xeb/xb6/x92", "HANGUL SYLLABLE BUBS");
+-   ("/xeb/xb6/x93", "HANGUL SYLLABLE BUS");
+-   ("/xeb/xb6/x94", "HANGUL SYLLABLE BUSS");
+-   ("/xeb/xb6/x95", "HANGUL SYLLABLE BUNG");
+-   ("/xeb/xb6/x96", "HANGUL SYLLABLE BUJ");
+-   ("/xeb/xb6/x97", "HANGUL SYLLABLE BUC");
+-   ("/xeb/xb6/x98", "HANGUL SYLLABLE BUK");
+-   ("/xeb/xb6/x99", "HANGUL SYLLABLE BUT");
+-   ("/xeb/xb6/x9a", "HANGUL SYLLABLE BUP");
+-   ("/xeb/xb6/x9b", "HANGUL SYLLABLE BUH");
+-   ("/xeb/xb6/x9c", "HANGUL SYLLABLE BWEO");
+-   ("/xeb/xb6/x9d", "HANGUL SYLLABLE BWEOG");
+-   ("/xeb/xb6/x9e", "HANGUL SYLLABLE BWEOGG");
+-   ("/xeb/xb6/x9f", "HANGUL SYLLABLE BWEOGS");
+-   ("/xeb/xb6/xa0", "HANGUL SYLLABLE BWEON");
+-   ("/xeb/xb6/xa1", "HANGUL SYLLABLE BWEONI");
+-   ("/xeb/xb6/xa2", "HANGUL SYLLABLE BWEONH");
+-   ("/xeb/xb6/xa3", "HANGUL SYLLABLE BWEOD");
+-   ("/xeb/xb6/xa4", "HANGUL SYLLABLE BWEOL");
+-   ("/xeb/xb6/xa5", "HANGUL SYLLABLE BWEOLG");
+-   ("/xeb/xb6/xa6", "HANGUL SYLLABLE BWEOLM");
+-   ("/xeb/xb6/xa7", "HANGUL SYLLABLE BWEOLB");
+-   ("/xeb/xb6/xa8", "HANGUL SYLLABLE BWEOLS");
+-   ("/xeb/xb6/xa9", "HANGUL SYLLABLE BWEOLT");
+-   ("/xeb/xb6/xaa", "HANGUL SYLLABLE BWEOLP");
+-   ("/xeb/xb6/xab", "HANGUL SYLLABLE BWEOLH");
+-   ("/xeb/xb6/xac", "HANGUL SYLLABLE BWEOM");
+-   ("/xeb/xb6/xad", "HANGUL SYLLABLE BWEOB");
+-   ("/xeb/xb6/xae", "HANGUL SYLLABLE BWEOBS");
+-   ("/xeb/xb6/xaf", "HANGUL SYLLABLE BWEOS");
+-   ("/xeb/xb6/xb0", "HANGUL SYLLABLE BWEOSS");
+-   ("/xeb/xb6/xb1", "HANGUL SYLLABLE BWEONG");
+-   ("/xeb/xb6/xb2", "HANGUL SYLLABLE BWEOJ");
+-   ("/xeb/xb6/xb3", "HANGUL SYLLABLE BWEOC");
+-   ("/xeb/xb6/xb4", "HANGUL SYLLABLE BWEOK");
+-   ("/xeb/xb6/xb5", "HANGUL SYLLABLE BWEOT");
+-   ("/xeb/xb6/xb6", "HANGUL SYLLABLE BWEOP");
+-   ("/xeb/xb6/xb7", "HANGUL SYLLABLE BWEOH");
+-   ("/xeb/xb6/xb8", "HANGUL SYLLABLE BWE");
+-   ("/xeb/xb6/xb9", "HANGUL SYLLABLE BWEG");
+-   ("/xeb/xb6/xba", "HANGUL SYLLABLE BWEGG");
+-   ("/xeb/xb6/xbb", "HANGUL SYLLABLE BWEGS");
+-   ("/xeb/xb6/xbc", "HANGUL SYLLABLE BWEN");
+-   ("/xeb/xb6/xbd", "HANGUL SYLLABLE BWENI");
+-   ("/xeb/xb6/xbe", "HANGUL SYLLABLE BWENH");
+-   ("/xeb/xb6/xbf", "HANGUL SYLLABLE BWED");
+-   ("/xeb/xb7/x80", "HANGUL SYLLABLE BWEL");
+-   ("/xeb/xb7/x81", "HANGUL SYLLABLE BWELG");
+-   ("/xeb/xb7/x82", "HANGUL SYLLABLE BWELM");
+-   ("/xeb/xb7/x83", "HANGUL SYLLABLE BWELB");
+-   ("/xeb/xb7/x84", "HANGUL SYLLABLE BWELS");
+-   ("/xeb/xb7/x85", "HANGUL SYLLABLE BWELT");
+-   ("/xeb/xb7/x86", "HANGUL SYLLABLE BWELP");
+-   ("/xeb/xb7/x87", "HANGUL SYLLABLE BWELH");
+-   ("/xeb/xb7/x88", "HANGUL SYLLABLE BWEM");
+-   ("/xeb/xb7/x89", "HANGUL SYLLABLE BWEB");
+-   ("/xeb/xb7/x8a", "HANGUL SYLLABLE BWEBS");
+-   ("/xeb/xb7/x8b", "HANGUL SYLLABLE BWES");
+-   ("/xeb/xb7/x8c", "HANGUL SYLLABLE BWESS");
+-   ("/xeb/xb7/x8d", "HANGUL SYLLABLE BWENG");
+-   ("/xeb/xb7/x8e", "HANGUL SYLLABLE BWEJ");
+-   ("/xeb/xb7/x8f", "HANGUL SYLLABLE BWEC");
+-   ("/xeb/xb7/x90", "HANGUL SYLLABLE BWEK");
+-   ("/xeb/xb7/x91", "HANGUL SYLLABLE BWET");
+-   ("/xeb/xb7/x92", "HANGUL SYLLABLE BWEP");
+-   ("/xeb/xb7/x93", "HANGUL SYLLABLE BWEH");
+-   ("/xeb/xb7/x94", "HANGUL SYLLABLE BWI");
+-   ("/xeb/xb7/x95", "HANGUL SYLLABLE BWIG");
+-   ("/xeb/xb7/x96", "HANGUL SYLLABLE BWIGG");
+-   ("/xeb/xb7/x97", "HANGUL SYLLABLE BWIGS");
+-   ("/xeb/xb7/x98", "HANGUL SYLLABLE BWIN");
+-   ("/xeb/xb7/x99", "HANGUL SYLLABLE BWINI");
+-   ("/xeb/xb7/x9a", "HANGUL SYLLABLE BWINH");
+-   ("/xeb/xb7/x9b", "HANGUL SYLLABLE BWID");
+-   ("/xeb/xb7/x9c", "HANGUL SYLLABLE BWIL");
+-   ("/xeb/xb7/x9d", "HANGUL SYLLABLE BWILG");
+-   ("/xeb/xb7/x9e", "HANGUL SYLLABLE BWILM");
+-   ("/xeb/xb7/x9f", "HANGUL SYLLABLE BWILB");
+-   ("/xeb/xb7/xa0", "HANGUL SYLLABLE BWILS");
+-   ("/xeb/xb7/xa1", "HANGUL SYLLABLE BWILT");
+-   ("/xeb/xb7/xa2", "HANGUL SYLLABLE BWILP");
+-   ("/xeb/xb7/xa3", "HANGUL SYLLABLE BWILH");
+-   ("/xeb/xb7/xa4", "HANGUL SYLLABLE BWIM");
+-   ("/xeb/xb7/xa5", "HANGUL SYLLABLE BWIB");
+-   ("/xeb/xb7/xa6", "HANGUL SYLLABLE BWIBS");
+-   ("/xeb/xb7/xa7", "HANGUL SYLLABLE BWIS");
+-   ("/xeb/xb7/xa8", "HANGUL SYLLABLE BWISS");
+-   ("/xeb/xb7/xa9", "HANGUL SYLLABLE BWING");
+-   ("/xeb/xb7/xaa", "HANGUL SYLLABLE BWIJ");
+-   ("/xeb/xb7/xab", "HANGUL SYLLABLE BWIC");
+-   ("/xeb/xb7/xac", "HANGUL SYLLABLE BWIK");
+-   ("/xeb/xb7/xad", "HANGUL SYLLABLE BWIT");
+-   ("/xeb/xb7/xae", "HANGUL SYLLABLE BWIP");
+-   ("/xeb/xb7/xaf", "HANGUL SYLLABLE BWIH");
+-   ("/xeb/xb7/xb0", "HANGUL SYLLABLE BYU");
+-   ("/xeb/xb7/xb1", "HANGUL SYLLABLE BYUG");
+-   ("/xeb/xb7/xb2", "HANGUL SYLLABLE BYUGG");
+-   ("/xeb/xb7/xb3", "HANGUL SYLLABLE BYUGS");
+-   ("/xeb/xb7/xb4", "HANGUL SYLLABLE BYUN");
+-   ("/xeb/xb7/xb5", "HANGUL SYLLABLE BYUNI");
+-   ("/xeb/xb7/xb6", "HANGUL SYLLABLE BYUNH");
+-   ("/xeb/xb7/xb7", "HANGUL SYLLABLE BYUD");
+-   ("/xeb/xb7/xb8", "HANGUL SYLLABLE BYUL");
+-   ("/xeb/xb7/xb9", "HANGUL SYLLABLE BYULG");
+-   ("/xeb/xb7/xba", "HANGUL SYLLABLE BYULM");
+-   ("/xeb/xb7/xbb", "HANGUL SYLLABLE BYULB");
+-   ("/xeb/xb7/xbc", "HANGUL SYLLABLE BYULS");
+-   ("/xeb/xb7/xbd", "HANGUL SYLLABLE BYULT");
+-   ("/xeb/xb7/xbe", "HANGUL SYLLABLE BYULP");
+-   ("/xeb/xb7/xbf", "HANGUL SYLLABLE BYULH");
+-   ("/xeb/xb8/x80", "HANGUL SYLLABLE BYUM");
+-   ("/xeb/xb8/x81", "HANGUL SYLLABLE BYUB");
+-   ("/xeb/xb8/x82", "HANGUL SYLLABLE BYUBS");
+-   ("/xeb/xb8/x83", "HANGUL SYLLABLE BYUS");
+-   ("/xeb/xb8/x84", "HANGUL SYLLABLE BYUSS");
+-   ("/xeb/xb8/x85", "HANGUL SYLLABLE BYUNG");
+-   ("/xeb/xb8/x86", "HANGUL SYLLABLE BYUJ");
+-   ("/xeb/xb8/x87", "HANGUL SYLLABLE BYUC");
+-   ("/xeb/xb8/x88", "HANGUL SYLLABLE BYUK");
+-   ("/xeb/xb8/x89", "HANGUL SYLLABLE BYUT");
+-   ("/xeb/xb8/x8a", "HANGUL SYLLABLE BYUP");
+-   ("/xeb/xb8/x8b", "HANGUL SYLLABLE BYUH");
+-   ("/xeb/xb8/x8c", "HANGUL SYLLABLE BEU");
+-   ("/xeb/xb8/x8d", "HANGUL SYLLABLE BEUG");
+-   ("/xeb/xb8/x8e", "HANGUL SYLLABLE BEUGG");
+-   ("/xeb/xb8/x8f", "HANGUL SYLLABLE BEUGS");
+-   ("/xeb/xb8/x90", "HANGUL SYLLABLE BEUN");
+-   ("/xeb/xb8/x91", "HANGUL SYLLABLE BEUNI");
+-   ("/xeb/xb8/x92", "HANGUL SYLLABLE BEUNH");
+-   ("/xeb/xb8/x93", "HANGUL SYLLABLE BEUD");
+-   ("/xeb/xb8/x94", "HANGUL SYLLABLE BEUL");
+-   ("/xeb/xb8/x95", "HANGUL SYLLABLE BEULG");
+-   ("/xeb/xb8/x96", "HANGUL SYLLABLE BEULM");
+-   ("/xeb/xb8/x97", "HANGUL SYLLABLE BEULB");
+-   ("/xeb/xb8/x98", "HANGUL SYLLABLE BEULS");
+-   ("/xeb/xb8/x99", "HANGUL SYLLABLE BEULT");
+-   ("/xeb/xb8/x9a", "HANGUL SYLLABLE BEULP");
+-   ("/xeb/xb8/x9b", "HANGUL SYLLABLE BEULH");
+-   ("/xeb/xb8/x9c", "HANGUL SYLLABLE BEUM");
+-   ("/xeb/xb8/x9d", "HANGUL SYLLABLE BEUB");
+-   ("/xeb/xb8/x9e", "HANGUL SYLLABLE BEUBS");
+-   ("/xeb/xb8/x9f", "HANGUL SYLLABLE BEUS");
+-   ("/xeb/xb8/xa0", "HANGUL SYLLABLE BEUSS");
+-   ("/xeb/xb8/xa1", "HANGUL SYLLABLE BEUNG");
+-   ("/xeb/xb8/xa2", "HANGUL SYLLABLE BEUJ");
+-   ("/xeb/xb8/xa3", "HANGUL SYLLABLE BEUC");
+-   ("/xeb/xb8/xa4", "HANGUL SYLLABLE BEUK");
+-   ("/xeb/xb8/xa5", "HANGUL SYLLABLE BEUT");
+-   ("/xeb/xb8/xa6", "HANGUL SYLLABLE BEUP");
+-   ("/xeb/xb8/xa7", "HANGUL SYLLABLE BEUH");
+-   ("/xeb/xb8/xa8", "HANGUL SYLLABLE BYI");
+-   ("/xeb/xb8/xa9", "HANGUL SYLLABLE BYIG");
+-   ("/xeb/xb8/xaa", "HANGUL SYLLABLE BYIGG");
+-   ("/xeb/xb8/xab", "HANGUL SYLLABLE BYIGS");
+-   ("/xeb/xb8/xac", "HANGUL SYLLABLE BYIN");
+-   ("/xeb/xb8/xad", "HANGUL SYLLABLE BYINI");
+-   ("/xeb/xb8/xae", "HANGUL SYLLABLE BYINH");
+-   ("/xeb/xb8/xaf", "HANGUL SYLLABLE BYID");
+-   ("/xeb/xb8/xb0", "HANGUL SYLLABLE BYIL");
+-   ("/xeb/xb8/xb1", "HANGUL SYLLABLE BYILG");
+-   ("/xeb/xb8/xb2", "HANGUL SYLLABLE BYILM");
+-   ("/xeb/xb8/xb3", "HANGUL SYLLABLE BYILB");
+-   ("/xeb/xb8/xb4", "HANGUL SYLLABLE BYILS");
+-   ("/xeb/xb8/xb5", "HANGUL SYLLABLE BYILT");
+-   ("/xeb/xb8/xb6", "HANGUL SYLLABLE BYILP");
+-   ("/xeb/xb8/xb7", "HANGUL SYLLABLE BYILH");
+-   ("/xeb/xb8/xb8", "HANGUL SYLLABLE BYIM");
+-   ("/xeb/xb8/xb9", "HANGUL SYLLABLE BYIB");
+-   ("/xeb/xb8/xba", "HANGUL SYLLABLE BYIBS");
+-   ("/xeb/xb8/xbb", "HANGUL SYLLABLE BYIS");
+-   ("/xeb/xb8/xbc", "HANGUL SYLLABLE BYISS");
+-   ("/xeb/xb8/xbd", "HANGUL SYLLABLE BYING");
+-   ("/xeb/xb8/xbe", "HANGUL SYLLABLE BYIJ");
+-   ("/xeb/xb8/xbf", "HANGUL SYLLABLE BYIC");
+-   ("/xeb/xb9/x80", "HANGUL SYLLABLE BYIK");
+-   ("/xeb/xb9/x81", "HANGUL SYLLABLE BYIT");
+-   ("/xeb/xb9/x82", "HANGUL SYLLABLE BYIP");
+-   ("/xeb/xb9/x83", "HANGUL SYLLABLE BYIH");
+-   ("/xeb/xb9/x84", "HANGUL SYLLABLE BI");
+-   ("/xeb/xb9/x85", "HANGUL SYLLABLE BIG");
+-   ("/xeb/xb9/x86", "HANGUL SYLLABLE BIGG");
+-   ("/xeb/xb9/x87", "HANGUL SYLLABLE BIGS");
+-   ("/xeb/xb9/x88", "HANGUL SYLLABLE BIN");
+-   ("/xeb/xb9/x89", "HANGUL SYLLABLE BINI");
+-   ("/xeb/xb9/x8a", "HANGUL SYLLABLE BINH");
+-   ("/xeb/xb9/x8b", "HANGUL SYLLABLE BID");
+-   ("/xeb/xb9/x8c", "HANGUL SYLLABLE BIL");
+-   ("/xeb/xb9/x8d", "HANGUL SYLLABLE BILG");
+-   ("/xeb/xb9/x8e", "HANGUL SYLLABLE BILM");
+-   ("/xeb/xb9/x8f", "HANGUL SYLLABLE BILB");
+-   ("/xeb/xb9/x90", "HANGUL SYLLABLE BILS");
+-   ("/xeb/xb9/x91", "HANGUL SYLLABLE BILT");
+-   ("/xeb/xb9/x92", "HANGUL SYLLABLE BILP");
+-   ("/xeb/xb9/x93", "HANGUL SYLLABLE BILH");
+-   ("/xeb/xb9/x94", "HANGUL SYLLABLE BIM");
+-   ("/xeb/xb9/x95", "HANGUL SYLLABLE BIB");
+-   ("/xeb/xb9/x96", "HANGUL SYLLABLE BIBS");
+-   ("/xeb/xb9/x97", "HANGUL SYLLABLE BIS");
+-   ("/xeb/xb9/x98", "HANGUL SYLLABLE BISS");
+-   ("/xeb/xb9/x99", "HANGUL SYLLABLE BING");
+-   ("/xeb/xb9/x9a", "HANGUL SYLLABLE BIJ");
+-   ("/xeb/xb9/x9b", "HANGUL SYLLABLE BIC");
+-   ("/xeb/xb9/x9c", "HANGUL SYLLABLE BIK");
+-   ("/xeb/xb9/x9d", "HANGUL SYLLABLE BIT");
+-   ("/xeb/xb9/x9e", "HANGUL SYLLABLE BIP");
+-   ("/xeb/xb9/x9f", "HANGUL SYLLABLE BIH");
+-   ("/xeb/xb9/xa0", "HANGUL SYLLABLE BBA");
+-   ("/xeb/xb9/xa1", "HANGUL SYLLABLE BBAG");
+-   ("/xeb/xb9/xa2", "HANGUL SYLLABLE BBAGG");
+-   ("/xeb/xb9/xa3", "HANGUL SYLLABLE BBAGS");
+-   ("/xeb/xb9/xa4", "HANGUL SYLLABLE BBAN");
+-   ("/xeb/xb9/xa5", "HANGUL SYLLABLE BBANI");
+-   ("/xeb/xb9/xa6", "HANGUL SYLLABLE BBANH");
+-   ("/xeb/xb9/xa7", "HANGUL SYLLABLE BBAD");
+-   ("/xeb/xb9/xa8", "HANGUL SYLLABLE BBAL");
+-   ("/xeb/xb9/xa9", "HANGUL SYLLABLE BBALG");
+-   ("/xeb/xb9/xaa", "HANGUL SYLLABLE BBALM");
+-   ("/xeb/xb9/xab", "HANGUL SYLLABLE BBALB");
+-   ("/xeb/xb9/xac", "HANGUL SYLLABLE BBALS");
+-   ("/xeb/xb9/xad", "HANGUL SYLLABLE BBALT");
+-   ("/xeb/xb9/xae", "HANGUL SYLLABLE BBALP");
+-   ("/xeb/xb9/xaf", "HANGUL SYLLABLE BBALH");
+-   ("/xeb/xb9/xb0", "HANGUL SYLLABLE BBAM");
+-   ("/xeb/xb9/xb1", "HANGUL SYLLABLE BBAB");
+-   ("/xeb/xb9/xb2", "HANGUL SYLLABLE BBABS");
+-   ("/xeb/xb9/xb3", "HANGUL SYLLABLE BBAS");
+-   ("/xeb/xb9/xb4", "HANGUL SYLLABLE BBASS");
+-   ("/xeb/xb9/xb5", "HANGUL SYLLABLE BBANG");
+-   ("/xeb/xb9/xb6", "HANGUL SYLLABLE BBAJ");
+-   ("/xeb/xb9/xb7", "HANGUL SYLLABLE BBAC");
+-   ("/xeb/xb9/xb8", "HANGUL SYLLABLE BBAK");
+-   ("/xeb/xb9/xb9", "HANGUL SYLLABLE BBAT");
+-   ("/xeb/xb9/xba", "HANGUL SYLLABLE BBAP");
+-   ("/xeb/xb9/xbb", "HANGUL SYLLABLE BBAH");
+-   ("/xeb/xb9/xbc", "HANGUL SYLLABLE BBAE");
+-   ("/xeb/xb9/xbd", "HANGUL SYLLABLE BBAEG");
+-   ("/xeb/xb9/xbe", "HANGUL SYLLABLE BBAEGG");
+-   ("/xeb/xb9/xbf", "HANGUL SYLLABLE BBAEGS");
+-   ("/xeb/xba/x80", "HANGUL SYLLABLE BBAEN");
+-   ("/xeb/xba/x81", "HANGUL SYLLABLE BBAENI");
+-   ("/xeb/xba/x82", "HANGUL SYLLABLE BBAENH");
+-   ("/xeb/xba/x83", "HANGUL SYLLABLE BBAED");
+-   ("/xeb/xba/x84", "HANGUL SYLLABLE BBAEL");
+-   ("/xeb/xba/x85", "HANGUL SYLLABLE BBAELG");
+-   ("/xeb/xba/x86", "HANGUL SYLLABLE BBAELM");
+-   ("/xeb/xba/x87", "HANGUL SYLLABLE BBAELB");
+-   ("/xeb/xba/x88", "HANGUL SYLLABLE BBAELS");
+-   ("/xeb/xba/x89", "HANGUL SYLLABLE BBAELT");
+-   ("/xeb/xba/x8a", "HANGUL SYLLABLE BBAELP");
+-   ("/xeb/xba/x8b", "HANGUL SYLLABLE BBAELH");
+-   ("/xeb/xba/x8c", "HANGUL SYLLABLE BBAEM");
+-   ("/xeb/xba/x8d", "HANGUL SYLLABLE BBAEB");
+-   ("/xeb/xba/x8e", "HANGUL SYLLABLE BBAEBS");
+-   ("/xeb/xba/x8f", "HANGUL SYLLABLE BBAES");
+-   ("/xeb/xba/x90", "HANGUL SYLLABLE BBAESS");
+-   ("/xeb/xba/x91", "HANGUL SYLLABLE BBAENG");
+-   ("/xeb/xba/x92", "HANGUL SYLLABLE BBAEJ");
+-   ("/xeb/xba/x93", "HANGUL SYLLABLE BBAEC");
+-   ("/xeb/xba/x94", "HANGUL SYLLABLE BBAEK");
+-   ("/xeb/xba/x95", "HANGUL SYLLABLE BBAET");
+-   ("/xeb/xba/x96", "HANGUL SYLLABLE BBAEP");
+-   ("/xeb/xba/x97", "HANGUL SYLLABLE BBAEH");
+-   ("/xeb/xba/x98", "HANGUL SYLLABLE BBYA");
+-   ("/xeb/xba/x99", "HANGUL SYLLABLE BBYAG");
+-   ("/xeb/xba/x9a", "HANGUL SYLLABLE BBYAGG");
+-   ("/xeb/xba/x9b", "HANGUL SYLLABLE BBYAGS");
+-   ("/xeb/xba/x9c", "HANGUL SYLLABLE BBYAN");
+-   ("/xeb/xba/x9d", "HANGUL SYLLABLE BBYANI");
+-   ("/xeb/xba/x9e", "HANGUL SYLLABLE BBYANH");
+-   ("/xeb/xba/x9f", "HANGUL SYLLABLE BBYAD");
+-   ("/xeb/xba/xa0", "HANGUL SYLLABLE BBYAL");
+-   ("/xeb/xba/xa1", "HANGUL SYLLABLE BBYALG");
+-   ("/xeb/xba/xa2", "HANGUL SYLLABLE BBYALM");
+-   ("/xeb/xba/xa3", "HANGUL SYLLABLE BBYALB");
+-   ("/xeb/xba/xa4", "HANGUL SYLLABLE BBYALS");
+-   ("/xeb/xba/xa5", "HANGUL SYLLABLE BBYALT");
+-   ("/xeb/xba/xa6", "HANGUL SYLLABLE BBYALP");
+-   ("/xeb/xba/xa7", "HANGUL SYLLABLE BBYALH");
+-   ("/xeb/xba/xa8", "HANGUL SYLLABLE BBYAM");
+-   ("/xeb/xba/xa9", "HANGUL SYLLABLE BBYAB");
+-   ("/xeb/xba/xaa", "HANGUL SYLLABLE BBYABS");
+-   ("/xeb/xba/xab", "HANGUL SYLLABLE BBYAS");
+-   ("/xeb/xba/xac", "HANGUL SYLLABLE BBYASS");
+-   ("/xeb/xba/xad", "HANGUL SYLLABLE BBYANG");
+-   ("/xeb/xba/xae", "HANGUL SYLLABLE BBYAJ");
+-   ("/xeb/xba/xaf", "HANGUL SYLLABLE BBYAC");
+-   ("/xeb/xba/xb0", "HANGUL SYLLABLE BBYAK");
+-   ("/xeb/xba/xb1", "HANGUL SYLLABLE BBYAT");
+-   ("/xeb/xba/xb2", "HANGUL SYLLABLE BBYAP");
+-   ("/xeb/xba/xb3", "HANGUL SYLLABLE BBYAH");
+-   ("/xeb/xba/xb4", "HANGUL SYLLABLE BBYAE");
+-   ("/xeb/xba/xb5", "HANGUL SYLLABLE BBYAEG");
+-   ("/xeb/xba/xb6", "HANGUL SYLLABLE BBYAEGG");
+-   ("/xeb/xba/xb7", "HANGUL SYLLABLE BBYAEGS");
+-   ("/xeb/xba/xb8", "HANGUL SYLLABLE BBYAEN");
+-   ("/xeb/xba/xb9", "HANGUL SYLLABLE BBYAENI");
+-   ("/xeb/xba/xba", "HANGUL SYLLABLE BBYAENH");
+-   ("/xeb/xba/xbb", "HANGUL SYLLABLE BBYAED");
+-   ("/xeb/xba/xbc", "HANGUL SYLLABLE BBYAEL");
+-   ("/xeb/xba/xbd", "HANGUL SYLLABLE BBYAELG");
+-   ("/xeb/xba/xbe", "HANGUL SYLLABLE BBYAELM");
+-   ("/xeb/xba/xbf", "HANGUL SYLLABLE BBYAELB");
+-   ("/xeb/xbb/x80", "HANGUL SYLLABLE BBYAELS");
+-   ("/xeb/xbb/x81", "HANGUL SYLLABLE BBYAELT");
+-   ("/xeb/xbb/x82", "HANGUL SYLLABLE BBYAELP");
+-   ("/xeb/xbb/x83", "HANGUL SYLLABLE BBYAELH");
+-   ("/xeb/xbb/x84", "HANGUL SYLLABLE BBYAEM");
+-   ("/xeb/xbb/x85", "HANGUL SYLLABLE BBYAEB");
+-   ("/xeb/xbb/x86", "HANGUL SYLLABLE BBYAEBS");
+-   ("/xeb/xbb/x87", "HANGUL SYLLABLE BBYAES");
+-   ("/xeb/xbb/x88", "HANGUL SYLLABLE BBYAESS");
+-   ("/xeb/xbb/x89", "HANGUL SYLLABLE BBYAENG");
+-   ("/xeb/xbb/x8a", "HANGUL SYLLABLE BBYAEJ");
+-   ("/xeb/xbb/x8b", "HANGUL SYLLABLE BBYAEC");
+-   ("/xeb/xbb/x8c", "HANGUL SYLLABLE BBYAEK");
+-   ("/xeb/xbb/x8d", "HANGUL SYLLABLE BBYAET");
+-   ("/xeb/xbb/x8e", "HANGUL SYLLABLE BBYAEP");
+-   ("/xeb/xbb/x8f", "HANGUL SYLLABLE BBYAEH");
+-   ("/xeb/xbb/x90", "HANGUL SYLLABLE BBEO");
+-   ("/xeb/xbb/x91", "HANGUL SYLLABLE BBEOG");
+-   ("/xeb/xbb/x92", "HANGUL SYLLABLE BBEOGG");
+-   ("/xeb/xbb/x93", "HANGUL SYLLABLE BBEOGS");
+-   ("/xeb/xbb/x94", "HANGUL SYLLABLE BBEON");
+-   ("/xeb/xbb/x95", "HANGUL SYLLABLE BBEONI");
+-   ("/xeb/xbb/x96", "HANGUL SYLLABLE BBEONH");
+-   ("/xeb/xbb/x97", "HANGUL SYLLABLE BBEOD");
+-   ("/xeb/xbb/x98", "HANGUL SYLLABLE BBEOL");
+-   ("/xeb/xbb/x99", "HANGUL SYLLABLE BBEOLG");
+-   ("/xeb/xbb/x9a", "HANGUL SYLLABLE BBEOLM");
+-   ("/xeb/xbb/x9b", "HANGUL SYLLABLE BBEOLB");
+-   ("/xeb/xbb/x9c", "HANGUL SYLLABLE BBEOLS");
+-   ("/xeb/xbb/x9d", "HANGUL SYLLABLE BBEOLT");
+-   ("/xeb/xbb/x9e", "HANGUL SYLLABLE BBEOLP");
+-   ("/xeb/xbb/x9f", "HANGUL SYLLABLE BBEOLH");
+-   ("/xeb/xbb/xa0", "HANGUL SYLLABLE BBEOM");
+-   ("/xeb/xbb/xa1", "HANGUL SYLLABLE BBEOB");
+-   ("/xeb/xbb/xa2", "HANGUL SYLLABLE BBEOBS");
+-   ("/xeb/xbb/xa3", "HANGUL SYLLABLE BBEOS");
+-   ("/xeb/xbb/xa4", "HANGUL SYLLABLE BBEOSS");
+-   ("/xeb/xbb/xa5", "HANGUL SYLLABLE BBEONG");
+-   ("/xeb/xbb/xa6", "HANGUL SYLLABLE BBEOJ");
+-   ("/xeb/xbb/xa7", "HANGUL SYLLABLE BBEOC");
+-   ("/xeb/xbb/xa8", "HANGUL SYLLABLE BBEOK");
+-   ("/xeb/xbb/xa9", "HANGUL SYLLABLE BBEOT");
+-   ("/xeb/xbb/xaa", "HANGUL SYLLABLE BBEOP");
+-   ("/xeb/xbb/xab", "HANGUL SYLLABLE BBEOH");
+-   ("/xeb/xbb/xac", "HANGUL SYLLABLE BBE");
+-   ("/xeb/xbb/xad", "HANGUL SYLLABLE BBEG");
+-   ("/xeb/xbb/xae", "HANGUL SYLLABLE BBEGG");
+-   ("/xeb/xbb/xaf", "HANGUL SYLLABLE BBEGS");
+-   ("/xeb/xbb/xb0", "HANGUL SYLLABLE BBEN");
+-   ("/xeb/xbb/xb1", "HANGUL SYLLABLE BBENI");
+-   ("/xeb/xbb/xb2", "HANGUL SYLLABLE BBENH");
+-   ("/xeb/xbb/xb3", "HANGUL SYLLABLE BBED");
+-   ("/xeb/xbb/xb4", "HANGUL SYLLABLE BBEL");
+-   ("/xeb/xbb/xb5", "HANGUL SYLLABLE BBELG");
+-   ("/xeb/xbb/xb6", "HANGUL SYLLABLE BBELM");
+-   ("/xeb/xbb/xb7", "HANGUL SYLLABLE BBELB");
+-   ("/xeb/xbb/xb8", "HANGUL SYLLABLE BBELS");
+-   ("/xeb/xbb/xb9", "HANGUL SYLLABLE BBELT");
+-   ("/xeb/xbb/xba", "HANGUL SYLLABLE BBELP");
+-   ("/xeb/xbb/xbb", "HANGUL SYLLABLE BBELH");
+-   ("/xeb/xbb/xbc", "HANGUL SYLLABLE BBEM");
+-   ("/xeb/xbb/xbd", "HANGUL SYLLABLE BBEB");
+-   ("/xeb/xbb/xbe", "HANGUL SYLLABLE BBEBS");
+-   ("/xeb/xbb/xbf", "HANGUL SYLLABLE BBES");
+-   ("/xeb/xbc/x80", "HANGUL SYLLABLE BBESS");
+-   ("/xeb/xbc/x81", "HANGUL SYLLABLE BBENG");
+-   ("/xeb/xbc/x82", "HANGUL SYLLABLE BBEJ");
+-   ("/xeb/xbc/x83", "HANGUL SYLLABLE BBEC");
+-   ("/xeb/xbc/x84", "HANGUL SYLLABLE BBEK");
+-   ("/xeb/xbc/x85", "HANGUL SYLLABLE BBET");
+-   ("/xeb/xbc/x86", "HANGUL SYLLABLE BBEP");
+-   ("/xeb/xbc/x87", "HANGUL SYLLABLE BBEH");
+-   ("/xeb/xbc/x88", "HANGUL SYLLABLE BBYEO");
+-   ("/xeb/xbc/x89", "HANGUL SYLLABLE BBYEOG");
+-   ("/xeb/xbc/x8a", "HANGUL SYLLABLE BBYEOGG");
+-   ("/xeb/xbc/x8b", "HANGUL SYLLABLE BBYEOGS");
+-   ("/xeb/xbc/x8c", "HANGUL SYLLABLE BBYEON");
+-   ("/xeb/xbc/x8d", "HANGUL SYLLABLE BBYEONI");
+-   ("/xeb/xbc/x8e", "HANGUL SYLLABLE BBYEONH");
+-   ("/xeb/xbc/x8f", "HANGUL SYLLABLE BBYEOD");
+-   ("/xeb/xbc/x90", "HANGUL SYLLABLE BBYEOL");
+-   ("/xeb/xbc/x91", "HANGUL SYLLABLE BBYEOLG");
+-   ("/xeb/xbc/x92", "HANGUL SYLLABLE BBYEOLM");
+-   ("/xeb/xbc/x93", "HANGUL SYLLABLE BBYEOLB");
+-   ("/xeb/xbc/x94", "HANGUL SYLLABLE BBYEOLS");
+-   ("/xeb/xbc/x95", "HANGUL SYLLABLE BBYEOLT");
+-   ("/xeb/xbc/x96", "HANGUL SYLLABLE BBYEOLP");
+-   ("/xeb/xbc/x97", "HANGUL SYLLABLE BBYEOLH");
+-   ("/xeb/xbc/x98", "HANGUL SYLLABLE BBYEOM");
+-   ("/xeb/xbc/x99", "HANGUL SYLLABLE BBYEOB");
+-   ("/xeb/xbc/x9a", "HANGUL SYLLABLE BBYEOBS");
+-   ("/xeb/xbc/x9b", "HANGUL SYLLABLE BBYEOS");
+-   ("/xeb/xbc/x9c", "HANGUL SYLLABLE BBYEOSS");
+-   ("/xeb/xbc/x9d", "HANGUL SYLLABLE BBYEONG");
+-   ("/xeb/xbc/x9e", "HANGUL SYLLABLE BBYEOJ");
+-   ("/xeb/xbc/x9f", "HANGUL SYLLABLE BBYEOC");
+-   ("/xeb/xbc/xa0", "HANGUL SYLLABLE BBYEOK");
+-   ("/xeb/xbc/xa1", "HANGUL SYLLABLE BBYEOT");
+-   ("/xeb/xbc/xa2", "HANGUL SYLLABLE BBYEOP");
+-   ("/xeb/xbc/xa3", "HANGUL SYLLABLE BBYEOH");
+-   ("/xeb/xbc/xa4", "HANGUL SYLLABLE BBYE");
+-   ("/xeb/xbc/xa5", "HANGUL SYLLABLE BBYEG");
+-   ("/xeb/xbc/xa6", "HANGUL SYLLABLE BBYEGG");
+-   ("/xeb/xbc/xa7", "HANGUL SYLLABLE BBYEGS");
+-   ("/xeb/xbc/xa8", "HANGUL SYLLABLE BBYEN");
+-   ("/xeb/xbc/xa9", "HANGUL SYLLABLE BBYENI");
+-   ("/xeb/xbc/xaa", "HANGUL SYLLABLE BBYENH");
+-   ("/xeb/xbc/xab", "HANGUL SYLLABLE BBYED");
+-   ("/xeb/xbc/xac", "HANGUL SYLLABLE BBYEL");
+-   ("/xeb/xbc/xad", "HANGUL SYLLABLE BBYELG");
+-   ("/xeb/xbc/xae", "HANGUL SYLLABLE BBYELM");
+-   ("/xeb/xbc/xaf", "HANGUL SYLLABLE BBYELB");
+-   ("/xeb/xbc/xb0", "HANGUL SYLLABLE BBYELS");
+-   ("/xeb/xbc/xb1", "HANGUL SYLLABLE BBYELT");
+-   ("/xeb/xbc/xb2", "HANGUL SYLLABLE BBYELP");
+-   ("/xeb/xbc/xb3", "HANGUL SYLLABLE BBYELH");
+-   ("/xeb/xbc/xb4", "HANGUL SYLLABLE BBYEM");
+-   ("/xeb/xbc/xb5", "HANGUL SYLLABLE BBYEB");
+-   ("/xeb/xbc/xb6", "HANGUL SYLLABLE BBYEBS");
+-   ("/xeb/xbc/xb7", "HANGUL SYLLABLE BBYES");
+-   ("/xeb/xbc/xb8", "HANGUL SYLLABLE BBYESS");
+-   ("/xeb/xbc/xb9", "HANGUL SYLLABLE BBYENG");
+-   ("/xeb/xbc/xba", "HANGUL SYLLABLE BBYEJ");
+-   ("/xeb/xbc/xbb", "HANGUL SYLLABLE BBYEC");
+-   ("/xeb/xbc/xbc", "HANGUL SYLLABLE BBYEK");
+-   ("/xeb/xbc/xbd", "HANGUL SYLLABLE BBYET");
+-   ("/xeb/xbc/xbe", "HANGUL SYLLABLE BBYEP");
+-   ("/xeb/xbc/xbf", "HANGUL SYLLABLE BBYEH");
+-   ("/xeb/xbd/x80", "HANGUL SYLLABLE BBO");
+-   ("/xeb/xbd/x81", "HANGUL SYLLABLE BBOG");
+-   ("/xeb/xbd/x82", "HANGUL SYLLABLE BBOGG");
+-   ("/xeb/xbd/x83", "HANGUL SYLLABLE BBOGS");
+-   ("/xeb/xbd/x84", "HANGUL SYLLABLE BBON");
+-   ("/xeb/xbd/x85", "HANGUL SYLLABLE BBONI");
+-   ("/xeb/xbd/x86", "HANGUL SYLLABLE BBONH");
+-   ("/xeb/xbd/x87", "HANGUL SYLLABLE BBOD");
+-   ("/xeb/xbd/x88", "HANGUL SYLLABLE BBOL");
+-   ("/xeb/xbd/x89", "HANGUL SYLLABLE BBOLG");
+-   ("/xeb/xbd/x8a", "HANGUL SYLLABLE BBOLM");
+-   ("/xeb/xbd/x8b", "HANGUL SYLLABLE BBOLB");
+-   ("/xeb/xbd/x8c", "HANGUL SYLLABLE BBOLS");
+-   ("/xeb/xbd/x8d", "HANGUL SYLLABLE BBOLT");
+-   ("/xeb/xbd/x8e", "HANGUL SYLLABLE BBOLP");
+-   ("/xeb/xbd/x8f", "HANGUL SYLLABLE BBOLH");
+-   ("/xeb/xbd/x90", "HANGUL SYLLABLE BBOM");
+-   ("/xeb/xbd/x91", "HANGUL SYLLABLE BBOB");
+-   ("/xeb/xbd/x92", "HANGUL SYLLABLE BBOBS");
+-   ("/xeb/xbd/x93", "HANGUL SYLLABLE BBOS");
+-   ("/xeb/xbd/x94", "HANGUL SYLLABLE BBOSS");
+-   ("/xeb/xbd/x95", "HANGUL SYLLABLE BBONG");
+-   ("/xeb/xbd/x96", "HANGUL SYLLABLE BBOJ");
+-   ("/xeb/xbd/x97", "HANGUL SYLLABLE BBOC");
+-   ("/xeb/xbd/x98", "HANGUL SYLLABLE BBOK");
+-   ("/xeb/xbd/x99", "HANGUL SYLLABLE BBOT");
+-   ("/xeb/xbd/x9a", "HANGUL SYLLABLE BBOP");
+-   ("/xeb/xbd/x9b", "HANGUL SYLLABLE BBOH");
+-   ("/xeb/xbd/x9c", "HANGUL SYLLABLE BBWA");
+-   ("/xeb/xbd/x9d", "HANGUL SYLLABLE BBWAG");
+-   ("/xeb/xbd/x9e", "HANGUL SYLLABLE BBWAGG");
+-   ("/xeb/xbd/x9f", "HANGUL SYLLABLE BBWAGS");
+-   ("/xeb/xbd/xa0", "HANGUL SYLLABLE BBWAN");
+-   ("/xeb/xbd/xa1", "HANGUL SYLLABLE BBWANI");
+-   ("/xeb/xbd/xa2", "HANGUL SYLLABLE BBWANH");
+-   ("/xeb/xbd/xa3", "HANGUL SYLLABLE BBWAD");
+-   ("/xeb/xbd/xa4", "HANGUL SYLLABLE BBWAL");
+-   ("/xeb/xbd/xa5", "HANGUL SYLLABLE BBWALG");
+-   ("/xeb/xbd/xa6", "HANGUL SYLLABLE BBWALM");
+-   ("/xeb/xbd/xa7", "HANGUL SYLLABLE BBWALB");
+-   ("/xeb/xbd/xa8", "HANGUL SYLLABLE BBWALS");
+-   ("/xeb/xbd/xa9", "HANGUL SYLLABLE BBWALT");
+-   ("/xeb/xbd/xaa", "HANGUL SYLLABLE BBWALP");
+-   ("/xeb/xbd/xab", "HANGUL SYLLABLE BBWALH");
+-   ("/xeb/xbd/xac", "HANGUL SYLLABLE BBWAM");
+-   ("/xeb/xbd/xad", "HANGUL SYLLABLE BBWAB");
+-   ("/xeb/xbd/xae", "HANGUL SYLLABLE BBWABS");
+-   ("/xeb/xbd/xaf", "HANGUL SYLLABLE BBWAS");
+-   ("/xeb/xbd/xb0", "HANGUL SYLLABLE BBWASS");
+-   ("/xeb/xbd/xb1", "HANGUL SYLLABLE BBWANG");
+-   ("/xeb/xbd/xb2", "HANGUL SYLLABLE BBWAJ");
+-   ("/xeb/xbd/xb3", "HANGUL SYLLABLE BBWAC");
+-   ("/xeb/xbd/xb4", "HANGUL SYLLABLE BBWAK");
+-   ("/xeb/xbd/xb5", "HANGUL SYLLABLE BBWAT");
+-   ("/xeb/xbd/xb6", "HANGUL SYLLABLE BBWAP");
+-   ("/xeb/xbd/xb7", "HANGUL SYLLABLE BBWAH");
+-   ("/xeb/xbd/xb8", "HANGUL SYLLABLE BBWAE");
+-   ("/xeb/xbd/xb9", "HANGUL SYLLABLE BBWAEG");
+-   ("/xeb/xbd/xba", "HANGUL SYLLABLE BBWAEGG");
+-   ("/xeb/xbd/xbb", "HANGUL SYLLABLE BBWAEGS");
+-   ("/xeb/xbd/xbc", "HANGUL SYLLABLE BBWAEN");
+-   ("/xeb/xbd/xbd", "HANGUL SYLLABLE BBWAENI");
+-   ("/xeb/xbd/xbe", "HANGUL SYLLABLE BBWAENH");
+-   ("/xeb/xbd/xbf", "HANGUL SYLLABLE BBWAED");
+-   ("/xeb/xbe/x80", "HANGUL SYLLABLE BBWAEL");
+-   ("/xeb/xbe/x81", "HANGUL SYLLABLE BBWAELG");
+-   ("/xeb/xbe/x82", "HANGUL SYLLABLE BBWAELM");
+-   ("/xeb/xbe/x83", "HANGUL SYLLABLE BBWAELB");
+-   ("/xeb/xbe/x84", "HANGUL SYLLABLE BBWAELS");
+-   ("/xeb/xbe/x85", "HANGUL SYLLABLE BBWAELT");
+-   ("/xeb/xbe/x86", "HANGUL SYLLABLE BBWAELP");
+-   ("/xeb/xbe/x87", "HANGUL SYLLABLE BBWAELH");
+-   ("/xeb/xbe/x88", "HANGUL SYLLABLE BBWAEM");
+-   ("/xeb/xbe/x89", "HANGUL SYLLABLE BBWAEB");
+-   ("/xeb/xbe/x8a", "HANGUL SYLLABLE BBWAEBS");
+-   ("/xeb/xbe/x8b", "HANGUL SYLLABLE BBWAES");
+-   ("/xeb/xbe/x8c", "HANGUL SYLLABLE BBWAESS");
+-   ("/xeb/xbe/x8d", "HANGUL SYLLABLE BBWAENG");
+-   ("/xeb/xbe/x8e", "HANGUL SYLLABLE BBWAEJ");
+-   ("/xeb/xbe/x8f", "HANGUL SYLLABLE BBWAEC");
+-   ("/xeb/xbe/x90", "HANGUL SYLLABLE BBWAEK");
+-   ("/xeb/xbe/x91", "HANGUL SYLLABLE BBWAET");
+-   ("/xeb/xbe/x92", "HANGUL SYLLABLE BBWAEP");
+-   ("/xeb/xbe/x93", "HANGUL SYLLABLE BBWAEH");
+-   ("/xeb/xbe/x94", "HANGUL SYLLABLE BBOE");
+-   ("/xeb/xbe/x95", "HANGUL SYLLABLE BBOEG");
+-   ("/xeb/xbe/x96", "HANGUL SYLLABLE BBOEGG");
+-   ("/xeb/xbe/x97", "HANGUL SYLLABLE BBOEGS");
+-   ("/xeb/xbe/x98", "HANGUL SYLLABLE BBOEN");
+-   ("/xeb/xbe/x99", "HANGUL SYLLABLE BBOENI");
+-   ("/xeb/xbe/x9a", "HANGUL SYLLABLE BBOENH");
+-   ("/xeb/xbe/x9b", "HANGUL SYLLABLE BBOED");
+-   ("/xeb/xbe/x9c", "HANGUL SYLLABLE BBOEL");
+-   ("/xeb/xbe/x9d", "HANGUL SYLLABLE BBOELG");
+-   ("/xeb/xbe/x9e", "HANGUL SYLLABLE BBOELM");
+-   ("/xeb/xbe/x9f", "HANGUL SYLLABLE BBOELB");
+-   ("/xeb/xbe/xa0", "HANGUL SYLLABLE BBOELS");
+-   ("/xeb/xbe/xa1", "HANGUL SYLLABLE BBOELT");
+-   ("/xeb/xbe/xa2", "HANGUL SYLLABLE BBOELP");
+-   ("/xeb/xbe/xa3", "HANGUL SYLLABLE BBOELH");
+-   ("/xeb/xbe/xa4", "HANGUL SYLLABLE BBOEM");
+-   ("/xeb/xbe/xa5", "HANGUL SYLLABLE BBOEB");
+-   ("/xeb/xbe/xa6", "HANGUL SYLLABLE BBOEBS");
+-   ("/xeb/xbe/xa7", "HANGUL SYLLABLE BBOES");
+-   ("/xeb/xbe/xa8", "HANGUL SYLLABLE BBOESS");
+-   ("/xeb/xbe/xa9", "HANGUL SYLLABLE BBOENG");
+-   ("/xeb/xbe/xaa", "HANGUL SYLLABLE BBOEJ");
+-   ("/xeb/xbe/xab", "HANGUL SYLLABLE BBOEC");
+-   ("/xeb/xbe/xac", "HANGUL SYLLABLE BBOEK");
+-   ("/xeb/xbe/xad", "HANGUL SYLLABLE BBOET");
+-   ("/xeb/xbe/xae", "HANGUL SYLLABLE BBOEP");
+-   ("/xeb/xbe/xaf", "HANGUL SYLLABLE BBOEH");
+-   ("/xeb/xbe/xb0", "HANGUL SYLLABLE BBYO");
+-   ("/xeb/xbe/xb1", "HANGUL SYLLABLE BBYOG");
+-   ("/xeb/xbe/xb2", "HANGUL SYLLABLE BBYOGG");
+-   ("/xeb/xbe/xb3", "HANGUL SYLLABLE BBYOGS");
+-   ("/xeb/xbe/xb4", "HANGUL SYLLABLE BBYON");
+-   ("/xeb/xbe/xb5", "HANGUL SYLLABLE BBYONI");
+-   ("/xeb/xbe/xb6", "HANGUL SYLLABLE BBYONH");
+-   ("/xeb/xbe/xb7", "HANGUL SYLLABLE BBYOD");
+-   ("/xeb/xbe/xb8", "HANGUL SYLLABLE BBYOL");
+-   ("/xeb/xbe/xb9", "HANGUL SYLLABLE BBYOLG");
+-   ("/xeb/xbe/xba", "HANGUL SYLLABLE BBYOLM");
+-   ("/xeb/xbe/xbb", "HANGUL SYLLABLE BBYOLB");
+-   ("/xeb/xbe/xbc", "HANGUL SYLLABLE BBYOLS");
+-   ("/xeb/xbe/xbd", "HANGUL SYLLABLE BBYOLT");
+-   ("/xeb/xbe/xbe", "HANGUL SYLLABLE BBYOLP");
+-   ("/xeb/xbe/xbf", "HANGUL SYLLABLE BBYOLH");
+-   ("/xeb/xbf/x80", "HANGUL SYLLABLE BBYOM");
+-   ("/xeb/xbf/x81", "HANGUL SYLLABLE BBYOB");
+-   ("/xeb/xbf/x82", "HANGUL SYLLABLE BBYOBS");
+-   ("/xeb/xbf/x83", "HANGUL SYLLABLE BBYOS");
+-   ("/xeb/xbf/x84", "HANGUL SYLLABLE BBYOSS");
+-   ("/xeb/xbf/x85", "HANGUL SYLLABLE BBYONG");
+-   ("/xeb/xbf/x86", "HANGUL SYLLABLE BBYOJ");
+-   ("/xeb/xbf/x87", "HANGUL SYLLABLE BBYOC");
+-   ("/xeb/xbf/x88", "HANGUL SYLLABLE BBYOK");
+-   ("/xeb/xbf/x89", "HANGUL SYLLABLE BBYOT");
+-   ("/xeb/xbf/x8a", "HANGUL SYLLABLE BBYOP");
+-   ("/xeb/xbf/x8b", "HANGUL SYLLABLE BBYOH");
+-   ("/xeb/xbf/x8c", "HANGUL SYLLABLE BBU");
+-   ("/xeb/xbf/x8d", "HANGUL SYLLABLE BBUG");
+-   ("/xeb/xbf/x8e", "HANGUL SYLLABLE BBUGG");
+-   ("/xeb/xbf/x8f", "HANGUL SYLLABLE BBUGS");
+-   ("/xeb/xbf/x90", "HANGUL SYLLABLE BBUN");
+-   ("/xeb/xbf/x91", "HANGUL SYLLABLE BBUNI");
+-   ("/xeb/xbf/x92", "HANGUL SYLLABLE BBUNH");
+-   ("/xeb/xbf/x93", "HANGUL SYLLABLE BBUD");
+-   ("/xeb/xbf/x94", "HANGUL SYLLABLE BBUL");
+-   ("/xeb/xbf/x95", "HANGUL SYLLABLE BBULG");
+-   ("/xeb/xbf/x96", "HANGUL SYLLABLE BBULM");
+-   ("/xeb/xbf/x97", "HANGUL SYLLABLE BBULB");
+-   ("/xeb/xbf/x98", "HANGUL SYLLABLE BBULS");
+-   ("/xeb/xbf/x99", "HANGUL SYLLABLE BBULT");
+-   ("/xeb/xbf/x9a", "HANGUL SYLLABLE BBULP");
+-   ("/xeb/xbf/x9b", "HANGUL SYLLABLE BBULH");
+-   ("/xeb/xbf/x9c", "HANGUL SYLLABLE BBUM");
+-   ("/xeb/xbf/x9d", "HANGUL SYLLABLE BBUB");
+-   ("/xeb/xbf/x9e", "HANGUL SYLLABLE BBUBS");
+-   ("/xeb/xbf/x9f", "HANGUL SYLLABLE BBUS");
+-   ("/xeb/xbf/xa0", "HANGUL SYLLABLE BBUSS");
+-   ("/xeb/xbf/xa1", "HANGUL SYLLABLE BBUNG");
+-   ("/xeb/xbf/xa2", "HANGUL SYLLABLE BBUJ");
+-   ("/xeb/xbf/xa3", "HANGUL SYLLABLE BBUC");
+-   ("/xeb/xbf/xa4", "HANGUL SYLLABLE BBUK");
+-   ("/xeb/xbf/xa5", "HANGUL SYLLABLE BBUT");
+-   ("/xeb/xbf/xa6", "HANGUL SYLLABLE BBUP");
+-   ("/xeb/xbf/xa7", "HANGUL SYLLABLE BBUH");
+-   ("/xeb/xbf/xa8", "HANGUL SYLLABLE BBWEO");
+-   ("/xeb/xbf/xa9", "HANGUL SYLLABLE BBWEOG");
+-   ("/xeb/xbf/xaa", "HANGUL SYLLABLE BBWEOGG");
+-   ("/xeb/xbf/xab", "HANGUL SYLLABLE BBWEOGS");
+-   ("/xeb/xbf/xac", "HANGUL SYLLABLE BBWEON");
+-   ("/xeb/xbf/xad", "HANGUL SYLLABLE BBWEONI");
+-   ("/xeb/xbf/xae", "HANGUL SYLLABLE BBWEONH");
+-   ("/xeb/xbf/xaf", "HANGUL SYLLABLE BBWEOD");
+-   ("/xeb/xbf/xb0", "HANGUL SYLLABLE BBWEOL");
+-   ("/xeb/xbf/xb1", "HANGUL SYLLABLE BBWEOLG");
+-   ("/xeb/xbf/xb2", "HANGUL SYLLABLE BBWEOLM");
+-   ("/xeb/xbf/xb3", "HANGUL SYLLABLE BBWEOLB");
+-   ("/xeb/xbf/xb4", "HANGUL SYLLABLE BBWEOLS");
+-   ("/xeb/xbf/xb5", "HANGUL SYLLABLE BBWEOLT");
+-   ("/xeb/xbf/xb6", "HANGUL SYLLABLE BBWEOLP");
+-   ("/xeb/xbf/xb7", "HANGUL SYLLABLE BBWEOLH");
+-   ("/xeb/xbf/xb8", "HANGUL SYLLABLE BBWEOM");
+-   ("/xeb/xbf/xb9", "HANGUL SYLLABLE BBWEOB");
+-   ("/xeb/xbf/xba", "HANGUL SYLLABLE BBWEOBS");
+-   ("/xeb/xbf/xbb", "HANGUL SYLLABLE BBWEOS");
+-   ("/xeb/xbf/xbc", "HANGUL SYLLABLE BBWEOSS");
+-   ("/xeb/xbf/xbd", "HANGUL SYLLABLE BBWEONG");
+-   ("/xeb/xbf/xbe", "HANGUL SYLLABLE BBWEOJ");
+-   ("/xeb/xbf/xbf", "HANGUL SYLLABLE BBWEOC");
+-   ("/xec/x80/x80", "HANGUL SYLLABLE BBWEOK");
+-   ("/xec/x80/x81", "HANGUL SYLLABLE BBWEOT");
+-   ("/xec/x80/x82", "HANGUL SYLLABLE BBWEOP");
+-   ("/xec/x80/x83", "HANGUL SYLLABLE BBWEOH");
+-   ("/xec/x80/x84", "HANGUL SYLLABLE BBWE");
+-   ("/xec/x80/x85", "HANGUL SYLLABLE BBWEG");
+-   ("/xec/x80/x86", "HANGUL SYLLABLE BBWEGG");
+-   ("/xec/x80/x87", "HANGUL SYLLABLE BBWEGS");
+-   ("/xec/x80/x88", "HANGUL SYLLABLE BBWEN");
+-   ("/xec/x80/x89", "HANGUL SYLLABLE BBWENI");
+-   ("/xec/x80/x8a", "HANGUL SYLLABLE BBWENH");
+-   ("/xec/x80/x8b", "HANGUL SYLLABLE BBWED");
+-   ("/xec/x80/x8c", "HANGUL SYLLABLE BBWEL");
+-   ("/xec/x80/x8d", "HANGUL SYLLABLE BBWELG");
+-   ("/xec/x80/x8e", "HANGUL SYLLABLE BBWELM");
+-   ("/xec/x80/x8f", "HANGUL SYLLABLE BBWELB");
+-   ("/xec/x80/x90", "HANGUL SYLLABLE BBWELS");
+-   ("/xec/x80/x91", "HANGUL SYLLABLE BBWELT");
+-   ("/xec/x80/x92", "HANGUL SYLLABLE BBWELP");
+-   ("/xec/x80/x93", "HANGUL SYLLABLE BBWELH");
+-   ("/xec/x80/x94", "HANGUL SYLLABLE BBWEM");
+-   ("/xec/x80/x95", "HANGUL SYLLABLE BBWEB");
+-   ("/xec/x80/x96", "HANGUL SYLLABLE BBWEBS");
+-   ("/xec/x80/x97", "HANGUL SYLLABLE BBWES");
+-   ("/xec/x80/x98", "HANGUL SYLLABLE BBWESS");
+-   ("/xec/x80/x99", "HANGUL SYLLABLE BBWENG");
+-   ("/xec/x80/x9a", "HANGUL SYLLABLE BBWEJ");
+-   ("/xec/x80/x9b", "HANGUL SYLLABLE BBWEC");
+-   ("/xec/x80/x9c", "HANGUL SYLLABLE BBWEK");
+-   ("/xec/x80/x9d", "HANGUL SYLLABLE BBWET");
+-   ("/xec/x80/x9e", "HANGUL SYLLABLE BBWEP");
+-   ("/xec/x80/x9f", "HANGUL SYLLABLE BBWEH");
+-   ("/xec/x80/xa0", "HANGUL SYLLABLE BBWI");
+-   ("/xec/x80/xa1", "HANGUL SYLLABLE BBWIG");
+-   ("/xec/x80/xa2", "HANGUL SYLLABLE BBWIGG");
+-   ("/xec/x80/xa3", "HANGUL SYLLABLE BBWIGS");
+-   ("/xec/x80/xa4", "HANGUL SYLLABLE BBWIN");
+-   ("/xec/x80/xa5", "HANGUL SYLLABLE BBWINI");
+-   ("/xec/x80/xa6", "HANGUL SYLLABLE BBWINH");
+-   ("/xec/x80/xa7", "HANGUL SYLLABLE BBWID");
+-   ("/xec/x80/xa8", "HANGUL SYLLABLE BBWIL");
+-   ("/xec/x80/xa9", "HANGUL SYLLABLE BBWILG");
+-   ("/xec/x80/xaa", "HANGUL SYLLABLE BBWILM");
+-   ("/xec/x80/xab", "HANGUL SYLLABLE BBWILB");
+-   ("/xec/x80/xac", "HANGUL SYLLABLE BBWILS");
+-   ("/xec/x80/xad", "HANGUL SYLLABLE BBWILT");
+-   ("/xec/x80/xae", "HANGUL SYLLABLE BBWILP");
+-   ("/xec/x80/xaf", "HANGUL SYLLABLE BBWILH");
+-   ("/xec/x80/xb0", "HANGUL SYLLABLE BBWIM");
+-   ("/xec/x80/xb1", "HANGUL SYLLABLE BBWIB");
+-   ("/xec/x80/xb2", "HANGUL SYLLABLE BBWIBS");
+-   ("/xec/x80/xb3", "HANGUL SYLLABLE BBWIS");
+-   ("/xec/x80/xb4", "HANGUL SYLLABLE BBWISS");
+-   ("/xec/x80/xb5", "HANGUL SYLLABLE BBWING");
+-   ("/xec/x80/xb6", "HANGUL SYLLABLE BBWIJ");
+-   ("/xec/x80/xb7", "HANGUL SYLLABLE BBWIC");
+-   ("/xec/x80/xb8", "HANGUL SYLLABLE BBWIK");
+-   ("/xec/x80/xb9", "HANGUL SYLLABLE BBWIT");
+-   ("/xec/x80/xba", "HANGUL SYLLABLE BBWIP");
+-   ("/xec/x80/xbb", "HANGUL SYLLABLE BBWIH");
+-   ("/xec/x80/xbc", "HANGUL SYLLABLE BBYU");
+-   ("/xec/x80/xbd", "HANGUL SYLLABLE BBYUG");
+-   ("/xec/x80/xbe", "HANGUL SYLLABLE BBYUGG");
+-   ("/xec/x80/xbf", "HANGUL SYLLABLE BBYUGS");
+-   ("/xec/x81/x80", "HANGUL SYLLABLE BBYUN");
+-   ("/xec/x81/x81", "HANGUL SYLLABLE BBYUNI");
+-   ("/xec/x81/x82", "HANGUL SYLLABLE BBYUNH");
+-   ("/xec/x81/x83", "HANGUL SYLLABLE BBYUD");
+-   ("/xec/x81/x84", "HANGUL SYLLABLE BBYUL");
+-   ("/xec/x81/x85", "HANGUL SYLLABLE BBYULG");
+-   ("/xec/x81/x86", "HANGUL SYLLABLE BBYULM");
+-   ("/xec/x81/x87", "HANGUL SYLLABLE BBYULB");
+-   ("/xec/x81/x88", "HANGUL SYLLABLE BBYULS");
+-   ("/xec/x81/x89", "HANGUL SYLLABLE BBYULT");
+-   ("/xec/x81/x8a", "HANGUL SYLLABLE BBYULP");
+-   ("/xec/x81/x8b", "HANGUL SYLLABLE BBYULH");
+-   ("/xec/x81/x8c", "HANGUL SYLLABLE BBYUM");
+-   ("/xec/x81/x8d", "HANGUL SYLLABLE BBYUB");
+-   ("/xec/x81/x8e", "HANGUL SYLLABLE BBYUBS");
+-   ("/xec/x81/x8f", "HANGUL SYLLABLE BBYUS");
+-   ("/xec/x81/x90", "HANGUL SYLLABLE BBYUSS");
+-   ("/xec/x81/x91", "HANGUL SYLLABLE BBYUNG");
+-   ("/xec/x81/x92", "HANGUL SYLLABLE BBYUJ");
+-   ("/xec/x81/x93", "HANGUL SYLLABLE BBYUC");
+-   ("/xec/x81/x94", "HANGUL SYLLABLE BBYUK");
+-   ("/xec/x81/x95", "HANGUL SYLLABLE BBYUT");
+-   ("/xec/x81/x96", "HANGUL SYLLABLE BBYUP");
+-   ("/xec/x81/x97", "HANGUL SYLLABLE BBYUH");
+-   ("/xec/x81/x98", "HANGUL SYLLABLE BBEU");
+-   ("/xec/x81/x99", "HANGUL SYLLABLE BBEUG");
+-   ("/xec/x81/x9a", "HANGUL SYLLABLE BBEUGG");
+-   ("/xec/x81/x9b", "HANGUL SYLLABLE BBEUGS");
+-   ("/xec/x81/x9c", "HANGUL SYLLABLE BBEUN");
+-   ("/xec/x81/x9d", "HANGUL SYLLABLE BBEUNI");
+-   ("/xec/x81/x9e", "HANGUL SYLLABLE BBEUNH");
+-   ("/xec/x81/x9f", "HANGUL SYLLABLE BBEUD");
+-   ("/xec/x81/xa0", "HANGUL SYLLABLE BBEUL");
+-   ("/xec/x81/xa1", "HANGUL SYLLABLE BBEULG");
+-   ("/xec/x81/xa2", "HANGUL SYLLABLE BBEULM");
+-   ("/xec/x81/xa3", "HANGUL SYLLABLE BBEULB");
+-   ("/xec/x81/xa4", "HANGUL SYLLABLE BBEULS");
+-   ("/xec/x81/xa5", "HANGUL SYLLABLE BBEULT");
+-   ("/xec/x81/xa6", "HANGUL SYLLABLE BBEULP");
+-   ("/xec/x81/xa7", "HANGUL SYLLABLE BBEULH");
+-   ("/xec/x81/xa8", "HANGUL SYLLABLE BBEUM");
+-   ("/xec/x81/xa9", "HANGUL SYLLABLE BBEUB");
+-   ("/xec/x81/xaa", "HANGUL SYLLABLE BBEUBS");
+-   ("/xec/x81/xab", "HANGUL SYLLABLE BBEUS");
+-   ("/xec/x81/xac", "HANGUL SYLLABLE BBEUSS");
+-   ("/xec/x81/xad", "HANGUL SYLLABLE BBEUNG");
+-   ("/xec/x81/xae", "HANGUL SYLLABLE BBEUJ");
+-   ("/xec/x81/xaf", "HANGUL SYLLABLE BBEUC");
+-   ("/xec/x81/xb0", "HANGUL SYLLABLE BBEUK");
+-   ("/xec/x81/xb1", "HANGUL SYLLABLE BBEUT");
+-   ("/xec/x81/xb2", "HANGUL SYLLABLE BBEUP");
+-   ("/xec/x81/xb3", "HANGUL SYLLABLE BBEUH");
+-   ("/xec/x81/xb4", "HANGUL SYLLABLE BBYI");
+-   ("/xec/x81/xb5", "HANGUL SYLLABLE BBYIG");
+-   ("/xec/x81/xb6", "HANGUL SYLLABLE BBYIGG");
+-   ("/xec/x81/xb7", "HANGUL SYLLABLE BBYIGS");
+-   ("/xec/x81/xb8", "HANGUL SYLLABLE BBYIN");
+-   ("/xec/x81/xb9", "HANGUL SYLLABLE BBYINI");
+-   ("/xec/x81/xba", "HANGUL SYLLABLE BBYINH");
+-   ("/xec/x81/xbb", "HANGUL SYLLABLE BBYID");
+-   ("/xec/x81/xbc", "HANGUL SYLLABLE BBYIL");
+-   ("/xec/x81/xbd", "HANGUL SYLLABLE BBYILG");
+-   ("/xec/x81/xbe", "HANGUL SYLLABLE BBYILM");
+-   ("/xec/x81/xbf", "HANGUL SYLLABLE BBYILB");
+-   ("/xec/x82/x80", "HANGUL SYLLABLE BBYILS");
+-   ("/xec/x82/x81", "HANGUL SYLLABLE BBYILT");
+-   ("/xec/x82/x82", "HANGUL SYLLABLE BBYILP");
+-   ("/xec/x82/x83", "HANGUL SYLLABLE BBYILH");
+-   ("/xec/x82/x84", "HANGUL SYLLABLE BBYIM");
+-   ("/xec/x82/x85", "HANGUL SYLLABLE BBYIB");
+-   ("/xec/x82/x86", "HANGUL SYLLABLE BBYIBS");
+-   ("/xec/x82/x87", "HANGUL SYLLABLE BBYIS");
+-   ("/xec/x82/x88", "HANGUL SYLLABLE BBYISS");
+-   ("/xec/x82/x89", "HANGUL SYLLABLE BBYING");
+-   ("/xec/x82/x8a", "HANGUL SYLLABLE BBYIJ");
+-   ("/xec/x82/x8b", "HANGUL SYLLABLE BBYIC");
+-   ("/xec/x82/x8c", "HANGUL SYLLABLE BBYIK");
+-   ("/xec/x82/x8d", "HANGUL SYLLABLE BBYIT");
+-   ("/xec/x82/x8e", "HANGUL SYLLABLE BBYIP");
+-   ("/xec/x82/x8f", "HANGUL SYLLABLE BBYIH");
+-   ("/xec/x82/x90", "HANGUL SYLLABLE BBI");
+-   ("/xec/x82/x91", "HANGUL SYLLABLE BBIG");
+-   ("/xec/x82/x92", "HANGUL SYLLABLE BBIGG");
+-   ("/xec/x82/x93", "HANGUL SYLLABLE BBIGS");
+-   ("/xec/x82/x94", "HANGUL SYLLABLE BBIN");
+-   ("/xec/x82/x95", "HANGUL SYLLABLE BBINI");
+-   ("/xec/x82/x96", "HANGUL SYLLABLE BBINH");
+-   ("/xec/x82/x97", "HANGUL SYLLABLE BBID");
+-   ("/xec/x82/x98", "HANGUL SYLLABLE BBIL");
+-   ("/xec/x82/x99", "HANGUL SYLLABLE BBILG");
+-   ("/xec/x82/x9a", "HANGUL SYLLABLE BBILM");
+-   ("/xec/x82/x9b", "HANGUL SYLLABLE BBILB");
+-   ("/xec/x82/x9c", "HANGUL SYLLABLE BBILS");
+-   ("/xec/x82/x9d", "HANGUL SYLLABLE BBILT");
+-   ("/xec/x82/x9e", "HANGUL SYLLABLE BBILP");
+-   ("/xec/x82/x9f", "HANGUL SYLLABLE BBILH");
+-   ("/xec/x82/xa0", "HANGUL SYLLABLE BBIM");
+-   ("/xec/x82/xa1", "HANGUL SYLLABLE BBIB");
+-   ("/xec/x82/xa2", "HANGUL SYLLABLE BBIBS");
+-   ("/xec/x82/xa3", "HANGUL SYLLABLE BBIS");
+-   ("/xec/x82/xa4", "HANGUL SYLLABLE BBISS");
+-   ("/xec/x82/xa5", "HANGUL SYLLABLE BBING");
+-   ("/xec/x82/xa6", "HANGUL SYLLABLE BBIJ");
+-   ("/xec/x82/xa7", "HANGUL SYLLABLE BBIC");
+-   ("/xec/x82/xa8", "HANGUL SYLLABLE BBIK");
+-   ("/xec/x82/xa9", "HANGUL SYLLABLE BBIT");
+-   ("/xec/x82/xaa", "HANGUL SYLLABLE BBIP");
+-   ("/xec/x82/xab", "HANGUL SYLLABLE BBIH");
+-   ("/xec/x82/xac", "HANGUL SYLLABLE SA");
+-   ("/xec/x82/xad", "HANGUL SYLLABLE SAG");
+-   ("/xec/x82/xae", "HANGUL SYLLABLE SAGG");
+-   ("/xec/x82/xaf", "HANGUL SYLLABLE SAGS");
+-   ("/xec/x82/xb0", "HANGUL SYLLABLE SAN");
+-   ("/xec/x82/xb1", "HANGUL SYLLABLE SANI");
+-   ("/xec/x82/xb2", "HANGUL SYLLABLE SANH");
+-   ("/xec/x82/xb3", "HANGUL SYLLABLE SAD");
+-   ("/xec/x82/xb4", "HANGUL SYLLABLE SAL");
+-   ("/xec/x82/xb5", "HANGUL SYLLABLE SALG");
+-   ("/xec/x82/xb6", "HANGUL SYLLABLE SALM");
+-   ("/xec/x82/xb7", "HANGUL SYLLABLE SALB");
+-   ("/xec/x82/xb8", "HANGUL SYLLABLE SALS");
+-   ("/xec/x82/xb9", "HANGUL SYLLABLE SALT");
+-   ("/xec/x82/xba", "HANGUL SYLLABLE SALP");
+-   ("/xec/x82/xbb", "HANGUL SYLLABLE SALH");
+-   ("/xec/x82/xbc", "HANGUL SYLLABLE SAM");
+-   ("/xec/x82/xbd", "HANGUL SYLLABLE SAB");
+-   ("/xec/x82/xbe", "HANGUL SYLLABLE SABS");
+-   ("/xec/x82/xbf", "HANGUL SYLLABLE SAS");
+-   ("/xec/x83/x80", "HANGUL SYLLABLE SASS");
+-   ("/xec/x83/x81", "HANGUL SYLLABLE SANG");
+-   ("/xec/x83/x82", "HANGUL SYLLABLE SAJ");
+-   ("/xec/x83/x83", "HANGUL SYLLABLE SAC");
+-   ("/xec/x83/x84", "HANGUL SYLLABLE SAK");
+-   ("/xec/x83/x85", "HANGUL SYLLABLE SAT");
+-   ("/xec/x83/x86", "HANGUL SYLLABLE SAP");
+-   ("/xec/x83/x87", "HANGUL SYLLABLE SAH");
+-   ("/xec/x83/x88", "HANGUL SYLLABLE SAE");
+-   ("/xec/x83/x89", "HANGUL SYLLABLE SAEG");
+-   ("/xec/x83/x8a", "HANGUL SYLLABLE SAEGG");
+-   ("/xec/x83/x8b", "HANGUL SYLLABLE SAEGS");
+-   ("/xec/x83/x8c", "HANGUL SYLLABLE SAEN");
+-   ("/xec/x83/x8d", "HANGUL SYLLABLE SAENI");
+-   ("/xec/x83/x8e", "HANGUL SYLLABLE SAENH");
+-   ("/xec/x83/x8f", "HANGUL SYLLABLE SAED");
+-   ("/xec/x83/x90", "HANGUL SYLLABLE SAEL");
+-   ("/xec/x83/x91", "HANGUL SYLLABLE SAELG");
+-   ("/xec/x83/x92", "HANGUL SYLLABLE SAELM");
+-   ("/xec/x83/x93", "HANGUL SYLLABLE SAELB");
+-   ("/xec/x83/x94", "HANGUL SYLLABLE SAELS");
+-   ("/xec/x83/x95", "HANGUL SYLLABLE SAELT");
+-   ("/xec/x83/x96", "HANGUL SYLLABLE SAELP");
+-   ("/xec/x83/x97", "HANGUL SYLLABLE SAELH");
+-   ("/xec/x83/x98", "HANGUL SYLLABLE SAEM");
+-   ("/xec/x83/x99", "HANGUL SYLLABLE SAEB");
+-   ("/xec/x83/x9a", "HANGUL SYLLABLE SAEBS");
+-   ("/xec/x83/x9b", "HANGUL SYLLABLE SAES");
+-   ("/xec/x83/x9c", "HANGUL SYLLABLE SAESS");
+-   ("/xec/x83/x9d", "HANGUL SYLLABLE SAENG");
+-   ("/xec/x83/x9e", "HANGUL SYLLABLE SAEJ");
+-   ("/xec/x83/x9f", "HANGUL SYLLABLE SAEC");
+-   ("/xec/x83/xa0", "HANGUL SYLLABLE SAEK");
+-   ("/xec/x83/xa1", "HANGUL SYLLABLE SAET");
+-   ("/xec/x83/xa2", "HANGUL SYLLABLE SAEP");
+-   ("/xec/x83/xa3", "HANGUL SYLLABLE SAEH");
+-   ("/xec/x83/xa4", "HANGUL SYLLABLE SYA");
+-   ("/xec/x83/xa5", "HANGUL SYLLABLE SYAG");
+-   ("/xec/x83/xa6", "HANGUL SYLLABLE SYAGG");
+-   ("/xec/x83/xa7", "HANGUL SYLLABLE SYAGS");
+-   ("/xec/x83/xa8", "HANGUL SYLLABLE SYAN");
+-   ("/xec/x83/xa9", "HANGUL SYLLABLE SYANI");
+-   ("/xec/x83/xaa", "HANGUL SYLLABLE SYANH");
+-   ("/xec/x83/xab", "HANGUL SYLLABLE SYAD");
+-   ("/xec/x83/xac", "HANGUL SYLLABLE SYAL");
+-   ("/xec/x83/xad", "HANGUL SYLLABLE SYALG");
+-   ("/xec/x83/xae", "HANGUL SYLLABLE SYALM");
+-   ("/xec/x83/xaf", "HANGUL SYLLABLE SYALB");
+-   ("/xec/x83/xb0", "HANGUL SYLLABLE SYALS");
+-   ("/xec/x83/xb1", "HANGUL SYLLABLE SYALT");
+-   ("/xec/x83/xb2", "HANGUL SYLLABLE SYALP");
+-   ("/xec/x83/xb3", "HANGUL SYLLABLE SYALH");
+-   ("/xec/x83/xb4", "HANGUL SYLLABLE SYAM");
+-   ("/xec/x83/xb5", "HANGUL SYLLABLE SYAB");
+-   ("/xec/x83/xb6", "HANGUL SYLLABLE SYABS");
+-   ("/xec/x83/xb7", "HANGUL SYLLABLE SYAS");
+-   ("/xec/x83/xb8", "HANGUL SYLLABLE SYASS");
+-   ("/xec/x83/xb9", "HANGUL SYLLABLE SYANG");
+-   ("/xec/x83/xba", "HANGUL SYLLABLE SYAJ");
+-   ("/xec/x83/xbb", "HANGUL SYLLABLE SYAC");
+-   ("/xec/x83/xbc", "HANGUL SYLLABLE SYAK");
+-   ("/xec/x83/xbd", "HANGUL SYLLABLE SYAT");
+-   ("/xec/x83/xbe", "HANGUL SYLLABLE SYAP");
+-   ("/xec/x83/xbf", "HANGUL SYLLABLE SYAH");
+-   ("/xec/x84/x80", "HANGUL SYLLABLE SYAE");
+-   ("/xec/x84/x81", "HANGUL SYLLABLE SYAEG");
+-   ("/xec/x84/x82", "HANGUL SYLLABLE SYAEGG");
+-   ("/xec/x84/x83", "HANGUL SYLLABLE SYAEGS");
+-   ("/xec/x84/x84", "HANGUL SYLLABLE SYAEN");
+-   ("/xec/x84/x85", "HANGUL SYLLABLE SYAENI");
+-   ("/xec/x84/x86", "HANGUL SYLLABLE SYAENH");
+-   ("/xec/x84/x87", "HANGUL SYLLABLE SYAED");
+-   ("/xec/x84/x88", "HANGUL SYLLABLE SYAEL");
+-   ("/xec/x84/x89", "HANGUL SYLLABLE SYAELG");
+-   ("/xec/x84/x8a", "HANGUL SYLLABLE SYAELM");
+-   ("/xec/x84/x8b", "HANGUL SYLLABLE SYAELB");
+-   ("/xec/x84/x8c", "HANGUL SYLLABLE SYAELS");
+-   ("/xec/x84/x8d", "HANGUL SYLLABLE SYAELT");
+-   ("/xec/x84/x8e", "HANGUL SYLLABLE SYAELP");
+-   ("/xec/x84/x8f", "HANGUL SYLLABLE SYAELH");
+-   ("/xec/x84/x90", "HANGUL SYLLABLE SYAEM");
+-   ("/xec/x84/x91", "HANGUL SYLLABLE SYAEB");
+-   ("/xec/x84/x92", "HANGUL SYLLABLE SYAEBS");
+-   ("/xec/x84/x93", "HANGUL SYLLABLE SYAES");
+-   ("/xec/x84/x94", "HANGUL SYLLABLE SYAESS");
+-   ("/xec/x84/x95", "HANGUL SYLLABLE SYAENG");
+-   ("/xec/x84/x96", "HANGUL SYLLABLE SYAEJ");
+-   ("/xec/x84/x97", "HANGUL SYLLABLE SYAEC");
+-   ("/xec/x84/x98", "HANGUL SYLLABLE SYAEK");
+-   ("/xec/x84/x99", "HANGUL SYLLABLE SYAET");
+-   ("/xec/x84/x9a", "HANGUL SYLLABLE SYAEP");
+-   ("/xec/x84/x9b", "HANGUL SYLLABLE SYAEH");
+-   ("/xec/x84/x9c", "HANGUL SYLLABLE SEO");
+-   ("/xec/x84/x9d", "HANGUL SYLLABLE SEOG");
+-   ("/xec/x84/x9e", "HANGUL SYLLABLE SEOGG");
+-   ("/xec/x84/x9f", "HANGUL SYLLABLE SEOGS");
+-   ("/xec/x84/xa0", "HANGUL SYLLABLE SEON");
+-   ("/xec/x84/xa1", "HANGUL SYLLABLE SEONI");
+-   ("/xec/x84/xa2", "HANGUL SYLLABLE SEONH");
+-   ("/xec/x84/xa3", "HANGUL SYLLABLE SEOD");
+-   ("/xec/x84/xa4", "HANGUL SYLLABLE SEOL");
+-   ("/xec/x84/xa5", "HANGUL SYLLABLE SEOLG");
+-   ("/xec/x84/xa6", "HANGUL SYLLABLE SEOLM");
+-   ("/xec/x84/xa7", "HANGUL SYLLABLE SEOLB");
+-   ("/xec/x84/xa8", "HANGUL SYLLABLE SEOLS");
+-   ("/xec/x84/xa9", "HANGUL SYLLABLE SEOLT");
+-   ("/xec/x84/xaa", "HANGUL SYLLABLE SEOLP");
+-   ("/xec/x84/xab", "HANGUL SYLLABLE SEOLH");
+-   ("/xec/x84/xac", "HANGUL SYLLABLE SEOM");
+-   ("/xec/x84/xad", "HANGUL SYLLABLE SEOB");
+-   ("/xec/x84/xae", "HANGUL SYLLABLE SEOBS");
+-   ("/xec/x84/xaf", "HANGUL SYLLABLE SEOS");
+-   ("/xec/x84/xb0", "HANGUL SYLLABLE SEOSS");
+-   ("/xec/x84/xb1", "HANGUL SYLLABLE SEONG");
+-   ("/xec/x84/xb2", "HANGUL SYLLABLE SEOJ");
+-   ("/xec/x84/xb3", "HANGUL SYLLABLE SEOC");
+-   ("/xec/x84/xb4", "HANGUL SYLLABLE SEOK");
+-   ("/xec/x84/xb5", "HANGUL SYLLABLE SEOT");
+-   ("/xec/x84/xb6", "HANGUL SYLLABLE SEOP");
+-   ("/xec/x84/xb7", "HANGUL SYLLABLE SEOH");
+-   ("/xec/x84/xb8", "HANGUL SYLLABLE SE");
+-   ("/xec/x84/xb9", "HANGUL SYLLABLE SEG");
+-   ("/xec/x84/xba", "HANGUL SYLLABLE SEGG");
+-   ("/xec/x84/xbb", "HANGUL SYLLABLE SEGS");
+-   ("/xec/x84/xbc", "HANGUL SYLLABLE SEN");
+-   ("/xec/x84/xbd", "HANGUL SYLLABLE SENI");
+-   ("/xec/x84/xbe", "HANGUL SYLLABLE SENH");
+-   ("/xec/x84/xbf", "HANGUL SYLLABLE SED");
+-   ("/xec/x85/x80", "HANGUL SYLLABLE SEL");
+-   ("/xec/x85/x81", "HANGUL SYLLABLE SELG");
+-   ("/xec/x85/x82", "HANGUL SYLLABLE SELM");
+-   ("/xec/x85/x83", "HANGUL SYLLABLE SELB");
+-   ("/xec/x85/x84", "HANGUL SYLLABLE SELS");
+-   ("/xec/x85/x85", "HANGUL SYLLABLE SELT");
+-   ("/xec/x85/x86", "HANGUL SYLLABLE SELP");
+-   ("/xec/x85/x87", "HANGUL SYLLABLE SELH");
+-   ("/xec/x85/x88", "HANGUL SYLLABLE SEM");
+-   ("/xec/x85/x89", "HANGUL SYLLABLE SEB");
+-   ("/xec/x85/x8a", "HANGUL SYLLABLE SEBS");
+-   ("/xec/x85/x8b", "HANGUL SYLLABLE SES");
+-   ("/xec/x85/x8c", "HANGUL SYLLABLE SESS");
+-   ("/xec/x85/x8d", "HANGUL SYLLABLE SENG");
+-   ("/xec/x85/x8e", "HANGUL SYLLABLE SEJ");
+-   ("/xec/x85/x8f", "HANGUL SYLLABLE SEC");
+-   ("/xec/x85/x90", "HANGUL SYLLABLE SEK");
+-   ("/xec/x85/x91", "HANGUL SYLLABLE SET");
+-   ("/xec/x85/x92", "HANGUL SYLLABLE SEP");
+-   ("/xec/x85/x93", "HANGUL SYLLABLE SEH");
+-   ("/xec/x85/x94", "HANGUL SYLLABLE SYEO");
+-   ("/xec/x85/x95", "HANGUL SYLLABLE SYEOG");
+-   ("/xec/x85/x96", "HANGUL SYLLABLE SYEOGG");
+-   ("/xec/x85/x97", "HANGUL SYLLABLE SYEOGS");
+-   ("/xec/x85/x98", "HANGUL SYLLABLE SYEON");
+-   ("/xec/x85/x99", "HANGUL SYLLABLE SYEONI");
+-   ("/xec/x85/x9a", "HANGUL SYLLABLE SYEONH");
+-   ("/xec/x85/x9b", "HANGUL SYLLABLE SYEOD");
+-   ("/xec/x85/x9c", "HANGUL SYLLABLE SYEOL");
+-   ("/xec/x85/x9d", "HANGUL SYLLABLE SYEOLG");
+-   ("/xec/x85/x9e", "HANGUL SYLLABLE SYEOLM");
+-   ("/xec/x85/x9f", "HANGUL SYLLABLE SYEOLB");
+-   ("/xec/x85/xa0", "HANGUL SYLLABLE SYEOLS");
+-   ("/xec/x85/xa1", "HANGUL SYLLABLE SYEOLT");
+-   ("/xec/x85/xa2", "HANGUL SYLLABLE SYEOLP");
+-   ("/xec/x85/xa3", "HANGUL SYLLABLE SYEOLH");
+-   ("/xec/x85/xa4", "HANGUL SYLLABLE SYEOM");
+-   ("/xec/x85/xa5", "HANGUL SYLLABLE SYEOB");
+-   ("/xec/x85/xa6", "HANGUL SYLLABLE SYEOBS");
+-   ("/xec/x85/xa7", "HANGUL SYLLABLE SYEOS");
+-   ("/xec/x85/xa8", "HANGUL SYLLABLE SYEOSS");
+-   ("/xec/x85/xa9", "HANGUL SYLLABLE SYEONG");
+-   ("/xec/x85/xaa", "HANGUL SYLLABLE SYEOJ");
+-   ("/xec/x85/xab", "HANGUL SYLLABLE SYEOC");
+-   ("/xec/x85/xac", "HANGUL SYLLABLE SYEOK");
+-   ("/xec/x85/xad", "HANGUL SYLLABLE SYEOT");
+-   ("/xec/x85/xae", "HANGUL SYLLABLE SYEOP");
+-   ("/xec/x85/xaf", "HANGUL SYLLABLE SYEOH");
+-   ("/xec/x85/xb0", "HANGUL SYLLABLE SYE");
+-   ("/xec/x85/xb1", "HANGUL SYLLABLE SYEG");
+-   ("/xec/x85/xb2", "HANGUL SYLLABLE SYEGG");
+-   ("/xec/x85/xb3", "HANGUL SYLLABLE SYEGS");
+-   ("/xec/x85/xb4", "HANGUL SYLLABLE SYEN");
+-   ("/xec/x85/xb5", "HANGUL SYLLABLE SYENI");
+-   ("/xec/x85/xb6", "HANGUL SYLLABLE SYENH");
+-   ("/xec/x85/xb7", "HANGUL SYLLABLE SYED");
+-   ("/xec/x85/xb8", "HANGUL SYLLABLE SYEL");
+-   ("/xec/x85/xb9", "HANGUL SYLLABLE SYELG");
+-   ("/xec/x85/xba", "HANGUL SYLLABLE SYELM");
+-   ("/xec/x85/xbb", "HANGUL SYLLABLE SYELB");
+-   ("/xec/x85/xbc", "HANGUL SYLLABLE SYELS");
+-   ("/xec/x85/xbd", "HANGUL SYLLABLE SYELT");
+-   ("/xec/x85/xbe", "HANGUL SYLLABLE SYELP");
+-   ("/xec/x85/xbf", "HANGUL SYLLABLE SYELH");
+-   ("/xec/x86/x80", "HANGUL SYLLABLE SYEM");
+-   ("/xec/x86/x81", "HANGUL SYLLABLE SYEB");
+-   ("/xec/x86/x82", "HANGUL SYLLABLE SYEBS");
+-   ("/xec/x86/x83", "HANGUL SYLLABLE SYES");
+-   ("/xec/x86/x84", "HANGUL SYLLABLE SYESS");
+-   ("/xec/x86/x85", "HANGUL SYLLABLE SYENG");
+-   ("/xec/x86/x86", "HANGUL SYLLABLE SYEJ");
+-   ("/xec/x86/x87", "HANGUL SYLLABLE SYEC");
+-   ("/xec/x86/x88", "HANGUL SYLLABLE SYEK");
+-   ("/xec/x86/x89", "HANGUL SYLLABLE SYET");
+-   ("/xec/x86/x8a", "HANGUL SYLLABLE SYEP");
+-   ("/xec/x86/x8b", "HANGUL SYLLABLE SYEH");
+-   ("/xec/x86/x8c", "HANGUL SYLLABLE SO");
+-   ("/xec/x86/x8d", "HANGUL SYLLABLE SOG");
+-   ("/xec/x86/x8e", "HANGUL SYLLABLE SOGG");
+-   ("/xec/x86/x8f", "HANGUL SYLLABLE SOGS");
+-   ("/xec/x86/x90", "HANGUL SYLLABLE SON");
+-   ("/xec/x86/x91", "HANGUL SYLLABLE SONI");
+-   ("/xec/x86/x92", "HANGUL SYLLABLE SONH");
+-   ("/xec/x86/x93", "HANGUL SYLLABLE SOD");
+-   ("/xec/x86/x94", "HANGUL SYLLABLE SOL");
+-   ("/xec/x86/x95", "HANGUL SYLLABLE SOLG");
+-   ("/xec/x86/x96", "HANGUL SYLLABLE SOLM");
+-   ("/xec/x86/x97", "HANGUL SYLLABLE SOLB");
+-   ("/xec/x86/x98", "HANGUL SYLLABLE SOLS");
+-   ("/xec/x86/x99", "HANGUL SYLLABLE SOLT");
+-   ("/xec/x86/x9a", "HANGUL SYLLABLE SOLP");
+-   ("/xec/x86/x9b", "HANGUL SYLLABLE SOLH");
+-   ("/xec/x86/x9c", "HANGUL SYLLABLE SOM");
+-   ("/xec/x86/x9d", "HANGUL SYLLABLE SOB");
+-   ("/xec/x86/x9e", "HANGUL SYLLABLE SOBS");
+-   ("/xec/x86/x9f", "HANGUL SYLLABLE SOS");
+-   ("/xec/x86/xa0", "HANGUL SYLLABLE SOSS");
+-   ("/xec/x86/xa1", "HANGUL SYLLABLE SONG");
+-   ("/xec/x86/xa2", "HANGUL SYLLABLE SOJ");
+-   ("/xec/x86/xa3", "HANGUL SYLLABLE SOC");
+-   ("/xec/x86/xa4", "HANGUL SYLLABLE SOK");
+-   ("/xec/x86/xa5", "HANGUL SYLLABLE SOT");
+-   ("/xec/x86/xa6", "HANGUL SYLLABLE SOP");
+-   ("/xec/x86/xa7", "HANGUL SYLLABLE SOH");
+-   ("/xec/x86/xa8", "HANGUL SYLLABLE SWA");
+-   ("/xec/x86/xa9", "HANGUL SYLLABLE SWAG");
+-   ("/xec/x86/xaa", "HANGUL SYLLABLE SWAGG");
+-   ("/xec/x86/xab", "HANGUL SYLLABLE SWAGS");
+-   ("/xec/x86/xac", "HANGUL SYLLABLE SWAN");
+-   ("/xec/x86/xad", "HANGUL SYLLABLE SWANI");
+-   ("/xec/x86/xae", "HANGUL SYLLABLE SWANH");
+-   ("/xec/x86/xaf", "HANGUL SYLLABLE SWAD");
+-   ("/xec/x86/xb0", "HANGUL SYLLABLE SWAL");
+-   ("/xec/x86/xb1", "HANGUL SYLLABLE SWALG");
+-   ("/xec/x86/xb2", "HANGUL SYLLABLE SWALM");
+-   ("/xec/x86/xb3", "HANGUL SYLLABLE SWALB");
+-   ("/xec/x86/xb4", "HANGUL SYLLABLE SWALS");
+-   ("/xec/x86/xb5", "HANGUL SYLLABLE SWALT");
+-   ("/xec/x86/xb6", "HANGUL SYLLABLE SWALP");
+-   ("/xec/x86/xb7", "HANGUL SYLLABLE SWALH");
+-   ("/xec/x86/xb8", "HANGUL SYLLABLE SWAM");
+-   ("/xec/x86/xb9", "HANGUL SYLLABLE SWAB");
+-   ("/xec/x86/xba", "HANGUL SYLLABLE SWABS");
+-   ("/xec/x86/xbb", "HANGUL SYLLABLE SWAS");
+-   ("/xec/x86/xbc", "HANGUL SYLLABLE SWASS");
+-   ("/xec/x86/xbd", "HANGUL SYLLABLE SWANG");
+-   ("/xec/x86/xbe", "HANGUL SYLLABLE SWAJ");
+-   ("/xec/x86/xbf", "HANGUL SYLLABLE SWAC");
+-   ("/xec/x87/x80", "HANGUL SYLLABLE SWAK");
+-   ("/xec/x87/x81", "HANGUL SYLLABLE SWAT");
+-   ("/xec/x87/x82", "HANGUL SYLLABLE SWAP");
+-   ("/xec/x87/x83", "HANGUL SYLLABLE SWAH");
+-   ("/xec/x87/x84", "HANGUL SYLLABLE SWAE");
+-   ("/xec/x87/x85", "HANGUL SYLLABLE SWAEG");
+-   ("/xec/x87/x86", "HANGUL SYLLABLE SWAEGG");
+-   ("/xec/x87/x87", "HANGUL SYLLABLE SWAEGS");
+-   ("/xec/x87/x88", "HANGUL SYLLABLE SWAEN");
+-   ("/xec/x87/x89", "HANGUL SYLLABLE SWAENI");
+-   ("/xec/x87/x8a", "HANGUL SYLLABLE SWAENH");
+-   ("/xec/x87/x8b", "HANGUL SYLLABLE SWAED");
+-   ("/xec/x87/x8c", "HANGUL SYLLABLE SWAEL");
+-   ("/xec/x87/x8d", "HANGUL SYLLABLE SWAELG");
+-   ("/xec/x87/x8e", "HANGUL SYLLABLE SWAELM");
+-   ("/xec/x87/x8f", "HANGUL SYLLABLE SWAELB");
+-   ("/xec/x87/x90", "HANGUL SYLLABLE SWAELS");
+-   ("/xec/x87/x91", "HANGUL SYLLABLE SWAELT");
+-   ("/xec/x87/x92", "HANGUL SYLLABLE SWAELP");
+-   ("/xec/x87/x93", "HANGUL SYLLABLE SWAELH");
+-   ("/xec/x87/x94", "HANGUL SYLLABLE SWAEM");
+-   ("/xec/x87/x95", "HANGUL SYLLABLE SWAEB");
+-   ("/xec/x87/x96", "HANGUL SYLLABLE SWAEBS");
+-   ("/xec/x87/x97", "HANGUL SYLLABLE SWAES");
+-   ("/xec/x87/x98", "HANGUL SYLLABLE SWAESS");
+-   ("/xec/x87/x99", "HANGUL SYLLABLE SWAENG");
+-   ("/xec/x87/x9a", "HANGUL SYLLABLE SWAEJ");
+-   ("/xec/x87/x9b", "HANGUL SYLLABLE SWAEC");
+-   ("/xec/x87/x9c", "HANGUL SYLLABLE SWAEK");
+-   ("/xec/x87/x9d", "HANGUL SYLLABLE SWAET");
+-   ("/xec/x87/x9e", "HANGUL SYLLABLE SWAEP");
+-   ("/xec/x87/x9f", "HANGUL SYLLABLE SWAEH");
+-   ("/xec/x87/xa0", "HANGUL SYLLABLE SOE");
+-   ("/xec/x87/xa1", "HANGUL SYLLABLE SOEG");
+-   ("/xec/x87/xa2", "HANGUL SYLLABLE SOEGG");
+-   ("/xec/x87/xa3", "HANGUL SYLLABLE SOEGS");
+-   ("/xec/x87/xa4", "HANGUL SYLLABLE SOEN");
+-   ("/xec/x87/xa5", "HANGUL SYLLABLE SOENI");
+-   ("/xec/x87/xa6", "HANGUL SYLLABLE SOENH");
+-   ("/xec/x87/xa7", "HANGUL SYLLABLE SOED");
+-   ("/xec/x87/xa8", "HANGUL SYLLABLE SOEL");
+-   ("/xec/x87/xa9", "HANGUL SYLLABLE SOELG");
+-   ("/xec/x87/xaa", "HANGUL SYLLABLE SOELM");
+-   ("/xec/x87/xab", "HANGUL SYLLABLE SOELB");
+-   ("/xec/x87/xac", "HANGUL SYLLABLE SOELS");
+-   ("/xec/x87/xad", "HANGUL SYLLABLE SOELT");
+-   ("/xec/x87/xae", "HANGUL SYLLABLE SOELP");
+-   ("/xec/x87/xaf", "HANGUL SYLLABLE SOELH");
+-   ("/xec/x87/xb0", "HANGUL SYLLABLE SOEM");
+-   ("/xec/x87/xb1", "HANGUL SYLLABLE SOEB");
+-   ("/xec/x87/xb2", "HANGUL SYLLABLE SOEBS");
+-   ("/xec/x87/xb3", "HANGUL SYLLABLE SOES");
+-   ("/xec/x87/xb4", "HANGUL SYLLABLE SOESS");
+-   ("/xec/x87/xb5", "HANGUL SYLLABLE SOENG");
+-   ("/xec/x87/xb6", "HANGUL SYLLABLE SOEJ");
+-   ("/xec/x87/xb7", "HANGUL SYLLABLE SOEC");
+-   ("/xec/x87/xb8", "HANGUL SYLLABLE SOEK");
+-   ("/xec/x87/xb9", "HANGUL SYLLABLE SOET");
+-   ("/xec/x87/xba", "HANGUL SYLLABLE SOEP");
+-   ("/xec/x87/xbb", "HANGUL SYLLABLE SOEH");
+-   ("/xec/x87/xbc", "HANGUL SYLLABLE SYO");
+-   ("/xec/x87/xbd", "HANGUL SYLLABLE SYOG");
+-   ("/xec/x87/xbe", "HANGUL SYLLABLE SYOGG");
+-   ("/xec/x87/xbf", "HANGUL SYLLABLE SYOGS");
+-   ("/xec/x88/x80", "HANGUL SYLLABLE SYON");
+-   ("/xec/x88/x81", "HANGUL SYLLABLE SYONI");
+-   ("/xec/x88/x82", "HANGUL SYLLABLE SYONH");
+-   ("/xec/x88/x83", "HANGUL SYLLABLE SYOD");
+-   ("/xec/x88/x84", "HANGUL SYLLABLE SYOL");
+-   ("/xec/x88/x85", "HANGUL SYLLABLE SYOLG");
+-   ("/xec/x88/x86", "HANGUL SYLLABLE SYOLM");
+-   ("/xec/x88/x87", "HANGUL SYLLABLE SYOLB");
+-   ("/xec/x88/x88", "HANGUL SYLLABLE SYOLS");
+-   ("/xec/x88/x89", "HANGUL SYLLABLE SYOLT");
+-   ("/xec/x88/x8a", "HANGUL SYLLABLE SYOLP");
+-   ("/xec/x88/x8b", "HANGUL SYLLABLE SYOLH");
+-   ("/xec/x88/x8c", "HANGUL SYLLABLE SYOM");
+-   ("/xec/x88/x8d", "HANGUL SYLLABLE SYOB");
+-   ("/xec/x88/x8e", "HANGUL SYLLABLE SYOBS");
+-   ("/xec/x88/x8f", "HANGUL SYLLABLE SYOS");
+-   ("/xec/x88/x90", "HANGUL SYLLABLE SYOSS");
+-   ("/xec/x88/x91", "HANGUL SYLLABLE SYONG");
+-   ("/xec/x88/x92", "HANGUL SYLLABLE SYOJ");
+-   ("/xec/x88/x93", "HANGUL SYLLABLE SYOC");
+-   ("/xec/x88/x94", "HANGUL SYLLABLE SYOK");
+-   ("/xec/x88/x95", "HANGUL SYLLABLE SYOT");
+-   ("/xec/x88/x96", "HANGUL SYLLABLE SYOP");
+-   ("/xec/x88/x97", "HANGUL SYLLABLE SYOH");
+-   ("/xec/x88/x98", "HANGUL SYLLABLE SU");
+-   ("/xec/x88/x99", "HANGUL SYLLABLE SUG");
+-   ("/xec/x88/x9a", "HANGUL SYLLABLE SUGG");
+-   ("/xec/x88/x9b", "HANGUL SYLLABLE SUGS");
+-   ("/xec/x88/x9c", "HANGUL SYLLABLE SUN");
+-   ("/xec/x88/x9d", "HANGUL SYLLABLE SUNI");
+-   ("/xec/x88/x9e", "HANGUL SYLLABLE SUNH");
+-   ("/xec/x88/x9f", "HANGUL SYLLABLE SUD");
+-   ("/xec/x88/xa0", "HANGUL SYLLABLE SUL");
+-   ("/xec/x88/xa1", "HANGUL SYLLABLE SULG");
+-   ("/xec/x88/xa2", "HANGUL SYLLABLE SULM");
+-   ("/xec/x88/xa3", "HANGUL SYLLABLE SULB");
+-   ("/xec/x88/xa4", "HANGUL SYLLABLE SULS");
+-   ("/xec/x88/xa5", "HANGUL SYLLABLE SULT");
+-   ("/xec/x88/xa6", "HANGUL SYLLABLE SULP");
+-   ("/xec/x88/xa7", "HANGUL SYLLABLE SULH");
+-   ("/xec/x88/xa8", "HANGUL SYLLABLE SUM");
+-   ("/xec/x88/xa9", "HANGUL SYLLABLE SUB");
+-   ("/xec/x88/xaa", "HANGUL SYLLABLE SUBS");
+-   ("/xec/x88/xab", "HANGUL SYLLABLE SUS");
+-   ("/xec/x88/xac", "HANGUL SYLLABLE SUSS");
+-   ("/xec/x88/xad", "HANGUL SYLLABLE SUNG");
+-   ("/xec/x88/xae", "HANGUL SYLLABLE SUJ");
+-   ("/xec/x88/xaf", "HANGUL SYLLABLE SUC");
+-   ("/xec/x88/xb0", "HANGUL SYLLABLE SUK");
+-   ("/xec/x88/xb1", "HANGUL SYLLABLE SUT");
+-   ("/xec/x88/xb2", "HANGUL SYLLABLE SUP");
+-   ("/xec/x88/xb3", "HANGUL SYLLABLE SUH");
+-   ("/xec/x88/xb4", "HANGUL SYLLABLE SWEO");
+-   ("/xec/x88/xb5", "HANGUL SYLLABLE SWEOG");
+-   ("/xec/x88/xb6", "HANGUL SYLLABLE SWEOGG");
+-   ("/xec/x88/xb7", "HANGUL SYLLABLE SWEOGS");
+-   ("/xec/x88/xb8", "HANGUL SYLLABLE SWEON");
+-   ("/xec/x88/xb9", "HANGUL SYLLABLE SWEONI");
+-   ("/xec/x88/xba", "HANGUL SYLLABLE SWEONH");
+-   ("/xec/x88/xbb", "HANGUL SYLLABLE SWEOD");
+-   ("/xec/x88/xbc", "HANGUL SYLLABLE SWEOL");
+-   ("/xec/x88/xbd", "HANGUL SYLLABLE SWEOLG");
+-   ("/xec/x88/xbe", "HANGUL SYLLABLE SWEOLM");
+-   ("/xec/x88/xbf", "HANGUL SYLLABLE SWEOLB");
+-   ("/xec/x89/x80", "HANGUL SYLLABLE SWEOLS");
+-   ("/xec/x89/x81", "HANGUL SYLLABLE SWEOLT");
+-   ("/xec/x89/x82", "HANGUL SYLLABLE SWEOLP");
+-   ("/xec/x89/x83", "HANGUL SYLLABLE SWEOLH");
+-   ("/xec/x89/x84", "HANGUL SYLLABLE SWEOM");
+-   ("/xec/x89/x85", "HANGUL SYLLABLE SWEOB");
+-   ("/xec/x89/x86", "HANGUL SYLLABLE SWEOBS");
+-   ("/xec/x89/x87", "HANGUL SYLLABLE SWEOS");
+-   ("/xec/x89/x88", "HANGUL SYLLABLE SWEOSS");
+-   ("/xec/x89/x89", "HANGUL SYLLABLE SWEONG");
+-   ("/xec/x89/x8a", "HANGUL SYLLABLE SWEOJ");
+-   ("/xec/x89/x8b", "HANGUL SYLLABLE SWEOC");
+-   ("/xec/x89/x8c", "HANGUL SYLLABLE SWEOK");
+-   ("/xec/x89/x8d", "HANGUL SYLLABLE SWEOT");
+-   ("/xec/x89/x8e", "HANGUL SYLLABLE SWEOP");
+-   ("/xec/x89/x8f", "HANGUL SYLLABLE SWEOH");
+-   ("/xec/x89/x90", "HANGUL SYLLABLE SWE");
+-   ("/xec/x89/x91", "HANGUL SYLLABLE SWEG");
+-   ("/xec/x89/x92", "HANGUL SYLLABLE SWEGG");
+-   ("/xec/x89/x93", "HANGUL SYLLABLE SWEGS");
+-   ("/xec/x89/x94", "HANGUL SYLLABLE SWEN");
+-   ("/xec/x89/x95", "HANGUL SYLLABLE SWENI");
+-   ("/xec/x89/x96", "HANGUL SYLLABLE SWENH");
+-   ("/xec/x89/x97", "HANGUL SYLLABLE SWED");
+-   ("/xec/x89/x98", "HANGUL SYLLABLE SWEL");
+-   ("/xec/x89/x99", "HANGUL SYLLABLE SWELG");
+-   ("/xec/x89/x9a", "HANGUL SYLLABLE SWELM");
+-   ("/xec/x89/x9b", "HANGUL SYLLABLE SWELB");
+-   ("/xec/x89/x9c", "HANGUL SYLLABLE SWELS");
+-   ("/xec/x89/x9d", "HANGUL SYLLABLE SWELT");
+-   ("/xec/x89/x9e", "HANGUL SYLLABLE SWELP");
+-   ("/xec/x89/x9f", "HANGUL SYLLABLE SWELH");
+-   ("/xec/x89/xa0", "HANGUL SYLLABLE SWEM");
+-   ("/xec/x89/xa1", "HANGUL SYLLABLE SWEB");
+-   ("/xec/x89/xa2", "HANGUL SYLLABLE SWEBS");
+-   ("/xec/x89/xa3", "HANGUL SYLLABLE SWES");
+-   ("/xec/x89/xa4", "HANGUL SYLLABLE SWESS");
+-   ("/xec/x89/xa5", "HANGUL SYLLABLE SWENG");
+-   ("/xec/x89/xa6", "HANGUL SYLLABLE SWEJ");
+-   ("/xec/x89/xa7", "HANGUL SYLLABLE SWEC");
+-   ("/xec/x89/xa8", "HANGUL SYLLABLE SWEK");
+-   ("/xec/x89/xa9", "HANGUL SYLLABLE SWET");
+-   ("/xec/x89/xaa", "HANGUL SYLLABLE SWEP");
+-   ("/xec/x89/xab", "HANGUL SYLLABLE SWEH");
+-   ("/xec/x89/xac", "HANGUL SYLLABLE SWI");
+-   ("/xec/x89/xad", "HANGUL SYLLABLE SWIG");
+-   ("/xec/x89/xae", "HANGUL SYLLABLE SWIGG");
+-   ("/xec/x89/xaf", "HANGUL SYLLABLE SWIGS");
+-   ("/xec/x89/xb0", "HANGUL SYLLABLE SWIN");
+-   ("/xec/x89/xb1", "HANGUL SYLLABLE SWINI");
+-   ("/xec/x89/xb2", "HANGUL SYLLABLE SWINH");
+-   ("/xec/x89/xb3", "HANGUL SYLLABLE SWID");
+-   ("/xec/x89/xb4", "HANGUL SYLLABLE SWIL");
+-   ("/xec/x89/xb5", "HANGUL SYLLABLE SWILG");
+-   ("/xec/x89/xb6", "HANGUL SYLLABLE SWILM");
+-   ("/xec/x89/xb7", "HANGUL SYLLABLE SWILB");
+-   ("/xec/x89/xb8", "HANGUL SYLLABLE SWILS");
+-   ("/xec/x89/xb9", "HANGUL SYLLABLE SWILT");
+-   ("/xec/x89/xba", "HANGUL SYLLABLE SWILP");
+-   ("/xec/x89/xbb", "HANGUL SYLLABLE SWILH");
+-   ("/xec/x89/xbc", "HANGUL SYLLABLE SWIM");
+-   ("/xec/x89/xbd", "HANGUL SYLLABLE SWIB");
+-   ("/xec/x89/xbe", "HANGUL SYLLABLE SWIBS");
+-   ("/xec/x89/xbf", "HANGUL SYLLABLE SWIS");
+-   ("/xec/x8a/x80", "HANGUL SYLLABLE SWISS");
+-   ("/xec/x8a/x81", "HANGUL SYLLABLE SWING");
+-   ("/xec/x8a/x82", "HANGUL SYLLABLE SWIJ");
+-   ("/xec/x8a/x83", "HANGUL SYLLABLE SWIC");
+-   ("/xec/x8a/x84", "HANGUL SYLLABLE SWIK");
+-   ("/xec/x8a/x85", "HANGUL SYLLABLE SWIT");
+-   ("/xec/x8a/x86", "HANGUL SYLLABLE SWIP");
+-   ("/xec/x8a/x87", "HANGUL SYLLABLE SWIH");
+-   ("/xec/x8a/x88", "HANGUL SYLLABLE SYU");
+-   ("/xec/x8a/x89", "HANGUL SYLLABLE SYUG");
+-   ("/xec/x8a/x8a", "HANGUL SYLLABLE SYUGG");
+-   ("/xec/x8a/x8b", "HANGUL SYLLABLE SYUGS");
+-   ("/xec/x8a/x8c", "HANGUL SYLLABLE SYUN");
+-   ("/xec/x8a/x8d", "HANGUL SYLLABLE SYUNI");
+-   ("/xec/x8a/x8e", "HANGUL SYLLABLE SYUNH");
+-   ("/xec/x8a/x8f", "HANGUL SYLLABLE SYUD");
+-   ("/xec/x8a/x90", "HANGUL SYLLABLE SYUL");
+-   ("/xec/x8a/x91", "HANGUL SYLLABLE SYULG");
+-   ("/xec/x8a/x92", "HANGUL SYLLABLE SYULM");
+-   ("/xec/x8a/x93", "HANGUL SYLLABLE SYULB");
+-   ("/xec/x8a/x94", "HANGUL SYLLABLE SYULS");
+-   ("/xec/x8a/x95", "HANGUL SYLLABLE SYULT");
+-   ("/xec/x8a/x96", "HANGUL SYLLABLE SYULP");
+-   ("/xec/x8a/x97", "HANGUL SYLLABLE SYULH");
+-   ("/xec/x8a/x98", "HANGUL SYLLABLE SYUM");
+-   ("/xec/x8a/x99", "HANGUL SYLLABLE SYUB");
+-   ("/xec/x8a/x9a", "HANGUL SYLLABLE SYUBS");
+-   ("/xec/x8a/x9b", "HANGUL SYLLABLE SYUS");
+-   ("/xec/x8a/x9c", "HANGUL SYLLABLE SYUSS");
+-   ("/xec/x8a/x9d", "HANGUL SYLLABLE SYUNG");
+-   ("/xec/x8a/x9e", "HANGUL SYLLABLE SYUJ");
+-   ("/xec/x8a/x9f", "HANGUL SYLLABLE SYUC");
+-   ("/xec/x8a/xa0", "HANGUL SYLLABLE SYUK");
+-   ("/xec/x8a/xa1", "HANGUL SYLLABLE SYUT");
+-   ("/xec/x8a/xa2", "HANGUL SYLLABLE SYUP");
+-   ("/xec/x8a/xa3", "HANGUL SYLLABLE SYUH");
+-   ("/xec/x8a/xa4", "HANGUL SYLLABLE SEU");
+-   ("/xec/x8a/xa5", "HANGUL SYLLABLE SEUG");
+-   ("/xec/x8a/xa6", "HANGUL SYLLABLE SEUGG");
+-   ("/xec/x8a/xa7", "HANGUL SYLLABLE SEUGS");
+-   ("/xec/x8a/xa8", "HANGUL SYLLABLE SEUN");
+-   ("/xec/x8a/xa9", "HANGUL SYLLABLE SEUNI");
+-   ("/xec/x8a/xaa", "HANGUL SYLLABLE SEUNH");
+-   ("/xec/x8a/xab", "HANGUL SYLLABLE SEUD");
+-   ("/xec/x8a/xac", "HANGUL SYLLABLE SEUL");
+-   ("/xec/x8a/xad", "HANGUL SYLLABLE SEULG");
+-   ("/xec/x8a/xae", "HANGUL SYLLABLE SEULM");
+-   ("/xec/x8a/xaf", "HANGUL SYLLABLE SEULB");
+-   ("/xec/x8a/xb0", "HANGUL SYLLABLE SEULS");
+-   ("/xec/x8a/xb1", "HANGUL SYLLABLE SEULT");
+-   ("/xec/x8a/xb2", "HANGUL SYLLABLE SEULP");
+-   ("/xec/x8a/xb3", "HANGUL SYLLABLE SEULH");
+-   ("/xec/x8a/xb4", "HANGUL SYLLABLE SEUM");
+-   ("/xec/x8a/xb5", "HANGUL SYLLABLE SEUB");
+-   ("/xec/x8a/xb6", "HANGUL SYLLABLE SEUBS");
+-   ("/xec/x8a/xb7", "HANGUL SYLLABLE SEUS");
+-   ("/xec/x8a/xb8", "HANGUL SYLLABLE SEUSS");
+-   ("/xec/x8a/xb9", "HANGUL SYLLABLE SEUNG");
+-   ("/xec/x8a/xba", "HANGUL SYLLABLE SEUJ");
+-   ("/xec/x8a/xbb", "HANGUL SYLLABLE SEUC");
+-   ("/xec/x8a/xbc", "HANGUL SYLLABLE SEUK");
+-   ("/xec/x8a/xbd", "HANGUL SYLLABLE SEUT");
+-   ("/xec/x8a/xbe", "HANGUL SYLLABLE SEUP");
+-   ("/xec/x8a/xbf", "HANGUL SYLLABLE SEUH");
+-   ("/xec/x8b/x80", "HANGUL SYLLABLE SYI");
+-   ("/xec/x8b/x81", "HANGUL SYLLABLE SYIG");
+-   ("/xec/x8b/x82", "HANGUL SYLLABLE SYIGG");
+-   ("/xec/x8b/x83", "HANGUL SYLLABLE SYIGS");
+-   ("/xec/x8b/x84", "HANGUL SYLLABLE SYIN");
+-   ("/xec/x8b/x85", "HANGUL SYLLABLE SYINI");
+-   ("/xec/x8b/x86", "HANGUL SYLLABLE SYINH");
+-   ("/xec/x8b/x87", "HANGUL SYLLABLE SYID");
+-   ("/xec/x8b/x88", "HANGUL SYLLABLE SYIL");
+-   ("/xec/x8b/x89", "HANGUL SYLLABLE SYILG");
+-   ("/xec/x8b/x8a", "HANGUL SYLLABLE SYILM");
+-   ("/xec/x8b/x8b", "HANGUL SYLLABLE SYILB");
+-   ("/xec/x8b/x8c", "HANGUL SYLLABLE SYILS");
+-   ("/xec/x8b/x8d", "HANGUL SYLLABLE SYILT");
+-   ("/xec/x8b/x8e", "HANGUL SYLLABLE SYILP");
+-   ("/xec/x8b/x8f", "HANGUL SYLLABLE SYILH");
+-   ("/xec/x8b/x90", "HANGUL SYLLABLE SYIM");
+-   ("/xec/x8b/x91", "HANGUL SYLLABLE SYIB");
+-   ("/xec/x8b/x92", "HANGUL SYLLABLE SYIBS");
+-   ("/xec/x8b/x93", "HANGUL SYLLABLE SYIS");
+-   ("/xec/x8b/x94", "HANGUL SYLLABLE SYISS");
+-   ("/xec/x8b/x95", "HANGUL SYLLABLE SYING");
+-   ("/xec/x8b/x96", "HANGUL SYLLABLE SYIJ");
+-   ("/xec/x8b/x97", "HANGUL SYLLABLE SYIC");
+-   ("/xec/x8b/x98", "HANGUL SYLLABLE SYIK");
+-   ("/xec/x8b/x99", "HANGUL SYLLABLE SYIT");
+-   ("/xec/x8b/x9a", "HANGUL SYLLABLE SYIP");
+-   ("/xec/x8b/x9b", "HANGUL SYLLABLE SYIH");
+-   ("/xec/x8b/x9c", "HANGUL SYLLABLE SI");
+-   ("/xec/x8b/x9d", "HANGUL SYLLABLE SIG");
+-   ("/xec/x8b/x9e", "HANGUL SYLLABLE SIGG");
+-   ("/xec/x8b/x9f", "HANGUL SYLLABLE SIGS");
+-   ("/xec/x8b/xa0", "HANGUL SYLLABLE SIN");
+-   ("/xec/x8b/xa1", "HANGUL SYLLABLE SINI");
+-   ("/xec/x8b/xa2", "HANGUL SYLLABLE SINH");
+-   ("/xec/x8b/xa3", "HANGUL SYLLABLE SID");
+-   ("/xec/x8b/xa4", "HANGUL SYLLABLE SIL");
+-   ("/xec/x8b/xa5", "HANGUL SYLLABLE SILG");
+-   ("/xec/x8b/xa6", "HANGUL SYLLABLE SILM");
+-   ("/xec/x8b/xa7", "HANGUL SYLLABLE SILB");
+-   ("/xec/x8b/xa8", "HANGUL SYLLABLE SILS");
+-   ("/xec/x8b/xa9", "HANGUL SYLLABLE SILT");
+-   ("/xec/x8b/xaa", "HANGUL SYLLABLE SILP");
+-   ("/xec/x8b/xab", "HANGUL SYLLABLE SILH");
+-   ("/xec/x8b/xac", "HANGUL SYLLABLE SIM");
+-   ("/xec/x8b/xad", "HANGUL SYLLABLE SIB");
+-   ("/xec/x8b/xae", "HANGUL SYLLABLE SIBS");
+-   ("/xec/x8b/xaf", "HANGUL SYLLABLE SIS");
+-   ("/xec/x8b/xb0", "HANGUL SYLLABLE SISS");
+-   ("/xec/x8b/xb1", "HANGUL SYLLABLE SING");
+-   ("/xec/x8b/xb2", "HANGUL SYLLABLE SIJ");
+-   ("/xec/x8b/xb3", "HANGUL SYLLABLE SIC");
+-   ("/xec/x8b/xb4", "HANGUL SYLLABLE SIK");
+-   ("/xec/x8b/xb5", "HANGUL SYLLABLE SIT");
+-   ("/xec/x8b/xb6", "HANGUL SYLLABLE SIP");
+-   ("/xec/x8b/xb7", "HANGUL SYLLABLE SIH");
+-   ("/xec/x8b/xb8", "HANGUL SYLLABLE SSA");
+-   ("/xec/x8b/xb9", "HANGUL SYLLABLE SSAG");
+-   ("/xec/x8b/xba", "HANGUL SYLLABLE SSAGG");
+-   ("/xec/x8b/xbb", "HANGUL SYLLABLE SSAGS");
+-   ("/xec/x8b/xbc", "HANGUL SYLLABLE SSAN");
+-   ("/xec/x8b/xbd", "HANGUL SYLLABLE SSANI");
+-   ("/xec/x8b/xbe", "HANGUL SYLLABLE SSANH");
+-   ("/xec/x8b/xbf", "HANGUL SYLLABLE SSAD");
+-   ("/xec/x8c/x80", "HANGUL SYLLABLE SSAL");
+-   ("/xec/x8c/x81", "HANGUL SYLLABLE SSALG");
+-   ("/xec/x8c/x82", "HANGUL SYLLABLE SSALM");
+-   ("/xec/x8c/x83", "HANGUL SYLLABLE SSALB");
+-   ("/xec/x8c/x84", "HANGUL SYLLABLE SSALS");
+-   ("/xec/x8c/x85", "HANGUL SYLLABLE SSALT");
+-   ("/xec/x8c/x86", "HANGUL SYLLABLE SSALP");
+-   ("/xec/x8c/x87", "HANGUL SYLLABLE SSALH");
+-   ("/xec/x8c/x88", "HANGUL SYLLABLE SSAM");
+-   ("/xec/x8c/x89", "HANGUL SYLLABLE SSAB");
+-   ("/xec/x8c/x8a", "HANGUL SYLLABLE SSABS");
+-   ("/xec/x8c/x8b", "HANGUL SYLLABLE SSAS");
+-   ("/xec/x8c/x8c", "HANGUL SYLLABLE SSASS");
+-   ("/xec/x8c/x8d", "HANGUL SYLLABLE SSANG");
+-   ("/xec/x8c/x8e", "HANGUL SYLLABLE SSAJ");
+-   ("/xec/x8c/x8f", "HANGUL SYLLABLE SSAC");
+-   ("/xec/x8c/x90", "HANGUL SYLLABLE SSAK");
+-   ("/xec/x8c/x91", "HANGUL SYLLABLE SSAT");
+-   ("/xec/x8c/x92", "HANGUL SYLLABLE SSAP");
+-   ("/xec/x8c/x93", "HANGUL SYLLABLE SSAH");
+-   ("/xec/x8c/x94", "HANGUL SYLLABLE SSAE");
+-   ("/xec/x8c/x95", "HANGUL SYLLABLE SSAEG");
+-   ("/xec/x8c/x96", "HANGUL SYLLABLE SSAEGG");
+-   ("/xec/x8c/x97", "HANGUL SYLLABLE SSAEGS");
+-   ("/xec/x8c/x98", "HANGUL SYLLABLE SSAEN");
+-   ("/xec/x8c/x99", "HANGUL SYLLABLE SSAENI");
+-   ("/xec/x8c/x9a", "HANGUL SYLLABLE SSAENH");
+-   ("/xec/x8c/x9b", "HANGUL SYLLABLE SSAED");
+-   ("/xec/x8c/x9c", "HANGUL SYLLABLE SSAEL");
+-   ("/xec/x8c/x9d", "HANGUL SYLLABLE SSAELG");
+-   ("/xec/x8c/x9e", "HANGUL SYLLABLE SSAELM");
+-   ("/xec/x8c/x9f", "HANGUL SYLLABLE SSAELB");
+-   ("/xec/x8c/xa0", "HANGUL SYLLABLE SSAELS");
+-   ("/xec/x8c/xa1", "HANGUL SYLLABLE SSAELT");
+-   ("/xec/x8c/xa2", "HANGUL SYLLABLE SSAELP");
+-   ("/xec/x8c/xa3", "HANGUL SYLLABLE SSAELH");
+-   ("/xec/x8c/xa4", "HANGUL SYLLABLE SSAEM");
+-   ("/xec/x8c/xa5", "HANGUL SYLLABLE SSAEB");
+-   ("/xec/x8c/xa6", "HANGUL SYLLABLE SSAEBS");
+-   ("/xec/x8c/xa7", "HANGUL SYLLABLE SSAES");
+-   ("/xec/x8c/xa8", "HANGUL SYLLABLE SSAESS");
+-   ("/xec/x8c/xa9", "HANGUL SYLLABLE SSAENG");
+-   ("/xec/x8c/xaa", "HANGUL SYLLABLE SSAEJ");
+-   ("/xec/x8c/xab", "HANGUL SYLLABLE SSAEC");
+-   ("/xec/x8c/xac", "HANGUL SYLLABLE SSAEK");
+-   ("/xec/x8c/xad", "HANGUL SYLLABLE SSAET");
+-   ("/xec/x8c/xae", "HANGUL SYLLABLE SSAEP");
+-   ("/xec/x8c/xaf", "HANGUL SYLLABLE SSAEH");
+-   ("/xec/x8c/xb0", "HANGUL SYLLABLE SSYA");
+-   ("/xec/x8c/xb1", "HANGUL SYLLABLE SSYAG");
+-   ("/xec/x8c/xb2", "HANGUL SYLLABLE SSYAGG");
+-   ("/xec/x8c/xb3", "HANGUL SYLLABLE SSYAGS");
+-   ("/xec/x8c/xb4", "HANGUL SYLLABLE SSYAN");
+-   ("/xec/x8c/xb5", "HANGUL SYLLABLE SSYANI");
+-   ("/xec/x8c/xb6", "HANGUL SYLLABLE SSYANH");
+-   ("/xec/x8c/xb7", "HANGUL SYLLABLE SSYAD");
+-   ("/xec/x8c/xb8", "HANGUL SYLLABLE SSYAL");
+-   ("/xec/x8c/xb9", "HANGUL SYLLABLE SSYALG");
+-   ("/xec/x8c/xba", "HANGUL SYLLABLE SSYALM");
+-   ("/xec/x8c/xbb", "HANGUL SYLLABLE SSYALB");
+-   ("/xec/x8c/xbc", "HANGUL SYLLABLE SSYALS");
+-   ("/xec/x8c/xbd", "HANGUL SYLLABLE SSYALT");
+-   ("/xec/x8c/xbe", "HANGUL SYLLABLE SSYALP");
+-   ("/xec/x8c/xbf", "HANGUL SYLLABLE SSYALH");
+-   ("/xec/x8d/x80", "HANGUL SYLLABLE SSYAM");
+-   ("/xec/x8d/x81", "HANGUL SYLLABLE SSYAB");
+-   ("/xec/x8d/x82", "HANGUL SYLLABLE SSYABS");
+-   ("/xec/x8d/x83", "HANGUL SYLLABLE SSYAS");
+-   ("/xec/x8d/x84", "HANGUL SYLLABLE SSYASS");
+-   ("/xec/x8d/x85", "HANGUL SYLLABLE SSYANG");
+-   ("/xec/x8d/x86", "HANGUL SYLLABLE SSYAJ");
+-   ("/xec/x8d/x87", "HANGUL SYLLABLE SSYAC");
+-   ("/xec/x8d/x88", "HANGUL SYLLABLE SSYAK");
+-   ("/xec/x8d/x89", "HANGUL SYLLABLE SSYAT");
+-   ("/xec/x8d/x8a", "HANGUL SYLLABLE SSYAP");
+-   ("/xec/x8d/x8b", "HANGUL SYLLABLE SSYAH");
+-   ("/xec/x8d/x8c", "HANGUL SYLLABLE SSYAE");
+-   ("/xec/x8d/x8d", "HANGUL SYLLABLE SSYAEG");
+-   ("/xec/x8d/x8e", "HANGUL SYLLABLE SSYAEGG");
+-   ("/xec/x8d/x8f", "HANGUL SYLLABLE SSYAEGS");
+-   ("/xec/x8d/x90", "HANGUL SYLLABLE SSYAEN");
+-   ("/xec/x8d/x91", "HANGUL SYLLABLE SSYAENI");
+-   ("/xec/x8d/x92", "HANGUL SYLLABLE SSYAENH");
+-   ("/xec/x8d/x93", "HANGUL SYLLABLE SSYAED");
+-   ("/xec/x8d/x94", "HANGUL SYLLABLE SSYAEL");
+-   ("/xec/x8d/x95", "HANGUL SYLLABLE SSYAELG");
+-   ("/xec/x8d/x96", "HANGUL SYLLABLE SSYAELM");
+-   ("/xec/x8d/x97", "HANGUL SYLLABLE SSYAELB");
+-   ("/xec/x8d/x98", "HANGUL SYLLABLE SSYAELS");
+-   ("/xec/x8d/x99", "HANGUL SYLLABLE SSYAELT");
+-   ("/xec/x8d/x9a", "HANGUL SYLLABLE SSYAELP");
+-   ("/xec/x8d/x9b", "HANGUL SYLLABLE SSYAELH");
+-   ("/xec/x8d/x9c", "HANGUL SYLLABLE SSYAEM");
+-   ("/xec/x8d/x9d", "HANGUL SYLLABLE SSYAEB");
+-   ("/xec/x8d/x9e", "HANGUL SYLLABLE SSYAEBS");
+-   ("/xec/x8d/x9f", "HANGUL SYLLABLE SSYAES");
+-   ("/xec/x8d/xa0", "HANGUL SYLLABLE SSYAESS");
+-   ("/xec/x8d/xa1", "HANGUL SYLLABLE SSYAENG");
+-   ("/xec/x8d/xa2", "HANGUL SYLLABLE SSYAEJ");
+-   ("/xec/x8d/xa3", "HANGUL SYLLABLE SSYAEC");
+-   ("/xec/x8d/xa4", "HANGUL SYLLABLE SSYAEK");
+-   ("/xec/x8d/xa5", "HANGUL SYLLABLE SSYAET");
+-   ("/xec/x8d/xa6", "HANGUL SYLLABLE SSYAEP");
+-   ("/xec/x8d/xa7", "HANGUL SYLLABLE SSYAEH");
+-   ("/xec/x8d/xa8", "HANGUL SYLLABLE SSEO");
+-   ("/xec/x8d/xa9", "HANGUL SYLLABLE SSEOG");
+-   ("/xec/x8d/xaa", "HANGUL SYLLABLE SSEOGG");
+-   ("/xec/x8d/xab", "HANGUL SYLLABLE SSEOGS");
+-   ("/xec/x8d/xac", "HANGUL SYLLABLE SSEON");
+-   ("/xec/x8d/xad", "HANGUL SYLLABLE SSEONI");
+-   ("/xec/x8d/xae", "HANGUL SYLLABLE SSEONH");
+-   ("/xec/x8d/xaf", "HANGUL SYLLABLE SSEOD");
+-   ("/xec/x8d/xb0", "HANGUL SYLLABLE SSEOL");
+-   ("/xec/x8d/xb1", "HANGUL SYLLABLE SSEOLG");
+-   ("/xec/x8d/xb2", "HANGUL SYLLABLE SSEOLM");
+-   ("/xec/x8d/xb3", "HANGUL SYLLABLE SSEOLB");
+-   ("/xec/x8d/xb4", "HANGUL SYLLABLE SSEOLS");
+-   ("/xec/x8d/xb5", "HANGUL SYLLABLE SSEOLT");
+-   ("/xec/x8d/xb6", "HANGUL SYLLABLE SSEOLP");
+-   ("/xec/x8d/xb7", "HANGUL SYLLABLE SSEOLH");
+-   ("/xec/x8d/xb8", "HANGUL SYLLABLE SSEOM");
+-   ("/xec/x8d/xb9", "HANGUL SYLLABLE SSEOB");
+-   ("/xec/x8d/xba", "HANGUL SYLLABLE SSEOBS");
+-   ("/xec/x8d/xbb", "HANGUL SYLLABLE SSEOS");
+-   ("/xec/x8d/xbc", "HANGUL SYLLABLE SSEOSS");
+-   ("/xec/x8d/xbd", "HANGUL SYLLABLE SSEONG");
+-   ("/xec/x8d/xbe", "HANGUL SYLLABLE SSEOJ");
+-   ("/xec/x8d/xbf", "HANGUL SYLLABLE SSEOC");
+-   ("/xec/x8e/x80", "HANGUL SYLLABLE SSEOK");
+-   ("/xec/x8e/x81", "HANGUL SYLLABLE SSEOT");
+-   ("/xec/x8e/x82", "HANGUL SYLLABLE SSEOP");
+-   ("/xec/x8e/x83", "HANGUL SYLLABLE SSEOH");
+-   ("/xec/x8e/x84", "HANGUL SYLLABLE SSE");
+-   ("/xec/x8e/x85", "HANGUL SYLLABLE SSEG");
+-   ("/xec/x8e/x86", "HANGUL SYLLABLE SSEGG");
+-   ("/xec/x8e/x87", "HANGUL SYLLABLE SSEGS");
+-   ("/xec/x8e/x88", "HANGUL SYLLABLE SSEN");
+-   ("/xec/x8e/x89", "HANGUL SYLLABLE SSENI");
+-   ("/xec/x8e/x8a", "HANGUL SYLLABLE SSENH");
+-   ("/xec/x8e/x8b", "HANGUL SYLLABLE SSED");
+-   ("/xec/x8e/x8c", "HANGUL SYLLABLE SSEL");
+-   ("/xec/x8e/x8d", "HANGUL SYLLABLE SSELG");
+-   ("/xec/x8e/x8e", "HANGUL SYLLABLE SSELM");
+-   ("/xec/x8e/x8f", "HANGUL SYLLABLE SSELB");
+-   ("/xec/x8e/x90", "HANGUL SYLLABLE SSELS");
+-   ("/xec/x8e/x91", "HANGUL SYLLABLE SSELT");
+-   ("/xec/x8e/x92", "HANGUL SYLLABLE SSELP");
+-   ("/xec/x8e/x93", "HANGUL SYLLABLE SSELH");
+-   ("/xec/x8e/x94", "HANGUL SYLLABLE SSEM");
+-   ("/xec/x8e/x95", "HANGUL SYLLABLE SSEB");
+-   ("/xec/x8e/x96", "HANGUL SYLLABLE SSEBS");
+-   ("/xec/x8e/x97", "HANGUL SYLLABLE SSES");
+-   ("/xec/x8e/x98", "HANGUL SYLLABLE SSESS");
+-   ("/xec/x8e/x99", "HANGUL SYLLABLE SSENG");
+-   ("/xec/x8e/x9a", "HANGUL SYLLABLE SSEJ");
+-   ("/xec/x8e/x9b", "HANGUL SYLLABLE SSEC");
+-   ("/xec/x8e/x9c", "HANGUL SYLLABLE SSEK");
+-   ("/xec/x8e/x9d", "HANGUL SYLLABLE SSET");
+-   ("/xec/x8e/x9e", "HANGUL SYLLABLE SSEP");
+-   ("/xec/x8e/x9f", "HANGUL SYLLABLE SSEH");
+-   ("/xec/x8e/xa0", "HANGUL SYLLABLE SSYEO");
+-   ("/xec/x8e/xa1", "HANGUL SYLLABLE SSYEOG");
+-   ("/xec/x8e/xa2", "HANGUL SYLLABLE SSYEOGG");
+-   ("/xec/x8e/xa3", "HANGUL SYLLABLE SSYEOGS");
+-   ("/xec/x8e/xa4", "HANGUL SYLLABLE SSYEON");
+-   ("/xec/x8e/xa5", "HANGUL SYLLABLE SSYEONI");
+-   ("/xec/x8e/xa6", "HANGUL SYLLABLE SSYEONH");
+-   ("/xec/x8e/xa7", "HANGUL SYLLABLE SSYEOD");
+-   ("/xec/x8e/xa8", "HANGUL SYLLABLE SSYEOL");
+-   ("/xec/x8e/xa9", "HANGUL SYLLABLE SSYEOLG");
+-   ("/xec/x8e/xaa", "HANGUL SYLLABLE SSYEOLM");
+-   ("/xec/x8e/xab", "HANGUL SYLLABLE SSYEOLB");
+-   ("/xec/x8e/xac", "HANGUL SYLLABLE SSYEOLS");
+-   ("/xec/x8e/xad", "HANGUL SYLLABLE SSYEOLT");
+-   ("/xec/x8e/xae", "HANGUL SYLLABLE SSYEOLP");
+-   ("/xec/x8e/xaf", "HANGUL SYLLABLE SSYEOLH");
+-   ("/xec/x8e/xb0", "HANGUL SYLLABLE SSYEOM");
+-   ("/xec/x8e/xb1", "HANGUL SYLLABLE SSYEOB");
+-   ("/xec/x8e/xb2", "HANGUL SYLLABLE SSYEOBS");
+-   ("/xec/x8e/xb3", "HANGUL SYLLABLE SSYEOS");
+-   ("/xec/x8e/xb4", "HANGUL SYLLABLE SSYEOSS");
+-   ("/xec/x8e/xb5", "HANGUL SYLLABLE SSYEONG");
+-   ("/xec/x8e/xb6", "HANGUL SYLLABLE SSYEOJ");
+-   ("/xec/x8e/xb7", "HANGUL SYLLABLE SSYEOC");
+-   ("/xec/x8e/xb8", "HANGUL SYLLABLE SSYEOK");
+-   ("/xec/x8e/xb9", "HANGUL SYLLABLE SSYEOT");
+-   ("/xec/x8e/xba", "HANGUL SYLLABLE SSYEOP");
+-   ("/xec/x8e/xbb", "HANGUL SYLLABLE SSYEOH");
+-   ("/xec/x8e/xbc", "HANGUL SYLLABLE SSYE");
+-   ("/xec/x8e/xbd", "HANGUL SYLLABLE SSYEG");
+-   ("/xec/x8e/xbe", "HANGUL SYLLABLE SSYEGG");
+-   ("/xec/x8e/xbf", "HANGUL SYLLABLE SSYEGS");
+-   ("/xec/x8f/x80", "HANGUL SYLLABLE SSYEN");
+-   ("/xec/x8f/x81", "HANGUL SYLLABLE SSYENI");
+-   ("/xec/x8f/x82", "HANGUL SYLLABLE SSYENH");
+-   ("/xec/x8f/x83", "HANGUL SYLLABLE SSYED");
+-   ("/xec/x8f/x84", "HANGUL SYLLABLE SSYEL");
+-   ("/xec/x8f/x85", "HANGUL SYLLABLE SSYELG");
+-   ("/xec/x8f/x86", "HANGUL SYLLABLE SSYELM");
+-   ("/xec/x8f/x87", "HANGUL SYLLABLE SSYELB");
+-   ("/xec/x8f/x88", "HANGUL SYLLABLE SSYELS");
+-   ("/xec/x8f/x89", "HANGUL SYLLABLE SSYELT");
+-   ("/xec/x8f/x8a", "HANGUL SYLLABLE SSYELP");
+-   ("/xec/x8f/x8b", "HANGUL SYLLABLE SSYELH");
+-   ("/xec/x8f/x8c", "HANGUL SYLLABLE SSYEM");
+-   ("/xec/x8f/x8d", "HANGUL SYLLABLE SSYEB");
+-   ("/xec/x8f/x8e", "HANGUL SYLLABLE SSYEBS");
+-   ("/xec/x8f/x8f", "HANGUL SYLLABLE SSYES");
+-   ("/xec/x8f/x90", "HANGUL SYLLABLE SSYESS");
+-   ("/xec/x8f/x91", "HANGUL SYLLABLE SSYENG");
+-   ("/xec/x8f/x92", "HANGUL SYLLABLE SSYEJ");
+-   ("/xec/x8f/x93", "HANGUL SYLLABLE SSYEC");
+-   ("/xec/x8f/x94", "HANGUL SYLLABLE SSYEK");
+-   ("/xec/x8f/x95", "HANGUL SYLLABLE SSYET");
+-   ("/xec/x8f/x96", "HANGUL SYLLABLE SSYEP");
+-   ("/xec/x8f/x97", "HANGUL SYLLABLE SSYEH");
+-   ("/xec/x8f/x98", "HANGUL SYLLABLE SSO");
+-   ("/xec/x8f/x99", "HANGUL SYLLABLE SSOG");
+-   ("/xec/x8f/x9a", "HANGUL SYLLABLE SSOGG");
+-   ("/xec/x8f/x9b", "HANGUL SYLLABLE SSOGS");
+-   ("/xec/x8f/x9c", "HANGUL SYLLABLE SSON");
+-   ("/xec/x8f/x9d", "HANGUL SYLLABLE SSONI");
+-   ("/xec/x8f/x9e", "HANGUL SYLLABLE SSONH");
+-   ("/xec/x8f/x9f", "HANGUL SYLLABLE SSOD");
+-   ("/xec/x8f/xa0", "HANGUL SYLLABLE SSOL");
+-   ("/xec/x8f/xa1", "HANGUL SYLLABLE SSOLG");
+-   ("/xec/x8f/xa2", "HANGUL SYLLABLE SSOLM");
+-   ("/xec/x8f/xa3", "HANGUL SYLLABLE SSOLB");
+-   ("/xec/x8f/xa4", "HANGUL SYLLABLE SSOLS");
+-   ("/xec/x8f/xa5", "HANGUL SYLLABLE SSOLT");
+-   ("/xec/x8f/xa6", "HANGUL SYLLABLE SSOLP");
+-   ("/xec/x8f/xa7", "HANGUL SYLLABLE SSOLH");
+-   ("/xec/x8f/xa8", "HANGUL SYLLABLE SSOM");
+-   ("/xec/x8f/xa9", "HANGUL SYLLABLE SSOB");
+-   ("/xec/x8f/xaa", "HANGUL SYLLABLE SSOBS");
+-   ("/xec/x8f/xab", "HANGUL SYLLABLE SSOS");
+-   ("/xec/x8f/xac", "HANGUL SYLLABLE SSOSS");
+-   ("/xec/x8f/xad", "HANGUL SYLLABLE SSONG");
+-   ("/xec/x8f/xae", "HANGUL SYLLABLE SSOJ");
+-   ("/xec/x8f/xaf", "HANGUL SYLLABLE SSOC");
+-   ("/xec/x8f/xb0", "HANGUL SYLLABLE SSOK");
+-   ("/xec/x8f/xb1", "HANGUL SYLLABLE SSOT");
+-   ("/xec/x8f/xb2", "HANGUL SYLLABLE SSOP");
+-   ("/xec/x8f/xb3", "HANGUL SYLLABLE SSOH");
+-   ("/xec/x8f/xb4", "HANGUL SYLLABLE SSWA");
+-   ("/xec/x8f/xb5", "HANGUL SYLLABLE SSWAG");
+-   ("/xec/x8f/xb6", "HANGUL SYLLABLE SSWAGG");
+-   ("/xec/x8f/xb7", "HANGUL SYLLABLE SSWAGS");
+-   ("/xec/x8f/xb8", "HANGUL SYLLABLE SSWAN");
+-   ("/xec/x8f/xb9", "HANGUL SYLLABLE SSWANI");
+-   ("/xec/x8f/xba", "HANGUL SYLLABLE SSWANH");
+-   ("/xec/x8f/xbb", "HANGUL SYLLABLE SSWAD");
+-   ("/xec/x8f/xbc", "HANGUL SYLLABLE SSWAL");
+-   ("/xec/x8f/xbd", "HANGUL SYLLABLE SSWALG");
+-   ("/xec/x8f/xbe", "HANGUL SYLLABLE SSWALM");
+-   ("/xec/x8f/xbf", "HANGUL SYLLABLE SSWALB");
+-   ("/xec/x90/x80", "HANGUL SYLLABLE SSWALS");
+-   ("/xec/x90/x81", "HANGUL SYLLABLE SSWALT");
+-   ("/xec/x90/x82", "HANGUL SYLLABLE SSWALP");
+-   ("/xec/x90/x83", "HANGUL SYLLABLE SSWALH");
+-   ("/xec/x90/x84", "HANGUL SYLLABLE SSWAM");
+-   ("/xec/x90/x85", "HANGUL SYLLABLE SSWAB");
+-   ("/xec/x90/x86", "HANGUL SYLLABLE SSWABS");
+-   ("/xec/x90/x87", "HANGUL SYLLABLE SSWAS");
+-   ("/xec/x90/x88", "HANGUL SYLLABLE SSWASS");
+-   ("/xec/x90/x89", "HANGUL SYLLABLE SSWANG");
+-   ("/xec/x90/x8a", "HANGUL SYLLABLE SSWAJ");
+-   ("/xec/x90/x8b", "HANGUL SYLLABLE SSWAC");
+-   ("/xec/x90/x8c", "HANGUL SYLLABLE SSWAK");
+-   ("/xec/x90/x8d", "HANGUL SYLLABLE SSWAT");
+-   ("/xec/x90/x8e", "HANGUL SYLLABLE SSWAP");
+-   ("/xec/x90/x8f", "HANGUL SYLLABLE SSWAH");
+-   ("/xec/x90/x90", "HANGUL SYLLABLE SSWAE");
+-   ("/xec/x90/x91", "HANGUL SYLLABLE SSWAEG");
+-   ("/xec/x90/x92", "HANGUL SYLLABLE SSWAEGG");
+-   ("/xec/x90/x93", "HANGUL SYLLABLE SSWAEGS");
+-   ("/xec/x90/x94", "HANGUL SYLLABLE SSWAEN");
+-   ("/xec/x90/x95", "HANGUL SYLLABLE SSWAENI");
+-   ("/xec/x90/x96", "HANGUL SYLLABLE SSWAENH");
+-   ("/xec/x90/x97", "HANGUL SYLLABLE SSWAED");
+-   ("/xec/x90/x98", "HANGUL SYLLABLE SSWAEL");
+-   ("/xec/x90/x99", "HANGUL SYLLABLE SSWAELG");
+-   ("/xec/x90/x9a", "HANGUL SYLLABLE SSWAELM");
+-   ("/xec/x90/x9b", "HANGUL SYLLABLE SSWAELB");
+-   ("/xec/x90/x9c", "HANGUL SYLLABLE SSWAELS");
+-   ("/xec/x90/x9d", "HANGUL SYLLABLE SSWAELT");
+-   ("/xec/x90/x9e", "HANGUL SYLLABLE SSWAELP");
+-   ("/xec/x90/x9f", "HANGUL SYLLABLE SSWAELH");
+-   ("/xec/x90/xa0", "HANGUL SYLLABLE SSWAEM");
+-   ("/xec/x90/xa1", "HANGUL SYLLABLE SSWAEB");
+-   ("/xec/x90/xa2", "HANGUL SYLLABLE SSWAEBS");
+-   ("/xec/x90/xa3", "HANGUL SYLLABLE SSWAES");
+-   ("/xec/x90/xa4", "HANGUL SYLLABLE SSWAESS");
+-   ("/xec/x90/xa5", "HANGUL SYLLABLE SSWAENG");
+-   ("/xec/x90/xa6", "HANGUL SYLLABLE SSWAEJ");
+-   ("/xec/x90/xa7", "HANGUL SYLLABLE SSWAEC");
+-   ("/xec/x90/xa8", "HANGUL SYLLABLE SSWAEK");
+-   ("/xec/x90/xa9", "HANGUL SYLLABLE SSWAET");
+-   ("/xec/x90/xaa", "HANGUL SYLLABLE SSWAEP");
+-   ("/xec/x90/xab", "HANGUL SYLLABLE SSWAEH");
+-   ("/xec/x90/xac", "HANGUL SYLLABLE SSOE");
+-   ("/xec/x90/xad", "HANGUL SYLLABLE SSOEG");
+-   ("/xec/x90/xae", "HANGUL SYLLABLE SSOEGG");
+-   ("/xec/x90/xaf", "HANGUL SYLLABLE SSOEGS");
+-   ("/xec/x90/xb0", "HANGUL SYLLABLE SSOEN");
+-   ("/xec/x90/xb1", "HANGUL SYLLABLE SSOENI");
+-   ("/xec/x90/xb2", "HANGUL SYLLABLE SSOENH");
+-   ("/xec/x90/xb3", "HANGUL SYLLABLE SSOED");
+-   ("/xec/x90/xb4", "HANGUL SYLLABLE SSOEL");
+-   ("/xec/x90/xb5", "HANGUL SYLLABLE SSOELG");
+-   ("/xec/x90/xb6", "HANGUL SYLLABLE SSOELM");
+-   ("/xec/x90/xb7", "HANGUL SYLLABLE SSOELB");
+-   ("/xec/x90/xb8", "HANGUL SYLLABLE SSOELS");
+-   ("/xec/x90/xb9", "HANGUL SYLLABLE SSOELT");
+-   ("/xec/x90/xba", "HANGUL SYLLABLE SSOELP");
+-   ("/xec/x90/xbb", "HANGUL SYLLABLE SSOELH");
+-   ("/xec/x90/xbc", "HANGUL SYLLABLE SSOEM");
+-   ("/xec/x90/xbd", "HANGUL SYLLABLE SSOEB");
+-   ("/xec/x90/xbe", "HANGUL SYLLABLE SSOEBS");
+-   ("/xec/x90/xbf", "HANGUL SYLLABLE SSOES");
+-   ("/xec/x91/x80", "HANGUL SYLLABLE SSOESS");
+-   ("/xec/x91/x81", "HANGUL SYLLABLE SSOENG");
+-   ("/xec/x91/x82", "HANGUL SYLLABLE SSOEJ");
+-   ("/xec/x91/x83", "HANGUL SYLLABLE SSOEC");
+-   ("/xec/x91/x84", "HANGUL SYLLABLE SSOEK");
+-   ("/xec/x91/x85", "HANGUL SYLLABLE SSOET");
+-   ("/xec/x91/x86", "HANGUL SYLLABLE SSOEP");
+-   ("/xec/x91/x87", "HANGUL SYLLABLE SSOEH");
+-   ("/xec/x91/x88", "HANGUL SYLLABLE SSYO");
+-   ("/xec/x91/x89", "HANGUL SYLLABLE SSYOG");
+-   ("/xec/x91/x8a", "HANGUL SYLLABLE SSYOGG");
+-   ("/xec/x91/x8b", "HANGUL SYLLABLE SSYOGS");
+-   ("/xec/x91/x8c", "HANGUL SYLLABLE SSYON");
+-   ("/xec/x91/x8d", "HANGUL SYLLABLE SSYONI");
+-   ("/xec/x91/x8e", "HANGUL SYLLABLE SSYONH");
+-   ("/xec/x91/x8f", "HANGUL SYLLABLE SSYOD");
+-   ("/xec/x91/x90", "HANGUL SYLLABLE SSYOL");
+-   ("/xec/x91/x91", "HANGUL SYLLABLE SSYOLG");
+-   ("/xec/x91/x92", "HANGUL SYLLABLE SSYOLM");
+-   ("/xec/x91/x93", "HANGUL SYLLABLE SSYOLB");
+-   ("/xec/x91/x94", "HANGUL SYLLABLE SSYOLS");
+-   ("/xec/x91/x95", "HANGUL SYLLABLE SSYOLT");
+-   ("/xec/x91/x96", "HANGUL SYLLABLE SSYOLP");
+-   ("/xec/x91/x97", "HANGUL SYLLABLE SSYOLH");
+-   ("/xec/x91/x98", "HANGUL SYLLABLE SSYOM");
+-   ("/xec/x91/x99", "HANGUL SYLLABLE SSYOB");
+-   ("/xec/x91/x9a", "HANGUL SYLLABLE SSYOBS");
+-   ("/xec/x91/x9b", "HANGUL SYLLABLE SSYOS");
+-   ("/xec/x91/x9c", "HANGUL SYLLABLE SSYOSS");
+-   ("/xec/x91/x9d", "HANGUL SYLLABLE SSYONG");
+-   ("/xec/x91/x9e", "HANGUL SYLLABLE SSYOJ");
+-   ("/xec/x91/x9f", "HANGUL SYLLABLE SSYOC");
+-   ("/xec/x91/xa0", "HANGUL SYLLABLE SSYOK");
+-   ("/xec/x91/xa1", "HANGUL SYLLABLE SSYOT");
+-   ("/xec/x91/xa2", "HANGUL SYLLABLE SSYOP");
+-   ("/xec/x91/xa3", "HANGUL SYLLABLE SSYOH");
+-   ("/xec/x91/xa4", "HANGUL SYLLABLE SSU");
+-   ("/xec/x91/xa5", "HANGUL SYLLABLE SSUG");
+-   ("/xec/x91/xa6", "HANGUL SYLLABLE SSUGG");
+-   ("/xec/x91/xa7", "HANGUL SYLLABLE SSUGS");
+-   ("/xec/x91/xa8", "HANGUL SYLLABLE SSUN");
+-   ("/xec/x91/xa9", "HANGUL SYLLABLE SSUNI");
+-   ("/xec/x91/xaa", "HANGUL SYLLABLE SSUNH");
+-   ("/xec/x91/xab", "HANGUL SYLLABLE SSUD");
+-   ("/xec/x91/xac", "HANGUL SYLLABLE SSUL");
+-   ("/xec/x91/xad", "HANGUL SYLLABLE SSULG");
+-   ("/xec/x91/xae", "HANGUL SYLLABLE SSULM");
+-   ("/xec/x91/xaf", "HANGUL SYLLABLE SSULB");
+-   ("/xec/x91/xb0", "HANGUL SYLLABLE SSULS");
+-   ("/xec/x91/xb1", "HANGUL SYLLABLE SSULT");
+-   ("/xec/x91/xb2", "HANGUL SYLLABLE SSULP");
+-   ("/xec/x91/xb3", "HANGUL SYLLABLE SSULH");
+-   ("/xec/x91/xb4", "HANGUL SYLLABLE SSUM");
+-   ("/xec/x91/xb5", "HANGUL SYLLABLE SSUB");
+-   ("/xec/x91/xb6", "HANGUL SYLLABLE SSUBS");
+-   ("/xec/x91/xb7", "HANGUL SYLLABLE SSUS");
+-   ("/xec/x91/xb8", "HANGUL SYLLABLE SSUSS");
+-   ("/xec/x91/xb9", "HANGUL SYLLABLE SSUNG");
+-   ("/xec/x91/xba", "HANGUL SYLLABLE SSUJ");
+-   ("/xec/x91/xbb", "HANGUL SYLLABLE SSUC");
+-   ("/xec/x91/xbc", "HANGUL SYLLABLE SSUK");
+-   ("/xec/x91/xbd", "HANGUL SYLLABLE SSUT");
+-   ("/xec/x91/xbe", "HANGUL SYLLABLE SSUP");
+-   ("/xec/x91/xbf", "HANGUL SYLLABLE SSUH");
+-   ("/xec/x92/x80", "HANGUL SYLLABLE SSWEO");
+-   ("/xec/x92/x81", "HANGUL SYLLABLE SSWEOG");
+-   ("/xec/x92/x82", "HANGUL SYLLABLE SSWEOGG");
+-   ("/xec/x92/x83", "HANGUL SYLLABLE SSWEOGS");
+-   ("/xec/x92/x84", "HANGUL SYLLABLE SSWEON");
+-   ("/xec/x92/x85", "HANGUL SYLLABLE SSWEONI");
+-   ("/xec/x92/x86", "HANGUL SYLLABLE SSWEONH");
+-   ("/xec/x92/x87", "HANGUL SYLLABLE SSWEOD");
+-   ("/xec/x92/x88", "HANGUL SYLLABLE SSWEOL");
+-   ("/xec/x92/x89", "HANGUL SYLLABLE SSWEOLG");
+-   ("/xec/x92/x8a", "HANGUL SYLLABLE SSWEOLM");
+-   ("/xec/x92/x8b", "HANGUL SYLLABLE SSWEOLB");
+-   ("/xec/x92/x8c", "HANGUL SYLLABLE SSWEOLS");
+-   ("/xec/x92/x8d", "HANGUL SYLLABLE SSWEOLT");
+-   ("/xec/x92/x8e", "HANGUL SYLLABLE SSWEOLP");
+-   ("/xec/x92/x8f", "HANGUL SYLLABLE SSWEOLH");
+-   ("/xec/x92/x90", "HANGUL SYLLABLE SSWEOM");
+-   ("/xec/x92/x91", "HANGUL SYLLABLE SSWEOB");
+-   ("/xec/x92/x92", "HANGUL SYLLABLE SSWEOBS");
+-   ("/xec/x92/x93", "HANGUL SYLLABLE SSWEOS");
+-   ("/xec/x92/x94", "HANGUL SYLLABLE SSWEOSS");
+-   ("/xec/x92/x95", "HANGUL SYLLABLE SSWEONG");
+-   ("/xec/x92/x96", "HANGUL SYLLABLE SSWEOJ");
+-   ("/xec/x92/x97", "HANGUL SYLLABLE SSWEOC");
+-   ("/xec/x92/x98", "HANGUL SYLLABLE SSWEOK");
+-   ("/xec/x92/x99", "HANGUL SYLLABLE SSWEOT");
+-   ("/xec/x92/x9a", "HANGUL SYLLABLE SSWEOP");
+-   ("/xec/x92/x9b", "HANGUL SYLLABLE SSWEOH");
+-   ("/xec/x92/x9c", "HANGUL SYLLABLE SSWE");
+-   ("/xec/x92/x9d", "HANGUL SYLLABLE SSWEG");
+-   ("/xec/x92/x9e", "HANGUL SYLLABLE SSWEGG");
+-   ("/xec/x92/x9f", "HANGUL SYLLABLE SSWEGS");
+-   ("/xec/x92/xa0", "HANGUL SYLLABLE SSWEN");
+-   ("/xec/x92/xa1", "HANGUL SYLLABLE SSWENI");
+-   ("/xec/x92/xa2", "HANGUL SYLLABLE SSWENH");
+-   ("/xec/x92/xa3", "HANGUL SYLLABLE SSWED");
+-   ("/xec/x92/xa4", "HANGUL SYLLABLE SSWEL");
+-   ("/xec/x92/xa5", "HANGUL SYLLABLE SSWELG");
+-   ("/xec/x92/xa6", "HANGUL SYLLABLE SSWELM");
+-   ("/xec/x92/xa7", "HANGUL SYLLABLE SSWELB");
+-   ("/xec/x92/xa8", "HANGUL SYLLABLE SSWELS");
+-   ("/xec/x92/xa9", "HANGUL SYLLABLE SSWELT");
+-   ("/xec/x92/xaa", "HANGUL SYLLABLE SSWELP");
+-   ("/xec/x92/xab", "HANGUL SYLLABLE SSWELH");
+-   ("/xec/x92/xac", "HANGUL SYLLABLE SSWEM");
+-   ("/xec/x92/xad", "HANGUL SYLLABLE SSWEB");
+-   ("/xec/x92/xae", "HANGUL SYLLABLE SSWEBS");
+-   ("/xec/x92/xaf", "HANGUL SYLLABLE SSWES");
+-   ("/xec/x92/xb0", "HANGUL SYLLABLE SSWESS");
+-   ("/xec/x92/xb1", "HANGUL SYLLABLE SSWENG");
+-   ("/xec/x92/xb2", "HANGUL SYLLABLE SSWEJ");
+-   ("/xec/x92/xb3", "HANGUL SYLLABLE SSWEC");
+-   ("/xec/x92/xb4", "HANGUL SYLLABLE SSWEK");
+-   ("/xec/x92/xb5", "HANGUL SYLLABLE SSWET");
+-   ("/xec/x92/xb6", "HANGUL SYLLABLE SSWEP");
+-   ("/xec/x92/xb7", "HANGUL SYLLABLE SSWEH");
+-   ("/xec/x92/xb8", "HANGUL SYLLABLE SSWI");
+-   ("/xec/x92/xb9", "HANGUL SYLLABLE SSWIG");
+-   ("/xec/x92/xba", "HANGUL SYLLABLE SSWIGG");
+-   ("/xec/x92/xbb", "HANGUL SYLLABLE SSWIGS");
+-   ("/xec/x92/xbc", "HANGUL SYLLABLE SSWIN");
+-   ("/xec/x92/xbd", "HANGUL SYLLABLE SSWINI");
+-   ("/xec/x92/xbe", "HANGUL SYLLABLE SSWINH");
+-   ("/xec/x92/xbf", "HANGUL SYLLABLE SSWID");
+-   ("/xec/x93/x80", "HANGUL SYLLABLE SSWIL");
+-   ("/xec/x93/x81", "HANGUL SYLLABLE SSWILG");
+-   ("/xec/x93/x82", "HANGUL SYLLABLE SSWILM");
+-   ("/xec/x93/x83", "HANGUL SYLLABLE SSWILB");
+-   ("/xec/x93/x84", "HANGUL SYLLABLE SSWILS");
+-   ("/xec/x93/x85", "HANGUL SYLLABLE SSWILT");
+-   ("/xec/x93/x86", "HANGUL SYLLABLE SSWILP");
+-   ("/xec/x93/x87", "HANGUL SYLLABLE SSWILH");
+-   ("/xec/x93/x88", "HANGUL SYLLABLE SSWIM");
+-   ("/xec/x93/x89", "HANGUL SYLLABLE SSWIB");
+-   ("/xec/x93/x8a", "HANGUL SYLLABLE SSWIBS");
+-   ("/xec/x93/x8b", "HANGUL SYLLABLE SSWIS");
+-   ("/xec/x93/x8c", "HANGUL SYLLABLE SSWISS");
+-   ("/xec/x93/x8d", "HANGUL SYLLABLE SSWING");
+-   ("/xec/x93/x8e", "HANGUL SYLLABLE SSWIJ");
+-   ("/xec/x93/x8f", "HANGUL SYLLABLE SSWIC");
+-   ("/xec/x93/x90", "HANGUL SYLLABLE SSWIK");
+-   ("/xec/x93/x91", "HANGUL SYLLABLE SSWIT");
+-   ("/xec/x93/x92", "HANGUL SYLLABLE SSWIP");
+-   ("/xec/x93/x93", "HANGUL SYLLABLE SSWIH");
+-   ("/xec/x93/x94", "HANGUL SYLLABLE SSYU");
+-   ("/xec/x93/x95", "HANGUL SYLLABLE SSYUG");
+-   ("/xec/x93/x96", "HANGUL SYLLABLE SSYUGG");
+-   ("/xec/x93/x97", "HANGUL SYLLABLE SSYUGS");
+-   ("/xec/x93/x98", "HANGUL SYLLABLE SSYUN");
+-   ("/xec/x93/x99", "HANGUL SYLLABLE SSYUNI");
+-   ("/xec/x93/x9a", "HANGUL SYLLABLE SSYUNH");
+-   ("/xec/x93/x9b", "HANGUL SYLLABLE SSYUD");
+-   ("/xec/x93/x9c", "HANGUL SYLLABLE SSYUL");
+-   ("/xec/x93/x9d", "HANGUL SYLLABLE SSYULG");
+-   ("/xec/x93/x9e", "HANGUL SYLLABLE SSYULM");
+-   ("/xec/x93/x9f", "HANGUL SYLLABLE SSYULB");
+-   ("/xec/x93/xa0", "HANGUL SYLLABLE SSYULS");
+-   ("/xec/x93/xa1", "HANGUL SYLLABLE SSYULT");
+-   ("/xec/x93/xa2", "HANGUL SYLLABLE SSYULP");
+-   ("/xec/x93/xa3", "HANGUL SYLLABLE SSYULH");
+-   ("/xec/x93/xa4", "HANGUL SYLLABLE SSYUM");
+-   ("/xec/x93/xa5", "HANGUL SYLLABLE SSYUB");
+-   ("/xec/x93/xa6", "HANGUL SYLLABLE SSYUBS");
+-   ("/xec/x93/xa7", "HANGUL SYLLABLE SSYUS");
+-   ("/xec/x93/xa8", "HANGUL SYLLABLE SSYUSS");
+-   ("/xec/x93/xa9", "HANGUL SYLLABLE SSYUNG");
+-   ("/xec/x93/xaa", "HANGUL SYLLABLE SSYUJ");
+-   ("/xec/x93/xab", "HANGUL SYLLABLE SSYUC");
+-   ("/xec/x93/xac", "HANGUL SYLLABLE SSYUK");
+-   ("/xec/x93/xad", "HANGUL SYLLABLE SSYUT");
+-   ("/xec/x93/xae", "HANGUL SYLLABLE SSYUP");
+-   ("/xec/x93/xaf", "HANGUL SYLLABLE SSYUH");
+-   ("/xec/x93/xb0", "HANGUL SYLLABLE SSEU");
+-   ("/xec/x93/xb1", "HANGUL SYLLABLE SSEUG");
+-   ("/xec/x93/xb2", "HANGUL SYLLABLE SSEUGG");
+-   ("/xec/x93/xb3", "HANGUL SYLLABLE SSEUGS");
+-   ("/xec/x93/xb4", "HANGUL SYLLABLE SSEUN");
+-   ("/xec/x93/xb5", "HANGUL SYLLABLE SSEUNI");
+-   ("/xec/x93/xb6", "HANGUL SYLLABLE SSEUNH");
+-   ("/xec/x93/xb7", "HANGUL SYLLABLE SSEUD");
+-   ("/xec/x93/xb8", "HANGUL SYLLABLE SSEUL");
+-   ("/xec/x93/xb9", "HANGUL SYLLABLE SSEULG");
+-   ("/xec/x93/xba", "HANGUL SYLLABLE SSEULM");
+-   ("/xec/x93/xbb", "HANGUL SYLLABLE SSEULB");
+-   ("/xec/x93/xbc", "HANGUL SYLLABLE SSEULS");
+-   ("/xec/x93/xbd", "HANGUL SYLLABLE SSEULT");
+-   ("/xec/x93/xbe", "HANGUL SYLLABLE SSEULP");
+-   ("/xec/x93/xbf", "HANGUL SYLLABLE SSEULH");
+-   ("/xec/x94/x80", "HANGUL SYLLABLE SSEUM");
+-   ("/xec/x94/x81", "HANGUL SYLLABLE SSEUB");
+-   ("/xec/x94/x82", "HANGUL SYLLABLE SSEUBS");
+-   ("/xec/x94/x83", "HANGUL SYLLABLE SSEUS");
+-   ("/xec/x94/x84", "HANGUL SYLLABLE SSEUSS");
+-   ("/xec/x94/x85", "HANGUL SYLLABLE SSEUNG");
+-   ("/xec/x94/x86", "HANGUL SYLLABLE SSEUJ");
+-   ("/xec/x94/x87", "HANGUL SYLLABLE SSEUC");
+-   ("/xec/x94/x88", "HANGUL SYLLABLE SSEUK");
+-   ("/xec/x94/x89", "HANGUL SYLLABLE SSEUT");
+-   ("/xec/x94/x8a", "HANGUL SYLLABLE SSEUP");
+-   ("/xec/x94/x8b", "HANGUL SYLLABLE SSEUH");
+-   ("/xec/x94/x8c", "HANGUL SYLLABLE SSYI");
+-   ("/xec/x94/x8d", "HANGUL SYLLABLE SSYIG");
+-   ("/xec/x94/x8e", "HANGUL SYLLABLE SSYIGG");
+-   ("/xec/x94/x8f", "HANGUL SYLLABLE SSYIGS");
+-   ("/xec/x94/x90", "HANGUL SYLLABLE SSYIN");
+-   ("/xec/x94/x91", "HANGUL SYLLABLE SSYINI");
+-   ("/xec/x94/x92", "HANGUL SYLLABLE SSYINH");
+-   ("/xec/x94/x93", "HANGUL SYLLABLE SSYID");
+-   ("/xec/x94/x94", "HANGUL SYLLABLE SSYIL");
+-   ("/xec/x94/x95", "HANGUL SYLLABLE SSYILG");
+-   ("/xec/x94/x96", "HANGUL SYLLABLE SSYILM");
+-   ("/xec/x94/x97", "HANGUL SYLLABLE SSYILB");
+-   ("/xec/x94/x98", "HANGUL SYLLABLE SSYILS");
+-   ("/xec/x94/x99", "HANGUL SYLLABLE SSYILT");
+-   ("/xec/x94/x9a", "HANGUL SYLLABLE SSYILP");
+-   ("/xec/x94/x9b", "HANGUL SYLLABLE SSYILH");
+-   ("/xec/x94/x9c", "HANGUL SYLLABLE SSYIM");
+-   ("/xec/x94/x9d", "HANGUL SYLLABLE SSYIB");
+-   ("/xec/x94/x9e", "HANGUL SYLLABLE SSYIBS");
+-   ("/xec/x94/x9f", "HANGUL SYLLABLE SSYIS");
+-   ("/xec/x94/xa0", "HANGUL SYLLABLE SSYISS");
+-   ("/xec/x94/xa1", "HANGUL SYLLABLE SSYING");
+-   ("/xec/x94/xa2", "HANGUL SYLLABLE SSYIJ");
+-   ("/xec/x94/xa3", "HANGUL SYLLABLE SSYIC");
+-   ("/xec/x94/xa4", "HANGUL SYLLABLE SSYIK");
+-   ("/xec/x94/xa5", "HANGUL SYLLABLE SSYIT");
+-   ("/xec/x94/xa6", "HANGUL SYLLABLE SSYIP");
+-   ("/xec/x94/xa7", "HANGUL SYLLABLE SSYIH");
+-   ("/xec/x94/xa8", "HANGUL SYLLABLE SSI");
+-   ("/xec/x94/xa9", "HANGUL SYLLABLE SSIG");
+-   ("/xec/x94/xaa", "HANGUL SYLLABLE SSIGG");
+-   ("/xec/x94/xab", "HANGUL SYLLABLE SSIGS");
+-   ("/xec/x94/xac", "HANGUL SYLLABLE SSIN");
+-   ("/xec/x94/xad", "HANGUL SYLLABLE SSINI");
+-   ("/xec/x94/xae", "HANGUL SYLLABLE SSINH");
+-   ("/xec/x94/xaf", "HANGUL SYLLABLE SSID");
+-   ("/xec/x94/xb0", "HANGUL SYLLABLE SSIL");
+-   ("/xec/x94/xb1", "HANGUL SYLLABLE SSILG");
+-   ("/xec/x94/xb2", "HANGUL SYLLABLE SSILM");
+-   ("/xec/x94/xb3", "HANGUL SYLLABLE SSILB");
+-   ("/xec/x94/xb4", "HANGUL SYLLABLE SSILS");
+-   ("/xec/x94/xb5", "HANGUL SYLLABLE SSILT");
+-   ("/xec/x94/xb6", "HANGUL SYLLABLE SSILP");
+-   ("/xec/x94/xb7", "HANGUL SYLLABLE SSILH");
+-   ("/xec/x94/xb8", "HANGUL SYLLABLE SSIM");
+-   ("/xec/x94/xb9", "HANGUL SYLLABLE SSIB");
+-   ("/xec/x94/xba", "HANGUL SYLLABLE SSIBS");
+-   ("/xec/x94/xbb", "HANGUL SYLLABLE SSIS");
+-   ("/xec/x94/xbc", "HANGUL SYLLABLE SSISS");
+-   ("/xec/x94/xbd", "HANGUL SYLLABLE SSING");
+-   ("/xec/x94/xbe", "HANGUL SYLLABLE SSIJ");
+-   ("/xec/x94/xbf", "HANGUL SYLLABLE SSIC");
+-   ("/xec/x95/x80", "HANGUL SYLLABLE SSIK");
+-   ("/xec/x95/x81", "HANGUL SYLLABLE SSIT");
+-   ("/xec/x95/x82", "HANGUL SYLLABLE SSIP");
+-   ("/xec/x95/x83", "HANGUL SYLLABLE SSIH");
+-   ("/xec/x95/x84", "HANGUL SYLLABLE A");
+-   ("/xec/x95/x85", "HANGUL SYLLABLE AG");
+-   ("/xec/x95/x86", "HANGUL SYLLABLE AGG");
+-   ("/xec/x95/x87", "HANGUL SYLLABLE AGS");
+-   ("/xec/x95/x88", "HANGUL SYLLABLE AN");
+-   ("/xec/x95/x89", "HANGUL SYLLABLE ANI");
+-   ("/xec/x95/x8a", "HANGUL SYLLABLE ANH");
+-   ("/xec/x95/x8b", "HANGUL SYLLABLE AD");
+-   ("/xec/x95/x8c", "HANGUL SYLLABLE AL");
+-   ("/xec/x95/x8d", "HANGUL SYLLABLE ALG");
+-   ("/xec/x95/x8e", "HANGUL SYLLABLE ALM");
+-   ("/xec/x95/x8f", "HANGUL SYLLABLE ALB");
+-   ("/xec/x95/x90", "HANGUL SYLLABLE ALS");
+-   ("/xec/x95/x91", "HANGUL SYLLABLE ALT");
+-   ("/xec/x95/x92", "HANGUL SYLLABLE ALP");
+-   ("/xec/x95/x93", "HANGUL SYLLABLE ALH");
+-   ("/xec/x95/x94", "HANGUL SYLLABLE AM");
+-   ("/xec/x95/x95", "HANGUL SYLLABLE AB");
+-   ("/xec/x95/x96", "HANGUL SYLLABLE ABS");
+-   ("/xec/x95/x97", "HANGUL SYLLABLE AS");
+-   ("/xec/x95/x98", "HANGUL SYLLABLE ASS");
+-   ("/xec/x95/x99", "HANGUL SYLLABLE ANG");
+-   ("/xec/x95/x9a", "HANGUL SYLLABLE AJ");
+-   ("/xec/x95/x9b", "HANGUL SYLLABLE AC");
+-   ("/xec/x95/x9c", "HANGUL SYLLABLE AK");
+-   ("/xec/x95/x9d", "HANGUL SYLLABLE AT");
+-   ("/xec/x95/x9e", "HANGUL SYLLABLE AP");
+-   ("/xec/x95/x9f", "HANGUL SYLLABLE AH");
+-   ("/xec/x95/xa0", "HANGUL SYLLABLE AE");
+-   ("/xec/x95/xa1", "HANGUL SYLLABLE AEG");
+-   ("/xec/x95/xa2", "HANGUL SYLLABLE AEGG");
+-   ("/xec/x95/xa3", "HANGUL SYLLABLE AEGS");
+-   ("/xec/x95/xa4", "HANGUL SYLLABLE AEN");
+-   ("/xec/x95/xa5", "HANGUL SYLLABLE AENI");
+-   ("/xec/x95/xa6", "HANGUL SYLLABLE AENH");
+-   ("/xec/x95/xa7", "HANGUL SYLLABLE AED");
+-   ("/xec/x95/xa8", "HANGUL SYLLABLE AEL");
+-   ("/xec/x95/xa9", "HANGUL SYLLABLE AELG");
+-   ("/xec/x95/xaa", "HANGUL SYLLABLE AELM");
+-   ("/xec/x95/xab", "HANGUL SYLLABLE AELB");
+-   ("/xec/x95/xac", "HANGUL SYLLABLE AELS");
+-   ("/xec/x95/xad", "HANGUL SYLLABLE AELT");
+-   ("/xec/x95/xae", "HANGUL SYLLABLE AELP");
+-   ("/xec/x95/xaf", "HANGUL SYLLABLE AELH");
+-   ("/xec/x95/xb0", "HANGUL SYLLABLE AEM");
+-   ("/xec/x95/xb1", "HANGUL SYLLABLE AEB");
+-   ("/xec/x95/xb2", "HANGUL SYLLABLE AEBS");
+-   ("/xec/x95/xb3", "HANGUL SYLLABLE AES");
+-   ("/xec/x95/xb4", "HANGUL SYLLABLE AESS");
+-   ("/xec/x95/xb5", "HANGUL SYLLABLE AENG");
+-   ("/xec/x95/xb6", "HANGUL SYLLABLE AEJ");
+-   ("/xec/x95/xb7", "HANGUL SYLLABLE AEC");
+-   ("/xec/x95/xb8", "HANGUL SYLLABLE AEK");
+-   ("/xec/x95/xb9", "HANGUL SYLLABLE AET");
+-   ("/xec/x95/xba", "HANGUL SYLLABLE AEP");
+-   ("/xec/x95/xbb", "HANGUL SYLLABLE AEH");
+-   ("/xec/x95/xbc", "HANGUL SYLLABLE YA");
+-   ("/xec/x95/xbd", "HANGUL SYLLABLE YAG");
+-   ("/xec/x95/xbe", "HANGUL SYLLABLE YAGG");
+-   ("/xec/x95/xbf", "HANGUL SYLLABLE YAGS");
+-   ("/xec/x96/x80", "HANGUL SYLLABLE YAN");
+-   ("/xec/x96/x81", "HANGUL SYLLABLE YANI");
+-   ("/xec/x96/x82", "HANGUL SYLLABLE YANH");
+-   ("/xec/x96/x83", "HANGUL SYLLABLE YAD");
+-   ("/xec/x96/x84", "HANGUL SYLLABLE YAL");
+-   ("/xec/x96/x85", "HANGUL SYLLABLE YALG");
+-   ("/xec/x96/x86", "HANGUL SYLLABLE YALM");
+-   ("/xec/x96/x87", "HANGUL SYLLABLE YALB");
+-   ("/xec/x96/x88", "HANGUL SYLLABLE YALS");
+-   ("/xec/x96/x89", "HANGUL SYLLABLE YALT");
+-   ("/xec/x96/x8a", "HANGUL SYLLABLE YALP");
+-   ("/xec/x96/x8b", "HANGUL SYLLABLE YALH");
+-   ("/xec/x96/x8c", "HANGUL SYLLABLE YAM");
+-   ("/xec/x96/x8d", "HANGUL SYLLABLE YAB");
+-   ("/xec/x96/x8e", "HANGUL SYLLABLE YABS");
+-   ("/xec/x96/x8f", "HANGUL SYLLABLE YAS");
+-   ("/xec/x96/x90", "HANGUL SYLLABLE YASS");
+-   ("/xec/x96/x91", "HANGUL SYLLABLE YANG");
+-   ("/xec/x96/x92", "HANGUL SYLLABLE YAJ");
+-   ("/xec/x96/x93", "HANGUL SYLLABLE YAC");
+-   ("/xec/x96/x94", "HANGUL SYLLABLE YAK");
+-   ("/xec/x96/x95", "HANGUL SYLLABLE YAT");
+-   ("/xec/x96/x96", "HANGUL SYLLABLE YAP");
+-   ("/xec/x96/x97", "HANGUL SYLLABLE YAH");
+-   ("/xec/x96/x98", "HANGUL SYLLABLE YAE");
+-   ("/xec/x96/x99", "HANGUL SYLLABLE YAEG");
+-   ("/xec/x96/x9a", "HANGUL SYLLABLE YAEGG");
+-   ("/xec/x96/x9b", "HANGUL SYLLABLE YAEGS");
+-   ("/xec/x96/x9c", "HANGUL SYLLABLE YAEN");
+-   ("/xec/x96/x9d", "HANGUL SYLLABLE YAENI");
+-   ("/xec/x96/x9e", "HANGUL SYLLABLE YAENH");
+-   ("/xec/x96/x9f", "HANGUL SYLLABLE YAED");
+-   ("/xec/x96/xa0", "HANGUL SYLLABLE YAEL");
+-   ("/xec/x96/xa1", "HANGUL SYLLABLE YAELG");
+-   ("/xec/x96/xa2", "HANGUL SYLLABLE YAELM");
+-   ("/xec/x96/xa3", "HANGUL SYLLABLE YAELB");
+-   ("/xec/x96/xa4", "HANGUL SYLLABLE YAELS");
+-   ("/xec/x96/xa5", "HANGUL SYLLABLE YAELT");
+-   ("/xec/x96/xa6", "HANGUL SYLLABLE YAELP");
+-   ("/xec/x96/xa7", "HANGUL SYLLABLE YAELH");
+-   ("/xec/x96/xa8", "HANGUL SYLLABLE YAEM");
+-   ("/xec/x96/xa9", "HANGUL SYLLABLE YAEB");
+-   ("/xec/x96/xaa", "HANGUL SYLLABLE YAEBS");
+-   ("/xec/x96/xab", "HANGUL SYLLABLE YAES");
+-   ("/xec/x96/xac", "HANGUL SYLLABLE YAESS");
+-   ("/xec/x96/xad", "HANGUL SYLLABLE YAENG");
+-   ("/xec/x96/xae", "HANGUL SYLLABLE YAEJ");
+-   ("/xec/x96/xaf", "HANGUL SYLLABLE YAEC");
+-   ("/xec/x96/xb0", "HANGUL SYLLABLE YAEK");
+-   ("/xec/x96/xb1", "HANGUL SYLLABLE YAET");
+-   ("/xec/x96/xb2", "HANGUL SYLLABLE YAEP");
+-   ("/xec/x96/xb3", "HANGUL SYLLABLE YAEH");
+-   ("/xec/x96/xb4", "HANGUL SYLLABLE EO");
+-   ("/xec/x96/xb5", "HANGUL SYLLABLE EOG");
+-   ("/xec/x96/xb6", "HANGUL SYLLABLE EOGG");
+-   ("/xec/x96/xb7", "HANGUL SYLLABLE EOGS");
+-   ("/xec/x96/xb8", "HANGUL SYLLABLE EON");
+-   ("/xec/x96/xb9", "HANGUL SYLLABLE EONI");
+-   ("/xec/x96/xba", "HANGUL SYLLABLE EONH");
+-   ("/xec/x96/xbb", "HANGUL SYLLABLE EOD");
+-   ("/xec/x96/xbc", "HANGUL SYLLABLE EOL");
+-   ("/xec/x96/xbd", "HANGUL SYLLABLE EOLG");
+-   ("/xec/x96/xbe", "HANGUL SYLLABLE EOLM");
+-   ("/xec/x96/xbf", "HANGUL SYLLABLE EOLB");
+-   ("/xec/x97/x80", "HANGUL SYLLABLE EOLS");
+-   ("/xec/x97/x81", "HANGUL SYLLABLE EOLT");
+-   ("/xec/x97/x82", "HANGUL SYLLABLE EOLP");
+-   ("/xec/x97/x83", "HANGUL SYLLABLE EOLH");
+-   ("/xec/x97/x84", "HANGUL SYLLABLE EOM");
+-   ("/xec/x97/x85", "HANGUL SYLLABLE EOB");
+-   ("/xec/x97/x86", "HANGUL SYLLABLE EOBS");
+-   ("/xec/x97/x87", "HANGUL SYLLABLE EOS");
+-   ("/xec/x97/x88", "HANGUL SYLLABLE EOSS");
+-   ("/xec/x97/x89", "HANGUL SYLLABLE EONG");
+-   ("/xec/x97/x8a", "HANGUL SYLLABLE EOJ");
+-   ("/xec/x97/x8b", "HANGUL SYLLABLE EOC");
+-   ("/xec/x97/x8c", "HANGUL SYLLABLE EOK");
+-   ("/xec/x97/x8d", "HANGUL SYLLABLE EOT");
+-   ("/xec/x97/x8e", "HANGUL SYLLABLE EOP");
+-   ("/xec/x97/x8f", "HANGUL SYLLABLE EOH");
+-   ("/xec/x97/x90", "HANGUL SYLLABLE E");
+-   ("/xec/x97/x91", "HANGUL SYLLABLE EG");
+-   ("/xec/x97/x92", "HANGUL SYLLABLE EGG");
+-   ("/xec/x97/x93", "HANGUL SYLLABLE EGS");
+-   ("/xec/x97/x94", "HANGUL SYLLABLE EN");
+-   ("/xec/x97/x95", "HANGUL SYLLABLE ENI");
+-   ("/xec/x97/x96", "HANGUL SYLLABLE ENH");
+-   ("/xec/x97/x97", "HANGUL SYLLABLE ED");
+-   ("/xec/x97/x98", "HANGUL SYLLABLE EL");
+-   ("/xec/x97/x99", "HANGUL SYLLABLE ELG");
+-   ("/xec/x97/x9a", "HANGUL SYLLABLE ELM");
+-   ("/xec/x97/x9b", "HANGUL SYLLABLE ELB");
+-   ("/xec/x97/x9c", "HANGUL SYLLABLE ELS");
+-   ("/xec/x97/x9d", "HANGUL SYLLABLE ELT");
+-   ("/xec/x97/x9e", "HANGUL SYLLABLE ELP");
+-   ("/xec/x97/x9f", "HANGUL SYLLABLE ELH");
+-   ("/xec/x97/xa0", "HANGUL SYLLABLE EM");
+-   ("/xec/x97/xa1", "HANGUL SYLLABLE EB");
+-   ("/xec/x97/xa2", "HANGUL SYLLABLE EBS");
+-   ("/xec/x97/xa3", "HANGUL SYLLABLE ES");
+-   ("/xec/x97/xa4", "HANGUL SYLLABLE ESS");
+-   ("/xec/x97/xa5", "HANGUL SYLLABLE ENG");
+-   ("/xec/x97/xa6", "HANGUL SYLLABLE EJ");
+-   ("/xec/x97/xa7", "HANGUL SYLLABLE EC");
+-   ("/xec/x97/xa8", "HANGUL SYLLABLE EK");
+-   ("/xec/x97/xa9", "HANGUL SYLLABLE ET");
+-   ("/xec/x97/xaa", "HANGUL SYLLABLE EP");
+-   ("/xec/x97/xab", "HANGUL SYLLABLE EH");
+-   ("/xec/x97/xac", "HANGUL SYLLABLE YEO");
+-   ("/xec/x97/xad", "HANGUL SYLLABLE YEOG");
+-   ("/xec/x97/xae", "HANGUL SYLLABLE YEOGG");
+-   ("/xec/x97/xaf", "HANGUL SYLLABLE YEOGS");
+-   ("/xec/x97/xb0", "HANGUL SYLLABLE YEON");
+-   ("/xec/x97/xb1", "HANGUL SYLLABLE YEONI");
+-   ("/xec/x97/xb2", "HANGUL SYLLABLE YEONH");
+-   ("/xec/x97/xb3", "HANGUL SYLLABLE YEOD");
+-   ("/xec/x97/xb4", "HANGUL SYLLABLE YEOL");
+-   ("/xec/x97/xb5", "HANGUL SYLLABLE YEOLG");
+-   ("/xec/x97/xb6", "HANGUL SYLLABLE YEOLM");
+-   ("/xec/x97/xb7", "HANGUL SYLLABLE YEOLB");
+-   ("/xec/x97/xb8", "HANGUL SYLLABLE YEOLS");
+-   ("/xec/x97/xb9", "HANGUL SYLLABLE YEOLT");
+-   ("/xec/x97/xba", "HANGUL SYLLABLE YEOLP");
+-   ("/xec/x97/xbb", "HANGUL SYLLABLE YEOLH");
+-   ("/xec/x97/xbc", "HANGUL SYLLABLE YEOM");
+-   ("/xec/x97/xbd", "HANGUL SYLLABLE YEOB");
+-   ("/xec/x97/xbe", "HANGUL SYLLABLE YEOBS");
+-   ("/xec/x97/xbf", "HANGUL SYLLABLE YEOS");
+-   ("/xec/x98/x80", "HANGUL SYLLABLE YEOSS");
+-   ("/xec/x98/x81", "HANGUL SYLLABLE YEONG");
+-   ("/xec/x98/x82", "HANGUL SYLLABLE YEOJ");
+-   ("/xec/x98/x83", "HANGUL SYLLABLE YEOC");
+-   ("/xec/x98/x84", "HANGUL SYLLABLE YEOK");
+-   ("/xec/x98/x85", "HANGUL SYLLABLE YEOT");
+-   ("/xec/x98/x86", "HANGUL SYLLABLE YEOP");
+-   ("/xec/x98/x87", "HANGUL SYLLABLE YEOH");
+-   ("/xec/x98/x88", "HANGUL SYLLABLE YE");
+-   ("/xec/x98/x89", "HANGUL SYLLABLE YEG");
+-   ("/xec/x98/x8a", "HANGUL SYLLABLE YEGG");
+-   ("/xec/x98/x8b", "HANGUL SYLLABLE YEGS");
+-   ("/xec/x98/x8c", "HANGUL SYLLABLE YEN");
+-   ("/xec/x98/x8d", "HANGUL SYLLABLE YENI");
+-   ("/xec/x98/x8e", "HANGUL SYLLABLE YENH");
+-   ("/xec/x98/x8f", "HANGUL SYLLABLE YED");
+-   ("/xec/x98/x90", "HANGUL SYLLABLE YEL");
+-   ("/xec/x98/x91", "HANGUL SYLLABLE YELG");
+-   ("/xec/x98/x92", "HANGUL SYLLABLE YELM");
+-   ("/xec/x98/x93", "HANGUL SYLLABLE YELB");
+-   ("/xec/x98/x94", "HANGUL SYLLABLE YELS");
+-   ("/xec/x98/x95", "HANGUL SYLLABLE YELT");
+-   ("/xec/x98/x96", "HANGUL SYLLABLE YELP");
+-   ("/xec/x98/x97", "HANGUL SYLLABLE YELH");
+-   ("/xec/x98/x98", "HANGUL SYLLABLE YEM");
+-   ("/xec/x98/x99", "HANGUL SYLLABLE YEB");
+-   ("/xec/x98/x9a", "HANGUL SYLLABLE YEBS");
+-   ("/xec/x98/x9b", "HANGUL SYLLABLE YES");
+-   ("/xec/x98/x9c", "HANGUL SYLLABLE YESS");
+-   ("/xec/x98/x9d", "HANGUL SYLLABLE YENG");
+-   ("/xec/x98/x9e", "HANGUL SYLLABLE YEJ");
+-   ("/xec/x98/x9f", "HANGUL SYLLABLE YEC");
+-   ("/xec/x98/xa0", "HANGUL SYLLABLE YEK");
+-   ("/xec/x98/xa1", "HANGUL SYLLABLE YET");
+-   ("/xec/x98/xa2", "HANGUL SYLLABLE YEP");
+-   ("/xec/x98/xa3", "HANGUL SYLLABLE YEH");
+-   ("/xec/x98/xa4", "HANGUL SYLLABLE O");
+-   ("/xec/x98/xa5", "HANGUL SYLLABLE OG");
+-   ("/xec/x98/xa6", "HANGUL SYLLABLE OGG");
+-   ("/xec/x98/xa7", "HANGUL SYLLABLE OGS");
+-   ("/xec/x98/xa8", "HANGUL SYLLABLE ON");
+-   ("/xec/x98/xa9", "HANGUL SYLLABLE ONI");
+-   ("/xec/x98/xaa", "HANGUL SYLLABLE ONH");
+-   ("/xec/x98/xab", "HANGUL SYLLABLE OD");
+-   ("/xec/x98/xac", "HANGUL SYLLABLE OL");
+-   ("/xec/x98/xad", "HANGUL SYLLABLE OLG");
+-   ("/xec/x98/xae", "HANGUL SYLLABLE OLM");
+-   ("/xec/x98/xaf", "HANGUL SYLLABLE OLB");
+-   ("/xec/x98/xb0", "HANGUL SYLLABLE OLS");
+-   ("/xec/x98/xb1", "HANGUL SYLLABLE OLT");
+-   ("/xec/x98/xb2", "HANGUL SYLLABLE OLP");
+-   ("/xec/x98/xb3", "HANGUL SYLLABLE OLH");
+-   ("/xec/x98/xb4", "HANGUL SYLLABLE OM");
+-   ("/xec/x98/xb5", "HANGUL SYLLABLE OB");
+-   ("/xec/x98/xb6", "HANGUL SYLLABLE OBS");
+-   ("/xec/x98/xb7", "HANGUL SYLLABLE OS");
+-   ("/xec/x98/xb8", "HANGUL SYLLABLE OSS");
+-   ("/xec/x98/xb9", "HANGUL SYLLABLE ONG");
+-   ("/xec/x98/xba", "HANGUL SYLLABLE OJ");
+-   ("/xec/x98/xbb", "HANGUL SYLLABLE OC");
+-   ("/xec/x98/xbc", "HANGUL SYLLABLE OK");
+-   ("/xec/x98/xbd", "HANGUL SYLLABLE OT");
+-   ("/xec/x98/xbe", "HANGUL SYLLABLE OP");
+-   ("/xec/x98/xbf", "HANGUL SYLLABLE OH");
+-   ("/xec/x99/x80", "HANGUL SYLLABLE WA");
+-   ("/xec/x99/x81", "HANGUL SYLLABLE WAG");
+-   ("/xec/x99/x82", "HANGUL SYLLABLE WAGG");
+-   ("/xec/x99/x83", "HANGUL SYLLABLE WAGS");
+-   ("/xec/x99/x84", "HANGUL SYLLABLE WAN");
+-   ("/xec/x99/x85", "HANGUL SYLLABLE WANI");
+-   ("/xec/x99/x86", "HANGUL SYLLABLE WANH");
+-   ("/xec/x99/x87", "HANGUL SYLLABLE WAD");
+-   ("/xec/x99/x88", "HANGUL SYLLABLE WAL");
+-   ("/xec/x99/x89", "HANGUL SYLLABLE WALG");
+-   ("/xec/x99/x8a", "HANGUL SYLLABLE WALM");
+-   ("/xec/x99/x8b", "HANGUL SYLLABLE WALB");
+-   ("/xec/x99/x8c", "HANGUL SYLLABLE WALS");
+-   ("/xec/x99/x8d", "HANGUL SYLLABLE WALT");
+-   ("/xec/x99/x8e", "HANGUL SYLLABLE WALP");
+-   ("/xec/x99/x8f", "HANGUL SYLLABLE WALH");
+-   ("/xec/x99/x90", "HANGUL SYLLABLE WAM");
+-   ("/xec/x99/x91", "HANGUL SYLLABLE WAB");
+-   ("/xec/x99/x92", "HANGUL SYLLABLE WABS");
+-   ("/xec/x99/x93", "HANGUL SYLLABLE WAS");
+-   ("/xec/x99/x94", "HANGUL SYLLABLE WASS");
+-   ("/xec/x99/x95", "HANGUL SYLLABLE WANG");
+-   ("/xec/x99/x96", "HANGUL SYLLABLE WAJ");
+-   ("/xec/x99/x97", "HANGUL SYLLABLE WAC");
+-   ("/xec/x99/x98", "HANGUL SYLLABLE WAK");
+-   ("/xec/x99/x99", "HANGUL SYLLABLE WAT");
+-   ("/xec/x99/x9a", "HANGUL SYLLABLE WAP");
+-   ("/xec/x99/x9b", "HANGUL SYLLABLE WAH");
+-   ("/xec/x99/x9c", "HANGUL SYLLABLE WAE");
+-   ("/xec/x99/x9d", "HANGUL SYLLABLE WAEG");
+-   ("/xec/x99/x9e", "HANGUL SYLLABLE WAEGG");
+-   ("/xec/x99/x9f", "HANGUL SYLLABLE WAEGS");
+-   ("/xec/x99/xa0", "HANGUL SYLLABLE WAEN");
+-   ("/xec/x99/xa1", "HANGUL SYLLABLE WAENI");
+-   ("/xec/x99/xa2", "HANGUL SYLLABLE WAENH");
+-   ("/xec/x99/xa3", "HANGUL SYLLABLE WAED");
+-   ("/xec/x99/xa4", "HANGUL SYLLABLE WAEL");
+-   ("/xec/x99/xa5", "HANGUL SYLLABLE WAELG");
+-   ("/xec/x99/xa6", "HANGUL SYLLABLE WAELM");
+-   ("/xec/x99/xa7", "HANGUL SYLLABLE WAELB");
+-   ("/xec/x99/xa8", "HANGUL SYLLABLE WAELS");
+-   ("/xec/x99/xa9", "HANGUL SYLLABLE WAELT");
+-   ("/xec/x99/xaa", "HANGUL SYLLABLE WAELP");
+-   ("/xec/x99/xab", "HANGUL SYLLABLE WAELH");
+-   ("/xec/x99/xac", "HANGUL SYLLABLE WAEM");
+-   ("/xec/x99/xad", "HANGUL SYLLABLE WAEB");
+-   ("/xec/x99/xae", "HANGUL SYLLABLE WAEBS");
+-   ("/xec/x99/xaf", "HANGUL SYLLABLE WAES");
+-   ("/xec/x99/xb0", "HANGUL SYLLABLE WAESS");
+-   ("/xec/x99/xb1", "HANGUL SYLLABLE WAENG");
+-   ("/xec/x99/xb2", "HANGUL SYLLABLE WAEJ");
+-   ("/xec/x99/xb3", "HANGUL SYLLABLE WAEC");
+-   ("/xec/x99/xb4", "HANGUL SYLLABLE WAEK");
+-   ("/xec/x99/xb5", "HANGUL SYLLABLE WAET");
+-   ("/xec/x99/xb6", "HANGUL SYLLABLE WAEP");
+-   ("/xec/x99/xb7", "HANGUL SYLLABLE WAEH");
+-   ("/xec/x99/xb8", "HANGUL SYLLABLE OE");
+-   ("/xec/x99/xb9", "HANGUL SYLLABLE OEG");
+-   ("/xec/x99/xba", "HANGUL SYLLABLE OEGG");
+-   ("/xec/x99/xbb", "HANGUL SYLLABLE OEGS");
+-   ("/xec/x99/xbc", "HANGUL SYLLABLE OEN");
+-   ("/xec/x99/xbd", "HANGUL SYLLABLE OENI");
+-   ("/xec/x99/xbe", "HANGUL SYLLABLE OENH");
+-   ("/xec/x99/xbf", "HANGUL SYLLABLE OED");
+-   ("/xec/x9a/x80", "HANGUL SYLLABLE OEL");
+-   ("/xec/x9a/x81", "HANGUL SYLLABLE OELG");
+-   ("/xec/x9a/x82", "HANGUL SYLLABLE OELM");
+-   ("/xec/x9a/x83", "HANGUL SYLLABLE OELB");
+-   ("/xec/x9a/x84", "HANGUL SYLLABLE OELS");
+-   ("/xec/x9a/x85", "HANGUL SYLLABLE OELT");
+-   ("/xec/x9a/x86", "HANGUL SYLLABLE OELP");
+-   ("/xec/x9a/x87", "HANGUL SYLLABLE OELH");
+-   ("/xec/x9a/x88", "HANGUL SYLLABLE OEM");
+-   ("/xec/x9a/x89", "HANGUL SYLLABLE OEB");
+-   ("/xec/x9a/x8a", "HANGUL SYLLABLE OEBS");
+-   ("/xec/x9a/x8b", "HANGUL SYLLABLE OES");
+-   ("/xec/x9a/x8c", "HANGUL SYLLABLE OESS");
+-   ("/xec/x9a/x8d", "HANGUL SYLLABLE OENG");
+-   ("/xec/x9a/x8e", "HANGUL SYLLABLE OEJ");
+-   ("/xec/x9a/x8f", "HANGUL SYLLABLE OEC");
+-   ("/xec/x9a/x90", "HANGUL SYLLABLE OEK");
+-   ("/xec/x9a/x91", "HANGUL SYLLABLE OET");
+-   ("/xec/x9a/x92", "HANGUL SYLLABLE OEP");
+-   ("/xec/x9a/x93", "HANGUL SYLLABLE OEH");
+-   ("/xec/x9a/x94", "HANGUL SYLLABLE YO");
+-   ("/xec/x9a/x95", "HANGUL SYLLABLE YOG");
+-   ("/xec/x9a/x96", "HANGUL SYLLABLE YOGG");
+-   ("/xec/x9a/x97", "HANGUL SYLLABLE YOGS");
+-   ("/xec/x9a/x98", "HANGUL SYLLABLE YON");
+-   ("/xec/x9a/x99", "HANGUL SYLLABLE YONI");
+-   ("/xec/x9a/x9a", "HANGUL SYLLABLE YONH");
+-   ("/xec/x9a/x9b", "HANGUL SYLLABLE YOD");
+-   ("/xec/x9a/x9c", "HANGUL SYLLABLE YOL");
+-   ("/xec/x9a/x9d", "HANGUL SYLLABLE YOLG");
+-   ("/xec/x9a/x9e", "HANGUL SYLLABLE YOLM");
+-   ("/xec/x9a/x9f", "HANGUL SYLLABLE YOLB");
+-   ("/xec/x9a/xa0", "HANGUL SYLLABLE YOLS");
+-   ("/xec/x9a/xa1", "HANGUL SYLLABLE YOLT");
+-   ("/xec/x9a/xa2", "HANGUL SYLLABLE YOLP");
+-   ("/xec/x9a/xa3", "HANGUL SYLLABLE YOLH");
+-   ("/xec/x9a/xa4", "HANGUL SYLLABLE YOM");
+-   ("/xec/x9a/xa5", "HANGUL SYLLABLE YOB");
+-   ("/xec/x9a/xa6", "HANGUL SYLLABLE YOBS");
+-   ("/xec/x9a/xa7", "HANGUL SYLLABLE YOS");
+-   ("/xec/x9a/xa8", "HANGUL SYLLABLE YOSS");
+-   ("/xec/x9a/xa9", "HANGUL SYLLABLE YONG");
+-   ("/xec/x9a/xaa", "HANGUL SYLLABLE YOJ");
+-   ("/xec/x9a/xab", "HANGUL SYLLABLE YOC");
+-   ("/xec/x9a/xac", "HANGUL SYLLABLE YOK");
+-   ("/xec/x9a/xad", "HANGUL SYLLABLE YOT");
+-   ("/xec/x9a/xae", "HANGUL SYLLABLE YOP");
+-   ("/xec/x9a/xaf", "HANGUL SYLLABLE YOH");
+-   ("/xec/x9a/xb0", "HANGUL SYLLABLE U");
+-   ("/xec/x9a/xb1", "HANGUL SYLLABLE UG");
+-   ("/xec/x9a/xb2", "HANGUL SYLLABLE UGG");
+-   ("/xec/x9a/xb3", "HANGUL SYLLABLE UGS");
+-   ("/xec/x9a/xb4", "HANGUL SYLLABLE UN");
+-   ("/xec/x9a/xb5", "HANGUL SYLLABLE UNI");
+-   ("/xec/x9a/xb6", "HANGUL SYLLABLE UNH");
+-   ("/xec/x9a/xb7", "HANGUL SYLLABLE UD");
+-   ("/xec/x9a/xb8", "HANGUL SYLLABLE UL");
+-   ("/xec/x9a/xb9", "HANGUL SYLLABLE ULG");
+-   ("/xec/x9a/xba", "HANGUL SYLLABLE ULM");
+-   ("/xec/x9a/xbb", "HANGUL SYLLABLE ULB");
+-   ("/xec/x9a/xbc", "HANGUL SYLLABLE ULS");
+-   ("/xec/x9a/xbd", "HANGUL SYLLABLE ULT");
+-   ("/xec/x9a/xbe", "HANGUL SYLLABLE ULP");
+-   ("/xec/x9a/xbf", "HANGUL SYLLABLE ULH");
+-   ("/xec/x9b/x80", "HANGUL SYLLABLE UM");
+-   ("/xec/x9b/x81", "HANGUL SYLLABLE UB");
+-   ("/xec/x9b/x82", "HANGUL SYLLABLE UBS");
+-   ("/xec/x9b/x83", "HANGUL SYLLABLE US");
+-   ("/xec/x9b/x84", "HANGUL SYLLABLE USS");
+-   ("/xec/x9b/x85", "HANGUL SYLLABLE UNG");
+-   ("/xec/x9b/x86", "HANGUL SYLLABLE UJ");
+-   ("/xec/x9b/x87", "HANGUL SYLLABLE UC");
+-   ("/xec/x9b/x88", "HANGUL SYLLABLE UK");
+-   ("/xec/x9b/x89", "HANGUL SYLLABLE UT");
+-   ("/xec/x9b/x8a", "HANGUL SYLLABLE UP");
+-   ("/xec/x9b/x8b", "HANGUL SYLLABLE UH");
+-   ("/xec/x9b/x8c", "HANGUL SYLLABLE WEO");
+-   ("/xec/x9b/x8d", "HANGUL SYLLABLE WEOG");
+-   ("/xec/x9b/x8e", "HANGUL SYLLABLE WEOGG");
+-   ("/xec/x9b/x8f", "HANGUL SYLLABLE WEOGS");
+-   ("/xec/x9b/x90", "HANGUL SYLLABLE WEON");
+-   ("/xec/x9b/x91", "HANGUL SYLLABLE WEONI");
+-   ("/xec/x9b/x92", "HANGUL SYLLABLE WEONH");
+-   ("/xec/x9b/x93", "HANGUL SYLLABLE WEOD");
+-   ("/xec/x9b/x94", "HANGUL SYLLABLE WEOL");
+-   ("/xec/x9b/x95", "HANGUL SYLLABLE WEOLG");
+-   ("/xec/x9b/x96", "HANGUL SYLLABLE WEOLM");
+-   ("/xec/x9b/x97", "HANGUL SYLLABLE WEOLB");
+-   ("/xec/x9b/x98", "HANGUL SYLLABLE WEOLS");
+-   ("/xec/x9b/x99", "HANGUL SYLLABLE WEOLT");
+-   ("/xec/x9b/x9a", "HANGUL SYLLABLE WEOLP");
+-   ("/xec/x9b/x9b", "HANGUL SYLLABLE WEOLH");
+-   ("/xec/x9b/x9c", "HANGUL SYLLABLE WEOM");
+-   ("/xec/x9b/x9d", "HANGUL SYLLABLE WEOB");
+-   ("/xec/x9b/x9e", "HANGUL SYLLABLE WEOBS");
+-   ("/xec/x9b/x9f", "HANGUL SYLLABLE WEOS");
+-   ("/xec/x9b/xa0", "HANGUL SYLLABLE WEOSS");
+-   ("/xec/x9b/xa1", "HANGUL SYLLABLE WEONG");
+-   ("/xec/x9b/xa2", "HANGUL SYLLABLE WEOJ");
+-   ("/xec/x9b/xa3", "HANGUL SYLLABLE WEOC");
+-   ("/xec/x9b/xa4", "HANGUL SYLLABLE WEOK");
+-   ("/xec/x9b/xa5", "HANGUL SYLLABLE WEOT");
+-   ("/xec/x9b/xa6", "HANGUL SYLLABLE WEOP");
+-   ("/xec/x9b/xa7", "HANGUL SYLLABLE WEOH");
+-   ("/xec/x9b/xa8", "HANGUL SYLLABLE WE");
+-   ("/xec/x9b/xa9", "HANGUL SYLLABLE WEG");
+-   ("/xec/x9b/xaa", "HANGUL SYLLABLE WEGG");
+-   ("/xec/x9b/xab", "HANGUL SYLLABLE WEGS");
+-   ("/xec/x9b/xac", "HANGUL SYLLABLE WEN");
+-   ("/xec/x9b/xad", "HANGUL SYLLABLE WENI");
+-   ("/xec/x9b/xae", "HANGUL SYLLABLE WENH");
+-   ("/xec/x9b/xaf", "HANGUL SYLLABLE WED");
+-   ("/xec/x9b/xb0", "HANGUL SYLLABLE WEL");
+-   ("/xec/x9b/xb1", "HANGUL SYLLABLE WELG");
+-   ("/xec/x9b/xb2", "HANGUL SYLLABLE WELM");
+-   ("/xec/x9b/xb3", "HANGUL SYLLABLE WELB");
+-   ("/xec/x9b/xb4", "HANGUL SYLLABLE WELS");
+-   ("/xec/x9b/xb5", "HANGUL SYLLABLE WELT");
+-   ("/xec/x9b/xb6", "HANGUL SYLLABLE WELP");
+-   ("/xec/x9b/xb7", "HANGUL SYLLABLE WELH");
+-   ("/xec/x9b/xb8", "HANGUL SYLLABLE WEM");
+-   ("/xec/x9b/xb9", "HANGUL SYLLABLE WEB");
+-   ("/xec/x9b/xba", "HANGUL SYLLABLE WEBS");
+-   ("/xec/x9b/xbb", "HANGUL SYLLABLE WES");
+-   ("/xec/x9b/xbc", "HANGUL SYLLABLE WESS");
+-   ("/xec/x9b/xbd", "HANGUL SYLLABLE WENG");
+-   ("/xec/x9b/xbe", "HANGUL SYLLABLE WEJ");
+-   ("/xec/x9b/xbf", "HANGUL SYLLABLE WEC");
+-   ("/xec/x9c/x80", "HANGUL SYLLABLE WEK");
+-   ("/xec/x9c/x81", "HANGUL SYLLABLE WET");
+-   ("/xec/x9c/x82", "HANGUL SYLLABLE WEP");
+-   ("/xec/x9c/x83", "HANGUL SYLLABLE WEH");
+-   ("/xec/x9c/x84", "HANGUL SYLLABLE WI");
+-   ("/xec/x9c/x85", "HANGUL SYLLABLE WIG");
+-   ("/xec/x9c/x86", "HANGUL SYLLABLE WIGG");
+-   ("/xec/x9c/x87", "HANGUL SYLLABLE WIGS");
+-   ("/xec/x9c/x88", "HANGUL SYLLABLE WIN");
+-   ("/xec/x9c/x89", "HANGUL SYLLABLE WINI");
+-   ("/xec/x9c/x8a", "HANGUL SYLLABLE WINH");
+-   ("/xec/x9c/x8b", "HANGUL SYLLABLE WID");
+-   ("/xec/x9c/x8c", "HANGUL SYLLABLE WIL");
+-   ("/xec/x9c/x8d", "HANGUL SYLLABLE WILG");
+-   ("/xec/x9c/x8e", "HANGUL SYLLABLE WILM");
+-   ("/xec/x9c/x8f", "HANGUL SYLLABLE WILB");
+-   ("/xec/x9c/x90", "HANGUL SYLLABLE WILS");
+-   ("/xec/x9c/x91", "HANGUL SYLLABLE WILT");
+-   ("/xec/x9c/x92", "HANGUL SYLLABLE WILP");
+-   ("/xec/x9c/x93", "HANGUL SYLLABLE WILH");
+-   ("/xec/x9c/x94", "HANGUL SYLLABLE WIM");
+-   ("/xec/x9c/x95", "HANGUL SYLLABLE WIB");
+-   ("/xec/x9c/x96", "HANGUL SYLLABLE WIBS");
+-   ("/xec/x9c/x97", "HANGUL SYLLABLE WIS");
+-   ("/xec/x9c/x98", "HANGUL SYLLABLE WISS");
+-   ("/xec/x9c/x99", "HANGUL SYLLABLE WING");
+-   ("/xec/x9c/x9a", "HANGUL SYLLABLE WIJ");
+-   ("/xec/x9c/x9b", "HANGUL SYLLABLE WIC");
+-   ("/xec/x9c/x9c", "HANGUL SYLLABLE WIK");
+-   ("/xec/x9c/x9d", "HANGUL SYLLABLE WIT");
+-   ("/xec/x9c/x9e", "HANGUL SYLLABLE WIP");
+-   ("/xec/x9c/x9f", "HANGUL SYLLABLE WIH");
+-   ("/xec/x9c/xa0", "HANGUL SYLLABLE YU");
+-   ("/xec/x9c/xa1", "HANGUL SYLLABLE YUG");
+-   ("/xec/x9c/xa2", "HANGUL SYLLABLE YUGG");
+-   ("/xec/x9c/xa3", "HANGUL SYLLABLE YUGS");
+-   ("/xec/x9c/xa4", "HANGUL SYLLABLE YUN");
+-   ("/xec/x9c/xa5", "HANGUL SYLLABLE YUNI");
+-   ("/xec/x9c/xa6", "HANGUL SYLLABLE YUNH");
+-   ("/xec/x9c/xa7", "HANGUL SYLLABLE YUD");
+-   ("/xec/x9c/xa8", "HANGUL SYLLABLE YUL");
+-   ("/xec/x9c/xa9", "HANGUL SYLLABLE YULG");
+-   ("/xec/x9c/xaa", "HANGUL SYLLABLE YULM");
+-   ("/xec/x9c/xab", "HANGUL SYLLABLE YULB");
+-   ("/xec/x9c/xac", "HANGUL SYLLABLE YULS");
+-   ("/xec/x9c/xad", "HANGUL SYLLABLE YULT");
+-   ("/xec/x9c/xae", "HANGUL SYLLABLE YULP");
+-   ("/xec/x9c/xaf", "HANGUL SYLLABLE YULH");
+-   ("/xec/x9c/xb0", "HANGUL SYLLABLE YUM");
+-   ("/xec/x9c/xb1", "HANGUL SYLLABLE YUB");
+-   ("/xec/x9c/xb2", "HANGUL SYLLABLE YUBS");
+-   ("/xec/x9c/xb3", "HANGUL SYLLABLE YUS");
+-   ("/xec/x9c/xb4", "HANGUL SYLLABLE YUSS");
+-   ("/xec/x9c/xb5", "HANGUL SYLLABLE YUNG");
+-   ("/xec/x9c/xb6", "HANGUL SYLLABLE YUJ");
+-   ("/xec/x9c/xb7", "HANGUL SYLLABLE YUC");
+-   ("/xec/x9c/xb8", "HANGUL SYLLABLE YUK");
+-   ("/xec/x9c/xb9", "HANGUL SYLLABLE YUT");
+-   ("/xec/x9c/xba", "HANGUL SYLLABLE YUP");
+-   ("/xec/x9c/xbb", "HANGUL SYLLABLE YUH");
+-   ("/xec/x9c/xbc", "HANGUL SYLLABLE EU");
+-   ("/xec/x9c/xbd", "HANGUL SYLLABLE EUG");
+-   ("/xec/x9c/xbe", "HANGUL SYLLABLE EUGG");
+-   ("/xec/x9c/xbf", "HANGUL SYLLABLE EUGS");
+-   ("/xec/x9d/x80", "HANGUL SYLLABLE EUN");
+-   ("/xec/x9d/x81", "HANGUL SYLLABLE EUNI");
+-   ("/xec/x9d/x82", "HANGUL SYLLABLE EUNH");
+-   ("/xec/x9d/x83", "HANGUL SYLLABLE EUD");
+-   ("/xec/x9d/x84", "HANGUL SYLLABLE EUL");
+-   ("/xec/x9d/x85", "HANGUL SYLLABLE EULG");
+-   ("/xec/x9d/x86", "HANGUL SYLLABLE EULM");
+-   ("/xec/x9d/x87", "HANGUL SYLLABLE EULB");
+-   ("/xec/x9d/x88", "HANGUL SYLLABLE EULS");
+-   ("/xec/x9d/x89", "HANGUL SYLLABLE EULT");
+-   ("/xec/x9d/x8a", "HANGUL SYLLABLE EULP");
+-   ("/xec/x9d/x8b", "HANGUL SYLLABLE EULH");
+-   ("/xec/x9d/x8c", "HANGUL SYLLABLE EUM");
+-   ("/xec/x9d/x8d", "HANGUL SYLLABLE EUB");
+-   ("/xec/x9d/x8e", "HANGUL SYLLABLE EUBS");
+-   ("/xec/x9d/x8f", "HANGUL SYLLABLE EUS");
+-   ("/xec/x9d/x90", "HANGUL SYLLABLE EUSS");
+-   ("/xec/x9d/x91", "HANGUL SYLLABLE EUNG");
+-   ("/xec/x9d/x92", "HANGUL SYLLABLE EUJ");
+-   ("/xec/x9d/x93", "HANGUL SYLLABLE EUC");
+-   ("/xec/x9d/x94", "HANGUL SYLLABLE EUK");
+-   ("/xec/x9d/x95", "HANGUL SYLLABLE EUT");
+-   ("/xec/x9d/x96", "HANGUL SYLLABLE EUP");
+-   ("/xec/x9d/x97", "HANGUL SYLLABLE EUH");
+-   ("/xec/x9d/x98", "HANGUL SYLLABLE YI");
+-   ("/xec/x9d/x99", "HANGUL SYLLABLE YIG");
+-   ("/xec/x9d/x9a", "HANGUL SYLLABLE YIGG");
+-   ("/xec/x9d/x9b", "HANGUL SYLLABLE YIGS");
+-   ("/xec/x9d/x9c", "HANGUL SYLLABLE YIN");
+-   ("/xec/x9d/x9d", "HANGUL SYLLABLE YINI");
+-   ("/xec/x9d/x9e", "HANGUL SYLLABLE YINH");
+-   ("/xec/x9d/x9f", "HANGUL SYLLABLE YID");
+-   ("/xec/x9d/xa0", "HANGUL SYLLABLE YIL");
+-   ("/xec/x9d/xa1", "HANGUL SYLLABLE YILG");
+-   ("/xec/x9d/xa2", "HANGUL SYLLABLE YILM");
+-   ("/xec/x9d/xa3", "HANGUL SYLLABLE YILB");
+-   ("/xec/x9d/xa4", "HANGUL SYLLABLE YILS");
+-   ("/xec/x9d/xa5", "HANGUL SYLLABLE YILT");
+-   ("/xec/x9d/xa6", "HANGUL SYLLABLE YILP");
+-   ("/xec/x9d/xa7", "HANGUL SYLLABLE YILH");
+-   ("/xec/x9d/xa8", "HANGUL SYLLABLE YIM");
+-   ("/xec/x9d/xa9", "HANGUL SYLLABLE YIB");
+-   ("/xec/x9d/xaa", "HANGUL SYLLABLE YIBS");
+-   ("/xec/x9d/xab", "HANGUL SYLLABLE YIS");
+-   ("/xec/x9d/xac", "HANGUL SYLLABLE YISS");
+-   ("/xec/x9d/xad", "HANGUL SYLLABLE YING");
+-   ("/xec/x9d/xae", "HANGUL SYLLABLE YIJ");
+-   ("/xec/x9d/xaf", "HANGUL SYLLABLE YIC");
+-   ("/xec/x9d/xb0", "HANGUL SYLLABLE YIK");
+-   ("/xec/x9d/xb1", "HANGUL SYLLABLE YIT");
+-   ("/xec/x9d/xb2", "HANGUL SYLLABLE YIP");
+-   ("/xec/x9d/xb3", "HANGUL SYLLABLE YIH");
+-   ("/xec/x9d/xb4", "HANGUL SYLLABLE I");
+-   ("/xec/x9d/xb5", "HANGUL SYLLABLE IG");
+-   ("/xec/x9d/xb6", "HANGUL SYLLABLE IGG");
+-   ("/xec/x9d/xb7", "HANGUL SYLLABLE IGS");
+-   ("/xec/x9d/xb8", "HANGUL SYLLABLE IN");
+-   ("/xec/x9d/xb9", "HANGUL SYLLABLE INI");
+-   ("/xec/x9d/xba", "HANGUL SYLLABLE INH");
+-   ("/xec/x9d/xbb", "HANGUL SYLLABLE ID");
+-   ("/xec/x9d/xbc", "HANGUL SYLLABLE IL");
+-   ("/xec/x9d/xbd", "HANGUL SYLLABLE ILG");
+-   ("/xec/x9d/xbe", "HANGUL SYLLABLE ILM");
+-   ("/xec/x9d/xbf", "HANGUL SYLLABLE ILB");
+-   ("/xec/x9e/x80", "HANGUL SYLLABLE ILS");
+-   ("/xec/x9e/x81", "HANGUL SYLLABLE ILT");
+-   ("/xec/x9e/x82", "HANGUL SYLLABLE ILP");
+-   ("/xec/x9e/x83", "HANGUL SYLLABLE ILH");
+-   ("/xec/x9e/x84", "HANGUL SYLLABLE IM");
+-   ("/xec/x9e/x85", "HANGUL SYLLABLE IB");
+-   ("/xec/x9e/x86", "HANGUL SYLLABLE IBS");
+-   ("/xec/x9e/x87", "HANGUL SYLLABLE IS");
+-   ("/xec/x9e/x88", "HANGUL SYLLABLE ISS");
+-   ("/xec/x9e/x89", "HANGUL SYLLABLE ING");
+-   ("/xec/x9e/x8a", "HANGUL SYLLABLE IJ");
+-   ("/xec/x9e/x8b", "HANGUL SYLLABLE IC");
+-   ("/xec/x9e/x8c", "HANGUL SYLLABLE IK");
+-   ("/xec/x9e/x8d", "HANGUL SYLLABLE IT");
+-   ("/xec/x9e/x8e", "HANGUL SYLLABLE IP");
+-   ("/xec/x9e/x8f", "HANGUL SYLLABLE IH");
+-   ("/xec/x9e/x90", "HANGUL SYLLABLE JA");
+-   ("/xec/x9e/x91", "HANGUL SYLLABLE JAG");
+-   ("/xec/x9e/x92", "HANGUL SYLLABLE JAGG");
+-   ("/xec/x9e/x93", "HANGUL SYLLABLE JAGS");
+-   ("/xec/x9e/x94", "HANGUL SYLLABLE JAN");
+-   ("/xec/x9e/x95", "HANGUL SYLLABLE JANI");
+-   ("/xec/x9e/x96", "HANGUL SYLLABLE JANH");
+-   ("/xec/x9e/x97", "HANGUL SYLLABLE JAD");
+-   ("/xec/x9e/x98", "HANGUL SYLLABLE JAL");
+-   ("/xec/x9e/x99", "HANGUL SYLLABLE JALG");
+-   ("/xec/x9e/x9a", "HANGUL SYLLABLE JALM");
+-   ("/xec/x9e/x9b", "HANGUL SYLLABLE JALB");
+-   ("/xec/x9e/x9c", "HANGUL SYLLABLE JALS");
+-   ("/xec/x9e/x9d", "HANGUL SYLLABLE JALT");
+-   ("/xec/x9e/x9e", "HANGUL SYLLABLE JALP");
+-   ("/xec/x9e/x9f", "HANGUL SYLLABLE JALH");
+-   ("/xec/x9e/xa0", "HANGUL SYLLABLE JAM");
+-   ("/xec/x9e/xa1", "HANGUL SYLLABLE JAB");
+-   ("/xec/x9e/xa2", "HANGUL SYLLABLE JABS");
+-   ("/xec/x9e/xa3", "HANGUL SYLLABLE JAS");
+-   ("/xec/x9e/xa4", "HANGUL SYLLABLE JASS");
+-   ("/xec/x9e/xa5", "HANGUL SYLLABLE JANG");
+-   ("/xec/x9e/xa6", "HANGUL SYLLABLE JAJ");
+-   ("/xec/x9e/xa7", "HANGUL SYLLABLE JAC");
+-   ("/xec/x9e/xa8", "HANGUL SYLLABLE JAK");
+-   ("/xec/x9e/xa9", "HANGUL SYLLABLE JAT");
+-   ("/xec/x9e/xaa", "HANGUL SYLLABLE JAP");
+-   ("/xec/x9e/xab", "HANGUL SYLLABLE JAH");
+-   ("/xec/x9e/xac", "HANGUL SYLLABLE JAE");
+-   ("/xec/x9e/xad", "HANGUL SYLLABLE JAEG");
+-   ("/xec/x9e/xae", "HANGUL SYLLABLE JAEGG");
+-   ("/xec/x9e/xaf", "HANGUL SYLLABLE JAEGS");
+-   ("/xec/x9e/xb0", "HANGUL SYLLABLE JAEN");
+-   ("/xec/x9e/xb1", "HANGUL SYLLABLE JAENI");
+-   ("/xec/x9e/xb2", "HANGUL SYLLABLE JAENH");
+-   ("/xec/x9e/xb3", "HANGUL SYLLABLE JAED");
+-   ("/xec/x9e/xb4", "HANGUL SYLLABLE JAEL");
+-   ("/xec/x9e/xb5", "HANGUL SYLLABLE JAELG");
+-   ("/xec/x9e/xb6", "HANGUL SYLLABLE JAELM");
+-   ("/xec/x9e/xb7", "HANGUL SYLLABLE JAELB");
+-   ("/xec/x9e/xb8", "HANGUL SYLLABLE JAELS");
+-   ("/xec/x9e/xb9", "HANGUL SYLLABLE JAELT");
+-   ("/xec/x9e/xba", "HANGUL SYLLABLE JAELP");
+-   ("/xec/x9e/xbb", "HANGUL SYLLABLE JAELH");
+-   ("/xec/x9e/xbc", "HANGUL SYLLABLE JAEM");
+-   ("/xec/x9e/xbd", "HANGUL SYLLABLE JAEB");
+-   ("/xec/x9e/xbe", "HANGUL SYLLABLE JAEBS");
+-   ("/xec/x9e/xbf", "HANGUL SYLLABLE JAES");
+-   ("/xec/x9f/x80", "HANGUL SYLLABLE JAESS");
+-   ("/xec/x9f/x81", "HANGUL SYLLABLE JAENG");
+-   ("/xec/x9f/x82", "HANGUL SYLLABLE JAEJ");
+-   ("/xec/x9f/x83", "HANGUL SYLLABLE JAEC");
+-   ("/xec/x9f/x84", "HANGUL SYLLABLE JAEK");
+-   ("/xec/x9f/x85", "HANGUL SYLLABLE JAET");
+-   ("/xec/x9f/x86", "HANGUL SYLLABLE JAEP");
+-   ("/xec/x9f/x87", "HANGUL SYLLABLE JAEH");
+-   ("/xec/x9f/x88", "HANGUL SYLLABLE JYA");
+-   ("/xec/x9f/x89", "HANGUL SYLLABLE JYAG");
+-   ("/xec/x9f/x8a", "HANGUL SYLLABLE JYAGG");
+-   ("/xec/x9f/x8b", "HANGUL SYLLABLE JYAGS");
+-   ("/xec/x9f/x8c", "HANGUL SYLLABLE JYAN");
+-   ("/xec/x9f/x8d", "HANGUL SYLLABLE JYANI");
+-   ("/xec/x9f/x8e", "HANGUL SYLLABLE JYANH");
+-   ("/xec/x9f/x8f", "HANGUL SYLLABLE JYAD");
+-   ("/xec/x9f/x90", "HANGUL SYLLABLE JYAL");
+-   ("/xec/x9f/x91", "HANGUL SYLLABLE JYALG");
+-   ("/xec/x9f/x92", "HANGUL SYLLABLE JYALM");
+-   ("/xec/x9f/x93", "HANGUL SYLLABLE JYALB");
+-   ("/xec/x9f/x94", "HANGUL SYLLABLE JYALS");
+-   ("/xec/x9f/x95", "HANGUL SYLLABLE JYALT");
+-   ("/xec/x9f/x96", "HANGUL SYLLABLE JYALP");
+-   ("/xec/x9f/x97", "HANGUL SYLLABLE JYALH");
+-   ("/xec/x9f/x98", "HANGUL SYLLABLE JYAM");
+-   ("/xec/x9f/x99", "HANGUL SYLLABLE JYAB");
+-   ("/xec/x9f/x9a", "HANGUL SYLLABLE JYABS");
+-   ("/xec/x9f/x9b", "HANGUL SYLLABLE JYAS");
+-   ("/xec/x9f/x9c", "HANGUL SYLLABLE JYASS");
+-   ("/xec/x9f/x9d", "HANGUL SYLLABLE JYANG");
+-   ("/xec/x9f/x9e", "HANGUL SYLLABLE JYAJ");
+-   ("/xec/x9f/x9f", "HANGUL SYLLABLE JYAC");
+-   ("/xec/x9f/xa0", "HANGUL SYLLABLE JYAK");
+-   ("/xec/x9f/xa1", "HANGUL SYLLABLE JYAT");
+-   ("/xec/x9f/xa2", "HANGUL SYLLABLE JYAP");
+-   ("/xec/x9f/xa3", "HANGUL SYLLABLE JYAH");
+-   ("/xec/x9f/xa4", "HANGUL SYLLABLE JYAE");
+-   ("/xec/x9f/xa5", "HANGUL SYLLABLE JYAEG");
+-   ("/xec/x9f/xa6", "HANGUL SYLLABLE JYAEGG");
+-   ("/xec/x9f/xa7", "HANGUL SYLLABLE JYAEGS");
+-   ("/xec/x9f/xa8", "HANGUL SYLLABLE JYAEN");
+-   ("/xec/x9f/xa9", "HANGUL SYLLABLE JYAENI");
+-   ("/xec/x9f/xaa", "HANGUL SYLLABLE JYAENH");
+-   ("/xec/x9f/xab", "HANGUL SYLLABLE JYAED");
+-   ("/xec/x9f/xac", "HANGUL SYLLABLE JYAEL");
+-   ("/xec/x9f/xad", "HANGUL SYLLABLE JYAELG");
+-   ("/xec/x9f/xae", "HANGUL SYLLABLE JYAELM");
+-   ("/xec/x9f/xaf", "HANGUL SYLLABLE JYAELB");
+-   ("/xec/x9f/xb0", "HANGUL SYLLABLE JYAELS");
+-   ("/xec/x9f/xb1", "HANGUL SYLLABLE JYAELT");
+-   ("/xec/x9f/xb2", "HANGUL SYLLABLE JYAELP");
+-   ("/xec/x9f/xb3", "HANGUL SYLLABLE JYAELH");
+-   ("/xec/x9f/xb4", "HANGUL SYLLABLE JYAEM");
+-   ("/xec/x9f/xb5", "HANGUL SYLLABLE JYAEB");
+-   ("/xec/x9f/xb6", "HANGUL SYLLABLE JYAEBS");
+-   ("/xec/x9f/xb7", "HANGUL SYLLABLE JYAES");
+-   ("/xec/x9f/xb8", "HANGUL SYLLABLE JYAESS");
+-   ("/xec/x9f/xb9", "HANGUL SYLLABLE JYAENG");
+-   ("/xec/x9f/xba", "HANGUL SYLLABLE JYAEJ");
+-   ("/xec/x9f/xbb", "HANGUL SYLLABLE JYAEC");
+-   ("/xec/x9f/xbc", "HANGUL SYLLABLE JYAEK");
+-   ("/xec/x9f/xbd", "HANGUL SYLLABLE JYAET");
+-   ("/xec/x9f/xbe", "HANGUL SYLLABLE JYAEP");
+-   ("/xec/x9f/xbf", "HANGUL SYLLABLE JYAEH");
+-   ("/xec/xa0/x80", "HANGUL SYLLABLE JEO");
+-   ("/xec/xa0/x81", "HANGUL SYLLABLE JEOG");
+-   ("/xec/xa0/x82", "HANGUL SYLLABLE JEOGG");
+-   ("/xec/xa0/x83", "HANGUL SYLLABLE JEOGS");
+-   ("/xec/xa0/x84", "HANGUL SYLLABLE JEON");
+-   ("/xec/xa0/x85", "HANGUL SYLLABLE JEONI");
+-   ("/xec/xa0/x86", "HANGUL SYLLABLE JEONH");
+-   ("/xec/xa0/x87", "HANGUL SYLLABLE JEOD");
+-   ("/xec/xa0/x88", "HANGUL SYLLABLE JEOL");
+-   ("/xec/xa0/x89", "HANGUL SYLLABLE JEOLG");
+-   ("/xec/xa0/x8a", "HANGUL SYLLABLE JEOLM");
+-   ("/xec/xa0/x8b", "HANGUL SYLLABLE JEOLB");
+-   ("/xec/xa0/x8c", "HANGUL SYLLABLE JEOLS");
+-   ("/xec/xa0/x8d", "HANGUL SYLLABLE JEOLT");
+-   ("/xec/xa0/x8e", "HANGUL SYLLABLE JEOLP");
+-   ("/xec/xa0/x8f", "HANGUL SYLLABLE JEOLH");
+-   ("/xec/xa0/x90", "HANGUL SYLLABLE JEOM");
+-   ("/xec/xa0/x91", "HANGUL SYLLABLE JEOB");
+-   ("/xec/xa0/x92", "HANGUL SYLLABLE JEOBS");
+-   ("/xec/xa0/x93", "HANGUL SYLLABLE JEOS");
+-   ("/xec/xa0/x94", "HANGUL SYLLABLE JEOSS");
+-   ("/xec/xa0/x95", "HANGUL SYLLABLE JEONG");
+-   ("/xec/xa0/x96", "HANGUL SYLLABLE JEOJ");
+-   ("/xec/xa0/x97", "HANGUL SYLLABLE JEOC");
+-   ("/xec/xa0/x98", "HANGUL SYLLABLE JEOK");
+-   ("/xec/xa0/x99", "HANGUL SYLLABLE JEOT");
+-   ("/xec/xa0/x9a", "HANGUL SYLLABLE JEOP");
+-   ("/xec/xa0/x9b", "HANGUL SYLLABLE JEOH");
+-   ("/xec/xa0/x9c", "HANGUL SYLLABLE JE");
+-   ("/xec/xa0/x9d", "HANGUL SYLLABLE JEG");
+-   ("/xec/xa0/x9e", "HANGUL SYLLABLE JEGG");
+-   ("/xec/xa0/x9f", "HANGUL SYLLABLE JEGS");
+-   ("/xec/xa0/xa0", "HANGUL SYLLABLE JEN");
+-   ("/xec/xa0/xa1", "HANGUL SYLLABLE JENI");
+-   ("/xec/xa0/xa2", "HANGUL SYLLABLE JENH");
+-   ("/xec/xa0/xa3", "HANGUL SYLLABLE JED");
+-   ("/xec/xa0/xa4", "HANGUL SYLLABLE JEL");
+-   ("/xec/xa0/xa5", "HANGUL SYLLABLE JELG");
+-   ("/xec/xa0/xa6", "HANGUL SYLLABLE JELM");
+-   ("/xec/xa0/xa7", "HANGUL SYLLABLE JELB");
+-   ("/xec/xa0/xa8", "HANGUL SYLLABLE JELS");
+-   ("/xec/xa0/xa9", "HANGUL SYLLABLE JELT");
+-   ("/xec/xa0/xaa", "HANGUL SYLLABLE JELP");
+-   ("/xec/xa0/xab", "HANGUL SYLLABLE JELH");
+-   ("/xec/xa0/xac", "HANGUL SYLLABLE JEM");
+-   ("/xec/xa0/xad", "HANGUL SYLLABLE JEB");
+-   ("/xec/xa0/xae", "HANGUL SYLLABLE JEBS");
+-   ("/xec/xa0/xaf", "HANGUL SYLLABLE JES");
+-   ("/xec/xa0/xb0", "HANGUL SYLLABLE JESS");
+-   ("/xec/xa0/xb1", "HANGUL SYLLABLE JENG");
+-   ("/xec/xa0/xb2", "HANGUL SYLLABLE JEJ");
+-   ("/xec/xa0/xb3", "HANGUL SYLLABLE JEC");
+-   ("/xec/xa0/xb4", "HANGUL SYLLABLE JEK");
+-   ("/xec/xa0/xb5", "HANGUL SYLLABLE JET");
+-   ("/xec/xa0/xb6", "HANGUL SYLLABLE JEP");
+-   ("/xec/xa0/xb7", "HANGUL SYLLABLE JEH");
+-   ("/xec/xa0/xb8", "HANGUL SYLLABLE JYEO");
+-   ("/xec/xa0/xb9", "HANGUL SYLLABLE JYEOG");
+-   ("/xec/xa0/xba", "HANGUL SYLLABLE JYEOGG");
+-   ("/xec/xa0/xbb", "HANGUL SYLLABLE JYEOGS");
+-   ("/xec/xa0/xbc", "HANGUL SYLLABLE JYEON");
+-   ("/xec/xa0/xbd", "HANGUL SYLLABLE JYEONI");
+-   ("/xec/xa0/xbe", "HANGUL SYLLABLE JYEONH");
+-   ("/xec/xa0/xbf", "HANGUL SYLLABLE JYEOD");
+-   ("/xec/xa1/x80", "HANGUL SYLLABLE JYEOL");
+-   ("/xec/xa1/x81", "HANGUL SYLLABLE JYEOLG");
+-   ("/xec/xa1/x82", "HANGUL SYLLABLE JYEOLM");
+-   ("/xec/xa1/x83", "HANGUL SYLLABLE JYEOLB");
+-   ("/xec/xa1/x84", "HANGUL SYLLABLE JYEOLS");
+-   ("/xec/xa1/x85", "HANGUL SYLLABLE JYEOLT");
+-   ("/xec/xa1/x86", "HANGUL SYLLABLE JYEOLP");
+-   ("/xec/xa1/x87", "HANGUL SYLLABLE JYEOLH");
+-   ("/xec/xa1/x88", "HANGUL SYLLABLE JYEOM");
+-   ("/xec/xa1/x89", "HANGUL SYLLABLE JYEOB");
+-   ("/xec/xa1/x8a", "HANGUL SYLLABLE JYEOBS");
+-   ("/xec/xa1/x8b", "HANGUL SYLLABLE JYEOS");
+-   ("/xec/xa1/x8c", "HANGUL SYLLABLE JYEOSS");
+-   ("/xec/xa1/x8d", "HANGUL SYLLABLE JYEONG");
+-   ("/xec/xa1/x8e", "HANGUL SYLLABLE JYEOJ");
+-   ("/xec/xa1/x8f", "HANGUL SYLLABLE JYEOC");
+-   ("/xec/xa1/x90", "HANGUL SYLLABLE JYEOK");
+-   ("/xec/xa1/x91", "HANGUL SYLLABLE JYEOT");
+-   ("/xec/xa1/x92", "HANGUL SYLLABLE JYEOP");
+-   ("/xec/xa1/x93", "HANGUL SYLLABLE JYEOH");
+-   ("/xec/xa1/x94", "HANGUL SYLLABLE JYE");
+-   ("/xec/xa1/x95", "HANGUL SYLLABLE JYEG");
+-   ("/xec/xa1/x96", "HANGUL SYLLABLE JYEGG");
+-   ("/xec/xa1/x97", "HANGUL SYLLABLE JYEGS");
+-   ("/xec/xa1/x98", "HANGUL SYLLABLE JYEN");
+-   ("/xec/xa1/x99", "HANGUL SYLLABLE JYENI");
+-   ("/xec/xa1/x9a", "HANGUL SYLLABLE JYENH");
+-   ("/xec/xa1/x9b", "HANGUL SYLLABLE JYED");
+-   ("/xec/xa1/x9c", "HANGUL SYLLABLE JYEL");
+-   ("/xec/xa1/x9d", "HANGUL SYLLABLE JYELG");
+-   ("/xec/xa1/x9e", "HANGUL SYLLABLE JYELM");
+-   ("/xec/xa1/x9f", "HANGUL SYLLABLE JYELB");
+-   ("/xec/xa1/xa0", "HANGUL SYLLABLE JYELS");
+-   ("/xec/xa1/xa1", "HANGUL SYLLABLE JYELT");
+-   ("/xec/xa1/xa2", "HANGUL SYLLABLE JYELP");
+-   ("/xec/xa1/xa3", "HANGUL SYLLABLE JYELH");
+-   ("/xec/xa1/xa4", "HANGUL SYLLABLE JYEM");
+-   ("/xec/xa1/xa5", "HANGUL SYLLABLE JYEB");
+-   ("/xec/xa1/xa6", "HANGUL SYLLABLE JYEBS");
+-   ("/xec/xa1/xa7", "HANGUL SYLLABLE JYES");
+-   ("/xec/xa1/xa8", "HANGUL SYLLABLE JYESS");
+-   ("/xec/xa1/xa9", "HANGUL SYLLABLE JYENG");
+-   ("/xec/xa1/xaa", "HANGUL SYLLABLE JYEJ");
+-   ("/xec/xa1/xab", "HANGUL SYLLABLE JYEC");
+-   ("/xec/xa1/xac", "HANGUL SYLLABLE JYEK");
+-   ("/xec/xa1/xad", "HANGUL SYLLABLE JYET");
+-   ("/xec/xa1/xae", "HANGUL SYLLABLE JYEP");
+-   ("/xec/xa1/xaf", "HANGUL SYLLABLE JYEH");
+-   ("/xec/xa1/xb0", "HANGUL SYLLABLE JO");
+-   ("/xec/xa1/xb1", "HANGUL SYLLABLE JOG");
+-   ("/xec/xa1/xb2", "HANGUL SYLLABLE JOGG");
+-   ("/xec/xa1/xb3", "HANGUL SYLLABLE JOGS");
+-   ("/xec/xa1/xb4", "HANGUL SYLLABLE JON");
+-   ("/xec/xa1/xb5", "HANGUL SYLLABLE JONI");
+-   ("/xec/xa1/xb6", "HANGUL SYLLABLE JONH");
+-   ("/xec/xa1/xb7", "HANGUL SYLLABLE JOD");
+-   ("/xec/xa1/xb8", "HANGUL SYLLABLE JOL");
+-   ("/xec/xa1/xb9", "HANGUL SYLLABLE JOLG");
+-   ("/xec/xa1/xba", "HANGUL SYLLABLE JOLM");
+-   ("/xec/xa1/xbb", "HANGUL SYLLABLE JOLB");
+-   ("/xec/xa1/xbc", "HANGUL SYLLABLE JOLS");
+-   ("/xec/xa1/xbd", "HANGUL SYLLABLE JOLT");
+-   ("/xec/xa1/xbe", "HANGUL SYLLABLE JOLP");
+-   ("/xec/xa1/xbf", "HANGUL SYLLABLE JOLH");
+-   ("/xec/xa2/x80", "HANGUL SYLLABLE JOM");
+-   ("/xec/xa2/x81", "HANGUL SYLLABLE JOB");
+-   ("/xec/xa2/x82", "HANGUL SYLLABLE JOBS");
+-   ("/xec/xa2/x83", "HANGUL SYLLABLE JOS");
+-   ("/xec/xa2/x84", "HANGUL SYLLABLE JOSS");
+-   ("/xec/xa2/x85", "HANGUL SYLLABLE JONG");
+-   ("/xec/xa2/x86", "HANGUL SYLLABLE JOJ");
+-   ("/xec/xa2/x87", "HANGUL SYLLABLE JOC");
+-   ("/xec/xa2/x88", "HANGUL SYLLABLE JOK");
+-   ("/xec/xa2/x89", "HANGUL SYLLABLE JOT");
+-   ("/xec/xa2/x8a", "HANGUL SYLLABLE JOP");
+-   ("/xec/xa2/x8b", "HANGUL SYLLABLE JOH");
+-   ("/xec/xa2/x8c", "HANGUL SYLLABLE JWA");
+-   ("/xec/xa2/x8d", "HANGUL SYLLABLE JWAG");
+-   ("/xec/xa2/x8e", "HANGUL SYLLABLE JWAGG");
+-   ("/xec/xa2/x8f", "HANGUL SYLLABLE JWAGS");
+-   ("/xec/xa2/x90", "HANGUL SYLLABLE JWAN");
+-   ("/xec/xa2/x91", "HANGUL SYLLABLE JWANI");
+-   ("/xec/xa2/x92", "HANGUL SYLLABLE JWANH");
+-   ("/xec/xa2/x93", "HANGUL SYLLABLE JWAD");
+-   ("/xec/xa2/x94", "HANGUL SYLLABLE JWAL");
+-   ("/xec/xa2/x95", "HANGUL SYLLABLE JWALG");
+-   ("/xec/xa2/x96", "HANGUL SYLLABLE JWALM");
+-   ("/xec/xa2/x97", "HANGUL SYLLABLE JWALB");
+-   ("/xec/xa2/x98", "HANGUL SYLLABLE JWALS");
+-   ("/xec/xa2/x99", "HANGUL SYLLABLE JWALT");
+-   ("/xec/xa2/x9a", "HANGUL SYLLABLE JWALP");
+-   ("/xec/xa2/x9b", "HANGUL SYLLABLE JWALH");
+-   ("/xec/xa2/x9c", "HANGUL SYLLABLE JWAM");
+-   ("/xec/xa2/x9d", "HANGUL SYLLABLE JWAB");
+-   ("/xec/xa2/x9e", "HANGUL SYLLABLE JWABS");
+-   ("/xec/xa2/x9f", "HANGUL SYLLABLE JWAS");
+-   ("/xec/xa2/xa0", "HANGUL SYLLABLE JWASS");
+-   ("/xec/xa2/xa1", "HANGUL SYLLABLE JWANG");
+-   ("/xec/xa2/xa2", "HANGUL SYLLABLE JWAJ");
+-   ("/xec/xa2/xa3", "HANGUL SYLLABLE JWAC");
+-   ("/xec/xa2/xa4", "HANGUL SYLLABLE JWAK");
+-   ("/xec/xa2/xa5", "HANGUL SYLLABLE JWAT");
+-   ("/xec/xa2/xa6", "HANGUL SYLLABLE JWAP");
+-   ("/xec/xa2/xa7", "HANGUL SYLLABLE JWAH");
+-   ("/xec/xa2/xa8", "HANGUL SYLLABLE JWAE");
+-   ("/xec/xa2/xa9", "HANGUL SYLLABLE JWAEG");
+-   ("/xec/xa2/xaa", "HANGUL SYLLABLE JWAEGG");
+-   ("/xec/xa2/xab", "HANGUL SYLLABLE JWAEGS");
+-   ("/xec/xa2/xac", "HANGUL SYLLABLE JWAEN");
+-   ("/xec/xa2/xad", "HANGUL SYLLABLE JWAENI");
+-   ("/xec/xa2/xae", "HANGUL SYLLABLE JWAENH");
+-   ("/xec/xa2/xaf", "HANGUL SYLLABLE JWAED");
+-   ("/xec/xa2/xb0", "HANGUL SYLLABLE JWAEL");
+-   ("/xec/xa2/xb1", "HANGUL SYLLABLE JWAELG");
+-   ("/xec/xa2/xb2", "HANGUL SYLLABLE JWAELM");
+-   ("/xec/xa2/xb3", "HANGUL SYLLABLE JWAELB");
+-   ("/xec/xa2/xb4", "HANGUL SYLLABLE JWAELS");
+-   ("/xec/xa2/xb5", "HANGUL SYLLABLE JWAELT");
+-   ("/xec/xa2/xb6", "HANGUL SYLLABLE JWAELP");
+-   ("/xec/xa2/xb7", "HANGUL SYLLABLE JWAELH");
+-   ("/xec/xa2/xb8", "HANGUL SYLLABLE JWAEM");
+-   ("/xec/xa2/xb9", "HANGUL SYLLABLE JWAEB");
+-   ("/xec/xa2/xba", "HANGUL SYLLABLE JWAEBS");
+-   ("/xec/xa2/xbb", "HANGUL SYLLABLE JWAES");
+-   ("/xec/xa2/xbc", "HANGUL SYLLABLE JWAESS");
+-   ("/xec/xa2/xbd", "HANGUL SYLLABLE JWAENG");
+-   ("/xec/xa2/xbe", "HANGUL SYLLABLE JWAEJ");
+-   ("/xec/xa2/xbf", "HANGUL SYLLABLE JWAEC");
+-   ("/xec/xa3/x80", "HANGUL SYLLABLE JWAEK");
+-   ("/xec/xa3/x81", "HANGUL SYLLABLE JWAET");
+-   ("/xec/xa3/x82", "HANGUL SYLLABLE JWAEP");
+-   ("/xec/xa3/x83", "HANGUL SYLLABLE JWAEH");
+-   ("/xec/xa3/x84", "HANGUL SYLLABLE JOE");
+-   ("/xec/xa3/x85", "HANGUL SYLLABLE JOEG");
+-   ("/xec/xa3/x86", "HANGUL SYLLABLE JOEGG");
+-   ("/xec/xa3/x87", "HANGUL SYLLABLE JOEGS");
+-   ("/xec/xa3/x88", "HANGUL SYLLABLE JOEN");
+-   ("/xec/xa3/x89", "HANGUL SYLLABLE JOENI");
+-   ("/xec/xa3/x8a", "HANGUL SYLLABLE JOENH");
+-   ("/xec/xa3/x8b", "HANGUL SYLLABLE JOED");
+-   ("/xec/xa3/x8c", "HANGUL SYLLABLE JOEL");
+-   ("/xec/xa3/x8d", "HANGUL SYLLABLE JOELG");
+-   ("/xec/xa3/x8e", "HANGUL SYLLABLE JOELM");
+-   ("/xec/xa3/x8f", "HANGUL SYLLABLE JOELB");
+-   ("/xec/xa3/x90", "HANGUL SYLLABLE JOELS");
+-   ("/xec/xa3/x91", "HANGUL SYLLABLE JOELT");
+-   ("/xec/xa3/x92", "HANGUL SYLLABLE JOELP");
+-   ("/xec/xa3/x93", "HANGUL SYLLABLE JOELH");
+-   ("/xec/xa3/x94", "HANGUL SYLLABLE JOEM");
+-   ("/xec/xa3/x95", "HANGUL SYLLABLE JOEB");
+-   ("/xec/xa3/x96", "HANGUL SYLLABLE JOEBS");
+-   ("/xec/xa3/x97", "HANGUL SYLLABLE JOES");
+-   ("/xec/xa3/x98", "HANGUL SYLLABLE JOESS");
+-   ("/xec/xa3/x99", "HANGUL SYLLABLE JOENG");
+-   ("/xec/xa3/x9a", "HANGUL SYLLABLE JOEJ");
+-   ("/xec/xa3/x9b", "HANGUL SYLLABLE JOEC");
+-   ("/xec/xa3/x9c", "HANGUL SYLLABLE JOEK");
+-   ("/xec/xa3/x9d", "HANGUL SYLLABLE JOET");
+-   ("/xec/xa3/x9e", "HANGUL SYLLABLE JOEP");
+-   ("/xec/xa3/x9f", "HANGUL SYLLABLE JOEH");
+-   ("/xec/xa3/xa0", "HANGUL SYLLABLE JYO");
+-   ("/xec/xa3/xa1", "HANGUL SYLLABLE JYOG");
+-   ("/xec/xa3/xa2", "HANGUL SYLLABLE JYOGG");
+-   ("/xec/xa3/xa3", "HANGUL SYLLABLE JYOGS");
+-   ("/xec/xa3/xa4", "HANGUL SYLLABLE JYON");
+-   ("/xec/xa3/xa5", "HANGUL SYLLABLE JYONI");
+-   ("/xec/xa3/xa6", "HANGUL SYLLABLE JYONH");
+-   ("/xec/xa3/xa7", "HANGUL SYLLABLE JYOD");
+-   ("/xec/xa3/xa8", "HANGUL SYLLABLE JYOL");
+-   ("/xec/xa3/xa9", "HANGUL SYLLABLE JYOLG");
+-   ("/xec/xa3/xaa", "HANGUL SYLLABLE JYOLM");
+-   ("/xec/xa3/xab", "HANGUL SYLLABLE JYOLB");
+-   ("/xec/xa3/xac", "HANGUL SYLLABLE JYOLS");
+-   ("/xec/xa3/xad", "HANGUL SYLLABLE JYOLT");
+-   ("/xec/xa3/xae", "HANGUL SYLLABLE JYOLP");
+-   ("/xec/xa3/xaf", "HANGUL SYLLABLE JYOLH");
+-   ("/xec/xa3/xb0", "HANGUL SYLLABLE JYOM");
+-   ("/xec/xa3/xb1", "HANGUL SYLLABLE JYOB");
+-   ("/xec/xa3/xb2", "HANGUL SYLLABLE JYOBS");
+-   ("/xec/xa3/xb3", "HANGUL SYLLABLE JYOS");
+-   ("/xec/xa3/xb4", "HANGUL SYLLABLE JYOSS");
+-   ("/xec/xa3/xb5", "HANGUL SYLLABLE JYONG");
+-   ("/xec/xa3/xb6", "HANGUL SYLLABLE JYOJ");
+-   ("/xec/xa3/xb7", "HANGUL SYLLABLE JYOC");
+-   ("/xec/xa3/xb8", "HANGUL SYLLABLE JYOK");
+-   ("/xec/xa3/xb9", "HANGUL SYLLABLE JYOT");
+-   ("/xec/xa3/xba", "HANGUL SYLLABLE JYOP");
+-   ("/xec/xa3/xbb", "HANGUL SYLLABLE JYOH");
+-   ("/xec/xa3/xbc", "HANGUL SYLLABLE JU");
+-   ("/xec/xa3/xbd", "HANGUL SYLLABLE JUG");
+-   ("/xec/xa3/xbe", "HANGUL SYLLABLE JUGG");
+-   ("/xec/xa3/xbf", "HANGUL SYLLABLE JUGS");
+-   ("/xec/xa4/x80", "HANGUL SYLLABLE JUN");
+-   ("/xec/xa4/x81", "HANGUL SYLLABLE JUNI");
+-   ("/xec/xa4/x82", "HANGUL SYLLABLE JUNH");
+-   ("/xec/xa4/x83", "HANGUL SYLLABLE JUD");
+-   ("/xec/xa4/x84", "HANGUL SYLLABLE JUL");
+-   ("/xec/xa4/x85", "HANGUL SYLLABLE JULG");
+-   ("/xec/xa4/x86", "HANGUL SYLLABLE JULM");
+-   ("/xec/xa4/x87", "HANGUL SYLLABLE JULB");
+-   ("/xec/xa4/x88", "HANGUL SYLLABLE JULS");
+-   ("/xec/xa4/x89", "HANGUL SYLLABLE JULT");
+-   ("/xec/xa4/x8a", "HANGUL SYLLABLE JULP");
+-   ("/xec/xa4/x8b", "HANGUL SYLLABLE JULH");
+-   ("/xec/xa4/x8c", "HANGUL SYLLABLE JUM");
+-   ("/xec/xa4/x8d", "HANGUL SYLLABLE JUB");
+-   ("/xec/xa4/x8e", "HANGUL SYLLABLE JUBS");
+-   ("/xec/xa4/x8f", "HANGUL SYLLABLE JUS");
+-   ("/xec/xa4/x90", "HANGUL SYLLABLE JUSS");
+-   ("/xec/xa4/x91", "HANGUL SYLLABLE JUNG");
+-   ("/xec/xa4/x92", "HANGUL SYLLABLE JUJ");
+-   ("/xec/xa4/x93", "HANGUL SYLLABLE JUC");
+-   ("/xec/xa4/x94", "HANGUL SYLLABLE JUK");
+-   ("/xec/xa4/x95", "HANGUL SYLLABLE JUT");
+-   ("/xec/xa4/x96", "HANGUL SYLLABLE JUP");
+-   ("/xec/xa4/x97", "HANGUL SYLLABLE JUH");
+-   ("/xec/xa4/x98", "HANGUL SYLLABLE JWEO");
+-   ("/xec/xa4/x99", "HANGUL SYLLABLE JWEOG");
+-   ("/xec/xa4/x9a", "HANGUL SYLLABLE JWEOGG");
+-   ("/xec/xa4/x9b", "HANGUL SYLLABLE JWEOGS");
+-   ("/xec/xa4/x9c", "HANGUL SYLLABLE JWEON");
+-   ("/xec/xa4/x9d", "HANGUL SYLLABLE JWEONI");
+-   ("/xec/xa4/x9e", "HANGUL SYLLABLE JWEONH");
+-   ("/xec/xa4/x9f", "HANGUL SYLLABLE JWEOD");
+-   ("/xec/xa4/xa0", "HANGUL SYLLABLE JWEOL");
+-   ("/xec/xa4/xa1", "HANGUL SYLLABLE JWEOLG");
+-   ("/xec/xa4/xa2", "HANGUL SYLLABLE JWEOLM");
+-   ("/xec/xa4/xa3", "HANGUL SYLLABLE JWEOLB");
+-   ("/xec/xa4/xa4", "HANGUL SYLLABLE JWEOLS");
+-   ("/xec/xa4/xa5", "HANGUL SYLLABLE JWEOLT");
+-   ("/xec/xa4/xa6", "HANGUL SYLLABLE JWEOLP");
+-   ("/xec/xa4/xa7", "HANGUL SYLLABLE JWEOLH");
+-   ("/xec/xa4/xa8", "HANGUL SYLLABLE JWEOM");
+-   ("/xec/xa4/xa9", "HANGUL SYLLABLE JWEOB");
+-   ("/xec/xa4/xaa", "HANGUL SYLLABLE JWEOBS");
+-   ("/xec/xa4/xab", "HANGUL SYLLABLE JWEOS");
+-   ("/xec/xa4/xac", "HANGUL SYLLABLE JWEOSS");
+-   ("/xec/xa4/xad", "HANGUL SYLLABLE JWEONG");
+-   ("/xec/xa4/xae", "HANGUL SYLLABLE JWEOJ");
+-   ("/xec/xa4/xaf", "HANGUL SYLLABLE JWEOC");
+-   ("/xec/xa4/xb0", "HANGUL SYLLABLE JWEOK");
+-   ("/xec/xa4/xb1", "HANGUL SYLLABLE JWEOT");
+-   ("/xec/xa4/xb2", "HANGUL SYLLABLE JWEOP");
+-   ("/xec/xa4/xb3", "HANGUL SYLLABLE JWEOH");
+-   ("/xec/xa4/xb4", "HANGUL SYLLABLE JWE");
+-   ("/xec/xa4/xb5", "HANGUL SYLLABLE JWEG");
+-   ("/xec/xa4/xb6", "HANGUL SYLLABLE JWEGG");
+-   ("/xec/xa4/xb7", "HANGUL SYLLABLE JWEGS");
+-   ("/xec/xa4/xb8", "HANGUL SYLLABLE JWEN");
+-   ("/xec/xa4/xb9", "HANGUL SYLLABLE JWENI");
+-   ("/xec/xa4/xba", "HANGUL SYLLABLE JWENH");
+-   ("/xec/xa4/xbb", "HANGUL SYLLABLE JWED");
+-   ("/xec/xa4/xbc", "HANGUL SYLLABLE JWEL");
+-   ("/xec/xa4/xbd", "HANGUL SYLLABLE JWELG");
+-   ("/xec/xa4/xbe", "HANGUL SYLLABLE JWELM");
+-   ("/xec/xa4/xbf", "HANGUL SYLLABLE JWELB");
+-   ("/xec/xa5/x80", "HANGUL SYLLABLE JWELS");
+-   ("/xec/xa5/x81", "HANGUL SYLLABLE JWELT");
+-   ("/xec/xa5/x82", "HANGUL SYLLABLE JWELP");
+-   ("/xec/xa5/x83", "HANGUL SYLLABLE JWELH");
+-   ("/xec/xa5/x84", "HANGUL SYLLABLE JWEM");
+-   ("/xec/xa5/x85", "HANGUL SYLLABLE JWEB");
+-   ("/xec/xa5/x86", "HANGUL SYLLABLE JWEBS");
+-   ("/xec/xa5/x87", "HANGUL SYLLABLE JWES");
+-   ("/xec/xa5/x88", "HANGUL SYLLABLE JWESS");
+-   ("/xec/xa5/x89", "HANGUL SYLLABLE JWENG");
+-   ("/xec/xa5/x8a", "HANGUL SYLLABLE JWEJ");
+-   ("/xec/xa5/x8b", "HANGUL SYLLABLE JWEC");
+-   ("/xec/xa5/x8c", "HANGUL SYLLABLE JWEK");
+-   ("/xec/xa5/x8d", "HANGUL SYLLABLE JWET");
+-   ("/xec/xa5/x8e", "HANGUL SYLLABLE JWEP");
+-   ("/xec/xa5/x8f", "HANGUL SYLLABLE JWEH");
+-   ("/xec/xa5/x90", "HANGUL SYLLABLE JWI");
+-   ("/xec/xa5/x91", "HANGUL SYLLABLE JWIG");
+-   ("/xec/xa5/x92", "HANGUL SYLLABLE JWIGG");
+-   ("/xec/xa5/x93", "HANGUL SYLLABLE JWIGS");
+-   ("/xec/xa5/x94", "HANGUL SYLLABLE JWIN");
+-   ("/xec/xa5/x95", "HANGUL SYLLABLE JWINI");
+-   ("/xec/xa5/x96", "HANGUL SYLLABLE JWINH");
+-   ("/xec/xa5/x97", "HANGUL SYLLABLE JWID");
+-   ("/xec/xa5/x98", "HANGUL SYLLABLE JWIL");
+-   ("/xec/xa5/x99", "HANGUL SYLLABLE JWILG");
+-   ("/xec/xa5/x9a", "HANGUL SYLLABLE JWILM");
+-   ("/xec/xa5/x9b", "HANGUL SYLLABLE JWILB");
+-   ("/xec/xa5/x9c", "HANGUL SYLLABLE JWILS");
+-   ("/xec/xa5/x9d", "HANGUL SYLLABLE JWILT");
+-   ("/xec/xa5/x9e", "HANGUL SYLLABLE JWILP");
+-   ("/xec/xa5/x9f", "HANGUL SYLLABLE JWILH");
+-   ("/xec/xa5/xa0", "HANGUL SYLLABLE JWIM");
+-   ("/xec/xa5/xa1", "HANGUL SYLLABLE JWIB");
+-   ("/xec/xa5/xa2", "HANGUL SYLLABLE JWIBS");
+-   ("/xec/xa5/xa3", "HANGUL SYLLABLE JWIS");
+-   ("/xec/xa5/xa4", "HANGUL SYLLABLE JWISS");
+-   ("/xec/xa5/xa5", "HANGUL SYLLABLE JWING");
+-   ("/xec/xa5/xa6", "HANGUL SYLLABLE JWIJ");
+-   ("/xec/xa5/xa7", "HANGUL SYLLABLE JWIC");
+-   ("/xec/xa5/xa8", "HANGUL SYLLABLE JWIK");
+-   ("/xec/xa5/xa9", "HANGUL SYLLABLE JWIT");
+-   ("/xec/xa5/xaa", "HANGUL SYLLABLE JWIP");
+-   ("/xec/xa5/xab", "HANGUL SYLLABLE JWIH");
+-   ("/xec/xa5/xac", "HANGUL SYLLABLE JYU");
+-   ("/xec/xa5/xad", "HANGUL SYLLABLE JYUG");
+-   ("/xec/xa5/xae", "HANGUL SYLLABLE JYUGG");
+-   ("/xec/xa5/xaf", "HANGUL SYLLABLE JYUGS");
+-   ("/xec/xa5/xb0", "HANGUL SYLLABLE JYUN");
+-   ("/xec/xa5/xb1", "HANGUL SYLLABLE JYUNI");
+-   ("/xec/xa5/xb2", "HANGUL SYLLABLE JYUNH");
+-   ("/xec/xa5/xb3", "HANGUL SYLLABLE JYUD");
+-   ("/xec/xa5/xb4", "HANGUL SYLLABLE JYUL");
+-   ("/xec/xa5/xb5", "HANGUL SYLLABLE JYULG");
+-   ("/xec/xa5/xb6", "HANGUL SYLLABLE JYULM");
+-   ("/xec/xa5/xb7", "HANGUL SYLLABLE JYULB");
+-   ("/xec/xa5/xb8", "HANGUL SYLLABLE JYULS");
+-   ("/xec/xa5/xb9", "HANGUL SYLLABLE JYULT");
+-   ("/xec/xa5/xba", "HANGUL SYLLABLE JYULP");
+-   ("/xec/xa5/xbb", "HANGUL SYLLABLE JYULH");
+-   ("/xec/xa5/xbc", "HANGUL SYLLABLE JYUM");
+-   ("/xec/xa5/xbd", "HANGUL SYLLABLE JYUB");
+-   ("/xec/xa5/xbe", "HANGUL SYLLABLE JYUBS");
+-   ("/xec/xa5/xbf", "HANGUL SYLLABLE JYUS");
+-   ("/xec/xa6/x80", "HANGUL SYLLABLE JYUSS");
+-   ("/xec/xa6/x81", "HANGUL SYLLABLE JYUNG");
+-   ("/xec/xa6/x82", "HANGUL SYLLABLE JYUJ");
+-   ("/xec/xa6/x83", "HANGUL SYLLABLE JYUC");
+-   ("/xec/xa6/x84", "HANGUL SYLLABLE JYUK");
+-   ("/xec/xa6/x85", "HANGUL SYLLABLE JYUT");
+-   ("/xec/xa6/x86", "HANGUL SYLLABLE JYUP");
+-   ("/xec/xa6/x87", "HANGUL SYLLABLE JYUH");
+-   ("/xec/xa6/x88", "HANGUL SYLLABLE JEU");
+-   ("/xec/xa6/x89", "HANGUL SYLLABLE JEUG");
+-   ("/xec/xa6/x8a", "HANGUL SYLLABLE JEUGG");
+-   ("/xec/xa6/x8b", "HANGUL SYLLABLE JEUGS");
+-   ("/xec/xa6/x8c", "HANGUL SYLLABLE JEUN");
+-   ("/xec/xa6/x8d", "HANGUL SYLLABLE JEUNI");
+-   ("/xec/xa6/x8e", "HANGUL SYLLABLE JEUNH");
+-   ("/xec/xa6/x8f", "HANGUL SYLLABLE JEUD");
+-   ("/xec/xa6/x90", "HANGUL SYLLABLE JEUL");
+-   ("/xec/xa6/x91", "HANGUL SYLLABLE JEULG");
+-   ("/xec/xa6/x92", "HANGUL SYLLABLE JEULM");
+-   ("/xec/xa6/x93", "HANGUL SYLLABLE JEULB");
+-   ("/xec/xa6/x94", "HANGUL SYLLABLE JEULS");
+-   ("/xec/xa6/x95", "HANGUL SYLLABLE JEULT");
+-   ("/xec/xa6/x96", "HANGUL SYLLABLE JEULP");
+-   ("/xec/xa6/x97", "HANGUL SYLLABLE JEULH");
+-   ("/xec/xa6/x98", "HANGUL SYLLABLE JEUM");
+-   ("/xec/xa6/x99", "HANGUL SYLLABLE JEUB");
+-   ("/xec/xa6/x9a", "HANGUL SYLLABLE JEUBS");
+-   ("/xec/xa6/x9b", "HANGUL SYLLABLE JEUS");
+-   ("/xec/xa6/x9c", "HANGUL SYLLABLE JEUSS");
+-   ("/xec/xa6/x9d", "HANGUL SYLLABLE JEUNG");
+-   ("/xec/xa6/x9e", "HANGUL SYLLABLE JEUJ");
+-   ("/xec/xa6/x9f", "HANGUL SYLLABLE JEUC");
+-   ("/xec/xa6/xa0", "HANGUL SYLLABLE JEUK");
+-   ("/xec/xa6/xa1", "HANGUL SYLLABLE JEUT");
+-   ("/xec/xa6/xa2", "HANGUL SYLLABLE JEUP");
+-   ("/xec/xa6/xa3", "HANGUL SYLLABLE JEUH");
+-   ("/xec/xa6/xa4", "HANGUL SYLLABLE JYI");
+-   ("/xec/xa6/xa5", "HANGUL SYLLABLE JYIG");
+-   ("/xec/xa6/xa6", "HANGUL SYLLABLE JYIGG");
+-   ("/xec/xa6/xa7", "HANGUL SYLLABLE JYIGS");
+-   ("/xec/xa6/xa8", "HANGUL SYLLABLE JYIN");
+-   ("/xec/xa6/xa9", "HANGUL SYLLABLE JYINI");
+-   ("/xec/xa6/xaa", "HANGUL SYLLABLE JYINH");
+-   ("/xec/xa6/xab", "HANGUL SYLLABLE JYID");
+-   ("/xec/xa6/xac", "HANGUL SYLLABLE JYIL");
+-   ("/xec/xa6/xad", "HANGUL SYLLABLE JYILG");
+-   ("/xec/xa6/xae", "HANGUL SYLLABLE JYILM");
+-   ("/xec/xa6/xaf", "HANGUL SYLLABLE JYILB");
+-   ("/xec/xa6/xb0", "HANGUL SYLLABLE JYILS");
+-   ("/xec/xa6/xb1", "HANGUL SYLLABLE JYILT");
+-   ("/xec/xa6/xb2", "HANGUL SYLLABLE JYILP");
+-   ("/xec/xa6/xb3", "HANGUL SYLLABLE JYILH");
+-   ("/xec/xa6/xb4", "HANGUL SYLLABLE JYIM");
+-   ("/xec/xa6/xb5", "HANGUL SYLLABLE JYIB");
+-   ("/xec/xa6/xb6", "HANGUL SYLLABLE JYIBS");
+-   ("/xec/xa6/xb7", "HANGUL SYLLABLE JYIS");
+-   ("/xec/xa6/xb8", "HANGUL SYLLABLE JYISS");
+-   ("/xec/xa6/xb9", "HANGUL SYLLABLE JYING");
+-   ("/xec/xa6/xba", "HANGUL SYLLABLE JYIJ");
+-   ("/xec/xa6/xbb", "HANGUL SYLLABLE JYIC");
+-   ("/xec/xa6/xbc", "HANGUL SYLLABLE JYIK");
+-   ("/xec/xa6/xbd", "HANGUL SYLLABLE JYIT");
+-   ("/xec/xa6/xbe", "HANGUL SYLLABLE JYIP");
+-   ("/xec/xa6/xbf", "HANGUL SYLLABLE JYIH");
+-   ("/xec/xa7/x80", "HANGUL SYLLABLE JI");
+-   ("/xec/xa7/x81", "HANGUL SYLLABLE JIG");
+-   ("/xec/xa7/x82", "HANGUL SYLLABLE JIGG");
+-   ("/xec/xa7/x83", "HANGUL SYLLABLE JIGS");
+-   ("/xec/xa7/x84", "HANGUL SYLLABLE JIN");
+-   ("/xec/xa7/x85", "HANGUL SYLLABLE JINI");
+-   ("/xec/xa7/x86", "HANGUL SYLLABLE JINH");
+-   ("/xec/xa7/x87", "HANGUL SYLLABLE JID");
+-   ("/xec/xa7/x88", "HANGUL SYLLABLE JIL");
+-   ("/xec/xa7/x89", "HANGUL SYLLABLE JILG");
+-   ("/xec/xa7/x8a", "HANGUL SYLLABLE JILM");
+-   ("/xec/xa7/x8b", "HANGUL SYLLABLE JILB");
+-   ("/xec/xa7/x8c", "HANGUL SYLLABLE JILS");
+-   ("/xec/xa7/x8d", "HANGUL SYLLABLE JILT");
+-   ("/xec/xa7/x8e", "HANGUL SYLLABLE JILP");
+-   ("/xec/xa7/x8f", "HANGUL SYLLABLE JILH");
+-   ("/xec/xa7/x90", "HANGUL SYLLABLE JIM");
+-   ("/xec/xa7/x91", "HANGUL SYLLABLE JIB");
+-   ("/xec/xa7/x92", "HANGUL SYLLABLE JIBS");
+-   ("/xec/xa7/x93", "HANGUL SYLLABLE JIS");
+-   ("/xec/xa7/x94", "HANGUL SYLLABLE JISS");
+-   ("/xec/xa7/x95", "HANGUL SYLLABLE JING");
+-   ("/xec/xa7/x96", "HANGUL SYLLABLE JIJ");
+-   ("/xec/xa7/x97", "HANGUL SYLLABLE JIC");
+-   ("/xec/xa7/x98", "HANGUL SYLLABLE JIK");
+-   ("/xec/xa7/x99", "HANGUL SYLLABLE JIT");
+-   ("/xec/xa7/x9a", "HANGUL SYLLABLE JIP");
+-   ("/xec/xa7/x9b", "HANGUL SYLLABLE JIH");
+-   ("/xec/xa7/x9c", "HANGUL SYLLABLE JJA");
+-   ("/xec/xa7/x9d", "HANGUL SYLLABLE JJAG");
+-   ("/xec/xa7/x9e", "HANGUL SYLLABLE JJAGG");
+-   ("/xec/xa7/x9f", "HANGUL SYLLABLE JJAGS");
+-   ("/xec/xa7/xa0", "HANGUL SYLLABLE JJAN");
+-   ("/xec/xa7/xa1", "HANGUL SYLLABLE JJANI");
+-   ("/xec/xa7/xa2", "HANGUL SYLLABLE JJANH");
+-   ("/xec/xa7/xa3", "HANGUL SYLLABLE JJAD");
+-   ("/xec/xa7/xa4", "HANGUL SYLLABLE JJAL");
+-   ("/xec/xa7/xa5", "HANGUL SYLLABLE JJALG");
+-   ("/xec/xa7/xa6", "HANGUL SYLLABLE JJALM");
+-   ("/xec/xa7/xa7", "HANGUL SYLLABLE JJALB");
+-   ("/xec/xa7/xa8", "HANGUL SYLLABLE JJALS");
+-   ("/xec/xa7/xa9", "HANGUL SYLLABLE JJALT");
+-   ("/xec/xa7/xaa", "HANGUL SYLLABLE JJALP");
+-   ("/xec/xa7/xab", "HANGUL SYLLABLE JJALH");
+-   ("/xec/xa7/xac", "HANGUL SYLLABLE JJAM");
+-   ("/xec/xa7/xad", "HANGUL SYLLABLE JJAB");
+-   ("/xec/xa7/xae", "HANGUL SYLLABLE JJABS");
+-   ("/xec/xa7/xaf", "HANGUL SYLLABLE JJAS");
+-   ("/xec/xa7/xb0", "HANGUL SYLLABLE JJASS");
+-   ("/xec/xa7/xb1", "HANGUL SYLLABLE JJANG");
+-   ("/xec/xa7/xb2", "HANGUL SYLLABLE JJAJ");
+-   ("/xec/xa7/xb3", "HANGUL SYLLABLE JJAC");
+-   ("/xec/xa7/xb4", "HANGUL SYLLABLE JJAK");
+-   ("/xec/xa7/xb5", "HANGUL SYLLABLE JJAT");
+-   ("/xec/xa7/xb6", "HANGUL SYLLABLE JJAP");
+-   ("/xec/xa7/xb7", "HANGUL SYLLABLE JJAH");
+-   ("/xec/xa7/xb8", "HANGUL SYLLABLE JJAE");
+-   ("/xec/xa7/xb9", "HANGUL SYLLABLE JJAEG");
+-   ("/xec/xa7/xba", "HANGUL SYLLABLE JJAEGG");
+-   ("/xec/xa7/xbb", "HANGUL SYLLABLE JJAEGS");
+-   ("/xec/xa7/xbc", "HANGUL SYLLABLE JJAEN");
+-   ("/xec/xa7/xbd", "HANGUL SYLLABLE JJAENI");
+-   ("/xec/xa7/xbe", "HANGUL SYLLABLE JJAENH");
+-   ("/xec/xa7/xbf", "HANGUL SYLLABLE JJAED");
+-   ("/xec/xa8/x80", "HANGUL SYLLABLE JJAEL");
+-   ("/xec/xa8/x81", "HANGUL SYLLABLE JJAELG");
+-   ("/xec/xa8/x82", "HANGUL SYLLABLE JJAELM");
+-   ("/xec/xa8/x83", "HANGUL SYLLABLE JJAELB");
+-   ("/xec/xa8/x84", "HANGUL SYLLABLE JJAELS");
+-   ("/xec/xa8/x85", "HANGUL SYLLABLE JJAELT");
+-   ("/xec/xa8/x86", "HANGUL SYLLABLE JJAELP");
+-   ("/xec/xa8/x87", "HANGUL SYLLABLE JJAELH");
+-   ("/xec/xa8/x88", "HANGUL SYLLABLE JJAEM");
+-   ("/xec/xa8/x89", "HANGUL SYLLABLE JJAEB");
+-   ("/xec/xa8/x8a", "HANGUL SYLLABLE JJAEBS");
+-   ("/xec/xa8/x8b", "HANGUL SYLLABLE JJAES");
+-   ("/xec/xa8/x8c", "HANGUL SYLLABLE JJAESS");
+-   ("/xec/xa8/x8d", "HANGUL SYLLABLE JJAENG");
+-   ("/xec/xa8/x8e", "HANGUL SYLLABLE JJAEJ");
+-   ("/xec/xa8/x8f", "HANGUL SYLLABLE JJAEC");
+-   ("/xec/xa8/x90", "HANGUL SYLLABLE JJAEK");
+-   ("/xec/xa8/x91", "HANGUL SYLLABLE JJAET");
+-   ("/xec/xa8/x92", "HANGUL SYLLABLE JJAEP");
+-   ("/xec/xa8/x93", "HANGUL SYLLABLE JJAEH");
+-   ("/xec/xa8/x94", "HANGUL SYLLABLE JJYA");
+-   ("/xec/xa8/x95", "HANGUL SYLLABLE JJYAG");
+-   ("/xec/xa8/x96", "HANGUL SYLLABLE JJYAGG");
+-   ("/xec/xa8/x97", "HANGUL SYLLABLE JJYAGS");
+-   ("/xec/xa8/x98", "HANGUL SYLLABLE JJYAN");
+-   ("/xec/xa8/x99", "HANGUL SYLLABLE JJYANI");
+-   ("/xec/xa8/x9a", "HANGUL SYLLABLE JJYANH");
+-   ("/xec/xa8/x9b", "HANGUL SYLLABLE JJYAD");
+-   ("/xec/xa8/x9c", "HANGUL SYLLABLE JJYAL");
+-   ("/xec/xa8/x9d", "HANGUL SYLLABLE JJYALG");
+-   ("/xec/xa8/x9e", "HANGUL SYLLABLE JJYALM");
+-   ("/xec/xa8/x9f", "HANGUL SYLLABLE JJYALB");
+-   ("/xec/xa8/xa0", "HANGUL SYLLABLE JJYALS");
+-   ("/xec/xa8/xa1", "HANGUL SYLLABLE JJYALT");
+-   ("/xec/xa8/xa2", "HANGUL SYLLABLE JJYALP");
+-   ("/xec/xa8/xa3", "HANGUL SYLLABLE JJYALH");
+-   ("/xec/xa8/xa4", "HANGUL SYLLABLE JJYAM");
+-   ("/xec/xa8/xa5", "HANGUL SYLLABLE JJYAB");
+-   ("/xec/xa8/xa6", "HANGUL SYLLABLE JJYABS");
+-   ("/xec/xa8/xa7", "HANGUL SYLLABLE JJYAS");
+-   ("/xec/xa8/xa8", "HANGUL SYLLABLE JJYASS");
+-   ("/xec/xa8/xa9", "HANGUL SYLLABLE JJYANG");
+-   ("/xec/xa8/xaa", "HANGUL SYLLABLE JJYAJ");
+-   ("/xec/xa8/xab", "HANGUL SYLLABLE JJYAC");
+-   ("/xec/xa8/xac", "HANGUL SYLLABLE JJYAK");
+-   ("/xec/xa8/xad", "HANGUL SYLLABLE JJYAT");
+-   ("/xec/xa8/xae", "HANGUL SYLLABLE JJYAP");
+-   ("/xec/xa8/xaf", "HANGUL SYLLABLE JJYAH");
+-   ("/xec/xa8/xb0", "HANGUL SYLLABLE JJYAE");
+-   ("/xec/xa8/xb1", "HANGUL SYLLABLE JJYAEG");
+-   ("/xec/xa8/xb2", "HANGUL SYLLABLE JJYAEGG");
+-   ("/xec/xa8/xb3", "HANGUL SYLLABLE JJYAEGS");
+-   ("/xec/xa8/xb4", "HANGUL SYLLABLE JJYAEN");
+-   ("/xec/xa8/xb5", "HANGUL SYLLABLE JJYAENI");
+-   ("/xec/xa8/xb6", "HANGUL SYLLABLE JJYAENH");
+-   ("/xec/xa8/xb7", "HANGUL SYLLABLE JJYAED");
+-   ("/xec/xa8/xb8", "HANGUL SYLLABLE JJYAEL");
+-   ("/xec/xa8/xb9", "HANGUL SYLLABLE JJYAELG");
+-   ("/xec/xa8/xba", "HANGUL SYLLABLE JJYAELM");
+-   ("/xec/xa8/xbb", "HANGUL SYLLABLE JJYAELB");
+-   ("/xec/xa8/xbc", "HANGUL SYLLABLE JJYAELS");
+-   ("/xec/xa8/xbd", "HANGUL SYLLABLE JJYAELT");
+-   ("/xec/xa8/xbe", "HANGUL SYLLABLE JJYAELP");
+-   ("/xec/xa8/xbf", "HANGUL SYLLABLE JJYAELH");
+-   ("/xec/xa9/x80", "HANGUL SYLLABLE JJYAEM");
+-   ("/xec/xa9/x81", "HANGUL SYLLABLE JJYAEB");
+-   ("/xec/xa9/x82", "HANGUL SYLLABLE JJYAEBS");
+-   ("/xec/xa9/x83", "HANGUL SYLLABLE JJYAES");
+-   ("/xec/xa9/x84", "HANGUL SYLLABLE JJYAESS");
+-   ("/xec/xa9/x85", "HANGUL SYLLABLE JJYAENG");
+-   ("/xec/xa9/x86", "HANGUL SYLLABLE JJYAEJ");
+-   ("/xec/xa9/x87", "HANGUL SYLLABLE JJYAEC");
+-   ("/xec/xa9/x88", "HANGUL SYLLABLE JJYAEK");
+-   ("/xec/xa9/x89", "HANGUL SYLLABLE JJYAET");
+-   ("/xec/xa9/x8a", "HANGUL SYLLABLE JJYAEP");
+-   ("/xec/xa9/x8b", "HANGUL SYLLABLE JJYAEH");
+-   ("/xec/xa9/x8c", "HANGUL SYLLABLE JJEO");
+-   ("/xec/xa9/x8d", "HANGUL SYLLABLE JJEOG");
+-   ("/xec/xa9/x8e", "HANGUL SYLLABLE JJEOGG");
+-   ("/xec/xa9/x8f", "HANGUL SYLLABLE JJEOGS");
+-   ("/xec/xa9/x90", "HANGUL SYLLABLE JJEON");
+-   ("/xec/xa9/x91", "HANGUL SYLLABLE JJEONI");
+-   ("/xec/xa9/x92", "HANGUL SYLLABLE JJEONH");
+-   ("/xec/xa9/x93", "HANGUL SYLLABLE JJEOD");
+-   ("/xec/xa9/x94", "HANGUL SYLLABLE JJEOL");
+-   ("/xec/xa9/x95", "HANGUL SYLLABLE JJEOLG");
+-   ("/xec/xa9/x96", "HANGUL SYLLABLE JJEOLM");
+-   ("/xec/xa9/x97", "HANGUL SYLLABLE JJEOLB");
+-   ("/xec/xa9/x98", "HANGUL SYLLABLE JJEOLS");
+-   ("/xec/xa9/x99", "HANGUL SYLLABLE JJEOLT");
+-   ("/xec/xa9/x9a", "HANGUL SYLLABLE JJEOLP");
+-   ("/xec/xa9/x9b", "HANGUL SYLLABLE JJEOLH");
+-   ("/xec/xa9/x9c", "HANGUL SYLLABLE JJEOM");
+-   ("/xec/xa9/x9d", "HANGUL SYLLABLE JJEOB");
+-   ("/xec/xa9/x9e", "HANGUL SYLLABLE JJEOBS");
+-   ("/xec/xa9/x9f", "HANGUL SYLLABLE JJEOS");
+-   ("/xec/xa9/xa0", "HANGUL SYLLABLE JJEOSS");
+-   ("/xec/xa9/xa1", "HANGUL SYLLABLE JJEONG");
+-   ("/xec/xa9/xa2", "HANGUL SYLLABLE JJEOJ");
+-   ("/xec/xa9/xa3", "HANGUL SYLLABLE JJEOC");
+-   ("/xec/xa9/xa4", "HANGUL SYLLABLE JJEOK");
+-   ("/xec/xa9/xa5", "HANGUL SYLLABLE JJEOT");
+-   ("/xec/xa9/xa6", "HANGUL SYLLABLE JJEOP");
+-   ("/xec/xa9/xa7", "HANGUL SYLLABLE JJEOH");
+-   ("/xec/xa9/xa8", "HANGUL SYLLABLE JJE");
+-   ("/xec/xa9/xa9", "HANGUL SYLLABLE JJEG");
+-   ("/xec/xa9/xaa", "HANGUL SYLLABLE JJEGG");
+-   ("/xec/xa9/xab", "HANGUL SYLLABLE JJEGS");
+-   ("/xec/xa9/xac", "HANGUL SYLLABLE JJEN");
+-   ("/xec/xa9/xad", "HANGUL SYLLABLE JJENI");
+-   ("/xec/xa9/xae", "HANGUL SYLLABLE JJENH");
+-   ("/xec/xa9/xaf", "HANGUL SYLLABLE JJED");
+-   ("/xec/xa9/xb0", "HANGUL SYLLABLE JJEL");
+-   ("/xec/xa9/xb1", "HANGUL SYLLABLE JJELG");
+-   ("/xec/xa9/xb2", "HANGUL SYLLABLE JJELM");
+-   ("/xec/xa9/xb3", "HANGUL SYLLABLE JJELB");
+-   ("/xec/xa9/xb4", "HANGUL SYLLABLE JJELS");
+-   ("/xec/xa9/xb5", "HANGUL SYLLABLE JJELT");
+-   ("/xec/xa9/xb6", "HANGUL SYLLABLE JJELP");
+-   ("/xec/xa9/xb7", "HANGUL SYLLABLE JJELH");
+-   ("/xec/xa9/xb8", "HANGUL SYLLABLE JJEM");
+-   ("/xec/xa9/xb9", "HANGUL SYLLABLE JJEB");
+-   ("/xec/xa9/xba", "HANGUL SYLLABLE JJEBS");
+-   ("/xec/xa9/xbb", "HANGUL SYLLABLE JJES");
+-   ("/xec/xa9/xbc", "HANGUL SYLLABLE JJESS");
+-   ("/xec/xa9/xbd", "HANGUL SYLLABLE JJENG");
+-   ("/xec/xa9/xbe", "HANGUL SYLLABLE JJEJ");
+-   ("/xec/xa9/xbf", "HANGUL SYLLABLE JJEC");
+-   ("/xec/xaa/x80", "HANGUL SYLLABLE JJEK");
+-   ("/xec/xaa/x81", "HANGUL SYLLABLE JJET");
+-   ("/xec/xaa/x82", "HANGUL SYLLABLE JJEP");
+-   ("/xec/xaa/x83", "HANGUL SYLLABLE JJEH");
+-   ("/xec/xaa/x84", "HANGUL SYLLABLE JJYEO");
+-   ("/xec/xaa/x85", "HANGUL SYLLABLE JJYEOG");
+-   ("/xec/xaa/x86", "HANGUL SYLLABLE JJYEOGG");
+-   ("/xec/xaa/x87", "HANGUL SYLLABLE JJYEOGS");
+-   ("/xec/xaa/x88", "HANGUL SYLLABLE JJYEON");
+-   ("/xec/xaa/x89", "HANGUL SYLLABLE JJYEONI");
+-   ("/xec/xaa/x8a", "HANGUL SYLLABLE JJYEONH");
+-   ("/xec/xaa/x8b", "HANGUL SYLLABLE JJYEOD");
+-   ("/xec/xaa/x8c", "HANGUL SYLLABLE JJYEOL");
+-   ("/xec/xaa/x8d", "HANGUL SYLLABLE JJYEOLG");
+-   ("/xec/xaa/x8e", "HANGUL SYLLABLE JJYEOLM");
+-   ("/xec/xaa/x8f", "HANGUL SYLLABLE JJYEOLB");
+-   ("/xec/xaa/x90", "HANGUL SYLLABLE JJYEOLS");
+-   ("/xec/xaa/x91", "HANGUL SYLLABLE JJYEOLT");
+-   ("/xec/xaa/x92", "HANGUL SYLLABLE JJYEOLP");
+-   ("/xec/xaa/x93", "HANGUL SYLLABLE JJYEOLH");
+-   ("/xec/xaa/x94", "HANGUL SYLLABLE JJYEOM");
+-   ("/xec/xaa/x95", "HANGUL SYLLABLE JJYEOB");
+-   ("/xec/xaa/x96", "HANGUL SYLLABLE JJYEOBS");
+-   ("/xec/xaa/x97", "HANGUL SYLLABLE JJYEOS");
+-   ("/xec/xaa/x98", "HANGUL SYLLABLE JJYEOSS");
+-   ("/xec/xaa/x99", "HANGUL SYLLABLE JJYEONG");
+-   ("/xec/xaa/x9a", "HANGUL SYLLABLE JJYEOJ");
+-   ("/xec/xaa/x9b", "HANGUL SYLLABLE JJYEOC");
+-   ("/xec/xaa/x9c", "HANGUL SYLLABLE JJYEOK");
+-   ("/xec/xaa/x9d", "HANGUL SYLLABLE JJYEOT");
+-   ("/xec/xaa/x9e", "HANGUL SYLLABLE JJYEOP");
+-   ("/xec/xaa/x9f", "HANGUL SYLLABLE JJYEOH");
+-   ("/xec/xaa/xa0", "HANGUL SYLLABLE JJYE");
+-   ("/xec/xaa/xa1", "HANGUL SYLLABLE JJYEG");
+-   ("/xec/xaa/xa2", "HANGUL SYLLABLE JJYEGG");
+-   ("/xec/xaa/xa3", "HANGUL SYLLABLE JJYEGS");
+-   ("/xec/xaa/xa4", "HANGUL SYLLABLE JJYEN");
+-   ("/xec/xaa/xa5", "HANGUL SYLLABLE JJYENI");
+-   ("/xec/xaa/xa6", "HANGUL SYLLABLE JJYENH");
+-   ("/xec/xaa/xa7", "HANGUL SYLLABLE JJYED");
+-   ("/xec/xaa/xa8", "HANGUL SYLLABLE JJYEL");
+-   ("/xec/xaa/xa9", "HANGUL SYLLABLE JJYELG");
+-   ("/xec/xaa/xaa", "HANGUL SYLLABLE JJYELM");
+-   ("/xec/xaa/xab", "HANGUL SYLLABLE JJYELB");
+-   ("/xec/xaa/xac", "HANGUL SYLLABLE JJYELS");
+-   ("/xec/xaa/xad", "HANGUL SYLLABLE JJYELT");
+-   ("/xec/xaa/xae", "HANGUL SYLLABLE JJYELP");
+-   ("/xec/xaa/xaf", "HANGUL SYLLABLE JJYELH");
+-   ("/xec/xaa/xb0", "HANGUL SYLLABLE JJYEM");
+-   ("/xec/xaa/xb1", "HANGUL SYLLABLE JJYEB");
+-   ("/xec/xaa/xb2", "HANGUL SYLLABLE JJYEBS");
+-   ("/xec/xaa/xb3", "HANGUL SYLLABLE JJYES");
+-   ("/xec/xaa/xb4", "HANGUL SYLLABLE JJYESS");
+-   ("/xec/xaa/xb5", "HANGUL SYLLABLE JJYENG");
+-   ("/xec/xaa/xb6", "HANGUL SYLLABLE JJYEJ");
+-   ("/xec/xaa/xb7", "HANGUL SYLLABLE JJYEC");
+-   ("/xec/xaa/xb8", "HANGUL SYLLABLE JJYEK");
+-   ("/xec/xaa/xb9", "HANGUL SYLLABLE JJYET");
+-   ("/xec/xaa/xba", "HANGUL SYLLABLE JJYEP");
+-   ("/xec/xaa/xbb", "HANGUL SYLLABLE JJYEH");
+-   ("/xec/xaa/xbc", "HANGUL SYLLABLE JJO");
+-   ("/xec/xaa/xbd", "HANGUL SYLLABLE JJOG");
+-   ("/xec/xaa/xbe", "HANGUL SYLLABLE JJOGG");
+-   ("/xec/xaa/xbf", "HANGUL SYLLABLE JJOGS");
+-   ("/xec/xab/x80", "HANGUL SYLLABLE JJON");
+-   ("/xec/xab/x81", "HANGUL SYLLABLE JJONI");
+-   ("/xec/xab/x82", "HANGUL SYLLABLE JJONH");
+-   ("/xec/xab/x83", "HANGUL SYLLABLE JJOD");
+-   ("/xec/xab/x84", "HANGUL SYLLABLE JJOL");
+-   ("/xec/xab/x85", "HANGUL SYLLABLE JJOLG");
+-   ("/xec/xab/x86", "HANGUL SYLLABLE JJOLM");
+-   ("/xec/xab/x87", "HANGUL SYLLABLE JJOLB");
+-   ("/xec/xab/x88", "HANGUL SYLLABLE JJOLS");
+-   ("/xec/xab/x89", "HANGUL SYLLABLE JJOLT");
+-   ("/xec/xab/x8a", "HANGUL SYLLABLE JJOLP");
+-   ("/xec/xab/x8b", "HANGUL SYLLABLE JJOLH");
+-   ("/xec/xab/x8c", "HANGUL SYLLABLE JJOM");
+-   ("/xec/xab/x8d", "HANGUL SYLLABLE JJOB");
+-   ("/xec/xab/x8e", "HANGUL SYLLABLE JJOBS");
+-   ("/xec/xab/x8f", "HANGUL SYLLABLE JJOS");
+-   ("/xec/xab/x90", "HANGUL SYLLABLE JJOSS");
+-   ("/xec/xab/x91", "HANGUL SYLLABLE JJONG");
+-   ("/xec/xab/x92", "HANGUL SYLLABLE JJOJ");
+-   ("/xec/xab/x93", "HANGUL SYLLABLE JJOC");
+-   ("/xec/xab/x94", "HANGUL SYLLABLE JJOK");
+-   ("/xec/xab/x95", "HANGUL SYLLABLE JJOT");
+-   ("/xec/xab/x96", "HANGUL SYLLABLE JJOP");
+-   ("/xec/xab/x97", "HANGUL SYLLABLE JJOH");
+-   ("/xec/xab/x98", "HANGUL SYLLABLE JJWA");
+-   ("/xec/xab/x99", "HANGUL SYLLABLE JJWAG");
+-   ("/xec/xab/x9a", "HANGUL SYLLABLE JJWAGG");
+-   ("/xec/xab/x9b", "HANGUL SYLLABLE JJWAGS");
+-   ("/xec/xab/x9c", "HANGUL SYLLABLE JJWAN");
+-   ("/xec/xab/x9d", "HANGUL SYLLABLE JJWANI");
+-   ("/xec/xab/x9e", "HANGUL SYLLABLE JJWANH");
+-   ("/xec/xab/x9f", "HANGUL SYLLABLE JJWAD");
+-   ("/xec/xab/xa0", "HANGUL SYLLABLE JJWAL");
+-   ("/xec/xab/xa1", "HANGUL SYLLABLE JJWALG");
+-   ("/xec/xab/xa2", "HANGUL SYLLABLE JJWALM");
+-   ("/xec/xab/xa3", "HANGUL SYLLABLE JJWALB");
+-   ("/xec/xab/xa4", "HANGUL SYLLABLE JJWALS");
+-   ("/xec/xab/xa5", "HANGUL SYLLABLE JJWALT");
+-   ("/xec/xab/xa6", "HANGUL SYLLABLE JJWALP");
+-   ("/xec/xab/xa7", "HANGUL SYLLABLE JJWALH");
+-   ("/xec/xab/xa8", "HANGUL SYLLABLE JJWAM");
+-   ("/xec/xab/xa9", "HANGUL SYLLABLE JJWAB");
+-   ("/xec/xab/xaa", "HANGUL SYLLABLE JJWABS");
+-   ("/xec/xab/xab", "HANGUL SYLLABLE JJWAS");
+-   ("/xec/xab/xac", "HANGUL SYLLABLE JJWASS");
+-   ("/xec/xab/xad", "HANGUL SYLLABLE JJWANG");
+-   ("/xec/xab/xae", "HANGUL SYLLABLE JJWAJ");
+-   ("/xec/xab/xaf", "HANGUL SYLLABLE JJWAC");
+-   ("/xec/xab/xb0", "HANGUL SYLLABLE JJWAK");
+-   ("/xec/xab/xb1", "HANGUL SYLLABLE JJWAT");
+-   ("/xec/xab/xb2", "HANGUL SYLLABLE JJWAP");
+-   ("/xec/xab/xb3", "HANGUL SYLLABLE JJWAH");
+-   ("/xec/xab/xb4", "HANGUL SYLLABLE JJWAE");
+-   ("/xec/xab/xb5", "HANGUL SYLLABLE JJWAEG");
+-   ("/xec/xab/xb6", "HANGUL SYLLABLE JJWAEGG");
+-   ("/xec/xab/xb7", "HANGUL SYLLABLE JJWAEGS");
+-   ("/xec/xab/xb8", "HANGUL SYLLABLE JJWAEN");
+-   ("/xec/xab/xb9", "HANGUL SYLLABLE JJWAENI");
+-   ("/xec/xab/xba", "HANGUL SYLLABLE JJWAENH");
+-   ("/xec/xab/xbb", "HANGUL SYLLABLE JJWAED");
+-   ("/xec/xab/xbc", "HANGUL SYLLABLE JJWAEL");
+-   ("/xec/xab/xbd", "HANGUL SYLLABLE JJWAELG");
+-   ("/xec/xab/xbe", "HANGUL SYLLABLE JJWAELM");
+-   ("/xec/xab/xbf", "HANGUL SYLLABLE JJWAELB");
+-   ("/xec/xac/x80", "HANGUL SYLLABLE JJWAELS");
+-   ("/xec/xac/x81", "HANGUL SYLLABLE JJWAELT");
+-   ("/xec/xac/x82", "HANGUL SYLLABLE JJWAELP");
+-   ("/xec/xac/x83", "HANGUL SYLLABLE JJWAELH");
+-   ("/xec/xac/x84", "HANGUL SYLLABLE JJWAEM");
+-   ("/xec/xac/x85", "HANGUL SYLLABLE JJWAEB");
+-   ("/xec/xac/x86", "HANGUL SYLLABLE JJWAEBS");
+-   ("/xec/xac/x87", "HANGUL SYLLABLE JJWAES");
+-   ("/xec/xac/x88", "HANGUL SYLLABLE JJWAESS");
+-   ("/xec/xac/x89", "HANGUL SYLLABLE JJWAENG");
+-   ("/xec/xac/x8a", "HANGUL SYLLABLE JJWAEJ");
+-   ("/xec/xac/x8b", "HANGUL SYLLABLE JJWAEC");
+-   ("/xec/xac/x8c", "HANGUL SYLLABLE JJWAEK");
+-   ("/xec/xac/x8d", "HANGUL SYLLABLE JJWAET");
+-   ("/xec/xac/x8e", "HANGUL SYLLABLE JJWAEP");
+-   ("/xec/xac/x8f", "HANGUL SYLLABLE JJWAEH");
+-   ("/xec/xac/x90", "HANGUL SYLLABLE JJOE");
+-   ("/xec/xac/x91", "HANGUL SYLLABLE JJOEG");
+-   ("/xec/xac/x92", "HANGUL SYLLABLE JJOEGG");
+-   ("/xec/xac/x93", "HANGUL SYLLABLE JJOEGS");
+-   ("/xec/xac/x94", "HANGUL SYLLABLE JJOEN");
+-   ("/xec/xac/x95", "HANGUL SYLLABLE JJOENI");
+-   ("/xec/xac/x96", "HANGUL SYLLABLE JJOENH");
+-   ("/xec/xac/x97", "HANGUL SYLLABLE JJOED");
+-   ("/xec/xac/x98", "HANGUL SYLLABLE JJOEL");
+-   ("/xec/xac/x99", "HANGUL SYLLABLE JJOELG");
+-   ("/xec/xac/x9a", "HANGUL SYLLABLE JJOELM");
+-   ("/xec/xac/x9b", "HANGUL SYLLABLE JJOELB");
+-   ("/xec/xac/x9c", "HANGUL SYLLABLE JJOELS");
+-   ("/xec/xac/x9d", "HANGUL SYLLABLE JJOELT");
+-   ("/xec/xac/x9e", "HANGUL SYLLABLE JJOELP");
+-   ("/xec/xac/x9f", "HANGUL SYLLABLE JJOELH");
+-   ("/xec/xac/xa0", "HANGUL SYLLABLE JJOEM");
+-   ("/xec/xac/xa1", "HANGUL SYLLABLE JJOEB");
+-   ("/xec/xac/xa2", "HANGUL SYLLABLE JJOEBS");
+-   ("/xec/xac/xa3", "HANGUL SYLLABLE JJOES");
+-   ("/xec/xac/xa4", "HANGUL SYLLABLE JJOESS");
+-   ("/xec/xac/xa5", "HANGUL SYLLABLE JJOENG");
+-   ("/xec/xac/xa6", "HANGUL SYLLABLE JJOEJ");
+-   ("/xec/xac/xa7", "HANGUL SYLLABLE JJOEC");
+-   ("/xec/xac/xa8", "HANGUL SYLLABLE JJOEK");
+-   ("/xec/xac/xa9", "HANGUL SYLLABLE JJOET");
+-   ("/xec/xac/xaa", "HANGUL SYLLABLE JJOEP");
+-   ("/xec/xac/xab", "HANGUL SYLLABLE JJOEH");
+-   ("/xec/xac/xac", "HANGUL SYLLABLE JJYO");
+-   ("/xec/xac/xad", "HANGUL SYLLABLE JJYOG");
+-   ("/xec/xac/xae", "HANGUL SYLLABLE JJYOGG");
+-   ("/xec/xac/xaf", "HANGUL SYLLABLE JJYOGS");
+-   ("/xec/xac/xb0", "HANGUL SYLLABLE JJYON");
+-   ("/xec/xac/xb1", "HANGUL SYLLABLE JJYONI");
+-   ("/xec/xac/xb2", "HANGUL SYLLABLE JJYONH");
+-   ("/xec/xac/xb3", "HANGUL SYLLABLE JJYOD");
+-   ("/xec/xac/xb4", "HANGUL SYLLABLE JJYOL");
+-   ("/xec/xac/xb5", "HANGUL SYLLABLE JJYOLG");
+-   ("/xec/xac/xb6", "HANGUL SYLLABLE JJYOLM");
+-   ("/xec/xac/xb7", "HANGUL SYLLABLE JJYOLB");
+-   ("/xec/xac/xb8", "HANGUL SYLLABLE JJYOLS");
+-   ("/xec/xac/xb9", "HANGUL SYLLABLE JJYOLT");
+-   ("/xec/xac/xba", "HANGUL SYLLABLE JJYOLP");
+-   ("/xec/xac/xbb", "HANGUL SYLLABLE JJYOLH");
+-   ("/xec/xac/xbc", "HANGUL SYLLABLE JJYOM");
+-   ("/xec/xac/xbd", "HANGUL SYLLABLE JJYOB");
+-   ("/xec/xac/xbe", "HANGUL SYLLABLE JJYOBS");
+-   ("/xec/xac/xbf", "HANGUL SYLLABLE JJYOS");
+-   ("/xec/xad/x80", "HANGUL SYLLABLE JJYOSS");
+-   ("/xec/xad/x81", "HANGUL SYLLABLE JJYONG");
+-   ("/xec/xad/x82", "HANGUL SYLLABLE JJYOJ");
+-   ("/xec/xad/x83", "HANGUL SYLLABLE JJYOC");
+-   ("/xec/xad/x84", "HANGUL SYLLABLE JJYOK");
+-   ("/xec/xad/x85", "HANGUL SYLLABLE JJYOT");
+-   ("/xec/xad/x86", "HANGUL SYLLABLE JJYOP");
+-   ("/xec/xad/x87", "HANGUL SYLLABLE JJYOH");
+-   ("/xec/xad/x88", "HANGUL SYLLABLE JJU");
+-   ("/xec/xad/x89", "HANGUL SYLLABLE JJUG");
+-   ("/xec/xad/x8a", "HANGUL SYLLABLE JJUGG");
+-   ("/xec/xad/x8b", "HANGUL SYLLABLE JJUGS");
+-   ("/xec/xad/x8c", "HANGUL SYLLABLE JJUN");
+-   ("/xec/xad/x8d", "HANGUL SYLLABLE JJUNI");
+-   ("/xec/xad/x8e", "HANGUL SYLLABLE JJUNH");
+-   ("/xec/xad/x8f", "HANGUL SYLLABLE JJUD");
+-   ("/xec/xad/x90", "HANGUL SYLLABLE JJUL");
+-   ("/xec/xad/x91", "HANGUL SYLLABLE JJULG");
+-   ("/xec/xad/x92", "HANGUL SYLLABLE JJULM");
+-   ("/xec/xad/x93", "HANGUL SYLLABLE JJULB");
+-   ("/xec/xad/x94", "HANGUL SYLLABLE JJULS");
+-   ("/xec/xad/x95", "HANGUL SYLLABLE JJULT");
+-   ("/xec/xad/x96", "HANGUL SYLLABLE JJULP");
+-   ("/xec/xad/x97", "HANGUL SYLLABLE JJULH");
+-   ("/xec/xad/x98", "HANGUL SYLLABLE JJUM");
+-   ("/xec/xad/x99", "HANGUL SYLLABLE JJUB");
+-   ("/xec/xad/x9a", "HANGUL SYLLABLE JJUBS");
+-   ("/xec/xad/x9b", "HANGUL SYLLABLE JJUS");
+-   ("/xec/xad/x9c", "HANGUL SYLLABLE JJUSS");
+-   ("/xec/xad/x9d", "HANGUL SYLLABLE JJUNG");
+-   ("/xec/xad/x9e", "HANGUL SYLLABLE JJUJ");
+-   ("/xec/xad/x9f", "HANGUL SYLLABLE JJUC");
+-   ("/xec/xad/xa0", "HANGUL SYLLABLE JJUK");
+-   ("/xec/xad/xa1", "HANGUL SYLLABLE JJUT");
+-   ("/xec/xad/xa2", "HANGUL SYLLABLE JJUP");
+-   ("/xec/xad/xa3", "HANGUL SYLLABLE JJUH");
+-   ("/xec/xad/xa4", "HANGUL SYLLABLE JJWEO");
+-   ("/xec/xad/xa5", "HANGUL SYLLABLE JJWEOG");
+-   ("/xec/xad/xa6", "HANGUL SYLLABLE JJWEOGG");
+-   ("/xec/xad/xa7", "HANGUL SYLLABLE JJWEOGS");
+-   ("/xec/xad/xa8", "HANGUL SYLLABLE JJWEON");
+-   ("/xec/xad/xa9", "HANGUL SYLLABLE JJWEONI");
+-   ("/xec/xad/xaa", "HANGUL SYLLABLE JJWEONH");
+-   ("/xec/xad/xab", "HANGUL SYLLABLE JJWEOD");
+-   ("/xec/xad/xac", "HANGUL SYLLABLE JJWEOL");
+-   ("/xec/xad/xad", "HANGUL SYLLABLE JJWEOLG");
+-   ("/xec/xad/xae", "HANGUL SYLLABLE JJWEOLM");
+-   ("/xec/xad/xaf", "HANGUL SYLLABLE JJWEOLB");
+-   ("/xec/xad/xb0", "HANGUL SYLLABLE JJWEOLS");
+-   ("/xec/xad/xb1", "HANGUL SYLLABLE JJWEOLT");
+-   ("/xec/xad/xb2", "HANGUL SYLLABLE JJWEOLP");
+-   ("/xec/xad/xb3", "HANGUL SYLLABLE JJWEOLH");
+-   ("/xec/xad/xb4", "HANGUL SYLLABLE JJWEOM");
+-   ("/xec/xad/xb5", "HANGUL SYLLABLE JJWEOB");
+-   ("/xec/xad/xb6", "HANGUL SYLLABLE JJWEOBS");
+-   ("/xec/xad/xb7", "HANGUL SYLLABLE JJWEOS");
+-   ("/xec/xad/xb8", "HANGUL SYLLABLE JJWEOSS");
+-   ("/xec/xad/xb9", "HANGUL SYLLABLE JJWEONG");
+-   ("/xec/xad/xba", "HANGUL SYLLABLE JJWEOJ");
+-   ("/xec/xad/xbb", "HANGUL SYLLABLE JJWEOC");
+-   ("/xec/xad/xbc", "HANGUL SYLLABLE JJWEOK");
+-   ("/xec/xad/xbd", "HANGUL SYLLABLE JJWEOT");
+-   ("/xec/xad/xbe", "HANGUL SYLLABLE JJWEOP");
+-   ("/xec/xad/xbf", "HANGUL SYLLABLE JJWEOH");
+-   ("/xec/xae/x80", "HANGUL SYLLABLE JJWE");
+-   ("/xec/xae/x81", "HANGUL SYLLABLE JJWEG");
+-   ("/xec/xae/x82", "HANGUL SYLLABLE JJWEGG");
+-   ("/xec/xae/x83", "HANGUL SYLLABLE JJWEGS");
+-   ("/xec/xae/x84", "HANGUL SYLLABLE JJWEN");
+-   ("/xec/xae/x85", "HANGUL SYLLABLE JJWENI");
+-   ("/xec/xae/x86", "HANGUL SYLLABLE JJWENH");
+-   ("/xec/xae/x87", "HANGUL SYLLABLE JJWED");
+-   ("/xec/xae/x88", "HANGUL SYLLABLE JJWEL");
+-   ("/xec/xae/x89", "HANGUL SYLLABLE JJWELG");
+-   ("/xec/xae/x8a", "HANGUL SYLLABLE JJWELM");
+-   ("/xec/xae/x8b", "HANGUL SYLLABLE JJWELB");
+-   ("/xec/xae/x8c", "HANGUL SYLLABLE JJWELS");
+-   ("/xec/xae/x8d", "HANGUL SYLLABLE JJWELT");
+-   ("/xec/xae/x8e", "HANGUL SYLLABLE JJWELP");
+-   ("/xec/xae/x8f", "HANGUL SYLLABLE JJWELH");
+-   ("/xec/xae/x90", "HANGUL SYLLABLE JJWEM");
+-   ("/xec/xae/x91", "HANGUL SYLLABLE JJWEB");
+-   ("/xec/xae/x92", "HANGUL SYLLABLE JJWEBS");
+-   ("/xec/xae/x93", "HANGUL SYLLABLE JJWES");
+-   ("/xec/xae/x94", "HANGUL SYLLABLE JJWESS");
+-   ("/xec/xae/x95", "HANGUL SYLLABLE JJWENG");
+-   ("/xec/xae/x96", "HANGUL SYLLABLE JJWEJ");
+-   ("/xec/xae/x97", "HANGUL SYLLABLE JJWEC");
+-   ("/xec/xae/x98", "HANGUL SYLLABLE JJWEK");
+-   ("/xec/xae/x99", "HANGUL SYLLABLE JJWET");
+-   ("/xec/xae/x9a", "HANGUL SYLLABLE JJWEP");
+-   ("/xec/xae/x9b", "HANGUL SYLLABLE JJWEH");
+-   ("/xec/xae/x9c", "HANGUL SYLLABLE JJWI");
+-   ("/xec/xae/x9d", "HANGUL SYLLABLE JJWIG");
+-   ("/xec/xae/x9e", "HANGUL SYLLABLE JJWIGG");
+-   ("/xec/xae/x9f", "HANGUL SYLLABLE JJWIGS");
+-   ("/xec/xae/xa0", "HANGUL SYLLABLE JJWIN");
+-   ("/xec/xae/xa1", "HANGUL SYLLABLE JJWINI");
+-   ("/xec/xae/xa2", "HANGUL SYLLABLE JJWINH");
+-   ("/xec/xae/xa3", "HANGUL SYLLABLE JJWID");
+-   ("/xec/xae/xa4", "HANGUL SYLLABLE JJWIL");
+-   ("/xec/xae/xa5", "HANGUL SYLLABLE JJWILG");
+-   ("/xec/xae/xa6", "HANGUL SYLLABLE JJWILM");
+-   ("/xec/xae/xa7", "HANGUL SYLLABLE JJWILB");
+-   ("/xec/xae/xa8", "HANGUL SYLLABLE JJWILS");
+-   ("/xec/xae/xa9", "HANGUL SYLLABLE JJWILT");
+-   ("/xec/xae/xaa", "HANGUL SYLLABLE JJWILP");
+-   ("/xec/xae/xab", "HANGUL SYLLABLE JJWILH");
+-   ("/xec/xae/xac", "HANGUL SYLLABLE JJWIM");
+-   ("/xec/xae/xad", "HANGUL SYLLABLE JJWIB");
+-   ("/xec/xae/xae", "HANGUL SYLLABLE JJWIBS");
+-   ("/xec/xae/xaf", "HANGUL SYLLABLE JJWIS");
+-   ("/xec/xae/xb0", "HANGUL SYLLABLE JJWISS");
+-   ("/xec/xae/xb1", "HANGUL SYLLABLE JJWING");
+-   ("/xec/xae/xb2", "HANGUL SYLLABLE JJWIJ");
+-   ("/xec/xae/xb3", "HANGUL SYLLABLE JJWIC");
+-   ("/xec/xae/xb4", "HANGUL SYLLABLE JJWIK");
+-   ("/xec/xae/xb5", "HANGUL SYLLABLE JJWIT");
+-   ("/xec/xae/xb6", "HANGUL SYLLABLE JJWIP");
+-   ("/xec/xae/xb7", "HANGUL SYLLABLE JJWIH");
+-   ("/xec/xae/xb8", "HANGUL SYLLABLE JJYU");
+-   ("/xec/xae/xb9", "HANGUL SYLLABLE JJYUG");
+-   ("/xec/xae/xba", "HANGUL SYLLABLE JJYUGG");
+-   ("/xec/xae/xbb", "HANGUL SYLLABLE JJYUGS");
+-   ("/xec/xae/xbc", "HANGUL SYLLABLE JJYUN");
+-   ("/xec/xae/xbd", "HANGUL SYLLABLE JJYUNI");
+-   ("/xec/xae/xbe", "HANGUL SYLLABLE JJYUNH");
+-   ("/xec/xae/xbf", "HANGUL SYLLABLE JJYUD");
+-   ("/xec/xaf/x80", "HANGUL SYLLABLE JJYUL");
+-   ("/xec/xaf/x81", "HANGUL SYLLABLE JJYULG");
+-   ("/xec/xaf/x82", "HANGUL SYLLABLE JJYULM");
+-   ("/xec/xaf/x83", "HANGUL SYLLABLE JJYULB");
+-   ("/xec/xaf/x84", "HANGUL SYLLABLE JJYULS");
+-   ("/xec/xaf/x85", "HANGUL SYLLABLE JJYULT");
+-   ("/xec/xaf/x86", "HANGUL SYLLABLE JJYULP");
+-   ("/xec/xaf/x87", "HANGUL SYLLABLE JJYULH");
+-   ("/xec/xaf/x88", "HANGUL SYLLABLE JJYUM");
+-   ("/xec/xaf/x89", "HANGUL SYLLABLE JJYUB");
+-   ("/xec/xaf/x8a", "HANGUL SYLLABLE JJYUBS");
+-   ("/xec/xaf/x8b", "HANGUL SYLLABLE JJYUS");
+-   ("/xec/xaf/x8c", "HANGUL SYLLABLE JJYUSS");
+-   ("/xec/xaf/x8d", "HANGUL SYLLABLE JJYUNG");
+-   ("/xec/xaf/x8e", "HANGUL SYLLABLE JJYUJ");
+-   ("/xec/xaf/x8f", "HANGUL SYLLABLE JJYUC");
+-   ("/xec/xaf/x90", "HANGUL SYLLABLE JJYUK");
+-   ("/xec/xaf/x91", "HANGUL SYLLABLE JJYUT");
+-   ("/xec/xaf/x92", "HANGUL SYLLABLE JJYUP");
+-   ("/xec/xaf/x93", "HANGUL SYLLABLE JJYUH");
+-   ("/xec/xaf/x94", "HANGUL SYLLABLE JJEU");
+-   ("/xec/xaf/x95", "HANGUL SYLLABLE JJEUG");
+-   ("/xec/xaf/x96", "HANGUL SYLLABLE JJEUGG");
+-   ("/xec/xaf/x97", "HANGUL SYLLABLE JJEUGS");
+-   ("/xec/xaf/x98", "HANGUL SYLLABLE JJEUN");
+-   ("/xec/xaf/x99", "HANGUL SYLLABLE JJEUNI");
+-   ("/xec/xaf/x9a", "HANGUL SYLLABLE JJEUNH");
+-   ("/xec/xaf/x9b", "HANGUL SYLLABLE JJEUD");
+-   ("/xec/xaf/x9c", "HANGUL SYLLABLE JJEUL");
+-   ("/xec/xaf/x9d", "HANGUL SYLLABLE JJEULG");
+-   ("/xec/xaf/x9e", "HANGUL SYLLABLE JJEULM");
+-   ("/xec/xaf/x9f", "HANGUL SYLLABLE JJEULB");
+-   ("/xec/xaf/xa0", "HANGUL SYLLABLE JJEULS");
+-   ("/xec/xaf/xa1", "HANGUL SYLLABLE JJEULT");
+-   ("/xec/xaf/xa2", "HANGUL SYLLABLE JJEULP");
+-   ("/xec/xaf/xa3", "HANGUL SYLLABLE JJEULH");
+-   ("/xec/xaf/xa4", "HANGUL SYLLABLE JJEUM");
+-   ("/xec/xaf/xa5", "HANGUL SYLLABLE JJEUB");
+-   ("/xec/xaf/xa6", "HANGUL SYLLABLE JJEUBS");
+-   ("/xec/xaf/xa7", "HANGUL SYLLABLE JJEUS");
+-   ("/xec/xaf/xa8", "HANGUL SYLLABLE JJEUSS");
+-   ("/xec/xaf/xa9", "HANGUL SYLLABLE JJEUNG");
+-   ("/xec/xaf/xaa", "HANGUL SYLLABLE JJEUJ");
+-   ("/xec/xaf/xab", "HANGUL SYLLABLE JJEUC");
+-   ("/xec/xaf/xac", "HANGUL SYLLABLE JJEUK");
+-   ("/xec/xaf/xad", "HANGUL SYLLABLE JJEUT");
+-   ("/xec/xaf/xae", "HANGUL SYLLABLE JJEUP");
+-   ("/xec/xaf/xaf", "HANGUL SYLLABLE JJEUH");
+-   ("/xec/xaf/xb0", "HANGUL SYLLABLE JJYI");
+-   ("/xec/xaf/xb1", "HANGUL SYLLABLE JJYIG");
+-   ("/xec/xaf/xb2", "HANGUL SYLLABLE JJYIGG");
+-   ("/xec/xaf/xb3", "HANGUL SYLLABLE JJYIGS");
+-   ("/xec/xaf/xb4", "HANGUL SYLLABLE JJYIN");
+-   ("/xec/xaf/xb5", "HANGUL SYLLABLE JJYINI");
+-   ("/xec/xaf/xb6", "HANGUL SYLLABLE JJYINH");
+-   ("/xec/xaf/xb7", "HANGUL SYLLABLE JJYID");
+-   ("/xec/xaf/xb8", "HANGUL SYLLABLE JJYIL");
+-   ("/xec/xaf/xb9", "HANGUL SYLLABLE JJYILG");
+-   ("/xec/xaf/xba", "HANGUL SYLLABLE JJYILM");
+-   ("/xec/xaf/xbb", "HANGUL SYLLABLE JJYILB");
+-   ("/xec/xaf/xbc", "HANGUL SYLLABLE JJYILS");
+-   ("/xec/xaf/xbd", "HANGUL SYLLABLE JJYILT");
+-   ("/xec/xaf/xbe", "HANGUL SYLLABLE JJYILP");
+-   ("/xec/xaf/xbf", "HANGUL SYLLABLE JJYILH");
+-   ("/xec/xb0/x80", "HANGUL SYLLABLE JJYIM");
+-   ("/xec/xb0/x81", "HANGUL SYLLABLE JJYIB");
+-   ("/xec/xb0/x82", "HANGUL SYLLABLE JJYIBS");
+-   ("/xec/xb0/x83", "HANGUL SYLLABLE JJYIS");
+-   ("/xec/xb0/x84", "HANGUL SYLLABLE JJYISS");
+-   ("/xec/xb0/x85", "HANGUL SYLLABLE JJYING");
+-   ("/xec/xb0/x86", "HANGUL SYLLABLE JJYIJ");
+-   ("/xec/xb0/x87", "HANGUL SYLLABLE JJYIC");
+-   ("/xec/xb0/x88", "HANGUL SYLLABLE JJYIK");
+-   ("/xec/xb0/x89", "HANGUL SYLLABLE JJYIT");
+-   ("/xec/xb0/x8a", "HANGUL SYLLABLE JJYIP");
+-   ("/xec/xb0/x8b", "HANGUL SYLLABLE JJYIH");
+-   ("/xec/xb0/x8c", "HANGUL SYLLABLE JJI");
+-   ("/xec/xb0/x8d", "HANGUL SYLLABLE JJIG");
+-   ("/xec/xb0/x8e", "HANGUL SYLLABLE JJIGG");
+-   ("/xec/xb0/x8f", "HANGUL SYLLABLE JJIGS");
+-   ("/xec/xb0/x90", "HANGUL SYLLABLE JJIN");
+-   ("/xec/xb0/x91", "HANGUL SYLLABLE JJINI");
+-   ("/xec/xb0/x92", "HANGUL SYLLABLE JJINH");
+-   ("/xec/xb0/x93", "HANGUL SYLLABLE JJID");
+-   ("/xec/xb0/x94", "HANGUL SYLLABLE JJIL");
+-   ("/xec/xb0/x95", "HANGUL SYLLABLE JJILG");
+-   ("/xec/xb0/x96", "HANGUL SYLLABLE JJILM");
+-   ("/xec/xb0/x97", "HANGUL SYLLABLE JJILB");
+-   ("/xec/xb0/x98", "HANGUL SYLLABLE JJILS");
+-   ("/xec/xb0/x99", "HANGUL SYLLABLE JJILT");
+-   ("/xec/xb0/x9a", "HANGUL SYLLABLE JJILP");
+-   ("/xec/xb0/x9b", "HANGUL SYLLABLE JJILH");
+-   ("/xec/xb0/x9c", "HANGUL SYLLABLE JJIM");
+-   ("/xec/xb0/x9d", "HANGUL SYLLABLE JJIB");
+-   ("/xec/xb0/x9e", "HANGUL SYLLABLE JJIBS");
+-   ("/xec/xb0/x9f", "HANGUL SYLLABLE JJIS");
+-   ("/xec/xb0/xa0", "HANGUL SYLLABLE JJISS");
+-   ("/xec/xb0/xa1", "HANGUL SYLLABLE JJING");
+-   ("/xec/xb0/xa2", "HANGUL SYLLABLE JJIJ");
+-   ("/xec/xb0/xa3", "HANGUL SYLLABLE JJIC");
+-   ("/xec/xb0/xa4", "HANGUL SYLLABLE JJIK");
+-   ("/xec/xb0/xa5", "HANGUL SYLLABLE JJIT");
+-   ("/xec/xb0/xa6", "HANGUL SYLLABLE JJIP");
+-   ("/xec/xb0/xa7", "HANGUL SYLLABLE JJIH");
+-   ("/xec/xb0/xa8", "HANGUL SYLLABLE CA");
+-   ("/xec/xb0/xa9", "HANGUL SYLLABLE CAG");
+-   ("/xec/xb0/xaa", "HANGUL SYLLABLE CAGG");
+-   ("/xec/xb0/xab", "HANGUL SYLLABLE CAGS");
+-   ("/xec/xb0/xac", "HANGUL SYLLABLE CAN");
+-   ("/xec/xb0/xad", "HANGUL SYLLABLE CANI");
+-   ("/xec/xb0/xae", "HANGUL SYLLABLE CANH");
+-   ("/xec/xb0/xaf", "HANGUL SYLLABLE CAD");
+-   ("/xec/xb0/xb0", "HANGUL SYLLABLE CAL");
+-   ("/xec/xb0/xb1", "HANGUL SYLLABLE CALG");
+-   ("/xec/xb0/xb2", "HANGUL SYLLABLE CALM");
+-   ("/xec/xb0/xb3", "HANGUL SYLLABLE CALB");
+-   ("/xec/xb0/xb4", "HANGUL SYLLABLE CALS");
+-   ("/xec/xb0/xb5", "HANGUL SYLLABLE CALT");
+-   ("/xec/xb0/xb6", "HANGUL SYLLABLE CALP");
+-   ("/xec/xb0/xb7", "HANGUL SYLLABLE CALH");
+-   ("/xec/xb0/xb8", "HANGUL SYLLABLE CAM");
+-   ("/xec/xb0/xb9", "HANGUL SYLLABLE CAB");
+-   ("/xec/xb0/xba", "HANGUL SYLLABLE CABS");
+-   ("/xec/xb0/xbb", "HANGUL SYLLABLE CAS");
+-   ("/xec/xb0/xbc", "HANGUL SYLLABLE CASS");
+-   ("/xec/xb0/xbd", "HANGUL SYLLABLE CANG");
+-   ("/xec/xb0/xbe", "HANGUL SYLLABLE CAJ");
+-   ("/xec/xb0/xbf", "HANGUL SYLLABLE CAC");
+-   ("/xec/xb1/x80", "HANGUL SYLLABLE CAK");
+-   ("/xec/xb1/x81", "HANGUL SYLLABLE CAT");
+-   ("/xec/xb1/x82", "HANGUL SYLLABLE CAP");
+-   ("/xec/xb1/x83", "HANGUL SYLLABLE CAH");
+-   ("/xec/xb1/x84", "HANGUL SYLLABLE CAE");
+-   ("/xec/xb1/x85", "HANGUL SYLLABLE CAEG");
+-   ("/xec/xb1/x86", "HANGUL SYLLABLE CAEGG");
+-   ("/xec/xb1/x87", "HANGUL SYLLABLE CAEGS");
+-   ("/xec/xb1/x88", "HANGUL SYLLABLE CAEN");
+-   ("/xec/xb1/x89", "HANGUL SYLLABLE CAENI");
+-   ("/xec/xb1/x8a", "HANGUL SYLLABLE CAENH");
+-   ("/xec/xb1/x8b", "HANGUL SYLLABLE CAED");
+-   ("/xec/xb1/x8c", "HANGUL SYLLABLE CAEL");
+-   ("/xec/xb1/x8d", "HANGUL SYLLABLE CAELG");
+-   ("/xec/xb1/x8e", "HANGUL SYLLABLE CAELM");
+-   ("/xec/xb1/x8f", "HANGUL SYLLABLE CAELB");
+-   ("/xec/xb1/x90", "HANGUL SYLLABLE CAELS");
+-   ("/xec/xb1/x91", "HANGUL SYLLABLE CAELT");
+-   ("/xec/xb1/x92", "HANGUL SYLLABLE CAELP");
+-   ("/xec/xb1/x93", "HANGUL SYLLABLE CAELH");
+-   ("/xec/xb1/x94", "HANGUL SYLLABLE CAEM");
+-   ("/xec/xb1/x95", "HANGUL SYLLABLE CAEB");
+-   ("/xec/xb1/x96", "HANGUL SYLLABLE CAEBS");
+-   ("/xec/xb1/x97", "HANGUL SYLLABLE CAES");
+-   ("/xec/xb1/x98", "HANGUL SYLLABLE CAESS");
+-   ("/xec/xb1/x99", "HANGUL SYLLABLE CAENG");
+-   ("/xec/xb1/x9a", "HANGUL SYLLABLE CAEJ");
+-   ("/xec/xb1/x9b", "HANGUL SYLLABLE CAEC");
+-   ("/xec/xb1/x9c", "HANGUL SYLLABLE CAEK");
+-   ("/xec/xb1/x9d", "HANGUL SYLLABLE CAET");
+-   ("/xec/xb1/x9e", "HANGUL SYLLABLE CAEP");
+-   ("/xec/xb1/x9f", "HANGUL SYLLABLE CAEH");
+-   ("/xec/xb1/xa0", "HANGUL SYLLABLE CYA");
+-   ("/xec/xb1/xa1", "HANGUL SYLLABLE CYAG");
+-   ("/xec/xb1/xa2", "HANGUL SYLLABLE CYAGG");
+-   ("/xec/xb1/xa3", "HANGUL SYLLABLE CYAGS");
+-   ("/xec/xb1/xa4", "HANGUL SYLLABLE CYAN");
+-   ("/xec/xb1/xa5", "HANGUL SYLLABLE CYANI");
+-   ("/xec/xb1/xa6", "HANGUL SYLLABLE CYANH");
+-   ("/xec/xb1/xa7", "HANGUL SYLLABLE CYAD");
+-   ("/xec/xb1/xa8", "HANGUL SYLLABLE CYAL");
+-   ("/xec/xb1/xa9", "HANGUL SYLLABLE CYALG");
+-   ("/xec/xb1/xaa", "HANGUL SYLLABLE CYALM");
+-   ("/xec/xb1/xab", "HANGUL SYLLABLE CYALB");
+-   ("/xec/xb1/xac", "HANGUL SYLLABLE CYALS");
+-   ("/xec/xb1/xad", "HANGUL SYLLABLE CYALT");
+-   ("/xec/xb1/xae", "HANGUL SYLLABLE CYALP");
+-   ("/xec/xb1/xaf", "HANGUL SYLLABLE CYALH");
+-   ("/xec/xb1/xb0", "HANGUL SYLLABLE CYAM");
+-   ("/xec/xb1/xb1", "HANGUL SYLLABLE CYAB");
+-   ("/xec/xb1/xb2", "HANGUL SYLLABLE CYABS");
+-   ("/xec/xb1/xb3", "HANGUL SYLLABLE CYAS");
+-   ("/xec/xb1/xb4", "HANGUL SYLLABLE CYASS");
+-   ("/xec/xb1/xb5", "HANGUL SYLLABLE CYANG");
+-   ("/xec/xb1/xb6", "HANGUL SYLLABLE CYAJ");
+-   ("/xec/xb1/xb7", "HANGUL SYLLABLE CYAC");
+-   ("/xec/xb1/xb8", "HANGUL SYLLABLE CYAK");
+-   ("/xec/xb1/xb9", "HANGUL SYLLABLE CYAT");
+-   ("/xec/xb1/xba", "HANGUL SYLLABLE CYAP");
+-   ("/xec/xb1/xbb", "HANGUL SYLLABLE CYAH");
+-   ("/xec/xb1/xbc", "HANGUL SYLLABLE CYAE");
+-   ("/xec/xb1/xbd", "HANGUL SYLLABLE CYAEG");
+-   ("/xec/xb1/xbe", "HANGUL SYLLABLE CYAEGG");
+-   ("/xec/xb1/xbf", "HANGUL SYLLABLE CYAEGS");
+-   ("/xec/xb2/x80", "HANGUL SYLLABLE CYAEN");
+-   ("/xec/xb2/x81", "HANGUL SYLLABLE CYAENI");
+-   ("/xec/xb2/x82", "HANGUL SYLLABLE CYAENH");
+-   ("/xec/xb2/x83", "HANGUL SYLLABLE CYAED");
+-   ("/xec/xb2/x84", "HANGUL SYLLABLE CYAEL");
+-   ("/xec/xb2/x85", "HANGUL SYLLABLE CYAELG");
+-   ("/xec/xb2/x86", "HANGUL SYLLABLE CYAELM");
+-   ("/xec/xb2/x87", "HANGUL SYLLABLE CYAELB");
+-   ("/xec/xb2/x88", "HANGUL SYLLABLE CYAELS");
+-   ("/xec/xb2/x89", "HANGUL SYLLABLE CYAELT");
+-   ("/xec/xb2/x8a", "HANGUL SYLLABLE CYAELP");
+-   ("/xec/xb2/x8b", "HANGUL SYLLABLE CYAELH");
+-   ("/xec/xb2/x8c", "HANGUL SYLLABLE CYAEM");
+-   ("/xec/xb2/x8d", "HANGUL SYLLABLE CYAEB");
+-   ("/xec/xb2/x8e", "HANGUL SYLLABLE CYAEBS");
+-   ("/xec/xb2/x8f", "HANGUL SYLLABLE CYAES");
+-   ("/xec/xb2/x90", "HANGUL SYLLABLE CYAESS");
+-   ("/xec/xb2/x91", "HANGUL SYLLABLE CYAENG");
+-   ("/xec/xb2/x92", "HANGUL SYLLABLE CYAEJ");
+-   ("/xec/xb2/x93", "HANGUL SYLLABLE CYAEC");
+-   ("/xec/xb2/x94", "HANGUL SYLLABLE CYAEK");
+-   ("/xec/xb2/x95", "HANGUL SYLLABLE CYAET");
+-   ("/xec/xb2/x96", "HANGUL SYLLABLE CYAEP");
+-   ("/xec/xb2/x97", "HANGUL SYLLABLE CYAEH");
+-   ("/xec/xb2/x98", "HANGUL SYLLABLE CEO");
+-   ("/xec/xb2/x99", "HANGUL SYLLABLE CEOG");
+-   ("/xec/xb2/x9a", "HANGUL SYLLABLE CEOGG");
+-   ("/xec/xb2/x9b", "HANGUL SYLLABLE CEOGS");
+-   ("/xec/xb2/x9c", "HANGUL SYLLABLE CEON");
+-   ("/xec/xb2/x9d", "HANGUL SYLLABLE CEONI");
+-   ("/xec/xb2/x9e", "HANGUL SYLLABLE CEONH");
+-   ("/xec/xb2/x9f", "HANGUL SYLLABLE CEOD");
+-   ("/xec/xb2/xa0", "HANGUL SYLLABLE CEOL");
+-   ("/xec/xb2/xa1", "HANGUL SYLLABLE CEOLG");
+-   ("/xec/xb2/xa2", "HANGUL SYLLABLE CEOLM");
+-   ("/xec/xb2/xa3", "HANGUL SYLLABLE CEOLB");
+-   ("/xec/xb2/xa4", "HANGUL SYLLABLE CEOLS");
+-   ("/xec/xb2/xa5", "HANGUL SYLLABLE CEOLT");
+-   ("/xec/xb2/xa6", "HANGUL SYLLABLE CEOLP");
+-   ("/xec/xb2/xa7", "HANGUL SYLLABLE CEOLH");
+-   ("/xec/xb2/xa8", "HANGUL SYLLABLE CEOM");
+-   ("/xec/xb2/xa9", "HANGUL SYLLABLE CEOB");
+-   ("/xec/xb2/xaa", "HANGUL SYLLABLE CEOBS");
+-   ("/xec/xb2/xab", "HANGUL SYLLABLE CEOS");
+-   ("/xec/xb2/xac", "HANGUL SYLLABLE CEOSS");
+-   ("/xec/xb2/xad", "HANGUL SYLLABLE CEONG");
+-   ("/xec/xb2/xae", "HANGUL SYLLABLE CEOJ");
+-   ("/xec/xb2/xaf", "HANGUL SYLLABLE CEOC");
+-   ("/xec/xb2/xb0", "HANGUL SYLLABLE CEOK");
+-   ("/xec/xb2/xb1", "HANGUL SYLLABLE CEOT");
+-   ("/xec/xb2/xb2", "HANGUL SYLLABLE CEOP");
+-   ("/xec/xb2/xb3", "HANGUL SYLLABLE CEOH");
+-   ("/xec/xb2/xb4", "HANGUL SYLLABLE CE");
+-   ("/xec/xb2/xb5", "HANGUL SYLLABLE CEG");
+-   ("/xec/xb2/xb6", "HANGUL SYLLABLE CEGG");
+-   ("/xec/xb2/xb7", "HANGUL SYLLABLE CEGS");
+-   ("/xec/xb2/xb8", "HANGUL SYLLABLE CEN");
+-   ("/xec/xb2/xb9", "HANGUL SYLLABLE CENI");
+-   ("/xec/xb2/xba", "HANGUL SYLLABLE CENH");
+-   ("/xec/xb2/xbb", "HANGUL SYLLABLE CED");
+-   ("/xec/xb2/xbc", "HANGUL SYLLABLE CEL");
+-   ("/xec/xb2/xbd", "HANGUL SYLLABLE CELG");
+-   ("/xec/xb2/xbe", "HANGUL SYLLABLE CELM");
+-   ("/xec/xb2/xbf", "HANGUL SYLLABLE CELB");
+-   ("/xec/xb3/x80", "HANGUL SYLLABLE CELS");
+-   ("/xec/xb3/x81", "HANGUL SYLLABLE CELT");
+-   ("/xec/xb3/x82", "HANGUL SYLLABLE CELP");
+-   ("/xec/xb3/x83", "HANGUL SYLLABLE CELH");
+-   ("/xec/xb3/x84", "HANGUL SYLLABLE CEM");
+-   ("/xec/xb3/x85", "HANGUL SYLLABLE CEB");
+-   ("/xec/xb3/x86", "HANGUL SYLLABLE CEBS");
+-   ("/xec/xb3/x87", "HANGUL SYLLABLE CES");
+-   ("/xec/xb3/x88", "HANGUL SYLLABLE CESS");
+-   ("/xec/xb3/x89", "HANGUL SYLLABLE CENG");
+-   ("/xec/xb3/x8a", "HANGUL SYLLABLE CEJ");
+-   ("/xec/xb3/x8b", "HANGUL SYLLABLE CEC");
+-   ("/xec/xb3/x8c", "HANGUL SYLLABLE CEK");
+-   ("/xec/xb3/x8d", "HANGUL SYLLABLE CET");
+-   ("/xec/xb3/x8e", "HANGUL SYLLABLE CEP");
+-   ("/xec/xb3/x8f", "HANGUL SYLLABLE CEH");
+-   ("/xec/xb3/x90", "HANGUL SYLLABLE CYEO");
+-   ("/xec/xb3/x91", "HANGUL SYLLABLE CYEOG");
+-   ("/xec/xb3/x92", "HANGUL SYLLABLE CYEOGG");
+-   ("/xec/xb3/x93", "HANGUL SYLLABLE CYEOGS");
+-   ("/xec/xb3/x94", "HANGUL SYLLABLE CYEON");
+-   ("/xec/xb3/x95", "HANGUL SYLLABLE CYEONI");
+-   ("/xec/xb3/x96", "HANGUL SYLLABLE CYEONH");
+-   ("/xec/xb3/x97", "HANGUL SYLLABLE CYEOD");
+-   ("/xec/xb3/x98", "HANGUL SYLLABLE CYEOL");
+-   ("/xec/xb3/x99", "HANGUL SYLLABLE CYEOLG");
+-   ("/xec/xb3/x9a", "HANGUL SYLLABLE CYEOLM");
+-   ("/xec/xb3/x9b", "HANGUL SYLLABLE CYEOLB");
+-   ("/xec/xb3/x9c", "HANGUL SYLLABLE CYEOLS");
+-   ("/xec/xb3/x9d", "HANGUL SYLLABLE CYEOLT");
+-   ("/xec/xb3/x9e", "HANGUL SYLLABLE CYEOLP");
+-   ("/xec/xb3/x9f", "HANGUL SYLLABLE CYEOLH");
+-   ("/xec/xb3/xa0", "HANGUL SYLLABLE CYEOM");
+-   ("/xec/xb3/xa1", "HANGUL SYLLABLE CYEOB");
+-   ("/xec/xb3/xa2", "HANGUL SYLLABLE CYEOBS");
+-   ("/xec/xb3/xa3", "HANGUL SYLLABLE CYEOS");
+-   ("/xec/xb3/xa4", "HANGUL SYLLABLE CYEOSS");
+-   ("/xec/xb3/xa5", "HANGUL SYLLABLE CYEONG");
+-   ("/xec/xb3/xa6", "HANGUL SYLLABLE CYEOJ");
+-   ("/xec/xb3/xa7", "HANGUL SYLLABLE CYEOC");
+-   ("/xec/xb3/xa8", "HANGUL SYLLABLE CYEOK");
+-   ("/xec/xb3/xa9", "HANGUL SYLLABLE CYEOT");
+-   ("/xec/xb3/xaa", "HANGUL SYLLABLE CYEOP");
+-   ("/xec/xb3/xab", "HANGUL SYLLABLE CYEOH");
+-   ("/xec/xb3/xac", "HANGUL SYLLABLE CYE");
+-   ("/xec/xb3/xad", "HANGUL SYLLABLE CYEG");
+-   ("/xec/xb3/xae", "HANGUL SYLLABLE CYEGG");
+-   ("/xec/xb3/xaf", "HANGUL SYLLABLE CYEGS");
+-   ("/xec/xb3/xb0", "HANGUL SYLLABLE CYEN");
+-   ("/xec/xb3/xb1", "HANGUL SYLLABLE CYENI");
+-   ("/xec/xb3/xb2", "HANGUL SYLLABLE CYENH");
+-   ("/xec/xb3/xb3", "HANGUL SYLLABLE CYED");
+-   ("/xec/xb3/xb4", "HANGUL SYLLABLE CYEL");
+-   ("/xec/xb3/xb5", "HANGUL SYLLABLE CYELG");
+-   ("/xec/xb3/xb6", "HANGUL SYLLABLE CYELM");
+-   ("/xec/xb3/xb7", "HANGUL SYLLABLE CYELB");
+-   ("/xec/xb3/xb8", "HANGUL SYLLABLE CYELS");
+-   ("/xec/xb3/xb9", "HANGUL SYLLABLE CYELT");
+-   ("/xec/xb3/xba", "HANGUL SYLLABLE CYELP");
+-   ("/xec/xb3/xbb", "HANGUL SYLLABLE CYELH");
+-   ("/xec/xb3/xbc", "HANGUL SYLLABLE CYEM");
+-   ("/xec/xb3/xbd", "HANGUL SYLLABLE CYEB");
+-   ("/xec/xb3/xbe", "HANGUL SYLLABLE CYEBS");
+-   ("/xec/xb3/xbf", "HANGUL SYLLABLE CYES");
+-   ("/xec/xb4/x80", "HANGUL SYLLABLE CYESS");
+-   ("/xec/xb4/x81", "HANGUL SYLLABLE CYENG");
+-   ("/xec/xb4/x82", "HANGUL SYLLABLE CYEJ");
+-   ("/xec/xb4/x83", "HANGUL SYLLABLE CYEC");
+-   ("/xec/xb4/x84", "HANGUL SYLLABLE CYEK");
+-   ("/xec/xb4/x85", "HANGUL SYLLABLE CYET");
+-   ("/xec/xb4/x86", "HANGUL SYLLABLE CYEP");
+-   ("/xec/xb4/x87", "HANGUL SYLLABLE CYEH");
+-   ("/xec/xb4/x88", "HANGUL SYLLABLE CO");
+-   ("/xec/xb4/x89", "HANGUL SYLLABLE COG");
+-   ("/xec/xb4/x8a", "HANGUL SYLLABLE COGG");
+-   ("/xec/xb4/x8b", "HANGUL SYLLABLE COGS");
+-   ("/xec/xb4/x8c", "HANGUL SYLLABLE CON");
+-   ("/xec/xb4/x8d", "HANGUL SYLLABLE CONI");
+-   ("/xec/xb4/x8e", "HANGUL SYLLABLE CONH");
+-   ("/xec/xb4/x8f", "HANGUL SYLLABLE COD");
+-   ("/xec/xb4/x90", "HANGUL SYLLABLE COL");
+-   ("/xec/xb4/x91", "HANGUL SYLLABLE COLG");
+-   ("/xec/xb4/x92", "HANGUL SYLLABLE COLM");
+-   ("/xec/xb4/x93", "HANGUL SYLLABLE COLB");
+-   ("/xec/xb4/x94", "HANGUL SYLLABLE COLS");
+-   ("/xec/xb4/x95", "HANGUL SYLLABLE COLT");
+-   ("/xec/xb4/x96", "HANGUL SYLLABLE COLP");
+-   ("/xec/xb4/x97", "HANGUL SYLLABLE COLH");
+-   ("/xec/xb4/x98", "HANGUL SYLLABLE COM");
+-   ("/xec/xb4/x99", "HANGUL SYLLABLE COB");
+-   ("/xec/xb4/x9a", "HANGUL SYLLABLE COBS");
+-   ("/xec/xb4/x9b", "HANGUL SYLLABLE COS");
+-   ("/xec/xb4/x9c", "HANGUL SYLLABLE COSS");
+-   ("/xec/xb4/x9d", "HANGUL SYLLABLE CONG");
+-   ("/xec/xb4/x9e", "HANGUL SYLLABLE COJ");
+-   ("/xec/xb4/x9f", "HANGUL SYLLABLE COC");
+-   ("/xec/xb4/xa0", "HANGUL SYLLABLE COK");
+-   ("/xec/xb4/xa1", "HANGUL SYLLABLE COT");
+-   ("/xec/xb4/xa2", "HANGUL SYLLABLE COP");
+-   ("/xec/xb4/xa3", "HANGUL SYLLABLE COH");
+-   ("/xec/xb4/xa4", "HANGUL SYLLABLE CWA");
+-   ("/xec/xb4/xa5", "HANGUL SYLLABLE CWAG");
+-   ("/xec/xb4/xa6", "HANGUL SYLLABLE CWAGG");
+-   ("/xec/xb4/xa7", "HANGUL SYLLABLE CWAGS");
+-   ("/xec/xb4/xa8", "HANGUL SYLLABLE CWAN");
+-   ("/xec/xb4/xa9", "HANGUL SYLLABLE CWANI");
+-   ("/xec/xb4/xaa", "HANGUL SYLLABLE CWANH");
+-   ("/xec/xb4/xab", "HANGUL SYLLABLE CWAD");
+-   ("/xec/xb4/xac", "HANGUL SYLLABLE CWAL");
+-   ("/xec/xb4/xad", "HANGUL SYLLABLE CWALG");
+-   ("/xec/xb4/xae", "HANGUL SYLLABLE CWALM");
+-   ("/xec/xb4/xaf", "HANGUL SYLLABLE CWALB");
+-   ("/xec/xb4/xb0", "HANGUL SYLLABLE CWALS");
+-   ("/xec/xb4/xb1", "HANGUL SYLLABLE CWALT");
+-   ("/xec/xb4/xb2", "HANGUL SYLLABLE CWALP");
+-   ("/xec/xb4/xb3", "HANGUL SYLLABLE CWALH");
+-   ("/xec/xb4/xb4", "HANGUL SYLLABLE CWAM");
+-   ("/xec/xb4/xb5", "HANGUL SYLLABLE CWAB");
+-   ("/xec/xb4/xb6", "HANGUL SYLLABLE CWABS");
+-   ("/xec/xb4/xb7", "HANGUL SYLLABLE CWAS");
+-   ("/xec/xb4/xb8", "HANGUL SYLLABLE CWASS");
+-   ("/xec/xb4/xb9", "HANGUL SYLLABLE CWANG");
+-   ("/xec/xb4/xba", "HANGUL SYLLABLE CWAJ");
+-   ("/xec/xb4/xbb", "HANGUL SYLLABLE CWAC");
+-   ("/xec/xb4/xbc", "HANGUL SYLLABLE CWAK");
+-   ("/xec/xb4/xbd", "HANGUL SYLLABLE CWAT");
+-   ("/xec/xb4/xbe", "HANGUL SYLLABLE CWAP");
+-   ("/xec/xb4/xbf", "HANGUL SYLLABLE CWAH");
+-   ("/xec/xb5/x80", "HANGUL SYLLABLE CWAE");
+-   ("/xec/xb5/x81", "HANGUL SYLLABLE CWAEG");
+-   ("/xec/xb5/x82", "HANGUL SYLLABLE CWAEGG");
+-   ("/xec/xb5/x83", "HANGUL SYLLABLE CWAEGS");
+-   ("/xec/xb5/x84", "HANGUL SYLLABLE CWAEN");
+-   ("/xec/xb5/x85", "HANGUL SYLLABLE CWAENI");
+-   ("/xec/xb5/x86", "HANGUL SYLLABLE CWAENH");
+-   ("/xec/xb5/x87", "HANGUL SYLLABLE CWAED");
+-   ("/xec/xb5/x88", "HANGUL SYLLABLE CWAEL");
+-   ("/xec/xb5/x89", "HANGUL SYLLABLE CWAELG");
+-   ("/xec/xb5/x8a", "HANGUL SYLLABLE CWAELM");
+-   ("/xec/xb5/x8b", "HANGUL SYLLABLE CWAELB");
+-   ("/xec/xb5/x8c", "HANGUL SYLLABLE CWAELS");
+-   ("/xec/xb5/x8d", "HANGUL SYLLABLE CWAELT");
+-   ("/xec/xb5/x8e", "HANGUL SYLLABLE CWAELP");
+-   ("/xec/xb5/x8f", "HANGUL SYLLABLE CWAELH");
+-   ("/xec/xb5/x90", "HANGUL SYLLABLE CWAEM");
+-   ("/xec/xb5/x91", "HANGUL SYLLABLE CWAEB");
+-   ("/xec/xb5/x92", "HANGUL SYLLABLE CWAEBS");
+-   ("/xec/xb5/x93", "HANGUL SYLLABLE CWAES");
+-   ("/xec/xb5/x94", "HANGUL SYLLABLE CWAESS");
+-   ("/xec/xb5/x95", "HANGUL SYLLABLE CWAENG");
+-   ("/xec/xb5/x96", "HANGUL SYLLABLE CWAEJ");
+-   ("/xec/xb5/x97", "HANGUL SYLLABLE CWAEC");
+-   ("/xec/xb5/x98", "HANGUL SYLLABLE CWAEK");
+-   ("/xec/xb5/x99", "HANGUL SYLLABLE CWAET");
+-   ("/xec/xb5/x9a", "HANGUL SYLLABLE CWAEP");
+-   ("/xec/xb5/x9b", "HANGUL SYLLABLE CWAEH");
+-   ("/xec/xb5/x9c", "HANGUL SYLLABLE COE");
+-   ("/xec/xb5/x9d", "HANGUL SYLLABLE COEG");
+-   ("/xec/xb5/x9e", "HANGUL SYLLABLE COEGG");
+-   ("/xec/xb5/x9f", "HANGUL SYLLABLE COEGS");
+-   ("/xec/xb5/xa0", "HANGUL SYLLABLE COEN");
+-   ("/xec/xb5/xa1", "HANGUL SYLLABLE COENI");
+-   ("/xec/xb5/xa2", "HANGUL SYLLABLE COENH");
+-   ("/xec/xb5/xa3", "HANGUL SYLLABLE COED");
+-   ("/xec/xb5/xa4", "HANGUL SYLLABLE COEL");
+-   ("/xec/xb5/xa5", "HANGUL SYLLABLE COELG");
+-   ("/xec/xb5/xa6", "HANGUL SYLLABLE COELM");
+-   ("/xec/xb5/xa7", "HANGUL SYLLABLE COELB");
+-   ("/xec/xb5/xa8", "HANGUL SYLLABLE COELS");
+-   ("/xec/xb5/xa9", "HANGUL SYLLABLE COELT");
+-   ("/xec/xb5/xaa", "HANGUL SYLLABLE COELP");
+-   ("/xec/xb5/xab", "HANGUL SYLLABLE COELH");
+-   ("/xec/xb5/xac", "HANGUL SYLLABLE COEM");
+-   ("/xec/xb5/xad", "HANGUL SYLLABLE COEB");
+-   ("/xec/xb5/xae", "HANGUL SYLLABLE COEBS");
+-   ("/xec/xb5/xaf", "HANGUL SYLLABLE COES");
+-   ("/xec/xb5/xb0", "HANGUL SYLLABLE COESS");
+-   ("/xec/xb5/xb1", "HANGUL SYLLABLE COENG");
+-   ("/xec/xb5/xb2", "HANGUL SYLLABLE COEJ");
+-   ("/xec/xb5/xb3", "HANGUL SYLLABLE COEC");
+-   ("/xec/xb5/xb4", "HANGUL SYLLABLE COEK");
+-   ("/xec/xb5/xb5", "HANGUL SYLLABLE COET");
+-   ("/xec/xb5/xb6", "HANGUL SYLLABLE COEP");
+-   ("/xec/xb5/xb7", "HANGUL SYLLABLE COEH");
+-   ("/xec/xb5/xb8", "HANGUL SYLLABLE CYO");
+-   ("/xec/xb5/xb9", "HANGUL SYLLABLE CYOG");
+-   ("/xec/xb5/xba", "HANGUL SYLLABLE CYOGG");
+-   ("/xec/xb5/xbb", "HANGUL SYLLABLE CYOGS");
+-   ("/xec/xb5/xbc", "HANGUL SYLLABLE CYON");
+-   ("/xec/xb5/xbd", "HANGUL SYLLABLE CYONI");
+-   ("/xec/xb5/xbe", "HANGUL SYLLABLE CYONH");
+-   ("/xec/xb5/xbf", "HANGUL SYLLABLE CYOD");
+-   ("/xec/xb6/x80", "HANGUL SYLLABLE CYOL");
+-   ("/xec/xb6/x81", "HANGUL SYLLABLE CYOLG");
+-   ("/xec/xb6/x82", "HANGUL SYLLABLE CYOLM");
+-   ("/xec/xb6/x83", "HANGUL SYLLABLE CYOLB");
+-   ("/xec/xb6/x84", "HANGUL SYLLABLE CYOLS");
+-   ("/xec/xb6/x85", "HANGUL SYLLABLE CYOLT");
+-   ("/xec/xb6/x86", "HANGUL SYLLABLE CYOLP");
+-   ("/xec/xb6/x87", "HANGUL SYLLABLE CYOLH");
+-   ("/xec/xb6/x88", "HANGUL SYLLABLE CYOM");
+-   ("/xec/xb6/x89", "HANGUL SYLLABLE CYOB");
+-   ("/xec/xb6/x8a", "HANGUL SYLLABLE CYOBS");
+-   ("/xec/xb6/x8b", "HANGUL SYLLABLE CYOS");
+-   ("/xec/xb6/x8c", "HANGUL SYLLABLE CYOSS");
+-   ("/xec/xb6/x8d", "HANGUL SYLLABLE CYONG");
+-   ("/xec/xb6/x8e", "HANGUL SYLLABLE CYOJ");
+-   ("/xec/xb6/x8f", "HANGUL SYLLABLE CYOC");
+-   ("/xec/xb6/x90", "HANGUL SYLLABLE CYOK");
+-   ("/xec/xb6/x91", "HANGUL SYLLABLE CYOT");
+-   ("/xec/xb6/x92", "HANGUL SYLLABLE CYOP");
+-   ("/xec/xb6/x93", "HANGUL SYLLABLE CYOH");
+-   ("/xec/xb6/x94", "HANGUL SYLLABLE CU");
+-   ("/xec/xb6/x95", "HANGUL SYLLABLE CUG");
+-   ("/xec/xb6/x96", "HANGUL SYLLABLE CUGG");
+-   ("/xec/xb6/x97", "HANGUL SYLLABLE CUGS");
+-   ("/xec/xb6/x98", "HANGUL SYLLABLE CUN");
+-   ("/xec/xb6/x99", "HANGUL SYLLABLE CUNI");
+-   ("/xec/xb6/x9a", "HANGUL SYLLABLE CUNH");
+-   ("/xec/xb6/x9b", "HANGUL SYLLABLE CUD");
+-   ("/xec/xb6/x9c", "HANGUL SYLLABLE CUL");
+-   ("/xec/xb6/x9d", "HANGUL SYLLABLE CULG");
+-   ("/xec/xb6/x9e", "HANGUL SYLLABLE CULM");
+-   ("/xec/xb6/x9f", "HANGUL SYLLABLE CULB");
+-   ("/xec/xb6/xa0", "HANGUL SYLLABLE CULS");
+-   ("/xec/xb6/xa1", "HANGUL SYLLABLE CULT");
+-   ("/xec/xb6/xa2", "HANGUL SYLLABLE CULP");
+-   ("/xec/xb6/xa3", "HANGUL SYLLABLE CULH");
+-   ("/xec/xb6/xa4", "HANGUL SYLLABLE CUM");
+-   ("/xec/xb6/xa5", "HANGUL SYLLABLE CUB");
+-   ("/xec/xb6/xa6", "HANGUL SYLLABLE CUBS");
+-   ("/xec/xb6/xa7", "HANGUL SYLLABLE CUS");
+-   ("/xec/xb6/xa8", "HANGUL SYLLABLE CUSS");
+-   ("/xec/xb6/xa9", "HANGUL SYLLABLE CUNG");
+-   ("/xec/xb6/xaa", "HANGUL SYLLABLE CUJ");
+-   ("/xec/xb6/xab", "HANGUL SYLLABLE CUC");
+-   ("/xec/xb6/xac", "HANGUL SYLLABLE CUK");
+-   ("/xec/xb6/xad", "HANGUL SYLLABLE CUT");
+-   ("/xec/xb6/xae", "HANGUL SYLLABLE CUP");
+-   ("/xec/xb6/xaf", "HANGUL SYLLABLE CUH");
+-   ("/xec/xb6/xb0", "HANGUL SYLLABLE CWEO");
+-   ("/xec/xb6/xb1", "HANGUL SYLLABLE CWEOG");
+-   ("/xec/xb6/xb2", "HANGUL SYLLABLE CWEOGG");
+-   ("/xec/xb6/xb3", "HANGUL SYLLABLE CWEOGS");
+-   ("/xec/xb6/xb4", "HANGUL SYLLABLE CWEON");
+-   ("/xec/xb6/xb5", "HANGUL SYLLABLE CWEONI");
+-   ("/xec/xb6/xb6", "HANGUL SYLLABLE CWEONH");
+-   ("/xec/xb6/xb7", "HANGUL SYLLABLE CWEOD");
+-   ("/xec/xb6/xb8", "HANGUL SYLLABLE CWEOL");
+-   ("/xec/xb6/xb9", "HANGUL SYLLABLE CWEOLG");
+-   ("/xec/xb6/xba", "HANGUL SYLLABLE CWEOLM");
+-   ("/xec/xb6/xbb", "HANGUL SYLLABLE CWEOLB");
+-   ("/xec/xb6/xbc", "HANGUL SYLLABLE CWEOLS");
+-   ("/xec/xb6/xbd", "HANGUL SYLLABLE CWEOLT");
+-   ("/xec/xb6/xbe", "HANGUL SYLLABLE CWEOLP");
+-   ("/xec/xb6/xbf", "HANGUL SYLLABLE CWEOLH");
+-   ("/xec/xb7/x80", "HANGUL SYLLABLE CWEOM");
+-   ("/xec/xb7/x81", "HANGUL SYLLABLE CWEOB");
+-   ("/xec/xb7/x82", "HANGUL SYLLABLE CWEOBS");
+-   ("/xec/xb7/x83", "HANGUL SYLLABLE CWEOS");
+-   ("/xec/xb7/x84", "HANGUL SYLLABLE CWEOSS");
+-   ("/xec/xb7/x85", "HANGUL SYLLABLE CWEONG");
+-   ("/xec/xb7/x86", "HANGUL SYLLABLE CWEOJ");
+-   ("/xec/xb7/x87", "HANGUL SYLLABLE CWEOC");
+-   ("/xec/xb7/x88", "HANGUL SYLLABLE CWEOK");
+-   ("/xec/xb7/x89", "HANGUL SYLLABLE CWEOT");
+-   ("/xec/xb7/x8a", "HANGUL SYLLABLE CWEOP");
+-   ("/xec/xb7/x8b", "HANGUL SYLLABLE CWEOH");
+-   ("/xec/xb7/x8c", "HANGUL SYLLABLE CWE");
+-   ("/xec/xb7/x8d", "HANGUL SYLLABLE CWEG");
+-   ("/xec/xb7/x8e", "HANGUL SYLLABLE CWEGG");
+-   ("/xec/xb7/x8f", "HANGUL SYLLABLE CWEGS");
+-   ("/xec/xb7/x90", "HANGUL SYLLABLE CWEN");
+-   ("/xec/xb7/x91", "HANGUL SYLLABLE CWENI");
+-   ("/xec/xb7/x92", "HANGUL SYLLABLE CWENH");
+-   ("/xec/xb7/x93", "HANGUL SYLLABLE CWED");
+-   ("/xec/xb7/x94", "HANGUL SYLLABLE CWEL");
+-   ("/xec/xb7/x95", "HANGUL SYLLABLE CWELG");
+-   ("/xec/xb7/x96", "HANGUL SYLLABLE CWELM");
+-   ("/xec/xb7/x97", "HANGUL SYLLABLE CWELB");
+-   ("/xec/xb7/x98", "HANGUL SYLLABLE CWELS");
+-   ("/xec/xb7/x99", "HANGUL SYLLABLE CWELT");
+-   ("/xec/xb7/x9a", "HANGUL SYLLABLE CWELP");
+-   ("/xec/xb7/x9b", "HANGUL SYLLABLE CWELH");
+-   ("/xec/xb7/x9c", "HANGUL SYLLABLE CWEM");
+-   ("/xec/xb7/x9d", "HANGUL SYLLABLE CWEB");
+-   ("/xec/xb7/x9e", "HANGUL SYLLABLE CWEBS");
+-   ("/xec/xb7/x9f", "HANGUL SYLLABLE CWES");
+-   ("/xec/xb7/xa0", "HANGUL SYLLABLE CWESS");
+-   ("/xec/xb7/xa1", "HANGUL SYLLABLE CWENG");
+-   ("/xec/xb7/xa2", "HANGUL SYLLABLE CWEJ");
+-   ("/xec/xb7/xa3", "HANGUL SYLLABLE CWEC");
+-   ("/xec/xb7/xa4", "HANGUL SYLLABLE CWEK");
+-   ("/xec/xb7/xa5", "HANGUL SYLLABLE CWET");
+-   ("/xec/xb7/xa6", "HANGUL SYLLABLE CWEP");
+-   ("/xec/xb7/xa7", "HANGUL SYLLABLE CWEH");
+-   ("/xec/xb7/xa8", "HANGUL SYLLABLE CWI");
+-   ("/xec/xb7/xa9", "HANGUL SYLLABLE CWIG");
+-   ("/xec/xb7/xaa", "HANGUL SYLLABLE CWIGG");
+-   ("/xec/xb7/xab", "HANGUL SYLLABLE CWIGS");
+-   ("/xec/xb7/xac", "HANGUL SYLLABLE CWIN");
+-   ("/xec/xb7/xad", "HANGUL SYLLABLE CWINI");
+-   ("/xec/xb7/xae", "HANGUL SYLLABLE CWINH");
+-   ("/xec/xb7/xaf", "HANGUL SYLLABLE CWID");
+-   ("/xec/xb7/xb0", "HANGUL SYLLABLE CWIL");
+-   ("/xec/xb7/xb1", "HANGUL SYLLABLE CWILG");
+-   ("/xec/xb7/xb2", "HANGUL SYLLABLE CWILM");
+-   ("/xec/xb7/xb3", "HANGUL SYLLABLE CWILB");
+-   ("/xec/xb7/xb4", "HANGUL SYLLABLE CWILS");
+-   ("/xec/xb7/xb5", "HANGUL SYLLABLE CWILT");
+-   ("/xec/xb7/xb6", "HANGUL SYLLABLE CWILP");
+-   ("/xec/xb7/xb7", "HANGUL SYLLABLE CWILH");
+-   ("/xec/xb7/xb8", "HANGUL SYLLABLE CWIM");
+-   ("/xec/xb7/xb9", "HANGUL SYLLABLE CWIB");
+-   ("/xec/xb7/xba", "HANGUL SYLLABLE CWIBS");
+-   ("/xec/xb7/xbb", "HANGUL SYLLABLE CWIS");
+-   ("/xec/xb7/xbc", "HANGUL SYLLABLE CWISS");
+-   ("/xec/xb7/xbd", "HANGUL SYLLABLE CWING");
+-   ("/xec/xb7/xbe", "HANGUL SYLLABLE CWIJ");
+-   ("/xec/xb7/xbf", "HANGUL SYLLABLE CWIC");
+-   ("/xec/xb8/x80", "HANGUL SYLLABLE CWIK");
+-   ("/xec/xb8/x81", "HANGUL SYLLABLE CWIT");
+-   ("/xec/xb8/x82", "HANGUL SYLLABLE CWIP");
+-   ("/xec/xb8/x83", "HANGUL SYLLABLE CWIH");
+-   ("/xec/xb8/x84", "HANGUL SYLLABLE CYU");
+-   ("/xec/xb8/x85", "HANGUL SYLLABLE CYUG");
+-   ("/xec/xb8/x86", "HANGUL SYLLABLE CYUGG");
+-   ("/xec/xb8/x87", "HANGUL SYLLABLE CYUGS");
+-   ("/xec/xb8/x88", "HANGUL SYLLABLE CYUN");
+-   ("/xec/xb8/x89", "HANGUL SYLLABLE CYUNI");
+-   ("/xec/xb8/x8a", "HANGUL SYLLABLE CYUNH");
+-   ("/xec/xb8/x8b", "HANGUL SYLLABLE CYUD");
+-   ("/xec/xb8/x8c", "HANGUL SYLLABLE CYUL");
+-   ("/xec/xb8/x8d", "HANGUL SYLLABLE CYULG");
+-   ("/xec/xb8/x8e", "HANGUL SYLLABLE CYULM");
+-   ("/xec/xb8/x8f", "HANGUL SYLLABLE CYULB");
+-   ("/xec/xb8/x90", "HANGUL SYLLABLE CYULS");
+-   ("/xec/xb8/x91", "HANGUL SYLLABLE CYULT");
+-   ("/xec/xb8/x92", "HANGUL SYLLABLE CYULP");
+-   ("/xec/xb8/x93", "HANGUL SYLLABLE CYULH");
+-   ("/xec/xb8/x94", "HANGUL SYLLABLE CYUM");
+-   ("/xec/xb8/x95", "HANGUL SYLLABLE CYUB");
+-   ("/xec/xb8/x96", "HANGUL SYLLABLE CYUBS");
+-   ("/xec/xb8/x97", "HANGUL SYLLABLE CYUS");
+-   ("/xec/xb8/x98", "HANGUL SYLLABLE CYUSS");
+-   ("/xec/xb8/x99", "HANGUL SYLLABLE CYUNG");
+-   ("/xec/xb8/x9a", "HANGUL SYLLABLE CYUJ");
+-   ("/xec/xb8/x9b", "HANGUL SYLLABLE CYUC");
+-   ("/xec/xb8/x9c", "HANGUL SYLLABLE CYUK");
+-   ("/xec/xb8/x9d", "HANGUL SYLLABLE CYUT");
+-   ("/xec/xb8/x9e", "HANGUL SYLLABLE CYUP");
+-   ("/xec/xb8/x9f", "HANGUL SYLLABLE CYUH");
+-   ("/xec/xb8/xa0", "HANGUL SYLLABLE CEU");
+-   ("/xec/xb8/xa1", "HANGUL SYLLABLE CEUG");
+-   ("/xec/xb8/xa2", "HANGUL SYLLABLE CEUGG");
+-   ("/xec/xb8/xa3", "HANGUL SYLLABLE CEUGS");
+-   ("/xec/xb8/xa4", "HANGUL SYLLABLE CEUN");
+-   ("/xec/xb8/xa5", "HANGUL SYLLABLE CEUNI");
+-   ("/xec/xb8/xa6", "HANGUL SYLLABLE CEUNH");
+-   ("/xec/xb8/xa7", "HANGUL SYLLABLE CEUD");
+-   ("/xec/xb8/xa8", "HANGUL SYLLABLE CEUL");
+-   ("/xec/xb8/xa9", "HANGUL SYLLABLE CEULG");
+-   ("/xec/xb8/xaa", "HANGUL SYLLABLE CEULM");
+-   ("/xec/xb8/xab", "HANGUL SYLLABLE CEULB");
+-   ("/xec/xb8/xac", "HANGUL SYLLABLE CEULS");
+-   ("/xec/xb8/xad", "HANGUL SYLLABLE CEULT");
+-   ("/xec/xb8/xae", "HANGUL SYLLABLE CEULP");
+-   ("/xec/xb8/xaf", "HANGUL SYLLABLE CEULH");
+-   ("/xec/xb8/xb0", "HANGUL SYLLABLE CEUM");
+-   ("/xec/xb8/xb1", "HANGUL SYLLABLE CEUB");
+-   ("/xec/xb8/xb2", "HANGUL SYLLABLE CEUBS");
+-   ("/xec/xb8/xb3", "HANGUL SYLLABLE CEUS");
+-   ("/xec/xb8/xb4", "HANGUL SYLLABLE CEUSS");
+-   ("/xec/xb8/xb5", "HANGUL SYLLABLE CEUNG");
+-   ("/xec/xb8/xb6", "HANGUL SYLLABLE CEUJ");
+-   ("/xec/xb8/xb7", "HANGUL SYLLABLE CEUC");
+-   ("/xec/xb8/xb8", "HANGUL SYLLABLE CEUK");
+-   ("/xec/xb8/xb9", "HANGUL SYLLABLE CEUT");
+-   ("/xec/xb8/xba", "HANGUL SYLLABLE CEUP");
+-   ("/xec/xb8/xbb", "HANGUL SYLLABLE CEUH");
+-   ("/xec/xb8/xbc", "HANGUL SYLLABLE CYI");
+-   ("/xec/xb8/xbd", "HANGUL SYLLABLE CYIG");
+-   ("/xec/xb8/xbe", "HANGUL SYLLABLE CYIGG");
+-   ("/xec/xb8/xbf", "HANGUL SYLLABLE CYIGS");
+-   ("/xec/xb9/x80", "HANGUL SYLLABLE CYIN");
+-   ("/xec/xb9/x81", "HANGUL SYLLABLE CYINI");
+-   ("/xec/xb9/x82", "HANGUL SYLLABLE CYINH");
+-   ("/xec/xb9/x83", "HANGUL SYLLABLE CYID");
+-   ("/xec/xb9/x84", "HANGUL SYLLABLE CYIL");
+-   ("/xec/xb9/x85", "HANGUL SYLLABLE CYILG");
+-   ("/xec/xb9/x86", "HANGUL SYLLABLE CYILM");
+-   ("/xec/xb9/x87", "HANGUL SYLLABLE CYILB");
+-   ("/xec/xb9/x88", "HANGUL SYLLABLE CYILS");
+-   ("/xec/xb9/x89", "HANGUL SYLLABLE CYILT");
+-   ("/xec/xb9/x8a", "HANGUL SYLLABLE CYILP");
+-   ("/xec/xb9/x8b", "HANGUL SYLLABLE CYILH");
+-   ("/xec/xb9/x8c", "HANGUL SYLLABLE CYIM");
+-   ("/xec/xb9/x8d", "HANGUL SYLLABLE CYIB");
+-   ("/xec/xb9/x8e", "HANGUL SYLLABLE CYIBS");
+-   ("/xec/xb9/x8f", "HANGUL SYLLABLE CYIS");
+-   ("/xec/xb9/x90", "HANGUL SYLLABLE CYISS");
+-   ("/xec/xb9/x91", "HANGUL SYLLABLE CYING");
+-   ("/xec/xb9/x92", "HANGUL SYLLABLE CYIJ");
+-   ("/xec/xb9/x93", "HANGUL SYLLABLE CYIC");
+-   ("/xec/xb9/x94", "HANGUL SYLLABLE CYIK");
+-   ("/xec/xb9/x95", "HANGUL SYLLABLE CYIT");
+-   ("/xec/xb9/x96", "HANGUL SYLLABLE CYIP");
+-   ("/xec/xb9/x97", "HANGUL SYLLABLE CYIH");
+-   ("/xec/xb9/x98", "HANGUL SYLLABLE CI");
+-   ("/xec/xb9/x99", "HANGUL SYLLABLE CIG");
+-   ("/xec/xb9/x9a", "HANGUL SYLLABLE CIGG");
+-   ("/xec/xb9/x9b", "HANGUL SYLLABLE CIGS");
+-   ("/xec/xb9/x9c", "HANGUL SYLLABLE CIN");
+-   ("/xec/xb9/x9d", "HANGUL SYLLABLE CINI");
+-   ("/xec/xb9/x9e", "HANGUL SYLLABLE CINH");
+-   ("/xec/xb9/x9f", "HANGUL SYLLABLE CID");
+-   ("/xec/xb9/xa0", "HANGUL SYLLABLE CIL");
+-   ("/xec/xb9/xa1", "HANGUL SYLLABLE CILG");
+-   ("/xec/xb9/xa2", "HANGUL SYLLABLE CILM");
+-   ("/xec/xb9/xa3", "HANGUL SYLLABLE CILB");
+-   ("/xec/xb9/xa4", "HANGUL SYLLABLE CILS");
+-   ("/xec/xb9/xa5", "HANGUL SYLLABLE CILT");
+-   ("/xec/xb9/xa6", "HANGUL SYLLABLE CILP");
+-   ("/xec/xb9/xa7", "HANGUL SYLLABLE CILH");
+-   ("/xec/xb9/xa8", "HANGUL SYLLABLE CIM");
+-   ("/xec/xb9/xa9", "HANGUL SYLLABLE CIB");
+-   ("/xec/xb9/xaa", "HANGUL SYLLABLE CIBS");
+-   ("/xec/xb9/xab", "HANGUL SYLLABLE CIS");
+-   ("/xec/xb9/xac", "HANGUL SYLLABLE CISS");
+-   ("/xec/xb9/xad", "HANGUL SYLLABLE CING");
+-   ("/xec/xb9/xae", "HANGUL SYLLABLE CIJ");
+-   ("/xec/xb9/xaf", "HANGUL SYLLABLE CIC");
+-   ("/xec/xb9/xb0", "HANGUL SYLLABLE CIK");
+-   ("/xec/xb9/xb1", "HANGUL SYLLABLE CIT");
+-   ("/xec/xb9/xb2", "HANGUL SYLLABLE CIP");
+-   ("/xec/xb9/xb3", "HANGUL SYLLABLE CIH");
+-   ("/xec/xb9/xb4", "HANGUL SYLLABLE KA");
+-   ("/xec/xb9/xb5", "HANGUL SYLLABLE KAG");
+-   ("/xec/xb9/xb6", "HANGUL SYLLABLE KAGG");
+-   ("/xec/xb9/xb7", "HANGUL SYLLABLE KAGS");
+-   ("/xec/xb9/xb8", "HANGUL SYLLABLE KAN");
+-   ("/xec/xb9/xb9", "HANGUL SYLLABLE KANI");
+-   ("/xec/xb9/xba", "HANGUL SYLLABLE KANH");
+-   ("/xec/xb9/xbb", "HANGUL SYLLABLE KAD");
+-   ("/xec/xb9/xbc", "HANGUL SYLLABLE KAL");
+-   ("/xec/xb9/xbd", "HANGUL SYLLABLE KALG");
+-   ("/xec/xb9/xbe", "HANGUL SYLLABLE KALM");
+-   ("/xec/xb9/xbf", "HANGUL SYLLABLE KALB");
+-   ("/xec/xba/x80", "HANGUL SYLLABLE KALS");
+-   ("/xec/xba/x81", "HANGUL SYLLABLE KALT");
+-   ("/xec/xba/x82", "HANGUL SYLLABLE KALP");
+-   ("/xec/xba/x83", "HANGUL SYLLABLE KALH");
+-   ("/xec/xba/x84", "HANGUL SYLLABLE KAM");
+-   ("/xec/xba/x85", "HANGUL SYLLABLE KAB");
+-   ("/xec/xba/x86", "HANGUL SYLLABLE KABS");
+-   ("/xec/xba/x87", "HANGUL SYLLABLE KAS");
+-   ("/xec/xba/x88", "HANGUL SYLLABLE KASS");
+-   ("/xec/xba/x89", "HANGUL SYLLABLE KANG");
+-   ("/xec/xba/x8a", "HANGUL SYLLABLE KAJ");
+-   ("/xec/xba/x8b", "HANGUL SYLLABLE KAC");
+-   ("/xec/xba/x8c", "HANGUL SYLLABLE KAK");
+-   ("/xec/xba/x8d", "HANGUL SYLLABLE KAT");
+-   ("/xec/xba/x8e", "HANGUL SYLLABLE KAP");
+-   ("/xec/xba/x8f", "HANGUL SYLLABLE KAH");
+-   ("/xec/xba/x90", "HANGUL SYLLABLE KAE");
+-   ("/xec/xba/x91", "HANGUL SYLLABLE KAEG");
+-   ("/xec/xba/x92", "HANGUL SYLLABLE KAEGG");
+-   ("/xec/xba/x93", "HANGUL SYLLABLE KAEGS");
+-   ("/xec/xba/x94", "HANGUL SYLLABLE KAEN");
+-   ("/xec/xba/x95", "HANGUL SYLLABLE KAENI");
+-   ("/xec/xba/x96", "HANGUL SYLLABLE KAENH");
+-   ("/xec/xba/x97", "HANGUL SYLLABLE KAED");
+-   ("/xec/xba/x98", "HANGUL SYLLABLE KAEL");
+-   ("/xec/xba/x99", "HANGUL SYLLABLE KAELG");
+-   ("/xec/xba/x9a", "HANGUL SYLLABLE KAELM");
+-   ("/xec/xba/x9b", "HANGUL SYLLABLE KAELB");
+-   ("/xec/xba/x9c", "HANGUL SYLLABLE KAELS");
+-   ("/xec/xba/x9d", "HANGUL SYLLABLE KAELT");
+-   ("/xec/xba/x9e", "HANGUL SYLLABLE KAELP");
+-   ("/xec/xba/x9f", "HANGUL SYLLABLE KAELH");
+-   ("/xec/xba/xa0", "HANGUL SYLLABLE KAEM");
+-   ("/xec/xba/xa1", "HANGUL SYLLABLE KAEB");
+-   ("/xec/xba/xa2", "HANGUL SYLLABLE KAEBS");
+-   ("/xec/xba/xa3", "HANGUL SYLLABLE KAES");
+-   ("/xec/xba/xa4", "HANGUL SYLLABLE KAESS");
+-   ("/xec/xba/xa5", "HANGUL SYLLABLE KAENG");
+-   ("/xec/xba/xa6", "HANGUL SYLLABLE KAEJ");
+-   ("/xec/xba/xa7", "HANGUL SYLLABLE KAEC");
+-   ("/xec/xba/xa8", "HANGUL SYLLABLE KAEK");
+-   ("/xec/xba/xa9", "HANGUL SYLLABLE KAET");
+-   ("/xec/xba/xaa", "HANGUL SYLLABLE KAEP");
+-   ("/xec/xba/xab", "HANGUL SYLLABLE KAEH");
+-   ("/xec/xba/xac", "HANGUL SYLLABLE KYA");
+-   ("/xec/xba/xad", "HANGUL SYLLABLE KYAG");
+-   ("/xec/xba/xae", "HANGUL SYLLABLE KYAGG");
+-   ("/xec/xba/xaf", "HANGUL SYLLABLE KYAGS");
+-   ("/xec/xba/xb0", "HANGUL SYLLABLE KYAN");
+-   ("/xec/xba/xb1", "HANGUL SYLLABLE KYANI");
+-   ("/xec/xba/xb2", "HANGUL SYLLABLE KYANH");
+-   ("/xec/xba/xb3", "HANGUL SYLLABLE KYAD");
+-   ("/xec/xba/xb4", "HANGUL SYLLABLE KYAL");
+-   ("/xec/xba/xb5", "HANGUL SYLLABLE KYALG");
+-   ("/xec/xba/xb6", "HANGUL SYLLABLE KYALM");
+-   ("/xec/xba/xb7", "HANGUL SYLLABLE KYALB");
+-   ("/xec/xba/xb8", "HANGUL SYLLABLE KYALS");
+-   ("/xec/xba/xb9", "HANGUL SYLLABLE KYALT");
+-   ("/xec/xba/xba", "HANGUL SYLLABLE KYALP");
+-   ("/xec/xba/xbb", "HANGUL SYLLABLE KYALH");
+-   ("/xec/xba/xbc", "HANGUL SYLLABLE KYAM");
+-   ("/xec/xba/xbd", "HANGUL SYLLABLE KYAB");
+-   ("/xec/xba/xbe", "HANGUL SYLLABLE KYABS");
+-   ("/xec/xba/xbf", "HANGUL SYLLABLE KYAS");
+-   ("/xec/xbb/x80", "HANGUL SYLLABLE KYASS");
+-   ("/xec/xbb/x81", "HANGUL SYLLABLE KYANG");
+-   ("/xec/xbb/x82", "HANGUL SYLLABLE KYAJ");
+-   ("/xec/xbb/x83", "HANGUL SYLLABLE KYAC");
+-   ("/xec/xbb/x84", "HANGUL SYLLABLE KYAK");
+-   ("/xec/xbb/x85", "HANGUL SYLLABLE KYAT");
+-   ("/xec/xbb/x86", "HANGUL SYLLABLE KYAP");
+-   ("/xec/xbb/x87", "HANGUL SYLLABLE KYAH");
+-   ("/xec/xbb/x88", "HANGUL SYLLABLE KYAE");
+-   ("/xec/xbb/x89", "HANGUL SYLLABLE KYAEG");
+-   ("/xec/xbb/x8a", "HANGUL SYLLABLE KYAEGG");
+-   ("/xec/xbb/x8b", "HANGUL SYLLABLE KYAEGS");
+-   ("/xec/xbb/x8c", "HANGUL SYLLABLE KYAEN");
+-   ("/xec/xbb/x8d", "HANGUL SYLLABLE KYAENI");
+-   ("/xec/xbb/x8e", "HANGUL SYLLABLE KYAENH");
+-   ("/xec/xbb/x8f", "HANGUL SYLLABLE KYAED");
+-   ("/xec/xbb/x90", "HANGUL SYLLABLE KYAEL");
+-   ("/xec/xbb/x91", "HANGUL SYLLABLE KYAELG");
+-   ("/xec/xbb/x92", "HANGUL SYLLABLE KYAELM");
+-   ("/xec/xbb/x93", "HANGUL SYLLABLE KYAELB");
+-   ("/xec/xbb/x94", "HANGUL SYLLABLE KYAELS");
+-   ("/xec/xbb/x95", "HANGUL SYLLABLE KYAELT");
+-   ("/xec/xbb/x96", "HANGUL SYLLABLE KYAELP");
+-   ("/xec/xbb/x97", "HANGUL SYLLABLE KYAELH");
+-   ("/xec/xbb/x98", "HANGUL SYLLABLE KYAEM");
+-   ("/xec/xbb/x99", "HANGUL SYLLABLE KYAEB");
+-   ("/xec/xbb/x9a", "HANGUL SYLLABLE KYAEBS");
+-   ("/xec/xbb/x9b", "HANGUL SYLLABLE KYAES");
+-   ("/xec/xbb/x9c", "HANGUL SYLLABLE KYAESS");
+-   ("/xec/xbb/x9d", "HANGUL SYLLABLE KYAENG");
+-   ("/xec/xbb/x9e", "HANGUL SYLLABLE KYAEJ");
+-   ("/xec/xbb/x9f", "HANGUL SYLLABLE KYAEC");
+-   ("/xec/xbb/xa0", "HANGUL SYLLABLE KYAEK");
+-   ("/xec/xbb/xa1", "HANGUL SYLLABLE KYAET");
+-   ("/xec/xbb/xa2", "HANGUL SYLLABLE KYAEP");
+-   ("/xec/xbb/xa3", "HANGUL SYLLABLE KYAEH");
+-   ("/xec/xbb/xa4", "HANGUL SYLLABLE KEO");
+-   ("/xec/xbb/xa5", "HANGUL SYLLABLE KEOG");
+-   ("/xec/xbb/xa6", "HANGUL SYLLABLE KEOGG");
+-   ("/xec/xbb/xa7", "HANGUL SYLLABLE KEOGS");
+-   ("/xec/xbb/xa8", "HANGUL SYLLABLE KEON");
+-   ("/xec/xbb/xa9", "HANGUL SYLLABLE KEONI");
+-   ("/xec/xbb/xaa", "HANGUL SYLLABLE KEONH");
+-   ("/xec/xbb/xab", "HANGUL SYLLABLE KEOD");
+-   ("/xec/xbb/xac", "HANGUL SYLLABLE KEOL");
+-   ("/xec/xbb/xad", "HANGUL SYLLABLE KEOLG");
+-   ("/xec/xbb/xae", "HANGUL SYLLABLE KEOLM");
+-   ("/xec/xbb/xaf", "HANGUL SYLLABLE KEOLB");
+-   ("/xec/xbb/xb0", "HANGUL SYLLABLE KEOLS");
+-   ("/xec/xbb/xb1", "HANGUL SYLLABLE KEOLT");
+-   ("/xec/xbb/xb2", "HANGUL SYLLABLE KEOLP");
+-   ("/xec/xbb/xb3", "HANGUL SYLLABLE KEOLH");
+-   ("/xec/xbb/xb4", "HANGUL SYLLABLE KEOM");
+-   ("/xec/xbb/xb5", "HANGUL SYLLABLE KEOB");
+-   ("/xec/xbb/xb6", "HANGUL SYLLABLE KEOBS");
+-   ("/xec/xbb/xb7", "HANGUL SYLLABLE KEOS");
+-   ("/xec/xbb/xb8", "HANGUL SYLLABLE KEOSS");
+-   ("/xec/xbb/xb9", "HANGUL SYLLABLE KEONG");
+-   ("/xec/xbb/xba", "HANGUL SYLLABLE KEOJ");
+-   ("/xec/xbb/xbb", "HANGUL SYLLABLE KEOC");
+-   ("/xec/xbb/xbc", "HANGUL SYLLABLE KEOK");
+-   ("/xec/xbb/xbd", "HANGUL SYLLABLE KEOT");
+-   ("/xec/xbb/xbe", "HANGUL SYLLABLE KEOP");
+-   ("/xec/xbb/xbf", "HANGUL SYLLABLE KEOH");
+-   ("/xec/xbc/x80", "HANGUL SYLLABLE KE");
+-   ("/xec/xbc/x81", "HANGUL SYLLABLE KEG");
+-   ("/xec/xbc/x82", "HANGUL SYLLABLE KEGG");
+-   ("/xec/xbc/x83", "HANGUL SYLLABLE KEGS");
+-   ("/xec/xbc/x84", "HANGUL SYLLABLE KEN");
+-   ("/xec/xbc/x85", "HANGUL SYLLABLE KENI");
+-   ("/xec/xbc/x86", "HANGUL SYLLABLE KENH");
+-   ("/xec/xbc/x87", "HANGUL SYLLABLE KED");
+-   ("/xec/xbc/x88", "HANGUL SYLLABLE KEL");
+-   ("/xec/xbc/x89", "HANGUL SYLLABLE KELG");
+-   ("/xec/xbc/x8a", "HANGUL SYLLABLE KELM");
+-   ("/xec/xbc/x8b", "HANGUL SYLLABLE KELB");
+-   ("/xec/xbc/x8c", "HANGUL SYLLABLE KELS");
+-   ("/xec/xbc/x8d", "HANGUL SYLLABLE KELT");
+-   ("/xec/xbc/x8e", "HANGUL SYLLABLE KELP");
+-   ("/xec/xbc/x8f", "HANGUL SYLLABLE KELH");
+-   ("/xec/xbc/x90", "HANGUL SYLLABLE KEM");
+-   ("/xec/xbc/x91", "HANGUL SYLLABLE KEB");
+-   ("/xec/xbc/x92", "HANGUL SYLLABLE KEBS");
+-   ("/xec/xbc/x93", "HANGUL SYLLABLE KES");
+-   ("/xec/xbc/x94", "HANGUL SYLLABLE KESS");
+-   ("/xec/xbc/x95", "HANGUL SYLLABLE KENG");
+-   ("/xec/xbc/x96", "HANGUL SYLLABLE KEJ");
+-   ("/xec/xbc/x97", "HANGUL SYLLABLE KEC");
+-   ("/xec/xbc/x98", "HANGUL SYLLABLE KEK");
+-   ("/xec/xbc/x99", "HANGUL SYLLABLE KET");
+-   ("/xec/xbc/x9a", "HANGUL SYLLABLE KEP");
+-   ("/xec/xbc/x9b", "HANGUL SYLLABLE KEH");
+-   ("/xec/xbc/x9c", "HANGUL SYLLABLE KYEO");
+-   ("/xec/xbc/x9d", "HANGUL SYLLABLE KYEOG");
+-   ("/xec/xbc/x9e", "HANGUL SYLLABLE KYEOGG");
+-   ("/xec/xbc/x9f", "HANGUL SYLLABLE KYEOGS");
+-   ("/xec/xbc/xa0", "HANGUL SYLLABLE KYEON");
+-   ("/xec/xbc/xa1", "HANGUL SYLLABLE KYEONI");
+-   ("/xec/xbc/xa2", "HANGUL SYLLABLE KYEONH");
+-   ("/xec/xbc/xa3", "HANGUL SYLLABLE KYEOD");
+-   ("/xec/xbc/xa4", "HANGUL SYLLABLE KYEOL");
+-   ("/xec/xbc/xa5", "HANGUL SYLLABLE KYEOLG");
+-   ("/xec/xbc/xa6", "HANGUL SYLLABLE KYEOLM");
+-   ("/xec/xbc/xa7", "HANGUL SYLLABLE KYEOLB");
+-   ("/xec/xbc/xa8", "HANGUL SYLLABLE KYEOLS");
+-   ("/xec/xbc/xa9", "HANGUL SYLLABLE KYEOLT");
+-   ("/xec/xbc/xaa", "HANGUL SYLLABLE KYEOLP");
+-   ("/xec/xbc/xab", "HANGUL SYLLABLE KYEOLH");
+-   ("/xec/xbc/xac", "HANGUL SYLLABLE KYEOM");
+-   ("/xec/xbc/xad", "HANGUL SYLLABLE KYEOB");
+-   ("/xec/xbc/xae", "HANGUL SYLLABLE KYEOBS");
+-   ("/xec/xbc/xaf", "HANGUL SYLLABLE KYEOS");
+-   ("/xec/xbc/xb0", "HANGUL SYLLABLE KYEOSS");
+-   ("/xec/xbc/xb1", "HANGUL SYLLABLE KYEONG");
+-   ("/xec/xbc/xb2", "HANGUL SYLLABLE KYEOJ");
+-   ("/xec/xbc/xb3", "HANGUL SYLLABLE KYEOC");
+-   ("/xec/xbc/xb4", "HANGUL SYLLABLE KYEOK");
+-   ("/xec/xbc/xb5", "HANGUL SYLLABLE KYEOT");
+-   ("/xec/xbc/xb6", "HANGUL SYLLABLE KYEOP");
+-   ("/xec/xbc/xb7", "HANGUL SYLLABLE KYEOH");
+-   ("/xec/xbc/xb8", "HANGUL SYLLABLE KYE");
+-   ("/xec/xbc/xb9", "HANGUL SYLLABLE KYEG");
+-   ("/xec/xbc/xba", "HANGUL SYLLABLE KYEGG");
+-   ("/xec/xbc/xbb", "HANGUL SYLLABLE KYEGS");
+-   ("/xec/xbc/xbc", "HANGUL SYLLABLE KYEN");
+-   ("/xec/xbc/xbd", "HANGUL SYLLABLE KYENI");
+-   ("/xec/xbc/xbe", "HANGUL SYLLABLE KYENH");
+-   ("/xec/xbc/xbf", "HANGUL SYLLABLE KYED");
+-   ("/xec/xbd/x80", "HANGUL SYLLABLE KYEL");
+-   ("/xec/xbd/x81", "HANGUL SYLLABLE KYELG");
+-   ("/xec/xbd/x82", "HANGUL SYLLABLE KYELM");
+-   ("/xec/xbd/x83", "HANGUL SYLLABLE KYELB");
+-   ("/xec/xbd/x84", "HANGUL SYLLABLE KYELS");
+-   ("/xec/xbd/x85", "HANGUL SYLLABLE KYELT");
+-   ("/xec/xbd/x86", "HANGUL SYLLABLE KYELP");
+-   ("/xec/xbd/x87", "HANGUL SYLLABLE KYELH");
+-   ("/xec/xbd/x88", "HANGUL SYLLABLE KYEM");
+-   ("/xec/xbd/x89", "HANGUL SYLLABLE KYEB");
+-   ("/xec/xbd/x8a", "HANGUL SYLLABLE KYEBS");
+-   ("/xec/xbd/x8b", "HANGUL SYLLABLE KYES");
+-   ("/xec/xbd/x8c", "HANGUL SYLLABLE KYESS");
+-   ("/xec/xbd/x8d", "HANGUL SYLLABLE KYENG");
+-   ("/xec/xbd/x8e", "HANGUL SYLLABLE KYEJ");
+-   ("/xec/xbd/x8f", "HANGUL SYLLABLE KYEC");
+-   ("/xec/xbd/x90", "HANGUL SYLLABLE KYEK");
+-   ("/xec/xbd/x91", "HANGUL SYLLABLE KYET");
+-   ("/xec/xbd/x92", "HANGUL SYLLABLE KYEP");
+-   ("/xec/xbd/x93", "HANGUL SYLLABLE KYEH");
+-   ("/xec/xbd/x94", "HANGUL SYLLABLE KO");
+-   ("/xec/xbd/x95", "HANGUL SYLLABLE KOG");
+-   ("/xec/xbd/x96", "HANGUL SYLLABLE KOGG");
+-   ("/xec/xbd/x97", "HANGUL SYLLABLE KOGS");
+-   ("/xec/xbd/x98", "HANGUL SYLLABLE KON");
+-   ("/xec/xbd/x99", "HANGUL SYLLABLE KONI");
+-   ("/xec/xbd/x9a", "HANGUL SYLLABLE KONH");
+-   ("/xec/xbd/x9b", "HANGUL SYLLABLE KOD");
+-   ("/xec/xbd/x9c", "HANGUL SYLLABLE KOL");
+-   ("/xec/xbd/x9d", "HANGUL SYLLABLE KOLG");
+-   ("/xec/xbd/x9e", "HANGUL SYLLABLE KOLM");
+-   ("/xec/xbd/x9f", "HANGUL SYLLABLE KOLB");
+-   ("/xec/xbd/xa0", "HANGUL SYLLABLE KOLS");
+-   ("/xec/xbd/xa1", "HANGUL SYLLABLE KOLT");
+-   ("/xec/xbd/xa2", "HANGUL SYLLABLE KOLP");
+-   ("/xec/xbd/xa3", "HANGUL SYLLABLE KOLH");
+-   ("/xec/xbd/xa4", "HANGUL SYLLABLE KOM");
+-   ("/xec/xbd/xa5", "HANGUL SYLLABLE KOB");
+-   ("/xec/xbd/xa6", "HANGUL SYLLABLE KOBS");
+-   ("/xec/xbd/xa7", "HANGUL SYLLABLE KOS");
+-   ("/xec/xbd/xa8", "HANGUL SYLLABLE KOSS");
+-   ("/xec/xbd/xa9", "HANGUL SYLLABLE KONG");
+-   ("/xec/xbd/xaa", "HANGUL SYLLABLE KOJ");
+-   ("/xec/xbd/xab", "HANGUL SYLLABLE KOC");
+-   ("/xec/xbd/xac", "HANGUL SYLLABLE KOK");
+-   ("/xec/xbd/xad", "HANGUL SYLLABLE KOT");
+-   ("/xec/xbd/xae", "HANGUL SYLLABLE KOP");
+-   ("/xec/xbd/xaf", "HANGUL SYLLABLE KOH");
+-   ("/xec/xbd/xb0", "HANGUL SYLLABLE KWA");
+-   ("/xec/xbd/xb1", "HANGUL SYLLABLE KWAG");
+-   ("/xec/xbd/xb2", "HANGUL SYLLABLE KWAGG");
+-   ("/xec/xbd/xb3", "HANGUL SYLLABLE KWAGS");
+-   ("/xec/xbd/xb4", "HANGUL SYLLABLE KWAN");
+-   ("/xec/xbd/xb5", "HANGUL SYLLABLE KWANI");
+-   ("/xec/xbd/xb6", "HANGUL SYLLABLE KWANH");
+-   ("/xec/xbd/xb7", "HANGUL SYLLABLE KWAD");
+-   ("/xec/xbd/xb8", "HANGUL SYLLABLE KWAL");
+-   ("/xec/xbd/xb9", "HANGUL SYLLABLE KWALG");
+-   ("/xec/xbd/xba", "HANGUL SYLLABLE KWALM");
+-   ("/xec/xbd/xbb", "HANGUL SYLLABLE KWALB");
+-   ("/xec/xbd/xbc", "HANGUL SYLLABLE KWALS");
+-   ("/xec/xbd/xbd", "HANGUL SYLLABLE KWALT");
+-   ("/xec/xbd/xbe", "HANGUL SYLLABLE KWALP");
+-   ("/xec/xbd/xbf", "HANGUL SYLLABLE KWALH");
+-   ("/xec/xbe/x80", "HANGUL SYLLABLE KWAM");
+-   ("/xec/xbe/x81", "HANGUL SYLLABLE KWAB");
+-   ("/xec/xbe/x82", "HANGUL SYLLABLE KWABS");
+-   ("/xec/xbe/x83", "HANGUL SYLLABLE KWAS");
+-   ("/xec/xbe/x84", "HANGUL SYLLABLE KWASS");
+-   ("/xec/xbe/x85", "HANGUL SYLLABLE KWANG");
+-   ("/xec/xbe/x86", "HANGUL SYLLABLE KWAJ");
+-   ("/xec/xbe/x87", "HANGUL SYLLABLE KWAC");
+-   ("/xec/xbe/x88", "HANGUL SYLLABLE KWAK");
+-   ("/xec/xbe/x89", "HANGUL SYLLABLE KWAT");
+-   ("/xec/xbe/x8a", "HANGUL SYLLABLE KWAP");
+-   ("/xec/xbe/x8b", "HANGUL SYLLABLE KWAH");
+-   ("/xec/xbe/x8c", "HANGUL SYLLABLE KWAE");
+-   ("/xec/xbe/x8d", "HANGUL SYLLABLE KWAEG");
+-   ("/xec/xbe/x8e", "HANGUL SYLLABLE KWAEGG");
+-   ("/xec/xbe/x8f", "HANGUL SYLLABLE KWAEGS");
+-   ("/xec/xbe/x90", "HANGUL SYLLABLE KWAEN");
+-   ("/xec/xbe/x91", "HANGUL SYLLABLE KWAENI");
+-   ("/xec/xbe/x92", "HANGUL SYLLABLE KWAENH");
+-   ("/xec/xbe/x93", "HANGUL SYLLABLE KWAED");
+-   ("/xec/xbe/x94", "HANGUL SYLLABLE KWAEL");
+-   ("/xec/xbe/x95", "HANGUL SYLLABLE KWAELG");
+-   ("/xec/xbe/x96", "HANGUL SYLLABLE KWAELM");
+-   ("/xec/xbe/x97", "HANGUL SYLLABLE KWAELB");
+-   ("/xec/xbe/x98", "HANGUL SYLLABLE KWAELS");
+-   ("/xec/xbe/x99", "HANGUL SYLLABLE KWAELT");
+-   ("/xec/xbe/x9a", "HANGUL SYLLABLE KWAELP");
+-   ("/xec/xbe/x9b", "HANGUL SYLLABLE KWAELH");
+-   ("/xec/xbe/x9c", "HANGUL SYLLABLE KWAEM");
+-   ("/xec/xbe/x9d", "HANGUL SYLLABLE KWAEB");
+-   ("/xec/xbe/x9e", "HANGUL SYLLABLE KWAEBS");
+-   ("/xec/xbe/x9f", "HANGUL SYLLABLE KWAES");
+-   ("/xec/xbe/xa0", "HANGUL SYLLABLE KWAESS");
+-   ("/xec/xbe/xa1", "HANGUL SYLLABLE KWAENG");
+-   ("/xec/xbe/xa2", "HANGUL SYLLABLE KWAEJ");
+-   ("/xec/xbe/xa3", "HANGUL SYLLABLE KWAEC");
+-   ("/xec/xbe/xa4", "HANGUL SYLLABLE KWAEK");
+-   ("/xec/xbe/xa5", "HANGUL SYLLABLE KWAET");
+-   ("/xec/xbe/xa6", "HANGUL SYLLABLE KWAEP");
+-   ("/xec/xbe/xa7", "HANGUL SYLLABLE KWAEH");
+-   ("/xec/xbe/xa8", "HANGUL SYLLABLE KOE");
+-   ("/xec/xbe/xa9", "HANGUL SYLLABLE KOEG");
+-   ("/xec/xbe/xaa", "HANGUL SYLLABLE KOEGG");
+-   ("/xec/xbe/xab", "HANGUL SYLLABLE KOEGS");
+-   ("/xec/xbe/xac", "HANGUL SYLLABLE KOEN");
+-   ("/xec/xbe/xad", "HANGUL SYLLABLE KOENI");
+-   ("/xec/xbe/xae", "HANGUL SYLLABLE KOENH");
+-   ("/xec/xbe/xaf", "HANGUL SYLLABLE KOED");
+-   ("/xec/xbe/xb0", "HANGUL SYLLABLE KOEL");
+-   ("/xec/xbe/xb1", "HANGUL SYLLABLE KOELG");
+-   ("/xec/xbe/xb2", "HANGUL SYLLABLE KOELM");
+-   ("/xec/xbe/xb3", "HANGUL SYLLABLE KOELB");
+-   ("/xec/xbe/xb4", "HANGUL SYLLABLE KOELS");
+-   ("/xec/xbe/xb5", "HANGUL SYLLABLE KOELT");
+-   ("/xec/xbe/xb6", "HANGUL SYLLABLE KOELP");
+-   ("/xec/xbe/xb7", "HANGUL SYLLABLE KOELH");
+-   ("/xec/xbe/xb8", "HANGUL SYLLABLE KOEM");
+-   ("/xec/xbe/xb9", "HANGUL SYLLABLE KOEB");
+-   ("/xec/xbe/xba", "HANGUL SYLLABLE KOEBS");
+-   ("/xec/xbe/xbb", "HANGUL SYLLABLE KOES");
+-   ("/xec/xbe/xbc", "HANGUL SYLLABLE KOESS");
+-   ("/xec/xbe/xbd", "HANGUL SYLLABLE KOENG");
+-   ("/xec/xbe/xbe", "HANGUL SYLLABLE KOEJ");
+-   ("/xec/xbe/xbf", "HANGUL SYLLABLE KOEC");
+-   ("/xec/xbf/x80", "HANGUL SYLLABLE KOEK");
+-   ("/xec/xbf/x81", "HANGUL SYLLABLE KOET");
+-   ("/xec/xbf/x82", "HANGUL SYLLABLE KOEP");
+-   ("/xec/xbf/x83", "HANGUL SYLLABLE KOEH");
+-   ("/xec/xbf/x84", "HANGUL SYLLABLE KYO");
+-   ("/xec/xbf/x85", "HANGUL SYLLABLE KYOG");
+-   ("/xec/xbf/x86", "HANGUL SYLLABLE KYOGG");
+-   ("/xec/xbf/x87", "HANGUL SYLLABLE KYOGS");
+-   ("/xec/xbf/x88", "HANGUL SYLLABLE KYON");
+-   ("/xec/xbf/x89", "HANGUL SYLLABLE KYONI");
+-   ("/xec/xbf/x8a", "HANGUL SYLLABLE KYONH");
+-   ("/xec/xbf/x8b", "HANGUL SYLLABLE KYOD");
+-   ("/xec/xbf/x8c", "HANGUL SYLLABLE KYOL");
+-   ("/xec/xbf/x8d", "HANGUL SYLLABLE KYOLG");
+-   ("/xec/xbf/x8e", "HANGUL SYLLABLE KYOLM");
+-   ("/xec/xbf/x8f", "HANGUL SYLLABLE KYOLB");
+-   ("/xec/xbf/x90", "HANGUL SYLLABLE KYOLS");
+-   ("/xec/xbf/x91", "HANGUL SYLLABLE KYOLT");
+-   ("/xec/xbf/x92", "HANGUL SYLLABLE KYOLP");
+-   ("/xec/xbf/x93", "HANGUL SYLLABLE KYOLH");
+-   ("/xec/xbf/x94", "HANGUL SYLLABLE KYOM");
+-   ("/xec/xbf/x95", "HANGUL SYLLABLE KYOB");
+-   ("/xec/xbf/x96", "HANGUL SYLLABLE KYOBS");
+-   ("/xec/xbf/x97", "HANGUL SYLLABLE KYOS");
+-   ("/xec/xbf/x98", "HANGUL SYLLABLE KYOSS");
+-   ("/xec/xbf/x99", "HANGUL SYLLABLE KYONG");
+-   ("/xec/xbf/x9a", "HANGUL SYLLABLE KYOJ");
+-   ("/xec/xbf/x9b", "HANGUL SYLLABLE KYOC");
+-   ("/xec/xbf/x9c", "HANGUL SYLLABLE KYOK");
+-   ("/xec/xbf/x9d", "HANGUL SYLLABLE KYOT");
+-   ("/xec/xbf/x9e", "HANGUL SYLLABLE KYOP");
+-   ("/xec/xbf/x9f", "HANGUL SYLLABLE KYOH");
+-   ("/xec/xbf/xa0", "HANGUL SYLLABLE KU");
+-   ("/xec/xbf/xa1", "HANGUL SYLLABLE KUG");
+-   ("/xec/xbf/xa2", "HANGUL SYLLABLE KUGG");
+-   ("/xec/xbf/xa3", "HANGUL SYLLABLE KUGS");
+-   ("/xec/xbf/xa4", "HANGUL SYLLABLE KUN");
+-   ("/xec/xbf/xa5", "HANGUL SYLLABLE KUNI");
+-   ("/xec/xbf/xa6", "HANGUL SYLLABLE KUNH");
+-   ("/xec/xbf/xa7", "HANGUL SYLLABLE KUD");
+-   ("/xec/xbf/xa8", "HANGUL SYLLABLE KUL");
+-   ("/xec/xbf/xa9", "HANGUL SYLLABLE KULG");
+-   ("/xec/xbf/xaa", "HANGUL SYLLABLE KULM");
+-   ("/xec/xbf/xab", "HANGUL SYLLABLE KULB");
+-   ("/xec/xbf/xac", "HANGUL SYLLABLE KULS");
+-   ("/xec/xbf/xad", "HANGUL SYLLABLE KULT");
+-   ("/xec/xbf/xae", "HANGUL SYLLABLE KULP");
+-   ("/xec/xbf/xaf", "HANGUL SYLLABLE KULH");
+-   ("/xec/xbf/xb0", "HANGUL SYLLABLE KUM");
+-   ("/xec/xbf/xb1", "HANGUL SYLLABLE KUB");
+-   ("/xec/xbf/xb2", "HANGUL SYLLABLE KUBS");
+-   ("/xec/xbf/xb3", "HANGUL SYLLABLE KUS");
+-   ("/xec/xbf/xb4", "HANGUL SYLLABLE KUSS");
+-   ("/xec/xbf/xb5", "HANGUL SYLLABLE KUNG");
+-   ("/xec/xbf/xb6", "HANGUL SYLLABLE KUJ");
+-   ("/xec/xbf/xb7", "HANGUL SYLLABLE KUC");
+-   ("/xec/xbf/xb8", "HANGUL SYLLABLE KUK");
+-   ("/xec/xbf/xb9", "HANGUL SYLLABLE KUT");
+-   ("/xec/xbf/xba", "HANGUL SYLLABLE KUP");
+-   ("/xec/xbf/xbb", "HANGUL SYLLABLE KUH");
+-   ("/xec/xbf/xbc", "HANGUL SYLLABLE KWEO");
+-   ("/xec/xbf/xbd", "HANGUL SYLLABLE KWEOG");
+-   ("/xec/xbf/xbe", "HANGUL SYLLABLE KWEOGG");
+-   ("/xec/xbf/xbf", "HANGUL SYLLABLE KWEOGS");
+-   ("/xed/x80/x80", "HANGUL SYLLABLE KWEON");
+-   ("/xed/x80/x81", "HANGUL SYLLABLE KWEONI");
+-   ("/xed/x80/x82", "HANGUL SYLLABLE KWEONH");
+-   ("/xed/x80/x83", "HANGUL SYLLABLE KWEOD");
+-   ("/xed/x80/x84", "HANGUL SYLLABLE KWEOL");
+-   ("/xed/x80/x85", "HANGUL SYLLABLE KWEOLG");
+-   ("/xed/x80/x86", "HANGUL SYLLABLE KWEOLM");
+-   ("/xed/x80/x87", "HANGUL SYLLABLE KWEOLB");
+-   ("/xed/x80/x88", "HANGUL SYLLABLE KWEOLS");
+-   ("/xed/x80/x89", "HANGUL SYLLABLE KWEOLT");
+-   ("/xed/x80/x8a", "HANGUL SYLLABLE KWEOLP");
+-   ("/xed/x80/x8b", "HANGUL SYLLABLE KWEOLH");
+-   ("/xed/x80/x8c", "HANGUL SYLLABLE KWEOM");
+-   ("/xed/x80/x8d", "HANGUL SYLLABLE KWEOB");
+-   ("/xed/x80/x8e", "HANGUL SYLLABLE KWEOBS");
+-   ("/xed/x80/x8f", "HANGUL SYLLABLE KWEOS");
+-   ("/xed/x80/x90", "HANGUL SYLLABLE KWEOSS");
+-   ("/xed/x80/x91", "HANGUL SYLLABLE KWEONG");
+-   ("/xed/x80/x92", "HANGUL SYLLABLE KWEOJ");
+-   ("/xed/x80/x93", "HANGUL SYLLABLE KWEOC");
+-   ("/xed/x80/x94", "HANGUL SYLLABLE KWEOK");
+-   ("/xed/x80/x95", "HANGUL SYLLABLE KWEOT");
+-   ("/xed/x80/x96", "HANGUL SYLLABLE KWEOP");
+-   ("/xed/x80/x97", "HANGUL SYLLABLE KWEOH");
+-   ("/xed/x80/x98", "HANGUL SYLLABLE KWE");
+-   ("/xed/x80/x99", "HANGUL SYLLABLE KWEG");
+-   ("/xed/x80/x9a", "HANGUL SYLLABLE KWEGG");
+-   ("/xed/x80/x9b", "HANGUL SYLLABLE KWEGS");
+-   ("/xed/x80/x9c", "HANGUL SYLLABLE KWEN");
+-   ("/xed/x80/x9d", "HANGUL SYLLABLE KWENI");
+-   ("/xed/x80/x9e", "HANGUL SYLLABLE KWENH");
+-   ("/xed/x80/x9f", "HANGUL SYLLABLE KWED");
+-   ("/xed/x80/xa0", "HANGUL SYLLABLE KWEL");
+-   ("/xed/x80/xa1", "HANGUL SYLLABLE KWELG");
+-   ("/xed/x80/xa2", "HANGUL SYLLABLE KWELM");
+-   ("/xed/x80/xa3", "HANGUL SYLLABLE KWELB");
+-   ("/xed/x80/xa4", "HANGUL SYLLABLE KWELS");
+-   ("/xed/x80/xa5", "HANGUL SYLLABLE KWELT");
+-   ("/xed/x80/xa6", "HANGUL SYLLABLE KWELP");
+-   ("/xed/x80/xa7", "HANGUL SYLLABLE KWELH");
+-   ("/xed/x80/xa8", "HANGUL SYLLABLE KWEM");
+-   ("/xed/x80/xa9", "HANGUL SYLLABLE KWEB");
+-   ("/xed/x80/xaa", "HANGUL SYLLABLE KWEBS");
+-   ("/xed/x80/xab", "HANGUL SYLLABLE KWES");
+-   ("/xed/x80/xac", "HANGUL SYLLABLE KWESS");
+-   ("/xed/x80/xad", "HANGUL SYLLABLE KWENG");
+-   ("/xed/x80/xae", "HANGUL SYLLABLE KWEJ");
+-   ("/xed/x80/xaf", "HANGUL SYLLABLE KWEC");
+-   ("/xed/x80/xb0", "HANGUL SYLLABLE KWEK");
+-   ("/xed/x80/xb1", "HANGUL SYLLABLE KWET");
+-   ("/xed/x80/xb2", "HANGUL SYLLABLE KWEP");
+-   ("/xed/x80/xb3", "HANGUL SYLLABLE KWEH");
+-   ("/xed/x80/xb4", "HANGUL SYLLABLE KWI");
+-   ("/xed/x80/xb5", "HANGUL SYLLABLE KWIG");
+-   ("/xed/x80/xb6", "HANGUL SYLLABLE KWIGG");
+-   ("/xed/x80/xb7", "HANGUL SYLLABLE KWIGS");
+-   ("/xed/x80/xb8", "HANGUL SYLLABLE KWIN");
+-   ("/xed/x80/xb9", "HANGUL SYLLABLE KWINI");
+-   ("/xed/x80/xba", "HANGUL SYLLABLE KWINH");
+-   ("/xed/x80/xbb", "HANGUL SYLLABLE KWID");
+-   ("/xed/x80/xbc", "HANGUL SYLLABLE KWIL");
+-   ("/xed/x80/xbd", "HANGUL SYLLABLE KWILG");
+-   ("/xed/x80/xbe", "HANGUL SYLLABLE KWILM");
+-   ("/xed/x80/xbf", "HANGUL SYLLABLE KWILB");
+-   ("/xed/x81/x80", "HANGUL SYLLABLE KWILS");
+-   ("/xed/x81/x81", "HANGUL SYLLABLE KWILT");
+-   ("/xed/x81/x82", "HANGUL SYLLABLE KWILP");
+-   ("/xed/x81/x83", "HANGUL SYLLABLE KWILH");
+-   ("/xed/x81/x84", "HANGUL SYLLABLE KWIM");
+-   ("/xed/x81/x85", "HANGUL SYLLABLE KWIB");
+-   ("/xed/x81/x86", "HANGUL SYLLABLE KWIBS");
+-   ("/xed/x81/x87", "HANGUL SYLLABLE KWIS");
+-   ("/xed/x81/x88", "HANGUL SYLLABLE KWISS");
+-   ("/xed/x81/x89", "HANGUL SYLLABLE KWING");
+-   ("/xed/x81/x8a", "HANGUL SYLLABLE KWIJ");
+-   ("/xed/x81/x8b", "HANGUL SYLLABLE KWIC");
+-   ("/xed/x81/x8c", "HANGUL SYLLABLE KWIK");
+-   ("/xed/x81/x8d", "HANGUL SYLLABLE KWIT");
+-   ("/xed/x81/x8e", "HANGUL SYLLABLE KWIP");
+-   ("/xed/x81/x8f", "HANGUL SYLLABLE KWIH");
+-   ("/xed/x81/x90", "HANGUL SYLLABLE KYU");
+-   ("/xed/x81/x91", "HANGUL SYLLABLE KYUG");
+-   ("/xed/x81/x92", "HANGUL SYLLABLE KYUGG");
+-   ("/xed/x81/x93", "HANGUL SYLLABLE KYUGS");
+-   ("/xed/x81/x94", "HANGUL SYLLABLE KYUN");
+-   ("/xed/x81/x95", "HANGUL SYLLABLE KYUNI");
+-   ("/xed/x81/x96", "HANGUL SYLLABLE KYUNH");
+-   ("/xed/x81/x97", "HANGUL SYLLABLE KYUD");
+-   ("/xed/x81/x98", "HANGUL SYLLABLE KYUL");
+-   ("/xed/x81/x99", "HANGUL SYLLABLE KYULG");
+-   ("/xed/x81/x9a", "HANGUL SYLLABLE KYULM");
+-   ("/xed/x81/x9b", "HANGUL SYLLABLE KYULB");
+-   ("/xed/x81/x9c", "HANGUL SYLLABLE KYULS");
+-   ("/xed/x81/x9d", "HANGUL SYLLABLE KYULT");
+-   ("/xed/x81/x9e", "HANGUL SYLLABLE KYULP");
+-   ("/xed/x81/x9f", "HANGUL SYLLABLE KYULH");
+-   ("/xed/x81/xa0", "HANGUL SYLLABLE KYUM");
+-   ("/xed/x81/xa1", "HANGUL SYLLABLE KYUB");
+-   ("/xed/x81/xa2", "HANGUL SYLLABLE KYUBS");
+-   ("/xed/x81/xa3", "HANGUL SYLLABLE KYUS");
+-   ("/xed/x81/xa4", "HANGUL SYLLABLE KYUSS");
+-   ("/xed/x81/xa5", "HANGUL SYLLABLE KYUNG");
+-   ("/xed/x81/xa6", "HANGUL SYLLABLE KYUJ");
+-   ("/xed/x81/xa7", "HANGUL SYLLABLE KYUC");
+-   ("/xed/x81/xa8", "HANGUL SYLLABLE KYUK");
+-   ("/xed/x81/xa9", "HANGUL SYLLABLE KYUT");
+-   ("/xed/x81/xaa", "HANGUL SYLLABLE KYUP");
+-   ("/xed/x81/xab", "HANGUL SYLLABLE KYUH");
+-   ("/xed/x81/xac", "HANGUL SYLLABLE KEU");
+-   ("/xed/x81/xad", "HANGUL SYLLABLE KEUG");
+-   ("/xed/x81/xae", "HANGUL SYLLABLE KEUGG");
+-   ("/xed/x81/xaf", "HANGUL SYLLABLE KEUGS");
+-   ("/xed/x81/xb0", "HANGUL SYLLABLE KEUN");
+-   ("/xed/x81/xb1", "HANGUL SYLLABLE KEUNI");
+-   ("/xed/x81/xb2", "HANGUL SYLLABLE KEUNH");
+-   ("/xed/x81/xb3", "HANGUL SYLLABLE KEUD");
+-   ("/xed/x81/xb4", "HANGUL SYLLABLE KEUL");
+-   ("/xed/x81/xb5", "HANGUL SYLLABLE KEULG");
+-   ("/xed/x81/xb6", "HANGUL SYLLABLE KEULM");
+-   ("/xed/x81/xb7", "HANGUL SYLLABLE KEULB");
+-   ("/xed/x81/xb8", "HANGUL SYLLABLE KEULS");
+-   ("/xed/x81/xb9", "HANGUL SYLLABLE KEULT");
+-   ("/xed/x81/xba", "HANGUL SYLLABLE KEULP");
+-   ("/xed/x81/xbb", "HANGUL SYLLABLE KEULH");
+-   ("/xed/x81/xbc", "HANGUL SYLLABLE KEUM");
+-   ("/xed/x81/xbd", "HANGUL SYLLABLE KEUB");
+-   ("/xed/x81/xbe", "HANGUL SYLLABLE KEUBS");
+-   ("/xed/x81/xbf", "HANGUL SYLLABLE KEUS");
+-   ("/xed/x82/x80", "HANGUL SYLLABLE KEUSS");
+-   ("/xed/x82/x81", "HANGUL SYLLABLE KEUNG");
+-   ("/xed/x82/x82", "HANGUL SYLLABLE KEUJ");
+-   ("/xed/x82/x83", "HANGUL SYLLABLE KEUC");
+-   ("/xed/x82/x84", "HANGUL SYLLABLE KEUK");
+-   ("/xed/x82/x85", "HANGUL SYLLABLE KEUT");
+-   ("/xed/x82/x86", "HANGUL SYLLABLE KEUP");
+-   ("/xed/x82/x87", "HANGUL SYLLABLE KEUH");
+-   ("/xed/x82/x88", "HANGUL SYLLABLE KYI");
+-   ("/xed/x82/x89", "HANGUL SYLLABLE KYIG");
+-   ("/xed/x82/x8a", "HANGUL SYLLABLE KYIGG");
+-   ("/xed/x82/x8b", "HANGUL SYLLABLE KYIGS");
+-   ("/xed/x82/x8c", "HANGUL SYLLABLE KYIN");
+-   ("/xed/x82/x8d", "HANGUL SYLLABLE KYINI");
+-   ("/xed/x82/x8e", "HANGUL SYLLABLE KYINH");
+-   ("/xed/x82/x8f", "HANGUL SYLLABLE KYID");
+-   ("/xed/x82/x90", "HANGUL SYLLABLE KYIL");
+-   ("/xed/x82/x91", "HANGUL SYLLABLE KYILG");
+-   ("/xed/x82/x92", "HANGUL SYLLABLE KYILM");
+-   ("/xed/x82/x93", "HANGUL SYLLABLE KYILB");
+-   ("/xed/x82/x94", "HANGUL SYLLABLE KYILS");
+-   ("/xed/x82/x95", "HANGUL SYLLABLE KYILT");
+-   ("/xed/x82/x96", "HANGUL SYLLABLE KYILP");
+-   ("/xed/x82/x97", "HANGUL SYLLABLE KYILH");
+-   ("/xed/x82/x98", "HANGUL SYLLABLE KYIM");
+-   ("/xed/x82/x99", "HANGUL SYLLABLE KYIB");
+-   ("/xed/x82/x9a", "HANGUL SYLLABLE KYIBS");
+-   ("/xed/x82/x9b", "HANGUL SYLLABLE KYIS");
+-   ("/xed/x82/x9c", "HANGUL SYLLABLE KYISS");
+-   ("/xed/x82/x9d", "HANGUL SYLLABLE KYING");
+-   ("/xed/x82/x9e", "HANGUL SYLLABLE KYIJ");
+-   ("/xed/x82/x9f", "HANGUL SYLLABLE KYIC");
+-   ("/xed/x82/xa0", "HANGUL SYLLABLE KYIK");
+-   ("/xed/x82/xa1", "HANGUL SYLLABLE KYIT");
+-   ("/xed/x82/xa2", "HANGUL SYLLABLE KYIP");
+-   ("/xed/x82/xa3", "HANGUL SYLLABLE KYIH");
+-   ("/xed/x82/xa4", "HANGUL SYLLABLE KI");
+-   ("/xed/x82/xa5", "HANGUL SYLLABLE KIG");
+-   ("/xed/x82/xa6", "HANGUL SYLLABLE KIGG");
+-   ("/xed/x82/xa7", "HANGUL SYLLABLE KIGS");
+-   ("/xed/x82/xa8", "HANGUL SYLLABLE KIN");
+-   ("/xed/x82/xa9", "HANGUL SYLLABLE KINI");
+-   ("/xed/x82/xaa", "HANGUL SYLLABLE KINH");
+-   ("/xed/x82/xab", "HANGUL SYLLABLE KID");
+-   ("/xed/x82/xac", "HANGUL SYLLABLE KIL");
+-   ("/xed/x82/xad", "HANGUL SYLLABLE KILG");
+-   ("/xed/x82/xae", "HANGUL SYLLABLE KILM");
+-   ("/xed/x82/xaf", "HANGUL SYLLABLE KILB");
+-   ("/xed/x82/xb0", "HANGUL SYLLABLE KILS");
+-   ("/xed/x82/xb1", "HANGUL SYLLABLE KILT");
+-   ("/xed/x82/xb2", "HANGUL SYLLABLE KILP");
+-   ("/xed/x82/xb3", "HANGUL SYLLABLE KILH");
+-   ("/xed/x82/xb4", "HANGUL SYLLABLE KIM");
+-   ("/xed/x82/xb5", "HANGUL SYLLABLE KIB");
+-   ("/xed/x82/xb6", "HANGUL SYLLABLE KIBS");
+-   ("/xed/x82/xb7", "HANGUL SYLLABLE KIS");
+-   ("/xed/x82/xb8", "HANGUL SYLLABLE KISS");
+-   ("/xed/x82/xb9", "HANGUL SYLLABLE KING");
+-   ("/xed/x82/xba", "HANGUL SYLLABLE KIJ");
+-   ("/xed/x82/xbb", "HANGUL SYLLABLE KIC");
+-   ("/xed/x82/xbc", "HANGUL SYLLABLE KIK");
+-   ("/xed/x82/xbd", "HANGUL SYLLABLE KIT");
+-   ("/xed/x82/xbe", "HANGUL SYLLABLE KIP");
+-   ("/xed/x82/xbf", "HANGUL SYLLABLE KIH");
+-   ("/xed/x83/x80", "HANGUL SYLLABLE TA");
+-   ("/xed/x83/x81", "HANGUL SYLLABLE TAG");
+-   ("/xed/x83/x82", "HANGUL SYLLABLE TAGG");
+-   ("/xed/x83/x83", "HANGUL SYLLABLE TAGS");
+-   ("/xed/x83/x84", "HANGUL SYLLABLE TAN");
+-   ("/xed/x83/x85", "HANGUL SYLLABLE TANI");
+-   ("/xed/x83/x86", "HANGUL SYLLABLE TANH");
+-   ("/xed/x83/x87", "HANGUL SYLLABLE TAD");
+-   ("/xed/x83/x88", "HANGUL SYLLABLE TAL");
+-   ("/xed/x83/x89", "HANGUL SYLLABLE TALG");
+-   ("/xed/x83/x8a", "HANGUL SYLLABLE TALM");
+-   ("/xed/x83/x8b", "HANGUL SYLLABLE TALB");
+-   ("/xed/x83/x8c", "HANGUL SYLLABLE TALS");
+-   ("/xed/x83/x8d", "HANGUL SYLLABLE TALT");
+-   ("/xed/x83/x8e", "HANGUL SYLLABLE TALP");
+-   ("/xed/x83/x8f", "HANGUL SYLLABLE TALH");
+-   ("/xed/x83/x90", "HANGUL SYLLABLE TAM");
+-   ("/xed/x83/x91", "HANGUL SYLLABLE TAB");
+-   ("/xed/x83/x92", "HANGUL SYLLABLE TABS");
+-   ("/xed/x83/x93", "HANGUL SYLLABLE TAS");
+-   ("/xed/x83/x94", "HANGUL SYLLABLE TASS");
+-   ("/xed/x83/x95", "HANGUL SYLLABLE TANG");
+-   ("/xed/x83/x96", "HANGUL SYLLABLE TAJ");
+-   ("/xed/x83/x97", "HANGUL SYLLABLE TAC");
+-   ("/xed/x83/x98", "HANGUL SYLLABLE TAK");
+-   ("/xed/x83/x99", "HANGUL SYLLABLE TAT");
+-   ("/xed/x83/x9a", "HANGUL SYLLABLE TAP");
+-   ("/xed/x83/x9b", "HANGUL SYLLABLE TAH");
+-   ("/xed/x83/x9c", "HANGUL SYLLABLE TAE");
+-   ("/xed/x83/x9d", "HANGUL SYLLABLE TAEG");
+-   ("/xed/x83/x9e", "HANGUL SYLLABLE TAEGG");
+-   ("/xed/x83/x9f", "HANGUL SYLLABLE TAEGS");
+-   ("/xed/x83/xa0", "HANGUL SYLLABLE TAEN");
+-   ("/xed/x83/xa1", "HANGUL SYLLABLE TAENI");
+-   ("/xed/x83/xa2", "HANGUL SYLLABLE TAENH");
+-   ("/xed/x83/xa3", "HANGUL SYLLABLE TAED");
+-   ("/xed/x83/xa4", "HANGUL SYLLABLE TAEL");
+-   ("/xed/x83/xa5", "HANGUL SYLLABLE TAELG");
+-   ("/xed/x83/xa6", "HANGUL SYLLABLE TAELM");
+-   ("/xed/x83/xa7", "HANGUL SYLLABLE TAELB");
+-   ("/xed/x83/xa8", "HANGUL SYLLABLE TAELS");
+-   ("/xed/x83/xa9", "HANGUL SYLLABLE TAELT");
+-   ("/xed/x83/xaa", "HANGUL SYLLABLE TAELP");
+-   ("/xed/x83/xab", "HANGUL SYLLABLE TAELH");
+-   ("/xed/x83/xac", "HANGUL SYLLABLE TAEM");
+-   ("/xed/x83/xad", "HANGUL SYLLABLE TAEB");
+-   ("/xed/x83/xae", "HANGUL SYLLABLE TAEBS");
+-   ("/xed/x83/xaf", "HANGUL SYLLABLE TAES");
+-   ("/xed/x83/xb0", "HANGUL SYLLABLE TAESS");
+-   ("/xed/x83/xb1", "HANGUL SYLLABLE TAENG");
+-   ("/xed/x83/xb2", "HANGUL SYLLABLE TAEJ");
+-   ("/xed/x83/xb3", "HANGUL SYLLABLE TAEC");
+-   ("/xed/x83/xb4", "HANGUL SYLLABLE TAEK");
+-   ("/xed/x83/xb5", "HANGUL SYLLABLE TAET");
+-   ("/xed/x83/xb6", "HANGUL SYLLABLE TAEP");
+-   ("/xed/x83/xb7", "HANGUL SYLLABLE TAEH");
+-   ("/xed/x83/xb8", "HANGUL SYLLABLE TYA");
+-   ("/xed/x83/xb9", "HANGUL SYLLABLE TYAG");
+-   ("/xed/x83/xba", "HANGUL SYLLABLE TYAGG");
+-   ("/xed/x83/xbb", "HANGUL SYLLABLE TYAGS");
+-   ("/xed/x83/xbc", "HANGUL SYLLABLE TYAN");
+-   ("/xed/x83/xbd", "HANGUL SYLLABLE TYANI");
+-   ("/xed/x83/xbe", "HANGUL SYLLABLE TYANH");
+-   ("/xed/x83/xbf", "HANGUL SYLLABLE TYAD");
+-   ("/xed/x84/x80", "HANGUL SYLLABLE TYAL");
+-   ("/xed/x84/x81", "HANGUL SYLLABLE TYALG");
+-   ("/xed/x84/x82", "HANGUL SYLLABLE TYALM");
+-   ("/xed/x84/x83", "HANGUL SYLLABLE TYALB");
+-   ("/xed/x84/x84", "HANGUL SYLLABLE TYALS");
+-   ("/xed/x84/x85", "HANGUL SYLLABLE TYALT");
+-   ("/xed/x84/x86", "HANGUL SYLLABLE TYALP");
+-   ("/xed/x84/x87", "HANGUL SYLLABLE TYALH");
+-   ("/xed/x84/x88", "HANGUL SYLLABLE TYAM");
+-   ("/xed/x84/x89", "HANGUL SYLLABLE TYAB");
+-   ("/xed/x84/x8a", "HANGUL SYLLABLE TYABS");
+-   ("/xed/x84/x8b", "HANGUL SYLLABLE TYAS");
+-   ("/xed/x84/x8c", "HANGUL SYLLABLE TYASS");
+-   ("/xed/x84/x8d", "HANGUL SYLLABLE TYANG");
+-   ("/xed/x84/x8e", "HANGUL SYLLABLE TYAJ");
+-   ("/xed/x84/x8f", "HANGUL SYLLABLE TYAC");
+-   ("/xed/x84/x90", "HANGUL SYLLABLE TYAK");
+-   ("/xed/x84/x91", "HANGUL SYLLABLE TYAT");
+-   ("/xed/x84/x92", "HANGUL SYLLABLE TYAP");
+-   ("/xed/x84/x93", "HANGUL SYLLABLE TYAH");
+-   ("/xed/x84/x94", "HANGUL SYLLABLE TYAE");
+-   ("/xed/x84/x95", "HANGUL SYLLABLE TYAEG");
+-   ("/xed/x84/x96", "HANGUL SYLLABLE TYAEGG");
+-   ("/xed/x84/x97", "HANGUL SYLLABLE TYAEGS");
+-   ("/xed/x84/x98", "HANGUL SYLLABLE TYAEN");
+-   ("/xed/x84/x99", "HANGUL SYLLABLE TYAENI");
+-   ("/xed/x84/x9a", "HANGUL SYLLABLE TYAENH");
+-   ("/xed/x84/x9b", "HANGUL SYLLABLE TYAED");
+-   ("/xed/x84/x9c", "HANGUL SYLLABLE TYAEL");
+-   ("/xed/x84/x9d", "HANGUL SYLLABLE TYAELG");
+-   ("/xed/x84/x9e", "HANGUL SYLLABLE TYAELM");
+-   ("/xed/x84/x9f", "HANGUL SYLLABLE TYAELB");
+-   ("/xed/x84/xa0", "HANGUL SYLLABLE TYAELS");
+-   ("/xed/x84/xa1", "HANGUL SYLLABLE TYAELT");
+-   ("/xed/x84/xa2", "HANGUL SYLLABLE TYAELP");
+-   ("/xed/x84/xa3", "HANGUL SYLLABLE TYAELH");
+-   ("/xed/x84/xa4", "HANGUL SYLLABLE TYAEM");
+-   ("/xed/x84/xa5", "HANGUL SYLLABLE TYAEB");
+-   ("/xed/x84/xa6", "HANGUL SYLLABLE TYAEBS");
+-   ("/xed/x84/xa7", "HANGUL SYLLABLE TYAES");
+-   ("/xed/x84/xa8", "HANGUL SYLLABLE TYAESS");
+-   ("/xed/x84/xa9", "HANGUL SYLLABLE TYAENG");
+-   ("/xed/x84/xaa", "HANGUL SYLLABLE TYAEJ");
+-   ("/xed/x84/xab", "HANGUL SYLLABLE TYAEC");
+-   ("/xed/x84/xac", "HANGUL SYLLABLE TYAEK");
+-   ("/xed/x84/xad", "HANGUL SYLLABLE TYAET");
+-   ("/xed/x84/xae", "HANGUL SYLLABLE TYAEP");
+-   ("/xed/x84/xaf", "HANGUL SYLLABLE TYAEH");
+-   ("/xed/x84/xb0", "HANGUL SYLLABLE TEO");
+-   ("/xed/x84/xb1", "HANGUL SYLLABLE TEOG");
+-   ("/xed/x84/xb2", "HANGUL SYLLABLE TEOGG");
+-   ("/xed/x84/xb3", "HANGUL SYLLABLE TEOGS");
+-   ("/xed/x84/xb4", "HANGUL SYLLABLE TEON");
+-   ("/xed/x84/xb5", "HANGUL SYLLABLE TEONI");
+-   ("/xed/x84/xb6", "HANGUL SYLLABLE TEONH");
+-   ("/xed/x84/xb7", "HANGUL SYLLABLE TEOD");
+-   ("/xed/x84/xb8", "HANGUL SYLLABLE TEOL");
+-   ("/xed/x84/xb9", "HANGUL SYLLABLE TEOLG");
+-   ("/xed/x84/xba", "HANGUL SYLLABLE TEOLM");
+-   ("/xed/x84/xbb", "HANGUL SYLLABLE TEOLB");
+-   ("/xed/x84/xbc", "HANGUL SYLLABLE TEOLS");
+-   ("/xed/x84/xbd", "HANGUL SYLLABLE TEOLT");
+-   ("/xed/x84/xbe", "HANGUL SYLLABLE TEOLP");
+-   ("/xed/x84/xbf", "HANGUL SYLLABLE TEOLH");
+-   ("/xed/x85/x80", "HANGUL SYLLABLE TEOM");
+-   ("/xed/x85/x81", "HANGUL SYLLABLE TEOB");
+-   ("/xed/x85/x82", "HANGUL SYLLABLE TEOBS");
+-   ("/xed/x85/x83", "HANGUL SYLLABLE TEOS");
+-   ("/xed/x85/x84", "HANGUL SYLLABLE TEOSS");
+-   ("/xed/x85/x85", "HANGUL SYLLABLE TEONG");
+-   ("/xed/x85/x86", "HANGUL SYLLABLE TEOJ");
+-   ("/xed/x85/x87", "HANGUL SYLLABLE TEOC");
+-   ("/xed/x85/x88", "HANGUL SYLLABLE TEOK");
+-   ("/xed/x85/x89", "HANGUL SYLLABLE TEOT");
+-   ("/xed/x85/x8a", "HANGUL SYLLABLE TEOP");
+-   ("/xed/x85/x8b", "HANGUL SYLLABLE TEOH");
+-   ("/xed/x85/x8c", "HANGUL SYLLABLE TE");
+-   ("/xed/x85/x8d", "HANGUL SYLLABLE TEG");
+-   ("/xed/x85/x8e", "HANGUL SYLLABLE TEGG");
+-   ("/xed/x85/x8f", "HANGUL SYLLABLE TEGS");
+-   ("/xed/x85/x90", "HANGUL SYLLABLE TEN");
+-   ("/xed/x85/x91", "HANGUL SYLLABLE TENI");
+-   ("/xed/x85/x92", "HANGUL SYLLABLE TENH");
+-   ("/xed/x85/x93", "HANGUL SYLLABLE TED");
+-   ("/xed/x85/x94", "HANGUL SYLLABLE TEL");
+-   ("/xed/x85/x95", "HANGUL SYLLABLE TELG");
+-   ("/xed/x85/x96", "HANGUL SYLLABLE TELM");
+-   ("/xed/x85/x97", "HANGUL SYLLABLE TELB");
+-   ("/xed/x85/x98", "HANGUL SYLLABLE TELS");
+-   ("/xed/x85/x99", "HANGUL SYLLABLE TELT");
+-   ("/xed/x85/x9a", "HANGUL SYLLABLE TELP");
+-   ("/xed/x85/x9b", "HANGUL SYLLABLE TELH");
+-   ("/xed/x85/x9c", "HANGUL SYLLABLE TEM");
+-   ("/xed/x85/x9d", "HANGUL SYLLABLE TEB");
+-   ("/xed/x85/x9e", "HANGUL SYLLABLE TEBS");
+-   ("/xed/x85/x9f", "HANGUL SYLLABLE TES");
+-   ("/xed/x85/xa0", "HANGUL SYLLABLE TESS");
+-   ("/xed/x85/xa1", "HANGUL SYLLABLE TENG");
+-   ("/xed/x85/xa2", "HANGUL SYLLABLE TEJ");
+-   ("/xed/x85/xa3", "HANGUL SYLLABLE TEC");
+-   ("/xed/x85/xa4", "HANGUL SYLLABLE TEK");
+-   ("/xed/x85/xa5", "HANGUL SYLLABLE TET");
+-   ("/xed/x85/xa6", "HANGUL SYLLABLE TEP");
+-   ("/xed/x85/xa7", "HANGUL SYLLABLE TEH");
+-   ("/xed/x85/xa8", "HANGUL SYLLABLE TYEO");
+-   ("/xed/x85/xa9", "HANGUL SYLLABLE TYEOG");
+-   ("/xed/x85/xaa", "HANGUL SYLLABLE TYEOGG");
+-   ("/xed/x85/xab", "HANGUL SYLLABLE TYEOGS");
+-   ("/xed/x85/xac", "HANGUL SYLLABLE TYEON");
+-   ("/xed/x85/xad", "HANGUL SYLLABLE TYEONI");
+-   ("/xed/x85/xae", "HANGUL SYLLABLE TYEONH");
+-   ("/xed/x85/xaf", "HANGUL SYLLABLE TYEOD");
+-   ("/xed/x85/xb0", "HANGUL SYLLABLE TYEOL");
+-   ("/xed/x85/xb1", "HANGUL SYLLABLE TYEOLG");
+-   ("/xed/x85/xb2", "HANGUL SYLLABLE TYEOLM");
+-   ("/xed/x85/xb3", "HANGUL SYLLABLE TYEOLB");
+-   ("/xed/x85/xb4", "HANGUL SYLLABLE TYEOLS");
+-   ("/xed/x85/xb5", "HANGUL SYLLABLE TYEOLT");
+-   ("/xed/x85/xb6", "HANGUL SYLLABLE TYEOLP");
+-   ("/xed/x85/xb7", "HANGUL SYLLABLE TYEOLH");
+-   ("/xed/x85/xb8", "HANGUL SYLLABLE TYEOM");
+-   ("/xed/x85/xb9", "HANGUL SYLLABLE TYEOB");
+-   ("/xed/x85/xba", "HANGUL SYLLABLE TYEOBS");
+-   ("/xed/x85/xbb", "HANGUL SYLLABLE TYEOS");
+-   ("/xed/x85/xbc", "HANGUL SYLLABLE TYEOSS");
+-   ("/xed/x85/xbd", "HANGUL SYLLABLE TYEONG");
+-   ("/xed/x85/xbe", "HANGUL SYLLABLE TYEOJ");
+-   ("/xed/x85/xbf", "HANGUL SYLLABLE TYEOC");
+-   ("/xed/x86/x80", "HANGUL SYLLABLE TYEOK");
+-   ("/xed/x86/x81", "HANGUL SYLLABLE TYEOT");
+-   ("/xed/x86/x82", "HANGUL SYLLABLE TYEOP");
+-   ("/xed/x86/x83", "HANGUL SYLLABLE TYEOH");
+-   ("/xed/x86/x84", "HANGUL SYLLABLE TYE");
+-   ("/xed/x86/x85", "HANGUL SYLLABLE TYEG");
+-   ("/xed/x86/x86", "HANGUL SYLLABLE TYEGG");
+-   ("/xed/x86/x87", "HANGUL SYLLABLE TYEGS");
+-   ("/xed/x86/x88", "HANGUL SYLLABLE TYEN");
+-   ("/xed/x86/x89", "HANGUL SYLLABLE TYENI");
+-   ("/xed/x86/x8a", "HANGUL SYLLABLE TYENH");
+-   ("/xed/x86/x8b", "HANGUL SYLLABLE TYED");
+-   ("/xed/x86/x8c", "HANGUL SYLLABLE TYEL");
+-   ("/xed/x86/x8d", "HANGUL SYLLABLE TYELG");
+-   ("/xed/x86/x8e", "HANGUL SYLLABLE TYELM");
+-   ("/xed/x86/x8f", "HANGUL SYLLABLE TYELB");
+-   ("/xed/x86/x90", "HANGUL SYLLABLE TYELS");
+-   ("/xed/x86/x91", "HANGUL SYLLABLE TYELT");
+-   ("/xed/x86/x92", "HANGUL SYLLABLE TYELP");
+-   ("/xed/x86/x93", "HANGUL SYLLABLE TYELH");
+-   ("/xed/x86/x94", "HANGUL SYLLABLE TYEM");
+-   ("/xed/x86/x95", "HANGUL SYLLABLE TYEB");
+-   ("/xed/x86/x96", "HANGUL SYLLABLE TYEBS");
+-   ("/xed/x86/x97", "HANGUL SYLLABLE TYES");
+-   ("/xed/x86/x98", "HANGUL SYLLABLE TYESS");
+-   ("/xed/x86/x99", "HANGUL SYLLABLE TYENG");
+-   ("/xed/x86/x9a", "HANGUL SYLLABLE TYEJ");
+-   ("/xed/x86/x9b", "HANGUL SYLLABLE TYEC");
+-   ("/xed/x86/x9c", "HANGUL SYLLABLE TYEK");
+-   ("/xed/x86/x9d", "HANGUL SYLLABLE TYET");
+-   ("/xed/x86/x9e", "HANGUL SYLLABLE TYEP");
+-   ("/xed/x86/x9f", "HANGUL SYLLABLE TYEH");
+-   ("/xed/x86/xa0", "HANGUL SYLLABLE TO");
+-   ("/xed/x86/xa1", "HANGUL SYLLABLE TOG");
+-   ("/xed/x86/xa2", "HANGUL SYLLABLE TOGG");
+-   ("/xed/x86/xa3", "HANGUL SYLLABLE TOGS");
+-   ("/xed/x86/xa4", "HANGUL SYLLABLE TON");
+-   ("/xed/x86/xa5", "HANGUL SYLLABLE TONI");
+-   ("/xed/x86/xa6", "HANGUL SYLLABLE TONH");
+-   ("/xed/x86/xa7", "HANGUL SYLLABLE TOD");
+-   ("/xed/x86/xa8", "HANGUL SYLLABLE TOL");
+-   ("/xed/x86/xa9", "HANGUL SYLLABLE TOLG");
+-   ("/xed/x86/xaa", "HANGUL SYLLABLE TOLM");
+-   ("/xed/x86/xab", "HANGUL SYLLABLE TOLB");
+-   ("/xed/x86/xac", "HANGUL SYLLABLE TOLS");
+-   ("/xed/x86/xad", "HANGUL SYLLABLE TOLT");
+-   ("/xed/x86/xae", "HANGUL SYLLABLE TOLP");
+-   ("/xed/x86/xaf", "HANGUL SYLLABLE TOLH");
+-   ("/xed/x86/xb0", "HANGUL SYLLABLE TOM");
+-   ("/xed/x86/xb1", "HANGUL SYLLABLE TOB");
+-   ("/xed/x86/xb2", "HANGUL SYLLABLE TOBS");
+-   ("/xed/x86/xb3", "HANGUL SYLLABLE TOS");
+-   ("/xed/x86/xb4", "HANGUL SYLLABLE TOSS");
+-   ("/xed/x86/xb5", "HANGUL SYLLABLE TONG");
+-   ("/xed/x86/xb6", "HANGUL SYLLABLE TOJ");
+-   ("/xed/x86/xb7", "HANGUL SYLLABLE TOC");
+-   ("/xed/x86/xb8", "HANGUL SYLLABLE TOK");
+-   ("/xed/x86/xb9", "HANGUL SYLLABLE TOT");
+-   ("/xed/x86/xba", "HANGUL SYLLABLE TOP");
+-   ("/xed/x86/xbb", "HANGUL SYLLABLE TOH");
+-   ("/xed/x86/xbc", "HANGUL SYLLABLE TWA");
+-   ("/xed/x86/xbd", "HANGUL SYLLABLE TWAG");
+-   ("/xed/x86/xbe", "HANGUL SYLLABLE TWAGG");
+-   ("/xed/x86/xbf", "HANGUL SYLLABLE TWAGS");
+-   ("/xed/x87/x80", "HANGUL SYLLABLE TWAN");
+-   ("/xed/x87/x81", "HANGUL SYLLABLE TWANI");
+-   ("/xed/x87/x82", "HANGUL SYLLABLE TWANH");
+-   ("/xed/x87/x83", "HANGUL SYLLABLE TWAD");
+-   ("/xed/x87/x84", "HANGUL SYLLABLE TWAL");
+-   ("/xed/x87/x85", "HANGUL SYLLABLE TWALG");
+-   ("/xed/x87/x86", "HANGUL SYLLABLE TWALM");
+-   ("/xed/x87/x87", "HANGUL SYLLABLE TWALB");
+-   ("/xed/x87/x88", "HANGUL SYLLABLE TWALS");
+-   ("/xed/x87/x89", "HANGUL SYLLABLE TWALT");
+-   ("/xed/x87/x8a", "HANGUL SYLLABLE TWALP");
+-   ("/xed/x87/x8b", "HANGUL SYLLABLE TWALH");
+-   ("/xed/x87/x8c", "HANGUL SYLLABLE TWAM");
+-   ("/xed/x87/x8d", "HANGUL SYLLABLE TWAB");
+-   ("/xed/x87/x8e", "HANGUL SYLLABLE TWABS");
+-   ("/xed/x87/x8f", "HANGUL SYLLABLE TWAS");
+-   ("/xed/x87/x90", "HANGUL SYLLABLE TWASS");
+-   ("/xed/x87/x91", "HANGUL SYLLABLE TWANG");
+-   ("/xed/x87/x92", "HANGUL SYLLABLE TWAJ");
+-   ("/xed/x87/x93", "HANGUL SYLLABLE TWAC");
+-   ("/xed/x87/x94", "HANGUL SYLLABLE TWAK");
+-   ("/xed/x87/x95", "HANGUL SYLLABLE TWAT");
+-   ("/xed/x87/x96", "HANGUL SYLLABLE TWAP");
+-   ("/xed/x87/x97", "HANGUL SYLLABLE TWAH");
+-   ("/xed/x87/x98", "HANGUL SYLLABLE TWAE");
+-   ("/xed/x87/x99", "HANGUL SYLLABLE TWAEG");
+-   ("/xed/x87/x9a", "HANGUL SYLLABLE TWAEGG");
+-   ("/xed/x87/x9b", "HANGUL SYLLABLE TWAEGS");
+-   ("/xed/x87/x9c", "HANGUL SYLLABLE TWAEN");
+-   ("/xed/x87/x9d", "HANGUL SYLLABLE TWAENI");
+-   ("/xed/x87/x9e", "HANGUL SYLLABLE TWAENH");
+-   ("/xed/x87/x9f", "HANGUL SYLLABLE TWAED");
+-   ("/xed/x87/xa0", "HANGUL SYLLABLE TWAEL");
+-   ("/xed/x87/xa1", "HANGUL SYLLABLE TWAELG");
+-   ("/xed/x87/xa2", "HANGUL SYLLABLE TWAELM");
+-   ("/xed/x87/xa3", "HANGUL SYLLABLE TWAELB");
+-   ("/xed/x87/xa4", "HANGUL SYLLABLE TWAELS");
+-   ("/xed/x87/xa5", "HANGUL SYLLABLE TWAELT");
+-   ("/xed/x87/xa6", "HANGUL SYLLABLE TWAELP");
+-   ("/xed/x87/xa7", "HANGUL SYLLABLE TWAELH");
+-   ("/xed/x87/xa8", "HANGUL SYLLABLE TWAEM");
+-   ("/xed/x87/xa9", "HANGUL SYLLABLE TWAEB");
+-   ("/xed/x87/xaa", "HANGUL SYLLABLE TWAEBS");
+-   ("/xed/x87/xab", "HANGUL SYLLABLE TWAES");
+-   ("/xed/x87/xac", "HANGUL SYLLABLE TWAESS");
+-   ("/xed/x87/xad", "HANGUL SYLLABLE TWAENG");
+-   ("/xed/x87/xae", "HANGUL SYLLABLE TWAEJ");
+-   ("/xed/x87/xaf", "HANGUL SYLLABLE TWAEC");
+-   ("/xed/x87/xb0", "HANGUL SYLLABLE TWAEK");
+-   ("/xed/x87/xb1", "HANGUL SYLLABLE TWAET");
+-   ("/xed/x87/xb2", "HANGUL SYLLABLE TWAEP");
+-   ("/xed/x87/xb3", "HANGUL SYLLABLE TWAEH");
+-   ("/xed/x87/xb4", "HANGUL SYLLABLE TOE");
+-   ("/xed/x87/xb5", "HANGUL SYLLABLE TOEG");
+-   ("/xed/x87/xb6", "HANGUL SYLLABLE TOEGG");
+-   ("/xed/x87/xb7", "HANGUL SYLLABLE TOEGS");
+-   ("/xed/x87/xb8", "HANGUL SYLLABLE TOEN");
+-   ("/xed/x87/xb9", "HANGUL SYLLABLE TOENI");
+-   ("/xed/x87/xba", "HANGUL SYLLABLE TOENH");
+-   ("/xed/x87/xbb", "HANGUL SYLLABLE TOED");
+-   ("/xed/x87/xbc", "HANGUL SYLLABLE TOEL");
+-   ("/xed/x87/xbd", "HANGUL SYLLABLE TOELG");
+-   ("/xed/x87/xbe", "HANGUL SYLLABLE TOELM");
+-   ("/xed/x87/xbf", "HANGUL SYLLABLE TOELB");
+-   ("/xed/x88/x80", "HANGUL SYLLABLE TOELS");
+-   ("/xed/x88/x81", "HANGUL SYLLABLE TOELT");
+-   ("/xed/x88/x82", "HANGUL SYLLABLE TOELP");
+-   ("/xed/x88/x83", "HANGUL SYLLABLE TOELH");
+-   ("/xed/x88/x84", "HANGUL SYLLABLE TOEM");
+-   ("/xed/x88/x85", "HANGUL SYLLABLE TOEB");
+-   ("/xed/x88/x86", "HANGUL SYLLABLE TOEBS");
+-   ("/xed/x88/x87", "HANGUL SYLLABLE TOES");
+-   ("/xed/x88/x88", "HANGUL SYLLABLE TOESS");
+-   ("/xed/x88/x89", "HANGUL SYLLABLE TOENG");
+-   ("/xed/x88/x8a", "HANGUL SYLLABLE TOEJ");
+-   ("/xed/x88/x8b", "HANGUL SYLLABLE TOEC");
+-   ("/xed/x88/x8c", "HANGUL SYLLABLE TOEK");
+-   ("/xed/x88/x8d", "HANGUL SYLLABLE TOET");
+-   ("/xed/x88/x8e", "HANGUL SYLLABLE TOEP");
+-   ("/xed/x88/x8f", "HANGUL SYLLABLE TOEH");
+-   ("/xed/x88/x90", "HANGUL SYLLABLE TYO");
+-   ("/xed/x88/x91", "HANGUL SYLLABLE TYOG");
+-   ("/xed/x88/x92", "HANGUL SYLLABLE TYOGG");
+-   ("/xed/x88/x93", "HANGUL SYLLABLE TYOGS");
+-   ("/xed/x88/x94", "HANGUL SYLLABLE TYON");
+-   ("/xed/x88/x95", "HANGUL SYLLABLE TYONI");
+-   ("/xed/x88/x96", "HANGUL SYLLABLE TYONH");
+-   ("/xed/x88/x97", "HANGUL SYLLABLE TYOD");
+-   ("/xed/x88/x98", "HANGUL SYLLABLE TYOL");
+-   ("/xed/x88/x99", "HANGUL SYLLABLE TYOLG");
+-   ("/xed/x88/x9a", "HANGUL SYLLABLE TYOLM");
+-   ("/xed/x88/x9b", "HANGUL SYLLABLE TYOLB");
+-   ("/xed/x88/x9c", "HANGUL SYLLABLE TYOLS");
+-   ("/xed/x88/x9d", "HANGUL SYLLABLE TYOLT");
+-   ("/xed/x88/x9e", "HANGUL SYLLABLE TYOLP");
+-   ("/xed/x88/x9f", "HANGUL SYLLABLE TYOLH");
+-   ("/xed/x88/xa0", "HANGUL SYLLABLE TYOM");
+-   ("/xed/x88/xa1", "HANGUL SYLLABLE TYOB");
+-   ("/xed/x88/xa2", "HANGUL SYLLABLE TYOBS");
+-   ("/xed/x88/xa3", "HANGUL SYLLABLE TYOS");
+-   ("/xed/x88/xa4", "HANGUL SYLLABLE TYOSS");
+-   ("/xed/x88/xa5", "HANGUL SYLLABLE TYONG");
+-   ("/xed/x88/xa6", "HANGUL SYLLABLE TYOJ");
+-   ("/xed/x88/xa7", "HANGUL SYLLABLE TYOC");
+-   ("/xed/x88/xa8", "HANGUL SYLLABLE TYOK");
+-   ("/xed/x88/xa9", "HANGUL SYLLABLE TYOT");
+-   ("/xed/x88/xaa", "HANGUL SYLLABLE TYOP");
+-   ("/xed/x88/xab", "HANGUL SYLLABLE TYOH");
+-   ("/xed/x88/xac", "HANGUL SYLLABLE TU");
+-   ("/xed/x88/xad", "HANGUL SYLLABLE TUG");
+-   ("/xed/x88/xae", "HANGUL SYLLABLE TUGG");
+-   ("/xed/x88/xaf", "HANGUL SYLLABLE TUGS");
+-   ("/xed/x88/xb0", "HANGUL SYLLABLE TUN");
+-   ("/xed/x88/xb1", "HANGUL SYLLABLE TUNI");
+-   ("/xed/x88/xb2", "HANGUL SYLLABLE TUNH");
+-   ("/xed/x88/xb3", "HANGUL SYLLABLE TUD");
+-   ("/xed/x88/xb4", "HANGUL SYLLABLE TUL");
+-   ("/xed/x88/xb5", "HANGUL SYLLABLE TULG");
+-   ("/xed/x88/xb6", "HANGUL SYLLABLE TULM");
+-   ("/xed/x88/xb7", "HANGUL SYLLABLE TULB");
+-   ("/xed/x88/xb8", "HANGUL SYLLABLE TULS");
+-   ("/xed/x88/xb9", "HANGUL SYLLABLE TULT");
+-   ("/xed/x88/xba", "HANGUL SYLLABLE TULP");
+-   ("/xed/x88/xbb", "HANGUL SYLLABLE TULH");
+-   ("/xed/x88/xbc", "HANGUL SYLLABLE TUM");
+-   ("/xed/x88/xbd", "HANGUL SYLLABLE TUB");
+-   ("/xed/x88/xbe", "HANGUL SYLLABLE TUBS");
+-   ("/xed/x88/xbf", "HANGUL SYLLABLE TUS");
+-   ("/xed/x89/x80", "HANGUL SYLLABLE TUSS");
+-   ("/xed/x89/x81", "HANGUL SYLLABLE TUNG");
+-   ("/xed/x89/x82", "HANGUL SYLLABLE TUJ");
+-   ("/xed/x89/x83", "HANGUL SYLLABLE TUC");
+-   ("/xed/x89/x84", "HANGUL SYLLABLE TUK");
+-   ("/xed/x89/x85", "HANGUL SYLLABLE TUT");
+-   ("/xed/x89/x86", "HANGUL SYLLABLE TUP");
+-   ("/xed/x89/x87", "HANGUL SYLLABLE TUH");
+-   ("/xed/x89/x88", "HANGUL SYLLABLE TWEO");
+-   ("/xed/x89/x89", "HANGUL SYLLABLE TWEOG");
+-   ("/xed/x89/x8a", "HANGUL SYLLABLE TWEOGG");
+-   ("/xed/x89/x8b", "HANGUL SYLLABLE TWEOGS");
+-   ("/xed/x89/x8c", "HANGUL SYLLABLE TWEON");
+-   ("/xed/x89/x8d", "HANGUL SYLLABLE TWEONI");
+-   ("/xed/x89/x8e", "HANGUL SYLLABLE TWEONH");
+-   ("/xed/x89/x8f", "HANGUL SYLLABLE TWEOD");
+-   ("/xed/x89/x90", "HANGUL SYLLABLE TWEOL");
+-   ("/xed/x89/x91", "HANGUL SYLLABLE TWEOLG");
+-   ("/xed/x89/x92", "HANGUL SYLLABLE TWEOLM");
+-   ("/xed/x89/x93", "HANGUL SYLLABLE TWEOLB");
+-   ("/xed/x89/x94", "HANGUL SYLLABLE TWEOLS");
+-   ("/xed/x89/x95", "HANGUL SYLLABLE TWEOLT");
+-   ("/xed/x89/x96", "HANGUL SYLLABLE TWEOLP");
+-   ("/xed/x89/x97", "HANGUL SYLLABLE TWEOLH");
+-   ("/xed/x89/x98", "HANGUL SYLLABLE TWEOM");
+-   ("/xed/x89/x99", "HANGUL SYLLABLE TWEOB");
+-   ("/xed/x89/x9a", "HANGUL SYLLABLE TWEOBS");
+-   ("/xed/x89/x9b", "HANGUL SYLLABLE TWEOS");
+-   ("/xed/x89/x9c", "HANGUL SYLLABLE TWEOSS");
+-   ("/xed/x89/x9d", "HANGUL SYLLABLE TWEONG");
+-   ("/xed/x89/x9e", "HANGUL SYLLABLE TWEOJ");
+-   ("/xed/x89/x9f", "HANGUL SYLLABLE TWEOC");
+-   ("/xed/x89/xa0", "HANGUL SYLLABLE TWEOK");
+-   ("/xed/x89/xa1", "HANGUL SYLLABLE TWEOT");
+-   ("/xed/x89/xa2", "HANGUL SYLLABLE TWEOP");
+-   ("/xed/x89/xa3", "HANGUL SYLLABLE TWEOH");
+-   ("/xed/x89/xa4", "HANGUL SYLLABLE TWE");
+-   ("/xed/x89/xa5", "HANGUL SYLLABLE TWEG");
+-   ("/xed/x89/xa6", "HANGUL SYLLABLE TWEGG");
+-   ("/xed/x89/xa7", "HANGUL SYLLABLE TWEGS");
+-   ("/xed/x89/xa8", "HANGUL SYLLABLE TWEN");
+-   ("/xed/x89/xa9", "HANGUL SYLLABLE TWENI");
+-   ("/xed/x89/xaa", "HANGUL SYLLABLE TWENH");
+-   ("/xed/x89/xab", "HANGUL SYLLABLE TWED");
+-   ("/xed/x89/xac", "HANGUL SYLLABLE TWEL");
+-   ("/xed/x89/xad", "HANGUL SYLLABLE TWELG");
+-   ("/xed/x89/xae", "HANGUL SYLLABLE TWELM");
+-   ("/xed/x89/xaf", "HANGUL SYLLABLE TWELB");
+-   ("/xed/x89/xb0", "HANGUL SYLLABLE TWELS");
+-   ("/xed/x89/xb1", "HANGUL SYLLABLE TWELT");
+-   ("/xed/x89/xb2", "HANGUL SYLLABLE TWELP");
+-   ("/xed/x89/xb3", "HANGUL SYLLABLE TWELH");
+-   ("/xed/x89/xb4", "HANGUL SYLLABLE TWEM");
+-   ("/xed/x89/xb5", "HANGUL SYLLABLE TWEB");
+-   ("/xed/x89/xb6", "HANGUL SYLLABLE TWEBS");
+-   ("/xed/x89/xb7", "HANGUL SYLLABLE TWES");
+-   ("/xed/x89/xb8", "HANGUL SYLLABLE TWESS");
+-   ("/xed/x89/xb9", "HANGUL SYLLABLE TWENG");
+-   ("/xed/x89/xba", "HANGUL SYLLABLE TWEJ");
+-   ("/xed/x89/xbb", "HANGUL SYLLABLE TWEC");
+-   ("/xed/x89/xbc", "HANGUL SYLLABLE TWEK");
+-   ("/xed/x89/xbd", "HANGUL SYLLABLE TWET");
+-   ("/xed/x89/xbe", "HANGUL SYLLABLE TWEP");
+-   ("/xed/x89/xbf", "HANGUL SYLLABLE TWEH");
+-   ("/xed/x8a/x80", "HANGUL SYLLABLE TWI");
+-   ("/xed/x8a/x81", "HANGUL SYLLABLE TWIG");
+-   ("/xed/x8a/x82", "HANGUL SYLLABLE TWIGG");
+-   ("/xed/x8a/x83", "HANGUL SYLLABLE TWIGS");
+-   ("/xed/x8a/x84", "HANGUL SYLLABLE TWIN");
+-   ("/xed/x8a/x85", "HANGUL SYLLABLE TWINI");
+-   ("/xed/x8a/x86", "HANGUL SYLLABLE TWINH");
+-   ("/xed/x8a/x87", "HANGUL SYLLABLE TWID");
+-   ("/xed/x8a/x88", "HANGUL SYLLABLE TWIL");
+-   ("/xed/x8a/x89", "HANGUL SYLLABLE TWILG");
+-   ("/xed/x8a/x8a", "HANGUL SYLLABLE TWILM");
+-   ("/xed/x8a/x8b", "HANGUL SYLLABLE TWILB");
+-   ("/xed/x8a/x8c", "HANGUL SYLLABLE TWILS");
+-   ("/xed/x8a/x8d", "HANGUL SYLLABLE TWILT");
+-   ("/xed/x8a/x8e", "HANGUL SYLLABLE TWILP");
+-   ("/xed/x8a/x8f", "HANGUL SYLLABLE TWILH");
+-   ("/xed/x8a/x90", "HANGUL SYLLABLE TWIM");
+-   ("/xed/x8a/x91", "HANGUL SYLLABLE TWIB");
+-   ("/xed/x8a/x92", "HANGUL SYLLABLE TWIBS");
+-   ("/xed/x8a/x93", "HANGUL SYLLABLE TWIS");
+-   ("/xed/x8a/x94", "HANGUL SYLLABLE TWISS");
+-   ("/xed/x8a/x95", "HANGUL SYLLABLE TWING");
+-   ("/xed/x8a/x96", "HANGUL SYLLABLE TWIJ");
+-   ("/xed/x8a/x97", "HANGUL SYLLABLE TWIC");
+-   ("/xed/x8a/x98", "HANGUL SYLLABLE TWIK");
+-   ("/xed/x8a/x99", "HANGUL SYLLABLE TWIT");
+-   ("/xed/x8a/x9a", "HANGUL SYLLABLE TWIP");
+-   ("/xed/x8a/x9b", "HANGUL SYLLABLE TWIH");
+-   ("/xed/x8a/x9c", "HANGUL SYLLABLE TYU");
+-   ("/xed/x8a/x9d", "HANGUL SYLLABLE TYUG");
+-   ("/xed/x8a/x9e", "HANGUL SYLLABLE TYUGG");
+-   ("/xed/x8a/x9f", "HANGUL SYLLABLE TYUGS");
+-   ("/xed/x8a/xa0", "HANGUL SYLLABLE TYUN");
+-   ("/xed/x8a/xa1", "HANGUL SYLLABLE TYUNI");
+-   ("/xed/x8a/xa2", "HANGUL SYLLABLE TYUNH");
+-   ("/xed/x8a/xa3", "HANGUL SYLLABLE TYUD");
+-   ("/xed/x8a/xa4", "HANGUL SYLLABLE TYUL");
+-   ("/xed/x8a/xa5", "HANGUL SYLLABLE TYULG");
+-   ("/xed/x8a/xa6", "HANGUL SYLLABLE TYULM");
+-   ("/xed/x8a/xa7", "HANGUL SYLLABLE TYULB");
+-   ("/xed/x8a/xa8", "HANGUL SYLLABLE TYULS");
+-   ("/xed/x8a/xa9", "HANGUL SYLLABLE TYULT");
+-   ("/xed/x8a/xaa", "HANGUL SYLLABLE TYULP");
+-   ("/xed/x8a/xab", "HANGUL SYLLABLE TYULH");
+-   ("/xed/x8a/xac", "HANGUL SYLLABLE TYUM");
+-   ("/xed/x8a/xad", "HANGUL SYLLABLE TYUB");
+-   ("/xed/x8a/xae", "HANGUL SYLLABLE TYUBS");
+-   ("/xed/x8a/xaf", "HANGUL SYLLABLE TYUS");
+-   ("/xed/x8a/xb0", "HANGUL SYLLABLE TYUSS");
+-   ("/xed/x8a/xb1", "HANGUL SYLLABLE TYUNG");
+-   ("/xed/x8a/xb2", "HANGUL SYLLABLE TYUJ");
+-   ("/xed/x8a/xb3", "HANGUL SYLLABLE TYUC");
+-   ("/xed/x8a/xb4", "HANGUL SYLLABLE TYUK");
+-   ("/xed/x8a/xb5", "HANGUL SYLLABLE TYUT");
+-   ("/xed/x8a/xb6", "HANGUL SYLLABLE TYUP");
+-   ("/xed/x8a/xb7", "HANGUL SYLLABLE TYUH");
+-   ("/xed/x8a/xb8", "HANGUL SYLLABLE TEU");
+-   ("/xed/x8a/xb9", "HANGUL SYLLABLE TEUG");
+-   ("/xed/x8a/xba", "HANGUL SYLLABLE TEUGG");
+-   ("/xed/x8a/xbb", "HANGUL SYLLABLE TEUGS");
+-   ("/xed/x8a/xbc", "HANGUL SYLLABLE TEUN");
+-   ("/xed/x8a/xbd", "HANGUL SYLLABLE TEUNI");
+-   ("/xed/x8a/xbe", "HANGUL SYLLABLE TEUNH");
+-   ("/xed/x8a/xbf", "HANGUL SYLLABLE TEUD");
+-   ("/xed/x8b/x80", "HANGUL SYLLABLE TEUL");
+-   ("/xed/x8b/x81", "HANGUL SYLLABLE TEULG");
+-   ("/xed/x8b/x82", "HANGUL SYLLABLE TEULM");
+-   ("/xed/x8b/x83", "HANGUL SYLLABLE TEULB");
+-   ("/xed/x8b/x84", "HANGUL SYLLABLE TEULS");
+-   ("/xed/x8b/x85", "HANGUL SYLLABLE TEULT");
+-   ("/xed/x8b/x86", "HANGUL SYLLABLE TEULP");
+-   ("/xed/x8b/x87", "HANGUL SYLLABLE TEULH");
+-   ("/xed/x8b/x88", "HANGUL SYLLABLE TEUM");
+-   ("/xed/x8b/x89", "HANGUL SYLLABLE TEUB");
+-   ("/xed/x8b/x8a", "HANGUL SYLLABLE TEUBS");
+-   ("/xed/x8b/x8b", "HANGUL SYLLABLE TEUS");
+-   ("/xed/x8b/x8c", "HANGUL SYLLABLE TEUSS");
+-   ("/xed/x8b/x8d", "HANGUL SYLLABLE TEUNG");
+-   ("/xed/x8b/x8e", "HANGUL SYLLABLE TEUJ");
+-   ("/xed/x8b/x8f", "HANGUL SYLLABLE TEUC");
+-   ("/xed/x8b/x90", "HANGUL SYLLABLE TEUK");
+-   ("/xed/x8b/x91", "HANGUL SYLLABLE TEUT");
+-   ("/xed/x8b/x92", "HANGUL SYLLABLE TEUP");
+-   ("/xed/x8b/x93", "HANGUL SYLLABLE TEUH");
+-   ("/xed/x8b/x94", "HANGUL SYLLABLE TYI");
+-   ("/xed/x8b/x95", "HANGUL SYLLABLE TYIG");
+-   ("/xed/x8b/x96", "HANGUL SYLLABLE TYIGG");
+-   ("/xed/x8b/x97", "HANGUL SYLLABLE TYIGS");
+-   ("/xed/x8b/x98", "HANGUL SYLLABLE TYIN");
+-   ("/xed/x8b/x99", "HANGUL SYLLABLE TYINI");
+-   ("/xed/x8b/x9a", "HANGUL SYLLABLE TYINH");
+-   ("/xed/x8b/x9b", "HANGUL SYLLABLE TYID");
+-   ("/xed/x8b/x9c", "HANGUL SYLLABLE TYIL");
+-   ("/xed/x8b/x9d", "HANGUL SYLLABLE TYILG");
+-   ("/xed/x8b/x9e", "HANGUL SYLLABLE TYILM");
+-   ("/xed/x8b/x9f", "HANGUL SYLLABLE TYILB");
+-   ("/xed/x8b/xa0", "HANGUL SYLLABLE TYILS");
+-   ("/xed/x8b/xa1", "HANGUL SYLLABLE TYILT");
+-   ("/xed/x8b/xa2", "HANGUL SYLLABLE TYILP");
+-   ("/xed/x8b/xa3", "HANGUL SYLLABLE TYILH");
+-   ("/xed/x8b/xa4", "HANGUL SYLLABLE TYIM");
+-   ("/xed/x8b/xa5", "HANGUL SYLLABLE TYIB");
+-   ("/xed/x8b/xa6", "HANGUL SYLLABLE TYIBS");
+-   ("/xed/x8b/xa7", "HANGUL SYLLABLE TYIS");
+-   ("/xed/x8b/xa8", "HANGUL SYLLABLE TYISS");
+-   ("/xed/x8b/xa9", "HANGUL SYLLABLE TYING");
+-   ("/xed/x8b/xaa", "HANGUL SYLLABLE TYIJ");
+-   ("/xed/x8b/xab", "HANGUL SYLLABLE TYIC");
+-   ("/xed/x8b/xac", "HANGUL SYLLABLE TYIK");
+-   ("/xed/x8b/xad", "HANGUL SYLLABLE TYIT");
+-   ("/xed/x8b/xae", "HANGUL SYLLABLE TYIP");
+-   ("/xed/x8b/xaf", "HANGUL SYLLABLE TYIH");
+-   ("/xed/x8b/xb0", "HANGUL SYLLABLE TI");
+-   ("/xed/x8b/xb1", "HANGUL SYLLABLE TIG");
+-   ("/xed/x8b/xb2", "HANGUL SYLLABLE TIGG");
+-   ("/xed/x8b/xb3", "HANGUL SYLLABLE TIGS");
+-   ("/xed/x8b/xb4", "HANGUL SYLLABLE TIN");
+-   ("/xed/x8b/xb5", "HANGUL SYLLABLE TINI");
+-   ("/xed/x8b/xb6", "HANGUL SYLLABLE TINH");
+-   ("/xed/x8b/xb7", "HANGUL SYLLABLE TID");
+-   ("/xed/x8b/xb8", "HANGUL SYLLABLE TIL");
+-   ("/xed/x8b/xb9", "HANGUL SYLLABLE TILG");
+-   ("/xed/x8b/xba", "HANGUL SYLLABLE TILM");
+-   ("/xed/x8b/xbb", "HANGUL SYLLABLE TILB");
+-   ("/xed/x8b/xbc", "HANGUL SYLLABLE TILS");
+-   ("/xed/x8b/xbd", "HANGUL SYLLABLE TILT");
+-   ("/xed/x8b/xbe", "HANGUL SYLLABLE TILP");
+-   ("/xed/x8b/xbf", "HANGUL SYLLABLE TILH");
+-   ("/xed/x8c/x80", "HANGUL SYLLABLE TIM");
+-   ("/xed/x8c/x81", "HANGUL SYLLABLE TIB");
+-   ("/xed/x8c/x82", "HANGUL SYLLABLE TIBS");
+-   ("/xed/x8c/x83", "HANGUL SYLLABLE TIS");
+-   ("/xed/x8c/x84", "HANGUL SYLLABLE TISS");
+-   ("/xed/x8c/x85", "HANGUL SYLLABLE TING");
+-   ("/xed/x8c/x86", "HANGUL SYLLABLE TIJ");
+-   ("/xed/x8c/x87", "HANGUL SYLLABLE TIC");
+-   ("/xed/x8c/x88", "HANGUL SYLLABLE TIK");
+-   ("/xed/x8c/x89", "HANGUL SYLLABLE TIT");
+-   ("/xed/x8c/x8a", "HANGUL SYLLABLE TIP");
+-   ("/xed/x8c/x8b", "HANGUL SYLLABLE TIH");
+-   ("/xed/x8c/x8c", "HANGUL SYLLABLE PA");
+-   ("/xed/x8c/x8d", "HANGUL SYLLABLE PAG");
+-   ("/xed/x8c/x8e", "HANGUL SYLLABLE PAGG");
+-   ("/xed/x8c/x8f", "HANGUL SYLLABLE PAGS");
+-   ("/xed/x8c/x90", "HANGUL SYLLABLE PAN");
+-   ("/xed/x8c/x91", "HANGUL SYLLABLE PANI");
+-   ("/xed/x8c/x92", "HANGUL SYLLABLE PANH");
+-   ("/xed/x8c/x93", "HANGUL SYLLABLE PAD");
+-   ("/xed/x8c/x94", "HANGUL SYLLABLE PAL");
+-   ("/xed/x8c/x95", "HANGUL SYLLABLE PALG");
+-   ("/xed/x8c/x96", "HANGUL SYLLABLE PALM");
+-   ("/xed/x8c/x97", "HANGUL SYLLABLE PALB");
+-   ("/xed/x8c/x98", "HANGUL SYLLABLE PALS");
+-   ("/xed/x8c/x99", "HANGUL SYLLABLE PALT");
+-   ("/xed/x8c/x9a", "HANGUL SYLLABLE PALP");
+-   ("/xed/x8c/x9b", "HANGUL SYLLABLE PALH");
+-   ("/xed/x8c/x9c", "HANGUL SYLLABLE PAM");
+-   ("/xed/x8c/x9d", "HANGUL SYLLABLE PAB");
+-   ("/xed/x8c/x9e", "HANGUL SYLLABLE PABS");
+-   ("/xed/x8c/x9f", "HANGUL SYLLABLE PAS");
+-   ("/xed/x8c/xa0", "HANGUL SYLLABLE PASS");
+-   ("/xed/x8c/xa1", "HANGUL SYLLABLE PANG");
+-   ("/xed/x8c/xa2", "HANGUL SYLLABLE PAJ");
+-   ("/xed/x8c/xa3", "HANGUL SYLLABLE PAC");
+-   ("/xed/x8c/xa4", "HANGUL SYLLABLE PAK");
+-   ("/xed/x8c/xa5", "HANGUL SYLLABLE PAT");
+-   ("/xed/x8c/xa6", "HANGUL SYLLABLE PAP");
+-   ("/xed/x8c/xa7", "HANGUL SYLLABLE PAH");
+-   ("/xed/x8c/xa8", "HANGUL SYLLABLE PAE");
+-   ("/xed/x8c/xa9", "HANGUL SYLLABLE PAEG");
+-   ("/xed/x8c/xaa", "HANGUL SYLLABLE PAEGG");
+-   ("/xed/x8c/xab", "HANGUL SYLLABLE PAEGS");
+-   ("/xed/x8c/xac", "HANGUL SYLLABLE PAEN");
+-   ("/xed/x8c/xad", "HANGUL SYLLABLE PAENI");
+-   ("/xed/x8c/xae", "HANGUL SYLLABLE PAENH");
+-   ("/xed/x8c/xaf", "HANGUL SYLLABLE PAED");
+-   ("/xed/x8c/xb0", "HANGUL SYLLABLE PAEL");
+-   ("/xed/x8c/xb1", "HANGUL SYLLABLE PAELG");
+-   ("/xed/x8c/xb2", "HANGUL SYLLABLE PAELM");
+-   ("/xed/x8c/xb3", "HANGUL SYLLABLE PAELB");
+-   ("/xed/x8c/xb4", "HANGUL SYLLABLE PAELS");
+-   ("/xed/x8c/xb5", "HANGUL SYLLABLE PAELT");
+-   ("/xed/x8c/xb6", "HANGUL SYLLABLE PAELP");
+-   ("/xed/x8c/xb7", "HANGUL SYLLABLE PAELH");
+-   ("/xed/x8c/xb8", "HANGUL SYLLABLE PAEM");
+-   ("/xed/x8c/xb9", "HANGUL SYLLABLE PAEB");
+-   ("/xed/x8c/xba", "HANGUL SYLLABLE PAEBS");
+-   ("/xed/x8c/xbb", "HANGUL SYLLABLE PAES");
+-   ("/xed/x8c/xbc", "HANGUL SYLLABLE PAESS");
+-   ("/xed/x8c/xbd", "HANGUL SYLLABLE PAENG");
+-   ("/xed/x8c/xbe", "HANGUL SYLLABLE PAEJ");
+-   ("/xed/x8c/xbf", "HANGUL SYLLABLE PAEC");
+-   ("/xed/x8d/x80", "HANGUL SYLLABLE PAEK");
+-   ("/xed/x8d/x81", "HANGUL SYLLABLE PAET");
+-   ("/xed/x8d/x82", "HANGUL SYLLABLE PAEP");
+-   ("/xed/x8d/x83", "HANGUL SYLLABLE PAEH");
+-   ("/xed/x8d/x84", "HANGUL SYLLABLE PYA");
+-   ("/xed/x8d/x85", "HANGUL SYLLABLE PYAG");
+-   ("/xed/x8d/x86", "HANGUL SYLLABLE PYAGG");
+-   ("/xed/x8d/x87", "HANGUL SYLLABLE PYAGS");
+-   ("/xed/x8d/x88", "HANGUL SYLLABLE PYAN");
+-   ("/xed/x8d/x89", "HANGUL SYLLABLE PYANI");
+-   ("/xed/x8d/x8a", "HANGUL SYLLABLE PYANH");
+-   ("/xed/x8d/x8b", "HANGUL SYLLABLE PYAD");
+-   ("/xed/x8d/x8c", "HANGUL SYLLABLE PYAL");
+-   ("/xed/x8d/x8d", "HANGUL SYLLABLE PYALG");
+-   ("/xed/x8d/x8e", "HANGUL SYLLABLE PYALM");
+-   ("/xed/x8d/x8f", "HANGUL SYLLABLE PYALB");
+-   ("/xed/x8d/x90", "HANGUL SYLLABLE PYALS");
+-   ("/xed/x8d/x91", "HANGUL SYLLABLE PYALT");
+-   ("/xed/x8d/x92", "HANGUL SYLLABLE PYALP");
+-   ("/xed/x8d/x93", "HANGUL SYLLABLE PYALH");
+-   ("/xed/x8d/x94", "HANGUL SYLLABLE PYAM");
+-   ("/xed/x8d/x95", "HANGUL SYLLABLE PYAB");
+-   ("/xed/x8d/x96", "HANGUL SYLLABLE PYABS");
+-   ("/xed/x8d/x97", "HANGUL SYLLABLE PYAS");
+-   ("/xed/x8d/x98", "HANGUL SYLLABLE PYASS");
+-   ("/xed/x8d/x99", "HANGUL SYLLABLE PYANG");
+-   ("/xed/x8d/x9a", "HANGUL SYLLABLE PYAJ");
+-   ("/xed/x8d/x9b", "HANGUL SYLLABLE PYAC");
+-   ("/xed/x8d/x9c", "HANGUL SYLLABLE PYAK");
+-   ("/xed/x8d/x9d", "HANGUL SYLLABLE PYAT");
+-   ("/xed/x8d/x9e", "HANGUL SYLLABLE PYAP");
+-   ("/xed/x8d/x9f", "HANGUL SYLLABLE PYAH");
+-   ("/xed/x8d/xa0", "HANGUL SYLLABLE PYAE");
+-   ("/xed/x8d/xa1", "HANGUL SYLLABLE PYAEG");
+-   ("/xed/x8d/xa2", "HANGUL SYLLABLE PYAEGG");
+-   ("/xed/x8d/xa3", "HANGUL SYLLABLE PYAEGS");
+-   ("/xed/x8d/xa4", "HANGUL SYLLABLE PYAEN");
+-   ("/xed/x8d/xa5", "HANGUL SYLLABLE PYAENI");
+-   ("/xed/x8d/xa6", "HANGUL SYLLABLE PYAENH");
+-   ("/xed/x8d/xa7", "HANGUL SYLLABLE PYAED");
+-   ("/xed/x8d/xa8", "HANGUL SYLLABLE PYAEL");
+-   ("/xed/x8d/xa9", "HANGUL SYLLABLE PYAELG");
+-   ("/xed/x8d/xaa", "HANGUL SYLLABLE PYAELM");
+-   ("/xed/x8d/xab", "HANGUL SYLLABLE PYAELB");
+-   ("/xed/x8d/xac", "HANGUL SYLLABLE PYAELS");
+-   ("/xed/x8d/xad", "HANGUL SYLLABLE PYAELT");
+-   ("/xed/x8d/xae", "HANGUL SYLLABLE PYAELP");
+-   ("/xed/x8d/xaf", "HANGUL SYLLABLE PYAELH");
+-   ("/xed/x8d/xb0", "HANGUL SYLLABLE PYAEM");
+-   ("/xed/x8d/xb1", "HANGUL SYLLABLE PYAEB");
+-   ("/xed/x8d/xb2", "HANGUL SYLLABLE PYAEBS");
+-   ("/xed/x8d/xb3", "HANGUL SYLLABLE PYAES");
+-   ("/xed/x8d/xb4", "HANGUL SYLLABLE PYAESS");
+-   ("/xed/x8d/xb5", "HANGUL SYLLABLE PYAENG");
+-   ("/xed/x8d/xb6", "HANGUL SYLLABLE PYAEJ");
+-   ("/xed/x8d/xb7", "HANGUL SYLLABLE PYAEC");
+-   ("/xed/x8d/xb8", "HANGUL SYLLABLE PYAEK");
+-   ("/xed/x8d/xb9", "HANGUL SYLLABLE PYAET");
+-   ("/xed/x8d/xba", "HANGUL SYLLABLE PYAEP");
+-   ("/xed/x8d/xbb", "HANGUL SYLLABLE PYAEH");
+-   ("/xed/x8d/xbc", "HANGUL SYLLABLE PEO");
+-   ("/xed/x8d/xbd", "HANGUL SYLLABLE PEOG");
+-   ("/xed/x8d/xbe", "HANGUL SYLLABLE PEOGG");
+-   ("/xed/x8d/xbf", "HANGUL SYLLABLE PEOGS");
+-   ("/xed/x8e/x80", "HANGUL SYLLABLE PEON");
+-   ("/xed/x8e/x81", "HANGUL SYLLABLE PEONI");
+-   ("/xed/x8e/x82", "HANGUL SYLLABLE PEONH");
+-   ("/xed/x8e/x83", "HANGUL SYLLABLE PEOD");
+-   ("/xed/x8e/x84", "HANGUL SYLLABLE PEOL");
+-   ("/xed/x8e/x85", "HANGUL SYLLABLE PEOLG");
+-   ("/xed/x8e/x86", "HANGUL SYLLABLE PEOLM");
+-   ("/xed/x8e/x87", "HANGUL SYLLABLE PEOLB");
+-   ("/xed/x8e/x88", "HANGUL SYLLABLE PEOLS");
+-   ("/xed/x8e/x89", "HANGUL SYLLABLE PEOLT");
+-   ("/xed/x8e/x8a", "HANGUL SYLLABLE PEOLP");
+-   ("/xed/x8e/x8b", "HANGUL SYLLABLE PEOLH");
+-   ("/xed/x8e/x8c", "HANGUL SYLLABLE PEOM");
+-   ("/xed/x8e/x8d", "HANGUL SYLLABLE PEOB");
+-   ("/xed/x8e/x8e", "HANGUL SYLLABLE PEOBS");
+-   ("/xed/x8e/x8f", "HANGUL SYLLABLE PEOS");
+-   ("/xed/x8e/x90", "HANGUL SYLLABLE PEOSS");
+-   ("/xed/x8e/x91", "HANGUL SYLLABLE PEONG");
+-   ("/xed/x8e/x92", "HANGUL SYLLABLE PEOJ");
+-   ("/xed/x8e/x93", "HANGUL SYLLABLE PEOC");
+-   ("/xed/x8e/x94", "HANGUL SYLLABLE PEOK");
+-   ("/xed/x8e/x95", "HANGUL SYLLABLE PEOT");
+-   ("/xed/x8e/x96", "HANGUL SYLLABLE PEOP");
+-   ("/xed/x8e/x97", "HANGUL SYLLABLE PEOH");
+-   ("/xed/x8e/x98", "HANGUL SYLLABLE PE");
+-   ("/xed/x8e/x99", "HANGUL SYLLABLE PEG");
+-   ("/xed/x8e/x9a", "HANGUL SYLLABLE PEGG");
+-   ("/xed/x8e/x9b", "HANGUL SYLLABLE PEGS");
+-   ("/xed/x8e/x9c", "HANGUL SYLLABLE PEN");
+-   ("/xed/x8e/x9d", "HANGUL SYLLABLE PENI");
+-   ("/xed/x8e/x9e", "HANGUL SYLLABLE PENH");
+-   ("/xed/x8e/x9f", "HANGUL SYLLABLE PED");
+-   ("/xed/x8e/xa0", "HANGUL SYLLABLE PEL");
+-   ("/xed/x8e/xa1", "HANGUL SYLLABLE PELG");
+-   ("/xed/x8e/xa2", "HANGUL SYLLABLE PELM");
+-   ("/xed/x8e/xa3", "HANGUL SYLLABLE PELB");
+-   ("/xed/x8e/xa4", "HANGUL SYLLABLE PELS");
+-   ("/xed/x8e/xa5", "HANGUL SYLLABLE PELT");
+-   ("/xed/x8e/xa6", "HANGUL SYLLABLE PELP");
+-   ("/xed/x8e/xa7", "HANGUL SYLLABLE PELH");
+-   ("/xed/x8e/xa8", "HANGUL SYLLABLE PEM");
+-   ("/xed/x8e/xa9", "HANGUL SYLLABLE PEB");
+-   ("/xed/x8e/xaa", "HANGUL SYLLABLE PEBS");
+-   ("/xed/x8e/xab", "HANGUL SYLLABLE PES");
+-   ("/xed/x8e/xac", "HANGUL SYLLABLE PESS");
+-   ("/xed/x8e/xad", "HANGUL SYLLABLE PENG");
+-   ("/xed/x8e/xae", "HANGUL SYLLABLE PEJ");
+-   ("/xed/x8e/xaf", "HANGUL SYLLABLE PEC");
+-   ("/xed/x8e/xb0", "HANGUL SYLLABLE PEK");
+-   ("/xed/x8e/xb1", "HANGUL SYLLABLE PET");
+-   ("/xed/x8e/xb2", "HANGUL SYLLABLE PEP");
+-   ("/xed/x8e/xb3", "HANGUL SYLLABLE PEH");
+-   ("/xed/x8e/xb4", "HANGUL SYLLABLE PYEO");
+-   ("/xed/x8e/xb5", "HANGUL SYLLABLE PYEOG");
+-   ("/xed/x8e/xb6", "HANGUL SYLLABLE PYEOGG");
+-   ("/xed/x8e/xb7", "HANGUL SYLLABLE PYEOGS");
+-   ("/xed/x8e/xb8", "HANGUL SYLLABLE PYEON");
+-   ("/xed/x8e/xb9", "HANGUL SYLLABLE PYEONI");
+-   ("/xed/x8e/xba", "HANGUL SYLLABLE PYEONH");
+-   ("/xed/x8e/xbb", "HANGUL SYLLABLE PYEOD");
+-   ("/xed/x8e/xbc", "HANGUL SYLLABLE PYEOL");
+-   ("/xed/x8e/xbd", "HANGUL SYLLABLE PYEOLG");
+-   ("/xed/x8e/xbe", "HANGUL SYLLABLE PYEOLM");
+-   ("/xed/x8e/xbf", "HANGUL SYLLABLE PYEOLB");
+-   ("/xed/x8f/x80", "HANGUL SYLLABLE PYEOLS");
+-   ("/xed/x8f/x81", "HANGUL SYLLABLE PYEOLT");
+-   ("/xed/x8f/x82", "HANGUL SYLLABLE PYEOLP");
+-   ("/xed/x8f/x83", "HANGUL SYLLABLE PYEOLH");
+-   ("/xed/x8f/x84", "HANGUL SYLLABLE PYEOM");
+-   ("/xed/x8f/x85", "HANGUL SYLLABLE PYEOB");
+-   ("/xed/x8f/x86", "HANGUL SYLLABLE PYEOBS");
+-   ("/xed/x8f/x87", "HANGUL SYLLABLE PYEOS");
+-   ("/xed/x8f/x88", "HANGUL SYLLABLE PYEOSS");
+-   ("/xed/x8f/x89", "HANGUL SYLLABLE PYEONG");
+-   ("/xed/x8f/x8a", "HANGUL SYLLABLE PYEOJ");
+-   ("/xed/x8f/x8b", "HANGUL SYLLABLE PYEOC");
+-   ("/xed/x8f/x8c", "HANGUL SYLLABLE PYEOK");
+-   ("/xed/x8f/x8d", "HANGUL SYLLABLE PYEOT");
+-   ("/xed/x8f/x8e", "HANGUL SYLLABLE PYEOP");
+-   ("/xed/x8f/x8f", "HANGUL SYLLABLE PYEOH");
+-   ("/xed/x8f/x90", "HANGUL SYLLABLE PYE");
+-   ("/xed/x8f/x91", "HANGUL SYLLABLE PYEG");
+-   ("/xed/x8f/x92", "HANGUL SYLLABLE PYEGG");
+-   ("/xed/x8f/x93", "HANGUL SYLLABLE PYEGS");
+-   ("/xed/x8f/x94", "HANGUL SYLLABLE PYEN");
+-   ("/xed/x8f/x95", "HANGUL SYLLABLE PYENI");
+-   ("/xed/x8f/x96", "HANGUL SYLLABLE PYENH");
+-   ("/xed/x8f/x97", "HANGUL SYLLABLE PYED");
+-   ("/xed/x8f/x98", "HANGUL SYLLABLE PYEL");
+-   ("/xed/x8f/x99", "HANGUL SYLLABLE PYELG");
+-   ("/xed/x8f/x9a", "HANGUL SYLLABLE PYELM");
+-   ("/xed/x8f/x9b", "HANGUL SYLLABLE PYELB");
+-   ("/xed/x8f/x9c", "HANGUL SYLLABLE PYELS");
+-   ("/xed/x8f/x9d", "HANGUL SYLLABLE PYELT");
+-   ("/xed/x8f/x9e", "HANGUL SYLLABLE PYELP");
+-   ("/xed/x8f/x9f", "HANGUL SYLLABLE PYELH");
+-   ("/xed/x8f/xa0", "HANGUL SYLLABLE PYEM");
+-   ("/xed/x8f/xa1", "HANGUL SYLLABLE PYEB");
+-   ("/xed/x8f/xa2", "HANGUL SYLLABLE PYEBS");
+-   ("/xed/x8f/xa3", "HANGUL SYLLABLE PYES");
+-   ("/xed/x8f/xa4", "HANGUL SYLLABLE PYESS");
+-   ("/xed/x8f/xa5", "HANGUL SYLLABLE PYENG");
+-   ("/xed/x8f/xa6", "HANGUL SYLLABLE PYEJ");
+-   ("/xed/x8f/xa7", "HANGUL SYLLABLE PYEC");
+-   ("/xed/x8f/xa8", "HANGUL SYLLABLE PYEK");
+-   ("/xed/x8f/xa9", "HANGUL SYLLABLE PYET");
+-   ("/xed/x8f/xaa", "HANGUL SYLLABLE PYEP");
+-   ("/xed/x8f/xab", "HANGUL SYLLABLE PYEH");
+-   ("/xed/x8f/xac", "HANGUL SYLLABLE PO");
+-   ("/xed/x8f/xad", "HANGUL SYLLABLE POG");
+-   ("/xed/x8f/xae", "HANGUL SYLLABLE POGG");
+-   ("/xed/x8f/xaf", "HANGUL SYLLABLE POGS");
+-   ("/xed/x8f/xb0", "HANGUL SYLLABLE PON");
+-   ("/xed/x8f/xb1", "HANGUL SYLLABLE PONI");
+-   ("/xed/x8f/xb2", "HANGUL SYLLABLE PONH");
+-   ("/xed/x8f/xb3", "HANGUL SYLLABLE POD");
+-   ("/xed/x8f/xb4", "HANGUL SYLLABLE POL");
+-   ("/xed/x8f/xb5", "HANGUL SYLLABLE POLG");
+-   ("/xed/x8f/xb6", "HANGUL SYLLABLE POLM");
+-   ("/xed/x8f/xb7", "HANGUL SYLLABLE POLB");
+-   ("/xed/x8f/xb8", "HANGUL SYLLABLE POLS");
+-   ("/xed/x8f/xb9", "HANGUL SYLLABLE POLT");
+-   ("/xed/x8f/xba", "HANGUL SYLLABLE POLP");
+-   ("/xed/x8f/xbb", "HANGUL SYLLABLE POLH");
+-   ("/xed/x8f/xbc", "HANGUL SYLLABLE POM");
+-   ("/xed/x8f/xbd", "HANGUL SYLLABLE POB");
+-   ("/xed/x8f/xbe", "HANGUL SYLLABLE POBS");
+-   ("/xed/x8f/xbf", "HANGUL SYLLABLE POS");
+-   ("/xed/x90/x80", "HANGUL SYLLABLE POSS");
+-   ("/xed/x90/x81", "HANGUL SYLLABLE PONG");
+-   ("/xed/x90/x82", "HANGUL SYLLABLE POJ");
+-   ("/xed/x90/x83", "HANGUL SYLLABLE POC");
+-   ("/xed/x90/x84", "HANGUL SYLLABLE POK");
+-   ("/xed/x90/x85", "HANGUL SYLLABLE POT");
+-   ("/xed/x90/x86", "HANGUL SYLLABLE POP");
+-   ("/xed/x90/x87", "HANGUL SYLLABLE POH");
+-   ("/xed/x90/x88", "HANGUL SYLLABLE PWA");
+-   ("/xed/x90/x89", "HANGUL SYLLABLE PWAG");
+-   ("/xed/x90/x8a", "HANGUL SYLLABLE PWAGG");
+-   ("/xed/x90/x8b", "HANGUL SYLLABLE PWAGS");
+-   ("/xed/x90/x8c", "HANGUL SYLLABLE PWAN");
+-   ("/xed/x90/x8d", "HANGUL SYLLABLE PWANI");
+-   ("/xed/x90/x8e", "HANGUL SYLLABLE PWANH");
+-   ("/xed/x90/x8f", "HANGUL SYLLABLE PWAD");
+-   ("/xed/x90/x90", "HANGUL SYLLABLE PWAL");
+-   ("/xed/x90/x91", "HANGUL SYLLABLE PWALG");
+-   ("/xed/x90/x92", "HANGUL SYLLABLE PWALM");
+-   ("/xed/x90/x93", "HANGUL SYLLABLE PWALB");
+-   ("/xed/x90/x94", "HANGUL SYLLABLE PWALS");
+-   ("/xed/x90/x95", "HANGUL SYLLABLE PWALT");
+-   ("/xed/x90/x96", "HANGUL SYLLABLE PWALP");
+-   ("/xed/x90/x97", "HANGUL SYLLABLE PWALH");
+-   ("/xed/x90/x98", "HANGUL SYLLABLE PWAM");
+-   ("/xed/x90/x99", "HANGUL SYLLABLE PWAB");
+-   ("/xed/x90/x9a", "HANGUL SYLLABLE PWABS");
+-   ("/xed/x90/x9b", "HANGUL SYLLABLE PWAS");
+-   ("/xed/x90/x9c", "HANGUL SYLLABLE PWASS");
+-   ("/xed/x90/x9d", "HANGUL SYLLABLE PWANG");
+-   ("/xed/x90/x9e", "HANGUL SYLLABLE PWAJ");
+-   ("/xed/x90/x9f", "HANGUL SYLLABLE PWAC");
+-   ("/xed/x90/xa0", "HANGUL SYLLABLE PWAK");
+-   ("/xed/x90/xa1", "HANGUL SYLLABLE PWAT");
+-   ("/xed/x90/xa2", "HANGUL SYLLABLE PWAP");
+-   ("/xed/x90/xa3", "HANGUL SYLLABLE PWAH");
+-   ("/xed/x90/xa4", "HANGUL SYLLABLE PWAE");
+-   ("/xed/x90/xa5", "HANGUL SYLLABLE PWAEG");
+-   ("/xed/x90/xa6", "HANGUL SYLLABLE PWAEGG");
+-   ("/xed/x90/xa7", "HANGUL SYLLABLE PWAEGS");
+-   ("/xed/x90/xa8", "HANGUL SYLLABLE PWAEN");
+-   ("/xed/x90/xa9", "HANGUL SYLLABLE PWAENI");
+-   ("/xed/x90/xaa", "HANGUL SYLLABLE PWAENH");
+-   ("/xed/x90/xab", "HANGUL SYLLABLE PWAED");
+-   ("/xed/x90/xac", "HANGUL SYLLABLE PWAEL");
+-   ("/xed/x90/xad", "HANGUL SYLLABLE PWAELG");
+-   ("/xed/x90/xae", "HANGUL SYLLABLE PWAELM");
+-   ("/xed/x90/xaf", "HANGUL SYLLABLE PWAELB");
+-   ("/xed/x90/xb0", "HANGUL SYLLABLE PWAELS");
+-   ("/xed/x90/xb1", "HANGUL SYLLABLE PWAELT");
+-   ("/xed/x90/xb2", "HANGUL SYLLABLE PWAELP");
+-   ("/xed/x90/xb3", "HANGUL SYLLABLE PWAELH");
+-   ("/xed/x90/xb4", "HANGUL SYLLABLE PWAEM");
+-   ("/xed/x90/xb5", "HANGUL SYLLABLE PWAEB");
+-   ("/xed/x90/xb6", "HANGUL SYLLABLE PWAEBS");
+-   ("/xed/x90/xb7", "HANGUL SYLLABLE PWAES");
+-   ("/xed/x90/xb8", "HANGUL SYLLABLE PWAESS");
+-   ("/xed/x90/xb9", "HANGUL SYLLABLE PWAENG");
+-   ("/xed/x90/xba", "HANGUL SYLLABLE PWAEJ");
+-   ("/xed/x90/xbb", "HANGUL SYLLABLE PWAEC");
+-   ("/xed/x90/xbc", "HANGUL SYLLABLE PWAEK");
+-   ("/xed/x90/xbd", "HANGUL SYLLABLE PWAET");
+-   ("/xed/x90/xbe", "HANGUL SYLLABLE PWAEP");
+-   ("/xed/x90/xbf", "HANGUL SYLLABLE PWAEH");
+-   ("/xed/x91/x80", "HANGUL SYLLABLE POE");
+-   ("/xed/x91/x81", "HANGUL SYLLABLE POEG");
+-   ("/xed/x91/x82", "HANGUL SYLLABLE POEGG");
+-   ("/xed/x91/x83", "HANGUL SYLLABLE POEGS");
+-   ("/xed/x91/x84", "HANGUL SYLLABLE POEN");
+-   ("/xed/x91/x85", "HANGUL SYLLABLE POENI");
+-   ("/xed/x91/x86", "HANGUL SYLLABLE POENH");
+-   ("/xed/x91/x87", "HANGUL SYLLABLE POED");
+-   ("/xed/x91/x88", "HANGUL SYLLABLE POEL");
+-   ("/xed/x91/x89", "HANGUL SYLLABLE POELG");
+-   ("/xed/x91/x8a", "HANGUL SYLLABLE POELM");
+-   ("/xed/x91/x8b", "HANGUL SYLLABLE POELB");
+-   ("/xed/x91/x8c", "HANGUL SYLLABLE POELS");
+-   ("/xed/x91/x8d", "HANGUL SYLLABLE POELT");
+-   ("/xed/x91/x8e", "HANGUL SYLLABLE POELP");
+-   ("/xed/x91/x8f", "HANGUL SYLLABLE POELH");
+-   ("/xed/x91/x90", "HANGUL SYLLABLE POEM");
+-   ("/xed/x91/x91", "HANGUL SYLLABLE POEB");
+-   ("/xed/x91/x92", "HANGUL SYLLABLE POEBS");
+-   ("/xed/x91/x93", "HANGUL SYLLABLE POES");
+-   ("/xed/x91/x94", "HANGUL SYLLABLE POESS");
+-   ("/xed/x91/x95", "HANGUL SYLLABLE POENG");
+-   ("/xed/x91/x96", "HANGUL SYLLABLE POEJ");
+-   ("/xed/x91/x97", "HANGUL SYLLABLE POEC");
+-   ("/xed/x91/x98", "HANGUL SYLLABLE POEK");
+-   ("/xed/x91/x99", "HANGUL SYLLABLE POET");
+-   ("/xed/x91/x9a", "HANGUL SYLLABLE POEP");
+-   ("/xed/x91/x9b", "HANGUL SYLLABLE POEH");
+-   ("/xed/x91/x9c", "HANGUL SYLLABLE PYO");
+-   ("/xed/x91/x9d", "HANGUL SYLLABLE PYOG");
+-   ("/xed/x91/x9e", "HANGUL SYLLABLE PYOGG");
+-   ("/xed/x91/x9f", "HANGUL SYLLABLE PYOGS");
+-   ("/xed/x91/xa0", "HANGUL SYLLABLE PYON");
+-   ("/xed/x91/xa1", "HANGUL SYLLABLE PYONI");
+-   ("/xed/x91/xa2", "HANGUL SYLLABLE PYONH");
+-   ("/xed/x91/xa3", "HANGUL SYLLABLE PYOD");
+-   ("/xed/x91/xa4", "HANGUL SYLLABLE PYOL");
+-   ("/xed/x91/xa5", "HANGUL SYLLABLE PYOLG");
+-   ("/xed/x91/xa6", "HANGUL SYLLABLE PYOLM");
+-   ("/xed/x91/xa7", "HANGUL SYLLABLE PYOLB");
+-   ("/xed/x91/xa8", "HANGUL SYLLABLE PYOLS");
+-   ("/xed/x91/xa9", "HANGUL SYLLABLE PYOLT");
+-   ("/xed/x91/xaa", "HANGUL SYLLABLE PYOLP");
+-   ("/xed/x91/xab", "HANGUL SYLLABLE PYOLH");
+-   ("/xed/x91/xac", "HANGUL SYLLABLE PYOM");
+-   ("/xed/x91/xad", "HANGUL SYLLABLE PYOB");
+-   ("/xed/x91/xae", "HANGUL SYLLABLE PYOBS");
+-   ("/xed/x91/xaf", "HANGUL SYLLABLE PYOS");
+-   ("/xed/x91/xb0", "HANGUL SYLLABLE PYOSS");
+-   ("/xed/x91/xb1", "HANGUL SYLLABLE PYONG");
+-   ("/xed/x91/xb2", "HANGUL SYLLABLE PYOJ");
+-   ("/xed/x91/xb3", "HANGUL SYLLABLE PYOC");
+-   ("/xed/x91/xb4", "HANGUL SYLLABLE PYOK");
+-   ("/xed/x91/xb5", "HANGUL SYLLABLE PYOT");
+-   ("/xed/x91/xb6", "HANGUL SYLLABLE PYOP");
+-   ("/xed/x91/xb7", "HANGUL SYLLABLE PYOH");
+-   ("/xed/x91/xb8", "HANGUL SYLLABLE PU");
+-   ("/xed/x91/xb9", "HANGUL SYLLABLE PUG");
+-   ("/xed/x91/xba", "HANGUL SYLLABLE PUGG");
+-   ("/xed/x91/xbb", "HANGUL SYLLABLE PUGS");
+-   ("/xed/x91/xbc", "HANGUL SYLLABLE PUN");
+-   ("/xed/x91/xbd", "HANGUL SYLLABLE PUNI");
+-   ("/xed/x91/xbe", "HANGUL SYLLABLE PUNH");
+-   ("/xed/x91/xbf", "HANGUL SYLLABLE PUD");
+-   ("/xed/x92/x80", "HANGUL SYLLABLE PUL");
+-   ("/xed/x92/x81", "HANGUL SYLLABLE PULG");
+-   ("/xed/x92/x82", "HANGUL SYLLABLE PULM");
+-   ("/xed/x92/x83", "HANGUL SYLLABLE PULB");
+-   ("/xed/x92/x84", "HANGUL SYLLABLE PULS");
+-   ("/xed/x92/x85", "HANGUL SYLLABLE PULT");
+-   ("/xed/x92/x86", "HANGUL SYLLABLE PULP");
+-   ("/xed/x92/x87", "HANGUL SYLLABLE PULH");
+-   ("/xed/x92/x88", "HANGUL SYLLABLE PUM");
+-   ("/xed/x92/x89", "HANGUL SYLLABLE PUB");
+-   ("/xed/x92/x8a", "HANGUL SYLLABLE PUBS");
+-   ("/xed/x92/x8b", "HANGUL SYLLABLE PUS");
+-   ("/xed/x92/x8c", "HANGUL SYLLABLE PUSS");
+-   ("/xed/x92/x8d", "HANGUL SYLLABLE PUNG");
+-   ("/xed/x92/x8e", "HANGUL SYLLABLE PUJ");
+-   ("/xed/x92/x8f", "HANGUL SYLLABLE PUC");
+-   ("/xed/x92/x90", "HANGUL SYLLABLE PUK");
+-   ("/xed/x92/x91", "HANGUL SYLLABLE PUT");
+-   ("/xed/x92/x92", "HANGUL SYLLABLE PUP");
+-   ("/xed/x92/x93", "HANGUL SYLLABLE PUH");
+-   ("/xed/x92/x94", "HANGUL SYLLABLE PWEO");
+-   ("/xed/x92/x95", "HANGUL SYLLABLE PWEOG");
+-   ("/xed/x92/x96", "HANGUL SYLLABLE PWEOGG");
+-   ("/xed/x92/x97", "HANGUL SYLLABLE PWEOGS");
+-   ("/xed/x92/x98", "HANGUL SYLLABLE PWEON");
+-   ("/xed/x92/x99", "HANGUL SYLLABLE PWEONI");
+-   ("/xed/x92/x9a", "HANGUL SYLLABLE PWEONH");
+-   ("/xed/x92/x9b", "HANGUL SYLLABLE PWEOD");
+-   ("/xed/x92/x9c", "HANGUL SYLLABLE PWEOL");
+-   ("/xed/x92/x9d", "HANGUL SYLLABLE PWEOLG");
+-   ("/xed/x92/x9e", "HANGUL SYLLABLE PWEOLM");
+-   ("/xed/x92/x9f", "HANGUL SYLLABLE PWEOLB");
+-   ("/xed/x92/xa0", "HANGUL SYLLABLE PWEOLS");
+-   ("/xed/x92/xa1", "HANGUL SYLLABLE PWEOLT");
+-   ("/xed/x92/xa2", "HANGUL SYLLABLE PWEOLP");
+-   ("/xed/x92/xa3", "HANGUL SYLLABLE PWEOLH");
+-   ("/xed/x92/xa4", "HANGUL SYLLABLE PWEOM");
+-   ("/xed/x92/xa5", "HANGUL SYLLABLE PWEOB");
+-   ("/xed/x92/xa6", "HANGUL SYLLABLE PWEOBS");
+-   ("/xed/x92/xa7", "HANGUL SYLLABLE PWEOS");
+-   ("/xed/x92/xa8", "HANGUL SYLLABLE PWEOSS");
+-   ("/xed/x92/xa9", "HANGUL SYLLABLE PWEONG");
+-   ("/xed/x92/xaa", "HANGUL SYLLABLE PWEOJ");
+-   ("/xed/x92/xab", "HANGUL SYLLABLE PWEOC");
+-   ("/xed/x92/xac", "HANGUL SYLLABLE PWEOK");
+-   ("/xed/x92/xad", "HANGUL SYLLABLE PWEOT");
+-   ("/xed/x92/xae", "HANGUL SYLLABLE PWEOP");
+-   ("/xed/x92/xaf", "HANGUL SYLLABLE PWEOH");
+-   ("/xed/x92/xb0", "HANGUL SYLLABLE PWE");
+-   ("/xed/x92/xb1", "HANGUL SYLLABLE PWEG");
+-   ("/xed/x92/xb2", "HANGUL SYLLABLE PWEGG");
+-   ("/xed/x92/xb3", "HANGUL SYLLABLE PWEGS");
+-   ("/xed/x92/xb4", "HANGUL SYLLABLE PWEN");
+-   ("/xed/x92/xb5", "HANGUL SYLLABLE PWENI");
+-   ("/xed/x92/xb6", "HANGUL SYLLABLE PWENH");
+-   ("/xed/x92/xb7", "HANGUL SYLLABLE PWED");
+-   ("/xed/x92/xb8", "HANGUL SYLLABLE PWEL");
+-   ("/xed/x92/xb9", "HANGUL SYLLABLE PWELG");
+-   ("/xed/x92/xba", "HANGUL SYLLABLE PWELM");
+-   ("/xed/x92/xbb", "HANGUL SYLLABLE PWELB");
+-   ("/xed/x92/xbc", "HANGUL SYLLABLE PWELS");
+-   ("/xed/x92/xbd", "HANGUL SYLLABLE PWELT");
+-   ("/xed/x92/xbe", "HANGUL SYLLABLE PWELP");
+-   ("/xed/x92/xbf", "HANGUL SYLLABLE PWELH");
+-   ("/xed/x93/x80", "HANGUL SYLLABLE PWEM");
+-   ("/xed/x93/x81", "HANGUL SYLLABLE PWEB");
+-   ("/xed/x93/x82", "HANGUL SYLLABLE PWEBS");
+-   ("/xed/x93/x83", "HANGUL SYLLABLE PWES");
+-   ("/xed/x93/x84", "HANGUL SYLLABLE PWESS");
+-   ("/xed/x93/x85", "HANGUL SYLLABLE PWENG");
+-   ("/xed/x93/x86", "HANGUL SYLLABLE PWEJ");
+-   ("/xed/x93/x87", "HANGUL SYLLABLE PWEC");
+-   ("/xed/x93/x88", "HANGUL SYLLABLE PWEK");
+-   ("/xed/x93/x89", "HANGUL SYLLABLE PWET");
+-   ("/xed/x93/x8a", "HANGUL SYLLABLE PWEP");
+-   ("/xed/x93/x8b", "HANGUL SYLLABLE PWEH");
+-   ("/xed/x93/x8c", "HANGUL SYLLABLE PWI");
+-   ("/xed/x93/x8d", "HANGUL SYLLABLE PWIG");
+-   ("/xed/x93/x8e", "HANGUL SYLLABLE PWIGG");
+-   ("/xed/x93/x8f", "HANGUL SYLLABLE PWIGS");
+-   ("/xed/x93/x90", "HANGUL SYLLABLE PWIN");
+-   ("/xed/x93/x91", "HANGUL SYLLABLE PWINI");
+-   ("/xed/x93/x92", "HANGUL SYLLABLE PWINH");
+-   ("/xed/x93/x93", "HANGUL SYLLABLE PWID");
+-   ("/xed/x93/x94", "HANGUL SYLLABLE PWIL");
+-   ("/xed/x93/x95", "HANGUL SYLLABLE PWILG");
+-   ("/xed/x93/x96", "HANGUL SYLLABLE PWILM");
+-   ("/xed/x93/x97", "HANGUL SYLLABLE PWILB");
+-   ("/xed/x93/x98", "HANGUL SYLLABLE PWILS");
+-   ("/xed/x93/x99", "HANGUL SYLLABLE PWILT");
+-   ("/xed/x93/x9a", "HANGUL SYLLABLE PWILP");
+-   ("/xed/x93/x9b", "HANGUL SYLLABLE PWILH");
+-   ("/xed/x93/x9c", "HANGUL SYLLABLE PWIM");
+-   ("/xed/x93/x9d", "HANGUL SYLLABLE PWIB");
+-   ("/xed/x93/x9e", "HANGUL SYLLABLE PWIBS");
+-   ("/xed/x93/x9f", "HANGUL SYLLABLE PWIS");
+-   ("/xed/x93/xa0", "HANGUL SYLLABLE PWISS");
+-   ("/xed/x93/xa1", "HANGUL SYLLABLE PWING");
+-   ("/xed/x93/xa2", "HANGUL SYLLABLE PWIJ");
+-   ("/xed/x93/xa3", "HANGUL SYLLABLE PWIC");
+-   ("/xed/x93/xa4", "HANGUL SYLLABLE PWIK");
+-   ("/xed/x93/xa5", "HANGUL SYLLABLE PWIT");
+-   ("/xed/x93/xa6", "HANGUL SYLLABLE PWIP");
+-   ("/xed/x93/xa7", "HANGUL SYLLABLE PWIH");
+-   ("/xed/x93/xa8", "HANGUL SYLLABLE PYU");
+-   ("/xed/x93/xa9", "HANGUL SYLLABLE PYUG");
+-   ("/xed/x93/xaa", "HANGUL SYLLABLE PYUGG");
+-   ("/xed/x93/xab", "HANGUL SYLLABLE PYUGS");
+-   ("/xed/x93/xac", "HANGUL SYLLABLE PYUN");
+-   ("/xed/x93/xad", "HANGUL SYLLABLE PYUNI");
+-   ("/xed/x93/xae", "HANGUL SYLLABLE PYUNH");
+-   ("/xed/x93/xaf", "HANGUL SYLLABLE PYUD");
+-   ("/xed/x93/xb0", "HANGUL SYLLABLE PYUL");
+-   ("/xed/x93/xb1", "HANGUL SYLLABLE PYULG");
+-   ("/xed/x93/xb2", "HANGUL SYLLABLE PYULM");
+-   ("/xed/x93/xb3", "HANGUL SYLLABLE PYULB");
+-   ("/xed/x93/xb4", "HANGUL SYLLABLE PYULS");
+-   ("/xed/x93/xb5", "HANGUL SYLLABLE PYULT");
+-   ("/xed/x93/xb6", "HANGUL SYLLABLE PYULP");
+-   ("/xed/x93/xb7", "HANGUL SYLLABLE PYULH");
+-   ("/xed/x93/xb8", "HANGUL SYLLABLE PYUM");
+-   ("/xed/x93/xb9", "HANGUL SYLLABLE PYUB");
+-   ("/xed/x93/xba", "HANGUL SYLLABLE PYUBS");
+-   ("/xed/x93/xbb", "HANGUL SYLLABLE PYUS");
+-   ("/xed/x93/xbc", "HANGUL SYLLABLE PYUSS");
+-   ("/xed/x93/xbd", "HANGUL SYLLABLE PYUNG");
+-   ("/xed/x93/xbe", "HANGUL SYLLABLE PYUJ");
+-   ("/xed/x93/xbf", "HANGUL SYLLABLE PYUC");
+-   ("/xed/x94/x80", "HANGUL SYLLABLE PYUK");
+-   ("/xed/x94/x81", "HANGUL SYLLABLE PYUT");
+-   ("/xed/x94/x82", "HANGUL SYLLABLE PYUP");
+-   ("/xed/x94/x83", "HANGUL SYLLABLE PYUH");
+-   ("/xed/x94/x84", "HANGUL SYLLABLE PEU");
+-   ("/xed/x94/x85", "HANGUL SYLLABLE PEUG");
+-   ("/xed/x94/x86", "HANGUL SYLLABLE PEUGG");
+-   ("/xed/x94/x87", "HANGUL SYLLABLE PEUGS");
+-   ("/xed/x94/x88", "HANGUL SYLLABLE PEUN");
+-   ("/xed/x94/x89", "HANGUL SYLLABLE PEUNI");
+-   ("/xed/x94/x8a", "HANGUL SYLLABLE PEUNH");
+-   ("/xed/x94/x8b", "HANGUL SYLLABLE PEUD");
+-   ("/xed/x94/x8c", "HANGUL SYLLABLE PEUL");
+-   ("/xed/x94/x8d", "HANGUL SYLLABLE PEULG");
+-   ("/xed/x94/x8e", "HANGUL SYLLABLE PEULM");
+-   ("/xed/x94/x8f", "HANGUL SYLLABLE PEULB");
+-   ("/xed/x94/x90", "HANGUL SYLLABLE PEULS");
+-   ("/xed/x94/x91", "HANGUL SYLLABLE PEULT");
+-   ("/xed/x94/x92", "HANGUL SYLLABLE PEULP");
+-   ("/xed/x94/x93", "HANGUL SYLLABLE PEULH");
+-   ("/xed/x94/x94", "HANGUL SYLLABLE PEUM");
+-   ("/xed/x94/x95", "HANGUL SYLLABLE PEUB");
+-   ("/xed/x94/x96", "HANGUL SYLLABLE PEUBS");
+-   ("/xed/x94/x97", "HANGUL SYLLABLE PEUS");
+-   ("/xed/x94/x98", "HANGUL SYLLABLE PEUSS");
+-   ("/xed/x94/x99", "HANGUL SYLLABLE PEUNG");
+-   ("/xed/x94/x9a", "HANGUL SYLLABLE PEUJ");
+-   ("/xed/x94/x9b", "HANGUL SYLLABLE PEUC");
+-   ("/xed/x94/x9c", "HANGUL SYLLABLE PEUK");
+-   ("/xed/x94/x9d", "HANGUL SYLLABLE PEUT");
+-   ("/xed/x94/x9e", "HANGUL SYLLABLE PEUP");
+-   ("/xed/x94/x9f", "HANGUL SYLLABLE PEUH");
+-   ("/xed/x94/xa0", "HANGUL SYLLABLE PYI");
+-   ("/xed/x94/xa1", "HANGUL SYLLABLE PYIG");
+-   ("/xed/x94/xa2", "HANGUL SYLLABLE PYIGG");
+-   ("/xed/x94/xa3", "HANGUL SYLLABLE PYIGS");
+-   ("/xed/x94/xa4", "HANGUL SYLLABLE PYIN");
+-   ("/xed/x94/xa5", "HANGUL SYLLABLE PYINI");
+-   ("/xed/x94/xa6", "HANGUL SYLLABLE PYINH");
+-   ("/xed/x94/xa7", "HANGUL SYLLABLE PYID");
+-   ("/xed/x94/xa8", "HANGUL SYLLABLE PYIL");
+-   ("/xed/x94/xa9", "HANGUL SYLLABLE PYILG");
+-   ("/xed/x94/xaa", "HANGUL SYLLABLE PYILM");
+-   ("/xed/x94/xab", "HANGUL SYLLABLE PYILB");
+-   ("/xed/x94/xac", "HANGUL SYLLABLE PYILS");
+-   ("/xed/x94/xad", "HANGUL SYLLABLE PYILT");
+-   ("/xed/x94/xae", "HANGUL SYLLABLE PYILP");
+-   ("/xed/x94/xaf", "HANGUL SYLLABLE PYILH");
+-   ("/xed/x94/xb0", "HANGUL SYLLABLE PYIM");
+-   ("/xed/x94/xb1", "HANGUL SYLLABLE PYIB");
+-   ("/xed/x94/xb2", "HANGUL SYLLABLE PYIBS");
+-   ("/xed/x94/xb3", "HANGUL SYLLABLE PYIS");
+-   ("/xed/x94/xb4", "HANGUL SYLLABLE PYISS");
+-   ("/xed/x94/xb5", "HANGUL SYLLABLE PYING");
+-   ("/xed/x94/xb6", "HANGUL SYLLABLE PYIJ");
+-   ("/xed/x94/xb7", "HANGUL SYLLABLE PYIC");
+-   ("/xed/x94/xb8", "HANGUL SYLLABLE PYIK");
+-   ("/xed/x94/xb9", "HANGUL SYLLABLE PYIT");
+-   ("/xed/x94/xba", "HANGUL SYLLABLE PYIP");
+-   ("/xed/x94/xbb", "HANGUL SYLLABLE PYIH");
+-   ("/xed/x94/xbc", "HANGUL SYLLABLE PI");
+-   ("/xed/x94/xbd", "HANGUL SYLLABLE PIG");
+-   ("/xed/x94/xbe", "HANGUL SYLLABLE PIGG");
+-   ("/xed/x94/xbf", "HANGUL SYLLABLE PIGS");
+-   ("/xed/x95/x80", "HANGUL SYLLABLE PIN");
+-   ("/xed/x95/x81", "HANGUL SYLLABLE PINI");
+-   ("/xed/x95/x82", "HANGUL SYLLABLE PINH");
+-   ("/xed/x95/x83", "HANGUL SYLLABLE PID");
+-   ("/xed/x95/x84", "HANGUL SYLLABLE PIL");
+-   ("/xed/x95/x85", "HANGUL SYLLABLE PILG");
+-   ("/xed/x95/x86", "HANGUL SYLLABLE PILM");
+-   ("/xed/x95/x87", "HANGUL SYLLABLE PILB");
+-   ("/xed/x95/x88", "HANGUL SYLLABLE PILS");
+-   ("/xed/x95/x89", "HANGUL SYLLABLE PILT");
+-   ("/xed/x95/x8a", "HANGUL SYLLABLE PILP");
+-   ("/xed/x95/x8b", "HANGUL SYLLABLE PILH");
+-   ("/xed/x95/x8c", "HANGUL SYLLABLE PIM");
+-   ("/xed/x95/x8d", "HANGUL SYLLABLE PIB");
+-   ("/xed/x95/x8e", "HANGUL SYLLABLE PIBS");
+-   ("/xed/x95/x8f", "HANGUL SYLLABLE PIS");
+-   ("/xed/x95/x90", "HANGUL SYLLABLE PISS");
+-   ("/xed/x95/x91", "HANGUL SYLLABLE PING");
+-   ("/xed/x95/x92", "HANGUL SYLLABLE PIJ");
+-   ("/xed/x95/x93", "HANGUL SYLLABLE PIC");
+-   ("/xed/x95/x94", "HANGUL SYLLABLE PIK");
+-   ("/xed/x95/x95", "HANGUL SYLLABLE PIT");
+-   ("/xed/x95/x96", "HANGUL SYLLABLE PIP");
+-   ("/xed/x95/x97", "HANGUL SYLLABLE PIH");
+-   ("/xed/x95/x98", "HANGUL SYLLABLE HA");
+-   ("/xed/x95/x99", "HANGUL SYLLABLE HAG");
+-   ("/xed/x95/x9a", "HANGUL SYLLABLE HAGG");
+-   ("/xed/x95/x9b", "HANGUL SYLLABLE HAGS");
+-   ("/xed/x95/x9c", "HANGUL SYLLABLE HAN");
+-   ("/xed/x95/x9d", "HANGUL SYLLABLE HANI");
+-   ("/xed/x95/x9e", "HANGUL SYLLABLE HANH");
+-   ("/xed/x95/x9f", "HANGUL SYLLABLE HAD");
+-   ("/xed/x95/xa0", "HANGUL SYLLABLE HAL");
+-   ("/xed/x95/xa1", "HANGUL SYLLABLE HALG");
+-   ("/xed/x95/xa2", "HANGUL SYLLABLE HALM");
+-   ("/xed/x95/xa3", "HANGUL SYLLABLE HALB");
+-   ("/xed/x95/xa4", "HANGUL SYLLABLE HALS");
+-   ("/xed/x95/xa5", "HANGUL SYLLABLE HALT");
+-   ("/xed/x95/xa6", "HANGUL SYLLABLE HALP");
+-   ("/xed/x95/xa7", "HANGUL SYLLABLE HALH");
+-   ("/xed/x95/xa8", "HANGUL SYLLABLE HAM");
+-   ("/xed/x95/xa9", "HANGUL SYLLABLE HAB");
+-   ("/xed/x95/xaa", "HANGUL SYLLABLE HABS");
+-   ("/xed/x95/xab", "HANGUL SYLLABLE HAS");
+-   ("/xed/x95/xac", "HANGUL SYLLABLE HASS");
+-   ("/xed/x95/xad", "HANGUL SYLLABLE HANG");
+-   ("/xed/x95/xae", "HANGUL SYLLABLE HAJ");
+-   ("/xed/x95/xaf", "HANGUL SYLLABLE HAC");
+-   ("/xed/x95/xb0", "HANGUL SYLLABLE HAK");
+-   ("/xed/x95/xb1", "HANGUL SYLLABLE HAT");
+-   ("/xed/x95/xb2", "HANGUL SYLLABLE HAP");
+-   ("/xed/x95/xb3", "HANGUL SYLLABLE HAH");
+-   ("/xed/x95/xb4", "HANGUL SYLLABLE HAE");
+-   ("/xed/x95/xb5", "HANGUL SYLLABLE HAEG");
+-   ("/xed/x95/xb6", "HANGUL SYLLABLE HAEGG");
+-   ("/xed/x95/xb7", "HANGUL SYLLABLE HAEGS");
+-   ("/xed/x95/xb8", "HANGUL SYLLABLE HAEN");
+-   ("/xed/x95/xb9", "HANGUL SYLLABLE HAENI");
+-   ("/xed/x95/xba", "HANGUL SYLLABLE HAENH");
+-   ("/xed/x95/xbb", "HANGUL SYLLABLE HAED");
+-   ("/xed/x95/xbc", "HANGUL SYLLABLE HAEL");
+-   ("/xed/x95/xbd", "HANGUL SYLLABLE HAELG");
+-   ("/xed/x95/xbe", "HANGUL SYLLABLE HAELM");
+-   ("/xed/x95/xbf", "HANGUL SYLLABLE HAELB");
+-   ("/xed/x96/x80", "HANGUL SYLLABLE HAELS");
+-   ("/xed/x96/x81", "HANGUL SYLLABLE HAELT");
+-   ("/xed/x96/x82", "HANGUL SYLLABLE HAELP");
+-   ("/xed/x96/x83", "HANGUL SYLLABLE HAELH");
+-   ("/xed/x96/x84", "HANGUL SYLLABLE HAEM");
+-   ("/xed/x96/x85", "HANGUL SYLLABLE HAEB");
+-   ("/xed/x96/x86", "HANGUL SYLLABLE HAEBS");
+-   ("/xed/x96/x87", "HANGUL SYLLABLE HAES");
+-   ("/xed/x96/x88", "HANGUL SYLLABLE HAESS");
+-   ("/xed/x96/x89", "HANGUL SYLLABLE HAENG");
+-   ("/xed/x96/x8a", "HANGUL SYLLABLE HAEJ");
+-   ("/xed/x96/x8b", "HANGUL SYLLABLE HAEC");
+-   ("/xed/x96/x8c", "HANGUL SYLLABLE HAEK");
+-   ("/xed/x96/x8d", "HANGUL SYLLABLE HAET");
+-   ("/xed/x96/x8e", "HANGUL SYLLABLE HAEP");
+-   ("/xed/x96/x8f", "HANGUL SYLLABLE HAEH");
+-   ("/xed/x96/x90", "HANGUL SYLLABLE HYA");
+-   ("/xed/x96/x91", "HANGUL SYLLABLE HYAG");
+-   ("/xed/x96/x92", "HANGUL SYLLABLE HYAGG");
+-   ("/xed/x96/x93", "HANGUL SYLLABLE HYAGS");
+-   ("/xed/x96/x94", "HANGUL SYLLABLE HYAN");
+-   ("/xed/x96/x95", "HANGUL SYLLABLE HYANI");
+-   ("/xed/x96/x96", "HANGUL SYLLABLE HYANH");
+-   ("/xed/x96/x97", "HANGUL SYLLABLE HYAD");
+-   ("/xed/x96/x98", "HANGUL SYLLABLE HYAL");
+-   ("/xed/x96/x99", "HANGUL SYLLABLE HYALG");
+-   ("/xed/x96/x9a", "HANGUL SYLLABLE HYALM");
+-   ("/xed/x96/x9b", "HANGUL SYLLABLE HYALB");
+-   ("/xed/x96/x9c", "HANGUL SYLLABLE HYALS");
+-   ("/xed/x96/x9d", "HANGUL SYLLABLE HYALT");
+-   ("/xed/x96/x9e", "HANGUL SYLLABLE HYALP");
+-   ("/xed/x96/x9f", "HANGUL SYLLABLE HYALH");
+-   ("/xed/x96/xa0", "HANGUL SYLLABLE HYAM");
+-   ("/xed/x96/xa1", "HANGUL SYLLABLE HYAB");
+-   ("/xed/x96/xa2", "HANGUL SYLLABLE HYABS");
+-   ("/xed/x96/xa3", "HANGUL SYLLABLE HYAS");
+-   ("/xed/x96/xa4", "HANGUL SYLLABLE HYASS");
+-   ("/xed/x96/xa5", "HANGUL SYLLABLE HYANG");
+-   ("/xed/x96/xa6", "HANGUL SYLLABLE HYAJ");
+-   ("/xed/x96/xa7", "HANGUL SYLLABLE HYAC");
+-   ("/xed/x96/xa8", "HANGUL SYLLABLE HYAK");
+-   ("/xed/x96/xa9", "HANGUL SYLLABLE HYAT");
+-   ("/xed/x96/xaa", "HANGUL SYLLABLE HYAP");
+-   ("/xed/x96/xab", "HANGUL SYLLABLE HYAH");
+-   ("/xed/x96/xac", "HANGUL SYLLABLE HYAE");
+-   ("/xed/x96/xad", "HANGUL SYLLABLE HYAEG");
+-   ("/xed/x96/xae", "HANGUL SYLLABLE HYAEGG");
+-   ("/xed/x96/xaf", "HANGUL SYLLABLE HYAEGS");
+-   ("/xed/x96/xb0", "HANGUL SYLLABLE HYAEN");
+-   ("/xed/x96/xb1", "HANGUL SYLLABLE HYAENI");
+-   ("/xed/x96/xb2", "HANGUL SYLLABLE HYAENH");
+-   ("/xed/x96/xb3", "HANGUL SYLLABLE HYAED");
+-   ("/xed/x96/xb4", "HANGUL SYLLABLE HYAEL");
+-   ("/xed/x96/xb5", "HANGUL SYLLABLE HYAELG");
+-   ("/xed/x96/xb6", "HANGUL SYLLABLE HYAELM");
+-   ("/xed/x96/xb7", "HANGUL SYLLABLE HYAELB");
+-   ("/xed/x96/xb8", "HANGUL SYLLABLE HYAELS");
+-   ("/xed/x96/xb9", "HANGUL SYLLABLE HYAELT");
+-   ("/xed/x96/xba", "HANGUL SYLLABLE HYAELP");
+-   ("/xed/x96/xbb", "HANGUL SYLLABLE HYAELH");
+-   ("/xed/x96/xbc", "HANGUL SYLLABLE HYAEM");
+-   ("/xed/x96/xbd", "HANGUL SYLLABLE HYAEB");
+-   ("/xed/x96/xbe", "HANGUL SYLLABLE HYAEBS");
+-   ("/xed/x96/xbf", "HANGUL SYLLABLE HYAES");
+-   ("/xed/x97/x80", "HANGUL SYLLABLE HYAESS");
+-   ("/xed/x97/x81", "HANGUL SYLLABLE HYAENG");
+-   ("/xed/x97/x82", "HANGUL SYLLABLE HYAEJ");
+-   ("/xed/x97/x83", "HANGUL SYLLABLE HYAEC");
+-   ("/xed/x97/x84", "HANGUL SYLLABLE HYAEK");
+-   ("/xed/x97/x85", "HANGUL SYLLABLE HYAET");
+-   ("/xed/x97/x86", "HANGUL SYLLABLE HYAEP");
+-   ("/xed/x97/x87", "HANGUL SYLLABLE HYAEH");
+-   ("/xed/x97/x88", "HANGUL SYLLABLE HEO");
+-   ("/xed/x97/x89", "HANGUL SYLLABLE HEOG");
+-   ("/xed/x97/x8a", "HANGUL SYLLABLE HEOGG");
+-   ("/xed/x97/x8b", "HANGUL SYLLABLE HEOGS");
+-   ("/xed/x97/x8c", "HANGUL SYLLABLE HEON");
+-   ("/xed/x97/x8d", "HANGUL SYLLABLE HEONI");
+-   ("/xed/x97/x8e", "HANGUL SYLLABLE HEONH");
+-   ("/xed/x97/x8f", "HANGUL SYLLABLE HEOD");
+-   ("/xed/x97/x90", "HANGUL SYLLABLE HEOL");
+-   ("/xed/x97/x91", "HANGUL SYLLABLE HEOLG");
+-   ("/xed/x97/x92", "HANGUL SYLLABLE HEOLM");
+-   ("/xed/x97/x93", "HANGUL SYLLABLE HEOLB");
+-   ("/xed/x97/x94", "HANGUL SYLLABLE HEOLS");
+-   ("/xed/x97/x95", "HANGUL SYLLABLE HEOLT");
+-   ("/xed/x97/x96", "HANGUL SYLLABLE HEOLP");
+-   ("/xed/x97/x97", "HANGUL SYLLABLE HEOLH");
+-   ("/xed/x97/x98", "HANGUL SYLLABLE HEOM");
+-   ("/xed/x97/x99", "HANGUL SYLLABLE HEOB");
+-   ("/xed/x97/x9a", "HANGUL SYLLABLE HEOBS");
+-   ("/xed/x97/x9b", "HANGUL SYLLABLE HEOS");
+-   ("/xed/x97/x9c", "HANGUL SYLLABLE HEOSS");
+-   ("/xed/x97/x9d", "HANGUL SYLLABLE HEONG");
+-   ("/xed/x97/x9e", "HANGUL SYLLABLE HEOJ");
+-   ("/xed/x97/x9f", "HANGUL SYLLABLE HEOC");
+-   ("/xed/x97/xa0", "HANGUL SYLLABLE HEOK");
+-   ("/xed/x97/xa1", "HANGUL SYLLABLE HEOT");
+-   ("/xed/x97/xa2", "HANGUL SYLLABLE HEOP");
+-   ("/xed/x97/xa3", "HANGUL SYLLABLE HEOH");
+-   ("/xed/x97/xa4", "HANGUL SYLLABLE HE");
+-   ("/xed/x97/xa5", "HANGUL SYLLABLE HEG");
+-   ("/xed/x97/xa6", "HANGUL SYLLABLE HEGG");
+-   ("/xed/x97/xa7", "HANGUL SYLLABLE HEGS");
+-   ("/xed/x97/xa8", "HANGUL SYLLABLE HEN");
+-   ("/xed/x97/xa9", "HANGUL SYLLABLE HENI");
+-   ("/xed/x97/xaa", "HANGUL SYLLABLE HENH");
+-   ("/xed/x97/xab", "HANGUL SYLLABLE HED");
+-   ("/xed/x97/xac", "HANGUL SYLLABLE HEL");
+-   ("/xed/x97/xad", "HANGUL SYLLABLE HELG");
+-   ("/xed/x97/xae", "HANGUL SYLLABLE HELM");
+-   ("/xed/x97/xaf", "HANGUL SYLLABLE HELB");
+-   ("/xed/x97/xb0", "HANGUL SYLLABLE HELS");
+-   ("/xed/x97/xb1", "HANGUL SYLLABLE HELT");
+-   ("/xed/x97/xb2", "HANGUL SYLLABLE HELP");
+-   ("/xed/x97/xb3", "HANGUL SYLLABLE HELH");
+-   ("/xed/x97/xb4", "HANGUL SYLLABLE HEM");
+-   ("/xed/x97/xb5", "HANGUL SYLLABLE HEB");
+-   ("/xed/x97/xb6", "HANGUL SYLLABLE HEBS");
+-   ("/xed/x97/xb7", "HANGUL SYLLABLE HES");
+-   ("/xed/x97/xb8", "HANGUL SYLLABLE HESS");
+-   ("/xed/x97/xb9", "HANGUL SYLLABLE HENG");
+-   ("/xed/x97/xba", "HANGUL SYLLABLE HEJ");
+-   ("/xed/x97/xbb", "HANGUL SYLLABLE HEC");
+-   ("/xed/x97/xbc", "HANGUL SYLLABLE HEK");
+-   ("/xed/x97/xbd", "HANGUL SYLLABLE HET");
+-   ("/xed/x97/xbe", "HANGUL SYLLABLE HEP");
+-   ("/xed/x97/xbf", "HANGUL SYLLABLE HEH");
+-   ("/xed/x98/x80", "HANGUL SYLLABLE HYEO");
+-   ("/xed/x98/x81", "HANGUL SYLLABLE HYEOG");
+-   ("/xed/x98/x82", "HANGUL SYLLABLE HYEOGG");
+-   ("/xed/x98/x83", "HANGUL SYLLABLE HYEOGS");
+-   ("/xed/x98/x84", "HANGUL SYLLABLE HYEON");
+-   ("/xed/x98/x85", "HANGUL SYLLABLE HYEONI");
+-   ("/xed/x98/x86", "HANGUL SYLLABLE HYEONH");
+-   ("/xed/x98/x87", "HANGUL SYLLABLE HYEOD");
+-   ("/xed/x98/x88", "HANGUL SYLLABLE HYEOL");
+-   ("/xed/x98/x89", "HANGUL SYLLABLE HYEOLG");
+-   ("/xed/x98/x8a", "HANGUL SYLLABLE HYEOLM");
+-   ("/xed/x98/x8b", "HANGUL SYLLABLE HYEOLB");
+-   ("/xed/x98/x8c", "HANGUL SYLLABLE HYEOLS");
+-   ("/xed/x98/x8d", "HANGUL SYLLABLE HYEOLT");
+-   ("/xed/x98/x8e", "HANGUL SYLLABLE HYEOLP");
+-   ("/xed/x98/x8f", "HANGUL SYLLABLE HYEOLH");
+-   ("/xed/x98/x90", "HANGUL SYLLABLE HYEOM");
+-   ("/xed/x98/x91", "HANGUL SYLLABLE HYEOB");
+-   ("/xed/x98/x92", "HANGUL SYLLABLE HYEOBS");
+-   ("/xed/x98/x93", "HANGUL SYLLABLE HYEOS");
+-   ("/xed/x98/x94", "HANGUL SYLLABLE HYEOSS");
+-   ("/xed/x98/x95", "HANGUL SYLLABLE HYEONG");
+-   ("/xed/x98/x96", "HANGUL SYLLABLE HYEOJ");
+-   ("/xed/x98/x97", "HANGUL SYLLABLE HYEOC");
+-   ("/xed/x98/x98", "HANGUL SYLLABLE HYEOK");
+-   ("/xed/x98/x99", "HANGUL SYLLABLE HYEOT");
+-   ("/xed/x98/x9a", "HANGUL SYLLABLE HYEOP");
+-   ("/xed/x98/x9b", "HANGUL SYLLABLE HYEOH");
+-   ("/xed/x98/x9c", "HANGUL SYLLABLE HYE");
+-   ("/xed/x98/x9d", "HANGUL SYLLABLE HYEG");
+-   ("/xed/x98/x9e", "HANGUL SYLLABLE HYEGG");
+-   ("/xed/x98/x9f", "HANGUL SYLLABLE HYEGS");
+-   ("/xed/x98/xa0", "HANGUL SYLLABLE HYEN");
+-   ("/xed/x98/xa1", "HANGUL SYLLABLE HYENI");
+-   ("/xed/x98/xa2", "HANGUL SYLLABLE HYENH");
+-   ("/xed/x98/xa3", "HANGUL SYLLABLE HYED");
+-   ("/xed/x98/xa4", "HANGUL SYLLABLE HYEL");
+-   ("/xed/x98/xa5", "HANGUL SYLLABLE HYELG");
+-   ("/xed/x98/xa6", "HANGUL SYLLABLE HYELM");
+-   ("/xed/x98/xa7", "HANGUL SYLLABLE HYELB");
+-   ("/xed/x98/xa8", "HANGUL SYLLABLE HYELS");
+-   ("/xed/x98/xa9", "HANGUL SYLLABLE HYELT");
+-   ("/xed/x98/xaa", "HANGUL SYLLABLE HYELP");
+-   ("/xed/x98/xab", "HANGUL SYLLABLE HYELH");
+-   ("/xed/x98/xac", "HANGUL SYLLABLE HYEM");
+-   ("/xed/x98/xad", "HANGUL SYLLABLE HYEB");
+-   ("/xed/x98/xae", "HANGUL SYLLABLE HYEBS");
+-   ("/xed/x98/xaf", "HANGUL SYLLABLE HYES");
+-   ("/xed/x98/xb0", "HANGUL SYLLABLE HYESS");
+-   ("/xed/x98/xb1", "HANGUL SYLLABLE HYENG");
+-   ("/xed/x98/xb2", "HANGUL SYLLABLE HYEJ");
+-   ("/xed/x98/xb3", "HANGUL SYLLABLE HYEC");
+-   ("/xed/x98/xb4", "HANGUL SYLLABLE HYEK");
+-   ("/xed/x98/xb5", "HANGUL SYLLABLE HYET");
+-   ("/xed/x98/xb6", "HANGUL SYLLABLE HYEP");
+-   ("/xed/x98/xb7", "HANGUL SYLLABLE HYEH");
+-   ("/xed/x98/xb8", "HANGUL SYLLABLE HO");
+-   ("/xed/x98/xb9", "HANGUL SYLLABLE HOG");
+-   ("/xed/x98/xba", "HANGUL SYLLABLE HOGG");
+-   ("/xed/x98/xbb", "HANGUL SYLLABLE HOGS");
+-   ("/xed/x98/xbc", "HANGUL SYLLABLE HON");
+-   ("/xed/x98/xbd", "HANGUL SYLLABLE HONI");
+-   ("/xed/x98/xbe", "HANGUL SYLLABLE HONH");
+-   ("/xed/x98/xbf", "HANGUL SYLLABLE HOD");
+-   ("/xed/x99/x80", "HANGUL SYLLABLE HOL");
+-   ("/xed/x99/x81", "HANGUL SYLLABLE HOLG");
+-   ("/xed/x99/x82", "HANGUL SYLLABLE HOLM");
+-   ("/xed/x99/x83", "HANGUL SYLLABLE HOLB");
+-   ("/xed/x99/x84", "HANGUL SYLLABLE HOLS");
+-   ("/xed/x99/x85", "HANGUL SYLLABLE HOLT");
+-   ("/xed/x99/x86", "HANGUL SYLLABLE HOLP");
+-   ("/xed/x99/x87", "HANGUL SYLLABLE HOLH");
+-   ("/xed/x99/x88", "HANGUL SYLLABLE HOM");
+-   ("/xed/x99/x89", "HANGUL SYLLABLE HOB");
+-   ("/xed/x99/x8a", "HANGUL SYLLABLE HOBS");
+-   ("/xed/x99/x8b", "HANGUL SYLLABLE HOS");
+-   ("/xed/x99/x8c", "HANGUL SYLLABLE HOSS");
+-   ("/xed/x99/x8d", "HANGUL SYLLABLE HONG");
+-   ("/xed/x99/x8e", "HANGUL SYLLABLE HOJ");
+-   ("/xed/x99/x8f", "HANGUL SYLLABLE HOC");
+-   ("/xed/x99/x90", "HANGUL SYLLABLE HOK");
+-   ("/xed/x99/x91", "HANGUL SYLLABLE HOT");
+-   ("/xed/x99/x92", "HANGUL SYLLABLE HOP");
+-   ("/xed/x99/x93", "HANGUL SYLLABLE HOH");
+-   ("/xed/x99/x94", "HANGUL SYLLABLE HWA");
+-   ("/xed/x99/x95", "HANGUL SYLLABLE HWAG");
+-   ("/xed/x99/x96", "HANGUL SYLLABLE HWAGG");
+-   ("/xed/x99/x97", "HANGUL SYLLABLE HWAGS");
+-   ("/xed/x99/x98", "HANGUL SYLLABLE HWAN");
+-   ("/xed/x99/x99", "HANGUL SYLLABLE HWANI");
+-   ("/xed/x99/x9a", "HANGUL SYLLABLE HWANH");
+-   ("/xed/x99/x9b", "HANGUL SYLLABLE HWAD");
+-   ("/xed/x99/x9c", "HANGUL SYLLABLE HWAL");
+-   ("/xed/x99/x9d", "HANGUL SYLLABLE HWALG");
+-   ("/xed/x99/x9e", "HANGUL SYLLABLE HWALM");
+-   ("/xed/x99/x9f", "HANGUL SYLLABLE HWALB");
+-   ("/xed/x99/xa0", "HANGUL SYLLABLE HWALS");
+-   ("/xed/x99/xa1", "HANGUL SYLLABLE HWALT");
+-   ("/xed/x99/xa2", "HANGUL SYLLABLE HWALP");
+-   ("/xed/x99/xa3", "HANGUL SYLLABLE HWALH");
+-   ("/xed/x99/xa4", "HANGUL SYLLABLE HWAM");
+-   ("/xed/x99/xa5", "HANGUL SYLLABLE HWAB");
+-   ("/xed/x99/xa6", "HANGUL SYLLABLE HWABS");
+-   ("/xed/x99/xa7", "HANGUL SYLLABLE HWAS");
+-   ("/xed/x99/xa8", "HANGUL SYLLABLE HWASS");
+-   ("/xed/x99/xa9", "HANGUL SYLLABLE HWANG");
+-   ("/xed/x99/xaa", "HANGUL SYLLABLE HWAJ");
+-   ("/xed/x99/xab", "HANGUL SYLLABLE HWAC");
+-   ("/xed/x99/xac", "HANGUL SYLLABLE HWAK");
+-   ("/xed/x99/xad", "HANGUL SYLLABLE HWAT");
+-   ("/xed/x99/xae", "HANGUL SYLLABLE HWAP");
+-   ("/xed/x99/xaf", "HANGUL SYLLABLE HWAH");
+-   ("/xed/x99/xb0", "HANGUL SYLLABLE HWAE");
+-   ("/xed/x99/xb1", "HANGUL SYLLABLE HWAEG");
+-   ("/xed/x99/xb2", "HANGUL SYLLABLE HWAEGG");
+-   ("/xed/x99/xb3", "HANGUL SYLLABLE HWAEGS");
+-   ("/xed/x99/xb4", "HANGUL SYLLABLE HWAEN");
+-   ("/xed/x99/xb5", "HANGUL SYLLABLE HWAENI");
+-   ("/xed/x99/xb6", "HANGUL SYLLABLE HWAENH");
+-   ("/xed/x99/xb7", "HANGUL SYLLABLE HWAED");
+-   ("/xed/x99/xb8", "HANGUL SYLLABLE HWAEL");
+-   ("/xed/x99/xb9", "HANGUL SYLLABLE HWAELG");
+-   ("/xed/x99/xba", "HANGUL SYLLABLE HWAELM");
+-   ("/xed/x99/xbb", "HANGUL SYLLABLE HWAELB");
+-   ("/xed/x99/xbc", "HANGUL SYLLABLE HWAELS");
+-   ("/xed/x99/xbd", "HANGUL SYLLABLE HWAELT");
+-   ("/xed/x99/xbe", "HANGUL SYLLABLE HWAELP");
+-   ("/xed/x99/xbf", "HANGUL SYLLABLE HWAELH");
+-   ("/xed/x9a/x80", "HANGUL SYLLABLE HWAEM");
+-   ("/xed/x9a/x81", "HANGUL SYLLABLE HWAEB");
+-   ("/xed/x9a/x82", "HANGUL SYLLABLE HWAEBS");
+-   ("/xed/x9a/x83", "HANGUL SYLLABLE HWAES");
+-   ("/xed/x9a/x84", "HANGUL SYLLABLE HWAESS");
+-   ("/xed/x9a/x85", "HANGUL SYLLABLE HWAENG");
+-   ("/xed/x9a/x86", "HANGUL SYLLABLE HWAEJ");
+-   ("/xed/x9a/x87", "HANGUL SYLLABLE HWAEC");
+-   ("/xed/x9a/x88", "HANGUL SYLLABLE HWAEK");
+-   ("/xed/x9a/x89", "HANGUL SYLLABLE HWAET");
+-   ("/xed/x9a/x8a", "HANGUL SYLLABLE HWAEP");
+-   ("/xed/x9a/x8b", "HANGUL SYLLABLE HWAEH");
+-   ("/xed/x9a/x8c", "HANGUL SYLLABLE HOE");
+-   ("/xed/x9a/x8d", "HANGUL SYLLABLE HOEG");
+-   ("/xed/x9a/x8e", "HANGUL SYLLABLE HOEGG");
+-   ("/xed/x9a/x8f", "HANGUL SYLLABLE HOEGS");
+-   ("/xed/x9a/x90", "HANGUL SYLLABLE HOEN");
+-   ("/xed/x9a/x91", "HANGUL SYLLABLE HOENI");
+-   ("/xed/x9a/x92", "HANGUL SYLLABLE HOENH");
+-   ("/xed/x9a/x93", "HANGUL SYLLABLE HOED");
+-   ("/xed/x9a/x94", "HANGUL SYLLABLE HOEL");
+-   ("/xed/x9a/x95", "HANGUL SYLLABLE HOELG");
+-   ("/xed/x9a/x96", "HANGUL SYLLABLE HOELM");
+-   ("/xed/x9a/x97", "HANGUL SYLLABLE HOELB");
+-   ("/xed/x9a/x98", "HANGUL SYLLABLE HOELS");
+-   ("/xed/x9a/x99", "HANGUL SYLLABLE HOELT");
+-   ("/xed/x9a/x9a", "HANGUL SYLLABLE HOELP");
+-   ("/xed/x9a/x9b", "HANGUL SYLLABLE HOELH");
+-   ("/xed/x9a/x9c", "HANGUL SYLLABLE HOEM");
+-   ("/xed/x9a/x9d", "HANGUL SYLLABLE HOEB");
+-   ("/xed/x9a/x9e", "HANGUL SYLLABLE HOEBS");
+-   ("/xed/x9a/x9f", "HANGUL SYLLABLE HOES");
+-   ("/xed/x9a/xa0", "HANGUL SYLLABLE HOESS");
+-   ("/xed/x9a/xa1", "HANGUL SYLLABLE HOENG");
+-   ("/xed/x9a/xa2", "HANGUL SYLLABLE HOEJ");
+-   ("/xed/x9a/xa3", "HANGUL SYLLABLE HOEC");
+-   ("/xed/x9a/xa4", "HANGUL SYLLABLE HOEK");
+-   ("/xed/x9a/xa5", "HANGUL SYLLABLE HOET");
+-   ("/xed/x9a/xa6", "HANGUL SYLLABLE HOEP");
+-   ("/xed/x9a/xa7", "HANGUL SYLLABLE HOEH");
+-   ("/xed/x9a/xa8", "HANGUL SYLLABLE HYO");
+-   ("/xed/x9a/xa9", "HANGUL SYLLABLE HYOG");
+-   ("/xed/x9a/xaa", "HANGUL SYLLABLE HYOGG");
+-   ("/xed/x9a/xab", "HANGUL SYLLABLE HYOGS");
+-   ("/xed/x9a/xac", "HANGUL SYLLABLE HYON");
+-   ("/xed/x9a/xad", "HANGUL SYLLABLE HYONI");
+-   ("/xed/x9a/xae", "HANGUL SYLLABLE HYONH");
+-   ("/xed/x9a/xaf", "HANGUL SYLLABLE HYOD");
+-   ("/xed/x9a/xb0", "HANGUL SYLLABLE HYOL");
+-   ("/xed/x9a/xb1", "HANGUL SYLLABLE HYOLG");
+-   ("/xed/x9a/xb2", "HANGUL SYLLABLE HYOLM");
+-   ("/xed/x9a/xb3", "HANGUL SYLLABLE HYOLB");
+-   ("/xed/x9a/xb4", "HANGUL SYLLABLE HYOLS");
+-   ("/xed/x9a/xb5", "HANGUL SYLLABLE HYOLT");
+-   ("/xed/x9a/xb6", "HANGUL SYLLABLE HYOLP");
+-   ("/xed/x9a/xb7", "HANGUL SYLLABLE HYOLH");
+-   ("/xed/x9a/xb8", "HANGUL SYLLABLE HYOM");
+-   ("/xed/x9a/xb9", "HANGUL SYLLABLE HYOB");
+-   ("/xed/x9a/xba", "HANGUL SYLLABLE HYOBS");
+-   ("/xed/x9a/xbb", "HANGUL SYLLABLE HYOS");
+-   ("/xed/x9a/xbc", "HANGUL SYLLABLE HYOSS");
+-   ("/xed/x9a/xbd", "HANGUL SYLLABLE HYONG");
+-   ("/xed/x9a/xbe", "HANGUL SYLLABLE HYOJ");
+-   ("/xed/x9a/xbf", "HANGUL SYLLABLE HYOC");
+-   ("/xed/x9b/x80", "HANGUL SYLLABLE HYOK");
+-   ("/xed/x9b/x81", "HANGUL SYLLABLE HYOT");
+-   ("/xed/x9b/x82", "HANGUL SYLLABLE HYOP");
+-   ("/xed/x9b/x83", "HANGUL SYLLABLE HYOH");
+-   ("/xed/x9b/x84", "HANGUL SYLLABLE HU");
+-   ("/xed/x9b/x85", "HANGUL SYLLABLE HUG");
+-   ("/xed/x9b/x86", "HANGUL SYLLABLE HUGG");
+-   ("/xed/x9b/x87", "HANGUL SYLLABLE HUGS");
+-   ("/xed/x9b/x88", "HANGUL SYLLABLE HUN");
+-   ("/xed/x9b/x89", "HANGUL SYLLABLE HUNI");
+-   ("/xed/x9b/x8a", "HANGUL SYLLABLE HUNH");
+-   ("/xed/x9b/x8b", "HANGUL SYLLABLE HUD");
+-   ("/xed/x9b/x8c", "HANGUL SYLLABLE HUL");
+-   ("/xed/x9b/x8d", "HANGUL SYLLABLE HULG");
+-   ("/xed/x9b/x8e", "HANGUL SYLLABLE HULM");
+-   ("/xed/x9b/x8f", "HANGUL SYLLABLE HULB");
+-   ("/xed/x9b/x90", "HANGUL SYLLABLE HULS");
+-   ("/xed/x9b/x91", "HANGUL SYLLABLE HULT");
+-   ("/xed/x9b/x92", "HANGUL SYLLABLE HULP");
+-   ("/xed/x9b/x93", "HANGUL SYLLABLE HULH");
+-   ("/xed/x9b/x94", "HANGUL SYLLABLE HUM");
+-   ("/xed/x9b/x95", "HANGUL SYLLABLE HUB");
+-   ("/xed/x9b/x96", "HANGUL SYLLABLE HUBS");
+-   ("/xed/x9b/x97", "HANGUL SYLLABLE HUS");
+-   ("/xed/x9b/x98", "HANGUL SYLLABLE HUSS");
+-   ("/xed/x9b/x99", "HANGUL SYLLABLE HUNG");
+-   ("/xed/x9b/x9a", "HANGUL SYLLABLE HUJ");
+-   ("/xed/x9b/x9b", "HANGUL SYLLABLE HUC");
+-   ("/xed/x9b/x9c", "HANGUL SYLLABLE HUK");
+-   ("/xed/x9b/x9d", "HANGUL SYLLABLE HUT");
+-   ("/xed/x9b/x9e", "HANGUL SYLLABLE HUP");
+-   ("/xed/x9b/x9f", "HANGUL SYLLABLE HUH");
+-   ("/xed/x9b/xa0", "HANGUL SYLLABLE HWEO");
+-   ("/xed/x9b/xa1", "HANGUL SYLLABLE HWEOG");
+-   ("/xed/x9b/xa2", "HANGUL SYLLABLE HWEOGG");
+-   ("/xed/x9b/xa3", "HANGUL SYLLABLE HWEOGS");
+-   ("/xed/x9b/xa4", "HANGUL SYLLABLE HWEON");
+-   ("/xed/x9b/xa5", "HANGUL SYLLABLE HWEONI");
+-   ("/xed/x9b/xa6", "HANGUL SYLLABLE HWEONH");
+-   ("/xed/x9b/xa7", "HANGUL SYLLABLE HWEOD");
+-   ("/xed/x9b/xa8", "HANGUL SYLLABLE HWEOL");
+-   ("/xed/x9b/xa9", "HANGUL SYLLABLE HWEOLG");
+-   ("/xed/x9b/xaa", "HANGUL SYLLABLE HWEOLM");
+-   ("/xed/x9b/xab", "HANGUL SYLLABLE HWEOLB");
+-   ("/xed/x9b/xac", "HANGUL SYLLABLE HWEOLS");
+-   ("/xed/x9b/xad", "HANGUL SYLLABLE HWEOLT");
+-   ("/xed/x9b/xae", "HANGUL SYLLABLE HWEOLP");
+-   ("/xed/x9b/xaf", "HANGUL SYLLABLE HWEOLH");
+-   ("/xed/x9b/xb0", "HANGUL SYLLABLE HWEOM");
+-   ("/xed/x9b/xb1", "HANGUL SYLLABLE HWEOB");
+-   ("/xed/x9b/xb2", "HANGUL SYLLABLE HWEOBS");
+-   ("/xed/x9b/xb3", "HANGUL SYLLABLE HWEOS");
+-   ("/xed/x9b/xb4", "HANGUL SYLLABLE HWEOSS");
+-   ("/xed/x9b/xb5", "HANGUL SYLLABLE HWEONG");
+-   ("/xed/x9b/xb6", "HANGUL SYLLABLE HWEOJ");
+-   ("/xed/x9b/xb7", "HANGUL SYLLABLE HWEOC");
+-   ("/xed/x9b/xb8", "HANGUL SYLLABLE HWEOK");
+-   ("/xed/x9b/xb9", "HANGUL SYLLABLE HWEOT");
+-   ("/xed/x9b/xba", "HANGUL SYLLABLE HWEOP");
+-   ("/xed/x9b/xbb", "HANGUL SYLLABLE HWEOH");
+-   ("/xed/x9b/xbc", "HANGUL SYLLABLE HWE");
+-   ("/xed/x9b/xbd", "HANGUL SYLLABLE HWEG");
+-   ("/xed/x9b/xbe", "HANGUL SYLLABLE HWEGG");
+-   ("/xed/x9b/xbf", "HANGUL SYLLABLE HWEGS");
+-   ("/xed/x9c/x80", "HANGUL SYLLABLE HWEN");
+-   ("/xed/x9c/x81", "HANGUL SYLLABLE HWENI");
+-   ("/xed/x9c/x82", "HANGUL SYLLABLE HWENH");
+-   ("/xed/x9c/x83", "HANGUL SYLLABLE HWED");
+-   ("/xed/x9c/x84", "HANGUL SYLLABLE HWEL");
+-   ("/xed/x9c/x85", "HANGUL SYLLABLE HWELG");
+-   ("/xed/x9c/x86", "HANGUL SYLLABLE HWELM");
+-   ("/xed/x9c/x87", "HANGUL SYLLABLE HWELB");
+-   ("/xed/x9c/x88", "HANGUL SYLLABLE HWELS");
+-   ("/xed/x9c/x89", "HANGUL SYLLABLE HWELT");
+-   ("/xed/x9c/x8a", "HANGUL SYLLABLE HWELP");
+-   ("/xed/x9c/x8b", "HANGUL SYLLABLE HWELH");
+-   ("/xed/x9c/x8c", "HANGUL SYLLABLE HWEM");
+-   ("/xed/x9c/x8d", "HANGUL SYLLABLE HWEB");
+-   ("/xed/x9c/x8e", "HANGUL SYLLABLE HWEBS");
+-   ("/xed/x9c/x8f", "HANGUL SYLLABLE HWES");
+-   ("/xed/x9c/x90", "HANGUL SYLLABLE HWESS");
+-   ("/xed/x9c/x91", "HANGUL SYLLABLE HWENG");
+-   ("/xed/x9c/x92", "HANGUL SYLLABLE HWEJ");
+-   ("/xed/x9c/x93", "HANGUL SYLLABLE HWEC");
+-   ("/xed/x9c/x94", "HANGUL SYLLABLE HWEK");
+-   ("/xed/x9c/x95", "HANGUL SYLLABLE HWET");
+-   ("/xed/x9c/x96", "HANGUL SYLLABLE HWEP");
+-   ("/xed/x9c/x97", "HANGUL SYLLABLE HWEH");
+-   ("/xed/x9c/x98", "HANGUL SYLLABLE HWI");
+-   ("/xed/x9c/x99", "HANGUL SYLLABLE HWIG");
+-   ("/xed/x9c/x9a", "HANGUL SYLLABLE HWIGG");
+-   ("/xed/x9c/x9b", "HANGUL SYLLABLE HWIGS");
+-   ("/xed/x9c/x9c", "HANGUL SYLLABLE HWIN");
+-   ("/xed/x9c/x9d", "HANGUL SYLLABLE HWINI");
+-   ("/xed/x9c/x9e", "HANGUL SYLLABLE HWINH");
+-   ("/xed/x9c/x9f", "HANGUL SYLLABLE HWID");
+-   ("/xed/x9c/xa0", "HANGUL SYLLABLE HWIL");
+-   ("/xed/x9c/xa1", "HANGUL SYLLABLE HWILG");
+-   ("/xed/x9c/xa2", "HANGUL SYLLABLE HWILM");
+-   ("/xed/x9c/xa3", "HANGUL SYLLABLE HWILB");
+-   ("/xed/x9c/xa4", "HANGUL SYLLABLE HWILS");
+-   ("/xed/x9c/xa5", "HANGUL SYLLABLE HWILT");
+-   ("/xed/x9c/xa6", "HANGUL SYLLABLE HWILP");
+-   ("/xed/x9c/xa7", "HANGUL SYLLABLE HWILH");
+-   ("/xed/x9c/xa8", "HANGUL SYLLABLE HWIM");
+-   ("/xed/x9c/xa9", "HANGUL SYLLABLE HWIB");
+-   ("/xed/x9c/xaa", "HANGUL SYLLABLE HWIBS");
+-   ("/xed/x9c/xab", "HANGUL SYLLABLE HWIS");
+-   ("/xed/x9c/xac", "HANGUL SYLLABLE HWISS");
+-   ("/xed/x9c/xad", "HANGUL SYLLABLE HWING");
+-   ("/xed/x9c/xae", "HANGUL SYLLABLE HWIJ");
+-   ("/xed/x9c/xaf", "HANGUL SYLLABLE HWIC");
+-   ("/xed/x9c/xb0", "HANGUL SYLLABLE HWIK");
+-   ("/xed/x9c/xb1", "HANGUL SYLLABLE HWIT");
+-   ("/xed/x9c/xb2", "HANGUL SYLLABLE HWIP");
+-   ("/xed/x9c/xb3", "HANGUL SYLLABLE HWIH");
+-   ("/xed/x9c/xb4", "HANGUL SYLLABLE HYU");
+-   ("/xed/x9c/xb5", "HANGUL SYLLABLE HYUG");
+-   ("/xed/x9c/xb6", "HANGUL SYLLABLE HYUGG");
+-   ("/xed/x9c/xb7", "HANGUL SYLLABLE HYUGS");
+-   ("/xed/x9c/xb8", "HANGUL SYLLABLE HYUN");
+-   ("/xed/x9c/xb9", "HANGUL SYLLABLE HYUNI");
+-   ("/xed/x9c/xba", "HANGUL SYLLABLE HYUNH");
+-   ("/xed/x9c/xbb", "HANGUL SYLLABLE HYUD");
+-   ("/xed/x9c/xbc", "HANGUL SYLLABLE HYUL");
+-   ("/xed/x9c/xbd", "HANGUL SYLLABLE HYULG");
+-   ("/xed/x9c/xbe", "HANGUL SYLLABLE HYULM");
+-   ("/xed/x9c/xbf", "HANGUL SYLLABLE HYULB");
+-   ("/xed/x9d/x80", "HANGUL SYLLABLE HYULS");
+-   ("/xed/x9d/x81", "HANGUL SYLLABLE HYULT");
+-   ("/xed/x9d/x82", "HANGUL SYLLABLE HYULP");
+-   ("/xed/x9d/x83", "HANGUL SYLLABLE HYULH");
+-   ("/xed/x9d/x84", "HANGUL SYLLABLE HYUM");
+-   ("/xed/x9d/x85", "HANGUL SYLLABLE HYUB");
+-   ("/xed/x9d/x86", "HANGUL SYLLABLE HYUBS");
+-   ("/xed/x9d/x87", "HANGUL SYLLABLE HYUS");
+-   ("/xed/x9d/x88", "HANGUL SYLLABLE HYUSS");
+-   ("/xed/x9d/x89", "HANGUL SYLLABLE HYUNG");
+-   ("/xed/x9d/x8a", "HANGUL SYLLABLE HYUJ");
+-   ("/xed/x9d/x8b", "HANGUL SYLLABLE HYUC");
+-   ("/xed/x9d/x8c", "HANGUL SYLLABLE HYUK");
+-   ("/xed/x9d/x8d", "HANGUL SYLLABLE HYUT");
+-   ("/xed/x9d/x8e", "HANGUL SYLLABLE HYUP");
+-   ("/xed/x9d/x8f", "HANGUL SYLLABLE HYUH");
+-   ("/xed/x9d/x90", "HANGUL SYLLABLE HEU");
+-   ("/xed/x9d/x91", "HANGUL SYLLABLE HEUG");
+-   ("/xed/x9d/x92", "HANGUL SYLLABLE HEUGG");
+-   ("/xed/x9d/x93", "HANGUL SYLLABLE HEUGS");
+-   ("/xed/x9d/x94", "HANGUL SYLLABLE HEUN");
+-   ("/xed/x9d/x95", "HANGUL SYLLABLE HEUNI");
+-   ("/xed/x9d/x96", "HANGUL SYLLABLE HEUNH");
+-   ("/xed/x9d/x97", "HANGUL SYLLABLE HEUD");
+-   ("/xed/x9d/x98", "HANGUL SYLLABLE HEUL");
+-   ("/xed/x9d/x99", "HANGUL SYLLABLE HEULG");
+-   ("/xed/x9d/x9a", "HANGUL SYLLABLE HEULM");
+-   ("/xed/x9d/x9b", "HANGUL SYLLABLE HEULB");
+-   ("/xed/x9d/x9c", "HANGUL SYLLABLE HEULS");
+-   ("/xed/x9d/x9d", "HANGUL SYLLABLE HEULT");
+-   ("/xed/x9d/x9e", "HANGUL SYLLABLE HEULP");
+-   ("/xed/x9d/x9f", "HANGUL SYLLABLE HEULH");
+-   ("/xed/x9d/xa0", "HANGUL SYLLABLE HEUM");
+-   ("/xed/x9d/xa1", "HANGUL SYLLABLE HEUB");
+-   ("/xed/x9d/xa2", "HANGUL SYLLABLE HEUBS");
+-   ("/xed/x9d/xa3", "HANGUL SYLLABLE HEUS");
+-   ("/xed/x9d/xa4", "HANGUL SYLLABLE HEUSS");
+-   ("/xed/x9d/xa5", "HANGUL SYLLABLE HEUNG");
+-   ("/xed/x9d/xa6", "HANGUL SYLLABLE HEUJ");
+-   ("/xed/x9d/xa7", "HANGUL SYLLABLE HEUC");
+-   ("/xed/x9d/xa8", "HANGUL SYLLABLE HEUK");
+-   ("/xed/x9d/xa9", "HANGUL SYLLABLE HEUT");
+-   ("/xed/x9d/xaa", "HANGUL SYLLABLE HEUP");
+-   ("/xed/x9d/xab", "HANGUL SYLLABLE HEUH");
+-   ("/xed/x9d/xac", "HANGUL SYLLABLE HYI");
+-   ("/xed/x9d/xad", "HANGUL SYLLABLE HYIG");
+-   ("/xed/x9d/xae", "HANGUL SYLLABLE HYIGG");
+-   ("/xed/x9d/xaf", "HANGUL SYLLABLE HYIGS");
+-   ("/xed/x9d/xb0", "HANGUL SYLLABLE HYIN");
+-   ("/xed/x9d/xb1", "HANGUL SYLLABLE HYINI");
+-   ("/xed/x9d/xb2", "HANGUL SYLLABLE HYINH");
+-   ("/xed/x9d/xb3", "HANGUL SYLLABLE HYID");
+-   ("/xed/x9d/xb4", "HANGUL SYLLABLE HYIL");
+-   ("/xed/x9d/xb5", "HANGUL SYLLABLE HYILG");
+-   ("/xed/x9d/xb6", "HANGUL SYLLABLE HYILM");
+-   ("/xed/x9d/xb7", "HANGUL SYLLABLE HYILB");
+-   ("/xed/x9d/xb8", "HANGUL SYLLABLE HYILS");
+-   ("/xed/x9d/xb9", "HANGUL SYLLABLE HYILT");
+-   ("/xed/x9d/xba", "HANGUL SYLLABLE HYILP");
+-   ("/xed/x9d/xbb", "HANGUL SYLLABLE HYILH");
+-   ("/xed/x9d/xbc", "HANGUL SYLLABLE HYIM");
+-   ("/xed/x9d/xbd", "HANGUL SYLLABLE HYIB");
+-   ("/xed/x9d/xbe", "HANGUL SYLLABLE HYIBS");
+-   ("/xed/x9d/xbf", "HANGUL SYLLABLE HYIS");
+-   ("/xed/x9e/x80", "HANGUL SYLLABLE HYISS");
+-   ("/xed/x9e/x81", "HANGUL SYLLABLE HYING");
+-   ("/xed/x9e/x82", "HANGUL SYLLABLE HYIJ");
+-   ("/xed/x9e/x83", "HANGUL SYLLABLE HYIC");
+-   ("/xed/x9e/x84", "HANGUL SYLLABLE HYIK");
+-   ("/xed/x9e/x85", "HANGUL SYLLABLE HYIT");
+-   ("/xed/x9e/x86", "HANGUL SYLLABLE HYIP");
+-   ("/xed/x9e/x87", "HANGUL SYLLABLE HYIH");
+-   ("/xed/x9e/x88", "HANGUL SYLLABLE HI");
+-   ("/xed/x9e/x89", "HANGUL SYLLABLE HIG");
+-   ("/xed/x9e/x8a", "HANGUL SYLLABLE HIGG");
+-   ("/xed/x9e/x8b", "HANGUL SYLLABLE HIGS");
+-   ("/xed/x9e/x8c", "HANGUL SYLLABLE HIN");
+-   ("/xed/x9e/x8d", "HANGUL SYLLABLE HINI");
+-   ("/xed/x9e/x8e", "HANGUL SYLLABLE HINH");
+-   ("/xed/x9e/x8f", "HANGUL SYLLABLE HID");
+-   ("/xed/x9e/x90", "HANGUL SYLLABLE HIL");
+-   ("/xed/x9e/x91", "HANGUL SYLLABLE HILG");
+-   ("/xed/x9e/x92", "HANGUL SYLLABLE HILM");
+-   ("/xed/x9e/x93", "HANGUL SYLLABLE HILB");
+-   ("/xed/x9e/x94", "HANGUL SYLLABLE HILS");
+-   ("/xed/x9e/x95", "HANGUL SYLLABLE HILT");
+-   ("/xed/x9e/x96", "HANGUL SYLLABLE HILP");
+-   ("/xed/x9e/x97", "HANGUL SYLLABLE HILH");
+-   ("/xed/x9e/x98", "HANGUL SYLLABLE HIM");
+-   ("/xed/x9e/x99", "HANGUL SYLLABLE HIB");
+-   ("/xed/x9e/x9a", "HANGUL SYLLABLE HIBS");
+-   ("/xed/x9e/x9b", "HANGUL SYLLABLE HIS");
+-   ("/xed/x9e/x9c", "HANGUL SYLLABLE HISS");
+-   ("/xed/x9e/x9d", "HANGUL SYLLABLE HING");
+-   ("/xed/x9e/x9e", "HANGUL SYLLABLE HIJ");
+-   ("/xed/x9e/x9f", "HANGUL SYLLABLE HIC");
+-   ("/xed/x9e/xa0", "HANGUL SYLLABLE HIK");
+-   ("/xed/x9e/xa1", "HANGUL SYLLABLE HIT");
+-   ("/xed/x9e/xa2", "HANGUL SYLLABLE HIP");
+-   ("/xed/x9e/xa3", "HANGUL SYLLABLE HIH");
+-   ("<UD800>", "/xed/xa0/x80 <Non Private Use High Surrogate, First>");
+-   ("<UDB7F>", "/xed/xad/xbf <Non Private Use High Surrogate, Last>");
+-   ("<UDB80>", "/xed/xae/x80 <Private Use High Surrogate, First>");
+-   ("<UDBFF>", "/xed/xaf/xbf <Private Use High Surrogate, Last>");
+-   ("<UDC00>", "/xed/xb0/x80 <Low Surrogate, First>");
+-   ("<UDFFF>", "/xed/xbf/xbf <Low Surrogate, Last>");
+-   ("/xee/x80/x80", "<Private Use>");
+-   ("/xee/x81/x80", "<Private Use>");
+-   ("/xee/x82/x80", "<Private Use>");
+-   ("/xee/x83/x80", "<Private Use>");
+-   ("/xee/x84/x80", "<Private Use>");
+-   ("/xee/x85/x80", "<Private Use>");
+-   ("/xee/x86/x80", "<Private Use>");
+-   ("/xee/x87/x80", "<Private Use>");
+-   ("/xee/x88/x80", "<Private Use>");
+-   ("/xee/x89/x80", "<Private Use>");
+-   ("/xee/x8a/x80", "<Private Use>");
+-   ("/xee/x8b/x80", "<Private Use>");
+-   ("/xee/x8c/x80", "<Private Use>");
+-   ("/xee/x8d/x80", "<Private Use>");
+-   ("/xee/x8e/x80", "<Private Use>");
+-   ("/xee/x8f/x80", "<Private Use>");
+-   ("/xee/x90/x80", "<Private Use>");
+-   ("/xee/x91/x80", "<Private Use>");
+-   ("/xee/x92/x80", "<Private Use>");
+-   ("/xee/x93/x80", "<Private Use>");
+-   ("/xee/x94/x80", "<Private Use>");
+-   ("/xee/x95/x80", "<Private Use>");
+-   ("/xee/x96/x80", "<Private Use>");
+-   ("/xee/x97/x80", "<Private Use>");
+-   ("/xee/x98/x80", "<Private Use>");
+-   ("/xee/x99/x80", "<Private Use>");
+-   ("/xee/x9a/x80", "<Private Use>");
+-   ("/xee/x9b/x80", "<Private Use>");
+-   ("/xee/x9c/x80", "<Private Use>");
+-   ("/xee/x9d/x80", "<Private Use>");
+-   ("/xee/x9e/x80", "<Private Use>");
+-   ("/xee/x9f/x80", "<Private Use>");
+-   ("/xee/xa0/x80", "<Private Use>");
+-   ("/xee/xa1/x80", "<Private Use>");
+-   ("/xee/xa2/x80", "<Private Use>");
+-   ("/xee/xa3/x80", "<Private Use>");
+-   ("/xee/xa4/x80", "<Private Use>");
+-   ("/xee/xa5/x80", "<Private Use>");
+-   ("/xee/xa6/x80", "<Private Use>");
+-   ("/xee/xa7/x80", "<Private Use>");
+-   ("/xee/xa8/x80", "<Private Use>");
+-   ("/xee/xa9/x80", "<Private Use>");
+-   ("/xee/xaa/x80", "<Private Use>");
+-   ("/xee/xab/x80", "<Private Use>");
+-   ("/xee/xac/x80", "<Private Use>");
+-   ("/xee/xad/x80", "<Private Use>");
+-   ("/xee/xae/x80", "<Private Use>");
+-   ("/xee/xaf/x80", "<Private Use>");
+-   ("/xee/xb0/x80", "<Private Use>");
+-   ("/xee/xb1/x80", "<Private Use>");
+-   ("/xee/xb2/x80", "<Private Use>");
+-   ("/xee/xb3/x80", "<Private Use>");
+-   ("/xee/xb4/x80", "<Private Use>");
+-   ("/xee/xb5/x80", "<Private Use>");
+-   ("/xee/xb6/x80", "<Private Use>");
+-   ("/xee/xb7/x80", "<Private Use>");
+-   ("/xee/xb8/x80", "<Private Use>");
+-   ("/xee/xb9/x80", "<Private Use>");
+-   ("/xee/xba/x80", "<Private Use>");
+-   ("/xee/xbb/x80", "<Private Use>");
+-   ("/xee/xbc/x80", "<Private Use>");
+-   ("/xee/xbd/x80", "<Private Use>");
+-   ("/xee/xbe/x80", "<Private Use>");
+-   ("/xee/xbf/x80", "<Private Use>");
+-   ("/xef/x80/x80", "<Private Use>");
+-   ("/xef/x81/x80", "<Private Use>");
+-   ("/xef/x82/x80", "<Private Use>");
+-   ("/xef/x83/x80", "<Private Use>");
+-   ("/xef/x84/x80", "<Private Use>");
+-   ("/xef/x85/x80", "<Private Use>");
+-   ("/xef/x86/x80", "<Private Use>");
+-   ("/xef/x87/x80", "<Private Use>");
+-   ("/xef/x88/x80", "<Private Use>");
+-   ("/xef/x89/x80", "<Private Use>");
+-   ("/xef/x8a/x80", "<Private Use>");
+-   ("/xef/x8b/x80", "<Private Use>");
+-   ("/xef/x8c/x80", "<Private Use>");
+-   ("/xef/x8d/x80", "<Private Use>");
+-   ("/xef/x8e/x80", "<Private Use>");
+-   ("/xef/x8f/x80", "<Private Use>");
+-   ("/xef/x90/x80", "<Private Use>");
+-   ("/xef/x91/x80", "<Private Use>");
+-   ("/xef/x92/x80", "<Private Use>");
+-   ("/xef/x93/x80", "<Private Use>");
+-   ("/xef/x94/x80", "<Private Use>");
+-   ("/xef/x95/x80", "<Private Use>");
+-   ("/xef/x96/x80", "<Private Use>");
+-   ("/xef/x97/x80", "<Private Use>");
+-   ("/xef/x98/x80", "<Private Use>");
+-   ("/xef/x99/x80", "<Private Use>");
+-   ("/xef/x9a/x80", "<Private Use>");
+-   ("/xef/x9b/x80", "<Private Use>");
+-   ("/xef/x9c/x80", "<Private Use>");
+-   ("/xef/x9d/x80", "<Private Use>");
+-   ("/xef/x9e/x80", "<Private Use>");
+-   ("/xef/x9f/x80", "<Private Use>");
+-   ("/xef/xa0/x80", "<Private Use>");
+-   ("/xef/xa1/x80", "<Private Use>");
+-   ("/xef/xa2/x80", "<Private Use>");
+-   ("/xef/xa3/x80", "<Private Use>");
+-   ("/xef/xa4/x80", "CJK COMPATIBILITY IDEOGRAPH-F900");
+-   ("/xef/xa4/x81", "CJK COMPATIBILITY IDEOGRAPH-F901");
+-   ("/xef/xa4/x82", "CJK COMPATIBILITY IDEOGRAPH-F902");
+-   ("/xef/xa4/x83", "CJK COMPATIBILITY IDEOGRAPH-F903");
+-   ("/xef/xa4/x84", "CJK COMPATIBILITY IDEOGRAPH-F904");
+-   ("/xef/xa4/x85", "CJK COMPATIBILITY IDEOGRAPH-F905");
+-   ("/xef/xa4/x86", "CJK COMPATIBILITY IDEOGRAPH-F906");
+-   ("/xef/xa4/x87", "CJK COMPATIBILITY IDEOGRAPH-F907");
+-   ("/xef/xa4/x88", "CJK COMPATIBILITY IDEOGRAPH-F908");
+-   ("/xef/xa4/x89", "CJK COMPATIBILITY IDEOGRAPH-F909");
+-   ("/xef/xa4/x8a", "CJK COMPATIBILITY IDEOGRAPH-F90A");
+-   ("/xef/xa4/x8b", "CJK COMPATIBILITY IDEOGRAPH-F90B");
+-   ("/xef/xa4/x8c", "CJK COMPATIBILITY IDEOGRAPH-F90C");
+-   ("/xef/xa4/x8d", "CJK COMPATIBILITY IDEOGRAPH-F90D");
+-   ("/xef/xa4/x8e", "CJK COMPATIBILITY IDEOGRAPH-F90E");
+-   ("/xef/xa4/x8f", "CJK COMPATIBILITY IDEOGRAPH-F90F");
+-   ("/xef/xa4/x90", "CJK COMPATIBILITY IDEOGRAPH-F910");
+-   ("/xef/xa4/x91", "CJK COMPATIBILITY IDEOGRAPH-F911");
+-   ("/xef/xa4/x92", "CJK COMPATIBILITY IDEOGRAPH-F912");
+-   ("/xef/xa4/x93", "CJK COMPATIBILITY IDEOGRAPH-F913");
+-   ("/xef/xa4/x94", "CJK COMPATIBILITY IDEOGRAPH-F914");
+-   ("/xef/xa4/x95", "CJK COMPATIBILITY IDEOGRAPH-F915");
+-   ("/xef/xa4/x96", "CJK COMPATIBILITY IDEOGRAPH-F916");
+-   ("/xef/xa4/x97", "CJK COMPATIBILITY IDEOGRAPH-F917");
+-   ("/xef/xa4/x98", "CJK COMPATIBILITY IDEOGRAPH-F918");
+-   ("/xef/xa4/x99", "CJK COMPATIBILITY IDEOGRAPH-F919");
+-   ("/xef/xa4/x9a", "CJK COMPATIBILITY IDEOGRAPH-F91A");
+-   ("/xef/xa4/x9b", "CJK COMPATIBILITY IDEOGRAPH-F91B");
+-   ("/xef/xa4/x9c", "CJK COMPATIBILITY IDEOGRAPH-F91C");
+-   ("/xef/xa4/x9d", "CJK COMPATIBILITY IDEOGRAPH-F91D");
+-   ("/xef/xa4/x9e", "CJK COMPATIBILITY IDEOGRAPH-F91E");
+-   ("/xef/xa4/x9f", "CJK COMPATIBILITY IDEOGRAPH-F91F");
+-   ("/xef/xa4/xa0", "CJK COMPATIBILITY IDEOGRAPH-F920");
+-   ("/xef/xa4/xa1", "CJK COMPATIBILITY IDEOGRAPH-F921");
+-   ("/xef/xa4/xa2", "CJK COMPATIBILITY IDEOGRAPH-F922");
+-   ("/xef/xa4/xa3", "CJK COMPATIBILITY IDEOGRAPH-F923");
+-   ("/xef/xa4/xa4", "CJK COMPATIBILITY IDEOGRAPH-F924");
+-   ("/xef/xa4/xa5", "CJK COMPATIBILITY IDEOGRAPH-F925");
+-   ("/xef/xa4/xa6", "CJK COMPATIBILITY IDEOGRAPH-F926");
+-   ("/xef/xa4/xa7", "CJK COMPATIBILITY IDEOGRAPH-F927");
+-   ("/xef/xa4/xa8", "CJK COMPATIBILITY IDEOGRAPH-F928");
+-   ("/xef/xa4/xa9", "CJK COMPATIBILITY IDEOGRAPH-F929");
+-   ("/xef/xa4/xaa", "CJK COMPATIBILITY IDEOGRAPH-F92A");
+-   ("/xef/xa4/xab", "CJK COMPATIBILITY IDEOGRAPH-F92B");
+-   ("/xef/xa4/xac", "CJK COMPATIBILITY IDEOGRAPH-F92C");
+-   ("/xef/xa4/xad", "CJK COMPATIBILITY IDEOGRAPH-F92D");
+-   ("/xef/xa4/xae", "CJK COMPATIBILITY IDEOGRAPH-F92E");
+-   ("/xef/xa4/xaf", "CJK COMPATIBILITY IDEOGRAPH-F92F");
+-   ("/xef/xa4/xb0", "CJK COMPATIBILITY IDEOGRAPH-F930");
+-   ("/xef/xa4/xb1", "CJK COMPATIBILITY IDEOGRAPH-F931");
+-   ("/xef/xa4/xb2", "CJK COMPATIBILITY IDEOGRAPH-F932");
+-   ("/xef/xa4/xb3", "CJK COMPATIBILITY IDEOGRAPH-F933");
+-   ("/xef/xa4/xb4", "CJK COMPATIBILITY IDEOGRAPH-F934");
+-   ("/xef/xa4/xb5", "CJK COMPATIBILITY IDEOGRAPH-F935");
+-   ("/xef/xa4/xb6", "CJK COMPATIBILITY IDEOGRAPH-F936");
+-   ("/xef/xa4/xb7", "CJK COMPATIBILITY IDEOGRAPH-F937");
+-   ("/xef/xa4/xb8", "CJK COMPATIBILITY IDEOGRAPH-F938");
+-   ("/xef/xa4/xb9", "CJK COMPATIBILITY IDEOGRAPH-F939");
+-   ("/xef/xa4/xba", "CJK COMPATIBILITY IDEOGRAPH-F93A");
+-   ("/xef/xa4/xbb", "CJK COMPATIBILITY IDEOGRAPH-F93B");
+-   ("/xef/xa4/xbc", "CJK COMPATIBILITY IDEOGRAPH-F93C");
+-   ("/xef/xa4/xbd", "CJK COMPATIBILITY IDEOGRAPH-F93D");
+-   ("/xef/xa4/xbe", "CJK COMPATIBILITY IDEOGRAPH-F93E");
+-   ("/xef/xa4/xbf", "CJK COMPATIBILITY IDEOGRAPH-F93F");
+-   ("/xef/xa5/x80", "CJK COMPATIBILITY IDEOGRAPH-F940");
+-   ("/xef/xa5/x81", "CJK COMPATIBILITY IDEOGRAPH-F941");
+-   ("/xef/xa5/x82", "CJK COMPATIBILITY IDEOGRAPH-F942");
+-   ("/xef/xa5/x83", "CJK COMPATIBILITY IDEOGRAPH-F943");
+-   ("/xef/xa5/x84", "CJK COMPATIBILITY IDEOGRAPH-F944");
+-   ("/xef/xa5/x85", "CJK COMPATIBILITY IDEOGRAPH-F945");
+-   ("/xef/xa5/x86", "CJK COMPATIBILITY IDEOGRAPH-F946");
+-   ("/xef/xa5/x87", "CJK COMPATIBILITY IDEOGRAPH-F947");
+-   ("/xef/xa5/x88", "CJK COMPATIBILITY IDEOGRAPH-F948");
+-   ("/xef/xa5/x89", "CJK COMPATIBILITY IDEOGRAPH-F949");
+-   ("/xef/xa5/x8a", "CJK COMPATIBILITY IDEOGRAPH-F94A");
+-   ("/xef/xa5/x8b", "CJK COMPATIBILITY IDEOGRAPH-F94B");
+-   ("/xef/xa5/x8c", "CJK COMPATIBILITY IDEOGRAPH-F94C");
+-   ("/xef/xa5/x8d", "CJK COMPATIBILITY IDEOGRAPH-F94D");
+-   ("/xef/xa5/x8e", "CJK COMPATIBILITY IDEOGRAPH-F94E");
+-   ("/xef/xa5/x8f", "CJK COMPATIBILITY IDEOGRAPH-F94F");
+-   ("/xef/xa5/x90", "CJK COMPATIBILITY IDEOGRAPH-F950");
+-   ("/xef/xa5/x91", "CJK COMPATIBILITY IDEOGRAPH-F951");
+-   ("/xef/xa5/x92", "CJK COMPATIBILITY IDEOGRAPH-F952");
+-   ("/xef/xa5/x93", "CJK COMPATIBILITY IDEOGRAPH-F953");
+-   ("/xef/xa5/x94", "CJK COMPATIBILITY IDEOGRAPH-F954");
+-   ("/xef/xa5/x95", "CJK COMPATIBILITY IDEOGRAPH-F955");
+-   ("/xef/xa5/x96", "CJK COMPATIBILITY IDEOGRAPH-F956");
+-   ("/xef/xa5/x97", "CJK COMPATIBILITY IDEOGRAPH-F957");
+-   ("/xef/xa5/x98", "CJK COMPATIBILITY IDEOGRAPH-F958");
+-   ("/xef/xa5/x99", "CJK COMPATIBILITY IDEOGRAPH-F959");
+-   ("/xef/xa5/x9a", "CJK COMPATIBILITY IDEOGRAPH-F95A");
+-   ("/xef/xa5/x9b", "CJK COMPATIBILITY IDEOGRAPH-F95B");
+-   ("/xef/xa5/x9c", "CJK COMPATIBILITY IDEOGRAPH-F95C");
+-   ("/xef/xa5/x9d", "CJK COMPATIBILITY IDEOGRAPH-F95D");
+-   ("/xef/xa5/x9e", "CJK COMPATIBILITY IDEOGRAPH-F95E");
+-   ("/xef/xa5/x9f", "CJK COMPATIBILITY IDEOGRAPH-F95F");
+-   ("/xef/xa5/xa0", "CJK COMPATIBILITY IDEOGRAPH-F960");
+-   ("/xef/xa5/xa1", "CJK COMPATIBILITY IDEOGRAPH-F961");
+-   ("/xef/xa5/xa2", "CJK COMPATIBILITY IDEOGRAPH-F962");
+-   ("/xef/xa5/xa3", "CJK COMPATIBILITY IDEOGRAPH-F963");
+-   ("/xef/xa5/xa4", "CJK COMPATIBILITY IDEOGRAPH-F964");
+-   ("/xef/xa5/xa5", "CJK COMPATIBILITY IDEOGRAPH-F965");
+-   ("/xef/xa5/xa6", "CJK COMPATIBILITY IDEOGRAPH-F966");
+-   ("/xef/xa5/xa7", "CJK COMPATIBILITY IDEOGRAPH-F967");
+-   ("/xef/xa5/xa8", "CJK COMPATIBILITY IDEOGRAPH-F968");
+-   ("/xef/xa5/xa9", "CJK COMPATIBILITY IDEOGRAPH-F969");
+-   ("/xef/xa5/xaa", "CJK COMPATIBILITY IDEOGRAPH-F96A");
+-   ("/xef/xa5/xab", "CJK COMPATIBILITY IDEOGRAPH-F96B");
+-   ("/xef/xa5/xac", "CJK COMPATIBILITY IDEOGRAPH-F96C");
+-   ("/xef/xa5/xad", "CJK COMPATIBILITY IDEOGRAPH-F96D");
+-   ("/xef/xa5/xae", "CJK COMPATIBILITY IDEOGRAPH-F96E");
+-   ("/xef/xa5/xaf", "CJK COMPATIBILITY IDEOGRAPH-F96F");
+-   ("/xef/xa5/xb0", "CJK COMPATIBILITY IDEOGRAPH-F970");
+-   ("/xef/xa5/xb1", "CJK COMPATIBILITY IDEOGRAPH-F971");
+-   ("/xef/xa5/xb2", "CJK COMPATIBILITY IDEOGRAPH-F972");
+-   ("/xef/xa5/xb3", "CJK COMPATIBILITY IDEOGRAPH-F973");
+-   ("/xef/xa5/xb4", "CJK COMPATIBILITY IDEOGRAPH-F974");
+-   ("/xef/xa5/xb5", "CJK COMPATIBILITY IDEOGRAPH-F975");
+-   ("/xef/xa5/xb6", "CJK COMPATIBILITY IDEOGRAPH-F976");
+-   ("/xef/xa5/xb7", "CJK COMPATIBILITY IDEOGRAPH-F977");
+-   ("/xef/xa5/xb8", "CJK COMPATIBILITY IDEOGRAPH-F978");
+-   ("/xef/xa5/xb9", "CJK COMPATIBILITY IDEOGRAPH-F979");
+-   ("/xef/xa5/xba", "CJK COMPATIBILITY IDEOGRAPH-F97A");
+-   ("/xef/xa5/xbb", "CJK COMPATIBILITY IDEOGRAPH-F97B");
+-   ("/xef/xa5/xbc", "CJK COMPATIBILITY IDEOGRAPH-F97C");
+-   ("/xef/xa5/xbd", "CJK COMPATIBILITY IDEOGRAPH-F97D");
+-   ("/xef/xa5/xbe", "CJK COMPATIBILITY IDEOGRAPH-F97E");
+-   ("/xef/xa5/xbf", "CJK COMPATIBILITY IDEOGRAPH-F97F");
+-   ("/xef/xa6/x80", "CJK COMPATIBILITY IDEOGRAPH-F980");
+-   ("/xef/xa6/x81", "CJK COMPATIBILITY IDEOGRAPH-F981");
+-   ("/xef/xa6/x82", "CJK COMPATIBILITY IDEOGRAPH-F982");
+-   ("/xef/xa6/x83", "CJK COMPATIBILITY IDEOGRAPH-F983");
+-   ("/xef/xa6/x84", "CJK COMPATIBILITY IDEOGRAPH-F984");
+-   ("/xef/xa6/x85", "CJK COMPATIBILITY IDEOGRAPH-F985");
+-   ("/xef/xa6/x86", "CJK COMPATIBILITY IDEOGRAPH-F986");
+-   ("/xef/xa6/x87", "CJK COMPATIBILITY IDEOGRAPH-F987");
+-   ("/xef/xa6/x88", "CJK COMPATIBILITY IDEOGRAPH-F988");
+-   ("/xef/xa6/x89", "CJK COMPATIBILITY IDEOGRAPH-F989");
+-   ("/xef/xa6/x8a", "CJK COMPATIBILITY IDEOGRAPH-F98A");
+-   ("/xef/xa6/x8b", "CJK COMPATIBILITY IDEOGRAPH-F98B");
+-   ("/xef/xa6/x8c", "CJK COMPATIBILITY IDEOGRAPH-F98C");
+-   ("/xef/xa6/x8d", "CJK COMPATIBILITY IDEOGRAPH-F98D");
+-   ("/xef/xa6/x8e", "CJK COMPATIBILITY IDEOGRAPH-F98E");
+-   ("/xef/xa6/x8f", "CJK COMPATIBILITY IDEOGRAPH-F98F");
+-   ("/xef/xa6/x90", "CJK COMPATIBILITY IDEOGRAPH-F990");
+-   ("/xef/xa6/x91", "CJK COMPATIBILITY IDEOGRAPH-F991");
+-   ("/xef/xa6/x92", "CJK COMPATIBILITY IDEOGRAPH-F992");
+-   ("/xef/xa6/x93", "CJK COMPATIBILITY IDEOGRAPH-F993");
+-   ("/xef/xa6/x94", "CJK COMPATIBILITY IDEOGRAPH-F994");
+-   ("/xef/xa6/x95", "CJK COMPATIBILITY IDEOGRAPH-F995");
+-   ("/xef/xa6/x96", "CJK COMPATIBILITY IDEOGRAPH-F996");
+-   ("/xef/xa6/x97", "CJK COMPATIBILITY IDEOGRAPH-F997");
+-   ("/xef/xa6/x98", "CJK COMPATIBILITY IDEOGRAPH-F998");
+-   ("/xef/xa6/x99", "CJK COMPATIBILITY IDEOGRAPH-F999");
+-   ("/xef/xa6/x9a", "CJK COMPATIBILITY IDEOGRAPH-F99A");
+-   ("/xef/xa6/x9b", "CJK COMPATIBILITY IDEOGRAPH-F99B");
+-   ("/xef/xa6/x9c", "CJK COMPATIBILITY IDEOGRAPH-F99C");
+-   ("/xef/xa6/x9d", "CJK COMPATIBILITY IDEOGRAPH-F99D");
+-   ("/xef/xa6/x9e", "CJK COMPATIBILITY IDEOGRAPH-F99E");
+-   ("/xef/xa6/x9f", "CJK COMPATIBILITY IDEOGRAPH-F99F");
+-   ("/xef/xa6/xa0", "CJK COMPATIBILITY IDEOGRAPH-F9A0");
+-   ("/xef/xa6/xa1", "CJK COMPATIBILITY IDEOGRAPH-F9A1");
+-   ("/xef/xa6/xa2", "CJK COMPATIBILITY IDEOGRAPH-F9A2");
+-   ("/xef/xa6/xa3", "CJK COMPATIBILITY IDEOGRAPH-F9A3");
+-   ("/xef/xa6/xa4", "CJK COMPATIBILITY IDEOGRAPH-F9A4");
+-   ("/xef/xa6/xa5", "CJK COMPATIBILITY IDEOGRAPH-F9A5");
+-   ("/xef/xa6/xa6", "CJK COMPATIBILITY IDEOGRAPH-F9A6");
+-   ("/xef/xa6/xa7", "CJK COMPATIBILITY IDEOGRAPH-F9A7");
+-   ("/xef/xa6/xa8", "CJK COMPATIBILITY IDEOGRAPH-F9A8");
+-   ("/xef/xa6/xa9", "CJK COMPATIBILITY IDEOGRAPH-F9A9");
+-   ("/xef/xa6/xaa", "CJK COMPATIBILITY IDEOGRAPH-F9AA");
+-   ("/xef/xa6/xab", "CJK COMPATIBILITY IDEOGRAPH-F9AB");
+-   ("/xef/xa6/xac", "CJK COMPATIBILITY IDEOGRAPH-F9AC");
+-   ("/xef/xa6/xad", "CJK COMPATIBILITY IDEOGRAPH-F9AD");
+-   ("/xef/xa6/xae", "CJK COMPATIBILITY IDEOGRAPH-F9AE");
+-   ("/xef/xa6/xaf", "CJK COMPATIBILITY IDEOGRAPH-F9AF");
+-   ("/xef/xa6/xb0", "CJK COMPATIBILITY IDEOGRAPH-F9B0");
+-   ("/xef/xa6/xb1", "CJK COMPATIBILITY IDEOGRAPH-F9B1");
+-   ("/xef/xa6/xb2", "CJK COMPATIBILITY IDEOGRAPH-F9B2");
+-   ("/xef/xa6/xb3", "CJK COMPATIBILITY IDEOGRAPH-F9B3");
+-   ("/xef/xa6/xb4", "CJK COMPATIBILITY IDEOGRAPH-F9B4");
+-   ("/xef/xa6/xb5", "CJK COMPATIBILITY IDEOGRAPH-F9B5");
+-   ("/xef/xa6/xb6", "CJK COMPATIBILITY IDEOGRAPH-F9B6");
+-   ("/xef/xa6/xb7", "CJK COMPATIBILITY IDEOGRAPH-F9B7");
+-   ("/xef/xa6/xb8", "CJK COMPATIBILITY IDEOGRAPH-F9B8");
+-   ("/xef/xa6/xb9", "CJK COMPATIBILITY IDEOGRAPH-F9B9");
+-   ("/xef/xa6/xba", "CJK COMPATIBILITY IDEOGRAPH-F9BA");
+-   ("/xef/xa6/xbb", "CJK COMPATIBILITY IDEOGRAPH-F9BB");
+-   ("/xef/xa6/xbc", "CJK COMPATIBILITY IDEOGRAPH-F9BC");
+-   ("/xef/xa6/xbd", "CJK COMPATIBILITY IDEOGRAPH-F9BD");
+-   ("/xef/xa6/xbe", "CJK COMPATIBILITY IDEOGRAPH-F9BE");
+-   ("/xef/xa6/xbf", "CJK COMPATIBILITY IDEOGRAPH-F9BF");
+-   ("/xef/xa7/x80", "CJK COMPATIBILITY IDEOGRAPH-F9C0");
+-   ("/xef/xa7/x81", "CJK COMPATIBILITY IDEOGRAPH-F9C1");
+-   ("/xef/xa7/x82", "CJK COMPATIBILITY IDEOGRAPH-F9C2");
+-   ("/xef/xa7/x83", "CJK COMPATIBILITY IDEOGRAPH-F9C3");
+-   ("/xef/xa7/x84", "CJK COMPATIBILITY IDEOGRAPH-F9C4");
+-   ("/xef/xa7/x85", "CJK COMPATIBILITY IDEOGRAPH-F9C5");
+-   ("/xef/xa7/x86", "CJK COMPATIBILITY IDEOGRAPH-F9C6");
+-   ("/xef/xa7/x87", "CJK COMPATIBILITY IDEOGRAPH-F9C7");
+-   ("/xef/xa7/x88", "CJK COMPATIBILITY IDEOGRAPH-F9C8");
+-   ("/xef/xa7/x89", "CJK COMPATIBILITY IDEOGRAPH-F9C9");
+-   ("/xef/xa7/x8a", "CJK COMPATIBILITY IDEOGRAPH-F9CA");
+-   ("/xef/xa7/x8b", "CJK COMPATIBILITY IDEOGRAPH-F9CB");
+-   ("/xef/xa7/x8c", "CJK COMPATIBILITY IDEOGRAPH-F9CC");
+-   ("/xef/xa7/x8d", "CJK COMPATIBILITY IDEOGRAPH-F9CD");
+-   ("/xef/xa7/x8e", "CJK COMPATIBILITY IDEOGRAPH-F9CE");
+-   ("/xef/xa7/x8f", "CJK COMPATIBILITY IDEOGRAPH-F9CF");
+-   ("/xef/xa7/x90", "CJK COMPATIBILITY IDEOGRAPH-F9D0");
+-   ("/xef/xa7/x91", "CJK COMPATIBILITY IDEOGRAPH-F9D1");
+-   ("/xef/xa7/x92", "CJK COMPATIBILITY IDEOGRAPH-F9D2");
+-   ("/xef/xa7/x93", "CJK COMPATIBILITY IDEOGRAPH-F9D3");
+-   ("/xef/xa7/x94", "CJK COMPATIBILITY IDEOGRAPH-F9D4");
+-   ("/xef/xa7/x95", "CJK COMPATIBILITY IDEOGRAPH-F9D5");
+-   ("/xef/xa7/x96", "CJK COMPATIBILITY IDEOGRAPH-F9D6");
+-   ("/xef/xa7/x97", "CJK COMPATIBILITY IDEOGRAPH-F9D7");
+-   ("/xef/xa7/x98", "CJK COMPATIBILITY IDEOGRAPH-F9D8");
+-   ("/xef/xa7/x99", "CJK COMPATIBILITY IDEOGRAPH-F9D9");
+-   ("/xef/xa7/x9a", "CJK COMPATIBILITY IDEOGRAPH-F9DA");
+-   ("/xef/xa7/x9b", "CJK COMPATIBILITY IDEOGRAPH-F9DB");
+-   ("/xef/xa7/x9c", "CJK COMPATIBILITY IDEOGRAPH-F9DC");
+-   ("/xef/xa7/x9d", "CJK COMPATIBILITY IDEOGRAPH-F9DD");
+-   ("/xef/xa7/x9e", "CJK COMPATIBILITY IDEOGRAPH-F9DE");
+-   ("/xef/xa7/x9f", "CJK COMPATIBILITY IDEOGRAPH-F9DF");
+-   ("/xef/xa7/xa0", "CJK COMPATIBILITY IDEOGRAPH-F9E0");
+-   ("/xef/xa7/xa1", "CJK COMPATIBILITY IDEOGRAPH-F9E1");
+-   ("/xef/xa7/xa2", "CJK COMPATIBILITY IDEOGRAPH-F9E2");
+-   ("/xef/xa7/xa3", "CJK COMPATIBILITY IDEOGRAPH-F9E3");
+-   ("/xef/xa7/xa4", "CJK COMPATIBILITY IDEOGRAPH-F9E4");
+-   ("/xef/xa7/xa5", "CJK COMPATIBILITY IDEOGRAPH-F9E5");
+-   ("/xef/xa7/xa6", "CJK COMPATIBILITY IDEOGRAPH-F9E6");
+-   ("/xef/xa7/xa7", "CJK COMPATIBILITY IDEOGRAPH-F9E7");
+-   ("/xef/xa7/xa8", "CJK COMPATIBILITY IDEOGRAPH-F9E8");
+-   ("/xef/xa7/xa9", "CJK COMPATIBILITY IDEOGRAPH-F9E9");
+-   ("/xef/xa7/xaa", "CJK COMPATIBILITY IDEOGRAPH-F9EA");
+-   ("/xef/xa7/xab", "CJK COMPATIBILITY IDEOGRAPH-F9EB");
+-   ("/xef/xa7/xac", "CJK COMPATIBILITY IDEOGRAPH-F9EC");
+-   ("/xef/xa7/xad", "CJK COMPATIBILITY IDEOGRAPH-F9ED");
+-   ("/xef/xa7/xae", "CJK COMPATIBILITY IDEOGRAPH-F9EE");
+-   ("/xef/xa7/xaf", "CJK COMPATIBILITY IDEOGRAPH-F9EF");
+-   ("/xef/xa7/xb0", "CJK COMPATIBILITY IDEOGRAPH-F9F0");
+-   ("/xef/xa7/xb1", "CJK COMPATIBILITY IDEOGRAPH-F9F1");
+-   ("/xef/xa7/xb2", "CJK COMPATIBILITY IDEOGRAPH-F9F2");
+-   ("/xef/xa7/xb3", "CJK COMPATIBILITY IDEOGRAPH-F9F3");
+-   ("/xef/xa7/xb4", "CJK COMPATIBILITY IDEOGRAPH-F9F4");
+-   ("/xef/xa7/xb5", "CJK COMPATIBILITY IDEOGRAPH-F9F5");
+-   ("/xef/xa7/xb6", "CJK COMPATIBILITY IDEOGRAPH-F9F6");
+-   ("/xef/xa7/xb7", "CJK COMPATIBILITY IDEOGRAPH-F9F7");
+-   ("/xef/xa7/xb8", "CJK COMPATIBILITY IDEOGRAPH-F9F8");
+-   ("/xef/xa7/xb9", "CJK COMPATIBILITY IDEOGRAPH-F9F9");
+-   ("/xef/xa7/xba", "CJK COMPATIBILITY IDEOGRAPH-F9FA");
+-   ("/xef/xa7/xbb", "CJK COMPATIBILITY IDEOGRAPH-F9FB");
+-   ("/xef/xa7/xbc", "CJK COMPATIBILITY IDEOGRAPH-F9FC");
+-   ("/xef/xa7/xbd", "CJK COMPATIBILITY IDEOGRAPH-F9FD");
+-   ("/xef/xa7/xbe", "CJK COMPATIBILITY IDEOGRAPH-F9FE");
+-   ("/xef/xa7/xbf", "CJK COMPATIBILITY IDEOGRAPH-F9FF");
+-   ("/xef/xa8/x80", "CJK COMPATIBILITY IDEOGRAPH-FA00");
+-   ("/xef/xa8/x81", "CJK COMPATIBILITY IDEOGRAPH-FA01");
+-   ("/xef/xa8/x82", "CJK COMPATIBILITY IDEOGRAPH-FA02");
+-   ("/xef/xa8/x83", "CJK COMPATIBILITY IDEOGRAPH-FA03");
+-   ("/xef/xa8/x84", "CJK COMPATIBILITY IDEOGRAPH-FA04");
+-   ("/xef/xa8/x85", "CJK COMPATIBILITY IDEOGRAPH-FA05");
+-   ("/xef/xa8/x86", "CJK COMPATIBILITY IDEOGRAPH-FA06");
+-   ("/xef/xa8/x87", "CJK COMPATIBILITY IDEOGRAPH-FA07");
+-   ("/xef/xa8/x88", "CJK COMPATIBILITY IDEOGRAPH-FA08");
+-   ("/xef/xa8/x89", "CJK COMPATIBILITY IDEOGRAPH-FA09");
+-   ("/xef/xa8/x8a", "CJK COMPATIBILITY IDEOGRAPH-FA0A");
+-   ("/xef/xa8/x8b", "CJK COMPATIBILITY IDEOGRAPH-FA0B");
+-   ("/xef/xa8/x8c", "CJK COMPATIBILITY IDEOGRAPH-FA0C");
+-   ("/xef/xa8/x8d", "CJK COMPATIBILITY IDEOGRAPH-FA0D");
+-   ("/xef/xa8/x8e", "CJK COMPATIBILITY IDEOGRAPH-FA0E");
+-   ("/xef/xa8/x8f", "CJK COMPATIBILITY IDEOGRAPH-FA0F");
+-   ("/xef/xa8/x90", "CJK COMPATIBILITY IDEOGRAPH-FA10");
+-   ("/xef/xa8/x91", "CJK COMPATIBILITY IDEOGRAPH-FA11");
+-   ("/xef/xa8/x92", "CJK COMPATIBILITY IDEOGRAPH-FA12");
+-   ("/xef/xa8/x93", "CJK COMPATIBILITY IDEOGRAPH-FA13");
+-   ("/xef/xa8/x94", "CJK COMPATIBILITY IDEOGRAPH-FA14");
+-   ("/xef/xa8/x95", "CJK COMPATIBILITY IDEOGRAPH-FA15");
+-   ("/xef/xa8/x96", "CJK COMPATIBILITY IDEOGRAPH-FA16");
+-   ("/xef/xa8/x97", "CJK COMPATIBILITY IDEOGRAPH-FA17");
+-   ("/xef/xa8/x98", "CJK COMPATIBILITY IDEOGRAPH-FA18");
+-   ("/xef/xa8/x99", "CJK COMPATIBILITY IDEOGRAPH-FA19");
+-   ("/xef/xa8/x9a", "CJK COMPATIBILITY IDEOGRAPH-FA1A");
+-   ("/xef/xa8/x9b", "CJK COMPATIBILITY IDEOGRAPH-FA1B");
+-   ("/xef/xa8/x9c", "CJK COMPATIBILITY IDEOGRAPH-FA1C");
+-   ("/xef/xa8/x9d", "CJK COMPATIBILITY IDEOGRAPH-FA1D");
+-   ("/xef/xa8/x9e", "CJK COMPATIBILITY IDEOGRAPH-FA1E");
+-   ("/xef/xa8/x9f", "CJK COMPATIBILITY IDEOGRAPH-FA1F");
+-   ("/xef/xa8/xa0", "CJK COMPATIBILITY IDEOGRAPH-FA20");
+-   ("/xef/xa8/xa1", "CJK COMPATIBILITY IDEOGRAPH-FA21");
+-   ("/xef/xa8/xa2", "CJK COMPATIBILITY IDEOGRAPH-FA22");
+-   ("/xef/xa8/xa3", "CJK COMPATIBILITY IDEOGRAPH-FA23");
+-   ("/xef/xa8/xa4", "CJK COMPATIBILITY IDEOGRAPH-FA24");
+-   ("/xef/xa8/xa5", "CJK COMPATIBILITY IDEOGRAPH-FA25");
+-   ("/xef/xa8/xa6", "CJK COMPATIBILITY IDEOGRAPH-FA26");
+-   ("/xef/xa8/xa7", "CJK COMPATIBILITY IDEOGRAPH-FA27");
+-   ("/xef/xa8/xa8", "CJK COMPATIBILITY IDEOGRAPH-FA28");
+-   ("/xef/xa8/xa9", "CJK COMPATIBILITY IDEOGRAPH-FA29");
+-   ("/xef/xa8/xaa", "CJK COMPATIBILITY IDEOGRAPH-FA2A");
+-   ("/xef/xa8/xab", "CJK COMPATIBILITY IDEOGRAPH-FA2B");
+-   ("/xef/xa8/xac", "CJK COMPATIBILITY IDEOGRAPH-FA2C");
+-   ("/xef/xa8/xad", "CJK COMPATIBILITY IDEOGRAPH-FA2D");
+-   ("/xef/xa8/xb0", "CJK COMPATIBILITY IDEOGRAPH-FA30");
+-   ("/xef/xa8/xb1", "CJK COMPATIBILITY IDEOGRAPH-FA31");
+-   ("/xef/xa8/xb2", "CJK COMPATIBILITY IDEOGRAPH-FA32");
+-   ("/xef/xa8/xb3", "CJK COMPATIBILITY IDEOGRAPH-FA33");
+-   ("/xef/xa8/xb4", "CJK COMPATIBILITY IDEOGRAPH-FA34");
+-   ("/xef/xa8/xb5", "CJK COMPATIBILITY IDEOGRAPH-FA35");
+-   ("/xef/xa8/xb6", "CJK COMPATIBILITY IDEOGRAPH-FA36");
+-   ("/xef/xa8/xb7", "CJK COMPATIBILITY IDEOGRAPH-FA37");
+-   ("/xef/xa8/xb8", "CJK COMPATIBILITY IDEOGRAPH-FA38");
+-   ("/xef/xa8/xb9", "CJK COMPATIBILITY IDEOGRAPH-FA39");
+-   ("/xef/xa8/xba", "CJK COMPATIBILITY IDEOGRAPH-FA3A");
+-   ("/xef/xa8/xbb", "CJK COMPATIBILITY IDEOGRAPH-FA3B");
+-   ("/xef/xa8/xbc", "CJK COMPATIBILITY IDEOGRAPH-FA3C");
+-   ("/xef/xa8/xbd", "CJK COMPATIBILITY IDEOGRAPH-FA3D");
+-   ("/xef/xa8/xbe", "CJK COMPATIBILITY IDEOGRAPH-FA3E");
+-   ("/xef/xa8/xbf", "CJK COMPATIBILITY IDEOGRAPH-FA3F");
+-   ("/xef/xa9/x80", "CJK COMPATIBILITY IDEOGRAPH-FA40");
+-   ("/xef/xa9/x81", "CJK COMPATIBILITY IDEOGRAPH-FA41");
+-   ("/xef/xa9/x82", "CJK COMPATIBILITY IDEOGRAPH-FA42");
+-   ("/xef/xa9/x83", "CJK COMPATIBILITY IDEOGRAPH-FA43");
+-   ("/xef/xa9/x84", "CJK COMPATIBILITY IDEOGRAPH-FA44");
+-   ("/xef/xa9/x85", "CJK COMPATIBILITY IDEOGRAPH-FA45");
+-   ("/xef/xa9/x86", "CJK COMPATIBILITY IDEOGRAPH-FA46");
+-   ("/xef/xa9/x87", "CJK COMPATIBILITY IDEOGRAPH-FA47");
+-   ("/xef/xa9/x88", "CJK COMPATIBILITY IDEOGRAPH-FA48");
+-   ("/xef/xa9/x89", "CJK COMPATIBILITY IDEOGRAPH-FA49");
+-   ("/xef/xa9/x8a", "CJK COMPATIBILITY IDEOGRAPH-FA4A");
+-   ("/xef/xa9/x8b", "CJK COMPATIBILITY IDEOGRAPH-FA4B");
+-   ("/xef/xa9/x8c", "CJK COMPATIBILITY IDEOGRAPH-FA4C");
+-   ("/xef/xa9/x8d", "CJK COMPATIBILITY IDEOGRAPH-FA4D");
+-   ("/xef/xa9/x8e", "CJK COMPATIBILITY IDEOGRAPH-FA4E");
+-   ("/xef/xa9/x8f", "CJK COMPATIBILITY IDEOGRAPH-FA4F");
+-   ("/xef/xa9/x90", "CJK COMPATIBILITY IDEOGRAPH-FA50");
+-   ("/xef/xa9/x91", "CJK COMPATIBILITY IDEOGRAPH-FA51");
+-   ("/xef/xa9/x92", "CJK COMPATIBILITY IDEOGRAPH-FA52");
+-   ("/xef/xa9/x93", "CJK COMPATIBILITY IDEOGRAPH-FA53");
+-   ("/xef/xa9/x94", "CJK COMPATIBILITY IDEOGRAPH-FA54");
+-   ("/xef/xa9/x95", "CJK COMPATIBILITY IDEOGRAPH-FA55");
+-   ("/xef/xa9/x96", "CJK COMPATIBILITY IDEOGRAPH-FA56");
+-   ("/xef/xa9/x97", "CJK COMPATIBILITY IDEOGRAPH-FA57");
+-   ("/xef/xa9/x98", "CJK COMPATIBILITY IDEOGRAPH-FA58");
+-   ("/xef/xa9/x99", "CJK COMPATIBILITY IDEOGRAPH-FA59");
+-   ("/xef/xa9/x9a", "CJK COMPATIBILITY IDEOGRAPH-FA5A");
+-   ("/xef/xa9/x9b", "CJK COMPATIBILITY IDEOGRAPH-FA5B");
+-   ("/xef/xa9/x9c", "CJK COMPATIBILITY IDEOGRAPH-FA5C");
+-   ("/xef/xa9/x9d", "CJK COMPATIBILITY IDEOGRAPH-FA5D");
+-   ("/xef/xa9/x9e", "CJK COMPATIBILITY IDEOGRAPH-FA5E");
+-   ("/xef/xa9/x9f", "CJK COMPATIBILITY IDEOGRAPH-FA5F");
+-   ("/xef/xa9/xa0", "CJK COMPATIBILITY IDEOGRAPH-FA60");
+-   ("/xef/xa9/xa1", "CJK COMPATIBILITY IDEOGRAPH-FA61");
+-   ("/xef/xa9/xa2", "CJK COMPATIBILITY IDEOGRAPH-FA62");
+-   ("/xef/xa9/xa3", "CJK COMPATIBILITY IDEOGRAPH-FA63");
+-   ("/xef/xa9/xa4", "CJK COMPATIBILITY IDEOGRAPH-FA64");
+-   ("/xef/xa9/xa5", "CJK COMPATIBILITY IDEOGRAPH-FA65");
+-   ("/xef/xa9/xa6", "CJK COMPATIBILITY IDEOGRAPH-FA66");
+-   ("/xef/xa9/xa7", "CJK COMPATIBILITY IDEOGRAPH-FA67");
+-   ("/xef/xa9/xa8", "CJK COMPATIBILITY IDEOGRAPH-FA68");
+-   ("/xef/xa9/xa9", "CJK COMPATIBILITY IDEOGRAPH-FA69");
+-   ("/xef/xa9/xaa", "CJK COMPATIBILITY IDEOGRAPH-FA6A");
+-   ("/xef/xa9/xb0", "CJK COMPATIBILITY IDEOGRAPH-FA70");
+-   ("/xef/xa9/xb1", "CJK COMPATIBILITY IDEOGRAPH-FA71");
+-   ("/xef/xa9/xb2", "CJK COMPATIBILITY IDEOGRAPH-FA72");
+-   ("/xef/xa9/xb3", "CJK COMPATIBILITY IDEOGRAPH-FA73");
+-   ("/xef/xa9/xb4", "CJK COMPATIBILITY IDEOGRAPH-FA74");
+-   ("/xef/xa9/xb5", "CJK COMPATIBILITY IDEOGRAPH-FA75");
+-   ("/xef/xa9/xb6", "CJK COMPATIBILITY IDEOGRAPH-FA76");
+-   ("/xef/xa9/xb7", "CJK COMPATIBILITY IDEOGRAPH-FA77");
+-   ("/xef/xa9/xb8", "CJK COMPATIBILITY IDEOGRAPH-FA78");
+-   ("/xef/xa9/xb9", "CJK COMPATIBILITY IDEOGRAPH-FA79");
+-   ("/xef/xa9/xba", "CJK COMPATIBILITY IDEOGRAPH-FA7A");
+-   ("/xef/xa9/xbb", "CJK COMPATIBILITY IDEOGRAPH-FA7B");
+-   ("/xef/xa9/xbc", "CJK COMPATIBILITY IDEOGRAPH-FA7C");
+-   ("/xef/xa9/xbd", "CJK COMPATIBILITY IDEOGRAPH-FA7D");
+-   ("/xef/xa9/xbe", "CJK COMPATIBILITY IDEOGRAPH-FA7E");
+-   ("/xef/xa9/xbf", "CJK COMPATIBILITY IDEOGRAPH-FA7F");
+-   ("/xef/xaa/x80", "CJK COMPATIBILITY IDEOGRAPH-FA80");
+-   ("/xef/xaa/x81", "CJK COMPATIBILITY IDEOGRAPH-FA81");
+-   ("/xef/xaa/x82", "CJK COMPATIBILITY IDEOGRAPH-FA82");
+-   ("/xef/xaa/x83", "CJK COMPATIBILITY IDEOGRAPH-FA83");
+-   ("/xef/xaa/x84", "CJK COMPATIBILITY IDEOGRAPH-FA84");
+-   ("/xef/xaa/x85", "CJK COMPATIBILITY IDEOGRAPH-FA85");
+-   ("/xef/xaa/x86", "CJK COMPATIBILITY IDEOGRAPH-FA86");
+-   ("/xef/xaa/x87", "CJK COMPATIBILITY IDEOGRAPH-FA87");
+-   ("/xef/xaa/x88", "CJK COMPATIBILITY IDEOGRAPH-FA88");
+-   ("/xef/xaa/x89", "CJK COMPATIBILITY IDEOGRAPH-FA89");
+-   ("/xef/xaa/x8a", "CJK COMPATIBILITY IDEOGRAPH-FA8A");
+-   ("/xef/xaa/x8b", "CJK COMPATIBILITY IDEOGRAPH-FA8B");
+-   ("/xef/xaa/x8c", "CJK COMPATIBILITY IDEOGRAPH-FA8C");
+-   ("/xef/xaa/x8d", "CJK COMPATIBILITY IDEOGRAPH-FA8D");
+-   ("/xef/xaa/x8e", "CJK COMPATIBILITY IDEOGRAPH-FA8E");
+-   ("/xef/xaa/x8f", "CJK COMPATIBILITY IDEOGRAPH-FA8F");
+-   ("/xef/xaa/x90", "CJK COMPATIBILITY IDEOGRAPH-FA90");
+-   ("/xef/xaa/x91", "CJK COMPATIBILITY IDEOGRAPH-FA91");
+-   ("/xef/xaa/x92", "CJK COMPATIBILITY IDEOGRAPH-FA92");
+-   ("/xef/xaa/x93", "CJK COMPATIBILITY IDEOGRAPH-FA93");
+-   ("/xef/xaa/x94", "CJK COMPATIBILITY IDEOGRAPH-FA94");
+-   ("/xef/xaa/x95", "CJK COMPATIBILITY IDEOGRAPH-FA95");
+-   ("/xef/xaa/x96", "CJK COMPATIBILITY IDEOGRAPH-FA96");
+-   ("/xef/xaa/x97", "CJK COMPATIBILITY IDEOGRAPH-FA97");
+-   ("/xef/xaa/x98", "CJK COMPATIBILITY IDEOGRAPH-FA98");
+-   ("/xef/xaa/x99", "CJK COMPATIBILITY IDEOGRAPH-FA99");
+-   ("/xef/xaa/x9a", "CJK COMPATIBILITY IDEOGRAPH-FA9A");
+-   ("/xef/xaa/x9b", "CJK COMPATIBILITY IDEOGRAPH-FA9B");
+-   ("/xef/xaa/x9c", "CJK COMPATIBILITY IDEOGRAPH-FA9C");
+-   ("/xef/xaa/x9d", "CJK COMPATIBILITY IDEOGRAPH-FA9D");
+-   ("/xef/xaa/x9e", "CJK COMPATIBILITY IDEOGRAPH-FA9E");
+-   ("/xef/xaa/x9f", "CJK COMPATIBILITY IDEOGRAPH-FA9F");
+-   ("/xef/xaa/xa0", "CJK COMPATIBILITY IDEOGRAPH-FAA0");
+-   ("/xef/xaa/xa1", "CJK COMPATIBILITY IDEOGRAPH-FAA1");
+-   ("/xef/xaa/xa2", "CJK COMPATIBILITY IDEOGRAPH-FAA2");
+-   ("/xef/xaa/xa3", "CJK COMPATIBILITY IDEOGRAPH-FAA3");
+-   ("/xef/xaa/xa4", "CJK COMPATIBILITY IDEOGRAPH-FAA4");
+-   ("/xef/xaa/xa5", "CJK COMPATIBILITY IDEOGRAPH-FAA5");
+-   ("/xef/xaa/xa6", "CJK COMPATIBILITY IDEOGRAPH-FAA6");
+-   ("/xef/xaa/xa7", "CJK COMPATIBILITY IDEOGRAPH-FAA7");
+-   ("/xef/xaa/xa8", "CJK COMPATIBILITY IDEOGRAPH-FAA8");
+-   ("/xef/xaa/xa9", "CJK COMPATIBILITY IDEOGRAPH-FAA9");
+-   ("/xef/xaa/xaa", "CJK COMPATIBILITY IDEOGRAPH-FAAA");
+-   ("/xef/xaa/xab", "CJK COMPATIBILITY IDEOGRAPH-FAAB");
+-   ("/xef/xaa/xac", "CJK COMPATIBILITY IDEOGRAPH-FAAC");
+-   ("/xef/xaa/xad", "CJK COMPATIBILITY IDEOGRAPH-FAAD");
+-   ("/xef/xaa/xae", "CJK COMPATIBILITY IDEOGRAPH-FAAE");
+-   ("/xef/xaa/xaf", "CJK COMPATIBILITY IDEOGRAPH-FAAF");
+-   ("/xef/xaa/xb0", "CJK COMPATIBILITY IDEOGRAPH-FAB0");
+-   ("/xef/xaa/xb1", "CJK COMPATIBILITY IDEOGRAPH-FAB1");
+-   ("/xef/xaa/xb2", "CJK COMPATIBILITY IDEOGRAPH-FAB2");
+-   ("/xef/xaa/xb3", "CJK COMPATIBILITY IDEOGRAPH-FAB3");
+-   ("/xef/xaa/xb4", "CJK COMPATIBILITY IDEOGRAPH-FAB4");
+-   ("/xef/xaa/xb5", "CJK COMPATIBILITY IDEOGRAPH-FAB5");
+-   ("/xef/xaa/xb6", "CJK COMPATIBILITY IDEOGRAPH-FAB6");
+-   ("/xef/xaa/xb7", "CJK COMPATIBILITY IDEOGRAPH-FAB7");
+-   ("/xef/xaa/xb8", "CJK COMPATIBILITY IDEOGRAPH-FAB8");
+-   ("/xef/xaa/xb9", "CJK COMPATIBILITY IDEOGRAPH-FAB9");
+-   ("/xef/xaa/xba", "CJK COMPATIBILITY IDEOGRAPH-FABA");
+-   ("/xef/xaa/xbb", "CJK COMPATIBILITY IDEOGRAPH-FABB");
+-   ("/xef/xaa/xbc", "CJK COMPATIBILITY IDEOGRAPH-FABC");
+-   ("/xef/xaa/xbd", "CJK COMPATIBILITY IDEOGRAPH-FABD");
+-   ("/xef/xaa/xbe", "CJK COMPATIBILITY IDEOGRAPH-FABE");
+-   ("/xef/xaa/xbf", "CJK COMPATIBILITY IDEOGRAPH-FABF");
+-   ("/xef/xab/x80", "CJK COMPATIBILITY IDEOGRAPH-FAC0");
+-   ("/xef/xab/x81", "CJK COMPATIBILITY IDEOGRAPH-FAC1");
+-   ("/xef/xab/x82", "CJK COMPATIBILITY IDEOGRAPH-FAC2");
+-   ("/xef/xab/x83", "CJK COMPATIBILITY IDEOGRAPH-FAC3");
+-   ("/xef/xab/x84", "CJK COMPATIBILITY IDEOGRAPH-FAC4");
+-   ("/xef/xab/x85", "CJK COMPATIBILITY IDEOGRAPH-FAC5");
+-   ("/xef/xab/x86", "CJK COMPATIBILITY IDEOGRAPH-FAC6");
+-   ("/xef/xab/x87", "CJK COMPATIBILITY IDEOGRAPH-FAC7");
+-   ("/xef/xab/x88", "CJK COMPATIBILITY IDEOGRAPH-FAC8");
+-   ("/xef/xab/x89", "CJK COMPATIBILITY IDEOGRAPH-FAC9");
+-   ("/xef/xab/x8a", "CJK COMPATIBILITY IDEOGRAPH-FACA");
+-   ("/xef/xab/x8b", "CJK COMPATIBILITY IDEOGRAPH-FACB");
+-   ("/xef/xab/x8c", "CJK COMPATIBILITY IDEOGRAPH-FACC");
+-   ("/xef/xab/x8d", "CJK COMPATIBILITY IDEOGRAPH-FACD");
+-   ("/xef/xab/x8e", "CJK COMPATIBILITY IDEOGRAPH-FACE");
+-   ("/xef/xab/x8f", "CJK COMPATIBILITY IDEOGRAPH-FACF");
+-   ("/xef/xab/x90", "CJK COMPATIBILITY IDEOGRAPH-FAD0");
+-   ("/xef/xab/x91", "CJK COMPATIBILITY IDEOGRAPH-FAD1");
+-   ("/xef/xab/x92", "CJK COMPATIBILITY IDEOGRAPH-FAD2");
+-   ("/xef/xab/x93", "CJK COMPATIBILITY IDEOGRAPH-FAD3");
+-   ("/xef/xab/x94", "CJK COMPATIBILITY IDEOGRAPH-FAD4");
+-   ("/xef/xab/x95", "CJK COMPATIBILITY IDEOGRAPH-FAD5");
+-   ("/xef/xab/x96", "CJK COMPATIBILITY IDEOGRAPH-FAD6");
+-   ("/xef/xab/x97", "CJK COMPATIBILITY IDEOGRAPH-FAD7");
+-   ("/xef/xab/x98", "CJK COMPATIBILITY IDEOGRAPH-FAD8");
+-   ("/xef/xab/x99", "CJK COMPATIBILITY IDEOGRAPH-FAD9");
+    ("/xef/xac/x80", "LATIN SMALL LIGATURE FF");
+    ("/xef/xac/x81", "LATIN SMALL LIGATURE FI");
+    ("/xef/xac/x82", "LATIN SMALL LIGATURE FL");
+@@ -25323,712 +2479,6 @@
+    ("/xef/xac/x95", "ARMENIAN SMALL LIGATURE MEN INI");
+    ("/xef/xac/x96", "ARMENIAN SMALL LIGATURE VEW NOW");
+    ("/xef/xac/x97", "ARMENIAN SMALL LIGATURE MEN XEH");
+-   ("/xef/xac/x9d", "HEBREW LETTER YOD WITH HIRIQ");
+-   ("/xef/xac/x9e", "HEBREW POINT JUDEO-SPANISH VARIKA");
+-   ("/xef/xac/x9f", "HEBREW LIGATURE YIDDISH YOD YOD PATAH");
+-   ("/xef/xac/xa0", "HEBREW LETTER ALTERNATIVE AYIN");
+-   ("/xef/xac/xa1", "HEBREW LETTER WIDE ALEF");
+-   ("/xef/xac/xa2", "HEBREW LETTER WIDE DALET");
+-   ("/xef/xac/xa3", "HEBREW LETTER WIDE HE");
+-   ("/xef/xac/xa4", "HEBREW LETTER WIDE KAF");
+-   ("/xef/xac/xa5", "HEBREW LETTER WIDE LAMED");
+-   ("/xef/xac/xa6", "HEBREW LETTER WIDE FINAL MEM");
+-   ("/xef/xac/xa7", "HEBREW LETTER WIDE RESH");
+-   ("/xef/xac/xa8", "HEBREW LETTER WIDE TAV");
+-   ("/xef/xac/xa9", "HEBREW LETTER ALTERNATIVE PLUS SIGN");
+-   ("/xef/xac/xaa", "HEBREW LETTER SHIN WITH SHIN DOT");
+-   ("/xef/xac/xab", "HEBREW LETTER SHIN WITH SIN DOT");
+-   ("/xef/xac/xac", "HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT");
+-   ("/xef/xac/xad", "HEBREW LETTER SHIN WITH DAGESH AND SIN DOT");
+-   ("/xef/xac/xae", "HEBREW LETTER ALEF WITH PATAH");
+-   ("/xef/xac/xaf", "HEBREW LETTER ALEF WITH QAMATS");
+-   ("/xef/xac/xb0", "HEBREW LETTER ALEF WITH MAPIQ");
+-   ("/xef/xac/xb1", "HEBREW LETTER BET WITH DAGESH");
+-   ("/xef/xac/xb2", "HEBREW LETTER GIMEL WITH DAGESH");
+-   ("/xef/xac/xb3", "HEBREW LETTER DALET WITH DAGESH");
+-   ("/xef/xac/xb4", "HEBREW LETTER HE WITH MAPIQ");
+-   ("/xef/xac/xb5", "HEBREW LETTER VAV WITH DAGESH");
+-   ("/xef/xac/xb6", "HEBREW LETTER ZAYIN WITH DAGESH");
+-   ("/xef/xac/xb8", "HEBREW LETTER TET WITH DAGESH");
+-   ("/xef/xac/xb9", "HEBREW LETTER YOD WITH DAGESH");
+-   ("/xef/xac/xba", "HEBREW LETTER FINAL KAF WITH DAGESH");
+-   ("/xef/xac/xbb", "HEBREW LETTER KAF WITH DAGESH");
+-   ("/xef/xac/xbc", "HEBREW LETTER LAMED WITH DAGESH");
+-   ("/xef/xac/xbe", "HEBREW LETTER MEM WITH DAGESH");
+-   ("/xef/xad/x80", "HEBREW LETTER NUN WITH DAGESH");
+-   ("/xef/xad/x81", "HEBREW LETTER SAMEKH WITH DAGESH");
+-   ("/xef/xad/x83", "HEBREW LETTER FINAL PE WITH DAGESH");
+-   ("/xef/xad/x84", "HEBREW LETTER PE WITH DAGESH");
+-   ("/xef/xad/x86", "HEBREW LETTER TSADI WITH DAGESH");
+-   ("/xef/xad/x87", "HEBREW LETTER QOF WITH DAGESH");
+-   ("/xef/xad/x88", "HEBREW LETTER RESH WITH DAGESH");
+-   ("/xef/xad/x89", "HEBREW LETTER SHIN WITH DAGESH");
+-   ("/xef/xad/x8a", "HEBREW LETTER TAV WITH DAGESH");
+-   ("/xef/xad/x8b", "HEBREW LETTER VAV WITH HOLAM");
+-   ("/xef/xad/x8c", "HEBREW LETTER BET WITH RAFE");
+-   ("/xef/xad/x8d", "HEBREW LETTER KAF WITH RAFE");
+-   ("/xef/xad/x8e", "HEBREW LETTER PE WITH RAFE");
+-   ("/xef/xad/x8f", "HEBREW LIGATURE ALEF LAMED");
+-   ("/xef/xad/x90", "ARABIC LETTER ALEF WASLA ISOLATED FORM");
+-   ("/xef/xad/x91", "ARABIC LETTER ALEF WASLA FINAL FORM");
+-   ("/xef/xad/x92", "ARABIC LETTER BEEH ISOLATED FORM");
+-   ("/xef/xad/x93", "ARABIC LETTER BEEH FINAL FORM");
+-   ("/xef/xad/x94", "ARABIC LETTER BEEH INITIAL FORM");
+-   ("/xef/xad/x95", "ARABIC LETTER BEEH MEDIAL FORM");
+-   ("/xef/xad/x96", "ARABIC LETTER PEH ISOLATED FORM");
+-   ("/xef/xad/x97", "ARABIC LETTER PEH FINAL FORM");
+-   ("/xef/xad/x98", "ARABIC LETTER PEH INITIAL FORM");
+-   ("/xef/xad/x99", "ARABIC LETTER PEH MEDIAL FORM");
+-   ("/xef/xad/x9a", "ARABIC LETTER BEHEH ISOLATED FORM");
+-   ("/xef/xad/x9b", "ARABIC LETTER BEHEH FINAL FORM");
+-   ("/xef/xad/x9c", "ARABIC LETTER BEHEH INITIAL FORM");
+-   ("/xef/xad/x9d", "ARABIC LETTER BEHEH MEDIAL FORM");
+-   ("/xef/xad/x9e", "ARABIC LETTER TTEHEH ISOLATED FORM");
+-   ("/xef/xad/x9f", "ARABIC LETTER TTEHEH FINAL FORM");
+-   ("/xef/xad/xa0", "ARABIC LETTER TTEHEH INITIAL FORM");
+-   ("/xef/xad/xa1", "ARABIC LETTER TTEHEH MEDIAL FORM");
+-   ("/xef/xad/xa2", "ARABIC LETTER TEHEH ISOLATED FORM");
+-   ("/xef/xad/xa3", "ARABIC LETTER TEHEH FINAL FORM");
+-   ("/xef/xad/xa4", "ARABIC LETTER TEHEH INITIAL FORM");
+-   ("/xef/xad/xa5", "ARABIC LETTER TEHEH MEDIAL FORM");
+-   ("/xef/xad/xa6", "ARABIC LETTER TTEH ISOLATED FORM");
+-   ("/xef/xad/xa7", "ARABIC LETTER TTEH FINAL FORM");
+-   ("/xef/xad/xa8", "ARABIC LETTER TTEH INITIAL FORM");
+-   ("/xef/xad/xa9", "ARABIC LETTER TTEH MEDIAL FORM");
+-   ("/xef/xad/xaa", "ARABIC LETTER VEH ISOLATED FORM");
+-   ("/xef/xad/xab", "ARABIC LETTER VEH FINAL FORM");
+-   ("/xef/xad/xac", "ARABIC LETTER VEH INITIAL FORM");
+-   ("/xef/xad/xad", "ARABIC LETTER VEH MEDIAL FORM");
+-   ("/xef/xad/xae", "ARABIC LETTER PEHEH ISOLATED FORM");
+-   ("/xef/xad/xaf", "ARABIC LETTER PEHEH FINAL FORM");
+-   ("/xef/xad/xb0", "ARABIC LETTER PEHEH INITIAL FORM");
+-   ("/xef/xad/xb1", "ARABIC LETTER PEHEH MEDIAL FORM");
+-   ("/xef/xad/xb2", "ARABIC LETTER DYEH ISOLATED FORM");
+-   ("/xef/xad/xb3", "ARABIC LETTER DYEH FINAL FORM");
+-   ("/xef/xad/xb4", "ARABIC LETTER DYEH INITIAL FORM");
+-   ("/xef/xad/xb5", "ARABIC LETTER DYEH MEDIAL FORM");
+-   ("/xef/xad/xb6", "ARABIC LETTER NYEH ISOLATED FORM");
+-   ("/xef/xad/xb7", "ARABIC LETTER NYEH FINAL FORM");
+-   ("/xef/xad/xb8", "ARABIC LETTER NYEH INITIAL FORM");
+-   ("/xef/xad/xb9", "ARABIC LETTER NYEH MEDIAL FORM");
+-   ("/xef/xad/xba", "ARABIC LETTER TCHEH ISOLATED FORM");
+-   ("/xef/xad/xbb", "ARABIC LETTER TCHEH FINAL FORM");
+-   ("/xef/xad/xbc", "ARABIC LETTER TCHEH INITIAL FORM");
+-   ("/xef/xad/xbd", "ARABIC LETTER TCHEH MEDIAL FORM");
+-   ("/xef/xad/xbe", "ARABIC LETTER TCHEHEH ISOLATED FORM");
+-   ("/xef/xad/xbf", "ARABIC LETTER TCHEHEH FINAL FORM");
+-   ("/xef/xae/x80", "ARABIC LETTER TCHEHEH INITIAL FORM");
+-   ("/xef/xae/x81", "ARABIC LETTER TCHEHEH MEDIAL FORM");
+-   ("/xef/xae/x82", "ARABIC LETTER DDAHAL ISOLATED FORM");
+-   ("/xef/xae/x83", "ARABIC LETTER DDAHAL FINAL FORM");
+-   ("/xef/xae/x84", "ARABIC LETTER DAHAL ISOLATED FORM");
+-   ("/xef/xae/x85", "ARABIC LETTER DAHAL FINAL FORM");
+-   ("/xef/xae/x86", "ARABIC LETTER DUL ISOLATED FORM");
+-   ("/xef/xae/x87", "ARABIC LETTER DUL FINAL FORM");
+-   ("/xef/xae/x88", "ARABIC LETTER DDAL ISOLATED FORM");
+-   ("/xef/xae/x89", "ARABIC LETTER DDAL FINAL FORM");
+-   ("/xef/xae/x8a", "ARABIC LETTER JEH ISOLATED FORM");
+-   ("/xef/xae/x8b", "ARABIC LETTER JEH FINAL FORM");
+-   ("/xef/xae/x8c", "ARABIC LETTER RREH ISOLATED FORM");
+-   ("/xef/xae/x8d", "ARABIC LETTER RREH FINAL FORM");
+-   ("/xef/xae/x8e", "ARABIC LETTER KEHEH ISOLATED FORM");
+-   ("/xef/xae/x8f", "ARABIC LETTER KEHEH FINAL FORM");
+-   ("/xef/xae/x90", "ARABIC LETTER KEHEH INITIAL FORM");
+-   ("/xef/xae/x91", "ARABIC LETTER KEHEH MEDIAL FORM");
+-   ("/xef/xae/x92", "ARABIC LETTER GAF ISOLATED FORM");
+-   ("/xef/xae/x93", "ARABIC LETTER GAF FINAL FORM");
+-   ("/xef/xae/x94", "ARABIC LETTER GAF INITIAL FORM");
+-   ("/xef/xae/x95", "ARABIC LETTER GAF MEDIAL FORM");
+-   ("/xef/xae/x96", "ARABIC LETTER GUEH ISOLATED FORM");
+-   ("/xef/xae/x97", "ARABIC LETTER GUEH FINAL FORM");
+-   ("/xef/xae/x98", "ARABIC LETTER GUEH INITIAL FORM");
+-   ("/xef/xae/x99", "ARABIC LETTER GUEH MEDIAL FORM");
+-   ("/xef/xae/x9a", "ARABIC LETTER NGOEH ISOLATED FORM");
+-   ("/xef/xae/x9b", "ARABIC LETTER NGOEH FINAL FORM");
+-   ("/xef/xae/x9c", "ARABIC LETTER NGOEH INITIAL FORM");
+-   ("/xef/xae/x9d", "ARABIC LETTER NGOEH MEDIAL FORM");
+-   ("/xef/xae/x9e", "ARABIC LETTER NOON GHUNNA ISOLATED FORM");
+-   ("/xef/xae/x9f", "ARABIC LETTER NOON GHUNNA FINAL FORM");
+-   ("/xef/xae/xa0", "ARABIC LETTER RNOON ISOLATED FORM");
+-   ("/xef/xae/xa1", "ARABIC LETTER RNOON FINAL FORM");
+-   ("/xef/xae/xa2", "ARABIC LETTER RNOON INITIAL FORM");
+-   ("/xef/xae/xa3", "ARABIC LETTER RNOON MEDIAL FORM");
+-   ("/xef/xae/xa4", "ARABIC LETTER HEH WITH YEH ABOVE ISOLATED FORM");
+-   ("/xef/xae/xa5", "ARABIC LETTER HEH WITH YEH ABOVE FINAL FORM");
+-   ("/xef/xae/xa6", "ARABIC LETTER HEH GOAL ISOLATED FORM");
+-   ("/xef/xae/xa7", "ARABIC LETTER HEH GOAL FINAL FORM");
+-   ("/xef/xae/xa8", "ARABIC LETTER HEH GOAL INITIAL FORM");
+-   ("/xef/xae/xa9", "ARABIC LETTER HEH GOAL MEDIAL FORM");
+-   ("/xef/xae/xaa", "ARABIC LETTER HEH DOACHASHMEE ISOLATED FORM");
+-   ("/xef/xae/xab", "ARABIC LETTER HEH DOACHASHMEE FINAL FORM");
+-   ("/xef/xae/xac", "ARABIC LETTER HEH DOACHASHMEE INITIAL FORM");
+-   ("/xef/xae/xad", "ARABIC LETTER HEH DOACHASHMEE MEDIAL FORM");
+-   ("/xef/xae/xae", "ARABIC LETTER YEH BARREE ISOLATED FORM");
+-   ("/xef/xae/xaf", "ARABIC LETTER YEH BARREE FINAL FORM");
+-   ("/xef/xae/xb0", "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xae/xb1", "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM");
+-   ("/xef/xaf/x93", "ARABIC LETTER NG ISOLATED FORM");
+-   ("/xef/xaf/x94", "ARABIC LETTER NG FINAL FORM");
+-   ("/xef/xaf/x95", "ARABIC LETTER NG INITIAL FORM");
+-   ("/xef/xaf/x96", "ARABIC LETTER NG MEDIAL FORM");
+-   ("/xef/xaf/x97", "ARABIC LETTER U ISOLATED FORM");
+-   ("/xef/xaf/x98", "ARABIC LETTER U FINAL FORM");
+-   ("/xef/xaf/x99", "ARABIC LETTER OE ISOLATED FORM");
+-   ("/xef/xaf/x9a", "ARABIC LETTER OE FINAL FORM");
+-   ("/xef/xaf/x9b", "ARABIC LETTER YU ISOLATED FORM");
+-   ("/xef/xaf/x9c", "ARABIC LETTER YU FINAL FORM");
+-   ("/xef/xaf/x9d", "ARABIC LETTER U WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xaf/x9e", "ARABIC LETTER VE ISOLATED FORM");
+-   ("/xef/xaf/x9f", "ARABIC LETTER VE FINAL FORM");
+-   ("/xef/xaf/xa0", "ARABIC LETTER KIRGHIZ OE ISOLATED FORM");
+-   ("/xef/xaf/xa1", "ARABIC LETTER KIRGHIZ OE FINAL FORM");
+-   ("/xef/xaf/xa2", "ARABIC LETTER KIRGHIZ YU ISOLATED FORM");
+-   ("/xef/xaf/xa3", "ARABIC LETTER KIRGHIZ YU FINAL FORM");
+-   ("/xef/xaf/xa4", "ARABIC LETTER E ISOLATED FORM");
+-   ("/xef/xaf/xa5", "ARABIC LETTER E FINAL FORM");
+-   ("/xef/xaf/xa6", "ARABIC LETTER E INITIAL FORM");
+-   ("/xef/xaf/xa7", "ARABIC LETTER E MEDIAL FORM");
+-   ("/xef/xaf/xa8", "ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA INITIAL FORM");
+-   ("/xef/xaf/xa9", "ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MEDIAL FORM");
+-   ("/xef/xaf/xaa", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF ISOLATED FORM");
+-   ("/xef/xaf/xab", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF FINAL FORM");
+-   ("/xef/xaf/xac", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE ISOLATED FORM");
+-   ("/xef/xaf/xad", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE FINAL FORM");
+-   ("/xef/xaf/xae", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW ISOLATED FORM");
+-   ("/xef/xaf/xaf", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW FINAL FORM");
+-   ("/xef/xaf/xb0", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U ISOLATED FORM");
+-   ("/xef/xaf/xb1", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U FINAL FORM");
+-   ("/xef/xaf/xb2", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE ISOLATED FORM");
+-   ("/xef/xaf/xb3", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE FINAL FORM");
+-   ("/xef/xaf/xb4", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU ISOLATED FORM");
+-   ("/xef/xaf/xb5", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU FINAL FORM");
+-   ("/xef/xaf/xb6", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E ISOLATED FORM");
+-   ("/xef/xaf/xb7", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E FINAL FORM");
+-   ("/xef/xaf/xb8", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E INITIAL FORM");
+-   ("/xef/xaf/xb9", "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xaf/xba", "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xaf/xbb", "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM");
+-   ("/xef/xaf/xbc", "ARABIC LETTER FARSI YEH ISOLATED FORM");
+-   ("/xef/xaf/xbd", "ARABIC LETTER FARSI YEH FINAL FORM");
+-   ("/xef/xaf/xbe", "ARABIC LETTER FARSI YEH INITIAL FORM");
+-   ("/xef/xaf/xbf", "ARABIC LETTER FARSI YEH MEDIAL FORM");
+-   ("/xef/xb0/x80", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x81", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x82", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x83", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/x84", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/x85", "ARABIC LIGATURE BEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x86", "ARABIC LIGATURE BEH WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x87", "ARABIC LIGATURE BEH WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/x88", "ARABIC LIGATURE BEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x89", "ARABIC LIGATURE BEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/x8a", "ARABIC LIGATURE BEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/x8b", "ARABIC LIGATURE TEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x8c", "ARABIC LIGATURE TEH WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x8d", "ARABIC LIGATURE TEH WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/x8e", "ARABIC LIGATURE TEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x8f", "ARABIC LIGATURE TEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/x90", "ARABIC LIGATURE TEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/x91", "ARABIC LIGATURE THEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x92", "ARABIC LIGATURE THEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x93", "ARABIC LIGATURE THEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/x94", "ARABIC LIGATURE THEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/x95", "ARABIC LIGATURE JEEM WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x96", "ARABIC LIGATURE JEEM WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x97", "ARABIC LIGATURE HAH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x98", "ARABIC LIGATURE HAH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x99", "ARABIC LIGATURE KHAH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x9a", "ARABIC LIGATURE KHAH WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x9b", "ARABIC LIGATURE KHAH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/x9c", "ARABIC LIGATURE SEEN WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/x9d", "ARABIC LIGATURE SEEN WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/x9e", "ARABIC LIGATURE SEEN WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/x9f", "ARABIC LIGATURE SEEN WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xa0", "ARABIC LIGATURE SAD WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xa1", "ARABIC LIGATURE SAD WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xa2", "ARABIC LIGATURE DAD WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/xa3", "ARABIC LIGATURE DAD WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xa4", "ARABIC LIGATURE DAD WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/xa5", "ARABIC LIGATURE DAD WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xa6", "ARABIC LIGATURE TAH WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xa7", "ARABIC LIGATURE TAH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xa8", "ARABIC LIGATURE ZAH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xa9", "ARABIC LIGATURE AIN WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/xaa", "ARABIC LIGATURE AIN WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xab", "ARABIC LIGATURE GHAIN WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/xac", "ARABIC LIGATURE GHAIN WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xad", "ARABIC LIGATURE FEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/xae", "ARABIC LIGATURE FEH WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xaf", "ARABIC LIGATURE FEH WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/xb0", "ARABIC LIGATURE FEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xb1", "ARABIC LIGATURE FEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/xb2", "ARABIC LIGATURE FEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/xb3", "ARABIC LIGATURE QAF WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xb4", "ARABIC LIGATURE QAF WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xb5", "ARABIC LIGATURE QAF WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/xb6", "ARABIC LIGATURE QAF WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/xb7", "ARABIC LIGATURE KAF WITH ALEF ISOLATED FORM");
+-   ("/xef/xb0/xb8", "ARABIC LIGATURE KAF WITH JEEM ISOLATED FORM");
+-   ("/xef/xb0/xb9", "ARABIC LIGATURE KAF WITH HAH ISOLATED FORM");
+-   ("/xef/xb0/xba", "ARABIC LIGATURE KAF WITH KHAH ISOLATED FORM");
+-   ("/xef/xb0/xbb", "ARABIC LIGATURE KAF WITH LAM ISOLATED FORM");
+-   ("/xef/xb0/xbc", "ARABIC LIGATURE KAF WITH MEEM ISOLATED FORM");
+-   ("/xef/xb0/xbd", "ARABIC LIGATURE KAF WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb0/xbe", "ARABIC LIGATURE KAF WITH YEH ISOLATED FORM");
+-   ("/xef/xb0/xbf", "ARABIC LIGATURE LAM WITH JEEM ISOLATED FORM");
+-   ("/xef/xb1/x80", "ARABIC LIGATURE LAM WITH HAH ISOLATED FORM");
+-   ("/xef/xb1/x81", "ARABIC LIGATURE LAM WITH KHAH ISOLATED FORM");
+-   ("/xef/xb1/x82", "ARABIC LIGATURE LAM WITH MEEM ISOLATED FORM");
+-   ("/xef/xb1/x83", "ARABIC LIGATURE LAM WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb1/x84", "ARABIC LIGATURE LAM WITH YEH ISOLATED FORM");
+-   ("/xef/xb1/x85", "ARABIC LIGATURE MEEM WITH JEEM ISOLATED FORM");
+-   ("/xef/xb1/x86", "ARABIC LIGATURE MEEM WITH HAH ISOLATED FORM");
+-   ("/xef/xb1/x87", "ARABIC LIGATURE MEEM WITH KHAH ISOLATED FORM");
+-   ("/xef/xb1/x88", "ARABIC LIGATURE MEEM WITH MEEM ISOLATED FORM");
+-   ("/xef/xb1/x89", "ARABIC LIGATURE MEEM WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb1/x8a", "ARABIC LIGATURE MEEM WITH YEH ISOLATED FORM");
+-   ("/xef/xb1/x8b", "ARABIC LIGATURE NOON WITH JEEM ISOLATED FORM");
+-   ("/xef/xb1/x8c", "ARABIC LIGATURE NOON WITH HAH ISOLATED FORM");
+-   ("/xef/xb1/x8d", "ARABIC LIGATURE NOON WITH KHAH ISOLATED FORM");
+-   ("/xef/xb1/x8e", "ARABIC LIGATURE NOON WITH MEEM ISOLATED FORM");
+-   ("/xef/xb1/x8f", "ARABIC LIGATURE NOON WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb1/x90", "ARABIC LIGATURE NOON WITH YEH ISOLATED FORM");
+-   ("/xef/xb1/x91", "ARABIC LIGATURE HEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb1/x92", "ARABIC LIGATURE HEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb1/x93", "ARABIC LIGATURE HEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb1/x94", "ARABIC LIGATURE HEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb1/x95", "ARABIC LIGATURE YEH WITH JEEM ISOLATED FORM");
+-   ("/xef/xb1/x96", "ARABIC LIGATURE YEH WITH HAH ISOLATED FORM");
+-   ("/xef/xb1/x97", "ARABIC LIGATURE YEH WITH KHAH ISOLATED FORM");
+-   ("/xef/xb1/x98", "ARABIC LIGATURE YEH WITH MEEM ISOLATED FORM");
+-   ("/xef/xb1/x99", "ARABIC LIGATURE YEH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb1/x9a", "ARABIC LIGATURE YEH WITH YEH ISOLATED FORM");
+-   ("/xef/xb1/x9b", "ARABIC LIGATURE THAL WITH SUPERSCRIPT ALEF ISOLATED FORM");
+-   ("/xef/xb1/x9c", "ARABIC LIGATURE REH WITH SUPERSCRIPT ALEF ISOLATED FORM");
+-   ("/xef/xb1/x9d", "ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF ISOLATED FORM");
+-   ("/xef/xb1/x9e", "ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM");
+-   ("/xef/xb1/x9f", "ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM");
+-   ("/xef/xb1/xa0", "ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM");
+-   ("/xef/xb1/xa1", "ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM");
+-   ("/xef/xb1/xa2", "ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM");
+-   ("/xef/xb1/xa3", "ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM");
+-   ("/xef/xb1/xa4", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH REH FINAL FORM");
+-   ("/xef/xb1/xa5", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ZAIN FINAL FORM");
+-   ("/xef/xb1/xa6", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM FINAL FORM");
+-   ("/xef/xb1/xa7", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH NOON FINAL FORM");
+-   ("/xef/xb1/xa8", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xa9", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH FINAL FORM");
+-   ("/xef/xb1/xaa", "ARABIC LIGATURE BEH WITH REH FINAL FORM");
+-   ("/xef/xb1/xab", "ARABIC LIGATURE BEH WITH ZAIN FINAL FORM");
+-   ("/xef/xb1/xac", "ARABIC LIGATURE BEH WITH MEEM FINAL FORM");
+-   ("/xef/xb1/xad", "ARABIC LIGATURE BEH WITH NOON FINAL FORM");
+-   ("/xef/xb1/xae", "ARABIC LIGATURE BEH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xaf", "ARABIC LIGATURE BEH WITH YEH FINAL FORM");
+-   ("/xef/xb1/xb0", "ARABIC LIGATURE TEH WITH REH FINAL FORM");
+-   ("/xef/xb1/xb1", "ARABIC LIGATURE TEH WITH ZAIN FINAL FORM");
+-   ("/xef/xb1/xb2", "ARABIC LIGATURE TEH WITH MEEM FINAL FORM");
+-   ("/xef/xb1/xb3", "ARABIC LIGATURE TEH WITH NOON FINAL FORM");
+-   ("/xef/xb1/xb4", "ARABIC LIGATURE TEH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xb5", "ARABIC LIGATURE TEH WITH YEH FINAL FORM");
+-   ("/xef/xb1/xb6", "ARABIC LIGATURE THEH WITH REH FINAL FORM");
+-   ("/xef/xb1/xb7", "ARABIC LIGATURE THEH WITH ZAIN FINAL FORM");
+-   ("/xef/xb1/xb8", "ARABIC LIGATURE THEH WITH MEEM FINAL FORM");
+-   ("/xef/xb1/xb9", "ARABIC LIGATURE THEH WITH NOON FINAL FORM");
+-   ("/xef/xb1/xba", "ARABIC LIGATURE THEH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xbb", "ARABIC LIGATURE THEH WITH YEH FINAL FORM");
+-   ("/xef/xb1/xbc", "ARABIC LIGATURE FEH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xbd", "ARABIC LIGATURE FEH WITH YEH FINAL FORM");
+-   ("/xef/xb1/xbe", "ARABIC LIGATURE QAF WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb1/xbf", "ARABIC LIGATURE QAF WITH YEH FINAL FORM");
+-   ("/xef/xb2/x80", "ARABIC LIGATURE KAF WITH ALEF FINAL FORM");
+-   ("/xef/xb2/x81", "ARABIC LIGATURE KAF WITH LAM FINAL FORM");
+-   ("/xef/xb2/x82", "ARABIC LIGATURE KAF WITH MEEM FINAL FORM");
+-   ("/xef/xb2/x83", "ARABIC LIGATURE KAF WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb2/x84", "ARABIC LIGATURE KAF WITH YEH FINAL FORM");
+-   ("/xef/xb2/x85", "ARABIC LIGATURE LAM WITH MEEM FINAL FORM");
+-   ("/xef/xb2/x86", "ARABIC LIGATURE LAM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb2/x87", "ARABIC LIGATURE LAM WITH YEH FINAL FORM");
+-   ("/xef/xb2/x88", "ARABIC LIGATURE MEEM WITH ALEF FINAL FORM");
+-   ("/xef/xb2/x89", "ARABIC LIGATURE MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb2/x8a", "ARABIC LIGATURE NOON WITH REH FINAL FORM");
+-   ("/xef/xb2/x8b", "ARABIC LIGATURE NOON WITH ZAIN FINAL FORM");
+-   ("/xef/xb2/x8c", "ARABIC LIGATURE NOON WITH MEEM FINAL FORM");
+-   ("/xef/xb2/x8d", "ARABIC LIGATURE NOON WITH NOON FINAL FORM");
+-   ("/xef/xb2/x8e", "ARABIC LIGATURE NOON WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb2/x8f", "ARABIC LIGATURE NOON WITH YEH FINAL FORM");
+-   ("/xef/xb2/x90", "ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF FINAL FORM");
+-   ("/xef/xb2/x91", "ARABIC LIGATURE YEH WITH REH FINAL FORM");
+-   ("/xef/xb2/x92", "ARABIC LIGATURE YEH WITH ZAIN FINAL FORM");
+-   ("/xef/xb2/x93", "ARABIC LIGATURE YEH WITH MEEM FINAL FORM");
+-   ("/xef/xb2/x94", "ARABIC LIGATURE YEH WITH NOON FINAL FORM");
+-   ("/xef/xb2/x95", "ARABIC LIGATURE YEH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb2/x96", "ARABIC LIGATURE YEH WITH YEH FINAL FORM");
+-   ("/xef/xb2/x97", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/x98", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH INITIAL FORM");
+-   ("/xef/xb2/x99", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/x9a", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/x9b", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH INITIAL FORM");
+-   ("/xef/xb2/x9c", "ARABIC LIGATURE BEH WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/x9d", "ARABIC LIGATURE BEH WITH HAH INITIAL FORM");
+-   ("/xef/xb2/x9e", "ARABIC LIGATURE BEH WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/x9f", "ARABIC LIGATURE BEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xa0", "ARABIC LIGATURE BEH WITH HEH INITIAL FORM");
+-   ("/xef/xb2/xa1", "ARABIC LIGATURE TEH WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xa2", "ARABIC LIGATURE TEH WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xa3", "ARABIC LIGATURE TEH WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/xa4", "ARABIC LIGATURE TEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xa5", "ARABIC LIGATURE TEH WITH HEH INITIAL FORM");
+-   ("/xef/xb2/xa6", "ARABIC LIGATURE THEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xa7", "ARABIC LIGATURE JEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xa8", "ARABIC LIGATURE JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xa9", "ARABIC LIGATURE HAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xaa", "ARABIC LIGATURE HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xab", "ARABIC LIGATURE KHAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xac", "ARABIC LIGATURE KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xad", "ARABIC LIGATURE SEEN WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xae", "ARABIC LIGATURE SEEN WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xaf", "ARABIC LIGATURE SEEN WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/xb0", "ARABIC LIGATURE SEEN WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xb1", "ARABIC LIGATURE SAD WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xb2", "ARABIC LIGATURE SAD WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/xb3", "ARABIC LIGATURE SAD WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xb4", "ARABIC LIGATURE DAD WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xb5", "ARABIC LIGATURE DAD WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xb6", "ARABIC LIGATURE DAD WITH KHAH INITIAL FORM");
+-   ("/xef/xb2/xb7", "ARABIC LIGATURE DAD WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xb8", "ARABIC LIGATURE TAH WITH HAH INITIAL FORM");
+-   ("/xef/xb2/xb9", "ARABIC LIGATURE ZAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xba", "ARABIC LIGATURE AIN WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xbb", "ARABIC LIGATURE AIN WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xbc", "ARABIC LIGATURE GHAIN WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xbd", "ARABIC LIGATURE GHAIN WITH MEEM INITIAL FORM");
+-   ("/xef/xb2/xbe", "ARABIC LIGATURE FEH WITH JEEM INITIAL FORM");
+-   ("/xef/xb2/xbf", "ARABIC LIGATURE FEH WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x80", "ARABIC LIGATURE FEH WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x81", "ARABIC LIGATURE FEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x82", "ARABIC LIGATURE QAF WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x83", "ARABIC LIGATURE QAF WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x84", "ARABIC LIGATURE KAF WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x85", "ARABIC LIGATURE KAF WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x86", "ARABIC LIGATURE KAF WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x87", "ARABIC LIGATURE KAF WITH LAM INITIAL FORM");
+-   ("/xef/xb3/x88", "ARABIC LIGATURE KAF WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x89", "ARABIC LIGATURE LAM WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x8a", "ARABIC LIGATURE LAM WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x8b", "ARABIC LIGATURE LAM WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x8c", "ARABIC LIGATURE LAM WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x8d", "ARABIC LIGATURE LAM WITH HEH INITIAL FORM");
+-   ("/xef/xb3/x8e", "ARABIC LIGATURE MEEM WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x8f", "ARABIC LIGATURE MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x90", "ARABIC LIGATURE MEEM WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x91", "ARABIC LIGATURE MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x92", "ARABIC LIGATURE NOON WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x93", "ARABIC LIGATURE NOON WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x94", "ARABIC LIGATURE NOON WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x95", "ARABIC LIGATURE NOON WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x96", "ARABIC LIGATURE NOON WITH HEH INITIAL FORM");
+-   ("/xef/xb3/x97", "ARABIC LIGATURE HEH WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x98", "ARABIC LIGATURE HEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x99", "ARABIC LIGATURE HEH WITH SUPERSCRIPT ALEF INITIAL FORM");
+-   ("/xef/xb3/x9a", "ARABIC LIGATURE YEH WITH JEEM INITIAL FORM");
+-   ("/xef/xb3/x9b", "ARABIC LIGATURE YEH WITH HAH INITIAL FORM");
+-   ("/xef/xb3/x9c", "ARABIC LIGATURE YEH WITH KHAH INITIAL FORM");
+-   ("/xef/xb3/x9d", "ARABIC LIGATURE YEH WITH MEEM INITIAL FORM");
+-   ("/xef/xb3/x9e", "ARABIC LIGATURE YEH WITH HEH INITIAL FORM");
+-   ("/xef/xb3/x9f", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xa0", "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xa1", "ARABIC LIGATURE BEH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xa2", "ARABIC LIGATURE BEH WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xa3", "ARABIC LIGATURE TEH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xa4", "ARABIC LIGATURE TEH WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xa5", "ARABIC LIGATURE THEH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xa6", "ARABIC LIGATURE THEH WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xa7", "ARABIC LIGATURE SEEN WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xa8", "ARABIC LIGATURE SEEN WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xa9", "ARABIC LIGATURE SHEEN WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xaa", "ARABIC LIGATURE SHEEN WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xab", "ARABIC LIGATURE KAF WITH LAM MEDIAL FORM");
+-   ("/xef/xb3/xac", "ARABIC LIGATURE KAF WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xad", "ARABIC LIGATURE LAM WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xae", "ARABIC LIGATURE NOON WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xaf", "ARABIC LIGATURE NOON WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xb0", "ARABIC LIGATURE YEH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb3/xb1", "ARABIC LIGATURE YEH WITH HEH MEDIAL FORM");
+-   ("/xef/xb3/xb2", "ARABIC LIGATURE SHADDA WITH FATHA MEDIAL FORM");
+-   ("/xef/xb3/xb3", "ARABIC LIGATURE SHADDA WITH DAMMA MEDIAL FORM");
+-   ("/xef/xb3/xb4", "ARABIC LIGATURE SHADDA WITH KASRA MEDIAL FORM");
+-   ("/xef/xb3/xb5", "ARABIC LIGATURE TAH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb3/xb6", "ARABIC LIGATURE TAH WITH YEH ISOLATED FORM");
+-   ("/xef/xb3/xb7", "ARABIC LIGATURE AIN WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb3/xb8", "ARABIC LIGATURE AIN WITH YEH ISOLATED FORM");
+-   ("/xef/xb3/xb9", "ARABIC LIGATURE GHAIN WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb3/xba", "ARABIC LIGATURE GHAIN WITH YEH ISOLATED FORM");
+-   ("/xef/xb3/xbb", "ARABIC LIGATURE SEEN WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb3/xbc", "ARABIC LIGATURE SEEN WITH YEH ISOLATED FORM");
+-   ("/xef/xb3/xbd", "ARABIC LIGATURE SHEEN WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb3/xbe", "ARABIC LIGATURE SHEEN WITH YEH ISOLATED FORM");
+-   ("/xef/xb3/xbf", "ARABIC LIGATURE HAH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb4/x80", "ARABIC LIGATURE HAH WITH YEH ISOLATED FORM");
+-   ("/xef/xb4/x81", "ARABIC LIGATURE JEEM WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb4/x82", "ARABIC LIGATURE JEEM WITH YEH ISOLATED FORM");
+-   ("/xef/xb4/x83", "ARABIC LIGATURE KHAH WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb4/x84", "ARABIC LIGATURE KHAH WITH YEH ISOLATED FORM");
+-   ("/xef/xb4/x85", "ARABIC LIGATURE SAD WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb4/x86", "ARABIC LIGATURE SAD WITH YEH ISOLATED FORM");
+-   ("/xef/xb4/x87", "ARABIC LIGATURE DAD WITH ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xb4/x88", "ARABIC LIGATURE DAD WITH YEH ISOLATED FORM");
+-   ("/xef/xb4/x89", "ARABIC LIGATURE SHEEN WITH JEEM ISOLATED FORM");
+-   ("/xef/xb4/x8a", "ARABIC LIGATURE SHEEN WITH HAH ISOLATED FORM");
+-   ("/xef/xb4/x8b", "ARABIC LIGATURE SHEEN WITH KHAH ISOLATED FORM");
+-   ("/xef/xb4/x8c", "ARABIC LIGATURE SHEEN WITH MEEM ISOLATED FORM");
+-   ("/xef/xb4/x8d", "ARABIC LIGATURE SHEEN WITH REH ISOLATED FORM");
+-   ("/xef/xb4/x8e", "ARABIC LIGATURE SEEN WITH REH ISOLATED FORM");
+-   ("/xef/xb4/x8f", "ARABIC LIGATURE SAD WITH REH ISOLATED FORM");
+-   ("/xef/xb4/x90", "ARABIC LIGATURE DAD WITH REH ISOLATED FORM");
+-   ("/xef/xb4/x91", "ARABIC LIGATURE TAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x92", "ARABIC LIGATURE TAH WITH YEH FINAL FORM");
+-   ("/xef/xb4/x93", "ARABIC LIGATURE AIN WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x94", "ARABIC LIGATURE AIN WITH YEH FINAL FORM");
+-   ("/xef/xb4/x95", "ARABIC LIGATURE GHAIN WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x96", "ARABIC LIGATURE GHAIN WITH YEH FINAL FORM");
+-   ("/xef/xb4/x97", "ARABIC LIGATURE SEEN WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x98", "ARABIC LIGATURE SEEN WITH YEH FINAL FORM");
+-   ("/xef/xb4/x99", "ARABIC LIGATURE SHEEN WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x9a", "ARABIC LIGATURE SHEEN WITH YEH FINAL FORM");
+-   ("/xef/xb4/x9b", "ARABIC LIGATURE HAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x9c", "ARABIC LIGATURE HAH WITH YEH FINAL FORM");
+-   ("/xef/xb4/x9d", "ARABIC LIGATURE JEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/x9e", "ARABIC LIGATURE JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb4/x9f", "ARABIC LIGATURE KHAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/xa0", "ARABIC LIGATURE KHAH WITH YEH FINAL FORM");
+-   ("/xef/xb4/xa1", "ARABIC LIGATURE SAD WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/xa2", "ARABIC LIGATURE SAD WITH YEH FINAL FORM");
+-   ("/xef/xb4/xa3", "ARABIC LIGATURE DAD WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb4/xa4", "ARABIC LIGATURE DAD WITH YEH FINAL FORM");
+-   ("/xef/xb4/xa5", "ARABIC LIGATURE SHEEN WITH JEEM FINAL FORM");
+-   ("/xef/xb4/xa6", "ARABIC LIGATURE SHEEN WITH HAH FINAL FORM");
+-   ("/xef/xb4/xa7", "ARABIC LIGATURE SHEEN WITH KHAH FINAL FORM");
+-   ("/xef/xb4/xa8", "ARABIC LIGATURE SHEEN WITH MEEM FINAL FORM");
+-   ("/xef/xb4/xa9", "ARABIC LIGATURE SHEEN WITH REH FINAL FORM");
+-   ("/xef/xb4/xaa", "ARABIC LIGATURE SEEN WITH REH FINAL FORM");
+-   ("/xef/xb4/xab", "ARABIC LIGATURE SAD WITH REH FINAL FORM");
+-   ("/xef/xb4/xac", "ARABIC LIGATURE DAD WITH REH FINAL FORM");
+-   ("/xef/xb4/xad", "ARABIC LIGATURE SHEEN WITH JEEM INITIAL FORM");
+-   ("/xef/xb4/xae", "ARABIC LIGATURE SHEEN WITH HAH INITIAL FORM");
+-   ("/xef/xb4/xaf", "ARABIC LIGATURE SHEEN WITH KHAH INITIAL FORM");
+-   ("/xef/xb4/xb0", "ARABIC LIGATURE SHEEN WITH MEEM INITIAL FORM");
+-   ("/xef/xb4/xb1", "ARABIC LIGATURE SEEN WITH HEH INITIAL FORM");
+-   ("/xef/xb4/xb2", "ARABIC LIGATURE SHEEN WITH HEH INITIAL FORM");
+-   ("/xef/xb4/xb3", "ARABIC LIGATURE TAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb4/xb4", "ARABIC LIGATURE SEEN WITH JEEM MEDIAL FORM");
+-   ("/xef/xb4/xb5", "ARABIC LIGATURE SEEN WITH HAH MEDIAL FORM");
+-   ("/xef/xb4/xb6", "ARABIC LIGATURE SEEN WITH KHAH MEDIAL FORM");
+-   ("/xef/xb4/xb7", "ARABIC LIGATURE SHEEN WITH JEEM MEDIAL FORM");
+-   ("/xef/xb4/xb8", "ARABIC LIGATURE SHEEN WITH HAH MEDIAL FORM");
+-   ("/xef/xb4/xb9", "ARABIC LIGATURE SHEEN WITH KHAH MEDIAL FORM");
+-   ("/xef/xb4/xba", "ARABIC LIGATURE TAH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb4/xbb", "ARABIC LIGATURE ZAH WITH MEEM MEDIAL FORM");
+-   ("/xef/xb4/xbc", "ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM");
+-   ("/xef/xb4/xbd", "ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM");
+-   ("/xef/xb4/xbe", "ORNATE LEFT PARENTHESIS");
+-   ("/xef/xb4/xbf", "ORNATE RIGHT PARENTHESIS");
+-   ("/xef/xb5/x90", "ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/x91", "ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM");
+-   ("/xef/xb5/x92", "ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb5/x93", "ARABIC LIGATURE TEH WITH HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/x94", "ARABIC LIGATURE TEH WITH KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/x95", "ARABIC LIGATURE TEH WITH MEEM WITH JEEM INITIAL FORM");
+-   ("/xef/xb5/x96", "ARABIC LIGATURE TEH WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb5/x97", "ARABIC LIGATURE TEH WITH MEEM WITH KHAH INITIAL FORM");
+-   ("/xef/xb5/x98", "ARABIC LIGATURE JEEM WITH MEEM WITH HAH FINAL FORM");
+-   ("/xef/xb5/x99", "ARABIC LIGATURE JEEM WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb5/x9a", "ARABIC LIGATURE HAH WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb5/x9b", "ARABIC LIGATURE HAH WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb5/x9c", "ARABIC LIGATURE SEEN WITH HAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb5/x9d", "ARABIC LIGATURE SEEN WITH JEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb5/x9e", "ARABIC LIGATURE SEEN WITH JEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb5/x9f", "ARABIC LIGATURE SEEN WITH MEEM WITH HAH FINAL FORM");
+-   ("/xef/xb5/xa0", "ARABIC LIGATURE SEEN WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb5/xa1", "ARABIC LIGATURE SEEN WITH MEEM WITH JEEM INITIAL FORM");
+-   ("/xef/xb5/xa2", "ARABIC LIGATURE SEEN WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xa3", "ARABIC LIGATURE SEEN WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xa4", "ARABIC LIGATURE SAD WITH HAH WITH HAH FINAL FORM");
+-   ("/xef/xb5/xa5", "ARABIC LIGATURE SAD WITH HAH WITH HAH INITIAL FORM");
+-   ("/xef/xb5/xa6", "ARABIC LIGATURE SAD WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xa7", "ARABIC LIGATURE SHEEN WITH HAH WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xa8", "ARABIC LIGATURE SHEEN WITH HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xa9", "ARABIC LIGATURE SHEEN WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb5/xaa", "ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH FINAL FORM");
+-   ("/xef/xb5/xab", "ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH INITIAL FORM");
+-   ("/xef/xb5/xac", "ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xad", "ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xae", "ARABIC LIGATURE DAD WITH HAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb5/xaf", "ARABIC LIGATURE DAD WITH KHAH WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xb0", "ARABIC LIGATURE DAD WITH KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xb1", "ARABIC LIGATURE TAH WITH MEEM WITH HAH FINAL FORM");
+-   ("/xef/xb5/xb2", "ARABIC LIGATURE TAH WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb5/xb3", "ARABIC LIGATURE TAH WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xb4", "ARABIC LIGATURE TAH WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb5/xb5", "ARABIC LIGATURE AIN WITH JEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xb6", "ARABIC LIGATURE AIN WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xb7", "ARABIC LIGATURE AIN WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xb8", "ARABIC LIGATURE AIN WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb5/xb9", "ARABIC LIGATURE GHAIN WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xba", "ARABIC LIGATURE GHAIN WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb5/xbb", "ARABIC LIGATURE GHAIN WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb5/xbc", "ARABIC LIGATURE FEH WITH KHAH WITH MEEM FINAL FORM");
+-   ("/xef/xb5/xbd", "ARABIC LIGATURE FEH WITH KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb5/xbe", "ARABIC LIGATURE QAF WITH MEEM WITH HAH FINAL FORM");
+-   ("/xef/xb5/xbf", "ARABIC LIGATURE QAF WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb6/x80", "ARABIC LIGATURE LAM WITH HAH WITH MEEM FINAL FORM");
+-   ("/xef/xb6/x81", "ARABIC LIGATURE LAM WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/x82", "ARABIC LIGATURE LAM WITH HAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/x83", "ARABIC LIGATURE LAM WITH JEEM WITH JEEM INITIAL FORM");
+-   ("/xef/xb6/x84", "ARABIC LIGATURE LAM WITH JEEM WITH JEEM FINAL FORM");
+-   ("/xef/xb6/x85", "ARABIC LIGATURE LAM WITH KHAH WITH MEEM FINAL FORM");
+-   ("/xef/xb6/x86", "ARABIC LIGATURE LAM WITH KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x87", "ARABIC LIGATURE LAM WITH MEEM WITH HAH FINAL FORM");
+-   ("/xef/xb6/x88", "ARABIC LIGATURE LAM WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb6/x89", "ARABIC LIGATURE MEEM WITH HAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb6/x8a", "ARABIC LIGATURE MEEM WITH HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x8b", "ARABIC LIGATURE MEEM WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/x8c", "ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb6/x8d", "ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x8e", "ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM");
+-   ("/xef/xb6/x8f", "ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x92", "ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM");
+-   ("/xef/xb6/x93", "ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM");
+-   ("/xef/xb6/x94", "ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x95", "ARABIC LIGATURE NOON WITH HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x96", "ARABIC LIGATURE NOON WITH HAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/x97", "ARABIC LIGATURE NOON WITH JEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb6/x98", "ARABIC LIGATURE NOON WITH JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x99", "ARABIC LIGATURE NOON WITH JEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/x9a", "ARABIC LIGATURE NOON WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/x9b", "ARABIC LIGATURE NOON WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/x9c", "ARABIC LIGATURE YEH WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb6/x9d", "ARABIC LIGATURE YEH WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/x9e", "ARABIC LIGATURE BEH WITH KHAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/x9f", "ARABIC LIGATURE TEH WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xa0", "ARABIC LIGATURE TEH WITH JEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa1", "ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xa2", "ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa3", "ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xa4", "ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa5", "ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xa6", "ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa7", "ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa8", "ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM");
+-   ("/xef/xb6/xa9", "ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xaa", "ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xab", "ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xac", "ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xad", "ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xae", "ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xaf", "ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb0", "ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb1", "ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb2", "ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb3", "ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb4", "ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb6/xb5", "ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/xb6", "ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb7", "ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb6/xb8", "ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM");
+-   ("/xef/xb6/xb9", "ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xba", "ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb6/xbb", "ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb6/xbc", "ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM");
+-   ("/xef/xb6/xbd", "ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM");
+-   ("/xef/xb6/xbe", "ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb6/xbf", "ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb7/x80", "ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb7/x81", "ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM");
+-   ("/xef/xb7/x82", "ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM");
+-   ("/xef/xb7/x83", "ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb7/x84", "ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb7/x85", "ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM");
+-   ("/xef/xb7/x86", "ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM");
+-   ("/xef/xb7/x87", "ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM");
+-   ("/xef/xb7/xb0", "ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM");
+-   ("/xef/xb7/xb1", "ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM");
+-   ("/xef/xb7/xb2", "ARABIC LIGATURE ALLAH ISOLATED FORM");
+-   ("/xef/xb7/xb3", "ARABIC LIGATURE AKBAR ISOLATED FORM");
+-   ("/xef/xb7/xb4", "ARABIC LIGATURE MOHAMMAD ISOLATED FORM");
+-   ("/xef/xb7/xb5", "ARABIC LIGATURE SALAM ISOLATED FORM");
+-   ("/xef/xb7/xb6", "ARABIC LIGATURE RASOUL ISOLATED FORM");
+-   ("/xef/xb7/xb7", "ARABIC LIGATURE ALAYHE ISOLATED FORM");
+-   ("/xef/xb7/xb8", "ARABIC LIGATURE WASALLAM ISOLATED FORM");
+-   ("/xef/xb7/xb9", "ARABIC LIGATURE SALLA ISOLATED FORM");
+-   ("/xef/xb7/xba", "ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM");
+-   ("/xef/xb7/xbb", "ARABIC LIGATURE JALLAJALALOUHOU");
+-   ("/xef/xb7/xbc", "RIAL SIGN");
+-   ("/xef/xb7/xbd", "ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM");
+-   ("/xef/xb8/x80", "VARIATION SELECTOR-1");
+-   ("/xef/xb8/x81", "VARIATION SELECTOR-2");
+-   ("/xef/xb8/x82", "VARIATION SELECTOR-3");
+-   ("/xef/xb8/x83", "VARIATION SELECTOR-4");
+-   ("/xef/xb8/x84", "VARIATION SELECTOR-5");
+-   ("/xef/xb8/x85", "VARIATION SELECTOR-6");
+-   ("/xef/xb8/x86", "VARIATION SELECTOR-7");
+-   ("/xef/xb8/x87", "VARIATION SELECTOR-8");
+-   ("/xef/xb8/x88", "VARIATION SELECTOR-9");
+-   ("/xef/xb8/x89", "VARIATION SELECTOR-10");
+-   ("/xef/xb8/x8a", "VARIATION SELECTOR-11");
+-   ("/xef/xb8/x8b", "VARIATION SELECTOR-12");
+-   ("/xef/xb8/x8c", "VARIATION SELECTOR-13");
+-   ("/xef/xb8/x8d", "VARIATION SELECTOR-14");
+-   ("/xef/xb8/x8e", "VARIATION SELECTOR-15");
+-   ("/xef/xb8/x8f", "VARIATION SELECTOR-16");
+-   ("/xef/xb8/x90", "PRESENTATION FORM FOR VERTICAL COMMA");
+-   ("/xef/xb8/x91", "PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA");
+-   ("/xef/xb8/x92", "PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP");
+-   ("/xef/xb8/x93", "PRESENTATION FORM FOR VERTICAL COLON");
+-   ("/xef/xb8/x94", "PRESENTATION FORM FOR VERTICAL SEMICOLON");
+-   ("/xef/xb8/x95", "PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK");
+-   ("/xef/xb8/x96", "PRESENTATION FORM FOR VERTICAL QUESTION MARK");
+-   ("/xef/xb8/x97", "PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET");
+-   ("/xef/xb8/x98", "PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET");
+-   ("/xef/xb8/x99", "PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS");
+-   ("/xef/xb8/xa0", "COMBINING LIGATURE LEFT HALF");
+-   ("/xef/xb8/xa1", "COMBINING LIGATURE RIGHT HALF");
+-   ("/xef/xb8/xa2", "COMBINING DOUBLE TILDE LEFT HALF");
+-   ("/xef/xb8/xa3", "COMBINING DOUBLE TILDE RIGHT HALF");
+-   ("/xef/xb8/xa4", "COMBINING MACRON LEFT HALF");
+-   ("/xef/xb8/xa5", "COMBINING MACRON RIGHT HALF");
+-   ("/xef/xb8/xa6", "COMBINING CONJOINING MACRON");
+-   ("/xef/xb8/xb0", "PRESENTATION FORM FOR VERTICAL TWO DOT LEADER");
+-   ("/xef/xb8/xb1", "PRESENTATION FORM FOR VERTICAL EM DASH");
+-   ("/xef/xb8/xb2", "PRESENTATION FORM FOR VERTICAL EN DASH");
+-   ("/xef/xb8/xb3", "PRESENTATION FORM FOR VERTICAL LOW LINE");
+-   ("/xef/xb8/xb4", "PRESENTATION FORM FOR VERTICAL WAVY LOW LINE");
+-   ("/xef/xb8/xb5", "PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS");
+-   ("/xef/xb8/xb6", "PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS");
+-   ("/xef/xb8/xb7", "PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET");
+-   ("/xef/xb8/xb8", "PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET");
+-   ("/xef/xb8/xb9", "PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET");
+-   ("/xef/xb8/xba", "PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET");
+-   ("/xef/xb8/xbb", "PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET");
+-   ("/xef/xb8/xbc", "PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET");
+-   ("/xef/xb8/xbd", "PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET");
+-   ("/xef/xb8/xbe", "PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET");
+-   ("/xef/xb8/xbf", "PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET");
+-   ("/xef/xb9/x80", "PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET");
+-   ("/xef/xb9/x81", "PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET");
+-   ("/xef/xb9/x82", "PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET");
+-   ("/xef/xb9/x83", "PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET");
+-   ("/xef/xb9/x84", "PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET");
+-   ("/xef/xb9/x85", "SESAME DOT");
+-   ("/xef/xb9/x86", "WHITE SESAME DOT");
+-   ("/xef/xb9/x87", "PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET");
+-   ("/xef/xb9/x88", "PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET");
+-   ("/xef/xb9/x89", "DASHED OVERLINE");
+-   ("/xef/xb9/x8a", "CENTRELINE OVERLINE");
+-   ("/xef/xb9/x8b", "WAVY OVERLINE");
+-   ("/xef/xb9/x8c", "DOUBLE WAVY OVERLINE");
+-   ("/xef/xb9/x8d", "DASHED LOW LINE");
+-   ("/xef/xb9/x8e", "CENTRELINE LOW LINE");
+-   ("/xef/xb9/x8f", "WAVY LOW LINE");
+    ("/xef/xb9/x90", "SMALL COMMA");
+    ("/xef/xb9/x91", "SMALL IDEOGRAPHIC COMMA");
+    ("/xef/xb9/x92", "SMALL FULL STOP");
+@@ -26055,179 +2505,6 @@
+    ("/xef/xb9/xa9", "SMALL DOLLAR SIGN");
+    ("/xef/xb9/xaa", "SMALL PERCENT SIGN");
+    ("/xef/xb9/xab", "SMALL COMMERCIAL AT");
+-   ("/xef/xb9/xb0", "ARABIC FATHATAN ISOLATED FORM");
+-   ("/xef/xb9/xb1", "ARABIC TATWEEL WITH FATHATAN ABOVE");
+-   ("/xef/xb9/xb2", "ARABIC DAMMATAN ISOLATED FORM");
+-   ("/xef/xb9/xb3", "ARABIC TAIL FRAGMENT");
+-   ("/xef/xb9/xb4", "ARABIC KASRATAN ISOLATED FORM");
+-   ("/xef/xb9/xb6", "ARABIC FATHA ISOLATED FORM");
+-   ("/xef/xb9/xb7", "ARABIC FATHA MEDIAL FORM");
+-   ("/xef/xb9/xb8", "ARABIC DAMMA ISOLATED FORM");
+-   ("/xef/xb9/xb9", "ARABIC DAMMA MEDIAL FORM");
+-   ("/xef/xb9/xba", "ARABIC KASRA ISOLATED FORM");
+-   ("/xef/xb9/xbb", "ARABIC KASRA MEDIAL FORM");
+-   ("/xef/xb9/xbc", "ARABIC SHADDA ISOLATED FORM");
+-   ("/xef/xb9/xbd", "ARABIC SHADDA MEDIAL FORM");
+-   ("/xef/xb9/xbe", "ARABIC SUKUN ISOLATED FORM");
+-   ("/xef/xb9/xbf", "ARABIC SUKUN MEDIAL FORM");
+-   ("/xef/xba/x80", "ARABIC LETTER HAMZA ISOLATED FORM");
+-   ("/xef/xba/x81", "ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM");
+-   ("/xef/xba/x82", "ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM");
+-   ("/xef/xba/x83", "ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xba/x84", "ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM");
+-   ("/xef/xba/x85", "ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xba/x86", "ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM");
+-   ("/xef/xba/x87", "ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM");
+-   ("/xef/xba/x88", "ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM");
+-   ("/xef/xba/x89", "ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xba/x8a", "ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM");
+-   ("/xef/xba/x8b", "ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM");
+-   ("/xef/xba/x8c", "ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM");
+-   ("/xef/xba/x8d", "ARABIC LETTER ALEF ISOLATED FORM");
+-   ("/xef/xba/x8e", "ARABIC LETTER ALEF FINAL FORM");
+-   ("/xef/xba/x8f", "ARABIC LETTER BEH ISOLATED FORM");
+-   ("/xef/xba/x90", "ARABIC LETTER BEH FINAL FORM");
+-   ("/xef/xba/x91", "ARABIC LETTER BEH INITIAL FORM");
+-   ("/xef/xba/x92", "ARABIC LETTER BEH MEDIAL FORM");
+-   ("/xef/xba/x93", "ARABIC LETTER TEH MARBUTA ISOLATED FORM");
+-   ("/xef/xba/x94", "ARABIC LETTER TEH MARBUTA FINAL FORM");
+-   ("/xef/xba/x95", "ARABIC LETTER TEH ISOLATED FORM");
+-   ("/xef/xba/x96", "ARABIC LETTER TEH FINAL FORM");
+-   ("/xef/xba/x97", "ARABIC LETTER TEH INITIAL FORM");
+-   ("/xef/xba/x98", "ARABIC LETTER TEH MEDIAL FORM");
+-   ("/xef/xba/x99", "ARABIC LETTER THEH ISOLATED FORM");
+-   ("/xef/xba/x9a", "ARABIC LETTER THEH FINAL FORM");
+-   ("/xef/xba/x9b", "ARABIC LETTER THEH INITIAL FORM");
+-   ("/xef/xba/x9c", "ARABIC LETTER THEH MEDIAL FORM");
+-   ("/xef/xba/x9d", "ARABIC LETTER JEEM ISOLATED FORM");
+-   ("/xef/xba/x9e", "ARABIC LETTER JEEM FINAL FORM");
+-   ("/xef/xba/x9f", "ARABIC LETTER JEEM INITIAL FORM");
+-   ("/xef/xba/xa0", "ARABIC LETTER JEEM MEDIAL FORM");
+-   ("/xef/xba/xa1", "ARABIC LETTER HAH ISOLATED FORM");
+-   ("/xef/xba/xa2", "ARABIC LETTER HAH FINAL FORM");
+-   ("/xef/xba/xa3", "ARABIC LETTER HAH INITIAL FORM");
+-   ("/xef/xba/xa4", "ARABIC LETTER HAH MEDIAL FORM");
+-   ("/xef/xba/xa5", "ARABIC LETTER KHAH ISOLATED FORM");
+-   ("/xef/xba/xa6", "ARABIC LETTER KHAH FINAL FORM");
+-   ("/xef/xba/xa7", "ARABIC LETTER KHAH INITIAL FORM");
+-   ("/xef/xba/xa8", "ARABIC LETTER KHAH MEDIAL FORM");
+-   ("/xef/xba/xa9", "ARABIC LETTER DAL ISOLATED FORM");
+-   ("/xef/xba/xaa", "ARABIC LETTER DAL FINAL FORM");
+-   ("/xef/xba/xab", "ARABIC LETTER THAL ISOLATED FORM");
+-   ("/xef/xba/xac", "ARABIC LETTER THAL FINAL FORM");
+-   ("/xef/xba/xad", "ARABIC LETTER REH ISOLATED FORM");
+-   ("/xef/xba/xae", "ARABIC LETTER REH FINAL FORM");
+-   ("/xef/xba/xaf", "ARABIC LETTER ZAIN ISOLATED FORM");
+-   ("/xef/xba/xb0", "ARABIC LETTER ZAIN FINAL FORM");
+-   ("/xef/xba/xb1", "ARABIC LETTER SEEN ISOLATED FORM");
+-   ("/xef/xba/xb2", "ARABIC LETTER SEEN FINAL FORM");
+-   ("/xef/xba/xb3", "ARABIC LETTER SEEN INITIAL FORM");
+-   ("/xef/xba/xb4", "ARABIC LETTER SEEN MEDIAL FORM");
+-   ("/xef/xba/xb5", "ARABIC LETTER SHEEN ISOLATED FORM");
+-   ("/xef/xba/xb6", "ARABIC LETTER SHEEN FINAL FORM");
+-   ("/xef/xba/xb7", "ARABIC LETTER SHEEN INITIAL FORM");
+-   ("/xef/xba/xb8", "ARABIC LETTER SHEEN MEDIAL FORM");
+-   ("/xef/xba/xb9", "ARABIC LETTER SAD ISOLATED FORM");
+-   ("/xef/xba/xba", "ARABIC LETTER SAD FINAL FORM");
+-   ("/xef/xba/xbb", "ARABIC LETTER SAD INITIAL FORM");
+-   ("/xef/xba/xbc", "ARABIC LETTER SAD MEDIAL FORM");
+-   ("/xef/xba/xbd", "ARABIC LETTER DAD ISOLATED FORM");
+-   ("/xef/xba/xbe", "ARABIC LETTER DAD FINAL FORM");
+-   ("/xef/xba/xbf", "ARABIC LETTER DAD INITIAL FORM");
+-   ("/xef/xbb/x80", "ARABIC LETTER DAD MEDIAL FORM");
+-   ("/xef/xbb/x81", "ARABIC LETTER TAH ISOLATED FORM");
+-   ("/xef/xbb/x82", "ARABIC LETTER TAH FINAL FORM");
+-   ("/xef/xbb/x83", "ARABIC LETTER TAH INITIAL FORM");
+-   ("/xef/xbb/x84", "ARABIC LETTER TAH MEDIAL FORM");
+-   ("/xef/xbb/x85", "ARABIC LETTER ZAH ISOLATED FORM");
+-   ("/xef/xbb/x86", "ARABIC LETTER ZAH FINAL FORM");
+-   ("/xef/xbb/x87", "ARABIC LETTER ZAH INITIAL FORM");
+-   ("/xef/xbb/x88", "ARABIC LETTER ZAH MEDIAL FORM");
+-   ("/xef/xbb/x89", "ARABIC LETTER AIN ISOLATED FORM");
+-   ("/xef/xbb/x8a", "ARABIC LETTER AIN FINAL FORM");
+-   ("/xef/xbb/x8b", "ARABIC LETTER AIN INITIAL FORM");
+-   ("/xef/xbb/x8c", "ARABIC LETTER AIN MEDIAL FORM");
+-   ("/xef/xbb/x8d", "ARABIC LETTER GHAIN ISOLATED FORM");
+-   ("/xef/xbb/x8e", "ARABIC LETTER GHAIN FINAL FORM");
+-   ("/xef/xbb/x8f", "ARABIC LETTER GHAIN INITIAL FORM");
+-   ("/xef/xbb/x90", "ARABIC LETTER GHAIN MEDIAL FORM");
+-   ("/xef/xbb/x91", "ARABIC LETTER FEH ISOLATED FORM");
+-   ("/xef/xbb/x92", "ARABIC LETTER FEH FINAL FORM");
+-   ("/xef/xbb/x93", "ARABIC LETTER FEH INITIAL FORM");
+-   ("/xef/xbb/x94", "ARABIC LETTER FEH MEDIAL FORM");
+-   ("/xef/xbb/x95", "ARABIC LETTER QAF ISOLATED FORM");
+-   ("/xef/xbb/x96", "ARABIC LETTER QAF FINAL FORM");
+-   ("/xef/xbb/x97", "ARABIC LETTER QAF INITIAL FORM");
+-   ("/xef/xbb/x98", "ARABIC LETTER QAF MEDIAL FORM");
+-   ("/xef/xbb/x99", "ARABIC LETTER KAF ISOLATED FORM");
+-   ("/xef/xbb/x9a", "ARABIC LETTER KAF FINAL FORM");
+-   ("/xef/xbb/x9b", "ARABIC LETTER KAF INITIAL FORM");
+-   ("/xef/xbb/x9c", "ARABIC LETTER KAF MEDIAL FORM");
+-   ("/xef/xbb/x9d", "ARABIC LETTER LAM ISOLATED FORM");
+-   ("/xef/xbb/x9e", "ARABIC LETTER LAM FINAL FORM");
+-   ("/xef/xbb/x9f", "ARABIC LETTER LAM INITIAL FORM");
+-   ("/xef/xbb/xa0", "ARABIC LETTER LAM MEDIAL FORM");
+-   ("/xef/xbb/xa1", "ARABIC LETTER MEEM ISOLATED FORM");
+-   ("/xef/xbb/xa2", "ARABIC LETTER MEEM FINAL FORM");
+-   ("/xef/xbb/xa3", "ARABIC LETTER MEEM INITIAL FORM");
+-   ("/xef/xbb/xa4", "ARABIC LETTER MEEM MEDIAL FORM");
+-   ("/xef/xbb/xa5", "ARABIC LETTER NOON ISOLATED FORM");
+-   ("/xef/xbb/xa6", "ARABIC LETTER NOON FINAL FORM");
+-   ("/xef/xbb/xa7", "ARABIC LETTER NOON INITIAL FORM");
+-   ("/xef/xbb/xa8", "ARABIC LETTER NOON MEDIAL FORM");
+-   ("/xef/xbb/xa9", "ARABIC LETTER HEH ISOLATED FORM");
+-   ("/xef/xbb/xaa", "ARABIC LETTER HEH FINAL FORM");
+-   ("/xef/xbb/xab", "ARABIC LETTER HEH INITIAL FORM");
+-   ("/xef/xbb/xac", "ARABIC LETTER HEH MEDIAL FORM");
+-   ("/xef/xbb/xad", "ARABIC LETTER WAW ISOLATED FORM");
+-   ("/xef/xbb/xae", "ARABIC LETTER WAW FINAL FORM");
+-   ("/xef/xbb/xaf", "ARABIC LETTER ALEF MAKSURA ISOLATED FORM");
+-   ("/xef/xbb/xb0", "ARABIC LETTER ALEF MAKSURA FINAL FORM");
+-   ("/xef/xbb/xb1", "ARABIC LETTER YEH ISOLATED FORM");
+-   ("/xef/xbb/xb2", "ARABIC LETTER YEH FINAL FORM");
+-   ("/xef/xbb/xb3", "ARABIC LETTER YEH INITIAL FORM");
+-   ("/xef/xbb/xb4", "ARABIC LETTER YEH MEDIAL FORM");
+-   ("/xef/xbb/xb5", "ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM");
+-   ("/xef/xbb/xb6", "ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM");
+-   ("/xef/xbb/xb7", "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM");
+-   ("/xef/xbb/xb8", "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM");
+-   ("/xef/xbb/xb9", "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM");
+-   ("/xef/xbb/xba", "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM");
+-   ("/xef/xbb/xbb", "ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM");
+-   ("/xef/xbb/xbc", "ARABIC LIGATURE LAM WITH ALEF FINAL FORM");
+-   ("/xef/xbb/xbf", "ZERO WIDTH NO-BREAK SPACE");
+-   ("/xef/xbc/x81", "FULLWIDTH EXCLAMATION MARK");
+-   ("/xef/xbc/x82", "FULLWIDTH QUOTATION MARK");
+-   ("/xef/xbc/x83", "FULLWIDTH NUMBER SIGN");
+-   ("/xef/xbc/x84", "FULLWIDTH DOLLAR SIGN");
+-   ("/xef/xbc/x85", "FULLWIDTH PERCENT SIGN");
+-   ("/xef/xbc/x86", "FULLWIDTH AMPERSAND");
+-   ("/xef/xbc/x87", "FULLWIDTH APOSTROPHE");
+-   ("/xef/xbc/x88", "FULLWIDTH LEFT PARENTHESIS");
+-   ("/xef/xbc/x89", "FULLWIDTH RIGHT PARENTHESIS");
+-   ("/xef/xbc/x8a", "FULLWIDTH ASTERISK");
+-   ("/xef/xbc/x8b", "FULLWIDTH PLUS SIGN");
+-   ("/xef/xbc/x8c", "FULLWIDTH COMMA");
+-   ("/xef/xbc/x8d", "FULLWIDTH HYPHEN-MINUS");
+-   ("/xef/xbc/x8e", "FULLWIDTH FULL STOP");
+-   ("/xef/xbc/x8f", "FULLWIDTH SOLIDUS");
+-   ("/xef/xbc/x90", "FULLWIDTH DIGIT ZERO");
+-   ("/xef/xbc/x91", "FULLWIDTH DIGIT ONE");
+-   ("/xef/xbc/x92", "FULLWIDTH DIGIT TWO");
+-   ("/xef/xbc/x93", "FULLWIDTH DIGIT THREE");
+-   ("/xef/xbc/x94", "FULLWIDTH DIGIT FOUR");
+-   ("/xef/xbc/x95", "FULLWIDTH DIGIT FIVE");
+-   ("/xef/xbc/x96", "FULLWIDTH DIGIT SIX");
+-   ("/xef/xbc/x97", "FULLWIDTH DIGIT SEVEN");
+-   ("/xef/xbc/x98", "FULLWIDTH DIGIT EIGHT");
+-   ("/xef/xbc/x99", "FULLWIDTH DIGIT NINE");
+-   ("/xef/xbc/x9a", "FULLWIDTH COLON");
+-   ("/xef/xbc/x9b", "FULLWIDTH SEMICOLON");
+-   ("/xef/xbc/x9c", "FULLWIDTH LESS-THAN SIGN");
+-   ("/xef/xbc/x9d", "FULLWIDTH EQUALS SIGN");
+-   ("/xef/xbc/x9e", "FULLWIDTH GREATER-THAN SIGN");
+-   ("/xef/xbc/x9f", "FULLWIDTH QUESTION MARK");
+-   ("/xef/xbc/xa0", "FULLWIDTH COMMERCIAL AT");
+    ("/xef/xbc/xa1", "FULLWIDTH LATIN CAPITAL LETTER A");
+    ("/xef/xbc/xa2", "FULLWIDTH LATIN CAPITAL LETTER B");
+    ("/xef/xbc/xa3", "FULLWIDTH LATIN CAPITAL LETTER C");
+@@ -26254,12 +2531,6 @@
+    ("/xef/xbc/xb8", "FULLWIDTH LATIN CAPITAL LETTER X");
+    ("/xef/xbc/xb9", "FULLWIDTH LATIN CAPITAL LETTER Y");
+    ("/xef/xbc/xba", "FULLWIDTH LATIN CAPITAL LETTER Z");
+-   ("/xef/xbc/xbb", "FULLWIDTH LEFT SQUARE BRACKET");
+-   ("/xef/xbc/xbc", "FULLWIDTH REVERSE SOLIDUS");
+-   ("/xef/xbc/xbd", "FULLWIDTH RIGHT SQUARE BRACKET");
+-   ("/xef/xbc/xbe", "FULLWIDTH CIRCUMFLEX ACCENT");
+-   ("/xef/xbc/xbf", "FULLWIDTH LOW LINE");
+-   ("/xef/xbd/x80", "FULLWIDTH GRAVE ACCENT");
+    ("/xef/xbd/x81", "FULLWIDTH LATIN SMALL LETTER A");
+    ("/xef/xbd/x82", "FULLWIDTH LATIN SMALL LETTER B");
+    ("/xef/xbd/x83", "FULLWIDTH LATIN SMALL LETTER C");
+@@ -26286,18 +2557,6 @@
+    ("/xef/xbd/x98", "FULLWIDTH LATIN SMALL LETTER X");
+    ("/xef/xbd/x99", "FULLWIDTH LATIN SMALL LETTER Y");
+    ("/xef/xbd/x9a", "FULLWIDTH LATIN SMALL LETTER Z");
+-   ("/xef/xbd/x9b", "FULLWIDTH LEFT CURLY BRACKET");
+-   ("/xef/xbd/x9c", "FULLWIDTH VERTICAL LINE");
+-   ("/xef/xbd/x9d", "FULLWIDTH RIGHT CURLY BRACKET");
+-   ("/xef/xbd/x9e", "FULLWIDTH TILDE");
+-   ("/xef/xbd/x9f", "FULLWIDTH LEFT WHITE PARENTHESIS");
+-   ("/xef/xbd/xa0", "FULLWIDTH RIGHT WHITE PARENTHESIS");
+-   ("/xef/xbd/xa1", "HALFWIDTH IDEOGRAPHIC FULL STOP");
+-   ("/xef/xbd/xa2", "HALFWIDTH LEFT CORNER BRACKET");
+-   ("/xef/xbd/xa3", "HALFWIDTH RIGHT CORNER BRACKET");
+-   ("/xef/xbd/xa4", "HALFWIDTH IDEOGRAPHIC COMMA");
+-   ("/xef/xbd/xa5", "HALFWIDTH KATAKANA MIDDLE DOT");
+-   ("/xef/xbd/xa6", "HALFWIDTH KATAKANA LETTER WO");
+    ("/xef/xbd/xa7", "HALFWIDTH KATAKANA LETTER SMALL A");
+    ("/xef/xbd/xa8", "HALFWIDTH KATAKANA LETTER SMALL I");
+    ("/xef/xbd/xa9", "HALFWIDTH KATAKANA LETTER SMALL U");
+@@ -26307,747 +2566,7 @@
+    ("/xef/xbd/xad", "HALFWIDTH KATAKANA LETTER SMALL YU");
+    ("/xef/xbd/xae", "HALFWIDTH KATAKANA LETTER SMALL YO");
+    ("/xef/xbd/xaf", "HALFWIDTH KATAKANA LETTER SMALL TU");
+-   ("/xef/xbd/xb0", "HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK");
+-   ("/xef/xbd/xb1", "HALFWIDTH KATAKANA LETTER A");
+-   ("/xef/xbd/xb2", "HALFWIDTH KATAKANA LETTER I");
+-   ("/xef/xbd/xb3", "HALFWIDTH KATAKANA LETTER U");
+-   ("/xef/xbd/xb4", "HALFWIDTH KATAKANA LETTER E");
+-   ("/xef/xbd/xb5", "HALFWIDTH KATAKANA LETTER O");
+-   ("/xef/xbd/xb6", "HALFWIDTH KATAKANA LETTER KA");
+-   ("/xef/xbd/xb7", "HALFWIDTH KATAKANA LETTER KI");
+-   ("/xef/xbd/xb8", "HALFWIDTH KATAKANA LETTER KU");
+-   ("/xef/xbd/xb9", "HALFWIDTH KATAKANA LETTER KE");
+-   ("/xef/xbd/xba", "HALFWIDTH KATAKANA LETTER KO");
+-   ("/xef/xbd/xbb", "HALFWIDTH KATAKANA LETTER SA");
+-   ("/xef/xbd/xbc", "HALFWIDTH KATAKANA LETTER SI");
+-   ("/xef/xbd/xbd", "HALFWIDTH KATAKANA LETTER SU");
+-   ("/xef/xbd/xbe", "HALFWIDTH KATAKANA LETTER SE");
+-   ("/xef/xbd/xbf", "HALFWIDTH KATAKANA LETTER SO");
+-   ("/xef/xbe/x80", "HALFWIDTH KATAKANA LETTER TA");
+-   ("/xef/xbe/x81", "HALFWIDTH KATAKANA LETTER TI");
+-   ("/xef/xbe/x82", "HALFWIDTH KATAKANA LETTER TU");
+-   ("/xef/xbe/x83", "HALFWIDTH KATAKANA LETTER TE");
+-   ("/xef/xbe/x84", "HALFWIDTH KATAKANA LETTER TO");
+-   ("/xef/xbe/x85", "HALFWIDTH KATAKANA LETTER NA");
+-   ("/xef/xbe/x86", "HALFWIDTH KATAKANA LETTER NI");
+-   ("/xef/xbe/x87", "HALFWIDTH KATAKANA LETTER NU");
+-   ("/xef/xbe/x88", "HALFWIDTH KATAKANA LETTER NE");
+-   ("/xef/xbe/x89", "HALFWIDTH KATAKANA LETTER NO");
+-   ("/xef/xbe/x8a", "HALFWIDTH KATAKANA LETTER HA");
+-   ("/xef/xbe/x8b", "HALFWIDTH KATAKANA LETTER HI");
+-   ("/xef/xbe/x8c", "HALFWIDTH KATAKANA LETTER HU");
+-   ("/xef/xbe/x8d", "HALFWIDTH KATAKANA LETTER HE");
+-   ("/xef/xbe/x8e", "HALFWIDTH KATAKANA LETTER HO");
+-   ("/xef/xbe/x8f", "HALFWIDTH KATAKANA LETTER MA");
+-   ("/xef/xbe/x90", "HALFWIDTH KATAKANA LETTER MI");
+-   ("/xef/xbe/x91", "HALFWIDTH KATAKANA LETTER MU");
+-   ("/xef/xbe/x92", "HALFWIDTH KATAKANA LETTER ME");
+-   ("/xef/xbe/x93", "HALFWIDTH KATAKANA LETTER MO");
+-   ("/xef/xbe/x94", "HALFWIDTH KATAKANA LETTER YA");
+-   ("/xef/xbe/x95", "HALFWIDTH KATAKANA LETTER YU");
+-   ("/xef/xbe/x96", "HALFWIDTH KATAKANA LETTER YO");
+-   ("/xef/xbe/x97", "HALFWIDTH KATAKANA LETTER RA");
+-   ("/xef/xbe/x98", "HALFWIDTH KATAKANA LETTER RI");
+-   ("/xef/xbe/x99", "HALFWIDTH KATAKANA LETTER RU");
+-   ("/xef/xbe/x9a", "HALFWIDTH KATAKANA LETTER RE");
+-   ("/xef/xbe/x9b", "HALFWIDTH KATAKANA LETTER RO");
+-   ("/xef/xbe/x9c", "HALFWIDTH KATAKANA LETTER WA");
+-   ("/xef/xbe/x9d", "HALFWIDTH KATAKANA LETTER N");
+-   ("/xef/xbe/x9e", "HALFWIDTH KATAKANA VOICED SOUND MARK");
+-   ("/xef/xbe/x9f", "HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK");
+-   ("/xef/xbe/xa0", "HALFWIDTH HANGUL FILLER");
+-   ("/xef/xbe/xa1", "HALFWIDTH HANGUL LETTER KIYEOK");
+-   ("/xef/xbe/xa2", "HALFWIDTH HANGUL LETTER SSANGKIYEOK");
+-   ("/xef/xbe/xa3", "HALFWIDTH HANGUL LETTER KIYEOK-SIOS");
+-   ("/xef/xbe/xa4", "HALFWIDTH HANGUL LETTER NIEUN");
+-   ("/xef/xbe/xa5", "HALFWIDTH HANGUL LETTER NIEUN-CIEUC");
+-   ("/xef/xbe/xa6", "HALFWIDTH HANGUL LETTER NIEUN-HIEUH");
+-   ("/xef/xbe/xa7", "HALFWIDTH HANGUL LETTER TIKEUT");
+-   ("/xef/xbe/xa8", "HALFWIDTH HANGUL LETTER SSANGTIKEUT");
+-   ("/xef/xbe/xa9", "HALFWIDTH HANGUL LETTER RIEUL");
+-   ("/xef/xbe/xaa", "HALFWIDTH HANGUL LETTER RIEUL-KIYEOK");
+-   ("/xef/xbe/xab", "HALFWIDTH HANGUL LETTER RIEUL-MIEUM");
+-   ("/xef/xbe/xac", "HALFWIDTH HANGUL LETTER RIEUL-PIEUP");
+-   ("/xef/xbe/xad", "HALFWIDTH HANGUL LETTER RIEUL-SIOS");
+-   ("/xef/xbe/xae", "HALFWIDTH HANGUL LETTER RIEUL-THIEUTH");
+-   ("/xef/xbe/xaf", "HALFWIDTH HANGUL LETTER RIEUL-PHIEUPH");
+-   ("/xef/xbe/xb0", "HALFWIDTH HANGUL LETTER RIEUL-HIEUH");
+-   ("/xef/xbe/xb1", "HALFWIDTH HANGUL LETTER MIEUM");
+-   ("/xef/xbe/xb2", "HALFWIDTH HANGUL LETTER PIEUP");
+-   ("/xef/xbe/xb3", "HALFWIDTH HANGUL LETTER SSANGPIEUP");
+-   ("/xef/xbe/xb4", "HALFWIDTH HANGUL LETTER PIEUP-SIOS");
+-   ("/xef/xbe/xb5", "HALFWIDTH HANGUL LETTER SIOS");
+-   ("/xef/xbe/xb6", "HALFWIDTH HANGUL LETTER SSANGSIOS");
+-   ("/xef/xbe/xb7", "HALFWIDTH HANGUL LETTER IEUNG");
+-   ("/xef/xbe/xb8", "HALFWIDTH HANGUL LETTER CIEUC");
+-   ("/xef/xbe/xb9", "HALFWIDTH HANGUL LETTER SSANGCIEUC");
+-   ("/xef/xbe/xba", "HALFWIDTH HANGUL LETTER CHIEUCH");
+-   ("/xef/xbe/xbb", "HALFWIDTH HANGUL LETTER KHIEUKH");
+-   ("/xef/xbe/xbc", "HALFWIDTH HANGUL LETTER THIEUTH");
+-   ("/xef/xbe/xbd", "HALFWIDTH HANGUL LETTER PHIEUPH");
+-   ("/xef/xbe/xbe", "HALFWIDTH HANGUL LETTER HIEUH");
+-   ("/xef/xbf/x82", "HALFWIDTH HANGUL LETTER A");
+-   ("/xef/xbf/x83", "HALFWIDTH HANGUL LETTER AE");
+-   ("/xef/xbf/x84", "HALFWIDTH HANGUL LETTER YA");
+-   ("/xef/xbf/x85", "HALFWIDTH HANGUL LETTER YAE");
+-   ("/xef/xbf/x86", "HALFWIDTH HANGUL LETTER EO");
+-   ("/xef/xbf/x87", "HALFWIDTH HANGUL LETTER E");
+-   ("/xef/xbf/x8a", "HALFWIDTH HANGUL LETTER YEO");
+-   ("/xef/xbf/x8b", "HALFWIDTH HANGUL LETTER YE");
+-   ("/xef/xbf/x8c", "HALFWIDTH HANGUL LETTER O");
+-   ("/xef/xbf/x8d", "HALFWIDTH HANGUL LETTER WA");
+-   ("/xef/xbf/x8e", "HALFWIDTH HANGUL LETTER WAE");
+-   ("/xef/xbf/x8f", "HALFWIDTH HANGUL LETTER OE");
+-   ("/xef/xbf/x92", "HALFWIDTH HANGUL LETTER YO");
+-   ("/xef/xbf/x93", "HALFWIDTH HANGUL LETTER U");
+-   ("/xef/xbf/x94", "HALFWIDTH HANGUL LETTER WEO");
+-   ("/xef/xbf/x95", "HALFWIDTH HANGUL LETTER WE");
+-   ("/xef/xbf/x96", "HALFWIDTH HANGUL LETTER WI");
+-   ("/xef/xbf/x97", "HALFWIDTH HANGUL LETTER YU");
+-   ("/xef/xbf/x9a", "HALFWIDTH HANGUL LETTER EU");
+-   ("/xef/xbf/x9b", "HALFWIDTH HANGUL LETTER YI");
+-   ("/xef/xbf/x9c", "HALFWIDTH HANGUL LETTER I");
+-   ("/xef/xbf/xa0", "FULLWIDTH CENT SIGN");
+-   ("/xef/xbf/xa1", "FULLWIDTH POUND SIGN");
+-   ("/xef/xbf/xa2", "FULLWIDTH NOT SIGN");
+-   ("/xef/xbf/xa3", "FULLWIDTH MACRON");
+-   ("/xef/xbf/xa4", "FULLWIDTH BROKEN BAR");
+-   ("/xef/xbf/xa5", "FULLWIDTH YEN SIGN");
+-   ("/xef/xbf/xa6", "FULLWIDTH WON SIGN");
+-   ("/xef/xbf/xa8", "HALFWIDTH FORMS LIGHT VERTICAL");
+-   ("/xef/xbf/xa9", "HALFWIDTH LEFTWARDS ARROW");
+-   ("/xef/xbf/xaa", "HALFWIDTH UPWARDS ARROW");
+-   ("/xef/xbf/xab", "HALFWIDTH RIGHTWARDS ARROW");
+-   ("/xef/xbf/xac", "HALFWIDTH DOWNWARDS ARROW");
+-   ("/xef/xbf/xad", "HALFWIDTH BLACK SQUARE");
+-   ("/xef/xbf/xae", "HALFWIDTH WHITE CIRCLE");
+-   ("/xef/xbf/xb9", "INTERLINEAR ANNOTATION ANCHOR");
+-   ("/xef/xbf/xba", "INTERLINEAR ANNOTATION SEPARATOR");
+-   ("/xef/xbf/xbb", "INTERLINEAR ANNOTATION TERMINATOR");
+-   ("/xef/xbf/xbc", "OBJECT REPLACEMENT CHARACTER");
+-   ("/xef/xbf/xbd", "REPLACEMENT CHARACTER");
+-   ("/xf0/x90/x80/x80", "LINEAR B SYLLABLE B008 A");
+-   ("/xf0/x90/x80/x81", "LINEAR B SYLLABLE B038 E");
+-   ("/xf0/x90/x80/x82", "LINEAR B SYLLABLE B028 I");
+-   ("/xf0/x90/x80/x83", "LINEAR B SYLLABLE B061 O");
+-   ("/xf0/x90/x80/x84", "LINEAR B SYLLABLE B010 U");
+-   ("/xf0/x90/x80/x85", "LINEAR B SYLLABLE B001 DA");
+-   ("/xf0/x90/x80/x86", "LINEAR B SYLLABLE B045 DE");
+-   ("/xf0/x90/x80/x87", "LINEAR B SYLLABLE B007 DI");
+-   ("/xf0/x90/x80/x88", "LINEAR B SYLLABLE B014 DO");
+-   ("/xf0/x90/x80/x89", "LINEAR B SYLLABLE B051 DU");
+-   ("/xf0/x90/x80/x8a", "LINEAR B SYLLABLE B057 JA");
+-   ("/xf0/x90/x80/x8b", "LINEAR B SYLLABLE B046 JE");
+-   ("/xf0/x90/x80/x8d", "LINEAR B SYLLABLE B036 JO");
+-   ("/xf0/x90/x80/x8e", "LINEAR B SYLLABLE B065 JU");
+-   ("/xf0/x90/x80/x8f", "LINEAR B SYLLABLE B077 KA");
+-   ("/xf0/x90/x80/x90", "LINEAR B SYLLABLE B044 KE");
+-   ("/xf0/x90/x80/x91", "LINEAR B SYLLABLE B067 KI");
+-   ("/xf0/x90/x80/x92", "LINEAR B SYLLABLE B070 KO");
+-   ("/xf0/x90/x80/x93", "LINEAR B SYLLABLE B081 KU");
+-   ("/xf0/x90/x80/x94", "LINEAR B SYLLABLE B080 MA");
+-   ("/xf0/x90/x80/x95", "LINEAR B SYLLABLE B013 ME");
+-   ("/xf0/x90/x80/x96", "LINEAR B SYLLABLE B073 MI");
+-   ("/xf0/x90/x80/x97", "LINEAR B SYLLABLE B015 MO");
+-   ("/xf0/x90/x80/x98", "LINEAR B SYLLABLE B023 MU");
+-   ("/xf0/x90/x80/x99", "LINEAR B SYLLABLE B006 NA");
+-   ("/xf0/x90/x80/x9a", "LINEAR B SYLLABLE B024 NE");
+-   ("/xf0/x90/x80/x9b", "LINEAR B SYLLABLE B030 NI");
+-   ("/xf0/x90/x80/x9c", "LINEAR B SYLLABLE B052 NO");
+-   ("/xf0/x90/x80/x9d", "LINEAR B SYLLABLE B055 NU");
+-   ("/xf0/x90/x80/x9e", "LINEAR B SYLLABLE B003 PA");
+-   ("/xf0/x90/x80/x9f", "LINEAR B SYLLABLE B072 PE");
+-   ("/xf0/x90/x80/xa0", "LINEAR B SYLLABLE B039 PI");
+-   ("/xf0/x90/x80/xa1", "LINEAR B SYLLABLE B011 PO");
+-   ("/xf0/x90/x80/xa2", "LINEAR B SYLLABLE B050 PU");
+-   ("/xf0/x90/x80/xa3", "LINEAR B SYLLABLE B016 QA");
+-   ("/xf0/x90/x80/xa4", "LINEAR B SYLLABLE B078 QE");
+-   ("/xf0/x90/x80/xa5", "LINEAR B SYLLABLE B021 QI");
+-   ("/xf0/x90/x80/xa6", "LINEAR B SYLLABLE B032 QO");
+-   ("/xf0/x90/x80/xa8", "LINEAR B SYLLABLE B060 RA");
+-   ("/xf0/x90/x80/xa9", "LINEAR B SYLLABLE B027 RE");
+-   ("/xf0/x90/x80/xaa", "LINEAR B SYLLABLE B053 RI");
+-   ("/xf0/x90/x80/xab", "LINEAR B SYLLABLE B002 RO");
+-   ("/xf0/x90/x80/xac", "LINEAR B SYLLABLE B026 RU");
+-   ("/xf0/x90/x80/xad", "LINEAR B SYLLABLE B031 SA");
+-   ("/xf0/x90/x80/xae", "LINEAR B SYLLABLE B009 SE");
+-   ("/xf0/x90/x80/xaf", "LINEAR B SYLLABLE B041 SI");
+-   ("/xf0/x90/x80/xb0", "LINEAR B SYLLABLE B012 SO");
+-   ("/xf0/x90/x80/xb1", "LINEAR B SYLLABLE B058 SU");
+-   ("/xf0/x90/x80/xb2", "LINEAR B SYLLABLE B059 TA");
+-   ("/xf0/x90/x80/xb3", "LINEAR B SYLLABLE B004 TE");
+-   ("/xf0/x90/x80/xb4", "LINEAR B SYLLABLE B037 TI");
+-   ("/xf0/x90/x80/xb5", "LINEAR B SYLLABLE B005 TO");
+-   ("/xf0/x90/x80/xb6", "LINEAR B SYLLABLE B069 TU");
+-   ("/xf0/x90/x80/xb7", "LINEAR B SYLLABLE B054 WA");
+-   ("/xf0/x90/x80/xb8", "LINEAR B SYLLABLE B075 WE");
+-   ("/xf0/x90/x80/xb9", "LINEAR B SYLLABLE B040 WI");
+-   ("/xf0/x90/x80/xba", "LINEAR B SYLLABLE B042 WO");
+-   ("/xf0/x90/x80/xbc", "LINEAR B SYLLABLE B017 ZA");
+-   ("/xf0/x90/x80/xbd", "LINEAR B SYLLABLE B074 ZE");
+-   ("/xf0/x90/x80/xbf", "LINEAR B SYLLABLE B020 ZO");
+-   ("/xf0/x90/x81/x80", "LINEAR B SYLLABLE B025 A2");
+-   ("/xf0/x90/x81/x81", "LINEAR B SYLLABLE B043 A3");
+-   ("/xf0/x90/x81/x82", "LINEAR B SYLLABLE B085 AU");
+-   ("/xf0/x90/x81/x83", "LINEAR B SYLLABLE B071 DWE");
+-   ("/xf0/x90/x81/x84", "LINEAR B SYLLABLE B090 DWO");
+-   ("/xf0/x90/x81/x85", "LINEAR B SYLLABLE B048 NWA");
+-   ("/xf0/x90/x81/x86", "LINEAR B SYLLABLE B029 PU2");
+-   ("/xf0/x90/x81/x87", "LINEAR B SYLLABLE B062 PTE");
+-   ("/xf0/x90/x81/x88", "LINEAR B SYLLABLE B076 RA2");
+-   ("/xf0/x90/x81/x89", "LINEAR B SYLLABLE B033 RA3");
+-   ("/xf0/x90/x81/x8a", "LINEAR B SYLLABLE B068 RO2");
+-   ("/xf0/x90/x81/x8b", "LINEAR B SYLLABLE B066 TA2");
+-   ("/xf0/x90/x81/x8c", "LINEAR B SYLLABLE B087 TWE");
+-   ("/xf0/x90/x81/x8d", "LINEAR B SYLLABLE B091 TWO");
+-   ("/xf0/x90/x81/x90", "LINEAR B SYMBOL B018");
+-   ("/xf0/x90/x81/x91", "LINEAR B SYMBOL B019");
+-   ("/xf0/x90/x81/x92", "LINEAR B SYMBOL B022");
+-   ("/xf0/x90/x81/x93", "LINEAR B SYMBOL B034");
+-   ("/xf0/x90/x81/x94", "LINEAR B SYMBOL B047");
+-   ("/xf0/x90/x81/x95", "LINEAR B SYMBOL B049");
+-   ("/xf0/x90/x81/x96", "LINEAR B SYMBOL B056");
+-   ("/xf0/x90/x81/x97", "LINEAR B SYMBOL B063");
+-   ("/xf0/x90/x81/x98", "LINEAR B SYMBOL B064");
+-   ("/xf0/x90/x81/x99", "LINEAR B SYMBOL B079");
+-   ("/xf0/x90/x81/x9a", "LINEAR B SYMBOL B082");
+-   ("/xf0/x90/x81/x9b", "LINEAR B SYMBOL B083");
+-   ("/xf0/x90/x81/x9c", "LINEAR B SYMBOL B086");
+-   ("/xf0/x90/x81/x9d", "LINEAR B SYMBOL B089");
+-   ("/xf0/x90/x82/x80", "LINEAR B IDEOGRAM B100 MAN");
+-   ("/xf0/x90/x82/x81", "LINEAR B IDEOGRAM B102 WOMAN");
+-   ("/xf0/x90/x82/x82", "LINEAR B IDEOGRAM B104 DEER");
+-   ("/xf0/x90/x82/x83", "LINEAR B IDEOGRAM B105 EQUID");
+-   ("/xf0/x90/x82/x84", "LINEAR B IDEOGRAM B105F MARE");
+-   ("/xf0/x90/x82/x85", "LINEAR B IDEOGRAM B105M STALLION");
+-   ("/xf0/x90/x82/x86", "LINEAR B IDEOGRAM B106F EWE");
+-   ("/xf0/x90/x82/x87", "LINEAR B IDEOGRAM B106M RAM");
+-   ("/xf0/x90/x82/x88", "LINEAR B IDEOGRAM B107F SHE-GOAT");
+-   ("/xf0/x90/x82/x89", "LINEAR B IDEOGRAM B107M HE-GOAT");
+-   ("/xf0/x90/x82/x8a", "LINEAR B IDEOGRAM B108F SOW");
+-   ("/xf0/x90/x82/x8b", "LINEAR B IDEOGRAM B108M BOAR");
+-   ("/xf0/x90/x82/x8c", "LINEAR B IDEOGRAM B109F COW");
+-   ("/xf0/x90/x82/x8d", "LINEAR B IDEOGRAM B109M BULL");
+-   ("/xf0/x90/x82/x8e", "LINEAR B IDEOGRAM B120 WHEAT");
+-   ("/xf0/x90/x82/x8f", "LINEAR B IDEOGRAM B121 BARLEY");
+-   ("/xf0/x90/x82/x90", "LINEAR B IDEOGRAM B122 OLIVE");
+-   ("/xf0/x90/x82/x91", "LINEAR B IDEOGRAM B123 SPICE");
+-   ("/xf0/x90/x82/x92", "LINEAR B IDEOGRAM B125 CYPERUS");
+-   ("/xf0/x90/x82/x93", "LINEAR B MONOGRAM B127 KAPO");
+-   ("/xf0/x90/x82/x94", "LINEAR B MONOGRAM B128 KANAKO");
+-   ("/xf0/x90/x82/x95", "LINEAR B IDEOGRAM B130 OIL");
+-   ("/xf0/x90/x82/x96", "LINEAR B IDEOGRAM B131 WINE");
+-   ("/xf0/x90/x82/x97", "LINEAR B IDEOGRAM B132");
+-   ("/xf0/x90/x82/x98", "LINEAR B MONOGRAM B133 AREPA");
+-   ("/xf0/x90/x82/x99", "LINEAR B MONOGRAM B135 MERI");
+-   ("/xf0/x90/x82/x9a", "LINEAR B IDEOGRAM B140 BRONZE");
+-   ("/xf0/x90/x82/x9b", "LINEAR B IDEOGRAM B141 GOLD");
+-   ("/xf0/x90/x82/x9c", "LINEAR B IDEOGRAM B142");
+-   ("/xf0/x90/x82/x9d", "LINEAR B IDEOGRAM B145 WOOL");
+-   ("/xf0/x90/x82/x9e", "LINEAR B IDEOGRAM B146");
+-   ("/xf0/x90/x82/x9f", "LINEAR B IDEOGRAM B150");
+-   ("/xf0/x90/x82/xa0", "LINEAR B IDEOGRAM B151 HORN");
+-   ("/xf0/x90/x82/xa1", "LINEAR B IDEOGRAM B152");
+-   ("/xf0/x90/x82/xa2", "LINEAR B IDEOGRAM B153");
+-   ("/xf0/x90/x82/xa3", "LINEAR B IDEOGRAM B154");
+-   ("/xf0/x90/x82/xa4", "LINEAR B MONOGRAM B156 TURO2");
+-   ("/xf0/x90/x82/xa5", "LINEAR B IDEOGRAM B157");
+-   ("/xf0/x90/x82/xa6", "LINEAR B IDEOGRAM B158");
+-   ("/xf0/x90/x82/xa7", "LINEAR B IDEOGRAM B159 CLOTH");
+-   ("/xf0/x90/x82/xa8", "LINEAR B IDEOGRAM B160");
+-   ("/xf0/x90/x82/xa9", "LINEAR B IDEOGRAM B161");
+-   ("/xf0/x90/x82/xaa", "LINEAR B IDEOGRAM B162 GARMENT");
+-   ("/xf0/x90/x82/xab", "LINEAR B IDEOGRAM B163 ARMOUR");
+-   ("/xf0/x90/x82/xac", "LINEAR B IDEOGRAM B164");
+-   ("/xf0/x90/x82/xad", "LINEAR B IDEOGRAM B165");
+-   ("/xf0/x90/x82/xae", "LINEAR B IDEOGRAM B166");
+-   ("/xf0/x90/x82/xaf", "LINEAR B IDEOGRAM B167");
+-   ("/xf0/x90/x82/xb0", "LINEAR B IDEOGRAM B168");
+-   ("/xf0/x90/x82/xb1", "LINEAR B IDEOGRAM B169");
+-   ("/xf0/x90/x82/xb2", "LINEAR B IDEOGRAM B170");
+-   ("/xf0/x90/x82/xb3", "LINEAR B IDEOGRAM B171");
+-   ("/xf0/x90/x82/xb4", "LINEAR B IDEOGRAM B172");
+-   ("/xf0/x90/x82/xb5", "LINEAR B IDEOGRAM B173 MONTH");
+-   ("/xf0/x90/x82/xb6", "LINEAR B IDEOGRAM B174");
+-   ("/xf0/x90/x82/xb7", "LINEAR B IDEOGRAM B176 TREE");
+-   ("/xf0/x90/x82/xb8", "LINEAR B IDEOGRAM B177");
+-   ("/xf0/x90/x82/xb9", "LINEAR B IDEOGRAM B178");
+-   ("/xf0/x90/x82/xba", "LINEAR B IDEOGRAM B179");
+-   ("/xf0/x90/x82/xbb", "LINEAR B IDEOGRAM B180");
+-   ("/xf0/x90/x82/xbc", "LINEAR B IDEOGRAM B181");
+-   ("/xf0/x90/x82/xbd", "LINEAR B IDEOGRAM B182");
+-   ("/xf0/x90/x82/xbe", "LINEAR B IDEOGRAM B183");
+-   ("/xf0/x90/x82/xbf", "LINEAR B IDEOGRAM B184");
+-   ("/xf0/x90/x83/x80", "LINEAR B IDEOGRAM B185");
+-   ("/xf0/x90/x83/x81", "LINEAR B IDEOGRAM B189");
+-   ("/xf0/x90/x83/x82", "LINEAR B IDEOGRAM B190");
+-   ("/xf0/x90/x83/x83", "LINEAR B IDEOGRAM B191 HELMET");
+-   ("/xf0/x90/x83/x84", "LINEAR B IDEOGRAM B220 FOOTSTOOL");
+-   ("/xf0/x90/x83/x85", "LINEAR B IDEOGRAM B225 BATHTUB");
+-   ("/xf0/x90/x83/x86", "LINEAR B IDEOGRAM B230 SPEAR");
+-   ("/xf0/x90/x83/x87", "LINEAR B IDEOGRAM B231 ARROW");
+-   ("/xf0/x90/x83/x88", "LINEAR B IDEOGRAM B232");
+-   ("/xf0/x90/x83/x89", "LINEAR B IDEOGRAM B233 SWORD");
+-   ("/xf0/x90/x83/x8a", "LINEAR B IDEOGRAM B234");
+-   ("/xf0/x90/x83/x8b", "LINEAR B IDEOGRAM B236");
+-   ("/xf0/x90/x83/x8c", "LINEAR B IDEOGRAM B240 WHEELED CHARIOT");
+-   ("/xf0/x90/x83/x8d", "LINEAR B IDEOGRAM B241 CHARIOT");
+-   ("/xf0/x90/x83/x8e", "LINEAR B IDEOGRAM B242 CHARIOT FRAME");
+-   ("/xf0/x90/x83/x8f", "LINEAR B IDEOGRAM B243 WHEEL");
+-   ("/xf0/x90/x83/x90", "LINEAR B IDEOGRAM B245");
+-   ("/xf0/x90/x83/x91", "LINEAR B IDEOGRAM B246");
+-   ("/xf0/x90/x83/x92", "LINEAR B MONOGRAM B247 DIPTE");
+-   ("/xf0/x90/x83/x93", "LINEAR B IDEOGRAM B248");
+-   ("/xf0/x90/x83/x94", "LINEAR B IDEOGRAM B249");
+-   ("/xf0/x90/x83/x95", "LINEAR B IDEOGRAM B251");
+-   ("/xf0/x90/x83/x96", "LINEAR B IDEOGRAM B252");
+-   ("/xf0/x90/x83/x97", "LINEAR B IDEOGRAM B253");
+-   ("/xf0/x90/x83/x98", "LINEAR B IDEOGRAM B254 DART");
+-   ("/xf0/x90/x83/x99", "LINEAR B IDEOGRAM B255");
+-   ("/xf0/x90/x83/x9a", "LINEAR B IDEOGRAM B256");
+-   ("/xf0/x90/x83/x9b", "LINEAR B IDEOGRAM B257");
+-   ("/xf0/x90/x83/x9c", "LINEAR B IDEOGRAM B258");
+-   ("/xf0/x90/x83/x9d", "LINEAR B IDEOGRAM B259");
+-   ("/xf0/x90/x83/x9e", "LINEAR B IDEOGRAM VESSEL B155");
+-   ("/xf0/x90/x83/x9f", "LINEAR B IDEOGRAM VESSEL B200");
+-   ("/xf0/x90/x83/xa0", "LINEAR B IDEOGRAM VESSEL B201");
+-   ("/xf0/x90/x83/xa1", "LINEAR B IDEOGRAM VESSEL B202");
+-   ("/xf0/x90/x83/xa2", "LINEAR B IDEOGRAM VESSEL B203");
+-   ("/xf0/x90/x83/xa3", "LINEAR B IDEOGRAM VESSEL B204");
+-   ("/xf0/x90/x83/xa4", "LINEAR B IDEOGRAM VESSEL B205");
+-   ("/xf0/x90/x83/xa5", "LINEAR B IDEOGRAM VESSEL B206");
+-   ("/xf0/x90/x83/xa6", "LINEAR B IDEOGRAM VESSEL B207");
+-   ("/xf0/x90/x83/xa7", "LINEAR B IDEOGRAM VESSEL B208");
+-   ("/xf0/x90/x83/xa8", "LINEAR B IDEOGRAM VESSEL B209");
+-   ("/xf0/x90/x83/xa9", "LINEAR B IDEOGRAM VESSEL B210");
+-   ("/xf0/x90/x83/xaa", "LINEAR B IDEOGRAM VESSEL B211");
+-   ("/xf0/x90/x83/xab", "LINEAR B IDEOGRAM VESSEL B212");
+-   ("/xf0/x90/x83/xac", "LINEAR B IDEOGRAM VESSEL B213");
+-   ("/xf0/x90/x83/xad", "LINEAR B IDEOGRAM VESSEL B214");
+-   ("/xf0/x90/x83/xae", "LINEAR B IDEOGRAM VESSEL B215");
+-   ("/xf0/x90/x83/xaf", "LINEAR B IDEOGRAM VESSEL B216");
+-   ("/xf0/x90/x83/xb0", "LINEAR B IDEOGRAM VESSEL B217");
+-   ("/xf0/x90/x83/xb1", "LINEAR B IDEOGRAM VESSEL B218");
+-   ("/xf0/x90/x83/xb2", "LINEAR B IDEOGRAM VESSEL B219");
+-   ("/xf0/x90/x83/xb3", "LINEAR B IDEOGRAM VESSEL B221");
+-   ("/xf0/x90/x83/xb4", "LINEAR B IDEOGRAM VESSEL B222");
+-   ("/xf0/x90/x83/xb5", "LINEAR B IDEOGRAM VESSEL B226");
+-   ("/xf0/x90/x83/xb6", "LINEAR B IDEOGRAM VESSEL B227");
+-   ("/xf0/x90/x83/xb7", "LINEAR B IDEOGRAM VESSEL B228");
+-   ("/xf0/x90/x83/xb8", "LINEAR B IDEOGRAM VESSEL B229");
+-   ("/xf0/x90/x83/xb9", "LINEAR B IDEOGRAM VESSEL B250");
+-   ("/xf0/x90/x83/xba", "LINEAR B IDEOGRAM VESSEL B305");
+-   ("/xf0/x90/x84/x80", "AEGEAN WORD SEPARATOR LINE");
+-   ("/xf0/x90/x84/x81", "AEGEAN WORD SEPARATOR DOT");
+-   ("/xf0/x90/x84/x82", "AEGEAN CHECK MARK");
+-   ("/xf0/x90/x84/x87", "AEGEAN NUMBER ONE");
+-   ("/xf0/x90/x84/x88", "AEGEAN NUMBER TWO");
+-   ("/xf0/x90/x84/x89", "AEGEAN NUMBER THREE");
+-   ("/xf0/x90/x84/x8a", "AEGEAN NUMBER FOUR");
+-   ("/xf0/x90/x84/x8b", "AEGEAN NUMBER FIVE");
+-   ("/xf0/x90/x84/x8c", "AEGEAN NUMBER SIX");
+-   ("/xf0/x90/x84/x8d", "AEGEAN NUMBER SEVEN");
+-   ("/xf0/x90/x84/x8e", "AEGEAN NUMBER EIGHT");
+-   ("/xf0/x90/x84/x8f", "AEGEAN NUMBER NINE");
+-   ("/xf0/x90/x84/x90", "AEGEAN NUMBER TEN");
+-   ("/xf0/x90/x84/x91", "AEGEAN NUMBER TWENTY");
+-   ("/xf0/x90/x84/x92", "AEGEAN NUMBER THIRTY");
+-   ("/xf0/x90/x84/x93", "AEGEAN NUMBER FORTY");
+-   ("/xf0/x90/x84/x94", "AEGEAN NUMBER FIFTY");
+-   ("/xf0/x90/x84/x95", "AEGEAN NUMBER SIXTY");
+-   ("/xf0/x90/x84/x96", "AEGEAN NUMBER SEVENTY");
+-   ("/xf0/x90/x84/x97", "AEGEAN NUMBER EIGHTY");
+-   ("/xf0/x90/x84/x98", "AEGEAN NUMBER NINETY");
+-   ("/xf0/x90/x84/x99", "AEGEAN NUMBER ONE HUNDRED");
+-   ("/xf0/x90/x84/x9a", "AEGEAN NUMBER TWO HUNDRED");
+-   ("/xf0/x90/x84/x9b", "AEGEAN NUMBER THREE HUNDRED");
+-   ("/xf0/x90/x84/x9c", "AEGEAN NUMBER FOUR HUNDRED");
+-   ("/xf0/x90/x84/x9d", "AEGEAN NUMBER FIVE HUNDRED");
+-   ("/xf0/x90/x84/x9e", "AEGEAN NUMBER SIX HUNDRED");
+-   ("/xf0/x90/x84/x9f", "AEGEAN NUMBER SEVEN HUNDRED");
+-   ("/xf0/x90/x84/xa0", "AEGEAN NUMBER EIGHT HUNDRED");
+-   ("/xf0/x90/x84/xa1", "AEGEAN NUMBER NINE HUNDRED");
+-   ("/xf0/x90/x84/xa2", "AEGEAN NUMBER ONE THOUSAND");
+-   ("/xf0/x90/x84/xa3", "AEGEAN NUMBER TWO THOUSAND");
+-   ("/xf0/x90/x84/xa4", "AEGEAN NUMBER THREE THOUSAND");
+-   ("/xf0/x90/x84/xa5", "AEGEAN NUMBER FOUR THOUSAND");
+-   ("/xf0/x90/x84/xa6", "AEGEAN NUMBER FIVE THOUSAND");
+-   ("/xf0/x90/x84/xa7", "AEGEAN NUMBER SIX THOUSAND");
+-   ("/xf0/x90/x84/xa8", "AEGEAN NUMBER SEVEN THOUSAND");
+-   ("/xf0/x90/x84/xa9", "AEGEAN NUMBER EIGHT THOUSAND");
+-   ("/xf0/x90/x84/xaa", "AEGEAN NUMBER NINE THOUSAND");
+-   ("/xf0/x90/x84/xab", "AEGEAN NUMBER TEN THOUSAND");
+-   ("/xf0/x90/x84/xac", "AEGEAN NUMBER TWENTY THOUSAND");
+-   ("/xf0/x90/x84/xad", "AEGEAN NUMBER THIRTY THOUSAND");
+-   ("/xf0/x90/x84/xae", "AEGEAN NUMBER FORTY THOUSAND");
+-   ("/xf0/x90/x84/xaf", "AEGEAN NUMBER FIFTY THOUSAND");
+-   ("/xf0/x90/x84/xb0", "AEGEAN NUMBER SIXTY THOUSAND");
+-   ("/xf0/x90/x84/xb1", "AEGEAN NUMBER SEVENTY THOUSAND");
+-   ("/xf0/x90/x84/xb2", "AEGEAN NUMBER EIGHTY THOUSAND");
+-   ("/xf0/x90/x84/xb3", "AEGEAN NUMBER NINETY THOUSAND");
+-   ("/xf0/x90/x84/xb7", "AEGEAN WEIGHT BASE UNIT");
+-   ("/xf0/x90/x84/xb8", "AEGEAN WEIGHT FIRST SUBUNIT");
+-   ("/xf0/x90/x84/xb9", "AEGEAN WEIGHT SECOND SUBUNIT");
+-   ("/xf0/x90/x84/xba", "AEGEAN WEIGHT THIRD SUBUNIT");
+-   ("/xf0/x90/x84/xbb", "AEGEAN WEIGHT FOURTH SUBUNIT");
+-   ("/xf0/x90/x84/xbc", "AEGEAN DRY MEASURE FIRST SUBUNIT");
+-   ("/xf0/x90/x84/xbd", "AEGEAN LIQUID MEASURE FIRST SUBUNIT");
+-   ("/xf0/x90/x84/xbe", "AEGEAN MEASURE SECOND SUBUNIT");
+-   ("/xf0/x90/x84/xbf", "AEGEAN MEASURE THIRD SUBUNIT");
+-   ("/xf0/x90/x85/x80", "GREEK ACROPHONIC ATTIC ONE QUARTER");
+-   ("/xf0/x90/x85/x81", "GREEK ACROPHONIC ATTIC ONE HALF");
+-   ("/xf0/x90/x85/x82", "GREEK ACROPHONIC ATTIC ONE DRACHMA");
+-   ("/xf0/x90/x85/x83", "GREEK ACROPHONIC ATTIC FIVE");
+-   ("/xf0/x90/x85/x84", "GREEK ACROPHONIC ATTIC FIFTY");
+-   ("/xf0/x90/x85/x85", "GREEK ACROPHONIC ATTIC FIVE HUNDRED");
+-   ("/xf0/x90/x85/x86", "GREEK ACROPHONIC ATTIC FIVE THOUSAND");
+-   ("/xf0/x90/x85/x87", "GREEK ACROPHONIC ATTIC FIFTY THOUSAND");
+-   ("/xf0/x90/x85/x88", "GREEK ACROPHONIC ATTIC FIVE TALENTS");
+-   ("/xf0/x90/x85/x89", "GREEK ACROPHONIC ATTIC TEN TALENTS");
+-   ("/xf0/x90/x85/x8a", "GREEK ACROPHONIC ATTIC FIFTY TALENTS");
+-   ("/xf0/x90/x85/x8b", "GREEK ACROPHONIC ATTIC ONE HUNDRED TALENTS");
+-   ("/xf0/x90/x85/x8c", "GREEK ACROPHONIC ATTIC FIVE HUNDRED TALENTS");
+-   ("/xf0/x90/x85/x8d", "GREEK ACROPHONIC ATTIC ONE THOUSAND TALENTS");
+-   ("/xf0/x90/x85/x8e", "GREEK ACROPHONIC ATTIC FIVE THOUSAND TALENTS");
+-   ("/xf0/x90/x85/x8f", "GREEK ACROPHONIC ATTIC FIVE STATERS");
+-   ("/xf0/x90/x85/x90", "GREEK ACROPHONIC ATTIC TEN STATERS");
+-   ("/xf0/x90/x85/x91", "GREEK ACROPHONIC ATTIC FIFTY STATERS");
+-   ("/xf0/x90/x85/x92", "GREEK ACROPHONIC ATTIC ONE HUNDRED STATERS");
+-   ("/xf0/x90/x85/x93", "GREEK ACROPHONIC ATTIC FIVE HUNDRED STATERS");
+-   ("/xf0/x90/x85/x94", "GREEK ACROPHONIC ATTIC ONE THOUSAND STATERS");
+-   ("/xf0/x90/x85/x95", "GREEK ACROPHONIC ATTIC TEN THOUSAND STATERS");
+-   ("/xf0/x90/x85/x96", "GREEK ACROPHONIC ATTIC FIFTY THOUSAND STATERS");
+-   ("/xf0/x90/x85/x97", "GREEK ACROPHONIC ATTIC TEN MNAS");
+-   ("/xf0/x90/x85/x98", "GREEK ACROPHONIC HERAEUM ONE PLETHRON");
+-   ("/xf0/x90/x85/x99", "GREEK ACROPHONIC THESPIAN ONE");
+-   ("/xf0/x90/x85/x9a", "GREEK ACROPHONIC HERMIONIAN ONE");
+-   ("/xf0/x90/x85/x9b", "GREEK ACROPHONIC EPIDAUREAN TWO");
+-   ("/xf0/x90/x85/x9c", "GREEK ACROPHONIC THESPIAN TWO");
+-   ("/xf0/x90/x85/x9d", "GREEK ACROPHONIC CYRENAIC TWO DRACHMAS");
+-   ("/xf0/x90/x85/x9e", "GREEK ACROPHONIC EPIDAUREAN TWO DRACHMAS");
+-   ("/xf0/x90/x85/x9f", "GREEK ACROPHONIC TROEZENIAN FIVE");
+-   ("/xf0/x90/x85/xa0", "GREEK ACROPHONIC TROEZENIAN TEN");
+-   ("/xf0/x90/x85/xa1", "GREEK ACROPHONIC TROEZENIAN TEN ALTERNATE FORM");
+-   ("/xf0/x90/x85/xa2", "GREEK ACROPHONIC HERMIONIAN TEN");
+-   ("/xf0/x90/x85/xa3", "GREEK ACROPHONIC MESSENIAN TEN");
+-   ("/xf0/x90/x85/xa4", "GREEK ACROPHONIC THESPIAN TEN");
+-   ("/xf0/x90/x85/xa5", "GREEK ACROPHONIC THESPIAN THIRTY");
+-   ("/xf0/x90/x85/xa6", "GREEK ACROPHONIC TROEZENIAN FIFTY");
+-   ("/xf0/x90/x85/xa7", "GREEK ACROPHONIC TROEZENIAN FIFTY ALTERNATE FORM");
+-   ("/xf0/x90/x85/xa8", "GREEK ACROPHONIC HERMIONIAN FIFTY");
+-   ("/xf0/x90/x85/xa9", "GREEK ACROPHONIC THESPIAN FIFTY");
+-   ("/xf0/x90/x85/xaa", "GREEK ACROPHONIC THESPIAN ONE HUNDRED");
+-   ("/xf0/x90/x85/xab", "GREEK ACROPHONIC THESPIAN THREE HUNDRED");
+-   ("/xf0/x90/x85/xac", "GREEK ACROPHONIC EPIDAUREAN FIVE HUNDRED");
+-   ("/xf0/x90/x85/xad", "GREEK ACROPHONIC TROEZENIAN FIVE HUNDRED");
+-   ("/xf0/x90/x85/xae", "GREEK ACROPHONIC THESPIAN FIVE HUNDRED");
+-   ("/xf0/x90/x85/xaf", "GREEK ACROPHONIC CARYSTIAN FIVE HUNDRED");
+-   ("/xf0/x90/x85/xb0", "GREEK ACROPHONIC NAXIAN FIVE HUNDRED");
+-   ("/xf0/x90/x85/xb1", "GREEK ACROPHONIC THESPIAN ONE THOUSAND");
+-   ("/xf0/x90/x85/xb2", "GREEK ACROPHONIC THESPIAN FIVE THOUSAND");
+-   ("/xf0/x90/x85/xb3", "GREEK ACROPHONIC DELPHIC FIVE MNAS");
+-   ("/xf0/x90/x85/xb4", "GREEK ACROPHONIC STRATIAN FIFTY MNAS");
+-   ("/xf0/x90/x85/xb5", "GREEK ONE HALF SIGN");
+-   ("/xf0/x90/x85/xb6", "GREEK ONE HALF SIGN ALTERNATE FORM");
+-   ("/xf0/x90/x85/xb7", "GREEK TWO THIRDS SIGN");
+-   ("/xf0/x90/x85/xb8", "GREEK THREE QUARTERS SIGN");
+-   ("/xf0/x90/x85/xb9", "GREEK YEAR SIGN");
+-   ("/xf0/x90/x85/xba", "GREEK TALENT SIGN");
+-   ("/xf0/x90/x85/xbb", "GREEK DRACHMA SIGN");
+-   ("/xf0/x90/x85/xbc", "GREEK OBOL SIGN");
+-   ("/xf0/x90/x85/xbd", "GREEK TWO OBOLS SIGN");
+-   ("/xf0/x90/x85/xbe", "GREEK THREE OBOLS SIGN");
+-   ("/xf0/x90/x85/xbf", "GREEK FOUR OBOLS SIGN");
+-   ("/xf0/x90/x86/x80", "GREEK FIVE OBOLS SIGN");
+-   ("/xf0/x90/x86/x81", "GREEK METRETES SIGN");
+-   ("/xf0/x90/x86/x82", "GREEK KYATHOS BASE SIGN");
+-   ("/xf0/x90/x86/x83", "GREEK LITRA SIGN");
+-   ("/xf0/x90/x86/x84", "GREEK OUNKIA SIGN");
+-   ("/xf0/x90/x86/x85", "GREEK XESTES SIGN");
+-   ("/xf0/x90/x86/x86", "GREEK ARTABE SIGN");
+-   ("/xf0/x90/x86/x87", "GREEK AROURA SIGN");
+-   ("/xf0/x90/x86/x88", "GREEK GRAMMA SIGN");
+-   ("/xf0/x90/x86/x89", "GREEK TRYBLION BASE SIGN");
+-   ("/xf0/x90/x86/x8a", "GREEK ZERO SIGN");
+-   ("/xf0/x90/x86/x90", "ROMAN SEXTANS SIGN");
+-   ("/xf0/x90/x86/x91", "ROMAN UNCIA SIGN");
+-   ("/xf0/x90/x86/x92", "ROMAN SEMUNCIA SIGN");
+-   ("/xf0/x90/x86/x93", "ROMAN SEXTULA SIGN");
+-   ("/xf0/x90/x86/x94", "ROMAN DIMIDIA SEXTULA SIGN");
+-   ("/xf0/x90/x86/x95", "ROMAN SILIQUA SIGN");
+-   ("/xf0/x90/x86/x96", "ROMAN DENARIUS SIGN");
+-   ("/xf0/x90/x86/x97", "ROMAN QUINARIUS SIGN");
+-   ("/xf0/x90/x86/x98", "ROMAN SESTERTIUS SIGN");
+-   ("/xf0/x90/x86/x99", "ROMAN DUPONDIUS SIGN");
+-   ("/xf0/x90/x86/x9a", "ROMAN AS SIGN");
+-   ("/xf0/x90/x86/x9b", "ROMAN CENTURIAL SIGN");
+-   ("/xf0/x90/x87/x90", "PHAISTOS DISC SIGN PEDESTRIAN");
+-   ("/xf0/x90/x87/x91", "PHAISTOS DISC SIGN PLUMED HEAD");
+-   ("/xf0/x90/x87/x92", "PHAISTOS DISC SIGN TATTOOED HEAD");
+-   ("/xf0/x90/x87/x93", "PHAISTOS DISC SIGN CAPTIVE");
+-   ("/xf0/x90/x87/x94", "PHAISTOS DISC SIGN CHILD");
+-   ("/xf0/x90/x87/x95", "PHAISTOS DISC SIGN WOMAN");
+-   ("/xf0/x90/x87/x96", "PHAISTOS DISC SIGN HELMET");
+-   ("/xf0/x90/x87/x97", "PHAISTOS DISC SIGN GAUNTLET");
+-   ("/xf0/x90/x87/x98", "PHAISTOS DISC SIGN TIARA");
+-   ("/xf0/x90/x87/x99", "PHAISTOS DISC SIGN ARROW");
+-   ("/xf0/x90/x87/x9a", "PHAISTOS DISC SIGN BOW");
+-   ("/xf0/x90/x87/x9b", "PHAISTOS DISC SIGN SHIELD");
+-   ("/xf0/x90/x87/x9c", "PHAISTOS DISC SIGN CLUB");
+-   ("/xf0/x90/x87/x9d", "PHAISTOS DISC SIGN MANACLES");
+-   ("/xf0/x90/x87/x9e", "PHAISTOS DISC SIGN MATTOCK");
+-   ("/xf0/x90/x87/x9f", "PHAISTOS DISC SIGN SAW");
+-   ("/xf0/x90/x87/xa0", "PHAISTOS DISC SIGN LID");
+-   ("/xf0/x90/x87/xa1", "PHAISTOS DISC SIGN BOOMERANG");
+-   ("/xf0/x90/x87/xa2", "PHAISTOS DISC SIGN CARPENTRY PLANE");
+-   ("/xf0/x90/x87/xa3", "PHAISTOS DISC SIGN DOLIUM");
+-   ("/xf0/x90/x87/xa4", "PHAISTOS DISC SIGN COMB");
+-   ("/xf0/x90/x87/xa5", "PHAISTOS DISC SIGN SLING");
+-   ("/xf0/x90/x87/xa6", "PHAISTOS DISC SIGN COLUMN");
+-   ("/xf0/x90/x87/xa7", "PHAISTOS DISC SIGN BEEHIVE");
+-   ("/xf0/x90/x87/xa8", "PHAISTOS DISC SIGN SHIP");
+-   ("/xf0/x90/x87/xa9", "PHAISTOS DISC SIGN HORN");
+-   ("/xf0/x90/x87/xaa", "PHAISTOS DISC SIGN HIDE");
+-   ("/xf0/x90/x87/xab", "PHAISTOS DISC SIGN BULLS LEG");
+-   ("/xf0/x90/x87/xac", "PHAISTOS DISC SIGN CAT");
+-   ("/xf0/x90/x87/xad", "PHAISTOS DISC SIGN RAM");
+-   ("/xf0/x90/x87/xae", "PHAISTOS DISC SIGN EAGLE");
+-   ("/xf0/x90/x87/xaf", "PHAISTOS DISC SIGN DOVE");
+-   ("/xf0/x90/x87/xb0", "PHAISTOS DISC SIGN TUNNY");
+-   ("/xf0/x90/x87/xb1", "PHAISTOS DISC SIGN BEE");
+-   ("/xf0/x90/x87/xb2", "PHAISTOS DISC SIGN PLANE TREE");
+-   ("/xf0/x90/x87/xb3", "PHAISTOS DISC SIGN VINE");
+-   ("/xf0/x90/x87/xb4", "PHAISTOS DISC SIGN PAPYRUS");
+-   ("/xf0/x90/x87/xb5", "PHAISTOS DISC SIGN ROSETTE");
+-   ("/xf0/x90/x87/xb6", "PHAISTOS DISC SIGN LILY");
+-   ("/xf0/x90/x87/xb7", "PHAISTOS DISC SIGN OX BACK");
+-   ("/xf0/x90/x87/xb8", "PHAISTOS DISC SIGN FLUTE");
+-   ("/xf0/x90/x87/xb9", "PHAISTOS DISC SIGN GRATER");
+-   ("/xf0/x90/x87/xba", "PHAISTOS DISC SIGN STRAINER");
+    ("/xf0/x90/x87/xbb", "PHAISTOS DISC SIGN SMALL AXE");
+-   ("/xf0/x90/x87/xbc", "PHAISTOS DISC SIGN WAVY BAND");
+-   ("/xf0/x90/x87/xbd", "PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE");
+-   ("/xf0/x90/x8a/x80", "LYCIAN LETTER A");
+-   ("/xf0/x90/x8a/x81", "LYCIAN LETTER E");
+-   ("/xf0/x90/x8a/x82", "LYCIAN LETTER B");
+-   ("/xf0/x90/x8a/x83", "LYCIAN LETTER BH");
+-   ("/xf0/x90/x8a/x84", "LYCIAN LETTER G");
+-   ("/xf0/x90/x8a/x85", "LYCIAN LETTER D");
+-   ("/xf0/x90/x8a/x86", "LYCIAN LETTER I");
+-   ("/xf0/x90/x8a/x87", "LYCIAN LETTER W");
+-   ("/xf0/x90/x8a/x88", "LYCIAN LETTER Z");
+-   ("/xf0/x90/x8a/x89", "LYCIAN LETTER TH");
+-   ("/xf0/x90/x8a/x8a", "LYCIAN LETTER J");
+-   ("/xf0/x90/x8a/x8b", "LYCIAN LETTER K");
+-   ("/xf0/x90/x8a/x8c", "LYCIAN LETTER Q");
+-   ("/xf0/x90/x8a/x8d", "LYCIAN LETTER L");
+-   ("/xf0/x90/x8a/x8e", "LYCIAN LETTER M");
+-   ("/xf0/x90/x8a/x8f", "LYCIAN LETTER N");
+-   ("/xf0/x90/x8a/x90", "LYCIAN LETTER MM");
+-   ("/xf0/x90/x8a/x91", "LYCIAN LETTER NN");
+-   ("/xf0/x90/x8a/x92", "LYCIAN LETTER U");
+-   ("/xf0/x90/x8a/x93", "LYCIAN LETTER P");
+-   ("/xf0/x90/x8a/x94", "LYCIAN LETTER KK");
+-   ("/xf0/x90/x8a/x95", "LYCIAN LETTER R");
+-   ("/xf0/x90/x8a/x96", "LYCIAN LETTER S");
+-   ("/xf0/x90/x8a/x97", "LYCIAN LETTER T");
+-   ("/xf0/x90/x8a/x98", "LYCIAN LETTER TT");
+-   ("/xf0/x90/x8a/x99", "LYCIAN LETTER AN");
+-   ("/xf0/x90/x8a/x9a", "LYCIAN LETTER EN");
+-   ("/xf0/x90/x8a/x9b", "LYCIAN LETTER H");
+-   ("/xf0/x90/x8a/x9c", "LYCIAN LETTER X");
+-   ("/xf0/x90/x8a/xa0", "CARIAN LETTER A");
+-   ("/xf0/x90/x8a/xa1", "CARIAN LETTER P2");
+-   ("/xf0/x90/x8a/xa2", "CARIAN LETTER D");
+-   ("/xf0/x90/x8a/xa3", "CARIAN LETTER L");
+-   ("/xf0/x90/x8a/xa4", "CARIAN LETTER UUU");
+-   ("/xf0/x90/x8a/xa5", "CARIAN LETTER R");
+-   ("/xf0/x90/x8a/xa6", "CARIAN LETTER LD");
+-   ("/xf0/x90/x8a/xa7", "CARIAN LETTER A2");
+-   ("/xf0/x90/x8a/xa8", "CARIAN LETTER Q");
+-   ("/xf0/x90/x8a/xa9", "CARIAN LETTER B");
+-   ("/xf0/x90/x8a/xaa", "CARIAN LETTER M");
+-   ("/xf0/x90/x8a/xab", "CARIAN LETTER O");
+-   ("/xf0/x90/x8a/xac", "CARIAN LETTER D2");
+-   ("/xf0/x90/x8a/xad", "CARIAN LETTER T");
+-   ("/xf0/x90/x8a/xae", "CARIAN LETTER SH");
+-   ("/xf0/x90/x8a/xaf", "CARIAN LETTER SH2");
+-   ("/xf0/x90/x8a/xb0", "CARIAN LETTER S");
+-   ("/xf0/x90/x8a/xb1", "CARIAN LETTER C-18");
+-   ("/xf0/x90/x8a/xb2", "CARIAN LETTER U");
+-   ("/xf0/x90/x8a/xb3", "CARIAN LETTER NN");
+-   ("/xf0/x90/x8a/xb4", "CARIAN LETTER X");
+-   ("/xf0/x90/x8a/xb5", "CARIAN LETTER N");
+-   ("/xf0/x90/x8a/xb6", "CARIAN LETTER TT2");
+-   ("/xf0/x90/x8a/xb7", "CARIAN LETTER P");
+-   ("/xf0/x90/x8a/xb8", "CARIAN LETTER SS");
+-   ("/xf0/x90/x8a/xb9", "CARIAN LETTER I");
+-   ("/xf0/x90/x8a/xba", "CARIAN LETTER E");
+-   ("/xf0/x90/x8a/xbb", "CARIAN LETTER UUUU");
+-   ("/xf0/x90/x8a/xbc", "CARIAN LETTER K");
+-   ("/xf0/x90/x8a/xbd", "CARIAN LETTER K2");
+-   ("/xf0/x90/x8a/xbe", "CARIAN LETTER ND");
+-   ("/xf0/x90/x8a/xbf", "CARIAN LETTER UU");
+-   ("/xf0/x90/x8b/x80", "CARIAN LETTER G");
+-   ("/xf0/x90/x8b/x81", "CARIAN LETTER G2");
+-   ("/xf0/x90/x8b/x82", "CARIAN LETTER ST");
+-   ("/xf0/x90/x8b/x83", "CARIAN LETTER ST2");
+-   ("/xf0/x90/x8b/x84", "CARIAN LETTER NG");
+-   ("/xf0/x90/x8b/x85", "CARIAN LETTER II");
+-   ("/xf0/x90/x8b/x86", "CARIAN LETTER C-39");
+-   ("/xf0/x90/x8b/x87", "CARIAN LETTER TT");
+-   ("/xf0/x90/x8b/x88", "CARIAN LETTER UUU2");
+-   ("/xf0/x90/x8b/x89", "CARIAN LETTER RR");
+-   ("/xf0/x90/x8b/x8a", "CARIAN LETTER MB");
+-   ("/xf0/x90/x8b/x8b", "CARIAN LETTER MB2");
+-   ("/xf0/x90/x8b/x8c", "CARIAN LETTER MB3");
+-   ("/xf0/x90/x8b/x8d", "CARIAN LETTER MB4");
+-   ("/xf0/x90/x8b/x8e", "CARIAN LETTER LD2");
+-   ("/xf0/x90/x8b/x8f", "CARIAN LETTER E2");
+-   ("/xf0/x90/x8b/x90", "CARIAN LETTER UUU3");
+-   ("/xf0/x90/x8c/x80", "OLD ITALIC LETTER A");
+-   ("/xf0/x90/x8c/x81", "OLD ITALIC LETTER BE");
+-   ("/xf0/x90/x8c/x82", "OLD ITALIC LETTER KE");
+-   ("/xf0/x90/x8c/x83", "OLD ITALIC LETTER DE");
+-   ("/xf0/x90/x8c/x84", "OLD ITALIC LETTER E");
+-   ("/xf0/x90/x8c/x85", "OLD ITALIC LETTER VE");
+-   ("/xf0/x90/x8c/x86", "OLD ITALIC LETTER ZE");
+-   ("/xf0/x90/x8c/x87", "OLD ITALIC LETTER HE");
+-   ("/xf0/x90/x8c/x88", "OLD ITALIC LETTER THE");
+-   ("/xf0/x90/x8c/x89", "OLD ITALIC LETTER I");
+-   ("/xf0/x90/x8c/x8a", "OLD ITALIC LETTER KA");
+-   ("/xf0/x90/x8c/x8b", "OLD ITALIC LETTER EL");
+-   ("/xf0/x90/x8c/x8c", "OLD ITALIC LETTER EM");
+-   ("/xf0/x90/x8c/x8d", "OLD ITALIC LETTER EN");
+-   ("/xf0/x90/x8c/x8e", "OLD ITALIC LETTER ESH");
+-   ("/xf0/x90/x8c/x8f", "OLD ITALIC LETTER O");
+-   ("/xf0/x90/x8c/x90", "OLD ITALIC LETTER PE");
+-   ("/xf0/x90/x8c/x91", "OLD ITALIC LETTER SHE");
+-   ("/xf0/x90/x8c/x92", "OLD ITALIC LETTER KU");
+-   ("/xf0/x90/x8c/x93", "OLD ITALIC LETTER ER");
+-   ("/xf0/x90/x8c/x94", "OLD ITALIC LETTER ES");
+-   ("/xf0/x90/x8c/x95", "OLD ITALIC LETTER TE");
+-   ("/xf0/x90/x8c/x96", "OLD ITALIC LETTER U");
+-   ("/xf0/x90/x8c/x97", "OLD ITALIC LETTER EKS");
+-   ("/xf0/x90/x8c/x98", "OLD ITALIC LETTER PHE");
+-   ("/xf0/x90/x8c/x99", "OLD ITALIC LETTER KHE");
+-   ("/xf0/x90/x8c/x9a", "OLD ITALIC LETTER EF");
+-   ("/xf0/x90/x8c/x9b", "OLD ITALIC LETTER ERS");
+-   ("/xf0/x90/x8c/x9c", "OLD ITALIC LETTER CHE");
+-   ("/xf0/x90/x8c/x9d", "OLD ITALIC LETTER II");
+-   ("/xf0/x90/x8c/x9e", "OLD ITALIC LETTER UU");
+-   ("/xf0/x90/x8c/xa0", "OLD ITALIC NUMERAL ONE");
+-   ("/xf0/x90/x8c/xa1", "OLD ITALIC NUMERAL FIVE");
+-   ("/xf0/x90/x8c/xa2", "OLD ITALIC NUMERAL TEN");
+-   ("/xf0/x90/x8c/xa3", "OLD ITALIC NUMERAL FIFTY");
+-   ("/xf0/x90/x8c/xb0", "GOTHIC LETTER AHSA");
+-   ("/xf0/x90/x8c/xb1", "GOTHIC LETTER BAIRKAN");
+-   ("/xf0/x90/x8c/xb2", "GOTHIC LETTER GIBA");
+-   ("/xf0/x90/x8c/xb3", "GOTHIC LETTER DAGS");
+-   ("/xf0/x90/x8c/xb4", "GOTHIC LETTER AIHVUS");
+-   ("/xf0/x90/x8c/xb5", "GOTHIC LETTER QAIRTHRA");
+-   ("/xf0/x90/x8c/xb6", "GOTHIC LETTER IUJA");
+-   ("/xf0/x90/x8c/xb7", "GOTHIC LETTER HAGL");
+-   ("/xf0/x90/x8c/xb8", "GOTHIC LETTER THIUTH");
+-   ("/xf0/x90/x8c/xb9", "GOTHIC LETTER EIS");
+-   ("/xf0/x90/x8c/xba", "GOTHIC LETTER KUSMA");
+-   ("/xf0/x90/x8c/xbb", "GOTHIC LETTER LAGUS");
+-   ("/xf0/x90/x8c/xbc", "GOTHIC LETTER MANNA");
+-   ("/xf0/x90/x8c/xbd", "GOTHIC LETTER NAUTHS");
+-   ("/xf0/x90/x8c/xbe", "GOTHIC LETTER JER");
+-   ("/xf0/x90/x8c/xbf", "GOTHIC LETTER URUS");
+-   ("/xf0/x90/x8d/x80", "GOTHIC LETTER PAIRTHRA");
+-   ("/xf0/x90/x8d/x81", "GOTHIC LETTER NINETY");
+-   ("/xf0/x90/x8d/x82", "GOTHIC LETTER RAIDA");
+-   ("/xf0/x90/x8d/x83", "GOTHIC LETTER SAUIL");
+-   ("/xf0/x90/x8d/x84", "GOTHIC LETTER TEIWS");
+-   ("/xf0/x90/x8d/x85", "GOTHIC LETTER WINJA");
+-   ("/xf0/x90/x8d/x86", "GOTHIC LETTER FAIHU");
+-   ("/xf0/x90/x8d/x87", "GOTHIC LETTER IGGWS");
+-   ("/xf0/x90/x8d/x88", "GOTHIC LETTER HWAIR");
+-   ("/xf0/x90/x8d/x89", "GOTHIC LETTER OTHAL");
+-   ("/xf0/x90/x8d/x8a", "GOTHIC LETTER NINE HUNDRED");
+-   ("/xf0/x90/x8e/x80", "UGARITIC LETTER ALPA");
+-   ("/xf0/x90/x8e/x81", "UGARITIC LETTER BETA");
+-   ("/xf0/x90/x8e/x82", "UGARITIC LETTER GAMLA");
+-   ("/xf0/x90/x8e/x83", "UGARITIC LETTER KHA");
+-   ("/xf0/x90/x8e/x84", "UGARITIC LETTER DELTA");
+-   ("/xf0/x90/x8e/x85", "UGARITIC LETTER HO");
+-   ("/xf0/x90/x8e/x86", "UGARITIC LETTER WO");
+-   ("/xf0/x90/x8e/x87", "UGARITIC LETTER ZETA");
+-   ("/xf0/x90/x8e/x88", "UGARITIC LETTER HOTA");
+-   ("/xf0/x90/x8e/x89", "UGARITIC LETTER TET");
+-   ("/xf0/x90/x8e/x8a", "UGARITIC LETTER YOD");
+-   ("/xf0/x90/x8e/x8b", "UGARITIC LETTER KAF");
+-   ("/xf0/x90/x8e/x8c", "UGARITIC LETTER SHIN");
+-   ("/xf0/x90/x8e/x8d", "UGARITIC LETTER LAMDA");
+-   ("/xf0/x90/x8e/x8e", "UGARITIC LETTER MEM");
+-   ("/xf0/x90/x8e/x8f", "UGARITIC LETTER DHAL");
+-   ("/xf0/x90/x8e/x90", "UGARITIC LETTER NUN");
+-   ("/xf0/x90/x8e/x91", "UGARITIC LETTER ZU");
+-   ("/xf0/x90/x8e/x92", "UGARITIC LETTER SAMKA");
+-   ("/xf0/x90/x8e/x93", "UGARITIC LETTER AIN");
+-   ("/xf0/x90/x8e/x94", "UGARITIC LETTER PU");
+-   ("/xf0/x90/x8e/x95", "UGARITIC LETTER SADE");
+-   ("/xf0/x90/x8e/x96", "UGARITIC LETTER QOPA");
+-   ("/xf0/x90/x8e/x97", "UGARITIC LETTER RASHA");
+-   ("/xf0/x90/x8e/x98", "UGARITIC LETTER THANNA");
+-   ("/xf0/x90/x8e/x99", "UGARITIC LETTER GHAIN");
+-   ("/xf0/x90/x8e/x9a", "UGARITIC LETTER TO");
+-   ("/xf0/x90/x8e/x9b", "UGARITIC LETTER I");
+-   ("/xf0/x90/x8e/x9c", "UGARITIC LETTER U");
+-   ("/xf0/x90/x8e/x9d", "UGARITIC LETTER SSU");
+-   ("/xf0/x90/x8e/x9f", "UGARITIC WORD DIVIDER");
+-   ("/xf0/x90/x8e/xa0", "OLD PERSIAN SIGN A");
+-   ("/xf0/x90/x8e/xa1", "OLD PERSIAN SIGN I");
+-   ("/xf0/x90/x8e/xa2", "OLD PERSIAN SIGN U");
+-   ("/xf0/x90/x8e/xa3", "OLD PERSIAN SIGN KA");
+-   ("/xf0/x90/x8e/xa4", "OLD PERSIAN SIGN KU");
+-   ("/xf0/x90/x8e/xa5", "OLD PERSIAN SIGN GA");
+-   ("/xf0/x90/x8e/xa6", "OLD PERSIAN SIGN GU");
+-   ("/xf0/x90/x8e/xa7", "OLD PERSIAN SIGN XA");
+-   ("/xf0/x90/x8e/xa8", "OLD PERSIAN SIGN CA");
+-   ("/xf0/x90/x8e/xa9", "OLD PERSIAN SIGN JA");
+-   ("/xf0/x90/x8e/xaa", "OLD PERSIAN SIGN JI");
+-   ("/xf0/x90/x8e/xab", "OLD PERSIAN SIGN TA");
+-   ("/xf0/x90/x8e/xac", "OLD PERSIAN SIGN TU");
+-   ("/xf0/x90/x8e/xad", "OLD PERSIAN SIGN DA");
+-   ("/xf0/x90/x8e/xae", "OLD PERSIAN SIGN DI");
+-   ("/xf0/x90/x8e/xaf", "OLD PERSIAN SIGN DU");
+-   ("/xf0/x90/x8e/xb0", "OLD PERSIAN SIGN THA");
+-   ("/xf0/x90/x8e/xb1", "OLD PERSIAN SIGN PA");
+-   ("/xf0/x90/x8e/xb2", "OLD PERSIAN SIGN BA");
+-   ("/xf0/x90/x8e/xb3", "OLD PERSIAN SIGN FA");
+-   ("/xf0/x90/x8e/xb4", "OLD PERSIAN SIGN NA");
+-   ("/xf0/x90/x8e/xb5", "OLD PERSIAN SIGN NU");
+-   ("/xf0/x90/x8e/xb6", "OLD PERSIAN SIGN MA");
+-   ("/xf0/x90/x8e/xb7", "OLD PERSIAN SIGN MI");
+-   ("/xf0/x90/x8e/xb8", "OLD PERSIAN SIGN MU");
+-   ("/xf0/x90/x8e/xb9", "OLD PERSIAN SIGN YA");
+-   ("/xf0/x90/x8e/xba", "OLD PERSIAN SIGN VA");
+-   ("/xf0/x90/x8e/xbb", "OLD PERSIAN SIGN VI");
+-   ("/xf0/x90/x8e/xbc", "OLD PERSIAN SIGN RA");
+-   ("/xf0/x90/x8e/xbd", "OLD PERSIAN SIGN RU");
+-   ("/xf0/x90/x8e/xbe", "OLD PERSIAN SIGN LA");
+-   ("/xf0/x90/x8e/xbf", "OLD PERSIAN SIGN SA");
+-   ("/xf0/x90/x8f/x80", "OLD PERSIAN SIGN ZA");
+-   ("/xf0/x90/x8f/x81", "OLD PERSIAN SIGN SHA");
+-   ("/xf0/x90/x8f/x82", "OLD PERSIAN SIGN SSA");
+-   ("/xf0/x90/x8f/x83", "OLD PERSIAN SIGN HA");
+-   ("/xf0/x90/x8f/x88", "OLD PERSIAN SIGN AURAMAZDAA");
+-   ("/xf0/x90/x8f/x89", "OLD PERSIAN SIGN AURAMAZDAA-2");
+-   ("/xf0/x90/x8f/x8a", "OLD PERSIAN SIGN AURAMAZDAAHA");
+-   ("/xf0/x90/x8f/x8b", "OLD PERSIAN SIGN XSHAAYATHIYA");
+-   ("/xf0/x90/x8f/x8c", "OLD PERSIAN SIGN DAHYAAUSH");
+-   ("/xf0/x90/x8f/x8d", "OLD PERSIAN SIGN DAHYAAUSH-2");
+-   ("/xf0/x90/x8f/x8e", "OLD PERSIAN SIGN BAGA");
+-   ("/xf0/x90/x8f/x8f", "OLD PERSIAN SIGN BUUMISH");
+-   ("/xf0/x90/x8f/x90", "OLD PERSIAN WORD DIVIDER");
+-   ("/xf0/x90/x8f/x91", "OLD PERSIAN NUMBER ONE");
+-   ("/xf0/x90/x8f/x92", "OLD PERSIAN NUMBER TWO");
+-   ("/xf0/x90/x8f/x93", "OLD PERSIAN NUMBER TEN");
+-   ("/xf0/x90/x8f/x94", "OLD PERSIAN NUMBER TWENTY");
+-   ("/xf0/x90/x8f/x95", "OLD PERSIAN NUMBER HUNDRED");
+    ("/xf0/x90/x90/x80", "DESERET CAPITAL LETTER LONG I");
+    ("/xf0/x90/x90/x81", "DESERET CAPITAL LETTER LONG E");
+    ("/xf0/x90/x90/x82", "DESERET CAPITAL LETTER LONG A");
+@@ -27128,1891 +2647,8 @@
+    ("/xf0/x90/x91/x8d", "DESERET SMALL LETTER ENG");
+    ("/xf0/x90/x91/x8e", "DESERET SMALL LETTER OI");
+    ("/xf0/x90/x91/x8f", "DESERET SMALL LETTER EW");
+-   ("/xf0/x90/x91/x90", "SHAVIAN LETTER PEEP");
+-   ("/xf0/x90/x91/x91", "SHAVIAN LETTER TOT");
+-   ("/xf0/x90/x91/x92", "SHAVIAN LETTER KICK");
+-   ("/xf0/x90/x91/x93", "SHAVIAN LETTER FEE");
+-   ("/xf0/x90/x91/x94", "SHAVIAN LETTER THIGH");
+-   ("/xf0/x90/x91/x95", "SHAVIAN LETTER SO");
+-   ("/xf0/x90/x91/x96", "SHAVIAN LETTER SURE");
+-   ("/xf0/x90/x91/x97", "SHAVIAN LETTER CHURCH");
+-   ("/xf0/x90/x91/x98", "SHAVIAN LETTER YEA");
+-   ("/xf0/x90/x91/x99", "SHAVIAN LETTER HUNG");
+-   ("/xf0/x90/x91/x9a", "SHAVIAN LETTER BIB");
+-   ("/xf0/x90/x91/x9b", "SHAVIAN LETTER DEAD");
+-   ("/xf0/x90/x91/x9c", "SHAVIAN LETTER GAG");
+-   ("/xf0/x90/x91/x9d", "SHAVIAN LETTER VOW");
+-   ("/xf0/x90/x91/x9e", "SHAVIAN LETTER THEY");
+-   ("/xf0/x90/x91/x9f", "SHAVIAN LETTER ZOO");
+-   ("/xf0/x90/x91/xa0", "SHAVIAN LETTER MEASURE");
+-   ("/xf0/x90/x91/xa1", "SHAVIAN LETTER JUDGE");
+-   ("/xf0/x90/x91/xa2", "SHAVIAN LETTER WOE");
+-   ("/xf0/x90/x91/xa3", "SHAVIAN LETTER HA-HA");
+-   ("/xf0/x90/x91/xa4", "SHAVIAN LETTER LOLL");
+-   ("/xf0/x90/x91/xa5", "SHAVIAN LETTER MIME");
+-   ("/xf0/x90/x91/xa6", "SHAVIAN LETTER IF");
+-   ("/xf0/x90/x91/xa7", "SHAVIAN LETTER EGG");
+-   ("/xf0/x90/x91/xa8", "SHAVIAN LETTER ASH");
+-   ("/xf0/x90/x91/xa9", "SHAVIAN LETTER ADO");
+-   ("/xf0/x90/x91/xaa", "SHAVIAN LETTER ON");
+-   ("/xf0/x90/x91/xab", "SHAVIAN LETTER WOOL");
+-   ("/xf0/x90/x91/xac", "SHAVIAN LETTER OUT");
+-   ("/xf0/x90/x91/xad", "SHAVIAN LETTER AH");
+-   ("/xf0/x90/x91/xae", "SHAVIAN LETTER ROAR");
+-   ("/xf0/x90/x91/xaf", "SHAVIAN LETTER NUN");
+-   ("/xf0/x90/x91/xb0", "SHAVIAN LETTER EAT");
+-   ("/xf0/x90/x91/xb1", "SHAVIAN LETTER AGE");
+-   ("/xf0/x90/x91/xb2", "SHAVIAN LETTER ICE");
+-   ("/xf0/x90/x91/xb3", "SHAVIAN LETTER UP");
+-   ("/xf0/x90/x91/xb4", "SHAVIAN LETTER OAK");
+-   ("/xf0/x90/x91/xb5", "SHAVIAN LETTER OOZE");
+-   ("/xf0/x90/x91/xb6", "SHAVIAN LETTER OIL");
+-   ("/xf0/x90/x91/xb7", "SHAVIAN LETTER AWE");
+-   ("/xf0/x90/x91/xb8", "SHAVIAN LETTER ARE");
+-   ("/xf0/x90/x91/xb9", "SHAVIAN LETTER OR");
+-   ("/xf0/x90/x91/xba", "SHAVIAN LETTER AIR");
+-   ("/xf0/x90/x91/xbb", "SHAVIAN LETTER ERR");
+-   ("/xf0/x90/x91/xbc", "SHAVIAN LETTER ARRAY");
+-   ("/xf0/x90/x91/xbd", "SHAVIAN LETTER EAR");
+-   ("/xf0/x90/x91/xbe", "SHAVIAN LETTER IAN");
+-   ("/xf0/x90/x91/xbf", "SHAVIAN LETTER YEW");
+-   ("/xf0/x90/x92/x80", "OSMANYA LETTER ALEF");
+-   ("/xf0/x90/x92/x81", "OSMANYA LETTER BA");
+-   ("/xf0/x90/x92/x82", "OSMANYA LETTER TA");
+-   ("/xf0/x90/x92/x83", "OSMANYA LETTER JA");
+-   ("/xf0/x90/x92/x84", "OSMANYA LETTER XA");
+-   ("/xf0/x90/x92/x85", "OSMANYA LETTER KHA");
+-   ("/xf0/x90/x92/x86", "OSMANYA LETTER DEEL");
+-   ("/xf0/x90/x92/x87", "OSMANYA LETTER RA");
+-   ("/xf0/x90/x92/x88", "OSMANYA LETTER SA");
+-   ("/xf0/x90/x92/x89", "OSMANYA LETTER SHIIN");
+-   ("/xf0/x90/x92/x8a", "OSMANYA LETTER DHA");
+-   ("/xf0/x90/x92/x8b", "OSMANYA LETTER CAYN");
+-   ("/xf0/x90/x92/x8c", "OSMANYA LETTER GA");
+-   ("/xf0/x90/x92/x8d", "OSMANYA LETTER FA");
+-   ("/xf0/x90/x92/x8e", "OSMANYA LETTER QAAF");
+-   ("/xf0/x90/x92/x8f", "OSMANYA LETTER KAAF");
+-   ("/xf0/x90/x92/x90", "OSMANYA LETTER LAAN");
+-   ("/xf0/x90/x92/x91", "OSMANYA LETTER MIIN");
+-   ("/xf0/x90/x92/x92", "OSMANYA LETTER NUUN");
+-   ("/xf0/x90/x92/x93", "OSMANYA LETTER WAW");
+-   ("/xf0/x90/x92/x94", "OSMANYA LETTER HA");
+-   ("/xf0/x90/x92/x95", "OSMANYA LETTER YA");
+-   ("/xf0/x90/x92/x96", "OSMANYA LETTER A");
+-   ("/xf0/x90/x92/x97", "OSMANYA LETTER E");
+-   ("/xf0/x90/x92/x98", "OSMANYA LETTER I");
+-   ("/xf0/x90/x92/x99", "OSMANYA LETTER O");
+-   ("/xf0/x90/x92/x9a", "OSMANYA LETTER U");
+-   ("/xf0/x90/x92/x9b", "OSMANYA LETTER AA");
+-   ("/xf0/x90/x92/x9c", "OSMANYA LETTER EE");
+-   ("/xf0/x90/x92/x9d", "OSMANYA LETTER OO");
+-   ("/xf0/x90/x92/xa0", "OSMANYA DIGIT ZERO");
+-   ("/xf0/x90/x92/xa1", "OSMANYA DIGIT ONE");
+-   ("/xf0/x90/x92/xa2", "OSMANYA DIGIT TWO");
+-   ("/xf0/x90/x92/xa3", "OSMANYA DIGIT THREE");
+-   ("/xf0/x90/x92/xa4", "OSMANYA DIGIT FOUR");
+-   ("/xf0/x90/x92/xa5", "OSMANYA DIGIT FIVE");
+-   ("/xf0/x90/x92/xa6", "OSMANYA DIGIT SIX");
+-   ("/xf0/x90/x92/xa7", "OSMANYA DIGIT SEVEN");
+-   ("/xf0/x90/x92/xa8", "OSMANYA DIGIT EIGHT");
+-   ("/xf0/x90/x92/xa9", "OSMANYA DIGIT NINE");
+-   ("/xf0/x90/xa0/x80", "CYPRIOT SYLLABLE A");
+-   ("/xf0/x90/xa0/x81", "CYPRIOT SYLLABLE E");
+-   ("/xf0/x90/xa0/x82", "CYPRIOT SYLLABLE I");
+-   ("/xf0/x90/xa0/x83", "CYPRIOT SYLLABLE O");
+-   ("/xf0/x90/xa0/x84", "CYPRIOT SYLLABLE U");
+-   ("/xf0/x90/xa0/x85", "CYPRIOT SYLLABLE JA");
+-   ("/xf0/x90/xa0/x88", "CYPRIOT SYLLABLE JO");
+-   ("/xf0/x90/xa0/x8a", "CYPRIOT SYLLABLE KA");
+-   ("/xf0/x90/xa0/x8b", "CYPRIOT SYLLABLE KE");
+-   ("/xf0/x90/xa0/x8c", "CYPRIOT SYLLABLE KI");
+-   ("/xf0/x90/xa0/x8d", "CYPRIOT SYLLABLE KO");
+-   ("/xf0/x90/xa0/x8e", "CYPRIOT SYLLABLE KU");
+-   ("/xf0/x90/xa0/x8f", "CYPRIOT SYLLABLE LA");
+-   ("/xf0/x90/xa0/x90", "CYPRIOT SYLLABLE LE");
+-   ("/xf0/x90/xa0/x91", "CYPRIOT SYLLABLE LI");
+-   ("/xf0/x90/xa0/x92", "CYPRIOT SYLLABLE LO");
+-   ("/xf0/x90/xa0/x93", "CYPRIOT SYLLABLE LU");
+-   ("/xf0/x90/xa0/x94", "CYPRIOT SYLLABLE MA");
+-   ("/xf0/x90/xa0/x95", "CYPRIOT SYLLABLE ME");
+-   ("/xf0/x90/xa0/x96", "CYPRIOT SYLLABLE MI");
+-   ("/xf0/x90/xa0/x97", "CYPRIOT SYLLABLE MO");
+-   ("/xf0/x90/xa0/x98", "CYPRIOT SYLLABLE MU");
+-   ("/xf0/x90/xa0/x99", "CYPRIOT SYLLABLE NA");
+-   ("/xf0/x90/xa0/x9a", "CYPRIOT SYLLABLE NE");
+-   ("/xf0/x90/xa0/x9b", "CYPRIOT SYLLABLE NI");
+-   ("/xf0/x90/xa0/x9c", "CYPRIOT SYLLABLE NO");
+-   ("/xf0/x90/xa0/x9d", "CYPRIOT SYLLABLE NU");
+-   ("/xf0/x90/xa0/x9e", "CYPRIOT SYLLABLE PA");
+-   ("/xf0/x90/xa0/x9f", "CYPRIOT SYLLABLE PE");
+-   ("/xf0/x90/xa0/xa0", "CYPRIOT SYLLABLE PI");
+-   ("/xf0/x90/xa0/xa1", "CYPRIOT SYLLABLE PO");
+-   ("/xf0/x90/xa0/xa2", "CYPRIOT SYLLABLE PU");
+-   ("/xf0/x90/xa0/xa3", "CYPRIOT SYLLABLE RA");
+-   ("/xf0/x90/xa0/xa4", "CYPRIOT SYLLABLE RE");
+-   ("/xf0/x90/xa0/xa5", "CYPRIOT SYLLABLE RI");
+-   ("/xf0/x90/xa0/xa6", "CYPRIOT SYLLABLE RO");
+-   ("/xf0/x90/xa0/xa7", "CYPRIOT SYLLABLE RU");
+-   ("/xf0/x90/xa0/xa8", "CYPRIOT SYLLABLE SA");
+-   ("/xf0/x90/xa0/xa9", "CYPRIOT SYLLABLE SE");
+-   ("/xf0/x90/xa0/xaa", "CYPRIOT SYLLABLE SI");
+-   ("/xf0/x90/xa0/xab", "CYPRIOT SYLLABLE SO");
+-   ("/xf0/x90/xa0/xac", "CYPRIOT SYLLABLE SU");
+-   ("/xf0/x90/xa0/xad", "CYPRIOT SYLLABLE TA");
+-   ("/xf0/x90/xa0/xae", "CYPRIOT SYLLABLE TE");
+-   ("/xf0/x90/xa0/xaf", "CYPRIOT SYLLABLE TI");
+-   ("/xf0/x90/xa0/xb0", "CYPRIOT SYLLABLE TO");
+-   ("/xf0/x90/xa0/xb1", "CYPRIOT SYLLABLE TU");
+-   ("/xf0/x90/xa0/xb2", "CYPRIOT SYLLABLE WA");
+-   ("/xf0/x90/xa0/xb3", "CYPRIOT SYLLABLE WE");
+-   ("/xf0/x90/xa0/xb4", "CYPRIOT SYLLABLE WI");
+-   ("/xf0/x90/xa0/xb5", "CYPRIOT SYLLABLE WO");
+-   ("/xf0/x90/xa0/xb7", "CYPRIOT SYLLABLE XA");
+-   ("/xf0/x90/xa0/xb8", "CYPRIOT SYLLABLE XE");
+-   ("/xf0/x90/xa0/xbc", "CYPRIOT SYLLABLE ZA");
+-   ("/xf0/x90/xa0/xbf", "CYPRIOT SYLLABLE ZO");
+-   ("/xf0/x90/xa4/x80", "PHOENICIAN LETTER ALF");
+-   ("/xf0/x90/xa4/x81", "PHOENICIAN LETTER BET");
+-   ("/xf0/x90/xa4/x82", "PHOENICIAN LETTER GAML");
+-   ("/xf0/x90/xa4/x83", "PHOENICIAN LETTER DELT");
+-   ("/xf0/x90/xa4/x84", "PHOENICIAN LETTER HE");
+-   ("/xf0/x90/xa4/x85", "PHOENICIAN LETTER WAU");
+-   ("/xf0/x90/xa4/x86", "PHOENICIAN LETTER ZAI");
+-   ("/xf0/x90/xa4/x87", "PHOENICIAN LETTER HET");
+-   ("/xf0/x90/xa4/x88", "PHOENICIAN LETTER TET");
+-   ("/xf0/x90/xa4/x89", "PHOENICIAN LETTER YOD");
+-   ("/xf0/x90/xa4/x8a", "PHOENICIAN LETTER KAF");
+-   ("/xf0/x90/xa4/x8b", "PHOENICIAN LETTER LAMD");
+-   ("/xf0/x90/xa4/x8c", "PHOENICIAN LETTER MEM");
+-   ("/xf0/x90/xa4/x8d", "PHOENICIAN LETTER NUN");
+-   ("/xf0/x90/xa4/x8e", "PHOENICIAN LETTER SEMK");
+-   ("/xf0/x90/xa4/x8f", "PHOENICIAN LETTER AIN");
+-   ("/xf0/x90/xa4/x90", "PHOENICIAN LETTER PE");
+-   ("/xf0/x90/xa4/x91", "PHOENICIAN LETTER SADE");
+-   ("/xf0/x90/xa4/x92", "PHOENICIAN LETTER QOF");
+-   ("/xf0/x90/xa4/x93", "PHOENICIAN LETTER ROSH");
+-   ("/xf0/x90/xa4/x94", "PHOENICIAN LETTER SHIN");
+-   ("/xf0/x90/xa4/x95", "PHOENICIAN LETTER TAU");
+-   ("/xf0/x90/xa4/x96", "PHOENICIAN NUMBER ONE");
+-   ("/xf0/x90/xa4/x97", "PHOENICIAN NUMBER TEN");
+-   ("/xf0/x90/xa4/x98", "PHOENICIAN NUMBER TWENTY");
+-   ("/xf0/x90/xa4/x99", "PHOENICIAN NUMBER ONE HUNDRED");
+-   ("/xf0/x90/xa4/x9f", "PHOENICIAN WORD SEPARATOR");
+-   ("/xf0/x90/xa4/xa0", "LYDIAN LETTER A");
+-   ("/xf0/x90/xa4/xa1", "LYDIAN LETTER B");
+-   ("/xf0/x90/xa4/xa2", "LYDIAN LETTER G");
+-   ("/xf0/x90/xa4/xa3", "LYDIAN LETTER D");
+-   ("/xf0/x90/xa4/xa4", "LYDIAN LETTER E");
+-   ("/xf0/x90/xa4/xa5", "LYDIAN LETTER V");
+-   ("/xf0/x90/xa4/xa6", "LYDIAN LETTER I");
+-   ("/xf0/x90/xa4/xa7", "LYDIAN LETTER Y");
+-   ("/xf0/x90/xa4/xa8", "LYDIAN LETTER K");
+-   ("/xf0/x90/xa4/xa9", "LYDIAN LETTER L");
+-   ("/xf0/x90/xa4/xaa", "LYDIAN LETTER M");
+-   ("/xf0/x90/xa4/xab", "LYDIAN LETTER N");
+-   ("/xf0/x90/xa4/xac", "LYDIAN LETTER O");
+-   ("/xf0/x90/xa4/xad", "LYDIAN LETTER R");
+-   ("/xf0/x90/xa4/xae", "LYDIAN LETTER SS");
+-   ("/xf0/x90/xa4/xaf", "LYDIAN LETTER T");
+-   ("/xf0/x90/xa4/xb0", "LYDIAN LETTER U");
+-   ("/xf0/x90/xa4/xb1", "LYDIAN LETTER F");
+-   ("/xf0/x90/xa4/xb2", "LYDIAN LETTER Q");
+-   ("/xf0/x90/xa4/xb3", "LYDIAN LETTER S");
+-   ("/xf0/x90/xa4/xb4", "LYDIAN LETTER TT");
+-   ("/xf0/x90/xa4/xb5", "LYDIAN LETTER AN");
+-   ("/xf0/x90/xa4/xb6", "LYDIAN LETTER EN");
+-   ("/xf0/x90/xa4/xb7", "LYDIAN LETTER LY");
+-   ("/xf0/x90/xa4/xb8", "LYDIAN LETTER NN");
+-   ("/xf0/x90/xa4/xb9", "LYDIAN LETTER C");
+-   ("/xf0/x90/xa4/xbf", "LYDIAN TRIANGULAR MARK");
+-   ("/xf0/x90/xa8/x80", "KHAROSHTHI LETTER A");
+-   ("/xf0/x90/xa8/x81", "KHAROSHTHI VOWEL SIGN I");
+-   ("/xf0/x90/xa8/x82", "KHAROSHTHI VOWEL SIGN U");
+-   ("/xf0/x90/xa8/x83", "KHAROSHTHI VOWEL SIGN VOCALIC R");
+-   ("/xf0/x90/xa8/x85", "KHAROSHTHI VOWEL SIGN E");
+-   ("/xf0/x90/xa8/x86", "KHAROSHTHI VOWEL SIGN O");
+-   ("/xf0/x90/xa8/x8c", "KHAROSHTHI VOWEL LENGTH MARK");
+-   ("/xf0/x90/xa8/x8d", "KHAROSHTHI SIGN DOUBLE RING BELOW");
+-   ("/xf0/x90/xa8/x8e", "KHAROSHTHI SIGN ANUSVARA");
+-   ("/xf0/x90/xa8/x8f", "KHAROSHTHI SIGN VISARGA");
+-   ("/xf0/x90/xa8/x90", "KHAROSHTHI LETTER KA");
+-   ("/xf0/x90/xa8/x91", "KHAROSHTHI LETTER KHA");
+-   ("/xf0/x90/xa8/x92", "KHAROSHTHI LETTER GA");
+-   ("/xf0/x90/xa8/x93", "KHAROSHTHI LETTER GHA");
+-   ("/xf0/x90/xa8/x95", "KHAROSHTHI LETTER CA");
+-   ("/xf0/x90/xa8/x96", "KHAROSHTHI LETTER CHA");
+-   ("/xf0/x90/xa8/x97", "KHAROSHTHI LETTER JA");
+-   ("/xf0/x90/xa8/x99", "KHAROSHTHI LETTER NYA");
+-   ("/xf0/x90/xa8/x9a", "KHAROSHTHI LETTER TTA");
+-   ("/xf0/x90/xa8/x9b", "KHAROSHTHI LETTER TTHA");
+-   ("/xf0/x90/xa8/x9c", "KHAROSHTHI LETTER DDA");
+-   ("/xf0/x90/xa8/x9d", "KHAROSHTHI LETTER DDHA");
+-   ("/xf0/x90/xa8/x9e", "KHAROSHTHI LETTER NNA");
+-   ("/xf0/x90/xa8/x9f", "KHAROSHTHI LETTER TA");
+-   ("/xf0/x90/xa8/xa0", "KHAROSHTHI LETTER THA");
+-   ("/xf0/x90/xa8/xa1", "KHAROSHTHI LETTER DA");
+-   ("/xf0/x90/xa8/xa2", "KHAROSHTHI LETTER DHA");
+-   ("/xf0/x90/xa8/xa3", "KHAROSHTHI LETTER NA");
+-   ("/xf0/x90/xa8/xa4", "KHAROSHTHI LETTER PA");
+-   ("/xf0/x90/xa8/xa5", "KHAROSHTHI LETTER PHA");
+-   ("/xf0/x90/xa8/xa6", "KHAROSHTHI LETTER BA");
+-   ("/xf0/x90/xa8/xa7", "KHAROSHTHI LETTER BHA");
+-   ("/xf0/x90/xa8/xa8", "KHAROSHTHI LETTER MA");
+-   ("/xf0/x90/xa8/xa9", "KHAROSHTHI LETTER YA");
+-   ("/xf0/x90/xa8/xaa", "KHAROSHTHI LETTER RA");
+-   ("/xf0/x90/xa8/xab", "KHAROSHTHI LETTER LA");
+-   ("/xf0/x90/xa8/xac", "KHAROSHTHI LETTER VA");
+-   ("/xf0/x90/xa8/xad", "KHAROSHTHI LETTER SHA");
+-   ("/xf0/x90/xa8/xae", "KHAROSHTHI LETTER SSA");
+-   ("/xf0/x90/xa8/xaf", "KHAROSHTHI LETTER SA");
+-   ("/xf0/x90/xa8/xb0", "KHAROSHTHI LETTER ZA");
+-   ("/xf0/x90/xa8/xb1", "KHAROSHTHI LETTER HA");
+-   ("/xf0/x90/xa8/xb2", "KHAROSHTHI LETTER KKA");
+-   ("/xf0/x90/xa8/xb3", "KHAROSHTHI LETTER TTTHA");
+-   ("/xf0/x90/xa8/xb8", "KHAROSHTHI SIGN BAR ABOVE");
+-   ("/xf0/x90/xa8/xb9", "KHAROSHTHI SIGN CAUDA");
+-   ("/xf0/x90/xa8/xba", "KHAROSHTHI SIGN DOT BELOW");
+-   ("/xf0/x90/xa8/xbf", "KHAROSHTHI VIRAMA");
+-   ("/xf0/x90/xa9/x80", "KHAROSHTHI DIGIT ONE");
+-   ("/xf0/x90/xa9/x81", "KHAROSHTHI DIGIT TWO");
+-   ("/xf0/x90/xa9/x82", "KHAROSHTHI DIGIT THREE");
+-   ("/xf0/x90/xa9/x83", "KHAROSHTHI DIGIT FOUR");
+-   ("/xf0/x90/xa9/x84", "KHAROSHTHI NUMBER TEN");
+-   ("/xf0/x90/xa9/x85", "KHAROSHTHI NUMBER TWENTY");
+-   ("/xf0/x90/xa9/x86", "KHAROSHTHI NUMBER ONE HUNDRED");
+-   ("/xf0/x90/xa9/x87", "KHAROSHTHI NUMBER ONE THOUSAND");
+-   ("/xf0/x90/xa9/x90", "KHAROSHTHI PUNCTUATION DOT");
+    ("/xf0/x90/xa9/x91", "KHAROSHTHI PUNCTUATION SMALL CIRCLE");
+-   ("/xf0/x90/xa9/x92", "KHAROSHTHI PUNCTUATION CIRCLE");
+-   ("/xf0/x90/xa9/x93", "KHAROSHTHI PUNCTUATION CRESCENT BAR");
+-   ("/xf0/x90/xa9/x94", "KHAROSHTHI PUNCTUATION MANGALAM");
+-   ("/xf0/x90/xa9/x95", "KHAROSHTHI PUNCTUATION LOTUS");
+-   ("/xf0/x90/xa9/x96", "KHAROSHTHI PUNCTUATION DANDA");
+-   ("/xf0/x90/xa9/x97", "KHAROSHTHI PUNCTUATION DOUBLE DANDA");
+-   ("/xf0/x90/xa9/x98", "KHAROSHTHI PUNCTUATION LINES");
+-   ("/xf0/x92/x80/x80", "CUNEIFORM SIGN A");
+-   ("/xf0/x92/x80/x81", "CUNEIFORM SIGN A TIMES A");
+-   ("/xf0/x92/x80/x82", "CUNEIFORM SIGN A TIMES BAD");
+-   ("/xf0/x92/x80/x83", "CUNEIFORM SIGN A TIMES GAN2 TENU");
+-   ("/xf0/x92/x80/x84", "CUNEIFORM SIGN A TIMES HA");
+-   ("/xf0/x92/x80/x85", "CUNEIFORM SIGN A TIMES IGI");
+-   ("/xf0/x92/x80/x86", "CUNEIFORM SIGN A TIMES LAGAR GUNU");
+-   ("/xf0/x92/x80/x87", "CUNEIFORM SIGN A TIMES MUSH");
+-   ("/xf0/x92/x80/x88", "CUNEIFORM SIGN A TIMES SAG");
+-   ("/xf0/x92/x80/x89", "CUNEIFORM SIGN A2");
+-   ("/xf0/x92/x80/x8a", "CUNEIFORM SIGN AB");
+-   ("/xf0/x92/x80/x8b", "CUNEIFORM SIGN AB TIMES ASH2");
+-   ("/xf0/x92/x80/x8c", "CUNEIFORM SIGN AB TIMES DUN3 GUNU");
+-   ("/xf0/x92/x80/x8d", "CUNEIFORM SIGN AB TIMES GAL");
+-   ("/xf0/x92/x80/x8e", "CUNEIFORM SIGN AB TIMES GAN2 TENU");
+-   ("/xf0/x92/x80/x8f", "CUNEIFORM SIGN AB TIMES HA");
+-   ("/xf0/x92/x80/x90", "CUNEIFORM SIGN AB TIMES IGI GUNU");
+-   ("/xf0/x92/x80/x91", "CUNEIFORM SIGN AB TIMES IMIN");
+-   ("/xf0/x92/x80/x92", "CUNEIFORM SIGN AB TIMES LAGAB");
+-   ("/xf0/x92/x80/x93", "CUNEIFORM SIGN AB TIMES SHESH");
+-   ("/xf0/x92/x80/x94", "CUNEIFORM SIGN AB TIMES U PLUS U PLUS U");
+-   ("/xf0/x92/x80/x95", "CUNEIFORM SIGN AB GUNU");
+-   ("/xf0/x92/x80/x96", "CUNEIFORM SIGN AB2");
+-   ("/xf0/x92/x80/x97", "CUNEIFORM SIGN AB2 TIMES BALAG");
+-   ("/xf0/x92/x80/x98", "CUNEIFORM SIGN AB2 TIMES GAN2 TENU");
+-   ("/xf0/x92/x80/x99", "CUNEIFORM SIGN AB2 TIMES ME PLUS EN");
+-   ("/xf0/x92/x80/x9a", "CUNEIFORM SIGN AB2 TIMES SHA3");
+-   ("/xf0/x92/x80/x9b", "CUNEIFORM SIGN AB2 TIMES TAK4");
+-   ("/xf0/x92/x80/x9c", "CUNEIFORM SIGN AD");
+-   ("/xf0/x92/x80/x9d", "CUNEIFORM SIGN AK");
+-   ("/xf0/x92/x80/x9e", "CUNEIFORM SIGN AK TIMES ERIN2");
+-   ("/xf0/x92/x80/x9f", "CUNEIFORM SIGN AK TIMES SHITA PLUS GISH");
+-   ("/xf0/x92/x80/xa0", "CUNEIFORM SIGN AL");
+-   ("/xf0/x92/x80/xa1", "CUNEIFORM SIGN AL TIMES AL");
+-   ("/xf0/x92/x80/xa2", "CUNEIFORM SIGN AL TIMES DIM2");
+-   ("/xf0/x92/x80/xa3", "CUNEIFORM SIGN AL TIMES GISH");
+-   ("/xf0/x92/x80/xa4", "CUNEIFORM SIGN AL TIMES HA");
+-   ("/xf0/x92/x80/xa5", "CUNEIFORM SIGN AL TIMES KAD3");
+-   ("/xf0/x92/x80/xa6", "CUNEIFORM SIGN AL TIMES KI");
+-   ("/xf0/x92/x80/xa7", "CUNEIFORM SIGN AL TIMES SHE");
+-   ("/xf0/x92/x80/xa8", "CUNEIFORM SIGN AL TIMES USH");
+-   ("/xf0/x92/x80/xa9", "CUNEIFORM SIGN ALAN");
+-   ("/xf0/x92/x80/xaa", "CUNEIFORM SIGN ALEPH");
+-   ("/xf0/x92/x80/xab", "CUNEIFORM SIGN AMAR");
+-   ("/xf0/x92/x80/xac", "CUNEIFORM SIGN AMAR TIMES SHE");
+-   ("/xf0/x92/x80/xad", "CUNEIFORM SIGN AN");
+-   ("/xf0/x92/x80/xae", "CUNEIFORM SIGN AN OVER AN");
+-   ("/xf0/x92/x80/xaf", "CUNEIFORM SIGN AN THREE TIMES");
+-   ("/xf0/x92/x80/xb0", "CUNEIFORM SIGN AN PLUS NAGA OPPOSING AN PLUS NAGA");
+-   ("/xf0/x92/x80/xb1", "CUNEIFORM SIGN AN PLUS NAGA SQUARED");
+-   ("/xf0/x92/x80/xb2", "CUNEIFORM SIGN ANSHE");
+-   ("/xf0/x92/x80/xb3", "CUNEIFORM SIGN APIN");
+-   ("/xf0/x92/x80/xb4", "CUNEIFORM SIGN ARAD");
+-   ("/xf0/x92/x80/xb5", "CUNEIFORM SIGN ARAD TIMES KUR");
+-   ("/xf0/x92/x80/xb6", "CUNEIFORM SIGN ARKAB");
+-   ("/xf0/x92/x80/xb7", "CUNEIFORM SIGN ASAL2");
+-   ("/xf0/x92/x80/xb8", "CUNEIFORM SIGN ASH");
+-   ("/xf0/x92/x80/xb9", "CUNEIFORM SIGN ASH ZIDA TENU");
+-   ("/xf0/x92/x80/xba", "CUNEIFORM SIGN ASH KABA TENU");
+-   ("/xf0/x92/x80/xbb", "CUNEIFORM SIGN ASH OVER ASH TUG2 OVER TUG2 TUG2 OVER TUG2 PAP");
+-   ("/xf0/x92/x80/xbc", "CUNEIFORM SIGN ASH OVER ASH OVER ASH");
+-   ("/xf0/x92/x80/xbd", "CUNEIFORM SIGN ASH OVER ASH OVER ASH CROSSING ASH OVER ASH OVER ASH");
+-   ("/xf0/x92/x80/xbe", "CUNEIFORM SIGN ASH2");
+-   ("/xf0/x92/x80/xbf", "CUNEIFORM SIGN ASHGAB");
+-   ("/xf0/x92/x81/x80", "CUNEIFORM SIGN BA");
+-   ("/xf0/x92/x81/x81", "CUNEIFORM SIGN BAD");
+-   ("/xf0/x92/x81/x82", "CUNEIFORM SIGN BAG3");
+-   ("/xf0/x92/x81/x83", "CUNEIFORM SIGN BAHAR2");
+-   ("/xf0/x92/x81/x84", "CUNEIFORM SIGN BAL");
+-   ("/xf0/x92/x81/x85", "CUNEIFORM SIGN BAL OVER BAL");
+-   ("/xf0/x92/x81/x86", "CUNEIFORM SIGN BALAG");
+-   ("/xf0/x92/x81/x87", "CUNEIFORM SIGN BAR");
+-   ("/xf0/x92/x81/x88", "CUNEIFORM SIGN BARA2");
+-   ("/xf0/x92/x81/x89", "CUNEIFORM SIGN BI");
+-   ("/xf0/x92/x81/x8a", "CUNEIFORM SIGN BI TIMES A");
+-   ("/xf0/x92/x81/x8b", "CUNEIFORM SIGN BI TIMES GAR");
+-   ("/xf0/x92/x81/x8c", "CUNEIFORM SIGN BI TIMES IGI GUNU");
+-   ("/xf0/x92/x81/x8d", "CUNEIFORM SIGN BU");
+-   ("/xf0/x92/x81/x8e", "CUNEIFORM SIGN BU OVER BU AB");
+-   ("/xf0/x92/x81/x8f", "CUNEIFORM SIGN BU OVER BU UN");
+-   ("/xf0/x92/x81/x90", "CUNEIFORM SIGN BU CROSSING BU");
+-   ("/xf0/x92/x81/x91", "CUNEIFORM SIGN BULUG");
+-   ("/xf0/x92/x81/x92", "CUNEIFORM SIGN BULUG OVER BULUG");
+-   ("/xf0/x92/x81/x93", "CUNEIFORM SIGN BUR");
+-   ("/xf0/x92/x81/x94", "CUNEIFORM SIGN BUR2");
+-   ("/xf0/x92/x81/x95", "CUNEIFORM SIGN DA");
+-   ("/xf0/x92/x81/x96", "CUNEIFORM SIGN DAG");
+-   ("/xf0/x92/x81/x97", "CUNEIFORM SIGN DAG KISIM5 TIMES A PLUS MASH");
+-   ("/xf0/x92/x81/x98", "CUNEIFORM SIGN DAG KISIM5 TIMES AMAR");
+-   ("/xf0/x92/x81/x99", "CUNEIFORM SIGN DAG KISIM5 TIMES BALAG");
+-   ("/xf0/x92/x81/x9a", "CUNEIFORM SIGN DAG KISIM5 TIMES BI");
+-   ("/xf0/x92/x81/x9b", "CUNEIFORM SIGN DAG KISIM5 TIMES GA");
+-   ("/xf0/x92/x81/x9c", "CUNEIFORM SIGN DAG KISIM5 TIMES GA PLUS MASH");
+-   ("/xf0/x92/x81/x9d", "CUNEIFORM SIGN DAG KISIM5 TIMES GI");
+-   ("/xf0/x92/x81/x9e", "CUNEIFORM SIGN DAG KISIM5 TIMES GIR2");
+-   ("/xf0/x92/x81/x9f", "CUNEIFORM SIGN DAG KISIM5 TIMES GUD");
+-   ("/xf0/x92/x81/xa0", "CUNEIFORM SIGN DAG KISIM5 TIMES HA");
+-   ("/xf0/x92/x81/xa1", "CUNEIFORM SIGN DAG KISIM5 TIMES IR");
+-   ("/xf0/x92/x81/xa2", "CUNEIFORM SIGN DAG KISIM5 TIMES IR PLUS LU");
+-   ("/xf0/x92/x81/xa3", "CUNEIFORM SIGN DAG KISIM5 TIMES KAK");
+-   ("/xf0/x92/x81/xa4", "CUNEIFORM SIGN DAG KISIM5 TIMES LA");
+-   ("/xf0/x92/x81/xa5", "CUNEIFORM SIGN DAG KISIM5 TIMES LU");
+-   ("/xf0/x92/x81/xa6", "CUNEIFORM SIGN DAG KISIM5 TIMES LU PLUS MASH2");
+-   ("/xf0/x92/x81/xa7", "CUNEIFORM SIGN DAG KISIM5 TIMES LUM");
+-   ("/xf0/x92/x81/xa8", "CUNEIFORM SIGN DAG KISIM5 TIMES NE");
+-   ("/xf0/x92/x81/xa9", "CUNEIFORM SIGN DAG KISIM5 TIMES PAP PLUS PAP");
+-   ("/xf0/x92/x81/xaa", "CUNEIFORM SIGN DAG KISIM5 TIMES SI");
+-   ("/xf0/x92/x81/xab", "CUNEIFORM SIGN DAG KISIM5 TIMES TAK4");
+-   ("/xf0/x92/x81/xac", "CUNEIFORM SIGN DAG KISIM5 TIMES U2 PLUS GIR2");
+-   ("/xf0/x92/x81/xad", "CUNEIFORM SIGN DAG KISIM5 TIMES USH");
+-   ("/xf0/x92/x81/xae", "CUNEIFORM SIGN DAM");
+-   ("/xf0/x92/x81/xaf", "CUNEIFORM SIGN DAR");
+-   ("/xf0/x92/x81/xb0", "CUNEIFORM SIGN DARA3");
+-   ("/xf0/x92/x81/xb1", "CUNEIFORM SIGN DARA4");
+-   ("/xf0/x92/x81/xb2", "CUNEIFORM SIGN DI");
+-   ("/xf0/x92/x81/xb3", "CUNEIFORM SIGN DIB");
+-   ("/xf0/x92/x81/xb4", "CUNEIFORM SIGN DIM");
+-   ("/xf0/x92/x81/xb5", "CUNEIFORM SIGN DIM TIMES SHE");
+-   ("/xf0/x92/x81/xb6", "CUNEIFORM SIGN DIM2");
+-   ("/xf0/x92/x81/xb7", "CUNEIFORM SIGN DIN");
+-   ("/xf0/x92/x81/xb8", "CUNEIFORM SIGN DIN KASKAL U GUNU DISH");
+-   ("/xf0/x92/x81/xb9", "CUNEIFORM SIGN DISH");
+-   ("/xf0/x92/x81/xba", "CUNEIFORM SIGN DU");
+-   ("/xf0/x92/x81/xbb", "CUNEIFORM SIGN DU OVER DU");
+-   ("/xf0/x92/x81/xbc", "CUNEIFORM SIGN DU GUNU");
+-   ("/xf0/x92/x81/xbd", "CUNEIFORM SIGN DU SHESHIG");
+-   ("/xf0/x92/x81/xbe", "CUNEIFORM SIGN DUB");
+-   ("/xf0/x92/x81/xbf", "CUNEIFORM SIGN DUB TIMES ESH2");
+-   ("/xf0/x92/x82/x80", "CUNEIFORM SIGN DUB2");
+-   ("/xf0/x92/x82/x81", "CUNEIFORM SIGN DUG");
+-   ("/xf0/x92/x82/x82", "CUNEIFORM SIGN DUGUD");
+-   ("/xf0/x92/x82/x83", "CUNEIFORM SIGN DUH");
+-   ("/xf0/x92/x82/x84", "CUNEIFORM SIGN DUN");
+-   ("/xf0/x92/x82/x85", "CUNEIFORM SIGN DUN3");
+-   ("/xf0/x92/x82/x86", "CUNEIFORM SIGN DUN3 GUNU");
+-   ("/xf0/x92/x82/x87", "CUNEIFORM SIGN DUN3 GUNU GUNU");
+-   ("/xf0/x92/x82/x88", "CUNEIFORM SIGN DUN4");
+-   ("/xf0/x92/x82/x89", "CUNEIFORM SIGN DUR2");
+-   ("/xf0/x92/x82/x8a", "CUNEIFORM SIGN E");
+-   ("/xf0/x92/x82/x8b", "CUNEIFORM SIGN E TIMES PAP");
+-   ("/xf0/x92/x82/x8c", "CUNEIFORM SIGN E OVER E NUN OVER NUN");
+-   ("/xf0/x92/x82/x8d", "CUNEIFORM SIGN E2");
+-   ("/xf0/x92/x82/x8e", "CUNEIFORM SIGN E2 TIMES A PLUS HA PLUS DA");
+-   ("/xf0/x92/x82/x8f", "CUNEIFORM SIGN E2 TIMES GAR");
+-   ("/xf0/x92/x82/x90", "CUNEIFORM SIGN E2 TIMES MI");
+-   ("/xf0/x92/x82/x91", "CUNEIFORM SIGN E2 TIMES SAL");
+-   ("/xf0/x92/x82/x92", "CUNEIFORM SIGN E2 TIMES SHE");
+-   ("/xf0/x92/x82/x93", "CUNEIFORM SIGN E2 TIMES U");
+-   ("/xf0/x92/x82/x94", "CUNEIFORM SIGN EDIN");
+-   ("/xf0/x92/x82/x95", "CUNEIFORM SIGN EGIR");
+-   ("/xf0/x92/x82/x96", "CUNEIFORM SIGN EL");
+-   ("/xf0/x92/x82/x97", "CUNEIFORM SIGN EN");
+-   ("/xf0/x92/x82/x98", "CUNEIFORM SIGN EN TIMES GAN2");
+-   ("/xf0/x92/x82/x99", "CUNEIFORM SIGN EN TIMES GAN2 TENU");
+-   ("/xf0/x92/x82/x9a", "CUNEIFORM SIGN EN TIMES ME");
+-   ("/xf0/x92/x82/x9b", "CUNEIFORM SIGN EN CROSSING EN");
+-   ("/xf0/x92/x82/x9c", "CUNEIFORM SIGN EN OPPOSING EN");
+-   ("/xf0/x92/x82/x9d", "CUNEIFORM SIGN EN SQUARED");
+-   ("/xf0/x92/x82/x9e", "CUNEIFORM SIGN EREN");
+-   ("/xf0/x92/x82/x9f", "CUNEIFORM SIGN ERIN2");
+-   ("/xf0/x92/x82/xa0", "CUNEIFORM SIGN ESH2");
+-   ("/xf0/x92/x82/xa1", "CUNEIFORM SIGN EZEN");
+-   ("/xf0/x92/x82/xa2", "CUNEIFORM SIGN EZEN TIMES A");
+-   ("/xf0/x92/x82/xa3", "CUNEIFORM SIGN EZEN TIMES A PLUS LAL");
+-   ("/xf0/x92/x82/xa4", "CUNEIFORM SIGN EZEN TIMES A PLUS LAL TIMES LAL");
+-   ("/xf0/x92/x82/xa5", "CUNEIFORM SIGN EZEN TIMES AN");
+-   ("/xf0/x92/x82/xa6", "CUNEIFORM SIGN EZEN TIMES BAD");
+-   ("/xf0/x92/x82/xa7", "CUNEIFORM SIGN EZEN TIMES DUN3 GUNU");
+-   ("/xf0/x92/x82/xa8", "CUNEIFORM SIGN EZEN TIMES DUN3 GUNU GUNU");
+-   ("/xf0/x92/x82/xa9", "CUNEIFORM SIGN EZEN TIMES HA");
+-   ("/xf0/x92/x82/xaa", "CUNEIFORM SIGN EZEN TIMES HA GUNU");
+-   ("/xf0/x92/x82/xab", "CUNEIFORM SIGN EZEN TIMES IGI GUNU");
+-   ("/xf0/x92/x82/xac", "CUNEIFORM SIGN EZEN TIMES KASKAL");
+-   ("/xf0/x92/x82/xad", "CUNEIFORM SIGN EZEN TIMES KASKAL SQUARED");
+-   ("/xf0/x92/x82/xae", "CUNEIFORM SIGN EZEN TIMES KU3");
+-   ("/xf0/x92/x82/xaf", "CUNEIFORM SIGN EZEN TIMES LA");
+-   ("/xf0/x92/x82/xb0", "CUNEIFORM SIGN EZEN TIMES LAL TIMES LAL");
+-   ("/xf0/x92/x82/xb1", "CUNEIFORM SIGN EZEN TIMES LI");
+-   ("/xf0/x92/x82/xb2", "CUNEIFORM SIGN EZEN TIMES LU");
+-   ("/xf0/x92/x82/xb3", "CUNEIFORM SIGN EZEN TIMES U2");
+-   ("/xf0/x92/x82/xb4", "CUNEIFORM SIGN EZEN TIMES UD");
+-   ("/xf0/x92/x82/xb5", "CUNEIFORM SIGN GA");
+-   ("/xf0/x92/x82/xb6", "CUNEIFORM SIGN GA GUNU");
+-   ("/xf0/x92/x82/xb7", "CUNEIFORM SIGN GA2");
+-   ("/xf0/x92/x82/xb8", "CUNEIFORM SIGN GA2 TIMES A PLUS DA PLUS HA");
+-   ("/xf0/x92/x82/xb9", "CUNEIFORM SIGN GA2 TIMES A PLUS HA");
+-   ("/xf0/x92/x82/xba", "CUNEIFORM SIGN GA2 TIMES A PLUS IGI");
+-   ("/xf0/x92/x82/xbb", "CUNEIFORM SIGN GA2 TIMES AB2 TENU PLUS TAB");
+-   ("/xf0/x92/x82/xbc", "CUNEIFORM SIGN GA2 TIMES AN");
+-   ("/xf0/x92/x82/xbd", "CUNEIFORM SIGN GA2 TIMES ASH");
+-   ("/xf0/x92/x82/xbe", "CUNEIFORM SIGN GA2 TIMES ASH2 PLUS GAL");
+-   ("/xf0/x92/x82/xbf", "CUNEIFORM SIGN GA2 TIMES BAD");
+-   ("/xf0/x92/x83/x80", "CUNEIFORM SIGN GA2 TIMES BAR PLUS RA");
+-   ("/xf0/x92/x83/x81", "CUNEIFORM SIGN GA2 TIMES BUR");
+-   ("/xf0/x92/x83/x82", "CUNEIFORM SIGN GA2 TIMES BUR PLUS RA");
+-   ("/xf0/x92/x83/x83", "CUNEIFORM SIGN GA2 TIMES DA");
+-   ("/xf0/x92/x83/x84", "CUNEIFORM SIGN GA2 TIMES DI");
+-   ("/xf0/x92/x83/x85", "CUNEIFORM SIGN GA2 TIMES DIM TIMES SHE");
+-   ("/xf0/x92/x83/x86", "CUNEIFORM SIGN GA2 TIMES DUB");
+-   ("/xf0/x92/x83/x87", "CUNEIFORM SIGN GA2 TIMES EL");
+-   ("/xf0/x92/x83/x88", "CUNEIFORM SIGN GA2 TIMES EL PLUS LA");
+-   ("/xf0/x92/x83/x89", "CUNEIFORM SIGN GA2 TIMES EN");
+-   ("/xf0/x92/x83/x8a", "CUNEIFORM SIGN GA2 TIMES EN TIMES GAN2 TENU");
+-   ("/xf0/x92/x83/x8b", "CUNEIFORM SIGN GA2 TIMES GAN2 TENU");
+-   ("/xf0/x92/x83/x8c", "CUNEIFORM SIGN GA2 TIMES GAR");
+-   ("/xf0/x92/x83/x8d", "CUNEIFORM SIGN GA2 TIMES GI");
+-   ("/xf0/x92/x83/x8e", "CUNEIFORM SIGN GA2 TIMES GI4");
+-   ("/xf0/x92/x83/x8f", "CUNEIFORM SIGN GA2 TIMES GI4 PLUS A");
+-   ("/xf0/x92/x83/x90", "CUNEIFORM SIGN GA2 TIMES GIR2 PLUS SU");
+-   ("/xf0/x92/x83/x91", "CUNEIFORM SIGN GA2 TIMES HA PLUS LU PLUS ESH2");
+-   ("/xf0/x92/x83/x92", "CUNEIFORM SIGN GA2 TIMES HAL");
+-   ("/xf0/x92/x83/x93", "CUNEIFORM SIGN GA2 TIMES HAL PLUS LA");
+-   ("/xf0/x92/x83/x94", "CUNEIFORM SIGN GA2 TIMES HI PLUS LI");
+-   ("/xf0/x92/x83/x95", "CUNEIFORM SIGN GA2 TIMES HUB2");
+-   ("/xf0/x92/x83/x96", "CUNEIFORM SIGN GA2 TIMES IGI GUNU");
+-   ("/xf0/x92/x83/x97", "CUNEIFORM SIGN GA2 TIMES ISH PLUS HU PLUS ASH");
+-   ("/xf0/x92/x83/x98", "CUNEIFORM SIGN GA2 TIMES KAK");
+-   ("/xf0/x92/x83/x99", "CUNEIFORM SIGN GA2 TIMES KASKAL");
+-   ("/xf0/x92/x83/x9a", "CUNEIFORM SIGN GA2 TIMES KID");
+-   ("/xf0/x92/x83/x9b", "CUNEIFORM SIGN GA2 TIMES KID PLUS LAL");
+-   ("/xf0/x92/x83/x9c", "CUNEIFORM SIGN GA2 TIMES KU3 PLUS AN");
+-   ("/xf0/x92/x83/x9d", "CUNEIFORM SIGN GA2 TIMES LA");
+-   ("/xf0/x92/x83/x9e", "CUNEIFORM SIGN GA2 TIMES ME PLUS EN");
+-   ("/xf0/x92/x83/x9f", "CUNEIFORM SIGN GA2 TIMES MI");
+-   ("/xf0/x92/x83/xa0", "CUNEIFORM SIGN GA2 TIMES NUN");
+-   ("/xf0/x92/x83/xa1", "CUNEIFORM SIGN GA2 TIMES NUN OVER NUN");
+-   ("/xf0/x92/x83/xa2", "CUNEIFORM SIGN GA2 TIMES PA");
+-   ("/xf0/x92/x83/xa3", "CUNEIFORM SIGN GA2 TIMES SAL");
+-   ("/xf0/x92/x83/xa4", "CUNEIFORM SIGN GA2 TIMES SAR");
+-   ("/xf0/x92/x83/xa5", "CUNEIFORM SIGN GA2 TIMES SHE");
+-   ("/xf0/x92/x83/xa6", "CUNEIFORM SIGN GA2 TIMES SHE PLUS TUR");
+-   ("/xf0/x92/x83/xa7", "CUNEIFORM SIGN GA2 TIMES SHID");
+-   ("/xf0/x92/x83/xa8", "CUNEIFORM SIGN GA2 TIMES SUM");
+-   ("/xf0/x92/x83/xa9", "CUNEIFORM SIGN GA2 TIMES TAK4");
+-   ("/xf0/x92/x83/xaa", "CUNEIFORM SIGN GA2 TIMES U");
+-   ("/xf0/x92/x83/xab", "CUNEIFORM SIGN GA2 TIMES UD");
+-   ("/xf0/x92/x83/xac", "CUNEIFORM SIGN GA2 TIMES UD PLUS DU");
+-   ("/xf0/x92/x83/xad", "CUNEIFORM SIGN GA2 OVER GA2");
+-   ("/xf0/x92/x83/xae", "CUNEIFORM SIGN GABA");
+-   ("/xf0/x92/x83/xaf", "CUNEIFORM SIGN GABA CROSSING GABA");
+-   ("/xf0/x92/x83/xb0", "CUNEIFORM SIGN GAD");
+-   ("/xf0/x92/x83/xb1", "CUNEIFORM SIGN GAD OVER GAD GAR OVER GAR");
+-   ("/xf0/x92/x83/xb2", "CUNEIFORM SIGN GAL");
+-   ("/xf0/x92/x83/xb3", "CUNEIFORM SIGN GAL GAD OVER GAD GAR OVER GAR");
+-   ("/xf0/x92/x83/xb4", "CUNEIFORM SIGN GALAM");
+-   ("/xf0/x92/x83/xb5", "CUNEIFORM SIGN GAM");
+-   ("/xf0/x92/x83/xb6", "CUNEIFORM SIGN GAN");
+-   ("/xf0/x92/x83/xb7", "CUNEIFORM SIGN GAN2");
+-   ("/xf0/x92/x83/xb8", "CUNEIFORM SIGN GAN2 TENU");
+-   ("/xf0/x92/x83/xb9", "CUNEIFORM SIGN GAN2 OVER GAN2");
+-   ("/xf0/x92/x83/xba", "CUNEIFORM SIGN GAN2 CROSSING GAN2");
+-   ("/xf0/x92/x83/xbb", "CUNEIFORM SIGN GAR");
+-   ("/xf0/x92/x83/xbc", "CUNEIFORM SIGN GAR3");
+-   ("/xf0/x92/x83/xbd", "CUNEIFORM SIGN GASHAN");
+-   ("/xf0/x92/x83/xbe", "CUNEIFORM SIGN GESHTIN");
+-   ("/xf0/x92/x83/xbf", "CUNEIFORM SIGN GESHTIN TIMES KUR");
+-   ("/xf0/x92/x84/x80", "CUNEIFORM SIGN GI");
+-   ("/xf0/x92/x84/x81", "CUNEIFORM SIGN GI TIMES E");
+-   ("/xf0/x92/x84/x82", "CUNEIFORM SIGN GI TIMES U");
+-   ("/xf0/x92/x84/x83", "CUNEIFORM SIGN GI CROSSING GI");
+-   ("/xf0/x92/x84/x84", "CUNEIFORM SIGN GI4");
+-   ("/xf0/x92/x84/x85", "CUNEIFORM SIGN GI4 OVER GI4");
+-   ("/xf0/x92/x84/x86", "CUNEIFORM SIGN GI4 CROSSING GI4");
+-   ("/xf0/x92/x84/x87", "CUNEIFORM SIGN GIDIM");
+-   ("/xf0/x92/x84/x88", "CUNEIFORM SIGN GIR2");
+-   ("/xf0/x92/x84/x89", "CUNEIFORM SIGN GIR2 GUNU");
+-   ("/xf0/x92/x84/x8a", "CUNEIFORM SIGN GIR3");
+-   ("/xf0/x92/x84/x8b", "CUNEIFORM SIGN GIR3 TIMES A PLUS IGI");
+-   ("/xf0/x92/x84/x8c", "CUNEIFORM SIGN GIR3 TIMES GAN2 TENU");
+-   ("/xf0/x92/x84/x8d", "CUNEIFORM SIGN GIR3 TIMES IGI");
+-   ("/xf0/x92/x84/x8e", "CUNEIFORM SIGN GIR3 TIMES LU PLUS IGI");
+-   ("/xf0/x92/x84/x8f", "CUNEIFORM SIGN GIR3 TIMES PA");
+-   ("/xf0/x92/x84/x90", "CUNEIFORM SIGN GISAL");
+-   ("/xf0/x92/x84/x91", "CUNEIFORM SIGN GISH");
+-   ("/xf0/x92/x84/x92", "CUNEIFORM SIGN GISH CROSSING GISH");
+-   ("/xf0/x92/x84/x93", "CUNEIFORM SIGN GISH TIMES BAD");
+-   ("/xf0/x92/x84/x94", "CUNEIFORM SIGN GISH TIMES TAK4");
+-   ("/xf0/x92/x84/x95", "CUNEIFORM SIGN GISH TENU");
+-   ("/xf0/x92/x84/x96", "CUNEIFORM SIGN GU");
+-   ("/xf0/x92/x84/x97", "CUNEIFORM SIGN GU CROSSING GU");
+-   ("/xf0/x92/x84/x98", "CUNEIFORM SIGN GU2");
+-   ("/xf0/x92/x84/x99", "CUNEIFORM SIGN GU2 TIMES KAK");
+-   ("/xf0/x92/x84/x9a", "CUNEIFORM SIGN GU2 TIMES KAK TIMES IGI GUNU");
+-   ("/xf0/x92/x84/x9b", "CUNEIFORM SIGN GU2 TIMES NUN");
+-   ("/xf0/x92/x84/x9c", "CUNEIFORM SIGN GU2 TIMES SAL PLUS TUG2");
+-   ("/xf0/x92/x84/x9d", "CUNEIFORM SIGN GU2 GUNU");
+-   ("/xf0/x92/x84/x9e", "CUNEIFORM SIGN GUD");
+-   ("/xf0/x92/x84/x9f", "CUNEIFORM SIGN GUD TIMES A PLUS KUR");
+-   ("/xf0/x92/x84/xa0", "CUNEIFORM SIGN GUD TIMES KUR");
+-   ("/xf0/x92/x84/xa1", "CUNEIFORM SIGN GUD OVER GUD LUGAL");
+-   ("/xf0/x92/x84/xa2", "CUNEIFORM SIGN GUL");
+-   ("/xf0/x92/x84/xa3", "CUNEIFORM SIGN GUM");
+-   ("/xf0/x92/x84/xa4", "CUNEIFORM SIGN GUM TIMES SHE");
+-   ("/xf0/x92/x84/xa5", "CUNEIFORM SIGN GUR");
+-   ("/xf0/x92/x84/xa6", "CUNEIFORM SIGN GUR7");
+-   ("/xf0/x92/x84/xa7", "CUNEIFORM SIGN GURUN");
+-   ("/xf0/x92/x84/xa8", "CUNEIFORM SIGN GURUSH");
+-   ("/xf0/x92/x84/xa9", "CUNEIFORM SIGN HA");
+-   ("/xf0/x92/x84/xaa", "CUNEIFORM SIGN HA TENU");
+-   ("/xf0/x92/x84/xab", "CUNEIFORM SIGN HA GUNU");
+-   ("/xf0/x92/x84/xac", "CUNEIFORM SIGN HAL");
+-   ("/xf0/x92/x84/xad", "CUNEIFORM SIGN HI");
+-   ("/xf0/x92/x84/xae", "CUNEIFORM SIGN HI TIMES ASH");
+-   ("/xf0/x92/x84/xaf", "CUNEIFORM SIGN HI TIMES ASH2");
+-   ("/xf0/x92/x84/xb0", "CUNEIFORM SIGN HI TIMES BAD");
+-   ("/xf0/x92/x84/xb1", "CUNEIFORM SIGN HI TIMES DISH");
+-   ("/xf0/x92/x84/xb2", "CUNEIFORM SIGN HI TIMES GAD");
+-   ("/xf0/x92/x84/xb3", "CUNEIFORM SIGN HI TIMES KIN");
+-   ("/xf0/x92/x84/xb4", "CUNEIFORM SIGN HI TIMES NUN");
+-   ("/xf0/x92/x84/xb5", "CUNEIFORM SIGN HI TIMES SHE");
+-   ("/xf0/x92/x84/xb6", "CUNEIFORM SIGN HI TIMES U");
+-   ("/xf0/x92/x84/xb7", "CUNEIFORM SIGN HU");
+-   ("/xf0/x92/x84/xb8", "CUNEIFORM SIGN HUB2");
+-   ("/xf0/x92/x84/xb9", "CUNEIFORM SIGN HUB2 TIMES AN");
+-   ("/xf0/x92/x84/xba", "CUNEIFORM SIGN HUB2 TIMES HAL");
+-   ("/xf0/x92/x84/xbb", "CUNEIFORM SIGN HUB2 TIMES KASKAL");
+-   ("/xf0/x92/x84/xbc", "CUNEIFORM SIGN HUB2 TIMES LISH");
+-   ("/xf0/x92/x84/xbd", "CUNEIFORM SIGN HUB2 TIMES UD");
+-   ("/xf0/x92/x84/xbe", "CUNEIFORM SIGN HUL2");
+-   ("/xf0/x92/x84/xbf", "CUNEIFORM SIGN I");
+-   ("/xf0/x92/x85/x80", "CUNEIFORM SIGN I A");
+-   ("/xf0/x92/x85/x81", "CUNEIFORM SIGN IB");
+-   ("/xf0/x92/x85/x82", "CUNEIFORM SIGN IDIM");
+-   ("/xf0/x92/x85/x83", "CUNEIFORM SIGN IDIM OVER IDIM BUR");
+-   ("/xf0/x92/x85/x84", "CUNEIFORM SIGN IDIM OVER IDIM SQUARED");
+-   ("/xf0/x92/x85/x85", "CUNEIFORM SIGN IG");
+-   ("/xf0/x92/x85/x86", "CUNEIFORM SIGN IGI");
+-   ("/xf0/x92/x85/x87", "CUNEIFORM SIGN IGI DIB");
+-   ("/xf0/x92/x85/x88", "CUNEIFORM SIGN IGI RI");
+-   ("/xf0/x92/x85/x89", "CUNEIFORM SIGN IGI OVER IGI SHIR OVER SHIR UD OVER UD");
+-   ("/xf0/x92/x85/x8a", "CUNEIFORM SIGN IGI GUNU");
+-   ("/xf0/x92/x85/x8b", "CUNEIFORM SIGN IL");
+-   ("/xf0/x92/x85/x8c", "CUNEIFORM SIGN IL TIMES GAN2 TENU");
+-   ("/xf0/x92/x85/x8d", "CUNEIFORM SIGN IL2");
+-   ("/xf0/x92/x85/x8e", "CUNEIFORM SIGN IM");
+-   ("/xf0/x92/x85/x8f", "CUNEIFORM SIGN IM TIMES TAK4");
+-   ("/xf0/x92/x85/x90", "CUNEIFORM SIGN IM CROSSING IM");
+-   ("/xf0/x92/x85/x91", "CUNEIFORM SIGN IM OPPOSING IM");
+-   ("/xf0/x92/x85/x92", "CUNEIFORM SIGN IM SQUARED");
+-   ("/xf0/x92/x85/x93", "CUNEIFORM SIGN IMIN");
+-   ("/xf0/x92/x85/x94", "CUNEIFORM SIGN IN");
+-   ("/xf0/x92/x85/x95", "CUNEIFORM SIGN IR");
+-   ("/xf0/x92/x85/x96", "CUNEIFORM SIGN ISH");
+-   ("/xf0/x92/x85/x97", "CUNEIFORM SIGN KA");
+-   ("/xf0/x92/x85/x98", "CUNEIFORM SIGN KA TIMES A");
+-   ("/xf0/x92/x85/x99", "CUNEIFORM SIGN KA TIMES AD");
+-   ("/xf0/x92/x85/x9a", "CUNEIFORM SIGN KA TIMES AD PLUS KU3");
+-   ("/xf0/x92/x85/x9b", "CUNEIFORM SIGN KA TIMES ASH2");
+-   ("/xf0/x92/x85/x9c", "CUNEIFORM SIGN KA TIMES BAD");
+-   ("/xf0/x92/x85/x9d", "CUNEIFORM SIGN KA TIMES BALAG");
+-   ("/xf0/x92/x85/x9e", "CUNEIFORM SIGN KA TIMES BAR");
+-   ("/xf0/x92/x85/x9f", "CUNEIFORM SIGN KA TIMES BI");
+-   ("/xf0/x92/x85/xa0", "CUNEIFORM SIGN KA TIMES ERIN2");
+-   ("/xf0/x92/x85/xa1", "CUNEIFORM SIGN KA TIMES ESH2");
+-   ("/xf0/x92/x85/xa2", "CUNEIFORM SIGN KA TIMES GA");
+-   ("/xf0/x92/x85/xa3", "CUNEIFORM SIGN KA TIMES GAL");
+-   ("/xf0/x92/x85/xa4", "CUNEIFORM SIGN KA TIMES GAN2 TENU");
+-   ("/xf0/x92/x85/xa5", "CUNEIFORM SIGN KA TIMES GAR");
+-   ("/xf0/x92/x85/xa6", "CUNEIFORM SIGN KA TIMES GAR PLUS SHA3 PLUS A");
+-   ("/xf0/x92/x85/xa7", "CUNEIFORM SIGN KA TIMES GI");
+-   ("/xf0/x92/x85/xa8", "CUNEIFORM SIGN KA TIMES GIR2");
+-   ("/xf0/x92/x85/xa9", "CUNEIFORM SIGN KA TIMES GISH PLUS SAR");
+-   ("/xf0/x92/x85/xaa", "CUNEIFORM SIGN KA TIMES GISH CROSSING GISH");
+-   ("/xf0/x92/x85/xab", "CUNEIFORM SIGN KA TIMES GU");
+-   ("/xf0/x92/x85/xac", "CUNEIFORM SIGN KA TIMES GUR7");
+-   ("/xf0/x92/x85/xad", "CUNEIFORM SIGN KA TIMES IGI");
+-   ("/xf0/x92/x85/xae", "CUNEIFORM SIGN KA TIMES IM");
+-   ("/xf0/x92/x85/xaf", "CUNEIFORM SIGN KA TIMES KAK");
+-   ("/xf0/x92/x85/xb0", "CUNEIFORM SIGN KA TIMES KI");
+-   ("/xf0/x92/x85/xb1", "CUNEIFORM SIGN KA TIMES KID");
+-   ("/xf0/x92/x85/xb2", "CUNEIFORM SIGN KA TIMES LI");
+-   ("/xf0/x92/x85/xb3", "CUNEIFORM SIGN KA TIMES LU");
+-   ("/xf0/x92/x85/xb4", "CUNEIFORM SIGN KA TIMES ME");
+-   ("/xf0/x92/x85/xb5", "CUNEIFORM SIGN KA TIMES ME PLUS DU");
+-   ("/xf0/x92/x85/xb6", "CUNEIFORM SIGN KA TIMES ME PLUS GI");
+-   ("/xf0/x92/x85/xb7", "CUNEIFORM SIGN KA TIMES ME PLUS TE");
+-   ("/xf0/x92/x85/xb8", "CUNEIFORM SIGN KA TIMES MI");
+-   ("/xf0/x92/x85/xb9", "CUNEIFORM SIGN KA TIMES MI PLUS NUNUZ");
+-   ("/xf0/x92/x85/xba", "CUNEIFORM SIGN KA TIMES NE");
+-   ("/xf0/x92/x85/xbb", "CUNEIFORM SIGN KA TIMES NUN");
+-   ("/xf0/x92/x85/xbc", "CUNEIFORM SIGN KA TIMES PI");
+-   ("/xf0/x92/x85/xbd", "CUNEIFORM SIGN KA TIMES RU");
+-   ("/xf0/x92/x85/xbe", "CUNEIFORM SIGN KA TIMES SA");
+-   ("/xf0/x92/x85/xbf", "CUNEIFORM SIGN KA TIMES SAR");
+-   ("/xf0/x92/x86/x80", "CUNEIFORM SIGN KA TIMES SHA");
+-   ("/xf0/x92/x86/x81", "CUNEIFORM SIGN KA TIMES SHE");
+-   ("/xf0/x92/x86/x82", "CUNEIFORM SIGN KA TIMES SHID");
+-   ("/xf0/x92/x86/x83", "CUNEIFORM SIGN KA TIMES SHU");
+-   ("/xf0/x92/x86/x84", "CUNEIFORM SIGN KA TIMES SIG");
+-   ("/xf0/x92/x86/x85", "CUNEIFORM SIGN KA TIMES SUHUR");
+-   ("/xf0/x92/x86/x86", "CUNEIFORM SIGN KA TIMES TAR");
+-   ("/xf0/x92/x86/x87", "CUNEIFORM SIGN KA TIMES U");
+-   ("/xf0/x92/x86/x88", "CUNEIFORM SIGN KA TIMES U2");
+-   ("/xf0/x92/x86/x89", "CUNEIFORM SIGN KA TIMES UD");
+-   ("/xf0/x92/x86/x8a", "CUNEIFORM SIGN KA TIMES UMUM TIMES PA");
+-   ("/xf0/x92/x86/x8b", "CUNEIFORM SIGN KA TIMES USH");
+-   ("/xf0/x92/x86/x8c", "CUNEIFORM SIGN KA TIMES ZI");
+-   ("/xf0/x92/x86/x8d", "CUNEIFORM SIGN KA2");
+-   ("/xf0/x92/x86/x8e", "CUNEIFORM SIGN KA2 CROSSING KA2");
+-   ("/xf0/x92/x86/x8f", "CUNEIFORM SIGN KAB");
+-   ("/xf0/x92/x86/x90", "CUNEIFORM SIGN KAD2");
+-   ("/xf0/x92/x86/x91", "CUNEIFORM SIGN KAD3");
+-   ("/xf0/x92/x86/x92", "CUNEIFORM SIGN KAD4");
+-   ("/xf0/x92/x86/x93", "CUNEIFORM SIGN KAD5");
+-   ("/xf0/x92/x86/x94", "CUNEIFORM SIGN KAD5 OVER KAD5");
+-   ("/xf0/x92/x86/x95", "CUNEIFORM SIGN KAK");
+-   ("/xf0/x92/x86/x96", "CUNEIFORM SIGN KAK TIMES IGI GUNU");
+-   ("/xf0/x92/x86/x97", "CUNEIFORM SIGN KAL");
+-   ("/xf0/x92/x86/x98", "CUNEIFORM SIGN KAL TIMES BAD");
+-   ("/xf0/x92/x86/x99", "CUNEIFORM SIGN KAL CROSSING KAL");
+-   ("/xf0/x92/x86/x9a", "CUNEIFORM SIGN KAM2");
+-   ("/xf0/x92/x86/x9b", "CUNEIFORM SIGN KAM4");
+-   ("/xf0/x92/x86/x9c", "CUNEIFORM SIGN KASKAL");
+-   ("/xf0/x92/x86/x9d", "CUNEIFORM SIGN KASKAL LAGAB TIMES U OVER LAGAB TIMES U");
+-   ("/xf0/x92/x86/x9e", "CUNEIFORM SIGN KASKAL OVER KASKAL LAGAB TIMES U OVER LAGAB TIMES U");
+-   ("/xf0/x92/x86/x9f", "CUNEIFORM SIGN KESH2");
+-   ("/xf0/x92/x86/xa0", "CUNEIFORM SIGN KI");
+-   ("/xf0/x92/x86/xa1", "CUNEIFORM SIGN KI TIMES BAD");
+-   ("/xf0/x92/x86/xa2", "CUNEIFORM SIGN KI TIMES U");
+-   ("/xf0/x92/x86/xa3", "CUNEIFORM SIGN KI TIMES UD");
+-   ("/xf0/x92/x86/xa4", "CUNEIFORM SIGN KID");
+-   ("/xf0/x92/x86/xa5", "CUNEIFORM SIGN KIN");
+-   ("/xf0/x92/x86/xa6", "CUNEIFORM SIGN KISAL");
+-   ("/xf0/x92/x86/xa7", "CUNEIFORM SIGN KISH");
+-   ("/xf0/x92/x86/xa8", "CUNEIFORM SIGN KISIM5");
+-   ("/xf0/x92/x86/xa9", "CUNEIFORM SIGN KISIM5 OVER KISIM5");
+-   ("/xf0/x92/x86/xaa", "CUNEIFORM SIGN KU");
+-   ("/xf0/x92/x86/xab", "CUNEIFORM SIGN KU OVER HI TIMES ASH2 KU OVER HI TIMES ASH2");
+-   ("/xf0/x92/x86/xac", "CUNEIFORM SIGN KU3");
+-   ("/xf0/x92/x86/xad", "CUNEIFORM SIGN KU4");
+-   ("/xf0/x92/x86/xae", "CUNEIFORM SIGN KU4 VARIANT FORM");
+-   ("/xf0/x92/x86/xaf", "CUNEIFORM SIGN KU7");
+-   ("/xf0/x92/x86/xb0", "CUNEIFORM SIGN KUL");
+-   ("/xf0/x92/x86/xb1", "CUNEIFORM SIGN KUL GUNU");
+-   ("/xf0/x92/x86/xb2", "CUNEIFORM SIGN KUN");
+-   ("/xf0/x92/x86/xb3", "CUNEIFORM SIGN KUR");
+-   ("/xf0/x92/x86/xb4", "CUNEIFORM SIGN KUR OPPOSING KUR");
+-   ("/xf0/x92/x86/xb5", "CUNEIFORM SIGN KUSHU2");
+-   ("/xf0/x92/x86/xb6", "CUNEIFORM SIGN KWU318");
+-   ("/xf0/x92/x86/xb7", "CUNEIFORM SIGN LA");
+-   ("/xf0/x92/x86/xb8", "CUNEIFORM SIGN LAGAB");
+-   ("/xf0/x92/x86/xb9", "CUNEIFORM SIGN LAGAB TIMES A");
+-   ("/xf0/x92/x86/xba", "CUNEIFORM SIGN LAGAB TIMES A PLUS DA PLUS HA");
+-   ("/xf0/x92/x86/xbb", "CUNEIFORM SIGN LAGAB TIMES A PLUS GAR");
+-   ("/xf0/x92/x86/xbc", "CUNEIFORM SIGN LAGAB TIMES A PLUS LAL");
+-   ("/xf0/x92/x86/xbd", "CUNEIFORM SIGN LAGAB TIMES AL");
+-   ("/xf0/x92/x86/xbe", "CUNEIFORM SIGN LAGAB TIMES AN");
+-   ("/xf0/x92/x86/xbf", "CUNEIFORM SIGN LAGAB TIMES ASH ZIDA TENU");
+-   ("/xf0/x92/x87/x80", "CUNEIFORM SIGN LAGAB TIMES BAD");
+-   ("/xf0/x92/x87/x81", "CUNEIFORM SIGN LAGAB TIMES BI");
+-   ("/xf0/x92/x87/x82", "CUNEIFORM SIGN LAGAB TIMES DAR");
+-   ("/xf0/x92/x87/x83", "CUNEIFORM SIGN LAGAB TIMES EN");
+-   ("/xf0/x92/x87/x84", "CUNEIFORM SIGN LAGAB TIMES GA");
+-   ("/xf0/x92/x87/x85", "CUNEIFORM SIGN LAGAB TIMES GAR");
+-   ("/xf0/x92/x87/x86", "CUNEIFORM SIGN LAGAB TIMES GUD");
+-   ("/xf0/x92/x87/x87", "CUNEIFORM SIGN LAGAB TIMES GUD PLUS GUD");
+-   ("/xf0/x92/x87/x88", "CUNEIFORM SIGN LAGAB TIMES HA");
+-   ("/xf0/x92/x87/x89", "CUNEIFORM SIGN LAGAB TIMES HAL");
+-   ("/xf0/x92/x87/x8a", "CUNEIFORM SIGN LAGAB TIMES HI TIMES NUN");
+-   ("/xf0/x92/x87/x8b", "CUNEIFORM SIGN LAGAB TIMES IGI GUNU");
+-   ("/xf0/x92/x87/x8c", "CUNEIFORM SIGN LAGAB TIMES IM");
+-   ("/xf0/x92/x87/x8d", "CUNEIFORM SIGN LAGAB TIMES IM PLUS HA");
+-   ("/xf0/x92/x87/x8e", "CUNEIFORM SIGN LAGAB TIMES IM PLUS LU");
+-   ("/xf0/x92/x87/x8f", "CUNEIFORM SIGN LAGAB TIMES KI");
+-   ("/xf0/x92/x87/x90", "CUNEIFORM SIGN LAGAB TIMES KIN");
+-   ("/xf0/x92/x87/x91", "CUNEIFORM SIGN LAGAB TIMES KU3");
+-   ("/xf0/x92/x87/x92", "CUNEIFORM SIGN LAGAB TIMES KUL");
+-   ("/xf0/x92/x87/x93", "CUNEIFORM SIGN LAGAB TIMES KUL PLUS HI PLUS A");
+-   ("/xf0/x92/x87/x94", "CUNEIFORM SIGN LAGAB TIMES LAGAB");
+-   ("/xf0/x92/x87/x95", "CUNEIFORM SIGN LAGAB TIMES LISH");
+-   ("/xf0/x92/x87/x96", "CUNEIFORM SIGN LAGAB TIMES LU");
+-   ("/xf0/x92/x87/x97", "CUNEIFORM SIGN LAGAB TIMES LUL");
+-   ("/xf0/x92/x87/x98", "CUNEIFORM SIGN LAGAB TIMES ME");
+-   ("/xf0/x92/x87/x99", "CUNEIFORM SIGN LAGAB TIMES ME PLUS EN");
+-   ("/xf0/x92/x87/x9a", "CUNEIFORM SIGN LAGAB TIMES MUSH");
+-   ("/xf0/x92/x87/x9b", "CUNEIFORM SIGN LAGAB TIMES NE");
+-   ("/xf0/x92/x87/x9c", "CUNEIFORM SIGN LAGAB TIMES SHE PLUS SUM");
+-   ("/xf0/x92/x87/x9d", "CUNEIFORM SIGN LAGAB TIMES SHITA PLUS GISH PLUS ERIN2");
+-   ("/xf0/x92/x87/x9e", "CUNEIFORM SIGN LAGAB TIMES SHITA PLUS GISH TENU");
+-   ("/xf0/x92/x87/x9f", "CUNEIFORM SIGN LAGAB TIMES SHU2");
+-   ("/xf0/x92/x87/xa0", "CUNEIFORM SIGN LAGAB TIMES SHU2 PLUS SHU2");
+-   ("/xf0/x92/x87/xa1", "CUNEIFORM SIGN LAGAB TIMES SUM");
+-   ("/xf0/x92/x87/xa2", "CUNEIFORM SIGN LAGAB TIMES TAG");
+-   ("/xf0/x92/x87/xa3", "CUNEIFORM SIGN LAGAB TIMES TAK4");
+-   ("/xf0/x92/x87/xa4", "CUNEIFORM SIGN LAGAB TIMES TE PLUS A PLUS SU PLUS NA");
+-   ("/xf0/x92/x87/xa5", "CUNEIFORM SIGN LAGAB TIMES U");
+-   ("/xf0/x92/x87/xa6", "CUNEIFORM SIGN LAGAB TIMES U PLUS A");
+-   ("/xf0/x92/x87/xa7", "CUNEIFORM SIGN LAGAB TIMES U PLUS U PLUS U");
+-   ("/xf0/x92/x87/xa8", "CUNEIFORM SIGN LAGAB TIMES U2 PLUS ASH");
+-   ("/xf0/x92/x87/xa9", "CUNEIFORM SIGN LAGAB TIMES UD");
+-   ("/xf0/x92/x87/xaa", "CUNEIFORM SIGN LAGAB TIMES USH");
+-   ("/xf0/x92/x87/xab", "CUNEIFORM SIGN LAGAB SQUARED");
+-   ("/xf0/x92/x87/xac", "CUNEIFORM SIGN LAGAR");
+-   ("/xf0/x92/x87/xad", "CUNEIFORM SIGN LAGAR TIMES SHE");
+-   ("/xf0/x92/x87/xae", "CUNEIFORM SIGN LAGAR TIMES SHE PLUS SUM");
+-   ("/xf0/x92/x87/xaf", "CUNEIFORM SIGN LAGAR GUNU");
+-   ("/xf0/x92/x87/xb0", "CUNEIFORM SIGN LAGAR GUNU OVER LAGAR GUNU SHE");
+-   ("/xf0/x92/x87/xb1", "CUNEIFORM SIGN LAHSHU");
+-   ("/xf0/x92/x87/xb2", "CUNEIFORM SIGN LAL");
+-   ("/xf0/x92/x87/xb3", "CUNEIFORM SIGN LAL TIMES LAL");
+-   ("/xf0/x92/x87/xb4", "CUNEIFORM SIGN LAM");
+-   ("/xf0/x92/x87/xb5", "CUNEIFORM SIGN LAM TIMES KUR");
+-   ("/xf0/x92/x87/xb6", "CUNEIFORM SIGN LAM TIMES KUR PLUS RU");
+-   ("/xf0/x92/x87/xb7", "CUNEIFORM SIGN LI");
+-   ("/xf0/x92/x87/xb8", "CUNEIFORM SIGN LIL");
+-   ("/xf0/x92/x87/xb9", "CUNEIFORM SIGN LIMMU2");
+-   ("/xf0/x92/x87/xba", "CUNEIFORM SIGN LISH");
+-   ("/xf0/x92/x87/xbb", "CUNEIFORM SIGN LU");
+-   ("/xf0/x92/x87/xbc", "CUNEIFORM SIGN LU TIMES BAD");
+-   ("/xf0/x92/x87/xbd", "CUNEIFORM SIGN LU2");
+-   ("/xf0/x92/x87/xbe", "CUNEIFORM SIGN LU2 TIMES AL");
+-   ("/xf0/x92/x87/xbf", "CUNEIFORM SIGN LU2 TIMES BAD");
+-   ("/xf0/x92/x88/x80", "CUNEIFORM SIGN LU2 TIMES ESH2");
+-   ("/xf0/x92/x88/x81", "CUNEIFORM SIGN LU2 TIMES ESH2 TENU");
+-   ("/xf0/x92/x88/x82", "CUNEIFORM SIGN LU2 TIMES GAN2 TENU");
+-   ("/xf0/x92/x88/x83", "CUNEIFORM SIGN LU2 TIMES HI TIMES BAD");
+-   ("/xf0/x92/x88/x84", "CUNEIFORM SIGN LU2 TIMES IM");
+-   ("/xf0/x92/x88/x85", "CUNEIFORM SIGN LU2 TIMES KAD2");
+-   ("/xf0/x92/x88/x86", "CUNEIFORM SIGN LU2 TIMES KAD3");
+-   ("/xf0/x92/x88/x87", "CUNEIFORM SIGN LU2 TIMES KAD3 PLUS ASH");
+-   ("/xf0/x92/x88/x88", "CUNEIFORM SIGN LU2 TIMES KI");
+-   ("/xf0/x92/x88/x89", "CUNEIFORM SIGN LU2 TIMES LA PLUS ASH");
+-   ("/xf0/x92/x88/x8a", "CUNEIFORM SIGN LU2 TIMES LAGAB");
+-   ("/xf0/x92/x88/x8b", "CUNEIFORM SIGN LU2 TIMES ME PLUS EN");
+-   ("/xf0/x92/x88/x8c", "CUNEIFORM SIGN LU2 TIMES NE");
+-   ("/xf0/x92/x88/x8d", "CUNEIFORM SIGN LU2 TIMES NU");
+-   ("/xf0/x92/x88/x8e", "CUNEIFORM SIGN LU2 TIMES SI PLUS ASH");
+-   ("/xf0/x92/x88/x8f", "CUNEIFORM SIGN LU2 TIMES SIK2 PLUS BU");
+-   ("/xf0/x92/x88/x90", "CUNEIFORM SIGN LU2 TIMES TUG2");
+-   ("/xf0/x92/x88/x91", "CUNEIFORM SIGN LU2 TENU");
+-   ("/xf0/x92/x88/x92", "CUNEIFORM SIGN LU2 CROSSING LU2");
+-   ("/xf0/x92/x88/x93", "CUNEIFORM SIGN LU2 OPPOSING LU2");
+-   ("/xf0/x92/x88/x94", "CUNEIFORM SIGN LU2 SQUARED");
+-   ("/xf0/x92/x88/x95", "CUNEIFORM SIGN LU2 SHESHIG");
+-   ("/xf0/x92/x88/x96", "CUNEIFORM SIGN LU3");
+-   ("/xf0/x92/x88/x97", "CUNEIFORM SIGN LUGAL");
+-   ("/xf0/x92/x88/x98", "CUNEIFORM SIGN LUGAL OVER LUGAL");
+-   ("/xf0/x92/x88/x99", "CUNEIFORM SIGN LUGAL OPPOSING LUGAL");
+-   ("/xf0/x92/x88/x9a", "CUNEIFORM SIGN LUGAL SHESHIG");
+-   ("/xf0/x92/x88/x9b", "CUNEIFORM SIGN LUH");
+-   ("/xf0/x92/x88/x9c", "CUNEIFORM SIGN LUL");
+-   ("/xf0/x92/x88/x9d", "CUNEIFORM SIGN LUM");
+-   ("/xf0/x92/x88/x9e", "CUNEIFORM SIGN LUM OVER LUM");
+-   ("/xf0/x92/x88/x9f", "CUNEIFORM SIGN LUM OVER LUM GAR OVER GAR");
+-   ("/xf0/x92/x88/xa0", "CUNEIFORM SIGN MA");
+-   ("/xf0/x92/x88/xa1", "CUNEIFORM SIGN MA TIMES TAK4");
+-   ("/xf0/x92/x88/xa2", "CUNEIFORM SIGN MA GUNU");
+-   ("/xf0/x92/x88/xa3", "CUNEIFORM SIGN MA2");
+-   ("/xf0/x92/x88/xa4", "CUNEIFORM SIGN MAH");
+-   ("/xf0/x92/x88/xa5", "CUNEIFORM SIGN MAR");
+-   ("/xf0/x92/x88/xa6", "CUNEIFORM SIGN MASH");
+-   ("/xf0/x92/x88/xa7", "CUNEIFORM SIGN MASH2");
+-   ("/xf0/x92/x88/xa8", "CUNEIFORM SIGN ME");
+-   ("/xf0/x92/x88/xa9", "CUNEIFORM SIGN MES");
+-   ("/xf0/x92/x88/xaa", "CUNEIFORM SIGN MI");
+-   ("/xf0/x92/x88/xab", "CUNEIFORM SIGN MIN");
+-   ("/xf0/x92/x88/xac", "CUNEIFORM SIGN MU");
+-   ("/xf0/x92/x88/xad", "CUNEIFORM SIGN MU OVER MU");
+-   ("/xf0/x92/x88/xae", "CUNEIFORM SIGN MUG");
+-   ("/xf0/x92/x88/xaf", "CUNEIFORM SIGN MUG GUNU");
+-   ("/xf0/x92/x88/xb0", "CUNEIFORM SIGN MUNSUB");
+-   ("/xf0/x92/x88/xb1", "CUNEIFORM SIGN MURGU2");
+-   ("/xf0/x92/x88/xb2", "CUNEIFORM SIGN MUSH");
+-   ("/xf0/x92/x88/xb3", "CUNEIFORM SIGN MUSH TIMES A");
+-   ("/xf0/x92/x88/xb4", "CUNEIFORM SIGN MUSH TIMES KUR");
+-   ("/xf0/x92/x88/xb5", "CUNEIFORM SIGN MUSH TIMES ZA");
+-   ("/xf0/x92/x88/xb6", "CUNEIFORM SIGN MUSH OVER MUSH");
+-   ("/xf0/x92/x88/xb7", "CUNEIFORM SIGN MUSH OVER MUSH TIMES A PLUS NA");
+-   ("/xf0/x92/x88/xb8", "CUNEIFORM SIGN MUSH CROSSING MUSH");
+-   ("/xf0/x92/x88/xb9", "CUNEIFORM SIGN MUSH3");
+-   ("/xf0/x92/x88/xba", "CUNEIFORM SIGN MUSH3 TIMES A");
+-   ("/xf0/x92/x88/xbb", "CUNEIFORM SIGN MUSH3 TIMES A PLUS DI");
+-   ("/xf0/x92/x88/xbc", "CUNEIFORM SIGN MUSH3 TIMES DI");
+-   ("/xf0/x92/x88/xbd", "CUNEIFORM SIGN MUSH3 GUNU");
+-   ("/xf0/x92/x88/xbe", "CUNEIFORM SIGN NA");
+-   ("/xf0/x92/x88/xbf", "CUNEIFORM SIGN NA2");
+-   ("/xf0/x92/x89/x80", "CUNEIFORM SIGN NAGA");
+-   ("/xf0/x92/x89/x81", "CUNEIFORM SIGN NAGA INVERTED");
+-   ("/xf0/x92/x89/x82", "CUNEIFORM SIGN NAGA TIMES SHU TENU");
+-   ("/xf0/x92/x89/x83", "CUNEIFORM SIGN NAGA OPPOSING NAGA");
+-   ("/xf0/x92/x89/x84", "CUNEIFORM SIGN NAGAR");
+-   ("/xf0/x92/x89/x85", "CUNEIFORM SIGN NAM NUTILLU");
+-   ("/xf0/x92/x89/x86", "CUNEIFORM SIGN NAM");
+-   ("/xf0/x92/x89/x87", "CUNEIFORM SIGN NAM2");
+-   ("/xf0/x92/x89/x88", "CUNEIFORM SIGN NE");
+-   ("/xf0/x92/x89/x89", "CUNEIFORM SIGN NE TIMES A");
+-   ("/xf0/x92/x89/x8a", "CUNEIFORM SIGN NE TIMES UD");
+-   ("/xf0/x92/x89/x8b", "CUNEIFORM SIGN NE SHESHIG");
+-   ("/xf0/x92/x89/x8c", "CUNEIFORM SIGN NI");
+-   ("/xf0/x92/x89/x8d", "CUNEIFORM SIGN NI TIMES E");
+-   ("/xf0/x92/x89/x8e", "CUNEIFORM SIGN NI2");
+-   ("/xf0/x92/x89/x8f", "CUNEIFORM SIGN NIM");
+-   ("/xf0/x92/x89/x90", "CUNEIFORM SIGN NIM TIMES GAN2 TENU");
+-   ("/xf0/x92/x89/x91", "CUNEIFORM SIGN NIM TIMES GAR PLUS GAN2 TENU");
+-   ("/xf0/x92/x89/x92", "CUNEIFORM SIGN NINDA2");
+-   ("/xf0/x92/x89/x93", "CUNEIFORM SIGN NINDA2 TIMES AN");
+-   ("/xf0/x92/x89/x94", "CUNEIFORM SIGN NINDA2 TIMES ASH");
+-   ("/xf0/x92/x89/x95", "CUNEIFORM SIGN NINDA2 TIMES ASH PLUS ASH");
+-   ("/xf0/x92/x89/x96", "CUNEIFORM SIGN NINDA2 TIMES GUD");
+-   ("/xf0/x92/x89/x97", "CUNEIFORM SIGN NINDA2 TIMES ME PLUS GAN2 TENU");
+-   ("/xf0/x92/x89/x98", "CUNEIFORM SIGN NINDA2 TIMES NE");
+-   ("/xf0/x92/x89/x99", "CUNEIFORM SIGN NINDA2 TIMES NUN");
+-   ("/xf0/x92/x89/x9a", "CUNEIFORM SIGN NINDA2 TIMES SHE");
+-   ("/xf0/x92/x89/x9b", "CUNEIFORM SIGN NINDA2 TIMES SHE PLUS A AN");
+-   ("/xf0/x92/x89/x9c", "CUNEIFORM SIGN NINDA2 TIMES SHE PLUS ASH");
+-   ("/xf0/x92/x89/x9d", "CUNEIFORM SIGN NINDA2 TIMES SHE PLUS ASH PLUS ASH");
+-   ("/xf0/x92/x89/x9e", "CUNEIFORM SIGN NINDA2 TIMES U2 PLUS ASH");
+-   ("/xf0/x92/x89/x9f", "CUNEIFORM SIGN NINDA2 TIMES USH");
+-   ("/xf0/x92/x89/xa0", "CUNEIFORM SIGN NISAG");
+-   ("/xf0/x92/x89/xa1", "CUNEIFORM SIGN NU");
+-   ("/xf0/x92/x89/xa2", "CUNEIFORM SIGN NU11");
+-   ("/xf0/x92/x89/xa3", "CUNEIFORM SIGN NUN");
+-   ("/xf0/x92/x89/xa4", "CUNEIFORM SIGN NUN LAGAR TIMES GAR");
+-   ("/xf0/x92/x89/xa5", "CUNEIFORM SIGN NUN LAGAR TIMES MASH");
+-   ("/xf0/x92/x89/xa6", "CUNEIFORM SIGN NUN LAGAR TIMES SAL");
+-   ("/xf0/x92/x89/xa7", "CUNEIFORM SIGN NUN LAGAR TIMES SAL OVER NUN LAGAR TIMES SAL");
+-   ("/xf0/x92/x89/xa8", "CUNEIFORM SIGN NUN LAGAR TIMES USH");
+-   ("/xf0/x92/x89/xa9", "CUNEIFORM SIGN NUN TENU");
+-   ("/xf0/x92/x89/xaa", "CUNEIFORM SIGN NUN OVER NUN");
+-   ("/xf0/x92/x89/xab", "CUNEIFORM SIGN NUN CROSSING NUN");
+-   ("/xf0/x92/x89/xac", "CUNEIFORM SIGN NUN CROSSING NUN LAGAR OVER LAGAR");
+-   ("/xf0/x92/x89/xad", "CUNEIFORM SIGN NUNUZ");
+-   ("/xf0/x92/x89/xae", "CUNEIFORM SIGN NUNUZ AB2 TIMES ASHGAB");
+-   ("/xf0/x92/x89/xaf", "CUNEIFORM SIGN NUNUZ AB2 TIMES BI");
+-   ("/xf0/x92/x89/xb0", "CUNEIFORM SIGN NUNUZ AB2 TIMES DUG");
+-   ("/xf0/x92/x89/xb1", "CUNEIFORM SIGN NUNUZ AB2 TIMES GUD");
+-   ("/xf0/x92/x89/xb2", "CUNEIFORM SIGN NUNUZ AB2 TIMES IGI GUNU");
+-   ("/xf0/x92/x89/xb3", "CUNEIFORM SIGN NUNUZ AB2 TIMES KAD3");
+-   ("/xf0/x92/x89/xb4", "CUNEIFORM SIGN NUNUZ AB2 TIMES LA");
+-   ("/xf0/x92/x89/xb5", "CUNEIFORM SIGN NUNUZ AB2 TIMES NE");
+-   ("/xf0/x92/x89/xb6", "CUNEIFORM SIGN NUNUZ AB2 TIMES SILA3");
+-   ("/xf0/x92/x89/xb7", "CUNEIFORM SIGN NUNUZ AB2 TIMES U2");
+-   ("/xf0/x92/x89/xb8", "CUNEIFORM SIGN NUNUZ KISIM5 TIMES BI");
+-   ("/xf0/x92/x89/xb9", "CUNEIFORM SIGN NUNUZ KISIM5 TIMES BI U");
+-   ("/xf0/x92/x89/xba", "CUNEIFORM SIGN PA");
+-   ("/xf0/x92/x89/xbb", "CUNEIFORM SIGN PAD");
+-   ("/xf0/x92/x89/xbc", "CUNEIFORM SIGN PAN");
+-   ("/xf0/x92/x89/xbd", "CUNEIFORM SIGN PAP");
+-   ("/xf0/x92/x89/xbe", "CUNEIFORM SIGN PESH2");
+-   ("/xf0/x92/x89/xbf", "CUNEIFORM SIGN PI");
+-   ("/xf0/x92/x8a/x80", "CUNEIFORM SIGN PI TIMES A");
+-   ("/xf0/x92/x8a/x81", "CUNEIFORM SIGN PI TIMES AB");
+-   ("/xf0/x92/x8a/x82", "CUNEIFORM SIGN PI TIMES BI");
+-   ("/xf0/x92/x8a/x83", "CUNEIFORM SIGN PI TIMES BU");
+-   ("/xf0/x92/x8a/x84", "CUNEIFORM SIGN PI TIMES E");
+-   ("/xf0/x92/x8a/x85", "CUNEIFORM SIGN PI TIMES I");
+-   ("/xf0/x92/x8a/x86", "CUNEIFORM SIGN PI TIMES IB");
+-   ("/xf0/x92/x8a/x87", "CUNEIFORM SIGN PI TIMES U");
+-   ("/xf0/x92/x8a/x88", "CUNEIFORM SIGN PI TIMES U2");
+-   ("/xf0/x92/x8a/x89", "CUNEIFORM SIGN PI CROSSING PI");
+-   ("/xf0/x92/x8a/x8a", "CUNEIFORM SIGN PIRIG");
+-   ("/xf0/x92/x8a/x8b", "CUNEIFORM SIGN PIRIG TIMES KAL");
+-   ("/xf0/x92/x8a/x8c", "CUNEIFORM SIGN PIRIG TIMES UD");
+-   ("/xf0/x92/x8a/x8d", "CUNEIFORM SIGN PIRIG TIMES ZA");
+-   ("/xf0/x92/x8a/x8e", "CUNEIFORM SIGN PIRIG OPPOSING PIRIG");
+-   ("/xf0/x92/x8a/x8f", "CUNEIFORM SIGN RA");
+-   ("/xf0/x92/x8a/x90", "CUNEIFORM SIGN RAB");
+-   ("/xf0/x92/x8a/x91", "CUNEIFORM SIGN RI");
+-   ("/xf0/x92/x8a/x92", "CUNEIFORM SIGN RU");
+-   ("/xf0/x92/x8a/x93", "CUNEIFORM SIGN SA");
+-   ("/xf0/x92/x8a/x94", "CUNEIFORM SIGN SAG NUTILLU");
+-   ("/xf0/x92/x8a/x95", "CUNEIFORM SIGN SAG");
+-   ("/xf0/x92/x8a/x96", "CUNEIFORM SIGN SAG TIMES A");
+-   ("/xf0/x92/x8a/x97", "CUNEIFORM SIGN SAG TIMES DU");
+-   ("/xf0/x92/x8a/x98", "CUNEIFORM SIGN SAG TIMES DUB");
+-   ("/xf0/x92/x8a/x99", "CUNEIFORM SIGN SAG TIMES HA");
+-   ("/xf0/x92/x8a/x9a", "CUNEIFORM SIGN SAG TIMES KAK");
+-   ("/xf0/x92/x8a/x9b", "CUNEIFORM SIGN SAG TIMES KUR");
+-   ("/xf0/x92/x8a/x9c", "CUNEIFORM SIGN SAG TIMES LUM");
+-   ("/xf0/x92/x8a/x9d", "CUNEIFORM SIGN SAG TIMES MI");
+-   ("/xf0/x92/x8a/x9e", "CUNEIFORM SIGN SAG TIMES NUN");
+-   ("/xf0/x92/x8a/x9f", "CUNEIFORM SIGN SAG TIMES SAL");
+-   ("/xf0/x92/x8a/xa0", "CUNEIFORM SIGN SAG TIMES SHID");
+-   ("/xf0/x92/x8a/xa1", "CUNEIFORM SIGN SAG TIMES TAB");
+-   ("/xf0/x92/x8a/xa2", "CUNEIFORM SIGN SAG TIMES U2");
+-   ("/xf0/x92/x8a/xa3", "CUNEIFORM SIGN SAG TIMES UB");
+-   ("/xf0/x92/x8a/xa4", "CUNEIFORM SIGN SAG TIMES UM");
+-   ("/xf0/x92/x8a/xa5", "CUNEIFORM SIGN SAG TIMES UR");
+-   ("/xf0/x92/x8a/xa6", "CUNEIFORM SIGN SAG TIMES USH");
+-   ("/xf0/x92/x8a/xa7", "CUNEIFORM SIGN SAG OVER SAG");
+-   ("/xf0/x92/x8a/xa8", "CUNEIFORM SIGN SAG GUNU");
+-   ("/xf0/x92/x8a/xa9", "CUNEIFORM SIGN SAL");
+-   ("/xf0/x92/x8a/xaa", "CUNEIFORM SIGN SAL LAGAB TIMES ASH2");
+-   ("/xf0/x92/x8a/xab", "CUNEIFORM SIGN SANGA2");
+-   ("/xf0/x92/x8a/xac", "CUNEIFORM SIGN SAR");
+-   ("/xf0/x92/x8a/xad", "CUNEIFORM SIGN SHA");
+-   ("/xf0/x92/x8a/xae", "CUNEIFORM SIGN SHA3");
+-   ("/xf0/x92/x8a/xaf", "CUNEIFORM SIGN SHA3 TIMES A");
+-   ("/xf0/x92/x8a/xb0", "CUNEIFORM SIGN SHA3 TIMES BAD");
+-   ("/xf0/x92/x8a/xb1", "CUNEIFORM SIGN SHA3 TIMES GISH");
+-   ("/xf0/x92/x8a/xb2", "CUNEIFORM SIGN SHA3 TIMES NE");
+-   ("/xf0/x92/x8a/xb3", "CUNEIFORM SIGN SHA3 TIMES SHU2");
+-   ("/xf0/x92/x8a/xb4", "CUNEIFORM SIGN SHA3 TIMES TUR");
+-   ("/xf0/x92/x8a/xb5", "CUNEIFORM SIGN SHA3 TIMES U");
+-   ("/xf0/x92/x8a/xb6", "CUNEIFORM SIGN SHA3 TIMES U PLUS A");
+-   ("/xf0/x92/x8a/xb7", "CUNEIFORM SIGN SHA6");
+-   ("/xf0/x92/x8a/xb8", "CUNEIFORM SIGN SHAB6");
+-   ("/xf0/x92/x8a/xb9", "CUNEIFORM SIGN SHAR2");
+-   ("/xf0/x92/x8a/xba", "CUNEIFORM SIGN SHE");
+-   ("/xf0/x92/x8a/xbb", "CUNEIFORM SIGN SHE HU");
+-   ("/xf0/x92/x8a/xbc", "CUNEIFORM SIGN SHE OVER SHE GAD OVER GAD GAR OVER GAR");
+-   ("/xf0/x92/x8a/xbd", "CUNEIFORM SIGN SHE OVER SHE TAB OVER TAB GAR OVER GAR");
+-   ("/xf0/x92/x8a/xbe", "CUNEIFORM SIGN SHEG9");
+-   ("/xf0/x92/x8a/xbf", "CUNEIFORM SIGN SHEN");
+-   ("/xf0/x92/x8b/x80", "CUNEIFORM SIGN SHESH");
+-   ("/xf0/x92/x8b/x81", "CUNEIFORM SIGN SHESH2");
+-   ("/xf0/x92/x8b/x82", "CUNEIFORM SIGN SHESHLAM");
+-   ("/xf0/x92/x8b/x83", "CUNEIFORM SIGN SHID");
+-   ("/xf0/x92/x8b/x84", "CUNEIFORM SIGN SHID TIMES A");
+-   ("/xf0/x92/x8b/x85", "CUNEIFORM SIGN SHID TIMES IM");
+-   ("/xf0/x92/x8b/x86", "CUNEIFORM SIGN SHIM");
+-   ("/xf0/x92/x8b/x87", "CUNEIFORM SIGN SHIM TIMES A");
+-   ("/xf0/x92/x8b/x88", "CUNEIFORM SIGN SHIM TIMES BAL");
+-   ("/xf0/x92/x8b/x89", "CUNEIFORM SIGN SHIM TIMES BULUG");
+-   ("/xf0/x92/x8b/x8a", "CUNEIFORM SIGN SHIM TIMES DIN");
+-   ("/xf0/x92/x8b/x8b", "CUNEIFORM SIGN SHIM TIMES GAR");
+-   ("/xf0/x92/x8b/x8c", "CUNEIFORM SIGN SHIM TIMES IGI");
+-   ("/xf0/x92/x8b/x8d", "CUNEIFORM SIGN SHIM TIMES IGI GUNU");
+-   ("/xf0/x92/x8b/x8e", "CUNEIFORM SIGN SHIM TIMES KUSHU2");
+-   ("/xf0/x92/x8b/x8f", "CUNEIFORM SIGN SHIM TIMES LUL");
+-   ("/xf0/x92/x8b/x90", "CUNEIFORM SIGN SHIM TIMES MUG");
+-   ("/xf0/x92/x8b/x91", "CUNEIFORM SIGN SHIM TIMES SAL");
+-   ("/xf0/x92/x8b/x92", "CUNEIFORM SIGN SHINIG");
+-   ("/xf0/x92/x8b/x93", "CUNEIFORM SIGN SHIR");
+-   ("/xf0/x92/x8b/x94", "CUNEIFORM SIGN SHIR TENU");
+-   ("/xf0/x92/x8b/x95", "CUNEIFORM SIGN SHIR OVER SHIR BUR OVER BUR");
+-   ("/xf0/x92/x8b/x96", "CUNEIFORM SIGN SHITA");
+-   ("/xf0/x92/x8b/x97", "CUNEIFORM SIGN SHU");
+-   ("/xf0/x92/x8b/x98", "CUNEIFORM SIGN SHU OVER INVERTED SHU");
+-   ("/xf0/x92/x8b/x99", "CUNEIFORM SIGN SHU2");
+-   ("/xf0/x92/x8b/x9a", "CUNEIFORM SIGN SHUBUR");
+-   ("/xf0/x92/x8b/x9b", "CUNEIFORM SIGN SI");
+-   ("/xf0/x92/x8b/x9c", "CUNEIFORM SIGN SI GUNU");
+-   ("/xf0/x92/x8b/x9d", "CUNEIFORM SIGN SIG");
+-   ("/xf0/x92/x8b/x9e", "CUNEIFORM SIGN SIG4");
+-   ("/xf0/x92/x8b/x9f", "CUNEIFORM SIGN SIG4 OVER SIG4 SHU2");
+-   ("/xf0/x92/x8b/xa0", "CUNEIFORM SIGN SIK2");
+-   ("/xf0/x92/x8b/xa1", "CUNEIFORM SIGN SILA3");
+-   ("/xf0/x92/x8b/xa2", "CUNEIFORM SIGN SU");
+-   ("/xf0/x92/x8b/xa3", "CUNEIFORM SIGN SU OVER SU");
+-   ("/xf0/x92/x8b/xa4", "CUNEIFORM SIGN SUD");
+-   ("/xf0/x92/x8b/xa5", "CUNEIFORM SIGN SUD2");
+-   ("/xf0/x92/x8b/xa6", "CUNEIFORM SIGN SUHUR");
+-   ("/xf0/x92/x8b/xa7", "CUNEIFORM SIGN SUM");
+-   ("/xf0/x92/x8b/xa8", "CUNEIFORM SIGN SUMASH");
+-   ("/xf0/x92/x8b/xa9", "CUNEIFORM SIGN SUR");
+-   ("/xf0/x92/x8b/xaa", "CUNEIFORM SIGN SUR9");
+-   ("/xf0/x92/x8b/xab", "CUNEIFORM SIGN TA");
+-   ("/xf0/x92/x8b/xac", "CUNEIFORM SIGN TA ASTERISK");
+-   ("/xf0/x92/x8b/xad", "CUNEIFORM SIGN TA TIMES HI");
+-   ("/xf0/x92/x8b/xae", "CUNEIFORM SIGN TA TIMES MI");
+-   ("/xf0/x92/x8b/xaf", "CUNEIFORM SIGN TA GUNU");
+-   ("/xf0/x92/x8b/xb0", "CUNEIFORM SIGN TAB");
+-   ("/xf0/x92/x8b/xb1", "CUNEIFORM SIGN TAB OVER TAB NI OVER NI DISH OVER DISH");
+-   ("/xf0/x92/x8b/xb2", "CUNEIFORM SIGN TAB SQUARED");
+-   ("/xf0/x92/x8b/xb3", "CUNEIFORM SIGN TAG");
+-   ("/xf0/x92/x8b/xb4", "CUNEIFORM SIGN TAG TIMES BI");
+-   ("/xf0/x92/x8b/xb5", "CUNEIFORM SIGN TAG TIMES GUD");
+-   ("/xf0/x92/x8b/xb6", "CUNEIFORM SIGN TAG TIMES SHE");
+-   ("/xf0/x92/x8b/xb7", "CUNEIFORM SIGN TAG TIMES SHU");
+-   ("/xf0/x92/x8b/xb8", "CUNEIFORM SIGN TAG TIMES TUG2");
+-   ("/xf0/x92/x8b/xb9", "CUNEIFORM SIGN TAG TIMES UD");
+-   ("/xf0/x92/x8b/xba", "CUNEIFORM SIGN TAK4");
+-   ("/xf0/x92/x8b/xbb", "CUNEIFORM SIGN TAR");
+-   ("/xf0/x92/x8b/xbc", "CUNEIFORM SIGN TE");
+-   ("/xf0/x92/x8b/xbd", "CUNEIFORM SIGN TE GUNU");
+-   ("/xf0/x92/x8b/xbe", "CUNEIFORM SIGN TI");
+-   ("/xf0/x92/x8b/xbf", "CUNEIFORM SIGN TI TENU");
+-   ("/xf0/x92/x8c/x80", "CUNEIFORM SIGN TIL");
+-   ("/xf0/x92/x8c/x81", "CUNEIFORM SIGN TIR");
+-   ("/xf0/x92/x8c/x82", "CUNEIFORM SIGN TIR TIMES TAK4");
+-   ("/xf0/x92/x8c/x83", "CUNEIFORM SIGN TIR OVER TIR");
+-   ("/xf0/x92/x8c/x84", "CUNEIFORM SIGN TIR OVER TIR GAD OVER GAD GAR OVER GAR");
+-   ("/xf0/x92/x8c/x85", "CUNEIFORM SIGN TU");
+-   ("/xf0/x92/x8c/x86", "CUNEIFORM SIGN TUG2");
+-   ("/xf0/x92/x8c/x87", "CUNEIFORM SIGN TUK");
+-   ("/xf0/x92/x8c/x88", "CUNEIFORM SIGN TUM");
+-   ("/xf0/x92/x8c/x89", "CUNEIFORM SIGN TUR");
+-   ("/xf0/x92/x8c/x8a", "CUNEIFORM SIGN TUR OVER TUR ZA OVER ZA");
+-   ("/xf0/x92/x8c/x8b", "CUNEIFORM SIGN U");
+-   ("/xf0/x92/x8c/x8c", "CUNEIFORM SIGN U GUD");
+-   ("/xf0/x92/x8c/x8d", "CUNEIFORM SIGN U U U");
+-   ("/xf0/x92/x8c/x8e", "CUNEIFORM SIGN U OVER U PA OVER PA GAR OVER GAR");
+-   ("/xf0/x92/x8c/x8f", "CUNEIFORM SIGN U OVER U SUR OVER SUR");
+-   ("/xf0/x92/x8c/x90", "CUNEIFORM SIGN U OVER U U REVERSED OVER U REVERSED");
+-   ("/xf0/x92/x8c/x91", "CUNEIFORM SIGN U2");
+-   ("/xf0/x92/x8c/x92", "CUNEIFORM SIGN UB");
+-   ("/xf0/x92/x8c/x93", "CUNEIFORM SIGN UD");
+-   ("/xf0/x92/x8c/x94", "CUNEIFORM SIGN UD KUSHU2");
+-   ("/xf0/x92/x8c/x95", "CUNEIFORM SIGN UD TIMES BAD");
+-   ("/xf0/x92/x8c/x96", "CUNEIFORM SIGN UD TIMES MI");
+-   ("/xf0/x92/x8c/x97", "CUNEIFORM SIGN UD TIMES U PLUS U PLUS U");
+-   ("/xf0/x92/x8c/x98", "CUNEIFORM SIGN UD TIMES U PLUS U PLUS U GUNU");
+-   ("/xf0/x92/x8c/x99", "CUNEIFORM SIGN UD GUNU");
+-   ("/xf0/x92/x8c/x9a", "CUNEIFORM SIGN UD SHESHIG");
+-   ("/xf0/x92/x8c/x9b", "CUNEIFORM SIGN UD SHESHIG TIMES BAD");
+-   ("/xf0/x92/x8c/x9c", "CUNEIFORM SIGN UDUG");
+-   ("/xf0/x92/x8c/x9d", "CUNEIFORM SIGN UM");
+-   ("/xf0/x92/x8c/x9e", "CUNEIFORM SIGN UM TIMES LAGAB");
+-   ("/xf0/x92/x8c/x9f", "CUNEIFORM SIGN UM TIMES ME PLUS DA");
+-   ("/xf0/x92/x8c/xa0", "CUNEIFORM SIGN UM TIMES SHA3");
+-   ("/xf0/x92/x8c/xa1", "CUNEIFORM SIGN UM TIMES U");
+-   ("/xf0/x92/x8c/xa2", "CUNEIFORM SIGN UMBIN");
+-   ("/xf0/x92/x8c/xa3", "CUNEIFORM SIGN UMUM");
+-   ("/xf0/x92/x8c/xa4", "CUNEIFORM SIGN UMUM TIMES KASKAL");
+-   ("/xf0/x92/x8c/xa5", "CUNEIFORM SIGN UMUM TIMES PA");
+-   ("/xf0/x92/x8c/xa6", "CUNEIFORM SIGN UN");
+-   ("/xf0/x92/x8c/xa7", "CUNEIFORM SIGN UN GUNU");
+-   ("/xf0/x92/x8c/xa8", "CUNEIFORM SIGN UR");
+-   ("/xf0/x92/x8c/xa9", "CUNEIFORM SIGN UR CROSSING UR");
+-   ("/xf0/x92/x8c/xaa", "CUNEIFORM SIGN UR SHESHIG");
+-   ("/xf0/x92/x8c/xab", "CUNEIFORM SIGN UR2");
+-   ("/xf0/x92/x8c/xac", "CUNEIFORM SIGN UR2 TIMES A PLUS HA");
+-   ("/xf0/x92/x8c/xad", "CUNEIFORM SIGN UR2 TIMES A PLUS NA");
+-   ("/xf0/x92/x8c/xae", "CUNEIFORM SIGN UR2 TIMES AL");
+-   ("/xf0/x92/x8c/xaf", "CUNEIFORM SIGN UR2 TIMES HA");
+-   ("/xf0/x92/x8c/xb0", "CUNEIFORM SIGN UR2 TIMES NUN");
+-   ("/xf0/x92/x8c/xb1", "CUNEIFORM SIGN UR2 TIMES U2");
+-   ("/xf0/x92/x8c/xb2", "CUNEIFORM SIGN UR2 TIMES U2 PLUS ASH");
+-   ("/xf0/x92/x8c/xb3", "CUNEIFORM SIGN UR2 TIMES U2 PLUS BI");
+-   ("/xf0/x92/x8c/xb4", "CUNEIFORM SIGN UR4");
+-   ("/xf0/x92/x8c/xb5", "CUNEIFORM SIGN URI");
+-   ("/xf0/x92/x8c/xb6", "CUNEIFORM SIGN URI3");
+-   ("/xf0/x92/x8c/xb7", "CUNEIFORM SIGN URU");
+-   ("/xf0/x92/x8c/xb8", "CUNEIFORM SIGN URU TIMES A");
+-   ("/xf0/x92/x8c/xb9", "CUNEIFORM SIGN URU TIMES ASHGAB");
+-   ("/xf0/x92/x8c/xba", "CUNEIFORM SIGN URU TIMES BAR");
+-   ("/xf0/x92/x8c/xbb", "CUNEIFORM SIGN URU TIMES DUN");
+-   ("/xf0/x92/x8c/xbc", "CUNEIFORM SIGN URU TIMES GA");
+-   ("/xf0/x92/x8c/xbd", "CUNEIFORM SIGN URU TIMES GAL");
+-   ("/xf0/x92/x8c/xbe", "CUNEIFORM SIGN URU TIMES GAN2 TENU");
+-   ("/xf0/x92/x8c/xbf", "CUNEIFORM SIGN URU TIMES GAR");
+-   ("/xf0/x92/x8d/x80", "CUNEIFORM SIGN URU TIMES GU");
+-   ("/xf0/x92/x8d/x81", "CUNEIFORM SIGN URU TIMES HA");
+-   ("/xf0/x92/x8d/x82", "CUNEIFORM SIGN URU TIMES IGI");
+-   ("/xf0/x92/x8d/x83", "CUNEIFORM SIGN URU TIMES IM");
+-   ("/xf0/x92/x8d/x84", "CUNEIFORM SIGN URU TIMES ISH");
+-   ("/xf0/x92/x8d/x85", "CUNEIFORM SIGN URU TIMES KI");
+-   ("/xf0/x92/x8d/x86", "CUNEIFORM SIGN URU TIMES LUM");
+-   ("/xf0/x92/x8d/x87", "CUNEIFORM SIGN URU TIMES MIN");
+-   ("/xf0/x92/x8d/x88", "CUNEIFORM SIGN URU TIMES PA");
+-   ("/xf0/x92/x8d/x89", "CUNEIFORM SIGN URU TIMES SHE");
+-   ("/xf0/x92/x8d/x8a", "CUNEIFORM SIGN URU TIMES SIG4");
+-   ("/xf0/x92/x8d/x8b", "CUNEIFORM SIGN URU TIMES TU");
+-   ("/xf0/x92/x8d/x8c", "CUNEIFORM SIGN URU TIMES U PLUS GUD");
+-   ("/xf0/x92/x8d/x8d", "CUNEIFORM SIGN URU TIMES UD");
+-   ("/xf0/x92/x8d/x8e", "CUNEIFORM SIGN URU TIMES URUDA");
+-   ("/xf0/x92/x8d/x8f", "CUNEIFORM SIGN URUDA");
+-   ("/xf0/x92/x8d/x90", "CUNEIFORM SIGN URUDA TIMES U");
+-   ("/xf0/x92/x8d/x91", "CUNEIFORM SIGN USH");
+-   ("/xf0/x92/x8d/x92", "CUNEIFORM SIGN USH TIMES A");
+-   ("/xf0/x92/x8d/x93", "CUNEIFORM SIGN USH TIMES KU");
+-   ("/xf0/x92/x8d/x94", "CUNEIFORM SIGN USH TIMES KUR");
+-   ("/xf0/x92/x8d/x95", "CUNEIFORM SIGN USH TIMES TAK4");
+-   ("/xf0/x92/x8d/x96", "CUNEIFORM SIGN USHX");
+-   ("/xf0/x92/x8d/x97", "CUNEIFORM SIGN USH2");
+-   ("/xf0/x92/x8d/x98", "CUNEIFORM SIGN USHUMX");
+-   ("/xf0/x92/x8d/x99", "CUNEIFORM SIGN UTUKI");
+-   ("/xf0/x92/x8d/x9a", "CUNEIFORM SIGN UZ3");
+-   ("/xf0/x92/x8d/x9b", "CUNEIFORM SIGN UZ3 TIMES KASKAL");
+-   ("/xf0/x92/x8d/x9c", "CUNEIFORM SIGN UZU");
+-   ("/xf0/x92/x8d/x9d", "CUNEIFORM SIGN ZA");
+-   ("/xf0/x92/x8d/x9e", "CUNEIFORM SIGN ZA TENU");
+-   ("/xf0/x92/x8d/x9f", "CUNEIFORM SIGN ZA SQUARED TIMES KUR");
+-   ("/xf0/x92/x8d/xa0", "CUNEIFORM SIGN ZAG");
+-   ("/xf0/x92/x8d/xa1", "CUNEIFORM SIGN ZAMX");
+-   ("/xf0/x92/x8d/xa2", "CUNEIFORM SIGN ZE2");
+-   ("/xf0/x92/x8d/xa3", "CUNEIFORM SIGN ZI");
+-   ("/xf0/x92/x8d/xa4", "CUNEIFORM SIGN ZI OVER ZI");
+-   ("/xf0/x92/x8d/xa5", "CUNEIFORM SIGN ZI3");
+-   ("/xf0/x92/x8d/xa6", "CUNEIFORM SIGN ZIB");
+-   ("/xf0/x92/x8d/xa7", "CUNEIFORM SIGN ZIB KABA TENU");
+-   ("/xf0/x92/x8d/xa8", "CUNEIFORM SIGN ZIG");
+-   ("/xf0/x92/x8d/xa9", "CUNEIFORM SIGN ZIZ2");
+-   ("/xf0/x92/x8d/xaa", "CUNEIFORM SIGN ZU");
+-   ("/xf0/x92/x8d/xab", "CUNEIFORM SIGN ZU5");
+-   ("/xf0/x92/x8d/xac", "CUNEIFORM SIGN ZU5 TIMES A");
+-   ("/xf0/x92/x8d/xad", "CUNEIFORM SIGN ZUBUR");
+-   ("/xf0/x92/x8d/xae", "CUNEIFORM SIGN ZUM");
+-   ("/xf0/x92/x90/x80", "CUNEIFORM NUMERIC SIGN TWO ASH");
+-   ("/xf0/x92/x90/x81", "CUNEIFORM NUMERIC SIGN THREE ASH");
+-   ("/xf0/x92/x90/x82", "CUNEIFORM NUMERIC SIGN FOUR ASH");
+-   ("/xf0/x92/x90/x83", "CUNEIFORM NUMERIC SIGN FIVE ASH");
+-   ("/xf0/x92/x90/x84", "CUNEIFORM NUMERIC SIGN SIX ASH");
+-   ("/xf0/x92/x90/x85", "CUNEIFORM NUMERIC SIGN SEVEN ASH");
+-   ("/xf0/x92/x90/x86", "CUNEIFORM NUMERIC SIGN EIGHT ASH");
+-   ("/xf0/x92/x90/x87", "CUNEIFORM NUMERIC SIGN NINE ASH");
+-   ("/xf0/x92/x90/x88", "CUNEIFORM NUMERIC SIGN THREE DISH");
+-   ("/xf0/x92/x90/x89", "CUNEIFORM NUMERIC SIGN FOUR DISH");
+-   ("/xf0/x92/x90/x8a", "CUNEIFORM NUMERIC SIGN FIVE DISH");
+-   ("/xf0/x92/x90/x8b", "CUNEIFORM NUMERIC SIGN SIX DISH");
+-   ("/xf0/x92/x90/x8c", "CUNEIFORM NUMERIC SIGN SEVEN DISH");
+-   ("/xf0/x92/x90/x8d", "CUNEIFORM NUMERIC SIGN EIGHT DISH");
+-   ("/xf0/x92/x90/x8e", "CUNEIFORM NUMERIC SIGN NINE DISH");
+-   ("/xf0/x92/x90/x8f", "CUNEIFORM NUMERIC SIGN FOUR U");
+-   ("/xf0/x92/x90/x90", "CUNEIFORM NUMERIC SIGN FIVE U");
+-   ("/xf0/x92/x90/x91", "CUNEIFORM NUMERIC SIGN SIX U");
+-   ("/xf0/x92/x90/x92", "CUNEIFORM NUMERIC SIGN SEVEN U");
+-   ("/xf0/x92/x90/x93", "CUNEIFORM NUMERIC SIGN EIGHT U");
+-   ("/xf0/x92/x90/x94", "CUNEIFORM NUMERIC SIGN NINE U");
+-   ("/xf0/x92/x90/x95", "CUNEIFORM NUMERIC SIGN ONE GESH2");
+-   ("/xf0/x92/x90/x96", "CUNEIFORM NUMERIC SIGN TWO GESH2");
+-   ("/xf0/x92/x90/x97", "CUNEIFORM NUMERIC SIGN THREE GESH2");
+-   ("/xf0/x92/x90/x98", "CUNEIFORM NUMERIC SIGN FOUR GESH2");
+-   ("/xf0/x92/x90/x99", "CUNEIFORM NUMERIC SIGN FIVE GESH2");
+-   ("/xf0/x92/x90/x9a", "CUNEIFORM NUMERIC SIGN SIX GESH2");
+-   ("/xf0/x92/x90/x9b", "CUNEIFORM NUMERIC SIGN SEVEN GESH2");
+-   ("/xf0/x92/x90/x9c", "CUNEIFORM NUMERIC SIGN EIGHT GESH2");
+-   ("/xf0/x92/x90/x9d", "CUNEIFORM NUMERIC SIGN NINE GESH2");
+-   ("/xf0/x92/x90/x9e", "CUNEIFORM NUMERIC SIGN ONE GESHU");
+-   ("/xf0/x92/x90/x9f", "CUNEIFORM NUMERIC SIGN TWO GESHU");
+-   ("/xf0/x92/x90/xa0", "CUNEIFORM NUMERIC SIGN THREE GESHU");
+-   ("/xf0/x92/x90/xa1", "CUNEIFORM NUMERIC SIGN FOUR GESHU");
+-   ("/xf0/x92/x90/xa2", "CUNEIFORM NUMERIC SIGN FIVE GESHU");
+-   ("/xf0/x92/x90/xa3", "CUNEIFORM NUMERIC SIGN TWO SHAR2");
+-   ("/xf0/x92/x90/xa4", "CUNEIFORM NUMERIC SIGN THREE SHAR2");
+-   ("/xf0/x92/x90/xa5", "CUNEIFORM NUMERIC SIGN THREE SHAR2 VARIANT FORM");
+-   ("/xf0/x92/x90/xa6", "CUNEIFORM NUMERIC SIGN FOUR SHAR2");
+-   ("/xf0/x92/x90/xa7", "CUNEIFORM NUMERIC SIGN FIVE SHAR2");
+-   ("/xf0/x92/x90/xa8", "CUNEIFORM NUMERIC SIGN SIX SHAR2");
+-   ("/xf0/x92/x90/xa9", "CUNEIFORM NUMERIC SIGN SEVEN SHAR2");
+-   ("/xf0/x92/x90/xaa", "CUNEIFORM NUMERIC SIGN EIGHT SHAR2");
+-   ("/xf0/x92/x90/xab", "CUNEIFORM NUMERIC SIGN NINE SHAR2");
+-   ("/xf0/x92/x90/xac", "CUNEIFORM NUMERIC SIGN ONE SHARU");
+-   ("/xf0/x92/x90/xad", "CUNEIFORM NUMERIC SIGN TWO SHARU");
+-   ("/xf0/x92/x90/xae", "CUNEIFORM NUMERIC SIGN THREE SHARU");
+-   ("/xf0/x92/x90/xaf", "CUNEIFORM NUMERIC SIGN THREE SHARU VARIANT FORM");
+-   ("/xf0/x92/x90/xb0", "CUNEIFORM NUMERIC SIGN FOUR SHARU");
+-   ("/xf0/x92/x90/xb1", "CUNEIFORM NUMERIC SIGN FIVE SHARU");
+-   ("/xf0/x92/x90/xb2", "CUNEIFORM NUMERIC SIGN SHAR2 TIMES GAL PLUS DISH");
+-   ("/xf0/x92/x90/xb3", "CUNEIFORM NUMERIC SIGN SHAR2 TIMES GAL PLUS MIN");
+-   ("/xf0/x92/x90/xb4", "CUNEIFORM NUMERIC SIGN ONE BURU");
+-   ("/xf0/x92/x90/xb5", "CUNEIFORM NUMERIC SIGN TWO BURU");
+-   ("/xf0/x92/x90/xb6", "CUNEIFORM NUMERIC SIGN THREE BURU");
+-   ("/xf0/x92/x90/xb7", "CUNEIFORM NUMERIC SIGN THREE BURU VARIANT FORM");
+-   ("/xf0/x92/x90/xb8", "CUNEIFORM NUMERIC SIGN FOUR BURU");
+-   ("/xf0/x92/x90/xb9", "CUNEIFORM NUMERIC SIGN FIVE BURU");
+-   ("/xf0/x92/x90/xba", "CUNEIFORM NUMERIC SIGN THREE VARIANT FORM ESH16");
+-   ("/xf0/x92/x90/xbb", "CUNEIFORM NUMERIC SIGN THREE VARIANT FORM ESH21");
+-   ("/xf0/x92/x90/xbc", "CUNEIFORM NUMERIC SIGN FOUR VARIANT FORM LIMMU");
+-   ("/xf0/x92/x90/xbd", "CUNEIFORM NUMERIC SIGN FOUR VARIANT FORM LIMMU4");
+-   ("/xf0/x92/x90/xbe", "CUNEIFORM NUMERIC SIGN FOUR VARIANT FORM LIMMU A");
+-   ("/xf0/x92/x90/xbf", "CUNEIFORM NUMERIC SIGN FOUR VARIANT FORM LIMMU B");
+-   ("/xf0/x92/x91/x80", "CUNEIFORM NUMERIC SIGN SIX VARIANT FORM ASH9");
+-   ("/xf0/x92/x91/x81", "CUNEIFORM NUMERIC SIGN SEVEN VARIANT FORM IMIN3");
+-   ("/xf0/x92/x91/x82", "CUNEIFORM NUMERIC SIGN SEVEN VARIANT FORM IMIN A");
+-   ("/xf0/x92/x91/x83", "CUNEIFORM NUMERIC SIGN SEVEN VARIANT FORM IMIN B");
+-   ("/xf0/x92/x91/x84", "CUNEIFORM NUMERIC SIGN EIGHT VARIANT FORM USSU");
+-   ("/xf0/x92/x91/x85", "CUNEIFORM NUMERIC SIGN EIGHT VARIANT FORM USSU3");
+-   ("/xf0/x92/x91/x86", "CUNEIFORM NUMERIC SIGN NINE VARIANT FORM ILIMMU");
+-   ("/xf0/x92/x91/x87", "CUNEIFORM NUMERIC SIGN NINE VARIANT FORM ILIMMU3");
+-   ("/xf0/x92/x91/x88", "CUNEIFORM NUMERIC SIGN NINE VARIANT FORM ILIMMU4");
+-   ("/xf0/x92/x91/x89", "CUNEIFORM NUMERIC SIGN NINE VARIANT FORM ILIMMU A");
+-   ("/xf0/x92/x91/x8a", "CUNEIFORM NUMERIC SIGN TWO ASH TENU");
+-   ("/xf0/x92/x91/x8b", "CUNEIFORM NUMERIC SIGN THREE ASH TENU");
+-   ("/xf0/x92/x91/x8c", "CUNEIFORM NUMERIC SIGN FOUR ASH TENU");
+-   ("/xf0/x92/x91/x8d", "CUNEIFORM NUMERIC SIGN FIVE ASH TENU");
+-   ("/xf0/x92/x91/x8e", "CUNEIFORM NUMERIC SIGN SIX ASH TENU");
+-   ("/xf0/x92/x91/x8f", "CUNEIFORM NUMERIC SIGN ONE BAN2");
+-   ("/xf0/x92/x91/x90", "CUNEIFORM NUMERIC SIGN TWO BAN2");
+-   ("/xf0/x92/x91/x91", "CUNEIFORM NUMERIC SIGN THREE BAN2");
+-   ("/xf0/x92/x91/x92", "CUNEIFORM NUMERIC SIGN FOUR BAN2");
+-   ("/xf0/x92/x91/x93", "CUNEIFORM NUMERIC SIGN FOUR BAN2 VARIANT FORM");
+-   ("/xf0/x92/x91/x94", "CUNEIFORM NUMERIC SIGN FIVE BAN2");
+-   ("/xf0/x92/x91/x95", "CUNEIFORM NUMERIC SIGN FIVE BAN2 VARIANT FORM");
+-   ("/xf0/x92/x91/x96", "CUNEIFORM NUMERIC SIGN NIGIDAMIN");
+-   ("/xf0/x92/x91/x97", "CUNEIFORM NUMERIC SIGN NIGIDAESH");
+-   ("/xf0/x92/x91/x98", "CUNEIFORM NUMERIC SIGN ONE ESHE3");
+-   ("/xf0/x92/x91/x99", "CUNEIFORM NUMERIC SIGN TWO ESHE3");
+-   ("/xf0/x92/x91/x9a", "CUNEIFORM NUMERIC SIGN ONE THIRD DISH");
+-   ("/xf0/x92/x91/x9b", "CUNEIFORM NUMERIC SIGN TWO THIRDS DISH");
+-   ("/xf0/x92/x91/x9c", "CUNEIFORM NUMERIC SIGN FIVE SIXTHS DISH");
+-   ("/xf0/x92/x91/x9d", "CUNEIFORM NUMERIC SIGN ONE THIRD VARIANT FORM A");
+-   ("/xf0/x92/x91/x9e", "CUNEIFORM NUMERIC SIGN TWO THIRDS VARIANT FORM A");
+-   ("/xf0/x92/x91/x9f", "CUNEIFORM NUMERIC SIGN ONE EIGHTH ASH");
+-   ("/xf0/x92/x91/xa0", "CUNEIFORM NUMERIC SIGN ONE QUARTER ASH");
+-   ("/xf0/x92/x91/xa1", "CUNEIFORM NUMERIC SIGN OLD ASSYRIAN ONE SIXTH");
+-   ("/xf0/x92/x91/xa2", "CUNEIFORM NUMERIC SIGN OLD ASSYRIAN ONE QUARTER");
+-   ("/xf0/x92/x91/xb0", "CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER");
+-   ("/xf0/x92/x91/xb1", "CUNEIFORM PUNCTUATION SIGN VERTICAL COLON");
+-   ("/xf0/x92/x91/xb2", "CUNEIFORM PUNCTUATION SIGN DIAGONAL COLON");
+-   ("/xf0/x92/x91/xb3", "CUNEIFORM PUNCTUATION SIGN DIAGONAL TRICOLON");
+-   ("/xf0/x9d/x80/x80", "BYZANTINE MUSICAL SYMBOL PSILI");
+-   ("/xf0/x9d/x80/x81", "BYZANTINE MUSICAL SYMBOL DASEIA");
+-   ("/xf0/x9d/x80/x82", "BYZANTINE MUSICAL SYMBOL PERISPOMENI");
+-   ("/xf0/x9d/x80/x83", "BYZANTINE MUSICAL SYMBOL OXEIA EKFONITIKON");
+-   ("/xf0/x9d/x80/x84", "BYZANTINE MUSICAL SYMBOL OXEIA DIPLI");
+-   ("/xf0/x9d/x80/x85", "BYZANTINE MUSICAL SYMBOL VAREIA EKFONITIKON");
+-   ("/xf0/x9d/x80/x86", "BYZANTINE MUSICAL SYMBOL VAREIA DIPLI");
+-   ("/xf0/x9d/x80/x87", "BYZANTINE MUSICAL SYMBOL KATHISTI");
+-   ("/xf0/x9d/x80/x88", "BYZANTINE MUSICAL SYMBOL SYRMATIKI");
+-   ("/xf0/x9d/x80/x89", "BYZANTINE MUSICAL SYMBOL PARAKLITIKI");
+-   ("/xf0/x9d/x80/x8a", "BYZANTINE MUSICAL SYMBOL YPOKRISIS");
+-   ("/xf0/x9d/x80/x8b", "BYZANTINE MUSICAL SYMBOL YPOKRISIS DIPLI");
+-   ("/xf0/x9d/x80/x8c", "BYZANTINE MUSICAL SYMBOL KREMASTI");
+-   ("/xf0/x9d/x80/x8d", "BYZANTINE MUSICAL SYMBOL APESO EKFONITIKON");
+-   ("/xf0/x9d/x80/x8e", "BYZANTINE MUSICAL SYMBOL EXO EKFONITIKON");
+-   ("/xf0/x9d/x80/x8f", "BYZANTINE MUSICAL SYMBOL TELEIA");
+-   ("/xf0/x9d/x80/x90", "BYZANTINE MUSICAL SYMBOL KENTIMATA");
+-   ("/xf0/x9d/x80/x91", "BYZANTINE MUSICAL SYMBOL APOSTROFOS");
+-   ("/xf0/x9d/x80/x92", "BYZANTINE MUSICAL SYMBOL APOSTROFOS DIPLI");
+-   ("/xf0/x9d/x80/x93", "BYZANTINE MUSICAL SYMBOL SYNEVMA");
+-   ("/xf0/x9d/x80/x94", "BYZANTINE MUSICAL SYMBOL THITA");
+-   ("/xf0/x9d/x80/x95", "BYZANTINE MUSICAL SYMBOL OLIGON ARCHAION");
+-   ("/xf0/x9d/x80/x96", "BYZANTINE MUSICAL SYMBOL GORGON ARCHAION");
+-   ("/xf0/x9d/x80/x97", "BYZANTINE MUSICAL SYMBOL PSILON");
+-   ("/xf0/x9d/x80/x98", "BYZANTINE MUSICAL SYMBOL CHAMILON");
+-   ("/xf0/x9d/x80/x99", "BYZANTINE MUSICAL SYMBOL VATHY");
+-   ("/xf0/x9d/x80/x9a", "BYZANTINE MUSICAL SYMBOL ISON ARCHAION");
+-   ("/xf0/x9d/x80/x9b", "BYZANTINE MUSICAL SYMBOL KENTIMA ARCHAION");
+-   ("/xf0/x9d/x80/x9c", "BYZANTINE MUSICAL SYMBOL KENTIMATA ARCHAION");
+-   ("/xf0/x9d/x80/x9d", "BYZANTINE MUSICAL SYMBOL SAXIMATA");
+-   ("/xf0/x9d/x80/x9e", "BYZANTINE MUSICAL SYMBOL PARICHON");
+-   ("/xf0/x9d/x80/x9f", "BYZANTINE MUSICAL SYMBOL STAVROS APODEXIA");
+-   ("/xf0/x9d/x80/xa0", "BYZANTINE MUSICAL SYMBOL OXEIAI ARCHAION");
+-   ("/xf0/x9d/x80/xa1", "BYZANTINE MUSICAL SYMBOL VAREIAI ARCHAION");
+-   ("/xf0/x9d/x80/xa2", "BYZANTINE MUSICAL SYMBOL APODERMA ARCHAION");
+-   ("/xf0/x9d/x80/xa3", "BYZANTINE MUSICAL SYMBOL APOTHEMA");
+-   ("/xf0/x9d/x80/xa4", "BYZANTINE MUSICAL SYMBOL KLASMA");
+-   ("/xf0/x9d/x80/xa5", "BYZANTINE MUSICAL SYMBOL REVMA");
+-   ("/xf0/x9d/x80/xa6", "BYZANTINE MUSICAL SYMBOL PIASMA ARCHAION");
+-   ("/xf0/x9d/x80/xa7", "BYZANTINE MUSICAL SYMBOL TINAGMA");
+-   ("/xf0/x9d/x80/xa8", "BYZANTINE MUSICAL SYMBOL ANATRICHISMA");
+-   ("/xf0/x9d/x80/xa9", "BYZANTINE MUSICAL SYMBOL SEISMA");
+-   ("/xf0/x9d/x80/xaa", "BYZANTINE MUSICAL SYMBOL SYNAGMA ARCHAION");
+-   ("/xf0/x9d/x80/xab", "BYZANTINE MUSICAL SYMBOL SYNAGMA META STAVROU");
+-   ("/xf0/x9d/x80/xac", "BYZANTINE MUSICAL SYMBOL OYRANISMA ARCHAION");
+-   ("/xf0/x9d/x80/xad", "BYZANTINE MUSICAL SYMBOL THEMA");
+-   ("/xf0/x9d/x80/xae", "BYZANTINE MUSICAL SYMBOL LEMOI");
+-   ("/xf0/x9d/x80/xaf", "BYZANTINE MUSICAL SYMBOL DYO");
+-   ("/xf0/x9d/x80/xb0", "BYZANTINE MUSICAL SYMBOL TRIA");
+-   ("/xf0/x9d/x80/xb1", "BYZANTINE MUSICAL SYMBOL TESSERA");
+-   ("/xf0/x9d/x80/xb2", "BYZANTINE MUSICAL SYMBOL KRATIMATA");
+-   ("/xf0/x9d/x80/xb3", "BYZANTINE MUSICAL SYMBOL APESO EXO NEO");
+-   ("/xf0/x9d/x80/xb4", "BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION");
+-   ("/xf0/x9d/x80/xb5", "BYZANTINE MUSICAL SYMBOL IMIFTHORA");
+-   ("/xf0/x9d/x80/xb6", "BYZANTINE MUSICAL SYMBOL TROMIKON ARCHAION");
+-   ("/xf0/x9d/x80/xb7", "BYZANTINE MUSICAL SYMBOL KATAVA TROMIKON");
+-   ("/xf0/x9d/x80/xb8", "BYZANTINE MUSICAL SYMBOL PELASTON");
+-   ("/xf0/x9d/x80/xb9", "BYZANTINE MUSICAL SYMBOL PSIFISTON");
+-   ("/xf0/x9d/x80/xba", "BYZANTINE MUSICAL SYMBOL KONTEVMA");
+-   ("/xf0/x9d/x80/xbb", "BYZANTINE MUSICAL SYMBOL CHOREVMA ARCHAION");
+-   ("/xf0/x9d/x80/xbc", "BYZANTINE MUSICAL SYMBOL RAPISMA");
+-   ("/xf0/x9d/x80/xbd", "BYZANTINE MUSICAL SYMBOL PARAKALESMA ARCHAION");
+-   ("/xf0/x9d/x80/xbe", "BYZANTINE MUSICAL SYMBOL PARAKLITIKI ARCHAION");
+-   ("/xf0/x9d/x80/xbf", "BYZANTINE MUSICAL SYMBOL ICHADIN");
+-   ("/xf0/x9d/x81/x80", "BYZANTINE MUSICAL SYMBOL NANA");
+-   ("/xf0/x9d/x81/x81", "BYZANTINE MUSICAL SYMBOL PETASMA");
+-   ("/xf0/x9d/x81/x82", "BYZANTINE MUSICAL SYMBOL KONTEVMA ALLO");
+-   ("/xf0/x9d/x81/x83", "BYZANTINE MUSICAL SYMBOL TROMIKON ALLO");
+-   ("/xf0/x9d/x81/x84", "BYZANTINE MUSICAL SYMBOL STRAGGISMATA");
+-   ("/xf0/x9d/x81/x85", "BYZANTINE MUSICAL SYMBOL GRONTHISMATA");
+-   ("/xf0/x9d/x81/x86", "BYZANTINE MUSICAL SYMBOL ISON NEO");
+-   ("/xf0/x9d/x81/x87", "BYZANTINE MUSICAL SYMBOL OLIGON NEO");
+-   ("/xf0/x9d/x81/x88", "BYZANTINE MUSICAL SYMBOL OXEIA NEO");
+-   ("/xf0/x9d/x81/x89", "BYZANTINE MUSICAL SYMBOL PETASTI");
+-   ("/xf0/x9d/x81/x8a", "BYZANTINE MUSICAL SYMBOL KOUFISMA");
+-   ("/xf0/x9d/x81/x8b", "BYZANTINE MUSICAL SYMBOL PETASTOKOUFISMA");
+-   ("/xf0/x9d/x81/x8c", "BYZANTINE MUSICAL SYMBOL KRATIMOKOUFISMA");
+-   ("/xf0/x9d/x81/x8d", "BYZANTINE MUSICAL SYMBOL PELASTON NEO");
+-   ("/xf0/x9d/x81/x8e", "BYZANTINE MUSICAL SYMBOL KENTIMATA NEO ANO");
+-   ("/xf0/x9d/x81/x8f", "BYZANTINE MUSICAL SYMBOL KENTIMA NEO ANO");
+-   ("/xf0/x9d/x81/x90", "BYZANTINE MUSICAL SYMBOL YPSILI");
+-   ("/xf0/x9d/x81/x91", "BYZANTINE MUSICAL SYMBOL APOSTROFOS NEO");
+-   ("/xf0/x9d/x81/x92", "BYZANTINE MUSICAL SYMBOL APOSTROFOI SYNDESMOS NEO");
+-   ("/xf0/x9d/x81/x93", "BYZANTINE MUSICAL SYMBOL YPORROI");
+-   ("/xf0/x9d/x81/x94", "BYZANTINE MUSICAL SYMBOL KRATIMOYPORROON");
+-   ("/xf0/x9d/x81/x95", "BYZANTINE MUSICAL SYMBOL ELAFRON");
+-   ("/xf0/x9d/x81/x96", "BYZANTINE MUSICAL SYMBOL CHAMILI");
+-   ("/xf0/x9d/x81/x97", "BYZANTINE MUSICAL SYMBOL MIKRON ISON");
+-   ("/xf0/x9d/x81/x98", "BYZANTINE MUSICAL SYMBOL VAREIA NEO");
+-   ("/xf0/x9d/x81/x99", "BYZANTINE MUSICAL SYMBOL PIASMA NEO");
+-   ("/xf0/x9d/x81/x9a", "BYZANTINE MUSICAL SYMBOL PSIFISTON NEO");
+-   ("/xf0/x9d/x81/x9b", "BYZANTINE MUSICAL SYMBOL OMALON");
+-   ("/xf0/x9d/x81/x9c", "BYZANTINE MUSICAL SYMBOL ANTIKENOMA");
+-   ("/xf0/x9d/x81/x9d", "BYZANTINE MUSICAL SYMBOL LYGISMA");
+-   ("/xf0/x9d/x81/x9e", "BYZANTINE MUSICAL SYMBOL PARAKLITIKI NEO");
+-   ("/xf0/x9d/x81/x9f", "BYZANTINE MUSICAL SYMBOL PARAKALESMA NEO");
+-   ("/xf0/x9d/x81/xa0", "BYZANTINE MUSICAL SYMBOL ETERON PARAKALESMA");
+-   ("/xf0/x9d/x81/xa1", "BYZANTINE MUSICAL SYMBOL KYLISMA");
+-   ("/xf0/x9d/x81/xa2", "BYZANTINE MUSICAL SYMBOL ANTIKENOKYLISMA");
+-   ("/xf0/x9d/x81/xa3", "BYZANTINE MUSICAL SYMBOL TROMIKON NEO");
+-   ("/xf0/x9d/x81/xa4", "BYZANTINE MUSICAL SYMBOL EKSTREPTON");
+-   ("/xf0/x9d/x81/xa5", "BYZANTINE MUSICAL SYMBOL SYNAGMA NEO");
+-   ("/xf0/x9d/x81/xa6", "BYZANTINE MUSICAL SYMBOL SYRMA");
+-   ("/xf0/x9d/x81/xa7", "BYZANTINE MUSICAL SYMBOL CHOREVMA NEO");
+-   ("/xf0/x9d/x81/xa8", "BYZANTINE MUSICAL SYMBOL EPEGERMA");
+-   ("/xf0/x9d/x81/xa9", "BYZANTINE MUSICAL SYMBOL SEISMA NEO");
+-   ("/xf0/x9d/x81/xaa", "BYZANTINE MUSICAL SYMBOL XIRON KLASMA");
+-   ("/xf0/x9d/x81/xab", "BYZANTINE MUSICAL SYMBOL TROMIKOPSIFISTON");
+-   ("/xf0/x9d/x81/xac", "BYZANTINE MUSICAL SYMBOL PSIFISTOLYGISMA");
+-   ("/xf0/x9d/x81/xad", "BYZANTINE MUSICAL SYMBOL TROMIKOLYGISMA");
+-   ("/xf0/x9d/x81/xae", "BYZANTINE MUSICAL SYMBOL TROMIKOPARAKALESMA");
+-   ("/xf0/x9d/x81/xaf", "BYZANTINE MUSICAL SYMBOL PSIFISTOPARAKALESMA");
+-   ("/xf0/x9d/x81/xb0", "BYZANTINE MUSICAL SYMBOL TROMIKOSYNAGMA");
+-   ("/xf0/x9d/x81/xb1", "BYZANTINE MUSICAL SYMBOL PSIFISTOSYNAGMA");
+-   ("/xf0/x9d/x81/xb2", "BYZANTINE MUSICAL SYMBOL GORGOSYNTHETON");
+-   ("/xf0/x9d/x81/xb3", "BYZANTINE MUSICAL SYMBOL ARGOSYNTHETON");
+-   ("/xf0/x9d/x81/xb4", "BYZANTINE MUSICAL SYMBOL ETERON ARGOSYNTHETON");
+-   ("/xf0/x9d/x81/xb5", "BYZANTINE MUSICAL SYMBOL OYRANISMA NEO");
+-   ("/xf0/x9d/x81/xb6", "BYZANTINE MUSICAL SYMBOL THEMATISMOS ESO");
+-   ("/xf0/x9d/x81/xb7", "BYZANTINE MUSICAL SYMBOL THEMATISMOS EXO");
+-   ("/xf0/x9d/x81/xb8", "BYZANTINE MUSICAL SYMBOL THEMA APLOUN");
+-   ("/xf0/x9d/x81/xb9", "BYZANTINE MUSICAL SYMBOL THES KAI APOTHES");
+-   ("/xf0/x9d/x81/xba", "BYZANTINE MUSICAL SYMBOL KATAVASMA");
+-   ("/xf0/x9d/x81/xbb", "BYZANTINE MUSICAL SYMBOL ENDOFONON");
+-   ("/xf0/x9d/x81/xbc", "BYZANTINE MUSICAL SYMBOL YFEN KATO");
+-   ("/xf0/x9d/x81/xbd", "BYZANTINE MUSICAL SYMBOL YFEN ANO");
+-   ("/xf0/x9d/x81/xbe", "BYZANTINE MUSICAL SYMBOL STAVROS");
+-   ("/xf0/x9d/x81/xbf", "BYZANTINE MUSICAL SYMBOL KLASMA ANO");
+-   ("/xf0/x9d/x82/x80", "BYZANTINE MUSICAL SYMBOL DIPLI ARCHAION");
+-   ("/xf0/x9d/x82/x81", "BYZANTINE MUSICAL SYMBOL KRATIMA ARCHAION");
+-   ("/xf0/x9d/x82/x82", "BYZANTINE MUSICAL SYMBOL KRATIMA ALLO");
+-   ("/xf0/x9d/x82/x83", "BYZANTINE MUSICAL SYMBOL KRATIMA NEO");
+-   ("/xf0/x9d/x82/x84", "BYZANTINE MUSICAL SYMBOL APODERMA NEO");
+-   ("/xf0/x9d/x82/x85", "BYZANTINE MUSICAL SYMBOL APLI");
+-   ("/xf0/x9d/x82/x86", "BYZANTINE MUSICAL SYMBOL DIPLI");
+-   ("/xf0/x9d/x82/x87", "BYZANTINE MUSICAL SYMBOL TRIPLI");
+-   ("/xf0/x9d/x82/x88", "BYZANTINE MUSICAL SYMBOL TETRAPLI");
+-   ("/xf0/x9d/x82/x89", "BYZANTINE MUSICAL SYMBOL KORONIS");
+-   ("/xf0/x9d/x82/x8a", "BYZANTINE MUSICAL SYMBOL LEIMMA ENOS CHRONOU");
+-   ("/xf0/x9d/x82/x8b", "BYZANTINE MUSICAL SYMBOL LEIMMA DYO CHRONON");
+-   ("/xf0/x9d/x82/x8c", "BYZANTINE MUSICAL SYMBOL LEIMMA TRION CHRONON");
+-   ("/xf0/x9d/x82/x8d", "BYZANTINE MUSICAL SYMBOL LEIMMA TESSARON CHRONON");
+-   ("/xf0/x9d/x82/x8e", "BYZANTINE MUSICAL SYMBOL LEIMMA IMISEOS CHRONOU");
+-   ("/xf0/x9d/x82/x8f", "BYZANTINE MUSICAL SYMBOL GORGON NEO ANO");
+-   ("/xf0/x9d/x82/x90", "BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON ARISTERA");
+-   ("/xf0/x9d/x82/x91", "BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON DEXIA");
+-   ("/xf0/x9d/x82/x92", "BYZANTINE MUSICAL SYMBOL DIGORGON");
+-   ("/xf0/x9d/x82/x93", "BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA KATO");
+-   ("/xf0/x9d/x82/x94", "BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA ANO");
+-   ("/xf0/x9d/x82/x95", "BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON DEXIA");
+-   ("/xf0/x9d/x82/x96", "BYZANTINE MUSICAL SYMBOL TRIGORGON");
+-   ("/xf0/x9d/x82/x97", "BYZANTINE MUSICAL SYMBOL ARGON");
+-   ("/xf0/x9d/x82/x98", "BYZANTINE MUSICAL SYMBOL IMIDIARGON");
+-   ("/xf0/x9d/x82/x99", "BYZANTINE MUSICAL SYMBOL DIARGON");
+-   ("/xf0/x9d/x82/x9a", "BYZANTINE MUSICAL SYMBOL AGOGI POLI ARGI");
+-   ("/xf0/x9d/x82/x9b", "BYZANTINE MUSICAL SYMBOL AGOGI ARGOTERI");
+-   ("/xf0/x9d/x82/x9c", "BYZANTINE MUSICAL SYMBOL AGOGI ARGI");
+-   ("/xf0/x9d/x82/x9d", "BYZANTINE MUSICAL SYMBOL AGOGI METRIA");
+-   ("/xf0/x9d/x82/x9e", "BYZANTINE MUSICAL SYMBOL AGOGI MESI");
+-   ("/xf0/x9d/x82/x9f", "BYZANTINE MUSICAL SYMBOL AGOGI GORGI");
+-   ("/xf0/x9d/x82/xa0", "BYZANTINE MUSICAL SYMBOL AGOGI GORGOTERI");
+-   ("/xf0/x9d/x82/xa1", "BYZANTINE MUSICAL SYMBOL AGOGI POLI GORGI");
+-   ("/xf0/x9d/x82/xa2", "BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOS ICHOS");
+-   ("/xf0/x9d/x82/xa3", "BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI PROTOS ICHOS");
+-   ("/xf0/x9d/x82/xa4", "BYZANTINE MUSICAL SYMBOL MARTYRIA DEYTEROS ICHOS");
+-   ("/xf0/x9d/x82/xa5", "BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI DEYTEROS ICHOS");
+-   ("/xf0/x9d/x82/xa6", "BYZANTINE MUSICAL SYMBOL MARTYRIA TRITOS ICHOS");
+-   ("/xf0/x9d/x82/xa7", "BYZANTINE MUSICAL SYMBOL MARTYRIA TRIFONIAS");
+-   ("/xf0/x9d/x82/xa8", "BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS ICHOS");
+-   ("/xf0/x9d/x82/xa9", "BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS LEGETOS ICHOS");
+-   ("/xf0/x9d/x82/xaa", "BYZANTINE MUSICAL SYMBOL MARTYRIA LEGETOS ICHOS");
+-   ("/xf0/x9d/x82/xab", "BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS ICHOS");
+-   ("/xf0/x9d/x82/xac", "BYZANTINE MUSICAL SYMBOL ISAKIA TELOUS ICHIMATOS");
+-   ("/xf0/x9d/x82/xad", "BYZANTINE MUSICAL SYMBOL APOSTROFOI TELOUS ICHIMATOS");
+-   ("/xf0/x9d/x82/xae", "BYZANTINE MUSICAL SYMBOL FANEROSIS TETRAFONIAS");
+-   ("/xf0/x9d/x82/xaf", "BYZANTINE MUSICAL SYMBOL FANEROSIS MONOFONIAS");
+-   ("/xf0/x9d/x82/xb0", "BYZANTINE MUSICAL SYMBOL FANEROSIS DIFONIAS");
+-   ("/xf0/x9d/x82/xb1", "BYZANTINE MUSICAL SYMBOL MARTYRIA VARYS ICHOS");
+-   ("/xf0/x9d/x82/xb2", "BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOVARYS ICHOS");
+-   ("/xf0/x9d/x82/xb3", "BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS TETARTOS ICHOS");
+-   ("/xf0/x9d/x82/xb4", "BYZANTINE MUSICAL SYMBOL GORTHMIKON N APLOUN");
+-   ("/xf0/x9d/x82/xb5", "BYZANTINE MUSICAL SYMBOL GORTHMIKON N DIPLOUN");
+-   ("/xf0/x9d/x82/xb6", "BYZANTINE MUSICAL SYMBOL ENARXIS KAI FTHORA VOU");
+-   ("/xf0/x9d/x82/xb7", "BYZANTINE MUSICAL SYMBOL IMIFONON");
+-   ("/xf0/x9d/x82/xb8", "BYZANTINE MUSICAL SYMBOL IMIFTHORON");
+-   ("/xf0/x9d/x82/xb9", "BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION DEYTEROU ICHOU");
+-   ("/xf0/x9d/x82/xba", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI PA");
+-   ("/xf0/x9d/x82/xbb", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NANA");
+-   ("/xf0/x9d/x82/xbc", "BYZANTINE MUSICAL SYMBOL FTHORA NAOS ICHOS");
+-   ("/xf0/x9d/x82/xbd", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI DI");
+-   ("/xf0/x9d/x82/xbe", "BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON DIATONON DI");
+-   ("/xf0/x9d/x82/xbf", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI KE");
+-   ("/xf0/x9d/x83/x80", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI ZO");
+-   ("/xf0/x9d/x83/x81", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI KATO");
+-   ("/xf0/x9d/x83/x82", "BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI ANO");
+-   ("/xf0/x9d/x83/x83", "BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA DIFONIAS");
+-   ("/xf0/x9d/x83/x84", "BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA MONOFONIAS");
+-   ("/xf0/x9d/x83/x85", "BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS");
+-   ("/xf0/x9d/x83/x86", "BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA SYNAFI");
+-   ("/xf0/x9d/x83/x87", "BYZANTINE MUSICAL SYMBOL FTHORA NENANO");
+-   ("/xf0/x9d/x83/x88", "BYZANTINE MUSICAL SYMBOL CHROA ZYGOS");
+-   ("/xf0/x9d/x83/x89", "BYZANTINE MUSICAL SYMBOL CHROA KLITON");
+-   ("/xf0/x9d/x83/x8a", "BYZANTINE MUSICAL SYMBOL CHROA SPATHI");
+-   ("/xf0/x9d/x83/x8b", "BYZANTINE MUSICAL SYMBOL FTHORA I YFESIS TETARTIMORION");
+-   ("/xf0/x9d/x83/x8c", "BYZANTINE MUSICAL SYMBOL FTHORA ENARMONIOS ANTIFONIA");
+-   ("/xf0/x9d/x83/x8d", "BYZANTINE MUSICAL SYMBOL YFESIS TRITIMORION");
+-   ("/xf0/x9d/x83/x8e", "BYZANTINE MUSICAL SYMBOL DIESIS TRITIMORION");
+-   ("/xf0/x9d/x83/x8f", "BYZANTINE MUSICAL SYMBOL DIESIS TETARTIMORION");
+-   ("/xf0/x9d/x83/x90", "BYZANTINE MUSICAL SYMBOL DIESIS APLI DYO DODEKATA");
+-   ("/xf0/x9d/x83/x91", "BYZANTINE MUSICAL SYMBOL DIESIS MONOGRAMMOS TESSERA DODEKATA");
+-   ("/xf0/x9d/x83/x92", "BYZANTINE MUSICAL SYMBOL DIESIS DIGRAMMOS EX DODEKATA");
+-   ("/xf0/x9d/x83/x93", "BYZANTINE MUSICAL SYMBOL DIESIS TRIGRAMMOS OKTO DODEKATA");
+-   ("/xf0/x9d/x83/x94", "BYZANTINE MUSICAL SYMBOL YFESIS APLI DYO DODEKATA");
+-   ("/xf0/x9d/x83/x95", "BYZANTINE MUSICAL SYMBOL YFESIS MONOGRAMMOS TESSERA DODEKATA");
+-   ("/xf0/x9d/x83/x96", "BYZANTINE MUSICAL SYMBOL YFESIS DIGRAMMOS EX DODEKATA");
+-   ("/xf0/x9d/x83/x97", "BYZANTINE MUSICAL SYMBOL YFESIS TRIGRAMMOS OKTO DODEKATA");
+-   ("/xf0/x9d/x83/x98", "BYZANTINE MUSICAL SYMBOL GENIKI DIESIS");
+-   ("/xf0/x9d/x83/x99", "BYZANTINE MUSICAL SYMBOL GENIKI YFESIS");
+-   ("/xf0/x9d/x83/x9a", "BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MIKRI");
+-   ("/xf0/x9d/x83/x9b", "BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MEGALI");
+-   ("/xf0/x9d/x83/x9c", "BYZANTINE MUSICAL SYMBOL DIASTOLI DIPLI");
+-   ("/xf0/x9d/x83/x9d", "BYZANTINE MUSICAL SYMBOL DIASTOLI THESEOS");
+-   ("/xf0/x9d/x83/x9e", "BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS");
+-   ("/xf0/x9d/x83/x9f", "BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS DISIMOU");
+-   ("/xf0/x9d/x83/xa0", "BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TRISIMOU");
+-   ("/xf0/x9d/x83/xa1", "BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TETRASIMOU");
+-   ("/xf0/x9d/x83/xa2", "BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS");
+-   ("/xf0/x9d/x83/xa3", "BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS DISIMOU");
+-   ("/xf0/x9d/x83/xa4", "BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TRISIMOU");
+-   ("/xf0/x9d/x83/xa5", "BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TETRASIMOU");
+-   ("/xf0/x9d/x83/xa6", "BYZANTINE MUSICAL SYMBOL DIGRAMMA GG");
+-   ("/xf0/x9d/x83/xa7", "BYZANTINE MUSICAL SYMBOL DIFTOGGOS OU");
+-   ("/xf0/x9d/x83/xa8", "BYZANTINE MUSICAL SYMBOL STIGMA");
+-   ("/xf0/x9d/x83/xa9", "BYZANTINE MUSICAL SYMBOL ARKTIKO PA");
+-   ("/xf0/x9d/x83/xaa", "BYZANTINE MUSICAL SYMBOL ARKTIKO VOU");
+-   ("/xf0/x9d/x83/xab", "BYZANTINE MUSICAL SYMBOL ARKTIKO GA");
+-   ("/xf0/x9d/x83/xac", "BYZANTINE MUSICAL SYMBOL ARKTIKO DI");
+-   ("/xf0/x9d/x83/xad", "BYZANTINE MUSICAL SYMBOL ARKTIKO KE");
+-   ("/xf0/x9d/x83/xae", "BYZANTINE MUSICAL SYMBOL ARKTIKO ZO");
+-   ("/xf0/x9d/x83/xaf", "BYZANTINE MUSICAL SYMBOL ARKTIKO NI");
+-   ("/xf0/x9d/x83/xb0", "BYZANTINE MUSICAL SYMBOL KENTIMATA NEO MESO");
+-   ("/xf0/x9d/x83/xb1", "BYZANTINE MUSICAL SYMBOL KENTIMA NEO MESO");
+-   ("/xf0/x9d/x83/xb2", "BYZANTINE MUSICAL SYMBOL KENTIMATA NEO KATO");
+-   ("/xf0/x9d/x83/xb3", "BYZANTINE MUSICAL SYMBOL KENTIMA NEO KATO");
+-   ("/xf0/x9d/x83/xb4", "BYZANTINE MUSICAL SYMBOL KLASMA KATO");
+-   ("/xf0/x9d/x83/xb5", "BYZANTINE MUSICAL SYMBOL GORGON NEO KATO");
+-   ("/xf0/x9d/x84/x80", "MUSICAL SYMBOL SINGLE BARLINE");
+-   ("/xf0/x9d/x84/x81", "MUSICAL SYMBOL DOUBLE BARLINE");
+-   ("/xf0/x9d/x84/x82", "MUSICAL SYMBOL FINAL BARLINE");
+-   ("/xf0/x9d/x84/x83", "MUSICAL SYMBOL REVERSE FINAL BARLINE");
+-   ("/xf0/x9d/x84/x84", "MUSICAL SYMBOL DASHED BARLINE");
+-   ("/xf0/x9d/x84/x85", "MUSICAL SYMBOL SHORT BARLINE");
+-   ("/xf0/x9d/x84/x86", "MUSICAL SYMBOL LEFT REPEAT SIGN");
+-   ("/xf0/x9d/x84/x87", "MUSICAL SYMBOL RIGHT REPEAT SIGN");
+-   ("/xf0/x9d/x84/x88", "MUSICAL SYMBOL REPEAT DOTS");
+-   ("/xf0/x9d/x84/x89", "MUSICAL SYMBOL DAL SEGNO");
+-   ("/xf0/x9d/x84/x8a", "MUSICAL SYMBOL DA CAPO");
+-   ("/xf0/x9d/x84/x8b", "MUSICAL SYMBOL SEGNO");
+-   ("/xf0/x9d/x84/x8c", "MUSICAL SYMBOL CODA");
+-   ("/xf0/x9d/x84/x8d", "MUSICAL SYMBOL REPEATED FIGURE-1");
+-   ("/xf0/x9d/x84/x8e", "MUSICAL SYMBOL REPEATED FIGURE-2");
+-   ("/xf0/x9d/x84/x8f", "MUSICAL SYMBOL REPEATED FIGURE-3");
+-   ("/xf0/x9d/x84/x90", "MUSICAL SYMBOL FERMATA");
+-   ("/xf0/x9d/x84/x91", "MUSICAL SYMBOL FERMATA BELOW");
+-   ("/xf0/x9d/x84/x92", "MUSICAL SYMBOL BREATH MARK");
+-   ("/xf0/x9d/x84/x93", "MUSICAL SYMBOL CAESURA");
+-   ("/xf0/x9d/x84/x94", "MUSICAL SYMBOL BRACE");
+-   ("/xf0/x9d/x84/x95", "MUSICAL SYMBOL BRACKET");
+-   ("/xf0/x9d/x84/x96", "MUSICAL SYMBOL ONE-LINE STAFF");
+-   ("/xf0/x9d/x84/x97", "MUSICAL SYMBOL TWO-LINE STAFF");
+-   ("/xf0/x9d/x84/x98", "MUSICAL SYMBOL THREE-LINE STAFF");
+-   ("/xf0/x9d/x84/x99", "MUSICAL SYMBOL FOUR-LINE STAFF");
+-   ("/xf0/x9d/x84/x9a", "MUSICAL SYMBOL FIVE-LINE STAFF");
+-   ("/xf0/x9d/x84/x9b", "MUSICAL SYMBOL SIX-LINE STAFF");
+-   ("/xf0/x9d/x84/x9c", "MUSICAL SYMBOL SIX-STRING FRETBOARD");
+-   ("/xf0/x9d/x84/x9d", "MUSICAL SYMBOL FOUR-STRING FRETBOARD");
+-   ("/xf0/x9d/x84/x9e", "MUSICAL SYMBOL G CLEF");
+-   ("/xf0/x9d/x84/x9f", "MUSICAL SYMBOL G CLEF OTTAVA ALTA");
+-   ("/xf0/x9d/x84/xa0", "MUSICAL SYMBOL G CLEF OTTAVA BASSA");
+-   ("/xf0/x9d/x84/xa1", "MUSICAL SYMBOL C CLEF");
+-   ("/xf0/x9d/x84/xa2", "MUSICAL SYMBOL F CLEF");
+-   ("/xf0/x9d/x84/xa3", "MUSICAL SYMBOL F CLEF OTTAVA ALTA");
+-   ("/xf0/x9d/x84/xa4", "MUSICAL SYMBOL F CLEF OTTAVA BASSA");
+-   ("/xf0/x9d/x84/xa5", "MUSICAL SYMBOL DRUM CLEF-1");
+-   ("/xf0/x9d/x84/xa6", "MUSICAL SYMBOL DRUM CLEF-2");
+-   ("/xf0/x9d/x84/xa9", "MUSICAL SYMBOL MULTIPLE MEASURE REST");
+-   ("/xf0/x9d/x84/xaa", "MUSICAL SYMBOL DOUBLE SHARP");
+-   ("/xf0/x9d/x84/xab", "MUSICAL SYMBOL DOUBLE FLAT");
+-   ("/xf0/x9d/x84/xac", "MUSICAL SYMBOL FLAT UP");
+-   ("/xf0/x9d/x84/xad", "MUSICAL SYMBOL FLAT DOWN");
+-   ("/xf0/x9d/x84/xae", "MUSICAL SYMBOL NATURAL UP");
+-   ("/xf0/x9d/x84/xaf", "MUSICAL SYMBOL NATURAL DOWN");
+-   ("/xf0/x9d/x84/xb0", "MUSICAL SYMBOL SHARP UP");
+-   ("/xf0/x9d/x84/xb1", "MUSICAL SYMBOL SHARP DOWN");
+-   ("/xf0/x9d/x84/xb2", "MUSICAL SYMBOL QUARTER TONE SHARP");
+-   ("/xf0/x9d/x84/xb3", "MUSICAL SYMBOL QUARTER TONE FLAT");
+-   ("/xf0/x9d/x84/xb4", "MUSICAL SYMBOL COMMON TIME");
+-   ("/xf0/x9d/x84/xb5", "MUSICAL SYMBOL CUT TIME");
+-   ("/xf0/x9d/x84/xb6", "MUSICAL SYMBOL OTTAVA ALTA");
+-   ("/xf0/x9d/x84/xb7", "MUSICAL SYMBOL OTTAVA BASSA");
+-   ("/xf0/x9d/x84/xb8", "MUSICAL SYMBOL QUINDICESIMA ALTA");
+-   ("/xf0/x9d/x84/xb9", "MUSICAL SYMBOL QUINDICESIMA BASSA");
+-   ("/xf0/x9d/x84/xba", "MUSICAL SYMBOL MULTI REST");
+-   ("/xf0/x9d/x84/xbb", "MUSICAL SYMBOL WHOLE REST");
+-   ("/xf0/x9d/x84/xbc", "MUSICAL SYMBOL HALF REST");
+-   ("/xf0/x9d/x84/xbd", "MUSICAL SYMBOL QUARTER REST");
+-   ("/xf0/x9d/x84/xbe", "MUSICAL SYMBOL EIGHTH REST");
+-   ("/xf0/x9d/x84/xbf", "MUSICAL SYMBOL SIXTEENTH REST");
+-   ("/xf0/x9d/x85/x80", "MUSICAL SYMBOL THIRTY-SECOND REST");
+-   ("/xf0/x9d/x85/x81", "MUSICAL SYMBOL SIXTY-FOURTH REST");
+-   ("/xf0/x9d/x85/x82", "MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH REST");
+-   ("/xf0/x9d/x85/x83", "MUSICAL SYMBOL X NOTEHEAD");
+-   ("/xf0/x9d/x85/x84", "MUSICAL SYMBOL PLUS NOTEHEAD");
+-   ("/xf0/x9d/x85/x85", "MUSICAL SYMBOL CIRCLE X NOTEHEAD");
+-   ("/xf0/x9d/x85/x86", "MUSICAL SYMBOL SQUARE NOTEHEAD WHITE");
+-   ("/xf0/x9d/x85/x87", "MUSICAL SYMBOL SQUARE NOTEHEAD BLACK");
+-   ("/xf0/x9d/x85/x88", "MUSICAL SYMBOL TRIANGLE NOTEHEAD UP WHITE");
+-   ("/xf0/x9d/x85/x89", "MUSICAL SYMBOL TRIANGLE NOTEHEAD UP BLACK");
+-   ("/xf0/x9d/x85/x8a", "MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT WHITE");
+-   ("/xf0/x9d/x85/x8b", "MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT BLACK");
+-   ("/xf0/x9d/x85/x8c", "MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT WHITE");
+-   ("/xf0/x9d/x85/x8d", "MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT BLACK");
+-   ("/xf0/x9d/x85/x8e", "MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN WHITE");
+-   ("/xf0/x9d/x85/x8f", "MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN BLACK");
+-   ("/xf0/x9d/x85/x90", "MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT WHITE");
+-   ("/xf0/x9d/x85/x91", "MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT BLACK");
+-   ("/xf0/x9d/x85/x92", "MUSICAL SYMBOL MOON NOTEHEAD WHITE");
+-   ("/xf0/x9d/x85/x93", "MUSICAL SYMBOL MOON NOTEHEAD BLACK");
+-   ("/xf0/x9d/x85/x94", "MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN WHITE");
+-   ("/xf0/x9d/x85/x95", "MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN BLACK");
+-   ("/xf0/x9d/x85/x96", "MUSICAL SYMBOL PARENTHESIS NOTEHEAD");
+-   ("/xf0/x9d/x85/x97", "MUSICAL SYMBOL VOID NOTEHEAD");
+-   ("/xf0/x9d/x85/x98", "MUSICAL SYMBOL NOTEHEAD BLACK");
+-   ("/xf0/x9d/x85/x99", "MUSICAL SYMBOL NULL NOTEHEAD");
+-   ("/xf0/x9d/x85/x9a", "MUSICAL SYMBOL CLUSTER NOTEHEAD WHITE");
+-   ("/xf0/x9d/x85/x9b", "MUSICAL SYMBOL CLUSTER NOTEHEAD BLACK");
+-   ("/xf0/x9d/x85/x9c", "MUSICAL SYMBOL BREVE");
+-   ("/xf0/x9d/x85/x9d", "MUSICAL SYMBOL WHOLE NOTE");
+-   ("/xf0/x9d/x85/x9e", "MUSICAL SYMBOL HALF NOTE");
+-   ("/xf0/x9d/x85/x9f", "MUSICAL SYMBOL QUARTER NOTE");
+-   ("/xf0/x9d/x85/xa0", "MUSICAL SYMBOL EIGHTH NOTE");
+-   ("/xf0/x9d/x85/xa1", "MUSICAL SYMBOL SIXTEENTH NOTE");
+-   ("/xf0/x9d/x85/xa2", "MUSICAL SYMBOL THIRTY-SECOND NOTE");
+-   ("/xf0/x9d/x85/xa3", "MUSICAL SYMBOL SIXTY-FOURTH NOTE");
+-   ("/xf0/x9d/x85/xa4", "MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE");
+-   ("/xf0/x9d/x85/xa5", "MUSICAL SYMBOL COMBINING STEM");
+-   ("/xf0/x9d/x85/xa6", "MUSICAL SYMBOL COMBINING SPRECHGESANG STEM");
+-   ("/xf0/x9d/x85/xa7", "MUSICAL SYMBOL COMBINING TREMOLO-1");
+-   ("/xf0/x9d/x85/xa8", "MUSICAL SYMBOL COMBINING TREMOLO-2");
+-   ("/xf0/x9d/x85/xa9", "MUSICAL SYMBOL COMBINING TREMOLO-3");
+-   ("/xf0/x9d/x85/xaa", "MUSICAL SYMBOL FINGERED TREMOLO-1");
+-   ("/xf0/x9d/x85/xab", "MUSICAL SYMBOL FINGERED TREMOLO-2");
+-   ("/xf0/x9d/x85/xac", "MUSICAL SYMBOL FINGERED TREMOLO-3");
+-   ("/xf0/x9d/x85/xad", "MUSICAL SYMBOL COMBINING AUGMENTATION DOT");
+-   ("/xf0/x9d/x85/xae", "MUSICAL SYMBOL COMBINING FLAG-1");
+-   ("/xf0/x9d/x85/xaf", "MUSICAL SYMBOL COMBINING FLAG-2");
+-   ("/xf0/x9d/x85/xb0", "MUSICAL SYMBOL COMBINING FLAG-3");
+-   ("/xf0/x9d/x85/xb1", "MUSICAL SYMBOL COMBINING FLAG-4");
+-   ("/xf0/x9d/x85/xb2", "MUSICAL SYMBOL COMBINING FLAG-5");
+-   ("/xf0/x9d/x85/xb3", "MUSICAL SYMBOL BEGIN BEAM");
+-   ("/xf0/x9d/x85/xb4", "MUSICAL SYMBOL END BEAM");
+-   ("/xf0/x9d/x85/xb5", "MUSICAL SYMBOL BEGIN TIE");
+-   ("/xf0/x9d/x85/xb6", "MUSICAL SYMBOL END TIE");
+-   ("/xf0/x9d/x85/xb7", "MUSICAL SYMBOL BEGIN SLUR");
+-   ("/xf0/x9d/x85/xb8", "MUSICAL SYMBOL END SLUR");
+-   ("/xf0/x9d/x85/xb9", "MUSICAL SYMBOL BEGIN PHRASE");
+-   ("/xf0/x9d/x85/xba", "MUSICAL SYMBOL END PHRASE");
+-   ("/xf0/x9d/x85/xbb", "MUSICAL SYMBOL COMBINING ACCENT");
+-   ("/xf0/x9d/x85/xbc", "MUSICAL SYMBOL COMBINING STACCATO");
+-   ("/xf0/x9d/x85/xbd", "MUSICAL SYMBOL COMBINING TENUTO");
+-   ("/xf0/x9d/x85/xbe", "MUSICAL SYMBOL COMBINING STACCATISSIMO");
+-   ("/xf0/x9d/x85/xbf", "MUSICAL SYMBOL COMBINING MARCATO");
+-   ("/xf0/x9d/x86/x80", "MUSICAL SYMBOL COMBINING MARCATO-STACCATO");
+-   ("/xf0/x9d/x86/x81", "MUSICAL SYMBOL COMBINING ACCENT-STACCATO");
+-   ("/xf0/x9d/x86/x82", "MUSICAL SYMBOL COMBINING LOURE");
+-   ("/xf0/x9d/x86/x83", "MUSICAL SYMBOL ARPEGGIATO UP");
+-   ("/xf0/x9d/x86/x84", "MUSICAL SYMBOL ARPEGGIATO DOWN");
+-   ("/xf0/x9d/x86/x85", "MUSICAL SYMBOL COMBINING DOIT");
+-   ("/xf0/x9d/x86/x86", "MUSICAL SYMBOL COMBINING RIP");
+-   ("/xf0/x9d/x86/x87", "MUSICAL SYMBOL COMBINING FLIP");
+-   ("/xf0/x9d/x86/x88", "MUSICAL SYMBOL COMBINING SMEAR");
+-   ("/xf0/x9d/x86/x89", "MUSICAL SYMBOL COMBINING BEND");
+-   ("/xf0/x9d/x86/x8a", "MUSICAL SYMBOL COMBINING DOUBLE TONGUE");
+-   ("/xf0/x9d/x86/x8b", "MUSICAL SYMBOL COMBINING TRIPLE TONGUE");
+-   ("/xf0/x9d/x86/x8c", "MUSICAL SYMBOL RINFORZANDO");
+-   ("/xf0/x9d/x86/x8d", "MUSICAL SYMBOL SUBITO");
+-   ("/xf0/x9d/x86/x8e", "MUSICAL SYMBOL Z");
+-   ("/xf0/x9d/x86/x8f", "MUSICAL SYMBOL PIANO");
+-   ("/xf0/x9d/x86/x90", "MUSICAL SYMBOL MEZZO");
+-   ("/xf0/x9d/x86/x91", "MUSICAL SYMBOL FORTE");
+-   ("/xf0/x9d/x86/x92", "MUSICAL SYMBOL CRESCENDO");
+-   ("/xf0/x9d/x86/x93", "MUSICAL SYMBOL DECRESCENDO");
+-   ("/xf0/x9d/x86/x94", "MUSICAL SYMBOL GRACE NOTE SLASH");
+-   ("/xf0/x9d/x86/x95", "MUSICAL SYMBOL GRACE NOTE NO SLASH");
+-   ("/xf0/x9d/x86/x96", "MUSICAL SYMBOL TR");
+-   ("/xf0/x9d/x86/x97", "MUSICAL SYMBOL TURN");
+-   ("/xf0/x9d/x86/x98", "MUSICAL SYMBOL INVERTED TURN");
+-   ("/xf0/x9d/x86/x99", "MUSICAL SYMBOL TURN SLASH");
+-   ("/xf0/x9d/x86/x9a", "MUSICAL SYMBOL TURN UP");
+-   ("/xf0/x9d/x86/x9b", "MUSICAL SYMBOL ORNAMENT STROKE-1");
+-   ("/xf0/x9d/x86/x9c", "MUSICAL SYMBOL ORNAMENT STROKE-2");
+-   ("/xf0/x9d/x86/x9d", "MUSICAL SYMBOL ORNAMENT STROKE-3");
+-   ("/xf0/x9d/x86/x9e", "MUSICAL SYMBOL ORNAMENT STROKE-4");
+-   ("/xf0/x9d/x86/x9f", "MUSICAL SYMBOL ORNAMENT STROKE-5");
+-   ("/xf0/x9d/x86/xa0", "MUSICAL SYMBOL ORNAMENT STROKE-6");
+-   ("/xf0/x9d/x86/xa1", "MUSICAL SYMBOL ORNAMENT STROKE-7");
+-   ("/xf0/x9d/x86/xa2", "MUSICAL SYMBOL ORNAMENT STROKE-8");
+-   ("/xf0/x9d/x86/xa3", "MUSICAL SYMBOL ORNAMENT STROKE-9");
+-   ("/xf0/x9d/x86/xa4", "MUSICAL SYMBOL ORNAMENT STROKE-10");
+-   ("/xf0/x9d/x86/xa5", "MUSICAL SYMBOL ORNAMENT STROKE-11");
+-   ("/xf0/x9d/x86/xa6", "MUSICAL SYMBOL HAUPTSTIMME");
+-   ("/xf0/x9d/x86/xa7", "MUSICAL SYMBOL NEBENSTIMME");
+-   ("/xf0/x9d/x86/xa8", "MUSICAL SYMBOL END OF STIMME");
+-   ("/xf0/x9d/x86/xa9", "MUSICAL SYMBOL DEGREE SLASH");
+-   ("/xf0/x9d/x86/xaa", "MUSICAL SYMBOL COMBINING DOWN BOW");
+-   ("/xf0/x9d/x86/xab", "MUSICAL SYMBOL COMBINING UP BOW");
+-   ("/xf0/x9d/x86/xac", "MUSICAL SYMBOL COMBINING HARMONIC");
+-   ("/xf0/x9d/x86/xad", "MUSICAL SYMBOL COMBINING SNAP PIZZICATO");
+-   ("/xf0/x9d/x86/xae", "MUSICAL SYMBOL PEDAL MARK");
+-   ("/xf0/x9d/x86/xaf", "MUSICAL SYMBOL PEDAL UP MARK");
+-   ("/xf0/x9d/x86/xb0", "MUSICAL SYMBOL HALF PEDAL MARK");
+-   ("/xf0/x9d/x86/xb1", "MUSICAL SYMBOL GLISSANDO UP");
+-   ("/xf0/x9d/x86/xb2", "MUSICAL SYMBOL GLISSANDO DOWN");
+-   ("/xf0/x9d/x86/xb3", "MUSICAL SYMBOL WITH FINGERNAILS");
+-   ("/xf0/x9d/x86/xb4", "MUSICAL SYMBOL DAMP");
+-   ("/xf0/x9d/x86/xb5", "MUSICAL SYMBOL DAMP ALL");
+-   ("/xf0/x9d/x86/xb6", "MUSICAL SYMBOL MAXIMA");
+-   ("/xf0/x9d/x86/xb7", "MUSICAL SYMBOL LONGA");
+-   ("/xf0/x9d/x86/xb8", "MUSICAL SYMBOL BREVIS");
+-   ("/xf0/x9d/x86/xb9", "MUSICAL SYMBOL SEMIBREVIS WHITE");
+-   ("/xf0/x9d/x86/xba", "MUSICAL SYMBOL SEMIBREVIS BLACK");
+-   ("/xf0/x9d/x86/xbb", "MUSICAL SYMBOL MINIMA");
+-   ("/xf0/x9d/x86/xbc", "MUSICAL SYMBOL MINIMA BLACK");
+-   ("/xf0/x9d/x86/xbd", "MUSICAL SYMBOL SEMIMINIMA WHITE");
+-   ("/xf0/x9d/x86/xbe", "MUSICAL SYMBOL SEMIMINIMA BLACK");
+-   ("/xf0/x9d/x86/xbf", "MUSICAL SYMBOL FUSA WHITE");
+-   ("/xf0/x9d/x87/x80", "MUSICAL SYMBOL FUSA BLACK");
+-   ("/xf0/x9d/x87/x81", "MUSICAL SYMBOL LONGA PERFECTA REST");
+-   ("/xf0/x9d/x87/x82", "MUSICAL SYMBOL LONGA IMPERFECTA REST");
+-   ("/xf0/x9d/x87/x83", "MUSICAL SYMBOL BREVIS REST");
+-   ("/xf0/x9d/x87/x84", "MUSICAL SYMBOL SEMIBREVIS REST");
+-   ("/xf0/x9d/x87/x85", "MUSICAL SYMBOL MINIMA REST");
+-   ("/xf0/x9d/x87/x86", "MUSICAL SYMBOL SEMIMINIMA REST");
+-   ("/xf0/x9d/x87/x87", "MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA");
+-   ("/xf0/x9d/x87/x88", "MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE IMPERFECTA");
+-   ("/xf0/x9d/x87/x89", "MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA DIMINUTION-1");
+-   ("/xf0/x9d/x87/x8a", "MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE PERFECTA");
+-   ("/xf0/x9d/x87/x8b", "MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA");
+-   ("/xf0/x9d/x87/x8c", "MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-1");
+-   ("/xf0/x9d/x87/x8d", "MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-2");
+-   ("/xf0/x9d/x87/x8e", "MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-3");
+-   ("/xf0/x9d/x87/x8f", "MUSICAL SYMBOL CROIX");
+-   ("/xf0/x9d/x87/x90", "MUSICAL SYMBOL GREGORIAN C CLEF");
+-   ("/xf0/x9d/x87/x91", "MUSICAL SYMBOL GREGORIAN F CLEF");
+-   ("/xf0/x9d/x87/x92", "MUSICAL SYMBOL SQUARE B");
+-   ("/xf0/x9d/x87/x93", "MUSICAL SYMBOL VIRGA");
+-   ("/xf0/x9d/x87/x94", "MUSICAL SYMBOL PODATUS");
+-   ("/xf0/x9d/x87/x95", "MUSICAL SYMBOL CLIVIS");
+-   ("/xf0/x9d/x87/x96", "MUSICAL SYMBOL SCANDICUS");
+-   ("/xf0/x9d/x87/x97", "MUSICAL SYMBOL CLIMACUS");
+-   ("/xf0/x9d/x87/x98", "MUSICAL SYMBOL TORCULUS");
+-   ("/xf0/x9d/x87/x99", "MUSICAL SYMBOL PORRECTUS");
+-   ("/xf0/x9d/x87/x9a", "MUSICAL SYMBOL PORRECTUS FLEXUS");
+-   ("/xf0/x9d/x87/x9b", "MUSICAL SYMBOL SCANDICUS FLEXUS");
+-   ("/xf0/x9d/x87/x9c", "MUSICAL SYMBOL TORCULUS RESUPINUS");
+-   ("/xf0/x9d/x87/x9d", "MUSICAL SYMBOL PES SUBPUNCTIS");
+-   ("/xf0/x9d/x88/x80", "GREEK VOCAL NOTATION SYMBOL-1");
+-   ("/xf0/x9d/x88/x81", "GREEK VOCAL NOTATION SYMBOL-2");
+-   ("/xf0/x9d/x88/x82", "GREEK VOCAL NOTATION SYMBOL-3");
+-   ("/xf0/x9d/x88/x83", "GREEK VOCAL NOTATION SYMBOL-4");
+-   ("/xf0/x9d/x88/x84", "GREEK VOCAL NOTATION SYMBOL-5");
+-   ("/xf0/x9d/x88/x85", "GREEK VOCAL NOTATION SYMBOL-6");
+-   ("/xf0/x9d/x88/x86", "GREEK VOCAL NOTATION SYMBOL-7");
+-   ("/xf0/x9d/x88/x87", "GREEK VOCAL NOTATION SYMBOL-8");
+-   ("/xf0/x9d/x88/x88", "GREEK VOCAL NOTATION SYMBOL-9");
+-   ("/xf0/x9d/x88/x89", "GREEK VOCAL NOTATION SYMBOL-10");
+-   ("/xf0/x9d/x88/x8a", "GREEK VOCAL NOTATION SYMBOL-11");
+-   ("/xf0/x9d/x88/x8b", "GREEK VOCAL NOTATION SYMBOL-12");
+-   ("/xf0/x9d/x88/x8c", "GREEK VOCAL NOTATION SYMBOL-13");
+-   ("/xf0/x9d/x88/x8d", "GREEK VOCAL NOTATION SYMBOL-14");
+-   ("/xf0/x9d/x88/x8e", "GREEK VOCAL NOTATION SYMBOL-15");
+-   ("/xf0/x9d/x88/x8f", "GREEK VOCAL NOTATION SYMBOL-16");
+-   ("/xf0/x9d/x88/x90", "GREEK VOCAL NOTATION SYMBOL-17");
+-   ("/xf0/x9d/x88/x91", "GREEK VOCAL NOTATION SYMBOL-18");
+-   ("/xf0/x9d/x88/x92", "GREEK VOCAL NOTATION SYMBOL-19");
+-   ("/xf0/x9d/x88/x93", "GREEK VOCAL NOTATION SYMBOL-20");
+-   ("/xf0/x9d/x88/x94", "GREEK VOCAL NOTATION SYMBOL-21");
+-   ("/xf0/x9d/x88/x95", "GREEK VOCAL NOTATION SYMBOL-22");
+-   ("/xf0/x9d/x88/x96", "GREEK VOCAL NOTATION SYMBOL-23");
+-   ("/xf0/x9d/x88/x97", "GREEK VOCAL NOTATION SYMBOL-24");
+-   ("/xf0/x9d/x88/x98", "GREEK VOCAL NOTATION SYMBOL-50");
+-   ("/xf0/x9d/x88/x99", "GREEK VOCAL NOTATION SYMBOL-51");
+-   ("/xf0/x9d/x88/x9a", "GREEK VOCAL NOTATION SYMBOL-52");
+-   ("/xf0/x9d/x88/x9b", "GREEK VOCAL NOTATION SYMBOL-53");
+-   ("/xf0/x9d/x88/x9c", "GREEK VOCAL NOTATION SYMBOL-54");
+-   ("/xf0/x9d/x88/x9d", "GREEK INSTRUMENTAL NOTATION SYMBOL-1");
+-   ("/xf0/x9d/x88/x9e", "GREEK INSTRUMENTAL NOTATION SYMBOL-2");
+-   ("/xf0/x9d/x88/x9f", "GREEK INSTRUMENTAL NOTATION SYMBOL-4");
+-   ("/xf0/x9d/x88/xa0", "GREEK INSTRUMENTAL NOTATION SYMBOL-5");
+-   ("/xf0/x9d/x88/xa1", "GREEK INSTRUMENTAL NOTATION SYMBOL-7");
+-   ("/xf0/x9d/x88/xa2", "GREEK INSTRUMENTAL NOTATION SYMBOL-8");
+-   ("/xf0/x9d/x88/xa3", "GREEK INSTRUMENTAL NOTATION SYMBOL-11");
+-   ("/xf0/x9d/x88/xa4", "GREEK INSTRUMENTAL NOTATION SYMBOL-12");
+-   ("/xf0/x9d/x88/xa5", "GREEK INSTRUMENTAL NOTATION SYMBOL-13");
+-   ("/xf0/x9d/x88/xa6", "GREEK INSTRUMENTAL NOTATION SYMBOL-14");
+-   ("/xf0/x9d/x88/xa7", "GREEK INSTRUMENTAL NOTATION SYMBOL-17");
+-   ("/xf0/x9d/x88/xa8", "GREEK INSTRUMENTAL NOTATION SYMBOL-18");
+-   ("/xf0/x9d/x88/xa9", "GREEK INSTRUMENTAL NOTATION SYMBOL-19");
+-   ("/xf0/x9d/x88/xaa", "GREEK INSTRUMENTAL NOTATION SYMBOL-23");
+-   ("/xf0/x9d/x88/xab", "GREEK INSTRUMENTAL NOTATION SYMBOL-24");
+-   ("/xf0/x9d/x88/xac", "GREEK INSTRUMENTAL NOTATION SYMBOL-25");
+-   ("/xf0/x9d/x88/xad", "GREEK INSTRUMENTAL NOTATION SYMBOL-26");
+-   ("/xf0/x9d/x88/xae", "GREEK INSTRUMENTAL NOTATION SYMBOL-27");
+-   ("/xf0/x9d/x88/xaf", "GREEK INSTRUMENTAL NOTATION SYMBOL-29");
+-   ("/xf0/x9d/x88/xb0", "GREEK INSTRUMENTAL NOTATION SYMBOL-30");
+-   ("/xf0/x9d/x88/xb1", "GREEK INSTRUMENTAL NOTATION SYMBOL-32");
+-   ("/xf0/x9d/x88/xb2", "GREEK INSTRUMENTAL NOTATION SYMBOL-36");
+-   ("/xf0/x9d/x88/xb3", "GREEK INSTRUMENTAL NOTATION SYMBOL-37");
+-   ("/xf0/x9d/x88/xb4", "GREEK INSTRUMENTAL NOTATION SYMBOL-38");
+-   ("/xf0/x9d/x88/xb5", "GREEK INSTRUMENTAL NOTATION SYMBOL-39");
+-   ("/xf0/x9d/x88/xb6", "GREEK INSTRUMENTAL NOTATION SYMBOL-40");
+-   ("/xf0/x9d/x88/xb7", "GREEK INSTRUMENTAL NOTATION SYMBOL-42");
+-   ("/xf0/x9d/x88/xb8", "GREEK INSTRUMENTAL NOTATION SYMBOL-43");
+-   ("/xf0/x9d/x88/xb9", "GREEK INSTRUMENTAL NOTATION SYMBOL-45");
+-   ("/xf0/x9d/x88/xba", "GREEK INSTRUMENTAL NOTATION SYMBOL-47");
+-   ("/xf0/x9d/x88/xbb", "GREEK INSTRUMENTAL NOTATION SYMBOL-48");
+-   ("/xf0/x9d/x88/xbc", "GREEK INSTRUMENTAL NOTATION SYMBOL-49");
+-   ("/xf0/x9d/x88/xbd", "GREEK INSTRUMENTAL NOTATION SYMBOL-50");
+-   ("/xf0/x9d/x88/xbe", "GREEK INSTRUMENTAL NOTATION SYMBOL-51");
+-   ("/xf0/x9d/x88/xbf", "GREEK INSTRUMENTAL NOTATION SYMBOL-52");
+-   ("/xf0/x9d/x89/x80", "GREEK INSTRUMENTAL NOTATION SYMBOL-53");
+-   ("/xf0/x9d/x89/x81", "GREEK INSTRUMENTAL NOTATION SYMBOL-54");
+-   ("/xf0/x9d/x89/x82", "COMBINING GREEK MUSICAL TRISEME");
+-   ("/xf0/x9d/x89/x83", "COMBINING GREEK MUSICAL TETRASEME");
+-   ("/xf0/x9d/x89/x84", "COMBINING GREEK MUSICAL PENTASEME");
+-   ("/xf0/x9d/x89/x85", "GREEK MUSICAL LEIMMA");
+-   ("/xf0/x9d/x8c/x80", "MONOGRAM FOR EARTH");
+-   ("/xf0/x9d/x8c/x81", "DIGRAM FOR HEAVENLY EARTH");
+-   ("/xf0/x9d/x8c/x82", "DIGRAM FOR HUMAN EARTH");
+-   ("/xf0/x9d/x8c/x83", "DIGRAM FOR EARTHLY HEAVEN");
+-   ("/xf0/x9d/x8c/x84", "DIGRAM FOR EARTHLY HUMAN");
+-   ("/xf0/x9d/x8c/x85", "DIGRAM FOR EARTH");
+-   ("/xf0/x9d/x8c/x86", "TETRAGRAM FOR CENTRE");
+-   ("/xf0/x9d/x8c/x87", "TETRAGRAM FOR FULL CIRCLE");
+-   ("/xf0/x9d/x8c/x88", "TETRAGRAM FOR MIRED");
+-   ("/xf0/x9d/x8c/x89", "TETRAGRAM FOR BARRIER");
+    ("/xf0/x9d/x8c/x8a", "TETRAGRAM FOR KEEPING SMALL");
+-   ("/xf0/x9d/x8c/x8b", "TETRAGRAM FOR CONTRARIETY");
+-   ("/xf0/x9d/x8c/x8c", "TETRAGRAM FOR ASCENT");
+-   ("/xf0/x9d/x8c/x8d", "TETRAGRAM FOR OPPOSITION");
+-   ("/xf0/x9d/x8c/x8e", "TETRAGRAM FOR BRANCHING OUT");
+-   ("/xf0/x9d/x8c/x8f", "TETRAGRAM FOR DEFECTIVENESS OR DISTORTION");
+-   ("/xf0/x9d/x8c/x90", "TETRAGRAM FOR DIVERGENCE");
+-   ("/xf0/x9d/x8c/x91", "TETRAGRAM FOR YOUTHFULNESS");
+-   ("/xf0/x9d/x8c/x92", "TETRAGRAM FOR INCREASE");
+-   ("/xf0/x9d/x8c/x93", "TETRAGRAM FOR PENETRATION");
+-   ("/xf0/x9d/x8c/x94", "TETRAGRAM FOR REACH");
+-   ("/xf0/x9d/x8c/x95", "TETRAGRAM FOR CONTACT");
+-   ("/xf0/x9d/x8c/x96", "TETRAGRAM FOR HOLDING BACK");
+-   ("/xf0/x9d/x8c/x97", "TETRAGRAM FOR WAITING");
+-   ("/xf0/x9d/x8c/x98", "TETRAGRAM FOR FOLLOWING");
+-   ("/xf0/x9d/x8c/x99", "TETRAGRAM FOR ADVANCE");
+-   ("/xf0/x9d/x8c/x9a", "TETRAGRAM FOR RELEASE");
+-   ("/xf0/x9d/x8c/x9b", "TETRAGRAM FOR RESISTANCE");
+-   ("/xf0/x9d/x8c/x9c", "TETRAGRAM FOR EASE");
+-   ("/xf0/x9d/x8c/x9d", "TETRAGRAM FOR JOY");
+-   ("/xf0/x9d/x8c/x9e", "TETRAGRAM FOR CONTENTION");
+-   ("/xf0/x9d/x8c/x9f", "TETRAGRAM FOR ENDEAVOUR");
+-   ("/xf0/x9d/x8c/xa0", "TETRAGRAM FOR DUTIES");
+-   ("/xf0/x9d/x8c/xa1", "TETRAGRAM FOR CHANGE");
+-   ("/xf0/x9d/x8c/xa2", "TETRAGRAM FOR DECISIVENESS");
+-   ("/xf0/x9d/x8c/xa3", "TETRAGRAM FOR BOLD RESOLUTION");
+-   ("/xf0/x9d/x8c/xa4", "TETRAGRAM FOR PACKING");
+-   ("/xf0/x9d/x8c/xa5", "TETRAGRAM FOR LEGION");
+-   ("/xf0/x9d/x8c/xa6", "TETRAGRAM FOR CLOSENESS");
+-   ("/xf0/x9d/x8c/xa7", "TETRAGRAM FOR KINSHIP");
+-   ("/xf0/x9d/x8c/xa8", "TETRAGRAM FOR GATHERING");
+-   ("/xf0/x9d/x8c/xa9", "TETRAGRAM FOR STRENGTH");
+-   ("/xf0/x9d/x8c/xaa", "TETRAGRAM FOR PURITY");
+-   ("/xf0/x9d/x8c/xab", "TETRAGRAM FOR FULLNESS");
+-   ("/xf0/x9d/x8c/xac", "TETRAGRAM FOR RESIDENCE");
+-   ("/xf0/x9d/x8c/xad", "TETRAGRAM FOR LAW OR MODEL");
+-   ("/xf0/x9d/x8c/xae", "TETRAGRAM FOR RESPONSE");
+-   ("/xf0/x9d/x8c/xaf", "TETRAGRAM FOR GOING TO MEET");
+-   ("/xf0/x9d/x8c/xb0", "TETRAGRAM FOR ENCOUNTERS");
+-   ("/xf0/x9d/x8c/xb1", "TETRAGRAM FOR STOVE");
+-   ("/xf0/x9d/x8c/xb2", "TETRAGRAM FOR GREATNESS");
+-   ("/xf0/x9d/x8c/xb3", "TETRAGRAM FOR ENLARGEMENT");
+-   ("/xf0/x9d/x8c/xb4", "TETRAGRAM FOR PATTERN");
+-   ("/xf0/x9d/x8c/xb5", "TETRAGRAM FOR RITUAL");
+-   ("/xf0/x9d/x8c/xb6", "TETRAGRAM FOR FLIGHT");
+-   ("/xf0/x9d/x8c/xb7", "TETRAGRAM FOR VASTNESS OR WASTING");
+-   ("/xf0/x9d/x8c/xb8", "TETRAGRAM FOR CONSTANCY");
+-   ("/xf0/x9d/x8c/xb9", "TETRAGRAM FOR MEASURE");
+-   ("/xf0/x9d/x8c/xba", "TETRAGRAM FOR ETERNITY");
+-   ("/xf0/x9d/x8c/xbb", "TETRAGRAM FOR UNITY");
+-   ("/xf0/x9d/x8c/xbc", "TETRAGRAM FOR DIMINISHMENT");
+-   ("/xf0/x9d/x8c/xbd", "TETRAGRAM FOR CLOSED MOUTH");
+-   ("/xf0/x9d/x8c/xbe", "TETRAGRAM FOR GUARDEDNESS");
+-   ("/xf0/x9d/x8c/xbf", "TETRAGRAM FOR GATHERING IN");
+-   ("/xf0/x9d/x8d/x80", "TETRAGRAM FOR MASSING");
+-   ("/xf0/x9d/x8d/x81", "TETRAGRAM FOR ACCUMULATION");
+-   ("/xf0/x9d/x8d/x82", "TETRAGRAM FOR EMBELLISHMENT");
+-   ("/xf0/x9d/x8d/x83", "TETRAGRAM FOR DOUBT");
+-   ("/xf0/x9d/x8d/x84", "TETRAGRAM FOR WATCH");
+-   ("/xf0/x9d/x8d/x85", "TETRAGRAM FOR SINKING");
+-   ("/xf0/x9d/x8d/x86", "TETRAGRAM FOR INNER");
+-   ("/xf0/x9d/x8d/x87", "TETRAGRAM FOR DEPARTURE");
+-   ("/xf0/x9d/x8d/x88", "TETRAGRAM FOR DARKENING");
+-   ("/xf0/x9d/x8d/x89", "TETRAGRAM FOR DIMMING");
+-   ("/xf0/x9d/x8d/x8a", "TETRAGRAM FOR EXHAUSTION");
+-   ("/xf0/x9d/x8d/x8b", "TETRAGRAM FOR SEVERANCE");
+-   ("/xf0/x9d/x8d/x8c", "TETRAGRAM FOR STOPPAGE");
+-   ("/xf0/x9d/x8d/x8d", "TETRAGRAM FOR HARDNESS");
+-   ("/xf0/x9d/x8d/x8e", "TETRAGRAM FOR COMPLETION");
+-   ("/xf0/x9d/x8d/x8f", "TETRAGRAM FOR CLOSURE");
+-   ("/xf0/x9d/x8d/x90", "TETRAGRAM FOR FAILURE");
+-   ("/xf0/x9d/x8d/x91", "TETRAGRAM FOR AGGRAVATION");
+-   ("/xf0/x9d/x8d/x92", "TETRAGRAM FOR COMPLIANCE");
+-   ("/xf0/x9d/x8d/x93", "TETRAGRAM FOR ON THE VERGE");
+-   ("/xf0/x9d/x8d/x94", "TETRAGRAM FOR DIFFICULTIES");
+-   ("/xf0/x9d/x8d/x95", "TETRAGRAM FOR LABOURING");
+-   ("/xf0/x9d/x8d/x96", "TETRAGRAM FOR FOSTERING");
+-   ("/xf0/x9d/x8d/xa0", "COUNTING ROD UNIT DIGIT ONE");
+-   ("/xf0/x9d/x8d/xa1", "COUNTING ROD UNIT DIGIT TWO");
+-   ("/xf0/x9d/x8d/xa2", "COUNTING ROD UNIT DIGIT THREE");
+-   ("/xf0/x9d/x8d/xa3", "COUNTING ROD UNIT DIGIT FOUR");
+-   ("/xf0/x9d/x8d/xa4", "COUNTING ROD UNIT DIGIT FIVE");
+-   ("/xf0/x9d/x8d/xa5", "COUNTING ROD UNIT DIGIT SIX");
+-   ("/xf0/x9d/x8d/xa6", "COUNTING ROD UNIT DIGIT SEVEN");
+-   ("/xf0/x9d/x8d/xa7", "COUNTING ROD UNIT DIGIT EIGHT");
+-   ("/xf0/x9d/x8d/xa8", "COUNTING ROD UNIT DIGIT NINE");
+-   ("/xf0/x9d/x8d/xa9", "COUNTING ROD TENS DIGIT ONE");
+-   ("/xf0/x9d/x8d/xaa", "COUNTING ROD TENS DIGIT TWO");
+-   ("/xf0/x9d/x8d/xab", "COUNTING ROD TENS DIGIT THREE");
+-   ("/xf0/x9d/x8d/xac", "COUNTING ROD TENS DIGIT FOUR");
+-   ("/xf0/x9d/x8d/xad", "COUNTING ROD TENS DIGIT FIVE");
+-   ("/xf0/x9d/x8d/xae", "COUNTING ROD TENS DIGIT SIX");
+-   ("/xf0/x9d/x8d/xaf", "COUNTING ROD TENS DIGIT SEVEN");
+-   ("/xf0/x9d/x8d/xb0", "COUNTING ROD TENS DIGIT EIGHT");
+-   ("/xf0/x9d/x8d/xb1", "COUNTING ROD TENS DIGIT NINE");
+    ("/xf0/x9d/x90/x80", "MATHEMATICAL BOLD CAPITAL A");
+    ("/xf0/x9d/x90/x81", "MATHEMATICAL BOLD CAPITAL B");
+    ("/xf0/x9d/x90/x82", "MATHEMATICAL BOLD CAPITAL C");
+@@ -29692,7 +3328,6 @@
+    ("/xf0/x9d/x9a/xbe", "MATHEMATICAL BOLD CAPITAL CHI");
+    ("/xf0/x9d/x9a/xbf", "MATHEMATICAL BOLD CAPITAL PSI");
+    ("/xf0/x9d/x9b/x80", "MATHEMATICAL BOLD CAPITAL OMEGA");
+-   ("/xf0/x9d/x9b/x81", "MATHEMATICAL BOLD NABLA");
+    ("/xf0/x9d/x9b/x82", "MATHEMATICAL BOLD SMALL ALPHA");
+    ("/xf0/x9d/x9b/x83", "MATHEMATICAL BOLD SMALL BETA");
+    ("/xf0/x9d/x9b/x84", "MATHEMATICAL BOLD SMALL GAMMA");
+@@ -29718,13 +3353,6 @@
+    ("/xf0/x9d/x9b/x98", "MATHEMATICAL BOLD SMALL CHI");
+    ("/xf0/x9d/x9b/x99", "MATHEMATICAL BOLD SMALL PSI");
+    ("/xf0/x9d/x9b/x9a", "MATHEMATICAL BOLD SMALL OMEGA");
+-   ("/xf0/x9d/x9b/x9b", "MATHEMATICAL BOLD PARTIAL DIFFERENTIAL");
+-   ("/xf0/x9d/x9b/x9c", "MATHEMATICAL BOLD EPSILON SYMBOL");
+-   ("/xf0/x9d/x9b/x9d", "MATHEMATICAL BOLD THETA SYMBOL");
+-   ("/xf0/x9d/x9b/x9e", "MATHEMATICAL BOLD KAPPA SYMBOL");
+-   ("/xf0/x9d/x9b/x9f", "MATHEMATICAL BOLD PHI SYMBOL");
+-   ("/xf0/x9d/x9b/xa0", "MATHEMATICAL BOLD RHO SYMBOL");
+-   ("/xf0/x9d/x9b/xa1", "MATHEMATICAL BOLD PI SYMBOL");
+    ("/xf0/x9d/x9b/xa2", "MATHEMATICAL ITALIC CAPITAL ALPHA");
+    ("/xf0/x9d/x9b/xa3", "MATHEMATICAL ITALIC CAPITAL BETA");
+    ("/xf0/x9d/x9b/xa4", "MATHEMATICAL ITALIC CAPITAL GAMMA");
+@@ -29750,7 +3378,6 @@
+    ("/xf0/x9d/x9b/xb8", "MATHEMATICAL ITALIC CAPITAL CHI");
+    ("/xf0/x9d/x9b/xb9", "MATHEMATICAL ITALIC CAPITAL PSI");
+    ("/xf0/x9d/x9b/xba", "MATHEMATICAL ITALIC CAPITAL OMEGA");
+-   ("/xf0/x9d/x9b/xbb", "MATHEMATICAL ITALIC NABLA");
+    ("/xf0/x9d/x9b/xbc", "MATHEMATICAL ITALIC SMALL ALPHA");
+    ("/xf0/x9d/x9b/xbd", "MATHEMATICAL ITALIC SMALL BETA");
+    ("/xf0/x9d/x9b/xbe", "MATHEMATICAL ITALIC SMALL GAMMA");
+@@ -29776,13 +3403,6 @@
+    ("/xf0/x9d/x9c/x92", "MATHEMATICAL ITALIC SMALL CHI");
+    ("/xf0/x9d/x9c/x93", "MATHEMATICAL ITALIC SMALL PSI");
+    ("/xf0/x9d/x9c/x94", "MATHEMATICAL ITALIC SMALL OMEGA");
+-   ("/xf0/x9d/x9c/x95", "MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL");
+-   ("/xf0/x9d/x9c/x96", "MATHEMATICAL ITALIC EPSILON SYMBOL");
+-   ("/xf0/x9d/x9c/x97", "MATHEMATICAL ITALIC THETA SYMBOL");
+-   ("/xf0/x9d/x9c/x98", "MATHEMATICAL ITALIC KAPPA SYMBOL");
+-   ("/xf0/x9d/x9c/x99", "MATHEMATICAL ITALIC PHI SYMBOL");
+-   ("/xf0/x9d/x9c/x9a", "MATHEMATICAL ITALIC RHO SYMBOL");
+-   ("/xf0/x9d/x9c/x9b", "MATHEMATICAL ITALIC PI SYMBOL");
+    ("/xf0/x9d/x9c/x9c", "MATHEMATICAL BOLD ITALIC CAPITAL ALPHA");
+    ("/xf0/x9d/x9c/x9d", "MATHEMATICAL BOLD ITALIC CAPITAL BETA");
+    ("/xf0/x9d/x9c/x9e", "MATHEMATICAL BOLD ITALIC CAPITAL GAMMA");
+@@ -29808,7 +3428,6 @@
+    ("/xf0/x9d/x9c/xb2", "MATHEMATICAL BOLD ITALIC CAPITAL CHI");
+    ("/xf0/x9d/x9c/xb3", "MATHEMATICAL BOLD ITALIC CAPITAL PSI");
+    ("/xf0/x9d/x9c/xb4", "MATHEMATICAL BOLD ITALIC CAPITAL OMEGA");
+-   ("/xf0/x9d/x9c/xb5", "MATHEMATICAL BOLD ITALIC NABLA");
+    ("/xf0/x9d/x9c/xb6", "MATHEMATICAL BOLD ITALIC SMALL ALPHA");
+    ("/xf0/x9d/x9c/xb7", "MATHEMATICAL BOLD ITALIC SMALL BETA");
+    ("/xf0/x9d/x9c/xb8", "MATHEMATICAL BOLD ITALIC SMALL GAMMA");
+@@ -29834,13 +3453,6 @@
+    ("/xf0/x9d/x9d/x8c", "MATHEMATICAL BOLD ITALIC SMALL CHI");
+    ("/xf0/x9d/x9d/x8d", "MATHEMATICAL BOLD ITALIC SMALL PSI");
+    ("/xf0/x9d/x9d/x8e", "MATHEMATICAL BOLD ITALIC SMALL OMEGA");
+-   ("/xf0/x9d/x9d/x8f", "MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL");
+-   ("/xf0/x9d/x9d/x90", "MATHEMATICAL BOLD ITALIC EPSILON SYMBOL");
+-   ("/xf0/x9d/x9d/x91", "MATHEMATICAL BOLD ITALIC THETA SYMBOL");
+-   ("/xf0/x9d/x9d/x92", "MATHEMATICAL BOLD ITALIC KAPPA SYMBOL");
+-   ("/xf0/x9d/x9d/x93", "MATHEMATICAL BOLD ITALIC PHI SYMBOL");
+-   ("/xf0/x9d/x9d/x94", "MATHEMATICAL BOLD ITALIC RHO SYMBOL");
+-   ("/xf0/x9d/x9d/x95", "MATHEMATICAL BOLD ITALIC PI SYMBOL");
+    ("/xf0/x9d/x9d/x96", "MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA");
+    ("/xf0/x9d/x9d/x97", "MATHEMATICAL SANS-SERIF BOLD CAPITAL BETA");
+    ("/xf0/x9d/x9d/x98", "MATHEMATICAL SANS-SERIF BOLD CAPITAL GAMMA");
+@@ -29866,7 +3478,6 @@
+    ("/xf0/x9d/x9d/xac", "MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI");
+    ("/xf0/x9d/x9d/xad", "MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI");
+    ("/xf0/x9d/x9d/xae", "MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA");
+-   ("/xf0/x9d/x9d/xaf", "MATHEMATICAL SANS-SERIF BOLD NABLA");
+    ("/xf0/x9d/x9d/xb0", "MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA");
+    ("/xf0/x9d/x9d/xb1", "MATHEMATICAL SANS-SERIF BOLD SMALL BETA");
+    ("/xf0/x9d/x9d/xb2", "MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA");
+@@ -29892,13 +3503,6 @@
+    ("/xf0/x9d/x9e/x86", "MATHEMATICAL SANS-SERIF BOLD SMALL CHI");
+    ("/xf0/x9d/x9e/x87", "MATHEMATICAL SANS-SERIF BOLD SMALL PSI");
+    ("/xf0/x9d/x9e/x88", "MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA");
+-   ("/xf0/x9d/x9e/x89", "MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL");
+-   ("/xf0/x9d/x9e/x8a", "MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL");
+-   ("/xf0/x9d/x9e/x8b", "MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL");
+-   ("/xf0/x9d/x9e/x8c", "MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL");
+-   ("/xf0/x9d/x9e/x8d", "MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL");
+-   ("/xf0/x9d/x9e/x8e", "MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL");
+-   ("/xf0/x9d/x9e/x8f", "MATHEMATICAL SANS-SERIF BOLD PI SYMBOL");
+    ("/xf0/x9d/x9e/x90", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA");
+    ("/xf0/x9d/x9e/x91", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA");
+    ("/xf0/x9d/x9e/x92", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA");
+@@ -29924,7 +3528,6 @@
+    ("/xf0/x9d/x9e/xa6", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI");
+    ("/xf0/x9d/x9e/xa7", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI");
+    ("/xf0/x9d/x9e/xa8", "MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA");
+-   ("/xf0/x9d/x9e/xa9", "MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA");
+    ("/xf0/x9d/x9e/xaa", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA");
+    ("/xf0/x9d/x9e/xab", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA");
+    ("/xf0/x9d/x9e/xac", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA");
+@@ -29950,1453 +3553,8 @@
+    ("/xf0/x9d/x9f/x80", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI");
+    ("/xf0/x9d/x9f/x81", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI");
+    ("/xf0/x9d/x9f/x82", "MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA");
+-   ("/xf0/x9d/x9f/x83", "MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL");
+-   ("/xf0/x9d/x9f/x84", "MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL");
+-   ("/xf0/x9d/x9f/x85", "MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL");
+-   ("/xf0/x9d/x9f/x86", "MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL");
+-   ("/xf0/x9d/x9f/x87", "MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL");
+-   ("/xf0/x9d/x9f/x88", "MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL");
+-   ("/xf0/x9d/x9f/x89", "MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL");
+    ("/xf0/x9d/x9f/x8a", "MATHEMATICAL BOLD CAPITAL DIGAMMA");
+    ("/xf0/x9d/x9f/x8b", "MATHEMATICAL BOLD SMALL DIGAMMA");
+-   ("/xf0/x9d/x9f/x8e", "MATHEMATICAL BOLD DIGIT ZERO");
+-   ("/xf0/x9d/x9f/x8f", "MATHEMATICAL BOLD DIGIT ONE");
+-   ("/xf0/x9d/x9f/x90", "MATHEMATICAL BOLD DIGIT TWO");
+-   ("/xf0/x9d/x9f/x91", "MATHEMATICAL BOLD DIGIT THREE");
+-   ("/xf0/x9d/x9f/x92", "MATHEMATICAL BOLD DIGIT FOUR");
+-   ("/xf0/x9d/x9f/x93", "MATHEMATICAL BOLD DIGIT FIVE");
+-   ("/xf0/x9d/x9f/x94", "MATHEMATICAL BOLD DIGIT SIX");
+-   ("/xf0/x9d/x9f/x95", "MATHEMATICAL BOLD DIGIT SEVEN");
+-   ("/xf0/x9d/x9f/x96", "MATHEMATICAL BOLD DIGIT EIGHT");
+-   ("/xf0/x9d/x9f/x97", "MATHEMATICAL BOLD DIGIT NINE");
+-   ("/xf0/x9d/x9f/x98", "MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO");
+-   ("/xf0/x9d/x9f/x99", "MATHEMATICAL DOUBLE-STRUCK DIGIT ONE");
+-   ("/xf0/x9d/x9f/x9a", "MATHEMATICAL DOUBLE-STRUCK DIGIT TWO");
+-   ("/xf0/x9d/x9f/x9b", "MATHEMATICAL DOUBLE-STRUCK DIGIT THREE");
+-   ("/xf0/x9d/x9f/x9c", "MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR");
+-   ("/xf0/x9d/x9f/x9d", "MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE");
+-   ("/xf0/x9d/x9f/x9e", "MATHEMATICAL DOUBLE-STRUCK DIGIT SIX");
+-   ("/xf0/x9d/x9f/x9f", "MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN");
+-   ("/xf0/x9d/x9f/xa0", "MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT");
+-   ("/xf0/x9d/x9f/xa1", "MATHEMATICAL DOUBLE-STRUCK DIGIT NINE");
+-   ("/xf0/x9d/x9f/xa2", "MATHEMATICAL SANS-SERIF DIGIT ZERO");
+-   ("/xf0/x9d/x9f/xa3", "MATHEMATICAL SANS-SERIF DIGIT ONE");
+-   ("/xf0/x9d/x9f/xa4", "MATHEMATICAL SANS-SERIF DIGIT TWO");
+-   ("/xf0/x9d/x9f/xa5", "MATHEMATICAL SANS-SERIF DIGIT THREE");
+-   ("/xf0/x9d/x9f/xa6", "MATHEMATICAL SANS-SERIF DIGIT FOUR");
+-   ("/xf0/x9d/x9f/xa7", "MATHEMATICAL SANS-SERIF DIGIT FIVE");
+-   ("/xf0/x9d/x9f/xa8", "MATHEMATICAL SANS-SERIF DIGIT SIX");
+-   ("/xf0/x9d/x9f/xa9", "MATHEMATICAL SANS-SERIF DIGIT SEVEN");
+-   ("/xf0/x9d/x9f/xaa", "MATHEMATICAL SANS-SERIF DIGIT EIGHT");
+-   ("/xf0/x9d/x9f/xab", "MATHEMATICAL SANS-SERIF DIGIT NINE");
+-   ("/xf0/x9d/x9f/xac", "MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO");
+-   ("/xf0/x9d/x9f/xad", "MATHEMATICAL SANS-SERIF BOLD DIGIT ONE");
+-   ("/xf0/x9d/x9f/xae", "MATHEMATICAL SANS-SERIF BOLD DIGIT TWO");
+-   ("/xf0/x9d/x9f/xaf", "MATHEMATICAL SANS-SERIF BOLD DIGIT THREE");
+-   ("/xf0/x9d/x9f/xb0", "MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR");
+-   ("/xf0/x9d/x9f/xb1", "MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE");
+-   ("/xf0/x9d/x9f/xb2", "MATHEMATICAL SANS-SERIF BOLD DIGIT SIX");
+-   ("/xf0/x9d/x9f/xb3", "MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN");
+-   ("/xf0/x9d/x9f/xb4", "MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT");
+-   ("/xf0/x9d/x9f/xb5", "MATHEMATICAL SANS-SERIF BOLD DIGIT NINE");
+-   ("/xf0/x9d/x9f/xb6", "MATHEMATICAL MONOSPACE DIGIT ZERO");
+-   ("/xf0/x9d/x9f/xb7", "MATHEMATICAL MONOSPACE DIGIT ONE");
+-   ("/xf0/x9d/x9f/xb8", "MATHEMATICAL MONOSPACE DIGIT TWO");
+-   ("/xf0/x9d/x9f/xb9", "MATHEMATICAL MONOSPACE DIGIT THREE");
+-   ("/xf0/x9d/x9f/xba", "MATHEMATICAL MONOSPACE DIGIT FOUR");
+-   ("/xf0/x9d/x9f/xbb", "MATHEMATICAL MONOSPACE DIGIT FIVE");
+-   ("/xf0/x9d/x9f/xbc", "MATHEMATICAL MONOSPACE DIGIT SIX");
+-   ("/xf0/x9d/x9f/xbd", "MATHEMATICAL MONOSPACE DIGIT SEVEN");
+-   ("/xf0/x9d/x9f/xbe", "MATHEMATICAL MONOSPACE DIGIT EIGHT");
+-   ("/xf0/x9d/x9f/xbf", "MATHEMATICAL MONOSPACE DIGIT NINE");
+-   ("/xf0/x9f/x80/x80", "MAHJONG TILE EAST WIND");
+-   ("/xf0/x9f/x80/x81", "MAHJONG TILE SOUTH WIND");
+-   ("/xf0/x9f/x80/x82", "MAHJONG TILE WEST WIND");
+-   ("/xf0/x9f/x80/x83", "MAHJONG TILE NORTH WIND");
+-   ("/xf0/x9f/x80/x84", "MAHJONG TILE RED DRAGON");
+-   ("/xf0/x9f/x80/x85", "MAHJONG TILE GREEN DRAGON");
+-   ("/xf0/x9f/x80/x86", "MAHJONG TILE WHITE DRAGON");
+-   ("/xf0/x9f/x80/x87", "MAHJONG TILE ONE OF CHARACTERS");
+-   ("/xf0/x9f/x80/x88", "MAHJONG TILE TWO OF CHARACTERS");
+-   ("/xf0/x9f/x80/x89", "MAHJONG TILE THREE OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8a", "MAHJONG TILE FOUR OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8b", "MAHJONG TILE FIVE OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8c", "MAHJONG TILE SIX OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8d", "MAHJONG TILE SEVEN OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8e", "MAHJONG TILE EIGHT OF CHARACTERS");
+-   ("/xf0/x9f/x80/x8f", "MAHJONG TILE NINE OF CHARACTERS");
+-   ("/xf0/x9f/x80/x90", "MAHJONG TILE ONE OF BAMBOOS");
+-   ("/xf0/x9f/x80/x91", "MAHJONG TILE TWO OF BAMBOOS");
+-   ("/xf0/x9f/x80/x92", "MAHJONG TILE THREE OF BAMBOOS");
+-   ("/xf0/x9f/x80/x93", "MAHJONG TILE FOUR OF BAMBOOS");
+-   ("/xf0/x9f/x80/x94", "MAHJONG TILE FIVE OF BAMBOOS");
+-   ("/xf0/x9f/x80/x95", "MAHJONG TILE SIX OF BAMBOOS");
+-   ("/xf0/x9f/x80/x96", "MAHJONG TILE SEVEN OF BAMBOOS");
+-   ("/xf0/x9f/x80/x97", "MAHJONG TILE EIGHT OF BAMBOOS");
+-   ("/xf0/x9f/x80/x98", "MAHJONG TILE NINE OF BAMBOOS");
+-   ("/xf0/x9f/x80/x99", "MAHJONG TILE ONE OF CIRCLES");
+-   ("/xf0/x9f/x80/x9a", "MAHJONG TILE TWO OF CIRCLES");
+-   ("/xf0/x9f/x80/x9b", "MAHJONG TILE THREE OF CIRCLES");
+-   ("/xf0/x9f/x80/x9c", "MAHJONG TILE FOUR OF CIRCLES");
+-   ("/xf0/x9f/x80/x9d", "MAHJONG TILE FIVE OF CIRCLES");
+-   ("/xf0/x9f/x80/x9e", "MAHJONG TILE SIX OF CIRCLES");
+-   ("/xf0/x9f/x80/x9f", "MAHJONG TILE SEVEN OF CIRCLES");
+-   ("/xf0/x9f/x80/xa0", "MAHJONG TILE EIGHT OF CIRCLES");
+-   ("/xf0/x9f/x80/xa1", "MAHJONG TILE NINE OF CIRCLES");
+-   ("/xf0/x9f/x80/xa2", "MAHJONG TILE PLUM");
+-   ("/xf0/x9f/x80/xa3", "MAHJONG TILE ORCHID");
+-   ("/xf0/x9f/x80/xa4", "MAHJONG TILE BAMBOO");
+-   ("/xf0/x9f/x80/xa5", "MAHJONG TILE CHRYSANTHEMUM");
+-   ("/xf0/x9f/x80/xa6", "MAHJONG TILE SPRING");
+-   ("/xf0/x9f/x80/xa7", "MAHJONG TILE SUMMER");
+-   ("/xf0/x9f/x80/xa8", "MAHJONG TILE AUTUMN");
+-   ("/xf0/x9f/x80/xa9", "MAHJONG TILE WINTER");
+-   ("/xf0/x9f/x80/xaa", "MAHJONG TILE JOKER");
+-   ("/xf0/x9f/x80/xab", "MAHJONG TILE BACK");
+-   ("/xf0/x9f/x80/xb0", "DOMINO TILE HORIZONTAL BACK");
+-   ("/xf0/x9f/x80/xb1", "DOMINO TILE HORIZONTAL-00-00");
+-   ("/xf0/x9f/x80/xb2", "DOMINO TILE HORIZONTAL-00-01");
+-   ("/xf0/x9f/x80/xb3", "DOMINO TILE HORIZONTAL-00-02");
+-   ("/xf0/x9f/x80/xb4", "DOMINO TILE HORIZONTAL-00-03");
+-   ("/xf0/x9f/x80/xb5", "DOMINO TILE HORIZONTAL-00-04");
+-   ("/xf0/x9f/x80/xb6", "DOMINO TILE HORIZONTAL-00-05");
+-   ("/xf0/x9f/x80/xb7", "DOMINO TILE HORIZONTAL-00-06");
+-   ("/xf0/x9f/x80/xb8", "DOMINO TILE HORIZONTAL-01-00");
+-   ("/xf0/x9f/x80/xb9", "DOMINO TILE HORIZONTAL-01-01");
+-   ("/xf0/x9f/x80/xba", "DOMINO TILE HORIZONTAL-01-02");
+-   ("/xf0/x9f/x80/xbb", "DOMINO TILE HORIZONTAL-01-03");
+-   ("/xf0/x9f/x80/xbc", "DOMINO TILE HORIZONTAL-01-04");
+-   ("/xf0/x9f/x80/xbd", "DOMINO TILE HORIZONTAL-01-05");
+-   ("/xf0/x9f/x80/xbe", "DOMINO TILE HORIZONTAL-01-06");
+-   ("/xf0/x9f/x80/xbf", "DOMINO TILE HORIZONTAL-02-00");
+-   ("/xf0/x9f/x81/x80", "DOMINO TILE HORIZONTAL-02-01");
+-   ("/xf0/x9f/x81/x81", "DOMINO TILE HORIZONTAL-02-02");
+-   ("/xf0/x9f/x81/x82", "DOMINO TILE HORIZONTAL-02-03");
+-   ("/xf0/x9f/x81/x83", "DOMINO TILE HORIZONTAL-02-04");
+-   ("/xf0/x9f/x81/x84", "DOMINO TILE HORIZONTAL-02-05");
+-   ("/xf0/x9f/x81/x85", "DOMINO TILE HORIZONTAL-02-06");
+-   ("/xf0/x9f/x81/x86", "DOMINO TILE HORIZONTAL-03-00");
+-   ("/xf0/x9f/x81/x87", "DOMINO TILE HORIZONTAL-03-01");
+-   ("/xf0/x9f/x81/x88", "DOMINO TILE HORIZONTAL-03-02");
+-   ("/xf0/x9f/x81/x89", "DOMINO TILE HORIZONTAL-03-03");
+-   ("/xf0/x9f/x81/x8a", "DOMINO TILE HORIZONTAL-03-04");
+-   ("/xf0/x9f/x81/x8b", "DOMINO TILE HORIZONTAL-03-05");
+-   ("/xf0/x9f/x81/x8c", "DOMINO TILE HORIZONTAL-03-06");
+-   ("/xf0/x9f/x81/x8d", "DOMINO TILE HORIZONTAL-04-00");
+-   ("/xf0/x9f/x81/x8e", "DOMINO TILE HORIZONTAL-04-01");
+-   ("/xf0/x9f/x81/x8f", "DOMINO TILE HORIZONTAL-04-02");
+-   ("/xf0/x9f/x81/x90", "DOMINO TILE HORIZONTAL-04-03");
+-   ("/xf0/x9f/x81/x91", "DOMINO TILE HORIZONTAL-04-04");
+-   ("/xf0/x9f/x81/x92", "DOMINO TILE HORIZONTAL-04-05");
+-   ("/xf0/x9f/x81/x93", "DOMINO TILE HORIZONTAL-04-06");
+-   ("/xf0/x9f/x81/x94", "DOMINO TILE HORIZONTAL-05-00");
+-   ("/xf0/x9f/x81/x95", "DOMINO TILE HORIZONTAL-05-01");
+-   ("/xf0/x9f/x81/x96", "DOMINO TILE HORIZONTAL-05-02");
+-   ("/xf0/x9f/x81/x97", "DOMINO TILE HORIZONTAL-05-03");
+-   ("/xf0/x9f/x81/x98", "DOMINO TILE HORIZONTAL-05-04");
+-   ("/xf0/x9f/x81/x99", "DOMINO TILE HORIZONTAL-05-05");
+-   ("/xf0/x9f/x81/x9a", "DOMINO TILE HORIZONTAL-05-06");
+-   ("/xf0/x9f/x81/x9b", "DOMINO TILE HORIZONTAL-06-00");
+-   ("/xf0/x9f/x81/x9c", "DOMINO TILE HORIZONTAL-06-01");
+-   ("/xf0/x9f/x81/x9d", "DOMINO TILE HORIZONTAL-06-02");
+-   ("/xf0/x9f/x81/x9e", "DOMINO TILE HORIZONTAL-06-03");
+-   ("/xf0/x9f/x81/x9f", "DOMINO TILE HORIZONTAL-06-04");
+-   ("/xf0/x9f/x81/xa0", "DOMINO TILE HORIZONTAL-06-05");
+-   ("/xf0/x9f/x81/xa1", "DOMINO TILE HORIZONTAL-06-06");
+-   ("/xf0/x9f/x81/xa2", "DOMINO TILE VERTICAL BACK");
+-   ("/xf0/x9f/x81/xa3", "DOMINO TILE VERTICAL-00-00");
+-   ("/xf0/x9f/x81/xa4", "DOMINO TILE VERTICAL-00-01");
+-   ("/xf0/x9f/x81/xa5", "DOMINO TILE VERTICAL-00-02");
+-   ("/xf0/x9f/x81/xa6", "DOMINO TILE VERTICAL-00-03");
+-   ("/xf0/x9f/x81/xa7", "DOMINO TILE VERTICAL-00-04");
+-   ("/xf0/x9f/x81/xa8", "DOMINO TILE VERTICAL-00-05");
+-   ("/xf0/x9f/x81/xa9", "DOMINO TILE VERTICAL-00-06");
+-   ("/xf0/x9f/x81/xaa", "DOMINO TILE VERTICAL-01-00");
+-   ("/xf0/x9f/x81/xab", "DOMINO TILE VERTICAL-01-01");
+-   ("/xf0/x9f/x81/xac", "DOMINO TILE VERTICAL-01-02");
+-   ("/xf0/x9f/x81/xad", "DOMINO TILE VERTICAL-01-03");
+-   ("/xf0/x9f/x81/xae", "DOMINO TILE VERTICAL-01-04");
+-   ("/xf0/x9f/x81/xaf", "DOMINO TILE VERTICAL-01-05");
+-   ("/xf0/x9f/x81/xb0", "DOMINO TILE VERTICAL-01-06");
+-   ("/xf0/x9f/x81/xb1", "DOMINO TILE VERTICAL-02-00");
+-   ("/xf0/x9f/x81/xb2", "DOMINO TILE VERTICAL-02-01");
+-   ("/xf0/x9f/x81/xb3", "DOMINO TILE VERTICAL-02-02");
+-   ("/xf0/x9f/x81/xb4", "DOMINO TILE VERTICAL-02-03");
+-   ("/xf0/x9f/x81/xb5", "DOMINO TILE VERTICAL-02-04");
+-   ("/xf0/x9f/x81/xb6", "DOMINO TILE VERTICAL-02-05");
+-   ("/xf0/x9f/x81/xb7", "DOMINO TILE VERTICAL-02-06");
+-   ("/xf0/x9f/x81/xb8", "DOMINO TILE VERTICAL-03-00");
+-   ("/xf0/x9f/x81/xb9", "DOMINO TILE VERTICAL-03-01");
+-   ("/xf0/x9f/x81/xba", "DOMINO TILE VERTICAL-03-02");
+-   ("/xf0/x9f/x81/xbb", "DOMINO TILE VERTICAL-03-03");
+-   ("/xf0/x9f/x81/xbc", "DOMINO TILE VERTICAL-03-04");
+-   ("/xf0/x9f/x81/xbd", "DOMINO TILE VERTICAL-03-05");
+-   ("/xf0/x9f/x81/xbe", "DOMINO TILE VERTICAL-03-06");
+-   ("/xf0/x9f/x81/xbf", "DOMINO TILE VERTICAL-04-00");
+-   ("/xf0/x9f/x82/x80", "DOMINO TILE VERTICAL-04-01");
+-   ("/xf0/x9f/x82/x81", "DOMINO TILE VERTICAL-04-02");
+-   ("/xf0/x9f/x82/x82", "DOMINO TILE VERTICAL-04-03");
+-   ("/xf0/x9f/x82/x83", "DOMINO TILE VERTICAL-04-04");
+-   ("/xf0/x9f/x82/x84", "DOMINO TILE VERTICAL-04-05");
+-   ("/xf0/x9f/x82/x85", "DOMINO TILE VERTICAL-04-06");
+-   ("/xf0/x9f/x82/x86", "DOMINO TILE VERTICAL-05-00");
+-   ("/xf0/x9f/x82/x87", "DOMINO TILE VERTICAL-05-01");
+-   ("/xf0/x9f/x82/x88", "DOMINO TILE VERTICAL-05-02");
+-   ("/xf0/x9f/x82/x89", "DOMINO TILE VERTICAL-05-03");
+-   ("/xf0/x9f/x82/x8a", "DOMINO TILE VERTICAL-05-04");
+-   ("/xf0/x9f/x82/x8b", "DOMINO TILE VERTICAL-05-05");
+-   ("/xf0/x9f/x82/x8c", "DOMINO TILE VERTICAL-05-06");
+-   ("/xf0/x9f/x82/x8d", "DOMINO TILE VERTICAL-06-00");
+-   ("/xf0/x9f/x82/x8e", "DOMINO TILE VERTICAL-06-01");
+-   ("/xf0/x9f/x82/x8f", "DOMINO TILE VERTICAL-06-02");
+-   ("/xf0/x9f/x82/x90", "DOMINO TILE VERTICAL-06-03");
+-   ("/xf0/x9f/x82/x91", "DOMINO TILE VERTICAL-06-04");
+-   ("/xf0/x9f/x82/x92", "DOMINO TILE VERTICAL-06-05");
+-   ("/xf0/x9f/x82/x93", "DOMINO TILE VERTICAL-06-06");
+-   ("/xf0/xa0/x80/x80", "<CJK>");
+-   ("/xf0/xa0/x81/x80", "<CJK>");
+-   ("/xf0/xa0/x82/x80", "<CJK>");
+-   ("/xf0/xa0/x83/x80", "<CJK>");
+-   ("/xf0/xa0/x84/x80", "<CJK>");
+-   ("/xf0/xa0/x85/x80", "<CJK>");
+-   ("/xf0/xa0/x86/x80", "<CJK>");
+-   ("/xf0/xa0/x87/x80", "<CJK>");
+-   ("/xf0/xa0/x88/x80", "<CJK>");
+-   ("/xf0/xa0/x89/x80", "<CJK>");
+-   ("/xf0/xa0/x8a/x80", "<CJK>");
+-   ("/xf0/xa0/x8b/x80", "<CJK>");
+-   ("/xf0/xa0/x8c/x80", "<CJK>");
+-   ("/xf0/xa0/x8d/x80", "<CJK>");
+-   ("/xf0/xa0/x8e/x80", "<CJK>");
+-   ("/xf0/xa0/x8f/x80", "<CJK>");
+-   ("/xf0/xa0/x90/x80", "<CJK>");
+-   ("/xf0/xa0/x91/x80", "<CJK>");
+-   ("/xf0/xa0/x92/x80", "<CJK>");
+-   ("/xf0/xa0/x93/x80", "<CJK>");
+-   ("/xf0/xa0/x94/x80", "<CJK>");
+-   ("/xf0/xa0/x95/x80", "<CJK>");
+-   ("/xf0/xa0/x96/x80", "<CJK>");
+-   ("/xf0/xa0/x97/x80", "<CJK>");
+-   ("/xf0/xa0/x98/x80", "<CJK>");
+-   ("/xf0/xa0/x99/x80", "<CJK>");
+-   ("/xf0/xa0/x9a/x80", "<CJK>");
+-   ("/xf0/xa0/x9b/x80", "<CJK>");
+-   ("/xf0/xa0/x9c/x80", "<CJK>");
+-   ("/xf0/xa0/x9d/x80", "<CJK>");
+-   ("/xf0/xa0/x9e/x80", "<CJK>");
+-   ("/xf0/xa0/x9f/x80", "<CJK>");
+-   ("/xf0/xa0/xa0/x80", "<CJK>");
+-   ("/xf0/xa0/xa1/x80", "<CJK>");
+-   ("/xf0/xa0/xa2/x80", "<CJK>");
+-   ("/xf0/xa0/xa3/x80", "<CJK>");
+-   ("/xf0/xa0/xa4/x80", "<CJK>");
+-   ("/xf0/xa0/xa5/x80", "<CJK>");
+-   ("/xf0/xa0/xa6/x80", "<CJK>");
+-   ("/xf0/xa0/xa7/x80", "<CJK>");
+-   ("/xf0/xa0/xa8/x80", "<CJK>");
+-   ("/xf0/xa0/xa9/x80", "<CJK>");
+-   ("/xf0/xa0/xaa/x80", "<CJK>");
+-   ("/xf0/xa0/xab/x80", "<CJK>");
+-   ("/xf0/xa0/xac/x80", "<CJK>");
+-   ("/xf0/xa0/xad/x80", "<CJK>");
+-   ("/xf0/xa0/xae/x80", "<CJK>");
+-   ("/xf0/xa0/xaf/x80", "<CJK>");
+-   ("/xf0/xa0/xb0/x80", "<CJK>");
+-   ("/xf0/xa0/xb1/x80", "<CJK>");
+-   ("/xf0/xa0/xb2/x80", "<CJK>");
+-   ("/xf0/xa0/xb3/x80", "<CJK>");
+-   ("/xf0/xa0/xb4/x80", "<CJK>");
+-   ("/xf0/xa0/xb5/x80", "<CJK>");
+-   ("/xf0/xa0/xb6/x80", "<CJK>");
+-   ("/xf0/xa0/xb7/x80", "<CJK>");
+-   ("/xf0/xa0/xb8/x80", "<CJK>");
+-   ("/xf0/xa0/xb9/x80", "<CJK>");
+-   ("/xf0/xa0/xba/x80", "<CJK>");
+-   ("/xf0/xa0/xbb/x80", "<CJK>");
+-   ("/xf0/xa0/xbc/x80", "<CJK>");
+-   ("/xf0/xa0/xbd/x80", "<CJK>");
+-   ("/xf0/xa0/xbe/x80", "<CJK>");
+-   ("/xf0/xa0/xbf/x80", "<CJK>");
+-   ("/xf0/xa1/x80/x80", "<CJK>");
+-   ("/xf0/xa1/x81/x80", "<CJK>");
+-   ("/xf0/xa1/x82/x80", "<CJK>");
+-   ("/xf0/xa1/x83/x80", "<CJK>");
+-   ("/xf0/xa1/x84/x80", "<CJK>");
+-   ("/xf0/xa1/x85/x80", "<CJK>");
+-   ("/xf0/xa1/x86/x80", "<CJK>");
+-   ("/xf0/xa1/x87/x80", "<CJK>");
+-   ("/xf0/xa1/x88/x80", "<CJK>");
+-   ("/xf0/xa1/x89/x80", "<CJK>");
+-   ("/xf0/xa1/x8a/x80", "<CJK>");
+-   ("/xf0/xa1/x8b/x80", "<CJK>");
+-   ("/xf0/xa1/x8c/x80", "<CJK>");
+-   ("/xf0/xa1/x8d/x80", "<CJK>");
+-   ("/xf0/xa1/x8e/x80", "<CJK>");
+-   ("/xf0/xa1/x8f/x80", "<CJK>");
+-   ("/xf0/xa1/x90/x80", "<CJK>");
+-   ("/xf0/xa1/x91/x80", "<CJK>");
+-   ("/xf0/xa1/x92/x80", "<CJK>");
+-   ("/xf0/xa1/x93/x80", "<CJK>");
+-   ("/xf0/xa1/x94/x80", "<CJK>");
+-   ("/xf0/xa1/x95/x80", "<CJK>");
+-   ("/xf0/xa1/x96/x80", "<CJK>");
+-   ("/xf0/xa1/x97/x80", "<CJK>");
+-   ("/xf0/xa1/x98/x80", "<CJK>");
+-   ("/xf0/xa1/x99/x80", "<CJK>");
+-   ("/xf0/xa1/x9a/x80", "<CJK>");
+-   ("/xf0/xa1/x9b/x80", "<CJK>");
+-   ("/xf0/xa1/x9c/x80", "<CJK>");
+-   ("/xf0/xa1/x9d/x80", "<CJK>");
+-   ("/xf0/xa1/x9e/x80", "<CJK>");
+-   ("/xf0/xa1/x9f/x80", "<CJK>");
+-   ("/xf0/xa1/xa0/x80", "<CJK>");
+-   ("/xf0/xa1/xa1/x80", "<CJK>");
+-   ("/xf0/xa1/xa2/x80", "<CJK>");
+-   ("/xf0/xa1/xa3/x80", "<CJK>");
+-   ("/xf0/xa1/xa4/x80", "<CJK>");
+-   ("/xf0/xa1/xa5/x80", "<CJK>");
+-   ("/xf0/xa1/xa6/x80", "<CJK>");
+-   ("/xf0/xa1/xa7/x80", "<CJK>");
+-   ("/xf0/xa1/xa8/x80", "<CJK>");
+-   ("/xf0/xa1/xa9/x80", "<CJK>");
+-   ("/xf0/xa1/xaa/x80", "<CJK>");
+-   ("/xf0/xa1/xab/x80", "<CJK>");
+-   ("/xf0/xa1/xac/x80", "<CJK>");
+-   ("/xf0/xa1/xad/x80", "<CJK>");
+-   ("/xf0/xa1/xae/x80", "<CJK>");
+-   ("/xf0/xa1/xaf/x80", "<CJK>");
+-   ("/xf0/xa1/xb0/x80", "<CJK>");
+-   ("/xf0/xa1/xb1/x80", "<CJK>");
+-   ("/xf0/xa1/xb2/x80", "<CJK>");
+-   ("/xf0/xa1/xb3/x80", "<CJK>");
+-   ("/xf0/xa1/xb4/x80", "<CJK>");
+-   ("/xf0/xa1/xb5/x80", "<CJK>");
+-   ("/xf0/xa1/xb6/x80", "<CJK>");
+-   ("/xf0/xa1/xb7/x80", "<CJK>");
+-   ("/xf0/xa1/xb8/x80", "<CJK>");
+-   ("/xf0/xa1/xb9/x80", "<CJK>");
+-   ("/xf0/xa1/xba/x80", "<CJK>");
+-   ("/xf0/xa1/xbb/x80", "<CJK>");
+-   ("/xf0/xa1/xbc/x80", "<CJK>");
+-   ("/xf0/xa1/xbd/x80", "<CJK>");
+-   ("/xf0/xa1/xbe/x80", "<CJK>");
+-   ("/xf0/xa1/xbf/x80", "<CJK>");
+-   ("/xf0/xa2/x80/x80", "<CJK>");
+-   ("/xf0/xa2/x81/x80", "<CJK>");
+-   ("/xf0/xa2/x82/x80", "<CJK>");
+-   ("/xf0/xa2/x83/x80", "<CJK>");
+-   ("/xf0/xa2/x84/x80", "<CJK>");
+-   ("/xf0/xa2/x85/x80", "<CJK>");
+-   ("/xf0/xa2/x86/x80", "<CJK>");
+-   ("/xf0/xa2/x87/x80", "<CJK>");
+-   ("/xf0/xa2/x88/x80", "<CJK>");
+-   ("/xf0/xa2/x89/x80", "<CJK>");
+-   ("/xf0/xa2/x8a/x80", "<CJK>");
+-   ("/xf0/xa2/x8b/x80", "<CJK>");
+-   ("/xf0/xa2/x8c/x80", "<CJK>");
+-   ("/xf0/xa2/x8d/x80", "<CJK>");
+-   ("/xf0/xa2/x8e/x80", "<CJK>");
+-   ("/xf0/xa2/x8f/x80", "<CJK>");
+-   ("/xf0/xa2/x90/x80", "<CJK>");
+-   ("/xf0/xa2/x91/x80", "<CJK>");
+-   ("/xf0/xa2/x92/x80", "<CJK>");
+-   ("/xf0/xa2/x93/x80", "<CJK>");
+-   ("/xf0/xa2/x94/x80", "<CJK>");
+-   ("/xf0/xa2/x95/x80", "<CJK>");
+-   ("/xf0/xa2/x96/x80", "<CJK>");
+-   ("/xf0/xa2/x97/x80", "<CJK>");
+-   ("/xf0/xa2/x98/x80", "<CJK>");
+-   ("/xf0/xa2/x99/x80", "<CJK>");
+-   ("/xf0/xa2/x9a/x80", "<CJK>");
+-   ("/xf0/xa2/x9b/x80", "<CJK>");
+-   ("/xf0/xa2/x9c/x80", "<CJK>");
+-   ("/xf0/xa2/x9d/x80", "<CJK>");
+-   ("/xf0/xa2/x9e/x80", "<CJK>");
+-   ("/xf0/xa2/x9f/x80", "<CJK>");
+-   ("/xf0/xa2/xa0/x80", "<CJK>");
+-   ("/xf0/xa2/xa1/x80", "<CJK>");
+-   ("/xf0/xa2/xa2/x80", "<CJK>");
+-   ("/xf0/xa2/xa3/x80", "<CJK>");
+-   ("/xf0/xa2/xa4/x80", "<CJK>");
+-   ("/xf0/xa2/xa5/x80", "<CJK>");
+-   ("/xf0/xa2/xa6/x80", "<CJK>");
+-   ("/xf0/xa2/xa7/x80", "<CJK>");
+-   ("/xf0/xa2/xa8/x80", "<CJK>");
+-   ("/xf0/xa2/xa9/x80", "<CJK>");
+-   ("/xf0/xa2/xaa/x80", "<CJK>");
+-   ("/xf0/xa2/xab/x80", "<CJK>");
+-   ("/xf0/xa2/xac/x80", "<CJK>");
+-   ("/xf0/xa2/xad/x80", "<CJK>");
+-   ("/xf0/xa2/xae/x80", "<CJK>");
+-   ("/xf0/xa2/xaf/x80", "<CJK>");
+-   ("/xf0/xa2/xb0/x80", "<CJK>");
+-   ("/xf0/xa2/xb1/x80", "<CJK>");
+-   ("/xf0/xa2/xb2/x80", "<CJK>");
+-   ("/xf0/xa2/xb3/x80", "<CJK>");
+-   ("/xf0/xa2/xb4/x80", "<CJK>");
+-   ("/xf0/xa2/xb5/x80", "<CJK>");
+-   ("/xf0/xa2/xb6/x80", "<CJK>");
+-   ("/xf0/xa2/xb7/x80", "<CJK>");
+-   ("/xf0/xa2/xb8/x80", "<CJK>");
+-   ("/xf0/xa2/xb9/x80", "<CJK>");
+-   ("/xf0/xa2/xba/x80", "<CJK>");
+-   ("/xf0/xa2/xbb/x80", "<CJK>");
+-   ("/xf0/xa2/xbc/x80", "<CJK>");
+-   ("/xf0/xa2/xbd/x80", "<CJK>");
+-   ("/xf0/xa2/xbe/x80", "<CJK>");
+-   ("/xf0/xa2/xbf/x80", "<CJK>");
+-   ("/xf0/xa3/x80/x80", "<CJK>");
+-   ("/xf0/xa3/x81/x80", "<CJK>");
+-   ("/xf0/xa3/x82/x80", "<CJK>");
+-   ("/xf0/xa3/x83/x80", "<CJK>");
+-   ("/xf0/xa3/x84/x80", "<CJK>");
+-   ("/xf0/xa3/x85/x80", "<CJK>");
+-   ("/xf0/xa3/x86/x80", "<CJK>");
+-   ("/xf0/xa3/x87/x80", "<CJK>");
+-   ("/xf0/xa3/x88/x80", "<CJK>");
+-   ("/xf0/xa3/x89/x80", "<CJK>");
+-   ("/xf0/xa3/x8a/x80", "<CJK>");
+-   ("/xf0/xa3/x8b/x80", "<CJK>");
+-   ("/xf0/xa3/x8c/x80", "<CJK>");
+-   ("/xf0/xa3/x8d/x80", "<CJK>");
+-   ("/xf0/xa3/x8e/x80", "<CJK>");
+-   ("/xf0/xa3/x8f/x80", "<CJK>");
+-   ("/xf0/xa3/x90/x80", "<CJK>");
+-   ("/xf0/xa3/x91/x80", "<CJK>");
+-   ("/xf0/xa3/x92/x80", "<CJK>");
+-   ("/xf0/xa3/x93/x80", "<CJK>");
+-   ("/xf0/xa3/x94/x80", "<CJK>");
+-   ("/xf0/xa3/x95/x80", "<CJK>");
+-   ("/xf0/xa3/x96/x80", "<CJK>");
+-   ("/xf0/xa3/x97/x80", "<CJK>");
+-   ("/xf0/xa3/x98/x80", "<CJK>");
+-   ("/xf0/xa3/x99/x80", "<CJK>");
+-   ("/xf0/xa3/x9a/x80", "<CJK>");
+-   ("/xf0/xa3/x9b/x80", "<CJK>");
+-   ("/xf0/xa3/x9c/x80", "<CJK>");
+-   ("/xf0/xa3/x9d/x80", "<CJK>");
+-   ("/xf0/xa3/x9e/x80", "<CJK>");
+-   ("/xf0/xa3/x9f/x80", "<CJK>");
+-   ("/xf0/xa3/xa0/x80", "<CJK>");
+-   ("/xf0/xa3/xa1/x80", "<CJK>");
+-   ("/xf0/xa3/xa2/x80", "<CJK>");
+-   ("/xf0/xa3/xa3/x80", "<CJK>");
+-   ("/xf0/xa3/xa4/x80", "<CJK>");
+-   ("/xf0/xa3/xa5/x80", "<CJK>");
+-   ("/xf0/xa3/xa6/x80", "<CJK>");
+-   ("/xf0/xa3/xa7/x80", "<CJK>");
+-   ("/xf0/xa3/xa8/x80", "<CJK>");
+-   ("/xf0/xa3/xa9/x80", "<CJK>");
+-   ("/xf0/xa3/xaa/x80", "<CJK>");
+-   ("/xf0/xa3/xab/x80", "<CJK>");
+-   ("/xf0/xa3/xac/x80", "<CJK>");
+-   ("/xf0/xa3/xad/x80", "<CJK>");
+-   ("/xf0/xa3/xae/x80", "<CJK>");
+-   ("/xf0/xa3/xaf/x80", "<CJK>");
+-   ("/xf0/xa3/xb0/x80", "<CJK>");
+-   ("/xf0/xa3/xb1/x80", "<CJK>");
+-   ("/xf0/xa3/xb2/x80", "<CJK>");
+-   ("/xf0/xa3/xb3/x80", "<CJK>");
+-   ("/xf0/xa3/xb4/x80", "<CJK>");
+-   ("/xf0/xa3/xb5/x80", "<CJK>");
+-   ("/xf0/xa3/xb6/x80", "<CJK>");
+-   ("/xf0/xa3/xb7/x80", "<CJK>");
+-   ("/xf0/xa3/xb8/x80", "<CJK>");
+-   ("/xf0/xa3/xb9/x80", "<CJK>");
+-   ("/xf0/xa3/xba/x80", "<CJK>");
+-   ("/xf0/xa3/xbb/x80", "<CJK>");
+-   ("/xf0/xa3/xbc/x80", "<CJK>");
+-   ("/xf0/xa3/xbd/x80", "<CJK>");
+-   ("/xf0/xa3/xbe/x80", "<CJK>");
+-   ("/xf0/xa3/xbf/x80", "<CJK>");
+-   ("/xf0/xa4/x80/x80", "<CJK>");
+-   ("/xf0/xa4/x81/x80", "<CJK>");
+-   ("/xf0/xa4/x82/x80", "<CJK>");
+-   ("/xf0/xa4/x83/x80", "<CJK>");
+-   ("/xf0/xa4/x84/x80", "<CJK>");
+-   ("/xf0/xa4/x85/x80", "<CJK>");
+-   ("/xf0/xa4/x86/x80", "<CJK>");
+-   ("/xf0/xa4/x87/x80", "<CJK>");
+-   ("/xf0/xa4/x88/x80", "<CJK>");
+-   ("/xf0/xa4/x89/x80", "<CJK>");
+-   ("/xf0/xa4/x8a/x80", "<CJK>");
+-   ("/xf0/xa4/x8b/x80", "<CJK>");
+-   ("/xf0/xa4/x8c/x80", "<CJK>");
+-   ("/xf0/xa4/x8d/x80", "<CJK>");
+-   ("/xf0/xa4/x8e/x80", "<CJK>");
+-   ("/xf0/xa4/x8f/x80", "<CJK>");
+-   ("/xf0/xa4/x90/x80", "<CJK>");
+-   ("/xf0/xa4/x91/x80", "<CJK>");
+-   ("/xf0/xa4/x92/x80", "<CJK>");
+-   ("/xf0/xa4/x93/x80", "<CJK>");
+-   ("/xf0/xa4/x94/x80", "<CJK>");
+-   ("/xf0/xa4/x95/x80", "<CJK>");
+-   ("/xf0/xa4/x96/x80", "<CJK>");
+-   ("/xf0/xa4/x97/x80", "<CJK>");
+-   ("/xf0/xa4/x98/x80", "<CJK>");
+-   ("/xf0/xa4/x99/x80", "<CJK>");
+-   ("/xf0/xa4/x9a/x80", "<CJK>");
+-   ("/xf0/xa4/x9b/x80", "<CJK>");
+-   ("/xf0/xa4/x9c/x80", "<CJK>");
+-   ("/xf0/xa4/x9d/x80", "<CJK>");
+-   ("/xf0/xa4/x9e/x80", "<CJK>");
+-   ("/xf0/xa4/x9f/x80", "<CJK>");
+-   ("/xf0/xa4/xa0/x80", "<CJK>");
+-   ("/xf0/xa4/xa1/x80", "<CJK>");
+-   ("/xf0/xa4/xa2/x80", "<CJK>");
+-   ("/xf0/xa4/xa3/x80", "<CJK>");
+-   ("/xf0/xa4/xa4/x80", "<CJK>");
+-   ("/xf0/xa4/xa5/x80", "<CJK>");
+-   ("/xf0/xa4/xa6/x80", "<CJK>");
+-   ("/xf0/xa4/xa7/x80", "<CJK>");
+-   ("/xf0/xa4/xa8/x80", "<CJK>");
+-   ("/xf0/xa4/xa9/x80", "<CJK>");
+-   ("/xf0/xa4/xaa/x80", "<CJK>");
+-   ("/xf0/xa4/xab/x80", "<CJK>");
+-   ("/xf0/xa4/xac/x80", "<CJK>");
+-   ("/xf0/xa4/xad/x80", "<CJK>");
+-   ("/xf0/xa4/xae/x80", "<CJK>");
+-   ("/xf0/xa4/xaf/x80", "<CJK>");
+-   ("/xf0/xa4/xb0/x80", "<CJK>");
+-   ("/xf0/xa4/xb1/x80", "<CJK>");
+-   ("/xf0/xa4/xb2/x80", "<CJK>");
+-   ("/xf0/xa4/xb3/x80", "<CJK>");
+-   ("/xf0/xa4/xb4/x80", "<CJK>");
+-   ("/xf0/xa4/xb5/x80", "<CJK>");
+-   ("/xf0/xa4/xb6/x80", "<CJK>");
+-   ("/xf0/xa4/xb7/x80", "<CJK>");
+-   ("/xf0/xa4/xb8/x80", "<CJK>");
+-   ("/xf0/xa4/xb9/x80", "<CJK>");
+-   ("/xf0/xa4/xba/x80", "<CJK>");
+-   ("/xf0/xa4/xbb/x80", "<CJK>");
+-   ("/xf0/xa4/xbc/x80", "<CJK>");
+-   ("/xf0/xa4/xbd/x80", "<CJK>");
+-   ("/xf0/xa4/xbe/x80", "<CJK>");
+-   ("/xf0/xa4/xbf/x80", "<CJK>");
+-   ("/xf0/xa5/x80/x80", "<CJK>");
+-   ("/xf0/xa5/x81/x80", "<CJK>");
+-   ("/xf0/xa5/x82/x80", "<CJK>");
+-   ("/xf0/xa5/x83/x80", "<CJK>");
+-   ("/xf0/xa5/x84/x80", "<CJK>");
+-   ("/xf0/xa5/x85/x80", "<CJK>");
+-   ("/xf0/xa5/x86/x80", "<CJK>");
+-   ("/xf0/xa5/x87/x80", "<CJK>");
+-   ("/xf0/xa5/x88/x80", "<CJK>");
+-   ("/xf0/xa5/x89/x80", "<CJK>");
+-   ("/xf0/xa5/x8a/x80", "<CJK>");
+-   ("/xf0/xa5/x8b/x80", "<CJK>");
+-   ("/xf0/xa5/x8c/x80", "<CJK>");
+-   ("/xf0/xa5/x8d/x80", "<CJK>");
+-   ("/xf0/xa5/x8e/x80", "<CJK>");
+-   ("/xf0/xa5/x8f/x80", "<CJK>");
+-   ("/xf0/xa5/x90/x80", "<CJK>");
+-   ("/xf0/xa5/x91/x80", "<CJK>");
+-   ("/xf0/xa5/x92/x80", "<CJK>");
+-   ("/xf0/xa5/x93/x80", "<CJK>");
+-   ("/xf0/xa5/x94/x80", "<CJK>");
+-   ("/xf0/xa5/x95/x80", "<CJK>");
+-   ("/xf0/xa5/x96/x80", "<CJK>");
+-   ("/xf0/xa5/x97/x80", "<CJK>");
+-   ("/xf0/xa5/x98/x80", "<CJK>");
+-   ("/xf0/xa5/x99/x80", "<CJK>");
+-   ("/xf0/xa5/x9a/x80", "<CJK>");
+-   ("/xf0/xa5/x9b/x80", "<CJK>");
+-   ("/xf0/xa5/x9c/x80", "<CJK>");
+-   ("/xf0/xa5/x9d/x80", "<CJK>");
+-   ("/xf0/xa5/x9e/x80", "<CJK>");
+-   ("/xf0/xa5/x9f/x80", "<CJK>");
+-   ("/xf0/xa5/xa0/x80", "<CJK>");
+-   ("/xf0/xa5/xa1/x80", "<CJK>");
+-   ("/xf0/xa5/xa2/x80", "<CJK>");
+-   ("/xf0/xa5/xa3/x80", "<CJK>");
+-   ("/xf0/xa5/xa4/x80", "<CJK>");
+-   ("/xf0/xa5/xa5/x80", "<CJK>");
+-   ("/xf0/xa5/xa6/x80", "<CJK>");
+-   ("/xf0/xa5/xa7/x80", "<CJK>");
+-   ("/xf0/xa5/xa8/x80", "<CJK>");
+-   ("/xf0/xa5/xa9/x80", "<CJK>");
+-   ("/xf0/xa5/xaa/x80", "<CJK>");
+-   ("/xf0/xa5/xab/x80", "<CJK>");
+-   ("/xf0/xa5/xac/x80", "<CJK>");
+-   ("/xf0/xa5/xad/x80", "<CJK>");
+-   ("/xf0/xa5/xae/x80", "<CJK>");
+-   ("/xf0/xa5/xaf/x80", "<CJK>");
+-   ("/xf0/xa5/xb0/x80", "<CJK>");
+-   ("/xf0/xa5/xb1/x80", "<CJK>");
+-   ("/xf0/xa5/xb2/x80", "<CJK>");
+-   ("/xf0/xa5/xb3/x80", "<CJK>");
+-   ("/xf0/xa5/xb4/x80", "<CJK>");
+-   ("/xf0/xa5/xb5/x80", "<CJK>");
+-   ("/xf0/xa5/xb6/x80", "<CJK>");
+-   ("/xf0/xa5/xb7/x80", "<CJK>");
+-   ("/xf0/xa5/xb8/x80", "<CJK>");
+-   ("/xf0/xa5/xb9/x80", "<CJK>");
+-   ("/xf0/xa5/xba/x80", "<CJK>");
+-   ("/xf0/xa5/xbb/x80", "<CJK>");
+-   ("/xf0/xa5/xbc/x80", "<CJK>");
+-   ("/xf0/xa5/xbd/x80", "<CJK>");
+-   ("/xf0/xa5/xbe/x80", "<CJK>");
+-   ("/xf0/xa5/xbf/x80", "<CJK>");
+-   ("/xf0/xa6/x80/x80", "<CJK>");
+-   ("/xf0/xa6/x81/x80", "<CJK>");
+-   ("/xf0/xa6/x82/x80", "<CJK>");
+-   ("/xf0/xa6/x83/x80", "<CJK>");
+-   ("/xf0/xa6/x84/x80", "<CJK>");
+-   ("/xf0/xa6/x85/x80", "<CJK>");
+-   ("/xf0/xa6/x86/x80", "<CJK>");
+-   ("/xf0/xa6/x87/x80", "<CJK>");
+-   ("/xf0/xa6/x88/x80", "<CJK>");
+-   ("/xf0/xa6/x89/x80", "<CJK>");
+-   ("/xf0/xa6/x8a/x80", "<CJK>");
+-   ("/xf0/xa6/x8b/x80", "<CJK>");
+-   ("/xf0/xa6/x8c/x80", "<CJK>");
+-   ("/xf0/xa6/x8d/x80", "<CJK>");
+-   ("/xf0/xa6/x8e/x80", "<CJK>");
+-   ("/xf0/xa6/x8f/x80", "<CJK>");
+-   ("/xf0/xa6/x90/x80", "<CJK>");
+-   ("/xf0/xa6/x91/x80", "<CJK>");
+-   ("/xf0/xa6/x92/x80", "<CJK>");
+-   ("/xf0/xa6/x93/x80", "<CJK>");
+-   ("/xf0/xa6/x94/x80", "<CJK>");
+-   ("/xf0/xa6/x95/x80", "<CJK>");
+-   ("/xf0/xa6/x96/x80", "<CJK>");
+-   ("/xf0/xa6/x97/x80", "<CJK>");
+-   ("/xf0/xa6/x98/x80", "<CJK>");
+-   ("/xf0/xa6/x99/x80", "<CJK>");
+-   ("/xf0/xa6/x9a/x80", "<CJK>");
+-   ("/xf0/xa6/x9b/x80", "<CJK>");
+-   ("/xf0/xa6/x9c/x80", "<CJK>");
+-   ("/xf0/xa6/x9d/x80", "<CJK>");
+-   ("/xf0/xa6/x9e/x80", "<CJK>");
+-   ("/xf0/xa6/x9f/x80", "<CJK>");
+-   ("/xf0/xa6/xa0/x80", "<CJK>");
+-   ("/xf0/xa6/xa1/x80", "<CJK>");
+-   ("/xf0/xa6/xa2/x80", "<CJK>");
+-   ("/xf0/xa6/xa3/x80", "<CJK>");
+-   ("/xf0/xa6/xa4/x80", "<CJK>");
+-   ("/xf0/xa6/xa5/x80", "<CJK>");
+-   ("/xf0/xa6/xa6/x80", "<CJK>");
+-   ("/xf0/xa6/xa7/x80", "<CJK>");
+-   ("/xf0/xa6/xa8/x80", "<CJK>");
+-   ("/xf0/xa6/xa9/x80", "<CJK>");
+-   ("/xf0/xa6/xaa/x80", "<CJK>");
+-   ("/xf0/xa6/xab/x80", "<CJK>");
+-   ("/xf0/xa6/xac/x80", "<CJK>");
+-   ("/xf0/xa6/xad/x80", "<CJK>");
+-   ("/xf0/xa6/xae/x80", "<CJK>");
+-   ("/xf0/xa6/xaf/x80", "<CJK>");
+-   ("/xf0/xa6/xb0/x80", "<CJK>");
+-   ("/xf0/xa6/xb1/x80", "<CJK>");
+-   ("/xf0/xa6/xb2/x80", "<CJK>");
+-   ("/xf0/xa6/xb3/x80", "<CJK>");
+-   ("/xf0/xa6/xb4/x80", "<CJK>");
+-   ("/xf0/xa6/xb5/x80", "<CJK>");
+-   ("/xf0/xa6/xb6/x80", "<CJK>");
+-   ("/xf0/xa6/xb7/x80", "<CJK>");
+-   ("/xf0/xa6/xb8/x80", "<CJK>");
+-   ("/xf0/xa6/xb9/x80", "<CJK>");
+-   ("/xf0/xa6/xba/x80", "<CJK>");
+-   ("/xf0/xa6/xbb/x80", "<CJK>");
+-   ("/xf0/xa6/xbc/x80", "<CJK>");
+-   ("/xf0/xa6/xbd/x80", "<CJK>");
+-   ("/xf0/xa6/xbe/x80", "<CJK>");
+-   ("/xf0/xa6/xbf/x80", "<CJK>");
+-   ("/xf0/xa7/x80/x80", "<CJK>");
+-   ("/xf0/xa7/x81/x80", "<CJK>");
+-   ("/xf0/xa7/x82/x80", "<CJK>");
+-   ("/xf0/xa7/x83/x80", "<CJK>");
+-   ("/xf0/xa7/x84/x80", "<CJK>");
+-   ("/xf0/xa7/x85/x80", "<CJK>");
+-   ("/xf0/xa7/x86/x80", "<CJK>");
+-   ("/xf0/xa7/x87/x80", "<CJK>");
+-   ("/xf0/xa7/x88/x80", "<CJK>");
+-   ("/xf0/xa7/x89/x80", "<CJK>");
+-   ("/xf0/xa7/x8a/x80", "<CJK>");
+-   ("/xf0/xa7/x8b/x80", "<CJK>");
+-   ("/xf0/xa7/x8c/x80", "<CJK>");
+-   ("/xf0/xa7/x8d/x80", "<CJK>");
+-   ("/xf0/xa7/x8e/x80", "<CJK>");
+-   ("/xf0/xa7/x8f/x80", "<CJK>");
+-   ("/xf0/xa7/x90/x80", "<CJK>");
+-   ("/xf0/xa7/x91/x80", "<CJK>");
+-   ("/xf0/xa7/x92/x80", "<CJK>");
+-   ("/xf0/xa7/x93/x80", "<CJK>");
+-   ("/xf0/xa7/x94/x80", "<CJK>");
+-   ("/xf0/xa7/x95/x80", "<CJK>");
+-   ("/xf0/xa7/x96/x80", "<CJK>");
+-   ("/xf0/xa7/x97/x80", "<CJK>");
+-   ("/xf0/xa7/x98/x80", "<CJK>");
+-   ("/xf0/xa7/x99/x80", "<CJK>");
+-   ("/xf0/xa7/x9a/x80", "<CJK>");
+-   ("/xf0/xa7/x9b/x80", "<CJK>");
+-   ("/xf0/xa7/x9c/x80", "<CJK>");
+-   ("/xf0/xa7/x9d/x80", "<CJK>");
+-   ("/xf0/xa7/x9e/x80", "<CJK>");
+-   ("/xf0/xa7/x9f/x80", "<CJK>");
+-   ("/xf0/xa7/xa0/x80", "<CJK>");
+-   ("/xf0/xa7/xa1/x80", "<CJK>");
+-   ("/xf0/xa7/xa2/x80", "<CJK>");
+-   ("/xf0/xa7/xa3/x80", "<CJK>");
+-   ("/xf0/xa7/xa4/x80", "<CJK>");
+-   ("/xf0/xa7/xa5/x80", "<CJK>");
+-   ("/xf0/xa7/xa6/x80", "<CJK>");
+-   ("/xf0/xa7/xa7/x80", "<CJK>");
+-   ("/xf0/xa7/xa8/x80", "<CJK>");
+-   ("/xf0/xa7/xa9/x80", "<CJK>");
+-   ("/xf0/xa7/xaa/x80", "<CJK>");
+-   ("/xf0/xa7/xab/x80", "<CJK>");
+-   ("/xf0/xa7/xac/x80", "<CJK>");
+-   ("/xf0/xa7/xad/x80", "<CJK>");
+-   ("/xf0/xa7/xae/x80", "<CJK>");
+-   ("/xf0/xa7/xaf/x80", "<CJK>");
+-   ("/xf0/xa7/xb0/x80", "<CJK>");
+-   ("/xf0/xa7/xb1/x80", "<CJK>");
+-   ("/xf0/xa7/xb2/x80", "<CJK>");
+-   ("/xf0/xa7/xb3/x80", "<CJK>");
+-   ("/xf0/xa7/xb4/x80", "<CJK>");
+-   ("/xf0/xa7/xb5/x80", "<CJK>");
+-   ("/xf0/xa7/xb6/x80", "<CJK>");
+-   ("/xf0/xa7/xb7/x80", "<CJK>");
+-   ("/xf0/xa7/xb8/x80", "<CJK>");
+-   ("/xf0/xa7/xb9/x80", "<CJK>");
+-   ("/xf0/xa7/xba/x80", "<CJK>");
+-   ("/xf0/xa7/xbb/x80", "<CJK>");
+-   ("/xf0/xa7/xbc/x80", "<CJK>");
+-   ("/xf0/xa7/xbd/x80", "<CJK>");
+-   ("/xf0/xa7/xbe/x80", "<CJK>");
+-   ("/xf0/xa7/xbf/x80", "<CJK>");
+-   ("/xf0/xa8/x80/x80", "<CJK>");
+-   ("/xf0/xa8/x81/x80", "<CJK>");
+-   ("/xf0/xa8/x82/x80", "<CJK>");
+-   ("/xf0/xa8/x83/x80", "<CJK>");
+-   ("/xf0/xa8/x84/x80", "<CJK>");
+-   ("/xf0/xa8/x85/x80", "<CJK>");
+-   ("/xf0/xa8/x86/x80", "<CJK>");
+-   ("/xf0/xa8/x87/x80", "<CJK>");
+-   ("/xf0/xa8/x88/x80", "<CJK>");
+-   ("/xf0/xa8/x89/x80", "<CJK>");
+-   ("/xf0/xa8/x8a/x80", "<CJK>");
+-   ("/xf0/xa8/x8b/x80", "<CJK>");
+-   ("/xf0/xa8/x8c/x80", "<CJK>");
+-   ("/xf0/xa8/x8d/x80", "<CJK>");
+-   ("/xf0/xa8/x8e/x80", "<CJK>");
+-   ("/xf0/xa8/x8f/x80", "<CJK>");
+-   ("/xf0/xa8/x90/x80", "<CJK>");
+-   ("/xf0/xa8/x91/x80", "<CJK>");
+-   ("/xf0/xa8/x92/x80", "<CJK>");
+-   ("/xf0/xa8/x93/x80", "<CJK>");
+-   ("/xf0/xa8/x94/x80", "<CJK>");
+-   ("/xf0/xa8/x95/x80", "<CJK>");
+-   ("/xf0/xa8/x96/x80", "<CJK>");
+-   ("/xf0/xa8/x97/x80", "<CJK>");
+-   ("/xf0/xa8/x98/x80", "<CJK>");
+-   ("/xf0/xa8/x99/x80", "<CJK>");
+-   ("/xf0/xa8/x9a/x80", "<CJK>");
+-   ("/xf0/xa8/x9b/x80", "<CJK>");
+-   ("/xf0/xa8/x9c/x80", "<CJK>");
+-   ("/xf0/xa8/x9d/x80", "<CJK>");
+-   ("/xf0/xa8/x9e/x80", "<CJK>");
+-   ("/xf0/xa8/x9f/x80", "<CJK>");
+-   ("/xf0/xa8/xa0/x80", "<CJK>");
+-   ("/xf0/xa8/xa1/x80", "<CJK>");
+-   ("/xf0/xa8/xa2/x80", "<CJK>");
+-   ("/xf0/xa8/xa3/x80", "<CJK>");
+-   ("/xf0/xa8/xa4/x80", "<CJK>");
+-   ("/xf0/xa8/xa5/x80", "<CJK>");
+-   ("/xf0/xa8/xa6/x80", "<CJK>");
+-   ("/xf0/xa8/xa7/x80", "<CJK>");
+-   ("/xf0/xa8/xa8/x80", "<CJK>");
+-   ("/xf0/xa8/xa9/x80", "<CJK>");
+-   ("/xf0/xa8/xaa/x80", "<CJK>");
+-   ("/xf0/xa8/xab/x80", "<CJK>");
+-   ("/xf0/xa8/xac/x80", "<CJK>");
+-   ("/xf0/xa8/xad/x80", "<CJK>");
+-   ("/xf0/xa8/xae/x80", "<CJK>");
+-   ("/xf0/xa8/xaf/x80", "<CJK>");
+-   ("/xf0/xa8/xb0/x80", "<CJK>");
+-   ("/xf0/xa8/xb1/x80", "<CJK>");
+-   ("/xf0/xa8/xb2/x80", "<CJK>");
+-   ("/xf0/xa8/xb3/x80", "<CJK>");
+-   ("/xf0/xa8/xb4/x80", "<CJK>");
+-   ("/xf0/xa8/xb5/x80", "<CJK>");
+-   ("/xf0/xa8/xb6/x80", "<CJK>");
+-   ("/xf0/xa8/xb7/x80", "<CJK>");
+-   ("/xf0/xa8/xb8/x80", "<CJK>");
+-   ("/xf0/xa8/xb9/x80", "<CJK>");
+-   ("/xf0/xa8/xba/x80", "<CJK>");
+-   ("/xf0/xa8/xbb/x80", "<CJK>");
+-   ("/xf0/xa8/xbc/x80", "<CJK>");
+-   ("/xf0/xa8/xbd/x80", "<CJK>");
+-   ("/xf0/xa8/xbe/x80", "<CJK>");
+-   ("/xf0/xa8/xbf/x80", "<CJK>");
+-   ("/xf0/xa9/x80/x80", "<CJK>");
+-   ("/xf0/xa9/x81/x80", "<CJK>");
+-   ("/xf0/xa9/x82/x80", "<CJK>");
+-   ("/xf0/xa9/x83/x80", "<CJK>");
+-   ("/xf0/xa9/x84/x80", "<CJK>");
+-   ("/xf0/xa9/x85/x80", "<CJK>");
+-   ("/xf0/xa9/x86/x80", "<CJK>");
+-   ("/xf0/xa9/x87/x80", "<CJK>");
+-   ("/xf0/xa9/x88/x80", "<CJK>");
+-   ("/xf0/xa9/x89/x80", "<CJK>");
+-   ("/xf0/xa9/x8a/x80", "<CJK>");
+-   ("/xf0/xa9/x8b/x80", "<CJK>");
+-   ("/xf0/xa9/x8c/x80", "<CJK>");
+-   ("/xf0/xa9/x8d/x80", "<CJK>");
+-   ("/xf0/xa9/x8e/x80", "<CJK>");
+-   ("/xf0/xa9/x8f/x80", "<CJK>");
+-   ("/xf0/xa9/x90/x80", "<CJK>");
+-   ("/xf0/xa9/x91/x80", "<CJK>");
+-   ("/xf0/xa9/x92/x80", "<CJK>");
+-   ("/xf0/xa9/x93/x80", "<CJK>");
+-   ("/xf0/xa9/x94/x80", "<CJK>");
+-   ("/xf0/xa9/x95/x80", "<CJK>");
+-   ("/xf0/xa9/x96/x80", "<CJK>");
+-   ("/xf0/xa9/x97/x80", "<CJK>");
+-   ("/xf0/xa9/x98/x80", "<CJK>");
+-   ("/xf0/xa9/x99/x80", "<CJK>");
+-   ("/xf0/xa9/x9a/x80", "<CJK>");
+-   ("/xf0/xa9/x9b/x80", "<CJK>");
+-   ("/xf0/xa9/x9c/x80", "<CJK>");
+-   ("/xf0/xa9/x9d/x80", "<CJK>");
+-   ("/xf0/xa9/x9e/x80", "<CJK>");
+-   ("/xf0/xa9/x9f/x80", "<CJK>");
+-   ("/xf0/xa9/xa0/x80", "<CJK>");
+-   ("/xf0/xa9/xa1/x80", "<CJK>");
+-   ("/xf0/xa9/xa2/x80", "<CJK>");
+-   ("/xf0/xa9/xa3/x80", "<CJK>");
+-   ("/xf0/xa9/xa4/x80", "<CJK>");
+-   ("/xf0/xa9/xa5/x80", "<CJK>");
+-   ("/xf0/xa9/xa6/x80", "<CJK>");
+-   ("/xf0/xa9/xa7/x80", "<CJK>");
+-   ("/xf0/xa9/xa8/x80", "<CJK>");
+-   ("/xf0/xa9/xa9/x80", "<CJK>");
+-   ("/xf0/xa9/xaa/x80", "<CJK>");
+-   ("/xf0/xa9/xab/x80", "<CJK>");
+-   ("/xf0/xa9/xac/x80", "<CJK>");
+-   ("/xf0/xa9/xad/x80", "<CJK>");
+-   ("/xf0/xa9/xae/x80", "<CJK>");
+-   ("/xf0/xa9/xaf/x80", "<CJK>");
+-   ("/xf0/xa9/xb0/x80", "<CJK>");
+-   ("/xf0/xa9/xb1/x80", "<CJK>");
+-   ("/xf0/xa9/xb2/x80", "<CJK>");
+-   ("/xf0/xa9/xb3/x80", "<CJK>");
+-   ("/xf0/xa9/xb4/x80", "<CJK>");
+-   ("/xf0/xa9/xb5/x80", "<CJK>");
+-   ("/xf0/xa9/xb6/x80", "<CJK>");
+-   ("/xf0/xa9/xb7/x80", "<CJK>");
+-   ("/xf0/xa9/xb8/x80", "<CJK>");
+-   ("/xf0/xa9/xb9/x80", "<CJK>");
+-   ("/xf0/xa9/xba/x80", "<CJK>");
+-   ("/xf0/xa9/xbb/x80", "<CJK>");
+-   ("/xf0/xa9/xbc/x80", "<CJK>");
+-   ("/xf0/xa9/xbd/x80", "<CJK>");
+-   ("/xf0/xa9/xbe/x80", "<CJK>");
+-   ("/xf0/xa9/xbf/x80", "<CJK>");
+-   ("/xf0/xaa/x80/x80", "<CJK>");
+-   ("/xf0/xaa/x81/x80", "<CJK>");
+-   ("/xf0/xaa/x82/x80", "<CJK>");
+-   ("/xf0/xaa/x83/x80", "<CJK>");
+-   ("/xf0/xaa/x84/x80", "<CJK>");
+-   ("/xf0/xaa/x85/x80", "<CJK>");
+-   ("/xf0/xaa/x86/x80", "<CJK>");
+-   ("/xf0/xaa/x87/x80", "<CJK>");
+-   ("/xf0/xaa/x88/x80", "<CJK>");
+-   ("/xf0/xaa/x89/x80", "<CJK>");
+-   ("/xf0/xaa/x8a/x80", "<CJK>");
+-   ("/xf0/xaa/x8b/x80", "<CJK>");
+-   ("/xf0/xaa/x8c/x80", "<CJK>");
+-   ("/xf0/xaa/x8d/x80", "<CJK>");
+-   ("/xf0/xaa/x8e/x80", "<CJK>");
+-   ("/xf0/xaa/x8f/x80", "<CJK>");
+-   ("/xf0/xaa/x90/x80", "<CJK>");
+-   ("/xf0/xaa/x91/x80", "<CJK>");
+-   ("/xf0/xaa/x92/x80", "<CJK>");
+-   ("/xf0/xaa/x93/x80", "<CJK>");
+-   ("/xf0/xaa/x94/x80", "<CJK>");
+-   ("/xf0/xaa/x95/x80", "<CJK>");
+-   ("/xf0/xaa/x96/x80", "<CJK>");
+-   ("/xf0/xaa/x97/x80", "<CJK>");
+-   ("/xf0/xaa/x98/x80", "<CJK>");
+-   ("/xf0/xaa/x99/x80", "<CJK>");
+-   ("/xf0/xaa/x9a/x80", "<CJK>");
+-   ("/xf0/xaa/x9b/x80", "<CJK>");
+-   ("/xf0/xaf/xa0/x80", "CJK COMPATIBILITY IDEOGRAPH-2F800");
+-   ("/xf0/xaf/xa0/x81", "CJK COMPATIBILITY IDEOGRAPH-2F801");
+-   ("/xf0/xaf/xa0/x82", "CJK COMPATIBILITY IDEOGRAPH-2F802");
+-   ("/xf0/xaf/xa0/x83", "CJK COMPATIBILITY IDEOGRAPH-2F803");
+-   ("/xf0/xaf/xa0/x84", "CJK COMPATIBILITY IDEOGRAPH-2F804");
+-   ("/xf0/xaf/xa0/x85", "CJK COMPATIBILITY IDEOGRAPH-2F805");
+-   ("/xf0/xaf/xa0/x86", "CJK COMPATIBILITY IDEOGRAPH-2F806");
+-   ("/xf0/xaf/xa0/x87", "CJK COMPATIBILITY IDEOGRAPH-2F807");
+-   ("/xf0/xaf/xa0/x88", "CJK COMPATIBILITY IDEOGRAPH-2F808");
+-   ("/xf0/xaf/xa0/x89", "CJK COMPATIBILITY IDEOGRAPH-2F809");
+-   ("/xf0/xaf/xa0/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F80A");
+-   ("/xf0/xaf/xa0/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F80B");
+-   ("/xf0/xaf/xa0/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F80C");
+-   ("/xf0/xaf/xa0/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F80D");
+-   ("/xf0/xaf/xa0/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F80E");
+-   ("/xf0/xaf/xa0/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F80F");
+-   ("/xf0/xaf/xa0/x90", "CJK COMPATIBILITY IDEOGRAPH-2F810");
+-   ("/xf0/xaf/xa0/x91", "CJK COMPATIBILITY IDEOGRAPH-2F811");
+-   ("/xf0/xaf/xa0/x92", "CJK COMPATIBILITY IDEOGRAPH-2F812");
+-   ("/xf0/xaf/xa0/x93", "CJK COMPATIBILITY IDEOGRAPH-2F813");
+-   ("/xf0/xaf/xa0/x94", "CJK COMPATIBILITY IDEOGRAPH-2F814");
+-   ("/xf0/xaf/xa0/x95", "CJK COMPATIBILITY IDEOGRAPH-2F815");
+-   ("/xf0/xaf/xa0/x96", "CJK COMPATIBILITY IDEOGRAPH-2F816");
+-   ("/xf0/xaf/xa0/x97", "CJK COMPATIBILITY IDEOGRAPH-2F817");
+-   ("/xf0/xaf/xa0/x98", "CJK COMPATIBILITY IDEOGRAPH-2F818");
+-   ("/xf0/xaf/xa0/x99", "CJK COMPATIBILITY IDEOGRAPH-2F819");
+-   ("/xf0/xaf/xa0/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F81A");
+-   ("/xf0/xaf/xa0/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F81B");
+-   ("/xf0/xaf/xa0/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F81C");
+-   ("/xf0/xaf/xa0/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F81D");
+-   ("/xf0/xaf/xa0/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F81E");
+-   ("/xf0/xaf/xa0/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F81F");
+-   ("/xf0/xaf/xa0/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F820");
+-   ("/xf0/xaf/xa0/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F821");
+-   ("/xf0/xaf/xa0/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F822");
+-   ("/xf0/xaf/xa0/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F823");
+-   ("/xf0/xaf/xa0/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F824");
+-   ("/xf0/xaf/xa0/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F825");
+-   ("/xf0/xaf/xa0/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F826");
+-   ("/xf0/xaf/xa0/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F827");
+-   ("/xf0/xaf/xa0/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F828");
+-   ("/xf0/xaf/xa0/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F829");
+-   ("/xf0/xaf/xa0/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F82A");
+-   ("/xf0/xaf/xa0/xab", "CJK COMPATIBILITY IDEOGRAPH-2F82B");
+-   ("/xf0/xaf/xa0/xac", "CJK COMPATIBILITY IDEOGRAPH-2F82C");
+-   ("/xf0/xaf/xa0/xad", "CJK COMPATIBILITY IDEOGRAPH-2F82D");
+-   ("/xf0/xaf/xa0/xae", "CJK COMPATIBILITY IDEOGRAPH-2F82E");
+-   ("/xf0/xaf/xa0/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F82F");
+-   ("/xf0/xaf/xa0/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F830");
+-   ("/xf0/xaf/xa0/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F831");
+-   ("/xf0/xaf/xa0/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F832");
+-   ("/xf0/xaf/xa0/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F833");
+-   ("/xf0/xaf/xa0/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F834");
+-   ("/xf0/xaf/xa0/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F835");
+-   ("/xf0/xaf/xa0/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F836");
+-   ("/xf0/xaf/xa0/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F837");
+-   ("/xf0/xaf/xa0/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F838");
+-   ("/xf0/xaf/xa0/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F839");
+-   ("/xf0/xaf/xa0/xba", "CJK COMPATIBILITY IDEOGRAPH-2F83A");
+-   ("/xf0/xaf/xa0/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F83B");
+-   ("/xf0/xaf/xa0/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F83C");
+-   ("/xf0/xaf/xa0/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F83D");
+-   ("/xf0/xaf/xa0/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F83E");
+-   ("/xf0/xaf/xa0/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F83F");
+-   ("/xf0/xaf/xa1/x80", "CJK COMPATIBILITY IDEOGRAPH-2F840");
+-   ("/xf0/xaf/xa1/x81", "CJK COMPATIBILITY IDEOGRAPH-2F841");
+-   ("/xf0/xaf/xa1/x82", "CJK COMPATIBILITY IDEOGRAPH-2F842");
+-   ("/xf0/xaf/xa1/x83", "CJK COMPATIBILITY IDEOGRAPH-2F843");
+-   ("/xf0/xaf/xa1/x84", "CJK COMPATIBILITY IDEOGRAPH-2F844");
+-   ("/xf0/xaf/xa1/x85", "CJK COMPATIBILITY IDEOGRAPH-2F845");
+-   ("/xf0/xaf/xa1/x86", "CJK COMPATIBILITY IDEOGRAPH-2F846");
+-   ("/xf0/xaf/xa1/x87", "CJK COMPATIBILITY IDEOGRAPH-2F847");
+-   ("/xf0/xaf/xa1/x88", "CJK COMPATIBILITY IDEOGRAPH-2F848");
+-   ("/xf0/xaf/xa1/x89", "CJK COMPATIBILITY IDEOGRAPH-2F849");
+-   ("/xf0/xaf/xa1/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F84A");
+-   ("/xf0/xaf/xa1/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F84B");
+-   ("/xf0/xaf/xa1/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F84C");
+-   ("/xf0/xaf/xa1/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F84D");
+-   ("/xf0/xaf/xa1/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F84E");
+-   ("/xf0/xaf/xa1/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F84F");
+-   ("/xf0/xaf/xa1/x90", "CJK COMPATIBILITY IDEOGRAPH-2F850");
+-   ("/xf0/xaf/xa1/x91", "CJK COMPATIBILITY IDEOGRAPH-2F851");
+-   ("/xf0/xaf/xa1/x92", "CJK COMPATIBILITY IDEOGRAPH-2F852");
+-   ("/xf0/xaf/xa1/x93", "CJK COMPATIBILITY IDEOGRAPH-2F853");
+-   ("/xf0/xaf/xa1/x94", "CJK COMPATIBILITY IDEOGRAPH-2F854");
+-   ("/xf0/xaf/xa1/x95", "CJK COMPATIBILITY IDEOGRAPH-2F855");
+-   ("/xf0/xaf/xa1/x96", "CJK COMPATIBILITY IDEOGRAPH-2F856");
+-   ("/xf0/xaf/xa1/x97", "CJK COMPATIBILITY IDEOGRAPH-2F857");
+-   ("/xf0/xaf/xa1/x98", "CJK COMPATIBILITY IDEOGRAPH-2F858");
+-   ("/xf0/xaf/xa1/x99", "CJK COMPATIBILITY IDEOGRAPH-2F859");
+-   ("/xf0/xaf/xa1/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F85A");
+-   ("/xf0/xaf/xa1/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F85B");
+-   ("/xf0/xaf/xa1/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F85C");
+-   ("/xf0/xaf/xa1/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F85D");
+-   ("/xf0/xaf/xa1/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F85E");
+-   ("/xf0/xaf/xa1/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F85F");
+-   ("/xf0/xaf/xa1/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F860");
+-   ("/xf0/xaf/xa1/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F861");
+-   ("/xf0/xaf/xa1/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F862");
+-   ("/xf0/xaf/xa1/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F863");
+-   ("/xf0/xaf/xa1/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F864");
+-   ("/xf0/xaf/xa1/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F865");
+-   ("/xf0/xaf/xa1/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F866");
+-   ("/xf0/xaf/xa1/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F867");
+-   ("/xf0/xaf/xa1/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F868");
+-   ("/xf0/xaf/xa1/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F869");
+-   ("/xf0/xaf/xa1/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F86A");
+-   ("/xf0/xaf/xa1/xab", "CJK COMPATIBILITY IDEOGRAPH-2F86B");
+-   ("/xf0/xaf/xa1/xac", "CJK COMPATIBILITY IDEOGRAPH-2F86C");
+-   ("/xf0/xaf/xa1/xad", "CJK COMPATIBILITY IDEOGRAPH-2F86D");
+-   ("/xf0/xaf/xa1/xae", "CJK COMPATIBILITY IDEOGRAPH-2F86E");
+-   ("/xf0/xaf/xa1/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F86F");
+-   ("/xf0/xaf/xa1/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F870");
+-   ("/xf0/xaf/xa1/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F871");
+-   ("/xf0/xaf/xa1/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F872");
+-   ("/xf0/xaf/xa1/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F873");
+-   ("/xf0/xaf/xa1/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F874");
+-   ("/xf0/xaf/xa1/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F875");
+-   ("/xf0/xaf/xa1/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F876");
+-   ("/xf0/xaf/xa1/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F877");
+-   ("/xf0/xaf/xa1/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F878");
+-   ("/xf0/xaf/xa1/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F879");
+-   ("/xf0/xaf/xa1/xba", "CJK COMPATIBILITY IDEOGRAPH-2F87A");
+-   ("/xf0/xaf/xa1/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F87B");
+-   ("/xf0/xaf/xa1/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F87C");
+-   ("/xf0/xaf/xa1/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F87D");
+-   ("/xf0/xaf/xa1/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F87E");
+-   ("/xf0/xaf/xa1/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F87F");
+-   ("/xf0/xaf/xa2/x80", "CJK COMPATIBILITY IDEOGRAPH-2F880");
+-   ("/xf0/xaf/xa2/x81", "CJK COMPATIBILITY IDEOGRAPH-2F881");
+-   ("/xf0/xaf/xa2/x82", "CJK COMPATIBILITY IDEOGRAPH-2F882");
+-   ("/xf0/xaf/xa2/x83", "CJK COMPATIBILITY IDEOGRAPH-2F883");
+-   ("/xf0/xaf/xa2/x84", "CJK COMPATIBILITY IDEOGRAPH-2F884");
+-   ("/xf0/xaf/xa2/x85", "CJK COMPATIBILITY IDEOGRAPH-2F885");
+-   ("/xf0/xaf/xa2/x86", "CJK COMPATIBILITY IDEOGRAPH-2F886");
+-   ("/xf0/xaf/xa2/x87", "CJK COMPATIBILITY IDEOGRAPH-2F887");
+-   ("/xf0/xaf/xa2/x88", "CJK COMPATIBILITY IDEOGRAPH-2F888");
+-   ("/xf0/xaf/xa2/x89", "CJK COMPATIBILITY IDEOGRAPH-2F889");
+-   ("/xf0/xaf/xa2/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F88A");
+-   ("/xf0/xaf/xa2/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F88B");
+-   ("/xf0/xaf/xa2/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F88C");
+-   ("/xf0/xaf/xa2/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F88D");
+-   ("/xf0/xaf/xa2/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F88E");
+-   ("/xf0/xaf/xa2/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F88F");
+-   ("/xf0/xaf/xa2/x90", "CJK COMPATIBILITY IDEOGRAPH-2F890");
+-   ("/xf0/xaf/xa2/x91", "CJK COMPATIBILITY IDEOGRAPH-2F891");
+-   ("/xf0/xaf/xa2/x92", "CJK COMPATIBILITY IDEOGRAPH-2F892");
+-   ("/xf0/xaf/xa2/x93", "CJK COMPATIBILITY IDEOGRAPH-2F893");
+-   ("/xf0/xaf/xa2/x94", "CJK COMPATIBILITY IDEOGRAPH-2F894");
+-   ("/xf0/xaf/xa2/x95", "CJK COMPATIBILITY IDEOGRAPH-2F895");
+-   ("/xf0/xaf/xa2/x96", "CJK COMPATIBILITY IDEOGRAPH-2F896");
+-   ("/xf0/xaf/xa2/x97", "CJK COMPATIBILITY IDEOGRAPH-2F897");
+-   ("/xf0/xaf/xa2/x98", "CJK COMPATIBILITY IDEOGRAPH-2F898");
+-   ("/xf0/xaf/xa2/x99", "CJK COMPATIBILITY IDEOGRAPH-2F899");
+-   ("/xf0/xaf/xa2/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F89A");
+-   ("/xf0/xaf/xa2/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F89B");
+-   ("/xf0/xaf/xa2/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F89C");
+-   ("/xf0/xaf/xa2/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F89D");
+-   ("/xf0/xaf/xa2/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F89E");
+-   ("/xf0/xaf/xa2/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F89F");
+-   ("/xf0/xaf/xa2/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F8A0");
+-   ("/xf0/xaf/xa2/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F8A1");
+-   ("/xf0/xaf/xa2/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F8A2");
+-   ("/xf0/xaf/xa2/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F8A3");
+-   ("/xf0/xaf/xa2/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F8A4");
+-   ("/xf0/xaf/xa2/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F8A5");
+-   ("/xf0/xaf/xa2/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F8A6");
+-   ("/xf0/xaf/xa2/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F8A7");
+-   ("/xf0/xaf/xa2/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F8A8");
+-   ("/xf0/xaf/xa2/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F8A9");
+-   ("/xf0/xaf/xa2/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F8AA");
+-   ("/xf0/xaf/xa2/xab", "CJK COMPATIBILITY IDEOGRAPH-2F8AB");
+-   ("/xf0/xaf/xa2/xac", "CJK COMPATIBILITY IDEOGRAPH-2F8AC");
+-   ("/xf0/xaf/xa2/xad", "CJK COMPATIBILITY IDEOGRAPH-2F8AD");
+-   ("/xf0/xaf/xa2/xae", "CJK COMPATIBILITY IDEOGRAPH-2F8AE");
+-   ("/xf0/xaf/xa2/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F8AF");
+-   ("/xf0/xaf/xa2/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F8B0");
+-   ("/xf0/xaf/xa2/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F8B1");
+-   ("/xf0/xaf/xa2/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F8B2");
+-   ("/xf0/xaf/xa2/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F8B3");
+-   ("/xf0/xaf/xa2/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F8B4");
+-   ("/xf0/xaf/xa2/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F8B5");
+-   ("/xf0/xaf/xa2/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F8B6");
+-   ("/xf0/xaf/xa2/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F8B7");
+-   ("/xf0/xaf/xa2/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F8B8");
+-   ("/xf0/xaf/xa2/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F8B9");
+-   ("/xf0/xaf/xa2/xba", "CJK COMPATIBILITY IDEOGRAPH-2F8BA");
+-   ("/xf0/xaf/xa2/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F8BB");
+-   ("/xf0/xaf/xa2/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F8BC");
+-   ("/xf0/xaf/xa2/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F8BD");
+-   ("/xf0/xaf/xa2/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F8BE");
+-   ("/xf0/xaf/xa2/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F8BF");
+-   ("/xf0/xaf/xa3/x80", "CJK COMPATIBILITY IDEOGRAPH-2F8C0");
+-   ("/xf0/xaf/xa3/x81", "CJK COMPATIBILITY IDEOGRAPH-2F8C1");
+-   ("/xf0/xaf/xa3/x82", "CJK COMPATIBILITY IDEOGRAPH-2F8C2");
+-   ("/xf0/xaf/xa3/x83", "CJK COMPATIBILITY IDEOGRAPH-2F8C3");
+-   ("/xf0/xaf/xa3/x84", "CJK COMPATIBILITY IDEOGRAPH-2F8C4");
+-   ("/xf0/xaf/xa3/x85", "CJK COMPATIBILITY IDEOGRAPH-2F8C5");
+-   ("/xf0/xaf/xa3/x86", "CJK COMPATIBILITY IDEOGRAPH-2F8C6");
+-   ("/xf0/xaf/xa3/x87", "CJK COMPATIBILITY IDEOGRAPH-2F8C7");
+-   ("/xf0/xaf/xa3/x88", "CJK COMPATIBILITY IDEOGRAPH-2F8C8");
+-   ("/xf0/xaf/xa3/x89", "CJK COMPATIBILITY IDEOGRAPH-2F8C9");
+-   ("/xf0/xaf/xa3/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F8CA");
+-   ("/xf0/xaf/xa3/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F8CB");
+-   ("/xf0/xaf/xa3/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F8CC");
+-   ("/xf0/xaf/xa3/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F8CD");
+-   ("/xf0/xaf/xa3/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F8CE");
+-   ("/xf0/xaf/xa3/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F8CF");
+-   ("/xf0/xaf/xa3/x90", "CJK COMPATIBILITY IDEOGRAPH-2F8D0");
+-   ("/xf0/xaf/xa3/x91", "CJK COMPATIBILITY IDEOGRAPH-2F8D1");
+-   ("/xf0/xaf/xa3/x92", "CJK COMPATIBILITY IDEOGRAPH-2F8D2");
+-   ("/xf0/xaf/xa3/x93", "CJK COMPATIBILITY IDEOGRAPH-2F8D3");
+-   ("/xf0/xaf/xa3/x94", "CJK COMPATIBILITY IDEOGRAPH-2F8D4");
+-   ("/xf0/xaf/xa3/x95", "CJK COMPATIBILITY IDEOGRAPH-2F8D5");
+-   ("/xf0/xaf/xa3/x96", "CJK COMPATIBILITY IDEOGRAPH-2F8D6");
+-   ("/xf0/xaf/xa3/x97", "CJK COMPATIBILITY IDEOGRAPH-2F8D7");
+-   ("/xf0/xaf/xa3/x98", "CJK COMPATIBILITY IDEOGRAPH-2F8D8");
+-   ("/xf0/xaf/xa3/x99", "CJK COMPATIBILITY IDEOGRAPH-2F8D9");
+-   ("/xf0/xaf/xa3/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F8DA");
+-   ("/xf0/xaf/xa3/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F8DB");
+-   ("/xf0/xaf/xa3/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F8DC");
+-   ("/xf0/xaf/xa3/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F8DD");
+-   ("/xf0/xaf/xa3/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F8DE");
+-   ("/xf0/xaf/xa3/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F8DF");
+-   ("/xf0/xaf/xa3/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F8E0");
+-   ("/xf0/xaf/xa3/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F8E1");
+-   ("/xf0/xaf/xa3/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F8E2");
+-   ("/xf0/xaf/xa3/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F8E3");
+-   ("/xf0/xaf/xa3/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F8E4");
+-   ("/xf0/xaf/xa3/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F8E5");
+-   ("/xf0/xaf/xa3/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F8E6");
+-   ("/xf0/xaf/xa3/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F8E7");
+-   ("/xf0/xaf/xa3/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F8E8");
+-   ("/xf0/xaf/xa3/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F8E9");
+-   ("/xf0/xaf/xa3/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F8EA");
+-   ("/xf0/xaf/xa3/xab", "CJK COMPATIBILITY IDEOGRAPH-2F8EB");
+-   ("/xf0/xaf/xa3/xac", "CJK COMPATIBILITY IDEOGRAPH-2F8EC");
+-   ("/xf0/xaf/xa3/xad", "CJK COMPATIBILITY IDEOGRAPH-2F8ED");
+-   ("/xf0/xaf/xa3/xae", "CJK COMPATIBILITY IDEOGRAPH-2F8EE");
+-   ("/xf0/xaf/xa3/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F8EF");
+-   ("/xf0/xaf/xa3/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F8F0");
+-   ("/xf0/xaf/xa3/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F8F1");
+-   ("/xf0/xaf/xa3/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F8F2");
+-   ("/xf0/xaf/xa3/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F8F3");
+-   ("/xf0/xaf/xa3/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F8F4");
+-   ("/xf0/xaf/xa3/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F8F5");
+-   ("/xf0/xaf/xa3/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F8F6");
+-   ("/xf0/xaf/xa3/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F8F7");
+-   ("/xf0/xaf/xa3/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F8F8");
+-   ("/xf0/xaf/xa3/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F8F9");
+-   ("/xf0/xaf/xa3/xba", "CJK COMPATIBILITY IDEOGRAPH-2F8FA");
+-   ("/xf0/xaf/xa3/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F8FB");
+-   ("/xf0/xaf/xa3/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F8FC");
+-   ("/xf0/xaf/xa3/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F8FD");
+-   ("/xf0/xaf/xa3/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F8FE");
+-   ("/xf0/xaf/xa3/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F8FF");
+-   ("/xf0/xaf/xa4/x80", "CJK COMPATIBILITY IDEOGRAPH-2F900");
+-   ("/xf0/xaf/xa4/x81", "CJK COMPATIBILITY IDEOGRAPH-2F901");
+-   ("/xf0/xaf/xa4/x82", "CJK COMPATIBILITY IDEOGRAPH-2F902");
+-   ("/xf0/xaf/xa4/x83", "CJK COMPATIBILITY IDEOGRAPH-2F903");
+-   ("/xf0/xaf/xa4/x84", "CJK COMPATIBILITY IDEOGRAPH-2F904");
+-   ("/xf0/xaf/xa4/x85", "CJK COMPATIBILITY IDEOGRAPH-2F905");
+-   ("/xf0/xaf/xa4/x86", "CJK COMPATIBILITY IDEOGRAPH-2F906");
+-   ("/xf0/xaf/xa4/x87", "CJK COMPATIBILITY IDEOGRAPH-2F907");
+-   ("/xf0/xaf/xa4/x88", "CJK COMPATIBILITY IDEOGRAPH-2F908");
+-   ("/xf0/xaf/xa4/x89", "CJK COMPATIBILITY IDEOGRAPH-2F909");
+-   ("/xf0/xaf/xa4/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F90A");
+-   ("/xf0/xaf/xa4/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F90B");
+-   ("/xf0/xaf/xa4/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F90C");
+-   ("/xf0/xaf/xa4/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F90D");
+-   ("/xf0/xaf/xa4/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F90E");
+-   ("/xf0/xaf/xa4/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F90F");
+-   ("/xf0/xaf/xa4/x90", "CJK COMPATIBILITY IDEOGRAPH-2F910");
+-   ("/xf0/xaf/xa4/x91", "CJK COMPATIBILITY IDEOGRAPH-2F911");
+-   ("/xf0/xaf/xa4/x92", "CJK COMPATIBILITY IDEOGRAPH-2F912");
+-   ("/xf0/xaf/xa4/x93", "CJK COMPATIBILITY IDEOGRAPH-2F913");
+-   ("/xf0/xaf/xa4/x94", "CJK COMPATIBILITY IDEOGRAPH-2F914");
+-   ("/xf0/xaf/xa4/x95", "CJK COMPATIBILITY IDEOGRAPH-2F915");
+-   ("/xf0/xaf/xa4/x96", "CJK COMPATIBILITY IDEOGRAPH-2F916");
+-   ("/xf0/xaf/xa4/x97", "CJK COMPATIBILITY IDEOGRAPH-2F917");
+-   ("/xf0/xaf/xa4/x98", "CJK COMPATIBILITY IDEOGRAPH-2F918");
+-   ("/xf0/xaf/xa4/x99", "CJK COMPATIBILITY IDEOGRAPH-2F919");
+-   ("/xf0/xaf/xa4/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F91A");
+-   ("/xf0/xaf/xa4/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F91B");
+-   ("/xf0/xaf/xa4/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F91C");
+-   ("/xf0/xaf/xa4/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F91D");
+-   ("/xf0/xaf/xa4/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F91E");
+-   ("/xf0/xaf/xa4/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F91F");
+-   ("/xf0/xaf/xa4/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F920");
+-   ("/xf0/xaf/xa4/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F921");
+-   ("/xf0/xaf/xa4/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F922");
+-   ("/xf0/xaf/xa4/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F923");
+-   ("/xf0/xaf/xa4/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F924");
+-   ("/xf0/xaf/xa4/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F925");
+-   ("/xf0/xaf/xa4/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F926");
+-   ("/xf0/xaf/xa4/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F927");
+-   ("/xf0/xaf/xa4/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F928");
+-   ("/xf0/xaf/xa4/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F929");
+-   ("/xf0/xaf/xa4/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F92A");
+-   ("/xf0/xaf/xa4/xab", "CJK COMPATIBILITY IDEOGRAPH-2F92B");
+-   ("/xf0/xaf/xa4/xac", "CJK COMPATIBILITY IDEOGRAPH-2F92C");
+-   ("/xf0/xaf/xa4/xad", "CJK COMPATIBILITY IDEOGRAPH-2F92D");
+-   ("/xf0/xaf/xa4/xae", "CJK COMPATIBILITY IDEOGRAPH-2F92E");
+-   ("/xf0/xaf/xa4/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F92F");
+-   ("/xf0/xaf/xa4/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F930");
+-   ("/xf0/xaf/xa4/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F931");
+-   ("/xf0/xaf/xa4/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F932");
+-   ("/xf0/xaf/xa4/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F933");
+-   ("/xf0/xaf/xa4/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F934");
+-   ("/xf0/xaf/xa4/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F935");
+-   ("/xf0/xaf/xa4/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F936");
+-   ("/xf0/xaf/xa4/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F937");
+-   ("/xf0/xaf/xa4/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F938");
+-   ("/xf0/xaf/xa4/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F939");
+-   ("/xf0/xaf/xa4/xba", "CJK COMPATIBILITY IDEOGRAPH-2F93A");
+-   ("/xf0/xaf/xa4/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F93B");
+-   ("/xf0/xaf/xa4/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F93C");
+-   ("/xf0/xaf/xa4/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F93D");
+-   ("/xf0/xaf/xa4/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F93E");
+-   ("/xf0/xaf/xa4/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F93F");
+-   ("/xf0/xaf/xa5/x80", "CJK COMPATIBILITY IDEOGRAPH-2F940");
+-   ("/xf0/xaf/xa5/x81", "CJK COMPATIBILITY IDEOGRAPH-2F941");
+-   ("/xf0/xaf/xa5/x82", "CJK COMPATIBILITY IDEOGRAPH-2F942");
+-   ("/xf0/xaf/xa5/x83", "CJK COMPATIBILITY IDEOGRAPH-2F943");
+-   ("/xf0/xaf/xa5/x84", "CJK COMPATIBILITY IDEOGRAPH-2F944");
+-   ("/xf0/xaf/xa5/x85", "CJK COMPATIBILITY IDEOGRAPH-2F945");
+-   ("/xf0/xaf/xa5/x86", "CJK COMPATIBILITY IDEOGRAPH-2F946");
+-   ("/xf0/xaf/xa5/x87", "CJK COMPATIBILITY IDEOGRAPH-2F947");
+-   ("/xf0/xaf/xa5/x88", "CJK COMPATIBILITY IDEOGRAPH-2F948");
+-   ("/xf0/xaf/xa5/x89", "CJK COMPATIBILITY IDEOGRAPH-2F949");
+-   ("/xf0/xaf/xa5/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F94A");
+-   ("/xf0/xaf/xa5/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F94B");
+-   ("/xf0/xaf/xa5/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F94C");
+-   ("/xf0/xaf/xa5/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F94D");
+-   ("/xf0/xaf/xa5/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F94E");
+-   ("/xf0/xaf/xa5/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F94F");
+-   ("/xf0/xaf/xa5/x90", "CJK COMPATIBILITY IDEOGRAPH-2F950");
+-   ("/xf0/xaf/xa5/x91", "CJK COMPATIBILITY IDEOGRAPH-2F951");
+-   ("/xf0/xaf/xa5/x92", "CJK COMPATIBILITY IDEOGRAPH-2F952");
+-   ("/xf0/xaf/xa5/x93", "CJK COMPATIBILITY IDEOGRAPH-2F953");
+-   ("/xf0/xaf/xa5/x94", "CJK COMPATIBILITY IDEOGRAPH-2F954");
+-   ("/xf0/xaf/xa5/x95", "CJK COMPATIBILITY IDEOGRAPH-2F955");
+-   ("/xf0/xaf/xa5/x96", "CJK COMPATIBILITY IDEOGRAPH-2F956");
+-   ("/xf0/xaf/xa5/x97", "CJK COMPATIBILITY IDEOGRAPH-2F957");
+-   ("/xf0/xaf/xa5/x98", "CJK COMPATIBILITY IDEOGRAPH-2F958");
+-   ("/xf0/xaf/xa5/x99", "CJK COMPATIBILITY IDEOGRAPH-2F959");
+-   ("/xf0/xaf/xa5/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F95A");
+-   ("/xf0/xaf/xa5/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F95B");
+-   ("/xf0/xaf/xa5/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F95C");
+-   ("/xf0/xaf/xa5/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F95D");
+-   ("/xf0/xaf/xa5/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F95E");
+-   ("/xf0/xaf/xa5/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F95F");
+-   ("/xf0/xaf/xa5/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F960");
+-   ("/xf0/xaf/xa5/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F961");
+-   ("/xf0/xaf/xa5/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F962");
+-   ("/xf0/xaf/xa5/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F963");
+-   ("/xf0/xaf/xa5/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F964");
+-   ("/xf0/xaf/xa5/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F965");
+-   ("/xf0/xaf/xa5/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F966");
+-   ("/xf0/xaf/xa5/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F967");
+-   ("/xf0/xaf/xa5/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F968");
+-   ("/xf0/xaf/xa5/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F969");
+-   ("/xf0/xaf/xa5/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F96A");
+-   ("/xf0/xaf/xa5/xab", "CJK COMPATIBILITY IDEOGRAPH-2F96B");
+-   ("/xf0/xaf/xa5/xac", "CJK COMPATIBILITY IDEOGRAPH-2F96C");
+-   ("/xf0/xaf/xa5/xad", "CJK COMPATIBILITY IDEOGRAPH-2F96D");
+-   ("/xf0/xaf/xa5/xae", "CJK COMPATIBILITY IDEOGRAPH-2F96E");
+-   ("/xf0/xaf/xa5/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F96F");
+-   ("/xf0/xaf/xa5/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F970");
+-   ("/xf0/xaf/xa5/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F971");
+-   ("/xf0/xaf/xa5/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F972");
+-   ("/xf0/xaf/xa5/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F973");
+-   ("/xf0/xaf/xa5/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F974");
+-   ("/xf0/xaf/xa5/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F975");
+-   ("/xf0/xaf/xa5/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F976");
+-   ("/xf0/xaf/xa5/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F977");
+-   ("/xf0/xaf/xa5/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F978");
+-   ("/xf0/xaf/xa5/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F979");
+-   ("/xf0/xaf/xa5/xba", "CJK COMPATIBILITY IDEOGRAPH-2F97A");
+-   ("/xf0/xaf/xa5/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F97B");
+-   ("/xf0/xaf/xa5/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F97C");
+-   ("/xf0/xaf/xa5/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F97D");
+-   ("/xf0/xaf/xa5/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F97E");
+-   ("/xf0/xaf/xa5/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F97F");
+-   ("/xf0/xaf/xa6/x80", "CJK COMPATIBILITY IDEOGRAPH-2F980");
+-   ("/xf0/xaf/xa6/x81", "CJK COMPATIBILITY IDEOGRAPH-2F981");
+-   ("/xf0/xaf/xa6/x82", "CJK COMPATIBILITY IDEOGRAPH-2F982");
+-   ("/xf0/xaf/xa6/x83", "CJK COMPATIBILITY IDEOGRAPH-2F983");
+-   ("/xf0/xaf/xa6/x84", "CJK COMPATIBILITY IDEOGRAPH-2F984");
+-   ("/xf0/xaf/xa6/x85", "CJK COMPATIBILITY IDEOGRAPH-2F985");
+-   ("/xf0/xaf/xa6/x86", "CJK COMPATIBILITY IDEOGRAPH-2F986");
+-   ("/xf0/xaf/xa6/x87", "CJK COMPATIBILITY IDEOGRAPH-2F987");
+-   ("/xf0/xaf/xa6/x88", "CJK COMPATIBILITY IDEOGRAPH-2F988");
+-   ("/xf0/xaf/xa6/x89", "CJK COMPATIBILITY IDEOGRAPH-2F989");
+-   ("/xf0/xaf/xa6/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F98A");
+-   ("/xf0/xaf/xa6/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F98B");
+-   ("/xf0/xaf/xa6/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F98C");
+-   ("/xf0/xaf/xa6/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F98D");
+-   ("/xf0/xaf/xa6/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F98E");
+-   ("/xf0/xaf/xa6/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F98F");
+-   ("/xf0/xaf/xa6/x90", "CJK COMPATIBILITY IDEOGRAPH-2F990");
+-   ("/xf0/xaf/xa6/x91", "CJK COMPATIBILITY IDEOGRAPH-2F991");
+-   ("/xf0/xaf/xa6/x92", "CJK COMPATIBILITY IDEOGRAPH-2F992");
+-   ("/xf0/xaf/xa6/x93", "CJK COMPATIBILITY IDEOGRAPH-2F993");
+-   ("/xf0/xaf/xa6/x94", "CJK COMPATIBILITY IDEOGRAPH-2F994");
+-   ("/xf0/xaf/xa6/x95", "CJK COMPATIBILITY IDEOGRAPH-2F995");
+-   ("/xf0/xaf/xa6/x96", "CJK COMPATIBILITY IDEOGRAPH-2F996");
+-   ("/xf0/xaf/xa6/x97", "CJK COMPATIBILITY IDEOGRAPH-2F997");
+-   ("/xf0/xaf/xa6/x98", "CJK COMPATIBILITY IDEOGRAPH-2F998");
+-   ("/xf0/xaf/xa6/x99", "CJK COMPATIBILITY IDEOGRAPH-2F999");
+-   ("/xf0/xaf/xa6/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F99A");
+-   ("/xf0/xaf/xa6/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F99B");
+-   ("/xf0/xaf/xa6/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F99C");
+-   ("/xf0/xaf/xa6/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F99D");
+-   ("/xf0/xaf/xa6/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F99E");
+-   ("/xf0/xaf/xa6/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F99F");
+-   ("/xf0/xaf/xa6/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F9A0");
+-   ("/xf0/xaf/xa6/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F9A1");
+-   ("/xf0/xaf/xa6/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F9A2");
+-   ("/xf0/xaf/xa6/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F9A3");
+-   ("/xf0/xaf/xa6/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F9A4");
+-   ("/xf0/xaf/xa6/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F9A5");
+-   ("/xf0/xaf/xa6/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F9A6");
+-   ("/xf0/xaf/xa6/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F9A7");
+-   ("/xf0/xaf/xa6/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F9A8");
+-   ("/xf0/xaf/xa6/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F9A9");
+-   ("/xf0/xaf/xa6/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F9AA");
+-   ("/xf0/xaf/xa6/xab", "CJK COMPATIBILITY IDEOGRAPH-2F9AB");
+-   ("/xf0/xaf/xa6/xac", "CJK COMPATIBILITY IDEOGRAPH-2F9AC");
+-   ("/xf0/xaf/xa6/xad", "CJK COMPATIBILITY IDEOGRAPH-2F9AD");
+-   ("/xf0/xaf/xa6/xae", "CJK COMPATIBILITY IDEOGRAPH-2F9AE");
+-   ("/xf0/xaf/xa6/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F9AF");
+-   ("/xf0/xaf/xa6/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F9B0");
+-   ("/xf0/xaf/xa6/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F9B1");
+-   ("/xf0/xaf/xa6/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F9B2");
+-   ("/xf0/xaf/xa6/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F9B3");
+-   ("/xf0/xaf/xa6/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F9B4");
+-   ("/xf0/xaf/xa6/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F9B5");
+-   ("/xf0/xaf/xa6/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F9B6");
+-   ("/xf0/xaf/xa6/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F9B7");
+-   ("/xf0/xaf/xa6/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F9B8");
+-   ("/xf0/xaf/xa6/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F9B9");
+-   ("/xf0/xaf/xa6/xba", "CJK COMPATIBILITY IDEOGRAPH-2F9BA");
+-   ("/xf0/xaf/xa6/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F9BB");
+-   ("/xf0/xaf/xa6/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F9BC");
+-   ("/xf0/xaf/xa6/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F9BD");
+-   ("/xf0/xaf/xa6/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F9BE");
+-   ("/xf0/xaf/xa6/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F9BF");
+-   ("/xf0/xaf/xa7/x80", "CJK COMPATIBILITY IDEOGRAPH-2F9C0");
+-   ("/xf0/xaf/xa7/x81", "CJK COMPATIBILITY IDEOGRAPH-2F9C1");
+-   ("/xf0/xaf/xa7/x82", "CJK COMPATIBILITY IDEOGRAPH-2F9C2");
+-   ("/xf0/xaf/xa7/x83", "CJK COMPATIBILITY IDEOGRAPH-2F9C3");
+-   ("/xf0/xaf/xa7/x84", "CJK COMPATIBILITY IDEOGRAPH-2F9C4");
+-   ("/xf0/xaf/xa7/x85", "CJK COMPATIBILITY IDEOGRAPH-2F9C5");
+-   ("/xf0/xaf/xa7/x86", "CJK COMPATIBILITY IDEOGRAPH-2F9C6");
+-   ("/xf0/xaf/xa7/x87", "CJK COMPATIBILITY IDEOGRAPH-2F9C7");
+-   ("/xf0/xaf/xa7/x88", "CJK COMPATIBILITY IDEOGRAPH-2F9C8");
+-   ("/xf0/xaf/xa7/x89", "CJK COMPATIBILITY IDEOGRAPH-2F9C9");
+-   ("/xf0/xaf/xa7/x8a", "CJK COMPATIBILITY IDEOGRAPH-2F9CA");
+-   ("/xf0/xaf/xa7/x8b", "CJK COMPATIBILITY IDEOGRAPH-2F9CB");
+-   ("/xf0/xaf/xa7/x8c", "CJK COMPATIBILITY IDEOGRAPH-2F9CC");
+-   ("/xf0/xaf/xa7/x8d", "CJK COMPATIBILITY IDEOGRAPH-2F9CD");
+-   ("/xf0/xaf/xa7/x8e", "CJK COMPATIBILITY IDEOGRAPH-2F9CE");
+-   ("/xf0/xaf/xa7/x8f", "CJK COMPATIBILITY IDEOGRAPH-2F9CF");
+-   ("/xf0/xaf/xa7/x90", "CJK COMPATIBILITY IDEOGRAPH-2F9D0");
+-   ("/xf0/xaf/xa7/x91", "CJK COMPATIBILITY IDEOGRAPH-2F9D1");
+-   ("/xf0/xaf/xa7/x92", "CJK COMPATIBILITY IDEOGRAPH-2F9D2");
+-   ("/xf0/xaf/xa7/x93", "CJK COMPATIBILITY IDEOGRAPH-2F9D3");
+-   ("/xf0/xaf/xa7/x94", "CJK COMPATIBILITY IDEOGRAPH-2F9D4");
+-   ("/xf0/xaf/xa7/x95", "CJK COMPATIBILITY IDEOGRAPH-2F9D5");
+-   ("/xf0/xaf/xa7/x96", "CJK COMPATIBILITY IDEOGRAPH-2F9D6");
+-   ("/xf0/xaf/xa7/x97", "CJK COMPATIBILITY IDEOGRAPH-2F9D7");
+-   ("/xf0/xaf/xa7/x98", "CJK COMPATIBILITY IDEOGRAPH-2F9D8");
+-   ("/xf0/xaf/xa7/x99", "CJK COMPATIBILITY IDEOGRAPH-2F9D9");
+-   ("/xf0/xaf/xa7/x9a", "CJK COMPATIBILITY IDEOGRAPH-2F9DA");
+-   ("/xf0/xaf/xa7/x9b", "CJK COMPATIBILITY IDEOGRAPH-2F9DB");
+-   ("/xf0/xaf/xa7/x9c", "CJK COMPATIBILITY IDEOGRAPH-2F9DC");
+-   ("/xf0/xaf/xa7/x9d", "CJK COMPATIBILITY IDEOGRAPH-2F9DD");
+-   ("/xf0/xaf/xa7/x9e", "CJK COMPATIBILITY IDEOGRAPH-2F9DE");
+-   ("/xf0/xaf/xa7/x9f", "CJK COMPATIBILITY IDEOGRAPH-2F9DF");
+-   ("/xf0/xaf/xa7/xa0", "CJK COMPATIBILITY IDEOGRAPH-2F9E0");
+-   ("/xf0/xaf/xa7/xa1", "CJK COMPATIBILITY IDEOGRAPH-2F9E1");
+-   ("/xf0/xaf/xa7/xa2", "CJK COMPATIBILITY IDEOGRAPH-2F9E2");
+-   ("/xf0/xaf/xa7/xa3", "CJK COMPATIBILITY IDEOGRAPH-2F9E3");
+-   ("/xf0/xaf/xa7/xa4", "CJK COMPATIBILITY IDEOGRAPH-2F9E4");
+-   ("/xf0/xaf/xa7/xa5", "CJK COMPATIBILITY IDEOGRAPH-2F9E5");
+-   ("/xf0/xaf/xa7/xa6", "CJK COMPATIBILITY IDEOGRAPH-2F9E6");
+-   ("/xf0/xaf/xa7/xa7", "CJK COMPATIBILITY IDEOGRAPH-2F9E7");
+-   ("/xf0/xaf/xa7/xa8", "CJK COMPATIBILITY IDEOGRAPH-2F9E8");
+-   ("/xf0/xaf/xa7/xa9", "CJK COMPATIBILITY IDEOGRAPH-2F9E9");
+-   ("/xf0/xaf/xa7/xaa", "CJK COMPATIBILITY IDEOGRAPH-2F9EA");
+-   ("/xf0/xaf/xa7/xab", "CJK COMPATIBILITY IDEOGRAPH-2F9EB");
+-   ("/xf0/xaf/xa7/xac", "CJK COMPATIBILITY IDEOGRAPH-2F9EC");
+-   ("/xf0/xaf/xa7/xad", "CJK COMPATIBILITY IDEOGRAPH-2F9ED");
+-   ("/xf0/xaf/xa7/xae", "CJK COMPATIBILITY IDEOGRAPH-2F9EE");
+-   ("/xf0/xaf/xa7/xaf", "CJK COMPATIBILITY IDEOGRAPH-2F9EF");
+-   ("/xf0/xaf/xa7/xb0", "CJK COMPATIBILITY IDEOGRAPH-2F9F0");
+-   ("/xf0/xaf/xa7/xb1", "CJK COMPATIBILITY IDEOGRAPH-2F9F1");
+-   ("/xf0/xaf/xa7/xb2", "CJK COMPATIBILITY IDEOGRAPH-2F9F2");
+-   ("/xf0/xaf/xa7/xb3", "CJK COMPATIBILITY IDEOGRAPH-2F9F3");
+-   ("/xf0/xaf/xa7/xb4", "CJK COMPATIBILITY IDEOGRAPH-2F9F4");
+-   ("/xf0/xaf/xa7/xb5", "CJK COMPATIBILITY IDEOGRAPH-2F9F5");
+-   ("/xf0/xaf/xa7/xb6", "CJK COMPATIBILITY IDEOGRAPH-2F9F6");
+-   ("/xf0/xaf/xa7/xb7", "CJK COMPATIBILITY IDEOGRAPH-2F9F7");
+-   ("/xf0/xaf/xa7/xb8", "CJK COMPATIBILITY IDEOGRAPH-2F9F8");
+-   ("/xf0/xaf/xa7/xb9", "CJK COMPATIBILITY IDEOGRAPH-2F9F9");
+-   ("/xf0/xaf/xa7/xba", "CJK COMPATIBILITY IDEOGRAPH-2F9FA");
+-   ("/xf0/xaf/xa7/xbb", "CJK COMPATIBILITY IDEOGRAPH-2F9FB");
+-   ("/xf0/xaf/xa7/xbc", "CJK COMPATIBILITY IDEOGRAPH-2F9FC");
+-   ("/xf0/xaf/xa7/xbd", "CJK COMPATIBILITY IDEOGRAPH-2F9FD");
+-   ("/xf0/xaf/xa7/xbe", "CJK COMPATIBILITY IDEOGRAPH-2F9FE");
+-   ("/xf0/xaf/xa7/xbf", "CJK COMPATIBILITY IDEOGRAPH-2F9FF");
+-   ("/xf0/xaf/xa8/x80", "CJK COMPATIBILITY IDEOGRAPH-2FA00");
+-   ("/xf0/xaf/xa8/x81", "CJK COMPATIBILITY IDEOGRAPH-2FA01");
+-   ("/xf0/xaf/xa8/x82", "CJK COMPATIBILITY IDEOGRAPH-2FA02");
+-   ("/xf0/xaf/xa8/x83", "CJK COMPATIBILITY IDEOGRAPH-2FA03");
+-   ("/xf0/xaf/xa8/x84", "CJK COMPATIBILITY IDEOGRAPH-2FA04");
+-   ("/xf0/xaf/xa8/x85", "CJK COMPATIBILITY IDEOGRAPH-2FA05");
+-   ("/xf0/xaf/xa8/x86", "CJK COMPATIBILITY IDEOGRAPH-2FA06");
+-   ("/xf0/xaf/xa8/x87", "CJK COMPATIBILITY IDEOGRAPH-2FA07");
+-   ("/xf0/xaf/xa8/x88", "CJK COMPATIBILITY IDEOGRAPH-2FA08");
+-   ("/xf0/xaf/xa8/x89", "CJK COMPATIBILITY IDEOGRAPH-2FA09");
+-   ("/xf0/xaf/xa8/x8a", "CJK COMPATIBILITY IDEOGRAPH-2FA0A");
+-   ("/xf0/xaf/xa8/x8b", "CJK COMPATIBILITY IDEOGRAPH-2FA0B");
+-   ("/xf0/xaf/xa8/x8c", "CJK COMPATIBILITY IDEOGRAPH-2FA0C");
+-   ("/xf0/xaf/xa8/x8d", "CJK COMPATIBILITY IDEOGRAPH-2FA0D");
+-   ("/xf0/xaf/xa8/x8e", "CJK COMPATIBILITY IDEOGRAPH-2FA0E");
+-   ("/xf0/xaf/xa8/x8f", "CJK COMPATIBILITY IDEOGRAPH-2FA0F");
+-   ("/xf0/xaf/xa8/x90", "CJK COMPATIBILITY IDEOGRAPH-2FA10");
+-   ("/xf0/xaf/xa8/x91", "CJK COMPATIBILITY IDEOGRAPH-2FA11");
+-   ("/xf0/xaf/xa8/x92", "CJK COMPATIBILITY IDEOGRAPH-2FA12");
+-   ("/xf0/xaf/xa8/x93", "CJK COMPATIBILITY IDEOGRAPH-2FA13");
+-   ("/xf0/xaf/xa8/x94", "CJK COMPATIBILITY IDEOGRAPH-2FA14");
+-   ("/xf0/xaf/xa8/x95", "CJK COMPATIBILITY IDEOGRAPH-2FA15");
+-   ("/xf0/xaf/xa8/x96", "CJK COMPATIBILITY IDEOGRAPH-2FA16");
+-   ("/xf0/xaf/xa8/x97", "CJK COMPATIBILITY IDEOGRAPH-2FA17");
+-   ("/xf0/xaf/xa8/x98", "CJK COMPATIBILITY IDEOGRAPH-2FA18");
+-   ("/xf0/xaf/xa8/x99", "CJK COMPATIBILITY IDEOGRAPH-2FA19");
+-   ("/xf0/xaf/xa8/x9a", "CJK COMPATIBILITY IDEOGRAPH-2FA1A");
+-   ("/xf0/xaf/xa8/x9b", "CJK COMPATIBILITY IDEOGRAPH-2FA1B");
+-   ("/xf0/xaf/xa8/x9c", "CJK COMPATIBILITY IDEOGRAPH-2FA1C");
+-   ("/xf0/xaf/xa8/x9d", "CJK COMPATIBILITY IDEOGRAPH-2FA1D");
+-   ("/xf3/xa0/x80/x81", "LANGUAGE TAG");
+-   ("/xf3/xa0/x80/xa0", "TAG SPACE");
+-   ("/xf3/xa0/x80/xa1", "TAG EXCLAMATION MARK");
+-   ("/xf3/xa0/x80/xa2", "TAG QUOTATION MARK");
+-   ("/xf3/xa0/x80/xa3", "TAG NUMBER SIGN");
+-   ("/xf3/xa0/x80/xa4", "TAG DOLLAR SIGN");
+-   ("/xf3/xa0/x80/xa5", "TAG PERCENT SIGN");
+-   ("/xf3/xa0/x80/xa6", "TAG AMPERSAND");
+-   ("/xf3/xa0/x80/xa7", "TAG APOSTROPHE");
+-   ("/xf3/xa0/x80/xa8", "TAG LEFT PARENTHESIS");
+-   ("/xf3/xa0/x80/xa9", "TAG RIGHT PARENTHESIS");
+-   ("/xf3/xa0/x80/xaa", "TAG ASTERISK");
+-   ("/xf3/xa0/x80/xab", "TAG PLUS SIGN");
+-   ("/xf3/xa0/x80/xac", "TAG COMMA");
+-   ("/xf3/xa0/x80/xad", "TAG HYPHEN-MINUS");
+-   ("/xf3/xa0/x80/xae", "TAG FULL STOP");
+-   ("/xf3/xa0/x80/xaf", "TAG SOLIDUS");
+-   ("/xf3/xa0/x80/xb0", "TAG DIGIT ZERO");
+-   ("/xf3/xa0/x80/xb1", "TAG DIGIT ONE");
+-   ("/xf3/xa0/x80/xb2", "TAG DIGIT TWO");
+-   ("/xf3/xa0/x80/xb3", "TAG DIGIT THREE");
+-   ("/xf3/xa0/x80/xb4", "TAG DIGIT FOUR");
+-   ("/xf3/xa0/x80/xb5", "TAG DIGIT FIVE");
+-   ("/xf3/xa0/x80/xb6", "TAG DIGIT SIX");
+-   ("/xf3/xa0/x80/xb7", "TAG DIGIT SEVEN");
+-   ("/xf3/xa0/x80/xb8", "TAG DIGIT EIGHT");
+-   ("/xf3/xa0/x80/xb9", "TAG DIGIT NINE");
+-   ("/xf3/xa0/x80/xba", "TAG COLON");
+-   ("/xf3/xa0/x80/xbb", "TAG SEMICOLON");
+-   ("/xf3/xa0/x80/xbc", "TAG LESS-THAN SIGN");
+-   ("/xf3/xa0/x80/xbd", "TAG EQUALS SIGN");
+-   ("/xf3/xa0/x80/xbe", "TAG GREATER-THAN SIGN");
+-   ("/xf3/xa0/x80/xbf", "TAG QUESTION MARK");
+-   ("/xf3/xa0/x81/x80", "TAG COMMERCIAL AT");
+    ("/xf3/xa0/x81/x81", "TAG LATIN CAPITAL LETTER A");
+    ("/xf3/xa0/x81/x82", "TAG LATIN CAPITAL LETTER B");
+    ("/xf3/xa0/x81/x83", "TAG LATIN CAPITAL LETTER C");
+@@ -31423,12 +3581,6 @@
+    ("/xf3/xa0/x81/x98", "TAG LATIN CAPITAL LETTER X");
+    ("/xf3/xa0/x81/x99", "TAG LATIN CAPITAL LETTER Y");
+    ("/xf3/xa0/x81/x9a", "TAG LATIN CAPITAL LETTER Z");
+-   ("/xf3/xa0/x81/x9b", "TAG LEFT SQUARE BRACKET");
+-   ("/xf3/xa0/x81/x9c", "TAG REVERSE SOLIDUS");
+-   ("/xf3/xa0/x81/x9d", "TAG RIGHT SQUARE BRACKET");
+-   ("/xf3/xa0/x81/x9e", "TAG CIRCUMFLEX ACCENT");
+-   ("/xf3/xa0/x81/x9f", "TAG LOW LINE");
+-   ("/xf3/xa0/x81/xa0", "TAG GRAVE ACCENT");
+    ("/xf3/xa0/x81/xa1", "TAG LATIN SMALL LETTER A");
+    ("/xf3/xa0/x81/xa2", "TAG LATIN SMALL LETTER B");
+    ("/xf3/xa0/x81/xa3", "TAG LATIN SMALL LETTER C");
+@@ -31454,250 +3606,5 @@
+    ("/xf3/xa0/x81/xb7", "TAG LATIN SMALL LETTER W");
+    ("/xf3/xa0/x81/xb8", "TAG LATIN SMALL LETTER X");
+    ("/xf3/xa0/x81/xb9", "TAG LATIN SMALL LETTER Y");
+-   ("/xf3/xa0/x81/xba", "TAG LATIN SMALL LETTER Z");
+-   ("/xf3/xa0/x81/xbb", "TAG LEFT CURLY BRACKET");
+-   ("/xf3/xa0/x81/xbc", "TAG VERTICAL LINE");
+-   ("/xf3/xa0/x81/xbd", "TAG RIGHT CURLY BRACKET");
+-   ("/xf3/xa0/x81/xbe", "TAG TILDE");
+-   ("/xf3/xa0/x81/xbf", "CANCEL TAG");
+-   ("/xf3/xa0/x84/x80", "VARIATION SELECTOR-17");
+-   ("/xf3/xa0/x84/x81", "VARIATION SELECTOR-18");
+-   ("/xf3/xa0/x84/x82", "VARIATION SELECTOR-19");
+-   ("/xf3/xa0/x84/x83", "VARIATION SELECTOR-20");
+-   ("/xf3/xa0/x84/x84", "VARIATION SELECTOR-21");
+-   ("/xf3/xa0/x84/x85", "VARIATION SELECTOR-22");
+-   ("/xf3/xa0/x84/x86", "VARIATION SELECTOR-23");
+-   ("/xf3/xa0/x84/x87", "VARIATION SELECTOR-24");
+-   ("/xf3/xa0/x84/x88", "VARIATION SELECTOR-25");
+-   ("/xf3/xa0/x84/x89", "VARIATION SELECTOR-26");
+-   ("/xf3/xa0/x84/x8a", "VARIATION SELECTOR-27");
+-   ("/xf3/xa0/x84/x8b", "VARIATION SELECTOR-28");
+-   ("/xf3/xa0/x84/x8c", "VARIATION SELECTOR-29");
+-   ("/xf3/xa0/x84/x8d", "VARIATION SELECTOR-30");
+-   ("/xf3/xa0/x84/x8e", "VARIATION SELECTOR-31");
+-   ("/xf3/xa0/x84/x8f", "VARIATION SELECTOR-32");
+-   ("/xf3/xa0/x84/x90", "VARIATION SELECTOR-33");
+-   ("/xf3/xa0/x84/x91", "VARIATION SELECTOR-34");
+-   ("/xf3/xa0/x84/x92", "VARIATION SELECTOR-35");
+-   ("/xf3/xa0/x84/x93", "VARIATION SELECTOR-36");
+-   ("/xf3/xa0/x84/x94", "VARIATION SELECTOR-37");
+-   ("/xf3/xa0/x84/x95", "VARIATION SELECTOR-38");
+-   ("/xf3/xa0/x84/x96", "VARIATION SELECTOR-39");
+-   ("/xf3/xa0/x84/x97", "VARIATION SELECTOR-40");
+-   ("/xf3/xa0/x84/x98", "VARIATION SELECTOR-41");
+-   ("/xf3/xa0/x84/x99", "VARIATION SELECTOR-42");
+-   ("/xf3/xa0/x84/x9a", "VARIATION SELECTOR-43");
+-   ("/xf3/xa0/x84/x9b", "VARIATION SELECTOR-44");
+-   ("/xf3/xa0/x84/x9c", "VARIATION SELECTOR-45");
+-   ("/xf3/xa0/x84/x9d", "VARIATION SELECTOR-46");
+-   ("/xf3/xa0/x84/x9e", "VARIATION SELECTOR-47");
+-   ("/xf3/xa0/x84/x9f", "VARIATION SELECTOR-48");
+-   ("/xf3/xa0/x84/xa0", "VARIATION SELECTOR-49");
+-   ("/xf3/xa0/x84/xa1", "VARIATION SELECTOR-50");
+-   ("/xf3/xa0/x84/xa2", "VARIATION SELECTOR-51");
+-   ("/xf3/xa0/x84/xa3", "VARIATION SELECTOR-52");
+-   ("/xf3/xa0/x84/xa4", "VARIATION SELECTOR-53");
+-   ("/xf3/xa0/x84/xa5", "VARIATION SELECTOR-54");
+-   ("/xf3/xa0/x84/xa6", "VARIATION SELECTOR-55");
+-   ("/xf3/xa0/x84/xa7", "VARIATION SELECTOR-56");
+-   ("/xf3/xa0/x84/xa8", "VARIATION SELECTOR-57");
+-   ("/xf3/xa0/x84/xa9", "VARIATION SELECTOR-58");
+-   ("/xf3/xa0/x84/xaa", "VARIATION SELECTOR-59");
+-   ("/xf3/xa0/x84/xab", "VARIATION SELECTOR-60");
+-   ("/xf3/xa0/x84/xac", "VARIATION SELECTOR-61");
+-   ("/xf3/xa0/x84/xad", "VARIATION SELECTOR-62");
+-   ("/xf3/xa0/x84/xae", "VARIATION SELECTOR-63");
+-   ("/xf3/xa0/x84/xaf", "VARIATION SELECTOR-64");
+-   ("/xf3/xa0/x84/xb0", "VARIATION SELECTOR-65");
+-   ("/xf3/xa0/x84/xb1", "VARIATION SELECTOR-66");
+-   ("/xf3/xa0/x84/xb2", "VARIATION SELECTOR-67");
+-   ("/xf3/xa0/x84/xb3", "VARIATION SELECTOR-68");
+-   ("/xf3/xa0/x84/xb4", "VARIATION SELECTOR-69");
+-   ("/xf3/xa0/x84/xb5", "VARIATION SELECTOR-70");
+-   ("/xf3/xa0/x84/xb6", "VARIATION SELECTOR-71");
+-   ("/xf3/xa0/x84/xb7", "VARIATION SELECTOR-72");
+-   ("/xf3/xa0/x84/xb8", "VARIATION SELECTOR-73");
+-   ("/xf3/xa0/x84/xb9", "VARIATION SELECTOR-74");
+-   ("/xf3/xa0/x84/xba", "VARIATION SELECTOR-75");
+-   ("/xf3/xa0/x84/xbb", "VARIATION SELECTOR-76");
+-   ("/xf3/xa0/x84/xbc", "VARIATION SELECTOR-77");
+-   ("/xf3/xa0/x84/xbd", "VARIATION SELECTOR-78");
+-   ("/xf3/xa0/x84/xbe", "VARIATION SELECTOR-79");
+-   ("/xf3/xa0/x84/xbf", "VARIATION SELECTOR-80");
+-   ("/xf3/xa0/x85/x80", "VARIATION SELECTOR-81");
+-   ("/xf3/xa0/x85/x81", "VARIATION SELECTOR-82");
+-   ("/xf3/xa0/x85/x82", "VARIATION SELECTOR-83");
+-   ("/xf3/xa0/x85/x83", "VARIATION SELECTOR-84");
+-   ("/xf3/xa0/x85/x84", "VARIATION SELECTOR-85");
+-   ("/xf3/xa0/x85/x85", "VARIATION SELECTOR-86");
+-   ("/xf3/xa0/x85/x86", "VARIATION SELECTOR-87");
+-   ("/xf3/xa0/x85/x87", "VARIATION SELECTOR-88");
+-   ("/xf3/xa0/x85/x88", "VARIATION SELECTOR-89");
+-   ("/xf3/xa0/x85/x89", "VARIATION SELECTOR-90");
+-   ("/xf3/xa0/x85/x8a", "VARIATION SELECTOR-91");
+-   ("/xf3/xa0/x85/x8b", "VARIATION SELECTOR-92");
+-   ("/xf3/xa0/x85/x8c", "VARIATION SELECTOR-93");
+-   ("/xf3/xa0/x85/x8d", "VARIATION SELECTOR-94");
+-   ("/xf3/xa0/x85/x8e", "VARIATION SELECTOR-95");
+-   ("/xf3/xa0/x85/x8f", "VARIATION SELECTOR-96");
+-   ("/xf3/xa0/x85/x90", "VARIATION SELECTOR-97");
+-   ("/xf3/xa0/x85/x91", "VARIATION SELECTOR-98");
+-   ("/xf3/xa0/x85/x92", "VARIATION SELECTOR-99");
+-   ("/xf3/xa0/x85/x93", "VARIATION SELECTOR-100");
+-   ("/xf3/xa0/x85/x94", "VARIATION SELECTOR-101");
+-   ("/xf3/xa0/x85/x95", "VARIATION SELECTOR-102");
+-   ("/xf3/xa0/x85/x96", "VARIATION SELECTOR-103");
+-   ("/xf3/xa0/x85/x97", "VARIATION SELECTOR-104");
+-   ("/xf3/xa0/x85/x98", "VARIATION SELECTOR-105");
+-   ("/xf3/xa0/x85/x99", "VARIATION SELECTOR-106");
+-   ("/xf3/xa0/x85/x9a", "VARIATION SELECTOR-107");
+-   ("/xf3/xa0/x85/x9b", "VARIATION SELECTOR-108");
+-   ("/xf3/xa0/x85/x9c", "VARIATION SELECTOR-109");
+-   ("/xf3/xa0/x85/x9d", "VARIATION SELECTOR-110");
+-   ("/xf3/xa0/x85/x9e", "VARIATION SELECTOR-111");
+-   ("/xf3/xa0/x85/x9f", "VARIATION SELECTOR-112");
+-   ("/xf3/xa0/x85/xa0", "VARIATION SELECTOR-113");
+-   ("/xf3/xa0/x85/xa1", "VARIATION SELECTOR-114");
+-   ("/xf3/xa0/x85/xa2", "VARIATION SELECTOR-115");
+-   ("/xf3/xa0/x85/xa3", "VARIATION SELECTOR-116");
+-   ("/xf3/xa0/x85/xa4", "VARIATION SELECTOR-117");
+-   ("/xf3/xa0/x85/xa5", "VARIATION SELECTOR-118");
+-   ("/xf3/xa0/x85/xa6", "VARIATION SELECTOR-119");
+-   ("/xf3/xa0/x85/xa7", "VARIATION SELECTOR-120");
+-   ("/xf3/xa0/x85/xa8", "VARIATION SELECTOR-121");
+-   ("/xf3/xa0/x85/xa9", "VARIATION SELECTOR-122");
+-   ("/xf3/xa0/x85/xaa", "VARIATION SELECTOR-123");
+-   ("/xf3/xa0/x85/xab", "VARIATION SELECTOR-124");
+-   ("/xf3/xa0/x85/xac", "VARIATION SELECTOR-125");
+-   ("/xf3/xa0/x85/xad", "VARIATION SELECTOR-126");
+-   ("/xf3/xa0/x85/xae", "VARIATION SELECTOR-127");
+-   ("/xf3/xa0/x85/xaf", "VARIATION SELECTOR-128");
+-   ("/xf3/xa0/x85/xb0", "VARIATION SELECTOR-129");
+-   ("/xf3/xa0/x85/xb1", "VARIATION SELECTOR-130");
+-   ("/xf3/xa0/x85/xb2", "VARIATION SELECTOR-131");
+-   ("/xf3/xa0/x85/xb3", "VARIATION SELECTOR-132");
+-   ("/xf3/xa0/x85/xb4", "VARIATION SELECTOR-133");
+-   ("/xf3/xa0/x85/xb5", "VARIATION SELECTOR-134");
+-   ("/xf3/xa0/x85/xb6", "VARIATION SELECTOR-135");
+-   ("/xf3/xa0/x85/xb7", "VARIATION SELECTOR-136");
+-   ("/xf3/xa0/x85/xb8", "VARIATION SELECTOR-137");
+-   ("/xf3/xa0/x85/xb9", "VARIATION SELECTOR-138");
+-   ("/xf3/xa0/x85/xba", "VARIATION SELECTOR-139");
+-   ("/xf3/xa0/x85/xbb", "VARIATION SELECTOR-140");
+-   ("/xf3/xa0/x85/xbc", "VARIATION SELECTOR-141");
+-   ("/xf3/xa0/x85/xbd", "VARIATION SELECTOR-142");
+-   ("/xf3/xa0/x85/xbe", "VARIATION SELECTOR-143");
+-   ("/xf3/xa0/x85/xbf", "VARIATION SELECTOR-144");
+-   ("/xf3/xa0/x86/x80", "VARIATION SELECTOR-145");
+-   ("/xf3/xa0/x86/x81", "VARIATION SELECTOR-146");
+-   ("/xf3/xa0/x86/x82", "VARIATION SELECTOR-147");
+-   ("/xf3/xa0/x86/x83", "VARIATION SELECTOR-148");
+-   ("/xf3/xa0/x86/x84", "VARIATION SELECTOR-149");
+-   ("/xf3/xa0/x86/x85", "VARIATION SELECTOR-150");
+-   ("/xf3/xa0/x86/x86", "VARIATION SELECTOR-151");
+-   ("/xf3/xa0/x86/x87", "VARIATION SELECTOR-152");
+-   ("/xf3/xa0/x86/x88", "VARIATION SELECTOR-153");
+-   ("/xf3/xa0/x86/x89", "VARIATION SELECTOR-154");
+-   ("/xf3/xa0/x86/x8a", "VARIATION SELECTOR-155");
+-   ("/xf3/xa0/x86/x8b", "VARIATION SELECTOR-156");
+-   ("/xf3/xa0/x86/x8c", "VARIATION SELECTOR-157");
+-   ("/xf3/xa0/x86/x8d", "VARIATION SELECTOR-158");
+-   ("/xf3/xa0/x86/x8e", "VARIATION SELECTOR-159");
+-   ("/xf3/xa0/x86/x8f", "VARIATION SELECTOR-160");
+-   ("/xf3/xa0/x86/x90", "VARIATION SELECTOR-161");
+-   ("/xf3/xa0/x86/x91", "VARIATION SELECTOR-162");
+-   ("/xf3/xa0/x86/x92", "VARIATION SELECTOR-163");
+-   ("/xf3/xa0/x86/x93", "VARIATION SELECTOR-164");
+-   ("/xf3/xa0/x86/x94", "VARIATION SELECTOR-165");
+-   ("/xf3/xa0/x86/x95", "VARIATION SELECTOR-166");
+-   ("/xf3/xa0/x86/x96", "VARIATION SELECTOR-167");
+-   ("/xf3/xa0/x86/x97", "VARIATION SELECTOR-168");
+-   ("/xf3/xa0/x86/x98", "VARIATION SELECTOR-169");
+-   ("/xf3/xa0/x86/x99", "VARIATION SELECTOR-170");
+-   ("/xf3/xa0/x86/x9a", "VARIATION SELECTOR-171");
+-   ("/xf3/xa0/x86/x9b", "VARIATION SELECTOR-172");
+-   ("/xf3/xa0/x86/x9c", "VARIATION SELECTOR-173");
+-   ("/xf3/xa0/x86/x9d", "VARIATION SELECTOR-174");
+-   ("/xf3/xa0/x86/x9e", "VARIATION SELECTOR-175");
+-   ("/xf3/xa0/x86/x9f", "VARIATION SELECTOR-176");
+-   ("/xf3/xa0/x86/xa0", "VARIATION SELECTOR-177");
+-   ("/xf3/xa0/x86/xa1", "VARIATION SELECTOR-178");
+-   ("/xf3/xa0/x86/xa2", "VARIATION SELECTOR-179");
+-   ("/xf3/xa0/x86/xa3", "VARIATION SELECTOR-180");
+-   ("/xf3/xa0/x86/xa4", "VARIATION SELECTOR-181");
+-   ("/xf3/xa0/x86/xa5", "VARIATION SELECTOR-182");
+-   ("/xf3/xa0/x86/xa6", "VARIATION SELECTOR-183");
+-   ("/xf3/xa0/x86/xa7", "VARIATION SELECTOR-184");
+-   ("/xf3/xa0/x86/xa8", "VARIATION SELECTOR-185");
+-   ("/xf3/xa0/x86/xa9", "VARIATION SELECTOR-186");
+-   ("/xf3/xa0/x86/xaa", "VARIATION SELECTOR-187");
+-   ("/xf3/xa0/x86/xab", "VARIATION SELECTOR-188");
+-   ("/xf3/xa0/x86/xac", "VARIATION SELECTOR-189");
+-   ("/xf3/xa0/x86/xad", "VARIATION SELECTOR-190");
+-   ("/xf3/xa0/x86/xae", "VARIATION SELECTOR-191");
+-   ("/xf3/xa0/x86/xaf", "VARIATION SELECTOR-192");
+-   ("/xf3/xa0/x86/xb0", "VARIATION SELECTOR-193");
+-   ("/xf3/xa0/x86/xb1", "VARIATION SELECTOR-194");
+-   ("/xf3/xa0/x86/xb2", "VARIATION SELECTOR-195");
+-   ("/xf3/xa0/x86/xb3", "VARIATION SELECTOR-196");
+-   ("/xf3/xa0/x86/xb4", "VARIATION SELECTOR-197");
+-   ("/xf3/xa0/x86/xb5", "VARIATION SELECTOR-198");
+-   ("/xf3/xa0/x86/xb6", "VARIATION SELECTOR-199");
+-   ("/xf3/xa0/x86/xb7", "VARIATION SELECTOR-200");
+-   ("/xf3/xa0/x86/xb8", "VARIATION SELECTOR-201");
+-   ("/xf3/xa0/x86/xb9", "VARIATION SELECTOR-202");
+-   ("/xf3/xa0/x86/xba", "VARIATION SELECTOR-203");
+-   ("/xf3/xa0/x86/xbb", "VARIATION SELECTOR-204");
+-   ("/xf3/xa0/x86/xbc", "VARIATION SELECTOR-205");
+-   ("/xf3/xa0/x86/xbd", "VARIATION SELECTOR-206");
+-   ("/xf3/xa0/x86/xbe", "VARIATION SELECTOR-207");
+-   ("/xf3/xa0/x86/xbf", "VARIATION SELECTOR-208");
+-   ("/xf3/xa0/x87/x80", "VARIATION SELECTOR-209");
+-   ("/xf3/xa0/x87/x81", "VARIATION SELECTOR-210");
+-   ("/xf3/xa0/x87/x82", "VARIATION SELECTOR-211");
+-   ("/xf3/xa0/x87/x83", "VARIATION SELECTOR-212");
+-   ("/xf3/xa0/x87/x84", "VARIATION SELECTOR-213");
+-   ("/xf3/xa0/x87/x85", "VARIATION SELECTOR-214");
+-   ("/xf3/xa0/x87/x86", "VARIATION SELECTOR-215");
+-   ("/xf3/xa0/x87/x87", "VARIATION SELECTOR-216");
+-   ("/xf3/xa0/x87/x88", "VARIATION SELECTOR-217");
+-   ("/xf3/xa0/x87/x89", "VARIATION SELECTOR-218");
+-   ("/xf3/xa0/x87/x8a", "VARIATION SELECTOR-219");
+-   ("/xf3/xa0/x87/x8b", "VARIATION SELECTOR-220");
+-   ("/xf3/xa0/x87/x8c", "VARIATION SELECTOR-221");
+-   ("/xf3/xa0/x87/x8d", "VARIATION SELECTOR-222");
+-   ("/xf3/xa0/x87/x8e", "VARIATION SELECTOR-223");
+-   ("/xf3/xa0/x87/x8f", "VARIATION SELECTOR-224");
+-   ("/xf3/xa0/x87/x90", "VARIATION SELECTOR-225");
+-   ("/xf3/xa0/x87/x91", "VARIATION SELECTOR-226");
+-   ("/xf3/xa0/x87/x92", "VARIATION SELECTOR-227");
+-   ("/xf3/xa0/x87/x93", "VARIATION SELECTOR-228");
+-   ("/xf3/xa0/x87/x94", "VARIATION SELECTOR-229");
+-   ("/xf3/xa0/x87/x95", "VARIATION SELECTOR-230");
+-   ("/xf3/xa0/x87/x96", "VARIATION SELECTOR-231");
+-   ("/xf3/xa0/x87/x97", "VARIATION SELECTOR-232");
+-   ("/xf3/xa0/x87/x98", "VARIATION SELECTOR-233");
+-   ("/xf3/xa0/x87/x99", "VARIATION SELECTOR-234");
+-   ("/xf3/xa0/x87/x9a", "VARIATION SELECTOR-235");
+-   ("/xf3/xa0/x87/x9b", "VARIATION SELECTOR-236");
+-   ("/xf3/xa0/x87/x9c", "VARIATION SELECTOR-237");
+-   ("/xf3/xa0/x87/x9d", "VARIATION SELECTOR-238");
+-   ("/xf3/xa0/x87/x9e", "VARIATION SELECTOR-239");
+-   ("/xf3/xa0/x87/x9f", "VARIATION SELECTOR-240");
+-   ("/xf3/xa0/x87/xa0", "VARIATION SELECTOR-241");
+-   ("/xf3/xa0/x87/xa1", "VARIATION SELECTOR-242");
+-   ("/xf3/xa0/x87/xa2", "VARIATION SELECTOR-243");
+-   ("/xf3/xa0/x87/xa3", "VARIATION SELECTOR-244");
+-   ("/xf3/xa0/x87/xa4", "VARIATION SELECTOR-245");
+-   ("/xf3/xa0/x87/xa5", "VARIATION SELECTOR-246");
+-   ("/xf3/xa0/x87/xa6", "VARIATION SELECTOR-247");
+-   ("/xf3/xa0/x87/xa7", "VARIATION SELECTOR-248");
+-   ("/xf3/xa0/x87/xa8", "VARIATION SELECTOR-249");
+-   ("/xf3/xa0/x87/xa9", "VARIATION SELECTOR-250");
+-   ("/xf3/xa0/x87/xaa", "VARIATION SELECTOR-251");
+-   ("/xf3/xa0/x87/xab", "VARIATION SELECTOR-252");
+-   ("/xf3/xa0/x87/xac", "VARIATION SELECTOR-253");
+-   ("/xf3/xa0/x87/xad", "VARIATION SELECTOR-254");
+-   ("/xf3/xa0/x87/xae", "VARIATION SELECTOR-255");
+-   ("/xf3/xa0/x87/xaf", "VARIATION SELECTOR-256")]
++   ("/xf3/xa0/x81/xba", "TAG LATIN SMALL LETTER Z")]
+ ;
diff --git a/www/geneweb/files/patch-src__Makefile b/www/geneweb/files/patch-src__Makefile
new file mode 100644
index 000000000000..5b87085cbe50
--- /dev/null
+++ b/www/geneweb/files/patch-src__Makefile
@@ -0,0 +1,10 @@
+--- ./src/Makefile.orig	2013-03-01 03:06:44.000000000 -0600
++++ ./src/Makefile	2014-05-13 23:46:54.000000000 -0500
+@@ -2,7 +2,6 @@
+ 
+ include ../tools/Makefile.inc
+ 
+-PREFIX=/usr
+ OCAMLI=-I ../wserver -I ../dag2html
+ GWC_OBJS=argl.cmo lock.cmo adef.cmo iovalue.cmo buff.cmo name.cmo mutil.cmo secure.cmo btree.cmo futil.cmo dutil.cmo database.cmo db2.cmo db2disk.cmo diff.cmo outbase.cmo gwdb.cmo pqueue.cmo progrBar.cmo consang.cmo consangAll.cmo checkItem.cmo check.cmo calendar.cmo notesLinks.cmo gwcomp.cmo db1link.cmo gwc.cmo
+ GWC2_OBJS=calendar.cmo adef.cmo iovalue.cmo buff.cmo name.cmo mutil.cmo gwcomp.cmo argl.cmo lock.cmo progrBar.cmo secure.cmo iochan.cmo futil.cmo db2.cmo db2out.cmo notesLinks.cmo db2disk.cmo dutil.cmo btree.cmo database.cmo gwdb.cmo consang.cmo consangAll.cmo checkItem.cmo check.cmo db2link.cmo gwc2.cmo
diff --git a/www/geneweb/files/pkg-message.in b/www/geneweb/files/pkg-message.in
index 3e8c52ccac2c..aeab4e886690 100644
--- a/www/geneweb/files/pkg-message.in
+++ b/www/geneweb/files/pkg-message.in
@@ -16,4 +16,14 @@ http://opensource.geneanet.org/projects/geneweb/wiki
 and/or to the GeneWeb mailing list GeneWeb@yahoogroups.com if you need
 help.
 
+Main Makefile in GeneWeb 6.07 does not build the experimental GUI, however
+it remains in the codebase. GTK2 option is being retained in this port in
+case the GUI becomes part of the main Makefile again in a later version.
+
+If you notice odd failures, e.g., when editing a family, make sure you are
+using an up-to-date template. Additional attributes, e.g., occupation got
+added around v6.06, and if your template does not include this, you will
+likely experience problems as the code throws an exception when trying to
+edit a family.
+
 ==========================================================================
diff --git a/www/geneweb/pkg-plist b/www/geneweb/pkg-plist
index 368592757c17..bec43b1ec7c1 100644
--- a/www/geneweb/pkg-plist
+++ b/www/geneweb/pkg-plist
@@ -7,6 +7,14 @@ bin/gwc1
 bin/gwc2
 bin/gwd
 bin/gwu
+man/man1/consang.1.gz
+man/man1/ged2gwb.1.gz
+man/man1/gwb2ged.1.gz
+man/man1/gwc.1.gz
+man/man1/gwc2.1.gz
+man/man1/gwd.1.gz
+man/man1/gwsetup.1.gz
+man/man1/gwu.1.gz
 %%DATADIR%%/a.gwf
 %%DATADIR%%/distribution/CHANGES.txt
 %%DATADIR%%/distribution/LICENSE.txt
@@ -31,6 +39,9 @@ bin/gwu
 %%DATADIR%%/distribution/gw/etc/forum.txt
 %%DATADIR%%/distribution/gw/etc/hed.txt
 %%DATADIR%%/distribution/gw/etc/index.txt
+%%DATADIR%%/distribution/gw/etc/jquery_1_9_1_min.js
+%%DATADIR%%/distribution/gw/etc/jquery_placeholder_min.js
+%%DATADIR%%/distribution/gw/etc/miss_evt.txt
 %%DATADIR%%/distribution/gw/etc/moved.txt
 %%DATADIR%%/distribution/gw/etc/particles.txt
 %%DATADIR%%/distribution/gw/etc/perso.txt
@@ -139,6 +150,7 @@ bin/gwu
 %%DATADIR%%/distribution/gw/etc/templm/relmenu.txt
 %%DATADIR%%/distribution/gw/etc/templm/toolbar.txt
 %%DATADIR%%/distribution/gw/etc/templm/trl.txt
+%%DATADIR%%/distribution/gw/etc/templm/upddata.txt
 %%DATADIR%%/distribution/gw/etc/templm/updfam.txt
 %%DATADIR%%/distribution/gw/etc/templm/updind.txt
 %%DATADIR%%/distribution/gw/etc/templm/updmenu.txt
@@ -157,6 +169,7 @@ bin/gwu
 %%DATADIR%%/distribution/gw/etc/upddata.txt
 %%DATADIR%%/distribution/gw/etc/updfam.txt
 %%DATADIR%%/distribution/gw/etc/updhist.txt
+%%DATADIR%%/distribution/gw/etc/updhist_diff.txt
 %%DATADIR%%/distribution/gw/etc/updind.txt
 %%DATADIR%%/distribution/gw/etc/updmenu.txt
 %%DATADIR%%/distribution/gw/etc/welcome.txt
@@ -278,6 +291,8 @@ bin/gwu
 %%DATADIR%%/distribution/gw/images/picto_branche_patronymique.png
 %%DATADIR%%/distribution/gw/images/picto_calendar.png
 %%DATADIR%%/distribution/gw/images/picto_cle.png
+%%DATADIR%%/distribution/gw/images/picto_edit_big.png
+%%DATADIR%%/distribution/gw/images/picto_edit_small.png
 %%DATADIR%%/distribution/gw/images/picto_fleche_blanche.png
 %%DATADIR%%/distribution/gw/images/picto_fleche_bleu.png
 %%DATADIR%%/distribution/gw/images/picto_loupe.png
@@ -362,9 +377,6 @@ bin/gwu
 %%DATADIR%%/distribution/gw/update_nldb
 %%DATADIR%%/distribution/gwd
 %%DATADIR%%/distribution/gwsetup
-%%GUI%%%%DATADIR%%/distribution/geneweb_gui
-%%GUI%%%%DATADIR%%/distribution/gw/gui_lex.txt
-%%GUI%%%%DATADIR%%/distribution/gw/gui
 %%DATADIR%%/etc/accent.txt
 %%DATADIR%%/etc/advanced.txt
 %%DATADIR%%/etc/anclist.txt
@@ -383,6 +395,9 @@ bin/gwu
 %%DATADIR%%/etc/forum.txt
 %%DATADIR%%/etc/hed.txt
 %%DATADIR%%/etc/index.txt
+%%DATADIR%%/etc/jquery_1_9_1_min.js
+%%DATADIR%%/etc/jquery_placeholder_min.js
+%%DATADIR%%/etc/miss_evt.txt
 %%DATADIR%%/etc/moved.txt
 %%DATADIR%%/etc/particles.txt
 %%DATADIR%%/etc/perso.txt
@@ -491,6 +506,7 @@ bin/gwu
 %%DATADIR%%/etc/templm/relmenu.txt
 %%DATADIR%%/etc/templm/toolbar.txt
 %%DATADIR%%/etc/templm/trl.txt
+%%DATADIR%%/etc/templm/upddata.txt
 %%DATADIR%%/etc/templm/updfam.txt
 %%DATADIR%%/etc/templm/updind.txt
 %%DATADIR%%/etc/templm/updmenu.txt
@@ -509,6 +525,7 @@ bin/gwu
 %%DATADIR%%/etc/upddata.txt
 %%DATADIR%%/etc/updfam.txt
 %%DATADIR%%/etc/updhist.txt
+%%DATADIR%%/etc/updhist_diff.txt
 %%DATADIR%%/etc/updind.txt
 %%DATADIR%%/etc/updmenu.txt
 %%DATADIR%%/etc/welcome.txt
@@ -612,6 +629,8 @@ bin/gwu
 %%DATADIR%%/images/picto_branche_patronymique.png
 %%DATADIR%%/images/picto_calendar.png
 %%DATADIR%%/images/picto_cle.png
+%%DATADIR%%/images/picto_edit_big.png
+%%DATADIR%%/images/picto_edit_small.png
 %%DATADIR%%/images/picto_fleche_blanche.png
 %%DATADIR%%/images/picto_fleche_bleu.png
 %%DATADIR%%/images/picto_loupe.png
@@ -636,40 +655,39 @@ bin/gwu
 %%DATADIR%%/lang/start.txt
 %%DATADIR%%/lang/start_utf8.txt
 %%DATADIR%%/lang/version.txt
-@dirrm %%DATADIR%%/lang
-@dirrm %%DATADIR%%/images/flags
-@dirrm %%DATADIR%%/images
-@dirrm %%DATADIR%%/etc/templx
-@dirrm %%DATADIR%%/etc/templm
-@dirrm %%DATADIR%%/etc/templh
-@dirrm %%DATADIR%%/etc/templf
-@dirrm %%DATADIR%%/etc/templd
-@dirrm %%DATADIR%%/etc/templc
-@dirrm %%DATADIR%%/etc/templb
-@dirrm %%DATADIR%%/etc/templa
-@dirrm %%DATADIR%%/etc/templ502
-@dirrm %%DATADIR%%/etc/perso_module
-@dirrm %%DATADIR%%/etc
-@dirrm %%DATADIR%%/distribution/gw/setup/lang
-@dirrm %%DATADIR%%/distribution/gw/setup
-@dirrm %%DATADIR%%/distribution/gw/old
-@dirrm %%DATADIR%%/distribution/gw/lang
-@dirrm %%DATADIR%%/distribution/gw/images/flags
-@dirrm %%DATADIR%%/distribution/gw/images
-@dirrm %%DATADIR%%/distribution/gw/gwtp_tmp/lang
-@dirrm %%DATADIR%%/distribution/gw/gwtp_tmp
-@dirrm %%DATADIR%%/distribution/gw/etc/templx
-@dirrm %%DATADIR%%/distribution/gw/etc/templm
-@dirrm %%DATADIR%%/distribution/gw/etc/templh
-@dirrm %%DATADIR%%/distribution/gw/etc/templf
-@dirrm %%DATADIR%%/distribution/gw/etc/templd
-@dirrm %%DATADIR%%/distribution/gw/etc/templc
-@dirrm %%DATADIR%%/distribution/gw/etc/templb
-@dirrm %%DATADIR%%/distribution/gw/etc/templa
-@dirrm %%DATADIR%%/distribution/gw/etc/templ502
 @dirrm %%DATADIR%%/distribution/gw/etc/perso_module
+@dirrm %%DATADIR%%/distribution/gw/etc/templ502
+@dirrm %%DATADIR%%/distribution/gw/etc/templa
+@dirrm %%DATADIR%%/distribution/gw/etc/templb
+@dirrm %%DATADIR%%/distribution/gw/etc/templc
+@dirrm %%DATADIR%%/distribution/gw/etc/templd
+@dirrm %%DATADIR%%/distribution/gw/etc/templf
+@dirrm %%DATADIR%%/distribution/gw/etc/templh
+@dirrm %%DATADIR%%/distribution/gw/etc/templm
+@dirrm %%DATADIR%%/distribution/gw/etc/templx
 @dirrm %%DATADIR%%/distribution/gw/etc
+@dirrm %%DATADIR%%/distribution/gw/gwtp_tmp/lang
+@dirrm %%DATADIR%%/distribution/gw/gwtp_tmp
+@dirrm %%DATADIR%%/distribution/gw/images/flags
+@dirrm %%DATADIR%%/distribution/gw/images
+@dirrm %%DATADIR%%/distribution/gw/lang
+@dirrmtry %%DATADIR%%/distribution/gw/old
+@dirrm %%DATADIR%%/distribution/gw/setup/lang
+@dirrm %%DATADIR%%/distribution/gw/setup
 @dirrm %%DATADIR%%/distribution/gw
 @dirrm %%DATADIR%%/distribution
+@dirrm %%DATADIR%%/etc/perso_module
+@dirrm %%DATADIR%%/etc/templ502
+@dirrm %%DATADIR%%/etc/templa
+@dirrm %%DATADIR%%/etc/templb
+@dirrm %%DATADIR%%/etc/templc
+@dirrm %%DATADIR%%/etc/templd
+@dirrm %%DATADIR%%/etc/templf
+@dirrm %%DATADIR%%/etc/templh
+@dirrm %%DATADIR%%/etc/templm
+@dirrm %%DATADIR%%/etc/templx
+@dirrm %%DATADIR%%/etc
+@dirrm %%DATADIR%%/images/flags
+@dirrm %%DATADIR%%/images
+@dirrm %%DATADIR%%/lang
 @dirrm %%DATADIR%%
-@exec mkdir -p %D/%%DATADIR%%/distribution/gw/old