From 46651ce6fe013220ed397add242004d764fc0153 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 4 May 2024 14:15:05 +0200 Subject: Adding upstream version 14.5. Signed-off-by: Daniel Baumann --- src/backend/utils/mb/Unicode/Makefile | 146 + src/backend/utils/mb/Unicode/UCS_to_BIG5.pl | 79 + src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl | 85 + .../utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl | 72 + src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl | 678 + src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl | 62 + src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl | 71 + src/backend/utils/mb/Unicode/UCS_to_GB18030.pl | 52 + src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl | 56 + .../utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl | 88 + src/backend/utils/mb/Unicode/UCS_to_SJIS.pl | 106 + src/backend/utils/mb/Unicode/UCS_to_UHC.pl | 66 + src/backend/utils/mb/Unicode/UCS_to_most.pl | 62 + src/backend/utils/mb/Unicode/big5_to_utf8.map | 4606 +++ src/backend/utils/mb/Unicode/convutils.pm | 838 + src/backend/utils/mb/Unicode/euc-jis-2004-std.txt | 11549 +++++++ src/backend/utils/mb/Unicode/euc_cn_to_utf8.map | 2280 ++ .../utils/mb/Unicode/euc_jis_2004_to_utf8.map | 3443 +++ src/backend/utils/mb/Unicode/euc_jp_to_utf8.map | 4142 +++ src/backend/utils/mb/Unicode/euc_kr_to_utf8.map | 2498 ++ src/backend/utils/mb/Unicode/euc_tw_to_utf8.map | 7834 +++++ src/backend/utils/mb/Unicode/gb-18030-2000.xml | 30916 +++++++++++++++++++ src/backend/utils/mb/Unicode/gb18030_to_utf8.map | 11151 +++++++ src/backend/utils/mb/Unicode/gbk_to_utf8.map | 6554 ++++ .../utils/mb/Unicode/iso8859_10_to_utf8.map | 111 + .../utils/mb/Unicode/iso8859_13_to_utf8.map | 111 + .../utils/mb/Unicode/iso8859_14_to_utf8.map | 111 + .../utils/mb/Unicode/iso8859_15_to_utf8.map | 111 + .../utils/mb/Unicode/iso8859_16_to_utf8.map | 111 + src/backend/utils/mb/Unicode/iso8859_2_to_utf8.map | 79 + src/backend/utils/mb/Unicode/iso8859_3_to_utf8.map | 79 + src/backend/utils/mb/Unicode/iso8859_4_to_utf8.map | 79 + src/backend/utils/mb/Unicode/iso8859_5_to_utf8.map | 111 + src/backend/utils/mb/Unicode/iso8859_6_to_utf8.map | 77 + src/backend/utils/mb/Unicode/iso8859_7_to_utf8.map | 111 + src/backend/utils/mb/Unicode/iso8859_8_to_utf8.map | 111 + src/backend/utils/mb/Unicode/iso8859_9_to_utf8.map | 79 + src/backend/utils/mb/Unicode/johab_to_utf8.map | 6280 ++++ src/backend/utils/mb/Unicode/koi8r_to_utf8.map | 111 + src/backend/utils/mb/Unicode/koi8u_to_utf8.map | 111 + .../utils/mb/Unicode/shift_jis_2004_to_utf8.map | 3234 ++ .../utils/mb/Unicode/sjis-0213-2004-std.txt | 11549 +++++++ src/backend/utils/mb/Unicode/sjis_to_utf8.map | 2417 ++ src/backend/utils/mb/Unicode/uhc_to_utf8.map | 6553 ++++ src/backend/utils/mb/Unicode/utf8_to_big5.map | 4100 +++ src/backend/utils/mb/Unicode/utf8_to_euc_cn.map | 4044 +++ .../utils/mb/Unicode/utf8_to_euc_jis_2004.map | 12567 ++++++++ src/backend/utils/mb/Unicode/utf8_to_euc_jp.map | 7141 +++++ src/backend/utils/mb/Unicode/utf8_to_euc_kr.map | 6392 ++++ src/backend/utils/mb/Unicode/utf8_to_euc_tw.map | 6865 ++++ src/backend/utils/mb/Unicode/utf8_to_gb18030.map | 9561 ++++++ src/backend/utils/mb/Unicode/utf8_to_gbk.map | 4271 +++ .../utils/mb/Unicode/utf8_to_iso8859_10.map | 114 + .../utils/mb/Unicode/utf8_to_iso8859_13.map | 113 + .../utils/mb/Unicode/utf8_to_iso8859_14.map | 146 + .../utils/mb/Unicode/utf8_to_iso8859_15.map | 101 + .../utils/mb/Unicode/utf8_to_iso8859_16.map | 131 + src/backend/utils/mb/Unicode/utf8_to_iso8859_2.map | 114 + src/backend/utils/mb/Unicode/utf8_to_iso8859_3.map | 113 + src/backend/utils/mb/Unicode/utf8_to_iso8859_4.map | 114 + src/backend/utils/mb/Unicode/utf8_to_iso8859_5.map | 103 + src/backend/utils/mb/Unicode/utf8_to_iso8859_6.map | 90 + src/backend/utils/mb/Unicode/utf8_to_iso8859_7.map | 125 + src/backend/utils/mb/Unicode/utf8_to_iso8859_8.map | 104 + src/backend/utils/mb/Unicode/utf8_to_iso8859_9.map | 100 + src/backend/utils/mb/Unicode/utf8_to_johab.map | 6333 ++++ src/backend/utils/mb/Unicode/utf8_to_koi8r.map | 175 + src/backend/utils/mb/Unicode/utf8_to_koi8u.map | 186 + .../utils/mb/Unicode/utf8_to_shift_jis_2004.map | 7685 +++++ src/backend/utils/mb/Unicode/utf8_to_sjis.map | 4253 +++ src/backend/utils/mb/Unicode/utf8_to_uhc.map | 6377 ++++ src/backend/utils/mb/Unicode/utf8_to_win1250.map | 145 + src/backend/utils/mb/Unicode/utf8_to_win1251.map | 134 + src/backend/utils/mb/Unicode/utf8_to_win1252.map | 146 + src/backend/utils/mb/Unicode/utf8_to_win1253.map | 135 + src/backend/utils/mb/Unicode/utf8_to_win1254.map | 157 + src/backend/utils/mb/Unicode/utf8_to_win1255.map | 157 + src/backend/utils/mb/Unicode/utf8_to_win1256.map | 194 + src/backend/utils/mb/Unicode/utf8_to_win1257.map | 145 + src/backend/utils/mb/Unicode/utf8_to_win1258.map | 167 + src/backend/utils/mb/Unicode/utf8_to_win866.map | 154 + src/backend/utils/mb/Unicode/utf8_to_win874.map | 130 + src/backend/utils/mb/Unicode/win1250_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1251_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1252_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1253_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1254_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1255_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1256_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1257_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win1258_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win866_to_utf8.map | 111 + src/backend/utils/mb/Unicode/win874_to_utf8.map | 109 + 93 files changed, 203271 insertions(+) create mode 100644 src/backend/utils/mb/Unicode/Makefile create mode 100755 src/backend/utils/mb/Unicode/UCS_to_BIG5.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_GB18030.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_SJIS.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_UHC.pl create mode 100755 src/backend/utils/mb/Unicode/UCS_to_most.pl create mode 100644 src/backend/utils/mb/Unicode/big5_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/convutils.pm create mode 100644 src/backend/utils/mb/Unicode/euc-jis-2004-std.txt create mode 100644 src/backend/utils/mb/Unicode/euc_cn_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/euc_jis_2004_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/euc_jp_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/euc_kr_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/euc_tw_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/gb-18030-2000.xml create mode 100644 src/backend/utils/mb/Unicode/gb18030_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/gbk_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_10_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_13_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_14_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_15_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_16_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_2_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_3_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_4_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_5_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_6_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_7_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_8_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/iso8859_9_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/johab_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/koi8r_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/koi8u_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/shift_jis_2004_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/sjis-0213-2004-std.txt create mode 100644 src/backend/utils/mb/Unicode/sjis_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/uhc_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_big5.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_euc_cn.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_euc_jis_2004.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_euc_jp.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_euc_kr.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_euc_tw.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_gb18030.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_gbk.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_10.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_13.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_14.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_15.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_16.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_2.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_3.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_4.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_5.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_6.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_7.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_8.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_iso8859_9.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_johab.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_koi8r.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_koi8u.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_shift_jis_2004.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_sjis.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_uhc.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1250.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1251.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1252.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1253.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1254.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1255.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1256.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1257.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win1258.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win866.map create mode 100644 src/backend/utils/mb/Unicode/utf8_to_win874.map create mode 100644 src/backend/utils/mb/Unicode/win1250_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1251_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1252_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1253_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1254_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1255_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1256_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1257_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win1258_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win866_to_utf8.map create mode 100644 src/backend/utils/mb/Unicode/win874_to_utf8.map (limited to 'src/backend/utils/mb/Unicode') diff --git a/src/backend/utils/mb/Unicode/Makefile b/src/backend/utils/mb/Unicode/Makefile new file mode 100644 index 0000000..ed6fc07 --- /dev/null +++ b/src/backend/utils/mb/Unicode/Makefile @@ -0,0 +1,146 @@ +#------------------------------------------------------------------------- +# +# Makefile for src/backend/utils/mb/Unicode +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/Makefile +# +#------------------------------------------------------------------------- + +subdir = src/backend/utils/mb/Unicode +top_builddir = ../../../../.. +include $(top_builddir)/src/Makefile.global + +ISO8859MAPS = iso8859_2_to_utf8.map utf8_to_iso8859_2.map \ + iso8859_3_to_utf8.map utf8_to_iso8859_3.map \ + iso8859_4_to_utf8.map utf8_to_iso8859_4.map \ + iso8859_5_to_utf8.map utf8_to_iso8859_5.map \ + iso8859_6_to_utf8.map utf8_to_iso8859_6.map \ + iso8859_7_to_utf8.map utf8_to_iso8859_7.map \ + iso8859_8_to_utf8.map utf8_to_iso8859_8.map \ + iso8859_9_to_utf8.map utf8_to_iso8859_9.map \ + iso8859_10_to_utf8.map utf8_to_iso8859_10.map \ + iso8859_13_to_utf8.map utf8_to_iso8859_13.map \ + iso8859_14_to_utf8.map utf8_to_iso8859_14.map \ + iso8859_15_to_utf8.map utf8_to_iso8859_15.map \ + iso8859_16_to_utf8.map utf8_to_iso8859_16.map + +WINMAPS = win866_to_utf8.map utf8_to_win866.map \ + win874_to_utf8.map utf8_to_win874.map \ + win1250_to_utf8.map utf8_to_win1250.map \ + win1251_to_utf8.map utf8_to_win1251.map \ + win1252_to_utf8.map utf8_to_win1252.map \ + win1253_to_utf8.map utf8_to_win1253.map \ + win1254_to_utf8.map utf8_to_win1254.map \ + win1255_to_utf8.map utf8_to_win1255.map \ + win1256_to_utf8.map utf8_to_win1256.map \ + win1257_to_utf8.map utf8_to_win1257.map \ + win1258_to_utf8.map utf8_to_win1258.map + +GENERICMAPS = $(ISO8859MAPS) $(WINMAPS) \ + gbk_to_utf8.map utf8_to_gbk.map \ + koi8r_to_utf8.map utf8_to_koi8r.map \ + koi8u_to_utf8.map utf8_to_koi8u.map + +SPECIALMAPS = euc_cn_to_utf8.map utf8_to_euc_cn.map \ + euc_jp_to_utf8.map utf8_to_euc_jp.map \ + euc_kr_to_utf8.map utf8_to_euc_kr.map \ + euc_tw_to_utf8.map utf8_to_euc_tw.map \ + sjis_to_utf8.map utf8_to_sjis.map \ + gb18030_to_utf8.map utf8_to_gb18030.map \ + big5_to_utf8.map utf8_to_big5.map \ + johab_to_utf8.map utf8_to_johab.map \ + uhc_to_utf8.map utf8_to_uhc.map \ + euc_jis_2004_to_utf8.map utf8_to_euc_jis_2004.map \ + shift_jis_2004_to_utf8.map utf8_to_shift_jis_2004.map + +MAPS = $(GENERICMAPS) $(SPECIALMAPS) + +ISO8859TEXTS = 8859-2.TXT 8859-3.TXT 8859-4.TXT 8859-5.TXT \ + 8859-6.TXT 8859-7.TXT 8859-8.TXT 8859-9.TXT \ + 8859-10.TXT 8859-13.TXT 8859-14.TXT 8859-15.TXT \ + 8859-16.TXT + +WINTEXTS = CP866.TXT CP874.TXT CP936.TXT \ + CP1250.TXT CP1251.TXT \ + CP1252.TXT CP1253.TXT CP1254.TXT CP1255.TXT \ + CP1256.TXT CP1257.TXT CP1258.TXT + +GENERICTEXTS = $(ISO8859TEXTS) $(WINTEXTS) \ + KOI8-R.TXT KOI8-U.TXT + +all: $(MAPS) + +$(GENERICMAPS): UCS_to_most.pl $(GENERICTEXTS) + $(PERL) -I $(srcdir) $< + +johab_to_utf8.map utf8_to_johab.map: UCS_to_JOHAB.pl JOHAB.TXT + $(PERL) -I $(srcdir) $< + +uhc_to_utf8.map utf8_to_uhc.map: UCS_to_UHC.pl windows-949-2000.xml + $(PERL) -I $(srcdir) $< + +euc_jp_to_utf8.map utf8_to_euc_jp.map: UCS_to_EUC_JP.pl CP932.TXT JIS0212.TXT + $(PERL) -I $(srcdir) $< + +euc_cn_to_utf8.map utf8_to_euc_cn.map: UCS_to_EUC_CN.pl gb-18030-2000.xml + $(PERL) -I $(srcdir) $< + +euc_kr_to_utf8.map utf8_to_euc_kr.map: UCS_to_EUC_KR.pl KSX1001.TXT + $(PERL) -I $(srcdir) $< + +euc_tw_to_utf8.map utf8_to_euc_tw.map: UCS_to_EUC_TW.pl CNS11643.TXT + $(PERL) -I $(srcdir) $< + +sjis_to_utf8.map utf8_to_sjis.map: UCS_to_SJIS.pl CP932.TXT + $(PERL) -I $(srcdir) $< + +gb18030_to_utf8.map utf8_to_gb18030.map: UCS_to_GB18030.pl gb-18030-2000.xml + $(PERL) -I $(srcdir) $< + +big5_to_utf8.map utf8_to_big5.map: UCS_to_BIG5.pl BIG5.TXT CP950.TXT + $(PERL) -I $(srcdir) $< + +euc_jis_2004_to_utf8.map utf8_to_euc_jis_2004.map: UCS_to_EUC_JIS_2004.pl euc-jis-2004-std.txt + $(PERL) -I $(srcdir) $< + +shift_jis_2004_to_utf8.map utf8_to_shift_jis_2004.map: UCS_to_SHIFT_JIS_2004.pl sjis-0213-2004-std.txt + $(PERL) -I $(srcdir) $< + +distclean: clean + rm -f $(TEXTS) + +maintainer-clean: distclean + rm -f $(MAPS) + + +BIG5.TXT CNS11643.TXT: + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/$(@F) + +euc-jis-2004-std.txt sjis-0213-2004-std.txt: + $(DOWNLOAD) http://x0213.org/codetable/$(@F) + +gb-18030-2000.xml windows-949-2000.xml: + $(DOWNLOAD) https://raw.githubusercontent.com/unicode-org/icu-data/master/charset/data/xml/$(@F) + +GB2312.TXT: + $(DOWNLOAD) 'http://trac.greenstone.org/browser/trunk/gsdl/unicode/MAPPINGS/EASTASIA/GB/GB2312.TXT?rev=1842&format=txt' + +JIS0212.TXT: + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/$(@F) + +JOHAB.TXT KSX1001.TXT: + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/KSC/$(@F) + +KOI8-R.TXT KOI8-U.TXT: + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/VENDORS/MISC/$(@F) + +$(ISO8859TEXTS): + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/ISO8859/$(@F) + +$(filter-out CP8%,$(WINTEXTS)) CP932.TXT CP950.TXT: + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/$(@F) + +$(filter CP8%,$(WINTEXTS)): + $(DOWNLOAD) https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/$(@F) diff --git a/src/backend/utils/mb/Unicode/UCS_to_BIG5.pl b/src/backend/utils/mb/Unicode/UCS_to_BIG5.pl new file mode 100755 index 0000000..67b6b43 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_BIG5.pl @@ -0,0 +1,79 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_BIG5.pl +# +# Generate UTF-8 <--> BIG5 conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain the map files from the organization's download site. +# https://www.unicode.org/Public/MAPPINGS/ +# +# Our "big5" comes from BIG5.TXT, with the addition of the characters +# in the range 0xf9d6-0xf9dc from CP950.TXT. +# +# BIG5.TXT format: +# BIG5 code in hex +# UCS-2 code in hex +# # and Unicode name (not used in this script) +# +# CP950.TXT format: +# CP950 code in hex +# UCS-2 code in hex +# # and Unicode name (not used in this script) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_BIG5.pl'; + +# Load BIG5.TXT +my $all = &read_source("BIG5.TXT"); + +# Load CP950.TXT +my $cp950txt = &read_source("CP950.TXT"); + +foreach my $i (@$cp950txt) +{ + my $code = $i->{code}; + my $ucs = $i->{ucs}; + + # Pick only the ETEN extended characters in the range 0xf9d6 - 0xf9dc + # from CP950.TXT + if ( $code >= 0x80 + && $ucs >= 0x0080 + && $code >= 0xf9d6 + && $code <= 0xf9dc) + { + push @$all, + { + code => $code, + ucs => $ucs, + comment => $i->{comment}, + direction => BOTH, + f => $i->{f}, + l => $i->{l} + }; + } +} + +foreach my $i (@$all) +{ + my $code = $i->{code}; + my $ucs = $i->{ucs}; + + # BIG5.TXT maps several BIG5 characters to U+FFFD. The UTF-8 to BIG5 mapping can + # contain only one of them. XXX: Doesn't really make sense to include any of them, + # but for historical reasons, we map the first one of them. + if ($i->{ucs} == 0xFFFD && $i->{code} != 0xA15A) + { + $i->{direction} = TO_UNICODE; + } +} + +# Output +print_conversion_tables($this_script, "BIG5", $all); diff --git a/src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl b/src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl new file mode 100755 index 0000000..88c561b --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl @@ -0,0 +1,85 @@ +#! /usr/bin/perl +# +# Copyright (c) 2007-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_GB18030.pl +# +# Generate UTF-8 <--> GB18030 code conversion tables from +# "gb-18030-2000.xml", obtained from +# http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/ +# +# The lines we care about in the source file look like +# +# where the "u" field is the Unicode code point in hex, +# and the "b" field is the hex byte sequence for GB18030 + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_EUC_CN.pl'; + +# Read the input + +my $in_file = "gb-18030-2000.xml"; + +open(my $in, '<', $in_file) || die("cannot open $in_file"); + +my @mapping; + +while (<$in>) +{ + next if (!m/= 0xA100 && $code <= 0xA9FF + || $code >= 0xB000 && $code <= 0xF7FF)); + + next if ($code >= 0xA2A1 && $code <= 0xA2B0); + next if ($code >= 0xA2E3 && $code <= 0xA2E4); + next if ($code >= 0xA2EF && $code <= 0xA2F0); + next if ($code >= 0xA2FD && $code <= 0xA2FE); + next if ($code >= 0xA4F4 && $code <= 0xA4FE); + next if ($code >= 0xA5F7 && $code <= 0xA5FE); + next if ($code >= 0xA6B9 && $code <= 0xA6C0); + next if ($code >= 0xA6D9 && $code <= 0xA6FE); + next if ($code >= 0xA7C2 && $code <= 0xA7D0); + next if ($code >= 0xA7F2 && $code <= 0xA7FE); + next if ($code >= 0xA8BB && $code <= 0xA8C4); + next if ($code >= 0xA8EA && $code <= 0xA8FE); + next if ($code >= 0xA9A1 && $code <= 0xA9A3); + next if ($code >= 0xA9F0 && $code <= 0xA9FE); + next if ($code >= 0xD7FA && $code <= 0xD7FE); + + # A couple of characters are mapped differently from GB-2312 or GB-18030 + if ($code == 0xA1A4) + { + $ucs = 0x30FB; + } + if ($code == 0xA1AA) + { + $ucs = 0x2015; + } + + push @mapping, + { + ucs => $ucs, + code => $code, + direction => BOTH, + f => $in_file, + l => $. + }; +} +close($in); + +print_conversion_tables($this_script, "EUC_CN", \@mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl b/src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl new file mode 100755 index 0000000..ea558db --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl @@ -0,0 +1,72 @@ +#! /usr/bin/perl +# +# Copyright (c) 2007-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl +# +# Generate UTF-8 <--> EUC_JIS_2004 code conversion tables from +# "euc-jis-2004-std.txt" (http://x0213.org) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_EUC_JIS_2004.pl'; + +# first generate UTF-8 --> EUC_JIS_2004 table + +my $in_file = "euc-jis-2004-std.txt"; + +open(my $in, '<', $in_file) || die("cannot open $in_file"); + +my @all; + +while (my $line = <$in>) +{ + if ($line =~ /^0x(\w+)\s*U\+(\w+)\+(\w+)\s*#\s*(\S.*)?\s*$/) + { + + # combined characters + my ($c, $u1, $u2) = ($1, $2, $3); + # The "\t \t" below is just to avoid insubstantial diffs. + my $rest = "U+" . $u1 . "+" . $u2 . "\t \t" . $4; + my $code = hex($c); + my $ucs1 = hex($u1); + my $ucs2 = hex($u2); + + push @all, + { + direction => BOTH, + ucs => $ucs1, + ucs_second => $ucs2, + code => $code, + comment => $rest, + f => $in_file, + l => $. + }; + } + elsif ($line =~ /^0x(\w+)\s*U\+(\w+)\s*#\s*(\S.*)?\s*$/) + { + + # non-combined characters + my ($c, $u, $rest) = ($1, $2, "U+" . $2 . $3); + my $ucs = hex($u); + my $code = hex($c); + + next if ($code < 0x80 && $ucs < 0x80); + + push @all, + { + direction => BOTH, + ucs => $ucs, + code => $code, + comment => $rest, + f => $in_file, + l => $. + }; + } +} +close($in); + +print_conversion_tables($this_script, "EUC_JIS_2004", \@all); diff --git a/src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl b/src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl new file mode 100755 index 0000000..bd50f63 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl @@ -0,0 +1,678 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl +# +# Generate UTF-8 <--> EUC_JP code conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain CP932.TXT and JIS0212.TXT from the +# organization's ftp site. + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_EUC_JP.pl'; + +# Load JIS0212.TXT +my $jis0212 = &read_source("JIS0212.TXT"); + +my @mapping; + +foreach my $i (@$jis0212) +{ + + # We have a different mapping for this in the EUC_JP to UTF-8 direction. + if ($i->{code} == 0x2243) + { + $i->{direction} = FROM_UNICODE; + } + + if ($i->{code} == 0x2271) + { + $i->{direction} = TO_UNICODE; + } + + if ($i->{ucs} >= 0x080) + { + $i->{code} = $i->{code} | 0x8f8080; + } + else + { + next; + } + + push @mapping, $i; +} + +# Load CP932.TXT. +my $ct932 = &read_source("CP932.TXT"); + +foreach my $i (@$ct932) +{ + my $sjis = $i->{code}; + + # We have a different mapping for this in the EUC_JP to UTF-8 direction. + if ( $sjis == 0xeefa + || $sjis == 0xeefb + || $sjis == 0xeefc) + { + next; + } + + if ($sjis >= 0xa1) + { + my $jis = &sjis2jis($sjis); + + $i->{code} = $jis | ( + $jis < 0x100 + ? 0x8e00 + : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080)); + + # Remember the SJIS code for later. + $i->{sjis} = $sjis; + + push @mapping, $i; + } +} + +# extract only SJIS characters +foreach my $i (grep defined $_->{sjis}, @mapping) +{ + my $sjis = $i->{sjis}; + + # These SJIS characters are excluded completely. + if ( $sjis >= 0xed00 && $sjis <= 0xeef9 + || $sjis >= 0xfa54 && $sjis <= 0xfa56 + || $sjis >= 0xfa58 && $sjis <= 0xfc4b) + { + $i->{direction} = NONE; + next; + } + + # These SJIS characters are only in the UTF-8 to EUC_JP table + if ($sjis == 0xeefa || $sjis == 0xeefb || $sjis == 0xeefc) + { + $i->{direction} = FROM_UNICODE; + next; + } + + if ( $sjis == 0x8790 + || $sjis == 0x8791 + || $sjis == 0x8792 + || $sjis == 0x8795 + || $sjis == 0x8796 + || $sjis == 0x8797 + || $sjis == 0x879a + || $sjis == 0x879b + || $sjis == 0x879c + || ($sjis >= 0xfa4a && $sjis <= 0xfa53)) + { + $i->{direction} = TO_UNICODE; + next; + } +} + +push @mapping, ( + { + direction => BOTH, + ucs => 0x4efc, + code => 0x8ff4af, + comment => '# CJK(4EFC)' + }, + { + direction => BOTH, + ucs => 0x50f4, + code => 0x8ff4b0, + comment => '# CJK(50F4)' + }, + { + direction => BOTH, + ucs => 0x51EC, + code => 0x8ff4b1, + comment => '# CJK(51EC)' + }, + { + direction => BOTH, + ucs => 0x5307, + code => 0x8ff4b2, + comment => '# CJK(5307)' + }, + { + direction => BOTH, + ucs => 0x5324, + code => 0x8ff4b3, + comment => '# CJK(5324)' + }, + { + direction => BOTH, + ucs => 0x548A, + code => 0x8ff4b5, + comment => '# CJK(548A)' + }, + { + direction => BOTH, + ucs => 0x5759, + code => 0x8ff4b6, + comment => '# CJK(5759)' + }, + { + direction => BOTH, + ucs => 0x589E, + code => 0x8ff4b9, + comment => '# CJK(589E)' + }, + { + direction => BOTH, + ucs => 0x5BEC, + code => 0x8ff4ba, + comment => '# CJK(5BEC)' + }, + { + direction => BOTH, + ucs => 0x5CF5, + code => 0x8ff4bb, + comment => '# CJK(5CF5)' + }, + { + direction => BOTH, + ucs => 0x5D53, + code => 0x8ff4bc, + comment => '# CJK(5D53)' + }, + { + direction => BOTH, + ucs => 0x5FB7, + code => 0x8ff4be, + comment => '# CJK(5FB7)' + }, + { + direction => BOTH, + ucs => 0x6085, + code => 0x8ff4bf, + comment => '# CJK(6085)' + }, + { + direction => BOTH, + ucs => 0x6120, + code => 0x8ff4c0, + comment => '# CJK(6120)' + }, + { + direction => BOTH, + ucs => 0x654E, + code => 0x8ff4c1, + comment => '# CJK(654E)' + }, + { + direction => BOTH, + ucs => 0x663B, + code => 0x8ff4c2, + comment => '# CJK(663B)' + }, + { + direction => BOTH, + ucs => 0x6665, + code => 0x8ff4c3, + comment => '# CJK(6665)' + }, + { + direction => BOTH, + ucs => 0x6801, + code => 0x8ff4c6, + comment => '# CJK(6801)' + }, + { + direction => BOTH, + ucs => 0x6A6B, + code => 0x8ff4c9, + comment => '# CJK(6A6B)' + }, + { + direction => BOTH, + ucs => 0x6AE2, + code => 0x8ff4ca, + comment => '# CJK(6AE2)' + }, + { + direction => BOTH, + ucs => 0x6DF2, + code => 0x8ff4cc, + comment => '# CJK(6DF2)' + }, + { + direction => BOTH, + ucs => 0x6DF8, + code => 0x8ff4cb, + comment => '# CJK(6DF8)' + }, + { + direction => BOTH, + ucs => 0x7028, + code => 0x8ff4cd, + comment => '# CJK(7028)' + }, + { + direction => BOTH, + ucs => 0x70BB, + code => 0x8ff4ae, + comment => '# CJK(70BB)' + }, + { + direction => BOTH, + ucs => 0x7501, + code => 0x8ff4d0, + comment => '# CJK(7501)' + }, + { + direction => BOTH, + ucs => 0x7682, + code => 0x8ff4d1, + comment => '# CJK(7682)' + }, + { + direction => BOTH, + ucs => 0x769E, + code => 0x8ff4d2, + comment => '# CJK(769E)' + }, + { + direction => BOTH, + ucs => 0x7930, + code => 0x8ff4d4, + comment => '# CJK(7930)' + }, + { + direction => BOTH, + ucs => 0x7AE7, + code => 0x8ff4d9, + comment => '# CJK(7AE7)' + }, + { + direction => BOTH, + ucs => 0x7DA0, + code => 0x8ff4dc, + comment => '# CJK(7DA0)' + }, + { + direction => BOTH, + ucs => 0x7DD6, + code => 0x8ff4dd, + comment => '# CJK(7DD6)' + }, + { + direction => BOTH, + ucs => 0x8362, + code => 0x8ff4df, + comment => '# CJK(8362)' + }, + { + direction => BOTH, + ucs => 0x85B0, + code => 0x8ff4e1, + comment => '# CJK(85B0)' + }, + { + direction => BOTH, + ucs => 0x8807, + code => 0x8ff4e4, + comment => '# CJK(8807)' + }, + { + direction => BOTH, + ucs => 0x8B7F, + code => 0x8ff4e6, + comment => '# CJK(8B7F)' + }, + { + direction => BOTH, + ucs => 0x8CF4, + code => 0x8ff4e7, + comment => '# CJK(8CF4)' + }, + { + direction => BOTH, + ucs => 0x8D76, + code => 0x8ff4e8, + comment => '# CJK(8D76)' + }, + { + direction => BOTH, + ucs => 0x90DE, + code => 0x8ff4ec, + comment => '# CJK(90DE)' + }, + { + direction => BOTH, + ucs => 0x9115, + code => 0x8ff4ee, + comment => '# CJK(9115)' + }, + { + direction => BOTH, + ucs => 0x9592, + code => 0x8ff4f1, + comment => '# CJK(9592)' + }, + { + direction => BOTH, + ucs => 0x973B, + code => 0x8ff4f4, + comment => '# CJK(973B)' + }, + { + direction => BOTH, + ucs => 0x974D, + code => 0x8ff4f5, + comment => '# CJK(974D)' + }, + { + direction => BOTH, + ucs => 0x9751, + code => 0x8ff4f6, + comment => '# CJK(9751)' + }, + { + direction => BOTH, + ucs => 0x999E, + code => 0x8ff4fa, + comment => '# CJK(999E)' + }, + { + direction => BOTH, + ucs => 0x9AD9, + code => 0x8ff4fb, + comment => '# CJK(9AD9)' + }, + { + direction => BOTH, + ucs => 0x9B72, + code => 0x8ff4fc, + comment => '# CJK(9B72)' + }, + { + direction => BOTH, + ucs => 0x9ED1, + code => 0x8ff4fe, + comment => '# CJK(9ED1)' + }, + { + direction => BOTH, + ucs => 0xF929, + code => 0x8ff4c5, + comment => '# CJK COMPATIBILITY IDEOGRAPH-F929' + }, + { + direction => BOTH, + ucs => 0xF9DC, + code => 0x8ff4f2, + comment => '# CJK COMPATIBILITY IDEOGRAPH-F9DC' + }, + { + direction => BOTH, + ucs => 0xFA0E, + code => 0x8ff4b4, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA0E' + }, + { + direction => BOTH, + ucs => 0xFA0F, + code => 0x8ff4b7, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA0F' + }, + { + direction => BOTH, + ucs => 0xFA10, + code => 0x8ff4b8, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA10' + }, + { + direction => BOTH, + ucs => 0xFA11, + code => 0x8ff4bd, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA11' + }, + { + direction => BOTH, + ucs => 0xFA12, + code => 0x8ff4c4, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA12' + }, + { + direction => BOTH, + ucs => 0xFA13, + code => 0x8ff4c7, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA13' + }, + { + direction => BOTH, + ucs => 0xFA14, + code => 0x8ff4c8, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA14' + }, + { + direction => BOTH, + ucs => 0xFA15, + code => 0x8ff4ce, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA15' + }, + { + direction => BOTH, + ucs => 0xFA16, + code => 0x8ff4cf, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA16' + }, + { + direction => BOTH, + ucs => 0xFA17, + code => 0x8ff4d3, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA17' + }, + { + direction => BOTH, + ucs => 0xFA18, + code => 0x8ff4d5, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA18' + }, + { + direction => BOTH, + ucs => 0xFA19, + code => 0x8ff4d6, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA19' + }, + { + direction => BOTH, + ucs => 0xFA1A, + code => 0x8ff4d7, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1A' + }, + { + direction => BOTH, + ucs => 0xFA1B, + code => 0x8ff4d8, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1B' + }, + { + direction => BOTH, + ucs => 0xFA1C, + code => 0x8ff4da, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1C' + }, + { + direction => BOTH, + ucs => 0xFA1D, + code => 0x8ff4db, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1D' + }, + { + direction => BOTH, + ucs => 0xFA1E, + code => 0x8ff4de, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1E' + }, + { + direction => BOTH, + ucs => 0xFA1F, + code => 0x8ff4e0, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA1F' + }, + { + direction => BOTH, + ucs => 0xFA20, + code => 0x8ff4e2, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA20' + }, + { + direction => BOTH, + ucs => 0xFA21, + code => 0x8ff4e3, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA21' + }, + { + direction => BOTH, + ucs => 0xFA22, + code => 0x8ff4e5, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA22' + }, + { + direction => BOTH, + ucs => 0xFA23, + code => 0x8ff4e9, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA23' + }, + { + direction => BOTH, + ucs => 0xFA24, + code => 0x8ff4ea, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA24' + }, + { + direction => BOTH, + ucs => 0xFA25, + code => 0x8ff4eb, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA25' + }, + { + direction => BOTH, + ucs => 0xFA26, + code => 0x8ff4ed, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA26' + }, + { + direction => BOTH, + ucs => 0xFA27, + code => 0x8ff4ef, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA27' + }, + { + direction => BOTH, + ucs => 0xFA28, + code => 0x8ff4f0, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA28' + }, + { + direction => BOTH, + ucs => 0xFA29, + code => 0x8ff4f3, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA29' + }, + { + direction => BOTH, + ucs => 0xFA2A, + code => 0x8ff4f7, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA2A' + }, + { + direction => BOTH, + ucs => 0xFA2B, + code => 0x8ff4f8, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA2B' + }, + { + direction => BOTH, + ucs => 0xFA2C, + code => 0x8ff4f9, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA2C' + }, + { + direction => BOTH, + ucs => 0xFA2D, + code => 0x8ff4fd, + comment => '# CJK COMPATIBILITY IDEOGRAPH-FA2D' + }, + { + direction => BOTH, + ucs => 0xFF07, + code => 0x8ff4a9, + comment => '# FULLWIDTH APOSTROPHE' + }, + { + direction => BOTH, + ucs => 0xFFE4, + code => 0x8fa2c3, + comment => '# FULLWIDTH BROKEN BAR' + }, + + # additional conversions for EUC_JP -> UTF-8 conversion + { + direction => TO_UNICODE, + ucs => 0x2116, + code => 0x8ff4ac, + comment => '# NUMERO SIGN' + }, + { + direction => TO_UNICODE, + ucs => 0x2121, + code => 0x8ff4ad, + comment => '# TELEPHONE SIGN' + }, + { + direction => TO_UNICODE, + ucs => 0x3231, + code => 0x8ff4ab, + comment => '# PARENTHESIZED IDEOGRAPH STOCK' + }); + +print_conversion_tables($this_script, "EUC_JP", \@mapping); + + +####################################################################### +# sjis2jis ; SJIS => JIS conversion +sub sjis2jis +{ + my ($sjis) = @_; + + return $sjis if ($sjis <= 0x100); + + my $hi = $sjis >> 8; + my $lo = $sjis & 0xff; + + if ($lo >= 0x80) { $lo--; } + $lo -= 0x40; + if ($hi >= 0xe0) { $hi -= 0x40; } + $hi -= 0x81; + my $pos = $lo + $hi * 0xbc; + + if ($pos >= 114 * 0x5e && $pos <= 115 * 0x5e + 0x1b) + { + + # This region (115-ku) is out of range of JIS code but for + # convenient to generate code in EUC CODESET 3, move this to + # seemingly duplicate region (83-84-ku). + $pos = $pos - ((31 * 0x5e) + 12); + + # after 85-ku 82-ten needs to be moved 2 codepoints + $pos = $pos - 2 if ($pos >= 84 * 0x5c + 82); + } + + my $hi2 = $pos / 0x5e; + my $lo2 = ($pos % 0x5e); + + my $ret = $lo2 + 0x21 + (($hi2 + 0x21) << 8); + + return $ret; +} diff --git a/src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl b/src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl new file mode 100755 index 0000000..a037493 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl @@ -0,0 +1,62 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl +# +# Generate UTF-8 <--> EUC_KR code conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain OLD5601.TXT from +# the organization's ftp site. +# +# OLD5601.TXT format: +# KSC5601 code in hex +# UCS-2 code in hex +# # and Unicode name (not used in this script) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_EUC_KR.pl'; + +# Load the source file. + +my $mapping = &read_source("KSX1001.TXT"); + +foreach my $i (@$mapping) +{ + $i->{code} = $i->{code} | 0x8080; +} + +# Some extra characters that are not in KSX1001.TXT +push @$mapping, + ( { + direction => BOTH, + ucs => 0x20AC, + code => 0xa2e6, + comment => '# EURO SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => BOTH, + ucs => 0x00AE, + code => 0xa2e7, + comment => '# REGISTERED SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => BOTH, + ucs => 0x327E, + code => 0xa2e8, + comment => '# CIRCLED HANGUL IEUNG U', + f => $this_script, + l => __LINE__ + }); + +print_conversion_tables($this_script, "EUC_KR", $mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl b/src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl new file mode 100755 index 0000000..7f49be8 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl @@ -0,0 +1,71 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl +# +# Generate UTF-8 <--> EUC_TW code conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain CNS11643.TXT from +# the organization's ftp site. +# +# CNS11643.TXT format: +# CNS11643 code in hex (3 bytes) +# (I guess the first byte means the plane No.) +# UCS-2 code in hex +# # and Unicode name (not used in this script) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_EUC_TW.pl'; + +my $mapping = &read_source("CNS11643.TXT"); + +my @extras; + +foreach my $i (@$mapping) +{ + my $ucs = $i->{ucs}; + my $code = $i->{code}; + my $origcode = $i->{code}; + + my $plane = ($code & 0x1f0000) >> 16; + if ($plane > 16) + { + printf STDERR "Warning: invalid plane No.$plane. ignored\n"; + next; + } + + if ($plane == 1) + { + $code = ($code & 0xffff) | 0x8080; + } + else + { + $code = (0x8ea00000 + ($plane << 16)) | (($code & 0xffff) | 0x8080); + } + $i->{code} = $code; + + # Some codes are mapped twice in the EUC_TW to UTF-8 table. + if ($origcode >= 0x12121 && $origcode <= 0x20000) + { + push @extras, + { + ucs => $i->{ucs}, + code => ($i->{code} + 0x8ea10000), + rest => $i->{rest}, + direction => TO_UNICODE, + f => $i->{f}, + l => $i->{l} + }; + } +} + +push @$mapping, @extras; + +print_conversion_tables($this_script, "EUC_TW", $mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_GB18030.pl b/src/backend/utils/mb/Unicode/UCS_to_GB18030.pl new file mode 100755 index 0000000..61c4797 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_GB18030.pl @@ -0,0 +1,52 @@ +#! /usr/bin/perl +# +# Copyright (c) 2007-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_GB18030.pl +# +# Generate UTF-8 <--> GB18030 code conversion tables from +# "gb-18030-2000.xml", obtained from +# http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/ +# +# The lines we care about in the source file look like +# +# where the "u" field is the Unicode code point in hex, +# and the "b" field is the hex byte sequence for GB18030 + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_GB18030.pl'; + +# Read the input + +my $in_file = "gb-18030-2000.xml"; + +open(my $in, '<', $in_file) || die("cannot open $in_file"); + +my @mapping; + +while (<$in>) +{ + next if (!m/= 0x80 && $ucs >= 0x0080) + { + push @mapping, + { + ucs => $ucs, + code => $code, + direction => BOTH, + f => $in_file, + l => $. + }; + } +} +close($in); + +print_conversion_tables($this_script, "GB18030", \@mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl b/src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl new file mode 100755 index 0000000..0f4bfe8 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl @@ -0,0 +1,56 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl +# +# Generate UTF-8 <--> JOHAB conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain the map files from the organization's download site. +# https://www.unicode.org/Public/MAPPINGS/ +# We assume the file include three tab-separated columns: +# JOHAB code in hex +# UCS-2 code in hex +# # and Unicode name (not used in this script) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_JOHAB.pl'; + +# Load the source file. + +my $mapping = &read_source("JOHAB.TXT"); + +# Some extra characters that are not in JOHAB.TXT +push @$mapping, + ( { + direction => BOTH, + ucs => 0x20AC, + code => 0xd9e6, + comment => '# EURO SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => BOTH, + ucs => 0x00AE, + code => 0xd9e7, + comment => '# REGISTERED SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => BOTH, + ucs => 0x327E, + code => 0xd9e8, + comment => '# CIRCLED HANGUL IEUNG U', + f => $this_script, + l => __LINE__ + }); + +print_conversion_tables($this_script, "JOHAB", $mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl b/src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl new file mode 100755 index 0000000..710d5ce --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl @@ -0,0 +1,88 @@ +#! /usr/bin/perl +# +# Copyright (c) 2007-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl +# +# Generate UTF-8 <--> SHIFT_JIS_2004 code conversion tables from +# "sjis-0213-2004-std.txt" (http://x0213.org) + +use strict; +use warnings; + +use convutils; + +# first generate UTF-8 --> SHIFT_JIS_2004 table + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_SHIFT_JIS_2004.pl'; + +my $in_file = "sjis-0213-2004-std.txt"; + +open(my $in, '<', $in_file) || die("cannot open $in_file"); + +my @mapping; + +while (my $line = <$in>) +{ + if ($line =~ /^0x(\w+)\s*U\+(\w+)\+(\w+)\s*#\s*(\S.*)?\s*$/) + { + + # combined characters + my ($c, $u1, $u2) = ($1, $2, $3); + # The "\t \t" below is just to avoid insubstantial diffs. + my $rest = "U+" . $u1 . "+" . $u2 . "\t \t" . $4; + my $code = hex($c); + my $ucs1 = hex($u1); + my $ucs2 = hex($u2); + + push @mapping, + { + code => $code, + ucs => $ucs1, + ucs_second => $ucs2, + comment => $rest, + direction => BOTH, + f => $in_file, + l => $. + }; + } + elsif ($line =~ /^0x(\w+)\s*U\+(\w+)\s*#\s*(\S.*)?\s*$/) + { + + # non-combined characters + my ($c, $u, $rest) = ($1, $2, "U+" . $2 . $3); + my $ucs = hex($u); + my $code = hex($c); + my $direction; + + if ($code < 0x80 && $ucs < 0x80) + { + next; + } + elsif ($code < 0x80) + { + $direction = FROM_UNICODE; + } + elsif ($ucs < 0x80) + { + $direction = TO_UNICODE; + } + else + { + $direction = BOTH; + } + + push @mapping, + { + code => $code, + ucs => $ucs, + comment => $rest, + direction => $direction, + f => $in_file, + l => $. + }; + } +} +close($in); + +print_conversion_tables($this_script, "SHIFT_JIS_2004", \@mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl new file mode 100755 index 0000000..bb1f51c --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl @@ -0,0 +1,106 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_SJIS.pl +# +# Generate UTF-8 <=> SJIS code conversion radix tree Generate UTF-8 +# <=> SJIS code conversion radix tree Unfortunately it is prohibited +# by the organization to distribute the map files. So if you try to +# use this script, you have to obtain CP932.TXT from the organization's +# ftp site. + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_SJIS.pl'; + +my $mapping = read_source("CP932.TXT"); + +# Drop these SJIS codes from the source for UTF8=>SJIS conversion +my @reject_sjis = ( + 0xed40 .. 0xeefc, 0x8754 .. 0x875d, 0x878a, 0x8782, + 0x8784, 0xfa5b, 0xfa54, 0x8790 .. 0x8792, + 0x8795 .. 0x8797, 0x879a .. 0x879c); + +foreach my $i (@$mapping) +{ + my $code = $i->{code}; + my $ucs = $i->{ucs}; + + if (grep { $code == $_ } @reject_sjis) + { + $i->{direction} = TO_UNICODE; + } +} + +# Add these UTF8->SJIS pairs to the table. +push @$mapping, + ( { + direction => FROM_UNICODE, + ucs => 0x00a2, + code => 0x8191, + comment => '# CENT SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x00a3, + code => 0x8192, + comment => '# POUND SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x00a5, + code => 0x5c, + comment => '# YEN SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x00ac, + code => 0x81ca, + comment => '# NOT SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x2016, + code => 0x8161, + comment => '# DOUBLE VERTICAL LINE', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x203e, + code => 0x7e, + comment => '# OVERLINE', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x2212, + code => 0x817c, + comment => '# MINUS SIGN', + f => $this_script, + l => __LINE__ + }, + { + direction => FROM_UNICODE, + ucs => 0x301c, + code => 0x8160, + comment => '# WAVE DASH', + f => $this_script, + l => __LINE__ + }); + +print_conversion_tables($this_script, "SJIS", $mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_UHC.pl b/src/backend/utils/mb/Unicode/UCS_to_UHC.pl new file mode 100755 index 0000000..cc416bd --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_UHC.pl @@ -0,0 +1,66 @@ +#! /usr/bin/perl +# +# Copyright (c) 2007-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_GB18030.pl +# +# Generate UTF-8 <--> UHC code conversion tables from +# "windows-949-2000.xml", obtained from +# http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/ +# +# The lines we care about in the source file look like +# +# where the "u" field is the Unicode code point in hex, +# and the "b" field is the hex byte sequence for UHC + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_UHC.pl'; + +# Read the input + +my $in_file = "windows-949-2000.xml"; + +open(my $in, '<', $in_file) || die("cannot open $in_file"); + +my @mapping; + +while (<$in>) +{ + next if (!m/= 0x80 && $ucs >= 0x0080) + { + push @mapping, + { + ucs => $ucs, + code => $code, + direction => BOTH, + f => $in_file, + l => $. + }; + } +} +close($in); + +# One extra character that's not in the source file. +push @mapping, + { + direction => BOTH, + code => 0xa2e8, + ucs => 0x327e, + comment => 'CIRCLED HANGUL IEUNG U', + f => $this_script, + l => __LINE__ + }; + +print_conversion_tables($this_script, "UHC", \@mapping); diff --git a/src/backend/utils/mb/Unicode/UCS_to_most.pl b/src/backend/utils/mb/Unicode/UCS_to_most.pl new file mode 100755 index 0000000..4f97438 --- /dev/null +++ b/src/backend/utils/mb/Unicode/UCS_to_most.pl @@ -0,0 +1,62 @@ +#! /usr/bin/perl +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/UCS_to_most.pl +# +# Generate UTF-8 <--> character code conversion tables from +# map files provided by Unicode organization. +# Unfortunately it is prohibited by the organization +# to distribute the map files. So if you try to use this script, +# you have to obtain the map files from the organization's download site. +# https://www.unicode.org/Public/MAPPINGS/ +# We assume the file include three tab-separated columns: +# source character set code in hex +# UCS-2 code in hex +# # and Unicode name (not used in this script) + +use strict; +use warnings; + +use convutils; + +my $this_script = 'src/backend/utils/mb/Unicode/UCS_to_most.pl'; + +my %filename = ( + 'WIN866' => 'CP866.TXT', + 'WIN874' => 'CP874.TXT', + 'WIN1250' => 'CP1250.TXT', + 'WIN1251' => 'CP1251.TXT', + 'WIN1252' => 'CP1252.TXT', + 'WIN1253' => 'CP1253.TXT', + 'WIN1254' => 'CP1254.TXT', + 'WIN1255' => 'CP1255.TXT', + 'WIN1256' => 'CP1256.TXT', + 'WIN1257' => 'CP1257.TXT', + 'WIN1258' => 'CP1258.TXT', + 'ISO8859_2' => '8859-2.TXT', + 'ISO8859_3' => '8859-3.TXT', + 'ISO8859_4' => '8859-4.TXT', + 'ISO8859_5' => '8859-5.TXT', + 'ISO8859_6' => '8859-6.TXT', + 'ISO8859_7' => '8859-7.TXT', + 'ISO8859_8' => '8859-8.TXT', + 'ISO8859_9' => '8859-9.TXT', + 'ISO8859_10' => '8859-10.TXT', + 'ISO8859_13' => '8859-13.TXT', + 'ISO8859_14' => '8859-14.TXT', + 'ISO8859_15' => '8859-15.TXT', + 'ISO8859_16' => '8859-16.TXT', + 'KOI8R' => 'KOI8-R.TXT', + 'KOI8U' => 'KOI8-U.TXT', + 'GBK' => 'CP936.TXT'); + +# make maps for all encodings if not specified +my @charsets = (scalar(@ARGV) > 0) ? @ARGV : sort keys(%filename); + +foreach my $charset (@charsets) +{ + my $mapping = &read_source($filename{$charset}); + + print_conversion_tables($this_script, $charset, $mapping); +} diff --git a/src/backend/utils/mb/Unicode/big5_to_utf8.map b/src/backend/utils/mb/Unicode/big5_to_utf8.map new file mode 100644 index 0000000..aa417bc --- /dev/null +++ b/src/backend/utils/mb/Unicode/big5_to_utf8.map @@ -0,0 +1,4606 @@ +/* src/backend/utils/mb/Unicode/big5_to_utf8.map */ +/* This file is generated by src/backend/utils/mb/Unicode/UCS_to_BIG5.pl */ + +static const uint32 big5_to_unicode_tree_table[17088]; + +static const pg_mb_radix_tree big5_to_unicode_tree = +{ + NULL, /* 16-bit table not used */ + big5_to_unicode_tree_table, + + 0x0000, /* offset of table for 1-byte inputs */ + 0x00, /* b1_lower */ + 0x00, /* b1_upper */ + + 0x00bf, /* offset of table for 2-byte inputs */ + 0xa1, /* b2_1_lower */ + 0xf9, /* b2_1_upper */ + 0x40, /* b2_2_lower */ + 0xfe, /* b2_2_upper */ + + 0x0000, /* offset of table for 3-byte inputs */ + 0x00, /* b3_1_lower */ + 0x00, /* b3_1_upper */ + 0x00, /* b3_2_lower */ + 0x00, /* b3_2_upper */ + 0x00, /* b3_3_lower */ + 0x00, /* b3_3_upper */ + + 0x0000, /* offset of table for 3-byte inputs */ + 0x00, /* b4_1_lower */ + 0x00, /* b4_1_upper */ + 0x00, /* b4_2_lower */ + 0x00, /* b4_2_upper */ + 0x00, /* b4_3_lower */ + 0x00, /* b4_3_upper */ + 0x00, /* b4_4_lower */ + 0x00 /* b4_4_upper */ +}; + +static const uint32 big5_to_unicode_tree_table[17088] = +{ + /*** Dummy map, for invalid values - offset 0x00000 ***/ + + /* 00 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 04 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 08 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 0c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 10 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 14 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 18 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 1c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 20 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 24 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 28 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 2c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 30 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 34 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 38 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 3c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 40 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 44 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 48 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 4c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 50 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 54 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 58 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 5c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 60 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 64 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 68 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 6c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 70 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 74 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 78 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 7c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* ac */ 0x000000, 0x000000, 0x000000, 0x000000, + /* b0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* b4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* b8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* bc */ 0x000000, 0x000000, 0x000000, + + /*** Two byte table, byte #1: xx - offset 0x000bf ***/ + + /* a1 */ 0x000118, 0x0001d7, 0x000296, 0x000355, + /* a5 */ 0x000414, 0x0004d3, 0x000592, 0x000651, + /* a9 */ 0x000710, 0x0007cf, 0x00088e, 0x00094d, + /* ad */ 0x000a0c, 0x000acb, 0x000b8a, 0x000c49, + /* b1 */ 0x000d08, 0x000dc7, 0x000e86, 0x000f45, + /* b5 */ 0x001004, 0x0010c3, 0x001182, 0x001241, + /* b9 */ 0x001300, 0x0013bf, 0x00147e, 0x00153d, + /* bd */ 0x0015fc, 0x0016bb, 0x00177a, 0x001839, + /* c1 */ 0x0018f8, 0x0019b7, 0x001a76, 0x001b35, + /* c5 */ 0x001bf4, 0x001cb3, 0x001d72, 0x000000, + /* c9 */ 0x001e31, 0x001ef0, 0x001faf, 0x00206e, + /* cd */ 0x00212d, 0x0021ec, 0x0022ab, 0x00236a, + /* d1 */ 0x002429, 0x0024e8, 0x0025a7, 0x002666, + /* d5 */ 0x002725, 0x0027e4, 0x0028a3, 0x002962, + /* d9 */ 0x002a21, 0x002ae0, 0x002b9f, 0x002c5e, + /* dd */ 0x002d1d, 0x002ddc, 0x002e9b, 0x002f5a, + /* e1 */ 0x003019, 0x0030d8, 0x003197, 0x003256, + /* e5 */ 0x003315, 0x0033d4, 0x003493, 0x003552, + /* e9 */ 0x003611, 0x0036d0, 0x00378f, 0x00384e, + /* ed */ 0x00390d, 0x0039cc, 0x003a8b, 0x003b4a, + /* f1 */ 0x003c09, 0x003cc8, 0x003d87, 0x003e46, + /* f5 */ 0x003f05, 0x003fc4, 0x004083, 0x004142, + /* f9 */ 0x004201, + + /*** Two byte table, leaf: a1xx - offset 0x00118 ***/ + + /* 40 */ 0xe38080, 0xefbc8c, 0xe38081, 0xe38082, + /* 44 */ 0xefbc8e, 0xe280a2, 0xefbc9b, 0xefbc9a, + /* 48 */ 0xefbc9f, 0xefbc81, 0xefb8b0, 0xe280a6, + /* 4c */ 0xe280a5, 0xefb990, 0xefbda4, 0xefb992, + /* 50 */ 0x00c2b7, 0xefb994, 0xefb995, 0xefb996, + /* 54 */ 0xefb997, 0xefbd9c, 0xe28093, 0xefb8b1, + /* 58 */ 0xe28094, 0xefb8b3, 0xefbfbd, 0xefb8b4, + /* 5c */ 0xefb98f, 0xefbc88, 0xefbc89, 0xefb8b5, + /* 60 */ 0xefb8b6, 0xefbd9b, 0xefbd9d, 0xefb8b7, + /* 64 */ 0xefb8b8, 0xe38094, 0xe38095, 0xefb8b9, + /* 68 */ 0xefb8ba, 0xe38090, 0xe38091, 0xefb8bb, + /* 6c */ 0xefb8bc, 0xe3808a, 0xe3808b, 0xefb8bd, + /* 70 */ 0xefb8be, 0xe38088, 0xe38089, 0xefb8bf, + /* 74 */ 0xefb980, 0xe3808c, 0xe3808d, 0xefb981, + /* 78 */ 0xefb982, 0xe3808e, 0xe3808f, 0xefb983, + /* 7c */ 0xefb984, 0xefb999, 0xefb99a, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xefb99b, 0xefb99c, 0xefb99d, + /* a4 */ 0xefb99e, 0xe28098, 0xe28099, 0xe2809c, + /* a8 */ 0xe2809d, 0xe3809d, 0xe3809e, 0xe280b5, + /* ac */ 0xe280b2, 0xefbc83, 0xefbc86, 0xefbc8a, + /* b0 */ 0xe280bb, 0x00c2a7, 0xe38083, 0xe2978b, + /* b4 */ 0xe2978f, 0xe296b3, 0xe296b2, 0xe2978e, + /* b8 */ 0xe29886, 0xe29885, 0xe29787, 0xe29786, + /* bc */ 0xe296a1, 0xe296a0, 0xe296bd, 0xe296bc, + /* c0 */ 0xe38aa3, 0xe28485, 0xe280be, 0xefbfbd, + /* c4 */ 0xefbcbf, 0xefbfbd, 0xefb989, 0xefb98a, + /* c8 */ 0xefb98d, 0xefb98e, 0xefb98b, 0xefb98c, + /* cc */ 0xefb99f, 0xefb9a0, 0xefb9a1, 0xefbc8b, + /* d0 */ 0xefbc8d, 0x00c397, 0x00c3b7, 0x00c2b1, + /* d4 */ 0xe2889a, 0xefbc9c, 0xefbc9e, 0xefbc9d, + /* d8 */ 0xe289a6, 0xe289a7, 0xe289a0, 0xe2889e, + /* dc */ 0xe28992, 0xe289a1, 0xefb9a2, 0xefb9a3, + /* e0 */ 0xefb9a4, 0xefb9a5, 0xefb9a6, 0xe288bc, + /* e4 */ 0xe288a9, 0xe288aa, 0xe28aa5, 0xe288a0, + /* e8 */ 0xe2889f, 0xe28abf, 0xe38f92, 0xe38f91, + /* ec */ 0xe288ab, 0xe288ae, 0xe288b5, 0xe288b4, + /* f0 */ 0xe29980, 0xe29982, 0xe29981, 0xe29889, + /* f4 */ 0xe28691, 0xe28693, 0xe28690, 0xe28692, + /* f8 */ 0xe28696, 0xe28697, 0xe28699, 0xe28698, + /* fc */ 0xe288a5, 0xe288a3, 0xefbfbd, + + /*** Two byte table, leaf: a2xx - offset 0x001d7 ***/ + + /* 40 */ 0xefbfbd, 0xefbc8f, 0xefbcbc, 0xefbc84, + /* 44 */ 0x00c2a5, 0xe38092, 0x00c2a2, 0x00c2a3, + /* 48 */ 0xefbc85, 0xefbca0, 0xe28483, 0xe28489, + /* 4c */ 0xefb9a9, 0xefb9aa, 0xefb9ab, 0xe38f95, + /* 50 */ 0xe38e9c, 0xe38e9d, 0xe38e9e, 0xe38f8e, + /* 54 */ 0xe38ea1, 0xe38e8e, 0xe38e8f, 0xe38f84, + /* 58 */ 0x00c2b0, 0xe58599, 0xe5859b, 0xe5859e, + /* 5c */ 0xe5859d, 0xe585a1, 0xe585a3, 0xe597a7, + /* 60 */ 0xe793a9, 0xe7b38e, 0xe29681, 0xe29682, + /* 64 */ 0xe29683, 0xe29684, 0xe29685, 0xe29686, + /* 68 */ 0xe29687, 0xe29688, 0xe2968f, 0xe2968e, + /* 6c */ 0xe2968d, 0xe2968c, 0xe2968b, 0xe2968a, + /* 70 */ 0xe29689, 0xe294bc, 0xe294b4, 0xe294ac, + /* 74 */ 0xe294a4, 0xe2949c, 0xe29694, 0xe29480, + /* 78 */ 0xe29482, 0xe29695, 0xe2948c, 0xe29490, + /* 7c */ 0xe29494, 0xe29498, 0xe295ad, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe295ae, 0xe295b0, 0xe295af, + /* a4 */ 0xe29590, 0xe2959e, 0xe295aa, 0xe295a1, + /* a8 */ 0xe297a2, 0xe297a3, 0xe297a5, 0xe297a4, + /* ac */ 0xe295b1, 0xe295b2, 0xe295b3, 0xefbc90, + /* b0 */ 0xefbc91, 0xefbc92, 0xefbc93, 0xefbc94, + /* b4 */ 0xefbc95, 0xefbc96, 0xefbc97, 0xefbc98, + /* b8 */ 0xefbc99, 0xe285a0, 0xe285a1, 0xe285a2, + /* bc */ 0xe285a3, 0xe285a4, 0xe285a5, 0xe285a6, + /* c0 */ 0xe285a7, 0xe285a8, 0xe285a9, 0xe380a1, + /* c4 */ 0xe380a2, 0xe380a3, 0xe380a4, 0xe380a5, + /* c8 */ 0xe380a6, 0xe380a7, 0xe380a8, 0xe380a9, + /* cc */ 0xefbfbd, 0xe58d84, 0xefbfbd, 0xefbca1, + /* d0 */ 0xefbca2, 0xefbca3, 0xefbca4, 0xefbca5, + /* d4 */ 0xefbca6, 0xefbca7, 0xefbca8, 0xefbca9, + /* d8 */ 0xefbcaa, 0xefbcab, 0xefbcac, 0xefbcad, + /* dc */ 0xefbcae, 0xefbcaf, 0xefbcb0, 0xefbcb1, + /* e0 */ 0xefbcb2, 0xefbcb3, 0xefbcb4, 0xefbcb5, + /* e4 */ 0xefbcb6, 0xefbcb7, 0xefbcb8, 0xefbcb9, + /* e8 */ 0xefbcba, 0xefbd81, 0xefbd82, 0xefbd83, + /* ec */ 0xefbd84, 0xefbd85, 0xefbd86, 0xefbd87, + /* f0 */ 0xefbd88, 0xefbd89, 0xefbd8a, 0xefbd8b, + /* f4 */ 0xefbd8c, 0xefbd8d, 0xefbd8e, 0xefbd8f, + /* f8 */ 0xefbd90, 0xefbd91, 0xefbd92, 0xefbd93, + /* fc */ 0xefbd94, 0xefbd95, 0xefbd96, + + /*** Two byte table, leaf: a3xx - offset 0x00296 ***/ + + /* 40 */ 0xefbd97, 0xefbd98, 0xefbd99, 0xefbd9a, + /* 44 */ 0x00ce91, 0x00ce92, 0x00ce93, 0x00ce94, + /* 48 */ 0x00ce95, 0x00ce96, 0x00ce97, 0x00ce98, + /* 4c */ 0x00ce99, 0x00ce9a, 0x00ce9b, 0x00ce9c, + /* 50 */ 0x00ce9d, 0x00ce9e, 0x00ce9f, 0x00cea0, + /* 54 */ 0x00cea1, 0x00cea3, 0x00cea4, 0x00cea5, + /* 58 */ 0x00cea6, 0x00cea7, 0x00cea8, 0x00cea9, + /* 5c */ 0x00ceb1, 0x00ceb2, 0x00ceb3, 0x00ceb4, + /* 60 */ 0x00ceb5, 0x00ceb6, 0x00ceb7, 0x00ceb8, + /* 64 */ 0x00ceb9, 0x00ceba, 0x00cebb, 0x00cebc, + /* 68 */ 0x00cebd, 0x00cebe, 0x00cebf, 0x00cf80, + /* 6c */ 0x00cf81, 0x00cf83, 0x00cf84, 0x00cf85, + /* 70 */ 0x00cf86, 0x00cf87, 0x00cf88, 0x00cf89, + /* 74 */ 0xe38485, 0xe38486, 0xe38487, 0xe38488, + /* 78 */ 0xe38489, 0xe3848a, 0xe3848b, 0xe3848c, + /* 7c */ 0xe3848d, 0xe3848e, 0xe3848f, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe38490, 0xe38491, 0xe38492, + /* a4 */ 0xe38493, 0xe38494, 0xe38495, 0xe38496, + /* a8 */ 0xe38497, 0xe38498, 0xe38499, 0xe3849a, + /* ac */ 0xe3849b, 0xe3849c, 0xe3849d, 0xe3849e, + /* b0 */ 0xe3849f, 0xe384a0, 0xe384a1, 0xe384a2, + /* b4 */ 0xe384a3, 0xe384a4, 0xe384a5, 0xe384a6, + /* b8 */ 0xe384a7, 0xe384a8, 0xe384a9, 0x00cb99, + /* bc */ 0x00cb89, 0x00cb8a, 0x00cb87, 0x00cb8b, + /* c0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* c4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* c8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* cc */ 0x000000, 0x000000, 0x000000, 0x000000, + /* d0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* d4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* d8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* dc */ 0x000000, 0x000000, 0x000000, 0x000000, + /* e0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* e4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* e8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* ec */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* fc */ 0x000000, 0x000000, 0x000000, + + /*** Two byte table, leaf: a4xx - offset 0x00355 ***/ + + /* 40 */ 0xe4b880, 0xe4b999, 0xe4b881, 0xe4b883, + /* 44 */ 0xe4b983, 0xe4b99d, 0xe4ba86, 0xe4ba8c, + /* 48 */ 0xe4baba, 0xe584bf, 0xe585a5, 0xe585ab, + /* 4c */ 0xe587a0, 0xe58880, 0xe58881, 0xe58a9b, + /* 50 */ 0xe58c95, 0xe58d81, 0xe58d9c, 0xe58f88, + /* 54 */ 0xe4b889, 0xe4b88b, 0xe4b888, 0xe4b88a, + /* 58 */ 0xe4b8ab, 0xe4b8b8, 0xe587a1, 0xe4b985, + /* 5c */ 0xe4b988, 0xe4b99f, 0xe4b99e, 0xe4ba8e, + /* 60 */ 0xe4baa1, 0xe58580, 0xe58883, 0xe58bba, + /* 64 */ 0xe58d83, 0xe58f89, 0xe58fa3, 0xe59c9f, + /* 68 */ 0xe5a3ab, 0xe5a495, 0xe5a4a7, 0xe5a5b3, + /* 6c */ 0xe5ad90, 0xe5ad91, 0xe5ad93, 0xe5afb8, + /* 70 */ 0xe5b08f, 0xe5b0a2, 0xe5b0b8, 0xe5b1b1, + /* 74 */ 0xe5b79d, 0xe5b7a5, 0xe5b7b1, 0xe5b7b2, + /* 78 */ 0xe5b7b3, 0xe5b7be, 0xe5b9b2, 0xe5bbbe, + /* 7c */ 0xe5bc8b, 0xe5bc93, 0xe6898d, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe4b891, 0xe4b890, 0xe4b88d, + /* a4 */ 0xe4b8ad, 0xe4b8b0, 0xe4b8b9, 0xe4b98b, + /* a8 */ 0xe5b0b9, 0xe4ba88, 0xe4ba91, 0xe4ba95, + /* ac */ 0xe4ba92, 0xe4ba94, 0xe4baa2, 0xe4bb81, + /* b0 */ 0xe4bb80, 0xe4bb83, 0xe4bb86, 0xe4bb87, + /* b4 */ 0xe4bb8d, 0xe4bb8a, 0xe4bb8b, 0xe4bb84, + /* b8 */ 0xe58583, 0xe58581, 0xe585a7, 0xe585ad, + /* bc */ 0xe585ae, 0xe585ac, 0xe58697, 0xe587b6, + /* c0 */ 0xe58886, 0xe58887, 0xe58888, 0xe58bbb, + /* c4 */ 0xe58bbe, 0xe58bbf, 0xe58c96, 0xe58cb9, + /* c8 */ 0xe58d88, 0xe58d87, 0xe58d85, 0xe58d9e, + /* cc */ 0xe58e84, 0xe58f8b, 0xe58f8a, 0xe58f8d, + /* d0 */ 0xe5a3ac, 0xe5a4a9, 0xe5a4ab, 0xe5a4aa, + /* d4 */ 0xe5a4ad, 0xe5ad94, 0xe5b091, 0xe5b0a4, + /* d8 */ 0xe5b0ba, 0xe5b1af, 0xe5b7b4, 0xe5b9bb, + /* dc */ 0xe5bbbf, 0xe5bc94, 0xe5bc95, 0xe5bf83, + /* e0 */ 0xe68888, 0xe688b6, 0xe6898b, 0xe6898e, + /* e4 */ 0xe694af, 0xe69687, 0xe69697, 0xe696a4, + /* e8 */ 0xe696b9, 0xe697a5, 0xe69bb0, 0xe69c88, + /* ec */ 0xe69ca8, 0xe6aca0, 0xe6ada2, 0xe6adb9, + /* f0 */ 0xe6af8b, 0xe6af94, 0xe6af9b, 0xe6b08f, + /* f4 */ 0xe6b0b4, 0xe781ab, 0xe788aa, 0xe788b6, + /* f8 */ 0xe788bb, 0xe78987, 0xe78999, 0xe7899b, + /* fc */ 0xe78aac, 0xe78e8b, 0xe4b899, + + /*** Two byte table, leaf: a5xx - offset 0x00414 ***/ + + /* 40 */ 0xe4b896, 0xe4b895, 0xe4b894, 0xe4b898, + /* 44 */ 0xe4b8bb, 0xe4b98d, 0xe4b98f, 0xe4b98e, + /* 48 */ 0xe4bba5, 0xe4bb98, 0xe4bb94, 0xe4bb95, + /* 4c */ 0xe4bb96, 0xe4bb97, 0xe4bba3, 0xe4bba4, + /* 50 */ 0xe4bb99, 0xe4bb9e, 0xe58585, 0xe58584, + /* 54 */ 0xe58689, 0xe5868a, 0xe586ac, 0xe587b9, + /* 58 */ 0xe587ba, 0xe587b8, 0xe5888a, 0xe58aa0, + /* 5c */ 0xe58a9f, 0xe58c85, 0xe58c86, 0xe58c97, + /* 60 */ 0xe58c9d, 0xe4bb9f, 0xe58d8a, 0xe58d89, + /* 64 */ 0xe58da1, 0xe58da0, 0xe58daf, 0xe58dae, + /* 68 */ 0xe58ebb, 0xe58faf, 0xe58fa4, 0xe58fb3, + /* 6c */ 0xe58fac, 0xe58fae, 0xe58fa9, 0xe58fa8, + /* 70 */ 0xe58fbc, 0xe58fb8, 0xe58fb5, 0xe58fab, + /* 74 */ 0xe58fa6, 0xe58faa, 0xe58fb2, 0xe58fb1, + /* 78 */ 0xe58fb0, 0xe58fa5, 0xe58fad, 0xe58fbb, + /* 7c */ 0xe59b9b, 0xe59b9a, 0xe5a496, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5a4ae, 0xe5a4b1, 0xe5a5b4, + /* a4 */ 0xe5a5b6, 0xe5ad95, 0xe5ae83, 0xe5b0bc, + /* a8 */ 0xe5b7a8, 0xe5b7a7, 0xe5b7a6, 0xe5b882, + /* ac */ 0xe5b883, 0xe5b9b3, 0xe5b9bc, 0xe5bc81, + /* b0 */ 0xe5bc98, 0xe5bc97, 0xe5bf85, 0xe6888a, + /* b4 */ 0xe68993, 0xe68994, 0xe68992, 0xe68991, + /* b8 */ 0xe696a5, 0xe697a6, 0xe69cae, 0xe69cac, + /* bc */ 0xe69caa, 0xe69cab, 0xe69cad, 0xe6ada3, + /* c0 */ 0xe6af8d, 0xe6b091, 0xe6b090, 0xe6b0b8, + /* c4 */ 0xe6b181, 0xe6b180, 0xe6b0be, 0xe78aaf, + /* c8 */ 0xe78e84, 0xe78e89, 0xe7939c, 0xe793a6, + /* cc */ 0xe79498, 0xe7949f, 0xe794a8, 0xe794a9, + /* d0 */ 0xe794b0, 0xe794b1, 0xe794b2, 0xe794b3, + /* d4 */ 0xe7968b, 0xe799bd, 0xe79aae, 0xe79abf, + /* d8 */ 0xe79bae, 0xe79f9b, 0xe79fa2, 0xe79fb3, + /* dc */ 0xe7a4ba, 0xe7a6be, 0xe7a9b4, 0xe7ab8b, + /* e0 */ 0xe4b89e, 0xe4b89f, 0xe4b992, 0xe4b993, + /* e4 */ 0xe4b9a9, 0xe4ba99, 0xe4baa4, 0xe4baa6, + /* e8 */ 0xe4baa5, 0xe4bbbf, 0xe4bc89, 0xe4bc99, + /* ec */ 0xe4bc8a, 0xe4bc95, 0xe4bc8d, 0xe4bc90, + /* f0 */ 0xe4bc91, 0xe4bc8f, 0xe4bbb2, 0xe4bbb6, + /* f4 */ 0xe4bbbb, 0xe4bbb0, 0xe4bbb3, 0xe4bbbd, + /* f8 */ 0xe4bc81, 0xe4bc8b, 0xe58589, 0xe58587, + /* fc */ 0xe58586, 0xe58588, 0xe585a8, + + /*** Two byte table, leaf: a6xx - offset 0x004d3 ***/ + + /* 40 */ 0xe585b1, 0xe5868d, 0xe586b0, 0xe58897, + /* 44 */ 0xe58891, 0xe58892, 0xe5888e, 0xe58896, + /* 48 */ 0xe58aa3, 0xe58c88, 0xe58ca1, 0xe58ca0, + /* 4c */ 0xe58db0, 0xe58db1, 0xe59089, 0xe5908f, + /* 50 */ 0xe5908c, 0xe5908a, 0xe59090, 0xe59081, + /* 54 */ 0xe5908b, 0xe59084, 0xe59091, 0xe5908d, + /* 58 */ 0xe59088, 0xe59083, 0xe5908e, 0xe59086, + /* 5c */ 0xe59092, 0xe59ba0, 0xe59b9e, 0xe59b9d, + /* 60 */ 0xe59cb3, 0xe59cb0, 0xe59ca8, 0xe59cad, + /* 64 */ 0xe59cac, 0xe59caf, 0xe59ca9, 0xe5a499, + /* 68 */ 0xe5a49a, 0xe5a4b7, 0xe5a4b8, 0xe5a684, + /* 6c */ 0xe5a5b8, 0xe5a683, 0xe5a5bd, 0xe5a5b9, + /* 70 */ 0xe5a682, 0xe5a681, 0xe5ad97, 0xe5ad98, + /* 74 */ 0xe5ae87, 0xe5ae88, 0xe5ae85, 0xe5ae89, + /* 78 */ 0xe5afba, 0xe5b096, 0xe5b1b9, 0xe5b79e, + /* 7c */ 0xe5b886, 0xe5b9b6, 0xe5b9b4, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5bc8f, 0xe5bc9b, 0xe5bf99, + /* a4 */ 0xe5bf96, 0xe6888e, 0xe6888c, 0xe6888d, + /* a8 */ 0xe68890, 0xe689a3, 0xe6899b, 0xe68998, + /* ac */ 0xe694b6, 0xe697a9, 0xe697a8, 0xe697ac, + /* b0 */ 0xe697ad, 0xe69bb2, 0xe69bb3, 0xe69c89, + /* b4 */ 0xe69cbd, 0xe69cb4, 0xe69cb1, 0xe69cb5, + /* b8 */ 0xe6aca1, 0xe6ada4, 0xe6adbb, 0xe6b096, + /* bc */ 0xe6b19d, 0xe6b197, 0xe6b199, 0xe6b19f, + /* c0 */ 0xe6b1a0, 0xe6b190, 0xe6b195, 0xe6b1a1, + /* c4 */ 0xe6b19b, 0xe6b18d, 0xe6b18e, 0xe781b0, + /* c8 */ 0xe7899f, 0xe7899d, 0xe799be, 0xe7abb9, + /* cc */ 0xe7b1b3, 0xe7b3b8, 0xe7bcb6, 0xe7be8a, + /* d0 */ 0xe7bebd, 0xe88081, 0xe88083, 0xe8808c, + /* d4 */ 0xe88092, 0xe880b3, 0xe881bf, 0xe88289, + /* d8 */ 0xe8828b, 0xe8828c, 0xe887a3, 0xe887aa, + /* dc */ 0xe887b3, 0xe887bc, 0xe8888c, 0xe8889b, + /* e0 */ 0xe8889f, 0xe889ae, 0xe889b2, 0xe889be, + /* e4 */ 0xe899ab, 0xe8a180, 0xe8a18c, 0xe8a1a3, + /* e8 */ 0xe8a5bf, 0xe998a1, 0xe4b8b2, 0xe4baa8, + /* ec */ 0xe4bd8d, 0xe4bd8f, 0xe4bd87, 0xe4bd97, + /* f0 */ 0xe4bd9e, 0xe4bcb4, 0xe4bd9b, 0xe4bd95, + /* f4 */ 0xe4bcb0, 0xe4bd90, 0xe4bd91, 0xe4bcbd, + /* f8 */ 0xe4bcba, 0xe4bcb8, 0xe4bd83, 0xe4bd94, + /* fc */ 0xe4bcbc, 0xe4bd86, 0xe4bda3, + + /*** Two byte table, leaf: a7xx - offset 0x00592 ***/ + + /* 40 */ 0xe4bd9c, 0xe4bda0, 0xe4bcaf, 0xe4bd8e, + /* 44 */ 0xe4bcb6, 0xe4bd99, 0xe4bd9d, 0xe4bd88, + /* 48 */ 0xe4bd9a, 0xe5858c, 0xe5858b, 0xe5858d, + /* 4c */ 0xe585b5, 0xe586b6, 0xe586b7, 0xe588a5, + /* 50 */ 0xe588a4, 0xe588a9, 0xe588aa, 0xe588a8, + /* 54 */ 0xe58aab, 0xe58aa9, 0xe58aaa, 0xe58aac, + /* 58 */ 0xe58ca3, 0xe58db3, 0xe58db5, 0xe5909d, + /* 5c */ 0xe590ad, 0xe5909e, 0xe590be, 0xe590a6, + /* 60 */ 0xe5918e, 0xe590a7, 0xe59186, 0xe59183, + /* 64 */ 0xe590b3, 0xe59188, 0xe59182, 0xe5909b, + /* 68 */ 0xe590a9, 0xe5918a, 0xe590b9, 0xe590bb, + /* 6c */ 0xe590b8, 0xe590ae, 0xe590b5, 0xe590b6, + /* 70 */ 0xe590a0, 0xe590bc, 0xe59180, 0xe590b1, + /* 74 */ 0xe590ab, 0xe5909f, 0xe590ac, 0xe59baa, + /* 78 */ 0xe59bb0, 0xe59ba4, 0xe59bab, 0xe59d8a, + /* 7c */ 0xe59d91, 0xe59d80, 0xe59d8d, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe59d87, 0xe59d8e, 0xe59cbe, + /* a4 */ 0xe59d90, 0xe59d8f, 0xe59cbb, 0xe5a3af, + /* a8 */ 0xe5a4be, 0xe5a69d, 0xe5a692, 0xe5a6a8, + /* ac */ 0xe5a69e, 0xe5a6a3, 0xe5a699, 0xe5a696, + /* b0 */ 0xe5a68d, 0xe5a6a4, 0xe5a693, 0xe5a68a, + /* b4 */ 0xe5a6a5, 0xe5ad9d, 0xe5ad9c, 0xe5ad9a, + /* b8 */ 0xe5ad9b, 0xe5ae8c, 0xe5ae8b, 0xe5ae8f, + /* bc */ 0xe5b0ac, 0xe5b180, 0xe5b181, 0xe5b0bf, + /* c0 */ 0xe5b0be, 0xe5b290, 0xe5b291, 0xe5b294, + /* c4 */ 0xe5b28c, 0xe5b7ab, 0xe5b88c, 0xe5ba8f, + /* c8 */ 0xe5ba87, 0xe5ba8a, 0xe5bbb7, 0xe5bc84, + /* cc */ 0xe5bc9f, 0xe5bda4, 0xe5bda2, 0xe5bdb7, + /* d0 */ 0xe5bdb9, 0xe5bf98, 0xe5bf8c, 0xe5bf97, + /* d4 */ 0xe5bf8d, 0xe5bfb1, 0xe5bfab, 0xe5bfb8, + /* d8 */ 0xe5bfaa, 0xe68892, 0xe68891, 0xe68a84, + /* dc */ 0xe68a97, 0xe68a96, 0xe68a80, 0xe689b6, + /* e0 */ 0xe68a89, 0xe689ad, 0xe68a8a, 0xe689bc, + /* e4 */ 0xe689be, 0xe689b9, 0xe689b3, 0xe68a92, + /* e8 */ 0xe689af, 0xe68a98, 0xe689ae, 0xe68a95, + /* ec */ 0xe68a93, 0xe68a91, 0xe68a86, 0xe694b9, + /* f0 */ 0xe694bb, 0xe694b8, 0xe697b1, 0xe69bb4, + /* f4 */ 0xe69d9f, 0xe69d8e, 0xe69d8f, 0xe69d90, + /* f8 */ 0xe69d91, 0xe69d9c, 0xe69d96, 0xe69d9e, + /* fc */ 0xe69d89, 0xe69d86, 0xe69da0, + + /*** Two byte table, leaf: a8xx - offset 0x00651 ***/ + + /* 40 */ 0xe69d93, 0xe69d97, 0xe6ada5, 0xe6af8f, + /* 44 */ 0xe6b182, 0xe6b19e, 0xe6b299, 0xe6b281, + /* 48 */ 0xe6b288, 0xe6b289, 0xe6b285, 0xe6b29b, + /* 4c */ 0xe6b1aa, 0xe6b1ba, 0xe6b290, 0xe6b1b0, + /* 50 */ 0xe6b28c, 0xe6b1a8, 0xe6b296, 0xe6b292, + /* 54 */ 0xe6b1bd, 0xe6b283, 0xe6b1b2, 0xe6b1be, + /* 58 */ 0xe6b1b4, 0xe6b286, 0xe6b1b6, 0xe6b28d, + /* 5c */ 0xe6b294, 0xe6b298, 0xe6b282, 0xe781b6, + /* 60 */ 0xe781bc, 0xe781bd, 0xe781b8, 0xe789a2, + /* 64 */ 0xe789a1, 0xe789a0, 0xe78b84, 0xe78b82, + /* 68 */ 0xe78e96, 0xe794ac, 0xe794ab, 0xe794b7, + /* 6c */ 0xe794b8, 0xe79a82, 0xe79baf, 0xe79fa3, + /* 70 */ 0xe7a781, 0xe7a780, 0xe7a6bf, 0xe7a9b6, + /* 74 */ 0xe7b3bb, 0xe7bd95, 0xe88296, 0xe88293, + /* 78 */ 0xe8829d, 0xe88298, 0xe8829b, 0xe8829a, + /* 7c */ 0xe882b2, 0xe889af, 0xe88a92, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88a8b, 0xe88a8d, 0xe8a68b, + /* a4 */ 0xe8a792, 0xe8a880, 0xe8b0b7, 0xe8b186, + /* a8 */ 0xe8b195, 0xe8b29d, 0xe8b5a4, 0xe8b5b0, + /* ac */ 0xe8b6b3, 0xe8baab, 0xe8bb8a, 0xe8be9b, + /* b0 */ 0xe8beb0, 0xe8bf82, 0xe8bf86, 0xe8bf85, + /* b4 */ 0xe8bf84, 0xe5b7a1, 0xe98291, 0xe982a2, + /* b8 */ 0xe982aa, 0xe982a6, 0xe982a3, 0xe98589, + /* bc */ 0xe98786, 0xe9878c, 0xe998b2, 0xe998ae, + /* c0 */ 0xe998b1, 0xe998aa, 0xe998ac, 0xe4b8a6, + /* c4 */ 0xe4b996, 0xe4b9b3, 0xe4ba8b, 0xe4ba9b, + /* c8 */ 0xe4ba9e, 0xe4baab, 0xe4baac, 0xe4bdaf, + /* cc */ 0xe4be9d, 0xe4be8d, 0xe4bdb3, 0xe4bdbf, + /* d0 */ 0xe4bdac, 0xe4be9b, 0xe4be8b, 0xe4be86, + /* d4 */ 0xe4be83, 0xe4bdb0, 0xe4bdb5, 0xe4be88, + /* d8 */ 0xe4bda9, 0xe4bdbb, 0xe4be96, 0xe4bdbe, + /* dc */ 0xe4be8f, 0xe4be91, 0xe4bdba, 0xe58594, + /* e0 */ 0xe58592, 0xe58595, 0xe585a9, 0xe585b7, + /* e4 */ 0xe585b6, 0xe585b8, 0xe586bd, 0xe587bd, + /* e8 */ 0xe588bb, 0xe588b8, 0xe588b7, 0xe588ba, + /* ec */ 0xe588b0, 0xe588ae, 0xe588b6, 0xe58981, + /* f0 */ 0xe58abe, 0xe58abb, 0xe58d92, 0xe58d94, + /* f4 */ 0xe58d93, 0xe58d91, 0xe58da6, 0xe58db7, + /* f8 */ 0xe58db8, 0xe58db9, 0xe58f96, 0xe58f94, + /* fc */ 0xe58f97, 0xe591b3, 0xe591b5, + + /*** Two byte table, leaf: a9xx - offset 0x00710 ***/ + + /* 40 */ 0xe59296, 0xe591b8, 0xe59295, 0xe59280, + /* 44 */ 0xe591bb, 0xe591b7, 0xe59284, 0xe59292, + /* 48 */ 0xe59286, 0xe591bc, 0xe59290, 0xe591b1, + /* 4c */ 0xe591b6, 0xe5928c, 0xe5929a, 0xe591a2, + /* 50 */ 0xe591a8, 0xe5928b, 0xe591bd, 0xe5928e, + /* 54 */ 0xe59bba, 0xe59e83, 0xe59db7, 0xe59daa, + /* 58 */ 0xe59da9, 0xe59da1, 0xe59da6, 0xe59da4, + /* 5c */ 0xe59dbc, 0xe5a49c, 0xe5a589, 0xe5a587, + /* 60 */ 0xe5a588, 0xe5a584, 0xe5a594, 0xe5a6be, + /* 64 */ 0xe5a6bb, 0xe5a794, 0xe5a6b9, 0xe5a6ae, + /* 68 */ 0xe5a791, 0xe5a786, 0xe5a790, 0xe5a78d, + /* 6c */ 0xe5a78b, 0xe5a793, 0xe5a78a, 0xe5a6af, + /* 70 */ 0xe5a6b3, 0xe5a792, 0xe5a785, 0xe5ad9f, + /* 74 */ 0xe5ada4, 0xe5ada3, 0xe5ae97, 0xe5ae9a, + /* 78 */ 0xe5ae98, 0xe5ae9c, 0xe5ae99, 0xe5ae9b, + /* 7c */ 0xe5b09a, 0xe5b188, 0xe5b185, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5b186, 0xe5b2b7, 0xe5b2a1, + /* a4 */ 0xe5b2b8, 0xe5b2a9, 0xe5b2ab, 0xe5b2b1, + /* a8 */ 0xe5b2b3, 0xe5b898, 0xe5b89a, 0xe5b896, + /* ac */ 0xe5b895, 0xe5b89b, 0xe5b891, 0xe5b9b8, + /* b0 */ 0xe5ba9a, 0xe5ba97, 0xe5ba9c, 0xe5ba95, + /* b4 */ 0xe5ba96, 0xe5bbb6, 0xe5bca6, 0xe5bca7, + /* b8 */ 0xe5bca9, 0xe5be80, 0xe5be81, 0xe5bdbf, + /* bc */ 0xe5bdbc, 0xe5bf9d, 0xe5bfa0, 0xe5bfbd, + /* c0 */ 0xe5bfb5, 0xe5bfbf, 0xe6808f, 0xe68094, + /* c4 */ 0xe680af, 0xe680b5, 0xe68096, 0xe680aa, + /* c8 */ 0xe68095, 0xe680a1, 0xe680a7, 0xe680a9, + /* cc */ 0xe680ab, 0xe6809b, 0xe68896, 0xe68895, + /* d0 */ 0xe688bf, 0xe688be, 0xe68980, 0xe689bf, + /* d4 */ 0xe68b89, 0xe68b8c, 0xe68b84, 0xe68abf, + /* d8 */ 0xe68b82, 0xe68ab9, 0xe68b92, 0xe68b9b, + /* dc */ 0xe68aab, 0xe68b93, 0xe68b94, 0xe68b8b, + /* e0 */ 0xe68b88, 0xe68aa8, 0xe68abd, 0xe68abc, + /* e4 */ 0xe68b90, 0xe68b99, 0xe68b87, 0xe68b8d, + /* e8 */ 0xe68ab5, 0xe68b9a, 0xe68ab1, 0xe68b98, + /* ec */ 0xe68b96, 0xe68b97, 0xe68b86, 0xe68aac, + /* f0 */ 0xe68b8e, 0xe694be, 0xe696a7, 0xe696bc, + /* f4 */ 0xe697ba, 0xe69894, 0xe69893, 0xe6988c, + /* f8 */ 0xe69886, 0xe69882, 0xe6988e, 0xe69880, + /* fc */ 0xe6988f, 0xe69895, 0xe6988a, + + /*** Two byte table, leaf: aaxx - offset 0x007cf ***/ + + /* 40 */ 0xe69887, 0xe69c8d, 0xe69c8b, 0xe69dad, + /* 44 */ 0xe69e8b, 0xe69e95, 0xe69db1, 0xe69e9c, + /* 48 */ 0xe69db3, 0xe69db7, 0xe69e87, 0xe69e9d, + /* 4c */ 0xe69e97, 0xe69daf, 0xe69db0, 0xe69dbf, + /* 50 */ 0xe69e89, 0xe69dbe, 0xe69e90, 0xe69db5, + /* 54 */ 0xe69e9a, 0xe69e93, 0xe69dbc, 0xe69daa, + /* 58 */ 0xe69db2, 0xe6aca3, 0xe6ada6, 0xe6ada7, + /* 5c */ 0xe6adbf, 0xe6b093, 0xe6b09b, 0xe6b3a3, + /* 60 */ 0xe6b3a8, 0xe6b3b3, 0xe6b2b1, 0xe6b38c, + /* 64 */ 0xe6b3a5, 0xe6b2b3, 0xe6b2bd, 0xe6b2be, + /* 68 */ 0xe6b2bc, 0xe6b3a2, 0xe6b2ab, 0xe6b395, + /* 6c */ 0xe6b393, 0xe6b2b8, 0xe6b384, 0xe6b2b9, + /* 70 */ 0xe6b381, 0xe6b2ae, 0xe6b397, 0xe6b385, + /* 74 */ 0xe6b3b1, 0xe6b2bf, 0xe6b2bb, 0xe6b3a1, + /* 78 */ 0xe6b39b, 0xe6b38a, 0xe6b2ac, 0xe6b3af, + /* 7c */ 0xe6b39c, 0xe6b396, 0xe6b3a0, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe78295, 0xe7828e, 0xe78292, + /* a4 */ 0xe7828a, 0xe78299, 0xe788ac, 0xe788ad, + /* a8 */ 0xe788b8, 0xe78988, 0xe789a7, 0xe789a9, + /* ac */ 0xe78b80, 0xe78b8e, 0xe78b99, 0xe78b97, + /* b0 */ 0xe78b90, 0xe78ea9, 0xe78ea8, 0xe78e9f, + /* b4 */ 0xe78eab, 0xe78ea5, 0xe794bd, 0xe7969d, + /* b8 */ 0xe79699, 0xe7969a, 0xe79a84, 0xe79b82, + /* bc */ 0xe79bb2, 0xe79bb4, 0xe79fa5, 0xe79fbd, + /* c0 */ 0xe7a4be, 0xe7a580, 0xe7a581, 0xe7a789, + /* c4 */ 0xe7a788, 0xe7a9ba, 0xe7a9b9, 0xe7abba, + /* c8 */ 0xe7b3be, 0xe7bd94, 0xe7be8c, 0xe7be8b, + /* cc */ 0xe88085, 0xe882ba, 0xe882a5, 0xe882a2, + /* d0 */ 0xe882b1, 0xe882a1, 0xe882ab, 0xe882a9, + /* d4 */ 0xe882b4, 0xe882aa, 0xe882af, 0xe887a5, + /* d8 */ 0xe887be, 0xe8888d, 0xe88ab3, 0xe88a9d, + /* dc */ 0xe88a99, 0xe88aad, 0xe88abd, 0xe88a9f, + /* e0 */ 0xe88ab9, 0xe88ab1, 0xe88aac, 0xe88aa5, + /* e4 */ 0xe88aaf, 0xe88ab8, 0xe88aa3, 0xe88ab0, + /* e8 */ 0xe88abe, 0xe88ab7, 0xe8998e, 0xe899b1, + /* ec */ 0xe5889d, 0xe8a1a8, 0xe8bb8b, 0xe8bf8e, + /* f0 */ 0xe8bf94, 0xe8bf91, 0xe982b5, 0xe982b8, + /* f4 */ 0xe982b1, 0xe982b6, 0xe98787, 0xe98791, + /* f8 */ 0xe995b7, 0xe99680, 0xe9989c, 0xe99980, + /* fc */ 0xe998bf, 0xe998bb, 0xe99984, + + /*** Two byte table, leaf: abxx - offset 0x0088e ***/ + + /* 40 */ 0xe99982, 0xe99ab9, 0xe99ba8, 0xe99d92, + /* 44 */ 0xe99d9e, 0xe4ba9f, 0xe4baad, 0xe4baae, + /* 48 */ 0xe4bfa1, 0xe4beb5, 0xe4beaf, 0xe4bebf, + /* 4c */ 0xe4bfa0, 0xe4bf91, 0xe4bf8f, 0xe4bf9d, + /* 50 */ 0xe4bf83, 0xe4beb6, 0xe4bf98, 0xe4bf9f, + /* 54 */ 0xe4bf8a, 0xe4bf97, 0xe4beae, 0xe4bf90, + /* 58 */ 0xe4bf84, 0xe4bf82, 0xe4bf9a, 0xe4bf8e, + /* 5c */ 0xe4bf9e, 0xe4beb7, 0xe58597, 0xe58692, + /* 60 */ 0xe58691, 0xe586a0, 0xe5898e, 0xe58983, + /* 64 */ 0xe5898a, 0xe5898d, 0xe5898c, 0xe5898b, + /* 68 */ 0xe58987, 0xe58b87, 0xe58b89, 0xe58b83, + /* 6c */ 0xe58b81, 0xe58c8d, 0xe58d97, 0xe58dbb, + /* 70 */ 0xe58e9a, 0xe58f9b, 0xe592ac, 0xe59380, + /* 74 */ 0xe592a8, 0xe5938e, 0xe59389, 0xe592b8, + /* 78 */ 0xe592a6, 0xe592b3, 0xe59387, 0xe59382, + /* 7c */ 0xe592bd, 0xe592aa, 0xe59381, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe59384, 0xe59388, 0xe592af, + /* a4 */ 0xe592ab, 0xe592b1, 0xe592bb, 0xe592a9, + /* a8 */ 0xe592a7, 0xe592bf, 0xe59bbf, 0xe59e82, + /* ac */ 0xe59e8b, 0xe59ea0, 0xe59ea3, 0xe59ea2, + /* b0 */ 0xe59f8e, 0xe59eae, 0xe59e93, 0xe5a595, + /* b4 */ 0xe5a591, 0xe5a58f, 0xe5a58e, 0xe5a590, + /* b8 */ 0xe5a79c, 0xe5a798, 0xe5a7bf, 0xe5a7a3, + /* bc */ 0xe5a7a8, 0xe5a883, 0xe5a7a5, 0xe5a7aa, + /* c0 */ 0xe5a79a, 0xe5a7a6, 0xe5a881, 0xe5a7bb, + /* c4 */ 0xe5ada9, 0xe5aea3, 0xe5aea6, 0xe5aea4, + /* c8 */ 0xe5aea2, 0xe5aea5, 0xe5b081, 0xe5b18e, + /* cc */ 0xe5b18f, 0xe5b18d, 0xe5b18b, 0xe5b399, + /* d0 */ 0xe5b392, 0xe5b7b7, 0xe5b89d, 0xe5b8a5, + /* d4 */ 0xe5b89f, 0xe5b9bd, 0xe5baa0, 0xe5baa6, + /* d8 */ 0xe5bbba, 0xe5bc88, 0xe5bcad, 0xe5bda5, + /* dc */ 0xe5be88, 0xe5be85, 0xe5be8a, 0xe5be8b, + /* e0 */ 0xe5be87, 0xe5be8c, 0xe5be89, 0xe68092, + /* e4 */ 0xe6809d, 0xe680a0, 0xe680a5, 0xe6808e, + /* e8 */ 0xe680a8, 0xe6818d, 0xe681b0, 0xe681a8, + /* ec */ 0xe681a2, 0xe68186, 0xe68183, 0xe681ac, + /* f0 */ 0xe681ab, 0xe681aa, 0xe681a4, 0xe68981, + /* f4 */ 0xe68b9c, 0xe68c96, 0xe68c89, 0xe68bbc, + /* f8 */ 0xe68bad, 0xe68c81, 0xe68bae, 0xe68bbd, + /* fc */ 0xe68c87, 0xe68bb1, 0xe68bb7, + + /*** Two byte table, leaf: acxx - offset 0x0094d ***/ + + /* 40 */ 0xe68baf, 0xe68bac, 0xe68bbe, 0xe68bb4, + /* 44 */ 0xe68c91, 0xe68c82, 0xe694bf, 0xe69585, + /* 48 */ 0xe696ab, 0xe696bd, 0xe697a2, 0xe698a5, + /* 4c */ 0xe698ad, 0xe698a0, 0xe698a7, 0xe698af, + /* 50 */ 0xe6989f, 0xe698a8, 0xe698b1, 0xe698a4, + /* 54 */ 0xe69bb7, 0xe69fbf, 0xe69f93, 0xe69fb1, + /* 58 */ 0xe69f94, 0xe69f90, 0xe69fac, 0xe69eb6, + /* 5c */ 0xe69eaf, 0xe69fb5, 0xe69fa9, 0xe69faf, + /* 60 */ 0xe69f84, 0xe69f91, 0xe69eb4, 0xe69f9a, + /* 64 */ 0xe69fa5, 0xe69eb8, 0xe69f8f, 0xe69f9e, + /* 68 */ 0xe69fb3, 0xe69eb0, 0xe69f99, 0xe69fa2, + /* 6c */ 0xe69f9d, 0xe69f92, 0xe6adaa, 0xe6ae83, + /* 70 */ 0xe6ae86, 0xe6aeb5, 0xe6af92, 0xe6af97, + /* 74 */ 0xe6b09f, 0xe6b389, 0xe6b48b, 0xe6b4b2, + /* 78 */ 0xe6b4aa, 0xe6b581, 0xe6b4a5, 0xe6b48c, + /* 7c */ 0xe6b4b1, 0xe6b49e, 0xe6b497, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6b4bb, 0xe6b4bd, 0xe6b4be, + /* a4 */ 0xe6b4b6, 0xe6b49b, 0xe6b3b5, 0xe6b4b9, + /* a8 */ 0xe6b4a7, 0xe6b4b8, 0xe6b4a9, 0xe6b4ae, + /* ac */ 0xe6b4b5, 0xe6b48e, 0xe6b4ab, 0xe782ab, + /* b0 */ 0xe782ba, 0xe782b3, 0xe782ac, 0xe782af, + /* b4 */ 0xe782ad, 0xe782b8, 0xe782ae, 0xe782a4, + /* b8 */ 0xe788b0, 0xe789b2, 0xe789af, 0xe789b4, + /* bc */ 0xe78ba9, 0xe78ba0, 0xe78ba1, 0xe78eb7, + /* c0 */ 0xe78f8a, 0xe78ebb, 0xe78eb2, 0xe78f8d, + /* c4 */ 0xe78f80, 0xe78eb3, 0xe7949a, 0xe794ad, + /* c8 */ 0xe7958f, 0xe7958c, 0xe7958e, 0xe7958b, + /* cc */ 0xe796ab, 0xe796a4, 0xe796a5, 0xe796a2, + /* d0 */ 0xe796a3, 0xe799b8, 0xe79a86, 0xe79a87, + /* d4 */ 0xe79a88, 0xe79b88, 0xe79b86, 0xe79b83, + /* d8 */ 0xe79b85, 0xe79c81, 0xe79bb9, 0xe79bb8, + /* dc */ 0xe79c89, 0xe79c8b, 0xe79bbe, 0xe79bbc, + /* e0 */ 0xe79c87, 0xe79f9c, 0xe7a082, 0xe7a094, + /* e4 */ 0xe7a08c, 0xe7a08d, 0xe7a586, 0xe7a589, + /* e8 */ 0xe7a588, 0xe7a587, 0xe7a6b9, 0xe7a6ba, + /* ec */ 0xe7a791, 0xe7a792, 0xe7a78b, 0xe7a9bf, + /* f0 */ 0xe7aa81, 0xe7abbf, 0xe7abbd, 0xe7b1bd, + /* f4 */ 0xe7b482, 0xe7b485, 0xe7b480, 0xe7b489, + /* f8 */ 0xe7b487, 0xe7b484, 0xe7b486, 0xe7bcb8, + /* fc */ 0xe7be8e, 0xe7bebf, 0xe88084, + + /*** Two byte table, leaf: adxx - offset 0x00a0c ***/ + + /* 40 */ 0xe88090, 0xe8808d, 0xe88091, 0xe880b6, + /* 44 */ 0xe88396, 0xe883a5, 0xe8839a, 0xe88383, + /* 48 */ 0xe88384, 0xe8838c, 0xe883a1, 0xe8839b, + /* 4c */ 0xe8838e, 0xe8839e, 0xe883a4, 0xe8839d, + /* 50 */ 0xe887b4, 0xe888a2, 0xe88ba7, 0xe88c83, + /* 54 */ 0xe88c85, 0xe88ba3, 0xe88b9b, 0xe88ba6, + /* 58 */ 0xe88c84, 0xe88ba5, 0xe88c82, 0xe88c89, + /* 5c */ 0xe88b92, 0xe88b97, 0xe88bb1, 0xe88c81, + /* 60 */ 0xe88b9c, 0xe88b94, 0xe88b91, 0xe88b9e, + /* 64 */ 0xe88b93, 0xe88b9f, 0xe88baf, 0xe88c86, + /* 68 */ 0xe89990, 0xe899b9, 0xe899bb, 0xe899ba, + /* 6c */ 0xe8a18d, 0xe8a1ab, 0xe8a681, 0xe8a794, + /* 70 */ 0xe8a888, 0xe8a882, 0xe8a883, 0xe8b29e, + /* 74 */ 0xe8b2a0, 0xe8b5b4, 0xe8b5b3, 0xe8b6b4, + /* 78 */ 0xe8bb8d, 0xe8bb8c, 0xe8bfb0, 0xe8bfa6, + /* 7c */ 0xe8bfa2, 0xe8bfaa, 0xe8bfa5, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe8bfad, 0xe8bfab, 0xe8bfa4, + /* a4 */ 0xe8bfa8, 0xe9838a, 0xe9838e, 0xe98381, + /* a8 */ 0xe98383, 0xe9858b, 0xe9858a, 0xe9878d, + /* ac */ 0xe99682, 0xe99990, 0xe9998b, 0xe9998c, + /* b0 */ 0xe9998d, 0xe99da2, 0xe99da9, 0xe99f8b, + /* b4 */ 0xe99fad, 0xe99fb3, 0xe9a081, 0xe9a2a8, + /* b8 */ 0xe9a39b, 0xe9a39f, 0xe9a696, 0xe9a699, + /* bc */ 0xe4b998, 0xe4bab3, 0xe5808c, 0xe5808d, + /* c0 */ 0xe580a3, 0xe4bfaf, 0xe580a6, 0xe580a5, + /* c4 */ 0xe4bfb8, 0xe580a9, 0xe58096, 0xe58086, + /* c8 */ 0xe580bc, 0xe5809f, 0xe5809a, 0xe58092, + /* cc */ 0xe58091, 0xe4bfba, 0xe58080, 0xe58094, + /* d0 */ 0xe580a8, 0xe4bfb1, 0xe580a1, 0xe5808b, + /* d4 */ 0xe58099, 0xe58098, 0xe4bfb3, 0xe4bfae, + /* d8 */ 0xe580ad, 0xe580aa, 0xe4bfbe, 0xe580ab, + /* dc */ 0xe58089, 0xe585bc, 0xe586a4, 0xe586a5, + /* e0 */ 0xe586a2, 0xe5878d, 0xe5878c, 0xe58786, + /* e4 */ 0xe5878b, 0xe58996, 0xe5899c, 0xe58994, + /* e8 */ 0xe5899b, 0xe5899d, 0xe58caa, 0xe58dbf, + /* ec */ 0xe58e9f, 0xe58e9d, 0xe58f9f, 0xe593a8, + /* f0 */ 0xe59490, 0xe59481, 0xe594b7, 0xe593bc, + /* f4 */ 0xe593a5, 0xe593b2, 0xe59486, 0xe593ba, + /* f8 */ 0xe59494, 0xe593a9, 0xe593ad, 0xe593a1, + /* fc */ 0xe59489, 0xe593ae, 0xe593aa, + + /*** Two byte table, leaf: aexx - offset 0x00acb ***/ + + /* 40 */ 0xe593a6, 0xe594a7, 0xe59487, 0xe593bd, + /* 44 */ 0xe5948f, 0xe59c83, 0xe59c84, 0xe59f82, + /* 48 */ 0xe59f94, 0xe59f8b, 0xe59f83, 0xe5a089, + /* 4c */ 0xe5a48f, 0xe5a597, 0xe5a598, 0xe5a59a, + /* 50 */ 0xe5a891, 0xe5a898, 0xe5a89c, 0xe5a89f, + /* 54 */ 0xe5a89b, 0xe5a893, 0xe5a7ac, 0xe5a8a0, + /* 58 */ 0xe5a8a3, 0xe5a8a9, 0xe5a8a5, 0xe5a88c, + /* 5c */ 0xe5a889, 0xe5adab, 0xe5b198, 0xe5aeb0, + /* 60 */ 0xe5aeb3, 0xe5aeb6, 0xe5aeb4, 0xe5aeae, + /* 64 */ 0xe5aeb5, 0xe5aeb9, 0xe5aeb8, 0xe5b084, + /* 68 */ 0xe5b191, 0xe5b195, 0xe5b190, 0xe5b3ad, + /* 6c */ 0xe5b3bd, 0xe5b3bb, 0xe5b3aa, 0xe5b3a8, + /* 70 */ 0xe5b3b0, 0xe5b3b6, 0xe5b481, 0xe5b3b4, + /* 74 */ 0xe5b7ae, 0xe5b8ad, 0xe5b8ab, 0xe5baab, + /* 78 */ 0xe5baad, 0xe5baa7, 0xe5bcb1, 0xe5be92, + /* 7c */ 0xe5be91, 0xe5be90, 0xe68199, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe681a3, 0xe681a5, 0xe68190, + /* a4 */ 0xe68195, 0xe681ad, 0xe681a9, 0xe681af, + /* a8 */ 0xe68284, 0xe6829f, 0xe6829a, 0xe6828d, + /* ac */ 0xe68294, 0xe6828c, 0xe68285, 0xe68296, + /* b0 */ 0xe68987, 0xe68bb3, 0xe68c88, 0xe68bbf, + /* b4 */ 0xe68d8e, 0xe68cbe, 0xe68caf, 0xe68d95, + /* b8 */ 0xe68d82, 0xe68d86, 0xe68d8f, 0xe68d89, + /* bc */ 0xe68cba, 0xe68d90, 0xe68cbd, 0xe68caa, + /* c0 */ 0xe68cab, 0xe68ca8, 0xe68d8d, 0xe68d8c, + /* c4 */ 0xe69588, 0xe69589, 0xe69699, 0xe69781, + /* c8 */ 0xe69785, 0xe69982, 0xe69989, 0xe6998f, + /* cc */ 0xe69983, 0xe69992, 0xe6998c, 0xe69985, + /* d0 */ 0xe69981, 0xe69bb8, 0xe69c94, 0xe69c95, + /* d4 */ 0xe69c97, 0xe6a0a1, 0xe6a0b8, 0xe6a188, + /* d8 */ 0xe6a186, 0xe6a193, 0xe6a0b9, 0xe6a182, + /* dc */ 0xe6a194, 0xe6a0a9, 0xe6a2b3, 0xe6a097, + /* e0 */ 0xe6a18c, 0xe6a191, 0xe6a0bd, 0xe69fb4, + /* e4 */ 0xe6a190, 0xe6a180, 0xe6a0bc, 0xe6a183, + /* e8 */ 0xe6a0aa, 0xe6a185, 0xe6a093, 0xe6a098, + /* ec */ 0xe6a181, 0xe6ae8a, 0xe6ae89, 0xe6aeb7, + /* f0 */ 0xe6b0a3, 0xe6b0a7, 0xe6b0a8, 0xe6b0a6, + /* f4 */ 0xe6b0a4, 0xe6b3b0, 0xe6b5aa, 0xe6b695, + /* f8 */ 0xe6b688, 0xe6b687, 0xe6b5a6, 0xe6b5b8, + /* fc */ 0xe6b5b7, 0xe6b599, 0xe6b693, + + /*** Two byte table, leaf: afxx - offset 0x00b8a ***/ + + /* 40 */ 0xe6b5ac, 0xe6b689, 0xe6b5ae, 0xe6b59a, + /* 44 */ 0xe6b5b4, 0xe6b5a9, 0xe6b68c, 0xe6b68a, + /* 48 */ 0xe6b5b9, 0xe6b685, 0xe6b5a5, 0xe6b694, + /* 4c */ 0xe7838a, 0xe78398, 0xe783a4, 0xe78399, + /* 50 */ 0xe78388, 0xe7838f, 0xe788b9, 0xe789b9, + /* 54 */ 0xe78bbc, 0xe78bb9, 0xe78bbd, 0xe78bb8, + /* 58 */ 0xe78bb7, 0xe78e86, 0xe78fad, 0xe79089, + /* 5c */ 0xe78fae, 0xe78fa0, 0xe78faa, 0xe78f9e, + /* 60 */ 0xe79594, 0xe7959d, 0xe7959c, 0xe7959a, + /* 64 */ 0xe79599, 0xe796be, 0xe79785, 0xe79787, + /* 68 */ 0xe796b2, 0xe796b3, 0xe796bd, 0xe796bc, + /* 6c */ 0xe796b9, 0xe79782, 0xe796b8, 0xe79a8b, + /* 70 */ 0xe79ab0, 0xe79b8a, 0xe79b8d, 0xe79b8e, + /* 74 */ 0xe79ca9, 0xe79c9f, 0xe79ca0, 0xe79ca8, + /* 78 */ 0xe79fa9, 0xe7a0b0, 0xe7a0a7, 0xe7a0b8, + /* 7c */ 0xe7a09d, 0xe7a0b4, 0xe7a0b7, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7a0a5, 0xe7a0ad, 0xe7a0a0, + /* a4 */ 0xe7a09f, 0xe7a0b2, 0xe7a595, 0xe7a590, + /* a8 */ 0xe7a5a0, 0xe7a59f, 0xe7a596, 0xe7a59e, + /* ac */ 0xe7a59d, 0xe7a597, 0xe7a59a, 0xe7a7a4, + /* b0 */ 0xe7a7a3, 0xe7a7a7, 0xe7a79f, 0xe7a7a6, + /* b4 */ 0xe7a7a9, 0xe7a798, 0xe7aa84, 0xe7aa88, + /* b8 */ 0xe7ab99, 0xe7ac86, 0xe7ac91, 0xe7b289, + /* bc */ 0xe7b4a1, 0xe7b497, 0xe7b48b, 0xe7b48a, + /* c0 */ 0xe7b4a0, 0xe7b4a2, 0xe7b494, 0xe7b490, + /* c4 */ 0xe7b495, 0xe7b49a, 0xe7b49c, 0xe7b48d, + /* c8 */ 0xe7b499, 0xe7b49b, 0xe7bcba, 0xe7bd9f, + /* cc */ 0xe7be94, 0xe7bf85, 0xe7bf81, 0xe88086, + /* d0 */ 0xe88098, 0xe88095, 0xe88099, 0xe88097, + /* d4 */ 0xe880bd, 0xe880bf, 0xe883b1, 0xe88482, + /* d8 */ 0xe883b0, 0xe88485, 0xe883ad, 0xe883b4, + /* dc */ 0xe88486, 0xe883b8, 0xe883b3, 0xe88488, + /* e0 */ 0xe883bd, 0xe8848a, 0xe883bc, 0xe883af, + /* e4 */ 0xe887ad, 0xe887ac, 0xe88880, 0xe88890, + /* e8 */ 0xe888aa, 0xe888ab, 0xe888a8, 0xe888ac, + /* ec */ 0xe88abb, 0xe88cab, 0xe88d92, 0xe88d94, + /* f0 */ 0xe88d8a, 0xe88cb8, 0xe88d90, 0xe88d89, + /* f4 */ 0xe88cb5, 0xe88cb4, 0xe88d8f, 0xe88cb2, + /* f8 */ 0xe88cb9, 0xe88cb6, 0xe88c97, 0xe88d80, + /* fc */ 0xe88cb1, 0xe88ca8, 0xe88d83, + + /*** Two byte table, leaf: b0xx - offset 0x00c49 ***/ + + /* 40 */ 0xe89994, 0xe89a8a, 0xe89aaa, 0xe89a93, + /* 44 */ 0xe89aa4, 0xe89aa9, 0xe89a8c, 0xe89aa3, + /* 48 */ 0xe89a9c, 0xe8a1b0, 0xe8a1b7, 0xe8a281, + /* 4c */ 0xe8a282, 0xe8a1bd, 0xe8a1b9, 0xe8a898, + /* 50 */ 0xe8a890, 0xe8a88e, 0xe8a88c, 0xe8a895, + /* 54 */ 0xe8a88a, 0xe8a897, 0xe8a893, 0xe8a896, + /* 58 */ 0xe8a88f, 0xe8a891, 0xe8b188, 0xe8b1ba, + /* 5c */ 0xe8b1b9, 0xe8b2a1, 0xe8b2a2, 0xe8b5b7, + /* 60 */ 0xe8baac, 0xe8bb92, 0xe8bb94, 0xe8bb8f, + /* 64 */ 0xe8beb1, 0xe98081, 0xe98086, 0xe8bfb7, + /* 68 */ 0xe98080, 0xe8bfba, 0xe8bfb4, 0xe98083, + /* 6c */ 0xe8bfbd, 0xe98085, 0xe8bfb8, 0xe98295, + /* 70 */ 0xe983a1, 0xe9839d, 0xe983a2, 0xe98592, + /* 74 */ 0xe9858d, 0xe9858c, 0xe98798, 0xe9879d, + /* 78 */ 0xe98797, 0xe9879c, 0xe98799, 0xe99683, + /* 7c */ 0xe999a2, 0xe999a3, 0xe999a1, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9999b, 0xe9999d, 0xe999a4, + /* a4 */ 0xe99998, 0xe9999e, 0xe99abb, 0xe9a3a2, + /* a8 */ 0xe9a6ac, 0xe9aaa8, 0xe9ab98, 0xe9aca5, + /* ac */ 0xe9acb2, 0xe9acbc, 0xe4b9be, 0xe581ba, + /* b0 */ 0xe581bd, 0xe5819c, 0xe58187, 0xe58183, + /* b4 */ 0xe5818c, 0xe5819a, 0xe58189, 0xe581a5, + /* b8 */ 0xe581b6, 0xe5818e, 0xe58195, 0xe581b5, + /* bc */ 0xe581b4, 0xe581b7, 0xe5818f, 0xe5808f, + /* c0 */ 0xe581af, 0xe581ad, 0xe5859c, 0xe58695, + /* c4 */ 0xe587b0, 0xe589aa, 0xe589af, 0xe58b92, + /* c8 */ 0xe58b99, 0xe58b98, 0xe58b95, 0xe58c90, + /* cc */ 0xe58c8f, 0xe58c99, 0xe58cbf, 0xe58d80, + /* d0 */ 0xe58cbe, 0xe58f83, 0xe69bbc, 0xe59586, + /* d4 */ 0xe595aa, 0xe595a6, 0xe59584, 0xe5959e, + /* d8 */ 0xe595a1, 0xe59583, 0xe5958a, 0xe594b1, + /* dc */ 0xe59596, 0xe5958f, 0xe59595, 0xe594af, + /* e0 */ 0xe595a4, 0xe594b8, 0xe594ae, 0xe5959c, + /* e4 */ 0xe594ac, 0xe595a3, 0xe594b3, 0xe59581, + /* e8 */ 0xe59597, 0xe59c88, 0xe59c8b, 0xe59c89, + /* ec */ 0xe59f9f, 0xe5a085, 0xe5a08a, 0xe5a086, + /* f0 */ 0xe59fa0, 0xe59fa4, 0xe59fba, 0xe5a082, + /* f4 */ 0xe5a0b5, 0xe59fb7, 0xe59fb9, 0xe5a4a0, + /* f8 */ 0xe5a5a2, 0xe5a8b6, 0xe5a981, 0xe5a989, + /* fc */ 0xe5a9a6, 0xe5a9aa, 0xe5a980, + + /*** Two byte table, leaf: b1xx - offset 0x00d08 ***/ + + /* 40 */ 0xe5a8bc, 0xe5a9a2, 0xe5a99a, 0xe5a986, + /* 44 */ 0xe5a98a, 0xe5adb0, 0xe5af87, 0xe5af85, + /* 48 */ 0xe5af84, 0xe5af82, 0xe5aebf, 0xe5af86, + /* 4c */ 0xe5b089, 0xe5b088, 0xe5b087, 0xe5b1a0, + /* 50 */ 0xe5b19c, 0xe5b19d, 0xe5b487, 0xe5b486, + /* 54 */ 0xe5b48e, 0xe5b49b, 0xe5b496, 0xe5b4a2, + /* 58 */ 0xe5b491, 0xe5b4a9, 0xe5b494, 0xe5b499, + /* 5c */ 0xe5b4a4, 0xe5b4a7, 0xe5b497, 0xe5b7a2, + /* 60 */ 0xe5b8b8, 0xe5b8b6, 0xe5b8b3, 0xe5b8b7, + /* 64 */ 0xe5bab7, 0xe5bab8, 0xe5bab6, 0xe5bab5, + /* 68 */ 0xe5babe, 0xe5bcb5, 0xe5bcb7, 0xe5bd97, + /* 6c */ 0xe5bdac, 0xe5bda9, 0xe5bdab, 0xe5be97, + /* 70 */ 0xe5be99, 0xe5be9e, 0xe5be98, 0xe5bea1, + /* 74 */ 0xe5bea0, 0xe5be9c, 0xe681bf, 0xe682a3, + /* 78 */ 0xe68289, 0xe682a0, 0xe682a8, 0xe6838b, + /* 7c */ 0xe682b4, 0xe683a6, 0xe682bd, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe68385, 0xe682bb, 0xe682b5, + /* a4 */ 0xe6839c, 0xe682bc, 0xe68398, 0xe68395, + /* a8 */ 0xe68386, 0xe6839f, 0xe682b8, 0xe6839a, + /* ac */ 0xe68387, 0xe6889a, 0xe6889b, 0xe68988, + /* b0 */ 0xe68ea0, 0xe68ea7, 0xe68db2, 0xe68e96, + /* b4 */ 0xe68ea2, 0xe68ea5, 0xe68db7, 0xe68da7, + /* b8 */ 0xe68e98, 0xe68eaa, 0xe68db1, 0xe68ea9, + /* bc */ 0xe68e89, 0xe68e83, 0xe68e9b, 0xe68dab, + /* c0 */ 0xe68ea8, 0xe68e84, 0xe68e88, 0xe68e99, + /* c4 */ 0xe68ea1, 0xe68eac, 0xe68e92, 0xe68e8f, + /* c8 */ 0xe68e80, 0xe68dbb, 0xe68da9, 0xe68da8, + /* cc */ 0xe68dba, 0xe6959d, 0xe69596, 0xe69591, + /* d0 */ 0xe69599, 0xe69597, 0xe5959f, 0xe6958f, + /* d4 */ 0xe69598, 0xe69595, 0xe69594, 0xe6969c, + /* d8 */ 0xe6969b, 0xe696ac, 0xe6978f, 0xe6978b, + /* dc */ 0xe6978c, 0xe6978e, 0xe6999d, 0xe6999a, + /* e0 */ 0xe699a4, 0xe699a8, 0xe699a6, 0xe6999e, + /* e4 */ 0xe69bb9, 0xe58b97, 0xe69c9b, 0xe6a281, + /* e8 */ 0xe6a2af, 0xe6a2a2, 0xe6a293, 0xe6a2b5, + /* ec */ 0xe6a1bf, 0xe6a1b6, 0xe6a2b1, 0xe6a2a7, + /* f0 */ 0xe6a297, 0xe6a2b0, 0xe6a283, 0xe6a384, + /* f4 */ 0xe6a2ad, 0xe6a286, 0xe6a285, 0xe6a294, + /* f8 */ 0xe6a29d, 0xe6a2a8, 0xe6a29f, 0xe6a2a1, + /* fc */ 0xe6a282, 0xe6acb2, 0xe6aeba, + + /*** Two byte table, leaf: b2xx - offset 0x00dc7 ***/ + + /* 40 */ 0xe6afab, 0xe6afac, 0xe6b0ab, 0xe6b68e, + /* 44 */ 0xe6b6bc, 0xe6b7b3, 0xe6b799, 0xe6b6b2, + /* 48 */ 0xe6b7a1, 0xe6b78c, 0xe6b7a4, 0xe6b7bb, + /* 4c */ 0xe6b7ba, 0xe6b885, 0xe6b787, 0xe6b78b, + /* 50 */ 0xe6b6af, 0xe6b791, 0xe6b6ae, 0xe6b79e, + /* 54 */ 0xe6b7b9, 0xe6b6b8, 0xe6b7b7, 0xe6b7b5, + /* 58 */ 0xe6b785, 0xe6b792, 0xe6b89a, 0xe6b6b5, + /* 5c */ 0xe6b79a, 0xe6b7ab, 0xe6b798, 0xe6b7aa, + /* 60 */ 0xe6b7b1, 0xe6b7ae, 0xe6b7a8, 0xe6b786, + /* 64 */ 0xe6b784, 0xe6b6aa, 0xe6b7ac, 0xe6b6bf, + /* 68 */ 0xe6b7a6, 0xe783b9, 0xe78489, 0xe7848a, + /* 6c */ 0xe783bd, 0xe783af, 0xe788bd, 0xe789bd, + /* 70 */ 0xe78a81, 0xe78c9c, 0xe78c9b, 0xe78c96, + /* 74 */ 0xe78c93, 0xe78c99, 0xe78e87, 0xe79085, + /* 78 */ 0xe7908a, 0xe79083, 0xe79086, 0xe78fbe, + /* 7c */ 0xe7908d, 0xe793a0, 0xe793b6, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe793b7, 0xe7949c, 0xe794a2, + /* a4 */ 0xe795a5, 0xe795a6, 0xe795a2, 0xe795b0, + /* a8 */ 0xe7968f, 0xe79794, 0xe79795, 0xe796b5, + /* ac */ 0xe7978a, 0xe7978d, 0xe79a8e, 0xe79b94, + /* b0 */ 0xe79b92, 0xe79b9b, 0xe79cb7, 0xe79cbe, + /* b4 */ 0xe79cbc, 0xe79cb6, 0xe79cb8, 0xe79cba, + /* b8 */ 0xe7a1ab, 0xe7a183, 0xe7a18e, 0xe7a5a5, + /* bc */ 0xe7a5a8, 0xe7a5ad, 0xe7a7bb, 0xe7aa92, + /* c0 */ 0xe7aa95, 0xe7aca0, 0xe7aca8, 0xe7ac9b, + /* c4 */ 0xe7acac, 0xe7aca6, 0xe7ac99, 0xe7ac9e, + /* c8 */ 0xe7acae, 0xe7b292, 0xe7b297, 0xe7b295, + /* cc */ 0xe7b586, 0xe7b583, 0xe7b5b1, 0xe7b4ae, + /* d0 */ 0xe7b4b9, 0xe7b4bc, 0xe7b580, 0xe7b4b0, + /* d4 */ 0xe7b4b3, 0xe7b584, 0xe7b4af, 0xe7b582, + /* d8 */ 0xe7b4b2, 0xe7b4b1, 0xe7bcbd, 0xe7be9e, + /* dc */ 0xe7be9a, 0xe7bf8c, 0xe7bf8e, 0xe7bf92, + /* e0 */ 0xe8809c, 0xe8818a, 0xe88186, 0xe884af, + /* e4 */ 0xe88496, 0xe884a3, 0xe884ab, 0xe884a9, + /* e8 */ 0xe884b0, 0xe884a4, 0xe88882, 0xe888b5, + /* ec */ 0xe888b7, 0xe888b6, 0xe888b9, 0xe88e8e, + /* f0 */ 0xe88e9e, 0xe88e98, 0xe88db8, 0xe88ea2, + /* f4 */ 0xe88e96, 0xe88ebd, 0xe88eab, 0xe88e92, + /* f8 */ 0xe88e8a, 0xe88e93, 0xe88e89, 0xe88ea0, + /* fc */ 0xe88db7, 0xe88dbb, 0xe88dbc, + + /*** Two byte table, leaf: b3xx - offset 0x00e86 ***/ + + /* 40 */ 0xe88e86, 0xe88ea7, 0xe89995, 0xe5bdaa, + /* 44 */ 0xe89b87, 0xe89b80, 0xe89ab6, 0xe89b84, + /* 48 */ 0xe89ab5, 0xe89b86, 0xe89b8b, 0xe89ab1, + /* 4c */ 0xe89aaf, 0xe89b89, 0xe8a193, 0xe8a29e, + /* 50 */ 0xe8a288, 0xe8a2ab, 0xe8a292, 0xe8a296, + /* 54 */ 0xe8a28d, 0xe8a28b, 0xe8a693, 0xe8a68f, + /* 58 */ 0xe8a8aa, 0xe8a89d, 0xe8a8a3, 0xe8a8a5, + /* 5c */ 0xe8a8b1, 0xe8a8ad, 0xe8a89f, 0xe8a89b, + /* 60 */ 0xe8a8a2, 0xe8b189, 0xe8b19a, 0xe8b2a9, + /* 64 */ 0xe8b2ac, 0xe8b2ab, 0xe8b2a8, 0xe8b2aa, + /* 68 */ 0xe8b2a7, 0xe8b5a7, 0xe8b5a6, 0xe8b6be, + /* 6c */ 0xe8b6ba, 0xe8bb9b, 0xe8bb9f, 0xe98099, + /* 70 */ 0xe9808d, 0xe9809a, 0xe98097, 0xe980a3, + /* 74 */ 0xe9809f, 0xe9809d, 0xe98090, 0xe98095, + /* 78 */ 0xe9809e, 0xe980a0, 0xe9808f, 0xe980a2, + /* 7c */ 0xe98096, 0xe9809b, 0xe98094, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe983a8, 0xe983ad, 0xe983bd, + /* a4 */ 0xe98597, 0xe9878e, 0xe987b5, 0xe987a6, + /* a8 */ 0xe987a3, 0xe987a7, 0xe987ad, 0xe987a9, + /* ac */ 0xe99689, 0xe999aa, 0xe999b5, 0xe999b3, + /* b0 */ 0xe999b8, 0xe999b0, 0xe999b4, 0xe999b6, + /* b4 */ 0xe999b7, 0xe999ac, 0xe99b80, 0xe99baa, + /* b8 */ 0xe99ba9, 0xe7aba0, 0xe7ab9f, 0xe9a082, + /* bc */ 0xe9a083, 0xe9ad9a, 0xe9b3a5, 0xe9b9b5, + /* c0 */ 0xe9b9bf, 0xe9baa5, 0xe9babb, 0xe582a2, + /* c4 */ 0xe5828d, 0xe58285, 0xe58299, 0xe58291, + /* c8 */ 0xe58280, 0xe58296, 0xe58298, 0xe5829a, + /* cc */ 0xe69c80, 0xe587b1, 0xe589b2, 0xe589b4, + /* d0 */ 0xe589b5, 0xe589a9, 0xe58b9e, 0xe58b9d, + /* d4 */ 0xe58b9b, 0xe58d9a, 0xe58ea5, 0xe595bb, + /* d8 */ 0xe59680, 0xe596a7, 0xe595bc, 0xe5968a, + /* dc */ 0xe5969d, 0xe59698, 0xe59682, 0xe5969c, + /* e0 */ 0xe596aa, 0xe59694, 0xe59687, 0xe5968b, + /* e4 */ 0xe59683, 0xe596b3, 0xe596ae, 0xe5969f, + /* e8 */ 0xe594be, 0xe596b2, 0xe5969a, 0xe596bb, + /* ec */ 0xe596ac, 0xe596b1, 0xe595be, 0xe59689, + /* f0 */ 0xe596ab, 0xe59699, 0xe59c8d, 0xe5a0af, + /* f4 */ 0xe5a0aa, 0xe5a0b4, 0xe5a0a4, 0xe5a0b0, + /* f8 */ 0xe5a0b1, 0xe5a0a1, 0xe5a09d, 0xe5a0a0, + /* fc */ 0xe5a3b9, 0xe5a3ba, 0xe5a5a0, + + /*** Two byte table, leaf: b4xx - offset 0x00f45 ***/ + + /* 40 */ 0xe5a9b7, 0xe5aa9a, 0xe5a9bf, 0xe5aa92, + /* 44 */ 0xe5aa9b, 0xe5aaa7, 0xe5adb3, 0xe5adb1, + /* 48 */ 0xe5af92, 0xe5af8c, 0xe5af93, 0xe5af90, + /* 4c */ 0xe5b08a, 0xe5b08b, 0xe5b0b1, 0xe5b58c, + /* 50 */ 0xe5b590, 0xe5b4b4, 0xe5b587, 0xe5b7bd, + /* 54 */ 0xe5b985, 0xe5b8bd, 0xe5b980, 0xe5b983, + /* 58 */ 0xe5b9be, 0xe5bb8a, 0xe5bb81, 0xe5bb82, + /* 5c */ 0xe5bb84, 0xe5bcbc, 0xe5bdad, 0xe5bea9, + /* 60 */ 0xe5beaa, 0xe5bea8, 0xe68391, 0xe683a1, + /* 64 */ 0xe682b2, 0xe682b6, 0xe683a0, 0xe6849c, + /* 68 */ 0xe684a3, 0xe683ba, 0xe68495, 0xe683b0, + /* 6c */ 0xe683bb, 0xe683b4, 0xe685a8, 0xe683b1, + /* 70 */ 0xe6848e, 0xe683b6, 0xe68489, 0xe68480, + /* 74 */ 0xe68492, 0xe6889f, 0xe68989, 0xe68ea3, + /* 78 */ 0xe68e8c, 0xe68f8f, 0xe68f80, 0xe68fa9, + /* 7c */ 0xe68f89, 0xe68f86, 0xe68f8d, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe68f92, 0xe68fa3, 0xe68f90, + /* a4 */ 0xe68fa1, 0xe68f96, 0xe68fad, 0xe68fae, + /* a8 */ 0xe68db6, 0xe68fb4, 0xe68faa, 0xe68f9b, + /* ac */ 0xe69192, 0xe68f9a, 0xe68fb9, 0xe6959e, + /* b0 */ 0xe695a6, 0xe695a2, 0xe695a3, 0xe69691, + /* b4 */ 0xe69690, 0xe696af, 0xe699ae, 0xe699b0, + /* b8 */ 0xe699b4, 0xe699b6, 0xe699af, 0xe69a91, + /* bc */ 0xe699ba, 0xe699be, 0xe699b7, 0xe69bbe, + /* c0 */ 0xe69bbf, 0xe69c9f, 0xe69c9d, 0xe6a3ba, + /* c4 */ 0xe6a395, 0xe6a3a0, 0xe6a398, 0xe6a397, + /* c8 */ 0xe6a485, 0xe6a39f, 0xe6a3b5, 0xe6a3ae, + /* cc */ 0xe6a3a7, 0xe6a3b9, 0xe6a392, 0xe6a3b2, + /* d0 */ 0xe6a3a3, 0xe6a38b, 0xe6a38d, 0xe6a48d, + /* d4 */ 0xe6a492, 0xe6a48e, 0xe6a389, 0xe6a39a, + /* d8 */ 0xe6a5ae, 0xe6a3bb, 0xe6acbe, 0xe6acba, + /* dc */ 0xe6acbd, 0xe6ae98, 0xe6ae96, 0xe6aebc, + /* e0 */ 0xe6afaf, 0xe6b0ae, 0xe6b0af, 0xe6b0ac, + /* e4 */ 0xe6b8af, 0xe6b8b8, 0xe6b994, 0xe6b8a1, + /* e8 */ 0xe6b8b2, 0xe6b9a7, 0xe6b98a, 0xe6b8a0, + /* ec */ 0xe6b8a5, 0xe6b8a3, 0xe6b89b, 0xe6b99b, + /* f0 */ 0xe6b998, 0xe6b8a4, 0xe6b996, 0xe6b9ae, + /* f4 */ 0xe6b8ad, 0xe6b8a6, 0xe6b9af, 0xe6b8b4, + /* f8 */ 0xe6b98d, 0xe6b8ba, 0xe6b8ac, 0xe6b983, + /* fc */ 0xe6b89d, 0xe6b8be, 0xe6bb8b, + + /*** Two byte table, leaf: b5xx - offset 0x01004 ***/ + + /* 40 */ 0xe6ba89, 0xe6b899, 0xe6b98e, 0xe6b9a3, + /* 44 */ 0xe6b984, 0xe6b9b2, 0xe6b9a9, 0xe6b99f, + /* 48 */ 0xe78499, 0xe7849a, 0xe784a6, 0xe784b0, + /* 4c */ 0xe784a1, 0xe784b6, 0xe785ae, 0xe7849c, + /* 50 */ 0xe7898c, 0xe78a84, 0xe78a80, 0xe78cb6, + /* 54 */ 0xe78ca5, 0xe78cb4, 0xe78ca9, 0xe790ba, + /* 58 */ 0xe790aa, 0xe790b3, 0xe790a2, 0xe790a5, + /* 5c */ 0xe790b5, 0xe790b6, 0xe790b4, 0xe790af, + /* 60 */ 0xe7909b, 0xe790a6, 0xe790a8, 0xe794a5, + /* 64 */ 0xe794a6, 0xe795ab, 0xe795aa, 0xe797a2, + /* 68 */ 0xe7979b, 0xe797a3, 0xe79799, 0xe79798, + /* 6c */ 0xe7979e, 0xe797a0, 0xe799bb, 0xe799bc, + /* 70 */ 0xe79a96, 0xe79a93, 0xe79ab4, 0xe79b9c, + /* 74 */ 0xe79d8f, 0xe79fad, 0xe7a19d, 0xe7a1ac, + /* 78 */ 0xe7a1af, 0xe7a88d, 0xe7a888, 0xe7a88b, + /* 7c */ 0xe7a885, 0xe7a880, 0xe7aa98, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7aa97, 0xe7aa96, 0xe7aba5, + /* a4 */ 0xe7aba3, 0xe7ad89, 0xe7ad96, 0xe7ad86, + /* a8 */ 0xe7ad90, 0xe7ad92, 0xe7ad94, 0xe7ad8d, + /* ac */ 0xe7ad8b, 0xe7ad8f, 0xe7ad91, 0xe7b29f, + /* b0 */ 0xe7b2a5, 0xe7b59e, 0xe7b590, 0xe7b5a8, + /* b4 */ 0xe7b595, 0xe7b4ab, 0xe7b5ae, 0xe7b5b2, + /* b8 */ 0xe7b5a1, 0xe7b5a6, 0xe7b5a2, 0xe7b5b0, + /* bc */ 0xe7b5b3, 0xe59684, 0xe7bf94, 0xe7bf95, + /* c0 */ 0xe8808b, 0xe88192, 0xe88285, 0xe88595, + /* c4 */ 0xe88594, 0xe8858b, 0xe88591, 0xe8858e, + /* c8 */ 0xe884b9, 0xe88586, 0xe884be, 0xe8858c, + /* cc */ 0xe88593, 0xe885b4, 0xe88892, 0xe8889c, + /* d0 */ 0xe88fa9, 0xe89083, 0xe88fb8, 0xe8908d, + /* d4 */ 0xe88fa0, 0xe88f85, 0xe8908b, 0xe88f81, + /* d8 */ 0xe88faf, 0xe88fb1, 0xe88fb4, 0xe89197, + /* dc */ 0xe8908a, 0xe88fb0, 0xe8908c, 0xe88f8c, + /* e0 */ 0xe88fbd, 0xe88fb2, 0xe88f8a, 0xe890b8, + /* e4 */ 0xe8908e, 0xe89084, 0xe88f9c, 0xe89087, + /* e8 */ 0xe88f94, 0xe88f9f, 0xe8999b, 0xe89b9f, + /* ec */ 0xe89b99, 0xe89bad, 0xe89b94, 0xe89b9b, + /* f0 */ 0xe89ba4, 0xe89b90, 0xe89b9e, 0xe8a197, + /* f4 */ 0xe8a381, 0xe8a382, 0xe8a2b1, 0xe8a683, + /* f8 */ 0xe8a696, 0xe8a8bb, 0xe8a9a0, 0xe8a995, + /* fc */ 0xe8a99e, 0xe8a8bc, 0xe8a981, + + /*** Two byte table, leaf: b6xx - offset 0x010c3 ***/ + + /* 40 */ 0xe8a994, 0xe8a99b, 0xe8a990, 0xe8a986, + /* 44 */ 0xe8a8b4, 0xe8a8ba, 0xe8a8b6, 0xe8a996, + /* 48 */ 0xe8b1a1, 0xe8b282, 0xe8b2af, 0xe8b2bc, + /* 4c */ 0xe8b2b3, 0xe8b2bd, 0xe8b381, 0xe8b2bb, + /* 50 */ 0xe8b380, 0xe8b2b4, 0xe8b2b7, 0xe8b2b6, + /* 54 */ 0xe8b2bf, 0xe8b2b8, 0xe8b68a, 0xe8b685, + /* 58 */ 0xe8b681, 0xe8b78e, 0xe8b79d, 0xe8b78b, + /* 5c */ 0xe8b79a, 0xe8b791, 0xe8b78c, 0xe8b79b, + /* 60 */ 0xe8b786, 0xe8bbbb, 0xe8bbb8, 0xe8bbbc, + /* 64 */ 0xe8be9c, 0xe980ae, 0xe980b5, 0xe980b1, + /* 68 */ 0xe980b8, 0xe980b2, 0xe980b6, 0xe98482, + /* 6c */ 0xe983b5, 0xe98489, 0xe983be, 0xe985a3, + /* 70 */ 0xe985a5, 0xe9878f, 0xe98894, 0xe98895, + /* 74 */ 0xe988a3, 0xe98889, 0xe9889e, 0xe9888d, + /* 78 */ 0xe98890, 0xe98887, 0xe98891, 0xe99694, + /* 7c */ 0xe9968f, 0xe9968b, 0xe99691, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe99693, 0xe99692, 0xe9968e, + /* a4 */ 0xe99a8a, 0xe99a8e, 0xe99a8b, 0xe999bd, + /* a8 */ 0xe99a85, 0xe99a86, 0xe99a8d, 0xe999b2, + /* ac */ 0xe99a84, 0xe99b81, 0xe99b85, 0xe99b84, + /* b0 */ 0xe99b86, 0xe99b87, 0xe99baf, 0xe99bb2, + /* b4 */ 0xe99f8c, 0xe9a085, 0xe9a086, 0xe9a088, + /* b8 */ 0xe9a3a7, 0xe9a3aa, 0xe9a3af, 0xe9a3a9, + /* bc */ 0xe9a3b2, 0xe9a3ad, 0xe9a6ae, 0xe9a6ad, + /* c0 */ 0xe9bb83, 0xe9bb8d, 0xe9bb91, 0xe4ba82, + /* c4 */ 0xe582ad, 0xe582b5, 0xe582b2, 0xe582b3, + /* c8 */ 0xe58385, 0xe582be, 0xe582ac, 0xe582b7, + /* cc */ 0xe582bb, 0xe582af, 0xe58387, 0xe589bf, + /* d0 */ 0xe589b7, 0xe589bd, 0xe58b9f, 0xe58ba6, + /* d4 */ 0xe58ba4, 0xe58ba2, 0xe58ba3, 0xe58caf, + /* d8 */ 0xe5979f, 0xe597a8, 0xe59793, 0xe597a6, + /* dc */ 0xe5978e, 0xe5979c, 0xe59787, 0xe59791, + /* e0 */ 0xe597a3, 0xe597a4, 0xe597af, 0xe5979a, + /* e4 */ 0xe597a1, 0xe59785, 0xe59786, 0xe597a5, + /* e8 */ 0xe59789, 0xe59c92, 0xe59c93, 0xe5a19e, + /* ec */ 0xe5a191, 0xe5a198, 0xe5a197, 0xe5a19a, + /* f0 */ 0xe5a194, 0xe5a1ab, 0xe5a18c, 0xe5a1ad, + /* f4 */ 0xe5a18a, 0xe5a1a2, 0xe5a192, 0xe5a18b, + /* f8 */ 0xe5a5a7, 0xe5ab81, 0xe5ab89, 0xe5ab8c, + /* fc */ 0xe5aabe, 0xe5aabd, 0xe5aabc, + + /*** Two byte table, leaf: b7xx - offset 0x01182 ***/ + + /* 40 */ 0xe5aab3, 0xe5ab82, 0xe5aab2, 0xe5b5a9, + /* 44 */ 0xe5b5af, 0xe5b98c, 0xe5b9b9, 0xe5bb89, + /* 48 */ 0xe5bb88, 0xe5bc92, 0xe5bd99, 0xe5beac, + /* 4c */ 0xe5beae, 0xe6849a, 0xe6848f, 0xe68588, + /* 50 */ 0xe6849f, 0xe683b3, 0xe6849b, 0xe683b9, + /* 54 */ 0xe68481, 0xe68488, 0xe6858e, 0xe6858c, + /* 58 */ 0xe68584, 0xe6858d, 0xe684be, 0xe684b4, + /* 5c */ 0xe684a7, 0xe6848d, 0xe68486, 0xe684b7, + /* 60 */ 0xe688a1, 0xe688a2, 0xe69093, 0xe690be, + /* 64 */ 0xe6909e, 0xe690aa, 0xe690ad, 0xe690bd, + /* 68 */ 0xe690ac, 0xe6908f, 0xe6909c, 0xe69094, + /* 6c */ 0xe6908d, 0xe690b6, 0xe69096, 0xe69097, + /* 70 */ 0xe69086, 0xe695ac, 0xe6969f, 0xe696b0, + /* 74 */ 0xe69a97, 0xe69a89, 0xe69a87, 0xe69a88, + /* 78 */ 0xe69a96, 0xe69a84, 0xe69a98, 0xe69a8d, + /* 7c */ 0xe69c83, 0xe6a694, 0xe6a5ad, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6a59a, 0xe6a5b7, 0xe6a5a0, + /* a4 */ 0xe6a594, 0xe6a5b5, 0xe6a4b0, 0xe6a682, + /* a8 */ 0xe6a58a, 0xe6a5a8, 0xe6a5ab, 0xe6a59e, + /* ac */ 0xe6a593, 0xe6a5b9, 0xe6a686, 0xe6a59d, + /* b0 */ 0xe6a5a3, 0xe6a59b, 0xe6ad87, 0xe6adb2, + /* b4 */ 0xe6af80, 0xe6aebf, 0xe6af93, 0xe6afbd, + /* b8 */ 0xe6baa2, 0xe6baaf, 0xe6bb93, 0xe6bab6, + /* bc */ 0xe6bb82, 0xe6ba90, 0xe6ba9d, 0xe6bb87, + /* c0 */ 0xe6bb85, 0xe6baa5, 0xe6ba98, 0xe6babc, + /* c4 */ 0xe6baba, 0xe6baab, 0xe6bb91, 0xe6ba96, + /* c8 */ 0xe6ba9c, 0xe6bb84, 0xe6bb94, 0xe6baaa, + /* cc */ 0xe6baa7, 0xe6bab4, 0xe7858e, 0xe78599, + /* d0 */ 0xe785a9, 0xe785a4, 0xe78589, 0xe785a7, + /* d4 */ 0xe7859c, 0xe785ac, 0xe785a6, 0xe7858c, + /* d8 */ 0xe785a5, 0xe7859e, 0xe78586, 0xe785a8, + /* dc */ 0xe78596, 0xe788ba, 0xe78992, 0xe78cb7, + /* e0 */ 0xe78d85, 0xe78cbf, 0xe78cbe, 0xe791af, + /* e4 */ 0xe7919a, 0xe79195, 0xe7919f, 0xe7919e, + /* e8 */ 0xe79181, 0xe790bf, 0xe79199, 0xe7919b, + /* ec */ 0xe7919c, 0xe795b6, 0xe795b8, 0xe79880, + /* f0 */ 0xe797b0, 0xe79881, 0xe797b2, 0xe797b1, + /* f4 */ 0xe797ba, 0xe797bf, 0xe797b4, 0xe797b3, + /* f8 */ 0xe79b9e, 0xe79b9f, 0xe79d9b, 0xe79dab, + /* fc */ 0xe79da6, 0xe79d9e, 0xe79da3, + + /*** Two byte table, leaf: b8xx - offset 0x01241 ***/ + + /* 40 */ 0xe79db9, 0xe79daa, 0xe79dac, 0xe79d9c, + /* 44 */ 0xe79da5, 0xe79da8, 0xe79da2, 0xe79fae, + /* 48 */ 0xe7a28e, 0xe7a2b0, 0xe7a297, 0xe7a298, + /* 4c */ 0xe7a28c, 0xe7a289, 0xe7a1bc, 0xe7a291, + /* 50 */ 0xe7a293, 0xe7a1bf, 0xe7a5ba, 0xe7a5bf, + /* 54 */ 0xe7a681, 0xe890ac, 0xe7a6bd, 0xe7a89c, + /* 58 */ 0xe7a89a, 0xe7a8a0, 0xe7a894, 0xe7a89f, + /* 5c */ 0xe7a89e, 0xe7aa9f, 0xe7aaa0, 0xe7adb7, + /* 60 */ 0xe7af80, 0xe7ada0, 0xe7adae, 0xe7ada7, + /* 64 */ 0xe7b2b1, 0xe7b2b3, 0xe7b2b5, 0xe7b693, + /* 68 */ 0xe7b5b9, 0xe7b691, 0xe7b681, 0xe7b68f, + /* 6c */ 0xe7b59b, 0xe7bdae, 0xe7bda9, 0xe7bdaa, + /* 70 */ 0xe7bdb2, 0xe7bea9, 0xe7bea8, 0xe7bea4, + /* 74 */ 0xe88196, 0xe88198, 0xe88286, 0xe88284, + /* 78 */ 0xe885b1, 0xe885b0, 0xe885b8, 0xe885a5, + /* 7c */ 0xe885ae, 0xe885b3, 0xe885ab, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe885b9, 0xe885ba, 0xe885a6, + /* a4 */ 0xe88885, 0xe88987, 0xe89282, 0xe891b7, + /* a8 */ 0xe890bd, 0xe890b1, 0xe891b5, 0xe891a6, + /* ac */ 0xe891ab, 0xe89189, 0xe891ac, 0xe8919b, + /* b0 */ 0xe890bc, 0xe890b5, 0xe891a1, 0xe891a3, + /* b4 */ 0xe891a9, 0xe891ad, 0xe89186, 0xe8999e, + /* b8 */ 0xe8999c, 0xe8999f, 0xe89bb9, 0xe89c93, + /* bc */ 0xe89c88, 0xe89c87, 0xe89c80, 0xe89bbe, + /* c0 */ 0xe89bbb, 0xe89c82, 0xe89c83, 0xe89c86, + /* c4 */ 0xe89c8a, 0xe8a199, 0xe8a39f, 0xe8a394, + /* c8 */ 0xe8a399, 0xe8a39c, 0xe8a398, 0xe8a39d, + /* cc */ 0xe8a3a1, 0xe8a38a, 0xe8a395, 0xe8a392, + /* d0 */ 0xe8a69c, 0xe8a7a3, 0xe8a9ab, 0xe8a9b2, + /* d4 */ 0xe8a9b3, 0xe8a9a6, 0xe8a9a9, 0xe8a9b0, + /* d8 */ 0xe8aa87, 0xe8a9bc, 0xe8a9a3, 0xe8aaa0, + /* dc */ 0xe8a9b1, 0xe8aa85, 0xe8a9ad, 0xe8a9a2, + /* e0 */ 0xe8a9ae, 0xe8a9ac, 0xe8a9b9, 0xe8a9bb, + /* e4 */ 0xe8a8be, 0xe8a9a8, 0xe8b1a2, 0xe8b28a, + /* e8 */ 0xe8b289, 0xe8b38a, 0xe8b387, 0xe8b388, + /* ec */ 0xe8b384, 0xe8b2b2, 0xe8b383, 0xe8b382, + /* f0 */ 0xe8b385, 0xe8b7a1, 0xe8b79f, 0xe8b7a8, + /* f4 */ 0xe8b7af, 0xe8b7b3, 0xe8b7ba, 0xe8b7aa, + /* f8 */ 0xe8b7a4, 0xe8b7a6, 0xe8bab2, 0xe8bc83, + /* fc */ 0xe8bc89, 0xe8bbbe, 0xe8bc8a, + + /*** Two byte table, leaf: b9xx - offset 0x01300 ***/ + + /* 40 */ 0xe8be9f, 0xe8beb2, 0xe9818b, 0xe9818a, + /* 44 */ 0xe98193, 0xe98182, 0xe98194, 0xe980bc, + /* 48 */ 0xe98195, 0xe98190, 0xe98187, 0xe9818f, + /* 4c */ 0xe9818e, 0xe9818d, 0xe98191, 0xe980be, + /* 50 */ 0xe98181, 0xe98492, 0xe98497, 0xe985ac, + /* 54 */ 0xe985aa, 0xe985a9, 0xe98789, 0xe988b7, + /* 58 */ 0xe98997, 0xe988b8, 0xe988bd, 0xe98980, + /* 5c */ 0xe988be, 0xe9899b, 0xe9898b, 0xe989a4, + /* 60 */ 0xe98991, 0xe988b4, 0xe98989, 0xe9898d, + /* 64 */ 0xe98985, 0xe988b9, 0xe988bf, 0xe9899a, + /* 68 */ 0xe99698, 0xe99a98, 0xe99a94, 0xe99a95, + /* 6c */ 0xe99b8d, 0xe99b8b, 0xe99b89, 0xe99b8a, + /* 70 */ 0xe99bb7, 0xe99bbb, 0xe99bb9, 0xe99bb6, + /* 74 */ 0xe99d96, 0xe99db4, 0xe99db6, 0xe9a090, + /* 78 */ 0xe9a091, 0xe9a093, 0xe9a08a, 0xe9a092, + /* 7c */ 0xe9a08c, 0xe9a3bc, 0xe9a3b4, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9a3bd, 0xe9a3be, 0xe9a6b3, + /* a4 */ 0xe9a6b1, 0xe9a6b4, 0xe9aba1, 0xe9b3a9, + /* a8 */ 0xe9ba82, 0xe9bc8e, 0xe9bc93, 0xe9bca0, + /* ac */ 0xe583a7, 0xe583ae, 0xe583a5, 0xe58396, + /* b0 */ 0xe583ad, 0xe5839a, 0xe58395, 0xe5838f, + /* b4 */ 0xe58391, 0xe583b1, 0xe5838e, 0xe583a9, + /* b8 */ 0xe585a2, 0xe587b3, 0xe58a83, 0xe58a82, + /* bc */ 0xe58cb1, 0xe58ead, 0xe597be, 0xe59880, + /* c0 */ 0xe5989b, 0xe59897, 0xe597bd, 0xe59894, + /* c4 */ 0xe59886, 0xe59889, 0xe5988d, 0xe5988e, + /* c8 */ 0xe597b7, 0xe59896, 0xe5989f, 0xe59888, + /* cc */ 0xe59890, 0xe597b6, 0xe59c98, 0xe59c96, + /* d0 */ 0xe5a1b5, 0xe5a1be, 0xe5a283, 0xe5a293, + /* d4 */ 0xe5a28a, 0xe5a1b9, 0xe5a285, 0xe5a1bd, + /* d8 */ 0xe5a3bd, 0xe5a4a5, 0xe5a4a2, 0xe5a4a4, + /* dc */ 0xe5a5aa, 0xe5a5a9, 0xe5aba1, 0xe5aba6, + /* e0 */ 0xe5aba9, 0xe5ab97, 0xe5ab96, 0xe5ab98, + /* e4 */ 0xe5aba3, 0xe5adb5, 0xe5af9e, 0xe5afa7, + /* e8 */ 0xe5afa1, 0xe5afa5, 0xe5afa6, 0xe5afa8, + /* ec */ 0xe5afa2, 0xe5afa4, 0xe5af9f, 0xe5b08d, + /* f0 */ 0xe5b1a2, 0xe5b684, 0xe5b687, 0xe5b99b, + /* f4 */ 0xe5b9a3, 0xe5b995, 0xe5b997, 0xe5b994, + /* f8 */ 0xe5bb93, 0xe5bb96, 0xe5bc8a, 0xe5bd86, + /* fc */ 0xe5bdb0, 0xe5beb9, 0xe68587, + + /*** Two byte table, leaf: baxx - offset 0x013bf ***/ + + /* 40 */ 0xe684bf, 0xe6858b, 0xe685b7, 0xe685a2, + /* 44 */ 0xe685a3, 0xe6859f, 0xe6859a, 0xe68598, + /* 48 */ 0xe685b5, 0xe688aa, 0xe69287, 0xe69198, + /* 4c */ 0xe69194, 0xe692a4, 0xe691b8, 0xe6919f, + /* 50 */ 0xe691ba, 0xe69191, 0xe691a7, 0xe690b4, + /* 54 */ 0xe691ad, 0xe691bb, 0xe695b2, 0xe696a1, + /* 58 */ 0xe69797, 0xe69796, 0xe69aa2, 0xe69aa8, + /* 5c */ 0xe69a9d, 0xe6a69c, 0xe6a6a8, 0xe6a695, + /* 60 */ 0xe6a781, 0xe6a6ae, 0xe6a793, 0xe6a78b, + /* 64 */ 0xe6a69b, 0xe6a6b7, 0xe6a6bb, 0xe6a6ab, + /* 68 */ 0xe6a6b4, 0xe6a790, 0xe6a78d, 0xe6a6ad, + /* 6c */ 0xe6a78c, 0xe6a6a6, 0xe6a783, 0xe6a6a3, + /* 70 */ 0xe6ad89, 0xe6ad8c, 0xe6b0b3, 0xe6bcb3, + /* 74 */ 0xe6bc94, 0xe6bbbe, 0xe6bc93, 0xe6bbb4, + /* 78 */ 0xe6bca9, 0xe6bcbe, 0xe6bca0, 0xe6bcac, + /* 7c */ 0xe6bc8f, 0xe6bc82, 0xe6bca2, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6bbbf, 0xe6bbaf, 0xe6bc86, + /* a4 */ 0xe6bcb1, 0xe6bcb8, 0xe6bcb2, 0xe6bca3, + /* a8 */ 0xe6bc95, 0xe6bcab, 0xe6bcaf, 0xe6be88, + /* ac */ 0xe6bcaa, 0xe6bbac, 0xe6bc81, 0xe6bbb2, + /* b0 */ 0xe6bb8c, 0xe6bbb7, 0xe78694, 0xe78699, + /* b4 */ 0xe785bd, 0xe7868a, 0xe78684, 0xe78692, + /* b8 */ 0xe788be, 0xe78a92, 0xe78a96, 0xe78d84, + /* bc */ 0xe78d90, 0xe791a4, 0xe791a3, 0xe791aa, + /* c0 */ 0xe791b0, 0xe791ad, 0xe79484, 0xe79691, + /* c4 */ 0xe798a7, 0xe7988d, 0xe7988b, 0xe79889, + /* c8 */ 0xe79893, 0xe79ba1, 0xe79ba3, 0xe79e84, + /* cc */ 0xe79dbd, 0xe79dbf, 0xe79da1, 0xe7a381, + /* d0 */ 0xe7a29f, 0xe7a2a7, 0xe7a2b3, 0xe7a2a9, + /* d4 */ 0xe7a2a3, 0xe7a68e, 0xe7a68f, 0xe7a68d, + /* d8 */ 0xe7a8ae, 0xe7a8b1, 0xe7aaaa, 0xe7aaa9, + /* dc */ 0xe7abad, 0xe7abaf, 0xe7aea1, 0xe7ae95, + /* e0 */ 0xe7ae8b, 0xe7adb5, 0xe7ae97, 0xe7ae9d, + /* e4 */ 0xe7ae94, 0xe7ae8f, 0xe7aeb8, 0xe7ae87, + /* e8 */ 0xe7ae84, 0xe7b2b9, 0xe7b2bd, 0xe7b2be, + /* ec */ 0xe7b6bb, 0xe7b6b0, 0xe7b69c, 0xe7b6bd, + /* f0 */ 0xe7b6be, 0xe7b6a0, 0xe7b78a, 0xe7b6b4, + /* f4 */ 0xe7b6b2, 0xe7b6b1, 0xe7b6ba, 0xe7b6a2, + /* f8 */ 0xe7b6bf, 0xe7b6b5, 0xe7b6b8, 0xe7b6ad, + /* fc */ 0xe7b792, 0xe7b787, 0xe7b6ac, + + /*** Two byte table, leaf: bbxx - offset 0x0147e ***/ + + /* 40 */ 0xe7bdb0, 0xe7bfa0, 0xe7bfa1, 0xe7bf9f, + /* 44 */ 0xe8819e, 0xe8819a, 0xe88287, 0xe88590, + /* 48 */ 0xe88680, 0xe8868f, 0xe88688, 0xe8868a, + /* 4c */ 0xe885bf, 0xe88682, 0xe887a7, 0xe887ba, + /* 50 */ 0xe88887, 0xe88894, 0xe8889e, 0xe8898b, + /* 54 */ 0xe89389, 0xe892bf, 0xe89386, 0xe89384, + /* 58 */ 0xe89299, 0xe8929e, 0xe892b2, 0xe8929c, + /* 5c */ 0xe8938b, 0xe892b8, 0xe89380, 0xe89393, + /* 60 */ 0xe89290, 0xe892bc, 0xe89391, 0xe8938a, + /* 64 */ 0xe89cbf, 0xe89c9c, 0xe89cbb, 0xe89ca2, + /* 68 */ 0xe89ca5, 0xe89cb4, 0xe89c98, 0xe89d95, + /* 6c */ 0xe89cb7, 0xe89ca9, 0xe8a3b3, 0xe8a482, + /* 70 */ 0xe8a3b4, 0xe8a3b9, 0xe8a3b8, 0xe8a3bd, + /* 74 */ 0xe8a3a8, 0xe8a49a, 0xe8a3af, 0xe8aaa6, + /* 78 */ 0xe8aa8c, 0xe8aa9e, 0xe8aaa3, 0xe8aa8d, + /* 7c */ 0xe8aaa1, 0xe8aa93, 0xe8aaa4, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe8aaaa, 0xe8aaa5, 0xe8aaa8, + /* a4 */ 0xe8aa98, 0xe8aa91, 0xe8aa9a, 0xe8aaa7, + /* a8 */ 0xe8b1aa, 0xe8b28d, 0xe8b28c, 0xe8b393, + /* ac */ 0xe8b391, 0xe8b392, 0xe8b5ab, 0xe8b699, + /* b0 */ 0xe8b695, 0xe8b7bc, 0xe8bc94, 0xe8bc92, + /* b4 */ 0xe8bc95, 0xe8bc93, 0xe8bea3, 0xe981a0, + /* b8 */ 0xe98198, 0xe9819c, 0xe981a3, 0xe98199, + /* bc */ 0xe9819e, 0xe981a2, 0xe9819d, 0xe9819b, + /* c0 */ 0xe98499, 0xe98498, 0xe9849e, 0xe985b5, + /* c4 */ 0xe985b8, 0xe985b7, 0xe985b4, 0xe989b8, + /* c8 */ 0xe98a80, 0xe98a85, 0xe98a98, 0xe98a96, + /* cc */ 0xe989bb, 0xe98a93, 0xe98a9c, 0xe98aa8, + /* d0 */ 0xe989bc, 0xe98a91, 0xe996a1, 0xe996a8, + /* d4 */ 0xe996a9, 0xe996a3, 0xe996a5, 0xe996a4, + /* d8 */ 0xe99a99, 0xe99a9c, 0xe99a9b, 0xe99b8c, + /* dc */ 0xe99b92, 0xe99c80, 0xe99dbc, 0xe99e85, + /* e0 */ 0xe99fb6, 0xe9a097, 0xe9a098, 0xe9a2af, + /* e4 */ 0xe9a2b1, 0xe9a483, 0xe9a485, 0xe9a48c, + /* e8 */ 0xe9a489, 0xe9a781, 0xe9aaaf, 0xe9aab0, + /* ec */ 0xe9aba6, 0xe9ad81, 0xe9ad82, 0xe9b3b4, + /* f0 */ 0xe9b3b6, 0xe9b3b3, 0xe9babc, 0xe9bcbb, + /* f4 */ 0xe9bd8a, 0xe58484, 0xe58480, 0xe583bb, + /* f8 */ 0xe583b5, 0xe583b9, 0xe58482, 0xe58488, + /* fc */ 0xe58489, 0xe58485, 0xe5879c, + + /*** Two byte table, leaf: bcxx - offset 0x0153d ***/ + + /* 40 */ 0xe58a87, 0xe58a88, 0xe58a89, 0xe58a8d, + /* 44 */ 0xe58a8a, 0xe58bb0, 0xe58eb2, 0xe598ae, + /* 48 */ 0xe598bb, 0xe598b9, 0xe598b2, 0xe598bf, + /* 4c */ 0xe598b4, 0xe598a9, 0xe59993, 0xe5998e, + /* 50 */ 0xe59997, 0xe599b4, 0xe598b6, 0xe598af, + /* 54 */ 0xe598b0, 0xe5a280, 0xe5a29f, 0xe5a29e, + /* 58 */ 0xe5a2b3, 0xe5a29c, 0xe5a2ae, 0xe5a2a9, + /* 5c */ 0xe5a2a6, 0xe5a5ad, 0xe5ac89, 0xe5abbb, + /* 60 */ 0xe5ac8b, 0xe5abb5, 0xe5ac8c, 0xe5ac88, + /* 64 */ 0xe5afae, 0xe5afac, 0xe5afa9, 0xe5afab, + /* 68 */ 0xe5b1a4, 0xe5b1a5, 0xe5b69d, 0xe5b694, + /* 6c */ 0xe5b9a2, 0xe5b99f, 0xe5b9a1, 0xe5bba2, + /* 70 */ 0xe5bb9a, 0xe5bb9f, 0xe5bb9d, 0xe5bba3, + /* 74 */ 0xe5bba0, 0xe5bd88, 0xe5bdb1, 0xe5beb7, + /* 78 */ 0xe5beb5, 0xe685b6, 0xe685a7, 0xe685ae, + /* 7c */ 0xe6859d, 0xe68595, 0xe68682, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe685bc, 0xe685b0, 0xe685ab, + /* a4 */ 0xe685be, 0xe686a7, 0xe68690, 0xe686ab, + /* a8 */ 0xe6868e, 0xe686ac, 0xe6869a, 0xe686a4, + /* ac */ 0xe68694, 0xe686ae, 0xe688ae, 0xe691a9, + /* b0 */ 0xe691af, 0xe691b9, 0xe6929e, 0xe692b2, + /* b4 */ 0xe69288, 0xe69290, 0xe692b0, 0xe692a5, + /* b8 */ 0xe69293, 0xe69295, 0xe692a9, 0xe69292, + /* bc */ 0xe692ae, 0xe692ad, 0xe692ab, 0xe6929a, + /* c0 */ 0xe692ac, 0xe69299, 0xe692a2, 0xe692b3, + /* c4 */ 0xe695b5, 0xe695b7, 0xe695b8, 0xe69aae, + /* c8 */ 0xe69aab, 0xe69ab4, 0xe69ab1, 0xe6a8a3, + /* cc */ 0xe6a89f, 0xe6a7a8, 0xe6a881, 0xe6a89e, + /* d0 */ 0xe6a899, 0xe6a7bd, 0xe6a8a1, 0xe6a893, + /* d4 */ 0xe6a88a, 0xe6a7b3, 0xe6a882, 0xe6a885, + /* d8 */ 0xe6a7ad, 0xe6a891, 0xe6ad90, 0xe6ad8e, + /* dc */ 0xe6aea4, 0xe6af85, 0xe6af86, 0xe6bcbf, + /* e0 */ 0xe6bdbc, 0xe6be84, 0xe6bd91, 0xe6bda6, + /* e4 */ 0xe6bd94, 0xe6be86, 0xe6bdad, 0xe6bd9b, + /* e8 */ 0xe6bdb8, 0xe6bdae, 0xe6be8e, 0xe6bdba, + /* ec */ 0xe6bdb0, 0xe6bda4, 0xe6be97, 0xe6bd98, + /* f0 */ 0xe6bb95, 0xe6bdaf, 0xe6bda0, 0xe6bd9f, + /* f4 */ 0xe7869f, 0xe786ac, 0xe786b1, 0xe786a8, + /* f8 */ 0xe78996, 0xe78a9b, 0xe78d8e, 0xe78d97, + /* fc */ 0xe791a9, 0xe7928b, 0xe79283, + + /*** Two byte table, leaf: bdxx - offset 0x015fc ***/ + + /* 40 */ 0xe791be, 0xe79280, 0xe795bf, 0xe798a0, + /* 44 */ 0xe798a9, 0xe7989f, 0xe798a4, 0xe798a6, + /* 48 */ 0xe798a1, 0xe798a2, 0xe79a9a, 0xe79aba, + /* 4c */ 0xe79ba4, 0xe79e8e, 0xe79e87, 0xe79e8c, + /* 50 */ 0xe79e91, 0xe79e8b, 0xe7a38b, 0xe7a385, + /* 54 */ 0xe7a2ba, 0xe7a38a, 0xe7a2be, 0xe7a395, + /* 58 */ 0xe7a2bc, 0xe7a390, 0xe7a8bf, 0xe7a8bc, + /* 5c */ 0xe7a980, 0xe7a8bd, 0xe7a8b7, 0xe7a8bb, + /* 60 */ 0xe7aaaf, 0xe7aaae, 0xe7aead, 0xe7aeb1, + /* 64 */ 0xe7af84, 0xe7aeb4, 0xe7af86, 0xe7af87, + /* 68 */ 0xe7af81, 0xe7aea0, 0xe7af8c, 0xe7b38a, + /* 6c */ 0xe7b7a0, 0xe7b7b4, 0xe7b7af, 0xe7b7bb, + /* 70 */ 0xe7b798, 0xe7b7ac, 0xe7b79d, 0xe7b7a8, + /* 74 */ 0xe7b7a3, 0xe7b79a, 0xe7b79e, 0xe7b7a9, + /* 78 */ 0xe7b69e, 0xe7b799, 0xe7b7b2, 0xe7b7b9, + /* 7c */ 0xe7bdb5, 0xe7bdb7, 0xe7beaf, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7bfa9, 0xe880a6, 0xe8869b, + /* a4 */ 0xe8869c, 0xe8869d, 0xe886a0, 0xe8869a, + /* a8 */ 0xe88698, 0xe89497, 0xe894bd, 0xe8949a, + /* ac */ 0xe893ae, 0xe894ac, 0xe894ad, 0xe89493, + /* b0 */ 0xe89491, 0xe894a3, 0xe894a1, 0xe89494, + /* b4 */ 0xe893ac, 0xe894a5, 0xe893bf, 0xe89486, + /* b8 */ 0xe89e82, 0xe89db4, 0xe89db6, 0xe89da0, + /* bc */ 0xe89da6, 0xe89db8, 0xe89da8, 0xe89d99, + /* c0 */ 0xe89d97, 0xe89d8c, 0xe89d93, 0xe8a19b, + /* c4 */ 0xe8a19d, 0xe8a490, 0xe8a487, 0xe8a492, + /* c8 */ 0xe8a493, 0xe8a495, 0xe8a48a, 0xe8aabc, + /* cc */ 0xe8ab92, 0xe8ab87, 0xe8ab84, 0xe8aa95, + /* d0 */ 0xe8ab8b, 0xe8abb8, 0xe8aab2, 0xe8ab89, + /* d4 */ 0xe8ab82, 0xe8aabf, 0xe8aab0, 0xe8ab96, + /* d8 */ 0xe8ab8d, 0xe8aab6, 0xe8aab9, 0xe8ab9b, + /* dc */ 0xe8b18c, 0xe8b18e, 0xe8b1ac, 0xe8b3a0, + /* e0 */ 0xe8b39e, 0xe8b3a6, 0xe8b3a4, 0xe8b3ac, + /* e4 */ 0xe8b3ad, 0xe8b3a2, 0xe8b3a3, 0xe8b39c, + /* e8 */ 0xe8b3aa, 0xe8b3a1, 0xe8b5ad, 0xe8b69f, + /* ec */ 0xe8b6a3, 0xe8b8ab, 0xe8b890, 0xe8b89d, + /* f0 */ 0xe8b8a2, 0xe8b88f, 0xe8b8a9, 0xe8b89f, + /* f4 */ 0xe8b8a1, 0xe8b89e, 0xe8baba, 0xe8bc9d, + /* f8 */ 0xe8bc9b, 0xe8bc9f, 0xe8bca9, 0xe8bca6, + /* fc */ 0xe8bcaa, 0xe8bc9c, 0xe8bc9e, + + /*** Two byte table, leaf: bexx - offset 0x016bb ***/ + + /* 40 */ 0xe8bca5, 0xe981a9, 0xe981ae, 0xe981a8, + /* 44 */ 0xe981ad, 0xe981b7, 0xe984b0, 0xe984ad, + /* 48 */ 0xe984a7, 0xe984b1, 0xe98687, 0xe98689, + /* 4c */ 0xe9868b, 0xe98683, 0xe98b85, 0xe98abb, + /* 50 */ 0xe98ab7, 0xe98baa, 0xe98aac, 0xe98ba4, + /* 54 */ 0xe98b81, 0xe98ab3, 0xe98abc, 0xe98b92, + /* 58 */ 0xe98b87, 0xe98bb0, 0xe98ab2, 0xe996ad, + /* 5c */ 0xe996b1, 0xe99c84, 0xe99c86, 0xe99c87, + /* 60 */ 0xe99c89, 0xe99da0, 0xe99e8d, 0xe99e8b, + /* 64 */ 0xe99e8f, 0xe9a0a1, 0xe9a0ab, 0xe9a09c, + /* 68 */ 0xe9a2b3, 0xe9a48a, 0xe9a493, 0xe9a492, + /* 6c */ 0xe9a498, 0xe9a79d, 0xe9a790, 0xe9a79f, + /* 70 */ 0xe9a79b, 0xe9a791, 0xe9a795, 0xe9a792, + /* 74 */ 0xe9a799, 0xe9aab7, 0xe9abae, 0xe9abaf, + /* 78 */ 0xe9aca7, 0xe9ad85, 0xe9ad84, 0xe9adb7, + /* 7c */ 0xe9adaf, 0xe9b486, 0xe9b489, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9b483, 0xe9baa9, 0xe9babe, + /* a4 */ 0xe9bb8e, 0xe5a2a8, 0xe9bd92, 0xe58492, + /* a8 */ 0xe58498, 0xe58494, 0xe58490, 0xe58495, + /* ac */ 0xe58680, 0xe586aa, 0xe5879d, 0xe58a91, + /* b0 */ 0xe58a93, 0xe58bb3, 0xe59999, 0xe599ab, + /* b4 */ 0xe599b9, 0xe599a9, 0xe599a4, 0xe599b8, + /* b8 */ 0xe599aa, 0xe599a8, 0xe599a5, 0xe599b1, + /* bc */ 0xe599af, 0xe599ac, 0xe599a2, 0xe599b6, + /* c0 */ 0xe5a381, 0xe5a2be, 0xe5a387, 0xe5a385, + /* c4 */ 0xe5a5ae, 0xe5ac9d, 0xe5acb4, 0xe5adb8, + /* c8 */ 0xe5afb0, 0xe5b08e, 0xe5bd8a, 0xe686b2, + /* cc */ 0xe68691, 0xe686a9, 0xe6868a, 0xe6878d, + /* d0 */ 0xe686b6, 0xe686be, 0xe6878a, 0xe68788, + /* d4 */ 0xe688b0, 0xe69385, 0xe69381, 0xe6938b, + /* d8 */ 0xe692bb, 0xe692bc, 0xe6939a, 0xe69384, + /* dc */ 0xe69387, 0xe69382, 0xe6938d, 0xe692bf, + /* e0 */ 0xe69392, 0xe69394, 0xe692be, 0xe695b4, + /* e4 */ 0xe69b86, 0xe69b89, 0xe69ab9, 0xe69b84, + /* e8 */ 0xe69b87, 0xe69ab8, 0xe6a8bd, 0xe6a8b8, + /* ec */ 0xe6a8ba, 0xe6a999, 0xe6a9ab, 0xe6a998, + /* f0 */ 0xe6a8b9, 0xe6a984, 0xe6a9a2, 0xe6a9a1, + /* f4 */ 0xe6a98b, 0xe6a987, 0xe6a8b5, 0xe6a99f, + /* f8 */ 0xe6a988, 0xe6ad99, 0xe6adb7, 0xe6b085, + /* fc */ 0xe6bf82, 0xe6beb1, 0xe6bea1, + + /*** Two byte table, leaf: bfxx - offset 0x0177a ***/ + + /* 40 */ 0xe6bf83, 0xe6bea4, 0xe6bf81, 0xe6bea7, + /* 44 */ 0xe6beb3, 0xe6bf80, 0xe6beb9, 0xe6beb6, + /* 48 */ 0xe6bea6, 0xe6bea0, 0xe6beb4, 0xe786be, + /* 4c */ 0xe78789, 0xe78790, 0xe78792, 0xe78788, + /* 50 */ 0xe78795, 0xe786b9, 0xe7878e, 0xe78799, + /* 54 */ 0xe7879c, 0xe78783, 0xe78784, 0xe78da8, + /* 58 */ 0xe7929c, 0xe792a3, 0xe79298, 0xe7929f, + /* 5c */ 0xe7929e, 0xe793a2, 0xe7948c, 0xe7948d, + /* 60 */ 0xe798b4, 0xe798b8, 0xe798ba, 0xe79ba7, + /* 64 */ 0xe79ba5, 0xe79ea0, 0xe79e9e, 0xe79e9f, + /* 68 */ 0xe79ea5, 0xe7a3a8, 0xe7a39a, 0xe7a3ac, + /* 6c */ 0xe7a3a7, 0xe7a6a6, 0xe7a98d, 0xe7a98e, + /* 70 */ 0xe7a986, 0xe7a98c, 0xe7a98b, 0xe7aaba, + /* 74 */ 0xe7af99, 0xe7b091, 0xe7af89, 0xe7afa4, + /* 78 */ 0xe7af9b, 0xe7afa1, 0xe7afa9, 0xe7afa6, + /* 7c */ 0xe7b395, 0xe7b396, 0xe7b88a, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7b891, 0xe7b888, 0xe7b89b, + /* a4 */ 0xe7b8a3, 0xe7b89e, 0xe7b89d, 0xe7b889, + /* a8 */ 0xe7b890, 0xe7bdb9, 0xe7beb2, 0xe7bfb0, + /* ac */ 0xe7bfb1, 0xe7bfae, 0xe880a8, 0xe886b3, + /* b0 */ 0xe886a9, 0xe886a8, 0xe887bb, 0xe88888, + /* b4 */ 0xe88998, 0xe88999, 0xe8958a, 0xe89599, + /* b8 */ 0xe89588, 0xe895a8, 0xe895a9, 0xe89583, + /* bc */ 0xe89589, 0xe895ad, 0xe895aa, 0xe8959e, + /* c0 */ 0xe89e83, 0xe89e9f, 0xe89e9e, 0xe89ea2, + /* c4 */ 0xe89e8d, 0xe8a1a1, 0xe8a4aa, 0xe8a4b2, + /* c8 */ 0xe8a4a5, 0xe8a4ab, 0xe8a4a1, 0xe8a6aa, + /* cc */ 0xe8a6a6, 0xe8aba6, 0xe8abba, 0xe8abab, + /* d0 */ 0xe8abb1, 0xe8ac80, 0xe8ab9c, 0xe8aba7, + /* d4 */ 0xe8abae, 0xe8abbe, 0xe8ac81, 0xe8ac82, + /* d8 */ 0xe8abb7, 0xe8abad, 0xe8abb3, 0xe8abb6, + /* dc */ 0xe8abbc, 0xe8b1ab, 0xe8b1ad, 0xe8b293, + /* e0 */ 0xe8b3b4, 0xe8b984, 0xe8b8b1, 0xe8b8b4, + /* e4 */ 0xe8b982, 0xe8b8b9, 0xe8b8b5, 0xe8bcbb, + /* e8 */ 0xe8bcaf, 0xe8bcb8, 0xe8bcb3, 0xe8bea8, + /* ec */ 0xe8bea6, 0xe981b5, 0xe981b4, 0xe981b8, + /* f0 */ 0xe981b2, 0xe981bc, 0xe981ba, 0xe984b4, + /* f4 */ 0xe98692, 0xe98ca0, 0xe98cb6, 0xe98bb8, + /* f8 */ 0xe98cb3, 0xe98caf, 0xe98ca2, 0xe98bbc, + /* fc */ 0xe98cab, 0xe98c84, 0xe98c9a, + + /*** Two byte table, leaf: c0xx - offset 0x01839 ***/ + + /* 40 */ 0xe98c90, 0xe98ca6, 0xe98ca1, 0xe98c95, + /* 44 */ 0xe98cae, 0xe98c99, 0xe996bb, 0xe99aa7, + /* 48 */ 0xe99aa8, 0xe99aaa, 0xe99b95, 0xe99c8e, + /* 4c */ 0xe99c91, 0xe99c96, 0xe99c8d, 0xe99c93, + /* 50 */ 0xe99c8f, 0xe99d9b, 0xe99d9c, 0xe99da6, + /* 54 */ 0xe99e98, 0xe9a0b0, 0xe9a0b8, 0xe9a0bb, + /* 58 */ 0xe9a0b7, 0xe9a0ad, 0xe9a0b9, 0xe9a0a4, + /* 5c */ 0xe9a490, 0xe9a4a8, 0xe9a49e, 0xe9a49b, + /* 60 */ 0xe9a4a1, 0xe9a49a, 0xe9a7ad, 0xe9a7a2, + /* 64 */ 0xe9a7b1, 0xe9aab8, 0xe9aabc, 0xe9abbb, + /* 68 */ 0xe9abad, 0xe9aca8, 0xe9ae91, 0xe9b495, + /* 6c */ 0xe9b4a3, 0xe9b4a6, 0xe9b4a8, 0xe9b492, + /* 70 */ 0xe9b49b, 0xe9bb98, 0xe9bb94, 0xe9be8d, + /* 74 */ 0xe9be9c, 0xe584aa, 0xe5849f, 0xe584a1, + /* 78 */ 0xe584b2, 0xe58bb5, 0xe59a8e, 0xe59a80, + /* 7c */ 0xe59a90, 0xe59a85, 0xe59a87, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe59a8f, 0xe5a395, 0xe5a393, + /* a4 */ 0xe5a391, 0xe5a38e, 0xe5acb0, 0xe5acaa, + /* a8 */ 0xe5aca4, 0xe5adba, 0xe5b0b7, 0xe5b1a8, + /* ac */ 0xe5b6bc, 0xe5b6ba, 0xe5b6bd, 0xe5b6b8, + /* b0 */ 0xe5b9ab, 0xe5bd8c, 0xe5bebd, 0xe68789, + /* b4 */ 0xe68782, 0xe68787, 0xe687a6, 0xe6878b, + /* b8 */ 0xe688b2, 0xe688b4, 0xe6938e, 0xe6938a, + /* bc */ 0xe69398, 0xe693a0, 0xe693b0, 0xe693a6, + /* c0 */ 0xe693ac, 0xe693b1, 0xe693a2, 0xe693ad, + /* c4 */ 0xe69682, 0xe69683, 0xe69b99, 0xe69b96, + /* c8 */ 0xe6aa80, 0xe6aa94, 0xe6aa84, 0xe6aaa2, + /* cc */ 0xe6aa9c, 0xe6ab9b, 0xe6aaa3, 0xe6a9be, + /* d0 */ 0xe6aa97, 0xe6aa90, 0xe6aaa0, 0xe6ad9c, + /* d4 */ 0xe6aeae, 0xe6af9a, 0xe6b088, 0xe6bf98, + /* d8 */ 0xe6bfb1, 0xe6bf9f, 0xe6bfa0, 0xe6bf9b, + /* dc */ 0xe6bfa4, 0xe6bfab, 0xe6bfaf, 0xe6be80, + /* e0 */ 0xe6bfac, 0xe6bfa1, 0xe6bfa9, 0xe6bf95, + /* e4 */ 0xe6bfae, 0xe6bfb0, 0xe787a7, 0xe7879f, + /* e8 */ 0xe787ae, 0xe787a6, 0xe787a5, 0xe787ad, + /* ec */ 0xe787ac, 0xe787b4, 0xe787a0, 0xe788b5, + /* f0 */ 0xe78986, 0xe78db0, 0xe78db2, 0xe792a9, + /* f4 */ 0xe792b0, 0xe792a6, 0xe792a8, 0xe79986, + /* f8 */ 0xe79982, 0xe7998c, 0xe79baa, 0xe79eb3, + /* fc */ 0xe79eaa, 0xe79eb0, 0xe79eac, + + /*** Two byte table, leaf: c1xx - offset 0x018f8 ***/ + + /* 40 */ 0xe79ea7, 0xe79ead, 0xe79faf, 0xe7a3b7, + /* 44 */ 0xe7a3ba, 0xe7a3b4, 0xe7a3af, 0xe7a481, + /* 48 */ 0xe7a6a7, 0xe7a6aa, 0xe7a997, 0xe7aabf, + /* 4c */ 0xe7b087, 0xe7b08d, 0xe7afbe, 0xe7afb7, + /* 50 */ 0xe7b08c, 0xe7afa0, 0xe7b3a0, 0xe7b39c, + /* 54 */ 0xe7b39e, 0xe7b3a2, 0xe7b39f, 0xe7b399, + /* 58 */ 0xe7b39d, 0xe7b8ae, 0xe7b8be, 0xe7b986, + /* 5c */ 0xe7b8b7, 0xe7b8b2, 0xe7b983, 0xe7b8ab, + /* 60 */ 0xe7b8bd, 0xe7b8b1, 0xe7b985, 0xe7b981, + /* 64 */ 0xe7b8b4, 0xe7b8b9, 0xe7b988, 0xe7b8b5, + /* 68 */ 0xe7b8bf, 0xe7b8af, 0xe7bd84, 0xe7bfb3, + /* 6c */ 0xe7bfbc, 0xe881b1, 0xe881b2, 0xe881b0, + /* 70 */ 0xe881af, 0xe881b3, 0xe88786, 0xe88783, + /* 74 */ 0xe886ba, 0xe88782, 0xe88780, 0xe886bf, + /* 78 */ 0xe886bd, 0xe88789, 0xe886be, 0xe887a8, + /* 7c */ 0xe88889, 0xe889b1, 0xe896aa, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe89684, 0xe895be, 0xe8969c, + /* a4 */ 0xe89691, 0xe89694, 0xe896af, 0xe8969b, + /* a8 */ 0xe89687, 0xe896a8, 0xe8968a, 0xe899a7, + /* ac */ 0xe89f80, 0xe89f91, 0xe89eb3, 0xe89f92, + /* b0 */ 0xe89f86, 0xe89eab, 0xe89ebb, 0xe89eba, + /* b4 */ 0xe89f88, 0xe89f8b, 0xe8a4bb, 0xe8a4b6, + /* b8 */ 0xe8a584, 0xe8a4b8, 0xe8a4bd, 0xe8a6ac, + /* bc */ 0xe8ac8e, 0xe8ac97, 0xe8ac99, 0xe8ac9b, + /* c0 */ 0xe8ac8a, 0xe8aca0, 0xe8ac9d, 0xe8ac84, + /* c4 */ 0xe8ac90, 0xe8b181, 0xe8b0bf, 0xe8b1b3, + /* c8 */ 0xe8b3ba, 0xe8b3bd, 0xe8b3bc, 0xe8b3b8, + /* cc */ 0xe8b3bb, 0xe8b6a8, 0xe8b989, 0xe8b98b, + /* d0 */ 0xe8b988, 0xe8b98a, 0xe8bd84, 0xe8bcbe, + /* d4 */ 0xe8bd82, 0xe8bd85, 0xe8bcbf, 0xe981bf, + /* d8 */ 0xe981bd, 0xe98284, 0xe98281, 0xe98282, + /* dc */ 0xe98280, 0xe984b9, 0xe986a3, 0xe9869e, + /* e0 */ 0xe9869c, 0xe98d8d, 0xe98e82, 0xe98ca8, + /* e4 */ 0xe98db5, 0xe98d8a, 0xe98da5, 0xe98d8b, + /* e8 */ 0xe98c98, 0xe98dbe, 0xe98dac, 0xe98d9b, + /* ec */ 0xe98db0, 0xe98d9a, 0xe98d94, 0xe9978a, + /* f0 */ 0xe9978b, 0xe9978c, 0xe99788, 0xe99786, + /* f4 */ 0xe99ab1, 0xe99ab8, 0xe99b96, 0xe99c9c, + /* f8 */ 0xe99c9e, 0xe99ea0, 0xe99f93, 0xe9a186, + /* fc */ 0xe9a2b6, 0xe9a4b5, 0xe9a881, + + /*** Two byte table, leaf: c2xx - offset 0x019b7 ***/ + + /* 40 */ 0xe9a7bf, 0xe9aeae, 0xe9aeab, 0xe9aeaa, + /* 44 */ 0xe9aead, 0xe9b4bb, 0xe9b4bf, 0xe9ba8b, + /* 48 */ 0xe9bb8f, 0xe9bb9e, 0xe9bb9c, 0xe9bb9d, + /* 4c */ 0xe9bb9b, 0xe9bcbe, 0xe9bd8b, 0xe58fa2, + /* 50 */ 0xe59a95, 0xe59aae, 0xe5a399, 0xe5a398, + /* 54 */ 0xe5acb8, 0xe5bd9d, 0xe687a3, 0xe688b3, + /* 58 */ 0xe693b4, 0xe693b2, 0xe693be, 0xe69486, + /* 5c */ 0xe693ba, 0xe693bb, 0xe693b7, 0xe696b7, + /* 60 */ 0xe69b9c, 0xe69ca6, 0xe6aab3, 0xe6aaac, + /* 64 */ 0xe6ab83, 0xe6aabb, 0xe6aab8, 0xe6ab82, + /* 68 */ 0xe6aaae, 0xe6aaaf, 0xe6ad9f, 0xe6adb8, + /* 6c */ 0xe6aeaf, 0xe78089, 0xe7808b, 0xe6bfbe, + /* 70 */ 0xe78086, 0xe6bfba, 0xe78091, 0xe7808f, + /* 74 */ 0xe787bb, 0xe787bc, 0xe787be, 0xe787b8, + /* 78 */ 0xe78db7, 0xe78db5, 0xe792a7, 0xe792bf, + /* 7c */ 0xe79495, 0xe79996, 0xe79998, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe79992, 0xe79ebd, 0xe79ebf, + /* a4 */ 0xe79ebb, 0xe79ebc, 0xe7a48e, 0xe7a6ae, + /* a8 */ 0xe7a9a1, 0xe7a9a2, 0xe7a9a0, 0xe7ab84, + /* ac */ 0xe7ab85, 0xe7b0ab, 0xe7b0a7, 0xe7b0aa, + /* b0 */ 0xe7b09e, 0xe7b0a3, 0xe7b0a1, 0xe7b3a7, + /* b4 */ 0xe7b994, 0xe7b995, 0xe7b99e, 0xe7b99a, + /* b8 */ 0xe7b9a1, 0xe7b992, 0xe7b999, 0xe7bd88, + /* bc */ 0xe7bfb9, 0xe7bfbb, 0xe881b7, 0xe881b6, + /* c0 */ 0xe8878d, 0xe8878f, 0xe8888a, 0xe8978f, + /* c4 */ 0xe896a9, 0xe8978d, 0xe89790, 0xe89789, + /* c8 */ 0xe896b0, 0xe896ba, 0xe896b9, 0xe896a6, + /* cc */ 0xe89faf, 0xe89fac, 0xe89fb2, 0xe89fa0, + /* d0 */ 0xe8a686, 0xe8a6b2, 0xe8a7b4, 0xe8aca8, + /* d4 */ 0xe8acb9, 0xe8acac, 0xe8acab, 0xe8b190, + /* d8 */ 0xe8b485, 0xe8b999, 0xe8b9a3, 0xe8b9a6, + /* dc */ 0xe8b9a4, 0xe8b99f, 0xe8b995, 0xe8bb80, + /* e0 */ 0xe8bd89, 0xe8bd8d, 0xe98287, 0xe98283, + /* e4 */ 0xe98288, 0xe986ab, 0xe986ac, 0xe98790, + /* e8 */ 0xe98e94, 0xe98e8a, 0xe98e96, 0xe98ea2, + /* ec */ 0xe98eb3, 0xe98eae, 0xe98eac, 0xe98eb0, + /* f0 */ 0xe98e98, 0xe98e9a, 0xe98e97, 0xe99794, + /* f4 */ 0xe99796, 0xe99790, 0xe99795, 0xe99ba2, + /* f8 */ 0xe99b9c, 0xe99b99, 0xe99b9b, 0xe99b9e, + /* fc */ 0xe99ca4, 0xe99ea3, 0xe99ea6, + + /*** Two byte table, leaf: c3xx - offset 0x01a76 ***/ + + /* 40 */ 0xe99ead, 0xe99fb9, 0xe9a18d, 0xe9a18f, + /* 44 */ 0xe9a18c, 0xe9a18e, 0xe9a193, 0xe9a2ba, + /* 48 */ 0xe9a4be, 0xe9a4bf, 0xe9a4bd, 0xe9a4ae, + /* 4c */ 0xe9a6a5, 0xe9a88e, 0xe9ab81, 0xe9ac83, + /* 50 */ 0xe9ac86, 0xe9ad8f, 0xe9ad8e, 0xe9ad8d, + /* 54 */ 0xe9af8a, 0xe9af89, 0xe9afbd, 0xe9af88, + /* 58 */ 0xe9af80, 0xe9b591, 0xe9b59d, 0xe9b5a0, + /* 5c */ 0xe9bba0, 0xe9bc95, 0xe9bcac, 0xe584b3, + /* 60 */ 0xe59aa5, 0xe5a39e, 0xe5a39f, 0xe5a3a2, + /* 64 */ 0xe5afb5, 0xe9be90, 0xe5bbac, 0xe687b2, + /* 68 */ 0xe687b7, 0xe687b6, 0xe687b5, 0xe69480, + /* 6c */ 0xe6948f, 0xe69ba0, 0xe69b9d, 0xe6aba5, + /* 70 */ 0xe6ab9d, 0xe6ab9a, 0xe6ab93, 0xe7809b, + /* 74 */ 0xe7809f, 0xe780a8, 0xe7809a, 0xe7809d, + /* 78 */ 0xe78095, 0xe78098, 0xe78886, 0xe7888d, + /* 7c */ 0xe78998, 0xe78aa2, 0xe78db8, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe78dba, 0xe792bd, 0xe7938a, + /* a4 */ 0xe793a3, 0xe79687, 0xe79686, 0xe7999f, + /* a8 */ 0xe799a1, 0xe79f87, 0xe7a499, 0xe7a6b1, + /* ac */ 0xe7a9ab, 0xe7a9a9, 0xe7b0be, 0xe7b0bf, + /* b0 */ 0xe7b0b8, 0xe7b0bd, 0xe7b0b7, 0xe7b180, + /* b4 */ 0xe7b9ab, 0xe7b9ad, 0xe7b9b9, 0xe7b9a9, + /* b8 */ 0xe7b9aa, 0xe7be85, 0xe7b9b3, 0xe7beb6, + /* bc */ 0xe7beb9, 0xe7beb8, 0xe88798, 0xe897a9, + /* c0 */ 0xe8979d, 0xe897aa, 0xe89795, 0xe897a4, + /* c4 */ 0xe897a5, 0xe897b7, 0xe89fbb, 0xe8a085, + /* c8 */ 0xe8a08d, 0xe89fb9, 0xe89fbe, 0xe8a5a0, + /* cc */ 0xe8a59f, 0xe8a596, 0xe8a59e, 0xe8ad81, + /* d0 */ 0xe8ad9c, 0xe8ad98, 0xe8ad89, 0xe8ad9a, + /* d4 */ 0xe8ad8e, 0xe8ad8f, 0xe8ad86, 0xe8ad99, + /* d8 */ 0xe8b488, 0xe8b48a, 0xe8b9bc, 0xe8b9b2, + /* dc */ 0xe8ba87, 0xe8b9b6, 0xe8b9ac, 0xe8b9ba, + /* e0 */ 0xe8b9b4, 0xe8bd94, 0xe8bd8e, 0xe8bead, + /* e4 */ 0xe9828a, 0xe9828b, 0xe986b1, 0xe986ae, + /* e8 */ 0xe98fa1, 0xe98f91, 0xe98f9f, 0xe98f83, + /* ec */ 0xe98f88, 0xe98f9c, 0xe98f9d, 0xe98f96, + /* f0 */ 0xe98fa2, 0xe98f8d, 0xe98f98, 0xe98fa4, + /* f4 */ 0xe98f97, 0xe98fa8, 0xe9979c, 0xe99ab4, + /* f8 */ 0xe99ba3, 0xe99caa, 0xe99ca7, 0xe99da1, + /* fc */ 0xe99f9c, 0xe99fbb, 0xe9a19e, + + /*** Two byte table, leaf: c4xx - offset 0x01b35 ***/ + + /* 40 */ 0xe9a198, 0xe9a19b, 0xe9a2bc, 0xe9a585, + /* 44 */ 0xe9a589, 0xe9a896, 0xe9a899, 0xe9ac8d, + /* 48 */ 0xe9afa8, 0xe9afa7, 0xe9af96, 0xe9af9b, + /* 4c */ 0xe9b689, 0xe9b5a1, 0xe9b5b2, 0xe9b5aa, + /* 50 */ 0xe9b5ac, 0xe9ba92, 0xe9ba97, 0xe9ba93, + /* 54 */ 0xe9bab4, 0xe58bb8, 0xe59aa8, 0xe59ab7, + /* 58 */ 0xe59ab6, 0xe59ab4, 0xe59abc, 0xe5a3a4, + /* 5c */ 0xe5ad80, 0xe5ad83, 0xe5adbd, 0xe5afb6, + /* 60 */ 0xe5b789, 0xe687b8, 0xe687ba, 0xe69498, + /* 64 */ 0xe69494, 0xe69499, 0xe69ba6, 0xe69ca7, + /* 68 */ 0xe6abac, 0xe780be, 0xe780b0, 0xe780b2, + /* 6c */ 0xe78890, 0xe78dbb, 0xe7938f, 0xe799a2, + /* 70 */ 0xe799a5, 0xe7a4a6, 0xe7a4aa, 0xe7a4ac, + /* 74 */ 0xe7a4ab, 0xe7ab87, 0xe7abb6, 0xe7b18c, + /* 78 */ 0xe7b183, 0xe7b18d, 0xe7b3af, 0xe7b3b0, + /* 7c */ 0xe8beae, 0xe7b9bd, 0xe7b9bc, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7ba82, 0xe7bd8c, 0xe88080, + /* a4 */ 0xe8879a, 0xe889a6, 0xe897bb, 0xe897b9, + /* a8 */ 0xe89891, 0xe897ba, 0xe89886, 0xe8988b, + /* ac */ 0xe89887, 0xe8988a, 0xe8a094, 0xe8a095, + /* b0 */ 0xe8a5a4, 0xe8a6ba, 0xe8a7b8, 0xe8adb0, + /* b4 */ 0xe8adac, 0xe8ada6, 0xe8adaf, 0xe8ad9f, + /* b8 */ 0xe8adab, 0xe8b48f, 0xe8b48d, 0xe8ba89, + /* bc */ 0xe8ba81, 0xe8ba85, 0xe8ba82, 0xe986b4, + /* c0 */ 0xe9878b, 0xe99098, 0xe99083, 0xe98fbd, + /* c4 */ 0xe997a1, 0xe99cb0, 0xe9a384, 0xe9a592, + /* c8 */ 0xe9a591, 0xe9a6a8, 0xe9a8ab, 0xe9a8b0, + /* cc */ 0xe9a8b7, 0xe9a8b5, 0xe9b093, 0xe9b08d, + /* d0 */ 0xe9b9b9, 0xe9bab5, 0xe9bba8, 0xe9bcaf, + /* d4 */ 0xe9bd9f, 0xe9bda3, 0xe9bda1, 0xe584b7, + /* d8 */ 0xe584b8, 0xe59b81, 0xe59b80, 0xe59b82, + /* dc */ 0xe5a494, 0xe5b1ac, 0xe5b78d, 0xe687bc, + /* e0 */ 0xe687be, 0xe6949d, 0xe6949c, 0xe69695, + /* e4 */ 0xe69ba9, 0xe6abbb, 0xe6ac84, 0xe6abba, + /* e8 */ 0xe6aeb2, 0xe7818c, 0xe7889b, 0xe78aa7, + /* ec */ 0xe79396, 0xe79394, 0xe799a9, 0xe79f93, + /* f0 */ 0xe7b190, 0xe7ba8f, 0xe7ba8c, 0xe7bebc, + /* f4 */ 0xe89897, 0xe898ad, 0xe8989a, 0xe8a0a3, + /* f8 */ 0xe8a0a2, 0xe8a0a1, 0xe8a09f, 0xe8a5aa, + /* fc */ 0xe8a5ac, 0xe8a6bd, 0xe8adb4, + + /*** Two byte table, leaf: c5xx - offset 0x01bf4 ***/ + + /* 40 */ 0xe8adb7, 0xe8adbd, 0xe8b493, 0xe8ba8a, + /* 44 */ 0xe8ba8d, 0xe8ba8b, 0xe8bd9f, 0xe8beaf, + /* 48 */ 0xe986ba, 0xe990ae, 0xe990b3, 0xe990b5, + /* 4c */ 0xe990ba, 0xe990b8, 0xe990b2, 0xe990ab, + /* 50 */ 0xe997a2, 0xe99cb8, 0xe99cb9, 0xe99cb2, + /* 54 */ 0xe99fbf, 0xe9a1a7, 0xe9a1a5, 0xe9a597, + /* 58 */ 0xe9a985, 0xe9a983, 0xe9a980, 0xe9a8be, + /* 5c */ 0xe9ab8f, 0xe9ad94, 0xe9ad91, 0xe9b0ad, + /* 60 */ 0xe9b0a5, 0xe9b6af, 0xe9b6b4, 0xe9b782, + /* 64 */ 0xe9b6b8, 0xe9ba9d, 0xe9bbaf, 0xe9bc99, + /* 68 */ 0xe9bd9c, 0xe9bda6, 0xe9bda7, 0xe584bc, + /* 6c */ 0xe584bb, 0xe59b88, 0xe59b8a, 0xe59b89, + /* 70 */ 0xe5adbf, 0xe5b794, 0xe5b792, 0xe5bd8e, + /* 74 */ 0xe687bf, 0xe694a4, 0xe6ac8a, 0xe6ada1, + /* 78 */ 0xe78191, 0xe78198, 0xe78e80, 0xe793a4, + /* 7c */ 0xe7968a, 0xe799ae, 0xe799ac, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7a6b3, 0xe7b1a0, 0xe7b19f, + /* a4 */ 0xe881be, 0xe881bd, 0xe8879f, 0xe8a5b2, + /* a8 */ 0xe8a5af, 0xe8a7bc, 0xe8ae80, 0xe8b496, + /* ac */ 0xe8b497, 0xe8ba91, 0xe8ba93, 0xe8bda1, + /* b0 */ 0xe98588, 0xe99184, 0xe99191, 0xe99192, + /* b4 */ 0xe99cbd, 0xe99cbe, 0xe99f83, 0xe99f81, + /* b8 */ 0xe9a1ab, 0xe9a595, 0xe9a995, 0xe9a98d, + /* bc */ 0xe9ab92, 0xe9ac9a, 0xe9b189, 0xe9b0b1, + /* c0 */ 0xe9b0be, 0xe9b0bb, 0xe9b793, 0xe9b797, + /* c4 */ 0xe9bcb4, 0xe9bdac, 0xe9bdaa, 0xe9be94, + /* c8 */ 0xe59b8c, 0xe5b796, 0xe68880, 0xe694a3, + /* cc */ 0xe694ab, 0xe694aa, 0xe69bac, 0xe6ac90, + /* d0 */ 0xe7939a, 0xe7ab8a, 0xe7b1a4, 0xe7b1a3, + /* d4 */ 0xe7b1a5, 0xe7ba93, 0xe7ba96, 0xe7ba94, + /* d8 */ 0xe887a2, 0xe898b8, 0xe898bf, 0xe8a0b1, + /* dc */ 0xe8ae8a, 0xe98290, 0xe9828f, 0xe991a3, + /* e0 */ 0xe991a0, 0xe991a4, 0xe99da8, 0xe9a1af, + /* e4 */ 0xe9a59c, 0xe9a99a, 0xe9a99b, 0xe9a997, + /* e8 */ 0xe9ab93, 0xe9ab94, 0xe9ab91, 0xe9b194, + /* ec */ 0xe9b197, 0xe9b196, 0xe9b7a5, 0xe9ba9f, + /* f0 */ 0xe9bbb4, 0xe59b91, 0xe5a3a9, 0xe694ac, + /* f4 */ 0xe7819e, 0xe799b1, 0xe799b2, 0xe79f97, + /* f8 */ 0xe7bd90, 0xe7be88, 0xe8a0b6, 0xe8a0b9, + /* fc */ 0xe8a1a2, 0xe8ae93, 0xe8ae92, + + /*** Two byte table, leaf: c6xx - offset 0x01cb3 ***/ + + /* 40 */ 0xe8ae96, 0xe889b7, 0xe8b49b, 0xe98780, + /* 44 */ 0xe991aa, 0xe99d82, 0xe99d88, 0xe99d84, + /* 48 */ 0xe99f86, 0xe9a1b0, 0xe9a99f, 0xe9aca2, + /* 4c */ 0xe9ad98, 0xe9b19f, 0xe9b7b9, 0xe9b7ba, + /* 50 */ 0xe9b9bc, 0xe9b9bd, 0xe9bc87, 0xe9bdb7, + /* 54 */ 0xe9bdb2, 0xe5bbb3, 0xe6ac96, 0xe781a3, + /* 58 */ 0xe7b1ac, 0xe7b1ae, 0xe8a0bb, 0xe8a780, + /* 5c */ 0xe8baa1, 0xe98781, 0xe991b2, 0xe991b0, + /* 60 */ 0xe9a1b1, 0xe9a59e, 0xe9ab96, 0xe9aca3, + /* 64 */ 0xe9bb8c, 0xe781a4, 0xe79f9a, 0xe8ae9a, + /* 68 */ 0xe991b7, 0xe99f89, 0xe9a9a2, 0xe9a9a5, + /* 6c */ 0xe7ba9c, 0xe8ae9c, 0xe8baaa, 0xe98785, + /* 70 */ 0xe991bd, 0xe991be, 0xe991bc, 0xe9b1b7, + /* 74 */ 0xe9b1b8, 0xe9bbb7, 0xe8b194, 0xe991bf, + /* 78 */ 0xe9b89a, 0xe788a8, 0xe9a9aa, 0xe9acb1, + /* 7c */ 0xe9b89b, 0xe9b89e, 0xe7b1b2, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe383be, 0xe3829d, 0xe3829e, + /* a4 */ 0xe38085, 0xe38181, 0xe38182, 0xe38183, + /* a8 */ 0xe38184, 0xe38185, 0xe38186, 0xe38187, + /* ac */ 0xe38188, 0xe38189, 0xe3818a, 0xe3818b, + /* b0 */ 0xe3818c, 0xe3818d, 0xe3818e, 0xe3818f, + /* b4 */ 0xe38190, 0xe38191, 0xe38192, 0xe38193, + /* b8 */ 0xe38194, 0xe38195, 0xe38196, 0xe38197, + /* bc */ 0xe38198, 0xe38199, 0xe3819a, 0xe3819b, + /* c0 */ 0xe3819c, 0xe3819d, 0xe3819e, 0xe3819f, + /* c4 */ 0xe381a0, 0xe381a1, 0xe381a2, 0xe381a3, + /* c8 */ 0xe381a4, 0xe381a5, 0xe381a6, 0xe381a7, + /* cc */ 0xe381a8, 0xe381a9, 0xe381aa, 0xe381ab, + /* d0 */ 0xe381ac, 0xe381ad, 0xe381ae, 0xe381af, + /* d4 */ 0xe381b0, 0xe381b1, 0xe381b2, 0xe381b3, + /* d8 */ 0xe381b4, 0xe381b5, 0xe381b6, 0xe381b7, + /* dc */ 0xe381b8, 0xe381b9, 0xe381ba, 0xe381bb, + /* e0 */ 0xe381bc, 0xe381bd, 0xe381be, 0xe381bf, + /* e4 */ 0xe38280, 0xe38281, 0xe38282, 0xe38283, + /* e8 */ 0xe38284, 0xe38285, 0xe38286, 0xe38287, + /* ec */ 0xe38288, 0xe38289, 0xe3828a, 0xe3828b, + /* f0 */ 0xe3828c, 0xe3828d, 0xe3828e, 0xe3828f, + /* f4 */ 0xe38290, 0xe38291, 0xe38292, 0xe38293, + /* f8 */ 0xe382a1, 0xe382a2, 0xe382a3, 0xe382a4, + /* fc */ 0xe382a5, 0xe382a6, 0xe382a7, + + /*** Two byte table, leaf: c7xx - offset 0x01d72 ***/ + + /* 40 */ 0xe382a8, 0xe382a9, 0xe382aa, 0xe382ab, + /* 44 */ 0xe382ac, 0xe382ad, 0xe382ae, 0xe382af, + /* 48 */ 0xe382b0, 0xe382b1, 0xe382b2, 0xe382b3, + /* 4c */ 0xe382b4, 0xe382b5, 0xe382b6, 0xe382b7, + /* 50 */ 0xe382b8, 0xe382b9, 0xe382ba, 0xe382bb, + /* 54 */ 0xe382bc, 0xe382bd, 0xe382be, 0xe382bf, + /* 58 */ 0xe38380, 0xe38381, 0xe38382, 0xe38383, + /* 5c */ 0xe38384, 0xe38385, 0xe38386, 0xe38387, + /* 60 */ 0xe38388, 0xe38389, 0xe3838a, 0xe3838b, + /* 64 */ 0xe3838c, 0xe3838d, 0xe3838e, 0xe3838f, + /* 68 */ 0xe38390, 0xe38391, 0xe38392, 0xe38393, + /* 6c */ 0xe38394, 0xe38395, 0xe38396, 0xe38397, + /* 70 */ 0xe38398, 0xe38399, 0xe3839a, 0xe3839b, + /* 74 */ 0xe3839c, 0xe3839d, 0xe3839e, 0xe3839f, + /* 78 */ 0xe383a0, 0xe383a1, 0xe383a2, 0xe383a3, + /* 7c */ 0xe383a4, 0xe383a5, 0xe383a6, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe383a7, 0xe383a8, 0xe383a9, + /* a4 */ 0xe383aa, 0xe383ab, 0xe383ac, 0xe383ad, + /* a8 */ 0xe383ae, 0xe383af, 0xe383b0, 0xe383b1, + /* ac */ 0xe383b2, 0xe383b3, 0xe383b4, 0xe383b5, + /* b0 */ 0xe383b6, 0x00d094, 0x00d095, 0x00d081, + /* b4 */ 0x00d096, 0x00d097, 0x00d098, 0x00d099, + /* b8 */ 0x00d09a, 0x00d09b, 0x00d09c, 0x00d0a3, + /* bc */ 0x00d0a4, 0x00d0a5, 0x00d0a6, 0x00d0a7, + /* c0 */ 0x00d0a8, 0x00d0a9, 0x00d0aa, 0x00d0ab, + /* c4 */ 0x00d0ac, 0x00d0ad, 0x00d0ae, 0x00d0af, + /* c8 */ 0x00d0b0, 0x00d0b1, 0x00d0b2, 0x00d0b3, + /* cc */ 0x00d0b4, 0x00d0b5, 0x00d191, 0x00d0b6, + /* d0 */ 0x00d0b7, 0x00d0b8, 0x00d0b9, 0x00d0ba, + /* d4 */ 0x00d0bb, 0x00d0bc, 0x00d0bd, 0x00d0be, + /* d8 */ 0x00d0bf, 0x00d180, 0x00d181, 0x00d182, + /* dc */ 0x00d183, 0x00d184, 0x00d185, 0x00d186, + /* e0 */ 0x00d187, 0x00d188, 0x00d189, 0x00d18a, + /* e4 */ 0x00d18b, 0x00d18c, 0x00d18d, 0x00d18e, + /* e8 */ 0x00d18f, 0xe291a0, 0xe291a1, 0xe291a2, + /* ec */ 0xe291a3, 0xe291a4, 0xe291a5, 0xe291a6, + /* f0 */ 0xe291a7, 0xe291a8, 0xe291a9, 0xe291b4, + /* f4 */ 0xe291b5, 0xe291b6, 0xe291b7, 0xe291b8, + /* f8 */ 0xe291b9, 0xe291ba, 0xe291bb, 0xe291bc, + /* fc */ 0xe291bd, 0x000000, 0x000000, + + /*** Two byte table, leaf: c9xx - offset 0x01e31 ***/ + + /* 40 */ 0xe4b982, 0xe4b99c, 0xe587b5, 0xe58c9a, + /* 44 */ 0xe58e82, 0xe4b887, 0xe4b88c, 0xe4b987, + /* 48 */ 0xe4ba8d, 0xe59b97, 0xefa88c, 0xe5b1ae, + /* 4c */ 0xe5bdb3, 0xe4b88f, 0xe58687, 0xe4b88e, + /* 50 */ 0xe4b8ae, 0xe4ba93, 0xe4bb82, 0xe4bb89, + /* 54 */ 0xe4bb88, 0xe58698, 0xe58bbc, 0xe58dac, + /* 58 */ 0xe58eb9, 0xe59ca0, 0xe5a483, 0xe5a4ac, + /* 5c */ 0xe5b090, 0xe5b7bf, 0xe697a1, 0xe6aeb3, + /* 60 */ 0xe6af8c, 0xe6b094, 0xe788bf, 0xe4b8b1, + /* 64 */ 0xe4b8bc, 0xe4bba8, 0xe4bb9c, 0xe4bba9, + /* 68 */ 0xe4bba1, 0xe4bb9d, 0xe4bb9a, 0xe5888c, + /* 6c */ 0xe58c9c, 0xe58d8c, 0xe59ca2, 0xe59ca3, + /* 70 */ 0xe5a497, 0xe5a4af, 0xe5ae81, 0xe5ae84, + /* 74 */ 0xe5b092, 0xe5b0bb, 0xe5b1b4, 0xe5b1b3, + /* 78 */ 0xe5b884, 0xe5ba80, 0xe5ba82, 0xe5bf89, + /* 7c */ 0xe68889, 0xe68990, 0xe6b095, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6b0b6, 0xe6b183, 0xe6b0bf, + /* a4 */ 0xe6b0bb, 0xe78aae, 0xe78ab0, 0xe78e8a, + /* a8 */ 0xe7a6b8, 0xe8828a, 0xe9989e, 0xe4bc8e, + /* ac */ 0xe4bc98, 0xe4bcac, 0xe4bbb5, 0xe4bc94, + /* b0 */ 0xe4bbb1, 0xe4bc80, 0xe4bbb7, 0xe4bc88, + /* b4 */ 0xe4bc9d, 0xe4bc82, 0xe4bc85, 0xe4bca2, + /* b8 */ 0xe4bc93, 0xe4bc84, 0xe4bbb4, 0xe4bc92, + /* bc */ 0xe586b1, 0xe58893, 0xe58889, 0xe58890, + /* c0 */ 0xe58aa6, 0xe58ca2, 0xe58c9f, 0xe58d8d, + /* c4 */ 0xe58e8a, 0xe59087, 0xe59ba1, 0xe59b9f, + /* c8 */ 0xe59cae, 0xe59caa, 0xe59cb4, 0xe5a4bc, + /* cc */ 0xe5a680, 0xe5a5bc, 0xe5a685, 0xe5a5bb, + /* d0 */ 0xe5a5be, 0xe5a5b7, 0xe5a5bf, 0xe5ad96, + /* d4 */ 0xe5b095, 0xe5b0a5, 0xe5b1bc, 0xe5b1ba, + /* d8 */ 0xe5b1bb, 0xe5b1be, 0xe5b79f, 0xe5b9b5, + /* dc */ 0xe5ba84, 0xe5bc82, 0xe5bc9a, 0xe5bdb4, + /* e0 */ 0xe5bf95, 0xe5bf94, 0xe5bf8f, 0xe6899c, + /* e4 */ 0xe6899e, 0xe689a4, 0xe689a1, 0xe689a6, + /* e8 */ 0xe689a2, 0xe68999, 0xe689a0, 0xe6899a, + /* ec */ 0xe689a5, 0xe697af, 0xe697ae, 0xe69cbe, + /* f0 */ 0xe69cb9, 0xe69cb8, 0xe69cbb, 0xe69cba, + /* f4 */ 0xe69cbf, 0xe69cbc, 0xe69cb3, 0xe6b098, + /* f8 */ 0xe6b186, 0xe6b192, 0xe6b19c, 0xe6b18f, + /* fc */ 0xe6b18a, 0xe6b194, 0xe6b18b, + + /*** Two byte table, leaf: caxx - offset 0x01ef0 ***/ + + /* 40 */ 0xe6b18c, 0xe781b1, 0xe7899e, 0xe78ab4, + /* 44 */ 0xe78ab5, 0xe78e8e, 0xe794aa, 0xe799bf, + /* 48 */ 0xe7a9b5, 0xe7bd91, 0xe889b8, 0xe889bc, + /* 4c */ 0xe88a80, 0xe889bd, 0xe889bf, 0xe8998d, + /* 50 */ 0xe8a5be, 0xe98299, 0xe98297, 0xe98298, + /* 54 */ 0xe9829b, 0xe98294, 0xe998a2, 0xe998a4, + /* 58 */ 0xe998a0, 0xe998a3, 0xe4bd96, 0xe4bcbb, + /* 5c */ 0xe4bda2, 0xe4bd89, 0xe4bd93, 0xe4bda4, + /* 60 */ 0xe4bcbe, 0xe4bda7, 0xe4bd92, 0xe4bd9f, + /* 64 */ 0xe4bd81, 0xe4bd98, 0xe4bcad, 0xe4bcb3, + /* 68 */ 0xe4bcbf, 0xe4bda1, 0xe5868f, 0xe586b9, + /* 6c */ 0xe5889c, 0xe5889e, 0xe588a1, 0xe58aad, + /* 70 */ 0xe58aae, 0xe58c89, 0xe58da3, 0xe58db2, + /* 74 */ 0xe58e8e, 0xe58e8f, 0xe590b0, 0xe590b7, + /* 78 */ 0xe590aa, 0xe59194, 0xe59185, 0xe59099, + /* 7c */ 0xe5909c, 0xe590a5, 0xe59098, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe590bd, 0xe5918f, 0xe59181, + /* a4 */ 0xe590a8, 0xe590a4, 0xe59187, 0xe59bae, + /* a8 */ 0xe59ba7, 0xe59ba5, 0xe59d81, 0xe59d85, + /* ac */ 0xe59d8c, 0xe59d89, 0xe59d8b, 0xe59d92, + /* b0 */ 0xe5a486, 0xe5a580, 0xe5a6a6, 0xe5a698, + /* b4 */ 0xe5a6a0, 0xe5a697, 0xe5a68e, 0xe5a6a2, + /* b8 */ 0xe5a690, 0xe5a68f, 0xe5a6a7, 0xe5a6a1, + /* bc */ 0xe5ae8e, 0xe5ae92, 0xe5b0a8, 0xe5b0aa, + /* c0 */ 0xe5b28d, 0xe5b28f, 0xe5b288, 0xe5b28b, + /* c4 */ 0xe5b289, 0xe5b292, 0xe5b28a, 0xe5b286, + /* c8 */ 0xe5b293, 0xe5b295, 0xe5b7a0, 0xe5b88a, + /* cc */ 0xe5b88e, 0xe5ba8b, 0xe5ba89, 0xe5ba8c, + /* d0 */ 0xe5ba88, 0xe5ba8d, 0xe5bc85, 0xe5bc9d, + /* d4 */ 0xe5bdb8, 0xe5bdb6, 0xe5bf92, 0xe5bf91, + /* d8 */ 0xe5bf90, 0xe5bfad, 0xe5bfa8, 0xe5bfae, + /* dc */ 0xe5bfb3, 0xe5bfa1, 0xe5bfa4, 0xe5bfa3, + /* e0 */ 0xe5bfba, 0xe5bfaf, 0xe5bfb7, 0xe5bfbb, + /* e4 */ 0xe68080, 0xe5bfb4, 0xe688ba, 0xe68a83, + /* e8 */ 0xe68a8c, 0xe68a8e, 0xe68a8f, 0xe68a94, + /* ec */ 0xe68a87, 0xe689b1, 0xe689bb, 0xe689ba, + /* f0 */ 0xe689b0, 0xe68a81, 0xe68a88, 0xe689b7, + /* f4 */ 0xe689bd, 0xe689b2, 0xe689b4, 0xe694b7, + /* f8 */ 0xe697b0, 0xe697b4, 0xe697b3, 0xe697b2, + /* fc */ 0xe697b5, 0xe69d85, 0xe69d87, + + /*** Two byte table, leaf: cbxx - offset 0x01faf ***/ + + /* 40 */ 0xe69d99, 0xe69d95, 0xe69d8c, 0xe69d88, + /* 44 */ 0xe69d9d, 0xe69d8d, 0xe69d9a, 0xe69d8b, + /* 48 */ 0xe6af90, 0xe6b099, 0xe6b09a, 0xe6b1b8, + /* 4c */ 0xe6b1a7, 0xe6b1ab, 0xe6b284, 0xe6b28b, + /* 50 */ 0xe6b28f, 0xe6b1b1, 0xe6b1af, 0xe6b1a9, + /* 54 */ 0xe6b29a, 0xe6b1ad, 0xe6b287, 0xe6b295, + /* 58 */ 0xe6b29c, 0xe6b1a6, 0xe6b1b3, 0xe6b1a5, + /* 5c */ 0xe6b1bb, 0xe6b28e, 0xe781b4, 0xe781ba, + /* 60 */ 0xe789a3, 0xe78abf, 0xe78abd, 0xe78b83, + /* 64 */ 0xe78b86, 0xe78b81, 0xe78aba, 0xe78b85, + /* 68 */ 0xe78e95, 0xe78e97, 0xe78e93, 0xe78e94, + /* 6c */ 0xe78e92, 0xe794ba, 0xe794b9, 0xe79694, + /* 70 */ 0xe79695, 0xe79a81, 0xe7a4bd, 0xe880b4, + /* 74 */ 0xe88295, 0xe88299, 0xe88290, 0xe88292, + /* 78 */ 0xe8829c, 0xe88a90, 0xe88a8f, 0xe88a85, + /* 7c */ 0xe88a8e, 0xe88a91, 0xe88a93, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88a8a, 0xe88a83, 0xe88a84, + /* a4 */ 0xe8b1b8, 0xe8bf89, 0xe8bebf, 0xe9829f, + /* a8 */ 0xe982a1, 0xe982a5, 0xe9829e, 0xe982a7, + /* ac */ 0xe982a0, 0xe998b0, 0xe998a8, 0xe998af, + /* b0 */ 0xe998ad, 0xe4b8b3, 0xe4be98, 0xe4bdbc, + /* b4 */ 0xe4be85, 0xe4bdbd, 0xe4be80, 0xe4be87, + /* b8 */ 0xe4bdb6, 0xe4bdb4, 0xe4be89, 0xe4be84, + /* bc */ 0xe4bdb7, 0xe4bd8c, 0xe4be97, 0xe4bdaa, + /* c0 */ 0xe4be9a, 0xe4bdb9, 0xe4be81, 0xe4bdb8, + /* c4 */ 0xe4be90, 0xe4be9c, 0xe4be94, 0xe4be9e, + /* c8 */ 0xe4be92, 0xe4be82, 0xe4be95, 0xe4bdab, + /* cc */ 0xe4bdae, 0xe5869e, 0xe586bc, 0xe586be, + /* d0 */ 0xe588b5, 0xe588b2, 0xe588b3, 0xe58986, + /* d4 */ 0xe588b1, 0xe58abc, 0xe58c8a, 0xe58c8b, + /* d8 */ 0xe58cbc, 0xe58e92, 0xe58e94, 0xe59287, + /* dc */ 0xe591bf, 0xe59281, 0xe59291, 0xe59282, + /* e0 */ 0xe59288, 0xe591ab, 0xe591ba, 0xe591be, + /* e4 */ 0xe591a5, 0xe591ac, 0xe591b4, 0xe591a6, + /* e8 */ 0xe5928d, 0xe591af, 0xe591a1, 0xe591a0, + /* ec */ 0xe59298, 0xe591a3, 0xe591a7, 0xe591a4, + /* f0 */ 0xe59bb7, 0xe59bb9, 0xe59daf, 0xe59db2, + /* f4 */ 0xe59dad, 0xe59dab, 0xe59db1, 0xe59db0, + /* f8 */ 0xe59db6, 0xe59e80, 0xe59db5, 0xe59dbb, + /* fc */ 0xe59db3, 0xe59db4, 0xe59da2, + + /*** Two byte table, leaf: ccxx - offset 0x0206e ***/ + + /* 40 */ 0xe59da8, 0xe59dbd, 0xe5a48c, 0xe5a585, + /* 44 */ 0xe5a6b5, 0xe5a6ba, 0xe5a78f, 0xe5a78e, + /* 48 */ 0xe5a6b2, 0xe5a78c, 0xe5a781, 0xe5a6b6, + /* 4c */ 0xe5a6bc, 0xe5a783, 0xe5a796, 0xe5a6b1, + /* 50 */ 0xe5a6bd, 0xe5a780, 0xe5a788, 0xe5a6b4, + /* 54 */ 0xe5a787, 0xe5ada2, 0xe5ada5, 0xe5ae93, + /* 58 */ 0xe5ae95, 0xe5b184, 0xe5b187, 0xe5b2ae, + /* 5c */ 0xe5b2a4, 0xe5b2a0, 0xe5b2b5, 0xe5b2af, + /* 60 */ 0xe5b2a8, 0xe5b2ac, 0xe5b29f, 0xe5b2a3, + /* 64 */ 0xe5b2ad, 0xe5b2a2, 0xe5b2aa, 0xe5b2a7, + /* 68 */ 0xe5b29d, 0xe5b2a5, 0xe5b2b6, 0xe5b2b0, + /* 6c */ 0xe5b2a6, 0xe5b897, 0xe5b894, 0xe5b899, + /* 70 */ 0xe5bca8, 0xe5bca2, 0xe5bca3, 0xe5bca4, + /* 74 */ 0xe5bd94, 0xe5be82, 0xe5bdbe, 0xe5bdbd, + /* 78 */ 0xe5bf9e, 0xe5bfa5, 0xe680ad, 0xe680a6, + /* 7c */ 0xe68099, 0xe680b2, 0xe6808b, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe680b4, 0xe6808a, 0xe68097, + /* a4 */ 0xe680b3, 0xe6809a, 0xe6809e, 0xe680ac, + /* a8 */ 0xe680a2, 0xe6808d, 0xe68090, 0xe680ae, + /* ac */ 0xe68093, 0xe68091, 0xe6808c, 0xe68089, + /* b0 */ 0xe6809c, 0xe68894, 0xe688bd, 0xe68aad, + /* b4 */ 0xe68ab4, 0xe68b91, 0xe68abe, 0xe68aaa, + /* b8 */ 0xe68ab6, 0xe68b8a, 0xe68aae, 0xe68ab3, + /* bc */ 0xe68aaf, 0xe68abb, 0xe68aa9, 0xe68ab0, + /* c0 */ 0xe68ab8, 0xe694bd, 0xe696a8, 0xe696bb, + /* c4 */ 0xe69889, 0xe697bc, 0xe69884, 0xe69892, + /* c8 */ 0xe69888, 0xe697bb, 0xe69883, 0xe6988b, + /* cc */ 0xe6988d, 0xe69885, 0xe697bd, 0xe69891, + /* d0 */ 0xe69890, 0xe69bb6, 0xe69c8a, 0xe69e85, + /* d4 */ 0xe69dac, 0xe69e8e, 0xe69e92, 0xe69db6, + /* d8 */ 0xe69dbb, 0xe69e98, 0xe69e86, 0xe69e84, + /* dc */ 0xe69db4, 0xe69e8d, 0xe69e8c, 0xe69dba, + /* e0 */ 0xe69e9f, 0xe69e91, 0xe69e99, 0xe69e83, + /* e4 */ 0xe69dbd, 0xe69e81, 0xe69db8, 0xe69db9, + /* e8 */ 0xe69e94, 0xe6aca5, 0xe6ae80, 0xe6adbe, + /* ec */ 0xe6af9e, 0xe6b09d, 0xe6b293, 0xe6b3ac, + /* f0 */ 0xe6b3ab, 0xe6b3ae, 0xe6b399, 0xe6b2b6, + /* f4 */ 0xe6b394, 0xe6b2ad, 0xe6b3a7, 0xe6b2b7, + /* f8 */ 0xe6b390, 0xe6b382, 0xe6b2ba, 0xe6b383, + /* fc */ 0xe6b386, 0xe6b3ad, 0xe6b3b2, + + /*** Two byte table, leaf: cdxx - offset 0x0212d ***/ + + /* 40 */ 0xe6b392, 0xe6b39d, 0xe6b2b4, 0xe6b28a, + /* 44 */ 0xe6b29d, 0xe6b280, 0xe6b39e, 0xe6b380, + /* 48 */ 0xe6b4b0, 0xe6b38d, 0xe6b387, 0xe6b2b0, + /* 4c */ 0xe6b3b9, 0xe6b38f, 0xe6b3a9, 0xe6b391, + /* 50 */ 0xe78294, 0xe78298, 0xe78285, 0xe78293, + /* 54 */ 0xe78286, 0xe78284, 0xe78291, 0xe78296, + /* 58 */ 0xe78282, 0xe7829a, 0xe78283, 0xe789aa, + /* 5c */ 0xe78b96, 0xe78b8b, 0xe78b98, 0xe78b89, + /* 60 */ 0xe78b9c, 0xe78b92, 0xe78b94, 0xe78b9a, + /* 64 */ 0xe78b8c, 0xe78b91, 0xe78ea4, 0xe78ea1, + /* 68 */ 0xe78ead, 0xe78ea6, 0xe78ea2, 0xe78ea0, + /* 6c */ 0xe78eac, 0xe78e9d, 0xe7939d, 0xe793a8, + /* 70 */ 0xe794bf, 0xe79580, 0xe794be, 0xe7968c, + /* 74 */ 0xe79698, 0xe79aaf, 0xe79bb3, 0xe79bb1, + /* 78 */ 0xe79bb0, 0xe79bb5, 0xe79fb8, 0xe79fbc, + /* 7c */ 0xe79fb9, 0xe79fbb, 0xe79fba, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe79fb7, 0xe7a582, 0xe7a4bf, + /* a4 */ 0xe7a785, 0xe7a9b8, 0xe7a9bb, 0xe7abbb, + /* a8 */ 0xe7b1b5, 0xe7b3bd, 0xe880b5, 0xe8828f, + /* ac */ 0xe882ae, 0xe882a3, 0xe882b8, 0xe882b5, + /* b0 */ 0xe882ad, 0xe888a0, 0xe88aa0, 0xe88b80, + /* b4 */ 0xe88aab, 0xe88a9a, 0xe88a98, 0xe88a9b, + /* b8 */ 0xe88ab5, 0xe88aa7, 0xe88aae, 0xe88abc, + /* bc */ 0xe88a9e, 0xe88aba, 0xe88ab4, 0xe88aa8, + /* c0 */ 0xe88aa1, 0xe88aa9, 0xe88b82, 0xe88aa4, + /* c4 */ 0xe88b83, 0xe88ab6, 0xe88aa2, 0xe899b0, + /* c8 */ 0xe899af, 0xe899ad, 0xe899ae, 0xe8b196, + /* cc */ 0xe8bf92, 0xe8bf8b, 0xe8bf93, 0xe8bf8d, + /* d0 */ 0xe8bf96, 0xe8bf95, 0xe8bf97, 0xe982b2, + /* d4 */ 0xe982b4, 0xe982af, 0xe982b3, 0xe982b0, + /* d8 */ 0xe998b9, 0xe998bd, 0xe998bc, 0xe998ba, + /* dc */ 0xe99983, 0xe4bf8d, 0xe4bf85, 0xe4bf93, + /* e0 */ 0xe4beb2, 0xe4bf89, 0xe4bf8b, 0xe4bf81, + /* e4 */ 0xe4bf94, 0xe4bf9c, 0xe4bf99, 0xe4bebb, + /* e8 */ 0xe4beb3, 0xe4bf9b, 0xe4bf87, 0xe4bf96, + /* ec */ 0xe4beba, 0xe4bf80, 0xe4beb9, 0xe4bfac, + /* f0 */ 0xe58984, 0xe58989, 0xe58b80, 0xe58b82, + /* f4 */ 0xe58cbd, 0xe58dbc, 0xe58e97, 0xe58e96, + /* f8 */ 0xe58e99, 0xe58e98, 0xe592ba, 0xe592a1, + /* fc */ 0xe592ad, 0xe592a5, 0xe5938f, + + /*** Two byte table, leaf: cexx - offset 0x021ec ***/ + + /* 40 */ 0xe59383, 0xe88c8d, 0xe592b7, 0xe592ae, + /* 44 */ 0xe59396, 0xe592b6, 0xe59385, 0xe59386, + /* 48 */ 0xe592a0, 0xe591b0, 0xe592bc, 0xe592a2, + /* 4c */ 0xe592be, 0xe591b2, 0xe5939e, 0xe592b0, + /* 50 */ 0xe59eb5, 0xe59e9e, 0xe59e9f, 0xe59ea4, + /* 54 */ 0xe59e8c, 0xe59e97, 0xe59e9d, 0xe59e9b, + /* 58 */ 0xe59e94, 0xe59e98, 0xe59e8f, 0xe59e99, + /* 5c */ 0xe59ea5, 0xe59e9a, 0xe59e95, 0xe5a3b4, + /* 60 */ 0xe5a48d, 0xe5a593, 0xe5a7a1, 0xe5a79e, + /* 64 */ 0xe5a7ae, 0xe5a880, 0xe5a7b1, 0xe5a79d, + /* 68 */ 0xe5a7ba, 0xe5a7bd, 0xe5a7bc, 0xe5a7b6, + /* 6c */ 0xe5a7a4, 0xe5a7b2, 0xe5a7b7, 0xe5a79b, + /* 70 */ 0xe5a7a9, 0xe5a7b3, 0xe5a7b5, 0xe5a7a0, + /* 74 */ 0xe5a7be, 0xe5a7b4, 0xe5a7ad, 0xe5aea8, + /* 78 */ 0xe5b18c, 0xe5b390, 0xe5b398, 0xe5b38c, + /* 7c */ 0xe5b397, 0xe5b38b, 0xe5b39b, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5b39e, 0xe5b39a, 0xe5b389, + /* a4 */ 0xe5b387, 0xe5b38a, 0xe5b396, 0xe5b393, + /* a8 */ 0xe5b394, 0xe5b38f, 0xe5b388, 0xe5b386, + /* ac */ 0xe5b38e, 0xe5b39f, 0xe5b3b8, 0xe5b7b9, + /* b0 */ 0xe5b8a1, 0xe5b8a2, 0xe5b8a3, 0xe5b8a0, + /* b4 */ 0xe5b8a4, 0xe5bab0, 0xe5baa4, 0xe5baa2, + /* b8 */ 0xe5ba9b, 0xe5baa3, 0xe5baa5, 0xe5bc87, + /* bc */ 0xe5bcae, 0xe5bd96, 0xe5be86, 0xe680b7, + /* c0 */ 0xe680b9, 0xe68194, 0xe681b2, 0xe6819e, + /* c4 */ 0xe68185, 0xe68193, 0xe68187, 0xe68189, + /* c8 */ 0xe6819b, 0xe6818c, 0xe68180, 0xe68182, + /* cc */ 0xe6819f, 0xe680a4, 0xe68184, 0xe68198, + /* d0 */ 0xe681a6, 0xe681ae, 0xe68982, 0xe68983, + /* d4 */ 0xe68b8f, 0xe68c8d, 0xe68c8b, 0xe68bb5, + /* d8 */ 0xe68c8e, 0xe68c83, 0xe68bab, 0xe68bb9, + /* dc */ 0xe68c8f, 0xe68c8c, 0xe68bb8, 0xe68bb6, + /* e0 */ 0xe68c80, 0xe68c93, 0xe68c94, 0xe68bba, + /* e4 */ 0xe68c95, 0xe68bbb, 0xe68bb0, 0xe69581, + /* e8 */ 0xe69583, 0xe696aa, 0xe696bf, 0xe698b6, + /* ec */ 0xe698a1, 0xe698b2, 0xe698b5, 0xe6989c, + /* f0 */ 0xe698a6, 0xe698a2, 0xe698b3, 0xe698ab, + /* f4 */ 0xe698ba, 0xe6989d, 0xe698b4, 0xe698b9, + /* f8 */ 0xe698ae, 0xe69c8f, 0xe69c90, 0xe69f81, + /* fc */ 0xe69fb2, 0xe69f88, 0xe69eba, + + /*** Two byte table, leaf: cfxx - offset 0x022ab ***/ + + /* 40 */ 0xe69f9c, 0xe69ebb, 0xe69fb8, 0xe69f98, + /* 44 */ 0xe69f80, 0xe69eb7, 0xe69f85, 0xe69fab, + /* 48 */ 0xe69fa4, 0xe69f9f, 0xe69eb5, 0xe69f8d, + /* 4c */ 0xe69eb3, 0xe69fb7, 0xe69fb6, 0xe69fae, + /* 50 */ 0xe69fa3, 0xe69f82, 0xe69eb9, 0xe69f8e, + /* 54 */ 0xe69fa7, 0xe69fb0, 0xe69eb2, 0xe69fbc, + /* 58 */ 0xe69f86, 0xe69fad, 0xe69f8c, 0xe69eae, + /* 5c */ 0xe69fa6, 0xe69f9b, 0xe69fba, 0xe69f89, + /* 60 */ 0xe69f8a, 0xe69f83, 0xe69faa, 0xe69f8b, + /* 64 */ 0xe6aca8, 0xe6ae82, 0xe6ae84, 0xe6aeb6, + /* 68 */ 0xe6af96, 0xe6af98, 0xe6afa0, 0xe6b0a0, + /* 6c */ 0xe6b0a1, 0xe6b4a8, 0xe6b4b4, 0xe6b4ad, + /* 70 */ 0xe6b49f, 0xe6b4bc, 0xe6b4bf, 0xe6b492, + /* 74 */ 0xe6b48a, 0xe6b39a, 0xe6b4b3, 0xe6b484, + /* 78 */ 0xe6b499, 0xe6b4ba, 0xe6b49a, 0xe6b491, + /* 7c */ 0xe6b480, 0xe6b49d, 0xe6b582, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6b481, 0xe6b498, 0xe6b4b7, + /* a4 */ 0xe6b483, 0xe6b48f, 0xe6b580, 0xe6b487, + /* a8 */ 0xe6b4a0, 0xe6b4ac, 0xe6b488, 0xe6b4a2, + /* ac */ 0xe6b489, 0xe6b490, 0xe782b7, 0xe7829f, + /* b0 */ 0xe782be, 0xe782b1, 0xe782b0, 0xe782a1, + /* b4 */ 0xe782b4, 0xe782b5, 0xe782a9, 0xe78981, + /* b8 */ 0xe78989, 0xe7898a, 0xe789ac, 0xe789b0, + /* bc */ 0xe789b3, 0xe789ae, 0xe78b8a, 0xe78ba4, + /* c0 */ 0xe78ba8, 0xe78bab, 0xe78b9f, 0xe78baa, + /* c4 */ 0xe78ba6, 0xe78ba3, 0xe78e85, 0xe78f8c, + /* c8 */ 0xe78f82, 0xe78f88, 0xe78f85, 0xe78eb9, + /* cc */ 0xe78eb6, 0xe78eb5, 0xe78eb4, 0xe78fab, + /* d0 */ 0xe78ebf, 0xe78f87, 0xe78ebe, 0xe78f83, + /* d4 */ 0xe78f86, 0xe78eb8, 0xe78f8b, 0xe793ac, + /* d8 */ 0xe793ae, 0xe794ae, 0xe79587, 0xe79588, + /* dc */ 0xe796a7, 0xe796aa, 0xe799b9, 0xe79b84, + /* e0 */ 0xe79c88, 0xe79c83, 0xe79c84, 0xe79c85, + /* e4 */ 0xe79c8a, 0xe79bb7, 0xe79bbb, 0xe79bba, + /* e8 */ 0xe79fa7, 0xe79fa8, 0xe7a086, 0xe7a091, + /* ec */ 0xe7a092, 0xe7a085, 0xe7a090, 0xe7a08f, + /* f0 */ 0xe7a08e, 0xe7a089, 0xe7a083, 0xe7a093, + /* f4 */ 0xe7a58a, 0xe7a58c, 0xe7a58b, 0xe7a585, + /* f8 */ 0xe7a584, 0xe7a795, 0xe7a78d, 0xe7a78f, + /* fc */ 0xe7a796, 0xe7a78e, 0xe7aa80, + + /*** Two byte table, leaf: d0xx - offset 0x0236a ***/ + + /* 40 */ 0xe7a9be, 0xe7ab91, 0xe7ac80, 0xe7ac81, + /* 44 */ 0xe7b1ba, 0xe7b1b8, 0xe7b1b9, 0xe7b1bf, + /* 48 */ 0xe7b280, 0xe7b281, 0xe7b483, 0xe7b488, + /* 4c */ 0xe7b481, 0xe7bd98, 0xe7be91, 0xe7be8d, + /* 50 */ 0xe7bebe, 0xe88087, 0xe8808e, 0xe8808f, + /* 54 */ 0xe88094, 0xe880b7, 0xe88398, 0xe88387, + /* 58 */ 0xe883a0, 0xe88391, 0xe88388, 0xe88382, + /* 5c */ 0xe88390, 0xe88385, 0xe883a3, 0xe88399, + /* 60 */ 0xe8839c, 0xe8838a, 0xe88395, 0xe88389, + /* 64 */ 0xe8838f, 0xe88397, 0xe883a6, 0xe8838d, + /* 68 */ 0xe887bf, 0xe888a1, 0xe88a94, 0xe88b99, + /* 6c */ 0xe88bbe, 0xe88bb9, 0xe88c87, 0xe88ba8, + /* 70 */ 0xe88c80, 0xe88b95, 0xe88cba, 0xe88bab, + /* 74 */ 0xe88b96, 0xe88bb4, 0xe88bac, 0xe88ba1, + /* 78 */ 0xe88bb2, 0xe88bb5, 0xe88c8c, 0xe88bbb, + /* 7c */ 0xe88bb6, 0xe88bb0, 0xe88baa, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88ba4, 0xe88ba0, 0xe88bba, + /* a4 */ 0xe88bb3, 0xe88bad, 0xe899b7, 0xe899b4, + /* a8 */ 0xe899bc, 0xe899b3, 0xe8a181, 0xe8a18e, + /* ac */ 0xe8a1a7, 0xe8a1aa, 0xe8a1a9, 0xe8a793, + /* b0 */ 0xe8a884, 0xe8a887, 0xe8b5b2, 0xe8bfa3, + /* b4 */ 0xe8bfa1, 0xe8bfae, 0xe8bfa0, 0xe983b1, + /* b8 */ 0xe982bd, 0xe982bf, 0xe98395, 0xe98385, + /* bc */ 0xe982be, 0xe98387, 0xe9838b, 0xe98388, + /* c0 */ 0xe98794, 0xe98793, 0xe99994, 0xe9998f, + /* c4 */ 0xe99991, 0xe99993, 0xe9998a, 0xe9998e, + /* c8 */ 0xe5809e, 0xe58085, 0xe58087, 0xe58093, + /* cc */ 0xe580a2, 0xe580b0, 0xe5809b, 0xe4bfb5, + /* d0 */ 0xe4bfb4, 0xe580b3, 0xe580b7, 0xe580ac, + /* d4 */ 0xe4bfb6, 0xe4bfb7, 0xe58097, 0xe5809c, + /* d8 */ 0xe580a0, 0xe580a7, 0xe580b5, 0xe580af, + /* dc */ 0xe580b1, 0xe5808e, 0xe5859a, 0xe58694, + /* e0 */ 0xe58693, 0xe5878a, 0xe58784, 0xe58785, + /* e4 */ 0xe58788, 0xe5878e, 0xe589a1, 0xe5899a, + /* e8 */ 0xe58992, 0xe5899e, 0xe5899f, 0xe58995, + /* ec */ 0xe589a2, 0xe58b8d, 0xe58c8e, 0xe58e9e, + /* f0 */ 0xe594a6, 0xe593a2, 0xe59497, 0xe59492, + /* f4 */ 0xe593a7, 0xe593b3, 0xe593a4, 0xe5949a, + /* f8 */ 0xe593bf, 0xe59484, 0xe59488, 0xe593ab, + /* fc */ 0xe59491, 0xe59485, 0xe593b1, + + /*** Two byte table, leaf: d1xx - offset 0x02429 ***/ + + /* 40 */ 0xe5948a, 0xe593bb, 0xe593b7, 0xe593b8, + /* 44 */ 0xe593a0, 0xe5948e, 0xe59483, 0xe5948b, + /* 48 */ 0xe59c81, 0xe59c82, 0xe59f8c, 0xe5a0b2, + /* 4c */ 0xe59f95, 0xe59f92, 0xe59eba, 0xe59f86, + /* 50 */ 0xe59ebd, 0xe59ebc, 0xe59eb8, 0xe59eb6, + /* 54 */ 0xe59ebf, 0xe59f87, 0xe59f90, 0xe59eb9, + /* 58 */ 0xe59f81, 0xe5a48e, 0xe5a58a, 0xe5a899, + /* 5c */ 0xe5a896, 0xe5a8ad, 0xe5a8ae, 0xe5a895, + /* 60 */ 0xe5a88f, 0xe5a897, 0xe5a88a, 0xe5a89e, + /* 64 */ 0xe5a8b3, 0xe5adac, 0xe5aea7, 0xe5aead, + /* 68 */ 0xe5aeac, 0xe5b083, 0xe5b196, 0xe5b194, + /* 6c */ 0xe5b3ac, 0xe5b3bf, 0xe5b3ae, 0xe5b3b1, + /* 70 */ 0xe5b3b7, 0xe5b480, 0xe5b3b9, 0xe5b8a9, + /* 74 */ 0xe5b8a8, 0xe5baa8, 0xe5baae, 0xe5baaa, + /* 78 */ 0xe5baac, 0xe5bcb3, 0xe5bcb0, 0xe5bda7, + /* 7c */ 0xe6819d, 0xe6819a, 0xe681a7, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe68181, 0xe682a2, 0xe68288, + /* a4 */ 0xe68280, 0xe68292, 0xe68281, 0xe6829d, + /* a8 */ 0xe68283, 0xe68295, 0xe6829b, 0xe68297, + /* ac */ 0xe68287, 0xe6829c, 0xe6828e, 0xe68899, + /* b0 */ 0xe68986, 0xe68bb2, 0xe68c90, 0xe68d96, + /* b4 */ 0xe68cac, 0xe68d84, 0xe68d85, 0xe68cb6, + /* b8 */ 0xe68d83, 0xe68fa4, 0xe68cb9, 0xe68d8b, + /* bc */ 0xe68d8a, 0xe68cbc, 0xe68ca9, 0xe68d81, + /* c0 */ 0xe68cb4, 0xe68d98, 0xe68d94, 0xe68d99, + /* c4 */ 0xe68cad, 0xe68d87, 0xe68cb3, 0xe68d9a, + /* c8 */ 0xe68d91, 0xe68cb8, 0xe68d97, 0xe68d80, + /* cc */ 0xe68d88, 0xe6958a, 0xe69586, 0xe69786, + /* d0 */ 0xe69783, 0xe69784, 0xe69782, 0xe6998a, + /* d4 */ 0xe6999f, 0xe69987, 0xe69991, 0xe69c92, + /* d8 */ 0xe69c93, 0xe6a09f, 0xe6a09a, 0xe6a189, + /* dc */ 0xe6a0b2, 0xe6a0b3, 0xe6a0bb, 0xe6a18b, + /* e0 */ 0xe6a18f, 0xe6a096, 0xe6a0b1, 0xe6a09c, + /* e4 */ 0xe6a0b5, 0xe6a0ab, 0xe6a0ad, 0xe6a0af, + /* e8 */ 0xe6a18e, 0xe6a184, 0xe6a0b4, 0xe6a09d, + /* ec */ 0xe6a092, 0xe6a094, 0xe6a0a6, 0xe6a0a8, + /* f0 */ 0xe6a0ae, 0xe6a18d, 0xe6a0ba, 0xe6a0a5, + /* f4 */ 0xe6a0a0, 0xe6acac, 0xe6acaf, 0xe6acad, + /* f8 */ 0xe6acb1, 0xe6acb4, 0xe6adad, 0xe88282, + /* fc */ 0xe6ae88, 0xe6afa6, 0xe6afa4, + + /*** Two byte table, leaf: d2xx - offset 0x024e8 ***/ + + /* 40 */ 0xe6afa8, 0xe6afa3, 0xe6afa2, 0xe6afa7, + /* 44 */ 0xe6b0a5, 0xe6b5ba, 0xe6b5a3, 0xe6b5a4, + /* 48 */ 0xe6b5b6, 0xe6b48d, 0xe6b5a1, 0xe6b692, + /* 4c */ 0xe6b598, 0xe6b5a2, 0xe6b5ad, 0xe6b5af, + /* 50 */ 0xe6b691, 0xe6b68d, 0xe6b7af, 0xe6b5bf, + /* 54 */ 0xe6b686, 0xe6b59e, 0xe6b5a7, 0xe6b5a0, + /* 58 */ 0xe6b697, 0xe6b5b0, 0xe6b5bc, 0xe6b59f, + /* 5c */ 0xe6b682, 0xe6b698, 0xe6b4af, 0xe6b5a8, + /* 60 */ 0xe6b68b, 0xe6b5be, 0xe6b680, 0xe6b684, + /* 64 */ 0xe6b496, 0xe6b683, 0xe6b5bb, 0xe6b5bd, + /* 68 */ 0xe6b5b5, 0xe6b690, 0xe7839c, 0xe78393, + /* 6c */ 0xe78391, 0xe7839d, 0xe7838b, 0xe7bcb9, + /* 70 */ 0xe783a2, 0xe78397, 0xe78392, 0xe7839e, + /* 74 */ 0xe783a0, 0xe78394, 0xe7838d, 0xe78385, + /* 78 */ 0xe78386, 0xe78387, 0xe7839a, 0xe7838e, + /* 7c */ 0xe783a1, 0xe78982, 0xe789b8, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe789b7, 0xe789b6, 0xe78c80, + /* a4 */ 0xe78bba, 0xe78bb4, 0xe78bbe, 0xe78bb6, + /* a8 */ 0xe78bb3, 0xe78bbb, 0xe78c81, 0xe78f93, + /* ac */ 0xe78f99, 0xe78fa5, 0xe78f96, 0xe78ebc, + /* b0 */ 0xe78fa7, 0xe78fa3, 0xe78fa9, 0xe78f9c, + /* b4 */ 0xe78f92, 0xe78f9b, 0xe78f94, 0xe78f9d, + /* b8 */ 0xe78f9a, 0xe78f97, 0xe78f98, 0xe78fa8, + /* bc */ 0xe7939e, 0xe7939f, 0xe793b4, 0xe793b5, + /* c0 */ 0xe794a1, 0xe7959b, 0xe7959f, 0xe796b0, + /* c4 */ 0xe79781, 0xe796bb, 0xe79784, 0xe79780, + /* c8 */ 0xe796bf, 0xe796b6, 0xe796ba, 0xe79a8a, + /* cc */ 0xe79b89, 0xe79c9d, 0xe79c9b, 0xe79c90, + /* d0 */ 0xe79c93, 0xe79c92, 0xe79ca3, 0xe79c91, + /* d4 */ 0xe79c95, 0xe79c99, 0xe79c9a, 0xe79ca2, + /* d8 */ 0xe79ca7, 0xe7a0a3, 0xe7a0ac, 0xe7a0a2, + /* dc */ 0xe7a0b5, 0xe7a0af, 0xe7a0a8, 0xe7a0ae, + /* e0 */ 0xe7a0ab, 0xe7a0a1, 0xe7a0a9, 0xe7a0b3, + /* e4 */ 0xe7a0aa, 0xe7a0b1, 0xe7a594, 0xe7a59b, + /* e8 */ 0xe7a58f, 0xe7a59c, 0xe7a593, 0xe7a592, + /* ec */ 0xe7a591, 0xe7a7ab, 0xe7a7ac, 0xe7a7a0, + /* f0 */ 0xe7a7ae, 0xe7a7ad, 0xe7a7aa, 0xe7a79c, + /* f4 */ 0xe7a79e, 0xe7a79d, 0xe7aa86, 0xe7aa89, + /* f8 */ 0xe7aa85, 0xe7aa8b, 0xe7aa8c, 0xe7aa8a, + /* fc */ 0xe7aa87, 0xe7ab98, 0xe7ac90, + + /*** Two byte table, leaf: d3xx - offset 0x025a7 ***/ + + /* 40 */ 0xe7ac84, 0xe7ac93, 0xe7ac85, 0xe7ac8f, + /* 44 */ 0xe7ac88, 0xe7ac8a, 0xe7ac8e, 0xe7ac89, + /* 48 */ 0xe7ac92, 0xe7b284, 0xe7b291, 0xe7b28a, + /* 4c */ 0xe7b28c, 0xe7b288, 0xe7b28d, 0xe7b285, + /* 50 */ 0xe7b49e, 0xe7b49d, 0xe7b491, 0xe7b48e, + /* 54 */ 0xe7b498, 0xe7b496, 0xe7b493, 0xe7b49f, + /* 58 */ 0xe7b492, 0xe7b48f, 0xe7b48c, 0xe7bd9c, + /* 5c */ 0xe7bda1, 0xe7bd9e, 0xe7bda0, 0xe7bd9d, + /* 60 */ 0xe7bd9b, 0xe7be96, 0xe7be92, 0xe7bf83, + /* 64 */ 0xe7bf82, 0xe7bf80, 0xe88096, 0xe880be, + /* 68 */ 0xe880b9, 0xe883ba, 0xe883b2, 0xe883b9, + /* 6c */ 0xe883b5, 0xe88481, 0xe883bb, 0xe88480, + /* 70 */ 0xe88881, 0xe888af, 0xe888a5, 0xe88cb3, + /* 74 */ 0xe88cad, 0xe88d84, 0xe88c99, 0xe88d91, + /* 78 */ 0xe88ca5, 0xe88d96, 0xe88cbf, 0xe88d81, + /* 7c */ 0xe88ca6, 0xe88c9c, 0xe88ca2, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88d82, 0xe88d8e, 0xe88c9b, + /* a4 */ 0xe88caa, 0xe88c88, 0xe88cbc, 0xe88d8d, + /* a8 */ 0xe88c96, 0xe88ca4, 0xe88ca0, 0xe88cb7, + /* ac */ 0xe88caf, 0xe88ca9, 0xe88d87, 0xe88d85, + /* b0 */ 0xe88d8c, 0xe88d93, 0xe88c9e, 0xe88cac, + /* b4 */ 0xe88d8b, 0xe88ca7, 0xe88d88, 0xe89993, + /* b8 */ 0xe89992, 0xe89aa2, 0xe89aa8, 0xe89a96, + /* bc */ 0xe89a8d, 0xe89a91, 0xe89a9e, 0xe89a87, + /* c0 */ 0xe89a97, 0xe89a86, 0xe89a8b, 0xe89a9a, + /* c4 */ 0xe89a85, 0xe89aa5, 0xe89a99, 0xe89aa1, + /* c8 */ 0xe89aa7, 0xe89a95, 0xe89a98, 0xe89a8e, + /* cc */ 0xe89a9d, 0xe89a90, 0xe89a94, 0xe8a183, + /* d0 */ 0xe8a184, 0xe8a1ad, 0xe8a1b5, 0xe8a1b6, + /* d4 */ 0xe8a1b2, 0xe8a280, 0xe8a1b1, 0xe8a1bf, + /* d8 */ 0xe8a1af, 0xe8a283, 0xe8a1be, 0xe8a1b4, + /* dc */ 0xe8a1bc, 0xe8a892, 0xe8b187, 0xe8b197, + /* e0 */ 0xe8b1bb, 0xe8b2a4, 0xe8b2a3, 0xe8b5b6, + /* e4 */ 0xe8b5b8, 0xe8b6b5, 0xe8b6b7, 0xe8b6b6, + /* e8 */ 0xe8bb91, 0xe8bb93, 0xe8bfbe, 0xe8bfb5, + /* ec */ 0xe98082, 0xe8bfbf, 0xe8bfbb, 0xe98084, + /* f0 */ 0xe8bfbc, 0xe8bfb6, 0xe98396, 0xe983a0, + /* f4 */ 0xe98399, 0xe9839a, 0xe983a3, 0xe9839f, + /* f8 */ 0xe983a5, 0xe98398, 0xe9839b, 0xe98397, + /* fc */ 0xe9839c, 0xe983a4, 0xe98590, + + /*** Two byte table, leaf: d4xx - offset 0x02666 ***/ + + /* 40 */ 0xe9858e, 0xe9858f, 0xe98795, 0xe987a2, + /* 44 */ 0xe9879a, 0xe9999c, 0xe9999f, 0xe99abc, + /* 48 */ 0xe9a3a3, 0xe9ab9f, 0xe9acaf, 0xe4b9bf, + /* 4c */ 0xe581b0, 0xe581aa, 0xe581a1, 0xe5819e, + /* 50 */ 0xe581a0, 0xe58193, 0xe5818b, 0xe5819d, + /* 54 */ 0xe581b2, 0xe58188, 0xe5818d, 0xe58181, + /* 58 */ 0xe5819b, 0xe5818a, 0xe581a2, 0xe58095, + /* 5c */ 0xe58185, 0xe5819f, 0xe581a9, 0xe581ab, + /* 60 */ 0xe581a3, 0xe581a4, 0xe58186, 0xe58180, + /* 64 */ 0xe581ae, 0xe581b3, 0xe58197, 0xe58191, + /* 68 */ 0xe58790, 0xe589ab, 0xe589ad, 0xe589ac, + /* 6c */ 0xe589ae, 0xe58b96, 0xe58b93, 0xe58cad, + /* 70 */ 0xe58e9c, 0xe595b5, 0xe595b6, 0xe594bc, + /* 74 */ 0xe5958d, 0xe59590, 0xe594b4, 0xe594aa, + /* 78 */ 0xe59591, 0xe595a2, 0xe594b6, 0xe594b5, + /* 7c */ 0xe594b0, 0xe59592, 0xe59585, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5948c, 0xe594b2, 0xe595a5, + /* a4 */ 0xe5958e, 0xe594b9, 0xe59588, 0xe594ad, + /* a8 */ 0xe594bb, 0xe59580, 0xe5958b, 0xe59c8a, + /* ac */ 0xe59c87, 0xe59fbb, 0xe5a094, 0xe59fa2, + /* b0 */ 0xe59fb6, 0xe59f9c, 0xe59fb4, 0xe5a080, + /* b4 */ 0xe59fad, 0xe59fbd, 0xe5a088, 0xe59fb8, + /* b8 */ 0xe5a08b, 0xe59fb3, 0xe59f8f, 0xe5a087, + /* bc */ 0xe59fae, 0xe59fa3, 0xe59fb2, 0xe59fa5, + /* c0 */ 0xe59fac, 0xe59fa1, 0xe5a08e, 0xe59fbc, + /* c4 */ 0xe5a090, 0xe59fa7, 0xe5a081, 0xe5a08c, + /* c8 */ 0xe59fb1, 0xe59fa9, 0xe59fb0, 0xe5a08d, + /* cc */ 0xe5a084, 0xe5a59c, 0xe5a9a0, 0xe5a998, + /* d0 */ 0xe5a995, 0xe5a9a7, 0xe5a99e, 0xe5a8b8, + /* d4 */ 0xe5a8b5, 0xe5a9ad, 0xe5a990, 0xe5a99f, + /* d8 */ 0xe5a9a5, 0xe5a9ac, 0xe5a993, 0xe5a9a4, + /* dc */ 0xe5a997, 0xe5a983, 0xe5a99d, 0xe5a992, + /* e0 */ 0xe5a984, 0xe5a99b, 0xe5a988, 0xe5aa8e, + /* e4 */ 0xe5a8be, 0xe5a98d, 0xe5a8b9, 0xe5a98c, + /* e8 */ 0xe5a9b0, 0xe5a9a9, 0xe5a987, 0xe5a991, + /* ec */ 0xe5a996, 0xe5a982, 0xe5a99c, 0xe5adb2, + /* f0 */ 0xe5adae, 0xe5af81, 0xe5af80, 0xe5b199, + /* f4 */ 0xe5b49e, 0xe5b48b, 0xe5b49d, 0xe5b49a, + /* f8 */ 0xe5b4a0, 0xe5b48c, 0xe5b4a8, 0xe5b48d, + /* fc */ 0xe5b4a6, 0xe5b4a5, 0xe5b48f, + + /*** Two byte table, leaf: d5xx - offset 0x02725 ***/ + + /* 40 */ 0xe5b4b0, 0xe5b492, 0xe5b4a3, 0xe5b49f, + /* 44 */ 0xe5b4ae, 0xe5b8be, 0xe5b8b4, 0xe5bab1, + /* 48 */ 0xe5bab4, 0xe5bab9, 0xe5bab2, 0xe5bab3, + /* 4c */ 0xe5bcb6, 0xe5bcb8, 0xe5be9b, 0xe5be96, + /* 50 */ 0xe5be9f, 0xe6828a, 0xe68290, 0xe68286, + /* 54 */ 0xe682be, 0xe682b0, 0xe682ba, 0xe68393, + /* 58 */ 0xe68394, 0xe6838f, 0xe683a4, 0xe68399, + /* 5c */ 0xe6839d, 0xe68388, 0xe682b1, 0xe6839b, + /* 60 */ 0xe682b7, 0xe6838a, 0xe682bf, 0xe68383, + /* 64 */ 0xe6838d, 0xe68380, 0xe68cb2, 0xe68da5, + /* 68 */ 0xe68e8a, 0xe68e82, 0xe68dbd, 0xe68ebd, + /* 6c */ 0xe68e9e, 0xe68ead, 0xe68e9d, 0xe68e97, + /* 70 */ 0xe68eab, 0xe68e8e, 0xe68daf, 0xe68e87, + /* 74 */ 0xe68e90, 0xe68dae, 0xe68eaf, 0xe68db5, + /* 78 */ 0xe68e9c, 0xe68dad, 0xe68eae, 0xe68dbc, + /* 7c */ 0xe68ea4, 0xe68cbb, 0xe68e9f, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe68db8, 0xe68e85, 0xe68e81, + /* a4 */ 0xe68e91, 0xe68e8d, 0xe68db0, 0xe69593, + /* a8 */ 0xe6978d, 0xe699a5, 0xe699a1, 0xe6999b, + /* ac */ 0xe69999, 0xe6999c, 0xe699a2, 0xe69c98, + /* b0 */ 0xe6a1b9, 0xe6a287, 0xe6a290, 0xe6a29c, + /* b4 */ 0xe6a1ad, 0xe6a1ae, 0xe6a2ae, 0xe6a2ab, + /* b8 */ 0xe6a596, 0xe6a1af, 0xe6a2a3, 0xe6a2ac, + /* bc */ 0xe6a2a9, 0xe6a1b5, 0xe6a1b4, 0xe6a2b2, + /* c0 */ 0xe6a28f, 0xe6a1b7, 0xe6a292, 0xe6a1bc, + /* c4 */ 0xe6a1ab, 0xe6a1b2, 0xe6a2aa, 0xe6a280, + /* c8 */ 0xe6a1b1, 0xe6a1be, 0xe6a29b, 0xe6a296, + /* cc */ 0xe6a28b, 0xe6a2a0, 0xe6a289, 0xe6a2a4, + /* d0 */ 0xe6a1b8, 0xe6a1bb, 0xe6a291, 0xe6a28c, + /* d4 */ 0xe6a28a, 0xe6a1bd, 0xe6acb6, 0xe6acb3, + /* d8 */ 0xe6acb7, 0xe6acb8, 0xe6ae91, 0xe6ae8f, + /* dc */ 0xe6ae8d, 0xe6ae8e, 0xe6ae8c, 0xe6b0aa, + /* e0 */ 0xe6b780, 0xe6b6ab, 0xe6b6b4, 0xe6b6b3, + /* e4 */ 0xe6b9b4, 0xe6b6ac, 0xe6b7a9, 0xe6b7a2, + /* e8 */ 0xe6b6b7, 0xe6b7b6, 0xe6b794, 0xe6b880, + /* ec */ 0xe6b788, 0xe6b7a0, 0xe6b79f, 0xe6b796, + /* f0 */ 0xe6b6be, 0xe6b7a5, 0xe6b79c, 0xe6b79d, + /* f4 */ 0xe6b79b, 0xe6b7b4, 0xe6b78a, 0xe6b6bd, + /* f8 */ 0xe6b7ad, 0xe6b7b0, 0xe6b6ba, 0xe6b795, + /* fc */ 0xe6b782, 0xe6b78f, 0xe6b789, + + /*** Two byte table, leaf: d6xx - offset 0x027e4 ***/ + + /* 40 */ 0xe6b790, 0xe6b7b2, 0xe6b793, 0xe6b7bd, + /* 44 */ 0xe6b797, 0xe6b78d, 0xe6b7a3, 0xe6b6bb, + /* 48 */ 0xe783ba, 0xe7848d, 0xe783b7, 0xe78497, + /* 4c */ 0xe783b4, 0xe7848c, 0xe783b0, 0xe78484, + /* 50 */ 0xe783b3, 0xe78490, 0xe783bc, 0xe783bf, + /* 54 */ 0xe78486, 0xe78493, 0xe78480, 0xe783b8, + /* 58 */ 0xe783b6, 0xe7848b, 0xe78482, 0xe7848e, + /* 5c */ 0xe789be, 0xe789bb, 0xe789bc, 0xe789bf, + /* 60 */ 0xe78c9d, 0xe78c97, 0xe78c87, 0xe78c91, + /* 64 */ 0xe78c98, 0xe78c8a, 0xe78c88, 0xe78bbf, + /* 68 */ 0xe78c8f, 0xe78c9e, 0xe78e88, 0xe78fb6, + /* 6c */ 0xe78fb8, 0xe78fb5, 0xe79084, 0xe79081, + /* 70 */ 0xe78fbd, 0xe79087, 0xe79080, 0xe78fba, + /* 74 */ 0xe78fbc, 0xe78fbf, 0xe7908c, 0xe7908b, + /* 78 */ 0xe78fb4, 0xe79088, 0xe795a4, 0xe795a3, + /* 7c */ 0xe7978e, 0xe79792, 0xe7978f, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7978b, 0xe7978c, 0xe79791, + /* a4 */ 0xe79790, 0xe79a8f, 0xe79a89, 0xe79b93, + /* a8 */ 0xe79cb9, 0xe79caf, 0xe79cad, 0xe79cb1, + /* ac */ 0xe79cb2, 0xe79cb4, 0xe79cb3, 0xe79cbd, + /* b0 */ 0xe79ca5, 0xe79cbb, 0xe79cb5, 0xe7a188, + /* b4 */ 0xe7a192, 0xe7a189, 0xe7a18d, 0xe7a18a, + /* b8 */ 0xe7a18c, 0xe7a0a6, 0xe7a185, 0xe7a190, + /* bc */ 0xe7a5a4, 0xe7a5a7, 0xe7a5a9, 0xe7a5aa, + /* c0 */ 0xe7a5a3, 0xe7a5ab, 0xe7a5a1, 0xe7a6bb, + /* c4 */ 0xe7a7ba, 0xe7a7b8, 0xe7a7b6, 0xe7a7b7, + /* c8 */ 0xe7aa8f, 0xe7aa94, 0xe7aa90, 0xe7acb5, + /* cc */ 0xe7ad87, 0xe7acb4, 0xe7aca5, 0xe7acb0, + /* d0 */ 0xe7aca2, 0xe7aca4, 0xe7acb3, 0xe7ac98, + /* d4 */ 0xe7acaa, 0xe7ac9d, 0xe7acb1, 0xe7acab, + /* d8 */ 0xe7acad, 0xe7acaf, 0xe7acb2, 0xe7acb8, + /* dc */ 0xe7ac9a, 0xe7aca3, 0xe7b294, 0xe7b298, + /* e0 */ 0xe7b296, 0xe7b2a3, 0xe7b4b5, 0xe7b4bd, + /* e4 */ 0xe7b4b8, 0xe7b4b6, 0xe7b4ba, 0xe7b585, + /* e8 */ 0xe7b4ac, 0xe7b4a9, 0xe7b581, 0xe7b587, + /* ec */ 0xe7b4be, 0xe7b4bf, 0xe7b58a, 0xe7b4bb, + /* f0 */ 0xe7b4a8, 0xe7bda3, 0xe7be95, 0xe7be9c, + /* f4 */ 0xe7be9d, 0xe7be9b, 0xe7bf8a, 0xe7bf8b, + /* f8 */ 0xe7bf8d, 0xe7bf90, 0xe7bf91, 0xe7bf87, + /* fc */ 0xe7bf8f, 0xe7bf89, 0xe8809f, + + /*** Two byte table, leaf: d7xx - offset 0x028a3 ***/ + + /* 40 */ 0xe8809e, 0xe8809b, 0xe88187, 0xe88183, + /* 44 */ 0xe88188, 0xe88498, 0xe884a5, 0xe88499, + /* 48 */ 0xe8849b, 0xe884ad, 0xe8849f, 0xe884ac, + /* 4c */ 0xe8849e, 0xe884a1, 0xe88495, 0xe884a7, + /* 50 */ 0xe8849d, 0xe884a2, 0xe88891, 0xe888b8, + /* 54 */ 0xe888b3, 0xe888ba, 0xe888b4, 0xe888b2, + /* 58 */ 0xe889b4, 0xe88e90, 0xe88ea3, 0xe88ea8, + /* 5c */ 0xe88e8d, 0xe88dba, 0xe88db3, 0xe88ea4, + /* 60 */ 0xe88db4, 0xe88e8f, 0xe88e81, 0xe88e95, + /* 64 */ 0xe88e99, 0xe88db5, 0xe88e94, 0xe88ea9, + /* 68 */ 0xe88dbd, 0xe88e83, 0xe88e8c, 0xe88e9d, + /* 6c */ 0xe88e9b, 0xe88eaa, 0xe88e8b, 0xe88dbe, + /* 70 */ 0xe88ea5, 0xe88eaf, 0xe88e88, 0xe88e97, + /* 74 */ 0xe88eb0, 0xe88dbf, 0xe88ea6, 0xe88e87, + /* 78 */ 0xe88eae, 0xe88db6, 0xe88e9a, 0xe89999, + /* 7c */ 0xe89996, 0xe89abf, 0xe89ab7, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe89b82, 0xe89b81, 0xe89b85, + /* a4 */ 0xe89aba, 0xe89ab0, 0xe89b88, 0xe89ab9, + /* a8 */ 0xe89ab3, 0xe89ab8, 0xe89b8c, 0xe89ab4, + /* ac */ 0xe89abb, 0xe89abc, 0xe89b83, 0xe89abd, + /* b0 */ 0xe89abe, 0xe8a192, 0xe8a289, 0xe8a295, + /* b4 */ 0xe8a2a8, 0xe8a2a2, 0xe8a2aa, 0xe8a29a, + /* b8 */ 0xe8a291, 0xe8a2a1, 0xe8a29f, 0xe8a298, + /* bc */ 0xe8a2a7, 0xe8a299, 0xe8a29b, 0xe8a297, + /* c0 */ 0xe8a2a4, 0xe8a2ac, 0xe8a28c, 0xe8a293, + /* c4 */ 0xe8a28e, 0xe8a682, 0xe8a796, 0xe8a799, + /* c8 */ 0xe8a795, 0xe8a8b0, 0xe8a8a7, 0xe8a8ac, + /* cc */ 0xe8a89e, 0xe8b0b9, 0xe8b0bb, 0xe8b19c, + /* d0 */ 0xe8b19d, 0xe8b1bd, 0xe8b2a5, 0xe8b5bd, + /* d4 */ 0xe8b5bb, 0xe8b5b9, 0xe8b6bc, 0xe8b782, + /* d8 */ 0xe8b6b9, 0xe8b6bf, 0xe8b781, 0xe8bb98, + /* dc */ 0xe8bb9e, 0xe8bb9d, 0xe8bb9c, 0xe8bb97, + /* e0 */ 0xe8bba0, 0xe8bba1, 0xe980a4, 0xe9808b, + /* e4 */ 0xe98091, 0xe9809c, 0xe9808c, 0xe980a1, + /* e8 */ 0xe983af, 0xe983aa, 0xe983b0, 0xe983b4, + /* ec */ 0xe983b2, 0xe983b3, 0xe98394, 0xe983ab, + /* f0 */ 0xe983ac, 0xe983a9, 0xe98596, 0xe98598, + /* f4 */ 0xe9859a, 0xe98593, 0xe98595, 0xe987ac, + /* f8 */ 0xe987b4, 0xe987b1, 0xe987b3, 0xe987b8, + /* fc */ 0xe987a4, 0xe987b9, 0xe987aa, + + /*** Two byte table, leaf: d8xx - offset 0x02962 ***/ + + /* 40 */ 0xe987ab, 0xe987b7, 0xe987a8, 0xe987ae, + /* 44 */ 0xe995ba, 0xe99686, 0xe99688, 0xe999bc, + /* 48 */ 0xe999ad, 0xe999ab, 0xe999b1, 0xe999af, + /* 4c */ 0xe99abf, 0xe99daa, 0xe9a084, 0xe9a3a5, + /* 50 */ 0xe9a697, 0xe5829b, 0xe58295, 0xe58294, + /* 54 */ 0xe5829e, 0xe5828b, 0xe582a3, 0xe58283, + /* 58 */ 0xe5828c, 0xe5828e, 0xe5829d, 0xe581a8, + /* 5c */ 0xe5829c, 0xe58292, 0xe58282, 0xe58287, + /* 60 */ 0xe5859f, 0xe58794, 0xe58c92, 0xe58c91, + /* 64 */ 0xe58ea4, 0xe58ea7, 0xe59691, 0xe596a8, + /* 68 */ 0xe596a5, 0xe596ad, 0xe595b7, 0xe59985, + /* 6c */ 0xe596a2, 0xe59693, 0xe59688, 0xe5968f, + /* 70 */ 0xe596b5, 0xe59681, 0xe596a3, 0xe59692, + /* 74 */ 0xe596a4, 0xe595bd, 0xe5968c, 0xe596a6, + /* 78 */ 0xe595bf, 0xe59695, 0xe596a1, 0xe5968e, + /* 7c */ 0xe59c8c, 0xe5a0a9, 0xe5a0b7, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5a099, 0xe5a09e, 0xe5a0a7, + /* a4 */ 0xe5a0a3, 0xe5a0a8, 0xe59fb5, 0xe5a188, + /* a8 */ 0xe5a0a5, 0xe5a09c, 0xe5a09b, 0xe5a0b3, + /* ac */ 0xe5a0bf, 0xe5a0b6, 0xe5a0ae, 0xe5a0b9, + /* b0 */ 0xe5a0b8, 0xe5a0ad, 0xe5a0ac, 0xe5a0bb, + /* b4 */ 0xe5a5a1, 0xe5aaaf, 0xe5aa94, 0xe5aa9f, + /* b8 */ 0xe5a9ba, 0xe5aaa2, 0xe5aa9e, 0xe5a9b8, + /* bc */ 0xe5aaa6, 0xe5a9bc, 0xe5aaa5, 0xe5aaac, + /* c0 */ 0xe5aa95, 0xe5aaae, 0xe5a8b7, 0xe5aa84, + /* c4 */ 0xe5aa8a, 0xe5aa97, 0xe5aa83, 0xe5aa8b, + /* c8 */ 0xe5aaa9, 0xe5a9bb, 0xe5a9bd, 0xe5aa8c, + /* cc */ 0xe5aa9c, 0xe5aa8f, 0xe5aa93, 0xe5aa9d, + /* d0 */ 0xe5afaa, 0xe5af8d, 0xe5af8b, 0xe5af94, + /* d4 */ 0xe5af91, 0xe5af8a, 0xe5af8e, 0xe5b08c, + /* d8 */ 0xe5b0b0, 0xe5b4b7, 0xe5b583, 0xe5b5ab, + /* dc */ 0xe5b581, 0xe5b58b, 0xe5b4bf, 0xe5b4b5, + /* e0 */ 0xe5b591, 0xe5b58e, 0xe5b595, 0xe5b4b3, + /* e4 */ 0xe5b4ba, 0xe5b592, 0xe5b4bd, 0xe5b4b1, + /* e8 */ 0xe5b599, 0xe5b582, 0xe5b4b9, 0xe5b589, + /* ec */ 0xe5b4b8, 0xe5b4bc, 0xe5b4b2, 0xe5b4b6, + /* f0 */ 0xe5b580, 0xe5b585, 0xe5b984, 0xe5b981, + /* f4 */ 0xe5bd98, 0xe5bea6, 0xe5bea5, 0xe5beab, + /* f8 */ 0xe68389, 0xe682b9, 0xe6838c, 0xe683a2, + /* fc */ 0xe6838e, 0xe68384, 0xe68494, + + /*** Two byte table, leaf: d9xx - offset 0x02a21 ***/ + + /* 40 */ 0xe683b2, 0xe6848a, 0xe68496, 0xe68485, + /* 44 */ 0xe683b5, 0xe68493, 0xe683b8, 0xe683bc, + /* 48 */ 0xe683be, 0xe68381, 0xe68483, 0xe68498, + /* 4c */ 0xe6849d, 0xe68490, 0xe683bf, 0xe68484, + /* 50 */ 0xe6848b, 0xe6898a, 0xe68e94, 0xe68eb1, + /* 54 */ 0xe68eb0, 0xe68f8e, 0xe68fa5, 0xe68fa8, + /* 58 */ 0xe68faf, 0xe68f83, 0xe6929d, 0xe68fb3, + /* 5c */ 0xe68f8a, 0xe68fa0, 0xe68fb6, 0xe68f95, + /* 60 */ 0xe68fb2, 0xe68fb5, 0xe691a1, 0xe68f9f, + /* 64 */ 0xe68ebe, 0xe68f9d, 0xe68f9c, 0xe68f84, + /* 68 */ 0xe68f98, 0xe68f93, 0xe68f82, 0xe68f87, + /* 6c */ 0xe68f8c, 0xe68f8b, 0xe68f88, 0xe68fb0, + /* 70 */ 0xe68f97, 0xe68f99, 0xe694b2, 0xe695a7, + /* 74 */ 0xe695aa, 0xe695a4, 0xe6959c, 0xe695a8, + /* 78 */ 0xe695a5, 0xe6968c, 0xe6969d, 0xe6969e, + /* 7c */ 0xe696ae, 0xe69790, 0xe69792, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe699bc, 0xe699ac, 0xe699bb, + /* a4 */ 0xe69a80, 0xe699b1, 0xe699b9, 0xe699aa, + /* a8 */ 0xe699b2, 0xe69c81, 0xe6a48c, 0xe6a393, + /* ac */ 0xe6a484, 0xe6a39c, 0xe6a4aa, 0xe6a3ac, + /* b0 */ 0xe6a3aa, 0xe6a3b1, 0xe6a48f, 0xe6a396, + /* b4 */ 0xe6a3b7, 0xe6a3ab, 0xe6a3a4, 0xe6a3b6, + /* b8 */ 0xe6a493, 0xe6a490, 0xe6a3b3, 0xe6a3a1, + /* bc */ 0xe6a487, 0xe6a38c, 0xe6a488, 0xe6a5b0, + /* c0 */ 0xe6a2b4, 0xe6a491, 0xe6a3af, 0xe6a386, + /* c4 */ 0xe6a494, 0xe6a3b8, 0xe6a390, 0xe6a3bd, + /* c8 */ 0xe6a3bc, 0xe6a3a8, 0xe6a48b, 0xe6a48a, + /* cc */ 0xe6a497, 0xe6a38e, 0xe6a388, 0xe6a39d, + /* d0 */ 0xe6a39e, 0xe6a3a6, 0xe6a3b4, 0xe6a391, + /* d4 */ 0xe6a486, 0xe6a394, 0xe6a3a9, 0xe6a495, + /* d8 */ 0xe6a4a5, 0xe6a387, 0xe6acb9, 0xe6acbb, + /* dc */ 0xe6acbf, 0xe6acbc, 0xe6ae94, 0xe6ae97, + /* e0 */ 0xe6ae99, 0xe6ae95, 0xe6aebd, 0xe6afb0, + /* e4 */ 0xe6afb2, 0xe6afb3, 0xe6b0b0, 0xe6b7bc, + /* e8 */ 0xe6b986, 0xe6b987, 0xe6b89f, 0xe6b989, + /* ec */ 0xe6ba88, 0xe6b8bc, 0xe6b8bd, 0xe6b985, + /* f0 */ 0xe6b9a2, 0xe6b8ab, 0xe6b8bf, 0xe6b981, + /* f4 */ 0xe6b99d, 0xe6b9b3, 0xe6b89c, 0xe6b8b3, + /* f8 */ 0xe6b98b, 0xe6b980, 0xe6b991, 0xe6b8bb, + /* fc */ 0xe6b883, 0xe6b8ae, 0xe6b99e, + + /*** Two byte table, leaf: daxx - offset 0x02ae0 ***/ + + /* 40 */ 0xe6b9a8, 0xe6b99c, 0xe6b9a1, 0xe6b8b1, + /* 44 */ 0xe6b8a8, 0xe6b9a0, 0xe6b9b1, 0xe6b9ab, + /* 48 */ 0xe6b8b9, 0xe6b8a2, 0xe6b8b0, 0xe6b993, + /* 4c */ 0xe6b9a5, 0xe6b8a7, 0xe6b9b8, 0xe6b9a4, + /* 50 */ 0xe6b9b7, 0xe6b995, 0xe6b9b9, 0xe6b992, + /* 54 */ 0xe6b9a6, 0xe6b8b5, 0xe6b8b6, 0xe6b99a, + /* 58 */ 0xe784a0, 0xe7849e, 0xe784af, 0xe783bb, + /* 5c */ 0xe784ae, 0xe784b1, 0xe784a3, 0xe784a5, + /* 60 */ 0xe784a2, 0xe784b2, 0xe7849f, 0xe784a8, + /* 64 */ 0xe784ba, 0xe7849b, 0xe7898b, 0xe7899a, + /* 68 */ 0xe78a88, 0xe78a89, 0xe78a86, 0xe78a85, + /* 6c */ 0xe78a8b, 0xe78c92, 0xe78c8b, 0xe78cb0, + /* 70 */ 0xe78ca2, 0xe78cb1, 0xe78cb3, 0xe78ca7, + /* 74 */ 0xe78cb2, 0xe78cad, 0xe78ca6, 0xe78ca3, + /* 78 */ 0xe78cb5, 0xe78c8c, 0xe790ae, 0xe790ac, + /* 7c */ 0xe790b0, 0xe790ab, 0xe79096, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7909a, 0xe790a1, 0xe790ad, + /* a4 */ 0xe790b1, 0xe790a4, 0xe790a3, 0xe7909d, + /* a8 */ 0xe790a9, 0xe790a0, 0xe790b2, 0xe793bb, + /* ac */ 0xe794af, 0xe795af, 0xe795ac, 0xe797a7, + /* b0 */ 0xe7979a, 0xe797a1, 0xe797a6, 0xe7979d, + /* b4 */ 0xe7979f, 0xe797a4, 0xe79797, 0xe79a95, + /* b8 */ 0xe79a92, 0xe79b9a, 0xe79d86, 0xe79d87, + /* bc */ 0xe79d84, 0xe79d8d, 0xe79d85, 0xe79d8a, + /* c0 */ 0xe79d8e, 0xe79d8b, 0xe79d8c, 0xe79f9e, + /* c4 */ 0xe79fac, 0xe7a1a0, 0xe7a1a4, 0xe7a1a5, + /* c8 */ 0xe7a19c, 0xe7a1ad, 0xe7a1b1, 0xe7a1aa, + /* cc */ 0xe7a1ae, 0xe7a1b0, 0xe7a1a9, 0xe7a1a8, + /* d0 */ 0xe7a19e, 0xe7a1a2, 0xe7a5b4, 0xe7a5b3, + /* d4 */ 0xe7a5b2, 0xe7a5b0, 0xe7a882, 0xe7a88a, + /* d8 */ 0xe7a883, 0xe7a88c, 0xe7a884, 0xe7aa99, + /* dc */ 0xe7aba6, 0xe7aba4, 0xe7ad8a, 0xe7acbb, + /* e0 */ 0xe7ad84, 0xe7ad88, 0xe7ad8c, 0xe7ad8e, + /* e4 */ 0xe7ad80, 0xe7ad98, 0xe7ad85, 0xe7b2a2, + /* e8 */ 0xe7b29e, 0xe7b2a8, 0xe7b2a1, 0xe7b598, + /* ec */ 0xe7b5af, 0xe7b5a3, 0xe7b593, 0xe7b596, + /* f0 */ 0xe7b5a7, 0xe7b5aa, 0xe7b58f, 0xe7b5ad, + /* f4 */ 0xe7b59c, 0xe7b5ab, 0xe7b592, 0xe7b594, + /* f8 */ 0xe7b5a9, 0xe7b591, 0xe7b59f, 0xe7b58e, + /* fc */ 0xe7bcbe, 0xe7bcbf, 0xe7bda5, + + /*** Two byte table, leaf: dbxx - offset 0x02b9f ***/ + + /* 40 */ 0xe7bda6, 0xe7bea2, 0xe7bea0, 0xe7bea1, + /* 44 */ 0xe7bf97, 0xe88191, 0xe8818f, 0xe88190, + /* 48 */ 0xe883be, 0xe88394, 0xe88583, 0xe8858a, + /* 4c */ 0xe88592, 0xe8858f, 0xe88587, 0xe884bd, + /* 50 */ 0xe8858d, 0xe884ba, 0xe887a6, 0xe887ae, + /* 54 */ 0xe887b7, 0xe887b8, 0xe887b9, 0xe88884, + /* 58 */ 0xe888bc, 0xe888bd, 0xe888bf, 0xe889b5, + /* 5c */ 0xe88cbb, 0xe88f8f, 0xe88fb9, 0xe890a3, + /* 60 */ 0xe88f80, 0xe88fa8, 0xe89092, 0xe88fa7, + /* 64 */ 0xe88fa4, 0xe88fbc, 0xe88fb6, 0xe89090, + /* 68 */ 0xe88f86, 0xe88f88, 0xe88fab, 0xe88fa3, + /* 6c */ 0xe88ebf, 0xe89081, 0xe88f9d, 0xe88fa5, + /* 70 */ 0xe88f98, 0xe88fbf, 0xe88fa1, 0xe88f8b, + /* 74 */ 0xe88f8e, 0xe88f96, 0xe88fb5, 0xe88f89, + /* 78 */ 0xe89089, 0xe8908f, 0xe88f9e, 0xe89091, + /* 7c */ 0xe89086, 0xe88f82, 0xe88fb3, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88f95, 0xe88fba, 0xe88f87, + /* a4 */ 0xe88f91, 0xe88faa, 0xe89093, 0xe88f83, + /* a8 */ 0xe88fac, 0xe88fae, 0xe88f84, 0xe88fbb, + /* ac */ 0xe88f97, 0xe88fa2, 0xe8909b, 0xe88f9b, + /* b0 */ 0xe88fbe, 0xe89b98, 0xe89ba2, 0xe89ba6, + /* b4 */ 0xe89b93, 0xe89ba3, 0xe89b9a, 0xe89baa, + /* b8 */ 0xe89b9d, 0xe89bab, 0xe89b9c, 0xe89bac, + /* bc */ 0xe89ba9, 0xe89b97, 0xe89ba8, 0xe89b91, + /* c0 */ 0xe8a188, 0xe8a196, 0xe8a195, 0xe8a2ba, + /* c4 */ 0xe8a397, 0xe8a2b9, 0xe8a2b8, 0xe8a380, + /* c8 */ 0xe8a2be, 0xe8a2b6, 0xe8a2bc, 0xe8a2b7, + /* cc */ 0xe8a2bd, 0xe8a2b2, 0xe8a481, 0xe8a389, + /* d0 */ 0xe8a695, 0xe8a698, 0xe8a697, 0xe8a79d, + /* d4 */ 0xe8a79a, 0xe8a79b, 0xe8a98e, 0xe8a98d, + /* d8 */ 0xe8a8b9, 0xe8a999, 0xe8a980, 0xe8a997, + /* dc */ 0xe8a998, 0xe8a984, 0xe8a985, 0xe8a992, + /* e0 */ 0xe8a988, 0xe8a991, 0xe8a98a, 0xe8a98c, + /* e4 */ 0xe8a98f, 0xe8b19f, 0xe8b281, 0xe8b280, + /* e8 */ 0xe8b2ba, 0xe8b2be, 0xe8b2b0, 0xe8b2b9, + /* ec */ 0xe8b2b5, 0xe8b684, 0xe8b680, 0xe8b689, + /* f0 */ 0xe8b798, 0xe8b793, 0xe8b78d, 0xe8b787, + /* f4 */ 0xe8b796, 0xe8b79c, 0xe8b78f, 0xe8b795, + /* f8 */ 0xe8b799, 0xe8b788, 0xe8b797, 0xe8b785, + /* fc */ 0xe8bbaf, 0xe8bbb7, 0xe8bbba, + + /*** Two byte table, leaf: dcxx - offset 0x02c5e ***/ + + /* 40 */ 0xe8bbb9, 0xe8bba6, 0xe8bbae, 0xe8bba5, + /* 44 */ 0xe8bbb5, 0xe8bba7, 0xe8bba8, 0xe8bbb6, + /* 48 */ 0xe8bbab, 0xe8bbb1, 0xe8bbac, 0xe8bbb4, + /* 4c */ 0xe8bba9, 0xe980ad, 0xe980b4, 0xe980af, + /* 50 */ 0xe98486, 0xe984ac, 0xe98484, 0xe983bf, + /* 54 */ 0xe983bc, 0xe98488, 0xe983b9, 0xe983bb, + /* 58 */ 0xe98481, 0xe98480, 0xe98487, 0xe98485, + /* 5c */ 0xe98483, 0xe985a1, 0xe985a4, 0xe9859f, + /* 60 */ 0xe985a2, 0xe985a0, 0xe98881, 0xe9888a, + /* 64 */ 0xe988a5, 0xe98883, 0xe9889a, 0xe988a6, + /* 68 */ 0xe9888f, 0xe9888c, 0xe98880, 0xe98892, + /* 6c */ 0xe987bf, 0xe987bd, 0xe98886, 0xe98884, + /* 70 */ 0xe988a7, 0xe98882, 0xe9889c, 0xe988a4, + /* 74 */ 0xe98899, 0xe98897, 0xe98885, 0xe98896, + /* 78 */ 0xe995bb, 0xe9968d, 0xe9968c, 0xe99690, + /* 7c */ 0xe99a87, 0xe999be, 0xe99a88, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe99a89, 0xe99a83, 0xe99a80, + /* a4 */ 0xe99b82, 0xe99b88, 0xe99b83, 0xe99bb1, + /* a8 */ 0xe99bb0, 0xe99dac, 0xe99db0, 0xe99dae, + /* ac */ 0xe9a087, 0xe9a2a9, 0xe9a3ab, 0xe9b3a6, + /* b0 */ 0xe9bbb9, 0xe4ba83, 0xe4ba84, 0xe4bab6, + /* b4 */ 0xe582bd, 0xe582bf, 0xe58386, 0xe582ae, + /* b8 */ 0xe58384, 0xe5838a, 0xe582b4, 0xe58388, + /* bc */ 0xe58382, 0xe582b0, 0xe58381, 0xe582ba, + /* c0 */ 0xe582b1, 0xe5838b, 0xe58389, 0xe582b6, + /* c4 */ 0xe582b8, 0xe58797, 0xe589ba, 0xe589b8, + /* c8 */ 0xe589bb, 0xe589bc, 0xe59783, 0xe5979b, + /* cc */ 0xe5978c, 0xe59790, 0xe5978b, 0xe5978a, + /* d0 */ 0xe5979d, 0xe59780, 0xe59794, 0xe59784, + /* d4 */ 0xe597a9, 0xe596bf, 0xe59792, 0xe5968d, + /* d8 */ 0xe5978f, 0xe59795, 0xe597a2, 0xe59796, + /* dc */ 0xe59788, 0xe597b2, 0xe5978d, 0xe59799, + /* e0 */ 0xe59782, 0xe59c94, 0xe5a193, 0xe5a1a8, + /* e4 */ 0xe5a1a4, 0xe5a18f, 0xe5a18d, 0xe5a189, + /* e8 */ 0xe5a1af, 0xe5a195, 0xe5a18e, 0xe5a19d, + /* ec */ 0xe5a199, 0xe5a1a5, 0xe5a19b, 0xe5a0bd, + /* f0 */ 0xe5a1a3, 0xe5a1b1, 0xe5a3bc, 0xe5ab87, + /* f4 */ 0xe5ab84, 0xe5ab8b, 0xe5aaba, 0xe5aab8, + /* f8 */ 0xe5aab1, 0xe5aab5, 0xe5aab0, 0xe5aabf, + /* fc */ 0xe5ab88, 0xe5aabb, 0xe5ab86, + + /*** Two byte table, leaf: ddxx - offset 0x02d1d ***/ + + /* 40 */ 0xe5aab7, 0xe5ab80, 0xe5ab8a, 0xe5aab4, + /* 44 */ 0xe5aab6, 0xe5ab8d, 0xe5aab9, 0xe5aa90, + /* 48 */ 0xe5af96, 0xe5af98, 0xe5af99, 0xe5b09f, + /* 4c */ 0xe5b0b3, 0xe5b5b1, 0xe5b5a3, 0xe5b58a, + /* 50 */ 0xe5b5a5, 0xe5b5b2, 0xe5b5ac, 0xe5b59e, + /* 54 */ 0xe5b5a8, 0xe5b5a7, 0xe5b5a2, 0xe5b7b0, + /* 58 */ 0xe5b98f, 0xe5b98e, 0xe5b98a, 0xe5b98d, + /* 5c */ 0xe5b98b, 0xe5bb85, 0xe5bb8c, 0xe5bb86, + /* 60 */ 0xe5bb8b, 0xe5bb87, 0xe5bd80, 0xe5beaf, + /* 64 */ 0xe5bead, 0xe683b7, 0xe68589, 0xe6858a, + /* 68 */ 0xe684ab, 0xe68585, 0xe684b6, 0xe684b2, + /* 6c */ 0xe684ae, 0xe68586, 0xe684af, 0xe6858f, + /* 70 */ 0xe684a9, 0xe68580, 0xe688a0, 0xe985a8, + /* 74 */ 0xe688a3, 0xe688a5, 0xe688a4, 0xe68f85, + /* 78 */ 0xe68fb1, 0xe68fab, 0xe69090, 0xe69092, + /* 7c */ 0xe69089, 0xe690a0, 0xe690a4, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe690b3, 0xe69183, 0xe6909f, + /* a4 */ 0xe69095, 0xe69098, 0xe690b9, 0xe690b7, + /* a8 */ 0xe690a2, 0xe690a3, 0xe6908c, 0xe690a6, + /* ac */ 0xe690b0, 0xe690a8, 0xe69181, 0xe690b5, + /* b0 */ 0xe690af, 0xe6908a, 0xe6909a, 0xe69180, + /* b4 */ 0xe690a5, 0xe690a7, 0xe6908b, 0xe68fa7, + /* b8 */ 0xe6909b, 0xe690ae, 0xe690a1, 0xe6908e, + /* bc */ 0xe695af, 0xe69692, 0xe69793, 0xe69a86, + /* c0 */ 0xe69a8c, 0xe69a95, 0xe69a90, 0xe69a8b, + /* c4 */ 0xe69a8a, 0xe69a99, 0xe69a94, 0xe699b8, + /* c8 */ 0xe69ca0, 0xe6a5a6, 0xe6a59f, 0xe6a4b8, + /* cc */ 0xe6a58e, 0xe6a5a2, 0xe6a5b1, 0xe6a4bf, + /* d0 */ 0xe6a585, 0xe6a5aa, 0xe6a4b9, 0xe6a582, + /* d4 */ 0xe6a597, 0xe6a599, 0xe6a5ba, 0xe6a588, + /* d8 */ 0xe6a589, 0xe6a4b5, 0xe6a5ac, 0xe6a4b3, + /* dc */ 0xe6a4bd, 0xe6a5a5, 0xe6a3b0, 0xe6a5b8, + /* e0 */ 0xe6a4b4, 0xe6a5a9, 0xe6a580, 0xe6a5af, + /* e4 */ 0xe6a584, 0xe6a5b6, 0xe6a598, 0xe6a581, + /* e8 */ 0xe6a5b4, 0xe6a58c, 0xe6a4bb, 0xe6a58b, + /* ec */ 0xe6a4b7, 0xe6a59c, 0xe6a58f, 0xe6a591, + /* f0 */ 0xe6a4b2, 0xe6a592, 0xe6a4af, 0xe6a5bb, + /* f4 */ 0xe6a4bc, 0xe6ad86, 0xe6ad85, 0xe6ad83, + /* f8 */ 0xe6ad82, 0xe6ad88, 0xe6ad81, 0xe6ae9b, + /* fc */ 0xefa88d, 0xe6afbb, 0xe6afbc, + + /*** Two byte table, leaf: dexx - offset 0x02ddc ***/ + + /* 40 */ 0xe6afb9, 0xe6afb7, 0xe6afb8, 0xe6ba9b, + /* 44 */ 0xe6bb96, 0xe6bb88, 0xe6ba8f, 0xe6bb80, + /* 48 */ 0xe6ba9f, 0xe6ba93, 0xe6ba94, 0xe6baa0, + /* 4c */ 0xe6bab1, 0xe6bab9, 0xe6bb86, 0xe6bb92, + /* 50 */ 0xe6babd, 0xe6bb81, 0xe6ba9e, 0xe6bb89, + /* 54 */ 0xe6bab7, 0xe6bab0, 0xe6bb8d, 0xe6baa6, + /* 58 */ 0xe6bb8f, 0xe6bab2, 0xe6babe, 0xe6bb83, + /* 5c */ 0xe6bb9c, 0xe6bb98, 0xe6ba99, 0xe6ba92, + /* 60 */ 0xe6ba8e, 0xe6ba8d, 0xe6baa4, 0xe6baa1, + /* 64 */ 0xe6babf, 0xe6bab3, 0xe6bb90, 0xe6bb8a, + /* 68 */ 0xe6ba97, 0xe6baae, 0xe6baa3, 0xe78587, + /* 6c */ 0xe78594, 0xe78592, 0xe785a3, 0xe785a0, + /* 70 */ 0xe78581, 0xe7859d, 0xe785a2, 0xe785b2, + /* 74 */ 0xe785b8, 0xe785aa, 0xe785a1, 0xe78582, + /* 78 */ 0xe78598, 0xe78583, 0xe7858b, 0xe785b0, + /* 7c */ 0xe7859f, 0xe78590, 0xe78593, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe78584, 0xe7858d, 0xe7859a, + /* a4 */ 0xe7898f, 0xe78a8d, 0xe78a8c, 0xe78a91, + /* a8 */ 0xe78a90, 0xe78a8e, 0xe78cbc, 0xe78d82, + /* ac */ 0xe78cbb, 0xe78cba, 0xe78d80, 0xe78d8a, + /* b0 */ 0xe78d89, 0xe79184, 0xe7918a, 0xe7918b, + /* b4 */ 0xe79192, 0xe79191, 0xe79197, 0xe79180, + /* b8 */ 0xe7918f, 0xe79190, 0xe7918e, 0xe79182, + /* bc */ 0xe79186, 0xe7918d, 0xe79194, 0xe793a1, + /* c0 */ 0xe793bf, 0xe793be, 0xe793bd, 0xe7949d, + /* c4 */ 0xe795b9, 0xe795b7, 0xe6a683, 0xe797af, + /* c8 */ 0xe7988f, 0xe79883, 0xe797b7, 0xe797be, + /* cc */ 0xe797bc, 0xe797b9, 0xe797b8, 0xe79890, + /* d0 */ 0xe797bb, 0xe797b6, 0xe797ad, 0xe797b5, + /* d4 */ 0xe797bd, 0xe79a99, 0xe79ab5, 0xe79b9d, + /* d8 */ 0xe79d95, 0xe79d9f, 0xe79da0, 0xe79d92, + /* dc */ 0xe79d96, 0xe79d9a, 0xe79da9, 0xe79da7, + /* e0 */ 0xe79d94, 0xe79d99, 0xe79dad, 0xe79fa0, + /* e4 */ 0xe7a287, 0xe7a29a, 0xe7a294, 0xe7a28f, + /* e8 */ 0xe7a284, 0xe7a295, 0xe7a285, 0xe7a286, + /* ec */ 0xe7a2a1, 0xe7a283, 0xe7a1b9, 0xe7a299, + /* f0 */ 0xe7a280, 0xe7a296, 0xe7a1bb, 0xe7a5bc, + /* f4 */ 0xe7a682, 0xe7a5bd, 0xe7a5b9, 0xe7a891, + /* f8 */ 0xe7a898, 0xe7a899, 0xe7a892, 0xe7a897, + /* fc */ 0xe7a895, 0xe7a8a2, 0xe7a893, + + /*** Two byte table, leaf: dfxx - offset 0x02e9b ***/ + + /* 40 */ 0xe7a89b, 0xe7a890, 0xe7aaa3, 0xe7aaa2, + /* 44 */ 0xe7aa9e, 0xe7abab, 0xe7ada6, 0xe7ada4, + /* 48 */ 0xe7adad, 0xe7adb4, 0xe7ada9, 0xe7adb2, + /* 4c */ 0xe7ada5, 0xe7adb3, 0xe7adb1, 0xe7adb0, + /* 50 */ 0xe7ada1, 0xe7adb8, 0xe7adb6, 0xe7ada3, + /* 54 */ 0xe7b2b2, 0xe7b2b4, 0xe7b2af, 0xe7b688, + /* 58 */ 0xe7b686, 0xe7b680, 0xe7b68d, 0xe7b5bf, + /* 5c */ 0xe7b685, 0xe7b5ba, 0xe7b68e, 0xe7b5bb, + /* 60 */ 0xe7b683, 0xe7b5bc, 0xe7b68c, 0xe7b694, + /* 64 */ 0xe7b684, 0xe7b5bd, 0xe7b692, 0xe7bdad, + /* 68 */ 0xe7bdab, 0xe7bda7, 0xe7bda8, 0xe7bdac, + /* 6c */ 0xe7bea6, 0xe7bea5, 0xe7bea7, 0xe7bf9b, + /* 70 */ 0xe7bf9c, 0xe880a1, 0xe885a4, 0xe885a0, + /* 74 */ 0xe885b7, 0xe8859c, 0xe885a9, 0xe8859b, + /* 78 */ 0xe885a2, 0xe885b2, 0xe69ca1, 0xe8859e, + /* 7c */ 0xe885b6, 0xe885a7, 0xe885af, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88584, 0xe885a1, 0xe8889d, + /* a4 */ 0xe88989, 0xe88984, 0xe88980, 0xe88982, + /* a8 */ 0xe88985, 0xe893b1, 0xe890bf, 0xe89196, + /* ac */ 0xe891b6, 0xe891b9, 0xe8928f, 0xe8928d, + /* b0 */ 0xe891a5, 0xe89191, 0xe89180, 0xe89286, + /* b4 */ 0xe891a7, 0xe890b0, 0xe8918d, 0xe891bd, + /* b8 */ 0xe8919a, 0xe89199, 0xe891b4, 0xe891b3, + /* bc */ 0xe8919d, 0xe89487, 0xe8919e, 0xe890b7, + /* c0 */ 0xe890ba, 0xe890b4, 0xe891ba, 0xe89183, + /* c4 */ 0xe891b8, 0xe890b2, 0xe89185, 0xe890a9, + /* c8 */ 0xe88f99, 0xe8918b, 0xe890af, 0xe89182, + /* cc */ 0xe890ad, 0xe8919f, 0xe891b0, 0xe890b9, + /* d0 */ 0xe8918e, 0xe8918c, 0xe89192, 0xe891af, + /* d4 */ 0xe89385, 0xe8928e, 0xe890bb, 0xe89187, + /* d8 */ 0xe890b6, 0xe890b3, 0xe891a8, 0xe891be, + /* dc */ 0xe89184, 0xe890ab, 0xe891a0, 0xe89194, + /* e0 */ 0xe891ae, 0xe89190, 0xe89c8b, 0xe89c84, + /* e4 */ 0xe89bb7, 0xe89c8c, 0xe89bba, 0xe89b96, + /* e8 */ 0xe89bb5, 0xe89d8d, 0xe89bb8, 0xe89c8e, + /* ec */ 0xe89c89, 0xe89c81, 0xe89bb6, 0xe89c8d, + /* f0 */ 0xe89c85, 0xe8a396, 0xe8a38b, 0xe8a38d, + /* f4 */ 0xe8a38e, 0xe8a39e, 0xe8a39b, 0xe8a39a, + /* f8 */ 0xe8a38c, 0xe8a390, 0xe8a685, 0xe8a69b, + /* fc */ 0xe8a79f, 0xe8a7a5, 0xe8a7a4, + + /*** Two byte table, leaf: e0xx - offset 0x02f5a ***/ + + /* 40 */ 0xe8a7a1, 0xe8a7a0, 0xe8a7a2, 0xe8a79c, + /* 44 */ 0xe8a7a6, 0xe8a9b6, 0xe8aa86, 0xe8a9bf, + /* 48 */ 0xe8a9a1, 0xe8a8bf, 0xe8a9b7, 0xe8aa82, + /* 4c */ 0xe8aa84, 0xe8a9b5, 0xe8aa83, 0xe8aa81, + /* 50 */ 0xe8a9b4, 0xe8a9ba, 0xe8b0bc, 0xe8b18b, + /* 54 */ 0xe8b18a, 0xe8b1a5, 0xe8b1a4, 0xe8b1a6, + /* 58 */ 0xe8b286, 0xe8b284, 0xe8b285, 0xe8b38c, + /* 5c */ 0xe8b5a8, 0xe8b5a9, 0xe8b691, 0xe8b68c, + /* 60 */ 0xe8b68e, 0xe8b68f, 0xe8b68d, 0xe8b693, + /* 64 */ 0xe8b694, 0xe8b690, 0xe8b692, 0xe8b7b0, + /* 68 */ 0xe8b7a0, 0xe8b7ac, 0xe8b7b1, 0xe8b7ae, + /* 6c */ 0xe8b790, 0xe8b7a9, 0xe8b7a3, 0xe8b7a2, + /* 70 */ 0xe8b7a7, 0xe8b7b2, 0xe8b7ab, 0xe8b7b4, + /* 74 */ 0xe8bc86, 0xe8bbbf, 0xe8bc81, 0xe8bc80, + /* 78 */ 0xe8bc85, 0xe8bc87, 0xe8bc88, 0xe8bc82, + /* 7c */ 0xe8bc8b, 0xe98192, 0xe980bf, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe98184, 0xe98189, 0xe980bd, + /* a4 */ 0xe98490, 0xe9848d, 0xe9848f, 0xe98491, + /* a8 */ 0xe98496, 0xe98494, 0xe9848b, 0xe9848e, + /* ac */ 0xe985ae, 0xe985af, 0xe98988, 0xe98992, + /* b0 */ 0xe988b0, 0xe988ba, 0xe989a6, 0xe988b3, + /* b4 */ 0xe989a5, 0xe9899e, 0xe98a83, 0xe988ae, + /* b8 */ 0xe9898a, 0xe98986, 0xe989ad, 0xe989ac, + /* bc */ 0xe9898f, 0xe989a0, 0xe989a7, 0xe989af, + /* c0 */ 0xe988b6, 0xe989a1, 0xe989b0, 0xe988b1, + /* c4 */ 0xe98994, 0xe989a3, 0xe98990, 0xe989b2, + /* c8 */ 0xe9898e, 0xe98993, 0xe9898c, 0xe98996, + /* cc */ 0xe988b2, 0xe9969f, 0xe9969c, 0xe9969e, + /* d0 */ 0xe9969b, 0xe99a92, 0xe99a93, 0xe99a91, + /* d4 */ 0xe99a97, 0xe99b8e, 0xe99bba, 0xe99bbd, + /* d8 */ 0xe99bb8, 0xe99bb5, 0xe99db3, 0xe99db7, + /* dc */ 0xe99db8, 0xe99db2, 0xe9a08f, 0xe9a08d, + /* e0 */ 0xe9a08e, 0xe9a2ac, 0xe9a3b6, 0xe9a3b9, + /* e4 */ 0xe9a6af, 0xe9a6b2, 0xe9a6b0, 0xe9a6b5, + /* e8 */ 0xe9aaad, 0xe9aaab, 0xe9ad9b, 0xe9b3aa, + /* ec */ 0xe9b3ad, 0xe9b3a7, 0xe9ba80, 0xe9bbbd, + /* f0 */ 0xe583a6, 0xe58394, 0xe58397, 0xe583a8, + /* f4 */ 0xe583b3, 0xe5839b, 0xe583aa, 0xe5839d, + /* f8 */ 0xe583a4, 0xe58393, 0xe583ac, 0xe583b0, + /* fc */ 0xe583af, 0xe583a3, 0xe583a0, + + /*** Two byte table, leaf: e1xx - offset 0x03019 ***/ + + /* 40 */ 0xe58798, 0xe58a80, 0xe58a81, 0xe58ba9, + /* 44 */ 0xe58bab, 0xe58cb0, 0xe58eac, 0xe598a7, + /* 48 */ 0xe59895, 0xe5988c, 0xe59892, 0xe597bc, + /* 4c */ 0xe5988f, 0xe5989c, 0xe59881, 0xe59893, + /* 50 */ 0xe59882, 0xe597ba, 0xe5989d, 0xe59884, + /* 54 */ 0xe597bf, 0xe597b9, 0xe5a289, 0xe5a1bc, + /* 58 */ 0xe5a290, 0xe5a298, 0xe5a286, 0xe5a281, + /* 5c */ 0xe5a1bf, 0xe5a1b4, 0xe5a28b, 0xe5a1ba, + /* 60 */ 0xe5a287, 0xe5a291, 0xe5a28e, 0xe5a1b6, + /* 64 */ 0xe5a282, 0xe5a288, 0xe5a1bb, 0xe5a294, + /* 68 */ 0xe5a28f, 0xe5a3be, 0xe5a5ab, 0xe5ab9c, + /* 6c */ 0xe5abae, 0xe5aba5, 0xe5ab95, 0xe5abaa, + /* 70 */ 0xe5ab9a, 0xe5abad, 0xe5abab, 0xe5abb3, + /* 74 */ 0xe5aba2, 0xe5aba0, 0xe5ab9b, 0xe5abac, + /* 78 */ 0xe5ab9e, 0xe5ab9d, 0xe5ab99, 0xe5aba8, + /* 7c */ 0xe5ab9f, 0xe5adb7, 0xe5afa0, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe5afa3, 0xe5b1a3, 0xe5b682, + /* a4 */ 0xe5b680, 0xe5b5bd, 0xe5b686, 0xe5b5ba, + /* a8 */ 0xe5b681, 0xe5b5b7, 0xe5b68a, 0xe5b689, + /* ac */ 0xe5b688, 0xe5b5be, 0xe5b5bc, 0xe5b68d, + /* b0 */ 0xe5b5b9, 0xe5b5bf, 0xe5b998, 0xe5b999, + /* b4 */ 0xe5b993, 0xe5bb98, 0xe5bb91, 0xe5bb97, + /* b8 */ 0xe5bb8e, 0xe5bb9c, 0xe5bb95, 0xe5bb99, + /* bc */ 0xe5bb92, 0xe5bb94, 0xe5bd84, 0xe5bd83, + /* c0 */ 0xe5bdaf, 0xe5beb6, 0xe684ac, 0xe684a8, + /* c4 */ 0xe68581, 0xe6859e, 0xe685b1, 0xe685b3, + /* c8 */ 0xe68592, 0xe68593, 0xe685b2, 0xe685ac, + /* cc */ 0xe68680, 0xe685b4, 0xe68594, 0xe685ba, + /* d0 */ 0xe6859b, 0xe685a5, 0xe684bb, 0xe685aa, + /* d4 */ 0xe685a1, 0xe68596, 0xe688a9, 0xe688a7, + /* d8 */ 0xe688ab, 0xe690ab, 0xe6918d, 0xe6919b, + /* dc */ 0xe6919d, 0xe691b4, 0xe691b6, 0xe691b2, + /* e0 */ 0xe691b3, 0xe691bd, 0xe691b5, 0xe691a6, + /* e4 */ 0xe692a6, 0xe6918e, 0xe69282, 0xe6919e, + /* e8 */ 0xe6919c, 0xe6918b, 0xe69193, 0xe691a0, + /* ec */ 0xe69190, 0xe691bf, 0xe690bf, 0xe691ac, + /* f0 */ 0xe691ab, 0xe69199, 0xe691a5, 0xe691b7, + /* f4 */ 0xe695b3, 0xe696a0, 0xe69aa1, 0xe69aa0, + /* f8 */ 0xe69a9f, 0xe69c85, 0xe69c84, 0xe69ca2, + /* fc */ 0xe6a6b1, 0xe6a6b6, 0xe6a789, + + /*** Two byte table, leaf: e2xx - offset 0x030d8 ***/ + + /* 40 */ 0xe6a6a0, 0xe6a78e, 0xe6a696, 0xe6a6b0, + /* 44 */ 0xe6a6ac, 0xe6a6bc, 0xe6a691, 0xe6a699, + /* 48 */ 0xe6a68e, 0xe6a6a7, 0xe6a68d, 0xe6a6a9, + /* 4c */ 0xe6a6be, 0xe6a6af, 0xe6a6bf, 0xe6a784, + /* 50 */ 0xe6a6bd, 0xe6a6a4, 0xe6a794, 0xe6a6b9, + /* 54 */ 0xe6a78a, 0xe6a69a, 0xe6a78f, 0xe6a6b3, + /* 58 */ 0xe6a693, 0xe6a6aa, 0xe6a6a1, 0xe6a69e, + /* 5c */ 0xe6a799, 0xe6a697, 0xe6a690, 0xe6a782, + /* 60 */ 0xe6a6b5, 0xe6a6a5, 0xe6a786, 0xe6ad8a, + /* 64 */ 0xe6ad8d, 0xe6ad8b, 0xe6ae9e, 0xe6ae9f, + /* 68 */ 0xe6aea0, 0xe6af83, 0xe6af84, 0xe6afbe, + /* 6c */ 0xe6bb8e, 0xe6bbb5, 0xe6bbb1, 0xe6bc83, + /* 70 */ 0xe6bca5, 0xe6bbb8, 0xe6bcb7, 0xe6bbbb, + /* 74 */ 0xe6bcae, 0xe6bc89, 0xe6bd8e, 0xe6bc99, + /* 78 */ 0xe6bc9a, 0xe6bca7, 0xe6bc98, 0xe6bcbb, + /* 7c */ 0xe6bc92, 0xe6bbad, 0xe6bc8a, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6bcb6, 0xe6bdb3, 0xe6bbb9, + /* a4 */ 0xe6bbae, 0xe6bcad, 0xe6bd80, 0xe6bcb0, + /* a8 */ 0xe6bcbc, 0xe6bcb5, 0xe6bbab, 0xe6bc87, + /* ac */ 0xe6bc8e, 0xe6bd83, 0xe6bc85, 0xe6bbbd, + /* b0 */ 0xe6bbb6, 0xe6bcb9, 0xe6bc9c, 0xe6bbbc, + /* b4 */ 0xe6bcba, 0xe6bc9f, 0xe6bc8d, 0xe6bc9e, + /* b8 */ 0xe6bc88, 0xe6bca1, 0xe78687, 0xe78690, + /* bc */ 0xe78689, 0xe78680, 0xe78685, 0xe78682, + /* c0 */ 0xe7868f, 0xe785bb, 0xe78686, 0xe78681, + /* c4 */ 0xe78697, 0xe78984, 0xe78993, 0xe78a97, + /* c8 */ 0xe78a95, 0xe78a93, 0xe78d83, 0xe78d8d, + /* cc */ 0xe78d91, 0xe78d8c, 0xe791a2, 0xe791b3, + /* d0 */ 0xe791b1, 0xe791b5, 0xe791b2, 0xe791a7, + /* d4 */ 0xe791ae, 0xe79480, 0xe79482, 0xe79483, + /* d8 */ 0xe795bd, 0xe79690, 0xe79896, 0xe79888, + /* dc */ 0xe7988c, 0xe79895, 0xe79891, 0xe7988a, + /* e0 */ 0xe79894, 0xe79ab8, 0xe79e81, 0xe79dbc, + /* e4 */ 0xe79e85, 0xe79e82, 0xe79dae, 0xe79e80, + /* e8 */ 0xe79daf, 0xe79dbe, 0xe79e83, 0xe7a2b2, + /* ec */ 0xe7a2aa, 0xe7a2b4, 0xe7a2ad, 0xe7a2a8, + /* f0 */ 0xe7a1be, 0xe7a2ab, 0xe7a29e, 0xe7a2a5, + /* f4 */ 0xe7a2a0, 0xe7a2ac, 0xe7a2a2, 0xe7a2a4, + /* f8 */ 0xe7a698, 0xe7a68a, 0xe7a68b, 0xe7a696, + /* fc */ 0xe7a695, 0xe7a694, 0xe7a693, + + /*** Two byte table, leaf: e3xx - offset 0x03197 ***/ + + /* 40 */ 0xe7a697, 0xe7a688, 0xe7a692, 0xe7a690, + /* 44 */ 0xe7a8ab, 0xe7a98a, 0xe7a8b0, 0xe7a8af, + /* 48 */ 0xe7a8a8, 0xe7a8a6, 0xe7aaa8, 0xe7aaab, + /* 4c */ 0xe7aaac, 0xe7abae, 0xe7ae88, 0xe7ae9c, + /* 50 */ 0xe7ae8a, 0xe7ae91, 0xe7ae90, 0xe7ae96, + /* 54 */ 0xe7ae8d, 0xe7ae8c, 0xe7ae9b, 0xe7ae8e, + /* 58 */ 0xe7ae85, 0xe7ae98, 0xe58a84, 0xe7ae99, + /* 5c */ 0xe7aea4, 0xe7ae82, 0xe7b2bb, 0xe7b2bf, + /* 60 */ 0xe7b2bc, 0xe7b2ba, 0xe7b6a7, 0xe7b6b7, + /* 64 */ 0xe7b782, 0xe7b6a3, 0xe7b6aa, 0xe7b781, + /* 68 */ 0xe7b780, 0xe7b785, 0xe7b69d, 0xe7b78e, + /* 6c */ 0xe7b784, 0xe7b786, 0xe7b78b, 0xe7b78c, + /* 70 */ 0xe7b6af, 0xe7b6b9, 0xe7b696, 0xe7b6bc, + /* 74 */ 0xe7b69f, 0xe7b6a6, 0xe7b6ae, 0xe7b6a9, + /* 78 */ 0xe7b6a1, 0xe7b789, 0xe7bdb3, 0xe7bfa2, + /* 7c */ 0xe7bfa3, 0xe7bfa5, 0xe7bf9e, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe880a4, 0xe8819d, 0xe8819c, + /* a4 */ 0xe88689, 0xe88686, 0xe88683, 0xe88687, + /* a8 */ 0xe8868d, 0xe8868c, 0xe8868b, 0xe88895, + /* ac */ 0xe89297, 0xe892a4, 0xe892a1, 0xe8929f, + /* b0 */ 0xe892ba, 0xe8938e, 0xe89382, 0xe892ac, + /* b4 */ 0xe892ae, 0xe892ab, 0xe892b9, 0xe892b4, + /* b8 */ 0xe89381, 0xe8938d, 0xe892aa, 0xe8929a, + /* bc */ 0xe892b1, 0xe89390, 0xe8929d, 0xe892a7, + /* c0 */ 0xe892bb, 0xe892a2, 0xe89294, 0xe89387, + /* c4 */ 0xe8938c, 0xe8929b, 0xe892a9, 0xe892af, + /* c8 */ 0xe892a8, 0xe89396, 0xe89298, 0xe892b6, + /* cc */ 0xe8938f, 0xe892a0, 0xe89397, 0xe89394, + /* d0 */ 0xe89392, 0xe8939b, 0xe892b0, 0xe89291, + /* d4 */ 0xe899a1, 0xe89cb3, 0xe89ca3, 0xe89ca8, + /* d8 */ 0xe89dab, 0xe89d80, 0xe89cae, 0xe89c9e, + /* dc */ 0xe89ca1, 0xe89c99, 0xe89c9b, 0xe89d83, + /* e0 */ 0xe89cac, 0xe89d81, 0xe89cbe, 0xe89d86, + /* e4 */ 0xe89ca0, 0xe89cb2, 0xe89caa, 0xe89cad, + /* e8 */ 0xe89cbc, 0xe89c92, 0xe89cba, 0xe89cb1, + /* ec */ 0xe89cb5, 0xe89d82, 0xe89ca6, 0xe89ca7, + /* f0 */ 0xe89cb8, 0xe89ca4, 0xe89c9a, 0xe89cb0, + /* f4 */ 0xe89c91, 0xe8a3b7, 0xe8a3a7, 0xe8a3b1, + /* f8 */ 0xe8a3b2, 0xe8a3ba, 0xe8a3be, 0xe8a3ae, + /* fc */ 0xe8a3bc, 0xe8a3b6, 0xe8a3bb, + + /*** Two byte table, leaf: e4xx - offset 0x03256 ***/ + + /* 40 */ 0xe8a3b0, 0xe8a3ac, 0xe8a3ab, 0xe8a69d, + /* 44 */ 0xe8a6a1, 0xe8a69f, 0xe8a69e, 0xe8a7a9, + /* 48 */ 0xe8a7ab, 0xe8a7a8, 0xe8aaab, 0xe8aa99, + /* 4c */ 0xe8aa8b, 0xe8aa92, 0xe8aa8f, 0xe8aa96, + /* 50 */ 0xe8b0bd, 0xe8b1a8, 0xe8b1a9, 0xe8b395, + /* 54 */ 0xe8b38f, 0xe8b397, 0xe8b696, 0xe8b889, + /* 58 */ 0xe8b882, 0xe8b7bf, 0xe8b88d, 0xe8b7bd, + /* 5c */ 0xe8b88a, 0xe8b883, 0xe8b887, 0xe8b886, + /* 60 */ 0xe8b885, 0xe8b7be, 0xe8b880, 0xe8b884, + /* 64 */ 0xe8bc90, 0xe8bc91, 0xe8bc8e, 0xe8bc8d, + /* 68 */ 0xe984a3, 0xe9849c, 0xe984a0, 0xe984a2, + /* 6c */ 0xe9849f, 0xe9849d, 0xe9849a, 0xe984a4, + /* 70 */ 0xe984a1, 0xe9849b, 0xe985ba, 0xe985b2, + /* 74 */ 0xe985b9, 0xe985b3, 0xe98aa5, 0xe98aa4, + /* 78 */ 0xe989b6, 0xe98a9b, 0xe989ba, 0xe98aa0, + /* 7c */ 0xe98a94, 0xe98aaa, 0xe98a8d, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe98aa6, 0xe98a9a, 0xe98aab, + /* a4 */ 0xe989b9, 0xe98a97, 0xe989bf, 0xe98aa3, + /* a8 */ 0xe98bae, 0xe98a8e, 0xe98a82, 0xe98a95, + /* ac */ 0xe98aa2, 0xe989bd, 0xe98a88, 0xe98aa1, + /* b0 */ 0xe98a8a, 0xe98a86, 0xe98a8c, 0xe98a99, + /* b4 */ 0xe98aa7, 0xe989be, 0xe98a87, 0xe98aa9, + /* b8 */ 0xe98a9d, 0xe98a8b, 0xe988ad, 0xe99a9e, + /* bc */ 0xe99aa1, 0xe99bbf, 0xe99d98, 0xe99dbd, + /* c0 */ 0xe99dba, 0xe99dbe, 0xe99e83, 0xe99e80, + /* c4 */ 0xe99e82, 0xe99dbb, 0xe99e84, 0xe99e81, + /* c8 */ 0xe99dbf, 0xe99f8e, 0xe99f8d, 0xe9a096, + /* cc */ 0xe9a2ad, 0xe9a2ae, 0xe9a482, 0xe9a480, + /* d0 */ 0xe9a487, 0xe9a69d, 0xe9a69c, 0xe9a783, + /* d4 */ 0xe9a6b9, 0xe9a6bb, 0xe9a6ba, 0xe9a782, + /* d8 */ 0xe9a6bd, 0xe9a787, 0xe9aab1, 0xe9aba3, + /* dc */ 0xe9aba7, 0xe9acbe, 0xe9acbf, 0xe9ada0, + /* e0 */ 0xe9ada1, 0xe9ad9f, 0xe9b3b1, 0xe9b3b2, + /* e4 */ 0xe9b3b5, 0xe9baa7, 0xe583bf, 0xe58483, + /* e8 */ 0xe584b0, 0xe583b8, 0xe58486, 0xe58487, + /* ec */ 0xe583b6, 0xe583be, 0xe5848b, 0xe5848c, + /* f0 */ 0xe583bd, 0xe5848a, 0xe58a8b, 0xe58a8c, + /* f4 */ 0xe58bb1, 0xe58baf, 0xe59988, 0xe59982, + /* f8 */ 0xe5998c, 0xe598b5, 0xe59981, 0xe5998a, + /* fc */ 0xe59989, 0xe59986, 0xe59998, + + /*** Two byte table, leaf: e5xx - offset 0x03315 ***/ + + /* 40 */ 0xe5999a, 0xe59980, 0xe598b3, 0xe598bd, + /* 44 */ 0xe598ac, 0xe598be, 0xe598b8, 0xe598aa, + /* 48 */ 0xe598ba, 0xe59c9a, 0xe5a2ab, 0xe5a29d, + /* 4c */ 0xe5a2b1, 0xe5a2a0, 0xe5a2a3, 0xe5a2af, + /* 50 */ 0xe5a2ac, 0xe5a2a5, 0xe5a2a1, 0xe5a3bf, + /* 54 */ 0xe5abbf, 0xe5abb4, 0xe5abbd, 0xe5abb7, + /* 58 */ 0xe5abb6, 0xe5ac83, 0xe5abb8, 0xe5ac82, + /* 5c */ 0xe5abb9, 0xe5ac81, 0xe5ac87, 0xe5ac85, + /* 60 */ 0xe5ac8f, 0xe5b1a7, 0xe5b699, 0xe5b697, + /* 64 */ 0xe5b69f, 0xe5b692, 0xe5b6a2, 0xe5b693, + /* 68 */ 0xe5b695, 0xe5b6a0, 0xe5b69c, 0xe5b6a1, + /* 6c */ 0xe5b69a, 0xe5b69e, 0xe5b9a9, 0xe5b99d, + /* 70 */ 0xe5b9a0, 0xe5b99c, 0xe7b7b3, 0xe5bb9b, + /* 74 */ 0xe5bb9e, 0xe5bba1, 0xe5bd89, 0xe5beb2, + /* 78 */ 0xe6868b, 0xe68683, 0xe685b9, 0xe686b1, + /* 7c */ 0xe686b0, 0xe686a2, 0xe68689, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe6869b, 0xe68693, 0xe686af, + /* a4 */ 0xe686ad, 0xe6869f, 0xe68692, 0xe686aa, + /* a8 */ 0xe686a1, 0xe6868d, 0xe685a6, 0xe686b3, + /* ac */ 0xe688ad, 0xe691ae, 0xe691b0, 0xe69296, + /* b0 */ 0xe692a0, 0xe69285, 0xe69297, 0xe6929c, + /* b4 */ 0xe6928f, 0xe6928b, 0xe6928a, 0xe6928c, + /* b8 */ 0xe692a3, 0xe6929f, 0xe691a8, 0xe692b1, + /* bc */ 0xe69298, 0xe695b6, 0xe695ba, 0xe695b9, + /* c0 */ 0xe695bb, 0xe696b2, 0xe696b3, 0xe69ab5, + /* c4 */ 0xe69ab0, 0xe69aa9, 0xe69ab2, 0xe69ab7, + /* c8 */ 0xe69aaa, 0xe69aaf, 0xe6a880, 0xe6a886, + /* cc */ 0xe6a897, 0xe6a7a5, 0xe6a7b8, 0xe6a895, + /* d0 */ 0xe6a7b1, 0xe6a7a4, 0xe6a8a0, 0xe6a7bf, + /* d4 */ 0xe6a7ac, 0xe6a7a2, 0xe6a89b, 0xe6a89d, + /* d8 */ 0xe6a7be, 0xe6a8a7, 0xe6a7b2, 0xe6a7ae, + /* dc */ 0xe6a894, 0xe6a7b7, 0xe6a7a7, 0xe6a980, + /* e0 */ 0xe6a888, 0xe6a7a6, 0xe6a7bb, 0xe6a88d, + /* e4 */ 0xe6a7bc, 0xe6a7ab, 0xe6a889, 0xe6a884, + /* e8 */ 0xe6a898, 0xe6a8a5, 0xe6a88f, 0xe6a7b6, + /* ec */ 0xe6a8a6, 0xe6a887, 0xe6a7b4, 0xe6a896, + /* f0 */ 0xe6ad91, 0xe6aea5, 0xe6aea3, 0xe6aea2, + /* f4 */ 0xe6aea6, 0xe6b081, 0xe6b080, 0xe6afbf, + /* f8 */ 0xe6b082, 0xe6bd81, 0xe6bca6, 0xe6bdbe, + /* fc */ 0xe6be87, 0xe6bf86, 0xe6be92, + + /*** Two byte table, leaf: e6xx - offset 0x033d4 ***/ + + /* 40 */ 0xe6be8d, 0xe6be89, 0xe6be8c, 0xe6bda2, + /* 44 */ 0xe6bd8f, 0xe6be85, 0xe6bd9a, 0xe6be96, + /* 48 */ 0xe6bdb6, 0xe6bdac, 0xe6be82, 0xe6bd95, + /* 4c */ 0xe6bdb2, 0xe6bd92, 0xe6bd90, 0xe6bd97, + /* 50 */ 0xe6be94, 0xe6be93, 0xe6bd9d, 0xe6bc80, + /* 54 */ 0xe6bda1, 0xe6bdab, 0xe6bdbd, 0xe6bda7, + /* 58 */ 0xe6be90, 0xe6bd93, 0xe6be8b, 0xe6bda9, + /* 5c */ 0xe6bdbf, 0xe6be95, 0xe6bda3, 0xe6bdb7, + /* 60 */ 0xe6bdaa, 0xe6bdbb, 0xe786b2, 0xe786af, + /* 64 */ 0xe7869b, 0xe786b0, 0xe786a0, 0xe7869a, + /* 68 */ 0xe786a9, 0xe786b5, 0xe7869d, 0xe786a5, + /* 6c */ 0xe7869e, 0xe786a4, 0xe786a1, 0xe786aa, + /* 70 */ 0xe7869c, 0xe786a7, 0xe786b3, 0xe78a98, + /* 74 */ 0xe78a9a, 0xe78d98, 0xe78d92, 0xe78d9e, + /* 78 */ 0xe78d9f, 0xe78da0, 0xe78d9d, 0xe78d9b, + /* 7c */ 0xe78da1, 0xe78d9a, 0xe78d99, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe78da2, 0xe79287, 0xe79289, + /* a4 */ 0xe7928a, 0xe79286, 0xe79281, 0xe791bd, + /* a8 */ 0xe79285, 0xe79288, 0xe791bc, 0xe791b9, + /* ac */ 0xe79488, 0xe79487, 0xe795be, 0xe798a5, + /* b0 */ 0xe7989e, 0xe79899, 0xe7989d, 0xe7989c, + /* b4 */ 0xe798a3, 0xe7989a, 0xe798a8, 0xe7989b, + /* b8 */ 0xe79a9c, 0xe79a9d, 0xe79a9e, 0xe79a9b, + /* bc */ 0xe79e8d, 0xe79e8f, 0xe79e89, 0xe79e88, + /* c0 */ 0xe7a38d, 0xe7a2bb, 0xe7a38f, 0xe7a38c, + /* c4 */ 0xe7a391, 0xe7a38e, 0xe7a394, 0xe7a388, + /* c8 */ 0xe7a383, 0xe7a384, 0xe7a389, 0xe7a69a, + /* cc */ 0xe7a6a1, 0xe7a6a0, 0xe7a69c, 0xe7a6a2, + /* d0 */ 0xe7a69b, 0xe6adb6, 0xe7a8b9, 0xe7aab2, + /* d4 */ 0xe7aab4, 0xe7aab3, 0xe7aeb7, 0xe7af8b, + /* d8 */ 0xe7aebe, 0xe7aeac, 0xe7af8e, 0xe7aeaf, + /* dc */ 0xe7aeb9, 0xe7af8a, 0xe7aeb5, 0xe7b385, + /* e0 */ 0xe7b388, 0xe7b38c, 0xe7b38b, 0xe7b7b7, + /* e4 */ 0xe7b79b, 0xe7b7aa, 0xe7b7a7, 0xe7b797, + /* e8 */ 0xe7b7a1, 0xe7b883, 0xe7b7ba, 0xe7b7a6, + /* ec */ 0xe7b7b6, 0xe7b7b1, 0xe7b7b0, 0xe7b7ae, + /* f0 */ 0xe7b79f, 0xe7bdb6, 0xe7beac, 0xe7beb0, + /* f4 */ 0xe7bead, 0xe7bfad, 0xe7bfab, 0xe7bfaa, + /* f8 */ 0xe7bfac, 0xe7bfa6, 0xe7bfa8, 0xe881a4, + /* fc */ 0xe881a7, 0xe886a3, 0xe8869f, + + /*** Two byte table, leaf: e7xx - offset 0x03493 ***/ + + /* 40 */ 0xe8869e, 0xe88695, 0xe886a2, 0xe88699, + /* 44 */ 0xe88697, 0xe88896, 0xe8898f, 0xe88993, + /* 48 */ 0xe88992, 0xe88990, 0xe8898e, 0xe88991, + /* 4c */ 0xe894a4, 0xe894bb, 0xe8948f, 0xe89480, + /* 50 */ 0xe894a9, 0xe8948e, 0xe89489, 0xe8948d, + /* 54 */ 0xe8949f, 0xe8948a, 0xe894a7, 0xe8949c, + /* 58 */ 0xe893bb, 0xe894ab, 0xe893ba, 0xe89488, + /* 5c */ 0xe8948c, 0xe893b4, 0xe894aa, 0xe893b2, + /* 60 */ 0xe89495, 0xe893b7, 0xe893ab, 0xe893b3, + /* 64 */ 0xe893bc, 0xe89492, 0xe893aa, 0xe893a9, + /* 68 */ 0xe89496, 0xe893be, 0xe894a8, 0xe8949d, + /* 6c */ 0xe894ae, 0xe89482, 0xe893bd, 0xe8949e, + /* 70 */ 0xe893b6, 0xe894b1, 0xe894a6, 0xe893a7, + /* 74 */ 0xe893a8, 0xe893b0, 0xe893af, 0xe893b9, + /* 78 */ 0xe89498, 0xe894a0, 0xe894b0, 0xe8948b, + /* 7c */ 0xe89499, 0xe894af, 0xe899a2, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe89d96, 0xe89da3, 0xe89da4, + /* a4 */ 0xe89db7, 0xe89fa1, 0xe89db3, 0xe89d98, + /* a8 */ 0xe89d94, 0xe89d9b, 0xe89d92, 0xe89da1, + /* ac */ 0xe89d9a, 0xe89d91, 0xe89d9e, 0xe89dad, + /* b0 */ 0xe89daa, 0xe89d90, 0xe89d8e, 0xe89d9f, + /* b4 */ 0xe89d9d, 0xe89daf, 0xe89dac, 0xe89dba, + /* b8 */ 0xe89dae, 0xe89d9c, 0xe89da5, 0xe89d8f, + /* bc */ 0xe89dbb, 0xe89db5, 0xe89da2, 0xe89da7, + /* c0 */ 0xe89da9, 0xe8a19a, 0xe8a485, 0xe8a48c, + /* c4 */ 0xe8a494, 0xe8a48b, 0xe8a497, 0xe8a498, + /* c8 */ 0xe8a499, 0xe8a486, 0xe8a496, 0xe8a491, + /* cc */ 0xe8a48e, 0xe8a489, 0xe8a6a2, 0xe8a6a4, + /* d0 */ 0xe8a6a3, 0xe8a7ad, 0xe8a7b0, 0xe8a7ac, + /* d4 */ 0xe8ab8f, 0xe8ab86, 0xe8aab8, 0xe8ab93, + /* d8 */ 0xe8ab91, 0xe8ab94, 0xe8ab95, 0xe8aabb, + /* dc */ 0xe8ab97, 0xe8aabe, 0xe8ab80, 0xe8ab85, + /* e0 */ 0xe8ab98, 0xe8ab83, 0xe8aaba, 0xe8aabd, + /* e4 */ 0xe8ab99, 0xe8b0be, 0xe8b18d, 0xe8b28f, + /* e8 */ 0xe8b3a5, 0xe8b39f, 0xe8b399, 0xe8b3a8, + /* ec */ 0xe8b39a, 0xe8b39d, 0xe8b3a7, 0xe8b6a0, + /* f0 */ 0xe8b69c, 0xe8b6a1, 0xe8b69b, 0xe8b8a0, + /* f4 */ 0xe8b8a3, 0xe8b8a5, 0xe8b8a4, 0xe8b8ae, + /* f8 */ 0xe8b895, 0xe8b89b, 0xe8b896, 0xe8b891, + /* fc */ 0xe8b899, 0xe8b8a6, 0xe8b8a7, + + /*** Two byte table, leaf: e8xx - offset 0x03552 ***/ + + /* 40 */ 0xe8b894, 0xe8b892, 0xe8b898, 0xe8b893, + /* 44 */ 0xe8b89c, 0xe8b897, 0xe8b89a, 0xe8bcac, + /* 48 */ 0xe8bca4, 0xe8bc98, 0xe8bc9a, 0xe8bca0, + /* 4c */ 0xe8bca3, 0xe8bc96, 0xe8bc97, 0xe981b3, + /* 50 */ 0xe981b0, 0xe981af, 0xe981a7, 0xe981ab, + /* 54 */ 0xe984af, 0xe984ab, 0xe984a9, 0xe984aa, + /* 58 */ 0xe984b2, 0xe984a6, 0xe984ae, 0xe98685, + /* 5c */ 0xe98686, 0xe9868a, 0xe98681, 0xe98682, + /* 60 */ 0xe98684, 0xe98680, 0xe98b90, 0xe98b83, + /* 64 */ 0xe98b84, 0xe98b80, 0xe98b99, 0xe98ab6, + /* 68 */ 0xe98b8f, 0xe98bb1, 0xe98b9f, 0xe98b98, + /* 6c */ 0xe98ba9, 0xe98b97, 0xe98b9d, 0xe98b8c, + /* 70 */ 0xe98baf, 0xe98b82, 0xe98ba8, 0xe98b8a, + /* 74 */ 0xe98b88, 0xe98b8e, 0xe98ba6, 0xe98b8d, + /* 78 */ 0xe98b95, 0xe98b89, 0xe98ba0, 0xe98b9e, + /* 7c */ 0xe98ba7, 0xe98b91, 0xe98b93, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe98ab5, 0xe98ba1, 0xe98b86, + /* a4 */ 0xe98ab4, 0xe995bc, 0xe996ac, 0xe996ab, + /* a8 */ 0xe996ae, 0xe996b0, 0xe99aa4, 0xe99aa2, + /* ac */ 0xe99b93, 0xe99c85, 0xe99c88, 0xe99c82, + /* b0 */ 0xe99d9a, 0xe99e8a, 0xe99e8e, 0xe99e88, + /* b4 */ 0xe99f90, 0xe99f8f, 0xe9a09e, 0xe9a09d, + /* b8 */ 0xe9a0a6, 0xe9a0a9, 0xe9a0a8, 0xe9a0a0, + /* bc */ 0xe9a09b, 0xe9a0a7, 0xe9a2b2, 0xe9a488, + /* c0 */ 0xe9a3ba, 0xe9a491, 0xe9a494, 0xe9a496, + /* c4 */ 0xe9a497, 0xe9a495, 0xe9a79c, 0xe9a78d, + /* c8 */ 0xe9a78f, 0xe9a793, 0xe9a794, 0xe9a78e, + /* cc */ 0xe9a789, 0xe9a796, 0xe9a798, 0xe9a78b, + /* d0 */ 0xe9a797, 0xe9a78c, 0xe9aab3, 0xe9abac, + /* d4 */ 0xe9abab, 0xe9abb3, 0xe9abb2, 0xe9abb1, + /* d8 */ 0xe9ad86, 0xe9ad83, 0xe9ada7, 0xe9adb4, + /* dc */ 0xe9adb1, 0xe9ada6, 0xe9adb6, 0xe9adb5, + /* e0 */ 0xe9adb0, 0xe9ada8, 0xe9ada4, 0xe9adac, + /* e4 */ 0xe9b3bc, 0xe9b3ba, 0xe9b3bd, 0xe9b3bf, + /* e8 */ 0xe9b3b7, 0xe9b487, 0xe9b480, 0xe9b3b9, + /* ec */ 0xe9b3bb, 0xe9b488, 0xe9b485, 0xe9b484, + /* f0 */ 0xe9ba83, 0xe9bb93, 0xe9bc8f, 0xe9bc90, + /* f4 */ 0xe5849c, 0xe58493, 0xe58497, 0xe5849a, + /* f8 */ 0xe58491, 0xe5879e, 0xe58cb4, 0xe58fa1, + /* fc */ 0xe599b0, 0xe599a0, 0xe599ae, + + /*** Two byte table, leaf: e9xx - offset 0x03611 ***/ + + /* 40 */ 0xe599b3, 0xe599a6, 0xe599a3, 0xe599ad, + /* 44 */ 0xe599b2, 0xe5999e, 0xe599b7, 0xe59c9c, + /* 48 */ 0xe59c9b, 0xe5a388, 0xe5a2bd, 0xe5a389, + /* 4c */ 0xe5a2bf, 0xe5a2ba, 0xe5a382, 0xe5a2bc, + /* 50 */ 0xe5a386, 0xe5ac97, 0xe5ac99, 0xe5ac9b, + /* 54 */ 0xe5aca1, 0xe5ac94, 0xe5ac93, 0xe5ac90, + /* 58 */ 0xe5ac96, 0xe5aca8, 0xe5ac9a, 0xe5aca0, + /* 5c */ 0xe5ac9e, 0xe5afaf, 0xe5b6ac, 0xe5b6b1, + /* 60 */ 0xe5b6a9, 0xe5b6a7, 0xe5b6b5, 0xe5b6b0, + /* 64 */ 0xe5b6ae, 0xe5b6aa, 0xe5b6a8, 0xe5b6b2, + /* 68 */ 0xe5b6ad, 0xe5b6af, 0xe5b6b4, 0xe5b9a7, + /* 6c */ 0xe5b9a8, 0xe5b9a6, 0xe5b9af, 0xe5bba9, + /* 70 */ 0xe5bba7, 0xe5bba6, 0xe5bba8, 0xe5bba5, + /* 74 */ 0xe5bd8b, 0xe5bebc, 0xe6869d, 0xe686a8, + /* 78 */ 0xe68696, 0xe68785, 0xe686b4, 0xe68786, + /* 7c */ 0xe68781, 0xe6878c, 0xe686ba, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe686bf, 0xe686b8, 0xe6868c, + /* a4 */ 0xe69397, 0xe69396, 0xe69390, 0xe6938f, + /* a8 */ 0xe69389, 0xe692bd, 0xe69289, 0xe69383, + /* ac */ 0xe6939b, 0xe693b3, 0xe69399, 0xe694b3, + /* b0 */ 0xe695bf, 0xe695bc, 0xe696a2, 0xe69b88, + /* b4 */ 0xe69abe, 0xe69b80, 0xe69b8a, 0xe69b8b, + /* b8 */ 0xe69b8f, 0xe69abd, 0xe69abb, 0xe69aba, + /* bc */ 0xe69b8c, 0xe69ca3, 0xe6a8b4, 0xe6a9a6, + /* c0 */ 0xe6a989, 0xe6a9a7, 0xe6a8b2, 0xe6a9a8, + /* c4 */ 0xe6a8be, 0xe6a99d, 0xe6a9ad, 0xe6a9b6, + /* c8 */ 0xe6a99b, 0xe6a991, 0xe6a8a8, 0xe6a99a, + /* cc */ 0xe6a8bb, 0xe6a8bf, 0xe6a981, 0xe6a9aa, + /* d0 */ 0xe6a9a4, 0xe6a990, 0xe6a98f, 0xe6a994, + /* d4 */ 0xe6a9af, 0xe6a9a9, 0xe6a9a0, 0xe6a8bc, + /* d8 */ 0xe6a99e, 0xe6a996, 0xe6a995, 0xe6a98d, + /* dc */ 0xe6a98e, 0xe6a986, 0xe6ad95, 0xe6ad94, + /* e0 */ 0xe6ad96, 0xe6aea7, 0xe6aeaa, 0xe6aeab, + /* e4 */ 0xe6af88, 0xe6af87, 0xe6b084, 0xe6b083, + /* e8 */ 0xe6b086, 0xe6bead, 0xe6bf8b, 0xe6bea3, + /* ec */ 0xe6bf87, 0xe6bebc, 0xe6bf8e, 0xe6bf88, + /* f0 */ 0xe6bd9e, 0xe6bf84, 0xe6bebd, 0xe6be9e, + /* f4 */ 0xe6bf8a, 0xe6bea8, 0xe78084, 0xe6bea5, + /* f8 */ 0xe6beae, 0xe6beba, 0xe6beac, 0xe6beaa, + /* fc */ 0xe6bf8f, 0xe6bebf, 0xe6beb8, + + /*** Two byte table, leaf: eaxx - offset 0x036d0 ***/ + + /* 40 */ 0xe6bea2, 0xe6bf89, 0xe6beab, 0xe6bf8d, + /* 44 */ 0xe6beaf, 0xe6beb2, 0xe6beb0, 0xe78785, + /* 48 */ 0xe78782, 0xe786bf, 0xe786b8, 0xe78796, + /* 4c */ 0xe78780, 0xe78781, 0xe7878b, 0xe78794, + /* 50 */ 0xe7878a, 0xe78787, 0xe7878f, 0xe786bd, + /* 54 */ 0xe78798, 0xe786bc, 0xe78786, 0xe7879a, + /* 58 */ 0xe7879b, 0xe78a9d, 0xe78a9e, 0xe78da9, + /* 5c */ 0xe78da6, 0xe78da7, 0xe78dac, 0xe78da5, + /* 60 */ 0xe78dab, 0xe78daa, 0xe791bf, 0xe7929a, + /* 64 */ 0xe792a0, 0xe79294, 0xe79292, 0xe79295, + /* 68 */ 0xe792a1, 0xe7948b, 0xe79680, 0xe798af, + /* 6c */ 0xe798ad, 0xe798b1, 0xe798bd, 0xe798b3, + /* 70 */ 0xe798bc, 0xe798b5, 0xe798b2, 0xe798b0, + /* 74 */ 0xe79abb, 0xe79ba6, 0xe79e9a, 0xe79e9d, + /* 78 */ 0xe79ea1, 0xe79e9c, 0xe79e9b, 0xe79ea2, + /* 7c */ 0xe79ea3, 0xe79e95, 0xe79e99, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe79e97, 0xe7a39d, 0xe7a3a9, + /* a4 */ 0xe7a3a5, 0xe7a3aa, 0xe7a39e, 0xe7a3a3, + /* a8 */ 0xe7a39b, 0xe7a3a1, 0xe7a3a2, 0xe7a3ad, + /* ac */ 0xe7a39f, 0xe7a3a0, 0xe7a6a4, 0xe7a984, + /* b0 */ 0xe7a988, 0xe7a987, 0xe7aab6, 0xe7aab8, + /* b4 */ 0xe7aab5, 0xe7aab1, 0xe7aab7, 0xe7af9e, + /* b8 */ 0xe7afa3, 0xe7afa7, 0xe7af9d, 0xe7af95, + /* bc */ 0xe7afa5, 0xe7af9a, 0xe7afa8, 0xe7afb9, + /* c0 */ 0xe7af94, 0xe7afaa, 0xe7afa2, 0xe7af9c, + /* c4 */ 0xe7afab, 0xe7af98, 0xe7af9f, 0xe7b392, + /* c8 */ 0xe7b394, 0xe7b397, 0xe7b390, 0xe7b391, + /* cc */ 0xe7b892, 0xe7b8a1, 0xe7b897, 0xe7b88c, + /* d0 */ 0xe7b89f, 0xe7b8a0, 0xe7b893, 0xe7b88e, + /* d4 */ 0xe7b89c, 0xe7b895, 0xe7b89a, 0xe7b8a2, + /* d8 */ 0xe7b88b, 0xe7b88f, 0xe7b896, 0xe7b88d, + /* dc */ 0xe7b894, 0xe7b8a5, 0xe7b8a4, 0xe7bd83, + /* e0 */ 0xe7bdbb, 0xe7bdbc, 0xe7bdba, 0xe7beb1, + /* e4 */ 0xe7bfaf, 0xe880aa, 0xe880a9, 0xe881ac, + /* e8 */ 0xe886b1, 0xe886a6, 0xe886ae, 0xe886b9, + /* ec */ 0xe886b5, 0xe886ab, 0xe886b0, 0xe886ac, + /* f0 */ 0xe886b4, 0xe886b2, 0xe886b7, 0xe886a7, + /* f4 */ 0xe887b2, 0xe88995, 0xe88996, 0xe88997, + /* f8 */ 0xe89596, 0xe89585, 0xe895ab, 0xe8958d, + /* fc */ 0xe89593, 0xe895a1, 0xe89598, + + /*** Two byte table, leaf: ebxx - offset 0x0378f ***/ + + /* 40 */ 0xe89580, 0xe89586, 0xe895a4, 0xe89581, + /* 44 */ 0xe895a2, 0xe89584, 0xe89591, 0xe89587, + /* 48 */ 0xe895a3, 0xe894be, 0xe8959b, 0xe895b1, + /* 4c */ 0xe8958e, 0xe895ae, 0xe895b5, 0xe89595, + /* 50 */ 0xe895a7, 0xe895a0, 0xe8968c, 0xe895a6, + /* 54 */ 0xe8959d, 0xe89594, 0xe895a5, 0xe895ac, + /* 58 */ 0xe899a3, 0xe899a5, 0xe899a4, 0xe89e9b, + /* 5c */ 0xe89e8f, 0xe89e97, 0xe89e93, 0xe89e92, + /* 60 */ 0xe89e88, 0xe89e81, 0xe89e96, 0xe89e98, + /* 64 */ 0xe89db9, 0xe89e87, 0xe89ea3, 0xe89e85, + /* 68 */ 0xe89e90, 0xe89e91, 0xe89e9d, 0xe89e84, + /* 6c */ 0xe89e94, 0xe89e9c, 0xe89e9a, 0xe89e89, + /* 70 */ 0xe8a49e, 0xe8a4a6, 0xe8a4b0, 0xe8a4ad, + /* 74 */ 0xe8a4ae, 0xe8a4a7, 0xe8a4b1, 0xe8a4a2, + /* 78 */ 0xe8a4a9, 0xe8a4a3, 0xe8a4af, 0xe8a4ac, + /* 7c */ 0xe8a49f, 0xe8a7b1, 0xe8aba0, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe8aba2, 0xe8abb2, 0xe8abb4, + /* a4 */ 0xe8abb5, 0xe8ab9d, 0xe8ac94, 0xe8aba4, + /* a8 */ 0xe8ab9f, 0xe8abb0, 0xe8ab88, 0xe8ab9e, + /* ac */ 0xe8aba1, 0xe8aba8, 0xe8abbf, 0xe8abaf, + /* b0 */ 0xe8abbb, 0xe8b291, 0xe8b292, 0xe8b290, + /* b4 */ 0xe8b3b5, 0xe8b3ae, 0xe8b3b1, 0xe8b3b0, + /* b8 */ 0xe8b3b3, 0xe8b5ac, 0xe8b5ae, 0xe8b6a5, + /* bc */ 0xe8b6a7, 0xe8b8b3, 0xe8b8be, 0xe8b8b8, + /* c0 */ 0xe8b980, 0xe8b985, 0xe8b8b6, 0xe8b8bc, + /* c4 */ 0xe8b8bd, 0xe8b981, 0xe8b8b0, 0xe8b8bf, + /* c8 */ 0xe8babd, 0xe8bcb6, 0xe8bcae, 0xe8bcb5, + /* cc */ 0xe8bcb2, 0xe8bcb9, 0xe8bcb7, 0xe8bcb4, + /* d0 */ 0xe981b6, 0xe981b9, 0xe981bb, 0xe98286, + /* d4 */ 0xe983ba, 0xe984b3, 0xe984b5, 0xe984b6, + /* d8 */ 0xe98693, 0xe98690, 0xe98691, 0xe9868d, + /* dc */ 0xe9868f, 0xe98ca7, 0xe98c9e, 0xe98c88, + /* e0 */ 0xe98c9f, 0xe98c86, 0xe98c8f, 0xe98dba, + /* e4 */ 0xe98cb8, 0xe98cbc, 0xe98c9b, 0xe98ca3, + /* e8 */ 0xe98c92, 0xe98c81, 0xe98d86, 0xe98cad, + /* ec */ 0xe98c8e, 0xe98c8d, 0xe98b8b, 0xe98c9d, + /* f0 */ 0xe98bba, 0xe98ca5, 0xe98c93, 0xe98bb9, + /* f4 */ 0xe98bb7, 0xe98cb4, 0xe98c82, 0xe98ca4, + /* f8 */ 0xe98bbf, 0xe98ca9, 0xe98cb9, 0xe98cb5, + /* fc */ 0xe98caa, 0xe98c94, 0xe98c8c, + + /*** Two byte table, leaf: ecxx - offset 0x0384e ***/ + + /* 40 */ 0xe98c8b, 0xe98bbe, 0xe98c89, 0xe98c80, + /* 44 */ 0xe98bbb, 0xe98c96, 0xe996bc, 0xe9978d, + /* 48 */ 0xe996be, 0xe996b9, 0xe996ba, 0xe996b6, + /* 4c */ 0xe996bf, 0xe996b5, 0xe996bd, 0xe99aa9, + /* 50 */ 0xe99b94, 0xe99c8b, 0xe99c92, 0xe99c90, + /* 54 */ 0xe99e99, 0xe99e97, 0xe99e94, 0xe99fb0, + /* 58 */ 0xe99fb8, 0xe9a0b5, 0xe9a0af, 0xe9a0b2, + /* 5c */ 0xe9a4a4, 0xe9a49f, 0xe9a4a7, 0xe9a4a9, + /* 60 */ 0xe9a69e, 0xe9a7ae, 0xe9a7ac, 0xe9a7a5, + /* 64 */ 0xe9a7a4, 0xe9a7b0, 0xe9a7a3, 0xe9a7aa, + /* 68 */ 0xe9a7a9, 0xe9a7a7, 0xe9aab9, 0xe9aabf, + /* 6c */ 0xe9aab4, 0xe9aabb, 0xe9abb6, 0xe9abba, + /* 70 */ 0xe9abb9, 0xe9abb7, 0xe9acb3, 0xe9ae80, + /* 74 */ 0xe9ae85, 0xe9ae87, 0xe9adbc, 0xe9adbe, + /* 78 */ 0xe9adbb, 0xe9ae82, 0xe9ae93, 0xe9ae92, + /* 7c */ 0xe9ae90, 0xe9adba, 0xe9ae95, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9adbd, 0xe9ae88, 0xe9b4a5, + /* a4 */ 0xe9b497, 0xe9b4a0, 0xe9b49e, 0xe9b494, + /* a8 */ 0xe9b4a9, 0xe9b49d, 0xe9b498, 0xe9b4a2, + /* ac */ 0xe9b490, 0xe9b499, 0xe9b49f, 0xe9ba88, + /* b0 */ 0xe9ba86, 0xe9ba87, 0xe9baae, 0xe9baad, + /* b4 */ 0xe9bb95, 0xe9bb96, 0xe9bbba, 0xe9bc92, + /* b8 */ 0xe9bcbd, 0xe584a6, 0xe584a5, 0xe584a2, + /* bc */ 0xe584a4, 0xe584a0, 0xe584a9, 0xe58bb4, + /* c0 */ 0xe59a93, 0xe59a8c, 0xe59a8d, 0xe59a86, + /* c4 */ 0xe59a84, 0xe59a83, 0xe599be, 0xe59a82, + /* c8 */ 0xe599bf, 0xe59a81, 0xe5a396, 0xe5a394, + /* cc */ 0xe5a38f, 0xe5a392, 0xe5acad, 0xe5aca5, + /* d0 */ 0xe5acb2, 0xe5aca3, 0xe5acac, 0xe5aca7, + /* d4 */ 0xe5aca6, 0xe5acaf, 0xe5acae, 0xe5adbb, + /* d8 */ 0xe5afb1, 0xe5afb2, 0xe5b6b7, 0xe5b9ac, + /* dc */ 0xe5b9aa, 0xe5bebe, 0xe5bebb, 0xe68783, + /* e0 */ 0xe686b5, 0xe686bc, 0xe687a7, 0xe687a0, + /* e4 */ 0xe687a5, 0xe687a4, 0xe687a8, 0xe6879e, + /* e8 */ 0xe693af, 0xe693a9, 0xe693a3, 0xe693ab, + /* ec */ 0xe693a4, 0xe693a8, 0xe69681, 0xe69680, + /* f0 */ 0xe696b6, 0xe6979a, 0xe69b92, 0xe6aa8d, + /* f4 */ 0xe6aa96, 0xe6aa81, 0xe6aaa5, 0xe6aa89, + /* f8 */ 0xe6aa9f, 0xe6aa9b, 0xe6aaa1, 0xe6aa9e, + /* fc */ 0xe6aa87, 0xe6aa93, 0xe6aa8e, + + /*** Two byte table, leaf: edxx - offset 0x0390d ***/ + + /* 40 */ 0xe6aa95, 0xe6aa83, 0xe6aaa8, 0xe6aaa4, + /* 44 */ 0xe6aa91, 0xe6a9bf, 0xe6aaa6, 0xe6aa9a, + /* 48 */ 0xe6aa85, 0xe6aa8c, 0xe6aa92, 0xe6ad9b, + /* 4c */ 0xe6aead, 0xe6b089, 0xe6bf8c, 0xe6bea9, + /* 50 */ 0xe6bfb4, 0xe6bf94, 0xe6bfa3, 0xe6bf9c, + /* 54 */ 0xe6bfad, 0xe6bfa7, 0xe6bfa6, 0xe6bf9e, + /* 58 */ 0xe6bfb2, 0xe6bf9d, 0xe6bfa2, 0xe6bfa8, + /* 5c */ 0xe787a1, 0xe787b1, 0xe787a8, 0xe787b2, + /* 60 */ 0xe787a4, 0xe787b0, 0xe787a2, 0xe78db3, + /* 64 */ 0xe78dae, 0xe78daf, 0xe79297, 0xe792b2, + /* 68 */ 0xe792ab, 0xe79290, 0xe792aa, 0xe792ad, + /* 6c */ 0xe792b1, 0xe792a5, 0xe792af, 0xe79490, + /* 70 */ 0xe79491, 0xe79492, 0xe7948f, 0xe79684, + /* 74 */ 0xe79983, 0xe79988, 0xe79989, 0xe79987, + /* 78 */ 0xe79aa4, 0xe79ba9, 0xe79eb5, 0xe79eab, + /* 7c */ 0xe79eb2, 0xe79eb7, 0xe79eb6, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe79eb4, 0xe79eb1, 0xe79ea8, + /* a4 */ 0xe79fb0, 0xe7a3b3, 0xe7a3bd, 0xe7a482, + /* a8 */ 0xe7a3bb, 0xe7a3bc, 0xe7a3b2, 0xe7a485, + /* ac */ 0xe7a3b9, 0xe7a3be, 0xe7a484, 0xe7a6ab, + /* b0 */ 0xe7a6a8, 0xe7a99c, 0xe7a99b, 0xe7a996, + /* b4 */ 0xe7a998, 0xe7a994, 0xe7a99a, 0xe7aabe, + /* b8 */ 0xe7ab80, 0xe7ab81, 0xe7b085, 0xe7b08f, + /* bc */ 0xe7afb2, 0xe7b080, 0xe7afbf, 0xe7afbb, + /* c0 */ 0xe7b08e, 0xe7afb4, 0xe7b08b, 0xe7afb3, + /* c4 */ 0xe7b082, 0xe7b089, 0xe7b083, 0xe7b081, + /* c8 */ 0xe7afb8, 0xe7afbd, 0xe7b086, 0xe7afb0, + /* cc */ 0xe7afb1, 0xe7b090, 0xe7b08a, 0xe7b3a8, + /* d0 */ 0xe7b8ad, 0xe7b8bc, 0xe7b982, 0xe7b8b3, + /* d4 */ 0xe9a188, 0xe7b8b8, 0xe7b8aa, 0xe7b989, + /* d8 */ 0xe7b980, 0xe7b987, 0xe7b8a9, 0xe7b98c, + /* dc */ 0xe7b8b0, 0xe7b8bb, 0xe7b8b6, 0xe7b984, + /* e0 */ 0xe7b8ba, 0xe7bd85, 0xe7bdbf, 0xe7bdbe, + /* e4 */ 0xe7bdbd, 0xe7bfb4, 0xe7bfb2, 0xe880ac, + /* e8 */ 0xe886bb, 0xe88784, 0xe8878c, 0xe8878a, + /* ec */ 0xe88785, 0xe88787, 0xe886bc, 0xe887a9, + /* f0 */ 0xe8899b, 0xe8899a, 0xe8899c, 0xe89683, + /* f4 */ 0xe89680, 0xe8968f, 0xe896a7, 0xe89695, + /* f8 */ 0xe896a0, 0xe8968b, 0xe896a3, 0xe895bb, + /* fc */ 0xe896a4, 0xe8969a, 0xe8969e, + + /*** Two byte table, leaf: eexx - offset 0x039cc ***/ + + /* 40 */ 0xe895b7, 0xe895bc, 0xe89689, 0xe896a1, + /* 44 */ 0xe895ba, 0xe895b8, 0xe89597, 0xe8968e, + /* 48 */ 0xe89696, 0xe89686, 0xe8968d, 0xe89699, + /* 4c */ 0xe8969d, 0xe89681, 0xe896a2, 0xe89682, + /* 50 */ 0xe89688, 0xe89685, 0xe895b9, 0xe895b6, + /* 54 */ 0xe89698, 0xe89690, 0xe8969f, 0xe899a8, + /* 58 */ 0xe89ebe, 0xe89eaa, 0xe89ead, 0xe89f85, + /* 5c */ 0xe89eb0, 0xe89eac, 0xe89eb9, 0xe89eb5, + /* 60 */ 0xe89ebc, 0xe89eae, 0xe89f89, 0xe89f83, + /* 64 */ 0xe89f82, 0xe89f8c, 0xe89eb7, 0xe89eaf, + /* 68 */ 0xe89f84, 0xe89f8a, 0xe89eb4, 0xe89eb6, + /* 6c */ 0xe89ebf, 0xe89eb8, 0xe89ebd, 0xe89f9e, + /* 70 */ 0xe89eb2, 0xe8a4b5, 0xe8a4b3, 0xe8a4bc, + /* 74 */ 0xe8a4be, 0xe8a581, 0xe8a592, 0xe8a4b7, + /* 78 */ 0xe8a582, 0xe8a6ad, 0xe8a6af, 0xe8a6ae, + /* 7c */ 0xe8a7b2, 0xe8a7b3, 0xe8ac9e, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe8ac98, 0xe8ac96, 0xe8ac91, + /* a4 */ 0xe8ac85, 0xe8ac8b, 0xe8aca2, 0xe8ac8f, + /* a8 */ 0xe8ac92, 0xe8ac95, 0xe8ac87, 0xe8ac8d, + /* ac */ 0xe8ac88, 0xe8ac86, 0xe8ac9c, 0xe8ac93, + /* b0 */ 0xe8ac9a, 0xe8b18f, 0xe8b1b0, 0xe8b1b2, + /* b4 */ 0xe8b1b1, 0xe8b1af, 0xe8b295, 0xe8b294, + /* b8 */ 0xe8b3b9, 0xe8b5af, 0xe8b98e, 0xe8b98d, + /* bc */ 0xe8b993, 0xe8b990, 0xe8b98c, 0xe8b987, + /* c0 */ 0xe8bd83, 0xe8bd80, 0xe98285, 0xe981be, + /* c4 */ 0xe984b8, 0xe9869a, 0xe986a2, 0xe9869b, + /* c8 */ 0xe98699, 0xe9869f, 0xe986a1, 0xe9869d, + /* cc */ 0xe986a0, 0xe98ea1, 0xe98e83, 0xe98eaf, + /* d0 */ 0xe98da4, 0xe98d96, 0xe98d87, 0xe98dbc, + /* d4 */ 0xe98d98, 0xe98d9c, 0xe98db6, 0xe98d89, + /* d8 */ 0xe98d90, 0xe98d91, 0xe98da0, 0xe98dad, + /* dc */ 0xe98e8f, 0xe98d8c, 0xe98daa, 0xe98db9, + /* e0 */ 0xe98d97, 0xe98d95, 0xe98d92, 0xe98d8f, + /* e4 */ 0xe98db1, 0xe98db7, 0xe98dbb, 0xe98da1, + /* e8 */ 0xe98d9e, 0xe98da3, 0xe98da7, 0xe98e80, + /* ec */ 0xe98d8e, 0xe98d99, 0xe99787, 0xe99780, + /* f0 */ 0xe99789, 0xe99783, 0xe99785, 0xe996b7, + /* f4 */ 0xe99aae, 0xe99ab0, 0xe99aac, 0xe99ca0, + /* f8 */ 0xe99c9f, 0xe99c98, 0xe99c9d, 0xe99c99, + /* fc */ 0xe99e9a, 0xe99ea1, 0xe99e9c, + + /*** Two byte table, leaf: efxx - offset 0x03a8b ***/ + + /* 40 */ 0xe99e9e, 0xe99e9d, 0xe99f95, 0xe99f94, + /* 44 */ 0xe99fb1, 0xe9a181, 0xe9a184, 0xe9a18a, + /* 48 */ 0xe9a189, 0xe9a185, 0xe9a183, 0xe9a4a5, + /* 4c */ 0xe9a4ab, 0xe9a4ac, 0xe9a4aa, 0xe9a4b3, + /* 50 */ 0xe9a4b2, 0xe9a4af, 0xe9a4ad, 0xe9a4b1, + /* 54 */ 0xe9a4b0, 0xe9a698, 0xe9a6a3, 0xe9a6a1, + /* 58 */ 0xe9a882, 0xe9a7ba, 0xe9a7b4, 0xe9a7b7, + /* 5c */ 0xe9a7b9, 0xe9a7b8, 0xe9a7b6, 0xe9a7bb, + /* 60 */ 0xe9a7bd, 0xe9a7be, 0xe9a7bc, 0xe9a883, + /* 64 */ 0xe9aabe, 0xe9abbe, 0xe9abbd, 0xe9ac81, + /* 68 */ 0xe9abbc, 0xe9ad88, 0xe9ae9a, 0xe9aea8, + /* 6c */ 0xe9ae9e, 0xe9ae9b, 0xe9aea6, 0xe9aea1, + /* 70 */ 0xe9aea5, 0xe9aea4, 0xe9ae86, 0xe9aea2, + /* 74 */ 0xe9aea0, 0xe9aeaf, 0xe9b4b3, 0xe9b581, + /* 78 */ 0xe9b5a7, 0xe9b4b6, 0xe9b4ae, 0xe9b4af, + /* 7c */ 0xe9b4b1, 0xe9b4b8, 0xe9b4b0, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9b585, 0xe9b582, 0xe9b583, + /* a4 */ 0xe9b4be, 0xe9b4b7, 0xe9b580, 0xe9b4bd, + /* a8 */ 0xe7bfb5, 0xe9b4ad, 0xe9ba8a, 0xe9ba89, + /* ac */ 0xe9ba8d, 0xe9bab0, 0xe9bb88, 0xe9bb9a, + /* b0 */ 0xe9bbbb, 0xe9bbbf, 0xe9bca4, 0xe9bca3, + /* b4 */ 0xe9bca2, 0xe9bd94, 0xe9bea0, 0xe584b1, + /* b8 */ 0xe584ad, 0xe584ae, 0xe59a98, 0xe59a9c, + /* bc */ 0xe59a97, 0xe59a9a, 0xe59a9d, 0xe59a99, + /* c0 */ 0xe5a5b0, 0xe5acbc, 0xe5b1a9, 0xe5b1aa, + /* c4 */ 0xe5b780, 0xe5b9ad, 0xe5b9ae, 0xe68798, + /* c8 */ 0xe6879f, 0xe687ad, 0xe687ae, 0xe687b1, + /* cc */ 0xe687aa, 0xe687b0, 0xe687ab, 0xe68796, + /* d0 */ 0xe687a9, 0xe693bf, 0xe69484, 0xe693bd, + /* d4 */ 0xe693b8, 0xe69481, 0xe69483, 0xe693bc, + /* d8 */ 0xe69694, 0xe6979b, 0xe69b9a, 0xe69b9b, + /* dc */ 0xe69b98, 0xe6ab85, 0xe6aab9, 0xe6aabd, + /* e0 */ 0xe6aba1, 0xe6ab86, 0xe6aaba, 0xe6aab6, + /* e4 */ 0xe6aab7, 0xe6ab87, 0xe6aab4, 0xe6aaad, + /* e8 */ 0xe6ad9e, 0xe6af89, 0xe6b08b, 0xe78087, + /* ec */ 0xe7808c, 0xe7808d, 0xe78081, 0xe78085, + /* f0 */ 0xe78094, 0xe7808e, 0xe6bfbf, 0xe78080, + /* f4 */ 0xe6bfbb, 0xe780a6, 0xe6bfbc, 0xe6bfb7, + /* f8 */ 0xe7808a, 0xe78881, 0xe787bf, 0xe787b9, + /* fc */ 0xe78883, 0xe787bd, 0xe78db6, + + /*** Two byte table, leaf: f0xx - offset 0x03b4a ***/ + + /* 40 */ 0xe792b8, 0xe79380, 0xe792b5, 0xe79381, + /* 44 */ 0xe792be, 0xe792b6, 0xe792bb, 0xe79382, + /* 48 */ 0xe79494, 0xe79493, 0xe7999c, 0xe799a4, + /* 4c */ 0xe79999, 0xe79990, 0xe79993, 0xe79997, + /* 50 */ 0xe7999a, 0xe79aa6, 0xe79abd, 0xe79bac, + /* 54 */ 0xe79f82, 0xe79eba, 0xe7a3bf, 0xe7a48c, + /* 58 */ 0xe7a493, 0xe7a494, 0xe7a489, 0xe7a490, + /* 5c */ 0xe7a492, 0xe7a491, 0xe7a6ad, 0xe7a6ac, + /* 60 */ 0xe7a99f, 0xe7b09c, 0xe7b0a9, 0xe7b099, + /* 64 */ 0xe7b0a0, 0xe7b09f, 0xe7b0ad, 0xe7b09d, + /* 68 */ 0xe7b0a6, 0xe7b0a8, 0xe7b0a2, 0xe7b0a5, + /* 6c */ 0xe7b0b0, 0xe7b99c, 0xe7b990, 0xe7b996, + /* 70 */ 0xe7b9a3, 0xe7b998, 0xe7b9a2, 0xe7b99f, + /* 74 */ 0xe7b991, 0xe7b9a0, 0xe7b997, 0xe7b993, + /* 78 */ 0xe7beb5, 0xe7beb3, 0xe7bfb7, 0xe7bfb8, + /* 7c */ 0xe881b5, 0xe88791, 0xe88792, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe88790, 0xe8899f, 0xe8899e, + /* a4 */ 0xe896b4, 0xe89786, 0xe89780, 0xe89783, + /* a8 */ 0xe89782, 0xe896b3, 0xe896b5, 0xe896bd, + /* ac */ 0xe89787, 0xe89784, 0xe896bf, 0xe8978b, + /* b0 */ 0xe8978e, 0xe89788, 0xe89785, 0xe896b1, + /* b4 */ 0xe896b6, 0xe89792, 0xe898a4, 0xe896b8, + /* b8 */ 0xe896b7, 0xe896be, 0xe899a9, 0xe89fa7, + /* bc */ 0xe89fa6, 0xe89fa2, 0xe89f9b, 0xe89fab, + /* c0 */ 0xe89faa, 0xe89fa5, 0xe89f9f, 0xe89fb3, + /* c4 */ 0xe89fa4, 0xe89f94, 0xe89f9c, 0xe89f93, + /* c8 */ 0xe89fad, 0xe89f98, 0xe89fa3, 0xe89ea4, + /* cc */ 0xe89f97, 0xe89f99, 0xe8a081, 0xe89fb4, + /* d0 */ 0xe89fa8, 0xe89f9d, 0xe8a593, 0xe8a58b, + /* d4 */ 0xe8a58f, 0xe8a58c, 0xe8a586, 0xe8a590, + /* d8 */ 0xe8a591, 0xe8a589, 0xe8acaa, 0xe8aca7, + /* dc */ 0xe8aca3, 0xe8acb3, 0xe8acb0, 0xe8acb5, + /* e0 */ 0xe8ad87, 0xe8acaf, 0xe8acbc, 0xe8acbe, + /* e4 */ 0xe8acb1, 0xe8aca5, 0xe8acb7, 0xe8aca6, + /* e8 */ 0xe8acb6, 0xe8acae, 0xe8aca4, 0xe8acbb, + /* ec */ 0xe8acbd, 0xe8acba, 0xe8b182, 0xe8b1b5, + /* f0 */ 0xe8b299, 0xe8b298, 0xe8b297, 0xe8b3be, + /* f4 */ 0xe8b484, 0xe8b482, 0xe8b480, 0xe8b99c, + /* f8 */ 0xe8b9a2, 0xe8b9a0, 0xe8b997, 0xe8b996, + /* fc */ 0xe8b99e, 0xe8b9a5, 0xe8b9a7, + + /*** Two byte table, leaf: f1xx - offset 0x03c09 ***/ + + /* 40 */ 0xe8b99b, 0xe8b99a, 0xe8b9a1, 0xe8b99d, + /* 44 */ 0xe8b9a9, 0xe8b994, 0xe8bd86, 0xe8bd87, + /* 48 */ 0xe8bd88, 0xe8bd8b, 0xe984a8, 0xe984ba, + /* 4c */ 0xe984bb, 0xe984be, 0xe986a8, 0xe986a5, + /* 50 */ 0xe986a7, 0xe986af, 0xe986aa, 0xe98eb5, + /* 54 */ 0xe98e8c, 0xe98e92, 0xe98eb7, 0xe98e9b, + /* 58 */ 0xe98e9d, 0xe98e89, 0xe98ea7, 0xe98e8e, + /* 5c */ 0xe98eaa, 0xe98e9e, 0xe98ea6, 0xe98e95, + /* 60 */ 0xe98e88, 0xe98e99, 0xe98e9f, 0xe98e8d, + /* 64 */ 0xe98eb1, 0xe98e91, 0xe98eb2, 0xe98ea4, + /* 68 */ 0xe98ea8, 0xe98eb4, 0xe98ea3, 0xe98ea5, + /* 6c */ 0xe99792, 0xe99793, 0xe99791, 0xe99ab3, + /* 70 */ 0xe99b97, 0xe99b9a, 0xe5b782, 0xe99b9f, + /* 74 */ 0xe99b98, 0xe99b9d, 0xe99ca3, 0xe99ca2, + /* 78 */ 0xe99ca5, 0xe99eac, 0xe99eae, 0xe99ea8, + /* 7c */ 0xe99eab, 0xe99ea4, 0xe99eaa, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe99ea2, 0xe99ea5, 0xe99f97, + /* a4 */ 0xe99f99, 0xe99f96, 0xe99f98, 0xe99fba, + /* a8 */ 0xe9a190, 0xe9a191, 0xe9a192, 0xe9a2b8, + /* ac */ 0xe9a581, 0xe9a4bc, 0xe9a4ba, 0xe9a88f, + /* b0 */ 0xe9a88b, 0xe9a889, 0xe9a88d, 0xe9a884, + /* b4 */ 0xe9a891, 0xe9a88a, 0xe9a885, 0xe9a887, + /* b8 */ 0xe9a886, 0xe9ab80, 0xe9ab9c, 0xe9ac88, + /* bc */ 0xe9ac84, 0xe9ac85, 0xe9aca9, 0xe9acb5, + /* c0 */ 0xe9ad8a, 0xe9ad8c, 0xe9ad8b, 0xe9af87, + /* c4 */ 0xe9af86, 0xe9af83, 0xe9aebf, 0xe9af81, + /* c8 */ 0xe9aeb5, 0xe9aeb8, 0xe9af93, 0xe9aeb6, + /* cc */ 0xe9af84, 0xe9aeb9, 0xe9aebd, 0xe9b59c, + /* d0 */ 0xe9b593, 0xe9b58f, 0xe9b58a, 0xe9b59b, + /* d4 */ 0xe9b58b, 0xe9b599, 0xe9b596, 0xe9b58c, + /* d8 */ 0xe9b597, 0xe9b592, 0xe9b594, 0xe9b59f, + /* dc */ 0xe9b598, 0xe9b59a, 0xe9ba8e, 0xe9ba8c, + /* e0 */ 0xe9bb9f, 0xe9bc81, 0xe9bc80, 0xe9bc96, + /* e4 */ 0xe9bca5, 0xe9bcab, 0xe9bcaa, 0xe9bca9, + /* e8 */ 0xe9bca8, 0xe9bd8c, 0xe9bd95, 0xe584b4, + /* ec */ 0xe584b5, 0xe58a96, 0xe58bb7, 0xe58eb4, + /* f0 */ 0xe59aab, 0xe59aad, 0xe59aa6, 0xe59aa7, + /* f4 */ 0xe59aaa, 0xe59aac, 0xe5a39a, 0xe5a39d, + /* f8 */ 0xe5a39b, 0xe5a492, 0xe5acbd, 0xe5acbe, + /* fc */ 0xe5acbf, 0xe5b783, 0xe5b9b0, + + /*** Two byte table, leaf: f2xx - offset 0x03cc8 ***/ + + /* 40 */ 0xe5bebf, 0xe687bb, 0xe69487, 0xe69490, + /* 44 */ 0xe6948d, 0xe69489, 0xe6948c, 0xe6948e, + /* 48 */ 0xe69684, 0xe6979e, 0xe6979d, 0xe69b9e, + /* 4c */ 0xe6aba7, 0xe6aba0, 0xe6ab8c, 0xe6ab91, + /* 50 */ 0xe6ab99, 0xe6ab8b, 0xe6ab9f, 0xe6ab9c, + /* 54 */ 0xe6ab90, 0xe6abab, 0xe6ab8f, 0xe6ab8d, + /* 58 */ 0xe6ab9e, 0xe6ada0, 0xe6aeb0, 0xe6b08c, + /* 5c */ 0xe78099, 0xe780a7, 0xe780a0, 0xe78096, + /* 60 */ 0xe780ab, 0xe780a1, 0xe780a2, 0xe780a3, + /* 64 */ 0xe780a9, 0xe78097, 0xe780a4, 0xe7809c, + /* 68 */ 0xe780aa, 0xe7888c, 0xe7888a, 0xe78887, + /* 6c */ 0xe78882, 0xe78885, 0xe78aa5, 0xe78aa6, + /* 70 */ 0xe78aa4, 0xe78aa3, 0xe78aa1, 0xe7938b, + /* 74 */ 0xe79385, 0xe792b7, 0xe79383, 0xe79496, + /* 78 */ 0xe799a0, 0xe79f89, 0xe79f8a, 0xe79f84, + /* 7c */ 0xe79fb1, 0xe7a49d, 0xe7a49b, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7a4a1, 0xe7a49c, 0xe7a497, + /* a4 */ 0xe7a49e, 0xe7a6b0, 0xe7a9a7, 0xe7a9a8, + /* a8 */ 0xe7b0b3, 0xe7b0bc, 0xe7b0b9, 0xe7b0ac, + /* ac */ 0xe7b0bb, 0xe7b3ac, 0xe7b3aa, 0xe7b9b6, + /* b0 */ 0xe7b9b5, 0xe7b9b8, 0xe7b9b0, 0xe7b9b7, + /* b4 */ 0xe7b9af, 0xe7b9ba, 0xe7b9b2, 0xe7b9b4, + /* b8 */ 0xe7b9a8, 0xe7bd8b, 0xe7bd8a, 0xe7be83, + /* bc */ 0xe7be86, 0xe7beb7, 0xe7bfbd, 0xe7bfbe, + /* c0 */ 0xe881b8, 0xe88797, 0xe88795, 0xe889a4, + /* c4 */ 0xe889a1, 0xe889a3, 0xe897ab, 0xe897b1, + /* c8 */ 0xe897ad, 0xe89799, 0xe897a1, 0xe897a8, + /* cc */ 0xe8979a, 0xe89797, 0xe897ac, 0xe897b2, + /* d0 */ 0xe897b8, 0xe89798, 0xe8979f, 0xe897a3, + /* d4 */ 0xe8979c, 0xe89791, 0xe897b0, 0xe897a6, + /* d8 */ 0xe897af, 0xe8979e, 0xe897a2, 0xe8a080, + /* dc */ 0xe89fba, 0xe8a083, 0xe89fb6, 0xe89fb7, + /* e0 */ 0xe8a089, 0xe8a08c, 0xe8a08b, 0xe8a086, + /* e4 */ 0xe89fbc, 0xe8a088, 0xe89fbf, 0xe8a08a, + /* e8 */ 0xe8a082, 0xe8a5a2, 0xe8a59a, 0xe8a59b, + /* ec */ 0xe8a597, 0xe8a5a1, 0xe8a59c, 0xe8a598, + /* f0 */ 0xe8a59d, 0xe8a599, 0xe8a688, 0xe8a6b7, + /* f4 */ 0xe8a6b6, 0xe8a7b6, 0xe8ad90, 0xe8ad88, + /* f8 */ 0xe8ad8a, 0xe8ad80, 0xe8ad93, 0xe8ad96, + /* fc */ 0xe8ad94, 0xe8ad8b, 0xe8ad95, + + /*** Two byte table, leaf: f3xx - offset 0x03d87 ***/ + + /* 40 */ 0xe8ad91, 0xe8ad82, 0xe8ad92, 0xe8ad97, + /* 44 */ 0xe8b183, 0xe8b1b7, 0xe8b1b6, 0xe8b29a, + /* 48 */ 0xe8b486, 0xe8b487, 0xe8b489, 0xe8b6ac, + /* 4c */ 0xe8b6aa, 0xe8b6ad, 0xe8b6ab, 0xe8b9ad, + /* 50 */ 0xe8b9b8, 0xe8b9b3, 0xe8b9aa, 0xe8b9af, + /* 54 */ 0xe8b9bb, 0xe8bb82, 0xe8bd92, 0xe8bd91, + /* 58 */ 0xe8bd8f, 0xe8bd90, 0xe8bd93, 0xe8beb4, + /* 5c */ 0xe98580, 0xe984bf, 0xe986b0, 0xe986ad, + /* 60 */ 0xe98f9e, 0xe98f87, 0xe98f8f, 0xe98f82, + /* 64 */ 0xe98f9a, 0xe98f90, 0xe98fb9, 0xe98fac, + /* 68 */ 0xe98f8c, 0xe98f99, 0xe98ea9, 0xe98fa6, + /* 6c */ 0xe98f8a, 0xe98f94, 0xe98fae, 0xe98fa3, + /* 70 */ 0xe98f95, 0xe98f84, 0xe98f8e, 0xe98f80, + /* 74 */ 0xe98f92, 0xe98fa7, 0xe995bd, 0xe9979a, + /* 78 */ 0xe9979b, 0xe99ba1, 0xe99ca9, 0xe99cab, + /* 7c */ 0xe99cac, 0xe99ca8, 0xe99ca6, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe99eb3, 0xe99eb7, 0xe99eb6, + /* a4 */ 0xe99f9d, 0xe99f9e, 0xe99f9f, 0xe9a19c, + /* a8 */ 0xe9a199, 0xe9a19d, 0xe9a197, 0xe9a2bf, + /* ac */ 0xe9a2bd, 0xe9a2bb, 0xe9a2be, 0xe9a588, + /* b0 */ 0xe9a587, 0xe9a583, 0xe9a6a6, 0xe9a6a7, + /* b4 */ 0xe9a89a, 0xe9a895, 0xe9a8a5, 0xe9a89d, + /* b8 */ 0xe9a8a4, 0xe9a89b, 0xe9a8a2, 0xe9a8a0, + /* bc */ 0xe9a8a7, 0xe9a8a3, 0xe9a89e, 0xe9a89c, + /* c0 */ 0xe9a894, 0xe9ab82, 0xe9ac8b, 0xe9ac8a, + /* c4 */ 0xe9ac8e, 0xe9ac8c, 0xe9acb7, 0xe9afaa, + /* c8 */ 0xe9afab, 0xe9afa0, 0xe9af9e, 0xe9afa4, + /* cc */ 0xe9afa6, 0xe9afa2, 0xe9afb0, 0xe9af94, + /* d0 */ 0xe9af97, 0xe9afac, 0xe9af9c, 0xe9af99, + /* d4 */ 0xe9afa5, 0xe9af95, 0xe9afa1, 0xe9af9a, + /* d8 */ 0xe9b5b7, 0xe9b681, 0xe9b68a, 0xe9b684, + /* dc */ 0xe9b688, 0xe9b5b1, 0xe9b680, 0xe9b5b8, + /* e0 */ 0xe9b686, 0xe9b68b, 0xe9b68c, 0xe9b5bd, + /* e4 */ 0xe9b5ab, 0xe9b5b4, 0xe9b5b5, 0xe9b5b0, + /* e8 */ 0xe9b5a9, 0xe9b685, 0xe9b5b3, 0xe9b5bb, + /* ec */ 0xe9b682, 0xe9b5af, 0xe9b5b9, 0xe9b5bf, + /* f0 */ 0xe9b687, 0xe9b5a8, 0xe9ba94, 0xe9ba91, + /* f4 */ 0xe9bb80, 0xe9bbbc, 0xe9bcad, 0xe9bd80, + /* f8 */ 0xe9bd81, 0xe9bd8d, 0xe9bd96, 0xe9bd97, + /* fc */ 0xe9bd98, 0xe58cb7, 0xe59ab2, + + /*** Two byte table, leaf: f4xx - offset 0x03e46 ***/ + + /* 40 */ 0xe59ab5, 0xe59ab3, 0xe5a3a3, 0xe5ad85, + /* 44 */ 0xe5b786, 0xe5b787, 0xe5bbae, 0xe5bbaf, + /* 48 */ 0xe5bf80, 0xe5bf81, 0xe687b9, 0xe69497, + /* 4c */ 0xe69496, 0xe69495, 0xe69493, 0xe6979f, + /* 50 */ 0xe69ba8, 0xe69ba3, 0xe69ba4, 0xe6abb3, + /* 54 */ 0xe6abb0, 0xe6abaa, 0xe6aba8, 0xe6abb9, + /* 58 */ 0xe6abb1, 0xe6abae, 0xe6abaf, 0xe780bc, + /* 5c */ 0xe780b5, 0xe780af, 0xe780b7, 0xe780b4, + /* 60 */ 0xe780b1, 0xe78182, 0xe780b8, 0xe780bf, + /* 64 */ 0xe780ba, 0xe780b9, 0xe78180, 0xe780bb, + /* 68 */ 0xe780b3, 0xe78181, 0xe78893, 0xe78894, + /* 6c */ 0xe78aa8, 0xe78dbd, 0xe78dbc, 0xe792ba, + /* 70 */ 0xe79aab, 0xe79aaa, 0xe79abe, 0xe79bad, + /* 74 */ 0xe79f8c, 0xe79f8e, 0xe79f8f, 0xe79f8d, + /* 78 */ 0xe79fb2, 0xe7a4a5, 0xe7a4a3, 0xe7a4a7, + /* 7c */ 0xe7a4a8, 0xe7a4a4, 0xe7a4a9, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe7a6b2, 0xe7a9ae, 0xe7a9ac, + /* a4 */ 0xe7a9ad, 0xe7abb7, 0xe7b189, 0xe7b188, + /* a8 */ 0xe7b18a, 0xe7b187, 0xe7b185, 0xe7b3ae, + /* ac */ 0xe7b9bb, 0xe7b9be, 0xe7ba81, 0xe7ba80, + /* b0 */ 0xe7beba, 0xe7bfbf, 0xe881b9, 0xe8879b, + /* b4 */ 0xe88799, 0xe8888b, 0xe889a8, 0xe889a9, + /* b8 */ 0xe898a2, 0xe897bf, 0xe89881, 0xe897be, + /* bc */ 0xe8989b, 0xe89880, 0xe897b6, 0xe89884, + /* c0 */ 0xe89889, 0xe89885, 0xe8988c, 0xe897bd, + /* c4 */ 0xe8a099, 0xe8a090, 0xe8a091, 0xe8a097, + /* c8 */ 0xe8a093, 0xe8a096, 0xe8a5a3, 0xe8a5a6, + /* cc */ 0xe8a6b9, 0xe8a7b7, 0xe8ada0, 0xe8adaa, + /* d0 */ 0xe8ad9d, 0xe8ada8, 0xe8ada3, 0xe8ada5, + /* d4 */ 0xe8ada7, 0xe8adad, 0xe8b6ae, 0xe8ba86, + /* d8 */ 0xe8ba88, 0xe8ba84, 0xe8bd99, 0xe8bd96, + /* dc */ 0xe8bd97, 0xe8bd95, 0xe8bd98, 0xe8bd9a, + /* e0 */ 0xe9828d, 0xe98583, 0xe98581, 0xe986b7, + /* e4 */ 0xe986b5, 0xe986b2, 0xe986b3, 0xe9908b, + /* e8 */ 0xe99093, 0xe98fbb, 0xe990a0, 0xe9908f, + /* ec */ 0xe99094, 0xe98fbe, 0xe99095, 0xe99090, + /* f0 */ 0xe990a8, 0xe99099, 0xe9908d, 0xe98fb5, + /* f4 */ 0xe99080, 0xe98fb7, 0xe99087, 0xe9908e, + /* f8 */ 0xe99096, 0xe99092, 0xe98fba, 0xe99089, + /* fc */ 0xe98fb8, 0xe9908a, 0xe98fbf, + + /*** Two byte table, leaf: f5xx - offset 0x03f05 ***/ + + /* 40 */ 0xe98fbc, 0xe9908c, 0xe98fb6, 0xe99091, + /* 44 */ 0xe99086, 0xe9979e, 0xe997a0, 0xe9979f, + /* 48 */ 0xe99cae, 0xe99caf, 0xe99eb9, 0xe99ebb, + /* 4c */ 0xe99fbd, 0xe99fbe, 0xe9a1a0, 0xe9a1a2, + /* 50 */ 0xe9a1a3, 0xe9a19f, 0xe9a381, 0xe9a382, + /* 54 */ 0xe9a590, 0xe9a58e, 0xe9a599, 0xe9a58c, + /* 58 */ 0xe9a58b, 0xe9a593, 0xe9a8b2, 0xe9a8b4, + /* 5c */ 0xe9a8b1, 0xe9a8ac, 0xe9a8aa, 0xe9a8b6, + /* 60 */ 0xe9a8a9, 0xe9a8ae, 0xe9a8b8, 0xe9a8ad, + /* 64 */ 0xe9ab87, 0xe9ab8a, 0xe9ab86, 0xe9ac90, + /* 68 */ 0xe9ac92, 0xe9ac91, 0xe9b08b, 0xe9b088, + /* 6c */ 0xe9afb7, 0xe9b085, 0xe9b092, 0xe9afb8, + /* 70 */ 0xe9b180, 0xe9b087, 0xe9b08e, 0xe9b086, + /* 74 */ 0xe9b097, 0xe9b094, 0xe9b089, 0xe9b69f, + /* 78 */ 0xe9b699, 0xe9b6a4, 0xe9b69d, 0xe9b692, + /* 7c */ 0xe9b698, 0xe9b690, 0xe9b69b, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9b6a0, 0xe9b694, 0xe9b69c, + /* a4 */ 0xe9b6aa, 0xe9b697, 0xe9b6a1, 0xe9b69a, + /* a8 */ 0xe9b6a2, 0xe9b6a8, 0xe9b69e, 0xe9b6a3, + /* ac */ 0xe9b6bf, 0xe9b6a9, 0xe9b696, 0xe9b6a6, + /* b0 */ 0xe9b6a7, 0xe9ba99, 0xe9ba9b, 0xe9ba9a, + /* b4 */ 0xe9bba5, 0xe9bba4, 0xe9bba7, 0xe9bba6, + /* b8 */ 0xe9bcb0, 0xe9bcae, 0xe9bd9b, 0xe9bda0, + /* bc */ 0xe9bd9e, 0xe9bd9d, 0xe9bd99, 0xe9be91, + /* c0 */ 0xe584ba, 0xe584b9, 0xe58a98, 0xe58a97, + /* c4 */ 0xe59b83, 0xe59abd, 0xe59abe, 0xe5ad88, + /* c8 */ 0xe5ad87, 0xe5b78b, 0xe5b78f, 0xe5bbb1, + /* cc */ 0xe687bd, 0xe6949b, 0xe6ac82, 0xe6abbc, + /* d0 */ 0xe6ac83, 0xe6abb8, 0xe6ac80, 0xe78183, + /* d4 */ 0xe78184, 0xe7818a, 0xe78188, 0xe78189, + /* d8 */ 0xe78185, 0xe78186, 0xe7889d, 0xe7889a, + /* dc */ 0xe78899, 0xe78dbe, 0xe79497, 0xe799aa, + /* e0 */ 0xe79f90, 0xe7a4ad, 0xe7a4b1, 0xe7a4af, + /* e4 */ 0xe7b194, 0xe7b193, 0xe7b3b2, 0xe7ba8a, + /* e8 */ 0xe7ba87, 0xe7ba88, 0xe7ba8b, 0xe7ba86, + /* ec */ 0xe7ba8d, 0xe7bd8d, 0xe7bebb, 0xe880b0, + /* f0 */ 0xe8879d, 0xe89898, 0xe898aa, 0xe898a6, + /* f4 */ 0xe8989f, 0xe898a3, 0xe8989c, 0xe89899, + /* f8 */ 0xe898a7, 0xe898ae, 0xe898a1, 0xe898a0, + /* fc */ 0xe898a9, 0xe8989e, 0xe898a5, + + /*** Two byte table, leaf: f6xx - offset 0x03fc4 ***/ + + /* 40 */ 0xe8a0a9, 0xe8a09d, 0xe8a09b, 0xe8a0a0, + /* 44 */ 0xe8a0a4, 0xe8a09c, 0xe8a0ab, 0xe8a18a, + /* 48 */ 0xe8a5ad, 0xe8a5a9, 0xe8a5ae, 0xe8a5ab, + /* 4c */ 0xe8a7ba, 0xe8adb9, 0xe8adb8, 0xe8ad85, + /* 50 */ 0xe8adba, 0xe8adbb, 0xe8b490, 0xe8b494, + /* 54 */ 0xe8b6af, 0xe8ba8e, 0xe8ba8c, 0xe8bd9e, + /* 58 */ 0xe8bd9b, 0xe8bd9d, 0xe98586, 0xe98584, + /* 5c */ 0xe98585, 0xe986b9, 0xe990bf, 0xe990bb, + /* 60 */ 0xe990b6, 0xe990a9, 0xe990bd, 0xe990bc, + /* 64 */ 0xe990b0, 0xe990b9, 0xe990aa, 0xe990b7, + /* 68 */ 0xe990ac, 0xe99180, 0xe990b1, 0xe997a5, + /* 6c */ 0xe997a4, 0xe997a3, 0xe99cb5, 0xe99cba, + /* 70 */ 0xe99ebf, 0xe99fa1, 0xe9a1a4, 0xe9a389, + /* 74 */ 0xe9a386, 0xe9a380, 0xe9a598, 0xe9a596, + /* 78 */ 0xe9a8b9, 0xe9a8bd, 0xe9a986, 0xe9a984, + /* 7c */ 0xe9a982, 0xe9a981, 0xe9a8ba, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9a8bf, 0xe9ab8d, 0xe9ac95, + /* a4 */ 0xe9ac97, 0xe9ac98, 0xe9ac96, 0xe9acba, + /* a8 */ 0xe9ad92, 0xe9b0ab, 0xe9b09d, 0xe9b09c, + /* ac */ 0xe9b0ac, 0xe9b0a3, 0xe9b0a8, 0xe9b0a9, + /* b0 */ 0xe9b0a4, 0xe9b0a1, 0xe9b6b7, 0xe9b6b6, + /* b4 */ 0xe9b6bc, 0xe9b781, 0xe9b787, 0xe9b78a, + /* b8 */ 0xe9b78f, 0xe9b6be, 0xe9b785, 0xe9b783, + /* bc */ 0xe9b6bb, 0xe9b6b5, 0xe9b78e, 0xe9b6b9, + /* c0 */ 0xe9b6ba, 0xe9b6ac, 0xe9b788, 0xe9b6b1, + /* c4 */ 0xe9b6ad, 0xe9b78c, 0xe9b6b3, 0xe9b78d, + /* c8 */ 0xe9b6b2, 0xe9b9ba, 0xe9ba9c, 0xe9bbab, + /* cc */ 0xe9bbae, 0xe9bbad, 0xe9bc9b, 0xe9bc98, + /* d0 */ 0xe9bc9a, 0xe9bcb1, 0xe9bd8e, 0xe9bda5, + /* d4 */ 0xe9bda4, 0xe9be92, 0xe4bab9, 0xe59b86, + /* d8 */ 0xe59b85, 0xe59b8b, 0xe5a5b1, 0xe5ad8b, + /* dc */ 0xe5ad8c, 0xe5b795, 0xe5b791, 0xe5bbb2, + /* e0 */ 0xe694a1, 0xe694a0, 0xe694a6, 0xe694a2, + /* e4 */ 0xe6ac8b, 0xe6ac88, 0xe6ac89, 0xe6b08d, + /* e8 */ 0xe78195, 0xe78196, 0xe78197, 0xe78192, + /* ec */ 0xe7889e, 0xe7889f, 0xe78aa9, 0xe78dbf, + /* f0 */ 0xe79398, 0xe79395, 0xe79399, 0xe79397, + /* f4 */ 0xe799ad, 0xe79aad, 0xe7a4b5, 0xe7a6b4, + /* f8 */ 0xe7a9b0, 0xe7a9b1, 0xe7b197, 0xe7b19c, + /* fc */ 0xe7b199, 0xe7b19b, 0xe7b19a, + + /*** Two byte table, leaf: f7xx - offset 0x04083 ***/ + + /* 40 */ 0xe7b3b4, 0xe7b3b1, 0xe7ba91, 0xe7bd8f, + /* 44 */ 0xe7be87, 0xe8879e, 0xe889ab, 0xe898b4, + /* 48 */ 0xe898b5, 0xe898b3, 0xe898ac, 0xe898b2, + /* 4c */ 0xe898b6, 0xe8a0ac, 0xe8a0a8, 0xe8a0a6, + /* 50 */ 0xe8a0aa, 0xe8a0a5, 0xe8a5b1, 0xe8a6bf, + /* 54 */ 0xe8a6be, 0xe8a7bb, 0xe8adbe, 0xe8ae84, + /* 58 */ 0xe8ae82, 0xe8ae86, 0xe8ae85, 0xe8adbf, + /* 5c */ 0xe8b495, 0xe8ba95, 0xe8ba94, 0xe8ba9a, + /* 60 */ 0xe8ba92, 0xe8ba90, 0xe8ba96, 0xe8ba97, + /* 64 */ 0xe8bda0, 0xe8bda2, 0xe98587, 0xe9918c, + /* 68 */ 0xe99190, 0xe9918a, 0xe9918b, 0xe9918f, + /* 6c */ 0xe99187, 0xe99185, 0xe99188, 0xe99189, + /* 70 */ 0xe99186, 0xe99cbf, 0xe99fa3, 0xe9a1aa, + /* 74 */ 0xe9a1a9, 0xe9a38b, 0xe9a594, 0xe9a59b, + /* 78 */ 0xe9a98e, 0xe9a993, 0xe9a994, 0xe9a98c, + /* 7c */ 0xe9a98f, 0xe9a988, 0xe9a98a, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9a989, 0xe9a992, 0xe9a990, + /* a4 */ 0xe9ab90, 0xe9ac99, 0xe9acab, 0xe9acbb, + /* a8 */ 0xe9ad96, 0xe9ad95, 0xe9b186, 0xe9b188, + /* ac */ 0xe9b0bf, 0xe9b184, 0xe9b0b9, 0xe9b0b3, + /* b0 */ 0xe9b181, 0xe9b0bc, 0xe9b0b7, 0xe9b0b4, + /* b4 */ 0xe9b0b2, 0xe9b0bd, 0xe9b0b6, 0xe9b79b, + /* b8 */ 0xe9b792, 0xe9b79e, 0xe9b79a, 0xe9b78b, + /* bc */ 0xe9b790, 0xe9b79c, 0xe9b791, 0xe9b79f, + /* c0 */ 0xe9b7a9, 0xe9b799, 0xe9b798, 0xe9b796, + /* c4 */ 0xe9b7b5, 0xe9b795, 0xe9b79d, 0xe9bab6, + /* c8 */ 0xe9bbb0, 0xe9bcb5, 0xe9bcb3, 0xe9bcb2, + /* cc */ 0xe9bd82, 0xe9bdab, 0xe9be95, 0xe9bea2, + /* d0 */ 0xe584bd, 0xe58a99, 0xe5a3a8, 0xe5a3a7, + /* d4 */ 0xe5a5b2, 0xe5ad8d, 0xe5b798, 0xe8a0af, + /* d8 */ 0xe5bd8f, 0xe68881, 0xe68883, 0xe68884, + /* dc */ 0xe694a9, 0xe694a5, 0xe69696, 0xe69bab, + /* e0 */ 0xe6ac91, 0xe6ac92, 0xe6ac8f, 0xe6af8a, + /* e4 */ 0xe7819b, 0xe7819a, 0xe788a2, 0xe78e82, + /* e8 */ 0xe78e81, 0xe78e83, 0xe799b0, 0xe79f94, + /* ec */ 0xe7b1a7, 0xe7b1a6, 0xe7ba95, 0xe889ac, + /* f0 */ 0xe898ba, 0xe89980, 0xe898b9, 0xe898bc, + /* f4 */ 0xe898b1, 0xe898bb, 0xe898be, 0xe8a0b0, + /* f8 */ 0xe8a0b2, 0xe8a0ae, 0xe8a0b3, 0xe8a5b6, + /* fc */ 0xe8a5b4, 0xe8a5b3, 0xe8a7be, + + /*** Two byte table, leaf: f8xx - offset 0x04142 ***/ + + /* 40 */ 0xe8ae8c, 0xe8ae8e, 0xe8ae8b, 0xe8ae88, + /* 44 */ 0xe8b185, 0xe8b499, 0xe8ba98, 0xe8bda4, + /* 48 */ 0xe8bda3, 0xe986bc, 0xe991a2, 0xe99195, + /* 4c */ 0xe9919d, 0xe99197, 0xe9919e, 0xe99f84, + /* 50 */ 0xe99f85, 0xe9a080, 0xe9a996, 0xe9a999, + /* 54 */ 0xe9ac9e, 0xe9ac9f, 0xe9aca0, 0xe9b192, + /* 58 */ 0xe9b198, 0xe9b190, 0xe9b18a, 0xe9b18d, + /* 5c */ 0xe9b18b, 0xe9b195, 0xe9b199, 0xe9b18c, + /* 60 */ 0xe9b18e, 0xe9b7bb, 0xe9b7b7, 0xe9b7af, + /* 64 */ 0xe9b7a3, 0xe9b7ab, 0xe9b7b8, 0xe9b7a4, + /* 68 */ 0xe9b7b6, 0xe9b7a1, 0xe9b7ae, 0xe9b7a6, + /* 6c */ 0xe9b7b2, 0xe9b7b0, 0xe9b7a2, 0xe9b7ac, + /* 70 */ 0xe9b7b4, 0xe9b7b3, 0xe9b7a8, 0xe9b7ad, + /* 74 */ 0xe9bb82, 0xe9bb90, 0xe9bbb2, 0xe9bbb3, + /* 78 */ 0xe9bc86, 0xe9bc9c, 0xe9bcb8, 0xe9bcb7, + /* 7c */ 0xe9bcb6, 0xe9bd83, 0xe9bd8f, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9bdb1, 0xe9bdb0, 0xe9bdae, + /* a4 */ 0xe9bdaf, 0xe59b93, 0xe59b8d, 0xe5ad8e, + /* a8 */ 0xe5b1ad, 0xe694ad, 0xe69bad, 0xe69bae, + /* ac */ 0xe6ac93, 0xe7819f, 0xe781a1, 0xe7819d, + /* b0 */ 0xe781a0, 0xe788a3, 0xe7939b, 0xe793a5, + /* b4 */ 0xe79f95, 0xe7a4b8, 0xe7a6b7, 0xe7a6b6, + /* b8 */ 0xe7b1aa, 0xe7ba97, 0xe7be89, 0xe889ad, + /* bc */ 0xe89983, 0xe8a0b8, 0xe8a0b7, 0xe8a0b5, + /* c0 */ 0xe8a18b, 0xe8ae94, 0xe8ae95, 0xe8ba9e, + /* c4 */ 0xe8ba9f, 0xe8baa0, 0xe8ba9d, 0xe986be, + /* c8 */ 0xe986bd, 0xe98782, 0xe991ab, 0xe991a8, + /* cc */ 0xe991a9, 0xe99ba5, 0xe99d86, 0xe99d83, + /* d0 */ 0xe99d87, 0xe99f87, 0xe99fa5, 0xe9a99e, + /* d4 */ 0xe9ab95, 0xe9ad99, 0xe9b1a3, 0xe9b1a7, + /* d8 */ 0xe9b1a6, 0xe9b1a2, 0xe9b19e, 0xe9b1a0, + /* dc */ 0xe9b882, 0xe9b7be, 0xe9b887, 0xe9b883, + /* e0 */ 0xe9b886, 0xe9b885, 0xe9b880, 0xe9b881, + /* e4 */ 0xe9b889, 0xe9b7bf, 0xe9b7bd, 0xe9b884, + /* e8 */ 0xe9baa0, 0xe9bc9e, 0xe9bd86, 0xe9bdb4, + /* ec */ 0xe9bdb5, 0xe9bdb6, 0xe59b94, 0xe694ae, + /* f0 */ 0xe696b8, 0xe6ac98, 0xe6ac99, 0xe6ac97, + /* f4 */ 0xe6ac9a, 0xe781a2, 0xe788a6, 0xe78aaa, + /* f8 */ 0xe79f98, 0xe79f99, 0xe7a4b9, 0xe7b1a9, + /* fc */ 0xe7b1ab, 0xe7b3b6, 0xe7ba9a, + + /*** Two byte table, leaf: f9xx - offset 0x04201 ***/ + + /* 40 */ 0xe7ba98, 0xe7ba9b, 0xe7ba99, 0xe887a0, + /* 44 */ 0xe887a1, 0xe89986, 0xe89987, 0xe89988, + /* 48 */ 0xe8a5b9, 0xe8a5ba, 0xe8a5bc, 0xe8a5bb, + /* 4c */ 0xe8a7bf, 0xe8ae98, 0xe8ae99, 0xe8baa5, + /* 50 */ 0xe8baa4, 0xe8baa3, 0xe991ae, 0xe991ad, + /* 54 */ 0xe991af, 0xe991b1, 0xe991b3, 0xe99d89, + /* 58 */ 0xe9a1b2, 0xe9a59f, 0xe9b1a8, 0xe9b1ae, + /* 5c */ 0xe9b1ad, 0xe9b88b, 0xe9b88d, 0xe9b890, + /* 60 */ 0xe9b88f, 0xe9b892, 0xe9b891, 0xe9baa1, + /* 64 */ 0xe9bbb5, 0xe9bc89, 0xe9bd87, 0xe9bdb8, + /* 68 */ 0xe9bdbb, 0xe9bdba, 0xe9bdb9, 0xe59c9e, + /* 6c */ 0xe781a6, 0xe7b1af, 0xe8a0bc, 0xe8b6b2, + /* 70 */ 0xe8baa6, 0xe98783, 0xe991b4, 0xe991b8, + /* 74 */ 0xe991b6, 0xe991b5, 0xe9a9a0, 0xe9b1b4, + /* 78 */ 0xe9b1b3, 0xe9b1b1, 0xe9b1b5, 0xe9b894, + /* 7c */ 0xe9b893, 0xe9bbb6, 0xe9bc8a, 0x000000, + /* 80 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 84 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 88 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 8c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 90 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 94 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 98 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* 9c */ 0x000000, 0x000000, 0x000000, 0x000000, + /* a0 */ 0x000000, 0xe9bea4, 0xe781a8, 0xe781a5, + /* a4 */ 0xe7b3b7, 0xe899aa, 0xe8a0be, 0xe8a0bd, + /* a8 */ 0xe8a0bf, 0xe8ae9e, 0xe8b29c, 0xe8baa9, + /* ac */ 0xe8bb89, 0xe99d8b, 0xe9a1b3, 0xe9a1b4, + /* b0 */ 0xe9a38c, 0xe9a5a1, 0xe9a6ab, 0xe9a9a4, + /* b4 */ 0xe9a9a6, 0xe9a9a7, 0xe9aca4, 0xe9b895, + /* b8 */ 0xe9b897, 0xe9bd88, 0xe68887, 0xe6ac9e, + /* bc */ 0xe788a7, 0xe8998c, 0xe8baa8, 0xe99282, + /* c0 */ 0xe99280, 0xe99281, 0xe9a9a9, 0xe9a9a8, + /* c4 */ 0xe9acae, 0xe9b899, 0xe788a9, 0xe8998b, + /* c8 */ 0xe8ae9f, 0xe99283, 0xe9b1b9, 0xe9bab7, + /* cc */ 0xe799b5, 0xe9a9ab, 0xe9b1ba, 0xe9b89d, + /* d0 */ 0xe781a9, 0xe781aa, 0xe9baa4, 0xe9bdbe, + /* d4 */ 0xe9bd89, 0xe9be98, 0xe7a281, 0xe98ab9, + /* d8 */ 0xe8a38f, 0xe5a2bb, 0xe68192, 0xe7b2a7, + /* dc */ 0xe5abba, 0x000000, 0x000000, 0x000000, + /* e0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* e4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* e8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* ec */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f0 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f4 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* f8 */ 0x000000, 0x000000, 0x000000, 0x000000, + /* fc */ 0x000000, 0x000000, 0x000000 +}; diff --git a/src/backend/utils/mb/Unicode/convutils.pm b/src/backend/utils/mb/Unicode/convutils.pm new file mode 100644 index 0000000..5ad3851 --- /dev/null +++ b/src/backend/utils/mb/Unicode/convutils.pm @@ -0,0 +1,838 @@ +# +# Copyright (c) 2001-2021, PostgreSQL Global Development Group +# +# src/backend/utils/mb/Unicode/convutils.pm + +package convutils; + +use strict; +use warnings; + +use Carp; +use Exporter 'import'; + +our @EXPORT = + qw( NONE TO_UNICODE FROM_UNICODE BOTH read_source print_conversion_tables); + +# Constants used in the 'direction' field of the character maps +use constant { + NONE => 0, + TO_UNICODE => 1, + FROM_UNICODE => 2, + BOTH => 3 +}; + +####################################################################### +# read_source - common routine to read source file +# +# fname ; input file name +# +sub read_source +{ + my ($fname) = @_; + my @r; + + open(my $in, '<', $fname) || die("cannot open $fname"); + + while (<$in>) + { + next if (/^#/); + chop; + + next if (/^$/); # Ignore empty lines + + next if (/^0x([0-9A-F]+)\s+(#.*)$/); + + # The Unicode source files have three columns + # 1: The "foreign" code (in hex) + # 2: Unicode code point (in hex) + # 3: Unicode name + if (!/^0x([0-9A-Fa-f]+)\s+0x([0-9A-Fa-f]+)\s+(#.*)$/) + { + print STDERR "READ ERROR at line $. in $fname: $_\n"; + exit; + } + my $out = { + code => hex($1), + ucs => hex($2), + comment => $4, + direction => BOTH, + f => $fname, + l => $. + }; + + # Ignore pure ASCII mappings. PostgreSQL character conversion code + # never even passes these to the conversion code. + next if ($out->{code} < 0x80 || $out->{ucs} < 0x80); + + push(@r, $out); + } + close($in); + + return \@r; +} + +################################################################## +# print_conversion_tables - output mapping tables +# +# print_conversion_tables($this_script, $csname, \%charset) +# +# this_script - the name of the *caller script* of this feature +# csname - character set name other than ucs +# charset - ref to character set array +# +# Input character set array format: +# +# Each element in the character set array is a hash. Each hash has the following fields: +# direction - BOTH, TO_UNICODE, or FROM_UNICODE (or NONE, to ignore the entry altogether) +# ucs - Unicode code point +# ucs_second - Second Unicode code point, if this is a "combined" character. +# code - Byte sequence in the "other" character set, as an integer +# comment - Text representation of the character +# f - Source filename +# l - Line number in source file +# +sub print_conversion_tables +{ + my ($this_script, $csname, $charset) = @_; + + print_conversion_tables_direction($this_script, $csname, FROM_UNICODE, + $charset); + print_conversion_tables_direction($this_script, $csname, TO_UNICODE, + $charset); + return; +} + +############################################################################# +# INTERNAL ROUTINES + +####################################################################### +# print_conversion_tables_direction - write the whole content of C source of radix tree +# +# print_conversion_tables_direction($this_script, $csname, $direction, \%charset, $tblwidth) +# +# this_script - the name of the *caller script* of this feature +# csname - character set name other than ucs +# direction - desired direction, TO_UNICODE or FROM_UNICODE +# charset - ref to character set array +# +sub print_conversion_tables_direction +{ + my ($this_script, $csname, $direction, $charset) = @_; + + my $fname; + my $tblname; + if ($direction == TO_UNICODE) + { + $fname = lc("${csname}_to_utf8.map"); + $tblname = lc("${csname}_to_unicode_tree"); + + print "- Writing ${csname}=>UTF8 conversion table: $fname\n"; + } + else + { + $fname = lc("utf8_to_${csname}.map"); + $tblname = lc("${csname}_from_unicode_tree"); + + print "- Writing UTF8=>${csname} conversion table: $fname\n"; + } + + open(my $out, '>', $fname) || die("cannot open $fname"); + + print $out "/* src/backend/utils/mb/Unicode/$fname */\n"; + print $out "/* This file is generated by $this_script */\n\n"; + + # Collect regular, non-combined, mappings, and create the radix tree from them. + my $charmap = &make_charmap($out, $charset, $direction, 0); + print_radix_table($out, $tblname, $charmap); + + # Collect combined characters, and create combined character table (if any) + my $charmap_combined = &make_charmap_combined($charset, $direction); + + if (scalar @{$charmap_combined} > 0) + { + if ($direction == TO_UNICODE) + { + print_to_utf8_combined_map($out, $csname, $charmap_combined, 1); + } + else + { + print_from_utf8_combined_map($out, $csname, $charmap_combined, 1); + } + } + + close($out); + return; +} + +sub print_from_utf8_combined_map +{ + my ($out, $charset, $table, $verbose) = @_; + + my $last_comment = ""; + + printf $out "\n/* Combined character map */\n"; + printf $out + "static const pg_utf_to_local_combined ULmap${charset}_combined[ %d ] = {", + scalar(@$table); + my $first = 1; + foreach my $i (sort { $a->{utf8} <=> $b->{utf8} } @$table) + { + print($out ",") if (!$first); + $first = 0; + print $out "\t/* $last_comment */" + if ($verbose && $last_comment ne ""); + + printf $out "\n {0x%08x, 0x%08x, 0x%04x}", + $i->{utf8}, $i->{utf8_second}, $i->{code}; + if ($verbose >= 2) + { + $last_comment = + sprintf("%s:%d %s", $i->{f}, $i->{l}, $i->{comment}); + } + elsif ($verbose >= 1) + { + $last_comment = $i->{comment}; + } + } + print $out "\t/* $last_comment */" if ($verbose && $last_comment ne ""); + print $out "\n};\n"; + return; +} + +sub print_to_utf8_combined_map +{ + my ($out, $charset, $table, $verbose) = @_; + + my $last_comment = ""; + + printf $out "\n/* Combined character map */\n"; + printf $out + "static const pg_local_to_utf_combined LUmap${charset}_combined[ %d ] = {", + scalar(@$table); + + my $first = 1; + foreach my $i (sort { $a->{code} <=> $b->{code} } @$table) + { + print($out ",") if (!$first); + $first = 0; + print $out "\t/* $last_comment */" + if ($verbose && $last_comment ne ""); + + printf $out "\n {0x%04x, 0x%08x, 0x%08x}", + $i->{code}, $i->{utf8}, $i->{utf8_second}; + + if ($verbose >= 2) + { + $last_comment = + sprintf("%s:%d %s", $i->{f}, $i->{l}, $i->{comment}); + } + elsif ($verbose >= 1) + { + $last_comment = $i->{comment}; + } + } + print $out "\t/* $last_comment */" if ($verbose && $last_comment ne ""); + print $out "\n};\n"; + return; +} + +####################################################################### +# print_radix_table(, , ) +# +# Input: A hash, mapping an input character to an output character. +# +# Constructs a radix tree from the hash, and prints it out as a C-struct. +# +sub print_radix_table +{ + my ($out, $tblname, $c) = @_; + + ### + ### Build radix trees in memory, for 1-, 2-, 3- and 4-byte inputs. Each + ### radix tree is represented as a nested hash, each hash indexed by + ### input byte + ### + my %b1map; + my %b2map; + my %b3map; + my %b4map; + foreach my $in (keys %$c) + { + my $out = $c->{$in}; + + if ($in <= 0xff) + { + $b1map{$in} = $out; + } + elsif ($in <= 0xffff) + { + my $b1 = $in >> 8; + my $b2 = $in & 0xff; + + $b2map{$b1}{$b2} = $out; + } + elsif ($in <= 0xffffff) + { + my $b1 = $in >> 16; + my $b2 = ($in >> 8) & 0xff; + my $b3 = $in & 0xff; + + $b3map{$b1}{$b2}{$b3} = $out; + } + elsif ($in <= 0xffffffff) + { + my $b1 = $in >> 24; + my $b2 = ($in >> 16) & 0xff; + my $b3 = ($in >> 8) & 0xff; + my $b4 = $in & 0xff; + + $b4map{$b1}{$b2}{$b3}{$b4} = $out; + } + else + { + die sprintf("up to 4 byte code is supported: %x", $in); + } + } + + my @segments; + + ### + ### Build a linear list of "segments", from the nested hashes. + ### + ### Each segment is a lookup table, keyed by the next byte in the input. + ### The segments are written out physically to one big array in the final + ### step, but logically, they form a radix tree. Or rather, four radix + ### trees: one for 1-byte inputs, another for 2-byte inputs, 3-byte + ### inputs, and 4-byte inputs. + ### + ### Each segment is represented by a hash with following fields: + ### + ### comment => + ### label =>