API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 18th, 2014
445
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 92.21 KB | None | 0 0
raw download clone embed print report
  1. root@linux-debian-1:/var/www/dns.web.local/httpdocs# cat lib/idna/idna_convert.class.php
  2. <?php
  3. // {{{ license
  4.  
  5. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
  6. //
  7. // +----------------------------------------------------------------------+
  8. // | This library is free software; you can redistribute it and/or modify |
  9. // | it under the terms of the GNU Lesser General Public License as       |
  10. // | published by the Free Software Foundation; either version 2.1 of the |
  11. // | License, or (at your option) any later version.                      |
  12. // |                                                                      |
  13. // | This library is distributed in the hope that it will be useful, but  |
  14. // | WITHOUT ANY WARRANTY; without even the implied warranty of           |
  15. // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
  16. // | Lesser General Public License for more details.                      |
  17. // |                                                                      |
  18. // | You should have received a copy of the GNU Lesser General Public     |
  19. // | License along with this library; if not, write to the Free Software  |
  20. // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
  21. // | USA.                                                                 |
  22. // +----------------------------------------------------------------------+
  23. //
  24.  
  25. // }}}
  26.  
  27. /**
  28.  * Encode/decode Internationalized Domain Names.
  29.  *
  30.  * The class allows to convert internationalized domain names
  31.  * (see RFC 3490 for details) as they can be used with various registries worldwide
  32.  * to be translated between their original (localized) form and their encoded form
  33.  * as it will be used in the DNS (Domain Name System).
  34.  *
  35.  * The class provides two public methods, encode() and decode(), which do exactly
  36.  * what you would expect them to do. You are allowed to use complete domain names,
  37.  * simple strings and complete email addresses as well. That means, that you might
  38.  * use any of the following notations:
  39.  *
  40.  * - www.nörgler.com
  41.  * - xn--nrgler-wxa
  42.  * - xn--brse-5qa.xn--knrz-1ra.info
  43.  *
  44.  * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4 array.
  45.  * Unicode output is available in the same formats.
  46.  * You can select your preferred format via {@link set_paramter()}.
  47.  *
  48.  * ACE input and output is always expected to be ASCII.
  49.  *
  50.  * @author  Matthias Sommerfeld <mso@phlylabs.de>
  51.  * @author  Leonid Kogan <lko@neuse.de>
  52.  * @copyright 2004-2010 phlyLabs Berlin, http://phlylabs.de
  53.  * @version 0.6.9 2010-11-04
  54.  */
  55. class idna_convert
  56. {
  57.     // NP See below
  58.  
  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.  
  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 $_encode_german_sz = true; // True to encode German ß; False, if not
  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)) return $this->set_parameter($options);
  100.         if (!$this->_encode_german_sz) {
  101.             $this->NP['replacemaps'][0xDF] = array(0x73, 0x73);
  102.         }
  103.     }
  104.  
  105.     /**
  106.      * Sets a new option value. Available options and values:
  107.      * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
  108.      *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
  109.      * [overlong - Unicode does not allow unnecessarily long encodings of chars,
  110.      *             to allow this, set this parameter to true, else to false;
  111.      *             default is false.]
  112.      * [strict - true: strict mode, good for registration purposes - Causes errors
  113.      *           on failures; false: loose mode, ideal for "wildlife" applications
  114.      *           by silently ignoring errors and returning the original input instead
  115.      *
  116.      * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
  117.      * @param    string    Value to use (if parameter 1 is a string)
  118.      * @return   boolean   true on success, false otherwise
  119.      */
  120.     public function set_parameter($option, $value = false)
  121.     {
  122.         if (!is_array($option)) {
  123.             $option = array($option => $value);
  124.         }
  125.         foreach ($option as $k => $v) {
  126.             switch ($k) {
  127.             case 'encoding':
  128.                 switch ($v) {
  129.                 case 'utf8':
  130.                 case 'ucs4_string':
  131.                 case 'ucs4_array':
  132.                     $this->_api_encoding = $v;
  133.                     break;
  134.                 default:
  135.                     $this->_error('Set Parameter: Unknown parameter '.$v.' for option '.$k);
  136.                     return false;
  137.                 }
  138.                 break;
  139.             case 'overlong':
  140.                 $this->_allow_overlong = ($v) ? true : false;
  141.                 break;
  142.             case 'strict':
  143.                 $this->_strict_mode = ($v) ? true : false;
  144.                 break;
  145.             case 'encode_german_sz':
  146.                 $this->_encode_german_sz = ($v) ? true : false;
  147.                 break;
  148.             default:
  149.                 $this->_error('Set Parameter: Unknown option '.$k);
  150.                 return false;
  151.             }
  152.         }
  153.         return true;
  154.     }
  155.  
  156.     /**
  157.      * Decode a given ACE domain name
  158.      * @param    string   Domain name (ACE string)
  159.      * [@param    string   Desired output encoding, see {@link set_parameter}]
  160.      * @return   string   Decoded Domain name (UTF-8 or UCS-4)
  161.      */
  162.     public function decode($input, $one_time_encoding = false)
  163.     {
  164.         // Optionally set
  165.         if ($one_time_encoding) {
  166.             switch ($one_time_encoding) {
  167.             case 'utf8':
  168.             case 'ucs4_string':
  169.             case 'ucs4_array':
  170.                 break;
  171.             default:
  172.                 $this->_error('Unknown encoding '.$one_time_encoding);
  173.                 return false;
  174.             }
  175.         }
  176.         // Make sure to drop any newline characters around
  177.         $input = trim($input);
  178.  
  179.         // Negotiate input and try to determine, whether it is a plain string,
  180.         // an email address or something like a complete URL
  181.         if (strpos($input, '@')) { // Maybe it is an email address
  182.             // No no in strict mode
  183.             if ($this->_strict_mode) {
  184.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  185.                 return false;
  186.             }
  187.             list ($email_pref, $input) = explode('@', $input, 2);
  188.             $arr = explode('.', $input);
  189.             foreach ($arr as $k => $v) {
  190.                 if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
  191.                     $conv = $this->_decode($v);
  192.                     if ($conv) $arr[$k] = $conv;
  193.                 }
  194.             }
  195.             $input = join('.', $arr);
  196.             $arr = explode('.', $email_pref);
  197.             foreach ($arr as $k => $v) {
  198.                 if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
  199.                     $conv = $this->_decode($v);
  200.                     if ($conv) $arr[$k] = $conv;
  201.                 }
  202.             }
  203.             $email_pref = join('.', $arr);
  204.             $return = $email_pref . '@' . $input;
  205.         } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
  206.             // No no in strict mode
  207.             if ($this->_strict_mode) {
  208.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  209.                 return false;
  210.             }
  211.             $parsed = parse_url($input);
  212.             if (isset($parsed['host'])) {
  213.                 $arr = explode('.', $parsed['host']);
  214.                 foreach ($arr as $k => $v) {
  215.                     $conv = $this->_decode($v);
  216.                     if ($conv) $arr[$k] = $conv;
  217.                 }
  218.                 $parsed['host'] = join('.', $arr);
  219.                 $return =
  220.                         (empty($parsed['scheme']) ? '' : $parsed['scheme'].(strtolower($parsed['scheme']) == 'mailto' ? ':' : '://'))
  221.                         .(empty($parsed['user']) ? '' : $parsed['user'].(empty($parsed['pass']) ? '' : ':'.$parsed['pass']).'@')
  222.                         .$parsed['host']
  223.                         .(empty($parsed['port']) ? '' : ':'.$parsed['port'])
  224.                         .(empty($parsed['path']) ? '' : $parsed['path'])
  225.                         .(empty($parsed['query']) ? '' : '?'.$parsed['query'])
  226.                         .(empty($parsed['fragment']) ? '' : '#'.$parsed['fragment']);
  227.             } else { // parse_url seems to have failed, try without it
  228.                 $arr = explode('.', $input);
  229.                 foreach ($arr as $k => $v) {
  230.                     $conv = $this->_decode($v);
  231.                     $arr[$k] = ($conv) ? $conv : $v;
  232.                 }
  233.                 $return = join('.', $arr);
  234.             }
  235.         } else { // Otherwise we consider it being a pure domain name string
  236.             $return = $this->_decode($input);
  237.             if (!$return) $return = $input;
  238.         }
  239.         // The output is UTF-8 by default, other output formats need conversion here
  240.         // If one time encoding is given, use this, else the objects property
  241.         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
  242.         case 'utf8':
  243.             return $return;
  244.             break;
  245.         case 'ucs4_string':
  246.            return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
  247.            break;
  248.         case 'ucs4_array':
  249.             return $this->_utf8_to_ucs4($return);
  250.             break;
  251.         default:
  252.             $this->_error('Unsupported output format');
  253.             return false;
  254.         }
  255.     }
  256.  
  257.     /**
  258.      * Encode a given UTF-8 domain name
  259.      * @param    string   Domain name (UTF-8 or UCS-4)
  260.      * [@param    string   Desired input encoding, see {@link set_parameter}]
  261.      * @return   string   Encoded Domain name (ACE string)
  262.      */
  263.     public function encode($decoded, $one_time_encoding = false)
  264.     {
  265.         // Forcing conversion of input to UCS4 array
  266.         // If one time encoding is given, use this, else the objects property
  267.         switch ($one_time_encoding ? $one_time_encoding : $this->_api_encoding) {
  268.         case 'utf8':
  269.             $decoded = $this->_utf8_to_ucs4($decoded);
  270.             break;
  271.         case 'ucs4_string':
  272.            $decoded = $this->_ucs4_string_to_ucs4($decoded);
  273.         case 'ucs4_array':
  274.            break;
  275.         default:
  276.             $this->_error('Unsupported input format: '.($one_time_encoding ? $one_time_encoding : $this->_api_encoding));
  277.             return false;
  278.         }
  279.  
  280.         // No input, no output, what else did you expect?
  281.         if (empty($decoded)) return '';
  282.  
  283.         // Anchors for iteration
  284.         $last_begin = 0;
  285.         // Output string
  286.         $output = '';
  287.         foreach ($decoded as $k => $v) {
  288.             // Make sure to use just the plain dot
  289.             switch($v) {
  290.             case 0x3002:
  291.             case 0xFF0E:
  292.             case 0xFF61:
  293.                 $decoded[$k] = 0x2E;
  294.                 // Right, no break here, the above are converted to dots anyway
  295.             // Stumbling across an anchoring character
  296.             case 0x2E:
  297.             case 0x2F:
  298.             case 0x3A:
  299.             case 0x3F:
  300.             case 0x40:
  301.                 // Neither email addresses nor URLs allowed in strict mode
  302.                 if ($this->_strict_mode) {
  303.                    $this->_error('Neither email addresses nor URLs are allowed in strict mode.');
  304.                    return false;
  305.                 } else {
  306.                     // Skip first char
  307.                     if ($k) {
  308.                         $encoded = '';
  309.                         $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  310.                         if ($encoded) {
  311.                             $output .= $encoded;
  312.                         } else {
  313.                             $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  314.                         }
  315.                         $output .= chr($decoded[$k]);
  316.                     }
  317.                     $last_begin = $k + 1;
  318.                 }
  319.             }
  320.         }
  321.         // Catch the rest of the string
  322.         if ($last_begin) {
  323.             $inp_len = sizeof($decoded);
  324.             $encoded = '';
  325.             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  326.             if ($encoded) {
  327.                 $output .= $encoded;
  328.             } else {
  329.                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  330.             }
  331.             return $output;
  332.         } else {
  333.             if ($output = $this->_encode($decoded)) {
  334.                 return $output;
  335.             } else {
  336.                 return $this->_ucs4_to_utf8($decoded);
  337.             }
  338.         }
  339.     }
  340.  
  341.     /**
  342.      * Removes a weakness of encode(), which cannot properly handle URIs but instead encodes their
  343.      * path or query components, too.
  344.      * @param string  $uri  Expects the URI as a UTF-8 (or ASCII) string
  345.      * @return  string  The URI encoded to Punycode, everything but the host component is left alone
  346.      * @since 0.6.4
  347.      */
  348.     public function encode_uri($uri)
  349.     {
  350.         $parsed = parse_url($uri);
  351.         if (!isset($parsed['host'])) {
  352.             $this->_error('The given string does not look like a URI');
  353.             return false;
  354.         }
  355.         $arr = explode('.', $parsed['host']);
  356.         foreach ($arr as $k => $v) {
  357.             $conv = $this->encode($v, 'utf8');
  358.             if ($conv) $arr[$k] = $conv;
  359.         }
  360.         $parsed['host'] = join('.', $arr);
  361.         $return =
  362.                 (empty($parsed['scheme']) ? '' : $parsed['scheme'].(strtolower($parsed['scheme']) == 'mailto' ? ':' : '://'))
  363.                 .(empty($parsed['user']) ? '' : $parsed['user'].(empty($parsed['pass']) ? '' : ':'.$parsed['pass']).'@')
  364.                 .$parsed['host']
  365.                 .(empty($parsed['port']) ? '' : ':'.$parsed['port'])
  366.                 .(empty($parsed['path']) ? '' : $parsed['path'])
  367.                 .(empty($parsed['query']) ? '' : '?'.$parsed['query'])
  368.                 .(empty($parsed['fragment']) ? '' : '#'.$parsed['fragment']);
  369.         return $return;
  370.     }
  371.  
  372.     /**
  373.      * Use this method to get the last error ocurred
  374.      * @param    void
  375.      * @return   string   The last error, that occured
  376.      */
  377.     public function get_last_error()
  378.     {
  379.         return $this->_error;
  380.     }
  381.  
  382.     /**
  383.      * The actual decoding algorithm
  384.      * @param string
  385.      * @return mixed
  386.      */
  387.     protected function _decode($encoded)
  388.     {
  389.         $decoded = array();
  390.         // find the Punycode prefix
  391.         if (!preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $encoded)) {
  392.             $this->_error('This is not a punycode string');
  393.             return false;
  394.         }
  395.         $encode_test = preg_replace('!^'.preg_quote($this->_punycode_prefix, '!').'!', '', $encoded);
  396.         // If nothing left after removing the prefix, it is hopeless
  397.         if (!$encode_test) {
  398.             $this->_error('The given encoded string was empty');
  399.             return false;
  400.         }
  401.         // Find last occurence of the delimiter
  402.         $delim_pos = strrpos($encoded, '-');
  403.         if ($delim_pos > strlen($this->_punycode_prefix)) {
  404.             for ($k = strlen($this->_punycode_prefix); $k < $delim_pos; ++$k) {
  405.                 $decoded[] = ord($encoded{$k});
  406.             }
  407.         }
  408.         $deco_len = count($decoded);
  409.         $enco_len = strlen($encoded);
  410.  
  411.         // Wandering through the strings; init
  412.         $is_first = true;
  413.         $bias = $this->_initial_bias;
  414.         $idx = 0;
  415.         $char = $this->_initial_n;
  416.  
  417.         for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
  418.             for ($old_idx = $idx, $w = 1, $k = $this->_base; 1 ; $k += $this->_base) {
  419.                 $digit = $this->_decode_digit($encoded{$enco_idx++});
  420.                 $idx += $digit * $w;
  421.                 $t = ($k <= $bias) ? $this->_tmin :
  422.                         (($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
  423.                 if ($digit < $t) break;
  424.                 $w = (int) ($w * ($this->_base - $t));
  425.             }
  426.             $bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
  427.             $is_first = false;
  428.             $char += (int) ($idx / ($deco_len + 1));
  429.             $idx %= ($deco_len + 1);
  430.             if ($deco_len > 0) {
  431.                 // Make room for the decoded char
  432.                 for ($i = $deco_len; $i > $idx; $i--) $decoded[$i] = $decoded[($i - 1)];
  433.             }
  434.             $decoded[$idx++] = $char;
  435.         }
  436.         return $this->_ucs4_to_utf8($decoded);
  437.     }
  438.  
  439.     /**
  440.      * The actual encoding algorithm
  441.      * @param  string
  442.      * @return mixed
  443.      */
  444.     protected function _encode($decoded)
  445.     {
  446.         // We cannot encode a domain name containing the Punycode prefix
  447.         $extract = strlen($this->_punycode_prefix);
  448.         $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
  449.         $check_deco = array_slice($decoded, 0, $extract);
  450.  
  451.         if ($check_pref == $check_deco) {
  452.             $this->_error('This is already a punycode string');
  453.             return false;
  454.         }
  455.         // We will not try to encode strings consisting of basic code points only
  456.         $encodable = false;
  457.         foreach ($decoded as $k => $v) {
  458.             if ($v > 0x7a) {
  459.                 $encodable = true;
  460.                 break;
  461.             }
  462.         }
  463.         if (!$encodable) {
  464.             $this->_error('The given string does not contain encodable chars');
  465.             return false;
  466.         }
  467.         // Do NAMEPREP
  468.         $decoded = $this->_nameprep($decoded);
  469.         if (!$decoded || !is_array($decoded)) return false; // NAMEPREP failed
  470.         $deco_len  = count($decoded);
  471.         if (!$deco_len) return false; // Empty array
  472.         $codecount = 0; // How many chars have been consumed
  473.         $encoded = '';
  474.         // Copy all basic code points to output
  475.         for ($i = 0; $i < $deco_len; ++$i) {
  476.             $test = $decoded[$i];
  477.             // Will match [-0-9a-zA-Z]
  478.             if ((0x2F < $test && $test < 0x40) || (0x40 < $test && $test < 0x5B)
  479.                     || (0x60 < $test && $test <= 0x7B) || (0x2D == $test)) {
  480.                 $encoded .= chr($decoded[$i]);
  481.                 $codecount++;
  482.             }
  483.         }
  484.         if ($codecount == $deco_len) return $encoded; // All codepoints were basic ones
  485.  
  486.         // Start with the prefix; copy it to output
  487.         $encoded = $this->_punycode_prefix.$encoded;
  488.         // If we have basic code points in output, add an hyphen to the end
  489.         if ($codecount) $encoded .= '-';
  490.         // Now find and encode all non-basic code points
  491.         $is_first = true;
  492.         $cur_code = $this->_initial_n;
  493.         $bias = $this->_initial_bias;
  494.         $delta = 0;
  495.         while ($codecount < $deco_len) {
  496.             // Find the smallest code point >= the current code point and
  497.             // remember the last ouccrence of it in the input
  498.             for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
  499.                 if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
  500.                     $next_code = $decoded[$i];
  501.                 }
  502.             }
  503.             $delta += ($next_code - $cur_code) * ($codecount + 1);
  504.             $cur_code = $next_code;
  505.  
  506.             // Scan input again and encode all characters whose code point is $cur_code
  507.             for ($i = 0; $i < $deco_len; $i++) {
  508.                 if ($decoded[$i] < $cur_code) {
  509.                     $delta++;
  510.                 } elseif ($decoded[$i] == $cur_code) {
  511.                     for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
  512.                         $t = ($k <= $bias) ? $this->_tmin :
  513.                                 (($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
  514.                         if ($q < $t) break;
  515.                         $encoded .= $this->_encode_digit(intval($t + (($q - $t) % ($this->_base - $t)))); //v0.4.5 Changed from ceil() to intval()
  516.                         $q = (int) (($q - $t) / ($this->_base - $t));
  517.                     }
  518.                     $encoded .= $this->_encode_digit($q);
  519.                     $bias = $this->_adapt($delta, $codecount+1, $is_first);
  520.                     $codecount++;
  521.                     $delta = 0;
  522.                     $is_first = false;
  523.                 }
  524.             }
  525.             $delta++;
  526.             $cur_code++;
  527.         }
  528.         return $encoded;
  529.     }
  530.  
  531.     /**
  532.      * Adapt the bias according to the current code point and position
  533.      * @param int $delta
  534.      * @param int $npoints
  535.      * @param int $is_first
  536.      * @return int
  537.      */
  538.     protected function _adapt($delta, $npoints, $is_first)
  539.     {
  540.         $delta = intval($is_first ? ($delta / $this->_damp) : ($delta / 2));
  541.         $delta += intval($delta / $npoints);
  542.         for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
  543.             $delta = intval($delta / ($this->_base - $this->_tmin));
  544.         }
  545.         return intval($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
  546.     }
  547.  
  548.     /**
  549.      * Encoding a certain digit
  550.      * @param    int $d
  551.      * @return string
  552.      */
  553.     protected function _encode_digit($d)
  554.     {
  555.         return chr($d + 22 + 75 * ($d < 26));
  556.     }
  557.  
  558.     /**
  559.      * Decode a certain digit
  560.      * @param    int $cp
  561.      * @return int
  562.      */
  563.     protected function _decode_digit($cp)
  564.     {
  565.         $cp = ord($cp);
  566.         return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
  567.     }
  568.  
  569.     /**
  570.      * Internal error handling method
  571.      * @param  string $error
  572.      */
  573.     protected function _error($error = '')
  574.     {
  575.         $this->_error = $error;
  576.     }
  577.  
  578.     /**
  579.      * Do Nameprep according to RFC3491 and RFC3454
  580.      * @param    array    Unicode Characters
  581.      * @return   string   Unicode Characters, Nameprep'd
  582.      */
  583.     protected function _nameprep($input)
  584.     {
  585.         $output = array();
  586.         $error = false;
  587.         //
  588.         // Mapping
  589.         // Walking through the input array, performing the required steps on each of
  590.         // the input chars and putting the result into the output array
  591.         // While mapping required chars we apply the cannonical ordering
  592.         foreach ($input as $v) {
  593.             // Map to nothing == skip that code point
  594.             if (in_array($v, $this->NP['map_nothing'])) continue;
  595.             // Try to find prohibited input
  596.             if (in_array($v, $this->NP['prohibit']) || in_array($v, $this->NP['general_prohibited'])) {
  597.                 $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  598.                 return false;
  599.             }
  600.             foreach ($this->NP['prohibit_ranges'] as $range) {
  601.                 if ($range[0] <= $v && $v <= $range[1]) {
  602.                     $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  603.                     return false;
  604.                 }
  605.             }
  606.             // Hangul syllable decomposition
  607.             if (0xAC00 <= $v && $v <= 0xD7AF) {
  608.                 foreach ($this->_hangul_decompose($v) as $out) $output[] = (int) $out;
  609.             // There's a decomposition mapping for that code point
  610.             } elseif (isset($this->NP['replacemaps'][$v])) {
  611.                 foreach ($this->_apply_cannonical_ordering($this->NP['replacemaps'][$v]) as $out) {
  612.                     $output[] = (int) $out;
  613.                 }
  614.             } else {
  615.                 $output[] = (int) $v;
  616.             }
  617.         }
  618.         // Before applying any Combining, try to rearrange any Hangul syllables
  619.         $output = $this->_hangul_compose($output);
  620.         //
  621.         // Combine code points
  622.         //
  623.         $last_class = 0;
  624.         $last_starter = 0;
  625.         $out_len = count($output);
  626.         for ($i = 0; $i < $out_len; ++$i) {
  627.             $class = $this->_get_combining_class($output[$i]);
  628.             if ((!$last_class || $last_class > $class) && $class) {
  629.                 // Try to match
  630.                 $seq_len = $i - $last_starter;
  631.                 $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
  632.                 // On match: Replace the last starter with the composed character and remove
  633.                 // the now redundant non-starter(s)
  634.                 if ($out) {
  635.                     $output[$last_starter] = $out;
  636.                     if (count($out) != $seq_len) {
  637.                         for ($j = $i+1; $j < $out_len; ++$j) $output[$j-1] = $output[$j];
  638.                         unset($output[$out_len]);
  639.                     }
  640.                     // Rewind the for loop by one, since there can be more possible compositions
  641.                     $i--;
  642.                     $out_len--;
  643.                     $last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i-1]);
  644.                     continue;
  645.                 }
  646.             }
  647.             // The current class is 0
  648.             if (!$class) $last_starter = $i;
  649.             $last_class = $class;
  650.         }
  651.         return $output;
  652.     }
  653.  
  654.     /**
  655.      * Decomposes a Hangul syllable
  656.      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  657.      * @param    integer  32bit UCS4 code point
  658.      * @return   array    Either Hangul Syllable decomposed or original 32bit value as one value array
  659.      */
  660.     protected function _hangul_decompose($char)
  661.     {
  662.         $sindex = (int) $char - $this->_sbase;
  663.         if ($sindex < 0 || $sindex >= $this->_scount) return array($char);
  664.         $result = array();
  665.         $result[] = (int) $this->_lbase + $sindex / $this->_ncount;
  666.         $result[] = (int) $this->_vbase + ($sindex % $this->_ncount) / $this->_tcount;
  667.         $T = intval($this->_tbase + $sindex % $this->_tcount);
  668.         if ($T != $this->_tbase) $result[] = $T;
  669.         return $result;
  670.     }
  671.     /**
  672.      * Ccomposes a Hangul syllable
  673.      * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  674.      * @param    array    Decomposed UCS4 sequence
  675.      * @return   array    UCS4 sequence with syllables composed
  676.      */
  677.     protected function _hangul_compose($input)
  678.     {
  679.         $inp_len = count($input);
  680.         if (!$inp_len) return array();
  681.         $result = array();
  682.         $last = (int) $input[0];
  683.         $result[] = $last; // copy first char from input to output
  684.  
  685.         for ($i = 1; $i < $inp_len; ++$i) {
  686.             $char = (int) $input[$i];
  687.             $sindex = $last - $this->_sbase;
  688.             $lindex = $last - $this->_lbase;
  689.             $vindex = $char - $this->_vbase;
  690.             $tindex = $char - $this->_tbase;
  691.             // Find out, whether two current characters are LV and T
  692.             if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount == 0)
  693.                     && 0 <= $tindex && $tindex <= $this->_tcount) {
  694.                 // create syllable of form LVT
  695.                 $last += $tindex;
  696.                 $result[(count($result) - 1)] = $last; // reset last
  697.                 continue; // discard char
  698.             }
  699.             // Find out, whether two current characters form L and V
  700.             if (0 <= $lindex && $lindex < $this->_lcount && 0 <= $vindex && $vindex < $this->_vcount) {
  701.                 // create syllable of form LV
  702.                 $last = (int) $this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount;
  703.                 $result[(count($result) - 1)] = $last; // reset last
  704.                 continue; // discard char
  705.             }
  706.             // if neither case was true, just add the character
  707.             $last = $char;
  708.             $result[] = $char;
  709.         }
  710.         return $result;
  711.     }
  712.  
  713.     /**
  714.      * Returns the combining class of a certain wide char
  715.      * @param    integer    Wide char to check (32bit integer)
  716.      * @return   integer    Combining class if found, else 0
  717.      */
  718.     protected function _get_combining_class($char)
  719.     {
  720.         return isset($this->NP['norm_combcls'][$char]) ? $this->NP['norm_combcls'][$char] : 0;
  721.     }
  722.  
  723.     /**
  724.      * Apllies the cannonical ordering of a decomposed UCS4 sequence
  725.      * @param    array      Decomposed UCS4 sequence
  726.      * @return   array      Ordered USC4 sequence
  727.      */
  728.     protected function _apply_cannonical_ordering($input)
  729.     {
  730.         $swap = true;
  731.         $size = count($input);
  732.         while ($swap) {
  733.             $swap = false;
  734.             $last = $this->_get_combining_class(intval($input[0]));
  735.             for ($i = 0; $i < $size-1; ++$i) {
  736.                 $next = $this->_get_combining_class(intval($input[$i+1]));
  737.                 if ($next != 0 && $last > $next) {
  738.                     // Move item leftward until it fits
  739.                     for ($j = $i + 1; $j > 0; --$j) {
  740.                         if ($this->_get_combining_class(intval($input[$j-1])) <= $next) break;
  741.                         $t = intval($input[$j]);
  742.                         $input[$j] = intval($input[$j-1]);
  743.                         $input[$j-1] = $t;
  744.                         $swap = true;
  745.                     }
  746.                     // Reentering the loop looking at the old character again
  747.                     $next = $last;
  748.                 }
  749.                 $last = $next;
  750.             }
  751.         }
  752.         return $input;
  753.     }
  754.  
  755.     /**
  756.      * Do composition of a sequence of starter and non-starter
  757.      * @param    array      UCS4 Decomposed sequence
  758.      * @return   array      Ordered USC4 sequence
  759.      */
  760.     protected function _combine($input)
  761.     {
  762.         $inp_len = count($input);
  763.         foreach ($this->NP['replacemaps'] as $np_src => $np_target) {
  764.             if ($np_target[0] != $input[0]) continue;
  765.             if (count($np_target) != $inp_len) continue;
  766.             $hit = false;
  767.             foreach ($input as $k2 => $v2) {
  768.                 if ($v2 == $np_target[$k2]) {
  769.                     $hit = true;
  770.                 } else {
  771.                     $hit = false;
  772.                     break;
  773.                 }
  774.             }
  775.             if ($hit) return $np_src;
  776.         }
  777.         return false;
  778.     }
  779.  
  780.     /**
  781.      * This converts an UTF-8 encoded string to its UCS-4 representation
  782.      * By talking about UCS-4 "strings" we mean arrays of 32bit integers representing
  783.      * each of the "chars". This is due to PHP not being able to handle strings with
  784.      * bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too.
  785.      * The following UTF-8 encodings are supported:
  786.      * bytes bits  representation
  787.      * 1        7  0xxxxxxx
  788.      * 2       11  110xxxxx 10xxxxxx
  789.      * 3       16  1110xxxx 10xxxxxx 10xxxxxx
  790.      * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  791.      * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  792.      * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  793.      * Each x represents a bit that can be used to store character data.
  794.      * The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000
  795.      * @param string $input
  796.      * @return string
  797.      */
  798.     protected function _utf8_to_ucs4($input)
  799.     {
  800.         $output = array();
  801.         $out_len = 0;
  802.         // Patch by Daniel Hahler; work around prolbem with mbstring.func_overload
  803.         if (function_exists('mb_strlen')) {
  804.             $inp_len = mb_strlen($input, '8bit');
  805.         } else {
  806.             $inp_len = strlen($input);
  807.         }
  808.         $mode = 'next';
  809.         $test = 'none';
  810.         for ($k = 0; $k < $inp_len; ++$k) {
  811.             $v = ord($input{$k}); // Extract byte from input string
  812.             if ($v < 128) { // We found an ASCII char - put into stirng as is
  813.                 $output[$out_len] = $v;
  814.                 ++$out_len;
  815.                 if ('add' == $mode) {
  816.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  817.                     return false;
  818.                 }
  819.                 continue;
  820.             }
  821.             if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
  822.                 $start_byte = $v;
  823.                 $mode = 'add';
  824.                 $test = 'range';
  825.                 if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
  826.                     $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
  827.                     $v = ($v - 192) << 6;
  828.                 } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
  829.                     $next_byte = 1;
  830.                     $v = ($v - 224) << 12;
  831.                 } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  832.                     $next_byte = 2;
  833.                     $v = ($v - 240) << 18;
  834.                 } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  835.                     $next_byte = 3;
  836.                     $v = ($v - 248) << 24;
  837.                 } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  838.                     $next_byte = 4;
  839.                     $v = ($v - 252) << 30;
  840.                 } else {
  841.                     $this->_error('This might be UTF-8, but I don\'t understand it at byte '.$k);
  842.                     return false;
  843.                 }
  844.                 if ('add' == $mode) {
  845.                     $output[$out_len] = (int) $v;
  846.                     ++$out_len;
  847.                     continue;
  848.                 }
  849.             }
  850.             if ('add' == $mode) {
  851.                 if (!$this->_allow_overlong && $test == 'range') {
  852.                     $test = 'none';
  853.                     if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
  854.                         $this->_error('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
  855.                         return false;
  856.                     }
  857.                 }
  858.                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
  859.                     $v = ($v - 128) << ($next_byte * 6);
  860.                     $output[($out_len - 1)] += $v;
  861.                     --$next_byte;
  862.                 } else {
  863.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  864.                     return false;
  865.                 }
  866.                 if ($next_byte < 0) {
  867.                     $mode = 'next';
  868.                 }
  869.             }
  870.         } // for
  871.         return $output;
  872.     }
  873.  
  874.     /**
  875.      * Convert UCS-4 string into UTF-8 string
  876.      * See _utf8_to_ucs4() for details
  877.      * @param string  $input
  878.      * @return string
  879.      */
  880.     protected function _ucs4_to_utf8($input)
  881.     {
  882.         $output = '';
  883.         foreach ($input as $k => $v) {
  884.             if ($v < 128) { // 7bit are transferred literally
  885.                 $output .= chr($v);
  886.             } elseif ($v < (1 << 11)) { // 2 bytes
  887.                 $output .= chr(192+($v >> 6)).chr(128+($v & 63));
  888.             } elseif ($v < (1 << 16)) { // 3 bytes
  889.                 $output .= chr(224+($v >> 12)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
  890.             } elseif ($v < (1 << 21)) { // 4 bytes
  891.                 $output .= chr(240+($v >> 18)).chr(128+(($v >> 12) & 63)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
  892.             } elseif (self::$safe_mode) {
  893.                 $output .= self::$safe_char;
  894.             } else {
  895.                 $this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
  896.                 return false;
  897.             }
  898.         }
  899.         return $output;
  900.     }
  901.  
  902.     /**
  903.      * Convert UCS-4 array into UCS-4 string
  904.      *
  905.      * @param array $input
  906.      * @return string
  907.      */
  908.     protected function _ucs4_to_ucs4_string($input)
  909.     {
  910.         $output = '';
  911.         // Take array values and split output to 4 bytes per value
  912.         // The bit mask is 255, which reads &11111111
  913.         foreach ($input as $v) {
  914.             $output .= chr(($v >> 24) & 255).chr(($v >> 16) & 255).chr(($v >> 8) & 255).chr($v & 255);
  915.         }
  916.         return $output;
  917.     }
  918.  
  919.     /**
  920.      * Convert UCS-4 strin into UCS-4 garray
  921.      *
  922.      * @param  string $input
  923.      * @return array
  924.      */
  925.     protected function _ucs4_string_to_ucs4($input)
  926.     {
  927.         $output = array();
  928.         $inp_len = strlen($input);
  929.         // Input length must be dividable by 4
  930.         if ($inp_len % 4) {
  931.             $this->_error('Input UCS4 string is broken');
  932.             return false;
  933.         }
  934.         // Empty input - return empty output
  935.         if (!$inp_len) return $output;
  936.         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
  937.             // Increment output position every 4 input bytes
  938.             if (!($i % 4)) {
  939.                 $out_len++;
  940.                 $output[$out_len] = 0;
  941.             }
  942.             $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
  943.         }
  944.         return $output;
  945.     }
  946.  
  947.     /**
  948.      * Holds all relevant mapping tables
  949.      * See RFC3454 for details
  950.      *
  951.      * @private array
  952.      * @since 0.5.2
  953.      */
  954.     protected $NP = array
  955.             ('map_nothing' => array(0xAD, 0x34F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B, 0x200C
  956.                     ,0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07
  957.                     ,0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF
  958.                     )
  959.             ,'general_prohibited' => array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
  960.                     ,20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 ,33, 34, 35, 36, 37, 38, 39, 40, 41, 42
  961.                     ,43, 44, 47, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94, 95, 96, 123, 124, 125, 126, 127, 0x3002
  962.                     )
  963.             ,'prohibit' => array(0xA0, 0x340, 0x341, 0x6DD, 0x70F, 0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003
  964.                     ,0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x200C, 0x200D, 0x200E, 0x200F
  965.                     ,0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E, 0x202F, 0x205F, 0x206A, 0x206B, 0x206C
  966.                     ,0x206D, 0x206E, 0x206F, 0x3000, 0xFEFF, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF
  967.                     ,0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE
  968.                     ,0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, 0xBFFFF
  969.                     ,0xCFFFE, 0xCFFFF, 0xDFFFE, 0xDFFFF, 0xE0001, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, 0x10FFFF
  970.                     )
  971.             ,'prohibit_ranges' => array(array(0x80, 0x9F), array(0x2060, 0x206F), array(0x1D173, 0x1D17A)
  972.                     ,array(0xE000, 0xF8FF) ,array(0xF0000, 0xFFFFD), array(0x100000, 0x10FFFD)
  973.                     ,array(0xFDD0, 0xFDEF), array(0xD800, 0xDFFF), array(0x2FF0, 0x2FFB), array(0xE0020, 0xE007F)
  974.                     )
  975.             ,'replacemaps' => array(0x41 => array(0x61), 0x42 => array(0x62), 0x43 => array(0x63)
  976.                     ,0x44 => array(0x64), 0x45 => array(0x65), 0x46 => array(0x66), 0x47 => array(0x67)
  977.                     ,0x48 => array(0x68), 0x49 => array(0x69), 0x4A => array(0x6A), 0x4B => array(0x6B)
  978.                     ,0x4C => array(0x6C), 0x4D => array(0x6D), 0x4E => array(0x6E), 0x4F => array(0x6F)
  979.                     ,0x50 => array(0x70), 0x51 => array(0x71), 0x52 => array(0x72), 0x53 => array(0x73)
  980.                     ,0x54 => array(0x74), 0x55 => array(0x75), 0x56 => array(0x76), 0x57 => array(0x77)
  981.                     ,0x58 => array(0x78), 0x59 => array(0x79), 0x5A => array(0x7A), 0xB5 => array(0x3BC)
  982.                     ,0xC0 => array(0xE0), 0xC1 => array(0xE1), 0xC2 => array(0xE2), 0xC3 => array(0xE3)
  983.                     ,0xC4 => array(0xE4), 0xC5 => array(0xE5), 0xC6 => array(0xE6), 0xC7 => array(0xE7)
  984.                     ,0xC8 => array(0xE8), 0xC9 => array(0xE9), 0xCA => array(0xEA), 0xCB => array(0xEB)
  985.                     ,0xCC => array(0xEC), 0xCD => array(0xED), 0xCE => array(0xEE), 0xCF => array(0xEF)
  986.                     ,0xD0 => array(0xF0), 0xD1 => array(0xF1), 0xD2 => array(0xF2), 0xD3 => array(0xF3)
  987.                     ,0xD4 => array(0xF4), 0xD5 => array(0xF5), 0xD6 => array(0xF6), 0xD8 => array(0xF8)
  988.                     ,0xD9 => array(0xF9), 0xDA => array(0xFA), 0xDB => array(0xFB), 0xDC => array(0xFC)
  989.                     ,0xDD => array(0xFD), 0xDE => array(0xFE) /* Here was German "ß" -> "ss", is now configurable */
  990.                     ,0x100 => array(0x101), 0x102 => array(0x103), 0x104 => array(0x105)
  991.                     ,0x106 => array(0x107), 0x108 => array(0x109), 0x10A => array(0x10B)
  992.                     ,0x10C => array(0x10D), 0x10E => array(0x10F), 0x110 => array(0x111)
  993.                     ,0x112 => array(0x113), 0x114 => array(0x115), 0x116 => array(0x117)
  994.                     ,0x118 => array(0x119), 0x11A => array(0x11B), 0x11C => array(0x11D)
  995.                     ,0x11E => array(0x11F), 0x120 => array(0x121), 0x122 => array(0x123)
  996.                     ,0x124 => array(0x125), 0x126 => array(0x127), 0x128 => array(0x129)
  997.                     ,0x12A => array(0x12B), 0x12C => array(0x12D), 0x12E => array(0x12F)
  998.                     ,0x130 => array(0x69, 0x307), 0x132 => array(0x133), 0x134 => array(0x135)
  999.                     ,0x136 => array(0x137), 0x139 => array(0x13A), 0x13B => array(0x13C)
  1000.                     ,0x13D => array(0x13E), 0x13F => array(0x140), 0x141 => array(0x142)
  1001.                     ,0x143 => array(0x144), 0x145 => array(0x146), 0x147 => array(0x148)
  1002.                     ,0x149 => array(0x2BC, 0x6E), 0x14A => array(0x14B), 0x14C => array(0x14D)
  1003.                     ,0x14E => array(0x14F), 0x150 => array(0x151), 0x152 => array(0x153)
  1004.                     ,0x154 => array(0x155), 0x156 => array(0x157), 0x158 => array(0x159)
  1005.                     ,0x15A => array(0x15B), 0x15C => array(0x15D), 0x15E => array(0x15F)
  1006.                     ,0x160 => array(0x161), 0x162 => array(0x163), 0x164 => array(0x165)
  1007.                     ,0x166 => array(0x167), 0x168 => array(0x169), 0x16A => array(0x16B)
  1008.                     ,0x16C => array(0x16D), 0x16E => array(0x16F), 0x170 => array(0x171)
  1009.                     ,0x172 => array(0x173), 0x174 => array(0x175), 0x176 => array(0x177)
  1010.                     ,0x178 => array(0xFF), 0x179 => array(0x17A), 0x17B => array(0x17C)
  1011.                     ,0x17D => array(0x17E), 0x17F => array(0x73), 0x181 => array(0x253)
  1012.                     ,0x182 => array(0x183), 0x184 => array(0x185), 0x186 => array(0x254)
  1013.                     ,0x187 => array(0x188), 0x189 => array(0x256), 0x18A => array(0x257)
  1014.                     ,0x18B => array(0x18C), 0x18E => array(0x1DD), 0x18F => array(0x259)
  1015.                     ,0x190 => array(0x25B), 0x191 => array(0x192), 0x193 => array(0x260)
  1016.                     ,0x194 => array(0x263), 0x196 => array(0x269), 0x197 => array(0x268)
  1017.                     ,0x198 => array(0x199), 0x19C => array(0x26F), 0x19D => array(0x272)
  1018.                     ,0x19F => array(0x275), 0x1A0 => array(0x1A1), 0x1A2 => array(0x1A3)
  1019.                     ,0x1A4 => array(0x1A5), 0x1A6 => array(0x280), 0x1A7 => array(0x1A8)
  1020.                     ,0x1A9 => array(0x283), 0x1AC => array(0x1AD), 0x1AE => array(0x288)
  1021.                     ,0x1AF => array(0x1B0), 0x1B1 => array(0x28A), 0x1B2 => array(0x28B)
  1022.                     ,0x1B3 => array(0x1B4), 0x1B5 => array(0x1B6), 0x1B7 => array(0x292)
  1023.                     ,0x1B8 => array(0x1B9), 0x1BC => array(0x1BD), 0x1C4 => array(0x1C6)
  1024.                     ,0x1C5 => array(0x1C6), 0x1C7 => array(0x1C9), 0x1C8 => array(0x1C9)
  1025.                     ,0x1CA => array(0x1CC), 0x1CB => array(0x1CC), 0x1CD => array(0x1CE)
  1026.                     ,0x1CF => array(0x1D0), 0x1D1   => array(0x1D2), 0x1D3   => array(0x1D4)
  1027.                     ,0x1D5   => array(0x1D6), 0x1D7   => array(0x1D8), 0x1D9   => array(0x1DA)
  1028.                     ,0x1DB   => array(0x1DC), 0x1DE   => array(0x1DF), 0x1E0   => array(0x1E1)
  1029.                     ,0x1E2   => array(0x1E3), 0x1E4   => array(0x1E5), 0x1E6   => array(0x1E7)
  1030.                     ,0x1E8   => array(0x1E9), 0x1EA   => array(0x1EB), 0x1EC   => array(0x1ED)
  1031.                     ,0x1EE   => array(0x1EF), 0x1F0   => array(0x6A, 0x30C), 0x1F1   => array(0x1F3)
  1032.                     ,0x1F2   => array(0x1F3), 0x1F4   => array(0x1F5), 0x1F6   => array(0x195)
  1033.                     ,0x1F7   => array(0x1BF), 0x1F8   => array(0x1F9), 0x1FA   => array(0x1FB)
  1034.                     ,0x1FC   => array(0x1FD), 0x1FE   => array(0x1FF), 0x200   => array(0x201)
  1035.                     ,0x202   => array(0x203), 0x204   => array(0x205), 0x206   => array(0x207)
  1036.                     ,0x208   => array(0x209), 0x20A   => array(0x20B), 0x20C   => array(0x20D)
  1037.                     ,0x20E   => array(0x20F), 0x210   => array(0x211), 0x212   => array(0x213)
  1038.                     ,0x214   => array(0x215), 0x216   => array(0x217), 0x218   => array(0x219)
  1039.                     ,0x21A   => array(0x21B), 0x21C   => array(0x21D), 0x21E   => array(0x21F)
  1040.                     ,0x220   => array(0x19E), 0x222   => array(0x223), 0x224   => array(0x225)
  1041.                     ,0x226   => array(0x227), 0x228   => array(0x229), 0x22A   => array(0x22B)
  1042.                     ,0x22C   => array(0x22D), 0x22E   => array(0x22F), 0x230   => array(0x231)
  1043.                     ,0x232   => array(0x233), 0x345   => array(0x3B9), 0x37A   => array(0x20, 0x3B9)
  1044.                     ,0x386   => array(0x3AC), 0x388   => array(0x3AD), 0x389   => array(0x3AE)
  1045.                     ,0x38A   => array(0x3AF), 0x38C   => array(0x3CC), 0x38E   => array(0x3CD)
  1046.                     ,0x38F   => array(0x3CE), 0x390   => array(0x3B9, 0x308, 0x301)
  1047.                     ,0x391   => array(0x3B1), 0x392   => array(0x3B2), 0x393   => array(0x3B3)
  1048.                     ,0x394   => array(0x3B4), 0x395   => array(0x3B5), 0x396   => array(0x3B6)
  1049.                     ,0x397   => array(0x3B7), 0x398   => array(0x3B8), 0x399   => array(0x3B9)
  1050.                     ,0x39A   => array(0x3BA), 0x39B   => array(0x3BB), 0x39C   => array(0x3BC)
  1051.                     ,0x39D   => array(0x3BD), 0x39E   => array(0x3BE), 0x39F   => array(0x3BF)
  1052.                     ,0x3A0   => array(0x3C0), 0x3A1   => array(0x3C1), 0x3A3   => array(0x3C3)
  1053.                     ,0x3A4   => array(0x3C4), 0x3A5   => array(0x3C5), 0x3A6   => array(0x3C6)
  1054.                     ,0x3A7   => array(0x3C7), 0x3A8   => array(0x3C8), 0x3A9   => array(0x3C9)
  1055.                     ,0x3AA   => array(0x3CA), 0x3AB   => array(0x3CB), 0x3B0   => array(0x3C5, 0x308, 0x301)
  1056.                     ,0x3C2   => array(0x3C3), 0x3D0   => array(0x3B2), 0x3D1   => array(0x3B8)
  1057.                     ,0x3D2   => array(0x3C5), 0x3D3   => array(0x3CD), 0x3D4   => array(0x3CB)
  1058.                     ,0x3D5   => array(0x3C6), 0x3D6   => array(0x3C0), 0x3D8   => array(0x3D9)
  1059.                     ,0x3DA   => array(0x3DB), 0x3DC   => array(0x3DD), 0x3DE   => array(0x3DF)
  1060.                     ,0x3E0   => array(0x3E1), 0x3E2   => array(0x3E3), 0x3E4   => array(0x3E5)
  1061.                     ,0x3E6   => array(0x3E7), 0x3E8   => array(0x3E9), 0x3EA   => array(0x3EB)
  1062.                     ,0x3EC   => array(0x3ED), 0x3EE   => array(0x3EF), 0x3F0   => array(0x3BA)
  1063.                     ,0x3F1   => array(0x3C1), 0x3F2   => array(0x3C3), 0x3F4   => array(0x3B8)
  1064.                     ,0x3F5   => array(0x3B5), 0x400   => array(0x450), 0x401   => array(0x451)
  1065.                     ,0x402   => array(0x452), 0x403   => array(0x453), 0x404   => array(0x454)
  1066.                     ,0x405   => array(0x455), 0x406   => array(0x456), 0x407   => array(0x457)
  1067.                     ,0x408   => array(0x458), 0x409   => array(0x459), 0x40A   => array(0x45A)
  1068.                     ,0x40B   => array(0x45B), 0x40C   => array(0x45C), 0x40D   => array(0x45D)
  1069.                     ,0x40E   => array(0x45E), 0x40F   => array(0x45F), 0x410   => array(0x430)
  1070.                     ,0x411   => array(0x431), 0x412   => array(0x432), 0x413   => array(0x433)
  1071.                     ,0x414   => array(0x434), 0x415   => array(0x435), 0x416   => array(0x436)
  1072.                     ,0x417   => array(0x437), 0x418   => array(0x438), 0x419   => array(0x439)
  1073.                     ,0x41A   => array(0x43A), 0x41B   => array(0x43B), 0x41C   => array(0x43C)
  1074.                     ,0x41D   => array(0x43D), 0x41E   => array(0x43E), 0x41F   => array(0x43F)
  1075.                     ,0x420   => array(0x440), 0x421   => array(0x441), 0x422   => array(0x442)
  1076.                     ,0x423   => array(0x443), 0x424   => array(0x444), 0x425   => array(0x445)
  1077.                     ,0x426   => array(0x446), 0x427   => array(0x447), 0x428   => array(0x448)
  1078.                     ,0x429   => array(0x449), 0x42A   => array(0x44A), 0x42B   => array(0x44B)
  1079.                     ,0x42C   => array(0x44C), 0x42D   => array(0x44D), 0x42E   => array(0x44E)
  1080.                     ,0x42F   => array(0x44F), 0x460   => array(0x461), 0x462   => array(0x463)
  1081.                     ,0x464   => array(0x465), 0x466   => array(0x467), 0x468   => array(0x469)
  1082.                     ,0x46A   => array(0x46B), 0x46C   => array(0x46D), 0x46E   => array(0x46F)
  1083.                     ,0x470   => array(0x471), 0x472   => array(0x473), 0x474   => array(0x475)
  1084.                     ,0x476   => array(0x477), 0x478   => array(0x479), 0x47A   => array(0x47B)
  1085.                     ,0x47C   => array(0x47D), 0x47E   => array(0x47F), 0x480   => array(0x481)
  1086.                     ,0x48A   => array(0x48B), 0x48C   => array(0x48D), 0x48E   => array(0x48F)
  1087.                     ,0x490   => array(0x491), 0x492   => array(0x493), 0x494   => array(0x495)
  1088.                     ,0x496   => array(0x497), 0x498   => array(0x499), 0x49A   => array(0x49B)
  1089.                     ,0x49C   => array(0x49D), 0x49E   => array(0x49F), 0x4A0   => array(0x4A1)
  1090.                     ,0x4A2   => array(0x4A3), 0x4A4   => array(0x4A5), 0x4A6   => array(0x4A7)
  1091.                     ,0x4A8   => array(0x4A9), 0x4AA   => array(0x4AB), 0x4AC   => array(0x4AD)
  1092.                     ,0x4AE   => array(0x4AF), 0x4B0   => array(0x4B1), 0x4B2   => array(0x4B3)
  1093.                     ,0x4B4   => array(0x4B5), 0x4B6   => array(0x4B7), 0x4B8   => array(0x4B9)
  1094.                     ,0x4BA   => array(0x4BB), 0x4BC   => array(0x4BD), 0x4BE   => array(0x4BF)
  1095.                     ,0x4C1   => array(0x4C2), 0x4C3   => array(0x4C4), 0x4C5   => array(0x4C6)
  1096.                     ,0x4C7   => array(0x4C8), 0x4C9   => array(0x4CA), 0x4CB   => array(0x4CC)
  1097.                     ,0x4CD   => array(0x4CE), 0x4D0   => array(0x4D1), 0x4D2   => array(0x4D3)
  1098.                     ,0x4D4   => array(0x4D5), 0x4D6   => array(0x4D7), 0x4D8   => array(0x4D9)
  1099.                     ,0x4DA   => array(0x4DB), 0x4DC   => array(0x4DD), 0x4DE   => array(0x4DF)
  1100.                     ,0x4E0   => array(0x4E1), 0x4E2   => array(0x4E3), 0x4E4   => array(0x4E5)
  1101.                     ,0x4E6   => array(0x4E7), 0x4E8   => array(0x4E9), 0x4EA   => array(0x4EB)
  1102.                     ,0x4EC   => array(0x4ED), 0x4EE   => array(0x4EF), 0x4F0   => array(0x4F1)
  1103.                     ,0x4F2   => array(0x4F3), 0x4F4   => array(0x4F5), 0x4F8   => array(0x4F9)
  1104.                     ,0x500   => array(0x501), 0x502   => array(0x503), 0x504   => array(0x505)
  1105.                     ,0x506   => array(0x507), 0x508   => array(0x509), 0x50A   => array(0x50B)
  1106.                     ,0x50C   => array(0x50D), 0x50E   => array(0x50F), 0x531   => array(0x561)
  1107.                     ,0x532   => array(0x562), 0x533   => array(0x563), 0x534   => array(0x564)
  1108.                     ,0x535   => array(0x565), 0x536   => array(0x566), 0x537   => array(0x567)
  1109.                     ,0x538   => array(0x568), 0x539   => array(0x569), 0x53A   => array(0x56A)
  1110.                     ,0x53B   => array(0x56B), 0x53C   => array(0x56C), 0x53D   => array(0x56D)
  1111.                     ,0x53E   => array(0x56E), 0x53F   => array(0x56F), 0x540   => array(0x570)
  1112.                     ,0x541   => array(0x571), 0x542   => array(0x572), 0x543   => array(0x573)
  1113.                     ,0x544   => array(0x574), 0x545   => array(0x575), 0x546   => array(0x576)
  1114.                     ,0x547   => array(0x577), 0x548   => array(0x578), 0x549   => array(0x579)
  1115.                     ,0x54A   => array(0x57A), 0x54B   => array(0x57B), 0x54C   => array(0x57C)
  1116.                     ,0x54D   => array(0x57D), 0x54E   => array(0x57E), 0x54F   => array(0x57F)
  1117.                     ,0x550   => array(0x580), 0x551   => array(0x581), 0x552   => array(0x582)
  1118.                     ,0x553   => array(0x583), 0x554   => array(0x584), 0x555   => array(0x585)
  1119.                     ,0x556 => array(0x586), 0x587 => array(0x565, 0x582), 0xE33 => array(0xE4D, 0xE32)
  1120.                     ,0x1E00  => array(0x1E01), 0x1E02  => array(0x1E03), 0x1E04  => array(0x1E05)
  1121.                     ,0x1E06  => array(0x1E07), 0x1E08  => array(0x1E09), 0x1E0A  => array(0x1E0B)
  1122.                     ,0x1E0C  => array(0x1E0D), 0x1E0E  => array(0x1E0F), 0x1E10  => array(0x1E11)
  1123.                     ,0x1E12  => array(0x1E13), 0x1E14  => array(0x1E15), 0x1E16  => array(0x1E17)
  1124.                     ,0x1E18  => array(0x1E19), 0x1E1A  => array(0x1E1B), 0x1E1C  => array(0x1E1D)
  1125.                     ,0x1E1E  => array(0x1E1F), 0x1E20  => array(0x1E21), 0x1E22  => array(0x1E23)
  1126.                     ,0x1E24  => array(0x1E25), 0x1E26  => array(0x1E27), 0x1E28  => array(0x1E29)
  1127.                     ,0x1E2A  => array(0x1E2B), 0x1E2C  => array(0x1E2D), 0x1E2E  => array(0x1E2F)
  1128.                     ,0x1E30  => array(0x1E31), 0x1E32  => array(0x1E33), 0x1E34  => array(0x1E35)
  1129.                     ,0x1E36  => array(0x1E37), 0x1E38  => array(0x1E39), 0x1E3A  => array(0x1E3B)
  1130.                     ,0x1E3C  => array(0x1E3D), 0x1E3E  => array(0x1E3F), 0x1E40  => array(0x1E41)
  1131.                     ,0x1E42  => array(0x1E43), 0x1E44  => array(0x1E45), 0x1E46  => array(0x1E47)
  1132.                     ,0x1E48  => array(0x1E49), 0x1E4A  => array(0x1E4B), 0x1E4C  => array(0x1E4D)
  1133.                     ,0x1E4E  => array(0x1E4F), 0x1E50  => array(0x1E51), 0x1E52  => array(0x1E53)
  1134.                     ,0x1E54  => array(0x1E55), 0x1E56  => array(0x1E57), 0x1E58  => array(0x1E59)
  1135.                     ,0x1E5A  => array(0x1E5B), 0x1E5C  => array(0x1E5D), 0x1E5E  => array(0x1E5F)
  1136.                     ,0x1E60  => array(0x1E61), 0x1E62  => array(0x1E63), 0x1E64  => array(0x1E65)
  1137.                     ,0x1E66  => array(0x1E67), 0x1E68  => array(0x1E69), 0x1E6A  => array(0x1E6B)
  1138.                     ,0x1E6C  => array(0x1E6D), 0x1E6E  => array(0x1E6F), 0x1E70  => array(0x1E71)
  1139.                     ,0x1E72  => array(0x1E73), 0x1E74  => array(0x1E75), 0x1E76  => array(0x1E77)
  1140.                     ,0x1E78  => array(0x1E79), 0x1E7A  => array(0x1E7B), 0x1E7C  => array(0x1E7D)
  1141.                     ,0x1E7E  => array(0x1E7F), 0x1E80  => array(0x1E81), 0x1E82  => array(0x1E83)
  1142.                     ,0x1E84  => array(0x1E85), 0x1E86  => array(0x1E87), 0x1E88  => array(0x1E89)
  1143.                     ,0x1E8A  => array(0x1E8B), 0x1E8C  => array(0x1E8D), 0x1E8E  => array(0x1E8F)
  1144.                     ,0x1E90  => array(0x1E91), 0x1E92  => array(0x1E93), 0x1E94  => array(0x1E95)
  1145.                     ,0x1E96  => array(0x68, 0x331), 0x1E97  => array(0x74, 0x308), 0x1E98  => array(0x77, 0x30A)
  1146.                     ,0x1E99  => array(0x79, 0x30A), 0x1E9A  => array(0x61, 0x2BE), 0x1E9B  => array(0x1E61)
  1147.                     ,0x1EA0  => array(0x1EA1), 0x1EA2  => array(0x1EA3), 0x1EA4  => array(0x1EA5)
  1148.                     ,0x1EA6  => array(0x1EA7), 0x1EA8  => array(0x1EA9), 0x1EAA  => array(0x1EAB)
  1149.                     ,0x1EAC  => array(0x1EAD), 0x1EAE  => array(0x1EAF), 0x1EB0  => array(0x1EB1)
  1150.                     ,0x1EB2  => array(0x1EB3), 0x1EB4  => array(0x1EB5), 0x1EB6  => array(0x1EB7)
  1151.                     ,0x1EB8  => array(0x1EB9), 0x1EBA  => array(0x1EBB), 0x1EBC  => array(0x1EBD)
  1152.                     ,0x1EBE  => array(0x1EBF), 0x1EC0  => array(0x1EC1), 0x1EC2  => array(0x1EC3)
  1153.                     ,0x1EC4  => array(0x1EC5), 0x1EC6  => array(0x1EC7), 0x1EC8  => array(0x1EC9)
  1154.                     ,0x1ECA  => array(0x1ECB), 0x1ECC  => array(0x1ECD), 0x1ECE  => array(0x1ECF)
  1155.                     ,0x1ED0  => array(0x1ED1), 0x1ED2  => array(0x1ED3), 0x1ED4  => array(0x1ED5)
  1156.                     ,0x1ED6  => array(0x1ED7), 0x1ED8  => array(0x1ED9), 0x1EDA  => array(0x1EDB)
  1157.                     ,0x1EDC  => array(0x1EDD), 0x1EDE  => array(0x1EDF), 0x1EE0  => array(0x1EE1)
  1158.                     ,0x1EE2  => array(0x1EE3), 0x1EE4  => array(0x1EE5), 0x1EE6  => array(0x1EE7)
  1159.                     ,0x1EE8  => array(0x1EE9), 0x1EEA  => array(0x1EEB), 0x1EEC  => array(0x1EED)
  1160.                     ,0x1EEE  => array(0x1EEF), 0x1EF0  => array(0x1EF1), 0x1EF2  => array(0x1EF3)
  1161.                     ,0x1EF4  => array(0x1EF5), 0x1EF6  => array(0x1EF7), 0x1EF8  => array(0x1EF9)
  1162.                     ,0x1F08  => array(0x1F00), 0x1F09  => array(0x1F01), 0x1F0A  => array(0x1F02)
  1163.                     ,0x1F0B  => array(0x1F03), 0x1F0C  => array(0x1F04), 0x1F0D  => array(0x1F05)
  1164.                     ,0x1F0E  => array(0x1F06), 0x1F0F  => array(0x1F07), 0x1F18  => array(0x1F10)
  1165.                     ,0x1F19  => array(0x1F11), 0x1F1A  => array(0x1F12), 0x1F1B  => array(0x1F13)
  1166.                     ,0x1F1C  => array(0x1F14), 0x1F1D  => array(0x1F15), 0x1F28  => array(0x1F20)
  1167.                     ,0x1F29  => array(0x1F21), 0x1F2A  => array(0x1F22), 0x1F2B  => array(0x1F23)
  1168.                     ,0x1F2C  => array(0x1F24), 0x1F2D  => array(0x1F25), 0x1F2E  => array(0x1F26)
  1169.                     ,0x1F2F  => array(0x1F27), 0x1F38  => array(0x1F30), 0x1F39  => array(0x1F31)
  1170.                     ,0x1F3A  => array(0x1F32), 0x1F3B  => array(0x1F33), 0x1F3C  => array(0x1F34)
  1171.                     ,0x1F3D  => array(0x1F35), 0x1F3E  => array(0x1F36), 0x1F3F  => array(0x1F37)
  1172.                     ,0x1F48  => array(0x1F40), 0x1F49  => array(0x1F41), 0x1F4A  => array(0x1F42)
  1173.                     ,0x1F4B  => array(0x1F43), 0x1F4C  => array(0x1F44), 0x1F4D  => array(0x1F45)
  1174.                     ,0x1F50  => array(0x3C5, 0x313), 0x1F52  => array(0x3C5, 0x313, 0x300)
  1175.                     ,0x1F54  => array(0x3C5, 0x313, 0x301), 0x1F56  => array(0x3C5, 0x313, 0x342)
  1176.                     ,0x1F59  => array(0x1F51), 0x1F5B  => array(0x1F53), 0x1F5D  => array(0x1F55)
  1177.                     ,0x1F5F  => array(0x1F57), 0x1F68  => array(0x1F60), 0x1F69  => array(0x1F61)
  1178.                     ,0x1F6A  => array(0x1F62), 0x1F6B  => array(0x1F63), 0x1F6C  => array(0x1F64)
  1179.                     ,0x1F6D  => array(0x1F65), 0x1F6E  => array(0x1F66), 0x1F6F  => array(0x1F67)
  1180.                     ,0x1F80  => array(0x1F00, 0x3B9), 0x1F81  => array(0x1F01, 0x3B9)
  1181.                     ,0x1F82  => array(0x1F02, 0x3B9), 0x1F83  => array(0x1F03, 0x3B9)
  1182.                     ,0x1F84  => array(0x1F04, 0x3B9), 0x1F85  => array(0x1F05, 0x3B9)
  1183.                     ,0x1F86  => array(0x1F06, 0x3B9), 0x1F87  => array(0x1F07, 0x3B9)
  1184.                     ,0x1F88  => array(0x1F00, 0x3B9), 0x1F89  => array(0x1F01, 0x3B9)
  1185.                     ,0x1F8A  => array(0x1F02, 0x3B9), 0x1F8B  => array(0x1F03, 0x3B9)
  1186.                     ,0x1F8C  => array(0x1F04, 0x3B9), 0x1F8D  => array(0x1F05, 0x3B9)
  1187.                     ,0x1F8E  => array(0x1F06, 0x3B9), 0x1F8F  => array(0x1F07, 0x3B9)
  1188.                     ,0x1F90  => array(0x1F20, 0x3B9), 0x1F91  => array(0x1F21, 0x3B9)
  1189.                     ,0x1F92  => array(0x1F22, 0x3B9), 0x1F93  => array(0x1F23, 0x3B9)
  1190.                     ,0x1F94  => array(0x1F24, 0x3B9), 0x1F95  => array(0x1F25, 0x3B9)
  1191.                     ,0x1F96  => array(0x1F26, 0x3B9), 0x1F97  => array(0x1F27, 0x3B9)
  1192.                     ,0x1F98  => array(0x1F20, 0x3B9), 0x1F99  => array(0x1F21, 0x3B9)
  1193.                     ,0x1F9A  => array(0x1F22, 0x3B9), 0x1F9B  => array(0x1F23, 0x3B9)
  1194.                     ,0x1F9C  => array(0x1F24, 0x3B9), 0x1F9D  => array(0x1F25, 0x3B9)
  1195.                     ,0x1F9E  => array(0x1F26, 0x3B9), 0x1F9F  => array(0x1F27, 0x3B9)
  1196.                     ,0x1FA0  => array(0x1F60, 0x3B9), 0x1FA1  => array(0x1F61, 0x3B9)
  1197.                     ,0x1FA2  => array(0x1F62, 0x3B9), 0x1FA3  => array(0x1F63, 0x3B9)
  1198.                     ,0x1FA4  => array(0x1F64, 0x3B9), 0x1FA5  => array(0x1F65, 0x3B9)
  1199.                     ,0x1FA6  => array(0x1F66, 0x3B9), 0x1FA7  => array(0x1F67, 0x3B9)
  1200.                     ,0x1FA8  => array(0x1F60, 0x3B9), 0x1FA9  => array(0x1F61, 0x3B9)
  1201.                     ,0x1FAA  => array(0x1F62, 0x3B9), 0x1FAB  => array(0x1F63, 0x3B9)
  1202.                     ,0x1FAC  => array(0x1F64, 0x3B9), 0x1FAD  => array(0x1F65, 0x3B9)
  1203.                     ,0x1FAE  => array(0x1F66, 0x3B9), 0x1FAF  => array(0x1F67, 0x3B9)
  1204.                     ,0x1FB2  => array(0x1F70, 0x3B9), 0x1FB3  => array(0x3B1, 0x3B9)
  1205.                     ,0x1FB4  => array(0x3AC, 0x3B9), 0x1FB6  => array(0x3B1, 0x342)
  1206.                     ,0x1FB7  => array(0x3B1, 0x342, 0x3B9), 0x1FB8  => array(0x1FB0)
  1207.                     ,0x1FB9  => array(0x1FB1), 0x1FBA  => array(0x1F70), 0x1FBB  => array(0x1F71)
  1208.                     ,0x1FBC  => array(0x3B1, 0x3B9), 0x1FBE  => array(0x3B9)
  1209.                     ,0x1FC2  => array(0x1F74, 0x3B9), 0x1FC3  => array(0x3B7, 0x3B9)
  1210.                     ,0x1FC4  => array(0x3AE, 0x3B9), 0x1FC6  => array(0x3B7, 0x342)
  1211.                     ,0x1FC7  => array(0x3B7, 0x342, 0x3B9), 0x1FC8  => array(0x1F72)
  1212.                     ,0x1FC9  => array(0x1F73), 0x1FCA  => array(0x1F74), 0x1FCB  => array(0x1F75)
  1213.                     ,0x1FCC  => array(0x3B7, 0x3B9), 0x1FD2  => array(0x3B9, 0x308, 0x300)
  1214.                     ,0x1FD3  => array(0x3B9, 0x308, 0x301), 0x1FD6  => array(0x3B9, 0x342)
  1215.                     ,0x1FD7  => array(0x3B9, 0x308, 0x342), 0x1FD8  => array(0x1FD0)
  1216.                     ,0x1FD9  => array(0x1FD1), 0x1FDA  => array(0x1F76)
  1217.                     ,0x1FDB  => array(0x1F77), 0x1FE2  => array(0x3C5, 0x308, 0x300)
  1218.                     ,0x1FE3  => array(0x3C5, 0x308, 0x301), 0x1FE4  => array(0x3C1, 0x313)
  1219.                     ,0x1FE6  => array(0x3C5, 0x342), 0x1FE7  => array(0x3C5, 0x308, 0x342)
  1220.                     ,0x1FE8  => array(0x1FE0), 0x1FE9  => array(0x1FE1)
  1221.                     ,0x1FEA  => array(0x1F7A), 0x1FEB  => array(0x1F7B)
  1222.                     ,0x1FEC  => array(0x1FE5), 0x1FF2  => array(0x1F7C, 0x3B9)
  1223.                     ,0x1FF3  => array(0x3C9, 0x3B9), 0x1FF4  => array(0x3CE, 0x3B9)
  1224.                     ,0x1FF6  => array(0x3C9, 0x342), 0x1FF7  => array(0x3C9, 0x342, 0x3B9)
  1225.                     ,0x1FF8  => array(0x1F78), 0x1FF9  => array(0x1F79), 0x1FFA  => array(0x1F7C)
  1226.                     ,0x1FFB  => array(0x1F7D), 0x1FFC  => array(0x3C9, 0x3B9)
  1227.                     ,0x20A8  => array(0x72, 0x73), 0x2102  => array(0x63), 0x2103  => array(0xB0, 0x63)
  1228.                     ,0x2107  => array(0x25B), 0x2109  => array(0xB0, 0x66), 0x210B  => array(0x68)
  1229.                     ,0x210C  => array(0x68), 0x210D  => array(0x68), 0x2110  => array(0x69)
  1230.                     ,0x2111  => array(0x69), 0x2112  => array(0x6C), 0x2115  => array(0x6E)
  1231.                     ,0x2116  => array(0x6E, 0x6F), 0x2119  => array(0x70), 0x211A  => array(0x71)
  1232.                     ,0x211B  => array(0x72), 0x211C  => array(0x72), 0x211D  => array(0x72)
  1233.                     ,0x2120  => array(0x73, 0x6D), 0x2121  => array(0x74, 0x65, 0x6C)
  1234.                     ,0x2122  => array(0x74, 0x6D), 0x2124  => array(0x7A), 0x2126  => array(0x3C9)
  1235.                     ,0x2128  => array(0x7A), 0x212A  => array(0x6B), 0x212B  => array(0xE5)
  1236.                     ,0x212C  => array(0x62), 0x212D  => array(0x63), 0x2130  => array(0x65)
  1237.                     ,0x2131  => array(0x66), 0x2133  => array(0x6D), 0x213E  => array(0x3B3)
  1238.                     ,0x213F  => array(0x3C0), 0x2145  => array(0x64) ,0x2160  => array(0x2170)
  1239.                     ,0x2161  => array(0x2171), 0x2162  => array(0x2172), 0x2163  => array(0x2173)
  1240.                     ,0x2164  => array(0x2174), 0x2165  => array(0x2175), 0x2166  => array(0x2176)
  1241.                     ,0x2167  => array(0x2177), 0x2168  => array(0x2178), 0x2169  => array(0x2179)
  1242.                     ,0x216A  => array(0x217A), 0x216B  => array(0x217B), 0x216C  => array(0x217C)
  1243.                     ,0x216D  => array(0x217D), 0x216E  => array(0x217E), 0x216F  => array(0x217F)
  1244.                     ,0x24B6  => array(0x24D0), 0x24B7  => array(0x24D1), 0x24B8  => array(0x24D2)
  1245.                     ,0x24B9  => array(0x24D3), 0x24BA  => array(0x24D4), 0x24BB  => array(0x24D5)
  1246.                     ,0x24BC  => array(0x24D6), 0x24BD  => array(0x24D7), 0x24BE  => array(0x24D8)
  1247.                     ,0x24BF  => array(0x24D9), 0x24C0  => array(0x24DA), 0x24C1  => array(0x24DB)
  1248.                     ,0x24C2  => array(0x24DC), 0x24C3  => array(0x24DD), 0x24C4  => array(0x24DE)
  1249.                     ,0x24C5  => array(0x24DF), 0x24C6  => array(0x24E0), 0x24C7  => array(0x24E1)
  1250.                     ,0x24C8  => array(0x24E2), 0x24C9  => array(0x24E3), 0x24CA  => array(0x24E4)
  1251.                     ,0x24CB  => array(0x24E5), 0x24CC  => array(0x24E6), 0x24CD  => array(0x24E7)
  1252.                     ,0x24CE  => array(0x24E8), 0x24CF  => array(0x24E9), 0x3371  => array(0x68, 0x70, 0x61)
  1253.                     ,0x3373  => array(0x61, 0x75), 0x3375  => array(0x6F, 0x76)
  1254.                     ,0x3380  => array(0x70, 0x61), 0x3381  => array(0x6E, 0x61)
  1255.                     ,0x3382  => array(0x3BC, 0x61), 0x3383  => array(0x6D, 0x61)
  1256.                     ,0x3384  => array(0x6B, 0x61), 0x3385  => array(0x6B, 0x62)
  1257.                     ,0x3386  => array(0x6D, 0x62), 0x3387  => array(0x67, 0x62)
  1258.                     ,0x338A  => array(0x70, 0x66), 0x338B  => array(0x6E, 0x66)
  1259.                     ,0x338C  => array(0x3BC, 0x66), 0x3390  => array(0x68, 0x7A)
  1260.                     ,0x3391  => array(0x6B, 0x68, 0x7A), 0x3392  => array(0x6D, 0x68, 0x7A)
  1261.                     ,0x3393  => array(0x67, 0x68, 0x7A), 0x3394  => array(0x74, 0x68, 0x7A)
  1262.                     ,0x33A9  => array(0x70, 0x61), 0x33AA  => array(0x6B, 0x70, 0x61)
  1263.                     ,0x33AB  => array(0x6D, 0x70, 0x61), 0x33AC  => array(0x67, 0x70, 0x61)
  1264.                     ,0x33B4  => array(0x70, 0x76), 0x33B5  => array(0x6E, 0x76)
  1265.                     ,0x33B6  => array(0x3BC, 0x76), 0x33B7  => array(0x6D, 0x76)
  1266.                     ,0x33B8  => array(0x6B, 0x76), 0x33B9  => array(0x6D, 0x76)
  1267.                     ,0x33BA  => array(0x70, 0x77), 0x33BB  => array(0x6E, 0x77)
  1268.                     ,0x33BC  => array(0x3BC, 0x77), 0x33BD  => array(0x6D, 0x77)
  1269.                     ,0x33BE  => array(0x6B, 0x77), 0x33BF  => array(0x6D, 0x77)
  1270.                     ,0x33C0  => array(0x6B, 0x3C9), 0x33C1  => array(0x6D, 0x3C9) /*
  1271.                     ,0x33C2  => array(0x61, 0x2E, 0x6D, 0x2E) */
  1272.                     ,0x33C3  => array(0x62, 0x71), 0x33C6  => array(0x63, 0x2215, 0x6B, 0x67)
  1273.                     ,0x33C7  => array(0x63, 0x6F, 0x2E), 0x33C8  => array(0x64, 0x62)
  1274.                     ,0x33C9  => array(0x67, 0x79), 0x33CB  => array(0x68, 0x70)
  1275.                     ,0x33CD  => array(0x6B, 0x6B), 0x33CE  => array(0x6B, 0x6D)
  1276.                     ,0x33D7  => array(0x70, 0x68), 0x33D9  => array(0x70, 0x70, 0x6D)
  1277.                     ,0x33DA  => array(0x70, 0x72), 0x33DC  => array(0x73, 0x76)
  1278.                     ,0x33DD  => array(0x77, 0x62), 0xFB00  => array(0x66, 0x66)
  1279.                     ,0xFB01  => array(0x66, 0x69), 0xFB02  => array(0x66, 0x6C)
  1280.                     ,0xFB03  => array(0x66, 0x66, 0x69), 0xFB04  => array(0x66, 0x66, 0x6C)
  1281.                     ,0xFB05  => array(0x73, 0x74), 0xFB06  => array(0x73, 0x74)
  1282.                     ,0xFB13  => array(0x574, 0x576), 0xFB14  => array(0x574, 0x565)
  1283.                     ,0xFB15  => array(0x574, 0x56B), 0xFB16  => array(0x57E, 0x576)
  1284.                     ,0xFB17  => array(0x574, 0x56D), 0xFF21  => array(0xFF41)
  1285.                     ,0xFF22  => array(0xFF42), 0xFF23  => array(0xFF43), 0xFF24  => array(0xFF44)
  1286.                     ,0xFF25  => array(0xFF45), 0xFF26  => array(0xFF46), 0xFF27  => array(0xFF47)
  1287.                     ,0xFF28  => array(0xFF48), 0xFF29  => array(0xFF49), 0xFF2A  => array(0xFF4A)
  1288.                     ,0xFF2B  => array(0xFF4B), 0xFF2C  => array(0xFF4C), 0xFF2D  => array(0xFF4D)
  1289.                     ,0xFF2E  => array(0xFF4E), 0xFF2F  => array(0xFF4F), 0xFF30  => array(0xFF50)
  1290.                     ,0xFF31  => array(0xFF51), 0xFF32  => array(0xFF52), 0xFF33  => array(0xFF53)
  1291.                     ,0xFF34  => array(0xFF54), 0xFF35  => array(0xFF55), 0xFF36  => array(0xFF56)
  1292.                     ,0xFF37  => array(0xFF57), 0xFF38  => array(0xFF58), 0xFF39  => array(0xFF59)
  1293.                     ,0xFF3A  => array(0xFF5A), 0x10400 => array(0x10428), 0x10401 => array(0x10429)
  1294.                     ,0x10402 => array(0x1042A), 0x10403 => array(0x1042B), 0x10404 => array(0x1042C)
  1295.                     ,0x10405 => array(0x1042D), 0x10406 => array(0x1042E), 0x10407 => array(0x1042F)
  1296.                     ,0x10408 => array(0x10430), 0x10409 => array(0x10431), 0x1040A => array(0x10432)
  1297.                     ,0x1040B => array(0x10433), 0x1040C => array(0x10434), 0x1040D => array(0x10435)
  1298.                     ,0x1040E => array(0x10436), 0x1040F => array(0x10437), 0x10410 => array(0x10438)
  1299.                     ,0x10411 => array(0x10439), 0x10412 => array(0x1043A), 0x10413 => array(0x1043B)
  1300.                     ,0x10414 => array(0x1043C), 0x10415 => array(0x1043D), 0x10416 => array(0x1043E)
  1301.                     ,0x10417 => array(0x1043F), 0x10418 => array(0x10440), 0x10419 => array(0x10441)
  1302.                     ,0x1041A => array(0x10442), 0x1041B => array(0x10443), 0x1041C => array(0x10444)
  1303.                     ,0x1041D => array(0x10445), 0x1041E => array(0x10446), 0x1041F => array(0x10447)
  1304.                     ,0x10420 => array(0x10448), 0x10421 => array(0x10449), 0x10422 => array(0x1044A)
  1305.                     ,0x10423 => array(0x1044B), 0x10424 => array(0x1044C), 0x10425 => array(0x1044D)
  1306.                     ,0x1D400 => array(0x61), 0x1D401 => array(0x62), 0x1D402 => array(0x63)
  1307.                     ,0x1D403 => array(0x64), 0x1D404 => array(0x65), 0x1D405 => array(0x66)
  1308.                     ,0x1D406 => array(0x67), 0x1D407 => array(0x68), 0x1D408 => array(0x69)
  1309.                     ,0x1D409 => array(0x6A), 0x1D40A => array(0x6B), 0x1D40B => array(0x6C)
  1310.                     ,0x1D40C => array(0x6D), 0x1D40D => array(0x6E), 0x1D40E => array(0x6F)
  1311.                     ,0x1D40F => array(0x70), 0x1D410 => array(0x71), 0x1D411 => array(0x72)
  1312.                     ,0x1D412 => array(0x73), 0x1D413 => array(0x74), 0x1D414 => array(0x75)
  1313.                     ,0x1D415 => array(0x76), 0x1D416 => array(0x77), 0x1D417 => array(0x78)
  1314.                     ,0x1D418 => array(0x79), 0x1D419 => array(0x7A), 0x1D434 => array(0x61)
  1315.                     ,0x1D435 => array(0x62), 0x1D436 => array(0x63), 0x1D437 => array(0x64)
  1316.                     ,0x1D438 => array(0x65), 0x1D439 => array(0x66), 0x1D43A => array(0x67)
  1317.                     ,0x1D43B => array(0x68), 0x1D43C => array(0x69), 0x1D43D => array(0x6A)
  1318.                     ,0x1D43E => array(0x6B), 0x1D43F => array(0x6C), 0x1D440 => array(0x6D)
  1319.                     ,0x1D441 => array(0x6E), 0x1D442 => array(0x6F), 0x1D443 => array(0x70)
  1320.                     ,0x1D444 => array(0x71), 0x1D445 => array(0x72), 0x1D446 => array(0x73)
  1321.                     ,0x1D447 => array(0x74), 0x1D448 => array(0x75), 0x1D449 => array(0x76)
  1322.                     ,0x1D44A => array(0x77), 0x1D44B => array(0x78), 0x1D44C => array(0x79)
  1323.                     ,0x1D44D => array(0x7A), 0x1D468 => array(0x61), 0x1D469 => array(0x62)
  1324.                     ,0x1D46A => array(0x63), 0x1D46B => array(0x64), 0x1D46C => array(0x65)
  1325.                     ,0x1D46D => array(0x66), 0x1D46E => array(0x67), 0x1D46F => array(0x68)
  1326.                     ,0x1D470 => array(0x69), 0x1D471 => array(0x6A), 0x1D472 => array(0x6B)
  1327.                     ,0x1D473 => array(0x6C), 0x1D474 => array(0x6D), 0x1D475 => array(0x6E)
  1328.                     ,0x1D476 => array(0x6F), 0x1D477 => array(0x70), 0x1D478 => array(0x71)
  1329.                     ,0x1D479 => array(0x72), 0x1D47A => array(0x73), 0x1D47B => array(0x74)
  1330.                     ,0x1D47C => array(0x75), 0x1D47D => array(0x76), 0x1D47E => array(0x77)
  1331.                     ,0x1D47F => array(0x78), 0x1D480 => array(0x79), 0x1D481 => array(0x7A)
  1332.                     ,0x1D49C => array(0x61), 0x1D49E => array(0x63), 0x1D49F => array(0x64)
  1333.                     ,0x1D4A2 => array(0x67), 0x1D4A5 => array(0x6A), 0x1D4A6 => array(0x6B)
  1334.                     ,0x1D4A9 => array(0x6E), 0x1D4AA => array(0x6F), 0x1D4AB => array(0x70)
  1335.                     ,0x1D4AC => array(0x71), 0x1D4AE => array(0x73), 0x1D4AF => array(0x74)
  1336.                     ,0x1D4B0 => array(0x75), 0x1D4B1 => array(0x76), 0x1D4B2 => array(0x77)
  1337.                     ,0x1D4B3 => array(0x78), 0x1D4B4 => array(0x79), 0x1D4B5 => array(0x7A)
  1338.                     ,0x1D4D0 => array(0x61), 0x1D4D1 => array(0x62), 0x1D4D2 => array(0x63)
  1339.                     ,0x1D4D3 => array(0x64), 0x1D4D4 => array(0x65), 0x1D4D5 => array(0x66)
  1340.                     ,0x1D4D6 => array(0x67), 0x1D4D7 => array(0x68), 0x1D4D8 => array(0x69)
  1341.                     ,0x1D4D9 => array(0x6A), 0x1D4DA => array(0x6B), 0x1D4DB => array(0x6C)
  1342.                     ,0x1D4DC => array(0x6D), 0x1D4DD => array(0x6E), 0x1D4DE => array(0x6F)
  1343.                     ,0x1D4DF => array(0x70), 0x1D4E0 => array(0x71), 0x1D4E1 => array(0x72)
  1344.                     ,0x1D4E2 => array(0x73), 0x1D4E3 => array(0x74), 0x1D4E4 => array(0x75)
  1345.                     ,0x1D4E5 => array(0x76), 0x1D4E6 => array(0x77), 0x1D4E7 => array(0x78)
  1346.                     ,0x1D4E8 => array(0x79), 0x1D4E9 => array(0x7A), 0x1D504 => array(0x61)
  1347.                     ,0x1D505 => array(0x62), 0x1D507 => array(0x64), 0x1D508 => array(0x65)
  1348.                     ,0x1D509 => array(0x66), 0x1D50A => array(0x67), 0x1D50D => array(0x6A)
  1349.                     ,0x1D50E => array(0x6B), 0x1D50F => array(0x6C), 0x1D510 => array(0x6D)
  1350.                     ,0x1D511 => array(0x6E), 0x1D512 => array(0x6F), 0x1D513 => array(0x70)
  1351.                     ,0x1D514 => array(0x71), 0x1D516 => array(0x73), 0x1D517 => array(0x74)
  1352.                     ,0x1D518 => array(0x75), 0x1D519 => array(0x76), 0x1D51A => array(0x77)
  1353.                     ,0x1D51B => array(0x78), 0x1D51C => array(0x79), 0x1D538 => array(0x61)
  1354.                     ,0x1D539 => array(0x62), 0x1D53B => array(0x64), 0x1D53C => array(0x65)
  1355.                     ,0x1D53D => array(0x66), 0x1D53E => array(0x67), 0x1D540 => array(0x69)
  1356.                     ,0x1D541 => array(0x6A), 0x1D542 => array(0x6B), 0x1D543 => array(0x6C)
  1357.                     ,0x1D544 => array(0x6D), 0x1D546 => array(0x6F), 0x1D54A => array(0x73)
  1358.                     ,0x1D54B => array(0x74), 0x1D54C => array(0x75), 0x1D54D => array(0x76)
  1359.                     ,0x1D54E => array(0x77), 0x1D54F => array(0x78), 0x1D550 => array(0x79)
  1360.                     ,0x1D56C => array(0x61), 0x1D56D => array(0x62), 0x1D56E => array(0x63)
  1361.                     ,0x1D56F => array(0x64), 0x1D570 => array(0x65), 0x1D571 => array(0x66)
  1362.                     ,0x1D572 => array(0x67), 0x1D573 => array(0x68), 0x1D574 => array(0x69)
  1363.                     ,0x1D575 => array(0x6A), 0x1D576 => array(0x6B), 0x1D577 => array(0x6C)
  1364.                     ,0x1D578 => array(0x6D), 0x1D579 => array(0x6E), 0x1D57A => array(0x6F)
  1365.                     ,0x1D57B => array(0x70), 0x1D57C => array(0x71), 0x1D57D => array(0x72)
  1366.                     ,0x1D57E => array(0x73), 0x1D57F => array(0x74), 0x1D580 => array(0x75)
  1367.                     ,0x1D581 => array(0x76), 0x1D582 => array(0x77), 0x1D583 => array(0x78)
  1368.                     ,0x1D584 => array(0x79), 0x1D585 => array(0x7A), 0x1D5A0 => array(0x61)
  1369.                     ,0x1D5A1 => array(0x62), 0x1D5A2 => array(0x63), 0x1D5A3 => array(0x64)
  1370.                     ,0x1D5A4 => array(0x65), 0x1D5A5 => array(0x66), 0x1D5A6 => array(0x67)
  1371.                     ,0x1D5A7 => array(0x68), 0x1D5A8 => array(0x69), 0x1D5A9 => array(0x6A)
  1372.                     ,0x1D5AA => array(0x6B), 0x1D5AB => array(0x6C), 0x1D5AC => array(0x6D)
  1373.                     ,0x1D5AD => array(0x6E), 0x1D5AE => array(0x6F), 0x1D5AF => array(0x70)
  1374.                     ,0x1D5B0 => array(0x71), 0x1D5B1 => array(0x72), 0x1D5B2 => array(0x73)
  1375.                     ,0x1D5B3 => array(0x74), 0x1D5B4 => array(0x75), 0x1D5B5 => array(0x76)
  1376.                     ,0x1D5B6 => array(0x77), 0x1D5B7 => array(0x78), 0x1D5B8 => array(0x79)
  1377.                     ,0x1D5B9 => array(0x7A), 0x1D5D4 => array(0x61), 0x1D5D5 => array(0x62)
  1378.                     ,0x1D5D6 => array(0x63), 0x1D5D7 => array(0x64), 0x1D5D8 => array(0x65)
  1379.                     ,0x1D5D9 => array(0x66), 0x1D5DA => array(0x67), 0x1D5DB => array(0x68)
  1380.                     ,0x1D5DC => array(0x69), 0x1D5DD => array(0x6A), 0x1D5DE => array(0x6B)
  1381.                     ,0x1D5DF => array(0x6C), 0x1D5E0 => array(0x6D), 0x1D5E1 => array(0x6E)
  1382.                     ,0x1D5E2 => array(0x6F), 0x1D5E3 => array(0x70), 0x1D5E4 => array(0x71)
  1383.                     ,0x1D5E5 => array(0x72), 0x1D5E6 => array(0x73), 0x1D5E7 => array(0x74)
  1384.                     ,0x1D5E8 => array(0x75), 0x1D5E9 => array(0x76), 0x1D5EA => array(0x77)
  1385.                     ,0x1D5EB => array(0x78), 0x1D5EC => array(0x79), 0x1D5ED => array(0x7A)
  1386.                     ,0x1D608 => array(0x61), 0x1D609 => array(0x62) ,0x1D60A => array(0x63)
  1387.                     ,0x1D60B => array(0x64), 0x1D60C => array(0x65), 0x1D60D => array(0x66)
  1388.                     ,0x1D60E => array(0x67), 0x1D60F => array(0x68), 0x1D610 => array(0x69)
  1389.                     ,0x1D611 => array(0x6A), 0x1D612 => array(0x6B), 0x1D613 => array(0x6C)
  1390.                     ,0x1D614 => array(0x6D), 0x1D615 => array(0x6E), 0x1D616 => array(0x6F)
  1391.                     ,0x1D617 => array(0x70), 0x1D618 => array(0x71), 0x1D619 => array(0x72)
  1392.                     ,0x1D61A => array(0x73), 0x1D61B => array(0x74), 0x1D61C => array(0x75)
  1393.                     ,0x1D61D => array(0x76), 0x1D61E => array(0x77), 0x1D61F => array(0x78)
  1394.                     ,0x1D620 => array(0x79), 0x1D621 => array(0x7A), 0x1D63C => array(0x61)
  1395.                     ,0x1D63D => array(0x62), 0x1D63E => array(0x63), 0x1D63F => array(0x64)
  1396.                     ,0x1D640 => array(0x65), 0x1D641 => array(0x66), 0x1D642 => array(0x67)
  1397.                     ,0x1D643 => array(0x68), 0x1D644 => array(0x69), 0x1D645 => array(0x6A)
  1398.                     ,0x1D646 => array(0x6B), 0x1D647 => array(0x6C), 0x1D648 => array(0x6D)
  1399.                     ,0x1D649 => array(0x6E), 0x1D64A => array(0x6F), 0x1D64B => array(0x70)
  1400.                     ,0x1D64C => array(0x71), 0x1D64D => array(0x72), 0x1D64E => array(0x73)
  1401.                     ,0x1D64F => array(0x74), 0x1D650 => array(0x75), 0x1D651 => array(0x76)
  1402.                     ,0x1D652 => array(0x77), 0x1D653 => array(0x78), 0x1D654 => array(0x79)
  1403.                     ,0x1D655 => array(0x7A), 0x1D670 => array(0x61), 0x1D671 => array(0x62)
  1404.                     ,0x1D672 => array(0x63), 0x1D673 => array(0x64), 0x1D674 => array(0x65)
  1405.                     ,0x1D675 => array(0x66), 0x1D676 => array(0x67), 0x1D677 => array(0x68)
  1406.                     ,0x1D678 => array(0x69), 0x1D679 => array(0x6A), 0x1D67A => array(0x6B)
  1407.                     ,0x1D67B => array(0x6C), 0x1D67C => array(0x6D), 0x1D67D => array(0x6E)
  1408.                     ,0x1D67E => array(0x6F), 0x1D67F => array(0x70), 0x1D680 => array(0x71)
  1409.                     ,0x1D681 => array(0x72), 0x1D682 => array(0x73), 0x1D683 => array(0x74)
  1410.                     ,0x1D684 => array(0x75), 0x1D685 => array(0x76), 0x1D686 => array(0x77)
  1411.                     ,0x1D687 => array(0x78), 0x1D688 => array(0x79), 0x1D689 => array(0x7A)
  1412.                     ,0x1D6A8 => array(0x3B1), 0x1D6A9 => array(0x3B2), 0x1D6AA => array(0x3B3)
  1413.                     ,0x1D6AB => array(0x3B4), 0x1D6AC => array(0x3B5), 0x1D6AD => array(0x3B6)
  1414.                     ,0x1D6AE => array(0x3B7), 0x1D6AF => array(0x3B8), 0x1D6B0 => array(0x3B9)
  1415.                     ,0x1D6B1 => array(0x3BA), 0x1D6B2 => array(0x3BB), 0x1D6B3 => array(0x3BC)
  1416.                     ,0x1D6B4 => array(0x3BD), 0x1D6B5 => array(0x3BE), 0x1D6B6 => array(0x3BF)
  1417.                     ,0x1D6B7 => array(0x3C0), 0x1D6B8 => array(0x3C1), 0x1D6B9 => array(0x3B8)
  1418.                     ,0x1D6BA => array(0x3C3), 0x1D6BB => array(0x3C4), 0x1D6BC => array(0x3C5)
  1419.                     ,0x1D6BD => array(0x3C6), 0x1D6BE => array(0x3C7), 0x1D6BF => array(0x3C8)
  1420.                     ,0x1D6C0 => array(0x3C9), 0x1D6D3 => array(0x3C3), 0x1D6E2 => array(0x3B1)
  1421.                     ,0x1D6E3 => array(0x3B2), 0x1D6E4 => array(0x3B3), 0x1D6E5 => array(0x3B4)
  1422.                     ,0x1D6E6 => array(0x3B5), 0x1D6E7 => array(0x3B6), 0x1D6E8 => array(0x3B7)
  1423.                     ,0x1D6E9 => array(0x3B8), 0x1D6EA => array(0x3B9), 0x1D6EB => array(0x3BA)
  1424.                     ,0x1D6EC => array(0x3BB), 0x1D6ED => array(0x3BC), 0x1D6EE => array(0x3BD)
  1425.                     ,0x1D6EF => array(0x3BE), 0x1D6F0 => array(0x3BF), 0x1D6F1 => array(0x3C0)
  1426.                     ,0x1D6F2 => array(0x3C1), 0x1D6F3 => array(0x3B8) ,0x1D6F4 => array(0x3C3)
  1427.                     ,0x1D6F5 => array(0x3C4), 0x1D6F6 => array(0x3C5), 0x1D6F7 => array(0x3C6)
  1428.                     ,0x1D6F8 => array(0x3C7), 0x1D6F9 => array(0x3C8) ,0x1D6FA => array(0x3C9)
  1429.                     ,0x1D70D => array(0x3C3), 0x1D71C => array(0x3B1), 0x1D71D => array(0x3B2)
  1430.                     ,0x1D71E => array(0x3B3), 0x1D71F => array(0x3B4), 0x1D720 => array(0x3B5)
  1431.                     ,0x1D721 => array(0x3B6), 0x1D722 => array(0x3B7), 0x1D723 => array(0x3B8)
  1432.                     ,0x1D724 => array(0x3B9), 0x1D725 => array(0x3BA), 0x1D726 => array(0x3BB)
  1433.                     ,0x1D727 => array(0x3BC), 0x1D728 => array(0x3BD), 0x1D729 => array(0x3BE)
  1434.                     ,0x1D72A => array(0x3BF), 0x1D72B => array(0x3C0), 0x1D72C => array(0x3C1)
  1435.                     ,0x1D72D => array(0x3B8), 0x1D72E => array(0x3C3), 0x1D72F => array(0x3C4)
  1436.                     ,0x1D730 => array(0x3C5), 0x1D731 => array(0x3C6), 0x1D732 => array(0x3C7)
  1437.                     ,0x1D733 => array(0x3C8), 0x1D734 => array(0x3C9), 0x1D747 => array(0x3C3)
  1438.                     ,0x1D756 => array(0x3B1), 0x1D757 => array(0x3B2), 0x1D758 => array(0x3B3)
  1439.                     ,0x1D759 => array(0x3B4), 0x1D75A => array(0x3B5), 0x1D75B => array(0x3B6)
  1440.                     ,0x1D75C => array(0x3B7), 0x1D75D => array(0x3B8), 0x1D75E => array(0x3B9)
  1441.                     ,0x1D75F => array(0x3BA), 0x1D760 => array(0x3BB), 0x1D761 => array(0x3BC)
  1442.                     ,0x1D762 => array(0x3BD), 0x1D763 => array(0x3BE), 0x1D764 => array(0x3BF)
  1443.                     ,0x1D765 => array(0x3C0), 0x1D766 => array(0x3C1), 0x1D767 => array(0x3B8)
  1444.                     ,0x1D768 => array(0x3C3), 0x1D769 => array(0x3C4), 0x1D76A => array(0x3C5)
  1445.                     ,0x1D76B => array(0x3C6), 0x1D76C => array(0x3C7), 0x1D76D => array(0x3C8)
  1446.                     ,0x1D76E => array(0x3C9), 0x1D781 => array(0x3C3), 0x1D790 => array(0x3B1)
  1447.                     ,0x1D791 => array(0x3B2), 0x1D792 => array(0x3B3), 0x1D793 => array(0x3B4)
  1448.                     ,0x1D794 => array(0x3B5), 0x1D795 => array(0x3B6), 0x1D796 => array(0x3B7)
  1449.                     ,0x1D797 => array(0x3B8), 0x1D798 => array(0x3B9), 0x1D799 => array(0x3BA)
  1450.                     ,0x1D79A => array(0x3BB), 0x1D79B => array(0x3BC), 0x1D79C => array(0x3BD)
  1451.                     ,0x1D79D => array(0x3BE), 0x1D79E => array(0x3BF), 0x1D79F => array(0x3C0)
  1452.                     ,0x1D7A0 => array(0x3C1), 0x1D7A1 => array(0x3B8), 0x1D7A2 => array(0x3C3)
  1453.                     ,0x1D7A3 => array(0x3C4), 0x1D7A4 => array(0x3C5), 0x1D7A5 => array(0x3C6)
  1454.                     ,0x1D7A6 => array(0x3C7), 0x1D7A7 => array(0x3C8), 0x1D7A8 => array(0x3C9)
  1455.                     ,0x1D7BB => array(0x3C3), 0x3F9   => array(0x3C3), 0x1D2C  => array(0x61)
  1456.                     ,0x1D2D  => array(0xE6), 0x1D2E  => array(0x62), 0x1D30  => array(0x64)
  1457.                     ,0x1D31  => array(0x65), 0x1D32  => array(0x1DD), 0x1D33  => array(0x67)
  1458.                     ,0x1D34  => array(0x68), 0x1D35  => array(0x69), 0x1D36  => array(0x6A)
  1459.                     ,0x1D37  => array(0x6B), 0x1D38  => array(0x6C), 0x1D39  => array(0x6D)
  1460.                     ,0x1D3A  => array(0x6E), 0x1D3C  => array(0x6F), 0x1D3D  => array(0x223)
  1461.                     ,0x1D3E  => array(0x70), 0x1D3F  => array(0x72), 0x1D40  => array(0x74)
  1462.                     ,0x1D41  => array(0x75), 0x1D42  => array(0x77), 0x213B  => array(0x66, 0x61, 0x78)
  1463.                     ,0x3250  => array(0x70, 0x74, 0x65), 0x32CC  => array(0x68, 0x67)
  1464.                     ,0x32CE  => array(0x65, 0x76), 0x32CF  => array(0x6C, 0x74, 0x64)
  1465.                     ,0x337A  => array(0x69, 0x75), 0x33DE  => array(0x76, 0x2215, 0x6D)
  1466.                     ,0x33DF  => array(0x61, 0x2215, 0x6D)
  1467.                     )
  1468.             ,'norm_combcls' => array(0x334   => 1,   0x335   => 1,   0x336   => 1,   0x337   => 1
  1469.                     ,0x338   => 1,   0x93C   => 7,   0x9BC   => 7,   0xA3C   => 7,   0xABC   => 7
  1470.                     ,0xB3C   => 7,   0xCBC   => 7,   0x1037  => 7,   0x3099  => 8,   0x309A  => 8
  1471.                     ,0x94D   => 9,   0x9CD   => 9,   0xA4D   => 9,   0xACD   => 9,   0xB4D   => 9
  1472.                     ,0xBCD   => 9,   0xC4D   => 9,   0xCCD   => 9,   0xD4D   => 9,   0xDCA   => 9
  1473.                     ,0xE3A   => 9,   0xF84   => 9,   0x1039  => 9,   0x1714  => 9,   0x1734  => 9
  1474.                     ,0x17D2  => 9,   0x5B0   => 10,  0x5B1   => 11,  0x5B2   => 12,  0x5B3   => 13
  1475.                     ,0x5B4   => 14,  0x5B5   => 15,  0x5B6   => 16,  0x5B7   => 17,  0x5B8   => 18
  1476.                     ,0x5B9   => 19,  0x5BB   => 20,  0x5Bc   => 21,  0x5BD   => 22,  0x5BF   => 23
  1477.                     ,0x5C1   => 24,  0x5C2   => 25,  0xFB1E  => 26,  0x64B   => 27,  0x64C   => 28
  1478.                     ,0x64D   => 29,  0x64E   => 30,  0x64F   => 31,  0x650   => 32,  0x651   => 33
  1479.                     ,0x652   => 34,  0x670   => 35,  0x711   => 36,  0xC55   => 84,  0xC56   => 91
  1480.                     ,0xE38   => 103, 0xE39   => 103, 0xE48   => 107, 0xE49   => 107, 0xE4A   => 107
  1481.                     ,0xE4B   => 107, 0xEB8   => 118, 0xEB9   => 118, 0xEC8   => 122, 0xEC9   => 122
  1482.                     ,0xECA   => 122, 0xECB   => 122, 0xF71   => 129, 0xF72   => 130, 0xF7A   => 130
  1483.                     ,0xF7B   => 130, 0xF7C   => 130, 0xF7D   => 130, 0xF80   => 130, 0xF74   => 132
  1484.                     ,0x321   => 202, 0x322   => 202, 0x327   => 202, 0x328   => 202, 0x31B   => 216
  1485.                     ,0xF39   => 216, 0x1D165 => 216, 0x1D166 => 216, 0x1D16E => 216, 0x1D16F => 216
  1486.                     ,0x1D170 => 216, 0x1D171 => 216, 0x1D172 => 216, 0x302A  => 218, 0x316   => 220
  1487.                     ,0x317   => 220, 0x318   => 220, 0x319   => 220, 0x31C   => 220, 0x31D   => 220
  1488.                     ,0x31E   => 220, 0x31F   => 220, 0x320   => 220, 0x323   => 220, 0x324   => 220
  1489.                     ,0x325   => 220, 0x326   => 220, 0x329   => 220, 0x32A   => 220, 0x32B   => 220
  1490.                     ,0x32C   => 220, 0x32D   => 220, 0x32E   => 220, 0x32F   => 220, 0x330   => 220
  1491.                     ,0x331   => 220, 0x332   => 220, 0x333   => 220, 0x339   => 220, 0x33A   => 220
  1492.                     ,0x33B   => 220, 0x33C   => 220, 0x347   => 220, 0x348   => 220, 0x349   => 220
  1493.                     ,0x34D   => 220, 0x34E   => 220, 0x353   => 220, 0x354   => 220, 0x355   => 220
  1494.                     ,0x356   => 220, 0x591   => 220, 0x596   => 220, 0x59B   => 220, 0x5A3   => 220
  1495.                     ,0x5A4   => 220, 0x5A5   => 220, 0x5A6   => 220, 0x5A7   => 220, 0x5AA   => 220
  1496.                     ,0x655   => 220, 0x656   => 220, 0x6E3   => 220, 0x6EA   => 220, 0x6ED   => 220
  1497.                     ,0x731   => 220, 0x734   => 220, 0x737   => 220, 0x738   => 220, 0x739   => 220
  1498.                     ,0x73B   => 220, 0x73C   => 220, 0x73E   => 220, 0x742   => 220, 0x744   => 220
  1499.                     ,0x746   => 220, 0x748   => 220, 0x952   => 220, 0xF18   => 220, 0xF19   => 220
  1500.                     ,0xF35   => 220, 0xF37   => 220, 0xFC6   => 220, 0x193B  => 220, 0x20E8  => 220
  1501.                     ,0x1D17B => 220, 0x1D17C => 220, 0x1D17D => 220, 0x1D17E => 220, 0x1D17F => 220
  1502.                     ,0x1D180 => 220, 0x1D181 => 220, 0x1D182 => 220, 0x1D18A => 220, 0x1D18B => 220
  1503.                     ,0x59A   => 222, 0x5AD   => 222, 0x1929  => 222, 0x302D  => 222, 0x302E  => 224
  1504.                     ,0x302F  => 224, 0x1D16D => 226, 0x5AE   => 228, 0x18A9  => 228, 0x302B  => 228
  1505.                     ,0x300   => 230, 0x301   => 230, 0x302   => 230, 0x303   => 230, 0x304   => 230
  1506.                     ,0x305   => 230, 0x306   => 230, 0x307   => 230, 0x308   => 230, 0x309   => 230
  1507.                     ,0x30A   => 230, 0x30B   => 230, 0x30C   => 230, 0x30D   => 230, 0x30E   => 230
  1508.                     ,0x30F   => 230, 0x310   => 230, 0x311   => 230, 0x312   => 230, 0x313   => 230
  1509.                     ,0x314   => 230, 0x33D   => 230, 0x33E   => 230, 0x33F   => 230, 0x340   => 230
  1510.                     ,0x341   => 230, 0x342   => 230, 0x343   => 230, 0x344   => 230, 0x346   => 230
  1511.                     ,0x34A   => 230, 0x34B   => 230, 0x34C   => 230, 0x350   => 230, 0x351   => 230
  1512.                     ,0x352   => 230, 0x357   => 230, 0x363   => 230, 0x364   => 230, 0x365   => 230
  1513.                     ,0x366   => 230, 0x367   => 230, 0x368   => 230, 0x369   => 230, 0x36A   => 230
  1514.                     ,0x36B   => 230, 0x36C   => 230, 0x36D   => 230, 0x36E   => 230, 0x36F   => 230
  1515.                     ,0x483   => 230, 0x484   => 230, 0x485   => 230, 0x486   => 230, 0x592   => 230
  1516.                     ,0x593   => 230, 0x594   => 230, 0x595   => 230, 0x597   => 230, 0x598   => 230
  1517.                     ,0x599   => 230, 0x59C   => 230, 0x59D   => 230, 0x59E   => 230, 0x59F   => 230
  1518.                     ,0x5A0   => 230, 0x5A1   => 230, 0x5A8   => 230, 0x5A9   => 230, 0x5AB   => 230
  1519.                     ,0x5AC   => 230, 0x5AF   => 230, 0x5C4   => 230, 0x610   => 230, 0x611   => 230
  1520.                     ,0x612   => 230, 0x613   => 230, 0x614   => 230, 0x615   => 230, 0x653   => 230
  1521.                     ,0x654   => 230, 0x657   => 230, 0x658   => 230, 0x6D6   => 230, 0x6D7   => 230
  1522.                     ,0x6D8   => 230, 0x6D9   => 230, 0x6DA   => 230, 0x6DB   => 230, 0x6DC   => 230
  1523.                     ,0x6DF   => 230, 0x6E0   => 230, 0x6E1   => 230, 0x6E2   => 230, 0x6E4   => 230
  1524.                     ,0x6E7   => 230, 0x6E8   => 230, 0x6EB   => 230, 0x6EC   => 230, 0x730   => 230
  1525.                     ,0x732   => 230, 0x733   => 230, 0x735   => 230, 0x736   => 230, 0x73A   => 230
  1526.                     ,0x73D   => 230, 0x73F   => 230, 0x740   => 230, 0x741   => 230, 0x743   => 230
  1527.                     ,0x745   => 230, 0x747   => 230, 0x749   => 230, 0x74A   => 230, 0x951   => 230
  1528.                     ,0x953   => 230, 0x954   => 230, 0xF82   => 230, 0xF83   => 230, 0xF86   => 230
  1529.                     ,0xF87   => 230, 0x170D  => 230, 0x193A  => 230, 0x20D0  => 230, 0x20D1  => 230
  1530.                     ,0x20D4  => 230, 0x20D5  => 230, 0x20D6  => 230, 0x20D7  => 230, 0x20DB  => 230
  1531.                     ,0x20DC  => 230, 0x20E1  => 230, 0x20E7  => 230, 0x20E9  => 230, 0xFE20  => 230
  1532.                     ,0xFE21  => 230, 0xFE22  => 230, 0xFE23  => 230, 0x1D185 => 230, 0x1D186 => 230
  1533.                     ,0x1D187 => 230, 0x1D189 => 230, 0x1D188 => 230, 0x1D1AA => 230, 0x1D1AB => 230
  1534.                     ,0x1D1AC => 230, 0x1D1AD => 230, 0x315   => 232, 0x31A   => 232, 0x302C  => 232
  1535.                     ,0x35F   => 233, 0x362   => 233, 0x35D   => 234, 0x35E   => 234, 0x360   => 234
  1536.                     ,0x361   => 234, 0x345   => 240
  1537.                     )
  1538.             );
  1539. }
  1540. ?>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!