diff --git a/Makefile.am b/Makefile.am index e1bd061b5..99585bad5 100644 --- a/Makefile.am +++ b/Makefile.am @@ -50,6 +50,11 @@ dist_pkginclude_HEADERS = \ include/safe_types.h \ include/safe_lib_errno.h +if ENABLE_U8 +pkginclude_HEADERS += \ + include/safe_u8_lib.h +endif + # Support files SAFEC_INFRA = \ $(top_srcdir)/README.md \ diff --git a/configure.ac b/configure.ac index 9455d285f..b67e246ea 100644 --- a/configure.ac +++ b/configure.ac @@ -210,6 +210,26 @@ fi AC_SUBST(INSERT_EXTS) AM_CONDITIONAL(ENABLE_EXTS, test "x$enable_extensions" = "xtrue") +AC_ARG_ENABLE(u8, + AS_HELP_STRING([--enable-u8], + [Add an additional utf-8 string library. + @<:@default=no@:>@]), + [case "${enableval}" in + yes) enable_u8=true ;; + no) enable_u8=false ;; + *) AC_MSG_ERROR([bad value ${enableval} for --enable-u8]) ;; + esac], [enable_u8=false]) +AC_MSG_CHECKING([for --enable-u8]) +if test "x$enable_u8" = "xtrue" ; then + AC_MSG_RESULT([yes]) + INSERT_U8="#define SAFECLIB_ENABLE_U8 1" +else + AC_MSG_RESULT([no (default)]) + INSERT_U8="#undef SAFECLIB_ENABLE_U8" +fi +AM_CONDITIONAL(ENABLE_U8, test "x$enable_u8" = "xtrue") +AC_SUBST(INSERT_U8) + AC_ARG_ENABLE(memmax, AS_HELP_STRING([--enable-memmax], [specify the largest object size allowed for the diff --git a/include/safe_str_lib.h b/include/safe_str_lib.h index 76a846c12..1bbbb4303 100644 --- a/include/safe_str_lib.h +++ b/include/safe_str_lib.h @@ -867,6 +867,10 @@ EXTERN errno_t _wcsnorm_s_chk(wchar_t *restrict dest, rsize_t dmax, #endif /* SAFECLIB_DISABLE_WCHAR */ +#ifdef SAFECLIB_ENABLE_U8 +#include "safe_u8_lib.h" +#endif + #ifdef __cplusplus } #endif diff --git a/include/safe_types.h.in b/include/safe_types.h.in index 9663ebc91..650dead72 100644 --- a/include/safe_types.h.in +++ b/include/safe_types.h.in @@ -49,6 +49,8 @@ extern "C" { /* errno_t isn't defined in the kernel */ typedef int errno_t; +@INSERT_U8@ + #else #include @@ -56,6 +58,7 @@ typedef int errno_t; @INSERT_INTTYPES_H@ @INSERT_STDINT_H@ @INSERT_ERRNO_H@ +@INSERT_U8@ @FALLBACK_ERRNO_T@ diff --git a/include/safe_u8_lib.h b/include/safe_u8_lib.h new file mode 100644 index 000000000..bc5d9d77d --- /dev/null +++ b/include/safe_u8_lib.h @@ -0,0 +1,456 @@ +/*------------------------------------------------------------------ + * safe_u8_lib.h -- Safe C Library UTF-8 String APIs + * + * September 2020, Reini Urban + * + * Copyright (c) 2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifndef __SAFE_U8_LIB_H__ +#define __SAFE_U8_LIB_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "safe_config.h" +#include "safe_lib_errno.h" +#include "safe_types.h" +#include "safe_compile.h" +#include "safe_str_lib.h" + +/* utf-8 string concatenate */ +EXTERN errno_t _u8cat_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, const size_t destbos) + BOS_CHK(dest) BOS_NULL(src); +#define u8cat_s(dest, dmax, src) _u8cat_s_chk(dest, dmax, src, BOS(dest)) + +/* utf-8 string copy */ +EXTERN errno_t _u8cpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, const size_t destbos) + BOS_CHK(dest) BOS_NULL(src); +#define u8cpy_s(dest, dmax, src) _u8cpy_s_chk(dest, dmax, src, BOS(dest)) + +/* utf-8 string identifier copy. dest normalized, normalizing src */ +EXTERN errno_t _u8icpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, const size_t destbos) + BOS_CHK(dest) BOS_NULL(src); +#define u8icpy_s(dest, dmax, src) _u8icpy_s_chk(dest, dmax, src, BOS(dest)) + +/* utf-8 string identifier concatenate. dest normalized, normalizing src */ +EXTERN errno_t _u8icat_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, const size_t destbos) + BOS_CHK(dest) BOS_NULL(src); +#define u8icat_s(dest, dmax, src) _u8icat_s_chk(dest, dmax, src, BOS(dest)) + +/* fitted utf-8 string concatenate */ +EXTERN errno_t _u8ncat_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, rsize_t slen, + const size_t destbos, const size_t srcbos) + BOS_ATTR((slen || dest || dmax) && + (_BOS_NULL(dest) || _BOS_ZERO(dest, dmax)), + "empty dest or dmax") + BOS_ATTR((slen || dest || dmax) && _BOS_OVR(dest, dmax), + "dest overflow") BOS_OVR2_BUTZERO(src, slen); +#define u8ncat_s(dest, dmax, src, slen) \ + _u8ncat_s_chk(dest, dmax, src, slen, BOS(dest), BOS(src)) + +/* fitted utf-8 string copy */ +EXTERN errno_t _u8ncpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, rsize_t slen, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_OVR2_BUTZERO(src, slen); +#define u8ncpy_s(dest, dmax, src, slen) \ + _u8ncpy_s_chk(dest, dmax, src, slen, BOS(dest), BOS(src)) + +/* utf-8 string length */ +EXTERN rsize_t _u8len_s_chk(const char *str, size_t strbos) + BOS_CHK(str); +#define u8len_s(str) _u8len_s_chk(str, BOS(str)) + +/* utf-8 string bounded length */ +EXTERN rsize_t _u8nlen_s_chk(const char *str, rsize_t smax, size_t strbos) + BOS_CHK2(str, smax); +#define u8nlen_s(str, smax) _u8nlen_s_chk(str, smax, BOS(str)) + +/* string tokenizer */ +EXTERN char *_u8tok_s_chk(char *restrict dest, rsize_t *restrict dmaxp, + const char *restrict delim, char **restrict ptr, + const size_t destbos) BOS_OVR2_BUTNULL(dest, *dmaxp) + BOS_ATTR(dest &&_BOS_NULL(dmaxp), "empty dmax") BOS_NULL(delim) + BOS_NULL(ptr); +#define u8tok_s(dest, dmaxp, delim, ptr) \ + _u8tok_s_chk(dest, dmaxp, delim, ptr, BOS(dest)) + +/* secure stdio */ + +/* safe u8sprintf_s */ +EXTERN int _u8sprintf_s_chk(char *restrict dest, const rsize_t dmax, + const size_t destbos, const char *restrict fmt, ...) + __attribute_format__(printf,4,5) BOS_CHK(dest) BOS_FMT(fmt); +#define u8sprintf_s(dest, dmax, fmt, ...) \ + _u8sprintf_s_chk(dest, dmax, BOS(dest), fmt, __VA_ARGS__) + +EXTERN int _vu8sprintf_s_chk(char *restrict dest, rsize_t dmax, + const size_t destbos, const char *restrict fmt, + va_list ap) BOS_CHK(dest) BOS_FMT(fmt); +#define vu8sprintf_s(dest, dmax, fmt, ap) \ + _vu8sprintf_s_chk(dest, dmax, BOS(dest), fmt, ap) + +/* truncating, no ESNOSPC */ +EXTERN int _u8snprintf_s_chk(char *restrict dest, rsize_t dmax, + const size_t destbos, const char *restrict fmt, ...) + __attribute_format__(printf,4,5) BOS_CHK(dest) BOS_FMT(fmt); +#define u8snprintf_s(dest, dmax, ...) \ + _u8snprintf_s_chk(dest, dmax, BOS(dest), __VA_ARGS__) + +EXTERN int _vu8snprintf_s_chk(char *restrict dest, rsize_t dmax, + const size_t destbos, const char *restrict fmt, + va_list ap) BOS_CHK(dest) BOS_FMT(fmt); +#define vu8snprintf_s(dest, dmax, fmt, ap) \ + _vu8snprintf_s_chk(dest, dmax, BOS(dest), fmt, ap) + +/* Note: there is no __vsscanf_chk yet. Unchecked */ +EXTERN int u8sscanf_s(const char *restrict buffer, const char *restrict fmt, ...) + __attribute_format__(scanf,2,3) BOS_NULL(buffer) BOS_FMT(fmt); + +EXTERN int fu8scanf_s(FILE *restrict stream, const char *restrict fmt, ...) + __attribute_format__(scanf,2,3) BOS_NULL(stream) BOS_FMT(fmt); + +EXTERN int u8scanf_s(const char *restrict fmt, ...) + __attribute_format__(scanf,1,2) BOS_FMT(fmt); + +EXTERN int vu8scanf_s(const char *restrict fmt, va_list ap) BOS_FMT(fmt); + +EXTERN int vfu8scanf_s(FILE *restrict stream, const char *restrict fmt, + va_list ap) BOS_NULL(stream) BOS_FMT(fmt); + +EXTERN int vu8sscanf_s(const char *restrict dest, const char *restrict fmt, + va_list ap) BOS_NULL(dest) BOS_FMT(fmt); + +EXTERN int u8printf_s(const char *restrict fmt, ...) + __attribute_format__(printf,1,2) BOS_FMT(fmt); + +EXTERN int fu8printf_s(FILE *restrict stream, const char *restrict fmt, ...) + __attribute_format__(printf,2,3) BOS_FMT(fmt); + +EXTERN int vu8printf_s(const char *restrict fmt, va_list ap) BOS_FMT(fmt); + +EXTERN int vfu8printf_s(FILE *restrict stream, const char *restrict fmt, + va_list arg) BOS_FMT(fmt); + +EXTERN errno_t _u8error_s_chk(char *dest, rsize_t dmax, errno_t errnum, + const size_t destbos) BOS_CHK(dest); +#define u8error_s(dest, dmax, errnum) \ + _u8error_s_chk(dest, dmax, errnum, BOS(dest)) + +EXTERN size_t u8errorlen_s(errno_t errnum); + +#ifndef SAFECLIB_DISABLE_EXTENSIONS + +/* utf-8 string compare, normalizing */ +EXTERN errno_t _u8cmp_s_chk(const char *dest, rsize_t dmax, const char *src, + int *resultp, const size_t destbos, + const size_t srcbos) BOS_CHK(dest) BOS_NULL(src) + BOS_NULL(resultp); +#define u8cmp_s(dest, dmax, src, resultp) \ + _u8cmp_s_chk(dest, dmax, src, resultp, BOS(dest), BOS(src)) + +/* utf-8 string compare, normalized (both being valid identifiers) */ +EXTERN errno_t _u8icmp_s_chk(const char *dest, rsize_t dmax, const char *src, + int *resultp, const size_t destbos, + const size_t srcbos) BOS_CHK(dest) BOS_NULL(src) + BOSW_CHK2(src, smax) BOS_NULL(resultp); +#define u8icmp_s(dest, dmax, src, resultp) \ + _u8icmp_s_chk(dest, dmax, src, resultp, BOS(dest), BOS(src)) + +/* utf-8 string compare fold-cased, normalizing */ +EXTERN errno_t _u8fccmp_s_chk(const char *dest, rsize_t dmax, + const char *src, int *resultp, + const size_t destbos) BOS_CHK(dest) + BOS_NULL(src) BOS_NULL(resultp); +#define u8fccmp_s(dest, dmax, src, resultp) \ + _u8fccmp_s_chk(dest, dmax, src, resultp, BOS(dest)) + +/* natural order string compare */ +EXTERN errno_t _u8natcmp_s_chk(const char *dest, rsize_t dmax, const char *src, + const int fold_case, int *resultp, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_NULL(src) BOS_NULL(resultp); +#define u8natcmp_s(dest, dmax, src, resultp) \ + _u8natcmp_s_chk(dest, dmax, src, 0, resultp, BOS(dest), BOS(src)) +#define u8natfccmp_s(dest, dmax, src, resultp) \ + _u8natfccmp_s_chk(dest, dmax, src, 1, resultp, BOS(dest), BOS(src)) + +/* find a substring - fold-cased, normalizing */ +EXTERN errno_t _u8fcu8_s_chk(char *dest, rsize_t dmax, const char *src, + rsize_t slen, char **substring, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_CHK2(src, slen) BOS_NULL(substring); +#define u8fcu8_s(dest, dmax, src, slen, substring) \ + _u8fcu8_s_chk(dest, dmax, src, slen, substring, BOS(dest), BOS(src)) + +/* find a substring - fold-cased, both normalized */ +EXTERN errno_t _u8ifcu8_s_chk(char *dest, rsize_t dmax, const char *src, + rsize_t slen, char **substring, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_CHK2(src, slen) BOS_NULL(substring); +#define u8ifcu8_s(dest, dmax, src, slen, substring) \ + _u8ifcu8_s_chk(dest, dmax, src, slen, substring, BOS(dest), BOS(src)) + +/* computes excluded prefix length */ +EXTERN errno_t _u8cspn_s_chk(const char *dest, rsize_t dmax, const char *src, + rsize_t slen, rsize_t *countp, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_OVR2(src, slen) BOS_NULL(countp); +#define u8cspn_s(dest, dmax, src, slen, countp) \ + _u8cspn_s_chk(dest, dmax, src, slen, countp, BOS(dest), BOS(src)) + +/* get pointer to first occurrence from set of char */ +EXTERN errno_t _u8pbrk_s_chk(char *dest, rsize_t dmax, char *src, rsize_t slen, + char **firstp, const size_t destbos, + const size_t srcbos) BOS_CHK(dest) + BOS_OVR2(src, slen) BOS_NULL(firstp); +#define u8pbrk_s(dest, dmax, src, slen, firstp) \ + _u8pbrk_s_chk(dest, dmax, src, slen, firstp, BOS(dest), BOS(src)) + +/* computes inclusive prefix length */ +EXTERN errno_t _u8spn_s_chk(const char *dest, rsize_t dmax, const char *src, + rsize_t slen, rsize_t *countp, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_CHK2(src, slen) BOS_NULL(countp); +#define u8spn_s(dest, dmax, src, slen, countp) \ + _u8spn_s_chk(dest, dmax, src, slen, countp, BOS(dest), BOS(src)) + +/* find a substring, normalizing */ +EXTERN errno_t _u8u8_s_chk(char *dest, rsize_t dmax, const char *src, + rsize_t slen, char **substringp, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_OVR2(src, slen) BOS_NULL(substringp); +#define u8u8_s(dest, dmax, src, slen, substringp) \ + _u8u8_s_chk(dest, dmax, src, slen, substringp, BOS(dest), BOS(src)) + +/* find a substring, normalized */ +EXTERN errno_t _u8iu8i_s_chk(char *dest, rsize_t dmax, const char *src, + rsize_t slen, char **substringp, + const size_t destbos, const size_t srcbos) + BOS_CHK(dest) BOS_OVR2(src, slen) BOS_NULL(substringp); +#define u8iu8i_s(dest, dmax, src, slen, substringp) \ + _u8iu8i_s_chk(dest, dmax, src, slen, substringp, BOS(dest), BOS(src)) + +/* find first character, normalizing */ +EXTERN errno_t _u8chr_s_chk(const char *restrict dest, rsize_t dmax, + const int ch, char **restrict resultp, + const size_t destbos) BOS_CHK(dest) + VAL_OVR2(ch, 255) BOS_NULL(resultp); +#define u8chr_s(dest, dmax, ch, resultp) \ + _u8chr_s_chk(dest, dmax, ch, resultp, BOS(dest)) + +/* find last character, normalizing */ +EXTERN errno_t _u8rchr_s_chk(const char *restrict dest, rsize_t dmax, + const int ch, char **restrict resultp, + const size_t destbos) BOS_CHK(dest) + VAL_OVR2(ch, 255) BOS_NULL(resultp) BOS_ATTR(!*dest, "empty *dest"); +#define u8rchr_s(dest, dmax, ch, resultp) \ + _u8rchr_s_chk(dest, dmax, ch, resultp, BOS(dest)) + +/* convert string to lowercase, normalizing */ +EXTERN errno_t _u8lwr_s_chk(char *dest, rsize_t dmax, + const size_t destbos) BOS_CHK2(dest, dmax); +#define u8lwr_s(dest, dmax) \ + _u8lwr_s_chk(dest, dmax, BOS(dest)) + +/* convert string to uppercase, normalizing */ +EXTERN errno_t _u8upr_s_chk(char *dest, rsize_t dmax, + const size_t destbos) BOS_CHK2(dest, dmax); +#define u8upr_s(dest, dmax) \ + _u8upr_s_chk(dest, dmax, BOS(dest)) + +/* zero an entire string with nulls. + mingw string_s.h has: _strset_s */ +EXTERN errno_t _u8zero_s_chk(char *dest, rsize_t dmax, const size_t destbos) + BOS_CHK(dest); +#define u8zero_s(dest, dmax) _u8zero_s_chk(dest, dmax, BOS(dest)) + +EXTERN errno_t _u8coll_s_chk(const char *restrict dest, rsize_t dmax, + const char *restrict src, int *resultp, + const size_t destbos) BOS_CHK(dest) BOS_NULL(src) + BOS_NULL(resultp); +#define u8coll_s(dest, dmax, src, resultp) \ + _u8coll_s_chk(dest, dmax, src, resultp, BOS(dest)) + +/* Derived from windows extensions sec_api/string_s.h + defined(MINGW_HAS_SECURE_API) */ + +EXTERN errno_t _u8set_s_chk(char *restrict dest, rsize_t dmax, int value, + const size_t destbos) BOS_CHK(dest) + VAL_OVR2(value, 255); +#define u8set_s(dest, dmax, value) _u8set_s_chk(dest, dmax, value, BOS(dest)) + +EXTERN errno_t _u8nset_s_chk(char *restrict dest, rsize_t dmax, int value, + rsize_t n, const size_t destbos) BOS_CHK(dest) + BOS_OVR2_BUTZERO(dest, n) VAL_OVR2(value, 255) VAL_OVR2_BUTZERO(n, dmax); +#define u8nset_s(dest, dmax, value, n) \ + _u8nset_s_chk(dest, dmax, value, n, BOS(dest)) + +#endif /* SAFECLIB_DISABLE_EXTENSIONS */ + +/* multibyte conversions, from - to wchar */ + +EXTERN errno_t _u8towcs_s_chk(size_t *restrict retvalp, wchar_t *restrict dest, + rsize_t dmax, const char *restrict src, + rsize_t len, const size_t destbos) + BOS_NULL(retvalp) + BOS_ATTR(!_BOS_NULL(dest) && _BOS_ZERO(dest, dmax), "empty dmax") + BOS_ATTR(!_BOS_NULL(dest) && _BOSW_OVR(dest, dmax), "dest overflow") + BOS_ATTR(!_BOS_NULL(dest) && (void *)dest == (void *)src, + "dest overlap") BOS_CHK2(src, len); +#define u8towcs_s(retvalp, dest, dmax, src, len) \ + _u8towcs_s_chk(retvalp, dest, dmax, src, len, BOS(dest)) + +EXTERN errno_t _u8rtowcs_s_chk(size_t *restrict retvalp, + wchar_t *restrict dest, rsize_t dmax, + const char **restrict srcp, rsize_t len, + mbstate_t *restrict ps, const size_t destbos) + BOS_NULL(retvalp) BOS_NULL(srcp) BOS_NULL(ps) + BOS_ATTR(!_BOS_NULL(dest) && _BOS_ZERO(dest, dmax), "empty dmax") + BOS_ATTR(!_BOS_NULL(dest) && _BOSW_OVR(dest, dmax), "dest overflow") + BOS_ATTR(!_BOS_NULL(dest) && (char *)dest == *srcp, + "dest overlap") BOS_CHK2(*srcp, len) + BOS_ATTR(dmax &&len > dmax, "len overflow >dmax"); +#define u8rtowcs_s(retvalp, dest, dmax, srcp, len, ps) \ + _u8rtowcs_s_chk(retvalp, dest, dmax, srcp, len, ps, BOS(dest)) + +EXTERN errno_t _wcstou8_s_chk(size_t *restrict retvalp, char *restrict dest, + rsize_t dmax, const char *restrict src, + rsize_t len, const size_t destbos) + BOS_NULL(retvalp) BOS_CHK(dest) BOSW_CHK2(src, len) + BOS_ATTR(dmax &&len > dmax, "len overflow >dmax"); +#define wcstou8_s(retvalp, dest, dmax, src, len) \ + _wcstou8_s_chk(retvalp, dest, dmax, src, len, BOS(dest)) + +EXTERN errno_t _wcsrtou8_s_chk(size_t *restrict retvalp, char *restrict dest, + rsize_t dmax, const char **restrict srcp, + rsize_t len, mbstate_t *restrict ps, + const size_t destbos) BOS_NULL(retvalp) + BOS_NULL(ps) BOS_ATTR(!_BOS_NULL(dest) && !dmax, "empty dmax") + BOS_ATTR(!_BOS_NULL(dest) && _BOS_OVR(dest, dmax), "dest overflow") + BOS_ATTR(!_BOS_NULL(dest) && (void *)dest == (void *)srcp, + "dest overlap") BOS_NULL(srcp) BOSW_CHK2(*srcp, len) + BOS_ATTR(dmax &&len > dmax, "len overflow >dmax"); +#define wcsrtou8_s(retvalp, dest, dmax, srcp, len, ps) \ + _wcsrtou8_s_chk(retvalp, dest, dmax, srcp, len, ps, BOS(dest)) + +EXTERN errno_t _wcrtou8_s_chk(size_t *restrict retvalp, char *restrict dest, + rsize_t dmax, char wc, mbstate_t *restrict ps, + const size_t destbos) BOS_NULL(retvalp) + BOS_CHK(dest) BOS_NULL(ps) VAL_OVR2(wc, 0x10ffff); +#define wcrtou8_s(retvalp, dest, dmax, wc, ps) \ + _wcrtou8_s_chk(retvalp, dest, dmax, wc, ps, BOS(dest)) + +EXTERN errno_t _wctou8_s_chk(int *restrict retvalp, char *restrict dest, + rsize_t dmax, char wc, const size_t destbos) + BOS_NULL(retvalp) + BOS_ATTR(!_BOS_NULL(dest) && + (!dmax || dmax > RSIZE_MAX_STR || _BOS_OVR(dest, dmax)), + "dest overflow or empty") VAL_OVR2(wc, 0x10ffff); +#define wctou8_s(retvalp, dest, dmax, wc) \ + _wctou8_s_chk(retvalp, dest, dmax, wc, BOS(dest)) + +/* search wide substring */ +EXTERN errno_t _u8str_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, rsize_t slen, + char **restrict substringp, + const size_t destbos, const size_t srcbos) + BOSW_CHK(dest) BOSW_OVR2(src, slen) BOS_NULL(substringp); +#define u8str_s(dest, dmax, src, slen, substringp) \ + _u8str_s_chk(dest, dmax, src, slen, substringp, BOS(dest), BOS(src)) + +/* TODO stricter security checks for identifiers: u8i + mixed scripts, ... +*/ + +/* full foldcase + NFD normalization */ +EXTERN errno_t _u8fc_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, rsize_t *restrict lenp, + const size_t destbos) BOSW_CHK(dest) BOS_NULL(src); +#define u8fc_s(dest, dmax, src, lenp) \ + _u8fc_s_chk(dest, dmax, src, lenp, BOS(dest)) + +/* Normalize to FCD/pre-NFKD */ +EXTERN errno_t _u8norm_decompose_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, + const bool iscompat, + const size_t destbos) BOSW_CHK(dest) + BOS_NULL(src); +#define u8norm_decompose_s(dest, dmax, src, lenp, iscompat) \ + _u8norm_decompose_s_chk(dest, dmax, src, lenp, iscompat, BOS(dest)) + +/* Normalize to NCD/NFKD */ +EXTERN errno_t _u8norm_reorder_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const rsize_t len, const size_t destbos) + BOSW_CHK(dest) BOSW_OVR2(src, len); +#define u8norm_reorder_s(dest, dmax, src, len) \ + _u8norm_reorder_s_chk(dest, dmax, src, len, BOS(dest)) + +/* Normalize to NFC/NFKC */ +EXTERN errno_t _u8norm_compose_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, bool iscontig, + const size_t destbos) BOSW_CHK(dest) + BOS_NULL(src) BOS_NULL(lenp); +#define u8norm_compose_s(dest, dmax, src, lenp, iscontig) \ + _u8norm_compose_s_chk(dest, dmax, src, lenp, iscontig, BOS(dest)) + +#ifdef SAFECLIB_DISABLE_WCHAR +enum wcsnorm_mode { + WCSNORM_NFD = 0, + WCSNORM_NFC = 1, /* default */ + WCSNORM_FCD = 2, /* not reordered */ + WCSNORM_FCC = 3, /* contiguous composition only */ + WCSNORM_NFKD = 4, /* compat. OPTIONAL with --enable-norm-compat */ + WCSNORM_NFKC = 5 /* compat. OPTIONAL with --enable-norm-compat */ +}; +typedef enum wcsnorm_mode wcsnorm_mode_t; +#endif /* SAFECLIB_DISABLE_WCHAR */ + +/* Normalize to NFC (default), NFD nfc=0. + experim. nfc>1: FCD, FCC */ +EXTERN errno_t _u8norm_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const wcsnorm_mode_t mode, rsize_t *restrict lenp, + const size_t destbos) BOSW_CHK(dest) + BOS_NULL(src); +#define u8norm_s(dest, dmax, src, mode, lenp) \ + _u8norm_s_chk(dest, dmax, src, mode, lenp, BOS(dest)) + +#ifdef __cplusplus +} +#endif + +#endif /* __SAFE_U8_LIB_H__ */ diff --git a/src/Makefile.am b/src/Makefile.am index 18284f0d8..41800df33 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -195,6 +195,17 @@ STD_WCHAR_FILES += \ extwchar/wcsnorm_s.c endif +if ENABLE_U8 +EXT_U8_FILES = \ + extu8/u8cat_s.c \ + extu8/u8icat_s.c \ + extu8/u8norm_s.c \ + extu8/u8cpy_s.c \ + extu8/u8icpy_s.c \ + extu8/u8ncpy_s.c \ + extu8/u8nlen_s.c +endif + STD_IO_FILES = \ io/sscanf_s.c \ io/fscanf_s.c \ @@ -227,6 +238,7 @@ ALL_SRC_FILES = $(STD_STR_FILES) \ $(EXT_MEM_FILES) \ $(EXT_STR_FILES) \ + $(EXT_U8_FILES) \ $(STD_WCHAR_FILES) \ $(STD_IO_FILES) \ $(STD_OS_FILES) \ @@ -283,6 +295,12 @@ libsafec_la_SOURCES += \ $(EXT_MEM_FILES) \ $(EXT_STR_FILES) endif +if ENABLE_U8 +libsafec_la_SOURCES += \ + $(EXT_U8_FILES) +lib_LTLIBRARIES += libsafecu8.la +libsafecu8_la_SOURCES = $(EXT_U8_FILES) +endif libsafec_la_LIBADD = \ libmemprims.la \ diff --git a/src/extu8/u8cat_s.c b/src/extu8/u8cat_s.c new file mode 100644 index 000000000..24d2c289b --- /dev/null +++ b/src/extu8/u8cat_s.c @@ -0,0 +1,231 @@ +/*------------------------------------------------------------------ + * u8cat_s.c + * + * September 2020, Reini Urban + * + * Copyright (c) 2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_u8_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8cat_s(dest,dmax,src) + * @brief + * The u8cat_s function appends a copy of the utf-8 string pointed + * to by src (including the terminating null character) to the + * end of the utf-8 string pointed to by dest. The initial utf-8 character + * from src overwrites the null character at the end of dest. + * @details + * All elements following the terminating null utf-8 character (if + * any) written by u8cat_s in the array of dmax characters + * pointed to by dest take unspecified values when u8cat_s + * returns. + * With SAFECLIB_STR_NULL_SLACK defined the rest is cleared with + * 0. + * + * @param[out] dest pointer to utf-8 string that will be extended by src + * if dmax allows. The utf-8 string is null terminated. + * If the resulting concatenated utf-8 string is less + * than dmax, the remaining slack space is nulled. + * @param[in] dmax restricted maximum wchar_t length of the resulting + * dest, including the null + * @param[in] src pointer to the utf-8 string that will be concatenaed + * to string dest + * + * @pre Neither dest nor src shall be a null pointer + * @pre dmax shall not equal zero + * @pre dmax shall not be greater than RSIZE_MAX_WSTR and size of dest + * @pre dmax shall be greater than u8nlen_s(src,m). + * @pre Copying shall not take place between objects that overlap + * + * @note C11 uses RSIZE_MAX, not RSIZE_MAX_STR. + * + * @return If there is a runtime-constraint violation, then if dest is + * not a null pointer and dmax is greater than zero and not + * greater than RSIZE_MAX_STR, then u8cat_s nulls dest. + * @retval EOK when successful operation, all the utf-8 characters from + * src were appended to dest and the result in dest is null + * terminated. + * @retval ESNULLP when dest or src is a NULL pointer + * @retval ESZEROL when dmax = 0 + * @retval ESLEMAX when dmax > RSIZE_MAX_WSTR + * @retval EOVERFLOW when dmax > size of dest (optionally, when the compiler + * knows the object_size statically) + * @retval ESLEWRNG when dmax != size of dest and --enable-error-dmax + * @retval ESUNTERM when dest not terminated in the first dmax utf-8 + * characters + * @retval ESOVRLP when src overlaps with dest + * + * @see + * u8icat_s(), wcscat_s(), strcpy_s(), strncpy_s() + */ +#ifdef FOR_DOXYGEN +errno_t u8cat_s(char *restrict dest, rsize_t dmax, const char *restrict src) +#else +EXPORT errno_t _u8cat_s_chk(char *restrict dest, rsize_t dmax, const char *restrict src, + const size_t destbos) +#endif +{ + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + + CHK_DEST_NULL("u8cat_s") + CHK_DMAX_ZERO("u8cat_s") + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8cat_s", RSIZE_MAX_STR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DESTW_OVR("u8cat_s", dmax, destbos) + } + CHK_SRC_NULL_CLEAR("u8cat_s", src) + + /* hold base of dest in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + /* Find the end of dest */ + while (*dest != L'\0') { + + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8cat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + dest++; + dmax--; + if (unlikely(dmax == 0)) { + handle_error(orig_dest, orig_dmax, + "u8cat_s: " + "dest unterminated", + ESUNTERM); + return RCNEGATE(ESUNTERM); + } + } + + while (dmax > 0) { + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8cat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (unlikely(*dest == L'\0')) { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } else { + overlap_bumper = dest; + + /* Find the end of dest */ + while (*dest != L'\0') { + + /* + * NOTE: no need to check for overlap here since src comes first + * in memory and we're not incrementing src here. + */ + dest++; + dmax--; + if (unlikely(dmax == 0)) { + handle_error(orig_dest, orig_dmax, + "u8cat_s: " + "dest unterminated", + ESUNTERM); + return RCNEGATE(ESUNTERM); + } + } + + while (dmax > 0) { + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8cat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == L'\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } + + /* + * the entire src was not copied, so null the string + */ + handle_error(orig_dest, orig_dmax, + "u8cat_s: not enough " + "space for src", + ESNOSPC); + + return RCNEGATE(ESNOSPC); +} diff --git a/src/extu8/u8cpy_s.c b/src/extu8/u8cpy_s.c new file mode 100644 index 000000000..83188232e --- /dev/null +++ b/src/extu8/u8cpy_s.c @@ -0,0 +1,181 @@ +/*------------------------------------------------------------------ + * u8cpy_s.c + * + * September 2020, Reini Urban + * + * Copyright (c) 2017,2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_str_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8cpy_s(dest,dmax,src) + * @brief + * The \c u8cpy_s function copies the string pointed to by \c src + * (including the terminating null character) into the buffer + * pointed to by dest. + * With \c SAFECLIB_STR_NULL_SLACK defined all elements following the + * terminating null character (if any) written by \c u8cpy_s in the + * array of \c dmax characters pointed to by \c dest are nulled when + * \c u8cpy_s returns. + * + * @param[out] dest pointer to wide string that will be replaced by src. + * @param[in] dmax restricted maximum length of dest + * @param[in] src pointer to the wide string that will be copied to dest + * + * @pre Neither dest nor src shall be a null pointer. + * @pre dmax shall not be greater than RSIZE_MAX_STR and size of dest. + * @pre dmax shall not equal zero. + * @pre dmax shall be greater than u8nlen_s(src, dmax). + * @pre Copying shall not take place between objects that overlap. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_STR, then u8cpy_s nulls dest. + * @retval EOK when successful operation, the wide characters in src + * were copied into dest and the result is null terminated. + * @retval -ESNULLP when dest or src is a NULL pointer + * @retval -ESZEROL when dmax = 0 + * @retval -ESLEMAX when dmax > RSIZE_MAX_STR + * @retval -ESOVRLP when buffers overlap + * @retval -ESNOSPC when dest < src + * + * @see + * u8ncpy(), wmemcpy(), wmemmove(), strncpy_s() + */ +#ifdef FOR_DOXYGEN +errno_t u8cpy_s(char *restrict dest, rsize_t dmax, + const char *restrict src) +#else +EXPORT errno_t _u8cpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const size_t destbos) +#endif +{ + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + + CHK_DEST_NULL("u8cpy_s") + CHK_DMAX_ZERO("u8cpy_s") + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8cpy_s", RSIZE_MAX_STR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DEST_OVR_CLEAR("u8cpy_s", destbos) + } + CHK_SRC_NULL_CLEAR("u8cpy_s", src) + + if (unlikely(dest == src)) { + return RCNEGATE(EOK); + } + + /* hold base of dest in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + while (dmax > 0) { + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8cpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == '\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } else { + overlap_bumper = dest; + + while (dmax > 0) { + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8cpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == '\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } + + /* + * the entire src must have been copied, if not reset dest + * to null the string. (only with SAFECLIB_STR_NULL_SLACK) + */ + handle_error(orig_dest, orig_dmax, + "u8cpy_s: not " + "enough space for src", + ESNOSPC); + return RCNEGATE(ESNOSPC); +} diff --git a/src/extu8/u8icat_s.c b/src/extu8/u8icat_s.c new file mode 100644 index 000000000..8a974c17a --- /dev/null +++ b/src/extu8/u8icat_s.c @@ -0,0 +1,240 @@ +/*------------------------------------------------------------------ + * u8icat_s.c + * + * September 2020, Reini Urban + * + * Copyright (c) 2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_u8_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8icat_s(dest,dmax,src) + * @brief + * The u8icat_s function appends a copy of the utf-8 string src + * (including the terminating null character) to + * the end of the utf-8 normalized identifier dest. The initial + * utf-8 character from src overwrites the null + * character at the end of dest. Identifiers follow stricter + * rules for mixed scripts, src will be normalized. + * @details + * All elements following the terminating null utf-8 character (if + * any) written by u8icat_s in the array of dmax characters + * pointed to by dest take unspecified values when u8icat_s + * returns. + * With SAFECLIB_STR_NULL_SLACK defined the rest is cleared with + * 0. + * + * @param[out] dest pointer to a normalized utf-8 string that will be + * extended by a normalized copy of src if dmax allows. + * The utf-8 string is normalized, follows the strict + * security guidelines for identifiers (esp. no mixed scripts) + * and will be null terminated. + * If the resulting concatenated utf-8 string is less + * than dmax, the remaining slack space is nulled. + * @param[in] dmax restricted maximum byte-length of the resulting + * dest buffer, including the null. + * @param[in] src pointer to the utf-8 string that will be normalized and + * concatenated to identifier dest. + * + * @pre Neither dest nor src shall be a null pointer + * @pre dest must be already normalized and contain no mixed scripts characters. + * @pre src must not contain mixed scripts characters. + * @pre The union of src and dest must not contain mixed scripts characters. + * @pre dmax shall not equal zero + * @pre dmax shall not be greater than RSIZE_MAX_WSTR and size of dest + * @pre dmax shall be greater than u8nlen_s(src,m). + * @pre Copying shall not take place between objects that overlap + * + * @note C11 uses RSIZE_MAX, not RSIZE_MAX_STR. + * + * @return If there is a runtime-constraint violation, then if dest is + * not a null pointer and dmax is greater than zero and not + * greater than RSIZE_MAX_STR, then u8icat_s nulls dest. + * @retval EOK when successful operation, all the normalized utf-8 characters + * from src were appended to dest and the result in dest is null + * terminated. + * @retval ESNULLP when dest or src is a NULL pointer + * @retval ESZEROL when dmax = 0 + * @retval ESLEMAX when dmax > RSIZE_MAX_WSTR + * @retval EOVERFLOW when dmax > size of dest (optionally, when the compiler + * knows the object_size statically) + * @retval ESLEWRNG when dmax != size of dest and --enable-error-dmax + * @retval ESUNTERM when dest not terminated in the first dmax utf-8 + * bytes + * @retval ESOVRLP when src overlaps with dest + * + * @see + * u8icat_s(), wcscat_s(), strcpy_s(), strncpy_s() + */ +#ifdef FOR_DOXYGEN +errno_t u8icat_s(char *restrict dest, rsize_t dmax, const char *restrict src) +#else +EXPORT errno_t _u8icat_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const size_t destbos) +#endif +{ + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + + CHK_DEST_NULL("u8icat_s") + CHK_DMAX_ZERO("u8icat_s") + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8icat_s", RSIZE_MAX_STR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DESTW_OVR("u8icat_s", dmax, destbos) + } + CHK_SRC_NULL_CLEAR("u8icat_s", src) + + /* hold base of dest in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + /* Find the end of dest */ + while (*dest != L'\0') { + + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8icat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + dest++; + dmax--; + if (unlikely(dmax == 0)) { + handle_error(orig_dest, orig_dmax, + "u8icat_s: " + "dest unterminated", + ESUNTERM); + return RCNEGATE(ESUNTERM); + } + } + + while (dmax > 0) { + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8icat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (unlikely(*dest == L'\0')) { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } else { + overlap_bumper = dest; + + /* Find the end of dest */ + while (*dest != L'\0') { + + /* + * NOTE: no need to check for overlap here since src comes first + * in memory and we're not incrementing src here. + */ + dest++; + dmax--; + if (unlikely(dmax == 0)) { + handle_error(orig_dest, orig_dmax, + "u8icat_s: " + "dest unterminated", + ESUNTERM); + return RCNEGATE(ESUNTERM); + } + } + + while (dmax > 0) { + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8icat_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == L'\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } + + /* + * the entire src was not copied, so null the string + */ + handle_error(orig_dest, orig_dmax, + "u8icat_s: not enough " + "space for src", + ESNOSPC); + + return RCNEGATE(ESNOSPC); +} diff --git a/src/extu8/u8icpy_s.c b/src/extu8/u8icpy_s.c new file mode 100644 index 000000000..b136f8779 --- /dev/null +++ b/src/extu8/u8icpy_s.c @@ -0,0 +1,183 @@ +/*------------------------------------------------------------------ + * u8icpy_s.c + * + * September 2020, Reini Urban (WIP) + * + * Copyright (c) 2017,2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_u8_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8icpy_s(dest,dmax,src) + * @brief + * The \c u8icpy_s function normalizes and checks the utf-8 string pointed to + * by \c src and copies it into the buffer pointed to by dest. + * dest disallows mixed scripts. + * With \c SAFECLIB_STR_NULL_SLACK defined all elements following the + * terminating null character (if any) written by \c u8icpy_s in the + * array of \c dmax characters pointed to by \c dest are nulled when + * \c u8icpy_s returns. + * + * @param[out] dest pointer to utf-8 string that will be replaced by src. + * @param[in] dmax restricted maximum length of dest + * @param[in] src pointer to the utf-8 string that will be copied to dest + * + * @pre Neither dest nor src shall be a null pointer. + * @pre src must not contain mixed scripts characters. + * @pre dmax shall not be greater than RSIZE_MAX_WSTR and size of dest. + * @pre dmax shall not equal zero. + * @pre dmax shall be greater than u8inlen_s(src, dmax). + * @pre Copying shall not take place between objects that overlap. + * + * @note C11 uses RSIZE_MAX, not RSIZE_MAX_WSTR. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_WSTR, then u8icpy_s nulls dest. + * @retval EOK when successful operation, the utf-8 characters in src + * were copied into dest and the result is null terminated. + * @retval -ESNULLP when dest or src is a NULL pointer + * @retval -ESZEROL when dmax = 0 + * @retval -ESLEMAX when dmax > RSIZE_MAX_WSTR + * @retval -ESOVRLP when buffers overlap + * @retval -ESNOSPC when dest < src + * + * @see + * u8cpy(), strncpy_s() + */ +#ifdef FOR_DOXYGEN +errno_t u8icpy_s(char *restrict dest, rsize_t dmax, const char *restrict src) +#else +EXPORT errno_t _u8icpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const size_t destbos) +#endif +{ + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + + CHK_DEST_NULL("u8icpy_s") + CHK_DMAX_ZERO("u8icpy_s") + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8icpy_s", RSIZE_MAX_WSTR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DEST_OVR_CLEAR("u8icpy_s", destbos) + } + CHK_SRC_NULL_CLEAR("u8icpy_s", src) + + if (unlikely(dest == src)) { + return RCNEGATE(EOK); + } + + /* hold base of dest in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + while (dmax > 0) { + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8icpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == '\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } else { + overlap_bumper = dest; + + while (dmax > 0) { + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8icpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + *dest = *src; + if (*dest == '\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + dest++; + src++; + } + } + + /* + * the entire src must have been copied, if not reset dest + * to null the string. (only with SAFECLIB_STR_NULL_SLACK) + */ + handle_error(orig_dest, orig_dmax, + "u8icpy_s: not " + "enough space for src", + ESNOSPC); + return RCNEGATE(ESNOSPC); +} diff --git a/src/extu8/u8ncpy_s.c b/src/extu8/u8ncpy_s.c new file mode 100644 index 000000000..0d9d2969b --- /dev/null +++ b/src/extu8/u8ncpy_s.c @@ -0,0 +1,237 @@ +/*------------------------------------------------------------------ + * u8ncpy_s.c + * + * September 2020, Reini Urban + * + * Copyright (c) 2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_u8_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8ncpy_s(dest,dmax,src,slen) + * @brief + * The \b u8ncpy_s function copies the utf-8 string pointed to by src + * (including the terminating null character) into the utf-8 string + * pointed to by dest. + * With SAFECLIB_STR_NULL_SLACK defined all elements following the + * terminating null character (if any) written by u8ncpy_s in the + * array of dmax characters pointed to by dest are nulled when + * u8ncpy_s returns. + * + * @param[out] dest pointer to utf-8 string that will be replaced by src. + * @param[in] dmax restricted maximum length of dest + * @param[in] src pointer to the utf-8 string that will be copied to dest + * @param[in] slen maximum number of utf-8 characters to copy + * + * @pre Neither dest nor src shall be a null pointer. + * @pre dmax shall not be greater than RSIZE_MAX_STR. + * @pre dmax shall not equal zero. + * @pre If slen is either greater than or equal to dmax, then dmax should + * be more than u8nlen_s(src,dmax) to avoid truncation. + * @pre Copying shall not take place between objects that overlap. + * + * @return If there is a runtime-constraint violation, then if dest and + * dmax are valid, then u8ncpy_s nulls dest. + * @retval EOK successful operation, when slen == 0 or the utf-8 + * characters in src were copied into dest and the result is null terminated. + * @retval ESNULLP when dest/src is a NULL pointer + * @retval ESZEROL when dmax = 0 + * @retval ESLEMAX when dmax > RSIZE_MAX_STR + * @retval EOVERFLOW when dmax/slen > size of dest/src (optionally, when the + * compiler knows the object_size statically) + * @retval ESLEWRNG when dmax != size of dest and --enable-error-dmax + * @retval ESOVRLP when buffers overlap + * @retval ESNOSPC when src > dest + * + * @see + * u8cpy_s(), strncpy_s(), wmemcpy_s(), wmemmove_s() + */ + +EXPORT errno_t _u8ncpy_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, rsize_t slen, + const size_t destbos, const size_t srcbos) { + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + + if (unlikely(slen == 0 && dest && dmax)) { + *dest = L'\0'; + return EOK; + } + CHK_DEST_NULL("u8ncpy_s") + CHK_DMAX_ZERO("u8ncpy_s") + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8ncpy_s", RSIZE_MAX_STR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DEST_OVR_CLEAR("u8ncpy_s", destbos) + } + CHK_SRC_NULL_CLEAR("u8ncpy_s", src) + if (unlikely(slen > RSIZE_MAX_STR)) { + handle_error(dest, u8nlen_s(dest, dmax), + "u8ncpy_s: slen exceeds max", + ESLEMAX); + return RCNEGATE(ESLEMAX); + } + if (srcbos == BOS_UNKNOWN) { + BND_CHK_PTR_BOUNDS(src, slen); + } else { + if (unlikely(slen > srcbos)) { + handle_error(dest, u8nlen_s(dest, dmax), + "u8ncpy_s: slen exceeds src", EOVERFLOW); + return RCNEGATE(EOVERFLOW); + } + } + + /* hold base in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + while (dmax > 0) { + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8ncpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + if (unlikely(slen == 0)) { + /* Copying truncated to slen chars. Note that the TR says to + * copy slen chars plus the null char. We null the slack. + */ +#ifdef SAFECLIB_STR_NULL_SLACK + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#else + *dest = L'\0'; +#endif + return RCNEGATE(EOK); + } + + *dest = *src; + if (*dest == L'\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + slen--; + dest++; + src++; + } + } else { + overlap_bumper = dest; + + while (dmax > 0) { + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8ncpy_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + + if (unlikely(slen == 0)) { + /* Copying truncated to slen chars. Note that the TR says to + * copy slen chars plus the null char. We null the slack. + */ +#ifdef SAFECLIB_STR_NULL_SLACK + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#else + *dest = L'\0'; +#endif + return RCNEGATE(EOK); + } + + *dest = *src; + if (*dest == L'\0') { +#ifdef SAFECLIB_STR_NULL_SLACK + /* null slack to clear any data */ + if (dmax > 0x20) + memset(dest, 0, dmax); + else { + while (dmax) { + *dest = L'\0'; + dmax--; + dest++; + } + } +#endif + return RCNEGATE(EOK); + } + + dmax--; + slen--; + dest++; + src++; + } + } + + /* + * the entire src must have been copied, if not reset dest + * to null the string. (only with SAFECLIB_STR_NULL_SLACK) + */ + handle_error(orig_dest, orig_dmax, + "u8ncpy_s: not " + "enough space for src", + ESNOSPC); + return RCNEGATE(ESNOSPC); +} diff --git a/src/extu8/u8nlen_s.c b/src/extu8/u8nlen_s.c new file mode 100644 index 000000000..118ec5937 --- /dev/null +++ b/src/extu8/u8nlen_s.c @@ -0,0 +1,117 @@ +/*------------------------------------------------------------------ + * u8nlen_s.c + * + * September 2020, Reini Urban + * + * Copyright (c) 2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_str_lib.h" +#else +#include "safeclib_private.h" +#endif + +/** + * @def u8nlen_s(str,smax) + * @brief + * The u8nlen_s function computes the byte-length of the utf-8 string pointed + * to by str, stopping at smax, providing limited support for non-null terminated + * strings. + * + * @param str pointer to utf-8 string + * @param smax maximum byte-length of utf-8 string, incl. the final \0. + * + * @pre str shall not be a null pointer. + * @pre smax shall not equal zero. + * @pre smax shall not be greater than RSIZE_MAX_STR and size of str + * (inc. final null). + * + * @return The function returns the utf-8 string length, excluding the + * terminating null character. If \c str is NULL, then \c u8nlen_s returns + * 0. Otherwise, the \c u8nlen_s function returns the number of wide + * characters that precede the terminating null character. If there is no null + * character in the first \c smax characters of str then \c u8nlen_s + * returns \c smax. At most the first \c smax characters of str are accessed + * by \c u8nlen_s. + * + * @see + * u8len_s(), strnlen_s(), wcsnlen_s() + */ +#ifdef FOR_DOXYGEN +rsize_t u8nlen_s(const char *str, rsize_t smax) +#else +EXPORT rsize_t _u8nlen_s_chk(const char *str, rsize_t smax, size_t strbos) +#endif +{ + const char *z; + rsize_t orig_smax = smax; + + if (unlikely(str == NULL)) { + return RCNEGATE(0); + } + if (unlikely(smax == 0)) { + invoke_safe_str_constraint_handler("u8nlen_s: smax is 0", (void *)str, + ESZEROL); + return RCNEGATE(0); + } + if (unlikely(smax > RSIZE_MAX_STR)) { + invoke_safe_str_constraint_handler("u8nlen_s: smax exceeds max", + (void *)str, ESLEMAX); + return RCNEGATE(0); + } +#if defined(HAVE_WARN_DMAX) || defined(HAVE_ERROR_DMAX) || \ + defined(HAVE___BND_CHK_PTR_BOUNDS) + if (strbos == BOS_UNKNOWN) { + BND_CHK_PTR_BOUNDS(str, smax); +#if defined(HAVE_WARN_DMAX) || defined(HAVE_ERROR_DMAX) + } else { + if (unlikely(smax != strbos)) { + handle_str_bos_chk_warn("u8nlen_s", (char *)str, smax, strbos); + RETURN_ESLEWRNG; + } +#endif + } +#endif + +#if 0 && defined(HAVE_MEMCHR) /* rather inline it */ + z = memchr(str, 0, smax); + if (z) smax = z - str; + return smax; +#else + if (strbos != BOS_UNKNOWN) { + /* Dont touch past strbos */ + for (z = str; smax && *str != 0; smax--, str++, strbos--) { + if (unlikely(strbos <= 0)) + return smax ? (rsize_t)(str - z) : orig_smax; + } + } else { + for (z = str; smax && *str != 0; smax--, str++) + ; + } + return smax ? (rsize_t)(str - z) : orig_smax; +#endif +} diff --git a/src/extu8/u8norm_s.c b/src/extu8/u8norm_s.c new file mode 100644 index 000000000..1498b712f --- /dev/null +++ b/src/extu8/u8norm_s.c @@ -0,0 +1,1141 @@ +/*------------------------------------------------------------------ + * u8norm_s.c + * + * September 2020, Reini Urban (WIP) + * + * Copyright (c) 2017,2020 by Reini Urban + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + *------------------------------------------------------------------ + */ + +#ifdef FOR_DOXYGEN +#include "safe_u8_lib.h" +#else +#include "safeclib_private.h" +#include +#endif + +/* generated via cperl dist/Unicode-Normalize/mkheader -ind -std */ +#define TRUE 1 +#define FALSE 0 +#define STDCHAR unsigned char +#include "un8ifcan.h" /* for NFD Canonical Decomposition */ +#include "un8ifcmb.h" /* for reorder Canonical_Combining_Class_Values */ +#include "un8ifcmp.h" /* for NFC Canonical Composition lists */ +#ifdef HAVE_NORM_COMPAT +#include "un8ifcpt.h" /* for NFKD/NFKC Compat. Decomposition. */ +#endif +#ifndef SAFECLIB_DISABLE_WCHAR +bool isExclusion (uint32_t uv); +#else +#include "../extwchar/unwifexc.h" +#endif +/* Korean/Hangul has special (easy) normalization rules */ +#include "../extwchar/hangul.h" + +#define _UNICODE_MAX 0x10ffff + +/* size of array for combining characters */ +/* enough as an initial value? */ +#define CC_SEQ_SIZE 10 +#define CC_SEQ_STEP 5 + +/* else a passthru macro in *_private.h */ +#if SIZEOF_WCHAR_T == 2 +/* convert surrogate pair to unicode codepoint */ +EXPORT uint32_t _dec_w16(char *src) { + uint32_t s1 = src[0]; + /*if (unlikely(s1 >= 0xd800 && s1 < 0xdc00)) {*/ + if (unlikely((s1 & 0xfc00) == 0xd800)) { + uint32_t s2 = src[1]; + if (likely((s2 & 0xfc00) == 0xdc00)) { +#if 0 + s1 = ((s1 & 0x3ff) << 10) + (s2 & 0x3ff); + if (s1 < 0x10000) + s1 += 0x10000; + return s1; +#else + return (s1 << 10) + s2 - 0x35FDC00; +#endif + } else { + invoke_safe_str_constraint_handler("u8norm_s: " + "illegal surrogate pair", + NULL, EILSEQ); + return 0; + } + } else { + return *src; + } +} +#endif + +#if defined(HAVE_NORM_COMPAT) || UN8IF_canon_exc_size > 0 + +#ifndef HAVE_NORM_COMPAT +/* They may have different structs (16 or 32 bit cp), but not together. + Either unw16ifcan+cpt (32) or unwifcpt (16) */ +#define UN8IF_compat_exc_t UN8IF_canon_exc_t +#endif + +static int _bsearch_exc(const void *ptr1, const void *ptr2) { + UN8IF_compat_exc_t *e1 = (UN8IF_compat_exc_t *)ptr1; + UN8IF_compat_exc_t *e2 = (UN8IF_compat_exc_t *)ptr2; + return e1->cp > e2->cp ? 1 : e1->cp == e2->cp ? 0 : -1; +} + +#endif + +/* Note that we can generate two versions of the tables. The old format as + * used in Unicode::Normalize, and the new 3x smaller NORMALIZE_IND_TBL cperl + * variant, as used here and in cperl core since 5.27.2. + */ +static int _u8decomp_canonical_s(char *dest, rsize_t dmax, uint32_t cp) { +#ifndef NORMALIZE_IND_TBL + /* the old big format */ + if (unlikely(dmax < 5)) { + return -ESNOSPC; + } else { + const char ***plane = UN8F_canon[cp >> 16]; + if (!plane) { + return 0; + } else { + const char **row = plane[(cp >> 8) & 0xff]; + if (row) { + const char *s = row[cp & 0xff]; + if (s) { + const int c = strlen(row[cp & 0xff]); + memcpy_s(dest, dmax, row[cp & 0xff], c); + return c; + } else { + *dest = 0; + return 0; + } + } else { + *dest = 0; + return 0; + } + } + } +#else + /* the new format generated with cperl Unicode-Normalize/mkheader -uni -ind -std + */ + const UN8IF_canon_PLANE_T **plane, *row; + if (unlikely(dmax < 5)) { + *dest = 0; + return -ESNOSPC; + } + plane = UN8IF_canon[cp >> 16]; + if (!plane) { /* Only the first 3 of 16 are filled */ + return 0; + } + row = plane[(cp >> 8) & 0xff]; + if (row) { /* the first row is pretty filled, the rest very sparse */ + const UN8IF_canon_PLANE_T vi = row[cp & 0xff]; + if (!vi) + return 0; +#if UN8IF_canon_exc_size > 0 + /* overlong: search in extra list */ + else if (unlikely(vi == (uint16_t)-1)) { + UN8IF_canon_exc_t *e; + assert(UN8IF_canon_exc_size); + e = (UN8IF_canon_exc_t *)bsearch( + &cp, &UN8IF_canon_exc, UN8IF_canon_exc_size, + sizeof(UN8IF_canon_exc[0]), _bsearch_exc); + if (e) { + size_t l = strlen(e->v); + memcpy(dest, e->v, l + 1); /* incl \0 */ + return (int)l; + } + return 0; + } +#endif + else { + /* value => length-index and offset */ + const int l = UN8IF_canon_LEN(vi); + const int i = UN8IF_canon_IDX(vi); + const char *tbl = (const char *)UN8IF_canon_tbl[l - 1]; +#if SIZEOF_WCHAR_T > 2 + const int len = l; +#else + /* unw16ifcan.h needs TBL(5) for len 6. UN8IF_canon_MAXLEN */ + const int len = (l == 5) ? 6 : l; +#endif +#if defined(DEBUG) + printf("U+%04X vi=0x%x (>>12, &fff) => TBL(%d)|%d\n", cp, vi, l, i); +#endif +#if SIZEOF_WCHAR_T > 2 + assert(l > 0 && l <= 4); + /* 13.0: tbl sizes: (917,763,227,36) */ + /* l: 1-4 */ + assert((l == 1 && i < 917) || (l == 2 && i < 763) || + (l == 3 && i < 227) || (l == 4 && i < 36) || 0); + assert(dmax > 4); +#endif + memcpy(dest, &tbl[i * len], len); /* 33% perf */ + dest[len] = L'\0'; + return len; + } + } else { + return 0; + } +#endif +} + +#ifdef HAVE_NORM_COMPAT + +static int _u8decomp_compat_s(char *dest, rsize_t dmax, uint32_t cp) { +#ifndef NORMALIZE_IND_TBL + /* the old big format */ + if (unlikely(dmax < 19)) { + *dest = 0; + return -ESNOSPC; + } else { + const char ***plane = UN8F_compat[cp >> 16]; + if (!plane) { + return 0; + } else { + const char **row = plane[(cp >> 8) & 0xff]; + if (row) { + const char *s = row[cp & 0xff]; + if (s) { + const int c = strlen(row[cp & 0xff]); + memcpy_s(dest, dmax, row[cp & 0xff], c); + dest[c] = L'\0'; + return c; + } else { + *dest = 0; + return 0; + } + } else { + *dest = 0; + return 0; + } + } + } +#else + /* the new format generated with cperl Unicode-Normalize/mkheader -uni -ind -std + */ + const UN8IF_compat_PLANE_T **plane, *row; + plane = UN8IF_compat[cp >> 16]; + if (!plane) { /* Only the first 3 of 16 are filled */ + return 0; + } + row = plane[(cp >> 8) & 0xff]; + if (row) { /* the first row is pretty filled, the rest very sparse */ + const UN8IF_compat_PLANE_T vi = row[cp & 0xff]; + if (!vi) + return 0; +#if UN8IF_compat_exc_size > 0 + else if (unlikely(vi == + (uint16_t)-1)) { /* overlong: search in extra list */ + UN8IF_compat_exc_t *e; + assert(UN8IF_compat_exc_size); +#if 1 + e = (UN8IF_compat_exc_t *)bsearch( + &cp, &UN8IF_compat_exc, UN8IF_compat_exc_size, + sizeof(UN8IF_compat_exc[0]), _bsearch_exc); + if (e) { + size_t l = strlen(e->v); + memcpy(dest, e->v, l + 1); /* incl \0 */ + return (int)l; + } +#else + for (e = (UN8IF_compat_exc_t *)UN8IF_compat_exc; e->cp; e++) { + if (cp == e->cp) { + size_t l = strlen(e->v); + if (unlikely(dmax < l)) { + *dest = 0; + return -(ESNOSPC); + } + /*assert(l < dmax);*/ + memcpy(dest, e->v, l + 1); /* incl \0 */ + return (int)l; + } else if (cp < e->cp) + break; + } +#endif + return 0; +#endif + } else { + /* value => length and index */ + const int l = UN8IF_compat_LEN(vi); + const int i = UN8IF_compat_IDX(vi); + const char *tbl = (const char *)UN8IF_compat_tbl[l - 1]; +#if 0 && defined(DEBUG) + printf("U+%04X vi=0x%x (>>12, &&fff) => TBL(%d)|%d\n", cp, vi, l, i); +#endif + if (unlikely(dmax < (rsize_t)l)) { + *dest = 0; + return -(ESNOSPC); + } + memcpy(dest, &tbl[i * l], l); + dest[l] = L'\0'; + return l; + } + } else { + return 0; + } +#endif +} +#endif + +static int _u8decomp_hangul_s(char *dest, rsize_t dmax, uint32_t cp) { + uint32_t sindex = cp - Hangul_SBase; + uint32_t lindex = sindex / Hangul_NCount; + uint32_t vindex = (sindex % Hangul_NCount) / Hangul_TCount; + uint32_t tindex = sindex % Hangul_TCount; + + if (unlikely(dmax < 4)) { + return -(ESNOSPC); + } + + dest[0] = lindex + Hangul_LBase; + dest[1] = vindex + Hangul_VBase; + if (tindex) { + dest[2] = tindex + Hangul_TBase; + dest[3] = 0; + return 3; + } else { + dest[2] = 0; + return 2; + } +} + +/* codepoint canonical decomposition. + dmax should be > 4, + 19 with the single arabic outlier U+FDFA for compat accepted, + but we only do canon here. + returns a negative errno_t on error +*/ + +EXPORT int _u8decomp_s(char *restrict dest, rsize_t dmax, const uint32_t cp, + const bool iscompat) { + /*assert(dmax > 4);*/ + + /* The costly is_HANGUL_cp_high(cp) checks also all composing chars. + Hangul_IsS only for the valid start points. Which we can do here. */ + if (Hangul_IsS(cp)) { + return _u8decomp_hangul_s(dest, dmax, cp); + } else { +#ifdef HAVE_NORM_COMPAT + return iscompat ? _u8decomp_compat_s(dest, dmax, cp) + : _u8decomp_canonical_s(dest, dmax, cp); +#else + (void)iscompat; + return _u8decomp_canonical_s(dest, dmax, cp); +#endif + } +} + +/* canonical ordering of combining characters (c.c.). */ +typedef struct { + uint8_t cc; /* combining class */ + uint32_t cp; /* codepoint */ + size_t pos; /* position */ +} UN8IF_cc; + +/* rc = u8norm_reorder_s(tmp, len+1, dest); */ +static int _compare_cc(const void *a, const void *b) { + int ret_cc; + ret_cc = ((UN8IF_cc *)a)->cc - ((UN8IF_cc *)b)->cc; + if (ret_cc) + return ret_cc; + + return (((UN8IF_cc *)a)->pos > ((UN8IF_cc *)b)->pos) - + (((UN8IF_cc *)a)->pos < ((UN8IF_cc *)b)->pos); +} + +static uint32_t _composite_cp(uint32_t cp, uint32_t cp2) { + const UN8IF_complist_s ***plane, **row, *cell; + + if (unlikely(!cp2)) { + invoke_safe_str_constraint_handler("u8norm_compose_s: " + "cp is 0", + NULL, ESZEROL); + return 0; + } + +#if SIZEOF_WCHAR_T > 2 + if (unlikely((_UNICODE_MAX < cp) || (_UNICODE_MAX < cp2))) { + return -(ESLEMAX); + } +#endif + + if (Hangul_IsL(cp) && Hangul_IsV(cp2)) { + uint32_t lindex = cp - Hangul_LBase; + uint32_t vindex = cp2 - Hangul_VBase; + return (Hangul_SBase + + (lindex * Hangul_VCount + vindex) * Hangul_TCount); + } + if (Hangul_IsLV(cp) && Hangul_IsT(cp2)) { + uint32_t tindex = cp2 - Hangul_TBase; + return (cp + tindex); + } + plane = UN8IF_compos[cp >> 16]; + if (!plane) { /* only 3 of 16 are defined */ + return 0; + } + row = plane[(cp >> 8) & 0xff]; + if (!row) { /* the zero plane is pretty filled, the others sparse */ + return 0; + } + cell = row[cp & 0xff]; + if (!cell) { + return 0; + } + /* no indirection here, but search in the composition lists */ + /* only 16 lists 011099-01d1bc need uint32, the rest can be short, uint16 */ + /* TODO: above which length is bsearch faster? + But then we'd need to store the lengths also */ + if (likely(cp < UN8IF_COMPLIST_FIRST_LONG)) { + UN8IF_complist_s *i; + for (i = (UN8IF_complist_s *)cell; i->nextchar; i++) { + if ((uint16_t)cp2 == i->nextchar) { + return (uint32_t)(i->composite); + } else if ((uint16_t)cp2 < i->nextchar) { /* nextchar is sorted */ + break; + } + } + } else { + UN8IF_complist *i; + GCC_DIAG_IGNORE(-Wcast-align) + for (i = (UN8IF_complist *)cell; i->nextchar; i++) { + GCC_DIAG_RESTORE + if (cp2 == i->nextchar) { + return i->composite; + } else if (cp2 < i->nextchar) { /* nextchar is sorted */ + break; + } + } + } + return 0; +} + +static uint8_t _combin_class(uint32_t cp) { + const uint8_t **plane, *row; + plane = UN8IF_combin[cp >> 16]; + if (!plane) + return 0; + row = plane[(cp >> 8) & 0xff]; + if (row) + return row[cp & 0xff]; + else + return 0; +} + +/** + * @def u8norm_decompose_s(dest,dmax,src,lenp,iscompat) + * @brief + * Converts the utf-8 string to the canonical NFD normalization, + * as defined in the latest Unicode standard, latest 10.0. The conversion + * stops at the first null or after dmax characters. + * + * @details + * Composed characters are checked for the left-hand-size of the + * Decomposition_Mapping Unicode property, which means the codepoint will + * be normalized if the sequence is composed. + * This is equivalent to all 1963 combining mark characters, plus some + * remaining 869 non-mark and non-hangul normalizables. Hangul has some + * special normalization logic. + * + * This function is used by \c u8norm_s() to do the argument checking, + * overlap checking and to do the first of three passes for NFC. + * + * @param[out] dest utf-8 string to hold the result + * @param[in] dmax maximum result buffer size + * @param[in] src utf-8 string + * @param[out] lenp pointer to length of the result, may be NULL + * @param[in] iscompat do NFKD, and not NFD (with \c --enable-norm-compat) + * + * @pre dest and src shall not be null pointers. + * @pre dmax shall not equal zero and big enough for dest. + * @pre dmax shall not be greater than RSIZE_MAX_STR and size of dest. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_STR, then u8norm_s nulls dest. + * @retval EOK on success + * @retval ESNULLP when dest or src is NULL pointer + * @retval ESZEROL when dmax = 0 + * @retval ESLEMIN when dmax < 5 or 19 with a compat mode + * @retval ESLEMAX when dmax > RSIZE_MAX_STR + * @retval EOVERFLOW when dmax > size of dest (optionally, when the compiler + * knows the object_size statically) + * @retval ESLEWRNG when dmax != size of dest and --enable-error-dmax + * @retval ESOVRLP when buffers overlap + * @retval ESNOSPC when dmax too small for the result buffer + * @retval EOF on some normalization error + * + * @see + * u8fc_s(), u8norm_s(), u8norm_compose_s(), u8norm_reorder_s(), + * ICU, gnulib/libunistring, utf8proc + */ + +/* create an unordered decomposed utf-8 string */ +#ifdef FOR_DOXYGEN +errno_t u8norm_decompose_s(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, + const bool iscompat) +#else +EXPORT errno_t _u8norm_decompose_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, + const bool iscompat, + const size_t destbos) +#endif +{ + rsize_t orig_dmax; + char *orig_dest; + const char *overlap_bumper; + uint32_t cp; + int c; + + if (lenp) + *lenp = 0; + CHK_DEST_NULL("u8norm_s") + if (unlikely(src == NULL)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "src is null", + dest, ESNULLP); + *dest = 0; + return RCNEGATE(ESNULLP); + } + if (unlikely(dmax == 0)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "dmax is 0", + dest, ESZEROL); + *dest = 0; + return RCNEGATE(ESZEROL); + } + if (unlikely(dmax < 5)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "dmax < 5", + dest, ESLEMIN); + *dest = 0; + return RCNEGATE(ESLEMIN); + } + + if (unlikely(dmax > RSIZE_MAX_STR)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "dmax exceeds max", + dest, ESLEMAX); + *dest = 0; + return RCNEGATE(ESLEMAX); + } + if (destbos == BOS_UNKNOWN) { + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DEST_OVR_CLEAR("u8fc_s", destbos) + } + + if (unlikely(dest == src)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "overlapping objects", + dest, ESOVRLP); + return RCNEGATE(ESOVRLP); + } +#ifndef HAVE_NORM_COMPAT + if (iscompat) { + invoke_safe_str_constraint_handler( + "u8norm_s: " + "not configured with --enable-norm-compat", + dest, EOF); + *dest = 0; + return RCNEGATE(EOF); + } +#else + if (unlikely(iscompat && dmax < 19)) { + invoke_safe_str_constraint_handler("u8norm_s: " + "dmax is < 19", + dest, ESLEMIN); + *dest = 0; + return RCNEGATE(ESLEMIN); + } +#endif + + /* hold base of dest in case src was not copied */ + orig_dmax = dmax; + orig_dest = dest; + + if (dest < src) { + overlap_bumper = src; + + while (dmax > 0) { + cp = _dec_w16(src); + if (unlikely(dest == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } + /* A surrogate pair can only represent max _UNICODE_MAX */ +#if SIZEOF_WCHAR_T > 2 + if (unlikely(_UNICODE_MAX < cp)) { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "cp is too high", + ESLEMAX); + return RCNEGATE(ESLEMAX); + } +#endif + if (!cp) + goto done; + + c = _u8decomp_s(dest, dmax, cp, iscompat); + if (c > 0) { + dest += c; + dmax -= c; +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) { + src++; + } +#endif + } else if (c == 0) { +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) { + *dest++ = *src++; + dmax--; + } +#endif + *dest++ = *src; + dmax--; + } else { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "decomposition error", + -c); + return -c; + } + src++; + } + } else { + overlap_bumper = dest; + + while (dmax > 0) { + cp = _dec_w16(src); + if (unlikely(src == overlap_bumper)) { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "overlapping objects", + ESOVRLP); + return RCNEGATE(ESOVRLP); + } +#if SIZEOF_WCHAR_T > 2 + if (unlikely(_UNICODE_MAX < cp)) { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "cp is too high", + ESLEMAX); + return RCNEGATE(ESLEMAX); + } +#endif + if (!cp) + goto done; + + c = _u8decomp_s(dest, dmax, cp, iscompat); + if (c > 0) { + dest += c; + dmax -= c; +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) + src++; +#endif + } else if (c == 0) { +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) { + *dest++ = *src++; + dmax--; + } +#endif + *dest++ = *src; + dmax--; + } else { + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "decomposition error", + -c); + return RCNEGATE(-c); + } + src++; + } + } + + if (lenp) + *lenp = orig_dmax - dmax; + handle_error(orig_dest, orig_dmax, + "u8norm_decompose_s: " + "dmax too small", + ESNOSPC); + return RCNEGATE(ESNOSPC); + +done: + if (lenp) + *lenp = orig_dmax - dmax; +#ifdef SAFECLIB_STR_NULL_SLACK + memset(dest, 0, dmax); +#else + *dest = 0; +#endif + return EOK; +} + +/** + * @def u8norm_reorder_s(dest,dmax,src,len) + * @brief + * Reorder all decomposed sequences in a utf-8 string to NFD, + * as defined in the latest Unicode standard, latest 10.0. The conversion + * stops at the first null or after dmax characters. + * + * @param[out] dest utf-8 string to hold the result + * @param[in] dmax maximum result buffer size + * @param[in] src utf-8 string to be converted + * @param[in] len length of src + * + * @pre dest and src shall not be null pointers. + * @pre dmax shall not equal zero and big enough for dest. + * @pre dmax shall not be greater than RSIZE_MAX_STR. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_STR, then \c u8norm_reorder_s nulls + * dest. + * @retval EOK on success + * @retval ESNOSPC when dmax too small for the result buffer + * @retval EOF on some normalization error + * + * @see + * u8norm_s(), u8norm_decompose_s(), ICU, gnulib/libunistring, utf8proc + */ + +/* reorder decomposed sequence to NFD */ +#ifdef FOR_DOXYGEN +errno_t u8norm_reorder_s(char *restrict dest, rsize_t dmax, const char *restrict src, + const rsize_t len) +#else +EXPORT errno_t _u8norm_reorder_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, const rsize_t len, + const size_t destbos) +#endif +{ + UN8IF_cc seq_ary[CC_SEQ_SIZE]; + UN8IF_cc *seq_ptr = (UN8IF_cc *)seq_ary; /* start with stack */ + UN8IF_cc *seq_ext = NULL; /* heap when needed */ + size_t seq_max = CC_SEQ_SIZE; + size_t cc_pos = 0; + char *p = (char *)src; + const char *e = p + len; + char *orig_dest = dest; + rsize_t orig_dmax = dmax; + + if (destbos == BOS_UNKNOWN) { + CHK_DMAX_MAX("u8norm_reorder_s", RSIZE_MAX_STR) + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + CHK_DEST_OVR_CLEAR("u8norm_reorder_s", destbos) + } + + while (p < e) { + uint8_t cur_cc; + uint32_t cp = _dec_w16(p); + p++; +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) { + p++; + } +#endif + + cur_cc = _combin_class(cp); + if (cur_cc != 0) { + if (seq_max < cc_pos + 1) { /* extend if need */ + seq_max = cc_pos + CC_SEQ_STEP; /* new size */ + if (CC_SEQ_SIZE == cc_pos) { /* seq_ary full */ + seq_ext = (UN8IF_cc *)malloc(seq_max * sizeof(UN8IF_cc)); + memcpy(seq_ext, seq_ary, cc_pos * sizeof(UN8IF_cc)); + } else { + seq_ext = (UN8IF_cc *)realloc(seq_ext, + seq_max * sizeof(UN8IF_cc)); + } + seq_ptr = seq_ext; /* use seq_ext from now */ + } + + seq_ptr[cc_pos].cc = cur_cc; + seq_ptr[cc_pos].cp = cp; + seq_ptr[cc_pos].pos = cc_pos; + ++cc_pos; + + if (p < e) + continue; + } + + /* output */ + if (cc_pos) { + size_t i; + + if (unlikely(dmax - cc_pos <= 0)) { + handle_error(orig_dest, orig_dmax, + "u8norm_reorder_s: " + "dmax too small", + ESNOSPC); + return RCNEGATE(ESNOSPC); + } + + if (cc_pos > 1) /* reorder if there are two Combining Classes */ + qsort((void *)seq_ptr, cc_pos, sizeof(UN8IF_cc), _compare_cc); + + for (i = 0; i < cc_pos; i++) { + _ENC_W16(dest, dmax, seq_ptr[i].cp); + } + cc_pos = 0; + } + + if (cur_cc == 0) { + _ENC_W16(dest, dmax, cp); + } + + if (unlikely(!dmax)) { + handle_error(orig_dest, orig_dmax, + "u8norm_reorder_s: " + "dmax too small", + ESNOSPC); + return RCNEGATE(ESNOSPC); + } + } + if (seq_ext) + free(seq_ext); + /* surrogate pairs can actually collapse */ +#if defined(SAFECLIB_STR_NULL_SLACK) && SIZEOF_WCHAR_T == 2 + memset(dest, 0, dmax); +#else + *dest = 0; +#endif + return EOK; +} + +/** + * @def u8norm_compose_s(dest,dmax,src,lenp,iscontig) + * @brief + * Combine all decomposed sequences in a utf-8 string to NFC, + * as defined in the latest Unicode standard, latest 13.0. The conversion + * stops at the first null or after dmax characters. + * + * @param[out] dest utf-8 string to hold the result + * @param[in] dmax maximum result buffer size + * @param[in] src utf-8 string to be converted + * @param[out] lenp pointer to length of p and the result length. + * @param[in] iscontig if true, the result will only be a fast FCC + * + * @pre dest, src and lenp shall not be null pointers. + * @pre dmax shall not equal zero and big enough for dest. + * @pre dmax shall not be greater than RSIZE_MAX_STR. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_STR, then \c u8norm_reorder_s nulls + * dest. + * @retval EOK on success + * @retval ESNOSPC when dmax too small for the result buffer + * @retval EOF on some normalization error + * + * @see + * u8norm_s(), u8norm_decompose_s(), ICU, gnulib/libunistring, utf8proc + */ + +/* combine decomposed sequences to NFC. */ +/* iscontig = false; composeContiguous? FCC if true */ +#ifdef FOR_DOXYGEN +errno_t u8norm_compose_s(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, + const bool iscontig) +#else +EXPORT errno_t _u8norm_compose_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + rsize_t *restrict lenp, + const bool iscontig, + const size_t destbos) +#endif +{ + char *p = (char *)src; + const char *e = p + *lenp; + uint32_t cpS = 0; /* starter code point */ + bool valid_cpS = false; /* if false, cpS isn't initialized yet */ + uint8_t pre_cc = 0; + + uint32_t seq_ary[CC_SEQ_SIZE]; + uint32_t *seq_ptr = (uint32_t *)seq_ary; /* either stack or heap */ + uint32_t *seq_ext = NULL; /* heap */ + size_t seq_max = CC_SEQ_SIZE; + size_t cc_pos = 0; + char *orig_dest = dest; + rsize_t orig_dmax = dmax; + + if (destbos == BOS_UNKNOWN) { + if (unlikely(dmax > RSIZE_MAX_STR)) { + *lenp = 0; + invoke_safe_str_constraint_handler("u8norm_compose_s: " + "dmax exceeds max", + (void *)dest, ESLEMAX); + return ESLEMAX; + } + BND_CHK_PTR_BOUNDS(dest, dmax); + } else { + const size_t destsz = dmax; + if (unlikely(destsz > destbos)) { + *lenp = 0; + handle_error(dest, destbos / sizeof(char), + "u8norm_compose_s: dmax exceeds dest", EOVERFLOW); + return EOVERFLOW; + } + } + + while (p < e) { + uint8_t cur_cc; + uint32_t cp = _dec_w16(p); + p++; +#if SIZEOF_WCHAR_T == 2 + if (cp > 0xffff) { + p++; + } +#endif + + cur_cc = _combin_class(cp); + + if (!valid_cpS) { + if (cur_cc == 0) { + cpS = cp; /* found the first Starter */ + valid_cpS = true; + if (p < e) + continue; + } else { + _ENC_W16(dest, dmax, cp); + if (unlikely(!dmax)) { + handle_error(orig_dest, orig_dmax, + "u8norm_compose_s: " + "dmax too small", + ESNOSPC); + return RCNEGATE(ESNOSPC); + } + continue; + } + } else { + bool composed; + + /* blocked */ + if ((iscontig && cc_pos) || /* discontiguous combination (FCC) */ + (cur_cc != 0 && pre_cc == cur_cc) || /* blocked by same CC */ + (pre_cc > cur_cc)) /* blocked by higher CC: revised D2 */ + composed = false; + + /* not blocked: + iscontig && cc_pos == 0 -- contiguous combination + cur_cc == 0 && pre_cc == 0 -- starter + starter + cur_cc != 0 && pre_cc < cur_cc -- lower CC */ + else { + /* try composition */ + uint32_t cpComp = _composite_cp(cpS, cp); + + if (cpComp && !isExclusion(cpComp)) { + cpS = cpComp; + composed = true; + + /* pre_cc should not be changed to cur_cc */ + /* e.g. 1E14 = 0045 0304 0300 where CC(0304) == CC(0300) */ + if (p < e) + continue; + } else + composed = false; + } + + if (!composed) { + pre_cc = cur_cc; + if (cur_cc != 0 || !(p < e)) { + if (seq_max < cc_pos + 1) { /* extend if need */ + seq_max = cc_pos + CC_SEQ_STEP; /* new size */ + if (CC_SEQ_SIZE == cc_pos) { /* seq_ary full */ + seq_ext = + (uint32_t *)malloc(seq_max * sizeof(uint32_t)); + memcpy(seq_ext, seq_ary, cc_pos * sizeof(uint32_t)); + } else { + seq_ext = (uint32_t *)realloc( + seq_ext, seq_max * sizeof(uint32_t)); + } + seq_ptr = seq_ext; /* use seq_ext from now */ + } + seq_ptr[cc_pos] = cp; + ++cc_pos; + } + if (cur_cc != 0 && p < e) + continue; + } + } + + /* output */ + _ENC_W16(dest, dmax, cpS); /* starter (composed or not) */ + if (unlikely(!dmax)) { + handle_error(orig_dest, orig_dmax, + "u8norm_compose_s: " + "dmax too small", + ESNOSPC); + return RCNEGATE(ESNOSPC); + } + + if (cc_pos == 1) { + _ENC_W16(dest, dmax, *seq_ptr); + cc_pos = 0; + } else if (cc_pos > 1) { + memcpy(dest, seq_ptr, cc_pos * sizeof(char)); + dest += cc_pos; + dmax -= cc_pos; + cc_pos = 0; + } + + cpS = cp; + } + if (seq_ext) + free(seq_ext); + +#ifdef SAFECLIB_STR_NULL_SLACK + memset(dest, 0, dmax); +#else + *dest = 0; +#endif + *lenp = orig_dmax - dmax; + return EOK; +} + +/** + * @def u8norm_s(dest,dmax,src,mode,lenp) + * @brief + * Converts the utf-8 string to the canonical NFC or NFD normalization, + * as defined in the latest Unicode standard, latest 13.0. The conversion + * stops at the first null or after dmax characters. + * + * @details + * Decomposed characters are checked for the left-hand-size and then + * right-hand-side of the Decomposition_Mapping Unicode property, which + * means the codepoint will be normalized if the sequence is composed or + * decomposed (NFD or NFKD). This is equivalent to all 1963 combining mark + * characters, plus some remaining 869 non-mark and non-hangul + * normalizables. Hangul has some special normalization logic. + * + * The compat tables for NFKC or NFKD are too large for a libc, and + * mostly unused. As default we only provide the smaller canonical + * conversions, but it can be enabled with \c --enable-norm-compat. + * The compat modes also don't roundtrip. + * + * @param[out] dest utf-8 string to hold the result + * @param[in] dmax maximum length of string + * @param[in] src utf-8 string + * @param[in] mode convert to nfc or just nfd. + * experimentally to fast modes FCD or FCC. + * optionally to compat modes NFKD, NFKC with \c + * --enable-norm-compat + * @see enum \c u8norm_mode. + * @param[out] lenp pointer to length of the result, may be NULL + * + * @pre dest and src shall not be null pointers. + * @pre dmax shall not equal zero and big enough for dest. + * @pre dmax shall not be greater than RSIZE_MAX_STR. + * + * @return If there is a runtime-constraint violation, then if dest + * is not a null pointer and dmax is greater than zero and + * not greater than RSIZE_MAX_STR, then u8norm_s nulls dest. + * @retval EOK on success + * @retval ESNULLP when dest or src is NULL pointer + * @retval ESZEROL when dmax = 0 + * @retval ESLEMIN when dmax < 5 + * @retval ESLEMAX when dmax > RSIZE_MAX_STR + * @retval ESOVRLP when buffers overlap + * @retval ESNOSPC when dmax too small for the result buffer + * @retval EOF any other normalization error + * + * @see + * u8fc_s(), ICU, gnulib/libunistring, utf8proc + */ + +/* Normalize to NFC, NFD, FCC, FCD (fastest, used in u8fc_s), and + * optionally NFKD, NFKC */ +#ifdef FOR_DOXYGEN +errno_t u8norm_s(char *restrict dest, rsize_t dmax, const char *restrict src, + const wcsnorm_mode_t mode, rsize_t *restrict lenp) +#else +EXPORT errno_t _u8norm_s_chk(char *restrict dest, rsize_t dmax, + const char *restrict src, + const wcsnorm_mode_t mode, rsize_t *restrict lenp, + const size_t destbos) +#endif +{ + char tmp_stack[128]; + char *tmp_ptr; + char *tmp = NULL; + rsize_t len; + const bool iscompat = + mode & WCSNORM_NFKD; /* WCSNORM_NFKD or WCSNORM_NFKC */ + + errno_t rc = + _u8norm_decompose_s_chk(dest, dmax, src, &len, iscompat, destbos); + if (lenp) + *lenp = len; + if (unlikely(rc)) + return rc; + if (unlikely(mode == WCSNORM_FCD)) + return EOK; + + /* temp. scratch space, on stack or heap */ + if (len + 2 < 128) + tmp_ptr = tmp_stack; + else + tmp_ptr = tmp = (char *)malloc((len + 2) * sizeof(char)); + + rc = _u8norm_reorder_s_chk(tmp_ptr, len + 2, dest, len, destbos); + if (unlikely(rc)) { + if (tmp) + free(tmp); +#ifdef SAFECLIB_STR_NULL_SLACK + memset(dest, 0, dmax); +#else + *dest = L'\0'; +#endif + return (rc); + } + if (mode == WCSNORM_NFD || mode == WCSNORM_NFKD) { + memcpy(dest, tmp_ptr, len + 1); + if (tmp) + free(tmp); + return (EOK); + } + + rc = _u8norm_compose_s_chk(dest, dmax, tmp_ptr, &len, mode == WCSNORM_FCC, + destbos); + if (tmp) + free(tmp); + if (unlikely(rc)) + return (rc); + if (lenp) + *lenp = len; + + return (EOK); +} diff --git a/src/extu8/un8ifcan.h b/src/extu8/un8ifcan.h new file mode 100644 index 000000000..ed56535ea --- /dev/null +++ b/src/extu8/un8ifcan.h @@ -0,0 +1,1942 @@ +/* ex: set ro ft=c: -*- buffer-read-only: t -*- + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is auto-generated by Unicode-Normalize 1.27 + * mkheader -ind -std + * for Unicode 13.0.0 UTF-8 + * Any changes here will be lost! + */ +/* Canonical Decomposition */ + +/* Using now indirect tables with indices into the unique values */ +/* even sparing the final \0 */ + +#undef NORMALIZE_IND_TBL +#define NORMALIZE_IND_TBL +/* tbl sizes: (3,8,1173,302,162,231,,53,2,,,9) */ +/* l: 1-12 */ +/* max size: 1173 0x495 */ +#define UN8IF_canon_MAXLEN 5 +#define TBL(i) ((i-1) << 11) +/* value = (const char*)&UN8IF_canon_tbl[LEN-1][IDX] */ +#define UN8IF_canon_LEN(v) (((v) >> 11) + 1) +#define UN8IF_canon_IDX(v) ((v) & 0x7ff) +#define UN8IF_canon_PLANE_T uint16_t + +/* the values */ +static const char UN8IF_canon_tbl_1 [3][1] = { + /* 0 */ {';'}, {'K'}, {'`'}}; + +static const char UN8IF_canon_tbl_2 [8][2] = { + /* 0 */ {'\xc2','\xb4'}, {'\xc2','\xb7'}, {'\xca','\xb9'}, {'\xcc','\x80'}, {'\xcc','\x81'}, {'\xcc','\x93'}, {'\xce','\xa9'}, {'\xce','\xb9'}}; + +static const char UN8IF_canon_tbl_3 [1173][3] = { + /* 0 */ {'<','\xcc','\xb8'}, {'=','\xcc','\xb8'}, {'>','\xcc','\xb8'}, {'A','\xcc','\x80'}, {'A','\xcc','\x81'}, {'A','\xcc','\x82'}, {'A','\xcc','\x83'}, {'A','\xcc','\x84'}, + /* 8 */ {'A','\xcc','\x86'}, {'A','\xcc','\x87'}, {'A','\xcc','\x88'}, {'A','\xcc','\x89'}, {'A','\xcc','\x8a'}, {'A','\xcc','\x8c'}, {'A','\xcc','\x8f'}, {'A','\xcc','\x91'}, + /* 16 */ {'A','\xcc','\xa3'}, {'A','\xcc','\xa5'}, {'A','\xcc','\xa8'}, {'B','\xcc','\x87'}, {'B','\xcc','\xa3'}, {'B','\xcc','\xb1'}, {'C','\xcc','\x81'}, {'C','\xcc','\x82'}, + /* 24 */ {'C','\xcc','\x87'}, {'C','\xcc','\x8c'}, {'C','\xcc','\xa7'}, {'D','\xcc','\x87'}, {'D','\xcc','\x8c'}, {'D','\xcc','\xa3'}, {'D','\xcc','\xa7'}, {'D','\xcc','\xad'}, + /* 32 */ {'D','\xcc','\xb1'}, {'E','\xcc','\x80'}, {'E','\xcc','\x81'}, {'E','\xcc','\x82'}, {'E','\xcc','\x83'}, {'E','\xcc','\x84'}, {'E','\xcc','\x86'}, {'E','\xcc','\x87'}, + /* 40 */ {'E','\xcc','\x88'}, {'E','\xcc','\x89'}, {'E','\xcc','\x8c'}, {'E','\xcc','\x8f'}, {'E','\xcc','\x91'}, {'E','\xcc','\xa3'}, {'E','\xcc','\xa7'}, {'E','\xcc','\xa8'}, + /* 48 */ {'E','\xcc','\xad'}, {'E','\xcc','\xb0'}, {'F','\xcc','\x87'}, {'G','\xcc','\x81'}, {'G','\xcc','\x82'}, {'G','\xcc','\x84'}, {'G','\xcc','\x86'}, {'G','\xcc','\x87'}, + /* 56 */ {'G','\xcc','\x8c'}, {'G','\xcc','\xa7'}, {'H','\xcc','\x82'}, {'H','\xcc','\x87'}, {'H','\xcc','\x88'}, {'H','\xcc','\x8c'}, {'H','\xcc','\xa3'}, {'H','\xcc','\xa7'}, + /* 64 */ {'H','\xcc','\xae'}, {'I','\xcc','\x80'}, {'I','\xcc','\x81'}, {'I','\xcc','\x82'}, {'I','\xcc','\x83'}, {'I','\xcc','\x84'}, {'I','\xcc','\x86'}, {'I','\xcc','\x87'}, + /* 72 */ {'I','\xcc','\x88'}, {'I','\xcc','\x89'}, {'I','\xcc','\x8c'}, {'I','\xcc','\x8f'}, {'I','\xcc','\x91'}, {'I','\xcc','\xa3'}, {'I','\xcc','\xa8'}, {'I','\xcc','\xb0'}, + /* 80 */ {'J','\xcc','\x82'}, {'K','\xcc','\x81'}, {'K','\xcc','\x8c'}, {'K','\xcc','\xa3'}, {'K','\xcc','\xa7'}, {'K','\xcc','\xb1'}, {'L','\xcc','\x81'}, {'L','\xcc','\x8c'}, + /* 88 */ {'L','\xcc','\xa3'}, {'L','\xcc','\xa7'}, {'L','\xcc','\xad'}, {'L','\xcc','\xb1'}, {'M','\xcc','\x81'}, {'M','\xcc','\x87'}, {'M','\xcc','\xa3'}, {'N','\xcc','\x80'}, + /* 96 */ {'N','\xcc','\x81'}, {'N','\xcc','\x83'}, {'N','\xcc','\x87'}, {'N','\xcc','\x8c'}, {'N','\xcc','\xa3'}, {'N','\xcc','\xa7'}, {'N','\xcc','\xad'}, {'N','\xcc','\xb1'}, + /* 104 */ {'O','\xcc','\x80'}, {'O','\xcc','\x81'}, {'O','\xcc','\x82'}, {'O','\xcc','\x83'}, {'O','\xcc','\x84'}, {'O','\xcc','\x86'}, {'O','\xcc','\x87'}, {'O','\xcc','\x88'}, + /* 112 */ {'O','\xcc','\x89'}, {'O','\xcc','\x8b'}, {'O','\xcc','\x8c'}, {'O','\xcc','\x8f'}, {'O','\xcc','\x91'}, {'O','\xcc','\x9b'}, {'O','\xcc','\xa3'}, {'O','\xcc','\xa8'}, + /* 120 */ {'P','\xcc','\x81'}, {'P','\xcc','\x87'}, {'R','\xcc','\x81'}, {'R','\xcc','\x87'}, {'R','\xcc','\x8c'}, {'R','\xcc','\x8f'}, {'R','\xcc','\x91'}, {'R','\xcc','\xa3'}, + /* 128 */ {'R','\xcc','\xa7'}, {'R','\xcc','\xb1'}, {'S','\xcc','\x81'}, {'S','\xcc','\x82'}, {'S','\xcc','\x87'}, {'S','\xcc','\x8c'}, {'S','\xcc','\xa3'}, {'S','\xcc','\xa6'}, + /* 136 */ {'S','\xcc','\xa7'}, {'T','\xcc','\x87'}, {'T','\xcc','\x8c'}, {'T','\xcc','\xa3'}, {'T','\xcc','\xa6'}, {'T','\xcc','\xa7'}, {'T','\xcc','\xad'}, {'T','\xcc','\xb1'}, + /* 144 */ {'U','\xcc','\x80'}, {'U','\xcc','\x81'}, {'U','\xcc','\x82'}, {'U','\xcc','\x83'}, {'U','\xcc','\x84'}, {'U','\xcc','\x86'}, {'U','\xcc','\x88'}, {'U','\xcc','\x89'}, + /* 152 */ {'U','\xcc','\x8a'}, {'U','\xcc','\x8b'}, {'U','\xcc','\x8c'}, {'U','\xcc','\x8f'}, {'U','\xcc','\x91'}, {'U','\xcc','\x9b'}, {'U','\xcc','\xa3'}, {'U','\xcc','\xa4'}, + /* 160 */ {'U','\xcc','\xa8'}, {'U','\xcc','\xad'}, {'U','\xcc','\xb0'}, {'V','\xcc','\x83'}, {'V','\xcc','\xa3'}, {'W','\xcc','\x80'}, {'W','\xcc','\x81'}, {'W','\xcc','\x82'}, + /* 168 */ {'W','\xcc','\x87'}, {'W','\xcc','\x88'}, {'W','\xcc','\xa3'}, {'X','\xcc','\x87'}, {'X','\xcc','\x88'}, {'Y','\xcc','\x80'}, {'Y','\xcc','\x81'}, {'Y','\xcc','\x82'}, + /* 176 */ {'Y','\xcc','\x83'}, {'Y','\xcc','\x84'}, {'Y','\xcc','\x87'}, {'Y','\xcc','\x88'}, {'Y','\xcc','\x89'}, {'Y','\xcc','\xa3'}, {'Z','\xcc','\x81'}, {'Z','\xcc','\x82'}, + /* 184 */ {'Z','\xcc','\x87'}, {'Z','\xcc','\x8c'}, {'Z','\xcc','\xa3'}, {'Z','\xcc','\xb1'}, {'\xe2','\x80','\x82'}, {'\xe2','\x80','\x83'}, {'\xe3','\x80','\x88'}, {'\xe3','\x80','\x89'}, + /* 192 */ {'\xe3','\x92','\x9e'}, {'\xe3','\x92','\xb9'}, {'\xe3','\x92','\xbb'}, {'\xe3','\x93','\x9f'}, {'\xe3','\x94','\x95'}, {'\xe3','\x9b','\xae'}, {'\xe3','\x9b','\xbc'}, {'\xe3','\x9e','\x81'}, + /* 200 */ {'\xe3','\xa0','\xaf'}, {'\xe3','\xa1','\xa2'}, {'\xe3','\xa1','\xbc'}, {'\xe3','\xa3','\x87'}, {'\xe3','\xa3','\xa3'}, {'\xe3','\xa4','\x9c'}, {'\xe3','\xa4','\xba'}, {'\xe3','\xa8','\xae'}, + /* 208 */ {'\xe3','\xa9','\xac'}, {'\xe3','\xab','\xa4'}, {'\xe3','\xac','\x88'}, {'\xe3','\xac','\x99'}, {'\xe3','\xad','\x89'}, {'\xe3','\xae','\x9d'}, {'\xe3','\xb0','\x98'}, {'\xe3','\xb1','\x8e'}, + /* 216 */ {'\xe3','\xb4','\xb3'}, {'\xe3','\xb6','\x96'}, {'\xe3','\xba','\xac'}, {'\xe3','\xba','\xb8'}, {'\xe3','\xbc','\x9b'}, {'\xe3','\xbf','\xbc'}, {'\xe4','\x80','\x88'}, {'\xe4','\x80','\x98'}, + /* 224 */ {'\xe4','\x80','\xb9'}, {'\xe4','\x81','\x86'}, {'\xe4','\x82','\x96'}, {'\xe4','\x83','\xa3'}, {'\xe4','\x84','\xaf'}, {'\xe4','\x88','\x82'}, {'\xe4','\x88','\xa7'}, {'\xe4','\x8a','\xa0'}, + /* 232 */ {'\xe4','\x8c','\x81'}, {'\xe4','\x8c','\xb4'}, {'\xe4','\x8d','\x99'}, {'\xe4','\x8f','\x95'}, {'\xe4','\x8f','\x99'}, {'\xe4','\x90','\x8b'}, {'\xe4','\x91','\xab'}, {'\xe4','\x94','\xab'}, + /* 240 */ {'\xe4','\x95','\x9d'}, {'\xe4','\x95','\xa1'}, {'\xe4','\x95','\xab'}, {'\xe4','\x97','\x97'}, {'\xe4','\x97','\xb9'}, {'\xe4','\x98','\xb5'}, {'\xe4','\x9a','\xbe'}, {'\xe4','\x9b','\x87'}, + /* 248 */ {'\xe4','\xa6','\x95'}, {'\xe4','\xa7','\xa6'}, {'\xe4','\xa9','\xae'}, {'\xe4','\xa9','\xb6'}, {'\xe4','\xaa','\xb2'}, {'\xe4','\xac','\xb3'}, {'\xe4','\xaf','\x8e'}, {'\xe4','\xb3','\x8e'}, + /* 256 */ {'\xe4','\xb3','\xad'}, {'\xe4','\xb3','\xb8'}, {'\xe4','\xb5','\x96'}, {'\xe4','\xb8','\x8d'}, {'\xe4','\xb8','\xa6'}, {'\xe4','\xb8','\xb2'}, {'\xe4','\xb8','\xb8'}, {'\xe4','\xb8','\xb9'}, + /* 264 */ {'\xe4','\xb8','\xbd'}, {'\xe4','\xb9','\x81'}, {'\xe4','\xba','\x82'}, {'\xe4','\xba','\x86'}, {'\xe4','\xba','\xae'}, {'\xe4','\xbb','\x80'}, {'\xe4','\xbb','\x8c'}, {'\xe4','\xbb','\xa4'}, + /* 272 */ {'\xe4','\xbd','\xa0'}, {'\xe4','\xbe','\x80'}, {'\xe4','\xbe','\x86'}, {'\xe4','\xbe','\x8b'}, {'\xe4','\xbe','\xae'}, {'\xe4','\xbe','\xbb'}, {'\xe4','\xbe','\xbf'}, {'\xe5','\x80','\x82'}, + /* 280 */ {'\xe5','\x80','\xab'}, {'\xe5','\x81','\xba'}, {'\xe5','\x82','\x99'}, {'\xe5','\x83','\x8f'}, {'\xe5','\x83','\x9a'}, {'\xe5','\x83','\xa7'}, {'\xe5','\x85','\x80'}, {'\xe5','\x85','\x85'}, + /* 288 */ {'\xe5','\x85','\x8d'}, {'\xe5','\x85','\x94'}, {'\xe5','\x85','\xa4'}, {'\xe5','\x85','\xa7'}, {'\xe5','\x85','\xa8'}, {'\xe5','\x85','\xa9'}, {'\xe5','\x85','\xad'}, {'\xe5','\x85','\xb7'}, + /* 296 */ {'\xe5','\x86','\x80'}, {'\xe5','\x86','\x8d'}, {'\xe5','\x86','\x92'}, {'\xe5','\x86','\x95'}, {'\xe5','\x86','\x97'}, {'\xe5','\x86','\xa4'}, {'\xe5','\x86','\xac'}, {'\xe5','\x86','\xb5'}, + /* 304 */ {'\xe5','\x86','\xb7'}, {'\xe5','\x87','\x89'}, {'\xe5','\x87','\x8c'}, {'\xe5','\x87','\x9c'}, {'\xe5','\x87','\x9e'}, {'\xe5','\x87','\xb5'}, {'\xe5','\x88','\x83'}, {'\xe5','\x88','\x87'}, + /* 312 */ {'\xe5','\x88','\x97'}, {'\xe5','\x88','\xa9'}, {'\xe5','\x88','\xba'}, {'\xe5','\x88','\xbb'}, {'\xe5','\x89','\x86'}, {'\xe5','\x89','\xb2'}, {'\xe5','\x89','\xb7'}, {'\xe5','\x8a','\x89'}, + /* 320 */ {'\xe5','\x8a','\x9b'}, {'\xe5','\x8a','\xa3'}, {'\xe5','\x8a','\xb3'}, {'\xe5','\x8b','\x87'}, {'\xe5','\x8b','\x89'}, {'\xe5','\x8b','\x92'}, {'\xe5','\x8b','\x9e'}, {'\xe5','\x8b','\xa4'}, + /* 328 */ {'\xe5','\x8b','\xb5'}, {'\xe5','\x8b','\xba'}, {'\xe5','\x8c','\x85'}, {'\xe5','\x8c','\x86'}, {'\xe5','\x8c','\x97'}, {'\xe5','\x8c','\xbf'}, {'\xe5','\x8d','\x89'}, {'\xe5','\x8d','\x91'}, + /* 336 */ {'\xe5','\x8d','\x9a'}, {'\xe5','\x8d','\xb3'}, {'\xe5','\x8d','\xb5'}, {'\xe5','\x8d','\xbd'}, {'\xe5','\x8d','\xbf'}, {'\xe5','\x8f','\x83'}, {'\xe5','\x8f','\x8a'}, {'\xe5','\x8f','\x9f'}, + /* 344 */ {'\xe5','\x8f','\xa5'}, {'\xe5','\x8f','\xab'}, {'\xe5','\x8f','\xb1'}, {'\xe5','\x90','\x86'}, {'\xe5','\x90','\x8f'}, {'\xe5','\x90','\x9d'}, {'\xe5','\x90','\xb8'}, {'\xe5','\x91','\x82'}, + /* 352 */ {'\xe5','\x91','\x88'}, {'\xe5','\x91','\xa8'}, {'\xe5','\x92','\x9e'}, {'\xe5','\x92','\xa2'}, {'\xe5','\x92','\xbd'}, {'\xe5','\x93','\xb6'}, {'\xe5','\x94','\x90'}, {'\xe5','\x95','\x93'}, + /* 360 */ {'\xe5','\x95','\x95'}, {'\xe5','\x95','\xa3'}, {'\xe5','\x96','\x84'}, {'\xe5','\x96','\x87'}, {'\xe5','\x96','\x99'}, {'\xe5','\x96','\x9d'}, {'\xe5','\x96','\xab'}, {'\xe5','\x96','\xb3'}, + /* 368 */ {'\xe5','\x97','\x80'}, {'\xe5','\x97','\x82'}, {'\xe5','\x97','\xa2'}, {'\xe5','\x98','\x86'}, {'\xe5','\x99','\x91'}, {'\xe5','\x99','\xa8'}, {'\xe5','\x99','\xb4'}, {'\xe5','\x9b','\xb9'}, + /* 376 */ {'\xe5','\x9c','\x96'}, {'\xe5','\x9c','\x97'}, {'\xe5','\x9e','\x8b'}, {'\xe5','\x9f','\x8e'}, {'\xe5','\x9f','\xb4'}, {'\xe5','\xa0','\x8d'}, {'\xe5','\xa0','\xb1'}, {'\xe5','\xa0','\xb2'}, + /* 384 */ {'\xe5','\xa1','\x80'}, {'\xe5','\xa1','\x9a'}, {'\xe5','\xa1','\x9e'}, {'\xe5','\xa2','\xa8'}, {'\xe5','\xa2','\xac'}, {'\xe5','\xa2','\xb3'}, {'\xe5','\xa3','\x98'}, {'\xe5','\xa3','\x9f'}, + /* 392 */ {'\xe5','\xa3','\xae'}, {'\xe5','\xa3','\xb2'}, {'\xe5','\xa3','\xb7'}, {'\xe5','\xa4','\x86'}, {'\xe5','\xa4','\x9a'}, {'\xe5','\xa4','\xa2'}, {'\xe5','\xa5','\x84'}, {'\xe5','\xa5','\x88'}, + /* 400 */ {'\xe5','\xa5','\x91'}, {'\xe5','\xa5','\x94'}, {'\xe5','\xa5','\xa2'}, {'\xe5','\xa5','\xb3'}, {'\xe5','\xa7','\x98'}, {'\xe5','\xa7','\xac'}, {'\xe5','\xa8','\x9b'}, {'\xe5','\xa8','\xa7'}, + /* 408 */ {'\xe5','\xa9','\xa2'}, {'\xe5','\xa9','\xa6'}, {'\xe5','\xaa','\xb5'}, {'\xe5','\xac','\x88'}, {'\xe5','\xac','\xa8'}, {'\xe5','\xac','\xbe'}, {'\xe5','\xae','\x85'}, {'\xe5','\xaf','\x83'}, + /* 416 */ {'\xe5','\xaf','\x98'}, {'\xe5','\xaf','\xa7'}, {'\xe5','\xaf','\xae'}, {'\xe5','\xaf','\xb3'}, {'\xe5','\xaf','\xbf'}, {'\xe5','\xb0','\x86'}, {'\xe5','\xb0','\xa2'}, {'\xe5','\xb0','\xbf'}, + /* 424 */ {'\xe5','\xb1','\xa0'}, {'\xe5','\xb1','\xa2'}, {'\xe5','\xb1','\xa4'}, {'\xe5','\xb1','\xa5'}, {'\xe5','\xb1','\xae'}, {'\xe5','\xb2','\x8d'}, {'\xe5','\xb3','\x80'}, {'\xe5','\xb4','\x99'}, + /* 432 */ {'\xe5','\xb5','\x83'}, {'\xe5','\xb5','\x90'}, {'\xe5','\xb5','\xab'}, {'\xe5','\xb5','\xae'}, {'\xe5','\xb5','\xbc'}, {'\xe5','\xb6','\xb2'}, {'\xe5','\xb6','\xba'}, {'\xe5','\xb7','\xa1'}, + /* 440 */ {'\xe5','\xb7','\xa2'}, {'\xe5','\xb7','\xbd'}, {'\xe5','\xb8','\xa8'}, {'\xe5','\xb8','\xbd'}, {'\xe5','\xb9','\xa9'}, {'\xe5','\xb9','\xb4'}, {'\xe5','\xba','\xa6'}, {'\xe5','\xba','\xb0'}, + /* 448 */ {'\xe5','\xba','\xb3'}, {'\xe5','\xba','\xb6'}, {'\xe5','\xbb','\x89'}, {'\xe5','\xbb','\x8a'}, {'\xe5','\xbb','\x92'}, {'\xe5','\xbb','\x93'}, {'\xe5','\xbb','\x99'}, {'\xe5','\xbb','\xac'}, + /* 456 */ {'\xe5','\xbb','\xbe'}, {'\xe5','\xbc','\x84'}, {'\xe5','\xbc','\xa2'}, {'\xe5','\xbd','\x93'}, {'\xe5','\xbd','\xa2'}, {'\xe5','\xbd','\xa9'}, {'\xe5','\xbd','\xab'}, {'\xe5','\xbe','\x8b'}, + /* 464 */ {'\xe5','\xbe','\x9a'}, {'\xe5','\xbe','\xa9'}, {'\xe5','\xbe','\xad'}, {'\xe5','\xbf','\x8d'}, {'\xe5','\xbf','\x97'}, {'\xe5','\xbf','\xb5'}, {'\xe5','\xbf','\xb9'}, {'\xe6','\x80','\x92'}, + /* 472 */ {'\xe6','\x80','\x9c'}, {'\xe6','\x81','\xb5'}, {'\xe6','\x82','\x81'}, {'\xe6','\x82','\x94'}, {'\xe6','\x83','\x87'}, {'\xe6','\x83','\x98'}, {'\xe6','\x83','\xa1'}, {'\xe6','\x84','\x88'}, + /* 480 */ {'\xe6','\x85','\x84'}, {'\xe6','\x85','\x88'}, {'\xe6','\x85','\x8c'}, {'\xe6','\x85','\x8e'}, {'\xe6','\x85','\xa0'}, {'\xe6','\x85','\xa8'}, {'\xe6','\x85','\xba'}, {'\xe6','\x86','\x8e'}, + /* 488 */ {'\xe6','\x86','\x90'}, {'\xe6','\x86','\xa4'}, {'\xe6','\x86','\xaf'}, {'\xe6','\x86','\xb2'}, {'\xe6','\x87','\x9e'}, {'\xe6','\x87','\xb2'}, {'\xe6','\x87','\xb6'}, {'\xe6','\x88','\x80'}, + /* 496 */ {'\xe6','\x88','\x90'}, {'\xe6','\x88','\x9b'}, {'\xe6','\x88','\xae'}, {'\xe6','\x88','\xb4'}, {'\xe6','\x89','\x9d'}, {'\xe6','\x8a','\xb1'}, {'\xe6','\x8b','\x89'}, {'\xe6','\x8b','\x8f'}, + /* 504 */ {'\xe6','\x8b','\x93'}, {'\xe6','\x8b','\x94'}, {'\xe6','\x8b','\xbc'}, {'\xe6','\x8b','\xbe'}, {'\xe6','\x8c','\xbd'}, {'\xe6','\x8d','\x90'}, {'\xe6','\x8d','\xa8'}, {'\xe6','\x8d','\xbb'}, + /* 512 */ {'\xe6','\x8e','\x83'}, {'\xe6','\x8e','\xa0'}, {'\xe6','\x8e','\xa9'}, {'\xe6','\x8f','\x84'}, {'\xe6','\x8f','\x85'}, {'\xe6','\x8f','\xa4'}, {'\xe6','\x90','\x9c'}, {'\xe6','\x90','\xa2'}, + /* 520 */ {'\xe6','\x91','\x92'}, {'\xe6','\x91','\xa9'}, {'\xe6','\x91','\xb7'}, {'\xe6','\x91','\xbe'}, {'\xe6','\x92','\x9a'}, {'\xe6','\x92','\x9d'}, {'\xe6','\x93','\x84'}, {'\xe6','\x95','\x8f'}, + /* 528 */ {'\xe6','\x95','\x96'}, {'\xe6','\x95','\xac'}, {'\xe6','\x95','\xb8'}, {'\xe6','\x96','\x99'}, {'\xe6','\x97','\x85'}, {'\xe6','\x97','\xa2'}, {'\xe6','\x97','\xa3'}, {'\xe6','\x98','\x93'}, + /* 536 */ {'\xe6','\x99','\x89'}, {'\xe6','\x99','\xb4'}, {'\xe6','\x9a','\x88'}, {'\xe6','\x9a','\x91'}, {'\xe6','\x9a','\x9c'}, {'\xe6','\x9a','\xb4'}, {'\xe6','\x9b','\x86'}, {'\xe6','\x9b','\xb4'}, + /* 544 */ {'\xe6','\x9b','\xb8'}, {'\xe6','\x9c','\x80'}, {'\xe6','\x9c','\x97'}, {'\xe6','\x9c','\x9b'}, {'\xe6','\x9c','\xa1'}, {'\xe6','\x9d','\x8e'}, {'\xe6','\x9d','\x93'}, {'\xe6','\x9d','\x96'}, + /* 552 */ {'\xe6','\x9d','\x9e'}, {'\xe6','\x9d','\xbb'}, {'\xe6','\x9e','\x85'}, {'\xe6','\x9e','\x97'}, {'\xe6','\x9f','\xb3'}, {'\xe6','\x9f','\xba'}, {'\xe6','\xa0','\x97'}, {'\xe6','\xa0','\x9f'}, + /* 560 */ {'\xe6','\xa1','\x92'}, {'\xe6','\xa2','\x81'}, {'\xe6','\xa2','\x85'}, {'\xe6','\xa2','\x8e'}, {'\xe6','\xa2','\xa8'}, {'\xe6','\xa4','\x94'}, {'\xe6','\xa5','\x82'}, {'\xe6','\xa6','\xa3'}, + /* 568 */ {'\xe6','\xa7','\xaa'}, {'\xe6','\xa8','\x82'}, {'\xe6','\xa8','\x93'}, {'\xe6','\xaa','\xa8'}, {'\xe6','\xab','\x93'}, {'\xe6','\xab','\x9b'}, {'\xe6','\xac','\x84'}, {'\xe6','\xac','\xa1'}, + /* 576 */ {'\xe6','\xad','\x94'}, {'\xe6','\xad','\xb2'}, {'\xe6','\xad','\xb7'}, {'\xe6','\xad','\xb9'}, {'\xe6','\xae','\x9f'}, {'\xe6','\xae','\xae'}, {'\xe6','\xae','\xba'}, {'\xe6','\xae','\xbb'}, + /* 584 */ {'\xe6','\xb1','\x8e'}, {'\xe6','\xb1','\xa7'}, {'\xe6','\xb2','\x88'}, {'\xe6','\xb2','\xbf'}, {'\xe6','\xb3','\x8c'}, {'\xe6','\xb3','\x8d'}, {'\xe6','\xb3','\xa5'}, {'\xe6','\xb4','\x96'}, + /* 592 */ {'\xe6','\xb4','\x9b'}, {'\xe6','\xb4','\x9e'}, {'\xe6','\xb4','\xb4'}, {'\xe6','\xb4','\xbe'}, {'\xe6','\xb5','\x81'}, {'\xe6','\xb5','\xa9'}, {'\xe6','\xb5','\xaa'}, {'\xe6','\xb5','\xb7'}, + /* 600 */ {'\xe6','\xb5','\xb8'}, {'\xe6','\xb6','\x85'}, {'\xe6','\xb7','\x8b'}, {'\xe6','\xb7','\x9a'}, {'\xe6','\xb7','\xaa'}, {'\xe6','\xb7','\xb9'}, {'\xe6','\xb8','\x9a'}, {'\xe6','\xb8','\xaf'}, + /* 608 */ {'\xe6','\xb9','\xae'}, {'\xe6','\xba','\x9c'}, {'\xe6','\xba','\xba'}, {'\xe6','\xbb','\x87'}, {'\xe6','\xbb','\x8b'}, {'\xe6','\xbb','\x91'}, {'\xe6','\xbb','\x9b'}, {'\xe6','\xbc','\x8f'}, + /* 616 */ {'\xe6','\xbc','\xa2'}, {'\xe6','\xbc','\xa3'}, {'\xe6','\xbd','\xae'}, {'\xe6','\xbf','\x86'}, {'\xe6','\xbf','\xab'}, {'\xe6','\xbf','\xbe'}, {'\xe7','\x80','\x9b'}, {'\xe7','\x80','\x9e'}, + /* 624 */ {'\xe7','\x80','\xb9'}, {'\xe7','\x81','\x8a'}, {'\xe7','\x81','\xb0'}, {'\xe7','\x81','\xb7'}, {'\xe7','\x81','\xbd'}, {'\xe7','\x82','\x99'}, {'\xe7','\x82','\xad'}, {'\xe7','\x83','\x88'}, + /* 632 */ {'\xe7','\x83','\x99'}, {'\xe7','\x85','\x85'}, {'\xe7','\x85','\x89'}, {'\xe7','\x85','\xae'}, {'\xe7','\x86','\x9c'}, {'\xe7','\x87','\x8e'}, {'\xe7','\x87','\x90'}, {'\xe7','\x88','\x90'}, + /* 640 */ {'\xe7','\x88','\x9b'}, {'\xe7','\x88','\xa8'}, {'\xe7','\x88','\xab'}, {'\xe7','\x88','\xb5'}, {'\xe7','\x89','\x90'}, {'\xe7','\x89','\xa2'}, {'\xe7','\x8a','\x80'}, {'\xe7','\x8a','\x95'}, + /* 648 */ {'\xe7','\x8a','\xaf'}, {'\xe7','\x8b','\x80'}, {'\xe7','\x8b','\xbc'}, {'\xe7','\x8c','\xaa'}, {'\xe7','\x8d','\xb5'}, {'\xe7','\x8d','\xba'}, {'\xe7','\x8e','\x87'}, {'\xe7','\x8e','\x8b'}, + /* 656 */ {'\xe7','\x8e','\xa5'}, {'\xe7','\x8e','\xb2'}, {'\xe7','\x8f','\x9e'}, {'\xe7','\x90','\x86'}, {'\xe7','\x90','\x89'}, {'\xe7','\x90','\xa2'}, {'\xe7','\x91','\x87'}, {'\xe7','\x91','\x9c'}, + /* 664 */ {'\xe7','\x91','\xa9'}, {'\xe7','\x91','\xb1'}, {'\xe7','\x92','\x85'}, {'\xe7','\x92','\x89'}, {'\xe7','\x92','\x98'}, {'\xe7','\x93','\x8a'}, {'\xe7','\x94','\x86'}, {'\xe7','\x94','\xa4'}, + /* 672 */ {'\xe7','\x94','\xbb'}, {'\xe7','\x94','\xbe'}, {'\xe7','\x95','\x99'}, {'\xe7','\x95','\xa5'}, {'\xe7','\x95','\xb0'}, {'\xe7','\x97','\xa2'}, {'\xe7','\x98','\x90'}, {'\xe7','\x98','\x9d'}, + /* 680 */ {'\xe7','\x98','\x9f'}, {'\xe7','\x99','\x82'}, {'\xe7','\x99','\xa9'}, {'\xe7','\x9b','\x8a'}, {'\xe7','\x9b','\x9b'}, {'\xe7','\x9b','\xa7'}, {'\xe7','\x9b','\xb4'}, {'\xe7','\x9c','\x81'}, + /* 688 */ {'\xe7','\x9c','\x9e'}, {'\xe7','\x9c','\x9f'}, {'\xe7','\x9d','\x80'}, {'\xe7','\x9d','\x8a'}, {'\xe7','\x9e','\x8b'}, {'\xe7','\x9e','\xa7'}, {'\xe7','\xa1','\x8e'}, {'\xe7','\xa1','\xab'}, + /* 696 */ {'\xe7','\xa2','\x8c'}, {'\xe7','\xa2','\x91'}, {'\xe7','\xa3','\x8a'}, {'\xe7','\xa3','\x8c'}, {'\xe7','\xa3','\xbb'}, {'\xe7','\xa4','\xaa'}, {'\xe7','\xa4','\xbc'}, {'\xe7','\xa4','\xbe'}, + /* 704 */ {'\xe7','\xa5','\x88'}, {'\xe7','\xa5','\x89'}, {'\xe7','\xa5','\x90'}, {'\xe7','\xa5','\x96'}, {'\xe7','\xa5','\x9d'}, {'\xe7','\xa5','\x9e'}, {'\xe7','\xa5','\xa5'}, {'\xe7','\xa5','\xbf'}, + /* 712 */ {'\xe7','\xa6','\x8d'}, {'\xe7','\xa6','\x8e'}, {'\xe7','\xa6','\x8f'}, {'\xe7','\xa6','\xae'}, {'\xe7','\xa7','\x8a'}, {'\xe7','\xa7','\xab'}, {'\xe7','\xa8','\x9c'}, {'\xe7','\xa9','\x80'}, + /* 720 */ {'\xe7','\xa9','\x8a'}, {'\xe7','\xa9','\x8f'}, {'\xe7','\xaa','\x81'}, {'\xe7','\xaa','\xb1'}, {'\xe7','\xab','\x8b'}, {'\xe7','\xab','\xae'}, {'\xe7','\xac','\xa0'}, {'\xe7','\xaf','\x80'}, + /* 728 */ {'\xe7','\xaf','\x86'}, {'\xe7','\xaf','\x89'}, {'\xe7','\xb0','\xbe'}, {'\xe7','\xb1','\xa0'}, {'\xe7','\xb1','\xbb'}, {'\xe7','\xb2','\x92'}, {'\xe7','\xb2','\xbe'}, {'\xe7','\xb3','\x92'}, + /* 736 */ {'\xe7','\xb3','\x96'}, {'\xe7','\xb3','\xa3'}, {'\xe7','\xb3','\xa7'}, {'\xe7','\xb3','\xa8'}, {'\xe7','\xb4','\x80'}, {'\xe7','\xb4','\x90'}, {'\xe7','\xb4','\xa2'}, {'\xe7','\xb4','\xaf'}, + /* 744 */ {'\xe7','\xb5','\x9b'}, {'\xe7','\xb5','\xa3'}, {'\xe7','\xb6','\xa0'}, {'\xe7','\xb6','\xbe'}, {'\xe7','\xb7','\x87'}, {'\xe7','\xb7','\xb4'}, {'\xe7','\xb8','\x82'}, {'\xe7','\xb8','\x89'}, + /* 752 */ {'\xe7','\xb8','\xb7'}, {'\xe7','\xb9','\x81'}, {'\xe7','\xb9','\x85'}, {'\xe7','\xbc','\xbe'}, {'\xe7','\xbd','\xb2'}, {'\xe7','\xbd','\xb9'}, {'\xe7','\xbd','\xba'}, {'\xe7','\xbe','\x85'}, + /* 760 */ {'\xe7','\xbe','\x95'}, {'\xe7','\xbe','\x9a'}, {'\xe7','\xbe','\xbd'}, {'\xe7','\xbf','\xba'}, {'\xe8','\x80','\x81'}, {'\xe8','\x80','\x85'}, {'\xe8','\x81','\x86'}, {'\xe8','\x81','\xa0'}, + /* 768 */ {'\xe8','\x81','\xaf'}, {'\xe8','\x81','\xb0'}, {'\xe8','\x81','\xbe'}, {'\xe8','\x82','\x8b'}, {'\xe8','\x82','\xad'}, {'\xe8','\x82','\xb2'}, {'\xe8','\x84','\x83'}, {'\xe8','\x84','\xbe'}, + /* 776 */ {'\xe8','\x87','\x98'}, {'\xe8','\x87','\xa8'}, {'\xe8','\x87','\xad'}, {'\xe8','\x88','\x81'}, {'\xe8','\x88','\x84'}, {'\xe8','\x88','\x98'}, {'\xe8','\x89','\xaf'}, {'\xe8','\x89','\xb9'}, + /* 784 */ {'\xe8','\x8a','\x8b'}, {'\xe8','\x8a','\x91'}, {'\xe8','\x8a','\x9d'}, {'\xe8','\x8a','\xb1'}, {'\xe8','\x8a','\xb3'}, {'\xe8','\x8a','\xbd'}, {'\xe8','\x8b','\xa5'}, {'\xe8','\x8b','\xa6'}, + /* 792 */ {'\xe8','\x8c','\x9d'}, {'\xe8','\x8c','\xa3'}, {'\xe8','\x8c','\xb6'}, {'\xe8','\x8d','\x92'}, {'\xe8','\x8d','\x93'}, {'\xe8','\x8d','\xa3'}, {'\xe8','\x8e','\xad'}, {'\xe8','\x8e','\xbd'}, + /* 800 */ {'\xe8','\x8f','\x89'}, {'\xe8','\x8f','\x8a'}, {'\xe8','\x8f','\x8c'}, {'\xe8','\x8f','\x9c'}, {'\xe8','\x8f','\xa7'}, {'\xe8','\x8f','\xaf'}, {'\xe8','\x8f','\xb1'}, {'\xe8','\x90','\xbd'}, + /* 808 */ {'\xe8','\x91','\x89'}, {'\xe8','\x91','\x97'}, {'\xe8','\x93','\xae'}, {'\xe8','\x93','\xb1'}, {'\xe8','\x93','\xb3'}, {'\xe8','\x93','\xbc'}, {'\xe8','\x94','\x96'}, {'\xe8','\x95','\xa4'}, + /* 816 */ {'\xe8','\x97','\x8d'}, {'\xe8','\x97','\xba'}, {'\xe8','\x98','\x86'}, {'\xe8','\x98','\x92'}, {'\xe8','\x98','\xad'}, {'\xe8','\x98','\xbf'}, {'\xe8','\x99','\x90'}, {'\xe8','\x99','\x9c'}, + /* 824 */ {'\xe8','\x99','\xa7'}, {'\xe8','\x99','\xa9'}, {'\xe8','\x9a','\x88'}, {'\xe8','\x9a','\xa9'}, {'\xe8','\x9b','\xa2'}, {'\xe8','\x9c','\x8e'}, {'\xe8','\x9c','\xa8'}, {'\xe8','\x9d','\xab'}, + /* 832 */ {'\xe8','\x9d','\xb9'}, {'\xe8','\x9e','\x86'}, {'\xe8','\x9e','\xba'}, {'\xe8','\x9f','\xa1'}, {'\xe8','\xa0','\x81'}, {'\xe8','\xa0','\x9f'}, {'\xe8','\xa1','\x8c'}, {'\xe8','\xa1','\xa0'}, + /* 840 */ {'\xe8','\xa1','\xa3'}, {'\xe8','\xa3','\x82'}, {'\xe8','\xa3','\x8f'}, {'\xe8','\xa3','\x97'}, {'\xe8','\xa3','\x9e'}, {'\xe8','\xa3','\xa1'}, {'\xe8','\xa3','\xb8'}, {'\xe8','\xa3','\xba'}, + /* 848 */ {'\xe8','\xa4','\x90'}, {'\xe8','\xa5','\x81'}, {'\xe8','\xa5','\xa4'}, {'\xe8','\xa6','\x86'}, {'\xe8','\xa6','\x8b'}, {'\xe8','\xa6','\x96'}, {'\xe8','\xaa','\xa0'}, {'\xe8','\xaa','\xaa'}, + /* 856 */ {'\xe8','\xaa','\xbf'}, {'\xe8','\xab','\x8b'}, {'\xe8','\xab','\x92'}, {'\xe8','\xab','\x96'}, {'\xe8','\xab','\xad'}, {'\xe8','\xab','\xb8'}, {'\xe8','\xab','\xbe'}, {'\xe8','\xac','\x81'}, + /* 864 */ {'\xe8','\xac','\xb9'}, {'\xe8','\xad','\x98'}, {'\xe8','\xae','\x80'}, {'\xe8','\xae','\x8a'}, {'\xe8','\xb1','\x88'}, {'\xe8','\xb1','\x95'}, {'\xe8','\xb2','\xab'}, {'\xe8','\xb3','\x81'}, + /* 872 */ {'\xe8','\xb3','\x82'}, {'\xe8','\xb3','\x88'}, {'\xe8','\xb3','\x93'}, {'\xe8','\xb4','\x88'}, {'\xe8','\xb4','\x9b'}, {'\xe8','\xb5','\xb7'}, {'\xe8','\xb6','\xbc'}, {'\xe8','\xb7','\x8b'}, + /* 880 */ {'\xe8','\xb7','\xaf'}, {'\xe8','\xb7','\xb0'}, {'\xe8','\xbb','\x8a'}, {'\xe8','\xbb','\x94'}, {'\xe8','\xbc','\xa6'}, {'\xe8','\xbc','\xaa'}, {'\xe8','\xbc','\xb8'}, {'\xe8','\xbc','\xbb'}, + /* 888 */ {'\xe8','\xbd','\xa2'}, {'\xe8','\xbe','\x9e'}, {'\xe8','\xbe','\xb0'}, {'\xe8','\xbe','\xb6'}, {'\xe9','\x80','\xa3'}, {'\xe9','\x80','\xb8'}, {'\xe9','\x81','\xb2'}, {'\xe9','\x81','\xbc'}, + /* 896 */ {'\xe9','\x82','\x8f'}, {'\xe9','\x82','\x94'}, {'\xe9','\x83','\x8e'}, {'\xe9','\x83','\x9e'}, {'\xe9','\x83','\xb1'}, {'\xe9','\x83','\xbd'}, {'\xe9','\x84','\x91'}, {'\xe9','\x84','\x9b'}, + /* 904 */ {'\xe9','\x85','\xaa'}, {'\xe9','\x86','\x99'}, {'\xe9','\x86','\xb4'}, {'\xe9','\x87','\x8c'}, {'\xe9','\x87','\x8f'}, {'\xe9','\x87','\x91'}, {'\xe9','\x88','\xb4'}, {'\xe9','\x88','\xb8'}, + /* 912 */ {'\xe9','\x89','\xb6'}, {'\xe9','\x89','\xbc'}, {'\xe9','\x8b','\x97'}, {'\xe9','\x8b','\x98'}, {'\xe9','\x8c','\x84'}, {'\xe9','\x8d','\x8a'}, {'\xe9','\x8f','\xb9'}, {'\xe9','\x90','\x95'}, + /* 920 */ {'\xe9','\x96','\x8b'}, {'\xe9','\x96','\xad'}, {'\xe9','\x96','\xb7'}, {'\xe9','\x98','\xae'}, {'\xe9','\x99','\x8b'}, {'\xe9','\x99','\x8d'}, {'\xe9','\x99','\xb5'}, {'\xe9','\x99','\xb8'}, + /* 928 */ {'\xe9','\x99','\xbc'}, {'\xe9','\x9a','\x86'}, {'\xe9','\x9a','\xa3'}, {'\xe9','\x9a','\xb7'}, {'\xe9','\x9a','\xb8'}, {'\xe9','\x9b','\x83'}, {'\xe9','\x9b','\xa2'}, {'\xe9','\x9b','\xa3'}, + /* 936 */ {'\xe9','\x9b','\xb6'}, {'\xe9','\x9b','\xb7'}, {'\xe9','\x9c','\xa3'}, {'\xe9','\x9c','\xb2'}, {'\xe9','\x9d','\x88'}, {'\xe9','\x9d','\x96'}, {'\xe9','\x9f','\x9b'}, {'\xe9','\x9f','\xa0'}, + /* 944 */ {'\xe9','\x9f','\xbf'}, {'\xe9','\xa0','\x8b'}, {'\xe9','\xa0','\x98'}, {'\xe9','\xa0','\xa9'}, {'\xe9','\xa0','\xbb'}, {'\xe9','\xa1','\x9e'}, {'\xe9','\xa3','\xa2'}, {'\xe9','\xa3','\xaf'}, + /* 952 */ {'\xe9','\xa3','\xbc'}, {'\xe9','\xa4','\xa8'}, {'\xe9','\xa4','\xa9'}, {'\xe9','\xa6','\xa7'}, {'\xe9','\xa7','\x82'}, {'\xe9','\xa7','\xb1'}, {'\xe9','\xa7','\xbe'}, {'\xe9','\xa9','\xaa'}, + /* 960 */ {'\xe9','\xac','\x92'}, {'\xe9','\xad','\xaf'}, {'\xe9','\xb1','\x80'}, {'\xe9','\xb1','\x97'}, {'\xe9','\xb3','\xbd'}, {'\xe9','\xb5','\xa7'}, {'\xe9','\xb6','\xb4'}, {'\xe9','\xb7','\xba'}, + /* 968 */ {'\xe9','\xb8','\x9e'}, {'\xe9','\xb9','\xbf'}, {'\xe9','\xba','\x97'}, {'\xe9','\xba','\x9f'}, {'\xe9','\xba','\xbb'}, {'\xe9','\xbb','\x8e'}, {'\xe9','\xbb','\xb9'}, {'\xe9','\xbb','\xbe'}, + /* 976 */ {'\xe9','\xbc','\x85'}, {'\xe9','\xbc','\x8f'}, {'\xe9','\xbc','\x96'}, {'\xe9','\xbc','\xbb'}, {'\xe9','\xbd','\x83'}, {'\xe9','\xbe','\x8d'}, {'\xe9','\xbe','\x8e'}, {'\xe9','\xbe','\x9c'}, + /* 984 */ {'a','\xcc','\x80'}, {'a','\xcc','\x81'}, {'a','\xcc','\x82'}, {'a','\xcc','\x83'}, {'a','\xcc','\x84'}, {'a','\xcc','\x86'}, {'a','\xcc','\x87'}, {'a','\xcc','\x88'}, + /* 992 */ {'a','\xcc','\x89'}, {'a','\xcc','\x8a'}, {'a','\xcc','\x8c'}, {'a','\xcc','\x8f'}, {'a','\xcc','\x91'}, {'a','\xcc','\xa3'}, {'a','\xcc','\xa5'}, {'a','\xcc','\xa8'}, + /* 1000 */ {'b','\xcc','\x87'}, {'b','\xcc','\xa3'}, {'b','\xcc','\xb1'}, {'c','\xcc','\x81'}, {'c','\xcc','\x82'}, {'c','\xcc','\x87'}, {'c','\xcc','\x8c'}, {'c','\xcc','\xa7'}, + /* 1008 */ {'d','\xcc','\x87'}, {'d','\xcc','\x8c'}, {'d','\xcc','\xa3'}, {'d','\xcc','\xa7'}, {'d','\xcc','\xad'}, {'d','\xcc','\xb1'}, {'e','\xcc','\x80'}, {'e','\xcc','\x81'}, + /* 1016 */ {'e','\xcc','\x82'}, {'e','\xcc','\x83'}, {'e','\xcc','\x84'}, {'e','\xcc','\x86'}, {'e','\xcc','\x87'}, {'e','\xcc','\x88'}, {'e','\xcc','\x89'}, {'e','\xcc','\x8c'}, + /* 1024 */ {'e','\xcc','\x8f'}, {'e','\xcc','\x91'}, {'e','\xcc','\xa3'}, {'e','\xcc','\xa7'}, {'e','\xcc','\xa8'}, {'e','\xcc','\xad'}, {'e','\xcc','\xb0'}, {'f','\xcc','\x87'}, + /* 1032 */ {'g','\xcc','\x81'}, {'g','\xcc','\x82'}, {'g','\xcc','\x84'}, {'g','\xcc','\x86'}, {'g','\xcc','\x87'}, {'g','\xcc','\x8c'}, {'g','\xcc','\xa7'}, {'h','\xcc','\x82'}, + /* 1040 */ {'h','\xcc','\x87'}, {'h','\xcc','\x88'}, {'h','\xcc','\x8c'}, {'h','\xcc','\xa3'}, {'h','\xcc','\xa7'}, {'h','\xcc','\xae'}, {'h','\xcc','\xb1'}, {'i','\xcc','\x80'}, + /* 1048 */ {'i','\xcc','\x81'}, {'i','\xcc','\x82'}, {'i','\xcc','\x83'}, {'i','\xcc','\x84'}, {'i','\xcc','\x86'}, {'i','\xcc','\x88'}, {'i','\xcc','\x89'}, {'i','\xcc','\x8c'}, + /* 1056 */ {'i','\xcc','\x8f'}, {'i','\xcc','\x91'}, {'i','\xcc','\xa3'}, {'i','\xcc','\xa8'}, {'i','\xcc','\xb0'}, {'j','\xcc','\x82'}, {'j','\xcc','\x8c'}, {'k','\xcc','\x81'}, + /* 1064 */ {'k','\xcc','\x8c'}, {'k','\xcc','\xa3'}, {'k','\xcc','\xa7'}, {'k','\xcc','\xb1'}, {'l','\xcc','\x81'}, {'l','\xcc','\x8c'}, {'l','\xcc','\xa3'}, {'l','\xcc','\xa7'}, + /* 1072 */ {'l','\xcc','\xad'}, {'l','\xcc','\xb1'}, {'m','\xcc','\x81'}, {'m','\xcc','\x87'}, {'m','\xcc','\xa3'}, {'n','\xcc','\x80'}, {'n','\xcc','\x81'}, {'n','\xcc','\x83'}, + /* 1080 */ {'n','\xcc','\x87'}, {'n','\xcc','\x8c'}, {'n','\xcc','\xa3'}, {'n','\xcc','\xa7'}, {'n','\xcc','\xad'}, {'n','\xcc','\xb1'}, {'o','\xcc','\x80'}, {'o','\xcc','\x81'}, + /* 1088 */ {'o','\xcc','\x82'}, {'o','\xcc','\x83'}, {'o','\xcc','\x84'}, {'o','\xcc','\x86'}, {'o','\xcc','\x87'}, {'o','\xcc','\x88'}, {'o','\xcc','\x89'}, {'o','\xcc','\x8b'}, + /* 1096 */ {'o','\xcc','\x8c'}, {'o','\xcc','\x8f'}, {'o','\xcc','\x91'}, {'o','\xcc','\x9b'}, {'o','\xcc','\xa3'}, {'o','\xcc','\xa8'}, {'p','\xcc','\x81'}, {'p','\xcc','\x87'}, + /* 1104 */ {'r','\xcc','\x81'}, {'r','\xcc','\x87'}, {'r','\xcc','\x8c'}, {'r','\xcc','\x8f'}, {'r','\xcc','\x91'}, {'r','\xcc','\xa3'}, {'r','\xcc','\xa7'}, {'r','\xcc','\xb1'}, + /* 1112 */ {'s','\xcc','\x81'}, {'s','\xcc','\x82'}, {'s','\xcc','\x87'}, {'s','\xcc','\x8c'}, {'s','\xcc','\xa3'}, {'s','\xcc','\xa6'}, {'s','\xcc','\xa7'}, {'t','\xcc','\x87'}, + /* 1120 */ {'t','\xcc','\x88'}, {'t','\xcc','\x8c'}, {'t','\xcc','\xa3'}, {'t','\xcc','\xa6'}, {'t','\xcc','\xa7'}, {'t','\xcc','\xad'}, {'t','\xcc','\xb1'}, {'u','\xcc','\x80'}, + /* 1128 */ {'u','\xcc','\x81'}, {'u','\xcc','\x82'}, {'u','\xcc','\x83'}, {'u','\xcc','\x84'}, {'u','\xcc','\x86'}, {'u','\xcc','\x88'}, {'u','\xcc','\x89'}, {'u','\xcc','\x8a'}, + /* 1136 */ {'u','\xcc','\x8b'}, {'u','\xcc','\x8c'}, {'u','\xcc','\x8f'}, {'u','\xcc','\x91'}, {'u','\xcc','\x9b'}, {'u','\xcc','\xa3'}, {'u','\xcc','\xa4'}, {'u','\xcc','\xa8'}, + /* 1144 */ {'u','\xcc','\xad'}, {'u','\xcc','\xb0'}, {'v','\xcc','\x83'}, {'v','\xcc','\xa3'}, {'w','\xcc','\x80'}, {'w','\xcc','\x81'}, {'w','\xcc','\x82'}, {'w','\xcc','\x87'}, + /* 1152 */ {'w','\xcc','\x88'}, {'w','\xcc','\x8a'}, {'w','\xcc','\xa3'}, {'x','\xcc','\x87'}, {'x','\xcc','\x88'}, {'y','\xcc','\x80'}, {'y','\xcc','\x81'}, {'y','\xcc','\x82'}, + /* 1160 */ {'y','\xcc','\x83'}, {'y','\xcc','\x84'}, {'y','\xcc','\x87'}, {'y','\xcc','\x88'}, {'y','\xcc','\x89'}, {'y','\xcc','\x8a'}, {'y','\xcc','\xa3'}, {'z','\xcc','\x81'}, + /* 1168 */ {'z','\xcc','\x82'}, {'z','\xcc','\x87'}, {'z','\xcc','\x8c'}, {'z','\xcc','\xa3'}, {'z','\xcc','\xb1'}}; + +static const char UN8IF_canon_tbl_4 [302][4] = { + /* 0 */ {'\xc2','\xa8','\xcc','\x80'}, {'\xc2','\xa8','\xcc','\x81'}, {'\xc2','\xa8','\xcd','\x82'}, {'\xc3','\x86','\xcc','\x81'}, {'\xc3','\x86','\xcc','\x84'}, {'\xc3','\x98','\xcc','\x81'}, {'\xc3','\xa6','\xcc','\x81'}, {'\xc3','\xa6','\xcc','\x84'}, + /* 8 */ {'\xc3','\xb8','\xcc','\x81'}, {'\xc5','\xbf','\xcc','\x87'}, {'\xc6','\xb7','\xcc','\x8c'}, {'\xca','\x92','\xcc','\x8c'}, {'\xcc','\x88','\xcc','\x81'}, {'\xce','\x91','\xcc','\x80'}, {'\xce','\x91','\xcc','\x81'}, {'\xce','\x91','\xcc','\x84'}, + /* 16 */ {'\xce','\x91','\xcc','\x86'}, {'\xce','\x91','\xcc','\x93'}, {'\xce','\x91','\xcc','\x94'}, {'\xce','\x91','\xcd','\x85'}, {'\xce','\x95','\xcc','\x80'}, {'\xce','\x95','\xcc','\x81'}, {'\xce','\x95','\xcc','\x93'}, {'\xce','\x95','\xcc','\x94'}, + /* 24 */ {'\xce','\x97','\xcc','\x80'}, {'\xce','\x97','\xcc','\x81'}, {'\xce','\x97','\xcc','\x93'}, {'\xce','\x97','\xcc','\x94'}, {'\xce','\x97','\xcd','\x85'}, {'\xce','\x99','\xcc','\x80'}, {'\xce','\x99','\xcc','\x81'}, {'\xce','\x99','\xcc','\x84'}, + /* 32 */ {'\xce','\x99','\xcc','\x86'}, {'\xce','\x99','\xcc','\x88'}, {'\xce','\x99','\xcc','\x93'}, {'\xce','\x99','\xcc','\x94'}, {'\xce','\x9f','\xcc','\x80'}, {'\xce','\x9f','\xcc','\x81'}, {'\xce','\x9f','\xcc','\x93'}, {'\xce','\x9f','\xcc','\x94'}, + /* 40 */ {'\xce','\xa1','\xcc','\x94'}, {'\xce','\xa5','\xcc','\x80'}, {'\xce','\xa5','\xcc','\x81'}, {'\xce','\xa5','\xcc','\x84'}, {'\xce','\xa5','\xcc','\x86'}, {'\xce','\xa5','\xcc','\x88'}, {'\xce','\xa5','\xcc','\x94'}, {'\xce','\xa9','\xcc','\x80'}, + /* 48 */ {'\xce','\xa9','\xcc','\x81'}, {'\xce','\xa9','\xcc','\x93'}, {'\xce','\xa9','\xcc','\x94'}, {'\xce','\xa9','\xcd','\x85'}, {'\xce','\xb1','\xcc','\x80'}, {'\xce','\xb1','\xcc','\x81'}, {'\xce','\xb1','\xcc','\x84'}, {'\xce','\xb1','\xcc','\x86'}, + /* 56 */ {'\xce','\xb1','\xcc','\x93'}, {'\xce','\xb1','\xcc','\x94'}, {'\xce','\xb1','\xcd','\x82'}, {'\xce','\xb1','\xcd','\x85'}, {'\xce','\xb5','\xcc','\x80'}, {'\xce','\xb5','\xcc','\x81'}, {'\xce','\xb5','\xcc','\x93'}, {'\xce','\xb5','\xcc','\x94'}, + /* 64 */ {'\xce','\xb7','\xcc','\x80'}, {'\xce','\xb7','\xcc','\x81'}, {'\xce','\xb7','\xcc','\x93'}, {'\xce','\xb7','\xcc','\x94'}, {'\xce','\xb7','\xcd','\x82'}, {'\xce','\xb7','\xcd','\x85'}, {'\xce','\xb9','\xcc','\x80'}, {'\xce','\xb9','\xcc','\x81'}, + /* 72 */ {'\xce','\xb9','\xcc','\x84'}, {'\xce','\xb9','\xcc','\x86'}, {'\xce','\xb9','\xcc','\x88'}, {'\xce','\xb9','\xcc','\x93'}, {'\xce','\xb9','\xcc','\x94'}, {'\xce','\xb9','\xcd','\x82'}, {'\xce','\xbf','\xcc','\x80'}, {'\xce','\xbf','\xcc','\x81'}, + /* 80 */ {'\xce','\xbf','\xcc','\x93'}, {'\xce','\xbf','\xcc','\x94'}, {'\xcf','\x81','\xcc','\x93'}, {'\xcf','\x81','\xcc','\x94'}, {'\xcf','\x85','\xcc','\x80'}, {'\xcf','\x85','\xcc','\x81'}, {'\xcf','\x85','\xcc','\x84'}, {'\xcf','\x85','\xcc','\x86'}, + /* 88 */ {'\xcf','\x85','\xcc','\x88'}, {'\xcf','\x85','\xcc','\x93'}, {'\xcf','\x85','\xcc','\x94'}, {'\xcf','\x85','\xcd','\x82'}, {'\xcf','\x89','\xcc','\x80'}, {'\xcf','\x89','\xcc','\x81'}, {'\xcf','\x89','\xcc','\x93'}, {'\xcf','\x89','\xcc','\x94'}, + /* 96 */ {'\xcf','\x89','\xcd','\x82'}, {'\xcf','\x89','\xcd','\x85'}, {'\xcf','\x92','\xcc','\x81'}, {'\xcf','\x92','\xcc','\x88'}, {'\xd0','\x86','\xcc','\x88'}, {'\xd0','\x90','\xcc','\x86'}, {'\xd0','\x90','\xcc','\x88'}, {'\xd0','\x93','\xcc','\x81'}, + /* 104 */ {'\xd0','\x95','\xcc','\x80'}, {'\xd0','\x95','\xcc','\x86'}, {'\xd0','\x95','\xcc','\x88'}, {'\xd0','\x96','\xcc','\x86'}, {'\xd0','\x96','\xcc','\x88'}, {'\xd0','\x97','\xcc','\x88'}, {'\xd0','\x98','\xcc','\x80'}, {'\xd0','\x98','\xcc','\x84'}, + /* 112 */ {'\xd0','\x98','\xcc','\x86'}, {'\xd0','\x98','\xcc','\x88'}, {'\xd0','\x9a','\xcc','\x81'}, {'\xd0','\x9e','\xcc','\x88'}, {'\xd0','\xa3','\xcc','\x84'}, {'\xd0','\xa3','\xcc','\x86'}, {'\xd0','\xa3','\xcc','\x88'}, {'\xd0','\xa3','\xcc','\x8b'}, + /* 120 */ {'\xd0','\xa7','\xcc','\x88'}, {'\xd0','\xab','\xcc','\x88'}, {'\xd0','\xad','\xcc','\x88'}, {'\xd0','\xb0','\xcc','\x86'}, {'\xd0','\xb0','\xcc','\x88'}, {'\xd0','\xb3','\xcc','\x81'}, {'\xd0','\xb5','\xcc','\x80'}, {'\xd0','\xb5','\xcc','\x86'}, + /* 128 */ {'\xd0','\xb5','\xcc','\x88'}, {'\xd0','\xb6','\xcc','\x86'}, {'\xd0','\xb6','\xcc','\x88'}, {'\xd0','\xb7','\xcc','\x88'}, {'\xd0','\xb8','\xcc','\x80'}, {'\xd0','\xb8','\xcc','\x84'}, {'\xd0','\xb8','\xcc','\x86'}, {'\xd0','\xb8','\xcc','\x88'}, + /* 136 */ {'\xd0','\xba','\xcc','\x81'}, {'\xd0','\xbe','\xcc','\x88'}, {'\xd1','\x83','\xcc','\x84'}, {'\xd1','\x83','\xcc','\x86'}, {'\xd1','\x83','\xcc','\x88'}, {'\xd1','\x83','\xcc','\x8b'}, {'\xd1','\x87','\xcc','\x88'}, {'\xd1','\x8b','\xcc','\x88'}, + /* 144 */ {'\xd1','\x8d','\xcc','\x88'}, {'\xd1','\x96','\xcc','\x88'}, {'\xd1','\xb4','\xcc','\x8f'}, {'\xd1','\xb5','\xcc','\x8f'}, {'\xd3','\x98','\xcc','\x88'}, {'\xd3','\x99','\xcc','\x88'}, {'\xd3','\xa8','\xcc','\x88'}, {'\xd3','\xa9','\xcc','\x88'}, + /* 152 */ {'\xd7','\x90','\xd6','\xb7'}, {'\xd7','\x90','\xd6','\xb8'}, {'\xd7','\x90','\xd6','\xbc'}, {'\xd7','\x91','\xd6','\xbc'}, {'\xd7','\x91','\xd6','\xbf'}, {'\xd7','\x92','\xd6','\xbc'}, {'\xd7','\x93','\xd6','\xbc'}, {'\xd7','\x94','\xd6','\xbc'}, + /* 160 */ {'\xd7','\x95','\xd6','\xb9'}, {'\xd7','\x95','\xd6','\xbc'}, {'\xd7','\x96','\xd6','\xbc'}, {'\xd7','\x98','\xd6','\xbc'}, {'\xd7','\x99','\xd6','\xb4'}, {'\xd7','\x99','\xd6','\xbc'}, {'\xd7','\x9a','\xd6','\xbc'}, {'\xd7','\x9b','\xd6','\xbc'}, + /* 168 */ {'\xd7','\x9b','\xd6','\xbf'}, {'\xd7','\x9c','\xd6','\xbc'}, {'\xd7','\x9e','\xd6','\xbc'}, {'\xd7','\xa0','\xd6','\xbc'}, {'\xd7','\xa1','\xd6','\xbc'}, {'\xd7','\xa3','\xd6','\xbc'}, {'\xd7','\xa4','\xd6','\xbc'}, {'\xd7','\xa4','\xd6','\xbf'}, + /* 176 */ {'\xd7','\xa6','\xd6','\xbc'}, {'\xd7','\xa7','\xd6','\xbc'}, {'\xd7','\xa8','\xd6','\xbc'}, {'\xd7','\xa9','\xd6','\xbc'}, {'\xd7','\xa9','\xd7','\x81'}, {'\xd7','\xa9','\xd7','\x82'}, {'\xd7','\xaa','\xd6','\xbc'}, {'\xd7','\xb2','\xd6','\xb7'}, + /* 184 */ {'\xd8','\xa7','\xd9','\x93'}, {'\xd8','\xa7','\xd9','\x94'}, {'\xd8','\xa7','\xd9','\x95'}, {'\xd9','\x88','\xd9','\x94'}, {'\xd9','\x8a','\xd9','\x94'}, {'\xdb','\x81','\xd9','\x94'}, {'\xdb','\x92','\xd9','\x94'}, {'\xdb','\x95','\xd9','\x94'}, + /* 192 */ {'\xf0','\xa0','\x84','\xa2'}, {'\xf0','\xa0','\x94','\x9c'}, {'\xf0','\xa0','\x94','\xa5'}, {'\xf0','\xa0','\x95','\x8b'}, {'\xf0','\xa0','\x98','\xba'}, {'\xf0','\xa0','\xa0','\x84'}, {'\xf0','\xa0','\xa3','\x9e'}, {'\xf0','\xa0','\xa8','\xac'}, + /* 200 */ {'\xf0','\xa0','\xad','\xa3'}, {'\xf0','\xa1','\x93','\xa4'}, {'\xf0','\xa1','\x9a','\xa8'}, {'\xf0','\xa1','\x9b','\xaa'}, {'\xf0','\xa1','\xa7','\x88'}, {'\xf0','\xa1','\xac','\x98'}, {'\xf0','\xa1','\xb4','\x8b'}, {'\xf0','\xa1','\xb7','\xa4'}, + /* 208 */ {'\xf0','\xa1','\xb7','\xa6'}, {'\xf0','\xa2','\x86','\x83'}, {'\xf0','\xa2','\x86','\x9f'}, {'\xf0','\xa2','\x8c','\xb1'}, {'\xf0','\xa2','\x9b','\x94'}, {'\xf0','\xa2','\xa1','\x84'}, {'\xf0','\xa2','\xa1','\x8a'}, {'\xf0','\xa2','\xac','\x8c'}, + /* 216 */ {'\xf0','\xa2','\xaf','\xb1'}, {'\xf0','\xa3','\x80','\x8a'}, {'\xf0','\xa3','\x8a','\xb8'}, {'\xf0','\xa3','\x8d','\x9f'}, {'\xf0','\xa3','\x8e','\x93'}, {'\xf0','\xa3','\x8e','\x9c'}, {'\xf0','\xa3','\x8f','\x83'}, {'\xf0','\xa3','\x8f','\x95'}, + /* 224 */ {'\xf0','\xa3','\x91','\xad'}, {'\xf0','\xa3','\x9a','\xa3'}, {'\xf0','\xa3','\xa2','\xa7'}, {'\xf0','\xa3','\xaa','\x8d'}, {'\xf0','\xa3','\xab','\xba'}, {'\xf0','\xa3','\xb2','\xbc'}, {'\xf0','\xa3','\xb4','\x9e'}, {'\xf0','\xa3','\xbb','\x91'}, + /* 232 */ {'\xf0','\xa3','\xbd','\x9e'}, {'\xf0','\xa3','\xbe','\x8e'}, {'\xf0','\xa4','\x89','\xa3'}, {'\xf0','\xa4','\x8b','\xae'}, {'\xf0','\xa4','\x8e','\xab'}, {'\xf0','\xa4','\x98','\x88'}, {'\xf0','\xa4','\x9c','\xb5'}, {'\xf0','\xa4','\xa0','\x94'}, + /* 240 */ {'\xf0','\xa4','\xb0','\xb6'}, {'\xf0','\xa4','\xb2','\x92'}, {'\xf0','\xa4','\xbe','\xa1'}, {'\xf0','\xa4','\xbe','\xb8'}, {'\xf0','\xa5','\x81','\x84'}, {'\xf0','\xa5','\x83','\xb2'}, {'\xf0','\xa5','\x83','\xb3'}, {'\xf0','\xa5','\x84','\x99'}, + /* 248 */ {'\xf0','\xa5','\x84','\xb3'}, {'\xf0','\xa5','\x89','\x89'}, {'\xf0','\xa5','\x90','\x9d'}, {'\xf0','\xa5','\x98','\xa6'}, {'\xf0','\xa5','\x9a','\x9a'}, {'\xf0','\xa5','\x9b','\x85'}, {'\xf0','\xa5','\xa5','\xbc'}, {'\xf0','\xa5','\xaa','\xa7'}, + /* 256 */ {'\xf0','\xa5','\xae','\xab'}, {'\xf0','\xa5','\xb2','\x80'}, {'\xf0','\xa5','\xb3','\x90'}, {'\xf0','\xa5','\xbe','\x86'}, {'\xf0','\xa6','\x87','\x9a'}, {'\xf0','\xa6','\x88','\xa8'}, {'\xf0','\xa6','\x89','\x87'}, {'\xf0','\xa6','\x8b','\x99'}, + /* 264 */ {'\xf0','\xa6','\x8c','\xbe'}, {'\xf0','\xa6','\x93','\x9a'}, {'\xf0','\xa6','\x94','\xa3'}, {'\xf0','\xa6','\x96','\xa8'}, {'\xf0','\xa6','\x9e','\xa7'}, {'\xf0','\xa6','\x9e','\xb5'}, {'\xf0','\xa6','\xac','\xbc'}, {'\xf0','\xa6','\xb0','\xb6'}, + /* 272 */ {'\xf0','\xa6','\xb3','\x95'}, {'\xf0','\xa6','\xb5','\xab'}, {'\xf0','\xa6','\xbc','\xac'}, {'\xf0','\xa6','\xbe','\xb1'}, {'\xf0','\xa7','\x83','\x92'}, {'\xf0','\xa7','\x8f','\x8a'}, {'\xf0','\xa7','\x99','\xa7'}, {'\xf0','\xa7','\xa2','\xae'}, + /* 280 */ {'\xf0','\xa7','\xa5','\xa6'}, {'\xf0','\xa7','\xb2','\xa8'}, {'\xf0','\xa7','\xbb','\x93'}, {'\xf0','\xa7','\xbc','\xaf'}, {'\xf0','\xa8','\x97','\x92'}, {'\xf0','\xa8','\x97','\xad'}, {'\xf0','\xa8','\x9c','\xae'}, {'\xf0','\xa8','\xaf','\xba'}, + /* 288 */ {'\xf0','\xa8','\xb5','\xb7'}, {'\xf0','\xa9','\x85','\x85'}, {'\xf0','\xa9','\x87','\x9f'}, {'\xf0','\xa9','\x88','\x9a'}, {'\xf0','\xa9','\x90','\x8a'}, {'\xf0','\xa9','\x92','\x96'}, {'\xf0','\xa9','\x96','\xb6'}, {'\xf0','\xa9','\xac','\xb0'}, + /* 296 */ {'\xf0','\xaa','\x83','\x8e'}, {'\xf0','\xaa','\x84','\x85'}, {'\xf0','\xaa','\x88','\x8e'}, {'\xf0','\xaa','\x8a','\x91'}, {'\xf0','\xaa','\x8e','\x92'}, {'\xf0','\xaa','\x98','\x80'}}; + +static const char UN8IF_canon_tbl_5 [162][5] = { + /* 0 */ {'A','\xcc','\x82','\xcc','\x80'}, {'A','\xcc','\x82','\xcc','\x81'}, {'A','\xcc','\x82','\xcc','\x83'}, {'A','\xcc','\x82','\xcc','\x89'}, {'A','\xcc','\x86','\xcc','\x80'}, {'A','\xcc','\x86','\xcc','\x81'}, {'A','\xcc','\x86','\xcc','\x83'}, {'A','\xcc','\x86','\xcc','\x89'}, + /* 8 */ {'A','\xcc','\x87','\xcc','\x84'}, {'A','\xcc','\x88','\xcc','\x84'}, {'A','\xcc','\x8a','\xcc','\x81'}, {'A','\xcc','\xa3','\xcc','\x82'}, {'A','\xcc','\xa3','\xcc','\x86'}, {'C','\xcc','\xa7','\xcc','\x81'}, {'E','\xcc','\x82','\xcc','\x80'}, {'E','\xcc','\x82','\xcc','\x81'}, + /* 16 */ {'E','\xcc','\x82','\xcc','\x83'}, {'E','\xcc','\x82','\xcc','\x89'}, {'E','\xcc','\x84','\xcc','\x80'}, {'E','\xcc','\x84','\xcc','\x81'}, {'E','\xcc','\xa3','\xcc','\x82'}, {'E','\xcc','\xa7','\xcc','\x86'}, {'I','\xcc','\x88','\xcc','\x81'}, {'L','\xcc','\xa3','\xcc','\x84'}, + /* 24 */ {'O','\xcc','\x82','\xcc','\x80'}, {'O','\xcc','\x82','\xcc','\x81'}, {'O','\xcc','\x82','\xcc','\x83'}, {'O','\xcc','\x82','\xcc','\x89'}, {'O','\xcc','\x83','\xcc','\x81'}, {'O','\xcc','\x83','\xcc','\x84'}, {'O','\xcc','\x83','\xcc','\x88'}, {'O','\xcc','\x84','\xcc','\x80'}, + /* 32 */ {'O','\xcc','\x84','\xcc','\x81'}, {'O','\xcc','\x87','\xcc','\x84'}, {'O','\xcc','\x88','\xcc','\x84'}, {'O','\xcc','\x9b','\xcc','\x80'}, {'O','\xcc','\x9b','\xcc','\x81'}, {'O','\xcc','\x9b','\xcc','\x83'}, {'O','\xcc','\x9b','\xcc','\x89'}, {'O','\xcc','\x9b','\xcc','\xa3'}, + /* 40 */ {'O','\xcc','\xa3','\xcc','\x82'}, {'O','\xcc','\xa8','\xcc','\x84'}, {'R','\xcc','\xa3','\xcc','\x84'}, {'S','\xcc','\x81','\xcc','\x87'}, {'S','\xcc','\x8c','\xcc','\x87'}, {'S','\xcc','\xa3','\xcc','\x87'}, {'U','\xcc','\x83','\xcc','\x81'}, {'U','\xcc','\x84','\xcc','\x88'}, + /* 48 */ {'U','\xcc','\x88','\xcc','\x80'}, {'U','\xcc','\x88','\xcc','\x81'}, {'U','\xcc','\x88','\xcc','\x84'}, {'U','\xcc','\x88','\xcc','\x8c'}, {'U','\xcc','\x9b','\xcc','\x80'}, {'U','\xcc','\x9b','\xcc','\x81'}, {'U','\xcc','\x9b','\xcc','\x83'}, {'U','\xcc','\x9b','\xcc','\x89'}, + /* 56 */ {'U','\xcc','\x9b','\xcc','\xa3'}, {'\xe1','\xbe','\xbf','\xcc','\x80'}, {'\xe1','\xbe','\xbf','\xcc','\x81'}, {'\xe1','\xbe','\xbf','\xcd','\x82'}, {'\xe1','\xbf','\xbe','\xcc','\x80'}, {'\xe1','\xbf','\xbe','\xcc','\x81'}, {'\xe1','\xbf','\xbe','\xcd','\x82'}, {'\xe2','\x86','\x90','\xcc','\xb8'}, + /* 64 */ {'\xe2','\x86','\x92','\xcc','\xb8'}, {'\xe2','\x86','\x94','\xcc','\xb8'}, {'\xe2','\x87','\x90','\xcc','\xb8'}, {'\xe2','\x87','\x92','\xcc','\xb8'}, {'\xe2','\x87','\x94','\xcc','\xb8'}, {'\xe2','\x88','\x83','\xcc','\xb8'}, {'\xe2','\x88','\x88','\xcc','\xb8'}, {'\xe2','\x88','\x8b','\xcc','\xb8'}, + /* 72 */ {'\xe2','\x88','\xa3','\xcc','\xb8'}, {'\xe2','\x88','\xa5','\xcc','\xb8'}, {'\xe2','\x88','\xbc','\xcc','\xb8'}, {'\xe2','\x89','\x83','\xcc','\xb8'}, {'\xe2','\x89','\x85','\xcc','\xb8'}, {'\xe2','\x89','\x88','\xcc','\xb8'}, {'\xe2','\x89','\x8d','\xcc','\xb8'}, {'\xe2','\x89','\xa1','\xcc','\xb8'}, + /* 80 */ {'\xe2','\x89','\xa4','\xcc','\xb8'}, {'\xe2','\x89','\xa5','\xcc','\xb8'}, {'\xe2','\x89','\xb2','\xcc','\xb8'}, {'\xe2','\x89','\xb3','\xcc','\xb8'}, {'\xe2','\x89','\xb6','\xcc','\xb8'}, {'\xe2','\x89','\xb7','\xcc','\xb8'}, {'\xe2','\x89','\xba','\xcc','\xb8'}, {'\xe2','\x89','\xbb','\xcc','\xb8'}, + /* 88 */ {'\xe2','\x89','\xbc','\xcc','\xb8'}, {'\xe2','\x89','\xbd','\xcc','\xb8'}, {'\xe2','\x8a','\x82','\xcc','\xb8'}, {'\xe2','\x8a','\x83','\xcc','\xb8'}, {'\xe2','\x8a','\x86','\xcc','\xb8'}, {'\xe2','\x8a','\x87','\xcc','\xb8'}, {'\xe2','\x8a','\x91','\xcc','\xb8'}, {'\xe2','\x8a','\x92','\xcc','\xb8'}, + /* 96 */ {'\xe2','\x8a','\xa2','\xcc','\xb8'}, {'\xe2','\x8a','\xa8','\xcc','\xb8'}, {'\xe2','\x8a','\xa9','\xcc','\xb8'}, {'\xe2','\x8a','\xab','\xcc','\xb8'}, {'\xe2','\x8a','\xb2','\xcc','\xb8'}, {'\xe2','\x8a','\xb3','\xcc','\xb8'}, {'\xe2','\x8a','\xb4','\xcc','\xb8'}, {'\xe2','\x8a','\xb5','\xcc','\xb8'}, + /* 104 */ {'\xe2','\xab','\x9d','\xcc','\xb8'}, {'a','\xcc','\x82','\xcc','\x80'}, {'a','\xcc','\x82','\xcc','\x81'}, {'a','\xcc','\x82','\xcc','\x83'}, {'a','\xcc','\x82','\xcc','\x89'}, {'a','\xcc','\x86','\xcc','\x80'}, {'a','\xcc','\x86','\xcc','\x81'}, {'a','\xcc','\x86','\xcc','\x83'}, + /* 112 */ {'a','\xcc','\x86','\xcc','\x89'}, {'a','\xcc','\x87','\xcc','\x84'}, {'a','\xcc','\x88','\xcc','\x84'}, {'a','\xcc','\x8a','\xcc','\x81'}, {'a','\xcc','\xa3','\xcc','\x82'}, {'a','\xcc','\xa3','\xcc','\x86'}, {'c','\xcc','\xa7','\xcc','\x81'}, {'e','\xcc','\x82','\xcc','\x80'}, + /* 120 */ {'e','\xcc','\x82','\xcc','\x81'}, {'e','\xcc','\x82','\xcc','\x83'}, {'e','\xcc','\x82','\xcc','\x89'}, {'e','\xcc','\x84','\xcc','\x80'}, {'e','\xcc','\x84','\xcc','\x81'}, {'e','\xcc','\xa3','\xcc','\x82'}, {'e','\xcc','\xa7','\xcc','\x86'}, {'i','\xcc','\x88','\xcc','\x81'}, + /* 128 */ {'l','\xcc','\xa3','\xcc','\x84'}, {'o','\xcc','\x82','\xcc','\x80'}, {'o','\xcc','\x82','\xcc','\x81'}, {'o','\xcc','\x82','\xcc','\x83'}, {'o','\xcc','\x82','\xcc','\x89'}, {'o','\xcc','\x83','\xcc','\x81'}, {'o','\xcc','\x83','\xcc','\x84'}, {'o','\xcc','\x83','\xcc','\x88'}, + /* 136 */ {'o','\xcc','\x84','\xcc','\x80'}, {'o','\xcc','\x84','\xcc','\x81'}, {'o','\xcc','\x87','\xcc','\x84'}, {'o','\xcc','\x88','\xcc','\x84'}, {'o','\xcc','\x9b','\xcc','\x80'}, {'o','\xcc','\x9b','\xcc','\x81'}, {'o','\xcc','\x9b','\xcc','\x83'}, {'o','\xcc','\x9b','\xcc','\x89'}, + /* 144 */ {'o','\xcc','\x9b','\xcc','\xa3'}, {'o','\xcc','\xa3','\xcc','\x82'}, {'o','\xcc','\xa8','\xcc','\x84'}, {'r','\xcc','\xa3','\xcc','\x84'}, {'s','\xcc','\x81','\xcc','\x87'}, {'s','\xcc','\x8c','\xcc','\x87'}, {'s','\xcc','\xa3','\xcc','\x87'}, {'u','\xcc','\x83','\xcc','\x81'}, + /* 152 */ {'u','\xcc','\x84','\xcc','\x88'}, {'u','\xcc','\x88','\xcc','\x80'}, {'u','\xcc','\x88','\xcc','\x81'}, {'u','\xcc','\x88','\xcc','\x84'}, {'u','\xcc','\x88','\xcc','\x8c'}, {'u','\xcc','\x9b','\xcc','\x80'}, {'u','\xcc','\x9b','\xcc','\x81'}, {'u','\xcc','\x9b','\xcc','\x83'}, + /* 160 */ {'u','\xcc','\x9b','\xcc','\x89'}, {'u','\xcc','\x9b','\xcc','\xa3'}}; + +/* the special-cased overlong entries */ +typedef struct { const uint32_t cp; const char* v; } UN8IF_canon_exc_t; +/* sorted for binary search */ +#define UN8IF_canon_exc_size 297 +static const UN8IF_canon_exc_t UN8IF_canon_exc [297] = { + { 0x390, "\xce\xb9\xcc\x88\xcc\x81" }, + { 0x3b0, "\xcf\x85\xcc\x88\xcc\x81" }, + { 0x929, "\xe0\xa4\xa8\xe0\xa4\xbc" }, + { 0x931, "\xe0\xa4\xb0\xe0\xa4\xbc" }, + { 0x934, "\xe0\xa4\xb3\xe0\xa4\xbc" }, + { 0x958, "\xe0\xa4\x95\xe0\xa4\xbc" }, + { 0x959, "\xe0\xa4\x96\xe0\xa4\xbc" }, + { 0x95a, "\xe0\xa4\x97\xe0\xa4\xbc" }, + { 0x95b, "\xe0\xa4\x9c\xe0\xa4\xbc" }, + { 0x95c, "\xe0\xa4\xa1\xe0\xa4\xbc" }, + { 0x95d, "\xe0\xa4\xa2\xe0\xa4\xbc" }, + { 0x95e, "\xe0\xa4\xab\xe0\xa4\xbc" }, + { 0x95f, "\xe0\xa4\xaf\xe0\xa4\xbc" }, + { 0x9cb, "\xe0\xa7\x87\xe0\xa6\xbe" }, + { 0x9cc, "\xe0\xa7\x87\xe0\xa7\x97" }, + { 0x9dc, "\xe0\xa6\xa1\xe0\xa6\xbc" }, + { 0x9dd, "\xe0\xa6\xa2\xe0\xa6\xbc" }, + { 0x9df, "\xe0\xa6\xaf\xe0\xa6\xbc" }, + { 0xa33, "\xe0\xa8\xb2\xe0\xa8\xbc" }, + { 0xa36, "\xe0\xa8\xb8\xe0\xa8\xbc" }, + { 0xa59, "\xe0\xa8\x96\xe0\xa8\xbc" }, + { 0xa5a, "\xe0\xa8\x97\xe0\xa8\xbc" }, + { 0xa5b, "\xe0\xa8\x9c\xe0\xa8\xbc" }, + { 0xa5e, "\xe0\xa8\xab\xe0\xa8\xbc" }, + { 0xb48, "\xe0\xad\x87\xe0\xad\x96" }, + { 0xb4b, "\xe0\xad\x87\xe0\xac\xbe" }, + { 0xb4c, "\xe0\xad\x87\xe0\xad\x97" }, + { 0xb5c, "\xe0\xac\xa1\xe0\xac\xbc" }, + { 0xb5d, "\xe0\xac\xa2\xe0\xac\xbc" }, + { 0xb94, "\xe0\xae\x92\xe0\xaf\x97" }, + { 0xbca, "\xe0\xaf\x86\xe0\xae\xbe" }, + { 0xbcb, "\xe0\xaf\x87\xe0\xae\xbe" }, + { 0xbcc, "\xe0\xaf\x86\xe0\xaf\x97" }, + { 0xc48, "\xe0\xb1\x86\xe0\xb1\x96" }, + { 0xcc0, "\xe0\xb2\xbf\xe0\xb3\x95" }, + { 0xcc7, "\xe0\xb3\x86\xe0\xb3\x95" }, + { 0xcc8, "\xe0\xb3\x86\xe0\xb3\x96" }, + { 0xcca, "\xe0\xb3\x86\xe0\xb3\x82" }, + { 0xccb, "\xe0\xb3\x86\xe0\xb3\x82\xe0\xb3\x95" }, + { 0xd4a, "\xe0\xb5\x86\xe0\xb4\xbe" }, + { 0xd4b, "\xe0\xb5\x87\xe0\xb4\xbe" }, + { 0xd4c, "\xe0\xb5\x86\xe0\xb5\x97" }, + { 0xdda, "\xe0\xb7\x99\xe0\xb7\x8a" }, + { 0xddc, "\xe0\xb7\x99\xe0\xb7\x8f" }, + { 0xddd, "\xe0\xb7\x99\xe0\xb7\x8f\xe0\xb7\x8a" }, + { 0xdde, "\xe0\xb7\x99\xe0\xb7\x9f" }, + { 0xf43, "\xe0\xbd\x82\xe0\xbe\xb7" }, + { 0xf4d, "\xe0\xbd\x8c\xe0\xbe\xb7" }, + { 0xf52, "\xe0\xbd\x91\xe0\xbe\xb7" }, + { 0xf57, "\xe0\xbd\x96\xe0\xbe\xb7" }, + { 0xf5c, "\xe0\xbd\x9b\xe0\xbe\xb7" }, + { 0xf69, "\xe0\xbd\x80\xe0\xbe\xb5" }, + { 0xf73, "\xe0\xbd\xb1\xe0\xbd\xb2" }, + { 0xf75, "\xe0\xbd\xb1\xe0\xbd\xb4" }, + { 0xf76, "\xe0\xbe\xb2\xe0\xbe\x80" }, + { 0xf78, "\xe0\xbe\xb3\xe0\xbe\x80" }, + { 0xf81, "\xe0\xbd\xb1\xe0\xbe\x80" }, + { 0xf93, "\xe0\xbe\x92\xe0\xbe\xb7" }, + { 0xf9d, "\xe0\xbe\x9c\xe0\xbe\xb7" }, + { 0xfa2, "\xe0\xbe\xa1\xe0\xbe\xb7" }, + { 0xfa7, "\xe0\xbe\xa6\xe0\xbe\xb7" }, + { 0xfac, "\xe0\xbe\xab\xe0\xbe\xb7" }, + { 0xfb9, "\xe0\xbe\x90\xe0\xbe\xb5" }, + { 0x1026, "\xe1\x80\xa5\xe1\x80\xae" }, + { 0x1b06, "\xe1\xac\x85\xe1\xac\xb5" }, + { 0x1b08, "\xe1\xac\x87\xe1\xac\xb5" }, + { 0x1b0a, "\xe1\xac\x89\xe1\xac\xb5" }, + { 0x1b0c, "\xe1\xac\x8b\xe1\xac\xb5" }, + { 0x1b0e, "\xe1\xac\x8d\xe1\xac\xb5" }, + { 0x1b12, "\xe1\xac\x91\xe1\xac\xb5" }, + { 0x1b3b, "\xe1\xac\xba\xe1\xac\xb5" }, + { 0x1b3d, "\xe1\xac\xbc\xe1\xac\xb5" }, + { 0x1b40, "\xe1\xac\xbe\xe1\xac\xb5" }, + { 0x1b41, "\xe1\xac\xbf\xe1\xac\xb5" }, + { 0x1b43, "\xe1\xad\x82\xe1\xac\xb5" }, + { 0x1f02, "\xce\xb1\xcc\x93\xcc\x80" }, + { 0x1f03, "\xce\xb1\xcc\x94\xcc\x80" }, + { 0x1f04, "\xce\xb1\xcc\x93\xcc\x81" }, + { 0x1f05, "\xce\xb1\xcc\x94\xcc\x81" }, + { 0x1f06, "\xce\xb1\xcc\x93\xcd\x82" }, + { 0x1f07, "\xce\xb1\xcc\x94\xcd\x82" }, + { 0x1f0a, "\xce\x91\xcc\x93\xcc\x80" }, + { 0x1f0b, "\xce\x91\xcc\x94\xcc\x80" }, + { 0x1f0c, "\xce\x91\xcc\x93\xcc\x81" }, + { 0x1f0d, "\xce\x91\xcc\x94\xcc\x81" }, + { 0x1f0e, "\xce\x91\xcc\x93\xcd\x82" }, + { 0x1f0f, "\xce\x91\xcc\x94\xcd\x82" }, + { 0x1f12, "\xce\xb5\xcc\x93\xcc\x80" }, + { 0x1f13, "\xce\xb5\xcc\x94\xcc\x80" }, + { 0x1f14, "\xce\xb5\xcc\x93\xcc\x81" }, + { 0x1f15, "\xce\xb5\xcc\x94\xcc\x81" }, + { 0x1f1a, "\xce\x95\xcc\x93\xcc\x80" }, + { 0x1f1b, "\xce\x95\xcc\x94\xcc\x80" }, + { 0x1f1c, "\xce\x95\xcc\x93\xcc\x81" }, + { 0x1f1d, "\xce\x95\xcc\x94\xcc\x81" }, + { 0x1f22, "\xce\xb7\xcc\x93\xcc\x80" }, + { 0x1f23, "\xce\xb7\xcc\x94\xcc\x80" }, + { 0x1f24, "\xce\xb7\xcc\x93\xcc\x81" }, + { 0x1f25, "\xce\xb7\xcc\x94\xcc\x81" }, + { 0x1f26, "\xce\xb7\xcc\x93\xcd\x82" }, + { 0x1f27, "\xce\xb7\xcc\x94\xcd\x82" }, + { 0x1f2a, "\xce\x97\xcc\x93\xcc\x80" }, + { 0x1f2b, "\xce\x97\xcc\x94\xcc\x80" }, + { 0x1f2c, "\xce\x97\xcc\x93\xcc\x81" }, + { 0x1f2d, "\xce\x97\xcc\x94\xcc\x81" }, + { 0x1f2e, "\xce\x97\xcc\x93\xcd\x82" }, + { 0x1f2f, "\xce\x97\xcc\x94\xcd\x82" }, + { 0x1f32, "\xce\xb9\xcc\x93\xcc\x80" }, + { 0x1f33, "\xce\xb9\xcc\x94\xcc\x80" }, + { 0x1f34, "\xce\xb9\xcc\x93\xcc\x81" }, + { 0x1f35, "\xce\xb9\xcc\x94\xcc\x81" }, + { 0x1f36, "\xce\xb9\xcc\x93\xcd\x82" }, + { 0x1f37, "\xce\xb9\xcc\x94\xcd\x82" }, + { 0x1f3a, "\xce\x99\xcc\x93\xcc\x80" }, + { 0x1f3b, "\xce\x99\xcc\x94\xcc\x80" }, + { 0x1f3c, "\xce\x99\xcc\x93\xcc\x81" }, + { 0x1f3d, "\xce\x99\xcc\x94\xcc\x81" }, + { 0x1f3e, "\xce\x99\xcc\x93\xcd\x82" }, + { 0x1f3f, "\xce\x99\xcc\x94\xcd\x82" }, + { 0x1f42, "\xce\xbf\xcc\x93\xcc\x80" }, + { 0x1f43, "\xce\xbf\xcc\x94\xcc\x80" }, + { 0x1f44, "\xce\xbf\xcc\x93\xcc\x81" }, + { 0x1f45, "\xce\xbf\xcc\x94\xcc\x81" }, + { 0x1f4a, "\xce\x9f\xcc\x93\xcc\x80" }, + { 0x1f4b, "\xce\x9f\xcc\x94\xcc\x80" }, + { 0x1f4c, "\xce\x9f\xcc\x93\xcc\x81" }, + { 0x1f4d, "\xce\x9f\xcc\x94\xcc\x81" }, + { 0x1f52, "\xcf\x85\xcc\x93\xcc\x80" }, + { 0x1f53, "\xcf\x85\xcc\x94\xcc\x80" }, + { 0x1f54, "\xcf\x85\xcc\x93\xcc\x81" }, + { 0x1f55, "\xcf\x85\xcc\x94\xcc\x81" }, + { 0x1f56, "\xcf\x85\xcc\x93\xcd\x82" }, + { 0x1f57, "\xcf\x85\xcc\x94\xcd\x82" }, + { 0x1f5b, "\xce\xa5\xcc\x94\xcc\x80" }, + { 0x1f5d, "\xce\xa5\xcc\x94\xcc\x81" }, + { 0x1f5f, "\xce\xa5\xcc\x94\xcd\x82" }, + { 0x1f62, "\xcf\x89\xcc\x93\xcc\x80" }, + { 0x1f63, "\xcf\x89\xcc\x94\xcc\x80" }, + { 0x1f64, "\xcf\x89\xcc\x93\xcc\x81" }, + { 0x1f65, "\xcf\x89\xcc\x94\xcc\x81" }, + { 0x1f66, "\xcf\x89\xcc\x93\xcd\x82" }, + { 0x1f67, "\xcf\x89\xcc\x94\xcd\x82" }, + { 0x1f6a, "\xce\xa9\xcc\x93\xcc\x80" }, + { 0x1f6b, "\xce\xa9\xcc\x94\xcc\x80" }, + { 0x1f6c, "\xce\xa9\xcc\x93\xcc\x81" }, + { 0x1f6d, "\xce\xa9\xcc\x94\xcc\x81" }, + { 0x1f6e, "\xce\xa9\xcc\x93\xcd\x82" }, + { 0x1f6f, "\xce\xa9\xcc\x94\xcd\x82" }, + { 0x1f80, "\xce\xb1\xcc\x93\xcd\x85" }, + { 0x1f81, "\xce\xb1\xcc\x94\xcd\x85" }, + { 0x1f82, "\xce\xb1\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f83, "\xce\xb1\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f84, "\xce\xb1\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f85, "\xce\xb1\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f86, "\xce\xb1\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f87, "\xce\xb1\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f88, "\xce\x91\xcc\x93\xcd\x85" }, + { 0x1f89, "\xce\x91\xcc\x94\xcd\x85" }, + { 0x1f8a, "\xce\x91\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f8b, "\xce\x91\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f8c, "\xce\x91\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f8d, "\xce\x91\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f8e, "\xce\x91\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f8f, "\xce\x91\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f90, "\xce\xb7\xcc\x93\xcd\x85" }, + { 0x1f91, "\xce\xb7\xcc\x94\xcd\x85" }, + { 0x1f92, "\xce\xb7\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f93, "\xce\xb7\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f94, "\xce\xb7\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f95, "\xce\xb7\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f96, "\xce\xb7\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f97, "\xce\xb7\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f98, "\xce\x97\xcc\x93\xcd\x85" }, + { 0x1f99, "\xce\x97\xcc\x94\xcd\x85" }, + { 0x1f9a, "\xce\x97\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f9b, "\xce\x97\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f9c, "\xce\x97\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f9d, "\xce\x97\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f9e, "\xce\x97\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f9f, "\xce\x97\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fa0, "\xcf\x89\xcc\x93\xcd\x85" }, + { 0x1fa1, "\xcf\x89\xcc\x94\xcd\x85" }, + { 0x1fa2, "\xcf\x89\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1fa3, "\xcf\x89\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1fa4, "\xcf\x89\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1fa5, "\xcf\x89\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1fa6, "\xcf\x89\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1fa7, "\xcf\x89\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fa8, "\xce\xa9\xcc\x93\xcd\x85" }, + { 0x1fa9, "\xce\xa9\xcc\x94\xcd\x85" }, + { 0x1faa, "\xce\xa9\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1fab, "\xce\xa9\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1fac, "\xce\xa9\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1fad, "\xce\xa9\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1fae, "\xce\xa9\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1faf, "\xce\xa9\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fb2, "\xce\xb1\xcc\x80\xcd\x85" }, + { 0x1fb4, "\xce\xb1\xcc\x81\xcd\x85" }, + { 0x1fb7, "\xce\xb1\xcd\x82\xcd\x85" }, + { 0x1fc2, "\xce\xb7\xcc\x80\xcd\x85" }, + { 0x1fc4, "\xce\xb7\xcc\x81\xcd\x85" }, + { 0x1fc7, "\xce\xb7\xcd\x82\xcd\x85" }, + { 0x1fd2, "\xce\xb9\xcc\x88\xcc\x80" }, + { 0x1fd3, "\xce\xb9\xcc\x88\xcc\x81" }, + { 0x1fd7, "\xce\xb9\xcc\x88\xcd\x82" }, + { 0x1fe2, "\xcf\x85\xcc\x88\xcc\x80" }, + { 0x1fe3, "\xcf\x85\xcc\x88\xcc\x81" }, + { 0x1fe7, "\xcf\x85\xcc\x88\xcd\x82" }, + { 0x1ff2, "\xcf\x89\xcc\x80\xcd\x85" }, + { 0x1ff4, "\xcf\x89\xcc\x81\xcd\x85" }, + { 0x1ff7, "\xcf\x89\xcd\x82\xcd\x85" }, + { 0x304c, "\xe3\x81\x8b\xe3\x82\x99" }, + { 0x304e, "\xe3\x81\x8d\xe3\x82\x99" }, + { 0x3050, "\xe3\x81\x8f\xe3\x82\x99" }, + { 0x3052, "\xe3\x81\x91\xe3\x82\x99" }, + { 0x3054, "\xe3\x81\x93\xe3\x82\x99" }, + { 0x3056, "\xe3\x81\x95\xe3\x82\x99" }, + { 0x3058, "\xe3\x81\x97\xe3\x82\x99" }, + { 0x305a, "\xe3\x81\x99\xe3\x82\x99" }, + { 0x305c, "\xe3\x81\x9b\xe3\x82\x99" }, + { 0x305e, "\xe3\x81\x9d\xe3\x82\x99" }, + { 0x3060, "\xe3\x81\x9f\xe3\x82\x99" }, + { 0x3062, "\xe3\x81\xa1\xe3\x82\x99" }, + { 0x3065, "\xe3\x81\xa4\xe3\x82\x99" }, + { 0x3067, "\xe3\x81\xa6\xe3\x82\x99" }, + { 0x3069, "\xe3\x81\xa8\xe3\x82\x99" }, + { 0x3070, "\xe3\x81\xaf\xe3\x82\x99" }, + { 0x3071, "\xe3\x81\xaf\xe3\x82\x9a" }, + { 0x3073, "\xe3\x81\xb2\xe3\x82\x99" }, + { 0x3074, "\xe3\x81\xb2\xe3\x82\x9a" }, + { 0x3076, "\xe3\x81\xb5\xe3\x82\x99" }, + { 0x3077, "\xe3\x81\xb5\xe3\x82\x9a" }, + { 0x3079, "\xe3\x81\xb8\xe3\x82\x99" }, + { 0x307a, "\xe3\x81\xb8\xe3\x82\x9a" }, + { 0x307c, "\xe3\x81\xbb\xe3\x82\x99" }, + { 0x307d, "\xe3\x81\xbb\xe3\x82\x9a" }, + { 0x3094, "\xe3\x81\x86\xe3\x82\x99" }, + { 0x309e, "\xe3\x82\x9d\xe3\x82\x99" }, + { 0x30ac, "\xe3\x82\xab\xe3\x82\x99" }, + { 0x30ae, "\xe3\x82\xad\xe3\x82\x99" }, + { 0x30b0, "\xe3\x82\xaf\xe3\x82\x99" }, + { 0x30b2, "\xe3\x82\xb1\xe3\x82\x99" }, + { 0x30b4, "\xe3\x82\xb3\xe3\x82\x99" }, + { 0x30b6, "\xe3\x82\xb5\xe3\x82\x99" }, + { 0x30b8, "\xe3\x82\xb7\xe3\x82\x99" }, + { 0x30ba, "\xe3\x82\xb9\xe3\x82\x99" }, + { 0x30bc, "\xe3\x82\xbb\xe3\x82\x99" }, + { 0x30be, "\xe3\x82\xbd\xe3\x82\x99" }, + { 0x30c0, "\xe3\x82\xbf\xe3\x82\x99" }, + { 0x30c2, "\xe3\x83\x81\xe3\x82\x99" }, + { 0x30c5, "\xe3\x83\x84\xe3\x82\x99" }, + { 0x30c7, "\xe3\x83\x86\xe3\x82\x99" }, + { 0x30c9, "\xe3\x83\x88\xe3\x82\x99" }, + { 0x30d0, "\xe3\x83\x8f\xe3\x82\x99" }, + { 0x30d1, "\xe3\x83\x8f\xe3\x82\x9a" }, + { 0x30d3, "\xe3\x83\x92\xe3\x82\x99" }, + { 0x30d4, "\xe3\x83\x92\xe3\x82\x9a" }, + { 0x30d6, "\xe3\x83\x95\xe3\x82\x99" }, + { 0x30d7, "\xe3\x83\x95\xe3\x82\x9a" }, + { 0x30d9, "\xe3\x83\x98\xe3\x82\x99" }, + { 0x30da, "\xe3\x83\x98\xe3\x82\x9a" }, + { 0x30dc, "\xe3\x83\x9b\xe3\x82\x99" }, + { 0x30dd, "\xe3\x83\x9b\xe3\x82\x9a" }, + { 0x30f4, "\xe3\x82\xa6\xe3\x82\x99" }, + { 0x30f7, "\xe3\x83\xaf\xe3\x82\x99" }, + { 0x30f8, "\xe3\x83\xb0\xe3\x82\x99" }, + { 0x30f9, "\xe3\x83\xb1\xe3\x82\x99" }, + { 0x30fa, "\xe3\x83\xb2\xe3\x82\x99" }, + { 0x30fe, "\xe3\x83\xbd\xe3\x82\x99" }, + { 0xfb2c, "\xd7\xa9\xd6\xbc\xd7\x81" }, + { 0xfb2d, "\xd7\xa9\xd6\xbc\xd7\x82" }, + { 0x1109a, "\xf0\x91\x82\x99\xf0\x91\x82\xba" }, + { 0x1109c, "\xf0\x91\x82\x9b\xf0\x91\x82\xba" }, + { 0x110ab, "\xf0\x91\x82\xa5\xf0\x91\x82\xba" }, + { 0x1112e, "\xf0\x91\x84\xb1\xf0\x91\x84\xa7" }, + { 0x1112f, "\xf0\x91\x84\xb2\xf0\x91\x84\xa7" }, + { 0x1134b, "\xf0\x91\x8d\x87\xf0\x91\x8c\xbe" }, + { 0x1134c, "\xf0\x91\x8d\x87\xf0\x91\x8d\x97" }, + { 0x114bb, "\xf0\x91\x92\xb9\xf0\x91\x92\xba" }, + { 0x114bc, "\xf0\x91\x92\xb9\xf0\x91\x92\xb0" }, + { 0x114be, "\xf0\x91\x92\xb9\xf0\x91\x92\xbd" }, + { 0x115ba, "\xf0\x91\x96\xb8\xf0\x91\x96\xaf" }, + { 0x115bb, "\xf0\x91\x96\xb9\xf0\x91\x96\xaf" }, + { 0x11938, "\xf0\x91\xa4\xb5\xf0\x91\xa4\xb0" }, + { 0x1d15e, "\xf0\x9d\x85\x97\xf0\x9d\x85\xa5" }, + { 0x1d15f, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5" }, + { 0x1d160, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d161, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" }, + { 0x1d162, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb0" }, + { 0x1d163, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb1" }, + { 0x1d164, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb2" }, + { 0x1d1bb, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5" }, + { 0x1d1bc, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5" }, + { 0x1d1bd, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d1be, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d1bf, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" }, + { 0x1d1c0, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" } +}; + +static const char* UN8IF_canon_tbl [5] = { + (const char*) UN8IF_canon_tbl_1, + (const char*) UN8IF_canon_tbl_2, + (const char*) UN8IF_canon_tbl_3, + (const char*) UN8IF_canon_tbl_4, + (const char*) UN8IF_canon_tbl_5 +}; + +/* the rows */ +static const uint16_t UN8IF_canon_00_00 [256] = { +/* 0000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00c0 */ TBL(3)|3, TBL(3)|4, TBL(3)|5, TBL(3)|6, TBL(3)|10, TBL(3)|12, 0, TBL(3)|26, +/* 00c8 */ TBL(3)|33, TBL(3)|34, TBL(3)|35, TBL(3)|40, TBL(3)|65, TBL(3)|66, TBL(3)|67, TBL(3)|72, +/* 00d0 */ 0, TBL(3)|97, TBL(3)|104, TBL(3)|105, TBL(3)|106, TBL(3)|107, TBL(3)|111, 0, +/* 00d8 */ 0, TBL(3)|144, TBL(3)|145, TBL(3)|146, TBL(3)|150, TBL(3)|174, 0, 0, +/* 00e0 */ TBL(3)|984, TBL(3)|985, TBL(3)|986, TBL(3)|987, TBL(3)|991, TBL(3)|993, 0, TBL(3)|1007, +/* 00e8 */ TBL(3)|1014, TBL(3)|1015, TBL(3)|1016, TBL(3)|1021, TBL(3)|1047, TBL(3)|1048, TBL(3)|1049, TBL(3)|1053, +/* 00f0 */ 0, TBL(3)|1079, TBL(3)|1086, TBL(3)|1087, TBL(3)|1088, TBL(3)|1089, TBL(3)|1093, 0, +/* 00f8 */ 0, TBL(3)|1127, TBL(3)|1128, TBL(3)|1129, TBL(3)|1133, TBL(3)|1158, 0, TBL(3)|1163 +}; + +static const uint16_t UN8IF_canon_00_01 [256] = { +/* 0100 */ TBL(3)|7, TBL(3)|988, TBL(3)|8, TBL(3)|989, TBL(3)|18, TBL(3)|999, TBL(3)|22, TBL(3)|1003, +/* 0108 */ TBL(3)|23, TBL(3)|1004, TBL(3)|24, TBL(3)|1005, TBL(3)|25, TBL(3)|1006, TBL(3)|28, TBL(3)|1009, +/* 0110 */ 0, 0, TBL(3)|37, TBL(3)|1018, TBL(3)|38, TBL(3)|1019, TBL(3)|39, TBL(3)|1020, +/* 0118 */ TBL(3)|47, TBL(3)|1028, TBL(3)|42, TBL(3)|1023, TBL(3)|52, TBL(3)|1033, TBL(3)|54, TBL(3)|1035, +/* 0120 */ TBL(3)|55, TBL(3)|1036, TBL(3)|57, TBL(3)|1038, TBL(3)|58, TBL(3)|1039, 0, 0, +/* 0128 */ TBL(3)|68, TBL(3)|1050, TBL(3)|69, TBL(3)|1051, TBL(3)|70, TBL(3)|1052, TBL(3)|78, TBL(3)|1059, +/* 0130 */ TBL(3)|71, 0, 0, 0, TBL(3)|80, TBL(3)|1061, TBL(3)|84, TBL(3)|1066, +/* 0138 */ 0, TBL(3)|86, TBL(3)|1068, TBL(3)|89, TBL(3)|1071, TBL(3)|87, TBL(3)|1069, 0, +/* 0140 */ 0, 0, 0, TBL(3)|96, TBL(3)|1078, TBL(3)|101, TBL(3)|1083, TBL(3)|99, +/* 0148 */ TBL(3)|1081, 0, 0, 0, TBL(3)|108, TBL(3)|1090, TBL(3)|109, TBL(3)|1091, +/* 0150 */ TBL(3)|113, TBL(3)|1095, 0, 0, TBL(3)|122, TBL(3)|1104, TBL(3)|128, TBL(3)|1110, +/* 0158 */ TBL(3)|124, TBL(3)|1106, TBL(3)|130, TBL(3)|1112, TBL(3)|131, TBL(3)|1113, TBL(3)|136, TBL(3)|1118, +/* 0160 */ TBL(3)|133, TBL(3)|1115, TBL(3)|141, TBL(3)|1124, TBL(3)|138, TBL(3)|1121, 0, 0, +/* 0168 */ TBL(3)|147, TBL(3)|1130, TBL(3)|148, TBL(3)|1131, TBL(3)|149, TBL(3)|1132, TBL(3)|152, TBL(3)|1135, +/* 0170 */ TBL(3)|153, TBL(3)|1136, TBL(3)|160, TBL(3)|1143, TBL(3)|167, TBL(3)|1150, TBL(3)|175, TBL(3)|1159, +/* 0178 */ TBL(3)|179, TBL(3)|182, TBL(3)|1167, TBL(3)|184, TBL(3)|1169, TBL(3)|185, TBL(3)|1170, 0, +/* 0180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01a0 */ TBL(3)|117, TBL(3)|1099, 0, 0, 0, 0, 0, 0, +/* 01a8 */ 0, 0, 0, 0, 0, 0, 0, TBL(3)|157, +/* 01b0 */ TBL(3)|1140, 0, 0, 0, 0, 0, 0, 0, +/* 01b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01c8 */ 0, 0, 0, 0, 0, TBL(3)|13, TBL(3)|994, TBL(3)|74, +/* 01d0 */ TBL(3)|1055, TBL(3)|114, TBL(3)|1096, TBL(3)|154, TBL(3)|1137, TBL(5)|50, TBL(5)|155, TBL(5)|49, +/* 01d8 */ TBL(5)|154, TBL(5)|51, TBL(5)|156, TBL(5)|48, TBL(5)|153, 0, TBL(5)|9, TBL(5)|114, +/* 01e0 */ TBL(5)|8, TBL(5)|113, TBL(4)|4, TBL(4)|7, 0, 0, TBL(3)|56, TBL(3)|1037, +/* 01e8 */ TBL(3)|82, TBL(3)|1064, TBL(3)|119, TBL(3)|1101, TBL(5)|41, TBL(5)|146, TBL(4)|10, TBL(4)|11, +/* 01f0 */ TBL(3)|1062, 0, 0, 0, TBL(3)|51, TBL(3)|1032, 0, 0, +/* 01f8 */ TBL(3)|95, TBL(3)|1077, TBL(5)|10, TBL(5)|115, TBL(4)|3, TBL(4)|6, TBL(4)|5, TBL(4)|8 +}; + +static const uint16_t UN8IF_canon_00_02 [256] = { +/* 0200 */ TBL(3)|14, TBL(3)|995, TBL(3)|15, TBL(3)|996, TBL(3)|43, TBL(3)|1024, TBL(3)|44, TBL(3)|1025, +/* 0208 */ TBL(3)|75, TBL(3)|1056, TBL(3)|76, TBL(3)|1057, TBL(3)|115, TBL(3)|1097, TBL(3)|116, TBL(3)|1098, +/* 0210 */ TBL(3)|125, TBL(3)|1107, TBL(3)|126, TBL(3)|1108, TBL(3)|155, TBL(3)|1138, TBL(3)|156, TBL(3)|1139, +/* 0218 */ TBL(3)|135, TBL(3)|1117, TBL(3)|140, TBL(3)|1123, 0, 0, TBL(3)|61, TBL(3)|1042, +/* 0220 */ 0, 0, 0, 0, 0, 0, TBL(3)|9, TBL(3)|990, +/* 0228 */ TBL(3)|46, TBL(3)|1027, TBL(5)|34, TBL(5)|139, TBL(5)|29, TBL(5)|134, TBL(3)|110, TBL(3)|1092, +/* 0230 */ TBL(5)|33, TBL(5)|138, TBL(3)|177, TBL(3)|1161, 0, 0, 0, 0, +/* 0238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0240 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_03 [256] = { +/* 0300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0340 */ TBL(2)|3, TBL(2)|4, 0, TBL(2)|5, TBL(4)|12, 0, 0, 0, +/* 0348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0370 */ 0, 0, 0, 0, TBL(2)|2, 0, 0, 0, +/* 0378 */ 0, 0, 0, 0, 0, 0, TBL(1)|0, 0, +/* 0380 */ 0, 0, 0, 0, 0, TBL(4)|1, TBL(4)|14, TBL(2)|1, +/* 0388 */ TBL(4)|21, TBL(4)|25, TBL(4)|30, 0, TBL(4)|37, 0, TBL(4)|42, TBL(4)|48, +/* 0390 */ (uint16_t)-1 /*TBL(6)|68*/, 0, 0, 0, 0, 0, 0, 0, +/* 0398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a8 */ 0, 0, TBL(4)|33, TBL(4)|45, TBL(4)|53, TBL(4)|61, TBL(4)|65, TBL(4)|71, +/* 03b0 */ (uint16_t)-1 /*TBL(6)|81*/, 0, 0, 0, 0, 0, 0, 0, +/* 03b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c8 */ 0, 0, TBL(4)|74, TBL(4)|88, TBL(4)|79, TBL(4)|85, TBL(4)|93, 0, +/* 03d0 */ 0, 0, 0, TBL(4)|98, TBL(4)|99, 0, 0, 0, +/* 03d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_04 [256] = { +/* 0400 */ TBL(4)|104, TBL(4)|106, 0, TBL(4)|103, 0, 0, 0, TBL(4)|100, +/* 0408 */ 0, 0, 0, 0, TBL(4)|114, TBL(4)|110, TBL(4)|117, 0, +/* 0410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0418 */ 0, TBL(4)|112, 0, 0, 0, 0, 0, 0, +/* 0420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0438 */ 0, TBL(4)|134, 0, 0, 0, 0, 0, 0, +/* 0440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0450 */ TBL(4)|126, TBL(4)|128, 0, TBL(4)|125, 0, 0, 0, TBL(4)|145, +/* 0458 */ 0, 0, 0, 0, TBL(4)|136, TBL(4)|132, TBL(4)|139, 0, +/* 0460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0470 */ 0, 0, 0, 0, 0, 0, TBL(4)|146, TBL(4)|147, +/* 0478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0480 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04c0 */ 0, TBL(4)|107, TBL(4)|129, 0, 0, 0, 0, 0, +/* 04c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04d0 */ TBL(4)|101, TBL(4)|123, TBL(4)|102, TBL(4)|124, 0, 0, TBL(4)|105, TBL(4)|127, +/* 04d8 */ 0, 0, TBL(4)|148, TBL(4)|149, TBL(4)|108, TBL(4)|130, TBL(4)|109, TBL(4)|131, +/* 04e0 */ 0, 0, TBL(4)|111, TBL(4)|133, TBL(4)|113, TBL(4)|135, TBL(4)|115, TBL(4)|137, +/* 04e8 */ 0, 0, TBL(4)|150, TBL(4)|151, TBL(4)|122, TBL(4)|144, TBL(4)|116, TBL(4)|138, +/* 04f0 */ TBL(4)|118, TBL(4)|140, TBL(4)|119, TBL(4)|141, TBL(4)|120, TBL(4)|142, 0, 0, +/* 04f8 */ TBL(4)|121, TBL(4)|143, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_06 [256] = { +/* 0600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0610 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0618 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0620 */ 0, 0, TBL(4)|184, TBL(4)|185, TBL(4)|187, TBL(4)|186, TBL(4)|188, 0, +/* 0628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0638 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0648 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0650 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0658 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0668 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0670 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0678 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0698 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06c0 */ TBL(4)|191, 0, TBL(4)|189, 0, 0, 0, 0, 0, +/* 06c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06d0 */ 0, 0, 0, TBL(4)|190, 0, 0, 0, 0, +/* 06d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_09 [256] = { +/* 0900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0928 */ 0, (uint16_t)-1 /*TBL(6)|108*/, 0, 0, 0, 0, 0, 0, +/* 0930 */ 0, (uint16_t)-1 /*TBL(6)|111*/, 0, 0, (uint16_t)-1 /*TBL(6)|112*/, 0, 0, 0, +/* 0938 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0958 */ (uint16_t)-1 /*TBL(6)|102*/, (uint16_t)-1 /*TBL(6)|103*/, (uint16_t)-1 /*TBL(6)|104*/, (uint16_t)-1 /*TBL(6)|105*/, (uint16_t)-1 /*TBL(6)|106*/, (uint16_t)-1 /*TBL(6)|107*/, (uint16_t)-1 /*TBL(6)|109*/, (uint16_t)-1 /*TBL(6)|110*/, +/* 0960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09c8 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|116*/, (uint16_t)-1 /*TBL(6)|117*/, 0, 0, 0, +/* 09d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09d8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|113*/, (uint16_t)-1 /*TBL(6)|114*/, 0, (uint16_t)-1 /*TBL(6)|115*/, +/* 09e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_0a [256] = { +/* 0a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a30 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|122*/, 0, 0, (uint16_t)-1 /*TBL(6)|123*/, 0, +/* 0a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a58 */ 0, (uint16_t)-1 /*TBL(6)|118*/, (uint16_t)-1 /*TBL(6)|119*/, (uint16_t)-1 /*TBL(6)|120*/, 0, 0, (uint16_t)-1 /*TBL(6)|121*/, 0, +/* 0a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_0b [256] = { +/* 0b00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b48 */ (uint16_t)-1 /*TBL(6)|127*/, 0, 0, (uint16_t)-1 /*TBL(6)|126*/, (uint16_t)-1 /*TBL(6)|128*/, 0, 0, 0, +/* 0b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b58 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|124*/, (uint16_t)-1 /*TBL(6)|125*/, 0, 0, +/* 0b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b90 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|129*/, 0, 0, 0, +/* 0b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc8 */ 0, 0, (uint16_t)-1 /*TBL(6)|130*/, (uint16_t)-1 /*TBL(6)|132*/, (uint16_t)-1 /*TBL(6)|131*/, 0, 0, 0, +/* 0bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_0c [256] = { +/* 0c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c48 */ (uint16_t)-1 /*TBL(6)|133*/, 0, 0, 0, 0, 0, 0, 0, +/* 0c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cc0 */ (uint16_t)-1 /*TBL(6)|134*/, 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|136*/, +/* 0cc8 */ (uint16_t)-1 /*TBL(6)|137*/, 0, (uint16_t)-1 /*TBL(6)|135*/, (uint16_t)-1 /*TBL(9)|0*/, 0, 0, 0, 0, +/* 0cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_0d [256] = { +/* 0d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d48 */ 0, 0, (uint16_t)-1 /*TBL(6)|138*/, (uint16_t)-1 /*TBL(6)|140*/, (uint16_t)-1 /*TBL(6)|139*/, 0, 0, 0, +/* 0d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dd8 */ 0, 0, (uint16_t)-1 /*TBL(6)|141*/, 0, (uint16_t)-1 /*TBL(6)|142*/, (uint16_t)-1 /*TBL(9)|1*/, (uint16_t)-1 /*TBL(6)|143*/, 0, +/* 0de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_0f [256] = { +/* 0f00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f40 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|145*/, 0, 0, 0, 0, +/* 0f48 */ 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|146*/, 0, 0, +/* 0f50 */ 0, 0, (uint16_t)-1 /*TBL(6)|147*/, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|148*/, +/* 0f58 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|149*/, 0, 0, 0, +/* 0f60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f68 */ 0, (uint16_t)-1 /*TBL(6)|144*/, 0, 0, 0, 0, 0, 0, +/* 0f70 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|150*/, 0, (uint16_t)-1 /*TBL(6)|151*/, (uint16_t)-1 /*TBL(6)|159*/, 0, +/* 0f78 */ (uint16_t)-1 /*TBL(6)|160*/, 0, 0, 0, 0, 0, 0, 0, +/* 0f80 */ 0, (uint16_t)-1 /*TBL(6)|152*/, 0, 0, 0, 0, 0, 0, +/* 0f88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f90 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|154*/, 0, 0, 0, 0, +/* 0f98 */ 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|155*/, 0, 0, +/* 0fa0 */ 0, 0, (uint16_t)-1 /*TBL(6)|156*/, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|157*/, +/* 0fa8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|158*/, 0, 0, 0, +/* 0fb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fb8 */ 0, (uint16_t)-1 /*TBL(6)|153*/, 0, 0, 0, 0, 0, 0, +/* 0fc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_10 [256] = { +/* 1000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1020 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|161*/, 0, +/* 1028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_1b [256] = { +/* 1b00 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|162*/, 0, +/* 1b08 */ (uint16_t)-1 /*TBL(6)|163*/, 0, (uint16_t)-1 /*TBL(6)|164*/, 0, (uint16_t)-1 /*TBL(6)|165*/, 0, (uint16_t)-1 /*TBL(6)|166*/, 0, +/* 1b10 */ 0, 0, (uint16_t)-1 /*TBL(6)|167*/, 0, 0, 0, 0, 0, +/* 1b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b38 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|168*/, 0, (uint16_t)-1 /*TBL(6)|169*/, 0, 0, +/* 1b40 */ (uint16_t)-1 /*TBL(6)|170*/, (uint16_t)-1 /*TBL(6)|171*/, 0, (uint16_t)-1 /*TBL(6)|172*/, 0, 0, 0, 0, +/* 1b48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_1e [256] = { +/* 1e00 */ TBL(3)|17, TBL(3)|998, TBL(3)|19, TBL(3)|1000, TBL(3)|20, TBL(3)|1001, TBL(3)|21, TBL(3)|1002, +/* 1e08 */ TBL(5)|13, TBL(5)|118, TBL(3)|27, TBL(3)|1008, TBL(3)|29, TBL(3)|1010, TBL(3)|32, TBL(3)|1013, +/* 1e10 */ TBL(3)|30, TBL(3)|1011, TBL(3)|31, TBL(3)|1012, TBL(5)|18, TBL(5)|123, TBL(5)|19, TBL(5)|124, +/* 1e18 */ TBL(3)|48, TBL(3)|1029, TBL(3)|49, TBL(3)|1030, TBL(5)|21, TBL(5)|126, TBL(3)|50, TBL(3)|1031, +/* 1e20 */ TBL(3)|53, TBL(3)|1034, TBL(3)|59, TBL(3)|1040, TBL(3)|62, TBL(3)|1043, TBL(3)|60, TBL(3)|1041, +/* 1e28 */ TBL(3)|63, TBL(3)|1044, TBL(3)|64, TBL(3)|1045, TBL(3)|79, TBL(3)|1060, TBL(5)|22, TBL(5)|127, +/* 1e30 */ TBL(3)|81, TBL(3)|1063, TBL(3)|83, TBL(3)|1065, TBL(3)|85, TBL(3)|1067, TBL(3)|88, TBL(3)|1070, +/* 1e38 */ TBL(5)|23, TBL(5)|128, TBL(3)|91, TBL(3)|1073, TBL(3)|90, TBL(3)|1072, TBL(3)|92, TBL(3)|1074, +/* 1e40 */ TBL(3)|93, TBL(3)|1075, TBL(3)|94, TBL(3)|1076, TBL(3)|98, TBL(3)|1080, TBL(3)|100, TBL(3)|1082, +/* 1e48 */ TBL(3)|103, TBL(3)|1085, TBL(3)|102, TBL(3)|1084, TBL(5)|28, TBL(5)|133, TBL(5)|30, TBL(5)|135, +/* 1e50 */ TBL(5)|31, TBL(5)|136, TBL(5)|32, TBL(5)|137, TBL(3)|120, TBL(3)|1102, TBL(3)|121, TBL(3)|1103, +/* 1e58 */ TBL(3)|123, TBL(3)|1105, TBL(3)|127, TBL(3)|1109, TBL(5)|42, TBL(5)|147, TBL(3)|129, TBL(3)|1111, +/* 1e60 */ TBL(3)|132, TBL(3)|1114, TBL(3)|134, TBL(3)|1116, TBL(5)|43, TBL(5)|148, TBL(5)|44, TBL(5)|149, +/* 1e68 */ TBL(5)|45, TBL(5)|150, TBL(3)|137, TBL(3)|1119, TBL(3)|139, TBL(3)|1122, TBL(3)|143, TBL(3)|1126, +/* 1e70 */ TBL(3)|142, TBL(3)|1125, TBL(3)|159, TBL(3)|1142, TBL(3)|162, TBL(3)|1145, TBL(3)|161, TBL(3)|1144, +/* 1e78 */ TBL(5)|46, TBL(5)|151, TBL(5)|47, TBL(5)|152, TBL(3)|163, TBL(3)|1146, TBL(3)|164, TBL(3)|1147, +/* 1e80 */ TBL(3)|165, TBL(3)|1148, TBL(3)|166, TBL(3)|1149, TBL(3)|169, TBL(3)|1152, TBL(3)|168, TBL(3)|1151, +/* 1e88 */ TBL(3)|170, TBL(3)|1154, TBL(3)|171, TBL(3)|1155, TBL(3)|172, TBL(3)|1156, TBL(3)|178, TBL(3)|1162, +/* 1e90 */ TBL(3)|183, TBL(3)|1168, TBL(3)|186, TBL(3)|1171, TBL(3)|187, TBL(3)|1172, TBL(3)|1046, TBL(3)|1120, +/* 1e98 */ TBL(3)|1153, TBL(3)|1165, 0, TBL(4)|9, 0, 0, 0, 0, +/* 1ea0 */ TBL(3)|16, TBL(3)|997, TBL(3)|11, TBL(3)|992, TBL(5)|1, TBL(5)|106, TBL(5)|0, TBL(5)|105, +/* 1ea8 */ TBL(5)|3, TBL(5)|108, TBL(5)|2, TBL(5)|107, TBL(5)|11, TBL(5)|116, TBL(5)|5, TBL(5)|110, +/* 1eb0 */ TBL(5)|4, TBL(5)|109, TBL(5)|7, TBL(5)|112, TBL(5)|6, TBL(5)|111, TBL(5)|12, TBL(5)|117, +/* 1eb8 */ TBL(3)|45, TBL(3)|1026, TBL(3)|41, TBL(3)|1022, TBL(3)|36, TBL(3)|1017, TBL(5)|15, TBL(5)|120, +/* 1ec0 */ TBL(5)|14, TBL(5)|119, TBL(5)|17, TBL(5)|122, TBL(5)|16, TBL(5)|121, TBL(5)|20, TBL(5)|125, +/* 1ec8 */ TBL(3)|73, TBL(3)|1054, TBL(3)|77, TBL(3)|1058, TBL(3)|118, TBL(3)|1100, TBL(3)|112, TBL(3)|1094, +/* 1ed0 */ TBL(5)|25, TBL(5)|130, TBL(5)|24, TBL(5)|129, TBL(5)|27, TBL(5)|132, TBL(5)|26, TBL(5)|131, +/* 1ed8 */ TBL(5)|40, TBL(5)|145, TBL(5)|36, TBL(5)|141, TBL(5)|35, TBL(5)|140, TBL(5)|38, TBL(5)|143, +/* 1ee0 */ TBL(5)|37, TBL(5)|142, TBL(5)|39, TBL(5)|144, TBL(3)|158, TBL(3)|1141, TBL(3)|151, TBL(3)|1134, +/* 1ee8 */ TBL(5)|53, TBL(5)|158, TBL(5)|52, TBL(5)|157, TBL(5)|55, TBL(5)|160, TBL(5)|54, TBL(5)|159, +/* 1ef0 */ TBL(5)|56, TBL(5)|161, TBL(3)|173, TBL(3)|1157, TBL(3)|181, TBL(3)|1166, TBL(3)|180, TBL(3)|1164, +/* 1ef8 */ TBL(3)|176, TBL(3)|1160, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_1f [256] = { +/* 1f00 */ TBL(4)|56, TBL(4)|57, (uint16_t)-1 /*TBL(6)|43*/, (uint16_t)-1 /*TBL(6)|47*/, (uint16_t)-1 /*TBL(6)|44*/, (uint16_t)-1 /*TBL(6)|48*/, (uint16_t)-1 /*TBL(6)|45*/, (uint16_t)-1 /*TBL(6)|49*/, +/* 1f08 */ TBL(4)|17, TBL(4)|18, (uint16_t)-1 /*TBL(6)|0*/, (uint16_t)-1 /*TBL(6)|4*/, (uint16_t)-1 /*TBL(6)|1*/, (uint16_t)-1 /*TBL(6)|5*/, (uint16_t)-1 /*TBL(6)|2*/, (uint16_t)-1 /*TBL(6)|6*/, +/* 1f10 */ TBL(4)|62, TBL(4)|63, (uint16_t)-1 /*TBL(6)|52*/, (uint16_t)-1 /*TBL(6)|54*/, (uint16_t)-1 /*TBL(6)|53*/, (uint16_t)-1 /*TBL(6)|55*/, 0, 0, +/* 1f18 */ TBL(4)|22, TBL(4)|23, (uint16_t)-1 /*TBL(6)|8*/, (uint16_t)-1 /*TBL(6)|10*/, (uint16_t)-1 /*TBL(6)|9*/, (uint16_t)-1 /*TBL(6)|11*/, 0, 0, +/* 1f20 */ TBL(4)|66, TBL(4)|67, (uint16_t)-1 /*TBL(6)|58*/, (uint16_t)-1 /*TBL(6)|62*/, (uint16_t)-1 /*TBL(6)|59*/, (uint16_t)-1 /*TBL(6)|63*/, (uint16_t)-1 /*TBL(6)|60*/, (uint16_t)-1 /*TBL(6)|64*/, +/* 1f28 */ TBL(4)|26, TBL(4)|27, (uint16_t)-1 /*TBL(6)|12*/, (uint16_t)-1 /*TBL(6)|16*/, (uint16_t)-1 /*TBL(6)|13*/, (uint16_t)-1 /*TBL(6)|17*/, (uint16_t)-1 /*TBL(6)|14*/, (uint16_t)-1 /*TBL(6)|18*/, +/* 1f30 */ TBL(4)|75, TBL(4)|76, (uint16_t)-1 /*TBL(6)|70*/, (uint16_t)-1 /*TBL(6)|73*/, (uint16_t)-1 /*TBL(6)|71*/, (uint16_t)-1 /*TBL(6)|74*/, (uint16_t)-1 /*TBL(6)|72*/, (uint16_t)-1 /*TBL(6)|75*/, +/* 1f38 */ TBL(4)|34, TBL(4)|35, (uint16_t)-1 /*TBL(6)|20*/, (uint16_t)-1 /*TBL(6)|23*/, (uint16_t)-1 /*TBL(6)|21*/, (uint16_t)-1 /*TBL(6)|24*/, (uint16_t)-1 /*TBL(6)|22*/, (uint16_t)-1 /*TBL(6)|25*/, +/* 1f40 */ TBL(4)|80, TBL(4)|81, (uint16_t)-1 /*TBL(6)|76*/, (uint16_t)-1 /*TBL(6)|78*/, (uint16_t)-1 /*TBL(6)|77*/, (uint16_t)-1 /*TBL(6)|79*/, 0, 0, +/* 1f48 */ TBL(4)|38, TBL(4)|39, (uint16_t)-1 /*TBL(6)|26*/, (uint16_t)-1 /*TBL(6)|28*/, (uint16_t)-1 /*TBL(6)|27*/, (uint16_t)-1 /*TBL(6)|29*/, 0, 0, +/* 1f50 */ TBL(4)|89, TBL(4)|90, (uint16_t)-1 /*TBL(6)|83*/, (uint16_t)-1 /*TBL(6)|86*/, (uint16_t)-1 /*TBL(6)|84*/, (uint16_t)-1 /*TBL(6)|87*/, (uint16_t)-1 /*TBL(6)|85*/, (uint16_t)-1 /*TBL(6)|88*/, +/* 1f58 */ 0, TBL(4)|46, 0, (uint16_t)-1 /*TBL(6)|30*/, 0, (uint16_t)-1 /*TBL(6)|31*/, 0, (uint16_t)-1 /*TBL(6)|32*/, +/* 1f60 */ TBL(4)|94, TBL(4)|95, (uint16_t)-1 /*TBL(6)|91*/, (uint16_t)-1 /*TBL(6)|95*/, (uint16_t)-1 /*TBL(6)|92*/, (uint16_t)-1 /*TBL(6)|96*/, (uint16_t)-1 /*TBL(6)|93*/, (uint16_t)-1 /*TBL(6)|97*/, +/* 1f68 */ TBL(4)|49, TBL(4)|50, (uint16_t)-1 /*TBL(6)|33*/, (uint16_t)-1 /*TBL(6)|37*/, (uint16_t)-1 /*TBL(6)|34*/, (uint16_t)-1 /*TBL(6)|38*/, (uint16_t)-1 /*TBL(6)|35*/, (uint16_t)-1 /*TBL(6)|39*/, +/* 1f70 */ TBL(4)|52, TBL(4)|53, TBL(4)|60, TBL(4)|61, TBL(4)|64, TBL(4)|65, TBL(4)|70, TBL(4)|71, +/* 1f78 */ TBL(4)|78, TBL(4)|79, TBL(4)|84, TBL(4)|85, TBL(4)|92, TBL(4)|93, 0, 0, +/* 1f80 */ (uint16_t)-1 /*TBL(6)|46*/, (uint16_t)-1 /*TBL(6)|50*/, (uint16_t)-1 /*TBL(8)|18*/, (uint16_t)-1 /*TBL(8)|21*/, (uint16_t)-1 /*TBL(8)|19*/, (uint16_t)-1 /*TBL(8)|22*/, (uint16_t)-1 /*TBL(8)|20*/, (uint16_t)-1 /*TBL(8)|23*/, +/* 1f88 */ (uint16_t)-1 /*TBL(6)|3*/, (uint16_t)-1 /*TBL(6)|7*/, (uint16_t)-1 /*TBL(8)|0*/, (uint16_t)-1 /*TBL(8)|3*/, (uint16_t)-1 /*TBL(8)|1*/, (uint16_t)-1 /*TBL(8)|4*/, (uint16_t)-1 /*TBL(8)|2*/, (uint16_t)-1 /*TBL(8)|5*/, +/* 1f90 */ (uint16_t)-1 /*TBL(6)|61*/, (uint16_t)-1 /*TBL(6)|65*/, (uint16_t)-1 /*TBL(8)|24*/, (uint16_t)-1 /*TBL(8)|27*/, (uint16_t)-1 /*TBL(8)|25*/, (uint16_t)-1 /*TBL(8)|28*/, (uint16_t)-1 /*TBL(8)|26*/, (uint16_t)-1 /*TBL(8)|29*/, +/* 1f98 */ (uint16_t)-1 /*TBL(6)|15*/, (uint16_t)-1 /*TBL(6)|19*/, (uint16_t)-1 /*TBL(8)|6*/, (uint16_t)-1 /*TBL(8)|9*/, (uint16_t)-1 /*TBL(8)|7*/, (uint16_t)-1 /*TBL(8)|10*/, (uint16_t)-1 /*TBL(8)|8*/, (uint16_t)-1 /*TBL(8)|11*/, +/* 1fa0 */ (uint16_t)-1 /*TBL(6)|94*/, (uint16_t)-1 /*TBL(6)|98*/, (uint16_t)-1 /*TBL(8)|30*/, (uint16_t)-1 /*TBL(8)|33*/, (uint16_t)-1 /*TBL(8)|31*/, (uint16_t)-1 /*TBL(8)|34*/, (uint16_t)-1 /*TBL(8)|32*/, (uint16_t)-1 /*TBL(8)|35*/, +/* 1fa8 */ (uint16_t)-1 /*TBL(6)|36*/, (uint16_t)-1 /*TBL(6)|40*/, (uint16_t)-1 /*TBL(8)|12*/, (uint16_t)-1 /*TBL(8)|15*/, (uint16_t)-1 /*TBL(8)|13*/, (uint16_t)-1 /*TBL(8)|16*/, (uint16_t)-1 /*TBL(8)|14*/, (uint16_t)-1 /*TBL(8)|17*/, +/* 1fb0 */ TBL(4)|55, TBL(4)|54, (uint16_t)-1 /*TBL(6)|41*/, TBL(4)|59, (uint16_t)-1 /*TBL(6)|42*/, 0, TBL(4)|58, (uint16_t)-1 /*TBL(6)|51*/, +/* 1fb8 */ TBL(4)|16, TBL(4)|15, TBL(4)|13, TBL(4)|14, TBL(4)|19, 0, TBL(2)|7, 0, +/* 1fc0 */ 0, TBL(4)|2, (uint16_t)-1 /*TBL(6)|56*/, TBL(4)|69, (uint16_t)-1 /*TBL(6)|57*/, 0, TBL(4)|68, (uint16_t)-1 /*TBL(6)|66*/, +/* 1fc8 */ TBL(4)|20, TBL(4)|21, TBL(4)|24, TBL(4)|25, TBL(4)|28, TBL(5)|57, TBL(5)|58, TBL(5)|59, +/* 1fd0 */ TBL(4)|73, TBL(4)|72, (uint16_t)-1 /*TBL(6)|67*/, (uint16_t)-1 /*TBL(6)|68*/, 0, 0, TBL(4)|77, (uint16_t)-1 /*TBL(6)|69*/, +/* 1fd8 */ TBL(4)|32, TBL(4)|31, TBL(4)|29, TBL(4)|30, 0, TBL(5)|60, TBL(5)|61, TBL(5)|62, +/* 1fe0 */ TBL(4)|87, TBL(4)|86, (uint16_t)-1 /*TBL(6)|80*/, (uint16_t)-1 /*TBL(6)|81*/, TBL(4)|82, TBL(4)|83, TBL(4)|91, (uint16_t)-1 /*TBL(6)|82*/, +/* 1fe8 */ TBL(4)|44, TBL(4)|43, TBL(4)|41, TBL(4)|42, TBL(4)|40, TBL(4)|0, TBL(4)|1, TBL(1)|2, +/* 1ff0 */ 0, 0, (uint16_t)-1 /*TBL(6)|89*/, TBL(4)|97, (uint16_t)-1 /*TBL(6)|90*/, 0, TBL(4)|96, (uint16_t)-1 /*TBL(6)|99*/, +/* 1ff8 */ TBL(4)|36, TBL(4)|37, TBL(4)|47, TBL(4)|48, TBL(4)|51, TBL(2)|0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_20 [256] = { +/* 2000 */ TBL(3)|188, TBL(3)|189, 0, 0, 0, 0, 0, 0, +/* 2008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_21 [256] = { +/* 2100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2120 */ 0, 0, 0, 0, 0, 0, TBL(2)|6, 0, +/* 2128 */ 0, 0, TBL(1)|1, TBL(3)|12, 0, 0, 0, 0, +/* 2130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2198 */ 0, 0, TBL(5)|63, TBL(5)|64, 0, 0, 0, 0, +/* 21a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21a8 */ 0, 0, 0, 0, 0, 0, TBL(5)|65, 0, +/* 21b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21c8 */ 0, 0, 0, 0, 0, TBL(5)|66, TBL(5)|68, TBL(5)|67, +/* 21d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_22 [256] = { +/* 2200 */ 0, 0, 0, 0, TBL(5)|69, 0, 0, 0, +/* 2208 */ 0, TBL(5)|70, 0, 0, TBL(5)|71, 0, 0, 0, +/* 2210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2220 */ 0, 0, 0, 0, TBL(5)|72, 0, TBL(5)|73, 0, +/* 2228 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2230 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2240 */ 0, TBL(5)|74, 0, 0, TBL(5)|75, 0, 0, TBL(5)|76, +/* 2248 */ 0, TBL(5)|77, 0, 0, 0, 0, 0, 0, +/* 2250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2260 */ TBL(3)|1, 0, TBL(5)|79, 0, 0, 0, 0, 0, +/* 2268 */ 0, 0, 0, 0, 0, TBL(5)|78, TBL(3)|0, TBL(3)|2, +/* 2270 */ TBL(5)|80, TBL(5)|81, 0, 0, TBL(5)|82, TBL(5)|83, 0, 0, +/* 2278 */ TBL(5)|84, TBL(5)|85, 0, 0, 0, 0, 0, 0, +/* 2280 */ TBL(5)|86, TBL(5)|87, 0, 0, TBL(5)|90, TBL(5)|91, 0, 0, +/* 2288 */ TBL(5)|92, TBL(5)|93, 0, 0, 0, 0, 0, 0, +/* 2290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22a8 */ 0, 0, 0, 0, TBL(5)|96, TBL(5)|97, TBL(5)|98, TBL(5)|99, +/* 22b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22e0 */ TBL(5)|88, TBL(5)|89, TBL(5)|94, TBL(5)|95, 0, 0, 0, 0, +/* 22e8 */ 0, 0, TBL(5)|100, TBL(5)|101, TBL(5)|102, TBL(5)|103, 0, 0, +/* 22f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_23 [256] = { +/* 2300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2328 */ 0, TBL(3)|190, TBL(3)|191, 0, 0, 0, 0, 0, +/* 2330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_2a [256] = { +/* 2a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ad8 */ 0, 0, 0, 0, TBL(5)|104, 0, 0, 0, +/* 2ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_30 [256] = { +/* 3000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3048 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|174*/, 0, (uint16_t)-1 /*TBL(6)|175*/, 0, +/* 3050 */ (uint16_t)-1 /*TBL(6)|176*/, 0, (uint16_t)-1 /*TBL(6)|177*/, 0, (uint16_t)-1 /*TBL(6)|178*/, 0, (uint16_t)-1 /*TBL(6)|179*/, 0, +/* 3058 */ (uint16_t)-1 /*TBL(6)|180*/, 0, (uint16_t)-1 /*TBL(6)|181*/, 0, (uint16_t)-1 /*TBL(6)|182*/, 0, (uint16_t)-1 /*TBL(6)|183*/, 0, +/* 3060 */ (uint16_t)-1 /*TBL(6)|184*/, 0, (uint16_t)-1 /*TBL(6)|185*/, 0, 0, (uint16_t)-1 /*TBL(6)|186*/, 0, (uint16_t)-1 /*TBL(6)|187*/, +/* 3068 */ 0, (uint16_t)-1 /*TBL(6)|188*/, 0, 0, 0, 0, 0, 0, +/* 3070 */ (uint16_t)-1 /*TBL(6)|189*/, (uint16_t)-1 /*TBL(6)|190*/, 0, (uint16_t)-1 /*TBL(6)|191*/, (uint16_t)-1 /*TBL(6)|192*/, 0, (uint16_t)-1 /*TBL(6)|193*/, (uint16_t)-1 /*TBL(6)|194*/, +/* 3078 */ 0, (uint16_t)-1 /*TBL(6)|195*/, (uint16_t)-1 /*TBL(6)|196*/, 0, (uint16_t)-1 /*TBL(6)|197*/, (uint16_t)-1 /*TBL(6)|198*/, 0, 0, +/* 3080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3090 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|173*/, 0, 0, 0, +/* 3098 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|199*/, 0, +/* 30a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30a8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|201*/, 0, (uint16_t)-1 /*TBL(6)|202*/, 0, +/* 30b0 */ (uint16_t)-1 /*TBL(6)|203*/, 0, (uint16_t)-1 /*TBL(6)|204*/, 0, (uint16_t)-1 /*TBL(6)|205*/, 0, (uint16_t)-1 /*TBL(6)|206*/, 0, +/* 30b8 */ (uint16_t)-1 /*TBL(6)|207*/, 0, (uint16_t)-1 /*TBL(6)|208*/, 0, (uint16_t)-1 /*TBL(6)|209*/, 0, (uint16_t)-1 /*TBL(6)|210*/, 0, +/* 30c0 */ (uint16_t)-1 /*TBL(6)|211*/, 0, (uint16_t)-1 /*TBL(6)|212*/, 0, 0, (uint16_t)-1 /*TBL(6)|213*/, 0, (uint16_t)-1 /*TBL(6)|214*/, +/* 30c8 */ 0, (uint16_t)-1 /*TBL(6)|215*/, 0, 0, 0, 0, 0, 0, +/* 30d0 */ (uint16_t)-1 /*TBL(6)|216*/, (uint16_t)-1 /*TBL(6)|217*/, 0, (uint16_t)-1 /*TBL(6)|218*/, (uint16_t)-1 /*TBL(6)|219*/, 0, (uint16_t)-1 /*TBL(6)|220*/, (uint16_t)-1 /*TBL(6)|221*/, +/* 30d8 */ 0, (uint16_t)-1 /*TBL(6)|222*/, (uint16_t)-1 /*TBL(6)|223*/, 0, (uint16_t)-1 /*TBL(6)|224*/, (uint16_t)-1 /*TBL(6)|225*/, 0, 0, +/* 30e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30f0 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|200*/, 0, 0, (uint16_t)-1 /*TBL(6)|226*/, +/* 30f8 */ (uint16_t)-1 /*TBL(6)|227*/, (uint16_t)-1 /*TBL(6)|228*/, (uint16_t)-1 /*TBL(6)|229*/, 0, 0, 0, (uint16_t)-1 /*TBL(6)|230*/, 0 +}; + +static const uint16_t UN8IF_canon_00_f9 [256] = { +/* f900 */ TBL(3)|868, TBL(3)|543, TBL(3)|882, TBL(3)|873, TBL(3)|613, TBL(3)|261, TBL(3)|344, TBL(3)|983, +/* f908 */ TBL(3)|983, TBL(3)|400, TBL(3)|909, TBL(3)|363, TBL(3)|399, TBL(3)|494, TBL(3)|682, TBL(3)|759, +/* f910 */ TBL(3)|821, TBL(3)|834, TBL(3)|846, TBL(3)|896, TBL(3)|569, TBL(3)|592, TBL(3)|632, TBL(3)|658, +/* f918 */ TBL(3)|807, TBL(3)|904, TBL(3)|957, TBL(3)|266, TBL(3)|338, TBL(3)|574, TBL(3)|640, TBL(3)|820, +/* f920 */ TBL(3)|968, TBL(3)|433, TBL(3)|620, TBL(3)|816, TBL(3)|850, TBL(3)|502, TBL(3)|776, TBL(3)|837, +/* f928 */ TBL(3)|451, TBL(3)|546, TBL(3)|598, TBL(3)|650, TBL(3)|898, TBL(3)|274, TBL(3)|304, TBL(3)|326, +/* f930 */ TBL(3)|526, TBL(3)|572, TBL(3)|639, TBL(3)|685, TBL(3)|764, TBL(3)|818, TBL(3)|823, TBL(3)|880, +/* f938 */ TBL(3)|939, TBL(3)|961, TBL(3)|967, TBL(3)|696, TBL(3)|711, TBL(3)|746, TBL(3)|800, TBL(3)|916, +/* f940 */ TBL(3)|969, TBL(3)|859, TBL(3)|391, TBL(3)|457, TBL(3)|731, TBL(3)|770, TBL(3)|645, TBL(3)|698, +/* f948 */ TBL(3)|872, TBL(3)|937, TBL(3)|390, TBL(3)|425, TBL(3)|570, TBL(3)|603, TBL(3)|615, TBL(3)|743, +/* f950 */ TBL(3)|752, TBL(3)|924, TBL(3)|325, TBL(3)|771, TBL(3)|307, TBL(3)|306, TBL(3)|718, TBL(3)|747, +/* f958 */ TBL(3)|806, TBL(3)|926, TBL(3)|866, TBL(3)|503, TBL(3)|569, TBL(3)|862, TBL(3)|263, TBL(3)|417, +/* f960 */ TBL(3)|471, TBL(3)|654, TBL(3)|676, TBL(3)|332, TBL(3)|700, TBL(3)|278, TBL(3)|465, TBL(3)|259, +/* f968 */ TBL(3)|588, TBL(3)|530, TBL(3)|742, TBL(3)|341, TBL(3)|386, TBL(3)|687, TBL(3)|808, TBL(3)|855, +/* f970 */ TBL(3)|582, TBL(3)|890, TBL(3)|586, TBL(3)|507, TBL(3)|790, TBL(3)|513, TBL(3)|675, TBL(3)|268, +/* f978 */ TBL(3)|293, TBL(3)|305, TBL(3)|561, TBL(3)|738, TBL(3)|782, TBL(3)|858, TBL(3)|908, TBL(3)|328, +/* f980 */ TBL(3)|351, TBL(3)|403, TBL(3)|455, TBL(3)|532, TBL(3)|621, TBL(3)|701, TBL(3)|921, TBL(3)|959, +/* f988 */ TBL(3)|970, TBL(3)|973, TBL(3)|320, TBL(3)|542, TBL(3)|578, TBL(3)|888, TBL(3)|445, TBL(3)|488, +/* f990 */ TBL(3)|495, TBL(3)|524, TBL(3)|617, TBL(3)|634, TBL(3)|667, TBL(3)|716, TBL(3)|749, TBL(3)|768, +/* f998 */ TBL(3)|884, TBL(3)|810, TBL(3)|892, TBL(3)|917, TBL(3)|312, TBL(3)|321, TBL(3)|356, TBL(3)|631, +/* f9a0 */ TBL(3)|841, TBL(3)|855, TBL(3)|450, TBL(3)|469, TBL(3)|511, TBL(3)|581, TBL(3)|730, TBL(3)|652, +/* f9a8 */ TBL(3)|271, TBL(3)|375, TBL(3)|417, TBL(3)|438, TBL(3)|472, TBL(3)|657, TBL(3)|664, TBL(3)|761, +/* f9b0 */ TBL(3)|766, TBL(3)|910, TBL(3)|936, TBL(3)|940, TBL(3)|946, TBL(3)|275, TBL(3)|715, TBL(3)|906, +/* f9b8 */ TBL(3)|932, TBL(3)|478, TBL(3)|267, TBL(3)|284, TBL(3)|418, TBL(3)|423, TBL(3)|531, TBL(3)|569, +/* f9c0 */ TBL(3)|637, TBL(3)|681, TBL(3)|813, TBL(3)|895, TBL(3)|981, TBL(3)|538, TBL(3)|923, TBL(3)|319, +/* f9c8 */ TBL(3)|553, TBL(3)|556, TBL(3)|596, TBL(3)|609, TBL(3)|660, TBL(3)|674, TBL(3)|695, TBL(3)|741, +/* f9d0 */ TBL(3)|949, TBL(3)|294, TBL(3)|498, TBL(3)|927, TBL(3)|280, TBL(3)|431, TBL(3)|604, TBL(3)|885, +/* f9d8 */ TBL(3)|463, TBL(3)|480, TBL(3)|558, TBL(3)|654, TBL(3)|929, TBL(3)|313, TBL(3)|348, TBL(3)|427, +/* f9e0 */ TBL(3)|535, TBL(3)|549, TBL(3)|564, TBL(3)|590, TBL(3)|659, TBL(3)|677, TBL(3)|757, TBL(3)|842, +/* f9e8 */ TBL(3)|845, TBL(3)|907, TBL(3)|934, TBL(3)|333, TBL(3)|610, TBL(3)|349, TBL(3)|638, TBL(3)|668, +/* f9f0 */ TBL(3)|817, TBL(3)|930, TBL(3)|963, TBL(3)|971, TBL(3)|555, TBL(3)|602, TBL(3)|777, TBL(3)|724, +/* f9f8 */ TBL(3)|726, TBL(3)|733, TBL(3)|649, TBL(3)|629, TBL(3)|865, TBL(3)|269, TBL(3)|794, TBL(3)|314 +}; + +static const uint16_t UN8IF_canon_00_fa [256] = { +/* fa00 */ TBL(3)|311, TBL(3)|446, TBL(3)|504, TBL(3)|736, TBL(3)|414, TBL(3)|593, TBL(3)|541, TBL(3)|887, +/* fa08 */ TBL(3)|838, TBL(3)|925, TBL(3)|852, TBL(3)|453, TBL(3)|286, TBL(3)|368, 0, 0, +/* fa10 */ TBL(3)|385, 0, TBL(3)|537, 0, 0, TBL(3)|308, TBL(3)|651, TBL(3)|683, +/* fa18 */ TBL(3)|702, TBL(3)|709, TBL(3)|710, TBL(3)|714, TBL(3)|941, TBL(3)|734, TBL(3)|762, 0, +/* fa20 */ TBL(3)|819, 0, TBL(3)|861, 0, 0, TBL(3)|893, TBL(3)|901, 0, +/* fa28 */ 0, 0, TBL(3)|951, TBL(3)|952, TBL(3)|953, TBL(3)|966, TBL(3)|899, TBL(3)|931, +/* fa30 */ TBL(3)|276, TBL(3)|285, TBL(3)|288, TBL(3)|324, TBL(3)|327, TBL(3)|335, TBL(3)|365, TBL(3)|371, +/* fa38 */ TBL(3)|373, TBL(3)|384, TBL(3)|387, TBL(3)|426, TBL(3)|428, TBL(3)|475, TBL(3)|485, TBL(3)|487, +/* fa40 */ TBL(3)|493, TBL(3)|527, TBL(3)|533, TBL(3)|539, TBL(3)|562, TBL(3)|599, TBL(3)|606, TBL(3)|616, +/* fa48 */ TBL(3)|635, TBL(3)|642, TBL(3)|661, TBL(3)|697, TBL(3)|703, TBL(3)|705, TBL(3)|704, TBL(3)|706, +/* fa50 */ TBL(3)|707, TBL(3)|708, TBL(3)|712, TBL(3)|713, TBL(3)|719, TBL(3)|722, TBL(3)|727, TBL(3)|749, +/* fa58 */ TBL(3)|751, TBL(3)|753, TBL(3)|756, TBL(3)|765, TBL(3)|778, TBL(3)|783, TBL(3)|783, TBL(3)|809, +/* fa60 */ TBL(3)|848, TBL(3)|853, TBL(3)|863, TBL(3)|864, TBL(3)|874, TBL(3)|875, TBL(3)|891, TBL(3)|893, +/* fa68 */ TBL(3)|935, TBL(3)|944, TBL(3)|948, TBL(3)|473, TBL(4)|235, TBL(3)|781, 0, 0, +/* fa70 */ TBL(3)|260, TBL(3)|303, TBL(3)|292, TBL(3)|273, TBL(3)|287, TBL(3)|296, TBL(3)|323, TBL(3)|329, +/* fa78 */ TBL(3)|365, TBL(3)|360, TBL(3)|364, TBL(3)|370, TBL(3)|385, TBL(3)|389, TBL(3)|398, TBL(3)|401, +/* fa80 */ TBL(3)|408, TBL(3)|412, TBL(3)|452, TBL(3)|454, TBL(3)|461, TBL(3)|466, TBL(3)|477, TBL(3)|483, +/* fa88 */ TBL(3)|479, TBL(3)|487, TBL(3)|484, TBL(3)|493, TBL(3)|499, TBL(3)|515, TBL(3)|518, TBL(3)|520, +/* fa90 */ TBL(3)|528, TBL(3)|537, TBL(3)|546, TBL(3)|547, TBL(3)|551, TBL(3)|579, TBL(3)|582, TBL(3)|596, +/* fa98 */ TBL(3)|614, TBL(3)|612, TBL(3)|616, TBL(3)|623, TBL(3)|635, TBL(3)|693, TBL(3)|643, TBL(3)|648, +/* faa0 */ TBL(3)|651, TBL(3)|665, TBL(3)|670, TBL(3)|672, TBL(3)|679, TBL(3)|680, TBL(3)|683, TBL(3)|684, +/* faa8 */ TBL(3)|686, TBL(3)|691, TBL(3)|690, TBL(3)|699, TBL(3)|723, TBL(3)|727, TBL(3)|732, TBL(3)|744, +/* fab0 */ TBL(3)|749, TBL(3)|755, TBL(3)|765, TBL(3)|795, TBL(3)|805, TBL(3)|832, TBL(3)|849, TBL(3)|851, +/* fab8 */ TBL(3)|853, TBL(3)|856, TBL(3)|861, TBL(3)|857, TBL(3)|863, TBL(3)|862, TBL(3)|860, TBL(3)|864, +/* fac0 */ TBL(3)|867, TBL(3)|875, TBL(3)|886, TBL(3)|894, TBL(3)|905, TBL(3)|912, TBL(3)|928, TBL(3)|935, +/* fac8 */ TBL(3)|941, TBL(3)|942, TBL(3)|944, TBL(3)|945, TBL(3)|948, TBL(3)|960, TBL(3)|983, TBL(4)|214, +/* fad0 */ TBL(4)|213, TBL(4)|223, TBL(3)|213, TBL(3)|223, TBL(3)|224, TBL(4)|249, TBL(4)|258, TBL(4)|282, +/* fad8 */ TBL(3)|980, TBL(3)|982, 0, 0, 0, 0, 0, 0, +/* fae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* faf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* faf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_00_fb [256] = { +/* fb00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb18 */ 0, 0, 0, 0, 0, TBL(4)|164, 0, TBL(4)|183, +/* fb20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb28 */ 0, 0, TBL(4)|180, TBL(4)|181, (uint16_t)-1 /*TBL(6)|100*/, (uint16_t)-1 /*TBL(6)|101*/, TBL(4)|152, TBL(4)|153, +/* fb30 */ TBL(4)|154, TBL(4)|155, TBL(4)|157, TBL(4)|158, TBL(4)|159, TBL(4)|161, TBL(4)|162, 0, +/* fb38 */ TBL(4)|163, TBL(4)|165, TBL(4)|166, TBL(4)|167, TBL(4)|169, 0, TBL(4)|170, 0, +/* fb40 */ TBL(4)|171, TBL(4)|172, 0, TBL(4)|173, TBL(4)|174, 0, TBL(4)|176, TBL(4)|177, +/* fb48 */ TBL(4)|178, TBL(4)|179, TBL(4)|182, TBL(4)|160, TBL(4)|156, TBL(4)|168, TBL(4)|175, 0, +/* fb50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_10 [256] = { +/* 011000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011098 */ 0, 0, (uint16_t)-1 /*TBL(8)|36*/, 0, (uint16_t)-1 /*TBL(8)|37*/, 0, 0, 0, +/* 0110a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110a8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|38*/, 0, 0, 0, 0, +/* 0110b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_11 [256] = { +/* 011100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011128 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(8)|39*/, (uint16_t)-1 /*TBL(8)|40*/, +/* 011130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_13 [256] = { +/* 011300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011348 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|41*/, (uint16_t)-1 /*TBL(8)|42*/, 0, 0, 0, +/* 011350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_14 [256] = { +/* 011400 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011408 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011418 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011438 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011450 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011458 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011470 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011480 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|44*/, (uint16_t)-1 /*TBL(8)|43*/, 0, (uint16_t)-1 /*TBL(8)|45*/, 0, +/* 0114c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_15 [256] = { +/* 011500 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011508 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011510 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011518 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011520 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011528 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011530 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011538 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011540 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011548 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011550 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011558 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011560 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011568 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011570 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011578 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011580 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011588 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011590 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011598 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b8 */ 0, 0, (uint16_t)-1 /*TBL(8)|46*/, (uint16_t)-1 /*TBL(8)|47*/, 0, 0, 0, 0, +/* 0115c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_19 [256] = { +/* 011900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011938 */ (uint16_t)-1 /*TBL(8)|48*/, 0, 0, 0, 0, 0, 0, 0, +/* 011940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_01_d1 [256] = { +/* 01d100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d158 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(8)|49*/, (uint16_t)-1 /*TBL(8)|50*/, +/* 01d160 */ (uint16_t)-1 /*TBL(12)|0*/, (uint16_t)-1 /*TBL(12)|1*/, (uint16_t)-1 /*TBL(12)|2*/, (uint16_t)-1 /*TBL(12)|3*/, (uint16_t)-1 /*TBL(12)|4*/, 0, 0, 0, +/* 01d168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1b8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|51*/, (uint16_t)-1 /*TBL(8)|52*/, (uint16_t)-1 /*TBL(12)|5*/, (uint16_t)-1 /*TBL(12)|7*/, (uint16_t)-1 /*TBL(12)|6*/, +/* 01d1c0 */ (uint16_t)-1 /*TBL(12)|8*/, 0, 0, 0, 0, 0, 0, 0, +/* 01d1c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_canon_02_f8 [256] = { +/* 02f800 */ TBL(3)|264, TBL(3)|262, TBL(3)|265, TBL(4)|192, TBL(3)|272, TBL(3)|276, TBL(3)|277, TBL(3)|279, +/* 02f808 */ TBL(3)|281, TBL(3)|282, TBL(3)|285, TBL(3)|283, TBL(3)|192, TBL(4)|196, TBL(3)|288, TBL(3)|289, +/* 02f810 */ TBL(3)|290, TBL(3)|295, TBL(4)|193, TBL(3)|193, TBL(3)|291, TBL(3)|297, TBL(4)|195, TBL(3)|300, +/* 02f818 */ TBL(3)|301, TBL(3)|270, TBL(3)|302, TBL(3)|303, TBL(4)|290, TBL(3)|309, TBL(3)|310, TBL(3)|195, +/* 02f820 */ TBL(3)|315, TBL(3)|316, TBL(3)|317, TBL(3)|318, TBL(3)|196, TBL(3)|323, TBL(3)|324, TBL(3)|327, +/* 02f828 */ TBL(3)|329, TBL(3)|330, TBL(3)|331, TBL(3)|332, TBL(3)|334, TBL(3)|335, TBL(3)|336, TBL(3)|337, +/* 02f830 */ TBL(3)|339, TBL(3)|340, TBL(3)|340, TBL(3)|340, TBL(4)|199, TBL(3)|626, TBL(3)|342, TBL(3)|343, +/* 02f838 */ TBL(4)|200, TBL(3)|345, TBL(3)|346, TBL(3)|347, TBL(3)|354, TBL(3)|350, TBL(3)|352, TBL(3)|353, +/* 02f840 */ TBL(3)|355, TBL(3)|357, TBL(3)|358, TBL(3)|359, TBL(3)|361, TBL(3)|362, TBL(3)|362, TBL(3)|364, +/* 02f848 */ TBL(3)|366, TBL(3)|367, TBL(3)|369, TBL(3)|376, TBL(3)|371, TBL(3)|377, TBL(3)|372, TBL(3)|374, +/* 02f850 */ TBL(3)|311, TBL(3)|392, TBL(3)|379, TBL(3)|380, TBL(3)|381, TBL(3)|378, TBL(3)|383, TBL(3)|382, +/* 02f858 */ TBL(3)|388, TBL(4)|201, TBL(3)|393, TBL(3)|394, TBL(3)|395, TBL(3)|396, TBL(3)|397, TBL(3)|402, +/* 02f860 */ TBL(4)|202, TBL(4)|203, TBL(3)|405, TBL(3)|406, TBL(3)|407, TBL(3)|404, TBL(3)|409, TBL(3)|197, +/* 02f868 */ TBL(3)|198, TBL(3)|411, TBL(3)|413, TBL(3)|413, TBL(4)|204, TBL(3)|415, TBL(3)|416, TBL(3)|417, +/* 02f870 */ TBL(3)|419, TBL(4)|205, TBL(3)|420, TBL(3)|421, TBL(3)|459, TBL(3)|422, TBL(3)|199, TBL(3)|424, +/* 02f878 */ TBL(3)|428, TBL(3)|430, TBL(3)|429, TBL(4)|207, TBL(3)|432, TBL(4)|208, TBL(3)|435, TBL(3)|434, +/* 02f880 */ TBL(3)|436, TBL(3)|439, TBL(3)|440, TBL(3)|200, TBL(3)|441, TBL(3)|442, TBL(3)|443, TBL(3)|444, +/* 02f888 */ TBL(3)|201, TBL(4)|209, TBL(3)|202, TBL(3)|447, TBL(3)|448, TBL(3)|449, TBL(3)|451, TBL(4)|300, +/* 02f890 */ TBL(3)|456, TBL(4)|211, TBL(4)|211, TBL(3)|779, TBL(3)|458, TBL(3)|458, TBL(3)|203, TBL(4)|218, +/* 02f898 */ TBL(4)|260, TBL(3)|460, TBL(3)|462, TBL(3)|204, TBL(3)|464, TBL(3)|467, TBL(3)|468, TBL(3)|470, +/* 02f8a0 */ TBL(3)|474, TBL(3)|206, TBL(3)|205, TBL(3)|475, TBL(4)|212, TBL(3)|476, TBL(3)|481, TBL(3)|482, +/* 02f8a8 */ TBL(3)|483, TBL(3)|482, TBL(3)|486, TBL(3)|487, TBL(3)|491, TBL(3)|489, TBL(3)|490, TBL(3)|492, +/* 02f8b0 */ TBL(3)|493, TBL(3)|494, TBL(3)|496, TBL(3)|497, TBL(3)|500, TBL(3)|501, TBL(3)|505, TBL(3)|509, +/* 02f8b8 */ TBL(4)|215, TBL(3)|508, TBL(3)|506, TBL(3)|510, TBL(3)|512, TBL(3)|517, TBL(4)|216, TBL(3)|519, +/* 02f8c0 */ TBL(3)|516, TBL(3)|514, TBL(3)|207, TBL(3)|521, TBL(3)|523, TBL(3)|525, TBL(3)|522, TBL(3)|208, +/* 02f8c8 */ TBL(3)|527, TBL(3)|529, TBL(4)|217, TBL(3)|534, TBL(3)|544, TBL(3)|536, TBL(3)|211, TBL(3)|539, +/* 02f8d0 */ TBL(3)|210, TBL(3)|209, TBL(3)|298, TBL(3)|299, TBL(3)|545, TBL(3)|540, TBL(3)|772, TBL(3)|236, +/* 02f8d8 */ TBL(3)|546, TBL(3)|547, TBL(3)|548, TBL(3)|552, TBL(3)|550, TBL(4)|222, TBL(3)|212, TBL(3)|557, +/* 02f8e0 */ TBL(3)|554, TBL(3)|560, TBL(3)|562, TBL(4)|224, TBL(3)|563, TBL(3)|559, TBL(3)|565, TBL(3)|213, +/* 02f8e8 */ TBL(3)|566, TBL(3)|567, TBL(3)|568, TBL(3)|571, TBL(4)|225, TBL(3)|573, TBL(3)|214, TBL(3)|575, +/* 02f8f0 */ TBL(4)|226, TBL(3)|576, TBL(3)|215, TBL(3)|577, TBL(3)|580, TBL(3)|582, TBL(3)|583, TBL(4)|227, +/* 02f8f8 */ TBL(4)|206, TBL(4)|228, TBL(3)|584, TBL(4)|229, TBL(3)|587, TBL(3)|589, TBL(3)|585, TBL(3)|591 +}; + +static const uint16_t UN8IF_canon_02_f9 [256] = { +/* 02f900 */ TBL(3)|595, TBL(3)|599, TBL(3)|596, TBL(3)|597, TBL(3)|600, TBL(3)|601, TBL(4)|230, TBL(3)|594, +/* 02f908 */ TBL(3)|607, TBL(3)|608, TBL(3)|216, TBL(3)|612, TBL(3)|611, TBL(4)|231, TBL(3)|605, TBL(3)|618, +/* 02f910 */ TBL(4)|232, TBL(4)|233, TBL(3)|619, TBL(3)|624, TBL(3)|623, TBL(3)|622, TBL(3)|217, TBL(3)|625, +/* 02f918 */ TBL(3)|628, TBL(3)|627, TBL(3)|630, TBL(4)|194, TBL(3)|633, TBL(4)|234, TBL(3)|636, TBL(4)|236, +/* 02f920 */ TBL(3)|641, TBL(3)|643, TBL(3)|644, TBL(4)|237, TBL(3)|646, TBL(3)|647, TBL(4)|238, TBL(4)|239, +/* 02f928 */ TBL(3)|653, TBL(3)|655, TBL(3)|218, TBL(3)|656, TBL(3)|219, TBL(3)|219, TBL(3)|662, TBL(3)|663, +/* 02f930 */ TBL(3)|665, TBL(3)|666, TBL(3)|669, TBL(3)|220, TBL(3)|671, TBL(4)|240, TBL(3)|673, TBL(4)|241, +/* 02f938 */ TBL(3)|676, TBL(4)|210, TBL(3)|678, TBL(4)|242, TBL(4)|243, TBL(4)|244, TBL(3)|221, TBL(3)|222, +/* 02f940 */ TBL(3)|686, TBL(4)|246, TBL(4)|245, TBL(4)|247, TBL(4)|248, TBL(3)|688, TBL(3)|689, TBL(3)|689, +/* 02f948 */ TBL(3)|691, TBL(3)|224, TBL(3)|692, TBL(3)|225, TBL(3)|226, TBL(4)|250, TBL(3)|694, TBL(3)|696, +/* 02f950 */ TBL(3)|699, TBL(3)|227, TBL(4)|251, TBL(3)|707, TBL(4)|252, TBL(4)|253, TBL(3)|714, TBL(3)|717, +/* 02f958 */ TBL(3)|228, TBL(3)|719, TBL(3)|720, TBL(3)|721, TBL(4)|254, TBL(4)|255, TBL(4)|255, TBL(3)|725, +/* 02f960 */ TBL(3)|229, TBL(4)|256, TBL(3)|728, TBL(3)|729, TBL(3)|230, TBL(4)|257, TBL(3)|735, TBL(3)|231, +/* 02f968 */ TBL(3)|739, TBL(3)|737, TBL(3)|740, TBL(4)|259, TBL(3)|745, TBL(3)|232, TBL(3)|748, TBL(3)|750, +/* 02f970 */ TBL(3)|754, TBL(3)|233, TBL(4)|261, TBL(4)|262, TBL(3)|234, TBL(4)|263, TBL(3)|758, TBL(4)|264, +/* 02f978 */ TBL(3)|760, TBL(3)|763, TBL(3)|765, TBL(4)|265, TBL(4)|266, TBL(3)|767, TBL(4)|267, TBL(3)|769, +/* 02f980 */ TBL(4)|219, TBL(3)|235, TBL(3)|773, TBL(3)|774, TBL(3)|237, TBL(3)|775, TBL(3)|410, TBL(4)|268, +/* 02f988 */ TBL(4)|269, TBL(4)|220, TBL(4)|221, TBL(3)|779, TBL(3)|780, TBL(3)|889, TBL(3)|238, TBL(3)|785, +/* 02f990 */ TBL(3)|784, TBL(3)|786, TBL(3)|322, TBL(3)|787, TBL(3)|788, TBL(3)|789, TBL(3)|791, TBL(4)|270, +/* 02f998 */ TBL(3)|790, TBL(3)|792, TBL(3)|797, TBL(3)|798, TBL(3)|793, TBL(3)|799, TBL(3)|804, TBL(3)|809, +/* 02f9a0 */ TBL(3)|796, TBL(3)|801, TBL(3)|802, TBL(3)|803, TBL(4)|271, TBL(4)|273, TBL(4)|272, TBL(3)|239, +/* 02f9a8 */ TBL(3)|811, TBL(3)|812, TBL(3)|814, TBL(4)|277, TBL(3)|815, TBL(4)|274, TBL(3)|240, TBL(3)|241, +/* 02f9b0 */ TBL(4)|275, TBL(4)|276, TBL(3)|242, TBL(3)|822, TBL(3)|823, TBL(3)|824, TBL(3)|825, TBL(3)|827, +/* 02f9b8 */ TBL(3)|826, TBL(3)|829, TBL(3)|828, TBL(3)|832, TBL(3)|830, TBL(3)|831, TBL(3)|833, TBL(3)|243, +/* 02f9c0 */ TBL(3)|835, TBL(3)|836, TBL(3)|244, TBL(3)|839, TBL(3)|840, TBL(4)|278, TBL(3)|843, TBL(3)|844, +/* 02f9c8 */ TBL(3)|245, TBL(3)|847, TBL(3)|194, TBL(4)|279, TBL(4)|280, TBL(3)|246, TBL(3)|247, TBL(3)|854, +/* 02f9d0 */ TBL(3)|860, TBL(3)|867, TBL(3)|869, TBL(4)|281, TBL(3)|870, TBL(3)|871, TBL(3)|876, TBL(3)|877, +/* 02f9d8 */ TBL(4)|283, TBL(4)|197, TBL(3)|879, TBL(3)|878, TBL(3)|881, TBL(4)|198, TBL(3)|883, TBL(3)|886, +/* 02f9e0 */ TBL(4)|284, TBL(4)|285, TBL(3)|897, TBL(3)|900, TBL(3)|902, TBL(4)|286, TBL(3)|903, TBL(3)|911, +/* 02f9e8 */ TBL(3)|914, TBL(3)|915, TBL(3)|913, TBL(3)|918, TBL(3)|919, TBL(4)|287, TBL(3)|920, TBL(3)|248, +/* 02f9f0 */ TBL(3)|922, TBL(4)|288, TBL(3)|249, TBL(3)|933, TBL(3)|437, TBL(3)|938, TBL(4)|289, TBL(4)|291, +/* 02f9f8 */ TBL(3)|250, TBL(3)|251, TBL(3)|943, TBL(4)|292, TBL(3)|252, TBL(4)|293, TBL(3)|945, TBL(3)|945 +}; + +static const uint16_t UN8IF_canon_02_fa [256] = { +/* 02fa00 */ TBL(3)|947, TBL(4)|294, TBL(3)|950, TBL(3)|253, TBL(3)|954, TBL(3)|955, TBL(3)|956, TBL(3)|958, +/* 02fa08 */ TBL(3)|254, TBL(4)|295, TBL(3)|960, TBL(3)|962, TBL(3)|964, TBL(3)|255, TBL(3)|256, TBL(3)|965, +/* 02fa10 */ TBL(4)|296, TBL(3)|257, TBL(4)|297, TBL(4)|298, TBL(4)|299, TBL(3)|972, TBL(3)|258, TBL(3)|974, +/* 02fa18 */ TBL(3)|975, TBL(3)|976, TBL(3)|977, TBL(3)|978, TBL(3)|979, TBL(4)|301, 0, 0, +/* 02fa20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* the planes */ +static const uint16_t* UN8IF_canon_00 [256] = { +UN8IF_canon_00_00, +UN8IF_canon_00_01, +UN8IF_canon_00_02, +UN8IF_canon_00_03, +UN8IF_canon_00_04, +NULL,UN8IF_canon_00_06, +NULL, +NULL,UN8IF_canon_00_09, +UN8IF_canon_00_0a, +UN8IF_canon_00_0b, +UN8IF_canon_00_0c, +UN8IF_canon_00_0d, +NULL,UN8IF_canon_00_0f, +UN8IF_canon_00_10, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_canon_00_1b, +NULL,NULL,UN8IF_canon_00_1e, +UN8IF_canon_00_1f, +UN8IF_canon_00_20, +UN8IF_canon_00_21, +UN8IF_canon_00_22, +UN8IF_canon_00_23, +NULL,NULL,NULL,NULL, +NULL,NULL,UN8IF_canon_00_2a, +NULL,NULL,NULL,NULL,NULL, +UN8IF_canon_00_30, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_canon_00_f9, +UN8IF_canon_00_fa, +UN8IF_canon_00_fb, +NULL,NULL,NULL,NULL +}; + +static const uint16_t* UN8IF_canon_01 [256] = { +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_canon_01_10, +UN8IF_canon_01_11, +NULL,UN8IF_canon_01_13, +UN8IF_canon_01_14, +UN8IF_canon_01_15, +NULL,NULL, +NULL,UN8IF_canon_01_19, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_canon_01_d1, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL +}; + +static const uint16_t* UN8IF_canon_02 [256] = { +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_canon_02_f8, +UN8IF_canon_02_f9, +UN8IF_canon_02_fa, +NULL,NULL,NULL,NULL,NULL +}; + +/* the main plane */ +#undef TBL +static const uint16_t** UN8IF_canon [] = { +UN8IF_canon_00, +UN8IF_canon_01, +UN8IF_canon_02, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL +}; + diff --git a/src/extu8/un8ifcmb.h b/src/extu8/un8ifcmb.h new file mode 100644 index 000000000..cefe67516 --- /dev/null +++ b/src/extu8/un8ifcmb.h @@ -0,0 +1,2399 @@ +/* ex: set ro ft=c: -*- buffer-read-only: t -*- + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is auto-generated by Unicode-Normalize 1.27 + * mkheader -ind -std + * for Unicode 13.0.0 UTF-8 + * Any changes here will be lost! + */ +/* CombiningClass */ +/* the rows */ +static const STDCHAR UN8IF_combin_00_03 [256] = { +/* 0300 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0308 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0310 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)232, (STDCHAR)220, (STDCHAR)220, +/* 0318 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)232, (STDCHAR)216, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 0320 */ (STDCHAR)220, (STDCHAR)202, (STDCHAR)202, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)202, +/* 0328 */ (STDCHAR)202, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 0330 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, +/* 0338 */ (STDCHAR)1, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0340 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)240, (STDCHAR)230, (STDCHAR)220, +/* 0348 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, 0, +/* 0350 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, +/* 0358 */ (STDCHAR)232, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)233, (STDCHAR)234, (STDCHAR)234, (STDCHAR)233, +/* 0360 */ (STDCHAR)234, (STDCHAR)234, (STDCHAR)233, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0368 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_04 [256] = { +/* 0400 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0408 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0418 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0438 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0450 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0458 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0470 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0480 */ 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_05 [256] = { +/* 0500 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0508 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0510 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0518 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0520 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0528 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0530 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0538 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0540 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0548 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0550 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0558 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0560 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0568 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0570 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0578 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0580 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0588 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0590 */ 0, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, +/* 0598 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)222, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 05a0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 05a8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)222, (STDCHAR)228, (STDCHAR)230, +/* 05b0 */ (STDCHAR)10, (STDCHAR)11, (STDCHAR)12, (STDCHAR)13, (STDCHAR)14, (STDCHAR)15, (STDCHAR)16, (STDCHAR)17, +/* 05b8 */ (STDCHAR)18, (STDCHAR)19, (STDCHAR)19, (STDCHAR)20, (STDCHAR)21, (STDCHAR)22, 0, (STDCHAR)23, +/* 05c0 */ 0, (STDCHAR)24, (STDCHAR)25, 0, (STDCHAR)230, (STDCHAR)220, 0, (STDCHAR)18, +/* 05c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_06 [256] = { +/* 0600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0610 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0618 */ (STDCHAR)30, (STDCHAR)31, (STDCHAR)32, 0, 0, 0, 0, 0, +/* 0620 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0638 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0648 */ 0, 0, 0, (STDCHAR)27, (STDCHAR)28, (STDCHAR)29, (STDCHAR)30, (STDCHAR)31, +/* 0650 */ (STDCHAR)32, (STDCHAR)33, (STDCHAR)34, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, +/* 0658 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, +/* 0660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0668 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0670 */ (STDCHAR)35, 0, 0, 0, 0, 0, 0, 0, +/* 0678 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0698 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06d0 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* 06d8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, (STDCHAR)230, +/* 06e0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, 0, 0, (STDCHAR)230, +/* 06e8 */ (STDCHAR)230, 0, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, 0, 0, +/* 06f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_07 [256] = { +/* 0700 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0708 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0710 */ 0, (STDCHAR)36, 0, 0, 0, 0, 0, 0, +/* 0718 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0720 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0728 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0730 */ (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, +/* 0738 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, +/* 0740 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, +/* 0748 */ (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, +/* 0750 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0758 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0760 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0768 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0770 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0778 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0780 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0788 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0790 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0798 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 07e8 */ 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 07f0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, 0, 0, 0, 0, +/* 07f8 */ 0, 0, 0, 0, 0, (STDCHAR)220, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_08 [256] = { +/* 0800 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0808 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0810 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* 0818 */ (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0820 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 0828 */ 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, +/* 0830 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0838 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0840 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0848 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0850 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0858 */ 0, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, 0, 0, 0, 0, +/* 0860 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0868 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0870 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0878 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0880 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0888 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0890 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0898 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 08d0 */ 0, 0, 0, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 08d8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 08e0 */ (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, +/* 08e8 */ (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 08f0 */ (STDCHAR)27, (STDCHAR)28, (STDCHAR)29, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, +/* 08f8 */ (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230 +}; + +static const STDCHAR UN8IF_combin_00_09 [256] = { +/* 0900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0938 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 0940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0948 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0950 */ 0, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 0958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b8 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 09c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09c8 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 09d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f8 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, 0 +}; + +static const STDCHAR UN8IF_combin_00_0a [256] = { +/* 0a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a38 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 0a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a48 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab8 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 0ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ac8 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_0b [256] = { +/* 0b00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b38 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 0b40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b48 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc8 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_0c [256] = { +/* 0c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c48 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0c50 */ 0, 0, 0, 0, 0, (STDCHAR)84, (STDCHAR)91, 0, +/* 0c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb8 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 0cc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cc8 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_0d [256] = { +/* 0d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d38 */ 0, 0, 0, (STDCHAR)9, (STDCHAR)9, 0, 0, 0, +/* 0d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d48 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 0d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc8 */ 0, 0, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 0dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_0e [256] = { +/* 0e00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e38 */ (STDCHAR)103, (STDCHAR)103, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 0e40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e48 */ (STDCHAR)107, (STDCHAR)107, (STDCHAR)107, (STDCHAR)107, 0, 0, 0, 0, +/* 0e50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ea0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ea8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0eb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0eb8 */ (STDCHAR)118, (STDCHAR)118, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 0ec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ec8 */ (STDCHAR)122, (STDCHAR)122, (STDCHAR)122, (STDCHAR)122, 0, 0, 0, 0, +/* 0ed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ed8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ef0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_0f [256] = { +/* 0f00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f18 */ (STDCHAR)220, (STDCHAR)220, 0, 0, 0, 0, 0, 0, +/* 0f20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f30 */ 0, 0, 0, 0, 0, (STDCHAR)220, 0, (STDCHAR)220, +/* 0f38 */ 0, (STDCHAR)216, 0, 0, 0, 0, 0, 0, +/* 0f40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f70 */ 0, (STDCHAR)129, (STDCHAR)130, 0, (STDCHAR)132, 0, 0, 0, +/* 0f78 */ 0, 0, (STDCHAR)130, (STDCHAR)130, (STDCHAR)130, (STDCHAR)130, 0, 0, +/* 0f80 */ (STDCHAR)130, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)9, 0, (STDCHAR)230, (STDCHAR)230, +/* 0f88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fc0 */ 0, 0, 0, 0, 0, 0, (STDCHAR)220, 0, +/* 0fc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_10 [256] = { +/* 1000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1030 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)7, +/* 1038 */ 0, (STDCHAR)9, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 1040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1088 */ 0, 0, 0, 0, 0, (STDCHAR)220, 0, 0, +/* 1090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_13 [256] = { +/* 1300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1358 */ 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 13f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_17 [256] = { +/* 1700 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1708 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1710 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* 1718 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1720 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1728 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1730 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* 1738 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1740 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1748 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1750 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1758 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1760 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1768 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1770 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1778 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1780 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1788 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1790 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1798 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17d0 */ 0, 0, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 17d8 */ 0, 0, 0, 0, 0, (STDCHAR)230, 0, 0, +/* 17e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 17f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_18 [256] = { +/* 1800 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1808 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1810 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1818 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1820 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1828 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1830 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1838 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1840 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1848 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1850 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1858 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1860 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1868 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1870 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1878 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1880 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1888 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1890 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1898 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18a8 */ 0, (STDCHAR)228, 0, 0, 0, 0, 0, 0, +/* 18b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 18f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_19 [256] = { +/* 1900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1938 */ 0, (STDCHAR)222, (STDCHAR)230, (STDCHAR)220, 0, 0, 0, 0, +/* 1940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 19f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_1a [256] = { +/* 1a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a10 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)230, +/* 1a18 */ (STDCHAR)220, 0, 0, 0, 0, 0, 0, 0, +/* 1a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a60 */ (STDCHAR)9, 0, 0, 0, 0, 0, 0, 0, +/* 1a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a70 */ 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1a78 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, (STDCHAR)220, +/* 1a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ab0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 1ab8 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, 0, (STDCHAR)220, +/* 1ac0 */ (STDCHAR)220, 0, 0, 0, 0, 0, 0, 0, +/* 1ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_1b [256] = { +/* 1b00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b30 */ 0, 0, 0, 0, (STDCHAR)7, 0, 0, 0, +/* 1b38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b40 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* 1b48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b68 */ 0, 0, 0, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1b70 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, +/* 1b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba8 */ 0, 0, (STDCHAR)9, (STDCHAR)9, 0, 0, 0, 0, +/* 1bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1be0 */ 0, 0, 0, 0, 0, 0, (STDCHAR)7, 0, +/* 1be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bf0 */ 0, 0, (STDCHAR)9, (STDCHAR)9, 0, 0, 0, 0, +/* 1bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_1c [256] = { +/* 1c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c30 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)7, +/* 1c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1cc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1cc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1cd0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)1, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 1cd8 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 1ce0 */ (STDCHAR)230, 0, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, +/* 1ce8 */ (STDCHAR)1, 0, 0, 0, 0, (STDCHAR)220, 0, 0, +/* 1cf0 */ 0, 0, 0, 0, (STDCHAR)230, 0, 0, 0, +/* 1cf8 */ (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_1d [256] = { +/* 1d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1dc0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1dc8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, (STDCHAR)234, (STDCHAR)214, (STDCHAR)220, +/* 1dd0 */ (STDCHAR)202, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1dd8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1de0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1de8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 1df0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)232, (STDCHAR)228, +/* 1df8 */ (STDCHAR)228, (STDCHAR)220, 0, (STDCHAR)230, (STDCHAR)233, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220 +}; + +static const STDCHAR UN8IF_combin_00_20 [256] = { +/* 2000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20d0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)1, (STDCHAR)1, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 20d8 */ (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 20e0 */ 0, (STDCHAR)230, 0, 0, 0, (STDCHAR)1, (STDCHAR)1, (STDCHAR)230, +/* 20e8 */ (STDCHAR)220, (STDCHAR)230, (STDCHAR)1, (STDCHAR)1, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 20f0 */ (STDCHAR)230, 0, 0, 0, 0, 0, 0, 0, +/* 20f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_2c [256] = { +/* 2c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ce8 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)230, +/* 2cf0 */ (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, 0, +/* 2cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_2d [256] = { +/* 2d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d78 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 2d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2de0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 2de8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 2df0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 2df8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230 +}; + +static const STDCHAR UN8IF_combin_00_30 [256] = { +/* 3000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3028 */ 0, 0, (STDCHAR)218, (STDCHAR)228, (STDCHAR)232, (STDCHAR)222, (STDCHAR)224, (STDCHAR)224, +/* 3030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3098 */ 0, (STDCHAR)8, (STDCHAR)8, 0, 0, 0, 0, 0, +/* 30a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_a6 [256] = { +/* a600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a610 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a618 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a620 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a638 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a648 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a650 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a658 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a668 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)230, +/* a670 */ 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* a678 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, +/* a680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a698 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* a6a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6f0 */ (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, 0, +/* a6f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_a8 [256] = { +/* a800 */ 0, 0, 0, 0, 0, 0, (STDCHAR)9, 0, +/* a808 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a810 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a818 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a820 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a828 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* a830 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a838 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a840 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a848 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a850 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a858 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a860 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a868 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a870 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a878 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a880 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a888 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a890 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a898 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8c0 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* a8c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a8e0 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* a8e8 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* a8f0 */ (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, 0, +/* a8f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_a9 [256] = { +/* a900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a928 */ 0, 0, 0, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, 0, 0, +/* a930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a938 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a950 */ 0, 0, 0, (STDCHAR)9, 0, 0, 0, 0, +/* a958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9b0 */ 0, 0, 0, (STDCHAR)7, 0, 0, 0, 0, +/* a9b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9c0 */ (STDCHAR)9, 0, 0, 0, 0, 0, 0, 0, +/* a9c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a9f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_aa [256] = { +/* aa00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aa98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aaa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aaa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aab0 */ (STDCHAR)230, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, 0, 0, (STDCHAR)230, +/* aab8 */ (STDCHAR)230, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* aac0 */ 0, (STDCHAR)230, 0, 0, 0, 0, 0, 0, +/* aac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aaf0 */ 0, 0, 0, 0, 0, 0, (STDCHAR)9, 0, +/* aaf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_ab [256] = { +/* ab00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abe8 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* abf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_fb [256] = { +/* fb00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb18 */ 0, 0, 0, 0, 0, 0, (STDCHAR)26, 0, +/* fb20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_00_fe [256] = { +/* fe00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe20 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, +/* fe28 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)230, (STDCHAR)230, +/* fe30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fea0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fea8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* feb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* feb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fec8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fed8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fef0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_01 [256] = { +/* 010100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0101f8 */ 0, 0, 0, 0, 0, (STDCHAR)220, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_02 [256] = { +/* 010200 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010208 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010220 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010228 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010230 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010240 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102e0 */ (STDCHAR)220, 0, 0, 0, 0, 0, 0, 0, +/* 0102e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0102f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_03 [256] = { +/* 010300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010370 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* 010378 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, +/* 010380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0103f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_0a [256] = { +/* 010a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a08 */ 0, 0, 0, 0, 0, (STDCHAR)220, 0, (STDCHAR)230, +/* 010a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a38 */ (STDCHAR)230, (STDCHAR)1, (STDCHAR)220, 0, 0, 0, 0, (STDCHAR)9, +/* 010a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ae0 */ 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)220, 0, +/* 010ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_0d [256] = { +/* 010d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d20 */ 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 010d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_0e [256] = { +/* 010e00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010e98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ea0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ea8 */ 0, 0, 0, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 010eb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010eb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ec8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ed8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ef0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_0f [256] = { +/* 010f00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f40 */ 0, 0, 0, 0, 0, 0, (STDCHAR)220, (STDCHAR)220, +/* 010f48 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 010f50 */ (STDCHAR)220, 0, 0, 0, 0, 0, 0, 0, +/* 010f58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010f98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 010ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_10 [256] = { +/* 011000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011040 */ 0, 0, 0, 0, 0, 0, (STDCHAR)9, 0, +/* 011048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011078 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 011080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110b8 */ 0, (STDCHAR)9, (STDCHAR)7, 0, 0, 0, 0, 0, +/* 0110c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_11 [256] = { +/* 011100 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, +/* 011108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011130 */ 0, 0, 0, (STDCHAR)9, (STDCHAR)9, 0, 0, 0, +/* 011138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011170 */ 0, 0, 0, (STDCHAR)7, 0, 0, 0, 0, +/* 011178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111c0 */ (STDCHAR)9, 0, 0, 0, 0, 0, 0, 0, +/* 0111c8 */ 0, 0, (STDCHAR)7, 0, 0, 0, 0, 0, +/* 0111d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_12 [256] = { +/* 011200 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011208 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011220 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011228 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011230 */ 0, 0, 0, 0, 0, (STDCHAR)9, (STDCHAR)7, 0, +/* 011238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011240 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112e8 */ 0, (STDCHAR)7, (STDCHAR)9, 0, 0, 0, 0, 0, +/* 0112f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0112f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_13 [256] = { +/* 011300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011338 */ 0, 0, 0, (STDCHAR)7, (STDCHAR)7, 0, 0, 0, +/* 011340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011348 */ 0, 0, 0, 0, 0, (STDCHAR)9, 0, 0, +/* 011350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011360 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, +/* 011368 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 011370 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 011378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_14 [256] = { +/* 011400 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011408 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011418 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011438 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011440 */ 0, 0, (STDCHAR)9, 0, 0, 0, (STDCHAR)7, 0, +/* 011448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011450 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011458 */ 0, 0, 0, 0, 0, 0, (STDCHAR)230, 0, +/* 011460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011470 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011480 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114c0 */ 0, 0, (STDCHAR)9, (STDCHAR)7, 0, 0, 0, 0, +/* 0114c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_15 [256] = { +/* 011500 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011508 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011510 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011518 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011520 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011528 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011530 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011538 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011540 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011548 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011550 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011558 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011560 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011568 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011570 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011578 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011580 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011588 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011590 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011598 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b8 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 0115c0 */ (STDCHAR)7, 0, 0, 0, 0, 0, 0, 0, +/* 0115c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_16 [256] = { +/* 011600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011610 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011618 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011620 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011638 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 011640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011648 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011650 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011658 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011668 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011670 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011678 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011698 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116b0 */ 0, 0, 0, 0, 0, 0, (STDCHAR)9, (STDCHAR)7, +/* 0116b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0116f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_17 [256] = { +/* 011700 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011708 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011710 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011718 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011720 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011728 */ 0, 0, 0, (STDCHAR)9, 0, 0, 0, 0, +/* 011730 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011738 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011740 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011748 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011750 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011758 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011760 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011768 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011770 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011778 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011780 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011788 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011790 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011798 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0117f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_18 [256] = { +/* 011800 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011808 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011810 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011818 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011820 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011828 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011830 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011838 */ 0, (STDCHAR)9, (STDCHAR)7, 0, 0, 0, 0, 0, +/* 011840 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011848 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011850 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011858 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011860 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011868 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011870 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011878 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011880 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011888 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011890 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011898 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0118f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_19 [256] = { +/* 011900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011938 */ 0, 0, 0, 0, 0, (STDCHAR)9, (STDCHAR)9, 0, +/* 011940 */ 0, 0, 0, (STDCHAR)7, 0, 0, 0, 0, +/* 011948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119e0 */ (STDCHAR)9, 0, 0, 0, 0, 0, 0, 0, +/* 0119e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_1a [256] = { +/* 011a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a30 */ 0, 0, 0, 0, (STDCHAR)9, 0, 0, 0, +/* 011a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a40 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 011a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011a98 */ 0, (STDCHAR)9, 0, 0, 0, 0, 0, 0, +/* 011aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_1c [256] = { +/* 011c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c38 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 011c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011ce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_1d [256] = { +/* 011d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d40 */ 0, 0, (STDCHAR)7, 0, (STDCHAR)9, (STDCHAR)9, 0, 0, +/* 011d48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011d90 */ 0, 0, 0, 0, 0, 0, 0, (STDCHAR)9, +/* 011d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_6a [256] = { +/* 016a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016af0 */ (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, (STDCHAR)1, 0, 0, 0, +/* 016af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_6b [256] = { +/* 016b00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b30 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, +/* 016b38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_6f [256] = { +/* 016f00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016f98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 016ff0 */ (STDCHAR)6, (STDCHAR)6, 0, 0, 0, 0, 0, 0, +/* 016ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_bc [256] = { +/* 01bc00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bc98 */ 0, 0, 0, 0, 0, 0, (STDCHAR)1, 0, +/* 01bca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01bcf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_d1 [256] = { +/* 01d100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d160 */ 0, 0, 0, 0, 0, (STDCHAR)216, (STDCHAR)216, (STDCHAR)1, +/* 01d168 */ (STDCHAR)1, (STDCHAR)1, 0, 0, 0, (STDCHAR)226, (STDCHAR)216, (STDCHAR)216, +/* 01d170 */ (STDCHAR)216, (STDCHAR)216, (STDCHAR)216, 0, 0, 0, 0, 0, +/* 01d178 */ 0, 0, 0, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, +/* 01d180 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01d188 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)220, (STDCHAR)220, 0, 0, 0, 0, +/* 01d190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a8 */ 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, +/* 01d1b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_d2 [256] = { +/* 01d200 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d208 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d220 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d228 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d230 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d240 */ 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, +/* 01d248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d2f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_e0 [256] = { +/* 01e000 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, +/* 01e008 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01e010 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01e018 */ (STDCHAR)230, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01e020 */ (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)230, (STDCHAR)230, 0, (STDCHAR)230, (STDCHAR)230, +/* 01e028 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, 0, 0, 0, 0, +/* 01e030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e0f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_e1 [256] = { +/* 01e100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e130 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, 0, +/* 01e138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e1f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_e2 [256] = { +/* 01e200 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e208 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e220 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e228 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e230 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e240 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2e8 */ 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01e2f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e2f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_e8 [256] = { +/* 01e800 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e808 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e810 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e818 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e820 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e828 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e830 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e838 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e840 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e848 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e850 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e858 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e860 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e868 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e870 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e878 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e880 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e888 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e890 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e898 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8d0 */ (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, (STDCHAR)220, 0, +/* 01e8d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e8f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const STDCHAR UN8IF_combin_01_e9 [256] = { +/* 01e900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e938 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e940 */ 0, 0, 0, 0, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, (STDCHAR)230, +/* 01e948 */ (STDCHAR)230, (STDCHAR)230, (STDCHAR)7, 0, 0, 0, 0, 0, +/* 01e950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01e9f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* the planes */ +static const STDCHAR* UN8IF_combin_00 [256] = { +NULL,NULL,NULL,UN8IF_combin_00_03, +UN8IF_combin_00_04, +UN8IF_combin_00_05, +UN8IF_combin_00_06, +UN8IF_combin_00_07, +UN8IF_combin_00_08, +UN8IF_combin_00_09, +UN8IF_combin_00_0a, +UN8IF_combin_00_0b, +UN8IF_combin_00_0c, +UN8IF_combin_00_0d, +UN8IF_combin_00_0e, +UN8IF_combin_00_0f, +UN8IF_combin_00_10, +NULL,NULL,UN8IF_combin_00_13, +NULL,NULL,NULL,UN8IF_combin_00_17, +UN8IF_combin_00_18, +UN8IF_combin_00_19, +UN8IF_combin_00_1a, +UN8IF_combin_00_1b, +UN8IF_combin_00_1c, +UN8IF_combin_00_1d, +NULL,NULL, +UN8IF_combin_00_20, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,UN8IF_combin_00_2c, +UN8IF_combin_00_2d, +NULL,NULL, +UN8IF_combin_00_30, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,UN8IF_combin_00_a6, +NULL, +UN8IF_combin_00_a8, +UN8IF_combin_00_a9, +UN8IF_combin_00_aa, +UN8IF_combin_00_ab, +NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_combin_00_fb, +NULL,NULL,UN8IF_combin_00_fe, +NULL +}; + +static const STDCHAR* UN8IF_combin_01 [256] = { +NULL,UN8IF_combin_01_01, +UN8IF_combin_01_02, +UN8IF_combin_01_03, +NULL,NULL,NULL,NULL, +NULL,NULL,UN8IF_combin_01_0a, +NULL,NULL,UN8IF_combin_01_0d, +UN8IF_combin_01_0e, +UN8IF_combin_01_0f, +UN8IF_combin_01_10, +UN8IF_combin_01_11, +UN8IF_combin_01_12, +UN8IF_combin_01_13, +UN8IF_combin_01_14, +UN8IF_combin_01_15, +UN8IF_combin_01_16, +UN8IF_combin_01_17, +UN8IF_combin_01_18, +UN8IF_combin_01_19, +UN8IF_combin_01_1a, +NULL,UN8IF_combin_01_1c, +UN8IF_combin_01_1d, +NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,UN8IF_combin_01_6a, +UN8IF_combin_01_6b, +NULL,NULL,NULL,UN8IF_combin_01_6f, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,UN8IF_combin_01_bc, +NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_combin_01_d1, +UN8IF_combin_01_d2, +NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_combin_01_e0, +UN8IF_combin_01_e1, +UN8IF_combin_01_e2, +NULL,NULL,NULL,NULL,NULL, +UN8IF_combin_01_e8, +UN8IF_combin_01_e9, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL +}; + +/* the main plane */ +static const STDCHAR** UN8IF_combin [] = { +UN8IF_combin_00, +UN8IF_combin_01, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL +}; + diff --git a/src/extu8/un8ifcmp.h b/src/extu8/un8ifcmp.h new file mode 100644 index 000000000..0401a1df6 --- /dev/null +++ b/src/extu8/un8ifcmp.h @@ -0,0 +1,2615 @@ +/* ex: set ro ft=c: -*- buffer-read-only: t -*- + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is auto-generated by Unicode-Normalize 1.27 + * mkheader -ind -std + * for Unicode 13.0.0 UTF-8 + * Any changes here will be lost! + */ +/* Composition */ +typedef struct { uint32_t nextchar; uint32_t composite; } UN8IF_complist; +typedef struct { uint16_t nextchar; uint16_t composite; } UN8IF_complist_s; + +/* max nextchar: 119154/0x1d172, max composite: 119232/0x1d1c0, max length: 20 */ +/* 17/442 lists > short (0xffff) */ + +#define UN8IF_COMPLIST_FIRST_LONG 0x011099 + +static const UN8IF_complist_s UN8IF_complist_00003c [2] = { + { 0x338, 0x226e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00003d [2] = { + { 0x338, 0x2260 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00003e [2] = { + { 0x338, 0x226f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000041 [17] = { + { 0x300, 0xc0 }, + { 0x301, 0xc1 }, + { 0x302, 0xc2 }, + { 0x303, 0xc3 }, + { 0x304, 0x100 }, + { 0x306, 0x102 }, + { 0x307, 0x226 }, + { 0x308, 0xc4 }, + { 0x309, 0x1ea2 }, + { 0x30a, 0xc5 }, + { 0x30c, 0x1cd }, + { 0x30f, 0x200 }, + { 0x311, 0x202 }, + { 0x323, 0x1ea0 }, + { 0x325, 0x1e00 }, + { 0x328, 0x104 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000042 [4] = { + { 0x307, 0x1e02 }, + { 0x323, 0x1e04 }, + { 0x331, 0x1e06 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000043 [6] = { + { 0x301, 0x106 }, + { 0x302, 0x108 }, + { 0x307, 0x10a }, + { 0x30c, 0x10c }, + { 0x327, 0xc7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000044 [7] = { + { 0x307, 0x1e0a }, + { 0x30c, 0x10e }, + { 0x323, 0x1e0c }, + { 0x327, 0x1e10 }, + { 0x32d, 0x1e12 }, + { 0x331, 0x1e0e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000045 [18] = { + { 0x300, 0xc8 }, + { 0x301, 0xc9 }, + { 0x302, 0xca }, + { 0x303, 0x1ebc }, + { 0x304, 0x112 }, + { 0x306, 0x114 }, + { 0x307, 0x116 }, + { 0x308, 0xcb }, + { 0x309, 0x1eba }, + { 0x30c, 0x11a }, + { 0x30f, 0x204 }, + { 0x311, 0x206 }, + { 0x323, 0x1eb8 }, + { 0x327, 0x228 }, + { 0x328, 0x118 }, + { 0x32d, 0x1e18 }, + { 0x330, 0x1e1a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000046 [2] = { + { 0x307, 0x1e1e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000047 [8] = { + { 0x301, 0x1f4 }, + { 0x302, 0x11c }, + { 0x304, 0x1e20 }, + { 0x306, 0x11e }, + { 0x307, 0x120 }, + { 0x30c, 0x1e6 }, + { 0x327, 0x122 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000048 [8] = { + { 0x302, 0x124 }, + { 0x307, 0x1e22 }, + { 0x308, 0x1e26 }, + { 0x30c, 0x21e }, + { 0x323, 0x1e24 }, + { 0x327, 0x1e28 }, + { 0x32e, 0x1e2a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000049 [16] = { + { 0x300, 0xcc }, + { 0x301, 0xcd }, + { 0x302, 0xce }, + { 0x303, 0x128 }, + { 0x304, 0x12a }, + { 0x306, 0x12c }, + { 0x307, 0x130 }, + { 0x308, 0xcf }, + { 0x309, 0x1ec8 }, + { 0x30c, 0x1cf }, + { 0x30f, 0x208 }, + { 0x311, 0x20a }, + { 0x323, 0x1eca }, + { 0x328, 0x12e }, + { 0x330, 0x1e2c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004a [2] = { + { 0x302, 0x134 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004b [6] = { + { 0x301, 0x1e30 }, + { 0x30c, 0x1e8 }, + { 0x323, 0x1e32 }, + { 0x327, 0x136 }, + { 0x331, 0x1e34 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004c [7] = { + { 0x301, 0x139 }, + { 0x30c, 0x13d }, + { 0x323, 0x1e36 }, + { 0x327, 0x13b }, + { 0x32d, 0x1e3c }, + { 0x331, 0x1e3a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004d [4] = { + { 0x301, 0x1e3e }, + { 0x307, 0x1e40 }, + { 0x323, 0x1e42 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004e [10] = { + { 0x300, 0x1f8 }, + { 0x301, 0x143 }, + { 0x303, 0xd1 }, + { 0x307, 0x1e44 }, + { 0x30c, 0x147 }, + { 0x323, 0x1e46 }, + { 0x327, 0x145 }, + { 0x32d, 0x1e4a }, + { 0x331, 0x1e48 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00004f [17] = { + { 0x300, 0xd2 }, + { 0x301, 0xd3 }, + { 0x302, 0xd4 }, + { 0x303, 0xd5 }, + { 0x304, 0x14c }, + { 0x306, 0x14e }, + { 0x307, 0x22e }, + { 0x308, 0xd6 }, + { 0x309, 0x1ece }, + { 0x30b, 0x150 }, + { 0x30c, 0x1d1 }, + { 0x30f, 0x20c }, + { 0x311, 0x20e }, + { 0x31b, 0x1a0 }, + { 0x323, 0x1ecc }, + { 0x328, 0x1ea }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000050 [3] = { + { 0x301, 0x1e54 }, + { 0x307, 0x1e56 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000052 [9] = { + { 0x301, 0x154 }, + { 0x307, 0x1e58 }, + { 0x30c, 0x158 }, + { 0x30f, 0x210 }, + { 0x311, 0x212 }, + { 0x323, 0x1e5a }, + { 0x327, 0x156 }, + { 0x331, 0x1e5e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000053 [8] = { + { 0x301, 0x15a }, + { 0x302, 0x15c }, + { 0x307, 0x1e60 }, + { 0x30c, 0x160 }, + { 0x323, 0x1e62 }, + { 0x326, 0x218 }, + { 0x327, 0x15e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000054 [8] = { + { 0x307, 0x1e6a }, + { 0x30c, 0x164 }, + { 0x323, 0x1e6c }, + { 0x326, 0x21a }, + { 0x327, 0x162 }, + { 0x32d, 0x1e70 }, + { 0x331, 0x1e6e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000055 [20] = { + { 0x300, 0xd9 }, + { 0x301, 0xda }, + { 0x302, 0xdb }, + { 0x303, 0x168 }, + { 0x304, 0x16a }, + { 0x306, 0x16c }, + { 0x308, 0xdc }, + { 0x309, 0x1ee6 }, + { 0x30a, 0x16e }, + { 0x30b, 0x170 }, + { 0x30c, 0x1d3 }, + { 0x30f, 0x214 }, + { 0x311, 0x216 }, + { 0x31b, 0x1af }, + { 0x323, 0x1ee4 }, + { 0x324, 0x1e72 }, + { 0x328, 0x172 }, + { 0x32d, 0x1e76 }, + { 0x330, 0x1e74 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000056 [3] = { + { 0x303, 0x1e7c }, + { 0x323, 0x1e7e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000057 [7] = { + { 0x300, 0x1e80 }, + { 0x301, 0x1e82 }, + { 0x302, 0x174 }, + { 0x307, 0x1e86 }, + { 0x308, 0x1e84 }, + { 0x323, 0x1e88 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000058 [3] = { + { 0x307, 0x1e8a }, + { 0x308, 0x1e8c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000059 [10] = { + { 0x300, 0x1ef2 }, + { 0x301, 0xdd }, + { 0x302, 0x176 }, + { 0x303, 0x1ef8 }, + { 0x304, 0x232 }, + { 0x307, 0x1e8e }, + { 0x308, 0x178 }, + { 0x309, 0x1ef6 }, + { 0x323, 0x1ef4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00005a [7] = { + { 0x301, 0x179 }, + { 0x302, 0x1e90 }, + { 0x307, 0x17b }, + { 0x30c, 0x17d }, + { 0x323, 0x1e92 }, + { 0x331, 0x1e94 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000061 [17] = { + { 0x300, 0xe0 }, + { 0x301, 0xe1 }, + { 0x302, 0xe2 }, + { 0x303, 0xe3 }, + { 0x304, 0x101 }, + { 0x306, 0x103 }, + { 0x307, 0x227 }, + { 0x308, 0xe4 }, + { 0x309, 0x1ea3 }, + { 0x30a, 0xe5 }, + { 0x30c, 0x1ce }, + { 0x30f, 0x201 }, + { 0x311, 0x203 }, + { 0x323, 0x1ea1 }, + { 0x325, 0x1e01 }, + { 0x328, 0x105 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000062 [4] = { + { 0x307, 0x1e03 }, + { 0x323, 0x1e05 }, + { 0x331, 0x1e07 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000063 [6] = { + { 0x301, 0x107 }, + { 0x302, 0x109 }, + { 0x307, 0x10b }, + { 0x30c, 0x10d }, + { 0x327, 0xe7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000064 [7] = { + { 0x307, 0x1e0b }, + { 0x30c, 0x10f }, + { 0x323, 0x1e0d }, + { 0x327, 0x1e11 }, + { 0x32d, 0x1e13 }, + { 0x331, 0x1e0f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000065 [18] = { + { 0x300, 0xe8 }, + { 0x301, 0xe9 }, + { 0x302, 0xea }, + { 0x303, 0x1ebd }, + { 0x304, 0x113 }, + { 0x306, 0x115 }, + { 0x307, 0x117 }, + { 0x308, 0xeb }, + { 0x309, 0x1ebb }, + { 0x30c, 0x11b }, + { 0x30f, 0x205 }, + { 0x311, 0x207 }, + { 0x323, 0x1eb9 }, + { 0x327, 0x229 }, + { 0x328, 0x119 }, + { 0x32d, 0x1e19 }, + { 0x330, 0x1e1b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000066 [2] = { + { 0x307, 0x1e1f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000067 [8] = { + { 0x301, 0x1f5 }, + { 0x302, 0x11d }, + { 0x304, 0x1e21 }, + { 0x306, 0x11f }, + { 0x307, 0x121 }, + { 0x30c, 0x1e7 }, + { 0x327, 0x123 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000068 [9] = { + { 0x302, 0x125 }, + { 0x307, 0x1e23 }, + { 0x308, 0x1e27 }, + { 0x30c, 0x21f }, + { 0x323, 0x1e25 }, + { 0x327, 0x1e29 }, + { 0x32e, 0x1e2b }, + { 0x331, 0x1e96 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000069 [15] = { + { 0x300, 0xec }, + { 0x301, 0xed }, + { 0x302, 0xee }, + { 0x303, 0x129 }, + { 0x304, 0x12b }, + { 0x306, 0x12d }, + { 0x308, 0xef }, + { 0x309, 0x1ec9 }, + { 0x30c, 0x1d0 }, + { 0x30f, 0x209 }, + { 0x311, 0x20b }, + { 0x323, 0x1ecb }, + { 0x328, 0x12f }, + { 0x330, 0x1e2d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006a [3] = { + { 0x302, 0x135 }, + { 0x30c, 0x1f0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006b [6] = { + { 0x301, 0x1e31 }, + { 0x30c, 0x1e9 }, + { 0x323, 0x1e33 }, + { 0x327, 0x137 }, + { 0x331, 0x1e35 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006c [7] = { + { 0x301, 0x13a }, + { 0x30c, 0x13e }, + { 0x323, 0x1e37 }, + { 0x327, 0x13c }, + { 0x32d, 0x1e3d }, + { 0x331, 0x1e3b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006d [4] = { + { 0x301, 0x1e3f }, + { 0x307, 0x1e41 }, + { 0x323, 0x1e43 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006e [10] = { + { 0x300, 0x1f9 }, + { 0x301, 0x144 }, + { 0x303, 0xf1 }, + { 0x307, 0x1e45 }, + { 0x30c, 0x148 }, + { 0x323, 0x1e47 }, + { 0x327, 0x146 }, + { 0x32d, 0x1e4b }, + { 0x331, 0x1e49 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00006f [17] = { + { 0x300, 0xf2 }, + { 0x301, 0xf3 }, + { 0x302, 0xf4 }, + { 0x303, 0xf5 }, + { 0x304, 0x14d }, + { 0x306, 0x14f }, + { 0x307, 0x22f }, + { 0x308, 0xf6 }, + { 0x309, 0x1ecf }, + { 0x30b, 0x151 }, + { 0x30c, 0x1d2 }, + { 0x30f, 0x20d }, + { 0x311, 0x20f }, + { 0x31b, 0x1a1 }, + { 0x323, 0x1ecd }, + { 0x328, 0x1eb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000070 [3] = { + { 0x301, 0x1e55 }, + { 0x307, 0x1e57 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000072 [9] = { + { 0x301, 0x155 }, + { 0x307, 0x1e59 }, + { 0x30c, 0x159 }, + { 0x30f, 0x211 }, + { 0x311, 0x213 }, + { 0x323, 0x1e5b }, + { 0x327, 0x157 }, + { 0x331, 0x1e5f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000073 [8] = { + { 0x301, 0x15b }, + { 0x302, 0x15d }, + { 0x307, 0x1e61 }, + { 0x30c, 0x161 }, + { 0x323, 0x1e63 }, + { 0x326, 0x219 }, + { 0x327, 0x15f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000074 [9] = { + { 0x307, 0x1e6b }, + { 0x308, 0x1e97 }, + { 0x30c, 0x165 }, + { 0x323, 0x1e6d }, + { 0x326, 0x21b }, + { 0x327, 0x163 }, + { 0x32d, 0x1e71 }, + { 0x331, 0x1e6f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000075 [20] = { + { 0x300, 0xf9 }, + { 0x301, 0xfa }, + { 0x302, 0xfb }, + { 0x303, 0x169 }, + { 0x304, 0x16b }, + { 0x306, 0x16d }, + { 0x308, 0xfc }, + { 0x309, 0x1ee7 }, + { 0x30a, 0x16f }, + { 0x30b, 0x171 }, + { 0x30c, 0x1d4 }, + { 0x30f, 0x215 }, + { 0x311, 0x217 }, + { 0x31b, 0x1b0 }, + { 0x323, 0x1ee5 }, + { 0x324, 0x1e73 }, + { 0x328, 0x173 }, + { 0x32d, 0x1e77 }, + { 0x330, 0x1e75 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000076 [3] = { + { 0x303, 0x1e7d }, + { 0x323, 0x1e7f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000077 [8] = { + { 0x300, 0x1e81 }, + { 0x301, 0x1e83 }, + { 0x302, 0x175 }, + { 0x307, 0x1e87 }, + { 0x308, 0x1e85 }, + { 0x30a, 0x1e98 }, + { 0x323, 0x1e89 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000078 [3] = { + { 0x307, 0x1e8b }, + { 0x308, 0x1e8d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000079 [11] = { + { 0x300, 0x1ef3 }, + { 0x301, 0xfd }, + { 0x302, 0x177 }, + { 0x303, 0x1ef9 }, + { 0x304, 0x233 }, + { 0x307, 0x1e8f }, + { 0x308, 0xff }, + { 0x309, 0x1ef7 }, + { 0x30a, 0x1e99 }, + { 0x323, 0x1ef5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00007a [7] = { + { 0x301, 0x17a }, + { 0x302, 0x1e91 }, + { 0x307, 0x17c }, + { 0x30c, 0x17e }, + { 0x323, 0x1e93 }, + { 0x331, 0x1e95 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000a8 [4] = { + { 0x300, 0x1fed }, + { 0x301, 0x385 }, + { 0x342, 0x1fc1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000c2 [5] = { + { 0x300, 0x1ea6 }, + { 0x301, 0x1ea4 }, + { 0x303, 0x1eaa }, + { 0x309, 0x1ea8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000c4 [2] = { + { 0x304, 0x1de }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000c5 [2] = { + { 0x301, 0x1fa }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000c6 [3] = { + { 0x301, 0x1fc }, + { 0x304, 0x1e2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000c7 [2] = { + { 0x301, 0x1e08 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000ca [5] = { + { 0x300, 0x1ec0 }, + { 0x301, 0x1ebe }, + { 0x303, 0x1ec4 }, + { 0x309, 0x1ec2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000cf [2] = { + { 0x301, 0x1e2e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000d4 [5] = { + { 0x300, 0x1ed2 }, + { 0x301, 0x1ed0 }, + { 0x303, 0x1ed6 }, + { 0x309, 0x1ed4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000d5 [4] = { + { 0x301, 0x1e4c }, + { 0x304, 0x22c }, + { 0x308, 0x1e4e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000d6 [2] = { + { 0x304, 0x22a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000d8 [2] = { + { 0x301, 0x1fe }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000dc [5] = { + { 0x300, 0x1db }, + { 0x301, 0x1d7 }, + { 0x304, 0x1d5 }, + { 0x30c, 0x1d9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000e2 [5] = { + { 0x300, 0x1ea7 }, + { 0x301, 0x1ea5 }, + { 0x303, 0x1eab }, + { 0x309, 0x1ea9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000e4 [2] = { + { 0x304, 0x1df }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000e5 [2] = { + { 0x301, 0x1fb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000e6 [3] = { + { 0x301, 0x1fd }, + { 0x304, 0x1e3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000e7 [2] = { + { 0x301, 0x1e09 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000ea [5] = { + { 0x300, 0x1ec1 }, + { 0x301, 0x1ebf }, + { 0x303, 0x1ec5 }, + { 0x309, 0x1ec3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000ef [2] = { + { 0x301, 0x1e2f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000f4 [5] = { + { 0x300, 0x1ed3 }, + { 0x301, 0x1ed1 }, + { 0x303, 0x1ed7 }, + { 0x309, 0x1ed5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000f5 [4] = { + { 0x301, 0x1e4d }, + { 0x304, 0x22d }, + { 0x308, 0x1e4f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000f6 [2] = { + { 0x304, 0x22b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000f8 [2] = { + { 0x301, 0x1ff }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0000fc [5] = { + { 0x300, 0x1dc }, + { 0x301, 0x1d8 }, + { 0x304, 0x1d6 }, + { 0x30c, 0x1da }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000102 [5] = { + { 0x300, 0x1eb0 }, + { 0x301, 0x1eae }, + { 0x303, 0x1eb4 }, + { 0x309, 0x1eb2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000103 [5] = { + { 0x300, 0x1eb1 }, + { 0x301, 0x1eaf }, + { 0x303, 0x1eb5 }, + { 0x309, 0x1eb3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000112 [3] = { + { 0x300, 0x1e14 }, + { 0x301, 0x1e16 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000113 [3] = { + { 0x300, 0x1e15 }, + { 0x301, 0x1e17 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00014c [3] = { + { 0x300, 0x1e50 }, + { 0x301, 0x1e52 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00014d [3] = { + { 0x300, 0x1e51 }, + { 0x301, 0x1e53 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00015a [2] = { + { 0x307, 0x1e64 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00015b [2] = { + { 0x307, 0x1e65 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000160 [2] = { + { 0x307, 0x1e66 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000161 [2] = { + { 0x307, 0x1e67 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000168 [2] = { + { 0x301, 0x1e78 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000169 [2] = { + { 0x301, 0x1e79 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00016a [2] = { + { 0x308, 0x1e7a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00016b [2] = { + { 0x308, 0x1e7b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00017f [2] = { + { 0x307, 0x1e9b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001a0 [6] = { + { 0x300, 0x1edc }, + { 0x301, 0x1eda }, + { 0x303, 0x1ee0 }, + { 0x309, 0x1ede }, + { 0x323, 0x1ee2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001a1 [6] = { + { 0x300, 0x1edd }, + { 0x301, 0x1edb }, + { 0x303, 0x1ee1 }, + { 0x309, 0x1edf }, + { 0x323, 0x1ee3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001af [6] = { + { 0x300, 0x1eea }, + { 0x301, 0x1ee8 }, + { 0x303, 0x1eee }, + { 0x309, 0x1eec }, + { 0x323, 0x1ef0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001b0 [6] = { + { 0x300, 0x1eeb }, + { 0x301, 0x1ee9 }, + { 0x303, 0x1eef }, + { 0x309, 0x1eed }, + { 0x323, 0x1ef1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001b7 [2] = { + { 0x30c, 0x1ee }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001ea [2] = { + { 0x304, 0x1ec }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0001eb [2] = { + { 0x304, 0x1ed }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000226 [2] = { + { 0x304, 0x1e0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000227 [2] = { + { 0x304, 0x1e1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000228 [2] = { + { 0x306, 0x1e1c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000229 [2] = { + { 0x306, 0x1e1d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00022e [2] = { + { 0x304, 0x230 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00022f [2] = { + { 0x304, 0x231 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000292 [2] = { + { 0x30c, 0x1ef }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000391 [8] = { + { 0x300, 0x1fba }, + { 0x301, 0x386 }, + { 0x304, 0x1fb9 }, + { 0x306, 0x1fb8 }, + { 0x313, 0x1f08 }, + { 0x314, 0x1f09 }, + { 0x345, 0x1fbc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000395 [5] = { + { 0x300, 0x1fc8 }, + { 0x301, 0x388 }, + { 0x313, 0x1f18 }, + { 0x314, 0x1f19 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000397 [6] = { + { 0x300, 0x1fca }, + { 0x301, 0x389 }, + { 0x313, 0x1f28 }, + { 0x314, 0x1f29 }, + { 0x345, 0x1fcc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000399 [8] = { + { 0x300, 0x1fda }, + { 0x301, 0x38a }, + { 0x304, 0x1fd9 }, + { 0x306, 0x1fd8 }, + { 0x308, 0x3aa }, + { 0x313, 0x1f38 }, + { 0x314, 0x1f39 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00039f [5] = { + { 0x300, 0x1ff8 }, + { 0x301, 0x38c }, + { 0x313, 0x1f48 }, + { 0x314, 0x1f49 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003a1 [2] = { + { 0x314, 0x1fec }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003a5 [7] = { + { 0x300, 0x1fea }, + { 0x301, 0x38e }, + { 0x304, 0x1fe9 }, + { 0x306, 0x1fe8 }, + { 0x308, 0x3ab }, + { 0x314, 0x1f59 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003a9 [6] = { + { 0x300, 0x1ffa }, + { 0x301, 0x38f }, + { 0x313, 0x1f68 }, + { 0x314, 0x1f69 }, + { 0x345, 0x1ffc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003ac [2] = { + { 0x345, 0x1fb4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003ae [2] = { + { 0x345, 0x1fc4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003b1 [9] = { + { 0x300, 0x1f70 }, + { 0x301, 0x3ac }, + { 0x304, 0x1fb1 }, + { 0x306, 0x1fb0 }, + { 0x313, 0x1f00 }, + { 0x314, 0x1f01 }, + { 0x342, 0x1fb6 }, + { 0x345, 0x1fb3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003b5 [5] = { + { 0x300, 0x1f72 }, + { 0x301, 0x3ad }, + { 0x313, 0x1f10 }, + { 0x314, 0x1f11 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003b7 [7] = { + { 0x300, 0x1f74 }, + { 0x301, 0x3ae }, + { 0x313, 0x1f20 }, + { 0x314, 0x1f21 }, + { 0x342, 0x1fc6 }, + { 0x345, 0x1fc3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003b9 [9] = { + { 0x300, 0x1f76 }, + { 0x301, 0x3af }, + { 0x304, 0x1fd1 }, + { 0x306, 0x1fd0 }, + { 0x308, 0x3ca }, + { 0x313, 0x1f30 }, + { 0x314, 0x1f31 }, + { 0x342, 0x1fd6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003bf [5] = { + { 0x300, 0x1f78 }, + { 0x301, 0x3cc }, + { 0x313, 0x1f40 }, + { 0x314, 0x1f41 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003c1 [3] = { + { 0x313, 0x1fe4 }, + { 0x314, 0x1fe5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003c5 [9] = { + { 0x300, 0x1f7a }, + { 0x301, 0x3cd }, + { 0x304, 0x1fe1 }, + { 0x306, 0x1fe0 }, + { 0x308, 0x3cb }, + { 0x313, 0x1f50 }, + { 0x314, 0x1f51 }, + { 0x342, 0x1fe6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003c9 [7] = { + { 0x300, 0x1f7c }, + { 0x301, 0x3ce }, + { 0x313, 0x1f60 }, + { 0x314, 0x1f61 }, + { 0x342, 0x1ff6 }, + { 0x345, 0x1ff3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003ca [4] = { + { 0x300, 0x1fd2 }, + { 0x301, 0x390 }, + { 0x342, 0x1fd7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003cb [4] = { + { 0x300, 0x1fe2 }, + { 0x301, 0x3b0 }, + { 0x342, 0x1fe7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003ce [2] = { + { 0x345, 0x1ff4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0003d2 [3] = { + { 0x301, 0x3d3 }, + { 0x308, 0x3d4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000406 [2] = { + { 0x308, 0x407 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000410 [3] = { + { 0x306, 0x4d0 }, + { 0x308, 0x4d2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000413 [2] = { + { 0x301, 0x403 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000415 [4] = { + { 0x300, 0x400 }, + { 0x306, 0x4d6 }, + { 0x308, 0x401 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000416 [3] = { + { 0x306, 0x4c1 }, + { 0x308, 0x4dc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000417 [2] = { + { 0x308, 0x4de }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000418 [5] = { + { 0x300, 0x40d }, + { 0x304, 0x4e2 }, + { 0x306, 0x419 }, + { 0x308, 0x4e4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00041a [2] = { + { 0x301, 0x40c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00041e [2] = { + { 0x308, 0x4e6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000423 [5] = { + { 0x304, 0x4ee }, + { 0x306, 0x40e }, + { 0x308, 0x4f0 }, + { 0x30b, 0x4f2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000427 [2] = { + { 0x308, 0x4f4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00042b [2] = { + { 0x308, 0x4f8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00042d [2] = { + { 0x308, 0x4ec }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000430 [3] = { + { 0x306, 0x4d1 }, + { 0x308, 0x4d3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000433 [2] = { + { 0x301, 0x453 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000435 [4] = { + { 0x300, 0x450 }, + { 0x306, 0x4d7 }, + { 0x308, 0x451 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000436 [3] = { + { 0x306, 0x4c2 }, + { 0x308, 0x4dd }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000437 [2] = { + { 0x308, 0x4df }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000438 [5] = { + { 0x300, 0x45d }, + { 0x304, 0x4e3 }, + { 0x306, 0x439 }, + { 0x308, 0x4e5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00043a [2] = { + { 0x301, 0x45c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00043e [2] = { + { 0x308, 0x4e7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000443 [5] = { + { 0x304, 0x4ef }, + { 0x306, 0x45e }, + { 0x308, 0x4f1 }, + { 0x30b, 0x4f3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000447 [2] = { + { 0x308, 0x4f5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00044b [2] = { + { 0x308, 0x4f9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00044d [2] = { + { 0x308, 0x4ed }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000456 [2] = { + { 0x308, 0x457 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000474 [2] = { + { 0x30f, 0x476 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000475 [2] = { + { 0x30f, 0x477 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0004d8 [2] = { + { 0x308, 0x4da }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0004d9 [2] = { + { 0x308, 0x4db }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0004e8 [2] = { + { 0x308, 0x4ea }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0004e9 [2] = { + { 0x308, 0x4eb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d0 [4] = { + { 0x5b7, 0xfb2e }, + { 0x5b8, 0xfb2f }, + { 0x5bc, 0xfb30 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d1 [3] = { + { 0x5bc, 0xfb31 }, + { 0x5bf, 0xfb4c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d2 [2] = { + { 0x5bc, 0xfb32 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d3 [2] = { + { 0x5bc, 0xfb33 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d4 [2] = { + { 0x5bc, 0xfb34 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d5 [3] = { + { 0x5b9, 0xfb4b }, + { 0x5bc, 0xfb35 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d6 [2] = { + { 0x5bc, 0xfb36 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d8 [2] = { + { 0x5bc, 0xfb38 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005d9 [3] = { + { 0x5b4, 0xfb1d }, + { 0x5bc, 0xfb39 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005da [2] = { + { 0x5bc, 0xfb3a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005db [3] = { + { 0x5bc, 0xfb3b }, + { 0x5bf, 0xfb4d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005dc [2] = { + { 0x5bc, 0xfb3c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005de [2] = { + { 0x5bc, 0xfb3e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e0 [2] = { + { 0x5bc, 0xfb40 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e1 [2] = { + { 0x5bc, 0xfb41 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e3 [2] = { + { 0x5bc, 0xfb43 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e4 [3] = { + { 0x5bc, 0xfb44 }, + { 0x5bf, 0xfb4e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e6 [2] = { + { 0x5bc, 0xfb46 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e7 [2] = { + { 0x5bc, 0xfb47 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e8 [2] = { + { 0x5bc, 0xfb48 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005e9 [4] = { + { 0x5bc, 0xfb49 }, + { 0x5c1, 0xfb2a }, + { 0x5c2, 0xfb2b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005ea [2] = { + { 0x5bc, 0xfb4a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0005f2 [2] = { + { 0x5b7, 0xfb1f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000627 [4] = { + { 0x653, 0x622 }, + { 0x654, 0x623 }, + { 0x655, 0x625 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000648 [2] = { + { 0x654, 0x624 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00064a [2] = { + { 0x654, 0x626 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0006c1 [2] = { + { 0x654, 0x6c2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0006d2 [2] = { + { 0x654, 0x6d3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0006d5 [2] = { + { 0x654, 0x6c0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000915 [2] = { + { 0x93c, 0x958 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000916 [2] = { + { 0x93c, 0x959 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000917 [2] = { + { 0x93c, 0x95a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00091c [2] = { + { 0x93c, 0x95b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000921 [2] = { + { 0x93c, 0x95c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000922 [2] = { + { 0x93c, 0x95d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000928 [2] = { + { 0x93c, 0x929 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00092b [2] = { + { 0x93c, 0x95e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00092f [2] = { + { 0x93c, 0x95f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000930 [2] = { + { 0x93c, 0x931 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000933 [2] = { + { 0x93c, 0x934 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0009a1 [2] = { + { 0x9bc, 0x9dc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0009a2 [2] = { + { 0x9bc, 0x9dd }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0009af [2] = { + { 0x9bc, 0x9df }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0009c7 [3] = { + { 0x9be, 0x9cb }, + { 0x9d7, 0x9cc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a16 [2] = { + { 0xa3c, 0xa59 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a17 [2] = { + { 0xa3c, 0xa5a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a1c [2] = { + { 0xa3c, 0xa5b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a2b [2] = { + { 0xa3c, 0xa5e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a32 [2] = { + { 0xa3c, 0xa33 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000a38 [2] = { + { 0xa3c, 0xa36 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000b21 [2] = { + { 0xb3c, 0xb5c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000b22 [2] = { + { 0xb3c, 0xb5d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000b47 [4] = { + { 0xb3e, 0xb4b }, + { 0xb56, 0xb48 }, + { 0xb57, 0xb4c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000b92 [2] = { + { 0xbd7, 0xb94 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000bc6 [3] = { + { 0xbbe, 0xbca }, + { 0xbd7, 0xbcc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000bc7 [2] = { + { 0xbbe, 0xbcb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000c46 [2] = { + { 0xc56, 0xc48 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000cbf [2] = { + { 0xcd5, 0xcc0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000cc6 [4] = { + { 0xcc2, 0xcca }, + { 0xcd5, 0xcc7 }, + { 0xcd6, 0xcc8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000cca [2] = { + { 0xcd5, 0xccb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000d46 [3] = { + { 0xd3e, 0xd4a }, + { 0xd57, 0xd4c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000d47 [2] = { + { 0xd3e, 0xd4b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000dd9 [4] = { + { 0xdca, 0xdda }, + { 0xdcf, 0xddc }, + { 0xddf, 0xdde }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000ddc [2] = { + { 0xdca, 0xddd }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f40 [2] = { + { 0xfb5, 0xf69 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f42 [2] = { + { 0xfb7, 0xf43 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f4c [2] = { + { 0xfb7, 0xf4d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f51 [2] = { + { 0xfb7, 0xf52 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f56 [2] = { + { 0xfb7, 0xf57 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f5b [2] = { + { 0xfb7, 0xf5c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f90 [2] = { + { 0xfb5, 0xfb9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f92 [2] = { + { 0xfb7, 0xf93 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000f9c [2] = { + { 0xfb7, 0xf9d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000fa1 [2] = { + { 0xfb7, 0xfa2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000fa6 [2] = { + { 0xfb7, 0xfa7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000fab [2] = { + { 0xfb7, 0xfac }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000fb2 [2] = { + { 0xf80, 0xf76 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_000fb3 [2] = { + { 0xf80, 0xf78 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001025 [2] = { + { 0x102e, 0x1026 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b05 [2] = { + { 0x1b35, 0x1b06 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b07 [2] = { + { 0x1b35, 0x1b08 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b09 [2] = { + { 0x1b35, 0x1b0a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b0b [2] = { + { 0x1b35, 0x1b0c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b0d [2] = { + { 0x1b35, 0x1b0e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b11 [2] = { + { 0x1b35, 0x1b12 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b3a [2] = { + { 0x1b35, 0x1b3b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b3c [2] = { + { 0x1b35, 0x1b3d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b3e [2] = { + { 0x1b35, 0x1b40 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b3f [2] = { + { 0x1b35, 0x1b41 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001b42 [2] = { + { 0x1b35, 0x1b43 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e36 [2] = { + { 0x304, 0x1e38 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e37 [2] = { + { 0x304, 0x1e39 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e5a [2] = { + { 0x304, 0x1e5c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e5b [2] = { + { 0x304, 0x1e5d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e62 [2] = { + { 0x307, 0x1e68 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001e63 [2] = { + { 0x307, 0x1e69 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ea0 [3] = { + { 0x302, 0x1eac }, + { 0x306, 0x1eb6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ea1 [3] = { + { 0x302, 0x1ead }, + { 0x306, 0x1eb7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001eb8 [2] = { + { 0x302, 0x1ec6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001eb9 [2] = { + { 0x302, 0x1ec7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ecc [2] = { + { 0x302, 0x1ed8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ecd [2] = { + { 0x302, 0x1ed9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f00 [5] = { + { 0x300, 0x1f02 }, + { 0x301, 0x1f04 }, + { 0x342, 0x1f06 }, + { 0x345, 0x1f80 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f01 [5] = { + { 0x300, 0x1f03 }, + { 0x301, 0x1f05 }, + { 0x342, 0x1f07 }, + { 0x345, 0x1f81 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f02 [2] = { + { 0x345, 0x1f82 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f03 [2] = { + { 0x345, 0x1f83 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f04 [2] = { + { 0x345, 0x1f84 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f05 [2] = { + { 0x345, 0x1f85 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f06 [2] = { + { 0x345, 0x1f86 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f07 [2] = { + { 0x345, 0x1f87 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f08 [5] = { + { 0x300, 0x1f0a }, + { 0x301, 0x1f0c }, + { 0x342, 0x1f0e }, + { 0x345, 0x1f88 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f09 [5] = { + { 0x300, 0x1f0b }, + { 0x301, 0x1f0d }, + { 0x342, 0x1f0f }, + { 0x345, 0x1f89 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0a [2] = { + { 0x345, 0x1f8a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0b [2] = { + { 0x345, 0x1f8b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0c [2] = { + { 0x345, 0x1f8c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0d [2] = { + { 0x345, 0x1f8d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0e [2] = { + { 0x345, 0x1f8e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f0f [2] = { + { 0x345, 0x1f8f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f10 [3] = { + { 0x300, 0x1f12 }, + { 0x301, 0x1f14 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f11 [3] = { + { 0x300, 0x1f13 }, + { 0x301, 0x1f15 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f18 [3] = { + { 0x300, 0x1f1a }, + { 0x301, 0x1f1c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f19 [3] = { + { 0x300, 0x1f1b }, + { 0x301, 0x1f1d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f20 [5] = { + { 0x300, 0x1f22 }, + { 0x301, 0x1f24 }, + { 0x342, 0x1f26 }, + { 0x345, 0x1f90 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f21 [5] = { + { 0x300, 0x1f23 }, + { 0x301, 0x1f25 }, + { 0x342, 0x1f27 }, + { 0x345, 0x1f91 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f22 [2] = { + { 0x345, 0x1f92 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f23 [2] = { + { 0x345, 0x1f93 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f24 [2] = { + { 0x345, 0x1f94 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f25 [2] = { + { 0x345, 0x1f95 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f26 [2] = { + { 0x345, 0x1f96 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f27 [2] = { + { 0x345, 0x1f97 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f28 [5] = { + { 0x300, 0x1f2a }, + { 0x301, 0x1f2c }, + { 0x342, 0x1f2e }, + { 0x345, 0x1f98 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f29 [5] = { + { 0x300, 0x1f2b }, + { 0x301, 0x1f2d }, + { 0x342, 0x1f2f }, + { 0x345, 0x1f99 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2a [2] = { + { 0x345, 0x1f9a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2b [2] = { + { 0x345, 0x1f9b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2c [2] = { + { 0x345, 0x1f9c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2d [2] = { + { 0x345, 0x1f9d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2e [2] = { + { 0x345, 0x1f9e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f2f [2] = { + { 0x345, 0x1f9f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f30 [4] = { + { 0x300, 0x1f32 }, + { 0x301, 0x1f34 }, + { 0x342, 0x1f36 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f31 [4] = { + { 0x300, 0x1f33 }, + { 0x301, 0x1f35 }, + { 0x342, 0x1f37 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f38 [4] = { + { 0x300, 0x1f3a }, + { 0x301, 0x1f3c }, + { 0x342, 0x1f3e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f39 [4] = { + { 0x300, 0x1f3b }, + { 0x301, 0x1f3d }, + { 0x342, 0x1f3f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f40 [3] = { + { 0x300, 0x1f42 }, + { 0x301, 0x1f44 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f41 [3] = { + { 0x300, 0x1f43 }, + { 0x301, 0x1f45 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f48 [3] = { + { 0x300, 0x1f4a }, + { 0x301, 0x1f4c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f49 [3] = { + { 0x300, 0x1f4b }, + { 0x301, 0x1f4d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f50 [4] = { + { 0x300, 0x1f52 }, + { 0x301, 0x1f54 }, + { 0x342, 0x1f56 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f51 [4] = { + { 0x300, 0x1f53 }, + { 0x301, 0x1f55 }, + { 0x342, 0x1f57 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f59 [4] = { + { 0x300, 0x1f5b }, + { 0x301, 0x1f5d }, + { 0x342, 0x1f5f }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f60 [5] = { + { 0x300, 0x1f62 }, + { 0x301, 0x1f64 }, + { 0x342, 0x1f66 }, + { 0x345, 0x1fa0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f61 [5] = { + { 0x300, 0x1f63 }, + { 0x301, 0x1f65 }, + { 0x342, 0x1f67 }, + { 0x345, 0x1fa1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f62 [2] = { + { 0x345, 0x1fa2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f63 [2] = { + { 0x345, 0x1fa3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f64 [2] = { + { 0x345, 0x1fa4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f65 [2] = { + { 0x345, 0x1fa5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f66 [2] = { + { 0x345, 0x1fa6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f67 [2] = { + { 0x345, 0x1fa7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f68 [5] = { + { 0x300, 0x1f6a }, + { 0x301, 0x1f6c }, + { 0x342, 0x1f6e }, + { 0x345, 0x1fa8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f69 [5] = { + { 0x300, 0x1f6b }, + { 0x301, 0x1f6d }, + { 0x342, 0x1f6f }, + { 0x345, 0x1fa9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6a [2] = { + { 0x345, 0x1faa }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6b [2] = { + { 0x345, 0x1fab }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6c [2] = { + { 0x345, 0x1fac }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6d [2] = { + { 0x345, 0x1fad }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6e [2] = { + { 0x345, 0x1fae }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f6f [2] = { + { 0x345, 0x1faf }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f70 [2] = { + { 0x345, 0x1fb2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f74 [2] = { + { 0x345, 0x1fc2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001f7c [2] = { + { 0x345, 0x1ff2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001fb6 [2] = { + { 0x345, 0x1fb7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001fbf [4] = { + { 0x300, 0x1fcd }, + { 0x301, 0x1fce }, + { 0x342, 0x1fcf }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001fc6 [2] = { + { 0x345, 0x1fc7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ff6 [2] = { + { 0x345, 0x1ff7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_001ffe [4] = { + { 0x300, 0x1fdd }, + { 0x301, 0x1fde }, + { 0x342, 0x1fdf }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002190 [2] = { + { 0x338, 0x219a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002192 [2] = { + { 0x338, 0x219b }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002194 [2] = { + { 0x338, 0x21ae }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0021d0 [2] = { + { 0x338, 0x21cd }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0021d2 [2] = { + { 0x338, 0x21cf }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0021d4 [2] = { + { 0x338, 0x21ce }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002203 [2] = { + { 0x338, 0x2204 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002208 [2] = { + { 0x338, 0x2209 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00220b [2] = { + { 0x338, 0x220c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002223 [2] = { + { 0x338, 0x2224 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002225 [2] = { + { 0x338, 0x2226 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00223c [2] = { + { 0x338, 0x2241 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002243 [2] = { + { 0x338, 0x2244 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002245 [2] = { + { 0x338, 0x2247 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002248 [2] = { + { 0x338, 0x2249 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00224d [2] = { + { 0x338, 0x226d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002261 [2] = { + { 0x338, 0x2262 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002264 [2] = { + { 0x338, 0x2270 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002265 [2] = { + { 0x338, 0x2271 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002272 [2] = { + { 0x338, 0x2274 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002273 [2] = { + { 0x338, 0x2275 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002276 [2] = { + { 0x338, 0x2278 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002277 [2] = { + { 0x338, 0x2279 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00227a [2] = { + { 0x338, 0x2280 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00227b [2] = { + { 0x338, 0x2281 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00227c [2] = { + { 0x338, 0x22e0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00227d [2] = { + { 0x338, 0x22e1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002282 [2] = { + { 0x338, 0x2284 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002283 [2] = { + { 0x338, 0x2285 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002286 [2] = { + { 0x338, 0x2288 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002287 [2] = { + { 0x338, 0x2289 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002291 [2] = { + { 0x338, 0x22e2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002292 [2] = { + { 0x338, 0x22e3 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022a2 [2] = { + { 0x338, 0x22ac }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022a8 [2] = { + { 0x338, 0x22ad }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022a9 [2] = { + { 0x338, 0x22ae }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022ab [2] = { + { 0x338, 0x22af }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022b2 [2] = { + { 0x338, 0x22ea }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022b3 [2] = { + { 0x338, 0x22eb }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022b4 [2] = { + { 0x338, 0x22ec }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0022b5 [2] = { + { 0x338, 0x22ed }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_002add [2] = { + { 0x338, 0x2adc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003046 [2] = { + { 0x3099, 0x3094 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00304b [2] = { + { 0x3099, 0x304c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00304d [2] = { + { 0x3099, 0x304e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00304f [2] = { + { 0x3099, 0x3050 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003051 [2] = { + { 0x3099, 0x3052 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003053 [2] = { + { 0x3099, 0x3054 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003055 [2] = { + { 0x3099, 0x3056 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003057 [2] = { + { 0x3099, 0x3058 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003059 [2] = { + { 0x3099, 0x305a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00305b [2] = { + { 0x3099, 0x305c }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00305d [2] = { + { 0x3099, 0x305e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00305f [2] = { + { 0x3099, 0x3060 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003061 [2] = { + { 0x3099, 0x3062 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003064 [2] = { + { 0x3099, 0x3065 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003066 [2] = { + { 0x3099, 0x3067 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003068 [2] = { + { 0x3099, 0x3069 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00306f [3] = { + { 0x3099, 0x3070 }, + { 0x309a, 0x3071 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003072 [3] = { + { 0x3099, 0x3073 }, + { 0x309a, 0x3074 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003075 [3] = { + { 0x3099, 0x3076 }, + { 0x309a, 0x3077 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_003078 [3] = { + { 0x3099, 0x3079 }, + { 0x309a, 0x307a }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00307b [3] = { + { 0x3099, 0x307c }, + { 0x309a, 0x307d }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00309d [2] = { + { 0x3099, 0x309e }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030a6 [2] = { + { 0x3099, 0x30f4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030ab [2] = { + { 0x3099, 0x30ac }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030ad [2] = { + { 0x3099, 0x30ae }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030af [2] = { + { 0x3099, 0x30b0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030b1 [2] = { + { 0x3099, 0x30b2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030b3 [2] = { + { 0x3099, 0x30b4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030b5 [2] = { + { 0x3099, 0x30b6 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030b7 [2] = { + { 0x3099, 0x30b8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030b9 [2] = { + { 0x3099, 0x30ba }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030bb [2] = { + { 0x3099, 0x30bc }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030bd [2] = { + { 0x3099, 0x30be }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030bf [2] = { + { 0x3099, 0x30c0 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030c1 [2] = { + { 0x3099, 0x30c2 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030c4 [2] = { + { 0x3099, 0x30c5 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030c6 [2] = { + { 0x3099, 0x30c7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030c8 [2] = { + { 0x3099, 0x30c9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030cf [3] = { + { 0x3099, 0x30d0 }, + { 0x309a, 0x30d1 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030d2 [3] = { + { 0x3099, 0x30d3 }, + { 0x309a, 0x30d4 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030d5 [3] = { + { 0x3099, 0x30d6 }, + { 0x309a, 0x30d7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030d8 [3] = { + { 0x3099, 0x30d9 }, + { 0x309a, 0x30da }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030db [3] = { + { 0x3099, 0x30dc }, + { 0x309a, 0x30dd }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030ef [2] = { + { 0x3099, 0x30f7 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030f0 [2] = { + { 0x3099, 0x30f8 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030f1 [2] = { + { 0x3099, 0x30f9 }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030f2 [2] = { + { 0x3099, 0x30fa }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_0030fd [2] = { + { 0x3099, 0x30fe }, { 0, 0 }}; +static const UN8IF_complist_s UN8IF_complist_00fb49 [3] = { + { 0x5c1, 0xfb2c }, + { 0x5c2, 0xfb2d }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_011099 [2] = { + { 0x110ba, 0x1109a }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01109b [2] = { + { 0x110ba, 0x1109c }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_0110a5 [2] = { + { 0x110ba, 0x110ab }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_011131 [2] = { + { 0x11127, 0x1112e }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_011132 [2] = { + { 0x11127, 0x1112f }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_011347 [3] = { + { 0x1133e, 0x1134b }, + { 0x11357, 0x1134c }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_0114b9 [4] = { + { 0x114b0, 0x114bc }, + { 0x114ba, 0x114bb }, + { 0x114bd, 0x114be }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_0115b8 [2] = { + { 0x115af, 0x115ba }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_0115b9 [2] = { + { 0x115af, 0x115bb }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_011935 [2] = { + { 0x11930, 0x11938 }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d157 [2] = { + { 0x1d165, 0x1d15e }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d158 [2] = { + { 0x1d165, 0x1d15f }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d15f [6] = { + { 0x1d16e, 0x1d160 }, + { 0x1d16f, 0x1d161 }, + { 0x1d170, 0x1d162 }, + { 0x1d171, 0x1d163 }, + { 0x1d172, 0x1d164 }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d1b9 [2] = { + { 0x1d165, 0x1d1bb }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d1ba [2] = { + { 0x1d165, 0x1d1bc }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d1bb [3] = { + { 0x1d16e, 0x1d1bd }, + { 0x1d16f, 0x1d1bf }, { 0, 0 }}; +static const UN8IF_complist UN8IF_complist_01d1bc [3] = { + { 0x1d16e, 0x1d1be }, + { 0x1d16f, 0x1d1c0 }, { 0, 0 }}; +/* the rows */ +static const UN8IF_complist_s * UN8IF_compos_00_00 [256] = { +/* 0000 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0008 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0010 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0018 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0020 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0028 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0030 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0038 */ NULL, NULL, NULL, NULL, UN8IF_complist_00003c, UN8IF_complist_00003d, UN8IF_complist_00003e, NULL, +/* 0040 */ NULL, UN8IF_complist_000041, UN8IF_complist_000042, UN8IF_complist_000043, UN8IF_complist_000044, UN8IF_complist_000045, UN8IF_complist_000046, UN8IF_complist_000047, +/* 0048 */ UN8IF_complist_000048, UN8IF_complist_000049, UN8IF_complist_00004a, UN8IF_complist_00004b, UN8IF_complist_00004c, UN8IF_complist_00004d, UN8IF_complist_00004e, UN8IF_complist_00004f, +/* 0050 */ UN8IF_complist_000050, NULL, UN8IF_complist_000052, UN8IF_complist_000053, UN8IF_complist_000054, UN8IF_complist_000055, UN8IF_complist_000056, UN8IF_complist_000057, +/* 0058 */ UN8IF_complist_000058, UN8IF_complist_000059, UN8IF_complist_00005a, NULL, NULL, NULL, NULL, NULL, +/* 0060 */ NULL, UN8IF_complist_000061, UN8IF_complist_000062, UN8IF_complist_000063, UN8IF_complist_000064, UN8IF_complist_000065, UN8IF_complist_000066, UN8IF_complist_000067, +/* 0068 */ UN8IF_complist_000068, UN8IF_complist_000069, UN8IF_complist_00006a, UN8IF_complist_00006b, UN8IF_complist_00006c, UN8IF_complist_00006d, UN8IF_complist_00006e, UN8IF_complist_00006f, +/* 0070 */ UN8IF_complist_000070, NULL, UN8IF_complist_000072, UN8IF_complist_000073, UN8IF_complist_000074, UN8IF_complist_000075, UN8IF_complist_000076, UN8IF_complist_000077, +/* 0078 */ UN8IF_complist_000078, UN8IF_complist_000079, UN8IF_complist_00007a, NULL, NULL, NULL, NULL, NULL, +/* 0080 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0088 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0090 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0098 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 00a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 00a8 */ UN8IF_complist_0000a8, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 00b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 00b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 00c0 */ NULL, NULL, UN8IF_complist_0000c2, NULL, UN8IF_complist_0000c4, UN8IF_complist_0000c5, UN8IF_complist_0000c6, UN8IF_complist_0000c7, +/* 00c8 */ NULL, NULL, UN8IF_complist_0000ca, NULL, NULL, NULL, NULL, UN8IF_complist_0000cf, +/* 00d0 */ NULL, NULL, NULL, NULL, UN8IF_complist_0000d4, UN8IF_complist_0000d5, UN8IF_complist_0000d6, NULL, +/* 00d8 */ UN8IF_complist_0000d8, NULL, NULL, NULL, UN8IF_complist_0000dc, NULL, NULL, NULL, +/* 00e0 */ NULL, NULL, UN8IF_complist_0000e2, NULL, UN8IF_complist_0000e4, UN8IF_complist_0000e5, UN8IF_complist_0000e6, UN8IF_complist_0000e7, +/* 00e8 */ NULL, NULL, UN8IF_complist_0000ea, NULL, NULL, NULL, NULL, UN8IF_complist_0000ef, +/* 00f0 */ NULL, NULL, NULL, NULL, UN8IF_complist_0000f4, UN8IF_complist_0000f5, UN8IF_complist_0000f6, NULL, +/* 00f8 */ UN8IF_complist_0000f8, NULL, NULL, NULL, UN8IF_complist_0000fc, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_01 [256] = { +/* 0100 */ NULL, NULL, UN8IF_complist_000102, UN8IF_complist_000103, NULL, NULL, NULL, NULL, +/* 0108 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110 */ NULL, NULL, UN8IF_complist_000112, UN8IF_complist_000113, NULL, NULL, NULL, NULL, +/* 0118 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0120 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0128 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0130 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0138 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0140 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0148 */ NULL, NULL, NULL, NULL, UN8IF_complist_00014c, UN8IF_complist_00014d, NULL, NULL, +/* 0150 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0158 */ NULL, NULL, UN8IF_complist_00015a, UN8IF_complist_00015b, NULL, NULL, NULL, NULL, +/* 0160 */ UN8IF_complist_000160, UN8IF_complist_000161, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0168 */ UN8IF_complist_000168, UN8IF_complist_000169, UN8IF_complist_00016a, UN8IF_complist_00016b, NULL, NULL, NULL, NULL, +/* 0170 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0178 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_00017f, +/* 0180 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0188 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0190 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0198 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01a0 */ UN8IF_complist_0001a0, UN8IF_complist_0001a1, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0001af, +/* 01b0 */ UN8IF_complist_0001b0, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0001b7, +/* 01b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01e8 */ NULL, NULL, UN8IF_complist_0001ea, UN8IF_complist_0001eb, NULL, NULL, NULL, NULL, +/* 01f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_02 [256] = { +/* 0200 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0208 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0210 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0218 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0220 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000226, UN8IF_complist_000227, +/* 0228 */ UN8IF_complist_000228, UN8IF_complist_000229, NULL, NULL, NULL, NULL, UN8IF_complist_00022e, UN8IF_complist_00022f, +/* 0230 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0238 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0240 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0248 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0250 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0258 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0260 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0268 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0270 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0278 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0280 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0288 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0290 */ NULL, NULL, UN8IF_complist_000292, NULL, NULL, NULL, NULL, NULL, +/* 0298 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 02f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_03 [256] = { +/* 0300 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0308 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0310 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0318 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0320 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0328 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0330 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0338 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0340 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0348 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0350 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0358 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0360 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0368 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0370 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0378 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0380 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0388 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0390 */ NULL, UN8IF_complist_000391, NULL, NULL, NULL, UN8IF_complist_000395, NULL, UN8IF_complist_000397, +/* 0398 */ NULL, UN8IF_complist_000399, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_00039f, +/* 03a0 */ NULL, UN8IF_complist_0003a1, NULL, NULL, NULL, UN8IF_complist_0003a5, NULL, NULL, +/* 03a8 */ NULL, UN8IF_complist_0003a9, NULL, NULL, UN8IF_complist_0003ac, NULL, UN8IF_complist_0003ae, NULL, +/* 03b0 */ NULL, UN8IF_complist_0003b1, NULL, NULL, NULL, UN8IF_complist_0003b5, NULL, UN8IF_complist_0003b7, +/* 03b8 */ NULL, UN8IF_complist_0003b9, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0003bf, +/* 03c0 */ NULL, UN8IF_complist_0003c1, NULL, NULL, NULL, UN8IF_complist_0003c5, NULL, NULL, +/* 03c8 */ NULL, UN8IF_complist_0003c9, UN8IF_complist_0003ca, UN8IF_complist_0003cb, NULL, NULL, UN8IF_complist_0003ce, NULL, +/* 03d0 */ NULL, NULL, UN8IF_complist_0003d2, NULL, NULL, NULL, NULL, NULL, +/* 03d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 03e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 03e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 03f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 03f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_04 [256] = { +/* 0400 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000406, NULL, +/* 0408 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0410 */ UN8IF_complist_000410, NULL, NULL, UN8IF_complist_000413, NULL, UN8IF_complist_000415, UN8IF_complist_000416, UN8IF_complist_000417, +/* 0418 */ UN8IF_complist_000418, NULL, UN8IF_complist_00041a, NULL, NULL, NULL, UN8IF_complist_00041e, NULL, +/* 0420 */ NULL, NULL, NULL, UN8IF_complist_000423, NULL, NULL, NULL, UN8IF_complist_000427, +/* 0428 */ NULL, NULL, NULL, UN8IF_complist_00042b, NULL, UN8IF_complist_00042d, NULL, NULL, +/* 0430 */ UN8IF_complist_000430, NULL, NULL, UN8IF_complist_000433, NULL, UN8IF_complist_000435, UN8IF_complist_000436, UN8IF_complist_000437, +/* 0438 */ UN8IF_complist_000438, NULL, UN8IF_complist_00043a, NULL, NULL, NULL, UN8IF_complist_00043e, NULL, +/* 0440 */ NULL, NULL, NULL, UN8IF_complist_000443, NULL, NULL, NULL, UN8IF_complist_000447, +/* 0448 */ NULL, NULL, NULL, UN8IF_complist_00044b, NULL, UN8IF_complist_00044d, NULL, NULL, +/* 0450 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000456, NULL, +/* 0458 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0460 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0468 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0470 */ NULL, NULL, NULL, NULL, UN8IF_complist_000474, UN8IF_complist_000475, NULL, NULL, +/* 0478 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0480 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0488 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0490 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0498 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04d8 */ UN8IF_complist_0004d8, UN8IF_complist_0004d9, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04e8 */ UN8IF_complist_0004e8, UN8IF_complist_0004e9, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 04f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_05 [256] = { +/* 0500 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0508 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0510 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0518 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0520 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0528 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0530 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0538 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0540 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0548 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0550 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0558 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0560 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0568 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0570 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0578 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0580 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0588 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0590 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0598 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 05d0 */ UN8IF_complist_0005d0, UN8IF_complist_0005d1, UN8IF_complist_0005d2, UN8IF_complist_0005d3, UN8IF_complist_0005d4, UN8IF_complist_0005d5, UN8IF_complist_0005d6, NULL, +/* 05d8 */ UN8IF_complist_0005d8, UN8IF_complist_0005d9, UN8IF_complist_0005da, UN8IF_complist_0005db, UN8IF_complist_0005dc, NULL, UN8IF_complist_0005de, NULL, +/* 05e0 */ UN8IF_complist_0005e0, UN8IF_complist_0005e1, NULL, UN8IF_complist_0005e3, UN8IF_complist_0005e4, NULL, UN8IF_complist_0005e6, UN8IF_complist_0005e7, +/* 05e8 */ UN8IF_complist_0005e8, UN8IF_complist_0005e9, UN8IF_complist_0005ea, NULL, NULL, NULL, NULL, NULL, +/* 05f0 */ NULL, NULL, UN8IF_complist_0005f2, NULL, NULL, NULL, NULL, NULL, +/* 05f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_06 [256] = { +/* 0600 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0608 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0610 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0618 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0620 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000627, +/* 0628 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0630 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0638 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0640 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0648 */ UN8IF_complist_000648, NULL, UN8IF_complist_00064a, NULL, NULL, NULL, NULL, NULL, +/* 0650 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0658 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0660 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0668 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0670 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0678 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0680 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0688 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0690 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0698 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06c0 */ NULL, UN8IF_complist_0006c1, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06d0 */ NULL, NULL, UN8IF_complist_0006d2, NULL, NULL, UN8IF_complist_0006d5, NULL, NULL, +/* 06d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 06f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_09 [256] = { +/* 0900 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0908 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0910 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000915, UN8IF_complist_000916, UN8IF_complist_000917, +/* 0918 */ NULL, NULL, NULL, NULL, UN8IF_complist_00091c, NULL, NULL, NULL, +/* 0920 */ NULL, UN8IF_complist_000921, UN8IF_complist_000922, NULL, NULL, NULL, NULL, NULL, +/* 0928 */ UN8IF_complist_000928, NULL, NULL, UN8IF_complist_00092b, NULL, NULL, NULL, UN8IF_complist_00092f, +/* 0930 */ UN8IF_complist_000930, NULL, NULL, UN8IF_complist_000933, NULL, NULL, NULL, NULL, +/* 0938 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0940 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0948 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0950 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0958 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0960 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0968 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0970 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0978 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0980 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0988 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0990 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0998 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09a0 */ NULL, UN8IF_complist_0009a1, UN8IF_complist_0009a2, NULL, NULL, NULL, NULL, NULL, +/* 09a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0009af, +/* 09b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0009c7, +/* 09c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 09f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_0a [256] = { +/* 0a00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a10 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000a16, UN8IF_complist_000a17, +/* 0a18 */ NULL, NULL, NULL, NULL, UN8IF_complist_000a1c, NULL, NULL, NULL, +/* 0a20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a28 */ NULL, NULL, NULL, UN8IF_complist_000a2b, NULL, NULL, NULL, NULL, +/* 0a30 */ NULL, NULL, UN8IF_complist_000a32, NULL, NULL, NULL, NULL, NULL, +/* 0a38 */ UN8IF_complist_000a38, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a40 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0a98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0aa0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0aa8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ab0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ab8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ac0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ac8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ad0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ad8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ae0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ae8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0af0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0af8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_0b [256] = { +/* 0b00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b20 */ NULL, UN8IF_complist_000b21, UN8IF_complist_000b22, NULL, NULL, NULL, NULL, NULL, +/* 0b28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b40 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000b47, +/* 0b48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0b90 */ NULL, NULL, UN8IF_complist_000b92, NULL, NULL, NULL, NULL, NULL, +/* 0b98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ba0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ba8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bb0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bc0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000bc6, UN8IF_complist_000bc7, +/* 0bc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0be0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0be8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bf0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0bf8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_0c [256] = { +/* 0c00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c40 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000c46, NULL, +/* 0c48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0c98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ca0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ca8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0cb0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0cb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000cbf, +/* 0cc0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000cc6, NULL, +/* 0cc8 */ NULL, NULL, UN8IF_complist_000cca, NULL, NULL, NULL, NULL, NULL, +/* 0cd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0cd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ce0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ce8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0cf0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0cf8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_0d [256] = { +/* 0d00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d40 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_000d46, UN8IF_complist_000d47, +/* 0d48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0d98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0da0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0da8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0db0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0db8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0dc0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0dc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0dd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0dd8 */ NULL, UN8IF_complist_000dd9, NULL, NULL, UN8IF_complist_000ddc, NULL, NULL, NULL, +/* 0de0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0de8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0df0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0df8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_0f [256] = { +/* 0f00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f40 */ UN8IF_complist_000f40, NULL, UN8IF_complist_000f42, NULL, NULL, NULL, NULL, NULL, +/* 0f48 */ NULL, NULL, NULL, NULL, UN8IF_complist_000f4c, NULL, NULL, NULL, +/* 0f50 */ NULL, UN8IF_complist_000f51, NULL, NULL, NULL, NULL, UN8IF_complist_000f56, NULL, +/* 0f58 */ NULL, NULL, NULL, UN8IF_complist_000f5b, NULL, NULL, NULL, NULL, +/* 0f60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0f90 */ UN8IF_complist_000f90, NULL, UN8IF_complist_000f92, NULL, NULL, NULL, NULL, NULL, +/* 0f98 */ NULL, NULL, NULL, NULL, UN8IF_complist_000f9c, NULL, NULL, NULL, +/* 0fa0 */ NULL, UN8IF_complist_000fa1, NULL, NULL, NULL, NULL, UN8IF_complist_000fa6, NULL, +/* 0fa8 */ NULL, NULL, NULL, UN8IF_complist_000fab, NULL, NULL, NULL, NULL, +/* 0fb0 */ NULL, NULL, UN8IF_complist_000fb2, UN8IF_complist_000fb3, NULL, NULL, NULL, NULL, +/* 0fb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fc0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fe0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0fe8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ff0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0ff8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_10 [256] = { +/* 1000 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1008 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1010 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1018 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1020 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001025, NULL, NULL, +/* 1028 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1030 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1038 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1040 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1048 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1050 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1058 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1060 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1068 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1070 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1078 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1080 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1088 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1090 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1098 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 10f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_1b [256] = { +/* 1b00 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001b05, NULL, UN8IF_complist_001b07, +/* 1b08 */ NULL, UN8IF_complist_001b09, NULL, UN8IF_complist_001b0b, NULL, UN8IF_complist_001b0d, NULL, NULL, +/* 1b10 */ NULL, UN8IF_complist_001b11, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b38 */ NULL, NULL, UN8IF_complist_001b3a, NULL, UN8IF_complist_001b3c, NULL, UN8IF_complist_001b3e, UN8IF_complist_001b3f, +/* 1b40 */ NULL, NULL, UN8IF_complist_001b42, NULL, NULL, NULL, NULL, NULL, +/* 1b48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1b98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ba0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ba8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bb0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bc0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1be0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1be8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bf0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1bf8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_1e [256] = { +/* 1e00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e30 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001e36, UN8IF_complist_001e37, +/* 1e38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e40 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e58 */ NULL, NULL, UN8IF_complist_001e5a, UN8IF_complist_001e5b, NULL, NULL, NULL, NULL, +/* 1e60 */ NULL, NULL, UN8IF_complist_001e62, UN8IF_complist_001e63, NULL, NULL, NULL, NULL, +/* 1e68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1e98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ea0 */ UN8IF_complist_001ea0, UN8IF_complist_001ea1, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ea8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1eb0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1eb8 */ UN8IF_complist_001eb8, UN8IF_complist_001eb9, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ec0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ec8 */ NULL, NULL, NULL, NULL, UN8IF_complist_001ecc, UN8IF_complist_001ecd, NULL, NULL, +/* 1ed0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ed8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ee0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ee8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ef0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ef8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_1f [256] = { +/* 1f00 */ UN8IF_complist_001f00, UN8IF_complist_001f01, UN8IF_complist_001f02, UN8IF_complist_001f03, UN8IF_complist_001f04, UN8IF_complist_001f05, UN8IF_complist_001f06, UN8IF_complist_001f07, +/* 1f08 */ UN8IF_complist_001f08, UN8IF_complist_001f09, UN8IF_complist_001f0a, UN8IF_complist_001f0b, UN8IF_complist_001f0c, UN8IF_complist_001f0d, UN8IF_complist_001f0e, UN8IF_complist_001f0f, +/* 1f10 */ UN8IF_complist_001f10, UN8IF_complist_001f11, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f18 */ UN8IF_complist_001f18, UN8IF_complist_001f19, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f20 */ UN8IF_complist_001f20, UN8IF_complist_001f21, UN8IF_complist_001f22, UN8IF_complist_001f23, UN8IF_complist_001f24, UN8IF_complist_001f25, UN8IF_complist_001f26, UN8IF_complist_001f27, +/* 1f28 */ UN8IF_complist_001f28, UN8IF_complist_001f29, UN8IF_complist_001f2a, UN8IF_complist_001f2b, UN8IF_complist_001f2c, UN8IF_complist_001f2d, UN8IF_complist_001f2e, UN8IF_complist_001f2f, +/* 1f30 */ UN8IF_complist_001f30, UN8IF_complist_001f31, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f38 */ UN8IF_complist_001f38, UN8IF_complist_001f39, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f40 */ UN8IF_complist_001f40, UN8IF_complist_001f41, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f48 */ UN8IF_complist_001f48, UN8IF_complist_001f49, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f50 */ UN8IF_complist_001f50, UN8IF_complist_001f51, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f58 */ NULL, UN8IF_complist_001f59, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f60 */ UN8IF_complist_001f60, UN8IF_complist_001f61, UN8IF_complist_001f62, UN8IF_complist_001f63, UN8IF_complist_001f64, UN8IF_complist_001f65, UN8IF_complist_001f66, UN8IF_complist_001f67, +/* 1f68 */ UN8IF_complist_001f68, UN8IF_complist_001f69, UN8IF_complist_001f6a, UN8IF_complist_001f6b, UN8IF_complist_001f6c, UN8IF_complist_001f6d, UN8IF_complist_001f6e, UN8IF_complist_001f6f, +/* 1f70 */ UN8IF_complist_001f70, NULL, NULL, NULL, UN8IF_complist_001f74, NULL, NULL, NULL, +/* 1f78 */ NULL, NULL, NULL, NULL, UN8IF_complist_001f7c, NULL, NULL, NULL, +/* 1f80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1f98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fa0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fa8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fb0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001fb6, NULL, +/* 1fb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001fbf, +/* 1fc0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001fc6, NULL, +/* 1fc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fe0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1fe8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 1ff0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001ff6, NULL, +/* 1ff8 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_001ffe, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_21 [256] = { +/* 2100 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2108 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2110 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2118 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2120 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2128 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2130 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2138 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2140 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2148 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2150 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2158 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2160 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2168 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2170 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2178 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2180 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2188 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2190 */ UN8IF_complist_002190, NULL, UN8IF_complist_002192, NULL, UN8IF_complist_002194, NULL, NULL, NULL, +/* 2198 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21d0 */ UN8IF_complist_0021d0, NULL, UN8IF_complist_0021d2, NULL, UN8IF_complist_0021d4, NULL, NULL, NULL, +/* 21d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 21f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_22 [256] = { +/* 2200 */ NULL, NULL, NULL, UN8IF_complist_002203, NULL, NULL, NULL, NULL, +/* 2208 */ UN8IF_complist_002208, NULL, NULL, UN8IF_complist_00220b, NULL, NULL, NULL, NULL, +/* 2210 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2218 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2220 */ NULL, NULL, NULL, UN8IF_complist_002223, NULL, UN8IF_complist_002225, NULL, NULL, +/* 2228 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2230 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2238 */ NULL, NULL, NULL, NULL, UN8IF_complist_00223c, NULL, NULL, NULL, +/* 2240 */ NULL, NULL, NULL, UN8IF_complist_002243, NULL, UN8IF_complist_002245, NULL, NULL, +/* 2248 */ UN8IF_complist_002248, NULL, NULL, NULL, NULL, UN8IF_complist_00224d, NULL, NULL, +/* 2250 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2258 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2260 */ NULL, UN8IF_complist_002261, NULL, NULL, UN8IF_complist_002264, UN8IF_complist_002265, NULL, NULL, +/* 2268 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2270 */ NULL, NULL, UN8IF_complist_002272, UN8IF_complist_002273, NULL, NULL, UN8IF_complist_002276, UN8IF_complist_002277, +/* 2278 */ NULL, NULL, UN8IF_complist_00227a, UN8IF_complist_00227b, UN8IF_complist_00227c, UN8IF_complist_00227d, NULL, NULL, +/* 2280 */ NULL, NULL, UN8IF_complist_002282, UN8IF_complist_002283, NULL, NULL, UN8IF_complist_002286, UN8IF_complist_002287, +/* 2288 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2290 */ NULL, UN8IF_complist_002291, UN8IF_complist_002292, NULL, NULL, NULL, NULL, NULL, +/* 2298 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22a0 */ NULL, NULL, UN8IF_complist_0022a2, NULL, NULL, NULL, NULL, NULL, +/* 22a8 */ UN8IF_complist_0022a8, UN8IF_complist_0022a9, NULL, UN8IF_complist_0022ab, NULL, NULL, NULL, NULL, +/* 22b0 */ NULL, NULL, UN8IF_complist_0022b2, UN8IF_complist_0022b3, UN8IF_complist_0022b4, UN8IF_complist_0022b5, NULL, NULL, +/* 22b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 22f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_2a [256] = { +/* 2a00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a40 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a48 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2a98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2aa0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2aa8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ab0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ab8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ac0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ac8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ad0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ad8 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_002add, NULL, NULL, +/* 2ae0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2ae8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2af0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 2af8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_30 [256] = { +/* 3000 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3008 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3010 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3018 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3020 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3028 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3030 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3038 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3040 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_003046, NULL, +/* 3048 */ NULL, NULL, NULL, UN8IF_complist_00304b, NULL, UN8IF_complist_00304d, NULL, UN8IF_complist_00304f, +/* 3050 */ NULL, UN8IF_complist_003051, NULL, UN8IF_complist_003053, NULL, UN8IF_complist_003055, NULL, UN8IF_complist_003057, +/* 3058 */ NULL, UN8IF_complist_003059, NULL, UN8IF_complist_00305b, NULL, UN8IF_complist_00305d, NULL, UN8IF_complist_00305f, +/* 3060 */ NULL, UN8IF_complist_003061, NULL, NULL, UN8IF_complist_003064, NULL, UN8IF_complist_003066, NULL, +/* 3068 */ UN8IF_complist_003068, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_00306f, +/* 3070 */ NULL, NULL, UN8IF_complist_003072, NULL, NULL, UN8IF_complist_003075, NULL, NULL, +/* 3078 */ UN8IF_complist_003078, NULL, NULL, UN8IF_complist_00307b, NULL, NULL, NULL, NULL, +/* 3080 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3088 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3090 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 3098 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_00309d, NULL, NULL, +/* 30a0 */ NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0030a6, NULL, +/* 30a8 */ NULL, NULL, NULL, UN8IF_complist_0030ab, NULL, UN8IF_complist_0030ad, NULL, UN8IF_complist_0030af, +/* 30b0 */ NULL, UN8IF_complist_0030b1, NULL, UN8IF_complist_0030b3, NULL, UN8IF_complist_0030b5, NULL, UN8IF_complist_0030b7, +/* 30b8 */ NULL, UN8IF_complist_0030b9, NULL, UN8IF_complist_0030bb, NULL, UN8IF_complist_0030bd, NULL, UN8IF_complist_0030bf, +/* 30c0 */ NULL, UN8IF_complist_0030c1, NULL, NULL, UN8IF_complist_0030c4, NULL, UN8IF_complist_0030c6, NULL, +/* 30c8 */ UN8IF_complist_0030c8, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0030cf, +/* 30d0 */ NULL, NULL, UN8IF_complist_0030d2, NULL, NULL, UN8IF_complist_0030d5, NULL, NULL, +/* 30d8 */ UN8IF_complist_0030d8, NULL, NULL, UN8IF_complist_0030db, NULL, NULL, NULL, NULL, +/* 30e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 30e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0030ef, +/* 30f0 */ UN8IF_complist_0030f0, UN8IF_complist_0030f1, UN8IF_complist_0030f2, NULL, NULL, NULL, NULL, NULL, +/* 30f8 */ NULL, NULL, NULL, NULL, NULL, UN8IF_complist_0030fd, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_00_fb [256] = { +/* fb00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb08 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb18 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb20 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb28 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb30 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb38 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb40 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb48 */ NULL, UN8IF_complist_00fb49, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb58 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb68 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb78 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb80 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb88 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fb98 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fba0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fba8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbb0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbb8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbc0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbc8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbd0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbd8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbe0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbe8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbf0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* fbf8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_10 [256] = { +/* 011000 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011008 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011010 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011018 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011020 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011028 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011030 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011038 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011040 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011048 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011050 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011058 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011060 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011068 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011070 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011078 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011080 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011088 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011090 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011098 */ NULL, (const UN8IF_complist_s*)UN8IF_complist_011099, NULL, (const UN8IF_complist_s*)UN8IF_complist_01109b, NULL, NULL, NULL, NULL, +/* 0110a0 */ NULL, NULL, NULL, NULL, NULL, (const UN8IF_complist_s*)UN8IF_complist_0110a5, NULL, NULL, +/* 0110a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0110f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_11 [256] = { +/* 011100 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011108 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011110 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011118 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011120 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011128 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011130 */ NULL, (const UN8IF_complist_s*)UN8IF_complist_011131, (const UN8IF_complist_s*)UN8IF_complist_011132, NULL, NULL, NULL, NULL, NULL, +/* 011138 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011140 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011148 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011150 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011158 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011160 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011168 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011170 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011178 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011180 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011188 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011190 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011198 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0111f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_13 [256] = { +/* 011300 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011308 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011310 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011318 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011320 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011328 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011330 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011338 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011340 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, (const UN8IF_complist_s*)UN8IF_complist_011347, +/* 011348 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011350 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011358 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011360 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011368 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011370 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011378 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011380 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011388 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011390 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011398 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0113f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_14 [256] = { +/* 011400 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011408 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011410 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011418 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011420 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011428 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011430 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011438 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011440 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011448 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011450 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011458 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011460 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011468 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011470 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011478 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011480 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011488 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011490 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011498 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114b8 */ NULL, (const UN8IF_complist_s*)UN8IF_complist_0114b9, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0114f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_15 [256] = { +/* 011500 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011508 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011510 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011518 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011520 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011528 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011530 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011538 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011540 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011548 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011550 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011558 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011560 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011568 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011570 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011578 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011580 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011588 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011590 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011598 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115b8 */ (const UN8IF_complist_s*)UN8IF_complist_0115b8, (const UN8IF_complist_s*)UN8IF_complist_0115b9, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0115f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_19 [256] = { +/* 011900 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011908 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011910 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011918 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011920 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011928 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011930 */ NULL, NULL, NULL, NULL, NULL, (const UN8IF_complist_s*)UN8IF_complist_011935, NULL, NULL, +/* 011938 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011940 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011948 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011950 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011958 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011960 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011968 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011970 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011978 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011980 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011988 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011990 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 011998 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119b8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 0119f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +static const UN8IF_complist_s * UN8IF_compos_01_d1 [256] = { +/* 01d100 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d108 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d110 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d118 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d120 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d128 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d130 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d138 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d140 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d148 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d150 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, (const UN8IF_complist_s*)UN8IF_complist_01d157, +/* 01d158 */ (const UN8IF_complist_s*)UN8IF_complist_01d158, NULL, NULL, NULL, NULL, NULL, NULL, (const UN8IF_complist_s*)UN8IF_complist_01d15f, +/* 01d160 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d168 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d170 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d178 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d180 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d188 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d190 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d198 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1a0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1a8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1b0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1b8 */ NULL, (const UN8IF_complist_s*)UN8IF_complist_01d1b9, (const UN8IF_complist_s*)UN8IF_complist_01d1ba, (const UN8IF_complist_s*)UN8IF_complist_01d1bb, (const UN8IF_complist_s*)UN8IF_complist_01d1bc, NULL, NULL, NULL, +/* 01d1c0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1c8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1d0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1d8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1e8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 01d1f8 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +/* the planes */ +static const UN8IF_complist_s ** UN8IF_compos_00 [256] = { +UN8IF_compos_00_00, +UN8IF_compos_00_01, +UN8IF_compos_00_02, +UN8IF_compos_00_03, +UN8IF_compos_00_04, +UN8IF_compos_00_05, +UN8IF_compos_00_06, +NULL, +NULL,UN8IF_compos_00_09, +UN8IF_compos_00_0a, +UN8IF_compos_00_0b, +UN8IF_compos_00_0c, +UN8IF_compos_00_0d, +NULL,UN8IF_compos_00_0f, +UN8IF_compos_00_10, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_compos_00_1b, +NULL,NULL,UN8IF_compos_00_1e, +UN8IF_compos_00_1f, +NULL,UN8IF_compos_00_21, +UN8IF_compos_00_22, +NULL,NULL,NULL,NULL,NULL, +NULL,NULL,UN8IF_compos_00_2a, +NULL,NULL,NULL,NULL,NULL, +UN8IF_compos_00_30, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_compos_00_fb, +NULL,NULL,NULL,NULL +}; + +static const UN8IF_complist_s ** UN8IF_compos_01 [256] = { +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_compos_01_10, +UN8IF_compos_01_11, +NULL,UN8IF_compos_01_13, +UN8IF_compos_01_14, +UN8IF_compos_01_15, +NULL,NULL, +NULL,UN8IF_compos_01_19, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_compos_01_d1, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL +}; + +/* the main plane */ +static const UN8IF_complist_s *** UN8IF_compos [] = { +UN8IF_compos_00, +UN8IF_compos_01, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL +}; + diff --git a/src/extu8/un8ifcpt.h b/src/extu8/un8ifcpt.h new file mode 100644 index 000000000..012859863 --- /dev/null +++ b/src/extu8/un8ifcpt.h @@ -0,0 +1,3390 @@ +/* ex: set ro ft=c: -*- buffer-read-only: t -*- + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is auto-generated by Unicode-Normalize 1.27 + * mkheader -ind -std + * for Unicode 13.0.0 UTF-8 + * Any changes here will be lost! + */ +/* Compat. Decomposition */ + +/* Using now indirect tables with indices into the unique values */ +/* even sparing the final \0 */ + +#undef NORMALIZE_IND_TBL +#define NORMALIZE_IND_TBL +/* tbl sizes: (95,370,1796,508,282,393,2,77,45,,,40,,1,16,,1,12,,,,,,,,,,,,,,,1) */ +/* l: 1-33 */ +/* max size: 1796 0x704 */ +#define UN8IF_compat_MAXLEN 5 +#define TBL(i) ((i-1) << 11) +/* value = (const char*)&UN8IF_compat_tbl[LEN-1][IDX] */ +#define UN8IF_compat_LEN(v) (((v) >> 11) + 1) +#define UN8IF_compat_IDX(v) ((v) & 0x7ff) +#define UN8IF_compat_PLANE_T uint16_t + +/* the values */ +static const char UN8IF_compat_tbl_1 [95][1] = { + /* 0 */ {'!'}, {'"'}, {'#'}, {'$'}, {'%'}, {'&'}, {'('}, {')'}, + /* 8 */ {'*'}, {'+'}, {','}, {'-'}, {'.'}, {'/'}, {'0'}, {'1'}, + /* 16 */ {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, + /* 24 */ {':'}, {';'}, {'<'}, {'='}, {'>'}, {'?'}, {'@'}, {'A'}, + /* 32 */ {'B'}, {'C'}, {'D'}, {'E'}, {'F'}, {'G'}, {'H'}, {'I'}, + /* 40 */ {'J'}, {'K'}, {'L'}, {'M'}, {'N'}, {'O'}, {'P'}, {'Q'}, + /* 48 */ {'R'}, {'S'}, {'T'}, {'U'}, {'V'}, {'W'}, {'X'}, {'Y'}, + /* 56 */ {'Z'}, {'['}, {'\x20'}, {'\x27'}, {'\x5c'}, {']'}, {'^'}, {'_'}, + /* 64 */ {'`'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}, {'g'}, + /* 72 */ {'h'}, {'i'}, {'j'}, {'k'}, {'l'}, {'m'}, {'n'}, {'o'}, + /* 80 */ {'p'}, {'q'}, {'r'}, {'s'}, {'t'}, {'u'}, {'v'}, {'w'}, + /* 88 */ {'x'}, {'y'}, {'z'}, {'{'}, {'|'}, {'}'}, {'~'}}; + +static const char UN8IF_compat_tbl_2 [370][2] = { + /* 0 */ {'!','!'}, {'!','?'}, {'.','.'}, {'0',','}, {'0','.'}, {'1',','}, {'1','.'}, {'1','0'}, + /* 8 */ {'1','1'}, {'1','2'}, {'1','3'}, {'1','4'}, {'1','5'}, {'1','6'}, {'1','7'}, {'1','8'}, + /* 16 */ {'1','9'}, {'2',','}, {'2','.'}, {'2','0'}, {'2','1'}, {'2','2'}, {'2','3'}, {'2','4'}, + /* 24 */ {'2','5'}, {'2','6'}, {'2','7'}, {'2','8'}, {'2','9'}, {'3',','}, {'3','.'}, {'3','0'}, + /* 32 */ {'3','1'}, {'3','2'}, {'3','3'}, {'3','4'}, {'3','5'}, {'3','6'}, {'3','7'}, {'3','8'}, + /* 40 */ {'3','9'}, {'4',','}, {'4','.'}, {'4','0'}, {'4','1'}, {'4','2'}, {'4','3'}, {'4','4'}, + /* 48 */ {'4','5'}, {'4','6'}, {'4','7'}, {'4','8'}, {'4','9'}, {'5',','}, {'5','.'}, {'5','0'}, + /* 56 */ {'6',','}, {'6','.'}, {'7',','}, {'7','.'}, {'8',','}, {'8','.'}, {'9',','}, {'9','.'}, + /* 64 */ {'=','='}, {'?','!'}, {'?','?'}, {'A','U'}, {'B','q'}, {'C','D'}, {'D','J'}, {'D','Z'}, + /* 72 */ {'D','z'}, {'G','B'}, {'G','y'}, {'H','P'}, {'H','V'}, {'H','g'}, {'H','z'}, {'I','I'}, + /* 80 */ {'I','J'}, {'I','U'}, {'I','V'}, {'I','X'}, {'K','B'}, {'K','K'}, {'K','M'}, {'L','J'}, + /* 88 */ {'L','j'}, {'M','B'}, {'M','C'}, {'M','D'}, {'M','R'}, {'M','V'}, {'M','W'}, {'N','J'}, + /* 96 */ {'N','j'}, {'N','o'}, {'P','H'}, {'P','R'}, {'P','a'}, {'R','s'}, {'S','D'}, {'S','M'}, + /* 104 */ {'S','S'}, {'S','v'}, {'T','M'}, {'V','I'}, {'W','C'}, {'W','Z'}, {'W','b'}, {'X','I'}, + /* 112 */ {'\xc2','\xa2'}, {'\xc2','\xa3'}, {'\xc2','\xa5'}, {'\xc2','\xa6'}, {'\xc2','\xac'}, {'\xc2','\xb7'}, {'\xc3','\x86'}, {'\xc3','\xb0'}, + /* 120 */ {'\xc4','\xa6'}, {'\xc4','\xa7'}, {'\xc4','\xb1'}, {'\xc5','\x8b'}, {'\xc5','\x93'}, {'\xc6','\x8e'}, {'\xc6','\x90'}, {'\xc6','\xab'}, + /* 128 */ {'\xc8','\xa2'}, {'\xc8','\xb7'}, {'\xc9','\x90'}, {'\xc9','\x91'}, {'\xc9','\x92'}, {'\xc9','\x94'}, {'\xc9','\x95'}, {'\xc9','\x99'}, + /* 136 */ {'\xc9','\x9b'}, {'\xc9','\x9c'}, {'\xc9','\x9f'}, {'\xc9','\xa1'}, {'\xc9','\xa3'}, {'\xc9','\xa5'}, {'\xc9','\xa6'}, {'\xc9','\xa8'}, + /* 144 */ {'\xc9','\xa9'}, {'\xc9','\xaa'}, {'\xc9','\xab'}, {'\xc9','\xad'}, {'\xc9','\xaf'}, {'\xc9','\xb0'}, {'\xc9','\xb1'}, {'\xc9','\xb2'}, + /* 152 */ {'\xc9','\xb3'}, {'\xc9','\xb4'}, {'\xc9','\xb5'}, {'\xc9','\xb8'}, {'\xc9','\xb9'}, {'\xc9','\xbb'}, {'\xca','\x81'}, {'\xca','\x82'}, + /* 160 */ {'\xca','\x83'}, {'\xca','\x89'}, {'\xca','\x8a'}, {'\xca','\x8b'}, {'\xca','\x8c'}, {'\xca','\x8d'}, {'\xca','\x90'}, {'\xca','\x91'}, + /* 168 */ {'\xca','\x92'}, {'\xca','\x95'}, {'\xca','\x9d'}, {'\xca','\x9f'}, {'\xca','\xb9'}, {'\xcc','\x80'}, {'\xcc','\x81'}, {'\xcc','\x93'}, + /* 176 */ {'\xce','\x91'}, {'\xce','\x92'}, {'\xce','\x93'}, {'\xce','\x94'}, {'\xce','\x95'}, {'\xce','\x96'}, {'\xce','\x97'}, {'\xce','\x98'}, + /* 184 */ {'\xce','\x99'}, {'\xce','\x9a'}, {'\xce','\x9b'}, {'\xce','\x9c'}, {'\xce','\x9d'}, {'\xce','\x9e'}, {'\xce','\x9f'}, {'\xce','\xa0'}, + /* 192 */ {'\xce','\xa1'}, {'\xce','\xa3'}, {'\xce','\xa4'}, {'\xce','\xa5'}, {'\xce','\xa6'}, {'\xce','\xa7'}, {'\xce','\xa8'}, {'\xce','\xa9'}, + /* 200 */ {'\xce','\xb1'}, {'\xce','\xb2'}, {'\xce','\xb3'}, {'\xce','\xb4'}, {'\xce','\xb5'}, {'\xce','\xb6'}, {'\xce','\xb7'}, {'\xce','\xb8'}, + /* 208 */ {'\xce','\xb9'}, {'\xce','\xba'}, {'\xce','\xbb'}, {'\xce','\xbc'}, {'\xce','\xbd'}, {'\xce','\xbe'}, {'\xce','\xbf'}, {'\xcf','\x80'}, + /* 216 */ {'\xcf','\x81'}, {'\xcf','\x82'}, {'\xcf','\x83'}, {'\xcf','\x84'}, {'\xcf','\x85'}, {'\xcf','\x86'}, {'\xcf','\x87'}, {'\xcf','\x88'}, + /* 224 */ {'\xcf','\x89'}, {'\xcf','\x9c'}, {'\xcf','\x9d'}, {'\xd0','\xbd'}, {'\xd1','\x8a'}, {'\xd1','\x8c'}, {'\xd7','\x90'}, {'\xd7','\x91'}, + /* 232 */ {'\xd7','\x92'}, {'\xd7','\x93'}, {'\xd7','\x94'}, {'\xd7','\x9b'}, {'\xd7','\x9c'}, {'\xd7','\x9d'}, {'\xd7','\xa2'}, {'\xd7','\xa8'}, + /* 240 */ {'\xd7','\xaa'}, {'\xd8','\xa1'}, {'\xd8','\xa7'}, {'\xd8','\xa8'}, {'\xd8','\xa9'}, {'\xd8','\xaa'}, {'\xd8','\xab'}, {'\xd8','\xac'}, + /* 248 */ {'\xd8','\xad'}, {'\xd8','\xae'}, {'\xd8','\xaf'}, {'\xd8','\xb0'}, {'\xd8','\xb1'}, {'\xd8','\xb2'}, {'\xd8','\xb3'}, {'\xd8','\xb4'}, + /* 256 */ {'\xd8','\xb5'}, {'\xd8','\xb6'}, {'\xd8','\xb7'}, {'\xd8','\xb8'}, {'\xd8','\xb9'}, {'\xd8','\xba'}, {'\xd9','\x81'}, {'\xd9','\x82'}, + /* 264 */ {'\xd9','\x83'}, {'\xd9','\x84'}, {'\xd9','\x85'}, {'\xd9','\x86'}, {'\xd9','\x87'}, {'\xd9','\x88'}, {'\xd9','\x89'}, {'\xd9','\x8a'}, + /* 272 */ {'\xd9','\xae'}, {'\xd9','\xaf'}, {'\xd9','\xb1'}, {'\xd9','\xb9'}, {'\xd9','\xba'}, {'\xd9','\xbb'}, {'\xd9','\xbe'}, {'\xd9','\xbf'}, + /* 280 */ {'\xda','\x80'}, {'\xda','\x83'}, {'\xda','\x84'}, {'\xda','\x86'}, {'\xda','\x87'}, {'\xda','\x88'}, {'\xda','\x8c'}, {'\xda','\x8d'}, + /* 288 */ {'\xda','\x8e'}, {'\xda','\x91'}, {'\xda','\x98'}, {'\xda','\xa1'}, {'\xda','\xa4'}, {'\xda','\xa6'}, {'\xda','\xa9'}, {'\xda','\xad'}, + /* 296 */ {'\xda','\xaf'}, {'\xda','\xb1'}, {'\xda','\xb3'}, {'\xda','\xba'}, {'\xda','\xbb'}, {'\xda','\xbe'}, {'\xdb','\x81'}, {'\xdb','\x85'}, + /* 304 */ {'\xdb','\x86'}, {'\xdb','\x87'}, {'\xdb','\x88'}, {'\xdb','\x89'}, {'\xdb','\x8b'}, {'\xdb','\x8c'}, {'\xdb','\x90'}, {'\xdb','\x92'}, + /* 312 */ {'c','c'}, {'c','d'}, {'c','m'}, {'d','B'}, {'d','a'}, {'d','l'}, {'d','m'}, {'d','z'}, + /* 320 */ {'e','V'}, {'f','f'}, {'f','i'}, {'f','l'}, {'f','m'}, {'h','a'}, {'i','i'}, {'i','j'}, + /* 328 */ {'i','n'}, {'i','v'}, {'i','x'}, {'k','A'}, {'k','V'}, {'k','W'}, {'k','g'}, {'k','l'}, + /* 336 */ {'k','m'}, {'k','t'}, {'l','j'}, {'l','m'}, {'l','n'}, {'l','x'}, {'m','2'}, {'m','3'}, + /* 344 */ {'m','A'}, {'m','V'}, {'m','W'}, {'m','b'}, {'m','g'}, {'m','l'}, {'m','m'}, {'m','s'}, + /* 352 */ {'n','A'}, {'n','F'}, {'n','V'}, {'n','W'}, {'n','j'}, {'n','m'}, {'n','s'}, {'o','V'}, + /* 360 */ {'p','A'}, {'p','F'}, {'p','V'}, {'p','W'}, {'p','c'}, {'p','s'}, {'s','r'}, {'s','t'}, + /* 368 */ {'v','i'}, {'x','i'}}; + +static const char UN8IF_compat_tbl_3 [1796][3] = { + /* 0 */ {'(','1',')'}, {'(','2',')'}, {'(','3',')'}, {'(','4',')'}, {'(','5',')'}, {'(','6',')'}, {'(','7',')'}, {'(','8',')'}, + /* 8 */ {'(','9',')'}, {'(','A',')'}, {'(','B',')'}, {'(','C',')'}, {'(','D',')'}, {'(','E',')'}, {'(','F',')'}, {'(','G',')'}, + /* 16 */ {'(','H',')'}, {'(','I',')'}, {'(','J',')'}, {'(','K',')'}, {'(','L',')'}, {'(','M',')'}, {'(','N',')'}, {'(','O',')'}, + /* 24 */ {'(','P',')'}, {'(','Q',')'}, {'(','R',')'}, {'(','S',')'}, {'(','T',')'}, {'(','U',')'}, {'(','V',')'}, {'(','W',')'}, + /* 32 */ {'(','X',')'}, {'(','Y',')'}, {'(','Z',')'}, {'(','a',')'}, {'(','b',')'}, {'(','c',')'}, {'(','d',')'}, {'(','e',')'}, + /* 40 */ {'(','f',')'}, {'(','g',')'}, {'(','h',')'}, {'(','i',')'}, {'(','j',')'}, {'(','k',')'}, {'(','l',')'}, {'(','m',')'}, + /* 48 */ {'(','n',')'}, {'(','o',')'}, {'(','p',')'}, {'(','q',')'}, {'(','r',')'}, {'(','s',')'}, {'(','t',')'}, {'(','u',')'}, + /* 56 */ {'(','v',')'}, {'(','w',')'}, {'(','x',')'}, {'(','y',')'}, {'(','z',')'}, {'.','.','.'}, {'1','0','.'}, {'1','1','.'}, + /* 64 */ {'1','2','.'}, {'1','3','.'}, {'1','4','.'}, {'1','5','.'}, {'1','6','.'}, {'1','7','.'}, {'1','8','.'}, {'1','9','.'}, + /* 72 */ {'2','0','.'}, {':',':','='}, {'<','\xcc','\xb8'}, {'=','=','='}, {'=','\xcc','\xb8'}, {'>','\xcc','\xb8'}, {'A','\xcc','\x80'}, {'A','\xcc','\x81'}, + /* 80 */ {'A','\xcc','\x82'}, {'A','\xcc','\x83'}, {'A','\xcc','\x84'}, {'A','\xcc','\x86'}, {'A','\xcc','\x87'}, {'A','\xcc','\x88'}, {'A','\xcc','\x89'}, {'A','\xcc','\x8a'}, + /* 88 */ {'A','\xcc','\x8c'}, {'A','\xcc','\x8f'}, {'A','\xcc','\x91'}, {'A','\xcc','\xa3'}, {'A','\xcc','\xa5'}, {'A','\xcc','\xa8'}, {'B','\xcc','\x87'}, {'B','\xcc','\xa3'}, + /* 96 */ {'B','\xcc','\xb1'}, {'C','\xcc','\x81'}, {'C','\xcc','\x82'}, {'C','\xcc','\x87'}, {'C','\xcc','\x8c'}, {'C','\xcc','\xa7'}, {'C','o','.'}, {'D','\xcc','\x87'}, + /* 104 */ {'D','\xcc','\x8c'}, {'D','\xcc','\xa3'}, {'D','\xcc','\xa7'}, {'D','\xcc','\xad'}, {'D','\xcc','\xb1'}, {'E','\xcc','\x80'}, {'E','\xcc','\x81'}, {'E','\xcc','\x82'}, + /* 112 */ {'E','\xcc','\x83'}, {'E','\xcc','\x84'}, {'E','\xcc','\x86'}, {'E','\xcc','\x87'}, {'E','\xcc','\x88'}, {'E','\xcc','\x89'}, {'E','\xcc','\x8c'}, {'E','\xcc','\x8f'}, + /* 120 */ {'E','\xcc','\x91'}, {'E','\xcc','\xa3'}, {'E','\xcc','\xa7'}, {'E','\xcc','\xa8'}, {'E','\xcc','\xad'}, {'E','\xcc','\xb0'}, {'F','A','X'}, {'F','\xcc','\x87'}, + /* 128 */ {'G','H','z'}, {'G','P','a'}, {'G','\xcc','\x81'}, {'G','\xcc','\x82'}, {'G','\xcc','\x84'}, {'G','\xcc','\x86'}, {'G','\xcc','\x87'}, {'G','\xcc','\x8c'}, + /* 136 */ {'G','\xcc','\xa7'}, {'H','\xcc','\x82'}, {'H','\xcc','\x87'}, {'H','\xcc','\x88'}, {'H','\xcc','\x8c'}, {'H','\xcc','\xa3'}, {'H','\xcc','\xa7'}, {'H','\xcc','\xae'}, + /* 144 */ {'I','I','I'}, {'I','\xcc','\x80'}, {'I','\xcc','\x81'}, {'I','\xcc','\x82'}, {'I','\xcc','\x83'}, {'I','\xcc','\x84'}, {'I','\xcc','\x86'}, {'I','\xcc','\x87'}, + /* 152 */ {'I','\xcc','\x88'}, {'I','\xcc','\x89'}, {'I','\xcc','\x8c'}, {'I','\xcc','\x8f'}, {'I','\xcc','\x91'}, {'I','\xcc','\xa3'}, {'I','\xcc','\xa8'}, {'I','\xcc','\xb0'}, + /* 160 */ {'J','\xcc','\x82'}, {'K','\xcc','\x81'}, {'K','\xcc','\x8c'}, {'K','\xcc','\xa3'}, {'K','\xcc','\xa7'}, {'K','\xcc','\xb1'}, {'L','T','D'}, {'L','\xc2','\xb7'}, + /* 168 */ {'L','\xcc','\x81'}, {'L','\xcc','\x8c'}, {'L','\xcc','\xa3'}, {'L','\xcc','\xa7'}, {'L','\xcc','\xad'}, {'L','\xcc','\xb1'}, {'M','H','z'}, {'M','P','a'}, + /* 176 */ {'M','\xcc','\x81'}, {'M','\xcc','\x87'}, {'M','\xcc','\xa3'}, {'M','\xce','\xa9'}, {'N','\xcc','\x80'}, {'N','\xcc','\x81'}, {'N','\xcc','\x83'}, {'N','\xcc','\x87'}, + /* 184 */ {'N','\xcc','\x8c'}, {'N','\xcc','\xa3'}, {'N','\xcc','\xa7'}, {'N','\xcc','\xad'}, {'N','\xcc','\xb1'}, {'O','\xcc','\x80'}, {'O','\xcc','\x81'}, {'O','\xcc','\x82'}, + /* 192 */ {'O','\xcc','\x83'}, {'O','\xcc','\x84'}, {'O','\xcc','\x86'}, {'O','\xcc','\x87'}, {'O','\xcc','\x88'}, {'O','\xcc','\x89'}, {'O','\xcc','\x8b'}, {'O','\xcc','\x8c'}, + /* 200 */ {'O','\xcc','\x8f'}, {'O','\xcc','\x91'}, {'O','\xcc','\x9b'}, {'O','\xcc','\xa3'}, {'O','\xcc','\xa8'}, {'P','P','M'}, {'P','P','V'}, {'P','T','E'}, + /* 208 */ {'P','\xcc','\x81'}, {'P','\xcc','\x87'}, {'R','\xcc','\x81'}, {'R','\xcc','\x87'}, {'R','\xcc','\x8c'}, {'R','\xcc','\x8f'}, {'R','\xcc','\x91'}, {'R','\xcc','\xa3'}, + /* 216 */ {'R','\xcc','\xa7'}, {'R','\xcc','\xb1'}, {'S','\xcc','\x81'}, {'S','\xcc','\x82'}, {'S','\xcc','\x87'}, {'S','\xcc','\x8c'}, {'S','\xcc','\xa3'}, {'S','\xcc','\xa6'}, + /* 224 */ {'S','\xcc','\xa7'}, {'T','E','L'}, {'T','H','z'}, {'T','\xcc','\x87'}, {'T','\xcc','\x8c'}, {'T','\xcc','\xa3'}, {'T','\xcc','\xa6'}, {'T','\xcc','\xa7'}, + /* 232 */ {'T','\xcc','\xad'}, {'T','\xcc','\xb1'}, {'U','\xcc','\x80'}, {'U','\xcc','\x81'}, {'U','\xcc','\x82'}, {'U','\xcc','\x83'}, {'U','\xcc','\x84'}, {'U','\xcc','\x86'}, + /* 240 */ {'U','\xcc','\x88'}, {'U','\xcc','\x89'}, {'U','\xcc','\x8a'}, {'U','\xcc','\x8b'}, {'U','\xcc','\x8c'}, {'U','\xcc','\x8f'}, {'U','\xcc','\x91'}, {'U','\xcc','\x9b'}, + /* 248 */ {'U','\xcc','\xa3'}, {'U','\xcc','\xa4'}, {'U','\xcc','\xa8'}, {'U','\xcc','\xad'}, {'U','\xcc','\xb0'}, {'V','I','I'}, {'V','\xcc','\x83'}, {'V','\xcc','\xa3'}, + /* 256 */ {'W','\xcc','\x80'}, {'W','\xcc','\x81'}, {'W','\xcc','\x82'}, {'W','\xcc','\x87'}, {'W','\xcc','\x88'}, {'W','\xcc','\xa3'}, {'X','I','I'}, {'X','\xcc','\x87'}, + /* 264 */ {'X','\xcc','\x88'}, {'Y','\xcc','\x80'}, {'Y','\xcc','\x81'}, {'Y','\xcc','\x82'}, {'Y','\xcc','\x83'}, {'Y','\xcc','\x84'}, {'Y','\xcc','\x87'}, {'Y','\xcc','\x88'}, + /* 272 */ {'Y','\xcc','\x89'}, {'Y','\xcc','\xa3'}, {'Z','\xcc','\x81'}, {'Z','\xcc','\x82'}, {'Z','\xcc','\x87'}, {'Z','\xcc','\x8c'}, {'Z','\xcc','\xa3'}, {'Z','\xcc','\xb1'}, + /* 280 */ {'\x20','\xcc','\x81'}, {'\x20','\xcc','\x83'}, {'\x20','\xcc','\x84'}, {'\x20','\xcc','\x85'}, {'\x20','\xcc','\x86'}, {'\x20','\xcc','\x87'}, {'\x20','\xcc','\x88'}, {'\x20','\xcc','\x8a'}, + /* 288 */ {'\x20','\xcc','\x8b'}, {'\x20','\xcc','\x93'}, {'\x20','\xcc','\x94'}, {'\x20','\xcc','\xa7'}, {'\x20','\xcc','\xa8'}, {'\x20','\xcc','\xb3'}, {'\x20','\xcd','\x82'}, {'\x20','\xcd','\x85'}, + /* 296 */ {'\x20','\xd9','\x8b'}, {'\x20','\xd9','\x8c'}, {'\x20','\xd9','\x8d'}, {'\x20','\xd9','\x8e'}, {'\x20','\xd9','\x8f'}, {'\x20','\xd9','\x90'}, {'\x20','\xd9','\x91'}, {'\x20','\xd9','\x92'}, + /* 304 */ {'\xc2','\xb0','C'}, {'\xc2','\xb0','F'}, {'\xca','\xbc','n'}, {'\xce','\xbc','A'}, {'\xce','\xbc','F'}, {'\xce','\xbc','V'}, {'\xce','\xbc','W'}, {'\xce','\xbc','g'}, + /* 312 */ {'\xce','\xbc','l'}, {'\xce','\xbc','m'}, {'\xce','\xbc','s'}, {'\xe0','\xbc','\x8b'}, {'\xe1','\x83','\x9c'}, {'\xe1','\x84','\x80'}, {'\xe1','\x84','\x81'}, {'\xe1','\x84','\x82'}, + /* 320 */ {'\xe1','\x84','\x83'}, {'\xe1','\x84','\x84'}, {'\xe1','\x84','\x85'}, {'\xe1','\x84','\x86'}, {'\xe1','\x84','\x87'}, {'\xe1','\x84','\x88'}, {'\xe1','\x84','\x89'}, {'\xe1','\x84','\x8a'}, + /* 328 */ {'\xe1','\x84','\x8b'}, {'\xe1','\x84','\x8c'}, {'\xe1','\x84','\x8d'}, {'\xe1','\x84','\x8e'}, {'\xe1','\x84','\x8f'}, {'\xe1','\x84','\x90'}, {'\xe1','\x84','\x91'}, {'\xe1','\x84','\x92'}, + /* 336 */ {'\xe1','\x84','\x94'}, {'\xe1','\x84','\x95'}, {'\xe1','\x84','\x9a'}, {'\xe1','\x84','\x9c'}, {'\xe1','\x84','\x9d'}, {'\xe1','\x84','\x9e'}, {'\xe1','\x84','\xa0'}, {'\xe1','\x84','\xa1'}, + /* 344 */ {'\xe1','\x84','\xa2'}, {'\xe1','\x84','\xa3'}, {'\xe1','\x84','\xa7'}, {'\xe1','\x84','\xa9'}, {'\xe1','\x84','\xab'}, {'\xe1','\x84','\xac'}, {'\xe1','\x84','\xad'}, {'\xe1','\x84','\xae'}, + /* 352 */ {'\xe1','\x84','\xaf'}, {'\xe1','\x84','\xb2'}, {'\xe1','\x84','\xb6'}, {'\xe1','\x85','\x80'}, {'\xe1','\x85','\x87'}, {'\xe1','\x85','\x8c'}, {'\xe1','\x85','\x97'}, {'\xe1','\x85','\x98'}, + /* 360 */ {'\xe1','\x85','\x99'}, {'\xe1','\x85','\xa0'}, {'\xe1','\x85','\xa1'}, {'\xe1','\x85','\xa2'}, {'\xe1','\x85','\xa3'}, {'\xe1','\x85','\xa4'}, {'\xe1','\x85','\xa5'}, {'\xe1','\x85','\xa6'}, + /* 368 */ {'\xe1','\x85','\xa7'}, {'\xe1','\x85','\xa8'}, {'\xe1','\x85','\xa9'}, {'\xe1','\x85','\xaa'}, {'\xe1','\x85','\xab'}, {'\xe1','\x85','\xac'}, {'\xe1','\x85','\xad'}, {'\xe1','\x85','\xae'}, + /* 376 */ {'\xe1','\x85','\xaf'}, {'\xe1','\x85','\xb0'}, {'\xe1','\x85','\xb1'}, {'\xe1','\x85','\xb2'}, {'\xe1','\x85','\xb3'}, {'\xe1','\x85','\xb4'}, {'\xe1','\x85','\xb5'}, {'\xe1','\x86','\x84'}, + /* 384 */ {'\xe1','\x86','\x85'}, {'\xe1','\x86','\x88'}, {'\xe1','\x86','\x91'}, {'\xe1','\x86','\x92'}, {'\xe1','\x86','\x94'}, {'\xe1','\x86','\x9e'}, {'\xe1','\x86','\xa1'}, {'\xe1','\x86','\xaa'}, + /* 392 */ {'\xe1','\x86','\xac'}, {'\xe1','\x86','\xad'}, {'\xe1','\x86','\xb0'}, {'\xe1','\x86','\xb1'}, {'\xe1','\x86','\xb2'}, {'\xe1','\x86','\xb3'}, {'\xe1','\x86','\xb4'}, {'\xe1','\x86','\xb5'}, + /* 400 */ {'\xe1','\x87','\x87'}, {'\xe1','\x87','\x88'}, {'\xe1','\x87','\x8c'}, {'\xe1','\x87','\x8e'}, {'\xe1','\x87','\x93'}, {'\xe1','\x87','\x97'}, {'\xe1','\x87','\x99'}, {'\xe1','\x87','\x9d'}, + /* 408 */ {'\xe1','\x87','\x9f'}, {'\xe1','\x87','\xb1'}, {'\xe1','\x87','\xb2'}, {'\xe1','\xb4','\x82'}, {'\xe1','\xb4','\x96'}, {'\xe1','\xb4','\x97'}, {'\xe1','\xb4','\x9c'}, {'\xe1','\xb4','\x9d'}, + /* 416 */ {'\xe1','\xb4','\xa5'}, {'\xe1','\xb5','\xbb'}, {'\xe1','\xb6','\x85'}, {'\xe2','\x80','\x90'}, {'\xe2','\x80','\x93'}, {'\xe2','\x80','\x94'}, {'\xe2','\x82','\xa9'}, {'\xe2','\x86','\x90'}, + /* 424 */ {'\xe2','\x86','\x91'}, {'\xe2','\x86','\x92'}, {'\xe2','\x86','\x93'}, {'\xe2','\x88','\x82'}, {'\xe2','\x88','\x87'}, {'\xe2','\x88','\x91'}, {'\xe2','\x88','\x92'}, {'\xe2','\x94','\x82'}, + /* 432 */ {'\xe2','\x96','\xa0'}, {'\xe2','\x97','\x8b'}, {'\xe2','\xa6','\x85'}, {'\xe2','\xa6','\x86'}, {'\xe2','\xb5','\xa1'}, {'\xe3','\x80','\x81'}, {'\xe3','\x80','\x82'}, {'\xe3','\x80','\x88'}, + /* 440 */ {'\xe3','\x80','\x89'}, {'\xe3','\x80','\x8a'}, {'\xe3','\x80','\x8b'}, {'\xe3','\x80','\x8c'}, {'\xe3','\x80','\x8d'}, {'\xe3','\x80','\x8e'}, {'\xe3','\x80','\x8f'}, {'\xe3','\x80','\x90'}, + /* 448 */ {'\xe3','\x80','\x91'}, {'\xe3','\x80','\x92'}, {'\xe3','\x80','\x94'}, {'\xe3','\x80','\x95'}, {'\xe3','\x80','\x96'}, {'\xe3','\x80','\x97'}, {'\xe3','\x82','\x99'}, {'\xe3','\x82','\x9a'}, + /* 456 */ {'\xe3','\x82','\xa1'}, {'\xe3','\x82','\xa2'}, {'\xe3','\x82','\xa3'}, {'\xe3','\x82','\xa4'}, {'\xe3','\x82','\xa5'}, {'\xe3','\x82','\xa6'}, {'\xe3','\x82','\xa7'}, {'\xe3','\x82','\xa8'}, + /* 464 */ {'\xe3','\x82','\xa9'}, {'\xe3','\x82','\xaa'}, {'\xe3','\x82','\xab'}, {'\xe3','\x82','\xad'}, {'\xe3','\x82','\xaf'}, {'\xe3','\x82','\xb1'}, {'\xe3','\x82','\xb3'}, {'\xe3','\x82','\xb5'}, + /* 472 */ {'\xe3','\x82','\xb7'}, {'\xe3','\x82','\xb9'}, {'\xe3','\x82','\xbb'}, {'\xe3','\x82','\xbd'}, {'\xe3','\x82','\xbf'}, {'\xe3','\x83','\x81'}, {'\xe3','\x83','\x83'}, {'\xe3','\x83','\x84'}, + /* 480 */ {'\xe3','\x83','\x86'}, {'\xe3','\x83','\x88'}, {'\xe3','\x83','\x8a'}, {'\xe3','\x83','\x8b'}, {'\xe3','\x83','\x8c'}, {'\xe3','\x83','\x8d'}, {'\xe3','\x83','\x8e'}, {'\xe3','\x83','\x8f'}, + /* 488 */ {'\xe3','\x83','\x92'}, {'\xe3','\x83','\x95'}, {'\xe3','\x83','\x98'}, {'\xe3','\x83','\x9b'}, {'\xe3','\x83','\x9e'}, {'\xe3','\x83','\x9f'}, {'\xe3','\x83','\xa0'}, {'\xe3','\x83','\xa1'}, + /* 496 */ {'\xe3','\x83','\xa2'}, {'\xe3','\x83','\xa3'}, {'\xe3','\x83','\xa4'}, {'\xe3','\x83','\xa5'}, {'\xe3','\x83','\xa6'}, {'\xe3','\x83','\xa7'}, {'\xe3','\x83','\xa8'}, {'\xe3','\x83','\xa9'}, + /* 504 */ {'\xe3','\x83','\xaa'}, {'\xe3','\x83','\xab'}, {'\xe3','\x83','\xac'}, {'\xe3','\x83','\xad'}, {'\xe3','\x83','\xaf'}, {'\xe3','\x83','\xb0'}, {'\xe3','\x83','\xb1'}, {'\xe3','\x83','\xb2'}, + /* 512 */ {'\xe3','\x83','\xb3'}, {'\xe3','\x83','\xbb'}, {'\xe3','\x83','\xbc'}, {'\xe3','\x92','\x9e'}, {'\xe3','\x92','\xb9'}, {'\xe3','\x92','\xbb'}, {'\xe3','\x93','\x9f'}, {'\xe3','\x94','\x95'}, + /* 520 */ {'\xe3','\x9b','\xae'}, {'\xe3','\x9b','\xbc'}, {'\xe3','\x9e','\x81'}, {'\xe3','\xa0','\xaf'}, {'\xe3','\xa1','\xa2'}, {'\xe3','\xa1','\xbc'}, {'\xe3','\xa3','\x87'}, {'\xe3','\xa3','\xa3'}, + /* 528 */ {'\xe3','\xa4','\x9c'}, {'\xe3','\xa4','\xba'}, {'\xe3','\xa8','\xae'}, {'\xe3','\xa9','\xac'}, {'\xe3','\xab','\xa4'}, {'\xe3','\xac','\x88'}, {'\xe3','\xac','\x99'}, {'\xe3','\xad','\x89'}, + /* 536 */ {'\xe3','\xae','\x9d'}, {'\xe3','\xb0','\x98'}, {'\xe3','\xb1','\x8e'}, {'\xe3','\xb4','\xb3'}, {'\xe3','\xb6','\x96'}, {'\xe3','\xba','\xac'}, {'\xe3','\xba','\xb8'}, {'\xe3','\xbc','\x9b'}, + /* 544 */ {'\xe3','\xbf','\xbc'}, {'\xe4','\x80','\x88'}, {'\xe4','\x80','\x98'}, {'\xe4','\x80','\xb9'}, {'\xe4','\x81','\x86'}, {'\xe4','\x82','\x96'}, {'\xe4','\x83','\xa3'}, {'\xe4','\x84','\xaf'}, + /* 552 */ {'\xe4','\x88','\x82'}, {'\xe4','\x88','\xa7'}, {'\xe4','\x8a','\xa0'}, {'\xe4','\x8c','\x81'}, {'\xe4','\x8c','\xb4'}, {'\xe4','\x8d','\x99'}, {'\xe4','\x8f','\x95'}, {'\xe4','\x8f','\x99'}, + /* 560 */ {'\xe4','\x90','\x8b'}, {'\xe4','\x91','\xab'}, {'\xe4','\x94','\xab'}, {'\xe4','\x95','\x9d'}, {'\xe4','\x95','\xa1'}, {'\xe4','\x95','\xab'}, {'\xe4','\x97','\x97'}, {'\xe4','\x97','\xb9'}, + /* 568 */ {'\xe4','\x98','\xb5'}, {'\xe4','\x9a','\xbe'}, {'\xe4','\x9b','\x87'}, {'\xe4','\xa6','\x95'}, {'\xe4','\xa7','\xa6'}, {'\xe4','\xa9','\xae'}, {'\xe4','\xa9','\xb6'}, {'\xe4','\xaa','\xb2'}, + /* 576 */ {'\xe4','\xac','\xb3'}, {'\xe4','\xaf','\x8e'}, {'\xe4','\xb3','\x8e'}, {'\xe4','\xb3','\xad'}, {'\xe4','\xb3','\xb8'}, {'\xe4','\xb5','\x96'}, {'\xe4','\xb8','\x80'}, {'\xe4','\xb8','\x81'}, + /* 584 */ {'\xe4','\xb8','\x83'}, {'\xe4','\xb8','\x89'}, {'\xe4','\xb8','\x8a'}, {'\xe4','\xb8','\x8b'}, {'\xe4','\xb8','\x8d'}, {'\xe4','\xb8','\x99'}, {'\xe4','\xb8','\xa6'}, {'\xe4','\xb8','\xa8'}, + /* 592 */ {'\xe4','\xb8','\xad'}, {'\xe4','\xb8','\xb2'}, {'\xe4','\xb8','\xb6'}, {'\xe4','\xb8','\xb8'}, {'\xe4','\xb8','\xb9'}, {'\xe4','\xb8','\xbd'}, {'\xe4','\xb8','\xbf'}, {'\xe4','\xb9','\x81'}, + /* 600 */ {'\xe4','\xb9','\x99'}, {'\xe4','\xb9','\x9d'}, {'\xe4','\xba','\x82'}, {'\xe4','\xba','\x85'}, {'\xe4','\xba','\x86'}, {'\xe4','\xba','\x8c'}, {'\xe4','\xba','\x94'}, {'\xe4','\xba','\xa0'}, + /* 608 */ {'\xe4','\xba','\xa4'}, {'\xe4','\xba','\xae'}, {'\xe4','\xba','\xba'}, {'\xe4','\xbb','\x80'}, {'\xe4','\xbb','\x8c'}, {'\xe4','\xbb','\xa4'}, {'\xe4','\xbc','\x81'}, {'\xe4','\xbc','\x91'}, + /* 616 */ {'\xe4','\xbd','\xa0'}, {'\xe4','\xbe','\x80'}, {'\xe4','\xbe','\x86'}, {'\xe4','\xbe','\x8b'}, {'\xe4','\xbe','\xae'}, {'\xe4','\xbe','\xbb'}, {'\xe4','\xbe','\xbf'}, {'\xe5','\x80','\x82'}, + /* 624 */ {'\xe5','\x80','\xab'}, {'\xe5','\x81','\xba'}, {'\xe5','\x82','\x99'}, {'\xe5','\x83','\x8f'}, {'\xe5','\x83','\x9a'}, {'\xe5','\x83','\xa7'}, {'\xe5','\x84','\xaa'}, {'\xe5','\x84','\xbf'}, + /* 632 */ {'\xe5','\x85','\x80'}, {'\xe5','\x85','\x85'}, {'\xe5','\x85','\x8d'}, {'\xe5','\x85','\x94'}, {'\xe5','\x85','\xa4'}, {'\xe5','\x85','\xa5'}, {'\xe5','\x85','\xa7'}, {'\xe5','\x85','\xa8'}, + /* 640 */ {'\xe5','\x85','\xa9'}, {'\xe5','\x85','\xab'}, {'\xe5','\x85','\xad'}, {'\xe5','\x85','\xb7'}, {'\xe5','\x86','\x80'}, {'\xe5','\x86','\x82'}, {'\xe5','\x86','\x8d'}, {'\xe5','\x86','\x92'}, + /* 648 */ {'\xe5','\x86','\x95'}, {'\xe5','\x86','\x96'}, {'\xe5','\x86','\x97'}, {'\xe5','\x86','\x99'}, {'\xe5','\x86','\xa4'}, {'\xe5','\x86','\xab'}, {'\xe5','\x86','\xac'}, {'\xe5','\x86','\xb5'}, + /* 656 */ {'\xe5','\x86','\xb7'}, {'\xe5','\x87','\x89'}, {'\xe5','\x87','\x8c'}, {'\xe5','\x87','\x9c'}, {'\xe5','\x87','\x9e'}, {'\xe5','\x87','\xa0'}, {'\xe5','\x87','\xb5'}, {'\xe5','\x88','\x80'}, + /* 664 */ {'\xe5','\x88','\x83'}, {'\xe5','\x88','\x87'}, {'\xe5','\x88','\x97'}, {'\xe5','\x88','\x9d'}, {'\xe5','\x88','\xa9'}, {'\xe5','\x88','\xba'}, {'\xe5','\x88','\xbb'}, {'\xe5','\x89','\x86'}, + /* 672 */ {'\xe5','\x89','\x8d'}, {'\xe5','\x89','\xb2'}, {'\xe5','\x89','\xb7'}, {'\xe5','\x8a','\x89'}, {'\xe5','\x8a','\x9b'}, {'\xe5','\x8a','\xa3'}, {'\xe5','\x8a','\xb3'}, {'\xe5','\x8a','\xb4'}, + /* 680 */ {'\xe5','\x8b','\x87'}, {'\xe5','\x8b','\x89'}, {'\xe5','\x8b','\x92'}, {'\xe5','\x8b','\x9e'}, {'\xe5','\x8b','\xa4'}, {'\xe5','\x8b','\xb5'}, {'\xe5','\x8b','\xb9'}, {'\xe5','\x8b','\xba'}, + /* 688 */ {'\xe5','\x8c','\x85'}, {'\xe5','\x8c','\x86'}, {'\xe5','\x8c','\x95'}, {'\xe5','\x8c','\x97'}, {'\xe5','\x8c','\x9a'}, {'\xe5','\x8c','\xb8'}, {'\xe5','\x8c','\xbb'}, {'\xe5','\x8c','\xbf'}, + /* 696 */ {'\xe5','\x8d','\x81'}, {'\xe5','\x8d','\x84'}, {'\xe5','\x8d','\x85'}, {'\xe5','\x8d','\x89'}, {'\xe5','\x8d','\x91'}, {'\xe5','\x8d','\x94'}, {'\xe5','\x8d','\x9a'}, {'\xe5','\x8d','\x9c'}, + /* 704 */ {'\xe5','\x8d','\xa9'}, {'\xe5','\x8d','\xb0'}, {'\xe5','\x8d','\xb3'}, {'\xe5','\x8d','\xb5'}, {'\xe5','\x8d','\xbd'}, {'\xe5','\x8d','\xbf'}, {'\xe5','\x8e','\x82'}, {'\xe5','\x8e','\xb6'}, + /* 712 */ {'\xe5','\x8f','\x83'}, {'\xe5','\x8f','\x88'}, {'\xe5','\x8f','\x8a'}, {'\xe5','\x8f','\x8c'}, {'\xe5','\x8f','\x9f'}, {'\xe5','\x8f','\xa3'}, {'\xe5','\x8f','\xa5'}, {'\xe5','\x8f','\xab'}, + /* 720 */ {'\xe5','\x8f','\xaf'}, {'\xe5','\x8f','\xb1'}, {'\xe5','\x8f','\xb3'}, {'\xe5','\x90','\x86'}, {'\xe5','\x90','\x88'}, {'\xe5','\x90','\x8d'}, {'\xe5','\x90','\x8f'}, {'\xe5','\x90','\x9d'}, + /* 728 */ {'\xe5','\x90','\xb8'}, {'\xe5','\x90','\xb9'}, {'\xe5','\x91','\x82'}, {'\xe5','\x91','\x88'}, {'\xe5','\x91','\xa8'}, {'\xe5','\x92','\x9e'}, {'\xe5','\x92','\xa2'}, {'\xe5','\x92','\xbd'}, + /* 736 */ {'\xe5','\x93','\xb6'}, {'\xe5','\x94','\x90'}, {'\xe5','\x95','\x8f'}, {'\xe5','\x95','\x93'}, {'\xe5','\x95','\x95'}, {'\xe5','\x95','\xa3'}, {'\xe5','\x96','\x84'}, {'\xe5','\x96','\x87'}, + /* 744 */ {'\xe5','\x96','\x99'}, {'\xe5','\x96','\x9d'}, {'\xe5','\x96','\xab'}, {'\xe5','\x96','\xb3'}, {'\xe5','\x96','\xb6'}, {'\xe5','\x97','\x80'}, {'\xe5','\x97','\x82'}, {'\xe5','\x97','\xa2'}, + /* 752 */ {'\xe5','\x98','\x86'}, {'\xe5','\x99','\x91'}, {'\xe5','\x99','\xa8'}, {'\xe5','\x99','\xb4'}, {'\xe5','\x9b','\x97'}, {'\xe5','\x9b','\x9b'}, {'\xe5','\x9b','\xb9'}, {'\xe5','\x9c','\x96'}, + /* 760 */ {'\xe5','\x9c','\x97'}, {'\xe5','\x9c','\x9f'}, {'\xe5','\x9c','\xb0'}, {'\xe5','\x9e','\x8b'}, {'\xe5','\x9f','\x8e'}, {'\xe5','\x9f','\xb4'}, {'\xe5','\xa0','\x8d'}, {'\xe5','\xa0','\xb1'}, + /* 768 */ {'\xe5','\xa0','\xb2'}, {'\xe5','\xa1','\x80'}, {'\xe5','\xa1','\x9a'}, {'\xe5','\xa1','\x9e'}, {'\xe5','\xa2','\xa8'}, {'\xe5','\xa2','\xac'}, {'\xe5','\xa2','\xb3'}, {'\xe5','\xa3','\x98'}, + /* 776 */ {'\xe5','\xa3','\x9f'}, {'\xe5','\xa3','\xab'}, {'\xe5','\xa3','\xae'}, {'\xe5','\xa3','\xb0'}, {'\xe5','\xa3','\xb2'}, {'\xe5','\xa3','\xb7'}, {'\xe5','\xa4','\x82'}, {'\xe5','\xa4','\x86'}, + /* 784 */ {'\xe5','\xa4','\x8a'}, {'\xe5','\xa4','\x95'}, {'\xe5','\xa4','\x9a'}, {'\xe5','\xa4','\x9c'}, {'\xe5','\xa4','\xa2'}, {'\xe5','\xa4','\xa7'}, {'\xe5','\xa4','\xa9'}, {'\xe5','\xa5','\x84'}, + /* 792 */ {'\xe5','\xa5','\x88'}, {'\xe5','\xa5','\x91'}, {'\xe5','\xa5','\x94'}, {'\xe5','\xa5','\xa2'}, {'\xe5','\xa5','\xb3'}, {'\xe5','\xa7','\x98'}, {'\xe5','\xa7','\xac'}, {'\xe5','\xa8','\x9b'}, + /* 800 */ {'\xe5','\xa8','\xa7'}, {'\xe5','\xa9','\xa2'}, {'\xe5','\xa9','\xa6'}, {'\xe5','\xaa','\xb5'}, {'\xe5','\xac','\x88'}, {'\xe5','\xac','\xa8'}, {'\xe5','\xac','\xbe'}, {'\xe5','\xad','\x90'}, + /* 808 */ {'\xe5','\xad','\x97'}, {'\xe5','\xad','\xa6'}, {'\xe5','\xae','\x80'}, {'\xe5','\xae','\x85'}, {'\xe5','\xae','\x97'}, {'\xe5','\xaf','\x83'}, {'\xe5','\xaf','\x98'}, {'\xe5','\xaf','\xa7'}, + /* 816 */ {'\xe5','\xaf','\xae'}, {'\xe5','\xaf','\xb3'}, {'\xe5','\xaf','\xb8'}, {'\xe5','\xaf','\xbf'}, {'\xe5','\xb0','\x86'}, {'\xe5','\xb0','\x8f'}, {'\xe5','\xb0','\xa2'}, {'\xe5','\xb0','\xb8'}, + /* 824 */ {'\xe5','\xb0','\xbf'}, {'\xe5','\xb1','\xa0'}, {'\xe5','\xb1','\xa2'}, {'\xe5','\xb1','\xa4'}, {'\xe5','\xb1','\xa5'}, {'\xe5','\xb1','\xae'}, {'\xe5','\xb1','\xb1'}, {'\xe5','\xb2','\x8d'}, + /* 832 */ {'\xe5','\xb3','\x80'}, {'\xe5','\xb4','\x99'}, {'\xe5','\xb5','\x83'}, {'\xe5','\xb5','\x90'}, {'\xe5','\xb5','\xab'}, {'\xe5','\xb5','\xae'}, {'\xe5','\xb5','\xbc'}, {'\xe5','\xb6','\xb2'}, + /* 840 */ {'\xe5','\xb6','\xba'}, {'\xe5','\xb7','\x9b'}, {'\xe5','\xb7','\xa1'}, {'\xe5','\xb7','\xa2'}, {'\xe5','\xb7','\xa5'}, {'\xe5','\xb7','\xa6'}, {'\xe5','\xb7','\xb1'}, {'\xe5','\xb7','\xbd'}, + /* 848 */ {'\xe5','\xb7','\xbe'}, {'\xe5','\xb8','\xa8'}, {'\xe5','\xb8','\xbd'}, {'\xe5','\xb9','\xa9'}, {'\xe5','\xb9','\xb2'}, {'\xe5','\xb9','\xb4'}, {'\xe5','\xb9','\xba'}, {'\xe5','\xb9','\xbc'}, + /* 856 */ {'\xe5','\xb9','\xbf'}, {'\xe5','\xba','\xa6'}, {'\xe5','\xba','\xb0'}, {'\xe5','\xba','\xb3'}, {'\xe5','\xba','\xb6'}, {'\xe5','\xbb','\x89'}, {'\xe5','\xbb','\x8a'}, {'\xe5','\xbb','\x92'}, + /* 864 */ {'\xe5','\xbb','\x93'}, {'\xe5','\xbb','\x99'}, {'\xe5','\xbb','\xac'}, {'\xe5','\xbb','\xb4'}, {'\xe5','\xbb','\xbe'}, {'\xe5','\xbc','\x84'}, {'\xe5','\xbc','\x8b'}, {'\xe5','\xbc','\x93'}, + /* 872 */ {'\xe5','\xbc','\xa2'}, {'\xe5','\xbd','\x90'}, {'\xe5','\xbd','\x93'}, {'\xe5','\xbd','\xa1'}, {'\xe5','\xbd','\xa2'}, {'\xe5','\xbd','\xa9'}, {'\xe5','\xbd','\xab'}, {'\xe5','\xbd','\xb3'}, + /* 880 */ {'\xe5','\xbe','\x8b'}, {'\xe5','\xbe','\x8c'}, {'\xe5','\xbe','\x97'}, {'\xe5','\xbe','\x9a'}, {'\xe5','\xbe','\xa9'}, {'\xe5','\xbe','\xad'}, {'\xe5','\xbf','\x83'}, {'\xe5','\xbf','\x8d'}, + /* 888 */ {'\xe5','\xbf','\x97'}, {'\xe5','\xbf','\xb5'}, {'\xe5','\xbf','\xb9'}, {'\xe6','\x80','\x92'}, {'\xe6','\x80','\x9c'}, {'\xe6','\x81','\xb5'}, {'\xe6','\x82','\x81'}, {'\xe6','\x82','\x94'}, + /* 896 */ {'\xe6','\x83','\x87'}, {'\xe6','\x83','\x98'}, {'\xe6','\x83','\xa1'}, {'\xe6','\x84','\x88'}, {'\xe6','\x85','\x84'}, {'\xe6','\x85','\x88'}, {'\xe6','\x85','\x8c'}, {'\xe6','\x85','\x8e'}, + /* 904 */ {'\xe6','\x85','\xa0'}, {'\xe6','\x85','\xa8'}, {'\xe6','\x85','\xba'}, {'\xe6','\x86','\x8e'}, {'\xe6','\x86','\x90'}, {'\xe6','\x86','\xa4'}, {'\xe6','\x86','\xaf'}, {'\xe6','\x86','\xb2'}, + /* 912 */ {'\xe6','\x87','\x9e'}, {'\xe6','\x87','\xb2'}, {'\xe6','\x87','\xb6'}, {'\xe6','\x88','\x80'}, {'\xe6','\x88','\x88'}, {'\xe6','\x88','\x90'}, {'\xe6','\x88','\x9b'}, {'\xe6','\x88','\xae'}, + /* 920 */ {'\xe6','\x88','\xb4'}, {'\xe6','\x88','\xb6'}, {'\xe6','\x89','\x8b'}, {'\xe6','\x89','\x93'}, {'\xe6','\x89','\x9d'}, {'\xe6','\x8a','\x95'}, {'\xe6','\x8a','\xb1'}, {'\xe6','\x8b','\x89'}, + /* 928 */ {'\xe6','\x8b','\x8f'}, {'\xe6','\x8b','\x93'}, {'\xe6','\x8b','\x94'}, {'\xe6','\x8b','\xbc'}, {'\xe6','\x8b','\xbe'}, {'\xe6','\x8c','\x87'}, {'\xe6','\x8c','\xbd'}, {'\xe6','\x8d','\x90'}, + /* 936 */ {'\xe6','\x8d','\x95'}, {'\xe6','\x8d','\xa8'}, {'\xe6','\x8d','\xbb'}, {'\xe6','\x8e','\x83'}, {'\xe6','\x8e','\xa0'}, {'\xe6','\x8e','\xa9'}, {'\xe6','\x8f','\x84'}, {'\xe6','\x8f','\x85'}, + /* 944 */ {'\xe6','\x8f','\xa4'}, {'\xe6','\x90','\x9c'}, {'\xe6','\x90','\xa2'}, {'\xe6','\x91','\x92'}, {'\xe6','\x91','\xa9'}, {'\xe6','\x91','\xb7'}, {'\xe6','\x91','\xbe'}, {'\xe6','\x92','\x9a'}, + /* 952 */ {'\xe6','\x92','\x9d'}, {'\xe6','\x93','\x84'}, {'\xe6','\x94','\xaf'}, {'\xe6','\x94','\xb4'}, {'\xe6','\x95','\x8f'}, {'\xe6','\x95','\x96'}, {'\xe6','\x95','\xac'}, {'\xe6','\x95','\xb8'}, + /* 960 */ {'\xe6','\x96','\x87'}, {'\xe6','\x96','\x97'}, {'\xe6','\x96','\x99'}, {'\xe6','\x96','\xa4'}, {'\xe6','\x96','\xb0'}, {'\xe6','\x96','\xb9'}, {'\xe6','\x97','\x85'}, {'\xe6','\x97','\xa0'}, + /* 968 */ {'\xe6','\x97','\xa2'}, {'\xe6','\x97','\xa3'}, {'\xe6','\x97','\xa5'}, {'\xe6','\x98','\x93'}, {'\xe6','\x98','\xa0'}, {'\xe6','\x99','\x89'}, {'\xe6','\x99','\xb4'}, {'\xe6','\x9a','\x88'}, + /* 976 */ {'\xe6','\x9a','\x91'}, {'\xe6','\x9a','\x9c'}, {'\xe6','\x9a','\xb4'}, {'\xe6','\x9b','\x86'}, {'\xe6','\x9b','\xb0'}, {'\xe6','\x9b','\xb4'}, {'\xe6','\x9b','\xb8'}, {'\xe6','\x9c','\x80'}, + /* 984 */ {'\xe6','\x9c','\x88'}, {'\xe6','\x9c','\x89'}, {'\xe6','\x9c','\x97'}, {'\xe6','\x9c','\x9b'}, {'\xe6','\x9c','\xa1'}, {'\xe6','\x9c','\xa8'}, {'\xe6','\x9d','\x8e'}, {'\xe6','\x9d','\x93'}, + /* 992 */ {'\xe6','\x9d','\x96'}, {'\xe6','\x9d','\x9e'}, {'\xe6','\x9d','\xbb'}, {'\xe6','\x9e','\x85'}, {'\xe6','\x9e','\x97'}, {'\xe6','\x9f','\xb3'}, {'\xe6','\x9f','\xba'}, {'\xe6','\xa0','\x97'}, + /* 1000 */ {'\xe6','\xa0','\x9f'}, {'\xe6','\xa0','\xaa'}, {'\xe6','\xa1','\x92'}, {'\xe6','\xa2','\x81'}, {'\xe6','\xa2','\x85'}, {'\xe6','\xa2','\x8e'}, {'\xe6','\xa2','\xa8'}, {'\xe6','\xa4','\x94'}, + /* 1008 */ {'\xe6','\xa5','\x82'}, {'\xe6','\xa6','\xa3'}, {'\xe6','\xa7','\xaa'}, {'\xe6','\xa8','\x82'}, {'\xe6','\xa8','\x93'}, {'\xe6','\xaa','\xa8'}, {'\xe6','\xab','\x93'}, {'\xe6','\xab','\x9b'}, + /* 1016 */ {'\xe6','\xac','\x84'}, {'\xe6','\xac','\xa0'}, {'\xe6','\xac','\xa1'}, {'\xe6','\xad','\x94'}, {'\xe6','\xad','\xa2'}, {'\xe6','\xad','\xa3'}, {'\xe6','\xad','\xb2'}, {'\xe6','\xad','\xb7'}, + /* 1024 */ {'\xe6','\xad','\xb9'}, {'\xe6','\xae','\x9f'}, {'\xe6','\xae','\xae'}, {'\xe6','\xae','\xb3'}, {'\xe6','\xae','\xba'}, {'\xe6','\xae','\xbb'}, {'\xe6','\xaf','\x8b'}, {'\xe6','\xaf','\x8d'}, + /* 1032 */ {'\xe6','\xaf','\x94'}, {'\xe6','\xaf','\x9b'}, {'\xe6','\xb0','\x8f'}, {'\xe6','\xb0','\x94'}, {'\xe6','\xb0','\xb4'}, {'\xe6','\xb1','\x8e'}, {'\xe6','\xb1','\xa7'}, {'\xe6','\xb2','\x88'}, + /* 1040 */ {'\xe6','\xb2','\xbf'}, {'\xe6','\xb3','\x8c'}, {'\xe6','\xb3','\x8d'}, {'\xe6','\xb3','\xa5'}, {'\xe6','\xb3','\xa8'}, {'\xe6','\xb4','\x96'}, {'\xe6','\xb4','\x9b'}, {'\xe6','\xb4','\x9e'}, + /* 1048 */ {'\xe6','\xb4','\xb4'}, {'\xe6','\xb4','\xbe'}, {'\xe6','\xb5','\x81'}, {'\xe6','\xb5','\xa9'}, {'\xe6','\xb5','\xaa'}, {'\xe6','\xb5','\xb7'}, {'\xe6','\xb5','\xb8'}, {'\xe6','\xb6','\x85'}, + /* 1056 */ {'\xe6','\xb7','\x8b'}, {'\xe6','\xb7','\x9a'}, {'\xe6','\xb7','\xaa'}, {'\xe6','\xb7','\xb9'}, {'\xe6','\xb8','\x9a'}, {'\xe6','\xb8','\xaf'}, {'\xe6','\xb9','\xae'}, {'\xe6','\xba','\x80'}, + /* 1064 */ {'\xe6','\xba','\x9c'}, {'\xe6','\xba','\xba'}, {'\xe6','\xbb','\x87'}, {'\xe6','\xbb','\x8b'}, {'\xe6','\xbb','\x91'}, {'\xe6','\xbb','\x9b'}, {'\xe6','\xbc','\x8f'}, {'\xe6','\xbc','\x94'}, + /* 1072 */ {'\xe6','\xbc','\xa2'}, {'\xe6','\xbc','\xa3'}, {'\xe6','\xbd','\xae'}, {'\xe6','\xbf','\x86'}, {'\xe6','\xbf','\xab'}, {'\xe6','\xbf','\xbe'}, {'\xe7','\x80','\x9b'}, {'\xe7','\x80','\x9e'}, + /* 1080 */ {'\xe7','\x80','\xb9'}, {'\xe7','\x81','\x8a'}, {'\xe7','\x81','\xab'}, {'\xe7','\x81','\xb0'}, {'\xe7','\x81','\xb7'}, {'\xe7','\x81','\xbd'}, {'\xe7','\x82','\x99'}, {'\xe7','\x82','\xad'}, + /* 1088 */ {'\xe7','\x83','\x88'}, {'\xe7','\x83','\x99'}, {'\xe7','\x84','\xa1'}, {'\xe7','\x85','\x85'}, {'\xe7','\x85','\x89'}, {'\xe7','\x85','\xae'}, {'\xe7','\x86','\x9c'}, {'\xe7','\x87','\x8e'}, + /* 1096 */ {'\xe7','\x87','\x90'}, {'\xe7','\x88','\x90'}, {'\xe7','\x88','\x9b'}, {'\xe7','\x88','\xa8'}, {'\xe7','\x88','\xaa'}, {'\xe7','\x88','\xab'}, {'\xe7','\x88','\xb5'}, {'\xe7','\x88','\xb6'}, + /* 1104 */ {'\xe7','\x88','\xbb'}, {'\xe7','\x88','\xbf'}, {'\xe7','\x89','\x87'}, {'\xe7','\x89','\x90'}, {'\xe7','\x89','\x99'}, {'\xe7','\x89','\x9b'}, {'\xe7','\x89','\xa2'}, {'\xe7','\x89','\xb9'}, + /* 1112 */ {'\xe7','\x8a','\x80'}, {'\xe7','\x8a','\x95'}, {'\xe7','\x8a','\xac'}, {'\xe7','\x8a','\xaf'}, {'\xe7','\x8b','\x80'}, {'\xe7','\x8b','\xbc'}, {'\xe7','\x8c','\xaa'}, {'\xe7','\x8d','\xb5'}, + /* 1120 */ {'\xe7','\x8d','\xba'}, {'\xe7','\x8e','\x84'}, {'\xe7','\x8e','\x87'}, {'\xe7','\x8e','\x89'}, {'\xe7','\x8e','\x8b'}, {'\xe7','\x8e','\xa5'}, {'\xe7','\x8e','\xb2'}, {'\xe7','\x8f','\x9e'}, + /* 1128 */ {'\xe7','\x90','\x86'}, {'\xe7','\x90','\x89'}, {'\xe7','\x90','\xa2'}, {'\xe7','\x91','\x87'}, {'\xe7','\x91','\x9c'}, {'\xe7','\x91','\xa9'}, {'\xe7','\x91','\xb1'}, {'\xe7','\x92','\x85'}, + /* 1136 */ {'\xe7','\x92','\x89'}, {'\xe7','\x92','\x98'}, {'\xe7','\x93','\x8a'}, {'\xe7','\x93','\x9c'}, {'\xe7','\x93','\xa6'}, {'\xe7','\x94','\x86'}, {'\xe7','\x94','\x98'}, {'\xe7','\x94','\x9f'}, + /* 1144 */ {'\xe7','\x94','\xa4'}, {'\xe7','\x94','\xa8'}, {'\xe7','\x94','\xb0'}, {'\xe7','\x94','\xb2'}, {'\xe7','\x94','\xb3'}, {'\xe7','\x94','\xb7'}, {'\xe7','\x94','\xbb'}, {'\xe7','\x94','\xbe'}, + /* 1152 */ {'\xe7','\x95','\x99'}, {'\xe7','\x95','\xa5'}, {'\xe7','\x95','\xb0'}, {'\xe7','\x96','\x8b'}, {'\xe7','\x96','\x92'}, {'\xe7','\x97','\xa2'}, {'\xe7','\x98','\x90'}, {'\xe7','\x98','\x9d'}, + /* 1160 */ {'\xe7','\x98','\x9f'}, {'\xe7','\x99','\x82'}, {'\xe7','\x99','\xa9'}, {'\xe7','\x99','\xb6'}, {'\xe7','\x99','\xbd'}, {'\xe7','\x9a','\xae'}, {'\xe7','\x9a','\xbf'}, {'\xe7','\x9b','\x8a'}, + /* 1168 */ {'\xe7','\x9b','\x9b'}, {'\xe7','\x9b','\xa3'}, {'\xe7','\x9b','\xa7'}, {'\xe7','\x9b','\xae'}, {'\xe7','\x9b','\xb4'}, {'\xe7','\x9c','\x81'}, {'\xe7','\x9c','\x9e'}, {'\xe7','\x9c','\x9f'}, + /* 1176 */ {'\xe7','\x9d','\x80'}, {'\xe7','\x9d','\x8a'}, {'\xe7','\x9e','\x8b'}, {'\xe7','\x9e','\xa7'}, {'\xe7','\x9f','\x9b'}, {'\xe7','\x9f','\xa2'}, {'\xe7','\x9f','\xb3'}, {'\xe7','\xa1','\x8e'}, + /* 1184 */ {'\xe7','\xa1','\xab'}, {'\xe7','\xa2','\x8c'}, {'\xe7','\xa2','\x91'}, {'\xe7','\xa3','\x8a'}, {'\xe7','\xa3','\x8c'}, {'\xe7','\xa3','\xbb'}, {'\xe7','\xa4','\xaa'}, {'\xe7','\xa4','\xba'}, + /* 1192 */ {'\xe7','\xa4','\xbc'}, {'\xe7','\xa4','\xbe'}, {'\xe7','\xa5','\x88'}, {'\xe7','\xa5','\x89'}, {'\xe7','\xa5','\x90'}, {'\xe7','\xa5','\x96'}, {'\xe7','\xa5','\x9d'}, {'\xe7','\xa5','\x9e'}, + /* 1200 */ {'\xe7','\xa5','\xa5'}, {'\xe7','\xa5','\xbf'}, {'\xe7','\xa6','\x81'}, {'\xe7','\xa6','\x8d'}, {'\xe7','\xa6','\x8e'}, {'\xe7','\xa6','\x8f'}, {'\xe7','\xa6','\xae'}, {'\xe7','\xa6','\xb8'}, + /* 1208 */ {'\xe7','\xa6','\xbe'}, {'\xe7','\xa7','\x8a'}, {'\xe7','\xa7','\x98'}, {'\xe7','\xa7','\xab'}, {'\xe7','\xa8','\x9c'}, {'\xe7','\xa9','\x80'}, {'\xe7','\xa9','\x8a'}, {'\xe7','\xa9','\x8f'}, + /* 1216 */ {'\xe7','\xa9','\xb4'}, {'\xe7','\xa9','\xba'}, {'\xe7','\xaa','\x81'}, {'\xe7','\xaa','\xb1'}, {'\xe7','\xab','\x8b'}, {'\xe7','\xab','\xae'}, {'\xe7','\xab','\xb9'}, {'\xe7','\xac','\xa0'}, + /* 1224 */ {'\xe7','\xae','\x8f'}, {'\xe7','\xaf','\x80'}, {'\xe7','\xaf','\x86'}, {'\xe7','\xaf','\x89'}, {'\xe7','\xb0','\xbe'}, {'\xe7','\xb1','\xa0'}, {'\xe7','\xb1','\xb3'}, {'\xe7','\xb1','\xbb'}, + /* 1232 */ {'\xe7','\xb2','\x92'}, {'\xe7','\xb2','\xbe'}, {'\xe7','\xb3','\x92'}, {'\xe7','\xb3','\x96'}, {'\xe7','\xb3','\xa3'}, {'\xe7','\xb3','\xa7'}, {'\xe7','\xb3','\xa8'}, {'\xe7','\xb3','\xb8'}, + /* 1240 */ {'\xe7','\xb4','\x80'}, {'\xe7','\xb4','\x90'}, {'\xe7','\xb4','\xa2'}, {'\xe7','\xb4','\xaf'}, {'\xe7','\xb5','\x82'}, {'\xe7','\xb5','\x9b'}, {'\xe7','\xb5','\xa3'}, {'\xe7','\xb6','\xa0'}, + /* 1248 */ {'\xe7','\xb6','\xbe'}, {'\xe7','\xb7','\x87'}, {'\xe7','\xb7','\xb4'}, {'\xe7','\xb8','\x82'}, {'\xe7','\xb8','\x89'}, {'\xe7','\xb8','\xb7'}, {'\xe7','\xb9','\x81'}, {'\xe7','\xb9','\x85'}, + /* 1256 */ {'\xe7','\xbc','\xb6'}, {'\xe7','\xbc','\xbe'}, {'\xe7','\xbd','\x91'}, {'\xe7','\xbd','\xb2'}, {'\xe7','\xbd','\xb9'}, {'\xe7','\xbd','\xba'}, {'\xe7','\xbe','\x85'}, {'\xe7','\xbe','\x8a'}, + /* 1264 */ {'\xe7','\xbe','\x95'}, {'\xe7','\xbe','\x9a'}, {'\xe7','\xbe','\xbd'}, {'\xe7','\xbf','\xba'}, {'\xe8','\x80','\x81'}, {'\xe8','\x80','\x85'}, {'\xe8','\x80','\x8c'}, {'\xe8','\x80','\x92'}, + /* 1272 */ {'\xe8','\x80','\xb3'}, {'\xe8','\x81','\x86'}, {'\xe8','\x81','\xa0'}, {'\xe8','\x81','\xaf'}, {'\xe8','\x81','\xb0'}, {'\xe8','\x81','\xbe'}, {'\xe8','\x81','\xbf'}, {'\xe8','\x82','\x89'}, + /* 1280 */ {'\xe8','\x82','\x8b'}, {'\xe8','\x82','\xad'}, {'\xe8','\x82','\xb2'}, {'\xe8','\x84','\x83'}, {'\xe8','\x84','\xbe'}, {'\xe8','\x87','\x98'}, {'\xe8','\x87','\xa3'}, {'\xe8','\x87','\xa8'}, + /* 1288 */ {'\xe8','\x87','\xaa'}, {'\xe8','\x87','\xad'}, {'\xe8','\x87','\xb3'}, {'\xe8','\x87','\xbc'}, {'\xe8','\x88','\x81'}, {'\xe8','\x88','\x84'}, {'\xe8','\x88','\x8c'}, {'\xe8','\x88','\x98'}, + /* 1296 */ {'\xe8','\x88','\x9b'}, {'\xe8','\x88','\x9f'}, {'\xe8','\x89','\xae'}, {'\xe8','\x89','\xaf'}, {'\xe8','\x89','\xb2'}, {'\xe8','\x89','\xb8'}, {'\xe8','\x89','\xb9'}, {'\xe8','\x8a','\x8b'}, + /* 1304 */ {'\xe8','\x8a','\x91'}, {'\xe8','\x8a','\x9d'}, {'\xe8','\x8a','\xb1'}, {'\xe8','\x8a','\xb3'}, {'\xe8','\x8a','\xbd'}, {'\xe8','\x8b','\xa5'}, {'\xe8','\x8b','\xa6'}, {'\xe8','\x8c','\x9d'}, + /* 1312 */ {'\xe8','\x8c','\xa3'}, {'\xe8','\x8c','\xb6'}, {'\xe8','\x8d','\x92'}, {'\xe8','\x8d','\x93'}, {'\xe8','\x8d','\xa3'}, {'\xe8','\x8e','\xad'}, {'\xe8','\x8e','\xbd'}, {'\xe8','\x8f','\x89'}, + /* 1320 */ {'\xe8','\x8f','\x8a'}, {'\xe8','\x8f','\x8c'}, {'\xe8','\x8f','\x9c'}, {'\xe8','\x8f','\xa7'}, {'\xe8','\x8f','\xaf'}, {'\xe8','\x8f','\xb1'}, {'\xe8','\x90','\xbd'}, {'\xe8','\x91','\x89'}, + /* 1328 */ {'\xe8','\x91','\x97'}, {'\xe8','\x93','\xae'}, {'\xe8','\x93','\xb1'}, {'\xe8','\x93','\xb3'}, {'\xe8','\x93','\xbc'}, {'\xe8','\x94','\x96'}, {'\xe8','\x95','\xa4'}, {'\xe8','\x97','\x8d'}, + /* 1336 */ {'\xe8','\x97','\xba'}, {'\xe8','\x98','\x86'}, {'\xe8','\x98','\x92'}, {'\xe8','\x98','\xad'}, {'\xe8','\x98','\xbf'}, {'\xe8','\x99','\x8d'}, {'\xe8','\x99','\x90'}, {'\xe8','\x99','\x9c'}, + /* 1344 */ {'\xe8','\x99','\xa7'}, {'\xe8','\x99','\xa9'}, {'\xe8','\x99','\xab'}, {'\xe8','\x9a','\x88'}, {'\xe8','\x9a','\xa9'}, {'\xe8','\x9b','\xa2'}, {'\xe8','\x9c','\x8e'}, {'\xe8','\x9c','\xa8'}, + /* 1352 */ {'\xe8','\x9d','\xab'}, {'\xe8','\x9d','\xb9'}, {'\xe8','\x9e','\x86'}, {'\xe8','\x9e','\xba'}, {'\xe8','\x9f','\xa1'}, {'\xe8','\xa0','\x81'}, {'\xe8','\xa0','\x9f'}, {'\xe8','\xa1','\x80'}, + /* 1360 */ {'\xe8','\xa1','\x8c'}, {'\xe8','\xa1','\xa0'}, {'\xe8','\xa1','\xa3'}, {'\xe8','\xa3','\x82'}, {'\xe8','\xa3','\x8f'}, {'\xe8','\xa3','\x97'}, {'\xe8','\xa3','\x9e'}, {'\xe8','\xa3','\xa1'}, + /* 1368 */ {'\xe8','\xa3','\xb8'}, {'\xe8','\xa3','\xba'}, {'\xe8','\xa4','\x90'}, {'\xe8','\xa5','\x81'}, {'\xe8','\xa5','\xa4'}, {'\xe8','\xa5','\xbe'}, {'\xe8','\xa6','\x86'}, {'\xe8','\xa6','\x8b'}, + /* 1376 */ {'\xe8','\xa6','\x96'}, {'\xe8','\xa7','\x92'}, {'\xe8','\xa7','\xa3'}, {'\xe8','\xa8','\x80'}, {'\xe8','\xaa','\xa0'}, {'\xe8','\xaa','\xaa'}, {'\xe8','\xaa','\xbf'}, {'\xe8','\xab','\x8b'}, + /* 1384 */ {'\xe8','\xab','\x92'}, {'\xe8','\xab','\x96'}, {'\xe8','\xab','\xad'}, {'\xe8','\xab','\xb8'}, {'\xe8','\xab','\xbe'}, {'\xe8','\xac','\x81'}, {'\xe8','\xac','\xb9'}, {'\xe8','\xad','\x98'}, + /* 1392 */ {'\xe8','\xae','\x80'}, {'\xe8','\xae','\x8a'}, {'\xe8','\xb0','\xb7'}, {'\xe8','\xb1','\x86'}, {'\xe8','\xb1','\x88'}, {'\xe8','\xb1','\x95'}, {'\xe8','\xb1','\xb8'}, {'\xe8','\xb2','\x9d'}, + /* 1400 */ {'\xe8','\xb2','\xa1'}, {'\xe8','\xb2','\xa9'}, {'\xe8','\xb2','\xab'}, {'\xe8','\xb3','\x81'}, {'\xe8','\xb3','\x82'}, {'\xe8','\xb3','\x87'}, {'\xe8','\xb3','\x88'}, {'\xe8','\xb3','\x93'}, + /* 1408 */ {'\xe8','\xb4','\x88'}, {'\xe8','\xb4','\x9b'}, {'\xe8','\xb5','\xa4'}, {'\xe8','\xb5','\xb0'}, {'\xe8','\xb5','\xb7'}, {'\xe8','\xb6','\xb3'}, {'\xe8','\xb6','\xbc'}, {'\xe8','\xb7','\x8b'}, + /* 1416 */ {'\xe8','\xb7','\xaf'}, {'\xe8','\xb7','\xb0'}, {'\xe8','\xba','\xab'}, {'\xe8','\xbb','\x8a'}, {'\xe8','\xbb','\x94'}, {'\xe8','\xbc','\xa6'}, {'\xe8','\xbc','\xaa'}, {'\xe8','\xbc','\xb8'}, + /* 1424 */ {'\xe8','\xbc','\xbb'}, {'\xe8','\xbd','\xa2'}, {'\xe8','\xbe','\x9b'}, {'\xe8','\xbe','\x9e'}, {'\xe8','\xbe','\xb0'}, {'\xe8','\xbe','\xb5'}, {'\xe8','\xbe','\xb6'}, {'\xe9','\x80','\xa3'}, + /* 1432 */ {'\xe9','\x80','\xb8'}, {'\xe9','\x81','\x8a'}, {'\xe9','\x81','\xa9'}, {'\xe9','\x81','\xb2'}, {'\xe9','\x81','\xbc'}, {'\xe9','\x82','\x8f'}, {'\xe9','\x82','\x91'}, {'\xe9','\x82','\x94'}, + /* 1440 */ {'\xe9','\x83','\x8e'}, {'\xe9','\x83','\x9e'}, {'\xe9','\x83','\xb1'}, {'\xe9','\x83','\xbd'}, {'\xe9','\x84','\x91'}, {'\xe9','\x84','\x9b'}, {'\xe9','\x85','\x89'}, {'\xe9','\x85','\x8d'}, + /* 1448 */ {'\xe9','\x85','\xaa'}, {'\xe9','\x86','\x99'}, {'\xe9','\x86','\xb4'}, {'\xe9','\x87','\x86'}, {'\xe9','\x87','\x8c'}, {'\xe9','\x87','\x8f'}, {'\xe9','\x87','\x91'}, {'\xe9','\x88','\xb4'}, + /* 1456 */ {'\xe9','\x88','\xb8'}, {'\xe9','\x89','\xb6'}, {'\xe9','\x89','\xbc'}, {'\xe9','\x8b','\x97'}, {'\xe9','\x8b','\x98'}, {'\xe9','\x8c','\x84'}, {'\xe9','\x8d','\x8a'}, {'\xe9','\x8f','\xb9'}, + /* 1464 */ {'\xe9','\x90','\x95'}, {'\xe9','\x95','\xb7'}, {'\xe9','\x96','\x80'}, {'\xe9','\x96','\x8b'}, {'\xe9','\x96','\xad'}, {'\xe9','\x96','\xb7'}, {'\xe9','\x98','\x9c'}, {'\xe9','\x98','\xae'}, + /* 1472 */ {'\xe9','\x99','\x8b'}, {'\xe9','\x99','\x8d'}, {'\xe9','\x99','\xb5'}, {'\xe9','\x99','\xb8'}, {'\xe9','\x99','\xbc'}, {'\xe9','\x9a','\x86'}, {'\xe9','\x9a','\xa3'}, {'\xe9','\x9a','\xb6'}, + /* 1480 */ {'\xe9','\x9a','\xb7'}, {'\xe9','\x9a','\xb8'}, {'\xe9','\x9a','\xb9'}, {'\xe9','\x9b','\x83'}, {'\xe9','\x9b','\xa2'}, {'\xe9','\x9b','\xa3'}, {'\xe9','\x9b','\xa8'}, {'\xe9','\x9b','\xb6'}, + /* 1488 */ {'\xe9','\x9b','\xb7'}, {'\xe9','\x9c','\xa3'}, {'\xe9','\x9c','\xb2'}, {'\xe9','\x9d','\x88'}, {'\xe9','\x9d','\x91'}, {'\xe9','\x9d','\x96'}, {'\xe9','\x9d','\x9e'}, {'\xe9','\x9d','\xa2'}, + /* 1496 */ {'\xe9','\x9d','\xa9'}, {'\xe9','\x9f','\x8b'}, {'\xe9','\x9f','\x9b'}, {'\xe9','\x9f','\xa0'}, {'\xe9','\x9f','\xad'}, {'\xe9','\x9f','\xb3'}, {'\xe9','\x9f','\xbf'}, {'\xe9','\xa0','\x81'}, + /* 1504 */ {'\xe9','\xa0','\x85'}, {'\xe9','\xa0','\x8b'}, {'\xe9','\xa0','\x98'}, {'\xe9','\xa0','\xa9'}, {'\xe9','\xa0','\xbb'}, {'\xe9','\xa1','\x9e'}, {'\xe9','\xa2','\xa8'}, {'\xe9','\xa3','\x9b'}, + /* 1512 */ {'\xe9','\xa3','\x9f'}, {'\xe9','\xa3','\xa2'}, {'\xe9','\xa3','\xaf'}, {'\xe9','\xa3','\xbc'}, {'\xe9','\xa4','\xa8'}, {'\xe9','\xa4','\xa9'}, {'\xe9','\xa6','\x96'}, {'\xe9','\xa6','\x99'}, + /* 1520 */ {'\xe9','\xa6','\xa7'}, {'\xe9','\xa6','\xac'}, {'\xe9','\xa7','\x82'}, {'\xe9','\xa7','\xb1'}, {'\xe9','\xa7','\xbe'}, {'\xe9','\xa9','\xaa'}, {'\xe9','\xaa','\xa8'}, {'\xe9','\xab','\x98'}, + /* 1528 */ {'\xe9','\xab','\x9f'}, {'\xe9','\xac','\x92'}, {'\xe9','\xac','\xa5'}, {'\xe9','\xac','\xaf'}, {'\xe9','\xac','\xb2'}, {'\xe9','\xac','\xbc'}, {'\xe9','\xad','\x9a'}, {'\xe9','\xad','\xaf'}, + /* 1536 */ {'\xe9','\xb1','\x80'}, {'\xe9','\xb1','\x97'}, {'\xe9','\xb3','\xa5'}, {'\xe9','\xb3','\xbd'}, {'\xe9','\xb5','\xa7'}, {'\xe9','\xb6','\xb4'}, {'\xe9','\xb7','\xba'}, {'\xe9','\xb8','\x9e'}, + /* 1544 */ {'\xe9','\xb9','\xb5'}, {'\xe9','\xb9','\xbf'}, {'\xe9','\xba','\x97'}, {'\xe9','\xba','\x9f'}, {'\xe9','\xba','\xa5'}, {'\xe9','\xba','\xbb'}, {'\xe9','\xbb','\x83'}, {'\xe9','\xbb','\x8d'}, + /* 1552 */ {'\xe9','\xbb','\x8e'}, {'\xe9','\xbb','\x91'}, {'\xe9','\xbb','\xb9'}, {'\xe9','\xbb','\xbd'}, {'\xe9','\xbb','\xbe'}, {'\xe9','\xbc','\x85'}, {'\xe9','\xbc','\x8e'}, {'\xe9','\xbc','\x8f'}, + /* 1560 */ {'\xe9','\xbc','\x93'}, {'\xe9','\xbc','\x96'}, {'\xe9','\xbc','\xa0'}, {'\xe9','\xbc','\xbb'}, {'\xe9','\xbd','\x83'}, {'\xe9','\xbd','\x8a'}, {'\xe9','\xbd','\x92'}, {'\xe9','\xbe','\x8d'}, + /* 1568 */ {'\xe9','\xbe','\x8e'}, {'\xe9','\xbe','\x9c'}, {'\xe9','\xbe','\x9f'}, {'\xe9','\xbe','\xa0'}, {'\xea','\x9c','\xa7'}, {'\xea','\x9d','\xaf'}, {'\xea','\xac','\xb7'}, {'\xea','\xad','\x92'}, + /* 1576 */ {'a','/','c'}, {'a','/','s'}, {'a','\xca','\xbe'}, {'a','\xcc','\x80'}, {'a','\xcc','\x81'}, {'a','\xcc','\x82'}, {'a','\xcc','\x83'}, {'a','\xcc','\x84'}, + /* 1584 */ {'a','\xcc','\x86'}, {'a','\xcc','\x87'}, {'a','\xcc','\x88'}, {'a','\xcc','\x89'}, {'a','\xcc','\x8a'}, {'a','\xcc','\x8c'}, {'a','\xcc','\x8f'}, {'a','\xcc','\x91'}, + /* 1592 */ {'a','\xcc','\xa3'}, {'a','\xcc','\xa5'}, {'a','\xcc','\xa8'}, {'b','\xcc','\x87'}, {'b','\xcc','\xa3'}, {'b','\xcc','\xb1'}, {'b','a','r'}, {'c','/','o'}, + /* 1600 */ {'c','/','u'}, {'c','\xcc','\x81'}, {'c','\xcc','\x82'}, {'c','\xcc','\x87'}, {'c','\xcc','\x8c'}, {'c','\xcc','\xa7'}, {'c','a','l'}, {'c','m','2'}, + /* 1608 */ {'c','m','3'}, {'d','\xcc','\x87'}, {'d','\xcc','\x8c'}, {'d','\xcc','\xa3'}, {'d','\xcc','\xa7'}, {'d','\xcc','\xad'}, {'d','\xcc','\xb1'}, {'d','m','2'}, + /* 1616 */ {'d','m','3'}, {'e','\xcc','\x80'}, {'e','\xcc','\x81'}, {'e','\xcc','\x82'}, {'e','\xcc','\x83'}, {'e','\xcc','\x84'}, {'e','\xcc','\x86'}, {'e','\xcc','\x87'}, + /* 1624 */ {'e','\xcc','\x88'}, {'e','\xcc','\x89'}, {'e','\xcc','\x8c'}, {'e','\xcc','\x8f'}, {'e','\xcc','\x91'}, {'e','\xcc','\xa3'}, {'e','\xcc','\xa7'}, {'e','\xcc','\xa8'}, + /* 1632 */ {'e','\xcc','\xad'}, {'e','\xcc','\xb0'}, {'e','r','g'}, {'f','\xcc','\x87'}, {'f','f','i'}, {'f','f','l'}, {'g','\xcc','\x81'}, {'g','\xcc','\x82'}, + /* 1640 */ {'g','\xcc','\x84'}, {'g','\xcc','\x86'}, {'g','\xcc','\x87'}, {'g','\xcc','\x8c'}, {'g','\xcc','\xa7'}, {'g','a','l'}, {'h','P','a'}, {'h','\xcc','\x82'}, + /* 1648 */ {'h','\xcc','\x87'}, {'h','\xcc','\x88'}, {'h','\xcc','\x8c'}, {'h','\xcc','\xa3'}, {'h','\xcc','\xa7'}, {'h','\xcc','\xae'}, {'h','\xcc','\xb1'}, {'i','\xcc','\x80'}, + /* 1656 */ {'i','\xcc','\x81'}, {'i','\xcc','\x82'}, {'i','\xcc','\x83'}, {'i','\xcc','\x84'}, {'i','\xcc','\x86'}, {'i','\xcc','\x88'}, {'i','\xcc','\x89'}, {'i','\xcc','\x8c'}, + /* 1664 */ {'i','\xcc','\x8f'}, {'i','\xcc','\x91'}, {'i','\xcc','\xa3'}, {'i','\xcc','\xa8'}, {'i','\xcc','\xb0'}, {'i','i','i'}, {'j','\xcc','\x82'}, {'j','\xcc','\x8c'}, + /* 1672 */ {'k','H','z'}, {'k','P','a'}, {'k','\xcc','\x81'}, {'k','\xcc','\x8c'}, {'k','\xcc','\xa3'}, {'k','\xcc','\xa7'}, {'k','\xcc','\xb1'}, {'k','\xce','\xa9'}, + /* 1680 */ {'k','m','2'}, {'k','m','3'}, {'l','\xc2','\xb7'}, {'l','\xcc','\x81'}, {'l','\xcc','\x8c'}, {'l','\xcc','\xa3'}, {'l','\xcc','\xa7'}, {'l','\xcc','\xad'}, + /* 1688 */ {'l','\xcc','\xb1'}, {'l','o','g'}, {'m','\xcc','\x81'}, {'m','\xcc','\x87'}, {'m','\xcc','\xa3'}, {'m','i','l'}, {'m','m','2'}, {'m','m','3'}, + /* 1696 */ {'m','o','l'}, {'n','\xcc','\x80'}, {'n','\xcc','\x81'}, {'n','\xcc','\x83'}, {'n','\xcc','\x87'}, {'n','\xcc','\x8c'}, {'n','\xcc','\xa3'}, {'n','\xcc','\xa7'}, + /* 1704 */ {'n','\xcc','\xad'}, {'n','\xcc','\xb1'}, {'o','\xcc','\x80'}, {'o','\xcc','\x81'}, {'o','\xcc','\x82'}, {'o','\xcc','\x83'}, {'o','\xcc','\x84'}, {'o','\xcc','\x86'}, + /* 1712 */ {'o','\xcc','\x87'}, {'o','\xcc','\x88'}, {'o','\xcc','\x89'}, {'o','\xcc','\x8b'}, {'o','\xcc','\x8c'}, {'o','\xcc','\x8f'}, {'o','\xcc','\x91'}, {'o','\xcc','\x9b'}, + /* 1720 */ {'o','\xcc','\xa3'}, {'o','\xcc','\xa8'}, {'p','\xcc','\x81'}, {'p','\xcc','\x87'}, {'r','\xcc','\x81'}, {'r','\xcc','\x87'}, {'r','\xcc','\x8c'}, {'r','\xcc','\x8f'}, + /* 1728 */ {'r','\xcc','\x91'}, {'r','\xcc','\xa3'}, {'r','\xcc','\xa7'}, {'r','\xcc','\xb1'}, {'r','a','d'}, {'s','\xcc','\x81'}, {'s','\xcc','\x82'}, {'s','\xcc','\x87'}, + /* 1736 */ {'s','\xcc','\x8c'}, {'s','\xcc','\xa3'}, {'s','\xcc','\xa6'}, {'s','\xcc','\xa7'}, {'t','\xcc','\x87'}, {'t','\xcc','\x88'}, {'t','\xcc','\x8c'}, {'t','\xcc','\xa3'}, + /* 1744 */ {'t','\xcc','\xa6'}, {'t','\xcc','\xa7'}, {'t','\xcc','\xad'}, {'t','\xcc','\xb1'}, {'u','\xcc','\x80'}, {'u','\xcc','\x81'}, {'u','\xcc','\x82'}, {'u','\xcc','\x83'}, + /* 1752 */ {'u','\xcc','\x84'}, {'u','\xcc','\x86'}, {'u','\xcc','\x88'}, {'u','\xcc','\x89'}, {'u','\xcc','\x8a'}, {'u','\xcc','\x8b'}, {'u','\xcc','\x8c'}, {'u','\xcc','\x8f'}, + /* 1760 */ {'u','\xcc','\x91'}, {'u','\xcc','\x9b'}, {'u','\xcc','\xa3'}, {'u','\xcc','\xa4'}, {'u','\xcc','\xa8'}, {'u','\xcc','\xad'}, {'u','\xcc','\xb0'}, {'v','\xcc','\x83'}, + /* 1768 */ {'v','\xcc','\xa3'}, {'v','i','i'}, {'w','\xcc','\x80'}, {'w','\xcc','\x81'}, {'w','\xcc','\x82'}, {'w','\xcc','\x87'}, {'w','\xcc','\x88'}, {'w','\xcc','\x8a'}, + /* 1776 */ {'w','\xcc','\xa3'}, {'x','\xcc','\x87'}, {'x','\xcc','\x88'}, {'x','i','i'}, {'y','\xcc','\x80'}, {'y','\xcc','\x81'}, {'y','\xcc','\x82'}, {'y','\xcc','\x83'}, + /* 1784 */ {'y','\xcc','\x84'}, {'y','\xcc','\x87'}, {'y','\xcc','\x88'}, {'y','\xcc','\x89'}, {'y','\xcc','\x8a'}, {'y','\xcc','\xa3'}, {'z','\xcc','\x81'}, {'z','\xcc','\x82'}, + /* 1792 */ {'z','\xcc','\x87'}, {'z','\xcc','\x8c'}, {'z','\xcc','\xa3'}, {'z','\xcc','\xb1'}}; + +static const char UN8IF_compat_tbl_4 [508][4] = { + /* 0 */ {'(','1','0',')'}, {'(','1','1',')'}, {'(','1','2',')'}, {'(','1','3',')'}, {'(','1','4',')'}, {'(','1','5',')'}, {'(','1','6',')'}, {'(','1','7',')'}, + /* 8 */ {'(','1','8',')'}, {'(','1','9',')'}, {'(','2','0',')'}, {'0','\xe7','\x82','\xb9'}, {'1','\xe2','\x81','\x84'}, {'1','\xe6','\x97','\xa5'}, {'1','\xe6','\x9c','\x88'}, {'1','\xe7','\x82','\xb9'}, + /* 16 */ {'2','\xe6','\x97','\xa5'}, {'2','\xe6','\x9c','\x88'}, {'2','\xe7','\x82','\xb9'}, {'3','\xe6','\x97','\xa5'}, {'3','\xe6','\x9c','\x88'}, {'3','\xe7','\x82','\xb9'}, {'4','\xe6','\x97','\xa5'}, {'4','\xe6','\x9c','\x88'}, + /* 24 */ {'4','\xe7','\x82','\xb9'}, {'5','\xe6','\x97','\xa5'}, {'5','\xe6','\x9c','\x88'}, {'5','\xe7','\x82','\xb9'}, {'6','\xe6','\x97','\xa5'}, {'6','\xe6','\x9c','\x88'}, {'6','\xe7','\x82','\xb9'}, {'7','\xe6','\x97','\xa5'}, + /* 32 */ {'7','\xe6','\x9c','\x88'}, {'7','\xe7','\x82','\xb9'}, {'8','\xe6','\x97','\xa5'}, {'8','\xe6','\x9c','\x88'}, {'8','\xe7','\x82','\xb9'}, {'9','\xe6','\x97','\xa5'}, {'9','\xe6','\x9c','\x88'}, {'9','\xe7','\x82','\xb9'}, + /* 40 */ {'D','Z','\xcc','\x8c'}, {'D','z','\xcc','\x8c'}, {'V','I','I','I'}, {'\x20','\xe3','\x82','\x99'}, {'\x20','\xe3','\x82','\x9a'}, {'\xc3','\x86','\xcc','\x81'}, {'\xc3','\x86','\xcc','\x84'}, {'\xc3','\x98','\xcc','\x81'}, + /* 48 */ {'\xc3','\xa6','\xcc','\x81'}, {'\xc3','\xa6','\xcc','\x84'}, {'\xc3','\xb8','\xcc','\x81'}, {'\xc6','\xb7','\xcc','\x8c'}, {'\xca','\x92','\xcc','\x8c'}, {'\xcc','\x88','\xcc','\x81'}, {'\xce','\x91','\xcc','\x80'}, {'\xce','\x91','\xcc','\x81'}, + /* 56 */ {'\xce','\x91','\xcc','\x84'}, {'\xce','\x91','\xcc','\x86'}, {'\xce','\x91','\xcc','\x93'}, {'\xce','\x91','\xcc','\x94'}, {'\xce','\x91','\xcd','\x85'}, {'\xce','\x95','\xcc','\x80'}, {'\xce','\x95','\xcc','\x81'}, {'\xce','\x95','\xcc','\x93'}, + /* 64 */ {'\xce','\x95','\xcc','\x94'}, {'\xce','\x97','\xcc','\x80'}, {'\xce','\x97','\xcc','\x81'}, {'\xce','\x97','\xcc','\x93'}, {'\xce','\x97','\xcc','\x94'}, {'\xce','\x97','\xcd','\x85'}, {'\xce','\x99','\xcc','\x80'}, {'\xce','\x99','\xcc','\x81'}, + /* 72 */ {'\xce','\x99','\xcc','\x84'}, {'\xce','\x99','\xcc','\x86'}, {'\xce','\x99','\xcc','\x88'}, {'\xce','\x99','\xcc','\x93'}, {'\xce','\x99','\xcc','\x94'}, {'\xce','\x9f','\xcc','\x80'}, {'\xce','\x9f','\xcc','\x81'}, {'\xce','\x9f','\xcc','\x93'}, + /* 80 */ {'\xce','\x9f','\xcc','\x94'}, {'\xce','\xa1','\xcc','\x94'}, {'\xce','\xa5','\xcc','\x80'}, {'\xce','\xa5','\xcc','\x81'}, {'\xce','\xa5','\xcc','\x84'}, {'\xce','\xa5','\xcc','\x86'}, {'\xce','\xa5','\xcc','\x88'}, {'\xce','\xa5','\xcc','\x94'}, + /* 88 */ {'\xce','\xa9','\xcc','\x80'}, {'\xce','\xa9','\xcc','\x81'}, {'\xce','\xa9','\xcc','\x93'}, {'\xce','\xa9','\xcc','\x94'}, {'\xce','\xa9','\xcd','\x85'}, {'\xce','\xb1','\xcc','\x80'}, {'\xce','\xb1','\xcc','\x81'}, {'\xce','\xb1','\xcc','\x84'}, + /* 96 */ {'\xce','\xb1','\xcc','\x86'}, {'\xce','\xb1','\xcc','\x93'}, {'\xce','\xb1','\xcc','\x94'}, {'\xce','\xb1','\xcd','\x82'}, {'\xce','\xb1','\xcd','\x85'}, {'\xce','\xb5','\xcc','\x80'}, {'\xce','\xb5','\xcc','\x81'}, {'\xce','\xb5','\xcc','\x93'}, + /* 104 */ {'\xce','\xb5','\xcc','\x94'}, {'\xce','\xb7','\xcc','\x80'}, {'\xce','\xb7','\xcc','\x81'}, {'\xce','\xb7','\xcc','\x93'}, {'\xce','\xb7','\xcc','\x94'}, {'\xce','\xb7','\xcd','\x82'}, {'\xce','\xb7','\xcd','\x85'}, {'\xce','\xb9','\xcc','\x80'}, + /* 112 */ {'\xce','\xb9','\xcc','\x81'}, {'\xce','\xb9','\xcc','\x84'}, {'\xce','\xb9','\xcc','\x86'}, {'\xce','\xb9','\xcc','\x88'}, {'\xce','\xb9','\xcc','\x93'}, {'\xce','\xb9','\xcc','\x94'}, {'\xce','\xb9','\xcd','\x82'}, {'\xce','\xbf','\xcc','\x80'}, + /* 120 */ {'\xce','\xbf','\xcc','\x81'}, {'\xce','\xbf','\xcc','\x93'}, {'\xce','\xbf','\xcc','\x94'}, {'\xcf','\x81','\xcc','\x93'}, {'\xcf','\x81','\xcc','\x94'}, {'\xcf','\x85','\xcc','\x80'}, {'\xcf','\x85','\xcc','\x81'}, {'\xcf','\x85','\xcc','\x84'}, + /* 128 */ {'\xcf','\x85','\xcc','\x86'}, {'\xcf','\x85','\xcc','\x88'}, {'\xcf','\x85','\xcc','\x93'}, {'\xcf','\x85','\xcc','\x94'}, {'\xcf','\x85','\xcd','\x82'}, {'\xcf','\x89','\xcc','\x80'}, {'\xcf','\x89','\xcc','\x81'}, {'\xcf','\x89','\xcc','\x93'}, + /* 136 */ {'\xcf','\x89','\xcc','\x94'}, {'\xcf','\x89','\xcd','\x82'}, {'\xcf','\x89','\xcd','\x85'}, {'\xd0','\x86','\xcc','\x88'}, {'\xd0','\x90','\xcc','\x86'}, {'\xd0','\x90','\xcc','\x88'}, {'\xd0','\x93','\xcc','\x81'}, {'\xd0','\x95','\xcc','\x80'}, + /* 144 */ {'\xd0','\x95','\xcc','\x86'}, {'\xd0','\x95','\xcc','\x88'}, {'\xd0','\x96','\xcc','\x86'}, {'\xd0','\x96','\xcc','\x88'}, {'\xd0','\x97','\xcc','\x88'}, {'\xd0','\x98','\xcc','\x80'}, {'\xd0','\x98','\xcc','\x84'}, {'\xd0','\x98','\xcc','\x86'}, + /* 152 */ {'\xd0','\x98','\xcc','\x88'}, {'\xd0','\x9a','\xcc','\x81'}, {'\xd0','\x9e','\xcc','\x88'}, {'\xd0','\xa3','\xcc','\x84'}, {'\xd0','\xa3','\xcc','\x86'}, {'\xd0','\xa3','\xcc','\x88'}, {'\xd0','\xa3','\xcc','\x8b'}, {'\xd0','\xa7','\xcc','\x88'}, + /* 160 */ {'\xd0','\xab','\xcc','\x88'}, {'\xd0','\xad','\xcc','\x88'}, {'\xd0','\xb0','\xcc','\x86'}, {'\xd0','\xb0','\xcc','\x88'}, {'\xd0','\xb3','\xcc','\x81'}, {'\xd0','\xb5','\xcc','\x80'}, {'\xd0','\xb5','\xcc','\x86'}, {'\xd0','\xb5','\xcc','\x88'}, + /* 168 */ {'\xd0','\xb6','\xcc','\x86'}, {'\xd0','\xb6','\xcc','\x88'}, {'\xd0','\xb7','\xcc','\x88'}, {'\xd0','\xb8','\xcc','\x80'}, {'\xd0','\xb8','\xcc','\x84'}, {'\xd0','\xb8','\xcc','\x86'}, {'\xd0','\xb8','\xcc','\x88'}, {'\xd0','\xba','\xcc','\x81'}, + /* 176 */ {'\xd0','\xbe','\xcc','\x88'}, {'\xd1','\x83','\xcc','\x84'}, {'\xd1','\x83','\xcc','\x86'}, {'\xd1','\x83','\xcc','\x88'}, {'\xd1','\x83','\xcc','\x8b'}, {'\xd1','\x87','\xcc','\x88'}, {'\xd1','\x8b','\xcc','\x88'}, {'\xd1','\x8d','\xcc','\x88'}, + /* 184 */ {'\xd1','\x96','\xcc','\x88'}, {'\xd1','\xb4','\xcc','\x8f'}, {'\xd1','\xb5','\xcc','\x8f'}, {'\xd3','\x98','\xcc','\x88'}, {'\xd3','\x99','\xcc','\x88'}, {'\xd3','\xa8','\xcc','\x88'}, {'\xd3','\xa9','\xcc','\x88'}, {'\xd5','\xa5','\xd6','\x82'}, + /* 192 */ {'\xd5','\xb4','\xd5','\xa5'}, {'\xd5','\xb4','\xd5','\xab'}, {'\xd5','\xb4','\xd5','\xad'}, {'\xd5','\xb4','\xd5','\xb6'}, {'\xd5','\xbe','\xd5','\xb6'}, {'\xd7','\x90','\xd6','\xb7'}, {'\xd7','\x90','\xd6','\xb8'}, {'\xd7','\x90','\xd6','\xbc'}, + /* 200 */ {'\xd7','\x90','\xd7','\x9c'}, {'\xd7','\x91','\xd6','\xbc'}, {'\xd7','\x91','\xd6','\xbf'}, {'\xd7','\x92','\xd6','\xbc'}, {'\xd7','\x93','\xd6','\xbc'}, {'\xd7','\x94','\xd6','\xbc'}, {'\xd7','\x95','\xd6','\xb9'}, {'\xd7','\x95','\xd6','\xbc'}, + /* 208 */ {'\xd7','\x96','\xd6','\xbc'}, {'\xd7','\x98','\xd6','\xbc'}, {'\xd7','\x99','\xd6','\xb4'}, {'\xd7','\x99','\xd6','\xbc'}, {'\xd7','\x9a','\xd6','\xbc'}, {'\xd7','\x9b','\xd6','\xbc'}, {'\xd7','\x9b','\xd6','\xbf'}, {'\xd7','\x9c','\xd6','\xbc'}, + /* 216 */ {'\xd7','\x9e','\xd6','\xbc'}, {'\xd7','\xa0','\xd6','\xbc'}, {'\xd7','\xa1','\xd6','\xbc'}, {'\xd7','\xa3','\xd6','\xbc'}, {'\xd7','\xa4','\xd6','\xbc'}, {'\xd7','\xa4','\xd6','\xbf'}, {'\xd7','\xa6','\xd6','\xbc'}, {'\xd7','\xa7','\xd6','\xbc'}, + /* 224 */ {'\xd7','\xa8','\xd6','\xbc'}, {'\xd7','\xa9','\xd6','\xbc'}, {'\xd7','\xa9','\xd7','\x81'}, {'\xd7','\xa9','\xd7','\x82'}, {'\xd7','\xaa','\xd6','\xbc'}, {'\xd7','\xb2','\xd6','\xb7'}, {'\xd8','\xa7','\xd9','\x8b'}, {'\xd8','\xa7','\xd9','\x93'}, + /* 232 */ {'\xd8','\xa7','\xd9','\x94'}, {'\xd8','\xa7','\xd9','\x95'}, {'\xd8','\xa7','\xd9','\xb4'}, {'\xd8','\xa8','\xd8','\xac'}, {'\xd8','\xa8','\xd8','\xad'}, {'\xd8','\xa8','\xd8','\xae'}, {'\xd8','\xa8','\xd8','\xb1'}, {'\xd8','\xa8','\xd8','\xb2'}, + /* 240 */ {'\xd8','\xa8','\xd9','\x85'}, {'\xd8','\xa8','\xd9','\x86'}, {'\xd8','\xa8','\xd9','\x87'}, {'\xd8','\xa8','\xd9','\x89'}, {'\xd8','\xa8','\xd9','\x8a'}, {'\xd8','\xaa','\xd8','\xac'}, {'\xd8','\xaa','\xd8','\xad'}, {'\xd8','\xaa','\xd8','\xae'}, + /* 248 */ {'\xd8','\xaa','\xd8','\xb1'}, {'\xd8','\xaa','\xd8','\xb2'}, {'\xd8','\xaa','\xd9','\x85'}, {'\xd8','\xaa','\xd9','\x86'}, {'\xd8','\xaa','\xd9','\x87'}, {'\xd8','\xaa','\xd9','\x89'}, {'\xd8','\xaa','\xd9','\x8a'}, {'\xd8','\xab','\xd8','\xac'}, + /* 256 */ {'\xd8','\xab','\xd8','\xb1'}, {'\xd8','\xab','\xd8','\xb2'}, {'\xd8','\xab','\xd9','\x85'}, {'\xd8','\xab','\xd9','\x86'}, {'\xd8','\xab','\xd9','\x87'}, {'\xd8','\xab','\xd9','\x89'}, {'\xd8','\xab','\xd9','\x8a'}, {'\xd8','\xac','\xd8','\xad'}, + /* 264 */ {'\xd8','\xac','\xd9','\x85'}, {'\xd8','\xac','\xd9','\x89'}, {'\xd8','\xac','\xd9','\x8a'}, {'\xd8','\xad','\xd8','\xac'}, {'\xd8','\xad','\xd9','\x85'}, {'\xd8','\xad','\xd9','\x89'}, {'\xd8','\xad','\xd9','\x8a'}, {'\xd8','\xae','\xd8','\xac'}, + /* 272 */ {'\xd8','\xae','\xd8','\xad'}, {'\xd8','\xae','\xd9','\x85'}, {'\xd8','\xae','\xd9','\x89'}, {'\xd8','\xae','\xd9','\x8a'}, {'\xd8','\xb0','\xd9','\xb0'}, {'\xd8','\xb1','\xd9','\xb0'}, {'\xd8','\xb3','\xd8','\xac'}, {'\xd8','\xb3','\xd8','\xad'}, + /* 280 */ {'\xd8','\xb3','\xd8','\xae'}, {'\xd8','\xb3','\xd8','\xb1'}, {'\xd8','\xb3','\xd9','\x85'}, {'\xd8','\xb3','\xd9','\x87'}, {'\xd8','\xb3','\xd9','\x89'}, {'\xd8','\xb3','\xd9','\x8a'}, {'\xd8','\xb4','\xd8','\xac'}, {'\xd8','\xb4','\xd8','\xad'}, + /* 288 */ {'\xd8','\xb4','\xd8','\xae'}, {'\xd8','\xb4','\xd8','\xb1'}, {'\xd8','\xb4','\xd9','\x85'}, {'\xd8','\xb4','\xd9','\x87'}, {'\xd8','\xb4','\xd9','\x89'}, {'\xd8','\xb4','\xd9','\x8a'}, {'\xd8','\xb5','\xd8','\xad'}, {'\xd8','\xb5','\xd8','\xae'}, + /* 296 */ {'\xd8','\xb5','\xd8','\xb1'}, {'\xd8','\xb5','\xd9','\x85'}, {'\xd8','\xb5','\xd9','\x89'}, {'\xd8','\xb5','\xd9','\x8a'}, {'\xd8','\xb6','\xd8','\xac'}, {'\xd8','\xb6','\xd8','\xad'}, {'\xd8','\xb6','\xd8','\xae'}, {'\xd8','\xb6','\xd8','\xb1'}, + /* 304 */ {'\xd8','\xb6','\xd9','\x85'}, {'\xd8','\xb6','\xd9','\x89'}, {'\xd8','\xb6','\xd9','\x8a'}, {'\xd8','\xb7','\xd8','\xad'}, {'\xd8','\xb7','\xd9','\x85'}, {'\xd8','\xb7','\xd9','\x89'}, {'\xd8','\xb7','\xd9','\x8a'}, {'\xd8','\xb8','\xd9','\x85'}, + /* 312 */ {'\xd8','\xb9','\xd8','\xac'}, {'\xd8','\xb9','\xd9','\x85'}, {'\xd8','\xb9','\xd9','\x89'}, {'\xd8','\xb9','\xd9','\x8a'}, {'\xd8','\xba','\xd8','\xac'}, {'\xd8','\xba','\xd9','\x85'}, {'\xd8','\xba','\xd9','\x89'}, {'\xd8','\xba','\xd9','\x8a'}, + /* 320 */ {'\xd9','\x80','\xd9','\x8b'}, {'\xd9','\x80','\xd9','\x8e'}, {'\xd9','\x80','\xd9','\x8f'}, {'\xd9','\x80','\xd9','\x90'}, {'\xd9','\x80','\xd9','\x91'}, {'\xd9','\x80','\xd9','\x92'}, {'\xd9','\x81','\xd8','\xac'}, {'\xd9','\x81','\xd8','\xad'}, + /* 328 */ {'\xd9','\x81','\xd8','\xae'}, {'\xd9','\x81','\xd9','\x85'}, {'\xd9','\x81','\xd9','\x89'}, {'\xd9','\x81','\xd9','\x8a'}, {'\xd9','\x82','\xd8','\xad'}, {'\xd9','\x82','\xd9','\x85'}, {'\xd9','\x82','\xd9','\x89'}, {'\xd9','\x82','\xd9','\x8a'}, + /* 336 */ {'\xd9','\x83','\xd8','\xa7'}, {'\xd9','\x83','\xd8','\xac'}, {'\xd9','\x83','\xd8','\xad'}, {'\xd9','\x83','\xd8','\xae'}, {'\xd9','\x83','\xd9','\x84'}, {'\xd9','\x83','\xd9','\x85'}, {'\xd9','\x83','\xd9','\x89'}, {'\xd9','\x83','\xd9','\x8a'}, + /* 344 */ {'\xd9','\x84','\xd8','\xa7'}, {'\xd9','\x84','\xd8','\xac'}, {'\xd9','\x84','\xd8','\xad'}, {'\xd9','\x84','\xd8','\xae'}, {'\xd9','\x84','\xd9','\x85'}, {'\xd9','\x84','\xd9','\x87'}, {'\xd9','\x84','\xd9','\x89'}, {'\xd9','\x84','\xd9','\x8a'}, + /* 352 */ {'\xd9','\x85','\xd8','\xa7'}, {'\xd9','\x85','\xd8','\xac'}, {'\xd9','\x85','\xd8','\xad'}, {'\xd9','\x85','\xd8','\xae'}, {'\xd9','\x85','\xd9','\x85'}, {'\xd9','\x85','\xd9','\x89'}, {'\xd9','\x85','\xd9','\x8a'}, {'\xd9','\x86','\xd8','\xac'}, + /* 360 */ {'\xd9','\x86','\xd8','\xad'}, {'\xd9','\x86','\xd8','\xae'}, {'\xd9','\x86','\xd8','\xb1'}, {'\xd9','\x86','\xd8','\xb2'}, {'\xd9','\x86','\xd9','\x85'}, {'\xd9','\x86','\xd9','\x86'}, {'\xd9','\x86','\xd9','\x87'}, {'\xd9','\x86','\xd9','\x89'}, + /* 368 */ {'\xd9','\x86','\xd9','\x8a'}, {'\xd9','\x87','\xd8','\xac'}, {'\xd9','\x87','\xd9','\x85'}, {'\xd9','\x87','\xd9','\x89'}, {'\xd9','\x87','\xd9','\x8a'}, {'\xd9','\x87','\xd9','\xb0'}, {'\xd9','\x88','\xd9','\x94'}, {'\xd9','\x88','\xd9','\xb4'}, + /* 376 */ {'\xd9','\x89','\xd9','\xb0'}, {'\xd9','\x8a','\xd8','\xac'}, {'\xd9','\x8a','\xd8','\xad'}, {'\xd9','\x8a','\xd8','\xae'}, {'\xd9','\x8a','\xd8','\xb1'}, {'\xd9','\x8a','\xd8','\xb2'}, {'\xd9','\x8a','\xd9','\x85'}, {'\xd9','\x8a','\xd9','\x86'}, + /* 384 */ {'\xd9','\x8a','\xd9','\x87'}, {'\xd9','\x8a','\xd9','\x89'}, {'\xd9','\x8a','\xd9','\x8a'}, {'\xd9','\x8a','\xd9','\x94'}, {'\xd9','\x8a','\xd9','\xb4'}, {'\xdb','\x81','\xd9','\x94'}, {'\xdb','\x87','\xd9','\xb4'}, {'\xdb','\x92','\xd9','\x94'}, + /* 392 */ {'\xdb','\x95','\xd9','\x94'}, {'\xf0','\xa0','\x84','\xa2'}, {'\xf0','\xa0','\x94','\x9c'}, {'\xf0','\xa0','\x94','\xa5'}, {'\xf0','\xa0','\x95','\x8b'}, {'\xf0','\xa0','\x98','\xba'}, {'\xf0','\xa0','\xa0','\x84'}, {'\xf0','\xa0','\xa3','\x9e'}, + /* 400 */ {'\xf0','\xa0','\xa8','\xac'}, {'\xf0','\xa0','\xad','\xa3'}, {'\xf0','\xa1','\x93','\xa4'}, {'\xf0','\xa1','\x9a','\xa8'}, {'\xf0','\xa1','\x9b','\xaa'}, {'\xf0','\xa1','\xa7','\x88'}, {'\xf0','\xa1','\xac','\x98'}, {'\xf0','\xa1','\xb4','\x8b'}, + /* 408 */ {'\xf0','\xa1','\xb7','\xa4'}, {'\xf0','\xa1','\xb7','\xa6'}, {'\xf0','\xa2','\x86','\x83'}, {'\xf0','\xa2','\x86','\x9f'}, {'\xf0','\xa2','\x8c','\xb1'}, {'\xf0','\xa2','\x9b','\x94'}, {'\xf0','\xa2','\xa1','\x84'}, {'\xf0','\xa2','\xa1','\x8a'}, + /* 416 */ {'\xf0','\xa2','\xac','\x8c'}, {'\xf0','\xa2','\xaf','\xb1'}, {'\xf0','\xa3','\x80','\x8a'}, {'\xf0','\xa3','\x8a','\xb8'}, {'\xf0','\xa3','\x8d','\x9f'}, {'\xf0','\xa3','\x8e','\x93'}, {'\xf0','\xa3','\x8e','\x9c'}, {'\xf0','\xa3','\x8f','\x83'}, + /* 424 */ {'\xf0','\xa3','\x8f','\x95'}, {'\xf0','\xa3','\x91','\xad'}, {'\xf0','\xa3','\x9a','\xa3'}, {'\xf0','\xa3','\xa2','\xa7'}, {'\xf0','\xa3','\xaa','\x8d'}, {'\xf0','\xa3','\xab','\xba'}, {'\xf0','\xa3','\xb2','\xbc'}, {'\xf0','\xa3','\xb4','\x9e'}, + /* 432 */ {'\xf0','\xa3','\xbb','\x91'}, {'\xf0','\xa3','\xbd','\x9e'}, {'\xf0','\xa3','\xbe','\x8e'}, {'\xf0','\xa4','\x89','\xa3'}, {'\xf0','\xa4','\x8b','\xae'}, {'\xf0','\xa4','\x8e','\xab'}, {'\xf0','\xa4','\x98','\x88'}, {'\xf0','\xa4','\x9c','\xb5'}, + /* 440 */ {'\xf0','\xa4','\xa0','\x94'}, {'\xf0','\xa4','\xb0','\xb6'}, {'\xf0','\xa4','\xb2','\x92'}, {'\xf0','\xa4','\xbe','\xa1'}, {'\xf0','\xa4','\xbe','\xb8'}, {'\xf0','\xa5','\x81','\x84'}, {'\xf0','\xa5','\x83','\xb2'}, {'\xf0','\xa5','\x83','\xb3'}, + /* 448 */ {'\xf0','\xa5','\x84','\x99'}, {'\xf0','\xa5','\x84','\xb3'}, {'\xf0','\xa5','\x89','\x89'}, {'\xf0','\xa5','\x90','\x9d'}, {'\xf0','\xa5','\x98','\xa6'}, {'\xf0','\xa5','\x9a','\x9a'}, {'\xf0','\xa5','\x9b','\x85'}, {'\xf0','\xa5','\xa5','\xbc'}, + /* 456 */ {'\xf0','\xa5','\xaa','\xa7'}, {'\xf0','\xa5','\xae','\xab'}, {'\xf0','\xa5','\xb2','\x80'}, {'\xf0','\xa5','\xb3','\x90'}, {'\xf0','\xa5','\xbe','\x86'}, {'\xf0','\xa6','\x87','\x9a'}, {'\xf0','\xa6','\x88','\xa8'}, {'\xf0','\xa6','\x89','\x87'}, + /* 464 */ {'\xf0','\xa6','\x8b','\x99'}, {'\xf0','\xa6','\x8c','\xbe'}, {'\xf0','\xa6','\x93','\x9a'}, {'\xf0','\xa6','\x94','\xa3'}, {'\xf0','\xa6','\x96','\xa8'}, {'\xf0','\xa6','\x9e','\xa7'}, {'\xf0','\xa6','\x9e','\xb5'}, {'\xf0','\xa6','\xac','\xbc'}, + /* 472 */ {'\xf0','\xa6','\xb0','\xb6'}, {'\xf0','\xa6','\xb3','\x95'}, {'\xf0','\xa6','\xb5','\xab'}, {'\xf0','\xa6','\xbc','\xac'}, {'\xf0','\xa6','\xbe','\xb1'}, {'\xf0','\xa7','\x83','\x92'}, {'\xf0','\xa7','\x8f','\x8a'}, {'\xf0','\xa7','\x99','\xa7'}, + /* 480 */ {'\xf0','\xa7','\xa2','\xae'}, {'\xf0','\xa7','\xa5','\xa6'}, {'\xf0','\xa7','\xb2','\xa8'}, {'\xf0','\xa7','\xbb','\x93'}, {'\xf0','\xa7','\xbc','\xaf'}, {'\xf0','\xa8','\x97','\x92'}, {'\xf0','\xa8','\x97','\xad'}, {'\xf0','\xa8','\x9c','\xae'}, + /* 488 */ {'\xf0','\xa8','\xaf','\xba'}, {'\xf0','\xa8','\xb5','\xb7'}, {'\xf0','\xa9','\x85','\x85'}, {'\xf0','\xa9','\x87','\x9f'}, {'\xf0','\xa9','\x88','\x9a'}, {'\xf0','\xa9','\x90','\x8a'}, {'\xf0','\xa9','\x92','\x96'}, {'\xf0','\xa9','\x96','\xb6'}, + /* 496 */ {'\xf0','\xa9','\xac','\xb0'}, {'\xf0','\xaa','\x83','\x8e'}, {'\xf0','\xaa','\x84','\x85'}, {'\xf0','\xaa','\x88','\x8e'}, {'\xf0','\xaa','\x8a','\x91'}, {'\xf0','\xaa','\x8e','\x92'}, {'\xf0','\xaa','\x98','\x80'}, {'a','.','m','.'}, + /* 504 */ {'d','z','\xcc','\x8c'}, {'k','c','a','l'}, {'p','.','m','.'}, {'v','i','i','i'}}; + +static const char UN8IF_compat_tbl_5 [282][5] = { + /* 0 */ {'(','\xe1','\x84','\x80',')'}, {'(','\xe1','\x84','\x82',')'}, {'(','\xe1','\x84','\x83',')'}, {'(','\xe1','\x84','\x85',')'}, {'(','\xe1','\x84','\x86',')'}, {'(','\xe1','\x84','\x87',')'}, {'(','\xe1','\x84','\x89',')'}, {'(','\xe1','\x84','\x8b',')'}, + /* 8 */ {'(','\xe1','\x84','\x8c',')'}, {'(','\xe1','\x84','\x8e',')'}, {'(','\xe1','\x84','\x8f',')'}, {'(','\xe1','\x84','\x90',')'}, {'(','\xe1','\x84','\x91',')'}, {'(','\xe1','\x84','\x92',')'}, {'(','\xe4','\xb8','\x80',')'}, {'(','\xe4','\xb8','\x83',')'}, + /* 16 */ {'(','\xe4','\xb8','\x89',')'}, {'(','\xe4','\xb9','\x9d',')'}, {'(','\xe4','\xba','\x8c',')'}, {'(','\xe4','\xba','\x94',')'}, {'(','\xe4','\xbb','\xa3',')'}, {'(','\xe4','\xbc','\x81',')'}, {'(','\xe4','\xbc','\x91',')'}, {'(','\xe5','\x85','\xab',')'}, + /* 24 */ {'(','\xe5','\x85','\xad',')'}, {'(','\xe5','\x8a','\xb4',')'}, {'(','\xe5','\x8d','\x81',')'}, {'(','\xe5','\x8d','\x94',')'}, {'(','\xe5','\x90','\x8d',')'}, {'(','\xe5','\x91','\xbc',')'}, {'(','\xe5','\x9b','\x9b',')'}, {'(','\xe5','\x9c','\x9f',')'}, + /* 32 */ {'(','\xe5','\xad','\xa6',')'}, {'(','\xe6','\x97','\xa5',')'}, {'(','\xe6','\x9c','\x88',')'}, {'(','\xe6','\x9c','\x89',')'}, {'(','\xe6','\x9c','\xa8',')'}, {'(','\xe6','\xa0','\xaa',')'}, {'(','\xe6','\xb0','\xb4',')'}, {'(','\xe7','\x81','\xab',')'}, + /* 40 */ {'(','\xe7','\x89','\xb9',')'}, {'(','\xe7','\x9b','\xa3',')'}, {'(','\xe7','\xa4','\xbe',')'}, {'(','\xe7','\xa5','\x9d',')'}, {'(','\xe7','\xa5','\xad',')'}, {'(','\xe8','\x87','\xaa',')'}, {'(','\xe8','\x87','\xb3',')'}, {'(','\xe8','\xb2','\xa1',')'}, + /* 48 */ {'(','\xe8','\xb3','\x87',')'}, {'(','\xe9','\x87','\x91',')'}, {'0','\xe2','\x81','\x84','3'}, {'1','0','\xe6','\x97','\xa5'}, {'1','0','\xe6','\x9c','\x88'}, {'1','0','\xe7','\x82','\xb9'}, {'1','1','\xe6','\x97','\xa5'}, {'1','1','\xe6','\x9c','\x88'}, + /* 56 */ {'1','1','\xe7','\x82','\xb9'}, {'1','2','\xe6','\x97','\xa5'}, {'1','2','\xe6','\x9c','\x88'}, {'1','2','\xe7','\x82','\xb9'}, {'1','3','\xe6','\x97','\xa5'}, {'1','3','\xe7','\x82','\xb9'}, {'1','4','\xe6','\x97','\xa5'}, {'1','4','\xe7','\x82','\xb9'}, + /* 64 */ {'1','5','\xe6','\x97','\xa5'}, {'1','5','\xe7','\x82','\xb9'}, {'1','6','\xe6','\x97','\xa5'}, {'1','6','\xe7','\x82','\xb9'}, {'1','7','\xe6','\x97','\xa5'}, {'1','7','\xe7','\x82','\xb9'}, {'1','8','\xe6','\x97','\xa5'}, {'1','8','\xe7','\x82','\xb9'}, + /* 72 */ {'1','9','\xe6','\x97','\xa5'}, {'1','9','\xe7','\x82','\xb9'}, {'1','\xe2','\x81','\x84','2'}, {'1','\xe2','\x81','\x84','3'}, {'1','\xe2','\x81','\x84','4'}, {'1','\xe2','\x81','\x84','5'}, {'1','\xe2','\x81','\x84','6'}, {'1','\xe2','\x81','\x84','7'}, + /* 80 */ {'1','\xe2','\x81','\x84','8'}, {'1','\xe2','\x81','\x84','9'}, {'2','0','\xe6','\x97','\xa5'}, {'2','0','\xe7','\x82','\xb9'}, {'2','1','\xe6','\x97','\xa5'}, {'2','1','\xe7','\x82','\xb9'}, {'2','2','\xe6','\x97','\xa5'}, {'2','2','\xe7','\x82','\xb9'}, + /* 88 */ {'2','3','\xe6','\x97','\xa5'}, {'2','3','\xe7','\x82','\xb9'}, {'2','4','\xe6','\x97','\xa5'}, {'2','4','\xe7','\x82','\xb9'}, {'2','5','\xe6','\x97','\xa5'}, {'2','6','\xe6','\x97','\xa5'}, {'2','7','\xe6','\x97','\xa5'}, {'2','8','\xe6','\x97','\xa5'}, + /* 96 */ {'2','9','\xe6','\x97','\xa5'}, {'2','\xe2','\x81','\x84','3'}, {'2','\xe2','\x81','\x84','5'}, {'3','0','\xe6','\x97','\xa5'}, {'3','1','\xe6','\x97','\xa5'}, {'3','\xe2','\x81','\x84','4'}, {'3','\xe2','\x81','\x84','5'}, {'3','\xe2','\x81','\x84','8'}, + /* 104 */ {'4','\xe2','\x81','\x84','5'}, {'5','\xe2','\x81','\x84','6'}, {'5','\xe2','\x81','\x84','8'}, {'7','\xe2','\x81','\x84','8'}, {'A','\xcc','\x82','\xcc','\x80'}, {'A','\xcc','\x82','\xcc','\x81'}, {'A','\xcc','\x82','\xcc','\x83'}, {'A','\xcc','\x82','\xcc','\x89'}, + /* 112 */ {'A','\xcc','\x86','\xcc','\x80'}, {'A','\xcc','\x86','\xcc','\x81'}, {'A','\xcc','\x86','\xcc','\x83'}, {'A','\xcc','\x86','\xcc','\x89'}, {'A','\xcc','\x87','\xcc','\x84'}, {'A','\xcc','\x88','\xcc','\x84'}, {'A','\xcc','\x8a','\xcc','\x81'}, {'A','\xcc','\xa3','\xcc','\x82'}, + /* 120 */ {'A','\xcc','\xa3','\xcc','\x86'}, {'A','\xe2','\x88','\x95','m'}, {'C','\xcc','\xa7','\xcc','\x81'}, {'E','\xcc','\x82','\xcc','\x80'}, {'E','\xcc','\x82','\xcc','\x81'}, {'E','\xcc','\x82','\xcc','\x83'}, {'E','\xcc','\x82','\xcc','\x89'}, {'E','\xcc','\x84','\xcc','\x80'}, + /* 128 */ {'E','\xcc','\x84','\xcc','\x81'}, {'E','\xcc','\xa3','\xcc','\x82'}, {'E','\xcc','\xa7','\xcc','\x86'}, {'I','\xcc','\x88','\xcc','\x81'}, {'L','\xcc','\xa3','\xcc','\x84'}, {'O','\xcc','\x82','\xcc','\x80'}, {'O','\xcc','\x82','\xcc','\x81'}, {'O','\xcc','\x82','\xcc','\x83'}, + /* 136 */ {'O','\xcc','\x82','\xcc','\x89'}, {'O','\xcc','\x83','\xcc','\x81'}, {'O','\xcc','\x83','\xcc','\x84'}, {'O','\xcc','\x83','\xcc','\x88'}, {'O','\xcc','\x84','\xcc','\x80'}, {'O','\xcc','\x84','\xcc','\x81'}, {'O','\xcc','\x87','\xcc','\x84'}, {'O','\xcc','\x88','\xcc','\x84'}, + /* 144 */ {'O','\xcc','\x9b','\xcc','\x80'}, {'O','\xcc','\x9b','\xcc','\x81'}, {'O','\xcc','\x9b','\xcc','\x83'}, {'O','\xcc','\x9b','\xcc','\x89'}, {'O','\xcc','\x9b','\xcc','\xa3'}, {'O','\xcc','\xa3','\xcc','\x82'}, {'O','\xcc','\xa8','\xcc','\x84'}, {'R','\xcc','\xa3','\xcc','\x84'}, + /* 152 */ {'S','\xcc','\x81','\xcc','\x87'}, {'S','\xcc','\x8c','\xcc','\x87'}, {'S','\xcc','\xa3','\xcc','\x87'}, {'U','\xcc','\x83','\xcc','\x81'}, {'U','\xcc','\x84','\xcc','\x88'}, {'U','\xcc','\x88','\xcc','\x80'}, {'U','\xcc','\x88','\xcc','\x81'}, {'U','\xcc','\x88','\xcc','\x84'}, + /* 160 */ {'U','\xcc','\x88','\xcc','\x8c'}, {'U','\xcc','\x9b','\xcc','\x80'}, {'U','\xcc','\x9b','\xcc','\x81'}, {'U','\xcc','\x9b','\xcc','\x83'}, {'U','\xcc','\x9b','\xcc','\x89'}, {'U','\xcc','\x9b','\xcc','\xa3'}, {'V','\xe2','\x88','\x95','m'}, {'\x20','\xcc','\x88','\xcc','\x80'}, + /* 168 */ {'\x20','\xcc','\x88','\xcc','\x81'}, {'\x20','\xcc','\x88','\xcd','\x82'}, {'\x20','\xcc','\x93','\xcc','\x80'}, {'\x20','\xcc','\x93','\xcc','\x81'}, {'\x20','\xcc','\x93','\xcd','\x82'}, {'\x20','\xcc','\x94','\xcc','\x80'}, {'\x20','\xcc','\x94','\xcc','\x81'}, {'\x20','\xcc','\x94','\xcd','\x82'}, + /* 176 */ {'\x20','\xd9','\x8c','\xd9','\x91'}, {'\x20','\xd9','\x8d','\xd9','\x91'}, {'\x20','\xd9','\x8e','\xd9','\x91'}, {'\x20','\xd9','\x8f','\xd9','\x91'}, {'\x20','\xd9','\x90','\xd9','\x91'}, {'\x20','\xd9','\x91','\xd9','\xb0'}, {'\xe2','\x86','\x90','\xcc','\xb8'}, {'\xe2','\x86','\x92','\xcc','\xb8'}, + /* 184 */ {'\xe2','\x86','\x94','\xcc','\xb8'}, {'\xe2','\x87','\x90','\xcc','\xb8'}, {'\xe2','\x87','\x92','\xcc','\xb8'}, {'\xe2','\x87','\x94','\xcc','\xb8'}, {'\xe2','\x88','\x83','\xcc','\xb8'}, {'\xe2','\x88','\x88','\xcc','\xb8'}, {'\xe2','\x88','\x8b','\xcc','\xb8'}, {'\xe2','\x88','\xa3','\xcc','\xb8'}, + /* 192 */ {'\xe2','\x88','\xa5','\xcc','\xb8'}, {'\xe2','\x88','\xbc','\xcc','\xb8'}, {'\xe2','\x89','\x83','\xcc','\xb8'}, {'\xe2','\x89','\x85','\xcc','\xb8'}, {'\xe2','\x89','\x88','\xcc','\xb8'}, {'\xe2','\x89','\x8d','\xcc','\xb8'}, {'\xe2','\x89','\xa1','\xcc','\xb8'}, {'\xe2','\x89','\xa4','\xcc','\xb8'}, + /* 200 */ {'\xe2','\x89','\xa5','\xcc','\xb8'}, {'\xe2','\x89','\xb2','\xcc','\xb8'}, {'\xe2','\x89','\xb3','\xcc','\xb8'}, {'\xe2','\x89','\xb6','\xcc','\xb8'}, {'\xe2','\x89','\xb7','\xcc','\xb8'}, {'\xe2','\x89','\xba','\xcc','\xb8'}, {'\xe2','\x89','\xbb','\xcc','\xb8'}, {'\xe2','\x89','\xbc','\xcc','\xb8'}, + /* 208 */ {'\xe2','\x89','\xbd','\xcc','\xb8'}, {'\xe2','\x8a','\x82','\xcc','\xb8'}, {'\xe2','\x8a','\x83','\xcc','\xb8'}, {'\xe2','\x8a','\x86','\xcc','\xb8'}, {'\xe2','\x8a','\x87','\xcc','\xb8'}, {'\xe2','\x8a','\x91','\xcc','\xb8'}, {'\xe2','\x8a','\x92','\xcc','\xb8'}, {'\xe2','\x8a','\xa2','\xcc','\xb8'}, + /* 216 */ {'\xe2','\x8a','\xa8','\xcc','\xb8'}, {'\xe2','\x8a','\xa9','\xcc','\xb8'}, {'\xe2','\x8a','\xab','\xcc','\xb8'}, {'\xe2','\x8a','\xb2','\xcc','\xb8'}, {'\xe2','\x8a','\xb3','\xcc','\xb8'}, {'\xe2','\x8a','\xb4','\xcc','\xb8'}, {'\xe2','\x8a','\xb5','\xcc','\xb8'}, {'\xe2','\xab','\x9d','\xcc','\xb8'}, + /* 224 */ {'a','\xcc','\x82','\xcc','\x80'}, {'a','\xcc','\x82','\xcc','\x81'}, {'a','\xcc','\x82','\xcc','\x83'}, {'a','\xcc','\x82','\xcc','\x89'}, {'a','\xcc','\x86','\xcc','\x80'}, {'a','\xcc','\x86','\xcc','\x81'}, {'a','\xcc','\x86','\xcc','\x83'}, {'a','\xcc','\x86','\xcc','\x89'}, + /* 232 */ {'a','\xcc','\x87','\xcc','\x84'}, {'a','\xcc','\x88','\xcc','\x84'}, {'a','\xcc','\x8a','\xcc','\x81'}, {'a','\xcc','\xa3','\xcc','\x82'}, {'a','\xcc','\xa3','\xcc','\x86'}, {'c','\xcc','\xa7','\xcc','\x81'}, {'e','\xcc','\x82','\xcc','\x80'}, {'e','\xcc','\x82','\xcc','\x81'}, + /* 240 */ {'e','\xcc','\x82','\xcc','\x83'}, {'e','\xcc','\x82','\xcc','\x89'}, {'e','\xcc','\x84','\xcc','\x80'}, {'e','\xcc','\x84','\xcc','\x81'}, {'e','\xcc','\xa3','\xcc','\x82'}, {'e','\xcc','\xa7','\xcc','\x86'}, {'i','\xcc','\x88','\xcc','\x81'}, {'l','\xcc','\xa3','\xcc','\x84'}, + /* 248 */ {'m','\xe2','\x88','\x95','s'}, {'o','\xcc','\x82','\xcc','\x80'}, {'o','\xcc','\x82','\xcc','\x81'}, {'o','\xcc','\x82','\xcc','\x83'}, {'o','\xcc','\x82','\xcc','\x89'}, {'o','\xcc','\x83','\xcc','\x81'}, {'o','\xcc','\x83','\xcc','\x84'}, {'o','\xcc','\x83','\xcc','\x88'}, + /* 256 */ {'o','\xcc','\x84','\xcc','\x80'}, {'o','\xcc','\x84','\xcc','\x81'}, {'o','\xcc','\x87','\xcc','\x84'}, {'o','\xcc','\x88','\xcc','\x84'}, {'o','\xcc','\x9b','\xcc','\x80'}, {'o','\xcc','\x9b','\xcc','\x81'}, {'o','\xcc','\x9b','\xcc','\x83'}, {'o','\xcc','\x9b','\xcc','\x89'}, + /* 264 */ {'o','\xcc','\x9b','\xcc','\xa3'}, {'o','\xcc','\xa3','\xcc','\x82'}, {'o','\xcc','\xa8','\xcc','\x84'}, {'r','\xcc','\xa3','\xcc','\x84'}, {'s','\xcc','\x81','\xcc','\x87'}, {'s','\xcc','\x8c','\xcc','\x87'}, {'s','\xcc','\xa3','\xcc','\x87'}, {'u','\xcc','\x83','\xcc','\x81'}, + /* 272 */ {'u','\xcc','\x84','\xcc','\x88'}, {'u','\xcc','\x88','\xcc','\x80'}, {'u','\xcc','\x88','\xcc','\x81'}, {'u','\xcc','\x88','\xcc','\x84'}, {'u','\xcc','\x88','\xcc','\x8c'}, {'u','\xcc','\x9b','\xcc','\x80'}, {'u','\xcc','\x9b','\xcc','\x81'}, {'u','\xcc','\x9b','\xcc','\x83'}, + /* 280 */ {'u','\xcc','\x9b','\xcc','\x89'}, {'u','\xcc','\x9b','\xcc','\xa3'}}; + +/* the special-cased overlong entries */ +typedef struct { const uint32_t cp; const char* v; } UN8IF_compat_exc_t; +/* sorted for binary search */ +#define UN8IF_compat_exc_size 637 +static const UN8IF_compat_exc_t UN8IF_compat_exc [637] = { + { 0x390, "\xce\xb9\xcc\x88\xcc\x81" }, + { 0x3b0, "\xcf\x85\xcc\x88\xcc\x81" }, + { 0x929, "\xe0\xa4\xa8\xe0\xa4\xbc" }, + { 0x931, "\xe0\xa4\xb0\xe0\xa4\xbc" }, + { 0x934, "\xe0\xa4\xb3\xe0\xa4\xbc" }, + { 0x958, "\xe0\xa4\x95\xe0\xa4\xbc" }, + { 0x959, "\xe0\xa4\x96\xe0\xa4\xbc" }, + { 0x95a, "\xe0\xa4\x97\xe0\xa4\xbc" }, + { 0x95b, "\xe0\xa4\x9c\xe0\xa4\xbc" }, + { 0x95c, "\xe0\xa4\xa1\xe0\xa4\xbc" }, + { 0x95d, "\xe0\xa4\xa2\xe0\xa4\xbc" }, + { 0x95e, "\xe0\xa4\xab\xe0\xa4\xbc" }, + { 0x95f, "\xe0\xa4\xaf\xe0\xa4\xbc" }, + { 0x9cb, "\xe0\xa7\x87\xe0\xa6\xbe" }, + { 0x9cc, "\xe0\xa7\x87\xe0\xa7\x97" }, + { 0x9dc, "\xe0\xa6\xa1\xe0\xa6\xbc" }, + { 0x9dd, "\xe0\xa6\xa2\xe0\xa6\xbc" }, + { 0x9df, "\xe0\xa6\xaf\xe0\xa6\xbc" }, + { 0xa33, "\xe0\xa8\xb2\xe0\xa8\xbc" }, + { 0xa36, "\xe0\xa8\xb8\xe0\xa8\xbc" }, + { 0xa59, "\xe0\xa8\x96\xe0\xa8\xbc" }, + { 0xa5a, "\xe0\xa8\x97\xe0\xa8\xbc" }, + { 0xa5b, "\xe0\xa8\x9c\xe0\xa8\xbc" }, + { 0xa5e, "\xe0\xa8\xab\xe0\xa8\xbc" }, + { 0xb48, "\xe0\xad\x87\xe0\xad\x96" }, + { 0xb4b, "\xe0\xad\x87\xe0\xac\xbe" }, + { 0xb4c, "\xe0\xad\x87\xe0\xad\x97" }, + { 0xb5c, "\xe0\xac\xa1\xe0\xac\xbc" }, + { 0xb5d, "\xe0\xac\xa2\xe0\xac\xbc" }, + { 0xb94, "\xe0\xae\x92\xe0\xaf\x97" }, + { 0xbca, "\xe0\xaf\x86\xe0\xae\xbe" }, + { 0xbcb, "\xe0\xaf\x87\xe0\xae\xbe" }, + { 0xbcc, "\xe0\xaf\x86\xe0\xaf\x97" }, + { 0xc48, "\xe0\xb1\x86\xe0\xb1\x96" }, + { 0xcc0, "\xe0\xb2\xbf\xe0\xb3\x95" }, + { 0xcc7, "\xe0\xb3\x86\xe0\xb3\x95" }, + { 0xcc8, "\xe0\xb3\x86\xe0\xb3\x96" }, + { 0xcca, "\xe0\xb3\x86\xe0\xb3\x82" }, + { 0xccb, "\xe0\xb3\x86\xe0\xb3\x82\xe0\xb3\x95" }, + { 0xd4a, "\xe0\xb5\x86\xe0\xb4\xbe" }, + { 0xd4b, "\xe0\xb5\x87\xe0\xb4\xbe" }, + { 0xd4c, "\xe0\xb5\x86\xe0\xb5\x97" }, + { 0xdda, "\xe0\xb7\x99\xe0\xb7\x8a" }, + { 0xddc, "\xe0\xb7\x99\xe0\xb7\x8f" }, + { 0xddd, "\xe0\xb7\x99\xe0\xb7\x8f\xe0\xb7\x8a" }, + { 0xdde, "\xe0\xb7\x99\xe0\xb7\x9f" }, + { 0xe33, "\xe0\xb9\x8d\xe0\xb8\xb2" }, + { 0xeb3, "\xe0\xbb\x8d\xe0\xba\xb2" }, + { 0xedc, "\xe0\xba\xab\xe0\xba\x99" }, + { 0xedd, "\xe0\xba\xab\xe0\xba\xa1" }, + { 0xf43, "\xe0\xbd\x82\xe0\xbe\xb7" }, + { 0xf4d, "\xe0\xbd\x8c\xe0\xbe\xb7" }, + { 0xf52, "\xe0\xbd\x91\xe0\xbe\xb7" }, + { 0xf57, "\xe0\xbd\x96\xe0\xbe\xb7" }, + { 0xf5c, "\xe0\xbd\x9b\xe0\xbe\xb7" }, + { 0xf69, "\xe0\xbd\x80\xe0\xbe\xb5" }, + { 0xf73, "\xe0\xbd\xb1\xe0\xbd\xb2" }, + { 0xf75, "\xe0\xbd\xb1\xe0\xbd\xb4" }, + { 0xf76, "\xe0\xbe\xb2\xe0\xbe\x80" }, + { 0xf77, "\xe0\xbe\xb2\xe0\xbd\xb1\xe0\xbe\x80" }, + { 0xf78, "\xe0\xbe\xb3\xe0\xbe\x80" }, + { 0xf79, "\xe0\xbe\xb3\xe0\xbd\xb1\xe0\xbe\x80" }, + { 0xf81, "\xe0\xbd\xb1\xe0\xbe\x80" }, + { 0xf93, "\xe0\xbe\x92\xe0\xbe\xb7" }, + { 0xf9d, "\xe0\xbe\x9c\xe0\xbe\xb7" }, + { 0xfa2, "\xe0\xbe\xa1\xe0\xbe\xb7" }, + { 0xfa7, "\xe0\xbe\xa6\xe0\xbe\xb7" }, + { 0xfac, "\xe0\xbe\xab\xe0\xbe\xb7" }, + { 0xfb9, "\xe0\xbe\x90\xe0\xbe\xb5" }, + { 0x1026, "\xe1\x80\xa5\xe1\x80\xae" }, + { 0x1b06, "\xe1\xac\x85\xe1\xac\xb5" }, + { 0x1b08, "\xe1\xac\x87\xe1\xac\xb5" }, + { 0x1b0a, "\xe1\xac\x89\xe1\xac\xb5" }, + { 0x1b0c, "\xe1\xac\x8b\xe1\xac\xb5" }, + { 0x1b0e, "\xe1\xac\x8d\xe1\xac\xb5" }, + { 0x1b12, "\xe1\xac\x91\xe1\xac\xb5" }, + { 0x1b3b, "\xe1\xac\xba\xe1\xac\xb5" }, + { 0x1b3d, "\xe1\xac\xbc\xe1\xac\xb5" }, + { 0x1b40, "\xe1\xac\xbe\xe1\xac\xb5" }, + { 0x1b41, "\xe1\xac\xbf\xe1\xac\xb5" }, + { 0x1b43, "\xe1\xad\x82\xe1\xac\xb5" }, + { 0x1f02, "\xce\xb1\xcc\x93\xcc\x80" }, + { 0x1f03, "\xce\xb1\xcc\x94\xcc\x80" }, + { 0x1f04, "\xce\xb1\xcc\x93\xcc\x81" }, + { 0x1f05, "\xce\xb1\xcc\x94\xcc\x81" }, + { 0x1f06, "\xce\xb1\xcc\x93\xcd\x82" }, + { 0x1f07, "\xce\xb1\xcc\x94\xcd\x82" }, + { 0x1f0a, "\xce\x91\xcc\x93\xcc\x80" }, + { 0x1f0b, "\xce\x91\xcc\x94\xcc\x80" }, + { 0x1f0c, "\xce\x91\xcc\x93\xcc\x81" }, + { 0x1f0d, "\xce\x91\xcc\x94\xcc\x81" }, + { 0x1f0e, "\xce\x91\xcc\x93\xcd\x82" }, + { 0x1f0f, "\xce\x91\xcc\x94\xcd\x82" }, + { 0x1f12, "\xce\xb5\xcc\x93\xcc\x80" }, + { 0x1f13, "\xce\xb5\xcc\x94\xcc\x80" }, + { 0x1f14, "\xce\xb5\xcc\x93\xcc\x81" }, + { 0x1f15, "\xce\xb5\xcc\x94\xcc\x81" }, + { 0x1f1a, "\xce\x95\xcc\x93\xcc\x80" }, + { 0x1f1b, "\xce\x95\xcc\x94\xcc\x80" }, + { 0x1f1c, "\xce\x95\xcc\x93\xcc\x81" }, + { 0x1f1d, "\xce\x95\xcc\x94\xcc\x81" }, + { 0x1f22, "\xce\xb7\xcc\x93\xcc\x80" }, + { 0x1f23, "\xce\xb7\xcc\x94\xcc\x80" }, + { 0x1f24, "\xce\xb7\xcc\x93\xcc\x81" }, + { 0x1f25, "\xce\xb7\xcc\x94\xcc\x81" }, + { 0x1f26, "\xce\xb7\xcc\x93\xcd\x82" }, + { 0x1f27, "\xce\xb7\xcc\x94\xcd\x82" }, + { 0x1f2a, "\xce\x97\xcc\x93\xcc\x80" }, + { 0x1f2b, "\xce\x97\xcc\x94\xcc\x80" }, + { 0x1f2c, "\xce\x97\xcc\x93\xcc\x81" }, + { 0x1f2d, "\xce\x97\xcc\x94\xcc\x81" }, + { 0x1f2e, "\xce\x97\xcc\x93\xcd\x82" }, + { 0x1f2f, "\xce\x97\xcc\x94\xcd\x82" }, + { 0x1f32, "\xce\xb9\xcc\x93\xcc\x80" }, + { 0x1f33, "\xce\xb9\xcc\x94\xcc\x80" }, + { 0x1f34, "\xce\xb9\xcc\x93\xcc\x81" }, + { 0x1f35, "\xce\xb9\xcc\x94\xcc\x81" }, + { 0x1f36, "\xce\xb9\xcc\x93\xcd\x82" }, + { 0x1f37, "\xce\xb9\xcc\x94\xcd\x82" }, + { 0x1f3a, "\xce\x99\xcc\x93\xcc\x80" }, + { 0x1f3b, "\xce\x99\xcc\x94\xcc\x80" }, + { 0x1f3c, "\xce\x99\xcc\x93\xcc\x81" }, + { 0x1f3d, "\xce\x99\xcc\x94\xcc\x81" }, + { 0x1f3e, "\xce\x99\xcc\x93\xcd\x82" }, + { 0x1f3f, "\xce\x99\xcc\x94\xcd\x82" }, + { 0x1f42, "\xce\xbf\xcc\x93\xcc\x80" }, + { 0x1f43, "\xce\xbf\xcc\x94\xcc\x80" }, + { 0x1f44, "\xce\xbf\xcc\x93\xcc\x81" }, + { 0x1f45, "\xce\xbf\xcc\x94\xcc\x81" }, + { 0x1f4a, "\xce\x9f\xcc\x93\xcc\x80" }, + { 0x1f4b, "\xce\x9f\xcc\x94\xcc\x80" }, + { 0x1f4c, "\xce\x9f\xcc\x93\xcc\x81" }, + { 0x1f4d, "\xce\x9f\xcc\x94\xcc\x81" }, + { 0x1f52, "\xcf\x85\xcc\x93\xcc\x80" }, + { 0x1f53, "\xcf\x85\xcc\x94\xcc\x80" }, + { 0x1f54, "\xcf\x85\xcc\x93\xcc\x81" }, + { 0x1f55, "\xcf\x85\xcc\x94\xcc\x81" }, + { 0x1f56, "\xcf\x85\xcc\x93\xcd\x82" }, + { 0x1f57, "\xcf\x85\xcc\x94\xcd\x82" }, + { 0x1f5b, "\xce\xa5\xcc\x94\xcc\x80" }, + { 0x1f5d, "\xce\xa5\xcc\x94\xcc\x81" }, + { 0x1f5f, "\xce\xa5\xcc\x94\xcd\x82" }, + { 0x1f62, "\xcf\x89\xcc\x93\xcc\x80" }, + { 0x1f63, "\xcf\x89\xcc\x94\xcc\x80" }, + { 0x1f64, "\xcf\x89\xcc\x93\xcc\x81" }, + { 0x1f65, "\xcf\x89\xcc\x94\xcc\x81" }, + { 0x1f66, "\xcf\x89\xcc\x93\xcd\x82" }, + { 0x1f67, "\xcf\x89\xcc\x94\xcd\x82" }, + { 0x1f6a, "\xce\xa9\xcc\x93\xcc\x80" }, + { 0x1f6b, "\xce\xa9\xcc\x94\xcc\x80" }, + { 0x1f6c, "\xce\xa9\xcc\x93\xcc\x81" }, + { 0x1f6d, "\xce\xa9\xcc\x94\xcc\x81" }, + { 0x1f6e, "\xce\xa9\xcc\x93\xcd\x82" }, + { 0x1f6f, "\xce\xa9\xcc\x94\xcd\x82" }, + { 0x1f80, "\xce\xb1\xcc\x93\xcd\x85" }, + { 0x1f81, "\xce\xb1\xcc\x94\xcd\x85" }, + { 0x1f82, "\xce\xb1\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f83, "\xce\xb1\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f84, "\xce\xb1\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f85, "\xce\xb1\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f86, "\xce\xb1\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f87, "\xce\xb1\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f88, "\xce\x91\xcc\x93\xcd\x85" }, + { 0x1f89, "\xce\x91\xcc\x94\xcd\x85" }, + { 0x1f8a, "\xce\x91\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f8b, "\xce\x91\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f8c, "\xce\x91\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f8d, "\xce\x91\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f8e, "\xce\x91\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f8f, "\xce\x91\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f90, "\xce\xb7\xcc\x93\xcd\x85" }, + { 0x1f91, "\xce\xb7\xcc\x94\xcd\x85" }, + { 0x1f92, "\xce\xb7\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f93, "\xce\xb7\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f94, "\xce\xb7\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f95, "\xce\xb7\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f96, "\xce\xb7\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f97, "\xce\xb7\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1f98, "\xce\x97\xcc\x93\xcd\x85" }, + { 0x1f99, "\xce\x97\xcc\x94\xcd\x85" }, + { 0x1f9a, "\xce\x97\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1f9b, "\xce\x97\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1f9c, "\xce\x97\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1f9d, "\xce\x97\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1f9e, "\xce\x97\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1f9f, "\xce\x97\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fa0, "\xcf\x89\xcc\x93\xcd\x85" }, + { 0x1fa1, "\xcf\x89\xcc\x94\xcd\x85" }, + { 0x1fa2, "\xcf\x89\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1fa3, "\xcf\x89\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1fa4, "\xcf\x89\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1fa5, "\xcf\x89\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1fa6, "\xcf\x89\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1fa7, "\xcf\x89\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fa8, "\xce\xa9\xcc\x93\xcd\x85" }, + { 0x1fa9, "\xce\xa9\xcc\x94\xcd\x85" }, + { 0x1faa, "\xce\xa9\xcc\x93\xcc\x80\xcd\x85" }, + { 0x1fab, "\xce\xa9\xcc\x94\xcc\x80\xcd\x85" }, + { 0x1fac, "\xce\xa9\xcc\x93\xcc\x81\xcd\x85" }, + { 0x1fad, "\xce\xa9\xcc\x94\xcc\x81\xcd\x85" }, + { 0x1fae, "\xce\xa9\xcc\x93\xcd\x82\xcd\x85" }, + { 0x1faf, "\xce\xa9\xcc\x94\xcd\x82\xcd\x85" }, + { 0x1fb2, "\xce\xb1\xcc\x80\xcd\x85" }, + { 0x1fb4, "\xce\xb1\xcc\x81\xcd\x85" }, + { 0x1fb7, "\xce\xb1\xcd\x82\xcd\x85" }, + { 0x1fc2, "\xce\xb7\xcc\x80\xcd\x85" }, + { 0x1fc4, "\xce\xb7\xcc\x81\xcd\x85" }, + { 0x1fc7, "\xce\xb7\xcd\x82\xcd\x85" }, + { 0x1fd2, "\xce\xb9\xcc\x88\xcc\x80" }, + { 0x1fd3, "\xce\xb9\xcc\x88\xcc\x81" }, + { 0x1fd7, "\xce\xb9\xcc\x88\xcd\x82" }, + { 0x1fe2, "\xcf\x85\xcc\x88\xcc\x80" }, + { 0x1fe3, "\xcf\x85\xcc\x88\xcc\x81" }, + { 0x1fe7, "\xcf\x85\xcc\x88\xcd\x82" }, + { 0x1ff2, "\xcf\x89\xcc\x80\xcd\x85" }, + { 0x1ff4, "\xcf\x89\xcc\x81\xcd\x85" }, + { 0x1ff7, "\xcf\x89\xcd\x82\xcd\x85" }, + { 0x2033, "\xe2\x80\xb2\xe2\x80\xb2" }, + { 0x2034, "\xe2\x80\xb2\xe2\x80\xb2\xe2\x80\xb2" }, + { 0x2036, "\xe2\x80\xb5\xe2\x80\xb5" }, + { 0x2037, "\xe2\x80\xb5\xe2\x80\xb5\xe2\x80\xb5" }, + { 0x2057, "\xe2\x80\xb2\xe2\x80\xb2\xe2\x80\xb2\xe2\x80\xb2" }, + { 0x2152, "\x31\xe2\x81\x84\x31\x30" }, + { 0x222c, "\xe2\x88\xab\xe2\x88\xab" }, + { 0x222d, "\xe2\x88\xab\xe2\x88\xab\xe2\x88\xab" }, + { 0x222f, "\xe2\x88\xae\xe2\x88\xae" }, + { 0x2230, "\xe2\x88\xae\xe2\x88\xae\xe2\x88\xae" }, + { 0x2a0c, "\xe2\x88\xab\xe2\x88\xab\xe2\x88\xab\xe2\x88\xab" }, + { 0x304c, "\xe3\x81\x8b\xe3\x82\x99" }, + { 0x304e, "\xe3\x81\x8d\xe3\x82\x99" }, + { 0x3050, "\xe3\x81\x8f\xe3\x82\x99" }, + { 0x3052, "\xe3\x81\x91\xe3\x82\x99" }, + { 0x3054, "\xe3\x81\x93\xe3\x82\x99" }, + { 0x3056, "\xe3\x81\x95\xe3\x82\x99" }, + { 0x3058, "\xe3\x81\x97\xe3\x82\x99" }, + { 0x305a, "\xe3\x81\x99\xe3\x82\x99" }, + { 0x305c, "\xe3\x81\x9b\xe3\x82\x99" }, + { 0x305e, "\xe3\x81\x9d\xe3\x82\x99" }, + { 0x3060, "\xe3\x81\x9f\xe3\x82\x99" }, + { 0x3062, "\xe3\x81\xa1\xe3\x82\x99" }, + { 0x3065, "\xe3\x81\xa4\xe3\x82\x99" }, + { 0x3067, "\xe3\x81\xa6\xe3\x82\x99" }, + { 0x3069, "\xe3\x81\xa8\xe3\x82\x99" }, + { 0x3070, "\xe3\x81\xaf\xe3\x82\x99" }, + { 0x3071, "\xe3\x81\xaf\xe3\x82\x9a" }, + { 0x3073, "\xe3\x81\xb2\xe3\x82\x99" }, + { 0x3074, "\xe3\x81\xb2\xe3\x82\x9a" }, + { 0x3076, "\xe3\x81\xb5\xe3\x82\x99" }, + { 0x3077, "\xe3\x81\xb5\xe3\x82\x9a" }, + { 0x3079, "\xe3\x81\xb8\xe3\x82\x99" }, + { 0x307a, "\xe3\x81\xb8\xe3\x82\x9a" }, + { 0x307c, "\xe3\x81\xbb\xe3\x82\x99" }, + { 0x307d, "\xe3\x81\xbb\xe3\x82\x9a" }, + { 0x3094, "\xe3\x81\x86\xe3\x82\x99" }, + { 0x309e, "\xe3\x82\x9d\xe3\x82\x99" }, + { 0x309f, "\xe3\x82\x88\xe3\x82\x8a" }, + { 0x30ac, "\xe3\x82\xab\xe3\x82\x99" }, + { 0x30ae, "\xe3\x82\xad\xe3\x82\x99" }, + { 0x30b0, "\xe3\x82\xaf\xe3\x82\x99" }, + { 0x30b2, "\xe3\x82\xb1\xe3\x82\x99" }, + { 0x30b4, "\xe3\x82\xb3\xe3\x82\x99" }, + { 0x30b6, "\xe3\x82\xb5\xe3\x82\x99" }, + { 0x30b8, "\xe3\x82\xb7\xe3\x82\x99" }, + { 0x30ba, "\xe3\x82\xb9\xe3\x82\x99" }, + { 0x30bc, "\xe3\x82\xbb\xe3\x82\x99" }, + { 0x30be, "\xe3\x82\xbd\xe3\x82\x99" }, + { 0x30c0, "\xe3\x82\xbf\xe3\x82\x99" }, + { 0x30c2, "\xe3\x83\x81\xe3\x82\x99" }, + { 0x30c5, "\xe3\x83\x84\xe3\x82\x99" }, + { 0x30c7, "\xe3\x83\x86\xe3\x82\x99" }, + { 0x30c9, "\xe3\x83\x88\xe3\x82\x99" }, + { 0x30d0, "\xe3\x83\x8f\xe3\x82\x99" }, + { 0x30d1, "\xe3\x83\x8f\xe3\x82\x9a" }, + { 0x30d3, "\xe3\x83\x92\xe3\x82\x99" }, + { 0x30d4, "\xe3\x83\x92\xe3\x82\x9a" }, + { 0x30d6, "\xe3\x83\x95\xe3\x82\x99" }, + { 0x30d7, "\xe3\x83\x95\xe3\x82\x9a" }, + { 0x30d9, "\xe3\x83\x98\xe3\x82\x99" }, + { 0x30da, "\xe3\x83\x98\xe3\x82\x9a" }, + { 0x30dc, "\xe3\x83\x9b\xe3\x82\x99" }, + { 0x30dd, "\xe3\x83\x9b\xe3\x82\x9a" }, + { 0x30f4, "\xe3\x82\xa6\xe3\x82\x99" }, + { 0x30f7, "\xe3\x83\xaf\xe3\x82\x99" }, + { 0x30f8, "\xe3\x83\xb0\xe3\x82\x99" }, + { 0x30f9, "\xe3\x83\xb1\xe3\x82\x99" }, + { 0x30fa, "\xe3\x83\xb2\xe3\x82\x99" }, + { 0x30fe, "\xe3\x83\xbd\xe3\x82\x99" }, + { 0x30ff, "\xe3\x82\xb3\xe3\x83\x88" }, + { 0x320e, "\x28\xe1\x84\x80\xe1\x85\xa1\x29" }, + { 0x320f, "\x28\xe1\x84\x82\xe1\x85\xa1\x29" }, + { 0x3210, "\x28\xe1\x84\x83\xe1\x85\xa1\x29" }, + { 0x3211, "\x28\xe1\x84\x85\xe1\x85\xa1\x29" }, + { 0x3212, "\x28\xe1\x84\x86\xe1\x85\xa1\x29" }, + { 0x3213, "\x28\xe1\x84\x87\xe1\x85\xa1\x29" }, + { 0x3214, "\x28\xe1\x84\x89\xe1\x85\xa1\x29" }, + { 0x3215, "\x28\xe1\x84\x8b\xe1\x85\xa1\x29" }, + { 0x3216, "\x28\xe1\x84\x8c\xe1\x85\xa1\x29" }, + { 0x3217, "\x28\xe1\x84\x8e\xe1\x85\xa1\x29" }, + { 0x3218, "\x28\xe1\x84\x8f\xe1\x85\xa1\x29" }, + { 0x3219, "\x28\xe1\x84\x90\xe1\x85\xa1\x29" }, + { 0x321a, "\x28\xe1\x84\x91\xe1\x85\xa1\x29" }, + { 0x321b, "\x28\xe1\x84\x92\xe1\x85\xa1\x29" }, + { 0x321c, "\x28\xe1\x84\x8c\xe1\x85\xae\x29" }, + { 0x321d, "\x28\xe1\x84\x8b\xe1\x85\xa9\xe1\x84\x8c\xe1\x85\xa5\xe1\x86\xab\x29" }, + { 0x321e, "\x28\xe1\x84\x8b\xe1\x85\xa9\xe1\x84\x92\xe1\x85\xae\x29" }, + { 0x326e, "\xe1\x84\x80\xe1\x85\xa1" }, + { 0x326f, "\xe1\x84\x82\xe1\x85\xa1" }, + { 0x3270, "\xe1\x84\x83\xe1\x85\xa1" }, + { 0x3271, "\xe1\x84\x85\xe1\x85\xa1" }, + { 0x3272, "\xe1\x84\x86\xe1\x85\xa1" }, + { 0x3273, "\xe1\x84\x87\xe1\x85\xa1" }, + { 0x3274, "\xe1\x84\x89\xe1\x85\xa1" }, + { 0x3275, "\xe1\x84\x8b\xe1\x85\xa1" }, + { 0x3276, "\xe1\x84\x8c\xe1\x85\xa1" }, + { 0x3277, "\xe1\x84\x8e\xe1\x85\xa1" }, + { 0x3278, "\xe1\x84\x8f\xe1\x85\xa1" }, + { 0x3279, "\xe1\x84\x90\xe1\x85\xa1" }, + { 0x327a, "\xe1\x84\x91\xe1\x85\xa1" }, + { 0x327b, "\xe1\x84\x92\xe1\x85\xa1" }, + { 0x327c, "\xe1\x84\x8e\xe1\x85\xa1\xe1\x86\xb7\xe1\x84\x80\xe1\x85\xa9" }, + { 0x327d, "\xe1\x84\x8c\xe1\x85\xae\xe1\x84\x8b\xe1\x85\xb4" }, + { 0x327e, "\xe1\x84\x8b\xe1\x85\xae" }, + { 0x32ff, "\xe4\xbb\xa4\xe5\x92\x8c" }, + { 0x3300, "\xe3\x82\xa2\xe3\x83\x8f\xe3\x82\x9a\xe3\x83\xbc\xe3\x83\x88" }, + { 0x3301, "\xe3\x82\xa2\xe3\x83\xab\xe3\x83\x95\xe3\x82\xa1" }, + { 0x3302, "\xe3\x82\xa2\xe3\x83\xb3\xe3\x83\x98\xe3\x82\x9a\xe3\x82\xa2" }, + { 0x3303, "\xe3\x82\xa2\xe3\x83\xbc\xe3\x83\xab" }, + { 0x3304, "\xe3\x82\xa4\xe3\x83\x8b\xe3\x83\xb3\xe3\x82\xaf\xe3\x82\x99" }, + { 0x3305, "\xe3\x82\xa4\xe3\x83\xb3\xe3\x83\x81" }, + { 0x3306, "\xe3\x82\xa6\xe3\x82\xa9\xe3\x83\xb3" }, + { 0x3307, "\xe3\x82\xa8\xe3\x82\xb9\xe3\x82\xaf\xe3\x83\xbc\xe3\x83\x88\xe3\x82\x99" }, + { 0x3308, "\xe3\x82\xa8\xe3\x83\xbc\xe3\x82\xab\xe3\x83\xbc" }, + { 0x3309, "\xe3\x82\xaa\xe3\x83\xb3\xe3\x82\xb9" }, + { 0x330a, "\xe3\x82\xaa\xe3\x83\xbc\xe3\x83\xa0" }, + { 0x330b, "\xe3\x82\xab\xe3\x82\xa4\xe3\x83\xaa" }, + { 0x330c, "\xe3\x82\xab\xe3\x83\xa9\xe3\x83\x83\xe3\x83\x88" }, + { 0x330d, "\xe3\x82\xab\xe3\x83\xad\xe3\x83\xaa\xe3\x83\xbc" }, + { 0x330e, "\xe3\x82\xab\xe3\x82\x99\xe3\x83\xad\xe3\x83\xb3" }, + { 0x330f, "\xe3\x82\xab\xe3\x82\x99\xe3\x83\xb3\xe3\x83\x9e" }, + { 0x3310, "\xe3\x82\xad\xe3\x82\x99\xe3\x82\xab\xe3\x82\x99" }, + { 0x3311, "\xe3\x82\xad\xe3\x82\x99\xe3\x83\x8b\xe3\x83\xbc" }, + { 0x3312, "\xe3\x82\xad\xe3\x83\xa5\xe3\x83\xaa\xe3\x83\xbc" }, + { 0x3313, "\xe3\x82\xad\xe3\x82\x99\xe3\x83\xab\xe3\x82\xbf\xe3\x82\x99\xe3\x83\xbc" }, + { 0x3314, "\xe3\x82\xad\xe3\x83\xad" }, + { 0x3315, "\xe3\x82\xad\xe3\x83\xad\xe3\x82\xaf\xe3\x82\x99\xe3\x83\xa9\xe3\x83\xa0" }, + { 0x3316, "\xe3\x82\xad\xe3\x83\xad\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\x88\xe3\x83\xab" }, + { 0x3317, "\xe3\x82\xad\xe3\x83\xad\xe3\x83\xaf\xe3\x83\x83\xe3\x83\x88" }, + { 0x3318, "\xe3\x82\xaf\xe3\x82\x99\xe3\x83\xa9\xe3\x83\xa0" }, + { 0x3319, "\xe3\x82\xaf\xe3\x82\x99\xe3\x83\xa9\xe3\x83\xa0\xe3\x83\x88\xe3\x83\xb3" }, + { 0x331a, "\xe3\x82\xaf\xe3\x83\xab\xe3\x82\xbb\xe3\x82\x99\xe3\x82\xa4\xe3\x83\xad" }, + { 0x331b, "\xe3\x82\xaf\xe3\x83\xad\xe3\x83\xbc\xe3\x83\x8d" }, + { 0x331c, "\xe3\x82\xb1\xe3\x83\xbc\xe3\x82\xb9" }, + { 0x331d, "\xe3\x82\xb3\xe3\x83\xab\xe3\x83\x8a" }, + { 0x331e, "\xe3\x82\xb3\xe3\x83\xbc\xe3\x83\x9b\xe3\x82\x9a" }, + { 0x331f, "\xe3\x82\xb5\xe3\x82\xa4\xe3\x82\xaf\xe3\x83\xab" }, + { 0x3320, "\xe3\x82\xb5\xe3\x83\xb3\xe3\x83\x81\xe3\x83\xbc\xe3\x83\xa0" }, + { 0x3321, "\xe3\x82\xb7\xe3\x83\xaa\xe3\x83\xb3\xe3\x82\xaf\xe3\x82\x99" }, + { 0x3322, "\xe3\x82\xbb\xe3\x83\xb3\xe3\x83\x81" }, + { 0x3323, "\xe3\x82\xbb\xe3\x83\xb3\xe3\x83\x88" }, + { 0x3324, "\xe3\x82\xbf\xe3\x82\x99\xe3\x83\xbc\xe3\x82\xb9" }, + { 0x3325, "\xe3\x83\x86\xe3\x82\x99\xe3\x82\xb7" }, + { 0x3326, "\xe3\x83\x88\xe3\x82\x99\xe3\x83\xab" }, + { 0x3327, "\xe3\x83\x88\xe3\x83\xb3" }, + { 0x3328, "\xe3\x83\x8a\xe3\x83\x8e" }, + { 0x3329, "\xe3\x83\x8e\xe3\x83\x83\xe3\x83\x88" }, + { 0x332a, "\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84" }, + { 0x332b, "\xe3\x83\x8f\xe3\x82\x9a\xe3\x83\xbc\xe3\x82\xbb\xe3\x83\xb3\xe3\x83\x88" }, + { 0x332c, "\xe3\x83\x8f\xe3\x82\x9a\xe3\x83\xbc\xe3\x83\x84" }, + { 0x332d, "\xe3\x83\x8f\xe3\x82\x99\xe3\x83\xbc\xe3\x83\xac\xe3\x83\xab" }, + { 0x332e, "\xe3\x83\x92\xe3\x82\x9a\xe3\x82\xa2\xe3\x82\xb9\xe3\x83\x88\xe3\x83\xab" }, + { 0x332f, "\xe3\x83\x92\xe3\x82\x9a\xe3\x82\xaf\xe3\x83\xab" }, + { 0x3330, "\xe3\x83\x92\xe3\x82\x9a\xe3\x82\xb3" }, + { 0x3331, "\xe3\x83\x92\xe3\x82\x99\xe3\x83\xab" }, + { 0x3332, "\xe3\x83\x95\xe3\x82\xa1\xe3\x83\xa9\xe3\x83\x83\xe3\x83\x88\xe3\x82\x99" }, + { 0x3333, "\xe3\x83\x95\xe3\x82\xa3\xe3\x83\xbc\xe3\x83\x88" }, + { 0x3334, "\xe3\x83\x95\xe3\x82\x99\xe3\x83\x83\xe3\x82\xb7\xe3\x82\xa7\xe3\x83\xab" }, + { 0x3335, "\xe3\x83\x95\xe3\x83\xa9\xe3\x83\xb3" }, + { 0x3336, "\xe3\x83\x98\xe3\x82\xaf\xe3\x82\xbf\xe3\x83\xbc\xe3\x83\xab" }, + { 0x3337, "\xe3\x83\x98\xe3\x82\x9a\xe3\x82\xbd" }, + { 0x3338, "\xe3\x83\x98\xe3\x82\x9a\xe3\x83\x8b\xe3\x83\x92" }, + { 0x3339, "\xe3\x83\x98\xe3\x83\xab\xe3\x83\x84" }, + { 0x333a, "\xe3\x83\x98\xe3\x82\x9a\xe3\x83\xb3\xe3\x82\xb9" }, + { 0x333b, "\xe3\x83\x98\xe3\x82\x9a\xe3\x83\xbc\xe3\x82\xb7\xe3\x82\x99" }, + { 0x333c, "\xe3\x83\x98\xe3\x82\x99\xe3\x83\xbc\xe3\x82\xbf" }, + { 0x333d, "\xe3\x83\x9b\xe3\x82\x9a\xe3\x82\xa4\xe3\x83\xb3\xe3\x83\x88" }, + { 0x333e, "\xe3\x83\x9b\xe3\x82\x99\xe3\x83\xab\xe3\x83\x88" }, + { 0x333f, "\xe3\x83\x9b\xe3\x83\xb3" }, + { 0x3340, "\xe3\x83\x9b\xe3\x82\x9a\xe3\x83\xb3\xe3\x83\x88\xe3\x82\x99" }, + { 0x3341, "\xe3\x83\x9b\xe3\x83\xbc\xe3\x83\xab" }, + { 0x3342, "\xe3\x83\x9b\xe3\x83\xbc\xe3\x83\xb3" }, + { 0x3343, "\xe3\x83\x9e\xe3\x82\xa4\xe3\x82\xaf\xe3\x83\xad" }, + { 0x3344, "\xe3\x83\x9e\xe3\x82\xa4\xe3\x83\xab" }, + { 0x3345, "\xe3\x83\x9e\xe3\x83\x83\xe3\x83\x8f" }, + { 0x3346, "\xe3\x83\x9e\xe3\x83\xab\xe3\x82\xaf" }, + { 0x3347, "\xe3\x83\x9e\xe3\x83\xb3\xe3\x82\xb7\xe3\x83\xa7\xe3\x83\xb3" }, + { 0x3348, "\xe3\x83\x9f\xe3\x82\xaf\xe3\x83\xad\xe3\x83\xb3" }, + { 0x3349, "\xe3\x83\x9f\xe3\x83\xaa" }, + { 0x334a, "\xe3\x83\x9f\xe3\x83\xaa\xe3\x83\x8f\xe3\x82\x99\xe3\x83\xbc\xe3\x83\xab" }, + { 0x334b, "\xe3\x83\xa1\xe3\x82\xab\xe3\x82\x99" }, + { 0x334c, "\xe3\x83\xa1\xe3\x82\xab\xe3\x82\x99\xe3\x83\x88\xe3\x83\xb3" }, + { 0x334d, "\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\x88\xe3\x83\xab" }, + { 0x334e, "\xe3\x83\xa4\xe3\x83\xbc\xe3\x83\x88\xe3\x82\x99" }, + { 0x334f, "\xe3\x83\xa4\xe3\x83\xbc\xe3\x83\xab" }, + { 0x3350, "\xe3\x83\xa6\xe3\x82\xa2\xe3\x83\xb3" }, + { 0x3351, "\xe3\x83\xaa\xe3\x83\x83\xe3\x83\x88\xe3\x83\xab" }, + { 0x3352, "\xe3\x83\xaa\xe3\x83\xa9" }, + { 0x3353, "\xe3\x83\xab\xe3\x83\x92\xe3\x82\x9a\xe3\x83\xbc" }, + { 0x3354, "\xe3\x83\xab\xe3\x83\xbc\xe3\x83\x95\xe3\x82\x99\xe3\x83\xab" }, + { 0x3355, "\xe3\x83\xac\xe3\x83\xa0" }, + { 0x3356, "\xe3\x83\xac\xe3\x83\xb3\xe3\x83\x88\xe3\x82\xb1\xe3\x82\x99\xe3\x83\xb3" }, + { 0x3357, "\xe3\x83\xaf\xe3\x83\x83\xe3\x83\x88" }, + { 0x337b, "\xe5\xb9\xb3\xe6\x88\x90" }, + { 0x337c, "\xe6\x98\xad\xe5\x92\x8c" }, + { 0x337d, "\xe5\xa4\xa7\xe6\xad\xa3" }, + { 0x337e, "\xe6\x98\x8e\xe6\xb2\xbb" }, + { 0x337f, "\xe6\xa0\xaa\xe5\xbc\x8f\xe4\xbc\x9a\xe7\xa4\xbe" }, + { 0x33a8, "\x6d\xe2\x88\x95\x73\x32" }, + { 0x33ae, "\x72\x61\x64\xe2\x88\x95\x73" }, + { 0x33af, "\x72\x61\x64\xe2\x88\x95\x73\x32" }, + { 0x33c6, "\x43\xe2\x88\x95\x6b\x67" }, + { 0xfb2c, "\xd7\xa9\xd6\xbc\xd7\x81" }, + { 0xfb2d, "\xd7\xa9\xd6\xbc\xd7\x82" }, + { 0xfbea, "\xd9\x8a\xd9\x94\xd8\xa7" }, + { 0xfbeb, "\xd9\x8a\xd9\x94\xd8\xa7" }, + { 0xfbec, "\xd9\x8a\xd9\x94\xdb\x95" }, + { 0xfbed, "\xd9\x8a\xd9\x94\xdb\x95" }, + { 0xfbee, "\xd9\x8a\xd9\x94\xd9\x88" }, + { 0xfbef, "\xd9\x8a\xd9\x94\xd9\x88" }, + { 0xfbf0, "\xd9\x8a\xd9\x94\xdb\x87" }, + { 0xfbf1, "\xd9\x8a\xd9\x94\xdb\x87" }, + { 0xfbf2, "\xd9\x8a\xd9\x94\xdb\x86" }, + { 0xfbf3, "\xd9\x8a\xd9\x94\xdb\x86" }, + { 0xfbf4, "\xd9\x8a\xd9\x94\xdb\x88" }, + { 0xfbf5, "\xd9\x8a\xd9\x94\xdb\x88" }, + { 0xfbf6, "\xd9\x8a\xd9\x94\xdb\x90" }, + { 0xfbf7, "\xd9\x8a\xd9\x94\xdb\x90" }, + { 0xfbf8, "\xd9\x8a\xd9\x94\xdb\x90" }, + { 0xfbf9, "\xd9\x8a\xd9\x94\xd9\x89" }, + { 0xfbfa, "\xd9\x8a\xd9\x94\xd9\x89" }, + { 0xfbfb, "\xd9\x8a\xd9\x94\xd9\x89" }, + { 0xfc00, "\xd9\x8a\xd9\x94\xd8\xac" }, + { 0xfc01, "\xd9\x8a\xd9\x94\xd8\xad" }, + { 0xfc02, "\xd9\x8a\xd9\x94\xd9\x85" }, + { 0xfc03, "\xd9\x8a\xd9\x94\xd9\x89" }, + { 0xfc04, "\xd9\x8a\xd9\x94\xd9\x8a" }, + { 0xfc64, "\xd9\x8a\xd9\x94\xd8\xb1" }, + { 0xfc65, "\xd9\x8a\xd9\x94\xd8\xb2" }, + { 0xfc66, "\xd9\x8a\xd9\x94\xd9\x85" }, + { 0xfc67, "\xd9\x8a\xd9\x94\xd9\x86" }, + { 0xfc68, "\xd9\x8a\xd9\x94\xd9\x89" }, + { 0xfc69, "\xd9\x8a\xd9\x94\xd9\x8a" }, + { 0xfc97, "\xd9\x8a\xd9\x94\xd8\xac" }, + { 0xfc98, "\xd9\x8a\xd9\x94\xd8\xad" }, + { 0xfc99, "\xd9\x8a\xd9\x94\xd8\xae" }, + { 0xfc9a, "\xd9\x8a\xd9\x94\xd9\x85" }, + { 0xfc9b, "\xd9\x8a\xd9\x94\xd9\x87" }, + { 0xfcdf, "\xd9\x8a\xd9\x94\xd9\x85" }, + { 0xfce0, "\xd9\x8a\xd9\x94\xd9\x87" }, + { 0xfcf2, "\xd9\x80\xd9\x8e\xd9\x91" }, + { 0xfcf3, "\xd9\x80\xd9\x8f\xd9\x91" }, + { 0xfcf4, "\xd9\x80\xd9\x90\xd9\x91" }, + { 0xfd50, "\xd8\xaa\xd8\xac\xd9\x85" }, + { 0xfd51, "\xd8\xaa\xd8\xad\xd8\xac" }, + { 0xfd52, "\xd8\xaa\xd8\xad\xd8\xac" }, + { 0xfd53, "\xd8\xaa\xd8\xad\xd9\x85" }, + { 0xfd54, "\xd8\xaa\xd8\xae\xd9\x85" }, + { 0xfd55, "\xd8\xaa\xd9\x85\xd8\xac" }, + { 0xfd56, "\xd8\xaa\xd9\x85\xd8\xad" }, + { 0xfd57, "\xd8\xaa\xd9\x85\xd8\xae" }, + { 0xfd58, "\xd8\xac\xd9\x85\xd8\xad" }, + { 0xfd59, "\xd8\xac\xd9\x85\xd8\xad" }, + { 0xfd5a, "\xd8\xad\xd9\x85\xd9\x8a" }, + { 0xfd5b, "\xd8\xad\xd9\x85\xd9\x89" }, + { 0xfd5c, "\xd8\xb3\xd8\xad\xd8\xac" }, + { 0xfd5d, "\xd8\xb3\xd8\xac\xd8\xad" }, + { 0xfd5e, "\xd8\xb3\xd8\xac\xd9\x89" }, + { 0xfd5f, "\xd8\xb3\xd9\x85\xd8\xad" }, + { 0xfd60, "\xd8\xb3\xd9\x85\xd8\xad" }, + { 0xfd61, "\xd8\xb3\xd9\x85\xd8\xac" }, + { 0xfd62, "\xd8\xb3\xd9\x85\xd9\x85" }, + { 0xfd63, "\xd8\xb3\xd9\x85\xd9\x85" }, + { 0xfd64, "\xd8\xb5\xd8\xad\xd8\xad" }, + { 0xfd65, "\xd8\xb5\xd8\xad\xd8\xad" }, + { 0xfd66, "\xd8\xb5\xd9\x85\xd9\x85" }, + { 0xfd67, "\xd8\xb4\xd8\xad\xd9\x85" }, + { 0xfd68, "\xd8\xb4\xd8\xad\xd9\x85" }, + { 0xfd69, "\xd8\xb4\xd8\xac\xd9\x8a" }, + { 0xfd6a, "\xd8\xb4\xd9\x85\xd8\xae" }, + { 0xfd6b, "\xd8\xb4\xd9\x85\xd8\xae" }, + { 0xfd6c, "\xd8\xb4\xd9\x85\xd9\x85" }, + { 0xfd6d, "\xd8\xb4\xd9\x85\xd9\x85" }, + { 0xfd6e, "\xd8\xb6\xd8\xad\xd9\x89" }, + { 0xfd6f, "\xd8\xb6\xd8\xae\xd9\x85" }, + { 0xfd70, "\xd8\xb6\xd8\xae\xd9\x85" }, + { 0xfd71, "\xd8\xb7\xd9\x85\xd8\xad" }, + { 0xfd72, "\xd8\xb7\xd9\x85\xd8\xad" }, + { 0xfd73, "\xd8\xb7\xd9\x85\xd9\x85" }, + { 0xfd74, "\xd8\xb7\xd9\x85\xd9\x8a" }, + { 0xfd75, "\xd8\xb9\xd8\xac\xd9\x85" }, + { 0xfd76, "\xd8\xb9\xd9\x85\xd9\x85" }, + { 0xfd77, "\xd8\xb9\xd9\x85\xd9\x85" }, + { 0xfd78, "\xd8\xb9\xd9\x85\xd9\x89" }, + { 0xfd79, "\xd8\xba\xd9\x85\xd9\x85" }, + { 0xfd7a, "\xd8\xba\xd9\x85\xd9\x8a" }, + { 0xfd7b, "\xd8\xba\xd9\x85\xd9\x89" }, + { 0xfd7c, "\xd9\x81\xd8\xae\xd9\x85" }, + { 0xfd7d, "\xd9\x81\xd8\xae\xd9\x85" }, + { 0xfd7e, "\xd9\x82\xd9\x85\xd8\xad" }, + { 0xfd7f, "\xd9\x82\xd9\x85\xd9\x85" }, + { 0xfd80, "\xd9\x84\xd8\xad\xd9\x85" }, + { 0xfd81, "\xd9\x84\xd8\xad\xd9\x8a" }, + { 0xfd82, "\xd9\x84\xd8\xad\xd9\x89" }, + { 0xfd83, "\xd9\x84\xd8\xac\xd8\xac" }, + { 0xfd84, "\xd9\x84\xd8\xac\xd8\xac" }, + { 0xfd85, "\xd9\x84\xd8\xae\xd9\x85" }, + { 0xfd86, "\xd9\x84\xd8\xae\xd9\x85" }, + { 0xfd87, "\xd9\x84\xd9\x85\xd8\xad" }, + { 0xfd88, "\xd9\x84\xd9\x85\xd8\xad" }, + { 0xfd89, "\xd9\x85\xd8\xad\xd8\xac" }, + { 0xfd8a, "\xd9\x85\xd8\xad\xd9\x85" }, + { 0xfd8b, "\xd9\x85\xd8\xad\xd9\x8a" }, + { 0xfd8c, "\xd9\x85\xd8\xac\xd8\xad" }, + { 0xfd8d, "\xd9\x85\xd8\xac\xd9\x85" }, + { 0xfd8e, "\xd9\x85\xd8\xae\xd8\xac" }, + { 0xfd8f, "\xd9\x85\xd8\xae\xd9\x85" }, + { 0xfd92, "\xd9\x85\xd8\xac\xd8\xae" }, + { 0xfd93, "\xd9\x87\xd9\x85\xd8\xac" }, + { 0xfd94, "\xd9\x87\xd9\x85\xd9\x85" }, + { 0xfd95, "\xd9\x86\xd8\xad\xd9\x85" }, + { 0xfd96, "\xd9\x86\xd8\xad\xd9\x89" }, + { 0xfd97, "\xd9\x86\xd8\xac\xd9\x85" }, + { 0xfd98, "\xd9\x86\xd8\xac\xd9\x85" }, + { 0xfd99, "\xd9\x86\xd8\xac\xd9\x89" }, + { 0xfd9a, "\xd9\x86\xd9\x85\xd9\x8a" }, + { 0xfd9b, "\xd9\x86\xd9\x85\xd9\x89" }, + { 0xfd9c, "\xd9\x8a\xd9\x85\xd9\x85" }, + { 0xfd9d, "\xd9\x8a\xd9\x85\xd9\x85" }, + { 0xfd9e, "\xd8\xa8\xd8\xae\xd9\x8a" }, + { 0xfd9f, "\xd8\xaa\xd8\xac\xd9\x8a" }, + { 0xfda0, "\xd8\xaa\xd8\xac\xd9\x89" }, + { 0xfda1, "\xd8\xaa\xd8\xae\xd9\x8a" }, + { 0xfda2, "\xd8\xaa\xd8\xae\xd9\x89" }, + { 0xfda3, "\xd8\xaa\xd9\x85\xd9\x8a" }, + { 0xfda4, "\xd8\xaa\xd9\x85\xd9\x89" }, + { 0xfda5, "\xd8\xac\xd9\x85\xd9\x8a" }, + { 0xfda6, "\xd8\xac\xd8\xad\xd9\x89" }, + { 0xfda7, "\xd8\xac\xd9\x85\xd9\x89" }, + { 0xfda8, "\xd8\xb3\xd8\xae\xd9\x89" }, + { 0xfda9, "\xd8\xb5\xd8\xad\xd9\x8a" }, + { 0xfdaa, "\xd8\xb4\xd8\xad\xd9\x8a" }, + { 0xfdab, "\xd8\xb6\xd8\xad\xd9\x8a" }, + { 0xfdac, "\xd9\x84\xd8\xac\xd9\x8a" }, + { 0xfdad, "\xd9\x84\xd9\x85\xd9\x8a" }, + { 0xfdae, "\xd9\x8a\xd8\xad\xd9\x8a" }, + { 0xfdaf, "\xd9\x8a\xd8\xac\xd9\x8a" }, + { 0xfdb0, "\xd9\x8a\xd9\x85\xd9\x8a" }, + { 0xfdb1, "\xd9\x85\xd9\x85\xd9\x8a" }, + { 0xfdb2, "\xd9\x82\xd9\x85\xd9\x8a" }, + { 0xfdb3, "\xd9\x86\xd8\xad\xd9\x8a" }, + { 0xfdb4, "\xd9\x82\xd9\x85\xd8\xad" }, + { 0xfdb5, "\xd9\x84\xd8\xad\xd9\x85" }, + { 0xfdb6, "\xd8\xb9\xd9\x85\xd9\x8a" }, + { 0xfdb7, "\xd9\x83\xd9\x85\xd9\x8a" }, + { 0xfdb8, "\xd9\x86\xd8\xac\xd8\xad" }, + { 0xfdb9, "\xd9\x85\xd8\xae\xd9\x8a" }, + { 0xfdba, "\xd9\x84\xd8\xac\xd9\x85" }, + { 0xfdbb, "\xd9\x83\xd9\x85\xd9\x85" }, + { 0xfdbc, "\xd9\x84\xd8\xac\xd9\x85" }, + { 0xfdbd, "\xd9\x86\xd8\xac\xd8\xad" }, + { 0xfdbe, "\xd8\xac\xd8\xad\xd9\x8a" }, + { 0xfdbf, "\xd8\xad\xd8\xac\xd9\x8a" }, + { 0xfdc0, "\xd9\x85\xd8\xac\xd9\x8a" }, + { 0xfdc1, "\xd9\x81\xd9\x85\xd9\x8a" }, + { 0xfdc2, "\xd8\xa8\xd8\xad\xd9\x8a" }, + { 0xfdc3, "\xd9\x83\xd9\x85\xd9\x85" }, + { 0xfdc4, "\xd8\xb9\xd8\xac\xd9\x85" }, + { 0xfdc5, "\xd8\xb5\xd9\x85\xd9\x85" }, + { 0xfdc6, "\xd8\xb3\xd8\xae\xd9\x8a" }, + { 0xfdc7, "\xd9\x86\xd8\xac\xd9\x8a" }, + { 0xfdf0, "\xd8\xb5\xd9\x84\xdb\x92" }, + { 0xfdf1, "\xd9\x82\xd9\x84\xdb\x92" }, + { 0xfdf2, "\xd8\xa7\xd9\x84\xd9\x84\xd9\x87" }, + { 0xfdf3, "\xd8\xa7\xd9\x83\xd8\xa8\xd8\xb1" }, + { 0xfdf4, "\xd9\x85\xd8\xad\xd9\x85\xd8\xaf" }, + { 0xfdf5, "\xd8\xb5\xd9\x84\xd8\xb9\xd9\x85" }, + { 0xfdf6, "\xd8\xb1\xd8\xb3\xd9\x88\xd9\x84" }, + { 0xfdf7, "\xd8\xb9\xd9\x84\xd9\x8a\xd9\x87" }, + { 0xfdf8, "\xd9\x88\xd8\xb3\xd9\x84\xd9\x85" }, + { 0xfdf9, "\xd8\xb5\xd9\x84\xd9\x89" }, + { 0xfdfa, "\xd8\xb5\xd9\x84\xd9\x89\x20\xd8\xa7\xd9\x84\xd9\x84\xd9\x87\x20\xd8\xb9\xd9\x84\xd9\x8a\xd9\x87\x20\xd9\x88\xd8\xb3\xd9\x84\xd9\x85" }, + { 0xfdfb, "\xd8\xac\xd9\x84\x20\xd8\xac\xd9\x84\xd8\xa7\xd9\x84\xd9\x87" }, + { 0xfdfc, "\xd8\xb1\xdb\x8c\xd8\xa7\xd9\x84" }, + { 0xfef5, "\xd9\x84\xd8\xa7\xd9\x93" }, + { 0xfef6, "\xd9\x84\xd8\xa7\xd9\x93" }, + { 0xfef7, "\xd9\x84\xd8\xa7\xd9\x94" }, + { 0xfef8, "\xd9\x84\xd8\xa7\xd9\x94" }, + { 0xfef9, "\xd9\x84\xd8\xa7\xd9\x95" }, + { 0xfefa, "\xd9\x84\xd8\xa7\xd9\x95" }, + { 0x1109a, "\xf0\x91\x82\x99\xf0\x91\x82\xba" }, + { 0x1109c, "\xf0\x91\x82\x9b\xf0\x91\x82\xba" }, + { 0x110ab, "\xf0\x91\x82\xa5\xf0\x91\x82\xba" }, + { 0x1112e, "\xf0\x91\x84\xb1\xf0\x91\x84\xa7" }, + { 0x1112f, "\xf0\x91\x84\xb2\xf0\x91\x84\xa7" }, + { 0x1134b, "\xf0\x91\x8d\x87\xf0\x91\x8c\xbe" }, + { 0x1134c, "\xf0\x91\x8d\x87\xf0\x91\x8d\x97" }, + { 0x114bb, "\xf0\x91\x92\xb9\xf0\x91\x92\xba" }, + { 0x114bc, "\xf0\x91\x92\xb9\xf0\x91\x92\xb0" }, + { 0x114be, "\xf0\x91\x92\xb9\xf0\x91\x92\xbd" }, + { 0x115ba, "\xf0\x91\x96\xb8\xf0\x91\x96\xaf" }, + { 0x115bb, "\xf0\x91\x96\xb9\xf0\x91\x96\xaf" }, + { 0x11938, "\xf0\x91\xa4\xb5\xf0\x91\xa4\xb0" }, + { 0x1d15e, "\xf0\x9d\x85\x97\xf0\x9d\x85\xa5" }, + { 0x1d15f, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5" }, + { 0x1d160, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d161, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" }, + { 0x1d162, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb0" }, + { 0x1d163, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb1" }, + { 0x1d164, "\xf0\x9d\x85\x98\xf0\x9d\x85\xa5\xf0\x9d\x85\xb2" }, + { 0x1d1bb, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5" }, + { 0x1d1bc, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5" }, + { 0x1d1bd, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d1be, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5\xf0\x9d\x85\xae" }, + { 0x1d1bf, "\xf0\x9d\x86\xb9\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" }, + { 0x1d1c0, "\xf0\x9d\x86\xba\xf0\x9d\x85\xa5\xf0\x9d\x85\xaf" }, + { 0x1f12a, "\xe3\x80\x94\x53\xe3\x80\x95" }, + { 0x1f200, "\xe3\x81\xbb\xe3\x81\x8b" }, + { 0x1f201, "\xe3\x82\xb3\xe3\x82\xb3" }, + { 0x1f213, "\xe3\x83\x86\xe3\x82\x99" }, + { 0x1f240, "\xe3\x80\x94\xe6\x9c\xac\xe3\x80\x95" }, + { 0x1f241, "\xe3\x80\x94\xe4\xb8\x89\xe3\x80\x95" }, + { 0x1f242, "\xe3\x80\x94\xe4\xba\x8c\xe3\x80\x95" }, + { 0x1f243, "\xe3\x80\x94\xe5\xae\x89\xe3\x80\x95" }, + { 0x1f244, "\xe3\x80\x94\xe7\x82\xb9\xe3\x80\x95" }, + { 0x1f245, "\xe3\x80\x94\xe6\x89\x93\xe3\x80\x95" }, + { 0x1f246, "\xe3\x80\x94\xe7\x9b\x97\xe3\x80\x95" }, + { 0x1f247, "\xe3\x80\x94\xe5\x8b\x9d\xe3\x80\x95" }, + { 0x1f248, "\xe3\x80\x94\xe6\x95\x97\xe3\x80\x95" } +}; + +static const char* UN8IF_compat_tbl [5] = { + (const char*) UN8IF_compat_tbl_1, + (const char*) UN8IF_compat_tbl_2, + (const char*) UN8IF_compat_tbl_3, + (const char*) UN8IF_compat_tbl_4, + (const char*) UN8IF_compat_tbl_5 +}; + +/* the rows */ +static const uint16_t UN8IF_compat_00_00 [256] = { +/* 0000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 00a0 */ TBL(1)|58, 0, 0, 0, 0, 0, 0, 0, +/* 00a8 */ TBL(3)|286, 0, TBL(1)|65, 0, 0, 0, 0, TBL(3)|282, +/* 00b0 */ 0, 0, TBL(1)|16, TBL(1)|17, TBL(3)|280, TBL(2)|211, 0, 0, +/* 00b8 */ TBL(3)|291, TBL(1)|15, TBL(1)|79, 0, TBL(5)|76, TBL(5)|74, TBL(5)|101, 0, +/* 00c0 */ TBL(3)|78, TBL(3)|79, TBL(3)|80, TBL(3)|81, TBL(3)|85, TBL(3)|87, 0, TBL(3)|101, +/* 00c8 */ TBL(3)|109, TBL(3)|110, TBL(3)|111, TBL(3)|116, TBL(3)|145, TBL(3)|146, TBL(3)|147, TBL(3)|152, +/* 00d0 */ 0, TBL(3)|182, TBL(3)|189, TBL(3)|190, TBL(3)|191, TBL(3)|192, TBL(3)|196, 0, +/* 00d8 */ 0, TBL(3)|234, TBL(3)|235, TBL(3)|236, TBL(3)|240, TBL(3)|266, 0, 0, +/* 00e0 */ TBL(3)|1579, TBL(3)|1580, TBL(3)|1581, TBL(3)|1582, TBL(3)|1586, TBL(3)|1588, 0, TBL(3)|1605, +/* 00e8 */ TBL(3)|1617, TBL(3)|1618, TBL(3)|1619, TBL(3)|1624, TBL(3)|1655, TBL(3)|1656, TBL(3)|1657, TBL(3)|1661, +/* 00f0 */ 0, TBL(3)|1699, TBL(3)|1706, TBL(3)|1707, TBL(3)|1708, TBL(3)|1709, TBL(3)|1713, 0, +/* 00f8 */ 0, TBL(3)|1748, TBL(3)|1749, TBL(3)|1750, TBL(3)|1754, TBL(3)|1781, 0, TBL(3)|1786 +}; + +static const uint16_t UN8IF_compat_00_01 [256] = { +/* 0100 */ TBL(3)|82, TBL(3)|1583, TBL(3)|83, TBL(3)|1584, TBL(3)|93, TBL(3)|1594, TBL(3)|97, TBL(3)|1601, +/* 0108 */ TBL(3)|98, TBL(3)|1602, TBL(3)|99, TBL(3)|1603, TBL(3)|100, TBL(3)|1604, TBL(3)|104, TBL(3)|1610, +/* 0110 */ 0, 0, TBL(3)|113, TBL(3)|1621, TBL(3)|114, TBL(3)|1622, TBL(3)|115, TBL(3)|1623, +/* 0118 */ TBL(3)|123, TBL(3)|1631, TBL(3)|118, TBL(3)|1626, TBL(3)|131, TBL(3)|1639, TBL(3)|133, TBL(3)|1641, +/* 0120 */ TBL(3)|134, TBL(3)|1642, TBL(3)|136, TBL(3)|1644, TBL(3)|137, TBL(3)|1647, 0, 0, +/* 0128 */ TBL(3)|148, TBL(3)|1658, TBL(3)|149, TBL(3)|1659, TBL(3)|150, TBL(3)|1660, TBL(3)|158, TBL(3)|1667, +/* 0130 */ TBL(3)|151, 0, TBL(2)|80, TBL(2)|327, TBL(3)|160, TBL(3)|1670, TBL(3)|164, TBL(3)|1677, +/* 0138 */ 0, TBL(3)|168, TBL(3)|1683, TBL(3)|171, TBL(3)|1686, TBL(3)|169, TBL(3)|1684, TBL(3)|167, +/* 0140 */ TBL(3)|1682, 0, 0, TBL(3)|181, TBL(3)|1698, TBL(3)|186, TBL(3)|1703, TBL(3)|184, +/* 0148 */ TBL(3)|1701, TBL(3)|306, 0, 0, TBL(3)|193, TBL(3)|1710, TBL(3)|194, TBL(3)|1711, +/* 0150 */ TBL(3)|198, TBL(3)|1715, 0, 0, TBL(3)|210, TBL(3)|1724, TBL(3)|216, TBL(3)|1730, +/* 0158 */ TBL(3)|212, TBL(3)|1726, TBL(3)|218, TBL(3)|1733, TBL(3)|219, TBL(3)|1734, TBL(3)|224, TBL(3)|1739, +/* 0160 */ TBL(3)|221, TBL(3)|1736, TBL(3)|231, TBL(3)|1745, TBL(3)|228, TBL(3)|1742, 0, 0, +/* 0168 */ TBL(3)|237, TBL(3)|1751, TBL(3)|238, TBL(3)|1752, TBL(3)|239, TBL(3)|1753, TBL(3)|242, TBL(3)|1756, +/* 0170 */ TBL(3)|243, TBL(3)|1757, TBL(3)|250, TBL(3)|1764, TBL(3)|258, TBL(3)|1772, TBL(3)|267, TBL(3)|1782, +/* 0178 */ TBL(3)|271, TBL(3)|274, TBL(3)|1790, TBL(3)|276, TBL(3)|1792, TBL(3)|277, TBL(3)|1793, TBL(1)|83, +/* 0180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01a0 */ TBL(3)|202, TBL(3)|1719, 0, 0, 0, 0, 0, 0, +/* 01a8 */ 0, 0, 0, 0, 0, 0, 0, TBL(3)|247, +/* 01b0 */ TBL(3)|1761, 0, 0, 0, 0, 0, 0, 0, +/* 01b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01c0 */ 0, 0, 0, 0, TBL(4)|40, TBL(4)|41, TBL(4)|504, TBL(2)|87, +/* 01c8 */ TBL(2)|88, TBL(2)|338, TBL(2)|95, TBL(2)|96, TBL(2)|356, TBL(3)|88, TBL(3)|1589, TBL(3)|154, +/* 01d0 */ TBL(3)|1663, TBL(3)|199, TBL(3)|1716, TBL(3)|244, TBL(3)|1758, TBL(5)|159, TBL(5)|275, TBL(5)|158, +/* 01d8 */ TBL(5)|274, TBL(5)|160, TBL(5)|276, TBL(5)|157, TBL(5)|273, 0, TBL(5)|117, TBL(5)|233, +/* 01e0 */ TBL(5)|116, TBL(5)|232, TBL(4)|46, TBL(4)|49, 0, 0, TBL(3)|135, TBL(3)|1643, +/* 01e8 */ TBL(3)|162, TBL(3)|1675, TBL(3)|204, TBL(3)|1721, TBL(5)|150, TBL(5)|266, TBL(4)|51, TBL(4)|52, +/* 01f0 */ TBL(3)|1671, TBL(2)|71, TBL(2)|72, TBL(2)|319, TBL(3)|130, TBL(3)|1638, 0, 0, +/* 01f8 */ TBL(3)|180, TBL(3)|1697, TBL(5)|118, TBL(5)|234, TBL(4)|45, TBL(4)|48, TBL(4)|47, TBL(4)|50 +}; + +static const uint16_t UN8IF_compat_00_02 [256] = { +/* 0200 */ TBL(3)|89, TBL(3)|1590, TBL(3)|90, TBL(3)|1591, TBL(3)|119, TBL(3)|1627, TBL(3)|120, TBL(3)|1628, +/* 0208 */ TBL(3)|155, TBL(3)|1664, TBL(3)|156, TBL(3)|1665, TBL(3)|200, TBL(3)|1717, TBL(3)|201, TBL(3)|1718, +/* 0210 */ TBL(3)|213, TBL(3)|1727, TBL(3)|214, TBL(3)|1728, TBL(3)|245, TBL(3)|1759, TBL(3)|246, TBL(3)|1760, +/* 0218 */ TBL(3)|223, TBL(3)|1738, TBL(3)|230, TBL(3)|1744, 0, 0, TBL(3)|140, TBL(3)|1650, +/* 0220 */ 0, 0, 0, 0, 0, 0, TBL(3)|84, TBL(3)|1585, +/* 0228 */ TBL(3)|122, TBL(3)|1630, TBL(5)|143, TBL(5)|259, TBL(5)|138, TBL(5)|254, TBL(3)|195, TBL(3)|1712, +/* 0230 */ TBL(5)|142, TBL(5)|258, TBL(3)|269, TBL(3)|1784, 0, 0, 0, 0, +/* 0238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0240 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02b0 */ TBL(1)|72, TBL(2)|142, TBL(1)|74, TBL(1)|82, TBL(2)|156, TBL(2)|157, TBL(2)|158, TBL(1)|87, +/* 02b8 */ TBL(1)|89, 0, 0, 0, 0, 0, 0, 0, +/* 02c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02d8 */ TBL(3)|284, TBL(3)|285, TBL(3)|287, TBL(3)|292, TBL(3)|281, TBL(3)|288, 0, 0, +/* 02e0 */ TBL(2)|140, TBL(1)|76, TBL(1)|83, TBL(1)|88, TBL(2)|169, 0, 0, 0, +/* 02e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_03 [256] = { +/* 0300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0340 */ TBL(2)|173, TBL(2)|174, 0, TBL(2)|175, TBL(4)|53, 0, 0, 0, +/* 0348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0370 */ 0, 0, 0, 0, TBL(2)|172, 0, 0, 0, +/* 0378 */ 0, 0, TBL(3)|295, 0, 0, 0, TBL(1)|25, 0, +/* 0380 */ 0, 0, 0, 0, TBL(3)|280, TBL(5)|168, TBL(4)|55, TBL(2)|117, +/* 0388 */ TBL(4)|62, TBL(4)|66, TBL(4)|71, 0, TBL(4)|78, 0, TBL(4)|83, TBL(4)|89, +/* 0390 */ (uint16_t)-1 /*TBL(6)|70*/, 0, 0, 0, 0, 0, 0, 0, +/* 0398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03a8 */ 0, 0, TBL(4)|74, TBL(4)|86, TBL(4)|94, TBL(4)|102, TBL(4)|106, TBL(4)|112, +/* 03b0 */ (uint16_t)-1 /*TBL(6)|83*/, 0, 0, 0, 0, 0, 0, 0, +/* 03b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03c8 */ 0, 0, TBL(4)|115, TBL(4)|129, TBL(4)|120, TBL(4)|126, TBL(4)|134, 0, +/* 03d0 */ TBL(2)|201, TBL(2)|207, TBL(2)|195, TBL(4)|83, TBL(4)|86, TBL(2)|221, TBL(2)|215, 0, +/* 03d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 03f0 */ TBL(2)|209, TBL(2)|216, TBL(2)|217, 0, TBL(2)|183, TBL(2)|204, 0, 0, +/* 03f8 */ 0, TBL(2)|193, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_04 [256] = { +/* 0400 */ TBL(4)|143, TBL(4)|145, 0, TBL(4)|142, 0, 0, 0, TBL(4)|139, +/* 0408 */ 0, 0, 0, 0, TBL(4)|153, TBL(4)|149, TBL(4)|156, 0, +/* 0410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0418 */ 0, TBL(4)|151, 0, 0, 0, 0, 0, 0, +/* 0420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0438 */ 0, TBL(4)|173, 0, 0, 0, 0, 0, 0, +/* 0440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0450 */ TBL(4)|165, TBL(4)|167, 0, TBL(4)|164, 0, 0, 0, TBL(4)|184, +/* 0458 */ 0, 0, 0, 0, TBL(4)|175, TBL(4)|171, TBL(4)|178, 0, +/* 0460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0470 */ 0, 0, 0, 0, 0, 0, TBL(4)|185, TBL(4)|186, +/* 0478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0480 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04c0 */ 0, TBL(4)|146, TBL(4)|168, 0, 0, 0, 0, 0, +/* 04c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 04d0 */ TBL(4)|140, TBL(4)|162, TBL(4)|141, TBL(4)|163, 0, 0, TBL(4)|144, TBL(4)|166, +/* 04d8 */ 0, 0, TBL(4)|187, TBL(4)|188, TBL(4)|147, TBL(4)|169, TBL(4)|148, TBL(4)|170, +/* 04e0 */ 0, 0, TBL(4)|150, TBL(4)|172, TBL(4)|152, TBL(4)|174, TBL(4)|154, TBL(4)|176, +/* 04e8 */ 0, 0, TBL(4)|189, TBL(4)|190, TBL(4)|161, TBL(4)|183, TBL(4)|155, TBL(4)|177, +/* 04f0 */ TBL(4)|157, TBL(4)|179, TBL(4)|158, TBL(4)|180, TBL(4)|159, TBL(4)|181, 0, 0, +/* 04f8 */ TBL(4)|160, TBL(4)|182, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_05 [256] = { +/* 0500 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0508 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0510 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0518 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0520 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0528 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0530 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0538 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0540 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0548 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0550 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0558 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0560 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0568 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0570 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0578 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0580 */ 0, 0, 0, 0, 0, 0, 0, TBL(4)|191, +/* 0588 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0590 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0598 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 05f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_06 [256] = { +/* 0600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0610 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0618 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0620 */ 0, 0, TBL(4)|231, TBL(4)|232, TBL(4)|374, TBL(4)|233, TBL(4)|387, 0, +/* 0628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0638 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0648 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0650 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0658 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0668 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0670 */ 0, 0, 0, 0, 0, TBL(4)|234, TBL(4)|375, TBL(4)|390, +/* 0678 */ TBL(4)|388, 0, 0, 0, 0, 0, 0, 0, +/* 0680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0698 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06c0 */ TBL(4)|392, 0, TBL(4)|389, 0, 0, 0, 0, 0, +/* 06c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06d0 */ 0, 0, 0, TBL(4)|391, 0, 0, 0, 0, +/* 06d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 06f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_09 [256] = { +/* 0900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0928 */ 0, (uint16_t)-1 /*TBL(6)|230*/, 0, 0, 0, 0, 0, 0, +/* 0930 */ 0, (uint16_t)-1 /*TBL(6)|233*/, 0, 0, (uint16_t)-1 /*TBL(6)|234*/, 0, 0, 0, +/* 0938 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0958 */ (uint16_t)-1 /*TBL(6)|224*/, (uint16_t)-1 /*TBL(6)|225*/, (uint16_t)-1 /*TBL(6)|226*/, (uint16_t)-1 /*TBL(6)|227*/, (uint16_t)-1 /*TBL(6)|228*/, (uint16_t)-1 /*TBL(6)|229*/, (uint16_t)-1 /*TBL(6)|231*/, (uint16_t)-1 /*TBL(6)|232*/, +/* 0960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09c8 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|238*/, (uint16_t)-1 /*TBL(6)|239*/, 0, 0, 0, +/* 09d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09d8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|235*/, (uint16_t)-1 /*TBL(6)|236*/, 0, (uint16_t)-1 /*TBL(6)|237*/, +/* 09e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 09f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0a [256] = { +/* 0a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a30 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|244*/, 0, 0, (uint16_t)-1 /*TBL(6)|245*/, 0, +/* 0a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a58 */ 0, (uint16_t)-1 /*TBL(6)|240*/, (uint16_t)-1 /*TBL(6)|241*/, (uint16_t)-1 /*TBL(6)|242*/, 0, 0, (uint16_t)-1 /*TBL(6)|243*/, 0, +/* 0a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0b [256] = { +/* 0b00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b48 */ (uint16_t)-1 /*TBL(6)|249*/, 0, 0, (uint16_t)-1 /*TBL(6)|248*/, (uint16_t)-1 /*TBL(6)|250*/, 0, 0, 0, +/* 0b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b58 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|246*/, (uint16_t)-1 /*TBL(6)|247*/, 0, 0, +/* 0b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0b90 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|251*/, 0, 0, 0, +/* 0b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bc8 */ 0, 0, (uint16_t)-1 /*TBL(6)|252*/, (uint16_t)-1 /*TBL(6)|254*/, (uint16_t)-1 /*TBL(6)|253*/, 0, 0, 0, +/* 0bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0c [256] = { +/* 0c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c48 */ (uint16_t)-1 /*TBL(6)|255*/, 0, 0, 0, 0, 0, 0, 0, +/* 0c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cc0 */ (uint16_t)-1 /*TBL(6)|256*/, 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|258*/, +/* 0cc8 */ (uint16_t)-1 /*TBL(6)|259*/, 0, (uint16_t)-1 /*TBL(6)|257*/, (uint16_t)-1 /*TBL(9)|0*/, 0, 0, 0, 0, +/* 0cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0d [256] = { +/* 0d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d48 */ 0, 0, (uint16_t)-1 /*TBL(6)|260*/, (uint16_t)-1 /*TBL(6)|262*/, (uint16_t)-1 /*TBL(6)|261*/, 0, 0, 0, +/* 0d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0dd8 */ 0, 0, (uint16_t)-1 /*TBL(6)|263*/, 0, (uint16_t)-1 /*TBL(6)|264*/, (uint16_t)-1 /*TBL(9)|1*/, (uint16_t)-1 /*TBL(6)|265*/, 0, +/* 0de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0e [256] = { +/* 0e00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e30 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|266*/, 0, 0, 0, 0, +/* 0e38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0e98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ea0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ea8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0eb0 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|269*/, 0, 0, 0, 0, +/* 0eb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ec8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ed8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|267*/, (uint16_t)-1 /*TBL(6)|268*/, 0, 0, +/* 0ee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ef0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_0f [256] = { +/* 0f00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f08 */ 0, 0, 0, 0, TBL(3)|315, 0, 0, 0, +/* 0f10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f40 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|271*/, 0, 0, 0, 0, +/* 0f48 */ 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|272*/, 0, 0, +/* 0f50 */ 0, 0, (uint16_t)-1 /*TBL(6)|273*/, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|274*/, +/* 0f58 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|275*/, 0, 0, 0, +/* 0f60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f68 */ 0, (uint16_t)-1 /*TBL(6)|270*/, 0, 0, 0, 0, 0, 0, +/* 0f70 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|276*/, 0, (uint16_t)-1 /*TBL(6)|277*/, (uint16_t)-1 /*TBL(6)|285*/, (uint16_t)-1 /*TBL(9)|2*/, +/* 0f78 */ (uint16_t)-1 /*TBL(6)|286*/, (uint16_t)-1 /*TBL(9)|3*/, 0, 0, 0, 0, 0, 0, +/* 0f80 */ 0, (uint16_t)-1 /*TBL(6)|278*/, 0, 0, 0, 0, 0, 0, +/* 0f88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0f90 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|280*/, 0, 0, 0, 0, +/* 0f98 */ 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|281*/, 0, 0, +/* 0fa0 */ 0, 0, (uint16_t)-1 /*TBL(6)|282*/, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|283*/, +/* 0fa8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|284*/, 0, 0, 0, +/* 0fb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fb8 */ 0, (uint16_t)-1 /*TBL(6)|279*/, 0, 0, 0, 0, 0, 0, +/* 0fc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_10 [256] = { +/* 1000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1020 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|287*/, 0, +/* 1028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1098 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 10f8 */ 0, 0, 0, 0, TBL(3)|316, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_1b [256] = { +/* 1b00 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|303*/, 0, +/* 1b08 */ (uint16_t)-1 /*TBL(6)|304*/, 0, (uint16_t)-1 /*TBL(6)|305*/, 0, (uint16_t)-1 /*TBL(6)|306*/, 0, (uint16_t)-1 /*TBL(6)|307*/, 0, +/* 1b10 */ 0, 0, (uint16_t)-1 /*TBL(6)|308*/, 0, 0, 0, 0, 0, +/* 1b18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b38 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|309*/, 0, (uint16_t)-1 /*TBL(6)|310*/, 0, 0, +/* 1b40 */ (uint16_t)-1 /*TBL(6)|311*/, (uint16_t)-1 /*TBL(6)|312*/, 0, (uint16_t)-1 /*TBL(6)|313*/, 0, 0, 0, 0, +/* 1b48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1b98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1ba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1be0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1be8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1bf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_1d [256] = { +/* 1d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d28 */ 0, 0, 0, 0, TBL(1)|31, TBL(2)|118, TBL(1)|32, 0, +/* 1d30 */ TBL(1)|34, TBL(1)|35, TBL(2)|125, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, +/* 1d38 */ TBL(1)|42, TBL(1)|43, TBL(1)|44, 0, TBL(1)|45, TBL(2)|128, TBL(1)|46, TBL(1)|48, +/* 1d40 */ TBL(1)|50, TBL(1)|51, TBL(1)|53, TBL(1)|65, TBL(2)|130, TBL(2)|131, TBL(3)|411, TBL(1)|66, +/* 1d48 */ TBL(1)|68, TBL(1)|69, TBL(2)|135, TBL(2)|136, TBL(2)|137, TBL(1)|71, 0, TBL(1)|75, +/* 1d50 */ TBL(1)|77, TBL(2)|123, TBL(1)|79, TBL(2)|133, TBL(3)|412, TBL(3)|413, TBL(1)|80, TBL(1)|84, +/* 1d58 */ TBL(1)|85, TBL(3)|415, TBL(2)|148, TBL(1)|86, TBL(3)|416, TBL(2)|201, TBL(2)|202, TBL(2)|203, +/* 1d60 */ TBL(2)|221, TBL(2)|222, TBL(1)|73, TBL(1)|82, TBL(1)|85, TBL(1)|86, TBL(2)|201, TBL(2)|202, +/* 1d68 */ TBL(2)|216, TBL(2)|221, TBL(2)|222, 0, 0, 0, 0, 0, +/* 1d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d78 */ TBL(2)|227, 0, 0, 0, 0, 0, 0, 0, +/* 1d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1d98 */ 0, 0, 0, TBL(2)|132, TBL(1)|67, TBL(2)|134, TBL(2)|119, TBL(2)|137, +/* 1da0 */ TBL(1)|70, TBL(2)|138, TBL(2)|139, TBL(2)|141, TBL(2)|143, TBL(2)|144, TBL(2)|145, TBL(3)|417, +/* 1da8 */ TBL(2)|170, TBL(2)|147, TBL(3)|418, TBL(2)|171, TBL(2)|150, TBL(2)|149, TBL(2)|151, TBL(2)|152, +/* 1db0 */ TBL(2)|153, TBL(2)|154, TBL(2)|155, TBL(2)|159, TBL(2)|160, TBL(2)|127, TBL(2)|161, TBL(2)|162, +/* 1db8 */ TBL(3)|414, TBL(2)|163, TBL(2)|164, TBL(1)|90, TBL(2)|166, TBL(2)|167, TBL(2)|168, TBL(2)|207, +/* 1dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 1df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_1e [256] = { +/* 1e00 */ TBL(3)|92, TBL(3)|1593, TBL(3)|94, TBL(3)|1595, TBL(3)|95, TBL(3)|1596, TBL(3)|96, TBL(3)|1597, +/* 1e08 */ TBL(5)|122, TBL(5)|237, TBL(3)|103, TBL(3)|1609, TBL(3)|105, TBL(3)|1611, TBL(3)|108, TBL(3)|1614, +/* 1e10 */ TBL(3)|106, TBL(3)|1612, TBL(3)|107, TBL(3)|1613, TBL(5)|127, TBL(5)|242, TBL(5)|128, TBL(5)|243, +/* 1e18 */ TBL(3)|124, TBL(3)|1632, TBL(3)|125, TBL(3)|1633, TBL(5)|130, TBL(5)|245, TBL(3)|127, TBL(3)|1635, +/* 1e20 */ TBL(3)|132, TBL(3)|1640, TBL(3)|138, TBL(3)|1648, TBL(3)|141, TBL(3)|1651, TBL(3)|139, TBL(3)|1649, +/* 1e28 */ TBL(3)|142, TBL(3)|1652, TBL(3)|143, TBL(3)|1653, TBL(3)|159, TBL(3)|1668, TBL(5)|131, TBL(5)|246, +/* 1e30 */ TBL(3)|161, TBL(3)|1674, TBL(3)|163, TBL(3)|1676, TBL(3)|165, TBL(3)|1678, TBL(3)|170, TBL(3)|1685, +/* 1e38 */ TBL(5)|132, TBL(5)|247, TBL(3)|173, TBL(3)|1688, TBL(3)|172, TBL(3)|1687, TBL(3)|176, TBL(3)|1690, +/* 1e40 */ TBL(3)|177, TBL(3)|1691, TBL(3)|178, TBL(3)|1692, TBL(3)|183, TBL(3)|1700, TBL(3)|185, TBL(3)|1702, +/* 1e48 */ TBL(3)|188, TBL(3)|1705, TBL(3)|187, TBL(3)|1704, TBL(5)|137, TBL(5)|253, TBL(5)|139, TBL(5)|255, +/* 1e50 */ TBL(5)|140, TBL(5)|256, TBL(5)|141, TBL(5)|257, TBL(3)|208, TBL(3)|1722, TBL(3)|209, TBL(3)|1723, +/* 1e58 */ TBL(3)|211, TBL(3)|1725, TBL(3)|215, TBL(3)|1729, TBL(5)|151, TBL(5)|267, TBL(3)|217, TBL(3)|1731, +/* 1e60 */ TBL(3)|220, TBL(3)|1735, TBL(3)|222, TBL(3)|1737, TBL(5)|152, TBL(5)|268, TBL(5)|153, TBL(5)|269, +/* 1e68 */ TBL(5)|154, TBL(5)|270, TBL(3)|227, TBL(3)|1740, TBL(3)|229, TBL(3)|1743, TBL(3)|233, TBL(3)|1747, +/* 1e70 */ TBL(3)|232, TBL(3)|1746, TBL(3)|249, TBL(3)|1763, TBL(3)|252, TBL(3)|1766, TBL(3)|251, TBL(3)|1765, +/* 1e78 */ TBL(5)|155, TBL(5)|271, TBL(5)|156, TBL(5)|272, TBL(3)|254, TBL(3)|1767, TBL(3)|255, TBL(3)|1768, +/* 1e80 */ TBL(3)|256, TBL(3)|1770, TBL(3)|257, TBL(3)|1771, TBL(3)|260, TBL(3)|1774, TBL(3)|259, TBL(3)|1773, +/* 1e88 */ TBL(3)|261, TBL(3)|1776, TBL(3)|263, TBL(3)|1777, TBL(3)|264, TBL(3)|1778, TBL(3)|270, TBL(3)|1785, +/* 1e90 */ TBL(3)|275, TBL(3)|1791, TBL(3)|278, TBL(3)|1794, TBL(3)|279, TBL(3)|1795, TBL(3)|1654, TBL(3)|1741, +/* 1e98 */ TBL(3)|1775, TBL(3)|1788, TBL(3)|1578, TBL(3)|1735, 0, 0, 0, 0, +/* 1ea0 */ TBL(3)|91, TBL(3)|1592, TBL(3)|86, TBL(3)|1587, TBL(5)|109, TBL(5)|225, TBL(5)|108, TBL(5)|224, +/* 1ea8 */ TBL(5)|111, TBL(5)|227, TBL(5)|110, TBL(5)|226, TBL(5)|119, TBL(5)|235, TBL(5)|113, TBL(5)|229, +/* 1eb0 */ TBL(5)|112, TBL(5)|228, TBL(5)|115, TBL(5)|231, TBL(5)|114, TBL(5)|230, TBL(5)|120, TBL(5)|236, +/* 1eb8 */ TBL(3)|121, TBL(3)|1629, TBL(3)|117, TBL(3)|1625, TBL(3)|112, TBL(3)|1620, TBL(5)|124, TBL(5)|239, +/* 1ec0 */ TBL(5)|123, TBL(5)|238, TBL(5)|126, TBL(5)|241, TBL(5)|125, TBL(5)|240, TBL(5)|129, TBL(5)|244, +/* 1ec8 */ TBL(3)|153, TBL(3)|1662, TBL(3)|157, TBL(3)|1666, TBL(3)|203, TBL(3)|1720, TBL(3)|197, TBL(3)|1714, +/* 1ed0 */ TBL(5)|134, TBL(5)|250, TBL(5)|133, TBL(5)|249, TBL(5)|136, TBL(5)|252, TBL(5)|135, TBL(5)|251, +/* 1ed8 */ TBL(5)|149, TBL(5)|265, TBL(5)|145, TBL(5)|261, TBL(5)|144, TBL(5)|260, TBL(5)|147, TBL(5)|263, +/* 1ee0 */ TBL(5)|146, TBL(5)|262, TBL(5)|148, TBL(5)|264, TBL(3)|248, TBL(3)|1762, TBL(3)|241, TBL(3)|1755, +/* 1ee8 */ TBL(5)|162, TBL(5)|278, TBL(5)|161, TBL(5)|277, TBL(5)|164, TBL(5)|280, TBL(5)|163, TBL(5)|279, +/* 1ef0 */ TBL(5)|165, TBL(5)|281, TBL(3)|265, TBL(3)|1780, TBL(3)|273, TBL(3)|1789, TBL(3)|272, TBL(3)|1787, +/* 1ef8 */ TBL(3)|268, TBL(3)|1783, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_1f [256] = { +/* 1f00 */ TBL(4)|97, TBL(4)|98, (uint16_t)-1 /*TBL(6)|45*/, (uint16_t)-1 /*TBL(6)|49*/, (uint16_t)-1 /*TBL(6)|46*/, (uint16_t)-1 /*TBL(6)|50*/, (uint16_t)-1 /*TBL(6)|47*/, (uint16_t)-1 /*TBL(6)|51*/, +/* 1f08 */ TBL(4)|58, TBL(4)|59, (uint16_t)-1 /*TBL(6)|2*/, (uint16_t)-1 /*TBL(6)|6*/, (uint16_t)-1 /*TBL(6)|3*/, (uint16_t)-1 /*TBL(6)|7*/, (uint16_t)-1 /*TBL(6)|4*/, (uint16_t)-1 /*TBL(6)|8*/, +/* 1f10 */ TBL(4)|103, TBL(4)|104, (uint16_t)-1 /*TBL(6)|54*/, (uint16_t)-1 /*TBL(6)|56*/, (uint16_t)-1 /*TBL(6)|55*/, (uint16_t)-1 /*TBL(6)|57*/, 0, 0, +/* 1f18 */ TBL(4)|63, TBL(4)|64, (uint16_t)-1 /*TBL(6)|10*/, (uint16_t)-1 /*TBL(6)|12*/, (uint16_t)-1 /*TBL(6)|11*/, (uint16_t)-1 /*TBL(6)|13*/, 0, 0, +/* 1f20 */ TBL(4)|107, TBL(4)|108, (uint16_t)-1 /*TBL(6)|60*/, (uint16_t)-1 /*TBL(6)|64*/, (uint16_t)-1 /*TBL(6)|61*/, (uint16_t)-1 /*TBL(6)|65*/, (uint16_t)-1 /*TBL(6)|62*/, (uint16_t)-1 /*TBL(6)|66*/, +/* 1f28 */ TBL(4)|67, TBL(4)|68, (uint16_t)-1 /*TBL(6)|14*/, (uint16_t)-1 /*TBL(6)|18*/, (uint16_t)-1 /*TBL(6)|15*/, (uint16_t)-1 /*TBL(6)|19*/, (uint16_t)-1 /*TBL(6)|16*/, (uint16_t)-1 /*TBL(6)|20*/, +/* 1f30 */ TBL(4)|116, TBL(4)|117, (uint16_t)-1 /*TBL(6)|72*/, (uint16_t)-1 /*TBL(6)|75*/, (uint16_t)-1 /*TBL(6)|73*/, (uint16_t)-1 /*TBL(6)|76*/, (uint16_t)-1 /*TBL(6)|74*/, (uint16_t)-1 /*TBL(6)|77*/, +/* 1f38 */ TBL(4)|75, TBL(4)|76, (uint16_t)-1 /*TBL(6)|22*/, (uint16_t)-1 /*TBL(6)|25*/, (uint16_t)-1 /*TBL(6)|23*/, (uint16_t)-1 /*TBL(6)|26*/, (uint16_t)-1 /*TBL(6)|24*/, (uint16_t)-1 /*TBL(6)|27*/, +/* 1f40 */ TBL(4)|121, TBL(4)|122, (uint16_t)-1 /*TBL(6)|78*/, (uint16_t)-1 /*TBL(6)|80*/, (uint16_t)-1 /*TBL(6)|79*/, (uint16_t)-1 /*TBL(6)|81*/, 0, 0, +/* 1f48 */ TBL(4)|79, TBL(4)|80, (uint16_t)-1 /*TBL(6)|28*/, (uint16_t)-1 /*TBL(6)|30*/, (uint16_t)-1 /*TBL(6)|29*/, (uint16_t)-1 /*TBL(6)|31*/, 0, 0, +/* 1f50 */ TBL(4)|130, TBL(4)|131, (uint16_t)-1 /*TBL(6)|85*/, (uint16_t)-1 /*TBL(6)|88*/, (uint16_t)-1 /*TBL(6)|86*/, (uint16_t)-1 /*TBL(6)|89*/, (uint16_t)-1 /*TBL(6)|87*/, (uint16_t)-1 /*TBL(6)|90*/, +/* 1f58 */ 0, TBL(4)|87, 0, (uint16_t)-1 /*TBL(6)|32*/, 0, (uint16_t)-1 /*TBL(6)|33*/, 0, (uint16_t)-1 /*TBL(6)|34*/, +/* 1f60 */ TBL(4)|135, TBL(4)|136, (uint16_t)-1 /*TBL(6)|93*/, (uint16_t)-1 /*TBL(6)|97*/, (uint16_t)-1 /*TBL(6)|94*/, (uint16_t)-1 /*TBL(6)|98*/, (uint16_t)-1 /*TBL(6)|95*/, (uint16_t)-1 /*TBL(6)|99*/, +/* 1f68 */ TBL(4)|90, TBL(4)|91, (uint16_t)-1 /*TBL(6)|35*/, (uint16_t)-1 /*TBL(6)|39*/, (uint16_t)-1 /*TBL(6)|36*/, (uint16_t)-1 /*TBL(6)|40*/, (uint16_t)-1 /*TBL(6)|37*/, (uint16_t)-1 /*TBL(6)|41*/, +/* 1f70 */ TBL(4)|93, TBL(4)|94, TBL(4)|101, TBL(4)|102, TBL(4)|105, TBL(4)|106, TBL(4)|111, TBL(4)|112, +/* 1f78 */ TBL(4)|119, TBL(4)|120, TBL(4)|125, TBL(4)|126, TBL(4)|133, TBL(4)|134, 0, 0, +/* 1f80 */ (uint16_t)-1 /*TBL(6)|48*/, (uint16_t)-1 /*TBL(6)|52*/, (uint16_t)-1 /*TBL(8)|33*/, (uint16_t)-1 /*TBL(8)|36*/, (uint16_t)-1 /*TBL(8)|34*/, (uint16_t)-1 /*TBL(8)|37*/, (uint16_t)-1 /*TBL(8)|35*/, (uint16_t)-1 /*TBL(8)|38*/, +/* 1f88 */ (uint16_t)-1 /*TBL(6)|5*/, (uint16_t)-1 /*TBL(6)|9*/, (uint16_t)-1 /*TBL(8)|15*/, (uint16_t)-1 /*TBL(8)|18*/, (uint16_t)-1 /*TBL(8)|16*/, (uint16_t)-1 /*TBL(8)|19*/, (uint16_t)-1 /*TBL(8)|17*/, (uint16_t)-1 /*TBL(8)|20*/, +/* 1f90 */ (uint16_t)-1 /*TBL(6)|63*/, (uint16_t)-1 /*TBL(6)|67*/, (uint16_t)-1 /*TBL(8)|39*/, (uint16_t)-1 /*TBL(8)|42*/, (uint16_t)-1 /*TBL(8)|40*/, (uint16_t)-1 /*TBL(8)|43*/, (uint16_t)-1 /*TBL(8)|41*/, (uint16_t)-1 /*TBL(8)|44*/, +/* 1f98 */ (uint16_t)-1 /*TBL(6)|17*/, (uint16_t)-1 /*TBL(6)|21*/, (uint16_t)-1 /*TBL(8)|21*/, (uint16_t)-1 /*TBL(8)|24*/, (uint16_t)-1 /*TBL(8)|22*/, (uint16_t)-1 /*TBL(8)|25*/, (uint16_t)-1 /*TBL(8)|23*/, (uint16_t)-1 /*TBL(8)|26*/, +/* 1fa0 */ (uint16_t)-1 /*TBL(6)|96*/, (uint16_t)-1 /*TBL(6)|100*/, (uint16_t)-1 /*TBL(8)|45*/, (uint16_t)-1 /*TBL(8)|48*/, (uint16_t)-1 /*TBL(8)|46*/, (uint16_t)-1 /*TBL(8)|49*/, (uint16_t)-1 /*TBL(8)|47*/, (uint16_t)-1 /*TBL(8)|50*/, +/* 1fa8 */ (uint16_t)-1 /*TBL(6)|38*/, (uint16_t)-1 /*TBL(6)|42*/, (uint16_t)-1 /*TBL(8)|27*/, (uint16_t)-1 /*TBL(8)|30*/, (uint16_t)-1 /*TBL(8)|28*/, (uint16_t)-1 /*TBL(8)|31*/, (uint16_t)-1 /*TBL(8)|29*/, (uint16_t)-1 /*TBL(8)|32*/, +/* 1fb0 */ TBL(4)|96, TBL(4)|95, (uint16_t)-1 /*TBL(6)|43*/, TBL(4)|100, (uint16_t)-1 /*TBL(6)|44*/, 0, TBL(4)|99, (uint16_t)-1 /*TBL(6)|53*/, +/* 1fb8 */ TBL(4)|57, TBL(4)|56, TBL(4)|54, TBL(4)|55, TBL(4)|60, TBL(3)|289, TBL(2)|208, TBL(3)|289, +/* 1fc0 */ TBL(3)|294, TBL(5)|169, (uint16_t)-1 /*TBL(6)|58*/, TBL(4)|110, (uint16_t)-1 /*TBL(6)|59*/, 0, TBL(4)|109, (uint16_t)-1 /*TBL(6)|68*/, +/* 1fc8 */ TBL(4)|61, TBL(4)|62, TBL(4)|65, TBL(4)|66, TBL(4)|69, TBL(5)|170, TBL(5)|171, TBL(5)|172, +/* 1fd0 */ TBL(4)|114, TBL(4)|113, (uint16_t)-1 /*TBL(6)|69*/, (uint16_t)-1 /*TBL(6)|70*/, 0, 0, TBL(4)|118, (uint16_t)-1 /*TBL(6)|71*/, +/* 1fd8 */ TBL(4)|73, TBL(4)|72, TBL(4)|70, TBL(4)|71, 0, TBL(5)|173, TBL(5)|174, TBL(5)|175, +/* 1fe0 */ TBL(4)|128, TBL(4)|127, (uint16_t)-1 /*TBL(6)|82*/, (uint16_t)-1 /*TBL(6)|83*/, TBL(4)|123, TBL(4)|124, TBL(4)|132, (uint16_t)-1 /*TBL(6)|84*/, +/* 1fe8 */ TBL(4)|85, TBL(4)|84, TBL(4)|82, TBL(4)|83, TBL(4)|81, TBL(5)|167, TBL(5)|168, TBL(1)|64, +/* 1ff0 */ 0, 0, (uint16_t)-1 /*TBL(6)|91*/, TBL(4)|138, (uint16_t)-1 /*TBL(6)|92*/, 0, TBL(4)|137, (uint16_t)-1 /*TBL(6)|101*/, +/* 1ff8 */ TBL(4)|77, TBL(4)|78, TBL(4)|88, TBL(4)|89, TBL(4)|92, TBL(3)|280, TBL(3)|290, 0 +}; + +static const uint16_t UN8IF_compat_00_20 [256] = { +/* 2000 */ TBL(1)|58, TBL(1)|58, TBL(1)|58, TBL(1)|58, TBL(1)|58, TBL(1)|58, TBL(1)|58, TBL(1)|58, +/* 2008 */ TBL(1)|58, TBL(1)|58, TBL(1)|58, 0, 0, 0, 0, 0, +/* 2010 */ 0, TBL(3)|419, 0, 0, 0, 0, 0, TBL(3)|293, +/* 2018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2020 */ 0, 0, 0, 0, TBL(1)|12, TBL(2)|2, TBL(3)|61, 0, +/* 2028 */ 0, 0, 0, 0, 0, 0, 0, TBL(1)|58, +/* 2030 */ 0, 0, 0, (uint16_t)-1 /*TBL(6)|314*/, (uint16_t)-1 /*TBL(9)|4*/, 0, (uint16_t)-1 /*TBL(6)|315*/, (uint16_t)-1 /*TBL(9)|5*/, +/* 2038 */ 0, 0, 0, 0, TBL(2)|0, 0, TBL(3)|283, 0, +/* 2040 */ 0, 0, 0, 0, 0, 0, 0, TBL(2)|66, +/* 2048 */ TBL(2)|65, TBL(2)|1, 0, 0, 0, 0, 0, 0, +/* 2050 */ 0, 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(12)|1*/, +/* 2058 */ 0, 0, 0, 0, 0, 0, 0, TBL(1)|58, +/* 2060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2070 */ TBL(1)|14, TBL(1)|73, 0, 0, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, +/* 2078 */ TBL(1)|22, TBL(1)|23, TBL(1)|9, TBL(3)|430, TBL(1)|27, TBL(1)|6, TBL(1)|7, TBL(1)|78, +/* 2080 */ TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, +/* 2088 */ TBL(1)|22, TBL(1)|23, TBL(1)|9, TBL(3)|430, TBL(1)|27, TBL(1)|6, TBL(1)|7, 0, +/* 2090 */ TBL(1)|65, TBL(1)|69, TBL(1)|79, TBL(1)|88, TBL(2)|135, TBL(1)|72, TBL(1)|75, TBL(1)|76, +/* 2098 */ TBL(1)|77, TBL(1)|78, TBL(1)|80, TBL(1)|83, TBL(1)|84, 0, 0, 0, +/* 20a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20a8 */ TBL(2)|101, 0, 0, 0, 0, 0, 0, 0, +/* 20b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 20f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_21 [256] = { +/* 2100 */ TBL(3)|1576, TBL(3)|1577, TBL(1)|33, TBL(3)|304, 0, TBL(3)|1599, TBL(3)|1600, TBL(2)|126, +/* 2108 */ 0, TBL(3)|305, TBL(1)|71, TBL(1)|38, TBL(1)|38, TBL(1)|38, TBL(1)|72, TBL(2)|121, +/* 2110 */ TBL(1)|39, TBL(1)|39, TBL(1)|42, TBL(1)|76, 0, TBL(1)|44, TBL(2)|97, 0, +/* 2118 */ 0, TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|48, TBL(1)|48, 0, 0, +/* 2120 */ TBL(2)|103, TBL(3)|225, TBL(2)|106, 0, TBL(1)|56, 0, TBL(2)|199, 0, +/* 2128 */ TBL(1)|56, 0, TBL(1)|41, TBL(3)|87, TBL(1)|32, TBL(1)|33, 0, TBL(1)|69, +/* 2130 */ TBL(1)|35, TBL(1)|36, 0, TBL(1)|43, TBL(1)|79, TBL(2)|230, TBL(2)|231, TBL(2)|232, +/* 2138 */ TBL(2)|233, TBL(1)|73, 0, TBL(3)|126, TBL(2)|215, TBL(2)|202, TBL(2)|178, TBL(2)|191, +/* 2140 */ TBL(3)|429, 0, 0, 0, 0, TBL(1)|34, TBL(1)|68, TBL(1)|69, +/* 2148 */ TBL(1)|73, TBL(1)|74, 0, 0, 0, 0, 0, 0, +/* 2150 */ TBL(5)|79, TBL(5)|81, (uint16_t)-1 /*TBL(6)|0*/, TBL(5)|75, TBL(5)|97, TBL(5)|77, TBL(5)|98, TBL(5)|102, +/* 2158 */ TBL(5)|104, TBL(5)|78, TBL(5)|105, TBL(5)|80, TBL(5)|103, TBL(5)|106, TBL(5)|107, TBL(4)|12, +/* 2160 */ TBL(1)|39, TBL(2)|79, TBL(3)|144, TBL(2)|82, TBL(1)|52, TBL(2)|107, TBL(3)|253, TBL(4)|42, +/* 2168 */ TBL(2)|83, TBL(1)|54, TBL(2)|111, TBL(3)|262, TBL(1)|42, TBL(1)|33, TBL(1)|34, TBL(1)|43, +/* 2170 */ TBL(1)|73, TBL(2)|326, TBL(3)|1669, TBL(2)|329, TBL(1)|86, TBL(2)|368, TBL(3)|1769, TBL(4)|507, +/* 2178 */ TBL(2)|330, TBL(1)|88, TBL(2)|369, TBL(3)|1779, TBL(1)|76, TBL(1)|67, TBL(1)|68, TBL(1)|77, +/* 2180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2188 */ 0, TBL(5)|50, 0, 0, 0, 0, 0, 0, +/* 2190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2198 */ 0, 0, TBL(5)|182, TBL(5)|183, 0, 0, 0, 0, +/* 21a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21a8 */ 0, 0, 0, 0, 0, 0, TBL(5)|184, 0, +/* 21b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21c8 */ 0, 0, 0, 0, 0, TBL(5)|185, TBL(5)|187, TBL(5)|186, +/* 21d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 21f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_22 [256] = { +/* 2200 */ 0, 0, 0, 0, TBL(5)|188, 0, 0, 0, +/* 2208 */ 0, TBL(5)|189, 0, 0, TBL(5)|190, 0, 0, 0, +/* 2210 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2218 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2220 */ 0, 0, 0, 0, TBL(5)|191, 0, TBL(5)|192, 0, +/* 2228 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|316*/, (uint16_t)-1 /*TBL(9)|6*/, 0, (uint16_t)-1 /*TBL(6)|317*/, +/* 2230 */ (uint16_t)-1 /*TBL(9)|7*/, 0, 0, 0, 0, 0, 0, 0, +/* 2238 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2240 */ 0, TBL(5)|193, 0, 0, TBL(5)|194, 0, 0, TBL(5)|195, +/* 2248 */ 0, TBL(5)|196, 0, 0, 0, 0, 0, 0, +/* 2250 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2260 */ TBL(3)|76, 0, TBL(5)|198, 0, 0, 0, 0, 0, +/* 2268 */ 0, 0, 0, 0, 0, TBL(5)|197, TBL(3)|74, TBL(3)|77, +/* 2270 */ TBL(5)|199, TBL(5)|200, 0, 0, TBL(5)|201, TBL(5)|202, 0, 0, +/* 2278 */ TBL(5)|203, TBL(5)|204, 0, 0, 0, 0, 0, 0, +/* 2280 */ TBL(5)|205, TBL(5)|206, 0, 0, TBL(5)|209, TBL(5)|210, 0, 0, +/* 2288 */ TBL(5)|211, TBL(5)|212, 0, 0, 0, 0, 0, 0, +/* 2290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22a8 */ 0, 0, 0, 0, TBL(5)|215, TBL(5)|216, TBL(5)|217, TBL(5)|218, +/* 22b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22e0 */ TBL(5)|207, TBL(5)|208, TBL(5)|213, TBL(5)|214, 0, 0, 0, 0, +/* 22e8 */ 0, 0, TBL(5)|219, TBL(5)|220, TBL(5)|221, TBL(5)|222, 0, 0, +/* 22f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 22f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_23 [256] = { +/* 2300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2328 */ 0, TBL(3)|439, TBL(3)|440, 0, 0, 0, 0, 0, +/* 2330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2348 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 23f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_24 [256] = { +/* 2400 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2408 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2418 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2438 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2450 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2458 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2460 */ TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, TBL(1)|22, +/* 2468 */ TBL(1)|23, TBL(2)|7, TBL(2)|8, TBL(2)|9, TBL(2)|10, TBL(2)|11, TBL(2)|12, TBL(2)|13, +/* 2470 */ TBL(2)|14, TBL(2)|15, TBL(2)|16, TBL(2)|19, TBL(3)|0, TBL(3)|1, TBL(3)|2, TBL(3)|3, +/* 2478 */ TBL(3)|4, TBL(3)|5, TBL(3)|6, TBL(3)|7, TBL(3)|8, TBL(4)|0, TBL(4)|1, TBL(4)|2, +/* 2480 */ TBL(4)|3, TBL(4)|4, TBL(4)|5, TBL(4)|6, TBL(4)|7, TBL(4)|8, TBL(4)|9, TBL(4)|10, +/* 2488 */ TBL(2)|6, TBL(2)|18, TBL(2)|30, TBL(2)|42, TBL(2)|54, TBL(2)|57, TBL(2)|59, TBL(2)|61, +/* 2490 */ TBL(2)|63, TBL(3)|62, TBL(3)|63, TBL(3)|64, TBL(3)|65, TBL(3)|66, TBL(3)|67, TBL(3)|68, +/* 2498 */ TBL(3)|69, TBL(3)|70, TBL(3)|71, TBL(3)|72, TBL(3)|35, TBL(3)|36, TBL(3)|37, TBL(3)|38, +/* 24a0 */ TBL(3)|39, TBL(3)|40, TBL(3)|41, TBL(3)|42, TBL(3)|43, TBL(3)|44, TBL(3)|45, TBL(3)|46, +/* 24a8 */ TBL(3)|47, TBL(3)|48, TBL(3)|49, TBL(3)|50, TBL(3)|51, TBL(3)|52, TBL(3)|53, TBL(3)|54, +/* 24b0 */ TBL(3)|55, TBL(3)|56, TBL(3)|57, TBL(3)|58, TBL(3)|59, TBL(3)|60, TBL(1)|31, TBL(1)|32, +/* 24b8 */ TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, +/* 24c0 */ TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, TBL(1)|48, +/* 24c8 */ TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, +/* 24d0 */ TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, TBL(1)|72, +/* 24d8 */ TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, +/* 24e0 */ TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, +/* 24e8 */ TBL(1)|89, TBL(1)|90, TBL(1)|14, 0, 0, 0, 0, 0, +/* 24f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 24f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_2a [256] = { +/* 2a00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a08 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(12)|2*/, 0, 0, 0, +/* 2a10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a70 */ 0, 0, 0, 0, TBL(3)|73, TBL(2)|64, TBL(3)|75, 0, +/* 2a78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2a98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2aa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2aa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ad8 */ 0, 0, 0, 0, TBL(5)|223, 0, 0, 0, +/* 2ae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2af0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2af8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_2c [256] = { +/* 2c00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c78 */ 0, 0, 0, 0, TBL(1)|74, TBL(1)|52, 0, 0, +/* 2c80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2c98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ca0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ca8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ce0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ce8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2cf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_2d [256] = { +/* 2d00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d68 */ 0, 0, 0, 0, 0, 0, 0, TBL(3)|436, +/* 2d70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2d98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2da0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2da8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2db0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2db8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2dd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2de0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2de8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2df0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2df8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_2e [256] = { +/* 2e00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2e98 */ 0, 0, 0, 0, 0, 0, 0, TBL(3)|1031, +/* 2ea0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ea8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2eb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2eb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ec8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ed8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ef0 */ 0, 0, 0, TBL(3)|1570, 0, 0, 0, 0, +/* 2ef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_2f [256] = { +/* 2f00 */ TBL(3)|582, TBL(3)|591, TBL(3)|594, TBL(3)|598, TBL(3)|600, TBL(3)|603, TBL(3)|605, TBL(3)|607, +/* 2f08 */ TBL(3)|610, TBL(3)|631, TBL(3)|637, TBL(3)|641, TBL(3)|645, TBL(3)|649, TBL(3)|653, TBL(3)|661, +/* 2f10 */ TBL(3)|662, TBL(3)|663, TBL(3)|676, TBL(3)|686, TBL(3)|690, TBL(3)|692, TBL(3)|693, TBL(3)|696, +/* 2f18 */ TBL(3)|703, TBL(3)|704, TBL(3)|710, TBL(3)|711, TBL(3)|713, TBL(3)|717, TBL(3)|756, TBL(3)|761, +/* 2f20 */ TBL(3)|777, TBL(3)|782, TBL(3)|784, TBL(3)|785, TBL(3)|789, TBL(3)|796, TBL(3)|807, TBL(3)|810, +/* 2f28 */ TBL(3)|818, TBL(3)|821, TBL(3)|822, TBL(3)|823, TBL(3)|829, TBL(3)|830, TBL(3)|841, TBL(3)|844, +/* 2f30 */ TBL(3)|846, TBL(3)|848, TBL(3)|852, TBL(3)|854, TBL(3)|856, TBL(3)|867, TBL(3)|868, TBL(3)|870, +/* 2f38 */ TBL(3)|871, TBL(3)|873, TBL(3)|875, TBL(3)|879, TBL(3)|886, TBL(3)|916, TBL(3)|921, TBL(3)|922, +/* 2f40 */ TBL(3)|954, TBL(3)|955, TBL(3)|960, TBL(3)|961, TBL(3)|963, TBL(3)|965, TBL(3)|967, TBL(3)|970, +/* 2f48 */ TBL(3)|980, TBL(3)|984, TBL(3)|989, TBL(3)|1017, TBL(3)|1020, TBL(3)|1024, TBL(3)|1027, TBL(3)|1030, +/* 2f50 */ TBL(3)|1032, TBL(3)|1033, TBL(3)|1034, TBL(3)|1035, TBL(3)|1036, TBL(3)|1082, TBL(3)|1100, TBL(3)|1103, +/* 2f58 */ TBL(3)|1104, TBL(3)|1105, TBL(3)|1106, TBL(3)|1108, TBL(3)|1109, TBL(3)|1114, TBL(3)|1121, TBL(3)|1123, +/* 2f60 */ TBL(3)|1139, TBL(3)|1140, TBL(3)|1142, TBL(3)|1143, TBL(3)|1145, TBL(3)|1146, TBL(3)|1155, TBL(3)|1156, +/* 2f68 */ TBL(3)|1163, TBL(3)|1164, TBL(3)|1165, TBL(3)|1166, TBL(3)|1171, TBL(3)|1180, TBL(3)|1181, TBL(3)|1182, +/* 2f70 */ TBL(3)|1191, TBL(3)|1207, TBL(3)|1208, TBL(3)|1216, TBL(3)|1220, TBL(3)|1222, TBL(3)|1230, TBL(3)|1239, +/* 2f78 */ TBL(3)|1256, TBL(3)|1258, TBL(3)|1263, TBL(3)|1266, TBL(3)|1268, TBL(3)|1270, TBL(3)|1271, TBL(3)|1272, +/* 2f80 */ TBL(3)|1278, TBL(3)|1279, TBL(3)|1286, TBL(3)|1288, TBL(3)|1290, TBL(3)|1291, TBL(3)|1294, TBL(3)|1296, +/* 2f88 */ TBL(3)|1297, TBL(3)|1298, TBL(3)|1300, TBL(3)|1301, TBL(3)|1341, TBL(3)|1346, TBL(3)|1359, TBL(3)|1360, +/* 2f90 */ TBL(3)|1362, TBL(3)|1373, TBL(3)|1375, TBL(3)|1377, TBL(3)|1379, TBL(3)|1394, TBL(3)|1395, TBL(3)|1397, +/* 2f98 */ TBL(3)|1398, TBL(3)|1399, TBL(3)|1410, TBL(3)|1411, TBL(3)|1413, TBL(3)|1418, TBL(3)|1419, TBL(3)|1426, +/* 2fa0 */ TBL(3)|1428, TBL(3)|1429, TBL(3)|1438, TBL(3)|1446, TBL(3)|1451, TBL(3)|1452, TBL(3)|1454, TBL(3)|1465, +/* 2fa8 */ TBL(3)|1466, TBL(3)|1470, TBL(3)|1479, TBL(3)|1482, TBL(3)|1486, TBL(3)|1492, TBL(3)|1494, TBL(3)|1495, +/* 2fb0 */ TBL(3)|1496, TBL(3)|1497, TBL(3)|1500, TBL(3)|1501, TBL(3)|1503, TBL(3)|1510, TBL(3)|1511, TBL(3)|1512, +/* 2fb8 */ TBL(3)|1518, TBL(3)|1519, TBL(3)|1521, TBL(3)|1526, TBL(3)|1527, TBL(3)|1528, TBL(3)|1530, TBL(3)|1531, +/* 2fc0 */ TBL(3)|1532, TBL(3)|1533, TBL(3)|1534, TBL(3)|1538, TBL(3)|1544, TBL(3)|1545, TBL(3)|1548, TBL(3)|1549, +/* 2fc8 */ TBL(3)|1550, TBL(3)|1551, TBL(3)|1553, TBL(3)|1554, TBL(3)|1555, TBL(3)|1558, TBL(3)|1560, TBL(3)|1562, +/* 2fd0 */ TBL(3)|1563, TBL(3)|1565, TBL(3)|1566, TBL(3)|1567, TBL(3)|1569, TBL(3)|1571, 0, 0, +/* 2fd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2fe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2fe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 2ff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_30 [256] = { +/* 3000 */ TBL(1)|58, 0, 0, 0, 0, 0, 0, 0, +/* 3008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3030 */ 0, 0, 0, 0, 0, 0, TBL(3)|449, 0, +/* 3038 */ TBL(3)|696, TBL(3)|697, TBL(3)|698, 0, 0, 0, 0, 0, +/* 3040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3048 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|319*/, 0, (uint16_t)-1 /*TBL(6)|320*/, 0, +/* 3050 */ (uint16_t)-1 /*TBL(6)|321*/, 0, (uint16_t)-1 /*TBL(6)|322*/, 0, (uint16_t)-1 /*TBL(6)|323*/, 0, (uint16_t)-1 /*TBL(6)|324*/, 0, +/* 3058 */ (uint16_t)-1 /*TBL(6)|325*/, 0, (uint16_t)-1 /*TBL(6)|326*/, 0, (uint16_t)-1 /*TBL(6)|327*/, 0, (uint16_t)-1 /*TBL(6)|328*/, 0, +/* 3060 */ (uint16_t)-1 /*TBL(6)|329*/, 0, (uint16_t)-1 /*TBL(6)|330*/, 0, 0, (uint16_t)-1 /*TBL(6)|331*/, 0, (uint16_t)-1 /*TBL(6)|332*/, +/* 3068 */ 0, (uint16_t)-1 /*TBL(6)|333*/, 0, 0, 0, 0, 0, 0, +/* 3070 */ (uint16_t)-1 /*TBL(6)|334*/, (uint16_t)-1 /*TBL(6)|335*/, 0, (uint16_t)-1 /*TBL(6)|336*/, (uint16_t)-1 /*TBL(6)|337*/, 0, (uint16_t)-1 /*TBL(6)|338*/, (uint16_t)-1 /*TBL(6)|339*/, +/* 3078 */ 0, (uint16_t)-1 /*TBL(6)|340*/, (uint16_t)-1 /*TBL(6)|341*/, 0, (uint16_t)-1 /*TBL(6)|343*/, (uint16_t)-1 /*TBL(6)|344*/, 0, 0, +/* 3080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3090 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|318*/, 0, 0, 0, +/* 3098 */ 0, 0, 0, TBL(4)|43, TBL(4)|44, 0, (uint16_t)-1 /*TBL(6)|346*/, (uint16_t)-1 /*TBL(6)|345*/, +/* 30a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30a8 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|348*/, 0, (uint16_t)-1 /*TBL(6)|349*/, 0, +/* 30b0 */ (uint16_t)-1 /*TBL(6)|351*/, 0, (uint16_t)-1 /*TBL(6)|352*/, 0, (uint16_t)-1 /*TBL(6)|353*/, 0, (uint16_t)-1 /*TBL(6)|356*/, 0, +/* 30b8 */ (uint16_t)-1 /*TBL(6)|357*/, 0, (uint16_t)-1 /*TBL(6)|358*/, 0, (uint16_t)-1 /*TBL(6)|359*/, 0, (uint16_t)-1 /*TBL(6)|360*/, 0, +/* 30c0 */ (uint16_t)-1 /*TBL(6)|361*/, 0, (uint16_t)-1 /*TBL(6)|362*/, 0, 0, (uint16_t)-1 /*TBL(6)|363*/, 0, (uint16_t)-1 /*TBL(6)|364*/, +/* 30c8 */ 0, (uint16_t)-1 /*TBL(6)|365*/, 0, 0, 0, 0, 0, 0, +/* 30d0 */ (uint16_t)-1 /*TBL(6)|368*/, (uint16_t)-1 /*TBL(6)|369*/, 0, (uint16_t)-1 /*TBL(6)|370*/, (uint16_t)-1 /*TBL(6)|371*/, 0, (uint16_t)-1 /*TBL(6)|372*/, (uint16_t)-1 /*TBL(6)|373*/, +/* 30d8 */ 0, (uint16_t)-1 /*TBL(6)|374*/, (uint16_t)-1 /*TBL(6)|375*/, 0, (uint16_t)-1 /*TBL(6)|376*/, (uint16_t)-1 /*TBL(6)|377*/, 0, 0, +/* 30e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 30f0 */ 0, 0, 0, 0, (uint16_t)-1 /*TBL(6)|347*/, 0, 0, (uint16_t)-1 /*TBL(6)|382*/, +/* 30f8 */ (uint16_t)-1 /*TBL(6)|383*/, (uint16_t)-1 /*TBL(6)|384*/, (uint16_t)-1 /*TBL(6)|385*/, 0, 0, 0, (uint16_t)-1 /*TBL(6)|386*/, (uint16_t)-1 /*TBL(6)|355*/ +}; + +static const uint16_t UN8IF_compat_00_31 [256] = { +/* 3100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3130 */ 0, TBL(3)|317, TBL(3)|318, TBL(3)|391, TBL(3)|319, TBL(3)|392, TBL(3)|393, TBL(3)|320, +/* 3138 */ TBL(3)|321, TBL(3)|322, TBL(3)|394, TBL(3)|395, TBL(3)|396, TBL(3)|397, TBL(3)|398, TBL(3)|399, +/* 3140 */ TBL(3)|338, TBL(3)|323, TBL(3)|324, TBL(3)|325, TBL(3)|343, TBL(3)|326, TBL(3)|327, TBL(3)|328, +/* 3148 */ TBL(3)|329, TBL(3)|330, TBL(3)|331, TBL(3)|332, TBL(3)|333, TBL(3)|334, TBL(3)|335, TBL(3)|362, +/* 3150 */ TBL(3)|363, TBL(3)|364, TBL(3)|365, TBL(3)|366, TBL(3)|367, TBL(3)|368, TBL(3)|369, TBL(3)|370, +/* 3158 */ TBL(3)|371, TBL(3)|372, TBL(3)|373, TBL(3)|374, TBL(3)|375, TBL(3)|376, TBL(3)|377, TBL(3)|378, +/* 3160 */ TBL(3)|379, TBL(3)|380, TBL(3)|381, TBL(3)|382, TBL(3)|361, TBL(3)|336, TBL(3)|337, TBL(3)|400, +/* 3168 */ TBL(3)|401, TBL(3)|402, TBL(3)|403, TBL(3)|404, TBL(3)|405, TBL(3)|406, TBL(3)|339, TBL(3)|407, +/* 3170 */ TBL(3)|408, TBL(3)|340, TBL(3)|341, TBL(3)|342, TBL(3)|344, TBL(3)|345, TBL(3)|346, TBL(3)|347, +/* 3178 */ TBL(3)|348, TBL(3)|349, TBL(3)|350, TBL(3)|351, TBL(3)|352, TBL(3)|353, TBL(3)|354, TBL(3)|355, +/* 3180 */ TBL(3)|356, TBL(3)|357, TBL(3)|409, TBL(3)|410, TBL(3)|358, TBL(3)|359, TBL(3)|360, TBL(3)|383, +/* 3188 */ TBL(3)|384, TBL(3)|385, TBL(3)|386, TBL(3)|387, TBL(3)|388, TBL(3)|389, TBL(3)|390, 0, +/* 3190 */ 0, 0, TBL(3)|582, TBL(3)|605, TBL(3)|585, TBL(3)|757, TBL(3)|586, TBL(3)|592, +/* 3198 */ TBL(3)|587, TBL(3)|1147, TBL(3)|600, TBL(3)|589, TBL(3)|583, TBL(3)|790, TBL(3)|762, TBL(3)|610, +/* 31a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 31f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_32 [256] = { +/* 3200 */ TBL(5)|0, TBL(5)|1, TBL(5)|2, TBL(5)|3, TBL(5)|4, TBL(5)|5, TBL(5)|6, TBL(5)|7, +/* 3208 */ TBL(5)|8, TBL(5)|9, TBL(5)|10, TBL(5)|11, TBL(5)|12, TBL(5)|13, (uint16_t)-1 /*TBL(8)|0*/, (uint16_t)-1 /*TBL(8)|1*/, +/* 3210 */ (uint16_t)-1 /*TBL(8)|2*/, (uint16_t)-1 /*TBL(8)|3*/, (uint16_t)-1 /*TBL(8)|4*/, (uint16_t)-1 /*TBL(8)|5*/, (uint16_t)-1 /*TBL(8)|6*/, (uint16_t)-1 /*TBL(8)|7*/, (uint16_t)-1 /*TBL(8)|8*/, (uint16_t)-1 /*TBL(8)|10*/, +/* 3218 */ (uint16_t)-1 /*TBL(8)|11*/, (uint16_t)-1 /*TBL(8)|12*/, (uint16_t)-1 /*TBL(8)|13*/, (uint16_t)-1 /*TBL(8)|14*/, (uint16_t)-1 /*TBL(8)|9*/, (uint16_t)-1 /*TBL(17)|0*/, (uint16_t)-1 /*TBL(14)|0*/, 0, +/* 3220 */ TBL(5)|14, TBL(5)|18, TBL(5)|16, TBL(5)|30, TBL(5)|19, TBL(5)|24, TBL(5)|15, TBL(5)|23, +/* 3228 */ TBL(5)|17, TBL(5)|26, TBL(5)|34, TBL(5)|39, TBL(5)|38, TBL(5)|36, TBL(5)|49, TBL(5)|31, +/* 3230 */ TBL(5)|33, TBL(5)|37, TBL(5)|35, TBL(5)|42, TBL(5)|28, TBL(5)|40, TBL(5)|47, TBL(5)|43, +/* 3238 */ TBL(5)|25, TBL(5)|20, TBL(5)|29, TBL(5)|32, TBL(5)|41, TBL(5)|21, TBL(5)|48, TBL(5)|27, +/* 3240 */ TBL(5)|44, TBL(5)|22, TBL(5)|45, TBL(5)|46, TBL(3)|738, TBL(3)|855, TBL(3)|960, TBL(3)|1224, +/* 3248 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 3250 */ TBL(3)|207, TBL(2)|20, TBL(2)|21, TBL(2)|22, TBL(2)|23, TBL(2)|24, TBL(2)|25, TBL(2)|26, +/* 3258 */ TBL(2)|27, TBL(2)|28, TBL(2)|31, TBL(2)|32, TBL(2)|33, TBL(2)|34, TBL(2)|35, TBL(2)|36, +/* 3260 */ TBL(3)|317, TBL(3)|319, TBL(3)|320, TBL(3)|322, TBL(3)|323, TBL(3)|324, TBL(3)|326, TBL(3)|328, +/* 3268 */ TBL(3)|329, TBL(3)|331, TBL(3)|332, TBL(3)|333, TBL(3)|334, TBL(3)|335, (uint16_t)-1 /*TBL(6)|288*/, (uint16_t)-1 /*TBL(6)|289*/, +/* 3270 */ (uint16_t)-1 /*TBL(6)|290*/, (uint16_t)-1 /*TBL(6)|291*/, (uint16_t)-1 /*TBL(6)|292*/, (uint16_t)-1 /*TBL(6)|293*/, (uint16_t)-1 /*TBL(6)|294*/, (uint16_t)-1 /*TBL(6)|295*/, (uint16_t)-1 /*TBL(6)|297*/, (uint16_t)-1 /*TBL(6)|298*/, +/* 3278 */ (uint16_t)-1 /*TBL(6)|299*/, (uint16_t)-1 /*TBL(6)|300*/, (uint16_t)-1 /*TBL(6)|301*/, (uint16_t)-1 /*TBL(6)|302*/, (uint16_t)-1 /*TBL(15)|1*/, (uint16_t)-1 /*TBL(12)|0*/, (uint16_t)-1 /*TBL(6)|296*/, 0, +/* 3280 */ TBL(3)|582, TBL(3)|605, TBL(3)|585, TBL(3)|757, TBL(3)|606, TBL(3)|642, TBL(3)|584, TBL(3)|641, +/* 3288 */ TBL(3)|601, TBL(3)|696, TBL(3)|984, TBL(3)|1082, TBL(3)|1036, TBL(3)|989, TBL(3)|1454, TBL(3)|761, +/* 3290 */ TBL(3)|970, TBL(3)|1001, TBL(3)|985, TBL(3)|1193, TBL(3)|725, TBL(3)|1111, TBL(3)|1400, TBL(3)|1198, +/* 3298 */ TBL(3)|679, TBL(3)|1210, TBL(3)|1149, TBL(3)|796, TBL(3)|1434, TBL(3)|630, TBL(3)|705, TBL(3)|1044, +/* 32a0 */ TBL(3)|1504, TBL(3)|615, TBL(3)|651, TBL(3)|1021, TBL(3)|586, TBL(3)|592, TBL(3)|587, TBL(3)|845, +/* 32a8 */ TBL(3)|722, TBL(3)|694, TBL(3)|812, TBL(3)|809, TBL(3)|1169, TBL(3)|614, TBL(3)|1405, TBL(3)|701, +/* 32b0 */ TBL(3)|787, TBL(2)|37, TBL(2)|38, TBL(2)|39, TBL(2)|40, TBL(2)|43, TBL(2)|44, TBL(2)|45, +/* 32b8 */ TBL(2)|46, TBL(2)|47, TBL(2)|48, TBL(2)|49, TBL(2)|50, TBL(2)|51, TBL(2)|52, TBL(2)|55, +/* 32c0 */ TBL(4)|14, TBL(4)|17, TBL(4)|20, TBL(4)|23, TBL(4)|26, TBL(4)|29, TBL(4)|32, TBL(4)|35, +/* 32c8 */ TBL(4)|38, TBL(5)|52, TBL(5)|55, TBL(5)|58, TBL(2)|77, TBL(3)|1634, TBL(2)|320, TBL(3)|166, +/* 32d0 */ TBL(3)|457, TBL(3)|459, TBL(3)|461, TBL(3)|463, TBL(3)|465, TBL(3)|466, TBL(3)|467, TBL(3)|468, +/* 32d8 */ TBL(3)|469, TBL(3)|470, TBL(3)|471, TBL(3)|472, TBL(3)|473, TBL(3)|474, TBL(3)|475, TBL(3)|476, +/* 32e0 */ TBL(3)|477, TBL(3)|479, TBL(3)|480, TBL(3)|481, TBL(3)|482, TBL(3)|483, TBL(3)|484, TBL(3)|485, +/* 32e8 */ TBL(3)|486, TBL(3)|487, TBL(3)|488, TBL(3)|489, TBL(3)|490, TBL(3)|491, TBL(3)|492, TBL(3)|493, +/* 32f0 */ TBL(3)|494, TBL(3)|495, TBL(3)|496, TBL(3)|498, TBL(3)|500, TBL(3)|502, TBL(3)|503, TBL(3)|504, +/* 32f8 */ TBL(3)|505, TBL(3)|506, TBL(3)|507, TBL(3)|508, TBL(3)|509, TBL(3)|510, TBL(3)|511, (uint16_t)-1 /*TBL(6)|387*/ +}; + +static const uint16_t UN8IF_compat_00_33 [256] = { +/* 3300 */ (uint16_t)-1 /*TBL(15)|2*/, (uint16_t)-1 /*TBL(12)|3*/, (uint16_t)-1 /*TBL(15)|3*/, (uint16_t)-1 /*TBL(9)|17*/, (uint16_t)-1 /*TBL(15)|4*/, (uint16_t)-1 /*TBL(9)|18*/, (uint16_t)-1 /*TBL(9)|19*/, (uint16_t)-1 /*TBL(18)|0*/, +/* 3308 */ (uint16_t)-1 /*TBL(12)|4*/, (uint16_t)-1 /*TBL(9)|20*/, (uint16_t)-1 /*TBL(9)|21*/, (uint16_t)-1 /*TBL(9)|22*/, (uint16_t)-1 /*TBL(12)|7*/, (uint16_t)-1 /*TBL(12)|8*/, (uint16_t)-1 /*TBL(12)|5*/, (uint16_t)-1 /*TBL(12)|6*/, +/* 3310 */ (uint16_t)-1 /*TBL(12)|9*/, (uint16_t)-1 /*TBL(12)|10*/, (uint16_t)-1 /*TBL(12)|11*/, (uint16_t)-1 /*TBL(18)|1*/, (uint16_t)-1 /*TBL(6)|350*/, (uint16_t)-1 /*TBL(18)|2*/, (uint16_t)-1 /*TBL(18)|3*/, (uint16_t)-1 /*TBL(15)|5*/, +/* 3318 */ (uint16_t)-1 /*TBL(12)|12*/, (uint16_t)-1 /*TBL(18)|4*/, (uint16_t)-1 /*TBL(18)|5*/, (uint16_t)-1 /*TBL(12)|13*/, (uint16_t)-1 /*TBL(9)|23*/, (uint16_t)-1 /*TBL(9)|24*/, (uint16_t)-1 /*TBL(12)|14*/, (uint16_t)-1 /*TBL(12)|15*/, +/* 3320 */ (uint16_t)-1 /*TBL(15)|6*/, (uint16_t)-1 /*TBL(15)|7*/, (uint16_t)-1 /*TBL(9)|25*/, (uint16_t)-1 /*TBL(9)|26*/, (uint16_t)-1 /*TBL(12)|16*/, (uint16_t)-1 /*TBL(9)|27*/, (uint16_t)-1 /*TBL(9)|28*/, (uint16_t)-1 /*TBL(6)|366*/, +/* 3328 */ (uint16_t)-1 /*TBL(6)|367*/, (uint16_t)-1 /*TBL(9)|29*/, (uint16_t)-1 /*TBL(9)|30*/, (uint16_t)-1 /*TBL(18)|6*/, (uint16_t)-1 /*TBL(12)|17*/, (uint16_t)-1 /*TBL(15)|8*/, (uint16_t)-1 /*TBL(18)|7*/, (uint16_t)-1 /*TBL(12)|18*/, +/* 3330 */ (uint16_t)-1 /*TBL(9)|32*/, (uint16_t)-1 /*TBL(9)|31*/, (uint16_t)-1 /*TBL(18)|9*/, (uint16_t)-1 /*TBL(12)|19*/, (uint16_t)-1 /*TBL(18)|8*/, (uint16_t)-1 /*TBL(9)|33*/, (uint16_t)-1 /*TBL(15)|10*/, (uint16_t)-1 /*TBL(9)|34*/, +/* 3338 */ (uint16_t)-1 /*TBL(12)|21*/, (uint16_t)-1 /*TBL(9)|35*/, (uint16_t)-1 /*TBL(12)|22*/, (uint16_t)-1 /*TBL(15)|9*/, (uint16_t)-1 /*TBL(12)|20*/, (uint16_t)-1 /*TBL(15)|11*/, (uint16_t)-1 /*TBL(12)|23*/, (uint16_t)-1 /*TBL(6)|378*/, +/* 3340 */ (uint16_t)-1 /*TBL(15)|12*/, (uint16_t)-1 /*TBL(9)|36*/, (uint16_t)-1 /*TBL(9)|37*/, (uint16_t)-1 /*TBL(12)|24*/, (uint16_t)-1 /*TBL(9)|38*/, (uint16_t)-1 /*TBL(9)|39*/, (uint16_t)-1 /*TBL(9)|40*/, (uint16_t)-1 /*TBL(15)|13*/, +/* 3348 */ (uint16_t)-1 /*TBL(12)|25*/, (uint16_t)-1 /*TBL(6)|379*/, (uint16_t)-1 /*TBL(18)|10*/, (uint16_t)-1 /*TBL(9)|41*/, (uint16_t)-1 /*TBL(15)|14*/, (uint16_t)-1 /*TBL(12)|26*/, (uint16_t)-1 /*TBL(12)|27*/, (uint16_t)-1 /*TBL(9)|42*/, +/* 3350 */ (uint16_t)-1 /*TBL(9)|43*/, (uint16_t)-1 /*TBL(12)|28*/, (uint16_t)-1 /*TBL(6)|380*/, (uint16_t)-1 /*TBL(12)|29*/, (uint16_t)-1 /*TBL(15)|15*/, (uint16_t)-1 /*TBL(6)|381*/, (uint16_t)-1 /*TBL(18)|11*/, (uint16_t)-1 /*TBL(9)|44*/, +/* 3358 */ TBL(4)|11, TBL(4)|15, TBL(4)|18, TBL(4)|21, TBL(4)|24, TBL(4)|27, TBL(4)|30, TBL(4)|33, +/* 3360 */ TBL(4)|36, TBL(4)|39, TBL(5)|53, TBL(5)|56, TBL(5)|59, TBL(5)|61, TBL(5)|63, TBL(5)|65, +/* 3368 */ TBL(5)|67, TBL(5)|69, TBL(5)|71, TBL(5)|73, TBL(5)|83, TBL(5)|85, TBL(5)|87, TBL(5)|89, +/* 3370 */ TBL(5)|91, TBL(3)|1646, TBL(2)|316, TBL(2)|67, TBL(3)|1598, TBL(2)|359, TBL(2)|364, TBL(2)|318, +/* 3378 */ TBL(3)|1615, TBL(3)|1616, TBL(2)|81, (uint16_t)-1 /*TBL(6)|389*/, (uint16_t)-1 /*TBL(6)|391*/, (uint16_t)-1 /*TBL(6)|388*/, (uint16_t)-1 /*TBL(6)|390*/, (uint16_t)-1 /*TBL(12)|30*/, +/* 3380 */ TBL(2)|360, TBL(2)|352, TBL(3)|307, TBL(2)|344, TBL(2)|331, TBL(2)|84, TBL(2)|89, TBL(2)|73, +/* 3388 */ TBL(3)|1606, TBL(4)|505, TBL(2)|361, TBL(2)|353, TBL(3)|308, TBL(3)|311, TBL(2)|348, TBL(2)|334, +/* 3390 */ TBL(2)|78, TBL(3)|1672, TBL(3)|174, TBL(3)|128, TBL(3)|226, TBL(3)|312, TBL(2)|349, TBL(2)|317, +/* 3398 */ TBL(2)|335, TBL(2)|324, TBL(2)|357, TBL(3)|313, TBL(2)|350, TBL(2)|314, TBL(2)|336, TBL(3)|1694, +/* 33a0 */ TBL(3)|1607, TBL(2)|342, TBL(3)|1680, TBL(3)|1695, TBL(3)|1608, TBL(2)|343, TBL(3)|1681, TBL(5)|248, +/* 33a8 */ (uint16_t)-1 /*TBL(6)|392*/, TBL(2)|100, TBL(3)|1673, TBL(3)|175, TBL(3)|129, TBL(3)|1732, (uint16_t)-1 /*TBL(7)|1*/, (uint16_t)-1 /*TBL(8)|76*/, +/* 33b0 */ TBL(2)|365, TBL(2)|358, TBL(3)|314, TBL(2)|351, TBL(2)|362, TBL(2)|354, TBL(3)|309, TBL(2)|345, +/* 33b8 */ TBL(2)|332, TBL(2)|93, TBL(2)|363, TBL(2)|355, TBL(3)|310, TBL(2)|346, TBL(2)|333, TBL(2)|94, +/* 33c0 */ TBL(3)|1679, TBL(3)|179, TBL(4)|503, TBL(2)|68, TBL(2)|312, TBL(2)|313, (uint16_t)-1 /*TBL(6)|1*/, TBL(3)|102, +/* 33c8 */ TBL(2)|315, TBL(2)|74, TBL(2)|325, TBL(2)|75, TBL(2)|328, TBL(2)|85, TBL(2)|86, TBL(2)|337, +/* 33d0 */ TBL(2)|339, TBL(2)|340, TBL(3)|1689, TBL(2)|341, TBL(2)|347, TBL(3)|1693, TBL(3)|1696, TBL(2)|98, +/* 33d8 */ TBL(4)|506, TBL(3)|205, TBL(2)|99, TBL(2)|366, TBL(2)|105, TBL(2)|110, TBL(5)|166, TBL(5)|121, +/* 33e0 */ TBL(4)|13, TBL(4)|16, TBL(4)|19, TBL(4)|22, TBL(4)|25, TBL(4)|28, TBL(4)|31, TBL(4)|34, +/* 33e8 */ TBL(4)|37, TBL(5)|51, TBL(5)|54, TBL(5)|57, TBL(5)|60, TBL(5)|62, TBL(5)|64, TBL(5)|66, +/* 33f0 */ TBL(5)|68, TBL(5)|70, TBL(5)|72, TBL(5)|82, TBL(5)|84, TBL(5)|86, TBL(5)|88, TBL(5)|90, +/* 33f8 */ TBL(5)|92, TBL(5)|93, TBL(5)|94, TBL(5)|95, TBL(5)|96, TBL(5)|99, TBL(5)|100, TBL(3)|1645 +}; + +static const uint16_t UN8IF_compat_00_a6 [256] = { +/* a600 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a608 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a610 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a618 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a620 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a628 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a630 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a638 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a640 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a648 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a650 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a658 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a660 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a668 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a670 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a678 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a680 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a688 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a690 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a698 */ 0, 0, 0, 0, TBL(2)|228, TBL(2)|229, 0, 0, +/* a6a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a6f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_a7 [256] = { +/* a700 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a708 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a710 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a718 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a720 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a728 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a730 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a738 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a740 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a748 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a750 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a758 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a760 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a768 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a770 */ TBL(3)|1573, 0, 0, 0, 0, 0, 0, 0, +/* a778 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a780 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a788 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a790 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a798 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* a7f8 */ TBL(2)|120, TBL(2)|124, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_ab [256] = { +/* ab00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab58 */ 0, 0, 0, 0, TBL(3)|1572, TBL(3)|1574, TBL(2)|146, TBL(3)|1575, +/* ab60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab68 */ 0, TBL(2)|165, 0, 0, 0, 0, 0, 0, +/* ab70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* ab98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* aba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* abf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_f9 [256] = { +/* f900 */ TBL(3)|1396, TBL(3)|981, TBL(3)|1419, TBL(3)|1406, TBL(3)|1068, TBL(3)|593, TBL(3)|718, TBL(3)|1569, +/* f908 */ TBL(3)|1569, TBL(3)|793, TBL(3)|1454, TBL(3)|743, TBL(3)|792, TBL(3)|914, TBL(3)|1162, TBL(3)|1262, +/* f910 */ TBL(3)|1340, TBL(3)|1355, TBL(3)|1368, TBL(3)|1437, TBL(3)|1011, TBL(3)|1046, TBL(3)|1089, TBL(3)|1127, +/* f918 */ TBL(3)|1326, TBL(3)|1448, TBL(3)|1523, TBL(3)|602, TBL(3)|707, TBL(3)|1016, TBL(3)|1098, TBL(3)|1339, +/* f920 */ TBL(3)|1543, TBL(3)|835, TBL(3)|1076, TBL(3)|1335, TBL(3)|1372, TBL(3)|927, TBL(3)|1285, TBL(3)|1358, +/* f928 */ TBL(3)|862, TBL(3)|986, TBL(3)|1052, TBL(3)|1117, TBL(3)|1440, TBL(3)|618, TBL(3)|656, TBL(3)|683, +/* f930 */ TBL(3)|953, TBL(3)|1014, TBL(3)|1097, TBL(3)|1170, TBL(3)|1268, TBL(3)|1337, TBL(3)|1343, TBL(3)|1416, +/* f938 */ TBL(3)|1490, TBL(3)|1535, TBL(3)|1542, TBL(3)|1185, TBL(3)|1201, TBL(3)|1247, TBL(3)|1319, TBL(3)|1461, +/* f940 */ TBL(3)|1545, TBL(3)|1385, TBL(3)|776, TBL(3)|869, TBL(3)|1229, TBL(3)|1277, TBL(3)|1110, TBL(3)|1187, +/* f948 */ TBL(3)|1404, TBL(3)|1488, TBL(3)|775, TBL(3)|826, TBL(3)|1012, TBL(3)|1057, TBL(3)|1070, TBL(3)|1243, +/* f950 */ TBL(3)|1253, TBL(3)|1472, TBL(3)|682, TBL(3)|1280, TBL(3)|659, TBL(3)|658, TBL(3)|1212, TBL(3)|1248, +/* f958 */ TBL(3)|1325, TBL(3)|1474, TBL(3)|1392, TBL(3)|928, TBL(3)|1011, TBL(3)|1388, TBL(3)|596, TBL(3)|815, +/* f960 */ TBL(3)|891, TBL(3)|1122, TBL(3)|1154, TBL(3)|691, TBL(3)|1189, TBL(3)|622, TBL(3)|884, TBL(3)|588, +/* f968 */ TBL(3)|1041, TBL(3)|959, TBL(3)|1242, TBL(3)|712, TBL(3)|771, TBL(3)|1173, TBL(3)|1327, TBL(3)|1381, +/* f970 */ TBL(3)|1028, TBL(3)|1428, TBL(3)|1039, TBL(3)|932, TBL(3)|1309, TBL(3)|940, TBL(3)|1153, TBL(3)|609, +/* f978 */ TBL(3)|640, TBL(3)|657, TBL(3)|1003, TBL(3)|1237, TBL(3)|1299, TBL(3)|1384, TBL(3)|1453, TBL(3)|685, +/* f980 */ TBL(3)|730, TBL(3)|796, TBL(3)|866, TBL(3)|966, TBL(3)|1077, TBL(3)|1190, TBL(3)|1468, TBL(3)|1525, +/* f988 */ TBL(3)|1546, TBL(3)|1552, TBL(3)|676, TBL(3)|979, TBL(3)|1023, TBL(3)|1425, TBL(3)|853, TBL(3)|908, +/* f990 */ TBL(3)|915, TBL(3)|951, TBL(3)|1073, TBL(3)|1092, TBL(3)|1136, TBL(3)|1209, TBL(3)|1250, TBL(3)|1275, +/* f998 */ TBL(3)|1421, TBL(3)|1329, TBL(3)|1431, TBL(3)|1462, TBL(3)|666, TBL(3)|677, TBL(3)|735, TBL(3)|1088, +/* f9a0 */ TBL(3)|1363, TBL(3)|1381, TBL(3)|861, TBL(3)|889, TBL(3)|938, TBL(3)|1026, TBL(3)|1228, TBL(3)|1119, +/* f9a8 */ TBL(3)|613, TBL(3)|758, TBL(3)|815, TBL(3)|840, TBL(3)|892, TBL(3)|1126, TBL(3)|1133, TBL(3)|1265, +/* f9b0 */ TBL(3)|1273, TBL(3)|1455, TBL(3)|1487, TBL(3)|1491, TBL(3)|1506, TBL(3)|619, TBL(3)|1206, TBL(3)|1450, +/* f9b8 */ TBL(3)|1481, TBL(3)|898, TBL(3)|604, TBL(3)|628, TBL(3)|816, TBL(3)|824, TBL(3)|962, TBL(3)|1011, +/* f9c0 */ TBL(3)|1095, TBL(3)|1161, TBL(3)|1332, TBL(3)|1436, TBL(3)|1567, TBL(3)|975, TBL(3)|1471, TBL(3)|675, +/* f9c8 */ TBL(3)|994, TBL(3)|997, TBL(3)|1050, TBL(3)|1064, TBL(3)|1129, TBL(3)|1152, TBL(3)|1184, TBL(3)|1241, +/* f9d0 */ TBL(3)|1509, TBL(3)|642, TBL(3)|919, TBL(3)|1475, TBL(3)|624, TBL(3)|833, TBL(3)|1058, TBL(3)|1422, +/* f9d8 */ TBL(3)|880, TBL(3)|900, TBL(3)|999, TBL(3)|1122, TBL(3)|1477, TBL(3)|668, TBL(3)|726, TBL(3)|828, +/* f9e0 */ TBL(3)|971, TBL(3)|990, TBL(3)|1006, TBL(3)|1043, TBL(3)|1128, TBL(3)|1157, TBL(3)|1260, TBL(3)|1364, +/* f9e8 */ TBL(3)|1367, TBL(3)|1452, TBL(3)|1484, TBL(3)|695, TBL(3)|1065, TBL(3)|727, TBL(3)|1096, TBL(3)|1137, +/* f9f0 */ TBL(3)|1336, TBL(3)|1478, TBL(3)|1537, TBL(3)|1547, TBL(3)|996, TBL(3)|1056, TBL(3)|1287, TBL(3)|1220, +/* f9f8 */ TBL(3)|1223, TBL(3)|1232, TBL(3)|1116, TBL(3)|1086, TBL(3)|1391, TBL(3)|611, TBL(3)|1313, TBL(3)|669 +}; + +static const uint16_t UN8IF_compat_00_fa [256] = { +/* fa00 */ TBL(3)|665, TBL(3)|857, TBL(3)|929, TBL(3)|1235, TBL(3)|811, TBL(3)|1047, TBL(3)|978, TBL(3)|1424, +/* fa08 */ TBL(3)|1360, TBL(3)|1473, TBL(3)|1375, TBL(3)|864, TBL(3)|632, TBL(3)|749, 0, 0, +/* fa10 */ TBL(3)|770, 0, TBL(3)|974, 0, 0, TBL(3)|660, TBL(3)|1118, TBL(3)|1167, +/* fa18 */ TBL(3)|1192, TBL(3)|1199, TBL(3)|1200, TBL(3)|1205, TBL(3)|1493, TBL(3)|1233, TBL(3)|1266, 0, +/* fa20 */ TBL(3)|1338, 0, TBL(3)|1387, 0, 0, TBL(3)|1432, TBL(3)|1443, 0, +/* fa28 */ 0, 0, TBL(3)|1514, TBL(3)|1515, TBL(3)|1516, TBL(3)|1541, TBL(3)|1441, TBL(3)|1480, +/* fa30 */ TBL(3)|620, TBL(3)|629, TBL(3)|634, TBL(3)|681, TBL(3)|684, TBL(3)|700, TBL(3)|745, TBL(3)|752, +/* fa38 */ TBL(3)|754, TBL(3)|769, TBL(3)|772, TBL(3)|827, TBL(3)|829, TBL(3)|895, TBL(3)|905, TBL(3)|907, +/* fa40 */ TBL(3)|913, TBL(3)|956, TBL(3)|968, TBL(3)|976, TBL(3)|1004, TBL(3)|1053, TBL(3)|1060, TBL(3)|1072, +/* fa48 */ TBL(3)|1093, TBL(3)|1101, TBL(3)|1130, TBL(3)|1186, TBL(3)|1193, TBL(3)|1195, TBL(3)|1194, TBL(3)|1196, +/* fa50 */ TBL(3)|1197, TBL(3)|1198, TBL(3)|1203, TBL(3)|1204, TBL(3)|1213, TBL(3)|1218, TBL(3)|1225, TBL(3)|1250, +/* fa58 */ TBL(3)|1252, TBL(3)|1254, TBL(3)|1259, TBL(3)|1269, TBL(3)|1289, TBL(3)|1302, TBL(3)|1302, TBL(3)|1328, +/* fa60 */ TBL(3)|1370, TBL(3)|1376, TBL(3)|1389, TBL(3)|1390, TBL(3)|1407, TBL(3)|1408, TBL(3)|1430, TBL(3)|1432, +/* fa68 */ TBL(3)|1485, TBL(3)|1502, TBL(3)|1508, TBL(3)|893, TBL(4)|436, TBL(3)|1295, 0, 0, +/* fa70 */ TBL(3)|590, TBL(3)|655, TBL(3)|639, TBL(3)|617, TBL(3)|633, TBL(3)|644, TBL(3)|680, TBL(3)|687, +/* fa78 */ TBL(3)|745, TBL(3)|740, TBL(3)|744, TBL(3)|751, TBL(3)|770, TBL(3)|774, TBL(3)|791, TBL(3)|794, +/* fa80 */ TBL(3)|801, TBL(3)|805, TBL(3)|863, TBL(3)|865, TBL(3)|877, TBL(3)|885, TBL(3)|897, TBL(3)|903, +/* fa88 */ TBL(3)|899, TBL(3)|907, TBL(3)|904, TBL(3)|913, TBL(3)|920, TBL(3)|942, TBL(3)|945, TBL(3)|947, +/* fa90 */ TBL(3)|957, TBL(3)|974, TBL(3)|986, TBL(3)|987, TBL(3)|992, TBL(3)|1024, TBL(3)|1028, TBL(3)|1050, +/* fa98 */ TBL(3)|1069, TBL(3)|1067, TBL(3)|1072, TBL(3)|1079, TBL(3)|1093, TBL(3)|1179, TBL(3)|1102, TBL(3)|1115, +/* faa0 */ TBL(3)|1118, TBL(3)|1134, TBL(3)|1141, TBL(3)|1150, TBL(3)|1159, TBL(3)|1160, TBL(3)|1167, TBL(3)|1168, +/* faa8 */ TBL(3)|1172, TBL(3)|1177, TBL(3)|1176, TBL(3)|1188, TBL(3)|1219, TBL(3)|1225, TBL(3)|1231, TBL(3)|1245, +/* fab0 */ TBL(3)|1250, TBL(3)|1257, TBL(3)|1269, TBL(3)|1314, TBL(3)|1324, TBL(3)|1353, TBL(3)|1371, TBL(3)|1374, +/* fab8 */ TBL(3)|1376, TBL(3)|1382, TBL(3)|1387, TBL(3)|1383, TBL(3)|1389, TBL(3)|1388, TBL(3)|1386, TBL(3)|1390, +/* fac0 */ TBL(3)|1393, TBL(3)|1408, TBL(3)|1423, TBL(3)|1435, TBL(3)|1449, TBL(3)|1457, TBL(3)|1476, TBL(3)|1485, +/* fac8 */ TBL(3)|1493, TBL(3)|1498, TBL(3)|1502, TBL(3)|1505, TBL(3)|1508, TBL(3)|1529, TBL(3)|1569, TBL(4)|415, +/* fad0 */ TBL(4)|414, TBL(4)|424, TBL(3)|536, TBL(3)|546, TBL(3)|547, TBL(4)|450, TBL(4)|459, TBL(4)|483, +/* fad8 */ TBL(3)|1564, TBL(3)|1568, 0, 0, 0, 0, 0, 0, +/* fae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* faf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* faf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_fb [256] = { +/* fb00 */ TBL(2)|321, TBL(2)|322, TBL(2)|323, TBL(3)|1636, TBL(3)|1637, TBL(2)|367, TBL(2)|367, 0, +/* fb08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fb10 */ 0, 0, 0, TBL(4)|195, TBL(4)|192, TBL(4)|193, TBL(4)|196, TBL(4)|194, +/* fb18 */ 0, 0, 0, 0, 0, TBL(4)|210, 0, TBL(4)|229, +/* fb20 */ TBL(2)|238, TBL(2)|230, TBL(2)|233, TBL(2)|234, TBL(2)|235, TBL(2)|236, TBL(2)|237, TBL(2)|239, +/* fb28 */ TBL(2)|240, TBL(1)|9, TBL(4)|226, TBL(4)|227, (uint16_t)-1 /*TBL(6)|102*/, (uint16_t)-1 /*TBL(6)|103*/, TBL(4)|197, TBL(4)|198, +/* fb30 */ TBL(4)|199, TBL(4)|201, TBL(4)|203, TBL(4)|204, TBL(4)|205, TBL(4)|207, TBL(4)|208, 0, +/* fb38 */ TBL(4)|209, TBL(4)|211, TBL(4)|212, TBL(4)|213, TBL(4)|215, 0, TBL(4)|216, 0, +/* fb40 */ TBL(4)|217, TBL(4)|218, 0, TBL(4)|219, TBL(4)|220, 0, TBL(4)|222, TBL(4)|223, +/* fb48 */ TBL(4)|224, TBL(4)|225, TBL(4)|228, TBL(4)|206, TBL(4)|202, TBL(4)|214, TBL(4)|221, TBL(4)|200, +/* fb50 */ TBL(2)|274, TBL(2)|274, TBL(2)|277, TBL(2)|277, TBL(2)|277, TBL(2)|277, TBL(2)|278, TBL(2)|278, +/* fb58 */ TBL(2)|278, TBL(2)|278, TBL(2)|280, TBL(2)|280, TBL(2)|280, TBL(2)|280, TBL(2)|276, TBL(2)|276, +/* fb60 */ TBL(2)|276, TBL(2)|276, TBL(2)|279, TBL(2)|279, TBL(2)|279, TBL(2)|279, TBL(2)|275, TBL(2)|275, +/* fb68 */ TBL(2)|275, TBL(2)|275, TBL(2)|292, TBL(2)|292, TBL(2)|292, TBL(2)|292, TBL(2)|293, TBL(2)|293, +/* fb70 */ TBL(2)|293, TBL(2)|293, TBL(2)|282, TBL(2)|282, TBL(2)|282, TBL(2)|282, TBL(2)|281, TBL(2)|281, +/* fb78 */ TBL(2)|281, TBL(2)|281, TBL(2)|283, TBL(2)|283, TBL(2)|283, TBL(2)|283, TBL(2)|284, TBL(2)|284, +/* fb80 */ TBL(2)|284, TBL(2)|284, TBL(2)|287, TBL(2)|287, TBL(2)|286, TBL(2)|286, TBL(2)|288, TBL(2)|288, +/* fb88 */ TBL(2)|285, TBL(2)|285, TBL(2)|290, TBL(2)|290, TBL(2)|289, TBL(2)|289, TBL(2)|294, TBL(2)|294, +/* fb90 */ TBL(2)|294, TBL(2)|294, TBL(2)|296, TBL(2)|296, TBL(2)|296, TBL(2)|296, TBL(2)|298, TBL(2)|298, +/* fb98 */ TBL(2)|298, TBL(2)|298, TBL(2)|297, TBL(2)|297, TBL(2)|297, TBL(2)|297, TBL(2)|299, TBL(2)|299, +/* fba0 */ TBL(2)|300, TBL(2)|300, TBL(2)|300, TBL(2)|300, TBL(4)|392, TBL(4)|392, TBL(2)|302, TBL(2)|302, +/* fba8 */ TBL(2)|302, TBL(2)|302, TBL(2)|301, TBL(2)|301, TBL(2)|301, TBL(2)|301, TBL(2)|311, TBL(2)|311, +/* fbb0 */ TBL(4)|391, TBL(4)|391, 0, 0, 0, 0, 0, 0, +/* fbb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fbd0 */ 0, 0, 0, TBL(2)|295, TBL(2)|295, TBL(2)|295, TBL(2)|295, TBL(2)|305, +/* fbd8 */ TBL(2)|305, TBL(2)|304, TBL(2)|304, TBL(2)|306, TBL(2)|306, TBL(4)|390, TBL(2)|308, TBL(2)|308, +/* fbe0 */ TBL(2)|303, TBL(2)|303, TBL(2)|307, TBL(2)|307, TBL(2)|310, TBL(2)|310, TBL(2)|310, TBL(2)|310, +/* fbe8 */ TBL(2)|270, TBL(2)|270, (uint16_t)-1 /*TBL(6)|207*/, (uint16_t)-1 /*TBL(6)|207*/, (uint16_t)-1 /*TBL(6)|223*/, (uint16_t)-1 /*TBL(6)|223*/, (uint16_t)-1 /*TBL(6)|216*/, (uint16_t)-1 /*TBL(6)|216*/, +/* fbf0 */ (uint16_t)-1 /*TBL(6)|220*/, (uint16_t)-1 /*TBL(6)|220*/, (uint16_t)-1 /*TBL(6)|219*/, (uint16_t)-1 /*TBL(6)|219*/, (uint16_t)-1 /*TBL(6)|221*/, (uint16_t)-1 /*TBL(6)|221*/, (uint16_t)-1 /*TBL(6)|222*/, (uint16_t)-1 /*TBL(6)|222*/, +/* fbf8 */ (uint16_t)-1 /*TBL(6)|222*/, (uint16_t)-1 /*TBL(6)|217*/, (uint16_t)-1 /*TBL(6)|217*/, (uint16_t)-1 /*TBL(6)|217*/, TBL(2)|309, TBL(2)|309, TBL(2)|309, TBL(2)|309 +}; + +static const uint16_t UN8IF_compat_00_fc [256] = { +/* fc00 */ (uint16_t)-1 /*TBL(6)|208*/, (uint16_t)-1 /*TBL(6)|209*/, (uint16_t)-1 /*TBL(6)|213*/, (uint16_t)-1 /*TBL(6)|217*/, (uint16_t)-1 /*TBL(6)|218*/, TBL(4)|235, TBL(4)|236, TBL(4)|237, +/* fc08 */ TBL(4)|240, TBL(4)|243, TBL(4)|244, TBL(4)|245, TBL(4)|246, TBL(4)|247, TBL(4)|250, TBL(4)|253, +/* fc10 */ TBL(4)|254, TBL(4)|255, TBL(4)|258, TBL(4)|261, TBL(4)|262, TBL(4)|263, TBL(4)|264, TBL(4)|267, +/* fc18 */ TBL(4)|268, TBL(4)|271, TBL(4)|272, TBL(4)|273, TBL(4)|278, TBL(4)|279, TBL(4)|280, TBL(4)|282, +/* fc20 */ TBL(4)|294, TBL(4)|297, TBL(4)|300, TBL(4)|301, TBL(4)|302, TBL(4)|304, TBL(4)|307, TBL(4)|308, +/* fc28 */ TBL(4)|311, TBL(4)|312, TBL(4)|313, TBL(4)|316, TBL(4)|317, TBL(4)|326, TBL(4)|327, TBL(4)|328, +/* fc30 */ TBL(4)|329, TBL(4)|330, TBL(4)|331, TBL(4)|332, TBL(4)|333, TBL(4)|334, TBL(4)|335, TBL(4)|336, +/* fc38 */ TBL(4)|337, TBL(4)|338, TBL(4)|339, TBL(4)|340, TBL(4)|341, TBL(4)|342, TBL(4)|343, TBL(4)|345, +/* fc40 */ TBL(4)|346, TBL(4)|347, TBL(4)|348, TBL(4)|350, TBL(4)|351, TBL(4)|353, TBL(4)|354, TBL(4)|355, +/* fc48 */ TBL(4)|356, TBL(4)|357, TBL(4)|358, TBL(4)|359, TBL(4)|360, TBL(4)|361, TBL(4)|364, TBL(4)|367, +/* fc50 */ TBL(4)|368, TBL(4)|369, TBL(4)|370, TBL(4)|371, TBL(4)|372, TBL(4)|377, TBL(4)|378, TBL(4)|379, +/* fc58 */ TBL(4)|382, TBL(4)|385, TBL(4)|386, TBL(4)|276, TBL(4)|277, TBL(4)|376, TBL(5)|176, TBL(5)|177, +/* fc60 */ TBL(5)|178, TBL(5)|179, TBL(5)|180, TBL(5)|181, (uint16_t)-1 /*TBL(6)|211*/, (uint16_t)-1 /*TBL(6)|212*/, (uint16_t)-1 /*TBL(6)|213*/, (uint16_t)-1 /*TBL(6)|214*/, +/* fc68 */ (uint16_t)-1 /*TBL(6)|217*/, (uint16_t)-1 /*TBL(6)|218*/, TBL(4)|238, TBL(4)|239, TBL(4)|240, TBL(4)|241, TBL(4)|243, TBL(4)|244, +/* fc70 */ TBL(4)|248, TBL(4)|249, TBL(4)|250, TBL(4)|251, TBL(4)|253, TBL(4)|254, TBL(4)|256, TBL(4)|257, +/* fc78 */ TBL(4)|258, TBL(4)|259, TBL(4)|261, TBL(4)|262, TBL(4)|330, TBL(4)|331, TBL(4)|334, TBL(4)|335, +/* fc80 */ TBL(4)|336, TBL(4)|340, TBL(4)|341, TBL(4)|342, TBL(4)|343, TBL(4)|348, TBL(4)|350, TBL(4)|351, +/* fc88 */ TBL(4)|352, TBL(4)|356, TBL(4)|362, TBL(4)|363, TBL(4)|364, TBL(4)|365, TBL(4)|367, TBL(4)|368, +/* fc90 */ TBL(4)|376, TBL(4)|380, TBL(4)|381, TBL(4)|382, TBL(4)|383, TBL(4)|385, TBL(4)|386, (uint16_t)-1 /*TBL(6)|208*/, +/* fc98 */ (uint16_t)-1 /*TBL(6)|209*/, (uint16_t)-1 /*TBL(6)|210*/, (uint16_t)-1 /*TBL(6)|213*/, (uint16_t)-1 /*TBL(6)|215*/, TBL(4)|235, TBL(4)|236, TBL(4)|237, TBL(4)|240, +/* fca0 */ TBL(4)|242, TBL(4)|245, TBL(4)|246, TBL(4)|247, TBL(4)|250, TBL(4)|252, TBL(4)|258, TBL(4)|263, +/* fca8 */ TBL(4)|264, TBL(4)|267, TBL(4)|268, TBL(4)|271, TBL(4)|273, TBL(4)|278, TBL(4)|279, TBL(4)|280, +/* fcb0 */ TBL(4)|282, TBL(4)|294, TBL(4)|295, TBL(4)|297, TBL(4)|300, TBL(4)|301, TBL(4)|302, TBL(4)|304, +/* fcb8 */ TBL(4)|307, TBL(4)|311, TBL(4)|312, TBL(4)|313, TBL(4)|316, TBL(4)|317, TBL(4)|326, TBL(4)|327, +/* fcc0 */ TBL(4)|328, TBL(4)|329, TBL(4)|332, TBL(4)|333, TBL(4)|337, TBL(4)|338, TBL(4)|339, TBL(4)|340, +/* fcc8 */ TBL(4)|341, TBL(4)|345, TBL(4)|346, TBL(4)|347, TBL(4)|348, TBL(4)|349, TBL(4)|353, TBL(4)|354, +/* fcd0 */ TBL(4)|355, TBL(4)|356, TBL(4)|359, TBL(4)|360, TBL(4)|361, TBL(4)|364, TBL(4)|366, TBL(4)|369, +/* fcd8 */ TBL(4)|370, TBL(4)|373, TBL(4)|377, TBL(4)|378, TBL(4)|379, TBL(4)|382, TBL(4)|384, (uint16_t)-1 /*TBL(6)|213*/, +/* fce0 */ (uint16_t)-1 /*TBL(6)|215*/, TBL(4)|240, TBL(4)|242, TBL(4)|250, TBL(4)|252, TBL(4)|258, TBL(4)|260, TBL(4)|282, +/* fce8 */ TBL(4)|283, TBL(4)|290, TBL(4)|291, TBL(4)|340, TBL(4)|341, TBL(4)|348, TBL(4)|364, TBL(4)|366, +/* fcf0 */ TBL(4)|382, TBL(4)|384, (uint16_t)-1 /*TBL(6)|158*/, (uint16_t)-1 /*TBL(6)|159*/, (uint16_t)-1 /*TBL(6)|160*/, TBL(4)|309, TBL(4)|310, TBL(4)|314, +/* fcf8 */ TBL(4)|315, TBL(4)|318, TBL(4)|319, TBL(4)|284, TBL(4)|285, TBL(4)|292, TBL(4)|293, TBL(4)|269 +}; + +static const uint16_t UN8IF_compat_00_fd [256] = { +/* fd00 */ TBL(4)|270, TBL(4)|265, TBL(4)|266, TBL(4)|274, TBL(4)|275, TBL(4)|298, TBL(4)|299, TBL(4)|305, +/* fd08 */ TBL(4)|306, TBL(4)|286, TBL(4)|287, TBL(4)|288, TBL(4)|290, TBL(4)|289, TBL(4)|281, TBL(4)|296, +/* fd10 */ TBL(4)|303, TBL(4)|309, TBL(4)|310, TBL(4)|314, TBL(4)|315, TBL(4)|318, TBL(4)|319, TBL(4)|284, +/* fd18 */ TBL(4)|285, TBL(4)|292, TBL(4)|293, TBL(4)|269, TBL(4)|270, TBL(4)|265, TBL(4)|266, TBL(4)|274, +/* fd20 */ TBL(4)|275, TBL(4)|298, TBL(4)|299, TBL(4)|305, TBL(4)|306, TBL(4)|286, TBL(4)|287, TBL(4)|288, +/* fd28 */ TBL(4)|290, TBL(4)|289, TBL(4)|281, TBL(4)|296, TBL(4)|303, TBL(4)|286, TBL(4)|287, TBL(4)|288, +/* fd30 */ TBL(4)|290, TBL(4)|283, TBL(4)|291, TBL(4)|308, TBL(4)|278, TBL(4)|279, TBL(4)|280, TBL(4)|286, +/* fd38 */ TBL(4)|287, TBL(4)|288, TBL(4)|308, TBL(4)|311, TBL(4)|230, TBL(4)|230, 0, 0, +/* fd40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fd48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fd50 */ (uint16_t)-1 /*TBL(6)|106*/, (uint16_t)-1 /*TBL(6)|109*/, (uint16_t)-1 /*TBL(6)|109*/, (uint16_t)-1 /*TBL(6)|110*/, (uint16_t)-1 /*TBL(6)|111*/, (uint16_t)-1 /*TBL(6)|114*/, (uint16_t)-1 /*TBL(6)|115*/, (uint16_t)-1 /*TBL(6)|116*/, +/* fd58 */ (uint16_t)-1 /*TBL(6)|121*/, (uint16_t)-1 /*TBL(6)|121*/, (uint16_t)-1 /*TBL(6)|126*/, (uint16_t)-1 /*TBL(6)|125*/, (uint16_t)-1 /*TBL(6)|129*/, (uint16_t)-1 /*TBL(6)|127*/, (uint16_t)-1 /*TBL(6)|128*/, (uint16_t)-1 /*TBL(6)|133*/, +/* fd60 */ (uint16_t)-1 /*TBL(6)|133*/, (uint16_t)-1 /*TBL(6)|132*/, (uint16_t)-1 /*TBL(6)|134*/, (uint16_t)-1 /*TBL(6)|134*/, (uint16_t)-1 /*TBL(6)|140*/, (uint16_t)-1 /*TBL(6)|140*/, (uint16_t)-1 /*TBL(6)|144*/, (uint16_t)-1 /*TBL(6)|136*/, +/* fd68 */ (uint16_t)-1 /*TBL(6)|136*/, (uint16_t)-1 /*TBL(6)|135*/, (uint16_t)-1 /*TBL(6)|138*/, (uint16_t)-1 /*TBL(6)|138*/, (uint16_t)-1 /*TBL(6)|139*/, (uint16_t)-1 /*TBL(6)|139*/, (uint16_t)-1 /*TBL(6)|145*/, (uint16_t)-1 /*TBL(6)|147*/, +/* fd70 */ (uint16_t)-1 /*TBL(6)|147*/, (uint16_t)-1 /*TBL(6)|148*/, (uint16_t)-1 /*TBL(6)|148*/, (uint16_t)-1 /*TBL(6)|149*/, (uint16_t)-1 /*TBL(6)|150*/, (uint16_t)-1 /*TBL(6)|151*/, (uint16_t)-1 /*TBL(6)|152*/, (uint16_t)-1 /*TBL(6)|152*/, +/* fd78 */ (uint16_t)-1 /*TBL(6)|153*/, (uint16_t)-1 /*TBL(6)|155*/, (uint16_t)-1 /*TBL(6)|157*/, (uint16_t)-1 /*TBL(6)|156*/, (uint16_t)-1 /*TBL(6)|161*/, (uint16_t)-1 /*TBL(6)|161*/, (uint16_t)-1 /*TBL(6)|164*/, (uint16_t)-1 /*TBL(6)|165*/, +/* fd80 */ (uint16_t)-1 /*TBL(6)|175*/, (uint16_t)-1 /*TBL(6)|177*/, (uint16_t)-1 /*TBL(6)|176*/, (uint16_t)-1 /*TBL(6)|172*/, (uint16_t)-1 /*TBL(6)|172*/, (uint16_t)-1 /*TBL(6)|178*/, (uint16_t)-1 /*TBL(6)|178*/, (uint16_t)-1 /*TBL(6)|179*/, +/* fd88 */ (uint16_t)-1 /*TBL(6)|179*/, (uint16_t)-1 /*TBL(6)|185*/, (uint16_t)-1 /*TBL(6)|186*/, (uint16_t)-1 /*TBL(6)|187*/, (uint16_t)-1 /*TBL(6)|181*/, (uint16_t)-1 /*TBL(6)|183*/, (uint16_t)-1 /*TBL(6)|188*/, (uint16_t)-1 /*TBL(6)|189*/, +/* fd90 */ 0, 0, (uint16_t)-1 /*TBL(6)|182*/, (uint16_t)-1 /*TBL(6)|201*/, (uint16_t)-1 /*TBL(6)|202*/, (uint16_t)-1 /*TBL(6)|196*/, (uint16_t)-1 /*TBL(6)|197*/, (uint16_t)-1 /*TBL(6)|193*/, +/* fd98 */ (uint16_t)-1 /*TBL(6)|193*/, (uint16_t)-1 /*TBL(6)|194*/, (uint16_t)-1 /*TBL(6)|200*/, (uint16_t)-1 /*TBL(6)|199*/, (uint16_t)-1 /*TBL(6)|205*/, (uint16_t)-1 /*TBL(6)|205*/, (uint16_t)-1 /*TBL(6)|105*/, (uint16_t)-1 /*TBL(6)|108*/, +/* fda0 */ (uint16_t)-1 /*TBL(6)|107*/, (uint16_t)-1 /*TBL(6)|113*/, (uint16_t)-1 /*TBL(6)|112*/, (uint16_t)-1 /*TBL(6)|118*/, (uint16_t)-1 /*TBL(6)|117*/, (uint16_t)-1 /*TBL(6)|123*/, (uint16_t)-1 /*TBL(6)|119*/, (uint16_t)-1 /*TBL(6)|122*/, +/* fda8 */ (uint16_t)-1 /*TBL(6)|130*/, (uint16_t)-1 /*TBL(6)|141*/, (uint16_t)-1 /*TBL(6)|137*/, (uint16_t)-1 /*TBL(6)|146*/, (uint16_t)-1 /*TBL(6)|174*/, (uint16_t)-1 /*TBL(6)|180*/, (uint16_t)-1 /*TBL(6)|204*/, (uint16_t)-1 /*TBL(6)|203*/, +/* fdb0 */ (uint16_t)-1 /*TBL(6)|206*/, (uint16_t)-1 /*TBL(6)|191*/, (uint16_t)-1 /*TBL(6)|166*/, (uint16_t)-1 /*TBL(6)|198*/, (uint16_t)-1 /*TBL(6)|164*/, (uint16_t)-1 /*TBL(6)|175*/, (uint16_t)-1 /*TBL(6)|154*/, (uint16_t)-1 /*TBL(6)|168*/, +/* fdb8 */ (uint16_t)-1 /*TBL(6)|192*/, (uint16_t)-1 /*TBL(6)|190*/, (uint16_t)-1 /*TBL(6)|173*/, (uint16_t)-1 /*TBL(6)|167*/, (uint16_t)-1 /*TBL(6)|173*/, (uint16_t)-1 /*TBL(6)|192*/, (uint16_t)-1 /*TBL(6)|120*/, (uint16_t)-1 /*TBL(6)|124*/, +/* fdc0 */ (uint16_t)-1 /*TBL(6)|184*/, (uint16_t)-1 /*TBL(6)|162*/, (uint16_t)-1 /*TBL(6)|104*/, (uint16_t)-1 /*TBL(6)|167*/, (uint16_t)-1 /*TBL(6)|151*/, (uint16_t)-1 /*TBL(6)|144*/, (uint16_t)-1 /*TBL(6)|131*/, (uint16_t)-1 /*TBL(6)|195*/, +/* fdc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fdd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fdd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fde0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fde8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fdf0 */ (uint16_t)-1 /*TBL(6)|143*/, (uint16_t)-1 /*TBL(6)|163*/, (uint16_t)-1 /*TBL(8)|52*/, (uint16_t)-1 /*TBL(8)|51*/, (uint16_t)-1 /*TBL(8)|57*/, (uint16_t)-1 /*TBL(8)|55*/, (uint16_t)-1 /*TBL(8)|53*/, (uint16_t)-1 /*TBL(8)|56*/, +/* fdf8 */ (uint16_t)-1 /*TBL(8)|58*/, (uint16_t)-1 /*TBL(6)|142*/, (uint16_t)-1 /*TBL(33)|0*/, (uint16_t)-1 /*TBL(15)|0*/, (uint16_t)-1 /*TBL(8)|54*/, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_fe [256] = { +/* fe00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe10 */ TBL(1)|10, TBL(3)|437, TBL(3)|438, TBL(1)|24, TBL(1)|25, TBL(1)|0, TBL(1)|29, TBL(3)|452, +/* fe18 */ TBL(3)|453, TBL(3)|61, 0, 0, 0, 0, 0, 0, +/* fe20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fe30 */ TBL(2)|2, TBL(3)|421, TBL(3)|420, TBL(1)|63, TBL(1)|63, TBL(1)|6, TBL(1)|7, TBL(1)|91, +/* fe38 */ TBL(1)|93, TBL(3)|450, TBL(3)|451, TBL(3)|447, TBL(3)|448, TBL(3)|441, TBL(3)|442, TBL(3)|439, +/* fe40 */ TBL(3)|440, TBL(3)|443, TBL(3)|444, TBL(3)|445, TBL(3)|446, 0, 0, TBL(1)|57, +/* fe48 */ TBL(1)|61, TBL(3)|283, TBL(3)|283, TBL(3)|283, TBL(3)|283, TBL(1)|63, TBL(1)|63, TBL(1)|63, +/* fe50 */ TBL(1)|10, TBL(3)|437, TBL(1)|12, 0, TBL(1)|25, TBL(1)|24, TBL(1)|29, TBL(1)|0, +/* fe58 */ TBL(3)|421, TBL(1)|6, TBL(1)|7, TBL(1)|91, TBL(1)|93, TBL(3)|450, TBL(3)|451, TBL(1)|2, +/* fe60 */ TBL(1)|5, TBL(1)|8, TBL(1)|9, TBL(1)|11, TBL(1)|26, TBL(1)|28, TBL(1)|27, 0, +/* fe68 */ TBL(1)|60, TBL(1)|3, TBL(1)|4, TBL(1)|30, 0, 0, 0, 0, +/* fe70 */ TBL(3)|296, TBL(4)|320, TBL(3)|297, 0, TBL(3)|298, 0, TBL(3)|299, TBL(4)|321, +/* fe78 */ TBL(3)|300, TBL(4)|322, TBL(3)|301, TBL(4)|323, TBL(3)|302, TBL(4)|324, TBL(3)|303, TBL(4)|325, +/* fe80 */ TBL(2)|241, TBL(4)|231, TBL(4)|231, TBL(4)|232, TBL(4)|232, TBL(4)|374, TBL(4)|374, TBL(4)|233, +/* fe88 */ TBL(4)|233, TBL(4)|387, TBL(4)|387, TBL(4)|387, TBL(4)|387, TBL(2)|242, TBL(2)|242, TBL(2)|243, +/* fe90 */ TBL(2)|243, TBL(2)|243, TBL(2)|243, TBL(2)|244, TBL(2)|244, TBL(2)|245, TBL(2)|245, TBL(2)|245, +/* fe98 */ TBL(2)|245, TBL(2)|246, TBL(2)|246, TBL(2)|246, TBL(2)|246, TBL(2)|247, TBL(2)|247, TBL(2)|247, +/* fea0 */ TBL(2)|247, TBL(2)|248, TBL(2)|248, TBL(2)|248, TBL(2)|248, TBL(2)|249, TBL(2)|249, TBL(2)|249, +/* fea8 */ TBL(2)|249, TBL(2)|250, TBL(2)|250, TBL(2)|251, TBL(2)|251, TBL(2)|252, TBL(2)|252, TBL(2)|253, +/* feb0 */ TBL(2)|253, TBL(2)|254, TBL(2)|254, TBL(2)|254, TBL(2)|254, TBL(2)|255, TBL(2)|255, TBL(2)|255, +/* feb8 */ TBL(2)|255, TBL(2)|256, TBL(2)|256, TBL(2)|256, TBL(2)|256, TBL(2)|257, TBL(2)|257, TBL(2)|257, +/* fec0 */ TBL(2)|257, TBL(2)|258, TBL(2)|258, TBL(2)|258, TBL(2)|258, TBL(2)|259, TBL(2)|259, TBL(2)|259, +/* fec8 */ TBL(2)|259, TBL(2)|260, TBL(2)|260, TBL(2)|260, TBL(2)|260, TBL(2)|261, TBL(2)|261, TBL(2)|261, +/* fed0 */ TBL(2)|261, TBL(2)|262, TBL(2)|262, TBL(2)|262, TBL(2)|262, TBL(2)|263, TBL(2)|263, TBL(2)|263, +/* fed8 */ TBL(2)|263, TBL(2)|264, TBL(2)|264, TBL(2)|264, TBL(2)|264, TBL(2)|265, TBL(2)|265, TBL(2)|265, +/* fee0 */ TBL(2)|265, TBL(2)|266, TBL(2)|266, TBL(2)|266, TBL(2)|266, TBL(2)|267, TBL(2)|267, TBL(2)|267, +/* fee8 */ TBL(2)|267, TBL(2)|268, TBL(2)|268, TBL(2)|268, TBL(2)|268, TBL(2)|269, TBL(2)|269, TBL(2)|270, +/* fef0 */ TBL(2)|270, TBL(2)|271, TBL(2)|271, TBL(2)|271, TBL(2)|271, (uint16_t)-1 /*TBL(6)|169*/, (uint16_t)-1 /*TBL(6)|169*/, (uint16_t)-1 /*TBL(6)|170*/, +/* fef8 */ (uint16_t)-1 /*TBL(6)|170*/, (uint16_t)-1 /*TBL(6)|171*/, (uint16_t)-1 /*TBL(6)|171*/, TBL(4)|344, TBL(4)|344, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_00_ff [256] = { +/* ff00 */ 0, TBL(1)|0, TBL(1)|1, TBL(1)|2, TBL(1)|3, TBL(1)|4, TBL(1)|5, TBL(1)|59, +/* ff08 */ TBL(1)|6, TBL(1)|7, TBL(1)|8, TBL(1)|9, TBL(1)|10, TBL(1)|11, TBL(1)|12, TBL(1)|13, +/* ff10 */ TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, +/* ff18 */ TBL(1)|22, TBL(1)|23, TBL(1)|24, TBL(1)|25, TBL(1)|26, TBL(1)|27, TBL(1)|28, TBL(1)|29, +/* ff20 */ TBL(1)|30, TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, +/* ff28 */ TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, +/* ff30 */ TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, +/* ff38 */ TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|57, TBL(1)|60, TBL(1)|61, TBL(1)|62, TBL(1)|63, +/* ff40 */ TBL(1)|64, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, +/* ff48 */ TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, +/* ff50 */ TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, +/* ff58 */ TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|91, TBL(1)|92, TBL(1)|93, TBL(1)|94, TBL(3)|434, +/* ff60 */ TBL(3)|435, TBL(3)|438, TBL(3)|443, TBL(3)|444, TBL(3)|437, TBL(3)|513, TBL(3)|511, TBL(3)|456, +/* ff68 */ TBL(3)|458, TBL(3)|460, TBL(3)|462, TBL(3)|464, TBL(3)|497, TBL(3)|499, TBL(3)|501, TBL(3)|478, +/* ff70 */ TBL(3)|514, TBL(3)|457, TBL(3)|459, TBL(3)|461, TBL(3)|463, TBL(3)|465, TBL(3)|466, TBL(3)|467, +/* ff78 */ TBL(3)|468, TBL(3)|469, TBL(3)|470, TBL(3)|471, TBL(3)|472, TBL(3)|473, TBL(3)|474, TBL(3)|475, +/* ff80 */ TBL(3)|476, TBL(3)|477, TBL(3)|479, TBL(3)|480, TBL(3)|481, TBL(3)|482, TBL(3)|483, TBL(3)|484, +/* ff88 */ TBL(3)|485, TBL(3)|486, TBL(3)|487, TBL(3)|488, TBL(3)|489, TBL(3)|490, TBL(3)|491, TBL(3)|492, +/* ff90 */ TBL(3)|493, TBL(3)|494, TBL(3)|495, TBL(3)|496, TBL(3)|498, TBL(3)|500, TBL(3)|502, TBL(3)|503, +/* ff98 */ TBL(3)|504, TBL(3)|505, TBL(3)|506, TBL(3)|507, TBL(3)|508, TBL(3)|512, TBL(3)|454, TBL(3)|455, +/* ffa0 */ TBL(3)|361, TBL(3)|317, TBL(3)|318, TBL(3)|391, TBL(3)|319, TBL(3)|392, TBL(3)|393, TBL(3)|320, +/* ffa8 */ TBL(3)|321, TBL(3)|322, TBL(3)|394, TBL(3)|395, TBL(3)|396, TBL(3)|397, TBL(3)|398, TBL(3)|399, +/* ffb0 */ TBL(3)|338, TBL(3)|323, TBL(3)|324, TBL(3)|325, TBL(3)|343, TBL(3)|326, TBL(3)|327, TBL(3)|328, +/* ffb8 */ TBL(3)|329, TBL(3)|330, TBL(3)|331, TBL(3)|332, TBL(3)|333, TBL(3)|334, TBL(3)|335, 0, +/* ffc0 */ 0, 0, TBL(3)|362, TBL(3)|363, TBL(3)|364, TBL(3)|365, TBL(3)|366, TBL(3)|367, +/* ffc8 */ 0, 0, TBL(3)|368, TBL(3)|369, TBL(3)|370, TBL(3)|371, TBL(3)|372, TBL(3)|373, +/* ffd0 */ 0, 0, TBL(3)|374, TBL(3)|375, TBL(3)|376, TBL(3)|377, TBL(3)|378, TBL(3)|379, +/* ffd8 */ 0, 0, TBL(3)|380, TBL(3)|381, TBL(3)|382, 0, 0, 0, +/* ffe0 */ TBL(2)|112, TBL(2)|113, TBL(2)|116, TBL(3)|282, TBL(2)|115, TBL(2)|114, TBL(3)|422, 0, +/* ffe8 */ TBL(3)|431, TBL(3)|423, TBL(3)|424, TBL(3)|425, TBL(3)|426, TBL(3)|432, TBL(3)|433, 0, +/* fff0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* fff8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_10 [256] = { +/* 011000 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011008 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011010 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011018 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011020 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011028 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011030 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011038 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011040 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011048 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011050 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011058 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011060 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011068 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011070 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011078 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011080 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011088 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011090 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011098 */ 0, 0, (uint16_t)-1 /*TBL(8)|59*/, 0, (uint16_t)-1 /*TBL(8)|60*/, 0, 0, 0, +/* 0110a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110a8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|61*/, 0, 0, 0, 0, +/* 0110b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0110f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_11 [256] = { +/* 011100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011128 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(8)|62*/, (uint16_t)-1 /*TBL(8)|63*/, +/* 011130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0111f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_13 [256] = { +/* 011300 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011308 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011310 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011318 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011320 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011328 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011330 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011338 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011340 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011348 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|64*/, (uint16_t)-1 /*TBL(8)|65*/, 0, 0, 0, +/* 011350 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011358 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011360 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011368 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011370 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011378 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011380 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011388 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011390 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011398 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0113f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_14 [256] = { +/* 011400 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011408 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011410 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011418 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011420 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011428 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011430 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011438 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011440 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011448 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011450 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011458 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011460 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011468 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011470 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011478 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011480 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011488 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011490 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011498 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114b8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|67*/, (uint16_t)-1 /*TBL(8)|66*/, 0, (uint16_t)-1 /*TBL(8)|68*/, 0, +/* 0114c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0114f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_15 [256] = { +/* 011500 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011508 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011510 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011518 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011520 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011528 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011530 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011538 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011540 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011548 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011550 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011558 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011560 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011568 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011570 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011578 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011580 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011588 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011590 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011598 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115b8 */ 0, 0, (uint16_t)-1 /*TBL(8)|69*/, (uint16_t)-1 /*TBL(8)|70*/, 0, 0, 0, 0, +/* 0115c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0115f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_19 [256] = { +/* 011900 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011908 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011910 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011918 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011920 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011928 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011930 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011938 */ (uint16_t)-1 /*TBL(8)|71*/, 0, 0, 0, 0, 0, 0, 0, +/* 011940 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011948 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011950 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011958 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011960 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011968 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011970 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011978 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011980 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011988 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011990 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 011998 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 0119f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_d1 [256] = { +/* 01d100 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d108 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d110 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d118 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d120 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d128 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d130 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d138 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d140 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d148 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d158 */ 0, 0, 0, 0, 0, 0, (uint16_t)-1 /*TBL(8)|72*/, (uint16_t)-1 /*TBL(8)|73*/, +/* 01d160 */ (uint16_t)-1 /*TBL(12)|31*/, (uint16_t)-1 /*TBL(12)|32*/, (uint16_t)-1 /*TBL(12)|33*/, (uint16_t)-1 /*TBL(12)|34*/, (uint16_t)-1 /*TBL(12)|35*/, 0, 0, 0, +/* 01d168 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d190 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1b8 */ 0, 0, 0, (uint16_t)-1 /*TBL(8)|74*/, (uint16_t)-1 /*TBL(8)|75*/, (uint16_t)-1 /*TBL(12)|36*/, (uint16_t)-1 /*TBL(12)|38*/, (uint16_t)-1 /*TBL(12)|37*/, +/* 01d1c0 */ (uint16_t)-1 /*TBL(12)|39*/, 0, 0, 0, 0, 0, 0, 0, +/* 01d1c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01d1f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_d4 [256] = { +/* 01d400 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d408 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d410 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d418 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d420 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d428 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d430 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, +/* 01d438 */ TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, +/* 01d440 */ TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, +/* 01d448 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, +/* 01d450 */ TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, 0, TBL(1)|73, TBL(1)|74, +/* 01d458 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, +/* 01d460 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d468 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d470 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d478 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d480 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d488 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d490 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d498 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, 0, TBL(1)|33, TBL(1)|34, +/* 01d4a0 */ 0, 0, TBL(1)|37, 0, 0, TBL(1)|40, TBL(1)|41, 0, +/* 01d4a8 */ 0, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, 0, TBL(1)|49, TBL(1)|50, +/* 01d4b0 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, +/* 01d4b8 */ TBL(1)|67, TBL(1)|68, 0, TBL(1)|70, 0, TBL(1)|72, TBL(1)|73, TBL(1)|74, +/* 01d4c0 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, 0, TBL(1)|80, TBL(1)|81, TBL(1)|82, +/* 01d4c8 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d4d0 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d4d8 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d4e0 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d4e8 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d4f0 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d4f8 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86 +}; + +static const uint16_t UN8IF_compat_01_d5 [256] = { +/* 01d500 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, TBL(1)|32, 0, TBL(1)|34, +/* 01d508 */ TBL(1)|35, TBL(1)|36, TBL(1)|37, 0, 0, TBL(1)|40, TBL(1)|41, TBL(1)|42, +/* 01d510 */ TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, 0, TBL(1)|49, TBL(1)|50, +/* 01d518 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, 0, TBL(1)|65, TBL(1)|66, +/* 01d520 */ TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, +/* 01d528 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, +/* 01d530 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d538 */ TBL(1)|31, TBL(1)|32, 0, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, 0, +/* 01d540 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, 0, TBL(1)|45, 0, +/* 01d548 */ 0, 0, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d550 */ TBL(1)|55, 0, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d558 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d560 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d568 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, +/* 01d570 */ TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, +/* 01d578 */ TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, +/* 01d580 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, +/* 01d588 */ TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, +/* 01d590 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, +/* 01d598 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d5a0 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d5a8 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d5b0 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d5b8 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d5c0 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d5c8 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d5d0 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, +/* 01d5d8 */ TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, +/* 01d5e0 */ TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, +/* 01d5e8 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, +/* 01d5f0 */ TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, +/* 01d5f8 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82 +}; + +static const uint16_t UN8IF_compat_01_d6 [256] = { +/* 01d600 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d608 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d610 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d618 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d620 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d628 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d630 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d638 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, +/* 01d640 */ TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, +/* 01d648 */ TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, +/* 01d650 */ TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, +/* 01d658 */ TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, +/* 01d660 */ TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, +/* 01d668 */ TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, +/* 01d670 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01d678 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01d680 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01d688 */ TBL(1)|55, TBL(1)|56, TBL(1)|65, TBL(1)|66, TBL(1)|67, TBL(1)|68, TBL(1)|69, TBL(1)|70, +/* 01d690 */ TBL(1)|71, TBL(1)|72, TBL(1)|73, TBL(1)|74, TBL(1)|75, TBL(1)|76, TBL(1)|77, TBL(1)|78, +/* 01d698 */ TBL(1)|79, TBL(1)|80, TBL(1)|81, TBL(1)|82, TBL(1)|83, TBL(1)|84, TBL(1)|85, TBL(1)|86, +/* 01d6a0 */ TBL(1)|87, TBL(1)|88, TBL(1)|89, TBL(1)|90, TBL(2)|122, TBL(2)|129, 0, 0, +/* 01d6a8 */ TBL(2)|176, TBL(2)|177, TBL(2)|178, TBL(2)|179, TBL(2)|180, TBL(2)|181, TBL(2)|182, TBL(2)|183, +/* 01d6b0 */ TBL(2)|184, TBL(2)|185, TBL(2)|186, TBL(2)|187, TBL(2)|188, TBL(2)|189, TBL(2)|190, TBL(2)|191, +/* 01d6b8 */ TBL(2)|192, TBL(2)|183, TBL(2)|193, TBL(2)|194, TBL(2)|195, TBL(2)|196, TBL(2)|197, TBL(2)|198, +/* 01d6c0 */ TBL(2)|199, TBL(3)|428, TBL(2)|200, TBL(2)|201, TBL(2)|202, TBL(2)|203, TBL(2)|204, TBL(2)|205, +/* 01d6c8 */ TBL(2)|206, TBL(2)|207, TBL(2)|208, TBL(2)|209, TBL(2)|210, TBL(2)|211, TBL(2)|212, TBL(2)|213, +/* 01d6d0 */ TBL(2)|214, TBL(2)|215, TBL(2)|216, TBL(2)|217, TBL(2)|218, TBL(2)|219, TBL(2)|220, TBL(2)|221, +/* 01d6d8 */ TBL(2)|222, TBL(2)|223, TBL(2)|224, TBL(3)|427, TBL(2)|204, TBL(2)|207, TBL(2)|209, TBL(2)|221, +/* 01d6e0 */ TBL(2)|216, TBL(2)|215, TBL(2)|176, TBL(2)|177, TBL(2)|178, TBL(2)|179, TBL(2)|180, TBL(2)|181, +/* 01d6e8 */ TBL(2)|182, TBL(2)|183, TBL(2)|184, TBL(2)|185, TBL(2)|186, TBL(2)|187, TBL(2)|188, TBL(2)|189, +/* 01d6f0 */ TBL(2)|190, TBL(2)|191, TBL(2)|192, TBL(2)|183, TBL(2)|193, TBL(2)|194, TBL(2)|195, TBL(2)|196, +/* 01d6f8 */ TBL(2)|197, TBL(2)|198, TBL(2)|199, TBL(3)|428, TBL(2)|200, TBL(2)|201, TBL(2)|202, TBL(2)|203 +}; + +static const uint16_t UN8IF_compat_01_d7 [256] = { +/* 01d700 */ TBL(2)|204, TBL(2)|205, TBL(2)|206, TBL(2)|207, TBL(2)|208, TBL(2)|209, TBL(2)|210, TBL(2)|211, +/* 01d708 */ TBL(2)|212, TBL(2)|213, TBL(2)|214, TBL(2)|215, TBL(2)|216, TBL(2)|217, TBL(2)|218, TBL(2)|219, +/* 01d710 */ TBL(2)|220, TBL(2)|221, TBL(2)|222, TBL(2)|223, TBL(2)|224, TBL(3)|427, TBL(2)|204, TBL(2)|207, +/* 01d718 */ TBL(2)|209, TBL(2)|221, TBL(2)|216, TBL(2)|215, TBL(2)|176, TBL(2)|177, TBL(2)|178, TBL(2)|179, +/* 01d720 */ TBL(2)|180, TBL(2)|181, TBL(2)|182, TBL(2)|183, TBL(2)|184, TBL(2)|185, TBL(2)|186, TBL(2)|187, +/* 01d728 */ TBL(2)|188, TBL(2)|189, TBL(2)|190, TBL(2)|191, TBL(2)|192, TBL(2)|183, TBL(2)|193, TBL(2)|194, +/* 01d730 */ TBL(2)|195, TBL(2)|196, TBL(2)|197, TBL(2)|198, TBL(2)|199, TBL(3)|428, TBL(2)|200, TBL(2)|201, +/* 01d738 */ TBL(2)|202, TBL(2)|203, TBL(2)|204, TBL(2)|205, TBL(2)|206, TBL(2)|207, TBL(2)|208, TBL(2)|209, +/* 01d740 */ TBL(2)|210, TBL(2)|211, TBL(2)|212, TBL(2)|213, TBL(2)|214, TBL(2)|215, TBL(2)|216, TBL(2)|217, +/* 01d748 */ TBL(2)|218, TBL(2)|219, TBL(2)|220, TBL(2)|221, TBL(2)|222, TBL(2)|223, TBL(2)|224, TBL(3)|427, +/* 01d750 */ TBL(2)|204, TBL(2)|207, TBL(2)|209, TBL(2)|221, TBL(2)|216, TBL(2)|215, TBL(2)|176, TBL(2)|177, +/* 01d758 */ TBL(2)|178, TBL(2)|179, TBL(2)|180, TBL(2)|181, TBL(2)|182, TBL(2)|183, TBL(2)|184, TBL(2)|185, +/* 01d760 */ TBL(2)|186, TBL(2)|187, TBL(2)|188, TBL(2)|189, TBL(2)|190, TBL(2)|191, TBL(2)|192, TBL(2)|183, +/* 01d768 */ TBL(2)|193, TBL(2)|194, TBL(2)|195, TBL(2)|196, TBL(2)|197, TBL(2)|198, TBL(2)|199, TBL(3)|428, +/* 01d770 */ TBL(2)|200, TBL(2)|201, TBL(2)|202, TBL(2)|203, TBL(2)|204, TBL(2)|205, TBL(2)|206, TBL(2)|207, +/* 01d778 */ TBL(2)|208, TBL(2)|209, TBL(2)|210, TBL(2)|211, TBL(2)|212, TBL(2)|213, TBL(2)|214, TBL(2)|215, +/* 01d780 */ TBL(2)|216, TBL(2)|217, TBL(2)|218, TBL(2)|219, TBL(2)|220, TBL(2)|221, TBL(2)|222, TBL(2)|223, +/* 01d788 */ TBL(2)|224, TBL(3)|427, TBL(2)|204, TBL(2)|207, TBL(2)|209, TBL(2)|221, TBL(2)|216, TBL(2)|215, +/* 01d790 */ TBL(2)|176, TBL(2)|177, TBL(2)|178, TBL(2)|179, TBL(2)|180, TBL(2)|181, TBL(2)|182, TBL(2)|183, +/* 01d798 */ TBL(2)|184, TBL(2)|185, TBL(2)|186, TBL(2)|187, TBL(2)|188, TBL(2)|189, TBL(2)|190, TBL(2)|191, +/* 01d7a0 */ TBL(2)|192, TBL(2)|183, TBL(2)|193, TBL(2)|194, TBL(2)|195, TBL(2)|196, TBL(2)|197, TBL(2)|198, +/* 01d7a8 */ TBL(2)|199, TBL(3)|428, TBL(2)|200, TBL(2)|201, TBL(2)|202, TBL(2)|203, TBL(2)|204, TBL(2)|205, +/* 01d7b0 */ TBL(2)|206, TBL(2)|207, TBL(2)|208, TBL(2)|209, TBL(2)|210, TBL(2)|211, TBL(2)|212, TBL(2)|213, +/* 01d7b8 */ TBL(2)|214, TBL(2)|215, TBL(2)|216, TBL(2)|217, TBL(2)|218, TBL(2)|219, TBL(2)|220, TBL(2)|221, +/* 01d7c0 */ TBL(2)|222, TBL(2)|223, TBL(2)|224, TBL(3)|427, TBL(2)|204, TBL(2)|207, TBL(2)|209, TBL(2)|221, +/* 01d7c8 */ TBL(2)|216, TBL(2)|215, TBL(2)|225, TBL(2)|226, 0, 0, TBL(1)|14, TBL(1)|15, +/* 01d7d0 */ TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, TBL(1)|22, TBL(1)|23, +/* 01d7d8 */ TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, +/* 01d7e0 */ TBL(1)|22, TBL(1)|23, TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, +/* 01d7e8 */ TBL(1)|20, TBL(1)|21, TBL(1)|22, TBL(1)|23, TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, +/* 01d7f0 */ TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, TBL(1)|22, TBL(1)|23, TBL(1)|14, TBL(1)|15, +/* 01d7f8 */ TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, TBL(1)|22, TBL(1)|23 +}; + +static const uint16_t UN8IF_compat_01_ee [256] = { +/* 01ee00 */ TBL(2)|242, TBL(2)|243, TBL(2)|247, TBL(2)|250, 0, TBL(2)|269, TBL(2)|253, TBL(2)|248, +/* 01ee08 */ TBL(2)|258, TBL(2)|271, TBL(2)|264, TBL(2)|265, TBL(2)|266, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01ee10 */ TBL(2)|262, TBL(2)|256, TBL(2)|263, TBL(2)|252, TBL(2)|255, TBL(2)|245, TBL(2)|246, TBL(2)|249, +/* 01ee18 */ TBL(2)|251, TBL(2)|257, TBL(2)|259, TBL(2)|261, TBL(2)|272, TBL(2)|299, TBL(2)|291, TBL(2)|273, +/* 01ee20 */ 0, TBL(2)|243, TBL(2)|247, 0, TBL(2)|268, 0, 0, TBL(2)|248, +/* 01ee28 */ 0, TBL(2)|271, TBL(2)|264, TBL(2)|265, TBL(2)|266, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01ee30 */ TBL(2)|262, TBL(2)|256, TBL(2)|263, 0, TBL(2)|255, TBL(2)|245, TBL(2)|246, TBL(2)|249, +/* 01ee38 */ 0, TBL(2)|257, 0, TBL(2)|261, 0, 0, 0, 0, +/* 01ee40 */ 0, 0, TBL(2)|247, 0, 0, 0, 0, TBL(2)|248, +/* 01ee48 */ 0, TBL(2)|271, 0, TBL(2)|265, 0, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01ee50 */ 0, TBL(2)|256, TBL(2)|263, 0, TBL(2)|255, 0, 0, TBL(2)|249, +/* 01ee58 */ 0, TBL(2)|257, 0, TBL(2)|261, 0, TBL(2)|299, 0, TBL(2)|273, +/* 01ee60 */ 0, TBL(2)|243, TBL(2)|247, 0, TBL(2)|268, 0, 0, TBL(2)|248, +/* 01ee68 */ TBL(2)|258, TBL(2)|271, TBL(2)|264, 0, TBL(2)|266, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01ee70 */ TBL(2)|262, TBL(2)|256, TBL(2)|263, 0, TBL(2)|255, TBL(2)|245, TBL(2)|246, TBL(2)|249, +/* 01ee78 */ 0, TBL(2)|257, TBL(2)|259, TBL(2)|261, TBL(2)|272, 0, TBL(2)|291, 0, +/* 01ee80 */ TBL(2)|242, TBL(2)|243, TBL(2)|247, TBL(2)|250, TBL(2)|268, TBL(2)|269, TBL(2)|253, TBL(2)|248, +/* 01ee88 */ TBL(2)|258, TBL(2)|271, 0, TBL(2)|265, TBL(2)|266, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01ee90 */ TBL(2)|262, TBL(2)|256, TBL(2)|263, TBL(2)|252, TBL(2)|255, TBL(2)|245, TBL(2)|246, TBL(2)|249, +/* 01ee98 */ TBL(2)|251, TBL(2)|257, TBL(2)|259, TBL(2)|261, 0, 0, 0, 0, +/* 01eea0 */ 0, TBL(2)|243, TBL(2)|247, TBL(2)|250, 0, TBL(2)|269, TBL(2)|253, TBL(2)|248, +/* 01eea8 */ TBL(2)|258, TBL(2)|271, 0, TBL(2)|265, TBL(2)|266, TBL(2)|267, TBL(2)|254, TBL(2)|260, +/* 01eeb0 */ TBL(2)|262, TBL(2)|256, TBL(2)|263, TBL(2)|252, TBL(2)|255, TBL(2)|245, TBL(2)|246, TBL(2)|249, +/* 01eeb8 */ TBL(2)|251, TBL(2)|257, TBL(2)|259, TBL(2)|261, 0, 0, 0, 0, +/* 01eec0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eec8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eed0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eed8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eee0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eee8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eef0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01eef8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_f1 [256] = { +/* 01f100 */ TBL(2)|4, TBL(2)|3, TBL(2)|5, TBL(2)|17, TBL(2)|29, TBL(2)|41, TBL(2)|53, TBL(2)|56, +/* 01f108 */ TBL(2)|58, TBL(2)|60, TBL(2)|62, 0, 0, 0, 0, 0, +/* 01f110 */ TBL(3)|9, TBL(3)|10, TBL(3)|11, TBL(3)|12, TBL(3)|13, TBL(3)|14, TBL(3)|15, TBL(3)|16, +/* 01f118 */ TBL(3)|17, TBL(3)|18, TBL(3)|19, TBL(3)|20, TBL(3)|21, TBL(3)|22, TBL(3)|23, TBL(3)|24, +/* 01f120 */ TBL(3)|25, TBL(3)|26, TBL(3)|27, TBL(3)|28, TBL(3)|29, TBL(3)|30, TBL(3)|31, TBL(3)|32, +/* 01f128 */ TBL(3)|33, TBL(3)|34, (uint16_t)-1 /*TBL(7)|0*/, TBL(1)|33, TBL(1)|48, TBL(2)|69, TBL(2)|109, 0, +/* 01f130 */ TBL(1)|31, TBL(1)|32, TBL(1)|33, TBL(1)|34, TBL(1)|35, TBL(1)|36, TBL(1)|37, TBL(1)|38, +/* 01f138 */ TBL(1)|39, TBL(1)|40, TBL(1)|41, TBL(1)|42, TBL(1)|43, TBL(1)|44, TBL(1)|45, TBL(1)|46, +/* 01f140 */ TBL(1)|47, TBL(1)|48, TBL(1)|49, TBL(1)|50, TBL(1)|51, TBL(1)|52, TBL(1)|53, TBL(1)|54, +/* 01f148 */ TBL(1)|55, TBL(1)|56, TBL(2)|76, TBL(2)|93, TBL(2)|102, TBL(2)|104, TBL(3)|206, TBL(2)|108, +/* 01f150 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f158 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f160 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f168 */ 0, 0, TBL(2)|90, TBL(2)|91, TBL(2)|92, 0, 0, 0, +/* 01f170 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f178 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f180 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f188 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f190 */ TBL(2)|70, 0, 0, 0, 0, 0, 0, 0, +/* 01f198 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f1f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_f2 [256] = { +/* 01f200 */ (uint16_t)-1 /*TBL(6)|342*/, (uint16_t)-1 /*TBL(6)|354*/, TBL(3)|471, 0, 0, 0, 0, 0, +/* 01f208 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f210 */ TBL(3)|922, TBL(3)|808, TBL(3)|715, (uint16_t)-1 /*TBL(6)|364*/, TBL(3)|605, TBL(3)|786, TBL(3)|1378, TBL(3)|790, +/* 01f218 */ TBL(3)|608, TBL(3)|972, TBL(3)|1090, TBL(3)|962, TBL(3)|672, TBL(3)|881, TBL(3)|646, TBL(3)|964, +/* 01f220 */ TBL(3)|667, TBL(3)|1244, TBL(3)|1143, TBL(3)|1401, TBL(3)|779, TBL(3)|729, TBL(3)|1071, TBL(3)|925, +/* 01f228 */ TBL(3)|936, TBL(3)|582, TBL(3)|585, TBL(3)|1433, TBL(3)|845, TBL(3)|592, TBL(3)|722, TBL(3)|933, +/* 01f230 */ TBL(3)|1411, TBL(3)|923, TBL(3)|1202, TBL(3)|1217, TBL(3)|724, TBL(3)|1063, TBL(3)|985, TBL(3)|984, +/* 01f238 */ TBL(3)|1148, TBL(3)|673, TBL(3)|748, TBL(3)|1447, 0, 0, 0, 0, +/* 01f240 */ (uint16_t)-1 /*TBL(9)|14*/, (uint16_t)-1 /*TBL(9)|8*/, (uint16_t)-1 /*TBL(9)|9*/, (uint16_t)-1 /*TBL(9)|11*/, (uint16_t)-1 /*TBL(9)|15*/, (uint16_t)-1 /*TBL(9)|12*/, (uint16_t)-1 /*TBL(9)|16*/, (uint16_t)-1 /*TBL(9)|10*/, +/* 01f248 */ (uint16_t)-1 /*TBL(9)|13*/, 0, 0, 0, 0, 0, 0, 0, +/* 01f250 */ TBL(3)|882, TBL(3)|720, 0, 0, 0, 0, 0, 0, +/* 01f258 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f260 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f268 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f270 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f278 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f280 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f288 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f290 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f298 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2a0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2a8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2b0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2b8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2c0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2c8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2d0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2d8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2e0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2e8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2f0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01f2f8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_01_fb [256] = { +/* 01fb00 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb08 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb10 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb18 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fb98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fba0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fba8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbb0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbb8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbc0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbc8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbd0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbd8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbe0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbe8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 01fbf0 */ TBL(1)|14, TBL(1)|15, TBL(1)|16, TBL(1)|17, TBL(1)|18, TBL(1)|19, TBL(1)|20, TBL(1)|21, +/* 01fbf8 */ TBL(1)|22, TBL(1)|23, 0, 0, 0, 0, 0, 0 +}; + +static const uint16_t UN8IF_compat_02_f8 [256] = { +/* 02f800 */ TBL(3)|597, TBL(3)|595, TBL(3)|599, TBL(4)|393, TBL(3)|616, TBL(3)|620, TBL(3)|621, TBL(3)|623, +/* 02f808 */ TBL(3)|625, TBL(3)|626, TBL(3)|629, TBL(3)|627, TBL(3)|515, TBL(4)|397, TBL(3)|634, TBL(3)|635, +/* 02f810 */ TBL(3)|636, TBL(3)|643, TBL(4)|394, TBL(3)|516, TBL(3)|638, TBL(3)|646, TBL(4)|396, TBL(3)|650, +/* 02f818 */ TBL(3)|652, TBL(3)|612, TBL(3)|654, TBL(3)|655, TBL(4)|491, TBL(3)|662, TBL(3)|664, TBL(3)|518, +/* 02f820 */ TBL(3)|670, TBL(3)|671, TBL(3)|673, TBL(3)|674, TBL(3)|519, TBL(3)|680, TBL(3)|681, TBL(3)|684, +/* 02f828 */ TBL(3)|687, TBL(3)|688, TBL(3)|689, TBL(3)|691, TBL(3)|699, TBL(3)|700, TBL(3)|702, TBL(3)|706, +/* 02f830 */ TBL(3)|708, TBL(3)|709, TBL(3)|709, TBL(3)|709, TBL(4)|400, TBL(3)|1083, TBL(3)|714, TBL(3)|716, +/* 02f838 */ TBL(4)|401, TBL(3)|719, TBL(3)|721, TBL(3)|723, TBL(3)|733, TBL(3)|728, TBL(3)|731, TBL(3)|732, +/* 02f840 */ TBL(3)|734, TBL(3)|736, TBL(3)|737, TBL(3)|739, TBL(3)|741, TBL(3)|742, TBL(3)|742, TBL(3)|744, +/* 02f848 */ TBL(3)|746, TBL(3)|747, TBL(3)|750, TBL(3)|759, TBL(3)|752, TBL(3)|760, TBL(3)|753, TBL(3)|755, +/* 02f850 */ TBL(3)|665, TBL(3)|778, TBL(3)|764, TBL(3)|765, TBL(3)|766, TBL(3)|763, TBL(3)|768, TBL(3)|767, +/* 02f858 */ TBL(3)|773, TBL(4)|402, TBL(3)|780, TBL(3)|781, TBL(3)|783, TBL(3)|786, TBL(3)|788, TBL(3)|795, +/* 02f860 */ TBL(4)|403, TBL(4)|404, TBL(3)|798, TBL(3)|799, TBL(3)|800, TBL(3)|797, TBL(3)|802, TBL(3)|520, +/* 02f868 */ TBL(3)|521, TBL(3)|804, TBL(3)|806, TBL(3)|806, TBL(4)|405, TBL(3)|813, TBL(3)|814, TBL(3)|815, +/* 02f870 */ TBL(3)|817, TBL(4)|406, TBL(3)|819, TBL(3)|820, TBL(3)|874, TBL(3)|822, TBL(3)|522, TBL(3)|825, +/* 02f878 */ TBL(3)|829, TBL(3)|832, TBL(3)|831, TBL(4)|408, TBL(3)|834, TBL(4)|409, TBL(3)|837, TBL(3)|836, +/* 02f880 */ TBL(3)|838, TBL(3)|842, TBL(3)|843, TBL(3)|523, TBL(3)|847, TBL(3)|849, TBL(3)|850, TBL(3)|851, +/* 02f888 */ TBL(3)|524, TBL(4)|410, TBL(3)|525, TBL(3)|858, TBL(3)|859, TBL(3)|860, TBL(3)|862, TBL(4)|501, +/* 02f890 */ TBL(3)|868, TBL(4)|412, TBL(4)|412, TBL(3)|1292, TBL(3)|872, TBL(3)|872, TBL(3)|526, TBL(4)|419, +/* 02f898 */ TBL(4)|461, TBL(3)|876, TBL(3)|878, TBL(3)|527, TBL(3)|883, TBL(3)|887, TBL(3)|888, TBL(3)|890, +/* 02f8a0 */ TBL(3)|894, TBL(3)|529, TBL(3)|528, TBL(3)|895, TBL(4)|413, TBL(3)|896, TBL(3)|901, TBL(3)|902, +/* 02f8a8 */ TBL(3)|903, TBL(3)|902, TBL(3)|906, TBL(3)|907, TBL(3)|911, TBL(3)|909, TBL(3)|910, TBL(3)|912, +/* 02f8b0 */ TBL(3)|913, TBL(3)|914, TBL(3)|917, TBL(3)|918, TBL(3)|924, TBL(3)|926, TBL(3)|930, TBL(3)|935, +/* 02f8b8 */ TBL(4)|416, TBL(3)|934, TBL(3)|931, TBL(3)|937, TBL(3)|939, TBL(3)|944, TBL(4)|417, TBL(3)|946, +/* 02f8c0 */ TBL(3)|943, TBL(3)|941, TBL(3)|530, TBL(3)|948, TBL(3)|950, TBL(3)|952, TBL(3)|949, TBL(3)|531, +/* 02f8c8 */ TBL(3)|956, TBL(3)|958, TBL(4)|418, TBL(3)|969, TBL(3)|982, TBL(3)|973, TBL(3)|534, TBL(3)|976, +/* 02f8d0 */ TBL(3)|533, TBL(3)|532, TBL(3)|647, TBL(3)|648, TBL(3)|983, TBL(3)|977, TBL(3)|1281, TBL(3)|559, +/* 02f8d8 */ TBL(3)|986, TBL(3)|987, TBL(3)|988, TBL(3)|993, TBL(3)|991, TBL(4)|423, TBL(3)|535, TBL(3)|998, +/* 02f8e0 */ TBL(3)|995, TBL(3)|1002, TBL(3)|1004, TBL(4)|425, TBL(3)|1005, TBL(3)|1000, TBL(3)|1007, TBL(3)|536, +/* 02f8e8 */ TBL(3)|1008, TBL(3)|1009, TBL(3)|1010, TBL(3)|1013, TBL(4)|426, TBL(3)|1015, TBL(3)|537, TBL(3)|1018, +/* 02f8f0 */ TBL(4)|427, TBL(3)|1019, TBL(3)|538, TBL(3)|1022, TBL(3)|1025, TBL(3)|1028, TBL(3)|1029, TBL(4)|428, +/* 02f8f8 */ TBL(4)|407, TBL(4)|429, TBL(3)|1037, TBL(4)|430, TBL(3)|1040, TBL(3)|1042, TBL(3)|1038, TBL(3)|1045 +}; + +static const uint16_t UN8IF_compat_02_f9 [256] = { +/* 02f900 */ TBL(3)|1049, TBL(3)|1053, TBL(3)|1050, TBL(3)|1051, TBL(3)|1054, TBL(3)|1055, TBL(4)|431, TBL(3)|1048, +/* 02f908 */ TBL(3)|1061, TBL(3)|1062, TBL(3)|539, TBL(3)|1067, TBL(3)|1066, TBL(4)|432, TBL(3)|1059, TBL(3)|1074, +/* 02f910 */ TBL(4)|433, TBL(4)|434, TBL(3)|1075, TBL(3)|1080, TBL(3)|1079, TBL(3)|1078, TBL(3)|540, TBL(3)|1081, +/* 02f918 */ TBL(3)|1085, TBL(3)|1084, TBL(3)|1087, TBL(4)|395, TBL(3)|1091, TBL(4)|435, TBL(3)|1094, TBL(4)|437, +/* 02f920 */ TBL(3)|1099, TBL(3)|1102, TBL(3)|1107, TBL(4)|438, TBL(3)|1112, TBL(3)|1113, TBL(4)|439, TBL(4)|440, +/* 02f928 */ TBL(3)|1120, TBL(3)|1124, TBL(3)|541, TBL(3)|1125, TBL(3)|542, TBL(3)|542, TBL(3)|1131, TBL(3)|1132, +/* 02f930 */ TBL(3)|1134, TBL(3)|1135, TBL(3)|1138, TBL(3)|543, TBL(3)|1144, TBL(4)|441, TBL(3)|1151, TBL(4)|442, +/* 02f938 */ TBL(3)|1154, TBL(4)|411, TBL(3)|1158, TBL(4)|443, TBL(4)|444, TBL(4)|445, TBL(3)|544, TBL(3)|545, +/* 02f940 */ TBL(3)|1172, TBL(4)|447, TBL(4)|446, TBL(4)|448, TBL(4)|449, TBL(3)|1174, TBL(3)|1175, TBL(3)|1175, +/* 02f948 */ TBL(3)|1177, TBL(3)|547, TBL(3)|1178, TBL(3)|548, TBL(3)|549, TBL(4)|451, TBL(3)|1183, TBL(3)|1185, +/* 02f950 */ TBL(3)|1188, TBL(3)|550, TBL(4)|452, TBL(3)|1197, TBL(4)|453, TBL(4)|454, TBL(3)|1205, TBL(3)|1211, +/* 02f958 */ TBL(3)|551, TBL(3)|1213, TBL(3)|1214, TBL(3)|1215, TBL(4)|455, TBL(4)|456, TBL(4)|456, TBL(3)|1221, +/* 02f960 */ TBL(3)|552, TBL(4)|457, TBL(3)|1226, TBL(3)|1227, TBL(3)|553, TBL(4)|458, TBL(3)|1234, TBL(3)|554, +/* 02f968 */ TBL(3)|1238, TBL(3)|1236, TBL(3)|1240, TBL(4)|460, TBL(3)|1246, TBL(3)|555, TBL(3)|1249, TBL(3)|1251, +/* 02f970 */ TBL(3)|1255, TBL(3)|556, TBL(4)|462, TBL(4)|463, TBL(3)|557, TBL(4)|464, TBL(3)|1261, TBL(4)|465, +/* 02f978 */ TBL(3)|1264, TBL(3)|1267, TBL(3)|1269, TBL(4)|466, TBL(4)|467, TBL(3)|1274, TBL(4)|468, TBL(3)|1276, +/* 02f980 */ TBL(4)|420, TBL(3)|558, TBL(3)|1282, TBL(3)|1283, TBL(3)|560, TBL(3)|1284, TBL(3)|803, TBL(4)|469, +/* 02f988 */ TBL(4)|470, TBL(4)|421, TBL(4)|422, TBL(3)|1292, TBL(3)|1293, TBL(3)|1427, TBL(3)|561, TBL(3)|1304, +/* 02f990 */ TBL(3)|1303, TBL(3)|1305, TBL(3)|678, TBL(3)|1306, TBL(3)|1307, TBL(3)|1308, TBL(3)|1310, TBL(4)|471, +/* 02f998 */ TBL(3)|1309, TBL(3)|1311, TBL(3)|1316, TBL(3)|1317, TBL(3)|1312, TBL(3)|1318, TBL(3)|1323, TBL(3)|1328, +/* 02f9a0 */ TBL(3)|1315, TBL(3)|1320, TBL(3)|1321, TBL(3)|1322, TBL(4)|472, TBL(4)|474, TBL(4)|473, TBL(3)|562, +/* 02f9a8 */ TBL(3)|1330, TBL(3)|1331, TBL(3)|1333, TBL(4)|478, TBL(3)|1334, TBL(4)|475, TBL(3)|563, TBL(3)|564, +/* 02f9b0 */ TBL(4)|476, TBL(4)|477, TBL(3)|565, TBL(3)|1342, TBL(3)|1343, TBL(3)|1344, TBL(3)|1345, TBL(3)|1348, +/* 02f9b8 */ TBL(3)|1347, TBL(3)|1350, TBL(3)|1349, TBL(3)|1353, TBL(3)|1351, TBL(3)|1352, TBL(3)|1354, TBL(3)|566, +/* 02f9c0 */ TBL(3)|1356, TBL(3)|1357, TBL(3)|567, TBL(3)|1361, TBL(3)|1362, TBL(4)|479, TBL(3)|1365, TBL(3)|1366, +/* 02f9c8 */ TBL(3)|568, TBL(3)|1369, TBL(3)|517, TBL(4)|480, TBL(4)|481, TBL(3)|569, TBL(3)|570, TBL(3)|1380, +/* 02f9d0 */ TBL(3)|1386, TBL(3)|1393, TBL(3)|1397, TBL(4)|482, TBL(3)|1402, TBL(3)|1403, TBL(3)|1409, TBL(3)|1412, +/* 02f9d8 */ TBL(4)|484, TBL(4)|398, TBL(3)|1415, TBL(3)|1414, TBL(3)|1417, TBL(4)|399, TBL(3)|1420, TBL(3)|1423, +/* 02f9e0 */ TBL(4)|485, TBL(4)|486, TBL(3)|1439, TBL(3)|1442, TBL(3)|1444, TBL(4)|487, TBL(3)|1445, TBL(3)|1456, +/* 02f9e8 */ TBL(3)|1459, TBL(3)|1460, TBL(3)|1458, TBL(3)|1463, TBL(3)|1464, TBL(4)|488, TBL(3)|1467, TBL(3)|571, +/* 02f9f0 */ TBL(3)|1469, TBL(4)|489, TBL(3)|572, TBL(3)|1483, TBL(3)|839, TBL(3)|1489, TBL(4)|490, TBL(4)|492, +/* 02f9f8 */ TBL(3)|573, TBL(3)|574, TBL(3)|1499, TBL(4)|493, TBL(3)|575, TBL(4)|494, TBL(3)|1505, TBL(3)|1505 +}; + +static const uint16_t UN8IF_compat_02_fa [256] = { +/* 02fa00 */ TBL(3)|1507, TBL(4)|495, TBL(3)|1513, TBL(3)|576, TBL(3)|1517, TBL(3)|1520, TBL(3)|1522, TBL(3)|1524, +/* 02fa08 */ TBL(3)|577, TBL(4)|496, TBL(3)|1529, TBL(3)|1536, TBL(3)|1539, TBL(3)|578, TBL(3)|579, TBL(3)|1540, +/* 02fa10 */ TBL(4)|497, TBL(3)|580, TBL(4)|498, TBL(4)|499, TBL(4)|500, TBL(3)|1549, TBL(3)|581, TBL(3)|1554, +/* 02fa18 */ TBL(3)|1556, TBL(3)|1557, TBL(3)|1559, TBL(3)|1561, TBL(3)|1563, TBL(4)|502, 0, 0, +/* 02fa20 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa28 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa30 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa38 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa40 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa48 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa50 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa58 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa60 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa68 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa70 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa78 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa80 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa88 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa90 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fa98 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faa0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faa8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fab0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fab8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fac0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fac8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fad0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fad8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fae0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02fae8 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faf0 */ 0, 0, 0, 0, 0, 0, 0, 0, +/* 02faf8 */ 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* the planes */ +static const uint16_t* UN8IF_compat_00 [256] = { +UN8IF_compat_00_00, +UN8IF_compat_00_01, +UN8IF_compat_00_02, +UN8IF_compat_00_03, +UN8IF_compat_00_04, +UN8IF_compat_00_05, +UN8IF_compat_00_06, +NULL, +NULL,UN8IF_compat_00_09, +UN8IF_compat_00_0a, +UN8IF_compat_00_0b, +UN8IF_compat_00_0c, +UN8IF_compat_00_0d, +UN8IF_compat_00_0e, +UN8IF_compat_00_0f, +UN8IF_compat_00_10, +NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_compat_00_1b, +NULL,UN8IF_compat_00_1d, +UN8IF_compat_00_1e, +UN8IF_compat_00_1f, +UN8IF_compat_00_20, +UN8IF_compat_00_21, +UN8IF_compat_00_22, +UN8IF_compat_00_23, +UN8IF_compat_00_24, +NULL,NULL,NULL, +NULL,NULL,UN8IF_compat_00_2a, +NULL,UN8IF_compat_00_2c, +UN8IF_compat_00_2d, +UN8IF_compat_00_2e, +UN8IF_compat_00_2f, +UN8IF_compat_00_30, +UN8IF_compat_00_31, +UN8IF_compat_00_32, +UN8IF_compat_00_33, +NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,UN8IF_compat_00_a6, +UN8IF_compat_00_a7, +NULL,NULL,NULL,UN8IF_compat_00_ab, +NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_compat_00_f9, +UN8IF_compat_00_fa, +UN8IF_compat_00_fb, +UN8IF_compat_00_fc, +UN8IF_compat_00_fd, +UN8IF_compat_00_fe, +UN8IF_compat_00_ff +}; + +static const uint16_t* UN8IF_compat_01 [256] = { +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_compat_01_10, +UN8IF_compat_01_11, +NULL,UN8IF_compat_01_13, +UN8IF_compat_01_14, +UN8IF_compat_01_15, +NULL,NULL, +NULL,UN8IF_compat_01_19, +NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,UN8IF_compat_01_d1, +NULL,NULL,UN8IF_compat_01_d4, +UN8IF_compat_01_d5, +UN8IF_compat_01_d6, +UN8IF_compat_01_d7, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,UN8IF_compat_01_ee, +NULL, +NULL,UN8IF_compat_01_f1, +UN8IF_compat_01_f2, +NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,UN8IF_compat_01_fb, +NULL,NULL,NULL,NULL +}; + +static const uint16_t* UN8IF_compat_02 [256] = { +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, +UN8IF_compat_02_f8, +UN8IF_compat_02_f9, +UN8IF_compat_02_fa, +NULL,NULL,NULL,NULL,NULL +}; + +/* the main plane */ +#undef TBL +static const uint16_t** UN8IF_compat [] = { +UN8IF_compat_00, +UN8IF_compat_01, +UN8IF_compat_02, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL, +NULL +}; + diff --git a/src/safeclib_private.h b/src/safeclib_private.h index 21ac5caa3..9382d1753 100644 --- a/src/safeclib_private.h +++ b/src/safeclib_private.h @@ -643,7 +643,6 @@ EXTERN wint_t towlower(wint_t wc); /* from wcsnorm_s.c */ EXTERN int _decomp_s(wchar_t *restrict dest, rsize_t dmax, const uint32_t cp, const bool iscompat); - #endif /* SAFECLIB_DISABLE_WCHAR */ // internal helpers for the *printf_s functions: @@ -715,4 +714,10 @@ static inline int safec_out_fct(char character, void *wrap, size_t idx, int safec_vsnprintf_s(out_fct_type out, const char *funcname, char *buffer, const size_t bufsize, const char *format, va_list va); +#ifdef SAFECLIB_ENABLE_U8 +/* from u8norm_s.c */ +EXTERN int _u8decomp_s(char *restrict dest, rsize_t dmax, const uint32_t cp, + const bool iscompat); +#endif + #endif /* __SAFECLIB_PRIVATE_H__ */