diff --git a/apps/lang/english.lang b/apps/lang/english.lang
old mode 100644
new mode 100755
index 7d1e242..d2442dd
--- a/apps/lang/english.lang
+++ b/apps/lang/english.lang
@@ -12604,3 +12604,101 @@
remote: "Remote Statusbar"
+
+ id: LANG_MAPPING_RULE
+ desc: mapping rule
+ user: core
+
+ *: "Tag string mapping rule"
+
+
+ *: "Tag string mapping rule"
+
+
+ *: "Tag string mapping rule"
+
+
+
+ id: LANG_MAPPING_RULE_IGNORE_DIACRITICAL_MARK
+ desc: mapping rule: ignore diacritical mark
+ user: core
+
+ *: "Ignore diacritical mark"
+
+
+ *: "Ignore diacritical mark"
+
+
+ *: "Ignore diacritical mark"
+
+
+
+ id: LANG_MAPPING_RULE_MAPPING_UMLAUT_MODE
+ desc: mapping rule: umlaut mapping mode
+ user: core
+
+ *: "Umlaut mapping mode"
+
+
+ *: "Umlaut mapping mode"
+
+
+ *: "Umlaut mapping mode"
+
+
+
+ id: LANG_MAPPING_RULE_UMLAUT_MAPPING_NOT_DELETE_UMLAUT
+ desc: mapping rule: ä != a, ae, ë != e, ee, ï != i, ie, ü != u, ue, ö != o, oe.
+ user: core
+
+ *: "ä -> ä"
+
+
+ *: "ä -> ä"
+
+
+ *: "A with umlaut mapping is done in A with umlaut"
+
+
+
+ id: LANG_MAPPING_RULE_UMLAUT_MAPPING_DELETE_UMLAUT
+ desc: mapping rule: ä -> a, ë -> e, ï -> i, ü -> u, ö -> o.
+ user: core
+
+ *: "ä -> a"
+
+
+ *: "ä -> a"
+
+
+ *: "A with umlaut mapping is done in A"
+
+
+
+ id: LANG_MAPPING_RULE_UMLAUT_MAPPING_WITH_E
+ desc: mapping rule: ä -> ae, ë -> ee, ï -> ie, ü -> ue, ö -> oe.
+ user: core
+
+ *: "ä -> ae"
+
+
+ *: "ä -> ae"
+
+
+ *: "A with umlaut mapping is done in A E"
+
+
+
+ id: LANG_MAPPING_RULE_UMLAUT_INVALID
+ desc: mapping rule: selected umlaut mapping mode is invalid
+ user: core
+
+ *: "Invalid selection"
+
+
+ *: "Invalid selection"
+
+
+ *: "Invalid selection"
+
+
diff --git a/apps/menus/settings_menu.c b/apps/menus/settings_menu.c
index fdc7758..cc7fdea 100644
--- a/apps/menus/settings_menu.c
+++ b/apps/menus/settings_menu.c
@@ -49,6 +49,32 @@
#endif
/***********************************/
+/* TAG STRING MAPPING RULE MENU */
+static int mr_umlaut_callback(int action,const struct menu_item_ex *this_item);
+MENUITEM_SETTING(mr_diacritical_mark, &global_settings.ignore_diacritical_mark, NULL);
+MENUITEM_SETTING(mr_umlaut, &global_settings.umlaut_mapping_mode, mr_umlaut_callback);
+
+static int mr_umlaut_callback(int action,const struct menu_item_ex *this_item)
+{
+ static int oldval;
+ int *variable = this_item->variable;
+ switch (action)
+ {
+ case ACTION_EXIT_MENUITEM: /* on exit */
+ if ((global_settings.ignore_diacritical_mark && *variable == 0) ||
+ (!global_settings.ignore_diacritical_mark && *variable != 0))
+ splash(HZ/2, ID2P(LANG_MAPPING_RULE_UMLAUT_INVALID));
+ else
+ oldval = *variable;
+ break;
+ }
+ return action;
+}
+
+MAKE_MENU(mapping_menu, ID2P(LANG_MAPPING_RULE), 0, Icon_NOICON,
+ &mr_diacritical_mark, &mr_umlaut);
+
+/***********************************/
/* TAGCACHE MENU */
#ifdef HAVE_TAGCACHE
@@ -86,7 +112,7 @@ MAKE_MENU(tagcache_menu, ID2P(LANG_TAGCACHE), 0, Icon_NOICON,
&tagcache_ram,
#endif
&tagcache_autoupdate, &tc_init, &tc_update, &runtimedb,
- &tc_export, &tc_import);
+ &tc_export, &tc_import, &mapping_menu);
#endif /* HAVE_TAGCACHE */
/* TAGCACHE MENU */
/***********************************/
diff --git a/apps/settings.c b/apps/settings.c
old mode 100644
new mode 100755
index e2f40a1..2a17761
--- a/apps/settings.c
+++ b/apps/settings.c
@@ -984,6 +984,10 @@ void settings_apply(bool read_disk)
send_event(GUI_EVENT_STATUSBAR_TOGGLE, NULL);
list_init_viewports(NULL);
send_event(GUI_EVENT_ACTIONUPDATE, (void*)true);
+
+ set_normalize_rule_diacritical_mark(global_settings.ignore_diacritical_mark);
+ set_normalize_rule_umlaut(global_settings.umlaut_mapping_mode);
+
}
diff --git a/apps/settings.h b/apps/settings.h
old mode 100644
new mode 100755
index 93a998e..c99b461
--- a/apps/settings.h
+++ b/apps/settings.h
@@ -739,6 +739,10 @@ struct user_settings
struct touchscreen_parameter ts_calibration_data;
#endif
+ /* database tag string mapping rule */
+ bool ignore_diacritical_mark;
+ int umlaut_mapping_mode;
+
/* If values are just added to the end, no need to bump plugin API
version. */
/* new stuff to be added at the end */
diff --git a/apps/settings_list.c b/apps/settings_list.c
old mode 100644
new mode 100755
index 9cfd9aa..f0d2e93
--- a/apps/settings_list.c
+++ b/apps/settings_list.c
@@ -1528,6 +1528,17 @@ const struct settings_list settings[] = {
tsc_is_changed, tsc_set_default),
#endif
OFFON_SETTING(0, prevent_skip, LANG_PREVENT_SKIPPING, false, "prevent track skip", NULL),
+
+ OFFON_SETTING(0, ignore_diacritical_mark, LANG_MAPPING_RULE_IGNORE_DIACRITICAL_MARK,
+ true, "mapping rule ignore diacritical mark",
+ set_normalize_rule_diacritical_mark),
+ CHOICE_SETTING(0, umlaut_mapping_mode, LANG_MAPPING_RULE_MAPPING_UMLAUT_MODE, 1,
+ "mapping rule umlaut mapping mode",
+ "0,1,2",
+ set_normalize_rule_umlaut, 3,
+ ID2P(LANG_MAPPING_RULE_UMLAUT_MAPPING_NOT_DELETE_UMLAUT),
+ ID2P(LANG_MAPPING_RULE_UMLAUT_MAPPING_DELETE_UMLAUT),
+ ID2P(LANG_MAPPING_RULE_UMLAUT_MAPPING_WITH_E)),
};
const int nb_settings = sizeof(settings)/sizeof(*settings);
diff --git a/apps/tagcache.c b/apps/tagcache.c
old mode 100644
new mode 100755
index 07af9bf..4df4dfd
--- a/apps/tagcache.c
+++ b/apps/tagcache.c
@@ -76,6 +76,7 @@
#include "settings.h"
#include "dir.h"
#include "structec.h"
+#include "unistring.h"
#ifndef __PCTOOL__
#include "lang.h"
@@ -806,34 +807,6 @@ long tagcache_get_numeric(const struct tagcache_search *tcs, int tag)
return check_virtual_tags(tag, &idx);
}
-inline static bool str_ends_with(const char *str1, const char *str2)
-{
- int str_len = strlen(str1);
- int clause_len = strlen(str2);
-
- if (clause_len > str_len)
- return false;
-
- return !strcasecmp(&str1[str_len - clause_len], str2);
-}
-
-inline static bool str_oneof(const char *str, const char *list)
-{
- const char *sep;
- int l, len = strlen(str);
-
- while (*list)
- {
- sep = strchr(list, '|');
- l = sep ? (long)sep - (long)list : (int)strlen(list);
- if ((l==len) && !strncasecmp(str, list, len))
- return true;
- list += sep ? l + 1 : l;
- }
-
- return false;
-}
-
static bool check_against_clause(long numeric, const char *str,
const struct tagcache_search_clause *clause)
{
@@ -862,31 +835,31 @@ static bool check_against_clause(long numeric, const char *str,
switch (clause->type)
{
case clause_is:
- return !strcasecmp(clause->str, str);
+ return !utf8strcmp(clause->str, str);
case clause_is_not:
- return strcasecmp(clause->str, str);
+ return utf8strcmp(clause->str, str);
case clause_gt:
- return 0>strcasecmp(clause->str, str);
+ return 0>utf8strcmp(clause->str, str);
case clause_gteq:
- return 0>=strcasecmp(clause->str, str);
+ return 0>=utf8strcmp(clause->str, str);
case clause_lt:
- return 0str, str);
+ return 0str, str);
case clause_lteq:
- return 0<=strcasecmp(clause->str, str);
+ return 0<=utf8strcmp(clause->str, str);
case clause_contains:
- return (strcasestr(str, clause->str) != NULL);
+ return find(str, clause->str);
case clause_not_contains:
- return (strcasestr(str, clause->str) == NULL);
+ return !find(str, clause->str);
case clause_begins_with:
- return (strcasestr(str, clause->str) == str);
+ return starts_with(str, clause->str);
case clause_not_begins_with:
- return (strcasestr(str, clause->str) != str);
+ return !starts_with(str, clause->str);
case clause_ends_with:
- return str_ends_with(str, clause->str);
+ return ends_with(str, clause->str);
case clause_not_ends_with:
- return !str_ends_with(str, clause->str);
+ return !ends_with(str, clause->str);
case clause_oneof:
- return str_oneof(str, clause->str);
+ return match_one_of(str, clause->str, '|');
default:
logf("Incorrect tag: %d", clause->type);
diff --git a/apps/tagtree.c b/apps/tagtree.c
old mode 100644
new mode 100755
index 691b227..6260b88
--- a/apps/tagtree.c
+++ b/apps/tagtree.c
@@ -53,6 +53,7 @@
#include "appevents.h"
#include "storage.h"
#include "dir_uncached.h"
+#include "unistring.h"
#define FILE_SEARCH_INSTRUCTIONS ROCKBOX_DIR "/tagnavi.config"
@@ -637,9 +638,9 @@ static int compare(const void *p1, const void *p2)
struct tagentry *e2 = (struct tagentry *)p2;
if (sort_inverse)
- return strncasecmp(e2->name, e1->name, MAX_PATH);
+ return utf8strncmp(e2->name, e1->name, MAX_PATH);
- return strncasecmp(e1->name, e2->name, MAX_PATH);
+ return utf8strncmp(e1->name, e2->name, MAX_PATH);
}
static void tagtree_buffer_event(struct mp3entry *id3)
diff --git a/firmware/SOURCES b/firmware/SOURCES
index 7c1a17f..9440b63 100644
--- a/firmware/SOURCES
+++ b/firmware/SOURCES
@@ -20,6 +20,7 @@ timer.c
#endif /* SIMULATOR */
panic.c
debug.c
+unistring.c
/* Common */
common/atoi.c
diff --git a/firmware/common/unicode.c b/firmware/common/unicode.c
index 61989e5..f51cb0d 100644
--- a/firmware/common/unicode.c
+++ b/firmware/common/unicode.c
@@ -113,6 +113,49 @@ static const unsigned char utf8comp[6] =
0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
};
+/* code normalize */
+
+/*
+ * If the mapping table file (uni.mt/unimini.mt)'s version != ACCEPT_MAPPING_TABLE_VERSION,
+ * then it is invalid file.
+ */
+#define ACCEPT_MAPPING_TABLE_VERSION 1
+
+#ifdef HAVE_LCD_BITMAP
+
+#define MAX_MAPPING_INDEX_COUNT 14
+#define MAPPING_FILENAME CODEPAGE_DIR"/uni.mt"
+
+#else /* !HAVE_LCD_BITMAP, reduced support */
+
+#define MAX_MAPPING_INDEX_COUNT 8
+#define MAPPING_FILENAME CODEPAGE_DIR"/unimini.mt"
+
+#endif
+
+#define MAX_MAPPING_TABLE_SIZE (MAX_MAPPING_INDEX_COUNT << 8)
+#define MAX_MAPPING_DATA_SIZE ((MAX_MAPPING_TABLE_SIZE << 1) + 256)
+
+static unsigned short* mapping_table[MAX_MAPPING_TABLE_SIZE];
+static unsigned short normalize_data[MAX_MAPPING_DATA_SIZE];
+static char mapping_index[256] = {0};
+static int loaded_mapping_table = 0;
+
+#define NR_WITH_DIACRITICAL_MARK 1
+#define NR_UMLAUT_MAPPING_WITH_E 2
+
+#define NR_UMLAUT_MODE_NOT_DELETE_UMLAUT 0
+#define NR_UMLAUT_MODE_DELETE_UMLAUT 1
+#define NR_UMLAUT_MODE_WITH_E 2
+
+struct normalize_rule
+{
+ bool diacritical_mark;
+ int umlaut_mode;
+};
+
+static struct normalize_rule nr = { true, NR_UMLAUT_MODE_DELETE_UMLAUT };
+
/* Load codepage file into memory */
static int load_cp_table(int cp)
{
@@ -392,3 +435,243 @@ const char* get_codepage_name(int cp)
return name_codepages[NUM_CODEPAGES];
return name_codepages[cp];
}
+
+/* normalize functions */
+
+static int read_mapping_table_data(int file, int index, unsigned short **np, bool flg)
+{
+ int i;
+ int len;
+ unsigned char tmp[MAX_MAPPING_INDEX_COUNT];
+
+ unsigned short *enp = normalize_data + MAX_MAPPING_DATA_SIZE;
+
+ if (!read(file, tmp, 1))
+ {
+ DEBUGF("[%d] Can't read maping data\n", index);
+ return 1;
+ }
+
+ len = tmp[0];
+
+ if (!flg)
+ {
+ if (lseek(file, len << 1, SEEK_CUR) < 0)
+ {
+ DEBUGF("[%d] Can't read maping data\n", index);
+ return 1;
+ }
+ return 0;
+ }
+
+ mapping_table[index] = *np;
+ **np = len;
+ (*np)++;
+
+ if (len == 0)
+ return 0;
+
+ if (len > 4)
+ {
+ DEBUGF("[%d] mapping data length too long: %d\n", index, len);
+ return 1;
+ }
+
+ if (!read(file, tmp, len << 1))
+ {
+ DEBUGF("[%d] Can't read mapping data\n", index);
+ return 1;
+ }
+
+ if (enp - *np <= len)
+ {
+ DEBUGF("[%d] mapping data too many: %d\n", index, len);
+ return 1;
+ }
+ for (i = 0; i < len; i++)
+ {
+ **np = (tmp[(i << 1) + 1] << 8) | tmp[i << 1];
+ (*np)++;
+ }
+
+ return 0;
+}
+
+/* Load character mapping data file into memory */
+static int load_mapping_table(void)
+{
+ int i;
+ int file;
+ int res = 0;
+ int index_size = 0;
+ int table_size = 0;
+ unsigned short *np = normalize_data;
+ unsigned char tmp[MAX_MAPPING_INDEX_COUNT];
+ unsigned char mapping;
+
+ if (loaded_mapping_table != 0)
+ return 1;
+
+ file = open(MAPPING_FILENAME, O_RDONLY|O_BINARY);
+
+ if (file < 0)
+ {
+ DEBUGF("Can't open mapping table file: %s\n", MAPPING_FILENAME);
+ return 0;
+ }
+
+ if (!read(file, tmp, 2))
+ {
+ DEBUGF("Can't read mapping data\n");
+ close(file);
+ return 0;
+ }
+
+ if (tmp[0] != ACCEPT_MAPPING_TABLE_VERSION)
+ {
+ DEBUGF("mapping table version invalid: %d\n", tmp[0]);
+ close(file);
+ return 0;
+ }
+
+ index_size = tmp[1];
+ table_size = tmp[1] << 8;
+
+ if (index_size > MAX_MAPPING_INDEX_COUNT)
+ {
+ DEBUGF("mapping data too many\n");
+ close(file);
+ return 0;
+ }
+
+ if (!read(file, tmp, index_size))
+ {
+ DEBUGF("Can't read mapping index data\n");
+ close(file);
+ return 0;
+ }
+
+ for (i = 0; i < index_size; i++)
+ mapping_index[tmp[i]] = i+1;
+
+ for (i = 0; i < table_size; i++)
+ {
+ if (!read(file, tmp, 1))
+ {
+ DEBUGF("[%d] Can't read maping data\n", i);
+ res = 1;
+ break;
+ }
+
+ mapping = tmp[0];
+
+ res = read_mapping_table_data(file, i, &np,
+ (mapping == 0) ||
+ (nr.diacritical_mark &&
+ (mapping == NR_WITH_DIACRITICAL_MARK ||
+ nr.umlaut_mode == NR_UMLAUT_MODE_DELETE_UMLAUT)));
+ if (res)
+ break;
+
+ if (mapping & NR_WITH_DIACRITICAL_MARK)
+ {
+ res = read_mapping_table_data(file, i, &np, !nr.diacritical_mark);
+ if (res)
+ break;
+ }
+
+ if (mapping & NR_UMLAUT_MAPPING_WITH_E)
+ {
+ res = read_mapping_table_data(file, i, &np, (nr.umlaut_mode == NR_UMLAUT_MODE_WITH_E));
+ if (res)
+ break;
+ }
+ }
+
+ loaded_mapping_table = (res == 0);
+ close(file);
+
+ return res;
+}
+
+void set_normalize_rule_diacritical_mark(bool rule)
+{
+ if (nr.diacritical_mark != rule)
+ {
+ nr.diacritical_mark = rule;
+ set_normalize_rule_umlaut(nr.umlaut_mode);
+ loaded_mapping_table = 0;
+ }
+}
+
+void set_normalize_rule_umlaut(int mode)
+{
+ if (mode < 0 || mode > 2)
+ mode = NR_UMLAUT_MODE_DELETE_UMLAUT;
+ if (mode != NR_UMLAUT_MODE_NOT_DELETE_UMLAUT && !nr.diacritical_mark)
+ mode = NR_UMLAUT_MODE_NOT_DELETE_UMLAUT;
+ else if (mode == NR_UMLAUT_MODE_NOT_DELETE_UMLAUT && nr.diacritical_mark)
+ mode = NR_UMLAUT_MODE_DELETE_UMLAUT;
+
+ if (nr.umlaut_mode != mode)
+ {
+ nr.umlaut_mode = mode;
+ loaded_mapping_table = 0;
+ }
+}
+
+inline static int search_mapping_data(const unsigned short ucs)
+{
+ return mapping_index[ucs >> 8]-1;
+}
+
+/*
+ * normalize UTF16 string
+ *
+ * Because one character replaces four characters or less as a result of normarization,
+ * "dst" should be able to store more than 4 * count + 1 characters.
+ *
+ */
+int utf16normalize(unsigned short *src, unsigned short *dst, int count)
+{
+ int idx;
+ int len;
+ unsigned short *dp = dst;
+ unsigned short *p;
+
+ if (!load_mapping_table())
+ {
+ while (count-- > 0)
+ {
+ if (*src == 0)
+ break;
+ *dp++ = *src++;
+ }
+ *dp = 0x0000;
+ return dp - dst;
+ }
+
+ while (count-- > 0)
+ {
+ if (*src == 0)
+ break;
+ idx = search_mapping_data(*src);
+ if (idx < 0)
+ *dp++ = *src;
+ else
+ {
+ p = mapping_table[(idx << 8) | (*src & 0xff)];
+ len = *p;
+ if (len == 0)
+ count++;
+ else
+ {
+ while (len-- > 0)
+ *dp++ = *(++p);
+ }
+ }
+ src++;
+ }
+ *dp = 0x0000;
+ return dp - dst;
+}
diff --git a/firmware/include/rbunicode.h b/firmware/include/rbunicode.h
index 39fe253..0185649 100644
--- a/firmware/include/rbunicode.h
+++ b/firmware/include/rbunicode.h
@@ -27,7 +27,8 @@
*/
#ifndef _RBUNICODE_H_
#define _RBUNICODE_H_
-
+
+#include
#ifndef __PCTOOL__
#include "config.h"
#endif
@@ -62,4 +63,7 @@ const unsigned char* utf8decode(const unsigned char *utf8, unsigned short *ucs);
void set_codepage(int cp);
int utf8seek(const unsigned char* utf8, int offset);
const char* get_codepage_name(int cp);
+void set_normalize_rule_diacritical_mark(bool rule);
+void set_normalize_rule_umlaut(int mode);
+int utf16normalize(unsigned short *ucs, unsigned short *out, int count);
#endif /* _RBUNICODE_H_ */
diff --git a/tools/Makefile b/tools/Makefile
old mode 100644
new mode 100755
index 43f53e2..4b4cf48
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -13,7 +13,8 @@ LDFLAGS := -g
CLEANALL := scramble descramble iriver sh2d bmp2rb rdf2binary convbdf \
generate_rocklatin mkboot ipod_fw codepages uclpack mi4 gigabeat \
- lngdump telechips gigabeats creative hmac-sha1 mktccboot mknkboot rbspeexenc mkzenboot
+ lngdump telechips gigabeats creative hmac-sha1 mktccboot mknkboot rbspeexenc mkzenboot \
+ mkmappingtable
all: scramble descramble sh2d rdf2binary mkboot mktccboot mknkboot mkzenboot \
convbdf codepages uclpack rbspeexenc voicefont
@@ -95,6 +96,9 @@ voicefont: voicefont.c
usb_benchmark: usb_benchmark.c
$(SILENT)$(CC) $(CFLAGS) -lusb $+ -o $@
+mkmappingtable: mkmappingtable.c code_mapping_tables.c
+ $(SILENT)$(CC) $(CFLAGS) $+ -o $@
+
clean:
@echo "Cleaning tools"
$(SILENT)rm -f $(CLEANALL) $(shell for f in $(CLEANALL) ; do echo $$f.exe $$f.o $$f.obj ; done) *.ajf *~
diff --git a/tools/buildzip.pl b/tools/buildzip.pl
index d21fd8e..c887868 100755
--- a/tools/buildzip.pl
+++ b/tools/buildzip.pl
@@ -255,12 +255,15 @@ STOP
if($bitmap) {
system("$ROOT/tools/codepages");
+ system("$ROOT/tools/mkmappingtable");
}
else {
system("$ROOT/tools/codepages -m");
+ system("$ROOT/tools/mkmappingtable -m");
}
glob_move('*.cp', "$rbdir/codepages/");
+ glob_move('*.mt', "$rbdir/codepages/");
if($bitmap) {
mkdir "$rbdir/codecs", 0777;
diff --git a/tools/configure b/tools/configure
index e543919..4d86700 100755
--- a/tools/configure
+++ b/tools/configure
@@ -797,7 +797,7 @@ EOF
fi
# Set of tools built for all target platforms:
- toolset="rdf2binary convbdf codepages"
+ toolset="rdf2binary convbdf codepages mkmappingtable"
# Toolsets for some target families:
archosbitmaptools="$toolset scramble descramble sh2d uclpack bmp2rb"
diff --git a/tools/root.make b/tools/root.make
index 0058637..2b507d5 100644
--- a/tools/root.make
+++ b/tools/root.make
@@ -20,7 +20,8 @@ PPCFLAGS = $(filter-out -Dmain=SDL_main,$(CFLAGS)) # cygwin sdl-config fix
TOOLS = $(TOOLSDIR)/rdf2binary $(TOOLSDIR)/convbdf \
$(TOOLSDIR)/codepages $(TOOLSDIR)/scramble $(TOOLSDIR)/bmp2rb \
- $(TOOLSDIR)/uclpack $(TOOLSDIR)/mktccboot $(TOOLSDIR)/mkboot
+ $(TOOLSDIR)/uclpack $(TOOLSDIR)/mktccboot $(TOOLSDIR)/mkboot \
+ $(TOOLSDIR)/mkmappingtable
ifeq (,$(PREFIX))
diff --git a/tools/tools.make b/tools/tools.make
index e033774..3c1e0af 100644
--- a/tools/tools.make
+++ b/tools/tools.make
@@ -21,6 +21,7 @@ $(TOOLSDIR)/mkboot: $(TOOLSDIR)/mkboot.c
$(TOOLSDIR)/mktccboot: $(TOOLSDIR)/mktccboot.c $(TOOLSDIR)/telechips.c
$(TOOLSDIR)/wavtrim: $(TOOLSDIR)/wavtrim.c
$(TOOLSDIR)/voicefont: $(TOOLSDIR)/voicefont.c
+$(TOOLSDIR)/mkmappingtable: $(TOOLSDIR)/mkmappingtable.c $(TOOLSDIR)/code_mapping_tables.c $(TOOLSDIR)/code_mapping_tables.h
$(TOOLSDIR)/iaudio_bl_flash.c $(TOOLSDIR)/iaudio_bl_flash.h: $(TOOLSDIR)/iaudio_bl_flash.bmp $(TOOLSDIR)/bmp2rb
$(call PRINTS,BMP2RB $(@F))
diff --git a/firmware/export/unistring.h b/firmware/export/unistring.h
new file mode 100644
index 0000000..ab24224
--- /dev/null
+++ b/firmware/export/unistring.h
@@ -0,0 +1,29 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2008 Yoshihisa Uchida
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include
+
+int utf8strcmp(const unsigned char *s1, const unsigned char *s2);
+int utf8strncmp(const unsigned char *s1, const unsigned char *s2, int len);
+bool find(const unsigned char *phaystack, const unsigned char *pneedle);
+bool match_one_of(const unsigned char *s, const unsigned char *list, unsigned short sepr);
+bool starts_with(const unsigned char *phaystack, const unsigned char *pneedle);
+bool ends_with(const unsigned char *phaystack, const unsigned char *pneedle);
diff --git a/firmware/unistring.c b/firmware/unistring.c
new file mode 100644
index 0000000..5d40c08
--- /dev/null
+++ b/firmware/unistring.c
@@ -0,0 +1,190 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2008 Yoshihisa Uchida
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "rbunicode.h"
+#include "unistring.h"
+
+/* -------------------------------------------------------------------------- */
+/* UTF8 -> UTF16 convert functions */
+/* -------------------------------------------------------------------------- */
+static int utf8_non_normalize_decode(const unsigned char* utf8, unsigned short* ucs, int len)
+{
+ unsigned short *p = ucs;
+
+ while (len-- > 0)
+ {
+ if (*utf8 == '\0')
+ break;
+ utf8 = utf8decode(utf8, p++);
+ }
+ *p = 0;
+ return p - ucs;
+}
+
+static int utf8_normalize_decode(const unsigned char* utf8, unsigned short* ucs, int len)
+{
+ unsigned short tucs[len+1];
+ int tlen = utf8_non_normalize_decode(utf8, tucs, len);
+
+ return utf16normalize(tucs, ucs, tlen);
+}
+
+/* -------------------------------------------------------------------------- */
+/* UTF16 string compare functions */
+/* -------------------------------------------------------------------------- */
+static int wcscmp(const unsigned short* s1, const unsigned short* s2)
+{
+ while (*s1 == *s2 && *s1 != 0)
+ {
+ s1++;
+ s2++;
+ }
+
+ return *s1 - *s2;
+}
+
+static int wcsncmp(const unsigned short* s1, const unsigned short* s2, int len)
+{
+ if (len <= 0)
+ return 0;
+
+ while (*s1 == *s2 && --len != 0)
+ {
+ if (*s1 == 0)
+ break;
+ s1++;
+ s2++;
+ }
+
+ return *s1 - *s2;
+}
+
+/* -------------------------------------------------------------------------- */
+/* UTF8 string compare functions */
+/* -------------------------------------------------------------------------- */
+
+int utf8strcmp(const unsigned char* s1, const unsigned char* s2)
+{
+ int len1 = utf8length(s1);
+ int len2 = utf8length(s2);
+
+ unsigned short ws1[4*len1+1];
+ unsigned short ws2[4*len2+1];
+
+ utf8_normalize_decode(s1, ws1, len1);
+ utf8_normalize_decode(s2, ws2, len2);
+
+ return wcscmp(ws1, ws2);
+}
+
+int utf8strncmp(const unsigned char* s1, const unsigned char* s2, int len)
+{
+ int len1 = utf8length(s1);
+ int len2 = utf8length(s2);
+ unsigned short ws1[4*len1+1];
+ unsigned short ws2[4*len2+1];
+
+ utf8_normalize_decode(s1, ws1, len1);
+ utf8_normalize_decode(s2, ws2, len2);
+
+ return wcsncmp(ws1, ws2, len);
+}
+
+bool find(const unsigned char* phaystack, const unsigned char* pneedle)
+{
+ int hlen = utf8length(phaystack);
+ int nlen = utf8length(pneedle);
+ unsigned short hws[4*hlen+1];
+ unsigned short nws[4*nlen+1];
+ unsigned short *p = hws;
+ int len;
+
+ hlen = utf8_normalize_decode(phaystack, hws, hlen);
+ nlen = utf8_normalize_decode(pneedle, nws, nlen);
+
+ len = hlen - nlen;
+ if (len < 0)
+ return false;
+
+ while (len-- >= 0)
+ {
+ if (!wcsncmp(p++, nws, nlen))
+ return true;
+ }
+ return false;
+}
+
+bool match_one_of(const unsigned char* s, const unsigned char* list, unsigned short sepr)
+{
+ int slen = utf8length(s);
+ int llen = utf8length(list);
+ unsigned short sws[4*slen+1];
+ unsigned short lws[llen+1];
+ unsigned short tmp[4*llen+1];
+ unsigned short* p1 = lws;
+ unsigned short* p2 = lws;
+
+ utf8_normalize_decode(s, sws, slen);
+ utf8_non_normalize_decode(list, lws, llen);
+
+ while (true)
+ {
+ while (*p2 != sepr && *p2 != 0)
+ p2++;
+ utf16normalize(p1, tmp, p2 - p1);
+ if (!wcscmp(sws, tmp))
+ return true;
+ if (*p2 == 0)
+ break;
+ p1 = ++p2;
+ }
+ return false;
+}
+
+bool starts_with(const unsigned char* phaystack, const unsigned char* pneedle)
+{
+ int len = utf8length(pneedle);
+
+ unsigned short hws[4*len+1];
+ unsigned short nws[4*len+1];
+
+ len = utf8_normalize_decode(pneedle, nws, len);
+ utf8_normalize_decode(phaystack, hws, len);
+
+ return !wcsncmp(hws, nws, len);
+}
+
+bool ends_with(const unsigned char* phaystack, const unsigned char* pneedle)
+{
+ int hlen = utf8length(phaystack);
+ int nlen = utf8length(pneedle);
+
+ unsigned short hws[4*nlen+1];
+ unsigned short nws[4*nlen+1];
+
+ hlen = utf8_normalize_decode(phaystack, hws, hlen);
+ nlen = utf8_normalize_decode(pneedle, nws, nlen);
+
+ if (hlen < nlen)
+ return false;
+
+ return !wcscmp(hws + hlen - nlen, nws);
+}
diff --git a/tools/code_mapping_tables.c b/tools/code_mapping_tables.c
new file mode 100644
index 0000000..dc28655
--- /dev/null
+++ b/tools/code_mapping_tables.c
@@ -0,0 +1,4742 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2008 Yoshihisa Uchida
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "code_mapping_tables.h"
+
+const unsigned char mini_index[] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x20, 0xfb
+};
+
+const unsigned char full_index[] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x1e, 0x1f, 0x20, 0x2c, 0x30, 0xa6, 0xfb, 0xff,
+};
+
+int get_mini_index_size(void)
+{
+ return sizeof(mini_index);
+}
+
+int get_full_index_size(void)
+{
+ return sizeof(full_index);
+}
+
+/*
+ * mapping table structure
+ *
+ * { original utf16 code, { normalized utf16 codes } },
+ *
+ * specific normalized utf16 code:
+ * 0xfffd: invalid unicode character.
+ * 0xffff: disappearing character after normalizing.
+ */
+
+/* common mapping table
+ *
+ * mapping rule
+ * - lowercase, titlecase -> uppercase
+ * - delete diacritical mark (accent, umlaut, sound mark, etc.)
+ * - variable glyph -> normal glyph
+ * - Japanese Hiragana, halfwidth Katakana -> fullwidth Katakana
+ */
+const struct mapping_data common_mapping_table[] =
+{
+{ 0x0000, { 0x0000 } },
+{ 0x0001, { 0x0001 } },
+{ 0x0002, { 0x0002 } },
+{ 0x0003, { 0x0003 } },
+{ 0x0004, { 0x0004 } },
+{ 0x0005, { 0x0005 } },
+{ 0x0006, { 0x0006 } },
+{ 0x0007, { 0x0007 } },
+{ 0x0008, { 0x0008 } },
+{ 0x0009, { 0x0009 } },
+{ 0x000a, { 0x000a } },
+{ 0x000b, { 0x000b } },
+{ 0x000c, { 0x000c } },
+{ 0x000d, { 0x000d } },
+{ 0x000e, { 0x000e } },
+{ 0x000f, { 0x000f } },
+{ 0x0010, { 0x0010 } },
+{ 0x0011, { 0x0011 } },
+{ 0x0012, { 0x0012 } },
+{ 0x0013, { 0x0013 } },
+{ 0x0014, { 0x0014 } },
+{ 0x0015, { 0x0015 } },
+{ 0x0016, { 0x0016 } },
+{ 0x0017, { 0x0017 } },
+{ 0x0018, { 0x0018 } },
+{ 0x0019, { 0x0019 } },
+{ 0x001a, { 0x001a } },
+{ 0x001b, { 0x001b } },
+{ 0x001c, { 0x001c } },
+{ 0x001d, { 0x001d } },
+{ 0x001e, { 0x001e } },
+{ 0x001f, { 0x001f } },
+{ 0x0020, { 0x0020 } },
+{ 0x0021, { 0x0021 } },
+{ 0x0022, { 0x0022 } },
+{ 0x0023, { 0x0023 } },
+{ 0x0024, { 0x0024 } },
+{ 0x0025, { 0x0025 } },
+{ 0x0026, { 0x0026 } },
+{ 0x0027, { 0x0027 } },
+{ 0x0028, { 0x0028 } },
+{ 0x0029, { 0x0029 } },
+{ 0x002a, { 0x002a } },
+{ 0x002b, { 0x002b } },
+{ 0x002c, { 0x002c } },
+{ 0x002d, { 0x002d } },
+{ 0x002e, { 0x002e } },
+{ 0x002f, { 0x002f } },
+{ 0x0030, { 0x0030 } },
+{ 0x0031, { 0x0031 } },
+{ 0x0032, { 0x0032 } },
+{ 0x0033, { 0x0033 } },
+{ 0x0034, { 0x0034 } },
+{ 0x0035, { 0x0035 } },
+{ 0x0036, { 0x0036 } },
+{ 0x0037, { 0x0037 } },
+{ 0x0038, { 0x0038 } },
+{ 0x0039, { 0x0039 } },
+{ 0x003a, { 0x003a } },
+{ 0x003b, { 0x003b } },
+{ 0x003c, { 0x003c } },
+{ 0x003d, { 0x003d } },
+{ 0x003e, { 0x003e } },
+{ 0x003f, { 0x003f } },
+{ 0x0040, { 0x0040 } },
+{ 0x0041, { 0x0041 } },
+{ 0x0042, { 0x0042 } },
+{ 0x0043, { 0x0043 } },
+{ 0x0044, { 0x0044 } },
+{ 0x0045, { 0x0045 } },
+{ 0x0046, { 0x0046 } },
+{ 0x0047, { 0x0047 } },
+{ 0x0048, { 0x0048 } },
+{ 0x0049, { 0x0049 } },
+{ 0x004a, { 0x004a } },
+{ 0x004b, { 0x004b } },
+{ 0x004c, { 0x004c } },
+{ 0x004d, { 0x004d } },
+{ 0x004e, { 0x004e } },
+{ 0x004f, { 0x004f } },
+{ 0x0050, { 0x0050 } },
+{ 0x0051, { 0x0051 } },
+{ 0x0052, { 0x0052 } },
+{ 0x0053, { 0x0053 } },
+{ 0x0054, { 0x0054 } },
+{ 0x0055, { 0x0055 } },
+{ 0x0056, { 0x0056 } },
+{ 0x0057, { 0x0057 } },
+{ 0x0058, { 0x0058 } },
+{ 0x0059, { 0x0059 } },
+{ 0x005a, { 0x005a } },
+{ 0x005b, { 0x005b } },
+{ 0x005c, { 0x005c } },
+{ 0x005d, { 0x005d } },
+{ 0x005e, { 0x005e } },
+{ 0x005f, { 0x005f } },
+{ 0x0060, { 0x0060 } },
+{ 0x0061, { 0x0041 } },
+{ 0x0062, { 0x0042 } },
+{ 0x0063, { 0x0043 } },
+{ 0x0064, { 0x0044 } },
+{ 0x0065, { 0x0045 } },
+{ 0x0066, { 0x0046 } },
+{ 0x0067, { 0x0047 } },
+{ 0x0068, { 0x0048 } },
+{ 0x0069, { 0x0049 } },
+{ 0x006a, { 0x004a } },
+{ 0x006b, { 0x004b } },
+{ 0x006c, { 0x004c } },
+{ 0x006d, { 0x004d } },
+{ 0x006e, { 0x004e } },
+{ 0x006f, { 0x004f } },
+{ 0x0070, { 0x0050 } },
+{ 0x0071, { 0x0051 } },
+{ 0x0072, { 0x0052 } },
+{ 0x0073, { 0x0053 } },
+{ 0x0074, { 0x0054 } },
+{ 0x0075, { 0x0055 } },
+{ 0x0076, { 0x0056 } },
+{ 0x0077, { 0x0057 } },
+{ 0x0078, { 0x0058 } },
+{ 0x0079, { 0x0059 } },
+{ 0x007a, { 0x005a } },
+{ 0x007b, { 0x007b } },
+{ 0x007c, { 0x007c } },
+{ 0x007d, { 0x007d } },
+{ 0x007e, { 0x007e } },
+{ 0x007f, { 0x007f } },
+{ 0x0080, { 0x0080 } },
+{ 0x0081, { 0x0081 } },
+{ 0x0082, { 0x0082 } },
+{ 0x0083, { 0x0083 } },
+{ 0x0084, { 0x0084 } },
+{ 0x0085, { 0x0085 } },
+{ 0x0086, { 0x0086 } },
+{ 0x0087, { 0x0087 } },
+{ 0x0088, { 0x0088 } },
+{ 0x0089, { 0x0089 } },
+{ 0x008a, { 0x008a } },
+{ 0x008b, { 0x008b } },
+{ 0x008c, { 0x008c } },
+{ 0x008d, { 0x008d } },
+{ 0x008e, { 0x008e } },
+{ 0x008f, { 0x008f } },
+{ 0x0090, { 0x0090 } },
+{ 0x0091, { 0x0091 } },
+{ 0x0092, { 0x0092 } },
+{ 0x0093, { 0x0093 } },
+{ 0x0094, { 0x0094 } },
+{ 0x0095, { 0x0095 } },
+{ 0x0096, { 0x0096 } },
+{ 0x0097, { 0x0097 } },
+{ 0x0098, { 0x0098 } },
+{ 0x0099, { 0x0099 } },
+{ 0x009a, { 0x009a } },
+{ 0x009b, { 0x009b } },
+{ 0x009c, { 0x009c } },
+{ 0x009d, { 0x009d } },
+{ 0x009e, { 0x009e } },
+{ 0x009f, { 0x009f } },
+{ 0x00a0, { 0x0020 } },
+{ 0x00a1, { 0x00a1 } },
+{ 0x00a2, { 0x00a2 } },
+{ 0x00a3, { 0x00a3 } },
+{ 0x00a4, { 0x00a4 } },
+{ 0x00a5, { 0x00a5 } },
+{ 0x00a6, { 0x00a6 } },
+{ 0x00a7, { 0x00a7 } },
+{ 0x00a8, { 0x00a8 } },
+{ 0x00a9, { 0x00a9 } },
+{ 0x00aa, { 0x0061 } },
+{ 0x00ab, { 0x00ab } },
+{ 0x00ac, { 0x00ac } },
+{ 0x00ad, { 0x00ad } },
+{ 0x00ae, { 0x00ae } },
+{ 0x00af, { 0x00af } },
+{ 0x00b0, { 0x00b0 } },
+{ 0x00b1, { 0x00b1 } },
+{ 0x00b2, { 0x0032 } },
+{ 0x00b3, { 0x0033 } },
+{ 0x00b4, { 0x00b4 } },
+{ 0x00b5, { 0x00b5 } },
+{ 0x00b6, { 0x00b6 } },
+{ 0x00b7, { 0x00b7 } },
+{ 0x00b8, { 0x00b8 } },
+{ 0x00b9, { 0x0031 } },
+{ 0x00ba, { 0x006f } },
+{ 0x00bb, { 0x00bb } },
+{ 0x00bc, { 0x0031, 0x002f, 0x0034 } },
+{ 0x00bd, { 0x0031, 0x002f, 0x0032 } },
+{ 0x00be, { 0x0033, 0x002f, 0x0034 } },
+{ 0x00bf, { 0x00bf } },
+{ 0x00c0, { 0x0041 } },
+{ 0x00c1, { 0x0041 } },
+{ 0x00c2, { 0x0041 } },
+{ 0x00c3, { 0x0041 } },
+{ 0x00c4, { 0x0041 } },
+{ 0x00c5, { 0x0041 } },
+{ 0x00c6, { 0x0041, 0x0045 } },
+{ 0x00c7, { 0x0043 } },
+{ 0x00c8, { 0x0045 } },
+{ 0x00c9, { 0x0045 } },
+{ 0x00ca, { 0x0045 } },
+{ 0x00cb, { 0x0045 } },
+{ 0x00cc, { 0x0049 } },
+{ 0x00cd, { 0x0049 } },
+{ 0x00ce, { 0x0049 } },
+{ 0x00cf, { 0x0049 } },
+{ 0x00d0, { 0x00d0 } },
+{ 0x00d1, { 0x004e } },
+{ 0x00d2, { 0x004f } },
+{ 0x00d3, { 0x004f } },
+{ 0x00d4, { 0x004f } },
+{ 0x00d5, { 0x004f } },
+{ 0x00d6, { 0x004f } },
+{ 0x00d7, { 0x00d7 } },
+{ 0x00d8, { 0x00d8 } },
+{ 0x00d9, { 0x0055 } },
+{ 0x00da, { 0x0055 } },
+{ 0x00db, { 0x0055 } },
+{ 0x00dc, { 0x0055 } },
+{ 0x00dd, { 0x0059 } },
+{ 0x00de, { 0x00de } },
+{ 0x00df, { 0x0053, 0x0053 } },
+{ 0x00e0, { 0x0041 } },
+{ 0x00e1, { 0x0041 } },
+{ 0x00e2, { 0x0041 } },
+{ 0x00e3, { 0x0041 } },
+{ 0x00e4, { 0x0041 } },
+{ 0x00e5, { 0x0041 } },
+{ 0x00e6, { 0x0041, 0x0045 } },
+{ 0x00e7, { 0x0043 } },
+{ 0x00e8, { 0x0045 } },
+{ 0x00e9, { 0x0045 } },
+{ 0x00ea, { 0x0045 } },
+{ 0x00eb, { 0x0045 } },
+{ 0x00ec, { 0x0049 } },
+{ 0x00ed, { 0x0049 } },
+{ 0x00ee, { 0x0049 } },
+{ 0x00ef, { 0x0049 } },
+{ 0x00f0, { 0x00d0 } },
+{ 0x00f1, { 0x004e } },
+{ 0x00f2, { 0x004f } },
+{ 0x00f3, { 0x004f } },
+{ 0x00f4, { 0x004f } },
+{ 0x00f5, { 0x004f } },
+{ 0x00f6, { 0x004f } },
+{ 0x00f7, { 0x00f7 } },
+{ 0x00f8, { 0x00d8 } },
+{ 0x00f9, { 0x0055 } },
+{ 0x00fa, { 0x0055 } },
+{ 0x00fb, { 0x0055 } },
+{ 0x00fc, { 0x0055 } },
+{ 0x00fd, { 0x0059 } },
+{ 0x00fe, { 0x00de } },
+{ 0x00ff, { 0x0059 } },
+{ 0x0100, { 0x0041 } },
+{ 0x0101, { 0x0041 } },
+{ 0x0102, { 0x0041 } },
+{ 0x0103, { 0x0041 } },
+{ 0x0104, { 0x0041 } },
+{ 0x0105, { 0x0041 } },
+{ 0x0106, { 0x0043 } },
+{ 0x0107, { 0x0043 } },
+{ 0x0108, { 0x0043 } },
+{ 0x0109, { 0x0043 } },
+{ 0x010a, { 0x0043 } },
+{ 0x010b, { 0x0043 } },
+{ 0x010c, { 0x0043 } },
+{ 0x010d, { 0x0043 } },
+{ 0x010e, { 0x0044 } },
+{ 0x010f, { 0x0044 } },
+{ 0x0110, { 0x0110 } },
+{ 0x0111, { 0x0110 } },
+{ 0x0112, { 0x0045 } },
+{ 0x0113, { 0x0045 } },
+{ 0x0114, { 0x0045 } },
+{ 0x0115, { 0x0045 } },
+{ 0x0116, { 0x0045 } },
+{ 0x0117, { 0x0045 } },
+{ 0x0118, { 0x0045 } },
+{ 0x0119, { 0x0045 } },
+{ 0x011a, { 0x0045 } },
+{ 0x011b, { 0x0045 } },
+{ 0x011c, { 0x0047 } },
+{ 0x011d, { 0x0047 } },
+{ 0x011e, { 0x0047 } },
+{ 0x011f, { 0x0047 } },
+{ 0x0120, { 0x0047 } },
+{ 0x0121, { 0x0047 } },
+{ 0x0122, { 0x0047 } },
+{ 0x0123, { 0x0047 } },
+{ 0x0124, { 0x0048 } },
+{ 0x0125, { 0x0048 } },
+{ 0x0126, { 0x0126 } },
+{ 0x0127, { 0x0126 } },
+{ 0x0128, { 0x0049 } },
+{ 0x0129, { 0x0049 } },
+{ 0x012a, { 0x0049 } },
+{ 0x012b, { 0x0049 } },
+{ 0x012c, { 0x0049 } },
+{ 0x012d, { 0x0049 } },
+{ 0x012e, { 0x0049 } },
+{ 0x012f, { 0x0049 } },
+{ 0x0130, { 0x0049 } },
+{ 0x0131, { 0x0049 } },
+{ 0x0132, { 0x0049, 0x004a } },
+{ 0x0133, { 0x0049, 0x004a } },
+{ 0x0134, { 0x004a } },
+{ 0x0135, { 0x004a } },
+{ 0x0136, { 0x004b } },
+{ 0x0137, { 0x004b } },
+{ 0x0138, { 0x0138 } },
+{ 0x0139, { 0x004c } },
+{ 0x013a, { 0x004c } },
+{ 0x013b, { 0x004c } },
+{ 0x013c, { 0x004c } },
+{ 0x013d, { 0x004c } },
+{ 0x013e, { 0x004c } },
+{ 0x013f, { 0x013f } },
+{ 0x0140, { 0x013f } },
+{ 0x0141, { 0x0141 } },
+{ 0x0142, { 0x0141 } },
+{ 0x0143, { 0x004e } },
+{ 0x0144, { 0x004e } },
+{ 0x0145, { 0x004e } },
+{ 0x0146, { 0x003e } },
+{ 0x0147, { 0x004e } },
+{ 0x0148, { 0x004e } },
+{ 0x0149, { 0x02bc, 0x004e } },
+{ 0x014a, { 0x014a } },
+{ 0x014b, { 0x014a } },
+{ 0x014c, { 0x004f } },
+{ 0x014d, { 0x004f } },
+{ 0x014e, { 0x004f } },
+{ 0x014f, { 0x004f } },
+{ 0x0150, { 0x004f } },
+{ 0x0151, { 0x004f } },
+{ 0x0152, { 0x004f, 0x0045 } },
+{ 0x0153, { 0x004f, 0x0045 } },
+{ 0x0154, { 0x0052 } },
+{ 0x0155, { 0x0052 } },
+{ 0x0156, { 0x0052 } },
+{ 0x0157, { 0x0052 } },
+{ 0x0158, { 0x0052 } },
+{ 0x0159, { 0x0052 } },
+{ 0x015a, { 0x0053 } },
+{ 0x015b, { 0x0053 } },
+{ 0x015c, { 0x0053 } },
+{ 0x015d, { 0x0053 } },
+{ 0x015e, { 0x0053 } },
+{ 0x015f, { 0x0053 } },
+{ 0x0160, { 0x0053 } },
+{ 0x0161, { 0x0053 } },
+{ 0x0162, { 0x0054 } },
+{ 0x0163, { 0x0054 } },
+{ 0x0164, { 0x0054 } },
+{ 0x0165, { 0x0054 } },
+{ 0x0166, { 0x0166 } },
+{ 0x0167, { 0x0166 } },
+{ 0x0168, { 0x0055 } },
+{ 0x0169, { 0x0055 } },
+{ 0x016a, { 0x0055 } },
+{ 0x016b, { 0x0055 } },
+{ 0x016c, { 0x0055 } },
+{ 0x016d, { 0x0055 } },
+{ 0x016e, { 0x0055 } },
+{ 0x016f, { 0x0055 } },
+{ 0x0170, { 0x0055 } },
+{ 0x0171, { 0x0055 } },
+{ 0x0172, { 0x0055 } },
+{ 0x0173, { 0x0055 } },
+{ 0x0174, { 0x0057 } },
+{ 0x0175, { 0x0057 } },
+{ 0x0176, { 0x0059 } },
+{ 0x0177, { 0x0059 } },
+{ 0x0178, { 0x0059 } },
+{ 0x0179, { 0x005a } },
+{ 0x017a, { 0x005a } },
+{ 0x017b, { 0x005a } },
+{ 0x017c, { 0x005a } },
+{ 0x017d, { 0x005a } },
+{ 0x017e, { 0x005a } },
+{ 0x017f, { 0x0073 } },
+{ 0x0180, { 0x0243 } },
+{ 0x0181, { 0x0181 } },
+{ 0x0182, { 0x0182 } },
+{ 0x0183, { 0x0182 } },
+{ 0x0184, { 0x0184 } },
+{ 0x0185, { 0x0184 } },
+{ 0x0186, { 0x0186 } },
+{ 0x0187, { 0x0187 } },
+{ 0x0188, { 0x0187 } },
+{ 0x0189, { 0x0189 } },
+{ 0x018a, { 0x018a } },
+{ 0x018b, { 0x018b } },
+{ 0x018c, { 0x018b } },
+{ 0x018d, { 0x018d } },
+{ 0x018e, { 0x018e } },
+{ 0x018f, { 0x018f } },
+{ 0x0190, { 0x0190 } },
+{ 0x0191, { 0x0191 } },
+{ 0x0192, { 0x0191 } },
+{ 0x0193, { 0x0193 } },
+{ 0x0194, { 0x0194 } },
+{ 0x0195, { 0x01f6 } },
+{ 0x0196, { 0x0196 } },
+{ 0x0197, { 0x0197 } },
+{ 0x0198, { 0x0198 } },
+{ 0x0199, { 0x0198 } },
+{ 0x019a, { 0x023d } },
+{ 0x019b, { 0x019b } },
+{ 0x019c, { 0x019c } },
+{ 0x019d, { 0x019d } },
+{ 0x019e, { 0x0220 } },
+{ 0x019f, { 0x019f } },
+{ 0x01a0, { 0x004f } },
+{ 0x01a1, { 0x006f } },
+{ 0x01a2, { 0x01a2 } },
+{ 0x01a3, { 0x01a2 } },
+{ 0x01a4, { 0x01a4 } },
+{ 0x01a5, { 0x01a4 } },
+{ 0x01a6, { 0x01a6 } },
+{ 0x01a7, { 0x01a7 } },
+{ 0x01a8, { 0x01a7 } },
+{ 0x01a9, { 0x01a9 } },
+{ 0x01aa, { 0x01aa } },
+{ 0x01ab, { 0x01ab } },
+{ 0x01ac, { 0x01ac } },
+{ 0x01ad, { 0x01ac } },
+{ 0x01ae, { 0x01ae } },
+{ 0x01af, { 0x0055 } },
+{ 0x01b0, { 0x0075 } },
+{ 0x01b1, { 0x01b1 } },
+{ 0x01b2, { 0x01b2 } },
+{ 0x01b3, { 0x01b3 } },
+{ 0x01b4, { 0x01b3 } },
+{ 0x01b5, { 0x01b5 } },
+{ 0x01b6, { 0x01b5 } },
+{ 0x01b7, { 0x01b7 } },
+{ 0x01b8, { 0x01b8 } },
+{ 0x01b9, { 0x01b8 } },
+{ 0x01ba, { 0x01ba } },
+{ 0x01bb, { 0x01bb } },
+{ 0x01bc, { 0x01bc } },
+{ 0x01bd, { 0x01bc } },
+{ 0x01be, { 0x01be } },
+{ 0x01bf, { 0x01f7 } },
+{ 0x01c0, { 0x01c0 } },
+{ 0x01c1, { 0x01c1 } },
+{ 0x01c2, { 0x01c2 } },
+{ 0x01c3, { 0x0021 } },
+{ 0x01c4, { 0x0044, 0x005a } },
+{ 0x01c5, { 0x0044, 0x005a } },
+{ 0x01c6, { 0x0044, 0x005a } },
+{ 0x01c7, { 0x004c, 0x004a } },
+{ 0x01c8, { 0x004c, 0x004a } },
+{ 0x01c9, { 0x004c, 0x004a } },
+{ 0x01ca, { 0x004e, 0x004a } },
+{ 0x01cb, { 0x004e, 0x004a } },
+{ 0x01cc, { 0x004e, 0x004a } },
+{ 0x01cd, { 0x0041 } },
+{ 0x01ce, { 0x0041 } },
+{ 0x01cf, { 0x0049 } },
+{ 0x01d0, { 0x0049 } },
+{ 0x01d1, { 0x004f } },
+{ 0x01d2, { 0x004f } },
+{ 0x01d3, { 0x0055 } },
+{ 0x01d4, { 0x0055 } },
+{ 0x01d5, { 0x0055 } },
+{ 0x01d6, { 0x0055 } },
+{ 0x01d7, { 0x0055 } },
+{ 0x01d8, { 0x0055 } },
+{ 0x01d9, { 0x0055 } },
+{ 0x01da, { 0x0055 } },
+{ 0x01db, { 0x0055 } },
+{ 0x01dc, { 0x0055 } },
+{ 0x01dd, { 0x018e } },
+{ 0x01de, { 0x0041 } },
+{ 0x01df, { 0x0041 } },
+{ 0x01e0, { 0x0041 } },
+{ 0x01e1, { 0x0041 } },
+{ 0x01e2, { 0x0041, 0x0045 } },
+{ 0x01e3, { 0x0041, 0x0045 } },
+{ 0x01e4, { 0x01e4 } },
+{ 0x01e5, { 0x01e4 } },
+{ 0x01e6, { 0x0047 } },
+{ 0x01e7, { 0x0047 } },
+{ 0x01e8, { 0x004b } },
+{ 0x01e9, { 0x004b } },
+{ 0x01ea, { 0x004f } },
+{ 0x01eb, { 0x004f } },
+{ 0x01ec, { 0x004f } },
+{ 0x01ed, { 0x004f } },
+{ 0x01ee, { 0x01b7 } },
+{ 0x01ef, { 0x01b7 } },
+{ 0x01f0, { 0x004a } },
+{ 0x01f1, { 0x0044, 0x005a } },
+{ 0x01f2, { 0x0044, 0x005a } },
+{ 0x01f3, { 0x0044, 0x005a } },
+{ 0x01f4, { 0x0047 } },
+{ 0x01f5, { 0x0047 } },
+{ 0x01f6, { 0x01f6 } },
+{ 0x01f7, { 0x01f7 } },
+{ 0x01f8, { 0x004e } },
+{ 0x01f9, { 0x004e } },
+{ 0x01fa, { 0x0041 } },
+{ 0x01fb, { 0x0041 } },
+{ 0x01fc, { 0x0041, 0x0045 } },
+{ 0x01fd, { 0x0041, 0x0045 } },
+{ 0x01fe, { 0x004f } },
+{ 0x01ff, { 0x004f } },
+{ 0x0200, { 0x0041 } },
+{ 0x0201, { 0x0041 } },
+{ 0x0202, { 0x0041 } },
+{ 0x0203, { 0x0041 } },
+{ 0x0204, { 0x0045 } },
+{ 0x0205, { 0x0045 } },
+{ 0x0206, { 0x0045 } },
+{ 0x0207, { 0x0045 } },
+{ 0x0208, { 0x0049 } },
+{ 0x0209, { 0x0049 } },
+{ 0x020a, { 0x0049 } },
+{ 0x020b, { 0x0049 } },
+{ 0x020c, { 0x004f } },
+{ 0x020d, { 0x004f } },
+{ 0x020e, { 0x004f } },
+{ 0x020f, { 0x004f } },
+{ 0x0210, { 0x0052 } },
+{ 0x0211, { 0x0052 } },
+{ 0x0212, { 0x0052 } },
+{ 0x0213, { 0x0052 } },
+{ 0x0214, { 0x0055 } },
+{ 0x0215, { 0x0055 } },
+{ 0x0216, { 0x0055 } },
+{ 0x0217, { 0x0055 } },
+{ 0x0218, { 0x0053 } },
+{ 0x0219, { 0x0053 } },
+{ 0x021a, { 0x0054 } },
+{ 0x021b, { 0x0054 } },
+{ 0x021c, { 0x021c } },
+{ 0x021d, { 0x021c } },
+{ 0x021e, { 0x0048 } },
+{ 0x021f, { 0x0048 } },
+{ 0x0220, { 0x0220 } },
+{ 0x0221, { 0x0221 } },
+{ 0x0222, { 0x0222 } },
+{ 0x0223, { 0x0222 } },
+{ 0x0224, { 0x0224 } },
+{ 0x0225, { 0x0224 } },
+{ 0x0226, { 0x0041 } },
+{ 0x0227, { 0x0041 } },
+{ 0x0228, { 0x0045 } },
+{ 0x0229, { 0x0045 } },
+{ 0x022a, { 0x004f } },
+{ 0x022b, { 0x004f } },
+{ 0x022c, { 0x004f } },
+{ 0x022d, { 0x004f } },
+{ 0x022e, { 0x004f } },
+{ 0x022f, { 0x004f } },
+{ 0x0230, { 0x004f } },
+{ 0x0231, { 0x004f } },
+{ 0x0232, { 0x0059 } },
+{ 0x0233, { 0x0059 } },
+{ 0x0234, { 0x0234 } },
+{ 0x0235, { 0x0235 } },
+{ 0x0236, { 0x0236 } },
+{ 0x0237, { 0x006a } },
+{ 0x0238, { 0x0044, 0x0042 } },
+{ 0x0239, { 0x0051, 0x0050 } },
+{ 0x023a, { 0x023a } },
+{ 0x023b, { 0x023b } },
+{ 0x023c, { 0x023b } },
+{ 0x023d, { 0x023d } },
+{ 0x023e, { 0x023e } },
+{ 0x023f, { 0x023f } },
+{ 0x0240, { 0x0240 } },
+{ 0x0241, { 0x0241 } },
+{ 0x0242, { 0x0241 } },
+{ 0x0243, { 0x0243 } },
+{ 0x0244, { 0x0244 } },
+{ 0x0245, { 0x0245 } },
+{ 0x0246, { 0x0246 } },
+{ 0x0247, { 0x0246 } },
+{ 0x0248, { 0x0248 } },
+{ 0x0249, { 0x0248 } },
+{ 0x024a, { 0x024a } },
+{ 0x024b, { 0x024a } },
+{ 0x024c, { 0x024c } },
+{ 0x024d, { 0x024c } },
+{ 0x024e, { 0x024e } },
+{ 0x024f, { 0x024e } },
+{ 0x0250, { 0x2c6f } },
+{ 0x0251, { 0x2c6d } },
+{ 0x0252, { 0x0252 } },
+{ 0x0253, { 0x0181 } },
+{ 0x0254, { 0x0186 } },
+{ 0x0255, { 0x0255 } },
+{ 0x0256, { 0x0189 } },
+{ 0x0257, { 0x018a } },
+{ 0x0258, { 0x0258 } },
+{ 0x0259, { 0x018f } },
+{ 0x025a, { 0x025a } },
+{ 0x025b, { 0x0190 } },
+{ 0x025c, { 0x025c } },
+{ 0x025d, { 0x025d } },
+{ 0x025e, { 0x025e } },
+{ 0x025f, { 0x025f } },
+{ 0x0260, { 0x0193 } },
+{ 0x0261, { 0x0067 } },
+{ 0x0262, { 0x0262 } },
+{ 0x0263, { 0x0194 } },
+{ 0x0264, { 0x0264 } },
+{ 0x0265, { 0x0265 } },
+{ 0x0266, { 0x0266 } },
+{ 0x0267, { 0x0267 } },
+{ 0x0268, { 0x026a } },
+{ 0x0269, { 0x0269 } },
+{ 0x026a, { 0x026a } },
+{ 0x026b, { 0x2c62 } },
+{ 0x026c, { 0x026c } },
+{ 0x026d, { 0x026d } },
+{ 0x026e, { 0x026e } },
+{ 0x026f, { 0x019c } },
+{ 0x0270, { 0x0270 } },
+{ 0x0271, { 0x2c6e } },
+{ 0x0272, { 0x019d } },
+{ 0x0273, { 0x0273 } },
+{ 0x0274, { 0x0274 } },
+{ 0x0275, { 0x019f } },
+{ 0x0276, { 0x004f, 0x0045 } },
+{ 0x0277, { 0x0277 } },
+{ 0x0278, { 0x0278 } },
+{ 0x0279, { 0x0279 } },
+{ 0x027a, { 0x027a } },
+{ 0x027b, { 0x027b } },
+{ 0x027c, { 0x027c } },
+{ 0x027d, { 0x2c64 } },
+{ 0x027e, { 0x027e } },
+{ 0x027f, { 0x027f } },
+{ 0x0280, { 0x01a6 } },
+{ 0x0281, { 0x0281 } },
+{ 0x0282, { 0x0282 } },
+{ 0x0283, { 0x0283 } },
+{ 0x0284, { 0x0284 } },
+{ 0x0285, { 0x0285 } },
+{ 0x0286, { 0x0286 } },
+{ 0x0287, { 0x0287 } },
+{ 0x0288, { 0x0288 } },
+{ 0x0289, { 0x0244 } },
+{ 0x028a, { 0x01b1 } },
+{ 0x028b, { 0x01b2 } },
+{ 0x028c, { 0x0245 } },
+{ 0x028d, { 0x028d } },
+{ 0x028e, { 0x028e } },
+{ 0x028f, { 0x028f } },
+{ 0x0290, { 0x0290 } },
+{ 0x0291, { 0x0291 } },
+{ 0x0292, { 0x01b7 } },
+{ 0x0293, { 0x0293 } },
+{ 0x0294, { 0x0294 } },
+{ 0x0295, { 0x0295 } },
+{ 0x0296, { 0x0296 } },
+{ 0x0297, { 0x0297 } },
+{ 0x0298, { 0x0298 } },
+{ 0x0299, { 0x0299 } },
+{ 0x029a, { 0x029a } },
+{ 0x029b, { 0x029b } },
+{ 0x029c, { 0x029c } },
+{ 0x029d, { 0x029d } },
+{ 0x029e, { 0x029e } },
+{ 0x029f, { 0x029f } },
+{ 0x02a0, { 0x02a0 } },
+{ 0x02a1, { 0x02a1 } },
+{ 0x02a2, { 0x02a2 } },
+{ 0x02a3, { 0x02a3 } },
+{ 0x02a4, { 0x02a4 } },
+{ 0x02a5, { 0x02a5 } },
+{ 0x02a6, { 0x02a6 } },
+{ 0x02a7, { 0x02a7 } },
+{ 0x02a8, { 0x02a8 } },
+{ 0x02a9, { 0x02a9 } },
+{ 0x02aa, { 0x02aa } },
+{ 0x02ab, { 0x02ab } },
+{ 0x02ac, { 0x02ac } },
+{ 0x02ad, { 0x02ad } },
+{ 0x02ae, { 0x02ae } },
+{ 0x02af, { 0x02af } },
+{ 0x02b0, { 0x0068 } },
+{ 0x02b1, { 0x0266 } },
+{ 0x02b2, { 0x006a } },
+{ 0x02b3, { 0x0072 } },
+{ 0x02b4, { 0x0279 } },
+{ 0x02b5, { 0x027b } },
+{ 0x02b6, { 0x02b1 } },
+{ 0x02b7, { 0x0077 } },
+{ 0x02b8, { 0x0079 } },
+{ 0x02b9, { 0x0027 } },
+{ 0x02ba, { 0x0022 } },
+{ 0x02bb, { 0x02bb } },
+{ 0x02bc, { 0x0027 } },
+{ 0x02bd, { 0x02bd } },
+{ 0x02be, { 0x02be } },
+{ 0x02bf, { 0x02bf } },
+{ 0x02c0, { 0x02c0 } },
+{ 0x02c1, { 0x02c1 } },
+{ 0x02c2, { 0x02c2 } },
+{ 0x02c3, { 0x02c3 } },
+{ 0x02c4, { 0x02c4 } },
+{ 0x02c5, { 0x02c5 } },
+{ 0x02c6, { 0x02c6 } },
+{ 0x02c7, { 0x02c7 } },
+{ 0x02c8, { 0x02c8 } },
+{ 0x02c9, { 0x00af } },
+{ 0x02ca, { 0x00b4 } },
+{ 0x02cb, { 0x0060 } },
+{ 0x02cc, { 0x02cc } },
+{ 0x02cd, { 0x005f } },
+{ 0x02ce, { 0x02ce } },
+{ 0x02cf, { 0x02cf } },
+{ 0x02d0, { 0x003a } },
+{ 0x02d1, { 0x00b7 } },
+{ 0x02d2, { 0x02d2 } },
+{ 0x02d3, { 0x02d3 } },
+{ 0x02d4, { 0x02d4 } },
+{ 0x02d5, { 0x02d5 } },
+{ 0x02d6, { 0x02d6 } },
+{ 0x02d7, { 0x02d7 } },
+{ 0x02d8, { 0x02d8 } },
+{ 0x02d9, { 0x02d9 } },
+{ 0x02da, { 0x02da } },
+{ 0x02db, { 0x02db } },
+{ 0x02dc, { 0x02dc } },
+{ 0x02dd, { 0x02dd } },
+{ 0x02de, { 0x02de } },
+{ 0x02df, { 0x02df } },
+{ 0x02e0, { 0x0263 } },
+{ 0x02e1, { 0x006c } },
+{ 0x02e2, { 0x0073 } },
+{ 0x02e3, { 0x0078 } },
+{ 0x02e4, { 0x0295 } },
+{ 0x02e5, { 0x02e5 } },
+{ 0x02e6, { 0x02e6 } },
+{ 0x02e7, { 0x02e7 } },
+{ 0x02e8, { 0x02e8 } },
+{ 0x02e9, { 0x02e9 } },
+{ 0x02ea, { 0x02ea } },
+{ 0x02eb, { 0x02eb } },
+{ 0x02ec, { 0x02ec } },
+{ 0x02ed, { 0x02ed } },
+{ 0x02ee, { 0x02ee } },
+{ 0x02ef, { 0x02ef } },
+{ 0x02f0, { 0x02f0 } },
+{ 0x02f1, { 0x02f1 } },
+{ 0x02f2, { 0x02f2 } },
+{ 0x02f3, { 0x02f3 } },
+{ 0x02f4, { 0x02f4 } },
+{ 0x02f5, { 0x02f5 } },
+{ 0x02f6, { 0x02f6 } },
+{ 0x02f7, { 0x02f7 } },
+{ 0x02f8, { 0x02f8 } },
+{ 0x02f9, { 0x02f9 } },
+{ 0x02fa, { 0x02fa } },
+{ 0x02fb, { 0x02fb } },
+{ 0x02fc, { 0x02fc } },
+{ 0x02fd, { 0x02fd } },
+{ 0x02fe, { 0x02fe } },
+{ 0x02ff, { 0x02ff } },
+{ 0x0300, { 0xffff } },
+{ 0x0301, { 0xffff } },
+{ 0x0302, { 0xffff } },
+{ 0x0303, { 0xffff } },
+{ 0x0304, { 0xffff } },
+{ 0x0305, { 0xffff } },
+{ 0x0306, { 0xffff } },
+{ 0x0307, { 0xffff } },
+{ 0x0308, { 0xffff } },
+{ 0x0309, { 0xffff } },
+{ 0x030a, { 0xffff } },
+{ 0x030b, { 0xffff } },
+{ 0x030c, { 0xffff } },
+{ 0x030d, { 0xffff } },
+{ 0x030e, { 0xffff } },
+{ 0x030f, { 0xffff } },
+{ 0x0310, { 0xffff } },
+{ 0x0311, { 0xffff } },
+{ 0x0312, { 0xffff } },
+{ 0x0313, { 0xffff } },
+{ 0x0314, { 0xffff } },
+{ 0x0315, { 0xffff } },
+{ 0x0316, { 0xffff } },
+{ 0x0317, { 0xffff } },
+{ 0x0318, { 0xffff } },
+{ 0x0319, { 0xffff } },
+{ 0x031a, { 0xffff } },
+{ 0x031b, { 0xffff } },
+{ 0x031c, { 0xffff } },
+{ 0x031d, { 0xffff } },
+{ 0x031e, { 0xffff } },
+{ 0x031f, { 0xffff } },
+{ 0x0320, { 0xffff } },
+{ 0x0321, { 0xffff } },
+{ 0x0322, { 0xffff } },
+{ 0x0323, { 0xffff } },
+{ 0x0324, { 0xffff } },
+{ 0x0325, { 0xffff } },
+{ 0x0326, { 0xffff } },
+{ 0x0327, { 0xffff } },
+{ 0x0328, { 0xffff } },
+{ 0x0329, { 0xffff } },
+{ 0x032a, { 0xffff } },
+{ 0x032b, { 0xffff } },
+{ 0x032c, { 0xffff } },
+{ 0x032d, { 0xffff } },
+{ 0x032e, { 0xffff } },
+{ 0x032f, { 0xffff } },
+{ 0x0330, { 0xffff } },
+{ 0x0331, { 0xffff } },
+{ 0x0332, { 0xffff } },
+{ 0x0333, { 0xffff } },
+{ 0x0334, { 0xffff } },
+{ 0x0335, { 0xffff } },
+{ 0x0336, { 0xffff } },
+{ 0x0337, { 0xffff } },
+{ 0x0338, { 0xffff } },
+{ 0x0339, { 0xffff } },
+{ 0x033a, { 0xffff } },
+{ 0x033b, { 0xffff } },
+{ 0x033c, { 0xffff } },
+{ 0x033d, { 0xffff } },
+{ 0x033e, { 0xffff } },
+{ 0x033f, { 0xffff } },
+{ 0x0340, { 0xffff } },
+{ 0x0341, { 0xffff } },
+{ 0x0342, { 0xffff } },
+{ 0x0343, { 0xffff } },
+{ 0x0344, { 0xffff } },
+{ 0x0345, { 0xffff } },
+{ 0x0346, { 0xffff } },
+{ 0x0347, { 0xffff } },
+{ 0x0348, { 0xffff } },
+{ 0x0349, { 0xffff } },
+{ 0x034a, { 0xffff } },
+{ 0x034b, { 0xffff } },
+{ 0x034c, { 0xffff } },
+{ 0x034d, { 0xffff } },
+{ 0x034e, { 0xffff } },
+{ 0x034f, { 0xffff } },
+{ 0x0350, { 0xffff } },
+{ 0x0351, { 0xffff } },
+{ 0x0352, { 0xffff } },
+{ 0x0353, { 0xffff } },
+{ 0x0354, { 0xffff } },
+{ 0x0355, { 0xffff } },
+{ 0x0356, { 0xffff } },
+{ 0x0357, { 0xffff } },
+{ 0x0358, { 0xffff } },
+{ 0x0359, { 0xffff } },
+{ 0x035a, { 0xffff } },
+{ 0x035b, { 0xffff } },
+{ 0x035c, { 0xffff } },
+{ 0x035d, { 0xffff } },
+{ 0x035e, { 0xffff } },
+{ 0x035f, { 0xffff } },
+{ 0x0360, { 0xffff } },
+{ 0x0361, { 0xffff } },
+{ 0x0362, { 0xffff } },
+{ 0x0363, { 0xffff } },
+{ 0x0364, { 0xffff } },
+{ 0x0365, { 0xffff } },
+{ 0x0366, { 0xffff } },
+{ 0x0367, { 0xffff } },
+{ 0x0368, { 0xffff } },
+{ 0x0369, { 0xffff } },
+{ 0x036a, { 0xffff } },
+{ 0x036b, { 0xffff } },
+{ 0x036c, { 0xffff } },
+{ 0x036d, { 0xffff } },
+{ 0x036e, { 0xffff } },
+{ 0x036f, { 0xffff } },
+{ 0x0370, { 0x0370 } },
+{ 0x0371, { 0x0370 } },
+{ 0x0372, { 0x0372 } },
+{ 0x0373, { 0x0372 } },
+{ 0x0374, { 0x0374 } },
+{ 0x0375, { 0x0375 } },
+{ 0x0376, { 0x0376 } },
+{ 0x0377, { 0x0376 } },
+{ 0x0378, { 0xfffd } },
+{ 0x0379, { 0xfffd } },
+{ 0x037a, { 0x037a } },
+{ 0x037b, { 0x03fd } },
+{ 0x037c, { 0x03fe } },
+{ 0x037d, { 0x03ff } },
+{ 0x037e, { 0x003b } },
+{ 0x037f, { 0xfffd } },
+{ 0x0380, { 0xfffd } },
+{ 0x0381, { 0xfffd } },
+{ 0x0382, { 0xfffd } },
+{ 0x0383, { 0xfffd } },
+{ 0x0384, { 0xffff } },
+{ 0x0385, { 0xffff } },
+{ 0x0386, { 0x0391 } },
+{ 0x0387, { 0x00b7 } },
+{ 0x0388, { 0x0395 } },
+{ 0x0389, { 0x0397 } },
+{ 0x038a, { 0x0399 } },
+{ 0x038b, { 0xfffd } },
+{ 0x038c, { 0x039f } },
+{ 0x038d, { 0xfffd } },
+{ 0x038e, { 0x03a5 } },
+{ 0x038f, { 0x03a9 } },
+{ 0x0390, { 0x0399 } },
+{ 0x0391, { 0x0391 } },
+{ 0x0392, { 0x0392 } },
+{ 0x0393, { 0x0393 } },
+{ 0x0394, { 0x0394 } },
+{ 0x0395, { 0x0395 } },
+{ 0x0396, { 0x0396 } },
+{ 0x0397, { 0x0397 } },
+{ 0x0398, { 0x0398 } },
+{ 0x0399, { 0x0399 } },
+{ 0x039a, { 0x039a } },
+{ 0x039b, { 0x039b } },
+{ 0x039c, { 0x039c } },
+{ 0x039d, { 0x039d } },
+{ 0x039e, { 0x039e } },
+{ 0x039f, { 0x039f } },
+{ 0x03a0, { 0x03a0 } },
+{ 0x03a1, { 0x03a1 } },
+{ 0x03a2, { 0xfffd } },
+{ 0x03a3, { 0x03a3 } },
+{ 0x03a4, { 0x03a4 } },
+{ 0x03a5, { 0x03a5 } },
+{ 0x03a6, { 0x03a6 } },
+{ 0x03a7, { 0x03a7 } },
+{ 0x03a8, { 0x03a8 } },
+{ 0x03a9, { 0x03a9 } },
+{ 0x03aa, { 0x0399 } },
+{ 0x03ab, { 0x03a5 } },
+{ 0x03ac, { 0x0391 } },
+{ 0x03ad, { 0x0395 } },
+{ 0x03ae, { 0x0397 } },
+{ 0x03af, { 0x0399 } },
+{ 0x03b0, { 0x03a5 } },
+{ 0x03b1, { 0x0391 } },
+{ 0x03b2, { 0x0392 } },
+{ 0x03b3, { 0x0393 } },
+{ 0x03b4, { 0x0394 } },
+{ 0x03b5, { 0x0395 } },
+{ 0x03b6, { 0x0396 } },
+{ 0x03b7, { 0x0397 } },
+{ 0x03b8, { 0x0398 } },
+{ 0x03b9, { 0x0399 } },
+{ 0x03ba, { 0x039a } },
+{ 0x03bb, { 0x039b } },
+{ 0x03bc, { 0x039c } },
+{ 0x03bd, { 0x039d } },
+{ 0x03be, { 0x039e } },
+{ 0x03bf, { 0x039f } },
+{ 0x03c0, { 0x03a0 } },
+{ 0x03c1, { 0x03a1 } },
+{ 0x03c2, { 0x03a3 } },
+{ 0x03c3, { 0x03a3 } },
+{ 0x03c4, { 0x03a4 } },
+{ 0x03c5, { 0x03a5 } },
+{ 0x03c6, { 0x03a6 } },
+{ 0x03c7, { 0x03a7 } },
+{ 0x03c8, { 0x03a8 } },
+{ 0x03c9, { 0x03a9 } },
+{ 0x03ca, { 0x0399 } },
+{ 0x03cb, { 0x03a5 } },
+{ 0x03cc, { 0x039f } },
+{ 0x03cd, { 0x03a5 } },
+{ 0x03ce, { 0x03a9 } },
+{ 0x03cf, { 0x03cf } },
+{ 0x03d0, { 0x0392 } },
+{ 0x03d1, { 0x0398 } },
+{ 0x03d2, { 0x03a5 } },
+{ 0x03d3, { 0x03a5 } },
+{ 0x03d4, { 0x03a5 } },
+{ 0x03d5, { 0x03c6 } },
+{ 0x03d6, { 0x03c0 } },
+{ 0x03d7, { 0x03cf } },
+{ 0x03d8, { 0x03d8 } },
+{ 0x03d9, { 0x03d8 } },
+{ 0x03da, { 0x03da } },
+{ 0x03db, { 0x03da } },
+{ 0x03dc, { 0x03dc } },
+{ 0x03dd, { 0x03dc } },
+{ 0x03de, { 0x03de } },
+{ 0x03df, { 0x03de } },
+{ 0x03e0, { 0x03e0 } },
+{ 0x03e1, { 0x03e0 } },
+{ 0x03e2, { 0x03e2 } },
+{ 0x03e3, { 0x03e2 } },
+{ 0x03e4, { 0x03e4 } },
+{ 0x03e5, { 0x03e4 } },
+{ 0x03e6, { 0x03e6 } },
+{ 0x03e7, { 0x03e6 } },
+{ 0x03e8, { 0x03e8 } },
+{ 0x03e9, { 0x03e8 } },
+{ 0x03ea, { 0x03ea } },
+{ 0x03eb, { 0x03ea } },
+{ 0x03ec, { 0x03ec } },
+{ 0x03ed, { 0x03ec } },
+{ 0x03ee, { 0x03ee } },
+{ 0x03ef, { 0x03ee } },
+{ 0x03f0, { 0x03ba } },
+{ 0x03f1, { 0x03c1 } },
+{ 0x03f2, { 0x03c2 } },
+{ 0x03f3, { 0x03f3 } },
+{ 0x03f4, { 0x0398 } },
+{ 0x03f5, { 0x03b5 } },
+{ 0x03f6, { 0x03f6 } },
+{ 0x03f7, { 0x03f7 } },
+{ 0x03f8, { 0x03f7 } },
+{ 0x03f9, { 0x03a3 } },
+{ 0x03fa, { 0x03fa } },
+{ 0x03fb, { 0x03fa } },
+{ 0x03fc, { 0x03c1 } },
+{ 0x03fd, { 0x03fd } },
+{ 0x03fe, { 0x03fe } },
+{ 0x03ff, { 0x03ff } },
+{ 0x0400, { 0x0415 } },
+{ 0x0401, { 0x0415 } },
+{ 0x0402, { 0x0402 } },
+{ 0x0403, { 0x0413 } },
+{ 0x0404, { 0x0404 } },
+{ 0x0405, { 0x0405 } },
+{ 0x0406, { 0x0406 } },
+{ 0x0407, { 0x0406 } },
+{ 0x0408, { 0x0408 } },
+{ 0x0409, { 0x0409 } },
+{ 0x040a, { 0x040a } },
+{ 0x040b, { 0x040b } },
+{ 0x040c, { 0x041a } },
+{ 0x040d, { 0x0418 } },
+{ 0x040e, { 0x0423 } },
+{ 0x040f, { 0x040f } },
+{ 0x0410, { 0x0410 } },
+{ 0x0411, { 0x0411 } },
+{ 0x0412, { 0x0412 } },
+{ 0x0413, { 0x0413 } },
+{ 0x0414, { 0x0414 } },
+{ 0x0415, { 0x0415 } },
+{ 0x0416, { 0x0416 } },
+{ 0x0417, { 0x0417 } },
+{ 0x0418, { 0x0418 } },
+{ 0x0419, { 0x0418 } },
+{ 0x041a, { 0x041a } },
+{ 0x041b, { 0x041b } },
+{ 0x041c, { 0x041c } },
+{ 0x041d, { 0x041d } },
+{ 0x041e, { 0x041e } },
+{ 0x041f, { 0x041f } },
+{ 0x0420, { 0x0420 } },
+{ 0x0421, { 0x0421 } },
+{ 0x0422, { 0x0422 } },
+{ 0x0423, { 0x0423 } },
+{ 0x0424, { 0x0424 } },
+{ 0x0425, { 0x0425 } },
+{ 0x0426, { 0x0426 } },
+{ 0x0427, { 0x0427 } },
+{ 0x0428, { 0x0428 } },
+{ 0x0429, { 0x0429 } },
+{ 0x042a, { 0x042a } },
+{ 0x042b, { 0x042b } },
+{ 0x042c, { 0x042c } },
+{ 0x042d, { 0x042d } },
+{ 0x042e, { 0x042e } },
+{ 0x042f, { 0x042f } },
+{ 0x0430, { 0x0410 } },
+{ 0x0431, { 0x0411 } },
+{ 0x0432, { 0x0412 } },
+{ 0x0433, { 0x0413 } },
+{ 0x0434, { 0x0414 } },
+{ 0x0435, { 0x0415 } },
+{ 0x0436, { 0x0416 } },
+{ 0x0437, { 0x0417 } },
+{ 0x0438, { 0x0418 } },
+{ 0x0439, { 0x0418 } },
+{ 0x043a, { 0x041a } },
+{ 0x043b, { 0x041b } },
+{ 0x043c, { 0x041c } },
+{ 0x043d, { 0x041d } },
+{ 0x043e, { 0x041e } },
+{ 0x043f, { 0x041f } },
+{ 0x0440, { 0x0420 } },
+{ 0x0441, { 0x0421 } },
+{ 0x0442, { 0x0422 } },
+{ 0x0443, { 0x0423 } },
+{ 0x0444, { 0x0424 } },
+{ 0x0445, { 0x0425 } },
+{ 0x0446, { 0x0426 } },
+{ 0x0447, { 0x0427 } },
+{ 0x0448, { 0x0428 } },
+{ 0x0449, { 0x0429 } },
+{ 0x044a, { 0x042a } },
+{ 0x044b, { 0x042b } },
+{ 0x044c, { 0x042c } },
+{ 0x044d, { 0x042d } },
+{ 0x044e, { 0x042e } },
+{ 0x044f, { 0x042f } },
+{ 0x0450, { 0x0415 } },
+{ 0x0451, { 0x0415 } },
+{ 0x0452, { 0x0402 } },
+{ 0x0453, { 0x0413 } },
+{ 0x0454, { 0x0404 } },
+{ 0x0455, { 0x0405 } },
+{ 0x0456, { 0x0406 } },
+{ 0x0457, { 0x0406 } },
+{ 0x0458, { 0x0408 } },
+{ 0x0459, { 0x0409 } },
+{ 0x045a, { 0x040a } },
+{ 0x045b, { 0x040b } },
+{ 0x045c, { 0x041a } },
+{ 0x045d, { 0x0418 } },
+{ 0x045e, { 0x0423 } },
+{ 0x045f, { 0x040f } },
+{ 0x0460, { 0x0460 } },
+{ 0x0461, { 0x0460 } },
+{ 0x0462, { 0x0462 } },
+{ 0x0463, { 0x0462 } },
+{ 0x0464, { 0x0464 } },
+{ 0x0465, { 0x0464 } },
+{ 0x0466, { 0x0466 } },
+{ 0x0467, { 0x0466 } },
+{ 0x0468, { 0x0468 } },
+{ 0x0469, { 0x0468 } },
+{ 0x046a, { 0x046a } },
+{ 0x046b, { 0x046a } },
+{ 0x046c, { 0x046c } },
+{ 0x046d, { 0x046c } },
+{ 0x046e, { 0x046e } },
+{ 0x046f, { 0x046e } },
+{ 0x0470, { 0x0470 } },
+{ 0x0471, { 0x0470 } },
+{ 0x0472, { 0x0472 } },
+{ 0x0473, { 0x0472 } },
+{ 0x0474, { 0x0474 } },
+{ 0x0475, { 0x0474 } },
+{ 0x0476, { 0x0474 } },
+{ 0x0477, { 0x0474 } },
+{ 0x0478, { 0x0478 } },
+{ 0x0479, { 0x0478 } },
+{ 0x047a, { 0x047a } },
+{ 0x047b, { 0x047a } },
+{ 0x047c, { 0x047c } },
+{ 0x047d, { 0x047c } },
+{ 0x047e, { 0x047e } },
+{ 0x047f, { 0x047e } },
+{ 0x0480, { 0x0480 } },
+{ 0x0481, { 0x0480 } },
+{ 0x0482, { 0x0482 } },
+{ 0x0483, { 0xffff } },
+{ 0x0484, { 0xffff } },
+{ 0x0485, { 0xffff } },
+{ 0x0486, { 0xffff } },
+{ 0x0487, { 0xffff } },
+{ 0x0488, { 0xffff } },
+{ 0x0489, { 0xffff } },
+{ 0x048a, { 0x048a } },
+{ 0x048b, { 0x048a } },
+{ 0x048c, { 0x048c } },
+{ 0x048d, { 0x048c } },
+{ 0x048e, { 0x048e } },
+{ 0x048f, { 0x048e } },
+{ 0x0490, { 0x0490 } },
+{ 0x0491, { 0x0490 } },
+{ 0x0492, { 0x0492 } },
+{ 0x0493, { 0x0492 } },
+{ 0x0494, { 0x0494 } },
+{ 0x0495, { 0x0494 } },
+{ 0x0496, { 0x0496 } },
+{ 0x0497, { 0x0496 } },
+{ 0x0498, { 0x0498 } },
+{ 0x0499, { 0x0498 } },
+{ 0x049a, { 0x049a } },
+{ 0x049b, { 0x049a } },
+{ 0x049c, { 0x049c } },
+{ 0x049d, { 0x049c } },
+{ 0x049e, { 0x049e } },
+{ 0x049f, { 0x049e } },
+{ 0x04a0, { 0x04a0 } },
+{ 0x04a1, { 0x04a0 } },
+{ 0x04a2, { 0x04a2 } },
+{ 0x04a3, { 0x04a2 } },
+{ 0x04a4, { 0x04a4 } },
+{ 0x04a5, { 0x04a4 } },
+{ 0x04a6, { 0x04a6 } },
+{ 0x04a7, { 0x04a6 } },
+{ 0x04a8, { 0x04a8 } },
+{ 0x04a9, { 0x04a8 } },
+{ 0x04aa, { 0x04aa } },
+{ 0x04ab, { 0x04aa } },
+{ 0x04ac, { 0x04ac } },
+{ 0x04ad, { 0x04ac } },
+{ 0x04ae, { 0x04ae } },
+{ 0x04af, { 0x04ae } },
+{ 0x04b0, { 0x04b0 } },
+{ 0x04b1, { 0x04b0 } },
+{ 0x04b2, { 0x04b2 } },
+{ 0x04b3, { 0x04b2 } },
+{ 0x04b4, { 0x04b4 } },
+{ 0x04b5, { 0x04b4 } },
+{ 0x04b6, { 0x04b6 } },
+{ 0x04b7, { 0x04b6 } },
+{ 0x04b8, { 0x04b8 } },
+{ 0x04b9, { 0x04b8 } },
+{ 0x04ba, { 0x04ba } },
+{ 0x04bb, { 0x04ba } },
+{ 0x04bc, { 0x04bc } },
+{ 0x04bd, { 0x04bc } },
+{ 0x04be, { 0x04be } },
+{ 0x04bf, { 0x04be } },
+{ 0x04c0, { 0x04c0 } },
+{ 0x04c1, { 0x04c1 } },
+{ 0x04c2, { 0x04c1 } },
+{ 0x04c3, { 0x04c3 } },
+{ 0x04c4, { 0x04c3 } },
+{ 0x04c5, { 0x04c5 } },
+{ 0x04c6, { 0x04c5 } },
+{ 0x04c7, { 0x04c7 } },
+{ 0x04c8, { 0x04c7 } },
+{ 0x04c9, { 0x04c9 } },
+{ 0x04ca, { 0x04c9 } },
+{ 0x04cb, { 0x04cb } },
+{ 0x04cc, { 0x04cb } },
+{ 0x04cd, { 0x04cd } },
+{ 0x04ce, { 0x04cd } },
+{ 0x04cf, { 0x04c0 } },
+{ 0x04d0, { 0x0410 } },
+{ 0x04d1, { 0x0410 } },
+{ 0x04d2, { 0x0410 } },
+{ 0x04d3, { 0x0410 } },
+{ 0x04d4, { 0x04d4 } },
+{ 0x04d5, { 0x04d4 } },
+{ 0x04d6, { 0x0415 } },
+{ 0x04d7, { 0x0415 } },
+{ 0x04d8, { 0x04d8 } },
+{ 0x04d9, { 0x04d8 } },
+{ 0x04da, { 0x04d8 } },
+{ 0x04db, { 0x04d8 } },
+{ 0x04dc, { 0x0416 } },
+{ 0x04dd, { 0x0416 } },
+{ 0x04de, { 0x0417 } },
+{ 0x04df, { 0x0417 } },
+{ 0x04e0, { 0x04e0 } },
+{ 0x04e1, { 0x04e0 } },
+{ 0x04e2, { 0x0418 } },
+{ 0x04e3, { 0x0418 } },
+{ 0x04e4, { 0x0418 } },
+{ 0x04e5, { 0x0418 } },
+{ 0x04e6, { 0x041e } },
+{ 0x04e7, { 0x041e } },
+{ 0x04e8, { 0x04e8 } },
+{ 0x04e9, { 0x04e8 } },
+{ 0x04ea, { 0x04e8 } },
+{ 0x04eb, { 0x04e8 } },
+{ 0x04ec, { 0x042d } },
+{ 0x04ed, { 0x042d } },
+{ 0x04ee, { 0x0423 } },
+{ 0x04ef, { 0x0423 } },
+{ 0x04f0, { 0x0423 } },
+{ 0x04f1, { 0x0423 } },
+{ 0x04f2, { 0x0423 } },
+{ 0x04f3, { 0x0423 } },
+{ 0x04f4, { 0x0427 } },
+{ 0x04f5, { 0x0427 } },
+{ 0x04f6, { 0x04f6 } },
+{ 0x04f7, { 0x04f6 } },
+{ 0x04f8, { 0x042b } },
+{ 0x04f9, { 0x042b } },
+{ 0x04fa, { 0x04fa } },
+{ 0x04fb, { 0x04fa } },
+{ 0x04fc, { 0x04fc } },
+{ 0x04fd, { 0x04fc } },
+{ 0x04fe, { 0x04fe } },
+{ 0x04ff, { 0x04fe } },
+{ 0x0500, { 0x0500 } },
+{ 0x0501, { 0x0500 } },
+{ 0x0502, { 0x0502 } },
+{ 0x0503, { 0x0502 } },
+{ 0x0504, { 0x0504 } },
+{ 0x0505, { 0x0504 } },
+{ 0x0506, { 0x0506 } },
+{ 0x0507, { 0x0506 } },
+{ 0x0508, { 0x0508 } },
+{ 0x0509, { 0x0508 } },
+{ 0x050a, { 0x050a } },
+{ 0x050b, { 0x050a } },
+{ 0x050c, { 0x050c } },
+{ 0x050d, { 0x050c } },
+{ 0x050e, { 0x050e } },
+{ 0x050f, { 0x050e } },
+{ 0x0510, { 0x0510 } },
+{ 0x0511, { 0x0510 } },
+{ 0x0512, { 0x0512 } },
+{ 0x0513, { 0x0512 } },
+{ 0x0514, { 0x0514 } },
+{ 0x0515, { 0x0514 } },
+{ 0x0516, { 0x0516 } },
+{ 0x0517, { 0x0516 } },
+{ 0x0518, { 0x0518 } },
+{ 0x0519, { 0x0518 } },
+{ 0x051a, { 0x051a } },
+{ 0x051b, { 0x051a } },
+{ 0x051c, { 0x051c } },
+{ 0x051d, { 0x051c } },
+{ 0x051e, { 0x051e } },
+{ 0x051f, { 0x051e } },
+{ 0x0520, { 0x0520 } },
+{ 0x0521, { 0x0520 } },
+{ 0x0522, { 0x0522 } },
+{ 0x0523, { 0x0522 } },
+{ 0x0524, { 0xfffd } },
+{ 0x0525, { 0xfffd } },
+{ 0x0526, { 0xfffd } },
+{ 0x0527, { 0xfffd } },
+{ 0x0528, { 0xfffd } },
+{ 0x0529, { 0xfffd } },
+{ 0x052a, { 0xfffd } },
+{ 0x052b, { 0xfffd } },
+{ 0x052c, { 0xfffd } },
+{ 0x052d, { 0xfffd } },
+{ 0x052e, { 0xfffd } },
+{ 0x052f, { 0xfffd } },
+{ 0x0530, { 0xfffd } },
+{ 0x0531, { 0x0531 } },
+{ 0x0532, { 0x0532 } },
+{ 0x0533, { 0x0533 } },
+{ 0x0534, { 0x0534 } },
+{ 0x0535, { 0x0535 } },
+{ 0x0536, { 0x0536 } },
+{ 0x0537, { 0x0537 } },
+{ 0x0538, { 0x0538 } },
+{ 0x0539, { 0x0539 } },
+{ 0x053a, { 0x053a } },
+{ 0x053b, { 0x053b } },
+{ 0x053c, { 0x053c } },
+{ 0x053d, { 0x053d } },
+{ 0x053e, { 0x053e } },
+{ 0x053f, { 0x053f } },
+{ 0x0540, { 0x0540 } },
+{ 0x0541, { 0x0541 } },
+{ 0x0542, { 0x0542 } },
+{ 0x0543, { 0x0543 } },
+{ 0x0544, { 0x0544 } },
+{ 0x0545, { 0x0545 } },
+{ 0x0546, { 0x0546 } },
+{ 0x0547, { 0x0547 } },
+{ 0x0548, { 0x0548 } },
+{ 0x0549, { 0x0549 } },
+{ 0x054a, { 0x054a } },
+{ 0x054b, { 0x054b } },
+{ 0x054c, { 0x054c } },
+{ 0x054d, { 0x054d } },
+{ 0x054e, { 0x054e } },
+{ 0x054f, { 0x054f } },
+{ 0x0550, { 0x0550 } },
+{ 0x0551, { 0x0551 } },
+{ 0x0552, { 0x0552 } },
+{ 0x0553, { 0x0553 } },
+{ 0x0554, { 0x0554 } },
+{ 0x0555, { 0x0555 } },
+{ 0x0556, { 0x0556 } },
+{ 0x0557, { 0xfffd } },
+{ 0x0558, { 0xfffd } },
+{ 0x0559, { 0x0559 } },
+{ 0x055a, { 0x055a } },
+{ 0x055b, { 0x055b } },
+{ 0x055c, { 0x055c } },
+{ 0x055d, { 0x055d } },
+{ 0x055e, { 0x055e } },
+{ 0x055f, { 0x055f } },
+{ 0x0560, { 0xfffd } },
+{ 0x0561, { 0x0531 } },
+{ 0x0562, { 0x0532 } },
+{ 0x0563, { 0x0533 } },
+{ 0x0564, { 0x0534 } },
+{ 0x0565, { 0x0535 } },
+{ 0x0566, { 0x0536 } },
+{ 0x0567, { 0x0537 } },
+{ 0x0568, { 0x0538 } },
+{ 0x0569, { 0x0539 } },
+{ 0x056a, { 0x053a } },
+{ 0x056b, { 0x053b } },
+{ 0x056c, { 0x053c } },
+{ 0x056d, { 0x053d } },
+{ 0x056e, { 0x053e } },
+{ 0x056f, { 0x053f } },
+{ 0x0570, { 0x0540 } },
+{ 0x0571, { 0x0541 } },
+{ 0x0572, { 0x0542 } },
+{ 0x0573, { 0x0543 } },
+{ 0x0574, { 0x0544 } },
+{ 0x0575, { 0x0545 } },
+{ 0x0576, { 0x0546 } },
+{ 0x0577, { 0x0547 } },
+{ 0x0578, { 0x0548 } },
+{ 0x0579, { 0x0549 } },
+{ 0x057a, { 0x054a } },
+{ 0x057b, { 0x054b } },
+{ 0x057c, { 0x054c } },
+{ 0x057d, { 0x054d } },
+{ 0x057e, { 0x054e } },
+{ 0x057f, { 0x054f } },
+{ 0x0580, { 0x0550 } },
+{ 0x0581, { 0x0551 } },
+{ 0x0582, { 0x0552 } },
+{ 0x0583, { 0x0553 } },
+{ 0x0584, { 0x0554 } },
+{ 0x0585, { 0x0555 } },
+{ 0x0586, { 0x0556 } },
+{ 0x0587, { 0x0535, 0x0552 } },
+{ 0x0588, { 0xfffd } },
+{ 0x0589, { 0x0589 } },
+{ 0x058a, { 0x058a } },
+{ 0x058b, { 0xfffd } },
+{ 0x058c, { 0xfffd } },
+{ 0x058d, { 0xfffd } },
+{ 0x058e, { 0xfffd } },
+{ 0x058f, { 0xfffd } },
+{ 0x0590, { 0xfffd } },
+{ 0x0591, { 0x0591 } },
+{ 0x0592, { 0x0592 } },
+{ 0x0593, { 0x0593 } },
+{ 0x0594, { 0x0594 } },
+{ 0x0595, { 0x0595 } },
+{ 0x0596, { 0x0596 } },
+{ 0x0597, { 0x0597 } },
+{ 0x0598, { 0x0598 } },
+{ 0x0599, { 0x0599 } },
+{ 0x059a, { 0x059a } },
+{ 0x059b, { 0x059b } },
+{ 0x059c, { 0x059c } },
+{ 0x059d, { 0x059d } },
+{ 0x059e, { 0x059e } },
+{ 0x059f, { 0x059f } },
+{ 0x05a0, { 0x05a0 } },
+{ 0x05a1, { 0x05a1 } },
+{ 0x05a2, { 0x05a2 } },
+{ 0x05a3, { 0x05a3 } },
+{ 0x05a4, { 0x05a4 } },
+{ 0x05a5, { 0x05a5 } },
+{ 0x05a6, { 0x05a6 } },
+{ 0x05a7, { 0x05a7 } },
+{ 0x05a8, { 0x05a8 } },
+{ 0x05a9, { 0x05a9 } },
+{ 0x05aa, { 0x05aa } },
+{ 0x05ab, { 0x05ab } },
+{ 0x05ac, { 0x05ac } },
+{ 0x05ad, { 0x05ad } },
+{ 0x05ae, { 0x05ae } },
+{ 0x05af, { 0x05af } },
+{ 0x05b0, { 0x05b0 } },
+{ 0x05b1, { 0x05b1 } },
+{ 0x05b2, { 0x05b2 } },
+{ 0x05b3, { 0x05b3 } },
+{ 0x05b4, { 0x05b4 } },
+{ 0x05b5, { 0x05b5 } },
+{ 0x05b6, { 0x05b6 } },
+{ 0x05b7, { 0x05b7 } },
+{ 0x05b8, { 0x05b8 } },
+{ 0x05b9, { 0x05b9 } },
+{ 0x05ba, { 0x05ba } },
+{ 0x05bb, { 0x05bb } },
+{ 0x05bc, { 0x05bc } },
+{ 0x05bd, { 0x05bd } },
+{ 0x05be, { 0x05be } },
+{ 0x05bf, { 0x05bf } },
+{ 0x05c0, { 0x007c } },
+{ 0x05c1, { 0x05c1 } },
+{ 0x05c2, { 0x05c2 } },
+{ 0x05c3, { 0x003a } },
+{ 0x05c4, { 0x05c4 } },
+{ 0x05c5, { 0x05c5 } },
+{ 0x05c6, { 0x05c6 } },
+{ 0x05c7, { 0x05c7 } },
+{ 0x05c8, { 0xfffd } },
+{ 0x05c9, { 0xfffd } },
+{ 0x05ca, { 0xfffd } },
+{ 0x05cb, { 0xfffd } },
+{ 0x05cc, { 0xfffd } },
+{ 0x05cd, { 0xfffd } },
+{ 0x05ce, { 0xfffd } },
+{ 0x05cf, { 0xfffd } },
+{ 0x05d0, { 0x05d0 } },
+{ 0x05d1, { 0x05d1 } },
+{ 0x05d2, { 0x05d2 } },
+{ 0x05d3, { 0x05d3 } },
+{ 0x05d4, { 0x05d4 } },
+{ 0x05d5, { 0x05d5 } },
+{ 0x05d6, { 0x05d6 } },
+{ 0x05d7, { 0x05d7 } },
+{ 0x05d8, { 0x05d8 } },
+{ 0x05d9, { 0x05d9 } },
+{ 0x05da, { 0x05da } },
+{ 0x05db, { 0x05db } },
+{ 0x05dc, { 0x05dc } },
+{ 0x05dd, { 0x05dd } },
+{ 0x05de, { 0x05de } },
+{ 0x05df, { 0x05df } },
+{ 0x05e0, { 0x05e0 } },
+{ 0x05e1, { 0x05e1 } },
+{ 0x05e2, { 0x05e2 } },
+{ 0x05e3, { 0x05e3 } },
+{ 0x05e4, { 0x05e4 } },
+{ 0x05e5, { 0x05e5 } },
+{ 0x05e6, { 0x05e6 } },
+{ 0x05e7, { 0x05e7 } },
+{ 0x05e8, { 0x05e8 } },
+{ 0x05e9, { 0x05e9 } },
+{ 0x05ea, { 0x05ea } },
+{ 0x05eb, { 0xfffd } },
+{ 0x05ec, { 0xfffd } },
+{ 0x05ed, { 0xfffd } },
+{ 0x05ee, { 0xfffd } },
+{ 0x05ef, { 0xfffd } },
+{ 0x05f0, { 0x05d5, 0x05d5 } },
+{ 0x05f1, { 0x05d5, 0x05d9 } },
+{ 0x05f2, { 0x05d9, 0x05d9 } },
+{ 0x05f3, { 0x05f3 } },
+{ 0x05f4, { 0x05f4 } },
+{ 0x05f5, { 0xfffd } },
+{ 0x05f6, { 0xfffd } },
+{ 0x05f7, { 0xfffd } },
+{ 0x05f8, { 0xfffd } },
+{ 0x05f9, { 0xfffd } },
+{ 0x05fa, { 0xfffd } },
+{ 0x05fb, { 0xfffd } },
+{ 0x05fc, { 0xfffd } },
+{ 0x05fd, { 0xfffd } },
+{ 0x05fe, { 0xfffd } },
+{ 0x05ff, { 0xfffd } },
+{ 0x1e00, { 0x0041 } },
+{ 0x1e01, { 0x0041 } },
+{ 0x1e02, { 0x0042 } },
+{ 0x1e03, { 0x0042 } },
+{ 0x1e04, { 0x0042 } },
+{ 0x1e05, { 0x0042 } },
+{ 0x1e06, { 0x0042 } },
+{ 0x1e07, { 0x0042 } },
+{ 0x1e08, { 0x0043 } },
+{ 0x1e09, { 0x0043 } },
+{ 0x1e0a, { 0x0044 } },
+{ 0x1e0b, { 0x0044 } },
+{ 0x1e0c, { 0x0044 } },
+{ 0x1e0d, { 0x0044 } },
+{ 0x1e0e, { 0x0044 } },
+{ 0x1e0f, { 0x0044 } },
+{ 0x1e10, { 0x0044 } },
+{ 0x1e11, { 0x0044 } },
+{ 0x1e12, { 0x0044 } },
+{ 0x1e13, { 0x0044 } },
+{ 0x1e14, { 0x0045 } },
+{ 0x1e15, { 0x0045 } },
+{ 0x1e16, { 0x0045 } },
+{ 0x1e17, { 0x0045 } },
+{ 0x1e18, { 0x0045 } },
+{ 0x1e19, { 0x0045 } },
+{ 0x1e1a, { 0x0045 } },
+{ 0x1e1b, { 0x0045 } },
+{ 0x1e1c, { 0x0045 } },
+{ 0x1e1d, { 0x0045 } },
+{ 0x1e1e, { 0x0046 } },
+{ 0x1e1f, { 0x0046 } },
+{ 0x1e20, { 0x0047 } },
+{ 0x1e21, { 0x0047 } },
+{ 0x1e22, { 0x0048 } },
+{ 0x1e23, { 0x0048 } },
+{ 0x1e24, { 0x0048 } },
+{ 0x1e25, { 0x0048 } },
+{ 0x1e26, { 0x0048 } },
+{ 0x1e27, { 0x0048 } },
+{ 0x1e28, { 0x0048 } },
+{ 0x1e29, { 0x0048 } },
+{ 0x1e2a, { 0x0048 } },
+{ 0x1e2b, { 0x0048 } },
+{ 0x1e2c, { 0x0049 } },
+{ 0x1e2d, { 0x0049 } },
+{ 0x1e2e, { 0x0049 } },
+{ 0x1e2f, { 0x0049 } },
+{ 0x1e30, { 0x004b } },
+{ 0x1e31, { 0x004b } },
+{ 0x1e32, { 0x004b } },
+{ 0x1e33, { 0x004b } },
+{ 0x1e34, { 0x004b } },
+{ 0x1e35, { 0x004b } },
+{ 0x1e36, { 0x004c } },
+{ 0x1e37, { 0x004c } },
+{ 0x1e38, { 0x004c } },
+{ 0x1e39, { 0x004c } },
+{ 0x1e3a, { 0x004c } },
+{ 0x1e3b, { 0x004c } },
+{ 0x1e3c, { 0x004c } },
+{ 0x1e3d, { 0x004c } },
+{ 0x1e3e, { 0x004d } },
+{ 0x1e3f, { 0x004d } },
+{ 0x1e40, { 0x004d } },
+{ 0x1e41, { 0x004d } },
+{ 0x1e42, { 0x004d } },
+{ 0x1e43, { 0x004d } },
+{ 0x1e44, { 0x004e } },
+{ 0x1e45, { 0x004e } },
+{ 0x1e46, { 0x004e } },
+{ 0x1e47, { 0x004e } },
+{ 0x1e48, { 0x004e } },
+{ 0x1e49, { 0x004e } },
+{ 0x1e4a, { 0x004e } },
+{ 0x1e4b, { 0x004e } },
+{ 0x1e4c, { 0x004f } },
+{ 0x1e4d, { 0x004f } },
+{ 0x1e4e, { 0x004f } },
+{ 0x1e4f, { 0x004f } },
+{ 0x1e50, { 0x004f } },
+{ 0x1e51, { 0x004f } },
+{ 0x1e52, { 0x004f } },
+{ 0x1e53, { 0x004f } },
+{ 0x1e54, { 0x0050 } },
+{ 0x1e55, { 0x0050 } },
+{ 0x1e56, { 0x0050 } },
+{ 0x1e57, { 0x0050 } },
+{ 0x1e58, { 0x0052 } },
+{ 0x1e59, { 0x0052 } },
+{ 0x1e5a, { 0x0052 } },
+{ 0x1e5b, { 0x0052 } },
+{ 0x1e5c, { 0x0052 } },
+{ 0x1e5d, { 0x0052 } },
+{ 0x1e5e, { 0x0052 } },
+{ 0x1e5f, { 0x0052 } },
+{ 0x1e60, { 0x0053 } },
+{ 0x1e61, { 0x0053 } },
+{ 0x1e62, { 0x0053 } },
+{ 0x1e63, { 0x0053 } },
+{ 0x1e64, { 0x0053 } },
+{ 0x1e65, { 0x0053 } },
+{ 0x1e66, { 0x0053 } },
+{ 0x1e67, { 0x0053 } },
+{ 0x1e68, { 0x0053 } },
+{ 0x1e69, { 0x0053 } },
+{ 0x1e6a, { 0x0054 } },
+{ 0x1e6b, { 0x0054 } },
+{ 0x1e6c, { 0x0054 } },
+{ 0x1e6d, { 0x0054 } },
+{ 0x1e6e, { 0x0054 } },
+{ 0x1e6f, { 0x0054 } },
+{ 0x1e70, { 0x0054 } },
+{ 0x1e71, { 0x0054 } },
+{ 0x1e72, { 0x0055 } },
+{ 0x1e73, { 0x0055 } },
+{ 0x1e74, { 0x0055 } },
+{ 0x1e75, { 0x0055 } },
+{ 0x1e76, { 0x0055 } },
+{ 0x1e77, { 0x0055 } },
+{ 0x1e78, { 0x0055 } },
+{ 0x1e79, { 0x0055 } },
+{ 0x1e7a, { 0x0055 } },
+{ 0x1e7b, { 0x0055 } },
+{ 0x1e7c, { 0x0056 } },
+{ 0x1e7d, { 0x0056 } },
+{ 0x1e7e, { 0x0056 } },
+{ 0x1e7f, { 0x0056 } },
+{ 0x1e80, { 0x0057 } },
+{ 0x1e81, { 0x0057 } },
+{ 0x1e82, { 0x0057 } },
+{ 0x1e83, { 0x0057 } },
+{ 0x1e84, { 0x0057 } },
+{ 0x1e85, { 0x0057 } },
+{ 0x1e86, { 0x0057 } },
+{ 0x1e87, { 0x0057 } },
+{ 0x1e88, { 0x0057 } },
+{ 0x1e89, { 0x0057 } },
+{ 0x1e8a, { 0x0058 } },
+{ 0x1e8b, { 0x0058 } },
+{ 0x1e8c, { 0x0058 } },
+{ 0x1e8d, { 0x0058 } },
+{ 0x1e8e, { 0x0059 } },
+{ 0x1e8f, { 0x0059 } },
+{ 0x1e90, { 0x005a } },
+{ 0x1e91, { 0x005a } },
+{ 0x1e92, { 0x005a } },
+{ 0x1e93, { 0x005a } },
+{ 0x1e94, { 0x005a } },
+{ 0x1e95, { 0x005a } },
+{ 0x1e96, { 0x0048 } },
+{ 0x1e97, { 0x0054 } },
+{ 0x1e98, { 0x0057 } },
+{ 0x1e99, { 0x0059 } },
+{ 0x1e9a, { 0x0041 } },
+{ 0x1e9b, { 0x017f } },
+{ 0x1e9c, { 0x017f } },
+{ 0x1e9d, { 0x017f } },
+{ 0x1e9e, { 0x1e9e } },
+{ 0x1e9f, { 0x1e9f } },
+{ 0x1ea0, { 0x0041 } },
+{ 0x1ea1, { 0x0041 } },
+{ 0x1ea2, { 0x0041 } },
+{ 0x1ea3, { 0x0041 } },
+{ 0x1ea4, { 0x0041 } },
+{ 0x1ea5, { 0x0041 } },
+{ 0x1ea6, { 0x0041 } },
+{ 0x1ea7, { 0x0041 } },
+{ 0x1ea8, { 0x0041 } },
+{ 0x1ea9, { 0x0041 } },
+{ 0x1eaa, { 0x0041 } },
+{ 0x1eab, { 0x0041 } },
+{ 0x1eac, { 0x0041 } },
+{ 0x1ead, { 0x0041 } },
+{ 0x1eae, { 0x0041 } },
+{ 0x1eaf, { 0x0041 } },
+{ 0x1eb0, { 0x0041 } },
+{ 0x1eb1, { 0x0041 } },
+{ 0x1eb2, { 0x0041 } },
+{ 0x1eb3, { 0x0041 } },
+{ 0x1eb4, { 0x0041 } },
+{ 0x1eb5, { 0x0041 } },
+{ 0x1eb6, { 0x0041 } },
+{ 0x1eb7, { 0x0041 } },
+{ 0x1eb8, { 0x0045 } },
+{ 0x1eb9, { 0x0045 } },
+{ 0x1eba, { 0x0045 } },
+{ 0x1ebb, { 0x0045 } },
+{ 0x1ebc, { 0x0045 } },
+{ 0x1ebd, { 0x0045 } },
+{ 0x1ebe, { 0x0045 } },
+{ 0x1ebf, { 0x0045 } },
+{ 0x1ec0, { 0x0045 } },
+{ 0x1ec1, { 0x0045 } },
+{ 0x1ec2, { 0x0045 } },
+{ 0x1ec3, { 0x0045 } },
+{ 0x1ec4, { 0x0045 } },
+{ 0x1ec5, { 0x0045 } },
+{ 0x1ec6, { 0x0045 } },
+{ 0x1ec7, { 0x0045 } },
+{ 0x1ec8, { 0x0049 } },
+{ 0x1ec9, { 0x0049 } },
+{ 0x1eca, { 0x0049 } },
+{ 0x1ecb, { 0x0049 } },
+{ 0x1ecc, { 0x004f } },
+{ 0x1ecd, { 0x004f } },
+{ 0x1ece, { 0x004f } },
+{ 0x1ecf, { 0x004f } },
+{ 0x1ed0, { 0x004f } },
+{ 0x1ed1, { 0x004f } },
+{ 0x1ed2, { 0x004f } },
+{ 0x1ed3, { 0x004f } },
+{ 0x1ed4, { 0x004f } },
+{ 0x1ed5, { 0x004f } },
+{ 0x1ed6, { 0x004f } },
+{ 0x1ed7, { 0x004f } },
+{ 0x1ed8, { 0x004f } },
+{ 0x1ed9, { 0x004f } },
+{ 0x1eda, { 0x004f } },
+{ 0x1edb, { 0x004f } },
+{ 0x1edc, { 0x004f } },
+{ 0x1edd, { 0x004f } },
+{ 0x1ede, { 0x004f } },
+{ 0x1edf, { 0x004f } },
+{ 0x1ee0, { 0x004f } },
+{ 0x1ee1, { 0x004f } },
+{ 0x1ee2, { 0x004f } },
+{ 0x1ee3, { 0x004f } },
+{ 0x1ee4, { 0x0055 } },
+{ 0x1ee5, { 0x0055 } },
+{ 0x1ee6, { 0x0055 } },
+{ 0x1ee7, { 0x0055 } },
+{ 0x1ee8, { 0x0055 } },
+{ 0x1ee9, { 0x0055 } },
+{ 0x1eea, { 0x0055 } },
+{ 0x1eeb, { 0x0055 } },
+{ 0x1eec, { 0x0055 } },
+{ 0x1eed, { 0x0055 } },
+{ 0x1eee, { 0x0055 } },
+{ 0x1eef, { 0x0055 } },
+{ 0x1ef0, { 0x0055 } },
+{ 0x1ef1, { 0x0055 } },
+{ 0x1ef2, { 0x0059 } },
+{ 0x1ef3, { 0x0059 } },
+{ 0x1ef4, { 0x0059 } },
+{ 0x1ef5, { 0x0059 } },
+{ 0x1ef6, { 0x0059 } },
+{ 0x1ef7, { 0x0059 } },
+{ 0x1ef8, { 0x0059 } },
+{ 0x1ef9, { 0x0059 } },
+{ 0x1efa, { 0x1efa } },
+{ 0x1efb, { 0x1efa } },
+{ 0x1efc, { 0x1efc } },
+{ 0x1efd, { 0x1efc } },
+{ 0x1efe, { 0x1efe } },
+{ 0x1eff, { 0x1efe } },
+{ 0x1f00, { 0x0391 } },
+{ 0x1f01, { 0x0391 } },
+{ 0x1f02, { 0x0391 } },
+{ 0x1f03, { 0x0391 } },
+{ 0x1f04, { 0x0391 } },
+{ 0x1f05, { 0x0391 } },
+{ 0x1f06, { 0x0391 } },
+{ 0x1f07, { 0x0391 } },
+{ 0x1f08, { 0x0391 } },
+{ 0x1f09, { 0x0391 } },
+{ 0x1f0a, { 0x0391 } },
+{ 0x1f0b, { 0x0391 } },
+{ 0x1f0c, { 0x0391 } },
+{ 0x1f0d, { 0x0391 } },
+{ 0x1f0e, { 0x0391 } },
+{ 0x1f0f, { 0x0391 } },
+{ 0x1f10, { 0x0395 } },
+{ 0x1f11, { 0x0395 } },
+{ 0x1f12, { 0x0395 } },
+{ 0x1f13, { 0x0395 } },
+{ 0x1f14, { 0x0395 } },
+{ 0x1f15, { 0x0395 } },
+{ 0x1f16, { 0xfffd } },
+{ 0x1f17, { 0xfffd } },
+{ 0x1f18, { 0x0395 } },
+{ 0x1f19, { 0x0395 } },
+{ 0x1f1a, { 0x0395 } },
+{ 0x1f1b, { 0x0395 } },
+{ 0x1f1c, { 0x0395 } },
+{ 0x1f1d, { 0x0395 } },
+{ 0x1f1e, { 0xfffd } },
+{ 0x1f1f, { 0xfffd } },
+{ 0x1f20, { 0x0397 } },
+{ 0x1f21, { 0x0397 } },
+{ 0x1f22, { 0x0397 } },
+{ 0x1f23, { 0x0397 } },
+{ 0x1f24, { 0x0397 } },
+{ 0x1f25, { 0x0397 } },
+{ 0x1f26, { 0x0397 } },
+{ 0x1f27, { 0x0397 } },
+{ 0x1f28, { 0x0397 } },
+{ 0x1f29, { 0x0397 } },
+{ 0x1f2a, { 0x0397 } },
+{ 0x1f2b, { 0x0397 } },
+{ 0x1f2c, { 0x0397 } },
+{ 0x1f2d, { 0x0397 } },
+{ 0x1f2e, { 0x0397 } },
+{ 0x1f2f, { 0x0397 } },
+{ 0x1f30, { 0x0399 } },
+{ 0x1f31, { 0x0399 } },
+{ 0x1f32, { 0x0399 } },
+{ 0x1f33, { 0x0399 } },
+{ 0x1f34, { 0x0399 } },
+{ 0x1f35, { 0x0399 } },
+{ 0x1f36, { 0x0399 } },
+{ 0x1f37, { 0x0399 } },
+{ 0x1f38, { 0x0399 } },
+{ 0x1f39, { 0x0399 } },
+{ 0x1f3a, { 0x0399 } },
+{ 0x1f3b, { 0x0399 } },
+{ 0x1f3c, { 0x0399 } },
+{ 0x1f3d, { 0x0399 } },
+{ 0x1f3e, { 0x0399 } },
+{ 0x1f3f, { 0x0399 } },
+{ 0x1f40, { 0x039f } },
+{ 0x1f41, { 0x039f } },
+{ 0x1f42, { 0x039f } },
+{ 0x1f43, { 0x039f } },
+{ 0x1f44, { 0x039f } },
+{ 0x1f45, { 0x039f } },
+{ 0x1f46, { 0xfffd } },
+{ 0x1f47, { 0xfffd } },
+{ 0x1f48, { 0x039f } },
+{ 0x1f49, { 0x039f } },
+{ 0x1f4a, { 0x039f } },
+{ 0x1f4b, { 0x039f } },
+{ 0x1f4c, { 0x039f } },
+{ 0x1f4d, { 0x039f } },
+{ 0x1f4e, { 0xfffd } },
+{ 0x1f4f, { 0xfffd } },
+{ 0x1f50, { 0x03a5 } },
+{ 0x1f51, { 0x03a5 } },
+{ 0x1f52, { 0x03a5 } },
+{ 0x1f53, { 0x03a5 } },
+{ 0x1f54, { 0x03a5 } },
+{ 0x1f55, { 0x03a5 } },
+{ 0x1f56, { 0x03a5 } },
+{ 0x1f57, { 0x03a5 } },
+{ 0x1f58, { 0xfffd } },
+{ 0x1f59, { 0x03a5 } },
+{ 0x1f5a, { 0xfffd } },
+{ 0x1f5b, { 0x03a5 } },
+{ 0x1f5c, { 0xfffd } },
+{ 0x1f5d, { 0x03a5 } },
+{ 0x1f5e, { 0xfffd } },
+{ 0x1f5f, { 0x03a5 } },
+{ 0x1f60, { 0x03a9 } },
+{ 0x1f61, { 0x03a9 } },
+{ 0x1f62, { 0x03a9 } },
+{ 0x1f63, { 0x03a9 } },
+{ 0x1f64, { 0x03a9 } },
+{ 0x1f65, { 0x03a9 } },
+{ 0x1f66, { 0x03a9 } },
+{ 0x1f67, { 0x03a9 } },
+{ 0x1f68, { 0x03a9 } },
+{ 0x1f69, { 0x03a9 } },
+{ 0x1f6a, { 0x03a9 } },
+{ 0x1f6b, { 0x03a9 } },
+{ 0x1f6c, { 0x03a9 } },
+{ 0x1f6d, { 0x03a9 } },
+{ 0x1f6e, { 0x03a9 } },
+{ 0x1f6f, { 0x03a9 } },
+{ 0x1f70, { 0x0391 } },
+{ 0x1f71, { 0x0391 } },
+{ 0x1f72, { 0x0395 } },
+{ 0x1f73, { 0x0395 } },
+{ 0x1f74, { 0x0397 } },
+{ 0x1f75, { 0x0397 } },
+{ 0x1f76, { 0x0399 } },
+{ 0x1f77, { 0x0399 } },
+{ 0x1f78, { 0x039f } },
+{ 0x1f79, { 0x039f } },
+{ 0x1f7a, { 0x03a5 } },
+{ 0x1f7b, { 0x03a5 } },
+{ 0x1f7c, { 0x03a9 } },
+{ 0x1f7d, { 0x03a9 } },
+{ 0x1f7e, { 0xfffd } },
+{ 0x1f7f, { 0xfffd } },
+{ 0x1f80, { 0x0391 } },
+{ 0x1f81, { 0x0391 } },
+{ 0x1f82, { 0x0391 } },
+{ 0x1f83, { 0x0391 } },
+{ 0x1f84, { 0x0391 } },
+{ 0x1f85, { 0x0391 } },
+{ 0x1f86, { 0x0391 } },
+{ 0x1f87, { 0x0391 } },
+{ 0x1f88, { 0x0391 } },
+{ 0x1f89, { 0x0391 } },
+{ 0x1f8a, { 0x0391 } },
+{ 0x1f8b, { 0x0391 } },
+{ 0x1f8c, { 0x0391 } },
+{ 0x1f8d, { 0x0391 } },
+{ 0x1f8e, { 0x0391 } },
+{ 0x1f8f, { 0x0391 } },
+{ 0x1f90, { 0x0397 } },
+{ 0x1f91, { 0x0397 } },
+{ 0x1f92, { 0x0397 } },
+{ 0x1f93, { 0x0397 } },
+{ 0x1f94, { 0x0397 } },
+{ 0x1f95, { 0x0397 } },
+{ 0x1f96, { 0x0397 } },
+{ 0x1f97, { 0x0397 } },
+{ 0x1f98, { 0x0397 } },
+{ 0x1f99, { 0x0397 } },
+{ 0x1f9a, { 0x0397 } },
+{ 0x1f9b, { 0x0397 } },
+{ 0x1f9c, { 0x0397 } },
+{ 0x1f9d, { 0x0397 } },
+{ 0x1f9e, { 0x0397 } },
+{ 0x1f9f, { 0x0397 } },
+{ 0x1fa0, { 0x03a9 } },
+{ 0x1fa1, { 0x03a9 } },
+{ 0x1fa2, { 0x03a9 } },
+{ 0x1fa3, { 0x03a9 } },
+{ 0x1fa4, { 0x03a9 } },
+{ 0x1fa5, { 0x03a9 } },
+{ 0x1fa6, { 0x03a9 } },
+{ 0x1fa7, { 0x03a9 } },
+{ 0x1fa8, { 0x03a9 } },
+{ 0x1fa9, { 0x03a9 } },
+{ 0x1faa, { 0x03a9 } },
+{ 0x1fab, { 0x03a9 } },
+{ 0x1fac, { 0x03a9 } },
+{ 0x1fad, { 0x03a9 } },
+{ 0x1fae, { 0x03a9 } },
+{ 0x1faf, { 0x03a9 } },
+{ 0x1fb0, { 0x0391 } },
+{ 0x1fb1, { 0x0391 } },
+{ 0x1fb2, { 0x0391 } },
+{ 0x1fb3, { 0x0391 } },
+{ 0x1fb4, { 0x0391 } },
+{ 0x1fb5, { 0xfffd } },
+{ 0x1fb6, { 0x0391 } },
+{ 0x1fb7, { 0x0391 } },
+{ 0x1fb8, { 0x0391 } },
+{ 0x1fb9, { 0x0391 } },
+{ 0x1fba, { 0x0391 } },
+{ 0x1fbb, { 0x0391 } },
+{ 0x1fbc, { 0x0391 } },
+{ 0x1fbd, { 0x1fbd } },
+{ 0x1fbe, { 0x0399 } },
+{ 0x1fbf, { 0x1fbf } },
+{ 0x1fc0, { 0x1fc0 } },
+{ 0x1fc1, { 0x1fc1 } },
+{ 0x1fc2, { 0x0397 } },
+{ 0x1fc3, { 0x0397 } },
+{ 0x1fc4, { 0x0397 } },
+{ 0x1fc5, { 0xfffd } },
+{ 0x1fc6, { 0x0397 } },
+{ 0x1fc7, { 0x0397 } },
+{ 0x1fc8, { 0x0395 } },
+{ 0x1fc9, { 0x0395 } },
+{ 0x1fca, { 0x0397 } },
+{ 0x1fcb, { 0x0397 } },
+{ 0x1fcc, { 0x0397 } },
+{ 0x1fcd, { 0x1fcd } },
+{ 0x1fce, { 0x1fce } },
+{ 0x1fcf, { 0x1fcf } },
+{ 0x1fd0, { 0x0399 } },
+{ 0x1fd1, { 0x0399 } },
+{ 0x1fd2, { 0x0399 } },
+{ 0x1fd3, { 0x0399 } },
+{ 0x1fd4, { 0xfffd } },
+{ 0x1fd5, { 0xfffd } },
+{ 0x1fd6, { 0x0399 } },
+{ 0x1fd7, { 0x0399 } },
+{ 0x1fd8, { 0x0399 } },
+{ 0x1fd9, { 0x0399 } },
+{ 0x1fda, { 0x0399 } },
+{ 0x1fdb, { 0x0399 } },
+{ 0x1fdc, { 0xfffd } },
+{ 0x1fdd, { 0x1fdd } },
+{ 0x1fde, { 0x1fde } },
+{ 0x1fdf, { 0x1fdf } },
+{ 0x1fe0, { 0x03a5 } },
+{ 0x1fe1, { 0x03a5 } },
+{ 0x1fe2, { 0x03a5 } },
+{ 0x1fe3, { 0x03a5 } },
+{ 0x1fe4, { 0x03a1 } },
+{ 0x1fe5, { 0x03a1 } },
+{ 0x1fe6, { 0x03a5 } },
+{ 0x1fe7, { 0x03a5 } },
+{ 0x1fe8, { 0x03a5 } },
+{ 0x1fe9, { 0x03a5 } },
+{ 0x1fea, { 0x03a5 } },
+{ 0x1feb, { 0x03a5 } },
+{ 0x1fec, { 0x03a1 } },
+{ 0x1fed, { 0x1fed } },
+{ 0x1fee, { 0x1fee } },
+{ 0x1fef, { 0x1fef } },
+{ 0x1ff0, { 0xfffd } },
+{ 0x1ff1, { 0xfffd } },
+{ 0x1ff2, { 0x03a9 } },
+{ 0x1ff3, { 0x03a9 } },
+{ 0x1ff4, { 0x03a9 } },
+{ 0x1ff5, { 0xfffd } },
+{ 0x1ff6, { 0x03a9 } },
+{ 0x1ff7, { 0x03a9 } },
+{ 0x1ff8, { 0x039f } },
+{ 0x1ff9, { 0x039f } },
+{ 0x1ffa, { 0x03a9 } },
+{ 0x1ffb, { 0x03a9 } },
+{ 0x1ffc, { 0x03a9 } },
+{ 0x1ffd, { 0x1ffd } },
+{ 0x1ffe, { 0x1ffe } },
+{ 0x1fff, { 0xfffd } },
+{ 0x2000, { 0x0020 } },
+{ 0x2001, { 0x0020 } },
+{ 0x2002, { 0x0020 } },
+{ 0x2003, { 0x0020 } },
+{ 0x2004, { 0x0020 } },
+{ 0x2005, { 0x0020 } },
+{ 0x2006, { 0x0020 } },
+{ 0x2007, { 0x0020 } },
+{ 0x2008, { 0x0020 } },
+{ 0x2009, { 0x0020 } },
+{ 0x200a, { 0x0020 } },
+{ 0x200b, { 0x0020 } },
+{ 0x200c, { 0x200c } },
+{ 0x200d, { 0x200d } },
+{ 0x200e, { 0x200e } },
+{ 0x200f, { 0x200f } },
+{ 0x2010, { 0x002d } },
+{ 0x2011, { 0x002d } },
+{ 0x2012, { 0x002d } },
+{ 0x2013, { 0x002d } },
+{ 0x2014, { 0x002d } },
+{ 0x2015, { 0x002d } },
+{ 0x2016, { 0x2016 } },
+{ 0x2017, { 0x005f } },
+{ 0x2018, { 0x0027 } },
+{ 0x2019, { 0x0027 } },
+{ 0x201a, { 0x201a } },
+{ 0x201b, { 0x201b } },
+{ 0x201c, { 0x0022 } },
+{ 0x201d, { 0x0022 } },
+{ 0x201e, { 0x201e } },
+{ 0x201f, { 0x201f } },
+{ 0x2020, { 0x2020 } },
+{ 0x2021, { 0x2021 } },
+{ 0x2022, { 0x00b7 } },
+{ 0x2023, { 0x2023 } },
+{ 0x2024, { 0x002e } },
+{ 0x2025, { 0x002e, 0x002e } },
+{ 0x2026, { 0x002e, 0x002e, 0x002e } },
+{ 0x2027, { 0x2027 } },
+{ 0x2028, { 0x2028 } },
+{ 0x2029, { 0x2029 } },
+{ 0x202a, { 0x202a } },
+{ 0x202b, { 0x202b } },
+{ 0x202c, { 0x202c } },
+{ 0x202d, { 0x202d } },
+{ 0x202e, { 0x202e } },
+{ 0x202f, { 0x0020 } },
+{ 0x2030, { 0x2030 } },
+{ 0x2031, { 0x2031 } },
+{ 0x2032, { 0x0027 } },
+{ 0x2033, { 0x0022 } },
+{ 0x2034, { 0x0027, 0x0027, 0x0027 } },
+{ 0x2035, { 0x0060 } },
+{ 0x2036, { 0x0060, 0x0060 } },
+{ 0x2037, { 0x0060, 0x0060, 0x0060 } },
+{ 0x2038, { 0x2038 } },
+{ 0x2039, { 0x2039 } },
+{ 0x203a, { 0x203a } },
+{ 0x203b, { 0x203b } },
+{ 0x203c, { 0x0021, 0x0021 } },
+{ 0x203d, { 0x203d } },
+{ 0x203e, { 0x203e } },
+{ 0x203f, { 0x203f } },
+{ 0x2040, { 0x2040 } },
+{ 0x2041, { 0x2041 } },
+{ 0x2042, { 0x2042 } },
+{ 0x2043, { 0x2043 } },
+{ 0x2044, { 0x002f } },
+{ 0x2045, { 0x2045 } },
+{ 0x2046, { 0x2046 } },
+{ 0x2047, { 0x003f, 0x003f } },
+{ 0x2048, { 0x003f, 0x0021 } },
+{ 0x2049, { 0x0021, 0x003f } },
+{ 0x204a, { 0x204a } },
+{ 0x204b, { 0x204b } },
+{ 0x204c, { 0x204c } },
+{ 0x204d, { 0x204d } },
+{ 0x204e, { 0x204e } },
+{ 0x204f, { 0x204f } },
+{ 0x2050, { 0x2050 } },
+{ 0x2051, { 0x2051 } },
+{ 0x2052, { 0x2052 } },
+{ 0x2053, { 0x007e } },
+{ 0x2054, { 0x2054 } },
+{ 0x2055, { 0x2055 } },
+{ 0x2056, { 0x2056 } },
+{ 0x2057, { 0x0027, 0x0027, 0x0027, 0x0027 } },
+{ 0x2058, { 0x2058 } },
+{ 0x2059, { 0x2059 } },
+{ 0x205a, { 0x205a } },
+{ 0x205b, { 0x205b } },
+{ 0x205c, { 0x205c } },
+{ 0x205d, { 0x205d } },
+{ 0x205e, { 0x205e } },
+{ 0x205f, { 0x0020 } },
+{ 0x2060, { 0x0020 } },
+{ 0x2061, { 0x2061 } },
+{ 0x2062, { 0x2062 } },
+{ 0x2063, { 0x2063 } },
+{ 0x2064, { 0x2064 } },
+{ 0x2065, { 0xfffd } },
+{ 0x2066, { 0xfffd } },
+{ 0x2067, { 0xfffd } },
+{ 0x2068, { 0xfffd } },
+{ 0x2069, { 0xfffd } },
+{ 0x206a, { 0x206a } },
+{ 0x206b, { 0x206b } },
+{ 0x206c, { 0x206c } },
+{ 0x206d, { 0x206d } },
+{ 0x206e, { 0x206e } },
+{ 0x206f, { 0x206f } },
+{ 0x2070, { 0x0030 } },
+{ 0x2071, { 0x0069 } },
+{ 0x2072, { 0xfffd } },
+{ 0x2073, { 0xfffd } },
+{ 0x2074, { 0x0034 } },
+{ 0x2075, { 0x0035 } },
+{ 0x2076, { 0x0036 } },
+{ 0x2077, { 0x0037 } },
+{ 0x2078, { 0x0038 } },
+{ 0x2079, { 0x0039 } },
+{ 0x207a, { 0x002b } },
+{ 0x207b, { 0x002d } },
+{ 0x207c, { 0x003d } },
+{ 0x207d, { 0x0028 } },
+{ 0x207e, { 0x0029 } },
+{ 0x207f, { 0x006e } },
+{ 0x2080, { 0x0030 } },
+{ 0x2081, { 0x0031 } },
+{ 0x2082, { 0x0032 } },
+{ 0x2083, { 0x0033 } },
+{ 0x2084, { 0x0034 } },
+{ 0x2085, { 0x0035 } },
+{ 0x2086, { 0x0036 } },
+{ 0x2087, { 0x0037 } },
+{ 0x2088, { 0x0038 } },
+{ 0x2089, { 0x0039 } },
+{ 0x208a, { 0x002b } },
+{ 0x208b, { 0x002d } },
+{ 0x208c, { 0x003d } },
+{ 0x208d, { 0x0028 } },
+{ 0x208e, { 0x0029 } },
+{ 0x208f, { 0xfffd } },
+{ 0x2090, { 0x0061 } },
+{ 0x2091, { 0x0065 } },
+{ 0x2092, { 0x006f } },
+{ 0x2093, { 0x0078 } },
+{ 0x2094, { 0x0259 } },
+{ 0x2095, { 0xfffd } },
+{ 0x2096, { 0xfffd } },
+{ 0x2097, { 0xfffd } },
+{ 0x2098, { 0xfffd } },
+{ 0x2099, { 0xfffd } },
+{ 0x209a, { 0xfffd } },
+{ 0x209b, { 0xfffd } },
+{ 0x209c, { 0xfffd } },
+{ 0x209d, { 0xfffd } },
+{ 0x209e, { 0xfffd } },
+{ 0x209f, { 0xfffd } },
+{ 0x20a0, { 0x20a0 } },
+{ 0x20a1, { 0x20a1 } },
+{ 0x20a2, { 0x20a2 } },
+{ 0x20a3, { 0x20a3 } },
+{ 0x20a4, { 0x20a4 } },
+{ 0x20a5, { 0x20a5 } },
+{ 0x20a6, { 0x20a6 } },
+{ 0x20a7, { 0x20a7 } },
+{ 0x20a8, { 0x20a8 } },
+{ 0x20a9, { 0x20a9 } },
+{ 0x20aa, { 0x20aa } },
+{ 0x20ab, { 0x20ab } },
+{ 0x20ac, { 0x20ac } },
+{ 0x20ad, { 0x20ad } },
+{ 0x20ae, { 0x20ae } },
+{ 0x20af, { 0x20af } },
+{ 0x20b0, { 0x20b0 } },
+{ 0x20b1, { 0x20b1 } },
+{ 0x20b2, { 0x20b2 } },
+{ 0x20b3, { 0x20b3 } },
+{ 0x20b4, { 0x20b4 } },
+{ 0x20b5, { 0x20b5 } },
+{ 0x20b6, { 0xfffd } },
+{ 0x20b7, { 0xfffd } },
+{ 0x20b8, { 0xfffd } },
+{ 0x20b9, { 0xfffd } },
+{ 0x20ba, { 0xfffd } },
+{ 0x20bb, { 0xfffd } },
+{ 0x20bc, { 0xfffd } },
+{ 0x20bd, { 0xfffd } },
+{ 0x20be, { 0xfffd } },
+{ 0x20bf, { 0xfffd } },
+{ 0x20c0, { 0xfffd } },
+{ 0x20c1, { 0xfffd } },
+{ 0x20c2, { 0xfffd } },
+{ 0x20c3, { 0xfffd } },
+{ 0x20c4, { 0xfffd } },
+{ 0x20c5, { 0xfffd } },
+{ 0x20c6, { 0xfffd } },
+{ 0x20c7, { 0xfffd } },
+{ 0x20c8, { 0xfffd } },
+{ 0x20c9, { 0xfffd } },
+{ 0x20ca, { 0xfffd } },
+{ 0x20cb, { 0xfffd } },
+{ 0x20cc, { 0xfffd } },
+{ 0x20cd, { 0xfffd } },
+{ 0x20ce, { 0xfffd } },
+{ 0x20cf, { 0xfffd } },
+{ 0x20d0, { 0xffff } },
+{ 0x20d1, { 0xffff } },
+{ 0x20d2, { 0xffff } },
+{ 0x20d3, { 0xffff } },
+{ 0x20d4, { 0xffff } },
+{ 0x20d5, { 0xffff } },
+{ 0x20d6, { 0xffff } },
+{ 0x20d7, { 0xffff } },
+{ 0x20d8, { 0xffff } },
+{ 0x20d9, { 0xffff } },
+{ 0x20da, { 0xffff } },
+{ 0x20db, { 0xffff } },
+{ 0x20dc, { 0xffff } },
+{ 0x20dd, { 0xffff } },
+{ 0x20de, { 0xffff } },
+{ 0x20df, { 0xffff } },
+{ 0x20e0, { 0xffff } },
+{ 0x20e1, { 0xffff } },
+{ 0x20e2, { 0xffff } },
+{ 0x20e3, { 0xffff } },
+{ 0x20e4, { 0xffff } },
+{ 0x20e5, { 0xffff } },
+{ 0x20e6, { 0xffff } },
+{ 0x20e7, { 0xffff } },
+{ 0x20e8, { 0xffff } },
+{ 0x20e9, { 0xffff } },
+{ 0x20ea, { 0xffff } },
+{ 0x20eb, { 0xffff } },
+{ 0x20ec, { 0xffff } },
+{ 0x20ed, { 0xffff } },
+{ 0x20ee, { 0xffff } },
+{ 0x20ef, { 0xffff } },
+{ 0x20f0, { 0xffff } },
+{ 0x20f1, { 0xfffd } },
+{ 0x20f2, { 0xfffd } },
+{ 0x20f3, { 0xfffd } },
+{ 0x20f4, { 0xfffd } },
+{ 0x20f5, { 0xfffd } },
+{ 0x20f6, { 0xfffd } },
+{ 0x20f7, { 0xfffd } },
+{ 0x20f8, { 0xfffd } },
+{ 0x20f9, { 0xfffd } },
+{ 0x20fa, { 0xfffd } },
+{ 0x20fb, { 0xfffd } },
+{ 0x20fc, { 0xfffd } },
+{ 0x20fd, { 0xfffd } },
+{ 0x20fe, { 0xfffd } },
+{ 0x20ff, { 0xfffd } },
+{ 0x2c00, { 0x2c00 } },
+{ 0x2c01, { 0x2c01 } },
+{ 0x2c02, { 0x2c02 } },
+{ 0x2c03, { 0x2c03 } },
+{ 0x2c04, { 0x2c04 } },
+{ 0x2c05, { 0x2c05 } },
+{ 0x2c06, { 0x2c06 } },
+{ 0x2c07, { 0x2c07 } },
+{ 0x2c08, { 0x2c08 } },
+{ 0x2c09, { 0x2c09 } },
+{ 0x2c0a, { 0x2c0a } },
+{ 0x2c0b, { 0x2c0b } },
+{ 0x2c0c, { 0x2c0c } },
+{ 0x2c0d, { 0x2c0d } },
+{ 0x2c0e, { 0x2c0e } },
+{ 0x2c0f, { 0x2c0f } },
+{ 0x2c10, { 0x2c10 } },
+{ 0x2c11, { 0x2c11 } },
+{ 0x2c12, { 0x2c12 } },
+{ 0x2c13, { 0x2c13 } },
+{ 0x2c14, { 0x2c14 } },
+{ 0x2c15, { 0x2c15 } },
+{ 0x2c16, { 0x2c16 } },
+{ 0x2c17, { 0x2c17 } },
+{ 0x2c18, { 0x2c18 } },
+{ 0x2c19, { 0x2c19 } },
+{ 0x2c1a, { 0x2c1a } },
+{ 0x2c1b, { 0x2c1b } },
+{ 0x2c1c, { 0x2c1c } },
+{ 0x2c1d, { 0x2c1d } },
+{ 0x2c1e, { 0x2c1e } },
+{ 0x2c1f, { 0x2c1f } },
+{ 0x2c20, { 0x2c20 } },
+{ 0x2c21, { 0x2c21 } },
+{ 0x2c22, { 0x2c22 } },
+{ 0x2c23, { 0x2c23 } },
+{ 0x2c24, { 0x2c24 } },
+{ 0x2c25, { 0x2c25 } },
+{ 0x2c26, { 0x2c26 } },
+{ 0x2c27, { 0x2c27 } },
+{ 0x2c28, { 0x2c28 } },
+{ 0x2c29, { 0x2c29 } },
+{ 0x2c2a, { 0x2c2a } },
+{ 0x2c2b, { 0x2c2b } },
+{ 0x2c2c, { 0x2c2c } },
+{ 0x2c2d, { 0x2c2d } },
+{ 0x2c2e, { 0x2c2e } },
+{ 0x2c2f, { 0xfffd } },
+{ 0x2c30, { 0x2c00 } },
+{ 0x2c31, { 0x2c01 } },
+{ 0x2c32, { 0x2c02 } },
+{ 0x2c33, { 0x2c03 } },
+{ 0x2c34, { 0x2c04 } },
+{ 0x2c35, { 0x2c05 } },
+{ 0x2c36, { 0x2c06 } },
+{ 0x2c37, { 0x2c07 } },
+{ 0x2c38, { 0x2c08 } },
+{ 0x2c39, { 0x2c09 } },
+{ 0x2c3a, { 0x2c0a } },
+{ 0x2c3b, { 0x2c0b } },
+{ 0x2c3c, { 0x2c0c } },
+{ 0x2c3d, { 0x2c0d } },
+{ 0x2c3e, { 0x2c0e } },
+{ 0x2c3f, { 0x2c0f } },
+{ 0x2c40, { 0x2c10 } },
+{ 0x2c41, { 0x2c11 } },
+{ 0x2c42, { 0x2c12 } },
+{ 0x2c43, { 0x2c13 } },
+{ 0x2c44, { 0x2c14 } },
+{ 0x2c45, { 0x2c15 } },
+{ 0x2c46, { 0x2c16 } },
+{ 0x2c47, { 0x2c17 } },
+{ 0x2c48, { 0x2c18 } },
+{ 0x2c49, { 0x2c19 } },
+{ 0x2c4a, { 0x2c1a } },
+{ 0x2c4b, { 0x2c1b } },
+{ 0x2c4c, { 0x2c1c } },
+{ 0x2c4d, { 0x2c1d } },
+{ 0x2c4e, { 0x2c1e } },
+{ 0x2c4f, { 0x2c1f } },
+{ 0x2c50, { 0x2c20 } },
+{ 0x2c51, { 0x2c21 } },
+{ 0x2c52, { 0x2c22 } },
+{ 0x2c53, { 0x2c23 } },
+{ 0x2c54, { 0x2c24 } },
+{ 0x2c55, { 0x2c25 } },
+{ 0x2c56, { 0x2c26 } },
+{ 0x2c57, { 0x2c27 } },
+{ 0x2c58, { 0x2c28 } },
+{ 0x2c59, { 0x2c29 } },
+{ 0x2c5a, { 0x2c2a } },
+{ 0x2c5b, { 0x2c2b } },
+{ 0x2c5c, { 0x2c2c } },
+{ 0x2c5d, { 0x2c2d } },
+{ 0x2c5e, { 0x2c2e } },
+{ 0x2c5f, { 0xfffd } },
+{ 0x2c60, { 0x2c60 } },
+{ 0x2c61, { 0x2c60 } },
+{ 0x2c62, { 0x2c62 } },
+{ 0x2c63, { 0x2c63 } },
+{ 0x2c64, { 0x2c64 } },
+{ 0x2c65, { 0x023a } },
+{ 0x2c66, { 0x023e } },
+{ 0x2c67, { 0x2c67 } },
+{ 0x2c68, { 0x2c67 } },
+{ 0x2c69, { 0x2c69 } },
+{ 0x2c6a, { 0x2c69 } },
+{ 0x2c6b, { 0x2c6b } },
+{ 0x2c6c, { 0x2c6b } },
+{ 0x2c6d, { 0x2c6d } },
+{ 0x2c6e, { 0x2c6e } },
+{ 0x2c6f, { 0x2c6f } },
+{ 0x2c70, { 0xfffd } },
+{ 0x2c71, { 0x2c71 } },
+{ 0x2c72, { 0x2c72 } },
+{ 0x2c73, { 0x2c72 } },
+{ 0x2c74, { 0x2c74 } },
+{ 0x2c75, { 0x2c75 } },
+{ 0x2c76, { 0x2c75 } },
+{ 0x2c77, { 0x2c77 } },
+{ 0x2c78, { 0x2c78 } },
+{ 0x2c79, { 0x2c79 } },
+{ 0x2c7a, { 0x2c7a } },
+{ 0x2c7b, { 0x2c7b } },
+{ 0x2c7c, { 0x006a } },
+{ 0x2c7d, { 0x0056 } },
+{ 0x2c7e, { 0xfffd } },
+{ 0x2c7f, { 0xfffd } },
+{ 0x2c80, { 0x2c80 } },
+{ 0x2c81, { 0x2c80 } },
+{ 0x2c82, { 0x2c82 } },
+{ 0x2c83, { 0x2c82 } },
+{ 0x2c84, { 0x2c84 } },
+{ 0x2c85, { 0x2c84 } },
+{ 0x2c86, { 0x2c86 } },
+{ 0x2c87, { 0x2c86 } },
+{ 0x2c88, { 0x2c88 } },
+{ 0x2c89, { 0x2c88 } },
+{ 0x2c8a, { 0x2c8a } },
+{ 0x2c8b, { 0x2c8a } },
+{ 0x2c8c, { 0x2c8c } },
+{ 0x2c8d, { 0x2c8c } },
+{ 0x2c8e, { 0x2c8e } },
+{ 0x2c8f, { 0x2c8e } },
+{ 0x2c90, { 0x2c90 } },
+{ 0x2c91, { 0x2c90 } },
+{ 0x2c92, { 0x2c92 } },
+{ 0x2c93, { 0x2c92 } },
+{ 0x2c94, { 0x2c94 } },
+{ 0x2c95, { 0x2c94 } },
+{ 0x2c96, { 0x2c96 } },
+{ 0x2c97, { 0x2c96 } },
+{ 0x2c98, { 0x2c98 } },
+{ 0x2c99, { 0x2c98 } },
+{ 0x2c9a, { 0x2c9a } },
+{ 0x2c9b, { 0x2c9a } },
+{ 0x2c9c, { 0x2c9c } },
+{ 0x2c9d, { 0x2c9c } },
+{ 0x2c9e, { 0x2c9e } },
+{ 0x2c9f, { 0x2c9e } },
+{ 0x2ca0, { 0x2ca0 } },
+{ 0x2ca1, { 0x2ca0 } },
+{ 0x2ca2, { 0x2ca2 } },
+{ 0x2ca3, { 0x2ca2 } },
+{ 0x2ca4, { 0x2ca4 } },
+{ 0x2ca5, { 0x2ca4 } },
+{ 0x2ca6, { 0x2ca6 } },
+{ 0x2ca7, { 0x2ca6 } },
+{ 0x2ca8, { 0x2ca8 } },
+{ 0x2ca9, { 0x2ca8 } },
+{ 0x2caa, { 0x2caa } },
+{ 0x2cab, { 0x2caa } },
+{ 0x2cac, { 0x2cac } },
+{ 0x2cad, { 0x2cac } },
+{ 0x2cae, { 0x2cae } },
+{ 0x2caf, { 0x2cae } },
+{ 0x2cb0, { 0x2cb0 } },
+{ 0x2cb1, { 0x2cb0 } },
+{ 0x2cb2, { 0x2cb2 } },
+{ 0x2cb3, { 0x2cb2 } },
+{ 0x2cb4, { 0x2cb4 } },
+{ 0x2cb5, { 0x2cb4 } },
+{ 0x2cb6, { 0x2cb6 } },
+{ 0x2cb7, { 0x2cb6 } },
+{ 0x2cb8, { 0x2cb8 } },
+{ 0x2cb9, { 0x2cb8 } },
+{ 0x2cba, { 0x2cba } },
+{ 0x2cbb, { 0x2cba } },
+{ 0x2cbc, { 0x2cbc } },
+{ 0x2cbd, { 0x2cbc } },
+{ 0x2cbe, { 0x2cbe } },
+{ 0x2cbf, { 0x2cbe } },
+{ 0x2cc0, { 0x2cc0 } },
+{ 0x2cc1, { 0x2cc0 } },
+{ 0x2cc2, { 0x2cc2 } },
+{ 0x2cc3, { 0x2cc2 } },
+{ 0x2cc4, { 0x2cc4 } },
+{ 0x2cc5, { 0x2cc4 } },
+{ 0x2cc6, { 0x2cc6 } },
+{ 0x2cc7, { 0x2cc6 } },
+{ 0x2cc8, { 0x2cc8 } },
+{ 0x2cc9, { 0x2cc8 } },
+{ 0x2cca, { 0x2cca } },
+{ 0x2ccb, { 0x2cca } },
+{ 0x2ccc, { 0x2ccc } },
+{ 0x2ccd, { 0x2ccc } },
+{ 0x2cce, { 0x2cce } },
+{ 0x2ccf, { 0x2cce } },
+{ 0x2cd0, { 0x2cd0 } },
+{ 0x2cd1, { 0x2cd0 } },
+{ 0x2cd2, { 0x2cd2 } },
+{ 0x2cd3, { 0x2cd2 } },
+{ 0x2cd4, { 0x2cd4 } },
+{ 0x2cd5, { 0x2cd4 } },
+{ 0x2cd6, { 0x2cd6 } },
+{ 0x2cd7, { 0x2cd6 } },
+{ 0x2cd8, { 0x2cd8 } },
+{ 0x2cd9, { 0x2cd8 } },
+{ 0x2cda, { 0x2cda } },
+{ 0x2cdb, { 0x2cda } },
+{ 0x2cdc, { 0x2cdc } },
+{ 0x2cdd, { 0x2cdc } },
+{ 0x2cde, { 0x2cde } },
+{ 0x2cdf, { 0x2cde } },
+{ 0x2ce0, { 0x2ce0 } },
+{ 0x2ce1, { 0x2ce0 } },
+{ 0x2ce2, { 0x2ce2 } },
+{ 0x2ce3, { 0x2ce2 } },
+{ 0x2ce4, { 0x2ce4 } },
+{ 0x2ce5, { 0x2ce5 } },
+{ 0x2ce6, { 0x2ce6 } },
+{ 0x2ce7, { 0x2ce7 } },
+{ 0x2ce8, { 0x2ce8 } },
+{ 0x2ce9, { 0x2ce9 } },
+{ 0x2cea, { 0x2cea } },
+{ 0x2ceb, { 0xfffd } },
+{ 0x2cec, { 0xfffd } },
+{ 0x2ced, { 0xfffd } },
+{ 0x2cee, { 0xfffd } },
+{ 0x2cef, { 0xfffd } },
+{ 0x2cf0, { 0xfffd } },
+{ 0x2cf1, { 0xfffd } },
+{ 0x2cf2, { 0xfffd } },
+{ 0x2cf3, { 0xfffd } },
+{ 0x2cf4, { 0xfffd } },
+{ 0x2cf5, { 0xfffd } },
+{ 0x2cf6, { 0xfffd } },
+{ 0x2cf7, { 0xfffd } },
+{ 0x2cf8, { 0xfffd } },
+{ 0x2cf9, { 0x2cf9 } },
+{ 0x2cfa, { 0x2cfa } },
+{ 0x2cfb, { 0x2cfb } },
+{ 0x2cfc, { 0x2cfc } },
+{ 0x2cfd, { 0x0031, 0x002f, 0x0032 } },
+{ 0x2cfe, { 0x2cfe } },
+{ 0x2cff, { 0x2cff } },
+{ 0x3000, { 0x0020 } },
+{ 0x3001, { 0x3001 } },
+{ 0x3002, { 0x3002 } },
+{ 0x3003, { 0x3003 } },
+{ 0x3004, { 0x3004 } },
+{ 0x3005, { 0x3005 } },
+{ 0x3006, { 0x3006 } },
+{ 0x3007, { 0x3007 } },
+{ 0x3008, { 0x3008 } },
+{ 0x3009, { 0x3009 } },
+{ 0x300a, { 0x300a } },
+{ 0x300b, { 0x300b } },
+{ 0x300c, { 0x300c } },
+{ 0x300d, { 0x300d } },
+{ 0x300e, { 0x300e } },
+{ 0x300f, { 0x300f } },
+{ 0x3010, { 0x3010 } },
+{ 0x3011, { 0x3011 } },
+{ 0x3012, { 0x3012 } },
+{ 0x3013, { 0x3013 } },
+{ 0x3014, { 0x3014 } },
+{ 0x3015, { 0x3015 } },
+{ 0x3016, { 0x3016 } },
+{ 0x3017, { 0x3017 } },
+{ 0x3018, { 0x3018 } },
+{ 0x3019, { 0x3019 } },
+{ 0x301a, { 0x301a } },
+{ 0x301b, { 0x301b } },
+{ 0x301c, { 0x301c } },
+{ 0x301d, { 0x301d } },
+{ 0x301e, { 0x301e } },
+{ 0x301f, { 0x301f } },
+{ 0x3020, { 0x3020 } },
+{ 0x3021, { 0x3021 } },
+{ 0x3022, { 0x3022 } },
+{ 0x3023, { 0x3023 } },
+{ 0x3024, { 0x3024 } },
+{ 0x3025, { 0x3025 } },
+{ 0x3026, { 0x3026 } },
+{ 0x3027, { 0x3027 } },
+{ 0x3028, { 0x3028 } },
+{ 0x3029, { 0x3029 } },
+{ 0x302a, { 0xffff } },
+{ 0x302b, { 0xffff } },
+{ 0x302c, { 0xffff } },
+{ 0x302d, { 0xffff } },
+{ 0x302e, { 0xffff } },
+{ 0x302f, { 0xffff } },
+{ 0x3030, { 0x3030 } },
+{ 0x3031, { 0x3031 } },
+{ 0x3032, { 0x3032 } },
+{ 0x3033, { 0x3033 } },
+{ 0x3034, { 0x3034 } },
+{ 0x3035, { 0x3035 } },
+{ 0x3036, { 0x3036 } },
+{ 0x3037, { 0x3037 } },
+{ 0x3038, { 0x3038 } },
+{ 0x3039, { 0x3039 } },
+{ 0x303a, { 0x303a } },
+{ 0x303b, { 0x303b } },
+{ 0x303c, { 0x303c } },
+{ 0x303d, { 0x303d } },
+{ 0x303e, { 0x303e } },
+{ 0x303f, { 0x303f } },
+{ 0x3040, { 0xfffd } },
+{ 0x3041, { 0x30a2 } },
+{ 0x3042, { 0x30a2 } },
+{ 0x3043, { 0x30a4 } },
+{ 0x3044, { 0x30a4 } },
+{ 0x3045, { 0x30a6 } },
+{ 0x3046, { 0x30a6 } },
+{ 0x3047, { 0x30a8 } },
+{ 0x3048, { 0x30a8 } },
+{ 0x3049, { 0x30aa } },
+{ 0x304a, { 0x30aa } },
+{ 0x304b, { 0x30ab } },
+{ 0x304c, { 0x30ab } },
+{ 0x304d, { 0x30ad } },
+{ 0x304e, { 0x30ad } },
+{ 0x304f, { 0x30af } },
+{ 0x3050, { 0x30af } },
+{ 0x3051, { 0x30b1 } },
+{ 0x3052, { 0x30b1 } },
+{ 0x3053, { 0x30b3 } },
+{ 0x3054, { 0x30b3 } },
+{ 0x3055, { 0x30b5 } },
+{ 0x3056, { 0x30b5 } },
+{ 0x3057, { 0x30b7 } },
+{ 0x3058, { 0x30b7 } },
+{ 0x3059, { 0x30b9 } },
+{ 0x305a, { 0x30b9 } },
+{ 0x305b, { 0x30bb } },
+{ 0x305c, { 0x30bb } },
+{ 0x305d, { 0x30bd } },
+{ 0x305e, { 0x30bd } },
+{ 0x305f, { 0x30bf } },
+{ 0x3060, { 0x30bf } },
+{ 0x3061, { 0x30c1 } },
+{ 0x3062, { 0x30c1 } },
+{ 0x3063, { 0x30c4 } },
+{ 0x3064, { 0x30c4 } },
+{ 0x3065, { 0x30c4 } },
+{ 0x3066, { 0x30c6 } },
+{ 0x3067, { 0x30c6 } },
+{ 0x3068, { 0x30c8 } },
+{ 0x3069, { 0x30c8 } },
+{ 0x306a, { 0x30ca } },
+{ 0x306b, { 0x30cb } },
+{ 0x306c, { 0x30cc } },
+{ 0x306d, { 0x30cd } },
+{ 0x306e, { 0x30ce } },
+{ 0x306f, { 0x30cf } },
+{ 0x3070, { 0x30cf } },
+{ 0x3071, { 0x30cf } },
+{ 0x3072, { 0x30d2 } },
+{ 0x3073, { 0x30d2 } },
+{ 0x3074, { 0x30d2 } },
+{ 0x3075, { 0x30d5 } },
+{ 0x3076, { 0x30d5 } },
+{ 0x3077, { 0x30d5 } },
+{ 0x3078, { 0x30d8 } },
+{ 0x3079, { 0x30d8 } },
+{ 0x307a, { 0x30d8 } },
+{ 0x307b, { 0x30db } },
+{ 0x307c, { 0x30db } },
+{ 0x307d, { 0x30db } },
+{ 0x307e, { 0x30de } },
+{ 0x307f, { 0x30df } },
+{ 0x3080, { 0x30e0 } },
+{ 0x3081, { 0x30e1 } },
+{ 0x3082, { 0x30e2 } },
+{ 0x3083, { 0x30e4 } },
+{ 0x3084, { 0x30e4 } },
+{ 0x3085, { 0x30e6 } },
+{ 0x3086, { 0x30e6 } },
+{ 0x3087, { 0x30e8 } },
+{ 0x3088, { 0x30e8 } },
+{ 0x3089, { 0x30e9 } },
+{ 0x308a, { 0x30ea } },
+{ 0x308b, { 0x30eb } },
+{ 0x308c, { 0x30ec } },
+{ 0x308d, { 0x30ed } },
+{ 0x308e, { 0x30ef } },
+{ 0x308f, { 0x30ef } },
+{ 0x3090, { 0x30f0 } },
+{ 0x3091, { 0x30f1 } },
+{ 0x3092, { 0x30f2 } },
+{ 0x3093, { 0x30f3 } },
+{ 0x3094, { 0x30a6 } },
+{ 0x3095, { 0x30ab } },
+{ 0x3096, { 0x30b1 } },
+{ 0x3097, { 0xfffd } },
+{ 0x3098, { 0xfffd } },
+{ 0x3099, { 0xffff } },
+{ 0x309a, { 0xffff } },
+{ 0x309b, { 0xffff } },
+{ 0x309c, { 0xffff } },
+{ 0x309d, { 0x30fd } },
+{ 0x309e, { 0x30fe } },
+{ 0x309f, { 0x3088, 0x308a } },
+{ 0x30a0, { 0x30a0 } },
+{ 0x30a1, { 0x30a2 } },
+{ 0x30a2, { 0x30a2 } },
+{ 0x30a3, { 0x30a4 } },
+{ 0x30a4, { 0x30a4 } },
+{ 0x30a5, { 0x30a6 } },
+{ 0x30a6, { 0x30a6 } },
+{ 0x30a7, { 0x30a8 } },
+{ 0x30a8, { 0x30a8 } },
+{ 0x30a9, { 0x30aa } },
+{ 0x30aa, { 0x30aa } },
+{ 0x30ab, { 0x30ab } },
+{ 0x30ac, { 0x30ab } },
+{ 0x30ad, { 0x30ad } },
+{ 0x30ae, { 0x30ad } },
+{ 0x30af, { 0x30af } },
+{ 0x30b0, { 0x30af } },
+{ 0x30b1, { 0x30b1 } },
+{ 0x30b2, { 0x30b1 } },
+{ 0x30b3, { 0x30b3 } },
+{ 0x30b4, { 0x30b3 } },
+{ 0x30b5, { 0x30b5 } },
+{ 0x30b6, { 0x30b5 } },
+{ 0x30b7, { 0x30b7 } },
+{ 0x30b8, { 0x30b7 } },
+{ 0x30b9, { 0x30b9 } },
+{ 0x30ba, { 0x30b9 } },
+{ 0x30bb, { 0x30bb } },
+{ 0x30bc, { 0x30bb } },
+{ 0x30bd, { 0x30bd } },
+{ 0x30be, { 0x30bd } },
+{ 0x30bf, { 0x30bf } },
+{ 0x30c0, { 0x30bf } },
+{ 0x30c1, { 0x30c1 } },
+{ 0x30c2, { 0x30c1 } },
+{ 0x30c3, { 0x30c4 } },
+{ 0x30c4, { 0x30c4 } },
+{ 0x30c5, { 0x30c4 } },
+{ 0x30c6, { 0x30c6 } },
+{ 0x30c7, { 0x30c6 } },
+{ 0x30c8, { 0x30c8 } },
+{ 0x30c9, { 0x30c8 } },
+{ 0x30ca, { 0x30ca } },
+{ 0x30cb, { 0x30cb } },
+{ 0x30cc, { 0x30cc } },
+{ 0x30cd, { 0x30cd } },
+{ 0x30ce, { 0x30ce } },
+{ 0x30cf, { 0x30cf } },
+{ 0x30d0, { 0x30cf } },
+{ 0x30d1, { 0x30cf } },
+{ 0x30d2, { 0x30d2 } },
+{ 0x30d3, { 0x30d2 } },
+{ 0x30d4, { 0x30d2 } },
+{ 0x30d5, { 0x30d5 } },
+{ 0x30d6, { 0x30d5 } },
+{ 0x30d7, { 0x30d5 } },
+{ 0x30d8, { 0x30d8 } },
+{ 0x30d9, { 0x30d8 } },
+{ 0x30da, { 0x30d8 } },
+{ 0x30db, { 0x30db } },
+{ 0x30dc, { 0x30db } },
+{ 0x30dd, { 0x30db } },
+{ 0x30de, { 0x30de } },
+{ 0x30df, { 0x30df } },
+{ 0x30e0, { 0x30e0 } },
+{ 0x30e1, { 0x30e1 } },
+{ 0x30e2, { 0x30e2 } },
+{ 0x30e3, { 0x30e4 } },
+{ 0x30e4, { 0x30e4 } },
+{ 0x30e5, { 0x30e6 } },
+{ 0x30e6, { 0x30e6 } },
+{ 0x30e7, { 0x30e8 } },
+{ 0x30e8, { 0x30e8 } },
+{ 0x30e9, { 0x30e9 } },
+{ 0x30ea, { 0x30ea } },
+{ 0x30eb, { 0x30eb } },
+{ 0x30ec, { 0x30ec } },
+{ 0x30ed, { 0x30ed } },
+{ 0x30ee, { 0x30ef } },
+{ 0x30ef, { 0x30ef } },
+{ 0x30f0, { 0x30f0 } },
+{ 0x30f1, { 0x30f1 } },
+{ 0x30f2, { 0x30f2 } },
+{ 0x30f3, { 0x30f3 } },
+{ 0x30f4, { 0x30a6 } },
+{ 0x30f5, { 0x30ab } },
+{ 0x30f6, { 0x30b1 } },
+{ 0x30f7, { 0x30ef } },
+{ 0x30f8, { 0x30f0 } },
+{ 0x30f9, { 0x30f1 } },
+{ 0x30fa, { 0x30f2 } },
+{ 0x30fb, { 0x00b7 } },
+{ 0x30fc, { 0xffff } },
+{ 0x30fd, { 0x30fd } },
+{ 0x30fe, { 0x30fe } },
+{ 0x30ff, { 0x30b3, 0x30c8 } },
+{ 0xa600, { 0xfffd } },
+{ 0xa601, { 0xfffd } },
+{ 0xa602, { 0xfffd } },
+{ 0xa603, { 0xfffd } },
+{ 0xa604, { 0xfffd } },
+{ 0xa605, { 0xfffd } },
+{ 0xa606, { 0xfffd } },
+{ 0xa607, { 0xfffd } },
+{ 0xa608, { 0xfffd } },
+{ 0xa609, { 0xfffd } },
+{ 0xa60a, { 0xfffd } },
+{ 0xa60b, { 0xfffd } },
+{ 0xa60c, { 0xfffd } },
+{ 0xa60d, { 0xfffd } },
+{ 0xa60e, { 0xfffd } },
+{ 0xa60f, { 0xfffd } },
+{ 0xa610, { 0xfffd } },
+{ 0xa611, { 0xfffd } },
+{ 0xa612, { 0xfffd } },
+{ 0xa613, { 0xfffd } },
+{ 0xa614, { 0xfffd } },
+{ 0xa615, { 0xfffd } },
+{ 0xa616, { 0xfffd } },
+{ 0xa617, { 0xfffd } },
+{ 0xa618, { 0xfffd } },
+{ 0xa619, { 0xfffd } },
+{ 0xa61a, { 0xfffd } },
+{ 0xa61b, { 0xfffd } },
+{ 0xa61c, { 0xfffd } },
+{ 0xa61d, { 0xfffd } },
+{ 0xa61e, { 0xfffd } },
+{ 0xa61f, { 0xfffd } },
+{ 0xa620, { 0xfffd } },
+{ 0xa621, { 0xfffd } },
+{ 0xa622, { 0xfffd } },
+{ 0xa623, { 0xfffd } },
+{ 0xa624, { 0xfffd } },
+{ 0xa625, { 0xfffd } },
+{ 0xa626, { 0xfffd } },
+{ 0xa627, { 0xfffd } },
+{ 0xa628, { 0xfffd } },
+{ 0xa629, { 0xfffd } },
+{ 0xa62a, { 0xfffd } },
+{ 0xa62b, { 0xfffd } },
+{ 0xa62c, { 0xfffd } },
+{ 0xa62d, { 0xfffd } },
+{ 0xa62e, { 0xfffd } },
+{ 0xa62f, { 0xfffd } },
+{ 0xa630, { 0xfffd } },
+{ 0xa631, { 0xfffd } },
+{ 0xa632, { 0xfffd } },
+{ 0xa633, { 0xfffd } },
+{ 0xa634, { 0xfffd } },
+{ 0xa635, { 0xfffd } },
+{ 0xa636, { 0xfffd } },
+{ 0xa637, { 0xfffd } },
+{ 0xa638, { 0xfffd } },
+{ 0xa639, { 0xfffd } },
+{ 0xa63a, { 0xfffd } },
+{ 0xa63b, { 0xfffd } },
+{ 0xa63c, { 0xfffd } },
+{ 0xa63d, { 0xfffd } },
+{ 0xa63e, { 0xfffd } },
+{ 0xa63f, { 0xfffd } },
+{ 0xa640, { 0xa640 } },
+{ 0xa641, { 0xa640 } },
+{ 0xa642, { 0xa642 } },
+{ 0xa643, { 0xa642 } },
+{ 0xa644, { 0xa644 } },
+{ 0xa645, { 0xa644 } },
+{ 0xa646, { 0xa646 } },
+{ 0xa647, { 0xa646 } },
+{ 0xa648, { 0xa648 } },
+{ 0xa649, { 0xa648 } },
+{ 0xa64a, { 0xa64a } },
+{ 0xa64b, { 0xa64a } },
+{ 0xa64c, { 0xa64c } },
+{ 0xa64d, { 0xa64c } },
+{ 0xa64e, { 0xa64e } },
+{ 0xa64f, { 0xa64e } },
+{ 0xa650, { 0xa650 } },
+{ 0xa651, { 0xa650 } },
+{ 0xa652, { 0xa652 } },
+{ 0xa653, { 0xa652 } },
+{ 0xa654, { 0xa654 } },
+{ 0xa655, { 0xa654 } },
+{ 0xa656, { 0xa656 } },
+{ 0xa657, { 0xa656 } },
+{ 0xa658, { 0xa658 } },
+{ 0xa659, { 0xa658 } },
+{ 0xa65a, { 0xa65a } },
+{ 0xa65b, { 0xa65a } },
+{ 0xa65c, { 0xa65c } },
+{ 0xa65d, { 0xa65c } },
+{ 0xa65e, { 0xa65e } },
+{ 0xa65f, { 0xa65e } },
+{ 0xa660, { 0xfffd } },
+{ 0xa661, { 0xfffd } },
+{ 0xa662, { 0xa662 } },
+{ 0xa663, { 0xa662 } },
+{ 0xa664, { 0xa664 } },
+{ 0xa665, { 0xa664 } },
+{ 0xa666, { 0xa666 } },
+{ 0xa667, { 0xa666 } },
+{ 0xa668, { 0xa668 } },
+{ 0xa669, { 0xa668 } },
+{ 0xa66a, { 0xa66a } },
+{ 0xa66b, { 0xa66a } },
+{ 0xa66c, { 0xa66c } },
+{ 0xa66d, { 0xa66c } },
+{ 0xa66e, { 0xa66e } },
+{ 0xa66f, { 0xa66f } },
+{ 0xa670, { 0xa670 } },
+{ 0xa671, { 0xa671 } },
+{ 0xa672, { 0xa672 } },
+{ 0xa673, { 0xa673 } },
+{ 0xa674, { 0xfffd } },
+{ 0xa675, { 0xfffd } },
+{ 0xa676, { 0xfffd } },
+{ 0xa677, { 0xfffd } },
+{ 0xa678, { 0xfffd } },
+{ 0xa679, { 0xfffd } },
+{ 0xa67a, { 0xfffd } },
+{ 0xa67b, { 0xfffd } },
+{ 0xa67c, { 0xa67c } },
+{ 0xa67d, { 0xa67d } },
+{ 0xa67e, { 0xa67e } },
+{ 0xa67f, { 0xa67f } },
+{ 0xa680, { 0xa680 } },
+{ 0xa681, { 0xa680 } },
+{ 0xa682, { 0xa682 } },
+{ 0xa683, { 0xa682 } },
+{ 0xa684, { 0xa684 } },
+{ 0xa685, { 0xa684 } },
+{ 0xa686, { 0xa686 } },
+{ 0xa687, { 0xa686 } },
+{ 0xa688, { 0xa688 } },
+{ 0xa689, { 0xa688 } },
+{ 0xa68a, { 0xa68a } },
+{ 0xa68b, { 0xa68a } },
+{ 0xa68c, { 0xa68c } },
+{ 0xa68d, { 0xa68c } },
+{ 0xa68e, { 0xa68e } },
+{ 0xa68f, { 0xa68e } },
+{ 0xa690, { 0xa690 } },
+{ 0xa691, { 0xa690 } },
+{ 0xa692, { 0xa692 } },
+{ 0xa693, { 0xa692 } },
+{ 0xa694, { 0xa694 } },
+{ 0xa695, { 0xa694 } },
+{ 0xa696, { 0xa696 } },
+{ 0xa697, { 0xa696 } },
+{ 0xa698, { 0xfffd } },
+{ 0xa699, { 0xfffd } },
+{ 0xa69a, { 0xfffd } },
+{ 0xa69b, { 0xfffd } },
+{ 0xa69c, { 0xfffd } },
+{ 0xa69d, { 0xfffd } },
+{ 0xa69e, { 0xfffd } },
+{ 0xa69f, { 0xfffd } },
+{ 0xa6a0, { 0xfffd } },
+{ 0xa6a1, { 0xfffd } },
+{ 0xa6a2, { 0xfffd } },
+{ 0xa6a3, { 0xfffd } },
+{ 0xa6a4, { 0xfffd } },
+{ 0xa6a5, { 0xfffd } },
+{ 0xa6a6, { 0xfffd } },
+{ 0xa6a7, { 0xfffd } },
+{ 0xa6a8, { 0xfffd } },
+{ 0xa6a9, { 0xfffd } },
+{ 0xa6aa, { 0xfffd } },
+{ 0xa6ab, { 0xfffd } },
+{ 0xa6ac, { 0xfffd } },
+{ 0xa6ad, { 0xfffd } },
+{ 0xa6ae, { 0xfffd } },
+{ 0xa6af, { 0xfffd } },
+{ 0xa6b0, { 0xfffd } },
+{ 0xa6b1, { 0xfffd } },
+{ 0xa6b2, { 0xfffd } },
+{ 0xa6b3, { 0xfffd } },
+{ 0xa6b4, { 0xfffd } },
+{ 0xa6b5, { 0xfffd } },
+{ 0xa6b6, { 0xfffd } },
+{ 0xa6b7, { 0xfffd } },
+{ 0xa6b8, { 0xfffd } },
+{ 0xa6b9, { 0xfffd } },
+{ 0xa6ba, { 0xfffd } },
+{ 0xa6bb, { 0xfffd } },
+{ 0xa6bc, { 0xfffd } },
+{ 0xa6bd, { 0xfffd } },
+{ 0xa6be, { 0xfffd } },
+{ 0xa6bf, { 0xfffd } },
+{ 0xa6c0, { 0xfffd } },
+{ 0xa6c1, { 0xfffd } },
+{ 0xa6c2, { 0xfffd } },
+{ 0xa6c3, { 0xfffd } },
+{ 0xa6c4, { 0xfffd } },
+{ 0xa6c5, { 0xfffd } },
+{ 0xa6c6, { 0xfffd } },
+{ 0xa6c7, { 0xfffd } },
+{ 0xa6c8, { 0xfffd } },
+{ 0xa6c9, { 0xfffd } },
+{ 0xa6ca, { 0xfffd } },
+{ 0xa6cb, { 0xfffd } },
+{ 0xa6cc, { 0xfffd } },
+{ 0xa6cd, { 0xfffd } },
+{ 0xa6ce, { 0xfffd } },
+{ 0xa6cf, { 0xfffd } },
+{ 0xa6d0, { 0xfffd } },
+{ 0xa6d1, { 0xfffd } },
+{ 0xa6d2, { 0xfffd } },
+{ 0xa6d3, { 0xfffd } },
+{ 0xa6d4, { 0xfffd } },
+{ 0xa6d5, { 0xfffd } },
+{ 0xa6d6, { 0xfffd } },
+{ 0xa6d7, { 0xfffd } },
+{ 0xa6d8, { 0xfffd } },
+{ 0xa6d9, { 0xfffd } },
+{ 0xa6da, { 0xfffd } },
+{ 0xa6db, { 0xfffd } },
+{ 0xa6dc, { 0xfffd } },
+{ 0xa6dd, { 0xfffd } },
+{ 0xa6de, { 0xfffd } },
+{ 0xa6df, { 0xfffd } },
+{ 0xa6e0, { 0xfffd } },
+{ 0xa6e1, { 0xfffd } },
+{ 0xa6e2, { 0xfffd } },
+{ 0xa6e3, { 0xfffd } },
+{ 0xa6e4, { 0xfffd } },
+{ 0xa6e5, { 0xfffd } },
+{ 0xa6e6, { 0xfffd } },
+{ 0xa6e7, { 0xfffd } },
+{ 0xa6e8, { 0xfffd } },
+{ 0xa6e9, { 0xfffd } },
+{ 0xa6ea, { 0xfffd } },
+{ 0xa6eb, { 0xfffd } },
+{ 0xa6ec, { 0xfffd } },
+{ 0xa6ed, { 0xfffd } },
+{ 0xa6ee, { 0xfffd } },
+{ 0xa6ef, { 0xfffd } },
+{ 0xa6f0, { 0xfffd } },
+{ 0xa6f1, { 0xfffd } },
+{ 0xa6f2, { 0xfffd } },
+{ 0xa6f3, { 0xfffd } },
+{ 0xa6f4, { 0xfffd } },
+{ 0xa6f5, { 0xfffd } },
+{ 0xa6f6, { 0xfffd } },
+{ 0xa6f7, { 0xfffd } },
+{ 0xa6f8, { 0xfffd } },
+{ 0xa6f9, { 0xfffd } },
+{ 0xa6fa, { 0xfffd } },
+{ 0xa6fb, { 0xfffd } },
+{ 0xa6fc, { 0xfffd } },
+{ 0xa6fd, { 0xfffd } },
+{ 0xa6fe, { 0xfffd } },
+{ 0xa6ff, { 0xfffd } },
+{ 0xfb00, { 0x0046, 0x0046 } },
+{ 0xfb01, { 0x0046, 0x0049 } },
+{ 0xfb02, { 0x0046, 0x004c } },
+{ 0xfb03, { 0x0046, 0x0046, 0x0049 } },
+{ 0xfb04, { 0x0046, 0x0046, 0x004c } },
+{ 0xfb05, { 0x0053, 0x0054 } },
+{ 0xfb06, { 0x0053, 0x0054 } },
+{ 0xfb07, { 0xfffd } },
+{ 0xfb08, { 0xfffd } },
+{ 0xfb09, { 0xfffd } },
+{ 0xfb0a, { 0xfffd } },
+{ 0xfb0b, { 0xfffd } },
+{ 0xfb0c, { 0xfffd } },
+{ 0xfb0d, { 0xfffd } },
+{ 0xfb0e, { 0xfffd } },
+{ 0xfb0f, { 0xfffd } },
+{ 0xfb10, { 0xfffd } },
+{ 0xfb11, { 0xfffd } },
+{ 0xfb12, { 0xfffd } },
+{ 0xfb13, { 0x0544, 0x0546 } },
+{ 0xfb14, { 0x0544, 0x0546 } },
+{ 0xfb15, { 0x0544, 0x0535 } },
+{ 0xfb16, { 0x054e, 0x053b } },
+{ 0xfb17, { 0x0544, 0x053d } },
+{ 0xfb18, { 0xfffd } },
+{ 0xfb19, { 0xfffd } },
+{ 0xfb1a, { 0xfffd } },
+{ 0xfb1b, { 0xfffd } },
+{ 0xfb1c, { 0xfffd } },
+{ 0xfb1d, { 0x05d9 } },
+{ 0xfb1e, { 0xfb1e } },
+{ 0xfb1f, { 0x05f2 } },
+{ 0xfb20, { 0x05e2 } },
+{ 0xfb21, { 0x05d0 } },
+{ 0xfb22, { 0x05d3 } },
+{ 0xfb23, { 0x05d4 } },
+{ 0xfb24, { 0x05db } },
+{ 0xfb25, { 0x05dc } },
+{ 0xfb26, { 0x05dd } },
+{ 0xfb27, { 0x05e8 } },
+{ 0xfb28, { 0x05ea } },
+{ 0xfb29, { 0x002b } },
+{ 0xfb2a, { 0x05e9 } },
+{ 0xfb2b, { 0x05e9 } },
+{ 0xfb2c, { 0x05e9 } },
+{ 0xfb2d, { 0x05e9 } },
+{ 0xfb2e, { 0x05d0 } },
+{ 0xfb2f, { 0x05d0 } },
+{ 0xfb30, { 0x05d0 } },
+{ 0xfb31, { 0x05d1 } },
+{ 0xfb32, { 0x05d2 } },
+{ 0xfb33, { 0x05d3 } },
+{ 0xfb34, { 0x05d4 } },
+{ 0xfb35, { 0x05d5 } },
+{ 0xfb36, { 0x05d6 } },
+{ 0xfb37, { 0xfffd } },
+{ 0xfb38, { 0x05d8 } },
+{ 0xfb39, { 0x05d9 } },
+{ 0xfb3a, { 0x05da } },
+{ 0xfb3b, { 0x05db } },
+{ 0xfb3c, { 0x05dc } },
+{ 0xfb3d, { 0xfffd } },
+{ 0xfb3e, { 0x05de } },
+{ 0xfb3f, { 0xfffd } },
+{ 0xfb40, { 0x05e0 } },
+{ 0xfb41, { 0x05e1 } },
+{ 0xfb42, { 0xfffd } },
+{ 0xfb43, { 0x05e3 } },
+{ 0xfb44, { 0x05e4 } },
+{ 0xfb45, { 0xfffd } },
+{ 0xfb46, { 0x05e6 } },
+{ 0xfb47, { 0x05e7 } },
+{ 0xfb48, { 0x05e8 } },
+{ 0xfb49, { 0x05e9 } },
+{ 0xfb4a, { 0x05ea } },
+{ 0xfb4b, { 0x05d5 } },
+{ 0xfb4c, { 0x05d1 } },
+{ 0xfb4d, { 0x05db } },
+{ 0xfb4e, { 0x05e4 } },
+{ 0xfb4f, { 0x05d0 } },
+{ 0xfb50, { 0xfb50 } },
+{ 0xfb51, { 0xfb51 } },
+{ 0xfb52, { 0xfb52 } },
+{ 0xfb53, { 0xfb53 } },
+{ 0xfb54, { 0xfb54 } },
+{ 0xfb55, { 0xfb55 } },
+{ 0xfb56, { 0xfb56 } },
+{ 0xfb57, { 0xfb57 } },
+{ 0xfb58, { 0xfb58 } },
+{ 0xfb59, { 0xfb59 } },
+{ 0xfb5a, { 0xfb5a } },
+{ 0xfb5b, { 0xfb5b } },
+{ 0xfb5c, { 0xfb5c } },
+{ 0xfb5d, { 0xfb5d } },
+{ 0xfb5e, { 0xfb5e } },
+{ 0xfb5f, { 0xfb5f } },
+{ 0xfb60, { 0xfb60 } },
+{ 0xfb61, { 0xfb61 } },
+{ 0xfb62, { 0xfb62 } },
+{ 0xfb63, { 0xfb63 } },
+{ 0xfb64, { 0xfb64 } },
+{ 0xfb65, { 0xfb65 } },
+{ 0xfb66, { 0xfb66 } },
+{ 0xfb67, { 0xfb67 } },
+{ 0xfb68, { 0xfb68 } },
+{ 0xfb69, { 0xfb69 } },
+{ 0xfb6a, { 0xfb6a } },
+{ 0xfb6b, { 0xfb6b } },
+{ 0xfb6c, { 0xfb6c } },
+{ 0xfb6d, { 0xfb6d } },
+{ 0xfb6e, { 0xfb6e } },
+{ 0xfb6f, { 0xfb6f } },
+{ 0xfb70, { 0xfb70 } },
+{ 0xfb71, { 0xfb71 } },
+{ 0xfb72, { 0xfb72 } },
+{ 0xfb73, { 0xfb73 } },
+{ 0xfb74, { 0xfb74 } },
+{ 0xfb75, { 0xfb75 } },
+{ 0xfb76, { 0xfb76 } },
+{ 0xfb77, { 0xfb77 } },
+{ 0xfb78, { 0xfb78 } },
+{ 0xfb79, { 0xfb79 } },
+{ 0xfb7a, { 0xfb7a } },
+{ 0xfb7b, { 0xfb7b } },
+{ 0xfb7c, { 0xfb7c } },
+{ 0xfb7d, { 0xfb7d } },
+{ 0xfb7e, { 0xfb7e } },
+{ 0xfb7f, { 0xfb7f } },
+{ 0xfb80, { 0xfb80 } },
+{ 0xfb81, { 0xfb81 } },
+{ 0xfb82, { 0xfb82 } },
+{ 0xfb83, { 0xfb83 } },
+{ 0xfb84, { 0xfb84 } },
+{ 0xfb85, { 0xfb85 } },
+{ 0xfb86, { 0xfb86 } },
+{ 0xfb87, { 0xfb87 } },
+{ 0xfb88, { 0xfb88 } },
+{ 0xfb89, { 0xfb89 } },
+{ 0xfb8a, { 0xfb8a } },
+{ 0xfb8b, { 0xfb8b } },
+{ 0xfb8c, { 0xfb8c } },
+{ 0xfb8d, { 0xfb8d } },
+{ 0xfb8e, { 0xfb8e } },
+{ 0xfb8f, { 0xfb8f } },
+{ 0xfb90, { 0xfb90 } },
+{ 0xfb91, { 0xfb91 } },
+{ 0xfb92, { 0xfb92 } },
+{ 0xfb93, { 0xfb93 } },
+{ 0xfb94, { 0xfb94 } },
+{ 0xfb95, { 0xfb95 } },
+{ 0xfb96, { 0xfb96 } },
+{ 0xfb97, { 0xfb97 } },
+{ 0xfb98, { 0xfb98 } },
+{ 0xfb99, { 0xfb99 } },
+{ 0xfb9a, { 0xfb9a } },
+{ 0xfb9b, { 0xfb9b } },
+{ 0xfb9c, { 0xfb9c } },
+{ 0xfb9d, { 0xfb9d } },
+{ 0xfb9e, { 0xfb9e } },
+{ 0xfb9f, { 0xfb9f } },
+{ 0xfba0, { 0xfba0 } },
+{ 0xfba1, { 0xfba1 } },
+{ 0xfba2, { 0xfba2 } },
+{ 0xfba3, { 0xfba3 } },
+{ 0xfba4, { 0xfba4 } },
+{ 0xfba5, { 0xfba5 } },
+{ 0xfba6, { 0xfba6 } },
+{ 0xfba7, { 0xfba7 } },
+{ 0xfba8, { 0xfba8 } },
+{ 0xfba9, { 0xfba9 } },
+{ 0xfbaa, { 0xfbaa } },
+{ 0xfbab, { 0xfbab } },
+{ 0xfbac, { 0xfbac } },
+{ 0xfbad, { 0xfbad } },
+{ 0xfbae, { 0xfbae } },
+{ 0xfbaf, { 0xfbaf } },
+{ 0xfbb0, { 0xfbb0 } },
+{ 0xfbb1, { 0xfbb1 } },
+{ 0xfbb2, { 0xfffd } },
+{ 0xfbb3, { 0xfffd } },
+{ 0xfbb4, { 0xfffd } },
+{ 0xfbb5, { 0xfffd } },
+{ 0xfbb6, { 0xfffd } },
+{ 0xfbb7, { 0xfffd } },
+{ 0xfbb8, { 0xfffd } },
+{ 0xfbb9, { 0xfffd } },
+{ 0xfbba, { 0xfffd } },
+{ 0xfbbb, { 0xfffd } },
+{ 0xfbbc, { 0xfffd } },
+{ 0xfbbd, { 0xfffd } },
+{ 0xfbbe, { 0xfffd } },
+{ 0xfbbf, { 0xfffd } },
+{ 0xfbc0, { 0xfffd } },
+{ 0xfbc1, { 0xfffd } },
+{ 0xfbc2, { 0xfffd } },
+{ 0xfbc3, { 0xfffd } },
+{ 0xfbc4, { 0xfffd } },
+{ 0xfbc5, { 0xfffd } },
+{ 0xfbc6, { 0xfffd } },
+{ 0xfbc7, { 0xfffd } },
+{ 0xfbc8, { 0xfffd } },
+{ 0xfbc9, { 0xfffd } },
+{ 0xfbca, { 0xfffd } },
+{ 0xfbcb, { 0xfffd } },
+{ 0xfbcc, { 0xfffd } },
+{ 0xfbcd, { 0xfffd } },
+{ 0xfbce, { 0xfffd } },
+{ 0xfbcf, { 0xfffd } },
+{ 0xfbd0, { 0xfffd } },
+{ 0xfbd1, { 0xfffd } },
+{ 0xfbd2, { 0xfffd } },
+{ 0xfbd3, { 0xfbd3 } },
+{ 0xfbd4, { 0xfbd4 } },
+{ 0xfbd5, { 0xfbd5 } },
+{ 0xfbd6, { 0xfbd6 } },
+{ 0xfbd7, { 0xfbd7 } },
+{ 0xfbd8, { 0xfbd8 } },
+{ 0xfbd9, { 0xfbd9 } },
+{ 0xfbda, { 0xfbda } },
+{ 0xfbdb, { 0xfbdb } },
+{ 0xfbdc, { 0xfbdc } },
+{ 0xfbdd, { 0xfbdd } },
+{ 0xfbde, { 0xfbde } },
+{ 0xfbdf, { 0xfbdf } },
+{ 0xfbe0, { 0xfbe0 } },
+{ 0xfbe1, { 0xfbe1 } },
+{ 0xfbe2, { 0xfbe2 } },
+{ 0xfbe3, { 0xfbe3 } },
+{ 0xfbe4, { 0xfbe4 } },
+{ 0xfbe5, { 0xfbe5 } },
+{ 0xfbe6, { 0xfbe6 } },
+{ 0xfbe7, { 0xfbe7 } },
+{ 0xfbe8, { 0xfbe8 } },
+{ 0xfbe9, { 0xfbe9 } },
+{ 0xfbea, { 0xfbea } },
+{ 0xfbeb, { 0xfbeb } },
+{ 0xfbec, { 0xfbec } },
+{ 0xfbed, { 0xfbed } },
+{ 0xfbee, { 0xfbee } },
+{ 0xfbef, { 0xfbef } },
+{ 0xfbf0, { 0xfbf0 } },
+{ 0xfbf1, { 0xfbf1 } },
+{ 0xfbf2, { 0xfbf2 } },
+{ 0xfbf3, { 0xfbf3 } },
+{ 0xfbf4, { 0xfbf4 } },
+{ 0xfbf5, { 0xfbf5 } },
+{ 0xfbf6, { 0xfbf6 } },
+{ 0xfbf7, { 0xfbf7 } },
+{ 0xfbf8, { 0xfbf8 } },
+{ 0xfbf9, { 0xfbf9 } },
+{ 0xfbfa, { 0xfbfa } },
+{ 0xfbfb, { 0xfbfb } },
+{ 0xfbfc, { 0xfbfc } },
+{ 0xfbfd, { 0xfbfd } },
+{ 0xfbfe, { 0xfbfe } },
+{ 0xfbff, { 0xfbff } },
+{ 0xff00, { 0xfffd } },
+{ 0xff01, { 0x0021 } },
+{ 0xff02, { 0x0022 } },
+{ 0xff03, { 0x0023 } },
+{ 0xff04, { 0x0024 } },
+{ 0xff05, { 0x0025 } },
+{ 0xff06, { 0x0026 } },
+{ 0xff07, { 0x0027 } },
+{ 0xff08, { 0x0028 } },
+{ 0xff09, { 0x0029 } },
+{ 0xff0a, { 0x002a } },
+{ 0xff0b, { 0x002b } },
+{ 0xff0c, { 0x002c } },
+{ 0xff0d, { 0x002d } },
+{ 0xff0e, { 0x002e } },
+{ 0xff0f, { 0x002f } },
+{ 0xff10, { 0x0030 } },
+{ 0xff11, { 0x0031 } },
+{ 0xff12, { 0x0032 } },
+{ 0xff13, { 0x0033 } },
+{ 0xff14, { 0x0034 } },
+{ 0xff15, { 0x0035 } },
+{ 0xff16, { 0x0036 } },
+{ 0xff17, { 0x0037 } },
+{ 0xff18, { 0x0038 } },
+{ 0xff19, { 0x0039 } },
+{ 0xff1a, { 0x003a } },
+{ 0xff1b, { 0x003b } },
+{ 0xff1c, { 0x003c } },
+{ 0xff1d, { 0x003d } },
+{ 0xff1e, { 0x003e } },
+{ 0xff1f, { 0x003f } },
+{ 0xff20, { 0x0040 } },
+{ 0xff21, { 0x0041 } },
+{ 0xff22, { 0x0042 } },
+{ 0xff23, { 0x0043 } },
+{ 0xff24, { 0x0044 } },
+{ 0xff25, { 0x0045 } },
+{ 0xff26, { 0x0046 } },
+{ 0xff27, { 0x0047 } },
+{ 0xff28, { 0x0048 } },
+{ 0xff29, { 0x0049 } },
+{ 0xff2a, { 0x004a } },
+{ 0xff2b, { 0x004b } },
+{ 0xff2c, { 0x004c } },
+{ 0xff2d, { 0x004d } },
+{ 0xff2e, { 0x004e } },
+{ 0xff2f, { 0x004f } },
+{ 0xff30, { 0x0050 } },
+{ 0xff31, { 0x0051 } },
+{ 0xff32, { 0x0052 } },
+{ 0xff33, { 0x0053 } },
+{ 0xff34, { 0x0054 } },
+{ 0xff35, { 0x0055 } },
+{ 0xff36, { 0x0056 } },
+{ 0xff37, { 0x0057 } },
+{ 0xff38, { 0x0058 } },
+{ 0xff39, { 0x0059 } },
+{ 0xff3a, { 0x005a } },
+{ 0xff3b, { 0x005b } },
+{ 0xff3c, { 0x005c } },
+{ 0xff3d, { 0x005d } },
+{ 0xff3e, { 0x005e } },
+{ 0xff3f, { 0x005f } },
+{ 0xff40, { 0x0060 } },
+{ 0xff41, { 0x0041 } },
+{ 0xff42, { 0x0042 } },
+{ 0xff43, { 0x0043 } },
+{ 0xff44, { 0x0044 } },
+{ 0xff45, { 0x0045 } },
+{ 0xff46, { 0x0046 } },
+{ 0xff47, { 0x0047 } },
+{ 0xff48, { 0x0048 } },
+{ 0xff49, { 0x0049 } },
+{ 0xff4a, { 0x004a } },
+{ 0xff4b, { 0x004b } },
+{ 0xff4c, { 0x004c } },
+{ 0xff4d, { 0x004d } },
+{ 0xff4e, { 0x004e } },
+{ 0xff4f, { 0x004f } },
+{ 0xff50, { 0x0050 } },
+{ 0xff51, { 0x0051 } },
+{ 0xff52, { 0x0052 } },
+{ 0xff53, { 0x0053 } },
+{ 0xff54, { 0x0054 } },
+{ 0xff55, { 0x0055 } },
+{ 0xff56, { 0x0056 } },
+{ 0xff57, { 0x0057 } },
+{ 0xff58, { 0x0058 } },
+{ 0xff59, { 0x0059 } },
+{ 0xff5a, { 0x005a } },
+{ 0xff5b, { 0x007b } },
+{ 0xff5c, { 0x007c } },
+{ 0xff5d, { 0x007d } },
+{ 0xff5e, { 0x007e } },
+{ 0xff5f, { 0x2985 } },
+{ 0xff60, { 0x2986 } },
+{ 0xff61, { 0x3002 } },
+{ 0xff62, { 0x300c } },
+{ 0xff63, { 0x300d } },
+{ 0xff64, { 0x3001 } },
+{ 0xff65, { 0x30fb } },
+{ 0xff66, { 0x30f2 } },
+{ 0xff67, { 0x30a2 } },
+{ 0xff68, { 0x30a4 } },
+{ 0xff69, { 0x30a6 } },
+{ 0xff6a, { 0x30a8 } },
+{ 0xff6b, { 0x30aa } },
+{ 0xff6c, { 0x30e4 } },
+{ 0xff6d, { 0x30e6 } },
+{ 0xff6e, { 0x30e8 } },
+{ 0xff6f, { 0x30c4 } },
+{ 0xff70, { 0xffff } },
+{ 0xff71, { 0x30a2 } },
+{ 0xff72, { 0x30a4 } },
+{ 0xff73, { 0x30a6 } },
+{ 0xff74, { 0x30a8 } },
+{ 0xff75, { 0x30aa } },
+{ 0xff76, { 0x30ab } },
+{ 0xff77, { 0x30ad } },
+{ 0xff78, { 0x30af } },
+{ 0xff79, { 0x30b1 } },
+{ 0xff7a, { 0x30b3 } },
+{ 0xff7b, { 0x30b5 } },
+{ 0xff7c, { 0x30b7 } },
+{ 0xff7d, { 0x30b9 } },
+{ 0xff7e, { 0x30bb } },
+{ 0xff7f, { 0x30bd } },
+{ 0xff80, { 0x30bf } },
+{ 0xff81, { 0x30c1 } },
+{ 0xff82, { 0x30c4 } },
+{ 0xff83, { 0x30c6 } },
+{ 0xff84, { 0x30c8 } },
+{ 0xff85, { 0x30ca } },
+{ 0xff86, { 0x30cb } },
+{ 0xff87, { 0x30cc } },
+{ 0xff88, { 0x30cd } },
+{ 0xff89, { 0x30ce } },
+{ 0xff8a, { 0x30cf } },
+{ 0xff8b, { 0x30d2 } },
+{ 0xff8c, { 0x30d5 } },
+{ 0xff8d, { 0x30d8 } },
+{ 0xff8e, { 0x30db } },
+{ 0xff8f, { 0x30de } },
+{ 0xff90, { 0x30df } },
+{ 0xff91, { 0x30e0 } },
+{ 0xff92, { 0x30e1 } },
+{ 0xff93, { 0x30e2 } },
+{ 0xff94, { 0x30e4 } },
+{ 0xff95, { 0x30e6 } },
+{ 0xff96, { 0x30e8 } },
+{ 0xff97, { 0x30e9 } },
+{ 0xff98, { 0x30ea } },
+{ 0xff99, { 0x30eb } },
+{ 0xff9a, { 0x30ec } },
+{ 0xff9b, { 0x30ed } },
+{ 0xff9c, { 0x30ef } },
+{ 0xff9d, { 0x30f3 } },
+{ 0xff9e, { 0xffff } },
+{ 0xff9f, { 0xffff } },
+{ 0xffa0, { 0x3164 } },
+{ 0xffa1, { 0x3131 } },
+{ 0xffa2, { 0x3132 } },
+{ 0xffa3, { 0x3133 } },
+{ 0xffa4, { 0x3134 } },
+{ 0xffa5, { 0x3135 } },
+{ 0xffa6, { 0x3136 } },
+{ 0xffa7, { 0x3137 } },
+{ 0xffa8, { 0x3138 } },
+{ 0xffa9, { 0x3139 } },
+{ 0xffaa, { 0x313a } },
+{ 0xffab, { 0x313b } },
+{ 0xffac, { 0x313c } },
+{ 0xffad, { 0x313d } },
+{ 0xffae, { 0x313e } },
+{ 0xffaf, { 0x313f } },
+{ 0xffb0, { 0x3140 } },
+{ 0xffb1, { 0x3141 } },
+{ 0xffb2, { 0x3142 } },
+{ 0xffb3, { 0x3143 } },
+{ 0xffb4, { 0x3144 } },
+{ 0xffb5, { 0x3145 } },
+{ 0xffb6, { 0x3146 } },
+{ 0xffb7, { 0x3147 } },
+{ 0xffb8, { 0x3148 } },
+{ 0xffb9, { 0x3149 } },
+{ 0xffba, { 0x314a } },
+{ 0xffbb, { 0x314b } },
+{ 0xffbc, { 0x314c } },
+{ 0xffbd, { 0x314d } },
+{ 0xffbe, { 0x314e } },
+{ 0xffbf, { 0xfffd } },
+{ 0xffc0, { 0xfffd } },
+{ 0xffc1, { 0xfffd } },
+{ 0xffc2, { 0x314f } },
+{ 0xffc3, { 0x3150 } },
+{ 0xffc4, { 0x3151 } },
+{ 0xffc5, { 0x3152 } },
+{ 0xffc6, { 0x3153 } },
+{ 0xffc7, { 0x3154 } },
+{ 0xffc8, { 0xfffd } },
+{ 0xffc9, { 0xfffd } },
+{ 0xffca, { 0x3155 } },
+{ 0xffcb, { 0x3156 } },
+{ 0xffcc, { 0x3157 } },
+{ 0xffcd, { 0x3158 } },
+{ 0xffce, { 0x3159 } },
+{ 0xffcf, { 0x315a } },
+{ 0xffd0, { 0xfffd } },
+{ 0xffd1, { 0xfffd } },
+{ 0xffd2, { 0x315b } },
+{ 0xffd3, { 0x315c } },
+{ 0xffd4, { 0x315d } },
+{ 0xffd5, { 0x315e } },
+{ 0xffd6, { 0x315f } },
+{ 0xffd7, { 0x3160 } },
+{ 0xffd8, { 0xfffd } },
+{ 0xffd9, { 0xfffd } },
+{ 0xffda, { 0x3161 } },
+{ 0xffdb, { 0x3162 } },
+{ 0xffdc, { 0x3163 } },
+{ 0xffdd, { 0xfffd } },
+{ 0xffde, { 0xfffd } },
+{ 0xffdf, { 0xfffd } },
+{ 0xffe0, { 0x00a2 } },
+{ 0xffe1, { 0x00a3 } },
+{ 0xffe2, { 0x00ac } },
+{ 0xffe3, { 0x00af } },
+{ 0xffe4, { 0x00a6 } },
+{ 0xffe5, { 0x00a5 } },
+{ 0xffe6, { 0x20a9 } },
+{ 0xffe7, { 0xfffd } },
+{ 0xffe8, { 0x2502 } },
+{ 0xffe9, { 0x2190 } },
+{ 0xffea, { 0x2191 } },
+{ 0xffeb, { 0x2192 } },
+{ 0xffec, { 0x2193 } },
+{ 0xffed, { 0x25a0 } },
+{ 0xffee, { 0x25cb } },
+{ 0xffef, { 0xfffd } },
+{ 0xfff0, { 0xfffd } },
+{ 0xfff1, { 0xfffd } },
+{ 0xfff2, { 0xfffd } },
+{ 0xfff3, { 0xfffd } },
+{ 0xfff4, { 0xfffd } },
+{ 0xfff5, { 0xfffd } },
+{ 0xfff6, { 0xfffd } },
+{ 0xfff7, { 0xfffd } },
+{ 0xfff8, { 0xfffd } },
+{ 0xfff9, { 0xfff9 } },
+{ 0xfffa, { 0xfffa } },
+{ 0xfffb, { 0xfffb } },
+{ 0xfffc, { 0xfffc } },
+{ 0xfffd, { 0xfffd } },
+{ 0xfffe, { 0xfffd } },
+{ 0xffff, { 0xfffd } },
+};
+
+int get_common_mapping_table_size(void)
+{
+ return sizeof(common_mapping_table)/sizeof(struct mapping_data);
+}
+
+/*
+ * special mapping rule
+ */
+
+/* not delete diacritical mark
+ *
+ * mapping rule
+ * - lowercase, titlecase -> uppercase
+ * - Japanese Hiragana, halfwidth Katakana -> fullwidth Katakana
+ */
+const struct mapping_data with_diacritical_mark_character_table[] =
+{
+{ 0x00c0, { 0x00c0 } },
+{ 0x00c1, { 0x00c1 } },
+{ 0x00c2, { 0x00c2 } },
+{ 0x00c3, { 0x00c3 } },
+{ 0x00c4, { 0x00c4 } },
+{ 0x00c5, { 0x00c5 } },
+{ 0x00c7, { 0x0043 } },
+{ 0x00c8, { 0x0045 } },
+{ 0x00c9, { 0x0045 } },
+{ 0x00ca, { 0x0045 } },
+{ 0x00cb, { 0x0045 } },
+{ 0x00cc, { 0x00cc } },
+{ 0x00cd, { 0x00cd } },
+{ 0x00ce, { 0x00ce } },
+{ 0x00cf, { 0x00cf } },
+{ 0x00d1, { 0x00d1 } },
+{ 0x00d2, { 0x00d2 } },
+{ 0x00d3, { 0x00d3 } },
+{ 0x00d4, { 0x00d4 } },
+{ 0x00d5, { 0x00d5 } },
+{ 0x00d6, { 0x00d6 } },
+{ 0x00d9, { 0x00d9 } },
+{ 0x00da, { 0x00da } },
+{ 0x00db, { 0x00db } },
+{ 0x00dc, { 0x00dc } },
+{ 0x00dd, { 0x00dd } },
+{ 0x00e0, { 0x00c0 } },
+{ 0x00e1, { 0x00c1 } },
+{ 0x00e2, { 0x00c2 } },
+{ 0x00e3, { 0x00c3 } },
+{ 0x00e4, { 0x00c4 } },
+{ 0x00e5, { 0x00c5 } },
+{ 0x00e7, { 0x00c7 } },
+{ 0x00e8, { 0x00c8 } },
+{ 0x00e9, { 0x00c9 } },
+{ 0x00ea, { 0x00ca } },
+{ 0x00eb, { 0x00cb } },
+{ 0x00ec, { 0x00cc } },
+{ 0x00ed, { 0x00cd } },
+{ 0x00ee, { 0x00ce } },
+{ 0x00ef, { 0x00cf } },
+{ 0x00f1, { 0x00d1 } },
+{ 0x00f2, { 0x00d2 } },
+{ 0x00f3, { 0x00d3 } },
+{ 0x00f4, { 0x00d4 } },
+{ 0x00f5, { 0x00d5 } },
+{ 0x00f6, { 0x00d6 } },
+{ 0x00f9, { 0x00d9 } },
+{ 0x00fa, { 0x00da } },
+{ 0x00fb, { 0x00db } },
+{ 0x00fc, { 0x00dc } },
+{ 0x00fd, { 0x00dd } },
+{ 0x00ff, { 0x0178 } },
+{ 0x0100, { 0x0100 } },
+{ 0x0101, { 0x0100 } },
+{ 0x0102, { 0x0102 } },
+{ 0x0103, { 0x0102 } },
+{ 0x0104, { 0x0104 } },
+{ 0x0105, { 0x0104 } },
+{ 0x0106, { 0x0106 } },
+{ 0x0107, { 0x0106 } },
+{ 0x0108, { 0x0108 } },
+{ 0x0109, { 0x0108 } },
+{ 0x010a, { 0x010a } },
+{ 0x010b, { 0x010a } },
+{ 0x010c, { 0x010c } },
+{ 0x010d, { 0x010c } },
+{ 0x010e, { 0x010e } },
+{ 0x010f, { 0x010e } },
+{ 0x0112, { 0x0112 } },
+{ 0x0113, { 0x0112 } },
+{ 0x0114, { 0x0114 } },
+{ 0x0115, { 0x0114 } },
+{ 0x0116, { 0x0116 } },
+{ 0x0117, { 0x0116 } },
+{ 0x0118, { 0x0118 } },
+{ 0x0119, { 0x0118 } },
+{ 0x011a, { 0x011a } },
+{ 0x011b, { 0x011a } },
+{ 0x011c, { 0x011c } },
+{ 0x011d, { 0x011c } },
+{ 0x011e, { 0x011e } },
+{ 0x011f, { 0x011e } },
+{ 0x0120, { 0x0120 } },
+{ 0x0121, { 0x0120 } },
+{ 0x0122, { 0x0122 } },
+{ 0x0123, { 0x0122 } },
+{ 0x0124, { 0x0124 } },
+{ 0x0125, { 0x0124 } },
+{ 0x0128, { 0x0128 } },
+{ 0x0129, { 0x0128 } },
+{ 0x012a, { 0x012a } },
+{ 0x012b, { 0x012a } },
+{ 0x012c, { 0x012c } },
+{ 0x012d, { 0x012c } },
+{ 0x012e, { 0x012e } },
+{ 0x012f, { 0x012e } },
+{ 0x0130, { 0x0130 } },
+{ 0x0134, { 0x0134 } },
+{ 0x0135, { 0x0134 } },
+{ 0x0136, { 0x0136 } },
+{ 0x0137, { 0x0136 } },
+{ 0x0139, { 0x0139 } },
+{ 0x013a, { 0x0139 } },
+{ 0x013b, { 0x013b } },
+{ 0x013c, { 0x013b } },
+{ 0x013d, { 0x013d } },
+{ 0x013e, { 0x013d } },
+{ 0x0143, { 0x0143 } },
+{ 0x0144, { 0x0143 } },
+{ 0x0145, { 0x0145 } },
+{ 0x0146, { 0x0145 } },
+{ 0x0147, { 0x0147 } },
+{ 0x0148, { 0x0147 } },
+{ 0x014c, { 0x014c } },
+{ 0x014d, { 0x014c } },
+{ 0x014e, { 0x014e } },
+{ 0x014f, { 0x014e } },
+{ 0x0150, { 0x0150 } },
+{ 0x0151, { 0x0150 } },
+{ 0x0154, { 0x0154 } },
+{ 0x0155, { 0x0154 } },
+{ 0x0156, { 0x0156 } },
+{ 0x0157, { 0x0156 } },
+{ 0x0158, { 0x0158 } },
+{ 0x0159, { 0x0158 } },
+{ 0x015a, { 0x015a } },
+{ 0x015b, { 0x015a } },
+{ 0x015c, { 0x015c } },
+{ 0x015d, { 0x015c } },
+{ 0x015e, { 0x015e } },
+{ 0x015f, { 0x015e } },
+{ 0x0160, { 0x0160 } },
+{ 0x0161, { 0x0160 } },
+{ 0x0162, { 0x0162 } },
+{ 0x0163, { 0x0162 } },
+{ 0x0164, { 0x0164 } },
+{ 0x0165, { 0x0164 } },
+{ 0x0168, { 0x0168 } },
+{ 0x0169, { 0x0168 } },
+{ 0x016a, { 0x016a } },
+{ 0x016b, { 0x016a } },
+{ 0x016c, { 0x016c } },
+{ 0x016d, { 0x016c } },
+{ 0x016e, { 0x016e } },
+{ 0x016f, { 0x016e } },
+{ 0x0170, { 0x0170 } },
+{ 0x0171, { 0x0170 } },
+{ 0x0172, { 0x0172 } },
+{ 0x0173, { 0x0172 } },
+{ 0x0174, { 0x0174 } },
+{ 0x0175, { 0x0174 } },
+{ 0x0176, { 0x0176 } },
+{ 0x0177, { 0x0176 } },
+{ 0x0178, { 0x0178 } },
+{ 0x0179, { 0x0179 } },
+{ 0x017a, { 0x0179 } },
+{ 0x017b, { 0x017b } },
+{ 0x017c, { 0x017b } },
+{ 0x017d, { 0x017d } },
+{ 0x017e, { 0x017d } },
+{ 0x01a0, { 0x01a0 } },
+{ 0x01a1, { 0x01a0 } },
+{ 0x01af, { 0x01af } },
+{ 0x01b0, { 0x01af } },
+{ 0x01cd, { 0x01cd } },
+{ 0x01ce, { 0x01cd } },
+{ 0x01cf, { 0x01cf } },
+{ 0x01d0, { 0x01cf } },
+{ 0x01d1, { 0x01d1 } },
+{ 0x01d2, { 0x01d1 } },
+{ 0x01d3, { 0x01d3 } },
+{ 0x01d4, { 0x01d3 } },
+{ 0x01d5, { 0x01d5 } },
+{ 0x01d6, { 0x01d5 } },
+{ 0x01d7, { 0x01d7 } },
+{ 0x01d8, { 0x01d7 } },
+{ 0x01d9, { 0x01d9 } },
+{ 0x01da, { 0x01d9 } },
+{ 0x01db, { 0x01db } },
+{ 0x01dc, { 0x01db } },
+{ 0x01de, { 0x01de } },
+{ 0x01df, { 0x01de } },
+{ 0x01e0, { 0x01e0 } },
+{ 0x01e1, { 0x01e0 } },
+{ 0x01e2, { 0x01e2 } },
+{ 0x01e3, { 0x01e2 } },
+{ 0x01e4, { 0x01e4 } },
+{ 0x01e6, { 0x01e6 } },
+{ 0x01e7, { 0x01e6 } },
+{ 0x01e8, { 0x01e8 } },
+{ 0x01e9, { 0x01e8 } },
+{ 0x01ea, { 0x01ea } },
+{ 0x01eb, { 0x01ea } },
+{ 0x01ec, { 0x01ec } },
+{ 0x01ed, { 0x01ec } },
+{ 0x01ee, { 0x01ee } },
+{ 0x01ef, { 0x01ee } },
+{ 0x01f0, { 0x004a, 0x030c } },
+{ 0x01f4, { 0x01f4 } },
+{ 0x01f5, { 0x01f4 } },
+{ 0x01f8, { 0x01f8 } },
+{ 0x01f9, { 0x01f8 } },
+{ 0x01fa, { 0x01fa } },
+{ 0x01fb, { 0x01fa } },
+{ 0x01fc, { 0x01fc } },
+{ 0x01fd, { 0x01fc } },
+{ 0x01fe, { 0x01fe } },
+{ 0x01ff, { 0x01fe } },
+{ 0x0200, { 0x0200 } },
+{ 0x0201, { 0x0200 } },
+{ 0x0202, { 0x0202 } },
+{ 0x0203, { 0x0202 } },
+{ 0x0204, { 0x0204 } },
+{ 0x0205, { 0x0204 } },
+{ 0x0206, { 0x0206 } },
+{ 0x0207, { 0x0206 } },
+{ 0x0208, { 0x0208 } },
+{ 0x0209, { 0x0208 } },
+{ 0x020a, { 0x020a } },
+{ 0x020b, { 0x020a } },
+{ 0x020c, { 0x020c } },
+{ 0x020d, { 0x020c } },
+{ 0x020e, { 0x020e } },
+{ 0x020f, { 0x020e } },
+{ 0x0210, { 0x0210 } },
+{ 0x0211, { 0x0210 } },
+{ 0x0212, { 0x0212 } },
+{ 0x0213, { 0x0212 } },
+{ 0x0214, { 0x0214 } },
+{ 0x0215, { 0x0214 } },
+{ 0x0216, { 0x0216 } },
+{ 0x0217, { 0x0216 } },
+{ 0x0218, { 0x0218 } },
+{ 0x0219, { 0x0218 } },
+{ 0x021a, { 0x021a } },
+{ 0x021b, { 0x021a } },
+{ 0x021e, { 0x021e } },
+{ 0x021f, { 0x021e } },
+{ 0x0226, { 0x0226 } },
+{ 0x0227, { 0x0226 } },
+{ 0x0228, { 0x0228 } },
+{ 0x0229, { 0x0228 } },
+{ 0x022a, { 0x022a } },
+{ 0x022b, { 0x022a } },
+{ 0x022c, { 0x022c } },
+{ 0x022d, { 0x022c } },
+{ 0x022e, { 0x022e } },
+{ 0x022f, { 0x022e } },
+{ 0x0230, { 0x0230 } },
+{ 0x0231, { 0x0230 } },
+{ 0x0232, { 0x0232 } },
+{ 0x0233, { 0x0232 } },
+{ 0x0300, { 0x0300 } },
+{ 0x0301, { 0x0301 } },
+{ 0x0302, { 0x0302 } },
+{ 0x0303, { 0x0303 } },
+{ 0x0304, { 0x0304 } },
+{ 0x0305, { 0x0305 } },
+{ 0x0306, { 0x0306 } },
+{ 0x0307, { 0x0307 } },
+{ 0x0308, { 0x0308 } },
+{ 0x0309, { 0x0309 } },
+{ 0x030a, { 0x030a } },
+{ 0x030b, { 0x030b } },
+{ 0x030c, { 0x030c } },
+{ 0x030d, { 0x030d } },
+{ 0x030e, { 0x030e } },
+{ 0x030f, { 0x030f } },
+{ 0x0310, { 0x0310 } },
+{ 0x0311, { 0x0311 } },
+{ 0x0312, { 0x0312 } },
+{ 0x0313, { 0x0313 } },
+{ 0x0314, { 0x0314 } },
+{ 0x0315, { 0x0315 } },
+{ 0x0316, { 0x0316 } },
+{ 0x0317, { 0x0317 } },
+{ 0x0318, { 0x0318 } },
+{ 0x0319, { 0x0319 } },
+{ 0x031a, { 0x031a } },
+{ 0x031b, { 0x031b } },
+{ 0x031c, { 0x031c } },
+{ 0x031d, { 0x031d } },
+{ 0x031e, { 0x031e } },
+{ 0x031f, { 0x031f } },
+{ 0x0320, { 0x0320 } },
+{ 0x0321, { 0x0321 } },
+{ 0x0322, { 0x0322 } },
+{ 0x0323, { 0x0323 } },
+{ 0x0324, { 0x0324 } },
+{ 0x0325, { 0x0325 } },
+{ 0x0326, { 0x0326 } },
+{ 0x0327, { 0x0327 } },
+{ 0x0328, { 0x0328 } },
+{ 0x0329, { 0x0329 } },
+{ 0x032a, { 0x032a } },
+{ 0x032b, { 0x032b } },
+{ 0x032c, { 0x032c } },
+{ 0x032d, { 0x032d } },
+{ 0x032e, { 0x032e } },
+{ 0x032f, { 0x032f } },
+{ 0x0330, { 0x0330 } },
+{ 0x0331, { 0x0331 } },
+{ 0x0332, { 0x0332 } },
+{ 0x0333, { 0x0333 } },
+{ 0x0334, { 0x0334 } },
+{ 0x0335, { 0x0335 } },
+{ 0x0336, { 0x0336 } },
+{ 0x0337, { 0x0337 } },
+{ 0x0338, { 0x0338 } },
+{ 0x0339, { 0x0339 } },
+{ 0x033a, { 0x033a } },
+{ 0x033b, { 0x033b } },
+{ 0x033c, { 0x033c } },
+{ 0x033d, { 0x033d } },
+{ 0x033e, { 0x033e } },
+{ 0x033f, { 0x033f } },
+{ 0x0340, { 0x0340 } },
+{ 0x0341, { 0x0341 } },
+{ 0x0342, { 0x0342 } },
+{ 0x0343, { 0x0343 } },
+{ 0x0344, { 0x0344 } },
+{ 0x0345, { 0x0345 } },
+{ 0x0346, { 0x0346 } },
+{ 0x0347, { 0x0347 } },
+{ 0x0348, { 0x0348 } },
+{ 0x0349, { 0x0349 } },
+{ 0x034a, { 0x034a } },
+{ 0x034b, { 0x034b } },
+{ 0x034c, { 0x034c } },
+{ 0x034d, { 0x034d } },
+{ 0x034e, { 0x034e } },
+{ 0x034f, { 0x034f } },
+{ 0x0350, { 0x0350 } },
+{ 0x0351, { 0x0351 } },
+{ 0x0352, { 0x0352 } },
+{ 0x0353, { 0x0353 } },
+{ 0x0354, { 0x0354 } },
+{ 0x0355, { 0x0355 } },
+{ 0x0356, { 0x0356 } },
+{ 0x0357, { 0x0357 } },
+{ 0x0358, { 0x0358 } },
+{ 0x0359, { 0x0359 } },
+{ 0x035a, { 0x035a } },
+{ 0x035b, { 0x035b } },
+{ 0x035c, { 0x035c } },
+{ 0x035d, { 0x035d } },
+{ 0x035e, { 0x035e } },
+{ 0x035f, { 0x035f } },
+{ 0x0360, { 0x0360 } },
+{ 0x0361, { 0x0361 } },
+{ 0x0362, { 0x0362 } },
+{ 0x0363, { 0x0363 } },
+{ 0x0364, { 0x0364 } },
+{ 0x0365, { 0x0365 } },
+{ 0x0366, { 0x0366 } },
+{ 0x0367, { 0x0367 } },
+{ 0x0368, { 0x0368 } },
+{ 0x0369, { 0x0369 } },
+{ 0x036a, { 0x036a } },
+{ 0x036b, { 0x036b } },
+{ 0x036c, { 0x036c } },
+{ 0x036d, { 0x036d } },
+{ 0x036e, { 0x036e } },
+{ 0x036f, { 0x036f } },
+{ 0x0384, { 0x0384 } },
+{ 0x0385, { 0x0385 } },
+{ 0x0386, { 0x0386 } },
+{ 0x0388, { 0x0388 } },
+{ 0x0389, { 0x0389 } },
+{ 0x038a, { 0x038a } },
+{ 0x038c, { 0x038c } },
+{ 0x038e, { 0x038e } },
+{ 0x038f, { 0x038f } },
+{ 0x0390, { 0x0399, 0x0308, 0x0301 } },
+{ 0x03aa, { 0x03aa } },
+{ 0x03ab, { 0x03ab } },
+{ 0x03ac, { 0x0386 } },
+{ 0x03ad, { 0x0388 } },
+{ 0x03ae, { 0x0389 } },
+{ 0x03af, { 0x038a } },
+{ 0x03b0, { 0x03a5, 0x0308, 0x0301 } },
+{ 0x03ca, { 0x03aa } },
+{ 0x03cb, { 0x03ab } },
+{ 0x03cc, { 0x038c } },
+{ 0x03cd, { 0x038e } },
+{ 0x03ce, { 0x038f } },
+{ 0x03d3, { 0x03a5, 0x0301 } },
+{ 0x03d4, { 0x03ab } },
+{ 0x0400, { 0x0400 } },
+{ 0x0401, { 0x0401 } },
+{ 0x0403, { 0x0403 } },
+{ 0x0407, { 0x0407 } },
+{ 0x040c, { 0x040c } },
+{ 0x040d, { 0x040d } },
+{ 0x040e, { 0x040e } },
+{ 0x0419, { 0x0419 } },
+{ 0x0439, { 0x0419 } },
+{ 0x0450, { 0x0400 } },
+{ 0x0451, { 0x0401 } },
+{ 0x0453, { 0x0403 } },
+{ 0x0457, { 0x0407 } },
+{ 0x045c, { 0x040c } },
+{ 0x045d, { 0x040d } },
+{ 0x045e, { 0x040e } },
+{ 0x0476, { 0x0476 } },
+{ 0x0477, { 0x0476 } },
+{ 0x0483, { 0x0483 } },
+{ 0x0484, { 0x0484 } },
+{ 0x0485, { 0x0485 } },
+{ 0x0486, { 0x0486 } },
+{ 0x0487, { 0x0487 } },
+{ 0x0488, { 0x0488 } },
+{ 0x0489, { 0x0489 } },
+{ 0x04d0, { 0x04d0 } },
+{ 0x04d1, { 0x04d0 } },
+{ 0x04d2, { 0x04d2 } },
+{ 0x04d3, { 0x04d2 } },
+{ 0x04d6, { 0x04d6 } },
+{ 0x04d7, { 0x04d6 } },
+{ 0x04da, { 0x04da } },
+{ 0x04db, { 0x04da } },
+{ 0x04dc, { 0x04dc } },
+{ 0x04dd, { 0x04dc } },
+{ 0x04de, { 0x04de } },
+{ 0x04df, { 0x04de } },
+{ 0x04e2, { 0x04e2 } },
+{ 0x04e3, { 0x04e2 } },
+{ 0x04e4, { 0x04e4 } },
+{ 0x04e5, { 0x04e4 } },
+{ 0x04e6, { 0x04e6 } },
+{ 0x04e7, { 0x04e6 } },
+{ 0x04ea, { 0x04ea } },
+{ 0x04eb, { 0x04ea } },
+{ 0x04ec, { 0x04ec } },
+{ 0x04ed, { 0x04ec } },
+{ 0x04ee, { 0x04ee } },
+{ 0x04ef, { 0x04ee } },
+{ 0x04f0, { 0x04f0 } },
+{ 0x04f1, { 0x04f0 } },
+{ 0x04f2, { 0x04f2 } },
+{ 0x04f3, { 0x04f2 } },
+{ 0x04f4, { 0x04f4 } },
+{ 0x04f5, { 0x04f4 } },
+{ 0x04f8, { 0x04f8 } },
+{ 0x04f9, { 0x04f8 } },
+{ 0x1e00, { 0x1e00 } },
+{ 0x1e01, { 0x1e00 } },
+{ 0x1e02, { 0x1e02 } },
+{ 0x1e03, { 0x1e02 } },
+{ 0x1e04, { 0x1e04 } },
+{ 0x1e05, { 0x1e04 } },
+{ 0x1e06, { 0x1e06 } },
+{ 0x1e07, { 0x1e06 } },
+{ 0x1e08, { 0x1e08 } },
+{ 0x1e09, { 0x1e08 } },
+{ 0x1e0a, { 0x1e0a } },
+{ 0x1e0b, { 0x1e0a } },
+{ 0x1e0c, { 0x1e0c } },
+{ 0x1e0d, { 0x1e0c } },
+{ 0x1e0e, { 0x1e0e } },
+{ 0x1e0f, { 0x1e0e } },
+{ 0x1e10, { 0x1e10 } },
+{ 0x1e11, { 0x1e10 } },
+{ 0x1e12, { 0x1e12 } },
+{ 0x1e13, { 0x1e12 } },
+{ 0x1e14, { 0x1e14 } },
+{ 0x1e15, { 0x1e14 } },
+{ 0x1e16, { 0x1e16 } },
+{ 0x1e17, { 0x1e16 } },
+{ 0x1e18, { 0x1e18 } },
+{ 0x1e19, { 0x1e18 } },
+{ 0x1e1a, { 0x1e1a } },
+{ 0x1e1b, { 0x1e1a } },
+{ 0x1e1c, { 0x1e1c } },
+{ 0x1e1d, { 0x1e1c } },
+{ 0x1e1e, { 0x1e1e } },
+{ 0x1e1f, { 0x1e1e } },
+{ 0x1e20, { 0x1e20 } },
+{ 0x1e21, { 0x1e20 } },
+{ 0x1e22, { 0x1e22 } },
+{ 0x1e23, { 0x1e22 } },
+{ 0x1e24, { 0x1e24 } },
+{ 0x1e25, { 0x1e24 } },
+{ 0x1e26, { 0x1e26 } },
+{ 0x1e27, { 0x1e26 } },
+{ 0x1e28, { 0x1e28 } },
+{ 0x1e29, { 0x1e28 } },
+{ 0x1e2a, { 0x1e2a } },
+{ 0x1e2b, { 0x1e2a } },
+{ 0x1e2c, { 0x1e2c } },
+{ 0x1e2d, { 0x1e2c } },
+{ 0x1e2e, { 0x1e2e } },
+{ 0x1e2f, { 0x1e2e } },
+{ 0x1e30, { 0x1e30 } },
+{ 0x1e31, { 0x1e30 } },
+{ 0x1e32, { 0x1e32 } },
+{ 0x1e33, { 0x1e32 } },
+{ 0x1e34, { 0x1e34 } },
+{ 0x1e35, { 0x1e34 } },
+{ 0x1e36, { 0x1e36 } },
+{ 0x1e37, { 0x1e36 } },
+{ 0x1e38, { 0x1e38 } },
+{ 0x1e39, { 0x1e38 } },
+{ 0x1e3a, { 0x1e3a } },
+{ 0x1e3b, { 0x1e3a } },
+{ 0x1e3c, { 0x1e3c } },
+{ 0x1e3d, { 0x1e3c } },
+{ 0x1e3e, { 0x1e3e } },
+{ 0x1e3f, { 0x1e3e } },
+{ 0x1e40, { 0x1e40 } },
+{ 0x1e41, { 0x1e40 } },
+{ 0x1e42, { 0x1e42 } },
+{ 0x1e43, { 0x1e42 } },
+{ 0x1e44, { 0x1e44 } },
+{ 0x1e45, { 0x1e44 } },
+{ 0x1e46, { 0x1e46 } },
+{ 0x1e47, { 0x1e46 } },
+{ 0x1e48, { 0x1e48 } },
+{ 0x1e49, { 0x1e48 } },
+{ 0x1e4a, { 0x1e4a } },
+{ 0x1e4b, { 0x1e4a } },
+{ 0x1e4c, { 0x1e4c } },
+{ 0x1e4d, { 0x1e4c } },
+{ 0x1e4e, { 0x1e4e } },
+{ 0x1e4f, { 0x1e4e } },
+{ 0x1e50, { 0x1e50 } },
+{ 0x1e51, { 0x1e50 } },
+{ 0x1e52, { 0x1e52 } },
+{ 0x1e53, { 0x1e52 } },
+{ 0x1e54, { 0x1e54 } },
+{ 0x1e55, { 0x1e54 } },
+{ 0x1e56, { 0x1e56 } },
+{ 0x1e57, { 0x1e56 } },
+{ 0x1e58, { 0x1e58 } },
+{ 0x1e59, { 0x1e58 } },
+{ 0x1e5a, { 0x1e5a } },
+{ 0x1e5b, { 0x1e5a } },
+{ 0x1e5c, { 0x1e5c } },
+{ 0x1e5d, { 0x1e5c } },
+{ 0x1e5e, { 0x1e5e } },
+{ 0x1e5f, { 0x1e5e } },
+{ 0x1e60, { 0x1e60 } },
+{ 0x1e61, { 0x1e60 } },
+{ 0x1e62, { 0x1e62 } },
+{ 0x1e63, { 0x1e62 } },
+{ 0x1e64, { 0x1e64 } },
+{ 0x1e65, { 0x1e64 } },
+{ 0x1e66, { 0x1e66 } },
+{ 0x1e67, { 0x1e66 } },
+{ 0x1e68, { 0x1e68 } },
+{ 0x1e69, { 0x1e68 } },
+{ 0x1e6a, { 0x1e6a } },
+{ 0x1e6b, { 0x1e6a } },
+{ 0x1e6c, { 0x1e6c } },
+{ 0x1e6d, { 0x1e6c } },
+{ 0x1e6e, { 0x1e6e } },
+{ 0x1e6f, { 0x1e6e } },
+{ 0x1e70, { 0x1e70 } },
+{ 0x1e71, { 0x1e70 } },
+{ 0x1e72, { 0x1e72 } },
+{ 0x1e73, { 0x1e72 } },
+{ 0x1e74, { 0x1e74 } },
+{ 0x1e75, { 0x1e74 } },
+{ 0x1e76, { 0x1e76 } },
+{ 0x1e77, { 0x1e76 } },
+{ 0x1e78, { 0x1e78 } },
+{ 0x1e79, { 0x1e78 } },
+{ 0x1e7a, { 0x1e7a } },
+{ 0x1e7b, { 0x1e7a } },
+{ 0x1e7c, { 0x1e7c } },
+{ 0x1e7d, { 0x1e7c } },
+{ 0x1e7e, { 0x1e7e } },
+{ 0x1e7f, { 0x1e7e } },
+{ 0x1e80, { 0x1e80 } },
+{ 0x1e81, { 0x1e80 } },
+{ 0x1e82, { 0x1e82 } },
+{ 0x1e83, { 0x1e82 } },
+{ 0x1e84, { 0x1e84 } },
+{ 0x1e85, { 0x1e84 } },
+{ 0x1e86, { 0x1e86 } },
+{ 0x1e87, { 0x1e86 } },
+{ 0x1e88, { 0x1e88 } },
+{ 0x1e89, { 0x1e88 } },
+{ 0x1e8a, { 0x1e8a } },
+{ 0x1e8b, { 0x1e8a } },
+{ 0x1e8c, { 0x1e8c } },
+{ 0x1e8d, { 0x1e8c } },
+{ 0x1e8e, { 0x1e8e } },
+{ 0x1e8f, { 0x1e8e } },
+{ 0x1e90, { 0x1e90 } },
+{ 0x1e91, { 0x1e90 } },
+{ 0x1e92, { 0x1e92 } },
+{ 0x1e93, { 0x1e92 } },
+{ 0x1e94, { 0x1e94 } },
+{ 0x1e95, { 0x1e94 } },
+{ 0x1e96, { 0x0048, 0x0331 } },
+{ 0x1e97, { 0x0054, 0x0308 } },
+{ 0x1e98, { 0x0057, 0x030a } },
+{ 0x1e99, { 0x0059, 0x030a } },
+{ 0x1e9a, { 0x0041, 0x02be } },
+{ 0x1e9b, { 0x1e60 } },
+{ 0x1e9c, { 0x1e9c } },
+{ 0x1e9d, { 0x1e9d } },
+{ 0x1ea0, { 0x1ea0 } },
+{ 0x1ea1, { 0x1ea0 } },
+{ 0x1ea2, { 0x1ea2 } },
+{ 0x1ea3, { 0x1ea2 } },
+{ 0x1ea4, { 0x1ea4 } },
+{ 0x1ea5, { 0x1ea4 } },
+{ 0x1ea6, { 0x1ea6 } },
+{ 0x1ea7, { 0x1ea6 } },
+{ 0x1ea8, { 0x1ea8 } },
+{ 0x1ea9, { 0x1ea8 } },
+{ 0x1eaa, { 0x1eaa } },
+{ 0x1eab, { 0x1eaa } },
+{ 0x1eac, { 0x1eac } },
+{ 0x1ead, { 0x1eac } },
+{ 0x1eae, { 0x1eae } },
+{ 0x1eaf, { 0x1eae } },
+{ 0x1eb0, { 0x1eb0 } },
+{ 0x1eb1, { 0x1eb0 } },
+{ 0x1eb2, { 0x1eb2 } },
+{ 0x1eb3, { 0x1eb2 } },
+{ 0x1eb4, { 0x1eb4 } },
+{ 0x1eb5, { 0x1eb4 } },
+{ 0x1eb6, { 0x1eb6 } },
+{ 0x1eb7, { 0x1eb6 } },
+{ 0x1eb8, { 0x1eb8 } },
+{ 0x1eb9, { 0x1eb8 } },
+{ 0x1eba, { 0x1eba } },
+{ 0x1ebb, { 0x1eba } },
+{ 0x1ebc, { 0x1ebc } },
+{ 0x1ebd, { 0x1ebc } },
+{ 0x1ebe, { 0x1ebe } },
+{ 0x1ebf, { 0x1ebe } },
+{ 0x1ec0, { 0x1ec0 } },
+{ 0x1ec1, { 0x1ec0 } },
+{ 0x1ec2, { 0x1ec2 } },
+{ 0x1ec3, { 0x1ec2 } },
+{ 0x1ec4, { 0x1ec4 } },
+{ 0x1ec5, { 0x1ec4 } },
+{ 0x1ec6, { 0x1ec6 } },
+{ 0x1ec7, { 0x1ec6 } },
+{ 0x1ec8, { 0x1ec8 } },
+{ 0x1ec9, { 0x1ec8 } },
+{ 0x1eca, { 0x1eca } },
+{ 0x1ecb, { 0x1eca } },
+{ 0x1ecc, { 0x1ecc } },
+{ 0x1ecd, { 0x1ecc } },
+{ 0x1ece, { 0x1ece } },
+{ 0x1ecf, { 0x1ece } },
+{ 0x1ed0, { 0x1ed0 } },
+{ 0x1ed1, { 0x1ed0 } },
+{ 0x1ed2, { 0x1ed2 } },
+{ 0x1ed3, { 0x1ed2 } },
+{ 0x1ed4, { 0x1ed4 } },
+{ 0x1ed5, { 0x1ed4 } },
+{ 0x1ed6, { 0x1ed6 } },
+{ 0x1ed7, { 0x1ed6 } },
+{ 0x1ed8, { 0x1ed8 } },
+{ 0x1ed9, { 0x1ed8 } },
+{ 0x1eda, { 0x1eda } },
+{ 0x1edb, { 0x1eda } },
+{ 0x1edc, { 0x1edc } },
+{ 0x1edd, { 0x1edc } },
+{ 0x1ede, { 0x1ede } },
+{ 0x1edf, { 0x1ede } },
+{ 0x1ee0, { 0x1ee0 } },
+{ 0x1ee1, { 0x1ee0 } },
+{ 0x1ee2, { 0x1ee2 } },
+{ 0x1ee3, { 0x1ee2 } },
+{ 0x1ee4, { 0x1ee4 } },
+{ 0x1ee5, { 0x1ee4 } },
+{ 0x1ee6, { 0x1ee6 } },
+{ 0x1ee7, { 0x1ee6 } },
+{ 0x1ee8, { 0x1ee8 } },
+{ 0x1ee9, { 0x1ee8 } },
+{ 0x1eea, { 0x1eea } },
+{ 0x1eeb, { 0x1eea } },
+{ 0x1eec, { 0x1eec } },
+{ 0x1eed, { 0x1eec } },
+{ 0x1eee, { 0x1eee } },
+{ 0x1eef, { 0x1eee } },
+{ 0x1ef0, { 0x1ef0 } },
+{ 0x1ef1, { 0x1ef0 } },
+{ 0x1ef2, { 0x1ef2 } },
+{ 0x1ef3, { 0x1ef2 } },
+{ 0x1ef4, { 0x1ef4 } },
+{ 0x1ef5, { 0x1ef4 } },
+{ 0x1ef6, { 0x1ef6 } },
+{ 0x1ef7, { 0x1ef6 } },
+{ 0x1ef8, { 0x1ef8 } },
+{ 0x1ef9, { 0x1ef8 } },
+{ 0x1f00, { 0x1f08 } },
+{ 0x1f01, { 0x1f09 } },
+{ 0x1f02, { 0x1f0a } },
+{ 0x1f03, { 0x1f0b } },
+{ 0x1f04, { 0x1f0c } },
+{ 0x1f05, { 0x1f0d } },
+{ 0x1f06, { 0x1f0e } },
+{ 0x1f07, { 0x1f0f } },
+{ 0x1f08, { 0x1f08 } },
+{ 0x1f09, { 0x1f09 } },
+{ 0x1f0a, { 0x1f0a } },
+{ 0x1f0b, { 0x1f0b } },
+{ 0x1f0c, { 0x1f0c } },
+{ 0x1f0d, { 0x1f0d } },
+{ 0x1f0e, { 0x1f0e } },
+{ 0x1f0f, { 0x1f0f } },
+{ 0x1f10, { 0x1f18 } },
+{ 0x1f11, { 0x1f19 } },
+{ 0x1f12, { 0x1f1a } },
+{ 0x1f13, { 0x1f1b } },
+{ 0x1f14, { 0x1f1c } },
+{ 0x1f15, { 0x1f1d } },
+{ 0x1f18, { 0x1f18 } },
+{ 0x1f19, { 0x1f19 } },
+{ 0x1f1a, { 0x1f1a } },
+{ 0x1f1b, { 0x1f1b } },
+{ 0x1f1c, { 0x1f1c } },
+{ 0x1f1d, { 0x1f1d } },
+{ 0x1f20, { 0x1f28 } },
+{ 0x1f21, { 0x1f29 } },
+{ 0x1f22, { 0x1f2a } },
+{ 0x1f23, { 0x1f2b } },
+{ 0x1f24, { 0x1f2c } },
+{ 0x1f25, { 0x1f2d } },
+{ 0x1f26, { 0x1f2e } },
+{ 0x1f27, { 0x1f2f } },
+{ 0x1f28, { 0x1f28 } },
+{ 0x1f29, { 0x1f29 } },
+{ 0x1f2a, { 0x1f2a } },
+{ 0x1f2b, { 0x1f2b } },
+{ 0x1f2c, { 0x1f2c } },
+{ 0x1f2d, { 0x1f2d } },
+{ 0x1f2e, { 0x1f2e } },
+{ 0x1f2f, { 0x1f2f } },
+{ 0x1f30, { 0x1f38 } },
+{ 0x1f31, { 0x1f39 } },
+{ 0x1f32, { 0x1f3a } },
+{ 0x1f33, { 0x1f3b } },
+{ 0x1f34, { 0x1f3c } },
+{ 0x1f35, { 0x1f3d } },
+{ 0x1f36, { 0x1f3e } },
+{ 0x1f37, { 0x1f3f } },
+{ 0x1f38, { 0x1f38 } },
+{ 0x1f39, { 0x1f39 } },
+{ 0x1f3a, { 0x1f3a } },
+{ 0x1f3b, { 0x1f3b } },
+{ 0x1f3c, { 0x1f3c } },
+{ 0x1f3d, { 0x1f3d } },
+{ 0x1f3e, { 0x1f3e } },
+{ 0x1f3f, { 0x1f3f } },
+{ 0x1f40, { 0x1f48 } },
+{ 0x1f41, { 0x1f49 } },
+{ 0x1f42, { 0x1f4a } },
+{ 0x1f43, { 0x1f4b } },
+{ 0x1f44, { 0x1f4c } },
+{ 0x1f45, { 0x1f4d } },
+{ 0x1f48, { 0x1f48 } },
+{ 0x1f49, { 0x1f49 } },
+{ 0x1f4a, { 0x1f4a } },
+{ 0x1f4b, { 0x1f4b } },
+{ 0x1f4c, { 0x1f4c } },
+{ 0x1f4d, { 0x1f4d } },
+{ 0x1f50, { 0x03a5, 0x0313 } },
+{ 0x1f51, { 0x1f59 } },
+{ 0x1f52, { 0x03a5, 0x0313, 0x0300 } },
+{ 0x1f53, { 0x1f5b } },
+{ 0x1f54, { 0x03a5, 0x0313, 0x0301 } },
+{ 0x1f55, { 0x1f5d } },
+{ 0x1f56, { 0x03a5, 0x0313, 0x0342 } },
+{ 0x1f57, { 0x1f5f } },
+{ 0x1f59, { 0x1f59 } },
+{ 0x1f5b, { 0x1f5b } },
+{ 0x1f5d, { 0x1f5d } },
+{ 0x1f5f, { 0x1f5f } },
+{ 0x1f60, { 0x1f68 } },
+{ 0x1f61, { 0x1f69 } },
+{ 0x1f62, { 0x1f6a } },
+{ 0x1f63, { 0x1f6b } },
+{ 0x1f64, { 0x1f6c } },
+{ 0x1f65, { 0x1f6d } },
+{ 0x1f66, { 0x1f6e } },
+{ 0x1f67, { 0x1f6f } },
+{ 0x1f68, { 0x1f68 } },
+{ 0x1f69, { 0x1f69 } },
+{ 0x1f6a, { 0x1f6a } },
+{ 0x1f6b, { 0x1f6b } },
+{ 0x1f6c, { 0x1f6c } },
+{ 0x1f6d, { 0x1f6d } },
+{ 0x1f6e, { 0x1d6e } },
+{ 0x1f6f, { 0x1f6f } },
+{ 0x1f70, { 0x1fba } },
+{ 0x1f71, { 0x1fbb } },
+{ 0x1f72, { 0x1fc8 } },
+{ 0x1f73, { 0x1fc9 } },
+{ 0x1f74, { 0x1fca } },
+{ 0x1f75, { 0x1fcb } },
+{ 0x1f76, { 0x1fda } },
+{ 0x1f77, { 0x1fdb } },
+{ 0x1f78, { 0x1ff8 } },
+{ 0x1f79, { 0x1ff9 } },
+{ 0x1f7a, { 0x1fea } },
+{ 0x1f7b, { 0x1feb } },
+{ 0x1f7c, { 0x1ffa } },
+{ 0x1f7d, { 0x1ffb } },
+{ 0x1f80, { 0x1f08, 0x0399 } },
+{ 0x1f81, { 0x1f09, 0x0399 } },
+{ 0x1f82, { 0x1f0a, 0x0399 } },
+{ 0x1f83, { 0x1f0b, 0x0399 } },
+{ 0x1f84, { 0x1f0c, 0x0399 } },
+{ 0x1f85, { 0x1f0d, 0x0399 } },
+{ 0x1f86, { 0x1f0e, 0x0399 } },
+{ 0x1f87, { 0x1f0f, 0x0399 } },
+{ 0x1f88, { 0x1f88 } },
+{ 0x1f89, { 0x1f89 } },
+{ 0x1f8a, { 0x1f8a } },
+{ 0x1f8b, { 0x1f8b } },
+{ 0x1f8c, { 0x1f8c } },
+{ 0x1f8d, { 0x1f8d } },
+{ 0x1f8e, { 0x1f8e } },
+{ 0x1f8f, { 0x1f8f } },
+{ 0x1f90, { 0x1f28, 0x0399 } },
+{ 0x1f91, { 0x1f29, 0x0399 } },
+{ 0x1f92, { 0x1f2a, 0x0399 } },
+{ 0x1f93, { 0x1f2b, 0x0399 } },
+{ 0x1f94, { 0x1f2c, 0x0399 } },
+{ 0x1f95, { 0x1f2d, 0x0399 } },
+{ 0x1f96, { 0x1f2e, 0x0399 } },
+{ 0x1f97, { 0x1f2f, 0x0399 } },
+{ 0x1f98, { 0x1f28, 0x0399 } },
+{ 0x1f99, { 0x1f29, 0x0399 } },
+{ 0x1f9a, { 0x1f2a, 0x0399 } },
+{ 0x1f9b, { 0x1f2b, 0x0399 } },
+{ 0x1f9c, { 0x1f2c, 0x0399 } },
+{ 0x1f9d, { 0x1f2d, 0x0399 } },
+{ 0x1f9e, { 0x1f2e, 0x0399 } },
+{ 0x1f9f, { 0x1f2f, 0x0399 } },
+{ 0x1fa0, { 0x1f68, 0x0399 } },
+{ 0x1fa1, { 0x1f69, 0x0399 } },
+{ 0x1fa2, { 0x1f6a, 0x0399 } },
+{ 0x1fa3, { 0x1f6b, 0x0399 } },
+{ 0x1fa4, { 0x1f6c, 0x0399 } },
+{ 0x1fa5, { 0x1f6d, 0x0399 } },
+{ 0x1fa6, { 0x1f6e, 0x0399 } },
+{ 0x1fa7, { 0x1f6f, 0x0399 } },
+{ 0x1fa8, { 0x1f68, 0x0399 } },
+{ 0x1fa9, { 0x1f69, 0x0399 } },
+{ 0x1faa, { 0x1f6a, 0x0399 } },
+{ 0x1fab, { 0x1f6b, 0x0399 } },
+{ 0x1fac, { 0x1f6c, 0x0399 } },
+{ 0x1fad, { 0x1f6d, 0x0399 } },
+{ 0x1fae, { 0x1f6e, 0x0399 } },
+{ 0x1faf, { 0x1f6f, 0x0399 } },
+{ 0x1fb0, { 0x1fb8 } },
+{ 0x1fb1, { 0x1fb9 } },
+{ 0x1fb2, { 0x1fba, 0x0399 } },
+{ 0x1fb3, { 0x0391, 0x0399 } },
+{ 0x1fb4, { 0x0386, 0x0399 } },
+{ 0x1fb6, { 0x0391, 0x0342 } },
+{ 0x1fb7, { 0x0391, 0x0342, 0x0399 } },
+{ 0x1fb8, { 0x1fb8 } },
+{ 0x1fb9, { 0x1fb9 } },
+{ 0x1fba, { 0x1fba } },
+{ 0x1fbb, { 0x1fbb } },
+{ 0x1fbc, { 0x0391, 0x0399 } },
+{ 0x1fc2, { 0x1fca, 0x0399 } },
+{ 0x1fc3, { 0x0397, 0x0399 } },
+{ 0x1fc4, { 0x0389, 0x0399 } },
+{ 0x1fc6, { 0x0397, 0x0342 } },
+{ 0x1fc7, { 0x0397, 0x0342, 0x0399 } },
+{ 0x1fc8, { 0x1fc8 } },
+{ 0x1fc9, { 0x1fc9 } },
+{ 0x1fca, { 0x1fca } },
+{ 0x1fcb, { 0x1fcb } },
+{ 0x1fcc, { 0x0397, 0x0399 } },
+{ 0x1fd0, { 0x1fd8 } },
+{ 0x1fd1, { 0x1fd9 } },
+{ 0x1fd2, { 0x0399, 0x0308, 0x0300 } },
+{ 0x1fd3, { 0x0399, 0x0308, 0x0301 } },
+{ 0x1fd6, { 0x0399, 0x0342 } },
+{ 0x1fd7, { 0x0399, 0x0308, 0x0342 } },
+{ 0x1fd8, { 0x1fd8 } },
+{ 0x1fd9, { 0x1fd9 } },
+{ 0x1fda, { 0x1fda } },
+{ 0x1fdb, { 0x1fdb } },
+{ 0x1fe0, { 0x1fe8 } },
+{ 0x1fe1, { 0x1fe9 } },
+{ 0x1fe2, { 0x03a5, 0x0308, 0x0300 } },
+{ 0x1fe3, { 0x03a5, 0x0308, 0x0301 } },
+{ 0x1fe4, { 0x03a1, 0x0313 } },
+{ 0x1fe5, { 0x1fec } },
+{ 0x1fe6, { 0x03a5, 0x0342 } },
+{ 0x1fe7, { 0x03a5, 0x0308, 0x0342 } },
+{ 0x1fe8, { 0x1fe8 } },
+{ 0x1fe9, { 0x1fe9 } },
+{ 0x1fea, { 0x1fea } },
+{ 0x1feb, { 0x1feb } },
+{ 0x1fec, { 0x1fec } },
+{ 0x1ff2, { 0x1ffa, 0x0399 } },
+{ 0x1ff3, { 0x03a9, 0x0399 } },
+{ 0x1ff4, { 0x038f, 0x0399 } },
+{ 0x1ff6, { 0x03a9, 0x0342 } },
+{ 0x1ff7, { 0x03a9, 0x0342, 0x0399 } },
+{ 0x1ff8, { 0x1ff8 } },
+{ 0x1ff9, { 0x1ff9 } },
+{ 0x1ffa, { 0x1ffa } },
+{ 0x1ffb, { 0x1ffb } },
+{ 0x1ffc, { 0x03a9, 0x0399 } },
+{ 0x20d0, { 0x20d0 } },
+{ 0x20d1, { 0x20d1 } },
+{ 0x20d2, { 0x20d2 } },
+{ 0x20d3, { 0x20d3 } },
+{ 0x20d4, { 0x20d4 } },
+{ 0x20d5, { 0x20d5 } },
+{ 0x20d6, { 0x20d6 } },
+{ 0x20d7, { 0x20d7 } },
+{ 0x20d8, { 0x20d8 } },
+{ 0x20d9, { 0x20d9 } },
+{ 0x20da, { 0x20da } },
+{ 0x20db, { 0x20db } },
+{ 0x20dc, { 0x20dc } },
+{ 0x20dd, { 0x20dd } },
+{ 0x20de, { 0x20de } },
+{ 0x20df, { 0x20df } },
+{ 0x20e0, { 0x20e0 } },
+{ 0x20e1, { 0x20e1 } },
+{ 0x20e2, { 0x20e2 } },
+{ 0x20e3, { 0x20e3 } },
+{ 0x20e4, { 0x20e4 } },
+{ 0x20e5, { 0x20e5 } },
+{ 0x20e6, { 0x20e6 } },
+{ 0x20e7, { 0x20e7 } },
+{ 0x20e8, { 0x20e8 } },
+{ 0x20e9, { 0x20e9 } },
+{ 0x20ea, { 0x20ea } },
+{ 0x20eb, { 0x20eb } },
+{ 0x20ec, { 0x20ec } },
+{ 0x20ed, { 0x20ed } },
+{ 0x20ee, { 0x20ee } },
+{ 0x20ef, { 0x20ef } },
+{ 0x20f0, { 0x20f0 } },
+{ 0x302a, { 0x302a } },
+{ 0x302b, { 0x302b } },
+{ 0x302c, { 0x302c } },
+{ 0x302d, { 0x302d } },
+{ 0x302e, { 0x302e } },
+{ 0x302f, { 0x302f } },
+{ 0x304c, { 0x30ac } },
+{ 0x304e, { 0x30ae } },
+{ 0x3050, { 0x30b0 } },
+{ 0x3052, { 0x30b2 } },
+{ 0x3054, { 0x30b4 } },
+{ 0x3056, { 0x30b6 } },
+{ 0x3058, { 0x30b8 } },
+{ 0x305a, { 0x30ba } },
+{ 0x305c, { 0x30bc } },
+{ 0x305e, { 0x30be } },
+{ 0x3060, { 0x30c0 } },
+{ 0x3062, { 0x30c2 } },
+{ 0x3065, { 0x30c5 } },
+{ 0x3067, { 0x30c7 } },
+{ 0x3069, { 0x30c9 } },
+{ 0x3070, { 0x30d0 } },
+{ 0x3071, { 0x30d1 } },
+{ 0x3073, { 0x30d3 } },
+{ 0x3074, { 0x30d4 } },
+{ 0x3076, { 0x30d6 } },
+{ 0x3077, { 0x30d7 } },
+{ 0x3079, { 0x30d9 } },
+{ 0x307a, { 0x30da } },
+{ 0x307c, { 0x30dc } },
+{ 0x307d, { 0x30dd } },
+{ 0x3094, { 0x30f4 } },
+{ 0x3099, { 0x3099 } },
+{ 0x309a, { 0x309a } },
+{ 0x309b, { 0x309b } },
+{ 0x309c, { 0x309c } },
+{ 0x30ac, { 0x30ac } },
+{ 0x30ae, { 0x30ae } },
+{ 0x30b0, { 0x30b0 } },
+{ 0x30b2, { 0x30b2 } },
+{ 0x30b4, { 0x30b4 } },
+{ 0x30b6, { 0x30b6 } },
+{ 0x30b8, { 0x30b8 } },
+{ 0x30ba, { 0x30ba } },
+{ 0x30bc, { 0x30bc } },
+{ 0x30be, { 0x30be } },
+{ 0x30c0, { 0x30c0 } },
+{ 0x30c2, { 0x30c2 } },
+{ 0x30c5, { 0x30c5 } },
+{ 0x30c7, { 0x30c7 } },
+{ 0x30c9, { 0x30c9 } },
+{ 0x30d0, { 0x30d0 } },
+{ 0x30d1, { 0x30d1 } },
+{ 0x30d3, { 0x30d3 } },
+{ 0x30d4, { 0x30d4 } },
+{ 0x30d6, { 0x30d6 } },
+{ 0x30d7, { 0x30d7 } },
+{ 0x30d9, { 0x30d9 } },
+{ 0x30da, { 0x30da } },
+{ 0x30dc, { 0x30dc } },
+{ 0x30dd, { 0x30dd } },
+{ 0x30f4, { 0x30f4 } },
+{ 0x30f7, { 0x30f7 } },
+{ 0x30f8, { 0x30f8 } },
+{ 0x30f9, { 0x30f9 } },
+{ 0x30fa, { 0x30fa } },
+{ 0xfb1d, { 0xfb1d } },
+{ 0xfb1f, { 0xfb1f } },
+{ 0xfb2a, { 0xfb2a } },
+{ 0xfb2b, { 0xfb2b } },
+{ 0xfb2c, { 0xfb2c } },
+{ 0xfb2d, { 0xfb2d } },
+{ 0xfb2e, { 0xfb2e } },
+{ 0xfb2f, { 0xfb2f } },
+{ 0xfb30, { 0xfb30 } },
+{ 0xfb31, { 0xfb31 } },
+{ 0xfb32, { 0xfb32 } },
+{ 0xfb33, { 0xfb33 } },
+{ 0xfb34, { 0xfb34 } },
+{ 0xfb35, { 0xfb35 } },
+{ 0xfb36, { 0xfb36 } },
+{ 0xfb38, { 0xfb38 } },
+{ 0xfb39, { 0xfb39 } },
+{ 0xfb3a, { 0xfb3a } },
+{ 0xfb3b, { 0xfb3b } },
+{ 0xfb3c, { 0xfb3c } },
+{ 0xfb3e, { 0xfb3e } },
+{ 0xfb40, { 0xfb40 } },
+{ 0xfb41, { 0xfb41 } },
+{ 0xfb43, { 0xfb43 } },
+{ 0xfb44, { 0xfb44 } },
+{ 0xfb46, { 0xfb46 } },
+{ 0xfb47, { 0xfb47 } },
+{ 0xfb48, { 0xfb48 } },
+{ 0xfb49, { 0xfb49 } },
+{ 0xfb4a, { 0xfb4a } },
+{ 0xfb4b, { 0xfb4b } },
+{ 0xfb4c, { 0xfb4c } },
+{ 0xfb4d, { 0xfb4d } },
+{ 0xfb4e, { 0xfb4e } },
+{ 0xfb4f, { 0xfb4f } },
+{ 0xff9e, { 0x3099 } },
+{ 0xff9f, { 0x309a } },
+};
+
+int get_with_diacritical_mark_character_table_size(void)
+{
+ return sizeof(with_diacritical_mark_character_table)/sizeof(struct mapping_data);
+}
+
+/* character with umlaut
+ *
+ * mapping rule
+ * - lowercase, titlecase -> uppercase
+ * - Ä -> AE, Ï -> IE, Ü -> UE, Ö -> OE
+ */
+const struct mapping_data umlaut_table[] =
+{
+{ 0x00c4, { 0x0041, 0x0045 } },
+{ 0x00cb, { 0x0045, 0x0045 } },
+{ 0x00cf, { 0x0049, 0x0045 } },
+{ 0x00d6, { 0x004f, 0x0045 } },
+{ 0x00dc, { 0x0055, 0x0045 } },
+{ 0x00e4, { 0x0041, 0x0045 } },
+{ 0x00eb, { 0x0045, 0x0045 } },
+{ 0x00ef, { 0x0049, 0x0045 } },
+{ 0x00f6, { 0x004f, 0x0045 } },
+{ 0x00fc, { 0x0055, 0x0045 } },
+};
+
+int get_umlaut_table_size(void)
+{
+ return sizeof(umlaut_table)/sizeof(struct mapping_data);
+}
diff --git a/tools/code_mapping_tables.h b/tools/code_mapping_tables.h
new file mode 100644
index 0000000..bd74a81
--- /dev/null
+++ b/tools/code_mapping_tables.h
@@ -0,0 +1,41 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2008 Yoshihisa Uchida
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#define MAPPING_TABLE_VERSION 1
+
+extern const unsigned char mini_index[];
+extern const unsigned char full_index[];
+
+struct mapping_data
+{
+ unsigned short code;
+ unsigned short data[5];
+};
+
+extern const struct mapping_data common_mapping_table[];
+extern const struct mapping_data with_diacritical_mark_character_table[];
+extern const struct mapping_data umlaut_table[];
+
+int get_mini_index_size(void);
+int get_full_index_size(void);
+int get_common_mapping_table_size(void);
+int get_with_diacritical_mark_character_table_size(void);
+int get_umlaut_table_size(void);
diff --git a/tools/mkmappingtable.c b/tools/mkmappingtable.c
new file mode 100644
index 0000000..bcc08ff
--- /dev/null
+++ b/tools/mkmappingtable.c
@@ -0,0 +1,201 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ * $Id$
+ *
+ * Copyright (C) 2008 Yoshihisa Uchida
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include
+#include
+#include
+#include "code_mapping_tables.h"
+
+#define WITH_DIACRITICAL_MARK 1
+#define OTHER_CHANGE_UMLAUT 2
+
+static int search_mapping_data(const struct mapping_data *table, int table_size, unsigned short ucs)
+{
+ int idx = 0;
+
+ for(idx = 0; idx < table_size; idx++)
+ {
+ if (table[idx].code == ucs)
+ return idx;
+ if (table[idx].code > ucs)
+ return -1;
+ }
+ return -1;
+}
+
+static int write_short(FILE *f, unsigned short s)
+{
+ putc(s, f);
+ return putc(s>>8, f) != EOF;
+}
+
+static int write_data(FILE *f, const unsigned short *d)
+{
+ int idx;
+ unsigned char count = 0;
+
+ for (idx = 0; idx < 5; idx++)
+ {
+ if (d[idx] == 0 && idx > 0)
+ break;
+ count++;
+ }
+
+ if (count == 1 && d[0] == 0xffff)
+ count = 0;
+
+ if (putc(count, f) == EOF)
+ return 0;
+
+ for (idx = 0; idx < count; idx++)
+ {
+ if (!write_short(f, d[idx]))
+ return 0;
+ }
+ return 1;
+}
+
+static int write_mapping_data(FILE *f, int idx)
+{
+ if (idx >= 0)
+ {
+ unsigned char kind = 0;
+ int idx2 = search_mapping_data(with_diacritical_mark_character_table,
+ get_with_diacritical_mark_character_table_size(),
+ common_mapping_table[idx].code);
+ int idx3 = search_mapping_data(umlaut_table,
+ get_umlaut_table_size(),
+ common_mapping_table[idx].code);
+
+ if (idx2 >= 0)
+ kind |= WITH_DIACRITICAL_MARK;
+
+ if (idx3 >= 0)
+ kind |= OTHER_CHANGE_UMLAUT;
+
+ if (putc(kind, f) == EOF)
+ return 0;
+
+ if (!write_data(f, common_mapping_table[idx].data))
+ return 0;
+ if (idx2 >= 0)
+ {
+ if (!write_data(f, with_diacritical_mark_character_table[idx2].data))
+ return 0;
+ }
+ if (idx3 >= 0)
+ {
+ if (!write_data(f, umlaut_table[idx3].data))
+ return 0;
+ }
+ }
+ return 1;
+}
+
+static int write_header(FILE *f, const unsigned char *table_index, int index_count)
+{
+ int i;
+ if (!write_short(f, (index_count << 8) | MAPPING_TABLE_VERSION))
+ return 0;
+ for (i = 0; i < index_count; i++)
+ {
+ if (putc(table_index[i], f) == EOF)
+ return 0;
+ }
+ return 1;
+}
+
+static int make_mapping_file(const char *fname, const unsigned char *table_index, int index_count)
+{
+ FILE *f;
+ int i, j;
+ unsigned short uni;
+ int idx;
+
+ f = fopen(fname, "wb");
+ if (!f)
+ return 1;
+
+ write_header(f, table_index, index_count);
+ for (i = 0; i < index_count; i++)
+ {
+ for (j = 0; j < 256; j++)
+ {
+ uni = (table_index[i] << 8) | (unsigned char)j;
+ idx = search_mapping_data(common_mapping_table, get_common_mapping_table_size(), uni);
+ if (idx < 0)
+ {
+ printf("error %x: mapping data does not exist.", uni);
+ fclose(f);
+ return 1;
+ }
+ write_mapping_data(f, idx);
+ }
+ }
+ fclose(f);
+ return 0;
+}
+
+
+static void print_usage(void)
+{
+ printf("Usage: mkmappingtable [-m]\n"
+ "\t-m create unimini.mt\n");
+ printf("build date: " __DATE__ "\n\n");
+}
+
+int main(int argc, char **argv)
+{
+ int i;
+ int mini_flag = 0;
+ int res;
+
+ for (i = 1;i < argc;i++)
+ {
+ if (argv[i][0] == '-')
+ {
+ switch (argv[i][1])
+ {
+ case 'm':
+ mini_flag = 1;
+ break;
+
+ case 'h': /* help */
+ case '?':
+ print_usage();
+ exit(1);
+ break;
+
+ default:
+ print_usage();
+ exit(1);
+ break;
+ }
+ }
+ }
+
+ if (mini_flag)
+ res = make_mapping_file("unimini.mt", mini_index, get_mini_index_size());
+ else
+ res = make_mapping_file("uni.mt", full_index, get_full_index_size());
+
+ return 0;
+}