"Fossies" - the Fresh Open Source Software Archive

Member "4.6.1/vendor/idna_convert/idna_convert.class.php" (8 Apr 2021, 274551 Bytes) of package /linux/www/studip-4.6.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) PHP source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "idna_convert.class.php": 4.5.2_vs_4.6.

    1 <?php
    2 
    3 // {{{ license
    4 
    5 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
    6 //
    7 // +----------------------------------------------------------------------+
    8 // | This library is free software; you can redistribute it and/or modify |
    9 // | it under the terms of the GNU Lesser General Public License as       |
   10 // | published by the Free Software Foundation; either version 2.1 of the |
   11 // | License, or (at your option) any later version.                      |
   12 // |                                                                      |
   13 // | This library is distributed in the hope that it will be useful, but  |
   14 // | WITHOUT ANY WARRANTY; without even the implied warranty of           |
   15 // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
   16 // | Lesser General Public License for more details.                      |
   17 // |                                                                      |
   18 // | You should have received a copy of the GNU Lesser General Public     |
   19 // | License along with this library; if not, write to the Free Software  |
   20 // | Foundation, Inc., 51 Franklin St, Boston, MA 02110, United States    |
   21 // +----------------------------------------------------------------------+
   22 //
   23 // }}}
   24 
   25 /**
   26  * Encode/decode Internationalized Domain Names.
   27  *
   28  * The class allows to convert internationalized domain names
   29  * (see RFC 3490 for details) as they can be used with various registries worldwide
   30  * to be translated between their original (localized) form and their encoded form
   31  * as it will be used in the DNS (Domain Name System).
   32  *
   33  * The class provides two public methods, encode() and decode(), which do exactly
   34  * what you would expect them to do. You are allowed to use complete domain names,
   35  * simple strings and complete email addresses as well. That means, that you might
   36  * use any of the following notations:
   37  *
   38  * - www.nörgler.com
   39  * - xn--nrgler-wxa
   40  * - xn--brse-5qa.xn--knrz-1ra.info
   41  *
   42  * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4 array.
   43  * Unicode output is available in the same formats.
   44  * You can select your preferred format via {@link set_paramter()}.
   45  *
   46  * ACE input and output is always expected to be ASCII.
   47  *
   48  * @author  Matthias Sommerfeld <mso@phlylabs.de>
   49  * @copyright 2004-2014 phlyLabs Berlin, http://phlylabs.de
   50  * @version 0.9.0 2014-12-12
   51  */
   52 class idna_convert {
   53 
   54     private $version = '0.9.0';
   55     protected $sub_version = 'main';
   56 
   57     // NP See below
   58     // Internal settings, do not mess with them
   59     protected $_punycode_prefix = 'xn--';
   60     protected $_invalid_ucs = 0x80000000;
   61     protected $_max_ucs = 0x10FFFF;
   62     protected $_base = 36;
   63     protected $_tmin = 1;
   64     protected $_tmax = 26;
   65     protected $_skew = 38;
   66     protected $_damp = 700;
   67     protected $_initial_bias = 72;
   68     protected $_initial_n = 0x80;
   69     protected $_sbase = 0xAC00;
   70     protected $_lbase = 0x1100;
   71     protected $_vbase = 0x1161;
   72     protected $_tbase = 0x11A7;
   73     protected $_lcount = 19;
   74     protected $_vcount = 21;
   75     protected $_tcount = 28;
   76     protected $_ncount = 588;   // _vcount * _tcount
   77     protected $_scount = 11172; // _lcount * _tcount * _vcount
   78     protected $_error = false;
   79     protected static $_mb_string_overload = null;
   80     // See {@link set_paramter()} for details of how to change the following
   81     // settings from within your script / application
   82     protected $_api_encoding = 'utf8';   // Default input charset is UTF-8
   83     protected $_allow_overlong = false;  // Overlong UTF-8 encodings are forbidden
   84     protected $_strict_mode = false;     // Behave strict or not
   85     protected $_idn_version = 2003;      // Can be either 2003 (old, default) or 2008
   86 
   87     /**
   88      * the constructor
   89      *
   90      * @param array $options
   91      * @return boolean
   92      * @since 0.5.2
   93      */
   94     public function __construct($options = false)
   95     {
   96         $this->slast = $this->_sbase + $this->_lcount * $this->_vcount * $this->_tcount;
   97         // If parameters are given, pass these to the respective method
   98         if (is_array($options)) {
   99             $this->set_parameter($options);
  100         }
  101 
  102         // populate mbstring overloading cache if not set
  103         if (self::$_mb_string_overload === null) {
  104             $func_overload = "0";
  105             if (version_compare(PHP_VERSION, '7.2.0', '<')) {
  106                 $func_overload = ini_get('mbstring.func_overload');
  107             }
  108             self::$_mb_string_overload = (extension_loaded('mbstring') && ($func_overload & 0x02) === 0x02);
  109         }
  110     }
  111 
  112     public function get_version()
  113     {
  114         return $this->version.'-'.$this->sub_version;
  115     }
  116 
  117     /**
  118      * Sets a new option value. Available options and values:
  119      * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
  120      *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
  121      * [overlong - Unicode does not allow unnecessarily long encodings of chars,
  122      *             to allow this, set this parameter to true, else to false;
  123      *             default is false.]
  124      * [strict - true: strict mode, good for registration purposes - Causes errors
  125      *           on failures; false: loose mode, ideal for "wildlife" applications
  126      *           by silently ignoring errors and returning the original input instead
  127      *
  128      * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
  129      * @param    string    Value to use (if parameter 1 is a string)
  130      * @return   boolean   true on success, false otherwise
  131      */
  132     public function set_parameter($option, $value = false)
  133     {
  134         if (!is_array($option)) {
  135             $option = array($option => $value);
  136         }
  137         foreach ($option as $k => $v) {
  138             switch ($k) {
  139                 case 'encoding':
  140                     switch ($v) {
  141                         case 'utf8':
  142                         case 'ucs4_string':
  143                         case 'ucs4_array':
  144                             $this->_api_encoding = $v;
  145                             break;
  146                         default:
  147                             $this->_error('Set Parameter: Unknown parameter ' . $v . ' for option ' . $k);
  148                             return false;
  149                     }
  150                     break;
  151                 case 'overlong':
  152                     $this->_allow_overlong = ($v) ? true : false;
  153                     break;
  154                 case 'strict':
  155                     $this->_strict_mode = ($v) ? true : false;
  156                     break;
  157                 case 'idn_version':
  158                     if (in_array($v, array('2003', '2008'))) {
  159                         $this->_idn_version = $v;
  160                     } else {
  161                         $this->_error('Set Parameter: Unknown parameter ' . $v . ' for option ' . $k);
  162                     }
  163                     break;
  164                 case 'encode_german_sz': // Deprecated
  165                     if (!$v) {
  166                         self::$NP['replacemaps'][0xDF] = array(0x73, 0x73);
  167                     } else {
  168                         unset(self::$NP['replacemaps'][0xDF]);
  169                     }
  170                     break;
  171                 default:
  172                     $this->_error('Set Parameter: Unknown option ' . $k);
  173                     return false;
  174             }
  175         }
  176         return true;
  177     }
  178 
  179     /**
  180      * Decode a given ACE domain name
  181      * @param    string   Domain name (ACE string)
  182      * [@param    string   Desired output encoding, see {@link set_parameter}]
  183      * @return   string   Decoded Domain name (UTF-8 or UCS-4)
  184      */
  185     public function decode($input, $one_time_encoding = false)
  186     {
  187         // Optionally set
  188         if ($one_time_encoding) {
  189             switch ($one_time_encoding) {
  190                 case 'utf8':
  191                 case 'ucs4_string':
  192                 case 'ucs4_array':
  193                     break;
  194                 default:
  195                     $this->_error('Unknown encoding ' . $one_time_encoding);
  196                     return false;
  197             }
  198         }
  199         // Make sure to drop any newline characters around
  200         $input = trim($input);
  201 
  202         // Negotiate input and try to determine, whether it is a plain string,
  203         // an email address or something like a complete URL
  204         if (strpos($input, '@')) { // Maybe it is an email address
  205             // No no in strict mode
  206             if ($this->_strict_mode) {
  207                 $this->_error('Only simple domain name parts can be handled in strict mode');
  208                 return false;
  209             }
  210             list ($email_pref, $input) = explode('@', $input, 2);
  211             $arr = explode('.', $input);
  212             foreach ($arr as $k => $v) {
  213                 if (preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $v)) {
  214                     $conv = $this->_decode($v);
  215                     if ($conv) {
  216                         $arr[$k] = $conv;
  217                     }
  218                 }
  219             }
  220             $input = join('.', $arr);
  221             $arr = explode('.', $email_pref);
  222             foreach ($arr as $k => $v) {
  223                 if (preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $v)) {
  224                     $conv = $this->_decode($v);
  225                     if ($conv) {
  226                         $arr[$k] = $conv;
  227                     }
  228                 }
  229             }
  230             $email_pref = join('.', $arr);
  231             $return = $email_pref . '@' . $input;
  232         } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
  233             // No no in strict mode
  234             if ($this->_strict_mode) {
  235                 $this->_error('Only simple domain name parts can be handled in strict mode');
  236                 return false;
  237             }
  238             $parsed = parse_url($input);
  239             if (isset($parsed['host'])) {
  240                 $arr = explode('.', $parsed['host']);
  241                 foreach ($arr as $k => $v) {
  242                     $conv = $this->_decode($v);
  243                     if ($conv) {
  244                         $arr[$k] = $conv;
  245                     }
  246                 }
  247                 $parsed['host'] = join('.', $arr);
  248                 $return = (empty($parsed['scheme']) ? '' : $parsed['scheme'] . (strtolower($parsed['scheme']) == 'mailto' ? ':' : '://')).
  249                         (empty($parsed['user']) ? '' : $parsed['user'] . (empty($parsed['pass']) ? '' : ':' . $parsed['pass']) . '@').
  250                         $parsed['host'].
  251                         (empty($parsed['port']) ? '' : ':' . $parsed['port']).
  252                         (empty($parsed['path']) ? '' : $parsed['path']).
  253                         (empty($parsed['query']) ? '' : '?' . $parsed['query']).
  254                         (empty($parsed['fragment']) ? '' : '#' . $parsed['fragment']);
  255             } else { // parse_url seems to have failed, try without it
  256                 $arr = explode('.', $input);
  257                 foreach ($arr as $k => $v) {
  258                     $conv = $this->_decode($v);
  259                     $arr[$k] = ($conv) ? $conv : $v;
  260                 }
  261                 $return = join('.', $arr);
  262             }
  263         } else { // Otherwise we consider it being a pure domain name string
  264             $return = $this->_decode($input);
  265             if (!$return) {
  266                 $return = $input;
  267             }
  268         }
  269         // The output is UTF-8 by default, other output formats need conversion here
  270         // If one time encoding is given, use this, else the objects property
  271         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
  272             case 'utf8':        return $return; // break;
  273             case 'ucs4_string': return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));  // break;
  274             case 'ucs4_array':  return $this->_utf8_to_ucs4($return); // break;
  275             default:            $this->_error('Unsupported output format'); return false;
  276         }
  277     }
  278 
  279     /**
  280      * Encode a given UTF-8 domain name
  281      * @param    string   Domain name (UTF-8 or UCS-4)
  282      * [@param    string   Desired input encoding, see {@link set_parameter}]
  283      * @return   string   Encoded Domain name (ACE string)
  284      */
  285     public function encode($decoded, $one_time_encoding = false)
  286     {
  287         // Forcing conversion of input to UCS4 array
  288         // If one time encoding is given, use this, else the objects property
  289         switch ($one_time_encoding ? $one_time_encoding : $this->_api_encoding) {
  290             case 'utf8':
  291                 $decoded = $this->_utf8_to_ucs4($decoded);
  292                 break;
  293             case 'ucs4_string':
  294                 $decoded = $this->_ucs4_string_to_ucs4($decoded);
  295             case 'ucs4_array':
  296                 break;
  297             default:
  298                 $this->_error('Unsupported input format: ' . ($one_time_encoding ? $one_time_encoding : $this->_api_encoding));
  299                 return false;
  300         }
  301 
  302         // No input, no output, what else did you expect?
  303         if (empty($decoded)) {
  304             return '';
  305         }
  306 
  307         // Anchors for iteration
  308         $last_begin = 0;
  309         // Output string
  310         $output = '';
  311         foreach ($decoded as $k => $v) {
  312             // Make sure to use just the plain dot
  313             switch ($v) {
  314                 case 0x3002:
  315                 case 0xFF0E:
  316                 case 0xFF61:
  317                     $decoded[$k] = 0x2E;
  318                     // Right, no break here, the above are converted to dots anyway
  319                 // Stumbling across an anchoring character
  320                 case 0x2E:
  321                 case 0x2F:
  322                 case 0x3A:
  323                 case 0x3F:
  324                 case 0x40:
  325                     // Neither email addresses nor URLs allowed in strict mode
  326                     if ($this->_strict_mode) {
  327                         $this->_error('Neither email addresses nor URLs are allowed in strict mode.');
  328                         return false;
  329                     } else {
  330                         // Skip first char
  331                         if ($k) {
  332                             $encoded = '';
  333                             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k) - $last_begin)));
  334                             if ($encoded) {
  335                                 $output .= $encoded;
  336                             } else {
  337                                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k) - $last_begin)));
  338                             }
  339                             $output .= chr($decoded[$k]);
  340                         }
  341                         $last_begin = $k + 1;
  342                     }
  343             }
  344         }
  345         // Catch the rest of the string
  346         if ($last_begin) {
  347             $inp_len = sizeof($decoded);
  348             $encoded = '';
  349             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len) - $last_begin)));
  350             if ($encoded) {
  351                 $output .= $encoded;
  352             } else {
  353                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len) - $last_begin)));
  354             }
  355             return $output;
  356         } else {
  357             if (false !== ($output = $this->_encode($decoded))) {
  358                 return $output;
  359             } else {
  360                 return $this->_ucs4_to_utf8($decoded);
  361             }
  362         }
  363     }
  364 
  365     /**
  366      * Removes a weakness of encode(), which cannot properly handle URIs but instead encodes their
  367      * path or query components, too.
  368      * @param string  $uri  Expects the URI as a UTF-8 (or ASCII) string
  369      * @return  string  The URI encoded to Punycode, everything but the host component is left alone
  370      * @since 0.6.4
  371      */
  372     public function encode_uri($uri)
  373     {
  374         $parsed = parse_url($uri);
  375         if (!isset($parsed['host'])) {
  376             $this->_error('The given string does not look like a URI');
  377             return false;
  378         }
  379         $arr = explode('.', $parsed['host']);
  380         foreach ($arr as $k => $v) {
  381             $conv = $this->encode($v, 'utf8');
  382             if ($conv) {
  383                 $arr[$k] = $conv;
  384             }
  385         }
  386         $parsed['host'] = join('.', $arr);
  387         $return = (empty($parsed['scheme']) ? '' : $parsed['scheme'] . (strtolower($parsed['scheme']) == 'mailto' ? ':' : '://')).
  388                 (empty($parsed['user']) ? '' : $parsed['user'] . (empty($parsed['pass']) ? '' : ':' . $parsed['pass']) . '@').
  389                 $parsed['host'].
  390                 (empty($parsed['port']) ? '' : ':' . $parsed['port']).
  391                 (empty($parsed['path']) ? '' : $parsed['path']).
  392                 (empty($parsed['query']) ? '' : '?' . $parsed['query']).
  393                 (empty($parsed['fragment']) ? '' : '#' . $parsed['fragment']);
  394         return $return;
  395     }
  396 
  397     /**
  398      * Use this method to get the last error ocurred
  399      * @param    void
  400      * @return   string   The last error, that occured
  401      */
  402     public function get_last_error()
  403     {
  404         return $this->_error;
  405     }
  406 
  407     /**
  408      * The actual decoding algorithm
  409      * @param string
  410      * @return mixed
  411      */
  412     protected function _decode($encoded)
  413     {
  414         $decoded = array();
  415         // find the Punycode prefix
  416         if (!preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $encoded)) {
  417             $this->_error('This is not a punycode string');
  418             return false;
  419         }
  420         $encode_test = preg_replace('!^' . preg_quote($this->_punycode_prefix, '!') . '!', '', $encoded);
  421         // If nothing left after removing the prefix, it is hopeless
  422         if (!$encode_test) {
  423             $this->_error('The given encoded string was empty');
  424             return false;
  425         }
  426         // Find last occurence of the delimiter
  427         $delim_pos = strrpos($encoded, '-');
  428         if ($delim_pos > self::byteLength($this->_punycode_prefix)) {
  429             for ($k = self::byteLength($this->_punycode_prefix); $k < $delim_pos; ++$k) {
  430                 $decoded[] = ord($encoded{$k});
  431             }
  432         }
  433         $deco_len = count($decoded);
  434         $enco_len = self::byteLength($encoded);
  435 
  436         // Wandering through the strings; init
  437         $is_first = true;
  438         $bias = $this->_initial_bias;
  439         $idx = 0;
  440         $char = $this->_initial_n;
  441 
  442         for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
  443             for ($old_idx = $idx, $w = 1, $k = $this->_base; 1; $k += $this->_base) {
  444                 $digit = $this->_decode_digit($encoded{$enco_idx++});
  445                 $idx += $digit * $w;
  446                 $t = ($k <= $bias) ? $this->_tmin :
  447                         (($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
  448                 if ($digit < $t) {
  449                     break;
  450                 }
  451                 $w = (int) ($w * ($this->_base - $t));
  452             }
  453             $bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
  454             $is_first = false;
  455             $char += (int) ($idx / ($deco_len + 1));
  456             $idx %= ($deco_len + 1);
  457             if ($deco_len > 0) {
  458                 // Make room for the decoded char
  459                 for ($i = $deco_len; $i > $idx; $i--) {
  460                     $decoded[$i] = $decoded[($i - 1)];
  461                 }
  462             }
  463             $decoded[$idx++] = $char;
  464         }
  465         return $this->_ucs4_to_utf8($decoded);
  466     }
  467 
  468     /**
  469      * The actual encoding algorithm
  470      * @param  string
  471      * @return mixed
  472      */
  473     protected function _encode($decoded)
  474     {
  475         // We cannot encode a domain name containing the Punycode prefix
  476         $extract = self::byteLength($this->_punycode_prefix);
  477         $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
  478         $check_deco = array_slice($decoded, 0, $extract);
  479 
  480         if ($check_pref == $check_deco) {
  481             $this->_error('This is already a punycode string');
  482             return false;
  483         }
  484         // We will not try to encode strings consisting of basic code points only
  485         $encodable = false;
  486         foreach ($decoded as $k => $v) {
  487             if ($v > 0x7a) {
  488                 $encodable = true;
  489                 break;
  490             }
  491         }
  492         if (!$encodable) {
  493             $this->_error('The given string does not contain encodable chars');
  494             return false;
  495         }
  496         // Do NAMEPREP
  497         $decoded = $this->_nameprep($decoded);
  498         if (!$decoded || !is_array($decoded)) {
  499             return false; // NAMEPREP failed
  500         }
  501         $deco_len = count($decoded);
  502         if (!$deco_len) {
  503             return false; // Empty array
  504         }
  505         $codecount = 0; // How many chars have been consumed
  506         $encoded = '';
  507         // Copy all basic code points to output
  508         for ($i = 0; $i < $deco_len; ++$i) {
  509             $test = $decoded[$i];
  510             // Will match [-0-9a-zA-Z]
  511             if ((0x2F < $test && $test < 0x40) || (0x40 < $test && $test < 0x5B) || (0x60 < $test && $test <= 0x7B) || (0x2D == $test)) {
  512                 $encoded .= chr($decoded[$i]);
  513                 $codecount++;
  514             }
  515         }
  516         if ($codecount == $deco_len) {
  517             return $encoded; // All codepoints were basic ones
  518         }
  519         // Start with the prefix; copy it to output
  520         $encoded = $this->_punycode_prefix . $encoded;
  521         // If we have basic code points in output, add an hyphen to the end
  522         if ($codecount) {
  523             $encoded .= '-';
  524         }
  525         // Now find and encode all non-basic code points
  526         $is_first = true;
  527         $cur_code = $this->_initial_n;
  528         $bias = $this->_initial_bias;
  529         $delta = 0;
  530         while ($codecount < $deco_len) {
  531             // Find the smallest code point >= the current code point and
  532             // remember the last ouccrence of it in the input
  533             for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
  534                 if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
  535                     $next_code = $decoded[$i];
  536                 }
  537             }
  538             $delta += ($next_code - $cur_code) * ($codecount + 1);
  539             $cur_code = $next_code;
  540 
  541             // Scan input again and encode all characters whose code point is $cur_code
  542             for ($i = 0; $i < $deco_len; $i++) {
  543                 if ($decoded[$i] < $cur_code) {
  544                     $delta++;
  545                 } elseif ($decoded[$i] == $cur_code) {
  546                     for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
  547                         $t = ($k <= $bias) ? $this->_tmin :
  548                                 (($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
  549                         if ($q < $t) {
  550                             break;
  551                         }
  552                         $encoded .= $this->_encode_digit(intval($t + (($q - $t) % ($this->_base - $t)))); //v0.4.5 Changed from ceil() to intval()
  553                         $q = (int) (($q - $t) / ($this->_base - $t));
  554                     }
  555                     $encoded .= $this->_encode_digit($q);
  556                     $bias = $this->_adapt($delta, $codecount + 1, $is_first);
  557                     $codecount++;
  558                     $delta = 0;
  559                     $is_first = false;
  560                 }
  561             }
  562             $delta++;
  563             $cur_code++;
  564         }
  565         return $encoded;
  566     }
  567 
  568     /**
  569      * Adapt the bias according to the current code point and position
  570      * @param int $delta
  571      * @param int $npoints
  572      * @param int $is_first
  573      * @return int
  574      */
  575     protected function _adapt($delta, $npoints, $is_first)
  576     {
  577         $delta = intval($is_first ? ($delta / $this->_damp) : ($delta / 2));
  578         $delta += intval($delta / $npoints);
  579         for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
  580             $delta = intval($delta / ($this->_base - $this->_tmin));
  581         }
  582         return intval($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
  583     }
  584 
  585     /**
  586      * Encoding a certain digit
  587      * @param    int $d
  588      * @return string
  589      */
  590     protected function _encode_digit($d)
  591     {
  592         return chr($d + 22 + 75 * ($d < 26));
  593     }
  594 
  595     /**
  596      * Decode a certain digit
  597      * @param    int $cp
  598      * @return int
  599      */
  600     protected function _decode_digit($cp)
  601     {
  602         $cp = ord($cp);
  603         return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
  604     }
  605 
  606     /**
  607      * Internal error handling method
  608      * @param  string $error
  609      */
  610     protected function _error($error = '')
  611     {
  612         $this->_error = $error;
  613     }
  614 
  615     /**
  616      * Do Nameprep according to RFC3491 and RFC3454
  617      * @param    array    Unicode Characters
  618      * @return   string   Unicode Characters, Nameprep'd
  619      */
  620     protected function _nameprep($input)
  621     {
  622         $output = array();
  623         //
  624         // Mapping
  625         // Walking through the input array, performing the required steps on each of
  626         // the input chars and putting the result into the output array
  627         // While mapping required chars we apply the cannonical ordering
  628         foreach ($input as $v) {
  629             // Map to nothing == skip that code point
  630             if (in_array($v, self::$NP['map_nothing'])) {
  631                 continue;
  632             }
  633             // Try to find prohibited input
  634             if (in_array($v, self::$NP['prohibit']) || in_array($v, self::$NP['general_prohibited'])) {
  635                 $this->_error('NAMEPREP: Prohibited input U+' . sprintf('%08X', $v));
  636                 return false;
  637             }
  638             foreach (self::$NP['prohibit_ranges'] as $range) {
  639                 if ($range[0] <= $v && $v <= $range[1]) {
  640                     $this->_error('NAMEPREP: Prohibited input U+' . sprintf('%08X', $v));
  641                     return false;
  642                 }
  643             }
  644 
  645             if (0xAC00 <= $v && $v <= 0xD7AF) {
  646                 // Hangul syllable decomposition
  647                 foreach ($this->_hangul_decompose($v) as $out) {
  648                     $output[] = (int) $out;
  649                 }
  650             } elseif (($this->_idn_version == '2003') && isset(self::$NP['replacemaps_2003'][$v])) {
  651                 foreach ($this->_apply_cannonical_ordering(self::$NP['replacemaps_2003'][$v]) as $out) {
  652                     $output[] = (int) $out;
  653                 }
  654             } elseif (($this->_idn_version == '2008') && isset(self::$NP['replacemaps'][$v])) {
  655                 foreach ($this->_apply_cannonical_ordering(self::$NP['replacemaps'][$v]) as $out) {
  656                     $output[] = (int) $out;
  657                 }
  658             } else {
  659                 $output[] = (int) $v;
  660             }
  661         }
  662         // Before applying any Combining, try to rearrange any Hangul syllables
  663         $output = $this->_hangul_compose($output);
  664         //
  665         // Combine code points
  666         //
  667         $last_class = 0;
  668         $last_starter = 0;
  669         $out_len = count($output);
  670         for ($i = 0; $i < $out_len; ++$i) {
  671             $class = $this->_get_combining_class($output[$i]);
  672             if ((!$last_class || $last_class > $class) && $class) {
  673                 // Try to match
  674                 $seq_len = $i - $last_starter;
  675                 $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
  676                 // On match: Replace the last starter with the composed character and remove
  677                 // the now redundant non-starter(s)
  678                 if ($out) {
  679                     $output[$last_starter] = $out;
  680                     if (count($out) != $seq_len) {
  681                         for ($j = $i + 1; $j < $out_len; ++$j) {
  682                             $output[$j - 1] = $output[$j];
  683                         }
  684                         unset($output[$out_len]);
  685                     }
  686                     // Rewind the for loop by one, since there can be more possible compositions
  687                     $i--;
  688                     $out_len--;
  689                     $last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i - 1]);
  690                     continue;
  691                 }
  692             }
  693             // The current class is 0
  694             if (!$class) {
  695                 $last_starter = $i;
  696             }
  697             $last_class = $class;
  698         }
  699         return $output;
  700     }
  701 
  702     /**
  703      * Decomposes a Hangul syllable
  704      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  705      * @param    integer  32bit UCS4 code point
  706      * @return   array    Either Hangul Syllable decomposed or original 32bit value as one value array
  707      */
  708     protected function _hangul_decompose($char)
  709     {
  710         $sindex = (int) $char - $this->_sbase;
  711         if ($sindex < 0 || $sindex >= $this->_scount) {
  712             return array($char);
  713         }
  714         $result = array();
  715         $result[] = (int) $this->_lbase + $sindex / $this->_ncount;
  716         $result[] = (int) $this->_vbase + ($sindex % $this->_ncount) / $this->_tcount;
  717         $T = intval($this->_tbase + $sindex % $this->_tcount);
  718         if ($T != $this->_tbase) {
  719             $result[] = $T;
  720         }
  721         return $result;
  722     }
  723 
  724     /**
  725      * Ccomposes a Hangul syllable
  726      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  727      * @param    array    Decomposed UCS4 sequence
  728      * @return   array    UCS4 sequence with syllables composed
  729      */
  730     protected function _hangul_compose($input)
  731     {
  732         $inp_len = count($input);
  733         if (!$inp_len) {
  734             return array();
  735         }
  736         $result = array();
  737         $last = (int) $input[0];
  738         $result[] = $last; // copy first char from input to output
  739 
  740         for ($i = 1; $i < $inp_len; ++$i) {
  741             $char = (int) $input[$i];
  742             $sindex = $last - $this->_sbase;
  743             $lindex = $last - $this->_lbase;
  744             $vindex = $char - $this->_vbase;
  745             $tindex = $char - $this->_tbase;
  746             // Find out, whether two current characters are LV and T
  747             if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount == 0) && 0 <= $tindex && $tindex <= $this->_tcount) {
  748                 // create syllable of form LVT
  749                 $last += $tindex;
  750                 $result[(count($result) - 1)] = $last; // reset last
  751                 continue; // discard char
  752             }
  753             // Find out, whether two current characters form L and V
  754             if (0 <= $lindex && $lindex < $this->_lcount && 0 <= $vindex && $vindex < $this->_vcount) {
  755                 // create syllable of form LV
  756                 $last = (int) $this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount;
  757                 $result[(count($result) - 1)] = $last; // reset last
  758                 continue; // discard char
  759             }
  760             // if neither case was true, just add the character
  761             $last = $char;
  762             $result[] = $char;
  763         }
  764         return $result;
  765     }
  766 
  767     /**
  768      * Returns the combining class of a certain wide char
  769      * @param    integer    Wide char to check (32bit integer)
  770      * @return   integer    Combining class if found, else 0
  771      */
  772     protected function _get_combining_class($char)
  773     {
  774         return isset(self::$NP['norm_combcls'][$char]) ? self::$NP['norm_combcls'][$char] : 0;
  775     }
  776 
  777     /**
  778      * Applies the cannonical ordering of a decomposed UCS4 sequence
  779      * @param    array      Decomposed UCS4 sequence
  780      * @return   array      Ordered USC4 sequence
  781      */
  782     protected function _apply_cannonical_ordering($input)
  783     {
  784         $swap = true;
  785         $size = count($input);
  786         while ($swap) {
  787             $swap = false;
  788             $last = $this->_get_combining_class(intval($input[0]));
  789             for ($i = 0; $i < $size - 1; ++$i) {
  790                 $next = $this->_get_combining_class(intval($input[$i + 1]));
  791                 if ($next != 0 && $last > $next) {
  792                     // Move item leftward until it fits
  793                     for ($j = $i + 1; $j > 0; --$j) {
  794                         if ($this->_get_combining_class(intval($input[$j - 1])) <= $next) {
  795                             break;
  796                         }
  797                         $t = intval($input[$j]);
  798                         $input[$j] = intval($input[$j - 1]);
  799                         $input[$j - 1] = $t;
  800                         $swap = true;
  801                     }
  802                     // Reentering the loop looking at the old character again
  803                     $next = $last;
  804                 }
  805                 $last = $next;
  806             }
  807         }
  808         return $input;
  809     }
  810 
  811     /**
  812      * Do composition of a sequence of starter and non-starter
  813      * @param    array      UCS4 Decomposed sequence
  814      * @return   array      Ordered USC4 sequence
  815      */
  816     protected function _combine($input)
  817     {
  818         $inp_len = count($input);
  819         if (0 == $inp_len) {
  820             return false;
  821         }
  822         foreach (self::$NP['replacemaps'] as $np_src => $np_target) {
  823             if ($np_target[0] != $input[0]) {
  824                 continue;
  825             }
  826             if (count($np_target) != $inp_len) {
  827                 continue;
  828             }
  829             $hit = false;
  830             foreach ($input as $k2 => $v2) {
  831                 if ($v2 == $np_target[$k2]) {
  832                     $hit = true;
  833                 } else {
  834                     $hit = false;
  835                     break;
  836                 }
  837             }
  838             if ($hit) {
  839                 return $np_src;
  840             }
  841         }
  842         return false;
  843     }
  844 
  845     /**
  846      * This converts an UTF-8 encoded string to its UCS-4 representation
  847      * By talking about UCS-4 "strings" we mean arrays of 32bit integers representing
  848      * each of the "chars". This is due to PHP not being able to handle strings with
  849      * bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too.
  850      * The following UTF-8 encodings are supported:
  851      * bytes bits  representation
  852      * 1        7  0xxxxxxx
  853      * 2       11  110xxxxx 10xxxxxx
  854      * 3       16  1110xxxx 10xxxxxx 10xxxxxx
  855      * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  856      * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  857      * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  858      * Each x represents a bit that can be used to store character data.
  859      * The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000
  860      * @param string $input
  861      * @return string
  862      */
  863     protected function _utf8_to_ucs4($input)
  864     {
  865         $output = array();
  866         $out_len = 0;
  867         $inp_len = self::byteLength($input);
  868         $mode = 'next';
  869         $test = 'none';
  870         for ($k = 0; $k < $inp_len; ++$k) {
  871             $v = ord($input{$k}); // Extract byte from input string
  872             if ($v < 128) { // We found an ASCII char - put into stirng as is
  873                 $output[$out_len] = $v;
  874                 ++$out_len;
  875                 if ('add' == $mode) {
  876                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte ' . $k);
  877                     return false;
  878                 }
  879                 continue;
  880             }
  881             if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
  882                 $start_byte = $v;
  883                 $mode = 'add';
  884                 $test = 'range';
  885                 if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
  886                     $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
  887                     $v = ($v - 192) << 6;
  888                 } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
  889                     $next_byte = 1;
  890                     $v = ($v - 224) << 12;
  891                 } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  892                     $next_byte = 2;
  893                     $v = ($v - 240) << 18;
  894                 } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  895                     $next_byte = 3;
  896                     $v = ($v - 248) << 24;
  897                 } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  898                     $next_byte = 4;
  899                     $v = ($v - 252) << 30;
  900                 } else {
  901                     $this->_error('This might be UTF-8, but I don\'t understand it at byte ' . $k);
  902                     return false;
  903                 }
  904                 if ('add' == $mode) {
  905                     $output[$out_len] = (int) $v;
  906                     ++$out_len;
  907                     continue;
  908                 }
  909             }
  910             if ('add' == $mode) {
  911                 if (!$this->_allow_overlong && $test == 'range') {
  912                     $test = 'none';
  913                     if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
  914                         $this->_error('Bogus UTF-8 character detected (out of legal range) at byte ' . $k);
  915                         return false;
  916                     }
  917                 }
  918                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
  919                     $v = ($v - 128) << ($next_byte * 6);
  920                     $output[($out_len - 1)] += $v;
  921                     --$next_byte;
  922                 } else {
  923                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte ' . $k);
  924                     return false;
  925                 }
  926                 if ($next_byte < 0) {
  927                     $mode = 'next';
  928                 }
  929             }
  930         } // for
  931         return $output;
  932     }
  933 
  934     /**
  935      * Convert UCS-4 string into UTF-8 string
  936      * See _utf8_to_ucs4() for details
  937      * @param string  $input
  938      * @return string
  939      */
  940     protected function _ucs4_to_utf8($input)
  941     {
  942         $output = '';
  943         foreach ($input as $k => $v) {
  944             if ($v < 128) { // 7bit are transferred literally
  945                 $output .= chr($v);
  946             } elseif ($v < (1 << 11)) { // 2 bytes
  947                 $output .= chr(192 + ($v >> 6)) . chr(128 + ($v & 63));
  948             } elseif ($v < (1 << 16)) { // 3 bytes
  949                 $output .= chr(224 + ($v >> 12)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
  950             } elseif ($v < (1 << 21)) { // 4 bytes
  951                 $output .= chr(240 + ($v >> 18)) . chr(128 + (($v >> 12) & 63)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
  952             } else {
  953                 $this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte ' . $k);
  954                 return false;
  955             }
  956         }
  957         return $output;
  958     }
  959 
  960     /**
  961      * Convert UCS-4 array into UCS-4 string
  962      *
  963      * @param array $input
  964      * @return string
  965      */
  966     protected function _ucs4_to_ucs4_string($input)
  967     {
  968         $output = '';
  969         // Take array values and split output to 4 bytes per value
  970         // The bit mask is 255, which reads &11111111
  971         foreach ($input as $v) {
  972             $output .= chr(($v >> 24) & 255) . chr(($v >> 16) & 255) . chr(($v >> 8) & 255) . chr($v & 255);
  973         }
  974         return $output;
  975     }
  976 
  977     /**
  978      * Convert UCS-4 strin into UCS-4 garray
  979      *
  980      * @param  string $input
  981      * @return array
  982      */
  983     protected function _ucs4_string_to_ucs4($input)
  984     {
  985         $output = array();
  986         $inp_len = self::byteLength($input);
  987         // Input length must be dividable by 4
  988         if ($inp_len % 4) {
  989             $this->_error('Input UCS4 string is broken');
  990             return false;
  991         }
  992         // Empty input - return empty output
  993         if (!$inp_len) {
  994             return $output;
  995         }
  996         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
  997             // Increment output position every 4 input bytes
  998             if (!($i % 4)) {
  999                 $out_len++;
 1000                 $output[$out_len] = 0;
 1001             }
 1002             $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
 1003         }
 1004         return $output;
 1005     }
 1006 
 1007     /**
 1008      * Gets the length of a string in bytes even if mbstring function
 1009      * overloading is turned on
 1010      *
 1011      * @param string $string the string for which to get the length.
 1012      * @return integer the length of the string in bytes.
 1013      */
 1014     protected static function byteLength($string)
 1015     {
 1016         if (self::$_mb_string_overload) {
 1017             return mb_strlen($string, '8bit');
 1018         }
 1019         return strlen((binary) $string);
 1020     }
 1021 
 1022     /**
 1023      * Attempts to return a concrete IDNA instance.
 1024      *
 1025      * @param array $params Set of paramaters
 1026      * @return idna_convert
 1027      * @access public
 1028      */
 1029     public function getInstance($params = array())
 1030     {
 1031         return new idna_convert($params);
 1032     }
 1033 
 1034     /**
 1035      * Attempts to return a concrete IDNA instance for either php4 or php5,
 1036      * only creating a new instance if no IDNA instance with the same
 1037      * parameters currently exists.
 1038      *
 1039      * @param array $params Set of paramaters
 1040      *
 1041      * @return object idna_convert
 1042      * @access public
 1043      */
 1044     public function singleton($params = array())
 1045     {
 1046         static $instances = array();
 1047 
 1048         $signature = serialize($params);
 1049         if (!isset($instances[$signature])) {
 1050             $instances[$signature] = idna_convert::getInstance($params);
 1051         }
 1052         return $instances[$signature];
 1053     }
 1054 
 1055     /**
 1056      * Holds all relevant mapping tables
 1057      * See RFC3454 for details
 1058      *
 1059      * @private array
 1060      * @since 0.5.2
 1061      */
 1062     protected static $NP = array(
 1063             'map_nothing' => array(0xAD, 0x34F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B, 0x200C,
 1064                     0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07,
 1065                     0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF
 1066             ),
 1067             'general_prohibited' => array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
 1068                     20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
 1069                     43, 44, 47, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94, 95, 96, 123, 124, 125, 126, 127, 0x3002
 1070             ),
 1071             'prohibit' => array(0xA0, 0x340, 0x341, 0x6DD, 0x70F, 0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003,
 1072                     0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x200C, 0x200D, 0x200E, 0x200F,
 1073                     0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E, 0x202F, 0x205F, 0x206A, 0x206B, 0x206C,
 1074                     0x206D, 0x206E, 0x206F, 0x3000, 0x33C2, 0xFEFF, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
 1075                     0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE,
 1076                     0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, 0xBFFFF,
 1077                     0xCFFFE, 0xCFFFF, 0xDFFFE, 0xDFFFF, 0xE0001, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, 0x10FFFF
 1078             ),
 1079             'prohibit_ranges' => array(array(0x80, 0x9F), array(0x2060, 0x206F), array(0x1D173, 0x1D17A),
 1080                     array(0xE000, 0xF8FF), array(0xF0000, 0xFFFFD), array(0x100000, 0x10FFFD),
 1081                     array(0xFDD0, 0xFDEF), array(0xD800, 0xDFFF), array(0x2FF0, 0x2FFB), array(0xE0020, 0xE007F)
 1082             ),
 1083             'replacemaps_2003' => array(0x41 => array(0x61), 0x42 => array(0x62), 0x43 => array(0x63),
 1084                     0x44 => array(0x64), 0x45 => array(0x65), 0x46 => array(0x66), 0x47 => array(0x67),
 1085                     0x48 => array(0x68), 0x49 => array(0x69), 0x4A => array(0x6A), 0x4B => array(0x6B),
 1086                     0x4C => array(0x6C), 0x4D => array(0x6D), 0x4E => array(0x6E), 0x4F => array(0x6F),
 1087                     0x50 => array(0x70), 0x51 => array(0x71), 0x52 => array(0x72), 0x53 => array(0x73),
 1088                     0x54 => array(0x74), 0x55 => array(0x75), 0x56 => array(0x76), 0x57 => array(0x77),
 1089                     0x58 => array(0x78), 0x59 => array(0x79), 0x5A => array(0x7A), 0xB5 => array(0x3BC),
 1090                     0xC0 => array(0xE0), 0xC1 => array(0xE1), 0xC2 => array(0xE2), 0xC3 => array(0xE3),
 1091                     0xC4 => array(0xE4), 0xC5 => array(0xE5), 0xC6 => array(0xE6), 0xC7 => array(0xE7),
 1092                     0xC8 => array(0xE8), 0xC9 => array(0xE9), 0xCA => array(0xEA), 0xCB => array(0xEB),
 1093                     0xCC => array(0xEC), 0xCD => array(0xED), 0xCE => array(0xEE), 0xCF => array(0xEF),
 1094                     0xD0 => array(0xF0), 0xD1 => array(0xF1), 0xD2 => array(0xF2), 0xD3 => array(0xF3),
 1095                     0xD4 => array(0xF4), 0xD5 => array(0xF5), 0xD6 => array(0xF6), 0xD8 => array(0xF8),
 1096                     0xD9 => array(0xF9), 0xDA => array(0xFA), 0xDB => array(0xFB), 0xDC => array(0xFC),
 1097                     0xDD => array(0xFD), 0xDE => array(0xFE), 0xDF => array(0x73, 0x73),
 1098                     0x100 => array(0x101), 0x102 => array(0x103), 0x104 => array(0x105),
 1099                     0x106 => array(0x107), 0x108 => array(0x109), 0x10A => array(0x10B),
 1100                     0x10C => array(0x10D), 0x10E => array(0x10F), 0x110 => array(0x111),
 1101                     0x112 => array(0x113), 0x114 => array(0x115), 0x116 => array(0x117),
 1102                     0x118 => array(0x119), 0x11A => array(0x11B), 0x11C => array(0x11D),
 1103                     0x11E => array(0x11F), 0x120 => array(0x121), 0x122 => array(0x123),
 1104                     0x124 => array(0x125), 0x126 => array(0x127), 0x128 => array(0x129),
 1105                     0x12A => array(0x12B), 0x12C => array(0x12D), 0x12E => array(0x12F),
 1106                     0x130 => array(0x69, 0x307), 0x132 => array(0x133), 0x134 => array(0x135),
 1107                     0x136 => array(0x137), 0x139 => array(0x13A), 0x13B => array(0x13C),
 1108                     0x13D => array(0x13E), 0x13F => array(0x140), 0x141 => array(0x142),
 1109                     0x143 => array(0x144), 0x145 => array(0x146), 0x147 => array(0x148),
 1110                     0x149 => array(0x2BC, 0x6E), 0x14A => array(0x14B), 0x14C => array(0x14D),
 1111                     0x14E => array(0x14F), 0x150 => array(0x151), 0x152 => array(0x153),
 1112                     0x154 => array(0x155), 0x156 => array(0x157), 0x158 => array(0x159),
 1113                     0x15A => array(0x15B), 0x15C => array(0x15D), 0x15E => array(0x15F),
 1114                     0x160 => array(0x161), 0x162 => array(0x163), 0x164 => array(0x165),
 1115                     0x166 => array(0x167), 0x168 => array(0x169), 0x16A => array(0x16B),
 1116                     0x16C => array(0x16D), 0x16E => array(0x16F), 0x170 => array(0x171),
 1117                     0x172 => array(0x173), 0x174 => array(0x175), 0x176 => array(0x177),
 1118                     0x178 => array(0xFF), 0x179 => array(0x17A), 0x17B => array(0x17C),
 1119                     0x17D => array(0x17E), 0x17F => array(0x73), 0x181 => array(0x253),
 1120                     0x182 => array(0x183), 0x184 => array(0x185), 0x186 => array(0x254),
 1121                     0x187 => array(0x188), 0x189 => array(0x256), 0x18A => array(0x257),
 1122                     0x18B => array(0x18C), 0x18E => array(0x1DD), 0x18F => array(0x259),
 1123                     0x190 => array(0x25B), 0x191 => array(0x192), 0x193 => array(0x260),
 1124                     0x194 => array(0x263), 0x196 => array(0x269), 0x197 => array(0x268),
 1125                     0x198 => array(0x199), 0x19C => array(0x26F), 0x19D => array(0x272),
 1126                     0x19F => array(0x275), 0x1A0 => array(0x1A1), 0x1A2 => array(0x1A3),
 1127                     0x1A4 => array(0x1A5), 0x1A6 => array(0x280), 0x1A7 => array(0x1A8),
 1128                     0x1A9 => array(0x283), 0x1AC => array(0x1AD), 0x1AE => array(0x288),
 1129                     0x1AF => array(0x1B0), 0x1B1 => array(0x28A), 0x1B2 => array(0x28B),
 1130                     0x1B3 => array(0x1B4), 0x1B5 => array(0x1B6), 0x1B7 => array(0x292),
 1131                     0x1B8 => array(0x1B9), 0x1BC => array(0x1BD), 0x1C4 => array(0x1C6),
 1132                     0x1C5 => array(0x1C6), 0x1C7 => array(0x1C9), 0x1C8 => array(0x1C9),
 1133                     0x1CA => array(0x1CC), 0x1CB => array(0x1CC), 0x1CD => array(0x1CE),
 1134                     0x1CF => array(0x1D0), 0x1D1 => array(0x1D2), 0x1D3 => array(0x1D4),
 1135                     0x1D5 => array(0x1D6), 0x1D7 => array(0x1D8), 0x1D9 => array(0x1DA),
 1136                     0x1DB => array(0x1DC), 0x1DE => array(0x1DF), 0x1E0 => array(0x1E1),
 1137                     0x1E2 => array(0x1E3), 0x1E4 => array(0x1E5), 0x1E6 => array(0x1E7),
 1138                     0x1E8 => array(0x1E9), 0x1EA => array(0x1EB), 0x1EC => array(0x1ED),
 1139                     0x1EE => array(0x1EF), 0x1F0 => array(0x6A, 0x30C), 0x1F1 => array(0x1F3),
 1140                     0x1F2 => array(0x1F3), 0x1F4 => array(0x1F5), 0x1F6 => array(0x195),
 1141                     0x1F7 => array(0x1BF), 0x1F8 => array(0x1F9), 0x1FA => array(0x1FB),
 1142                     0x1FC => array(0x1FD), 0x1FE => array(0x1FF), 0x200 => array(0x201),
 1143                     0x202 => array(0x203), 0x204 => array(0x205), 0x206 => array(0x207),
 1144                     0x208 => array(0x209), 0x20A => array(0x20B), 0x20C => array(0x20D),
 1145                     0x20E => array(0x20F), 0x210 => array(0x211), 0x212 => array(0x213),
 1146                     0x214 => array(0x215), 0x216 => array(0x217), 0x218 => array(0x219),
 1147                     0x21A => array(0x21B), 0x21C => array(0x21D), 0x21E => array(0x21F),
 1148                     0x220 => array(0x19E), 0x222 => array(0x223), 0x224 => array(0x225),
 1149                     0x226 => array(0x227), 0x228 => array(0x229), 0x22A => array(0x22B),
 1150                     0x22C => array(0x22D), 0x22E => array(0x22F), 0x230 => array(0x231),
 1151                     0x232 => array(0x233), 0x345 => array(0x3B9), 0x37A => array(0x20, 0x3B9),
 1152                     0x386 => array(0x3AC), 0x388 => array(0x3AD), 0x389 => array(0x3AE),
 1153                     0x38A => array(0x3AF), 0x38C => array(0x3CC), 0x38E => array(0x3CD),
 1154                     0x38F => array(0x3CE), 0x390 => array(0x3B9, 0x308, 0x301),
 1155                     0x391 => array(0x3B1), 0x392 => array(0x3B2), 0x393 => array(0x3B3),
 1156                     0x394 => array(0x3B4), 0x395 => array(0x3B5), 0x396 => array(0x3B6),
 1157                     0x397 => array(0x3B7), 0x398 => array(0x3B8), 0x399 => array(0x3B9),
 1158                     0x39A => array(0x3BA), 0x39B => array(0x3BB), 0x39C => array(0x3BC),
 1159                     0x39D => array(0x3BD), 0x39E => array(0x3BE), 0x39F => array(0x3BF),
 1160                     0x3A0 => array(0x3C0), 0x3A1 => array(0x3C1), 0x3A3 => array(0x3C3),
 1161                     0x3A4 => array(0x3C4), 0x3A5 => array(0x3C5), 0x3A6 => array(0x3C6),
 1162                     0x3A7 => array(0x3C7), 0x3A8 => array(0x3C8), 0x3A9 => array(0x3C9),
 1163                     0x3AA => array(0x3CA), 0x3AB => array(0x3CB), 0x3B0 => array(0x3C5, 0x308, 0x301),
 1164                     0x3C2 => array(0x3C3), 0x3D0 => array(0x3B2), 0x3D1 => array(0x3B8),
 1165                     0x3D2 => array(0x3C5), 0x3D3 => array(0x3CD), 0x3D4 => array(0x3CB),
 1166                     0x3D5 => array(0x3C6), 0x3D6 => array(0x3C0), 0x3D8 => array(0x3D9),
 1167                     0x3DA => array(0x3DB), 0x3DC => array(0x3DD), 0x3DE => array(0x3DF),
 1168                     0x3E0 => array(0x3E1), 0x3E2 => array(0x3E3), 0x3E4 => array(0x3E5),
 1169                     0x3E6 => array(0x3E7), 0x3E8 => array(0x3E9), 0x3EA => array(0x3EB),
 1170                     0x3EC => array(0x3ED), 0x3EE => array(0x3EF), 0x3F0 => array(0x3BA),
 1171                     0x3F1 => array(0x3C1), 0x3F2 => array(0x3C3), 0x3F4 => array(0x3B8),
 1172                     0x3F5 => array(0x3B5), 0x400 => array(0x450), 0x401 => array(0x451),
 1173                     0x402 => array(0x452), 0x403 => array(0x453), 0x404 => array(0x454),
 1174                     0x405 => array(0x455), 0x406 => array(0x456), 0x407 => array(0x457),
 1175                     0x408 => array(0x458), 0x409 => array(0x459), 0x40A => array(0x45A),
 1176                     0x40B => array(0x45B), 0x40C => array(0x45C), 0x40D => array(0x45D),
 1177                     0x40E => array(0x45E), 0x40F => array(0x45F), 0x410 => array(0x430),
 1178                     0x411 => array(0x431), 0x412 => array(0x432), 0x413 => array(0x433),
 1179                     0x414 => array(0x434), 0x415 => array(0x435), 0x416 => array(0x436),
 1180                     0x417 => array(0x437), 0x418 => array(0x438), 0x419 => array(0x439),
 1181                     0x41A => array(0x43A), 0x41B => array(0x43B), 0x41C => array(0x43C),
 1182                     0x41D => array(0x43D), 0x41E => array(0x43E), 0x41F => array(0x43F),
 1183                     0x420 => array(0x440), 0x421 => array(0x441), 0x422 => array(0x442),
 1184                     0x423 => array(0x443), 0x424 => array(0x444), 0x425 => array(0x445),
 1185                     0x426 => array(0x446), 0x427 => array(0x447), 0x428 => array(0x448),
 1186                     0x429 => array(0x449), 0x42A => array(0x44A), 0x42B => array(0x44B),
 1187                     0x42C => array(0x44C), 0x42D => array(0x44D), 0x42E => array(0x44E),
 1188                     0x42F => array(0x44F), 0x460 => array(0x461), 0x462 => array(0x463),
 1189                     0x464 => array(0x465), 0x466 => array(0x467), 0x468 => array(0x469),
 1190                     0x46A => array(0x46B), 0x46C => array(0x46D), 0x46E => array(0x46F),
 1191                     0x470 => array(0x471), 0x472 => array(0x473), 0x474 => array(0x475),
 1192                     0x476 => array(0x477), 0x478 => array(0x479), 0x47A => array(0x47B),
 1193                     0x47C => array(0x47D), 0x47E => array(0x47F), 0x480 => array(0x481),
 1194                     0x48A => array(0x48B), 0x48C => array(0x48D), 0x48E => array(0x48F),
 1195                     0x490 => array(0x491), 0x492 => array(0x493), 0x494 => array(0x495),
 1196                     0x496 => array(0x497), 0x498 => array(0x499), 0x49A => array(0x49B),
 1197                     0x49C => array(0x49D), 0x49E => array(0x49F), 0x4A0 => array(0x4A1),
 1198                     0x4A2 => array(0x4A3), 0x4A4 => array(0x4A5), 0x4A6 => array(0x4A7),
 1199                     0x4A8 => array(0x4A9), 0x4AA => array(0x4AB), 0x4AC => array(0x4AD),
 1200                     0x4AE => array(0x4AF), 0x4B0 => array(0x4B1), 0x4B2 => array(0x4B3),
 1201                     0x4B4 => array(0x4B5), 0x4B6 => array(0x4B7), 0x4B8 => array(0x4B9),
 1202                     0x4BA => array(0x4BB), 0x4BC => array(0x4BD), 0x4BE => array(0x4BF),
 1203                     0x4C1 => array(0x4C2), 0x4C3 => array(0x4C4), 0x4C5 => array(0x4C6),
 1204                     0x4C7 => array(0x4C8), 0x4C9 => array(0x4CA), 0x4CB => array(0x4CC),
 1205                     0x4CD => array(0x4CE), 0x4D0 => array(0x4D1), 0x4D2 => array(0x4D3),
 1206                     0x4D4 => array(0x4D5), 0x4D6 => array(0x4D7), 0x4D8 => array(0x4D9),
 1207                     0x4DA => array(0x4DB), 0x4DC => array(0x4DD), 0x4DE => array(0x4DF),
 1208                     0x4E0 => array(0x4E1), 0x4E2 => array(0x4E3), 0x4E4 => array(0x4E5),
 1209                     0x4E6 => array(0x4E7), 0x4E8 => array(0x4E9), 0x4EA => array(0x4EB),
 1210                     0x4EC => array(0x4ED), 0x4EE => array(0x4EF), 0x4F0 => array(0x4F1),
 1211                     0x4F2 => array(0x4F3), 0x4F4 => array(0x4F5), 0x4F8 => array(0x4F9),
 1212                     0x500 => array(0x501), 0x502 => array(0x503), 0x504 => array(0x505),
 1213                     0x506 => array(0x507), 0x508 => array(0x509), 0x50A => array(0x50B),
 1214                     0x50C => array(0x50D), 0x50E => array(0x50F), 0x531 => array(0x561),
 1215                     0x532 => array(0x562), 0x533 => array(0x563), 0x534 => array(0x564),
 1216                     0x535 => array(0x565), 0x536 => array(0x566), 0x537 => array(0x567),
 1217                     0x538 => array(0x568), 0x539 => array(0x569), 0x53A => array(0x56A),
 1218                     0x53B => array(0x56B), 0x53C => array(0x56C), 0x53D => array(0x56D),
 1219                     0x53E => array(0x56E), 0x53F => array(0x56F), 0x540 => array(0x570),
 1220                     0x541 => array(0x571), 0x542 => array(0x572), 0x543 => array(0x573),
 1221                     0x544 => array(0x574), 0x545 => array(0x575), 0x546 => array(0x576),
 1222                     0x547 => array(0x577), 0x548 => array(0x578), 0x549 => array(0x579),
 1223                     0x54A => array(0x57A), 0x54B => array(0x57B), 0x54C => array(0x57C),
 1224                     0x54D => array(0x57D), 0x54E => array(0x57E), 0x54F => array(0x57F),
 1225                     0x550 => array(0x580), 0x551 => array(0x581), 0x552 => array(0x582),
 1226                     0x553 => array(0x583), 0x554 => array(0x584), 0x555 => array(0x585),
 1227                     0x556 => array(0x586), 0x587 => array(0x565, 0x582), 0xE33 => array(0xE4D, 0xE32),
 1228                     0x1E00 => array(0x1E01), 0x1E02 => array(0x1E03), 0x1E04 => array(0x1E05),
 1229                     0x1E06 => array(0x1E07), 0x1E08 => array(0x1E09), 0x1E0A => array(0x1E0B),
 1230                     0x1E0C => array(0x1E0D), 0x1E0E => array(0x1E0F), 0x1E10 => array(0x1E11),
 1231                     0x1E12 => array(0x1E13), 0x1E14 => array(0x1E15), 0x1E16 => array(0x1E17),
 1232                     0x1E18 => array(0x1E19), 0x1E1A => array(0x1E1B), 0x1E1C => array(0x1E1D),
 1233                     0x1E1E => array(0x1E1F), 0x1E20 => array(0x1E21), 0x1E22 => array(0x1E23),
 1234                     0x1E24 => array(0x1E25), 0x1E26 => array(0x1E27), 0x1E28 => array(0x1E29),
 1235                     0x1E2A => array(0x1E2B), 0x1E2C => array(0x1E2D), 0x1E2E => array(0x1E2F),
 1236                     0x1E30 => array(0x1E31), 0x1E32 => array(0x1E33), 0x1E34 => array(0x1E35),
 1237                     0x1E36 => array(0x1E37), 0x1E38 => array(0x1E39), 0x1E3A => array(0x1E3B),
 1238                     0x1E3C => array(0x1E3D), 0x1E3E => array(0x1E3F), 0x1E40 => array(0x1E41),
 1239                     0x1E42 => array(0x1E43), 0x1E44 => array(0x1E45), 0x1E46 => array(0x1E47),
 1240                     0x1E48 => array(0x1E49), 0x1E4A => array(0x1E4B), 0x1E4C => array(0x1E4D),
 1241                     0x1E4E => array(0x1E4F), 0x1E50 => array(0x1E51), 0x1E52 => array(0x1E53),
 1242                     0x1E54 => array(0x1E55), 0x1E56 => array(0x1E57), 0x1E58 => array(0x1E59),
 1243                     0x1E5A => array(0x1E5B), 0x1E5C => array(0x1E5D), 0x1E5E => array(0x1E5F),
 1244                     0x1E60 => array(0x1E61), 0x1E62 => array(0x1E63), 0x1E64 => array(0x1E65),
 1245                     0x1E66 => array(0x1E67), 0x1E68 => array(0x1E69), 0x1E6A => array(0x1E6B),
 1246                     0x1E6C => array(0x1E6D), 0x1E6E => array(0x1E6F), 0x1E70 => array(0x1E71),
 1247                     0x1E72 => array(0x1E73), 0x1E74 => array(0x1E75), 0x1E76 => array(0x1E77),
 1248                     0x1E78 => array(0x1E79), 0x1E7A => array(0x1E7B), 0x1E7C => array(0x1E7D),
 1249                     0x1E7E => array(0x1E7F), 0x1E80 => array(0x1E81), 0x1E82 => array(0x1E83),
 1250                     0x1E84 => array(0x1E85), 0x1E86 => array(0x1E87), 0x1E88 => array(0x1E89),
 1251                     0x1E8A => array(0x1E8B), 0x1E8C => array(0x1E8D), 0x1E8E => array(0x1E8F),
 1252                     0x1E90 => array(0x1E91), 0x1E92 => array(0x1E93), 0x1E94 => array(0x1E95),
 1253                     0x1E96 => array(0x68, 0x331), 0x1E97 => array(0x74, 0x308), 0x1E98 => array(0x77, 0x30A),
 1254                     0x1E99 => array(0x79, 0x30A), 0x1E9A => array(0x61, 0x2BE), 0x1E9B => array(0x1E61),
 1255                     0x1EA0 => array(0x1EA1), 0x1EA2 => array(0x1EA3), 0x1EA4 => array(0x1EA5),
 1256                     0x1EA6 => array(0x1EA7), 0x1EA8 => array(0x1EA9), 0x1EAA => array(0x1EAB),
 1257                     0x1EAC => array(0x1EAD), 0x1EAE => array(0x1EAF), 0x1EB0 => array(0x1EB1),
 1258                     0x1EB2 => array(0x1EB3), 0x1EB4 => array(0x1EB5), 0x1EB6 => array(0x1EB7),
 1259                     0x1EB8 => array(0x1EB9), 0x1EBA => array(0x1EBB), 0x1EBC => array(0x1EBD),
 1260                     0x1EBE => array(0x1EBF), 0x1EC0 => array(0x1EC1), 0x1EC2 => array(0x1EC3),
 1261                     0x1EC4 => array(0x1EC5), 0x1EC6 => array(0x1EC7), 0x1EC8 => array(0x1EC9),
 1262                     0x1ECA => array(0x1ECB), 0x1ECC => array(0x1ECD), 0x1ECE => array(0x1ECF),
 1263                     0x1ED0 => array(0x1ED1), 0x1ED2 => array(0x1ED3), 0x1ED4 => array(0x1ED5),
 1264                     0x1ED6 => array(0x1ED7), 0x1ED8 => array(0x1ED9), 0x1EDA => array(0x1EDB),
 1265                     0x1EDC => array(0x1EDD), 0x1EDE => array(0x1EDF), 0x1EE0 => array(0x1EE1),
 1266                     0x1EE2 => array(0x1EE3), 0x1EE4 => array(0x1EE5), 0x1EE6 => array(0x1EE7),
 1267                     0x1EE8 => array(0x1EE9), 0x1EEA => array(0x1EEB), 0x1EEC => array(0x1EED),
 1268                     0x1EEE => array(0x1EEF), 0x1EF0 => array(0x1EF1), 0x1EF2 => array(0x1EF3),
 1269                     0x1EF4 => array(0x1EF5), 0x1EF6 => array(0x1EF7), 0x1EF8 => array(0x1EF9),
 1270                     0x1F08 => array(0x1F00), 0x1F09 => array(0x1F01), 0x1F0A => array(0x1F02),
 1271                     0x1F0B => array(0x1F03), 0x1F0C => array(0x1F04), 0x1F0D => array(0x1F05),
 1272                     0x1F0E => array(0x1F06), 0x1F0F => array(0x1F07), 0x1F18 => array(0x1F10),
 1273                     0x1F19 => array(0x1F11), 0x1F1A => array(0x1F12), 0x1F1B => array(0x1F13),
 1274                     0x1F1C => array(0x1F14), 0x1F1D => array(0x1F15), 0x1F28 => array(0x1F20),
 1275                     0x1F29 => array(0x1F21), 0x1F2A => array(0x1F22), 0x1F2B => array(0x1F23),
 1276                     0x1F2C => array(0x1F24), 0x1F2D => array(0x1F25), 0x1F2E => array(0x1F26),
 1277                     0x1F2F => array(0x1F27), 0x1F38 => array(0x1F30), 0x1F39 => array(0x1F31),
 1278                     0x1F3A => array(0x1F32), 0x1F3B => array(0x1F33), 0x1F3C => array(0x1F34),
 1279                     0x1F3D => array(0x1F35), 0x1F3E => array(0x1F36), 0x1F3F => array(0x1F37),
 1280                     0x1F48 => array(0x1F40), 0x1F49 => array(0x1F41), 0x1F4A => array(0x1F42),
 1281                     0x1F4B => array(0x1F43), 0x1F4C => array(0x1F44), 0x1F4D => array(0x1F45),
 1282                     0x1F50 => array(0x3C5, 0x313), 0x1F52 => array(0x3C5, 0x313, 0x300),
 1283                     0x1F54 => array(0x3C5, 0x313, 0x301), 0x1F56 => array(0x3C5, 0x313, 0x342),
 1284                     0x1F59 => array(0x1F51), 0x1F5B => array(0x1F53), 0x1F5D => array(0x1F55),
 1285                     0x1F5F => array(0x1F57), 0x1F68 => array(0x1F60), 0x1F69 => array(0x1F61),
 1286                     0x1F6A => array(0x1F62), 0x1F6B => array(0x1F63), 0x1F6C => array(0x1F64),
 1287                     0x1F6D => array(0x1F65), 0x1F6E => array(0x1F66), 0x1F6F => array(0x1F67),
 1288                     0x1F80 => array(0x1F00, 0x3B9), 0x1F81 => array(0x1F01, 0x3B9),
 1289                     0x1F82 => array(0x1F02, 0x3B9), 0x1F83 => array(0x1F03, 0x3B9),
 1290                     0x1F84 => array(0x1F04, 0x3B9), 0x1F85 => array(0x1F05, 0x3B9),
 1291                     0x1F86 => array(0x1F06, 0x3B9), 0x1F87 => array(0x1F07, 0x3B9),
 1292                     0x1F88 => array(0x1F00, 0x3B9), 0x1F89 => array(0x1F01, 0x3B9),
 1293                     0x1F8A => array(0x1F02, 0x3B9), 0x1F8B => array(0x1F03, 0x3B9),
 1294                     0x1F8C => array(0x1F04, 0x3B9), 0x1F8D => array(0x1F05, 0x3B9),
 1295                     0x1F8E => array(0x1F06, 0x3B9), 0x1F8F => array(0x1F07, 0x3B9),
 1296                     0x1F90 => array(0x1F20, 0x3B9), 0x1F91 => array(0x1F21, 0x3B9),
 1297                     0x1F92 => array(0x1F22, 0x3B9), 0x1F93 => array(0x1F23, 0x3B9),
 1298                     0x1F94 => array(0x1F24, 0x3B9), 0x1F95 => array(0x1F25, 0x3B9),
 1299                     0x1F96 => array(0x1F26, 0x3B9), 0x1F97 => array(0x1F27, 0x3B9),
 1300                     0x1F98 => array(0x1F20, 0x3B9), 0x1F99 => array(0x1F21, 0x3B9),
 1301                     0x1F9A => array(0x1F22, 0x3B9), 0x1F9B => array(0x1F23, 0x3B9),
 1302                     0x1F9C => array(0x1F24, 0x3B9), 0x1F9D => array(0x1F25, 0x3B9),
 1303                     0x1F9E => array(0x1F26, 0x3B9), 0x1F9F => array(0x1F27, 0x3B9),
 1304                     0x1FA0 => array(0x1F60, 0x3B9), 0x1FA1 => array(0x1F61, 0x3B9),
 1305                     0x1FA2 => array(0x1F62, 0x3B9), 0x1FA3 => array(0x1F63, 0x3B9),
 1306                     0x1FA4 => array(0x1F64, 0x3B9), 0x1FA5 => array(0x1F65, 0x3B9),
 1307                     0x1FA6 => array(0x1F66, 0x3B9), 0x1FA7 => array(0x1F67, 0x3B9),
 1308                     0x1FA8 => array(0x1F60, 0x3B9), 0x1FA9 => array(0x1F61, 0x3B9),
 1309                     0x1FAA => array(0x1F62, 0x3B9), 0x1FAB => array(0x1F63, 0x3B9),
 1310                     0x1FAC => array(0x1F64, 0x3B9), 0x1FAD => array(0x1F65, 0x3B9),
 1311                     0x1FAE => array(0x1F66, 0x3B9), 0x1FAF => array(0x1F67, 0x3B9),
 1312                     0x1FB2 => array(0x1F70, 0x3B9), 0x1FB3 => array(0x3B1, 0x3B9),
 1313                     0x1FB4 => array(0x3AC, 0x3B9), 0x1FB6 => array(0x3B1, 0x342),
 1314                     0x1FB7 => array(0x3B1, 0x342, 0x3B9), 0x1FB8 => array(0x1FB0),
 1315                     0x1FB9 => array(0x1FB1), 0x1FBA => array(0x1F70), 0x1FBB => array(0x1F71),
 1316                     0x1FBC => array(0x3B1, 0x3B9), 0x1FBE => array(0x3B9),
 1317                     0x1FC2 => array(0x1F74, 0x3B9), 0x1FC3 => array(0x3B7, 0x3B9),
 1318                     0x1FC4 => array(0x3AE, 0x3B9), 0x1FC6 => array(0x3B7, 0x342),
 1319                     0x1FC7 => array(0x3B7, 0x342, 0x3B9), 0x1FC8 => array(0x1F72),
 1320                     0x1FC9 => array(0x1F73), 0x1FCA => array(0x1F74), 0x1FCB => array(0x1F75),
 1321                     0x1FCC => array(0x3B7, 0x3B9), 0x1FD2 => array(0x3B9, 0x308, 0x300),
 1322                     0x1FD3 => array(0x3B9, 0x308, 0x301), 0x1FD6 => array(0x3B9, 0x342),
 1323                     0x1FD7 => array(0x3B9, 0x308, 0x342), 0x1FD8 => array(0x1FD0),
 1324                     0x1FD9 => array(0x1FD1), 0x1FDA => array(0x1F76),
 1325                     0x1FDB => array(0x1F77), 0x1FE2 => array(0x3C5, 0x308, 0x300),
 1326                     0x1FE3 => array(0x3C5, 0x308, 0x301), 0x1FE4 => array(0x3C1, 0x313),
 1327                     0x1FE6 => array(0x3C5, 0x342), 0x1FE7 => array(0x3C5, 0x308, 0x342),
 1328                     0x1FE8 => array(0x1FE0), 0x1FE9 => array(0x1FE1),
 1329                     0x1FEA => array(0x1F7A), 0x1FEB => array(0x1F7B),
 1330                     0x1FEC => array(0x1FE5), 0x1FF2 => array(0x1F7C, 0x3B9),
 1331                     0x1FF3 => array(0x3C9, 0x3B9), 0x1FF4 => array(0x3CE, 0x3B9),
 1332                     0x1FF6 => array(0x3C9, 0x342), 0x1FF7 => array(0x3C9, 0x342, 0x3B9),
 1333                     0x1FF8 => array(0x1F78), 0x1FF9 => array(0x1F79), 0x1FFA => array(0x1F7C),
 1334                     0x1FFB => array(0x1F7D), 0x1FFC => array(0x3C9, 0x3B9),
 1335                     0x20A8 => array(0x72, 0x73), 0x2102 => array(0x63), 0x2103 => array(0xB0, 0x63),
 1336                     0x2107 => array(0x25B), 0x2109 => array(0xB0, 0x66), 0x210B => array(0x68),
 1337                     0x210C => array(0x68), 0x210D => array(0x68), 0x2110 => array(0x69),
 1338                     0x2111 => array(0x69), 0x2112 => array(0x6C), 0x2115 => array(0x6E),
 1339                     0x2116 => array(0x6E, 0x6F), 0x2119 => array(0x70), 0x211A => array(0x71),
 1340                     0x211B => array(0x72), 0x211C => array(0x72), 0x211D => array(0x72),
 1341                     0x2120 => array(0x73, 0x6D), 0x2121 => array(0x74, 0x65, 0x6C),
 1342                     0x2122 => array(0x74, 0x6D), 0x2124 => array(0x7A), 0x2126 => array(0x3C9),
 1343                     0x2128 => array(0x7A), 0x212A => array(0x6B), 0x212B => array(0xE5),
 1344                     0x212C => array(0x62), 0x212D => array(0x63), 0x2130 => array(0x65),
 1345                     0x2131 => array(0x66), 0x2133 => array(0x6D), 0x213E => array(0x3B3),
 1346                     0x213F => array(0x3C0), 0x2145 => array(0x64), 0x2160 => array(0x2170),
 1347                     0x2161 => array(0x2171), 0x2162 => array(0x2172), 0x2163 => array(0x2173),
 1348                     0x2164 => array(0x2174), 0x2165 => array(0x2175), 0x2166 => array(0x2176),
 1349                     0x2167 => array(0x2177), 0x2168 => array(0x2178), 0x2169 => array(0x2179),
 1350                     0x216A => array(0x217A), 0x216B => array(0x217B), 0x216C => array(0x217C),
 1351                     0x216D => array(0x217D), 0x216E => array(0x217E), 0x216F => array(0x217F),
 1352                     0x24B6 => array(0x24D0), 0x24B7 => array(0x24D1), 0x24B8 => array(0x24D2),
 1353                     0x24B9 => array(0x24D3), 0x24BA => array(0x24D4), 0x24BB => array(0x24D5),
 1354                     0x24BC => array(0x24D6), 0x24BD => array(0x24D7), 0x24BE => array(0x24D8),
 1355                     0x24BF => array(0x24D9), 0x24C0 => array(0x24DA), 0x24C1 => array(0x24DB),
 1356                     0x24C2 => array(0x24DC), 0x24C3 => array(0x24DD), 0x24C4 => array(0x24DE),
 1357                     0x24C5 => array(0x24DF), 0x24C6 => array(0x24E0), 0x24C7 => array(0x24E1),
 1358                     0x24C8 => array(0x24E2), 0x24C9 => array(0x24E3), 0x24CA => array(0x24E4),
 1359                     0x24CB => array(0x24E5), 0x24CC => array(0x24E6), 0x24CD => array(0x24E7),
 1360                     0x24CE => array(0x24E8), 0x24CF => array(0x24E9), 0x3371 => array(0x68, 0x70, 0x61),
 1361                     0x3373 => array(0x61, 0x75), 0x3375 => array(0x6F, 0x76),
 1362                     0x3380 => array(0x70, 0x61), 0x3381 => array(0x6E, 0x61),
 1363                     0x3382 => array(0x3BC, 0x61), 0x3383 => array(0x6D, 0x61),
 1364                     0x3384 => array(0x6B, 0x61), 0x3385 => array(0x6B, 0x62),
 1365                     0x3386 => array(0x6D, 0x62), 0x3387 => array(0x67, 0x62),
 1366                     0x338A => array(0x70, 0x66), 0x338B => array(0x6E, 0x66),
 1367                     0x338C => array(0x3BC, 0x66), 0x3390 => array(0x68, 0x7A),
 1368                     0x3391 => array(0x6B, 0x68, 0x7A), 0x3392 => array(0x6D, 0x68, 0x7A),
 1369                     0x3393 => array(0x67, 0x68, 0x7A), 0x3394 => array(0x74, 0x68, 0x7A),
 1370                     0x33A9 => array(0x70, 0x61), 0x33AA => array(0x6B, 0x70, 0x61),
 1371                     0x33AB => array(0x6D, 0x70, 0x61), 0x33AC => array(0x67, 0x70, 0x61),
 1372                     0x33B4 => array(0x70, 0x76), 0x33B5 => array(0x6E, 0x76),
 1373                     0x33B6 => array(0x3BC, 0x76), 0x33B7 => array(0x6D, 0x76),
 1374                     0x33B8 => array(0x6B, 0x76), 0x33B9 => array(0x6D, 0x76),
 1375                     0x33BA => array(0x70, 0x77), 0x33BB => array(0x6E, 0x77),
 1376                     0x33BC => array(0x3BC, 0x77), 0x33BD => array(0x6D, 0x77),
 1377                     0x33BE => array(0x6B, 0x77), 0x33BF => array(0x6D, 0x77),
 1378                     0x33C0 => array(0x6B, 0x3C9), 0x33C1 => array(0x6D, 0x3C9), /*
 1379                     0x33C2  => array(0x61, 0x2E, 0x6D, 0x2E), */
 1380                     0x33C3 => array(0x62, 0x71), 0x33C6 => array(0x63, 0x2215, 0x6B, 0x67),
 1381                     0x33C7 => array(0x63, 0x6F, 0x2E), 0x33C8 => array(0x64, 0x62),
 1382                     0x33C9 => array(0x67, 0x79), 0x33CB => array(0x68, 0x70),
 1383                     0x33CD => array(0x6B, 0x6B), 0x33CE => array(0x6B, 0x6D),
 1384                     0x33D7 => array(0x70, 0x68), 0x33D9 => array(0x70, 0x70, 0x6D),
 1385                     0x33DA => array(0x70, 0x72), 0x33DC => array(0x73, 0x76),
 1386                     0x33DD => array(0x77, 0x62), 0xFB00 => array(0x66, 0x66),
 1387                     0xFB01 => array(0x66, 0x69), 0xFB02 => array(0x66, 0x6C),
 1388                     0xFB03 => array(0x66, 0x66, 0x69), 0xFB04 => array(0x66, 0x66, 0x6C),
 1389                     0xFB05 => array(0x73, 0x74), 0xFB06 => array(0x73, 0x74),
 1390                     0xFB13 => array(0x574, 0x576), 0xFB14 => array(0x574, 0x565),
 1391                     0xFB15 => array(0x574, 0x56B), 0xFB16 => array(0x57E, 0x576),
 1392                     0xFB17 => array(0x574, 0x56D), 0xFF21 => array(0xFF41),
 1393                     0xFF22 => array(0xFF42), 0xFF23 => array(0xFF43), 0xFF24 => array(0xFF44),
 1394                     0xFF25 => array(0xFF45), 0xFF26 => array(0xFF46), 0xFF27 => array(0xFF47),
 1395                     0xFF28 => array(0xFF48), 0xFF29 => array(0xFF49), 0xFF2A => array(0xFF4A),
 1396                     0xFF2B => array(0xFF4B), 0xFF2C => array(0xFF4C), 0xFF2D => array(0xFF4D),
 1397                     0xFF2E => array(0xFF4E), 0xFF2F => array(0xFF4F), 0xFF30 => array(0xFF50),
 1398                     0xFF31 => array(0xFF51), 0xFF32 => array(0xFF52), 0xFF33 => array(0xFF53),
 1399                     0xFF34 => array(0xFF54), 0xFF35 => array(0xFF55), 0xFF36 => array(0xFF56),
 1400                     0xFF37 => array(0xFF57), 0xFF38 => array(0xFF58), 0xFF39 => array(0xFF59),
 1401                     0xFF3A => array(0xFF5A), 0x10400 => array(0x10428), 0x10401 => array(0x10429),
 1402                     0x10402 => array(0x1042A), 0x10403 => array(0x1042B), 0x10404 => array(0x1042C),
 1403                     0x10405 => array(0x1042D), 0x10406 => array(0x1042E), 0x10407 => array(0x1042F),
 1404                     0x10408 => array(0x10430), 0x10409 => array(0x10431), 0x1040A => array(0x10432),
 1405                     0x1040B => array(0x10433), 0x1040C => array(0x10434), 0x1040D => array(0x10435),
 1406                     0x1040E => array(0x10436), 0x1040F => array(0x10437), 0x10410 => array(0x10438),
 1407                     0x10411 => array(0x10439), 0x10412 => array(0x1043A), 0x10413 => array(0x1043B),
 1408                     0x10414 => array(0x1043C), 0x10415 => array(0x1043D), 0x10416 => array(0x1043E),
 1409                     0x10417 => array(0x1043F), 0x10418 => array(0x10440), 0x10419 => array(0x10441),
 1410                     0x1041A => array(0x10442), 0x1041B => array(0x10443), 0x1041C => array(0x10444),
 1411                     0x1041D => array(0x10445), 0x1041E => array(0x10446), 0x1041F => array(0x10447),
 1412                     0x10420 => array(0x10448), 0x10421 => array(0x10449), 0x10422 => array(0x1044A),
 1413                     0x10423 => array(0x1044B), 0x10424 => array(0x1044C), 0x10425 => array(0x1044D),
 1414                     0x1D400 => array(0x61), 0x1D401 => array(0x62), 0x1D402 => array(0x63),
 1415                     0x1D403 => array(0x64), 0x1D404 => array(0x65), 0x1D405 => array(0x66),
 1416                     0x1D406 => array(0x67), 0x1D407 => array(0x68), 0x1D408 => array(0x69),
 1417                     0x1D409 => array(0x6A), 0x1D40A => array(0x6B), 0x1D40B => array(0x6C),
 1418                     0x1D40C => array(0x6D), 0x1D40D => array(0x6E), 0x1D40E => array(0x6F),
 1419                     0x1D40F => array(0x70), 0x1D410 => array(0x71), 0x1D411 => array(0x72),
 1420                     0x1D412 => array(0x73), 0x1D413 => array(0x74), 0x1D414 => array(0x75),
 1421                     0x1D415 => array(0x76), 0x1D416 => array(0x77), 0x1D417 => array(0x78),
 1422                     0x1D418 => array(0x79), 0x1D419 => array(0x7A), 0x1D434 => array(0x61),
 1423                     0x1D435 => array(0x62), 0x1D436 => array(0x63), 0x1D437 => array(0x64),
 1424                     0x1D438 => array(0x65), 0x1D439 => array(0x66), 0x1D43A => array(0x67),
 1425                     0x1D43B => array(0x68), 0x1D43C => array(0x69), 0x1D43D => array(0x6A),
 1426                     0x1D43E => array(0x6B), 0x1D43F => array(0x6C), 0x1D440 => array(0x6D),
 1427                     0x1D441 => array(0x6E), 0x1D442 => array(0x6F), 0x1D443 => array(0x70),
 1428                     0x1D444 => array(0x71), 0x1D445 => array(0x72), 0x1D446 => array(0x73),
 1429                     0x1D447 => array(0x74), 0x1D448 => array(0x75), 0x1D449 => array(0x76),
 1430                     0x1D44A => array(0x77), 0x1D44B => array(0x78), 0x1D44C => array(0x79),
 1431                     0x1D44D => array(0x7A), 0x1D468 => array(0x61), 0x1D469 => array(0x62),
 1432                     0x1D46A => array(0x63), 0x1D46B => array(0x64), 0x1D46C => array(0x65),
 1433                     0x1D46D => array(0x66), 0x1D46E => array(0x67), 0x1D46F => array(0x68),
 1434                     0x1D470 => array(0x69), 0x1D471 => array(0x6A), 0x1D472 => array(0x6B),
 1435                     0x1D473 => array(0x6C), 0x1D474 => array(0x6D), 0x1D475 => array(0x6E),
 1436                     0x1D476 => array(0x6F), 0x1D477 => array(0x70), 0x1D478 => array(0x71),
 1437                     0x1D479 => array(0x72), 0x1D47A => array(0x73), 0x1D47B => array(0x74),
 1438                     0x1D47C => array(0x75), 0x1D47D => array(0x76), 0x1D47E => array(0x77),
 1439                     0x1D47F => array(0x78), 0x1D480 => array(0x79), 0x1D481 => array(0x7A),
 1440                     0x1D49C => array(0x61), 0x1D49E => array(0x63), 0x1D49F => array(0x64),
 1441                     0x1D4A2 => array(0x67), 0x1D4A5 => array(0x6A), 0x1D4A6 => array(0x6B),
 1442                     0x1D4A9 => array(0x6E), 0x1D4AA => array(0x6F), 0x1D4AB => array(0x70),
 1443                     0x1D4AC => array(0x71), 0x1D4AE => array(0x73), 0x1D4AF => array(0x74),
 1444                     0x1D4B0 => array(0x75), 0x1D4B1 => array(0x76), 0x1D4B2 => array(0x77),
 1445                     0x1D4B3 => array(0x78), 0x1D4B4 => array(0x79), 0x1D4B5 => array(0x7A),
 1446                     0x1D4D0 => array(0x61), 0x1D4D1 => array(0x62), 0x1D4D2 => array(0x63),
 1447                     0x1D4D3 => array(0x64), 0x1D4D4 => array(0x65), 0x1D4D5 => array(0x66),
 1448                     0x1D4D6 => array(0x67), 0x1D4D7 => array(0x68), 0x1D4D8 => array(0x69),
 1449                     0x1D4D9 => array(0x6A), 0x1D4DA => array(0x6B), 0x1D4DB => array(0x6C),
 1450                     0x1D4DC => array(0x6D), 0x1D4DD => array(0x6E), 0x1D4DE => array(0x6F),
 1451                     0x1D4DF => array(0x70), 0x1D4E0 => array(0x71), 0x1D4E1 => array(0x72),
 1452                     0x1D4E2 => array(0x73), 0x1D4E3 => array(0x74), 0x1D4E4 => array(0x75),
 1453                     0x1D4E5 => array(0x76), 0x1D4E6 => array(0x77), 0x1D4E7 => array(0x78),
 1454                     0x1D4E8 => array(0x79), 0x1D4E9 => array(0x7A), 0x1D504 => array(0x61),
 1455                     0x1D505 => array(0x62), 0x1D507 => array(0x64), 0x1D508 => array(0x65),
 1456                     0x1D509 => array(0x66), 0x1D50A => array(0x67), 0x1D50D => array(0x6A),
 1457                     0x1D50E => array(0x6B), 0x1D50F => array(0x6C), 0x1D510 => array(0x6D),
 1458                     0x1D511 => array(0x6E), 0x1D512 => array(0x6F), 0x1D513 => array(0x70),
 1459                     0x1D514 => array(0x71), 0x1D516 => array(0x73), 0x1D517 => array(0x74),
 1460                     0x1D518 => array(0x75), 0x1D519 => array(0x76), 0x1D51A => array(0x77),
 1461                     0x1D51B => array(0x78), 0x1D51C => array(0x79), 0x1D538 => array(0x61),
 1462                     0x1D539 => array(0x62), 0x1D53B => array(0x64), 0x1D53C => array(0x65),
 1463                     0x1D53D => array(0x66), 0x1D53E => array(0x67), 0x1D540 => array(0x69),
 1464                     0x1D541 => array(0x6A), 0x1D542 => array(0x6B), 0x1D543 => array(0x6C),
 1465                     0x1D544 => array(0x6D), 0x1D546 => array(0x6F), 0x1D54A => array(0x73),
 1466                     0x1D54B => array(0x74), 0x1D54C => array(0x75), 0x1D54D => array(0x76),
 1467                     0x1D54E => array(0x77), 0x1D54F => array(0x78), 0x1D550 => array(0x79),
 1468                     0x1D56C => array(0x61), 0x1D56D => array(0x62), 0x1D56E => array(0x63),
 1469                     0x1D56F => array(0x64), 0x1D570 => array(0x65), 0x1D571 => array(0x66),
 1470                     0x1D572 => array(0x67), 0x1D573 => array(0x68), 0x1D574 => array(0x69),
 1471                     0x1D575 => array(0x6A), 0x1D576 => array(0x6B), 0x1D577 => array(0x6C),
 1472                     0x1D578 => array(0x6D), 0x1D579 => array(0x6E), 0x1D57A => array(0x6F),
 1473                     0x1D57B => array(0x70), 0x1D57C => array(0x71), 0x1D57D => array(0x72),
 1474                     0x1D57E => array(0x73), 0x1D57F => array(0x74), 0x1D580 => array(0x75),
 1475                     0x1D581 => array(0x76), 0x1D582 => array(0x77), 0x1D583 => array(0x78),
 1476                     0x1D584 => array(0x79), 0x1D585 => array(0x7A), 0x1D5A0 => array(0x61),
 1477                     0x1D5A1 => array(0x62), 0x1D5A2 => array(0x63), 0x1D5A3 => array(0x64),
 1478                     0x1D5A4 => array(0x65), 0x1D5A5 => array(0x66), 0x1D5A6 => array(0x67),
 1479                     0x1D5A7 => array(0x68), 0x1D5A8 => array(0x69), 0x1D5A9 => array(0x6A),
 1480                     0x1D5AA => array(0x6B), 0x1D5AB => array(0x6C), 0x1D5AC => array(0x6D),
 1481                     0x1D5AD => array(0x6E), 0x1D5AE => array(0x6F), 0x1D5AF => array(0x70),
 1482                     0x1D5B0 => array(0x71), 0x1D5B1 => array(0x72), 0x1D5B2 => array(0x73),
 1483                     0x1D5B3 => array(0x74), 0x1D5B4 => array(0x75), 0x1D5B5 => array(0x76),
 1484                     0x1D5B6 => array(0x77), 0x1D5B7 => array(0x78), 0x1D5B8 => array(0x79),
 1485                     0x1D5B9 => array(0x7A), 0x1D5D4 => array(0x61), 0x1D5D5 => array(0x62),
 1486                     0x1D5D6 => array(0x63), 0x1D5D7 => array(0x64), 0x1D5D8 => array(0x65),
 1487                     0x1D5D9 => array(0x66), 0x1D5DA => array(0x67), 0x1D5DB => array(0x68),
 1488                     0x1D5DC => array(0x69), 0x1D5DD => array(0x6A), 0x1D5DE => array(0x6B),
 1489                     0x1D5DF => array(0x6C), 0x1D5E0 => array(0x6D), 0x1D5E1 => array(0x6E),
 1490                     0x1D5E2 => array(0x6F), 0x1D5E3 => array(0x70), 0x1D5E4 => array(0x71),
 1491                     0x1D5E5 => array(0x72), 0x1D5E6 => array(0x73), 0x1D5E7 => array(0x74),
 1492                     0x1D5E8 => array(0x75), 0x1D5E9 => array(0x76), 0x1D5EA => array(0x77),
 1493                     0x1D5EB => array(0x78), 0x1D5EC => array(0x79), 0x1D5ED => array(0x7A),
 1494                     0x1D608 => array(0x61), 0x1D609 => array(0x62), 0x1D60A => array(0x63),
 1495                     0x1D60B => array(0x64), 0x1D60C => array(0x65), 0x1D60D => array(0x66),
 1496                     0x1D60E => array(0x67), 0x1D60F => array(0x68), 0x1D610 => array(0x69),
 1497                     0x1D611 => array(0x6A), 0x1D612 => array(0x6B), 0x1D613 => array(0x6C),
 1498                     0x1D614 => array(0x6D), 0x1D615 => array(0x6E), 0x1D616 => array(0x6F),
 1499                     0x1D617 => array(0x70), 0x1D618 => array(0x71), 0x1D619 => array(0x72),
 1500                     0x1D61A => array(0x73), 0x1D61B => array(0x74), 0x1D61C => array(0x75),
 1501                     0x1D61D => array(0x76), 0x1D61E => array(0x77), 0x1D61F => array(0x78),
 1502                     0x1D620 => array(0x79), 0x1D621 => array(0x7A), 0x1D63C => array(0x61),
 1503                     0x1D63D => array(0x62), 0x1D63E => array(0x63), 0x1D63F => array(0x64),
 1504                     0x1D640 => array(0x65), 0x1D641 => array(0x66), 0x1D642 => array(0x67),
 1505                     0x1D643 => array(0x68), 0x1D644 => array(0x69), 0x1D645 => array(0x6A),
 1506                     0x1D646 => array(0x6B), 0x1D647 => array(0x6C), 0x1D648 => array(0x6D),
 1507                     0x1D649 => array(0x6E), 0x1D64A => array(0x6F), 0x1D64B => array(0x70),
 1508                     0x1D64C => array(0x71), 0x1D64D => array(0x72), 0x1D64E => array(0x73),
 1509                     0x1D64F => array(0x74), 0x1D650 => array(0x75), 0x1D651 => array(0x76),
 1510                     0x1D652 => array(0x77), 0x1D653 => array(0x78), 0x1D654 => array(0x79),
 1511                     0x1D655 => array(0x7A), 0x1D670 => array(0x61), 0x1D671 => array(0x62),
 1512                     0x1D672 => array(0x63), 0x1D673 => array(0x64), 0x1D674 => array(0x65),
 1513                     0x1D675 => array(0x66), 0x1D676 => array(0x67), 0x1D677 => array(0x68),
 1514                     0x1D678 => array(0x69), 0x1D679 => array(0x6A), 0x1D67A => array(0x6B),
 1515                     0x1D67B => array(0x6C), 0x1D67C => array(0x6D), 0x1D67D => array(0x6E),
 1516                     0x1D67E => array(0x6F), 0x1D67F => array(0x70), 0x1D680 => array(0x71),
 1517                     0x1D681 => array(0x72), 0x1D682 => array(0x73), 0x1D683 => array(0x74),
 1518                     0x1D684 => array(0x75), 0x1D685 => array(0x76), 0x1D686 => array(0x77),
 1519                     0x1D687 => array(0x78), 0x1D688 => array(0x79), 0x1D689 => array(0x7A),
 1520                     0x1D6A8 => array(0x3B1), 0x1D6A9 => array(0x3B2), 0x1D6AA => array(0x3B3),
 1521                     0x1D6AB => array(0x3B4), 0x1D6AC => array(0x3B5), 0x1D6AD => array(0x3B6),
 1522                     0x1D6AE => array(0x3B7), 0x1D6AF => array(0x3B8), 0x1D6B0 => array(0x3B9),
 1523                     0x1D6B1 => array(0x3BA), 0x1D6B2 => array(0x3BB), 0x1D6B3 => array(0x3BC),
 1524                     0x1D6B4 => array(0x3BD), 0x1D6B5 => array(0x3BE), 0x1D6B6 => array(0x3BF),
 1525                     0x1D6B7 => array(0x3C0), 0x1D6B8 => array(0x3C1), 0x1D6B9 => array(0x3B8),
 1526                     0x1D6BA => array(0x3C3), 0x1D6BB => array(0x3C4), 0x1D6BC => array(0x3C5),
 1527                     0x1D6BD => array(0x3C6), 0x1D6BE => array(0x3C7), 0x1D6BF => array(0x3C8),
 1528                     0x1D6C0 => array(0x3C9), 0x1D6D3 => array(0x3C3), 0x1D6E2 => array(0x3B1),
 1529                     0x1D6E3 => array(0x3B2), 0x1D6E4 => array(0x3B3), 0x1D6E5 => array(0x3B4),
 1530                     0x1D6E6 => array(0x3B5), 0x1D6E7 => array(0x3B6), 0x1D6E8 => array(0x3B7),
 1531                     0x1D6E9 => array(0x3B8), 0x1D6EA => array(0x3B9), 0x1D6EB => array(0x3BA),
 1532                     0x1D6EC => array(0x3BB), 0x1D6ED => array(0x3BC), 0x1D6EE => array(0x3BD),
 1533                     0x1D6EF => array(0x3BE), 0x1D6F0 => array(0x3BF), 0x1D6F1 => array(0x3C0),
 1534                     0x1D6F2 => array(0x3C1), 0x1D6F3 => array(0x3B8), 0x1D6F4 => array(0x3C3),
 1535                     0x1D6F5 => array(0x3C4), 0x1D6F6 => array(0x3C5), 0x1D6F7 => array(0x3C6),
 1536                     0x1D6F8 => array(0x3C7), 0x1D6F9 => array(0x3C8), 0x1D6FA => array(0x3C9),
 1537                     0x1D70D => array(0x3C3), 0x1D71C => array(0x3B1), 0x1D71D => array(0x3B2),
 1538                     0x1D71E => array(0x3B3), 0x1D71F => array(0x3B4), 0x1D720 => array(0x3B5),
 1539                     0x1D721 => array(0x3B6), 0x1D722 => array(0x3B7), 0x1D723 => array(0x3B8),
 1540                     0x1D724 => array(0x3B9), 0x1D725 => array(0x3BA), 0x1D726 => array(0x3BB),
 1541                     0x1D727 => array(0x3BC), 0x1D728 => array(0x3BD), 0x1D729 => array(0x3BE),
 1542                     0x1D72A => array(0x3BF), 0x1D72B => array(0x3C0), 0x1D72C => array(0x3C1),
 1543                     0x1D72D => array(0x3B8), 0x1D72E => array(0x3C3), 0x1D72F => array(0x3C4),
 1544                     0x1D730 => array(0x3C5), 0x1D731 => array(0x3C6), 0x1D732 => array(0x3C7),
 1545                     0x1D733 => array(0x3C8), 0x1D734 => array(0x3C9), 0x1D747 => array(0x3C3),
 1546                     0x1D756 => array(0x3B1), 0x1D757 => array(0x3B2), 0x1D758 => array(0x3B3),
 1547                     0x1D759 => array(0x3B4), 0x1D75A => array(0x3B5), 0x1D75B => array(0x3B6),
 1548                     0x1D75C => array(0x3B7), 0x1D75D => array(0x3B8), 0x1D75E => array(0x3B9),
 1549                     0x1D75F => array(0x3BA), 0x1D760 => array(0x3BB), 0x1D761 => array(0x3BC),
 1550                     0x1D762 => array(0x3BD), 0x1D763 => array(0x3BE), 0x1D764 => array(0x3BF),
 1551                     0x1D765 => array(0x3C0), 0x1D766 => array(0x3C1), 0x1D767 => array(0x3B8),
 1552                     0x1D768 => array(0x3C3), 0x1D769 => array(0x3C4), 0x1D76A => array(0x3C5),
 1553                     0x1D76B => array(0x3C6), 0x1D76C => array(0x3C7), 0x1D76D => array(0x3C8),
 1554                     0x1D76E => array(0x3C9), 0x1D781 => array(0x3C3), 0x1D790 => array(0x3B1),
 1555                     0x1D791 => array(0x3B2), 0x1D792 => array(0x3B3), 0x1D793 => array(0x3B4),
 1556                     0x1D794 => array(0x3B5), 0x1D795 => array(0x3B6), 0x1D796 => array(0x3B7),
 1557                     0x1D797 => array(0x3B8), 0x1D798 => array(0x3B9), 0x1D799 => array(0x3BA),
 1558                     0x1D79A => array(0x3BB), 0x1D79B => array(0x3BC), 0x1D79C => array(0x3BD),
 1559                     0x1D79D => array(0x3BE), 0x1D79E => array(0x3BF), 0x1D79F => array(0x3C0),
 1560                     0x1D7A0 => array(0x3C1), 0x1D7A1 => array(0x3B8), 0x1D7A2 => array(0x3C3),
 1561                     0x1D7A3 => array(0x3C4), 0x1D7A4 => array(0x3C5), 0x1D7A5 => array(0x3C6),
 1562                     0x1D7A6 => array(0x3C7), 0x1D7A7 => array(0x3C8), 0x1D7A8 => array(0x3C9),
 1563                     0x1D7BB => array(0x3C3), 0x3F9 => array(0x3C3), 0x1D2C => array(0x61),
 1564                     0x1D2D => array(0xE6), 0x1D2E => array(0x62), 0x1D30 => array(0x64),
 1565                     0x1D31 => array(0x65), 0x1D32 => array(0x1DD), 0x1D33 => array(0x67),
 1566                     0x1D34 => array(0x68), 0x1D35 => array(0x69), 0x1D36 => array(0x6A),
 1567                     0x1D37 => array(0x6B), 0x1D38 => array(0x6C), 0x1D39 => array(0x6D),
 1568                     0x1D3A => array(0x6E), 0x1D3C => array(0x6F), 0x1D3D => array(0x223),
 1569                     0x1D3E => array(0x70), 0x1D3F => array(0x72), 0x1D40 => array(0x74),
 1570                     0x1D41 => array(0x75), 0x1D42 => array(0x77), 0x213B => array(0x66, 0x61, 0x78),
 1571                     0x3250 => array(0x70, 0x74, 0x65), 0x32CC => array(0x68, 0x67),
 1572                     0x32CE => array(0x65, 0x76), 0x32CF => array(0x6C, 0x74, 0x64),
 1573                     0x337A => array(0x69, 0x75), 0x33DE => array(0x76, 0x2215, 0x6D),
 1574                     0x33DF => array(0x61, 0x2215, 0x6D)
 1575             ),
 1576             'replacemaps' => array(0x41 => array(0x61), 0x42 => array(0x62), 0x43 => array(0x63),
 1577                     0x44 => array(0x64), 0x45 => array(0x65), 0x46 => array(0x66),
 1578                     0x47 => array(0x67), 0x48 => array(0x68), 0x49 => array(0x69),
 1579                     0x4A => array(0x6A), 0x4B => array(0x6B), 0x4C => array(0x6C),
 1580                     0x4D => array(0x6D), 0x4E => array(0x6E), 0x4F => array(0x6F),
 1581                     0x50 => array(0x70), 0x51 => array(0x71), 0x52 => array(0x72),
 1582                     0x53 => array(0x73), 0x54 => array(0x74), 0x55 => array(0x75),
 1583                     0x56 => array(0x76), 0x57 => array(0x77), 0x58 => array(0x78),
 1584                     0x59 => array(0x79), 0x5A => array(0x7A), 0xAA => array(0x61),
 1585                     0xB2 => array(0x32), 0xB3 => array(0x33), 0xB5 => array(0x3BC),
 1586                     0xB9 => array(0x31), 0xBA => array(0x6F), 0xBC => array(0x31, 0x2044, 0x34),
 1587                     0xBD => array(0x31, 0x2044, 0x32), 0xBE => array(0x33, 0x2044, 0x34), 0xC0 => array(0xE0),
 1588                     0xC1 => array(0xE1), 0xC2 => array(0xE2), 0xC3 => array(0xE3),
 1589                     0xC4 => array(0xE4), 0xC5 => array(0xE5), 0xC6 => array(0xE6),
 1590                     0xC7 => array(0xE7), 0xC8 => array(0xE8), 0xC9 => array(0xE9),
 1591                     0xCA => array(0xEA), 0xCB => array(0xEB), 0xCC => array(0xEC),
 1592                     0xCD => array(0xED), 0xCE => array(0xEE), 0xCF => array(0xEF),
 1593                     0xD0 => array(0xF0), 0xD1 => array(0xF1), 0xD2 => array(0xF2),
 1594                     0xD3 => array(0xF3), 0xD4 => array(0xF4), 0xD5 => array(0xF5),
 1595                     0xD6 => array(0xF6), 0xD8 => array(0xF8), 0xD9 => array(0xF9),
 1596                     0xDA => array(0xFA), 0xDB => array(0xFB), 0xDC => array(0xFC),
 1597                     0xDD => array(0xFD), 0xDE => array(0xFE), 0x100 => array(0x101),
 1598                     0x102 => array(0x103), 0x104 => array(0x105), 0x106 => array(0x107),
 1599                     0x108 => array(0x109), 0x10A => array(0x10B), 0x10C => array(0x10D),
 1600                     0x10E => array(0x10F), 0x110 => array(0x111), 0x112 => array(0x113),
 1601                     0x114 => array(0x115), 0x116 => array(0x117), 0x118 => array(0x119),
 1602                     0x11A => array(0x11B), 0x11C => array(0x11D), 0x11E => array(0x11F),
 1603                     0x120 => array(0x121), 0x122 => array(0x123), 0x124 => array(0x125),
 1604                     0x126 => array(0x127), 0x128 => array(0x129), 0x12A => array(0x12B),
 1605                     0x12C => array(0x12D), 0x12E => array(0x12F), 0x130 => array(0x69, 0x307),
 1606                     0x132 => array(0x69, 0x6A), 0x133 => array(0x69, 0x6A), 0x134 => array(0x135),
 1607                     0x136 => array(0x137), 0x139 => array(0x13A), 0x13B => array(0x13C),
 1608                     0x13D => array(0x13E), 0x13F => array(0x6C, 0xB7), 0x140 => array(0x6C, 0xB7),
 1609                     0x141 => array(0x142), 0x143 => array(0x144), 0x145 => array(0x146),
 1610                     0x147 => array(0x148), 0x149 => array(0x2BC, 0x6E), 0x14A => array(0x14B),
 1611                     0x14C => array(0x14D), 0x14E => array(0x14F), 0x150 => array(0x151),
 1612                     0x152 => array(0x153), 0x154 => array(0x155), 0x156 => array(0x157),
 1613                     0x158 => array(0x159), 0x15A => array(0x15B), 0x15C => array(0x15D),
 1614                     0x15E => array(0x15F), 0x160 => array(0x161), 0x162 => array(0x163),
 1615                     0x164 => array(0x165), 0x166 => array(0x167), 0x168 => array(0x169),
 1616                     0x16A => array(0x16B), 0x16C => array(0x16D), 0x16E => array(0x16F),
 1617                     0x170 => array(0x171), 0x172 => array(0x173), 0x174 => array(0x175),
 1618                     0x176 => array(0x177), 0x178 => array(0xFF), 0x179 => array(0x17A),
 1619                     0x17B => array(0x17C), 0x17D => array(0x17E), 0x17F => array(0x73),
 1620                     0x181 => array(0x253), 0x182 => array(0x183), 0x184 => array(0x185),
 1621                     0x186 => array(0x254), 0x187 => array(0x188), 0x189 => array(0x256),
 1622                     0x18A => array(0x257), 0x18B => array(0x18C), 0x18E => array(0x1DD),
 1623                     0x18F => array(0x259), 0x190 => array(0x25B), 0x191 => array(0x192),
 1624                     0x193 => array(0x260), 0x194 => array(0x263), 0x196 => array(0x269),
 1625                     0x197 => array(0x268), 0x198 => array(0x199), 0x19C => array(0x26F),
 1626                     0x19D => array(0x272), 0x19F => array(0x275), 0x1A0 => array(0x1A1),
 1627                     0x1A2 => array(0x1A3), 0x1A4 => array(0x1A5), 0x1A6 => array(0x280),
 1628                     0x1A7 => array(0x1A8), 0x1A9 => array(0x283), 0x1AC => array(0x1AD),
 1629                     0x1AE => array(0x288), 0x1AF => array(0x1B0), 0x1B1 => array(0x28A),
 1630                     0x1B2 => array(0x28B), 0x1B3 => array(0x1B4), 0x1B5 => array(0x1B6),
 1631                     0x1B7 => array(0x292), 0x1B8 => array(0x1B9), 0x1BC => array(0x1BD),
 1632                     0x1C4 => array(0x64, 0x17E), 0x1C5 => array(0x64, 0x17E), 0x1C6 => array(0x64, 0x17E),
 1633                     0x1C7 => array(0x6C, 0x6A), 0x1C8 => array(0x6C, 0x6A), 0x1C9 => array(0x6C, 0x6A),
 1634                     0x1CA => array(0x6E, 0x6A), 0x1CB => array(0x6E, 0x6A), 0x1CC => array(0x6E, 0x6A),
 1635                     0x1CD => array(0x1CE), 0x1CF => array(0x1D0), 0x1D1 => array(0x1D2),
 1636                     0x1D3 => array(0x1D4), 0x1D5 => array(0x1D6), 0x1D7 => array(0x1D8),
 1637                     0x1D9 => array(0x1DA), 0x1DB => array(0x1DC), 0x1DE => array(0x1DF),
 1638                     0x1E0 => array(0x1E1), 0x1E2 => array(0x1E3), 0x1E4 => array(0x1E5),
 1639                     0x1E6 => array(0x1E7), 0x1E8 => array(0x1E9), 0x1EA => array(0x1EB),
 1640                     0x1EC => array(0x1ED), 0x1EE => array(0x1EF), 0x1F1 => array(0x64, 0x7A),
 1641                     0x1F2 => array(0x64, 0x7A), 0x1F3 => array(0x64, 0x7A), 0x1F4 => array(0x1F5),
 1642                     0x1F6 => array(0x195), 0x1F7 => array(0x1BF), 0x1F8 => array(0x1F9),
 1643                     0x1FA => array(0x1FB), 0x1FC => array(0x1FD), 0x1FE => array(0x1FF),
 1644                     0x200 => array(0x201), 0x202 => array(0x203), 0x204 => array(0x205),
 1645                     0x206 => array(0x207), 0x208 => array(0x209), 0x20A => array(0x20B),
 1646                     0x20C => array(0x20D), 0x20E => array(0x20F), 0x210 => array(0x211),
 1647                     0x212 => array(0x213), 0x214 => array(0x215), 0x216 => array(0x217),
 1648                     0x218 => array(0x219), 0x21A => array(0x21B), 0x21C => array(0x21D),
 1649                     0x21E => array(0x21F), 0x220 => array(0x19E), 0x222 => array(0x223),
 1650                     0x224 => array(0x225), 0x226 => array(0x227), 0x228 => array(0x229),
 1651                     0x22A => array(0x22B), 0x22C => array(0x22D), 0x22E => array(0x22F),
 1652                     0x230 => array(0x231), 0x232 => array(0x233), 0x23A => array(0x2C65),
 1653                     0x23B => array(0x23C), 0x23D => array(0x19A), 0x23E => array(0x2C66),
 1654                     0x241 => array(0x242), 0x243 => array(0x180), 0x244 => array(0x289),
 1655                     0x245 => array(0x28C), 0x246 => array(0x247), 0x248 => array(0x249),
 1656                     0x24A => array(0x24B), 0x24C => array(0x24D), 0x24E => array(0x24F),
 1657                     0x2B0 => array(0x68), 0x2B1 => array(0x266), 0x2B2 => array(0x6A),
 1658                     0x2B3 => array(0x72), 0x2B4 => array(0x279), 0x2B5 => array(0x27B),
 1659                     0x2B6 => array(0x281), 0x2B7 => array(0x77), 0x2B8 => array(0x79),
 1660                     0x2E0 => array(0x263), 0x2E1 => array(0x6C), 0x2E2 => array(0x73),
 1661                     0x2E3 => array(0x78), 0x2E4 => array(0x295), 0x340 => array(0x300),
 1662                     0x341 => array(0x301), 0x343 => array(0x313), 0x344 => array(0x308, 0x301),
 1663                     0x345 => array(0x3B9), 0x370 => array(0x371), 0x372 => array(0x373),
 1664                     0x374 => array(0x2B9), 0x376 => array(0x377), 0x37F => array(0x3F3),
 1665                     0x386 => array(0x3AC), 0x387 => array(0xB7), 0x388 => array(0x3AD),
 1666                     0x389 => array(0x3AE), 0x38A => array(0x3AF), 0x38C => array(0x3CC),
 1667                     0x38E => array(0x3CD), 0x38F => array(0x3CE), 0x391 => array(0x3B1),
 1668                     0x392 => array(0x3B2), 0x393 => array(0x3B3), 0x394 => array(0x3B4),
 1669                     0x395 => array(0x3B5), 0x396 => array(0x3B6), 0x397 => array(0x3B7),
 1670                     0x398 => array(0x3B8), 0x399 => array(0x3B9), 0x39A => array(0x3BA),
 1671                     0x39B => array(0x3BB), 0x39C => array(0x3BC), 0x39D => array(0x3BD),
 1672                     0x39E => array(0x3BE), 0x39F => array(0x3BF), 0x3A0 => array(0x3C0),
 1673                     0x3A1 => array(0x3C1), 0x3A3 => array(0x3C3), 0x3A4 => array(0x3C4),
 1674                     0x3A5 => array(0x3C5), 0x3A6 => array(0x3C6), 0x3A7 => array(0x3C7),
 1675                     0x3A8 => array(0x3C8), 0x3A9 => array(0x3C9), 0x3AA => array(0x3CA),
 1676                     0x3AB => array(0x3CB), 0x3CF => array(0x3D7), 0x3D0 => array(0x3B2),
 1677                     0x3D1 => array(0x3B8), 0x3D2 => array(0x3C5), 0x3D3 => array(0x3CD),
 1678                     0x3D4 => array(0x3CB), 0x3D5 => array(0x3C6), 0x3D6 => array(0x3C0),
 1679                     0x3D8 => array(0x3D9), 0x3DA => array(0x3DB), 0x3DC => array(0x3DD),
 1680                     0x3DE => array(0x3DF), 0x3E0 => array(0x3E1), 0x3E2 => array(0x3E3),
 1681                     0x3E4 => array(0x3E5), 0x3E6 => array(0x3E7), 0x3E8 => array(0x3E9),
 1682                     0x3EA => array(0x3EB), 0x3EC => array(0x3ED), 0x3EE => array(0x3EF),
 1683                     0x3F0 => array(0x3BA), 0x3F1 => array(0x3C1), 0x3F2 => array(0x3C3),
 1684                     0x3F4 => array(0x3B8), 0x3F5 => array(0x3B5), 0x3F7 => array(0x3F8),
 1685                     0x3F9 => array(0x3C3), 0x3FA => array(0x3FB), 0x3FD => array(0x37B),
 1686                     0x3FE => array(0x37C), 0x3FF => array(0x37D), 0x400 => array(0x450),
 1687                     0x401 => array(0x451), 0x402 => array(0x452), 0x403 => array(0x453),
 1688                     0x404 => array(0x454), 0x405 => array(0x455), 0x406 => array(0x456),
 1689                     0x407 => array(0x457), 0x408 => array(0x458), 0x409 => array(0x459),
 1690                     0x40A => array(0x45A), 0x40B => array(0x45B), 0x40C => array(0x45C),
 1691                     0x40D => array(0x45D), 0x40E => array(0x45E), 0x40F => array(0x45F),
 1692                     0x410 => array(0x430), 0x411 => array(0x431), 0x412 => array(0x432),
 1693                     0x413 => array(0x433), 0x414 => array(0x434), 0x415 => array(0x435),
 1694                     0x416 => array(0x436), 0x417 => array(0x437), 0x418 => array(0x438),
 1695                     0x419 => array(0x439), 0x41A => array(0x43A), 0x41B => array(0x43B),
 1696                     0x41C => array(0x43C), 0x41D => array(0x43D), 0x41E => array(0x43E),
 1697                     0x41F => array(0x43F), 0x420 => array(0x440), 0x421 => array(0x441),
 1698                     0x422 => array(0x442), 0x423 => array(0x443), 0x424 => array(0x444),
 1699                     0x425 => array(0x445), 0x426 => array(0x446), 0x427 => array(0x447),
 1700                     0x428 => array(0x448), 0x429 => array(0x449), 0x42A => array(0x44A),
 1701                     0x42B => array(0x44B), 0x42C => array(0x44C), 0x42D => array(0x44D),
 1702                     0x42E => array(0x44E), 0x42F => array(0x44F), 0x460 => array(0x461),
 1703                     0x462 => array(0x463), 0x464 => array(0x465), 0x466 => array(0x467),
 1704                     0x468 => array(0x469), 0x46A => array(0x46B), 0x46C => array(0x46D),
 1705                     0x46E => array(0x46F), 0x470 => array(0x471), 0x472 => array(0x473),
 1706                     0x474 => array(0x475), 0x476 => array(0x477), 0x478 => array(0x479),
 1707                     0x47A => array(0x47B), 0x47C => array(0x47D), 0x47E => array(0x47F),
 1708                     0x480 => array(0x481), 0x48A => array(0x48B), 0x48C => array(0x48D),
 1709                     0x48E => array(0x48F), 0x490 => array(0x491), 0x492 => array(0x493),
 1710                     0x494 => array(0x495), 0x496 => array(0x497), 0x498 => array(0x499),
 1711                     0x49A => array(0x49B), 0x49C => array(0x49D), 0x49E => array(0x49F),
 1712                     0x4A0 => array(0x4A1), 0x4A2 => array(0x4A3), 0x4A4 => array(0x4A5),
 1713                     0x4A6 => array(0x4A7), 0x4A8 => array(0x4A9), 0x4AA => array(0x4AB),
 1714                     0x4AC => array(0x4AD), 0x4AE => array(0x4AF), 0x4B0 => array(0x4B1),
 1715                     0x4B2 => array(0x4B3), 0x4B4 => array(0x4B5), 0x4B6 => array(0x4B7),
 1716                     0x4B8 => array(0x4B9), 0x4BA => array(0x4BB), 0x4BC => array(0x4BD),
 1717                     0x4BE => array(0x4BF), 0x4C1 => array(0x4C2), 0x4C3 => array(0x4C4),
 1718                     0x4C5 => array(0x4C6), 0x4C7 => array(0x4C8), 0x4C9 => array(0x4CA),
 1719                     0x4CB => array(0x4CC), 0x4CD => array(0x4CE), 0x4D0 => array(0x4D1),
 1720                     0x4D2 => array(0x4D3), 0x4D4 => array(0x4D5), 0x4D6 => array(0x4D7),
 1721                     0x4D8 => array(0x4D9), 0x4DA => array(0x4DB), 0x4DC => array(0x4DD),
 1722                     0x4DE => array(0x4DF), 0x4E0 => array(0x4E1), 0x4E2 => array(0x4E3),
 1723                     0x4E4 => array(0x4E5), 0x4E6 => array(0x4E7), 0x4E8 => array(0x4E9),
 1724                     0x4EA => array(0x4EB), 0x4EC => array(0x4ED), 0x4EE => array(0x4EF),
 1725                     0x4F0 => array(0x4F1), 0x4F2 => array(0x4F3), 0x4F4 => array(0x4F5),
 1726                     0x4F6 => array(0x4F7), 0x4F8 => array(0x4F9), 0x4FA => array(0x4FB),
 1727                     0x4FC => array(0x4FD), 0x4FE => array(0x4FF), 0x500 => array(0x501),
 1728                     0x502 => array(0x503), 0x504 => array(0x505), 0x506 => array(0x507),
 1729                     0x508 => array(0x509), 0x50A => array(0x50B), 0x50C => array(0x50D),
 1730                     0x50E => array(0x50F), 0x510 => array(0x511), 0x512 => array(0x513),
 1731                     0x514 => array(0x515), 0x516 => array(0x517), 0x518 => array(0x519),
 1732                     0x51A => array(0x51B), 0x51C => array(0x51D), 0x51E => array(0x51F),
 1733                     0x520 => array(0x521), 0x522 => array(0x523), 0x524 => array(0x525),
 1734                     0x526 => array(0x527), 0x528 => array(0x529), 0x52A => array(0x52B),
 1735                     0x52C => array(0x52D), 0x52E => array(0x52F), 0x531 => array(0x561),
 1736                     0x532 => array(0x562), 0x533 => array(0x563), 0x534 => array(0x564),
 1737                     0x535 => array(0x565), 0x536 => array(0x566), 0x537 => array(0x567),
 1738                     0x538 => array(0x568), 0x539 => array(0x569), 0x53A => array(0x56A),
 1739                     0x53B => array(0x56B), 0x53C => array(0x56C), 0x53D => array(0x56D),
 1740                     0x53E => array(0x56E), 0x53F => array(0x56F), 0x540 => array(0x570),
 1741                     0x541 => array(0x571), 0x542 => array(0x572), 0x543 => array(0x573),
 1742                     0x544 => array(0x574), 0x545 => array(0x575), 0x546 => array(0x576),
 1743                     0x547 => array(0x577), 0x548 => array(0x578), 0x549 => array(0x579),
 1744                     0x54A => array(0x57A), 0x54B => array(0x57B), 0x54C => array(0x57C),
 1745                     0x54D => array(0x57D), 0x54E => array(0x57E), 0x54F => array(0x57F),
 1746                     0x550 => array(0x580), 0x551 => array(0x581), 0x552 => array(0x582),
 1747                     0x553 => array(0x583), 0x554 => array(0x584), 0x555 => array(0x585),
 1748                     0x556 => array(0x586), 0x587 => array(0x565, 0x582), 0x675 => array(0x627, 0x674),
 1749                     0x676 => array(0x648, 0x674), 0x677 => array(0x6C7, 0x674), 0x678 => array(0x64A, 0x674),
 1750                     0x958 => array(0x915, 0x93C), 0x959 => array(0x916, 0x93C), 0x95A => array(0x917, 0x93C),
 1751                     0x95B => array(0x91C, 0x93C), 0x95C => array(0x921, 0x93C), 0x95D => array(0x922, 0x93C),
 1752                     0x95E => array(0x92B, 0x93C), 0x95F => array(0x92F, 0x93C), 0x9DC => array(0x9A1, 0x9BC),
 1753                     0x9DD => array(0x9A2, 0x9BC), 0x9DF => array(0x9AF, 0x9BC), 0xA33 => array(0xA32, 0xA3C),
 1754                     0xA36 => array(0xA38, 0xA3C), 0xA59 => array(0xA16, 0xA3C), 0xA5A => array(0xA17, 0xA3C),
 1755                     0xA5B => array(0xA1C, 0xA3C), 0xA5E => array(0xA2B, 0xA3C), 0xB5C => array(0xB21, 0xB3C),
 1756                     0xB5D => array(0xB22, 0xB3C), 0xE33 => array(0xE4D, 0xE32), 0xEB3 => array(0xECD, 0xEB2),
 1757                     0xEDC => array(0xEAB, 0xE99), 0xEDD => array(0xEAB, 0xEA1), 0xF0C => array(0xF0B),
 1758                     0xF43 => array(0xF42, 0xFB7), 0xF4D => array(0xF4C, 0xFB7), 0xF52 => array(0xF51, 0xFB7),
 1759                     0xF57 => array(0xF56, 0xFB7), 0xF5C => array(0xF5B, 0xFB7), 0xF69 => array(0xF40, 0xFB5),
 1760                     0xF73 => array(0xF71, 0xF72), 0xF75 => array(0xF71, 0xF74), 0xF76 => array(0xFB2, 0xF80),
 1761                     0xF77 => array(0xFB2, 0xF71, 0xF80), 0xF78 => array(0xFB3, 0xF80), 0xF79 => array(0xFB3, 0xF71, 0xF80),
 1762                     0xF81 => array(0xF71, 0xF80), 0xF93 => array(0xF92, 0xFB7), 0xF9D => array(0xF9C, 0xFB7),
 1763                     0xFA2 => array(0xFA1, 0xFB7), 0xFA7 => array(0xFA6, 0xFB7), 0xFAC => array(0xFAB, 0xFB7),
 1764                     0xFB9 => array(0xF90, 0xFB5), 0x10C7 => array(0x2D27), 0x10CD => array(0x2D2D),
 1765                     0x10FC => array(0x10DC), 0x1D2C => array(0x61), 0x1D2D => array(0xE6),
 1766                     0x1D2E => array(0x62), 0x1D30 => array(0x64), 0x1D31 => array(0x65),
 1767                     0x1D32 => array(0x1DD), 0x1D33 => array(0x67), 0x1D34 => array(0x68),
 1768                     0x1D35 => array(0x69), 0x1D36 => array(0x6A), 0x1D37 => array(0x6B),
 1769                     0x1D38 => array(0x6C), 0x1D39 => array(0x6D), 0x1D3A => array(0x6E),
 1770                     0x1D3C => array(0x6F), 0x1D3D => array(0x223), 0x1D3E => array(0x70),
 1771                     0x1D3F => array(0x72), 0x1D40 => array(0x74), 0x1D41 => array(0x75),
 1772                     0x1D42 => array(0x77), 0x1D43 => array(0x61), 0x1D44 => array(0x250),
 1773                     0x1D45 => array(0x251), 0x1D46 => array(0x1D02), 0x1D47 => array(0x62),
 1774                     0x1D48 => array(0x64), 0x1D49 => array(0x65), 0x1D4A => array(0x259),
 1775                     0x1D4B => array(0x25B), 0x1D4C => array(0x25C), 0x1D4D => array(0x67),
 1776                     0x1D4F => array(0x6B), 0x1D50 => array(0x6D), 0x1D51 => array(0x14B),
 1777                     0x1D52 => array(0x6F), 0x1D53 => array(0x254), 0x1D54 => array(0x1D16),
 1778                     0x1D55 => array(0x1D17), 0x1D56 => array(0x70), 0x1D57 => array(0x74),
 1779                     0x1D58 => array(0x75), 0x1D59 => array(0x1D1D), 0x1D5A => array(0x26F),
 1780                     0x1D5B => array(0x76), 0x1D5C => array(0x1D25), 0x1D5D => array(0x3B2),
 1781                     0x1D5E => array(0x3B3), 0x1D5F => array(0x3B4), 0x1D60 => array(0x3C6),
 1782                     0x1D61 => array(0x3C7), 0x1D62 => array(0x69), 0x1D63 => array(0x72),
 1783                     0x1D64 => array(0x75), 0x1D65 => array(0x76), 0x1D66 => array(0x3B2),
 1784                     0x1D67 => array(0x3B3), 0x1D68 => array(0x3C1), 0x1D69 => array(0x3C6),
 1785                     0x1D6A => array(0x3C7), 0x1D78 => array(0x43D), 0x1D9B => array(0x252),
 1786                     0x1D9C => array(0x63), 0x1D9D => array(0x255), 0x1D9E => array(0xF0),
 1787                     0x1D9F => array(0x25C), 0x1DA0 => array(0x66), 0x1DA1 => array(0x25F),
 1788                     0x1DA2 => array(0x261), 0x1DA3 => array(0x265), 0x1DA4 => array(0x268),
 1789                     0x1DA5 => array(0x269), 0x1DA6 => array(0x26A), 0x1DA7 => array(0x1D7B),
 1790                     0x1DA8 => array(0x29D), 0x1DA9 => array(0x26D), 0x1DAA => array(0x1D85),
 1791                     0x1DAB => array(0x29F), 0x1DAC => array(0x271), 0x1DAD => array(0x270),
 1792                     0x1DAE => array(0x272), 0x1DAF => array(0x273), 0x1DB0 => array(0x274),
 1793                     0x1DB1 => array(0x275), 0x1DB2 => array(0x278), 0x1DB3 => array(0x282),
 1794                     0x1DB4 => array(0x283), 0x1DB5 => array(0x1AB), 0x1DB6 => array(0x289),
 1795                     0x1DB7 => array(0x28A), 0x1DB8 => array(0x1D1C), 0x1DB9 => array(0x28B),
 1796                     0x1DBA => array(0x28C), 0x1DBB => array(0x7A), 0x1DBC => array(0x290),
 1797                     0x1DBD => array(0x291), 0x1DBE => array(0x292), 0x1DBF => array(0x3B8),
 1798                     0x1E00 => array(0x1E01), 0x1E02 => array(0x1E03), 0x1E04 => array(0x1E05),
 1799                     0x1E06 => array(0x1E07), 0x1E08 => array(0x1E09), 0x1E0A => array(0x1E0B),
 1800                     0x1E0C => array(0x1E0D), 0x1E0E => array(0x1E0F), 0x1E10 => array(0x1E11),
 1801                     0x1E12 => array(0x1E13), 0x1E14 => array(0x1E15), 0x1E16 => array(0x1E17),
 1802                     0x1E18 => array(0x1E19), 0x1E1A => array(0x1E1B), 0x1E1C => array(0x1E1D),
 1803                     0x1E1E => array(0x1E1F), 0x1E20 => array(0x1E21), 0x1E22 => array(0x1E23),
 1804                     0x1E24 => array(0x1E25), 0x1E26 => array(0x1E27), 0x1E28 => array(0x1E29),
 1805                     0x1E2A => array(0x1E2B), 0x1E2C => array(0x1E2D), 0x1E2E => array(0x1E2F),
 1806                     0x1E30 => array(0x1E31), 0x1E32 => array(0x1E33), 0x1E34 => array(0x1E35),
 1807                     0x1E36 => array(0x1E37), 0x1E38 => array(0x1E39), 0x1E3A => array(0x1E3B),
 1808                     0x1E3C => array(0x1E3D), 0x1E3E => array(0x1E3F), 0x1E40 => array(0x1E41),
 1809                     0x1E42 => array(0x1E43), 0x1E44 => array(0x1E45), 0x1E46 => array(0x1E47),
 1810                     0x1E48 => array(0x1E49), 0x1E4A => array(0x1E4B), 0x1E4C => array(0x1E4D),
 1811                     0x1E4E => array(0x1E4F), 0x1E50 => array(0x1E51), 0x1E52 => array(0x1E53),
 1812                     0x1E54 => array(0x1E55), 0x1E56 => array(0x1E57), 0x1E58 => array(0x1E59),
 1813                     0x1E5A => array(0x1E5B), 0x1E5C => array(0x1E5D), 0x1E5E => array(0x1E5F),
 1814                     0x1E60 => array(0x1E61), 0x1E62 => array(0x1E63), 0x1E64 => array(0x1E65),
 1815                     0x1E66 => array(0x1E67), 0x1E68 => array(0x1E69), 0x1E6A => array(0x1E6B),
 1816                     0x1E6C => array(0x1E6D), 0x1E6E => array(0x1E6F), 0x1E70 => array(0x1E71),
 1817                     0x1E72 => array(0x1E73), 0x1E74 => array(0x1E75), 0x1E76 => array(0x1E77),
 1818                     0x1E78 => array(0x1E79), 0x1E7A => array(0x1E7B), 0x1E7C => array(0x1E7D),
 1819                     0x1E7E => array(0x1E7F), 0x1E80 => array(0x1E81), 0x1E82 => array(0x1E83),
 1820                     0x1E84 => array(0x1E85), 0x1E86 => array(0x1E87), 0x1E88 => array(0x1E89),
 1821                     0x1E8A => array(0x1E8B), 0x1E8C => array(0x1E8D), 0x1E8E => array(0x1E8F),
 1822                     0x1E90 => array(0x1E91), 0x1E92 => array(0x1E93), 0x1E94 => array(0x1E95),
 1823                     0x1E9A => array(0x61, 0x2BE), 0x1E9B => array(0x1E61), 0x1E9E => array(0x73, 0x73),
 1824                     0x1EA0 => array(0x1EA1), 0x1EA2 => array(0x1EA3), 0x1EA4 => array(0x1EA5),
 1825                     0x1EA6 => array(0x1EA7), 0x1EA8 => array(0x1EA9), 0x1EAA => array(0x1EAB),
 1826                     0x1EAC => array(0x1EAD), 0x1EAE => array(0x1EAF), 0x1EB0 => array(0x1EB1),
 1827                     0x1EB2 => array(0x1EB3), 0x1EB4 => array(0x1EB5), 0x1EB6 => array(0x1EB7),
 1828                     0x1EB8 => array(0x1EB9), 0x1EBA => array(0x1EBB), 0x1EBC => array(0x1EBD),
 1829                     0x1EBE => array(0x1EBF), 0x1EC0 => array(0x1EC1), 0x1EC2 => array(0x1EC3),
 1830                     0x1EC4 => array(0x1EC5), 0x1EC6 => array(0x1EC7), 0x1EC8 => array(0x1EC9),
 1831                     0x1ECA => array(0x1ECB), 0x1ECC => array(0x1ECD), 0x1ECE => array(0x1ECF),
 1832                     0x1ED0 => array(0x1ED1), 0x1ED2 => array(0x1ED3), 0x1ED4 => array(0x1ED5),
 1833                     0x1ED6 => array(0x1ED7), 0x1ED8 => array(0x1ED9), 0x1EDA => array(0x1EDB),
 1834                     0x1EDC => array(0x1EDD), 0x1EDE => array(0x1EDF), 0x1EE0 => array(0x1EE1),
 1835                     0x1EE2 => array(0x1EE3), 0x1EE4 => array(0x1EE5), 0x1EE6 => array(0x1EE7),
 1836                     0x1EE8 => array(0x1EE9), 0x1EEA => array(0x1EEB), 0x1EEC => array(0x1EED),
 1837                     0x1EEE => array(0x1EEF), 0x1EF0 => array(0x1EF1), 0x1EF2 => array(0x1EF3),
 1838                     0x1EF4 => array(0x1EF5), 0x1EF6 => array(0x1EF7), 0x1EF8 => array(0x1EF9),
 1839                     0x1EFA => array(0x1EFB), 0x1EFC => array(0x1EFD), 0x1EFE => array(0x1EFF),
 1840                     0x1F08 => array(0x1F00), 0x1F09 => array(0x1F01), 0x1F0A => array(0x1F02),
 1841                     0x1F0B => array(0x1F03), 0x1F0C => array(0x1F04), 0x1F0D => array(0x1F05),
 1842                     0x1F0E => array(0x1F06), 0x1F0F => array(0x1F07), 0x1F18 => array(0x1F10),
 1843                     0x1F19 => array(0x1F11), 0x1F1A => array(0x1F12), 0x1F1B => array(0x1F13),
 1844                     0x1F1C => array(0x1F14), 0x1F1D => array(0x1F15), 0x1F28 => array(0x1F20),
 1845                     0x1F29 => array(0x1F21), 0x1F2A => array(0x1F22), 0x1F2B => array(0x1F23),
 1846                     0x1F2C => array(0x1F24), 0x1F2D => array(0x1F25), 0x1F2E => array(0x1F26),
 1847                     0x1F2F => array(0x1F27), 0x1F38 => array(0x1F30), 0x1F39 => array(0x1F31),
 1848                     0x1F3A => array(0x1F32), 0x1F3B => array(0x1F33), 0x1F3C => array(0x1F34),
 1849                     0x1F3D => array(0x1F35), 0x1F3E => array(0x1F36), 0x1F3F => array(0x1F37),
 1850                     0x1F48 => array(0x1F40), 0x1F49 => array(0x1F41), 0x1F4A => array(0x1F42),
 1851                     0x1F4B => array(0x1F43), 0x1F4C => array(0x1F44), 0x1F4D => array(0x1F45),
 1852                     0x1F59 => array(0x1F51), 0x1F5B => array(0x1F53), 0x1F5D => array(0x1F55),
 1853                     0x1F5F => array(0x1F57), 0x1F68 => array(0x1F60), 0x1F69 => array(0x1F61),
 1854                     0x1F6A => array(0x1F62), 0x1F6B => array(0x1F63), 0x1F6C => array(0x1F64),
 1855                     0x1F6D => array(0x1F65), 0x1F6E => array(0x1F66), 0x1F6F => array(0x1F67),
 1856                     0x1F71 => array(0x3AC), 0x1F73 => array(0x3AD), 0x1F75 => array(0x3AE),
 1857                     0x1F77 => array(0x3AF), 0x1F79 => array(0x3CC), 0x1F7B => array(0x3CD),
 1858                     0x1F7D => array(0x3CE), 0x1F80 => array(0x1F00, 0x3B9), 0x1F81 => array(0x1F01, 0x3B9),
 1859                     0x1F82 => array(0x1F02, 0x3B9), 0x1F83 => array(0x1F03, 0x3B9), 0x1F84 => array(0x1F04, 0x3B9),
 1860                     0x1F85 => array(0x1F05, 0x3B9), 0x1F86 => array(0x1F06, 0x3B9), 0x1F87 => array(0x1F07, 0x3B9),
 1861                     0x1F88 => array(0x1F00, 0x3B9), 0x1F89 => array(0x1F01, 0x3B9), 0x1F8A => array(0x1F02, 0x3B9),
 1862                     0x1F8B => array(0x1F03, 0x3B9), 0x1F8C => array(0x1F04, 0x3B9), 0x1F8D => array(0x1F05, 0x3B9),
 1863                     0x1F8E => array(0x1F06, 0x3B9), 0x1F8F => array(0x1F07, 0x3B9), 0x1F90 => array(0x1F20, 0x3B9),
 1864                     0x1F91 => array(0x1F21, 0x3B9), 0x1F92 => array(0x1F22, 0x3B9), 0x1F93 => array(0x1F23, 0x3B9),
 1865                     0x1F94 => array(0x1F24, 0x3B9), 0x1F95 => array(0x1F25, 0x3B9), 0x1F96 => array(0x1F26, 0x3B9),
 1866                     0x1F97 => array(0x1F27, 0x3B9), 0x1F98 => array(0x1F20, 0x3B9), 0x1F99 => array(0x1F21, 0x3B9),
 1867                     0x1F9A => array(0x1F22, 0x3B9), 0x1F9B => array(0x1F23, 0x3B9), 0x1F9C => array(0x1F24, 0x3B9),
 1868                     0x1F9D => array(0x1F25, 0x3B9), 0x1F9E => array(0x1F26, 0x3B9), 0x1F9F => array(0x1F27, 0x3B9),
 1869                     0x1FA0 => array(0x1F60, 0x3B9), 0x1FA1 => array(0x1F61, 0x3B9), 0x1FA2 => array(0x1F62, 0x3B9),
 1870                     0x1FA3 => array(0x1F63, 0x3B9), 0x1FA4 => array(0x1F64, 0x3B9), 0x1FA5 => array(0x1F65, 0x3B9),
 1871                     0x1FA6 => array(0x1F66, 0x3B9), 0x1FA7 => array(0x1F67, 0x3B9), 0x1FA8 => array(0x1F60, 0x3B9),
 1872                     0x1FA9 => array(0x1F61, 0x3B9), 0x1FAA => array(0x1F62, 0x3B9), 0x1FAB => array(0x1F63, 0x3B9),
 1873                     0x1FAC => array(0x1F64, 0x3B9), 0x1FAD => array(0x1F65, 0x3B9), 0x1FAE => array(0x1F66, 0x3B9),
 1874                     0x1FAF => array(0x1F67, 0x3B9), 0x1FB2 => array(0x1F70, 0x3B9), 0x1FB3 => array(0x3B1, 0x3B9),
 1875                     0x1FB4 => array(0x3AC, 0x3B9), 0x1FB7 => array(0x1FB6, 0x3B9), 0x1FB8 => array(0x1FB0),
 1876                     0x1FB9 => array(0x1FB1), 0x1FBA => array(0x1F70), 0x1FBB => array(0x3AC),
 1877                     0x1FBC => array(0x3B1, 0x3B9), 0x1FBE => array(0x3B9), 0x1FC2 => array(0x1F74, 0x3B9),
 1878                     0x1FC3 => array(0x3B7, 0x3B9), 0x1FC4 => array(0x3AE, 0x3B9), 0x1FC7 => array(0x1FC6, 0x3B9),
 1879                     0x1FC8 => array(0x1F72), 0x1FC9 => array(0x3AD), 0x1FCA => array(0x1F74),
 1880                     0x1FCB => array(0x3AE), 0x1FCC => array(0x3B7, 0x3B9), 0x1FD3 => array(0x390),
 1881                     0x1FD8 => array(0x1FD0), 0x1FD9 => array(0x1FD1), 0x1FDA => array(0x1F76),
 1882                     0x1FDB => array(0x3AF), 0x1FE3 => array(0x3B0), 0x1FE8 => array(0x1FE0),
 1883                     0x1FE9 => array(0x1FE1), 0x1FEA => array(0x1F7A), 0x1FEB => array(0x3CD),
 1884                     0x1FEC => array(0x1FE5), 0x1FF2 => array(0x1F7C, 0x3B9), 0x1FF3 => array(0x3C9, 0x3B9),
 1885                     0x1FF4 => array(0x3CE, 0x3B9), 0x1FF7 => array(0x1FF6, 0x3B9), 0x1FF8 => array(0x1F78),
 1886                     0x1FF9 => array(0x3CC), 0x1FFA => array(0x1F7C), 0x1FFB => array(0x3CE),
 1887                     0x1FFC => array(0x3C9, 0x3B9), 0x2011 => array(0x2010), 0x2033 => array(0x2032, 0x2032),
 1888                     0x2034 => array(0x2032, 0x2032, 0x2032), 0x2036 => array(0x2035, 0x2035), 0x2037 => array(0x2035, 0x2035, 0x2035),
 1889                     0x2057 => array(0x2032, 0x2032, 0x2032, 0x2032), 0x2070 => array(0x30), 0x2071 => array(0x69),
 1890                     0x2074 => array(0x34), 0x2075 => array(0x35), 0x2076 => array(0x36),
 1891                     0x2077 => array(0x37), 0x2078 => array(0x38), 0x2079 => array(0x39),
 1892                     0x207B => array(0x2212), 0x207F => array(0x6E), 0x2080 => array(0x30),
 1893                     0x2081 => array(0x31), 0x2082 => array(0x32), 0x2083 => array(0x33),
 1894                     0x2084 => array(0x34), 0x2085 => array(0x35), 0x2086 => array(0x36),
 1895                     0x2087 => array(0x37), 0x2088 => array(0x38), 0x2089 => array(0x39),
 1896                     0x208B => array(0x2212), 0x2090 => array(0x61), 0x2091 => array(0x65),
 1897                     0x2092 => array(0x6F), 0x2093 => array(0x78), 0x2094 => array(0x259),
 1898                     0x2095 => array(0x68), 0x2096 => array(0x6B), 0x2097 => array(0x6C),
 1899                     0x2098 => array(0x6D), 0x2099 => array(0x6E), 0x209A => array(0x70),
 1900                     0x209B => array(0x73), 0x209C => array(0x74), 0x20A8 => array(0x72, 0x73),
 1901                     0x2102 => array(0x63), 0x2103 => array(0xB0, 0x63), 0x2107 => array(0x25B),
 1902                     0x2109 => array(0xB0, 0x66), 0x210A => array(0x67), 0x210B => array(0x68),
 1903                     0x210C => array(0x68), 0x210D => array(0x68), 0x210E => array(0x68),
 1904                     0x210F => array(0x127), 0x2110 => array(0x69), 0x2111 => array(0x69),
 1905                     0x2112 => array(0x6C), 0x2113 => array(0x6C), 0x2115 => array(0x6E),
 1906                     0x2116 => array(0x6E, 0x6F), 0x2119 => array(0x70), 0x211A => array(0x71),
 1907                     0x211B => array(0x72), 0x211C => array(0x72), 0x211D => array(0x72),
 1908                     0x2120 => array(0x73, 0x6D), 0x2121 => array(0x74, 0x65, 0x6C), 0x2122 => array(0x74, 0x6D),
 1909                     0x2124 => array(0x7A), 0x2126 => array(0x3C9), 0x2128 => array(0x7A),
 1910                     0x212A => array(0x6B), 0x212B => array(0xE5), 0x212C => array(0x62),
 1911                     0x212D => array(0x63), 0x212F => array(0x65), 0x2130 => array(0x65),
 1912                     0x2131 => array(0x66), 0x2133 => array(0x6D), 0x2134 => array(0x6F),
 1913                     0x2135 => array(0x5D0), 0x2136 => array(0x5D1), 0x2137 => array(0x5D2),
 1914                     0x2138 => array(0x5D3), 0x2139 => array(0x69), 0x213B => array(0x66, 0x61, 0x78),
 1915                     0x213C => array(0x3C0), 0x213D => array(0x3B3), 0x213E => array(0x3B3),
 1916                     0x213F => array(0x3C0), 0x2140 => array(0x2211), 0x2145 => array(0x64),
 1917                     0x2146 => array(0x64), 0x2147 => array(0x65), 0x2148 => array(0x69),
 1918                     0x2149 => array(0x6A), 0x2150 => array(0x31, 0x2044, 0x37), 0x2151 => array(0x31, 0x2044, 0x39),
 1919                     0x2152 => array(0x31, 0x2044, 0x31, 0x30), 0x2153 => array(0x31, 0x2044, 0x33), 0x2154 => array(0x32, 0x2044, 0x33),
 1920                     0x2155 => array(0x31, 0x2044, 0x35), 0x2156 => array(0x32, 0x2044, 0x35), 0x2157 => array(0x33, 0x2044, 0x35),
 1921                     0x2158 => array(0x34, 0x2044, 0x35), 0x2159 => array(0x31, 0x2044, 0x36), 0x215A => array(0x35, 0x2044, 0x36),
 1922                     0x215B => array(0x31, 0x2044, 0x38), 0x215C => array(0x33, 0x2044, 0x38), 0x215D => array(0x35, 0x2044, 0x38),
 1923                     0x215E => array(0x37, 0x2044, 0x38), 0x215F => array(0x31, 0x2044), 0x2160 => array(0x69),
 1924                     0x2161 => array(0x69, 0x69), 0x2162 => array(0x69, 0x69, 0x69), 0x2163 => array(0x69, 0x76),
 1925                     0x2164 => array(0x76), 0x2165 => array(0x76, 0x69), 0x2166 => array(0x76, 0x69, 0x69),
 1926                     0x2167 => array(0x76, 0x69, 0x69, 0x69), 0x2168 => array(0x69, 0x78), 0x2169 => array(0x78),
 1927                     0x216A => array(0x78, 0x69), 0x216B => array(0x78, 0x69, 0x69), 0x216C => array(0x6C),
 1928                     0x216D => array(0x63), 0x216E => array(0x64), 0x216F => array(0x6D),
 1929                     0x2170 => array(0x69), 0x2171 => array(0x69, 0x69), 0x2172 => array(0x69, 0x69, 0x69),
 1930                     0x2173 => array(0x69, 0x76), 0x2174 => array(0x76), 0x2175 => array(0x76, 0x69),
 1931                     0x2176 => array(0x76, 0x69, 0x69), 0x2177 => array(0x76, 0x69, 0x69, 0x69), 0x2178 => array(0x69, 0x78),
 1932                     0x2179 => array(0x78), 0x217A => array(0x78, 0x69), 0x217B => array(0x78, 0x69, 0x69),
 1933                     0x217C => array(0x6C), 0x217D => array(0x63), 0x217E => array(0x64),
 1934                     0x217F => array(0x6D), 0x2189 => array(0x30, 0x2044, 0x33), 0x222C => array(0x222B, 0x222B),
 1935                     0x222D => array(0x222B, 0x222B, 0x222B), 0x222F => array(0x222E, 0x222E), 0x2230 => array(0x222E, 0x222E, 0x222E),
 1936                     0x2329 => array(0x3008), 0x232A => array(0x3009), 0x2460 => array(0x31),
 1937                     0x2461 => array(0x32), 0x2462 => array(0x33), 0x2463 => array(0x34),
 1938                     0x2464 => array(0x35), 0x2465 => array(0x36), 0x2466 => array(0x37),
 1939                     0x2467 => array(0x38), 0x2468 => array(0x39), 0x2469 => array(0x31, 0x30),
 1940                     0x246A => array(0x31, 0x31), 0x246B => array(0x31, 0x32), 0x246C => array(0x31, 0x33),
 1941                     0x246D => array(0x31, 0x34), 0x246E => array(0x31, 0x35), 0x246F => array(0x31, 0x36),
 1942                     0x2470 => array(0x31, 0x37), 0x2471 => array(0x31, 0x38), 0x2472 => array(0x31, 0x39),
 1943                     0x2473 => array(0x32, 0x30), 0x24B6 => array(0x61), 0x24B7 => array(0x62),
 1944                     0x24B8 => array(0x63), 0x24B9 => array(0x64), 0x24BA => array(0x65),
 1945                     0x24BB => array(0x66), 0x24BC => array(0x67), 0x24BD => array(0x68),
 1946                     0x24BE => array(0x69), 0x24BF => array(0x6A), 0x24C0 => array(0x6B),
 1947                     0x24C1 => array(0x6C), 0x24C2 => array(0x6D), 0x24C3 => array(0x6E),
 1948                     0x24C4 => array(0x6F), 0x24C5 => array(0x70), 0x24C6 => array(0x71),
 1949                     0x24C7 => array(0x72), 0x24C8 => array(0x73), 0x24C9 => array(0x74),
 1950                     0x24CA => array(0x75), 0x24CB => array(0x76), 0x24CC => array(0x77),
 1951                     0x24CD => array(0x78), 0x24CE => array(0x79), 0x24CF => array(0x7A),
 1952                     0x24D0 => array(0x61), 0x24D1 => array(0x62), 0x24D2 => array(0x63),
 1953                     0x24D3 => array(0x64), 0x24D4 => array(0x65), 0x24D5 => array(0x66),
 1954                     0x24D6 => array(0x67), 0x24D7 => array(0x68), 0x24D8 => array(0x69),
 1955                     0x24D9 => array(0x6A), 0x24DA => array(0x6B), 0x24DB => array(0x6C),
 1956                     0x24DC => array(0x6D), 0x24DD => array(0x6E), 0x24DE => array(0x6F),
 1957                     0x24DF => array(0x70), 0x24E0 => array(0x71), 0x24E1 => array(0x72),
 1958                     0x24E2 => array(0x73), 0x24E3 => array(0x74), 0x24E4 => array(0x75),
 1959                     0x24E5 => array(0x76), 0x24E6 => array(0x77), 0x24E7 => array(0x78),
 1960                     0x24E8 => array(0x79), 0x24E9 => array(0x7A), 0x24EA => array(0x30),
 1961                     0x2A0C => array(0x222B, 0x222B, 0x222B, 0x222B), 0x2ADC => array(0x2ADD, 0x338), 0x2C00 => array(0x2C30),
 1962                     0x2C01 => array(0x2C31), 0x2C02 => array(0x2C32), 0x2C03 => array(0x2C33),
 1963                     0x2C04 => array(0x2C34), 0x2C05 => array(0x2C35), 0x2C06 => array(0x2C36),
 1964                     0x2C07 => array(0x2C37), 0x2C08 => array(0x2C38), 0x2C09 => array(0x2C39),
 1965                     0x2C0A => array(0x2C3A), 0x2C0B => array(0x2C3B), 0x2C0C => array(0x2C3C),
 1966                     0x2C0D => array(0x2C3D), 0x2C0E => array(0x2C3E), 0x2C0F => array(0x2C3F),
 1967                     0x2C10 => array(0x2C40), 0x2C11 => array(0x2C41), 0x2C12 => array(0x2C42),
 1968                     0x2C13 => array(0x2C43), 0x2C14 => array(0x2C44), 0x2C15 => array(0x2C45),
 1969                     0x2C16 => array(0x2C46), 0x2C17 => array(0x2C47), 0x2C18 => array(0x2C48),
 1970                     0x2C19 => array(0x2C49), 0x2C1A => array(0x2C4A), 0x2C1B => array(0x2C4B),
 1971                     0x2C1C => array(0x2C4C), 0x2C1D => array(0x2C4D), 0x2C1E => array(0x2C4E),
 1972                     0x2C1F => array(0x2C4F), 0x2C20 => array(0x2C50), 0x2C21 => array(0x2C51),
 1973                     0x2C22 => array(0x2C52), 0x2C23 => array(0x2C53), 0x2C24 => array(0x2C54),
 1974                     0x2C25 => array(0x2C55), 0x2C26 => array(0x2C56), 0x2C27 => array(0x2C57),
 1975                     0x2C28 => array(0x2C58), 0x2C29 => array(0x2C59), 0x2C2A => array(0x2C5A),
 1976                     0x2C2B => array(0x2C5B), 0x2C2C => array(0x2C5C), 0x2C2D => array(0x2C5D),
 1977                     0x2C2E => array(0x2C5E), 0x2C60 => array(0x2C61), 0x2C62 => array(0x26B),
 1978                     0x2C63 => array(0x1D7D), 0x2C64 => array(0x27D), 0x2C67 => array(0x2C68),
 1979                     0x2C69 => array(0x2C6A), 0x2C6B => array(0x2C6C), 0x2C6D => array(0x251),
 1980                     0x2C6E => array(0x271), 0x2C6F => array(0x250), 0x2C70 => array(0x252),
 1981                     0x2C72 => array(0x2C73), 0x2C75 => array(0x2C76), 0x2C7C => array(0x6A),
 1982                     0x2C7D => array(0x76), 0x2C7E => array(0x23F), 0x2C7F => array(0x240),
 1983                     0x2C80 => array(0x2C81), 0x2C82 => array(0x2C83), 0x2C84 => array(0x2C85),
 1984                     0x2C86 => array(0x2C87), 0x2C88 => array(0x2C89), 0x2C8A => array(0x2C8B),
 1985                     0x2C8C => array(0x2C8D), 0x2C8E => array(0x2C8F), 0x2C90 => array(0x2C91),
 1986                     0x2C92 => array(0x2C93), 0x2C94 => array(0x2C95), 0x2C96 => array(0x2C97),
 1987                     0x2C98 => array(0x2C99), 0x2C9A => array(0x2C9B), 0x2C9C => array(0x2C9D),
 1988                     0x2C9E => array(0x2C9F), 0x2CA0 => array(0x2CA1), 0x2CA2 => array(0x2CA3),
 1989                     0x2CA4 => array(0x2CA5), 0x2CA6 => array(0x2CA7), 0x2CA8 => array(0x2CA9),
 1990                     0x2CAA => array(0x2CAB), 0x2CAC => array(0x2CAD), 0x2CAE => array(0x2CAF),
 1991                     0x2CB0 => array(0x2CB1), 0x2CB2 => array(0x2CB3), 0x2CB4 => array(0x2CB5),
 1992                     0x2CB6 => array(0x2CB7), 0x2CB8 => array(0x2CB9), 0x2CBA => array(0x2CBB),
 1993                     0x2CBC => array(0x2CBD), 0x2CBE => array(0x2CBF), 0x2CC0 => array(0x2CC1),
 1994                     0x2CC2 => array(0x2CC3), 0x2CC4 => array(0x2CC5), 0x2CC6 => array(0x2CC7),
 1995                     0x2CC8 => array(0x2CC9), 0x2CCA => array(0x2CCB), 0x2CCC => array(0x2CCD),
 1996                     0x2CCE => array(0x2CCF), 0x2CD0 => array(0x2CD1), 0x2CD2 => array(0x2CD3),
 1997                     0x2CD4 => array(0x2CD5), 0x2CD6 => array(0x2CD7), 0x2CD8 => array(0x2CD9),
 1998                     0x2CDA => array(0x2CDB), 0x2CDC => array(0x2CDD), 0x2CDE => array(0x2CDF),
 1999                     0x2CE0 => array(0x2CE1), 0x2CE2 => array(0x2CE3), 0x2CEB => array(0x2CEC),
 2000                     0x2CED => array(0x2CEE), 0x2CF2 => array(0x2CF3), 0x2D6F => array(0x2D61),
 2001                     0x2E9F => array(0x6BCD), 0x2EF3 => array(0x9F9F), 0x2F00 => array(0x4E00),
 2002                     0x2F01 => array(0x4E28), 0x2F02 => array(0x4E36), 0x2F03 => array(0x4E3F),
 2003                     0x2F04 => array(0x4E59), 0x2F05 => array(0x4E85), 0x2F06 => array(0x4E8C),
 2004                     0x2F07 => array(0x4EA0), 0x2F08 => array(0x4EBA), 0x2F09 => array(0x513F),
 2005                     0x2F0A => array(0x5165), 0x2F0B => array(0x516B), 0x2F0C => array(0x5182),
 2006                     0x2F0D => array(0x5196), 0x2F0E => array(0x51AB), 0x2F0F => array(0x51E0),
 2007                     0x2F10 => array(0x51F5), 0x2F11 => array(0x5200), 0x2F12 => array(0x529B),
 2008                     0x2F13 => array(0x52F9), 0x2F14 => array(0x5315), 0x2F15 => array(0x531A),
 2009                     0x2F16 => array(0x5338), 0x2F17 => array(0x5341), 0x2F18 => array(0x535C),
 2010                     0x2F19 => array(0x5369), 0x2F1A => array(0x5382), 0x2F1B => array(0x53B6),
 2011                     0x2F1C => array(0x53C8), 0x2F1D => array(0x53E3), 0x2F1E => array(0x56D7),
 2012                     0x2F1F => array(0x571F), 0x2F20 => array(0x58EB), 0x2F21 => array(0x5902),
 2013                     0x2F22 => array(0x590A), 0x2F23 => array(0x5915), 0x2F24 => array(0x5927),
 2014                     0x2F25 => array(0x5973), 0x2F26 => array(0x5B50), 0x2F27 => array(0x5B80),
 2015                     0x2F28 => array(0x5BF8), 0x2F29 => array(0x5C0F), 0x2F2A => array(0x5C22),
 2016                     0x2F2B => array(0x5C38), 0x2F2C => array(0x5C6E), 0x2F2D => array(0x5C71),
 2017                     0x2F2E => array(0x5DDB), 0x2F2F => array(0x5DE5), 0x2F30 => array(0x5DF1),
 2018                     0x2F31 => array(0x5DFE), 0x2F32 => array(0x5E72), 0x2F33 => array(0x5E7A),
 2019                     0x2F34 => array(0x5E7F), 0x2F35 => array(0x5EF4), 0x2F36 => array(0x5EFE),
 2020                     0x2F37 => array(0x5F0B), 0x2F38 => array(0x5F13), 0x2F39 => array(0x5F50),
 2021                     0x2F3A => array(0x5F61), 0x2F3B => array(0x5F73), 0x2F3C => array(0x5FC3),
 2022                     0x2F3D => array(0x6208), 0x2F3E => array(0x6236), 0x2F3F => array(0x624B),
 2023                     0x2F40 => array(0x652F), 0x2F41 => array(0x6534), 0x2F42 => array(0x6587),
 2024                     0x2F43 => array(0x6597), 0x2F44 => array(0x65A4), 0x2F45 => array(0x65B9),
 2025                     0x2F46 => array(0x65E0), 0x2F47 => array(0x65E5), 0x2F48 => array(0x66F0),
 2026                     0x2F49 => array(0x6708), 0x2F4A => array(0x6728), 0x2F4B => array(0x6B20),
 2027                     0x2F4C => array(0x6B62), 0x2F4D => array(0x6B79), 0x2F4E => array(0x6BB3),
 2028                     0x2F4F => array(0x6BCB), 0x2F50 => array(0x6BD4), 0x2F51 => array(0x6BDB),
 2029                     0x2F52 => array(0x6C0F), 0x2F53 => array(0x6C14), 0x2F54 => array(0x6C34),
 2030                     0x2F55 => array(0x706B), 0x2F56 => array(0x722A), 0x2F57 => array(0x7236),
 2031                     0x2F58 => array(0x723B), 0x2F59 => array(0x723F), 0x2F5A => array(0x7247),
 2032                     0x2F5B => array(0x7259), 0x2F5C => array(0x725B), 0x2F5D => array(0x72AC),
 2033                     0x2F5E => array(0x7384), 0x2F5F => array(0x7389), 0x2F60 => array(0x74DC),
 2034                     0x2F61 => array(0x74E6), 0x2F62 => array(0x7518), 0x2F63 => array(0x751F),
 2035                     0x2F64 => array(0x7528), 0x2F65 => array(0x7530), 0x2F66 => array(0x758B),
 2036                     0x2F67 => array(0x7592), 0x2F68 => array(0x7676), 0x2F69 => array(0x767D),
 2037                     0x2F6A => array(0x76AE), 0x2F6B => array(0x76BF), 0x2F6C => array(0x76EE),
 2038                     0x2F6D => array(0x77DB), 0x2F6E => array(0x77E2), 0x2F6F => array(0x77F3),
 2039                     0x2F70 => array(0x793A), 0x2F71 => array(0x79B8), 0x2F72 => array(0x79BE),
 2040                     0x2F73 => array(0x7A74), 0x2F74 => array(0x7ACB), 0x2F75 => array(0x7AF9),
 2041                     0x2F76 => array(0x7C73), 0x2F77 => array(0x7CF8), 0x2F78 => array(0x7F36),
 2042                     0x2F79 => array(0x7F51), 0x2F7A => array(0x7F8A), 0x2F7B => array(0x7FBD),
 2043                     0x2F7C => array(0x8001), 0x2F7D => array(0x800C), 0x2F7E => array(0x8012),
 2044                     0x2F7F => array(0x8033), 0x2F80 => array(0x807F), 0x2F81 => array(0x8089),
 2045                     0x2F82 => array(0x81E3), 0x2F83 => array(0x81EA), 0x2F84 => array(0x81F3),
 2046                     0x2F85 => array(0x81FC), 0x2F86 => array(0x820C), 0x2F87 => array(0x821B),
 2047                     0x2F88 => array(0x821F), 0x2F89 => array(0x826E), 0x2F8A => array(0x8272),
 2048                     0x2F8B => array(0x8278), 0x2F8C => array(0x864D), 0x2F8D => array(0x866B),
 2049                     0x2F8E => array(0x8840), 0x2F8F => array(0x884C), 0x2F90 => array(0x8863),
 2050                     0x2F91 => array(0x897E), 0x2F92 => array(0x898B), 0x2F93 => array(0x89D2),
 2051                     0x2F94 => array(0x8A00), 0x2F95 => array(0x8C37), 0x2F96 => array(0x8C46),
 2052                     0x2F97 => array(0x8C55), 0x2F98 => array(0x8C78), 0x2F99 => array(0x8C9D),
 2053                     0x2F9A => array(0x8D64), 0x2F9B => array(0x8D70), 0x2F9C => array(0x8DB3),
 2054                     0x2F9D => array(0x8EAB), 0x2F9E => array(0x8ECA), 0x2F9F => array(0x8F9B),
 2055                     0x2FA0 => array(0x8FB0), 0x2FA1 => array(0x8FB5), 0x2FA2 => array(0x9091),
 2056                     0x2FA3 => array(0x9149), 0x2FA4 => array(0x91C6), 0x2FA5 => array(0x91CC),
 2057                     0x2FA6 => array(0x91D1), 0x2FA7 => array(0x9577), 0x2FA8 => array(0x9580),
 2058                     0x2FA9 => array(0x961C), 0x2FAA => array(0x96B6), 0x2FAB => array(0x96B9),
 2059                     0x2FAC => array(0x96E8), 0x2FAD => array(0x9751), 0x2FAE => array(0x975E),
 2060                     0x2FAF => array(0x9762), 0x2FB0 => array(0x9769), 0x2FB1 => array(0x97CB),
 2061                     0x2FB2 => array(0x97ED), 0x2FB3 => array(0x97F3), 0x2FB4 => array(0x9801),
 2062                     0x2FB5 => array(0x98A8), 0x2FB6 => array(0x98DB), 0x2FB7 => array(0x98DF),
 2063                     0x2FB8 => array(0x9996), 0x2FB9 => array(0x9999), 0x2FBA => array(0x99AC),
 2064                     0x2FBB => array(0x9AA8), 0x2FBC => array(0x9AD8), 0x2FBD => array(0x9ADF),
 2065                     0x2FBE => array(0x9B25), 0x2FBF => array(0x9B2F), 0x2FC0 => array(0x9B32),
 2066                     0x2FC1 => array(0x9B3C), 0x2FC2 => array(0x9B5A), 0x2FC3 => array(0x9CE5),
 2067                     0x2FC4 => array(0x9E75), 0x2FC5 => array(0x9E7F), 0x2FC6 => array(0x9EA5),
 2068                     0x2FC7 => array(0x9EBB), 0x2FC8 => array(0x9EC3), 0x2FC9 => array(0x9ECD),
 2069                     0x2FCA => array(0x9ED1), 0x2FCB => array(0x9EF9), 0x2FCC => array(0x9EFD),
 2070                     0x2FCD => array(0x9F0E), 0x2FCE => array(0x9F13), 0x2FCF => array(0x9F20),
 2071                     0x2FD0 => array(0x9F3B), 0x2FD1 => array(0x9F4A), 0x2FD2 => array(0x9F52),
 2072                     0x2FD3 => array(0x9F8D), 0x2FD4 => array(0x9F9C), 0x2FD5 => array(0x9FA0),
 2073                     0x3002 => array(0x2E), 0x3036 => array(0x3012), 0x3038 => array(0x5341),
 2074                     0x3039 => array(0x5344), 0x303A => array(0x5345), 0x309F => array(0x3088, 0x308A),
 2075                     0x30FF => array(0x30B3, 0x30C8), 0x3131 => array(0x1100), 0x3132 => array(0x1101),
 2076                     0x3133 => array(0x11AA), 0x3134 => array(0x1102), 0x3135 => array(0x11AC),
 2077                     0x3136 => array(0x11AD), 0x3137 => array(0x1103), 0x3138 => array(0x1104),
 2078                     0x3139 => array(0x1105), 0x313A => array(0x11B0), 0x313B => array(0x11B1),
 2079                     0x313C => array(0x11B2), 0x313D => array(0x11B3), 0x313E => array(0x11B4),
 2080                     0x313F => array(0x11B5), 0x3140 => array(0x111A), 0x3141 => array(0x1106),
 2081                     0x3142 => array(0x1107), 0x3143 => array(0x1108), 0x3144 => array(0x1121),
 2082                     0x3145 => array(0x1109), 0x3146 => array(0x110A), 0x3147 => array(0x110B),
 2083                     0x3148 => array(0x110C), 0x3149 => array(0x110D), 0x314A => array(0x110E),
 2084                     0x314B => array(0x110F), 0x314C => array(0x1110), 0x314D => array(0x1111),
 2085                     0x314E => array(0x1112), 0x314F => array(0x1161), 0x3150 => array(0x1162),
 2086                     0x3151 => array(0x1163), 0x3152 => array(0x1164), 0x3153 => array(0x1165),
 2087                     0x3154 => array(0x1166), 0x3155 => array(0x1167), 0x3156 => array(0x1168),
 2088                     0x3157 => array(0x1169), 0x3158 => array(0x116A), 0x3159 => array(0x116B),
 2089                     0x315A => array(0x116C), 0x315B => array(0x116D), 0x315C => array(0x116E),
 2090                     0x315D => array(0x116F), 0x315E => array(0x1170), 0x315F => array(0x1171),
 2091                     0x3160 => array(0x1172), 0x3161 => array(0x1173), 0x3162 => array(0x1174),
 2092                     0x3163 => array(0x1175), 0x3165 => array(0x1114), 0x3166 => array(0x1115),
 2093                     0x3167 => array(0x11C7), 0x3168 => array(0x11C8), 0x3169 => array(0x11CC),
 2094                     0x316A => array(0x11CE), 0x316B => array(0x11D3), 0x316C => array(0x11D7),
 2095                     0x316D => array(0x11D9), 0x316E => array(0x111C), 0x316F => array(0x11DD),
 2096                     0x3170 => array(0x11DF), 0x3171 => array(0x111D), 0x3172 => array(0x111E),
 2097                     0x3173 => array(0x1120), 0x3174 => array(0x1122), 0x3175 => array(0x1123),
 2098                     0x3176 => array(0x1127), 0x3177 => array(0x1129), 0x3178 => array(0x112B),
 2099                     0x3179 => array(0x112C), 0x317A => array(0x112D), 0x317B => array(0x112E),
 2100                     0x317C => array(0x112F), 0x317D => array(0x1132), 0x317E => array(0x1136),
 2101                     0x317F => array(0x1140), 0x3180 => array(0x1147), 0x3181 => array(0x114C),
 2102                     0x3182 => array(0x11F1), 0x3183 => array(0x11F2), 0x3184 => array(0x1157),
 2103                     0x3185 => array(0x1158), 0x3186 => array(0x1159), 0x3187 => array(0x1184),
 2104                     0x3188 => array(0x1185), 0x3189 => array(0x1188), 0x318A => array(0x1191),
 2105                     0x318B => array(0x1192), 0x318C => array(0x1194), 0x318D => array(0x119E),
 2106                     0x318E => array(0x11A1), 0x3192 => array(0x4E00), 0x3193 => array(0x4E8C),
 2107                     0x3194 => array(0x4E09), 0x3195 => array(0x56DB), 0x3196 => array(0x4E0A),
 2108                     0x3197 => array(0x4E2D), 0x3198 => array(0x4E0B), 0x3199 => array(0x7532),
 2109                     0x319A => array(0x4E59), 0x319B => array(0x4E19), 0x319C => array(0x4E01),
 2110                     0x319D => array(0x5929), 0x319E => array(0x5730), 0x319F => array(0x4EBA),
 2111                     0x3244 => array(0x554F), 0x3245 => array(0x5E7C), 0x3246 => array(0x6587),
 2112                     0x3247 => array(0x7B8F), 0x3250 => array(0x70, 0x74, 0x65), 0x3251 => array(0x32, 0x31),
 2113                     0x3252 => array(0x32, 0x32), 0x3253 => array(0x32, 0x33), 0x3254 => array(0x32, 0x34),
 2114                     0x3255 => array(0x32, 0x35), 0x3256 => array(0x32, 0x36), 0x3257 => array(0x32, 0x37),
 2115                     0x3258 => array(0x32, 0x38), 0x3259 => array(0x32, 0x39), 0x325A => array(0x33, 0x30),
 2116                     0x325B => array(0x33, 0x31), 0x325C => array(0x33, 0x32), 0x325D => array(0x33, 0x33),
 2117                     0x325E => array(0x33, 0x34), 0x325F => array(0x33, 0x35), 0x3260 => array(0x1100),
 2118                     0x3261 => array(0x1102), 0x3262 => array(0x1103), 0x3263 => array(0x1105),
 2119                     0x3264 => array(0x1106), 0x3265 => array(0x1107), 0x3266 => array(0x1109),
 2120                     0x3267 => array(0x110B), 0x3268 => array(0x110C), 0x3269 => array(0x110E),
 2121                     0x326A => array(0x110F), 0x326B => array(0x1110), 0x326C => array(0x1111),
 2122                     0x326D => array(0x1112), 0x326E => array(0xAC00), 0x326F => array(0xB098),
 2123                     0x3270 => array(0xB2E4), 0x3271 => array(0xB77C), 0x3272 => array(0xB9C8),
 2124                     0x3273 => array(0xBC14), 0x3274 => array(0xC0AC), 0x3275 => array(0xC544),
 2125                     0x3276 => array(0xC790), 0x3277 => array(0xCC28), 0x3278 => array(0xCE74),
 2126                     0x3279 => array(0xD0C0), 0x327A => array(0xD30C), 0x327B => array(0xD558),
 2127                     0x327C => array(0xCC38, 0xACE0), 0x327D => array(0xC8FC, 0xC758), 0x327E => array(0xC6B0),
 2128                     0x3280 => array(0x4E00), 0x3281 => array(0x4E8C), 0x3282 => array(0x4E09),
 2129                     0x3283 => array(0x56DB), 0x3284 => array(0x4E94), 0x3285 => array(0x516D),
 2130                     0x3286 => array(0x4E03), 0x3287 => array(0x516B), 0x3288 => array(0x4E5D),
 2131                     0x3289 => array(0x5341), 0x328A => array(0x6708), 0x328B => array(0x706B),
 2132                     0x328C => array(0x6C34), 0x328D => array(0x6728), 0x328E => array(0x91D1),
 2133                     0x328F => array(0x571F), 0x3290 => array(0x65E5), 0x3291 => array(0x682A),
 2134                     0x3292 => array(0x6709), 0x3293 => array(0x793E), 0x3294 => array(0x540D),
 2135                     0x3295 => array(0x7279), 0x3296 => array(0x8CA1), 0x3297 => array(0x795D),
 2136                     0x3298 => array(0x52B4), 0x3299 => array(0x79D8), 0x329A => array(0x7537),
 2137                     0x329B => array(0x5973), 0x329C => array(0x9069), 0x329D => array(0x512A),
 2138                     0x329E => array(0x5370), 0x329F => array(0x6CE8), 0x32A0 => array(0x9805),
 2139                     0x32A1 => array(0x4F11), 0x32A2 => array(0x5199), 0x32A3 => array(0x6B63),
 2140                     0x32A4 => array(0x4E0A), 0x32A5 => array(0x4E2D), 0x32A6 => array(0x4E0B),
 2141                     0x32A7 => array(0x5DE6), 0x32A8 => array(0x53F3), 0x32A9 => array(0x533B),
 2142                     0x32AA => array(0x5B97), 0x32AB => array(0x5B66), 0x32AC => array(0x76E3),
 2143                     0x32AD => array(0x4F01), 0x32AE => array(0x8CC7), 0x32AF => array(0x5354),
 2144                     0x32B0 => array(0x591C), 0x32B1 => array(0x33, 0x36), 0x32B2 => array(0x33, 0x37),
 2145                     0x32B3 => array(0x33, 0x38), 0x32B4 => array(0x33, 0x39), 0x32B5 => array(0x34, 0x30),
 2146                     0x32B6 => array(0x34, 0x31), 0x32B7 => array(0x34, 0x32), 0x32B8 => array(0x34, 0x33),
 2147                     0x32B9 => array(0x34, 0x34), 0x32BA => array(0x34, 0x35), 0x32BB => array(0x34, 0x36),
 2148                     0x32BC => array(0x34, 0x37), 0x32BD => array(0x34, 0x38), 0x32BE => array(0x34, 0x39),
 2149                     0x32BF => array(0x35, 0x30), 0x32C0 => array(0x31, 0x6708), 0x32C1 => array(0x32, 0x6708),
 2150                     0x32C2 => array(0x33, 0x6708), 0x32C3 => array(0x34, 0x6708), 0x32C4 => array(0x35, 0x6708),
 2151                     0x32C5 => array(0x36, 0x6708), 0x32C6 => array(0x37, 0x6708), 0x32C7 => array(0x38, 0x6708),
 2152                     0x32C8 => array(0x39, 0x6708), 0x32C9 => array(0x31, 0x30, 0x6708), 0x32CA => array(0x31, 0x31, 0x6708),
 2153                     0x32CB => array(0x31, 0x32, 0x6708), 0x32CC => array(0x68, 0x67), 0x32CD => array(0x65, 0x72, 0x67),
 2154                     0x32CE => array(0x65, 0x76), 0x32CF => array(0x6C, 0x74, 0x64), 0x32D0 => array(0x30A2),
 2155                     0x32D1 => array(0x30A4), 0x32D2 => array(0x30A6), 0x32D3 => array(0x30A8),
 2156                     0x32D4 => array(0x30AA), 0x32D5 => array(0x30AB), 0x32D6 => array(0x30AD),
 2157                     0x32D7 => array(0x30AF), 0x32D8 => array(0x30B1), 0x32D9 => array(0x30B3),
 2158                     0x32DA => array(0x30B5), 0x32DB => array(0x30B7), 0x32DC => array(0x30B9),
 2159                     0x32DD => array(0x30BB), 0x32DE => array(0x30BD), 0x32DF => array(0x30BF),
 2160                     0x32E0 => array(0x30C1), 0x32E1 => array(0x30C4), 0x32E2 => array(0x30C6),
 2161                     0x32E3 => array(0x30C8), 0x32E4 => array(0x30CA), 0x32E5 => array(0x30CB),
 2162                     0x32E6 => array(0x30CC), 0x32E7 => array(0x30CD), 0x32E8 => array(0x30CE),
 2163                     0x32E9 => array(0x30CF), 0x32EA => array(0x30D2), 0x32EB => array(0x30D5),
 2164                     0x32EC => array(0x30D8), 0x32ED => array(0x30DB), 0x32EE => array(0x30DE),
 2165                     0x32EF => array(0x30DF), 0x32F0 => array(0x30E0), 0x32F1 => array(0x30E1),
 2166                     0x32F2 => array(0x30E2), 0x32F3 => array(0x30E4), 0x32F4 => array(0x30E6),
 2167                     0x32F5 => array(0x30E8), 0x32F6 => array(0x30E9), 0x32F7 => array(0x30EA),
 2168                     0x32F8 => array(0x30EB), 0x32F9 => array(0x30EC), 0x32FA => array(0x30ED),
 2169                     0x32FB => array(0x30EF), 0x32FC => array(0x30F0), 0x32FD => array(0x30F1),
 2170                     0x32FE => array(0x30F2), 0x3300 => array(0x30A2, 0x30D1, 0x30FC, 0x30C8), 0x3301 => array(0x30A2, 0x30EB, 0x30D5, 0x30A1),
 2171                     0x3302 => array(0x30A2, 0x30F3, 0x30DA, 0x30A2), 0x3303 => array(0x30A2, 0x30FC, 0x30EB), 0x3304 => array(0x30A4, 0x30CB, 0x30F3, 0x30B0),
 2172                     0x3305 => array(0x30A4, 0x30F3, 0x30C1), 0x3306 => array(0x30A6, 0x30A9, 0x30F3), 0x3307 => array(0x30A8, 0x30B9, 0x30AF, 0x30FC, 0x30C9),
 2173                     0x3308 => array(0x30A8, 0x30FC, 0x30AB, 0x30FC), 0x3309 => array(0x30AA, 0x30F3, 0x30B9), 0x330A => array(0x30AA, 0x30FC, 0x30E0),
 2174                     0x330B => array(0x30AB, 0x30A4, 0x30EA), 0x330C => array(0x30AB, 0x30E9, 0x30C3, 0x30C8), 0x330D => array(0x30AB, 0x30ED, 0x30EA, 0x30FC),
 2175                     0x330E => array(0x30AC, 0x30ED, 0x30F3), 0x330F => array(0x30AC, 0x30F3, 0x30DE), 0x3310 => array(0x30AE, 0x30AC),
 2176                     0x3311 => array(0x30AE, 0x30CB, 0x30FC), 0x3312 => array(0x30AD, 0x30E5, 0x30EA, 0x30FC), 0x3313 => array(0x30AE, 0x30EB, 0x30C0, 0x30FC),
 2177                     0x3314 => array(0x30AD, 0x30ED), 0x3315 => array(0x30AD, 0x30ED, 0x30B0, 0x30E9, 0x30E0), 0x3316 => array(0x30AD, 0x30ED, 0x30E1, 0x30FC, 0x30C8, 0x30EB),
 2178                     0x3317 => array(0x30AD, 0x30ED, 0x30EF, 0x30C3, 0x30C8), 0x3318 => array(0x30B0, 0x30E9, 0x30E0), 0x3319 => array(0x30B0, 0x30E9, 0x30E0, 0x30C8, 0x30F3),
 2179                     0x331A => array(0x30AF, 0x30EB, 0x30BC, 0x30A4, 0x30ED), 0x331B => array(0x30AF, 0x30ED, 0x30FC, 0x30CD), 0x331C => array(0x30B1, 0x30FC, 0x30B9),
 2180                     0x331D => array(0x30B3, 0x30EB, 0x30CA), 0x331E => array(0x30B3, 0x30FC, 0x30DD), 0x331F => array(0x30B5, 0x30A4, 0x30AF, 0x30EB),
 2181                     0x3320 => array(0x30B5, 0x30F3, 0x30C1, 0x30FC, 0x30E0), 0x3321 => array(0x30B7, 0x30EA, 0x30F3, 0x30B0), 0x3322 => array(0x30BB, 0x30F3, 0x30C1),
 2182                     0x3323 => array(0x30BB, 0x30F3, 0x30C8), 0x3324 => array(0x30C0, 0x30FC, 0x30B9), 0x3325 => array(0x30C7, 0x30B7),
 2183                     0x3326 => array(0x30C9, 0x30EB), 0x3327 => array(0x30C8, 0x30F3), 0x3328 => array(0x30CA, 0x30CE),
 2184                     0x3329 => array(0x30CE, 0x30C3, 0x30C8), 0x332A => array(0x30CF, 0x30A4, 0x30C4), 0x332B => array(0x30D1, 0x30FC, 0x30BB, 0x30F3, 0x30C8),
 2185                     0x332C => array(0x30D1, 0x30FC, 0x30C4), 0x332D => array