lib/system/api/idna/idna_convert.class.php

   1 <?php
   2 namespace dns\system\api\idna;
   3
   4 // {{{ license
   5
   6 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
   7 //
   8 // +----------------------------------------------------------------------+
   9 // | This library is free software; you can redistribute it and/or modify |
  10 // | it under the terms of the GNU Lesser General Public License as       |
  11 // | published by the Free Software Foundation; either version 2.1 of the |
  12 // | License, or (at your option) any later version.                      |
  13 // |                                                                      |
  14 // | This library is distributed in the hope that it will be useful, but  |
  15 // | WITHOUT ANY WARRANTY; without even the implied warranty of           |
  16 // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
  17 // | Lesser General Public License for more details.                      |
  18 // |                                                                      |
  19 // | You should have received a copy of the GNU Lesser General Public     |
  20 // | License along with this library; if not, write to the Free Software  |
  21 // | Foundation, Inc., 51 Franklin St, Boston, MA 02110, United States    |
  22 // +----------------------------------------------------------------------+
  23 //
  24 // }}}
  25
  26 /**
  27  * Encode/decode Internationalized Domain Names.
  28  *
  29  * The class allows to convert internationalized domain names
  30  * (see RFC 3490 for details) as they can be used with various registries worldwide
  31  * to be translated between their original (localized) form and their encoded form
  32  * as it will be used in the DNS (Domain Name System).
  33  *
  34  * The class provides two public methods, encode() and decode(), which do exactly
  35  * what you would expect them to do. You are allowed to use complete domain names,
  36  * simple strings and complete email addresses as well. That means, that you might
  37  * use any of the following notations:
  38  *
  39  * - www.nörgler.com
  40  * - xn--nrgler-wxa
  41  * - xn--brse-5qa.xn--knrz-1ra.info
  42  *
  43  * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4 array.
  44  * Unicode output is available in the same formats.
  45  * You can select your preferred format via {@link set_paramter()}.
  46  *
  47  * ACE input and output is always expected to be ASCII.
  48  *
  49  * @author  Matthias Sommerfeld <mso@phlylabs.de>
  50  * @copyright 2004-2014 phlyLabs Berlin, http://phlylabs.de
  51  * @version 0.9.0 2014-12-12
  52  */
  53 class idna_convert {
  54
  55     private $version = '0.9.0';
  56     protected $sub_version = 'main';
  57
  58     // NP See below
  59     // Internal settings, do not mess with them
  60     protected $_punycode_prefix = 'xn--';
  61     protected $_invalid_ucs = 0x80000000;
  62     protected $_max_ucs = 0x10FFFF;
  63     protected $_base = 36;
  64     protected $_tmin = 1;
  65     protected $_tmax = 26;
  66     protected $_skew = 38;
  67     protected $_damp = 700;
  68     protected $_initial_bias = 72;
  69     protected $_initial_n = 0x80;
  70     protected $_sbase = 0xAC00;
  71     protected $_lbase = 0x1100;
  72     protected $_vbase = 0x1161;
  73     protected $_tbase = 0x11A7;
  74     protected $_lcount = 19;
  75     protected $_vcount = 21;
  76     protected $_tcount = 28;
  77     protected $_ncount = 588;   // _vcount * _tcount
  78     protected $_scount = 11172; // _lcount * _tcount * _vcount
  79     protected $_error = false;
  80     protected static $_mb_string_overload = null;
  81     // See {@link set_paramter()} for details of how to change the following
  82     // settings from within your script / application
  83     protected $_api_encoding = 'utf8';   // Default input charset is UTF-8
  84     protected $_allow_overlong = false;  // Overlong UTF-8 encodings are forbidden
  85     protected $_strict_mode = false;     // Behave strict or not
  86     protected $_idn_version = 2003;      // Can be either 2003 (old, default) or 2008
  87
  88     /**
  89      * the constructor
  90      *
  91      * @param array $options
  92      * @return boolean
  93      * @since 0.5.2
  94      */
  95     public function __construct($options = false)
  96     {
  97         $this->slast = $this->_sbase + $this->_lcount * $this->_vcount * $this->_tcount;
  98         // If parameters are given, pass these to the respective method
  99         if (is_array($options)) {
 100             $this->set_parameter($options);
 101         }
 102
 103         // populate mbstring overloading cache if not set
 104         if (self::$_mb_string_overload === null) {
 105             self::$_mb_string_overload = (extension_loaded('mbstring') && (ini_get('mbstring.func_overload') & 0x02) === 0x02);
 106         }
 107     }
 108
 109     public function get_version()
 110     {
 111         return $this->version.'-'.$this->sub_version;
 112     }
 113
 114     /**
 115      * Sets a new option value. Available options and values:
 116      * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
 117      *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
 118      * [overlong - Unicode does not allow unnecessarily long encodings of chars,
 119      *             to allow this, set this parameter to true, else to false;
 120      *             default is false.]
 121      * [strict - true: strict mode, good for registration purposes - Causes errors
 122      *           on failures; false: loose mode, ideal for "wildlife" applications
 123      *           by silently ignoring errors and returning the original input instead
 124      *
 125      * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
 126      * @param    string    Value to use (if parameter 1 is a string)
 127      * @return   boolean   true on success, false otherwise
 128      */
 129     public function set_parameter($option, $value = false)
 130     {
 131         if (!is_array($option)) {
 132             $option = array($option => $value);
 133         }
 134         foreach ($option as $k => $v) {
 135             switch ($k) {
 136                 case 'encoding':
 137                     switch ($v) {
 138                         case 'utf8':
 139                         case 'ucs4_string':
 140                         case 'ucs4_array':
 141                             $this->_api_encoding = $v;
 142                             break;
 143                         default:
 144                             $this->_error('Set Parameter: Unknown parameter ' . $v . ' for option ' . $k);
 145                             return false;
 146                     }
 147                     break;
 148                 case 'overlong':
 149                     $this->_allow_overlong = ($v) ? true : false;
 150                     break;
 151                 case 'strict':
 152                     $this->_strict_mode = ($v) ? true : false;
 153                     break;
 154                 case 'idn_version':
 155                     if (in_array($v, array('2003', '2008'))) {
 156                         $this->_idn_version = $v;
 157                     } else {
 158                         $this->_error('Set Parameter: Unknown parameter ' . $v . ' for option ' . $k);
 159                     }
 160                     break;
 161                 case 'encode_german_sz': // Deprecated
 162                     if (!$v) {
 163                         self::$NP['replacemaps'][0xDF] = array(0x73, 0x73);
 164                     } else {
 165                         unset(self::$NP['replacemaps'][0xDF]);
 166                     }
 167                     break;
 168                 default:
 169                     $this->_error('Set Parameter: Unknown option ' . $k);
 170                     return false;
 171             }
 172         }
 173         return true;
 174     }
 175
 176     /**
 177      * Decode a given ACE domain name
 178      * @param    string   Domain name (ACE string)
 179      * [@param    string   Desired output encoding, see {@link set_parameter}]
 180      * @return   string   Decoded Domain name (UTF-8 or UCS-4)
 181      */
 182     public function decode($input, $one_time_encoding = false)
 183     {
 184         // Optionally set
 185         if ($one_time_encoding) {
 186             switch ($one_time_encoding) {
 187                 case 'utf8':
 188                 case 'ucs4_string':
 189                 case 'ucs4_array':
 190                     break;
 191                 default:
 192                     $this->_error('Unknown encoding ' . $one_time_encoding);
 193                     return false;
 194             }
 195         }
 196         // Make sure to drop any newline characters around
 197         $input = trim($input);
 198
 199         // Negotiate input and try to determine, whether it is a plain string,
 200         // an email address or something like a complete URL
 201         if (strpos($input, '@')) { // Maybe it is an email address
 202             // No no in strict mode
 203             if ($this->_strict_mode) {
 204                 $this->_error('Only simple domain name parts can be handled in strict mode');
 205                 return false;
 206             }
 207             list ($email_pref, $input) = explode('@', $input, 2);
 208             $arr = explode('.', $input);
 209             foreach ($arr as $k => $v) {
 210                 if (preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $v)) {
 211                     $conv = $this->_decode($v);
 212                     if ($conv) {
 213                         $arr[$k] = $conv;
 214                     }
 215                 }
 216             }
 217             $input = join('.', $arr);
 218             $arr = explode('.', $email_pref);
 219             foreach ($arr as $k => $v) {
 220                 if (preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $v)) {
 221                     $conv = $this->_decode($v);
 222                     if ($conv) {
 223                         $arr[$k] = $conv;
 224                     }
 225                 }
 226             }
 227             $email_pref = join('.', $arr);
 228             $return = $email_pref . '@' . $input;
 229         } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
 230             // No no in strict mode
 231             if ($this->_strict_mode) {
 232                 $this->_error('Only simple domain name parts can be handled in strict mode');
 233                 return false;
 234             }
 235             $parsed = parse_url($input);
 236             if (isset($parsed['host'])) {
 237                 $arr = explode('.', $parsed['host']);
 238                 foreach ($arr as $k => $v) {
 239                     $conv = $this->_decode($v);
 240                     if ($conv) {
 241                         $arr[$k] = $conv;
 242                     }
 243                 }
 244                 $parsed['host'] = join('.', $arr);
 245                 $return = (empty($parsed['scheme']) ? '' : $parsed['scheme'] . (strtolower($parsed['scheme']) == 'mailto' ? ':' : '://')).
 246                         (empty($parsed['user']) ? '' : $parsed['user'] . (empty($parsed['pass']) ? '' : ':' . $parsed['pass']) . '@').
 247                         $parsed['host'].
 248                         (empty($parsed['port']) ? '' : ':' . $parsed['port']).
 249                         (empty($parsed['path']) ? '' : $parsed['path']).
 250                         (empty($parsed['query']) ? '' : '?' . $parsed['query']).
 251                         (empty($parsed['fragment']) ? '' : '#' . $parsed['fragment']);
 252             } else { // parse_url seems to have failed, try without it
 253                 $arr = explode('.', $input);
 254                 foreach ($arr as $k => $v) {
 255                     $conv = $this->_decode($v);
 256                     $arr[$k] = ($conv) ? $conv : $v;
 257                 }
 258                 $return = join('.', $arr);
 259             }
 260         } else { // Otherwise we consider it being a pure domain name string
 261             $return = $this->_decode($input);
 262             if (!$return) {
 263                 $return = $input;
 264             }
 265         }
 266         // The output is UTF-8 by default, other output formats need conversion here
 267         // If one time encoding is given, use this, else the objects property
 268         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
 269             case 'utf8':        return $return; // break;
 270             case 'ucs4_string': return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));  // break;
 271             case 'ucs4_array':  return $this->_utf8_to_ucs4($return); // break;
 272             default:            $this->_error('Unsupported output format'); return false;
 273         }
 274     }
 275
 276     /**
 277      * Encode a given UTF-8 domain name
 278      * @param    string   Domain name (UTF-8 or UCS-4)
 279      * [@param    string   Desired input encoding, see {@link set_parameter}]
 280      * @return   string   Encoded Domain name (ACE string)
 281      */
 282     public function encode($decoded, $one_time_encoding = false)
 283     {
 284         // Forcing conversion of input to UCS4 array
 285         // If one time encoding is given, use this, else the objects property
 286         switch ($one_time_encoding ? $one_time_encoding : $this->_api_encoding) {
 287             case 'utf8':
 288                 $decoded = $this->_utf8_to_ucs4($decoded);
 289                 break;
 290             case 'ucs4_string':
 291                 $decoded = $this->_ucs4_string_to_ucs4($decoded);
 292             case 'ucs4_array':
 293                 break;
 294             default:
 295                 $this->_error('Unsupported input format: ' . ($one_time_encoding ? $one_time_encoding : $this->_api_encoding));
 296                 return false;
 297         }
 298
 299         // No input, no output, what else did you expect?
 300         if (empty($decoded)) {
 301             return '';
 302         }
 303
 304         // Anchors for iteration
 305         $last_begin = 0;
 306         // Output string
 307         $output = '';
 308         foreach ($decoded as $k => $v) {
 309             // Make sure to use just the plain dot
 310             switch ($v) {
 311                 case 0x3002:
 312                 case 0xFF0E:
 313                 case 0xFF61:
 314                     $decoded[$k] = 0x2E;
 315                     // Right, no break here, the above are converted to dots anyway
 316                 // Stumbling across an anchoring character
 317                 case 0x2E:
 318                 case 0x2F:
 319                 case 0x3A:
 320                 case 0x3F:
 321                 case 0x40:
 322                     // Neither email addresses nor URLs allowed in strict mode
 323                     if ($this->_strict_mode) {
 324                         $this->_error('Neither email addresses nor URLs are allowed in strict mode.');
 325                         return false;
 326                     } else {
 327                         // Skip first char
 328                         if ($k) {
 329                             $encoded = '';
 330                             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k) - $last_begin)));
 331                             if ($encoded) {
 332                                 $output .= $encoded;
 333                             } else {
 334                                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k) - $last_begin)));
 335                             }
 336                             $output .= chr($decoded[$k]);
 337                         }
 338                         $last_begin = $k + 1;
 339                     }
 340             }
 341         }
 342         // Catch the rest of the string
 343         if ($last_begin) {
 344             $inp_len = sizeof($decoded);
 345             $encoded = '';
 346             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len) - $last_begin)));
 347             if ($encoded) {
 348                 $output .= $encoded;
 349             } else {
 350                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len) - $last_begin)));
 351             }
 352             return $output;
 353         } else {
 354             if (false !== ($output = $this->_encode($decoded))) {
 355                 return $output;
 356             } else {
 357                 return $this->_ucs4_to_utf8($decoded);
 358             }
 359         }
 360     }
 361
 362     /**
 363      * Removes a weakness of encode(), which cannot properly handle URIs but instead encodes their
 364      * path or query components, too.
 365      * @param string  $uri  Expects the URI as a UTF-8 (or ASCII) string
 366      * @return  string  The URI encoded to Punycode, everything but the host component is left alone
 367      * @since 0.6.4
 368      */
 369     public function encode_uri($uri)
 370     {
 371         $parsed = parse_url($uri);
 372         if (!isset($parsed['host'])) {
 373             $this->_error('The given string does not look like a URI');
 374             return false;
 375         }
 376         $arr = explode('.', $parsed['host']);
 377         foreach ($arr as $k => $v) {
 378             $conv = $this->encode($v, 'utf8');
 379             if ($conv) {
 380                 $arr[$k] = $conv;
 381             }
 382         }
 383         $parsed['host'] = join('.', $arr);
 384         $return = (empty($parsed['scheme']) ? '' : $parsed['scheme'] . (strtolower($parsed['scheme']) == 'mailto' ? ':' : '://')).
 385                 (empty($parsed['user']) ? '' : $parsed['user'] . (empty($parsed['pass']) ? '' : ':' . $parsed['pass']) . '@').
 386                 $parsed['host'].
 387                 (empty($parsed['port']) ? '' : ':' . $parsed['port']).
 388                 (empty($parsed['path']) ? '' : $parsed['path']).
 389                 (empty($parsed['query']) ? '' : '?' . $parsed['query']).
 390                 (empty($parsed['fragment']) ? '' : '#' . $parsed['fragment']);
 391         return $return;
 392     }
 393
 394     /**
 395      * Use this method to get the last error ocurred
 396      * @param    void
 397      * @return   string   The last error, that occured
 398      */
 399     public function get_last_error()
 400     {
 401         return $this->_error;
 402     }
 403
 404     /**
 405      * The actual decoding algorithm
 406      * @param string
 407      * @return mixed
 408      */
 409     protected function _decode($encoded)
 410     {
 411         $decoded = array();
 412         // find the Punycode prefix
 413         if (!preg_match('!^' . preg_quote($this->_punycode_prefix, '!') . '!', $encoded)) {
 414             $this->_error('This is not a punycode string');
 415             return false;
 416         }
 417         $encode_test = preg_replace('!^' . preg_quote($this->_punycode_prefix, '!') . '!', '', $encoded);
 418         // If nothing left after removing the prefix, it is hopeless
 419         if (!$encode_test) {
 420             $this->_error('The given encoded string was empty');
 421             return false;
 422         }
 423         // Find last occurence of the delimiter
 424         $delim_pos = strrpos($encoded, '-');
 425         if ($delim_pos > self::byteLength($this->_punycode_prefix)) {
 426             for ($k = self::byteLength($this->_punycode_prefix); $k < $delim_pos; ++$k) {
 427                 $decoded[] = ord($encoded{$k});
 428             }
 429         }
 430         $deco_len = count($decoded);
 431         $enco_len = self::byteLength($encoded);
 432
 433         // Wandering through the strings; init
 434         $is_first = true;
 435         $bias = $this->_initial_bias;
 436         $idx = 0;
 437         $char = $this->_initial_n;
 438
 439         for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
 440             for ($old_idx = $idx, $w = 1, $k = $this->_base; 1; $k += $this->_base) {
 441                 $digit = $this->_decode_digit($encoded{$enco_idx++});
 442                 $idx += $digit * $w;
 443                 $t = ($k <= $bias) ? $this->_tmin :
 444                         (($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
 445                 if ($digit < $t) {
 446                     break;
 447                 }
 448                 $w = (int) ($w * ($this->_base - $t));
 449             }
 450             $bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
 451             $is_first = false;
 452             $char += (int) ($idx / ($deco_len + 1));
 453             $idx %= ($deco_len + 1);
 454             if ($deco_len > 0) {
 455                 // Make room for the decoded char
 456                 for ($i = $deco_len; $i > $idx; $i--) {
 457                     $decoded[$i] = $decoded[($i - 1)];
 458                 }
 459             }
 460             $decoded[$idx++] = $char;
 461         }
 462         return $this->_ucs4_to_utf8($decoded);
 463     }
 464
 465     /**
 466      * The actual encoding algorithm
 467      * @param  string
 468      * @return mixed
 469      */
 470     protected function _encode($decoded)
 471     {
 472         // We cannot encode a domain name containing the Punycode prefix
 473         $extract = self::byteLength($this->_punycode_prefix);
 474         $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
 475         $check_deco = array_slice($decoded, 0, $extract);
 476
 477         if ($check_pref == $check_deco) {
 478             $this->_error('This is already a punycode string');
 479             return false;
 480         }
 481         // We will not try to encode strings consisting of basic code points only
 482         $encodable = false;
 483         foreach ($decoded as $k => $v) {
 484             if ($v > 0x7a) {
 485                 $encodable = true;
 486                 break;
 487             }
 488         }
 489         if (!$encodable) {
 490             $this->_error('The given string does not contain encodable chars');
 491             return false;
 492         }
 493         // Do NAMEPREP
 494         $decoded = $this->_nameprep($decoded);
 495         if (!$decoded || !is_array($decoded)) {
 496             return false; // NAMEPREP failed
 497         }
 498         $deco_len = count($decoded);
 499         if (!$deco_len) {
 500             return false; // Empty array
 501         }
 502         $codecount = 0; // How many chars have been consumed
 503         $encoded = '';
 504         // Copy all basic code points to output
 505         for ($i = 0; $i < $deco_len; ++$i) {
 506             $test = $decoded[$i];
 507             // Will match [-0-9a-zA-Z]
 508             if ((0x2F < $test && $test < 0x40) || (0x40 < $test && $test < 0x5B) || (0x60 < $test && $test <= 0x7B) || (0x2D == $test)) {
 509                 $encoded .= chr($decoded[$i]);
 510                 $codecount++;
 511             }
 512         }
 513         if ($codecount == $deco_len) {
 514             return $encoded; // All codepoints were basic ones
 515         }
 516         // Start with the prefix; copy it to output
 517         $encoded = $this->_punycode_prefix . $encoded;
 518         // If we have basic code points in output, add an hyphen to the end
 519         if ($codecount) {
 520             $encoded .= '-';
 521         }
 522         // Now find and encode all non-basic code points
 523         $is_first = true;
 524         $cur_code = $this->_initial_n;
 525         $bias = $this->_initial_bias;
 526         $delta = 0;
 527         while ($codecount < $deco_len) {
 528             // Find the smallest code point >= the current code point and
 529             // remember the last ouccrence of it in the input
 530             for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
 531                 if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
 532                     $next_code = $decoded[$i];
 533                 }
 534             }
 535             $delta += ($next_code - $cur_code) * ($codecount + 1);
 536             $cur_code = $next_code;
 537
 538             // Scan input again and encode all characters whose code point is $cur_code
 539             for ($i = 0; $i < $deco_len; $i++) {
 540                 if ($decoded[$i] < $cur_code) {
 541                     $delta++;
 542                 } elseif ($decoded[$i] == $cur_code) {
 543                     for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
 544                         $t = ($k <= $bias) ? $this->_tmin :
 545                                 (($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
 546                         if ($q < $t) {
 547                             break;
 548                         }
 549                         $encoded .= $this->_encode_digit(intval($t + (($q - $t) % ($this->_base - $t)))); //v0.4.5 Changed from ceil() to intval()
 550                         $q = (int) (($q - $t) / ($this->_base - $t));
 551                     }
 552                     $encoded .= $this->_encode_digit($q);
 553                     $bias = $this->_adapt($delta, $codecount + 1, $is_first);
 554                     $codecount++;
 555                     $delta = 0;
 556                     $is_first = false;
 557                 }
 558             }
 559             $delta++;
 560             $cur_code++;
 561         }
 562         return $encoded;
 563     }
 564
 565     /**
 566      * Adapt the bias according to the current code point and position
 567      * @param int $delta
 568      * @param int $npoints
 569      * @param int $is_first
 570      * @return int
 571      */
 572     protected function _adapt($delta, $npoints, $is_first)
 573     {
 574         $delta = intval($is_first ? ($delta / $this->_damp) : ($delta / 2));
 575         $delta += intval($delta / $npoints);
 576         for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
 577             $delta = intval($delta / ($this->_base - $this->_tmin));
 578         }
 579         return intval($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
 580     }
 581
 582     /**
 583      * Encoding a certain digit
 584      * @param    int $d
 585      * @return string
 586      */
 587     protected function _encode_digit($d)
 588     {
 589         return chr($d + 22 + 75 * ($d < 26));
 590     }
 591
 592     /**
 593      * Decode a certain digit
 594      * @param    int $cp
 595      * @return int
 596      */
 597     protected function _decode_digit($cp)
 598     {
 599         $cp = ord($cp);
 600         return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
 601     }
 602
 603     /**
 604      * Internal error handling method
 605      * @param  string $error
 606      */
 607     protected function _error($error = '')
 608     {
 609         $this->_error = $error;
 610     }
 611
 612     /**
 613      * Do Nameprep according to RFC3491 and RFC3454
 614      * @param    array    Unicode Characters
 615      * @return   string   Unicode Characters, Nameprep'd
 616      */
 617     protected function _nameprep($input)
 618     {
 619         $output = array();
 620         //
 621         // Mapping
 622         // Walking through the input array, performing the required steps on each of
 623         // the input chars and putting the result into the output array
 624         // While mapping required chars we apply the cannonical ordering
 625         foreach ($input as $v) {
 626             // Map to nothing == skip that code point
 627             if (in_array($v, self::$NP['map_nothing'])) {
 628                 continue;
 629             }
 630             // Try to find prohibited input
 631             if (in_array($v, self::$NP['prohibit']) || in_array($v, self::$NP['general_prohibited'])) {
 632                 $this->_error('NAMEPREP: Prohibited input U+' . sprintf('%08X', $v));
 633                 return false;
 634             }
 635             foreach (self::$NP['prohibit_ranges'] as $range) {
 636                 if ($range[0] <= $v && $v <= $range[1]) {
 637                     $this->_error('NAMEPREP: Prohibited input U+' . sprintf('%08X', $v));
 638                     return false;
 639                 }
 640             }
 641
 642             if (0xAC00 <= $v && $v <= 0xD7AF) {
 643                 // Hangul syllable decomposition
 644                 foreach ($this->_hangul_decompose($v) as $out) {
 645                     $output[] = (int) $out;
 646                 }
 647             } elseif (($this->_idn_version == '2003') && isset(self::$NP['replacemaps_2003'][$v])) {
 648                 foreach ($this->_apply_cannonical_ordering(self::$NP['replacemaps_2003'][$v]) as $out) {
 649                     $output[] = (int) $out;
 650                 }
 651             } elseif (($this->_idn_version == '2008') && isset(self::$NP['replacemaps'][$v])) {
 652                 foreach ($this->_apply_cannonical_ordering(self::$NP['replacemaps'][$v]) as $out) {
 653                     $output[] = (int) $out;
 654                 }
 655             } else {
 656                 $output[] = (int) $v;
 657             }
 658         }
 659         // Before applying any Combining, try to rearrange any Hangul syllables
 660         $output = $this->_hangul_compose($output);
 661         //
 662         // Combine code points
 663         //
 664         $last_class = 0;
 665         $last_starter = 0;
 666         $out_len = count($output);
 667         for ($i = 0; $i < $out_len; ++$i) {
 668             $class = $this->_get_combining_class($output[$i]);
 669             if ((!$last_class || $last_class > $class) && $class) {
 670                 // Try to match
 671                 $seq_len = $i - $last_starter;
 672                 $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
 673                 // On match: Replace the last starter with the composed character and remove
 674                 // the now redundant non-starter(s)
 675                 if ($out) {
 676                     $output[$last_starter] = $out;
 677                     if (count($out) != $seq_len) {
 678                         for ($j = $i + 1; $j < $out_len; ++$j) {
 679                             $output[$j - 1] = $output[$j];
 680                         }
 681                         unset($output[$out_len]);
 682                     }
 683                     // Rewind the for loop by one, since there can be more possible compositions
 684                     $i--;
 685                     $out_len--;
 686                     $last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i - 1]);
 687                     continue;
 688                 }
 689             }
 690             // The current class is 0
 691             if (!$class) {
 692                 $last_starter = $i;
 693             }
 694             $last_class = $class;
 695         }
 696         return $output;
 697     }
 698
 699     /**
 700      * Decomposes a Hangul syllable
 701      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
 702      * @param    integer  32bit UCS4 code point
 703      * @return   array    Either Hangul Syllable decomposed or original 32bit value as one value array
 704      */
 705     protected function _hangul_decompose($char)
 706     {
 707         $sindex = (int) $char - $this->_sbase;
 708         if ($sindex < 0 || $sindex >= $this->_scount) {
 709             return array($char);
 710         }
 711         $result = array();
 712         $result[] = (int) $this->_lbase + $sindex / $this->_ncount;
 713         $result[] = (int) $this->_vbase + ($sindex % $this->_ncount) / $this->_tcount;
 714         $T = intval($this->_tbase + $sindex % $this->_tcount);
 715         if ($T != $this->_tbase) {
 716             $result[] = $T;
 717         }
 718         return $result;
 719     }
 720
 721     /**
 722      * Ccomposes a Hangul syllable
 723      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
 724      * @param    array    Decomposed UCS4 sequence
 725      * @return   array    UCS4 sequence with syllables composed
 726      */
 727     protected function _hangul_compose($input)
 728     {
 729         $inp_len = count($input);
 730         if (!$inp_len) {
 731             return array();
 732         }
 733         $result = array();
 734         $last = (int) $input[0];
 735         $result[] = $last; // copy first char from input to output
 736
 737         for ($i = 1; $i < $inp_len; ++$i) {
 738             $char = (int) $input[$i];
 739             $sindex = $last - $this->_sbase;
 740             $lindex = $last - $this->_lbase;
 741             $vindex = $char - $this->_vbase;
 742             $tindex = $char - $this->_tbase;
 743             // Find out, whether two current characters are LV and T
 744             if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount == 0) && 0 <= $tindex && $tindex <= $this->_tcount) {
 745                 // create syllable of form LVT
 746                 $last += $tindex;
 747                 $result[(count($result) - 1)] = $last; // reset last
 748                 continue; // discard char
 749             }
 750             // Find out, whether two current characters form L and V
 751             if (0 <= $lindex && $lindex < $this->_lcount && 0 <= $vindex && $vindex < $this->_vcount) {
 752                 // create syllable of form LV
 753                 $last = (int) $this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount;
 754                 $result[(count($result) - 1)] = $last; // reset last
 755                 continue; // discard char
 756             }
 757             // if neither case was true, just add the character
 758             $last = $char;
 759             $result[] = $char;
 760         }
 761         return $result;
 762     }
 763
 764     /**
 765      * Returns the combining class of a certain wide char
 766      * @param    integer    Wide char to check (32bit integer)
 767      * @return   integer    Combining class if found, else 0
 768      */
 769     protected function _get_combining_class($char)
 770     {
 771         return isset(self::$NP['norm_combcls'][$char]) ? self::$NP['norm_combcls'][$char] : 0;
 772     }
 773
 774     /**
 775      * Applies the cannonical ordering of a decomposed UCS4 sequence
 776      * @param    array      Decomposed UCS4 sequence
 777      * @return   array      Ordered USC4 sequence
 778      */
 779     protected function _apply_cannonical_ordering($input)
 780     {
 781         $swap = true;
 782         $size = count($input);
 783         while ($swap) {
 784             $swap = false;
 785             $last = $this->_get_combining_class(intval($input[0]));
 786             for ($i = 0; $i < $size - 1; ++$i) {
 787                 $next = $this->_get_combining_class(intval($input[$i + 1]));
 788                 if ($next != 0 && $last > $next) {
 789                     // Move item leftward until it fits
 790                     for ($j = $i + 1; $j > 0; --$j) {
 791                         if ($this->_get_combining_class(intval($input[$j - 1])) <= $next) {
 792                             break;
 793                         }
 794                         $t = intval($input[$j]);
 795                         $input[$j] = intval($input[$j - 1]);
 796                         $input[$j - 1] = $t;
 797                         $swap = true;
 798                     }
 799                     // Reentering the loop looking at the old character again
 800                     $next = $last;
 801                 }
 802                 $last = $next;
 803             }
 804         }
 805         return $input;
 806     }
 807
 808     /**
 809      * Do composition of a sequence of starter and non-starter
 810      * @param    array      UCS4 Decomposed sequence
 811      * @return   array      Ordered USC4 sequence
 812      */
 813     protected function _combine($input)
 814     {
 815         $inp_len = count($input);
 816         if (0 == $inp_len) {
 817             return false;
 818         }
 819         foreach (self::$NP['replacemaps'] as $np_src => $np_target) {
 820             if ($np_target[0] != $input[0]) {
 821                 continue;
 822             }
 823             if (count($np_target) != $inp_len) {
 824                 continue;
 825             }
 826             $hit = false;
 827             foreach ($input as $k2 => $v2) {
 828                 if ($v2 == $np_target[$k2]) {
 829                     $hit = true;
 830                 } else {
 831                     $hit = false;
 832                     break;
 833                 }
 834             }
 835             if ($hit) {
 836                 return $np_src;
 837             }
 838         }
 839         return false;
 840     }
 841
 842     /**
 843      * This converts an UTF-8 encoded string to its UCS-4 representation
 844      * By talking about UCS-4 "strings" we mean arrays of 32bit integers representing
 845      * each of the "chars". This is due to PHP not being able to handle strings with
 846      * bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too.
 847      * The following UTF-8 encodings are supported:
 848      * bytes bits  representation
 849      * 1        7  0xxxxxxx
 850      * 2       11  110xxxxx 10xxxxxx
 851      * 3       16  1110xxxx 10xxxxxx 10xxxxxx
 852      * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 853      * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
 854      * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
 855      * Each x represents a bit that can be used to store character data.
 856      * The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000
 857      * @param string $input
 858      * @return string
 859      */
 860     protected function _utf8_to_ucs4($input)
 861     {
 862         $output = array();
 863         $out_len = 0;
 864         $inp_len = self::byteLength($input);
 865         $mode = 'next';
 866         $test = 'none';
 867         for ($k = 0; $k < $inp_len; ++$k) {
 868             $v = ord($input{$k}); // Extract byte from input string
 869             if ($v < 128) { // We found an ASCII char - put into stirng as is
 870                 $output[$out_len] = $v;
 871                 ++$out_len;
 872                 if ('add' == $mode) {
 873                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte ' . $k);
 874                     return false;
 875                 }
 876                 continue;
 877             }
 878             if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
 879                 $start_byte = $v;
 880                 $mode = 'add';
 881                 $test = 'range';
 882                 if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
 883                     $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
 884                     $v = ($v - 192) << 6;
 885                 } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
 886                     $next_byte = 1;
 887                     $v = ($v - 224) << 12;
 888                 } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 889                     $next_byte = 2;
 890                     $v = ($v - 240) << 18;
 891                 } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
 892                     $next_byte = 3;
 893                     $v = ($v - 248) << 24;
 894                 } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
 895                     $next_byte = 4;
 896                     $v = ($v - 252) << 30;
 897                 } else {
 898                     $this->_error('This might be UTF-8, but I don\'t understand it at byte ' . $k);
 899                     return false;
 900                 }
 901                 if ('add' == $mode) {
 902                     $output[$out_len] = (int) $v;
 903                     ++$out_len;
 904                     continue;
 905                 }
 906             }
 907             if ('add' == $mode) {
 908                 if (!$this->_allow_overlong && $test == 'range') {
 909                     $test = 'none';
 910                     if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
 911                         $this->_error('Bogus UTF-8 character detected (out of legal range) at byte ' . $k);
 912                         return false;
 913                     }
 914                 }
 915                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
 916                     $v = ($v - 128) << ($next_byte * 6);
 917                     $output[($out_len - 1)] += $v;
 918                     --$next_byte;
 919                 } else {
 920                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte ' . $k);
 921                     return false;
 922                 }
 923                 if ($next_byte < 0) {
 924                     $mode = 'next';
 925                 }
 926             }
 927         } // for
 928         return $output;
 929     }
 930
 931     /**
 932      * Convert UCS-4 string into UTF-8 string
 933      * See _utf8_to_ucs4() for details
 934      * @param string  $input
 935      * @return string
 936      */
 937     protected function _ucs4_to_utf8($input)
 938     {
 939         $output = '';
 940         foreach ($input as $k => $v) {
 941             if ($v < 128) { // 7bit are transferred literally
 942                 $output .= chr($v);
 943             } elseif ($v < (1 << 11)) { // 2 bytes
 944                 $output .= chr(192 + ($v >> 6)) . chr(128 + ($v & 63));
 945             } elseif ($v < (1 << 16)) { // 3 bytes
 946                 $output .= chr(224 + ($v >> 12)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
 947             } elseif ($v < (1 << 21)) { // 4 bytes
 948                 $output .= chr(240 + ($v >> 18)) . chr(128 + (($v >> 12) & 63)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
 949             } else {
 950                 $this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte ' . $k);
 951                 return false;
 952             }
 953         }
 954         return $output;
 955     }
 956
 957     /**
 958      * Convert UCS-4 array into UCS-4 string
 959      *
 960      * @param array $input
 961      * @return string
 962      */
 963     protected function _ucs4_to_ucs4_string($input)
 964     {
 965         $output = '';
 966         // Take array values and split output to 4 bytes per value
 967         // The bit mask is 255, which reads &11111111
 968         foreach ($input as $v) {
 969             $output .= chr(($v >> 24) & 255) . chr(($v >> 16) & 255) . chr(($v >> 8) & 255) . chr($v & 255);
 970         }
 971         return $output;
 972     }
 973
 974     /**
 975      * Convert UCS-4 strin into UCS-4 garray
 976      *
 977      * @param  string $input
 978      * @return array
 979      */
 980     protected function _ucs4_string_to_ucs4($input)
 981     {
 982         $output = array();
 983         $inp_len = self::byteLength($input);
 984         // Input length must be dividable by 4
 985         if ($inp_len % 4) {
 986             $this->_error('Input UCS4 string is broken');
 987             return false;
 988         }
 989         // Empty input - return empty output
 990         if (!$inp_len) {
 991             return $output;
 992         }
 993         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
 994             // Increment output position every 4 input bytes
 995             if (!($i % 4)) {
 996                 $out_len++;
 997                 $output[$out_len] = 0;
 998             }
 999             $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
1000         }
1001         return $output;
1002     }
1003
1004     /**
1005      * Gets the length of a string in bytes even if mbstring function
1006      * overloading is turned on
1007      *
1008      * @param string $string the string for which to get the length.
1009      * @return integer the length of the string in bytes.
1010      */
1011     protected static function byteLength($string)
1012     {
1013         if (self::$_mb_string_overload) {
1014             return mb_strlen($string, '8bit');
1015         }
1016         return strlen((binary) $string);
1017     }
1018
1019     /**
1020      * Attempts to return a concrete IDNA instance.
1021      *
1022      * @param array $params Set of paramaters
1023      * @return idna_convert
1024      * @access public
1025      */
1026     public function getInstance($params = array())
1027     {
1028         return new idna_convert($params);
1029     }
1030
1031     /**
1032      * Attempts to return a concrete IDNA instance for either php4 or php5,
1033      * only creating a new instance if no IDNA instance with the same
1034      * parameters currently exists.
1035      *
1036      * @param array $params Set of paramaters
1037      *
1038      * @return object idna_convert
1039      * @access public
1040      */
1041     public function singleton($params = array())
1042     {
1043         static $instances = array();
1044
1045         $signature = serialize($params);
1046         if (!isset($instances[$signature])) {
1047             $instances[$signature] = idna_convert::getInstance($params);
1048         }
1049         return $instances[$signature];
1050     }
1051
1052     /**
1053      * Holds all relevant mapping tables
1054      * See RFC3454 for details
1055      *
1056      * @private array
1057      * @since 0.5.2
1058      */
1059     protected static $NP = array(
1060             'map_nothing' => array(0xAD, 0x34F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B, 0x200C,
1061                     0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07,
1062                     0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF
1063             ),
1064             'general_prohibited' => array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1065                     20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1066                     43, 44, 47, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94, 95, 96, 123, 124, 125, 126, 127, 0x3002
1067             ),
1068             'prohibit' => array(0xA0, 0x340, 0x341, 0x6DD, 0x70F, 0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003,
1069                     0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x200C, 0x200D, 0x200E, 0x200F,
1070                     0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E, 0x202F, 0x205F, 0x206A, 0x206B, 0x206C,
1071                     0x206D, 0x206E, 0x206F, 0x3000, 0x33C2, 0xFEFF, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
1072                     0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE,
1073                     0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, 0xBFFFF,
1074                     0xCFFFE, 0xCFFFF, 0xDFFFE, 0xDFFFF, 0xE0001, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, 0x10FFFF
1075             ),
1076             'prohibit_ranges' => array(array(0x80, 0x9F), array(0x2060, 0x206F), array(0x1D173, 0x1D17A),
1077                     array(0xE000, 0xF8FF), array(0xF0000, 0xFFFFD), array(0x100000, 0x10FFFD),
1078                     array(0xFDD0, 0xFDEF), array(0xD800, 0xDFFF), array(0x2FF0, 0x2FFB), array(0xE0020, 0xE007F)
1079             ),
1080             'replacemaps_2003' => array(0x41 => array(0x61), 0x42 => array(0x62), 0x43 => array(0x63),
1081                     0x44 => array(0x64), 0x45 => array(0x65), 0x46 => array(0x66), 0x47 => array(0x67),
1082                     0x48 => array(0x68), 0x49 => array(0x69), 0x4A => array(0x6A), 0x4B => array(0x6B),
1083                     0x4C => array(0x6C), 0x4D => array(0x6D), 0x4E => array(0x6E), 0x4F => array(0x6F),
1084                     0x50 => array(0x70), 0x51 => array(0x71), 0x52 => array(0x72), 0x53 => array(0x73),
1085                     0x54 => array(0x74), 0x55 => array(0x75), 0x56 => array(0x76), 0x57 => array(0x77),
1086                     0x58 => array(0x78), 0x59 => array(0x79), 0x5A => array(0x7A), 0xB5 => array(0x3BC),
1087                     0xC0 => array(0xE0), 0xC1 => array(0xE1), 0xC2 => array(0xE2), 0xC3 => array(0xE3),
1088                     0xC4 => array(0xE4), 0xC5 => array(0xE5), 0xC6 => array(0xE6), 0xC7 => array(0xE7),
1089                     0xC8 => array(0xE8), 0xC9 => array(0xE9), 0xCA => array(0xEA), 0xCB => array(0xEB),
1090                     0xCC => array(0xEC), 0xCD => array(0xED), 0xCE => array(0xEE), 0xCF => array(0xEF),
1091                     0xD0 => array(0xF0), 0xD1 => array(0xF1), 0xD2 => array(0xF2), 0xD3 => array(0xF3),
1092                     0xD4 => array(0xF4), 0xD5 => array(0xF5), 0xD6 => array(0xF6), 0xD8 => array(0xF8),
1093                     0xD9 => array(0xF9), 0xDA => array(0xFA), 0xDB => array(0xFB), 0xDC => array(0xFC),
1094                     0xDD => array(0xFD), 0xDE => array(0xFE), 0xDF => array(0x73, 0x73),
1095                     0x100 => array(0x101), 0x102 => array(0x103), 0x104 => array(0x105),
1096                     0x106 => array(0x107), 0x108 => array(0x109), 0x10A => array(0x10B),
1097                     0x10C => array(0x10D), 0x10E => array(0x10F), 0x110 => array(0x111),
1098                     0x112 => array(0x113), 0x114 => array(0x115), 0x116 => array(0x117),
1099                     0x118 => array(0x119), 0x11A => array(0x11B), 0x11C => array(0x11D),
1100                     0x11E => array(0x11F), 0x120 => array(0x121), 0x122 => array(0x123),
1101                     0x124 => array(0x125), 0x126 => array(0x127), 0x128 => array(0x129),
1102                     0x12A => array(0x12B), 0x12C => array(0x12D), 0x12E => array(0x12F),
1103                     0x130 => array(0x69, 0x307), 0x132 => array(0x133), 0x134 => array(0x135),
1104                     0x136 => array(0x137), 0x139 => array(0x13A), 0x13B => array(0x13C),
1105                     0x13D => array(0x13E), 0x13F => array(0x140), 0x141 => array(0x142),
1106                     0x143 => array(0x144), 0x145 => array(0x146), 0x147 => array(0x148),
1107                     0x149 => array(0x2BC, 0x6E), 0x14A => array(0x14B), 0x14C => array(0x14D),
1108                     0x14E => array(0x14F), 0x150 => array(0x151), 0x152 => array(0x153),
1109                     0x154 => array(0x155), 0x156 => array(0x157), 0x158 => array(0x159),
1110                     0x15A => array(0x15B), 0x15C => array(0x15D), 0x15E => array(0x15F),
1111                     0x160 => array(0x161), 0x162 => array(0x163), 0x164 => array(0x165),
1112                     0x166 => array(0x167), 0x168 => array(0x169), 0x16A => array(0x16B),
1113                     0x16C => array(0x16D), 0x16E => array(0x16F), 0x170 => array(0x171),
1114                     0x172 => array(0x173), 0x174 => array(0x175), 0x176 => array(0x177),
1115                     0x178 => array(0xFF), 0x179 => array(0x17A), 0x17B => array(0x17C),
1116                     0x17D => array(0x17E), 0x17F => array(0x73), 0x181 => array(0x253),
1117                     0x182 => array(0x183), 0x184 => array(0x185), 0x186 => array(0x254),
1118                     0x187 => array(0x188), 0x189 => array(0x256), 0x18A => array(0x257),
1119                     0x18B => array(0x18C), 0x18E => array(0x1DD), 0x18F => array(0x259),
1120                     0x190 => array(0x25B), 0x191 => array(0x192), 0x193 => array(0x260),
1121                     0x194 => array(0x263), 0x196 => array(0x269), 0x197 => array(0x268),
1122                     0x198 => array(0x199), 0x19C => array(0x26F), 0x19D => array(0x272),
1123                     0x19F => array(0x275), 0x1A0 => array(0x1A1), 0x1A2 => array(0x1A3),
1124                     0x1A4 => array(0x1A5), 0x1A6 => array(0x280), 0x1A7 => array(0x1A8),
1125                     0x1A9 => array(0x283), 0x1AC => array(0x1AD), 0x1AE => array(0x288),
1126                     0x1AF => array(0x1B0), 0x1B1 => array(0x28A), 0x1B2 => array(0x28B),
1127                     0x1B3 => array(0x1B4), 0x1B5 => array(0x1B6), 0x1B7 => array(0x292),
1128                     0x1B8 => array(0x1B9), 0x1BC => array(0x1BD), 0x1C4 => array(0x1C6),
1129                     0x1C5 => array(0x1C6), 0x1C7 => array(0x1C9), 0x1C8 => array(0x1C9),
1130                     0x1CA => array(0x1CC), 0x1CB => array(0x1CC), 0x1CD => array(0x1CE),
1131                     0x1CF => array(0x1D0), 0x1D1 => array(0x1D2), 0x1D3 => array(0x1D4),
1132                     0x1D5 => array(0x1D6), 0x1D7 => array(0x1D8), 0x1D9 => array(0x1DA),
1133                     0x1DB => array(0x1DC), 0x1DE => array(0x1DF), 0x1E0 => array(0x1E1),
1134                     0x1E2 => array(0x1E3), 0x1E4 => array(0x1E5), 0x1E6 => array(0x1E7),
1135                     0x1E8 => array(0x1E9), 0x1EA => array(0x1EB), 0x1EC => array(0x1ED),
1136                     0x1EE => array(0x1EF), 0x1F0 => array(0x6A, 0x30C), 0x1F1 => array(0x1F3),
1137                     0x1F2 => array(0x1F3), 0x1F4 => array(0x1F5), 0x1F6 => array(0x195),
1138                     0x1F7 => array(0x1BF), 0x1F8 => array(0x1F9), 0x1FA => array(0x1FB),
1139                     0x1FC => array(0x1FD), 0x1FE => array(0x1FF), 0x200 => array(0x201),
1140                     0x202 => array(0x203), 0x204 => array(0x205), 0x206 => array(0x207),
1141                     0x208 => array(0x209), 0x20A => array(0x20B), 0x20C => array(0x20D),
1142                     0x20E => array(0x20F), 0x210 => array(0x211), 0x212 => array(0x213),
1143                     0x214 => array(0x215), 0x216 => array(0x217), 0x218 => array(0x219),
1144                     0x21A => array(0x21B), 0x21C => array(0x21D), 0x21E => array(0x21F),
1145                     0x220 => array(0x19E), 0x222 => array(0x223), 0x224 => array(0x225),
1146                     0x226 => array(0x227), 0x228 => array(0x229), 0x22A => array(0x22B),
1147                     0x22C => array(0x22D), 0x22E => array(0x22F), 0x230 => array(0x231),
1148                     0x232 => array(0x233), 0x345 => array(0x3B9), 0x37A => array(0x20, 0x3B9),
1149                     0x386 => array(0x3AC), 0x388 => array(0x3AD), 0x389 => array(0x3AE),
1150                     0x38A => array(0x3AF), 0x38C => array(0x3CC), 0x38E => array(0x3CD),
1151                     0x38F => array(0x3CE), 0x390 => array(0x3B9, 0x308, 0x301),
1152                     0x391 => array(0x3B1), 0x392 => array(0x3B2), 0x393 => array(0x3B3),
1153                     0x394 => array(0x3B4), 0x395 => array(0x3B5), 0x396 => array(0x3B6),
1154                     0x397 => array(0x3B7), 0x398 => array(0x3B8), 0x399 => array(0x3B9),
1155                     0x39A => array(0x3BA), 0x39B => array(0x3BB), 0x39C => array(0x3BC),
1156                     0x39D => array(0x3BD), 0x39E => array(0x3BE), 0x39F => array(0x3BF),
1157                     0x3A0 => array(0x3C0), 0x3A1 => array(0x3C1), 0x3A3 => array(0x3C3),
1158                     0x3A4 => array(0x3C4), 0x3A5 => array(0x3C5), 0x3A6 => array(0x3C6),
1159                     0x3A7 => array(0x3C7), 0x3A8 => array(0x3C8), 0x3A9 => array(0x3C9),
1160                     0x3AA => array(0x3CA), 0x3AB => array(0x3CB), 0x3B0 => array(0x3C5, 0x308, 0x301),
1161                     0x3C2 => array(0x3C3), 0x3D0 => array(0x3B2), 0x3D1 => array(0x3B8),
1162                     0x3D2 => array(0x3C5), 0x3D3 => array(0x3CD), 0x3D4 => array(0x3CB),
1163                     0x3D5 => array(0x3C6), 0x3D6 => array(0x3C0), 0x3D8 => array(0x3D9),
1164                     0x3DA => array(0x3DB), 0x3DC => array(0x3DD), 0x3DE => array(0x3DF),
1165                     0x3E0 => array(0x3E1), 0x3E2 => array(0x3E3), 0x3E4 => array(0x3E5),
1166                     0x3E6 => array(0x3E7), 0x3E8 => array(0x3E9), 0x3EA => array(0x3EB),
1167                     0x3EC => array(0x3ED), 0x3EE => array(0x3EF), 0x3F0 => array(0x3BA),
1168                     0x3F1 => array(0x3C1), 0x3F2 => array(0x3C3), 0x3F4 => array(0x3B8),
1169                     0x3F5 => array(0x3B5), 0x400 => array(0x450), 0x401 => array(0x451),
1170                     0x402 => array(0x452), 0x403 => array(0x453), 0x404 => array(0x454),
1171                     0x405 => array(0x455), 0x406 => array(0x456), 0x407 => array(0x457),
1172                     0x408 => array(0x458), 0x409 => array(0x459), 0x40A => array(0x45A),
1173                     0x40B => array(0x45B), 0x40C => array(0x45C), 0x40D => array(0x45D),
1174                     0x40E => array(0x45E), 0x40F => array(0x45F), 0x410 => array(0x430),
1175                     0x411 => array(0x431), 0x412 => array(0x432), 0x413 => array(0x433),
1176                     0x414 => array(0x434), 0x415 => array(0x435), 0x416 => array(0x436),
1177                     0x417 => array(0x437), 0x418 => array(0x438), 0x419 => array(0x439),
1178                     0x41A => array(0x43A), 0x41B => array(0x43B), 0x41C => array(0x43C),
1179                     0x41D => array(0x43D), 0x41E => array(0x43E), 0x41F => array(0x43F),
1180                     0x420 => array(0x440), 0x421 => array(0x441), 0x422 => array(0x442),
1181                     0x423 => array(0x443), 0x424 => array(0x444), 0x425 => array(0x445),
1182                     0x426 => array(0x446), 0x427 => array(0x447), 0x428 => array(0x448),
1183                     0x429 => array(0x449), 0x42A => array(0x44A), 0x42B => array(0x44B),
1184                     0x42C => array(0x44C), 0x42D => array(0x44D), 0x42E => array(0x44E),
1185                     0x42F => array(0x44F), 0x460 => array(0x461), 0x462 => array(0x463),
1186                     0x464 => array(0x465), 0x466 => array(0x467), 0x468 => array(0x469),
1187                     0x46A => array(0x46B), 0x46C => array(0x46D), 0x46E => array(0x46F),
1188                     0x470 => array(0x471), 0x472 => array(0x473), 0x474 => array(0x475),
1189                     0x476 => array(0x477), 0x478 => array(0x479), 0x47A => array(0x47B),
1190                     0x47C => array(0x47D), 0x47E => array(0x47F), 0x480 => array(0x481),
1191                     0x48A => array(0x48B), 0x48C => array(0x48D), 0x48E => array(0x48F),
1192                     0x490 => array(0x491), 0x492 => array(0x493), 0x494 => array(0x495),
1193                     0x496 => array(0x497), 0x498 => array(0x499), 0x49A => array(0x49B),
1194                     0x49C => array(0x49D), 0x49E => array(0x49F), 0x4A0 => array(0x4A1),
1195                     0x4A2 => array(0x4A3), 0x4A4 => array(0x4A5), 0x4A6 => array(0x4A7),
1196                     0x4A8 => array(0x4A9), 0x4AA => array(0x4AB), 0x4AC => array(0x4AD),
1197                     0x4AE => array(0x4AF), 0x4B0 => array(0x4B1), 0x4B2 => array(0x4B3),
1198                     0x4B4 => array(0x4B5), 0x4B6 => array(0x4B7), 0x4B8 => array(0x4B9),
1199                     0x4BA => array(0x4BB), 0x4BC => array(0x4BD), 0x4BE => array(0x4BF),
1200                     0x4C1 => array(0x4C2), 0x4C3 => array(0x4C4), 0x4C5 => array(0x4C6),
1201                     0x4C7 => array(0x4C8), 0x4C9 => array(0x4CA), 0x4CB => array(0x4CC),
1202                     0x4CD => array(0x4CE), 0x4D0 => array(0x4D1), 0x4D2 => array(0x4D3),
1203                     0x4D4 => array(0x4D5), 0x4D6 => array(0x4D7), 0x4D8 => array(0x4D9),
1204                     0x4DA => array(0x4DB), 0x4DC => array(0x4DD), 0x4DE => array(0x4DF),
1205                     0x4E0 => array(0x4E1), 0x4E2 => array(0x4E3), 0x4E4 => array(0x4E5),
1206                     0x4E6 => array(0x4E7), 0x4E8 => array(0x4E9), 0x4EA => array(0x4EB),
1207                     0x4EC => array(0x4ED), 0x4EE => array(0x4EF), 0x4F0 => array(0x4F1),
1208                     0x4F2 => array(0x4F3), 0x4F4 => array(0x4F5), 0x4F8 => array(0x4F9),
1209                     0x500 => array(0x501), 0x502 => array(0x503), 0x504 => array(0x505),
1210                     0x506 => array(0x507), 0x508 => array(0x509), 0x50A => array(0x50B),
1211                     0x50C => array(0x50D), 0x50E => array(0x50F), 0x531 => array(0x561),
1212                     0x532 => array(0x562), 0x533 => array(0x563), 0x534 => array(0x564),
1213                     0x535 => array(0x565), 0x536 => array(0x566), 0x537 => array(0x567),
1214                     0x538 => array(0x568), 0x539 => array(0x569), 0x53A => array(0x56A),
1215                     0x53B => array(0x56B), 0x53C => array(0x56C), 0x53D => array(0x56D),
1216                     0x53E => array(0x56E), 0x53F => array(0x56F), 0x540 => array(0x570),
1217                     0x541 => array(0x571), 0x542 => array(0x572), 0x543 => array(0x573),
1218                     0x544 => array(0x574), 0x545 => array(0x575), 0x546 => array(0x576),
1219                     0x547 => array(0x577), 0x548 => array(0x578), 0x549 => array(0x579),
1220                     0x54A => array(0x57A), 0x54B => array(0x57B), 0x54C => array(0x57C),
1221                     0x54D => array(0x57D), 0x54E => array(0x57E), 0x54F => array(0x57F),
1222                     0x550 => array(0x580), 0x551 => array(0x581), 0x552 => array(0x582),
1223                     0x553 => array(0x583), 0x554 => array(0x584), 0x555 => array(0x585),
1224                     0x556 => array(0x586), 0x587 => array(0x565, 0x582), 0xE33 => array(0xE4D, 0xE32),
1225                     0x1E00 => array(0x1E01), 0x1E02 => array(0x1E03), 0x1E04 => array(0x1E05),
1226                     0x1E06 => array(0x1E07), 0x1E08 => array(0x1E09), 0x1E0A => array(0x1E0B),
1227                     0x1E0C => array(0x1E0D), 0x1E0E => array(0x1E0F), 0x1E10 => array(0x1E11),
1228                     0x1E12 => array(0x1E13), 0x1E14 => array(0x1E15), 0x1E16 => array(0x1E17),
1229                     0x1E18 => array(0x1E19), 0x1E1A => array(0x1E1B), 0x1E1C => array(0x1E1D),
1230                     0x1E1E => array(0x1E1F), 0x1E20 => array(0x1E21), 0x1E22 => array(0x1E23),
1231                     0x1E24 => array(0x1E25), 0x1E26 => array(0x1E27), 0x1E28 => array(0x1E29),
1232                     0x1E2A => array(0x1E2B), 0x1E2C => array(0x1E2D), 0x1E2E => array(0x1E2F),
1233                     0x1E30 => array(0x1E31), 0x1E32 => array(0x1E33), 0x1E34 => array(0x1E35),
1234                     0x1E36 => array(0x1E37), 0x1E38 => array(0x1E39), 0x1E3A => array(0x1E3B),
1235                     0x1E3C => array(0x1E3D), 0x1E3E => array(0x1E3F), 0x1E40 => array(0x1E41),
1236                     0x1E42 => array(0x1E43), 0x1E44 => array(0x1E45), 0x1E46 => array(0x1E47),
1237                     0x1E48 => array(0x1E49), 0x1E4A => array(0x1E4B), 0x1E4C => array(0x1E4D),
1238                     0x1E4E => array(0x1E4F), 0x1E50 => array(0x1E51), 0x1E52 => array(0x1E53),
1239                     0x1E54 => array(0x1E55), 0x1E56 => array(0x1E57), 0x1E58 => array(0x1E59),
1240                     0x1E5A => array(0x1E5B), 0x1E5C => array(0x1E5D), 0x1E5E => array(0x1E5F),
1241                     0x1E60 => array(0x1E61), 0x1E62 => array(0x1E63), 0x1E64 => array(0x1E65),
1242                     0x1E66 => array(0x1E67), 0x1E68 => array(0x1E69), 0x1E6A => array(0x1E6B),
1243                     0x1E6C => array(0x1E6D), 0x1E6E => array(0x1E6F), 0x1E70 => array(0x1E71),
1244                     0x1E72 => array(0x1E73), 0x1E74 => array(0x1E75), 0x1E76 => array(0x1E77),
1245                     0x1E78 => array(0x1E79), 0x1E7A => array(0x1E7B), 0x1E7C => array(0x1E7D),
1246                     0x1E7E => array(0x1E7F), 0x1E80 => array(0x1E81), 0x1E82 => array(0x1E83),
1247                     0x1E84 => array(0x1E85), 0x1E86 => array(0x1E87), 0x1E88 => array(0x1E89),
1248                     0x1E8A => array(0x1E8B), 0x1E8C => array(0x1E8D), 0x1E8E => array(0x1E8F),
1249                     0x1E90 => array(0x1E91), 0x1E92 => array(0x1E93), 0x1E94 => array(0x1E95),
1250                     0x1E96 => array(0x68, 0x331), 0x1E97 => array(0x74, 0x308), 0x1E98 => array(0x77, 0x30A),
1251                     0x1E99 => array(0x79, 0x30A), 0x1E9A => array(0x61, 0x2BE), 0x1E9B => array(0x1E61),
1252                     0x1EA0 => array(0x1EA1), 0x1EA2 => array(0x1EA3), 0x1EA4 => array(0x1EA5),
1253                     0x1EA6 => array(0x1EA7), 0x1EA8 => array(0x1EA9), 0x1EAA => array(0x1EAB),
1254                     0x1EAC => array(0x1EAD), 0x1EAE => array(0x1EAF), 0x1EB0 => array(0x1EB1),
1255                     0x1EB2 => array(0x1EB3), 0x1EB4 => array(0x1EB5), 0x1EB6 => array(0x1EB7),
1256                     0x1EB8 => array(0x1EB9), 0x1EBA => array(0x1EBB), 0x1EBC => array(0x1EBD),
1257                     0x1EBE => array(0x1EBF), 0x1EC0 => array(0x1EC1), 0x1EC2 => array(0x1EC3),
1258                     0x1EC4 => array(0x1EC5), 0x1EC6 => array(0x1EC7), 0x1EC8 => array(0x1EC9),
1259                     0x1ECA => array(0x1ECB), 0x1ECC => array(0x1ECD), 0x1ECE => array(0x1ECF),
1260                     0x1ED0 => array(0x1ED1), 0x1ED2 => array(0x1ED3), 0x1ED4 => array(0x1ED5),
1261                     0x1ED6 => array(0x1ED7), 0x1ED8 => array(0x1ED9), 0x1EDA => array(0x1EDB),
1262                     0x1EDC => array(0x1EDD), 0x1EDE => array(0x1EDF), 0x1EE0 => array(0x1EE1),
1263                     0x1EE2 => array(0x1EE3), 0x1EE4 => array(0x1EE5), 0x1EE6 => array(0x1EE7),
1264                     0x1EE8 => array(0x1EE9), 0x1EEA => array(0x1EEB), 0x1EEC => array(0x1EED),
1265                     0x1EEE => array(0x1EEF), 0x1EF0 => array(0x1EF1), 0x1EF2 => array(0x1EF3),
1266                     0x1EF4 => array(0x1EF5), 0x1EF6 => array(0x1EF7), 0x1EF8 => array(0x1EF9),
1267                     0x1F08 => array(0x1F00), 0x1F09 => array(0x1F01), 0x1F0A => array(0x1F02),
1268                     0x1F0B => array(0x1F03), 0x1F0C => array(0x1F04), 0x1F0D => array(0x1F05),
1269                     0x1F0E => array(0x1F06), 0x1F0F => array(0x1F07), 0x1F18 => array(0x1F10),
1270                     0x1F19 => array(0x1F11), 0x1F1A => array(0x1F12), 0x1F1B => array(0x1F13),
1271                     0x1F1C => array(0x1F14), 0x1F1D => array(0x1F15), 0x1F28 => array(0x1F20),
1272                     0x1F29 => array(0x1F21), 0x1F2A => array(0x1F22), 0x1F2B => array(0x1F23),
1273                     0x1F2C => array(0x1F24), 0x1F2D => array(0x1F25), 0x1F2E => array(0x1F26),
1274                     0x1F2F => array(0x1F27), 0x1F38 => array(0x1F30), 0x1F39 => array(0x1F31),
1275                     0x1F3A => array(0x1F32), 0x1F3B => array(0x1F33), 0x1F3C => array(0x1F34),
1276                     0x1F3D => array(0x1F35), 0x1F3E => array(0x1F36), 0x1F3F => array(0x1F37),
1277                     0x1F48 => array(0x1F40), 0x1F49 => array(0x1F41), 0x1F4A => array(0x1F42),
1278                     0x1F4B => array(0x1F43), 0x1F4C => array(0x1F44), 0x1F4D => array(0x1F45),
1279                     0x1F50 => array(0x3C5, 0x313), 0x1F52 => array(0x3C5, 0x313, 0x300),
1280                     0x1F54 => array(0x3C5, 0x313, 0x301), 0x1F56 => array(0x3C5, 0x313, 0x342),
1281                     0x1F59 => array(0x1F51), 0x1F5B => array(0x1F53), 0x1F5D => array(0x1F55),
1282                     0x1F5F => array(0x1F57), 0x1F68 => array(0x1F60), 0x1F69 => array(0x1F61),
1283                     0x1F6A => array(0x1F62), 0x1F6B => array(0x1F63), 0x1F6C => array(0x1F64),
1284                     0x1F6D => array(0x1F65), 0x1F6E => array(0x1F66), 0x1F6F => array(0x1F67),
1285                     0x1F80 => array(0x1F00, 0x3B9), 0x1F81 => array(0x1F01, 0x3B9),
1286                     0x1F82 => array(0x1F02, 0x3B9), 0x1F83 => array(0x1F03, 0x3B9),
1287                     0x1F84 => array(0x1F04, 0x3B9), 0x1F85 => array(0x1F05, 0x3B9),
1288                     0x1F86 => array(0x1F06, 0x3B9), 0x1F87 => array(0x1F07, 0x3B9),
1289                     0x1F88 => array(0x1F00, 0x3B9), 0x1F89 => array(0x1F01, 0x3B9),
1290                     0x1F8A => array(0x1F02, 0x3B9), 0x1F8B => array(0x1F03, 0x3B9),
1291                     0x1F8C => array(0x1F04, 0x3B9), 0x1F8D => array(0x1F05, 0x3B9),
1292                     0x1F8E => array(0x1F06, 0x3B9), 0x1F8F => array(0x1F07, 0x3B9),
1293                     0x1F90 => array(0x1F20, 0x3B9), 0x1F91 => array(0x1F21, 0x3B9),
1294                     0x1F92 => array(0x1F22, 0x3B9), 0x1F93 => array(0x1F23, 0x3B9),
1295                     0x1F94 => array(0x1F24, 0x3B9), 0x1F95 => array(0x1F25, 0x3B9),
1296                     0x1F96 => array(0x1F26, 0x3B9), 0x1F97 => array(0x1F27, 0x3B9),
1297                     0x1F98 => array(0x1F20, 0x3B9), 0x1F99 => array(0x1F21, 0x3B9),
1298                     0x1F9A => array(0x1F22, 0x3B9), 0x1F9B => array(0x1F23, 0x3B9),
1299                     0x1F9C => array(0x1F24, 0x3B9), 0x1F9D => array(0x1F25, 0x3B9),
1300                     0x1F9E => array(0x1F26, 0x3B9), 0x1F9F => array(0x1F27, 0x3B9),
1301                     0x1FA0 => array(0x1F60, 0x3B9), 0x1FA1 => array(0x1F61, 0x3B9),
1302                     0x1FA2 => array(0x1F62, 0x3B9), 0x1FA3 => array(0x1F63, 0x3B9),
1303                     0x1FA4 => array(0x1F64, 0x3B9), 0x1FA5 => array(0x1F65, 0x3B9),
1304                     0x1FA6 => array(0x1F66, 0x3B9), 0x1FA7 => array(0x1F67, 0x3B9),
1305                     0x1FA8 => array(0x1F60, 0x3B9), 0x1FA9 => array(0x1F61, 0x3B9),
1306                     0x1FAA => array(0x1F62, 0x3B9), 0x1FAB => array(0x1F63, 0x3B9),
1307                     0x1FAC => array(0x1F64, 0x3B9), 0x1FAD => array(0x1F65, 0x3B9),
1308                     0x1FAE => array(0x1F66, 0x3B9), 0x1FAF => array(0x1F67, 0x3B9),
1309                     0x1FB2 => array(0x1F70, 0x3B9), 0x1FB3 => array(0x3B1, 0x3B9),
1310                     0x1FB4 => array(0x3AC, 0x3B9), 0x1FB6 => array(0x3B1, 0x342),
1311                     0x1FB7 => array(0x3B1, 0x342, 0x3B9), 0x1FB8 => array(0x1FB0),
1312                     0x1FB9 => array(0x1FB1), 0x1FBA => array(0x1F70), 0x1FBB => array(0x1F71),
1313                     0x1FBC => array(0x3B1, 0x3B9), 0x1FBE => array(0x3B9),
1314                     0x1FC2 => array(0x1F74, 0x3B9), 0x1FC3 => array(0x3B7, 0x3B9),
1315                     0x1FC4 => array(0x3AE, 0x3B9), 0x1FC6 => array(0x3B7, 0x342),
1316                     0x1FC7 => array(0x3B7, 0x342, 0x3B9), 0x1FC8 => array(0x1F72),
1317                     0x1FC9 => array(0x1F73), 0x1FCA => array(0x1F74), 0x1FCB => array(0x1F75),
1318                     0x1FCC => array(0x3B7, 0x3B9), 0x1FD2 => array(0x3B9, 0x308, 0x300),
1319                     0x1FD3 => array(0x3B9, 0x308, 0x301), 0x1FD6 => array(0x3B9, 0x342),
1320                     0x1FD7 => array(0x3B9, 0x308, 0x342), 0x1FD8 => array(0x1FD0),
1321                     0x1FD9 => array(0x1FD1), 0x1FDA => array(0x1F76),
1322                     0x1FDB => array(0x1F77), 0x1FE2 => array(0x3C5, 0x308, 0x300),
1323                     0x1FE3 => array(0x3C5, 0x308, 0x301), 0x1FE4 => array(0x3C1, 0x313),
1324                     0x1FE6 => array(0x3C5, 0x342), 0x1FE7 => array(0x3C5, 0x308, 0x342),
1325                     0x1FE8 => array(0x1FE0), 0x1FE9 => array(0x1FE1),
1326                     0x1FEA => array(0x1F7A), 0x1FEB => array(0x1F7B),
1327                     0x1FEC => array(0x1FE5), 0x1FF2 => array(0x1F7C, 0x3B9),
1328                     0x1FF3 => array(0x3C9, 0x3B9), 0x1FF4 => array(0x3CE, 0x3B9),
1329                     0x1FF6 => array(0x3C9, 0x342), 0x1FF7 => array(0x3C9, 0x342, 0x3B9),
1330                     0x1FF8 => array(0x1F78), 0x1FF9 => array(0x1F79), 0x1FFA => array(0x1F7C),
1331                     0x1FFB => array(0x1F7D), 0x1FFC => array(0x3C9, 0x3B9),
1332                     0x20A8 => array(0x72, 0x73), 0x2102 => array(0x63), 0x2103 => array(0xB0, 0x63),
1333                     0x2107 => array(0x25B), 0x2109 => array(0xB0, 0x66), 0x210B => array(0x68),
1334                     0x210C => array(0x68), 0x210D => array(0x68), 0x2110 => array(0x69),
1335                     0x2111 => array(0x69), 0x2112 => array(0x6C), 0x2115 => array(0x6E),
1336                     0x2116 => array(0x6E, 0x6F), 0x2119 => array(0x70), 0x211A => array(0x71),
1337                     0x211B => array(0x72), 0x211C => array(0x72), 0x211D => array(0x72),
1338                     0x2120 => array(0x73, 0x6D), 0x2121 => array(0x74, 0x65, 0x6C),
1339                     0x2122 => array(0x74, 0x6D), 0x2124 => array(0x7A), 0x2126 => array(0x3C9),
1340                     0x2128 => array(0x7A), 0x212A => array(0x6B), 0x212B => array(0xE5),
1341                     0x212C => array(0x62), 0x212D => array(0x63), 0x2130 => array(0x65),
1342                     0x2131 => array(0x66), 0x2133 => array(0x6D), 0x213E => array(0x3B3),
1343                     0x213F => array(0x3C0), 0x2145 => array(0x64), 0x2160 => array(0x2170),
1344                     0x2161 => array(0x2171), 0x2162 => array(0x2172), 0x2163 => array(0x2173),
1345                     0x2164 => array(0x2174), 0x2165 => array(0x2175), 0x2166 => array(0x2176),
1346                     0x2167 => array(0x2177), 0x2168 => array(0x2178), 0x2169 => array(0x2179),
1347                     0x216A => array(0x217A), 0x216B => array(0x217B), 0x216C => array(0x217C),
1348                     0x216D => array(0x217D), 0x216E => array(0x217E), 0x216F => array(0x217F),
1349                     0x24B6 => array(0x24D0), 0x24B7 => array(0x24D1), 0x24B8 => array(0x24D2),
1350                     0x24B9 => array(0x24D3), 0x24BA => array(0x24D4), 0x24BB => array(0x24D5),
1351                     0x24BC => array(0x24D6), 0x24BD => array(0x24D7), 0x24BE => array(0x24D8),
1352                     0x24BF => array(0x24D9), 0x24C0 => array(0x24DA), 0x24C1 => array(0x24DB),
1353                     0x24C2 => array(0x24DC), 0x24C3 => array(0x24DD), 0x24C4 => array(0x24DE),
1354                     0x24C5 => array(0x24DF), 0x24C6 => array(0x24E0), 0x24C7 => array(0x24E1),
1355                     0x24C8 => array(0x24E2), 0x24C9 => array(0x24E3), 0x24CA => array(0x24E4),
1356                     0x24CB => array(0x24E5), 0x24CC => array(0x24E6), 0x24CD => array(0x24E7),
1357                     0x24CE => array(0x24E8), 0x24CF => array(0x24E9), 0x3371 => array(0x68, 0x70, 0x61),
1358                     0x3373 => array(0x61, 0x75), 0x3375 => array(0x6F, 0x76),
1359                     0x3380 => array(0x70, 0x61), 0x3381 => array(0x6E, 0x61),
1360                     0x3382 => array(0x3BC, 0x61), 0x3383 => array(0x6D, 0x61),
1361                     0x3384 => array(0x6B, 0x61), 0x3385 => array(0x6B, 0x62),
1362                     0x3386 => array(0x6D, 0x62), 0x3387 => array(0x67, 0x62),
1363                     0x338A => array(0x70, 0x66), 0x338B => array(0x6E, 0x66),
1364                     0x338C => array(0x3BC, 0x66), 0x3390 => array(0x68, 0x7A),
1365                     0x3391 => array(0x6B, 0x68, 0x7A), 0x3392 => array(0x6D, 0x68, 0x7A),
1366                     0x3393 => array(0x67, 0x68, 0x7A), 0x3394 => array(0x74, 0x68, 0x7A),
1367                     0x33A9 => array(0x70, 0x61), 0x33AA => array(0x6B, 0x70, 0x61),
1368                     0x33AB => array(0x6D, 0x70, 0x61), 0x33AC => array(0x67, 0x70, 0x61),
1369                     0x33B4 => array(0x70, 0x76), 0x33B5 => array(0x6E, 0x76),
1370                     0x33B6 => array(0x3BC, 0x76), 0x33B7 => array(0x6D, 0x76),
1371                     0x33B8 => array(0x6B, 0x76), 0x33B9 => array(0x6D, 0x76),
1372                     0x33BA => array(0x70, 0x77), 0x33BB => array(0x6E, 0x77),
1373                     0x33BC => array(0x3BC, 0x77), 0x33BD => array(0x6D, 0x77),
1374                     0x33BE => array(0x6B, 0x77), 0x33BF => array(0x6D, 0x77),
1375                     0x33C0 => array(0x6B, 0x3C9), 0x33C1 => array(0x6D, 0x3C9), /*
1376                     0x33C2  => array(0x61, 0x2E, 0x6D, 0x2E), */
1377                     0x33C3 => array(0x62, 0x71), 0x33C6 => array(0x63, 0x2215, 0x6B, 0x67),
1378                     0x33C7 => array(0x63, 0x6F, 0x2E), 0x33C8 => array(0x64, 0x62),
1379                     0x33C9 => array(0x67, 0x79), 0x33CB => array(0x68, 0x70),
1380                     0x33CD => array(0x6B, 0x6B), 0x33CE => array(0x6B, 0x6D),
1381                     0x33D7 => array(0x70, 0x68), 0x33D9 => array(0x70, 0x70, 0x6D),
1382                     0x33DA => array(0x70, 0x72), 0x33DC => array(0x73, 0x76),
1383                     0x33DD => array(0x77, 0x62), 0xFB00 => array(0x66, 0x66),
1384                     0xFB01 => array(0x66, 0x69), 0xFB02 => array(0x66, 0x6C),
1385                     0xFB03 => array(0x66, 0x66, 0x69), 0xFB04 => array(0x66, 0x66, 0x6C),
1386                     0xFB05 => array(0x73, 0x74), 0xFB06 => array(0x73, 0x74),
1387                     0xFB13 => array(0x574, 0x576), 0xFB14 => array(0x574, 0x565),
1388                     0xFB15 => array(0x574, 0x56B), 0xFB16 => array(0x57E, 0x576),
1389                     0xFB17 => array(0x574, 0x56D), 0xFF21 => array(0xFF41),
1390                     0xFF22 => array(0xFF42), 0xFF23 => array(0xFF43), 0xFF24 => array(0xFF44),
1391                     0xFF25 => array(0xFF45), 0xFF26 => array(0xFF46), 0xFF27 => array(0xFF47),
1392                     0xFF28 => array(0xFF48), 0xFF29 => array(0xFF49), 0xFF2A => array(0xFF4A),
1393                     0xFF2B => array(0xFF4B), 0xFF2C => array(0xFF4C), 0xFF2D => array(0xFF4D),
1394                     0xFF2E => array(0xFF4E), 0xFF2F => array(0xFF4F), 0xFF30 => array(0xFF50),
1395                     0xFF31 => array(0xFF51), 0xFF32 => array(0xFF52), 0xFF33 => array(0xFF53),
1396                     0xFF34 => array(0xFF54), 0xFF35 => array(0xFF55), 0xFF36 => array(0xFF56),
1397                     0xFF37 => array(0xFF57), 0xFF38 => array(0xFF58), 0xFF39 => array(0xFF59),
1398                     0xFF3A => array(0xFF5A), 0x10400 => array(0x10428), 0x10401 => array(0x10429),
1399                     0x10402 => array(0x1042A), 0x10403 => array(0x1042B), 0x10404 => array(0x1042C),
1400                     0x10405 => array(0x1042D), 0x10406 => array(0x1042E), 0x10407 => array(0x1042F),
1401                     0x10408 => array(0x10430), 0x10409 => array(0x10431), 0x1040A => array(0x10432),
1402                     0x1040B => array(0x10433), 0x1040C => array(0x10434), 0x1040D => array(0x10435),
1403                     0x1040E => array(0x10436), 0x1040F => array(0x10437), 0x10410 => array(0x10438),
1404                     0x10411 => array(0x10439), 0x10412 => array(0x1043A), 0x10413 => array(0x1043B),
1405                     0x10414 => array(0x1043C), 0x10415 => array(0x1043D), 0x10416 => array(0x1043E),
1406                     0x10417 => array(0x1043F), 0x10418 => array(0x10440), 0x10419 => array(0x10441),
1407                     0x1041A => array(0x10442), 0x1041B => array(0x10443), 0x1041C => array(0x10444),
1408                     0x1041D => array(0x10445), 0x1041E => array(0x10446), 0x1041F => array(0x10447),
1409                     0x10420 => array(0x10448), 0x10421 => array(0x10449), 0x10422 => array(0x1044A),
1410                     0x10423 => array(0x1044B), 0x10424 => array(0x1044C), 0x10425 => array(0x1044D),
1411                     0x1D400 => array(0x61), 0x1D401 => array(0x62), 0x1D402 => array(0x63),
1412                     0x1D403 => array(0x64), 0x1D404 => array(0x65), 0x1D405 => array(0x66),
1413                     0x1D406 => array(0x67), 0x1D407 => array(0x68), 0x1D408 => array(0x69),
1414                     0x1D409 => array(0x6A), 0x1D40A => array(0x6B), 0x1D40B => array(0x6C),
1415                     0x1D40C => array(0x6D), 0x1D40D => array(0x6E), 0x1D40E => array(0x6F),
1416                     0x1D40F => array(0x70), 0x1D410 => array(0x71), 0x1D411 => array(0x72),
1417                     0x1D412 => array(0x73), 0x1D413 => array(0x74), 0x1D414 => array(0x75),
1418                     0x1D415 => array(0x76), 0x1D416 => array(0x77), 0x1D417 => array(0x78),
1419                     0x1D418 => array(0x79), 0x1D419 => array(0x7A), 0x1D434 => array(0x61),
1420                     0x1D435 => array(0x62), 0x1D436 => array(0x63), 0x1D437 => array(0x64),
1421                     0x1D438 => array(0x65), 0x1D439 => array(0x66), 0x1D43A => array(0x67),
1422                     0x1D43B => array(0x68), 0x1D43C => array(0x69), 0x1D43D => array(0x6A),
1423                     0x1D43E => array(0x6B), 0x1D43F => array(0x6C), 0x1D440 => array(0x6D),
1424                     0x1D441 => array(0x6E), 0x1D442 => array(0x6F), 0x1D443 => array(0x70),
1425                     0x1D444 => array(0x71), 0x1D445 => array(0x72), 0x1D446 => array(0x73),
1426                     0x1D447 => array(0x74), 0x1D448 => array(0x75), 0x1D449 => array(0x76),
1427                     0x1D44A => array(0x77), 0x1D44B => array(0x78), 0x1D44C => array(0x79),
1428                     0x1D44D => array(0x7A), 0x1D468 => array(0x61), 0x1D469 => array(0x62),
1429                     0x1D46A => array(0x63), 0x1D46B => array(0x64), 0x1D46C => array(0x65),
1430                     0x1D46D => array(0x66), 0x1D46E => array(0x67), 0x1D46F => array(0x68),
1431                     0x1D470 => array(0x69), 0x1D471 => array(0x6A), 0x1D472 => array(0x6B),
1432                     0x1D473 => array(0x6C), 0x1D474 => array(0x6D), 0x1D475 => array(0x6E),
1433                     0x1D476 => array(0x6F), 0x1D477 => array(0x70), 0x1D478 => array(0x71),
1434                     0x1D479 => array(0x72), 0x1D47A => array(0x73), 0x1D47B => array(0x74),
1435                     0x1D47C => array(0x75), 0x1D47D => array(0x76), 0x1D47E => array(0x77),
1436                     0x1D47F => array(0x78), 0x1D480 => array(0x79), 0x1D481 => array(0x7A),
1437                     0x1D49C => array(0x61), 0x1D49E => array(0x63), 0x1D49F => array(0x64),
1438                     0x1D4A2 => array(0x67), 0x1D4A5 => array(0x6A), 0x1D4A6 => array(0x6B),
1439                     0x1D4A9 => array(0x6E), 0x1D4AA => array(0x6F), 0x1D4AB => array(0x70),
1440                     0x1D4AC => array(0x71), 0x1D4AE => array(0x73), 0x1D4AF => array(0x74),
1441                     0x1D4B0 => array(0x75), 0x1D4B1 => array(0x76), 0x1D4B2 => array(0x77),
1442                     0x1D4B3 => array(0x78), 0x1D4B4 => array(0x79), 0x1D4B5 => array(0x7A),
1443                     0x1D4D0 => array(0x61), 0x1D4D1 => array(0x62), 0x1D4D2 => array(0x63),
1444                     0x1D4D3 => array(0x64), 0x1D4D4 => array(0x65), 0x1D4D5 => array(0x66),
1445                     0x1D4D6 => array(0x67), 0x1D4D7 => array(0x68), 0x1D4D8 => array(0x69),
1446                     0x1D4D9 => array(0x6A), 0x1D4DA => array(0x6B), 0x1D4DB => array(0x6C),
1447                     0x1D4DC => array(0x6D), 0x1D4DD => array(0x6E), 0x1D4DE => array(0x6F),
1448                     0x1D4DF => array(0x70), 0x1D4E0 => array(0x71), 0x1D4E1 => array(0x72),
1449                     0x1D4E2 => array(0x73), 0x1D4E3 => array(0x74), 0x1D4E4 => array(0x75),
1450                     0x1D4E5 => array(0x76), 0x1D4E6 => array(0x77), 0x1D4E7 => array(0x78),
1451                     0x1D4E8 => array(0x79), 0x1D4E9 => array(0x7A), 0x1D504 => array(0x61),
1452                     0x1D505 => array(0x62), 0x1D507 => array(0x64), 0x1D508 => array(0x65),
1453                     0x1D509 => array(0x66), 0x1D50A => array(0x67), 0x1D50D => array(0x6A),
1454                     0x1D50E => array(0x6B), 0x1D50F => array(0x6C), 0x1D510 => array(0x6D),
1455                     0x1D511 => array(0x6E), 0x1D512 => array(0x6F), 0x1D513 => array(0x70),
1456                     0x1D514 => array(0x71), 0x1D516 => array(0x73), 0x1D517 => array(0x74),
1457                     0x1D518 => array(0x75), 0x1D519 => array(0x76), 0x1D51A => array(0x77),
1458                     0x1D51B => array(0x78), 0x1D51C => array(0x79), 0x1D538 => array(0x61),
1459                     0x1D539 => array(0x62), 0x1D53B => array(0x64), 0x1D53C => array(0x65),
1460                     0x1D53D => array(0x66), 0x1D53E => array(0x67), 0x1D540 => array(0x69),
1461                     0x1D541 => array(0x6A), 0x1D542 => array(0x6B), 0x1D543 => array(0x6C),
1462                     0x1D544 => array(0x6D), 0x1D546 => array(0x6F), 0x1D54A => array(0x73),
1463                     0x1D54B => array(0x74), 0x1D54C => array(0x75), 0x1D54D => array(0x76),
1464                     0x1D54E => array(0x77), 0x1D54F => array(0x78), 0x1D550 => array(0x79),
1465                     0x1D56C => array(0x61), 0x1D56D => array(0x62), 0x1D56E => array(0x63),
1466                     0x1D56F => array(0x64), 0x1D570 => array(0x65), 0x1D571 => array(0x66),
1467                     0x1D572 => array(0x67), 0x1D573 => array(0x68), 0x1D574 => array(0x69),
1468                     0x1D575 => array(0x6A), 0x1D576 => array(0x6B), 0x1D577 => array(0x6C),
1469                     0x1D578 => array(0x6D), 0x1D579 => array(0x6E), 0x1D57A => array(0x6F),
1470                     0x1D57B => array(0x70), 0x1D57C => array(0x71), 0x1D57D => array(0x72),
1471                     0x1D57E => array(0x73), 0x1D57F => array(0x74), 0x1D580 => array(0x75),
1472                     0x1D581 => array(0x76), 0x1D582 => array(0x77), 0x1D583 => array(0x78),
1473                     0x1D584 => array(0x79), 0x1D585 => array(0x7A), 0x1D5A0 => array(0x61),
1474                     0x1D5A1 => array(0x62), 0x1D5A2 => array(0x63), 0x1D5A3 => array(0x64),
1475                     0x1D5A4 => array(0x65), 0x1D5A5 => array(0x66), 0x1D5A6 => array(0x67),
1476                     0x1D5A7 => array(0x68), 0x1D5A8 => array(0x69), 0x1D5A9 => array(0x6A),
1477                     0x1D5AA => array(0x6B), 0x1D5AB => array(0x6C), 0x1D5AC => array(0x6D),
1478                     0x1D5AD => array(0x6E), 0x1D5AE => array(0x6F), 0x1D5AF => array(0x70),
1479                     0x1D5B0 => array(0x71), 0x1D5B1 => array(0x72), 0x1D5B2 => array(0x73),
1480                     0x1D5B3 => array(0x74), 0x1D5B4 => array(0x75), 0x1D5B5 => array(0x76),
1481                     0x1D5B6 => array(0x77), 0x1D5B7 => array(0x78), 0x1D5B8 => array(0x79),
1482                     0x1D5B9 => array(0x7A), 0x1D5D4 => array(0x61), 0x1D5D5 => array(0x62),
1483                     0x1D5D6 => array(0x63), 0x1D5D7 => array(0x64), 0x1D5D8 => array(0x65),
1484                     0x1D5D9 => array(0x66), 0x1D5DA => array(0x67), 0x1D5DB => array(0x68),
1485                     0x1D5DC => array(0x69), 0x1D5DD => array(0x6A), 0x1D5DE => array(0x6B),
1486                     0x1D5DF => array(0x6C), 0x1D5E0 => array(0x6D), 0x1D5E1 => array(0x6E),
1487                     0x1D5E2 => array(0x6F), 0x1D5E3 => array(0x70), 0x1D5E4 => array(0x71),
1488                     0x1D5E5 => array(0x72), 0x1D5E6 => array(0x73), 0x1D5E7 => array(0x74),
1489                     0x1D5E8 => array(0x75), 0x1D5E9 => array(0x76), 0x1D5EA => array(0x77),
1490                     0x1D5EB => array(0x78), 0x1D5EC => array(0x79), 0x1D5ED => array(0x7A),
1491                     0x1D608 => array(0x61), 0x1D609 => array(0x62), 0x1D60A => array(0x63),
1492                     0x1D60B => array(0x64), 0x1D60C => array(0x65), 0x1D60D => array(0x66),
1493                     0x1D60E => array(0x67), 0x1D60F => array(0x68), 0x1D610 => array(0x69),
1494                     0x1D611 => array(0x6A), 0x1D612 => array(0x6B), 0x1D613 => array(0x6C),
1495                     0x1D614 => array(0x6D), 0x1D615 => array(0x6E), 0x1D616 => array(0x6F),
1496                     0x1D617 => array(0x70), 0x1D618 => array(0x71), 0x1D619 => array(0x72),
1497                     0x1D61A => array(0x73), 0x1D61B => array(0x74), 0x1D61C => array(0x75),
1498                     0x1D61D => array(0x76), 0x1D61E => array(0x77), 0x1D61F => array(0x78),
1499                     0x1D620 => array(0x79), 0x1D621 => array(0x7A), 0x1D63C => array(0x61),
1500                     0x1D63D => array(0x62), 0x1D63E => array(0x63), 0x1D63F => array(0x64),
1501                     0x1D640 => array(0x65), 0x1D641 => array(0x66), 0x1D642 => array(0x67),
1502                     0x1D643 => array(0x68), 0x1D644 => array(0x69), 0x1D645 => array(0x6A),
1503                     0x1D646 => array(0x6B), 0x1D647 => array(0x6C), 0x1D648 => array(0x6D),
1504                     0x1D649 => array(0x6E), 0x1D64A => array(0x6F), 0x1D64B => array(0x70),
1505                     0x1D64C => array(0x71), 0x1D64D => array(0x72), 0x1D64E => array(0x73),
1506                     0x1D64F => array(0x74), 0x1D650 => array(0x75), 0x1D651 => array(0x76),
1507                     0x1D652 => array(0x77), 0x1D653 => array(0x78), 0x1D654 => array(0x79),
1508                     0x1D655 => array(0x7A), 0x1D670 => array(0x61), 0x1D671 => array(0x62),
1509                     0x1D672 => array(0x63), 0x1D673 => array(0x64), 0x1D674 => array(0x65),
1510                     0x1D675 => array(0x66), 0x1D676 => array(0x67), 0x1D677 => array(0x68),
1511                     0x1D678 => array(0x69), 0x1D679 => array(0x6A), 0x1D67A => array(0x6B),
1512                     0x1D67B => array(0x6C), 0x1D67C => array(0x6D), 0x1D67D => array(0x6E),
1513                     0x1D67E => array(0x6F), 0x1D67F => array(0x70), 0x1D680 => array(0x71),
1514                     0x1D681 => array(0x72), 0x1D682 => array(0x73), 0x1D683 => array(0x74),
1515                     0x1D684 => array(0x75), 0x1D685 => array(0x76), 0x1D686 => array(0x77),
1516                     0x1D687 => array(0x78), 0x1D688 => array(0x79), 0x1D689 => array(0x7A),
1517                     0x1D6A8 => array(0x3B1), 0x1D6A9 => array(0x3B2), 0x1D6AA => array(0x3B3),
1518                     0x1D6AB => array(0x3B4), 0x1D6AC => array(0x3B5), 0x1D6AD => array(0x3B6),
1519                     0x1D6AE => array(0x3B7), 0x1D6AF => array(0x3B8), 0x1D6B0 => array(0x3B9),
1520                     0x1D6B1 => array(0x3BA), 0x1D6B2 => array(0x3BB), 0x1D6B3 => array(0x3BC),
1521                     0x1D6B4 => array(0x3BD), 0x1D6B5 => array(0x3BE), 0x1D6B6 => array(0x3BF),
1522                     0x1D6B7 => array(0x3C0), 0x1D6B8 => array(0x3C1), 0x1D6B9 => array(0x3B8),
1523                     0x1D6BA => array(0x3C3), 0x1D6BB => array(0x3C4), 0x1D6BC => array(0x3C5),
1524                     0x1D6BD => array(0x3C6), 0x1D6BE => array(0x3C7), 0x1D6BF => array(0x3C8),
1525                     0x1D6C0 => array(0x3C9), 0x1D6D3 => array(0x3C3), 0x1D6E2 => array(0x3B1),
1526                     0x1D6E3 => array(0x3B2), 0x1D6E4 => array(0x3B3), 0x1D6E5 => array(0x3B4),
1527                     0x1D6E6 => array(0x3B5), 0x1D6E7 => array(0x3B6), 0x1D6E8 => array(0x3B7),
1528                     0x1D6E9 => array(0x3B8), 0x1D6EA => array(0x3B9), 0x1D6EB => array(0x3BA),
1529                     0x1D6EC => array(0x3BB), 0x1D6ED => array(0x3BC), 0x1D6EE => array(0x3BD),
1530                     0x1D6EF => array(0x3BE), 0x1D6F0 => array(0x3BF), 0x1D6F1 => array(0x3C0),
1531                     0x1D6F2 => array(0x3C1), 0x1D6F3 => array(0x3B8), 0x1D6F4 => array(0x3C3),
1532                     0x1D6F5 => array(0x3C4), 0x1D6F6 => array(0x3C5), 0x1D6F7 => array(0x3C6),
1533                     0x1D6F8 => array(0x3C7), 0x1D6F9 => array(0x3C8), 0x1D6FA => array(0x3C9),
1534                     0x1D70D => array(0x3C3), 0x1D71C => array(0x3B1), 0x1D71D => array(0x3B2),
1535                     0x1D71E => array(0x3B3), 0x1D71F => array(0x3B4), 0x1D720 => array(0x3B5),
1536                     0x1D721 => array(0x3B6), 0x1D722 => array(0x3B7), 0x1D723 => array(0x3B8),
1537                     0x1D724 => array(0x3B9), 0x1D725 => array(0x3BA), 0x1D726 => array(0x3BB),
1538                     0x1D727 => array(0x3BC), 0x1D728 => array(0x3BD), 0x1D729 => array(0x3BE),
1539                     0x1D72A => array(0x3BF), 0x1D72B => array(0x3C0), 0x1D72C => array(0x3C1),
1540                     0x1D72D => array(0x3B8), 0x1D72E => array(0x3C3), 0x1D72F => array(0x3C4),
1541                     0x1D730 => array(0x3C5), 0x1D731 => array(0x3C6), 0x1D732 => array(0x3C7),
1542                     0x1D733 => array(0x3C8), 0x1D734 => array(0x3C9), 0x1D747 => array(0x3C3),
1543                     0x1D756 => array(0x3B1), 0x1D757 => array(0x3B2), 0x1D758 => array(0x3B3),
1544                     0x1D759 => array(0x3B4), 0x1D75A => array(0x3B5), 0x1D75B => array(0x3B6),
1545                     0x1D75C => array(0x3B7), 0x1D75D => array(0x3B8), 0x1D75E => array(0x3B9),
1546                     0x1D75F => array(0x3BA), 0x1D760 => array(0x3BB), 0x1D761 => array(0x3BC),
1547                     0x1D762 => array(0x3BD), 0x1D763 => array(0x3BE), 0x1D764 => array(0x3BF),
1548                     0x1D765 => array(0x3C0), 0x1D766 => array(0x3C1), 0x1D767 => array(0x3B8),
1549                     0x1D768 => array(0x3C3), 0x1D769 => array(0x3C4), 0x1D76A => array(0x3C5),
1550                     0x1D76B => array(0x3C6), 0x1D76C => array(0x3C7), 0x1D76D => array(0x3C8),
1551                     0x1D76E => array(0x3C9), 0x1D781 => array(0x3C3), 0x1D790 => array(0x3B1),
1552                     0x1D791 => array(0x3B2), 0x1D792 => array(0x3B3), 0x1D793 => array(0x3B4),
1553                     0x1D794 => array(0x3B5), 0x1D795 => array(0x3B6), 0x1D796 => array(0x3B7),
1554                     0x1D797 => array(0x3B8), 0x1D798 => array(0x3B9), 0x1D799 => array(0x3BA),
1555                     0x1D79A => array(0x3BB), 0x1D79B => array(0x3BC), 0x1D79C => array(0x3BD),
1556                     0x1D79D => array(0x3BE), 0x1D79E => array(0x3BF), 0x1D79F => array(0x3C0),
1557                     0x1D7A0 => array(0x3C1), 0x1D7A1 => array(0x3B8), 0x1D7A2 => array(0x3C3),
1558                     0x1D7A3 => array(0x3C4), 0x1D7A4 => array(0x3C5), 0x1D7A5 => array(0x3C6),
1559                     0x1D7A6 => array(0x3C7), 0x1D7A7 => array(0x3C8), 0x1D7A8 => array(0x3C9),
1560                     0x1D7BB => array(0x3C3), 0x3F9 => array(0x3C3), 0x1D2C => array(0x61),
1561                     0x1D2D => array(0xE6), 0x1D2E => array(0x62), 0x1D30 => array(0x64),
1562                     0x1D31 => array(0x65), 0x1D32 => array(0x1DD), 0x1D33 => array(0x67),
1563                     0x1D34 => array(0x68), 0x1D35 => array(0x69), 0x1D36 => array(0x6A),
1564                     0x1D37 => array(0x6B), 0x1D38 => array(0x6C), 0x1D39 => array(0x6D),
1565                     0x1D3A => array(0x6E), 0x1D3C => array(0x6F), 0x1D3D => array(0x223),
1566                     0x1D3E => array(0x70), 0x1D3F => array(0x72), 0x1D40 => array(0x74),
1567                     0x1D41 => array(0x75), 0x1D42 => array(0x77), 0x213B => array(0x66, 0x61, 0x78),
1568                     0x3250 => array(0x70, 0x74, 0x65), 0x32CC => array(0x68, 0x67),
1569                     0x32CE => array(0x65, 0x76), 0x32CF => array(0x6C, 0x74, 0x64),
1570                     0x337A => array(0x69, 0x75), 0x33DE => array(0x76, 0x2215, 0x6D),
1571                     0x33DF => array(0x61, 0x2215, 0x6D)
1572             ),
1573             'replacemaps' => array(0x41 => array(0x61), 0x42 => array(0x62), 0x43 => array(0x63),
1574                     0x44 => array(0x64), 0x45 => array(0x65), 0x46 => array(0x66),
1575                     0x47 => array(0x67), 0x48 => array(0x68), 0x49 => array(0x69),
1576                     0x4A => array(0x6A), 0x4B => array(0x6B), 0x4C => array(0x6C),
1577                     0x4D => array(0x6D), 0x4E => array(0x6E), 0x4F => array(0x6F),
1578                     0x50 => array(0x70), 0x51 => array(0x71), 0x52 => array(0x72),
1579                     0x53 => array(0x73), 0x54 => array(0x74), 0x55 => array(0x75),
1580                     0x56 => array(0x76), 0x57 => array(0x77), 0x58 => array(0x78),
1581                     0x59 => array(0x79), 0x5A => array(0x7A), 0xAA => array(0x61),
1582                     0xB2 => array(0x32), 0xB3 => array(0x33), 0xB5 => array(0x3BC),
1583                     0xB9 => array(0x31), 0xBA => array(0x6F), 0xBC => array(0x31, 0x2044, 0x34),
1584                     0xBD => array(0x31, 0x2044, 0x32), 0xBE => array(0x33, 0x2044, 0x34), 0xC0 => array(0xE0),
1585                     0xC1 => array(0xE1), 0xC2 => array(0xE2), 0xC3 => array(0xE3),
1586                     0xC4 => array(0xE4), 0xC5 => array(0xE5), 0xC6 => array(0xE6),
1587                     0xC7 => array(0xE7), 0xC8 => array(0xE8), 0xC9 => array(0xE9),
1588                     0xCA => array(0xEA), 0xCB => array(0xEB), 0xCC => array(0xEC),
1589                     0xCD => array(0xED), 0xCE => array(0xEE), 0xCF => array(0xEF),
1590                     0xD0 => array(0xF0), 0xD1 => array(0xF1), 0xD2 => array(0xF2),
1591                     0xD3 => array(0xF3), 0xD4 => array(0xF4), 0xD5 => array(0xF5),
1592                     0xD6 => array(0xF6), 0xD8 => array(0xF8), 0xD9 => array(0xF9),
1593                     0xDA => array(0xFA), 0xDB => array(0xFB), 0xDC => array(0xFC),
1594                     0xDD => array(0xFD), 0xDE => array(0xFE), 0x100 => array(0x101),
1595                     0x102 => array(0x103), 0x104 => array(0x105), 0x106 => array(0x107),
1596                     0x108 => array(0x109), 0x10A => array(0x10B), 0x10C => array(0x10D),
1597                     0x10E => array(0x10F), 0x110 => array(0x111), 0x112 => array(0x113),
1598                     0x114 => array(0x115), 0x116 => array(0x117), 0x118 => array(0x119),
1599                     0x11A => array(0x11B), 0x11C => array(0x11D), 0x11E => array(0x11F),
1600                     0x120 => array(0x121), 0x122 => array(0x123), 0x124 => array(0x125),
1601                     0x126 => array(0x127), 0x128 => array(0x129), 0x12A => array(0x12B),
1602                     0x12C => array(0x12D), 0x12E => array(0x12F), 0x130 => array(0x69, 0x307),
1603                     0x132 => array(0x69, 0x6A), 0x133 => array(0x69, 0x6A), 0x134 => array(0x135),
1604                     0x136 => array(0x137), 0x139 => array(0x13A), 0x13B => array(0x13C),
1605                     0x13D => array(0x13E), 0x13F => array(0x6C, 0xB7), 0x140 => array(0x6C, 0xB7),
1606                     0x141 => array(0x142), 0x143 => array(0x144), 0x145 => array(0x146),
1607                     0x147 => array(0x148), 0x149 => array(0x2BC, 0x6E), 0x14A => array(0x14B),
1608                     0x14C => array(0x14D), 0x14E => array(0x14F), 0x150 => array(0x151),
1609                     0x152 => array(0x153), 0x154 => array(0x155), 0x156 => array(0x157),
1610                     0x158 => array(0x159), 0x15A => array(0x15B), 0x15C => array(0x15D),
1611                     0x15E => array(0x15F), 0x160 => array(0x161), 0x162 => array(0x163),
1612                     0x164 => array(0x165), 0x166 => array(0x167), 0x168 => array(0x169),
1613                     0x16A => array(0x16B), 0x16C => array(0x16D), 0x16E => array(0x16F),
1614                     0x170 => array(0x171), 0x172 => array(0x173), 0x174 => array(0x175),
1615                     0x176 => array(0x177), 0x178 => array(0xFF), 0x179 => array(0x17A),
1616                     0x17B => array(0x17C), 0x17D => array(0x17E), 0x17F => array(0x73),
1617                     0x181 => array(0x253), 0x182 => array(0x183), 0x184 => array(0x185),
1618                     0x186 => array(0x254), 0x187 => array(0x188), 0x189 => array(0x256),
1619                     0x18A => array(0x257), 0x18B => array(0x18C), 0x18E => array(0x1DD),
1620                     0x18F => array(0x259), 0x190 => array(0x25B), 0x191 => array(0x192),
1621                     0x193 => array(0x260), 0x194 => array(0x263), 0x196 => array(0x269),
1622                     0x197 => array(0x268), 0x198 => array(0x199), 0x19C => array(0x26F),
1623                     0x19D => array(0x272), 0x19F => array(0x275), 0x1A0 => array(0x1A1),
1624                     0x1A2 => array(0x1A3), 0x1A4 => array(0x1A5), 0x1A6 => array(0x280),
1625                     0x1A7 => array(0x1A8), 0x1A9 => array(0x283), 0x1AC => array(0x1AD),
1626                     0x1AE => array(0x288), 0x1AF => array(0x1B0), 0x1B1 => array(0x28A),
1627                     0x1B2 => array(0x28B), 0x1B3 => array(0x1B4), 0x1B5 => array(0x1B6),
1628                     0x1B7 => array(0x292), 0x1B8 => array(0x1B9), 0x1BC => array(0x1BD),
1629                     0x1C4 => array(0x64, 0x17E), 0x1C5 => array(0x64, 0x17E), 0x1C6 => array(0x64, 0x17E),
1630                     0x1C7 => array(0x6C, 0x6A), 0x1C8 => array(0x6C, 0x6A), 0x1C9 => array(0x6C, 0x6A),
1631                     0x1CA => array(0x6E, 0x6A), 0x1CB => array(0x6E, 0x6A), 0x1CC => array(0x6E, 0x6A),
1632                     0x1CD => array(0x1CE), 0x1CF => array(0x1D0), 0x1D1 => array(0x1D2),
1633                     0x1D3 => array(0x1D4), 0x1D5 => array(0x1D6), 0x1D7 => array(0x1D8),
1634                     0x1D9 => array(0x1DA), 0x1DB => array(0x1DC), 0x1DE => array(0x1DF),
1635                     0x1E0 => array(0x1E1), 0x1E2 => array(0x1E3), 0x1E4 => array(0x1E5),
1636                     0x1E6 => array(0x1E7), 0x1E8 => array(0x1E9), 0x1EA => array(0x1EB),
1637                     0x1EC => array(0x1ED), 0x1EE => array(0x1EF), 0x1F1 => array(0x64, 0x7A),
1638                     0x1F2 => array(0x64, 0x7A), 0x1F3 => array(0x64, 0x7A), 0x1F4 => array(0x1F5),
1639                     0x1F6 => array(0x195), 0x1F7 => array(0x1BF), 0x1F8 => array(0x1F9),
1640                     0x1FA => array(0x1FB), 0x1FC => array(0x1FD), 0x1FE => array(0x1FF),
1641                     0x200 => array(0x201), 0x202 => array(0x203), 0x204 => array(0x205),
1642                     0x206 => array(0x207), 0x208 => array(0x209), 0x20A => array(0x20B),
1643                     0x20C => array(0x20D), 0x20E => array(0x20F), 0x210 => array(0x211),
1644                     0x212 => array(0x213), 0x214 => array(0x215), 0x216 => array(0x217),
1645                     0x218 => array(0x219), 0x21A => array(0x21B), 0x21C => array(0x21D),
1646                     0x21E => array(0x21F), 0x220 => array(0x19E), 0x222 => array(0x223),
1647                     0x224 => array(0x225), 0x226 => array(0x227), 0x228 => array(0x229),
1648                     0x22A => array(0x22B), 0x22C => array(0x22D), 0x22E => array(0x22F),
1649                     0x230 => array(0x231), 0x232 => array(0x233), 0x23A => array(0x2C65),
1650                     0x23B => array(0x23C), 0x23D => array(0x19A), 0x23E => array(0x2C66),
1651                     0x241 => array(0x242), 0x243 => array(0x180), 0x244 => array(0x289),
1652                     0x245 => array(0x28C), 0x246 => array(0x247), 0x248 => array(0x249),
1653                     0x24A => array(0x24B), 0x24C => array(0x24D), 0x24E => array(0x24F),
1654                     0x2B0 => array(0x68), 0x2B1 => array(0x266), 0x2B2 => array(0x6A),
1655                     0x2B3 => array(0x72), 0x2B4 => array(0x279), 0x2B5 => array(0x27B),
1656                     0x2B6 => array(0x281), 0x2B7 => array(0x77), 0x2B8 => array(0x79),
1657                     0x2E0 => array(0x263), 0x2E1 => array(0x6C), 0x2E2 => array(0x73),
1658                     0x2E3 => array(0x78), 0x2E4 => array(0x295), 0x340 => array(0x300),
1659                     0x341 => array(0x301), 0x343 => array(0x313), 0x344 => array(0x308, 0x301),
1660                     0x345 => array(0x3B9), 0x370 => array(0x371), 0x372 => array(0x373),
1661                     0x374 => array(0x2B9), 0x376 => array(0x377), 0x37F => array(0x3F3),
1662                     0x386 => array(0x3AC), 0x387 => array(0xB7), 0x388 => array(0x3AD),
1663                     0x389 => array(0x3AE), 0x38A => array(0x3AF), 0x38C => array(0x3CC),
1664                     0x38E => array(0x3CD), 0x38F => array(0x3CE), 0x391 => array(0x3B1),
1665                     0x392 => array(0x3B2), 0x393 => array(0x3B3), 0x394 => array(0x3B4),
1666                     0x395 => array(0x3B5), 0x396 => array(0x3B6), 0x397 => array(0x3B7),
1667                     0x398 => array(0x3B8), 0x399 => array(0x3B9), 0x39A => array(0x3BA),
1668                     0x39B => array(0x3BB), 0x39C => array(0x3BC), 0x39D => array(0x3BD),
1669                     0x39E => array(0x3BE), 0x39F => array(0x3BF), 0x3A0 => array(0x3C0),
1670                     0x3A1 => array(0x3C1), 0x3A3 => array(0x3C3), 0x3A4 => array(0x3C4),
1671                     0x3A5 => array(0x3C5), 0x3A6 => array(0x3C6), 0x3A7 => array(0x3C7),
1672                     0x3A8 => array(0x3C8), 0x3A9 => array(0x3C9), 0x3AA => array(0x3CA),
1673                     0x3AB => array(0x3CB), 0x3CF => array(0x3D7), 0x3D0 => array(0x3B2),
1674                     0x3D1 => array(0x3B8), 0x3D2 => array(0x3C5), 0x3D3 => array(0x3CD),
1675                     0x3D4 => array(0x3CB), 0x3D5 => array(0x3C6), 0x3D6 => array(0x3C0),
1676                     0x3D8 => array(0x3D9), 0x3DA => array(0x3DB), 0x3DC => array(0x3DD),
1677                     0x3DE => array(0x3DF), 0x3E0 => array(0x3E1), 0x3E2 => array(0x3E3),
1678                     0x3E4 => array(0x3E5), 0x3E6 => array(0x3E7), 0x3E8 => array(0x3E9),
1679                     0x3EA => array(0x3EB), 0x3EC => array(0x3ED), 0x3EE => array(0x3EF),
1680                     0x3F0 => array(0x3BA), 0x3F1 => array(0x3C1), 0x3F2 => array(0x3C3),
1681                     0x3F4 => array(0x3B8), 0x3F5 => array(0x3B5), 0x3F7 => array(0x3F8),
1682                     0x3F9 => array(0x3C3), 0x3FA => array(0x3FB), 0x3FD => array(0x37B),
1683                     0x3FE => array(0x37C), 0x3FF => array(0x37D), 0x400 => array(0x450),
1684                     0x401 => array(0x451), 0x402 => array(0x452), 0x403 => array(0x453),
1685                     0x404 => array(0x454), 0x405 => array(0x455), 0x406 => array(0x456),
1686                     0x407 => array(0x457), 0x408 => array(0x458), 0x409 => array(0x459),
1687                     0x40A => array(0x45A), 0x40B => array(0x45B), 0x40C => array(0x45C),
1688                     0x40D => array(0x45D), 0x40E => array(0x45E), 0x40F => array(0x45F),
1689                     0x410 => array(0x430), 0x411 => array(0x431), 0x412 => array(0x432),
1690                     0x413 => array(0x433), 0x414 => array(0x434), 0x415 => array(0x435),
1691                     0x416 => array(0x436), 0x417 => array(0x437), 0x418 => array(0x438),
1692                     0x419 => array(0x439), 0x41A => array(0x43A), 0x41B => array(0x43B),
1693                     0x41C => array(0x43C), 0x41D => array(0x43D), 0x41E => array(0x43E),
1694                     0x41F => array(0x43F), 0x420 => array(0x440), 0x421 => array(0x441),
1695                     0x422 => array(0x442), 0x423 => array(0x443), 0x424 => array(0x444),
1696                     0x425 => array(0x445), 0x426 => array(0x446), 0x427 => array(0x447),
1697                     0x428 => array(0x448), 0x429 => array(0x449), 0x42A => array(0x44A),
1698                     0x42B => array(0x44B), 0x42C => array(0x44C), 0x42D => array(0x44D),
1699                     0x42E => array(0x44E), 0x42F => array(0x44F), 0x460 => array(0x461),
1700                     0x462 => array(0x463), 0x464 => array(0x465), 0x466 => array(0x467),
1701                     0x468 => array(0x469), 0x46A => array(0x46B), 0x46C => array(0x46D),
1702                     0x46E => array(0x46F), 0x470 => array(0x471), 0x472 => array(0x473),
1703                     0x474 => array(0x475), 0x476 => array(0x477), 0x478 => array(0x479),
1704                     0x47A => array(0x47B), 0x47C => array(0x47D), 0x47E => array(0x47F),
1705                     0x480 => array(0x481), 0x48A => array(0x48B), 0x48C => array(0x48D),
1706                     0x48E => array(0x48F), 0x490 => array(0x491), 0x492 => array(0x493),
1707                     0x494 => array(0x495), 0x496 => array(0x497), 0x498 => array(0x499),
1708                     0x49A => array(0x49B), 0x49C => array(0x49D), 0x49E => array(0x49F),
1709                     0x4A0 => array(0x4A1), 0x4A2 => array(0x4A3), 0x4A4 => array(0x4A5),
1710                     0x4A6 => array(0x4A7), 0x4A8 => array(0x4A9), 0x4AA => array(0x4AB),
1711                     0x4AC => array(0x4AD), 0x4AE => array(0x4AF), 0x4B0 => array(0x4B1),
1712                     0x4B2 => array(0x4B3), 0x4B4 => array(0x4B5), 0x4B6 => array(0x4B7),
1713                     0x4B8 => array(0x4B9), 0x4BA => array(0x4BB), 0x4BC => array(0x4BD),
1714                     0x4BE => array(0x4BF), 0x4C1 => array(0x4C2), 0x4C3 => array(0x4C4),
1715                     0x4C5 => array(0x4C6), 0x4C7 => array(0x4C8), 0x4C9 => array(0x4CA),
1716                     0x4CB => array(0x4CC), 0x4CD => array(0x4CE), 0x4D0 => array(0x4D1),
1717                     0x4D2 => array(0x4D3), 0x4D4 => array(0x4D5), 0x4D6 => array(0x4D7),
1718                     0x4D8 => array(0x4D9), 0x4DA => array(0x4DB), 0x4DC => array(0x4DD),
1719                     0x4DE => array(0x4DF), 0x4E0 => array(0x4E1), 0x4E2 => array(0x4E3),
1720                     0x4E4 => array(0x4E5), 0x4E6 => array(0x4E7), 0x4E8 => array(0x4E9),
1721                     0x4EA => array(0x4EB), 0x4EC => array(0x4ED), 0x4EE => array(0x4EF),
1722                     0x4F0 => array(0x4F1), 0x4F2 => array(0x4F3), 0x4F4 => array(0x4F5),
1723                     0x4F6 => array(0x4F7), 0x4F8 => array(0x4F9), 0x4FA => array(0x4FB),
1724                     0x4FC => array(0x4FD), 0x4FE => array(0x4FF), 0x500 => array(0x501),
1725                     0x502 => array(0x503), 0x504 => array(0x505), 0x506 => array(0x507),
1726                     0x508 => array(0x509), 0x50A => array(0x50B), 0x50C => array(0x50D),
1727                     0x50E => array(0x50F), 0x510 => array(0x511), 0x512 => array(0x513),
1728                     0x514 => array(0x515), 0x516 => array(0x517), 0x518 => array(0x519),
1729                     0x51A => array(0x51B), 0x51C => array(0x51D), 0x51E => array(0x51F),
1730                     0x520 => array(0x521), 0x522 => array(0x523), 0x524 => array(0x525),
1731                     0x526 => array(0x527), 0x528 => array(0x529), 0x52A => array(0x52B),
1732                     0x52C => array(0x52D), 0x52E => array(0x52F), 0x531 => array(0x561),
1733                     0x532 => array(0x562), 0x533 => array(0x563), 0x534 => array(0x564),
1734                     0x535 => array(0x565), 0x536 => array(0x566), 0x537 => array(0x567),
1735                     0x538 => array(0x568), 0x539 => array(0x569), 0x53A => array(0x56A),
1736                     0x53B => array(0x56B), 0x53C => array(0x56C), 0x53D => array(0x56D),
1737                     0x53E => array(0x56E), 0x53F => array(0x56F), 0x540 => array(0x570),
1738                     0x541 => array(0x571), 0x542 => array(0x572), 0x543 => array(0x573),
1739                     0x544 => array(0x574), 0x545 => array(0x575), 0x546 => array(0x576),
1740                     0x547 => array(0x577), 0x548 => array(0x578), 0x549 => array(0x579),
1741                     0x54A => array(0x57A), 0x54B => array(0x57B), 0x54C => array(0x57C),
1742                     0x54D => array(0x57D), 0x54E => array(0x57E), 0x54F => array(0x57F),
1743                     0x550 => array(0x580), 0x551 => array(0x581), 0x552 => array(0x582),
1744                     0x553 => array(0x583), 0x554 => array(0x584), 0x555 => array(0x585),
1745                     0x556 => array(0x586), 0x587 => array(0x565, 0x582), 0x675 => array(0x627, 0x674),
1746                     0x676 => array(0x648, 0x674), 0x677 => array(0x6C7, 0x674), 0x678 => array(0x64A, 0x674),
1747                     0x958 => array(0x915, 0x93C), 0x959 => array(0x916, 0x93C), 0x95A => array(0x917, 0x93C),
1748                     0x95B => array(0x91C, 0x93C), 0x95C => array(0x921, 0x93C), 0x95D => array(0x922, 0x93C),
1749                     0x95E => array(0x92B, 0x93C), 0x95F => array(0x92F, 0x93C), 0x9DC => array(0x9A1, 0x9BC),
1750                     0x9DD => array(0x9A2, 0x9BC), 0x9DF => array(0x9AF, 0x9BC), 0xA33 => array(0xA32, 0xA3C),
1751                     0xA36 => array(0xA38, 0xA3C), 0xA59 => array(0xA16, 0xA3C), 0xA5A => array(0xA17, 0xA3C),
1752                     0xA5B => array(0xA1C, 0xA3C), 0xA5E => array(0xA2B, 0xA3C), 0xB5C => array(0xB21, 0xB3C),
1753                     0xB5D => array(0xB22, 0xB3C), 0xE33 => array(0xE4D, 0xE32), 0xEB3 => array(0xECD, 0xEB2),
1754                     0xEDC => array(0xEAB, 0xE99), 0xEDD => array(0xEAB, 0xEA1), 0xF0C => array(0xF0B),
1755                     0xF43 => array(0xF42, 0xFB7), 0xF4D => array(0xF4C, 0xFB7), 0xF52 => array(0xF51, 0xFB7),
1756                     0xF57 => array(0xF56, 0xFB7), 0xF5C => array(0xF5B, 0xFB7), 0xF69 => array(0xF40, 0xFB5),
1757                     0xF73 => array(0xF71, 0xF72), 0xF75 => array(0xF71, 0xF74), 0xF76 => array(0xFB2, 0xF80),
1758                     0xF77 => array(0xFB2, 0xF71, 0xF80), 0xF78 => array(0xFB3, 0xF80), 0xF79 => array(0xFB3, 0xF71, 0xF80),
1759                     0xF81 => array(0xF71, 0xF80), 0xF93 => array(0xF92, 0xFB7), 0xF9D => array(0xF9C, 0xFB7),
1760                     0xFA2 => array(0xFA1, 0xFB7), 0xFA7 => array(0xFA6, 0xFB7), 0xFAC => array(0xFAB, 0xFB7),
1761                     0xFB9 => array(0xF90, 0xFB5), 0x10C7 => array(0x2D27), 0x10CD => array(0x2D2D),
1762                     0x10FC => array(0x10DC), 0x1D2C => array(0x61), 0x1D2D => array(0xE6),
1763                     0x1D2E => array(0x62), 0x1D30 => array(0x64), 0x1D31 => array(0x65),
1764                     0x1D32 => array(0x1DD), 0x1D33 => array(0x67), 0x1D34 => array(0x68),
1765                     0x1D35 => array(0x69), 0x1D36 => array(0x6A), 0x1D37 => array(0x6B),
1766                     0x1D38 => array(0x6C), 0x1D39 => array(0x6D), 0x1D3A => array(0x6E),
1767                     0x1D3C => array(0x6F), 0x1D3D => array(0x223), 0x1D3E => array(0x70),
1768                     0x1D3F => array(0x72), 0x1D40 => array(0x74), 0x1D41 => array(0x75),
1769                     0x1D42 => array(0x77), 0x1D43 => array(0x61), 0x1D44 => array(0x250),
1770                     0x1D45 => array(0x251), 0x1D46 => array(0x1D02), 0x1D47 => array(0x62),
1771                     0x1D48 => array(0x64), 0x1D49 => array(0x65), 0x1D4A => array(0x259),
1772                     0x1D4B => array(0x25B), 0x1D4C => array(0x25C), 0x1D4D => array(0x67),
1773                     0x1D4F => array(0x6B), 0x1D50 => array(0x6D), 0x1D51 => array(0x14B),
1774                     0x1D52 => array(0x6F), 0x1D53 => array(0x254), 0x1D54 => array(0x1D16),
1775                     0x1D55 => array(0x1D17), 0x1D56 => array(0x70), 0x1D57 => array(0x74),
1776                     0x1D58 => array(0x75), 0x1D59 => array(0x1D1D), 0x1D5A => array(0x26F),
1777                     0x1D5B => array(0x76), 0x1D5C => array(0x1D25), 0x1D5D => array(0x3B2),
1778                     0x1D5E => array(0x3B3), 0x1D5F => array(0x3B4), 0x1D60 => array(0x3C6),
1779                     0x1D61 => array(0x3C7), 0x1D62 => array(0x69), 0x1D63 => array(0x72),
1780                     0x1D64 => array(0x75), 0x1D65 => array(0x76), 0x1D66 => array(0x3B2),
1781                     0x1D67 => array(0x3B3), 0x1D68 => array(0x3C1), 0x1D69 => array(0x3C6),
1782                     0x1D6A => array(0x3C7), 0x1D78 => array(0x43D), 0x1D9B => array(0x252),
1783                     0x1D9C => array(0x63), 0x1D9D => array(0x255), 0x1D9E => array(0xF0),
1784                     0x1D9F => array(0x25C), 0x1DA0 => array(0x66), 0x1DA1 => array(0x25F),
1785                     0x1DA2 => array(0x261), 0x1DA3 => array(0x265), 0x1DA4 => array(0x268),
1786                     0x1DA5 => array(0x269), 0x1DA6 => array(0x26A), 0x1DA7 => array(0x1D7B),
1787                     0x1DA8 => array(0x29D), 0x1DA9 => array(0x26D), 0x1DAA => array(0x1D85),
1788                     0x1DAB => array(0x29F), 0x1DAC => array(0x271), 0x1DAD => array(0x270),
1789                     0x1DAE => array(0x272), 0x1DAF => array(0x273), 0x1DB0 => array(0x274),
1790                     0x1DB1 => array(0x275), 0x1DB2 => array(0x278), 0x1DB3 => array(0x282),
1791                     0x1DB4 => array(0x283), 0x1DB5 => array(0x1AB), 0x1DB6 => array(0x289),
1792                     0x1DB7 => array(0x28A), 0x1DB8 => array(0x1D1C), 0x1DB9 => array(0x28B),
1793                     0x1DBA => array(0x28C), 0x1DBB => array(0x7A), 0x1DBC => array(0x290),
1794                     0x1DBD => array(0x291), 0x1DBE => array(0x292), 0x1DBF => array(0x3B8),
1795                     0x1E00 => array(0x1E01), 0x1E02 => array(0x1E03), 0x1E04 => array(0x1E05),
1796                     0x1E06 => array(0x1E07), 0x1E08 => array(0x1E09), 0x1E0A => array(0x1E0B),
1797                     0x1E0C => array(0x1E0D), 0x1E0E => array(0x1E0F), 0x1E10 => array(0x1E11),
1798                     0x1E12 => array(0x1E13), 0x1E14 => array(0x1E15), 0x1E16 => array(0x1E17),
1799                     0x1E18 => array(0x1E19), 0x1E1A => array(0x1E1B), 0x1E1C => array(0x1E1D),
1800                     0x1E1E => array(0x1E1F), 0x1E20 => array(0x1E21), 0x1E22 => array(0x1E23),
1801                     0x1E24 => array(0x1E25), 0x1E26 => array(0x1E27), 0x1E28 => array(0x1E29),
1802                     0x1E2A => array(0x1E2B), 0x1E2C => array(0x1E2D), 0x1E2E => array(0x1E2F),
1803                     0x1E30 => array(0x1E31), 0x1E32 => array(0x1E33), 0x1E34 => array(0x1E35),
1804                     0x1E36 => array(0x1E37), 0x1E38 => array(0x1E39), 0x1E3A => array(0x1E3B),
1805                     0x1E3C => array(0x1E3D), 0x1E3E => array(0x1E3F), 0x1E40 => array(0x1E41),
1806                     0x1E42 => array(0x1E43), 0x1E44 => array(0x1E45), 0x1E46 => array(0x1E47),
1807                     0x1E48 => array(0x1E49), 0x1E4A => array(0x1E4B), 0x1E4C => array(0x1E4D),
1808                     0x1E4E => array(0x1E4F), 0x1E50 => array(0x1E51), 0x1E52 => array(0x1E53),
1809                     0x1E54 => array(0x1E55), 0x1E56 => array(0x1E57), 0x1E58 => array(0x1E59),
1810                     0x1E5A => array(0x1E5B), 0x1E5C => array(0x1E5D), 0x1E5E => array(0x1E5F),
1811                     0x1E60 => array(0x1E61), 0x1E62 => array(0x1E63), 0x1E64 => array(0x1E65),
1812                     0x1E66 => array(0x1E67), 0x1E68 => array(0x1E69), 0x1E6A => array(0x1E6B),
1813                     0x1E6C => array(0x1E6D), 0x1E6E => array(0x1E6F), 0x1E70 => array(0x1E71),
1814                     0x1E72 => array(0x1E73), 0x1E74 => array(0x1E75), 0x1E76 => array(0x1E77),
1815                     0x1E78 => array(0x1E79), 0x1E7A => array(0x1E7B), 0x1E7C => array(0x1E7D),
1816                     0x1E7E => array(0x1E7F), 0x1E80 => array(0x1E81), 0x1E82 => array(0x1E83),
1817                     0x1E84 => array(0x1E85), 0x1E86 => array(0x1E87), 0x1E88 => array(0x1E89),
1818                     0x1E8A => array(0x1E8B), 0x1E8C => array(0x1E8D), 0x1E8E => array(0x1E8F),
1819                     0x1E90 => array(0x1E91), 0x1E92 => array(0x1E93), 0x1E94 => array(0x1E95),
1820                     0x1E9A => array(0x61, 0x2BE), 0x1E9B => array(0x1E61), 0x1E9E => array(0x73, 0x73),
1821                     0x1EA0 => array(0x1EA1), 0x1EA2 => array(0x1EA3), 0x1EA4 => array(0x1EA5),
1822                     0x1EA6 => array(0x1EA7), 0x1EA8 => array(0x1EA9), 0x1EAA => array(0x1EAB),
1823                     0x1EAC => array(0x1EAD), 0x1EAE => array(0x1EAF), 0x1EB0 => array(0x1EB1),
1824                     0x1EB2 => array(0x1EB3), 0x1EB4 => array(0x1EB5), 0x1EB6 => array(0x1EB7),
1825                     0x1EB8 => array(0x1EB9), 0x1EBA => array(0x1EBB), 0x1EBC => array(0x1EBD),
1826                     0x1EBE => array(0x1EBF), 0x1EC0 => array(0x1EC1), 0x1EC2 => array(0x1EC3),
1827                     0x1EC4 => array(0x1EC5), 0x1EC6 => array(0x1EC7), 0x1EC8 => array(0x1EC9),
1828                     0x1ECA => array(0x1ECB), 0x1ECC => array(0x1ECD), 0x1ECE => array(0x1ECF),
1829                     0x1ED0 => array(0x1ED1), 0x1ED2 => array(0x1ED3), 0x1ED4 => array(0x1ED5),
1830                     0x1ED6 => array(0x1ED7), 0x1ED8 => array(0x1ED9), 0x1EDA => array(0x1EDB),
1831                     0x1EDC => array(0x1EDD), 0x1EDE => array(0x1EDF), 0x1EE0 => array(0x1EE1),
1832                     0x1EE2 => array(0x1EE3), 0x1EE4 => array(0x1EE5), 0x1EE6 => array(0x1EE7),
1833                     0x1EE8 => array(0x1EE9), 0x1EEA => array(0x1EEB), 0x1EEC => array(0x1EED),
1834                     0x1EEE => array(0x1EEF), 0x1EF0 => array(0x1EF1), 0x1EF2 => array(0x1EF3),
1835                     0x1EF4 => array(0x1EF5), 0x1EF6 => array(0x1EF7), 0x1EF8 => array(0x1EF9),
1836                     0x1EFA => array(0x1EFB), 0x1EFC => array(0x1EFD), 0x1EFE => array(0x1EFF),
1837                     0x1F08 => array(0x1F00), 0x1F09 => array(0x1F01), 0x1F0A => array(0x1F02),
1838                     0x1F0B => array(0x1F03), 0x1F0C => array(0x1F04), 0x1F0D => array(0x1F05),
1839                     0x1F0E => array(0x1F06), 0x1F0F => array(0x1F07), 0x1F18 => array(0x1F10),
1840                     0x1F19 => array(0x1F11), 0x1F1A => array(0x1F12), 0x1F1B => array(0x1F13),
1841                     0x1F1C => array(0x1F14), 0x1F1D => array(0x1F15), 0x1F28 => array(0x1F20),
1842                     0x1F29 => array(0x1F21), 0x1F2A => array(0x1F22), 0x1F2B => array(0x1F23),
1843                     0x1F2C => array(0x1F24), 0x1F2D => array(0x1F25), 0x1F2E => array(0x1F26),
1844                     0x1F2F => array(0x1F27), 0x1F38 => array(0x1F30), 0x1F39 => array(0x1F31),
1845                     0x1F3A => array(0x1F32), 0x1F3B => array(0x1F33), 0x1F3C => array(0x1F34),
1846                     0x1F3D => array(0x1F35), 0x1F3E => array(0x1F36), 0x1F3F => array(0x1F37),
1847                     0x1F48 => array(0x1F40), 0x1F49 => array(0x1F41), 0x1F4A => array(0x1F42),
1848                     0x1F4B => array(0x1F43), 0x1F4C => array(0x1F44), 0x1F4D => array(0x1F45),
1849                     0x1F59 => array(0x1F51), 0x1F5B => array(0x1F53), 0x1F5D => array(0x1F55),
1850                     0x1F5F => array(0x1F57), 0x1F68 => array(0x1F60), 0x1F69 => array(0x1F61),
1851                     0x1F6A => array(0x1F62), 0x1F6B => array(0x1F63), 0x1F6C => array(0x1F64),
1852                     0x1F6D => array(0x1F65), 0x1F6E => array(0x1F66), 0x1F6F => array(0x1F67),
1853                     0x1F71 => array(0x3AC), 0x1F73 => array(0x3AD), 0x1F75 => array(0x3AE),
1854                     0x1F77 => array(0x3AF), 0x1F79 => array(0x3CC), 0x1F7B => array(0x3CD),
1855                     0x1F7D => array(0x3CE), 0x1F80 => array(0x1F00, 0x3B9), 0x1F81 => array(0x1F01, 0x3B9),
1856                     0x1F82 => array(0x1F02, 0x3B9), 0x1F83 => array(0x1F03, 0x3B9), 0x1F84 => array(0x1F04, 0x3B9),
1857                     0x1F85 => array(0x1F05, 0x3B9), 0x1F86 => array(0x1F06, 0x3B9), 0x1F87 => array(0x1F07, 0x3B9),
1858                     0x1F88 => array(0x1F00, 0x3B9), 0x1F89 => array(0x1F01, 0x3B9), 0x1F8A => array(0x1F02, 0x3B9),
1859                     0x1F8B => array(0x1F03, 0x3B9), 0x1F8C => array(0x1F04, 0x3B9), 0x1F8D => array(0x1F05, 0x3B9),
1860                     0x1F8E => array(0x1F06, 0x3B9), 0x1F8F => array(0x1F07, 0x3B9), 0x1F90 => array(0x1F20, 0x3B9),
1861                     0x1F91 => array(0x1F21, 0x3B9), 0x1F92 => array(0x1F22, 0x3B9), 0x1F93 => array(0x1F23, 0x3B9),
1862                     0x1F94 => array(0x1F24, 0x3B9), 0x1F95 => array(0x1F25, 0x3B9), 0x1F96 => array(0x1F26, 0x3B9),
1863                     0x1F97 => array(0x1F27, 0x3B9), 0x1F98 => array(0x1F20, 0x3B9), 0x1F99 => array(0x1F21, 0x3B9),
1864                     0x1F9A => array(0x1F22, 0x3B9), 0x1F9B => array(0x1F23, 0x3B9), 0x1F9C => array(0x1F24, 0x3B9),
1865                     0x1F9D => array(0x1F25, 0x3B9), 0x1F9E => array(0x1F26, 0x3B9), 0x1F9F => array(0x1F27, 0x3B9),
1866                     0x1FA0 => array(0x1F60, 0x3B9), 0x1FA1 => array(0x1F61, 0x3B9), 0x1FA2 => array(0x1F62, 0x3B9),
1867                     0x1FA3 => array(0x1F63, 0x3B9), 0x1FA4 => array(0x1F64, 0x3B9), 0x1FA5 => array(0x1F65, 0x3B9),
1868                     0x1FA6 => array(0x1F66, 0x3B9), 0x1FA7 => array(0x1F67, 0x3B9), 0x1FA8 => array(0x1F60, 0x3B9),
1869                     0x1FA9 => array(0x1F61, 0x3B9), 0x1FAA => array(0x1F62, 0x3B9), 0x1FAB => array(0x1F63, 0x3B9),
1870                     0x1FAC => array(0x1F64, 0x3B9), 0x1FAD => array(0x1F65, 0x3B9), 0x1FAE => array(0x1F66, 0x3B9),
1871                     0x1FAF => array(0x1F67, 0x3B9), 0x1FB2 => array(0x1F70, 0x3B9), 0x1FB3 => array(0x3B1, 0x3B9),
1872                     0x1FB4 => array(0x3AC, 0x3B9), 0x1FB7 => array(0x1FB6, 0x3B9), 0x1FB8 => array(0x1FB0),
1873                     0x1FB9 => array(0x1FB1), 0x1FBA => array(0x1F70), 0x1FBB => array(0x3AC),
1874                     0x1FBC => array(0x3B1, 0x3B9), 0x1FBE => array(0x3B9), 0x1FC2 => array(0x1F74, 0x3B9),
1875                     0x1FC3 => array(0x3B7, 0x3B9), 0x1FC4 => array(0x3AE, 0x3B9), 0x1FC7 => array(0x1FC6, 0x3B9),
1876                     0x1FC8 => array(0x1F72), 0x1FC9 => array(0x3AD), 0x1FCA => array(0x1F74),
1877                     0x1FCB => array(0x3AE), 0x1FCC => array(0x3B7, 0x3B9), 0x1FD3 => array(0x390),
1878                     0x1FD8 => array(0x1FD0), 0x1FD9 => array(0x1FD1), 0x1FDA => array(0x1F76),
1879                     0x1FDB => array(0x3AF), 0x1FE3 => array(0x3B0), 0x1FE8 => array(0x1FE0),
1880                     0x1FE9 => array(0x1FE1), 0x1FEA => array(0x1F7A), 0x1FEB => array(0x3CD),
1881                     0x1FEC => array(0x1FE5), 0x1FF2 => array(0x1F7C, 0x3B9), 0x1FF3 => array(0x3C9, 0x3B9),
1882                     0x1FF4 => array(0x3CE, 0x3B9), 0x1FF7 => array(0x1FF6, 0x3B9), 0x1FF8 => array(0x1F78),
1883                     0x1FF9 => array(0x3CC), 0x1FFA => array(0x1F7C), 0x1FFB => array(0x3CE),
1884                     0x1FFC => array(0x3C9, 0x3B9), 0x2011 => array(0x2010), 0x2033 => array(0x2032, 0x2032),
1885                     0x2034 => array(0x2032, 0x2032, 0x2032), 0x2036 => array(0x2035, 0x2035), 0x2037 => array(0x2035, 0x2035, 0x2035),
1886                     0x2057 => array(0x2032, 0x2032, 0x2032, 0x2032), 0x2070 => array(0x30), 0x2071 => array(0x69),
1887                     0x2074 => array(0x34), 0x2075 => array(0x35), 0x2076 => array(0x36),
1888                     0x2077 => array(0x37), 0x2078 => array(0x38), 0x2079 => array(0x39),
1889                     0x207B => array(0x2212), 0x207F => array(0x6E), 0x2080 => array(0x30),
1890                     0x2081 => array(0x31), 0x2082 => array(0x32), 0x2083 => array(0x33),
1891                     0x2084 => array(0x34), 0x2085 => array(0x35), 0x2086 => array(0x36),
1892                     0x2087 => array(0x37), 0x2088 => array(0x38), 0x2089 => array(0x39),
1893                     0x208B => array(0x2212), 0x2090 => array(0x61), 0x2091 => array(0x65),
1894                     0x2092 => array(0x6F), 0x2093 => array(0x78), 0x2094 => array(0x259),
1895                     0x2095 => array(0x68), 0x2096 => array(0x6B), 0x2097 => array(0x6C),
1896                     0x2098 => array(0x6D), 0x2099 => array(0x6E), 0x209A => array(0x70),
1897                     0x209B => array(0x73), 0x209C => array(0x74), 0x20A8 => array(0x72, 0x73),
1898                     0x2102 => array(0x63), 0x2103 => array(0xB0, 0x63), 0x2107 => array(0x25B),
1899                     0x2109 => array(0xB0, 0x66), 0x210A => array(0x67), 0x210B => array(0x68),
1900                     0x210C => array(0x68), 0x210D => array(0x68), 0x210E => array(0x68),
1901                     0x210F => array(0x127), 0x2110 => array(0x69), 0x2111 => array(0x69),
1902                     0x2112 => array(0x6C), 0x2113 => array(0x6C), 0x2115 => array(0x6E),
1903                     0x2116 => array(0x6E, 0x6F), 0x2119 => array(0x70), 0x211A => array(0x71),
1904                     0x211B => array(0x72), 0x211C => array(0x72), 0x211D => array(0x72),
1905                     0x2120 => array(0x73, 0x6D), 0x2121 => array(0x74, 0x65, 0x6C), 0x2122 => array(0x74, 0x6D),
1906                     0x2124 => array(0x7A), 0x2126 => array(0x3C9), 0x2128 => array(0x7A),
1907                     0x212A => array(0x6B), 0x212B => array(0xE5), 0x212C => array(0x62),
1908                     0x212D => array(0x63), 0x212F => array(0x65), 0x2130 => array(0x65),
1909                     0x2131 => array(0x66), 0x2133 => array(0x6D), 0x2134 => array(0x6F),
1910                     0x2135 => array(0x5D0), 0x2136 => array(0x5D1), 0x2137 => array(0x5D2),
1911                     0x2138 => array(0x5D3), 0x2139 => array(0x69), 0x213B => array(0x66, 0x61, 0x78),
1912                     0x213C => array(0x3C0), 0x213D => array(0x3B3), 0x213E => array(0x3B3),
1913                     0x213F => array(0x3C0), 0x2140 => array(0x2211), 0x2145 => array(0x64),
1914                     0x2146 => array(0x64), 0x2147 => array(0x65), 0x2148 => array(0x69),
1915                     0x2149 => array(0x6A), 0x2150 => array(0x31, 0x2044, 0x37), 0x2151 => array(0x31, 0x2044, 0x39),
1916                     0x2152 => array(0x31, 0x2044, 0x31, 0x30), 0x2153 => array(0x31, 0x2044, 0x33), 0x2154 => array(0x32, 0x2044, 0x33),
1917                     0x2155 => array(0x31, 0x2044, 0x35), 0x2156 => array(0x32, 0x2044, 0x35), 0x2157 => array(0x33, 0x2044, 0x35),
1918                     0x2158 => array(0x34, 0x2044, 0x35), 0x2159 => array(0x31, 0x2044, 0x36), 0x215A => array(0x35, 0x2044, 0x36),
1919                     0x215B => array(0x31, 0x2044, 0x38), 0x215C => array(0x33, 0x2044, 0x38), 0x215D => array(0x35, 0x2044, 0x38),
1920                     0x215E => array(0x37, 0x2044, 0x38), 0x215F => array(0x31, 0x2044), 0x2160 => array(0x69),
1921                     0x2161 => array(0x69, 0x69), 0x2162 => array(0x69, 0x69, 0x69), 0x2163 => array(0x69, 0x76),
1922                     0x2164 => array(0x76), 0x2165 => array(0x76, 0x69), 0x2166 => array(0x76, 0x69, 0x69),
1923                     0x2167 => array(0x76, 0x69, 0x69, 0x69), 0x2168 => array(0x69, 0x78), 0x2169 => array(0x78),
1924                     0x216A => array(0x78, 0x69), 0x216B => array(0x78, 0x69, 0x69), 0x216C => array(0x6C),
1925                     0x216D => array(0x63), 0x216E => array(0x64), 0x216F => array(0x6D),
1926                     0x2170 => array(0x69), 0x2171 => array(0x69, 0x69), 0x2172 => array(0x69, 0x69, 0x69),
1927                     0x2173 => array(0x69, 0x76), 0x2174 => array(0x76), 0x2175 => array(0x76, 0x69),
1928                     0x2176 => array(0x76, 0x69, 0x69), 0x2177 => array(0x76, 0x69, 0x69, 0x69), 0x2178 => array(0x69, 0x78),
1929                     0x2179 => array(0x78), 0x217A => array(0x78, 0x69), 0x217B => array(0x78, 0x69, 0x69),
1930                     0x217C => array(0x6C), 0x217D => array(0x63), 0x217E => array(0x64),
1931                     0x217F => array(0x6D), 0x2189 => array(0x30, 0x2044, 0x33), 0x222C => array(0x222B, 0x222B),
1932                     0x222D => array(0x222B, 0x222B, 0x222B), 0x222F => array(0x222E, 0x222E), 0x2230 => array(0x222E, 0x222E, 0x222E),
1933                     0x2329 => array(0x3008), 0x232A => array(0x3009), 0x2460 => array(0x31),
1934                     0x2461 => array(0x32), 0x2462 => array(0x33), 0x2463 => array(0x34),
1935                     0x2464 => array(0x35), 0x2465 => array(0x36), 0x2466 => array(0x37),
1936                     0x2467 => array(0x38), 0x2468 => array(0x39), 0x2469 => array(0x31, 0x30),
1937                     0x246A => array(0x31, 0x31), 0x246B => array(0x31, 0x32), 0x246C => array(0x31, 0x33),
1938                     0x246D => array(0x31, 0x34), 0x246E => array(0x31, 0x35), 0x246F => array(0x31, 0x36),
1939                     0x2470 => array(0x31, 0x37), 0x2471 => array(0x31, 0x38), 0x2472 => array(0x31, 0x39),
1940                     0x2473 => array(0x32, 0x30), 0x24B6 => array(0x61), 0x24B7 => array(0x62),
1941                     0x24B8 => array(0x63), 0x24B9 => array(0x64), 0x24BA => array(0x65),
1942                     0x24BB => array(0x66), 0x24BC => array(0x67), 0x24BD => array(0x68),
1943                     0x24BE => array(0x69), 0x24BF => array(0x6A), 0x24C0 => array(0x6B),
1944                     0x24C1 => array(0x6C), 0x24C2 => array(0x6D), 0x24C3 => array(0x6E),
1945                     0x24C4 => array(0x6F), 0x24C5 => array(0x70), 0x24C6 => array(0x71),
1946                     0x24C7 => array(0x72), 0x24C8 => array(0x73), 0x24C9 => array(0x74),
1947                     0x24CA => array(0x75), 0x24CB => array(0x76), 0x24CC => array(0x77),
1948                     0x24CD => array(0x78), 0x24CE => array(0x79), 0x24CF => array(0x7A),
1949                     0x24D0 => array(0x61), 0x24D1 => array(0x62), 0x24D2 => array(0x63),
1950                     0x24D3 => array(0x64), 0x24D4 => array(0x65), 0x24D5 => array(0x66),
1951                     0x24D6 => array(0x67), 0x24D7 => array(0x68), 0x24D8 => array(0x69),
1952                     0x24D9 => array(0x6A), 0x24DA => array(0x6B), 0x24DB => array(0x6C),
1953                     0x24DC => array(0x6D), 0x24DD => array(0x6E), 0x24DE => array(0x6F),
1954                     0x24DF => array(0x70), 0x24E0 => array(0x71), 0x24E1 => array(0x72),
1955                     0x24E2 => array(0x73), 0x24E3 => array(0x74), 0x24E4 => array(0x75),
1956                     0x24E5 => array(0x76), 0x24E6 => array(0x77), 0x24E7 => array(0x78),
1957                     0x24E8 => array(0x79), 0x24E9 => array(0x7A), 0x24EA => array(0x30),
1958                     0x2A0C => array(0x222B, 0x222B, 0x222B, 0x222B), 0x2ADC => array(0x2ADD, 0x338), 0x2C00 => array(0x2C30),
1959                     0x2C01 => array(0x2C31), 0x2C02 => array(0x2C32), 0x2C03 => array(0x2C33),
1960                     0x2C04 => array(0x2C34), 0x2C05 => array(0x2C35), 0x2C06 => array(0x2C36),
1961                     0x2C07 => array(0x2C37), 0x2C08 => array(0x2C38), 0x2C09 => array(0x2C39),
1962                     0x2C0A => array(0x2C3A), 0x2C0B => array(0x2C3B), 0x2C0C => array(0x2C3C),
1963                     0x2C0D => array(0x2C3D), 0x2C0E => array(0x2C3E), 0x2C0F => array(0x2C3F),
1964                     0x2C10 => array(0x2C40), 0x2C11 => array(0x2C41), 0x2C12 => array(0x2C42),
1965                     0x2C13 => array(0x2C43), 0x2C14 => array(0x2C44), 0x2C15 => array(0x2C45),
1966                     0x2C16 => array(0x2C46), 0x2C17 => array(0x2C47), 0x2C18 => array(0x2C48),
1967                     0x2C19 => array(0x2C49), 0x2C1A => array(0x2C4A), 0x2C1B => array(0x2C4B),
1968                     0x2C1C => array(0x2C4C), 0x2C1D => array(0x2C4D), 0x2C1E => array(0x2C4E),
1969                     0x2C1F => array(0x2C4F), 0x2C20 => array(0x2C50), 0x2C21 => array(0x2C51),
1970                     0x2C22 => array(0x2C52), 0x2C23 => array(0x2C53), 0x2C24 => array(0x2C54),
1971                     0x2C25 => array(0x2C55), 0x2C26 => array(0x2C56), 0x2C27 => array(0x2C57),
1972                     0x2C28 => array(0x2C58), 0x2C29 => array(0x2C59), 0x2C2A => array(0x2C5A),
1973                     0x2C2B => array(0x2C5B), 0x2C2C => array(0x2C5C), 0x2C2D => array(0x2C5D),
1974                     0x2C2E => array(0x2C5E), 0x2C60 => array(0x2C61), 0x2C62 => array(0x26B),
1975                     0x2C63 => array(0x1D7D), 0x2C64 => array(0x27D), 0x2C67 => array(0x2C68),
1976                     0x2C69 => array(0x2C6A), 0x2C6B => array(0x2C6C), 0x2C6D => array(0x251),
1977                     0x2C6E => array(0x271), 0x2C6F => array(0x250), 0x2C70 => array(0x252),
1978                     0x2C72 => array(0x2C73), 0x2C75 => array(0x2C76), 0x2C7C => array(0x6A),
1979                     0x2C7D => array(0x76), 0x2C7E => array(0x23F), 0x2C7F => array(0x240),
1980                     0x2C80 => array(0x2C81), 0x2C82 => array(0x2C83), 0x2C84 => array(0x2C85),
1981                     0x2C86 => array(0x2C87), 0x2C88 => array(0x2C89), 0x2C8A => array(0x2C8B),
1982                     0x2C8C => array(0x2C8D), 0x2C8E => array(0x2C8F), 0x2C90 => array(0x2C91),
1983                     0x2C92 => array(0x2C93), 0x2C94 => array(0x2C95), 0x2C96 => array(0x2C97),
1984                     0x2C98 => array(0x2C99), 0x2C9A => array(0x2C9B), 0x2C9C => array(0x2C9D),
1985                     0x2C9E => array(0x2C9F), 0x2CA0 => array(0x2CA1), 0x2CA2 => array(0x2CA3),
1986                     0x2CA4 => array(0x2CA5), 0x2CA6 => array(0x2CA7), 0x2CA8 => array(0x2CA9),
1987                     0x2CAA => array(0x2CAB), 0x2CAC => array(0x2CAD), 0x2CAE => array(0x2CAF),
1988                     0x2CB0 => array(0x2CB1), 0x2CB2 => array(0x2CB3), 0x2CB4 => array(0x2CB5),
1989                     0x2CB6 => array(0x2CB7), 0x2CB8 => array(0x2CB9), 0x2CBA => array(0x2CBB),
1990                     0x2CBC => array(0x2CBD), 0x2CBE => array(0x2CBF), 0x2CC0 => array(0x2CC1),
1991                     0x2CC2 => array(0x2CC3), 0x2CC4 => array(0x2CC5), 0x2CC6 => array(0x2CC7),
1992                     0x2CC8 => array(0x2CC9), 0x2CCA => array(0x2CCB), 0x2CCC => array(0x2CCD),
1993                     0x2CCE => array(0x2CCF), 0x2CD0 => array(0x2CD1), 0x2CD2 => array(0x2CD3),
1994                     0x2CD4 => array(0x2CD5), 0x2CD6 => array(0x2CD7), 0x2CD8 => array(0x2CD9),
1995                     0x2CDA => array(0x2CDB), 0x2CDC => array(0x2CDD), 0x2CDE => array(0x2CDF),
1996                     0x2CE0 => array(0x2CE1), 0x2CE2 => array(0x2CE3), 0x2CEB => array(0x2CEC),
1997                     0x2CED => array(0x2CEE), 0x2CF2 => array(0x2CF3), 0x2D6F => array(0x2D61),
1998                     0x2E9F => array(0x6BCD), 0x2EF3 => array(0x9F9F), 0x2F00 => array(0x4E00),
1999                     0x2F01 => array(0x4E28), 0x2F02 => array(0x4E36), 0x2F03 => array(0x4E3F),
2000                     0x2F04 => array(0x4E59), 0x2F05 => array(0x4E85), 0x2F06 => array(0x4E8C),
2001                     0x2F07 => array(0x4EA0), 0x2F08 => array(0x4EBA), 0x2F09 => array(0x513F),
2002                     0x2F0A => array(0x5165), 0x2F0B => array(0x516B), 0x2F0C => array(0x5182),
2003                     0x2F0D => array(0x5196), 0x2F0E => array(0x51AB), 0x2F0F => array(0x51E0),
2004                     0x2F10 => array(0x51F5), 0x2F11 => array(0x5200), 0x2F12 => array(0x529B),
2005                     0x2F13 => array(0x52F9), 0x2F14 => array(0x5315), 0x2F15 => array(0x531A),
2006                     0x2F16 => array(0x5338), 0x2F17 => array(0x5341), 0x2F18 => array(0x535C),
2007                     0x2F19 => array(0x5369), 0x2F1A => array(0x5382), 0x2F1B => array(0x53B6),
2008                     0x2F1C => array(0x53C8), 0x2F1D => array(0x53E3), 0x2F1E => array(0x56D7),
2009                     0x2F1F => array(0x571F), 0x2F20 => array(0x58EB), 0x2F21 => array(0x5902),
2010                     0x2F22 => array(0x590A), 0x2F23 => array(0x5915), 0x2F24 => array(0x5927),
2011                     0x2F25 => array(0x5973), 0x2F26 => array(0x5B50), 0x2F27 => array(0x5B80),
2012                     0x2F28 => array(0x5BF8), 0x2F29 => array(0x5C0F), 0x2F2A => array(0x5C22),
2013                     0x2F2B => array(0x5C38), 0x2F2C => array(0x5C6E), 0x2F2D => array(0x5C71),
2014                     0x2F2E => array(0x5DDB), 0x2F2F => array(0x5DE5), 0x2F30 => array(0x5DF1),
2015                     0x2F31 => array(0x5DFE), 0x2F32 => array(0x5E72), 0x2F33 => array(0x5E7A),
2016                     0x2F34 => array(0x5E7F), 0x2F35 => array(0x5EF4), 0x2F36 => array(0x5EFE),
2017                     0x2F37 => array(0x5F0B), 0x2F38 => array(0x5F13), 0x2F39 => array(0x5F50),
2018                     0x2F3A => array(0x5F61), 0x2F3B => array(0x5F73), 0x2F3C => array(0x5FC3),
2019                     0x2F3D => array(0x6208), 0x2F3E => array(0x6236), 0x2F3F => array(0x624B),
2020                     0x2F40 => array(0x652F), 0x2F41 => array(0x6534), 0x2F42 => array(0x6587),
2021                     0x2F43 => array(0x6597), 0x2F44 => array(0x65A4), 0x2F45 => array(0x65B9),
2022                     0x2F46 => array(0x65E0), 0x2F47 => array(0x65E5), 0x2F48 => array(0x66F0),
2023                     0x2F49 => array(0x6708), 0x2F4A => array(0x6728), 0x2F4B => array(0x6B20),
2024                     0x2F4C => array(0x6B62), 0x2F4D => array(0x6B79), 0x2F4E => array(0x6BB3),
2025                     0x2F4F => array(0x6BCB), 0x2F50 => array(0x6BD4), 0x2F51 => array(0x6BDB),
2026                     0x2F52 => array(0x6C0F), 0x2F53 => array(0x6C14), 0x2F54 => array(0x6C34),
2027                     0x2F55 => array(0x706B), 0x2F56 => array(0x722A), 0x2F57 => array(0x7236),
2028                     0x2F58 => array(0x723B), 0x2F59 => array(0x723F), 0x2F5A => array(0x7247),
2029                     0x2F5B => array(0x7259), 0x2F5C => array(0x725B), 0x2F5D => array(0x72AC),
2030                     0x2F5E => array(0x7384), 0x2F5F => array(0x7389), 0x2F60 => array(0x74DC),
2031                     0x2F61 => array(0x74E6), 0x2F62 => array(0x7518), 0x2F63 => array(0x751F),
2032                     0x2F64 => array(0x7528), 0x2F65 => array(0x7530), 0x2F66 => array(0x758B),
2033                     0x2F67 => array(0x7592), 0x2F68 => array(0x7676), 0x2F69 => array(0x767D),
2034                     0x2F6A => array(0x76AE), 0x2F6B => array(0x76BF), 0x2F6C => array(0x76EE),
2035                     0x2F6D => array(0x77DB), 0x2F6E => array(0x77E2), 0x2F6F => array(0x77F3),
2036                     0x2F70 => array(0x793A), 0x2F71 => array(0x79B8), 0x2F72 => array(0x79BE),
2037                     0x2F73 => array(0x7A74), 0x2F74 => array(0x7ACB), 0x2F75 => array(0x7AF9),
2038                     0x2F76 => array(0x7C73), 0x2F77 => array(0x7CF8), 0x2F78 => array(0x7F36),
2039                     0x2F79 => array(0x7F51), 0x2F7A => array(0x7F8A), 0x2F7B => array(0x7FBD),
2040                     0x2F7C => array(0x8001), 0x2F7D => array(0x800C), 0x2F7E => array(0x8012),
2041                     0x2F7F => array(0x8033), 0x2F80 => array(0x807F), 0x2F81 => array(0x8089),
2042                     0x2F82 => array(0x81E3), 0x2F83 => array(0x81EA), 0x2F84 => array(0x81F3),
2043                     0x2F85 => array(0x81FC), 0x2F86 => array(0x820C), 0x2F87 => array(0x821B),
2044                     0x2F88 => array(0x821F), 0x2F89 => array(0x826E), 0x2F8A => array(0x8272),
2045                     0x2F8B => array(0x8278), 0x2F8C => array(0x864D), 0x2F8D => array(0x866B),
2046                     0x2F8E => array(0x8840), 0x2F8F => array(0x884C), 0x2F90 => array(0x8863),
2047                     0x2F91 => array(0x897E), 0x2F92 => array(0x898B), 0x2F93 => array(0x89D2),
2048                     0x2F94 => array(0x8A00), 0x2F95 => array(0x8C37), 0x2F96 => array(0x8C46),
2049                     0x2F97 => array(0x8C55), 0x2F98 => array(0x8C78), 0x2F99 => array(0x8C9D),
2050                     0x2F9A => array(0x8D64), 0x2F9B => array(0x8D70), 0x2F9C => array(0x8DB3),
2051                     0x2F9D => array(0x8EAB), 0x2F9E => array(0x8ECA), 0x2F9F => array(0x8F9B),
2052                     0x2FA0 => array(0x8FB0), 0x2FA1 => array(0x8FB5), 0x2FA2 => array(0x9091),
2053                     0x2FA3 => array(0x9149), 0x2FA4 => array(0x91C6), 0x2FA5 => array(0x91CC),
2054                     0x2FA6 => array(0x91D1), 0x2FA7 => array(0x9577), 0x2FA8 => array(0x9580),
2055                     0x2FA9 => array(0x961C), 0x2FAA => array(0x96B6), 0x2FAB => array(0x96B9),
2056                     0x2FAC => array(0x96E8), 0x2FAD => array(0x9751), 0x2FAE => array(0x975E),
2057                     0x2FAF => array(0x9762), 0x2FB0 => array(0x9769), 0x2FB1 => array(0x97CB),
2058                     0x2FB2 => array(0x97ED), 0x2FB3 => array(0x97F3), 0x2FB4 => array(0x9801),
2059                     0x2FB5 => array(0x98A8), 0x2FB6 => array(0x98DB), 0x2FB7 => array(0x98DF),
2060                     0x2FB8 => array(0x9996), 0x2FB9 => array(0x9999), 0x2FBA => array(0x99AC),
2061                     0x2FBB => array(0x9AA8), 0x2FBC => array(0x9AD8), 0x2FBD => array(0x9ADF),
2062                     0x2FBE => array(0x9B25), 0x2FBF => array(0x9B2F), 0x2FC0 => array(0x9B32),
2063                     0x2FC1 => array(0x9B3C), 0x2FC2 => array(0x9B5A), 0x2FC3 => array(0x9CE5),
2064                     0x2FC4 => array(0x9E75), 0x2FC5 => array(0x9E7F), 0x2FC6 => array(0x9EA5),
2065                     0x2FC7 => array(0x9EBB), 0x2FC8 => array(0x9EC3), 0x2FC9 => array(0x9ECD),
2066                     0x2FCA => array(0x9ED1), 0x2FCB => array(0x9EF9), 0x2FCC => array(0x9EFD),
2067                     0x2FCD => array(0x9F0E), 0x2FCE => array(0x9F13), 0x2FCF => array(0x9F20),
2068                     0x2FD0 => array(0x9F3B), 0x2FD1 => array(0x9F4A), 0x2FD2 => array(0x9F52),
2069                     0x2FD3 => array(0x9F8D), 0x2FD4 => array(0x9F9C), 0x2FD5 => array(0x9FA0),
2070                     0x3002 => array(0x2E), 0x3036 => array(0x3012), 0x3038 => array(0x5341),
2071                     0x3039 => array(0x5344), 0x303A => array(0x5345), 0x309F => array(0x3088, 0x308A),
2072                     0x30FF => array(0x30B3, 0x30C8), 0x3131 => array(0x1100), 0x3132 => array(0x1101),
2073                     0x3133 => array(0x11AA), 0x3134 => array(0x1102), 0x3135 => array(0x11AC),
2074                     0x3136 => array(0x11AD), 0x3137 => array(0x1103), 0x3138 => array(0x1104),
2075                     0x3139 => array(0x1105), 0x313A => array(0x11B0), 0x313B => array(0x11B1),
2076                     0x313C => array(0x11B2), 0x313D => array(0x11B3), 0x313E => array(0x11B4),
2077                     0x313F => array(0x11B5), 0x3140 => array(0x111A), 0x3141 => array(0x1106),
2078                     0x3142 => array(0x1107), 0x3143 => array(0x1108), 0x3144 => array(0x1121),
2079                     0x3145 => array(0x1109), 0x3146 => array(0x110A), 0x3147 => array(0x110B),
2080                     0x3148 => array(0x110C), 0x3149 => array(0x110D), 0x314A => array(0x110E),
2081                     0x314B => array(0x110F), 0x314C => array(0x1110), 0x314D => array(0x1111),
2082                     0x314E => array(0x1112), 0x314F => array(0x1161), 0x3150 => array(0x1162),
2083                     0x3151 => array(0x1163), 0x3152 => array(0x1164), 0x3153 => array(0x1165),
2084                     0x3154 => array(0x1166), 0x3155 => array(0x1167), 0x3156 => array(0x1168),
2085                     0x3157 => array(0x1169), 0x3158 => array(0x116A), 0x3159 => array(0x116B),
2086                     0x315A => array(0x116C), 0x315B => array(0x116D), 0x315C => array(0x116E),
2087                     0x315D => array(0x116F), 0x315E => array(0x1170), 0x315F => array(0x1171),
2088                     0x3160 => array(0x1172), 0x3161 => array(0x1173), 0x3162 => array(0x1174),
2089                     0x3163 => array(0x1175), 0x3165 => array(0x1114), 0x3166 => array(0x1115),
2090                     0x3167 => array(0x11C7), 0x3168 => array(0x11C8), 0x3169 => array(0x11CC),
2091                     0x316A => array(0x11CE), 0x316B => array(0x11D3), 0x316C => array(0x11D7),
2092                     0x316D => array(0x11D9), 0x316E => array(0x111C), 0x316F => array(0x11DD),
2093                     0x3170 => array(0x11DF), 0x3171 => array(0x111D), 0x3172 => array(0x111E),
2094                     0x3173 => array(0x1120), 0x3174 => array(0x1122), 0x3175 => array(0x1123),
2095                     0x3176 => array(0x1127), 0x3177 => array(0x1129), 0x3178 => array(0x112B),
2096                     0x3179 => array(0x112C), 0x317A => array(0x112D), 0x317B => array(0x112E),
2097                     0x317C => array(0x112F), 0x317D => array(0x1132), 0x317E => array(0x1136),
2098                     0x317F => array(0x1140), 0x3180 => array(0x1147), 0x3181 => array(0x114C),
2099                     0x3182 => array(0x11F1), 0x3183 => array(0x11F2), 0x3184 => array(0x1157),
2100                     0x3185 => array(0x1158), 0x3186 => array(0x1159), 0x3187 => array(0x1184),
2101                     0x3188 => array(0x1185), 0x3189 => array(0x1188), 0x318A => array(0x1191),
2102                     0x318B => array(0x1192), 0x318C => array(0x1194), 0x318D => array(0x119E),
2103                     0x318E => array(0x11A1), 0x3192 => array(0x4E00), 0x3193 => array(0x4E8C),
2104                     0x3194 => array(0x4E09), 0x3195 => array(0x56DB), 0x3196 => array(0x4E0A),
2105                     0x3197 => array(0x4E2D), 0x3198 => array(0x4E0B), 0x3199 => array(0x7532),
2106                     0x319A => array(0x4E59), 0x319B => array(0x4E19), 0x319C => array(0x4E01),
2107                     0x319D => array(0x5929), 0x319E => array(0x5730), 0x319F => array(0x4EBA),
2108                     0x3244 => array(0x554F), 0x3245 => array(0x5E7C), 0x3246 => array(0x6587),
2109                     0x3247 => array(0x7B8F), 0x3250 => array(0x70, 0x74, 0x65), 0x3251 => array(0x32, 0x31),
2110                     0x3252 => array(0x32, 0x32), 0x3253 => array(0x32, 0x33), 0x3254 => array(0x32, 0x34),
2111                     0x3255 => array(0x32, 0x35), 0x3256 => array(0x32, 0x36), 0x3257 => array(0x32, 0x37),
2112                     0x3258 => array(0x32, 0x38), 0x3259 => array(0x32, 0x39), 0x325A => array(0x33, 0x30),
2113                     0x325B => array(0x33, 0x31), 0x325C => array(0x33, 0x32), 0x325D => array(0x33, 0x33),
2114                     0x325E => array(0x33, 0x34), 0x325F => array(0x33, 0x35), 0x3260 => array(0x1100),
2115                     0x3261 => array(0x1102), 0x3262 => array(0x1103), 0x3263 => array(0x1105),
2116                     0x3264 => array(0x1106), 0x3265 => array(0x1107), 0x3266 => array(0x1109),
2117                     0x3267 => array(0x110B), 0x3268 => array(0x110C), 0x3269 => array(0x110E),
2118                     0x326A => array(0x110F), 0x326B => array(0x1110), 0x326C => array(0x1111),
2119                     0x326D => array(0x1112), 0x326E => array(0xAC00), 0x326F => array(0xB098),
2120                     0x3270 => array(0xB2E4), 0x3271 => array(0xB77C), 0x3272 => array(0xB9C8),
2121                     0x3273 => array(0xBC14), 0x3274 => array(0xC0AC), 0x3275 => array(0xC544),
2122                     0x3276 => array(0xC790), 0x3277 => array(0xCC28), 0x3278 => array(0xCE74),
2123                     0x3279 => array(0xD0C0), 0x327A => array(0xD30C), 0x327B => array(0xD558),
2124                     0x327C => array(0xCC38, 0xACE0), 0x327D => array(0xC8FC, 0xC758), 0x327E => array(0xC6B0),
2125                     0x3280 => array(0x4E00), 0x3281 => array(0x4E8C), 0x3282 => array(0x4E09),
2126                     0x3283 => array(0x56DB), 0x3284 => array(0x4E94), 0x3285 => array(0x516D),
2127                     0x3286 => array(0x4E03), 0x3287 => array(0x516B), 0x3288 => array(0x4E5D),
2128                     0x3289 => array(0x5341), 0x328A => array(0x6708), 0x328B => array(0x706B),
2129                     0x328C => array(0x6C34), 0x328D => array(0x6728), 0x328E => array(0x91D1),
2130                     0x328F => array(0x571F), 0x3290 => array(0x65E5), 0x3291 => array(0x682A),
2131                     0x3292 => array(0x6709), 0x3293 => array(0x793E), 0x3294 => array(0x540D),
2132                     0x3295 => array(0x7279), 0x3296 => array(0x8CA1), 0x3297 => array(0x795D),
2133                     0x3298 => array(0x52B4), 0x3299 => array(0x79D8), 0x329A => array(0x7537),
2134                     0x329B => array(0x5973), 0x329C => array(0x9069), 0x329D => array(0x512A),
2135                     0x329E => array(0x5370), 0x329F => array(0x6CE8), 0x32A0 => array(0x9805),
2136                     0x32A1 => array(0x4F11), 0x32A2 => array(0x5199), 0x32A3 => array(0x6B63),
2137                     0x32A4 => array(0x4E0A), 0x32A5 => array(0x4E2D), 0x32A6 => array(0x4E0B),
2138                     0x32A7 => array(0x5DE6), 0x32A8 => array(0x53F3), 0x32A9 => array(0x533B),
2139                     0x32AA => array(0x5B97), 0x32AB => array(0x5B66), 0x32AC => array(0x76E3),
2140                     0x32AD => array(0x4F01), 0x32AE => array(0x8CC7), 0x32AF => array(0x5354),
2141                     0x32B0 => array(0x591C), 0x32B1 => array(0x33, 0x36), 0x32B2 => array(0x33, 0x37),
2142                     0x32B3 => array(0x33, 0x38), 0x32B4 => array(0x33, 0x39), 0x32B5 => array(0x34, 0x30),
2143                     0x32B6 => array(0x34, 0x31), 0x32B7 => array(0x34, 0x32), 0x32B8 => array(0x34, 0x33),
2144                     0x32B9 => array(0x34, 0x34), 0x32BA => array(0x34, 0x35), 0x32BB => array(0x34, 0x36),
2145                     0x32BC => array(0x34, 0x37), 0x32BD => array(0x34, 0x38), 0x32BE => array(0x34, 0x39),
2146                     0x32BF => array(0x35, 0x30), 0x32C0 => array(0x31, 0x6708), 0x32C1 => array(0x32, 0x6708),
2147                     0x32C2 => array(0x33, 0x6708), 0x32C3 => array(0x34, 0x6708), 0x32C4 => array(0x35, 0x6708),
2148                     0x32C5 => array(0x36, 0x6708), 0x32C6 => array(0x37, 0x6708), 0x32C7 => array(0x38, 0x6708),
2149                     0x32C8 => array(0x39, 0x6708), 0x32C9 => array(0x31, 0x30, 0x6708), 0x32CA => array(0x31, 0x31, 0x6708),
2150                     0x32CB => array(0x31, 0x32, 0x6708), 0x32CC => array(0x68, 0x67), 0x32CD => array(0x65, 0x72, 0x67),
2151                     0x32CE => array(0x65, 0x76), 0x32CF => array(0x6C, 0x74, 0x64), 0x32D0 => array(0x30A2),
2152                     0x32D1 => array(0x30A4), 0x32D2 => array(0x30A6), 0x32D3 => array(0x30A8),
2153                     0x32D4 => array(0x30AA), 0x32D5 => array(0x30AB), 0x32D6 => array(0x30AD),
2154                     0x32D7 => array(0x30AF), 0x32D8 => array(0x30B1), 0x32D9 => array(0x30B3),
2155                     0x32DA => array(0x30B5), 0x32DB => array(0x30B7), 0x32DC => array(0x30B9),
2156                     0x32DD => array(0x30BB), 0x32DE => array(0x30BD), 0x32DF => array(0x30BF),
2157                     0x32E0 => array(0x30C1), 0x32E1 => array(0x30C4), 0x32E2 => array(0x30C6),
2158                     0x32E3 => array(0x30C8), 0x32E4 => array(0x30CA), 0x32E5 => array(0x30CB),
2159                     0x32E6 => array(0x30CC), 0x32E7 => array(0x30CD), 0x32E8 => array(0x30CE),
2160                     0x32E9 => array(0x30CF), 0x32EA => array(0x30D2), 0x32EB => array(0x30D5),
2161                     0x32EC => array(0x30D8), 0x32ED => array(0x30DB), 0x32EE => array(0x30DE),
2162                     0x32EF => array(0x30DF), 0x32F0 => array(0x30E0), 0x32F1 => array(0x30E1),
2163                     0x32F2 => array(0x30E2), 0x32F3 => array(0x30E4), 0x32F4 => array(0x30E6),
2164                     0x32F5 => array(0x30E8), 0x32F6 => array(0x30E9), 0x32F7 => array(0x30EA),
2165                     0x32F8 => array(0x30EB), 0x32F9 => array(0x30EC), 0x32FA => array(0x30ED),
2166                     0x32FB => array(0x30EF), 0x32FC => array(0x30F0), 0x32FD => array(0x30F1),
2167                     0x32FE => array(0x30F2), 0x3300 => array(0x30A2, 0x30D1, 0x30FC, 0x30C8), 0x3301 => array(0x30A2, 0x30EB, 0x30D5, 0x30A1),
2168                     0x3302 => array(0x30A2, 0x30F3, 0x30DA, 0x30A2), 0x3303 => array(0x30A2, 0x30FC, 0x30EB), 0x3304 => array(0x30A4, 0x30CB, 0x30F3, 0x30B0),
2169                     0x3305 => array(0x30A4, 0x30F3, 0x30C1), 0x3306 => array(0x30A6, 0x30A9, 0x30F3), 0x3307 => array(0x30A8, 0x30B9, 0x30AF, 0x30FC, 0x30C9),
2170                     0x3308 => array(0x30A8, 0x30FC, 0x30AB, 0x30FC), 0x3309 => array(0x30AA, 0x30F3, 0x30B9), 0x330A => array(0x30AA, 0x30FC, 0x30E0),
2171                     0x330B => array(0x30AB, 0x30A4, 0x30EA), 0x330C => array(0x30AB, 0x30E9, 0x30C3, 0x30C8), 0x330D => array(0x30AB, 0x30ED, 0x30EA, 0x30FC),
2172                     0x330E => array(0x30AC, 0x30ED, 0x30F3), 0x330F => array(0x30AC, 0x30F3, 0x30DE), 0x3310 => array(0x30AE, 0x30AC),
2173                     0x3311 => array(0x30AE, 0x30CB, 0x30FC), 0x3312 => array(0x30AD, 0x30E5, 0x30EA, 0x30FC), 0x3313 => array(0x30AE, 0x30EB, 0x30C0, 0x30FC),
2174                     0x3314 => array(0x30AD, 0x30ED), 0x3315 => array(0x30AD, 0x30ED, 0x30B0, 0x30E9, 0x30E0), 0x3316 => array(0x30AD, 0x30ED, 0x30E1, 0x30FC, 0x30C8, 0x30EB),
2175                     0x3317 => array(0x30AD, 0x30ED, 0x30EF, 0x30C3, 0x30C8), 0x3318 => array(0x30B0, 0x30E9, 0x30E0), 0x3319 => array(0x30B0, 0x30E9, 0x30E0, 0x30C8, 0x30F3),
2176                     0x331A => array(0x30AF, 0x30EB, 0x30BC, 0x30A4, 0x30ED), 0x331B => array(0x30AF, 0x30ED, 0x30FC, 0x30CD), 0x331C => array(0x30B1, 0x30FC, 0x30B9),
2177                     0x331D => array(0x30B3, 0x30EB, 0x30CA), 0x331E => array(0x30B3, 0x30FC, 0x30DD), 0x331F => array(0x30B5, 0x30A4, 0x30AF, 0x30EB),
2178                     0x3320 => array(0x30B5, 0x30F3, 0x30C1, 0x30FC, 0x30E0), 0x3321 => array(0x30B7, 0x30EA, 0x30F3, 0x30B0), 0x3322 => array(0x30BB, 0x30F3, 0x30C1),
2179                     0x3323 => array(0x30BB, 0x30F3, 0x30C8), 0x3324 => array(0x30C0, 0x30FC, 0x30B9), 0x3325 => array(0x30C7, 0x30B7),
2180                     0x3326 => array(0x30C9, 0x30EB), 0x3327 => array(0x30C8, 0x30F3), 0x3328 => array(0x30CA, 0x30CE),
2181                     0x3329 => array(0x30CE, 0x30C3, 0x30C8), 0x332A => array(0x30CF, 0x30A4, 0x30C4), 0x332B => array(0x30D1, 0x30FC, 0x30BB, 0x30F3, 0x30C8),
2182                     0x332C => array(0x30D1, 0x30FC, 0x30C4), 0x332D => array(0x30D0, 0x30FC, 0x30EC, 0x30EB), 0x332E => array(0x30D4, 0x30A2, 0x30B9, 0x30C8, 0x30EB),
2183                     0x332F => array(0x30D4, 0x30AF, 0x30EB), 0x3330 => array(0x30D4, 0x30B3), 0x3331 => array(0x30D3, 0x30EB),
2184                     0x3332 => array(0x30D5, 0x30A1, 0x30E9, 0x30C3, 0x30C9), 0x3333 => array(0x30D5, 0x30A3, 0x30FC, 0x30C8), 0x3334 => array(0x30D6, 0x30C3, 0x30B7, 0x30A7, 0x30EB),
2185                     0x3335 => array(0x30D5, 0x30E9, 0x30F3), 0x3336 => array(0x30D8, 0x30AF, 0x30BF, 0x30FC, 0x30EB), 0x3337 => array(0x30DA, 0x30BD),
2186                     0x3338 => array(0x30DA, 0x30CB, 0x30D2), 0x3339 => array(0x30D8, 0x30EB, 0x30C4), 0x333A => array(0x30DA, 0x30F3, 0x30B9),
2187                     0x333B => array(0x30DA, 0x30FC, 0x30B8), 0x333C => array(0x30D9, 0x30FC, 0x30BF), 0x333D => array(0x30DD, 0x30A4, 0x30F3, 0x30C8),
2188                     0x333E => array(0x30DC, 0x30EB, 0x30C8), 0x333F => array(0x30DB, 0x30F3), 0x3340 => array(0x30DD, 0x30F3, 0x30C9),
2189                     0x3341 => array(0x30DB, 0x30FC, 0x30EB), 0x3342 => array(0x30DB, 0x30FC, 0x30F3), 0x3343 => array(0x30DE, 0x30A4, 0x30AF, 0x30ED),
2190                     0x3344 => array(0x30DE, 0x30A4, 0x30EB), 0x3345 => array(0x30DE, 0x30C3, 0x30CF), 0x3346 => array(0x30DE, 0x30EB, 0x30AF),
2191                     0x3347 => array(0x30DE, 0x30F3, 0x30B7, 0x30E7, 0x30F3), 0x3348 => array(0x30DF, 0x30AF, 0x30ED, 0x30F3), 0x3349 => array(0x30DF, 0x30EA),
2192                     0x334A => array(0x30DF, 0x30EA, 0x30D0, 0x30FC, 0x30EB), 0x334B => array(0x30E1, 0x30AC), 0x334C => array(0x30E1, 0x30AC, 0x30C8, 0x30F3),
2193                     0x334D => array(0x30E1, 0x30FC, 0x30C8, 0x30EB), 0x334E => array(0x30E4, 0x30FC, 0x30C9), 0x334F => array(0x30E4, 0x30FC, 0x30EB),
2194                     0x3350 => array(0x30E6, 0x30A2, 0x30F3), 0x3351 => array(0x30EA, 0x30C3, 0x30C8, 0x30EB), 0x3352 => array(0x30EA, 0x30E9),
2195                     0x3353 => array(0x30EB, 0x30D4, 0x30FC), 0x3354 => array(0x30EB, 0x30FC, 0x30D6, 0x30EB), 0x3355 => array(0x30EC, 0x30E0),
2196                     0x3356 => array(0x30EC, 0x30F3, 0x30C8, 0x30B2, 0x30F3), 0x3357 => array(0x30EF, 0x30C3, 0x30C8), 0x3358 => array(0x30, 0x70B9),
2197                     0x3359 => array(0x31, 0x70B9), 0x335A => array(0x32, 0x70B9), 0x335B => array(0x33, 0x70B9),
2198                     0x335C => array(0x34, 0x70B9), 0x335D => array(0x35, 0x70B9), 0x335E => array(0x36, 0x70B9),
2199                     0x335F => array(0x37, 0x70B9), 0x3360 => array(0x38, 0x70B9), 0x3361 => array(0x39, 0x70B9),
2200                     0x3362 => array(0x31, 0x30, 0x70B9), 0x3363 => array(0x31, 0x31, 0x70B9), 0x3364 => array(0x31, 0x32, 0x70B9),
2201                     0x3365 => array(0x31, 0x33, 0x70B9), 0x3366 => array(0x31, 0x34, 0x70B9), 0x3367 => array(0x31, 0x35, 0x70B9),
2202                     0x3368 => array(0x31, 0x36, 0x70B9), 0x3369 => array(0x31, 0x37, 0x70B9), 0x336A => array(0x31, 0x38, 0x70B9),
2203                     0x336B => array(0x31, 0x39, 0x70B9), 0x336C => array(0x32, 0x30, 0x70B9), 0x336D => array(0x32, 0x31, 0x70B9),
2204                     0x336E => array(0x32, 0x32, 0x70B9), 0x336F => array(0x32, 0x33, 0x70B9), 0x3370 => array(0x32, 0x34, 0x70B9),
2205                     0x3371 => array(0x68, 0x70, 0x61), 0x3372 => array(0x64, 0x61), 0x3373 => array(0x61, 0x75),
2206                     0x3374 => array(0x62, 0x61, 0x72), 0x3375 => array(0x6F, 0x76), 0x3376 => array(0x70, 0x63),
2207                     0x3377 => array(0x64, 0x6D), 0x3378 => array(0x64, 0x6D, 0x32), 0x3379 => array(0x64, 0x6D, 0x33),
2208                     0x337A => array(0x69, 0x75), 0x337B => array(0x5E73, 0x6210), 0x337C => array(0x662D, 0x548C),
2209                     0x337D => array(0x5927, 0x6B63), 0x337E => array(0x660E, 0x6CBB), 0x337F => array(0x682A, 0x5F0F, 0x4F1A, 0x793E),
2210                     0x3380 => array(0x70, 0x61), 0x3381 => array(0x6E, 0x61), 0x3382 => array(0x3BC, 0x61),
2211                     0x3383 => array(0x6D, 0x61), 0x3384 => array(0x6B, 0x61), 0x3385 => array(0x6B, 0x62),
2212                     0x3386 => array(0x6D, 0x62), 0x3387 => array(0x67, 0x62), 0x3388 => array(0x63, 0x61, 0x6C),
2213                     0x3389 => array(0x6B, 0x63, 0x61, 0x6C), 0x338A => array(0x70, 0x66), 0x338B => array(0x6E, 0x66),
2214                     0x338C => array(0x3BC, 0x66), 0x338D => array(0x3BC, 0x67), 0x338E => array(0x6D, 0x67),
2215                     0x338F => array(0x6B, 0x67), 0x3390 => array(0x68, 0x7A), 0x3391 => array(0x6B, 0x68, 0x7A),
2216                     0x3392 => array(0x6D, 0x68, 0x7A), 0x3393 => array(0x67, 0x68, 0x7A), 0x3394 => array(0x74, 0x68, 0x7A),
2217                     0x3395 => array(0x3BC, 0x6C), 0x3396 => array(0x6D, 0x6C), 0x3397 => array(0x64, 0x6C),
2218                     0x3398 => array(0x6B, 0x6C), 0x3399 => array(0x66, 0x6D), 0x339A => array(0x6E, 0x6D),
2219                     0x339B => array(0x3BC, 0x6D), 0x339C => array(0x6D, 0x6D), 0x339D => array(0x63, 0x6D),
2220                     0x339E => array(0x6B, 0x6D), 0x339F => array(0x6D, 0x6D, 0x32), 0x33A0 => array(0x63, 0x6D, 0x32),
2221                     0x33A1 => array(0x6D, 0x32), 0x33A2 => array(0x6B, 0x6D, 0x32), 0x33A3 => array(0x6D, 0x6D, 0x33),
2222                     0x33A4 => array(0x63, 0x6D, 0x33), 0x33A5 => array(0x6D, 0x33), 0x33A6 => array(0x6B, 0x6D, 0x33),
2223                     0x33A7 => array(0x6D, 0x2215, 0x73), 0x33A8 => array(0x6D, 0x2215, 0x73, 0x32), 0x33A9 => array(0x70, 0x61),
2224                     0x33AA => array(0x6B, 0x70, 0x61), 0x33AB => array(0x6D, 0x70, 0x61), 0x33AC => array(0x67, 0x70, 0x61),
2225                     0x33AD => array(0x72, 0x61, 0x64), 0x33AE => array(0x72, 0x61, 0x64, 0x2215, 0x73), 0x33AF => array(0x72, 0x61, 0x64, 0x2215, 0x73, 0x32),
2226                     0x33B0 => array(0x70, 0x73), 0x33B1 => array(0x6E, 0x73), 0x33B2 => array(0x3BC, 0x73),
2227                     0x33B3 => array(0x6D, 0x73), 0x33B4 => array(0x70, 0x76), 0x33B5 => array(0x6E, 0x76),
2228                     0x33B6 => array(0x3BC, 0x76), 0x33B7 => array(0x6D, 0x76), 0x33B8 => array(0x6B, 0x76),
2229                     0x33B9 => array(0x6D, 0x76), 0x33BA => array(0x70, 0x77), 0x33BB => array(0x6E, 0x77),
2230                     0x33BC => array(0x3BC, 0x77), 0x33BD => array(0x6D, 0x77), 0x33BE => array(0x6B, 0x77),
2231                     0x33BF => array(0x6D, 0x77), 0x33C0 => array(0x6B, 0x3C9), 0x33C1 => array(0x6D, 0x3C9),
2232                     0x33C3 => array(0x62, 0x71), 0x33C4 => array(0x63, 0x63), 0x33C5 => array(0x63, 0x64),
2233                     0x33C6 => array(0x63, 0x2215, 0x6B, 0x67), 0x33C8 => array(0x64, 0x62), 0x33C9 => array(0x67, 0x79),
2234                     0x33CA => array(0x68, 0x61), 0x33CB => array(0x68, 0x70), 0x33CC => array(0x69, 0x6E),
2235                     0x33CD => array(0x6B, 0x6B), 0x33CE => array(0x6B, 0x6D), 0x33CF => array(0x6B, 0x74),
2236                     0x33D0 => array(0x6C, 0x6D), 0x33D1 => array(0x6C, 0x6E), 0x33D2 => array(0x6C, 0x6F, 0x67),
2237                     0x33D3 => array(0x6C, 0x78), 0x33D4 => array(0x6D, 0x62), 0x33D5 => array(0x6D, 0x69, 0x6C),
2238                     0x33D6 => array(0x6D, 0x6F, 0x6C), 0x33D7 => array(0x70, 0x68), 0x33D9 => array(0x70, 0x70, 0x6D),
2239                     0x33DA => array(0x70, 0x72), 0x33DB => array(0x73, 0x72), 0x33DC => array(0x73, 0x76),
2240                     0x33DD => array(0x77, 0x62), 0x33DE => array(0x76, 0x2215, 0x6D), 0x33DF => array(0x61, 0x2215, 0x6D),
2241                     0x33E0 => array(0x31, 0x65E5), 0x33E1 => array(0x32, 0x65E5), 0x33E2 => array(0x33, 0x65E5),
2242                     0x33E3 => array(0x34, 0x65E5), 0x33E4 => array(0x35, 0x65E5), 0x33E5 => array(0x36, 0x65E5),
2243                     0x33E6 => array(0x37, 0x65E5), 0x33E7 => array(0x38, 0x65E5), 0x33E8 => array(0x39, 0x65E5),
2244                     0x33E9 => array(0x31, 0x30, 0x65E5), 0x33EA => array(0x31, 0x31, 0x65E5), 0x33EB => array(0x31, 0x32, 0x65E5),
2245                     0x33EC => array(0x31, 0x33, 0x65E5), 0x33ED => array(0x31, 0x34, 0x65E5), 0x33EE => array(0x31, 0x35, 0x65E5),
2246                     0x33EF => array(0x31, 0x36, 0x65E5), 0x33F0 => array(0x31, 0x37, 0x65E5), 0x33F1 => array(0x31, 0x38, 0x65E5),
2247                     0x33F2 => array(0x31, 0x39, 0x65E5), 0x33F3 => array(0x32, 0x30, 0x65E5), 0x33F4 => array(0x32, 0x31, 0x65E5),
2248                     0x33F5 => array(0x32, 0x32, 0x65E5), 0x33F6 => array(0x32, 0x33, 0x65E5), 0x33F7 => array(0x32, 0x34, 0x65E5),
2249                     0x33F8 => array(0x32, 0x35, 0x65E5), 0x33F9 => array(0x32, 0x36, 0x65E5), 0x33FA => array(0x32, 0x37, 0x65E5),
2250                     0x33FB => array(0x32, 0x38, 0x65E5), 0x33FC => array(0x32, 0x39, 0x65E5), 0x33FD => array(0x33, 0x30, 0x65E5),
2251                     0x33FE => array(0x33, 0x31, 0x65E5), 0x33FF => array(0x67, 0x61, 0x6C), 0xA640 => array(0xA641),
2252                     0xA642 => array(0xA643), 0xA644 => array(0xA645), 0xA646 => array(0xA647),
2253                     0xA648 => array(0xA649), 0xA64A => array(0xA64B), 0xA64C => array(0xA64D),
2254                     0xA64E => array(0xA64F), 0xA650 => array(0xA651), 0xA652 => array(0xA653),
2255                     0xA654 => array(0xA655), 0xA656 => array(0xA657), 0xA658 => array(0xA659),
2256                     0xA65A => array(0xA65B), 0xA65C => array(0xA65D), 0xA65E => array(0xA65F),
2257                     0xA660 => array(0xA661), 0xA662 => array(0xA663), 0xA664 => array(0xA665),
2258                     0xA666 => array(0xA667), 0xA668 => array(0xA669), 0xA66A => array(0xA66B),
2259                     0xA66C => array(0xA66D), 0xA680 => array(0xA681), 0xA682 => array(0xA683),
2260                     0xA684 => array(0xA685), 0xA686 => array(0xA687), 0xA688 => array(0xA689),
2261                     0xA68A => array(0xA68B), 0xA68C => array(0xA68D), 0xA68E => array(0xA68F),
2262                     0xA690 => array(0xA691), 0xA692 => array(0xA693), 0xA694 => array(0xA695),
2263                     0xA696 => array(0xA697), 0xA698 => array(0xA699), 0xA69A => array(0xA69B),
2264                     0xA69C => array(0x44A), 0xA69D => array(0x44C), 0xA722 => array(0xA723),
2265                     0xA724 => array(0xA725), 0xA726 => array(0xA727), 0xA728 => array(0xA729),
2266                     0xA72A => array(0xA72B), 0xA72C => array(0xA72D), 0xA72E => array(0xA72F),
2267                     0xA732 => array(0xA733), 0xA734 => array(0xA735), 0xA736 => array(0xA737),
2268                     0xA738 => array(0xA739), 0xA73A => array(0xA73B), 0xA73C => array(0xA73D),
2269                     0xA73E => array(0xA73F), 0xA740 => array(0xA741), 0xA742 => array(0xA743),
2270                     0xA744 => array(0xA745), 0xA746 => array(0xA747), 0xA748 => array(0xA749),
2271                     0xA74A => array(0xA74B), 0xA74C => array(0xA74D), 0xA74E => array(0xA74F),
2272                     0xA750 => array(0xA751), 0xA752 => array(0xA753), 0xA754 => array(0xA755),
2273                     0xA756 => array(0xA757), 0xA758 => array(0xA759), 0xA75A => array(0xA75B),
2274                     0xA75C => array(0xA75D), 0xA75E => array(0xA75F), 0xA760 => array(0xA761),
2275                     0xA762 => array(0xA763), 0xA764 => array(0xA765), 0xA766 => array(0xA767),
2276                     0xA768 => array(0xA769), 0xA76A => array(0xA76B), 0xA76C => array(0xA76D),
2277                     0xA76E => array(0xA76F), 0xA770 => array(0xA76F), 0xA779 => array(0xA77A),
2278                     0xA77B => array(0xA77C), 0xA77D => array(0x1D79), 0xA77E => array(0xA77F),
2279                     0xA780 => array(0xA781), 0xA782 => array(0xA783), 0xA784 => array(0xA785),
2280                     0xA786 => array(0xA787), 0xA78B => array(0xA78C), 0xA78D => array(0x265),
2281                     0xA790 => array(0xA791), 0xA792 => array(0xA793), 0xA796 => array(0xA797),
2282                     0xA798 => array(0xA799), 0xA79A => array(0xA79B), 0xA79C => array(0xA79D),
2283                     0xA79E => array(0xA79F), 0xA7A0 => array(0xA7A1), 0xA7A2 => array(0xA7A3),
2284                     0xA7A4 => array(0xA7A5), 0xA7A6 => array(0xA7A7), 0xA7A8 => array(0xA7A9),
2285                     0xA7AA => array(0x266), 0xA7AB => array(0x25C), 0xA7AC => array(0x261),
2286                     0xA7AD => array(0x26C), 0xA7B0 => array(0x29E), 0xA7B1 => array(0x287),
2287                     0xA7F8 => array(0x127), 0xA7F9 => array(0x153), 0xAB5C => array(0xA727),
2288                     0xAB5D => array(0xAB37), 0xAB5E => array(0x26B), 0xAB5F => array(0xAB52),
2289                     0xF900 => array(0x8C48), 0xF901 => array(0x66F4), 0xF902 => array(0x8ECA),
2290                     0xF903 => array(0x8CC8), 0xF904 => array(0x6ED1), 0xF905 => array(0x4E32),
2291                     0xF906 => array(0x53E5), 0xF907 => array(0x9F9C), 0xF908 => array(0x9F9C),
2292                     0xF909 => array(0x5951), 0xF90A => array(0x91D1), 0xF90B => array(0x5587),
2293                     0xF90C => array(0x5948), 0xF90D => array(0x61F6), 0xF90E => array(0x7669),
2294                     0xF90F => array(0x7F85), 0xF910 => array(0x863F), 0xF911 => array(0x87BA),
2295                     0xF912 => array(0x88F8), 0xF913 => array(0x908F), 0xF914 => array(0x6A02),
2296                     0xF915 => array(0x6D1B), 0xF916 => array(0x70D9), 0xF917 => array(0x73DE),
2297                     0xF918 => array(0x843D), 0xF919 => array(0x916A), 0xF91A => array(0x99F1),
2298                     0xF91B => array(0x4E82), 0xF91C => array(0x5375), 0xF91D => array(0x6B04),
2299                     0xF91E => array(0x721B), 0xF91F => array(0x862D), 0xF920 => array(0x9E1E),
2300                     0xF921 => array(0x5D50), 0xF922 => array(0x6FEB), 0xF923 => array(0x85CD),
2301                     0xF924 => array(0x8964), 0xF925 => array(0x62C9), 0xF926 => array(0x81D8),
2302                     0xF927 => array(0x881F), 0xF928 => array(0x5ECA), 0xF929 => array(0x6717),
2303                     0xF92A => array(0x6D6A), 0xF92B => array(0x72FC), 0xF92C => array(0x90CE),
2304                     0xF92D => array(0x4F86), 0xF92E => array(0x51B7), 0xF92F => array(0x52DE),
2305                     0xF930 => array(0x64C4), 0xF931 => array(0x6AD3), 0xF932 => array(0x7210),
2306                     0xF933 => array(0x76E7), 0xF934 => array(0x8001), 0xF935 => array(0x8606),
2307                     0xF936 => array(0x865C), 0xF937 => array(0x8DEF), 0xF938 => array(0x9732),
2308                     0xF939 => array(0x9B6F), 0xF93A => array(0x9DFA), 0xF93B => array(0x788C),
2309                     0xF93C => array(0x797F), 0xF93D => array(0x7DA0), 0xF93E => array(0x83C9),
2310                     0xF93F => array(0x9304), 0xF940 => array(0x9E7F), 0xF941 => array(0x8AD6),
2311                     0xF942 => array(0x58DF), 0xF943 => array(0x5F04), 0xF944 => array(0x7C60),
2312                     0xF945 => array(0x807E), 0xF946 => array(0x7262), 0xF947 => array(0x78CA),
2313                     0xF948 => array(0x8CC2), 0xF949 => array(0x96F7), 0xF94A => array(0x58D8),
2314                     0xF94B => array(0x5C62), 0xF94C => array(0x6A13), 0xF94D => array(0x6DDA),
2315                     0xF94E => array(0x6F0F), 0xF94F => array(0x7D2F), 0xF950 => array(0x7E37),
2316                     0xF951 => array(0x964B), 0xF952 => array(0x52D2), 0xF953 => array(0x808B),
2317                     0xF954 => array(0x51DC), 0xF955 => array(0x51CC), 0xF956 => array(0x7A1C),
2318                     0xF957 => array(0x7DBE), 0xF958 => array(0x83F1), 0xF959 => array(0x9675),
2319                     0xF95A => array(0x8B80), 0xF95B => array(0x62CF), 0xF95C => array(0x6A02),
2320                     0xF95D => array(0x8AFE), 0xF95E => array(0x4E39), 0xF95F => array(0x5BE7),
2321                     0xF960 => array(0x6012), 0xF961 => array(0x7387), 0xF962 => array(0x7570),
2322                     0xF963 => array(0x5317), 0xF964 => array(0x78FB), 0xF965 => array(0x4FBF),
2323                     0xF966 => array(0x5FA9), 0xF967 => array(0x4E0D), 0xF968 => array(0x6CCC),
2324                     0xF969 => array(0x6578), 0xF96A => array(0x7D22), 0xF96B => array(0x53C3),
2325                     0xF96C => array(0x585E), 0xF96D => array(0x7701), 0xF96E => array(0x8449),
2326                     0xF96F => array(0x8AAA), 0xF970 => array(0x6BBA), 0xF971 => array(0x8FB0),
2327                     0xF972 => array(0x6C88), 0xF973 => array(0x62FE), 0xF974 => array(0x82E5),
2328                     0xF975 => array(0x63A0), 0xF976 => array(0x7565), 0xF977 => array(0x4EAE),
2329                     0xF978 => array(0x5169), 0xF979 => array(0x51C9), 0xF97A => array(0x6881),
2330                     0xF97B => array(0x7CE7), 0xF97C => array(0x826F), 0xF97D => array(0x8AD2),
2331                     0xF97E => array(0x91CF), 0xF97F => array(0x52F5), 0xF980 => array(0x5442),
2332                     0xF981 => array(0x5973), 0xF982 => array(0x5EEC), 0xF983 => array(0x65C5),
2333                     0xF984 => array(0x6FFE), 0xF985 => array(0x792A), 0xF986 => array(0x95AD),
2334                     0xF987 => array(0x9A6A), 0xF988 => array(0x9E97), 0xF989 => array(0x9ECE),
2335                     0xF98A => array(0x529B), 0xF98B => array(0x66C6), 0xF98C => array(0x6B77),
2336                     0xF98D => array(0x8F62), 0xF98E => array(0x5E74), 0xF98F => array(0x6190),
2337                     0xF990 => array(0x6200), 0xF991 => array(0x649A), 0xF992 => array(0x6F23),
2338                     0xF993 => array(0x7149), 0xF994 => array(0x7489), 0xF995 => array(0x79CA),
2339                     0xF996 => array(0x7DF4), 0xF997 => array(0x806F), 0xF998 => array(0x8F26),
2340                     0xF999 => array(0x84EE), 0xF99A => array(0x9023), 0xF99B => array(0x934A),
2341                     0xF99C => array(0x5217), 0xF99D => array(0x52A3), 0xF99E => array(0x54BD),
2342                     0xF99F => array(0x70C8), 0xF9A0 => array(0x88C2), 0xF9A1 => array(0x8AAA),
2343                     0xF9A2 => array(0x5EC9), 0xF9A3 => array(0x5FF5), 0xF9A4 => array(0x637B),
2344                     0xF9A5 => array(0x6BAE), 0xF9A6 => array(0x7C3E), 0xF9A7 => array(0x7375),
2345                     0xF9A8 => array(0x4EE4), 0xF9A9 => array(0x56F9), 0xF9AA => array(0x5BE7),
2346                     0xF9AB => array(0x5DBA), 0xF9AC => array(0x601C), 0xF9AD => array(0x73B2),
2347                     0xF9AE => array(0x7469), 0xF9AF => array(0x7F9A), 0xF9B0 => array(0x8046),
2348                     0xF9B1 => array(0x9234), 0xF9B2 => array(0x96F6), 0xF9B3 => array(0x9748),
2349                     0xF9B4 => array(0x9818), 0xF9B5 => array(0x4F8B), 0xF9B6 => array(0x79AE),
2350                     0xF9B7 => array(0x91B4), 0xF9B8 => array(0x96B8), 0xF9B9 => array(0x60E1),
2351                     0xF9BA => array(0x4E86), 0xF9BB => array(0x50DA), 0xF9BC => array(0x5BEE),
2352                     0xF9BD => array(0x5C3F), 0xF9BE => array(0x6599), 0xF9BF => array(0x6A02),
2353                     0xF9C0 => array(0x71CE), 0xF9C1 => array(0x7642), 0xF9C2 => array(0x84FC),
2354                     0xF9C3 => array(0x907C), 0xF9C4 => array(0x9F8D), 0xF9C5 => array(0x6688),
2355                     0xF9C6 => array(0x962E), 0xF9C7 => array(0x5289), 0xF9C8 => array(0x677B),
2356                     0xF9C9 => array(0x67F3), 0xF9CA => array(0x6D41), 0xF9CB => array(0x6E9C),
2357                     0xF9CC => array(0x7409), 0xF9CD => array(0x7559), 0xF9CE => array(0x786B),
2358                     0xF9CF => array(0x7D10), 0xF9D0 => array(0x985E), 0xF9D1 => array(0x516D),
2359                     0xF9D2 => array(0x622E), 0xF9D3 => array(0x9678), 0xF9D4 => array(0x502B),
2360                     0xF9D5 => array(0x5D19), 0xF9D6 => array(0x6DEA), 0xF9D7 => array(0x8F2A),
2361                     0xF9D8 => array(0x5F8B), 0xF9D9 => array(0x6144), 0xF9DA => array(0x6817),
2362                     0xF9DB => array(0x7387), 0xF9DC => array(0x9686), 0xF9DD => array(0x5229),
2363                     0xF9DE => array(0x540F), 0xF9DF => array(0x5C65), 0xF9E0 => array(0x6613),
2364                     0xF9E1 => array(0x674E), 0xF9E2 => array(0x68A8), 0xF9E3 => array(0x6CE5),
2365                     0xF9E4 => array(0x7406), 0xF9E5 => array(0x75E2), 0xF9E6 => array(0x7F79),
2366                     0xF9E7 => array(0x88CF), 0xF9E8 => array(0x88E1), 0xF9E9 => array(0x91CC),
2367                     0xF9EA => array(0x96E2), 0xF9EB => array(0x533F), 0xF9EC => array(0x6EBA),
2368                     0xF9ED => array(0x541D), 0xF9EE => array(0x71D0), 0xF9EF => array(0x7498),
2369                     0xF9F0 => array(0x85FA), 0xF9F1 => array(0x96A3), 0xF9F2 => array(0x9C57),
2370                     0xF9F3 => array(0x9E9F), 0xF9F4 => array(0x6797), 0xF9F5 => array(0x6DCB),
2371                     0xF9F6 => array(0x81E8), 0xF9F7 => array(0x7ACB), 0xF9F8 => array(0x7B20),
2372                     0xF9F9 => array(0x7C92), 0xF9FA => array(0x72C0), 0xF9FB => array(0x7099),
2373                     0xF9FC => array(0x8B58), 0xF9FD => array(0x4EC0), 0xF9FE => array(0x8336),
2374                     0xF9FF => array(0x523A), 0xFA00 => array(0x5207), 0xFA01 => array(0x5EA6),
2375                     0xFA02 => array(0x62D3), 0xFA03 => array(0x7CD6), 0xFA04 => array(0x5B85),
2376                     0xFA05 => array(0x6D1E), 0xFA06 => array(0x66B4), 0xFA07 => array(0x8F3B),
2377                     0xFA08 => array(0x884C), 0xFA09 => array(0x964D), 0xFA0A => array(0x898B),
2378                     0xFA0B => array(0x5ED3), 0xFA0C => array(0x5140), 0xFA0D => array(0x55C0),
2379                     0xFA10 => array(0x585A), 0xFA12 => array(0x6674), 0xFA15 => array(0x51DE),
2380                     0xFA16 => array(0x732A), 0xFA17 => array(0x76CA), 0xFA18 => array(0x793C),
2381                     0xFA19 => array(0x795E), 0xFA1A => array(0x7965), 0xFA1B => array(0x798F),
2382                     0xFA1C => array(0x9756), 0xFA1D => array(0x7CBE), 0xFA1E => array(0x7FBD),
2383                     0xFA20 => array(0x8612), 0xFA22 => array(0x8AF8), 0xFA25 => array(0x9038),
2384                     0xFA26 => array(0x90FD), 0xFA2A => array(0x98EF), 0xFA2B => array(0x98FC),
2385                     0xFA2C => array(0x9928), 0xFA2D => array(0x9DB4), 0xFA2E => array(0x90DE),
2386                     0xFA2F => array(0x96B7), 0xFA30 => array(0x4FAE), 0xFA31 => array(0x50E7),
2387                     0xFA32 => array(0x514D), 0xFA33 => array(0x52C9), 0xFA34 => array(0x52E4),
2388                     0xFA35 => array(0x5351), 0xFA36 => array(0x559D), 0xFA37 => array(0x5606),
2389                     0xFA38 => array(0x5668), 0xFA39 => array(0x5840), 0xFA3A => array(0x58A8),
2390                     0xFA3B => array(0x5C64), 0xFA3C => array(0x5C6E), 0xFA3D => array(0x6094),
2391                     0xFA3E => array(0x6168), 0xFA3F => array(0x618E), 0xFA40 => array(0x61F2),
2392                     0xFA41 => array(0x654F), 0xFA42 => array(0x65E2), 0xFA43 => array(0x6691),
2393                     0xFA44 => array(0x6885), 0xFA45 => array(0x6D77), 0xFA46 => array(0x6E1A),
2394                     0xFA47 => array(0x6F22), 0xFA48 => array(0x716E), 0xFA49 => array(0x722B),
2395                     0xFA4A => array(0x7422), 0xFA4B => array(0x7891), 0xFA4C => array(0x793E),
2396                     0xFA4D => array(0x7949), 0xFA4E => array(0x7948), 0xFA4F => array(0x7950),
2397                     0xFA50 => array(0x7956), 0xFA51 => array(0x795D), 0xFA52 => array(0x798D),
2398                     0xFA53 => array(0x798E), 0xFA54 => array(0x7A40), 0xFA55 => array(0x7A81),
2399                     0xFA56 => array(0x7BC0), 0xFA57 => array(0x7DF4), 0xFA58 => array(0x7E09),
2400                     0xFA59 => array(0x7E41), 0xFA5A => array(0x7F72), 0xFA5B => array(0x8005),
2401                     0xFA5C => array(0x81ED), 0xFA5D => array(0x8279), 0xFA5E => array(0x8279),
2402                     0xFA5F => array(0x8457), 0xFA60 => array(0x8910), 0xFA61 => array(0x8996),
2403                     0xFA62 => array(0x8B01), 0xFA63 => array(0x8B39), 0xFA64 => array(0x8CD3),
2404                     0xFA65 => array(0x8D08), 0xFA66 => array(0x8FB6), 0xFA67 => array(0x9038),
2405                     0xFA68 => array(0x96E3), 0xFA69 => array(0x97FF), 0xFA6A => array(0x983B),
2406                     0xFA6B => array(0x6075), 0xFA6C => array(0x242EE), 0xFA6D => array(0x8218),
2407                     0xFA70 => array(0x4E26), 0xFA71 => array(0x51B5), 0xFA72 => array(0x5168),
2408                     0xFA73 => array(0x4F80), 0xFA74 => array(0x5145), 0xFA75 => array(0x5180),
2409                     0xFA76 => array(0x52C7), 0xFA77 => array(0x52FA), 0xFA78 => array(0x559D),
2410                     0xFA79 => array(0x5555), 0xFA7A => array(0x5599), 0xFA7B => array(0x55E2),
2411                     0xFA7C => array(0x585A), 0xFA7D => array(0x58B3), 0xFA7E => array(0x5944),
2412                     0xFA7F => array(0x5954), 0xFA80 => array(0x5A62), 0xFA81 => array(0x5B28),
2413                     0xFA82 => array(0x5ED2), 0xFA83 => array(0x5ED9), 0xFA84 => array(0x5F69),
2414                     0xFA85 => array(0x5FAD), 0xFA86 => array(0x60D8), 0xFA87 => array(0x614E),
2415                     0xFA88 => array(0x6108), 0xFA89 => array(0x618E), 0xFA8A => array(0x6160),
2416                     0xFA8B => array(0x61F2), 0xFA8C => array(0x6234), 0xFA8D => array(0x63C4),
2417                     0xFA8E => array(0x641C), 0xFA8F => array(0x6452), 0xFA90 => array(0x6556),
2418                     0xFA91 => array(0x6674), 0xFA92 => array(0x6717), 0xFA93 => array(0x671B),
2419                     0xFA94 => array(0x6756), 0xFA95 => array(0x6B79), 0xFA96 => array(0x6BBA),
2420                     0xFA97 => array(0x6D41), 0xFA98 => array(0x6EDB), 0xFA99 => array(0x6ECB),
2421                     0xFA9A => array(0x6F22), 0xFA9B => array(0x701E), 0xFA9C => array(0x716E),
2422                     0xFA9D => array(0x77A7), 0xFA9E => array(0x7235), 0xFA9F => array(0x72AF),
2423                     0xFAA0 => array(0x732A), 0xFAA1 => array(0x7471), 0xFAA2 => array(0x7506),
2424                     0xFAA3 => array(0x753B), 0xFAA4 => array(0x761D), 0xFAA5 => array(0x761F),
2425                     0xFAA6 => array(0x76CA), 0xFAA7 => array(0x76DB), 0xFAA8 => array(0x76F4),
2426                     0xFAA9 => array(0x774A), 0xFAAA => array(0x7740), 0xFAAB => array(0x78CC),
2427                     0xFAAC => array(0x7AB1), 0xFAAD => array(0x7BC0), 0xFAAE => array(0x7C7B),
2428                     0xFAAF => array(0x7D5B), 0xFAB0 => array(0x7DF4), 0xFAB1 => array(0x7F3E),
2429                     0xFAB2 => array(0x8005), 0xFAB3 => array(0x8352), 0xFAB4 => array(0x83EF),
2430                     0xFAB5 => array(0x8779), 0xFAB6 => array(0x8941), 0xFAB7 => array(0x8986),
2431                     0xFAB8 => array(0x8996), 0xFAB9 => array(0x8ABF), 0xFABA => array(0x8AF8),
2432                     0xFABB => array(0x8ACB), 0xFABC => array(0x8B01), 0xFABD => array(0x8AFE),
2433                     0xFABE => array(0x8AED), 0xFABF => array(0x8B39), 0xFAC0 => array(0x8B8A),
2434                     0xFAC1 => array(0x8D08), 0xFAC2 => array(0x8F38), 0xFAC3 => array(0x9072),
2435                     0xFAC4 => array(0x9199), 0xFAC5 => array(0x9276), 0xFAC6 => array(0x967C),
2436                     0xFAC7 => array(0x96E3), 0xFAC8 => array(0x9756), 0xFAC9 => array(0x97DB),
2437                     0xFACA => array(0x97FF), 0xFACB => array(0x980B), 0xFACC => array(0x983B),
2438                     0xFACD => array(0x9B12), 0xFACE => array(0x9F9C), 0xFACF => array(0x2284A),
2439                     0xFAD0 => array(0x22844), 0xFAD1 => array(0x233D5), 0xFAD2 => array(0x3B9D),
2440                     0xFAD3 => array(0x4018), 0xFAD4 => array(0x4039), 0xFAD5 => array(0x25249),
2441                     0xFAD6 => array(0x25CD0), 0xFAD7 => array(0x27ED3), 0xFAD8 => array(0x9F43),
2442                     0xFAD9 => array(0x9F8E), 0xFB00 => array(0x66, 0x66), 0xFB01 => array(0x66, 0x69),
2443                     0xFB02 => array(0x66, 0x6C), 0xFB03 => array(0x66, 0x66, 0x69), 0xFB04 => array(0x66, 0x66, 0x6C),
2444                     0xFB05 => array(0x73, 0x74), 0xFB06 => array(0x73, 0x74), 0xFB13 => array(0x574, 0x576),
2445                     0xFB14 => array(0x574, 0x565), 0xFB15 => array(0x574, 0x56B), 0xFB16 => array(0x57E, 0x576),
2446                     0xFB17 => array(0x574, 0x56D), 0xFB1D => array(0x5D9, 0x5B4), 0xFB1F => array(0x5F2, 0x5B7),
2447                     0xFB20 => array(0x5E2), 0xFB21 => array(0x5D0), 0xFB22 => array(0x5D3),
2448                     0xFB23 => array(0x5D4), 0xFB24 => array(0x5DB), 0xFB25 => array(0x5DC),
2449                     0xFB26 => array(0x5DD), 0xFB27 => array(0x5E8), 0xFB28 => array(0x5EA),
2450                     0xFB2A => array(0x5E9, 0x5C1), 0xFB2B => array(0x5E9, 0x5C2), 0xFB2C => array(0x5E9, 0x5BC, 0x5C1),
2451                     0xFB2D => array(0x5E9, 0x5BC, 0x5C2), 0xFB2E => array(0x5D0, 0x5B7), 0xFB2F => array(0x5D0, 0x5B8),
2452                     0xFB30 => array(0x5D0, 0x5BC), 0xFB31 => array(0x5D1, 0x5BC), 0xFB32 => array(0x5D2, 0x5BC),
2453                     0xFB33 => array(0x5D3, 0x5BC), 0xFB34 => array(0x5D4, 0x5BC), 0xFB35 => array(0x5D5, 0x5BC),
2454                     0xFB36 => array(0x5D6, 0x5BC), 0xFB38 => array(0x5D8, 0x5BC), 0xFB39 => array(0x5D9, 0x5BC),
2455                     0xFB3A => array(0x5DA, 0x5BC), 0xFB3B => array(0x5DB, 0x5BC), 0xFB3C => array(0x5DC, 0x5BC),
2456                     0xFB3E => array(0x5DE, 0x5BC), 0xFB40 => array(0x5E0, 0x5BC), 0xFB41 => array(0x5E1, 0x5BC),
2457                     0xFB43 => array(0x5E3, 0x5BC), 0xFB44 => array(0x5E4, 0x5BC), 0xFB46 => array(0x5E6, 0x5BC),
2458                     0xFB47 => array(0x5E7, 0x5BC), 0xFB48 => array(0x5E8, 0x5BC), 0xFB49 => array(0x5E9, 0x5BC),
2459                     0xFB4A => array(0x5EA, 0x5BC), 0xFB4B => array(0x5D5, 0x5B9), 0xFB4C => array(0x5D1, 0x5BF),
2460                     0xFB4D => array(0x5DB, 0x5BF), 0xFB4E => array(0x5E4, 0x5BF), 0xFB4F => array(0x5D0, 0x5DC),
2461                     0xFB50 => array(0x671), 0xFB51 => array(0x671), 0xFB52 => array(0x67B),
2462                     0xFB53 => array(0x67B), 0xFB54 => array(0x67B), 0xFB55 => array(0x67B),
2463                     0xFB56 => array(0x67E), 0xFB57 => array(0x67E), 0xFB58 => array(0x67E),
2464                     0xFB59 => array(0x67E), 0xFB5A => array(0x680), 0xFB5B => array(0x680),
2465                     0xFB5C => array(0x680), 0xFB5D => array(0x680), 0xFB5E => array(0x67A),
2466                     0xFB5F => array(0x67A), 0xFB60 => array(0x67A), 0xFB61 => array(0x67A),
2467                     0xFB62 => array(0x67F), 0xFB63 => array(0x67F), 0xFB64 => array(0x67F),
2468                     0xFB65 => array(0x67F), 0xFB66 => array(0x679), 0xFB67 => array(0x679),
2469                     0xFB68 => array(0x679), 0xFB69 => array(0x679), 0xFB6A => array(0x6A4),
2470                     0xFB6B => array(0x6A4), 0xFB6C => array(0x6A4), 0xFB6D => array(0x6A4),
2471                     0xFB6E => array(0x6A6), 0xFB6F => array(0x6A6), 0xFB70 => array(0x6A6),
2472                     0xFB71 => array(0x6A6), 0xFB72 => array(0x684), 0xFB73 => array(0x684),
2473                     0xFB74 => array(0x684), 0xFB75 => array(0x684), 0xFB76 => array(0x683),
2474                     0xFB77 => array(0x683), 0xFB78 => array(0x683), 0xFB79 => array(0x683),
2475                     0xFB7A => array(0x686), 0xFB7B => array(0x686), 0xFB7C => array(0x686),
2476                     0xFB7D => array(0x686), 0xFB7E => array(0x687), 0xFB7F => array(0x687),
2477                     0xFB80 => array(0x687), 0xFB81 => array(0x687), 0xFB82 => array(0x68D),
2478                     0xFB83 => array(0x68D), 0xFB84 => array(0x68C), 0xFB85 => array(0x68C),
2479                     0xFB86 => array(0x68E), 0xFB87 => array(0x68E), 0xFB88 => array(0x688),
2480                     0xFB89 => array(0x688), 0xFB8A => array(0x698), 0xFB8B => array(0x698),
2481                     0xFB8C => array(0x691), 0xFB8D => array(0x691), 0xFB8E => array(0x6A9),
2482                     0xFB8F => array(0x6A9), 0xFB90 => array(0x6A9), 0xFB91 => array(0x6A9),
2483                     0xFB92 => array(0x6AF), 0xFB93 => array(0x6AF), 0xFB94 => array(0x6AF),
2484                     0xFB95 => array(0x6AF), 0xFB96 => array(0x6B3), 0xFB97 => array(0x6B3),
2485                     0xFB98 => array(0x6B3), 0xFB99 => array(0x6B3), 0xFB9A => array(0x6B1),
2486                     0xFB9B => array(0x6B1), 0xFB9C => array(0x6B1), 0xFB9D => array(0x6B1),
2487                     0xFB9E => array(0x6BA), 0xFB9F => array(0x6BA), 0xFBA0 => array(0x6BB),
2488                     0xFBA1 => array(0x6BB), 0xFBA2 => array(0x6BB), 0xFBA3 => array(0x6BB),
2489                     0xFBA4 => array(0x6C0), 0xFBA5 => array(0x6C0), 0xFBA6 => array(0x6C1),
2490                     0xFBA7 => array(0x6C1), 0xFBA8 => array(0x6C1), 0xFBA9 => array(0x6C1),
2491                     0xFBAA => array(0x6BE), 0xFBAB => array(0x6BE), 0xFBAC => array(0x6BE),
2492                     0xFBAD => array(0x6BE), 0xFBAE => array(0x6D2), 0xFBAF => array(0x6D2),
2493                     0xFBB0 => array(0x6D3), 0xFBB1 => array(0x6D3), 0xFBD3 => array(0x6AD),
2494                     0xFBD4 => array(0x6AD), 0xFBD5 => array(0x6AD), 0xFBD6 => array(0x6AD),
2495                     0xFBD7 => array(0x6C7), 0xFBD8 => array(0x6C7), 0xFBD9 => array(0x6C6),
2496                     0xFBDA => array(0x6C6), 0xFBDB => array(0x6C8), 0xFBDC => array(0x6C8),
2497                     0xFBDD => array(0x6C7, 0x674), 0xFBDE => array(0x6CB), 0xFBDF => array(0x6CB),
2498                     0xFBE0 => array(0x6C5), 0xFBE1 => array(0x6C5), 0xFBE2 => array(0x6C9),
2499                     0xFBE3 => array(0x6C9), 0xFBE4 => array(0x6D0), 0xFBE5 => array(0x6D0),
2500                     0xFBE6 => array(0x6D0), 0xFBE7 => array(0x6D0), 0xFBE8 => array(0x649),
2501                     0xFBE9 => array(0x649), 0xFBEA => array(0x626, 0x627), 0xFBEB => array(0x626, 0x627),
2502                     0xFBEC => array(0x626, 0x6D5), 0xFBED => array(0x626, 0x6D5), 0xFBEE => array(0x626, 0x648),
2503                     0xFBEF => array(0x626, 0x648), 0xFBF0 => array(0x626, 0x6C7), 0xFBF1 => array(0x626, 0x6C7),
2504                     0xFBF2 => array(0x626, 0x6C6), 0xFBF3 => array(0x626, 0x6C6), 0xFBF4 => array(0x626, 0x6C8),
2505                     0xFBF5 => array(0x626, 0x6C8), 0xFBF6 => array(0x626, 0x6D0), 0xFBF7 => array(0x626, 0x6D0),
2506                     0xFBF8 => array(0x626, 0x6D0), 0xFBF9 => array(0x626, 0x649), 0xFBFA => array(0x626, 0x649),
2507                     0xFBFB => array(0x626, 0x649), 0xFBFC => array(0x6CC), 0xFBFD => array(0x6CC),
2508                     0xFBFE => array(0x6CC), 0xFBFF => array(0x6CC), 0xFC00 => array(0x626, 0x62C),
2509                     0xFC01 => array(0x626, 0x62D), 0xFC02 => array(0x626, 0x645), 0xFC03 => array(0x626, 0x649),
2510                     0xFC04 => array(0x626, 0x64A), 0xFC05 => array(0x628, 0x62C), 0xFC06 => array(0x628, 0x62D),
2511                     0xFC07 => array(0x628, 0x62E), 0xFC08 => array(0x628, 0x645), 0xFC09 => array(0x628, 0x649),
2512                     0xFC0A => array(0x628, 0x64A), 0xFC0B => array(0x62A, 0x62C), 0xFC0C => array(0x62A, 0x62D),
2513                     0xFC0D => array(0x62A, 0x62E), 0xFC0E => array(0x62A, 0x645), 0xFC0F => array(0x62A, 0x649),
2514                     0xFC10 => array(0x62A, 0x64A), 0xFC11 => array(0x62B, 0x62C), 0xFC12 => array(0x62B, 0x645),
2515                     0xFC13 => array(0x62B, 0x649), 0xFC14 => array(0x62B, 0x64A), 0xFC15 => array(0x62C, 0x62D),
2516                     0xFC16 => array(0x62C, 0x645), 0xFC17 => array(0x62D, 0x62C), 0xFC18 => array(0x62D, 0x645),
2517                     0xFC19 => array(0x62E, 0x62C), 0xFC1A => array(0x62E, 0x62D), 0xFC1B => array(0x62E, 0x645),
2518                     0xFC1C => array(0x633, 0x62C), 0xFC1D => array(0x633, 0x62D), 0xFC1E => array(0x633, 0x62E),
2519                     0xFC1F => array(0x633, 0x645), 0xFC20 => array(0x635, 0x62D), 0xFC21 => array(0x635, 0x645),
2520                     0xFC22 => array(0x636, 0x62C), 0xFC23 => array(0x636, 0x62D), 0xFC24 => array(0x636, 0x62E),
2521                     0xFC25 => array(0x636, 0x645), 0xFC26 => array(0x637, 0x62D), 0xFC27 => array(0x637, 0x645),
2522                     0xFC28 => array(0x638, 0x645), 0xFC29 => array(0x639, 0x62C), 0xFC2A => array(0x639, 0x645),
2523                     0xFC2B => array(0x63A, 0x62C), 0xFC2C => array(0x63A, 0x645), 0xFC2D => array(0x641, 0x62C),
2524                     0xFC2E => array(0x641, 0x62D), 0xFC2F => array(0x641, 0x62E), 0xFC30 => array(0x641, 0x645),
2525                     0xFC31 => array(0x641, 0x649), 0xFC32 => array(0x641, 0x64A), 0xFC33 => array(0x642, 0x62D),
2526                     0xFC34 => array(0x642, 0x645), 0xFC35 => array(0x642, 0x649), 0xFC36 => array(0x642, 0x64A),
2527                     0xFC37 => array(0x643, 0x627), 0xFC38 => array(0x643, 0x62C), 0xFC39 => array(0x643, 0x62D),
2528                     0xFC3A => array(0x643, 0x62E), 0xFC3B => array(0x643, 0x644), 0xFC3C => array(0x643, 0x645),
2529                     0xFC3D => array(0x643, 0x649), 0xFC3E => array(0x643, 0x64A), 0xFC3F => array(0x644, 0x62C),
2530                     0xFC40 => array(0x644, 0x62D), 0xFC41 => array(0x644, 0x62E), 0xFC42 => array(0x644, 0x645),
2531                     0xFC43 => array(0x644, 0x649), 0xFC44 => array(0x644, 0x64A), 0xFC45 => array(0x645, 0x62C),
2532                     0xFC46 => array(0x645, 0x62D), 0xFC47 => array(0x645, 0x62E), 0xFC48 => array(0x645, 0x645),
2533                     0xFC49 => array(0x645, 0x649), 0xFC4A => array(0x645, 0x64A), 0xFC4B => array(0x646, 0x62C),
2534                     0xFC4C => array(0x646, 0x62D), 0xFC4D => array(0x646, 0x62E), 0xFC4E => array(0x646, 0x645),
2535                     0xFC4F => array(0x646, 0x649), 0xFC50 => array(0x646, 0x64A), 0xFC51 => array(0x647, 0x62C),
2536                     0xFC52 => array(0x647, 0x645), 0xFC53 => array(0x647, 0x649), 0xFC54 => array(0x647, 0x64A),
2537                     0xFC55 => array(0x64A, 0x62C), 0xFC56 => array(0x64A, 0x62D), 0xFC57 => array(0x64A, 0x62E),
2538                     0xFC58 => array(0x64A, 0x645), 0xFC59 => array(0x64A, 0x649), 0xFC5A => array(0x64A, 0x64A),
2539                     0xFC5B => array(0x630, 0x670), 0xFC5C => array(0x631, 0x670), 0xFC5D => array(0x649, 0x670),
2540                     0xFC64 => array(0x626, 0x631), 0xFC65 => array(0x626, 0x632), 0xFC66 => array(0x626, 0x645),
2541                     0xFC67 => array(0x626, 0x646), 0xFC68 => array(0x626, 0x649), 0xFC69 => array(0x626, 0x64A),
2542                     0xFC6A => array(0x628, 0x631), 0xFC6B => array(0x628, 0x632), 0xFC6C => array(0x628, 0x645),
2543                     0xFC6D => array(0x628, 0x646), 0xFC6E => array(0x628, 0x649), 0xFC6F => array(0x628, 0x64A),
2544                     0xFC70 => array(0x62A, 0x631), 0xFC71 => array(0x62A, 0x632), 0xFC72 => array(0x62A, 0x645),
2545                     0xFC73 => array(0x62A, 0x646), 0xFC74 => array(0x62A, 0x649), 0xFC75 => array(0x62A, 0x64A),
2546                     0xFC76 => array(0x62B, 0x631), 0xFC77 => array(0x62B, 0x632), 0xFC78 => array(0x62B, 0x645),
2547                     0xFC79 => array(0x62B, 0x646), 0xFC7A => array(0x62B, 0x649), 0xFC7B => array(0x62B, 0x64A),
2548                     0xFC7C => array(0x641, 0x649), 0xFC7D => array(0x641, 0x64A), 0xFC7E => array(0x642, 0x649),
2549                     0xFC7F => array(0x642, 0x64A), 0xFC80 => array(0x643, 0x627), 0xFC81 => array(0x643, 0x644),
2550                     0xFC82 => array(0x643, 0x645), 0xFC83 => array(0x643, 0x649), 0xFC84 => array(0x643, 0x64A),
2551                     0xFC85 => array(0x644, 0x645), 0xFC86 => array(0x644, 0x649), 0xFC87 => array(0x644, 0x64A),
2552                     0xFC88 => array(0x645, 0x627), 0xFC89 => array(0x645, 0x645), 0xFC8A => array(0x646, 0x631),
2553                     0xFC8B => array(0x646, 0x632), 0xFC8C => array(0x646, 0x645), 0xFC8D => array(0x646, 0x646),
2554                     0xFC8E => array(0x646, 0x649), 0xFC8F => array(0x646, 0x64A), 0xFC90 => array(0x649, 0x670),
2555                     0xFC91 => array(0x64A, 0x631), 0xFC92 => array(0x64A, 0x632), 0xFC93 => array(0x64A, 0x645),
2556                     0xFC94 => array(0x64A, 0x646), 0xFC95 => array(0x64A, 0x649), 0xFC96 => array(0x64A, 0x64A),
2557                     0xFC97 => array(0x626, 0x62C), 0xFC98 => array(0x626, 0x62D), 0xFC99 => array(0x626, 0x62E),
2558                     0xFC9A => array(0x626, 0x645), 0xFC9B => array(0x626, 0x647), 0xFC9C => array(0x628, 0x62C),
2559                     0xFC9D => array(0x628, 0x62D), 0xFC9E => array(0x628, 0x62E), 0xFC9F => array(0x628, 0x645),
2560                     0xFCA0 => array(0x628, 0x647), 0xFCA1 => array(0x62A, 0x62C), 0xFCA2 => array(0x62A, 0x62D),
2561                     0xFCA3 => array(0x62A, 0x62E), 0xFCA4 => array(0x62A, 0x645), 0xFCA5 => array(0x62A, 0x647),
2562                     0xFCA6 => array(0x62B, 0x645), 0xFCA7 => array(0x62C, 0x62D), 0xFCA8 => array(0x62C, 0x645),
2563                     0xFCA9 => array(0x62D, 0x62C), 0xFCAA => array(0x62D, 0x645), 0xFCAB => array(0x62E, 0x62C),
2564                     0xFCAC => array(0x62E, 0x645), 0xFCAD => array(0x633, 0x62C), 0xFCAE => array(0x633, 0x62D),
2565                     0xFCAF => array(0x633, 0x62E), 0xFCB0 => array(0x633, 0x645), 0xFCB1 => array(0x635, 0x62D),
2566                     0xFCB2 => array(0x635, 0x62E), 0xFCB3 => array(0x635, 0x645), 0xFCB4 => array(0x636, 0x62C),
2567                     0xFCB5 => array(0x636, 0x62D), 0xFCB6 => array(0x636, 0x62E), 0xFCB7 => array(0x636, 0x645),
2568                     0xFCB8 => array(0x637, 0x62D), 0xFCB9 => array(0x638, 0x645), 0xFCBA => array(0x639, 0x62C),
2569                     0xFCBB => array(0x639, 0x645), 0xFCBC => array(0x63A, 0x62C), 0xFCBD => array(0x63A, 0x645),
2570                     0xFCBE => array(0x641, 0x62C), 0xFCBF => array(0x641, 0x62D), 0xFCC0 => array(0x641, 0x62E),
2571                     0xFCC1 => array(0x641, 0x645), 0xFCC2 => array(0x642, 0x62D), 0xFCC3 => array(0x642, 0x645),
2572                     0xFCC4 => array(0x643, 0x62C), 0xFCC5 => array(0x643, 0x62D), 0xFCC6 => array(0x643, 0x62E),
2573                     0xFCC7 => array(0x643, 0x644), 0xFCC8 => array(0x643, 0x645), 0xFCC9 => array(0x644, 0x62C),
2574                     0xFCCA => array(0x644, 0x62D), 0xFCCB => array(0x644, 0x62E), 0xFCCC => array(0x644, 0x645),
2575                     0xFCCD => array(0x644, 0x647), 0xFCCE => array(0x645, 0x62C), 0xFCCF => array(0x645, 0x62D),
2576                     0xFCD0 => array(0x645, 0x62E), 0xFCD1 => array(0x645, 0x645), 0xFCD2 => array(0x646, 0x62C),
2577                     0xFCD3 => array(0x646, 0x62D), 0xFCD4 => array(0x646, 0x62E), 0xFCD5 => array(0x646, 0x645),
2578                     0xFCD6 => array(0x646, 0x647), 0xFCD7 => array(0x647, 0x62C), 0xFCD8 => array(0x647, 0x645),
2579                     0xFCD9 => array(0x647, 0x670), 0xFCDA => array(0x64A, 0x62C), 0xFCDB => array(0x64A, 0x62D),
2580                     0xFCDC => array(0x64A, 0x62E), 0xFCDD => array(0x64A, 0x645), 0xFCDE => array(0x64A, 0x647),
2581                     0xFCDF => array(0x626, 0x645), 0xFCE0 => array(0x626, 0x647), 0xFCE1 => array(0x628, 0x645),
2582                     0xFCE2 => array(0x628, 0x647), 0xFCE3 => array(0x62A, 0x645), 0xFCE4 => array(0x62A, 0x647),
2583                     0xFCE5 => array(0x62B, 0x645), 0xFCE6 => array(0x62B, 0x647), 0xFCE7 => array(0x633, 0x645),
2584                     0xFCE8 => array(0x633, 0x647), 0xFCE9 => array(0x634, 0x645), 0xFCEA => array(0x634, 0x647),
2585                     0xFCEB => array(0x643, 0x644), 0xFCEC => array(0x643, 0x645), 0xFCED => array(0x644, 0x645),
2586                     0xFCEE => array(0x646, 0x645), 0xFCEF => array(0x646, 0x647), 0xFCF0 => array(0x64A, 0x645),
2587                     0xFCF1 => array(0x64A, 0x647), 0xFCF2 => array(0x640, 0x64E, 0x651), 0xFCF3 => array(0x640, 0x64F, 0x651),
2588                     0xFCF4 => array(0x640, 0x650, 0x651), 0xFCF5 => array(0x637, 0x649), 0xFCF6 => array(0x637, 0x64A),
2589                     0xFCF7 => array(0x639, 0x649), 0xFCF8 => array(0x639, 0x64A), 0xFCF9 => array(0x63A, 0x649),
2590                     0xFCFA => array(0x63A, 0x64A), 0xFCFB => array(0x633, 0x649), 0xFCFC => array(0x633, 0x64A),
2591                     0xFCFD => array(0x634, 0x649), 0xFCFE => array(0x634, 0x64A), 0xFCFF => array(0x62D, 0x649),
2592                     0xFD00 => array(0x62D, 0x64A), 0xFD01 => array(0x62C, 0x649), 0xFD02 => array(0x62C, 0x64A),
2593                     0xFD03 => array(0x62E, 0x649), 0xFD04 => array(0x62E, 0x64A), 0xFD05 => array(0x635, 0x649),
2594                     0xFD06 => array(0x635, 0x64A), 0xFD07 => array(0x636, 0x649), 0xFD08 => array(0x636, 0x64A),
2595                     0xFD09 => array(0x634, 0x62C), 0xFD0A => array(0x634, 0x62D), 0xFD0B => array(0x634, 0x62E),
2596                     0xFD0C => array(0x634, 0x645), 0xFD0D => array(0x634, 0x631), 0xFD0E => array(0x633, 0x631),
2597                     0xFD0F => array(0x635, 0x631), 0xFD10 => array(0x636, 0x631), 0xFD11 => array(0x637, 0x649),
2598                     0xFD12 => array(0x637, 0x64A), 0xFD13 => array(0x639, 0x649), 0xFD14 => array(0x639, 0x64A),
2599                     0xFD15 => array(0x63A, 0x649), 0xFD16 => array(0x63A, 0x64A), 0xFD17 => array(0x633, 0x649),
2600                     0xFD18 => array(0x633, 0x64A), 0xFD19 => array(0x634, 0x649), 0xFD1A => array(0x634, 0x64A),
2601                     0xFD1B => array(0x62D, 0x649), 0xFD1C => array(0x62D, 0x64A), 0xFD1D => array(0x62C, 0x649),
2602                     0xFD1E => array(0x62C, 0x64A), 0xFD1F => array(0x62E, 0x649), 0xFD20 => array(0x62E, 0x64A),
2603                     0xFD21 => array(0x635, 0x649), 0xFD22 => array(0x635, 0x64A), 0xFD23 => array(0x636, 0x649),
2604                     0xFD24 => array(0x636, 0x64A), 0xFD25 => array(0x634, 0x62C), 0xFD26 => array(0x634, 0x62D),
2605                     0xFD27 => array(0x634, 0x62E), 0xFD28 => array(0x634, 0x645), 0xFD29 => array(0x634, 0x631),
2606                     0xFD2A => array(0x633, 0x631), 0xFD2B => array(0x635, 0x631), 0xFD2C => array(0x636, 0x631),
2607                     0xFD2D => array(0x634, 0x62C), 0xFD2E => array(0x634, 0x62D), 0xFD2F => array(0x634, 0x62E),
2608                     0xFD30 => array(0x634, 0x645), 0xFD31 => array(0x633, 0x647), 0xFD32 => array(0x634, 0x647),
2609                     0xFD33 => array(0x637, 0x645), 0xFD34 => array(0x633, 0x62C), 0xFD35 => array(0x633, 0x62D),
2610                     0xFD36 => array(0x633, 0x62E), 0xFD37 => array(0x634, 0x62C), 0xFD38 => array(0x634, 0x62D),
2611                     0xFD39 => array(0x634, 0x62E), 0xFD3A => array(0x637, 0x645), 0xFD3B => array(0x638, 0x645),
2612                     0xFD3C => array(0x627, 0x64B), 0xFD3D => array(0x627, 0x64B), 0xFD50 => array(0x62A, 0x62C, 0x645),
2613                     0xFD51 => array(0x62A, 0x62D, 0x62C), 0xFD52 => array(0x62A, 0x62D, 0x62C), 0xFD53 => array(0x62A, 0x62D, 0x645),
2614                     0xFD54 => array(0x62A, 0x62E, 0x645), 0xFD55 => array(0x62A, 0x645, 0x62C), 0xFD56 => array(0x62A, 0x645, 0x62D),
2615                     0xFD57 => array(0x62A, 0x645, 0x62E), 0xFD58 => array(0x62C, 0x645, 0x62D), 0xFD59 => array(0x62C, 0x645, 0x62D),
2616                     0xFD5A => array(0x62D, 0x645, 0x64A), 0xFD5B => array(0x62D, 0x645, 0x649), 0xFD5C => array(0x633, 0x62D, 0x62C),
2617                     0xFD5D => array(0x633, 0x62C, 0x62D), 0xFD5E => array(0x633, 0x62C, 0x649), 0xFD5F => array(0x633, 0x645, 0x62D),
2618                     0xFD60 => array(0x633, 0x645, 0x62D), 0xFD61 => array(0x633, 0x645, 0x62C), 0xFD62 => array(0x633, 0x645, 0x645),
2619                     0xFD63 => array(0x633, 0x645, 0x645), 0xFD64 => array(0x635, 0x62D, 0x62D), 0xFD65 => array(0x635, 0x62D, 0x62D),
2620                     0xFD66 => array(0x635, 0x645, 0x645), 0xFD67 => array(0x634, 0x62D, 0x645), 0xFD68 => array(0x634, 0x62D, 0x645),
2621                     0xFD69 => array(0x634, 0x62C, 0x64A), 0xFD6A => array(0x634, 0x645, 0x62E), 0xFD6B => array(0x634, 0x645, 0x62E),
2622                     0xFD6C => array(0x634, 0x645, 0x645), 0xFD6D => array(0x634, 0x645, 0x645), 0xFD6E => array(0x636, 0x62D, 0x649),
2623                     0xFD6F => array(0x636, 0x62E, 0x645), 0xFD70 => array(0x636, 0x62E, 0x645), 0xFD71 => array(0x637, 0x645, 0x62D),
2624                     0xFD72 => array(0x637, 0x645, 0x62D), 0xFD73 => array(0x637, 0x645, 0x645), 0xFD74 => array(0x637, 0x645, 0x64A),
2625                     0xFD75 => array(0x639, 0x62C, 0x645), 0xFD76 => array(0x639, 0x645, 0x645), 0xFD77 => array(0x639, 0x645, 0x645),
2626                     0xFD78 => array(0x639, 0x645, 0x649), 0xFD79 => array(0x63A, 0x645, 0x645), 0xFD7A => array(0x63A, 0x645, 0x64A),
2627                     0xFD7B => array(0x63A, 0x645, 0x649), 0xFD7C => array(0x641, 0x62E, 0x645), 0xFD7D => array(0x641, 0x62E, 0x645),
2628                     0xFD7E => array(0x642, 0x645, 0x62D), 0xFD7F => array(0x642, 0x645, 0x645), 0xFD80 => array(0x644, 0x62D, 0x645),
2629                     0xFD81 => array(0x644, 0x62D, 0x64A), 0xFD82 => array(0x644, 0x62D, 0x649), 0xFD83 => array(0x644, 0x62C, 0x62C),
2630                     0xFD84 => array(0x644, 0x62C, 0x62C), 0xFD85 => array(0x644, 0x62E, 0x645), 0xFD86 => array(0x644, 0x62E, 0x645),
2631                     0xFD87 => array(0x644, 0x645, 0x62D), 0xFD88 => array(0x644, 0x645, 0x62D), 0xFD89 => array(0x645, 0x62D, 0x62C),
2632                     0xFD8A => array(0x645, 0x62D, 0x645), 0xFD8B => array(0x645, 0x62D, 0x64A), 0xFD8C => array(0x645, 0x62C, 0x62D),
2633                     0xFD8D => array(0x645, 0x62C, 0x645), 0xFD8E => array(0x645, 0x62E, 0x62C), 0xFD8F => array(0x645, 0x62E, 0x645),
2634                     0xFD92 => array(0x645, 0x62C, 0x62E), 0xFD93 => array(0x647, 0x645, 0x62C), 0xFD94 => array(0x647, 0x645, 0x645),
2635                     0xFD95 => array(0x646, 0x62D, 0x645), 0xFD96 => array(0x646, 0x62D, 0x649), 0xFD97 => array(0x646, 0x62C, 0x645),
2636                     0xFD98 => array(0x646, 0x62C, 0x645), 0xFD99 => array(0x646, 0x62C, 0x649), 0xFD9A => array(0x646, 0x645, 0x64A),
2637                     0xFD9B => array(0x646, 0x645, 0x649), 0xFD9C => array(0x64A, 0x645, 0x645), 0xFD9D => array(0x64A, 0x645, 0x645),
2638                     0xFD9E => array(0x628, 0x62E, 0x64A), 0xFD9F => array(0x62A, 0x62C, 0x64A), 0xFDA0 => array(0x62A, 0x62C, 0x649),
2639                     0xFDA1 => array(0x62A, 0x62E, 0x64A), 0xFDA2 => array(0x62A, 0x62E, 0x649), 0xFDA3 => array(0x62A, 0x645, 0x64A),
2640                     0xFDA4 => array(0x62A, 0x645, 0x649), 0xFDA5 => array(0x62C, 0x645, 0x64A), 0xFDA6 => array(0x62C, 0x62D, 0x649),
2641                     0xFDA7 => array(0x62C, 0x645, 0x649), 0xFDA8 => array(0x633, 0x62E, 0x649), 0xFDA9 => array(0x635, 0x62D, 0x64A),
2642                     0xFDAA => array(0x634, 0x62D, 0x64A), 0xFDAB => array(0x636, 0x62D, 0x64A), 0xFDAC => array(0x644, 0x62C, 0x64A),
2643                     0xFDAD => array(0x644, 0x645, 0x64A), 0xFDAE => array(0x64A, 0x62D, 0x64A), 0xFDAF => array(0x64A, 0x62C, 0x64A),
2644                     0xFDB0 => array(0x64A, 0x645, 0x64A), 0xFDB1 => array(0x645, 0x645, 0x64A), 0xFDB2 => array(0x642, 0x645, 0x64A),
2645                     0xFDB3 => array(0x646, 0x62D, 0x64A), 0xFDB4 => array(0x642, 0x645, 0x62D), 0xFDB5 => array(0x644, 0x62D, 0x645),
2646                     0xFDB6 => array(0x639, 0x645, 0x64A), 0xFDB7 => array(0x643, 0x645, 0x64A), 0xFDB8 => array(0x646, 0x62C, 0x62D),
2647                     0xFDB9 => array(0x645, 0x62E, 0x64A), 0xFDBA => array(0x644, 0x62C, 0x645), 0xFDBB => array(0x643, 0x645, 0x645),
2648                     0xFDBC => array(0x644, 0x62C, 0x645), 0xFDBD => array(0x646, 0x62C, 0x62D), 0xFDBE => array(0x62C, 0x62D, 0x64A),
2649                     0xFDBF => array(0x62D, 0x62C, 0x64A), 0xFDC0 => array(0x645, 0x62C, 0x64A), 0xFDC1 => array(0x641, 0x645, 0x64A),
2650                     0xFDC2 => array(0x628, 0x62D, 0x64A), 0xFDC3 => array(0x643, 0x645, 0x645), 0xFDC4 => array(0x639, 0x62C, 0x645),
2651                     0xFDC5 => array(0x635, 0x645, 0x645), 0xFDC6 => array(0x633, 0x62E, 0x64A), 0xFDC7 => array(0x646, 0x62C, 0x64A),
2652                     0xFDF0 => array(0x635, 0x644, 0x6D2), 0xFDF1 => array(0x642, 0x644, 0x6D2), 0xFDF2 => array(0x627, 0x644, 0x644, 0x647),
2653                     0xFDF3 => array(0x627, 0x643, 0x628, 0x631), 0xFDF4 => array(0x645, 0x62D, 0x645, 0x62F), 0xFDF5 => array(0x635, 0x644, 0x639, 0x645),
2654                     0xFDF6 => array(0x631, 0x633, 0x648, 0x644), 0xFDF7 => array(0x639, 0x644, 0x64A, 0x647), 0xFDF8 => array(0x648, 0x633, 0x644, 0x645),
2655                     0xFDF9 => array(0x635, 0x644, 0x649), 0xFDFC => array(0x631, 0x6CC, 0x627, 0x644), 0xFE11 => array(0x3001),
2656                     0xFE17 => array(0x3016), 0xFE18 => array(0x3017), 0xFE31 => array(0x2014),
2657                     0xFE32 => array(0x2013), 0xFE39 => array(0x3014), 0xFE3A => array(0x3015),
2658                     0xFE3B => array(0x3010), 0xFE3C => array(0x3011), 0xFE3D => array(0x300A),
2659                     0xFE3E => array(0x300B), 0xFE3F => array(0x3008), 0xFE40 => array(0x3009),
2660                     0xFE41 => array(0x300C), 0xFE42 => array(0x300D), 0xFE43 => array(0x300E),
2661                     0xFE44 => array(0x300F), 0xFE51 => array(0x3001), 0xFE58 => array(0x2014),
2662                     0xFE5D => array(0x3014), 0xFE5E => array(0x3015), 0xFE63 => array(0x2D),
2663                     0xFE71 => array(0x640, 0x64B), 0xFE77 => array(0x640, 0x64E), 0xFE79 => array(0x640, 0x64F),
2664                     0xFE7B => array(0x640, 0x650), 0xFE7D => array(0x640, 0x651), 0xFE7F => array(0x640, 0x652),
2665                     0xFE80 => array(0x621), 0xFE81 => array(0x622), 0xFE82 => array(0x622),
2666                     0xFE83 => array(0x623), 0xFE84 => array(0x623), 0xFE85 => array(0x624),
2667                     0xFE86 => array(0x624), 0xFE87 => array(0x625), 0xFE88 => array(0x625),
2668                     0xFE89 => array(0x626), 0xFE8A => array(0x626), 0xFE8B => array(0x626),
2669                     0xFE8C => array(0x626), 0xFE8D => array(0x627), 0xFE8E => array(0x627),
2670                     0xFE8F => array(0x628), 0xFE90 => array(0x628), 0xFE91 => array(0x628),
2671                     0xFE92 => array(0x628), 0xFE93 => array(0x629), 0xFE94 => array(0x629),
2672                     0xFE95 => array(0x62A), 0xFE96 => array(0x62A), 0xFE97 => array(0x62A),
2673                     0xFE98 => array(0x62A), 0xFE99 => array(0x62B), 0xFE9A => array(0x62B),
2674                     0xFE9B => array(0x62B), 0xFE9C => array(0x62B), 0xFE9D => array(0x62C),
2675                     0xFE9E => array(0x62C), 0xFE9F => array(0x62C), 0xFEA0 => array(0x62C),
2676                     0xFEA1 => array(0x62D), 0xFEA2 => array(0x62D), 0xFEA3 => array(0x62D),
2677                     0xFEA4 => array(0x62D), 0xFEA5 => array(0x62E), 0xFEA6 => array(0x62E),
2678                     0xFEA7 => array(0x62E), 0xFEA8 => array(0x62E), 0xFEA9 => array(0x62F),
2679                     0xFEAA => array(0x62F), 0xFEAB => array(0x630), 0xFEAC => array(0x630),
2680                     0xFEAD => array(0x631), 0xFEAE => array(0x631), 0xFEAF => array(0x632),
2681                     0xFEB0 => array(0x632), 0xFEB1 => array(0x633), 0xFEB2 => array(0x633),
2682                     0xFEB3 => array(0x633), 0xFEB4 => array(0x633), 0xFEB5 => array(0x634),
2683                     0xFEB6 => array(0x634), 0xFEB7 => array(0x634), 0xFEB8 => array(0x634),
2684                     0xFEB9 => array(0x635), 0xFEBA => array(0x635), 0xFEBB => array(0x635),
2685                     0xFEBC => array(0x635), 0xFEBD => array(0x636), 0xFEBE => array(0x636),
2686                     0xFEBF => array(0x636), 0xFEC0 => array(0x636), 0xFEC1 => array(0x637),
2687                     0xFEC2 => array(0x637), 0xFEC3 => array(0x637), 0xFEC4 => array(0x637),
2688                     0xFEC5 => array(0x638), 0xFEC6 => array(0x638), 0xFEC7 => array(0x638),
2689                     0xFEC8 => array(0x638), 0xFEC9 => array(0x639), 0xFECA => array(0x639),
2690                     0xFECB => array(0x639), 0xFECC => array(0x639), 0xFECD => array(0x63A),
2691                     0xFECE => array(0x63A), 0xFECF => array(0x63A), 0xFED0 => array(0x63A),
2692                     0xFED1 => array(0x641), 0xFED2 => array(0x641), 0xFED3 => array(0x641),
2693                     0xFED4 => array(0x641), 0xFED5 => array(0x642), 0xFED6 => array(0x642),
2694                     0xFED7 => array(0x642), 0xFED8 => array(0x642), 0xFED9 => array(0x643),
2695                     0xFEDA => array(0x643), 0xFEDB => array(0x643), 0xFEDC => array(0x643),
2696                     0xFEDD => array(0x644), 0xFEDE => array(0x644), 0xFEDF => array(0x644),
2697                     0xFEE0 => array(0x644), 0xFEE1 => array(0x645), 0xFEE2 => array(0x645),
2698                     0xFEE3 => array(0x645), 0xFEE4 => array(0x645), 0xFEE5 => array(0x646),
2699                     0xFEE6 => array(0x646), 0xFEE7 => array(0x646), 0xFEE8 => array(0x646),
2700                     0xFEE9 => array(0x647), 0xFEEA => array(0x647), 0xFEEB => array(0x647),
2701                     0xFEEC => array(0x647), 0xFEED => array(0x648), 0xFEEE => array(0x648),
2702                     0xFEEF => array(0x649), 0xFEF0 => array(0x649), 0xFEF1 => array(0x64A),
2703                     0xFEF2 => array(0x64A), 0xFEF3 => array(0x64A), 0xFEF4 => array(0x64A),
2704                     0xFEF5 => array(0x644, 0x622), 0xFEF6 => array(0x644, 0x622), 0xFEF7 => array(0x644, 0x623),
2705                     0xFEF8 => array(0x644, 0x623), 0xFEF9 => array(0x644, 0x625), 0xFEFA => array(0x644, 0x625),
2706                     0xFEFB => array(0x644, 0x627), 0xFEFC => array(0x644, 0x627), 0xFF0D => array(0x2D),
2707                     0xFF0E => array(0x2E), 0xFF10 => array(0x30), 0xFF11 => array(0x31),
2708                     0xFF12 => array(0x32), 0xFF13 => array(0x33), 0xFF14 => array(0x34),
2709                     0xFF15 => array(0x35), 0xFF16 => array(0x36), 0xFF17 => array(0x37),
2710                     0xFF18 => array(0x38), 0xFF19 => array(0x39), 0xFF21 => array(0x61),
2711                     0xFF22 => array(0x62), 0xFF23 => array(0x63), 0xFF24 => array(0x64),
2712                     0xFF25 => array(0x65), 0xFF26 => array(0x66), 0xFF27 => array(0x67),
2713                     0xFF28 => array(0x68), 0xFF29 => array(0x69), 0xFF2A => array(0x6A),
2714                     0xFF2B => array(0x6B), 0xFF2C => array(0x6C), 0xFF2D => array(0x6D),
2715                     0xFF2E => array(0x6E), 0xFF2F => array(0x6F), 0xFF30 => array(0x70),
2716                     0xFF31 => array(0x71), 0xFF32 => array(0x72), 0xFF33 => array(0x73),
2717                     0xFF34 => array(0x74), 0xFF35 => array(0x75), 0xFF36 => array(0x76),
2718                     0xFF37 => array(0x77), 0xFF38 => array(0x78), 0xFF39 => array(0x79),
2719                     0xFF3A => array(0x7A), 0xFF41 => array(0x61), 0xFF42 => array(0x62),
2720                     0xFF43 => array(0x63), 0xFF44 => array(0x64), 0xFF45 => array(0x65),
2721                     0xFF46 => array(0x66), 0xFF47 => array(0x67), 0xFF48 => array(0x68),
2722                     0xFF49 => array(0x69), 0xFF4A => array(0x6A), 0xFF4B => array(0x6B),
2723                     0xFF4C => array(0x6C), 0xFF4D => array(0x6D), 0xFF4E => array(0x6E),
2724                     0xFF4F => array(0x6F), 0xFF50 => array(0x70), 0xFF51 => array(0x71),
2725                     0xFF52 => array(0x72), 0xFF53 => array(0x73), 0xFF54 => array(0x74),
2726                     0xFF55 => array(0x75), 0xFF56 => array(0x76), 0xFF57 => array(0x77),
2727                     0xFF58 => array(0x78), 0xFF59 => array(0x79), 0xFF5A => array(0x7A),
2728                     0xFF5F => array(0x2985), 0xFF60 => array(0x2986), 0xFF61 => array(0x2E),
2729                     0xFF62 => array(0x300C), 0xFF63 => array(0x300D), 0xFF64 => array(0x3001),
2730                     0xFF65 => array(0x30FB), 0xFF66 => array(0x30F2), 0xFF67 => array(0x30A1),
2731                     0xFF68 => array(0x30A3), 0xFF69 => array(0x30A5), 0xFF6A => array(0x30A7),
2732                     0xFF6B => array(0x30A9), 0xFF6C => array(0x30E3), 0xFF6D => array(0x30E5),
2733                     0xFF6E => array(0x30E7), 0xFF6F => array(0x30C3), 0xFF70 => array(0x30FC),
2734                     0xFF71 => array(0x30A2), 0xFF72 => array(0x30A4), 0xFF73 => array(0x30A6),
2735                     0xFF74 => array(0x30A8), 0xFF75 => array(0x30AA), 0xFF76 => array(0x30AB),
2736                     0xFF77 => array(0x30AD), 0xFF78 => array(0x30AF), 0xFF79 => array(0x30B1),
2737                     0xFF7A => array(0x30B3), 0xFF7B => array(0x30B5), 0xFF7C => array(0x30B7),
2738                     0xFF7D => array(0x30B9), 0xFF7E => array(0x30BB), 0xFF7F => array(0x30BD),
2739                     0xFF80 => array(0x30BF), 0xFF81 => array(0x30C1), 0xFF82 => array(0x30C4),
2740                     0xFF83 => array(0x30C6), 0xFF84 => array(0x30C8), 0xFF85 => array(0x30CA),
2741                     0xFF86 => array(0x30CB), 0xFF87 => array(0x30CC), 0xFF88 => array(0x30CD),
2742                     0xFF89 => array(0x30CE), 0xFF8A => array(0x30CF), 0xFF8B => array(0x30D2),
2743                     0xFF8C => array(0x30D5), 0xFF8D => array(0x30D8), 0xFF8E => array(0x30DB),
2744                     0xFF8F => array(0x30DE), 0xFF90 => array(0x30DF), 0xFF91 => array(0x30E0),
2745                     0xFF92 => array(0x30E1), 0xFF93 => array(0x30E2), 0xFF94 => array(0x30E4),
2746                     0xFF95 => array(0x30E6), 0xFF96 => array(0x30E8), 0xFF97 => array(0x30E9),
2747                     0xFF98 => array(0x30EA), 0xFF99 => array(0x30EB), 0xFF9A => array(0x30EC),
2748                     0xFF9B => array(0x30ED), 0xFF9C => array(0x30EF), 0xFF9D => array(0x30F3),
2749                     0xFF9E => array(0x3099), 0xFF9F => array(0x309A), 0xFFA1 => array(0x1100),
2750                     0xFFA2 => array(0x1101), 0xFFA3 => array(0x11AA), 0xFFA4 => array(0x1102),
2751                     0xFFA5 => array(0x11AC), 0xFFA6 => array(0x11AD), 0xFFA7 => array(0x1103),
2752                     0xFFA8 => array(0x1104), 0xFFA9 => array(0x1105), 0xFFAA => array(0x11B0),
2753                     0xFFAB => array(0x11B1), 0xFFAC => array(0x11B2), 0xFFAD => array(0x11B3),
2754                     0xFFAE => array(0x11B4), 0xFFAF => array(0x11B5), 0xFFB0 => array(0x111A),
2755                     0xFFB1 => array(0x1106), 0xFFB2 => array(0x1107), 0xFFB3 => array(0x1108),
2756                     0xFFB4 => array(0x1121), 0xFFB5 => array(0x1109), 0xFFB6 => array(0x110A),
2757                     0xFFB7 => array(0x110B), 0xFFB8 => array(0x110C), 0xFFB9 => array(0x110D),
2758                     0xFFBA => array(0x110E), 0xFFBB => array(0x110F), 0xFFBC => array(0x1110),
2759                     0xFFBD => array(0x1111), 0xFFBE => array(0x1112), 0xFFC2 => array(0x1161),
2760                     0xFFC3 => array(0x1162), 0xFFC4 => array(0x1163), 0xFFC5 => array(0x1164),
2761                     0xFFC6 => array(0x1165), 0xFFC7 => array(0x1166), 0xFFCA => array(0x1167),
2762                     0xFFCB => array(0x1168), 0xFFCC => array(0x1169), 0xFFCD => array(0x116A),
2763                     0xFFCE => array(0x116B), 0xFFCF => array(0x116C), 0xFFD2 => array(0x116D),
2764                     0xFFD3 => array(0x116E), 0xFFD4 => array(0x116F), 0xFFD5 => array(0x1170),
2765                     0xFFD6 => array(0x1171), 0xFFD7 => array(0x1172), 0xFFDA => array(0x1173),
2766                     0xFFDB => array(0x1174), 0xFFDC => array(0x1175), 0xFFE0 => array(0xA2),
2767                     0xFFE1 => array(0xA3), 0xFFE2 => array(0xAC), 0xFFE4 => array(0xA6),
2768                     0xFFE5 => array(0xA5), 0xFFE6 => array(0x20A9), 0xFFE8 => array(0x2502),
2769                     0xFFE9 => array(0x2190), 0xFFEA => array(0x2191), 0xFFEB => array(0x2192),
2770                     0xFFEC => array(0x2193), 0xFFED => array(0x25A0), 0xFFEE => array(0x25CB),
2771                     0x10400 => array(0x10428), 0x10401 => array(0x10429), 0x10402 => array(0x1042A),
2772                     0x10403 => array(0x1042B), 0x10404 => array(0x1042C), 0x10405 => array(0x1042D),
2773                     0x10406 => array(0x1042E), 0x10407 => array(0x1042F), 0x10408 => array(0x10430),
2774                     0x10409 => array(0x10431), 0x1040A => array(0x10432), 0x1040B => array(0x10433),
2775                     0x1040C => array(0x10434), 0x1040D => array(0x10435), 0x1040E => array(0x10436),
2776                     0x1040F => array(0x10437), 0x10410 => array(0x10438), 0x10411 => array(0x10439),
2777                     0x10412 => array(0x1043A), 0x10413 => array(0x1043B), 0x10414 => array(0x1043C),
2778                     0x10415 => array(0x1043D), 0x10416 => array(0x1043E), 0x10417 => array(0x1043F),
2779                     0x10418 => array(0x10440), 0x10419 => array(0x10441), 0x1041A => array(0x10442),
2780                     0x1041B => array(0x10443), 0x1041C => array(0x10444), 0x1041D => array(0x10445),
2781                     0x1041E => array(0x10446), 0x1041F => array(0x10447), 0x10420 => array(0x10448),
2782                     0x10421 => array(0x10449), 0x10422 => array(0x1044A), 0x10423 => array(0x1044B),
2783                     0x10424 => array(0x1044C), 0x10425 => array(0x1044D), 0x10426 => array(0x1044E),
2784                     0x10427 => array(0x1044F), 0x118A0 => array(0x118C0), 0x118A1 => array(0x118C1),
2785                     0x118A2 => array(0x118C2), 0x118A3 => array(0x118C3), 0x118A4 => array(0x118C4),
2786                     0x118A5 => array(0x118C5), 0x118A6 => array(0x118C6), 0x118A7 => array(0x118C7),
2787                     0x118A8 => array(0x118C8), 0x118A9 => array(0x118C9), 0x118AA => array(0x118CA),
2788                     0x118AB => array(0x118CB), 0x118AC => array(0x118CC), 0x118AD => array(0x118CD),
2789                     0x118AE => array(0x118CE), 0x118AF => array(0x118CF), 0x118B0 => array(0x118D0),
2790                     0x118B1 => array(0x118D1), 0x118B2 => array(0x118D2), 0x118B3 => array(0x118D3),
2791                     0x118B4 => array(0x118D4), 0x118B5 => array(0x118D5), 0x118B6 => array(0x118D6),
2792                     0x118B7 => array(0x118D7), 0x118B8 => array(0x118D8), 0x118B9 => array(0x118D9),
2793                     0x118BA => array(0x118DA), 0x118BB => array(0x118DB), 0x118BC => array(0x118DC),
2794                     0x118BD => array(0x118DD), 0x118BE => array(0x118DE), 0x118BF => array(0x118DF),
2795                     0x1D15E => array(0x1D157, 0x1D165), 0x1D15F => array(0x1D158, 0x1D165), 0x1D160 => array(0x1D158, 0x1D165, 0x1D16E),
2796                     0x1D161 => array(0x1D158, 0x1D165, 0x1D16F), 0x1D162 => array(0x1D158, 0x1D165, 0x1D170), 0x1D163 => array(0x1D158, 0x1D165, 0x1D171),
2797                     0x1D164 => array(0x1D158, 0x1D165, 0x1D172), 0x1D1BB => array(0x1D1B9, 0x1D165), 0x1D1BC => array(0x1D1BA, 0x1D165),
2798                     0x1D1BD => array(0x1D1B9, 0x1D165, 0x1D16E), 0x1D1BE => array(0x1D1BA, 0x1D165, 0x1D16E), 0x1D1BF => array(0x1D1B9, 0x1D165, 0x1D16F),
2799                     0x1D1C0 => array(0x1D1BA, 0x1D165, 0x1D16F), 0x1D400 => array(0x61), 0x1D401 => array(0x62),
2800                     0x1D402 => array(0x63), 0x1D403 => array(0x64), 0x1D404 => array(0x65),
2801                     0x1D405 => array(0x66), 0x1D406 => array(0x67), 0x1D407 => array(0x68),
2802                     0x1D408 => array(0x69), 0x1D409 => array(0x6A), 0x1D40A => array(0x6B),
2803                     0x1D40B => array(0x6C), 0x1D40C => array(0x6D), 0x1D40D => array(0x6E),
2804                     0x1D40E => array(0x6F), 0x1D40F => array(0x70), 0x1D410 => array(0x71),
2805                     0x1D411 => array(0x72), 0x1D412 => array(0x73), 0x1D413 => array(0x74),
2806                     0x1D414 => array(0x75), 0x1D415 => array(0x76), 0x1D416 => array(0x77),
2807                     0x1D417 => array(0x78), 0x1D418 => array(0x79), 0x1D419 => array(0x7A),
2808                     0x1D41A => array(0x61), 0x1D41B => array(0x62), 0x1D41C => array(0x63),
2809                     0x1D41D => array(0x64), 0x1D41E => array(0x65), 0x1D41F => array(0x66),
2810                     0x1D420 => array(0x67), 0x1D421 => array(0x68), 0x1D422 => array(0x69),
2811                     0x1D423 => array(0x6A), 0x1D424 => array(0x6B), 0x1D425 => array(0x6C),
2812                     0x1D426 => array(0x6D), 0x1D427 => array(0x6E), 0x1D428 => array(0x6F),
2813                     0x1D429 => array(0x70), 0x1D42A => array(0x71), 0x1D42B => array(0x72),
2814                     0x1D42C => array(0x73), 0x1D42D => array(0x74), 0x1D42E => array(0x75),
2815                     0x1D42F => array(0x76), 0x1D430 => array(0x77), 0x1D431 => array(0x78),
2816                     0x1D432 => array(0x79), 0x1D433 => array(0x7A), 0x1D434 => array(0x61),
2817                     0x1D435 => array(0x62), 0x1D436 => array(0x63), 0x1D437 => array(0x64),
2818                     0x1D438 => array(0x65), 0x1D439 => array(0x66), 0x1D43A => array(0x67),
2819                     0x1D43B => array(0x68), 0x1D43C => array(0x69), 0x1D43D => array(0x6A),
2820                     0x1D43E => array(0x6B), 0x1D43F => array(0x6C), 0x1D440 => array(0x6D),
2821                     0x1D441 => array(0x6E), 0x1D442 => array(0x6F), 0x1D443 => array(0x70),
2822                     0x1D444 => array(0x71), 0x1D445 => array(0x72), 0x1D446 => array(0x73),
2823                     0x1D447 => array(0x74), 0x1D448 => array(0x75), 0x1D449 => array(0x76),
2824                     0x1D44A => array(0x77), 0x1D44B => array(0x78), 0x1D44C => array(0x79),
2825                     0x1D44D => array(0x7A), 0x1D44E => array(0x61), 0x1D44F => array(0x62),
2826                     0x1D450 => array(0x63), 0x1D451 => array(0x64), 0x1D452 => array(0x65),
2827                     0x1D453 => array(0x66), 0x1D454 => array(0x67), 0x1D456 => array(0x69),
2828                     0x1D457 => array(0x6A), 0x1D458 => array(0x6B), 0x1D459 => array(0x6C),
2829                     0x1D45A => array(0x6D), 0x1D45B => array(0x6E), 0x1D45C => array(0x6F),
2830                     0x1D45D => array(0x70), 0x1D45E => array(0x71), 0x1D45F => array(0x72),
2831                     0x1D460 => array(0x73), 0x1D461 => array(0x74), 0x1D462 => array(0x75),
2832                     0x1D463 => array(0x76), 0x1D464 => array(0x77), 0x1D465 => array(0x78),
2833                     0x1D466 => array(0x79), 0x1D467 => array(0x7A), 0x1D468 => array(0x61),
2834                     0x1D469 => array(0x62), 0x1D46A => array(0x63), 0x1D46B => array(0x64),
2835                     0x1D46C => array(0x65), 0x1D46D => array(0x66), 0x1D46E => array(0x67),
2836                     0x1D46F => array(0x68), 0x1D470 => array(0x69), 0x1D471 => array(0x6A),
2837                     0x1D472 => array(0x6B), 0x1D473 => array(0x6C), 0x1D474 => array(0x6D),
2838                     0x1D475 => array(0x6E), 0x1D476 => array(0x6F), 0x1D477 => array(0x70),
2839                     0x1D478 => array(0x71), 0x1D479 => array(0x72), 0x1D47A => array(0x73),
2840                     0x1D47B => array(0x74), 0x1D47C => array(0x75), 0x1D47D => array(0x76),
2841                     0x1D47E => array(0x77), 0x1D47F => array(0x78), 0x1D480 => array(0x79),
2842                     0x1D481 => array(0x7A), 0x1D482 => array(0x61), 0x1D483 => array(0x62),
2843                     0x1D484 => array(0x63), 0x1D485 => array(0x64), 0x1D486 => array(0x65),
2844                     0x1D487 => array(0x66), 0x1D488 => array(0x67), 0x1D489 => array(0x68),
2845                     0x1D48A => array(0x69), 0x1D48B => array(0x6A), 0x1D48C => array(0x6B),
2846                     0x1D48D => array(0x6C), 0x1D48E => array(0x6D), 0x1D48F => array(0x6E),
2847                     0x1D490 => array(0x6F), 0x1D491 => array(0x70), 0x1D492 => array(0x71),
2848                     0x1D493 => array(0x72), 0x1D494 => array(0x73), 0x1D495 => array(0x74),
2849                     0x1D496 => array(0x75), 0x1D497 => array(0x76), 0x1D498 => array(0x77),
2850                     0x1D499 => array(0x78), 0x1D49A => array(0x79), 0x1D49B => array(0x7A),
2851                     0x1D49C => array(0x61), 0x1D49E => array(0x63), 0x1D49F => array(0x64),
2852                     0x1D4A2 => array(0x67), 0x1D4A5 => array(0x6A), 0x1D4A6 => array(0x6B),
2853                     0x1D4A9 => array(0x6E), 0x1D4AA => array(0x6F), 0x1D4AB => array(0x70),
2854                     0x1D4AC => array(0x71), 0x1D4AE => array(0x73), 0x1D4AF => array(0x74),
2855                     0x1D4B0 => array(0x75), 0x1D4B1 => array(0x76), 0x1D4B2 => array(0x77),
2856                     0x1D4B3 => array(0x78), 0x1D4B4 => array(0x79), 0x1D4B5 => array(0x7A),
2857                     0x1D4B6 => array(0x61), 0x1D4B7 => array(0x62), 0x1D4B8 => array(0x63),
2858                     0x1D4B9 => array(0x64), 0x1D4BB => array(0x66), 0x1D4BD => array(0x68),
2859                     0x1D4BE => array(0x69), 0x1D4BF => array(0x6A), 0x1D4C0 => array(0x6B),
2860                     0x1D4C1 => array(0x6C), 0x1D4C2 => array(0x6D), 0x1D4C3 => array(0x6E),
2861                     0x1D4C5 => array(0x70), 0x1D4C6 => array(0x71), 0x1D4C7 => array(0x72),
2862                     0x1D4C8 => array(0x73), 0x1D4C9 => array(0x74), 0x1D4CA => array(0x75),
2863                     0x1D4CB => array(0x76), 0x1D4CC => array(0x77), 0x1D4CD => array(0x78),
2864                     0x1D4CE => array(0x79), 0x1D4CF => array(0x7A), 0x1D4D0 => array(0x61),
2865                     0x1D4D1 => array(0x62), 0x1D4D2 => array(0x63), 0x1D4D3 => array(0x64),
2866                     0x1D4D4 => array(0x65), 0x1D4D5 => array(0x66), 0x1D4D6 => array(0x67),
2867                     0x1D4D7 => array(0x68), 0x1D4D8 => array(0x69), 0x1D4D9 => array(0x6A),
2868                     0x1D4DA => array(0x6B), 0x1D4DB => array(0x6C), 0x1D4DC => array(0x6D),
2869                     0x1D4DD => array(0x6E), 0x1D4DE => array(0x6F), 0x1D4DF => array(0x70),
2870                     0x1D4E0 => array(0x71), 0x1D4E1 => array(0x72), 0x1D4E2 => array(0x73),
2871                     0x1D4E3 => array(0x74), 0x1D4E4 => array(0x75), 0x1D4E5 => array(0x76),
2872                     0x1D4E6 => array(0x77), 0x1D4E7 => array(0x78), 0x1D4E8 => array(0x79),
2873                     0x1D4E9 => array(0x7A), 0x1D4EA => array(0x61), 0x1D4EB => array(0x62),
2874                     0x1D4EC => array(0x63), 0x1D4ED => array(0x64), 0x1D4EE => array(0x65),
2875                     0x1D4EF => array(0x66), 0x1D4F0 => array(0x67), 0x1D4F1 => array(0x68),
2876                     0x1D4F2 => array(0x69), 0x1D4F3 => array(0x6A), 0x1D4F4 => array(0x6B),
2877                     0x1D4F5 => array(0x6C), 0x1D4F6 => array(0x6D), 0x1D4F7 => array(0x6E),
2878                     0x1D4F8 => array(0x6F), 0x1D4F9 => array(0x70), 0x1D4FA => array(0x71),
2879                     0x1D4FB => array(0x72), 0x1D4FC => array(0x73), 0x1D4FD => array(0x74),
2880                     0x1D4FE => array(0x75), 0x1D4FF => array(0x76), 0x1D500 => array(0x77),
2881                     0x1D501 => array(0x78), 0x1D502 => array(0x79), 0x1D503 => array(0x7A),
2882                     0x1D504 => array(0x61), 0x1D505 => array(0x62), 0x1D507 => array(0x64),
2883                     0x1D508 => array(0x65), 0x1D509 => array(0x66), 0x1D50A => array(0x67),
2884                     0x1D50D => array(0x6A), 0x1D50E => array(0x6B), 0x1D50F => array(0x6C),
2885                     0x1D510 => array(0x6D), 0x1D511 => array(0x6E), 0x1D512 => array(0x6F),
2886                     0x1D513 => array(0x70), 0x1D514 => array(0x71), 0x1D516 => array(0x73),
2887                     0x1D517 => array(0x74), 0x1D518 => array(0x75), 0x1D519 => array(0x76),
2888                     0x1D51A => array(0x77), 0x1D51B => array(0x78), 0x1D51C => array(0x79),
2889                     0x1D51E => array(0x61), 0x1D51F => array(0x62), 0x1D520 => array(0x63),
2890                     0x1D521 => array(0x64), 0x1D522 => array(0x65), 0x1D523 => array(0x66),
2891                     0x1D524 => array(0x67), 0x1D525 => array(0x68), 0x1D526 => array(0x69),
2892                     0x1D527 => array(0x6A), 0x1D528 => array(0x6B), 0x1D529 => array(0x6C),
2893                     0x1D52A => array(0x6D), 0x1D52B => array(0x6E), 0x1D52C => array(0x6F),
2894                     0x1D52D => array(0x70), 0x1D52E => array(0x71), 0x1D52F => array(0x72),
2895                     0x1D530 => array(0x73), 0x1D531 => array(0x74), 0x1D532 => array(0x75),
2896                     0x1D533 => array(0x76), 0x1D534 => array(0x77), 0x1D535 => array(0x78),
2897                     0x1D536 => array(0x79), 0x1D537 => array(0x7A), 0x1D538 => array(0x61),
2898                     0x1D539 => array(0x62), 0x1D53B => array(0x64), 0x1D53C => array(0x65),
2899                     0x1D53D => array(0x66), 0x1D53E => array(0x67), 0x1D540 => array(0x69),
2900                     0x1D541 => array(0x6A), 0x1D542 => array(0x6B), 0x1D543 => array(0x6C),
2901                     0x1D544 => array(0x6D), 0x1D546 => array(0x6F), 0x1D54A => array(0x73),
2902                     0x1D54B => array(0x74), 0x1D54C => array(0x75), 0x1D54D => array(0x76),
2903                     0x1D54E => array(0x77), 0x1D54F => array(0x78), 0x1D550 => array(0x79),
2904                     0x1D552 => array(0x61), 0x1D553 => array(0x62), 0x1D554 => array(0x63),
2905                     0x1D555 => array(0x64), 0x1D556 => array(0x65), 0x1D557 => array(0x66),
2906                     0x1D558 => array(0x67), 0x1D559 => array(0x68), 0x1D55A => array(0x69),
2907                     0x1D55B => array(0x6A), 0x1D55C => array(0x6B), 0x1D55D => array(0x6C),
2908                     0x1D55E => array(0x6D), 0x1D55F => array(0x6E), 0x1D560 => array(0x6F),
2909                     0x1D561 => array(0x70), 0x1D562 => array(0x71), 0x1D563 => array(0x72),
2910                     0x1D564 => array(0x73), 0x1D565 => array(0x74), 0x1D566 => array(0x75),
2911                     0x1D567 => array(0x76), 0x1D568 => array(0x77), 0x1D569 => array(0x78),
2912                     0x1D56A => array(0x79), 0x1D56B => array(0x7A), 0x1D56C => array(0x61),
2913                     0x1D56D => array(0x62), 0x1D56E => array(0x63), 0x1D56F => array(0x64),
2914                     0x1D570 => array(0x65), 0x1D571 => array(0x66), 0x1D572 => array(0x67),
2915                     0x1D573 => array(0x68), 0x1D574 => array(0x69), 0x1D575 => array(0x6A),
2916                     0x1D576 => array(0x6B), 0x1D577 => array(0x6C), 0x1D578 => array(0x6D),
2917                     0x1D579 => array(0x6E), 0x1D57A => array(0x6F), 0x1D57B => array(0x70),
2918                     0x1D57C => array(0x71), 0x1D57D => array(0x72), 0x1D57E => array(0x73),
2919                     0x1D57F => array(0x74), 0x1D580 => array(0x75), 0x1D581 => array(0x76),
2920                     0x1D582 => array(0x77), 0x1D583 => array(0x78), 0x1D584 => array(0x79),
2921                     0x1D585 => array(0x7A), 0x1D586 => array(0x61), 0x1D587 => array(0x62),
2922                     0x1D588 => array(0x63), 0x1D589 => array(0x64), 0x1D58A => array(0x65),
2923                     0x1D58B => array(0x66), 0x1D58C => array(0x67), 0x1D58D => array(0x68),
2924                     0x1D58E => array(0x69), 0x1D58F => array(0x6A), 0x1D590 => array(0x6B),
2925                     0x1D591 => array(0x6C), 0x1D592 => array(0x6D), 0x1D593 => array(0x6E),
2926                     0x1D594 => array(0x6F), 0x1D595 => array(0x70), 0x1D596 => array(0x71),
2927                     0x1D597 => array(0x72), 0x1D598 => array(0x73), 0x1D599 => array(0x74),
2928                     0x1D59A => array(0x75), 0x1D59B => array(0x76), 0x1D59C => array(0x77),
2929                     0x1D59D => array(0x78), 0x1D59E => array(0x79), 0x1D59F => array(0x7A),
2930                     0x1D5A0 => array(0x61), 0x1D5A1 => array(0x62), 0x1D5A2 => array(0x63),
2931                     0x1D5A3 => array(0x64), 0x1D5A4 => array(0x65), 0x1D5A5 => array(0x66),
2932                     0x1D5A6 => array(0x67), 0x1D5A7 => array(0x68), 0x1D5A8 => array(0x69),
2933                     0x1D5A9 => array(0x6A), 0x1D5AA => array(0x6B), 0x1D5AB => array(0x6C),
2934                     0x1D5AC => array(0x6D), 0x1D5AD => array(0x6E), 0x1D5AE => array(0x6F),
2935                     0x1D5AF => array(0x70), 0x1D5B0 => array(0x71), 0x1D5B1 => array(0x72),
2936                     0x1D5B2 => array(0x73), 0x1D5B3 => array(0x74), 0x1D5B4 => array(0x75),
2937                     0x1D5B5 => array(0x76), 0x1D5B6 => array(0x77), 0x1D5B7 => array(0x78),
2938                     0x1D5B8 => array(0x79), 0x1D5B9 => array(0x7A), 0x1D5BA => array(0x61),
2939                     0x1D5BB => array(0x62), 0x1D5BC => array(0x63), 0x1D5BD => array(0x64),
2940                     0x1D5BE => array(0x65), 0x1D5BF => array(0x66), 0x1D5C0 => array(0x67),
2941                     0x1D5C1 => array(0x68), 0x1D5C2 => array(0x69), 0x1D5C3 => array(0x6A),
2942                     0x1D5C4 => array(0x6B), 0x1D5C5 => array(0x6C), 0x1D5C6 => array(0x6D),
2943                     0x1D5C7 => array(0x6E), 0x1D5C8 => array(0x6F), 0x1D5C9 => array(0x70),
2944                     0x1D5CA => array(0x71), 0x1D5CB => array(0x72), 0x1D5CC => array(0x73),
2945                     0x1D5CD => array(0x74), 0x1D5CE => array(0x75), 0x1D5CF => array(0x76),
2946                     0x1D5D0 => array(0x77), 0x1D5D1 => array(0x78), 0x1D5D2 => array(0x79),
2947                     0x1D5D3 => array(0x7A), 0x1D5D4 => array(0x61), 0x1D5D5 => array(0x62),
2948                     0x1D5D6 => array(0x63), 0x1D5D7 => array(0x64), 0x1D5D8 => array(0x65),
2949                     0x1D5D9 => array(0x66), 0x1D5DA => array(0x67), 0x1D5DB => array(0x68),
2950                     0x1D5DC => array(0x69), 0x1D5DD => array(0x6A), 0x1D5DE => array(0x6B),
2951                     0x1D5DF => array(0x6C), 0x1D5E0 => array(0x6D), 0x1D5E1 => array(0x6E),
2952                     0x1D5E2 => array(0x6F), 0x1D5E3 => array(0x70), 0x1D5E4 => array(0x71),
2953                     0x1D5E5 => array(0x72), 0x1D5E6 => array(0x73), 0x1D5E7 => array(0x74),
2954                     0x1D5E8 => array(0x75), 0x1D5E9 => array(0x76), 0x1D5EA => array(0x77),
2955                     0x1D5EB => array(0x78), 0x1D5EC => array(0x79), 0x1D5ED => array(0x7A),
2956                     0x1D5EE => array(0x61), 0x1D5EF => array(0x62), 0x1D5F0 => array(0x63),
2957                     0x1D5F1 => array(0x64), 0x1D5F2 => array(0x65), 0x1D5F3 => array(0x66),
2958                     0x1D5F4 => array(0x67), 0x1D5F5 => array(0x68), 0x1D5F6 => array(0x69),
2959                     0x1D5F7 => array(0x6A), 0x1D5F8 => array(0x6B), 0x1D5F9 => array(0x6C),
2960                     0x1D5FA => array(0x6D), 0x1D5FB => array(0x6E), 0x1D5FC => array(0x6F),
2961                     0x1D5FD => array(0x70), 0x1D5FE => array(0x71), 0x1D5FF => array(0x72),
2962                     0x1D600 => array(0x73), 0x1D601 => array(0x74), 0x1D602 => array(0x75),
2963                     0x1D603 => array(0x76), 0x1D604 => array(0x77), 0x1D605 => array(0x78),
2964                     0x1D606 => array(0x79), 0x1D607 => array(0x7A), 0x1D608 => array(0x61),
2965                     0x1D609 => array(0x62), 0x1D60A => array(0x63), 0x1D60B => array(0x64),
2966                     0x1D60C => array(0x65), 0x1D60D => array(0x66), 0x1D60E => array(0x67),
2967                     0x1D60F => array(0x68), 0x1D610 => array(0x69), 0x1D611 => array(0x6A),
2968                     0x1D612 => array(0x6B), 0x1D613 => array(0x6C), 0x1D614 => array(0x6D),
2969                     0x1D615 => array(0x6E), 0x1D616 => array(0x6F), 0x1D617 => array(0x70),
2970                     0x1D618 => array(0x71), 0x1D619 => array(0x72), 0x1D61A => array(0x73),
2971                     0x1D61B => array(0x74), 0x1D61C => array(0x75), 0x1D61D => array(0x76),
2972                     0x1D61E => array(0x77), 0x1D61F => array(0x78), 0x1D620 => array(0x79),
2973                     0x1D621 => array(0x7A), 0x1D622 => array(0x61), 0x1D623 => array(0x62),
2974                     0x1D624 => array(0x63), 0x1D625 => array(0x64), 0x1D626 => array(0x65),
2975                     0x1D627 => array(0x66), 0x1D628 => array(0x67), 0x1D629 => array(0x68),
2976                     0x1D62A => array(0x69), 0x1D62B => array(0x6A), 0x1D62C => array(0x6B),
2977                     0x1D62D => array(0x6C), 0x1D62E => array(0x6D), 0x1D62F => array(0x6E),
2978                     0x1D630 => array(0x6F), 0x1D631 => array(0x70), 0x1D632 => array(0x71),
2979                     0x1D633 => array(0x72), 0x1D634 => array(0x73), 0x1D635 => array(0x74),
2980                     0x1D636 => array(0x75), 0x1D637 => array(0x76), 0x1D638 => array(0x77),
2981                     0x1D639 => array(0x78), 0x1D63A => array(0x79), 0x1D63B => array(0x7A),
2982                     0x1D63C => array(0x61), 0x1D63D => array(0x62), 0x1D63E => array(0x63),
2983                     0x1D63F => array(0x64), 0x1D640 => array(0x65), 0x1D641 => array(0x66),
2984                     0x1D642 => array(0x67), 0x1D643 => array(0x68), 0x1D644 => array(0x69),
2985                     0x1D645 => array(0x6A), 0x1D646 => array(0x6B), 0x1D647 => array(0x6C),
2986                     0x1D648 => array(0x6D), 0x1D649 => array(0x6E), 0x1D64A => array(0x6F),
2987                     0x1D64B => array(0x70), 0x1D64C => array(0x71), 0x1D64D => array(0x72),
2988                     0x1D64E => array(0x73), 0x1D64F => array(0x74), 0x1D650 => array(0x75),
2989                     0x1D651 => array(0x76), 0x1D652 => array(0x77), 0x1D653 => array(0x78),
2990                     0x1D654 => array(0x79), 0x1D655 => array(0x7A), 0x1D656 => array(0x61),
2991                     0x1D657 => array(0x62), 0x1D658 => array(0x63), 0x1D659 => array(0x64),
2992                     0x1D65A => array(0x65), 0x1D65B => array(0x66), 0x1D65C => array(0x67),
2993                     0x1D65D => array(0x68), 0x1D65E => array(0x69), 0x1D65F => array(0x6A),
2994                     0x1D660 => array(0x6B), 0x1D661 => array(0x6C), 0x1D662 => array(0x6D),
2995                     0x1D663 => array(0x6E), 0x1D664 => array(0x6F), 0x1D665 => array(0x70),
2996                     0x1D666 => array(0x71), 0x1D667 => array(0x72), 0x1D668 => array(0x73),
2997                     0x1D669 => array(0x74), 0x1D66A => array(0x75), 0x1D66B => array(0x76),
2998                     0x1D66C => array(0x77), 0x1D66D => array(0x78), 0x1D66E => array(0x79),
2999                     0x1D66F => array(0x7A), 0x1D670 => array(0x61), 0x1D671 => array(0x62),
3000                     0x1D672 => array(0x63), 0x1D673 => array(0x64), 0x1D674 => array(0x65),
3001                     0x1D675 => array(0x66), 0x1D676 => array(0x67), 0x1D677 => array(0x68),
3002                     0x1D678 => array(0x69), 0x1D679 => array(0x6A), 0x1D67A => array(0x6B),
3003                     0x1D67B => array(0x6C), 0x1D67C => array(0x6D), 0x1D67D => array(0x6E),
3004                     0x1D67E => array(0x6F), 0x1D67F => array(0x70), 0x1D680 => array(0x71),
3005                     0x1D681 => array(0x72), 0x1D682 => array(0x73), 0x1D683 => array(0x74),
3006                     0x1D684 => array(0x75), 0x1D685 => array(0x76), 0x1D686 => array(0x77),
3007                     0x1D687 => array(0x78), 0x1D688 => array(0x79), 0x1D689 => array(0x7A),
3008                     0x1D68A => array(0x61), 0x1D68B => array(0x62), 0x1D68C => array(0x63),
3009                     0x1D68D => array(0x64), 0x1D68E => array(0x65), 0x1D68F => array(0x66),
3010                     0x1D690 => array(0x67), 0x1D691 => array(0x68), 0x1D692 => array(0x69),
3011                     0x1D693 => array(0x6A), 0x1D694 => array(0x6B), 0x1D695 => array(0x6C),
3012                     0x1D696 => array(0x6D), 0x1D697 => array(0x6E), 0x1D698 => array(0x6F),
3013                     0x1D699 => array(0x70), 0x1D69A => array(0x71), 0x1D69B => array(0x72),
3014                     0x1D69C => array(0x73), 0x1D69D => array(0x74), 0x1D69E => array(0x75),
3015                     0x1D69F => array(0x76), 0x1D6A0 => array(0x77), 0x1D6A1 => array(0x78),
3016                     0x1D6A2 => array(0x79), 0x1D6A3 => array(0x7A), 0x1D6A4 => array(0x131),
3017                     0x1D6A5 => array(0x237), 0x1D6A8 => array(0x3B1), 0x1D6A9 => array(0x3B2),
3018                     0x1D6AA => array(0x3B3), 0x1D6AB => array(0x3B4), 0x1D6AC => array(0x3B5),
3019                     0x1D6AD => array(0x3B6), 0x1D6AE => array(0x3B7), 0x1D6AF => array(0x3B8),
3020                     0x1D6B0 => array(0x3B9), 0x1D6B1 => array(0x3BA), 0x1D6B2 => array(0x3BB),
3021                     0x1D6B3 => array(0x3BC), 0x1D6B4 => array(0x3BD), 0x1D6B5 => array(0x3BE),
3022                     0x1D6B6 => array(0x3BF), 0x1D6B7 => array(0x3C0), 0x1D6B8 => array(0x3C1),
3023                     0x1D6B9 => array(0x3B8), 0x1D6BA => array(0x3C3), 0x1D6BB => array(0x3C4),
3024                     0x1D6BC => array(0x3C5), 0x1D6BD => array(0x3C6), 0x1D6BE => array(0x3C7),
3025                     0x1D6BF => array(0x3C8), 0x1D6C0 => array(0x3C9), 0x1D6C1 => array(0x2207),
3026                     0x1D6C2 => array(0x3B1), 0x1D6C3 => array(0x3B2), 0x1D6C4 => array(0x3B3),
3027                     0x1D6C5 => array(0x3B4), 0x1D6C6 => array(0x3B5), 0x1D6C7 => array(0x3B6),
3028                     0x1D6C8 => array(0x3B7), 0x1D6C9 => array(0x3B8), 0x1D6CA => array(0x3B9),
3029                     0x1D6CB => array(0x3BA), 0x1D6CC => array(0x3BB), 0x1D6CD => array(0x3BC),
3030                     0x1D6CE => array(0x3BD), 0x1D6CF => array(0x3BE), 0x1D6D0 => array(0x3BF),
3031                     0x1D6D1 => array(0x3C0), 0x1D6D2 => array(0x3C1), 0x1D6D3 => array(0x3C3),
3032                     0x1D6D4 => array(0x3C3), 0x1D6D5 => array(0x3C4), 0x1D6D6 => array(0x3C5),
3033                     0x1D6D7 => array(0x3C6), 0x1D6D8 => array(0x3C7), 0x1D6D9 => array(0x3C8),
3034                     0x1D6DA => array(0x3C9), 0x1D6DB => array(0x2202), 0x1D6DC => array(0x3B5),
3035                     0x1D6DD => array(0x3B8), 0x1D6DE => array(0x3BA), 0x1D6DF => array(0x3C6),
3036                     0x1D6E0 => array(0x3C1), 0x1D6E1 => array(0x3C0), 0x1D6E2 => array(0x3B1),
3037                     0x1D6E3 => array(0x3B2), 0x1D6E4 => array(0x3B3), 0x1D6E5 => array(0x3B4),
3038                     0x1D6E6 => array(0x3B5), 0x1D6E7 => array(0x3B6), 0x1D6E8 => array(0x3B7),
3039                     0x1D6E9 => array(0x3B8), 0x1D6EA => array(0x3B9), 0x1D6EB => array(0x3BA),
3040                     0x1D6EC => array(0x3BB), 0x1D6ED => array(0x3BC), 0x1D6EE => array(0x3BD),
3041                     0x1D6EF => array(0x3BE), 0x1D6F0 => array(0x3BF), 0x1D6F1 => array(0x3C0),
3042                     0x1D6F2 => array(0x3C1), 0x1D6F3 => array(0x3B8), 0x1D6F4 => array(0x3C3),
3043                     0x1D6F5 => array(0x3C4), 0x1D6F6 => array(0x3C5), 0x1D6F7 => array(0x3C6),
3044                     0x1D6F8 => array(0x3C7), 0x1D6F9 => array(0x3C8), 0x1D6FA => array(0x3C9),
3045                     0x1D6FB => array(0x2207), 0x1D6FC => array(0x3B1), 0x1D6FD => array(0x3B2),
3046                     0x1D6FE => array(0x3B3), 0x1D6FF => array(0x3B4), 0x1D700 => array(0x3B5),
3047                     0x1D701 => array(0x3B6), 0x1D702 => array(0x3B7), 0x1D703 => array(0x3B8),
3048                     0x1D704 => array(0x3B9), 0x1D705 => array(0x3BA), 0x1D706 => array(0x3BB),
3049                     0x1D707 => array(0x3BC), 0x1D708 => array(0x3BD), 0x1D709 => array(0x3BE),
3050                     0x1D70A => array(0x3BF), 0x1D70B => array(0x3C0), 0x1D70C => array(0x3C1),
3051                     0x1D70D => array(0x3C3), 0x1D70E => array(0x3C3), 0x1D70F => array(0x3C4),
3052                     0x1D710 => array(0x3C5), 0x1D711 => array(0x3C6), 0x1D712 => array(0x3C7),
3053                     0x1D713 => array(0x3C8), 0x1D714 => array(0x3C9), 0x1D715 => array(0x2202),
3054                     0x1D716 => array(0x3B5), 0x1D717 => array(0x3B8), 0x1D718 => array(0x3BA),
3055                     0x1D719 => array(0x3C6), 0x1D71A => array(0x3C1), 0x1D71B => array(0x3C0),
3056                     0x1D71C => array(0x3B1), 0x1D71D => array(0x3B2), 0x1D71E => array(0x3B3),
3057                     0x1D71F => array(0x3B4), 0x1D720 => array(0x3B5), 0x1D721 => array(0x3B6),
3058                     0x1D722 => array(0x3B7), 0x1D723 => array(0x3B8), 0x1D724 => array(0x3B9),
3059                     0x1D725 => array(0x3BA), 0x1D726 => array(0x3BB), 0x1D727 => array(0x3BC),
3060                     0x1D728 => array(0x3BD), 0x1D729 => array(0x3BE), 0x1D72A => array(0x3BF),
3061                     0x1D72B => array(0x3C0), 0x1D72C => array(0x3C1), 0x1D72D => array(0x3B8),
3062                     0x1D72E => array(0x3C3), 0x1D72F => array(0x3C4), 0x1D730 => array(0x3C5),
3063                     0x1D731 => array(0x3C6), 0x1D732 => array(0x3C7), 0x1D733 => array(0x3C8),
3064                     0x1D734 => array(0x3C9), 0x1D735 => array(0x2207), 0x1D736 => array(0x3B1),
3065                     0x1D737 => array(0x3B2), 0x1D738 => array(0x3B3), 0x1D739 => array(0x3B4),
3066                     0x1D73A => array(0x3B5), 0x1D73B => array(0x3B6), 0x1D73C => array(0x3B7),
3067                     0x1D73D => array(0x3B8), 0x1D73E => array(0x3B9), 0x1D73F => array(0x3BA),
3068                     0x1D740 => array(0x3BB), 0x1D741 => array(0x3BC), 0x1D742 => array(0x3BD),
3069                     0x1D743 => array(0x3BE), 0x1D744 => array(0x3BF), 0x1D745 => array(0x3C0),
3070                     0x1D746 => array(0x3C1), 0x1D747 => array(0x3C3), 0x1D748 => array(0x3C3),
3071                     0x1D749 => array(0x3C4), 0x1D74A => array(0x3C5), 0x1D74B => array(0x3C6),
3072                     0x1D74C => array(0x3C7), 0x1D74D => array(0x3C8), 0x1D74E => array(0x3C9),
3073                     0x1D74F => array(0x2202), 0x1D750 => array(0x3B5), 0x1D751 => array(0x3B8),
3074                     0x1D752 => array(0x3BA), 0x1D753 => array(0x3C6), 0x1D754 => array(0x3C1),
3075                     0x1D755 => array(0x3C0), 0x1D756 => array(0x3B1), 0x1D757 => array(0x3B2),
3076                     0x1D758 => array(0x3B3), 0x1D759 => array(0x3B4), 0x1D75A => array(0x3B5),
3077                     0x1D75B => array(0x3B6), 0x1D75C => array(0x3B7), 0x1D75D => array(0x3B8),
3078                     0x1D75E => array(0x3B9), 0x1D75F => array(0x3BA), 0x1D760 => array(0x3BB),
3079                     0x1D761 => array(0x3BC), 0x1D762 => array(0x3BD), 0x1D763 => array(0x3BE),
3080                     0x1D764 => array(0x3BF), 0x1D765 => array(0x3C0), 0x1D766 => array(0x3C1),
3081                     0x1D767 => array(0x3B8), 0x1D768 => array(0x3C3), 0x1D769 => array(0x3C4),
3082                     0x1D76A => array(0x3C5), 0x1D76B => array(0x3C6), 0x1D76C => array(0x3C7),
3083                     0x1D76D => array(0x3C8), 0x1D76E => array(0x3C9), 0x1D76F => array(0x2207),
3084                     0x1D770 => array(0x3B1), 0x1D771 => array(0x3B2), 0x1D772 => array(0x3B3),
3085                     0x1D773 => array(0x3B4), 0x1D774 => array(0x3B5), 0x1D775 => array(0x3B6),
3086                     0x1D776 => array(0x3B7), 0x1D777 => array(0x3B8), 0x1D778 => array(0x3B9),
3087                     0x1D779 => array(0x3BA), 0x1D77A => array(0x3BB), 0x1D77B => array(0x3BC),
3088                     0x1D77C => array(0x3BD), 0x1D77D => array(0x3BE), 0x1D77E => array(0x3BF),
3089                     0x1D77F => array(0x3C0), 0x1D780 => array(0x3C1), 0x1D781 => array(0x3C3),
3090                     0x1D782 => array(0x3C3), 0x1D783 => array(0x3C4), 0x1D784 => array(0x3C5),
3091                     0x1D785 => array(0x3C6), 0x1D786 => array(0x3C7), 0x1D787 => array(0x3C8),
3092                     0x1D788 => array(0x3C9), 0x1D789 => array(0x2202), 0x1D78A => array(0x3B5),
3093                     0x1D78B => array(0x3B8), 0x1D78C => array(0x3BA), 0x1D78D => array(0x3C6),
3094                     0x1D78E => array(0x3C1), 0x1D78F => array(0x3C0), 0x1D790 => array(0x3B1),
3095                     0x1D791 => array(0x3B2), 0x1D792 => array(0x3B3), 0x1D793 => array(0x3B4),
3096                     0x1D794 => array(0x3B5), 0x1D795 => array(0x3B6), 0x1D796 => array(0x3B7),
3097                     0x1D797 => array(0x3B8), 0x1D798 => array(0x3B9), 0x1D799 => array(0x3BA),
3098                     0x1D79A => array(0x3BB), 0x1D79B => array(0x3BC), 0x1D79C => array(0x3BD),
3099                     0x1D79D => array(0x3BE), 0x1D79E => array(0x3BF), 0x1D79F => array(0x3C0),
3100                     0x1D7A0 => array(0x3C1), 0x1D7A1 => array(0x3B8), 0x1D7A2 => array(0x3C3),
3101                     0x1D7A3 => array(0x3C4), 0x1D7A4 => array(0x3C5), 0x1D7A5 => array(0x3C6),
3102                     0x1D7A6 => array(0x3C7), 0x1D7A7 => array(0x3C8), 0x1D7A8 => array(0x3C9),
3103                     0x1D7A9 => array(0x2207), 0x1D7AA => array(0x3B1), 0x1D7AB => array(0x3B2),
3104                     0x1D7AC => array(0x3B3), 0x1D7AD => array(0x3B4), 0x1D7AE => array(0x3B5),
3105                     0x1D7AF => array(0x3B6), 0x1D7B0 => array(0x3B7), 0x1D7B1 => array(0x3B8),
3106                     0x1D7B2 => array(0x3B9), 0x1D7B3 => array(0x3BA), 0x1D7B4 => array(0x3BB),
3107                     0x1D7B5 => array(0x3BC), 0x1D7B6 => array(0x3BD), 0x1D7B7 => array(0x3BE),
3108                     0x1D7B8 => array(0x3BF), 0x1D7B9 => array(0x3C0), 0x1D7BA => array(0x3C1),
3109                     0x1D7BB => array(0x3C3), 0x1D7BC => array(0x3C3), 0x1D7BD => array(0x3C4),
3110                     0x1D7BE => array(0x3C5), 0x1D7BF => array(0x3C6), 0x1D7C0 => array(0x3C7),
3111                     0x1D7C1 => array(0x3C8), 0x1D7C2 => array(0x3C9), 0x1D7C3 => array(0x2202),
3112                     0x1D7C4 => array(0x3B5), 0x1D7C5 => array(0x3B8), 0x1D7C6 => array(0x3BA),
3113                     0x1D7C7 => array(0x3C6), 0x1D7C8 => array(0x3C1), 0x1D7C9 => array(0x3C0),
3114                     0x1D7CA => array(0x3DD), 0x1D7CB => array(0x3DD), 0x1D7CE => array(0x30),
3115                     0x1D7CF => array(0x31), 0x1D7D0 => array(0x32), 0x1D7D1 => array(0x33),
3116                     0x1D7D2 => array(0x34), 0x1D7D3 => array(0x35), 0x1D7D4 => array(0x36),
3117                     0x1D7D5 => array(0x37), 0x1D7D6 => array(0x38), 0x1D7D7 => array(0x39),
3118                     0x1D7D8 => array(0x30), 0x1D7D9 => array(0x31), 0x1D7DA => array(0x32),
3119                     0x1D7DB => array(0x33), 0x1D7DC => array(0x34), 0x1D7DD => array(0x35),
3120                     0x1D7DE => array(0x36), 0x1D7DF => array(0x37), 0x1D7E0 => array(0x38),
3121                     0x1D7E1 => array(0x39), 0x1D7E2 => array(0x30), 0x1D7E3 => array(0x31),
3122                     0x1D7E4 => array(0x32), 0x1D7E5 => array(0x33), 0x1D7E6 => array(0x34),
3123                     0x1D7E7 => array(0x35), 0x1D7E8 => array(0x36), 0x1D7E9 => array(0x37),
3124                     0x1D7EA => array(0x38), 0x1D7EB => array(0x39), 0x1D7EC => array(0x30),
3125                     0x1D7ED => array(0x31), 0x1D7EE => array(0x32), 0x1D7EF => array(0x33),
3126                     0x1D7F0 => array(0x34), 0x1D7F1 => array(0x35), 0x1D7F2 => array(0x36),
3127                     0x1D7F3 => array(0x37), 0x1D7F4 => array(0x38), 0x1D7F5 => array(0x39),
3128                     0x1D7F6 => array(0x30), 0x1D7F7 => array(0x31), 0x1D7F8 => array(0x32),
3129                     0x1D7F9 => array(0x33), 0x1D7FA => array(0x34), 0x1D7FB => array(0x35),
3130                     0x1D7FC => array(0x36), 0x1D7FD => array(0x37), 0x1D7FE => array(0x38),
3131                     0x1D7FF => array(0x39), 0x1EE00 => array(0x627), 0x1EE01 => array(0x628),
3132                     0x1EE02 => array(0x62C), 0x1EE03 => array(0x62F), 0x1EE05 => array(0x648),
3133                     0x1EE06 => array(0x632), 0x1EE07 => array(0x62D), 0x1EE08 => array(0x637),
3134                     0x1EE09 => array(0x64A), 0x1EE0A => array(0x643), 0x1EE0B => array(0x644),
3135                     0x1EE0C => array(0x645), 0x1EE0D => array(0x646), 0x1EE0E => array(0x633),
3136                     0x1EE0F => array(0x639), 0x1EE10 => array(0x641), 0x1EE11 => array(0x635),
3137                     0x1EE12 => array(0x642), 0x1EE13 => array(0x631), 0x1EE14 => array(0x634),
3138                     0x1EE15 => array(0x62A), 0x1EE16 => array(0x62B), 0x1EE17 => array(0x62E),
3139                     0x1EE18 => array(0x630), 0x1EE19 => array(0x636), 0x1EE1A => array(0x638),
3140                     0x1EE1B => array(0x63A), 0x1EE1C => array(0x66E), 0x1EE1D => array(0x6BA),
3141                     0x1EE1E => array(0x6A1), 0x1EE1F => array(0x66F), 0x1EE21 => array(0x628),
3142                     0x1EE22 => array(0x62C), 0x1EE24 => array(0x647), 0x1EE27 => array(0x62D),
3143                     0x1EE29 => array(0x64A), 0x1EE2A => array(0x643), 0x1EE2B => array(0x644),
3144                     0x1EE2C => array(0x645), 0x1EE2D => array(0x646), 0x1EE2E => array(0x633),
3145                     0x1EE2F => array(0x639), 0x1EE30 => array(0x641), 0x1EE31 => array(0x635),
3146                     0x1EE32 => array(0x642), 0x1EE34 => array(0x634), 0x1EE35 => array(0x62A),
3147                     0x1EE36 => array(0x62B), 0x1EE37 => array(0x62E), 0x1EE39 => array(0x636),
3148                     0x1EE3B => array(0x63A), 0x1EE42 => array(0x62C), 0x1EE47 => array(0x62D),
3149                     0x1EE49 => array(0x64A), 0x1EE4B => array(0x644), 0x1EE4D => array(0x646),
3150                     0x1EE4E => array(0x633), 0x1EE4F => array(0x639), 0x1EE51 => array(0x635),
3151                     0x1EE52 => array(0x642), 0x1EE54 => array(0x634), 0x1EE57 => array(0x62E),
3152                     0x1EE59 => array(0x636), 0x1EE5B => array(0x63A), 0x1EE5D => array(0x6BA),
3153                     0x1EE5F => array(0x66F), 0x1EE61 => array(0x628), 0x1EE62 => array(0x62C),
3154                     0x1EE64 => array(0x647), 0x1EE67 => array(0x62D), 0x1EE68 => array(0x637),
3155                     0x1EE69 => array(0x64A), 0x1EE6A => array(0x643), 0x1EE6C => array(0x645),
3156                     0x1EE6D => array(0x646), 0x1EE6E => array(0x633), 0x1EE6F => array(0x639),
3157                     0x1EE70 => array(0x641), 0x1EE71 => array(0x635), 0x1EE72 => array(0x642),
3158                     0x1EE74 => array(0x634), 0x1EE75 => array(0x62A), 0x1EE76 => array(0x62B),
3159                     0x1EE77 => array(0x62E), 0x1EE79 => array(0x636), 0x1EE7A => array(0x638),
3160                     0x1EE7B => array(0x63A), 0x1EE7C => array(0x66E), 0x1EE7E => array(0x6A1),
3161                     0x1EE80 => array(0x627), 0x1EE81 => array(0x628), 0x1EE82 => array(0x62C),
3162                     0x1EE83 => array(0x62F), 0x1EE84 => array(0x647), 0x1EE85 => array(0x648),
3163                     0x1EE86 => array(0x632), 0x1EE87 => array(0x62D), 0x1EE88 => array(0x637),
3164                     0x1EE89 => array(0x64A), 0x1EE8B => array(0x644), 0x1EE8C => array(0x645),
3165                     0x1EE8D => array(0x646), 0x1EE8E => array(0x633), 0x1EE8F => array(0x639),
3166                     0x1EE90 => array(0x641), 0x1EE91 => array(0x635), 0x1EE92 => array(0x642),
3167                     0x1EE93 => array(0x631), 0x1EE94 => array(0x634), 0x1EE95 => array(0x62A),
3168                     0x1EE96 => array(0x62B), 0x1EE97 => array(0x62E), 0x1EE98 => array(0x630),
3169                     0x1EE99 => array(0x636), 0x1EE9A => array(0x638), 0x1EE9B => array(0x63A),
3170                     0x1EEA1 => array(0x628), 0x1EEA2 => array(0x62C), 0x1EEA3 => array(0x62F),
3171                     0x1EEA5 => array(0x648), 0x1EEA6 => array(0x632), 0x1EEA7 => array(0x62D),
3172                     0x1EEA8 => array(0x637), 0x1EEA9 => array(0x64A), 0x1EEAB => array(0x644),
3173                     0x1EEAC => array(0x645), 0x1EEAD => array(0x646), 0x1EEAE => array(0x633),
3174                     0x1EEAF => array(0x639), 0x1EEB0 => array(0x641), 0x1EEB1 => array(0x635),
3175                     0x1EEB2 => array(0x642), 0x1EEB3 => array(0x631), 0x1EEB4 => array(0x634),
3176                     0x1EEB5 => array(0x62A), 0x1EEB6 => array(0x62B), 0x1EEB7 => array(0x62E),
3177                     0x1EEB8 => array(0x630), 0x1EEB9 => array(0x636), 0x1EEBA => array(0x638),
3178                     0x1EEBB => array(0x63A), 0x1F12A => array(0x3014, 0x73, 0x3015), 0x1F12B => array(0x63),
3179                     0x1F12C => array(0x72), 0x1F12D => array(0x63, 0x64), 0x1F12E => array(0x77, 0x7A),
3180                     0x1F130 => array(0x61), 0x1F131 => array(0x62), 0x1F132 => array(0x63),
3181                     0x1F133 => array(0x64), 0x1F134 => array(0x65), 0x1F135 => array(0x66),
3182                     0x1F136 => array(0x67), 0x1F137 => array(0x68), 0x1F138 => array(0x69),
3183                     0x1F139 => array(0x6A), 0x1F13A => array(0x6B), 0x1F13B => array(0x6C),
3184                     0x1F13C => array(0x6D), 0x1F13D => array(0x6E), 0x1F13E => array(0x6F),
3185                     0x1F13F => array(0x70), 0x1F140 => array(0x71), 0x1F141 => array(0x72),
3186                     0x1F142 => array(0x73), 0x1F143 => array(0x74), 0x1F144 => array(0x75),
3187                     0x1F145 => array(0x76), 0x1F146 => array(0x77), 0x1F147 => array(0x78),
3188                     0x1F148 => array(0x79), 0x1F149 => array(0x7A), 0x1F14A => array(0x68, 0x76),
3189                     0x1F14B => array(0x6D, 0x76), 0x1F14C => array(0x73, 0x64), 0x1F14D => array(0x73, 0x73),
3190                     0x1F14E => array(0x70, 0x70, 0x76), 0x1F14F => array(0x77, 0x63), 0x1F16A => array(0x6D, 0x63),
3191                     0x1F16B => array(0x6D, 0x64), 0x1F190 => array(0x64, 0x6A), 0x1F200 => array(0x307B, 0x304B),
3192                     0x1F201 => array(0x30B3, 0x30B3), 0x1F202 => array(0x30B5), 0x1F210 => array(0x624B),
3193                     0x1F211 => array(0x5B57), 0x1F212 => array(0x53CC), 0x1F213 => array(0x30C7),
3194                     0x1F214 => array(0x4E8C), 0x1F215 => array(0x591A), 0x1F216 => array(0x89E3),
3195                     0x1F217 => array(0x5929), 0x1F218 => array(0x4EA4), 0x1F219 => array(0x6620),
3196                     0x1F21A => array(0x7121), 0x1F21B => array(0x6599), 0x1F21C => array(0x524D),
3197                     0x1F21D => array(0x5F8C), 0x1F21E => array(0x518D), 0x1F21F => array(0x65B0),
3198                     0x1F220 => array(0x521D), 0x1F221 => array(0x7D42), 0x1F222 => array(0x751F),
3199                     0x1F223 => array(0x8CA9), 0x1F224 => array(0x58F0), 0x1F225 => array(0x5439),
3200                     0x1F226 => array(0x6F14), 0x1F227 => array(0x6295), 0x1F228 => array(0x6355),
3201                     0x1F229 => array(0x4E00), 0x1F22A => array(0x4E09), 0x1F22B => array(0x904A),
3202                     0x1F22C => array(0x5DE6), 0x1F22D => array(0x4E2D), 0x1F22E => array(0x53F3),
3203                     0x1F22F => array(0x6307), 0x1F230 => array(0x8D70), 0x1F231 => array(0x6253),
3204                     0x1F232 => array(0x7981), 0x1F233 => array(0x7A7A), 0x1F234 => array(0x5408),
3205                     0x1F235 => array(0x6E80), 0x1F236 => array(0x6709), 0x1F237 => array(0x6708),
3206                     0x1F238 => array(0x7533), 0x1F239 => array(0x5272), 0x1F23A => array(0x55B6),
3207                     0x1F240 => array(0x3014, 0x672C, 0x3015), 0x1F241 => array(0x3014, 0x4E09, 0x3015), 0x1F242 => array(0x3014, 0x4E8C, 0x3015),
3208                     0x1F243 => array(0x3014, 0x5B89, 0x3015), 0x1F244 => array(0x3014, 0x70B9, 0x3015), 0x1F245 => array(0x3014, 0x6253, 0x3015),
3209                     0x1F246 => array(0x3014, 0x76D7, 0x3015), 0x1F247 => array(0x3014, 0x52DD, 0x3015), 0x1F248 => array(0x3014, 0x6557, 0x3015),
3210                     0x1F250 => array(0x5F97), 0x1F251 => array(0x53EF), 0x2F800 => array(0x4E3D),
3211                     0x2F801 => array(0x4E38), 0x2F802 => array(0x4E41), 0x2F803 => array(0x20122),
3212                     0x2F804 => array(0x4F60), 0x2F805 => array(0x4FAE), 0x2F806 => array(0x4FBB),
3213                     0x2F807 => array(0x5002), 0x2F808 => array(0x507A), 0x2F809 => array(0x5099),
3214                     0x2F80A => array(0x50E7), 0x2F80B => array(0x50CF), 0x2F80C => array(0x349E),
3215                     0x2F80D => array(0x2063A), 0x2F80E => array(0x514D), 0x2F80F => array(0x5154),
3216                     0x2F810 => array(0x5164), 0x2F811 => array(0x5177), 0x2F812 => array(0x2051C),
3217                     0x2F813 => array(0x34B9), 0x2F814 => array(0x5167), 0x2F815 => array(0x518D),
3218                     0x2F816 => array(0x2054B), 0x2F817 => array(0x5197), 0x2F818 => array(0x51A4),
3219                     0x2F819 => array(0x4ECC), 0x2F81A => array(0x51AC), 0x2F81B => array(0x51B5),
3220                     0x2F81C => array(0x291DF), 0x2F81D => array(0x51F5), 0x2F81E => array(0x5203),
3221                     0x2F81F => array(0x34DF), 0x2F820 => array(0x523B), 0x2F821 => array(0x5246),
3222                     0x2F822 => array(0x5272), 0x2F823 => array(0x5277), 0x2F824 => array(0x3515),
3223                     0x2F825 => array(0x52C7), 0x2F826 => array(0x52C9), 0x2F827 => array(0x52E4),
3224                     0x2F828 => array(0x52FA), 0x2F829 => array(0x5305), 0x2F82A => array(0x5306),
3225                     0x2F82B => array(0x5317), 0x2F82C => array(0x5349), 0x2F82D => array(0x5351),
3226                     0x2F82E => array(0x535A), 0x2F82F => array(0x5373), 0x2F830 => array(0x537D),
3227                     0x2F831 => array(0x537F), 0x2F832 => array(0x537F), 0x2F833 => array(0x537F),
3228                     0x2F834 => array(0x20A2C), 0x2F835 => array(0x7070), 0x2F836 => array(0x53CA),
3229                     0x2F837 => array(0x53DF), 0x2F838 => array(0x20B63), 0x2F839 => array(0x53EB),
3230                     0x2F83A => array(0x53F1), 0x2F83B => array(0x5406), 0x2F83C => array(0x549E),
3231                     0x2F83D => array(0x5438), 0x2F83E => array(0x5448), 0x2F83F => array(0x5468),
3232                     0x2F840 => array(0x54A2), 0x2F841 => array(0x54F6), 0x2F842 => array(0x5510),
3233                     0x2F843 => array(0x5553), 0x2F844 => array(0x5563), 0x2F845 => array(0x5584),
3234                     0x2F846 => array(0x5584), 0x2F847 => array(0x5599), 0x2F848 => array(0x55AB),
3235                     0x2F849 => array(0x55B3), 0x2F84A => array(0x55C2), 0x2F84B => array(0x5716),
3236                     0x2F84C => array(0x5606), 0x2F84D => array(0x5717), 0x2F84E => array(0x5651),
3237                     0x2F84F => array(0x5674), 0x2F850 => array(0x5207), 0x2F851 => array(0x58EE),
3238                     0x2F852 => array(0x57CE), 0x2F853 => array(0x57F4), 0x2F854 => array(0x580D),
3239                     0x2F855 => array(0x578B), 0x2F856 => array(0x5832), 0x2F857 => array(0x5831),
3240                     0x2F858 => array(0x58AC), 0x2F859 => array(0x214E4), 0x2F85A => array(0x58F2),
3241                     0x2F85B => array(0x58F7), 0x2F85C => array(0x5906), 0x2F85D => array(0x591A),
3242                     0x2F85E => array(0x5922), 0x2F85F => array(0x5962), 0x2F860 => array(0x216A8),
3243                     0x2F861 => array(0x216EA), 0x2F862 => array(0x59EC), 0x2F863 => array(0x5A1B),
3244                     0x2F864 => array(0x5A27), 0x2F865 => array(0x59D8), 0x2F866 => array(0x5A66),
3245                     0x2F867 => array(0x36EE), 0x2F869 => array(0x5B08), 0x2F86A => array(0x5B3E),
3246                     0x2F86B => array(0x5B3E), 0x2F86C => array(0x219C8), 0x2F86D => array(0x5BC3),
3247                     0x2F86E => array(0x5BD8), 0x2F86F => array(0x5BE7), 0x2F870 => array(0x5BF3),
3248                     0x2F871 => array(0x21B18), 0x2F872 => array(0x5BFF), 0x2F873 => array(0x5C06),
3249                     0x2F875 => array(0x5C22), 0x2F876 => array(0x3781), 0x2F877 => array(0x5C60),
3250                     0x2F878 => array(0x5C6E), 0x2F879 => array(0x5CC0), 0x2F87A => array(0x5C8D),
3251                     0x2F87B => array(0x21DE4), 0x2F87C => array(0x5D43), 0x2F87D => array(0x21DE6),
3252                     0x2F87E => array(0x5D6E), 0x2F87F => array(0x5D6B), 0x2F880 => array(0x5D7C),
3253                     0x2F881 => array(0x5DE1), 0x2F882 => array(0x5DE2), 0x2F883 => array(0x382F),
3254                     0x2F884 => array(0x5DFD), 0x2F885 => array(0x5E28), 0x2F886 => array(0x5E3D),
3255                     0x2F887 => array(0x5E69), 0x2F888 => array(0x3862), 0x2F889 => array(0x22183),
3256                     0x2F88A => array(0x387C), 0x2F88B => array(0x5EB0), 0x2F88C => array(0x5EB3),
3257                     0x2F88D => array(0x5EB6), 0x2F88E => array(0x5ECA), 0x2F88F => array(0x2A392),
3258                     0x2F890 => array(0x5EFE), 0x2F891 => array(0x22331), 0x2F892 => array(0x22331),
3259                     0x2F893 => array(0x8201), 0x2F894 => array(0x5F22), 0x2F895 => array(0x5F22),
3260                     0x2F896 => array(0x38C7), 0x2F897 => array(0x232B8), 0x2F898 => array(0x261DA),
3261                     0x2F899 => array(0x5F62), 0x2F89A => array(0x5F6B), 0x2F89B => array(0x38E3),
3262                     0x2F89C => array(0x5F9A), 0x2F89D => array(0x5FCD), 0x2F89E => array(0x5FD7),
3263                     0x2F89F => array(0x5FF9), 0x2F8A0 => array(0x6081), 0x2F8A1 => array(0x393A),
3264                     0x2F8A2 => array(0x391C), 0x2F8A3 => array(0x6094), 0x2F8A4 => array(0x226D4),
3265                     0x2F8A5 => array(0x60C7), 0x2F8A6 => array(0x6148), 0x2F8A7 => array(0x614C),
3266                     0x2F8A8 => array(0x614E), 0x2F8A9 => array(0x614C), 0x2F8AA => array(0x617A),
3267                     0x2F8AB => array(0x618E), 0x2F8AC => array(0x61B2), 0x2F8AD => array(0x61A4),
3268                     0x2F8AE => array(0x61AF), 0x2F8AF => array(0x61DE), 0x2F8B0 => array(0x61F2),
3269                     0x2F8B1 => array(0x61F6), 0x2F8B2 => array(0x6210), 0x2F8B3 => array(0x621B),
3270                     0x2F8B4 => array(0x625D), 0x2F8B5 => array(0x62B1), 0x2F8B6 => array(0x62D4),
3271                     0x2F8B7 => array(0x6350), 0x2F8B8 => array(0x22B0C), 0x2F8B9 => array(0x633D),
3272                     0x2F8BA => array(0x62FC), 0x2F8BB => array(0x6368), 0x2F8BC => array(0x6383),
3273                     0x2F8BD => array(0x63E4), 0x2F8BE => array(0x22BF1), 0x2F8BF => array(0x6422),
3274                     0x2F8C0 => array(0x63C5), 0x2F8C1 => array(0x63A9), 0x2F8C2 => array(0x3A2E),
3275                     0x2F8C3 => array(0x6469), 0x2F8C4 => array(0x647E), 0x2F8C5 => array(0x649D),
3276                     0x2F8C6 => array(0x6477), 0x2F8C7 => array(0x3A6C), 0x2F8C8 => array(0x654F),
3277                     0x2F8C9 => array(0x656C), 0x2F8CA => array(0x2300A), 0x2F8CB => array(0x65E3),
3278                     0x2F8CC => array(0x66F8), 0x2F8CD => array(0x6649), 0x2F8CE => array(0x3B19),
3279                     0x2F8CF => array(0x6691), 0x2F8D0 => array(0x3B08), 0x2F8D1 => array(0x3AE4),
3280                     0x2F8D2 => array(0x5192), 0x2F8D3 => array(0x5195), 0x2F8D4 => array(0x6700),
3281                     0x2F8D5 => array(0x669C), 0x2F8D6 => array(0x80AD), 0x2F8D7 => array(0x43D9),
3282                     0x2F8D8 => array(0x6717), 0x2F8D9 => array(0x671B), 0x2F8DA => array(0x6721),
3283                     0x2F8DB => array(0x675E), 0x2F8DC => array(0x6753), 0x2F8DD => array(0x233C3),
3284                     0x2F8DE => array(0x3B49), 0x2F8DF => array(0x67FA), 0x2F8E0 => array(0x6785),
3285                     0x2F8E1 => array(0x6852), 0x2F8E2 => array(0x6885), 0x2F8E3 => array(0x2346D),
3286                     0x2F8E4 => array(0x688E), 0x2F8E5 => array(0x681F), 0x2F8E6 => array(0x6914),
3287                     0x2F8E7 => array(0x3B9D), 0x2F8E8 => array(0x6942), 0x2F8E9 => array(0x69A3),
3288                     0x2F8EA => array(0x69EA), 0x2F8EB => array(0x6AA8), 0x2F8EC => array(0x236A3),
3289                     0x2F8ED => array(0x6ADB), 0x2F8EE => array(0x3C18), 0x2F8EF => array(0x6B21),
3290                     0x2F8F0 => array(0x238A7), 0x2F8F1 => array(0x6B54), 0x2F8F2 => array(0x3C4E),
3291                     0x2F8F3 => array(0x6B72), 0x2F8F4 => array(0x6B9F), 0x2F8F5 => array(0x6BBA),
3292                     0x2F8F6 => array(0x6BBB), 0x2F8F7 => array(0x23A8D), 0x2F8F8 => array(0x21D0B),
3293                     0x2F8F9 => array(0x23AFA), 0x2F8FA => array(0x6C4E), 0x2F8FB => array(0x23CBC),
3294                     0x2F8FC => array(0x6CBF), 0x2F8FD => array(0x6CCD), 0x2F8FE => array(0x6C67),
3295                     0x2F8FF => array(0x6D16), 0x2F900 => array(0x6D3E), 0x2F901 => array(0x6D77),
3296                     0x2F902 => array(0x6D41), 0x2F903 => array(0x6D69), 0x2F904 => array(0x6D78),
3297                     0x2F905 => array(0x6D85), 0x2F906 => array(0x23D1E), 0x2F907 => array(0x6D34),
3298                     0x2F908 => array(0x6E2F), 0x2F909 => array(0x6E6E), 0x2F90A => array(0x3D33),
3299                     0x2F90B => array(0x6ECB), 0x2F90C => array(0x6EC7), 0x2F90D => array(0x23ED1),
3300                     0x2F90E => array(0x6DF9), 0x2F90F => array(0x6F6E), 0x2F910 => array(0x23F5E),
3301                     0x2F911 => array(0x23F8E), 0x2F912 => array(0x6FC6), 0x2F913 => array(0x7039),
3302                     0x2F914 => array(0x701E), 0x2F915 => array(0x701B), 0x2F916 => array(0x3D96),
3303                     0x2F917 => array(0x704A), 0x2F918 => array(0x707D), 0x2F919 => array(0x7077),
3304                     0x2F91A => array(0x70AD), 0x2F91B => array(0x20525), 0x2F91C => array(0x7145),
3305                     0x2F91D => array(0x24263), 0x2F91E => array(0x719C), 0x2F920 => array(0x7228),
3306                     0x2F921 => array(0x7235), 0x2F922 => array(0x7250), 0x2F923 => array(0x24608),
3307                     0x2F924 => array(0x7280), 0x2F925 => array(0x7295), 0x2F926 => array(0x24735),
3308                     0x2F927 => array(0x24814), 0x2F928 => array(0x737A), 0x2F929 => array(0x738B),
3309                     0x2F92A => array(0x3EAC), 0x2F92B => array(0x73A5), 0x2F92C => array(0x3EB8),
3310                     0x2F92D => array(0x3EB8), 0x2F92E => array(0x7447), 0x2F92F => array(0x745C),
3311                     0x2F930 => array(0x7471), 0x2F931 => array(0x7485), 0x2F932 => array(0x74CA),
3312                     0x2F933 => array(0x3F1B), 0x2F934 => array(0x7524), 0x2F935 => array(0x24C36),
3313                     0x2F936 => array(0x753E), 0x2F937 => array(0x24C92), 0x2F938 => array(0x7570),
3314                     0x2F939 => array(0x2219F), 0x2F93A => array(0x7610), 0x2F93B => array(0x24FA1),
3315                     0x2F93C => array(0x24FB8), 0x2F93D => array(0x25044), 0x2F93E => array(0x3FFC),
3316                     0x2F93F => array(0x4008), 0x2F940 => array(0x76F4), 0x2F941 => array(0x250F3),
3317                     0x2F942 => array(0x250F2), 0x2F943 => array(0x25119), 0x2F944 => array(0x25133),
3318                     0x2F945 => array(0x771E), 0x2F946 => array(0x771F), 0x2F947 => array(0x771F),
3319                     0x2F948 => array(0x774A), 0x2F949 => array(0x4039), 0x2F94A => array(0x778B),
3320                     0x2F94B => array(0x4046), 0x2F94C => array(0x4096), 0x2F94D => array(0x2541D),
3321                     0x2F94E => array(0x784E), 0x2F94F => array(0x788C), 0x2F950 => array(0x78CC),
3322                     0x2F951 => array(0x40E3), 0x2F952 => array(0x25626), 0x2F953 => array(0x7956),
3323                     0x2F954 => array(0x2569A), 0x2F955 => array(0x256C5), 0x2F956 => array(0x798F),
3324                     0x2F957 => array(0x79EB), 0x2F958 => array(0x412F), 0x2F959 => array(0x7A40),
3325                     0x2F95A => array(0x7A4A), 0x2F95B => array(0x7A4F), 0x2F95C => array(0x2597C),
3326                     0x2F95D => array(0x25AA7), 0x2F95E => array(0x25AA7), 0x2F960 => array(0x4202),
3327                     0x2F961 => array(0x25BAB), 0x2F962 => array(0x7BC6), 0x2F963 => array(0x7BC9),
3328                     0x2F964 => array(0x4227), 0x2F965 => array(0x25C80), 0x2F966 => array(0x7CD2),
3329                     0x2F967 => array(0x42A0), 0x2F968 => array(0x7CE8), 0x2F969 => array(0x7CE3),
3330                     0x2F96A => array(0x7D00), 0x2F96B => array(0x25F86), 0x2F96C => array(0x7D63),
3331                     0x2F96D => array(0x4301), 0x2F96E => array(0x7DC7), 0x2F96F => array(0x7E02),
3332                     0x2F970 => array(0x7E45), 0x2F971 => array(0x4334), 0x2F972 => array(0x26228),
3333                     0x2F973 => array(0x26247), 0x2F974 => array(0x4359), 0x2F975 => array(0x262D9),
3334                     0x2F976 => array(0x7F7A), 0x2F977 => array(0x2633E), 0x2F978 => array(0x7F95),
3335                     0x2F979 => array(0x7FFA), 0x2F97A => array(0x8005), 0x2F97B => array(0x264DA),
3336                     0x2F97C => array(0x26523), 0x2F97D => array(0x8060), 0x2F97E => array(0x265A8),
3337                     0x2F97F => array(0x8070), 0x2F980 => array(0x2335F), 0x2F981 => array(0x43D5),
3338                     0x2F982 => array(0x80B2), 0x2F983 => array(0x8103), 0x2F984 => array(0x440B),
3339                     0x2F985 => array(0x813E), 0x2F986 => array(0x5AB5), 0x2F987 => array(0x267A7),
3340                     0x2F988 => array(0x267B5), 0x2F989 => array(0x23393), 0x2F98A => array(0x2339C),
3341                     0x2F98B => array(0x8201), 0x2F98C => array(0x8204), 0x2F98D => array(0x8F9E),
3342                     0x2F98E => array(0x446B), 0x2F98F => array(0x8291), 0x2F990 => array(0x828B),
3343                     0x2F991 => array(0x829D), 0x2F992 => array(0x52B3), 0x2F993 => array(0x82B1),
3344                     0x2F994 => array(0x82B3), 0x2F995 => array(0x82BD), 0x2F996 => array(0x82E6),
3345                     0x2F997 => array(0x26B3C), 0x2F998 => array(0x82E5), 0x2F999 => array(0x831D),
3346                     0x2F99A => array(0x8363), 0x2F99B => array(0x83AD), 0x2F99C => array(0x8323),
3347                     0x2F99D => array(0x83BD), 0x2F99E => array(0x83E7), 0x2F99F => array(0x8457),
3348                     0x2F9A0 => array(0x8353), 0x2F9A1 => array(0x83CA), 0x2F9A2 => array(0x83CC),
3349                     0x2F9A3 => array(0x83DC), 0x2F9A4 => array(0x26C36), 0x2F9A5 => array(0x26D6B),
3350                     0x2F9A6 => array(0x26CD5), 0x2F9A7 => array(0x452B), 0x2F9A8 => array(0x84F1),
3351                     0x2F9A9 => array(0x84F3), 0x2F9AA => array(0x8516), 0x2F9AB => array(0x273CA),
3352                     0x2F9AC => array(0x8564), 0x2F9AD => array(0x26F2C), 0x2F9AE => array(0x455D),
3353                     0x2F9AF => array(0x4561), 0x2F9B0 => array(0x26FB1), 0x2F9B1 => array(0x270D2),
3354                     0x2F9B2 => array(0x456B), 0x2F9B3 => array(0x8650), 0x2F9B4 => array(0x865C),
3355                     0x2F9B5 => array(0x8667), 0x2F9B6 => array(0x8669), 0x2F9B7 => array(0x86A9),
3356                     0x2F9B8 => array(0x8688), 0x2F9B9 => array(0x870E), 0x2F9BA => array(0x86E2),
3357                     0x2F9BB => array(0x8779), 0x2F9BC => array(0x8728), 0x2F9BD => array(0x876B),
3358                     0x2F9BE => array(0x8786), 0x2F9C0 => array(0x87E1), 0x2F9C1 => array(0x8801),
3359                     0x2F9C2 => array(0x45F9), 0x2F9C3 => array(0x8860), 0x2F9C4 => array(0x8863),
3360                     0x2F9C5 => array(0x27667), 0x2F9C6 => array(0x88D7), 0x2F9C7 => array(0x88DE),
3361                     0x2F9C8 => array(0x4635), 0x2F9C9 => array(0x88FA), 0x2F9CA => array(0x34BB),
3362                     0x2F9CB => array(0x278AE), 0x2F9CC => array(0x27966), 0x2F9CD => array(0x46BE),
3363                     0x2F9CE => array(0x46C7), 0x2F9CF => array(0x8AA0), 0x2F9D0 => array(0x8AED),
3364                     0x2F9D1 => array(0x8B8A), 0x2F9D2 => array(0x8C55), 0x2F9D3 => array(0x27CA8),
3365                     0x2F9D4 => array(0x8CAB), 0x2F9D5 => array(0x8CC1), 0x2F9D6 => array(0x8D1B),
3366                     0x2F9D7 => array(0x8D77), 0x2F9D8 => array(0x27F2F), 0x2F9D9 => array(0x20804),
3367                     0x2F9DA => array(0x8DCB), 0x2F9DB => array(0x8DBC), 0x2F9DC => array(0x8DF0),
3368                     0x2F9DD => array(0x208DE), 0x2F9DE => array(0x8ED4), 0x2F9DF => array(0x8F38),
3369                     0x2F9E0 => array(0x285D2), 0x2F9E1 => array(0x285ED), 0x2F9E2 => array(0x9094),
3370                     0x2F9E3 => array(0x90F1), 0x2F9E4 => array(0x9111), 0x2F9E5 => array(0x2872E),
3371                     0x2F9E6 => array(0x911B), 0x2F9E7 => array(0x9238), 0x2F9E8 => array(0x92D7),
3372                     0x2F9E9 => array(0x92D8), 0x2F9EA => array(0x927C), 0x2F9EB => array(0x93F9),
3373                     0x2F9EC => array(0x9415), 0x2F9ED => array(0x28BFA), 0x2F9EE => array(0x958B),
3374                     0x2F9EF => array(0x4995), 0x2F9F0 => array(0x95B7), 0x2F9F1 => array(0x28D77),
3375                     0x2F9F2 => array(0x49E6), 0x2F9F3 => array(0x96C3), 0x2F9F4 => array(0x5DB2),
3376                     0x2F9F5 => array(0x9723), 0x2F9F6 => array(0x29145), 0x2F9F7 => array(0x2921A),
3377                     0x2F9F8 => array(0x4A6E), 0x2F9F9 => array(0x4A76), 0x2F9FA => array(0x97E0),
3378                     0x2F9FB => array(0x2940A), 0x2F9FC => array(0x4AB2), 0x2F9FD => array(0x29496),
3379                     0x2F9FE => array(0x980B), 0x2F9FF => array(0x980B), 0x2FA00 => array(0x9829),
3380                     0x2FA01 => array(0x295B6), 0x2FA02 => array(0x98E2), 0x2FA03 => array(0x4B33),
3381                     0x2FA04 => array(0x9929), 0x2FA05 => array(0x99A7), 0x2FA06 => array(0x99C2),
3382                     0x2FA07 => array(0x99FE), 0x2FA08 => array(0x4BCE), 0x2FA09 => array(0x29B30),
3383                     0x2FA0A => array(0x9B12), 0x2FA0B => array(0x9C40), 0x2FA0C => array(0x9CFD),
3384                     0x2FA0D => array(0x4CCE), 0x2FA0E => array(0x4CED), 0x2FA0F => array(0x9D67),
3385                     0x2FA10 => array(0x2A0CE), 0x2FA11 => array(0x4CF8), 0x2FA12 => array(0x2A105),
3386                     0x2FA13 => array(0x2A20E), 0x2FA14 => array(0x2A291), 0x2FA15 => array(0x9EBB),
3387                     0x2FA16 => array(0x4D56), 0x2FA17 => array(0x9EF9), 0x2FA18 => array(0x9EFE),
3388                     0x2FA19 => array(0x9F05), 0x2FA1A => array(0x9F0F), 0x2FA1B => array(0x9F16),
3389                     0x2FA1C => array(0x9F3B), 0x2FA1D => array(0x2A600)
3390             ),
3391             'norm_combcls' => array(0x334 => 1, 0x335 => 1, 0x336 => 1, 0x337 => 1,
3392                     0x338 => 1, 0x93C => 7, 0x9BC => 7, 0xA3C => 7, 0xABC => 7,
3393                     0xB3C => 7, 0xCBC => 7, 0x1037 => 7, 0x3099 => 8, 0x309A => 8,
3394                     0x94D => 9, 0x9CD => 9, 0xA4D => 9, 0xACD => 9, 0xB4D => 9,
3395                     0xBCD => 9, 0xC4D => 9, 0xCCD => 9, 0xD4D => 9, 0xDCA => 9,
3396                     0xE3A => 9, 0xF84 => 9, 0x1039 => 9, 0x1714 => 9, 0x1734 => 9,
3397                     0x17D2 => 9, 0x5B0 => 10, 0x5B1 => 11, 0x5B2 => 12, 0x5B3 => 13,
3398                     0x5B4 => 14, 0x5B5 => 15, 0x5B6 => 16, 0x5B7 => 17, 0x5B8 => 18,
3399                     0x5B9 => 19, 0x5BB => 20, 0x5Bc => 21, 0x5BD => 22, 0x5BF => 23,
3400                     0x5C1 => 24, 0x5C2 => 25, 0xFB1E => 26, 0x64B => 27, 0x64C => 28,
3401                     0x64D => 29, 0x64E => 30, 0x64F => 31, 0x650 => 32, 0x651 => 33,
3402                     0x652 => 34, 0x670 => 35, 0x711 => 36, 0xC55 => 84, 0xC56 => 91,
3403                     0xE38 => 103, 0xE39 => 103, 0xE48 => 107, 0xE49 => 107, 0xE4A => 107,
3404                     0xE4B => 107, 0xEB8 => 118, 0xEB9 => 118, 0xEC8 => 122, 0xEC9 => 122,
3405                     0xECA => 122, 0xECB => 122, 0xF71 => 129, 0xF72 => 130, 0xF7A => 130,
3406                     0xF7B => 130, 0xF7C => 130, 0xF7D => 130, 0xF80 => 130, 0xF74 => 132,
3407                     0x321 => 202, 0x322 => 202, 0x327 => 202, 0x328 => 202, 0x31B => 216,
3408                     0xF39 => 216, 0x1D165 => 216, 0x1D166 => 216, 0x1D16E => 216, 0x1D16F => 216,
3409                     0x1D170 => 216, 0x1D171 => 216, 0x1D172 => 216, 0x302A => 218, 0x316 => 220,
3410                     0x317 => 220, 0x318 => 220, 0x319 => 220, 0x31C => 220, 0x31D => 220,
3411                     0x31E => 220, 0x31F => 220, 0x320 => 220, 0x323 => 220, 0x324 => 220,
3412                     0x325 => 220, 0x326 => 220, 0x329 => 220, 0x32A => 220, 0x32B => 220,
3413                     0x32C => 220, 0x32D => 220, 0x32E => 220, 0x32F => 220, 0x330 => 220,
3414                     0x331 => 220, 0x332 => 220, 0x333 => 220, 0x339 => 220, 0x33A => 220,
3415                     0x33B => 220, 0x33C => 220, 0x347 => 220, 0x348 => 220, 0x349 => 220,
3416                     0x34D => 220, 0x34E => 220, 0x353 => 220, 0x354 => 220, 0x355 => 220,
3417                     0x356 => 220, 0x591 => 220, 0x596 => 220, 0x59B => 220, 0x5A3 => 220,
3418                     0x5A4 => 220, 0x5A5 => 220, 0x5A6 => 220, 0x5A7 => 220, 0x5AA => 220,
3419                     0x655 => 220, 0x656 => 220, 0x6E3 => 220, 0x6EA => 220, 0x6ED => 220,
3420                     0x731 => 220, 0x734 => 220, 0x737 => 220, 0x738 => 220, 0x739 => 220,
3421                     0x73B => 220, 0x73C => 220, 0x73E => 220, 0x742 => 220, 0x744 => 220,
3422                     0x746 => 220, 0x748 => 220, 0x952 => 220, 0xF18 => 220, 0xF19 => 220,
3423                     0xF35 => 220, 0xF37 => 220, 0xFC6 => 220, 0x193B => 220, 0x20E8 => 220,
3424                     0x1D17B => 220, 0x1D17C => 220, 0x1D17D => 220, 0x1D17E => 220, 0x1D17F => 220,
3425                     0x1D180 => 220, 0x1D181 => 220, 0x1D182 => 220, 0x1D18A => 220, 0x1D18B => 220,
3426                     0x59A => 222, 0x5AD => 222, 0x1929 => 222, 0x302D => 222, 0x302E => 224,
3427                     0x302F => 224, 0x1D16D => 226, 0x5AE => 228, 0x18A9 => 228, 0x302B => 228,
3428                     0x300 => 230, 0x301 => 230, 0x302 => 230, 0x303 => 230, 0x304 => 230,
3429                     0x305 => 230, 0x306 => 230, 0x307 => 230, 0x308 => 230, 0x309 => 230,
3430                     0x30A => 230, 0x30B => 230, 0x30C => 230, 0x30D => 230, 0x30E => 230,
3431                     0x30F => 230, 0x310 => 230, 0x311 => 230, 0x312 => 230, 0x313 => 230,
3432                     0x314 => 230, 0x33D => 230, 0x33E => 230, 0x33F => 230, 0x340 => 230,
3433                     0x341 => 230, 0x342 => 230, 0x343 => 230, 0x344 => 230, 0x346 => 230,
3434                     0x34A => 230, 0x34B => 230, 0x34C => 230, 0x350 => 230, 0x351 => 230,
3435                     0x352 => 230, 0x357 => 230, 0x363 => 230, 0x364 => 230, 0x365 => 230,
3436                     0x366 => 230, 0x367 => 230, 0x368 => 230, 0x369 => 230, 0x36A => 230,
3437                     0x36B => 230, 0x36C => 230, 0x36D => 230, 0x36E => 230, 0x36F => 230,
3438                     0x483 => 230, 0x484 => 230, 0x485 => 230, 0x486 => 230, 0x592 => 230,
3439                     0x593 => 230, 0x594 => 230, 0x595 => 230, 0x597 => 230, 0x598 => 230,
3440                     0x599 => 230, 0x59C => 230, 0x59D => 230, 0x59E => 230, 0x59F => 230,
3441                     0x5A0 => 230, 0x5A1 => 230, 0x5A8 => 230, 0x5A9 => 230, 0x5AB => 230,
3442                     0x5AC => 230, 0x5AF => 230, 0x5C4 => 230, 0x610 => 230, 0x611 => 230,
3443                     0x612 => 230, 0x613 => 230, 0x614 => 230, 0x615 => 230, 0x653 => 230,
3444                     0x654 => 230, 0x657 => 230, 0x658 => 230, 0x6D6 => 230, 0x6D7 => 230,
3445                     0x6D8 => 230, 0x6D9 => 230, 0x6DA => 230, 0x6DB => 230, 0x6DC => 230,
3446                     0x6DF => 230, 0x6E0 => 230, 0x6E1 => 230, 0x6E2 => 230, 0x6E4 => 230,
3447                     0x6E7 => 230, 0x6E8 => 230, 0x6EB => 230, 0x6EC => 230, 0x730 => 230,
3448                     0x732 => 230, 0x733 => 230, 0x735 => 230, 0x736 => 230, 0x73A => 230,
3449                     0x73D => 230, 0x73F => 230, 0x740 => 230, 0x741 => 230, 0x743 => 230,
3450                     0x745 => 230, 0x747 => 230, 0x749 => 230, 0x74A => 230, 0x951 => 230,
3451                     0x953 => 230, 0x954 => 230, 0xF82 => 230, 0xF83 => 230, 0xF86 => 230,
3452                     0xF87 => 230, 0x170D => 230, 0x193A => 230, 0x20D0 => 230, 0x20D1 => 230,
3453                     0x20D4 => 230, 0x20D5 => 230, 0x20D6 => 230, 0x20D7 => 230, 0x20DB => 230,
3454                     0x20DC => 230, 0x20E1 => 230, 0x20E7 => 230, 0x20E9 => 230, 0xFE20 => 230,
3455                     0xFE21 => 230, 0xFE22 => 230, 0xFE23 => 230, 0x1D185 => 230, 0x1D186 => 230,
3456                     0x1D187 => 230, 0x1D189 => 230, 0x1D188 => 230, 0x1D1AA => 230, 0x1D1AB => 230,
3457                     0x1D1AC => 230, 0x1D1AD => 230, 0x315 => 232, 0x31A => 232, 0x302C => 232,
3458                     0x35F => 233, 0x362 => 233, 0x35D => 234, 0x35E => 234, 0x360 => 234,
3459                     0x361 => 234, 0x345 => 240
3460             )
3461     );
3462 }